diff --git a/.gitignore b/.gitignore index 3a5acef9f3..9e054bad1b 100644 --- a/.gitignore +++ b/.gitignore @@ -35,6 +35,7 @@ profile.cov .idea # dashboard +/dashboard/assets/flow-typed /dashboard/assets/node_modules /dashboard/assets/stats.json /dashboard/assets/public/bundle.js diff --git a/.travis.yml b/.travis.yml index cc1b185fce..bc296bf2f1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -87,13 +87,13 @@ matrix: - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-arm-linux-gnueabihf libc6-dev-armhf-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross - sudo ln -s /usr/include/asm-generic /usr/include/asm - - GOARM=5 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm + - GOARM=5 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc - GOARM=5 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - GOARM=6 CC=arm-linux-gnueabi-gcc go run build/ci.go install -arch arm + - GOARM=6 go run build/ci.go install -arch arm -cc arm-linux-gnueabi-gcc - GOARM=6 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - GOARM=7 CC=arm-linux-gnueabihf-gcc go run build/ci.go install -arch arm + - GOARM=7 go run build/ci.go install -arch arm -cc arm-linux-gnueabihf-gcc - GOARM=7 go run build/ci.go archive -arch arm -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds - - CC=aarch64-linux-gnu-gcc go run build/ci.go install -arch arm64 + - go run build/ci.go install -arch arm64 -cc aarch64-linux-gnu-gcc - go run build/ci.go archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds # This builder does the Linux Azure MIPS xgo uploads diff --git a/accounts/abi/abi.go b/accounts/abi/abi.go index 205dc300b0..cbcf4ca924 100644 --- a/accounts/abi/abi.go +++ b/accounts/abi/abi.go @@ -17,6 +17,7 @@ package abi import ( + "bytes" "encoding/json" "fmt" "io" @@ -50,51 +51,47 @@ func JSON(reader io.Reader) (ABI, error) { // methods string signature. (signature = baz(uint32,string32)) func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) { // Fetch the ABI of the requested method - var method Method - if name == "" { - method = abi.Constructor - } else { - m, exist := abi.Methods[name] - if !exist { - return nil, fmt.Errorf("method '%s' not found", name) + // constructor + arguments, err := abi.Constructor.Inputs.Pack(args...) + if err != nil { + return nil, err } - method = m + return arguments, nil + } - arguments, err := method.pack(args...) + method, exist := abi.Methods[name] + if !exist { + return nil, fmt.Errorf("method '%s' not found", name) + } + + arguments, err := method.Inputs.Pack(args...) if err != nil { return nil, err } // Pack up the method ID too if not a constructor and return - if name == "" { - return arguments, nil - } return append(method.Id(), arguments...), nil } // Unpack output in v according to the abi specification func (abi ABI) Unpack(v interface{}, name string, output []byte) (err error) { - if err = bytesAreProper(output); err != nil { - return err + if len(output) == 0 { + return fmt.Errorf("abi: unmarshalling empty output") } // since there can't be naming collisions with contracts and events, // we need to decide whether we're calling a method or an event - var unpack unpacker if method, ok := abi.Methods[name]; ok { - unpack = method + if len(output)%32 != 0 { + return fmt.Errorf("abi: improperly formatted output") + } + return method.Outputs.Unpack(v, output) } else if event, ok := abi.Events[name]; ok { - unpack = event - } else { - return fmt.Errorf("abi: could not locate named method or event.") + return event.Inputs.Unpack(v, output) } - - // requires a struct to unpack into for a tuple return... - if unpack.isTupleReturn() { - return unpack.tupleUnpack(v, output) - } - return unpack.singleUnpack(v, output) + return fmt.Errorf("abi: could not locate named method or event") } +// UnmarshalJSON implements json.Unmarshaler interface func (abi *ABI) UnmarshalJSON(data []byte) error { var fields []struct { Type string @@ -137,3 +134,14 @@ func (abi *ABI) UnmarshalJSON(data []byte) error { return nil } + +// MethodById looks up a method by the 4-byte id +// returns nil if none found +func (abi *ABI) MethodById(sigdata []byte) *Method { + for _, method := range abi.Methods { + if bytes.Equal(method.Id(), sigdata[:4]) { + return &method + } + } + return nil +} diff --git a/accounts/abi/abi_test.go b/accounts/abi/abi_test.go index 79c4d4a163..2d43b631c2 100644 --- a/accounts/abi/abi_test.go +++ b/accounts/abi/abi_test.go @@ -18,13 +18,15 @@ package abi import ( "bytes" + "encoding/hex" "fmt" "log" "math/big" - "reflect" "strings" "testing" + "reflect" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" ) @@ -74,9 +76,24 @@ func TestReader(t *testing.T) { } // deep equal fails for some reason - t.Skip() - if !reflect.DeepEqual(abi, exp) { - t.Errorf("\nabi: %v\ndoes not match exp: %v", abi, exp) + for name, expM := range exp.Methods { + gotM, exist := abi.Methods[name] + if !exist { + t.Errorf("Missing expected method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } + } + + for name, gotM := range abi.Methods { + expM, exist := exp.Methods[name] + if !exist { + t.Errorf("Found extra method %v", name) + } + if !reflect.DeepEqual(gotM, expM) { + t.Errorf("\nGot abi method: \n%v\ndoes not match expected method\n%v", gotM, expM) + } } } @@ -348,6 +365,188 @@ func TestInputVariableInputLength(t *testing.T) { } } +func TestInputFixedArrayAndVariableInputLength(t *testing.T) { + const definition = `[ + { "type" : "function", "name" : "fixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] }, + { "type" : "function", "name" : "fixedArrBytes", "constant" : true, "inputs" : [ { "name" : "str", "type" : "bytes" }, { "name" : "fixedArr", "type" : "uint256[2]" } ] }, + { "type" : "function", "name" : "mixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr", "type": "uint256[2]" }, { "name" : "dynArr", "type": "uint256[]" } ] }, + { "type" : "function", "name" : "doubleFixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "fixedArr2", "type": "uint256[3]" } ] }, + { "type" : "function", "name" : "multipleMixedArrStr", "constant" : true, "inputs" : [ { "name" : "str", "type" : "string" }, { "name" : "fixedArr1", "type": "uint256[2]" }, { "name" : "dynArr", "type" : "uint256[]" }, { "name" : "fixedArr2", "type" : "uint256[3]" } ] } + ]` + + abi, err := JSON(strings.NewReader(definition)) + if err != nil { + t.Error(err) + } + + // test string, fixed array uint256[2] + strin := "hello world" + arrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedArrStrPack, err := abi.Pack("fixedArrStr", strin, arrin) + if err != nil { + t.Error(err) + } + + // generate expected output + offset := make([]byte, 32) + offset[31] = 96 + length := make([]byte, 32) + length[31] = byte(len(strin)) + strvalue := common.RightPadBytes([]byte(strin), 32) + arrinvalue1 := common.LeftPadBytes(arrin[0].Bytes(), 32) + arrinvalue2 := common.LeftPadBytes(arrin[1].Bytes(), 32) + exp := append(offset, arrinvalue1...) + exp = append(exp, arrinvalue2...) + exp = append(exp, append(length, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + fixedArrStrPack = fixedArrStrPack[4:] + if !bytes.Equal(fixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, fixedArrStrPack) + } + + // test byte array, fixed array uint256[2] + bytesin := []byte(strin) + arrin = [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedArrBytesPack, err := abi.Pack("fixedArrBytes", bytesin, arrin) + if err != nil { + t.Error(err) + } + + // generate expected output + offset = make([]byte, 32) + offset[31] = 96 + length = make([]byte, 32) + length[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + arrinvalue1 = common.LeftPadBytes(arrin[0].Bytes(), 32) + arrinvalue2 = common.LeftPadBytes(arrin[1].Bytes(), 32) + exp = append(offset, arrinvalue1...) + exp = append(exp, arrinvalue2...) + exp = append(exp, append(length, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + fixedArrBytesPack = fixedArrBytesPack[4:] + if !bytes.Equal(fixedArrBytesPack, exp) { + t.Errorf("expected %x, got %x\n", exp, fixedArrBytesPack) + } + + // test string, fixed array uint256[2], dynamic array uint256[] + strin = "hello world" + fixedarrin := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + dynarrin := []*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + mixedArrStrPack, err := abi.Pack("mixedArrStr", strin, fixedarrin, dynarrin) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset := make([]byte, 32) + stroffset[31] = 128 + strlength := make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrinvalue1 := common.LeftPadBytes(fixedarrin[0].Bytes(), 32) + fixedarrinvalue2 := common.LeftPadBytes(fixedarrin[1].Bytes(), 32) + dynarroffset := make([]byte, 32) + dynarroffset[31] = byte(160 + ((len(strin)/32)+1)*32) + dynarrlength := make([]byte, 32) + dynarrlength[31] = byte(len(dynarrin)) + dynarrinvalue1 := common.LeftPadBytes(dynarrin[0].Bytes(), 32) + dynarrinvalue2 := common.LeftPadBytes(dynarrin[1].Bytes(), 32) + dynarrinvalue3 := common.LeftPadBytes(dynarrin[2].Bytes(), 32) + exp = append(stroffset, fixedarrinvalue1...) + exp = append(exp, fixedarrinvalue2...) + exp = append(exp, dynarroffset...) + exp = append(exp, append(strlength, strvalue...)...) + dynarrarg := append(dynarrlength, dynarrinvalue1...) + dynarrarg = append(dynarrarg, dynarrinvalue2...) + dynarrarg = append(dynarrarg, dynarrinvalue3...) + exp = append(exp, dynarrarg...) + + // ignore first 4 bytes of the output. This is the function identifier + mixedArrStrPack = mixedArrStrPack[4:] + if !bytes.Equal(mixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, mixedArrStrPack) + } + + // test string, fixed array uint256[2], fixed array uint256[3] + strin = "hello world" + fixedarrin1 := [2]*big.Int{big.NewInt(1), big.NewInt(2)} + fixedarrin2 := [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + doubleFixedArrStrPack, err := abi.Pack("doubleFixedArrStr", strin, fixedarrin1, fixedarrin2) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset = make([]byte, 32) + stroffset[31] = 192 + strlength = make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrin1value1 := common.LeftPadBytes(fixedarrin1[0].Bytes(), 32) + fixedarrin1value2 := common.LeftPadBytes(fixedarrin1[1].Bytes(), 32) + fixedarrin2value1 := common.LeftPadBytes(fixedarrin2[0].Bytes(), 32) + fixedarrin2value2 := common.LeftPadBytes(fixedarrin2[1].Bytes(), 32) + fixedarrin2value3 := common.LeftPadBytes(fixedarrin2[2].Bytes(), 32) + exp = append(stroffset, fixedarrin1value1...) + exp = append(exp, fixedarrin1value2...) + exp = append(exp, fixedarrin2value1...) + exp = append(exp, fixedarrin2value2...) + exp = append(exp, fixedarrin2value3...) + exp = append(exp, append(strlength, strvalue...)...) + + // ignore first 4 bytes of the output. This is the function identifier + doubleFixedArrStrPack = doubleFixedArrStrPack[4:] + if !bytes.Equal(doubleFixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, doubleFixedArrStrPack) + } + + // test string, fixed array uint256[2], dynamic array uint256[], fixed array uint256[3] + strin = "hello world" + fixedarrin1 = [2]*big.Int{big.NewInt(1), big.NewInt(2)} + dynarrin = []*big.Int{big.NewInt(1), big.NewInt(2)} + fixedarrin2 = [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)} + multipleMixedArrStrPack, err := abi.Pack("multipleMixedArrStr", strin, fixedarrin1, dynarrin, fixedarrin2) + if err != nil { + t.Error(err) + } + + // generate expected output + stroffset = make([]byte, 32) + stroffset[31] = 224 + strlength = make([]byte, 32) + strlength[31] = byte(len(strin)) + strvalue = common.RightPadBytes([]byte(strin), 32) + fixedarrin1value1 = common.LeftPadBytes(fixedarrin1[0].Bytes(), 32) + fixedarrin1value2 = common.LeftPadBytes(fixedarrin1[1].Bytes(), 32) + dynarroffset = U256(big.NewInt(int64(256 + ((len(strin)/32)+1)*32))) + dynarrlength = make([]byte, 32) + dynarrlength[31] = byte(len(dynarrin)) + dynarrinvalue1 = common.LeftPadBytes(dynarrin[0].Bytes(), 32) + dynarrinvalue2 = common.LeftPadBytes(dynarrin[1].Bytes(), 32) + fixedarrin2value1 = common.LeftPadBytes(fixedarrin2[0].Bytes(), 32) + fixedarrin2value2 = common.LeftPadBytes(fixedarrin2[1].Bytes(), 32) + fixedarrin2value3 = common.LeftPadBytes(fixedarrin2[2].Bytes(), 32) + exp = append(stroffset, fixedarrin1value1...) + exp = append(exp, fixedarrin1value2...) + exp = append(exp, dynarroffset...) + exp = append(exp, fixedarrin2value1...) + exp = append(exp, fixedarrin2value2...) + exp = append(exp, fixedarrin2value3...) + exp = append(exp, append(strlength, strvalue...)...) + dynarrarg = append(dynarrlength, dynarrinvalue1...) + dynarrarg = append(dynarrarg, dynarrinvalue2...) + exp = append(exp, dynarrarg...) + + // ignore first 4 bytes of the output. This is the function identifier + multipleMixedArrStrPack = multipleMixedArrStrPack[4:] + if !bytes.Equal(multipleMixedArrStrPack, exp) { + t.Errorf("expected %x, got %x\n", exp, multipleMixedArrStrPack) + } +} + func TestDefaultFunctionParsing(t *testing.T) { const definition = `[{ "name" : "balance" }]` @@ -418,3 +617,82 @@ func TestBareEvents(t *testing.T) { } } } + +// TestUnpackEvent is based on this contract: +// contract T { +// event received(address sender, uint amount, bytes memo); +// function receive(bytes memo) external payable { +// received(msg.sender, msg.value, memo); +// } +// } +// When receive("X") is called with sender 0x00... and value 1, it produces this tx receipt: +// receipt{status=1 cgas=23949 bloom=00000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000040200000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 logs=[log: b6818c8064f645cd82d99b59a1a267d6d61117ef [75fd880d39c1daf53b6547ab6cb59451fc6452d27caa90e5b6649dd8293b9eed] 000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158 9ae378b6d4409eada347a5dc0c180f186cb62dc68fcc0f043425eb917335aa28 0 95d429d309bb9d753954195fe2d69bd140b4ae731b9b5b605c34323de162cf00 0]} +func TestUnpackEvent(t *testing.T) { + const abiJSON = `[{"constant":false,"inputs":[{"name":"memo","type":"bytes"}],"name":"receive","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]` + abi, err := JSON(strings.NewReader(abiJSON)) + if err != nil { + t.Fatal(err) + } + + const hexdata = `000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158` + data, err := hex.DecodeString(hexdata) + if err != nil { + t.Fatal(err) + } + if len(data)%32 == 0 { + t.Errorf("len(data) is %d, want a non-multiple of 32", len(data)) + } + + type ReceivedEvent struct { + Address common.Address + Amount *big.Int + Memo []byte + } + var ev ReceivedEvent + + err = abi.Unpack(&ev, "received", data) + if err != nil { + t.Error(err) + } else { + t.Logf("len(data): %d; received event: %+v", len(data), ev) + } +} + +func TestABI_MethodById(t *testing.T) { + const abiJSON = `[ + {"type":"function","name":"receive","constant":false,"inputs":[{"name":"memo","type":"bytes"}],"outputs":[],"payable":true,"stateMutability":"payable"}, + {"type":"event","name":"received","anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}]}, + {"type":"function","name":"fixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"fixedArrBytes","constant":true,"inputs":[{"name":"str","type":"bytes"},{"name":"fixedArr","type":"uint256[2]"}]}, + {"type":"function","name":"mixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"}]}, + {"type":"function","name":"doubleFixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"multipleMixedArrStr","constant":true,"inputs":[{"name":"str","type":"string"},{"name":"fixedArr1","type":"uint256[2]"},{"name":"dynArr","type":"uint256[]"},{"name":"fixedArr2","type":"uint256[3]"}]}, + {"type":"function","name":"balance","constant":true}, + {"type":"function","name":"send","constant":false,"inputs":[{"name":"amount","type":"uint256"}]}, + {"type":"function","name":"test","constant":false,"inputs":[{"name":"number","type":"uint32"}]}, + {"type":"function","name":"string","constant":false,"inputs":[{"name":"inputs","type":"string"}]}, + {"type":"function","name":"bool","constant":false,"inputs":[{"name":"inputs","type":"bool"}]}, + {"type":"function","name":"address","constant":false,"inputs":[{"name":"inputs","type":"address"}]}, + {"type":"function","name":"uint64[2]","constant":false,"inputs":[{"name":"inputs","type":"uint64[2]"}]}, + {"type":"function","name":"uint64[]","constant":false,"inputs":[{"name":"inputs","type":"uint64[]"}]}, + {"type":"function","name":"foo","constant":false,"inputs":[{"name":"inputs","type":"uint32"}]}, + {"type":"function","name":"bar","constant":false,"inputs":[{"name":"inputs","type":"uint32"},{"name":"string","type":"uint16"}]}, + {"type":"function","name":"_slice","constant":false,"inputs":[{"name":"inputs","type":"uint32[2]"}]}, + {"type":"function","name":"__slice256","constant":false,"inputs":[{"name":"inputs","type":"uint256[2]"}]}, + {"type":"function","name":"sliceAddress","constant":false,"inputs":[{"name":"inputs","type":"address[]"}]}, + {"type":"function","name":"sliceMultiAddress","constant":false,"inputs":[{"name":"a","type":"address[]"},{"name":"b","type":"address[]"}]} + ] +` + abi, err := JSON(strings.NewReader(abiJSON)) + if err != nil { + t.Fatal(err) + } + for name, m := range abi.Methods { + a := fmt.Sprintf("%v", m) + b := fmt.Sprintf("%v", abi.MethodById(m.Id())) + if a != b { + t.Errorf("Method %v (id %v) not 'findable' by id in ABI", name, common.ToHex(m.Id())) + } + } + +} diff --git a/accounts/abi/argument.go b/accounts/abi/argument.go index 4691318ce7..04ca6150ad 100644 --- a/accounts/abi/argument.go +++ b/accounts/abi/argument.go @@ -19,6 +19,8 @@ package abi import ( "encoding/json" "fmt" + "reflect" + "strings" ) // Argument holds the name of the argument and the corresponding type. @@ -29,7 +31,10 @@ type Argument struct { Indexed bool // indexed is only used by events } -func (a *Argument) UnmarshalJSON(data []byte) error { +type Arguments []Argument + +// UnmarshalJSON implements json.Unmarshaler interface +func (argument *Argument) UnmarshalJSON(data []byte) error { var extarg struct { Name string Type string @@ -40,12 +45,206 @@ func (a *Argument) UnmarshalJSON(data []byte) error { return fmt.Errorf("argument json err: %v", err) } - a.Type, err = NewType(extarg.Type) + argument.Type, err = NewType(extarg.Type) if err != nil { return err } - a.Name = extarg.Name - a.Indexed = extarg.Indexed + argument.Name = extarg.Name + argument.Indexed = extarg.Indexed return nil } + +// LengthNonIndexed returns the number of arguments when not counting 'indexed' ones. Only events +// can ever have 'indexed' arguments, it should always be false on arguments for method input/output +func (arguments Arguments) LengthNonIndexed() int { + out := 0 + for _, arg := range arguments { + if !arg.Indexed { + out++ + } + } + return out +} + +// isTuple returns true for non-atomic constructs, like (uint,uint) or uint[] +func (arguments Arguments) isTuple() bool { + return len(arguments) > 1 +} + +// Unpack performs the operation hexdata -> Go format +func (arguments Arguments) Unpack(v interface{}, data []byte) error { + if arguments.isTuple() { + return arguments.unpackTuple(v, data) + } + return arguments.unpackAtomic(v, data) +} + +func (arguments Arguments) unpackTuple(v interface{}, output []byte) error { + // make sure the passed value is arguments pointer + valueOf := reflect.ValueOf(v) + if reflect.Ptr != valueOf.Kind() { + return fmt.Errorf("abi: Unpack(non-pointer %T)", v) + } + + var ( + value = valueOf.Elem() + typ = value.Type() + kind = value.Kind() + ) + + if err := requireUnpackKind(value, typ, kind, arguments); err != nil { + return err + } + // If the output interface is a struct, make sure names don't collide + if kind == reflect.Struct { + exists := make(map[string]bool) + for _, arg := range arguments { + field := capitalise(arg.Name) + if field == "" { + return fmt.Errorf("abi: purely underscored output cannot unpack to struct") + } + if exists[field] { + return fmt.Errorf("abi: multiple outputs mapping to the same struct field '%s'", field) + } + exists[field] = true + } + } + // `i` counts the nonindexed arguments. + // `j` counts the number of complex types. + // both `i` and `j` are used to to correctly compute `data` offset. + + i, j := -1, 0 + for _, arg := range arguments { + + if arg.Indexed { + // can't read, continue + continue + } + i++ + marshalledValue, err := toGoType((i+j)*32, arg.Type, output) + if err != nil { + return err + } + + if arg.Type.T == ArrayTy { + // combined index ('i' + 'j') need to be adjusted only by size of array, thus + // we need to decrement 'j' because 'i' was incremented + j += arg.Type.Size - 1 + } + + reflectValue := reflect.ValueOf(marshalledValue) + + switch kind { + case reflect.Struct: + name := capitalise(arg.Name) + for j := 0; j < typ.NumField(); j++ { + // TODO read tags: `abi:"fieldName"` + if typ.Field(j).Name == name { + if err := set(value.Field(j), reflectValue, arg); err != nil { + return err + } + } + } + case reflect.Slice, reflect.Array: + if value.Len() < i { + return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(arguments), value.Len()) + } + v := value.Index(i) + if err := requireAssignable(v, reflectValue); err != nil { + return err + } + + if err := set(v.Elem(), reflectValue, arg); err != nil { + return err + } + default: + return fmt.Errorf("abi:[2] cannot unmarshal tuple in to %v", typ) + } + } + return nil +} + +// unpackAtomic unpacks ( hexdata -> go ) a single value +func (arguments Arguments) unpackAtomic(v interface{}, output []byte) error { + // make sure the passed value is arguments pointer + valueOf := reflect.ValueOf(v) + if reflect.Ptr != valueOf.Kind() { + return fmt.Errorf("abi: Unpack(non-pointer %T)", v) + } + arg := arguments[0] + if arg.Indexed { + return fmt.Errorf("abi: attempting to unpack indexed variable into element.") + } + + value := valueOf.Elem() + + marshalledValue, err := toGoType(0, arg.Type, output) + if err != nil { + return err + } + return set(value, reflect.ValueOf(marshalledValue), arg) +} + +// Unpack performs the operation Go format -> Hexdata +func (arguments Arguments) Pack(args ...interface{}) ([]byte, error) { + // Make sure arguments match up and pack them + abiArgs := arguments + if len(args) != len(abiArgs) { + return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(abiArgs)) + } + + // variable input is the output appended at the end of packed + // output. This is used for strings and bytes types input. + var variableInput []byte + + // input offset is the bytes offset for packed output + inputOffset := 0 + for _, abiArg := range abiArgs { + if abiArg.Type.T == ArrayTy { + inputOffset += 32 * abiArg.Type.Size + } else { + inputOffset += 32 + } + } + + var ret []byte + for i, a := range args { + input := abiArgs[i] + // pack the input + packed, err := input.Type.pack(reflect.ValueOf(a)) + if err != nil { + return nil, err + } + + // check for a slice type (string, bytes, slice) + if input.Type.requiresLengthPrefix() { + // calculate the offset + offset := inputOffset + len(variableInput) + // set the offset + ret = append(ret, packNum(reflect.ValueOf(offset))...) + // Append the packed output to the variable input. The variable input + // will be appended at the end of the input. + variableInput = append(variableInput, packed...) + } else { + // append the packed value to the input + ret = append(ret, packed...) + } + } + // append the variable input at the end of the packed input + ret = append(ret, variableInput...) + + return ret, nil +} + +// capitalise makes the first character of a string upper case, also removing any +// prefixing underscores from the variable names. +func capitalise(input string) string { + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } + return strings.ToUpper(input[:1]) + input[1:] +} diff --git a/accounts/abi/bind/backend.go b/accounts/abi/bind/backend.go index 25b61928e1..a7ca7bfc00 100644 --- a/accounts/abi/bind/backend.go +++ b/accounts/abi/bind/backend.go @@ -85,7 +85,7 @@ type ContractTransactor interface { // There is no guarantee that this is the true gas limit requirement as other // transactions may be added or removed by miners, but it should provide a basis // for setting a reasonable default. - EstimateGas(ctx context.Context, call ethereum.CallMsg) (usedGas *big.Int, err error) + EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) // SendTransaction injects the transaction into the pending pool for execution. SendTransaction(ctx context.Context, tx *types.Transaction) error } diff --git a/accounts/abi/bind/backends/simulated.go b/accounts/abi/bind/backends/simulated.go index 09288d401e..81c32e4211 100644 --- a/accounts/abi/bind/backends/simulated.go +++ b/accounts/abi/bind/backends/simulated.go @@ -89,7 +89,7 @@ func (b *SimulatedBackend) Rollback() { } func (b *SimulatedBackend) rollback() { - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {}) + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(int, *core.BlockGen) {}) b.pendingBlock = blocks[0] b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) } @@ -200,7 +200,7 @@ func (b *SimulatedBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error // EstimateGas executes the requested code against the currently pending block/state and // returns the used amount of gas. -func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (*big.Int, error) { +func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMsg) (uint64, error) { b.mu.Lock() defer b.mu.Unlock() @@ -210,16 +210,16 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs hi uint64 cap uint64 ) - if call.Gas != nil && call.Gas.Uint64() >= params.TxGas { - hi = call.Gas.Uint64() + if call.Gas >= params.TxGas { + hi = call.Gas } else { - hi = b.pendingBlock.GasLimit().Uint64() + hi = b.pendingBlock.GasLimit() } cap = hi // Create a helper to check if a gas allowance results in an executable transaction executable := func(gas uint64) bool { - call.Gas = new(big.Int).SetUint64(gas) + call.Gas = gas snapshot := b.pendingState.Snapshot() _, _, failed, err := b.callContract(ctx, call, b.pendingBlock, b.pendingState) @@ -242,21 +242,21 @@ func (b *SimulatedBackend) EstimateGas(ctx context.Context, call ethereum.CallMs // Reject the transaction as invalid if it still fails at the highest allowance if hi == cap { if !executable(hi) { - return nil, errGasEstimationFailed + return 0, errGasEstimationFailed } } - return new(big.Int).SetUint64(hi), nil + return hi, nil } // callContract implemens common code between normal and pending contract calls. // state is modified during execution, make sure to copy it if necessary. -func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, statedb *state.StateDB) ([]byte, *big.Int, bool, error) { +func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallMsg, block *types.Block, statedb *state.StateDB) ([]byte, uint64, bool, error) { // Ensure message is initialized properly. if call.GasPrice == nil { call.GasPrice = big.NewInt(1) } - if call.Gas == nil || call.Gas.Sign() == 0 { - call.Gas = big.NewInt(50000000) + if call.Gas == 0 { + call.Gas = 50000000 } if call.Value == nil { call.Value = new(big.Int) @@ -271,9 +271,9 @@ func (b *SimulatedBackend) callContract(ctx context.Context, call ethereum.CallM // Create a new environment which holds all relevant information // about the transaction and calling mechanisms. vmenv := vm.NewEVM(evmContext, statedb, b.config, vm.Config{}) - gaspool := new(core.GasPool).AddGas(math.MaxBig256) - ret, gasUsed, _, failed, err := core.NewStateTransition(vmenv, msg, gaspool).TransitionDb() - return ret, gasUsed, failed, err + gaspool := new(core.GasPool).AddGas(math.MaxUint64) + + return core.NewStateTransition(vmenv, msg, gaspool).TransitionDb() } // SendTransaction updates the pending block to include the given transaction. @@ -291,7 +291,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa panic(fmt.Errorf("invalid transaction nonce: got %d, want %d", tx.Nonce(), nonce)) } - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { block.AddTx(tx) } @@ -306,7 +306,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa func (b *SimulatedBackend) AdjustTime(adjustment time.Duration) error { b.mu.Lock() defer b.mu.Unlock() - blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(number int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), ethash.NewFaker(), b.database, 1, func(number int, block *core.BlockGen) { for _, tx := range b.pendingBlock.Transactions() { block.AddTx(tx) } @@ -328,6 +328,6 @@ func (m callmsg) Nonce() uint64 { return 0 } func (m callmsg) CheckNonce() bool { return false } func (m callmsg) To() *common.Address { return m.CallMsg.To } func (m callmsg) GasPrice() *big.Int { return m.CallMsg.GasPrice } -func (m callmsg) Gas() *big.Int { return m.CallMsg.Gas } +func (m callmsg) Gas() uint64 { return m.CallMsg.Gas } func (m callmsg) Value() *big.Int { return m.CallMsg.Value } func (m callmsg) Data() []byte { return m.CallMsg.Data } diff --git a/accounts/abi/bind/base.go b/accounts/abi/bind/base.go index b40bd65e80..2bd683f22f 100644 --- a/accounts/abi/bind/base.go +++ b/accounts/abi/bind/base.go @@ -50,7 +50,7 @@ type TransactOpts struct { Value *big.Int // Funds to transfer along along the transaction (nil = 0 = no funds) GasPrice *big.Int // Gas price to use for the transaction execution (nil = gas price oracle) - GasLimit *big.Int // Gas limit to set for the transaction execution (nil = estimate + 10%) + GasLimit uint64 // Gas limit to set for the transaction execution (0 = estimate) Context context.Context // Network context to support cancellation and timeouts (nil = no timeout) } @@ -189,7 +189,7 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i } } gasLimit := opts.GasLimit - if gasLimit == nil { + if gasLimit == 0 { // Gas estimation cannot succeed without code for method invocations if contract != nil { if code, err := c.transactor.PendingCodeAt(ensureContext(opts.Context), c.address); err != nil { diff --git a/accounts/abi/bind/bind.go b/accounts/abi/bind/bind.go index 4dce79b779..8175e3cb9b 100644 --- a/accounts/abi/bind/bind.go +++ b/accounts/abi/bind/bind.go @@ -304,8 +304,15 @@ var methodNormalizer = map[Lang]func(string) string{ LangJava: decapitalise, } -// capitalise makes the first character of a string upper case. +// capitalise makes the first character of a string upper case, also removing any +// prefixing underscores from the variable names. func capitalise(input string) string { + for len(input) > 0 && input[0] == '_' { + input = input[1:] + } + if len(input) == 0 { + return "" + } return strings.ToUpper(input[:1]) + input[1:] } @@ -315,15 +322,24 @@ func decapitalise(input string) string { } // structured checks whether a method has enough information to return a proper -// Go struct ot if flat returns are needed. +// Go struct or if flat returns are needed. func structured(method abi.Method) bool { if len(method.Outputs) < 2 { return false } + exists := make(map[string]bool) for _, out := range method.Outputs { + // If the name is anonymous, we can't organize into a struct if out.Name == "" { return false } + // If the field name is empty when normalized or collides (var, Var, _var, _Var), + // we can't organize into a struct + field := capitalise(out.Name) + if field == "" || exists[field] { + return false + } + exists[field] = true } return true } diff --git a/accounts/abi/bind/bind_test.go b/accounts/abi/bind/bind_test.go index 43ed53b922..b56477e0c7 100644 --- a/accounts/abi/bind/bind_test.go +++ b/accounts/abi/bind/bind_test.go @@ -126,6 +126,7 @@ var bindTests = []struct { {"type":"function","name":"namedOutput","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"}]}, {"type":"function","name":"anonOutput","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"}]}, {"type":"function","name":"namedOutputs","constant":true,"inputs":[],"outputs":[{"name":"str1","type":"string"},{"name":"str2","type":"string"}]}, + {"type":"function","name":"collidingOutputs","constant":true,"inputs":[],"outputs":[{"name":"str","type":"string"},{"name":"Str","type":"string"}]}, {"type":"function","name":"anonOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"","type":"string"}]}, {"type":"function","name":"mixedOutputs","constant":true,"inputs":[],"outputs":[{"name":"","type":"string"},{"name":"str","type":"string"}]} ] @@ -140,6 +141,7 @@ var bindTests = []struct { str1, err = b.NamedOutput(nil) str1, err = b.AnonOutput(nil) res, _ := b.NamedOutputs(nil) + str1, str2, err = b.CollidingOutputs(nil) str1, str2, err = b.AnonOutputs(nil) str1, str2, err = b.MixedOutputs(nil) @@ -397,7 +399,6 @@ var bindTests = []struct { sim.Commit() // Set the field with automatic estimation and check that it succeeds - auth.GasLimit = nil if _, err := limiter.SetField(auth, "automatic"); err != nil { t.Fatalf("Failed to call automatically gased transaction: %v", err) } @@ -447,6 +448,66 @@ var bindTests = []struct { } `, }, + { + `Underscorer`, + ` + contract Underscorer { + function UnderscoredOutput() constant returns (int _int, string _string) { + return (314, "pi"); + } + function LowerLowerCollision() constant returns (int _res, int res) { + return (1, 2); + } + function LowerUpperCollision() constant returns (int _res, int Res) { + return (1, 2); + } + function UpperLowerCollision() constant returns (int _Res, int res) { + return (1, 2); + } + function UpperUpperCollision() constant returns (int _Res, int Res) { + return (1, 2); + } + function PurelyUnderscoredOutput() constant returns (int _, int res) { + return (1, 2); + } + function AllPurelyUnderscoredOutput() constant returns (int _, int __) { + return (1, 2); + } + } + `, `6060604052341561000f57600080fd5b6103498061001e6000396000f300606060405260043610610083576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806303a592131461008857806367e6633d146100b85780639df484851461014d578063af7486ab1461017d578063b564b34d146101ad578063e02ab24d146101dd578063e409ca451461020d575b600080fd5b341561009357600080fd5b61009b61023d565b604051808381526020018281526020019250505060405180910390f35b34156100c357600080fd5b6100cb610252565b6040518083815260200180602001828103825283818151815260200191508051906020019080838360005b838110156101115780820151818401526020810190506100f6565b50505050905090810190601f16801561013e5780820380516001836020036101000a031916815260200191505b50935050505060405180910390f35b341561015857600080fd5b6101606102a0565b604051808381526020018281526020019250505060405180910390f35b341561018857600080fd5b6101906102b5565b604051808381526020018281526020019250505060405180910390f35b34156101b857600080fd5b6101c06102ca565b604051808381526020018281526020019250505060405180910390f35b34156101e857600080fd5b6101f06102df565b604051808381526020018281526020019250505060405180910390f35b341561021857600080fd5b6102206102f4565b604051808381526020018281526020019250505060405180910390f35b60008060016002819150809050915091509091565b600061025c610309565b61013a8090506040805190810160405280600281526020017f7069000000000000000000000000000000000000000000000000000000000000815250915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b60008060016002819150809050915091509091565b6020604051908101604052806000815250905600a165627a7a72305820c11dcfa136fc7d182ee4d34f0b12d988496228f7e2d02d2b5376d996ca1743d00029`, + `[{"constant":true,"inputs":[],"name":"LowerUpperCollision","outputs":[{"name":"_res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UnderscoredOutput","outputs":[{"name":"_int","type":"int256"},{"name":"_string","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperLowerCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"AllPurelyUnderscoredOutput","outputs":[{"name":"_","type":"int256"},{"name":"__","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"UpperUpperCollision","outputs":[{"name":"_Res","type":"int256"},{"name":"Res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"LowerLowerCollision","outputs":[{"name":"_res","type":"int256"},{"name":"res","type":"int256"}],"payable":false,"stateMutability":"view","type":"function"}]`, + ` + // Generate a new random account and a funded simulator + key, _ := crypto.GenerateKey() + auth := bind.NewKeyedTransactor(key) + sim := backends.NewSimulatedBackend(core.GenesisAlloc{auth.From: {Balance: big.NewInt(10000000000)}}) + + // Deploy a underscorer tester contract and execute a structured call on it + _, _, underscorer, err := DeployUnderscorer(auth, sim) + if err != nil { + t.Fatalf("Failed to deploy underscorer contract: %v", err) + } + sim.Commit() + + // Verify that underscored return values correctly parse into structs + if res, err := underscorer.UnderscoredOutput(nil); err != nil { + t.Errorf("Failed to call constant function: %v", err) + } else if res.Int.Cmp(big.NewInt(314)) != 0 || res.String != "pi" { + t.Errorf("Invalid result, want: {314, \"pi\"}, got: %+v", res) + } + // Verify that underscored and non-underscored name collisions force tuple outputs + var a, b *big.Int + + a, b, _ = underscorer.LowerLowerCollision(nil) + a, b, _ = underscorer.LowerUpperCollision(nil) + a, b, _ = underscorer.UpperLowerCollision(nil) + a, b, _ = underscorer.UpperUpperCollision(nil) + a, b, _ = underscorer.PurelyUnderscoredOutput(nil) + a, b, _ = underscorer.AllPurelyUnderscoredOutput(nil) + + fmt.Println(a, b, err) + `, + }, } // Tests that packages generated by the binder can be successfully compiled and diff --git a/accounts/abi/bind/util_test.go b/accounts/abi/bind/util_test.go index d24aa721e5..49e6dc813a 100644 --- a/accounts/abi/bind/util_test.go +++ b/accounts/abi/bind/util_test.go @@ -34,18 +34,18 @@ var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d var waitDeployedTests = map[string]struct { code string - gas *big.Int + gas uint64 wantAddress common.Address wantErr error }{ "successful deploy": { code: `6060604052600a8060106000396000f360606040526008565b00`, - gas: big.NewInt(3000000), + gas: 3000000, wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), }, "empty code": { code: ``, - gas: big.NewInt(300000), + gas: 300000, wantErr: bind.ErrNoCodeAfterDeploy, wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), }, diff --git a/accounts/abi/event.go b/accounts/abi/event.go index 44ed7b8df2..726bac90e9 100644 --- a/accounts/abi/event.go +++ b/accounts/abi/event.go @@ -18,7 +18,6 @@ package abi import ( "fmt" - "reflect" "strings" "github.com/ethereum/go-ethereum/common" @@ -31,7 +30,7 @@ import ( type Event struct { Name string Anonymous bool - Inputs []Argument + Inputs Arguments } // Id returns the canonical representation of the event's signature used by the @@ -45,93 +44,3 @@ func (e Event) Id() common.Hash { } return common.BytesToHash(crypto.Keccak256([]byte(fmt.Sprintf("%v(%v)", e.Name, strings.Join(types, ","))))) } - -// unpacks an event return tuple into a struct of corresponding go types -// -// Unpacking can be done into a struct or a slice/array. -func (e Event) tupleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - var ( - value = valueOf.Elem() - typ = value.Type() - ) - - if value.Kind() != reflect.Struct { - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - - j := 0 - for i := 0; i < len(e.Inputs); i++ { - input := e.Inputs[i] - if input.Indexed { - // can't read, continue - continue - } else if input.Type.T == ArrayTy { - // need to move this up because they read sequentially - j += input.Type.Size - } - marshalledValue, err := toGoType((i+j)*32, input.Type, output) - if err != nil { - return err - } - reflectValue := reflect.ValueOf(marshalledValue) - - switch value.Kind() { - case reflect.Struct: - for j := 0; j < typ.NumField(); j++ { - field := typ.Field(j) - // TODO read tags: `abi:"fieldName"` - if field.Name == strings.ToUpper(e.Inputs[i].Name[:1])+e.Inputs[i].Name[1:] { - if err := set(value.Field(j), reflectValue, e.Inputs[i]); err != nil { - return err - } - } - } - case reflect.Slice, reflect.Array: - if value.Len() < i { - return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(e.Inputs), value.Len()) - } - v := value.Index(i) - if v.Kind() != reflect.Ptr && v.Kind() != reflect.Interface { - return fmt.Errorf("abi: cannot unmarshal %v in to %v", v.Type(), reflectValue.Type()) - } - reflectValue := reflect.ValueOf(marshalledValue) - if err := set(v.Elem(), reflectValue, e.Inputs[i]); err != nil { - return err - } - default: - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - } - return nil -} - -func (e Event) isTupleReturn() bool { return len(e.Inputs) > 1 } - -func (e Event) singleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - if e.Inputs[0].Indexed { - return fmt.Errorf("abi: attempting to unpack indexed variable into element.") - } - - value := valueOf.Elem() - - marshalledValue, err := toGoType(0, e.Inputs[0].Type, output) - if err != nil { - return err - } - if err := set(value, reflect.ValueOf(marshalledValue), e.Inputs[0]); err != nil { - return err - } - return nil -} diff --git a/accounts/abi/event_test.go b/accounts/abi/event_test.go index 7e2f13f763..cca61e433d 100644 --- a/accounts/abi/event_test.go +++ b/accounts/abi/event_test.go @@ -17,13 +17,53 @@ package abi import ( + "bytes" + "encoding/hex" + "encoding/json" + "math/big" + "reflect" "strings" "testing" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) +var jsonEventTransfer = []byte(`{ + "anonymous": false, + "inputs": [ + { + "indexed": true, "name": "from", "type": "address" + }, { + "indexed": true, "name": "to", "type": "address" + }, { + "indexed": false, "name": "value", "type": "uint256" + }], + "name": "Transfer", + "type": "event" +}`) + +var jsonEventPledge = []byte(`{ + "anonymous": false, + "inputs": [{ + "indexed": false, "name": "who", "type": "address" + }, { + "indexed": false, "name": "wad", "type": "uint128" + }, { + "indexed": false, "name": "currency", "type": "bytes3" + }], + "name": "Pledge", + "type": "event" +}`) + +// 1000000 +var transferData1 = "00000000000000000000000000000000000000000000000000000000000f4240" + +// "0x00Ce0d46d924CC8437c806721496599FC3FFA268", 2218516807680, "usd" +var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa2680000000000000000000000000000000000000000000000000000020489e800007573640000000000000000000000000000000000000000000000000000000000" + func TestEventId(t *testing.T) { var table = []struct { definition string @@ -54,3 +94,223 @@ func TestEventId(t *testing.T) { } } } + +// TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array. +func TestEventMultiValueWithArrayUnpack(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]` + type testStruct struct { + Value1 [2]uint8 + Value2 uint8 + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + var i uint8 = 1 + for ; i <= 3; i++ { + b.Write(packNum(reflect.ValueOf(i))) + } + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, [2]uint8{1, 2}, rst.Value1) + require.Equal(t, uint8(3), rst.Value2) +} + +func TestEventTupleUnpack(t *testing.T) { + + type EventTransfer struct { + Value *big.Int + } + + type EventPledge struct { + Who common.Address + Wad *big.Int + Currency [3]byte + } + + type BadEventPledge struct { + Who string + Wad int + Currency [3]byte + } + + bigint := new(big.Int) + bigintExpected := big.NewInt(1000000) + bigintExpected2 := big.NewInt(2218516807680) + addr := common.HexToAddress("0x00Ce0d46d924CC8437c806721496599FC3FFA268") + var testCases = []struct { + data string + dest interface{} + expected interface{} + jsonLog []byte + error string + name string + }{{ + transferData1, + &EventTransfer{}, + &EventTransfer{Value: bigintExpected}, + jsonEventTransfer, + "", + "Can unpack ERC20 Transfer event into structure", + }, { + transferData1, + &[]interface{}{&bigint}, + &[]interface{}{&bigintExpected}, + jsonEventTransfer, + "", + "Can unpack ERC20 Transfer event into slice", + }, { + pledgeData1, + &EventPledge{}, + &EventPledge{ + addr, + bigintExpected2, + [3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into structure", + }, { + pledgeData1, + &[]interface{}{&common.Address{}, &bigint, &[3]byte{}}, + &[]interface{}{ + &addr, + &bigintExpected2, + &[3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into slice", + }, { + pledgeData1, + &[3]interface{}{&common.Address{}, &bigint, &[3]byte{}}, + &[3]interface{}{ + &addr, + &bigintExpected2, + &[3]byte{'u', 's', 'd'}}, + jsonEventPledge, + "", + "Can unpack Pledge event into an array", + }, { + pledgeData1, + &[]interface{}{new(int), 0, 0}, + &[]interface{}{}, + jsonEventPledge, + "abi: cannot unmarshal common.Address in to int", + "Can not unpack Pledge event into slice with wrong types", + }, { + pledgeData1, + &BadEventPledge{}, + &BadEventPledge{}, + jsonEventPledge, + "abi: cannot unmarshal common.Address in to string", + "Can not unpack Pledge event into struct with wrong filed types", + }, { + pledgeData1, + &[]interface{}{common.Address{}, new(big.Int)}, + &[]interface{}{}, + jsonEventPledge, + "abi: insufficient number of elements in the list/array for unpack, want 3, got 2", + "Can not unpack Pledge event into too short slice", + }, { + pledgeData1, + new(map[string]interface{}), + &[]interface{}{}, + jsonEventPledge, + "abi: cannot unmarshal tuple into map[string]interface {}", + "Can not unpack Pledge event into map", + }} + + for _, tc := range testCases { + assert := assert.New(t) + tc := tc + t.Run(tc.name, func(t *testing.T) { + err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert) + if tc.error == "" { + assert.Nil(err, "Should be able to unpack event data.") + assert.Equal(tc.expected, tc.dest, tc.name) + } else { + assert.EqualError(err, tc.error) + } + }) + } +} + +func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, assert *assert.Assertions) error { + data, err := hex.DecodeString(hexData) + assert.NoError(err, "Hex data should be a correct hex-string") + var e Event + assert.NoError(json.Unmarshal(jsonEvent, &e), "Should be able to unmarshal event ABI") + a := ABI{Events: map[string]Event{"e": e}} + return a.Unpack(dest, "e", data) +} + +/* +Taken from +https://github.com/ethereum/go-ethereum/pull/15568 +*/ + +type testResult struct { + Values [2]*big.Int + Value1 *big.Int + Value2 *big.Int +} + +type testCase struct { + definition string + want testResult +} + +func (tc testCase) encoded(intType, arrayType Type) []byte { + var b bytes.Buffer + if tc.want.Value1 != nil { + val, _ := intType.pack(reflect.ValueOf(tc.want.Value1)) + b.Write(val) + } + + if !reflect.DeepEqual(tc.want.Values, [2]*big.Int{nil, nil}) { + val, _ := arrayType.pack(reflect.ValueOf(tc.want.Values)) + b.Write(val) + } + if tc.want.Value2 != nil { + val, _ := intType.pack(reflect.ValueOf(tc.want.Value2)) + b.Write(val) + } + return b.Bytes() +} + +// TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder. +func TestEventUnpackIndexed(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]` + type testStruct struct { + Value1 uint8 + Value2 uint8 + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + b.Write(packNum(reflect.ValueOf(uint8(8)))) + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, uint8(0), rst.Value1) + require.Equal(t, uint8(8), rst.Value2) +} + +// TestEventIndexedWithArrayUnpack verifies that decoder will not overlow when static array is indexed input. +func TestEventIndexedWithArrayUnpack(t *testing.T) { + definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]` + type testStruct struct { + Value1 [2]uint8 + Value2 string + } + abi, err := JSON(strings.NewReader(definition)) + require.NoError(t, err) + var b bytes.Buffer + stringOut := "abc" + // number of fields that will be encoded * 32 + b.Write(packNum(reflect.ValueOf(32))) + b.Write(packNum(reflect.ValueOf(len(stringOut)))) + b.Write(common.RightPadBytes([]byte(stringOut), 32)) + + var rst testStruct + require.NoError(t, abi.Unpack(&rst, "test", b.Bytes())) + require.Equal(t, [2]uint8{0, 0}, rst.Value1) + require.Equal(t, stringOut, rst.Value2) +} diff --git a/accounts/abi/method.go b/accounts/abi/method.go index d8838e9ed6..f434ffdbef 100644 --- a/accounts/abi/method.go +++ b/accounts/abi/method.go @@ -18,13 +18,12 @@ package abi import ( "fmt" - "reflect" "strings" "github.com/ethereum/go-ethereum/crypto" ) -// Callable method given a `Name` and whether the method is a constant. +// Method represents a callable given a `Name` and whether the method is a constant. // If the method is `Const` no transaction needs to be created for this // particular Method call. It can easily be simulated using a local VM. // For example a `Balance()` method only needs to retrieve something @@ -35,125 +34,8 @@ import ( type Method struct { Name string Const bool - Inputs []Argument - Outputs []Argument -} - -func (method Method) pack(args ...interface{}) ([]byte, error) { - // Make sure arguments match up and pack them - if len(args) != len(method.Inputs) { - return nil, fmt.Errorf("argument count mismatch: %d for %d", len(args), len(method.Inputs)) - } - // variable input is the output appended at the end of packed - // output. This is used for strings and bytes types input. - var variableInput []byte - - var ret []byte - for i, a := range args { - input := method.Inputs[i] - // pack the input - packed, err := input.Type.pack(reflect.ValueOf(a)) - if err != nil { - return nil, fmt.Errorf("`%s` %v", method.Name, err) - } - - // check for a slice type (string, bytes, slice) - if input.Type.requiresLengthPrefix() { - // calculate the offset - offset := len(method.Inputs)*32 + len(variableInput) - // set the offset - ret = append(ret, packNum(reflect.ValueOf(offset))...) - // Append the packed output to the variable input. The variable input - // will be appended at the end of the input. - variableInput = append(variableInput, packed...) - } else { - // append the packed value to the input - ret = append(ret, packed...) - } - } - // append the variable input at the end of the packed input - ret = append(ret, variableInput...) - - return ret, nil -} - -// unpacks a method return tuple into a struct of corresponding go types -// -// Unpacking can be done into a struct or a slice/array. -func (method Method) tupleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - var ( - value = valueOf.Elem() - typ = value.Type() - ) - - j := 0 - for i := 0; i < len(method.Outputs); i++ { - toUnpack := method.Outputs[i] - if toUnpack.Type.T == ArrayTy { - // need to move this up because they read sequentially - j += toUnpack.Type.Size - } - marshalledValue, err := toGoType((i+j)*32, toUnpack.Type, output) - if err != nil { - return err - } - reflectValue := reflect.ValueOf(marshalledValue) - - switch value.Kind() { - case reflect.Struct: - for j := 0; j < typ.NumField(); j++ { - field := typ.Field(j) - // TODO read tags: `abi:"fieldName"` - if field.Name == strings.ToUpper(method.Outputs[i].Name[:1])+method.Outputs[i].Name[1:] { - if err := set(value.Field(j), reflectValue, method.Outputs[i]); err != nil { - return err - } - } - } - case reflect.Slice, reflect.Array: - if value.Len() < i { - return fmt.Errorf("abi: insufficient number of arguments for unpack, want %d, got %d", len(method.Outputs), value.Len()) - } - v := value.Index(i) - if v.Kind() != reflect.Ptr && v.Kind() != reflect.Interface { - return fmt.Errorf("abi: cannot unmarshal %v in to %v", v.Type(), reflectValue.Type()) - } - reflectValue := reflect.ValueOf(marshalledValue) - if err := set(v.Elem(), reflectValue, method.Outputs[i]); err != nil { - return err - } - default: - return fmt.Errorf("abi: cannot unmarshal tuple in to %v", typ) - } - } - return nil -} - -func (method Method) isTupleReturn() bool { return len(method.Outputs) > 1 } - -func (method Method) singleUnpack(v interface{}, output []byte) error { - // make sure the passed value is a pointer - valueOf := reflect.ValueOf(v) - if reflect.Ptr != valueOf.Kind() { - return fmt.Errorf("abi: Unpack(non-pointer %T)", v) - } - - value := valueOf.Elem() - - marshalledValue, err := toGoType(0, method.Outputs[0].Type, output) - if err != nil { - return err - } - if err := set(value, reflect.ValueOf(marshalledValue), method.Outputs[0]); err != nil { - return err - } - return nil + Inputs Arguments + Outputs Arguments } // Sig returns the methods string signature according to the ABI spec. @@ -163,35 +45,35 @@ func (method Method) singleUnpack(v interface{}, output []byte) error { // function foo(uint32 a, int b) = "foo(uint32,int256)" // // Please note that "int" is substitute for its canonical representation "int256" -func (m Method) Sig() string { - types := make([]string, len(m.Inputs)) +func (method Method) Sig() string { + types := make([]string, len(method.Inputs)) i := 0 - for _, input := range m.Inputs { + for _, input := range method.Inputs { types[i] = input.Type.String() i++ } - return fmt.Sprintf("%v(%v)", m.Name, strings.Join(types, ",")) + return fmt.Sprintf("%v(%v)", method.Name, strings.Join(types, ",")) } -func (m Method) String() string { - inputs := make([]string, len(m.Inputs)) - for i, input := range m.Inputs { +func (method Method) String() string { + inputs := make([]string, len(method.Inputs)) + for i, input := range method.Inputs { inputs[i] = fmt.Sprintf("%v %v", input.Name, input.Type) } - outputs := make([]string, len(m.Outputs)) - for i, output := range m.Outputs { + outputs := make([]string, len(method.Outputs)) + for i, output := range method.Outputs { if len(output.Name) > 0 { outputs[i] = fmt.Sprintf("%v ", output.Name) } outputs[i] += output.Type.String() } constant := "" - if m.Const { + if method.Const { constant = "constant " } - return fmt.Sprintf("function %v(%v) %sreturns(%v)", m.Name, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", ")) + return fmt.Sprintf("function %v(%v) %sreturns(%v)", method.Name, strings.Join(inputs, ", "), constant, strings.Join(outputs, ", ")) } -func (m Method) Id() []byte { - return crypto.Keccak256([]byte(m.Sig()))[:4] +func (method Method) Id() []byte { + return crypto.Keccak256([]byte(method.Sig()))[:4] } diff --git a/accounts/abi/pack.go b/accounts/abi/pack.go index 072e805368..36c58265bd 100644 --- a/accounts/abi/pack.go +++ b/accounts/abi/pack.go @@ -48,9 +48,8 @@ func packElement(t Type, reflectValue reflect.Value) []byte { case BoolTy: if reflectValue.Bool() { return math.PaddedBigBytes(common.Big1, 32) - } else { - return math.PaddedBigBytes(common.Big0, 32) } + return math.PaddedBigBytes(common.Big0, 32) case BytesTy: if reflectValue.Kind() == reflect.Array { reflectValue = mustArrayToByteSlice(reflectValue) diff --git a/accounts/abi/reflect.go b/accounts/abi/reflect.go index e953b77c18..7a9cdacd54 100644 --- a/accounts/abi/reflect.go +++ b/accounts/abi/reflect.go @@ -85,3 +85,28 @@ func set(dst, src reflect.Value, output Argument) error { } return nil } + +// requireAssignable assures that `dest` is a pointer and it's not an interface. +func requireAssignable(dst, src reflect.Value) error { + if dst.Kind() != reflect.Ptr && dst.Kind() != reflect.Interface { + return fmt.Errorf("abi: cannot unmarshal %v into %v", src.Type(), dst.Type()) + } + return nil +} + +// requireUnpackKind verifies preconditions for unpacking `args` into `kind` +func requireUnpackKind(v reflect.Value, t reflect.Type, k reflect.Kind, + args Arguments) error { + + switch k { + case reflect.Struct: + case reflect.Slice, reflect.Array: + if minLen := args.LengthNonIndexed(); v.Len() < minLen { + return fmt.Errorf("abi: insufficient number of elements in the list/array for unpack, want %d, got %d", + minLen, v.Len()) + } + default: + return fmt.Errorf("abi: cannot unmarshal tuple into %v", t) + } + return nil +} diff --git a/accounts/abi/type.go b/accounts/abi/type.go index fba10b96d2..a1f13ffa29 100644 --- a/accounts/abi/type.go +++ b/accounts/abi/type.go @@ -24,6 +24,7 @@ import ( "strings" ) +// Type enumerator const ( IntTy byte = iota UintTy @@ -100,69 +101,66 @@ func NewType(t string) (typ Type, err error) { return Type{}, fmt.Errorf("invalid formatting of array type") } return typ, err - } else { - // parse the type and size of the abi-type. - parsedType := typeRegex.FindAllStringSubmatch(t, -1)[0] - // varSize is the size of the variable - var varSize int - if len(parsedType[3]) > 0 { - var err error - varSize, err = strconv.Atoi(parsedType[2]) - if err != nil { - return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err) - } - } else { - if parsedType[0] == "uint" || parsedType[0] == "int" { - // this should fail because it means that there's something wrong with - // the abi type (the compiler should always format it to the size...always) - return Type{}, fmt.Errorf("unsupported arg type: %s", t) - } + } + // parse the type and size of the abi-type. + parsedType := typeRegex.FindAllStringSubmatch(t, -1)[0] + // varSize is the size of the variable + var varSize int + if len(parsedType[3]) > 0 { + var err error + varSize, err = strconv.Atoi(parsedType[2]) + if err != nil { + return Type{}, fmt.Errorf("abi: error parsing variable size: %v", err) } - // varType is the parsed abi type - varType := parsedType[1] - - switch varType { - case "int": - typ.Kind, typ.Type = reflectIntKindAndType(false, varSize) - typ.Size = varSize - typ.T = IntTy - case "uint": - typ.Kind, typ.Type = reflectIntKindAndType(true, varSize) - typ.Size = varSize - typ.T = UintTy - case "bool": - typ.Kind = reflect.Bool - typ.T = BoolTy - typ.Type = reflect.TypeOf(bool(false)) - case "address": - typ.Kind = reflect.Array - typ.Type = address_t - typ.Size = 20 - typ.T = AddressTy - case "string": - typ.Kind = reflect.String - typ.Type = reflect.TypeOf("") - typ.T = StringTy - case "bytes": - if varSize == 0 { - typ.T = BytesTy - typ.Kind = reflect.Slice - typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0))) - } else { - typ.T = FixedBytesTy - typ.Kind = reflect.Array - typ.Size = varSize - typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0))) - } - case "function": - typ.Kind = reflect.Array - typ.T = FunctionTy - typ.Size = 24 - typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0))) - default: + } else { + if parsedType[0] == "uint" || parsedType[0] == "int" { + // this should fail because it means that there's something wrong with + // the abi type (the compiler should always format it to the size...always) return Type{}, fmt.Errorf("unsupported arg type: %s", t) } } + // varType is the parsed abi type + switch varType := parsedType[1]; varType { + case "int": + typ.Kind, typ.Type = reflectIntKindAndType(false, varSize) + typ.Size = varSize + typ.T = IntTy + case "uint": + typ.Kind, typ.Type = reflectIntKindAndType(true, varSize) + typ.Size = varSize + typ.T = UintTy + case "bool": + typ.Kind = reflect.Bool + typ.T = BoolTy + typ.Type = reflect.TypeOf(bool(false)) + case "address": + typ.Kind = reflect.Array + typ.Type = address_t + typ.Size = 20 + typ.T = AddressTy + case "string": + typ.Kind = reflect.String + typ.Type = reflect.TypeOf("") + typ.T = StringTy + case "bytes": + if varSize == 0 { + typ.T = BytesTy + typ.Kind = reflect.Slice + typ.Type = reflect.SliceOf(reflect.TypeOf(byte(0))) + } else { + typ.T = FixedBytesTy + typ.Kind = reflect.Array + typ.Size = varSize + typ.Type = reflect.ArrayOf(varSize, reflect.TypeOf(byte(0))) + } + case "function": + typ.Kind = reflect.Array + typ.T = FunctionTy + typ.Size = 24 + typ.Type = reflect.ArrayOf(24, reflect.TypeOf(byte(0))) + default: + return Type{}, fmt.Errorf("unsupported arg type: %s", t) + } return } diff --git a/accounts/abi/unpack.go b/accounts/abi/unpack.go index 57732797b6..80efb3f7ea 100644 --- a/accounts/abi/unpack.go +++ b/accounts/abi/unpack.go @@ -25,15 +25,6 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// unpacker is a utility interface that enables us to have -// abstraction between events and methods and also to properly -// "unpack" them; e.g. events use Inputs, methods use Outputs. -type unpacker interface { - tupleUnpack(v interface{}, output []byte) error - singleUnpack(v interface{}, output []byte) error - isTupleReturn() bool -} - // reads the integer based on its kind func readInteger(kind reflect.Kind, b []byte) interface{} { switch kind { @@ -79,7 +70,7 @@ func readBool(word []byte) (bool, error) { // This enforces that standard by always presenting it as a 24-array (address + sig = 24 bytes) func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) { if t.T != FunctionTy { - return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array.") + return [24]byte{}, fmt.Errorf("abi: invalid type in call to make function type byte array") } if garbage := binary.BigEndian.Uint64(word[24:32]); garbage != 0 { err = fmt.Errorf("abi: got improperly encoded function type, got %v", word) @@ -92,7 +83,7 @@ func readFunctionType(t Type, word []byte) (funcTy [24]byte, err error) { // through reflection, creates a fixed array to be read from func readFixedBytes(t Type, word []byte) (interface{}, error) { if t.T != FixedBytesTy { - return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array.") + return nil, fmt.Errorf("abi: invalid type in call to make fixed byte array") } // convert array := reflect.New(t.Type).Elem() @@ -203,14 +194,3 @@ func lengthPrefixPointsTo(index int, output []byte) (start int, length int, err //fmt.Printf("LENGTH PREFIX INFO: \nsize: %v\noffset: %v\nstart: %v\n", length, offset, start) return } - -// checks for proper formatting of byte output -func bytesAreProper(output []byte) error { - if len(output) == 0 { - return fmt.Errorf("abi: unmarshalling empty output") - } else if len(output)%32 != 0 { - return fmt.Errorf("abi: improperly formatted output") - } else { - return nil - } -} diff --git a/accounts/abi/unpack_test.go b/accounts/abi/unpack_test.go index 1e21aafc05..4d7fe638c4 100644 --- a/accounts/abi/unpack_test.go +++ b/accounts/abi/unpack_test.go @@ -22,10 +22,12 @@ import ( "fmt" "math/big" "reflect" + "strconv" "strings" "testing" "github.com/ethereum/go-ethereum/common" + "github.com/stretchr/testify/require" ) type unpackTest struct { @@ -257,82 +259,179 @@ var unpackTests = []unpackTest{ enc: "000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003", want: [3]*big.Int{big.NewInt(1), big.NewInt(2), big.NewInt(3)}, }, + // struct outputs + { + def: `[{"name":"int1","type":"int256"},{"name":"int2","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{big.NewInt(1), big.NewInt(2)}, + }, + { + def: `[{"name":"int","type":"int256"},{"name":"Int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"int","type":"int256"},{"name":"_int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"Int","type":"int256"},{"name":"_int","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: multiple outputs mapping to the same struct field 'Int'", + }, + { + def: `[{"name":"Int","type":"int256"},{"name":"_","type":"int256"}]`, + enc: "00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002", + want: struct { + Int1 *big.Int + Int2 *big.Int + }{}, + err: "abi: purely underscored output cannot unpack to struct", + }, } func TestUnpack(t *testing.T) { for i, test := range unpackTests { - def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) - abi, err := JSON(strings.NewReader(def)) - if err != nil { - t.Fatalf("invalid ABI definition %s: %v", def, err) - } - encb, err := hex.DecodeString(test.enc) - if err != nil { - t.Fatalf("invalid hex: %s" + test.enc) - } - outptr := reflect.New(reflect.TypeOf(test.want)) - err = abi.Unpack(outptr.Interface(), "method", encb) - if err := test.checkError(err); err != nil { - t.Errorf("test %d (%v) failed: %v", i, test.def, err) - continue - } - out := outptr.Elem().Interface() - if !reflect.DeepEqual(test.want, out) { - t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out) - } + t.Run(strconv.Itoa(i), func(t *testing.T) { + def := fmt.Sprintf(`[{ "name" : "method", "outputs": %s}]`, test.def) + abi, err := JSON(strings.NewReader(def)) + if err != nil { + t.Fatalf("invalid ABI definition %s: %v", def, err) + } + encb, err := hex.DecodeString(test.enc) + if err != nil { + t.Fatalf("invalid hex: %s" + test.enc) + } + outptr := reflect.New(reflect.TypeOf(test.want)) + err = abi.Unpack(outptr.Interface(), "method", encb) + if err := test.checkError(err); err != nil { + t.Errorf("test %d (%v) failed: %v", i, test.def, err) + return + } + out := outptr.Elem().Interface() + if !reflect.DeepEqual(test.want, out) { + t.Errorf("test %d (%v) failed: expected %v, got %v", i, test.def, test.want, out) + } + }) } } -func TestMultiReturnWithStruct(t *testing.T) { +type methodMultiOutput struct { + Int *big.Int + String string +} + +func methodMultiReturn(require *require.Assertions) (ABI, []byte, methodMultiOutput) { const definition = `[ { "name" : "multi", "constant" : false, "outputs": [ { "name": "Int", "type": "uint256" }, { "name": "String", "type": "string" } ] }]` + var expected = methodMultiOutput{big.NewInt(1), "hello"} abi, err := JSON(strings.NewReader(definition)) - if err != nil { - t.Fatal(err) - } - + require.NoError(err) // using buff to make the code readable buff := new(bytes.Buffer) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000001")) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000040")) buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000005")) - stringOut := "hello" - buff.Write(common.RightPadBytes([]byte(stringOut), 32)) + buff.Write(common.RightPadBytes([]byte(expected.String), 32)) + return abi, buff.Bytes(), expected +} - var inter struct { - Int *big.Int - String string - } - err = abi.Unpack(&inter, "multi", buff.Bytes()) - if err != nil { - t.Error(err) - } - - if inter.Int == nil || inter.Int.Cmp(big.NewInt(1)) != 0 { - t.Error("expected Int to be 1 got", inter.Int) - } - - if inter.String != stringOut { - t.Error("expected String to be", stringOut, "got", inter.String) - } - - var reversed struct { +func TestMethodMultiReturn(t *testing.T) { + type reversed struct { String string Int *big.Int } - err = abi.Unpack(&reversed, "multi", buff.Bytes()) + abi, data, expected := methodMultiReturn(require.New(t)) + bigint := new(big.Int) + var testCases = []struct { + dest interface{} + expected interface{} + error string + name string + }{{ + &methodMultiOutput{}, + &expected, + "", + "Can unpack into structure", + }, { + &reversed{}, + &reversed{expected.String, expected.Int}, + "", + "Can unpack into reversed structure", + }, { + &[]interface{}{&bigint, new(string)}, + &[]interface{}{&expected.Int, &expected.String}, + "", + "Can unpack into a slice", + }, { + &[2]interface{}{&bigint, new(string)}, + &[2]interface{}{&expected.Int, &expected.String}, + "", + "Can unpack into an array", + }, { + &[]interface{}{new(int), new(int)}, + &[]interface{}{&expected.Int, &expected.String}, + "abi: cannot unmarshal *big.Int in to int", + "Can not unpack into a slice with wrong types", + }, { + &[]interface{}{new(int)}, + &[]interface{}{}, + "abi: insufficient number of elements in the list/array for unpack, want 2, got 1", + "Can not unpack into a slice with wrong types", + }} + for _, tc := range testCases { + tc := tc + t.Run(tc.name, func(t *testing.T) { + require := require.New(t) + err := abi.Unpack(tc.dest, "multi", data) + if tc.error == "" { + require.Nil(err, "Should be able to unpack method outputs.") + require.Equal(tc.expected, tc.dest) + } else { + require.EqualError(err, tc.error) + } + }) + } +} + +func TestMultiReturnWithArray(t *testing.T) { + const definition = `[{"name" : "multi", "outputs": [{"type": "uint64[3]"}, {"type": "uint64"}]}]` + abi, err := JSON(strings.NewReader(definition)) if err != nil { - t.Error(err) + t.Fatal(err) } + buff := new(bytes.Buffer) + buff.Write(common.Hex2Bytes("000000000000000000000000000000000000000000000000000000000000000900000000000000000000000000000000000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000009")) + buff.Write(common.Hex2Bytes("0000000000000000000000000000000000000000000000000000000000000008")) - if reversed.Int == nil || reversed.Int.Cmp(big.NewInt(1)) != 0 { - t.Error("expected Int to be 1 got", reversed.Int) + ret1, ret1Exp := new([3]uint64), [3]uint64{9, 9, 9} + ret2, ret2Exp := new(uint64), uint64(8) + if err := abi.Unpack(&[]interface{}{ret1, ret2}, "multi", buff.Bytes()); err != nil { + t.Fatal(err) } - - if reversed.String != stringOut { - t.Error("expected String to be", stringOut, "got", reversed.String) + if !reflect.DeepEqual(*ret1, ret1Exp) { + t.Error("array result", *ret1, "!= Expected", ret1Exp) + } + if *ret2 != ret2Exp { + t.Error("int result", *ret2, "!= Expected", ret2Exp) } } diff --git a/accounts/keystore/presale.go b/accounts/keystore/presale.go index ed900ad085..1554294e14 100644 --- a/accounts/keystore/presale.go +++ b/accounts/keystore/presale.go @@ -58,6 +58,9 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error if err != nil { return nil, errors.New("invalid hex in encSeed") } + if len(encSeedBytes) < 16 { + return nil, errors.New("invalid encSeed, too short") + } iv := encSeedBytes[:16] cipherText := encSeedBytes[16:] /* diff --git a/accounts/usbwallet/trezor.go b/accounts/usbwallet/trezor.go index 159cb2ea97..b84a955992 100644 --- a/accounts/usbwallet/trezor.go +++ b/accounts/usbwallet/trezor.go @@ -180,7 +180,7 @@ func (w *trezorDriver) trezorSign(derivationPath []uint32, tx *types.Transaction AddressN: derivationPath, Nonce: new(big.Int).SetUint64(tx.Nonce()).Bytes(), GasPrice: tx.GasPrice().Bytes(), - GasLimit: tx.Gas().Bytes(), + GasLimit: new(big.Int).SetUint64(tx.Gas()).Bytes(), Value: tx.Value().Bytes(), DataLength: &length, } diff --git a/appveyor.yml b/appveyor.yml index 78b11fa9d6..99029f553d 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -23,8 +23,8 @@ environment: install: - git submodule update --init - rmdir C:\go /s /q - - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.windows-%GETH_ARCH%.zip - - 7z x go1.9.windows-%GETH_ARCH%.zip -y -oC:\ > NUL + - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.2.windows-%GETH_ARCH%.zip + - 7z x go1.9.2.windows-%GETH_ARCH%.zip -y -oC:\ > NUL - go version - gcc --version diff --git a/build/ci.go b/build/ci.go index 987f0bb18a..1f98bb8438 100644 --- a/build/ci.go +++ b/build/ci.go @@ -23,7 +23,7 @@ Usage: go run build/ci.go Available commands are: - install [ -arch architecture ] [ packages... ] -- builds packages and executables + install [ -arch architecture ] [ -cc compiler ] [ packages... ] -- builds packages and executables test [ -coverage ] [ packages... ] -- runs the tests lint -- runs certain pre-selected linters archive [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -upload dest ] -- archives build artefacts @@ -173,17 +173,24 @@ func main() { func doInstall(cmdline []string) { var ( arch = flag.String("arch", "", "Architecture to cross build for") + cc = flag.String("cc", "", "C compiler to cross build with") ) flag.CommandLine.Parse(cmdline) env := build.Env() // Check Go version. People regularly open issues about compilation // failure with outdated Go. This should save them the trouble. - if runtime.Version() < "go1.7" && !strings.Contains(runtime.Version(), "devel") { - log.Println("You have Go version", runtime.Version()) - log.Println("go-ethereum requires at least Go version 1.7 and cannot") - log.Println("be compiled with an earlier version. Please upgrade your Go installation.") - os.Exit(1) + if !strings.Contains(runtime.Version(), "devel") { + // Figure out the minor version number since we can't textually compare (1.10 < 1.7) + var minor int + fmt.Sscanf(strings.TrimPrefix(runtime.Version(), "go1."), "%d", &minor) + + if minor < 7 { + log.Println("You have Go version", runtime.Version()) + log.Println("go-ethereum requires at least Go version 1.7 and cannot") + log.Println("be compiled with an earlier version. Please upgrade your Go installation.") + os.Exit(1) + } } // Compile packages given as arguments, or everything if there are no arguments. packages := []string{"./..."} @@ -207,7 +214,7 @@ func doInstall(cmdline []string) { } } // Seems we are cross compiling, work around forbidden GOBIN - goinstall := goToolArch(*arch, "install", buildFlags(env)...) + goinstall := goToolArch(*arch, *cc, "install", buildFlags(env)...) goinstall.Args = append(goinstall.Args, "-v") goinstall.Args = append(goinstall.Args, []string{"-buildmode", "archive"}...) goinstall.Args = append(goinstall.Args, packages...) @@ -221,7 +228,7 @@ func doInstall(cmdline []string) { } for name := range pkgs { if name == "main" { - gobuild := goToolArch(*arch, "build", buildFlags(env)...) + gobuild := goToolArch(*arch, *cc, "build", buildFlags(env)...) gobuild.Args = append(gobuild.Args, "-v") gobuild.Args = append(gobuild.Args, []string{"-o", executablePath(cmd.Name())}...) gobuild.Args = append(gobuild.Args, "."+string(filepath.Separator)+filepath.Join("cmd", cmd.Name())) @@ -249,15 +256,18 @@ func buildFlags(env build.Environment) (flags []string) { } func goTool(subcmd string, args ...string) *exec.Cmd { - return goToolArch(runtime.GOARCH, subcmd, args...) + return goToolArch(runtime.GOARCH, os.Getenv("CC"), subcmd, args...) } -func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd { +func goToolArch(arch string, cc string, subcmd string, args ...string) *exec.Cmd { cmd := build.GoTool(subcmd, args...) if subcmd == "build" || subcmd == "install" || subcmd == "test" { // Go CGO has a Windows linker error prior to 1.8 (https://github.com/golang/go/issues/8756). // Work around issue by allowing multiple definitions for <1.8 builds. - if runtime.GOOS == "windows" && runtime.Version() < "go1.8" { + var minor int + fmt.Sscanf(strings.TrimPrefix(runtime.Version(), "go1."), "%d", &minor) + + if runtime.GOOS == "windows" && minor < 8 { cmd.Args = append(cmd.Args, []string{"-ldflags", "-extldflags -Wl,--allow-multiple-definition"}...) } } @@ -268,6 +278,9 @@ func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd { cmd.Env = append(cmd.Env, "CGO_ENABLED=1") cmd.Env = append(cmd.Env, "GOARCH="+arch) } + if cc != "" { + cmd.Env = append(cmd.Env, "CC="+cc) + } for _, e := range os.Environ() { if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") { continue diff --git a/cmd/ethkey/README.md b/cmd/ethkey/README.md new file mode 100644 index 0000000000..cf72ba43d7 --- /dev/null +++ b/cmd/ethkey/README.md @@ -0,0 +1,41 @@ +ethkey +====== + +ethkey is a simple command-line tool for working with Ethereum keyfiles. + + +# Usage + +### `ethkey generate` + +Generate a new keyfile. +If you want to use an existing private key to use in the keyfile, it can be +specified by setting `--privatekey` with the location of the file containing the +private key. + + +### `ethkey inspect ` + +Print various information about the keyfile. +Private key information can be printed by using the `--private` flag; +make sure to use this feature with great caution! + + +### `ethkey sign ` + +Sign the message with a keyfile. +It is possible to refer to a file containing the message. + + +### `ethkey verify
` + +Verify the signature of the message. +It is possible to refer to a file containing the message. + + +## Passphrases + +For every command that uses a keyfile, you will be prompted to provide the +passphrase for decrypting the keyfile. To avoid this message, it is possible +to pass the passphrase by using the `--passphrase` flag pointing to a file that +contains the passphrase. diff --git a/cmd/ethkey/generate.go b/cmd/ethkey/generate.go new file mode 100644 index 0000000000..dee0e9d70e --- /dev/null +++ b/cmd/ethkey/generate.go @@ -0,0 +1,117 @@ +package main + +import ( + "crypto/ecdsa" + "crypto/rand" + "fmt" + "io/ioutil" + "os" + "path/filepath" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "github.com/pborman/uuid" + "gopkg.in/urfave/cli.v1" +) + +type outputGenerate struct { + Address string + AddressEIP55 string +} + +var commandGenerate = cli.Command{ + Name: "generate", + Usage: "generate new keyfile", + ArgsUsage: "[ ]", + Description: ` +Generate a new keyfile. +If you want to use an existing private key to use in the keyfile, it can be +specified by setting --privatekey with the location of the file containing the +private key.`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + cli.StringFlag{ + Name: "privatekey", + Usage: "the file from where to read the private key to " + + "generate a keyfile for", + }, + }, + Action: func(ctx *cli.Context) error { + // Check if keyfile path given and make sure it doesn't already exist. + keyfilepath := ctx.Args().First() + if keyfilepath == "" { + keyfilepath = defaultKeyfileName + } + if _, err := os.Stat(keyfilepath); err == nil { + utils.Fatalf("Keyfile already exists at %s.", keyfilepath) + } else if !os.IsNotExist(err) { + utils.Fatalf("Error checking if keyfile exists: %v", err) + } + + var privateKey *ecdsa.PrivateKey + + // First check if a private key file is provided. + privateKeyFile := ctx.String("privatekey") + if privateKeyFile != "" { + privateKeyBytes, err := ioutil.ReadFile(privateKeyFile) + if err != nil { + utils.Fatalf("Failed to read the private key file '%s': %v", + privateKeyFile, err) + } + + pk, err := crypto.HexToECDSA(string(privateKeyBytes)) + if err != nil { + utils.Fatalf( + "Could not construct ECDSA private key from file content: %v", + err) + } + privateKey = pk + } + + // If not loaded, generate random. + if privateKey == nil { + pk, err := ecdsa.GenerateKey(crypto.S256(), rand.Reader) + if err != nil { + utils.Fatalf("Failed to generate random private key: %v", err) + } + privateKey = pk + } + + // Create the keyfile object with a random UUID. + id := uuid.NewRandom() + key := &keystore.Key{ + Id: id, + Address: crypto.PubkeyToAddress(privateKey.PublicKey), + PrivateKey: privateKey, + } + + // Encrypt key with passphrase. + passphrase := getPassPhrase(ctx, true) + keyjson, err := keystore.EncryptKey(key, passphrase, + keystore.StandardScryptN, keystore.StandardScryptP) + if err != nil { + utils.Fatalf("Error encrypting key: %v", err) + } + + // Store the file to disk. + if err := os.MkdirAll(filepath.Dir(keyfilepath), 0700); err != nil { + utils.Fatalf("Could not create directory %s", filepath.Dir(keyfilepath)) + } + if err := ioutil.WriteFile(keyfilepath, keyjson, 0600); err != nil { + utils.Fatalf("Failed to write keyfile to %s: %v", keyfilepath, err) + } + + // Output some information. + out := outputGenerate{ + Address: key.Address.Hex(), + } + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Address: ", out.Address) + } + return nil + }, +} diff --git a/cmd/ethkey/inspect.go b/cmd/ethkey/inspect.go new file mode 100644 index 0000000000..8a7aeef848 --- /dev/null +++ b/cmd/ethkey/inspect.go @@ -0,0 +1,74 @@ +package main + +import ( + "encoding/hex" + "fmt" + "io/ioutil" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +type outputInspect struct { + Address string + PublicKey string + PrivateKey string +} + +var commandInspect = cli.Command{ + Name: "inspect", + Usage: "inspect a keyfile", + ArgsUsage: "", + Description: ` +Print various information about the keyfile. +Private key information can be printed by using the --private flag; +make sure to use this feature with great caution!`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + cli.BoolFlag{ + Name: "private", + Usage: "include the private key in the output", + }, + }, + Action: func(ctx *cli.Context) error { + keyfilepath := ctx.Args().First() + + // Read key from file. + keyjson, err := ioutil.ReadFile(keyfilepath) + if err != nil { + utils.Fatalf("Failed to read the keyfile at '%s': %v", keyfilepath, err) + } + + // Decrypt key with passphrase. + passphrase := getPassPhrase(ctx, false) + key, err := keystore.DecryptKey(keyjson, passphrase) + if err != nil { + utils.Fatalf("Error decrypting key: %v", err) + } + + // Output all relevant information we can retrieve. + showPrivate := ctx.Bool("private") + out := outputInspect{ + Address: key.Address.Hex(), + PublicKey: hex.EncodeToString( + crypto.FromECDSAPub(&key.PrivateKey.PublicKey)), + } + if showPrivate { + out.PrivateKey = hex.EncodeToString(crypto.FromECDSA(key.PrivateKey)) + } + + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Address: ", out.Address) + fmt.Println("Public key: ", out.PublicKey) + if showPrivate { + fmt.Println("Private key: ", out.PrivateKey) + } + } + return nil + }, +} diff --git a/cmd/ethkey/main.go b/cmd/ethkey/main.go new file mode 100644 index 0000000000..b9b7a18e05 --- /dev/null +++ b/cmd/ethkey/main.go @@ -0,0 +1,70 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "fmt" + "os" + + "github.com/ethereum/go-ethereum/cmd/utils" + "gopkg.in/urfave/cli.v1" +) + +const ( + defaultKeyfileName = "keyfile.json" +) + +var ( + gitCommit = "" // Git SHA1 commit hash of the release (set via linker flags) + + app *cli.App // the main app instance +) + +var ( // Commonly used command line flags. + passphraseFlag = cli.StringFlag{ + Name: "passwordfile", + Usage: "the file that contains the passphrase for the keyfile", + } + + jsonFlag = cli.BoolFlag{ + Name: "json", + Usage: "output JSON instead of human-readable format", + } + + messageFlag = cli.StringFlag{ + Name: "message", + Usage: "the file that contains the message to sign/verify", + } +) + +// Configure the app instance. +func init() { + app = utils.NewApp(gitCommit, "an Ethereum key manager") + app.Commands = []cli.Command{ + commandGenerate, + commandInspect, + commandSignMessage, + commandVerifyMessage, + } +} + +func main() { + if err := app.Run(os.Args); err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } +} diff --git a/cmd/ethkey/message.go b/cmd/ethkey/message.go new file mode 100644 index 0000000000..ae6b6552d3 --- /dev/null +++ b/cmd/ethkey/message.go @@ -0,0 +1,148 @@ +package main + +import ( + "encoding/hex" + "fmt" + "io/ioutil" + "os" + "strings" + + "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +type outputSign struct { + Signature string +} + +var commandSignMessage = cli.Command{ + Name: "signmessage", + Usage: "sign a message", + ArgsUsage: " ", + Description: ` +Sign the message with a keyfile. +It is possible to refer to a file containing the message.`, + Flags: []cli.Flag{ + passphraseFlag, + jsonFlag, + }, + Action: func(ctx *cli.Context) error { + keyfilepath := ctx.Args().First() + message := []byte(ctx.Args().Get(1)) + + // Load the keyfile. + keyjson, err := ioutil.ReadFile(keyfilepath) + if err != nil { + utils.Fatalf("Failed to read the keyfile at '%s': %v", + keyfilepath, err) + } + + // Decrypt key with passphrase. + passphrase := getPassPhrase(ctx, false) + key, err := keystore.DecryptKey(keyjson, passphrase) + if err != nil { + utils.Fatalf("Error decrypting key: %v", err) + } + + if len(message) == 0 { + utils.Fatalf("A message must be provided") + } + // Read message if file. + if _, err := os.Stat(string(message)); err == nil { + message, err = ioutil.ReadFile(string(message)) + if err != nil { + utils.Fatalf("Failed to read the message file: %v", err) + } + } + + signature, err := crypto.Sign(signHash(message), key.PrivateKey) + if err != nil { + utils.Fatalf("Failed to sign message: %v", err) + } + + out := outputSign{ + Signature: hex.EncodeToString(signature), + } + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + fmt.Println("Signature: ", out.Signature) + } + return nil + }, +} + +type outputVerify struct { + Success bool + RecoveredAddress string + RecoveredPublicKey string +} + +var commandVerifyMessage = cli.Command{ + Name: "verifymessage", + Usage: "verify the signature of a signed message", + ArgsUsage: "
", + Description: ` +Verify the signature of the message. +It is possible to refer to a file containing the message.`, + Flags: []cli.Flag{ + jsonFlag, + }, + Action: func(ctx *cli.Context) error { + addressStr := ctx.Args().First() + signatureHex := ctx.Args().Get(1) + message := []byte(ctx.Args().Get(2)) + + // Determine whether it is a keyfile, public key or address. + if !common.IsHexAddress(addressStr) { + utils.Fatalf("Invalid address: %s", addressStr) + } + address := common.HexToAddress(addressStr) + + signature, err := hex.DecodeString(signatureHex) + if err != nil { + utils.Fatalf("Signature encoding is not hexadecimal: %v", err) + } + + if len(message) == 0 { + utils.Fatalf("A message must be provided") + } + // Read message if file. + if _, err := os.Stat(string(message)); err == nil { + message, err = ioutil.ReadFile(string(message)) + if err != nil { + utils.Fatalf("Failed to read the message file: %v", err) + } + } + + recoveredPubkey, err := crypto.SigToPub(signHash(message), signature) + if err != nil || recoveredPubkey == nil { + utils.Fatalf("Signature verification failed: %v", err) + } + recoveredPubkeyBytes := crypto.FromECDSAPub(recoveredPubkey) + recoveredAddress := crypto.PubkeyToAddress(*recoveredPubkey) + + success := address == recoveredAddress + + out := outputVerify{ + Success: success, + RecoveredPublicKey: hex.EncodeToString(recoveredPubkeyBytes), + RecoveredAddress: strings.ToLower(recoveredAddress.Hex()), + } + if ctx.Bool(jsonFlag.Name) { + mustPrintJSON(out) + } else { + if out.Success { + fmt.Println("Signature verification successful!") + } else { + fmt.Println("Signature verification failed!") + } + fmt.Println("Recovered public key: ", out.RecoveredPublicKey) + fmt.Println("Recovered address: ", out.RecoveredAddress) + } + return nil + }, +} diff --git a/cmd/ethkey/utils.go b/cmd/ethkey/utils.go new file mode 100644 index 0000000000..0e563bf922 --- /dev/null +++ b/cmd/ethkey/utils.go @@ -0,0 +1,83 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with go-ethereum. If not, see . + +package main + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "strings" + + "github.com/ethereum/go-ethereum/cmd/utils" + "github.com/ethereum/go-ethereum/console" + "github.com/ethereum/go-ethereum/crypto" + "gopkg.in/urfave/cli.v1" +) + +// getPassPhrase obtains a passphrase given by the user. It first checks the +// --passphrase command line flag and ultimately prompts the user for a +// passphrase. +func getPassPhrase(ctx *cli.Context, confirmation bool) string { + // Look for the --passphrase flag. + passphraseFile := ctx.String(passphraseFlag.Name) + if passphraseFile != "" { + content, err := ioutil.ReadFile(passphraseFile) + if err != nil { + utils.Fatalf("Failed to read passphrase file '%s': %v", + passphraseFile, err) + } + return strings.TrimRight(string(content), "\r\n") + } + + // Otherwise prompt the user for the passphrase. + passphrase, err := console.Stdin.PromptPassword("Passphrase: ") + if err != nil { + utils.Fatalf("Failed to read passphrase: %v", err) + } + if confirmation { + confirm, err := console.Stdin.PromptPassword("Repeat passphrase: ") + if err != nil { + utils.Fatalf("Failed to read passphrase confirmation: %v", err) + } + if passphrase != confirm { + utils.Fatalf("Passphrases do not match") + } + } + return passphrase +} + +// signHash is a helper function that calculates a hash for the given message +// that can be safely used to calculate a signature from. +// +// The hash is calulcated as +// keccak256("\x19Ethereum Signed Message:\n"${message length}${message}). +// +// This gives context to the signed message and prevents signing of transactions. +func signHash(data []byte) []byte { + msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data) + return crypto.Keccak256([]byte(msg)) +} + +// mustPrintJSON prints the JSON encoding of the given object and +// exits the program with an error message when the marshaling fails. +func mustPrintJSON(jsonObject interface{}) { + str, err := json.MarshalIndent(jsonObject, "", " ") + if err != nil { + utils.Fatalf("Failed to marshal JSON object: %v", err) + } + fmt.Println(string(str)) +} diff --git a/cmd/evm/json_logger.go b/cmd/evm/json_logger.go index eb7b0c4660..47daf7dbbc 100644 --- a/cmd/evm/json_logger.go +++ b/cmd/evm/json_logger.go @@ -19,6 +19,7 @@ package main import ( "encoding/json" "io" + "math/big" "time" "github.com/ethereum/go-ethereum/common" @@ -35,6 +36,10 @@ func NewJSONLogger(cfg *vm.LogConfig, writer io.Writer) *JSONLogger { return &JSONLogger{json.NewEncoder(writer), cfg} } +func (l *JSONLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error { + return nil +} + // CaptureState outputs state information on the logger. func (l *JSONLogger) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { log := vm.StructLog{ @@ -56,6 +61,11 @@ func (l *JSONLogger) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cos return l.encoder.Encode(log) } +// CaptureFault outputs state information on the logger. +func (l *JSONLogger) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { + return nil +} + // CaptureEnd is triggered at end of execution. func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { type endLog struct { diff --git a/cmd/faucet/faucet.go b/cmd/faucet/faucet.go index 5f16f2978e..051f9254ce 100644 --- a/cmd/faucet/faucet.go +++ b/cmd/faucet/faucet.go @@ -21,7 +21,6 @@ package main import ( "bytes" - "compress/zlib" "context" "encoding/json" "errors" @@ -474,7 +473,7 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { amount = new(big.Int).Mul(amount, new(big.Int).Exp(big.NewInt(5), big.NewInt(int64(msg.Tier)), nil)) amount = new(big.Int).Div(amount, new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(msg.Tier)), nil)) - tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, big.NewInt(21000), f.price, nil) + tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, 21000, f.price, nil) signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainId) if err != nil { f.lock.Unlock() @@ -698,11 +697,7 @@ func authTwitter(url string) (string, string, common.Address, error) { } defer res.Body.Close() - reader, err := zlib.NewReader(res.Body) - if err != nil { - return "", "", common.Address{}, err - } - body, err := ioutil.ReadAll(reader) + body, err := ioutil.ReadAll(res.Body) if err != nil { return "", "", common.Address{}, err } diff --git a/cmd/geth/consolecmd.go b/cmd/geth/consolecmd.go index 2c6b166875..9d5cc38a1b 100644 --- a/cmd/geth/consolecmd.go +++ b/cmd/geth/consolecmd.go @@ -120,8 +120,12 @@ func remoteConsole(ctx *cli.Context) error { if ctx.GlobalIsSet(utils.DataDirFlag.Name) { path = ctx.GlobalString(utils.DataDirFlag.Name) } - if path != "" && ctx.GlobalBool(utils.TestnetFlag.Name) { - path = filepath.Join(path, "testnet") + if path != "" { + if ctx.GlobalBool(utils.TestnetFlag.Name) { + path = filepath.Join(path, "testnet") + } else if ctx.GlobalBool(utils.RinkebyFlag.Name) { + path = filepath.Join(path, "rinkeby") + } } endpoint = fmt.Sprintf("%s/geth.ipc", path) } diff --git a/cmd/geth/misccmd.go b/cmd/geth/misccmd.go index 2e68dcda32..aa9b1ee568 100644 --- a/cmd/geth/misccmd.go +++ b/cmd/geth/misccmd.go @@ -134,7 +134,6 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License -along with geth. If not, see . -`) +along with geth. If not, see .`) return nil } diff --git a/cmd/puppeth/genesis.go b/cmd/puppeth/genesis.go index 5e36f7fce5..f747f47395 100644 --- a/cmd/puppeth/genesis.go +++ b/cmd/puppeth/genesis.go @@ -44,7 +44,7 @@ type cppEthereumGenesisSpec struct { MaximumExtraDataSize hexutil.Uint64 `json:"maximumExtraDataSize"` MinGasLimit hexutil.Uint64 `json:"minGasLimit"` MaxGasLimit hexutil.Uint64 `json:"maxGasLimit"` - GasLimitBoundDivisor *hexutil.Big `json:"gasLimitBoundDivisor"` + GasLimitBoundDivisor hexutil.Uint64 `json:"gasLimitBoundDivisor"` MinimumDifficulty *hexutil.Big `json:"minimumDifficulty"` DifficultyBoundDivisor *hexutil.Big `json:"difficultyBoundDivisor"` DurationLimit *hexutil.Big `json:"durationLimit"` @@ -107,11 +107,11 @@ func newCppEthereumGenesisSpec(network string, genesis *core.Genesis) (*cppEther spec.Params.ChainID = (hexutil.Uint64)(genesis.Config.ChainId.Uint64()) spec.Params.MaximumExtraDataSize = (hexutil.Uint64)(params.MaximumExtraDataSize) - spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit.Uint64()) + spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit) spec.Params.MaxGasLimit = (hexutil.Uint64)(math.MaxUint64) spec.Params.MinimumDifficulty = (*hexutil.Big)(params.MinimumDifficulty) spec.Params.DifficultyBoundDivisor = (*hexutil.Big)(params.DifficultyBoundDivisor) - spec.Params.GasLimitBoundDivisor = (*hexutil.Big)(params.GasLimitBoundDivisor) + spec.Params.GasLimitBoundDivisor = (hexutil.Uint64)(params.GasLimitBoundDivisor) spec.Params.DurationLimit = (*hexutil.Big)(params.DurationLimit) spec.Params.BlockReward = (*hexutil.Big)(ethash.FrontierBlockReward) @@ -168,26 +168,26 @@ type parityChainSpec struct { Engine struct { Ethash struct { Params struct { - MinimumDifficulty *hexutil.Big `json:"minimumDifficulty"` - DifficultyBoundDivisor *hexutil.Big `json:"difficultyBoundDivisor"` - GasLimitBoundDivisor *hexutil.Big `json:"gasLimitBoundDivisor"` - DurationLimit *hexutil.Big `json:"durationLimit"` - BlockReward *hexutil.Big `json:"blockReward"` - HomesteadTransition uint64 `json:"homesteadTransition"` - EIP150Transition uint64 `json:"eip150Transition"` - EIP160Transition uint64 `json:"eip160Transition"` - EIP161abcTransition uint64 `json:"eip161abcTransition"` - EIP161dTransition uint64 `json:"eip161dTransition"` - EIP649Reward *hexutil.Big `json:"eip649Reward"` - EIP100bTransition uint64 `json:"eip100bTransition"` - EIP649Transition uint64 `json:"eip649Transition"` + MinimumDifficulty *hexutil.Big `json:"minimumDifficulty"` + DifficultyBoundDivisor *hexutil.Big `json:"difficultyBoundDivisor"` + GasLimitBoundDivisor hexutil.Uint64 `json:"gasLimitBoundDivisor"` + DurationLimit *hexutil.Big `json:"durationLimit"` + BlockReward *hexutil.Big `json:"blockReward"` + HomesteadTransition uint64 `json:"homesteadTransition"` + EIP150Transition uint64 `json:"eip150Transition"` + EIP160Transition uint64 `json:"eip160Transition"` + EIP161abcTransition uint64 `json:"eip161abcTransition"` + EIP161dTransition uint64 `json:"eip161dTransition"` + EIP649Reward *hexutil.Big `json:"eip649Reward"` + EIP100bTransition uint64 `json:"eip100bTransition"` + EIP649Transition uint64 `json:"eip649Transition"` } `json:"params"` } `json:"Ethash"` } `json:"engine"` Params struct { MaximumExtraDataSize hexutil.Uint64 `json:"maximumExtraDataSize"` - MinGasLimit *hexutil.Big `json:"minGasLimit"` + MinGasLimit hexutil.Uint64 `json:"minGasLimit"` NetworkID hexutil.Uint64 `json:"networkID"` MaxCodeSize uint64 `json:"maxCodeSize"` EIP155Transition uint64 `json:"eip155Transition"` @@ -270,7 +270,7 @@ func newParityChainSpec(network string, genesis *core.Genesis, bootnodes []strin } spec.Engine.Ethash.Params.MinimumDifficulty = (*hexutil.Big)(params.MinimumDifficulty) spec.Engine.Ethash.Params.DifficultyBoundDivisor = (*hexutil.Big)(params.DifficultyBoundDivisor) - spec.Engine.Ethash.Params.GasLimitBoundDivisor = (*hexutil.Big)(params.GasLimitBoundDivisor) + spec.Engine.Ethash.Params.GasLimitBoundDivisor = (hexutil.Uint64)(params.GasLimitBoundDivisor) spec.Engine.Ethash.Params.DurationLimit = (*hexutil.Big)(params.DurationLimit) spec.Engine.Ethash.Params.BlockReward = (*hexutil.Big)(ethash.FrontierBlockReward) spec.Engine.Ethash.Params.HomesteadTransition = genesis.Config.HomesteadBlock.Uint64() @@ -283,7 +283,7 @@ func newParityChainSpec(network string, genesis *core.Genesis, bootnodes []strin spec.Engine.Ethash.Params.EIP649Transition = genesis.Config.ByzantiumBlock.Uint64() spec.Params.MaximumExtraDataSize = (hexutil.Uint64)(params.MaximumExtraDataSize) - spec.Params.MinGasLimit = (*hexutil.Big)(params.MinGasLimit) + spec.Params.MinGasLimit = (hexutil.Uint64)(params.MinGasLimit) spec.Params.NetworkID = (hexutil.Uint64)(genesis.Config.ChainId.Uint64()) spec.Params.MaxCodeSize = params.MaxCodeSize spec.Params.EIP155Transition = genesis.Config.EIP155Block.Uint64() diff --git a/cmd/puppeth/module_faucet.go b/cmd/puppeth/module_faucet.go index 57b7a2dc07..92b4cb2861 100644 --- a/cmd/puppeth/module_faucet.go +++ b/cmd/puppeth/module_faucet.go @@ -39,6 +39,8 @@ ADD genesis.json /genesis.json ADD account.json /account.json ADD account.pass /account.pass +EXPOSE 8080 30303 30303/udp + ENTRYPOINT [ \ "faucet", "--genesis", "/genesis.json", "--network", "{{.NetworkID}}", "--bootnodes", "{{.Bootnodes}}", "--ethstats", "{{.Ethstats}}", "--ethport", "{{.EthPort}}", \ "--faucet.name", "{{.FaucetName}}", "--faucet.amount", "{{.FaucetAmount}}", "--faucet.minutes", "{{.FaucetMinutes}}", "--faucet.tiers", "{{.FaucetTiers}}", \ diff --git a/cmd/swarm/config.go b/cmd/swarm/config.go index 8b1d87f142..e6a64cd85d 100644 --- a/cmd/swarm/config.go +++ b/cmd/swarm/config.go @@ -326,7 +326,7 @@ func checkDeprecated(ctx *cli.Context) { func printConfig(config *bzzapi.Config) string { out, err := tomlSettings.Marshal(&config) if err != nil { - return (fmt.Sprintf("Something is not right with the configuration: %v", err)) + return fmt.Sprintf("Something is not right with the configuration: %v", err) } return string(out) } diff --git a/cmd/utils/fdlimit_freebsd.go b/cmd/utils/fdlimit_freebsd.go index 4cb5013c84..f9ed8937ee 100644 --- a/cmd/utils/fdlimit_freebsd.go +++ b/cmd/utils/fdlimit_freebsd.go @@ -52,3 +52,13 @@ func getFdLimit() (int, error) { } return int(limit.Cur), nil } + +// getFdMaxLimit retrieves the maximum number of file descriptors this process is +// allowed to request for itself. +func getFdMaxLimit() (int, error) { + var limit syscall.Rlimit + if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { + return 0, err + } + return int(limit.Max), nil +} diff --git a/cmd/utils/fdlimit_test.go b/cmd/utils/fdlimit_test.go index 0a950a6c9d..48489cf4c7 100644 --- a/cmd/utils/fdlimit_test.go +++ b/cmd/utils/fdlimit_test.go @@ -16,12 +16,22 @@ package utils -import "testing" +import ( + "fmt" + "testing" +) // TestFileDescriptorLimits simply tests whether the file descriptor allowance // per this process can be retrieved. func TestFileDescriptorLimits(t *testing.T) { target := 4096 + hardlimit, err := getFdMaxLimit() + if err != nil { + t.Fatal(err) + } + if hardlimit < target { + t.Skip(fmt.Sprintf("system limit is less than desired test target: %d < %d", hardlimit, target)) + } if limit, err := getFdLimit(); err != nil || limit <= 0 { t.Fatalf("failed to retrieve file descriptor limit (%d): %v", limit, err) diff --git a/cmd/utils/fdlimit_unix.go b/cmd/utils/fdlimit_unix.go index 08e153bbd4..c08d1fab08 100644 --- a/cmd/utils/fdlimit_unix.go +++ b/cmd/utils/fdlimit_unix.go @@ -48,3 +48,13 @@ func getFdLimit() (int, error) { } return int(limit.Cur), nil } + +// getFdMaxLimit retrieves the maximum number of file descriptors this process is +// allowed to request for itself. +func getFdMaxLimit() (int, error) { + var limit syscall.Rlimit + if err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &limit); err != nil { + return 0, err + } + return int(limit.Max), nil +} diff --git a/cmd/utils/fdlimit_windows.go b/cmd/utils/fdlimit_windows.go index 53aad3d7a5..f239683d2a 100644 --- a/cmd/utils/fdlimit_windows.go +++ b/cmd/utils/fdlimit_windows.go @@ -39,3 +39,9 @@ func getFdLimit() (int, error) { // Please see raiseFdLimit for the reason why we use hard coded 16K as the limit return 16384, nil } + +// getFdMaxLimit retrieves the maximum number of file descriptors this process is +// allowed to request for itself. +func getFdMaxLimit() (int, error) { + return getFdLimit() +} diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index 30edf199c9..edf3dc2c21 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -96,7 +96,7 @@ func NewApp(gitCommit, usage string) *cli.App { //app.Authors = nil app.Email = "" app.Version = params.Version - if gitCommit != "" { + if len(gitCommit) >= 8 { app.Version += "-" + gitCommit[:8] } app.Usage = usage @@ -313,7 +313,7 @@ var ( TargetGasLimitFlag = cli.Uint64Flag{ Name: "targetgaslimit", Usage: "Target gas limit sets the artificial target gas floor for the blocks to mine", - Value: params.GenesisGasLimit.Uint64(), + Value: params.GenesisGasLimit, } EtherbaseFlag = cli.StringFlag{ Name: "etherbase", @@ -1138,7 +1138,7 @@ func RegisterEthStatsService(stack *node.Node, url string) { // SetupNetwork configures the system for either the main net or some test network. func SetupNetwork(ctx *cli.Context) { // TODO(fjl): move target gas limit into config - params.TargetGasLimit = new(big.Int).SetUint64(ctx.GlobalUint64(TargetGasLimitFlag.Name)) + params.TargetGasLimit = ctx.GlobalUint64(TargetGasLimitFlag.Name) } // MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails. diff --git a/common/bitutil/bitutil.go b/common/bitutil/bitutil.go index 117616543d..cd3e72169f 100644 --- a/common/bitutil/bitutil.go +++ b/common/bitutil/bitutil.go @@ -40,7 +40,7 @@ func fastXORBytes(dst, a, b []byte) int { dw[i] = aw[i] ^ bw[i] } } - for i := (n - n%wordSize); i < n; i++ { + for i := n - n%wordSize; i < n; i++ { dst[i] = a[i] ^ b[i] } return n @@ -84,7 +84,7 @@ func fastANDBytes(dst, a, b []byte) int { dw[i] = aw[i] & bw[i] } } - for i := (n - n%wordSize); i < n; i++ { + for i := n - n%wordSize; i < n; i++ { dst[i] = a[i] & b[i] } return n @@ -128,7 +128,7 @@ func fastORBytes(dst, a, b []byte) int { dw[i] = aw[i] | bw[i] } } - for i := (n - n%wordSize); i < n; i++ { + for i := n - n%wordSize; i < n; i++ { dst[i] = a[i] | b[i] } return n @@ -168,7 +168,7 @@ func fastTestBytes(p []byte) bool { } } } - for i := (n - n%wordSize); i < n; i++ { + for i := n - n%wordSize; i < n; i++ { if p[i] != 0 { return true } diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go index a980581417..2bdad9092a 100644 --- a/consensus/clique/clique.go +++ b/consensus/clique/clique.go @@ -510,7 +510,6 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro header.Nonce = types.BlockNonce{} number := header.Number.Uint64() - // Assemble the voting snapshot to check which votes make sense snap, err := c.snapshot(chain, number-1, header.ParentHash, nil) if err != nil { @@ -538,10 +537,8 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro c.lock.RUnlock() } // Set the correct difficulty - header.Difficulty = diffNoTurn - if snap.inturn(header.Number.Uint64(), c.signer) { - header.Difficulty = diffInTurn - } + header.Difficulty = CalcDifficulty(snap, c.signer) + // Ensure the extra data has all it's components if len(header.Extra) < extraVanity { header.Extra = append(header.Extra, bytes.Repeat([]byte{0x00}, extraVanity-len(header.Extra))...) @@ -655,6 +652,27 @@ func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop <-ch return block.WithSeal(header), nil } +// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty +// that a new block should have based on the previous blocks in the chain and the +// current signer. +func (c *Clique) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int { + snap, err := c.snapshot(chain, parent.Number.Uint64(), parent.Hash(), nil) + if err != nil { + return nil + } + return CalcDifficulty(snap, c.signer) +} + +// CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty +// that a new block should have based on the previous blocks in the chain and the +// current signer. +func CalcDifficulty(snap *Snapshot, signer common.Address) *big.Int { + if snap.inturn(snap.Number+1, signer) { + return new(big.Int).Set(diffInTurn) + } + return new(big.Int).Set(diffNoTurn) +} + // APIs implements consensus.Engine, returning the user facing RPC API to allow // controlling the signer voting. func (c *Clique) APIs(chain consensus.ChainReader) []rpc.API { diff --git a/consensus/consensus.go b/consensus/consensus.go index 865238cee0..be5e661c12 100644 --- a/consensus/consensus.go +++ b/consensus/consensus.go @@ -23,6 +23,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rpc" + "math/big" ) // ChainReader defines a small collection of methods needed to access the local @@ -88,6 +89,10 @@ type Engine interface { // seal place on top. Seal(chain ChainReader, block *types.Block, stop <-chan struct{}) (*types.Block, error) + // CalcDifficulty is the difficulty adjustment algorithm. It returns the difficulty + // that a new block should have. + CalcDifficulty(chain ChainReader, time uint64, parent *types.Header) *big.Int + // APIs returns the RPC APIs this consensus engine provides. APIs(chain ChainReader) []rpc.API } diff --git a/consensus/ethash/algorithm_test.go b/consensus/ethash/algorithm_test.go index 7765ff9fe6..a54f3b582c 100644 --- a/consensus/ethash/algorithm_test.go +++ b/consensus/ethash/algorithm_test.go @@ -688,8 +688,8 @@ func TestConcurrentDiskCacheGeneration(t *testing.T) { TxHash: common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"), ReceiptHash: common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"), Difficulty: big.NewInt(167925187834220), - GasLimit: big.NewInt(4015682), - GasUsed: big.NewInt(0), + GasLimit: 4015682, + GasUsed: 0, Time: big.NewInt(1488928920), Extra: []byte("www.bw.com"), MixDigest: common.HexToHash("0x3e140b0784516af5e5ec6730f2fb20cca22f32be399b9e4ad77d32541f798cd0"), diff --git a/consensus/ethash/consensus.go b/consensus/ethash/consensus.go index 775419e067..0af68c31ab 100644 --- a/consensus/ethash/consensus.go +++ b/consensus/ethash/consensus.go @@ -36,9 +36,10 @@ import ( // Ethash proof-of-work protocol constants. var ( - FrontierBlockReward *big.Int = big.NewInt(5e+18) // Block reward in wei for successfully mining a block - ByzantiumBlockReward *big.Int = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium - maxUncles = 2 // Maximum number of uncles allowed in a single block + FrontierBlockReward *big.Int = big.NewInt(5e+18) // Block reward in wei for successfully mining a block + ByzantiumBlockReward *big.Int = big.NewInt(3e+18) // Block reward in wei for successfully mining a block upward from Byzantium + maxUncles = 2 // Maximum number of uncles allowed in a single block + allowedFutureBlockTime = 15 * time.Second // Max time from current time allowed for blocks, before they're considered future blocks ) // Various error messages to mark blocks invalid. These should be private to @@ -231,7 +232,7 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent * return errLargeBlockTime } } else { - if header.Time.Cmp(big.NewInt(time.Now().Unix())) > 0 { + if header.Time.Cmp(big.NewInt(time.Now().Add(allowedFutureBlockTime).Unix())) > 0 { return consensus.ErrFutureBlock } } @@ -239,29 +240,30 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent * return errZeroBlockTime } // Verify the block's difficulty based in it's timestamp and parent's difficulty - expected := CalcDifficulty(chain.Config(), header.Time.Uint64(), parent) + expected := ethash.CalcDifficulty(chain, header.Time.Uint64(), parent) + if expected.Cmp(header.Difficulty) != 0 { return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected) } // Verify that the gas limit is <= 2^63-1 - if header.GasLimit.Cmp(math.MaxBig63) > 0 { - return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, math.MaxBig63) + cap := uint64(0x7fffffffffffffff) + if header.GasLimit > cap { + return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap) } // Verify that the gasUsed is <= gasLimit - if header.GasUsed.Cmp(header.GasLimit) > 0 { - return fmt.Errorf("invalid gasUsed: have %v, gasLimit %v", header.GasUsed, header.GasLimit) + if header.GasUsed > header.GasLimit { + return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit) } // Verify that the gas limit remains within allowed bounds - diff := new(big.Int).Set(parent.GasLimit) - diff = diff.Sub(diff, header.GasLimit) - diff.Abs(diff) + diff := int64(parent.GasLimit) - int64(header.GasLimit) + if diff < 0 { + diff *= -1 + } + limit := parent.GasLimit / params.GasLimitBoundDivisor - limit := new(big.Int).Set(parent.GasLimit) - limit = limit.Div(limit, params.GasLimitBoundDivisor) - - if diff.Cmp(limit) >= 0 || header.GasLimit.Cmp(params.MinGasLimit) < 0 { - return fmt.Errorf("invalid gas limit: have %v, want %v += %v", header.GasLimit, parent.GasLimit, limit) + if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit { + return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit) } // Verify that the block number is parent's +1 if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 { @@ -286,7 +288,13 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent * // CalcDifficulty is the difficulty adjustment algorithm. It returns // the difficulty that a new block should have when created at time // given the parent block's time and difficulty. -// TODO (karalabe): Move the chain maker into this package and make this private! +func (ethash *Ethash) CalcDifficulty(chain consensus.ChainReader, time uint64, parent *types.Header) *big.Int { + return CalcDifficulty(chain.Config(), time, parent) +} + +// CalcDifficulty is the difficulty adjustment algorithm. It returns +// the difficulty that a new block should have when created at time +// given the parent block's time and difficulty. func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int { next := new(big.Int).Add(parent.Number, big1) switch { @@ -373,7 +381,7 @@ func calcDifficultyByzantium(time uint64, parent *types.Header) *big.Int { // the difficulty that a new block should have when created at time given the // parent block's time and difficulty. The calculation uses the Homestead rules. func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int { - // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.mediawiki + // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.md // algorithm: // diff = (parent_diff + // (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)) @@ -501,8 +509,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header) if parent == nil { return consensus.ErrUnknownAncestor } - header.Difficulty = CalcDifficulty(chain.Config(), header.Time.Uint64(), parent) - + header.Difficulty = ethash.CalcDifficulty(chain, header.Time.Uint64(), parent) return nil } @@ -510,7 +517,7 @@ func (ethash *Ethash) Prepare(chain consensus.ChainReader, header *types.Header) // setting the final state and assembling the block. func (ethash *Ethash) Finalize(chain consensus.ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) { // Accumulate any block and uncle rewards and commit the final state root - AccumulateRewards(chain.Config(), state, header, uncles) + accumulateRewards(chain.Config(), state, header, uncles) header.Root = state.IntermediateRoot(chain.Config().IsEIP158(header.Number)) // Header seems complete, assemble into a block and return @@ -526,8 +533,7 @@ var ( // AccumulateRewards credits the coinbase of the given block with the mining // reward. The total reward consists of the static block reward and rewards for // included uncles. The coinbase of each uncle block is also rewarded. -// TODO (karalabe): Move the chain maker into this package and make this private! -func AccumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) { +func accumulateRewards(config *params.ChainConfig, state *state.StateDB, header *types.Header, uncles []*types.Header) { // Select the correct block reward based on chain progression blockReward := FrontierBlockReward if config.IsByzantium(header.Number) { diff --git a/consensus/ethash/consensus_test.go b/consensus/ethash/consensus_test.go index a58d220efa..438a99dd66 100644 --- a/consensus/ethash/consensus_test.go +++ b/consensus/ethash/consensus_test.go @@ -71,6 +71,7 @@ func TestCalcDifficulty(t *testing.T) { } config := ¶ms.ChainConfig{HomesteadBlock: big.NewInt(1150000)} + for name, test := range tests { number := new(big.Int).Sub(test.CurrentBlocknumber, big.NewInt(1)) diff := CalcDifficulty(config, test.CurrentTimestamp, &types.Header{ diff --git a/console/console.go b/console/console.go index 1ecbfd0b0f..52fe1f542a 100644 --- a/console/console.go +++ b/console/console.go @@ -92,6 +92,9 @@ func New(config Config) (*Console, error) { printer: config.Printer, histPath: filepath.Join(config.DataDir, HistoryFile), } + if err := os.MkdirAll(config.DataDir, 0700); err != nil { + return nil, err + } if err := console.init(config.Preload); err != nil { return nil, err } @@ -423,7 +426,7 @@ func (c *Console) Execute(path string) error { return c.jsre.Exec(path) } -// Stop cleans up the console and terminates the runtime envorinment. +// Stop cleans up the console and terminates the runtime environment. func (c *Console) Stop(graceful bool) error { if err := ioutil.WriteFile(c.histPath, []byte(strings.Join(c.history, "\n")), 0600); err != nil { return err diff --git a/console/prompter.go b/console/prompter.go index ea03694d41..c477b48178 100644 --- a/console/prompter.go +++ b/console/prompter.go @@ -155,8 +155,7 @@ func (p *terminalPrompter) SetHistory(history []string) { p.State.ReadHistory(strings.NewReader(strings.Join(history, "\n"))) } -// AppendHistory appends an entry to the scrollback history. It should be called -// if and only if the prompt to append was a valid command. +// AppendHistory appends an entry to the scrollback history. func (p *terminalPrompter) AppendHistory(command string) { p.State.AppendHistory(command) } diff --git a/containers/docker/develop-alpine/Dockerfile b/containers/docker/develop-alpine/Dockerfile index d239129d53..1f3e1112ec 100644 --- a/containers/docker/develop-alpine/Dockerfile +++ b/containers/docker/develop-alpine/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.5 +FROM alpine:3.7 RUN \ apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ diff --git a/containers/docker/develop-ubuntu/Dockerfile b/containers/docker/develop-ubuntu/Dockerfile index c79becb55a..8c4fe9f595 100644 --- a/containers/docker/develop-ubuntu/Dockerfile +++ b/containers/docker/develop-ubuntu/Dockerfile @@ -1,12 +1,14 @@ FROM ubuntu:xenial +ENV PATH=/usr/lib/go-1.9/bin:$PATH + RUN \ apt-get update && apt-get upgrade -q -y && \ - apt-get install -y --no-install-recommends golang git make gcc libc-dev ca-certificates && \ + apt-get install -y --no-install-recommends golang-1.9 git make gcc libc-dev ca-certificates && \ git clone --depth 1 https://github.com/ethereum/go-ethereum && \ (cd go-ethereum && make geth) && \ cp go-ethereum/build/bin/geth /geth && \ - apt-get remove -y golang git make gcc libc-dev && apt autoremove -y && apt-get clean && \ + apt-get remove -y golang-1.9 git make gcc libc-dev && apt autoremove -y && apt-get clean && \ rm -rf /go-ethereum EXPOSE 8545 diff --git a/containers/docker/master-alpine/Dockerfile b/containers/docker/master-alpine/Dockerfile index 44402361d7..c7b71c7263 100644 --- a/containers/docker/master-alpine/Dockerfile +++ b/containers/docker/master-alpine/Dockerfile @@ -1,4 +1,4 @@ -FROM alpine:3.5 +FROM alpine:3.7 RUN \ apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ diff --git a/containers/docker/master-ubuntu/Dockerfile b/containers/docker/master-ubuntu/Dockerfile index cc4fad10c4..bba70abfdd 100644 --- a/containers/docker/master-ubuntu/Dockerfile +++ b/containers/docker/master-ubuntu/Dockerfile @@ -1,12 +1,14 @@ FROM ubuntu:xenial +ENV PATH=/usr/lib/go-1.9/bin:$PATH + RUN \ apt-get update && apt-get upgrade -q -y && \ - apt-get install -y --no-install-recommends golang git make gcc libc-dev ca-certificates && \ + apt-get install -y --no-install-recommends golang-1.9 git make gcc libc-dev ca-certificates && \ git clone --depth 1 --branch release/1.7 https://github.com/ethereum/go-ethereum && \ (cd go-ethereum && make geth) && \ cp go-ethereum/build/bin/geth /geth && \ - apt-get remove -y golang git make gcc libc-dev && apt autoremove -y && apt-get clean && \ + apt-get remove -y golang-1.9 git make gcc libc-dev && apt autoremove -y && apt-get clean && \ rm -rf /go-ethereum EXPOSE 8545 diff --git a/contracts/chequebook/cheque.go b/contracts/chequebook/cheque.go index 09daa92484..f6335adc65 100644 --- a/contracts/chequebook/cheque.go +++ b/contracts/chequebook/cheque.go @@ -56,8 +56,8 @@ import ( // * watching incoming ether var ( - gasToCash = big.NewInt(2000000) // gas cost of a cash transaction using chequebook - // gasToDeploy = big.NewInt(3000000) + gasToCash = uint64(2000000) // gas cost of a cash transaction using chequebook + // gasToDeploy = uint64(3000000) ) // Backend wraps all methods required for chequebook operation. diff --git a/contracts/ens/ens.go b/contracts/ens/ens.go index c292a1714a..60c3c83ab0 100644 --- a/contracts/ens/ens.go +++ b/contracts/ens/ens.go @@ -19,7 +19,6 @@ package ens //go:generate abigen --sol contract/ens.sol --pkg contract --out contract/ens.go import ( - "math/big" "strings" "github.com/ethereum/go-ethereum/accounts/abi/bind" @@ -163,7 +162,7 @@ func (self *ENS) Register(name string) (*types.Transaction, error) { } opts := self.TransactOpts - opts.GasLimit = big.NewInt(200000) + opts.GasLimit = 200000 return registrar.Contract.Register(&opts, label, self.TransactOpts.From) } @@ -178,6 +177,6 @@ func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transacti } opts := self.TransactOpts - opts.GasLimit = big.NewInt(200000) + opts.GasLimit = 200000 return resolver.Contract.SetContent(&opts, node, hash) } diff --git a/contracts/ens/ens_test.go b/contracts/ens/ens_test.go index 5faa9b1ad4..9ab1375813 100644 --- a/contracts/ens/ens_test.go +++ b/contracts/ens/ens_test.go @@ -37,7 +37,7 @@ func TestENS(t *testing.T) { contractBackend := backends.NewSimulatedBackend(core.GenesisAlloc{addr: {Balance: big.NewInt(1000000000)}}) transactOpts := bind.NewKeyedTransactor(key) // Workaround for bug estimating gas in the call to Register - transactOpts.GasLimit = big.NewInt(1000000) + transactOpts.GasLimit = 1000000 ens, err := DeployENS(transactOpts, contractBackend) if err != nil { diff --git a/contracts/release/release.go b/contracts/release/release.go index 28a35381d4..4442ce3e0d 100644 --- a/contracts/release/release.go +++ b/contracts/release/release.go @@ -137,7 +137,7 @@ func (r *ReleaseService) checkVersion() { if err != nil { if err == bind.ErrNoCode { log.Debug("Release oracle not found", "contract", r.config.Oracle) - } else { + } else if err != les.ErrNoPeers { log.Error("Failed to retrieve current release", "err", err) } return diff --git a/core/bench_test.go b/core/bench_test.go index ab25c27d39..f976331d17 100644 --- a/core/bench_test.go +++ b/core/bench_test.go @@ -84,7 +84,7 @@ func genValueTx(nbytes int) func(int, *BlockGen) { return func(i int, gen *BlockGen) { toaddr := common.Address{} data := make([]byte, nbytes) - gas := IntrinsicGas(data, false, false) + gas, _ := IntrinsicGas(data, false, false) tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(benchRootAddr), toaddr, big.NewInt(1), gas, nil, data), types.HomesteadSigner{}, benchRootKey) gen.AddTx(tx) } @@ -93,7 +93,6 @@ func genValueTx(nbytes int) func(int, *BlockGen) { var ( ringKeys = make([]*ecdsa.PrivateKey, 1000) ringAddrs = make([]common.Address, len(ringKeys)) - bigTxGas = new(big.Int).SetUint64(params.TxGas) ) func init() { @@ -113,8 +112,8 @@ func genTxRing(naccounts int) func(int, *BlockGen) { return func(i int, gen *BlockGen) { gas := CalcGasLimit(gen.PrevBlock(i - 1)) for { - gas.Sub(gas, bigTxGas) - if gas.Cmp(bigTxGas) < 0 { + gas -= params.TxGas + if gas < params.TxGas { break } to := (from + 1) % naccounts @@ -122,7 +121,7 @@ func genTxRing(naccounts int) func(int, *BlockGen) { gen.TxNonce(ringAddrs[from]), ringAddrs[to], benchRootFunds, - bigTxGas, + params.TxGas, nil, nil, ) @@ -170,7 +169,7 @@ func benchInsertChain(b *testing.B, disk bool, gen func(int, *BlockGen)) { Alloc: GenesisAlloc{benchRootAddr: {Balance: benchRootFunds}}, } genesis := gspec.MustCommit(db) - chain, _ := GenerateChain(gspec.Config, genesis, db, b.N, gen) + chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, b.N, gen) // Time the insertion of the new chain. // State and blocks are stored in the same DB. diff --git a/core/block_validator.go b/core/block_validator.go index e9cfd04827..143728bb84 100644 --- a/core/block_validator.go +++ b/core/block_validator.go @@ -18,9 +18,7 @@ package core import ( "fmt" - "math/big" - "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -76,10 +74,10 @@ func (v *BlockValidator) ValidateBody(block *types.Block) error { // transition, such as amount of used gas, the receipt roots and the state root // itself. ValidateState returns a database batch if the validation was a success // otherwise nil and an error is returned. -func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas *big.Int) error { +func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *state.StateDB, receipts types.Receipts, usedGas uint64) error { header := block.Header() - if block.GasUsed().Cmp(usedGas) != 0 { - return fmt.Errorf("invalid gas used (remote: %v local: %v)", block.GasUsed(), usedGas) + if block.GasUsed() != usedGas { + return fmt.Errorf("invalid gas used (remote: %d local: %d)", block.GasUsed(), usedGas) } // Validate the received block's bloom with the one derived from the generated receipts. // For valid blocks this should always validate to true. @@ -101,17 +99,13 @@ func (v *BlockValidator) ValidateState(block, parent *types.Block, statedb *stat } // CalcGasLimit computes the gas limit of the next block after parent. -// The result may be modified by the caller. // This is miner strategy, not consensus protocol. -func CalcGasLimit(parent *types.Block) *big.Int { +func CalcGasLimit(parent *types.Block) uint64 { // contrib = (parentGasUsed * 3 / 2) / 1024 - contrib := new(big.Int).Mul(parent.GasUsed(), big.NewInt(3)) - contrib = contrib.Div(contrib, big.NewInt(2)) - contrib = contrib.Div(contrib, params.GasLimitBoundDivisor) + contrib := (parent.GasUsed() + parent.GasUsed()/2) / params.GasLimitBoundDivisor // decay = parentGasLimit / 1024 -1 - decay := new(big.Int).Div(parent.GasLimit(), params.GasLimitBoundDivisor) - decay.Sub(decay, big.NewInt(1)) + decay := parent.GasLimit()/params.GasLimitBoundDivisor - 1 /* strategy: gasLimit of block-to-mine is set based on parent's @@ -120,15 +114,17 @@ func CalcGasLimit(parent *types.Block) *big.Int { at that usage) the amount increased/decreased depends on how far away from parentGasLimit * (2/3) parentGasUsed is. */ - gl := new(big.Int).Sub(parent.GasLimit(), decay) - gl = gl.Add(gl, contrib) - gl.Set(math.BigMax(gl, params.MinGasLimit)) - + limit := parent.GasLimit() - decay + contrib + if limit < params.MinGasLimit { + limit = params.MinGasLimit + } // however, if we're now below the target (TargetGasLimit) we increase the // limit as much as we can (parentGasLimit / 1024 -1) - if gl.Cmp(params.TargetGasLimit) < 0 { - gl.Add(parent.GasLimit(), decay) - gl.Set(math.BigMin(gl, params.TargetGasLimit)) + if limit < params.TargetGasLimit { + limit = parent.GasLimit() + decay + if limit > params.TargetGasLimit { + limit = params.TargetGasLimit + } } - return gl + return limit } diff --git a/core/block_validator_test.go b/core/block_validator_test.go index 6d54c2b932..e668601f38 100644 --- a/core/block_validator_test.go +++ b/core/block_validator_test.go @@ -35,7 +35,7 @@ func TestHeaderVerification(t *testing.T) { testdb, _ = ethdb.NewMemDatabase() gspec = &Genesis{Config: params.TestChainConfig} genesis = gspec.MustCommit(testdb) - blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil) + blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 8, nil) ) headers := make([]*types.Header, len(blocks)) for i, block := range blocks { @@ -87,7 +87,7 @@ func testHeaderConcurrentVerification(t *testing.T, threads int) { testdb, _ = ethdb.NewMemDatabase() gspec = &Genesis{Config: params.TestChainConfig} genesis = gspec.MustCommit(testdb) - blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 8, nil) + blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 8, nil) ) headers := make([]*types.Header, len(blocks)) seals := make([]bool, len(blocks)) @@ -159,7 +159,7 @@ func testHeaderConcurrentAbortion(t *testing.T, threads int) { testdb, _ = ethdb.NewMemDatabase() gspec = &Genesis{Config: params.TestChainConfig} genesis = gspec.MustCommit(testdb) - blocks, _ = GenerateChain(params.TestChainConfig, genesis, testdb, 1024, nil) + blocks, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), testdb, 1024, nil) ) headers := make([]*types.Header, len(blocks)) seals := make([]bool, len(blocks)) diff --git a/core/blockchain.go b/core/blockchain.go index 325753c7a7..737fbe3eee 100644 --- a/core/blockchain.go +++ b/core/blockchain.go @@ -305,7 +305,7 @@ func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error { } // GasLimit returns the gas limit of the current HEAD block. -func (bc *BlockChain) GasLimit() *big.Int { +func (bc *BlockChain) GasLimit() uint64 { bc.mu.RLock() defer bc.mu.RUnlock() @@ -677,9 +677,9 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty } // The used gas can be calculated based on previous receipts if j == 0 { - receipts[j].GasUsed = new(big.Int).Set(receipts[j].CumulativeGasUsed) + receipts[j].GasUsed = receipts[j].CumulativeGasUsed } else { - receipts[j].GasUsed = new(big.Int).Sub(receipts[j].CumulativeGasUsed, receipts[j-1].CumulativeGasUsed) + receipts[j].GasUsed = receipts[j].CumulativeGasUsed - receipts[j-1].CumulativeGasUsed } // The derived log fields can simply be set from the block and transaction for k := 0; k < len(receipts[j].Logs); k++ { @@ -1002,7 +1002,7 @@ func (bc *BlockChain) insertChain(chain types.Blocks) (int, []interface{}, []*ty events = append(events, ChainSideEvent{block}) } stats.processed++ - stats.usedGas += usedGas.Uint64() + stats.usedGas += usedGas stats.report(chain, i) } // Append a single chain head event if we've progressed the chain @@ -1196,10 +1196,11 @@ func (bc *BlockChain) PostChainEvents(events []interface{}, logs []*types.Log) { } func (bc *BlockChain) update() { - futureTimer := time.Tick(5 * time.Second) + futureTimer := time.NewTicker(5 * time.Second) + defer futureTimer.Stop() for { select { - case <-futureTimer: + case <-futureTimer.C: bc.procFutureBlocks() case <-bc.quit: return diff --git a/core/blockchain_test.go b/core/blockchain_test.go index cb1df8d4b0..26c816027f 100644 --- a/core/blockchain_test.go +++ b/core/blockchain_test.go @@ -57,7 +57,7 @@ func newTestBlockChain(fake bool) *BlockChain { // Test fork of length N starting from block i func testFork(t *testing.T, blockchain *BlockChain, i, n int, full bool, comparator func(td1, td2 *big.Int)) { // Copy old chain up to #i into a new db - db, blockchain2, err := newCanonical(i, full) + db, blockchain2, err := newCanonical(ethash.NewFaker(), i, full) if err != nil { t.Fatal("could not make new canonical in testFork", err) } @@ -81,12 +81,12 @@ func testFork(t *testing.T, blockchain *BlockChain, i, n int, full bool, compara headerChainB []*types.Header ) if full { - blockChainB = makeBlockChain(blockchain2.CurrentBlock(), n, db, forkSeed) + blockChainB = makeBlockChain(blockchain2.CurrentBlock(), n, ethash.NewFaker(), db, forkSeed) if _, err := blockchain2.InsertChain(blockChainB); err != nil { t.Fatalf("failed to insert forking chain: %v", err) } } else { - headerChainB = makeHeaderChain(blockchain2.CurrentHeader(), n, db, forkSeed) + headerChainB = makeHeaderChain(blockchain2.CurrentHeader(), n, ethash.NewFaker(), db, forkSeed) if _, err := blockchain2.InsertHeaderChain(headerChainB, 1); err != nil { t.Fatalf("failed to insert forking chain: %v", err) } @@ -186,7 +186,7 @@ func TestLastBlock(t *testing.T) { bchain := newTestBlockChain(false) defer bchain.Stop() - block := makeBlockChain(bchain.CurrentBlock(), 1, bchain.chainDb, 0)[0] + block := makeBlockChain(bchain.CurrentBlock(), 1, ethash.NewFaker(), bchain.chainDb, 0)[0] bchain.insert(block) if block.Hash() != GetHeadBlockHash(bchain.chainDb) { t.Errorf("Write/Get HeadBlockHash failed") @@ -202,7 +202,7 @@ func testExtendCanonical(t *testing.T, full bool) { length := 5 // Make first chain starting from genesis - _, processor, err := newCanonical(length, full) + _, processor, err := newCanonical(ethash.NewFaker(), length, full) if err != nil { t.Fatalf("failed to make new canonical chain: %v", err) } @@ -230,7 +230,7 @@ func testShorterFork(t *testing.T, full bool) { length := 10 // Make first chain starting from genesis - _, processor, err := newCanonical(length, full) + _, processor, err := newCanonical(ethash.NewFaker(), length, full) if err != nil { t.Fatalf("failed to make new canonical chain: %v", err) } @@ -260,7 +260,7 @@ func testLongerFork(t *testing.T, full bool) { length := 10 // Make first chain starting from genesis - _, processor, err := newCanonical(length, full) + _, processor, err := newCanonical(ethash.NewFaker(), length, full) if err != nil { t.Fatalf("failed to make new canonical chain: %v", err) } @@ -290,7 +290,7 @@ func testEqualFork(t *testing.T, full bool) { length := 10 // Make first chain starting from genesis - _, processor, err := newCanonical(length, full) + _, processor, err := newCanonical(ethash.NewFaker(), length, full) if err != nil { t.Fatalf("failed to make new canonical chain: %v", err) } @@ -317,7 +317,7 @@ func TestBrokenBlockChain(t *testing.T) { testBrokenChain(t, true) } func testBrokenChain(t *testing.T, full bool) { // Make chain starting from genesis - db, blockchain, err := newCanonical(10, full) + db, blockchain, err := newCanonical(ethash.NewFaker(), 10, full) if err != nil { t.Fatalf("failed to make new canonical chain: %v", err) } @@ -325,12 +325,12 @@ func testBrokenChain(t *testing.T, full bool) { // Create a forked chain, and try to insert with a missing link if full { - chain := makeBlockChain(blockchain.CurrentBlock(), 5, db, forkSeed)[1:] + chain := makeBlockChain(blockchain.CurrentBlock(), 5, ethash.NewFaker(), db, forkSeed)[1:] if err := testBlockChainImport(chain, blockchain); err == nil { t.Errorf("broken block chain not reported") } } else { - chain := makeHeaderChain(blockchain.CurrentHeader(), 5, db, forkSeed)[1:] + chain := makeHeaderChain(blockchain.CurrentHeader(), 5, ethash.NewFaker(), db, forkSeed)[1:] if err := testHeaderChainImport(chain, blockchain); err == nil { t.Errorf("broken header chain not reported") } @@ -340,11 +340,11 @@ func testBrokenChain(t *testing.T, full bool) { type bproc struct{} func (bproc) ValidateBody(*types.Block) error { return nil } -func (bproc) ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error { +func (bproc) ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas uint64) error { return nil } -func (bproc) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) { - return nil, nil, new(big.Int), nil +func (bproc) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { + return nil, nil, 0, nil } func makeHeaderChainWithDiff(genesis *types.Block, d []int, seed byte) []*types.Header { @@ -506,8 +506,8 @@ func testReorgBadHashes(t *testing.T, full bool) { if ncm.CurrentBlock().Hash() != blocks[2].Header().Hash() { t.Errorf("last block hash mismatch: have: %x, want %x", ncm.CurrentBlock().Hash(), blocks[2].Header().Hash()) } - if blocks[2].Header().GasLimit.Cmp(ncm.GasLimit()) != 0 { - t.Errorf("last block gasLimit mismatch: have: %x, want %x", ncm.GasLimit(), blocks[2].Header().GasLimit) + if blocks[2].Header().GasLimit != ncm.GasLimit() { + t.Errorf("last block gasLimit mismatch: have: %d, want %d", ncm.GasLimit(), blocks[2].Header().GasLimit) } } else { if ncm.CurrentHeader().Hash() != headers[2].Hash() { @@ -523,7 +523,7 @@ func TestBlocksInsertNonceError(t *testing.T) { testInsertNonceError(t, true) } func testInsertNonceError(t *testing.T, full bool) { for i := 1; i < 25 && !t.Failed(); i++ { // Create a pristine chain and database - db, blockchain, err := newCanonical(0, full) + db, blockchain, err := newCanonical(ethash.NewFaker(), 0, full) if err != nil { t.Fatalf("failed to create pristine chain: %v", err) } @@ -536,7 +536,7 @@ func testInsertNonceError(t *testing.T, full bool) { failNum uint64 ) if full { - blocks := makeBlockChain(blockchain.CurrentBlock(), i, db, 0) + blocks := makeBlockChain(blockchain.CurrentBlock(), i, ethash.NewFaker(), db, 0) failAt = rand.Int() % len(blocks) failNum = blocks[failAt].NumberU64() @@ -544,7 +544,7 @@ func testInsertNonceError(t *testing.T, full bool) { blockchain.engine = ethash.NewFakeFailer(failNum) failRes, err = blockchain.InsertChain(blocks) } else { - headers := makeHeaderChain(blockchain.CurrentHeader(), i, db, 0) + headers := makeHeaderChain(blockchain.CurrentHeader(), i, ethash.NewFaker(), db, 0) failAt = rand.Int() % len(headers) failNum = headers[failAt].Number.Uint64() @@ -588,13 +588,13 @@ func TestFastVsFullChains(t *testing.T) { genesis = gspec.MustCommit(gendb) signer = types.NewEIP155Signer(gspec.Config.ChainId) ) - blocks, receipts := GenerateChain(gspec.Config, genesis, gendb, 1024, func(i int, block *BlockGen) { + blocks, receipts := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, 1024, func(i int, block *BlockGen) { block.SetCoinbase(common.Address{0x00}) // If the block number is multiple of 3, send a few bonus transactions to the miner if i%3 == 2 { for j := 0; j < i%4+1; j++ { - tx, err := types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), bigTxGas, nil, nil), signer, key) + tx, err := types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{0x00}, big.NewInt(1000), params.TxGas, nil, nil), signer, key) if err != nil { panic(err) } @@ -673,7 +673,7 @@ func TestLightVsFastVsFullChainHeads(t *testing.T) { genesis = gspec.MustCommit(gendb) ) height := uint64(1024) - blocks, receipts := GenerateChain(gspec.Config, genesis, gendb, int(height), nil) + blocks, receipts := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), gendb, int(height), nil) // Configure a subchain to roll back remove := []common.Hash{} @@ -767,8 +767,8 @@ func TestChainTxReorgs(t *testing.T) { // Create two transactions shared between the chains: // - postponed: transaction included at a later block in the forked chain // - swapped: transaction included at the same block number in the forked chain - postponed, _ := types.SignTx(types.NewTransaction(0, addr1, big.NewInt(1000), bigTxGas, nil, nil), signer, key1) - swapped, _ := types.SignTx(types.NewTransaction(1, addr1, big.NewInt(1000), bigTxGas, nil, nil), signer, key1) + postponed, _ := types.SignTx(types.NewTransaction(0, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1) + swapped, _ := types.SignTx(types.NewTransaction(1, addr1, big.NewInt(1000), params.TxGas, nil, nil), signer, key1) // Create two transactions that will be dropped by the forked chain: // - pastDrop: transaction dropped retroactively from a past block @@ -781,16 +781,16 @@ func TestChainTxReorgs(t *testing.T) { // - futureAdd: transaction added after the reorg has already finished var pastAdd, freshAdd, futureAdd *types.Transaction - chain, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, gen *BlockGen) { + chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) { switch i { case 0: - pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key2) + pastDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2) gen.AddTx(pastDrop) // This transaction will be dropped in the fork from below the split point gen.AddTx(postponed) // This transaction will be postponed till block #3 in the fork case 2: - freshDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key2) + freshDrop, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key2) gen.AddTx(freshDrop) // This transaction will be dropped in the fork from exactly at the split point gen.AddTx(swapped) // This transaction will be swapped out at the exact height @@ -806,21 +806,21 @@ func TestChainTxReorgs(t *testing.T) { defer blockchain.Stop() // overwrite the old chain - chain, _ = GenerateChain(gspec.Config, genesis, db, 5, func(i int, gen *BlockGen) { + chain, _ = GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 5, func(i int, gen *BlockGen) { switch i { case 0: - pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3) + pastAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3) gen.AddTx(pastAdd) // This transaction needs to be injected during reorg case 2: gen.AddTx(postponed) // This transaction was postponed from block #1 in the original chain gen.AddTx(swapped) // This transaction was swapped from the exact current spot in the original chain - freshAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3) + freshAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3) gen.AddTx(freshAdd) // This transaction will be added exactly at reorg time case 3: - futureAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key3) + futureAdd, _ = types.SignTx(types.NewTransaction(gen.TxNonce(addr3), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key3) gen.AddTx(futureAdd) // This transaction will be added after a full reorg } }) @@ -875,9 +875,9 @@ func TestLogReorgs(t *testing.T) { rmLogsCh := make(chan RemovedLogsEvent) blockchain.SubscribeRemovedLogsEvent(rmLogsCh) - chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 2, func(i int, gen *BlockGen) { + chain, _ := GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 2, func(i int, gen *BlockGen) { if i == 1 { - tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), code), signer, key1) + tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), 1000000, new(big.Int), code), signer, key1) if err != nil { t.Fatalf("failed to create tx: %v", err) } @@ -888,7 +888,7 @@ func TestLogReorgs(t *testing.T) { t.Fatalf("failed to insert chain: %v", err) } - chain, _ = GenerateChain(params.TestChainConfig, genesis, db, 3, func(i int, gen *BlockGen) {}) + chain, _ = GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) {}) if _, err := blockchain.InsertChain(chain); err != nil { t.Fatalf("failed to insert forked chain: %v", err) } @@ -920,13 +920,13 @@ func TestReorgSideEvent(t *testing.T) { blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{}) defer blockchain.Stop() - chain, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, gen *BlockGen) {}) + chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, gen *BlockGen) {}) if _, err := blockchain.InsertChain(chain); err != nil { t.Fatalf("failed to insert chain: %v", err) } - replacementBlocks, _ := GenerateChain(gspec.Config, genesis, db, 4, func(i int, gen *BlockGen) { - tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), big.NewInt(1000000), new(big.Int), nil), signer, key1) + replacementBlocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 4, func(i int, gen *BlockGen) { + tx, err := types.SignTx(types.NewContractCreation(gen.TxNonce(addr1), new(big.Int), 1000000, new(big.Int), nil), signer, key1) if i == 2 { gen.OffsetTime(-9) } @@ -992,7 +992,7 @@ func TestCanonicalBlockRetrieval(t *testing.T) { bc := newTestBlockChain(true) defer bc.Stop() - chain, _ := GenerateChain(bc.config, bc.genesisBlock, bc.chainDb, 10, func(i int, gen *BlockGen) {}) + chain, _ := GenerateChain(bc.config, bc.genesisBlock, ethash.NewFaker(), bc.chainDb, 10, func(i int, gen *BlockGen) {}) var pend sync.WaitGroup pend.Add(len(chain)) @@ -1046,12 +1046,12 @@ func TestEIP155Transition(t *testing.T) { blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{}) defer blockchain.Stop() - blocks, _ := GenerateChain(gspec.Config, genesis, db, 4, func(i int, block *BlockGen) { + blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 4, func(i int, block *BlockGen) { var ( tx *types.Transaction err error basicTx = func(signer types.Signer) (*types.Transaction, error) { - return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key) + return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), 21000, new(big.Int), nil), signer, key) } ) switch i { @@ -1109,12 +1109,12 @@ func TestEIP155Transition(t *testing.T) { // generate an invalid chain id transaction config := ¶ms.ChainConfig{ChainId: big.NewInt(2), EIP155Block: big.NewInt(2), HomesteadBlock: new(big.Int)} - blocks, _ = GenerateChain(config, blocks[len(blocks)-1], db, 4, func(i int, block *BlockGen) { + blocks, _ = GenerateChain(config, blocks[len(blocks)-1], ethash.NewFaker(), db, 4, func(i int, block *BlockGen) { var ( tx *types.Transaction err error basicTx = func(signer types.Signer) (*types.Transaction, error) { - return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key) + return types.SignTx(types.NewTransaction(block.TxNonce(address), common.Address{}, new(big.Int), 21000, new(big.Int), nil), signer, key) } ) switch i { @@ -1154,7 +1154,7 @@ func TestEIP161AccountRemoval(t *testing.T) { blockchain, _ := NewBlockChain(db, gspec.Config, ethash.NewFaker(), vm.Config{}) defer blockchain.Stop() - blocks, _ := GenerateChain(gspec.Config, genesis, db, 3, func(i int, block *BlockGen) { + blocks, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 3, func(i int, block *BlockGen) { var ( tx *types.Transaction err error @@ -1162,11 +1162,11 @@ func TestEIP161AccountRemoval(t *testing.T) { ) switch i { case 0: - tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key) + tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key) case 1: - tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key) + tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key) case 2: - tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), big.NewInt(21000), new(big.Int), nil), signer, key) + tx, err = types.SignTx(types.NewTransaction(block.TxNonce(address), theAddr, new(big.Int), 21000, new(big.Int), nil), signer, key) } if err != nil { t.Fatal(err) diff --git a/core/chain_makers.go b/core/chain_makers.go index 59af633dfd..5e264a9942 100644 --- a/core/chain_makers.go +++ b/core/chain_makers.go @@ -21,7 +21,7 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/consensus/ethash" + "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -39,11 +39,12 @@ var ( // BlockGen creates blocks for testing. // See GenerateChain for a detailed explanation. type BlockGen struct { - i int - parent *types.Block - chain []*types.Block - header *types.Header - statedb *state.StateDB + i int + parent *types.Block + chain []*types.Block + chainReader consensus.ChainReader + header *types.Header + statedb *state.StateDB gasPool *GasPool txs []*types.Transaction @@ -51,6 +52,7 @@ type BlockGen struct { uncles []*types.Header config *params.ChainConfig + engine consensus.Engine } // SetCoinbase sets the coinbase of the generated block. @@ -84,7 +86,7 @@ func (b *BlockGen) AddTx(tx *types.Transaction) { b.SetCoinbase(common.Address{}) } b.statedb.Prepare(tx.Hash(), common.Hash{}, len(b.txs)) - receipt, _, err := ApplyTransaction(b.config, nil, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, b.header.GasUsed, vm.Config{}) + receipt, _, err := ApplyTransaction(b.config, nil, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{}) if err != nil { panic(err) } @@ -141,7 +143,7 @@ func (b *BlockGen) OffsetTime(seconds int64) { if b.header.Time.Cmp(b.parent.Header().Time) <= 0 { panic("block time out of range") } - b.header.Difficulty = ethash.CalcDifficulty(b.config, b.header.Time.Uint64(), b.parent.Header()) + b.header.Difficulty = b.engine.CalcDifficulty(b.chainReader, b.header.Time.Uint64(), b.parent.Header()) } // GenerateChain creates a chain of n blocks. The first block's @@ -156,44 +158,54 @@ func (b *BlockGen) OffsetTime(seconds int64) { // Blocks created by GenerateChain do not contain valid proof of work // values. Inserting them into BlockChain requires use of FakePow or // a similar non-validating proof of work implementation. -func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) { +func GenerateChain(config *params.ChainConfig, parent *types.Block, engine consensus.Engine, db ethdb.Database, n int, gen func(int, *BlockGen)) ([]*types.Block, []types.Receipts) { if config == nil { config = params.TestChainConfig } blocks, receipts := make(types.Blocks, n), make([]types.Receipts, n) - genblock := func(i int, h *types.Header, statedb *state.StateDB) (*types.Block, types.Receipts) { - b := &BlockGen{parent: parent, i: i, chain: blocks, header: h, statedb: statedb, config: config} + genblock := func(i int, parent *types.Block, statedb *state.StateDB) (*types.Block, types.Receipts) { + // TODO(karalabe): This is needed for clique, which depends on multiple blocks. + // It's nonetheless ugly to spin up a blockchain here. Get rid of this somehow. + blockchain, _ := NewBlockChain(db, config, engine, vm.Config{}) + defer blockchain.Stop() + + b := &BlockGen{i: i, parent: parent, chain: blocks, chainReader: blockchain, statedb: statedb, config: config, engine: engine} + b.header = makeHeader(b.chainReader, parent, statedb, b.engine) + // Mutate the state and block according to any hard-fork specs if daoBlock := config.DAOForkBlock; daoBlock != nil { limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange) - if h.Number.Cmp(daoBlock) >= 0 && h.Number.Cmp(limit) < 0 { + if b.header.Number.Cmp(daoBlock) >= 0 && b.header.Number.Cmp(limit) < 0 { if config.DAOForkSupport { - h.Extra = common.CopyBytes(params.DAOForkBlockExtra) + b.header.Extra = common.CopyBytes(params.DAOForkBlockExtra) } } } - if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(h.Number) == 0 { + if config.DAOForkSupport && config.DAOForkBlock != nil && config.DAOForkBlock.Cmp(b.header.Number) == 0 { misc.ApplyDAOHardFork(statedb) } // Execute any user modifications to the block and finalize it if gen != nil { gen(i, b) } - ethash.AccumulateRewards(config, statedb, h, b.uncles) - root, err := statedb.CommitTo(db, config.IsEIP158(h.Number)) - if err != nil { - panic(fmt.Sprintf("state write error: %v", err)) + + if b.engine != nil { + block, _ := b.engine.Finalize(b.chainReader, b.header, statedb, b.txs, b.uncles, b.receipts) + // Write state changes to db + _, err := statedb.CommitTo(db, config.IsEIP158(b.header.Number)) + if err != nil { + panic(fmt.Sprintf("state write error: %v", err)) + } + return block, b.receipts } - h.Root = root - return types.NewBlock(h, b.txs, b.uncles, b.receipts), b.receipts + return nil, nil } for i := 0; i < n; i++ { statedb, err := state.New(parent.Root(), state.NewDatabase(db)) if err != nil { panic(err) } - header := makeHeader(config, parent, statedb) - block, receipt := genblock(i, header, statedb) + block, receipt := genblock(i, parent, statedb) blocks[i] = block receipts[i] = receipt parent = block @@ -201,7 +213,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat return blocks, receipts } -func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.StateDB) *types.Header { +func makeHeader(chain consensus.ChainReader, parent *types.Block, state *state.StateDB, engine consensus.Engine) *types.Header { var time *big.Int if parent.Time() == nil { time = big.NewInt(10) @@ -210,17 +222,16 @@ func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.St } return &types.Header{ - Root: state.IntermediateRoot(config.IsEIP158(parent.Number())), + Root: state.IntermediateRoot(chain.Config().IsEIP158(parent.Number())), ParentHash: parent.Hash(), Coinbase: parent.Coinbase(), - Difficulty: ethash.CalcDifficulty(config, time.Uint64(), &types.Header{ + Difficulty: engine.CalcDifficulty(chain, time.Uint64(), &types.Header{ Number: parent.Number(), Time: new(big.Int).Sub(time, big.NewInt(10)), Difficulty: parent.Difficulty(), UncleHash: parent.UncleHash(), }), GasLimit: CalcGasLimit(parent), - GasUsed: new(big.Int), Number: new(big.Int).Add(parent.Number(), common.Big1), Time: time, } @@ -229,32 +240,32 @@ func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.St // newCanonical creates a chain database, and injects a deterministic canonical // chain. Depending on the full flag, if creates either a full block chain or a // header only chain. -func newCanonical(n int, full bool) (ethdb.Database, *BlockChain, error) { +func newCanonical(engine consensus.Engine, n int, full bool) (ethdb.Database, *BlockChain, error) { // Initialize a fresh chain with only a genesis block gspec := new(Genesis) db, _ := ethdb.NewMemDatabase() genesis := gspec.MustCommit(db) - blockchain, _ := NewBlockChain(db, params.AllEthashProtocolChanges, ethash.NewFaker(), vm.Config{}) + blockchain, _ := NewBlockChain(db, params.AllEthashProtocolChanges, engine, vm.Config{}) // Create and inject the requested chain if n == 0 { return db, blockchain, nil } if full { // Full block-chain requested - blocks := makeBlockChain(genesis, n, db, canonicalSeed) + blocks := makeBlockChain(genesis, n, engine, db, canonicalSeed) _, err := blockchain.InsertChain(blocks) return db, blockchain, err } // Header-only chain requested - headers := makeHeaderChain(genesis.Header(), n, db, canonicalSeed) + headers := makeHeaderChain(genesis.Header(), n, engine, db, canonicalSeed) _, err := blockchain.InsertHeaderChain(headers, 1) return db, blockchain, err } // makeHeaderChain creates a deterministic chain of headers rooted at parent. -func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) []*types.Header { - blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, db, seed) +func makeHeaderChain(parent *types.Header, n int, engine consensus.Engine, db ethdb.Database, seed int) []*types.Header { + blocks := makeBlockChain(types.NewBlockWithHeader(parent), n, engine, db, seed) headers := make([]*types.Header, len(blocks)) for i, block := range blocks { headers[i] = block.Header() @@ -263,8 +274,8 @@ func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) [ } // makeBlockChain creates a deterministic chain of blocks rooted at parent. -func makeBlockChain(parent *types.Block, n int, db ethdb.Database, seed int) []*types.Block { - blocks, _ := GenerateChain(params.TestChainConfig, parent, db, n, func(i int, b *BlockGen) { +func makeBlockChain(parent *types.Block, n int, engine consensus.Engine, db ethdb.Database, seed int) []*types.Block { + blocks, _ := GenerateChain(params.TestChainConfig, parent, engine, db, n, func(i int, b *BlockGen) { b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)}) }) return blocks diff --git a/core/chain_makers_test.go b/core/chain_makers_test.go index 2260c62fbd..a3b80da299 100644 --- a/core/chain_makers_test.go +++ b/core/chain_makers_test.go @@ -50,17 +50,17 @@ func ExampleGenerateChain() { // each block and adds different features to gen based on the // block index. signer := types.HomesteadSigner{} - chain, _ := GenerateChain(gspec.Config, genesis, db, 5, func(i int, gen *BlockGen) { + chain, _ := GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, 5, func(i int, gen *BlockGen) { switch i { case 0: // In block 1, addr1 sends addr2 some ether. - tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), bigTxGas, nil, nil), signer, key1) + tx, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(10000), params.TxGas, nil, nil), signer, key1) gen.AddTx(tx) case 1: // In block 2, addr1 sends some more ether to addr2. // addr2 passes it on to addr3. - tx1, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), bigTxGas, nil, nil), signer, key1) - tx2, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), bigTxGas, nil, nil), signer, key2) + tx1, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr1), addr2, big.NewInt(1000), params.TxGas, nil, nil), signer, key1) + tx2, _ := types.SignTx(types.NewTransaction(gen.TxNonce(addr2), addr3, big.NewInt(1000), params.TxGas, nil, nil), signer, key2) gen.AddTx(tx1) gen.AddTx(tx2) case 2: diff --git a/core/dao_test.go b/core/dao_test.go index b9898ff7c8..43e2982a52 100644 --- a/core/dao_test.go +++ b/core/dao_test.go @@ -35,7 +35,7 @@ func TestDAOForkRangeExtradata(t *testing.T) { db, _ := ethdb.NewMemDatabase() gspec := new(Genesis) genesis := gspec.MustCommit(db) - prefix, _ := GenerateChain(params.TestChainConfig, genesis, db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {}) + prefix, _ := GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, int(forkBlock.Int64()-1), func(i int, gen *BlockGen) {}) // Create the concurrent, conflicting two nodes proDb, _ := ethdb.NewMemDatabase() @@ -79,12 +79,12 @@ func TestDAOForkRangeExtradata(t *testing.T) { if _, err := bc.InsertChain(blocks); err != nil { t.Fatalf("failed to import contra-fork chain for expansion: %v", err) } - blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := conBc.InsertChain(blocks); err == nil { t.Fatalf("contra-fork chain accepted pro-fork block: %v", blocks[0]) } // Create a proper no-fork block for the contra-forker - blocks, _ = GenerateChain(&conConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&conConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := conBc.InsertChain(blocks); err != nil { t.Fatalf("contra-fork chain didn't accepted no-fork block: %v", err) } @@ -101,12 +101,12 @@ func TestDAOForkRangeExtradata(t *testing.T) { if _, err := bc.InsertChain(blocks); err != nil { t.Fatalf("failed to import pro-fork chain for expansion: %v", err) } - blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := proBc.InsertChain(blocks); err == nil { t.Fatalf("pro-fork chain accepted contra-fork block: %v", blocks[0]) } // Create a proper pro-fork block for the pro-forker - blocks, _ = GenerateChain(&proConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&proConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := proBc.InsertChain(blocks); err != nil { t.Fatalf("pro-fork chain didn't accepted pro-fork block: %v", err) } @@ -124,7 +124,7 @@ func TestDAOForkRangeExtradata(t *testing.T) { if _, err := bc.InsertChain(blocks); err != nil { t.Fatalf("failed to import contra-fork chain for expansion: %v", err) } - blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&proConf, conBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := conBc.InsertChain(blocks); err != nil { t.Fatalf("contra-fork chain didn't accept pro-fork block post-fork: %v", err) } @@ -141,7 +141,7 @@ func TestDAOForkRangeExtradata(t *testing.T) { if _, err := bc.InsertChain(blocks); err != nil { t.Fatalf("failed to import pro-fork chain for expansion: %v", err) } - blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), db, 1, func(i int, gen *BlockGen) {}) + blocks, _ = GenerateChain(&conConf, proBc.CurrentBlock(), ethash.NewFaker(), db, 1, func(i int, gen *BlockGen) {}) if _, err := proBc.InsertChain(blocks); err != nil { t.Fatalf("pro-fork chain didn't accept contra-fork block post-fork: %v", err) } diff --git a/core/database_util_test.go b/core/database_util_test.go index 36f43cf50a..ab4e45a478 100644 --- a/core/database_util_test.go +++ b/core/database_util_test.go @@ -290,9 +290,9 @@ func TestHeadStorage(t *testing.T) { func TestLookupStorage(t *testing.T) { db, _ := ethdb.NewMemDatabase() - tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), big.NewInt(1111), big.NewInt(11111), []byte{0x11, 0x11, 0x11}) - tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(222), big.NewInt(2222), big.NewInt(22222), []byte{0x22, 0x22, 0x22}) - tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(333), big.NewInt(3333), big.NewInt(33333), []byte{0x33, 0x33, 0x33}) + tx1 := types.NewTransaction(1, common.BytesToAddress([]byte{0x11}), big.NewInt(111), 1111, big.NewInt(11111), []byte{0x11, 0x11, 0x11}) + tx2 := types.NewTransaction(2, common.BytesToAddress([]byte{0x22}), big.NewInt(222), 2222, big.NewInt(22222), []byte{0x22, 0x22, 0x22}) + tx3 := types.NewTransaction(3, common.BytesToAddress([]byte{0x33}), big.NewInt(333), 3333, big.NewInt(33333), []byte{0x33, 0x33, 0x33}) txs := []*types.Transaction{tx1, tx2, tx3} block := types.NewBlock(&types.Header{Number: big.NewInt(314)}, txs, nil, nil) @@ -337,25 +337,25 @@ func TestBlockReceiptStorage(t *testing.T) { receipt1 := &types.Receipt{ Status: types.ReceiptStatusFailed, - CumulativeGasUsed: big.NewInt(1), + CumulativeGasUsed: 1, Logs: []*types.Log{ {Address: common.BytesToAddress([]byte{0x11})}, {Address: common.BytesToAddress([]byte{0x01, 0x11})}, }, TxHash: common.BytesToHash([]byte{0x11, 0x11}), ContractAddress: common.BytesToAddress([]byte{0x01, 0x11, 0x11}), - GasUsed: big.NewInt(111111), + GasUsed: 111111, } receipt2 := &types.Receipt{ PostState: common.Hash{2}.Bytes(), - CumulativeGasUsed: big.NewInt(2), + CumulativeGasUsed: 2, Logs: []*types.Log{ {Address: common.BytesToAddress([]byte{0x22})}, {Address: common.BytesToAddress([]byte{0x02, 0x22})}, }, TxHash: common.BytesToHash([]byte{0x22, 0x22}), ContractAddress: common.BytesToAddress([]byte{0x02, 0x22, 0x22}), - GasUsed: big.NewInt(222222), + GasUsed: 222222, } receipts := []*types.Receipt{receipt1, receipt2} diff --git a/core/evm.go b/core/evm.go index 4912aa6505..55db53927b 100644 --- a/core/evm.go +++ b/core/evm.go @@ -53,7 +53,7 @@ func NewEVMContext(msg Message, header *types.Header, chain ChainContext, author BlockNumber: new(big.Int).Set(header.Number), Time: new(big.Int).Set(header.Time), Difficulty: new(big.Int).Set(header.Difficulty), - GasLimit: new(big.Int).Set(header.GasLimit), + GasLimit: header.GasLimit, GasPrice: new(big.Int).Set(msg.GasPrice()), } } diff --git a/core/gaspool.go b/core/gaspool.go index ef99908cfe..c3ee5c198f 100644 --- a/core/gaspool.go +++ b/core/gaspool.go @@ -16,31 +16,34 @@ package core -import "math/big" +import ( + "fmt" + "math" +) -// GasPool tracks the amount of gas available during -// execution of the transactions in a block. -// The zero value is a pool with zero gas available. -type GasPool big.Int +// GasPool tracks the amount of gas available during execution of the transactions +// in a block. The zero value is a pool with zero gas available. +type GasPool uint64 // AddGas makes gas available for execution. -func (gp *GasPool) AddGas(amount *big.Int) *GasPool { - i := (*big.Int)(gp) - i.Add(i, amount) +func (gp *GasPool) AddGas(amount uint64) *GasPool { + if uint64(*gp) > math.MaxUint64-amount { + panic("gas pool pushed above uint64") + } + *(*uint64)(gp) += amount return gp } // SubGas deducts the given amount from the pool if enough gas is // available and returns an error otherwise. -func (gp *GasPool) SubGas(amount *big.Int) error { - i := (*big.Int)(gp) - if i.Cmp(amount) < 0 { +func (gp *GasPool) SubGas(amount uint64) error { + if uint64(*gp) < amount { return ErrGasLimitReached } - i.Sub(i, amount) + *(*uint64)(gp) -= amount return nil } func (gp *GasPool) String() string { - return (*big.Int)(gp).String() + return fmt.Sprintf("%d", *gp) } diff --git a/core/gen_genesis.go b/core/gen_genesis.go index 4d75704a6d..6f941e35a7 100644 --- a/core/gen_genesis.go +++ b/core/gen_genesis.go @@ -13,6 +13,8 @@ import ( "github.com/ethereum/go-ethereum/params" ) +var _ = (*genesisSpecMarshaling)(nil) + func (g Genesis) MarshalJSON() ([]byte, error) { type Genesis struct { Config *params.ChainConfig `json:"config"` diff --git a/core/genesis.go b/core/genesis.go index df491ce0f4..e22985b800 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -239,8 +239,8 @@ func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) { Time: new(big.Int).SetUint64(g.Timestamp), ParentHash: g.ParentHash, Extra: g.ExtraData, - GasLimit: new(big.Int).SetUint64(g.GasLimit), - GasUsed: new(big.Int).SetUint64(g.GasUsed), + GasLimit: g.GasLimit, + GasUsed: g.GasUsed, Difficulty: g.Difficulty, MixDigest: g.Mixhash, Coinbase: g.Coinbase, diff --git a/core/state/journal.go b/core/state/journal.go index ddc819fe5f..a89bb3d13a 100644 --- a/core/state/journal.go +++ b/core/state/journal.go @@ -62,7 +62,7 @@ type ( // Changes to other state values. refundChange struct { - prev *big.Int + prev uint64 } addLogChange struct { txhash common.Hash diff --git a/core/state/statedb.go b/core/state/statedb.go index de9fb367d9..8e29104d59 100644 --- a/core/state/statedb.go +++ b/core/state/statedb.go @@ -57,7 +57,7 @@ type StateDB struct { dbErr error // The refund counter, also used by state transitioning. - refund *big.Int + refund uint64 thash, bhash common.Hash txIndex int @@ -86,7 +86,6 @@ func New(root common.Hash, db Database) (*StateDB, error) { trie: tr, stateObjects: make(map[common.Address]*stateObject), stateObjectsDirty: make(map[common.Address]struct{}), - refund: new(big.Int), logs: make(map[common.Hash][]*types.Log), preimages: make(map[common.Hash][]byte), }, nil @@ -161,9 +160,9 @@ func (self *StateDB) Preimages() map[common.Hash][]byte { return self.preimages } -func (self *StateDB) AddRefund(gas *big.Int) { - self.journal = append(self.journal, refundChange{prev: new(big.Int).Set(self.refund)}) - self.refund.Add(self.refund, gas) +func (self *StateDB) AddRefund(gas uint64) { + self.journal = append(self.journal, refundChange{prev: self.refund}) + self.refund += gas } // Exist reports whether the given account address exists in the state. @@ -456,7 +455,7 @@ func (self *StateDB) Copy() *StateDB { trie: self.db.CopyTrie(self.trie), stateObjects: make(map[common.Address]*stateObject, len(self.stateObjectsDirty)), stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)), - refund: new(big.Int).Set(self.refund), + refund: self.refund, logs: make(map[common.Hash][]*types.Log, len(self.logs)), logSize: self.logSize, preimages: make(map[common.Hash][]byte), @@ -506,9 +505,7 @@ func (self *StateDB) RevertToSnapshot(revid int) { } // GetRefund returns the current value of the refund counter. -// The return value must not be modified by the caller and will become -// invalid at the next call to AddRefund. -func (self *StateDB) GetRefund() *big.Int { +func (self *StateDB) GetRefund() uint64 { return self.refund } @@ -568,7 +565,7 @@ func (s *StateDB) DeleteSuicides() { func (s *StateDB) clearJournalAndRefund() { s.journal = nil s.validRevisions = s.validRevisions[:0] - s.refund = new(big.Int) + s.refund = 0 } // CommitTo writes the state to the given database. diff --git a/core/state/statedb_test.go b/core/state/statedb_test.go index e9944cd745..5c80e3aa56 100644 --- a/core/state/statedb_test.go +++ b/core/state/statedb_test.go @@ -263,7 +263,7 @@ func newTestAction(addr common.Address, r *rand.Rand) testAction { { name: "AddRefund", fn: func(a testAction, s *StateDB) { - s.AddRefund(big.NewInt(a.args[0])) + s.AddRefund(uint64(a.args[0])) }, args: make([]int64, 1), noAddr: true, @@ -396,7 +396,7 @@ func (test *snapshotTest) checkEqual(state, checkstate *StateDB) error { } } - if state.GetRefund().Cmp(checkstate.GetRefund()) != 0 { + if state.GetRefund() != checkstate.GetRefund() { return fmt.Errorf("got GetRefund() == %d, want GetRefund() == %d", state.GetRefund(), checkstate.GetRefund()) } diff --git a/core/state_processor.go b/core/state_processor.go index 689c83785f..4dc58b9dea 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -17,8 +17,6 @@ package core import ( - "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" @@ -55,13 +53,13 @@ func NewStateProcessor(config *params.ChainConfig, bc *BlockChain, engine consen // Process returns the receipts and logs accumulated during the process and // returns the amount of gas that was used in the process. If any of the // transactions failed to execute due to insufficient gas it will return an error. -func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) { +func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) { var ( - receipts types.Receipts - totalUsedGas = big.NewInt(0) - header = block.Header() - allLogs []*types.Log - gp = new(GasPool).AddGas(block.GasLimit()) + receipts types.Receipts + usedGas = new(uint64) + header = block.Header() + allLogs []*types.Log + gp = new(GasPool).AddGas(block.GasLimit()) ) // Mutate the the block and state according to any hard-fork specs if p.config.DAOForkSupport && p.config.DAOForkBlock != nil && p.config.DAOForkBlock.Cmp(block.Number()) == 0 { @@ -70,9 +68,9 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg // Iterate over and process the individual transactions for i, tx := range block.Transactions() { statedb.Prepare(tx.Hash(), block.Hash(), i) - receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, totalUsedGas, cfg) + receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, usedGas, cfg) if err != nil { - return nil, nil, nil, err + return nil, nil, 0, err } receipts = append(receipts, receipt) allLogs = append(allLogs, receipt.Logs...) @@ -80,17 +78,17 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg // Finalize the block, applying any consensus engine specific extras (e.g. block rewards) p.engine.Finalize(p.bc, header, statedb, block.Transactions(), block.Uncles(), receipts) - return receipts, allLogs, totalUsedGas, nil + return receipts, allLogs, *usedGas, nil } // ApplyTransaction attempts to apply a transaction to the given state database // and uses the input parameters for its environment. It returns the receipt // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. -func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *big.Int, cfg vm.Config) (*types.Receipt, *big.Int, error) { +func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, uint64, error) { msg, err := tx.AsMessage(types.MakeSigner(config, header.Number)) if err != nil { - return nil, nil, err + return nil, 0, err } // Create a new context to be used in the EVM environment context := NewEVMContext(msg, header, bc, author) @@ -100,9 +98,8 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common // Apply the transaction to the current state (included in the env) _, gas, failed, err := ApplyMessage(vmenv, msg, gp) if err != nil { - return nil, nil, err + return nil, 0, err } - // Update the state with pending changes var root []byte if config.IsByzantium(header.Number) { @@ -110,18 +107,17 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common } else { root = statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes() } - usedGas.Add(usedGas, gas) + *usedGas += gas // Create a new receipt for the transaction, storing the intermediate root and gas used by the tx // based on the eip phase, we're passing wether the root touch-delete accounts. - receipt := types.NewReceipt(root, failed, usedGas) + receipt := types.NewReceipt(root, failed, *usedGas) receipt.TxHash = tx.Hash() - receipt.GasUsed = new(big.Int).Set(gas) + receipt.GasUsed = gas // if the transaction created a contract, store the creation address in the receipt. if msg.To() == nil { receipt.ContractAddress = crypto.CreateAddress(vmenv.Context.Origin, tx.Nonce()) } - // Set the receipt logs and create a bloom for filtering receipt.Logs = statedb.GetLogs(tx.Hash()) receipt.Bloom = types.CreateBloom(types.Receipts{receipt}) diff --git a/core/state_transition.go b/core/state_transition.go index e7a0685893..390473fffd 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -18,17 +18,16 @@ package core import ( "errors" + "math" "math/big" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" ) var ( - Big0 = big.NewInt(0) errInsufficientBalanceForGas = errors.New("insufficient balance to pay for gas") ) @@ -54,7 +53,7 @@ type StateTransition struct { msg Message gas uint64 gasPrice *big.Int - initialGas *big.Int + initialGas uint64 value *big.Int data []byte state vm.StateDB @@ -68,7 +67,7 @@ type Message interface { To() *common.Address GasPrice() *big.Int - Gas() *big.Int + Gas() uint64 Value() *big.Int Nonce() uint64 @@ -76,45 +75,49 @@ type Message interface { Data() []byte } -// IntrinsicGas computes the 'intrinsic gas' for a message -// with the given data. -// -// TODO convert to uint64 -func IntrinsicGas(data []byte, contractCreation, homestead bool) *big.Int { - igas := new(big.Int) +// IntrinsicGas computes the 'intrinsic gas' for a message with the given data. +func IntrinsicGas(data []byte, contractCreation, homestead bool) (uint64, error) { + // Set the starting gas for the raw transaction + var gas uint64 if contractCreation && homestead { - igas.SetUint64(params.TxGasContractCreation) + gas = params.TxGasContractCreation } else { - igas.SetUint64(params.TxGas) + gas = params.TxGas } + // Bump the required gas by the amount of transactional data if len(data) > 0 { - var nz int64 + // Zero and non-zero bytes are priced differently + var nz uint64 for _, byt := range data { if byt != 0 { nz++ } } - m := big.NewInt(nz) - m.Mul(m, new(big.Int).SetUint64(params.TxDataNonZeroGas)) - igas.Add(igas, m) - m.SetInt64(int64(len(data)) - nz) - m.Mul(m, new(big.Int).SetUint64(params.TxDataZeroGas)) - igas.Add(igas, m) + // Make sure we don't exceed uint64 for all data combinations + if (math.MaxUint64-gas)/params.TxDataNonZeroGas < nz { + return 0, vm.ErrOutOfGas + } + gas += nz * params.TxDataNonZeroGas + + z := uint64(len(data)) - nz + if (math.MaxUint64-gas)/params.TxDataZeroGas < z { + return 0, vm.ErrOutOfGas + } + gas += z * params.TxDataZeroGas } - return igas + return gas, nil } // NewStateTransition initialises and returns a new state transition object. func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition { return &StateTransition{ - gp: gp, - evm: evm, - msg: msg, - gasPrice: msg.GasPrice(), - initialGas: new(big.Int), - value: msg.Value(), - data: msg.Data(), - state: evm.StateDB, + gp: gp, + evm: evm, + msg: msg, + gasPrice: msg.GasPrice(), + value: msg.Value(), + data: msg.Data(), + state: evm.StateDB, } } @@ -125,11 +128,8 @@ func NewStateTransition(evm *vm.EVM, msg Message, gp *GasPool) *StateTransition // the gas used (which includes gas refunds) and an error if it failed. An error always // indicates a core error meaning that the message would always fail for that particular // state and would never be accepted within a block. -func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, *big.Int, bool, error) { - st := NewStateTransition(evm, msg, gp) - - ret, _, gasUsed, failed, err := st.TransitionDb() - return ret, gasUsed, failed, err +func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, uint64, bool, error) { + return NewStateTransition(evm, msg, gp).TransitionDb() } func (st *StateTransition) from() vm.AccountRef { @@ -166,26 +166,20 @@ func (st *StateTransition) useGas(amount uint64) error { } func (st *StateTransition) buyGas() error { - mgas := st.msg.Gas() - if mgas.BitLen() > 64 { - return vm.ErrOutOfGas - } - - mgval := new(big.Int).Mul(mgas, st.gasPrice) - var ( state = st.state sender = st.from() ) + mgval := new(big.Int).Mul(new(big.Int).SetUint64(st.msg.Gas()), st.gasPrice) if state.GetBalance(sender.Address()).Cmp(mgval) < 0 { return errInsufficientBalanceForGas } - if err := st.gp.SubGas(mgas); err != nil { + if err := st.gp.SubGas(st.msg.Gas()); err != nil { return err } - st.gas += mgas.Uint64() + st.gas += st.msg.Gas() - st.initialGas.Set(mgas) + st.initialGas = st.msg.Gas() state.SubBalance(sender.Address(), mgval) return nil } @@ -206,10 +200,10 @@ func (st *StateTransition) preCheck() error { return st.buyGas() } -// TransitionDb will transition the state by applying the current message and returning the result -// including the required gas for the operation as well as the used gas. It returns an error if it +// TransitionDb will transition the state by applying the current message and +// returning the result including the the used gas. It returns an error if it // failed. An error indicates a consensus issue. -func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, failed bool, err error) { +func (st *StateTransition) TransitionDb() (ret []byte, usedGas uint64, failed bool, err error) { if err = st.preCheck(); err != nil { return } @@ -220,13 +214,9 @@ func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big contractCreation := msg.To() == nil // Pay intrinsic gas - // TODO convert to uint64 - intrinsicGas := IntrinsicGas(st.data, contractCreation, homestead) - if intrinsicGas.BitLen() > 64 { - return nil, nil, nil, false, vm.ErrOutOfGas - } - if err = st.useGas(intrinsicGas.Uint64()); err != nil { - return nil, nil, nil, false, err + gas, err := IntrinsicGas(st.data, contractCreation, homestead) + if err = st.useGas(gas); err != nil { + return nil, 0, false, err } var ( @@ -249,36 +239,35 @@ func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big // sufficient balance to make the transfer happen. The first // balance transfer may never fail. if vmerr == vm.ErrInsufficientBalance { - return nil, nil, nil, false, vmerr + return nil, 0, false, vmerr } } - requiredGas = new(big.Int).Set(st.gasUsed()) - st.refundGas() - st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(st.gasUsed(), st.gasPrice)) + st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), st.gasPrice)) - return ret, requiredGas, st.gasUsed(), vmerr != nil, err + return ret, st.gasUsed(), vmerr != nil, err } func (st *StateTransition) refundGas() { - // Return eth for remaining gas to the sender account, - // exchanged at the original rate. - sender := st.from() // err already checked + // Apply refund counter, capped to half of the used gas. + refund := st.gasUsed() / 2 + if refund > st.state.GetRefund() { + refund = st.state.GetRefund() + } + st.gas += refund + + // Return ETH for remaining gas, exchanged at the original rate. + sender := st.from() + remaining := new(big.Int).Mul(new(big.Int).SetUint64(st.gas), st.gasPrice) st.state.AddBalance(sender.Address(), remaining) - // Apply refund counter, capped to half of the used gas. - uhalf := remaining.Div(st.gasUsed(), common.Big2) - refund := math.BigMin(uhalf, st.state.GetRefund()) - st.gas += refund.Uint64() - - st.state.AddBalance(sender.Address(), refund.Mul(refund, st.gasPrice)) - // Also return remaining gas to the block gas counter so it is // available for the next transaction. - st.gp.AddGas(new(big.Int).SetUint64(st.gas)) + st.gp.AddGas(st.gas) } -func (st *StateTransition) gasUsed() *big.Int { - return new(big.Int).Sub(st.initialGas, new(big.Int).SetUint64(st.gas)) +// gasUsed returns the amount of gas used up by the state transition. +func (st *StateTransition) gasUsed() uint64 { + return st.initialGas - st.gas } diff --git a/core/tx_list.go b/core/tx_list.go index 838433b897..55fc42617d 100644 --- a/core/tx_list.go +++ b/core/tx_list.go @@ -224,7 +224,7 @@ type txList struct { txs *txSortedMap // Heap indexed sorted hash map of the transactions costcap *big.Int // Price of the highest costing transaction (reset only if exceeds balance) - gascap *big.Int // Gas limit of the highest spending transaction (reset only if exceeds block limit) + gascap uint64 // Gas limit of the highest spending transaction (reset only if exceeds block limit) } // newTxList create a new transaction list for maintaining nonce-indexable fast, @@ -234,7 +234,6 @@ func newTxList(strict bool) *txList { strict: strict, txs: newTxSortedMap(), costcap: new(big.Int), - gascap: new(big.Int), } } @@ -266,7 +265,7 @@ func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Tran if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 { l.costcap = cost } - if gas := tx.Gas(); l.gascap.Cmp(gas) < 0 { + if gas := tx.Gas(); l.gascap < gas { l.gascap = gas } return true, old @@ -288,16 +287,16 @@ func (l *txList) Forward(threshold uint64) types.Transactions { // a point in calculating all the costs or if the balance covers all. If the threshold // is lower than the costgas cap, the caps will be reset to a new high after removing // the newly invalidated transactions. -func (l *txList) Filter(costLimit, gasLimit *big.Int) (types.Transactions, types.Transactions) { +func (l *txList) Filter(costLimit *big.Int, gasLimit uint64) (types.Transactions, types.Transactions) { // If all transactions are below the threshold, short circuit - if l.costcap.Cmp(costLimit) <= 0 && l.gascap.Cmp(gasLimit) <= 0 { + if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit { return nil, nil } l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds - l.gascap = new(big.Int).Set(gasLimit) + l.gascap = gasLimit // Filter out all the transactions above the account's funds - removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(costLimit) > 0 || tx.Gas().Cmp(gasLimit) > 0 }) + removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(costLimit) > 0 || tx.Gas() > gasLimit }) // If the list was strict, filter anything above the lowest nonce var invalids types.Transactions diff --git a/core/tx_list_test.go b/core/tx_list_test.go index b4f0b5228b..d579f501af 100644 --- a/core/tx_list_test.go +++ b/core/tx_list_test.go @@ -17,7 +17,6 @@ package core import ( - "math/big" "math/rand" "testing" @@ -33,7 +32,7 @@ func TestStrictTxListAdd(t *testing.T) { txs := make(types.Transactions, 1024) for i := 0; i < len(txs); i++ { - txs[i] = transaction(uint64(i), new(big.Int), key) + txs[i] = transaction(uint64(i), 0, key) } // Insert the transactions in a random order list := newTxList(true) diff --git a/core/tx_pool.go b/core/tx_pool.go index c3915575b0..dc3ddc4232 100644 --- a/core/tx_pool.go +++ b/core/tx_pool.go @@ -103,7 +103,7 @@ var ( underpricedTxCounter = metrics.NewCounter("txpool/underpriced") ) -// TxStatus is the current status of a transaction as seen py the pool. +// TxStatus is the current status of a transaction as seen by the pool. type TxStatus uint const ( @@ -197,9 +197,9 @@ type TxPool struct { currentState *state.StateDB // Current state in the blockchain head pendingState *state.ManagedState // Pending state tracking virtual nonces - currentMaxGas *big.Int // Current gas limit for transaction caps + currentMaxGas uint64 // Current gas limit for transaction caps - locals *accountSet // Set of local transaction to exepmt from evicion rules + locals *accountSet // Set of local transaction to exempt from eviction rules journal *txJournal // Journal of local transaction to back up to disk pending map[common.Address]*txList // All currently processable transactions @@ -214,7 +214,7 @@ type TxPool struct { } // NewTxPool creates a new transaction pool to gather, sort and filter inbound -// trnsactions from the network. +// transactions from the network. func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, chain blockChain) *TxPool { // Sanitize the input to ensure no vulnerable gas prices are set config = (&config).sanitize() @@ -360,7 +360,7 @@ func (pool *TxPool) reset(oldHead, newHead *types.Header) { newNum := newHead.Number.Uint64() if depth := uint64(math.Abs(float64(oldNum) - float64(newNum))); depth > 64 { - log.Warn("Skipping deep transaction reorg", "depth", depth) + log.Debug("Skipping deep transaction reorg", "depth", depth) } else { // Reorg seems shallow enough to pull in all transactions into memory var discarded, included types.Transactions @@ -564,7 +564,7 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error { return ErrNegativeValue } // Ensure the transaction doesn't exceed the current block limit gas. - if pool.currentMaxGas.Cmp(tx.Gas()) < 0 { + if pool.currentMaxGas < tx.Gas() { return ErrGasLimit } // Make sure the transaction is signed properly @@ -586,8 +586,11 @@ func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error { if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 { return ErrInsufficientFunds } - intrGas := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead) - if tx.Gas().Cmp(intrGas) < 0 { + intrGas, err := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead) + if err != nil { + return err + } + if tx.Gas() < intrGas { return ErrIntrinsicGas } return nil @@ -838,7 +841,7 @@ func (pool *TxPool) Status(hashes []common.Hash) []TxStatus { for i, hash := range hashes { if tx := pool.all[hash]; tx != nil { from, _ := types.Sender(pool.signer, tx) // already validated - if pool.pending[from].txs.items[tx.Nonce()] != nil { + if pool.pending[from] != nil && pool.pending[from].txs.items[tx.Nonce()] != nil { status[i] = TxStatusPending } else { status[i] = TxStatusQueued diff --git a/core/tx_pool_test.go b/core/tx_pool_test.go index 21171a7379..cd11f2ba29 100644 --- a/core/tx_pool_test.go +++ b/core/tx_pool_test.go @@ -46,7 +46,7 @@ func init() { type testBlockChain struct { statedb *state.StateDB - gasLimit *big.Int + gasLimit uint64 chainHeadFeed *event.Feed } @@ -68,11 +68,11 @@ func (bc *testBlockChain) SubscribeChainHeadEvent(ch chan<- ChainHeadEvent) even return bc.chainHeadFeed.Subscribe(ch) } -func transaction(nonce uint64, gaslimit *big.Int, key *ecdsa.PrivateKey) *types.Transaction { +func transaction(nonce uint64, gaslimit uint64, key *ecdsa.PrivateKey) *types.Transaction { return pricedTransaction(nonce, gaslimit, big.NewInt(1), key) } -func pricedTransaction(nonce uint64, gaslimit, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction { +func pricedTransaction(nonce uint64, gaslimit uint64, gasprice *big.Int, key *ecdsa.PrivateKey) *types.Transaction { tx, _ := types.SignTx(types.NewTransaction(nonce, common.Address{}, big.NewInt(100), gaslimit, gasprice, nil), types.HomesteadSigner{}, key) return tx } @@ -80,7 +80,7 @@ func pricedTransaction(nonce uint64, gaslimit, gasprice *big.Int, key *ecdsa.Pri func setupTxPool() (*TxPool, *ecdsa.PrivateKey) { db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} key, _ := crypto.GenerateKey() pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) @@ -184,10 +184,10 @@ func TestStateChangeDuringTransactionPoolReset(t *testing.T) { // setup pool with 2 transaction in it statedb.SetBalance(address, new(big.Int).SetUint64(params.Ether)) - blockchain := &testChain{&testBlockChain{statedb, big.NewInt(1000000000), new(event.Feed)}, address, &trigger} + blockchain := &testChain{&testBlockChain{statedb, 1000000000, new(event.Feed)}, address, &trigger} - tx0 := transaction(0, big.NewInt(100000), key) - tx1 := transaction(1, big.NewInt(100000), key) + tx0 := transaction(0, 100000, key) + tx1 := transaction(1, 100000, key) pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) defer pool.Stop() @@ -230,7 +230,7 @@ func TestInvalidTransactions(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - tx := transaction(0, big.NewInt(100), key) + tx := transaction(0, 100, key) from, _ := deriveSender(tx) pool.currentState.AddBalance(from, big.NewInt(1)) @@ -238,7 +238,7 @@ func TestInvalidTransactions(t *testing.T) { t.Error("expected", ErrInsufficientFunds) } - balance := new(big.Int).Add(tx.Value(), new(big.Int).Mul(tx.Gas(), tx.GasPrice())) + balance := new(big.Int).Add(tx.Value(), new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())) pool.currentState.AddBalance(from, balance) if err := pool.AddRemote(tx); err != ErrIntrinsicGas { t.Error("expected", ErrIntrinsicGas, "got", err) @@ -246,12 +246,12 @@ func TestInvalidTransactions(t *testing.T) { pool.currentState.SetNonce(from, 1) pool.currentState.AddBalance(from, big.NewInt(0xffffffffffffff)) - tx = transaction(0, big.NewInt(100000), key) + tx = transaction(0, 100000, key) if err := pool.AddRemote(tx); err != ErrNonceTooLow { t.Error("expected", ErrNonceTooLow) } - tx = transaction(1, big.NewInt(100000), key) + tx = transaction(1, 100000, key) pool.gasPrice = big.NewInt(1000) if err := pool.AddRemote(tx); err != ErrUnderpriced { t.Error("expected", ErrUnderpriced, "got", err) @@ -267,7 +267,7 @@ func TestTransactionQueue(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - tx := transaction(0, big.NewInt(100), key) + tx := transaction(0, 100, key) from, _ := deriveSender(tx) pool.currentState.AddBalance(from, big.NewInt(1000)) pool.lockedReset(nil, nil) @@ -278,7 +278,7 @@ func TestTransactionQueue(t *testing.T) { t.Error("expected valid txs to be 1 is", len(pool.pending)) } - tx = transaction(1, big.NewInt(100), key) + tx = transaction(1, 100, key) from, _ = deriveSender(tx) pool.currentState.SetNonce(from, 2) pool.enqueueTx(tx.Hash(), tx) @@ -294,9 +294,9 @@ func TestTransactionQueue(t *testing.T) { pool, key = setupTxPool() defer pool.Stop() - tx1 := transaction(0, big.NewInt(100), key) - tx2 := transaction(10, big.NewInt(100), key) - tx3 := transaction(11, big.NewInt(100), key) + tx1 := transaction(0, 100, key) + tx2 := transaction(10, 100, key) + tx3 := transaction(11, 100, key) from, _ = deriveSender(tx1) pool.currentState.AddBalance(from, big.NewInt(1000)) pool.lockedReset(nil, nil) @@ -321,7 +321,7 @@ func TestTransactionNegativeValue(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), big.NewInt(100), big.NewInt(1), nil), types.HomesteadSigner{}, key) + tx, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(-1), 100, big.NewInt(1), nil), types.HomesteadSigner{}, key) from, _ := deriveSender(tx) pool.currentState.AddBalance(from, big.NewInt(1)) if err := pool.AddRemote(tx); err != ErrNegativeValue { @@ -341,12 +341,12 @@ func TestTransactionChainFork(t *testing.T) { statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) statedb.AddBalance(addr, big.NewInt(100000000000000)) - pool.chain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + pool.chain = &testBlockChain{statedb, 1000000, new(event.Feed)} pool.lockedReset(nil, nil) } resetState() - tx := transaction(0, big.NewInt(100000), key) + tx := transaction(0, 100000, key) if _, err := pool.add(tx, false); err != nil { t.Error("didn't expect error", err) } @@ -371,15 +371,15 @@ func TestTransactionDoubleNonce(t *testing.T) { statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) statedb.AddBalance(addr, big.NewInt(100000000000000)) - pool.chain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + pool.chain = &testBlockChain{statedb, 1000000, new(event.Feed)} pool.lockedReset(nil, nil) } resetState() signer := types.HomesteadSigner{} - tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(100000), big.NewInt(1), nil), signer, key) - tx2, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(2), nil), signer, key) - tx3, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), big.NewInt(1000000), big.NewInt(1), nil), signer, key) + tx1, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 100000, big.NewInt(1), nil), signer, key) + tx2, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(2), nil), signer, key) + tx3, _ := types.SignTx(types.NewTransaction(0, common.Address{}, big.NewInt(100), 1000000, big.NewInt(1), nil), signer, key) // Add the first two transaction, ensure higher priced stays only if replace, err := pool.add(tx1, false); err != nil || replace { @@ -418,7 +418,7 @@ func TestTransactionMissingNonce(t *testing.T) { addr := crypto.PubkeyToAddress(key.PublicKey) pool.currentState.AddBalance(addr, big.NewInt(100000000000000)) - tx := transaction(1, big.NewInt(100000), key) + tx := transaction(1, 100000, key) if _, err := pool.add(tx, false); err != nil { t.Error("didn't expect error", err) } @@ -445,7 +445,7 @@ func TestTransactionNonceRecovery(t *testing.T) { pool.currentState.AddBalance(addr, big.NewInt(100000000000000)) pool.lockedReset(nil, nil) - tx := transaction(n, big.NewInt(100000), key) + tx := transaction(n, 100000, key) if err := pool.AddRemote(tx); err != nil { t.Error(err) } @@ -466,17 +466,17 @@ func TestTransactionDropping(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000)) // Add some pending and some queued transactions var ( - tx0 = transaction(0, big.NewInt(100), key) - tx1 = transaction(1, big.NewInt(200), key) - tx2 = transaction(2, big.NewInt(300), key) - tx10 = transaction(10, big.NewInt(100), key) - tx11 = transaction(11, big.NewInt(200), key) - tx12 = transaction(12, big.NewInt(300), key) + tx0 = transaction(0, 100, key) + tx1 = transaction(1, 200, key) + tx2 = transaction(2, 300, key) + tx10 = transaction(10, 100, key) + tx11 = transaction(11, 200, key) + tx12 = transaction(12, 300, key) ) pool.promoteTx(account, tx0.Hash(), tx0) pool.promoteTx(account, tx1.Hash(), tx1) @@ -531,7 +531,7 @@ func TestTransactionDropping(t *testing.T) { t.Errorf("total transaction mismatch: have %d, want %d", len(pool.all), 4) } // Reduce the block gas limit, check that invalidated transactions are dropped - pool.chain.(*testBlockChain).gasLimit = big.NewInt(100) + pool.chain.(*testBlockChain).gasLimit = 100 pool.lockedReset(nil, nil) if _, ok := pool.pending[account].txs.items[tx0.Nonce()]; !ok { @@ -561,7 +561,7 @@ func TestTransactionPostponing(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000)) // Add a batch consecutive pending transactions for validation @@ -569,9 +569,9 @@ func TestTransactionPostponing(t *testing.T) { for i := 0; i < 100; i++ { var tx *types.Transaction if i%2 == 0 { - tx = transaction(uint64(i), big.NewInt(100), key) + tx = transaction(uint64(i), 100, key) } else { - tx = transaction(uint64(i), big.NewInt(500), key) + tx = transaction(uint64(i), 500, key) } pool.promoteTx(account, tx.Hash(), tx) txns = append(txns, tx) @@ -638,7 +638,7 @@ func TestTransactionGapFilling(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) // Keep track of transaction events to ensure all executables get announced @@ -647,10 +647,10 @@ func TestTransactionGapFilling(t *testing.T) { defer sub.Unsubscribe() // Create a pending and a queued transaction with a nonce-gap in between - if err := pool.AddRemote(transaction(0, big.NewInt(100000), key)); err != nil { + if err := pool.AddRemote(transaction(0, 100000, key)); err != nil { t.Fatalf("failed to add pending transaction: %v", err) } - if err := pool.AddRemote(transaction(2, big.NewInt(100000), key)); err != nil { + if err := pool.AddRemote(transaction(2, 100000, key)); err != nil { t.Fatalf("failed to add queued transaction: %v", err) } pending, queued := pool.Stats() @@ -667,7 +667,7 @@ func TestTransactionGapFilling(t *testing.T) { t.Fatalf("pool internal state corrupted: %v", err) } // Fill the nonce gap and ensure all transactions become pending - if err := pool.AddRemote(transaction(1, big.NewInt(100000), key)); err != nil { + if err := pool.AddRemote(transaction(1, 100000, key)); err != nil { t.Fatalf("failed to add gapped transaction: %v", err) } pending, queued = pool.Stats() @@ -694,12 +694,12 @@ func TestTransactionQueueAccountLimiting(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) // Keep queuing up transactions and make sure all above a limit are dropped for i := uint64(1); i <= testTxPoolConfig.AccountQueue+5; i++ { - if err := pool.AddRemote(transaction(i, big.NewInt(100000), key)); err != nil { + if err := pool.AddRemote(transaction(i, 100000, key)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } if len(pool.pending) != 0 { @@ -738,7 +738,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) { // Create the pool to test the limit enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.NoLocals = nolocals @@ -763,7 +763,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) { key := keys[rand.Intn(len(keys)-1)] // skip adding transactions with the local account addr := crypto.PubkeyToAddress(key.PublicKey) - txs = append(txs, transaction(nonces[addr]+1, big.NewInt(100000), key)) + txs = append(txs, transaction(nonces[addr]+1, 100000, key)) nonces[addr]++ } // Import the batch and verify that limits have been enforced @@ -782,7 +782,7 @@ func testTransactionQueueGlobalLimiting(t *testing.T, nolocals bool) { // Generate a batch of transactions from the local account and import them txs = txs[:0] for i := uint64(0); i < 3*config.GlobalQueue; i++ { - txs = append(txs, transaction(i+1, big.NewInt(100000), local)) + txs = append(txs, transaction(i+1, 100000, local)) } pool.AddLocals(txs) @@ -827,7 +827,7 @@ func testTransactionQueueTimeLimiting(t *testing.T, nolocals bool) { // Create the pool to test the non-expiration enforcement db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.Lifetime = time.Second @@ -844,10 +844,10 @@ func testTransactionQueueTimeLimiting(t *testing.T, nolocals bool) { pool.currentState.AddBalance(crypto.PubkeyToAddress(remote.PublicKey), big.NewInt(1000000000)) // Add the two transactions and ensure they both are queued up - if err := pool.AddLocal(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), local)); err != nil { + if err := pool.AddLocal(pricedTransaction(1, 100000, big.NewInt(1), local)); err != nil { t.Fatalf("failed to add local transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), remote)); err != nil { + if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), remote)); err != nil { t.Fatalf("failed to add remote transaction: %v", err) } pending, queued := pool.Stats() @@ -891,7 +891,7 @@ func TestTransactionPendingLimiting(t *testing.T) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) // Keep track of transaction events to ensure all executables get announced @@ -901,7 +901,7 @@ func TestTransactionPendingLimiting(t *testing.T) { // Keep queuing up transactions and make sure all above a limit are dropped for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ { - if err := pool.AddRemote(transaction(i, big.NewInt(100000), key)); err != nil { + if err := pool.AddRemote(transaction(i, 100000, key)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } if pool.pending[account].Len() != int(i)+1 { @@ -934,11 +934,11 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) { pool1, key1 := setupTxPool() defer pool1.Stop() - account1, _ := deriveSender(transaction(0, big.NewInt(0), key1)) + account1, _ := deriveSender(transaction(0, 0, key1)) pool1.currentState.AddBalance(account1, big.NewInt(1000000)) for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ { - if err := pool1.AddRemote(transaction(origin+i, big.NewInt(100000), key1)); err != nil { + if err := pool1.AddRemote(transaction(origin+i, 100000, key1)); err != nil { t.Fatalf("tx %d: failed to add transaction: %v", i, err) } } @@ -946,12 +946,12 @@ func testTransactionLimitingEquivalency(t *testing.T, origin uint64) { pool2, key2 := setupTxPool() defer pool2.Stop() - account2, _ := deriveSender(transaction(0, big.NewInt(0), key2)) + account2, _ := deriveSender(transaction(0, 0, key2)) pool2.currentState.AddBalance(account2, big.NewInt(1000000)) txns := []*types.Transaction{} for i := uint64(0); i < testTxPoolConfig.AccountQueue+5; i++ { - txns = append(txns, transaction(origin+i, big.NewInt(100000), key2)) + txns = append(txns, transaction(origin+i, 100000, key2)) } pool2.AddRemotes(txns) @@ -982,7 +982,7 @@ func TestTransactionPendingGlobalLimiting(t *testing.T) { // Create the pool to test the limit enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.GlobalSlots = config.AccountSlots * 10 @@ -1003,7 +1003,7 @@ func TestTransactionPendingGlobalLimiting(t *testing.T) { for _, key := range keys { addr := crypto.PubkeyToAddress(key.PublicKey) for j := 0; j < int(config.GlobalSlots)/len(keys)*2; j++ { - txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key)) + txs = append(txs, transaction(nonces[addr], 100000, key)) nonces[addr]++ } } @@ -1029,7 +1029,7 @@ func TestTransactionCapClearsFromAll(t *testing.T) { // Create the pool to test the limit enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.AccountSlots = 2 @@ -1046,7 +1046,7 @@ func TestTransactionCapClearsFromAll(t *testing.T) { txs := types.Transactions{} for j := 0; j < int(config.GlobalSlots)*2; j++ { - txs = append(txs, transaction(uint64(j), big.NewInt(100000), key)) + txs = append(txs, transaction(uint64(j), 100000, key)) } // Import the batch and verify that limits have been enforced pool.AddRemotes(txs) @@ -1064,7 +1064,7 @@ func TestTransactionPendingMinimumAllowance(t *testing.T) { // Create the pool to test the limit enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.GlobalSlots = 0 @@ -1085,7 +1085,7 @@ func TestTransactionPendingMinimumAllowance(t *testing.T) { for _, key := range keys { addr := crypto.PubkeyToAddress(key.PublicKey) for j := 0; j < int(config.AccountSlots)*2; j++ { - txs = append(txs, transaction(nonces[addr], big.NewInt(100000), key)) + txs = append(txs, transaction(nonces[addr], 100000, key)) nonces[addr]++ } } @@ -1113,7 +1113,7 @@ func TestTransactionPoolRepricing(t *testing.T) { // Create the pool to test the pricing enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) defer pool.Stop() @@ -1132,15 +1132,15 @@ func TestTransactionPoolRepricing(t *testing.T) { // Generate and queue a batch of transactions, both pending and queued txs := types.Transactions{} - txs = append(txs, pricedTransaction(0, big.NewInt(100000), big.NewInt(2), keys[0])) - txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[0])) - txs = append(txs, pricedTransaction(2, big.NewInt(100000), big.NewInt(2), keys[0])) + txs = append(txs, pricedTransaction(0, 100000, big.NewInt(2), keys[0])) + txs = append(txs, pricedTransaction(1, 100000, big.NewInt(1), keys[0])) + txs = append(txs, pricedTransaction(2, 100000, big.NewInt(2), keys[0])) - txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(2), keys[1])) - txs = append(txs, pricedTransaction(2, big.NewInt(100000), big.NewInt(1), keys[1])) - txs = append(txs, pricedTransaction(3, big.NewInt(100000), big.NewInt(2), keys[1])) + txs = append(txs, pricedTransaction(1, 100000, big.NewInt(2), keys[1])) + txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[1])) + txs = append(txs, pricedTransaction(3, 100000, big.NewInt(2), keys[1])) - ltx := pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[2]) + ltx := pricedTransaction(0, 100000, big.NewInt(1), keys[2]) // Import the batch and that both pending and queued transactions match up pool.AddRemotes(txs) @@ -1176,10 +1176,10 @@ func TestTransactionPoolRepricing(t *testing.T) { t.Fatalf("pool internal state corrupted: %v", err) } // Check that we can't add the old transactions back - if err := pool.AddRemote(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[0])); err != ErrUnderpriced { + if err := pool.AddRemote(pricedTransaction(1, 100000, big.NewInt(1), keys[0])); err != ErrUnderpriced { t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), keys[1])); err != ErrUnderpriced { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced { t.Fatalf("adding underpriced queued transaction error mismatch: have %v, want %v", err, ErrUnderpriced) } if err := validateEvents(events, 0); err != nil { @@ -1189,7 +1189,7 @@ func TestTransactionPoolRepricing(t *testing.T) { t.Fatalf("pool internal state corrupted: %v", err) } // However we can add local underpriced transactions - tx := pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[2]) + tx := pricedTransaction(1, 100000, big.NewInt(1), keys[2]) if err := pool.AddLocal(tx); err != nil { t.Fatalf("failed to add underpriced local transaction: %v", err) } @@ -1212,7 +1212,7 @@ func TestTransactionPoolRepricingKeepsLocals(t *testing.T) { // Create the pool to test the pricing enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) defer pool.Stop() @@ -1226,12 +1226,12 @@ func TestTransactionPoolRepricingKeepsLocals(t *testing.T) { // Create transaction (both pending and queued) with a linearly growing gasprice for i := uint64(0); i < 500; i++ { // Add pending - p_tx := pricedTransaction(i, big.NewInt(100000), big.NewInt(int64(i)), keys[2]) + p_tx := pricedTransaction(i, 100000, big.NewInt(int64(i)), keys[2]) if err := pool.AddLocal(p_tx); err != nil { t.Fatal(err) } // Add queued - q_tx := pricedTransaction(i+501, big.NewInt(100000), big.NewInt(int64(i)), keys[2]) + q_tx := pricedTransaction(i+501, 100000, big.NewInt(int64(i)), keys[2]) if err := pool.AddLocal(q_tx); err != nil { t.Fatal(err) } @@ -1275,7 +1275,7 @@ func TestTransactionPoolUnderpricing(t *testing.T) { // Create the pool to test the pricing enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.GlobalSlots = 2 @@ -1298,12 +1298,12 @@ func TestTransactionPoolUnderpricing(t *testing.T) { // Generate and queue a batch of transactions, both pending and queued txs := types.Transactions{} - txs = append(txs, pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[0])) - txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(2), keys[0])) + txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[0])) + txs = append(txs, pricedTransaction(1, 100000, big.NewInt(2), keys[0])) - txs = append(txs, pricedTransaction(1, big.NewInt(100000), big.NewInt(1), keys[1])) + txs = append(txs, pricedTransaction(1, 100000, big.NewInt(1), keys[1])) - ltx := pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[2]) + ltx := pricedTransaction(0, 100000, big.NewInt(1), keys[2]) // Import the batch and that both pending and queued transactions match up pool.AddRemotes(txs) @@ -1323,17 +1323,17 @@ func TestTransactionPoolUnderpricing(t *testing.T) { t.Fatalf("pool internal state corrupted: %v", err) } // Ensure that adding an underpriced transaction on block limit fails - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), keys[1])); err != ErrUnderpriced { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), keys[1])); err != ErrUnderpriced { t.Fatalf("adding underpriced pending transaction error mismatch: have %v, want %v", err, ErrUnderpriced) } // Ensure that adding high priced transactions drops cheap ones, but not own - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(3), keys[1])); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(3), keys[1])); err != nil { t.Fatalf("failed to add well priced transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(4), keys[1])); err != nil { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(4), keys[1])); err != nil { t.Fatalf("failed to add well priced transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(3, big.NewInt(100000), big.NewInt(5), keys[1])); err != nil { + if err := pool.AddRemote(pricedTransaction(3, 100000, big.NewInt(5), keys[1])); err != nil { t.Fatalf("failed to add well priced transaction: %v", err) } pending, queued = pool.Stats() @@ -1350,7 +1350,7 @@ func TestTransactionPoolUnderpricing(t *testing.T) { t.Fatalf("pool internal state corrupted: %v", err) } // Ensure that adding local transactions can push out even higher priced ones - tx := pricedTransaction(1, big.NewInt(100000), big.NewInt(0), keys[2]) + tx := pricedTransaction(1, 100000, big.NewInt(0), keys[2]) if err := pool.AddLocal(tx); err != nil { t.Fatalf("failed to add underpriced local transaction: %v", err) } @@ -1377,7 +1377,7 @@ func TestTransactionReplacement(t *testing.T) { // Create the pool to test the pricing enforcement with db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) defer pool.Stop() @@ -1395,49 +1395,49 @@ func TestTransactionReplacement(t *testing.T) { price := int64(100) threshold := (price * (100 + int64(testTxPoolConfig.PriceBump))) / 100 - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), key)); err != nil { t.Fatalf("failed to add original cheap pending transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100001), big.NewInt(1), key)); err != ErrReplaceUnderpriced { + if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced { t.Fatalf("original cheap pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(2), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(2), key)); err != nil { t.Fatalf("failed to replace original cheap pending transaction: %v", err) } if err := validateEvents(events, 2); err != nil { t.Fatalf("cheap replacement event firing failed: %v", err) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(price), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(price), key)); err != nil { t.Fatalf("failed to add original proper pending transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100001), big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced { + if err := pool.AddRemote(pricedTransaction(0, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced { t.Fatalf("original proper pending transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(threshold), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(threshold), key)); err != nil { t.Fatalf("failed to replace original proper pending transaction: %v", err) } if err := validateEvents(events, 2); err != nil { t.Fatalf("proper replacement event firing failed: %v", err) } // Add queued transactions, ensuring the minimum price bump is enforced for replacement (for ultra low prices too) - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(1), key)); err != nil { t.Fatalf("failed to add original cheap queued transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100001), big.NewInt(1), key)); err != ErrReplaceUnderpriced { + if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(1), key)); err != ErrReplaceUnderpriced { t.Fatalf("original cheap queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(2), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(2), key)); err != nil { t.Fatalf("failed to replace original cheap queued transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(price), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(price), key)); err != nil { t.Fatalf("failed to add original proper queued transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100001), big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced { + if err := pool.AddRemote(pricedTransaction(2, 100001, big.NewInt(threshold-1), key)); err != ErrReplaceUnderpriced { t.Fatalf("original proper queued transaction replacement error mismatch: have %v, want %v", err, ErrReplaceUnderpriced) } - if err := pool.AddRemote(pricedTransaction(2, big.NewInt(100000), big.NewInt(threshold), key)); err != nil { + if err := pool.AddRemote(pricedTransaction(2, 100000, big.NewInt(threshold), key)); err != nil { t.Fatalf("failed to replace original proper queued transaction: %v", err) } @@ -1472,7 +1472,7 @@ func testTransactionJournaling(t *testing.T, nolocals bool) { // Create the original pool to inject transaction into the journal db, _ := ethdb.NewMemDatabase() statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) - blockchain := &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} config := testTxPoolConfig config.NoLocals = nolocals @@ -1489,16 +1489,16 @@ func testTransactionJournaling(t *testing.T, nolocals bool) { pool.currentState.AddBalance(crypto.PubkeyToAddress(remote.PublicKey), big.NewInt(1000000000)) // Add three local and a remote transactions and ensure they are queued up - if err := pool.AddLocal(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), local)); err != nil { + if err := pool.AddLocal(pricedTransaction(0, 100000, big.NewInt(1), local)); err != nil { t.Fatalf("failed to add local transaction: %v", err) } - if err := pool.AddLocal(pricedTransaction(1, big.NewInt(100000), big.NewInt(1), local)); err != nil { + if err := pool.AddLocal(pricedTransaction(1, 100000, big.NewInt(1), local)); err != nil { t.Fatalf("failed to add local transaction: %v", err) } - if err := pool.AddLocal(pricedTransaction(2, big.NewInt(100000), big.NewInt(1), local)); err != nil { + if err := pool.AddLocal(pricedTransaction(2, 100000, big.NewInt(1), local)); err != nil { t.Fatalf("failed to add local transaction: %v", err) } - if err := pool.AddRemote(pricedTransaction(0, big.NewInt(100000), big.NewInt(1), remote)); err != nil { + if err := pool.AddRemote(pricedTransaction(0, 100000, big.NewInt(1), remote)); err != nil { t.Fatalf("failed to add remote transaction: %v", err) } pending, queued := pool.Stats() @@ -1514,7 +1514,7 @@ func testTransactionJournaling(t *testing.T, nolocals bool) { // Terminate the old pool, bump the local nonce, create a new pool and ensure relevant transaction survive pool.Stop() statedb.SetNonce(crypto.PubkeyToAddress(local.PublicKey), 1) - blockchain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain = &testBlockChain{statedb, 1000000, new(event.Feed)} pool = NewTxPool(config, params.TestChainConfig, blockchain) @@ -1541,7 +1541,7 @@ func testTransactionJournaling(t *testing.T, nolocals bool) { pool.Stop() statedb.SetNonce(crypto.PubkeyToAddress(local.PublicKey), 1) - blockchain = &testBlockChain{statedb, big.NewInt(1000000), new(event.Feed)} + blockchain = &testBlockChain{statedb, 1000000, new(event.Feed)} pool = NewTxPool(config, params.TestChainConfig, blockchain) pending, queued = pool.Stats() @@ -1563,6 +1563,63 @@ func testTransactionJournaling(t *testing.T, nolocals bool) { pool.Stop() } +// TestTransactionStatusCheck tests that the pool can correctly retrieve the +// pending status of individual transactions. +func TestTransactionStatusCheck(t *testing.T) { + t.Parallel() + + // Create the pool to test the status retrievals with + db, _ := ethdb.NewMemDatabase() + statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) + blockchain := &testBlockChain{statedb, 1000000, new(event.Feed)} + + pool := NewTxPool(testTxPoolConfig, params.TestChainConfig, blockchain) + defer pool.Stop() + + // Create the test accounts to check various transaction statuses with + keys := make([]*ecdsa.PrivateKey, 3) + for i := 0; i < len(keys); i++ { + keys[i], _ = crypto.GenerateKey() + pool.currentState.AddBalance(crypto.PubkeyToAddress(keys[i].PublicKey), big.NewInt(1000000)) + } + // Generate and queue a batch of transactions, both pending and queued + txs := types.Transactions{} + + txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[0])) // Pending only + txs = append(txs, pricedTransaction(0, 100000, big.NewInt(1), keys[1])) // Pending and queued + txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[1])) + txs = append(txs, pricedTransaction(2, 100000, big.NewInt(1), keys[2])) // Queued only + + // Import the transaction and ensure they are correctly added + pool.AddRemotes(txs) + + pending, queued := pool.Stats() + if pending != 2 { + t.Fatalf("pending transactions mismatched: have %d, want %d", pending, 2) + } + if queued != 2 { + t.Fatalf("queued transactions mismatched: have %d, want %d", queued, 2) + } + if err := validateTxPoolInternals(pool); err != nil { + t.Fatalf("pool internal state corrupted: %v", err) + } + // Retrieve the status of each transaction and validate them + hashes := make([]common.Hash, len(txs)) + for i, tx := range txs { + hashes[i] = tx.Hash() + } + hashes = append(hashes, common.Hash{}) + + statuses := pool.Status(hashes) + expect := []TxStatus{TxStatusPending, TxStatusPending, TxStatusQueued, TxStatusQueued, TxStatusUnknown} + + for i := 0; i < len(statuses); i++ { + if statuses[i] != expect[i] { + t.Errorf("transaction %d: status mismatch: have %v, want %v", i, statuses[i], expect[i]) + } + } +} + // Benchmarks the speed of validating the contents of the pending queue of the // transaction pool. func BenchmarkPendingDemotion100(b *testing.B) { benchmarkPendingDemotion(b, 100) } @@ -1574,11 +1631,11 @@ func benchmarkPendingDemotion(b *testing.B, size int) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) for i := 0; i < size; i++ { - tx := transaction(uint64(i), big.NewInt(100000), key) + tx := transaction(uint64(i), 100000, key) pool.promoteTx(account, tx.Hash(), tx) } // Benchmark the speed of pool validation @@ -1599,11 +1656,11 @@ func benchmarkFuturePromotion(b *testing.B, size int) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) for i := 0; i < size; i++ { - tx := transaction(uint64(1+i), big.NewInt(100000), key) + tx := transaction(uint64(1+i), 100000, key) pool.enqueueTx(tx.Hash(), tx) } // Benchmark the speed of pool validation @@ -1619,12 +1676,12 @@ func BenchmarkPoolInsert(b *testing.B) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) txs := make(types.Transactions, b.N) for i := 0; i < b.N; i++ { - txs[i] = transaction(uint64(i), big.NewInt(100000), key) + txs[i] = transaction(uint64(i), 100000, key) } // Benchmark importing the transactions into the queue b.ResetTimer() @@ -1643,14 +1700,14 @@ func benchmarkPoolBatchInsert(b *testing.B, size int) { pool, key := setupTxPool() defer pool.Stop() - account, _ := deriveSender(transaction(0, big.NewInt(0), key)) + account, _ := deriveSender(transaction(0, 0, key)) pool.currentState.AddBalance(account, big.NewInt(1000000)) batches := make([]types.Transactions, b.N) for i := 0; i < b.N; i++ { batches[i] = make(types.Transactions, size) for j := 0; j < size; j++ { - batches[i][j] = transaction(uint64(size*i+j), big.NewInt(100000), key) + batches[i][j] = transaction(uint64(size*i+j), 100000, key) } } // Benchmark importing the transactions into the queue diff --git a/core/types.go b/core/types.go index 1cfbbab29b..d0bbaf0aa7 100644 --- a/core/types.go +++ b/core/types.go @@ -17,8 +17,6 @@ package core import ( - "math/big" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" @@ -34,7 +32,7 @@ type Validator interface { // ValidateState validates the given statedb and optionally the receipts and // gas used. - ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas *big.Int) error + ValidateState(block, parent *types.Block, state *state.StateDB, receipts types.Receipts, usedGas uint64) error } // Processor is an interface for processing blocks using a given initial state. @@ -44,5 +42,5 @@ type Validator interface { // of gas used in the process and return an error if any of the internal rules // failed. type Processor interface { - Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, *big.Int, error) + Process(block *types.Block, statedb *state.StateDB, cfg vm.Config) (types.Receipts, []*types.Log, uint64, error) } diff --git a/core/types/block.go b/core/types/block.go index 1d00d9f930..9be62b9e00 100644 --- a/core/types/block.go +++ b/core/types/block.go @@ -77,8 +77,8 @@ type Header struct { Bloom Bloom `json:"logsBloom" gencodec:"required"` Difficulty *big.Int `json:"difficulty" gencodec:"required"` Number *big.Int `json:"number" gencodec:"required"` - GasLimit *big.Int `json:"gasLimit" gencodec:"required"` - GasUsed *big.Int `json:"gasUsed" gencodec:"required"` + GasLimit uint64 `json:"gasLimit" gencodec:"required"` + GasUsed uint64 `json:"gasUsed" gencodec:"required"` Time *big.Int `json:"timestamp" gencodec:"required"` Extra []byte `json:"extraData" gencodec:"required"` MixDigest common.Hash `json:"mixHash" gencodec:"required"` @@ -89,8 +89,8 @@ type Header struct { type headerMarshaling struct { Difficulty *hexutil.Big Number *hexutil.Big - GasLimit *hexutil.Big - GasUsed *hexutil.Big + GasLimit *hexutil.Uint64 + GasUsed *hexutil.Uint64 Time *hexutil.Big Extra hexutil.Bytes Hash common.Hash `json:"hash"` // adds call to Hash() in MarshalJSON @@ -243,12 +243,6 @@ func CopyHeader(h *Header) *Header { if cpy.Number = new(big.Int); h.Number != nil { cpy.Number.Set(h.Number) } - if cpy.GasLimit = new(big.Int); h.GasLimit != nil { - cpy.GasLimit.Set(h.GasLimit) - } - if cpy.GasUsed = new(big.Int); h.GasUsed != nil { - cpy.GasUsed.Set(h.GasUsed) - } if len(h.Extra) > 0 { cpy.Extra = make([]byte, len(h.Extra)) copy(cpy.Extra, h.Extra) @@ -302,8 +296,8 @@ func (b *Block) Transaction(hash common.Hash) *Transaction { } func (b *Block) Number() *big.Int { return new(big.Int).Set(b.header.Number) } -func (b *Block) GasLimit() *big.Int { return new(big.Int).Set(b.header.GasLimit) } -func (b *Block) GasUsed() *big.Int { return new(big.Int).Set(b.header.GasUsed) } +func (b *Block) GasLimit() uint64 { return b.header.GasLimit } +func (b *Block) GasUsed() uint64 { return b.header.GasUsed } func (b *Block) Difficulty() *big.Int { return new(big.Int).Set(b.header.Difficulty) } func (b *Block) Time() *big.Int { return new(big.Int).Set(b.header.Time) } diff --git a/core/types/block_test.go b/core/types/block_test.go index 93435ca00c..a35fbc25b1 100644 --- a/core/types/block_test.go +++ b/core/types/block_test.go @@ -41,8 +41,8 @@ func TestBlockEncoding(t *testing.T) { } } check("Difficulty", block.Difficulty(), big.NewInt(131072)) - check("GasLimit", block.GasLimit(), big.NewInt(3141592)) - check("GasUsed", block.GasUsed(), big.NewInt(21000)) + check("GasLimit", block.GasLimit(), uint64(3141592)) + check("GasUsed", block.GasUsed(), uint64(21000)) check("Coinbase", block.Coinbase(), common.HexToAddress("8888f1f195afa192cfee860698584c030f4c9db1")) check("MixDigest", block.MixDigest(), common.HexToHash("bd4472abb6659ebe3ee06ee4d7b72a00a9f4d001caca51342001075469aff498")) check("Root", block.Root(), common.HexToHash("ef1552a40b7165c3cd773806b9e0c165b75356e0314bf0706f279c729f51e017")) @@ -51,7 +51,7 @@ func TestBlockEncoding(t *testing.T) { check("Time", block.Time(), big.NewInt(1426516743)) check("Size", block.Size(), common.StorageSize(len(blockEnc))) - tx1 := NewTransaction(0, common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"), big.NewInt(10), big.NewInt(50000), big.NewInt(10), nil) + tx1 := NewTransaction(0, common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"), big.NewInt(10), 50000, big.NewInt(10), nil) tx1, _ = tx1.WithSignature(HomesteadSigner{}, common.Hex2Bytes("9bea4c4daac7c7c52e093e6a4c35dbbcf8856f1af7b059ba20253e70848d094f8a8fae537ce25ed8cb5af9adac3f141af69bd515bd2ba031522df09b97dd72b100")) fmt.Println(block.Transactions()[0].Hash()) diff --git a/core/types/gen_header_json.go b/core/types/gen_header_json.go index bcff7a940d..8af0591044 100644 --- a/core/types/gen_header_json.go +++ b/core/types/gen_header_json.go @@ -22,8 +22,8 @@ func (h Header) MarshalJSON() ([]byte, error) { Bloom Bloom `json:"logsBloom" gencodec:"required"` Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` Number *hexutil.Big `json:"number" gencodec:"required"` - GasLimit *hexutil.Big `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Big `json:"gasUsed" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` Time *hexutil.Big `json:"timestamp" gencodec:"required"` Extra hexutil.Bytes `json:"extraData" gencodec:"required"` MixDigest common.Hash `json:"mixHash" gencodec:"required"` @@ -40,8 +40,8 @@ func (h Header) MarshalJSON() ([]byte, error) { enc.Bloom = h.Bloom enc.Difficulty = (*hexutil.Big)(h.Difficulty) enc.Number = (*hexutil.Big)(h.Number) - enc.GasLimit = (*hexutil.Big)(h.GasLimit) - enc.GasUsed = (*hexutil.Big)(h.GasUsed) + enc.GasLimit = hexutil.Uint64(h.GasLimit) + enc.GasUsed = hexutil.Uint64(h.GasUsed) enc.Time = (*hexutil.Big)(h.Time) enc.Extra = h.Extra enc.MixDigest = h.MixDigest @@ -61,8 +61,8 @@ func (h *Header) UnmarshalJSON(input []byte) error { Bloom *Bloom `json:"logsBloom" gencodec:"required"` Difficulty *hexutil.Big `json:"difficulty" gencodec:"required"` Number *hexutil.Big `json:"number" gencodec:"required"` - GasLimit *hexutil.Big `json:"gasLimit" gencodec:"required"` - GasUsed *hexutil.Big `json:"gasUsed" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gasLimit" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` Time *hexutil.Big `json:"timestamp" gencodec:"required"` Extra hexutil.Bytes `json:"extraData" gencodec:"required"` MixDigest *common.Hash `json:"mixHash" gencodec:"required"` @@ -111,11 +111,11 @@ func (h *Header) UnmarshalJSON(input []byte) error { if dec.GasLimit == nil { return errors.New("missing required field 'gasLimit' for Header") } - h.GasLimit = (*big.Int)(dec.GasLimit) + h.GasLimit = (uint64)(*dec.GasLimit) if dec.GasUsed == nil { return errors.New("missing required field 'gasUsed' for Header") } - h.GasUsed = (*big.Int)(dec.GasUsed) + h.GasUsed = (uint64)(*dec.GasUsed) if dec.Time == nil { return errors.New("missing required field 'timestamp' for Header") } diff --git a/core/types/gen_receipt_json.go b/core/types/gen_receipt_json.go index b95d99c951..5209668746 100644 --- a/core/types/gen_receipt_json.go +++ b/core/types/gen_receipt_json.go @@ -5,7 +5,6 @@ package types import ( "encoding/json" "errors" - "math/big" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -15,22 +14,22 @@ func (r Receipt) MarshalJSON() ([]byte, error) { type Receipt struct { PostState hexutil.Bytes `json:"root"` Status hexutil.Uint `json:"status"` - CumulativeGasUsed *hexutil.Big `json:"cumulativeGasUsed" gencodec:"required"` + CumulativeGasUsed hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"` Bloom Bloom `json:"logsBloom" gencodec:"required"` Logs []*Log `json:"logs" gencodec:"required"` TxHash common.Hash `json:"transactionHash" gencodec:"required"` ContractAddress common.Address `json:"contractAddress"` - GasUsed *hexutil.Big `json:"gasUsed" gencodec:"required"` + GasUsed hexutil.Uint64 `json:"gasUsed" gencodec:"required"` } var enc Receipt enc.PostState = r.PostState enc.Status = hexutil.Uint(r.Status) - enc.CumulativeGasUsed = (*hexutil.Big)(r.CumulativeGasUsed) + enc.CumulativeGasUsed = hexutil.Uint64(r.CumulativeGasUsed) enc.Bloom = r.Bloom enc.Logs = r.Logs enc.TxHash = r.TxHash enc.ContractAddress = r.ContractAddress - enc.GasUsed = (*hexutil.Big)(r.GasUsed) + enc.GasUsed = hexutil.Uint64(r.GasUsed) return json.Marshal(&enc) } @@ -38,12 +37,12 @@ func (r *Receipt) UnmarshalJSON(input []byte) error { type Receipt struct { PostState hexutil.Bytes `json:"root"` Status *hexutil.Uint `json:"status"` - CumulativeGasUsed *hexutil.Big `json:"cumulativeGasUsed" gencodec:"required"` + CumulativeGasUsed *hexutil.Uint64 `json:"cumulativeGasUsed" gencodec:"required"` Bloom *Bloom `json:"logsBloom" gencodec:"required"` Logs []*Log `json:"logs" gencodec:"required"` TxHash *common.Hash `json:"transactionHash" gencodec:"required"` ContractAddress *common.Address `json:"contractAddress"` - GasUsed *hexutil.Big `json:"gasUsed" gencodec:"required"` + GasUsed *hexutil.Uint64 `json:"gasUsed" gencodec:"required"` } var dec Receipt if err := json.Unmarshal(input, &dec); err != nil { @@ -58,7 +57,7 @@ func (r *Receipt) UnmarshalJSON(input []byte) error { if dec.CumulativeGasUsed == nil { return errors.New("missing required field 'cumulativeGasUsed' for Receipt") } - r.CumulativeGasUsed = (*big.Int)(dec.CumulativeGasUsed) + r.CumulativeGasUsed = uint64(*dec.CumulativeGasUsed) if dec.Bloom == nil { return errors.New("missing required field 'logsBloom' for Receipt") } @@ -77,6 +76,6 @@ func (r *Receipt) UnmarshalJSON(input []byte) error { if dec.GasUsed == nil { return errors.New("missing required field 'gasUsed' for Receipt") } - r.GasUsed = (*big.Int)(dec.GasUsed) + r.GasUsed = uint64(*dec.GasUsed) return nil } diff --git a/core/types/gen_tx_json.go b/core/types/gen_tx_json.go index 4fb658e0d9..a82822c36f 100644 --- a/core/types/gen_tx_json.go +++ b/core/types/gen_tx_json.go @@ -15,7 +15,7 @@ func (t txdata) MarshalJSON() ([]byte, error) { type txdata struct { AccountNonce hexutil.Uint64 `json:"nonce" gencodec:"required"` Price *hexutil.Big `json:"gasPrice" gencodec:"required"` - GasLimit *hexutil.Big `json:"gas" gencodec:"required"` + GasLimit hexutil.Uint64 `json:"gas" gencodec:"required"` Recipient *common.Address `json:"to" rlp:"nil"` Amount *hexutil.Big `json:"value" gencodec:"required"` Payload hexutil.Bytes `json:"input" gencodec:"required"` @@ -27,7 +27,7 @@ func (t txdata) MarshalJSON() ([]byte, error) { var enc txdata enc.AccountNonce = hexutil.Uint64(t.AccountNonce) enc.Price = (*hexutil.Big)(t.Price) - enc.GasLimit = (*hexutil.Big)(t.GasLimit) + enc.GasLimit = hexutil.Uint64(t.GasLimit) enc.Recipient = t.Recipient enc.Amount = (*hexutil.Big)(t.Amount) enc.Payload = t.Payload @@ -42,7 +42,7 @@ func (t *txdata) UnmarshalJSON(input []byte) error { type txdata struct { AccountNonce *hexutil.Uint64 `json:"nonce" gencodec:"required"` Price *hexutil.Big `json:"gasPrice" gencodec:"required"` - GasLimit *hexutil.Big `json:"gas" gencodec:"required"` + GasLimit *hexutil.Uint64 `json:"gas" gencodec:"required"` Recipient *common.Address `json:"to" rlp:"nil"` Amount *hexutil.Big `json:"value" gencodec:"required"` Payload hexutil.Bytes `json:"input" gencodec:"required"` @@ -66,7 +66,7 @@ func (t *txdata) UnmarshalJSON(input []byte) error { if dec.GasLimit == nil { return errors.New("missing required field 'gas' for txdata") } - t.GasLimit = (*big.Int)(dec.GasLimit) + t.GasLimit = uint64(*dec.GasLimit) if dec.Recipient != nil { t.Recipient = dec.Recipient } diff --git a/core/types/receipt.go b/core/types/receipt.go index bc3c996b4f..208d54aaa1 100644 --- a/core/types/receipt.go +++ b/core/types/receipt.go @@ -20,7 +20,6 @@ import ( "bytes" "fmt" "io" - "math/big" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -45,46 +44,46 @@ const ( // Receipt represents the results of a transaction. type Receipt struct { // Consensus fields - PostState []byte `json:"root"` - Status uint `json:"status"` - CumulativeGasUsed *big.Int `json:"cumulativeGasUsed" gencodec:"required"` - Bloom Bloom `json:"logsBloom" gencodec:"required"` - Logs []*Log `json:"logs" gencodec:"required"` + PostState []byte `json:"root"` + Status uint `json:"status"` + CumulativeGasUsed uint64 `json:"cumulativeGasUsed" gencodec:"required"` + Bloom Bloom `json:"logsBloom" gencodec:"required"` + Logs []*Log `json:"logs" gencodec:"required"` // Implementation fields (don't reorder!) TxHash common.Hash `json:"transactionHash" gencodec:"required"` ContractAddress common.Address `json:"contractAddress"` - GasUsed *big.Int `json:"gasUsed" gencodec:"required"` + GasUsed uint64 `json:"gasUsed" gencodec:"required"` } type receiptMarshaling struct { PostState hexutil.Bytes Status hexutil.Uint - CumulativeGasUsed *hexutil.Big - GasUsed *hexutil.Big + CumulativeGasUsed hexutil.Uint64 + GasUsed hexutil.Uint64 } // receiptRLP is the consensus encoding of a receipt. type receiptRLP struct { PostStateOrStatus []byte - CumulativeGasUsed *big.Int + CumulativeGasUsed uint64 Bloom Bloom Logs []*Log } type receiptStorageRLP struct { PostStateOrStatus []byte - CumulativeGasUsed *big.Int + CumulativeGasUsed uint64 Bloom Bloom TxHash common.Hash ContractAddress common.Address Logs []*LogForStorage - GasUsed *big.Int + GasUsed uint64 } // NewReceipt creates a barebone transaction receipt, copying the init fields. -func NewReceipt(root []byte, failed bool, cumulativeGasUsed *big.Int) *Receipt { - r := &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: new(big.Int).Set(cumulativeGasUsed)} +func NewReceipt(root []byte, failed bool, cumulativeGasUsed uint64) *Receipt { + r := &Receipt{PostState: common.CopyBytes(root), CumulativeGasUsed: cumulativeGasUsed} if failed { r.Status = ReceiptStatusFailed } else { diff --git a/core/types/transaction.go b/core/types/transaction.go index 7e2933bb1a..a7ed211e42 100644 --- a/core/types/transaction.go +++ b/core/types/transaction.go @@ -57,7 +57,7 @@ type Transaction struct { type txdata struct { AccountNonce uint64 `json:"nonce" gencodec:"required"` Price *big.Int `json:"gasPrice" gencodec:"required"` - GasLimit *big.Int `json:"gas" gencodec:"required"` + GasLimit uint64 `json:"gas" gencodec:"required"` Recipient *common.Address `json:"to" rlp:"nil"` // nil means contract creation Amount *big.Int `json:"value" gencodec:"required"` Payload []byte `json:"input" gencodec:"required"` @@ -74,7 +74,7 @@ type txdata struct { type txdataMarshaling struct { AccountNonce hexutil.Uint64 Price *hexutil.Big - GasLimit *hexutil.Big + GasLimit hexutil.Uint64 Amount *hexutil.Big Payload hexutil.Bytes V *hexutil.Big @@ -82,15 +82,15 @@ type txdataMarshaling struct { S *hexutil.Big } -func NewTransaction(nonce uint64, to common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction { +func NewTransaction(nonce uint64, to common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction { return newTransaction(nonce, &to, amount, gasLimit, gasPrice, data) } -func NewContractCreation(nonce uint64, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction { +func NewContractCreation(nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction { return newTransaction(nonce, nil, amount, gasLimit, gasPrice, data) } -func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice *big.Int, data []byte) *Transaction { +func newTransaction(nonce uint64, to *common.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte) *Transaction { if len(data) > 0 { data = common.CopyBytes(data) } @@ -99,7 +99,7 @@ func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice Recipient: to, Payload: data, Amount: new(big.Int), - GasLimit: new(big.Int), + GasLimit: gasLimit, Price: new(big.Int), V: new(big.Int), R: new(big.Int), @@ -108,9 +108,6 @@ func newTransaction(nonce uint64, to *common.Address, amount, gasLimit, gasPrice if amount != nil { d.Amount.Set(amount) } - if gasLimit != nil { - d.GasLimit.Set(gasLimit) - } if gasPrice != nil { d.Price.Set(gasPrice) } @@ -153,6 +150,7 @@ func (tx *Transaction) DecodeRLP(s *rlp.Stream) error { return err } +// MarshalJSON encodes the web3 RPC transaction format. func (tx *Transaction) MarshalJSON() ([]byte, error) { hash := tx.Hash() data := tx.data @@ -168,8 +166,8 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error { } var V byte if isProtectedV(dec.V) { - chainId := deriveChainId(dec.V).Uint64() - V = byte(dec.V.Uint64() - 35 - 2*chainId) + chainID := deriveChainId(dec.V).Uint64() + V = byte(dec.V.Uint64() - 35 - 2*chainID) } else { V = byte(dec.V.Uint64() - 27) } @@ -181,7 +179,7 @@ func (tx *Transaction) UnmarshalJSON(input []byte) error { } func (tx *Transaction) Data() []byte { return common.CopyBytes(tx.data.Payload) } -func (tx *Transaction) Gas() *big.Int { return new(big.Int).Set(tx.data.GasLimit) } +func (tx *Transaction) Gas() uint64 { return tx.data.GasLimit } func (tx *Transaction) GasPrice() *big.Int { return new(big.Int).Set(tx.data.Price) } func (tx *Transaction) Value() *big.Int { return new(big.Int).Set(tx.data.Amount) } func (tx *Transaction) Nonce() uint64 { return tx.data.AccountNonce } @@ -192,10 +190,9 @@ func (tx *Transaction) CheckNonce() bool { return true } func (tx *Transaction) To() *common.Address { if tx.data.Recipient == nil { return nil - } else { - to := *tx.data.Recipient - return &to } + to := *tx.data.Recipient + return &to } // Hash hashes the RLP encoding of tx. @@ -227,8 +224,8 @@ func (tx *Transaction) Size() common.StorageSize { func (tx *Transaction) AsMessage(s Signer) (Message, error) { msg := Message{ nonce: tx.data.AccountNonce, - price: new(big.Int).Set(tx.data.Price), - gasLimit: new(big.Int).Set(tx.data.GasLimit), + gasLimit: tx.data.GasLimit, + gasPrice: new(big.Int).Set(tx.data.Price), to: tx.data.Recipient, amount: tx.data.Amount, data: tx.data.Payload, @@ -254,7 +251,7 @@ func (tx *Transaction) WithSignature(signer Signer, sig []byte) (*Transaction, e // Cost returns amount + gasprice * gaslimit. func (tx *Transaction) Cost() *big.Int { - total := new(big.Int).Mul(tx.data.Price, tx.data.GasLimit) + total := new(big.Int).Mul(tx.data.Price, new(big.Int).SetUint64(tx.data.GasLimit)) total.Add(total, tx.data.Amount) return total } @@ -315,22 +312,22 @@ func (tx *Transaction) String() string { ) } -// Transaction slice type for basic sorting. +// Transactions is a Transaction slice type for basic sorting. type Transactions []*Transaction -// Len returns the length of s +// Len returns the length of s. func (s Transactions) Len() int { return len(s) } -// Swap swaps the i'th and the j'th element in s +// Swap swaps the i'th and the j'th element in s. func (s Transactions) Swap(i, j int) { s[i], s[j] = s[j], s[i] } -// GetRlp implements Rlpable and returns the i'th element of s in rlp +// GetRlp implements Rlpable and returns the i'th element of s in rlp. func (s Transactions) GetRlp(i int) []byte { enc, _ := rlp.EncodeToBytes(s[i]) return enc } -// Returns a new set t which is the difference between a to b +// TxDifference returns a new set t which is the difference between a to b. func TxDifference(a, b Transactions) (keep Transactions) { keep = make(Transactions, 0, len(a)) @@ -378,7 +375,7 @@ func (s *TxByPrice) Pop() interface{} { } // TransactionsByPriceAndNonce represents a set of transactions that can return -// transactions in a profit-maximising sorted order, while supporting removing +// transactions in a profit-maximizing sorted order, while supporting removing // entire batches of transactions for non-executable accounts. type TransactionsByPriceAndNonce struct { txs map[common.Address]Transactions // Per account nonce-sorted list of transactions @@ -440,22 +437,24 @@ func (t *TransactionsByPriceAndNonce) Pop() { // // NOTE: In a future PR this will be removed. type Message struct { - to *common.Address - from common.Address - nonce uint64 - amount, price, gasLimit *big.Int - data []byte - checkNonce bool + to *common.Address + from common.Address + nonce uint64 + amount *big.Int + gasLimit uint64 + gasPrice *big.Int + data []byte + checkNonce bool } -func NewMessage(from common.Address, to *common.Address, nonce uint64, amount, gasLimit, price *big.Int, data []byte, checkNonce bool) Message { +func NewMessage(from common.Address, to *common.Address, nonce uint64, amount *big.Int, gasLimit uint64, gasPrice *big.Int, data []byte, checkNonce bool) Message { return Message{ from: from, to: to, nonce: nonce, amount: amount, - price: price, gasLimit: gasLimit, + gasPrice: gasPrice, data: data, checkNonce: checkNonce, } @@ -463,9 +462,9 @@ func NewMessage(from common.Address, to *common.Address, nonce uint64, amount, g func (m Message) From() common.Address { return m.from } func (m Message) To() *common.Address { return m.to } -func (m Message) GasPrice() *big.Int { return m.price } +func (m Message) GasPrice() *big.Int { return m.gasPrice } func (m Message) Value() *big.Int { return m.amount } -func (m Message) Gas() *big.Int { return m.gasLimit } +func (m Message) Gas() uint64 { return m.gasLimit } func (m Message) Nonce() uint64 { return m.nonce } func (m Message) Data() []byte { return m.data } func (m Message) CheckNonce() bool { return m.checkNonce } diff --git a/core/types/transaction_signing_test.go b/core/types/transaction_signing_test.go index 7f799fb101..689fc38a9b 100644 --- a/core/types/transaction_signing_test.go +++ b/core/types/transaction_signing_test.go @@ -30,7 +30,7 @@ func TestEIP155Signing(t *testing.T) { addr := crypto.PubkeyToAddress(key.PublicKey) signer := NewEIP155Signer(big.NewInt(18)) - tx, err := SignTx(NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil), signer, key) + tx, err := SignTx(NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil), signer, key) if err != nil { t.Fatal(err) } @@ -49,7 +49,7 @@ func TestEIP155ChainId(t *testing.T) { addr := crypto.PubkeyToAddress(key.PublicKey) signer := NewEIP155Signer(big.NewInt(18)) - tx, err := SignTx(NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil), signer, key) + tx, err := SignTx(NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil), signer, key) if err != nil { t.Fatal(err) } @@ -61,7 +61,7 @@ func TestEIP155ChainId(t *testing.T) { t.Error("expected chainId to be", signer.chainId, "got", tx.ChainId()) } - tx = NewTransaction(0, addr, new(big.Int), new(big.Int), new(big.Int), nil) + tx = NewTransaction(0, addr, new(big.Int), 0, new(big.Int), nil) tx, err = SignTx(tx, HomesteadSigner{}, key) if err != nil { t.Fatal(err) @@ -118,7 +118,7 @@ func TestEIP155SigningVitalik(t *testing.T) { func TestChainId(t *testing.T) { key, _ := defaultTestKey() - tx := NewTransaction(0, common.Address{}, new(big.Int), new(big.Int), new(big.Int), nil) + tx := NewTransaction(0, common.Address{}, new(big.Int), 0, new(big.Int), nil) var err error tx, err = SignTx(tx, NewEIP155Signer(big.NewInt(1)), key) diff --git a/core/types/transaction_test.go b/core/types/transaction_test.go index 82d74e3b34..d1861b14cd 100644 --- a/core/types/transaction_test.go +++ b/core/types/transaction_test.go @@ -34,7 +34,7 @@ var ( emptyTx = NewTransaction( 0, common.HexToAddress("095e7baea6a6c7c4c2dfeb977efac326af552d87"), - big.NewInt(0), big.NewInt(0), big.NewInt(0), + big.NewInt(0), 0, big.NewInt(0), nil, ) @@ -42,7 +42,7 @@ var ( 3, common.HexToAddress("b94f5374fce5edbc8e2a8697c15331677e6ebf0b"), big.NewInt(10), - big.NewInt(2000), + 2000, big.NewInt(1), common.FromHex("5544"), ).WithSignature( @@ -139,7 +139,7 @@ func TestTransactionPriceNonceSort(t *testing.T) { for start, key := range keys { addr := crypto.PubkeyToAddress(key.PublicKey) for i := 0; i < 25; i++ { - tx, _ := SignTx(NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), big.NewInt(100), big.NewInt(int64(start+i)), nil), signer, key) + tx, _ := SignTx(NewTransaction(uint64(start+i), common.Address{}, big.NewInt(100), 100, big.NewInt(int64(start+i)), nil), signer, key) groups[addr] = append(groups[addr], tx) } } @@ -204,9 +204,9 @@ func TestTransactionJSON(t *testing.T) { var tx *Transaction switch i % 2 { case 0: - tx = NewTransaction(i, common.Address{1}, common.Big0, common.Big1, common.Big2, []byte("abcdef")) + tx = NewTransaction(i, common.Address{1}, common.Big0, 1, common.Big2, []byte("abcdef")) case 1: - tx = NewContractCreation(i, common.Big0, common.Big1, common.Big2, []byte("abcdef")) + tx = NewContractCreation(i, common.Big0, 1, common.Big2, []byte("abcdef")) } tx, err := SignTx(tx, signer, key) diff --git a/core/vm/evm.go b/core/vm/evm.go index 344435f73c..8796a633ec 100644 --- a/core/vm/evm.go +++ b/core/vm/evm.go @@ -19,6 +19,7 @@ package vm import ( "math/big" "sync/atomic" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" @@ -38,7 +39,7 @@ type ( ) // run runs the given contract and takes care of running precompiles with a fallback to the byte code interpreter. -func run(evm *EVM, snapshot int, contract *Contract, input []byte) ([]byte, error) { +func run(evm *EVM, contract *Contract, input []byte) ([]byte, error) { if contract.CodeAddr != nil { precompiles := PrecompiledContractsHomestead if evm.ChainConfig().IsByzantium(evm.BlockNumber) { @@ -48,7 +49,7 @@ func run(evm *EVM, snapshot int, contract *Contract, input []byte) ([]byte, erro return RunPrecompiledContract(p, input, contract) } } - return evm.interpreter.Run(snapshot, contract, input) + return evm.interpreter.Run(contract, input) } // Context provides the EVM with auxiliary information. Once provided @@ -68,7 +69,7 @@ type Context struct { // Block information Coinbase common.Address // Provides information for COINBASE - GasLimit *big.Int // Provides information for GASLIMIT + GasLimit uint64 // Provides information for GASLIMIT BlockNumber *big.Int // Provides information for NUMBER Time *big.Int // Provides information for TIME Difficulty *big.Int // Provides information for DIFFICULTY @@ -165,13 +166,23 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas } evm.Transfer(evm.StateDB, caller.Address(), to.Address(), value) - // initialise a new contract and set the code that is to be used by the - // E The contract is a scoped environment for this execution context - // only. + // Initialise a new contract and set the code that is to be used by the EVM. + // The contract is a scoped environment for this execution context only. contract := NewContract(caller, to, value, gas) contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr)) - ret, err = run(evm, snapshot, contract, input) + start := time.Now() + + // Capture the tracer start/end events in debug mode + if evm.vmConfig.Debug && evm.depth == 0 { + evm.vmConfig.Tracer.CaptureStart(caller.Address(), addr, false, input, gas, value) + + defer func() { // Lazy evaluation of the parameters + evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err) + }() + } + ret, err = run(evm, contract, input) + // When an error was returned by the EVM or when setting the creation code // above we revert to the snapshot and consume any gas remaining. Additionally // when we're in homestead this also counts for code storage gas errors. @@ -215,7 +226,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte, contract := NewContract(caller, to, value, gas) contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr)) - ret, err = run(evm, snapshot, contract, input) + ret, err = run(evm, contract, input) if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != errExecutionReverted { @@ -248,7 +259,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by contract := NewContract(caller, to, nil, gas).AsDelegate() contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr)) - ret, err = run(evm, snapshot, contract, input) + ret, err = run(evm, contract, input) if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != errExecutionReverted { @@ -291,7 +302,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte // When an error was returned by the EVM or when setting the creation code // above we revert to the snapshot and consume any gas remaining. Additionally // when we're in Homestead this also counts for code storage gas errors. - ret, err = run(evm, snapshot, contract, input) + ret, err = run(evm, contract, input) if err != nil { evm.StateDB.RevertToSnapshot(snapshot) if err != errExecutionReverted { @@ -338,7 +349,14 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I if evm.vmConfig.NoRecursion && evm.depth > 0 { return nil, contractAddr, gas, nil } - ret, err = run(evm, snapshot, contract, nil) + + if evm.vmConfig.Debug && evm.depth == 0 { + evm.vmConfig.Tracer.CaptureStart(caller.Address(), contractAddr, true, code, gas, value) + } + start := time.Now() + + ret, err = run(evm, contract, nil) + // check whether the max code size has been exceeded maxCodeSizeExceeded := evm.ChainConfig().IsEIP158(evm.BlockNumber) && len(ret) > params.MaxCodeSize // if the contract creation ran successfully and no errors were returned @@ -367,6 +385,9 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I if maxCodeSizeExceeded && err == nil { err = errMaxCodeSizeExceeded } + if evm.vmConfig.Debug && evm.depth == 0 { + evm.vmConfig.Tracer.CaptureEnd(ret, gas-contract.Gas, time.Since(start), err) + } return ret, contractAddr, contract.Gas, err } diff --git a/core/vm/gas_table.go b/core/vm/gas_table.go index ff109af57b..83adba428e 100644 --- a/core/vm/gas_table.go +++ b/core/vm/gas_table.go @@ -17,8 +17,6 @@ package vm import ( - "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/params" @@ -130,7 +128,7 @@ func gasSStore(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, m // 0 => non 0 return params.SstoreSetGas, nil } else if !common.EmptyHash(val) && common.EmptyHash(common.BigToHash(y)) { - evm.StateDB.AddRefund(new(big.Int).SetUint64(params.SstoreRefundGas)) + evm.StateDB.AddRefund(params.SstoreRefundGas) return params.SstoreClearGas, nil } else { @@ -405,7 +403,7 @@ func gasSuicide(gt params.GasTable, evm *EVM, contract *Contract, stack *Stack, } if !evm.StateDB.HasSuicided(contract.Address()) { - evm.StateDB.AddRefund(new(big.Int).SetUint64(params.SuicideRefundGas)) + evm.StateDB.AddRefund(params.SuicideRefundGas) } return gas, nil } diff --git a/core/vm/instructions.go b/core/vm/instructions.go index 1d1585fcac..7661725010 100644 --- a/core/vm/instructions.go +++ b/core/vm/instructions.go @@ -472,7 +472,7 @@ func opDifficulty(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stac } func opGasLimit(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.push(math.U256(new(big.Int).Set(evm.GasLimit))) + stack.push(math.U256(new(big.Int).SetUint64(evm.GasLimit))) return nil, nil } diff --git a/core/vm/interface.go b/core/vm/interface.go index c0c52732bb..1ef91cf1d6 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -39,8 +39,8 @@ type StateDB interface { SetCode(common.Address, []byte) GetCodeSize(common.Address) int - AddRefund(*big.Int) - GetRefund() *big.Int + AddRefund(uint64) + GetRefund() uint64 GetState(common.Address, common.Hash) common.Hash SetState(common.Address, common.Hash, common.Hash) diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index ac6000f97d..482e67a3a9 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -107,9 +107,9 @@ func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack // the return byte-slice and an error if one occurred. // // It's important to note that any errors returned by the interpreter should be -// considered a revert-and-consume-all-gas operation. No error specific checks -// should be handled to reduce complexity and errors further down the in. -func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret []byte, err error) { +// considered a revert-and-consume-all-gas operation except for +// errExecutionReverted which means revert-and-keep-gas-left. +func (in *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err error) { // Increment the call depth which is restricted to 1024 in.evm.depth++ defer func() { in.evm.depth-- }() @@ -144,12 +144,17 @@ func (in *Interpreter) Run(snapshot int, contract *Contract, input []byte) (ret ) contract.Input = input - defer func() { - if err != nil && !logged && in.cfg.Debug { - in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) - } - }() - + if in.cfg.Debug { + defer func() { + if err != nil { + if !logged { + in.cfg.Tracer.CaptureState(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) + } else { + in.cfg.Tracer.CaptureFault(in.evm, pcCopy, op, gasCopy, cost, mem, stack, contract, in.evm.depth, err) + } + } + }() + } // The Interpreter main run loop (contextual). This loop runs until either an // explicit STOP, RETURN or SELFDESTRUCT is executed, an error occurred during // the execution of one of the operations or until the done flag is set by the diff --git a/core/vm/logger.go b/core/vm/logger.go index 75309da921..1191814330 100644 --- a/core/vm/logger.go +++ b/core/vm/logger.go @@ -84,7 +84,9 @@ func (s *StructLog) OpName() string { // Note that reference types are actual VM data structures; make copies // if you need to retain them beyond the current call. type Tracer interface { + CaptureStart(from common.Address, to common.Address, call bool, input []byte, gas uint64, value *big.Int) error CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error + CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error } @@ -98,6 +100,8 @@ type StructLogger struct { logs []StructLog changedValues map[common.Address]Storage + output []byte + err error } // NewStructLogger returns a new logger @@ -111,6 +115,10 @@ func NewStructLogger(cfg *LogConfig) *StructLogger { return logger } +func (l *StructLogger) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error { + return nil +} + // CaptureState logs a new structured log message and pushes it out to the environment // // CaptureState also tracks SSTORE ops to track dirty values. @@ -161,19 +169,25 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui return nil } -func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { - fmt.Printf("0x%x", output) - if err != nil { - fmt.Printf(" error: %v\n", err) - } +func (l *StructLogger) CaptureFault(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error { return nil } -// StructLogs returns a list of captured log entries -func (l *StructLogger) StructLogs() []StructLog { - return l.logs +func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { + l.output = output + l.err = err + return nil } +// StructLogs returns the captured log entries. +func (l *StructLogger) StructLogs() []StructLog { return l.logs } + +// Error returns the VM error captured by the trace. +func (l *StructLogger) Error() error { return l.err } + +// Output returns the VM return value captured by the trace. +func (l *StructLogger) Output() []byte { return l.output } + // WriteTrace writes a formatted trace to the given writer func WriteTrace(writer io.Writer, logs []StructLog) { for _, log := range logs { diff --git a/core/vm/noop.go b/core/vm/noop.go index 2a04a95654..b71ead0d77 100644 --- a/core/vm/noop.go +++ b/core/vm/noop.go @@ -55,8 +55,8 @@ func (NoopStateDB) GetCodeHash(common.Address) common.Hash func (NoopStateDB) GetCode(common.Address) []byte { return nil } func (NoopStateDB) SetCode(common.Address, []byte) {} func (NoopStateDB) GetCodeSize(common.Address) int { return 0 } -func (NoopStateDB) AddRefund(*big.Int) {} -func (NoopStateDB) GetRefund() *big.Int { return nil } +func (NoopStateDB) AddRefund(uint64) {} +func (NoopStateDB) GetRefund() uint64 { return 0 } func (NoopStateDB) GetState(common.Address, common.Hash) common.Hash { return common.Hash{} } func (NoopStateDB) SetState(common.Address, common.Hash, common.Hash) {} func (NoopStateDB) Suicide(common.Address) bool { return false } diff --git a/core/vm/runtime/env.go b/core/vm/runtime/env.go index 818da1be26..31c9b9cf9d 100644 --- a/core/vm/runtime/env.go +++ b/core/vm/runtime/env.go @@ -17,8 +17,6 @@ package runtime import ( - "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/vm" @@ -35,7 +33,7 @@ func NewEnv(cfg *Config) *vm.EVM { BlockNumber: cfg.BlockNumber, Time: cfg.Time, Difficulty: cfg.Difficulty, - GasLimit: new(big.Int).SetUint64(cfg.GasLimit), + GasLimit: cfg.GasLimit, GasPrice: cfg.GasPrice, } diff --git a/crypto/crypto.go b/crypto/crypto.go index 3a98bfb503..1c4d5a2e02 100644 --- a/crypto/crypto.go +++ b/crypto/crypto.go @@ -79,7 +79,7 @@ func ToECDSA(d []byte) (*ecdsa.PrivateKey, error) { return toECDSA(d, true) } -// ToECDSAUnsafe blidly converts a binary blob to a private key. It should almost +// ToECDSAUnsafe blindly converts a binary blob to a private key. It should almost // never be used unless you are sure the input is valid and want to avoid hitting // errors due to bad origin encoding (0 prefixes cut off). func ToECDSAUnsafe(d []byte) *ecdsa.PrivateKey { @@ -97,6 +97,16 @@ func toECDSA(d []byte, strict bool) (*ecdsa.PrivateKey, error) { return nil, fmt.Errorf("invalid length, need %d bits", priv.Params().BitSize) } priv.D = new(big.Int).SetBytes(d) + + // The priv.D must < N + if priv.D.Cmp(secp256k1_N) >= 0 { + return nil, fmt.Errorf("invalid private key, >=N") + } + // The priv.D must not be zero or negative. + if priv.D.Sign() <= 0 { + return nil, fmt.Errorf("invalid private key, zero or negative") + } + priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(d) if priv.PublicKey.X == nil { return nil, errors.New("invalid private key") diff --git a/crypto/ecies/ecies.go b/crypto/ecies/ecies.go index 1d5f96ed27..2ed91c895d 100644 --- a/crypto/ecies/ecies.go +++ b/crypto/ecies/ecies.go @@ -314,7 +314,7 @@ func (prv *PrivateKey) Decrypt(rand io.Reader, c, s1, s2 []byte) (m []byte, err switch c[0] { case 2, 3, 4: - rLen = ((prv.PublicKey.Curve.Params().BitSize + 7) / 4) + rLen = (prv.PublicKey.Curve.Params().BitSize + 7) / 4 if len(c) < (rLen + hLen + 1) { err = ErrInvalidMessage return diff --git a/crypto/secp256k1/curve.go b/crypto/secp256k1/curve.go index ec6d266cec..df80481857 100644 --- a/crypto/secp256k1/curve.go +++ b/crypto/secp256k1/curve.go @@ -34,7 +34,6 @@ package secp256k1 import ( "crypto/elliptic" "math/big" - "sync" "unsafe" "github.com/ethereum/go-ethereum/common/math" @@ -42,7 +41,7 @@ import ( /* #include "libsecp256k1/include/secp256k1.h" -extern int secp256k1_pubkey_scalar_mul(const secp256k1_context* ctx, const unsigned char *point, const unsigned char *scalar); +extern int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, const unsigned char *point, const unsigned char *scalar); */ import "C" @@ -236,7 +235,7 @@ func (BitCurve *BitCurve) ScalarMult(Bx, By *big.Int, scalar []byte) (*big.Int, math.ReadBits(By, point[32:]) pointPtr := (*C.uchar)(unsafe.Pointer(&point[0])) scalarPtr := (*C.uchar)(unsafe.Pointer(&scalar[0])) - res := C.secp256k1_pubkey_scalar_mul(context, pointPtr, scalarPtr) + res := C.secp256k1_ext_scalar_mul(context, pointPtr, scalarPtr) // Unpack the result and clear temporaries. x := new(big.Int).SetBytes(point[:32]) @@ -263,14 +262,10 @@ func (BitCurve *BitCurve) ScalarBaseMult(k []byte) (*big.Int, *big.Int) { // X9.62. func (BitCurve *BitCurve) Marshal(x, y *big.Int) []byte { byteLen := (BitCurve.BitSize + 7) >> 3 - ret := make([]byte, 1+2*byteLen) - ret[0] = 4 // uncompressed point - - xBytes := x.Bytes() - copy(ret[1+byteLen-len(xBytes):], xBytes) - yBytes := y.Bytes() - copy(ret[1+2*byteLen-len(yBytes):], yBytes) + ret[0] = 4 // uncompressed point flag + math.ReadBits(x, ret[1:1+byteLen]) + math.ReadBits(y, ret[1+byteLen:]) return ret } @@ -289,24 +284,21 @@ func (BitCurve *BitCurve) Unmarshal(data []byte) (x, y *big.Int) { return } -var ( - initonce sync.Once - theCurve *BitCurve -) +var theCurve = new(BitCurve) -// S256 returns a BitCurve which implements secp256k1 (see SEC 2 section 2.7.1) +func init() { + // See SEC 2 section 2.7.1 + // curve parameters taken from: + // http://www.secg.org/collateral/sec2_final.pdf + theCurve.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16) + theCurve.N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16) + theCurve.B, _ = new(big.Int).SetString("0000000000000000000000000000000000000000000000000000000000000007", 16) + theCurve.Gx, _ = new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16) + theCurve.Gy, _ = new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16) + theCurve.BitSize = 256 +} + +// S256 returns a BitCurve which implements secp256k1. func S256() *BitCurve { - initonce.Do(func() { - // See SEC 2 section 2.7.1 - // curve parameters taken from: - // http://www.secg.org/collateral/sec2_final.pdf - theCurve = new(BitCurve) - theCurve.P, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16) - theCurve.N, _ = new(big.Int).SetString("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16) - theCurve.B, _ = new(big.Int).SetString("0000000000000000000000000000000000000000000000000000000000000007", 16) - theCurve.Gx, _ = new(big.Int).SetString("79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", 16) - theCurve.Gy, _ = new(big.Int).SetString("483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", 16) - theCurve.BitSize = 256 - }) return theCurve } diff --git a/crypto/secp256k1/ext.h b/crypto/secp256k1/ext.h index b0f30b73c6..9b043c724e 100644 --- a/crypto/secp256k1/ext.h +++ b/crypto/secp256k1/ext.h @@ -19,7 +19,7 @@ static secp256k1_context* secp256k1_context_create_sign_verify() { return secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY); } -// secp256k1_ecdsa_recover_pubkey recovers the public key of an encoded compact signature. +// secp256k1_ext_ecdsa_recover recovers the public key of an encoded compact signature. // // Returns: 1: recovery was successful // 0: recovery was not successful @@ -27,7 +27,7 @@ static secp256k1_context* secp256k1_context_create_sign_verify() { // Out: pubkey_out: the serialized 65-byte public key of the signer (cannot be NULL) // In: sigdata: pointer to a 65-byte signature with the recovery id at the end (cannot be NULL) // msgdata: pointer to a 32-byte message (cannot be NULL) -static int secp256k1_ecdsa_recover_pubkey( +static int secp256k1_ext_ecdsa_recover( const secp256k1_context* ctx, unsigned char *pubkey_out, const unsigned char *sigdata, @@ -46,7 +46,7 @@ static int secp256k1_ecdsa_recover_pubkey( return secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &outputlen, &pubkey, SECP256K1_EC_UNCOMPRESSED); } -// secp256k1_ecdsa_verify_enc verifies an encoded compact signature. +// secp256k1_ext_ecdsa_verify verifies an encoded compact signature. // // Returns: 1: signature is valid // 0: signature is invalid @@ -55,7 +55,7 @@ static int secp256k1_ecdsa_recover_pubkey( // msgdata: pointer to a 32-byte message (cannot be NULL) // pubkeydata: pointer to public key data (cannot be NULL) // pubkeylen: length of pubkeydata -static int secp256k1_ecdsa_verify_enc( +static int secp256k1_ext_ecdsa_verify( const secp256k1_context* ctx, const unsigned char *sigdata, const unsigned char *msgdata, @@ -74,28 +74,34 @@ static int secp256k1_ecdsa_verify_enc( return secp256k1_ecdsa_verify(ctx, &sig, msgdata, &pubkey); } -// secp256k1_decompress_pubkey decompresses a public key. +// secp256k1_ext_reencode_pubkey decodes then encodes a public key. It can be used to +// convert between public key formats. The input/output formats are chosen depending on the +// length of the input/output buffers. // -// Returns: 1: public key is valid -// 0: public key is invalid +// Returns: 1: conversion successful +// 0: conversion unsuccessful // Args: ctx: pointer to a context object (cannot be NULL) -// Out: pubkey_out: the serialized 65-byte public key (cannot be NULL) -// In: pubkeydata: pointer to 33 bytes of compressed public key data (cannot be NULL) -static int secp256k1_decompress_pubkey( +// Out: out: output buffer that will contain the reencoded key (cannot be NULL) +// In: outlen: length of out (33 for compressed keys, 65 for uncompressed keys) +// pubkeydata: the input public key (cannot be NULL) +// pubkeylen: length of pubkeydata +static int secp256k1_ext_reencode_pubkey( const secp256k1_context* ctx, - unsigned char *pubkey_out, - const unsigned char *pubkeydata + unsigned char *out, + size_t outlen, + const unsigned char *pubkeydata, + size_t pubkeylen ) { secp256k1_pubkey pubkey; - if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, 33)) { + if (!secp256k1_ec_pubkey_parse(ctx, &pubkey, pubkeydata, pubkeylen)) { return 0; } - size_t outputlen = 65; - return secp256k1_ec_pubkey_serialize(ctx, pubkey_out, &outputlen, &pubkey, SECP256K1_EC_UNCOMPRESSED); + unsigned int flag = (outlen == 33) ? SECP256K1_EC_COMPRESSED : SECP256K1_EC_UNCOMPRESSED; + return secp256k1_ec_pubkey_serialize(ctx, out, &outlen, &pubkey, flag); } -// secp256k1_pubkey_scalar_mul multiplies a point by a scalar in constant time. +// secp256k1_ext_scalar_mul multiplies a point by a scalar in constant time. // // Returns: 1: multiplication was successful // 0: scalar was invalid (zero or overflow) @@ -104,7 +110,7 @@ static int secp256k1_decompress_pubkey( // In: point: pointer to a 64-byte public point, // encoded as two 256bit big-endian numbers. // scalar: a 32-byte scalar with which to multiply the point -int secp256k1_pubkey_scalar_mul(const secp256k1_context* ctx, unsigned char *point, const unsigned char *scalar) { +int secp256k1_ext_scalar_mul(const secp256k1_context* ctx, unsigned char *point, const unsigned char *scalar) { int ret = 0; int overflow = 0; secp256k1_fe feX, feY; diff --git a/crypto/secp256k1/secp256.go b/crypto/secp256k1/secp256.go index 00a1f8aaa4..eefbb99ee4 100644 --- a/crypto/secp256k1/secp256.go +++ b/crypto/secp256k1/secp256.go @@ -115,7 +115,7 @@ func RecoverPubkey(msg []byte, sig []byte) ([]byte, error) { sigdata = (*C.uchar)(unsafe.Pointer(&sig[0])) msgdata = (*C.uchar)(unsafe.Pointer(&msg[0])) ) - if C.secp256k1_ecdsa_recover_pubkey(context, (*C.uchar)(unsafe.Pointer(&pubkey[0])), sigdata, msgdata) == 0 { + if C.secp256k1_ext_ecdsa_recover(context, (*C.uchar)(unsafe.Pointer(&pubkey[0])), sigdata, msgdata) == 0 { return nil, ErrRecoverFailed } return pubkey, nil @@ -130,22 +130,42 @@ func VerifySignature(pubkey, msg, signature []byte) bool { sigdata := (*C.uchar)(unsafe.Pointer(&signature[0])) msgdata := (*C.uchar)(unsafe.Pointer(&msg[0])) keydata := (*C.uchar)(unsafe.Pointer(&pubkey[0])) - return C.secp256k1_ecdsa_verify_enc(context, sigdata, msgdata, keydata, C.size_t(len(pubkey))) != 0 + return C.secp256k1_ext_ecdsa_verify(context, sigdata, msgdata, keydata, C.size_t(len(pubkey))) != 0 } // DecompressPubkey parses a public key in the 33-byte compressed format. // It returns non-nil coordinates if the public key is valid. -func DecompressPubkey(pubkey []byte) (X, Y *big.Int) { +func DecompressPubkey(pubkey []byte) (x, y *big.Int) { if len(pubkey) != 33 { return nil, nil } - buf := make([]byte, 65) - bufdata := (*C.uchar)(unsafe.Pointer(&buf[0])) - pubkeydata := (*C.uchar)(unsafe.Pointer(&pubkey[0])) - if C.secp256k1_decompress_pubkey(context, bufdata, pubkeydata) == 0 { + var ( + pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0])) + pubkeylen = C.size_t(len(pubkey)) + out = make([]byte, 65) + outdata = (*C.uchar)(unsafe.Pointer(&out[0])) + outlen = C.size_t(len(out)) + ) + if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 { return nil, nil } - return new(big.Int).SetBytes(buf[1:33]), new(big.Int).SetBytes(buf[33:]) + return new(big.Int).SetBytes(out[1:33]), new(big.Int).SetBytes(out[33:]) +} + +// CompressPubkey encodes a public key to 33-byte compressed format. +func CompressPubkey(x, y *big.Int) []byte { + var ( + pubkey = S256().Marshal(x, y) + pubkeydata = (*C.uchar)(unsafe.Pointer(&pubkey[0])) + pubkeylen = C.size_t(len(pubkey)) + out = make([]byte, 33) + outdata = (*C.uchar)(unsafe.Pointer(&out[0])) + outlen = C.size_t(len(out)) + ) + if C.secp256k1_ext_reencode_pubkey(context, outdata, outlen, pubkeydata, pubkeylen) == 0 { + panic("libsecp256k1 error") + } + return out } func checkSignature(sig []byte) error { diff --git a/crypto/signature_cgo.go b/crypto/signature_cgo.go index 381d8a1bbc..340bfc221e 100644 --- a/crypto/signature_cgo.go +++ b/crypto/signature_cgo.go @@ -76,6 +76,11 @@ func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) { return &ecdsa.PublicKey{X: x, Y: y, Curve: S256()}, nil } +// CompressPubkey encodes a public key to the 33-byte compressed format. +func CompressPubkey(pubkey *ecdsa.PublicKey) []byte { + return secp256k1.CompressPubkey(pubkey.X, pubkey.Y) +} + // S256 returns an instance of the secp256k1 curve. func S256() elliptic.Curve { return secp256k1.S256() diff --git a/crypto/signature_nocgo.go b/crypto/signature_nocgo.go index 17fd613b21..f636b23772 100644 --- a/crypto/signature_nocgo.go +++ b/crypto/signature_nocgo.go @@ -87,6 +87,10 @@ func VerifySignature(pubkey, hash, signature []byte) bool { if err != nil { return false } + // Reject malleable signatures. libsecp256k1 does this check but btcec doesn't. + if sig.S.Cmp(secp256k1_halfN) > 0 { + return false + } return sig.Verify(hash, key) } @@ -102,6 +106,11 @@ func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error) { return key.ToECDSA(), nil } +// CompressPubkey encodes a public key to the 33-byte compressed format. +func CompressPubkey(pubkey *ecdsa.PublicKey) []byte { + return (*btcec.PublicKey)(pubkey).SerializeCompressed() +} + // S256 returns an instance of the secp256k1 curve. func S256() elliptic.Curve { return btcec.S256() diff --git a/crypto/signature_test.go b/crypto/signature_test.go index abcab425b5..aecff76bfb 100644 --- a/crypto/signature_test.go +++ b/crypto/signature_test.go @@ -18,10 +18,13 @@ package crypto import ( "bytes" + "crypto/ecdsa" + "reflect" "testing" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" ) var ( @@ -65,6 +68,21 @@ func TestVerifySignature(t *testing.T) { if VerifySignature(testpubkey, testmsg, sig[:len(sig)-2]) { t.Errorf("signature valid even though it's incomplete") } + wrongkey := common.CopyBytes(testpubkey) + wrongkey[10]++ + if VerifySignature(wrongkey, testmsg, sig) { + t.Errorf("signature valid with with wrong public key") + } +} + +// This test checks that VerifySignature rejects malleable signatures with s > N/2. +func TestVerifySignatureMalleable(t *testing.T) { + sig := hexutil.MustDecode("0x638a54215d80a6713c8d523a6adc4e6e73652d859103a36b700851cb0e61b66b8ebfc1a610c57d732ec6e0a8f06a9a7a28df5051ece514702ff9cdff0b11f454") + key := hexutil.MustDecode("0x03ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138") + msg := hexutil.MustDecode("0xd301ce462d3e639518f482c7f03821fec1e602018630ce621e1e7851c12343a6") + if VerifySignature(key, msg, sig) { + t.Error("VerifySignature returned true for malleable signature") + } } func TestDecompressPubkey(t *testing.T) { @@ -86,6 +104,36 @@ func TestDecompressPubkey(t *testing.T) { } } +func TestCompressPubkey(t *testing.T) { + key := &ecdsa.PublicKey{ + Curve: S256(), + X: math.MustParseBig256("0xe32df42865e97135acfb65f3bae71bdc86f4d49150ad6a440b6f15878109880a"), + Y: math.MustParseBig256("0x0a2b2667f7e725ceea70c673093bf67663e0312623c8e091b13cf2c0f11ef652"), + } + compressed := CompressPubkey(key) + if !bytes.Equal(compressed, testpubkeyc) { + t.Errorf("wrong public key result: got %x, want %x", compressed, testpubkeyc) + } +} + +func TestPubkeyRandom(t *testing.T) { + const runs = 200 + + for i := 0; i < runs; i++ { + key, err := GenerateKey() + if err != nil { + t.Fatalf("iteration %d: %v", i, err) + } + pubkey2, err := DecompressPubkey(CompressPubkey(&key.PublicKey)) + if err != nil { + t.Fatalf("iteration %d: %v", i, err) + } + if !reflect.DeepEqual(key.PublicKey, *pubkey2) { + t.Fatalf("iteration %d: keys not equal", i) + } + } +} + func BenchmarkEcrecoverSignature(b *testing.B) { for i := 0; i < b.N; i++ { if _, err := Ecrecover(testmsg, testsig); err != nil { diff --git a/dashboard/README.md b/dashboard/README.md index 84810f7173..da28f5a192 100644 --- a/dashboard/README.md +++ b/dashboard/README.md @@ -9,10 +9,11 @@ The client's UI uses [React][React] with JSX syntax, which is validated by the [ ### Development and bundling -As the dashboard depends on certain NPM packages (which are not included in the go-ethereum repo), these need to be installed first: +As the dashboard depends on certain NPM packages (which are not included in the `go-ethereum` repo), these need to be installed first: ``` $ (cd dashboard/assets && npm install) +$ (cd dashboard/assets && ./node_modules/.bin/flow-typed install) ``` Normally the dashboard assets are bundled into Geth via `go-bindata` to avoid external dependencies. Rebuilding Geth after each UI modification however is not feasible from a developer perspective. Instead, we can run `webpack` in watch mode to automatically rebundle the UI, and ask `geth` to use external assets to not rely on compiled resources: @@ -22,13 +23,20 @@ $ (cd dashboard/assets && ./node_modules/.bin/webpack --watch) $ geth --dashboard --dashboard.assets=dashboard/assets/public --vmodule=dashboard=5 ``` -To bundle up the final UI into Geth, run `webpack` and `go generate`: +To bundle up the final UI into Geth, run `go generate`: ``` -$ (cd dashboard/assets && ./node_modules/.bin/webpack) $ go generate ./dashboard ``` +### Static type checking + +Since JavaScript doesn't provide type safety, [Flow][Flow] is used to check types. These are only useful during development, so at the end of the process Babel will strip them. + +To take advantage of static type checking, your IDE needs to be prepared for it. In case of [Atom][Atom] a configuration guide can be found [here][Atom config]: Install the [Nuclide][Nuclide] package for Flow support, making sure it installs all of its support packages by enabling `Install Recommended Packages on Startup`, and set the path of the `flow-bin` which were installed previously by `npm`. + +For more IDE support install the `linter-eslint` package too, which finds the `.eslintrc` file, and provides real-time linting. Atom warns, that these two packages are incompatible, but they seem to work well together. For third-party library errors and auto-completion [flow-typed][flow-typed] is used. + ### Have fun [Webpack][Webpack] offers handy tools for visualizing the bundle's dependency tree and space usage. @@ -44,3 +52,8 @@ $ go generate ./dashboard [WA]: http://webpack.github.io/analyse/ [WV]: http://chrisbateman.github.io/webpack-visualizer/ [Node.js]: https://nodejs.org/en/ +[Flow]: https://flow.org/ +[Atom]: https://atom.io/ +[Atom config]: https://medium.com/@fastphrase/integrating-flow-into-a-react-project-fbbc2f130eed +[Nuclide]: https://nuclide.io/docs/quick-start/getting-started/ +[flow-typed]: https://github.com/flowtype/flow-typed diff --git a/dashboard/assets.go b/dashboard/assets.go index ef2cf6ac9a..71868d9772 100644 --- a/dashboard/assets.go +++ b/dashboard/assets.go @@ -7,10 +7,7 @@ package dashboard import ( - "bytes" - "compress/gzip" "fmt" - "io" "io/ioutil" "os" "path/filepath" @@ -18,26 +15,6 @@ import ( "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 @@ -69,13 +46,42062 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _publicBundleJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xbd\x7d\x57\x1b\xb9\x93\x28\xfc\xf7\xf0\x29\x94\xdc\x59\x6c\x27\xc6\x60\x92\xcc\x0b\x0c\x93\x25\x84\x64\xd9\x9b\x84\xdc\xc0\xcc\xdc\x3d\x2c\xd7\x91\xbb\x65\x5b\xa1\xdd\xf2\x74\xb7\x01\xff\x02\xdf\xfd\x39\xaa\xd2\x7b\x77\x1b\x63\x9c\xf9\xed\xec\xb3\xe4\x9c\xd8\x96\x4a\xa5\x52\xa9\x54\x7a\x2b\x55\x6d\x3e\x81\xbf\x4d\xd2\x1c\x4c\xd3\xa8\xe0\x22\x6d\x8e\x45\x3c\x4d\x58\xde\x22\x5f\xc9\xe6\x26\xb9\x62\xfd\x09\x8d\x2e\x5e\x09\x51\xe4\x45\x46\x27\x6b\xa6\xc4\x77\x9b\x9b\xe4\x74\xc4\x08\xc2\x93\x88\x46\x23\xe6\xe4\x5e\xd2\x8c\xf0\x34\x2f\x68\x92\xb0\xf8\x3d\xe2\x24\x7b\xe4\xeb\xed\xae\x01\x2a\xe3\xca\xd8\x9f\x53\x9e\x31\xa2\x89\x71\x20\x74\x12\xe9\xf5\x14\x4d\x3d\x05\xdd\xeb\x29\x9a\x8f\xe2\x16\xf9\x5a\x85\x5d\xa2\x3f\x18\xb1\xe8\x82\xf0\x81\xa6\x97\xe7\x84\xa7\x25\xaa\xbf\xe3\x83\x66\x48\xf5\x99\xc6\x7e\xee\xa2\x27\xdf\x7d\xf7\x5d\xc6\x8a\x69\x96\x96\x9a\x69\x0b\x74\xd8\xf5\x44\x64\x45\xbe\xeb\x16\xbb\x0d\x29\xcb\x18\x2d\x18\xa1\x24\x65\x57\x9a\xba\x26\x4d\x63\x32\x99\x16\x84\x17\x84\xa7\x85\x20\xc5\x48\xb1\xb8\xe5\x96\x96\x4c\x56\x25\xf6\xe6\x90\x21\xf9\xee\x11\xce\x77\x88\xce\x6c\x7b\x19\xc9\x0e\x19\xd0\x24\x67\x7e\xaa\x6a\xc5\x0e\xf9\xea\xd1\x5e\xdd\x95\xb2\x49\x87\xd7\x2c\x9a\x16\x0c\xa8\x56\xf4\x55\x74\xe9\x77\xe3\x12\xbf\x22\x9a\x24\xaa\x37\x35\xef\xda\x0a\x83\xfe\xb4\xe9\x15\x92\xd0\xaa\x25\xe9\x4d\x42\x87\x2e\x3d\x34\x27\x89\xa0\x31\x8b\xcb\x04\x75\x12\xb2\x47\x8a\x6c\xca\x6a\x91\x7d\xc2\x8e\x97\xe8\x14\x35\x44\x0c\x1c\xec\x2e\xb8\x12\x12\x9f\x78\x57\x20\x6e\xcb\xb5\xf8\x23\x43\x96\xc9\x5d\x66\xe6\x44\xf4\xbf\xb0\xa8\x20\x4d\xcb\x02\x95\xd3\xeb\xb9\x02\x52\xc1\xa1\xce\x98\xec\x69\x34\x75\x43\xb1\x54\x61\x69\x9c\x54\x21\x8e\x2a\x64\xb0\xae\x86\x98\x0d\x78\xca\xc8\x90\x15\x05\xcb\x8c\x6c\x90\x81\xc8\xc8\x88\x66\x63\x91\xce\x34\x63\xef\xa8\x34\x26\x7b\xa6\x78\xd3\x48\x46\x4a\xc7\xac\xad\xb0\x07\x83\x96\x0f\x9a\x8f\xaa\x10\x09\xbf\x74\x2b\x1c\xeb\xc7\xc0\xf1\x0e\x12\xfe\x31\x13\x13\x96\x15\xb3\xb0\x46\xbf\xc8\x77\x91\x48\x07\x7c\x38\xcd\x68\x3f\x61\x95\x03\xeb\x3b\x96\x4e\xc7\x4c\xe5\x4b\x89\x0b\xb2\x87\xac\xd8\x51\xcd\xf0\x32\x6e\x5b\xb5\x1a\xa5\x56\xbf\x0e\x59\xf1\x9a\x0d\xe8\x34\x29\x0e\x81\x68\x9f\xeb\x91\x18\x4f\x68\xc1\xfb\x3c\xe1\xc5\x8c\x5c\xf1\x62\x44\x52\x91\x6e\xe8\xce\x50\x02\x73\x47\x67\xa4\x6e\x67\x60\x91\x80\x8d\x52\x61\xa9\x4e\xd7\x52\x48\xd6\xd7\xf5\xe0\xe8\xf5\x58\x8e\x82\x43\x5e\x7a\xed\x35\xa4\xda\x46\x34\xe5\x04\xe5\x8d\xad\xb3\x46\x8c\x59\x8d\xf3\x5d\x72\x4b\x76\x6a\x31\x60\x15\xc8\x85\xbc\x8c\x67\x97\xdc\x7a\xdc\xad\x14\xbb\x26\xb6\xa2\x4d\x1a\xb4\x61\x24\x6d\xb7\x62\xdc\x63\xd6\xee\x22\x3d\xa4\x44\x6c\x92\x89\x42\x14\xb3\x09\xeb\x8c\x68\x7e\x7c\x95\x6a\x61\x03\xe5\x78\x47\x0f\x08\xb7\x07\x50\x49\xb4\xc9\x44\x21\x70\x5a\xba\x48\x55\xe5\xf2\x1e\x67\x7c\xda\x2d\x31\x93\x69\x3f\xe1\x51\x6f\x42\x8b\x51\xaf\x77\x07\xb9\x13\xb2\x47\x1e\x3f\xae\xc3\xf9\x4e\xd0\x98\xb0\xb4\xc8\x66\x46\x69\xa7\xb1\x6e\x41\x59\x3d\xa8\x8c\xaa\xf5\x41\x55\xdd\x72\x35\xf2\x7c\x6b\xdb\xed\xb4\x5b\xa3\x3b\x1f\xfe\xe7\xb4\xa5\x79\xb6\xb6\xf9\x84\x6c\x11\x95\x56\x5e\x6c\xb5\xc9\xdc\x39\x8d\x7c\x5d\x93\x08\xfe\x38\x7c\xf5\x71\xff\xe0\x7f\x93\xdf\xf7\x3f\x91\xa3\x0f\xff\x7e\x78\x70\x7a\x74\xfc\x81\x3c\xd9\xb4\xd8\x26\x99\x88\x58\x2e\x97\x6e\x9b\x4f\x9e\xac\x91\x27\xe4\x40\x4c\x66\x19\x1f\x8e\x0a\xd2\x8c\x5a\x64\x7b\xab\xfb\x6c\x63\x92\xb1\x9c\xa5\x45\x9b\xbc\xa1\x11\xeb\x0b\x71\xd1\x26\x47\x69\xd4\x59\x23\x50\xe0\x74\xc4\x73\x92\x8b\x69\x16\x31\x12\x89\x18\x96\x49\x09\x8f\x58\x9a\xb3\x98\x4c\xd3\x98\x65\x30\x2b\xbc\x3f\x3a\xd5\xc9\x64\x20\xa6\x69\x2c\xd7\x52\xc5\x88\x49\x14\xef\x8e\x0e\x0e\x3f\x9c\x1c\x92\x01\x97\xab\x2c\x9c\x24\x33\x21\x0a\x12\xf3\x8c\x45\x85\xc8\x66\x38\x57\xda\x8a\x8a\x8c\x31\x49\xc0\xe6\xda\x1a\x1f\x10\xdd\x8a\x0e\x4b\x2f\x3b\x1f\x8e\x5f\x1f\xf6\x0e\x3f\xfc\x4e\x1e\xed\xed\x91\xc6\x24\x13\xf1\x14\x9a\xda\x90\x4c\x21\x44\xaa\x93\x4f\x87\xfb\x07\xa7\xbd\xc3\x77\x87\xef\x0f\x3f\x9c\xf6\x4e\xff\xe3\xe3\x21\xd9\x23\x4d\x29\xd4\x62\x40\x4e\x66\xe3\xbe\x48\xc8\x9e\x2c\xad\xd9\xd4\x20\xeb\xeb\x6b\x84\x10\x95\xd9\x91\xea\xaf\x94\xd2\x6c\x64\x8c\x46\x45\x87\x25\x6c\xcc\xd2\xa2\xd1\x6a\x91\x9b\x1b\x80\xd9\xba\x66\x34\xfa\x71\x77\x4d\x55\xcf\xf3\xdf\x69\xc2\xe3\x43\x84\x2b\x0f\x3f\x24\x94\x68\xb1\x55\x74\xa9\xf9\x1b\xe8\xc2\xef\x86\x2a\xa2\x33\x65\x93\xd3\x69\x92\x84\x19\x9d\xef\xbf\x57\x58\x64\xf1\x72\xf3\x77\xd7\x88\x1c\xa7\x6b\x44\xae\xdf\x5f\xc1\x44\x9a\xf0\x88\x17\xc9\x8c\x4c\x73\x9e\x0e\xc9\x67\x39\xa0\x37\x24\x8e\xfc\x33\x99\x89\x29\xa1\x19\x23\x62\x52\xc8\x3c\x58\x6c\xca\x85\x68\xcc\x2e\x59\x22\x26\xd0\xa8\x3e\x1b\xd1\x4b\x2e\xb2\x0e\xe2\x1c\x15\xc5\x64\x67\x73\x73\xd0\xef\x8c\xd9\xa6\xc5\xb5\xc1\xd3\x0d\xd9\x43\x8a\x31\xc5\x28\x13\x57\xc7\xe9\x6b\xe8\xf5\xfd\x48\x76\xa9\x59\x56\x91\x60\x39\x44\xf6\x2a\x87\xed\xf3\xe7\x2f\x5a\x4d\x9f\xc1\xed\x2a\xbc\xad\xdd\xb5\x5b\xc2\x92\x9c\x01\xaf\x1f\xd2\x6a\x2b\x61\xf7\x6f\xf4\x82\x4d\xfa\xa1\xd5\x94\xf4\xce\x1d\xd2\xb7\xa8\x80\xe7\x69\x85\xe6\xb3\x56\xab\xb5\xa6\x14\xca\x6d\x4b\x2e\x1c\x48\xf7\x41\x2a\xe6\xf1\x34\x67\x24\x2f\x32\x1e\x15\xa0\x92\xef\xa5\x70\xe6\x0c\xdd\xbd\xca\xa1\xbb\x18\xb7\xb6\x9e\xf9\x7d\xbb\x60\xa9\xe7\xdf\x8a\xc3\xdb\x0f\xe2\xb0\x1c\x16\xbd\x9e\x22\xa9\xb7\xff\xfe\x75\xef\xf5\xe1\x9b\xa3\x0f\x87\xbd\xfd\x4f\x9f\xf6\xff\xa3\xd7\x6b\x57\xe7\x7e\x3a\x3c\xf9\xed\xdd\x69\xaf\xb7\xbb\xf9\xe4\xd1\x1a\x29\x2b\xf5\x1f\xc8\xbf\xb3\x98\xfc\x41\x8b\x5c\xa4\x52\x5a\xdf\x55\x2b\x6c\x95\x4c\x9a\xef\x8f\x4e\x5b\x6d\x92\x33\xb6\x46\xb4\x58\x7f\x61\xf1\x15\x96\x1f\xf2\x62\x34\xed\x77\xb8\xd8\x8c\x12\x9a\xe7\x72\x5d\x9b\xaf\x41\xa3\xc9\x30\x11\x7d\x9a\xe8\xb5\xbb\x54\xd7\x86\x07\x44\x2e\xa3\xd6\xbe\x6b\x58\x11\x6a\xec\xae\xad\xc1\x72\x0f\x57\x16\xb0\xf5\x0f\x56\x19\x12\xc2\x20\x80\xda\x3e\xc8\xda\x14\x2e\x28\x0c\xa9\x70\x70\x70\x76\x2e\xc1\xbf\x93\xca\xba\x09\x7a\x97\xec\x91\xad\x5d\xc2\xc9\x2f\x84\x66\xc3\xa9\xd4\x0d\x79\x27\x61\xe9\xb0\x18\xed\x12\xfe\xf4\x29\xe2\x00\x24\x34\x1b\x92\x3d\x0b\x75\xc6\xcf\x77\x65\x96\x14\xd8\x47\x34\x1b\xb6\x48\x24\xd2\x82\xa7\x52\x31\x39\x45\x4e\x67\x13\xb9\xab\x56\xaa\x96\x66\x43\xcc\x95\xa5\x4c\xae\x94\x6c\xd9\xdc\x74\xd8\x20\x37\x37\xc4\x4b\x4f\xa7\xe3\x3e\xcb\x1a\x8a\x8e\xef\x54\x4b\x3a\x93\x69\x3e\x92\x08\x5a\x40\x83\x12\x6d\x89\x74\x3f\xcb\xe8\xac\xc3\x73\xf8\x04\x88\xca\xa2\x96\x4f\x1d\x3a\x99\x24\xb3\xa6\x9c\x22\xda\x04\xe0\x43\x94\x1e\x3d\x6a\x9a\xd1\x48\x0d\x23\x2f\xd8\x4c\x4e\xd3\xc0\x08\xcc\x82\x36\x62\x57\xe1\x28\xa1\xd9\xb0\x2d\xe1\x5a\x72\xad\x4e\xb3\xe1\xd9\x05\x9b\x9d\x1b\x68\x9f\x3e\x09\xb6\x8b\x19\xb7\x6b\xe6\x7f\xf9\xdf\xad\xe4\x9f\x9a\x06\x75\x91\x2f\x82\xa7\xcd\x06\x69\xc8\x22\x32\x5f\xd6\xac\x38\xae\x96\x7c\x30\xf1\x4b\x41\x96\x42\x17\x37\x9c\xdd\x82\x1a\x6e\x48\x47\x49\x31\x58\x3e\x49\xd4\x96\x27\x72\x02\xc2\x22\x9b\x9b\x24\x63\x43\x9e\xcb\xcd\x08\xcd\x49\xc3\xca\x7b\xa3\x2d\x45\x22\x97\x59\x69\xa1\x36\x43\x93\x31\x91\x23\x9a\x0e\x19\xec\xf5\xd6\xbe\xfb\xee\x51\x73\xde\x58\x06\x91\xbd\x63\x40\x3b\xab\x05\x2d\xf4\x1e\x83\x34\xf9\xdf\xdd\xaa\xbe\x76\x34\x4c\x7d\xcd\xad\x36\xf0\x7d\x7e\xcd\x92\xad\x86\xab\x92\xa9\xcd\x0a\xd5\x3a\x07\x01\x08\x9b\x51\xcc\xdf\x7d\x77\xc5\xd3\x58\x5c\x75\x9c\x51\x1c\x76\xc1\xda\x6d\x53\x16\x0a\x14\xea\xb3\x05\x14\x2a\x2e\x80\x37\x49\x3e\xe2\x63\xd8\xac\xe2\x84\xae\x26\x1b\x29\xbc\xfd\x4c\x5c\xe5\x2c\x03\x05\xab\x93\xf7\xca\x93\xc5\x57\xb9\x2c\xda\xdc\xc4\xd3\x8c\x98\x0c\x32\x31\x26\x57\x23\x5a\xb0\x4b\x96\x69\xed\xc6\x73\xa2\x96\xc8\x24\x17\xa4\x18\xd1\x82\x14\x2c\x2f\x48\x36\x4d\x53\x96\xe5\x98\x92\x17\xd3\x3e\xe1\x85\xc4\x15\x8b\xb4\x51\x90\x7e\xc6\xe8\x85\x5c\xd4\xa6\xc3\xbc\x43\xc8\xab\x69\x41\xae\x18\x49\x19\x8b\x49\x21\xc8\x55\x46\x27\x78\x92\x47\x28\x91\xdb\x99\x88\x16\xd1\x08\xcf\x1f\xa5\x58\x16\x84\xe7\x12\x97\x84\x9b\x30\x58\x4c\xa3\x12\x95\x4d\x50\x0b\xf1\xab\x11\x8f\x46\x24\x16\x2c\x97\xf5\x29\x1d\x4c\xd3\x99\xa2\x5b\xd6\x7a\x54\x34\x24\x37\x72\x1e\x33\x42\x25\x3e\x23\x5c\x7d\x16\x51\xa9\x9a\x8b\x6c\xb6\x09\x75\xb3\x9c\xc4\x4c\x2e\x7e\xc6\xfc\x1f\xb0\x4a\x8f\x58\x56\x50\x9e\x12\x96\x0e\x79\xca\xf2\x0e\x4e\x56\xc8\xa8\x13\x56\x9c\xf2\x31\x13\xd3\x62\xd7\x49\x3d\x48\x18\xcd\x4c\xfa\x9a\xa9\x4b\x6d\xc2\xb1\x90\x98\xc2\x46\x1d\xd6\xaf\xb0\x70\x83\x55\xd6\x61\x96\xc9\x15\x76\x6e\xf0\xca\x49\x82\xa4\x42\xae\x34\x59\x4a\xf4\x58\x87\x49\x3c\xc4\xeb\x56\x4b\xea\x71\x47\x2e\x58\x3d\xf6\x60\x02\x03\x54\xd9\x4c\x7d\x93\x7f\x8e\x42\x72\xc8\xf5\xf7\x13\x2d\x07\x5e\xfe\x85\x5c\x23\x7b\x4e\xd9\x5d\x03\xea\x2c\x6b\xe6\x96\x0d\x19\xea\x60\x58\x43\x3c\x28\x4e\x4d\xe6\x12\xb2\x30\xa2\xdb\xf9\xad\xf6\x18\xb9\x48\xbb\xbd\x0e\xda\xf3\xca\x2f\xd4\xf6\xa0\x7c\x45\xb7\xdf\x87\x01\x8b\x62\xbb\x5d\xbb\x25\xcd\x56\xcb\x8a\x5b\x36\x4d\x15\x80\x94\x11\x8d\x58\x32\xa6\xcc\xd9\x3d\xb7\x83\x5d\x1a\x36\x37\x53\x91\x8d\x69\x42\x58\x7a\xc9\x33\x01\xcb\x0f\x18\xdd\x34\x65\x24\xe7\xc5\x94\xca\xba\x72\x03\xaf\x94\xbf\x45\x26\xeb\x6e\x93\xad\x96\xdb\x55\x9b\x9b\x92\x0c\x47\x1a\xaf\x28\xe8\x04\x7a\x49\x79\x42\xfb\x09\x23\x7d\x4c\x24\x09\x85\x93\x36\x25\xf1\xa6\x01\xd5\x2d\x08\xa5\x43\x2e\x68\x1e\x85\x90\xb0\x02\xa8\x6e\xeb\x82\x52\xbf\x50\x13\x7d\x69\x94\x9a\x71\xc4\x52\xfc\x2f\x17\x63\xd6\x17\xf1\x0c\x06\x75\x1e\x65\xec\x8a\xc5\x38\x45\x3b\x1c\x91\x0c\x48\x05\x39\xea\x1c\x76\xc8\x98\xc6\x71\xca\xf2\x12\x93\x43\x7a\x03\x3a\x50\xa6\x9a\xac\x65\xe9\xf0\xa9\x52\x94\xfd\x01\x94\x31\xd8\x4d\xf2\x14\xab\x94\xd5\xcb\x55\x77\x1e\x65\x7c\x82\xea\x07\x54\x0f\xbb\xa4\x09\x8b\xe5\xbc\x02\x60\x5a\x99\x17\xd9\x34\xc7\x02\x6a\x0e\x52\x07\x00\xd0\xde\x08\x8e\xd3\x09\xca\x51\x32\xf3\xaa\xaf\x69\x09\x2e\xda\x70\x5d\xe8\x35\xaa\xae\x61\xaa\x29\x39\x1d\xc3\xbd\x08\xed\x8b\x4b\x25\x44\x92\x02\x2e\xa7\x15\x4a\x2e\x59\x96\xcb\x81\x21\x06\x48\x3d\x4c\x84\x63\x49\xf9\x88\x5e\xb2\x0a\xf2\xe5\x4c\xdd\x28\x46\x5c\x2e\xa7\x46\x62\x32\x98\x26\xc9\x8c\x88\x69\x06\xcb\x6d\x76\x5d\x90\x48\x64\x72\x0f\x4f\x44\x31\x62\xd9\x15\xc7\x99\xf0\x8a\x27\x89\x52\xe7\x54\x23\x64\x52\xa7\x2f\xde\x72\x59\x67\x55\xcb\x95\x80\xad\xb9\xb3\x4a\x36\x4d\x5d\x65\xd0\x1c\xd3\xec\x02\xef\x0c\xfc\xe1\x7e\x10\xaa\x41\x57\xaf\xad\x60\xc8\x47\x15\x44\x94\x07\xbd\xa7\x8c\x97\x1c\xf6\xa5\x96\x54\x4d\xac\x76\xec\x1f\x78\xed\x5c\x5f\xaf\x6d\xf8\x3d\xb4\xff\x82\x6d\xfe\xeb\xb4\x40\x95\x08\xec\x86\x73\xcb\xb7\x57\x04\x2b\xd2\x04\x6e\x6b\x5c\x5d\xe0\x35\xac\xb6\x71\x7f\x0b\x65\xd0\x09\xc9\x3d\x11\x63\xa6\xa9\xca\x0d\x59\x40\x4c\xcc\x07\x03\x96\xc9\x05\x7d\x06\x77\xa7\x70\xdd\xe5\x8a\xe9\x65\xee\x48\xcd\x7d\xd8\x8a\x8a\xa6\xcc\x56\xa3\x68\xd6\x6e\x61\xc1\xfc\xe7\x94\x4d\x99\x3a\xc3\x90\xbf\xe3\x8c\xf2\x54\x6e\x61\xf6\xf0\x52\x50\x2d\xab\xa7\x99\xa4\xf2\xff\x48\xe0\x5d\x5b\xee\x28\x8d\xd9\x35\xd9\x23\x1b\x5d\x77\x95\x2d\x1b\x90\xfe\x36\xf9\xc0\xae\x8b\x53\x1e\x5d\x34\x5d\x8d\xf5\xc8\xe0\x87\x61\xec\xa0\x75\xc7\x2b\xb6\xcd\x1d\x6f\x65\xb2\x8c\x0e\x74\x70\xa8\x43\x16\x17\x95\x6e\x9f\x07\x16\x89\x34\xa2\x45\x13\xf2\xcc\x60\x0a\x56\x7d\xa5\x06\x5a\x62\x64\xb5\x7f\xd6\xd4\x07\x84\x42\x2d\x4d\xa3\x30\x6e\xdd\x2d\x88\x93\xef\xf0\x45\xb7\x6f\x3e\x17\xe0\xec\xda\x28\x30\x67\x19\x18\xb0\x5c\xd5\xec\x30\x0d\xcf\xb6\x0d\x92\x84\xa5\x64\x8f\xb8\x6d\xc0\x12\x57\x23\x9e\xb0\x66\xc2\x52\x4f\x7b\x3a\xac\xd3\xa5\x76\x4b\x0c\x96\x02\xa4\xd3\x00\x0d\x69\x3e\x7d\xea\x30\xf1\x17\x12\xa0\xad\xea\xc0\x30\x3f\xac\xfe\xcc\x22\x3c\xef\x64\xd3\xb4\xe9\x88\xb6\x65\x93\xff\xad\xb2\x23\xe5\x5f\x1d\x13\xb0\x68\xd0\x6a\xa9\xa6\x4a\x5c\x75\x44\x31\x9c\xac\x55\x37\xe1\x61\xaf\x3e\x7b\x4e\x55\xff\x78\x87\x2b\xce\x12\x5e\x1d\xef\xe5\xb2\x3e\x76\x45\xcc\x71\x9b\x77\x84\x48\x36\x48\xb7\x65\xe5\xbf\x94\xfd\x2b\xe9\xba\x6c\xf4\x4e\x25\xbb\x77\x9c\x4a\xba\xbc\x94\x84\x9c\x71\x59\xdb\x79\xe9\x88\x32\x54\x27\x86\xcf\x78\xd0\x26\x89\x3f\x2a\xd8\x18\xd7\xad\x12\x51\xcb\xa1\xd8\xe5\x38\xcc\xf2\x5d\x39\x77\x3f\xaa\x1c\x02\x56\xc4\xed\xc0\xb1\xe3\x0a\x8f\x4c\x2e\x7f\x22\x09\xbf\x60\x70\x38\x12\xf3\xa8\xe0\x72\xc1\x81\xba\x3d\xb7\x03\xcf\xa5\x27\xa3\x33\xbb\x3b\xe7\x79\x67\x30\x55\xe6\x01\xbb\x36\x0d\xa0\xa0\xe1\x19\x9d\xc9\x5e\x94\x08\x9c\x5b\xe9\x6c\x9a\x96\xce\xc8\x5c\x84\xde\x11\xa8\xc5\x28\x05\x62\xd7\x08\x44\xc1\x0b\xb0\x8f\x6a\xa8\x53\xa2\x86\xcd\x52\x29\x66\xec\x3a\xf7\x17\xea\xb8\x48\xa7\xd0\x6c\x78\xa9\x06\xa0\x4e\xd2\x73\xe0\x1e\x69\x34\x76\xe5\x1c\xc4\xc6\x93\x62\x46\xf0\x3c\x98\x14\x82\xd0\x4b\xc1\x63\x92\xb1\x21\xbb\x9e\x10\x9e\xe7\x53\x96\x87\x85\xcd\xa9\x94\x69\x63\x2a\xc4\x44\xb6\xd3\x91\x68\xa8\x43\xa6\x3b\xe4\xc4\xf1\x3b\x38\x9e\x04\xe2\xfd\x3c\x91\x46\xac\x9c\x38\x18\x94\xd2\x32\x36\x16\x97\xac\x16\x0f\x66\xef\x27\x89\x86\xc8\x4b\x20\x6c\xcc\x8b\x52\xe2\x24\x63\x13\x96\xd6\xd3\xa7\xf2\x8f\xd3\xa8\x5c\xb7\x01\x4a\x9c\x3a\x6d\xff\x83\x65\x8e\xb5\x62\x38\x3b\x27\x0e\x9b\xfa\x3c\x8d\x95\xca\x08\x0b\x54\x9f\x11\x85\x05\x39\x9e\x12\xe5\xd3\xc9\x44\x64\x85\x3a\x22\x72\x68\x8a\xae\xe2\x50\x1a\x35\x25\x8d\xcd\x06\x71\xa4\x25\x1a\xc5\x3c\xf3\x60\x63\x9e\xdd\x49\x07\x96\xaa\xa1\x42\x03\x4d\xc7\x34\x77\x75\x9b\x4b\xc5\x16\x18\x68\x04\x27\xac\xcf\x57\x78\x29\xb8\xb6\xa6\x0a\xb8\xa6\x3a\x66\xe2\x83\xeb\x2d\x9a\xe7\x7c\x98\xd6\xdc\xcc\x6d\x3f\x7b\xd1\xf2\x01\xb7\x25\x24\x4f\x0b\x96\x89\xc9\x27\x84\xd3\x06\x3e\x0a\xa2\xe5\x8e\x8e\x1a\x50\xd1\xff\xe2\xb0\x41\xf4\xbf\x48\x65\x27\xfa\x5f\x3c\x8b\x22\x48\xdf\x21\x5f\xf5\x86\x67\x07\x12\x6e\x77\xa5\x0c\xe9\x66\xa9\x2c\x49\x94\xa2\xcf\x24\xdd\xdc\x38\xdd\x59\xd0\x6c\xc8\xd4\xf6\xe7\xde\xca\x5f\xc2\x2a\xd3\x87\x50\xe7\xaf\x79\xb3\x89\xba\x9a\x41\x58\xab\xb2\xa5\x7e\x5f\xc8\x80\x07\x0b\xe2\xd5\x8d\xab\xf1\x91\x7a\xb8\xc5\x21\x7b\x0a\x3d\xfc\xd2\x93\x8e\x9d\x72\x6e\x25\x49\xda\x76\x01\x8a\xe1\x98\xf0\x44\xec\xc5\x5f\x26\x62\xe5\x7e\xb2\x7d\x22\xfa\x5f\xa0\xa9\xb9\xb5\x0d\x41\x8a\xb5\x8e\xf5\xba\x8a\x83\x9c\xb8\xcb\x43\x59\xb4\xc3\xe5\x1a\xe6\x78\xd0\xe4\x2d\xf2\xeb\x1e\xd9\x72\xef\x06\x35\xdc\xa3\x45\x8d\xa7\xda\x84\xb7\x42\x04\x8a\xf5\x5c\x32\x5e\xf4\xbf\xa8\x89\x7e\x21\x2e\xff\xf0\xcf\xbc\xdd\xbf\xc3\xfc\xf1\xb1\xed\xac\xc7\x6d\xc5\xfe\x64\xaa\x8c\x1a\xd7\x6e\x5b\xbb\xa6\xe7\xf2\x11\x63\x45\xfe\x9e\xa6\x74\x08\x7a\xdf\x5c\x42\x69\xbd\x20\xbb\xa1\x46\x7d\x3c\x7b\xd6\x72\xa1\xe6\xe9\x0e\x90\x03\x0d\xcc\xae\x0b\x96\xc6\x08\x5f\x65\x2f\x10\x02\x3e\x9b\x83\x58\xe3\x32\x65\x86\xac\xf8\xa8\x25\xe1\x78\x50\x53\xc5\x4f\x35\xe0\xf3\x9a\xe0\x43\x1a\x04\x70\xab\x76\x40\x93\x04\x2c\xda\xeb\xda\xf4\x73\x0d\xfc\xbc\xa6\x05\x98\x2d\x06\x30\x50\x3f\x90\xb9\x75\xd5\x75\xb7\xaa\xa0\xe7\x56\xe6\x20\x35\x65\x27\x22\xcf\xe5\xca\xf2\x40\xa4\x79\x91\x4d\xa3\x42\x64\x68\x6a\x5d\x5b\x6f\xf7\xee\xb2\xf3\xa8\xa8\xaf\xd0\xe0\xe5\xe9\x88\x65\xbc\xa8\x6f\x7a\x19\x74\x5e\x8d\x06\x9d\x29\x85\xab\xe8\x3f\x78\x31\x12\xd3\x42\x0d\x2d\xce\x6a\xeb\x7b\x71\x57\xc1\x79\xb5\xd7\xd5\x65\x70\x8e\xe9\xa4\x6e\x94\xbc\xe8\xba\x50\xf3\x24\x77\x4c\x27\x16\x94\xa7\x27\x74\xc0\x8e\xd2\x82\xe1\x80\xaf\xc4\xfd\xc3\x8f\x35\x05\xe6\x56\xe3\x41\x1a\x04\x60\xb8\x57\xd7\x59\x3e\xd4\x3c\xec\x00\x60\xa5\x2b\x13\x93\xd3\xd9\x84\xd5\xa9\xa6\xad\x32\xe4\x3c\xe4\x06\xc8\x14\xbb\xa2\x99\xda\xf0\x56\xd2\xfd\x3c\x04\x9c\x87\x5d\x81\x98\x22\x23\xc1\xf3\xe2\x83\x48\x3f\xc9\x26\x9d\x14\xb4\xe0\x51\xad\xed\xd4\x8f\x5b\x73\x8b\xcd\xab\xb6\x0a\xde\x92\x9d\xd1\xc9\x6b\x9e\x4f\x12\x3a\xfb\x40\xc7\xac\xa6\xfa\x1f\x9f\xd7\x15\x98\xdb\x5e\x1f\xd4\xd5\xb5\x77\x57\xb9\xfd\xe2\x87\x9a\x02\x77\x28\xe7\xaa\x1a\xd5\x69\xe6\x3c\x49\x79\xfe\x63\xb7\x12\x7c\x5e\x6d\x2e\x9c\x29\xfc\x25\xaf\xab\x62\xfb\xc5\x4f\x2e\xd4\xc7\x8c\xe5\xc6\x6e\xbe\x8e\xaa\x9f\x7e\xac\x2d\x32\x8f\xb2\x10\xd6\x20\x49\xeb\x89\x33\x35\x21\x8c\x8f\xf9\x0f\x9e\xc4\x11\xcd\xe2\x66\x2f\xcd\x83\x39\xe5\xfd\x94\x9f\x8e\x58\x6d\x47\x76\x7f\xfc\xb9\xa6\xc0\x5c\xd6\x7a\x90\x06\x41\x21\x7f\x39\xdb\xd3\xea\x0a\xb7\xab\xe1\xe7\xd5\xe7\x01\x06\xf4\xbe\x95\x69\x7a\x56\x9c\x23\xb2\x2f\xba\x2f\xee\x2a\x79\x77\x93\x4b\x45\xdc\x51\x70\x52\xcc\x12\x96\xc3\xcb\x34\x51\xd7\xfc\x17\xdd\x1f\x6a\x8b\xdc\x31\x74\x3c\xd8\x79\x1b\x3c\x23\x0d\x6a\x87\x27\xd7\xdf\x95\xdb\x3b\x7f\xfb\xb7\x6b\x8e\x9a\x61\x1b\x90\xb2\xab\xe3\xfe\x17\xdc\x06\x18\x14\x8f\xf0\xbc\x51\x16\x0c\x37\x5c\x4e\x65\x8b\xaf\xf5\x71\x93\x85\x55\xe9\xad\x95\x50\x5f\x25\x3d\xb7\x2a\xcf\xd9\xbb\x00\xa5\x8a\x6a\xcc\x04\xc0\xbf\x60\xbf\x2b\x1b\xdb\xa7\x7d\x96\x7c\x4c\xa6\x43\x9e\xbe\x49\xc4\x15\x68\xed\x8f\x7a\x5e\x82\x19\x4a\x36\xb8\xf7\x6f\x7c\x38\x62\xd9\x71\x16\xb3\xec\x40\x8c\x27\x22\x45\x33\xf7\xea\xa5\xd0\x0f\xad\xce\x43\xd0\xde\xdc\xd4\x4c\xae\x1d\x9a\xce\xe0\x8c\x8d\x5c\x31\x7a\x01\x27\x92\x1f\xd8\x15\xf9\xf7\x93\x13\x7c\x72\x96\x46\xac\x03\x8d\x42\xa5\xd8\xdc\x6a\x83\x1a\xeb\xa0\xa8\xb7\x9a\x3a\xc1\xd7\x6b\xba\x2b\x5a\x68\x99\xb6\xb9\x49\x7e\xcb\x19\xa1\x24\xe7\xe9\x30\x61\x85\x48\x89\x40\xf3\xd9\x49\x26\x2e\x79\xcc\x62\x22\x52\x46\xfa\x33\x7c\x8d\x89\x3a\x19\xab\x1d\x56\x8c\x5c\xa8\xb3\x6e\x78\x3a\x55\x63\xcd\x6f\x95\xf9\x19\x9c\xa1\x47\x62\x2a\xfb\x9d\x14\x02\x8d\xd1\xb2\x4b\xa6\x4f\x0c\x84\xe4\x58\x47\x96\xd8\xcf\xc9\x15\x23\x58\x01\xde\x32\xca\x51\x45\x60\x83\x45\xe2\x29\x9c\x42\x46\x9a\xb5\x7f\xf0\x24\x79\x2f\xb1\x92\x84\x0f\x58\x34\x8b\x12\xd6\x06\x53\xb8\x11\x4f\xe2\x8c\xa5\x70\x6d\x39\xa2\x69\x9c\xb0\x98\xd0\x41\xa1\xec\x86\x27\x34\x63\xa9\xdc\xe0\xe5\xf8\x04\x15\x6a\x27\x62\xa0\xea\x52\xaf\x23\x72\x72\x25\xa6\x49\x2c\xf1\xf5\x75\x99\x8d\x5f\x01\x75\x87\x1c\x15\x84\xe7\x84\x4a\x1e\xf6\x13\x36\x26\x72\xe9\x39\x1c\xe1\x6d\x22\x55\xc0\x64\x82\x66\xbe\xd4\xda\x0c\x82\x3d\x1c\xd8\xbc\xa5\x8c\xc5\xb9\x64\x85\xb8\x64\x59\x06\xc6\x6d\xe9\x0c\x09\xcf\x91\x8e\xbc\x43\x40\xa3\x9c\x40\xd3\xd5\x4b\x4c\x00\x80\x2b\x57\x4a\x46\x20\x6c\x60\x43\x38\x61\x11\x1f\xf0\x88\x17\xb3\xb6\x31\x8b\x53\x25\x4a\x1c\x3e\x11\x70\x45\x99\x8b\x64\x0a\xa3\x91\x03\x19\x19\x03\xb3\x6a\xdc\xc8\xca\x82\x63\xf3\xcc\x85\x5d\xb2\x2c\xd7\x5c\x02\x02\x36\x7e\x05\x38\xc9\x40\x89\x11\xee\x49\x55\x9b\x5d\xd2\x5c\xba\x50\xa2\x40\x10\x0e\x94\x1c\xec\x95\x96\xc5\x5a\x7e\x94\x02\x0e\x77\xd5\x75\xbb\xed\x94\x5d\xe1\xea\x5d\x97\xd7\xe2\xf7\x07\x23\x53\xf5\xe4\x13\x6e\x7e\xf1\x2c\x5b\x5d\xde\x42\xa3\x07\x28\x95\x56\xd2\x94\x2d\x24\x1a\x40\x82\xa9\x23\x05\x6e\xe8\x7b\x01\x6c\x47\x2a\xc4\x44\xcf\xda\xda\xfe\xf2\x28\x55\x2c\x2a\x04\x5e\xd1\xe6\x2c\x19\x6c\xa8\x13\x4f\x4f\x6c\xf3\xb6\x94\xf1\x8c\x25\x33\x62\x4d\x00\x55\x2d\x20\x41\xa9\x28\xcc\xe8\xc4\x0a\x15\x90\xae\x13\xce\xe0\xb7\xdc\x29\xc6\xbe\x21\x04\x18\x75\xa9\x00\x17\x84\x4e\x72\xf0\x6e\xc7\xcd\x32\x27\x36\x41\x55\xce\x80\x37\x2b\x0f\x6f\x9c\xd7\x60\xbb\x9f\x3e\x56\x53\x41\x2c\xb3\xe0\xfa\x60\x8d\x10\x78\xee\x45\xc8\x13\xa9\xbf\x06\xd3\x44\xf2\x15\xcf\x29\x1c\xbd\x40\x27\x93\x84\xa3\x3d\xaa\x65\x2f\xdc\xa3\x3f\xd9\x5c\x23\xda\x22\x7b\xa7\x4e\x01\xab\xc7\x80\x6b\x41\x6d\x4a\xa2\xd5\x74\x08\x0a\x8b\xe6\x52\xae\x41\x60\x68\x92\xf4\x69\x74\x41\xd4\x03\xf6\x98\x45\x42\xaa\xc1\xd8\x52\x60\x09\xe0\x69\xca\xb2\x4f\x6c\x50\x4b\x81\xec\xc0\xb5\xdb\xdd\xfb\xf0\xea\x28\x95\x44\xfb\xbc\x5a\xac\xa1\x1d\x9e\x6b\x46\xb7\xd7\x08\x4a\xdc\xe2\x45\xf4\xad\xd9\x07\x51\xb0\xb6\x12\x57\x9e\xcb\x29\x23\xe6\x52\x06\x69\x92\xc8\x85\x06\x12\xd7\x06\xeb\x8a\x41\x22\xae\x24\x4c\x0e\xfb\x26\x42\x53\x9a\xcc\x72\x78\x23\xe7\x5a\x12\xf3\x34\x4a\xa6\x31\x23\xbc\xe8\x40\x05\xef\x78\x7a\x21\x27\x2c\x47\xf3\x83\x15\x0c\x75\x39\x2c\x47\x5c\x01\x46\x26\x30\x5c\xc6\x22\xe6\x03\x3d\x87\xe9\x99\x17\x14\x30\x56\x51\xec\xca\x12\x72\x5a\x65\x34\x6e\x13\x5e\x28\xa9\xcd\x95\x8b\x02\x53\xa8\xad\xeb\xfa\xac\x78\xfa\xd9\x08\x02\x0e\x45\x99\x8d\x4b\x3d\xf7\xa0\xd6\xa6\x36\x51\x8f\x1c\x67\x7a\x25\x68\x0e\x6e\xc5\xa4\x50\xb7\x63\x55\x57\xaf\xea\x19\x82\x3a\x37\xef\x9e\x07\xd6\xec\x2f\xfd\xcc\x1d\xd0\x3b\x66\xec\xd9\x03\x63\xb3\xee\x70\x0f\xe6\x7b\xaa\xea\xef\x25\x99\x7a\x64\xab\xb4\x8e\x49\x6b\xdb\x6b\x78\x07\xac\xaa\x6c\x40\x19\xdc\x66\x93\x9d\x0a\x50\x8b\x72\x90\xf0\x89\x53\xa9\xfc\x69\x33\x53\xea\x51\x04\xef\xce\x4d\x66\x6e\x66\xc1\x63\xc3\x40\xd0\x4a\x75\x47\x45\x56\x3d\x29\x84\x6d\x72\xd6\x30\x24\x35\xda\xa4\x21\x6b\x97\x9f\xb2\xa2\xc6\x79\xcb\xb1\x6f\xc8\x83\x3d\x02\x54\x54\xda\x08\xd8\x1a\xc2\xce\xde\xb5\x96\x12\xb0\x1d\x3a\x15\x9a\x8f\x1e\xe6\x8e\x1c\x3e\x3c\x1d\x1e\xa6\xb4\x2f\x17\x27\x37\x37\x0e\xcf\x6f\x6e\xf4\x03\x1d\xe4\x8b\xf3\x20\x47\x51\x2a\xf5\xba\x8f\x4f\xb3\x0e\x97\x5a\x5e\x07\x39\x77\x2c\xee\xf4\xfb\x74\x8f\x18\x93\x86\xb9\xb8\xbc\x62\xfa\x06\x1d\x3e\x6a\x1f\xb5\x3e\xb6\x2f\xe3\x1e\x93\x97\xc8\x44\x7d\xc4\x63\x79\xe7\x91\xf3\x0b\xd9\x92\xdd\xf4\x9e\x16\x2c\xe3\x34\xd9\xf8\xed\x68\x07\x1e\x34\x8e\xe1\x51\x18\x4c\xa8\x94\x8c\xd9\x58\x64\x33\x92\x30\x7a\xd1\x91\xfd\x77\x3a\x62\x7e\xa3\xdc\x7b\x46\x35\xf4\x87\x99\xb8\xd2\xa6\x5c\xd1\xa8\xd3\x38\xb7\xef\x73\x5a\x64\xc7\x4e\xa5\xba\xdf\xa0\xa7\xbd\x3b\x98\x1e\x68\xe2\xef\x4b\x23\x8b\x60\xc3\xcc\x01\xa9\x6d\x19\xe0\x68\x93\x52\x41\x55\x0d\xb1\xc8\x01\xb2\x29\x35\x4c\xde\xd6\xab\x6f\xf7\x56\x0b\xa7\x5f\xff\xb4\xdb\xd6\x83\xb6\x5a\x80\xc3\xe2\x56\x43\x1e\x1e\x23\x2b\x01\xae\x3f\x46\x0e\x71\x21\xe9\x9d\x5e\x0f\x36\x87\xbd\x9e\x14\x46\x3d\x06\xdc\x23\xfe\xa0\xad\xad\x96\x6b\x3c\x16\x34\xc7\x25\x0d\xc8\xea\xc8\xf9\x40\xaf\x9d\xfc\x9c\x69\x9a\x4f\xfb\x79\x94\xf1\x3e\x3b\x8a\x3d\xeb\x19\x0b\x83\xdb\xa1\xaa\x9c\x70\x65\xe8\xfd\x0e\x81\x63\x9e\xcb\xc1\x87\x23\x5b\x6d\x66\xd0\xf4\xc1\xb1\xce\x71\x69\x76\xc6\xc8\x09\xbd\x64\x75\xe4\x15\x6a\xc0\xd7\x12\x68\xd5\xd8\xe2\xc5\xc1\x29\x8e\x5a\x7f\x7d\xc4\xa5\x61\x66\xf1\x60\x49\xbd\x79\xab\x81\xdb\x5d\x0b\xbb\x41\x1d\xb6\xb9\x85\xcf\x52\x48\x3e\x97\xfd\xfe\x25\xcf\x9d\x9e\x93\x3a\xa7\x06\xb3\x6f\x00\x34\x07\xd0\xef\xa0\xd0\x6e\xa8\xba\x0f\x17\x42\xe5\x1a\x73\xdd\xae\xad\x85\x38\xeb\xbb\xba\x0e\x7b\x4d\x09\xd7\x80\xc9\x35\xe2\xdd\x2f\x0a\x1a\x8d\x9c\x6d\x84\x9e\x41\xd4\x22\x51\xef\xe7\xcd\x3e\xce\xac\x51\x68\xae\x37\x5a\xaa\x07\x5c\xb4\x62\x40\xe0\xc4\x7e\x63\x24\x8a\x0d\xf0\xec\x83\x3b\xd8\x91\x10\x17\x39\x89\x68\x2a\xb7\xa6\x0c\xfd\x12\xc5\xf8\x12\xcb\x1a\x86\x46\x89\xc8\xa7\x99\xc1\xbb\xe3\x22\x1e\x15\xc5\x24\xdf\xd9\xdc\x54\x0f\x63\x23\x31\xde\x1c\x52\x46\x33\x91\x6e\x86\x15\x6e\xf6\x13\xd1\xdf\x1c\xd3\xbc\x60\xd9\x66\x9e\x45\x9b\x13\x5a\x44\xa3\x4e\xcc\x2e\x3b\x5f\xf2\xff\xf5\xae\xbb\xf5\xe3\x22\x03\xc5\x4b\xbc\x63\x54\x80\xbe\xd1\xb7\x96\x56\xd1\xb8\xc2\x52\x3a\x9a\xd8\x29\x27\xd9\xae\x6a\x97\x65\xdc\xad\xf2\xdc\xb1\x05\xb4\xbb\xc6\x9b\x1b\xe8\x9b\xa2\x91\x93\x84\xfe\x63\x06\xe6\xcd\x53\xb9\xce\xef\xd4\x0c\x58\x7f\xc2\x7f\x19\x1e\x9f\xea\x86\x74\x78\xca\x0b\x4e\x93\xa6\xd1\xf6\x37\x37\x15\xdb\xb7\x1d\xbb\xc9\x2c\xd9\x98\x43\xbd\xd6\xac\x61\xcd\x90\x7e\x78\x8d\xd3\xde\x40\x4a\x1e\xcb\x0b\x32\x99\x66\x32\x25\xef\xac\xcd\x81\xca\x0d\x98\x81\x72\x76\x7d\x78\xe9\x59\x9a\xdb\xce\x6c\x77\x5c\xb0\xd9\x0e\x69\x94\x4f\x65\x1a\x6d\x47\x7d\xc1\xc5\xb9\xb5\xf4\x2d\x01\x37\x7d\x6d\x80\x76\x6f\x30\xaa\x9a\x96\xcb\x25\x7b\x64\xe8\xdc\x5a\x4a\x5e\xf3\x78\x61\x42\x34\x6c\x40\x87\x99\x4a\xb7\xc9\x1e\x41\xb6\x07\xaa\xee\x91\xd7\xef\xa1\x4e\x73\x4d\x71\x83\xfe\x32\xcd\x0c\xe7\xbc\x3a\xc1\x31\x50\x4d\x57\x9a\xdb\xae\x05\x4f\x15\x09\xb0\xf5\x48\x62\xb3\x9e\x87\xd6\x20\x3f\x77\xcb\xfa\x77\xdb\xc8\x73\x3d\x84\xea\x17\x17\xbe\xe5\xf1\x05\xc4\xec\x13\x53\x87\x4a\xbe\xc2\x53\x87\x6e\xf0\x8c\x3f\x99\x79\x07\x23\x72\x18\xc0\xe1\x93\xda\x5d\x4e\x27\x31\x2d\x58\xc9\x2c\xfe\xd5\xcc\xcb\x97\x5b\xc9\x31\xa3\x29\xc9\x58\xc4\xf8\xa5\xc4\x48\xd3\x18\x8e\x06\x00\xbd\xc4\x07\x5b\x3c\x29\xc8\xb0\xa4\xce\x3b\x55\xad\xca\x19\xdc\xef\xb1\xe6\xd7\xdb\x76\x85\x79\x66\x09\x3e\x66\xc0\x05\xcd\xda\xd0\xa0\xd8\xfb\x7d\x7b\x4f\xc9\x95\xc3\xe2\x13\x34\x07\xec\x52\xf2\x45\x87\x92\x5b\x26\xa0\x1c\x5e\x86\x07\x73\x89\x3e\xa0\x23\x89\x18\xf2\x28\x10\xec\x5a\x65\xbe\x17\xa8\x73\xa9\xc0\xee\xe1\x24\xc3\xfe\x2d\x32\x38\x14\x97\x2b\x75\x80\x02\xb9\xcf\x84\xb3\x22\xcd\x22\x79\xfd\x5b\x3a\xbe\x8f\x96\x53\xe0\x55\x7a\xae\xaa\x8d\x55\x9d\xe1\x2b\x0a\xed\x4a\xa7\x62\x19\x55\xa9\x3e\x9c\xd2\x81\x02\x29\x23\xf7\x85\x77\x11\xd6\x20\x47\xe7\x30\xc3\xb0\xbc\xa4\xa2\x4c\xfb\x6a\x16\x5d\xf7\x14\x9b\xd2\x36\x5e\x8b\x44\x8d\xb0\xec\x86\x65\xe5\xd2\xc0\xae\x3f\xcb\x8b\xd2\xce\x90\x15\xcd\x32\x9e\x72\xa7\x3d\x72\x51\x85\xad\x08\xaa\xa9\x3c\xc4\x76\xe1\x2b\xe8\xc8\x2b\xe9\x68\x7b\xa8\x5b\xf3\xf9\xe4\x40\x9a\x83\x0a\x27\x0d\x9a\x5a\x23\x92\x8f\x4a\x85\xe7\x35\xd1\x1c\x97\x07\xca\x34\x63\x83\x7c\x87\x6c\xb5\x83\x64\x28\xba\x03\xf2\xed\xab\xd5\xdd\xda\x1a\x80\x1d\x40\x6b\xbb\x5c\x73\x3d\x1b\xe0\x2c\x25\x04\xef\x48\xb2\x40\x7f\x6d\x55\x4d\xa7\xb9\x3e\xff\x2b\x73\x5f\xdd\xce\x69\x42\x52\x5a\x9a\x19\xd0\x20\x88\x15\xd4\x3d\xc8\x77\x01\xee\xe9\x2f\xcc\xfd\xd3\x78\xe1\xe0\xc8\xd9\xba\xbb\x06\x20\x76\x29\xe7\x1e\x4c\x78\x4c\x5e\x2b\xb7\x18\x8e\x61\xd5\x68\xb0\x97\x90\xf6\x86\x4a\x09\x62\x7b\x91\xd5\xbb\xfc\x93\x84\xee\x20\xbd\x61\xdf\x0f\x12\x3e\xd9\xd1\x47\x60\x78\x6e\x28\x1b\xde\x17\x22\x61\x34\x6d\x90\x97\x98\xb8\x83\xab\x80\x0e\xba\x60\x83\xed\x9c\x04\xcb\x8a\xa4\x11\x62\x4c\x78\x7a\xa1\x7c\x55\xfa\x0d\x6d\x93\xd2\x06\xa4\x5d\xd5\xa9\xe6\x20\x31\x6c\x46\x0a\x7b\x8f\xd4\xdd\x6e\x28\xc4\xa5\x63\xcb\x56\xb8\x46\x2a\x4b\x9d\xe6\x32\x7c\x56\x48\xba\x9e\xb7\x42\x4c\xf6\xb6\xec\x13\x38\x7f\xc9\x66\xba\xab\xc2\x2d\x8f\x01\x38\xdf\x2d\xc9\x9c\x0f\x50\x16\x2e\x3f\xbf\x43\xe3\x18\x8b\xd4\x3e\xa5\x0a\x24\xa9\x66\x94\xb9\x07\x91\x73\xa7\x18\x9c\x26\xe7\x4c\x31\x66\x1e\xfd\x6f\x3c\xc5\xd4\x23\xba\x8f\xfe\xae\xe9\x8a\x0d\xe8\x8a\x07\x28\x47\xaf\xee\x98\x25\x4c\x6b\xc2\xaa\xc9\xec\x8b\x79\x8f\xe3\xaa\x91\xea\x41\x51\xa1\x43\xff\x72\x81\x47\x5a\x17\xa4\xf0\xf6\xbe\x0b\x28\xdc\x2c\xcd\x91\x6e\x04\xa8\xdb\x9f\x3e\xab\xda\x9f\x1a\xdb\xcd\x5c\xb3\x07\x8f\x66\x83\x76\xaa\x9b\x2e\xb9\x6b\x90\x1b\x44\x80\xe9\xa8\xc4\x10\x56\xdf\x68\x5a\x40\x9d\x12\x42\xc2\xa3\xe7\xc5\xef\x6a\x7a\xea\xd4\xf8\xac\xa1\x6a\x6e\xb4\x49\x43\xe3\xc6\x4b\x9a\xa0\x65\xd6\x8f\x9a\x9e\x46\xfd\x7c\x64\x18\x8b\x0f\x0c\x9c\x7a\x31\xe1\xca\xc0\xa3\xfb\xa8\x85\xc5\xc7\x6e\x8d\x22\xa8\x15\xe3\xbb\xc7\x70\xe5\xfe\x87\x54\x34\xb2\x8c\x10\xe9\xd3\x3d\x3a\x77\x25\xe4\x88\x42\xc9\x13\x8e\xa9\xa1\x6e\x8a\xbf\x6d\x87\xe4\xa8\xe5\x00\x3c\x6c\xb0\x80\x6e\x25\x9d\x8c\xc5\xd3\x88\x39\x3e\x8b\x68\x14\x4d\xc7\xd3\x44\xf2\x4c\x39\x68\x0b\xc7\xe5\x03\xef\x9d\x02\x1a\xd1\xae\xed\xe6\x46\x8d\xa3\x3a\x59\x28\xdd\x4e\x15\x23\x06\xb6\x75\x9f\x1b\xe4\x29\x7c\x79\x4a\x1a\x9f\x89\xfc\x01\xaf\xdf\xd0\xb6\x4a\x7b\xb9\x57\xbc\x33\x36\x05\xea\xa2\x8a\x8f\x27\x68\x6d\x84\xc7\xb7\x50\x78\xc1\x25\x9b\xac\xae\xd3\x68\xb5\x49\xe3\x3f\xc4\x14\xce\x82\x45\x9a\xcc\xac\x3d\x91\x48\xcd\x69\xf3\x40\x24\x89\xb8\xe2\xe9\x70\xc7\xd6\x10\x74\x49\xc0\x93\x96\xba\x24\x6b\x37\x5a\xfa\xbe\xec\x3f\xd3\x8a\x0b\xb3\x95\xf5\xc9\x23\x47\x26\x4c\x87\x18\x6f\x4d\x41\x96\x7b\x23\xfa\x4d\xba\xe5\x92\x26\x1c\xcf\x47\x97\xef\x11\x6d\xdd\xa0\xea\x24\x94\xa4\x22\xf5\x9f\xd3\x2a\x73\x04\x22\x06\xd8\x31\xa5\x86\x02\xc2\x05\x3b\x20\x18\xbd\xc6\x9d\x21\x09\xfe\x9c\xe1\xa5\x2d\x3a\x2b\x07\xc4\x53\xd2\xa8\x24\x6a\x37\xc0\x78\x1b\x12\xa2\x0e\xa9\x9d\x7a\x76\xc3\xb5\xf1\xd7\xdb\x96\xbf\x21\xab\xf4\x9c\x65\xf4\x4d\x40\xdf\xdc\x65\xd9\x58\x64\xac\xac\xe9\x37\x37\x89\xba\xe1\x71\x8e\x17\x95\x10\x68\x07\x75\xbe\xf9\x8e\x2d\x78\x02\xc6\x2a\x68\x11\x86\x8e\x40\x84\x31\x2b\xfb\x6c\x6e\xed\x9b\xad\xcf\x04\xcd\x3f\x37\xd0\x0c\xec\xa0\x0a\x9d\xec\x24\x53\x24\xec\x1d\x49\xba\x73\xfa\xaa\x15\x7e\x6d\x73\xf5\x6d\x00\xbe\xfa\x30\xe7\x3c\xb8\x33\x53\xae\x85\xad\x78\xd6\xef\xcc\xac\xf5\x90\x66\xf9\x6d\x1b\x88\x69\xe3\x1c\xde\x06\xab\xdc\xc1\x8e\x9d\xfb\xbd\xee\x33\x6b\x1a\x7b\x8f\xa2\x28\x03\x15\xaa\x2c\x06\x9a\x21\x99\xa5\x5b\x71\xbc\x79\x0e\x1e\x1b\xdc\xb1\x9b\xac\xb9\xbe\xdb\x71\x5f\xac\x98\x1a\x71\x0d\xb2\xa6\x64\xd0\x7f\xa7\xa0\x81\xda\x0b\x5f\xe3\x78\x84\xee\x48\x91\xde\x75\x9a\xf1\x81\x5e\xc0\x86\xc0\xb4\xd2\xcd\x74\xdf\xdd\x2c\xaa\x37\x75\x8b\x17\x35\x69\x53\xf2\xb6\x90\xfd\x19\x0e\x41\x34\x29\xc2\xbe\x00\xb6\x57\x3e\x95\x29\x5d\x04\x95\xfa\x71\x73\x53\x0d\x04\xd7\xfe\xd3\x69\xbd\x35\x83\x12\xe6\x62\x9a\x2c\x77\xec\x81\x08\x63\xef\x39\x0c\x4e\x30\xc1\x3b\x9b\x0a\x75\xdd\x26\x0d\x6b\xb4\xd5\x68\x79\x86\x2d\xa1\xfc\xde\xe2\xcb\xd5\xf2\x43\x5d\x8b\x61\xee\xf3\xd3\x25\x1d\x33\xff\xf8\xd7\xbe\x72\xf7\xdf\xc1\xd6\x99\xc3\xff\x60\x9f\x69\xf8\x05\xe6\x3d\x8f\xf0\x21\xff\x49\xaf\xdf\xcb\xaf\xaa\xdb\xb8\xc9\xb2\xc6\xb2\xde\x5b\x09\x3b\x12\x82\x86\x3a\x06\x66\x06\x91\x16\x49\xb5\x6b\x83\x0f\x3d\x0a\xcb\x01\x51\xd4\x58\xf6\x42\xa9\xb8\x39\x57\x19\x2f\x6c\x2a\x8a\x26\x88\xa8\x37\x53\x0a\xfb\x28\x03\xea\x0b\x5f\x5d\x8b\xfe\x97\x8a\x27\xd7\x3f\x3d\x48\xaa\xca\xfe\x67\xc9\x63\xc5\x8e\xc7\xd5\x5a\xe6\xf9\x76\xb7\x25\xf1\xe9\x6e\xc3\x36\x91\x12\x5d\x3f\xff\x97\x78\x70\xaf\x2d\x35\xa4\x62\x33\xc6\x52\x56\x40\x1e\x19\x00\x63\xd3\x21\x06\x1e\x68\xd9\x23\x86\x54\xf5\xe8\x15\xe3\xf1\x01\x4d\xe5\xfa\x52\x6a\x03\xfd\x2e\x00\xfc\x91\x19\x02\x1e\x63\x2f\x97\x7b\xad\xfb\xb0\x50\x1b\xff\xa3\x0c\x6a\x7b\x5c\x39\xbc\x70\x5c\xf2\x5a\xea\x38\xcb\x95\x5b\x0c\x65\xd5\xa6\x7b\xb7\xca\x65\x3b\x1e\x87\x54\x3a\x46\x42\x1b\x7e\xf4\x98\x07\x76\xa5\x00\xeb\x78\x44\xb2\x99\x1d\xab\x2d\xc0\xb7\x6b\x55\xfa\xcd\x8d\x6f\xa3\xe6\x40\xb9\x3a\xc5\x09\x4d\xa1\x27\xd8\xc7\xa0\x28\x1e\x4b\x25\x67\x0b\xb5\x5c\x04\x5a\xf5\x04\x85\xe7\xeb\x41\xcd\x23\x07\x0f\x68\x45\xa7\x0e\xeb\x22\xcb\x55\x51\xae\xe1\xb2\x19\x43\xc0\xeb\x42\x7c\xc4\x03\x21\x34\x1e\xff\xe8\x72\x5f\x2d\x15\x14\x48\xab\xdc\x67\x0e\x32\xfb\xcc\xcd\x45\xeb\x78\x95\xf2\xf0\xcf\xc3\xe4\x93\xb2\xeb\xae\x14\x1c\x28\xbd\x5e\xc0\x47\x28\xde\x10\x5e\x65\x28\x8b\x05\x86\x30\x6e\x9f\xeb\xbd\x0c\xd8\xc7\xb1\x08\x39\xef\x8d\xbd\xc2\xf5\x4f\x1f\xac\x39\x4b\x06\x6d\xd0\x9f\x8e\x4e\x96\x89\x65\xb5\xfb\x89\x81\x21\x5c\xa4\x75\x2f\x18\xc4\x8e\xd0\xbf\x28\x38\xac\x54\x86\x58\x3c\x67\x31\xd9\x20\xf9\x74\x02\xa7\xab\x2e\x04\x7a\xa7\xd4\x3a\x79\xcd\xf1\x9d\x08\x11\x6c\x48\xd3\x38\x94\x96\x09\x7b\x72\xd5\x6e\xcc\xae\xe5\xa2\xdd\xfd\xb5\x83\x43\x48\xb1\xda\x39\x0c\x93\x6d\x69\x61\x61\x5c\xbc\x3f\x76\xcf\x3e\x0c\x62\x3b\x43\x90\x97\x98\xbc\x03\x4f\x8c\x2a\x66\xf8\xee\xc3\x22\x7a\xdc\x5b\xd0\xf2\x45\xbc\x85\x3c\x7f\x66\xdf\x6f\xe7\x0b\xfb\x0b\xc9\x6b\xfc\x85\xe0\x03\xc1\xba\x70\x34\xa1\x9b\x8f\xbb\x1f\x0e\xb7\xfe\x5b\x0f\x9a\x69\x1f\x8e\x4e\xda\x28\xe4\xf0\xdd\x0e\x1f\xed\x09\xde\x64\xe1\xf6\xd3\xc8\x1b\x78\xc7\xf6\x33\x5d\xb3\x93\xca\x75\xce\x89\x84\x97\x92\x96\xb1\x1c\xfc\xc9\x81\x1b\x55\xc6\xe1\x4a\xa0\xcf\x30\x04\x94\xc8\x9c\x85\x4f\x1b\x0e\xde\x1e\x93\xa7\x55\x04\x2d\x37\xb2\x9c\xc6\xb6\xec\x10\xd6\xcc\xb0\xf3\x82\xff\xca\x6d\xbb\x0a\x81\xcf\x03\x77\x4a\x41\x26\x44\x56\xff\xef\x84\x5b\x01\xc3\xfd\x8a\xdd\x80\x0a\x9f\x58\xb5\xe8\xaf\xdf\x24\xd8\x89\x14\x5a\x05\x73\x98\xd3\xaf\xe1\xe8\x32\x22\xa1\x0e\x5f\x6b\xb2\x5b\x35\x62\x62\x1b\xe0\xbc\x0a\xd8\x73\x40\xaa\x14\xd0\xdc\x08\x18\x76\x60\x29\xa1\xc5\x20\x41\x0b\xba\x78\xf2\x43\x69\x92\xa6\x72\x74\xd7\x22\x4f\x36\xab\x90\x74\xe2\x66\x65\x7d\x8f\xa3\xc7\xed\x4a\x7f\x73\x1f\x3f\x1d\x9e\x1c\x7e\x38\xdd\x97\x5b\xf7\xde\xfe\xe9\xe9\xa7\xa3\x57\xbf\x9d\x1e\x9e\xec\x12\x8c\x4f\xb9\xb2\xfa\x69\x4d\xfd\x87\xbf\x1f\x7e\x38\xfd\x96\x15\xc7\x35\x15\x9f\x1c\xec\xbf\x3b\x84\x60\x6b\xab\xaf\xb3\x5f\x53\xe7\xbb\xc3\xb7\x87\x1f\x5e\x7f\xa3\x4a\xbf\xd4\x54\xea\x1f\xe5\xaf\xbc\xda\x51\x4d\xb5\x03\x9e\xc6\xfb\x49\xf2\x6a\x26\xf5\xe4\xca\x6b\xe5\x73\x6a\x3d\x18\xf1\x24\x0e\xea\x9d\xa6\x53\xb9\xee\x09\xaa\xbf\xc2\x0b\x5a\x08\xb0\x84\xf1\xb1\x56\x45\xdf\x45\x7d\x67\x7c\xc4\xd0\x34\x70\xcb\xb6\x5f\x14\x19\xef\x4f\x0b\x96\xaf\x9c\x43\xac\x96\x43\x49\xc1\xb2\xc3\x4b\x96\x16\xdf\xb0\xf6\xc1\xdd\xb5\xe7\xc7\x03\xe8\xa9\x95\xd7\xfd\x67\x4d\xdd\x70\xcd\x45\x0b\xf6\x07\x8f\x8b\xd1\xbf\x31\x3e\x1c\x15\x2b\xaf\x3b\xad\xa9\x9b\xe7\x27\x79\xb6\xf2\xda\x86\x73\xb9\x7c\x72\x39\x54\xd7\x22\xf9\x1d\xe3\x80\xe7\x27\xe0\x2e\x03\xfa\xe3\xf0\xcf\x29\x4d\x56\x3c\x1c\xc6\xb5\x6c\x39\x50\xce\x2b\xa0\xd6\x95\x33\x68\x52\x53\x2f\x5e\xb1\xbd\x9a\x81\xef\x92\x95\xd7\x9a\xd4\x0f\x7e\xb8\x5c\x00\xf1\xff\x46\x8a\x51\xd4\xd4\x3d\xa1\x59\x8e\xfd\x0b\x2e\xbe\x4b\xf5\xf2\x31\xd4\xfb\x64\x13\xad\x68\x4c\xdc\xb0\xa3\xf7\x1f\x8f\x3f\x9d\x1e\xbe\xee\xbd\x3f\x7e\xfd\xdb\xbb\xc3\xde\x56\x2f\x11\x31\xcd\x47\x3d\x9e\x7f\xe0\x09\xac\x8d\x2a\x8f\xf7\xbb\xab\x41\xdf\x8b\xe7\xb9\xbc\xea\xa4\xcd\xc5\x51\x2d\x47\x50\xd7\x62\x39\x81\x6b\xec\xda\x26\x77\x7f\x7e\xb1\xb2\x2a\x1e\xd0\xec\x0a\x6c\xcb\x91\xb5\x6d\x11\xa1\x07\xa5\xfa\xce\xfe\x69\x65\x35\x3c\xa0\xe1\x15\xd8\x96\x23\xeb\x99\x45\xf4\x46\x8d\xa4\xfa\x4e\xff\x61\x85\x75\x3c\xa0\xf1\x95\xf8\x96\x23\xed\xb9\x45\x05\x8e\xf5\xeb\xdb\xbe\x64\xb7\x97\x2b\x78\x40\xc3\xcb\xc8\x96\x23\xea\x05\x5e\xd8\xd7\x37\xf6\x81\x68\x1f\xd0\x44\x83\x63\x39\x12\x7e\x00\xe3\x00\x38\x2f\xc8\x6b\x9b\xb7\xb5\x0a\xdc\x0f\x68\xa3\x8f\x68\x39\x62\x7e\xec\xf5\x5e\xd3\x82\xfe\x56\xf0\xa4\xbe\xa1\x70\xa2\xb5\x04\xf2\x9f\x7a\xbd\x8f\xd3\x8c\x7d\x82\x85\x43\x3d\x76\xb8\x20\x82\x3f\x7b\x04\x56\x88\x03\x91\xe6\xd3\x31\xed\x27\x4c\x87\xaa\xc8\xb4\x73\xba\x30\x64\x2c\xdc\xa8\x05\xf7\x2d\x10\x8a\x61\x9b\xec\x99\x40\x17\x99\x0e\xa8\xa2\x3d\x95\x67\xc1\x3d\x0c\x14\x40\x0f\xd5\x34\xcb\xce\x38\x78\xaf\xd3\x96\x4a\x59\xb6\xed\x38\xd7\x53\xa9\x48\xc7\x20\x13\x63\x20\x42\x39\xb1\xc3\x3f\x49\x48\xcd\x39\x81\x7a\xe2\x42\x13\x3e\x4c\xe5\x4a\xf3\x15\xcd\x59\xc2\x53\xf0\xb3\x73\x3f\xa1\xe9\xd0\x0e\xda\x89\xb5\x25\x3e\xb9\x1a\x5d\x0a\x07\x86\xec\x95\x38\xfa\x8a\x94\x93\x11\x1f\x14\x0f\xa4\x27\x82\x37\x1a\x0f\x46\xf1\x91\x16\xa3\x15\xa0\xf9\x34\x5d\x92\x39\x0e\x1a\x91\x88\x6c\x15\x38\x8e\xd2\x82\x65\x13\x91\xc0\x76\x76\xe5\x08\xdf\xc0\x46\x26\x5f\x05\xde\x8f\x99\x18\xf0\xd5\xf0\x0d\x95\x00\x18\x98\x3e\x0c\xd9\x34\xcb\x1f\xdc\x0b\xe6\x3d\xd0\x52\x78\x44\xca\x8e\x07\xcd\xb3\x46\x52\x64\x8d\xb6\x7a\x4d\x44\x1a\xca\xc7\x4b\xe3\xbc\x85\x35\xc0\xe9\xd1\x43\xe9\x14\x63\x9e\xd2\x95\x69\x08\x06\xae\x84\x5e\xd1\xe8\x62\x98\x89\x69\x1a\x3f\x10\xdd\x80\x27\xc9\x0a\x50\x1c\x4f\x68\xc4\x8b\xe5\x58\x05\x5d\x21\xf7\x84\xcd\xb3\xe5\xe9\x58\x5e\x65\x62\x5f\xcb\x46\x2c\xad\x5e\xb4\x30\xa5\x22\xfd\x07\xcb\x84\x94\x24\x76\xc9\x52\x11\xc7\x65\xa1\xc2\x23\x8a\x87\xb2\x3c\x11\x22\x3e\x58\x81\x2a\x03\x44\x7f\xff\xce\x13\xe9\x43\x27\x3a\x89\xe2\x0d\x1d\xf3\xe4\xa1\xc3\x5d\x22\x3a\xe1\xff\x78\x80\x20\x2d\xcd\x4d\xb5\x04\x58\x9e\x7e\xcb\x4d\xd9\x82\xfd\xf8\xcb\x34\x5f\x8e\xaf\xff\x75\xda\x51\x64\xac\x88\x96\x5b\x7b\xd8\x51\x9d\x8d\x29\x4c\x0f\x57\x1c\x9e\x6e\x91\x46\x4a\xb3\x4c\x5c\xe1\xf7\x69\x52\x64\x74\x23\x12\x69\xcc\xd2\x9c\xc1\x88\x67\xd7\xa5\x24\xef\x47\xce\xc6\x7c\xa3\x9c\xc2\xae\x27\x34\x8d\x35\x0a\xf7\xbb\x44\xe7\xa6\x60\x9d\x6e\x4a\xa0\x64\xa0\xe9\xb3\x07\xab\x33\xdd\x70\x5e\xd0\x84\x47\xf2\x9b\xe8\x27\xfc\xcf\x29\xab\xae\xf2\x77\x9a\x71\xba\xe4\x50\x2c\x57\x9a\x8f\x69\x92\x6c\x44\x74\x92\x57\xd7\xf6\x07\x9c\x64\xaf\xa8\xb2\xbe\x48\x62\xfd\x89\xfd\x9a\x48\xec\xf0\xb5\xbb\xb5\xd5\x26\xdb\xf2\xbf\x67\xf2\xbf\xe7\xf2\xbf\x17\xf2\xbf\x1f\xe4\x7f\x3f\xca\xff\x7e\x92\xff\xfd\x2c\xff\x0b\x08\x1d\x26\xb3\xc9\xe8\x38\xe3\xfa\xe2\xe3\xdf\x44\xc6\xff\x21\xd2\x82\x3e\x74\xd6\x0d\x11\xff\xce\xb2\x82\x47\x0f\x46\xcb\xc7\x74\xc8\x1e\xb6\xce\xd3\xcc\xa5\xd3\x02\xa6\x42\x1d\xaa\xff\x64\xc2\x50\x56\x75\xc2\xff\x99\xd2\x84\x17\xb3\x72\xef\x5e\x30\x78\x37\xf4\xf7\x55\x3d\x09\x2b\x0a\x96\x9d\xc8\x79\xf5\x6f\xdd\x0c\x39\x04\x78\x3a\x5c\xc5\x4a\x03\x23\xcd\x1e\x3e\x78\xc1\x8a\x78\xde\xf3\xd5\xe0\x39\x29\x68\xf6\xd0\xa5\xc3\x98\xe6\x17\x0f\x44\x21\xfe\x69\x2b\xb0\x15\x49\x8a\xb8\x64\xd9\x20\x11\x57\x0f\x52\x18\x97\x1c\xbc\x57\x4a\x7d\x30\xe2\x71\xcc\x52\x98\x05\xa2\x4c\x24\xa0\xa2\xb5\x3e\xf1\x75\xc5\x44\x80\xa5\x15\xde\xac\xae\xa2\xfa\x8f\x54\x22\x04\x45\xa5\x52\xde\x70\x24\x40\xfd\x3c\x29\x32\x71\xc1\x9c\x04\xf9\x75\x62\x4b\x0d\x14\x78\x6e\xe0\x28\x26\xa4\x22\xad\x98\x38\xf3\x11\x9d\x7c\x6b\x8d\x1b\x65\x3c\x9f\x1c\xc6\x43\x7c\x6d\x3d\x64\x62\xcc\x8a\x8c\x47\x1f\x33\x16\xf1\x9c\x8b\xb4\x82\xaa\x42\x4c\x56\x31\xec\x25\x9e\x7f\xde\xfe\x62\x45\xd2\x8d\x3d\xf9\x77\xa7\xff\x35\xcd\x47\x10\x62\xf6\xc1\x5d\xaa\xb1\x89\xc1\x20\x67\x7f\xe3\x1d\x02\xb6\xe4\x1d\x4f\x59\x44\x97\x3b\xe6\xd4\x23\xaf\x3f\x2d\x0a\x38\x47\x12\xd3\x14\x17\xf4\x7f\x4e\x69\x56\x35\xda\x4d\x95\x5f\x04\x7f\xd8\xd1\xd5\x98\xe3\xf2\xd4\x56\xda\x67\x97\xac\xe2\x1c\x0b\xeb\x7c\x2f\xc1\x13\x3e\xe6\x7f\xfb\x0e\xfb\x6f\xa2\x4f\xc0\x1c\xe7\xef\xdb\x88\x82\x5d\x17\xfb\x69\x34\x5a\x72\x8a\xd0\x52\x9c\xcb\x15\x98\x94\xd9\x31\x8f\x63\x9c\x4b\x59\x5a\xb1\xa5\x95\xd5\xbd\xc6\x18\x0c\x0f\x3d\xf3\xd5\xf3\x30\xfa\xa6\xe4\xf8\x43\xae\x60\xf4\x77\xf9\xb9\x51\x8c\x32\x31\x1d\x8e\x60\x5c\x25\x3c\xbd\xa8\x26\xe9\x2f\xda\x2a\xbd\x63\x43\xde\xe7\x7a\xb7\xb4\xc8\x04\x3e\x4d\x79\x24\x62\xf6\x8a\xc7\x7c\x45\x5b\x64\x36\xee\x23\x51\x7d\x1e\xf3\x0d\xed\x80\xa2\x5c\x33\xac\x8a\x80\xd6\xd5\xaf\x06\x23\x91\x24\x74\x92\x57\xd4\x7a\x25\xb2\xf8\x6f\xbf\xe1\xba\xca\xb8\xdc\x6f\xbd\x17\xf1\xc3\x4e\x6e\x92\x6c\xa3\xe8\xc3\xd4\x90\xa8\x2f\x45\x7f\x23\x83\x5e\x4c\x70\xca\x48\x30\xb1\x42\xa8\x33\x9a\xe6\x03\x91\x8d\x1f\xbc\x4a\x58\xfa\xf8\xc9\x46\x6b\xb9\x5a\x5a\x45\xda\xeb\xd0\xd1\xf2\xc7\x44\x16\x49\x7c\xfd\x50\x04\xcb\x0d\x06\x8b\xe0\xa1\x04\x3c\xb4\xfe\xe5\xb4\x3c\x96\x87\x97\x03\x97\x34\x2b\x19\xbd\xab\x5b\x74\x91\x1e\x24\x3c\x5a\x6e\x13\x3d\x98\xa6\x11\xec\x40\xd3\xf7\x62\x9a\xb3\xd7\xe2\x6a\xb9\xc9\x21\xc0\xf3\xdb\x72\xeb\xc1\x00\xcb\xf1\xe5\x92\x57\x3d\x01\x9e\xf7\xe2\x72\xb9\xb1\x14\xd2\x33\x5d\x6e\x20\x04\x68\x0e\xd3\x65\xaf\xb0\x02\x44\xef\x18\x7d\x70\xc3\x4e\xc5\x34\x1a\x2d\x7b\xae\x14\xa0\x59\x01\x9f\x01\xcf\xf2\xc7\x4a\x01\xa2\x03\x9a\x46\x6c\xb9\x33\x5d\x1d\x72\x0a\x06\xde\xa7\xc3\xfd\x83\xd3\xde\xab\x4f\xc7\x7f\x9c\x1c\x7e\xea\xe1\x30\x7c\xbf\xff\xd1\x84\x95\x82\xd1\xd7\x50\xe3\x10\x9c\xd3\x8d\x65\xff\xc4\x30\x9a\x1a\xce\xd8\xb2\x79\xd3\x89\xcd\xf9\x6d\x62\xd3\x05\xc8\x7c\xc3\x19\x01\x36\x6f\x0c\xfc\x6d\x38\x52\xed\x94\x93\xb2\xd9\xb0\x82\x6a\x73\x18\x8a\x5b\xc3\x95\x3e\x9b\x9b\xa0\x0c\x35\x5c\x91\x82\xdc\x42\x32\x30\x52\x0c\x6c\x78\x0c\xb5\xf9\x4c\x0a\x4e\xc3\x4a\x91\xcd\x31\xb4\x1a\xc9\xb0\x79\x39\xf6\x6f\xc3\xed\xee\x86\x61\xb6\xf3\xc2\x86\xec\x11\xbb\xba\x93\xcb\x4a\x0a\xd3\xef\x44\x5c\xe1\x26\x11\x97\xbe\x89\x18\xc2\x44\x1c\xb3\xb4\x50\x4b\xbc\x82\x63\x08\xa3\x3e\xc5\xc5\x30\x1c\x73\xc1\x8a\x30\x8b\x79\x8a\x0b\xb2\x3f\xa7\x34\x2d\x38\x2e\x91\xf0\xfb\x3f\x70\x5d\x5b\x44\xa7\xaa\x78\xce\xfe\x9c\x4a\xa4\x58\xa0\x18\x65\x2c\x1f\x89\x24\x6e\x9c\x2b\x52\xdd\x87\x39\x40\xab\x5e\x02\xdb\xfd\x6b\xc6\x22\xa8\x38\xe2\x59\x84\x75\x45\x99\xc8\xe1\x20\x29\xe6\x74\x2c\xd4\x7e\xb7\xc0\x96\x15\x19\x07\x1b\x26\xb8\x2e\x9b\x31\x73\xec\x75\x8e\x6f\xc7\xd6\xc8\x13\xf2\x96\x61\x20\x3e\x65\x5e\x81\x4e\x6c\xc5\xc0\x8d\xfb\x25\xc1\xfe\x75\x42\x33\x3a\x26\xe4\x2b\x1a\xb5\xde\x82\x07\x1a\x72\x82\xbe\x66\x58\x6c\x1d\xd2\x00\xb0\xb2\xe6\xfa\x8a\xa6\xbf\xb7\xf8\xa6\xee\x75\x50\x83\x5b\x64\x53\xc5\xbe\x0c\xa2\x2c\x7b\x91\xf6\x6c\x0e\xf8\x93\x71\x9e\x22\xdb\x9f\xe6\xb1\x70\xa3\x81\x6f\x0f\xbd\xd7\x96\x40\xb3\xeb\xc7\x2c\x28\x24\xf3\x75\x31\x27\xc9\xf3\x75\x73\x73\x83\x69\xda\xd9\x6f\xc3\x34\xa3\xa1\xdf\xe4\x49\x16\xbc\xe1\x69\x0c\x1e\xf1\xb5\xb9\x5b\x92\x90\x31\x2d\xa2\x11\x8b\x6d\xa4\xcc\xfe\x0c\x5e\x1c\x77\xc8\x67\xf9\xf1\x59\xc7\x16\xa1\x04\xec\xf3\x75\x4c\x4c\xe5\xb1\x42\x64\x12\x2f\x12\x6e\x38\xe6\x3d\x6f\x72\x19\xe6\x65\x34\x75\x8d\x6d\xa8\xcf\x06\x47\xcb\x58\x8e\x86\x92\x67\xe0\x13\x41\x26\x15\xca\x45\x92\x4c\x51\xdc\x5b\xc6\x86\xb6\xd9\x02\xa6\x5b\xc7\x1c\x0a\x2d\xb4\x77\x4c\x27\x8e\xeb\x41\x27\xf4\x52\xe5\x5b\xb1\xa6\xf6\xf2\x59\xe1\x8c\xc5\x50\x1b\x16\x91\x75\x9f\x9b\xe7\xa7\xf7\xb0\x8c\xed\xd0\x8e\x7e\x0c\xd2\x19\x88\xec\x90\x46\x23\x87\x7d\x96\x6a\x48\x73\xc3\xbd\x41\x82\xea\x06\x8c\x18\xba\xbe\x8e\x5f\x3a\xf0\xde\x75\x7d\x5d\x15\x82\x9f\xa1\x4c\x39\x39\x8e\xf7\x6a\x2d\xbb\x2a\x2c\xd8\xf1\xa0\x69\x6a\x69\xc1\x9b\xe0\x8d\xae\xcb\x3c\xd9\x99\x9d\xc9\x34\x57\x14\xbb\xde\x1f\xd0\x4f\x94\x79\x77\x92\x43\xc0\xcf\xdb\x5d\x25\xad\x18\x97\x0a\xdd\x16\xf2\x2c\x2f\x7c\x51\xd5\x72\xda\x36\x11\x86\xe1\x21\x71\x31\x62\xd9\x15\xcf\x59\x47\x62\x58\x4c\x82\x95\xf8\x76\x3c\xf9\x75\x1e\xca\x85\x12\xec\x64\xdd\x2d\xc3\x73\x45\xbe\xdc\x7c\xd9\x21\xf8\xed\x6c\xeb\xdc\x1d\xba\x07\xf8\xcc\x1d\x43\x14\xc2\x11\xad\xd4\x56\x66\xd0\xb2\xeb\x28\x99\xc6\x3a\xc6\x85\x48\x59\x6e\xb8\x05\x5e\xee\x66\x13\x66\x9a\xe7\xbe\xec\x0b\xe2\x16\xaa\xe4\xda\x66\xa5\xec\x4a\xcb\x61\xe5\xf8\x74\x1c\x12\xfe\xcf\x18\x5d\x64\x8c\x82\xab\xc6\xea\x71\x59\x33\x2c\xd7\xd7\x49\xc5\xe0\x2b\xc1\x55\x8d\x44\xeb\xc8\x1a\x1d\xf5\x39\xbd\x19\x0e\x50\x7f\x68\x3a\x80\xe6\x89\xb7\x14\xca\x21\x2b\x60\x0e\xc1\x18\xd2\xf6\xe9\x26\xa1\xfa\xf5\x24\xc4\x52\xbe\x1c\xea\x31\x57\x39\x69\xb3\x84\xec\x63\x40\x12\x33\x34\x6d\x5c\xea\x49\x8e\xf3\xbe\x97\xef\x4d\xe7\x1a\x0d\x21\xb6\x5a\x18\xd6\x18\x31\xc0\xce\xe2\xd5\x8f\x4b\x83\x09\xbd\x1a\xa8\xc9\x5c\x27\x23\x2c\xc1\x48\xde\x4b\x3d\x60\x69\xb6\x24\xb2\x60\x8e\xd7\x11\xde\x40\xe6\x24\xb9\xda\x53\xf3\xfd\xe4\x8f\xe7\xbf\xd3\x84\xc7\xda\xe1\xa3\x24\xfa\x25\x61\x09\xba\x7a\x26\x3b\x84\x25\x66\x68\x3e\xaa\xc7\x3c\xe7\xe9\x51\xb3\x85\x01\x0a\xef\xa4\x5f\x4c\x0b\x27\x70\xdd\xe6\x26\x61\x79\xc2\xd3\x62\x43\x79\xd4\xdd\x48\xd9\x75\xb1\x21\x17\x92\x24\x15\x1b\x19\xc3\x57\xfd\x2c\xde\xc8\x67\x69\x41\xaf\xd7\x3c\xaf\x4a\x3c\xf5\x1d\x2e\x49\xf2\xbf\xde\x56\x46\xaa\x57\x8e\xa3\x79\x4b\x0e\x93\x1a\xb3\xfc\x33\xee\x38\x43\x05\x56\x88\x69\xd1\x52\x14\xdb\x30\x84\x62\x5a\xe0\x23\x01\xdf\x3f\xd3\xad\xbf\x12\x13\xd3\xa2\x76\x44\xb0\x4b\x88\xea\x76\x9f\xa1\x40\xe4\x60\xd0\x7f\xcb\x0c\x0a\x8d\x50\xcb\x1d\x44\xe5\xff\x37\x88\x7b\x9e\x41\x48\xf9\x91\xfa\x2e\x06\x48\x5f\xdd\x50\xb2\x7f\x73\x06\x55\xe5\x7b\x69\x7f\xba\xac\x00\x68\xb2\xa4\xed\x90\xf5\x3f\x03\xeb\xef\x36\xb0\xc2\x23\xba\xfb\x8e\x28\x47\x24\x31\x5e\xd4\x02\xe3\x4b\xe9\x70\x10\x25\x5d\xd8\xd7\xdc\x6e\x56\x53\x64\x7c\x28\xf7\xc0\xea\x77\x9b\xc4\xb4\xa0\x6d\x8c\x10\x8b\xb4\x96\xbc\x8e\x19\x27\xbc\x41\xd9\xa6\x53\xb4\x4d\x4c\xf4\x84\xb0\x83\x2c\x99\x15\xef\xf8\x6b\xc6\x84\xce\xd6\xec\x2d\x11\xf9\xff\x5f\x81\x92\xc9\xcb\x2b\x02\x2d\x53\xad\x7b\xc9\x65\x28\x44\x1a\x8b\xdf\x31\x0b\xcd\x03\xda\x9f\x02\xba\x95\xe6\x71\x31\x82\x7d\x37\x5e\x34\xb8\x2a\x3c\x1a\xd1\xac\x5a\x85\x7b\xcb\xa3\x32\x98\xd6\xd9\xaf\x30\x16\x8e\x54\xda\xe0\x4c\xf3\x68\xe0\xcc\x12\xa5\x9a\x69\xc6\x88\xbe\x88\x92\xc9\x43\xd8\x56\xc8\x89\x85\xa6\x64\xcb\x28\xf6\x0a\x77\x10\xae\x08\x57\x64\x57\xad\x90\x1e\x69\x0d\x19\xc8\xa0\x71\x58\x78\xab\x64\xb0\xc7\x92\xef\xb5\x62\xd6\x65\x8c\x2b\x24\x68\xc2\x9e\x85\xe9\x40\x8a\xce\x1e\x69\xe2\x6c\x3e\x26\xa1\xff\x62\xa0\x06\x39\x39\x67\x37\xe2\xbf\x8e\x3c\x7b\x3c\x78\x4c\x36\x9f\x10\x9e\x7f\x00\x4e\x91\x27\x9b\xe7\xad\x26\xd4\xda\xc2\xf0\xdc\x92\xa2\x5f\xf6\xc8\x16\x34\x72\x25\xd8\x91\x66\x40\xaf\x5a\xf4\x8b\x13\x53\xa5\xcc\x37\x2b\x79\xe8\x7d\x4d\xeb\x1e\xf0\xa5\xe1\x76\x15\x24\x34\x3d\x95\xf7\x48\x9f\x3c\x5d\xf1\x34\x16\x57\xe8\x54\xd9\x38\xd1\x6a\xc8\x91\x87\x39\x9d\x58\x44\x10\x67\xbe\x22\xc9\xf7\x2d\xee\x00\xe4\xac\x38\xe5\x63\x26\x47\x9a\x25\xeb\xe4\xf7\xb7\xbd\xd3\xfd\xb7\xea\xac\x13\xed\xdd\x8a\xb7\xc9\x6c\x32\x72\xbf\xbf\x66\x03\xf7\xe7\x51\xc1\xc6\xf0\x3b\xe5\x63\x5a\x30\xe7\x2b\x58\x9d\x39\xbf\xdf\x8b\x42\x5d\x70\xab\x84\x53\x7d\x43\x19\x9c\x4a\xaa\x77\x86\xea\x9a\x58\x64\x1b\x13\x7c\xf9\x06\x09\xf0\xe2\x0c\xce\x2c\xd9\x00\xcf\x2e\x59\x0e\x06\xed\x2c\x49\xb8\xba\x50\x1e\xb0\x57\x89\xb2\x3d\x18\x20\x19\x63\x5a\x64\xfc\x5a\x27\xa8\x53\x37\xac\x1f\x4d\x6f\x54\x72\xce\x0b\xa6\x7f\xa6\x97\x22\xb9\x64\xef\x9d\x92\xaf\xf9\x60\x30\xcd\xd9\x3b\x65\x4d\xab\x13\xe5\x76\x2e\x02\x0e\xbf\xa7\x13\x93\x58\xd0\xb4\x00\x48\x4c\x79\x93\x08\xa1\x28\x92\xca\x70\xdf\x7e\x7d\x65\xbf\xbe\xb5\x5f\x3f\xe1\xd7\xb7\x74\x9a\xe7\x9c\xa6\xaf\x92\xa9\xa2\xf3\x68\x4c\x87\x8a\xc6\xf7\x2c\xf3\xbe\x7e\x10\xb1\xfe\x29\xb2\xc9\x48\x24\x62\x38\xc3\xdf\xc7\x60\xe0\x85\xdf\x3f\x0a\xee\x51\x76\x32\x61\xd1\x34\xa1\x99\xdf\xac\x93\x89\x70\x81\x4e\x15\xff\x07\xec\x74\x9a\xf5\xa7\x09\x4b\x23\xa6\x6c\x24\x95\xf1\xd2\x40\xe0\xb9\xb6\xfc\xdc\x18\x50\x95\xad\x7f\x6c\x0c\xa0\x13\xfc\x34\x08\xe7\xef\xa5\x4c\xf1\x3e\x7b\x20\x32\xc6\x87\x29\x0e\x5a\x30\x94\x80\xff\xb4\x28\xc2\x97\x4f\x28\x87\xa3\x0b\x96\xa1\xd5\x84\xe6\x8b\x6b\xfc\xf1\x36\xa3\x31\x67\x48\x18\x1a\x0a\xe3\xb7\x1c\xac\x40\xc6\xac\xa0\x72\xd2\x40\xab\x95\x3c\xe7\xe9\x70\xc3\x54\x32\x9e\x28\x19\x74\x3e\x0b\x55\xd7\x44\x24\xb3\xa1\x30\x5f\x75\x8d\xb2\x32\x9a\xb8\x75\xea\x33\x77\xf4\xaa\x8a\x07\xf9\xf8\x51\x88\x09\x7e\xce\x90\xb1\xf9\x25\xb4\x31\xbf\xe2\x45\x04\xd5\xe5\xb3\x71\x5f\xe0\x69\x3f\xbb\x2e\xf4\xa7\x1e\x18\x05\x2f\xb0\x5c\x91\x21\x1f\x8a\x7c\x42\x81\xa0\x69\xae\x4c\x5a\x19\x5c\x4d\x5c\x02\x7f\xce\xad\xe6\x31\x3e\x75\x02\x05\x64\xd2\xdd\xb3\x0f\xed\x3f\xb3\xfa\xf0\xa3\x5e\x9b\xce\xf1\x08\xd2\x6c\x39\x87\x21\xb0\xb0\xd0\x7a\xa7\xe2\xb0\xa4\x45\x7e\xdd\x23\x5b\xde\xa4\x8d\x2f\x6a\xcd\xfe\xcd\xd9\xac\xe5\xee\x61\x9b\x37\x4b\xc3\xe9\xd5\xad\x3d\x88\x3b\x1d\x31\xfb\xe3\x8e\x93\x0b\x55\xd6\x6e\xf8\x2a\x2a\x0e\xf6\x5a\x8e\xdf\xa2\xf2\x9a\xd2\xc9\x34\x27\x4f\xf6\xec\x2e\xf7\x8a\xaa\x93\xf4\x6f\x70\xbe\xc5\x52\x27\x82\x96\x9c\x7f\x21\x41\xf6\x06\x7c\x79\x70\x17\x5b\x2c\xd5\x5d\xec\xe6\xff\xea\x05\x26\x73\x38\x80\xe7\x5d\x48\x6a\xdd\x81\xb4\x03\xee\x4d\xb0\xa1\x3b\x28\x5f\xd8\x83\xdc\xa6\x5c\x3f\xc3\xcf\x36\x99\x64\xec\xf2\xc0\x8e\x80\xf9\x27\xa4\x75\xde\x7e\x9a\x2d\x8b\xb2\x35\x9f\x8f\x73\x50\x58\x52\x82\x35\x86\x76\xf4\xac\x0e\x4b\xef\xd8\x80\x2c\x4c\xe4\x72\x38\x6a\xa9\xbc\x73\xcd\x15\xb8\xa4\x38\x7b\xdc\x87\x45\x57\x3e\xa2\x49\x22\xae\xb4\x1b\xaf\x73\x87\x4c\xb5\xea\xb4\x9d\xa4\x96\xae\xe1\x7a\x4b\x2d\xc2\xe0\x96\x02\xb4\xc6\x1f\x0c\x5c\x99\x9a\x35\xbd\x19\xfd\xd1\x88\xa6\x43\x16\x57\x2e\xea\x4d\xb5\x5a\x67\x24\x14\xa2\xb4\x57\xea\x18\x5d\xc8\x90\xa6\x0b\xc9\x04\xbf\x48\xc5\xae\xc0\xfe\x31\x68\xb6\xc8\x48\x2a\xec\xf5\x66\xe0\x66\xcc\x97\x66\x2f\xab\xe9\x12\xdd\xf6\xa8\xb1\x02\xed\x35\x6c\x6f\x6f\xaf\x02\xac\x2c\x6b\x77\xdf\x17\x18\x6d\x74\xf6\x58\x23\x7b\x7c\xde\x89\x20\x8c\xb2\x5b\x25\x1e\x7b\x2f\x87\xc7\xa3\xf4\xae\x2d\x0b\x14\x59\xec\x1c\xe9\x2e\x92\xcd\xd1\x91\xc2\xb9\x57\x5e\xf9\x5b\x4e\x85\x90\xdd\x00\xb2\x42\x03\xdd\x97\x44\x91\x26\x33\x9f\xc2\x79\x46\x8b\x73\x70\xf8\x0c\x35\x3d\x5d\xe5\x30\x1f\x1a\xe4\x79\xca\xc7\xeb\x26\x45\x04\x1c\x1a\x59\x82\xcc\x69\x11\x9e\xe8\xa9\x5a\x88\x2f\x6c\x00\x64\x26\xa1\x25\xaf\xa2\x1c\x2d\x36\xf7\x64\x72\x2e\x92\xb2\x1a\x53\x1b\xd3\xda\x01\xe6\xce\x15\x6e\x6c\xa8\x50\x1a\xed\x5d\x8e\xab\xaf\x17\x9d\x85\x4a\xd7\x67\x0e\xde\xd0\x3b\xbf\xbf\xcd\xf4\x7c\x04\xba\x2a\xc3\xcb\x70\x96\x07\x98\xfe\x9e\x4e\xec\x7a\x84\xf9\x8b\x11\x7d\x6f\x1a\x89\x2c\xb6\x51\xbb\xee\x2b\x77\x77\x5e\xbc\x79\xc7\x6b\xc1\xfd\x5b\xc5\x52\xd5\xb2\x88\x79\x2b\x07\xef\x2a\xdb\xb2\xde\xa0\x32\xed\x0d\xef\x17\x9d\x05\xe8\x79\x10\x14\xc2\x33\x32\xa9\x2f\xb6\xeb\x94\xe9\x99\x7a\xbe\xb7\xc5\x4d\x98\x34\x59\xbd\x83\xf5\xdc\x0d\xcb\x39\x32\x67\xa8\x95\x38\x3a\x2a\xdf\x2d\x22\xd2\x88\xd5\xc2\xcb\x4c\x1b\x97\x53\xf2\x02\xc0\xe5\xd4\x8f\x7d\xea\x51\x02\x07\x27\x12\xc0\x15\x6e\x7b\x6f\x2e\x65\x42\x11\xa0\x7b\xcd\x29\x6d\x0f\xe2\x4c\xd1\x07\x8c\x70\x55\x63\xcb\x0f\xc1\xe6\x0a\xa7\xfe\x2e\x95\x77\x1a\xd1\xa2\x59\xe1\xb5\xca\x60\x71\x82\xa1\x95\x23\xd9\xf9\x32\xa4\xcb\xb8\xf1\xd3\x9c\x91\x5e\x66\x9a\x1f\x86\xe3\xb6\x66\xd9\xca\x4a\x6b\xd6\x0a\xdf\x9a\xc1\xd9\x79\x98\xdd\x74\xee\xfc\x0b\x04\x87\xbe\x64\x20\x82\x66\xc2\xd2\x4b\xf9\x1a\xd3\xc1\x33\x99\x7f\x1e\x4c\x50\x73\x61\xc3\xc5\x16\x1e\x4b\xeb\x76\x04\x7e\x3a\xdd\x36\x04\x59\x5a\x6a\xca\xbb\x20\x63\x98\xb1\x01\x91\xa6\x57\xa9\x5f\x60\x37\x51\xa1\x5f\x70\xff\x23\x27\x6b\xef\xea\x9f\x58\x5a\xa0\xc8\x02\x76\x31\x81\x6b\xf5\xe7\x2b\x8c\xed\x30\x27\x64\x99\xc5\xad\x62\xb2\xb5\xc8\x57\xb5\xf6\x3d\x10\x93\x59\x06\xc7\x95\xdb\x5b\xdd\xe7\x1b\xdb\x5b\xdd\x17\x6d\xf2\x86\x46\xac\x2f\xc4\x45\x9b\x1c\xa5\x11\xd8\xe1\xc8\x8d\x2d\x80\xe5\xb2\x35\x2c\xbb\x64\xb1\x4c\x97\x59\xa7\x23\x9e\x93\x5c\x4c\xb3\x88\x91\x48\xc4\x8c\xf0\x9c\x24\x3c\x02\xaf\x17\x04\x5e\xdf\xc0\x96\xf8\xd5\xc9\xeb\x0d\x38\xd0\xd0\x99\x64\x20\xa6\x29\x44\x4a\x2d\x46\x4c\x22\x7a\x77\x74\x70\xf8\xe1\xe4\x50\x6e\x85\x99\x4a\x26\x99\x10\x85\x72\x02\x25\xb2\x19\xc6\x40\xb5\xd5\x15\x19\x63\x1d\xb2\x9f\x12\x1a\xc7\x5c\xb6\x8f\x26\x64\x98\x51\xdc\xa4\x8b\x01\x99\xd0\x82\xa5\x85\x26\x5c\x19\x11\xb9\xd5\x92\x8f\xfb\xa7\x87\x1f\x4e\x4f\xbc\x3a\x73\xa9\xbf\x4d\x9d\x68\x54\xb4\x66\x8e\x18\x4e\xf8\x98\x27\x72\x50\x09\xc2\xd3\x4b\xf4\x85\x41\xfa\xd3\x02\x23\xb6\x26\x62\x98\x13\x4a\x54\x4c\x54\x29\x3c\x10\x9a\x54\xa4\x48\x9f\x8e\x49\x3a\x66\x45\xc7\xf0\x4e\xd1\x05\xae\x8b\x0b\x21\x51\x10\x9e\xe7\x53\x96\x63\x60\x9f\x4b\x96\x88\x09\x9c\xc9\xb0\xf4\x92\x67\x22\x45\xb5\xc6\x53\x12\x65\x1c\xbc\x41\x48\x4c\x13\x5a\x8c\xf2\x0e\xf9\xc4\xc6\xe2\x52\x1b\x11\x25\x62\x38\x94\xdf\xa1\x57\xe4\x9a\xcd\xc6\xdd\xf3\x71\x5d\xf1\x24\x21\x17\x8c\x4d\x74\x57\x00\x0b\x12\x31\xe4\x11\xdc\x31\x60\xcc\x59\xcb\x1c\x40\x88\x35\x22\x77\xc0\x28\x49\xb5\x79\xcf\xf3\xd0\x2b\x65\xfe\x9e\xc1\x00\x2b\x10\x19\x06\xb6\x09\x9e\x15\xb6\x09\xcd\x86\xb9\xbb\xd2\x4c\xc0\xa0\x89\x66\xc3\x29\x2a\x68\xe5\x32\x10\xf2\x25\x2c\xde\x5a\x2a\x27\x83\x12\xf8\x57\xb2\x4d\x5e\x42\xb1\x0d\xb2\x4d\x76\xc8\x96\x52\xe3\x66\x71\x7b\xc1\x66\x64\x8f\x6c\xef\xc2\x97\x5f\x24\x24\x7c\x75\x43\x41\x49\xc4\x67\x32\x7b\x83\x6c\x9f\xbb\xd5\x3b\xd1\x55\x6f\x8d\x1a\x41\xd2\x41\x8f\x98\xc3\x7a\x8b\xcb\xc6\xde\xc0\xb8\x1b\x66\x22\x69\x7c\x56\x1c\xa9\x62\x43\xa7\xd3\x01\x4e\x7c\x26\x4a\x37\xb8\xe2\xd7\x20\x4f\x2d\x96\x31\xcb\x73\x3a\x64\x86\xc6\x86\xca\xf2\xa3\x25\x5a\x3a\x15\x07\xc9\x2f\xa4\x0b\xd7\x24\xcd\xcd\xff\x77\x96\xff\xe7\x1f\xe7\x4f\xbe\xdf\x6c\x75\xe4\x56\x57\xc1\xb5\x16\x69\x82\xdc\xeb\x6a\xaa\x14\x1b\xf2\x91\x98\x26\x31\x98\xf5\xf5\x13\x0c\xc4\x9a\xf2\x3f\xa7\x2c\x99\x11\xb4\x91\x1e\xcc\x70\xb0\x7b\xad\x50\x48\x3a\xe4\x63\xc2\x68\xce\xda\x10\xbd\x95\x62\xa4\x58\x1d\xa0\x8a\x5f\x32\x5d\x49\x31\xa2\x29\xc6\xe3\xc5\x84\xda\x36\x3f\x32\xbc\xf5\xd7\x74\x34\x1b\xea\xa9\x6a\xcb\x5d\xb7\x69\x6e\xee\x91\xc6\x1f\x54\x39\x32\x71\x09\x55\x3c\xcc\x18\x9c\xff\x37\x37\xff\x25\xdf\x1c\xfa\xbe\xab\x9d\x55\x85\xf1\x5d\x39\xcc\xcf\x74\x85\x4f\x9f\x3a\xd1\x79\x6f\x5b\x6e\xdc\x2f\x75\xf9\x13\x89\x34\x17\x09\x0b\x6f\x7f\x5c\xd4\x0a\xa4\xc3\xa0\x3b\x14\xcd\x2d\x7f\xfd\x41\x88\x9c\xdc\x6c\x99\xcd\x4d\x54\x4b\x50\x86\x5c\xd1\x1c\xbb\x35\xc5\xd8\x76\x91\x48\x2f\x59\xca\x99\x5c\x1a\xe6\x42\xf2\xb7\x20\x33\x15\xb3\x1a\x03\xe9\x4a\xf5\x5c\xd0\xe8\xc2\x45\x58\x08\x30\xa3\x44\x65\x48\x93\x24\xe7\x70\xb1\x4a\x0b\x12\x51\xd4\x7b\xb2\x98\x16\x10\x80\xce\x98\x8d\xb5\x1b\xca\x55\xa9\x21\x24\xa2\x45\x34\x6a\xca\x49\xdb\x59\x54\xed\xae\xdd\x56\xc4\x38\x54\xb5\xc0\x5c\xbc\xea\x20\x9f\xdd\x17\x7f\x5d\xac\x14\x3e\x1e\x4f\x21\xc4\x4c\xe0\x45\xdd\xe0\x3e\x7b\xdc\x7f\x7c\x0e\x31\xe4\xed\x91\xd9\xb2\x98\x28\x60\x9a\x98\x03\x39\xf5\x48\x57\x64\xbb\xd6\x15\xac\x5b\x4f\x93\xb6\x49\x1f\x25\x71\xf3\x49\x60\x90\x50\x69\x86\x20\xf9\x16\xe8\x5e\x9e\x12\xba\x80\x1d\x02\x55\x81\xe5\xd7\xd7\x49\xf3\x51\x0d\x4c\x5f\xc1\xdc\xdc\x10\x8a\x51\x36\xe5\xa0\xe9\x63\x5c\xed\xbb\x37\xd1\x0e\x61\x3d\x45\x59\x7f\x01\xca\xfa\x18\x9a\x1d\x8f\x4f\xeb\xa9\x07\x98\x45\x88\xf0\x37\xf2\x6b\x2e\xe7\xa5\x2a\x35\x77\x97\xbf\x4d\x62\x5a\x30\x6d\xa0\x91\x17\xb4\x60\xfe\xf5\xb1\xd7\x53\x0a\x0c\x62\x54\xab\xbb\x7e\xb9\xb7\xf3\x60\x00\x87\x82\x41\x7c\x3e\x01\x15\x82\xd1\x8c\x6c\x2c\xf5\xaf\x77\xdb\xa5\xc0\x49\xe9\x46\xc6\x68\x9e\xf3\x61\x0a\xbe\x48\x75\xc8\x6d\x13\xa0\xa9\x53\xd9\x4e\x90\xf0\x8a\x74\xa0\xd0\x1f\x9d\x3f\x3c\x68\xb9\x2d\xbb\xbf\x4f\x73\xf6\x96\x15\xa7\x74\x58\xe3\x23\xf9\xc5\xb3\x16\xee\xb8\xb5\x41\xcf\x3c\xaf\xf2\x92\x16\xf2\x19\xe1\xfe\x57\x21\xf0\xaa\xe4\xb3\xde\x55\x64\x3a\xe6\x5d\xde\xd1\x47\xbd\x34\x9f\xa5\x11\x56\xde\x38\xc3\x27\xb4\x64\x5f\xa6\x69\x1b\x9a\xf3\x06\xd6\x2e\x5b\x17\xc0\x85\x20\x43\x96\x06\x10\x6f\x59\xca\xa0\xef\x42\xd0\x49\x26\xae\x67\x01\xf0\x47\x99\x76\xde\xb0\x77\x6f\x07\x23\x16\x5d\xe4\x72\x3c\x7c\x86\x60\x59\x9f\xe5\x62\x17\x2c\xf4\xf1\x29\x0f\x4c\x1f\x9f\x35\xea\xcf\x04\xf1\xe8\x5d\xc4\xbf\x62\x38\x46\xf8\x3a\x66\xe3\x3e\xcb\x8e\x07\xa4\x87\x39\x5c\x4e\x36\x5b\x9d\x6e\x67\x0b\x7e\x47\xb4\x60\x43\xb9\x1b\x78\x47\xe1\xc9\x8a\x3e\x66\xff\xfa\xe4\x16\xc3\x74\xc1\xc9\x3a\x7e\x2b\x04\x89\x24\x5d\x1d\xe7\x6c\x3d\x27\x5f\xfb\xfa\x70\xfd\x93\x4a\xf9\x2c\x07\xd5\xe7\x80\x78\x37\xa0\x19\x9c\x04\x7c\x86\x41\xf9\x19\x91\xb1\x6b\x3a\x9e\x24\x4c\xd1\xdf\xeb\x58\x43\xa6\x66\x4f\xce\x4c\x4f\xa4\xc8\xef\xfd\xaa\xa2\x7c\x95\x81\x36\x69\x3f\xda\x74\x01\x01\x39\xac\xa7\x9d\xf3\x7b\x03\x1e\x04\x37\x7e\xa4\xe5\x4b\x65\xcc\x3b\xed\x86\x19\x1d\x36\x18\x72\x53\x54\x96\x37\x7a\x29\x78\x9c\xeb\x4d\xc7\x15\x2f\x46\x18\x0f\x1f\xd7\x19\x9f\x89\xd4\x57\x52\x2c\x10\x15\x4f\xc9\x09\x1d\xd0\x8c\x93\x9f\xc9\xd5\x88\x47\x23\xa2\xd9\xda\xc0\x2e\x6d\x80\xb6\x94\x85\x63\x7c\xe7\x90\xc3\x26\x02\x1e\x76\xb8\xc1\xd5\xe4\xe6\x01\xcf\x27\x40\xb2\xec\xd0\x52\x4d\xda\x75\x54\x9e\x84\xd8\x33\x52\x7d\x73\xa3\x53\x94\x10\xdb\x04\x33\x42\x6c\x92\x96\xde\xea\xe5\x80\x65\xf1\xee\x5a\xa8\x2f\xe6\xc6\xec\xfe\xaf\x11\xf9\xac\x2e\x40\xd5\x98\x16\xa3\x13\x3e\x4c\xff\xb2\xa8\x3c\x3c\xff\xc8\xb2\x88\xa5\xab\x8f\x3a\x54\x17\x6d\x49\xdb\x5f\xfd\x65\xc1\xa5\xa0\xc2\xe3\xec\xa4\x58\x7d\x95\x75\x11\xbf\x70\x4b\x74\xb4\xfa\x30\x52\x75\x41\xdc\x86\xac\x50\xfd\xf8\x3b\x44\x21\xff\xab\x22\xe5\x0d\x59\xb1\x9f\xce\xd4\xd1\xfd\xf1\x00\x75\xd4\xca\x6b\xaf\x8b\x13\x38\xa2\xf9\xeb\xe9\x24\xe1\x72\x6a\xf9\xcb\x62\xf4\x71\xe3\x0b\x9e\xd5\x08\xf2\x12\x71\x85\xbe\x4d\x50\x93\x72\x05\xfa\xfc\xfd\x61\xa1\x8b\x1e\x14\xd4\xc4\x31\x32\xf9\x40\x3f\xd4\xb6\xf9\xc7\xee\x92\xe1\x3f\x42\xfc\x0f\x68\x72\x88\xea\xc1\x11\x85\x50\x60\xe6\x44\x6b\x5a\x32\x72\x4f\x45\x15\x0f\x68\x76\x05\xb6\x07\x07\x14\xfa\x56\x71\xaa\x2a\xaa\x78\x40\xcb\x2b\xb0\x99\xd8\x29\x70\x7c\xa4\xa6\x67\xf7\x06\x44\xa7\x85\x4b\x3d\x5c\xc9\x56\x19\x15\x6c\xb9\x16\x05\x08\xf6\x6b\x09\xa8\x1b\x5e\xc9\x6c\x74\x5d\x63\x28\xa5\xed\x7d\xab\x11\x95\xe8\x52\xa2\x0a\x2f\xc5\xc0\x66\x4b\x63\x5a\x5f\xc7\x85\xb9\xb1\xf5\x6a\xfc\x4b\x03\xe3\x65\x63\xb2\x3a\x73\xdc\x20\x1e\x8d\xca\xce\xda\x23\x11\xd3\xee\x45\xe1\x1c\xe1\xf6\x28\x9c\x63\xea\x54\xa7\x13\x4c\xf9\x80\x6c\x58\x2d\x94\x08\x87\xd4\x0a\xd2\xc3\x56\x2d\xfa\x94\xaa\x96\xdf\x0e\x35\xf1\x81\x98\xca\x09\x07\x0f\x32\x65\x92\x5e\x5b\xb8\xe4\xe9\xb4\xe6\x24\x63\x03\x7e\x6d\x6f\xdd\xb8\x04\x7b\xfa\xd4\xa0\x71\xef\xb7\x1a\x0d\xf2\x94\xa8\x12\xe0\xbb\xa0\xd1\x22\x4f\x09\x8f\x5d\x1b\xab\xb7\xac\x20\x13\x25\x6a\x28\xa9\x60\x5a\x59\x88\x82\x26\x98\xe0\xee\xe4\x90\x0d\x37\xda\xcf\x83\x2e\xb8\xaf\xbf\x95\x61\x6f\x11\x15\x2c\x5a\xe0\x18\xe5\xb4\x06\xf3\x6f\x08\xad\x38\xa5\xe1\xed\x8e\x11\xdb\xc4\x62\x72\x35\x62\xa9\xa9\x99\xe7\xf6\xc8\x9e\x88\x0c\xae\x7e\x12\xee\x5a\x86\x59\x83\x2d\xf3\x72\x04\xfe\x8e\x06\x24\x67\x85\xdc\x88\xf6\x19\xc6\x82\xc6\x8b\x2d\xdc\xe3\xc3\xcd\x4b\x9f\x99\x32\xb1\x67\x03\xa6\x9b\xa6\x5b\x61\x1f\xc2\x3a\x4b\xb4\xf0\xf9\xab\x93\xd5\x54\xe4\xb7\x1d\xe6\xd8\x2e\xf5\x58\x50\xbe\x3a\x81\x0b\x92\xf5\x75\xe7\x4e\x63\x1b\x8f\xcd\x2c\x23\x5e\xfa\x99\x3b\xa8\x90\xdc\xe7\x27\xd5\x78\x9f\xf9\x78\x9f\xcd\xc3\xfb\x4c\xe2\x55\xdb\x59\xbb\xf7\x55\xe3\x44\xb5\xef\xae\x51\x3b\x7f\xa8\x68\x24\x81\xde\x74\xd9\xe3\xbd\xb7\x52\xfa\x38\x7c\x2a\x6f\xb5\x66\x88\x10\xc6\x8f\xba\x44\x50\x79\x9e\xfe\xd3\x96\x50\x88\xd6\x91\xe3\x27\x78\x2b\xfe\x26\x11\xd4\x60\xed\xe4\x09\x8f\x58\x73\x4b\x5f\x53\xb7\xc8\x26\xe9\x6e\x6d\x95\x9e\xc7\x6b\x74\x4f\x55\x39\xcf\x4c\x0f\xb4\x57\x70\x72\xa0\x0b\x54\xb6\x5b\x4d\x30\xd8\xa7\x5a\x89\x93\x5f\x4b\x72\x55\xd5\x8c\x70\xfe\xb9\xc4\x44\xc7\xb6\xa1\xbc\xf2\x0f\x84\xba\x0c\xa0\x82\xec\x6b\x89\x30\xbf\xea\x9f\xc9\x5d\xb0\x99\xdc\xef\x63\xf1\x8e\xfc\x05\x38\x4c\xff\x41\xfe\xfa\x3a\xc0\xe9\x08\x64\x3e\x4a\xd1\xff\x72\x26\x73\xcf\xb6\xce\xef\xb0\x73\x70\xf7\x13\x6e\x53\xdc\xf4\x26\xd5\x46\xd6\x8b\x9b\xe8\x96\x8d\x5f\x24\x92\xb9\x8f\x8c\xdc\xbb\xd1\x99\x73\x2b\x0a\x26\x90\x34\x1a\x31\x6b\xaa\x55\x65\xd6\x07\xb7\x9e\x8e\x51\x1f\xde\x95\xc9\x72\x67\x34\x9b\x9d\xf1\x73\xc7\x06\xca\x4b\xf6\x6c\x5d\x02\x4b\x9a\xc0\x26\xb2\x6c\xab\x66\x4d\x74\x71\xf2\x0a\x77\x4a\xde\x8c\x1a\x66\x36\xf1\x79\xdc\x7e\x5b\xbd\x93\x7b\x65\xb9\x6c\x14\x87\x02\x69\xa1\xd1\x98\x97\xf8\xaa\xc4\xcf\x39\xee\x2a\x14\x1e\xf2\x94\x14\xe4\x09\xd1\x18\xc8\x86\xce\xd0\x17\x8d\x25\x1b\x64\x83\xb3\x24\xb6\x80\xc1\x79\x90\xea\x1f\x49\xfd\xb4\xc0\x11\x36\x9c\x38\xdd\xe3\x54\x36\x25\x9f\x41\xb0\xfe\x16\x67\xb2\x29\x9e\x29\x2e\x76\x22\x8b\xb7\xfd\x67\xdd\x36\xd9\x6e\x93\x67\xe7\x73\x8e\x65\x11\xd2\xbc\x8d\xeb\x8b\x78\xd6\x89\xac\x7d\x6f\xe9\x90\xd6\x2f\xd7\xa0\xfd\xa8\x71\x37\x58\xaf\x93\x0a\x31\xa9\x3e\xf3\xc5\x25\x23\xc0\xe9\x58\x88\xba\xdc\x6e\xe5\xb1\xa5\xce\x0a\x04\xe4\xe7\x6f\x7f\x66\xb9\xf8\xa9\xc1\x37\x89\x3a\xba\xb5\x82\xa8\xa3\x5b\x0f\x8b\x3a\xda\xfd\x86\x51\x47\xbb\xab\x8a\x3a\xda\x5d\x41\xd4\xd1\xed\x1e\xe8\x8a\x94\x8e\xe7\x34\x74\x7b\x15\xb8\x1f\x74\xcc\xe0\x22\x6a\xe1\xee\xa6\xc7\xae\x0b\x96\xc6\xce\x94\x8f\x57\x8b\x72\x83\xe2\x68\x74\x9a\x0d\x59\x51\x0a\x4a\xda\xd5\xa1\x47\x03\x6b\x22\x1d\x80\x14\x5e\x63\xa1\x0d\x9a\x6b\xf4\xc3\xcf\x77\x4b\x57\xd8\x08\xa6\x03\xa2\x2a\x52\xec\x95\x66\xd5\x9d\x30\x16\xc1\x2b\x6b\x59\x10\x89\xc4\x7b\xeb\x3d\x85\x10\x0d\x8c\xc8\x2d\xfc\x33\xb7\x24\x12\x6e\x57\x4e\x1c\x4e\x80\x56\xd4\xe9\x7f\xa0\x6f\x28\x55\x11\x67\xb0\xf8\x81\x2a\x72\xdd\x20\x2c\x8e\xcb\x81\xc0\x27\x00\x2e\xaf\xcc\x32\xc9\xac\x5e\xb9\x7e\xa0\x15\x89\xb4\xe0\xe9\x94\xed\xba\xef\xb5\xef\x68\x26\x10\xc0\x5b\x6e\x61\xd5\x52\x78\xcb\x2f\x57\x5b\x5e\x68\x57\xd3\x3c\x33\xb9\xfd\xeb\x80\x27\xe0\x7c\xf2\x92\xb3\x2b\xf2\x8e\xce\x58\xa6\xad\xf5\xd6\xb4\xab\x90\x53\xe5\x26\x0a\x5d\x60\xd2\x3c\xff\x40\xc7\x73\xdd\x7f\x56\x8f\x3f\x3f\xb4\xa5\x9a\x18\x96\x42\xb3\x90\x0f\xea\xda\xd2\x30\xf9\x1d\x0f\x16\x1e\xf6\xae\x9b\x5e\x11\xb3\xb9\x0f\x41\xe6\x96\x3c\x6f\xad\x79\x72\x05\xdc\x6e\x3a\xce\x01\x8c\xb3\x3a\x74\x2d\x86\x2f\xf9\x8d\x95\xad\x5e\x22\xea\x1e\xb0\x10\x3a\x45\x83\xc0\x3d\x21\x38\x78\xa9\x93\x5c\x65\xb1\x70\xd6\xd0\xd8\xf1\x65\xb8\xc2\xd3\x38\xc7\x35\x3d\x2c\x7c\x25\x91\x07\xe0\x25\x6e\xde\x43\x9f\x6a\x4d\xd4\x6c\x35\x1b\x19\x03\xbf\x0d\xf9\x06\x60\x6a\xb4\x6d\x03\x3c\x0b\xdf\x7b\x4c\x56\x1d\xea\x3f\xbc\x47\x23\xb9\xc6\x50\x5d\xb5\x6b\xb5\xd5\xfc\xea\x4a\xab\xd3\x8e\xdb\xb6\xe2\x90\xb2\x33\xb0\x8f\xc7\x08\x1a\x65\x40\xc7\x74\x5c\xd1\x37\xdf\xd1\xe6\x49\xeb\x69\xad\x70\xd5\xfd\xc6\x7c\xd3\x9f\x26\xa0\x6d\x85\xeb\xd1\xed\xad\x15\x5a\x30\x6b\x13\x8b\x3e\x4b\x3e\x26\xd3\x21\x4f\xdf\x24\xe2\x0a\x0c\xdb\x3f\xea\x16\x80\x84\x4a\x01\xed\xc1\x03\x7d\x30\xd8\x7b\x3d\xc5\x70\x01\xb5\xd3\xb0\x3f\xe4\x2a\x21\xac\x6b\xf7\xca\x6c\x08\xdf\xd3\xfc\x0a\x91\x59\x95\x57\xe4\x39\x68\x3a\x3c\xff\x84\xa9\x31\x04\x73\xbd\xc6\x68\x1c\x8b\x95\x58\xbb\x6d\x81\x00\x2f\xc5\x8a\x03\x9a\x24\x7d\x1a\x5d\xd4\xb3\x42\xf6\xd1\xd2\xd8\xa5\x00\x1a\x65\x4a\x27\x13\x46\xeb\x59\xe1\x84\xbb\x06\xc0\xfd\xa8\xe0\xe8\x77\xf9\x0e\xf0\xf9\x1c\x0e\xe0\x16\xc7\x3a\xaf\x13\x7c\xb0\x85\x70\x96\xb7\x66\xdb\xdd\x07\x5b\x17\x0d\x13\xd1\x87\x07\x9c\xd5\x77\x77\x3f\xab\xa5\x4d\x24\x32\x56\x7b\xfd\xb1\xa5\x80\x46\x3c\xae\x03\x7a\xd6\x7d\xae\x80\x32\x86\x47\x6e\x35\x80\x3f\xfc\xf4\x93\xae\xb2\xb8\xae\x83\xf9\xb9\xab\x60\x3e\x7e\x3a\x3e\x3d\x3e\xfd\x8f\x8f\x87\x04\xad\xba\x71\xea\x6f\x28\x69\xfb\x5e\xa9\x99\x3d\x77\xf5\x05\xde\x3f\x53\x78\x11\x64\xd6\x49\x4a\x75\x1f\x9d\xf4\xde\x1c\x7f\x3a\x38\x7c\xad\x3c\x47\x92\x75\x8d\xa2\xf3\x66\xd7\xc2\xbc\x7d\x77\xfc\x6a\xff\x5d\x19\xe6\xad\x03\x73\x72\xba\x7f\x7a\x74\x50\x86\x39\x71\x60\x80\xf8\x32\xc8\x47\x07\xe4\xd5\xd1\x87\x0a\x62\x5e\x19\x0f\x9a\x7a\xf9\x64\xa9\x7a\xa9\x7b\x74\xc7\x21\x43\x27\x9e\xa5\xfa\x1d\x55\xd3\x4b\x90\xeb\xaf\x16\xd9\x09\x52\x6f\x6e\x64\xf2\x99\xe1\xb1\x79\x6f\x67\xb7\x84\x6e\xbd\x20\x22\x3b\xf0\xe1\xd4\xe3\xfc\x84\x5a\x1c\x1c\x1f\x65\x7f\x91\x3d\x8d\xce\xa9\x08\x4a\x56\x24\x7b\x18\x2e\xd8\xac\x4d\xc4\x55\xda\x26\x62\x5a\x80\xb4\xef\xaa\x23\x17\x43\x55\xcb\xae\x98\x25\x09\xbb\xfa\xc0\x29\x5c\x27\xaf\x29\x9b\x61\xb9\x2a\xa4\x3c\x85\x97\x0e\x29\x95\x43\x12\x7d\x7b\x5d\x49\x45\xff\xc8\x8a\xc7\xfa\xba\x66\xbd\xf9\x66\x4d\x3c\xcd\x99\xf2\xae\x46\xab\xc4\x10\x31\x12\x91\x91\x89\x54\x6a\x31\xe2\x06\xbf\x52\x4d\x59\xc5\x4b\x8d\x74\x47\x53\xe6\x98\xf4\x6f\x6e\x92\x3e\x98\x33\xf3\xb1\x5c\xaa\x14\x42\xf7\xb3\x6c\x90\x5c\xdb\x92\x41\x26\xc6\xba\x2a\xd9\x10\x76\x8d\xa6\xe7\xec\x7a\x82\x3d\x05\xc2\xb4\xbe\x4e\xb0\xae\xa8\xb8\x6e\x02\xe3\x10\x4f\x0b\x05\x06\x65\x52\xb9\x0b\x15\x03\x24\x6f\x8f\x34\xf4\x00\x6a\xa8\x92\xda\x80\x09\x96\xd5\xd0\x03\x12\x01\x38\xb4\x32\x8d\x96\x8b\x0a\x85\xdd\x9c\xe3\xe9\xcd\x8f\xd6\x02\x2a\xa1\xad\x7a\x53\xd2\x13\x08\xfb\x6f\xad\x80\x8f\xf6\x89\x94\x12\x10\xc5\x79\x24\x42\xea\x20\x6b\x43\x0d\x58\xd9\xf5\xc4\x71\x42\xec\x36\x52\x0b\xa1\x8f\xc2\x4f\xdd\xd3\xad\xba\x95\xfa\x17\x9b\xd3\x51\xea\x50\x7e\xec\xae\x6d\x6e\x22\xcd\x7d\x5e\x8c\xe9\x64\xcd\xa8\x0c\xdc\xd4\x01\xe5\x03\x91\x45\x2c\x36\x59\x6f\xf1\x91\x07\x64\x29\x06\x19\x05\x41\xf6\xc8\x73\x95\xa5\xce\xc2\x8c\x62\x20\x7b\xe4\x27\x95\x05\xba\xce\xe4\xbc\x92\x55\xfd\xb0\x6b\xa4\xc4\x64\xfc\x41\xf6\xc8\xb3\x6d\xcc\xb8\xca\x1c\xe2\x7e\x23\x7b\xe4\x87\xe7\x98\x91\xd3\x01\x33\x19\x9f\x24\xaa\xed\x9f\x76\x65\x46\xc6\x68\x82\x35\x91\x31\x2b\x46\x22\x06\x61\xfb\x9c\xf0\x7e\x46\xb3\xd9\xe7\xf2\x09\x91\x42\x52\x3a\x21\xda\xde\xfe\xaf\x6f\xd5\x76\x55\x6f\x25\x04\x57\x0a\xaf\x66\xaf\x69\x41\xff\x37\x9b\xad\xdc\x58\x27\xad\xaf\xf9\xb5\x18\x53\x9e\x1e\x0f\x64\xd5\xaf\x66\xdf\xa2\xf2\x3a\xa3\xac\x88\x26\xd1\x34\xa1\x05\xc3\xa5\xc9\x29\x8f\x2e\xe0\x8d\xc8\xca\x09\xc8\xea\x5b\xff\x9e\xf2\x14\xdc\x65\x1d\x0f\xde\x66\x74\x32\xe2\xd1\x51\xc1\xc6\x2b\xa7\xe0\xcf\x7a\x0a\xde\xb1\x21\x4b\x63\xb9\x42\xcd\xff\x32\xfb\xbb\x21\x2b\x5e\xd1\xec\x84\xff\x83\xbd\xe3\xf9\xea\xed\xd1\xea\xac\x37\xb1\xda\x8f\x02\xd7\xdd\x7f\x99\x11\x9e\x5c\xa9\xa7\x31\xfa\x03\x3b\x1e\x20\xbf\x4d\xe5\xd3\x14\x5e\xea\x04\x34\x38\xe3\x02\xde\xe6\xbc\xa2\x59\x8e\xfa\x65\x65\xd4\xce\x6a\xa8\x85\xbb\x51\x53\xe9\xf1\x60\xff\x9a\xaf\x5e\x30\xc4\xdd\xfa\x40\x8e\x83\xfc\x0f\x5e\x8c\x4e\xe8\x98\x7d\x13\x22\xae\x6b\x0d\x52\x0f\xf0\xde\x85\xd3\xe4\x9b\x54\x3c\xae\x6f\xfd\x81\xc0\x20\x25\x05\xcb\xa5\x46\xe0\xab\x37\x51\x9d\xd6\x57\x2e\x35\xe0\xb7\xea\xf1\x3a\x73\xcd\x48\x8c\xfb\x3c\x65\xae\x7f\xd1\xd5\x57\xfe\x8f\x79\xb2\x7e\x12\xd1\x64\xf5\xe6\xa9\x75\x36\xb1\x70\x47\xa7\x65\xfc\xdb\x54\x5d\x67\xd9\x3d\xe0\x69\xac\x95\xdf\xf1\xe0\x15\x5d\xbd\xbd\xf5\xab\x9a\x9a\x8b\x6c\x9a\x46\xb4\x90\x0b\x0c\x68\xf9\x1d\xda\x0f\x63\xe3\x82\x21\x1f\xea\xbc\x5a\x25\x79\x52\xd0\xe8\x82\xc5\x72\xed\xb0\x62\xf5\x98\xd7\x0f\x13\xa8\xf4\x6d\x26\xa6\x93\xfc\xd5\x4c\x0e\x96\xa3\xbb\xd4\xb9\x59\x69\xe8\x8e\x87\x91\xb6\x62\x8a\x2f\xef\x1c\xd8\xdf\x46\xdc\x92\x39\xda\x0c\x7c\x92\x6a\x8d\x76\x3c\x78\xc7\xd3\xd5\xd7\x7f\xb1\x78\xfd\xdf\x42\xe6\xbf\xcc\x5b\x6c\xe4\x0c\x16\xd6\xdf\xa6\xe6\xba\x07\x15\x31\x2b\x58\x54\x7c\xd2\xef\xdc\xb4\xaf\xbe\x60\xe8\xad\x8a\x8a\xe2\x8e\x81\x82\xa3\x13\xe7\xf3\x95\x57\x3e\xb9\x7b\x1d\xe1\x8c\xd6\x3b\x46\xe9\xfb\xa3\x0f\xbd\xdf\xf7\xdf\xfd\x76\xd8\xfb\x74\xf8\x76\xae\xe6\x79\xbf\xff\x7f\x4b\x90\xab\x6a\xd2\xfe\xdc\xb9\x4a\x87\xf0\xfa\x46\x9d\x79\x50\x53\xb9\x36\x52\xb3\x83\xe9\x28\xfd\x44\xd3\xe1\xea\x47\x73\xdd\x43\x28\x18\x4e\x69\x2c\xf7\x0c\x35\x2b\x94\x7b\xbf\xba\xc8\x45\x56\xbc\xaa\x7f\xd5\xf1\xec\xc5\x92\x37\xf0\xa5\x0a\x56\xf1\xaa\x43\xe3\x7a\xf0\xa3\x8b\x6f\x65\xe9\x3f\xc7\x39\xe9\xc3\x9e\x76\x38\x96\xfe\x0f\x79\x7a\x31\xa6\xd7\xb5\x8d\xfe\xe9\xc5\x8f\xab\xc0\xbe\x8a\x37\x1d\x80\xe8\x81\x6f\x2d\xc6\x3c\x9d\x23\xd5\x0f\x7d\xc9\x01\xd8\x57\xf1\x88\x03\x10\x2d\x47\x4c\xd9\x73\xd9\x8a\x9f\x66\xd5\xbb\x46\x5b\xa2\xc5\x65\x64\xcb\x11\xf5\xa2\x2a\xba\x43\x5d\xc3\x97\x7c\xaa\x54\x59\xc7\x03\xda\x5e\x89\x6f\x39\xd2\x7e\xd0\xa8\x86\xac\xde\xfa\xed\xd9\xf3\x25\x7b\xdc\xc7\xfe\x80\x16\xfb\x88\x96\x23\xe6\xc7\xc0\xf7\x6f\xed\x95\xe3\x6a\xd0\x3f\xa0\xb5\x21\xaa\xe5\x08\xfa\xa9\xa7\x4d\x42\x7a\xb9\xdc\xa4\xcc\xd1\xd4\x4b\x76\x6f\xb9\x86\x07\x34\xba\x8c\x6c\x39\xa2\x7e\xee\xc5\xcf\xee\x68\xf0\xb3\x65\x1b\xdc\xdd\x02\xe4\x23\x3a\xa9\x47\xde\xfd\xf9\xe7\x25\x91\x77\xbd\xd8\x1d\x75\xe8\x97\x9c\x55\xbb\xdb\xbd\x5e\x44\xb3\x82\xe5\x9c\xa6\x3d\xb3\x91\x79\x2d\xe6\x0c\xfb\x9f\x97\x1c\x0a\xdd\x67\x95\x75\xc9\x9d\xea\x9c\xca\x96\x5c\x19\x76\x9f\x57\x56\xb6\x9f\x31\x3a\xa7\xb2\x67\x4b\x56\xf6\xc2\xad\x4c\x9f\xe8\xd6\x77\xd6\xd6\xb2\xb2\xf0\x43\xaf\x67\xdc\xca\xf4\xf0\x78\x7b\x8e\xc4\x2d\x2b\x13\x3f\xf6\x7a\x60\x4b\x73\x87\xc8\x3d\x33\x0f\x42\x95\xe1\xd3\xff\x58\xac\x2a\x8b\x55\xbc\x8d\xd6\x35\x18\x43\xd5\x36\xd1\x2f\x26\xb5\x21\xaa\x63\x9a\xaa\xc8\xac\x2d\xfa\x15\x0b\xef\xe0\x47\x9b\xb0\x74\x3a\x66\x19\xed\x27\x6c\x47\xbd\xca\x8b\x44\x3a\xe0\xc3\xa9\x97\x76\x95\xf1\xc2\xfe\x96\xfb\x38\xf3\x94\x45\xbf\x06\x92\x0d\xbc\x54\xae\x12\x9c\x87\x42\x60\xa6\x6a\x9b\x54\xf6\x37\x4b\xb3\x4c\xb7\xc4\x33\xf6\x87\x8c\x52\xf7\x6e\xb5\x09\xcd\xb2\x6d\xfd\x32\x40\x02\xe9\x37\x4a\xba\xe3\xb3\xb0\xcb\x65\x01\x34\xa5\xa5\x59\xe6\x9b\xd2\xca\x2c\xa7\x29\x2a\x15\xe9\x18\x64\x62\x0c\x44\x40\x5f\xad\xb9\x7f\xea\xb9\x96\x7f\x05\x1b\x3c\xd5\xf2\x33\xb1\x07\x62\xfc\xd1\xf6\xde\x96\x2d\x12\x42\xa1\x6e\xfa\x6f\xb6\xf0\xfd\xd7\xdc\x07\xb2\x73\x0a\x2b\x82\x16\x7a\xf2\x67\x07\xc1\xbc\x5d\x60\x37\x08\x11\xc5\x6c\x88\x28\x7c\x03\x0c\xb1\x0a\x6a\xea\xbd\xef\x5a\x0f\x9b\x5f\xc7\xd7\x85\x1d\xf2\xcf\x8f\xc0\x56\xc7\x23\xdb\xb1\xa5\xc8\x0a\x3e\xff\xfc\xc7\xbf\x31\x9c\x03\x11\x31\x00\x0c\xa4\x3f\x93\xe3\xb2\x2a\x10\x0b\x41\x00\x7c\xc4\x3b\x62\xf8\x4b\x79\x51\x66\xc6\x71\x2b\x2c\x6a\xbc\xe2\x26\x28\xbc\x54\x0c\xb6\x38\xbe\x68\x86\x44\x78\x71\x3c\xcc\xc4\x74\xa2\xc9\xa8\x46\x00\x06\x24\x06\x01\xfc\x92\x45\xaf\x79\xee\xc1\x9b\x07\xbf\x18\xbb\xe5\x03\x4f\xc8\x1f\x23\x0c\x25\x81\x11\x1a\x54\x06\x49\xb9\x7a\x88\x9c\x57\x05\x8f\x79\xed\x31\xc6\x0b\x5a\x1f\x1a\x1c\x84\xa1\xeb\xc3\x7c\x15\xe8\x10\x14\x1e\xda\xd6\x19\xd2\xac\x61\xdd\x20\xa1\x45\xc1\x52\xb8\x89\xd8\x83\x3a\x3b\x19\x8b\xa7\x11\x73\xe2\x32\xe3\xeb\xe4\x36\xf1\x22\xc1\xb8\x6f\x5f\xcb\x03\x5d\xf9\x4e\x96\x33\xc0\xc3\x9d\xf6\xfb\x2f\x53\x8d\x7c\x9d\xdd\xed\xc0\xbb\xd5\xae\x52\xb6\x0a\x9f\xe7\xf5\xf3\x5e\x38\xcf\x00\xc3\x39\x4a\x7c\x9b\x9c\x9d\xb7\x7c\x17\xda\x10\xfd\x1f\x6d\x79\x1b\x2e\xbf\x94\xd4\xef\xb9\x5c\xef\x60\xa7\xdc\x47\x9b\x54\x04\x9c\xf3\x83\x58\x9e\xbd\xa7\xc5\xa8\x33\xe6\x69\x87\x4e\x26\xc9\xac\x99\x4e\x93\xa4\xad\x6a\x6f\xb5\x09\xe6\xd2\xeb\xaa\xdc\xf3\xf0\x71\x33\x9c\x9f\x2a\xf1\xb0\xa2\xfd\xb2\xaa\x09\x35\x31\x83\xb4\x9f\xc1\xa5\x74\xb3\x0d\xe9\x03\x66\x90\x4e\xad\xbb\xfe\x23\x62\x43\x67\x10\x54\xbc\x8a\x94\x55\x29\x70\x85\xfb\x25\x8e\x0c\xb2\x43\x1a\x0d\x1d\x6c\x5b\x3f\x56\xad\x33\xd6\x71\x07\x6f\x1d\x4c\x33\x32\xc7\xd6\x6d\x52\xf0\xe8\xc2\x79\x5b\xa1\x5f\x90\xa3\xdb\x73\xfb\xac\x17\xc0\xcc\xc3\x5e\x25\x94\xe8\xe0\xd8\x84\x16\x59\xe4\x65\xaf\x7a\x21\x8b\x8e\x46\x20\x9e\x97\xa1\x85\xfc\xb2\x47\x9a\x50\xcf\x19\x97\xc3\xc5\xa4\x3f\x25\x2a\x95\x3c\x25\x5d\x37\xa7\x45\x36\xc9\xb6\x9c\x9e\x39\xf9\x15\xb1\xa9\x2a\xc9\x06\xe9\x06\xc8\x7f\xbd\x0b\xf7\x46\x15\xee\xd5\x11\x28\x1b\xbc\x42\xca\x5c\xff\xbb\xba\xcf\x0c\x16\xc7\x4f\xbc\xfc\xeb\x67\x8c\x5e\x54\x84\x03\x70\x9f\x4b\x73\xd7\xfd\xb0\x3b\xdb\x2a\x5c\x4e\xf8\x33\x39\xcf\xca\xc9\x11\x74\x0e\x84\x47\x84\x28\xd1\x34\x1a\x91\x21\xda\x6c\x11\x5e\xb0\xb1\x37\x8b\x61\xe0\x00\xbc\x79\xbb\x85\x6c\xb2\x5f\x86\xd6\x73\x96\x99\x23\xed\x1f\x18\x85\xb9\xd3\x56\xb5\xa5\x58\x30\x77\x55\x03\x35\x65\x85\x8e\x87\x0a\x2f\xa0\x86\xcc\x2b\x45\xc9\xdf\x0d\xa3\x02\x38\x5e\x19\x30\x5e\x1e\x69\x7a\x41\xf5\x91\xa9\x11\xcd\x19\x69\xc8\xbd\x73\x63\xc7\x49\x90\xfb\x5b\x2f\xe1\x13\x8d\x69\xa6\x52\x5c\x77\xff\x92\x14\x7c\xbf\x94\x17\x99\xb8\x30\x21\x1d\x9c\x0e\x55\x1a\x6d\x5e\xd9\x01\x47\x1f\x05\x5e\xc9\xdb\x9a\xc8\x01\x8a\xbb\x8e\x15\x5c\xc0\x52\x27\xa7\xd9\xcb\xd8\xa0\xf2\x59\x96\xcc\x28\xbd\xca\x42\x67\xd5\x2c\x56\x3d\x41\x13\x30\x69\xd2\xd0\xd5\xb9\xba\x6c\x02\xb5\xfe\xa1\x63\xbc\xca\x02\x4e\x92\x0f\x65\xe2\xd0\x3a\x60\x98\xe6\xc3\x1d\x88\xb4\x40\x9f\x44\x0e\xa0\x4a\xb4\x6f\xbb\x20\x55\x89\xd6\xdd\xfa\x3d\xd8\x95\x9f\x3d\xe6\xa0\xe0\x07\x3c\x8d\x21\x3a\x84\x8a\xaa\x01\x5a\xde\xc6\x86\xb8\xef\x61\xc2\xd9\x63\x0a\x68\xf5\x89\x1d\xce\xd4\xca\x6d\x82\xa5\xf8\x2e\x5f\x15\x08\xa9\xe6\x60\x2d\xd1\x5a\xb3\x6b\x24\x2a\x76\xf9\xfa\x3a\x09\xd3\x3a\x13\x3a\x4b\x04\x35\xce\xe5\x3d\x74\xf7\x41\x10\xc4\x91\x0b\x7a\x47\xae\x79\xcc\x13\xbc\xca\xba\x9a\x35\x92\x75\x73\x23\x97\x50\xf5\xeb\x4e\xd9\xed\xdb\x10\x5b\xda\xf5\xc5\xce\xb1\xaf\x21\xb3\x23\x7f\xb8\xb1\x6d\x4c\x58\x78\xc8\x85\x5f\xae\xbf\xf6\x94\x8e\x19\xae\xa0\x9d\xf1\xa7\x12\x4d\x18\x1a\xd0\x39\x48\xb9\x1a\xdc\x10\x03\x22\x37\x41\xce\x3b\x90\x0b\xd4\x9b\x42\xde\x50\xd5\x6b\xc9\xf8\x8e\x65\x89\x53\xd0\x75\x04\x2f\xb5\xdb\x4e\xb9\x37\x78\x24\x52\x90\x4e\x39\x5f\xd9\x64\x84\x93\x19\x2e\x23\xd4\x39\x07\x06\x51\x4c\x9d\x87\x95\xa0\xd5\xa4\xca\xd5\x99\x52\xfd\x78\x2c\xc4\x4e\x57\xd9\xd6\xf9\xbc\x99\xa0\xcc\x0a\x5a\xad\x80\x83\x99\xea\x3e\x5d\xef\xf3\x46\x76\xda\xb3\xda\xce\x7e\x36\xb7\xb3\x9f\x95\x3b\xbb\x27\xe1\x4d\x3c\x6a\xcb\x31\x17\x45\x6c\x4e\x2f\x1c\xe8\x8e\xde\x51\x3b\x80\x29\xce\x3e\x2e\x54\xc8\x55\xdb\x11\x01\x60\x75\x0f\xe9\xa7\x59\x0e\xa0\x4c\xb2\xc1\x97\x4a\x92\xc1\x53\xaa\x1e\xa5\x49\x40\x8b\x4b\x91\xbb\x43\x4a\x74\x2f\x20\x49\x0e\xd5\x37\x37\xa4\x91\xff\x39\xa5\x19\x6b\xb4\xd7\x02\x59\xb9\x63\xb2\xb6\xf0\x4a\xf0\x80\x5f\x37\x37\x65\x92\x8c\x78\xd9\x0e\x59\xf3\x24\xec\xb6\x74\xa0\x60\x5f\xc3\xde\xb6\x4b\x8d\x59\x89\x76\xee\x0c\x19\xbc\x30\x56\x31\xd0\x6d\x1d\x6d\x77\x66\x6b\xb5\x55\x67\x98\x36\x58\x59\xb7\xcb\x7f\xed\x72\x45\x2f\xee\x31\x60\x0a\xff\x07\x1e\x1f\x24\x09\x9e\x3d\xe4\xb0\x1a\xcf\xd1\xe2\x88\xf4\xe5\xac\x2e\x79\x5a\x19\x2f\x32\xb7\x26\x41\x70\x16\xc1\x61\x08\x01\x1a\x59\x76\x06\x87\x12\x47\x31\xf8\x57\x06\xd8\x23\xdf\x81\x98\xc6\x73\x5a\x49\x88\xbb\x68\x73\xac\xdc\x83\x65\x85\x93\x03\xe3\xf4\xb9\x5d\x57\xe0\x73\x19\x99\xab\xc6\xe2\xf3\x4e\x1f\xa1\x75\xaf\x43\xe2\xf7\x6e\x33\x34\xa0\x93\xa6\x81\x2b\xc0\xfc\xa2\x81\x93\xb0\xaf\xb7\x64\xa7\x0c\x66\xdd\x84\x39\x89\xc1\x84\xfb\xf5\xd6\x9b\x6e\xcd\xda\x0c\xd3\x61\xbe\x98\x8e\x59\xc6\x23\x34\x9a\x0c\xfd\x46\xb9\x88\x2b\x3c\x27\xb5\xd5\xce\xcc\xc7\x61\x8f\x67\x2b\x36\x5f\x70\x3c\x0f\x41\x6a\x1c\xdc\x67\x3e\x82\x33\x7e\x7e\xde\xf1\x1a\x6a\x4a\x62\xd7\x97\xc8\x1c\xe6\xfa\x98\xc0\x10\xf8\x05\x09\xcc\xdf\x01\x85\xba\xa0\xa1\xed\x0b\xf9\x05\xf2\x76\xc9\x17\x77\x67\x08\x4a\x35\x1f\xe6\xdf\xeb\x02\xdf\x4b\x3c\xf9\x30\x3f\xd3\x09\x67\x5f\xce\xbd\xe8\x74\x5c\xaf\x20\xfd\x52\xa0\xc9\x3d\x3d\x1c\xc9\x5d\x30\x4a\x71\x19\xda\x66\x5a\xe5\x88\x4f\x97\x33\xbd\x44\x05\x84\xe5\xf3\x08\xee\xac\xb2\xc8\x7d\xce\x01\x4a\xeb\xc4\x2f\xa0\x32\xfc\x68\x7e\xb8\x4c\x34\x1b\x92\x96\x75\xe7\xf6\x8a\x66\x0d\x1d\x98\x5a\xcf\x9a\xbb\x6e\x50\x3d\x43\xfa\xfa\xba\x69\x46\xe0\x6e\xcc\x74\x2b\x4b\x06\x6a\x70\x69\xc8\xb3\xad\x73\xa5\xc9\xd5\x40\x73\x42\xe8\xe1\xe1\x43\x81\x1e\x1d\x4b\x05\xce\x2c\x2f\xcf\x83\xb8\x7b\x8f\x50\xfe\xcf\xb0\xf0\x79\x18\x9b\xc6\xcd\x33\xa1\x1e\x55\xdb\xdc\x70\x77\x2e\x1c\xc6\xc7\xfb\x1a\x08\xc4\x8e\x4b\x96\x2b\x04\xd0\xe5\x52\xc3\x58\x08\xe5\xe7\xae\xdb\x72\xe1\x54\xa3\xe7\xf9\xdd\x98\x73\xb2\xa4\xf9\xd9\x32\x6f\x70\x81\xbb\x3b\x86\xd1\xb6\x5d\xad\x8a\x4d\x79\x7d\x44\x37\x09\x53\xa7\xf7\x61\xf7\x2d\xb5\x3c\x55\xf1\x6f\x86\x74\x42\xfa\xac\xb8\x62\x2c\x25\xc5\x95\x90\x79\x39\x22\x30\xea\x5f\xfb\x7d\xec\x2b\x3b\x42\xe2\x29\x70\xc0\xa8\x1d\x6e\x05\x25\x73\xa5\xa9\x6f\x89\xfe\x46\x6a\x95\xbf\x57\x70\x4c\xaf\x95\xa2\xbf\x25\xf6\x3b\x94\x1d\xd3\x6b\x3e\x9e\x8e\x0d\x8e\x3e\xcd\x54\xe1\xd0\x4f\x65\x89\xca\x85\xda\xed\xce\x41\xda\xea\xbf\x3c\x07\xe9\x1c\x98\x83\x5e\xd8\x39\xa8\x4f\xb3\xb7\x74\xa2\xe6\x8b\x17\x1d\xfc\xa9\x65\xa6\x4f\x33\xf5\x42\x66\x16\x00\x39\xc9\x16\x58\x71\xdb\x82\x61\x82\x3b\x99\xbd\xf8\x3e\xb7\xd3\x24\x82\xe9\x04\x33\x8d\x05\x00\x4e\x89\x60\x02\x3b\x3b\x57\x13\x98\x85\xd1\x48\x9c\x3e\xd0\xf5\xd8\xa4\x5d\xdf\xb1\x9f\x2e\xeb\x78\xf7\xd3\x67\x80\xbf\x90\x6e\xcb\xdf\x65\x9a\x29\x8f\x26\xaf\x34\xeb\xee\x7f\x3a\xda\xd7\x4a\xd1\xf3\x44\x0a\x5a\x51\xf5\x80\x61\x67\x5b\xce\x37\x45\xa6\x2e\xa6\xea\xce\x6a\x36\x37\xc9\x95\x7f\x79\xc2\x73\x3d\xdc\x49\xce\x8a\x02\xd7\x3b\xd3\x9c\x65\xaa\x79\xba\xd5\x52\xc3\x69\x40\xc9\xe0\xa7\x15\x19\xee\x34\x3b\xcd\xd9\x9b\x69\x02\x61\xb2\x6d\x88\x1d\xb8\x18\x99\x26\x89\xe5\xb9\x91\x86\x4d\x98\xac\xed\x5c\x3b\x1d\xbb\x2c\xaf\xda\xc2\x06\xf7\x26\xae\xd6\x20\x4f\xd5\xde\x4b\x53\x7c\x73\xa3\x67\x8a\xdb\xb6\x09\x41\x27\xeb\x78\xba\x87\x3d\xb8\x21\x7b\xf0\x89\xd3\x5f\xce\xed\x8a\x84\xfb\xd5\x92\xea\xc4\xc9\x9f\x8e\xc9\x46\x3d\x02\x4d\x95\x23\x02\x5b\x61\xb0\xba\x00\xb7\x9c\xae\x5c\x06\xfd\xea\x86\xe5\xb7\x2c\x75\xc3\x9b\xba\xe0\x4f\xf6\xc8\x56\xe7\xe7\x5d\x87\x3c\x3c\x73\x7d\xe2\x42\x79\xd7\x33\x92\xd7\xf8\xbc\x46\x6e\x26\x0d\x19\x1b\xb2\x30\x1e\xde\xfe\xfa\xab\xa6\xfa\x52\x05\x91\x96\x2b\x38\x55\x68\x47\x17\xde\x70\xda\xd9\x86\x7e\xdb\x21\x5b\xe4\xd6\x5c\x9f\x28\x51\xbc\x5f\x87\xc2\x0a\x91\x5d\x7d\x62\x18\xfb\x78\xfe\x0d\x52\xab\x4d\xce\x9c\xad\x1c\xcc\x83\x28\x04\xfe\xb6\x76\xa2\x34\xdc\x8e\x37\xff\xea\xe6\xc8\xf6\x75\x54\x9b\x9e\xe2\x2f\x50\xb5\x4f\xdd\xf6\xb9\x53\x2a\xb4\x54\xf7\xcc\x4b\xaf\x37\x76\x7c\x21\x74\xa6\x73\xf5\x79\x6e\xd7\x2c\x8a\xaf\xd8\xda\x33\xfc\x70\xdc\x74\x9f\x77\x34\xd9\xde\x2a\x07\xf1\x9b\x69\x1d\xde\xf7\xfb\x49\x15\x6b\x9e\x10\x42\x87\x6a\xad\x5f\xd5\x11\x45\x97\x5a\x6e\x28\xe6\x02\x5b\x1d\x76\x42\x13\x6e\x5b\x55\xe1\xf4\x6e\xfd\x11\x8a\xd8\xe6\x1e\x72\xc0\x52\xd8\x08\xe6\xaa\x35\xa7\x3b\x2d\x55\x6a\x50\x33\x3e\x9d\x11\xb1\x4d\x9e\x18\x92\x36\x6a\x06\x3d\xf9\x65\xcf\x1d\xb1\xd5\x63\xdf\x0e\xbc\x8c\x0f\x79\x6a\xb6\x76\xf7\xad\xac\xe5\x2a\x4d\x88\x24\xed\xe2\x73\xee\xa5\x88\x5f\xd3\xaf\xbf\x06\x8a\x08\x14\x2e\xd2\xe0\x4e\x88\x52\xcb\x3b\xbf\x5f\x12\x7d\xfb\xe9\x55\xd4\x76\xca\x80\x43\x0c\x27\x6f\x99\xe1\x5f\x3a\x8f\xfc\x8b\x35\x40\xcf\x8c\x7e\x9f\x9f\x4f\x3d\xce\x3f\x21\xbc\x04\xb1\x01\xed\x03\xad\x59\x56\x11\xf9\x5d\x1a\xe0\xbf\xdc\x78\xbe\x5b\x17\x3d\x68\xb4\xcf\xb9\x7f\xa9\x7a\x20\xef\x2e\x55\xab\xf2\x9b\xd8\x6d\x6d\xdc\xa9\xb6\x89\x3a\xbb\xc2\x03\xa4\x57\xe2\xfa\x1e\xde\xf3\xae\xd4\x2d\x0b\xe6\x5e\xb9\x17\x2c\x23\x7d\xb5\xa2\xce\x13\xbd\x5b\x95\x31\xcd\x86\xdc\xa2\xc5\x9f\xc1\x45\x8a\xbe\xc1\xc1\x3a\x36\x48\x13\xa1\x3a\x09\x1b\x14\xb0\x4a\x69\x39\x89\x18\x31\x1a\x52\x77\x3d\x2c\xe6\x86\x47\xd1\x63\x8b\x14\x62\x52\x42\xd3\x17\x45\x21\xc6\x55\x78\xf4\xfd\x56\x70\xad\xf5\xd5\x71\xbd\x68\x2f\x69\x80\xb1\x3b\x9a\xbf\x4e\x73\x76\xdc\x1f\x6d\x8f\xc4\x1d\x9f\x60\xeb\xc9\x28\x65\x57\xc7\x5a\xbb\x63\xcf\x39\x97\xea\x86\x12\x77\x41\xd9\x17\xd7\xe6\x5a\xe5\x95\xb8\x46\x57\x4d\x76\x61\x42\x13\x8c\xf3\xe1\x94\xee\x40\x9a\x73\x72\xca\x32\x08\xe4\xbc\x5f\x01\xea\xe5\xd9\x22\x09\x9d\xa1\xb7\x22\x17\x16\x13\xf5\x51\x89\x24\xb9\xa9\xe1\xf6\xf6\x48\x43\xa3\x6a\xc0\xe9\xaf\x93\x31\x12\x19\xff\x87\x48\x0b\x99\xb5\xbe\x1e\x92\x03\xd7\x3c\xe0\x6d\xad\x01\xfe\xb2\xef\x3f\xe7\x55\x98\xaf\xa8\x51\x71\x06\x9c\x70\x63\x70\xba\xfc\xf7\x8e\x7f\xf5\x30\x0a\xcd\x43\x65\x1e\xf2\xd3\x96\x55\x68\xa5\x22\xec\x8b\x6b\x1c\x29\x28\x66\xad\x72\xe8\xdf\x66\x1d\x2b\x02\x2e\x59\xf6\xad\xaf\xeb\x5e\xfd\xa6\xbc\xf1\xfa\xe1\xc1\x3c\xf2\x05\xc9\xe1\x95\x5f\x8d\xe6\x99\x1a\xc0\x01\xd3\x02\xa7\xf7\x1a\x87\x77\x43\x5d\xf6\x07\x52\x6d\xb6\x66\xf2\x95\xd9\x1a\xaa\x79\x63\xd3\x48\xaf\x79\x7e\x3a\x9b\xb0\x4a\xfd\xe8\xdc\x82\xe9\x54\xa3\xcf\x98\x53\xef\x12\xe7\x7d\x23\x73\x2f\xbc\x9f\x24\xf7\xbe\x15\xae\x31\x65\xaf\xba\x17\xae\x30\xa2\x52\xf0\x70\x21\xed\x99\x91\x41\x34\x7a\x3c\x17\xf1\x80\x14\x0f\x4c\xbe\x1e\xfb\x77\x1a\x96\xce\x33\x8e\xd5\xc8\x96\xb7\xaf\xb5\x7d\xf7\x12\x2d\xa7\x77\x4c\x77\x9a\xa3\x52\xa7\x1a\xbd\xec\xbb\xb5\x56\x75\xb6\x13\xe5\x52\x43\xff\x08\x16\x19\x97\x36\xac\x83\x05\x09\x6e\x5d\xab\x58\x6a\xf8\x53\xc9\x4b\xe5\x59\xca\x5c\x49\xb9\x0c\xbd\x87\xb9\xa4\x12\x46\x99\xf4\xfb\x5d\x56\x93\x46\xe8\xb7\x5a\x5e\x90\x71\xca\x53\x5d\x76\x49\x4b\x4a\x5b\xbf\xec\x8b\x39\x1e\x87\xab\x5f\x4d\xfa\x18\xe6\x49\x7e\xf5\x03\x53\xbf\xfc\x39\xd9\x21\x67\xf6\x77\xdb\xe1\xce\xb9\xdb\x6e\xe8\x96\xd7\xda\x74\x12\x3c\x4e\x97\x78\x2e\x37\x75\x30\xbe\xf6\xb3\xac\x4d\x2e\xc2\xb3\x73\x40\x71\x27\xdf\x2f\x5c\x8e\xab\xf5\x87\xb8\x62\xa6\xa0\xe9\x80\xb3\xad\x73\xb2\x81\xdb\x0c\xda\xcf\x97\x35\x6b\xb5\x44\x81\x09\xa1\xf9\x25\xb1\xef\x38\xbf\x03\x92\xa6\x93\x49\x15\x49\x5d\xa9\xab\xbf\x19\x49\xdd\x12\x49\xe1\x5d\x8a\xb1\x39\x6d\x5a\x9e\xb5\x89\xdb\x2f\x67\x5b\xe7\x8e\xf1\x69\xd3\xb6\x23\x00\xeb\x9e\xb7\x4c\xff\xcb\x85\xf8\x51\x3a\xe0\x29\x2f\x66\x6d\xb2\xa1\xbf\x3a\xfb\x91\x52\xf5\x8e\xb8\x9c\x6d\x9d\xb7\xf5\x55\x84\x5f\xb9\x0b\xd4\xb5\x40\xb6\xea\x39\x15\xd7\x84\x7a\x81\x63\xa7\x0a\x27\x54\xee\x7c\x57\x95\xef\xcc\x77\xf9\xdc\x09\x0f\x2d\x74\xed\x2d\x97\xaf\xda\x78\xd9\x90\x68\x89\xd9\x15\xf5\xee\x5f\x65\xd0\x6b\xf4\xbb\x6e\xda\xfa\xba\x6e\x65\x75\xcc\x1d\x9d\xb9\xa8\xce\x2d\x09\x87\x11\x06\x05\x1a\x88\x85\x11\x03\x9d\xfd\x10\x81\x98\xfb\xdc\x01\x5e\x2d\xe8\x37\x46\xd0\x06\x31\x40\x2b\x17\x86\xd6\x97\xab\x7c\x0c\x61\x8a\xe3\x3d\xac\x2e\xce\xd3\xbc\xa0\x69\xc4\x72\x5d\xf7\x7d\x1f\x40\xe8\x98\x3a\x64\x83\xa8\x05\xeb\x3e\xa4\x9a\xf8\x2f\x1b\x44\x1f\x61\x41\xce\xb7\x78\x30\xa1\xfe\x50\xd0\xab\xde\x4b\x94\x1c\xb2\xd5\x2c\x40\x4b\x70\xfe\xc0\xac\x7d\x41\xb1\xf8\xb0\x0c\x8c\x91\xb6\x6b\xac\x91\x5c\xfb\x4c\x07\xba\xb4\xff\xaf\xb1\x5a\xda\xb6\x6b\x16\xbb\xab\x29\x3d\x4b\x80\xa1\xa6\xde\xf4\x84\xc3\x65\x51\xbd\x01\x2b\xc2\x39\x2f\x4f\x8c\x7a\x09\x79\xe7\x1e\xea\xcd\xf1\xa8\xb9\x08\x9a\xdb\x05\x9e\x5e\x6c\x6e\x06\xb7\xb1\x76\x38\x2a\xf9\xc5\xd7\x3c\x7f\x13\x3d\x73\x69\x82\xa4\xe3\xc1\xc2\xe6\xa6\x31\xf5\x9e\xa6\x92\x4a\xb9\x15\x14\x03\x3b\x0a\x55\xeb\x96\x6a\x5b\xb5\x2d\x0b\x9e\xe5\xcd\x33\x61\x51\xb6\x04\x05\x1d\xe2\x12\xcf\x8f\x0d\x46\x88\x97\x61\xae\x8a\x02\xfb\x01\x3c\xf8\xd3\x60\x15\xb7\xf0\xa5\xa3\x39\x7b\x74\x67\x03\x6f\xfa\x5e\x11\xfd\xf0\x9b\x7e\x9e\xda\xfb\x87\x93\xaf\xaa\x63\xce\x19\x89\x86\xc7\xcc\x6b\x89\xeb\x8e\x03\x03\xaf\xc0\xac\xb2\x40\x24\x1b\xce\xa3\x0a\x78\x9a\x0e\x13\x56\x59\x26\xa3\x31\xaf\xac\x42\x66\x4c\x73\x28\x63\x26\xa7\xd0\x48\xc1\x71\xe2\x28\xe5\x67\x98\xf1\x78\xad\x3c\x8b\xc0\xeb\x05\x9c\x0a\xe0\x1b\x4f\x51\xc0\xca\x31\x38\xc7\x3c\x55\x93\xc6\x98\xa7\x7c\x3c\x4d\x9d\x58\x9f\x35\x25\xe8\xb5\x2e\x01\x66\x06\x15\x25\x2a\xd5\xbf\x43\xf9\x9a\x9d\x01\x4a\x4e\x29\x03\xcd\x5f\xca\xc7\xf7\x1d\x6d\x49\x2e\x5c\x17\x58\x25\x3f\xa2\xf9\x7b\xd8\x7e\xe0\x25\xb5\x39\x67\xa5\xf9\x7b\x7a\xed\xdf\x5d\x9b\x87\x71\xb9\x79\x8e\x33\xc7\xf4\xd7\x1e\xa7\x3b\x4f\x4a\x64\x8f\x8d\x79\x6a\xc7\x8b\xa9\xde\x0f\x92\x37\xaf\xb8\xa6\xde\x23\xd3\x2d\xee\x0e\x9f\x10\x45\xa0\x59\x1f\x61\xfd\x5e\x50\x47\x75\x2a\x2f\xc9\x74\xe3\x0e\x3f\xc2\xba\x2a\x41\xe9\x75\x69\xb1\x84\xf9\x95\xcf\x56\x50\xba\x64\xcf\xa7\xe5\xd7\x96\xda\x94\x11\x72\x40\x60\x4a\x8b\xa9\x72\x31\xbb\xe4\xe0\x39\x88\x43\xb0\xde\xa0\x19\x73\x6a\xe6\x29\x8e\x80\xea\xf2\xfb\x49\xa2\x42\xd3\x05\xc4\x26\x09\x24\x4c\x04\x4f\x8b\x5c\x61\xae\x5c\xb7\x80\x73\x43\x77\xc1\xe2\xb8\x31\x0d\x04\xd5\xc9\x69\xe2\xba\x0b\x1b\xd0\x46\x42\x9c\xb8\x91\x32\xb7\x15\x3e\x24\x80\x7b\xb3\x88\x26\xf0\xd8\xff\x9a\xe7\x1d\xf8\xa1\x73\x62\x1d\x82\xd2\x6c\xb1\x01\x26\x48\xd6\x12\x8f\x93\x2c\x82\xc8\xef\x46\xe4\xed\xed\xbc\x62\xee\xcd\x8d\xa6\x4e\xf9\xac\x57\x5a\x4d\xcd\x4a\xa0\xa3\x80\x10\xb0\xac\xc1\x43\x59\xa5\xb6\x3a\x46\x77\x3d\x0a\xd4\xdd\xcb\xb0\x48\x13\x6f\xff\x77\xac\xe1\x88\xd5\x4c\xbe\xa1\x08\xc9\x47\x62\x9a\xc4\x44\xa4\xc9\x8c\xd0\xc1\x80\x45\xae\x9c\xd1\xf8\x0b\x85\xd8\xbe\x85\x40\x99\x4a\x78\xca\x4c\x9c\x48\x68\xd0\xfa\x3a\x69\x62\xbb\xa1\xc4\xcd\x0d\xd2\x9a\xf2\x08\x9e\xec\xe5\xe1\xdb\xe8\xf9\xc0\xf3\xdf\x03\x98\x2e\xb3\x8f\x5f\xc2\x7e\x7a\x19\xa6\x98\xb3\x34\x85\x4b\xdd\x2a\x86\x3b\x65\x3b\x07\xdb\xf1\xbe\x83\x95\x35\xdd\x2a\x5b\xe4\xa9\x3e\x41\x76\xce\x1f\xec\x6b\x02\x9b\xea\xdb\x58\xe8\x49\xba\x64\xc5\x2d\x59\x09\x4c\x70\xa7\x5d\xd3\xe5\x4a\x2e\xe4\x0c\x89\xcd\x09\xb8\x59\x0d\x54\xc5\x45\x1d\x0b\x37\x5c\x9d\xcd\x6b\x38\xb2\xec\xae\x86\x02\xde\x1d\xfc\x58\xaa\xf9\x28\xbc\x28\x12\xeb\xeb\xe4\x91\x33\x7c\x0d\x99\x0e\x8c\x95\x20\x88\xb3\x7d\x87\xcc\xe8\x66\xd6\x36\xcf\x76\xa8\xdf\xbe\xd0\x48\xa6\x4c\xfb\xe6\xa6\xd4\x95\xd8\x09\x72\x36\xb1\xa2\x17\x93\x82\x5d\x17\x6d\x92\x33\xe8\x4d\x5c\x4f\xe7\xa0\x4a\xc1\x03\x65\x21\xc8\x90\xa5\x2c\x93\xf3\x12\xd0\xb2\x16\x34\x14\x97\xa3\xcd\xca\xb6\x05\x3d\x19\xf4\xe3\xdd\xcd\x5c\xf3\x3a\xf3\xce\x01\x84\x0b\xd2\x73\x12\xf4\x7b\x55\xaf\x57\xf4\xf9\xad\xfb\xf4\x57\xcd\x65\xca\x4b\x34\xe8\x99\x91\xf2\x12\xed\xcd\x63\xda\xd7\x82\x09\x41\xae\x7c\x49\x93\xa3\xb4\x60\x59\x0a\x41\x1e\xf8\xa5\x64\x9e\x2a\x5e\x53\x7a\x42\x33\xeb\x88\x9a\x10\xfd\xc5\xf0\x33\xd7\x0e\x38\xe5\xb4\x86\xc0\xc4\xbc\x88\xa8\xc1\x09\xfb\x4d\x83\xf2\x0e\x9c\x00\x1c\xa0\xd4\xfd\x65\x51\x06\x7f\x38\x6f\x03\x8b\x62\xa7\x81\x9b\x2a\xae\x51\xd9\xc3\xb6\xf7\x6a\xba\x22\xbf\xe9\x73\xb1\xed\xf3\xa5\xed\x35\xc9\xb9\x49\x9a\xe6\x85\x18\xf3\x7f\x30\xd3\xda\x52\x38\xef\xe5\x1d\x67\x78\x55\x9a\x07\xa7\x15\x35\xba\x80\xc1\x4b\xbb\xe5\x6b\xf7\xda\x3f\xb7\x7a\x0f\x72\x55\x4e\x43\xbc\xde\x80\xe3\x82\x52\xd5\xb5\xe1\x95\x69\x36\xec\xb6\x09\xcd\x86\xdb\xf0\xff\x33\xf8\xff\xb9\xbf\xbf\x5c\x19\x69\xee\xd6\xd4\xcf\xaa\xa3\xc3\x6e\x46\x57\x42\x4f\x99\x2f\x2e\x49\xa5\xdc\xbb\xa9\x22\x55\x81\xa6\xc3\xb3\xc9\x8f\x34\xcb\x95\x81\x3a\xac\x0f\x0d\xf7\xab\x3c\x9c\x98\x35\x37\x4e\x03\xde\x28\x16\x93\xda\x62\xf6\x91\x38\x1c\x4c\x9e\xea\xd3\x44\x38\xc0\x74\x1e\x51\x88\x81\x73\x72\x79\x97\xea\x38\xf5\x48\xe6\xc2\x9e\xfc\x59\xdf\xf8\xa5\x83\x77\x48\x55\x0b\x68\x43\x8b\x55\x03\xe5\x25\x72\xdd\xa2\xd7\xbc\x4f\xd6\x66\x17\x90\xa3\x0e\x0f\x54\x9e\xdd\x7e\xfb\x4b\xda\x5d\x6f\x2d\xa0\xf6\xf3\xd3\x42\x34\xdc\x1d\xe1\x7d\xb7\xf4\x15\x8b\x00\x40\x3f\xef\x69\x84\xeb\xc4\xef\xec\x31\x7c\x79\x45\xd3\xf8\xf1\x79\xb3\xd5\x06\x1b\x32\x60\xd7\x29\xbc\x1c\x6c\xc8\xf5\x76\xc3\x2c\x0c\x9c\x37\xc0\x8b\x10\x6a\xd7\xef\x2b\xa2\xf3\x1d\x4f\x19\xcd\xaa\x29\x4d\x20\xcf\xd2\x5a\x75\x06\xea\xed\x41\xac\x54\xca\x05\xbe\xf9\x65\x1f\xf1\xc8\xda\x0e\x64\xb2\x7a\xca\x03\x6a\xac\x0c\xb6\x9f\x31\xea\x82\x95\x1d\xd6\x2c\xd7\xd8\x8f\x72\x27\x59\xdd\x56\xd8\x64\x56\x75\x4b\x45\x53\xff\x62\x11\xf1\x8e\x17\xbe\x71\x2f\x2f\x34\x53\xce\xf1\xf3\xdc\x6c\xe1\x60\x6c\xb9\x07\xf5\xea\xa1\x6f\x03\x72\x1a\xe4\xa9\x5a\xae\xe2\x3b\xa4\xad\x36\xe9\xb6\x3a\x85\xf8\x6d\x32\x61\xd9\x01\xcd\x59\xb3\x15\x40\x74\x03\x53\x01\x63\x8b\x8f\x8c\x98\x43\xa8\xc7\x09\x13\xad\x6f\x19\x91\x69\x35\xcd\x8e\x26\xe0\xdf\xbd\x6a\x7f\x89\xbc\x30\xf2\x56\x3d\xb5\x2c\x3f\xf5\x21\xef\xc9\x4b\x2b\x26\xa8\x1a\x6f\xc9\xce\xb7\x1c\x32\xea\xca\xf6\xf0\xe3\x09\xd9\x23\x5d\xb6\xf1\x5c\xc5\xb6\x2c\x05\x3a\xf1\x16\x9d\xa5\x5c\x4d\xbe\x7f\x1d\x44\xf6\x82\xed\x8d\x3d\x4b\x53\x00\x37\x37\x0a\x54\x9b\xac\xfe\xb2\x67\xbd\xc5\x20\x4f\x03\x27\x10\x12\xa9\x57\xc4\xbc\xa0\xa1\xe9\x90\x99\x1a\xe1\x57\xd3\x58\x30\x8e\x81\x18\x7b\x31\x21\x73\xf1\x5e\x1c\xbe\x75\xcf\x5b\x64\x43\x32\xc1\xc0\xc3\x41\xa1\xbd\xa9\xa8\x80\x7f\xea\xc2\x0f\x78\x06\x8f\x9b\x70\x07\x16\xeb\x7b\x77\x6b\xc1\x49\xcb\xd9\xca\x4c\xdc\x71\x9b\x85\x58\x7e\x01\x6a\x6f\x6e\x14\xd2\x5f\x81\x18\x38\xe1\x76\x33\xe1\xd7\xaf\xee\x09\xa7\xc7\xea\xb3\xd8\xde\xfd\x07\xf5\xe9\x4b\x14\x7d\x37\x50\x8a\x2c\xe3\x76\x75\x29\xb3\xd9\xb7\xef\xce\xd4\x56\xc2\x39\x79\x73\x32\xe7\xf9\xf3\xa8\xbe\x4f\x71\x0a\xcf\xbd\x55\x51\x4f\x46\x35\x2c\xf8\x10\x02\xcf\x08\x7b\x7b\x2e\x41\x4e\xe5\x01\xb4\x7d\x9e\x41\xaa\x2c\xf8\xf4\xf2\x10\xb8\x13\x46\xbf\x71\x99\x13\xe6\x35\x95\x23\xcd\xd8\x39\xba\x99\x2b\xed\x8f\xf6\xf6\xd0\xe3\xd2\xa3\xd5\x18\x49\x5a\xc1\x5b\x3d\xd2\xee\x79\x78\xb4\x77\xe9\xf9\x84\xac\x18\x66\x65\x19\xec\xda\x21\x11\x0c\xb1\x1a\xd8\xf0\x79\x1c\x3a\x9d\x03\xb0\x4b\x65\x93\x73\x6e\x9c\xc9\xac\xa6\xbd\xba\x06\xe0\xa1\xfe\x81\x03\xcf\x32\x40\x5d\x6c\x12\xb8\xa2\xf0\x36\x8a\x2b\xa5\xa2\xeb\x52\xd1\x3d\xf7\x07\xbc\xb9\x3f\xc5\xa7\x20\x1e\x15\x96\xc2\xaa\x22\x5b\x73\x8a\x74\xab\xdb\xda\x0d\xdb\x5a\xf9\xec\x97\xb0\x3c\xe1\x69\x41\x52\xb1\x01\x3b\x9f\x8d\x8c\xa1\xc3\xde\x1d\xb2\xa5\xf7\x26\x4e\x80\xa8\x3d\x77\xaf\xa5\x53\x9b\x39\xcb\x38\x73\xbc\xbc\xc1\x3c\x02\x69\xc1\x6b\xce\xd4\x7b\xc1\x13\x4c\x17\xe1\xf3\xfe\xb1\xc1\x72\xb6\x75\xee\x3d\xee\x1f\xef\x92\xa7\x4f\xbf\xb8\xcb\x1e\x54\x10\x97\xcc\x3e\x04\x42\x33\xf8\x21\xb5\xa9\x15\x17\xc3\xa8\xae\x52\x89\x2e\x78\x16\xa3\x7d\x44\xf2\xfc\x03\xfd\xa0\x1a\x78\xc6\xcf\xcf\xbe\x9c\x43\x17\xbf\x24\x5e\x12\x98\xbe\x05\x40\xde\xd3\x13\x44\xf7\xab\xf7\x7c\x89\x94\x70\xec\x99\x76\xec\x56\xc3\x74\x5d\x18\xf2\xd4\x0e\x68\xfc\x73\xb8\x50\x22\x46\x6d\xb0\xdd\x57\x60\xd5\x24\x68\xa6\xcd\x23\xc1\x30\xb6\x44\x82\xc3\xf2\x3a\x12\x1c\x1d\xae\x75\xf6\xc9\xa9\x1c\x76\xc7\x6f\xde\x9c\x1c\x9e\xf6\xde\xef\x7f\x54\xd1\xd9\x51\x0e\xad\xa0\x61\x70\xf3\x09\x4d\xe3\x79\x2b\x2b\xcf\x15\xfb\xd9\x63\x01\x63\x15\x1e\xf0\xa0\x9d\xf7\x21\x60\x90\x83\x56\xe2\x4b\x45\x3a\x77\x9d\x16\x60\x9b\x84\xd8\x3e\x88\x94\x69\x5c\x39\x4f\x46\x62\xca\x8a\xe2\x3e\x18\xff\x0c\x31\x9e\x18\x2c\x1a\xef\x15\x1f\x0e\xe7\xaf\x26\x03\x9c\x59\x88\xf3\x0f\xc0\x20\xf1\xb9\x46\xee\x6e\x3c\x37\xff\xea\xce\xc9\x51\xe6\x2c\xe8\xd0\x02\x8d\x8a\xb0\x47\x02\x33\x3f\x34\x77\x31\xde\x3f\x8e\x16\x33\xf6\x73\x6c\xe0\x1d\x9b\x65\xfb\x92\x05\x70\x2d\x64\x03\xef\x73\x20\xb5\x1c\x40\xf5\xdc\x42\x77\x22\x9a\xcc\x56\x07\x04\xd7\x21\x2e\x46\xbf\xaf\x3e\x79\x4f\xcb\x56\xb7\xb1\xf2\x4d\xbb\xa5\xad\x0e\x45\x16\xcf\x77\x84\xea\x53\x96\x3b\x7d\x23\x4b\x6a\x01\x6a\xa9\x87\xb1\xcd\x70\x30\x9c\x59\x76\xab\x09\x56\xdf\x44\x48\x1c\xd0\xa2\xd6\x6e\xa9\x5b\xfd\x88\x79\x55\xdd\xeb\x43\xa8\x6e\xee\x29\xbb\x31\xcf\x6b\x4b\xdb\x71\x70\xe2\xf6\xbe\xdc\xa7\x5c\xb2\x2c\x67\x27\xa6\x35\xee\x1a\x4a\x12\x36\x67\x4d\x09\xf1\xa0\x65\x71\x9e\x0e\x95\x89\x5f\x21\xf4\x15\x67\xc6\xd2\x18\xae\xb8\xe5\xff\x4d\xa9\xb5\x13\x3a\x63\x72\x03\xdc\x5a\xb3\xbe\xb5\xa4\xb4\x95\x48\x20\x2f\x55\x2b\x3a\x2a\xab\xd9\x22\x3b\x2a\xc9\xac\x4f\x7c\x37\x3d\x1a\xbc\xc6\xb4\x68\x8e\x35\xdc\xb3\x1a\x6b\x38\xe5\xff\xc5\xb7\x71\x7b\xd6\x51\xc9\x16\xae\xec\x46\xeb\x99\xe7\x47\x4b\x72\x52\xfe\xae\x7a\x87\xaf\x4c\x87\xbc\x47\xaf\x54\x77\xb7\x25\xca\xf7\xc0\x73\xee\xbc\x36\x87\xb3\x73\x60\x02\xf0\x11\x96\x0d\x88\x00\x63\xf5\x93\x11\xcd\x81\xaf\x3b\xe8\x66\xa0\xed\xb2\x6d\x87\x7c\xbd\x35\x4f\xd0\x57\xe9\x5f\x5c\xf1\xa8\xe5\x4f\xc8\xb0\x4f\xd0\xb4\x3a\x94\xbb\xce\x84\xb4\x23\x1f\xa4\xde\xce\x49\x6e\xfb\x77\xea\x45\x7b\xc7\x13\x73\xf5\x20\xef\xec\xdc\x5e\x8d\xea\x1b\x3c\x43\x0a\x7a\x02\x42\x3b\x11\x10\x12\xfb\xe2\xdc\xa1\x50\x73\x31\xb4\x17\xbb\xb3\x15\x7b\x4e\x55\xde\x61\xd9\xd7\x3b\x30\xdc\xbf\x2b\xd0\x91\x24\xfa\x19\x3f\x8a\xb1\x23\x1a\x3d\x45\x49\xaf\xd1\x3a\x57\x53\xf2\x2a\x38\x2a\x3f\xcf\x83\x0b\x67\xff\xc5\x8f\xfb\x1c\xcc\xb8\x53\xac\x7a\x32\xa7\x30\x3b\x7c\x68\x69\xf7\xd6\x5f\x6f\x3d\x65\x59\xe7\xfa\xaa\x7e\xd4\x23\x72\x77\xdc\x0f\x95\xf8\xb9\xac\xa6\x9e\x37\x22\x39\x0e\x86\x5e\xa7\x5b\x29\x1e\x86\xdd\x14\x78\xba\x2a\xe5\x57\xd3\xa6\xa7\xe2\x38\x7c\x2d\x32\x24\x7b\xe5\x3a\x8c\x30\x95\x9f\x3e\x84\x5c\xae\x66\xb1\xd6\x58\xfe\x03\xe7\x79\xfd\xef\xc0\xd5\x48\x82\x03\xa1\x64\x62\x58\xf6\xa9\x95\xdb\x25\xc8\x4e\xf5\x92\x44\x17\x72\xd7\x23\x06\x81\xf1\xf3\x68\x85\x61\x05\x82\x36\x2c\x8b\x98\x73\x6f\x3e\xf4\x6c\xe6\x0b\x65\x29\x55\x67\x8a\x68\x6c\xaf\xea\xae\x9e\xd0\x82\xbd\xd2\x7d\x7f\x60\x95\x15\xfb\x66\xe4\x35\x01\x70\xab\x7c\x77\x7b\x10\xda\x90\xb0\x30\x2b\xbb\xb9\x06\xca\x73\xdd\xb6\xa3\xe3\xef\x1a\xaf\xed\x98\x79\x1e\x6e\x4d\x21\xd9\xe3\xe8\x81\x32\x8f\x5b\xf0\xb6\xcf\xfa\x1c\x04\xc8\xd3\x52\x99\x2a\x58\x31\x29\x72\x52\x63\x8c\x17\xf2\xdb\x5e\x26\xc2\x28\x48\x92\x0a\x4b\xb8\xd2\xe9\x6b\x90\x85\x47\xaf\x6d\xa8\xd7\xae\x9f\xbd\x13\x5f\xb2\x07\xb9\x1d\x2f\x31\xb8\xd6\x03\x00\xf7\x5a\xcf\x18\xdc\x98\x4c\x9d\x60\xcc\x3f\x94\x3f\x05\x73\x30\x06\x60\x7e\xaa\xb9\x08\x4c\x12\x71\xf5\x9a\x45\x7c\x4c\x93\x5c\x83\x7a\x89\x76\x2d\xe5\x90\xed\x37\xe3\xe6\x06\xcb\x29\xcb\x3d\xf7\x0a\xd1\xb1\x93\x9b\x16\xc2\x9a\xd5\xd9\x74\x75\x59\x32\x6f\x09\x09\xe2\x69\x9a\xed\x19\xec\x39\x0f\x06\x82\x66\xaf\xaf\x5b\xcf\x12\xe6\xc1\x95\x73\xa3\x09\x54\xfb\xf9\x5d\x37\xbf\x55\x6b\xa0\x8f\x03\x5b\x3d\x93\x51\x36\xfa\xca\x22\x99\x5c\x8d\x18\xda\x5c\xc2\x2d\x34\xcf\x09\x2d\x59\xf1\xcf\x3d\x87\xd7\x00\xb2\x8e\xdf\xb5\x9d\xee\x9d\xf3\x7c\x39\x74\xda\xd9\xe3\x21\x2b\x3e\x28\x7b\x3e\x44\xf4\xd8\x9c\x19\xb6\xad\x10\xb5\x7d\x09\xd0\x2b\x1b\x8f\xac\x39\x5a\x04\x31\x2b\x55\x12\x5e\x2a\x11\x63\x4f\xb8\xe3\xb6\x27\xbc\x15\x9b\xdf\xb3\xde\x82\xfc\x4e\xb6\xf5\x56\xc2\x37\xcb\xb3\x37\xfc\x5a\x87\x05\x96\xec\xeb\x2d\xca\xbf\x2a\x16\xf4\x4a\x3c\xa8\x3d\xdc\xae\x89\xf2\x1d\x5a\x88\x57\x80\x80\xcb\xb9\x1f\xac\xbe\xa1\x68\xaf\x0b\xa9\x70\xcb\xef\xaa\x11\x9b\x83\x33\x82\xca\x0a\x9c\xcb\xfd\x50\x72\x2e\x87\x01\x25\x74\x6e\xd9\x1c\xcd\x64\x29\xb7\xff\xae\x79\xe5\x9c\xcb\x5f\x77\x7a\x38\x83\xa2\xe7\xe4\xa5\xf7\xd3\x8f\x6c\xe0\xb8\x3d\xdb\x26\x3b\x65\xcf\xe4\x77\x06\x80\x41\x53\x62\xf5\x5c\xc8\x5d\x45\x2e\xf7\x78\xf0\x52\x3f\x4d\xb5\x36\x1a\x3a\x6d\xe7\xee\x0e\x0e\x2e\x78\xaa\x21\xa0\x7b\x7f\xac\xec\xde\x1f\x6b\xbb\xf7\x47\xbf\x7b\x8d\x2d\x34\xe6\xf9\xd6\x88\x41\xdf\xff\x38\xb7\xef\x7f\xac\xef\xfb\x1f\xbf\x71\xdf\xab\x46\xb8\xbd\xbe\x44\xa7\xeb\x5f\xa8\xfe\xb1\x9e\x6f\x2b\x08\x1b\xbe\xd4\x96\x1a\xe2\x08\x88\x1f\xe8\xbe\xe4\x65\xd2\xcd\x04\xb1\xf8\xc9\x39\x99\xb7\x2b\x75\xd5\x1f\x3f\x75\x9c\x34\x33\xa5\x1b\x7d\xea\x64\x76\x6a\xae\x86\x5d\x90\xb9\x5a\x7a\xd1\xcb\xa6\x7b\x5e\x37\x21\x15\x12\xf9\x2f\x2a\xe8\x8b\x2c\xfa\x6b\xe0\x2a\x0c\x7a\xad\xe4\x20\x50\x42\xfe\x52\x01\xa8\xae\x5a\xc2\xfd\x42\xc5\x75\x8a\xa1\xcb\x76\x51\xcc\x0a\x16\x15\x26\xde\xa4\x8a\x4b\x92\x97\xaf\x23\xe7\x02\x3a\xae\x3a\xf4\xe4\xa2\x77\x21\xe5\x47\xd6\x72\xad\xf4\x4f\x71\x15\x32\x2f\x9e\x67\x5d\x1c\x09\x14\xb0\xe2\x9f\x42\xef\x9c\x58\xa7\xf3\xc8\x55\xaf\x9b\x25\xc9\xc0\x6a\x13\x22\x41\x14\xb9\x01\xa2\x19\xa3\xff\x94\x46\xcd\x8b\x73\x3a\xaf\x55\x3c\xc6\x67\xb8\xc6\xee\xed\x29\x69\x1c\xc5\x8d\x5d\x57\x63\xfa\x10\x20\xe7\xda\x82\xc2\xdd\x49\xa0\x88\x5a\xcf\x27\x8a\x5f\xc1\x7b\x78\xbf\x8c\x01\xaa\x7f\xd3\x99\xf8\x86\xb3\x2c\x51\x47\x9a\x40\x39\x2e\xca\xd5\x89\xe7\xfa\x3a\xd1\xb9\x1d\x9a\x5c\xd1\x59\x7e\x32\x12\x57\xab\x73\x67\x64\xaa\xd6\x5c\x39\x6f\x85\x07\x30\x7a\x86\x29\x83\xce\xf3\x3b\xe1\xbc\xb9\xbd\x54\x0e\x4a\xaa\x1e\xdc\x62\xde\x79\x8d\x17\x38\xef\x34\xb8\xed\xf2\x39\x78\xc8\x22\x45\xb4\xda\x01\x4d\x57\xc7\x00\x95\x3d\xfe\x94\x34\xba\x8d\x5d\x37\x7b\x3b\xc8\xde\x6e\xe8\x1b\x55\xaf\x4f\xb1\x82\xbf\x55\x87\xca\xb6\x9f\xaf\xd0\xf1\x95\x8b\x78\xbb\x46\x4a\xba\xae\x98\x00\x01\xbb\x65\xa0\xed\x00\x68\xfb\x5e\x72\xd4\x55\x9f\xdb\xf3\x04\xca\x02\x3d\x44\xb2\xb4\x11\xbc\xcd\x2b\xdf\x47\xe1\xc9\x1d\xfa\x2b\xa8\xbf\x6c\xc4\xfc\x26\xbe\xd7\x2f\x85\x3e\xb8\xb4\x61\x02\xc2\xf8\x55\x90\x88\x97\x26\xdf\xf2\x2e\xa2\xee\x14\x38\x38\x65\x35\xc7\xc0\x52\xaa\x86\xce\x4d\x41\xe8\x5f\x52\x5f\x64\x1d\x39\x71\xf1\x54\x56\xb5\xc9\x55\x19\x59\xdd\x43\x76\xf7\x30\x1a\xe0\x21\x8c\xee\xde\x1e\x29\xfb\xab\x74\x29\xe0\xbb\x4e\x86\x17\xda\xcd\x71\xac\xe9\x8b\x88\x2d\x0e\x76\xc6\x2f\xdd\x53\x68\xec\xd6\x33\x03\x72\xee\xac\xcc\xef\xb2\xe4\x72\x9c\x2b\x9c\xf0\x74\x58\x3a\x54\xf3\x33\x9b\xf6\xbe\xf1\xfe\x7e\xae\xe6\x1e\x65\xea\x67\xc6\x30\xe3\x9f\x99\x71\x66\x9d\x9f\x3d\x4c\x61\xd4\x1d\x92\x56\x56\xdb\x5d\x5d\xb5\xe7\xda\xef\x40\x8d\xdf\x86\xaa\x6e\xf0\x2e\x2f\x2a\xfb\xc2\x42\xb8\xd7\x2c\x30\x98\xb3\x02\x44\x40\xb6\x2c\x3e\xb2\x2f\xe4\x96\xbe\xa0\x09\xee\x41\xee\x1e\x9b\xc4\x0d\x35\x62\xec\x1e\x4a\xd2\xba\xbb\x56\x71\x1c\x67\xb3\x17\xf7\xae\xad\x9c\x7f\x06\x72\xaa\x3c\xca\x82\xbd\x75\x15\x57\xc8\x53\xd2\x6d\xcd\xf1\x14\x95\x81\x41\x54\x9b\xe4\x65\xef\x1c\xa0\xd8\xf3\xc5\xdc\x72\x54\xca\xbd\xbb\xcd\xaa\xf4\x40\x15\xd7\x3a\x9f\xaa\xad\x2a\x30\x02\x51\xe1\x68\xfd\x81\xa7\xcd\x05\xf7\xf6\x88\x2e\x48\x6e\x6e\xdc\x64\x83\x90\xbc\x24\x5b\x64\xc7\x75\x9d\xe1\xc8\xea\xfb\xa3\x0f\xbd\xdf\xf7\xdf\xfd\x76\xd8\xfb\x74\xf8\x96\xec\x91\xcd\xff\x27\x95\xc0\x7b\x9e\x9e\xfd\x67\x7e\xfe\x64\x03\xfe\x6f\x9e\x6d\x6d\xfc\x7c\xfe\xb4\x79\xd6\x39\xff\xda\xbd\xc5\x1f\xad\xaf\x5b\xed\xee\x6d\xeb\xfb\x4d\xb4\xa6\x7e\xbf\xff\x7f\xab\xd0\xd0\x6b\x40\xf0\x9f\x4f\x17\xc1\xe3\x3c\xeb\xd1\x2f\x0e\xcb\x3b\xc0\xaa\xfc\x66\xee\xff\x46\x57\x32\xfa\x3b\x9e\x2a\xca\xa9\xf2\x92\x65\x83\x44\x5c\x39\x16\x17\x4b\xba\x4f\x0b\xea\xab\x0a\x96\xad\x67\x75\xe7\x10\xcd\x0c\x0d\x15\x46\x6e\xb9\x69\xb7\x6a\x01\x15\xd0\x23\x25\x50\x93\x14\xdb\xf3\xfa\x32\x27\xc8\x4b\x52\x2e\x4a\x76\xec\x89\x43\x39\xd7\xe5\xad\x36\xff\x76\x4e\xa0\x3d\x71\xea\x14\x2c\x2f\xe6\x11\xe7\xee\x01\x9e\xfa\x45\xd9\x35\x8b\xaa\x8a\x5a\x3b\x41\xb7\x65\x1e\x4d\x64\xc3\xb1\xdb\x5d\xc5\xe3\xca\x05\xd9\x5b\x06\x6b\xd6\xf2\xaa\x5c\xda\x03\xdd\x7d\x58\x18\xfa\x45\x64\xa4\x5b\x6a\x44\x77\x51\x19\xe9\x5a\x19\xa1\xd7\x15\x88\x3d\x19\xe9\x96\x65\xc4\xd5\x15\xd5\x32\xd2\xf5\x65\xa4\x67\x85\xc4\x2b\x5b\x29\x24\xdd\x0a\x21\xe9\x06\x1c\x06\x27\x8a\xbd\x6f\x2b\x25\x35\x0c\x2e\x83\x35\x6b\xb9\x55\x2e\xed\x81\x56\x9f\xac\x59\xdd\xae\xa3\x65\xdb\x93\xef\xa3\xf4\x93\x7a\x43\x62\x14\x6a\x2d\x90\x17\x95\xda\x79\xfc\x82\x41\xd6\xec\x6f\xbb\x9b\xd1\x81\x55\x6c\x84\xb5\x79\x0f\x56\xf4\x83\x12\xfd\xf2\x24\x78\x48\x82\xc9\xf0\xbf\xeb\xec\xdd\x9c\xc4\xe4\xbf\x2b\xc2\x21\x5e\x39\xbc\x2a\xd9\xc3\xb2\x2f\xbd\x60\xce\x3a\xb7\x14\x39\x1a\x60\x77\x02\x58\x48\x2c\x81\x02\x06\xf7\x30\xdb\xd6\xee\x5f\xbe\x97\x63\x41\xb9\xb1\x8f\x6c\xf4\xa6\x8a\xd7\xb6\xf8\xd6\xd6\xbe\xb1\xad\xb6\x74\xd0\x4e\x65\x42\xe7\x4c\x55\x57\xef\xda\xd9\x12\x06\xfb\x70\x03\x2e\xe1\xb1\x79\xa5\x0b\x1a\x3f\x53\x3d\xa2\x75\x62\x92\xeb\x1b\x08\xe3\xcf\x03\xcd\x05\xbc\x5f\xd6\x6b\x4b\x95\x6f\x8f\x92\x63\x97\x92\xe3\x10\xb8\xbd\xd4\xbe\x33\xdc\x40\xe7\xb2\x87\xb6\x5d\xc5\x00\xd6\x8e\x2c\xd6\xd6\x1a\xf5\x83\x77\x4b\x0f\xde\x5c\x64\xc5\x2b\x7f\x36\x57\x36\x1c\x76\xc1\x25\x4a\xa7\xdb\x22\xf0\x99\x64\xc3\x0b\x80\x2b\x78\x7b\xd3\xa3\xd7\x5c\x55\xc6\xf3\x5d\xbd\x25\x75\xa9\xbe\x63\x4f\x8a\x6e\x0b\xb2\xa0\xd0\x19\xf7\x1c\xe7\xaa\x60\x2d\x3e\x84\x1a\x2d\xe5\xcb\x28\x33\xb9\x37\xa3\x69\xe6\x5e\x05\x19\x3f\xfd\x10\x66\x26\xcc\xb0\x81\x49\x2a\x0d\x83\x6c\x05\xee\x8a\x14\x57\x9e\x3a\x2f\xd4\x57\x5b\x66\xf0\x3c\xd9\x24\xb7\xad\xf6\xda\xe6\x13\xb2\xfd\x4c\x4a\x2a\x26\x99\x35\x70\x73\x2c\xe2\x69\xc2\xda\x84\x5d\x4f\x44\x86\x46\x20\xca\x77\x44\x06\xde\x71\x21\xbb\xa3\x72\x21\x1e\x10\x98\xc9\x8a\x74\x87\x34\xb6\x3b\x2f\x3a\x5d\x78\x09\xa8\x6d\x73\xc4\x80\xf4\x7a\x92\x52\xe7\xd2\x05\x12\x00\xdf\x2e\xd9\xdc\x54\x8f\x3c\x36\x62\x9e\xd3\x7e\xc2\x36\x12\x9e\x32\x92\x8a\x0d\x08\xe3\xb5\x16\x92\xfc\x7c\x01\x92\xdb\xa4\xd7\xbb\x62\xfd\x09\x8d\x2e\x7a\x19\xfb\x73\xca\x33\xd6\xeb\x41\x3b\x1e\x4f\x73\x46\xf2\x22\xe3\x51\xf1\x78\x57\xe2\x53\x32\x4c\x7e\xdf\xff\x44\x8e\x3e\xfc\xfb\xe1\xc1\xe9\xd1\xf1\x07\xf2\x64\xd3\xe2\x9e\x64\x22\x62\x39\xb2\x41\xed\x02\x03\x13\x2c\x53\xeb\xe3\x5e\x8f\xe5\xef\x81\x96\xc7\x6d\x75\x26\x04\x5e\x52\x8a\x6c\xca\xd6\xc0\xe2\x0f\x6f\xfb\x81\x2f\xdb\x30\x88\x4a\x74\x36\xbb\xdd\x1f\x03\xc8\x67\x60\x83\x9b\x16\x2c\x13\x93\x4f\x08\xf7\x5a\x8d\x28\x8d\xcb\x94\x50\xce\xba\xab\x10\x3f\x7b\xe6\x41\x6d\xcf\xc1\x2a\xf3\x25\xb0\x6a\x5a\x27\xa2\x13\x5e\xd0\x84\xff\x83\xbd\x91\xea\xf9\x1d\x2b\x0a\xf4\xaf\x51\x95\xbe\x6b\x8b\x89\xb4\x50\x7e\x3c\xf5\x57\x9b\x39\xe0\x7a\x4b\xb9\x47\xcc\x77\x3f\x5b\xe5\x38\x08\x33\x26\xa7\xcf\x11\xe5\x29\x8b\xf5\xca\x40\x62\xaf\x4a\xd7\x8d\xbd\xa2\x59\xca\xd3\x61\x1d\xbb\x9f\xb7\x02\xc0\x79\x8c\x51\x20\xb2\x88\xd1\x61\x35\xb0\xa2\xff\xa5\x45\xbe\x1a\xad\xd6\xff\x02\xd6\x3e\xfd\x2f\x1d\x2b\x25\xe4\x25\xa4\xef\x90\xaf\x26\x96\x3d\x24\xdc\xee\xca\xb1\xeb\xd8\xc3\x55\x70\xb9\x99\x83\x21\x1e\xaa\x2f\x25\xa4\x1d\x96\x5e\x76\x3e\x1c\xbf\x3e\xec\x1d\x7e\xf8\x1d\xec\x94\x1e\x4f\x32\x11\x4f\x01\xcd\x63\xf2\x92\x34\xb7\xda\xb6\x99\x1d\x55\x67\x4b\x0f\x54\xc4\x88\x37\xa4\xf8\xbd\xd1\x26\x8d\xf7\xb4\x00\x3f\x44\x1b\xbf\x1d\xed\xdc\x41\x0a\xbb\x9e\xb0\xa8\xc8\x09\xd5\xa8\x68\x36\x9c\x8e\x59\x5a\x74\x1a\x2d\xb2\xe3\xfa\x7f\x31\x8f\x04\x24\x58\x27\x1a\xd1\x6c\xbf\x68\x6e\x55\x3c\xff\x46\x00\xfb\xfe\xfb\x56\x6a\x0c\x72\xc5\xe8\x85\xcb\x20\x25\x5c\x92\xe7\xe0\xf8\x3a\xf6\x0e\x6f\xa0\xd5\x20\xf2\xb6\xc9\x00\xd4\x61\x97\x2c\x9b\x39\xdb\xff\xf2\x1b\x0b\xd9\x61\x23\x9a\x1f\x5f\xa5\x66\xbc\x03\x10\xf6\xe5\xd9\x85\xbe\x17\x90\xf8\xe0\x97\xd9\xf4\x3b\xf4\x19\xf1\x6e\xd2\x2c\x73\x09\x54\x33\x8a\x0e\x6c\xad\xfa\x41\xa6\x60\x2f\x98\x50\x86\x0d\xf2\xd2\xfb\xb5\x83\x8d\x52\xfa\x21\x68\xd6\x6e\xe9\x4d\x2c\x4e\x79\x34\xcb\x9c\x29\xf0\xe9\x9e\x8d\x12\x25\xb5\xb5\xa5\x43\xd6\xac\x69\x07\x1b\xb5\x47\x8f\x64\xa6\x24\xfe\x8c\x9f\xb7\x09\x6f\x4b\x54\x2d\x00\x84\xa0\x59\xe1\x14\xce\xc3\x9b\x6c\x1f\xb7\x00\x35\x8a\x8e\x22\x74\xcf\x69\xdc\xd0\x80\xbb\x11\x9e\x39\x02\xaa\xe6\x95\x36\x69\xf4\xd1\x97\x60\xe3\xdc\x78\x90\xd0\x15\xb7\x60\x34\x6c\x74\x4b\x98\x25\x4f\x5c\x60\x2f\x0e\x87\x81\xda\xe8\x96\x3b\xb4\xaa\x2f\x79\xa8\xcf\x1c\xa0\x5d\x67\x49\x8b\xe7\xd1\x64\xa3\x4b\x5e\x12\x68\xb9\x3e\x7d\x36\x5d\x0c\xf5\xa9\xa5\xee\x09\x1d\x80\x07\x6a\x70\xe9\xe4\x18\x8b\xca\xbc\x3f\x78\x92\xa0\xfb\x3d\xd4\x81\x84\x92\x94\x5d\x39\xee\x58\x07\x24\x65\x2c\x66\x71\x5b\x42\x8b\x62\xc4\xb2\x2b\x9e\x33\x72\x25\xcb\x4d\x68\x9e\x93\x3e\x8d\x2e\x08\xbb\xe6\x79\x21\x47\xac\x2e\x88\x6e\x16\xa7\x49\xd2\x51\x15\x69\xc3\xd4\x81\xf1\x1e\x63\x41\x0b\x81\xe4\x39\x4b\xe2\xdc\x42\xde\x48\x34\xb7\xb0\x2a\xb6\x23\xb6\x4a\x61\x37\x91\x91\x46\x74\x7b\xb8\x84\xd3\x4a\x44\xaf\xdf\x70\xf9\x28\x27\x15\x0c\xff\x25\xc1\x5a\x38\xc2\x51\xd6\xe1\xdb\x2f\x50\x1c\x7f\xd8\x55\x1e\x94\x3c\xeb\xe1\xb0\xb5\x98\x31\xa5\x74\x65\x24\x81\xcb\x7e\xdb\xe5\xb7\x0a\x0f\x4b\xe4\xd1\x9e\x35\xeb\xa9\x38\x18\xa6\x51\x84\x94\xeb\xb2\xab\x51\xda\x50\xb5\x3f\x64\x43\xa5\xcd\x53\xd8\x78\x92\x7d\xd5\x5c\x82\xcf\xa3\xc6\xd3\xbc\x40\xd1\x99\x64\xe2\x92\xc7\xd6\x10\x39\x6f\x5b\x41\x6c\x1b\x41\x08\x75\x78\xd9\xbf\x54\x54\xd9\x9f\xde\xe2\x5c\x76\xca\x76\x65\xa7\xd2\x6c\xe8\xf7\xe9\xb6\xea\xd4\x6d\xdb\xab\xdb\xaa\x5b\xb7\xd5\x4f\xff\x4a\x49\x62\x80\x9e\xdc\x2e\x77\xee\xf6\x79\xc9\xb9\x14\x8d\x22\x75\xa5\x51\x8c\xe4\xce\x4b\x16\x37\x66\xf9\xb2\x4d\x75\xb9\xb7\xea\x44\xd9\xf6\x6d\x4b\x59\xdb\xcf\x5b\x52\xde\x76\x22\x9a\x24\xcd\x79\x6b\xd4\xe6\xb3\x56\xab\x15\xae\x78\x5f\xac\x70\xc5\xbb\xb2\x25\xec\xc9\xe5\xf0\x28\x82\xa5\x57\x55\x33\x5e\xfc\x00\x8b\xaa\x3b\xea\x6a\x28\x51\x6e\x60\x45\x0c\x4c\xb5\xe4\x16\x00\x6b\x6b\xaf\x11\xb9\x49\xde\xf1\xb6\xcc\xcd\x60\xe0\xd5\xad\xd3\x14\x7d\x2d\x3d\x5c\x94\x8f\x8a\xbf\x64\xdd\xe6\x77\xdf\x0f\xf3\xba\xcf\x32\x4f\x71\xa5\xd7\xbb\xc7\xe6\x65\x44\xb3\xb1\x48\x67\x4a\x08\x48\x93\x8f\xc7\xd3\x42\x32\xb0\x45\x9e\x6c\x56\xe1\x3e\x7b\x4c\x1f\xe3\x0b\xe9\x2b\xf0\x85\x78\x49\x13\xbc\x52\x28\xb6\x30\x95\xbc\xa6\x85\xb2\x99\x2c\xba\x4e\x92\xcb\x36\xa7\x70\x73\x90\x08\x91\x71\xfd\xc6\x85\xb7\x49\x84\xd6\xc5\x03\xce\xd0\x6f\xc6\x1a\x71\xa6\x22\x5d\x2a\xa6\x45\xe9\x3c\x0b\x10\x35\xd5\x19\x93\xae\xb6\xf9\x14\x40\x5b\x70\xc8\x69\xb7\xb4\x1a\x51\x07\x4a\x91\x3d\x93\xb0\xeb\xe5\x46\x8c\x27\xce\x89\xcb\x3d\xaa\x85\xdf\x1b\xa4\x2b\x6b\x56\x4d\x83\xb4\x36\xe9\xb6\xda\x6e\x21\x97\x32\xbf\xf2\x4c\x4c\xbd\xc0\x85\x5e\xed\x70\x43\xb1\xe5\x10\xae\x90\x19\x4d\x16\x77\x9d\x4c\x68\x08\x42\xec\x06\x57\x1f\x92\xca\x78\x8b\xfc\x22\x0b\x6c\x60\xc2\x4b\x99\xb0\x43\xe2\x6e\x05\x51\xc6\x86\xd6\xa3\xaa\x4d\xf2\x82\x4d\xc2\x75\xaf\xd3\xec\x72\x8f\x60\x11\xb9\xab\x4f\x31\xf6\x6d\x57\x9f\x52\x03\x73\x9a\x80\x70\x0e\x73\x82\x83\x51\xbc\x69\x94\x48\xc5\xc4\xa7\xc6\x3d\xd9\xd4\x61\xf1\x01\xb8\xc4\x1f\x48\xd5\xd1\x9d\x81\xb8\x45\x68\xdc\x35\x2b\xca\x47\x88\x81\xfc\x02\x54\xa0\xc7\x13\x80\x81\x40\xcc\xc6\xff\x33\x10\x03\xc7\x16\x34\xc9\x85\x72\xb0\x99\x93\x23\x35\xc5\x4a\x1e\xa9\x83\x64\x04\xc5\xe7\x97\x96\x7d\x48\x66\x6b\x97\x5c\x8d\x78\xc2\x48\x53\xf3\xd9\x70\x80\x4d\xac\x88\x21\xb0\xba\x9e\xd6\x94\x79\x37\x93\x40\x4d\x99\xc1\x2a\xca\x87\xc3\xe1\x82\xe5\xe1\xb5\xa6\x37\x90\xab\xc4\x54\xc5\x91\x51\xc7\xb5\x98\xa3\xc8\xf6\xc7\xc0\x23\xb8\x58\xc0\xb1\x0a\x70\x9d\x9c\x15\xa7\x7c\xec\x8c\x24\x6b\xa3\x53\x2f\x7a\x55\xf5\xf9\x06\x23\xd0\x1f\x60\x12\xab\xe8\x78\xfa\x14\x93\x02\xdf\x15\x24\x64\x2f\x56\xb6\xd1\x0d\x89\xfd\x7a\x3b\xe7\x04\x8a\x8d\x27\xc5\xcc\xda\x97\xe0\x3d\x81\x42\xbc\xb1\x81\xb2\xb1\x58\xc5\x4f\x1f\x54\xb1\x67\xd8\xa2\x3c\x08\x9b\x5b\x4d\xd0\xb8\x66\x1f\x67\x86\x84\x7a\x6a\x15\x8e\x30\x96\x3a\x2f\x33\x8b\x2d\xd3\x4f\x4f\xb5\xa8\x15\x5d\x9b\x26\x81\xcd\x7a\x08\x3b\xbc\xd8\xb2\xd2\x59\x74\x4d\xae\x92\x28\x67\x74\x01\x01\xcd\x62\x4b\x62\x6c\xd9\x75\x93\x4f\x25\x6c\xbf\x7d\x2a\x5d\x69\x50\xc3\xb8\x7a\xcc\x5a\x63\x77\x9e\xbf\xe1\x29\x2f\x98\x2a\xed\x0f\x5c\xf2\x52\xbd\x84\x33\x7f\x3b\x36\xbb\x2b\xb3\x35\x35\x1e\x48\x30\x92\x9a\x30\xa1\x39\x10\xf2\xef\xa5\x23\xcb\xce\x8a\x01\x40\x65\xca\xbf\x68\x05\x04\xcb\xd7\xdb\xa0\xf4\x4e\x75\x69\xbf\x07\xe5\xd2\xbf\x8c\xc9\x5b\x86\xba\x37\x25\x66\x1a\xbc\x2d\x9d\x9b\xfe\xf8\xa0\x55\x24\xdc\x66\x24\xa2\x4f\x93\xba\xb3\xc5\x1f\x5a\xbb\xee\x29\x71\x15\xcc\xf6\x33\x0d\x53\x5c\xd7\x2d\x1c\x7f\x56\x20\xda\xf3\x40\x15\xcc\x96\x82\xf9\xf8\xe9\xf8\xf4\xf8\xf4\x3f\x3e\x1e\x92\x3d\xd2\x98\x64\xa2\x10\x72\x4b\xd4\x50\x4b\xd4\xef\xd5\xaa\xc8\xb9\x72\x69\x62\xb0\x9b\x94\x8e\xa5\xe2\x11\xd3\x2c\x72\x8c\xd4\x8f\x4e\x7a\x6f\x8e\x3f\x1d\x1c\xbe\x56\xe7\x30\x64\x5d\xa3\xe8\xbc\xd9\xb5\x30\x6f\xdf\x1d\xbf\xda\x7f\x57\x86\x79\xeb\xc0\x9c\x9c\xee\x9f\x1e\x1d\x94\x61\x4e\x1c\x18\x20\xbe\x0c\xf2\xd1\x01\x79\x75\xf4\xa1\x82\x98\x57\x0e\xc4\x1f\x9f\xc0\x1b\x4d\x00\xf1\x87\xb1\x0b\x37\x67\xf4\x96\xf0\x97\xd8\x43\x3b\xf0\x61\x5d\x21\x36\x9d\x9f\x7b\xfa\x41\xb2\xc2\xf1\x51\xb2\x96\xec\x69\x74\x67\x86\xef\xe6\x82\xb0\xa0\xd9\x10\xd6\x15\x6e\x3d\x4a\x5e\x76\x1c\x8e\xe8\x44\x55\xd1\x0e\x69\x7a\xbf\x21\xac\x6f\xab\x02\x3f\xb8\x34\x11\x57\x69\x9b\x40\xf0\x5d\x54\x7c\xa6\xae\x96\xea\x4b\xb9\x4c\xa1\x63\x66\x4e\xbf\x2e\xd8\x8c\xf0\xd4\xeb\x68\x78\x16\x69\x4e\xa5\x79\x4a\x52\xf0\x07\x04\x39\xe2\x4a\x6e\x67\x1e\x59\x39\x58\x5f\xd7\x0d\x33\xdf\xf0\xbc\x4f\xee\xd1\x9d\x83\x1a\x3d\x39\x49\x04\xeb\xeb\x44\x55\x6b\xae\x4f\x64\x75\x3c\xd5\x6e\x88\xa4\xd2\x47\xc1\xc4\xaa\xe5\xee\x7a\x42\xf3\x9c\xa1\x76\x41\xd7\xb7\x12\xd3\x4b\xaf\xca\x1d\xd5\x0c\x73\xc4\x08\x98\x26\x19\xbb\x94\xfb\x79\xc5\xea\x89\x48\x92\x29\x9e\x4f\x09\x74\xb6\x99\x4f\x68\xc4\xf0\xfd\xa6\xee\x3d\x75\xf4\x61\x7b\x4a\x3d\x5f\x14\x83\xa0\x8d\xee\x19\xe0\x4b\xb7\x7a\x5d\x7b\x9f\xa7\x31\x29\xf8\x98\x65\x70\x02\xa4\x88\x90\x55\xcb\x8d\x2e\x19\x64\x62\xac\xdb\x2a\x79\xc0\xae\xd1\xa7\xfb\x8e\x91\x6d\xb9\xaf\x82\x96\x46\xc5\x75\x13\x62\x04\x21\x8e\x96\xae\xe1\x2a\xa3\x13\x8d\x37\x12\x69\x5e\x64\xd3\xe8\xff\x63\xef\xed\xbb\xdb\xb6\x91\xc5\xe1\xbf\x6f\x3e\x05\x9a\x7b\xd7\x92\x12\x59\x7e\x89\x9d\xa4\xf2\xba\x39\x89\x93\x76\xf3\xdc\xa4\xce\x13\xbb\xdb\xdb\xe3\xc7\x3f\x85\x26\x21\x8b\x0d\x45\x6a\x49\x2a\x96\x36\xf6\x77\x7f\x0e\x66\xf0\x32\x00\x41\x4a\x96\xec\xb4\x7b\x7f\xeb\x9e\xd3\x88\x78\x1d\x0c\x06\x83\xc1\x60\x30\x53\x66\x79\x01\x9d\xa8\xc1\x87\x23\x90\x0f\xcb\x11\x1f\x0b\xbc\x27\xf1\x45\x1e\xe4\x73\xd3\x15\x2c\x12\x67\x06\x0f\x0f\x01\xd3\x2f\x18\xd1\xcf\x1c\xd9\x37\x81\x3f\x5a\x9c\x23\xe8\xb2\x8b\x2e\x0b\x5d\x79\xa4\x1c\xc5\x85\x0e\xf9\x96\x0d\xd9\x91\x2d\x0b\x14\x57\x71\x19\x8e\xc0\xed\xf6\xd4\xf7\xe2\x40\xfd\x85\x41\xc1\xd9\x76\x9f\x08\x66\xec\xa8\xdd\x39\xa8\x96\xd9\x71\xca\x04\xbe\x42\xbb\x6e\xa1\x2e\xbb\xb0\xca\xdd\x54\xf3\xc5\xd8\x88\x29\xad\x2a\x70\xe4\xaa\x40\x70\x18\xc6\x79\x81\xfa\xf1\x23\x59\xb5\xec\x90\x1d\x39\x8b\x98\x6c\xd7\x3f\x6a\xea\x1d\x07\x9f\xc5\x79\x36\x28\xe3\x50\x5d\x21\xaa\x99\x95\xbc\x9c\x8d\x79\x39\xca\xa2\x42\x0a\x3e\x82\x46\x3a\x38\xa9\xc8\x3e\x0d\xe9\xa2\xc3\x64\x9b\x64\x05\x55\x29\x55\x14\xe8\x5e\x80\x7d\x88\x06\x24\x17\xa1\xab\x11\xfa\x54\xfd\x81\x42\x33\xcb\x79\xef\x2f\x47\xc7\x3f\x9f\x9c\x7e\xfc\xe5\xe8\xf4\xf8\xe3\x5f\x7a\x32\xb7\xf7\x97\x9f\x5f\xbe\x7f\xf3\x17\xbd\xee\x15\x38\x66\x56\x95\x8e\xa3\xf7\x25\xce\xcb\x69\x90\x00\x87\x75\xd3\x80\xcd\x76\xd4\x7a\xd4\x20\xdd\x16\x28\x8d\x2c\x0a\x16\xf1\x8d\x60\xf6\x85\x8f\xf0\x6a\x41\xf1\xf3\x8d\x0d\xf6\x9d\xfa\x00\x20\x3a\xb0\xe9\xb6\x55\x9a\x74\x24\x25\x30\x46\x55\xe2\x37\x07\x0f\xb6\xb6\x70\xc7\xb9\x88\xcb\x71\x30\x79\xa0\x77\x49\x76\xc8\x76\x0e\x10\xfe\x61\x96\x87\x3c\xd2\x59\x3f\xb1\x43\xb6\x2b\xb3\x70\x39\xeb\xac\x13\x76\xc8\xf6\x64\x16\xd2\x82\xce\x12\x5b\xdb\xf3\x03\xc5\xe9\xb2\x32\xd3\x39\xaf\x44\x57\x4f\x0f\x34\x17\xd2\x19\xbf\xb2\x43\xf6\x64\xf7\x40\x33\x0f\x9d\xf1\x0b\x3b\x64\x4f\xf7\x30\xa3\x08\x86\xfc\x81\x41\xca\x21\xdb\xd9\x7d\x7e\x80\x0e\x9f\x20\x36\x84\xc1\x39\x50\xe3\x27\xc9\x51\x3e\x3d\xa8\x5c\x7d\xcb\x46\x0e\x2a\xd2\xd6\xf3\x3f\xf2\x96\x5a\x11\x1a\xd1\x57\x69\xdf\x3e\xa0\xbc\xc3\xa0\x3d\xbf\x4c\xe4\xd9\xde\xaf\xc1\x7b\xda\xf1\x15\x6f\xba\x1b\xa5\xe5\x48\x65\xb0\x72\x7b\xf3\x8f\x69\xad\xec\xb8\xff\xf4\xb9\xb7\x78\x73\x5f\xa6\x9c\xa9\xcc\xcb\xd7\xc4\xf9\x7d\x8d\x14\xfa\xfc\xfb\x9a\x0a\x8d\xfd\x59\x25\xcd\x8d\x71\x1e\x4c\x16\x77\xf9\x6c\xaf\xae\x42\xe3\x55\xb3\x5d\xf4\x9b\xa8\x2e\xe1\x3e\x72\x9a\xdb\x6e\xfe\xa7\x39\x6f\xbf\x0a\x0a\x7e\xa4\x02\x91\x18\xa1\x79\x94\x85\xec\x10\x2f\x28\x2c\x2a\x31\xb7\x14\x34\x9c\x74\x36\x29\xba\x2c\xe5\xb3\xf2\x83\xf8\xe9\x68\x23\xbe\x93\xad\x90\xf9\xa7\xd7\x9a\x4e\xdd\x03\x3b\x98\x5a\xed\x55\x4a\xcb\x5c\xa5\xb8\x8f\xb6\xb1\x3f\x9b\x02\x4c\x8f\x78\xe9\xe2\xcc\x96\xc9\xb6\xf0\xd1\x65\x2d\x81\xa4\x56\xa7\xd3\x1e\x65\xa1\x83\xab\xca\x43\xa4\x6a\x11\x34\xcd\x51\xcb\x56\xbd\x85\x3c\x04\xcc\x37\xae\xff\x55\xaf\x14\xbe\xff\x23\xd9\x93\xe3\xf7\xfb\xe8\x8d\xd4\xe9\x6f\x3d\x52\xa2\xde\x60\xf0\xf1\xcd\xcb\xa3\xd3\xc1\xeb\x37\x7f\x3f\x3d\x3e\x7e\xa7\x24\xd5\xc1\xdf\x8e\x8f\xff\x7b\x30\x10\xb0\xe3\xac\xa3\x9e\x5a\x19\x19\x35\xd6\x71\x6f\xd3\xaf\xaf\x97\xaf\xdc\x53\x80\x22\x45\x69\x11\xe3\x01\x63\x3e\x67\xb1\x2b\x50\x24\x44\x58\x8b\x0b\x76\x91\x07\x69\x38\x62\x71\xc1\xa6\x69\xce\x83\x70\x14\x5c\x24\x9c\x5d\xf0\x30\x98\x42\x48\x91\xb8\xa0\x71\x36\xe5\xb5\x6f\x90\x24\xf2\xf0\xb0\xb5\x05\x91\x88\x74\xfb\x5d\x76\x31\x2d\x55\x54\xe4\x28\x56\xd5\xc4\x56\x80\x75\xe3\x94\x45\xfc\x0b\x4f\xb2\x09\x18\x69\x18\x58\x78\xce\x87\xe2\x98\x18\x0f\xa1\xba\x81\xab\x28\xe3\x24\x61\x22\xbf\xcb\x22\x1e\x44\x2c\xcc\x22\xce\x78\x12\x8f\xe3\x14\x1d\x13\x5d\x05\x45\xda\x2a\xcd\x09\x25\x9b\xf0\x3c\x99\x33\x21\x47\xc6\x3c\xd2\x7d\xbc\xce\xd2\x16\x95\xdd\xd9\x98\x17\x45\x70\xc9\x7b\x0c\xde\x1e\xb3\xd7\xfc\xcb\x69\x96\x25\x05\xcb\x79\x12\x73\x31\x56\x16\x97\x3d\xf6\x32\x29\x32\x29\x38\x4e\x73\xae\x1a\x03\xcc\xc8\x06\x58\x94\x71\x01\x01\xcb\xc2\x70\x9a\x83\xce\xee\x4a\xc0\x8b\x91\x9c\x09\x06\xe1\x62\x33\x2e\xf1\x26\x1c\x30\xac\x9a\x0b\xd0\xbc\x56\x7b\xac\x45\xa0\xcb\x51\x9e\x5d\x81\xc8\x0c\x01\x7c\xdb\xad\xff\x33\xf8\x3f\x2d\x1d\xa7\xb1\xcc\xe7\x66\x32\xff\xce\xf3\x78\x38\x67\xe5\x28\x50\xe8\x8f\x38\x0b\x2e\xb2\x2f\x1c\x02\x7d\x5d\x70\x9e\x7a\xb0\xc7\x23\xd6\x7e\x7d\xf4\xa6\x15\x75\xb0\xc3\x25\xa9\xb2\xad\x7e\x48\x6b\xe6\x30\x80\x33\x07\xcf\x73\x42\x5e\x1a\x9d\xc8\xa6\x01\xf7\x79\x50\x8c\x10\xdb\x5d\x96\x0a\xac\x82\x51\xd7\xd5\x28\x30\x94\xf0\x2b\x57\x11\xfe\x70\xe2\x73\x0e\x72\x69\x9c\xe2\x49\xe3\x8a\xe3\x23\x3c\x44\xac\x18\x0c\xd6\x14\x67\xb5\x4c\x48\x4a\x80\x28\x01\x89\xbc\x7f\x7b\xf0\xa0\x76\x6d\x1c\x7a\xd7\x86\x00\xfd\xe8\x0d\xb2\x0a\x05\xca\x28\x98\x4c\x78\xca\x2e\x90\x44\x61\x00\xaf\x8f\xdf\xb3\x8b\x69\x1a\x25\x9c\xf1\x19\x0f\xa7\x25\x2f\x58\x91\xc1\x04\x3c\xb0\xc7\x1f\x06\xa9\x1a\xc5\x45\x10\x41\x10\xd5\x61\x1c\x22\xe9\x46\x53\x30\x5a\x8a\xd3\xdf\x39\x1e\x1a\x1e\x30\xc2\xa4\xc4\x10\x2a\x12\xa0\x8f\xe3\xee\x6d\xef\x83\xa1\x92\x36\x2b\x5f\xb2\xd6\xf3\x8e\x34\xfa\xb8\x6b\x7e\xff\x64\x7b\x6d\xe5\x5f\x51\xd6\xeb\xf5\x76\x9e\xee\x76\xda\xad\xab\xcf\x45\x4b\x2a\xe6\xa6\x10\x15\xd6\x6f\xdb\xb8\x2f\xcb\x9c\xcc\xc7\x17\x59\x83\x36\xb1\x87\x05\xb0\xf0\x2f\x27\x6f\x06\x27\xbf\xbd\x7f\x75\xfc\xce\x18\x49\xa9\x06\x28\x47\xb6\x55\x7f\x85\xcf\x5a\xd5\xc8\x23\xa9\x10\xaa\xa8\x99\x18\x8c\x91\xa8\xc4\xe8\xf7\x21\xd0\x35\x81\x63\x63\x43\x42\x40\x2a\x90\xec\x17\x0a\xbe\xbe\xc0\x46\xa7\xdd\xc2\xcf\x5e\x8b\x3d\x06\xc5\x4c\x47\x6e\xfa\x0a\xd4\x9e\x42\x30\xfc\x5b\x39\x50\x3c\xd9\x59\xd6\x52\x57\x59\xc7\x0b\xb2\x2d\x04\xff\xfe\x04\x17\xf8\x9f\x04\xf3\xfe\x94\x4e\x93\xe4\x93\x60\x7b\x9f\xf4\x56\xf8\x49\xdb\xf7\xc8\xd3\x97\xf8\x39\xe6\xe3\x0b\x9e\x1f\x0f\xd9\x00\x73\xe2\x34\xe4\x6c\xaf\xb7\xdd\xdb\x86\x6f\x1d\x04\xfb\x5d\x90\x5e\x52\xdb\xa0\x47\x37\xf2\x89\xd1\xe9\x88\xcb\x5f\x60\x1a\xc4\xc3\xcf\x3d\xdb\x36\xe8\x42\x45\x7d\xfd\x28\x53\x3e\x89\x5d\xe9\x93\x03\xb0\x80\x37\x2e\x46\x5d\x5c\x4a\x9f\x80\x2b\x7f\xc2\x96\xf8\x2c\x18\x4f\x12\x2e\x81\x1f\xf4\xc0\x9d\x0d\xbc\x4d\x15\x0b\xf5\x91\x58\xf3\x87\x3f\xa0\xd5\x82\x5d\x04\x0d\x58\x16\x14\xfa\x39\xf8\x99\x96\x80\x8e\x6d\x03\x26\xd9\x18\xba\xc7\xf9\xea\x04\xdf\x55\x97\x8e\xb0\x9e\x2b\x24\x08\x55\xab\x53\xbc\xbb\xf6\x22\x0d\x52\xb4\xb8\xa8\x59\x55\x4f\x95\xe2\xfc\xed\x9b\xe7\x83\xd7\xc7\xef\x07\xaf\xdf\xfc\xf8\xf6\xe7\x37\xb5\xda\xfa\x67\xb2\x78\x99\x7d\xc8\xe3\xb1\xf2\xdd\xee\x5d\xd6\xfb\x4a\xfd\x1f\x7d\x30\x7e\x43\x6d\xbb\x0f\x22\xe1\x0e\xeb\x96\xfd\xb3\x0e\x7b\xe1\xaf\x4d\xae\x4b\x98\x63\x4f\x72\xdc\x65\x1f\xba\xec\x65\x59\xe6\xf1\x85\x60\xfc\x38\x1d\x0a\x17\xed\x63\x60\xdc\xa0\x26\x37\xe3\x68\x7f\xe8\xa2\xe5\xe2\x01\x2d\x4a\xda\xd0\x4a\x66\x0b\x55\x1d\xb2\xcd\xab\x4b\xf8\x0f\x55\x00\xec\x7d\x58\x9c\xc8\xb6\x1e\x31\xb8\xd3\x63\x62\xbe\x65\xd3\xad\x4b\x5e\xb6\xc4\x56\x6a\x6a\x0a\x2e\xd2\x2a\x2a\xc9\x1d\x29\x7b\x9c\xce\x27\x5c\xca\x1e\x2f\x43\xb1\x83\x66\x79\x01\x41\x96\x8b\xe9\x44\x60\x96\x47\xdf\xb5\x34\xe4\x2d\xa0\xc4\x4a\x4b\xc7\x67\x1f\xce\xd9\x21\x49\xea\xe9\x97\x59\xea\xa9\x33\x72\x26\x87\x3a\x97\x79\x2a\x50\x4f\x9d\x9e\x47\x03\x0f\xe5\x39\xe7\x61\xdf\xbf\x1d\xee\x7d\xdf\x11\xed\xa9\x73\x2b\xda\x04\xb1\xca\x1b\x86\x27\x77\xf9\x20\xe0\x0e\xcc\xa3\x14\x8d\x97\x79\x90\x16\x49\x50\xf2\x93\x72\x0e\x0a\x18\x95\xf1\x32\x8d\xc7\x41\xc9\x95\xb3\x68\x62\x2a\x3f\x8c\x2f\x5f\xf1\x7f\xc6\x70\x6f\x6f\x27\x9f\x4c\xd0\x30\x9b\xde\x3a\xa0\x3e\x41\xb6\x56\x6b\xf1\xbf\xdd\x71\x4a\x36\x69\x1c\x64\x11\x5d\x85\x07\x45\xbd\xdd\xfc\x93\x3d\xf3\x9c\x60\x5a\xc6\x75\x5b\xf9\x0e\x29\xe6\x0c\xdd\x57\xfc\xf9\x93\x3d\x6f\xf1\x25\xc0\x46\x07\xcb\xdf\x42\x4b\x52\x33\x39\x12\x5f\x56\xf2\xc1\x83\x9a\x09\xb6\x0b\x63\xb2\x29\xec\x62\xca\x42\x85\xb1\x69\xab\x25\x36\x98\x11\x27\xf9\xc0\xa3\x61\xd0\x54\x61\xda\x74\x96\x57\xa3\xf5\xe1\xdd\x9a\xaf\x5d\xc4\x69\x04\xcf\x08\x2c\xe3\x35\xdd\x48\x2f\x6a\x7b\xfb\x7b\x18\x3c\x24\x56\x25\x64\x66\x3f\xbe\x7c\xfd\xf6\xe5\xcf\x78\x5f\x0e\xee\xc3\x21\x78\xb2\xd3\x6b\xc4\x2f\x73\xce\x4f\xb3\x8f\x41\x14\x07\x29\x0e\xb6\xa6\x28\xc4\x62\x4c\x4f\xb3\xd7\x50\x45\x16\xbd\xab\x41\xf0\x9a\x41\x4c\xb2\x24\xc8\x4f\xb3\x23\xe5\x41\x4b\x0f\xe7\xae\x3a\x0e\x6b\x3a\xbe\xe4\xe5\xfb\x60\xf6\x11\xe2\x61\xde\x79\xa7\x17\x35\x9d\x0e\xb3\x7c\x1c\x94\x2f\x67\x71\xf1\x3e\x98\x2c\x9a\xb9\x18\xaf\xdd\x5e\xe1\xab\x4f\x88\x4f\x57\x34\x4e\xe0\x25\x2f\x5f\xa6\x97\x09\x3f\x1e\x42\xe1\xc6\xb2\x12\x12\x2c\x7e\xc2\xc3\x32\xcb\xef\x78\xc6\xa3\x1a\x1c\xc4\xf8\x24\x58\xf5\x5a\xc1\x7d\x3c\x86\x7e\x1f\x6d\xe1\x73\xed\xc5\xcf\x30\xa5\xa7\xc7\x3a\x3e\xbe\x73\x37\xcd\x0f\x08\x57\xf1\x60\x21\x6d\x78\xed\xed\x36\xb5\x1a\x40\xf6\xc3\xfc\xba\xed\xe8\xd9\x6a\x8d\xef\x0e\x06\x10\x87\xb4\xb9\xf5\x5d\x78\x87\x27\x37\x4f\x74\xde\x6e\xc4\x61\x8c\x5c\x05\x91\xf8\x8c\x41\x0a\xdc\x49\x8b\xc9\xb7\x5f\xaf\xaa\xf7\x3a\xf6\xb5\xb1\x7a\xaf\x8a\xee\x5b\x94\xcd\x83\xb1\x73\x8f\xcf\x0f\x4c\x3b\xae\xf5\x03\x71\x6f\x40\xee\x0c\xed\xa7\x4d\xa8\x5e\xc0\x2a\x18\x70\x46\x54\xb4\x2e\xce\x2d\x3b\x04\x76\x03\xff\x29\x2f\xa8\x50\xee\x00\x64\x34\xb3\x07\x3b\xa2\x14\xbc\xd0\x82\x9b\x45\x75\x76\x02\xc0\x24\xb4\x72\x6b\xf6\x4b\x61\xa6\xea\x57\x25\x76\xc9\x08\x79\x15\xd3\x71\xe3\x2c\x9d\xa4\x5d\xe5\x71\x69\xbe\xc5\xb2\xd2\x6f\xff\xc9\x5b\x2e\xe9\xcf\xc2\x0c\x2b\xbb\xf8\x1d\x76\x7d\x39\xb1\xb8\xab\x28\xb3\xb4\x0f\x6f\xd9\x16\xdb\x79\xbe\xad\x9d\x6b\x5a\xbb\x89\xe5\x4d\x93\xe6\xb4\x21\x7c\xaf\x75\x70\x84\x14\xf6\xc8\x6d\x56\xf9\x17\x70\x36\x1f\xd2\xb2\x9d\x83\x2d\xbf\x4d\xb1\x9f\x6a\x0f\x2a\x87\x3d\x12\xed\xb3\x2d\xd5\x9f\xe9\xc9\xdd\x71\xac\xbb\x20\x27\xaf\x1d\xce\xba\x2c\x9c\x77\x19\xc6\x4d\xee\xb2\xea\xb8\xf0\xb4\x34\xeb\xb3\x70\xc6\x1e\x63\x6f\x61\x56\xb4\x37\x25\x1e\x1f\xa9\x2a\x8f\x54\x1b\x50\x7e\xde\x67\xe1\x5c\x95\x2f\xe2\xb4\xbe\x3c\x1a\x43\x12\x77\x50\x7a\xd7\x72\x5e\xdb\xeb\xf4\x36\xbc\x85\xef\xb2\x11\x8f\x2f\x47\xe4\x32\x4b\x5b\x47\xbb\xeb\x8e\xfd\xc0\x76\xe1\xd5\xbd\x5e\x69\xbb\x8e\x11\x10\x3c\xe3\x22\x99\x7d\x39\xec\x32\x9b\xf4\xd9\x76\x97\xe5\xa2\x27\xf8\x75\x91\x95\x65\x36\xee\xa3\xcf\xb4\xa1\x48\x7b\x20\xcd\x28\xa8\x0d\xe5\x38\x4e\xdb\xf0\x23\xb8\x90\xe0\xb2\x4d\x65\x53\xda\x13\xf5\xcc\x03\x72\x99\x08\x3d\x60\xaa\xf2\x88\x24\xea\xe2\x18\x49\xb9\x32\x9b\x54\xea\x22\x4c\xb2\x72\x87\x6d\xb1\xdd\x26\x4f\x0b\x56\xc8\x82\x2e\x9b\xe8\xe8\x9d\x16\x5a\xd1\x4b\x02\xf7\x47\x3b\x87\xeb\x3c\x30\x53\x78\x17\x94\xbc\x28\x31\xa1\xd6\x55\xc3\xfb\x60\xc2\x6a\x63\x20\xd4\x74\x21\x27\x53\x85\x52\xc7\xaf\x6c\xc8\xc0\x2d\xd0\x24\x40\x25\x36\x8c\xe7\xcb\xa5\xf2\xf5\x59\x0b\xc0\xa9\x27\xd6\x05\x2f\x14\xd5\x6f\x82\x1f\x85\x2c\x47\xca\xdc\xac\x8d\x98\x01\x2e\xdb\xe1\x9a\x58\xb4\x94\xd6\xc6\x67\x57\x3d\x1f\xd1\xc1\x6a\xa7\x12\x96\x88\x64\xc5\x56\xa5\x19\xea\xc6\x54\xa2\x4f\x3d\x63\x30\xde\x79\xbb\x06\x1c\xb3\x02\x90\xd2\x0e\x71\x3a\x7a\x38\x9f\xd2\x9e\x44\xce\xaa\xca\xc3\xcf\xae\x36\xd4\x0d\x72\x94\x95\x74\x01\x93\x64\x5c\x70\x47\x76\x11\x95\xa0\xfd\x3a\x87\xb3\xa5\xfc\xd3\x3a\x0e\x78\x2e\xc0\x01\xcf\x25\x2f\x3f\xf0\x3c\xe4\x29\xfa\xcf\x46\x3f\x3c\xd8\x8f\xe0\x51\x92\x36\x71\x80\x5b\x6c\x57\xdb\x37\x86\xf3\xfb\xe9\x73\xae\x16\x82\x5e\x10\xb4\xd7\x31\xe1\x51\xf5\xac\x49\xcd\x9a\x71\x89\x9b\xa6\x3c\xd7\x15\xef\x1e\x6a\xd2\x7e\xd7\xc0\xa8\xa2\xc9\x01\x8f\x9c\x96\xf7\x0a\x01\x69\xdf\x82\xc0\x20\xec\x11\xdb\xee\x3d\x27\x4e\x82\xdd\x40\x45\x92\xe2\x2d\x7f\xe8\x71\xd4\x14\x3f\xcd\xf2\xd1\x27\x5d\xd3\xcb\x56\xce\x62\xea\x99\x4f\x3b\x15\x23\xee\xd7\xcd\x9b\x1d\x19\xcf\x2d\x52\xf9\xea\x9b\x38\xec\x53\x2f\x59\xac\x47\x94\xcd\x9e\x90\xea\xc4\xec\x76\x07\xc3\x48\x4b\x5f\xf0\xf0\xbb\x63\x3f\xa4\xd0\x9c\x0b\xa3\x83\x88\xa5\x26\xb8\x43\x8b\x5a\x1f\xea\xb7\x35\x64\xbd\xea\x95\xea\x06\xe6\xac\x36\x8a\x0c\xb0\xbe\x55\x8b\xa0\xc8\xdc\x56\x1f\x63\x62\xc8\x58\xc4\x98\xb7\x29\x15\x2a\xbb\xab\x9d\x18\xb9\x41\x3b\xed\xe8\x63\xaa\xa2\x41\x8f\xe5\x4a\x05\x64\x74\x74\x70\x27\x23\xe2\x2c\x24\x66\xe7\x0c\x70\xf6\xf0\x9f\x40\xcd\xa4\x11\x20\x64\x74\xe3\x63\xb8\x2b\xa5\x10\x3b\x8a\x0e\xe9\xdf\x1f\x4c\x47\x46\x34\x71\x8a\x9a\x78\x35\x4e\xc4\x13\x19\x28\x5a\x3a\x7f\x42\x92\xc0\x41\xdf\x7e\x6c\x21\x8c\xcd\x13\xb8\x1d\x1d\x9c\x81\x4b\x2a\xb3\x32\x54\xdc\x86\xdb\xf7\xf3\x45\x71\x04\x2b\x3e\x91\xe9\xa4\x6b\x87\xc1\x42\xe4\x7e\x75\x43\xd0\xdb\x98\xbd\xd1\x0e\x2a\xb5\x2b\x70\x15\x53\xa0\xda\x96\xf4\x48\x64\xc8\x46\xd0\x67\x9f\x12\x6b\x4d\xbc\x7f\x7b\xc6\xac\x30\xfb\x5d\x16\x82\xc0\x2b\x64\xe3\x3e\xc8\xc7\x64\x21\xf4\x59\xdd\xaa\xb0\x7b\x25\xbb\x6a\x9f\xf9\x96\x67\x5f\xff\xd2\x0f\x83\xac\xa7\xb1\xcb\x86\x0f\x8b\xa3\xae\x41\x52\x35\x7c\x18\x70\x3e\xaf\xae\x85\x1e\x6f\x7c\x05\xda\x13\xf1\x8f\x38\x14\x80\xdf\x01\x48\x34\xc2\xc6\x6c\x07\xc2\x05\xc7\x69\xd9\x9b\x29\x14\xcf\x4d\xda\x5c\xb1\xf8\x19\x3c\x17\x27\x4d\x90\xe2\x95\xac\x39\x7a\x59\xa6\xb2\x74\xf1\x8f\xbc\x44\x61\x7a\x92\x5d\xb5\x67\x3b\x6c\x93\xcd\x76\xbb\x6c\xb7\xa3\x8e\x17\x22\x79\x2e\x92\xe7\x90\x6c\x3b\x97\xb5\x14\x46\xf6\x81\x82\x66\x41\x28\x8b\x2e\xc4\xac\xd8\x25\x43\x94\x61\x2c\x08\xc4\x2a\x45\x0f\x2f\x54\x85\x76\x85\xa0\x22\x8b\x85\x73\x93\x38\x37\x61\xcb\xd5\xbe\xeb\xc7\xf6\x57\x71\xca\x9a\x75\xc5\xd9\x69\x0e\x33\xc8\x24\x11\xe2\x61\x8a\x98\xcb\xc9\x86\xaa\xe1\xae\xc5\xca\x92\xa4\x28\xcb\xdc\x58\x4e\xe6\xc2\x4c\x74\xdf\x9e\xb1\x4d\x16\xce\xc4\x49\x01\x4b\xe9\x18\x03\xd6\x09\x53\x1e\x91\x03\x71\xdc\x0b\xb3\xc2\x74\x3f\x67\x3f\xb0\x50\x3b\x5a\x71\x2b\xed\x92\x43\xf0\xa6\x9d\xeb\x9a\xd2\xb9\xd0\xca\xf3\x67\xbf\xf9\x4c\xdc\xb5\x1b\xed\x3b\x10\x90\xd3\xa4\x4f\x09\x58\x95\xb8\x69\x36\xd0\xc1\x13\xcb\x21\xb8\x91\x8c\x21\xaf\x59\x32\xc6\x22\x15\xc9\x18\xea\x1c\x01\x05\x5a\xaf\xe1\x74\xe3\x5b\xec\xc9\x53\x23\xa5\xf1\x34\xaa\x14\xd6\x9d\xd8\x45\x9d\xb0\x27\xaa\xa3\xae\x6c\xc3\x12\xa3\xbe\x3e\xb0\x85\x7d\xca\x96\xd8\x26\x34\xf5\x48\x34\x8e\xe3\xaa\xb2\x29\x5a\xc6\x3e\xb6\x3b\x3a\x4f\x8a\x64\x27\x0b\x10\xbc\xd7\x65\x05\x7c\x55\x97\xda\x5e\x75\xad\xed\xf5\xcc\x12\x1a\x54\x97\xb4\xbb\x92\xdd\x65\x24\x7b\xea\x5a\x1b\x84\x68\xda\xa9\xd8\xcb\xad\xdd\x22\x50\x33\xea\x16\x0b\xac\x99\xb5\x45\x7a\xec\xcb\x92\xc3\x65\x73\xb6\xe0\x2d\xcb\x91\x44\xe3\x5d\x5e\x2d\x6e\xab\xe9\xeb\x6b\x05\xf8\x0f\xb4\xa9\x46\xaf\x92\xa4\x31\x78\x79\xe8\x06\x3d\xca\xa7\xb6\x07\xca\x41\xcd\x72\xf1\xac\x12\x07\xa7\xf6\x2a\xf1\x54\x58\xb0\x68\x7c\x35\x2a\x6b\x88\x14\x82\x5d\x43\xe5\xa9\x17\xcd\x24\xfb\x07\xdd\xba\xf6\x1b\x43\x72\x37\x0f\x05\x01\xeb\xa1\x7b\xea\xff\x95\x8c\xc8\xd7\xc2\x63\xbb\x05\xb2\x02\x6c\x7c\xb1\x1f\x0e\x29\x6e\x36\x36\xac\xcc\xbf\x1e\x32\x6b\x90\x62\xbe\x64\x33\xae\x97\x0c\x2a\x0a\x20\xee\xbb\xf5\xcc\x93\xf6\x71\x53\x31\x5f\x36\x5e\xf0\xed\x8b\xc2\x46\x3f\x17\x96\x85\xd2\x16\x1b\x95\xe5\xa4\xe8\x6f\x6d\x5d\xc6\xe5\x68\x7a\xd1\x0b\xb3\xf1\xd6\x3f\x93\x2c\xce\xb3\xf0\xf3\x56\x98\xe5\x7c\xf3\xf7\x62\x2b\x2e\x8a\x29\x2f\xb6\x9e\x3f\xfd\x4f\xf8\x15\x66\xe3\x31\x4f\xcb\xcd\x9d\x9d\xfd\x67\xfb\xdf\x6f\xef\x3e\xb7\xdf\xa4\x56\x0c\x0c\xa4\x95\xd8\x55\x9c\x46\xd9\x15\xbc\x66\x23\xd6\xbf\x1b\x1b\x32\xa3\x27\x18\x1f\x3b\x44\x06\xf8\x80\xb1\x17\xaa\x42\x5f\x35\x50\xf0\x64\xe8\xa9\x2e\x92\xad\xca\xec\x05\xa4\xa1\xb5\xa1\xf3\xac\x3b\xe5\xb3\x52\xbf\xed\x4e\xf9\xd5\xa6\xc0\xcf\x03\xc6\xfa\x4c\x7b\xca\x69\xa9\x45\x35\x12\x47\xa9\x76\xc7\x71\xa0\x78\xe9\x3a\x50\x84\x70\xba\x30\xf8\x5b\xbb\x50\x7c\xb2\xde\x53\x60\xb0\x0f\x0e\xd2\xcf\xad\x82\xbd\x7d\xf3\x1c\xee\x1b\xa4\x55\x6d\x3a\x77\x4c\x73\xaa\x66\x1f\xdf\x79\xed\x92\x76\xe8\x33\x01\x9f\xdb\x7d\x8f\xd0\xda\x0a\x5a\x82\x84\x6d\x07\x31\xf4\x1a\xed\x19\xdc\x4e\x74\x7a\x81\x98\xbd\x67\x07\xe8\xfb\xc5\xc1\xc4\x32\xcf\x74\x16\x5a\xd5\x95\x23\x2e\xf2\xce\x92\x20\xbd\x9c\x06\x97\xa8\x23\x3c\x6f\x0b\x1a\xef\x6f\x6d\x5d\x5d\x5d\xf5\x78\x38\x0e\x36\xc1\x16\x01\x6d\xa4\x83\xa4\x97\xe5\x97\x5b\x90\xbc\xfb\x74\x77\xeb\x59\x6f\x7b\xeb\x3f\x0b\x1e\x6e\x8a\x94\x22\xcc\xe3\x49\xb9\xa9\x5a\xdb\x14\xad\x15\x1d\x70\xde\x35\x64\x9f\x10\x21\x9f\x7a\xac\xcd\x7b\x97\x3d\x16\xe4\x79\x30\x27\xfe\x54\xc5\x79\x02\x4a\x14\x42\xe4\xbf\xe4\xa0\xa5\xfc\x94\xf2\x2b\x86\x0e\x6a\xdb\xdb\x9d\x4f\x62\x9d\x47\x98\x88\x9a\xc9\x76\xab\xd5\xf9\xd4\x59\xd6\x0c\x70\xbb\xb7\xf3\xad\xcd\x00\x83\x54\x8e\x6a\x39\x43\x40\x79\x08\xc5\x47\xcc\x35\x46\x7e\xb2\xcc\xd9\x4e\x97\xed\x76\xd9\x93\xf3\xc5\x45\x07\xbd\x34\xcb\x26\x8b\xcb\xb9\x26\x88\x5e\xdb\x41\x59\x96\x98\x0f\xc2\x29\xda\xf2\x02\xe8\xda\x65\x21\x22\xa5\x93\x31\x88\x13\x2b\xe3\xd9\x19\x87\x7a\xd7\xd7\x4c\xa7\x69\xa3\xd8\x4e\x9d\x15\x22\x02\x51\x5d\x15\xeb\xbd\x0e\x81\xad\x36\xe7\xfc\xa7\x26\x77\x01\xbb\xcf\xe1\xa6\x74\xeb\xd1\x23\xf6\x1a\xc2\xcc\x41\x15\x81\x84\x18\x9e\x3c\x7c\x12\xbc\xf4\x53\x4f\xeb\xbc\x73\xce\x4f\x04\x23\x3e\xb4\xd8\xb2\xe3\x4b\x10\xd2\x14\x6f\x56\x96\x90\x87\x4a\x29\xa1\x72\x64\xb7\xbf\x14\x3c\x62\x41\xc1\x02\x96\xab\x90\x64\x82\x48\xcb\x11\x57\x9b\x0a\xb6\xac\x61\xc8\xb3\x0c\x0e\x80\x66\x68\xd7\xd7\x06\xb0\xeb\xeb\x26\x5e\x5e\xc5\xbe\x68\xad\x82\xf9\xbd\xf5\xec\xb4\xef\xc9\xd5\xd7\xe9\x7c\x92\x5d\xe6\xc1\x64\x34\xaf\x7d\xbf\xb7\xfd\x07\x7b\xfb\x32\x20\xfe\xf1\x0e\xbf\xf6\x96\x36\xd5\x06\x01\xe6\x40\xee\xa8\x71\xc1\xae\xb2\xfc\x33\x3a\x25\xc8\xd2\x4d\x9c\x47\x21\xd7\xf0\x07\x62\xb3\x6f\x53\x53\x91\x07\xff\x41\x48\x4c\x6c\x6d\x40\x64\x68\x9b\xfa\x1f\x4e\x73\x43\xc6\xbf\x04\x09\xb0\xd1\x24\xc9\xae\x78\xc4\xda\x05\xe7\xec\xe8\xe4\x43\xe7\xc1\x7f\x80\x18\x61\x11\xef\x43\xd2\xf2\xc3\x4e\x1b\xdc\xa9\xb4\x77\xba\xa2\x8d\x4e\xfb\x21\xa6\x1e\x3c\x90\xd6\xad\x60\xdc\xea\xe9\x51\xac\x22\x29\x48\x99\xd5\x25\x20\xf8\x12\xc4\x89\x98\xf3\x07\xff\x11\x0f\xdb\xb6\x88\x26\x56\xea\x43\x5c\x73\x0f\x3b\x0f\xfe\x03\x40\xc3\x2c\x7c\x15\xb1\xc5\x2e\xe1\xf1\x06\x3e\x44\xb9\xe0\xd4\x43\xe1\xc5\xb4\x64\x69\x56\x8e\xe2\xf4\x52\x2c\xe2\x28\x63\xc1\x45\x36\x2d\x59\x5c\xf6\x7a\xbd\x07\xf8\x8e\x45\x8e\x8b\xd4\x8a\xd3\xa2\xe4\x41\x24\xf6\x55\x55\x19\x1f\x36\x15\x19\x8b\xcb\x56\x21\x2a\xf2\xa0\x88\x79\x2e\x1a\x45\x4f\x4f\xf2\xa5\x4b\x50\xf0\x1e\x8b\x87\xed\xef\xa4\xc3\x02\xf6\x95\xf5\x7a\x3d\x1f\x9b\xbd\xac\xae\xf2\xf5\x0c\xbd\xef\xcd\x62\x55\x7a\x8e\xae\x98\x98\xca\xb3\x43\x9d\xbb\x6a\x63\xaf\x29\x0b\x36\x79\xab\x56\x6d\xe9\x3a\x38\xe1\xbf\xc6\xe5\x28\x9b\x96\x12\xfa\x98\xd7\x76\xb6\xbf\xa8\x62\x53\xe7\x75\x7d\x75\xbc\x8f\x2f\xd1\x43\xe9\xab\x9c\x07\x9f\x41\x21\x59\x7c\xab\xf7\xb7\x17\xc1\x05\x4f\x3e\x24\xd3\xcb\x38\xfd\x31\xc9\xae\xe0\x7d\x93\x80\xf6\x54\x08\x82\x83\x49\x9e\x4d\xc4\xc2\x19\x18\xc8\x6a\x70\xb5\xdd\xe9\x65\x29\x3f\x1e\xb6\xcf\x5a\xb3\xa2\xd5\x65\xad\x62\x2c\xfe\x3f\x8e\xc4\xff\x13\xf0\x9c\x3b\x4b\x5a\x10\x6c\x69\x6b\x8b\x9d\x80\xfd\x38\x7b\x79\x72\xc4\x2e\xe6\x10\x4e\xa1\x27\xe4\xfc\xb2\x55\x48\x1b\xa9\x20\x2d\x61\x29\xbd\x2d\xc5\x32\x6c\x95\x62\x09\xaa\xeb\x78\xdc\x4a\xc5\x9a\x61\x60\x4b\x87\x32\x64\x90\x24\x73\xe5\xcf\x01\xa1\xef\x3d\x90\x96\x49\x05\x31\x71\x96\x9f\xcd\x50\x22\x90\xff\xcd\xf9\x44\x30\xc8\x31\x78\x1e\x19\x05\xa5\x90\x51\xa3\x38\x60\xe0\x85\x23\x4c\xa6\x45\xfc\x85\xab\x10\xf7\x47\x27\x27\x2a\x00\x08\xbe\xef\xea\xb9\xee\x67\xc9\xe4\xb6\x2f\xcc\x6f\x23\x90\x0d\x48\xea\x7f\x7d\x51\xf1\xd9\x49\x22\x1a\xcf\x6b\x25\x8d\x2e\xe2\xad\xe8\x18\x8c\x48\xc3\x98\xa2\xcf\x76\xb0\x7e\x31\xee\xb3\xa7\xdb\x52\x7b\x36\x8e\xfa\xec\x7b\xa5\x4a\x4b\x2e\xfb\x6c\x67\xf7\xb9\xfc\x9a\x25\x7d\xb6\xf3\xfd\x2e\xa8\xd0\x58\xdf\xd7\x97\x82\xc7\xca\x9a\xa6\x71\xe9\x40\x2f\x92\x54\x59\x99\xed\xa9\xe2\xc0\xdd\x9a\xcc\x5a\x6e\xb7\xb4\x21\x2b\x43\xba\xf0\xa2\x9d\x8a\xa4\xae\xed\xe1\xcb\x53\xc5\xe9\x74\xdf\xed\x91\xb6\x02\xfa\x7f\xf5\x0e\xbd\x8e\x31\x98\xb7\xdb\xa4\x99\x2e\x3b\xc3\x77\x12\x40\x7a\x62\x14\x40\x82\x25\x9f\xe0\xc2\xa0\xee\x2b\xa7\x13\xea\x1e\xfc\x0b\x09\xa7\x84\x2d\xa0\xfd\xd8\xf5\xb5\xa0\x6f\xcb\x4f\x63\x4b\x12\x69\x7b\x1c\xa7\x9b\x70\xc1\xdf\x6f\xb1\xc7\xb2\xf6\x63\x44\xfc\x63\xd6\xea\xb4\xb4\xaa\xc5\x5c\xab\x64\x57\xe9\xda\xbd\x06\x33\xd2\x2b\x9e\x39\xd8\x26\xa2\x7e\x8b\xed\x6c\x6f\x77\x16\x00\x21\xc3\xaa\x78\x5c\xc8\x69\xd5\xb4\xf2\xe3\x2f\xd6\xb2\x76\xa7\x4d\x3d\x32\x4a\xad\xb4\xb7\x9c\x71\x33\xb7\x04\xc2\x60\xc0\xc5\x99\xe9\xf5\xfc\x9c\x82\x0f\x67\x5b\x18\x67\xcb\x3b\x70\x59\x9d\x46\xb3\x3b\x3f\x6f\xc0\x46\xa7\x8a\x8e\x2c\x4d\xe6\xee\x9c\x7c\xe6\x73\xef\xd0\x3e\x43\x84\x7e\x75\xbf\x6d\x4a\x1d\xca\x72\x26\xd8\x4e\xc5\x31\xb9\x24\x37\xea\xf8\x5c\x85\xff\x90\xf3\x01\xa6\x90\xaa\x8c\x0d\x23\x46\x7b\xa9\x7a\xb3\x27\x34\xe3\xea\xf5\x60\xf1\xa8\x2d\xdc\x2c\x16\xac\x2e\x80\xed\xc3\xff\xbb\x0f\x0c\xa3\x93\xf6\x97\x32\x6d\x3a\xe9\xb3\xa9\x5c\x93\x82\x6e\xfb\xf0\x7f\xfc\x96\x20\xf7\xd5\x0f\x4c\x15\x98\xec\xc3\xff\xf1\x1b\x27\x0b\xff\xc1\x4b\x48\x58\xd9\xea\x59\x2c\x95\xa1\xd6\x7b\x8e\xf4\xe7\x08\x03\x72\xc9\xcb\x0f\xca\x10\xf7\xb8\xee\x4d\xdc\xf3\x9a\xe2\x4d\x0f\x62\xec\x92\xba\x81\x30\x09\x8a\xe2\x28\x48\x12\x50\x63\xd5\x89\x58\xdf\xd7\x94\x6f\x92\xac\x9c\x96\x4d\x0b\xe8\xe5\x5d\xe4\xd6\x46\x3b\xd9\xf6\x95\x6e\xec\x8c\x34\xaa\xeb\x4e\xb2\xa2\x88\x2f\x12\x7e\x64\xbc\x84\xa1\x4a\xa9\x3e\xca\xca\xe2\xba\x4d\x50\xd4\x77\xa8\xdb\x8d\xd3\x11\xcf\xe3\xb2\x7e\xe8\xd5\xa2\x4d\x3d\xea\xe6\xfe\x05\xe3\xc8\xfc\xa9\x64\x7d\x68\x53\x5a\xe3\xd7\xbd\x7d\xdd\x77\x0a\x36\x0d\x12\x4b\xd0\x53\xc4\x55\x5c\x8e\x8e\x65\x64\x31\x71\x8a\xd5\x5f\xaa\xd1\x1c\x7c\x5c\xd4\xcc\x9b\x21\x4c\x25\x37\xd7\x4a\xf8\x95\x92\x4d\x70\xea\x42\xb7\x71\xce\xb4\xb3\xf3\xe4\x6e\x9c\x33\xdd\x53\x14\x1e\x04\x0c\xdf\xbf\xd6\xe1\x69\x7f\x57\x73\x51\x5a\xd2\x6e\xfc\xd7\x38\x89\xc2\x20\x8f\xda\xba\xb5\x26\xdd\x91\x2e\x2d\x8f\x7c\xe0\xff\xd1\x77\xde\xb3\xcf\x83\xe4\xc5\x81\x80\x26\xe5\x57\xc7\x17\xbf\x83\x27\xb8\x03\xdd\x84\xd4\xf0\x5a\x8f\x42\xec\xe7\x11\x4b\xbf\xe4\x50\x2f\x26\x3a\x1d\xd9\x95\xf6\x36\x27\x7f\xe2\x0b\x0e\xcc\x23\x67\x5f\x80\xd4\xf8\x08\x3c\x46\xc0\x6f\xbe\xd1\x01\x58\x26\xbf\xf9\xc2\xd3\xd2\xac\x22\xb1\x8f\x86\xc1\xa4\x9c\xe6\xbc\x8f\x4a\x75\x21\x34\x4c\xc4\xe2\xfb\xa2\x52\xc0\x3b\xdd\x23\xe7\x36\x8c\x4d\x40\x07\xb5\x59\x4c\x72\x1e\x44\x42\x6e\x30\xc3\x18\xf3\xfc\x52\x01\x4f\xfb\x6b\xcb\xb8\x80\xd5\x30\x42\x92\x1d\x10\x01\xe9\xa6\xeb\x83\xb8\xab\x42\x0b\x3a\xa1\x80\x2e\x39\x16\x7b\x17\x17\x25\x4f\x79\xfe\x32\xbf\x2c\xda\xe0\xc8\xf2\x67\x70\x4b\x2b\xe6\xed\x22\x08\x3f\x9b\xfa\xfa\x34\x2a\x03\x64\x9c\x79\x4a\x83\x34\x27\xf2\xd1\xdd\xb8\xa2\xe0\x9e\x44\x0f\xc2\x24\x30\x2f\xd1\xd9\x57\xbf\x7a\x12\xa5\x34\x3a\x8d\x68\xc7\x06\x3a\x4b\xe5\x4b\xa5\x2e\x5b\x0c\x2a\xf8\xe9\x56\x00\x04\x51\x64\x0d\x57\xc9\xa3\xd8\x5c\x25\x5b\xb9\x9b\x94\x9d\xdd\x1e\x59\x6e\xfc\x53\x03\x48\x59\x06\xe1\x08\x5a\x23\x6e\x71\xde\xbe\x79\xfe\x98\x9d\x60\x19\x0b\x2e\x53\xba\xdd\xca\x52\x71\x7e\x20\xdd\xba\x97\x95\x60\xb1\x25\x41\xc1\x85\x27\xdf\x75\xd1\xf0\x85\x37\x36\x46\x87\xc3\x55\x51\x9a\xf3\x71\xf6\x85\x37\x61\xd5\x53\xe2\xfe\x10\x1b\xf1\xdb\x20\x96\x94\xf6\x20\x56\x75\xeb\x41\xd8\x30\xcb\xdf\x04\xe1\x48\x01\xac\xde\x37\xc4\x25\xcf\x83\x92\x93\x4b\xb4\x70\x14\x27\x51\x0e\x81\x83\xa4\x29\xbe\x4c\x50\xda\x02\xed\xac\x18\xb3\x25\x4a\x94\x55\x89\x00\x06\x5c\xcc\x2d\xaf\x4f\x90\xa0\x9c\xb5\x54\x4f\xad\x2e\x6b\x61\xb3\x5a\x8b\xe0\x0b\x41\x66\xfa\xea\xf4\xe4\xf0\xda\x3e\xf7\x34\x38\xff\xe2\xbb\x57\x4c\x2f\x30\xee\x95\x68\x6f\x17\x83\x5a\xb5\x88\x23\x31\xea\x89\xcc\x32\x75\x16\x30\xb2\x43\x32\x3c\x74\x5b\x43\x2c\x78\x9d\x08\x64\xd9\x64\xe5\x08\x64\xd9\x84\x1c\xfa\xd5\x35\xa3\x72\x53\x4d\x03\x80\xd1\x52\x24\x98\x5f\x59\x0d\x42\x46\x4c\xe5\xbf\xd3\x2d\x6e\x6c\x80\xef\x77\x59\x66\x21\x0a\x24\xa7\x93\x5e\xa2\x25\x2a\xdb\x9b\xcf\x3a\xbd\x32\x7b\x97\x5d\xe9\xa0\x73\xd0\xb3\x2c\x4c\x40\xd4\x64\x6a\x37\x20\xe6\x62\xd7\x69\x02\x2b\xd1\x0a\xaa\xef\x17\x26\xd5\x9e\x4b\x93\xac\x55\x02\xcf\x3a\xac\x6f\xd2\x09\x06\x14\x02\x88\xb5\xbf\x5c\x05\x74\x09\x8b\x79\xe8\xe1\xa5\x45\x2e\xbf\xcc\x8e\xc4\xaa\xf6\xf2\x75\x6d\x74\xeb\x37\xc9\xaf\x66\x43\x56\x03\xbc\xe9\x50\x6f\xb1\xce\xde\x47\x04\xe1\xb6\x86\xcc\x62\x74\x6b\x86\xc4\xca\xd4\xde\xdb\x02\x01\x7b\x13\x86\xb2\x99\x48\x9e\xd1\x67\x27\xe8\x40\xec\x82\x9b\xc8\xd0\x7a\x4b\x8c\x2d\xf8\xea\x02\x16\x22\xb6\x24\xf0\x7d\xf5\x43\xaa\x33\xb0\x6a\x7f\xb1\x54\x21\x8d\x1f\x51\xdc\xb1\x18\xb1\xe5\xa1\x6a\xe0\x78\xdc\x84\x51\xeb\xa3\xa2\x19\xb6\xd5\x42\x97\x0d\xa8\x67\x49\xaa\x15\xb2\xca\xe9\xbd\x0b\x5a\x75\xce\xfa\x24\xca\x18\x78\x7e\xb6\x77\x1b\x4b\x59\x07\xd5\xeb\x8f\xd0\x6e\x4b\x36\xb0\xbd\xc1\x00\x24\xd8\xc1\x00\xee\x19\x45\x53\x8e\x9a\xa3\x66\x94\x9d\x4e\x8d\x67\x6a\xa3\x0c\xc3\x71\x11\x9d\x42\x2d\xc2\xce\xb4\x92\xab\xcf\x5a\xa1\x42\xde\xeb\x38\x7a\x9f\x4d\xd3\xb2\x45\x54\x5e\xe4\x7a\xba\x52\x8e\x08\x03\x02\x28\x21\xdb\xa8\x2e\x8a\x36\x5d\x15\xea\xb1\x01\xf6\x87\x4e\xed\xf4\x94\xa1\x03\xd5\x9a\x3e\xbd\x65\xdb\x15\x8f\xaa\xcb\xf9\x54\x05\x20\xbd\x8e\x55\xbd\x70\xea\xf1\xfe\x1a\x27\x49\x23\x94\x9e\x92\x2e\x6e\x50\x42\x59\x06\x3d\x14\xcd\xcb\xf5\xaa\x0b\xae\x38\x21\x36\xf8\xe9\x78\x19\x1a\x20\x45\x57\x1f\x2a\x85\xaf\xa6\x43\x7b\x08\xce\xf0\xc4\x7a\x30\xb9\x59\x5a\xdf\x93\x03\x53\x4d\x67\x15\xc8\x9b\xfb\x1b\x0e\x1b\x86\x66\x95\xad\x1b\x9c\x3b\x80\xe3\xfc\x78\x38\xb4\xbd\xf2\x6b\xe1\xcd\x50\xaf\x94\xe0\x50\xce\x52\x7b\xa4\x76\xac\xa0\x5f\x52\xc1\x1e\x8e\xef\x7c\x45\x75\x55\x47\x65\x13\x73\x4b\xd5\x07\x09\x83\x6b\x3b\xec\x37\xcd\xa0\x81\xc2\x19\xd6\x38\x27\x0e\xf4\x4d\xc3\xae\xe0\x4a\x97\x9d\x1c\x62\xef\x22\x4e\x23\x30\x1c\xeb\xaa\xb6\x3b\x1d\xe7\x71\x9b\x6f\x12\xd3\x88\xe7\xb5\x73\x27\x32\xdb\x15\x8e\x40\xd0\xa6\x05\xe5\xeb\x6b\x1d\xb7\x52\x76\x74\x4e\x8f\x83\x16\xb3\x3c\x78\x70\xd3\x46\xed\x55\xcf\xda\x65\x6c\xae\x4e\x15\x57\xcb\x6e\xe9\xe8\x02\xf8\x91\x00\xe2\x11\xfb\x2d\x9b\x82\xb1\x87\x0a\x4c\x19\xb0\x22\x06\x7b\x64\x00\x9a\x95\x59\x06\x8e\x46\xc1\x13\xb0\x1a\x47\x9f\xaa\xc1\x14\x9b\xeb\x49\x7c\x76\x69\xeb\xa7\x23\xce\x5e\x1f\xbf\x57\x13\x5d\x66\x0c\x45\x04\x56\x92\x66\x31\xd3\xdf\x28\xdc\xab\x8b\xb4\xf6\x99\x37\x5b\x1a\x2b\xfa\xf2\x90\xa0\xce\x3b\xbd\xb8\x90\xba\x93\xe8\xc1\x0d\xeb\xb3\xaf\x37\x3e\xff\x4c\x0e\xee\xef\xde\x35\xe8\xde\x32\xee\xd3\x16\x9a\xc0\xe2\x80\x37\x93\xf8\x33\xef\xb1\x97\xf2\x86\xd2\x4e\x17\x35\xc0\x40\x20\xcd\x4a\xe9\x88\xf2\x01\x38\x73\x88\xc0\x25\x6e\xc0\x3e\xe1\xea\xfb\x24\x9f\xaa\xb1\x6c\xa8\xcd\x81\xfe\xcc\x2e\x2a\xc9\x10\x6f\x63\x9d\xfa\x2e\xfe\xcc\x97\xb1\x50\x85\x72\xcb\x5b\xa9\x42\xf1\xaa\xa5\xaa\xb2\x41\xf5\x14\xbe\x85\xb9\x2a\x94\xaf\xf3\x78\x49\xec\x52\xa9\xfd\x2a\xb3\x8e\x7b\x4d\x76\xa8\xa2\xf5\xaa\xad\xd4\x9f\x32\xf8\xe9\xab\x69\x59\x66\xe9\xab\xa0\xa8\x8d\x9e\xb0\xb7\xfb\x07\x5b\x44\x1a\x10\xff\x04\x16\x91\xcb\x3c\x0d\x69\x36\x28\xbe\x08\x0a\xfe\xb6\x68\xba\xa7\xd8\xdd\xde\xeb\x18\x97\x25\x1f\x78\x3e\xcc\xf2\xb1\xe0\x2b\x11\xe7\x13\x10\xd4\x82\x3c\x2e\x8c\x35\x03\x2b\xaf\x32\x65\xaf\x53\x66\x2c\xe2\x25\xcf\xc7\x71\xaa\x5c\x9e\xcf\x59\x90\x83\x59\xbf\xe8\xe0\x4b\x90\xa0\x7b\x74\x68\xfb\xd1\xa3\x9f\xb3\x92\xf7\x1f\x3d\x42\xa3\x47\x19\x29\x44\x5f\x2c\xc8\xae\x20\xf8\x3d\x1a\xe7\xc3\xbf\xec\x62\x3a\x1c\xf2\xbc\xe8\x32\xc9\x57\x0a\x08\xc8\x0d\x21\x38\xb4\xc9\x3e\xf8\xcb\x36\x9f\xe3\x00\x64\x73\xb0\xdc\x2f\xba\xda\xf8\xbf\x6a\xe2\x2f\x5a\x2a\x78\x09\x6f\x86\x45\xd7\xe2\x07\xf8\x1b\x2e\xd0\xd8\x5f\xac\xc8\x48\xc2\xd3\xab\xb4\x23\x86\x2a\xc1\xe6\x91\x68\x0a\x0d\xa8\xe2\x1c\x43\x6e\x09\x86\x2d\x0f\x9d\x3c\xa2\xbe\x96\xa4\x73\xf7\x32\xe6\x45\x4f\x1b\x90\x16\xd0\xe1\xeb\xe3\xf7\xa2\xa1\x34\x8b\xb8\xdd\x3c\x18\x97\xa1\x69\x2b\x17\xb3\x19\x97\xf3\x2e\x8b\x7b\xbc\xc7\x3e\x1d\x1e\x1e\x2e\xef\x8c\x78\xf5\x57\x08\x08\x48\xcf\x29\x89\x26\x44\xe0\x2a\x06\x7e\xf9\xcb\x2f\xb3\x37\x94\xaa\x37\x1c\xb8\xa1\x9f\xc5\xdb\x03\x38\xd8\x50\xda\xb2\xaf\xac\x15\xb4\xfa\x6c\x07\x5e\xe0\xca\x3c\x69\xe7\x64\x67\x29\xa6\x0e\xab\xa3\xad\x64\x0f\x65\x39\xe1\xdb\x2f\x32\x63\x1b\x0f\xc5\x16\xb1\x7f\x6c\x59\xfa\xda\xc2\x86\xe9\x06\x40\x16\xa7\x5d\xa8\x8e\xe1\x43\xd1\x2a\xaf\x6f\x7c\x97\x74\x37\xae\x26\x97\x77\x6e\x37\x28\xf2\x70\x70\x11\x17\x3c\x2c\xeb\x5d\xe7\x41\xb8\x42\xd2\x7c\xce\xef\xcb\x31\xe2\xd2\xa0\x42\x88\xe7\x3a\xcf\x89\x1a\x3e\x2c\xfd\x11\xfc\xd2\x78\xbd\x20\x3a\x25\xdf\xf1\x61\xe9\xb8\x3f\xbc\x85\x5b\x3e\x01\x5f\x50\x84\x1c\x50\x52\x8b\xcd\xe7\x3b\x77\x8d\xcc\x3a\xc7\xa0\xb7\x01\xd6\xc6\xe7\x0a\x6e\x03\xcd\xe4\x64\x79\x3d\x25\xc1\x13\x8a\x3b\x1d\x7c\x9d\x5f\xcf\x5b\x00\xbb\xde\xd8\x9f\x60\x73\x61\x9e\x15\xf5\x1e\x13\x9f\x3f\xdd\x6d\xa6\x54\xa8\xbe\x22\xe9\xed\x21\x04\x11\x5f\x4c\x7b\x4f\x9f\x34\x83\x61\xda\x58\x11\x96\x7d\x05\xcb\x97\x18\x8c\x91\x1b\x48\x61\x01\x46\x74\x13\x2b\x42\xf2\x14\x21\x01\x53\xbf\x06\xde\x06\x21\xfc\x1b\xc0\xc0\xfa\x2b\xc2\xf0\x0c\x61\x18\xc5\x45\x99\x5d\xe6\xc1\xb8\x61\x62\x16\x80\xa1\x9b\x58\x11\x92\xe7\x08\x49\x39\xca\x79\x31\xca\x92\x68\x30\xcc\x39\x8f\xc6\x41\xfa\x3a\x0e\xc2\x2c\x8d\x9b\x48\xf7\x59\x33\x68\xba\xcd\x1f\x9d\x26\x57\x04\xf5\x7b\x17\xd4\x22\xcc\xca\xfa\x19\x7c\x0e\x61\xd5\x96\x81\xef\x44\xb4\xb3\x2a\x7b\xdf\xae\x40\x55\x4e\xf3\x4b\x5e\x8f\xb7\x27\xcb\xc3\x85\x2d\xad\x0a\x99\x64\xe6\xe3\x60\xd6\x80\xa3\xef\x9b\x61\x19\x07\xb3\x55\xbb\x97\xec\x74\xcc\x83\xfa\xc5\xfe\xfc\xd9\xf6\x82\xfe\x79\xb0\xea\x3a\xdf\x79\xa2\x00\x88\xe2\x46\x10\x76\x16\x81\x40\x3c\x63\xdf\x1a\x88\x3d\x05\x44\x7e\xc9\x1b\x60\x58\xc0\xf3\xa0\xfa\xaa\x20\x48\xd6\x3b\x8e\x9b\x98\xee\x22\x3a\x88\x57\xc6\x80\xe4\xb7\x93\x20\xce\x9b\x16\xc5\x82\x59\x80\xea\xab\x82\x20\xd9\xed\x84\xe7\xe3\x69\xd9\x34\x0d\x0b\x76\x41\xd9\xc0\xaa\x60\x48\x5e\xfb\x8f\x69\x90\x96\x71\x52\x0f\xc7\x2e\x44\x09\xba\x53\x69\xa8\xce\xd9\xf6\x6d\xa0\x5d\x4f\x1c\xda\x91\xec\x1b\xdc\xb2\x35\xd0\xc1\xd3\xbb\x1e\x7a\x9d\x67\xf9\xa5\x41\x5d\x53\x04\x96\x1b\x44\x11\x36\x32\xa1\x05\xdb\xbc\xa8\xbd\x22\xd9\xed\xca\x7d\xa0\x18\x4d\x87\xc3\x06\xaa\x7b\xfe\x6c\x7f\x01\x0c\xd8\xc0\xaa\x60\xc8\xfd\xa0\x98\x36\x48\x3b\xcf\x9e\x2e\x00\x61\xba\xaa\x9c\xb3\x2b\x77\x03\x70\x77\xd7\x40\x7e\xcf\xee\x9a\xfc\x46\xb7\x3f\x87\xd8\xa0\xfa\xc9\x6f\x7d\xc0\x86\xeb\x03\x76\x71\x2f\x80\x5d\xae\x0f\x58\xb8\xce\x82\x95\x5b\x36\x44\x0f\x99\x64\x45\x03\xb3\x5a\x24\xbd\xe8\x26\x56\x25\x5a\xb9\x75\x83\x5f\x88\x34\x6c\x62\x9b\x0b\x76\x2e\xd5\xc2\xaa\x80\xc8\x4d\xfc\x9f\xf1\xa4\x61\xf1\x2e\x38\x0f\xfc\x33\x9e\x80\xf5\x71\xd3\x9f\xad\x11\x6b\xf4\x4f\xf3\xe7\x08\xbe\x52\xb7\xb1\x46\xd2\x6f\xf5\x09\x0f\xb3\x34\xfa\x66\x51\x4b\x54\xb7\xef\xe3\x74\x5a\xf2\x6f\x16\xb7\x44\x75\xfb\xb7\x6c\x5a\x0d\xd8\x71\x5f\x6a\x2c\xd5\xe9\xeb\x60\x7e\xe7\x7d\xd6\x09\x0d\xaa\xcf\x5f\x39\xff\x8c\x9d\x82\xc5\xbe\x35\xd9\xec\x90\xed\xf0\x27\x76\x0e\xce\x07\x3b\x64\x4f\xf9\x9e\x9d\x23\x50\xc6\x0e\xd9\x93\xa7\x7c\xdf\xce\x78\x1d\xcc\xd9\x21\x7b\xfe\x74\xcf\xcd\x10\x7d\x8b\x96\xb6\xf7\x9e\x8b\x2c\x77\xd1\xdc\x65\x70\x63\x73\xed\x9d\x4d\xe6\xe8\x62\xbf\x1d\x76\xd8\xee\xf6\xce\x93\xcd\x49\xce\x0b\x50\xeb\xff\x18\x84\xfc\x22\xcb\x3e\x77\xd9\xdb\x34\x54\x37\x18\x70\x37\x24\x63\x74\x40\x94\xd7\xb8\x60\x49\x1c\xf2\x54\xb0\x86\x69\x1a\xf1\x1c\x6e\x0a\xde\xbf\x3d\x55\xc9\x6c\x98\x4d\xd3\x48\xba\xa5\x17\x4d\xbc\x7b\x7b\xf4\xe6\xe7\x93\x37\x6c\x18\x27\x5c\x79\xab\x07\x2f\x34\x51\x9c\x83\x86\x6e\xce\xb2\x21\x3a\xa4\x90\x1d\x95\x39\xe7\x0a\x80\x07\xce\x4b\x87\xe0\x33\x7f\x33\x9e\x94\x73\xed\xe9\x23\xc8\x2f\x2d\x35\x7e\xd5\xaa\xdd\xbc\x07\x38\xd0\x16\x8b\x12\x1f\xa7\x56\x2c\xe2\x20\x0c\xf9\xa4\xc4\xab\x9f\x28\x2e\xc2\x20\x8f\x0a\x16\xa7\x93\x69\x59\x1c\xb0\xb8\x84\x1b\xfe\x34\x63\x45\x1c\x71\xc6\x87\x43\x1e\x96\x45\x0f\x9b\x40\x57\xf9\x93\x3c\x1e\x07\x79\x9c\xcc\xd9\xb4\xe0\xc3\x69\xc2\xe2\x28\xce\xc6\x96\x0f\x81\xec\x0b\xcf\xf3\x38\x82\x7b\x27\xdd\x2f\x4f\x23\x7c\xc7\xcd\xae\x46\x71\x38\x02\x83\x82\xe4\x2a\x98\x17\x2c\xe5\x3c\x62\x65\x06\x4e\x0a\x82\x04\x7c\x8e\x74\x19\x5e\x1d\xfd\x3f\x27\x2c\x09\xc2\xcf\x05\x0b\xe0\xc6\x7a\x53\xe4\x63\x87\x2c\x48\x02\x76\x94\x85\x59\xd0\xd3\xee\xf6\x39\xc5\x19\xb5\xce\xb4\x32\x04\xca\x20\x86\x37\x4d\xec\x95\xa3\xa0\x54\x17\x44\x87\xd5\x19\x38\xa8\x2f\xfe\x23\xc4\x1f\xf6\xd4\x69\xc3\x05\x4d\xa7\xa1\xea\x69\x3e\xf5\xd7\x94\xf1\x0e\x6b\x2b\xfe\x3c\x4d\x12\x6f\x45\x69\x22\x50\xdf\xe3\x28\xb6\x23\xab\x5a\x64\x25\x5d\xd4\x34\xd4\x7f\x29\x8d\x37\xad\x36\x5c\xea\x04\x22\xbc\xf1\xb9\x52\xe2\x36\x4e\x6d\x6e\xb0\xbf\x7e\xe8\x5b\x08\x69\xe9\x15\x3a\x76\x25\xfb\x43\x23\xd3\xd7\xbc\x08\xeb\x44\x83\xe7\x9d\x83\x2a\xe0\xf5\x21\x30\x0d\x1a\xd4\x75\x9e\x15\x31\xe7\x01\x89\x3e\xd9\x1b\xda\x65\x0c\x2c\xed\x1d\x55\x03\x1c\xf6\xf4\x97\x68\x15\xd3\xed\x40\x38\xa6\xb3\x4c\xfa\x0b\xab\x46\x87\xdc\x5f\xda\xe7\x51\x43\x3c\xde\xb8\xb4\xe9\x06\xad\x48\xa4\x03\x0a\xed\xe7\xeb\x85\x48\xf9\x4e\xc6\x57\x35\x6e\x1a\x55\x31\xf2\x62\xc0\x03\xe6\xfa\x21\x56\xc9\x73\x06\xef\xf4\x3d\x97\x3e\x4d\xd3\xec\xaa\xce\x36\xe4\xc9\xb6\x2c\x53\x66\xe8\x94\xaf\xd6\x47\xda\x13\xe5\x23\x0d\x82\x7e\xea\x00\xe7\x61\x96\x16\x65\x90\x0a\x1e\x2a\x99\xd4\x8f\xbf\xfc\x7c\x34\x78\xf3\xf1\xe3\xf1\xc7\xc1\xe9\x9b\xff\x39\x65\x87\xac\xf5\x66\x36\xe1\x61\xc9\x23\x16\x30\xfa\x8a\x62\xeb\x11\x7b\x35\x8d\x93\x72\x33\x4e\x95\xe5\x82\xf6\xd0\x54\x00\xa3\x2d\x47\x42\x5e\xbf\x8a\xcb\x11\x86\x47\x09\xc6\x32\x56\x49\x50\xc8\x0b\xe8\x4f\x18\x91\xe0\x93\x6c\xc0\x80\x91\x06\x65\xfc\x85\xbf\x0f\x66\xda\xa3\x70\x20\x9d\xf1\xca\x1c\xcb\xd7\x30\x09\x30\x03\x34\x8b\xc6\x1a\x17\xd9\x34\x0d\x79\x64\xe8\x02\xdc\xbc\x44\x3c\x11\x5c\x3d\x4e\xbf\x64\x9f\xe3\xf4\x92\x7d\x12\xd9\x9f\xd8\x34\x2d\xe3\x84\x05\xc3\x52\x40\x75\x15\xc4\x25\xd8\x94\x8d\xe3\x24\x89\x0b\x10\x45\x0a\x36\x0a\xbe\x70\xc6\x93\x60\x02\x7e\x69\x60\x03\x10\xc3\x4a\x82\xa2\x64\x65\x3c\xc6\x2f\x4f\xb7\x57\x01\xec\x4c\xd0\x23\x8f\x7a\x60\x1a\xe0\x29\x16\x66\x63\x5e\x20\xb6\x02\xf6\x29\x14\x47\x8c\x44\x21\x06\xcc\x07\x20\x05\x2c\x3d\xc4\x10\x78\xa4\x40\x17\x0d\xa3\x5b\x1a\xdc\x36\x03\xf6\x69\x98\x4c\x0d\x56\x45\xe5\x78\x0c\xba\xd7\x92\x43\xa8\x7e\x01\x88\x80\x76\x0c\xa6\x03\x1f\xa4\x65\xe4\x27\xf9\xa6\xe0\x13\x54\x48\xa3\x38\x0c\x4a\xce\xae\x46\x1c\xa7\x0a\x3b\x2b\xf4\xbb\x07\x39\x1e\x96\x69\x29\x23\xe1\x01\x5c\x6b\x05\x69\xb4\x25\xa6\x3f\x0f\xe2\x44\x7c\xf3\xe8\x92\xa3\x7c\xc1\x25\x6e\x01\x5f\xd9\xb4\x44\x64\xa8\x71\x14\xaa\x4d\xd1\x98\x26\x1b\xc0\xaf\xb6\xca\x57\x76\x9c\x91\x72\xb1\x57\xc5\x64\x8f\x9d\x4c\x2f\x0a\xfe\x8f\xa9\x8c\xc3\x23\x76\xe5\xa2\xbe\xb8\xd9\x5d\x38\x31\x18\xd4\x3d\x23\x70\x6a\x02\x95\xfb\x1f\xd7\x7e\xe7\xed\x90\x7d\x92\xc3\xff\x84\x4e\x31\xd5\xe8\x3f\xe9\x67\x21\x41\xce\xa5\x71\x47\xd7\x0c\x99\x50\x86\xc4\xa4\x1f\x6f\x12\x61\xe0\xe2\x42\xd9\x86\x54\xc7\x02\xad\x69\x34\xb2\x71\x96\x8b\x79\x0e\x52\x96\x09\x6a\x95\x41\xe9\x3d\xd3\x20\xc7\x23\x46\x81\x19\x71\xc1\x3e\x6d\xcb\x91\xe8\x71\x89\x44\x34\x39\xe9\x56\x69\x4f\xe4\x46\x62\xfd\x4b\xcb\x1f\x5c\x50\x12\xeb\x29\x9f\x95\x10\x1e\x41\x48\x4e\xe3\x38\x81\x50\xd0\xec\x53\xc1\xcb\x53\x84\xe0\x93\x22\x7c\x3d\xce\xa1\x00\x40\x01\x76\xc2\x39\x3b\x7b\x1d\x7c\x89\x23\x76\x94\xe5\x17\x41\x38\xca\x5a\x02\xa1\x65\x1c\x26\xd2\x41\x6a\xd1\xdf\xda\x0a\x8b\x62\x53\xc8\xdb\x9f\x0b\x70\x04\x2c\xf1\x13\xa7\x97\x9b\xe5\x28\xcf\xca\x52\x60\x75\x93\xcf\x26\x49\x10\xa7\x3c\xda\x94\x26\x33\xc5\x16\xf8\x44\x15\x1c\x2b\xe2\x65\x10\x27\x05\x88\x88\x88\xe2\x78\xa8\x59\x9a\x32\xf7\xfa\x34\xe8\x29\xcc\x4b\x0c\x0d\x7a\xb2\x7d\xbe\x96\xd9\xd1\x8f\x64\x16\x95\x41\x91\x4a\xbb\x81\x39\x86\xe5\x62\xf8\x59\xa6\x49\xc0\x32\x42\x42\x33\xaf\x1b\x76\x26\xe6\xf2\x70\xfb\x1c\x83\x44\xe1\x06\x91\x0d\x6d\xa6\x06\x6d\x24\xc1\xdc\x6a\x40\x85\x8d\x3a\x93\xa4\x7b\xf8\xf5\x06\x1b\x51\xa4\x2c\x1d\x5a\xd2\x3a\xda\x8e\x49\x55\xea\x49\xba\x39\x04\x92\x39\x17\x65\xd9\x09\xbc\x95\x9a\x1b\xee\x2b\x49\x5e\x71\x0e\x0f\xc5\xfb\x47\xa6\xfa\x18\x07\xb3\x5f\x83\xb8\xc4\xd6\x05\x84\xe3\x60\x16\x8f\xa7\x63\x64\xc8\x86\xb1\x28\x87\x85\x28\xc7\x2b\x06\x7a\xc1\x87\x62\x85\x80\x31\xb1\x62\xcf\xcd\x63\x52\x6b\xf3\x50\xac\xe3\xe6\x31\x35\x2d\x63\xc7\x06\xcc\x4c\xb2\x92\xf1\x71\xd1\x5c\xf9\xb8\x9b\xc7\xda\x6b\x6b\x8b\xbd\x84\x07\x66\x61\x56\x94\xc9\x5c\x70\x3c\x08\xb3\x06\x73\x85\x4e\xc5\x89\x1f\xc5\x22\xfe\x27\x47\x2e\xc1\x86\xc9\x74\x06\x0d\xfe\xfe\xff\x4e\x79\x3e\x6f\x63\x89\x4e\x0f\x5d\x8f\x8a\x82\xad\x2e\x33\xe4\xde\x56\x0d\xf3\x77\xc1\x3c\x9b\x96\x5d\xb6\xb3\xbf\x0d\xef\x0b\x14\x18\x6f\x71\x6f\xf9\x54\xf0\x34\x7a\x1f\xc4\xc9\x27\xb1\x7f\xa4\x2c\x4c\xe2\xf0\x33\x8f\xba\xcc\x2c\x49\x56\x68\x26\x8d\x1c\x9a\xc2\xa1\x9e\x2e\x00\x20\x50\xd9\x86\x43\x35\xdf\x65\x4f\xb6\xb7\xc1\xe6\xf5\x11\x63\xac\x25\xc9\xa8\xa5\xad\x5e\x21\x55\x4d\x44\xab\xaf\x6d\xd2\xe4\xe3\x42\x05\xf5\x9b\xb4\x98\x0a\xe6\x7c\x11\x94\xe1\xe8\x5d\x76\x49\xf7\x22\x64\x9d\x28\x18\xec\x30\x5c\x36\x62\x36\xcd\xcc\x18\xe8\xd1\xe5\x80\x4a\x3f\xa4\x10\xab\xa6\xbb\x6c\x77\x5f\x40\xcc\x5a\x92\x74\x5b\x7d\xb6\xb3\xbd\xbd\xcd\xa4\x01\xf7\x17\x1a\x8f\x53\x50\x00\xd8\xed\x9f\x40\x4a\xbb\xb5\x55\x94\x39\x0f\xc6\x2d\x2c\x2b\x91\x25\xe3\x72\x02\xae\xa4\x60\xd7\xea\x1a\x38\xe8\x40\x8f\x40\x86\xb0\xc9\xd3\x00\x6c\x6f\x70\x3e\x9a\x98\x64\x13\xc1\xd7\xac\xf6\x7b\x28\x98\x40\x37\xc4\xd6\x4f\x8f\x5c\xa4\x74\x99\x60\x45\x1e\x47\x04\x62\x8b\x7d\x99\x5f\x6a\x37\x73\xe2\x5b\x1c\x02\xd5\xb7\x44\x92\x89\x9b\x03\xb1\x67\xd4\xdb\xa1\x78\xcc\xf3\xb7\x11\xad\x7b\x14\x24\x89\xd8\x52\x68\x1a\xd2\xa4\x48\x65\x87\x6c\x5b\xe7\x48\x96\x73\x68\x3c\x40\xc8\x0e\x3d\xa9\x1a\x59\x87\x32\x56\xc1\x03\xeb\x99\x0f\xb0\xe6\xef\x2c\x4f\xc9\xea\x19\x3d\x44\xdb\x17\xf3\x68\x22\xee\x3b\x22\xb6\x7c\x66\xc8\x00\x45\xa2\x03\x29\xcb\xb7\xc5\x37\x38\x4d\xdd\x56\x81\xf8\xb5\xb7\x67\xfd\x94\x5e\x76\x63\x06\xf3\xdd\x77\x0e\xfb\xc5\xb7\x38\x7a\x58\x9a\xec\xc0\x09\x88\x72\x25\x43\x50\x0d\xe7\x76\x28\xfc\xc2\x48\xe1\x6d\x0d\x94\xc3\x78\x11\x3e\x9c\xde\x0e\xeb\xab\x46\xb0\x45\x82\x35\xb3\x08\x49\xbf\xec\x05\x01\x57\x17\xee\xeb\x7a\x55\x67\x64\xb8\x26\x05\xbb\x6c\x8b\xc9\xb7\xa2\xad\xa1\x4b\x0b\x97\xa0\xf0\x85\xd9\xcb\xfc\x52\xe6\x9d\x82\x0e\xe1\x81\xa2\x8d\x97\xa6\x96\xd4\x3d\x10\xa7\xa5\x5e\x02\x12\xfd\xaa\x57\xab\x05\x3e\xad\x11\xe0\x91\x37\xa4\x2f\xf3\x4b\x78\x46\x5a\xd8\xaf\x5b\xb1\x78\x75\x4c\x72\x9e\xde\x44\x97\xdc\x1a\xd4\xd6\x16\xfb\xc8\x0b\x5e\xb2\x20\x9d\xb3\x4f\x12\xb1\x28\xb2\xe5\xbd\x45\xb0\x6d\x6d\xb1\x93\x32\x00\x0b\x18\xdc\x74\x72\x79\x22\x73\xf6\x25\x6c\x48\x2e\x24\x88\x06\xa2\x24\x32\x80\x25\x7f\x33\x9b\xc4\xb9\x60\xdc\x30\xc1\xba\xed\xb7\xfa\x08\x61\x6d\xdd\x3d\x3a\x5e\x95\xf1\xa2\x3a\x6b\xfd\x5a\x64\xe4\x7c\x1c\xc4\x69\x9c\x5e\x8a\xc1\x56\xe6\x58\x7c\x9f\x08\xe9\xe9\x9d\x5c\xea\x72\xcc\x6c\xd3\xbb\xf8\x99\x5d\x41\x02\x6d\x55\x31\xe8\xa3\xb1\xd5\xe4\xbc\xc2\x82\xdc\xac\xf6\x6a\x07\xc7\x72\x57\x4b\x9c\xea\x78\x80\x6a\x49\x6d\xfa\x00\x69\x42\x03\x9e\xb2\xb0\xdc\x37\xc5\x82\x1c\x9a\xd8\x13\x63\x38\xf6\x95\xa8\x5a\x85\xa9\x1e\xc6\x79\x81\x9b\x75\x97\x05\x61\x19\x7f\x89\xcb\x39\x28\x64\x8b\x32\x9b\xc0\xb3\x80\x34\x62\x57\xbc\x95\x73\x16\x94\x78\x28\xc4\xb6\x2c\x92\xeb\xa2\x32\x60\x5e\x94\x5c\x8a\x69\xa2\x89\xcb\x2c\xe5\xec\x22\x08\x3f\x5f\x81\xc6\xd7\xb4\x24\x36\xbc\x32\x4e\x2f\x55\x5b\x71\xc9\x82\xa2\x4a\xc8\x5d\x96\xe5\xa2\xc6\x17\xce\x46\x31\x92\xbd\x59\x33\x49\x3c\x8e\x4b\x8b\x38\xdb\x14\x53\x8e\x8b\xd0\xeb\x6b\xd6\xae\xe2\xf8\x87\x43\xa6\x18\xb2\x44\xac\xa7\xd0\x5f\xd9\x36\xba\xb9\x96\x44\xb1\xb1\xe1\x45\xfe\x0f\x87\x8a\x34\x3a\x1e\x8f\x8b\x74\xe1\xb5\xdd\x89\x17\x52\x41\x76\xd5\x26\xae\x20\xab\xb4\x52\x7d\xaa\x29\x31\x65\x78\x0c\xf5\x05\x89\x8c\xc6\xe6\x16\x4b\xf3\x05\xcf\x82\xf5\x0d\xa9\x02\x80\xda\x1f\x75\x0f\xd4\x59\xb4\x84\xea\x38\x35\xda\x8a\x78\xc8\xae\x38\xaa\x60\x3e\x29\xc6\xfd\x09\x75\xf5\x60\xd9\x56\x28\x61\x5f\x10\xd3\x05\xe7\xa9\x6a\xc4\x88\x37\x41\x29\x78\x52\x51\x82\x44\xd7\xd3\xf8\xd3\x64\xb4\xb1\xa1\xb7\x84\x0a\x06\x5d\x16\x46\xf1\xb7\xd4\x3e\xb2\x60\x13\x40\x19\xaa\x4d\xbd\xb4\x28\xd4\x58\xd1\xa1\x89\x97\xa0\x84\x07\xb9\x35\x27\x6f\xa3\x0a\x58\xb6\xe8\x73\xe0\x03\xd7\x2c\x02\x0a\xbd\x77\x5e\x5c\xa0\x41\xcb\xe4\x5e\xf1\xe8\x9a\x8e\xdb\x5d\xc9\x55\xfb\x36\x2d\x00\x2d\x7b\x08\x46\xcf\x5a\xed\x02\x30\xec\x2d\x2e\xde\xaa\xa3\xd7\xa1\x87\x73\x56\x77\x7b\xad\x4c\x32\x08\x51\xc3\x06\xe9\xc0\x15\x26\xf5\xce\x4a\xfc\xa6\xa8\x2e\xed\x38\xa9\xde\xc1\x5b\x31\x48\xad\xbd\x11\x50\x40\x7b\x72\x9e\x6a\x63\xa3\xc8\x4b\x68\x2b\x5b\x5b\xec\x6f\xe8\x43\x9e\xea\xfe\xe2\x14\xf4\x27\x97\xa3\x92\x25\x59\x36\xe9\x59\xfc\x7f\xf9\xed\xdd\x4f\xf5\x0d\x50\xde\x54\x48\xb6\x66\xf8\xb7\x83\xe3\xa6\x6e\xdd\xb0\xca\xd9\x03\xdc\xe2\x88\x1f\x07\x56\x26\xd0\xa7\x90\xcf\xc4\xbf\xe4\xf6\x41\x97\xf0\xbf\x2a\x52\xd9\x55\xa5\xff\x7a\xae\x62\x05\x05\x9f\xc0\x5b\xba\x3a\x7f\xa9\x4f\x24\x55\x5f\xf2\xf2\x63\x70\x75\x1a\xd4\xb9\x38\xdc\x7f\xb2\x23\x4b\xa2\x22\xe6\x34\xc3\xf0\x3b\xb5\xc5\x75\x88\x14\xf9\x60\xef\x3f\x4b\x59\x43\xbf\x91\x36\xaa\x7b\xa3\x83\x9f\x26\x09\xc2\xd0\x3a\x93\xef\xbc\x7e\x9e\x26\xc9\xb9\xf4\x13\xa0\x27\xd8\x29\xf3\x8b\x4a\x3f\x6f\xc9\x4e\xf5\x35\x01\x3e\x85\xf3\x74\x55\xcc\xc7\x6a\x0c\xd8\x9a\xc4\xd3\x0b\xf9\xa3\x57\x92\xdc\xbe\xb5\x57\xe8\x5b\x64\x0e\xaf\xc7\x58\x3c\x9e\xa0\xf2\x40\x07\x76\xff\x74\xc9\xcb\xd3\xe0\x12\x55\x8c\xd9\xb4\x14\x47\x3b\xf0\x0d\x86\xb7\x14\x17\xd3\xcb\xcb\x39\xe3\xe9\x97\x38\xcf\x52\x8c\xd5\xaf\x74\x78\x93\x3c\xfe\x12\x94\x7c\xf1\x53\xc0\x7f\x88\x93\xb2\xa3\xd4\x29\x64\xac\x76\xaa\xd2\xf9\x44\xc6\xf1\xa9\x67\x1f\x98\x05\xf4\x3f\x01\xa4\xf4\x65\xb4\x58\x56\xfa\xf9\xb3\x74\xe6\x48\x17\x86\xca\xb3\x99\xad\x35\x37\x7d\x35\x93\x6a\xf9\x28\x19\xc8\xc1\xfa\xc6\x86\x3b\x0f\xb1\x0a\x9b\x25\x21\xea\x40\xcf\x2f\x0c\x7d\xca\x74\x48\xee\x3b\xc4\x28\xf3\xfc\x6b\xcc\x0c\xb6\xba\xca\x96\xf1\x23\xf0\xcd\x1f\x6a\x7f\x08\x26\xb5\xd7\x6b\xfb\xe8\xc6\xf6\x0f\x7c\xa3\x0d\xd0\xfd\xf1\xcf\xb3\xf7\x1b\xdf\xd8\x7f\xeb\x77\x97\x3a\xda\x39\x4e\x4c\xbd\xc5\xdf\xf3\xd5\xac\x1b\x3d\x3d\x0c\x8c\xbf\x0d\x9f\x89\x54\xba\x5c\x74\x76\xd5\xda\x8a\xd6\xe1\xa6\x21\xa5\x57\xae\x1d\xfa\xce\xd3\x3b\xec\x63\x8d\xc1\x7b\xdb\x5b\xf5\x9d\xa4\x1d\xe5\xbe\x6e\xd2\x77\xee\xa6\xf9\x35\x06\xed\x36\xb5\xea\xdb\x48\xf0\xa1\x53\x3f\xc5\x6b\x36\xbb\xc6\x00\x75\x1b\xab\x81\xb0\x07\x4e\x6f\xc0\x2d\x64\xbd\x99\xf9\xf6\x5d\xb4\xbd\xc6\x18\xed\x86\x56\x03\x66\x1f\x7d\xe6\xa5\xc1\xb8\x61\xa0\xbb\x77\xd1\xf6\x1a\x03\xb5\x1b\x5a\x0d\x98\xa7\x83\xc1\x29\x9f\xd5\xd3\xea\xd3\x15\x39\xf1\xb3\xc1\x60\x5a\xc6\xc9\x00\x02\x1c\xfd\x52\xc6\x49\x3d\x1a\x77\x9e\xac\xd6\xc5\x73\xd9\xc5\xeb\xa0\x0c\x16\xf4\xf0\x6c\xb5\x1e\xbe\x97\x3d\x7c\xc8\x92\x20\x6f\xee\x02\x7d\xca\x3f\xb0\x83\x65\x31\x15\x9e\xb0\x27\x1d\xd2\x5f\x5f\x13\x93\x28\xed\xc5\xcc\x78\x02\x8f\xd9\x21\xdb\x39\x60\x31\xfb\xab\x39\x11\x4b\x9f\xa1\x07\x2c\x7e\xfc\xb8\x23\x5d\x8b\xeb\xeb\x28\x5d\xea\x2c\x3e\x3f\xa8\x78\x14\x97\xd7\x50\xb7\x71\x2a\x8e\x55\x94\x5f\xf1\xaf\xd2\x51\x96\x32\x1a\xc3\x5c\xe2\x5c\xfc\x46\xeb\x18\xd0\xe5\x1a\xbb\xb1\x24\x9c\x32\x3b\xca\xd2\x62\x3a\x16\x32\xd5\xcb\x3c\x0f\xe6\xed\x20\xcf\x15\x3c\x90\xd0\x8b\x0b\x93\x51\xc1\xc5\x36\xf8\x57\xd9\x65\x87\x4c\x17\x92\xe8\xe8\x28\x2c\xe5\x2e\x7e\x44\x85\xb3\xf8\x1c\x90\x93\x03\x5a\x6e\x8c\x99\x61\xbe\x4b\x9c\xb4\xcb\x54\x84\x63\x98\x67\x63\x00\x42\x3a\x43\xd7\x7f\xe8\x5d\x36\x2f\x79\x11\x07\xe9\xdf\x63\x7e\xf5\x2a\x9b\x9d\x8c\x82\x09\xba\x07\xba\x1d\x37\xeb\x05\xbd\x42\x54\x85\xc0\x2b\xb3\xfe\x2a\xf5\xf1\xbe\x5d\x88\xa6\xf3\x35\xeb\xcb\x80\x2c\x6b\xb5\x31\xe2\xf1\xe5\xa8\x5c\xa3\x91\x07\xca\xca\x7c\x22\xd6\xd8\x5d\xa2\x37\x5c\x17\xbf\xe1\xba\x08\x26\x21\xda\xd7\x6c\x89\x04\x75\x5f\xb3\x25\x1a\xdf\x7f\xad\x86\x54\x70\xf2\x75\xe7\xfe\x81\x72\x60\xad\x5c\x0a\xc2\x81\x0f\xe9\x60\xa5\xb6\x89\xfb\x3e\xef\xb2\xed\x56\x49\xed\x1c\x54\x37\x18\x19\xbd\xe4\xf9\x4a\xdd\xc2\x9d\xba\x39\xab\xae\x07\xf8\xea\x33\xb3\xd2\x9a\x91\x5e\x0b\x81\xd2\x86\xc3\x82\xaf\xb3\xa0\x21\x6e\x43\x56\xc4\x62\x03\x58\x1d\x0d\xed\xb3\x56\x99\x4d\x20\x4a\x20\x1f\x42\xd8\x36\x78\x9f\x21\x7e\x5c\x64\x65\x99\x41\x18\xc1\x38\x2d\xe2\x88\x8b\x5f\xd9\xb4\x54\x3f\x31\xf1\x9d\xac\x85\x5f\x1f\x55\x5d\xfc\x3c\xc5\x96\xf1\xe3\x95\xd3\xdc\x69\x36\xb1\x2b\x63\x01\x3b\xed\x34\x9b\x38\x6d\x62\x29\x27\x11\xee\x7b\xcd\xe7\x9b\x14\xe2\x1e\x72\xfc\x27\xe4\xe2\xf8\xdf\x42\xb4\x13\x37\x97\xdf\x9a\x70\xc0\x71\xd8\xf1\x70\x69\x81\x9a\xce\x78\x16\xf1\xce\x4a\x24\x27\x6a\xca\x91\x0b\x11\xf6\xe7\x60\xbc\xda\x9a\x41\xd2\x85\x76\xb2\xb4\xe4\xe9\x6a\x94\xbb\x1e\x02\x95\x13\xd2\x55\xb9\xc6\x79\x07\xac\xd9\x49\x70\x14\x15\xa2\xe0\x2b\x59\x90\xfb\xba\xd0\x25\x2f\xdf\x05\x17\xa0\x62\xa7\x8a\x29\x48\xc3\x70\x05\xc6\x98\x47\x85\x13\x44\xa7\xb0\xe8\xbf\x4b\xaa\xfe\x35\xbb\xd3\xd9\x3a\x05\xae\x55\xd0\x16\x08\xfb\xb9\xfd\xe1\xbb\x2d\x23\x27\x68\x47\xb4\x1d\xf6\x42\x42\xd3\x77\x42\x37\x68\xd3\x9d\x15\x95\x1b\xed\x4e\x5b\x43\xde\x71\xb4\x73\x3a\xa3\x0d\x43\xe9\xb8\x71\xf1\x20\xf5\x80\xa2\xf6\x35\x4f\xca\x00\x76\x36\x07\xbf\x26\xa3\x6d\x36\xd1\xae\xde\x07\x0d\xce\x65\xe8\x29\x15\x59\xfe\x36\xe7\x97\xb3\x87\xa3\x87\x6c\xeb\x11\x1b\x07\xe5\xe8\x44\x34\xf3\x68\xeb\xbc\xd3\x56\x5d\x40\x24\x43\xd5\x33\x0c\x05\x69\x86\x00\xac\xcc\xef\xdb\xf0\x23\xb8\x28\x6a\x2a\x77\x19\x3a\xa5\x32\x98\x00\xa8\x1f\x91\xd6\x0c\x56\xd0\xdd\xb0\x10\x3f\x82\xa4\x42\x79\x95\x4c\xc4\xf4\x07\xf4\x81\x0c\xbf\xbb\x2c\x28\xcb\x9c\x50\xa5\xda\x1f\xe0\x82\x53\x15\xee\xa9\x54\x1d\x6f\x15\x77\x68\xbb\x90\x4c\xd4\xc1\x41\x61\x75\xd8\x45\x30\xad\xab\x2f\x65\x25\x7f\xb1\x0b\xe9\x64\x85\xc6\x50\x74\x24\x5b\xef\x85\xba\x83\x70\x4e\x93\xe7\x2a\x99\x88\x76\x24\x9f\xa4\x6a\x00\x8d\xe4\x46\x0a\x92\x54\x13\x2c\x55\x4d\x0e\x29\x47\x08\x4d\x16\xd3\xd3\x69\x0a\xa9\x24\x33\xe2\x2c\xfc\xfc\x6b\x5c\xd0\x32\x3a\x4d\x2f\xed\x5c\xc1\xd4\xa6\x63\x79\x4c\x01\xee\xb0\x2d\xb6\xeb\x25\xb3\x25\x96\xc3\x81\xbd\x1a\x48\xf5\x1f\x0e\xd9\x36\x7b\xc1\x76\x58\x9f\x6d\xee\x1c\x50\x4e\xa3\x47\x06\x91\x19\xd4\x78\xf0\x41\x24\x92\x0b\x89\xd9\x20\x38\x86\x21\xa4\xc3\x43\x7b\xd3\xd5\x66\x78\xb4\x5d\x82\xe3\xc7\x8a\xe0\x91\x5a\xf0\x7e\x93\xf6\x44\x30\x66\x85\xc6\xf1\x75\x29\x36\x76\x6f\x87\x74\xf1\x35\x77\xf7\xdd\x72\xfd\xf1\x85\x3d\xdd\x72\x60\x02\x93\x34\x97\xcc\xd3\x5f\x71\x9e\x4c\x6e\x9f\x7d\xa7\x3f\x34\x1d\x01\x4e\x3f\xc8\x48\xd5\x0b\x79\x9e\x4f\xa3\x72\xf6\x90\x03\xd3\x03\xb1\xfc\x34\x3b\x52\x42\x3b\x32\xbf\x70\xd6\x65\xe1\xbc\x2b\xe9\xb5\x4b\x46\xad\x49\x8c\xa7\xd1\x1f\x02\x00\x7b\xcc\xda\x06\x3b\x8a\xa2\x3b\xec\x11\x43\xdf\x91\x92\xd9\x05\xe5\x88\x1d\xb2\xd6\xfb\x96\x98\x1b\x8d\xad\xde\x8c\x3d\x66\xad\xae\x93\x38\x17\x89\xff\x5f\x2a\xe6\xec\xa5\xc8\xca\xd5\xb2\xc4\x92\xe4\x73\xbb\xbb\x03\x49\x16\x04\xdb\xac\xcf\x76\x3a\x90\x8f\x8d\x40\x08\x26\x89\x1e\xd2\xa3\x4e\x9a\x2b\x28\xe3\x68\xe5\x2d\x2b\x06\xe4\x4d\xd3\xf8\x1f\x53\xfe\x36\x42\xa4\xb5\x72\x1e\x8e\x82\xbc\x2c\x36\x73\xd8\x19\x36\x93\x38\xe5\x9b\x2d\x6b\xc7\xb9\x85\xa6\xbb\x17\xf4\xf0\xe9\xe3\x1b\x94\xb5\xda\x40\xd5\xad\x92\xcf\x54\xf0\x06\xa5\x72\x83\x88\x6d\xb0\xdd\x74\xb5\x91\x43\x94\x8d\xe3\x34\x48\xcb\x57\x41\xc1\x05\x1c\x7d\x14\xbe\xf3\x20\x69\x55\x76\x89\x26\xf9\xd1\xaf\xb8\x6d\x7b\x46\x7b\x11\xe4\x9b\x40\x27\xad\xae\x69\x1a\xef\x64\x6f\xa4\x99\xc0\xda\xa3\x67\x70\x7d\x59\xe8\x21\x40\x84\x01\xf9\x7b\x9d\xc6\x5b\x82\x60\x5b\x5d\xf6\x95\xc5\x51\x9f\xc5\x51\x97\x45\x7d\x24\xe2\x1b\x1c\xc1\x1d\x0e\x40\x4c\xe0\x07\xe8\x4e\xa6\x7c\x65\xb3\x24\x4e\x3f\xff\x2d\xe7\xc3\x3e\x6b\xfd\xa7\xa0\xd5\x38\x62\x37\xc6\x76\xfc\x82\x27\x08\xc4\x03\xc6\x3a\x96\xe0\xf6\x52\x4c\xfa\xf1\x10\x16\xb6\x4f\x3e\xae\xe4\x57\x64\x65\x2d\x6f\x4c\x1a\x45\x8d\x89\x47\xca\x20\x12\xcd\xc4\x12\x66\xfe\xf7\x88\x17\x9a\xe3\x8f\x63\x5d\xa6\x6d\xed\xa8\x46\x14\x06\xb9\xc1\xbb\x47\xab\x93\x3a\xb5\x21\x1b\x54\x18\xef\xbd\x32\x72\x8a\xb3\xc7\x72\x5a\xbb\x7a\x54\xc4\x8a\x6d\x20\xe6\xac\x02\x5c\x6f\x46\x4a\xcc\xbd\x25\xe6\xb6\x39\xb2\xe2\x43\xb3\x3e\x1b\xe8\xca\xf3\x3e\x1b\xe8\xf9\x16\xeb\xe0\x65\x1a\x8e\xb2\x5c\x14\x11\x12\x52\x38\x63\x2f\x58\x0b\xd0\xdb\x62\x7d\xa9\x34\x50\x82\x31\xcf\xc1\x79\x82\xaa\xd1\x1a\xc7\x51\x94\xf0\x16\xf2\x17\xbd\xad\x57\x91\x2f\x55\x0e\xce\x19\x89\x80\x17\x52\xf0\x42\x2f\x78\xaa\xb3\x5b\x02\x03\x22\xe7\x32\xd2\xe6\x83\x1a\x9a\xd8\xbd\xe7\xdd\xdd\x43\x01\xde\xe9\xdf\x35\xf3\xef\x9d\xfc\x5d\x39\xfb\x16\x72\x67\x7d\x26\x6b\xcd\xfb\x4c\xa2\xb5\x1e\xa9\x0d\x28\xbd\xf1\xb1\x3c\xdd\x77\x03\xdb\xb3\xcb\x7c\x53\xd6\x47\x39\x9f\x85\x3b\x95\xa8\xe9\x0c\x6e\x24\x48\x06\x7c\xab\x4c\xbc\x6a\x20\xb9\x98\x60\x04\x51\x3c\x68\xc8\x62\xce\x21\xc3\xbb\x1c\xca\x6c\xd2\xb0\x16\x84\xb4\x84\x00\x6d\xb1\x5d\xb2\x2c\xe6\xae\x30\xbf\xd2\x2a\x11\xeb\x79\xe1\x7a\x95\xaa\xce\x55\x60\x7c\xac\x10\xf1\xf8\x0e\x80\x45\x36\xb4\x10\x5c\x50\xd5\x36\x01\xbb\xe9\x00\x61\x43\x4a\x86\x60\x41\x77\x27\xac\x0f\xd5\xc7\xcb\x60\xf2\xf1\x4a\x40\x22\x8a\xd6\x06\x93\x68\xaf\x9b\x61\xfd\xc3\x61\xfc\xb8\x34\x42\xff\xc0\x59\x37\xfa\xfe\xd5\xd6\xd0\x37\x5b\x3a\xd6\x5d\xc4\x5a\xeb\xfd\x9b\x31\x27\xfb\xba\x64\x05\x6a\x5d\x0c\xe7\x02\x82\xbd\x15\x6e\xf5\x95\xcd\x1a\x24\xbb\x18\xe2\x46\xaa\x5d\x81\x16\xd6\xe4\x04\xcb\x10\xc3\x02\x24\xdf\x82\x16\xe8\x1d\xd8\xfa\x8c\x61\x19\xd8\x1b\xd1\x5d\x03\xf9\x4a\xd6\xa3\xed\x8e\x1e\x71\x87\x6d\x6c\x28\x63\x9a\xdb\xaa\x4a\x86\x20\x89\xc6\x85\x74\x0d\x04\x12\xa8\x6a\xb7\x37\x83\x77\x6a\xab\x35\x7c\x29\x1b\xfe\xc0\xf3\x10\x1d\xf7\xdb\x2d\xdf\x1b\xd0\xf3\x7b\x03\x7a\xde\x71\x2f\x73\x1c\x22\x5a\xad\xd3\x0b\xe8\xf4\x92\x97\xb2\xd7\xbf\xc3\x9d\x94\x83\xaf\x2e\x52\x68\xc7\xa1\xcc\xfb\xeb\x71\xde\x95\x64\xdf\xb9\x13\x3a\xaf\x1c\x3e\xaa\xfb\x46\xcd\x2e\xbc\xee\xa9\x24\x2e\xe0\xec\x45\x0f\x21\x32\xa9\x2d\xe5\x76\xcb\x0f\xd8\xdd\x51\xa4\xd1\xad\x48\xb5\x90\xee\x7f\x95\x13\x4f\xed\xa1\x46\xcf\x42\xfd\xc5\xea\xc2\x18\xf5\xf2\xaa\xda\xe4\xe3\xb7\x56\xde\x41\xea\x7f\xd1\x8b\xab\x89\x7d\x67\xe5\xbb\xdb\xaa\xd6\x72\x1e\xa0\xb4\x5a\xac\x5f\x29\x85\x71\x55\x21\xf2\xba\xc2\xc8\xf5\xf5\x6a\xd7\xbd\xf2\x85\xcc\xc6\xc6\x6a\xd5\xcd\x3d\xf1\xc6\x06\xfb\x6e\x21\x5d\x68\x1d\xe3\xd9\xc3\xb8\xf8\x7b\x90\xc4\x91\xd4\x2d\x3e\x14\x87\x7a\x44\x28\x36\xb5\xfa\xad\xb2\x6a\xc6\x61\x43\x2a\x9c\xaa\xde\x51\xee\x06\x58\xa7\x97\xdb\x34\x1a\x26\x59\xca\xab\x4d\x62\x88\xf7\x42\x7b\xb3\x58\xef\x8e\xbd\x06\x4e\x99\xdc\xa6\x5d\xa9\x3b\x85\xc2\x52\xc6\xba\x7c\xe0\xc0\x31\x32\x70\x6c\x18\x54\x36\x28\xf3\x97\x51\xfe\xf8\x4c\x8e\xcf\x1e\x7e\xd6\xdc\x17\x3d\xba\xc2\x1b\xb4\x97\x65\x99\xc7\x17\xd3\x12\xc2\x8f\x9c\x77\x74\x8f\xda\xa9\x07\x01\x5c\x6c\x9c\xf5\xf7\x8c\x62\xb9\xd4\x5d\x09\x56\xf3\xe0\xfa\xce\x41\x60\xf5\x02\x7d\xe2\xb9\x3b\xb7\x10\xab\x1a\x7d\x29\x51\x63\xc1\xfb\xa2\x51\xd9\xdd\x5f\xa4\x13\xba\xd3\x1b\x9a\x25\xec\xce\xcf\x1e\x06\x30\x43\xca\x0c\xfe\xd1\xd6\xb9\x7b\xa3\xe3\x72\xbb\x35\xef\x68\xea\x2e\x66\xf4\xbd\x91\x85\x5e\xb9\x21\xab\x9b\x07\x7c\x3c\x07\x08\xeb\x45\x71\x31\x49\x82\xb9\x64\xc0\x2d\x48\x6c\x1d\xa8\x4c\xdb\x94\x87\x7e\xaa\x22\x4e\x20\x65\xfc\xad\x2c\x22\x83\xbc\xe0\x7f\xd7\x9b\x94\xde\xcc\x68\xba\xbb\xa7\x85\x66\x3b\x73\x6e\x18\x64\xa2\x56\xb4\x05\x52\x7f\x8f\xe9\x01\xbd\x01\xb0\x2e\x0a\x30\xbf\xf1\x9a\x00\x8b\xb8\x36\x08\xc6\xa8\x28\xd7\x49\xea\x96\x42\xa6\x5b\xd7\x13\xf6\x85\x07\x96\x58\x78\xdd\x21\xb5\x91\xd5\xcb\x0e\x83\x07\x4b\xdf\x88\x49\x46\xab\x9d\x4d\x74\x62\x99\x4d\xf4\x1d\x13\x1f\x9a\xad\x59\x7c\xb8\xda\x49\xcc\xf1\xeb\x26\x31\x0f\x3f\x7d\xf6\x18\x6a\x23\x37\xd6\x18\xcb\xee\x21\x4b\x0b\x42\x28\xb9\x0a\xb6\x75\x77\x6d\x4a\xd9\x94\xfa\x42\xb8\xbb\xc6\x67\x77\x0c\xec\xbc\xea\x6d\xe3\x2b\x6a\xe0\x51\xfb\xae\x0c\xdf\x71\x06\xb5\x09\xbb\x9c\xc3\x1b\xf9\xd4\xdd\x58\x60\xdc\x1d\x64\x65\x36\xb9\xe3\xb1\x0a\xfa\xac\x19\xae\x20\x69\x31\x60\x20\xe1\xe5\xc6\x7c\x2b\xa1\xe6\x4f\x30\xbf\x4d\xb3\xbb\x6d\x46\xb9\xed\x68\x00\xee\x0e\x94\xf0\xae\xc7\x16\x56\x07\xa7\xb8\x08\x5e\xcf\xc1\xab\x04\xc3\xc8\xa9\x39\x3f\xe1\xdc\xd7\xd7\x92\xc5\x83\x2b\x30\x87\x69\xf7\x0d\xfb\xf6\x96\xb3\x9e\x2d\x50\xc6\x4c\x0b\x59\x2f\x12\x28\x5b\xbe\xbe\x56\x9c\x5e\xfc\xb2\xea\x68\xb6\xd7\x37\x3f\x7d\xaa\x25\x7a\x20\x73\xb0\x61\xe5\x55\x8e\xbb\xe4\x1c\x0a\xfb\x64\xe5\x3e\xcc\xa4\xb6\xa5\x74\x65\x75\x03\xe7\x20\x34\x14\x5d\x20\xf2\x4b\x99\xf5\x10\x9d\xcf\xb9\x4f\xc2\xd7\x10\x9b\xde\x21\x58\x5f\xd9\x67\x3e\xef\xb3\x16\xf4\xb3\x19\x8f\x27\x49\x1c\xc6\x65\xab\x6b\x5e\x46\xa8\xe3\xda\x4d\xe7\x0e\x68\x9b\x1b\x52\x3c\xce\x4f\x4a\xc5\x5c\x00\x13\x7f\xe0\xe0\xba\xea\x35\x05\xa2\xfb\xb6\x43\x6d\x3c\x76\xc9\x69\x6e\x3c\xed\x2e\x3a\x12\x7d\x73\x04\x69\x23\x77\x9b\x7a\x6b\xa9\x61\x55\x5d\xe7\x7d\x0d\xcc\xc8\xf4\x1e\xd0\xf5\x89\xa7\x66\xf8\xd2\x43\xa8\xb5\xe4\x71\x61\xda\x86\xca\x47\x41\x92\xbc\x9a\x7f\x08\x72\x27\xea\x40\x35\xb7\x3d\x81\x7f\xa4\xad\xb2\xc5\x0a\x40\x9e\xfe\xcc\xc3\xcf\x90\xa9\x18\x89\xfb\x28\x93\xfd\xc0\x76\xc5\x06\x60\x9e\x61\xee\x9e\xdb\xde\xa1\xd8\x0b\x3b\xb3\x6f\x7b\xab\xfc\x8e\x40\x20\x68\x91\x7e\x6b\xbd\x91\xe8\xc1\x85\x65\x63\xc3\x2e\xdb\xcc\xb5\xe4\x78\x88\x62\xca\xd3\x8d\xbe\x49\xc7\x4c\x73\xf8\xb0\xcf\x1c\xa6\x66\x47\xd7\xe0\x33\x9c\xa3\xa3\x51\x9c\x60\x07\x2b\x9e\xd6\xd1\xfc\x7d\x18\xa7\xd1\x4b\x31\x4d\xe2\x44\x24\x37\x46\xa5\x43\x43\x75\x5e\xa7\x37\x0e\x26\x6d\xf3\x96\x16\xb2\xbb\x2c\x4e\x23\xee\x6e\x19\x6b\x29\x52\xb0\x59\xb5\x07\x57\x68\x56\x1c\xf0\x29\xb2\xd4\x4e\x47\xe9\x17\x6c\xd8\x04\x5c\xb8\xd5\x21\x09\x1b\x5d\xc3\x77\xce\xcc\x3a\xd0\x3b\x98\xa5\xd3\xa9\x16\x86\x22\x4e\xb2\xb9\x55\x28\xa3\x5b\x0b\xb2\x75\xe0\x3f\xb3\xda\x3c\xef\x85\x59\x1a\x06\x65\xdb\xf3\x8e\xd7\x81\xab\x23\x95\xae\xf2\x60\x6b\x1f\x5e\xe9\xa7\x3a\xfb\x7a\x97\x6a\x35\x11\x83\x1a\xa8\x77\xdb\x4a\x47\x20\xe3\x1f\x59\x51\x8f\xb4\x03\x13\x88\x28\xc7\x0e\x19\xf2\x9c\x4e\x25\x66\xc8\xd3\x3f\x93\x43\x14\x0c\xa2\x9d\x25\x0d\xd1\xc3\x77\x77\x9e\xff\xf1\xa1\xd3\x6d\x48\x85\xc0\xf0\xe7\x08\xda\xe7\xc2\x75\x79\x2f\x70\xdd\x3e\xbe\xa8\x0b\xd7\x70\x9d\xd8\xa2\xd8\x56\x12\x5c\xd4\x47\xa7\x7b\x7e\xe7\x31\x55\x57\x08\x2c\x4a\xe0\xbc\xaf\xb0\x8e\xb7\x8f\x7b\x6f\x43\xe5\x8b\xe9\x78\xcb\x70\xff\xe1\xf4\x82\x8f\x78\x12\x37\xc4\x9d\x7e\x7e\xe7\x61\x5e\xeb\x42\xd3\xdd\x06\x5a\x32\x27\xd5\x68\x84\xfb\xcf\xfe\x4c\x6c\x51\xca\xa6\x45\x96\x97\xaf\xe6\x0d\x3e\x37\x56\xf4\xc0\x52\xe9\xe0\x2e\x9c\x44\xa9\xb6\xfe\xed\x22\x6a\x1d\x1f\x4e\xcd\x01\x94\xf7\xb6\x57\x74\x2e\xe4\xb6\x7f\x17\x3e\xa2\x64\x53\xab\x3a\x73\xba\x57\x9f\x58\x6e\xf3\x6b\xb9\x8c\xba\x0b\x9f\x58\x7b\xaa\x15\x15\x96\xa5\x61\xc8\x2b\xae\x6a\x4f\x17\x6b\x79\x91\xaa\xb4\xb6\xaa\xbb\xa7\x7b\xf1\x06\xb6\x7f\x07\xde\xc0\xf6\xd7\xf3\x06\xf6\xf4\x1e\xbd\x81\x3d\xbd\x2b\x6f\x60\x4f\xef\xc0\x1b\xd8\xb3\x7b\xf4\x06\xf6\xec\xae\xbc\x81\x3d\xbb\x03\x6f\x60\xcf\x25\x41\x14\xe3\x2c\x2b\x47\xf5\x4b\x74\xef\x6e\x9a\x5f\x63\xb4\x6e\x53\x2b\x3b\xf8\x0a\xb3\xb4\x0c\xe2\x94\xe7\x83\x93\x69\x3e\x0c\x1a\xc2\x50\x7f\xbf\xea\xb6\xbb\x4d\x7b\x79\x17\xcc\x79\xfd\x61\x6f\xe7\xfb\x15\xfb\xd8\x11\x7d\x8c\x27\x59\xca\xd3\x72\x70\x9a\x65\x49\xd9\x10\xcc\x7a\x67\x55\xff\x9a\x3b\xbb\xb4\x9b\x77\xfc\x92\xa7\x51\xc3\x58\x56\x74\xbb\xb6\xf3\x64\x30\x00\x3f\x4e\x83\xa3\x69\xfe\xa5\x21\xa6\xff\x8a\x8e\xe3\x76\xf6\x74\xfb\x79\x56\x34\xf8\x74\xfb\x7e\x45\x3a\xdf\xd9\x57\x1d\x9c\x40\x28\xdf\x7a\x14\xed\xaf\xc8\x1e\x77\x9e\xaa\x1e\x5e\x67\xf5\x5b\xcb\xb3\x55\x5b\x7f\xa6\x5a\xff\xc8\xc3\x12\x6e\x88\xea\x27\x61\x45\xbe\xb7\xf3\xfc\xfe\x3d\x04\xee\x88\xf5\xad\x8c\x5c\x06\xda\xdc\xe5\xe5\x2c\xae\xef\x6b\x6f\x7b\x55\x37\xa4\xdb\xb4\xb3\x57\xf9\xb4\x68\x60\xa0\xdf\xaf\xb8\xce\x77\x77\xd4\xf5\xcd\xf1\xfb\x66\x9c\xed\xee\xac\x48\xbc\xbb\xbb\xf7\xee\x57\x71\xf7\x89\xec\xe2\x68\x14\xe4\x0b\xe6\x7e\x77\x45\xfa\xda\xdd\xbb\xa5\xf3\xc6\x55\xfa\xd8\x57\x7d\x4c\x73\xfe\x11\x94\x97\x0d\x4b\x7d\xc5\x3e\x9e\xca\x3e\x20\xea\x58\xfd\x18\xbe\xdf\xdb\x53\x07\xfb\x7f\xfb\xa0\x94\x28\xc0\x3b\xa8\x23\x21\x16\xb9\x21\xac\x69\x5c\x0b\xe2\x1c\x3c\xe6\x85\xc4\x89\x32\x9e\xac\xb8\xa4\x44\xd4\x28\xf3\xa0\x0a\x5a\x22\x5e\x84\x79\x3c\x29\x33\x6d\x02\x05\x68\x31\xc9\x3d\xe3\x66\x1c\xec\xc2\x7c\xe9\x62\x8e\x82\xa4\xe0\x56\xbd\x30\x4b\x87\xf1\xe5\x54\xd5\x84\x7b\x24\x40\xea\x43\xb8\x25\x7d\x28\xb0\x6d\x8a\x77\x68\xd5\xab\x3c\x2e\xad\x6a\x7e\xc7\xe8\x6a\xe4\xa4\x26\x04\x91\x26\xad\x1e\x50\x84\x1b\x8c\x1e\x65\x69\x51\xe6\x53\xb1\xd9\x01\xe2\xca\x4c\x5e\xaa\x61\xcc\xcd\x0f\x0a\x95\xf2\x7e\x5f\x66\x77\xaa\xc8\x27\x0d\x19\x2a\xa1\x4d\x76\x70\xcc\x56\xbb\x4d\xad\xd8\x20\x1c\x28\xd0\x49\x89\x03\xf0\x9b\xde\xb6\x7d\xb3\xa3\xe3\xfc\x5f\x31\x3c\x01\x69\x39\xbb\xf8\x1d\x08\xb3\x50\xf3\x8d\x38\x63\x87\xec\xeb\xcd\x01\xa5\x94\x18\x7c\xb7\xab\x31\x8b\x1a\x3d\xb8\x05\x3a\x1e\xb6\xe3\x0e\x3c\x4f\xed\xc0\x75\x6e\x9c\xaa\x69\xfc\x6e\xa9\xc5\x01\x00\xc4\x1d\x5a\x59\xae\x0f\xf0\x79\x9a\x5d\xfc\x6e\xfb\x3c\xd5\x8b\xe2\x7f\x89\x5f\x56\x33\x08\x87\x78\xd5\xcc\x98\x98\xe7\x0a\xf3\x64\x2e\xfc\x74\x6f\xaa\x7e\x55\x16\x07\x68\xd1\x5f\x0d\x09\xc0\xe8\x2a\x54\x69\x6a\x79\xe1\x37\xbb\xe9\x90\xc1\x88\x09\xb1\x42\xae\x9b\x61\x67\x17\xbf\x3b\xf3\x02\x27\xb8\xa3\x20\x49\x8e\x46\x3c\xfc\xdc\x8e\x21\x14\xb8\x60\x85\x84\x5c\xd5\xc0\xbe\xd3\xd9\x4c\xfd\xc8\x86\x56\x41\xe0\x9d\x9e\x68\x87\x0f\x8f\x82\x34\xcd\x30\x6c\x18\x0b\xd0\x0e\x96\x05\x05\x09\x26\xfe\xb0\x8a\xed\x49\x56\x14\xf1\x45\xc2\x49\x07\x18\x46\xa3\x5d\xf0\x64\xd8\x85\xc6\x34\x68\x22\xc9\xee\xfd\xa3\x8a\x30\x22\x41\x80\x20\x66\xa3\xa0\x48\x5b\x25\xc4\x86\x62\x71\x1a\x97\x71\x90\xc4\x05\x8f\xd8\x26\x2b\xa6\x13\x9e\xb7\x3b\x56\x09\xd1\x03\x8f\x10\x34\x65\x7c\x2e\x46\xb0\xb1\xa1\xa3\x3e\xc2\xf7\xe1\xe1\x21\x7b\x88\xeb\xf7\xa1\xe0\xa4\x95\x3c\x33\x4a\xf6\x02\x93\xfb\x4c\x40\xec\x4c\x46\x9c\x8e\x78\x1e\x97\x45\xbb\x98\x5e\xc0\x1e\xd2\x45\xb0\xe0\xb7\x1a\xaa\x6c\xdc\x64\xc0\xf5\xbf\xe9\x02\x42\x78\xd8\x99\x32\x64\x88\x7f\x6a\x4e\x44\x59\xc6\x67\x93\x9c\x17\x85\x00\x63\x3c\x2d\x4a\xc6\x31\xf2\xdb\x05\xc7\xc0\xf8\x59\x4e\xe6\xaa\xcb\xc4\x5c\x3e\x64\x8f\x59\x05\x16\x40\x95\x82\xde\xf0\x15\x23\x12\xe0\x06\xd9\x26\x00\x5a\xe0\x52\x0e\xfc\x15\x23\xd3\xe3\xcc\xf7\xcd\x42\x31\xc8\xa1\x6b\x05\x43\x75\x3a\x0b\xc3\xb7\x78\x04\x99\x29\x96\x4e\x90\x2b\xe1\x2b\xb8\xe0\xbd\x08\xc2\xf1\x90\xbd\xf0\xa7\xd7\x4c\x90\x81\xad\x37\x18\xc0\x48\x40\x78\x32\x45\x0e\x2c\x3f\xcf\x95\x3f\xc1\xec\x8e\x3f\xbe\x7d\xf3\xf3\xe9\xe0\xfd\xcb\x0f\xd2\x1d\xe3\x4c\x1c\x1e\xfa\xec\x8c\xb8\x21\x2d\xb3\x49\x0b\x6c\xd6\xe7\x2a\xcf\xf6\x59\x7a\xae\xed\x53\xb2\x3c\xbe\x8c\xd3\xa3\x2c\xcb\xa3\x38\x0d\x4a\x31\x11\x60\xbb\xb8\x0d\xb6\x8b\xdb\xcc\xb8\x76\x48\x79\x2e\x24\x17\x0c\x43\x1d\x87\x41\x02\x92\xb2\xed\xda\xc1\x5f\xa6\x3d\xc8\xf9\xd0\xd8\xb0\x20\x4b\xe9\xb2\x41\xc9\xc7\x93\xae\x20\x6a\xb5\xcc\xa4\x29\xba\xb6\x0d\x09\xf2\x52\x3d\x25\xca\xf9\xb0\xa7\x13\x94\x4d\xc3\x4f\x79\x30\x19\x61\x37\x71\x12\xa9\x62\x76\xaa\x7e\xc2\x94\xf3\xe1\x7f\x71\x21\xb0\x9e\x22\xbd\x41\x59\x9d\xa0\x2d\x12\x9d\x12\xb4\x8a\xfb\x7a\x29\x98\xc5\x05\xbc\x60\xb2\xca\x69\x83\xf6\x59\x5c\x1c\x29\xc5\x44\xa1\x3a\xb4\x53\x8d\x81\xf7\x25\x4f\xa3\x23\xfd\x08\x0b\x8a\x5a\x89\xb6\x8b\x4c\x31\xab\xef\x83\x89\x2a\x69\x25\x6a\x1f\x75\xb6\xb5\x3f\x14\xa4\x69\xfa\x5d\x19\x31\xf9\x87\x42\xc4\xee\x1f\x27\xc2\x9d\xcf\x5f\xf3\x60\x82\x71\x6e\xda\x30\x87\xa2\x62\x58\x91\x68\x07\x7a\x98\xca\x7e\xc4\xb0\xaf\x9a\x16\xbb\x8c\x54\x92\x0e\x6b\x74\x83\x35\x75\xe8\x8b\x03\xe8\xc4\xd9\xb0\x04\x57\xef\xd6\x55\x56\x9d\x48\xc2\x2c\x31\xbe\x5b\xc3\xc6\x82\xad\xd5\xc1\x4f\x16\xb5\x7e\x81\xda\xbb\xb4\x19\x43\x1d\x24\x1d\x94\xa5\xb0\x03\x1c\x93\x81\xce\x5d\x23\x58\x16\xe0\xb5\x87\x20\x27\xf8\xa4\xc4\xa5\x0c\x25\x7a\x84\x4b\x4a\xf6\xfa\x9a\x14\x23\x6f\x9b\x54\x2b\xd3\x49\x14\x94\x1c\x62\xb0\x6d\xab\x74\x6c\xaa\x50\x0d\x53\xdf\x66\xb4\x53\xc1\x95\x55\xf5\x3e\xdb\x96\x95\x6f\xba\xb2\x3e\x66\x41\xc9\xe3\xa1\x24\xd8\xe2\x18\x5e\x53\xbf\x4c\xa3\x93\x32\x08\x3f\xff\x94\x67\xd3\x49\xd1\x26\x76\x79\x00\xa0\x74\xd1\xca\x1a\xfb\xd3\x80\xdf\x74\x28\xf6\xb0\x6b\xf0\x06\x07\x38\x7f\xbb\x94\x67\x39\x9f\xd6\x61\x81\x6b\xb9\x96\xe9\xd4\x98\x0d\xab\xdb\x9a\xd7\x3c\x09\xe6\x34\x40\x1f\xc2\x55\xe6\xf1\xe5\x25\xcf\x79\xf4\x72\x58\xf2\xfc\x7d\x36\x2d\xf8\xfb\xec\xcb\x22\x5f\xf3\xb5\xf7\x4a\xed\x4e\xbb\xb1\xdd\x2e\xf3\x41\xe5\x46\x14\x54\x77\xf9\x26\xd4\xe1\x8d\x0c\xb8\xf9\x88\xf1\x22\x89\xd3\x72\x33\x8a\x0b\x38\xbf\x31\xd0\x7a\x6f\xa5\xd9\x66\x14\x47\x9b\xe3\x6c\x9a\x96\x9b\x05\x2f\x37\x91\x54\x1e\x6d\x3d\x50\x15\x1f\xc1\xbf\x8f\x74\xa8\x33\x09\x70\x97\xe5\x10\xc0\x18\xcb\xab\xf8\xc3\xa1\x59\x26\xb8\x11\xf4\x64\x6d\x15\x62\x0d\xa7\xef\x46\x52\x05\x72\x39\x19\x5b\xae\xcc\xd8\xb4\xe0\x32\xa6\xbc\x0c\x0c\x0b\x8d\x2a\xdd\x3e\x74\xa5\xda\x53\x96\xda\xaa\xc1\x5f\x47\x59\x82\x61\xf5\x49\x31\x35\x0a\x7a\x7e\xaf\xe7\x62\x67\x5f\x2d\xa3\x3b\xad\x9e\x7e\x1d\x47\xef\x05\x7e\x5a\xd6\x93\x5d\x12\xcc\xab\x52\xb2\x4d\xe9\x05\xe4\xd8\xdb\x5f\xb0\xb6\x3b\xc0\x55\x7a\xf2\xe5\xd4\x3c\x0d\xdf\x46\x1d\xda\x2e\x46\xbf\xee\x05\x51\xf4\x2e\x2e\x4a\xb1\x89\xb7\x49\x94\xc7\x1b\x8b\x34\x6e\x8c\xe9\xa1\x33\xb8\x5f\xe3\x24\xf9\xc8\x43\x1e\x7f\x41\x1e\xb5\x78\x90\x6e\x8d\x76\xca\x67\xe5\x07\x9b\x9d\x2b\xd7\x5b\x72\x17\x33\x03\xe9\x12\xf0\x19\x8b\x82\x32\xd0\x2f\x8e\x7b\xe2\xcb\xce\x27\x76\xa6\x03\xff\x0b\x68\xfc\x53\x0f\xaa\x06\x9e\x17\x55\xf8\xa7\xdf\x55\x0d\x7c\x0f\xab\xf0\x2f\x09\xe6\xd9\x94\x94\xc1\x6f\xbb\x4c\x21\x78\xdd\xb1\xf2\x62\x35\xd0\xcf\xda\x54\xa2\x5d\x7a\x1c\xe4\x97\x31\x81\x1e\xbf\x0f\x2c\x24\x11\xae\x6d\x78\x75\x4f\xa5\x1e\x3c\x78\x60\x11\x92\xc6\x35\x60\x0b\x4e\x01\xf0\xe3\xfa\x9a\x99\x2c\x44\x87\xc8\xc3\x5f\x56\xa6\xc4\x84\xc8\x95\x3f\xad\x6c\x89\x04\x91\x2d\x7f\x5a\xd9\x74\xfc\xa2\x0c\xfd\xbe\xbe\x5e\xe2\xb9\xb5\x57\xd3\xa9\x5c\x1b\x14\xa3\x20\x49\xb2\xab\x37\xff\x98\x06\x09\xf2\x68\xd3\x33\xe2\xae\x2b\x71\xea\xac\x04\xcf\x26\xba\xcc\x1e\x6a\x28\xf7\xc0\x5d\x56\x05\x97\x65\x96\xdc\x33\xf5\x34\x3e\x66\x3b\xa4\xad\x9b\x2e\x5b\x7b\x07\xd5\x50\x2e\xb9\x8b\x3e\x66\x3b\xb0\x93\x52\x6e\x60\x1e\xa1\x2d\x9e\x22\xef\x85\xca\xd9\xc3\xb1\x7c\xda\x71\x24\x97\xa0\x77\x96\x8c\x75\xb5\x7e\x86\x5f\x9d\xa9\x51\x50\xfc\x94\x64\x17\x41\xf2\x1a\xd7\xff\x6a\xdc\xd1\x5e\x0a\xd6\x0c\x8a\x4e\x52\x7e\xf5\x8b\x59\x5a\x76\x97\x2f\x0c\xb2\x6c\xbc\xb9\x8d\x0c\x0a\x4a\x4d\xf0\x61\xaf\x70\xe4\x61\xf0\x82\xfb\x6d\x1a\x71\x70\xf4\x87\x2b\xd8\x4e\xf7\xd5\x7a\x93\x46\x9e\x3a\x2a\x95\x82\xb2\xb5\xc5\x5e\x67\x69\xab\x94\xb0\xb2\x8b\x7c\x5a\x8c\x1e\xb8\xb0\xba\x52\x24\x25\xdc\xdb\xad\x06\x41\x58\x14\x96\xbe\xf5\xd5\x75\xc6\xdc\x77\xbe\x29\xf9\x2f\xbb\xb0\x06\x0e\x5d\x5b\xe8\x32\x34\x4e\x26\xf5\x8e\x16\x99\xd5\x91\xbb\xe0\xec\x3e\xd6\x83\xd1\x59\x90\x0f\xc8\xdc\x06\x51\xc4\x70\x83\xb7\x78\xfd\x1d\xc9\x0c\x0b\x7c\x57\x2c\xb5\xc2\x56\x16\x3f\x60\x7c\x39\x1f\x0b\xd1\xd8\x33\xc4\xbb\x92\x8b\x9a\x9d\x85\xac\x39\x44\x04\x7f\x5d\x21\xeb\x97\x74\xbc\x9c\x10\x49\x0a\x7f\x4b\x39\x72\xf1\x28\x19\xd5\x53\x36\x1d\x56\x74\xe4\xee\xc3\x43\xd6\x52\x03\x6c\x79\xfa\x6c\xae\x5f\x8f\x69\x73\x2e\x11\x67\x81\x9f\x78\x89\x87\x0f\xa5\x13\x54\xc1\xa1\x83\x24\x61\xb3\xcd\x60\x16\x17\x2c\xcb\xd9\x1c\x7e\xe9\x5a\xf2\x44\xe2\x1e\x49\xf4\xdf\xbb\xa0\xe4\x45\x89\xa9\xd5\x4a\x27\x32\x00\xb4\x68\x12\xd4\x4c\xf8\x77\x3a\xe2\xa0\x3c\x85\xde\xbd\xbd\xc1\x5d\xc4\x0d\x63\x97\x4a\xdd\xf5\xb6\xe4\xe3\x02\x2a\x2a\xe5\x7b\x21\x6a\xc7\x25\x1f\xd7\xc3\x5a\x18\x5e\xa6\xba\x8d\xa1\x9d\x4b\x91\xc6\x23\x76\x31\x87\xfe\xdf\x46\x2c\x48\x23\x2c\xae\x97\x9e\x39\x8d\xe1\x83\xe1\x1b\x77\x0f\x83\xf6\xe0\x11\x30\xbe\x37\x62\x30\xdf\x1c\x25\xcd\x82\xe7\x31\x2f\xf0\x98\x16\xe0\x4e\xc4\xe2\x82\x05\x93\x49\x12\xf3\xe6\x2e\xf4\x86\x27\x41\xe6\x69\xb4\x46\x07\xee\x09\x50\xff\x1d\x51\x3a\x50\xe5\xb7\x1e\xf8\xd7\xe8\x25\x57\x1a\xb8\xda\x95\x69\x8a\x28\x87\x2a\x83\x9c\x0f\x77\x2b\xa7\x1d\x91\xf8\x5f\x9a\x20\x50\x2d\xb7\xdb\x53\x09\xb6\x04\xe0\x16\x23\xf5\x5c\x7d\x25\x28\x8a\x95\xc2\xd2\x14\xb4\xdb\x7b\x29\x15\x94\xba\x5b\x95\x60\x17\x73\xa8\x4e\x15\xb6\x93\x3d\x27\x1e\x49\x6a\xaa\x3c\x49\xab\x1e\xe8\x6c\x61\x08\xca\x37\xc9\x42\xae\x24\xa4\x2b\x54\x05\x21\xf7\xe9\x61\xf5\xd1\xa1\x29\x87\xd4\xff\xdf\x7c\xce\x0e\x0d\xb2\x1f\xb3\xd6\xdb\xa8\x75\x40\xf7\x26\xc1\x3c\x04\x9f\x28\xc9\x02\x14\xe4\xf8\xd2\xac\x5e\xd5\x20\x5f\xca\x79\x50\x8d\xf4\xbc\xc4\x7b\x44\x35\x65\x1d\xcf\x50\x50\x6d\xfc\xf5\xe6\xc0\x3e\x0e\x02\x50\x1b\x1b\x00\x9c\xba\x37\xb5\xd8\xac\xa9\x0b\x0c\xd7\x90\xf2\xab\xf9\xcb\x19\x2f\x14\x41\x7f\x85\x16\xfa\xf0\xff\xae\x43\x25\x7d\xe7\xbb\xab\xf1\xd9\xd7\xbf\xba\x06\xdf\x7d\xf3\xb3\x96\x90\xfa\xf4\x63\x91\x38\xd9\x6d\x10\x45\x2d\x01\x93\x1c\x72\x1c\x3a\xdf\xd8\x70\xc6\x70\x5b\x5c\x41\x25\x8d\xac\xca\xca\xeb\xb3\x65\x96\xdb\x1a\x88\xfc\x06\xc8\x33\x84\xa5\xee\xd2\x71\xf0\xae\x8e\xd1\xec\xbc\x8d\x5b\xaf\xd8\x74\x2f\xe6\x90\x99\x4d\x44\x6a\xa1\x93\xd5\x32\x33\xcd\x2c\xd8\x8b\x3d\x5b\x31\xd9\x61\xd4\x8e\x0a\x6b\xc1\xfc\x9d\x3a\x0b\x5a\x64\x7b\x7a\x94\xb5\x6f\xb1\x1d\x2f\x16\x03\x5c\x29\xa0\x8b\x97\x7d\x6c\x53\x4a\x23\x5d\xbc\xe0\x63\x9b\xb6\x4c\x52\xd7\x30\xb2\x31\xd5\x30\xea\xb0\x59\x1c\x41\xeb\x29\xab\x69\xc0\x2f\x29\xdc\x4e\x50\x58\x2c\x29\xac\x2d\x28\x2c\x96\x14\xd6\x14\x14\x6a\x25\x05\x9f\x94\xb0\x8c\x98\x80\x8c\x73\x09\x61\xc1\xe6\xb0\x62\x5f\x7b\x52\x11\x19\x04\xa3\xd9\x95\x0c\xa7\xc2\xf5\xf5\xdd\xde\x93\x1e\xf0\xe5\xc5\x3b\xf9\x93\xc6\x9d\xdc\x91\x39\x9e\x34\x88\x26\x6a\xe7\x34\xe5\x9a\x19\xba\x2e\x7a\x3b\xc9\xe0\xc9\x6d\x25\x83\x27\x0d\x92\x81\x56\xdf\xd6\x6b\x6f\x17\x3a\xd4\x24\x03\x3b\xb6\x43\x15\x90\x34\x67\xa2\xe2\x42\xdd\x28\x04\xc9\x52\x17\x54\x3e\x9b\xd5\xb3\x87\x33\xa5\x5e\xd3\x8d\x01\x8f\x90\xfe\x53\x60\x2c\x7a\x06\xa9\x84\xb0\xb5\xc5\xde\x24\xf1\x18\xcd\x00\xa2\xe9\x24\x89\xc3\xa0\xe4\x91\xc5\xef\x1c\x31\x02\xa4\x85\x9c\x47\xd3\x90\x13\xcf\x07\x39\x2f\xe0\x5e\x07\x70\x52\x55\xda\x0d\x20\xfd\xbf\x94\x4a\x1f\xbe\x7c\x3a\x7d\xc6\xa4\x65\x08\xad\xd0\x2b\x2b\x64\x86\xf3\x2b\xc9\x8c\x16\x95\xc9\x6e\x69\xd0\x0c\xbf\x0e\xca\xe0\xf8\x0b\xcf\x87\x49\x76\xe5\xd6\xab\x14\x70\x5b\x28\xc2\x20\xa9\x00\x06\x89\x07\xae\x2e\x4d\xb2\x44\x6b\x98\x67\x7a\x19\x9c\xbb\x6a\x42\xe9\xbf\x8f\x47\x52\xa1\x89\xeb\xda\xd2\xb7\x5d\xf2\xf2\x35\x2d\xe5\x17\x26\x9a\x05\x86\xde\x30\x4e\x4a\x9e\x93\x39\x13\xbc\xbc\xe3\xb4\xa1\x37\x70\x91\x59\x01\x1d\xce\x17\xf8\x79\x60\x55\xbb\xe9\x34\x2d\xd8\x8a\x5c\x51\xbb\x52\x6d\x19\xa3\x56\x17\x08\x2b\x16\x56\xa2\x85\x3c\x65\xeb\x47\x27\x04\x14\x1f\x48\x9d\x72\x20\xe7\xee\x98\x61\x12\xb2\x71\x10\xa7\x95\xa0\x7f\x04\x4a\xb5\x38\x5e\x2f\x2a\x49\xae\x31\x9d\xb2\x16\x60\x08\x9a\xa4\xd7\xea\x34\x68\x80\x56\x65\x09\xa9\xf2\x38\x8a\x40\x1c\x0f\x05\x86\x5e\xcd\xc5\x9a\x01\xb6\x60\x61\xae\xab\xd6\x53\x17\x16\x60\xc7\x81\xd4\x28\x6f\x64\x04\x1f\x1c\xe2\xbc\x25\x84\x63\xca\x75\xaa\xe3\x90\xe8\x55\xd8\x5b\xfd\x12\x3e\x84\xf1\x8c\x82\xe2\xb5\x6e\x0b\xc7\x01\xc3\xeb\x1c\x2c\x31\x63\x06\x8a\x17\x0a\xbf\x7d\xe9\x9e\xa6\x52\x7b\x6b\x8b\xfd\x0a\x97\xc9\x72\xa8\x28\x7d\x8e\x82\x82\xb2\xc9\x92\xcf\xca\x2e\x88\x12\x41\xc2\x30\xf0\x74\xc1\x82\x9c\xb3\x69\x21\x72\x33\x6d\x1e\x85\xec\xa3\x0a\xa2\x0f\xb2\xdb\x3f\x1f\x6e\x77\xda\xdb\x5d\xb1\x20\x3a\xac\x2f\xdb\x74\xd1\x41\x8e\x37\x9e\x69\xf4\x4d\xdb\xd6\x16\xe3\x7a\x6b\x30\x3a\x85\x2c\xd7\xc6\x7f\x7c\x3c\x29\xe7\x0c\x63\x1f\x37\x0c\x0d\x7e\x54\xb9\x0f\x4f\xcb\xdc\x43\xf7\x8c\x38\x9d\x11\x25\xe0\xa2\xb0\xd5\x5a\x5d\x0f\x8d\xfd\x54\xc9\xe3\xa6\x92\xe6\xc5\x11\xce\xaa\x17\x43\xe0\x72\x28\xcf\xb3\xfc\x55\x90\x17\xaf\xd7\x5d\xaf\x73\x0c\x0f\x15\xe4\x05\x1a\x61\x8a\x46\xf1\x22\xc2\xbb\x5e\x57\x63\xee\x6c\x79\x06\x0f\x18\x37\x85\x7a\xa3\x38\xe2\x3e\x2c\x12\xd6\xe1\x93\x30\xd4\x9f\xc0\xaa\x83\x2c\x3f\x78\x9a\x70\x9c\xd2\x9e\xbe\xdd\xf9\xf3\x31\x2d\x4b\xc0\x52\x36\xba\xd6\xd4\xb2\xeb\x6b\xb9\xbb\x03\xa9\x05\xd3\x32\x6b\x75\x7c\xb0\xf9\x18\xfb\xb7\xe6\xce\x64\xcd\x56\xc8\xd7\xde\x91\x0d\x31\x37\x33\x68\x8d\xef\x75\xf8\xce\x41\x5d\xdf\x54\xcc\xdf\xd8\xa0\x52\xbf\xda\x8d\x6b\x92\x7b\xa3\xa0\x80\x4b\x37\x91\xbf\xc4\x72\xdc\xda\xc2\xb3\x1c\x15\xbf\xe3\x82\xb5\xf8\x6c\x12\x40\xa4\x7b\x38\xf9\xe1\x58\xc7\xc1\x9c\x5d\x70\x16\x06\x49\x38\x4d\x50\xde\x2d\xd8\xd9\x76\x97\xed\xf4\xb6\xcd\xdf\xee\x79\x1d\xa6\x2c\x11\x1f\x1c\x6a\x63\x27\xec\x05\xb6\x72\xce\xfa\x2b\x13\xc6\xc4\x25\x0c\x72\xf3\x88\xa4\xe1\x43\x56\x83\x52\xc7\x56\xe2\xf8\x67\xea\xce\x85\x8f\xcc\x1d\x05\x70\xa9\x5f\xe3\x72\x74\x12\x8c\xf9\x9d\x33\xb5\x3b\x64\x69\x82\xa1\xa1\xa9\x39\xb8\xd4\x74\xd0\x55\x91\xdf\x96\xa3\xcc\xd3\x8c\x45\xbc\xe4\x61\xc9\xae\x38\x98\xd0\x8b\xff\x71\xd0\x37\x80\x5f\x1e\xf9\x28\x81\x25\x71\x0a\x3a\x89\xac\xe0\x52\x8b\x15\x24\x57\xc1\xbc\x38\x19\x65\x57\xa2\xb4\x00\xe9\xae\xa7\x8a\x4b\xbf\xe7\x02\x3c\xf3\x3c\x02\x9d\xcf\xa9\x5d\xcd\xd1\x35\x63\x9f\x4a\xdb\xd8\xc4\xf7\x05\x8a\xc8\x29\xa8\x17\xd5\x32\xfe\xb5\xc7\xf1\xd2\xec\x9f\x27\x13\x1e\xc6\xc3\x98\x47\x15\xf0\x2d\x30\xc8\x40\xdc\xd3\xdf\x22\xe6\x6a\x8f\x53\x59\x4e\x52\x9b\x04\x75\x20\x76\xdf\x07\x41\x60\x60\x89\x37\xab\x02\x3d\x13\x57\xf0\xe3\xd1\xf5\x7a\xe9\x40\x89\x7f\x6e\x6e\x65\xeb\xea\x57\x93\x2a\x2d\xda\xf2\x73\xdf\x4d\x70\xcb\xe3\xb3\x02\xd2\x41\x15\xe1\x2e\x75\x90\x8d\xa9\x6f\x7d\xb9\x25\x51\x87\xd1\x97\xff\x3a\x47\xcf\x8e\x35\x5b\xd6\xdc\xe8\xe0\x06\x62\x32\x88\xbe\xba\xcb\xbe\x52\xf9\xef\x1e\x95\xd6\x82\xdd\x74\x4d\x75\x30\x37\xff\x1c\xa7\x91\xae\x12\x65\xbc\x80\xb7\x33\x92\x17\xb2\x38\x45\xeb\xd7\xbb\xd1\x70\xaf\xab\xa4\x86\x8b\x28\xc9\x0e\x6e\xe0\xa6\x82\xc9\x7b\x0b\xa6\xed\xf6\xff\xad\xdb\xfe\xdf\xa4\xdb\xd6\x7f\xab\x2b\xb9\x81\xc4\x96\xd2\x72\x5b\x77\x63\x83\x9c\x0f\xf7\x5c\x35\xb7\x57\x57\xbd\xd7\xa8\xab\x06\x1a\x52\x05\xc5\x47\xa3\x2a\x7b\x6f\x49\x55\xf6\xde\xf2\xaa\xec\xbd\x5b\xaa\xb2\xf7\x6e\xab\xca\xde\xbb\x27\x55\xb6\xa3\x9d\x76\x55\x93\x15\x43\xc0\x65\x14\x93\x8b\xee\x31\x57\xbf\x83\x34\xfc\xbc\xe3\xa0\xa0\x41\x37\x48\xcb\xfd\x31\xda\x77\x0b\x02\x39\xa9\x32\x3a\x30\xfe\x09\x89\x91\x3c\x5d\x50\x1c\x53\x5a\x23\xc5\x85\xad\x94\xea\xd6\xd5\x93\x6e\xba\x0b\xbb\xae\xe0\x12\x8e\xc6\x2a\x1b\x02\x5a\x17\xf5\x3f\xd7\x6d\x60\x45\x8b\xc3\x36\x75\x3e\xb7\x3a\x97\x92\x9e\xdb\xa9\x7d\xcb\xe0\x9c\x04\x6e\x7b\xdf\xb0\x50\x05\x7f\x3b\x0d\x31\xcc\xd2\xe3\xc7\x07\x8b\xd4\xc6\x1e\x05\xef\xbf\xf6\xe1\xfb\x1e\xf4\xd2\xdf\xf6\x80\xfb\xa7\x3b\x20\x79\xa6\xea\xce\x51\xbc\xe8\x28\x24\xb8\x93\xf5\x2e\x54\x1f\x88\xfe\xef\x3c\xef\xeb\xb3\x3b\x9a\x51\xd9\xa8\x59\x7c\x36\xfc\x33\x53\xd8\x5d\x1f\x54\x17\x9e\x4b\xed\xee\x3d\x08\xad\x1e\x6e\xc5\xb4\xc8\xa7\xf9\xd5\x23\xa5\x8a\x95\xd7\x27\x8f\xe0\xcf\x54\x67\xc0\xbf\x7c\xe9\x67\xb8\xaf\xfe\x85\xed\x9e\xdf\xee\xa0\xec\x1e\x62\x6b\x97\xca\x7d\x1c\x65\x61\x13\x2d\x60\xc5\xce\xa5\x4a\x1a\x64\xf8\x34\xb3\x2d\x0a\x4d\x59\x51\xc6\xee\x8e\xbd\x60\xad\x0b\x50\x46\xf6\x59\x2b\x89\x53\x1e\xe4\xad\xee\x9d\x1d\x98\x97\x3a\x31\x7b\x8f\x06\x61\x19\x7f\xe1\xc6\xe7\x40\xe3\xe1\xc0\x29\xdb\x2e\xd1\x91\xe0\x69\x1c\x7e\x2e\xba\x2c\x80\x6c\xc9\xfa\x61\x53\x3c\x06\xaf\x2a\x7e\x21\x98\x98\xaf\x63\x9a\x23\xe2\xe2\x25\xd3\x21\xa3\x7d\x9c\x91\x2e\xce\x1d\xa3\x49\xcf\xb5\x15\x46\xe2\xc1\xfe\x0e\x0f\x59\x6b\x94\xe5\xf1\x3f\xb3\xb4\x0c\x92\x8a\x36\x90\x86\x8a\x82\x96\x7a\xa1\x1e\x26\x78\x5f\x50\xe3\xe9\xcd\x55\x38\x2c\x89\x59\xb3\xab\xd3\xae\x54\x34\xdc\xc6\x8e\x74\x9b\x18\x9c\xca\xed\x77\xa9\x8e\x42\x51\x2b\x0e\x2b\xfd\x80\x71\x87\x8a\xe3\xe7\xb6\x5c\x95\x97\x06\x3a\xfc\x9e\x06\x0a\x53\x0e\x96\x60\x54\xb2\xc6\x32\xbb\x94\xcf\xeb\x9a\xe2\xb3\x13\x91\x76\x9a\x69\x3f\x7c\xc8\x5a\x35\x3c\x21\xa1\xaa\x5e\x38\xef\x2a\x98\xbb\x72\x9c\x1d\x8f\x76\x0e\xe3\x59\x61\x7e\x57\x06\x9e\xea\xab\x8a\xce\xe2\xab\x5d\x7a\x10\x3a\x46\xa1\xa7\x09\x95\x20\xe0\x4a\x94\x6b\x48\x21\xe1\xc0\xb3\x94\xff\x14\x38\x54\x28\xf4\x63\x50\xe2\xcf\x41\x5f\x05\x7b\xcd\x16\xa7\xae\x57\x93\xa5\xb4\x78\x71\x8a\x7e\x34\xa4\x0e\x6f\x9c\x4d\x05\xed\x4b\x05\x5c\x97\x46\xb0\x41\x4e\x2c\xea\xc8\x42\xa8\xb4\x8b\x31\x6d\x91\xc2\x0e\x3c\x85\x30\xa5\xb4\x81\x0f\x7c\xb8\xbe\x8c\x32\x06\x9e\xb6\x58\x87\xa5\x26\x25\x0c\x94\x7e\x9b\x0e\xb3\x26\x16\xab\x0b\xb5\x01\x98\xca\x4b\x21\x75\xd0\x47\x6f\xb1\xf6\xa2\x77\xc2\xfa\x54\xe6\x03\x0c\xed\x55\x55\x6d\x08\xb7\x98\xde\xaa\x3e\x25\x49\xd0\x72\xd9\x0e\xc6\x2f\xb4\x81\xb3\x0f\xd4\xcb\x59\x98\xf8\xfa\xc2\x00\xb0\xfa\x52\x10\x44\x34\xe2\x24\x07\xba\x06\x6c\x75\xdd\xe1\x39\x20\x28\xca\x57\xbb\x4f\x9c\x7e\x14\x29\x6d\x8e\xde\x6c\xfe\xa7\xcb\xe4\xaf\xdf\x48\x45\x3c\x85\x7a\x76\xb3\xe5\x10\x8e\x6f\x40\x77\x1b\x1e\x9b\xce\x88\x03\x19\x2c\xdc\x9b\x39\xee\x63\xf0\x6f\x5e\x2d\xa8\x92\xdc\x07\xe5\xc6\x51\x0e\x5e\x9d\xc3\x5b\x93\x8d\x0d\xd3\xd7\xc6\x86\x6e\xae\x7a\x48\x9f\x9d\x48\x9b\xba\x15\x2d\x82\x02\x45\x1c\x2f\xd3\xb9\x94\x96\x8f\x87\xd8\x96\x0c\xf9\xa8\xba\x56\x86\x7a\x76\xff\xf3\xfb\xee\x7f\xde\xdc\xff\xec\xef\x32\x7a\xbb\x44\x84\x40\x1c\xfc\xea\xc5\xa9\xd8\xd8\xd9\x0b\xfb\x5b\x13\x50\x47\x9b\x2d\x39\x03\x52\x0d\xce\x75\x83\x73\xa7\xc1\xb9\xaf\xc1\xdf\x3a\x3e\x3b\x28\xdf\xfe\x01\xaf\xc6\x11\xee\xbe\xfc\xb7\x2b\xbb\xed\xab\xee\x6b\xd8\xb4\xa1\xd2\x27\x0d\x54\x5a\x0a\xf9\x4b\x53\xde\x93\x5e\x96\x47\x3c\xe7\xd1\x29\x95\x00\x2b\x5a\x5a\x52\x5e\x8a\x71\x55\xa5\x2f\x95\xef\xaa\xe5\x21\xd9\x91\x0c\x27\x99\xf6\x3e\xa1\x99\x82\x84\xe3\x43\x56\xe8\xcd\xce\x59\xfc\x44\x74\x5c\xe3\x44\x78\x61\xf3\x22\x94\x88\x05\x90\xd8\x30\x46\x0b\xcf\x8a\x2e\xe2\x0b\x0f\x6a\x1d\xf7\x79\x0f\x81\xe4\x87\x43\xb6\x0d\x86\x14\x64\xb8\x1e\xad\x19\xd4\x50\x81\xbc\x6a\x25\x62\xb7\x21\x2b\xb3\x87\xee\x05\xbd\x2d\x7f\x08\xe6\x49\x16\x44\xe4\x8d\x8c\xc4\xa7\x74\x78\x45\x41\xae\xd8\x7b\x06\xce\xa9\x80\xbe\xb4\xa9\x1c\x18\x9a\x4e\x0a\x4b\x11\xb9\x4d\x63\x88\x7e\x84\x55\xea\xa1\x69\xdb\x9e\xc2\x80\xc4\x3e\xfd\xe8\xda\x48\xe8\xdb\x9f\xdd\xca\xf8\xfa\x95\x94\xa5\x45\x21\xca\x1b\x16\x5d\x62\x82\xf7\xb1\x32\x63\x17\xdc\xe8\xcb\x95\x54\x23\x27\xd9\x23\xd7\xa8\x2b\x29\x4a\x63\x8c\x31\x9c\x08\x73\x23\x65\xc9\x2c\x46\xc2\x51\x8f\x6e\x9c\xbf\x53\x02\x51\x36\xac\xf4\xde\x20\xf3\xd8\x64\xd4\x24\xf8\x34\x10\xdc\xa2\x7b\x27\xe2\x60\xc5\xce\x5b\xfb\xd2\x84\x78\xb8\x21\xbd\x34\xad\xe7\xbf\xb2\x6d\xf0\x98\xe2\x00\x59\x4d\x52\x11\x22\xaf\xaf\x99\xc3\x0f\x7c\xb7\x23\xb7\x93\x3b\x64\xfe\x9a\xaa\xfa\x51\x1c\x71\x5b\x51\x2f\xf5\x74\xce\x09\x5b\x24\xd6\x9c\x72\x5d\x6d\x85\xe7\x60\x45\xcd\xf6\x77\x9b\x5f\x20\xf8\x5f\x16\xec\xd6\x3d\x2d\x48\xa5\xb7\x42\xab\x6c\x4a\x3c\x16\xaa\xbf\x69\x1a\x97\x95\x82\x22\xd1\x2d\x88\x47\x92\x12\xbc\xed\xd9\xa5\x75\x0e\x15\xc4\x4c\xd8\xc4\xa6\x48\x89\x88\xa3\x4e\x97\x9d\x59\xbc\x6e\xd5\x17\xa9\x9f\x95\xec\xf3\x21\xe7\x85\xd2\xd1\xbd\x2c\xcb\x3c\xbe\x98\x96\xbc\x20\xea\xca\xca\x69\x4f\xe2\xb1\x6f\x8c\x1a\x05\x12\xfa\xf0\xff\xae\x19\x7c\xdf\xfc\xb4\x11\x24\x70\xdb\x47\xb4\x5f\x5f\x33\xef\xac\x40\xc0\xbb\xd5\x6d\xf0\x72\x35\xb8\xf7\x81\x38\x51\x26\x59\x7e\x3c\x94\x1e\x26\x05\x8d\x5b\x83\x73\x54\x1c\xc0\x70\x56\xed\xf7\x4a\xf5\x0b\x82\xd4\xab\xf9\x6b\x49\x89\x55\xd5\xb9\xb5\xe5\x6a\xf3\x50\x07\x9a\x89\xda\x69\xea\xab\x5a\x5b\xca\x79\xc7\x52\xf8\x9d\x9d\x77\x16\xeb\xf5\x7e\x84\x39\x5a\x78\xdf\x4f\x8a\xa9\x2b\xe2\x70\x9a\xe7\x3c\x45\x7f\x28\xde\xa7\x6d\x4f\xfc\x4f\xdb\x2a\x7c\x99\x36\x74\x8b\xc7\xe8\x56\xb5\xda\xeb\xfa\x4c\x9d\x5f\xad\xe2\x99\xc7\x5d\x17\x71\xc5\x65\x95\x55\xe9\x0b\xcc\x00\xac\x3a\xb7\xb0\x06\xa8\xd4\xf3\x1b\x05\x5c\x04\xf9\x49\xfc\x4f\xae\x2f\xfc\xe5\x77\x8d\x0f\xb3\x7a\xcb\x81\x8b\x20\xff\x09\x8e\x86\xba\x99\x9f\xdc\xf3\xe3\x45\x90\x4b\x75\xf4\xdc\x29\x4a\x92\x9d\xf7\x88\xe0\x5d\xe9\x7d\x30\x7b\xe5\x80\x39\xd6\x49\x0e\x15\x0c\xa4\x11\xc9\xcf\xc1\x98\xbf\x9a\xbf\xb3\xb4\xbd\x9e\x2c\xa9\xcb\x74\x16\x08\x78\x0a\x8e\x43\x55\x58\xb0\x5b\x4f\xdd\x9e\x53\xcc\x61\x35\x42\x3c\x5f\xd0\x00\x2d\xe3\x8c\x63\x14\x14\xaf\x82\xdc\x27\x25\x60\x8e\xf3\x18\xdd\x39\x6c\x14\xf1\x3f\xc1\xe9\x0a\xfa\xa8\x12\x0d\x6d\x6c\xac\xcc\x7d\x62\xc5\x7d\x24\xc6\xa1\x61\x60\x3d\x5f\x15\xf9\xf4\xd5\x8f\xfa\x37\xe5\x15\x5b\x0c\xe4\xe2\x3c\x52\xcb\xf5\x8c\x6a\xd4\xdd\x0b\xc0\x2c\x7f\x13\x84\x23\xe7\x06\xd0\x09\xa8\x6c\x9a\xf6\xbe\x9c\x7b\xb2\x9c\x81\xca\x5a\x4f\xdf\xbb\x70\xf5\x58\x39\xa2\x0c\x44\xaa\x7e\xe4\x68\x2e\x1e\x1b\x24\x0c\x53\xa3\x4e\xbe\x80\x7d\xc6\x5a\x1a\xb4\x92\x77\x81\x48\x1f\x66\x86\x6c\x81\x2b\x91\xdb\x52\x97\xf0\xd1\xb5\x45\xe5\x65\xa2\xa2\x5b\xb7\xba\x45\xf3\x35\x75\xc5\x89\x14\x75\x60\xb6\xfb\xe3\x7a\xf9\xd0\xfb\x20\x88\xc6\x10\xd9\x73\x2e\x09\x6c\x8b\x11\xca\x08\xcf\x50\x7d\x4e\x5d\x77\xbc\x0f\x26\x36\x90\xd2\xfe\xc6\x19\x5a\xb5\xa2\x3b\x38\xd3\xaf\x1c\x9b\xd4\x73\xc9\x9f\x67\x71\x74\xbe\xcc\x65\x86\x1c\xb4\x76\x26\xb6\x07\x1e\x3a\xaa\xd7\xb0\x3a\x5f\x22\xa8\x67\x3b\x7b\xe8\xdc\xa2\x86\x18\x0d\x1c\xd8\x5b\xab\x5f\xf4\x4f\x15\x93\x80\x86\xe8\xfb\x24\x80\xa6\x63\xee\x8a\xf7\x9c\x5b\x46\xc7\xe4\xd6\xa6\x30\x89\xca\xe3\x8b\xdf\x2d\xe2\xf2\x52\xa4\x52\xe1\xf8\x2a\x98\x21\x56\xaa\x02\x8f\xd2\xac\xa2\xc1\x34\xc6\x5a\x37\x15\x0b\x19\x3b\xd7\x7a\xa5\xb2\x2a\x4e\x4b\x85\xd3\x13\x03\x22\x5a\x50\x20\x66\x91\x07\x36\x00\x41\xb2\x2a\x18\xbe\x08\xd2\x48\xf2\x8d\x55\xe1\xbb\x34\x1b\x03\xb6\x45\xa7\x5d\x61\xbf\x6b\xe6\xa6\x02\xc3\xd8\xe2\x5e\xab\x3c\xe2\x73\x98\x60\x87\xbd\xa8\xca\x0c\x7d\x97\x55\x56\x51\x91\x7f\xc8\x8a\x18\xb8\xce\x5d\x6c\x98\x23\xb2\x61\xea\x86\x71\xc3\xf4\xc8\x4c\x7d\xf9\x6f\xd7\x11\x90\xfa\xce\x77\x57\x4f\x59\x5f\xff\xea\xea\x9d\xbe\xaf\x7f\x9d\x19\xee\x7c\xde\x25\x28\xee\x93\xdf\x35\x1a\x23\x75\x47\x23\x78\x72\xc1\xa3\x1f\x53\xc9\x03\xe1\x35\xaf\xe0\x85\x60\xf1\x47\x3f\xc4\x3e\x0a\x3c\xbc\x40\xf2\xac\x9c\xce\x49\x63\x4d\x2c\x7c\xdf\x61\x8d\x96\x70\xd0\x9b\x4c\x8b\x51\xc5\xc4\x44\xba\x55\xb4\xdf\x4a\x98\xde\x6c\x4f\x90\x92\x27\xc0\xfe\x4e\xb7\x7d\xe7\x0c\xd4\xb5\xfc\x8b\x77\x3d\x47\x52\x31\xf2\x3e\x1a\xef\xfb\xe6\xc3\x81\x91\x51\xda\xea\xd3\x8f\xae\x3c\x41\xf4\xe5\xbf\x5d\xca\x87\xfa\xf4\xa3\xeb\x58\x86\xac\x63\x18\x5b\x85\x2f\x4b\x05\x8a\xe1\xda\xef\x1d\x0f\xbe\xac\x71\x48\x8d\x50\x35\x9d\x8d\x2f\xe2\x94\x43\x34\xb0\xbf\x05\x69\x94\xf0\x5c\x32\x04\x29\x84\x8d\x20\xd1\xee\xb4\x0b\xba\xa4\x2e\xd9\x6f\x7b\x59\x6a\xb2\x3b\x8d\x60\xbf\x49\x41\x29\xf0\x6d\xc1\x86\x4e\xeb\xc1\x86\xec\x8e\x03\xf5\x8d\xd8\x05\x35\x59\xee\xcb\x88\x1d\xf6\x1f\x9c\x9f\xa1\xbd\xcf\x7c\xce\xae\xaf\x59\x4b\x7c\x6c\xb6\xd8\x63\x94\x75\xdd\x26\xeb\x77\xf9\xfd\xae\x7b\x8c\xd1\xab\xc0\x15\xf3\xce\x1b\x84\x85\xfd\xae\x75\x92\xe9\xfa\xb7\xe3\xe6\x06\x5a\x41\x1a\xe3\x5d\xfa\xdb\xa8\xd5\xd5\x07\x62\x22\x13\xec\x77\x2a\x73\x0c\x3c\x5b\x92\xf0\xaa\xca\xa8\xcc\xd8\x3b\x1e\xe9\xe6\xe8\xde\x69\x1b\xb9\x57\x60\x30\x8b\xfd\x81\x3d\x91\xb6\x4a\x91\xa6\xbb\x4a\x50\x8b\x91\x2d\x56\x9b\x1c\x4d\xf3\x22\xcb\x75\x58\xcb\x26\xd5\x89\x53\xb4\x7d\x1b\x4b\x27\x5a\x0e\x6f\xbc\xf6\x1a\xee\xde\x3c\x37\x2c\xb2\x52\xcf\xcd\xaa\x51\x92\xa8\xe2\x3e\xfd\x08\xb9\x99\x7b\x65\x64\x12\x55\xc3\x93\x5b\x39\x29\x27\x43\x59\xc9\xd7\xd4\x16\xdb\xad\xce\x0a\x5d\x78\x45\x99\x67\x9f\x79\x9f\xb5\xd2\x2c\xe5\x96\x49\xdc\x30\x4e\x92\x3e\x6b\xfd\x67\x18\x86\x56\xfa\xac\xcf\x6a\xcc\xba\xd8\x8b\x0a\xb2\x7a\x33\xb6\x69\x60\x54\xec\xbe\x97\xf0\x61\xc9\x1e\xb3\xed\xde\x3e\x6d\x79\xde\xd4\xb2\xac\x59\x66\x13\xac\xc8\xaa\x37\x41\xbd\x39\xe9\x8c\x36\x0c\x2e\xdb\x9b\x1a\xf7\xa1\x4e\x03\x8b\x0e\xdf\x37\xd9\x0e\x6d\x12\xfd\xbc\x2f\x01\xb0\x74\x08\xbf\xc9\x76\x58\xdf\xd7\x8f\x59\x3f\xcb\xae\x8f\x0f\x59\x9c\x96\x8d\x7a\x45\x5a\x6e\xcd\x95\xb1\xbf\xca\xca\xd8\xbf\xdd\xca\xd8\x97\x2b\xc3\x21\xed\xd9\x4e\x8d\x3b\x99\x79\x5d\xc6\x6c\xb7\xae\xc6\xae\xef\x31\xc2\xd2\x16\x8a\x00\x49\x95\xb4\x29\x1f\x84\xae\x67\x96\xb3\x73\x00\xd3\x90\xad\x95\xb5\x6b\x65\xb1\xc7\x36\xb5\x78\xfd\x2f\x2e\x61\xe0\x38\xf7\xc2\x39\xaf\xf4\x3c\xb7\xe0\x9c\x11\x38\xc5\xc2\xac\x0c\xcb\x5e\xb4\x74\x55\xf8\xbd\xe1\xaf\x74\x96\xa9\x80\x1d\xce\x3a\x70\x73\x77\x47\xad\xcd\x3b\xcd\xe6\xa9\x4d\xa6\x9c\xe1\xcc\x87\xd7\xd0\x23\x50\x86\x73\x6f\xc9\x8a\xfa\x8a\xb1\x38\x4d\x79\xfe\x51\x19\x36\x56\xaa\x90\x6c\x8f\xfc\x37\x2d\x9b\xea\x92\xec\x6a\x5d\x65\x22\x59\xa9\x55\x35\x95\x54\x6f\xb1\x52\x8e\xbc\x64\xa9\xc3\xf2\xed\xed\x23\xc3\x59\x97\x85\xe2\x70\x41\x86\x2c\x4d\x22\xab\x1a\x26\x18\xdb\xb7\x80\x86\x22\xd1\x0b\x0d\x2c\x1b\x83\x1c\x9b\x1d\xc8\xb5\x48\xb2\xe7\x07\x55\x56\x65\x06\x53\xa9\xed\x64\xcf\x3d\xc6\xc8\x9e\xf3\xe4\xf2\x84\x3a\x58\x9e\x52\xf3\x5a\x42\xcb\x6b\x68\x0c\x9e\xf8\xbe\xac\x23\x34\x93\x5b\xad\xc9\xd3\xa8\xb6\x9e\xca\xf3\xd0\x28\x34\x79\x9f\x54\x31\x10\x64\x31\xa0\x36\xbb\x66\x14\x1e\x2a\xe5\x69\xf4\x6d\xa1\x51\xb8\x71\x7d\x4d\x78\x24\x3e\xf1\x37\x01\xd1\xa0\xcf\xce\x0c\xe2\xba\x1a\xe8\xca\xdb\x90\x70\xd6\x67\x03\x5c\x17\x7d\xda\x6d\xdf\x83\x8c\x3e\xf9\x6d\xc0\xea\xeb\x5f\xf6\x51\xa2\xe6\x24\x51\x91\x58\xcf\xc0\x62\x7f\xb6\x03\x96\xfa\xf3\x1d\x10\x8e\x20\x65\x17\x53\x76\xd9\xcd\xf9\x12\xaf\x2d\x9c\x1b\xa8\x45\x4f\xb1\x7d\x57\x65\x8e\x49\xf0\x52\xe2\x83\x7e\x75\xe0\x9c\x3c\xfb\xac\x05\xb6\x90\x2d\xfb\x94\xd9\xd7\xfe\xc9\x6f\x56\x15\x04\x1a\x7a\x9c\xf9\x7b\x9c\x2f\xdb\xa3\x7f\x9f\x6c\xe8\x10\x69\xc4\xdf\x2b\xf0\xd5\x6a\xcf\xd5\x13\x8b\xa7\x5d\x53\xb7\xd2\x2c\xe9\x72\xa1\x58\xed\x31\x62\xac\x8f\x27\xd1\x64\xf0\x78\x9b\xa7\x36\x2b\xd3\x90\x79\xb4\x52\x17\x4b\x62\x79\xea\x30\x8f\x6a\x96\x69\xab\x71\xde\xdd\xf7\x16\xf5\x33\x59\x79\xe0\xd2\x38\x39\xd2\x46\xbc\x76\x42\x94\x0d\xf9\xac\xcb\xe6\x77\x3e\x01\x42\xfa\x5c\x02\x9b\x20\x95\xa8\x03\x0d\xb1\x86\xab\x9c\x69\xd4\xe3\xfa\xb7\x08\xb4\x38\x2f\xb0\x1f\x6c\xe9\x7a\x63\x83\xcd\xd8\x5f\x9b\x24\x6e\xb0\x5e\x26\xd5\xc4\xe9\x01\x92\xfe\xda\x7c\xa0\xa8\xce\x99\x01\xe4\x85\x64\xa6\xc8\x4b\xd9\x4d\xc5\x8e\xda\x6b\xaf\xfc\xb4\xe9\x64\xa8\xd6\x26\x35\x98\x7f\xda\xa3\xc9\x76\x05\xb3\x62\xed\x1a\x56\xba\x3b\x6f\x56\x2f\x1b\x1b\x76\x23\x1e\x3b\x5e\x55\xfc\x1e\x6d\xdb\x29\x48\x5e\x93\xda\x55\xc5\x01\x54\xd4\x4a\x7a\x3f\x1e\x9e\xf0\xb0\xcc\x72\x65\x87\x40\x27\xaf\x6b\xc6\x79\x4b\x6b\xd8\xca\xea\x43\xaf\x8b\x5f\x78\x5a\x16\xc7\x43\x19\xd2\xb1\x76\x29\xfa\x0a\x57\x74\x0f\xc4\xc3\x06\x59\x95\x35\x6e\x36\xa4\xb2\x04\x6e\xfc\x56\x0f\x12\x11\xeb\x20\x11\xa0\x04\xf5\x87\x89\x68\x68\x75\x67\x30\xd0\x61\x84\x06\x92\xef\x1b\x52\x50\x7e\x1d\x44\x7b\x07\x3e\xe8\x11\x23\x46\x3b\xf7\x56\x5e\x28\xd9\xc1\x94\xe5\x1b\x91\x17\x16\xcd\x52\x6d\x7a\x1f\xf1\x85\x7a\x78\xa2\x83\xaf\x16\x7f\x9f\x7d\xe1\xd5\xd2\x10\xef\xb4\x5a\x58\x5e\x7a\xb8\xa5\xf1\x5a\xc2\x2a\x7e\x9a\x4d\xc3\x51\xa5\x6d\x9d\x4a\xa4\x86\x3e\x84\xd4\xa0\xa8\x80\x73\x8c\x46\xc4\xaa\x13\xc9\xe5\x44\x26\xaa\x31\xd7\xae\xb2\x62\x2f\x8c\x30\x1e\xeb\xde\x3d\x0a\x6a\xeb\x9a\x8c\xc0\xd9\xb5\xe7\xaf\x12\x15\xd6\xb2\x1b\x3f\x1d\x71\xa6\x42\xa3\x81\x9f\x5b\x3e\x9b\xf0\xb4\x88\xbf\x70\x56\x66\x2c\x87\x80\x8c\x2c\x4b\x59\x12\xe4\x97\xda\x17\x51\x49\xbc\x30\x15\x19\x9b\xe4\xd9\x97\x38\xe2\x60\x60\x1e\x5c\xc4\x49\x5c\xce\x45\xe5\xa2\xcc\x72\x48\x1c\xb3\x38\x95\x81\x61\x83\x34\x62\x59\x9a\xcc\x55\xe4\x3a\xc8\xc5\x17\xd1\x3c\xe4\x45\x11\xe4\x73\xd3\x74\x39\xe2\x73\x80\x29\xe2\x13\x01\x48\x5a\xb2\xe9\x24\x43\x43\x76\xf4\xc4\x24\x9a\xa3\x0e\x93\xac\xba\xd2\x4d\x52\x91\xb1\xb8\x6c\x15\x2c\x1e\x4f\xb2\xbc\x0c\xd2\x92\x95\xa3\xa0\x44\xb7\x5d\x63\x5e\x8e\xb2\x08\xfd\xaf\x24\x09\x8f\xd8\x20\x18\x96\x3c\x1f\xd8\xed\x20\xe8\x71\x21\x81\x8e\xd8\x55\x5c\x8e\xc0\xcf\x9f\x8c\x2f\x9b\x97\x5b\x12\x8a\x38\x24\x51\x25\x4c\x2b\xfe\x70\xb7\xfa\x4f\x4c\xc2\xc4\x89\x7d\x7b\x21\x5d\x0e\x0f\x33\x19\x13\x54\x85\xbf\x15\xcb\x6d\x1c\xf8\x22\x5f\xfc\x4b\x3b\xae\x72\x3a\xd0\xb6\x97\x06\x43\x92\x64\xe2\x26\x77\x57\x38\x55\x3f\xab\xb0\xbf\x40\x86\xdc\x3c\xc9\xac\x7b\x70\xb0\x74\xa4\xc0\xda\x2d\xe4\x16\xb1\x06\x73\x3e\xdc\xf7\x9a\xc7\xee\xf9\xcd\x63\x27\x24\xf6\xfb\x7e\x5d\xd8\xdc\x8a\x03\xaa\xfd\xdb\x3a\xa0\xda\xef\xd5\xdf\x37\x13\x4b\x58\x2c\x4a\xe2\xd1\xaa\x32\x6b\x05\x13\xfd\x07\x30\xc8\x2f\x41\x12\x8b\x76\x7f\x15\xd2\xe2\xdf\xf0\xf2\x41\x8a\x09\x76\xf4\xf0\xce\x0a\xef\x57\x97\x8b\xf5\xb0\x84\xc1\xec\x82\x70\x10\x55\x44\xeb\x52\xd5\x88\xc6\x39\xff\xc2\xf3\x82\x03\x7d\x1c\xe7\x11\x3c\x10\xc0\xb2\x95\x9c\x25\xcc\x65\x77\xef\xc9\x5e\x76\x77\x6d\x83\xd9\xdd\x26\x8b\xd9\x8a\xfd\xf7\x3d\x06\xd5\xfa\x49\xf5\x05\x12\x95\x6b\x7c\x6b\x99\x93\xaf\x6a\x97\x50\x58\xc6\x5f\xd8\xdc\xab\xb9\xb4\xba\x44\xc3\x7f\x8f\xab\x9c\xca\xa5\xbf\xb4\x54\xb4\x15\x04\x3a\x91\x12\x5c\x95\x8a\xdc\x17\x8c\x77\x61\xb9\x09\x06\xa8\x38\xc3\x7e\x5b\xcc\xc5\xae\x0a\x1a\xfc\xd2\xc0\xf3\x1a\xc9\x06\x7b\x9e\x08\x7b\xd6\x6b\x3e\xd1\xfd\xed\x42\x65\x34\x84\x1e\x73\x06\x23\x44\x5a\x77\x26\x6c\x83\xc1\x7b\x8f\x8b\x61\x47\x86\x75\xfd\xb4\x54\xcf\xec\x5a\xb5\x83\xf4\x50\x6b\x3f\x65\x5b\x48\x35\x23\x4c\x80\x41\x3a\xc5\xb5\xd0\xfb\xcc\xe7\x45\x5b\xb6\xd8\xf1\xd8\x76\x7f\x76\xe3\x5e\x28\x9b\x93\xcf\xe0\xc6\x49\xda\x54\x38\x73\x4b\xcb\x74\xb5\x51\xd5\x67\x3e\xef\xe5\x7c\x92\x04\x21\x6f\x03\x79\x75\x59\xab\xd5\xe9\xa2\x5f\x06\x31\x2b\x14\x47\x0e\xbd\xab\x15\xa3\xc2\xdb\xf8\xad\x4a\x1d\xfb\x61\x38\xf8\x80\x09\xac\x79\xe7\x4f\xdf\xc4\xfe\x84\x81\x1f\xb2\xbc\x4d\x9a\x77\x27\x46\x19\x8d\xfc\xe4\x7d\x6a\xe8\x7f\x36\x53\x6b\xee\xb6\xba\xb1\x98\x27\x0c\x38\xa5\xc4\x45\xfe\x1b\xeb\xa3\xcb\xd9\xa6\x6f\x64\x02\x1a\xcf\x27\xa4\x6b\x3f\x82\xfa\x35\xe9\x8b\x63\x0f\x7a\x6d\xf1\x3c\xa0\xd3\xf5\xa4\x66\x59\x63\x9b\x1c\x91\xf4\x19\x89\xf1\x22\x89\xd3\x72\x33\x8a\x8b\xe0\x22\xe1\x8c\xa5\xd9\xe6\x54\x9c\x86\x8a\x30\xcb\xf9\x66\x84\x77\x91\xb5\x12\x25\x89\x83\x5c\x2b\x33\x5a\xb1\x92\xc9\xb2\x69\xd8\x71\x9e\xca\x1d\x07\x8f\x76\xe6\x5d\x39\x1c\xc9\x8f\xb8\x38\x57\x8b\x2d\xa6\x97\xa5\x4d\xfb\x56\xb5\x15\xd4\x08\x9c\xfc\xf6\xf3\xd1\xe0\xcd\xdf\xdf\xfc\x7c\x2a\x1a\xb1\x4e\xa2\x1f\x79\xc8\xe3\x2f\xfc\x64\x9e\x86\x95\xf3\x68\x73\x70\xea\xa5\x61\x2e\x78\xf9\x3e\x98\x29\x8c\x14\xcd\x31\x9c\x97\x6e\x75\x30\x26\x6d\xda\xcc\xe9\xee\x61\xbe\x0b\x34\x58\x00\xb3\xc7\x6c\x67\xf9\x00\xd3\x76\xcc\xe6\x5a\xba\x73\x43\x3b\xdf\x2d\xe9\x39\xad\xff\x9b\x0c\xff\x37\x90\xe1\x66\x03\x19\x3a\x1a\xa5\x23\x25\x8d\xa0\xdf\x74\x94\x54\xb2\x21\x03\x9f\x87\x13\x54\x43\xa0\x5a\xe5\xcb\x25\xe3\xa8\x88\xae\xe8\x01\x6e\x13\x86\x7b\xcd\x70\xda\xbe\x4e\xb5\xb7\x1b\xfc\x3b\xf5\x79\x87\x9f\xd5\xf9\x33\x57\x8d\xcc\x97\x68\xa4\xe2\x14\xdd\x55\x68\x9c\xde\x1e\x87\x75\x5b\x92\x23\x26\x2e\xbe\x29\x54\xe2\x64\xce\x87\x4f\x5d\x85\x05\x55\x4a\x3c\xf5\x29\x25\xbc\x4e\xbe\x9f\x36\xbe\xe6\x85\x12\xff\x45\xbd\x1a\x41\x15\xbf\x4f\x23\xb7\x18\xa9\xe7\x44\xcc\xfe\x7a\x23\x83\x65\x9b\x32\xbe\x7e\xe7\x6e\xbf\xf3\x85\xbe\x94\x9c\x7a\xf5\xfd\x1a\x6f\x4b\x14\x87\x78\x29\xa6\x0e\xfc\xf0\x65\xf7\x25\xed\x2f\x55\x09\xfc\x5c\xcd\xef\xf7\x38\xc8\x2f\xe3\x94\xbc\xc2\x85\xcf\xeb\xeb\x8a\xc2\x1b\x54\x74\x7f\xec\xbd\xc5\xee\xf6\x60\x10\x2a\xab\x91\xc1\x2b\x01\xd0\x32\xb7\x16\x09\xbf\xe4\x69\xf4\x07\x5f\xb9\xec\xd2\x2b\x97\x77\x00\x51\x1d\xec\x9e\x13\xdd\xdf\x34\xe4\x78\xd4\x32\xee\xa6\x6a\x4f\xea\xb1\xc7\x01\x87\xf2\x80\xa9\xaa\xe3\x0b\x46\xbb\x0c\x71\xc4\xaa\x4f\xf4\x24\xad\xea\x4f\x1b\x8b\x8c\xe3\x3c\xcf\xe0\x8d\x95\x4c\x68\x70\xe2\xb1\xf4\xe1\x9f\xf4\xab\x0a\x9e\x91\xb4\x73\xf6\x58\x02\x08\x6b\x64\x35\x5f\xa7\x2c\xe1\xc3\xb2\x2f\xd7\x01\xde\x4e\x5f\x5f\xb3\xed\x2e\xcb\xd1\x18\x5a\x66\xc0\x17\xe4\xb0\x9a\x53\xf7\xdf\x9d\x39\x9a\xad\x37\x47\xb3\xff\x6d\x73\x84\x5c\x6a\xc5\x49\x2a\xb3\x89\x9e\x8a\x32\x9b\xc8\x29\xba\xc8\xca\x32\x1b\xeb\x0c\xfc\x6c\x9c\x24\xc1\x9d\xad\xeb\x31\x9c\x3a\xf5\xe3\x6f\x6e\x2d\xe0\x7a\xaf\xb0\x5d\x6d\x8c\x80\xfd\x38\x12\xa6\xe6\x8f\x36\x42\xad\x2a\xec\xf1\xa1\xe1\xa3\x3d\xca\xbc\x05\xd0\xeb\x33\x3e\xdb\x7d\x71\xc5\xee\xda\xb1\x10\x31\x6c\x71\x63\x03\x65\x69\x99\x24\x05\xa2\x2a\x6d\x62\xfe\xab\x6c\xa6\x14\x17\x76\x85\xde\x25\x2f\x5f\xbd\xca\x66\x6d\xdb\x4a\x20\x5b\xde\x31\xa4\x5f\x71\x8a\xe3\x0c\x26\x13\x9e\x46\x28\x7b\x1c\x0f\x91\x85\x22\x03\x56\x67\x7c\x57\x07\x20\xf5\x28\x1a\xea\x46\xdb\x01\xaf\x56\x82\x4c\x7f\x9f\x7e\x50\xe2\x54\xbd\xd3\x7a\xf2\x71\x86\x7a\x65\x41\x4d\x5f\xf4\x57\xee\x6e\xda\xea\xf9\x85\x7e\x5d\x41\x6c\x5f\x36\x6d\x42\xf2\x68\xb8\x6a\x6f\x71\xf1\x80\x94\x1b\xa7\xa7\x20\xcb\xc7\xe9\xe5\x62\x57\xa6\xcc\xfa\x7b\xd3\xec\xcc\xf4\xe7\x69\x92\x54\x3d\x7d\xc1\xe5\x8b\x2b\x82\xde\x0a\xca\x80\x15\x21\xf8\x06\xaa\xbf\x36\xe5\x09\x64\x88\x76\xd0\xc2\xd6\x53\xc5\x15\xa0\xd3\x4c\xce\xfc\x2a\xc0\x25\x3c\xf8\x52\x07\xdb\x9d\x76\x34\xce\xa0\x9f\x25\x02\x45\xf1\x5b\x4d\xd3\x2a\x40\xc5\xee\xe8\xfd\x20\x11\x88\xd6\x03\xa5\x72\x50\x29\xf3\xf8\xf2\x92\xe7\xfa\x90\x5f\x7b\x52\x71\x0b\xc2\xc5\x8a\x7b\x52\x29\xe6\x69\xf8\x36\xb2\xad\x76\x30\xcd\xb5\xc9\x5a\xed\xb9\x06\xb6\xd5\xb9\xf3\x33\x3d\x1f\xc7\x8d\x3c\x74\x59\xed\x09\xc2\x27\xb5\x28\x18\x51\x0b\xd8\xae\x48\x03\x7c\x2d\xad\x5e\x42\xfb\x15\xa3\xc1\xae\x9d\x17\xb7\xa0\x7c\xb3\x29\x1f\x6c\xe3\x6b\x54\xf3\x4a\xd4\x9d\xb0\x66\x1d\x3a\x1a\x28\xfa\xcb\xd0\x09\x1d\x66\x39\x6b\x83\xd1\x22\x3b\x64\x18\x56\x45\x5f\x40\xb8\xf5\x54\x24\x21\x16\xb3\xbf\x8a\x82\x07\x2c\x7e\xfc\xb8\x5e\x64\xf3\x37\x72\x16\x57\x83\xd0\xa0\x44\x04\x0f\xf1\xc5\xe9\x10\x7e\x5c\x5f\x4b\x41\x09\x49\xf1\x33\x9f\xeb\x3c\xf5\x74\x98\x20\x0a\xf2\x56\x3d\xcc\xfc\xae\x63\x78\x90\x06\xd1\xeb\xb1\x06\x0c\x9c\x01\x74\x84\x68\x60\x66\x04\x3a\x95\xfe\xca\xbd\xd3\xc4\x9c\x90\xce\xcb\xda\xc2\x2f\x61\xb8\x87\x26\x47\x68\x1b\xed\x65\x55\xaf\xf3\xe0\xca\x1f\x09\x4e\x73\x24\x50\xeb\xcb\x80\x7d\xa7\x76\xf0\xbe\xe6\x8a\x52\x95\x82\xd9\xa7\xd2\xd8\xa6\x56\x49\xa5\x23\xd7\xd1\xf9\xc2\x90\x49\x32\xf0\x1f\xdc\x97\xd6\xf6\xaa\x6c\x5d\x62\xe5\x6c\x53\xf5\xaa\xcd\x68\xaa\x3d\x2b\x9e\x6a\x07\xf1\xa3\x55\x51\x46\x53\x1a\x2a\x62\x8e\xb4\x55\xab\x0e\x56\x18\x6f\x13\xc4\x75\x55\xe7\xce\xba\xad\x38\x6e\x02\x63\x04\xed\x85\x91\x18\xb2\x59\xd4\xa2\x74\x1d\xb2\x64\xa3\xb6\x43\x95\xd1\xf6\xbf\x15\x19\xae\x76\x21\xec\x0f\x72\x81\x18\xc3\xa0\x7b\x41\x2f\xcc\x79\x50\xaa\xe0\x2b\x4d\x8b\xe8\x7b\x2a\x7d\xeb\x67\x2b\x02\x31\x5e\x29\xdc\x77\x73\xa7\x70\x47\x97\x4a\x98\x04\x85\xb6\xee\xe7\xb0\x99\x16\xe0\x17\x80\xd4\xb0\x2e\xd3\x59\x5d\x26\xc5\x17\xac\x16\x39\x45\x3e\xbe\xf1\x98\xb5\x8c\xf3\x01\x5a\xf1\x4b\xcc\xaf\x5e\x65\xb3\x3e\x1a\x4e\x6f\x83\xed\xed\x76\xd7\x12\x65\xbb\xae\x8c\x7a\x43\x1b\x28\xad\xdb\x50\x69\x53\x29\x28\xcd\xbe\x26\x25\xb2\x6b\xb3\xf0\x0a\x0b\xfa\x32\x8f\xab\xd6\x60\x2e\x99\xab\xe5\x59\x8e\x38\x54\x70\xd5\xb8\xfe\xc5\xe1\x2e\x0b\xab\xab\x3a\x19\x04\x17\x05\x9e\x3e\x9a\x18\x11\x1e\x3a\x96\x5c\xa0\xde\x55\xfa\xce\x6e\xa1\x79\x95\x62\xe1\x8a\x6d\x32\xd8\x4d\xec\xfb\xcd\xc7\xd6\xd9\x4e\xab\x6b\xfc\x49\xc3\x1a\x27\xba\x48\x59\xb8\xc6\xc8\xca\x66\x06\x4f\x96\x60\x06\x4f\xaa\x8f\x01\x2c\xad\x26\x91\xed\xea\x55\x9b\x38\x57\xbf\xca\xce\xd5\xa1\xad\xed\xaa\x84\x3a\x24\xd1\xa8\x83\xbc\xca\xc6\xbf\x29\x28\xf5\x59\xae\xed\x28\x2f\x68\x63\x44\x6f\xe1\xb4\xa6\xb4\xe9\xab\x9e\x9c\xff\xa1\x36\x7a\xa4\x0f\xd0\x0b\x54\xfd\x16\xa9\xc9\xe8\x33\xa3\xca\xbc\xed\x7d\x3c\xc1\x61\x9f\x7e\x74\x2d\x8c\xf4\xad\x2f\x95\x27\x5d\x34\xf7\xed\x4f\xeb\x8c\x6b\xcb\xe3\x80\x96\x95\x3c\x18\x2f\x44\xa4\xde\x28\xce\x1e\x5a\xfb\xc3\xc3\xf3\x4e\xd3\x16\xb1\xac\x7a\xd7\xd9\x1b\x3c\x31\x34\x61\x1f\xf8\x95\x32\x5d\x37\xf3\x6f\x16\x0f\xa6\xd9\x48\x4f\x4a\x1f\xd6\xb5\xd0\x33\xb4\x78\xc6\x50\xaa\x7f\x5c\xe1\x0d\x19\x86\xa3\xd7\x61\x87\x72\x66\x6c\x2f\x6f\x54\xc5\x93\xbe\x7a\x95\xcd\x7e\x01\x93\x12\xcb\x98\x1e\x51\x61\x32\x6f\xc7\xfc\x4f\x2b\x5e\xc9\x6b\xb8\xa8\xcb\x3b\xdd\x8a\xcd\xdc\x5c\x96\x6e\xb8\x17\x27\xa5\xfe\x6f\x7b\xff\x61\xaf\x3c\x02\xff\xaa\x91\x4b\x9e\x35\xbc\xb1\x8a\x0b\x09\x8d\x74\x2f\xaf\x1e\x4d\x3d\xeb\x39\x39\x4b\x3a\xed\x78\xb6\xc0\x69\x87\x1b\xac\xc0\xae\xa5\x1c\xf6\x7b\xaa\xa8\xc8\x09\x76\x05\xf4\xfe\x6f\x15\x77\xdc\x82\x3c\x33\x4f\xe8\xd6\x62\x4d\x49\x96\x52\xce\x44\xa6\xc5\xe6\x26\x5a\xa8\xf3\x68\xbd\xe5\x7b\x63\xa2\x9c\x04\x99\x8f\x68\x1d\x6f\x2c\xab\x60\x1c\x63\xdf\x9d\x24\x5a\x24\xa9\xc6\x42\x20\xb9\xda\x4b\xb5\x3b\xcd\x2f\x9c\x89\xe8\xb3\x33\xeb\xc1\x76\xb8\x4c\xa8\x04\x57\x15\x5a\x77\x82\x84\xfa\xaf\xb3\x7a\xed\x91\x53\xae\x8d\xa7\x44\xc9\xac\xdd\xd5\x1f\x65\x65\x9d\x1b\x96\xdb\x4c\x68\x5c\xfc\x3d\x48\xe2\x88\x4c\x29\xf6\xea\xa8\x8f\xb0\xb7\x75\x28\xc5\x1e\x8c\xf7\x65\x74\x03\xe3\x30\xda\xae\x1f\x25\xb6\x2c\x95\x57\x03\xcc\x98\xd5\xae\xe9\xb6\x5a\xfe\x9e\x8e\x72\x4f\x07\x83\x62\x14\x4c\xf8\xe0\x75\x56\xd6\x6c\xd0\x15\x10\xef\xf4\x98\xb9\x94\x2e\x70\x67\x5b\x30\x68\x19\x78\x6a\xf0\x2e\x98\xf3\xdc\x0f\x2c\x69\xed\xab\xff\x3c\x89\xcb\x65\x33\x12\xf4\x8e\xeb\xc0\xa8\x97\xac\x2d\x3c\xca\x8c\xc4\x75\x9b\x95\xb4\xc0\x73\x53\xb5\x28\xd8\x8d\x3c\x73\xd7\x11\xea\xc2\xc0\x2c\xe2\x19\xe8\x9f\xbc\x8c\x5a\xfa\x9f\xc0\x52\x24\xcd\x75\x4b\x5e\x38\x45\x75\x8a\xe7\x60\x42\xdf\xba\x3c\x23\x7a\x2d\x77\x67\x52\x0f\x9c\x25\x88\xf8\xed\x6c\xef\x78\x77\x29\x5d\x5f\xd3\x0c\xd0\xe6\x51\xb7\x82\x9f\xf9\xdc\x39\x46\x81\xab\xe7\xaa\x5b\xe9\x3a\xdf\xd2\x81\xe2\x4f\xda\x4d\x34\xf1\x15\xad\x33\xab\x76\xe6\xd4\x1b\x75\xd5\x25\xb5\x1b\xe0\x24\xc3\xbb\x44\xeb\xda\x94\xea\x32\xd1\xc6\xd8\x8f\xb4\x8a\xab\x4d\xca\xd1\x75\x5c\x1d\xe9\x2a\xc6\xca\x9c\xdb\x99\x56\xcd\xbc\xcf\xf6\xaa\x2e\xdd\xee\x35\xfe\x83\x9e\x07\x6b\x3b\x44\x2f\x73\x52\x52\xdf\xad\xe6\xf4\x59\xeb\x3f\x87\xc3\x61\xcb\xbb\x03\xd2\xe1\x4d\xaa\x62\x86\x5c\x45\xb4\x14\x24\x55\x14\x3d\x82\xae\x1e\xb3\xd6\x26\x29\x09\xda\x1d\x33\x23\x86\x8f\xdd\x73\x08\x10\x4d\x73\x8e\xcd\xb7\x58\x11\xe8\xef\x15\xa4\x3e\x77\x77\x35\xa4\xaa\xa9\xcd\xba\x04\x70\x45\x50\xbd\x94\x5d\xf9\x73\xf9\x7e\x2c\x59\xc8\x74\x6a\x9f\x84\x04\x85\xea\xbe\x7a\x0e\x37\x10\x14\x6a\x32\x1d\xff\x42\xd6\xc4\xe8\x52\x75\xd3\x82\x71\xa9\xed\x01\xeb\x1c\xb3\x29\x4b\x7e\x53\x3f\x68\x21\x79\x37\xee\x5a\xb6\x5d\x45\x23\x67\x5f\xc0\xcd\xfd\x6a\xa6\xa7\x55\x35\xd3\x7d\x3e\xfd\x13\x5d\xad\xf0\xdc\x0f\xd5\x46\x7b\xb7\xd1\x56\xed\xd5\x68\xab\xf4\x7e\x4b\x4b\xaa\xb4\x26\xc5\xd6\xde\x12\x8a\xad\x3d\xaf\x55\x5f\x51\xce\x13\xda\x1d\x7c\x3b\x50\x65\xe3\x49\x10\xd2\x86\x64\x8a\x73\x2e\x29\x47\x3c\x07\xbe\x8e\xd7\xb3\xbf\xc6\xe5\x28\x9b\x96\xd2\xb4\x27\xe6\x45\x5b\x56\xef\xb2\xb3\x96\x1a\x7f\xab\xcb\x5a\x7a\x84\xe2\x03\xc6\x21\x7e\x20\xb0\xe2\x17\x80\x04\x05\xb1\xdb\x56\xc5\xa4\x2d\x28\xcb\x7c\x9d\xd7\x7c\x4b\x71\x23\x1c\x9f\xa3\x4e\x1b\x83\x79\x26\x25\x19\xad\xcd\xff\x29\x8f\xa3\x3e\xfb\xaa\x2e\xbb\xa5\x12\x03\xe9\x5d\xe4\x75\x59\x96\x86\x32\x76\xb9\x2d\x38\xe9\x30\xee\x2f\x73\x1e\xd4\x35\xe1\xc6\x7a\xaf\x69\xe2\x5d\x9c\xf2\x35\x9b\x78\x9d\x95\xab\xb5\xf0\x3f\x2f\x67\x71\x51\x57\x15\x32\xed\xf2\xbf\x35\x95\xff\xad\x5a\x1e\xcc\x96\xea\xca\x43\x66\x3d\x8e\x5f\x05\x79\xfd\xe4\xc0\x6e\x0d\x8a\x10\xbb\x52\x13\x32\xeb\x6b\x35\xcd\x62\x7d\xad\x8f\x41\xb4\x0a\x88\x1f\x83\x28\x0e\x92\x95\x46\x77\x12\xca\xd8\x59\xb7\xad\xf8\x21\x5e\x01\x2b\xf2\xbc\x5e\x57\x11\x9d\xb3\xd6\xcf\x1f\xf8\x7d\x69\x5a\x62\xba\xc0\x82\x36\x5e\x2a\x3f\x30\x8d\x0d\x55\x89\x0f\x92\x3f\x6a\x5f\x3a\x4b\xd4\x36\x1b\x08\x61\x5f\x5b\x5b\xa0\x6a\x7c\x28\x79\xdb\x43\x36\xce\x22\xf0\x00\x31\x0e\x62\xf0\x5e\x51\xf0\x88\x05\x05\x5c\x44\x4d\x82\x34\xcb\x83\x71\x00\x5e\x21\xe2\x14\xe9\xdf\xda\x1a\x65\x2b\xde\x4d\xec\x8e\xce\x98\x4d\xa7\xcc\xef\xe9\x21\xf3\x64\x9a\x0f\x83\x90\x2f\x3c\x66\x32\xe7\x72\x53\xf0\xf2\x2e\xfb\xba\xe0\x9a\xd0\x79\x5d\xbe\x2a\xe7\x9f\x00\x64\x92\x63\xcc\xf1\x5d\xbc\xa3\xf5\x1c\x07\x13\xea\xa5\xbd\x3e\x40\x2d\xd7\x4e\x6c\x40\x0e\xf0\x7a\xfa\x39\xb8\xa7\x93\x7f\x2b\x8a\xbf\x58\xe7\x02\xef\xe1\xca\xba\x21\xae\xef\xf9\xd9\x00\x8a\xa5\xc1\x98\x17\x96\x36\xc6\x28\x01\xae\x94\x9f\x23\xd3\x62\xc7\x23\x58\x38\x5a\x42\x14\x2e\xd8\x57\x36\xd1\xe1\x0e\x5a\x39\x4f\x02\x21\x47\xb7\x20\xaa\x5b\x91\xe5\x7d\xd6\x92\x3d\xb6\x16\xdd\x15\xd3\x79\xb9\xe9\xca\x09\x70\xc5\xee\xea\x45\x45\x9a\x55\x8d\x94\xe5\x45\xc5\x53\x13\x1b\x9c\x1d\x32\x51\xd0\x76\x5b\x79\x63\x4b\xd9\x4b\xe9\x5e\xfe\xbd\xbc\x6e\xb3\xbc\xac\xfb\x7f\xc3\x47\xd5\x75\x74\x4d\xb6\xbe\x4a\xa9\xd5\x38\x69\xa1\x51\x2e\x3c\x19\x35\x05\x1d\x34\x04\x79\x29\x97\xa8\xa8\x75\xb3\x9c\x22\x54\x7b\x37\x78\x08\xb1\x0d\x60\x21\xf4\x2c\x83\x2a\xf3\x84\x5c\xe7\x0b\x11\xf8\x74\x3e\xe1\x1e\x05\x08\x9a\xcf\x35\x2d\xcc\xa7\x20\x41\x0f\x4a\x51\xdf\x22\xa7\x2c\xe5\xc7\x43\xd1\x6c\xfb\x6c\x85\xda\x05\x18\x17\x35\xdd\xef\xd4\x56\x4d\xc1\xb0\xe8\x5c\x4e\x8b\xdc\x7e\x56\x1a\xc2\x45\x96\x49\xd5\xbe\xa4\xcc\x95\xa1\xc1\x56\x14\x45\xaf\xd9\x4c\x04\xa1\x56\x56\x68\x24\xc8\xf3\x60\x7e\x3c\x6c\x20\xa5\xfa\xd9\x84\xd5\x26\x71\xaa\x02\xbb\xac\x4a\x15\xed\x33\xea\xad\xb1\x4b\x1c\x34\xaa\x59\x23\x0e\x3e\xd6\xea\xa6\x88\x2f\xe1\x3c\xc7\x67\x93\x20\x8d\xc4\x2f\x8c\x96\x20\x0e\x75\x97\x97\x78\x84\x2b\xe2\x64\x94\x4d\x79\x59\x72\xdd\x7d\x39\xca\xb3\xb2\x4c\xf8\x6b\x9e\x04\xf3\xb5\xe7\x4b\x5d\x58\xaf\xb2\x0c\x46\xc1\x84\xeb\xfd\x12\xde\x87\xac\x09\x0c\x53\x4f\x7e\xd6\x6e\x47\xbd\x4b\x59\xbb\x21\x7c\x9b\xb4\x72\x33\x0f\xe8\xc6\xe7\xc6\xa2\xfa\xe6\x8c\x4b\x0e\x6d\xa5\xc9\x06\x9e\x77\x6e\x46\xf2\xaf\x3f\x02\x0c\x33\xf5\xaf\x3b\x04\x1a\x86\x6c\x4d\x3a\x57\xc2\xe7\xaa\xbc\x57\x6e\x67\xcb\x08\xcb\x8b\x76\x55\x6c\x49\xdb\x43\x7d\xf3\xe9\x59\x63\x1f\x02\x39\x79\x35\xb1\x20\x8b\xb8\x9a\xd6\x2c\x3d\x4a\xe2\xf0\xf3\x4a\x43\x17\x62\xbb\x6a\x85\xba\xe2\xbc\x8b\xa6\xa4\xc7\xd0\xbb\x68\x0a\x3d\x7e\xde\x45\x4b\xaf\xb3\xab\xd5\x88\xa4\xd2\xd2\x2f\xab\xb1\x33\xd3\x4e\xc5\xd5\xd7\xca\x62\xdd\x03\x38\x9d\x69\xc9\x97\x08\xcb\xe4\x71\x61\x55\x1e\x56\x92\x8f\x25\xbf\x54\x25\x16\x1a\x93\xc9\xdd\x91\x5a\x3b\xdb\x7f\x69\xd9\x2c\x7e\xcf\x96\x13\xe4\x43\xd0\x7d\xfd\x3a\x77\xdf\x3c\x02\xdd\xef\xca\xed\x72\x5f\xa9\x7e\x3c\x38\x19\x06\x49\xc1\x71\x84\x74\x38\x66\x90\x78\xd4\x7b\x8d\x79\xe0\xb6\x91\x1d\x9a\xf3\x68\xdb\xb2\x01\x69\x74\x1f\x28\xcf\x2f\xff\x9a\x4f\xe7\x75\xfc\x09\x75\x39\x6e\x86\xb0\xb1\xe1\x3e\x61\xf5\x24\xf5\x48\xe5\xeb\x6b\xb6\x6d\x5a\xe5\xc6\xb9\xe4\x6d\xdb\xd4\x55\xaf\xaf\x89\xdf\x44\x51\xd2\x7c\xc9\x17\x3b\x10\x9a\xca\x74\xec\x44\x8c\x80\x73\xde\xff\xf4\x4d\x40\x25\x48\xf8\x8d\x24\xb8\x2e\xb6\x8a\x8a\xe3\x36\xdb\xc9\x16\x77\xbc\x63\xe2\x65\xa3\x3c\xe6\xca\x32\x9b\x3a\xd6\x96\x63\xfe\x64\xa8\x52\x46\x8f\xb8\xd1\xd4\xa8\x63\x86\x1b\x0a\x74\xa2\x84\xcb\x41\xc1\x4d\x9b\xe3\x5a\xe3\xfa\x9a\x39\x49\x12\x3b\x46\x9b\xa2\x42\xda\x89\xfe\x11\x55\x37\xd6\xb1\xdb\xa9\x5e\x64\x63\xee\x44\xec\x36\x6d\x11\x3f\x80\x77\xff\x2e\xa9\x12\xb3\xd4\x5c\x2a\xa9\x5b\x3f\xe9\x90\x4f\xfc\xdb\x03\xbb\x84\xe3\x61\xbb\xf5\x2a\xc8\x5b\x1d\xf6\xc3\xa1\xa2\x04\x34\x12\x33\x08\x76\x83\x86\x57\x17\x7b\x17\x0c\x3e\x9e\xcb\x38\xe0\x64\xe5\x7b\x1d\x99\x3c\xaf\x75\x64\xe2\x75\xc6\xfa\xbc\xd6\x19\xab\xc7\x11\xeb\x73\x27\xe8\xbf\x86\x44\x40\x56\x48\xe8\xdb\x55\x22\x38\x3b\x6f\x70\x41\x00\xcc\xc3\x9e\x44\xd1\x9c\x6c\x0d\x72\x7b\x66\x79\x69\xa4\xc3\x95\xb4\x2a\x27\xe7\xe5\xb5\x59\x7f\x54\x5f\xa7\xc2\x9d\x9c\xf7\xc2\x2c\x0d\x83\xb2\x3d\x28\xb3\xa3\x2c\x2d\xa6\xe3\xe0\x22\xe1\xe0\x98\x47\x42\x23\xb8\x70\x35\x4f\x35\xdd\xa9\x7a\x63\xf3\xdc\x6c\xdf\x74\xc5\x78\x0f\x1e\x50\x20\x0b\x0a\x65\x41\xc0\x64\x3f\xb0\xed\xca\x62\xd0\x85\xac\x05\xa1\xda\xd2\x44\xa8\xd9\x14\x31\xea\x89\x48\x3f\xbd\x2a\x53\xaa\xeb\xcd\x42\x30\xe9\x13\x2c\x70\x5c\x3f\xb1\xca\x72\x54\x00\xa4\xfa\xa3\x9d\x2c\x15\xe5\xd8\x1b\x08\x60\x88\xee\xf8\x0b\x7c\x7e\x66\x3c\x92\x1a\xf2\xec\xdc\x43\xeb\x8a\x9e\x3b\x15\xd4\xc0\xa8\x8a\x24\x0e\x79\xbb\xc9\xc5\x21\x71\x85\x66\x33\x2f\xb4\xc1\x12\x6b\x3d\x4e\xe3\x32\x0e\x92\xb8\xe0\x4a\x78\xd1\x0b\xc1\xcd\x6b\xd3\x25\x0e\x4a\xe6\x67\xb6\x5d\x43\x83\x71\xbb\xc5\x3c\x2e\x32\xf2\x1a\x0e\x0c\x57\xb2\x19\xf8\x0c\x83\x36\x1b\x5c\x2d\x18\x4b\xe9\xe7\x62\xe1\x63\x71\x8f\xad\x74\x95\xa1\x60\xa5\x5b\xf9\x77\x26\x55\x16\x7b\x78\x96\x85\x89\x8f\x67\x5d\x54\x81\xc9\x51\x66\x6a\xcb\xef\xe5\xbd\x5f\x53\xfd\xbe\xf4\x47\x2a\xdb\x20\x81\x9b\xef\xce\xeb\xa5\xb9\x15\x72\xdf\x21\xdc\x54\xe7\xd9\x75\x2e\x67\xcd\x33\xbc\xa1\x0e\xad\x87\xd3\x16\x37\x45\x33\x8a\x7d\x33\x95\x15\x93\x13\xfd\x10\x5d\x16\x95\xaf\xd0\x6d\xbb\x6a\xe9\x7d\x5a\x15\xb1\x83\x5b\x8a\x7e\xe8\x44\x11\x9a\xf1\xcc\x96\x20\x46\xd5\xe7\xe1\x21\x13\xff\xc2\x2b\x5f\x18\x02\xfb\xee\x50\x37\x60\x3d\x0a\xaf\x18\x3e\xbb\xe4\x07\xcb\xf5\x16\xb4\xa7\xcb\x93\x1d\xcd\xba\x1e\x5d\xed\xd9\xbd\x07\x8c\x35\x62\x2e\x56\x80\x74\xdf\xf3\xbb\x74\xef\xbf\xc8\xbb\x7b\x67\xc0\x5d\x76\xfb\x25\xf6\x2d\x16\x16\xb8\x29\xbe\xc3\x10\x9a\x30\x01\x55\x71\xba\x53\x7d\x85\x8f\x52\xbd\x22\x2c\xfc\xea\x3a\xb7\x86\x28\xe8\x5b\x65\x7e\x73\xcb\x54\x3b\x53\xe5\xab\x39\xae\x63\x26\x64\x91\xdf\x37\xf2\xed\xca\x9b\x90\xef\xbd\x41\x94\x75\x18\x65\x78\x3d\x4b\x0a\xd3\xe4\xaa\xa7\x27\x6c\xca\xff\x26\xdf\xff\x1a\x1f\x21\x97\x0f\x45\xfc\xfe\x91\x96\x79\x29\x42\x1b\xdf\xda\x62\xbf\x62\x60\x87\x10\xce\xf7\x70\x83\x81\xc8\x87\x98\x1a\x18\x9a\x5d\xc7\xcb\x00\x5b\x2d\xcc\xee\x82\xe9\x04\x98\x1d\xb2\x6c\x28\xe7\xd4\x6e\x39\x48\x23\x35\x8f\xe3\x60\xce\x2e\xf8\x3c\x4b\x23\x8c\xeb\x91\x4d\xd3\x28\xc8\x63\x5e\xf4\xdc\xd1\x49\x2b\xc2\x23\x45\x23\xef\x83\x72\xd4\x1b\xc7\x69\x5b\xd2\x89\x1a\x7f\x4f\x88\x13\xea\x37\x7a\x15\x73\xe7\xd8\x6a\xeb\xb7\x4a\x5b\xbf\x99\xb6\xe6\xa4\x2d\xe9\xfd\xca\x6d\xcc\x7e\x4d\x44\xa7\xf6\xac\x4a\x6d\xe7\xe0\xa8\x69\x41\x19\x34\x14\xf6\xf7\x43\x1e\x3a\x21\x79\x5e\xf2\x52\x56\x96\x8f\x2e\xdb\x9e\xa5\xe6\x6f\xcb\x7a\x6d\xb5\x10\xf0\x17\x0e\x41\x36\x06\xdc\x5e\x38\x44\xf3\x1e\x88\xf5\x9d\xb9\xb5\x17\x51\x63\xf4\x6d\x67\x22\xfb\xb7\xe9\x97\xae\x24\xd6\x67\x59\x1e\x5f\xc6\xa9\x41\x89\xb5\x2e\xeb\xf7\x88\x1b\xe4\xae\x62\x79\x11\x42\xb0\xdf\x4f\x55\xd0\x5d\x7d\x02\xd5\xb5\xa7\xb7\xef\xcc\xf6\x8d\x87\x21\x37\xed\x61\xcd\xce\x5f\xaa\xe2\x11\x68\x93\x8e\x46\xf2\x79\x84\x91\x8c\xc4\x99\xf5\x7b\x5b\x18\x2a\xdc\x03\xf0\xf7\xbd\xaa\x6a\x85\x61\xcc\x54\xbb\x18\xb7\x8f\xbd\xc0\x09\x8e\xd3\x64\xae\x7c\xfd\x08\x96\x90\x5e\xf2\x42\x70\x41\xc1\x0b\x00\xc7\x65\xa1\x62\xce\x60\x80\x99\x51\xf0\x05\x3c\x44\x4d\x83\x24\x99\xcb\x1a\x11\x95\x8a\x0c\x78\x44\x0c\x42\x39\xca\x91\x77\xc0\x5b\x4b\xd4\x50\x56\x0b\x0c\x8e\xdc\xb4\xbc\x9c\xb6\xa4\x74\xb1\x58\x57\xc5\x6a\xf5\x55\x66\x92\xef\x4f\x9e\x28\x6a\x65\x09\xbe\x58\x8e\x70\x51\x51\xf1\xec\x74\xf7\x98\x58\x7c\x1e\x30\x17\x12\x16\xbd\x73\x9b\xd6\xe9\xc5\x85\x23\xfd\xf7\x68\x9e\x1e\x24\x58\x28\x83\x83\x2d\xca\x9f\xa1\xe0\xdb\x74\x98\xb5\x89\xce\x4b\x10\x2b\x14\x75\xa9\x2b\xe5\x33\xad\xb5\xb6\xf8\x0c\x94\x16\x8c\xa6\xa2\x7c\x44\x4b\x4b\xb2\xe0\x5d\xaa\xd3\x6d\x56\xcb\x54\xa6\x83\x96\xb5\x84\xf9\x35\x1e\x15\x12\x5c\x39\x62\x1f\xcd\x32\x5d\x77\x19\x5f\x8e\x7d\x49\xe8\x79\xf4\x72\x58\xf2\x5c\xdf\x0d\x2d\x31\xa9\xb2\x98\x6f\x4e\x45\xd6\xad\xa6\xd4\x3f\x79\x58\xeb\xc5\x2d\x27\x91\xf5\x7d\x99\xa0\xde\x25\x76\xac\x8b\x27\xf8\x16\xd3\x7b\x27\x93\x2b\x90\x66\xcd\x2d\x49\xf7\x4f\x6c\xed\xe2\x7c\x5b\xf2\x71\xdd\x02\x4d\x4c\x17\x2e\x0e\x48\x08\x64\x1f\x6e\x0d\x03\xc1\xbd\x55\xf4\xd2\x67\xf4\x79\xb3\xb3\x05\xf3\x44\x09\xea\x95\x57\xe4\xd5\x0d\x9d\x14\x96\xa6\x96\xe0\xa6\x44\x48\x49\x3c\xe9\x85\x18\x07\x53\xfc\x9a\x1b\x72\x56\x2a\xaf\x06\x0c\xc0\xf5\xab\x85\x81\x95\xc6\x6f\x6e\x27\x1a\xbb\x5d\xb8\x7e\xc0\xf1\x59\xb3\xdb\xfc\x45\xe4\xc2\x7b\x13\x9e\x17\x71\x51\x5a\xc4\xa2\x53\xdb\x15\x9f\x12\x36\x21\xbb\x2b\x5d\xaf\xbf\xba\xe1\x54\x31\xe8\xe7\x07\xaa\x9c\x8f\x21\x40\x9e\xc5\x11\xe8\x3a\xff\x97\x5c\xae\x30\x24\xdf\x7a\x85\x8c\x5b\x2e\x58\x13\xcb\xb2\x09\xd1\x60\x2d\xfc\xf3\x7a\xd7\x4b\x89\xba\x5e\x42\xef\x21\xa2\x45\x7a\x8f\xea\x60\xc9\xf4\xb8\x16\xc9\x52\x92\x38\xd3\x6d\x9e\x77\xdc\x9d\x7b\xb9\x6d\x02\xcb\x2a\x8f\x9c\x36\xc1\x91\xd6\xc9\xe6\x2b\xcb\xb6\xe5\xde\xb1\xc4\x84\x80\x01\x48\x33\xd1\xab\x22\x0e\xbd\x43\xb2\xad\x68\x5c\x87\xd6\xa0\xb9\x5b\x23\x8a\xd0\x24\x34\x70\x8b\x91\x6b\xa3\x8e\x25\x96\xbc\x2c\xe6\x5b\xf1\x22\xeb\xee\xb0\xa0\x9b\x5c\x07\x13\xba\x91\xdb\x62\xe3\x97\xc9\x12\xb8\x80\x42\x3e\x4c\xfc\x32\xb9\x63\x3c\xfc\x32\x59\x1b\x0b\xbf\x4c\x6e\x81\x03\x1d\x0c\xb8\x71\x53\xeb\xc9\xa3\x24\x94\xe6\x05\xfb\xee\x10\x1e\xa1\x42\x4c\x64\x27\xcf\x7b\x17\xa8\x39\xb8\xb3\x93\x56\x5a\x3e\xdb\x3e\x6f\x82\x59\x19\x0b\x1b\xd9\xc2\xb8\xdd\xab\x1c\xcd\x77\xb6\xed\xb9\x9c\xc9\x30\xe2\x98\x87\xd1\x35\xe8\xb9\x49\xbf\x61\xc5\xfc\xca\x13\x56\xf3\x80\x15\x0b\x54\xdf\xaf\x1a\xbd\x27\x96\x50\xae\x70\x30\x77\xe9\x60\xe2\xfe\x97\xfc\x63\xc5\xdc\xc9\xe0\x8f\x87\x3f\xe5\xb1\x74\x12\x7e\x77\xfe\x1d\x41\x6b\x16\x87\x9f\x0b\x5b\x93\x73\x87\x1d\x50\xd3\xa4\x2e\x4e\x0c\x7d\x27\x03\x8e\x16\x57\xf7\x79\x30\x55\x98\x82\x41\xe0\x21\x1f\x71\x24\x7b\x12\x02\x2f\x79\xba\xb1\x92\x63\x48\x2d\x2f\x76\xba\xb6\xde\x98\xfa\x42\xd7\x11\xfd\xa9\xa6\xd5\x5e\x85\x5a\x63\xb7\x1c\x4d\xef\xd8\x34\x3d\xa7\x34\xbd\x83\x91\x5b\x6a\x69\x7a\x67\x11\x4d\xef\x2c\xa4\xe9\x9d\x7f\xd3\xf4\x72\x34\x3d\xff\x66\x34\x3d\xbf\x57\x9a\x2e\xb3\x09\xfd\x6d\x28\xda\xd2\xf7\x5b\x24\x5d\xf5\x88\x6a\x91\x71\x30\x8b\x8b\x8a\x29\xc4\xdd\xa3\x25\x30\x58\xf1\xc0\xe8\x8d\x6f\x59\x01\xf3\x7d\x30\xb1\x97\x5b\x80\xab\x6d\x45\x0b\x91\x40\x01\xfb\x32\x9d\xcb\xb7\x76\xc7\x43\x6c\xcb\xc0\x8c\xb1\x35\x4d\x97\xce\x25\xd9\x7d\x21\x0a\xce\x64\x1a\x5f\xf6\xe4\x10\x22\x26\xc0\xd8\xd7\x09\x86\xf2\xb2\x3c\x12\x07\xd1\x53\xab\x68\x3d\xbc\xdb\x4a\x2e\x2a\xb2\xbc\x7c\x35\xb7\x64\x22\xab\x03\x32\x37\x99\xf7\x45\x71\x46\xae\x2f\x68\x88\xd4\xae\x0b\x3e\x3e\x90\x0e\x2c\x56\x49\xb2\x5e\x05\x69\x84\x66\xff\xab\x22\xfb\x52\x21\x5b\x35\xe5\xe2\x5b\xbd\x0b\xbc\xf1\x90\x26\x7d\x70\xee\x68\x77\x80\x64\x1c\xeb\x0b\x50\xae\xef\x6c\x37\xdc\xc8\xd6\xf9\x1c\xdc\xd9\x6e\x72\x3a\x58\xeb\x72\x70\x67\xbb\xd1\xe7\xa0\xdf\xe3\xa0\xae\xe4\x71\x39\xe8\xdc\x16\x13\xb9\x89\x4a\xd6\xdf\x29\x1f\xc8\xd7\xd7\x4c\xfd\x56\xae\x28\x11\x57\x22\xc3\x1d\xab\x48\x73\xa1\xf5\xd8\xee\x55\xdd\xb3\x4b\x67\xb7\xda\x2c\x85\xca\xfe\xca\x36\x85\x14\xcc\x79\xa1\xed\xc6\x95\xaf\x3c\x93\x8b\x00\x1e\x65\xe3\x49\xa3\xe3\xb7\x9d\x27\xca\x79\xdb\xd1\x34\xff\xe2\x7f\x4b\x6b\x9d\xe0\xf5\x7b\x4e\xbc\xfd\x93\x1e\x13\x80\x16\x5b\xf6\x28\x0d\x74\x2e\x36\xcc\x4a\x59\x16\xca\x3d\x0d\x65\x9e\x15\xfe\xcd\x50\xe3\xd2\x58\x47\x38\xb0\xbe\x0a\x16\xc0\x69\x4e\x3b\xb8\x14\x3e\xf2\xb0\x84\xd0\xb3\xf4\xd5\xfa\xb2\x20\x3f\x53\x20\xeb\x56\x96\x05\x9b\xde\xae\xe6\xe0\xcc\xa2\x55\xb1\x65\xd3\x30\xa2\xff\x37\x0f\xf0\xd2\x31\x9c\xf3\x8c\x39\x9c\xc9\xa0\xf1\xb4\x50\x2f\xac\xb8\x62\xf2\x96\x72\x7c\x32\xe5\xe0\xfa\xc1\x57\x12\x73\xdc\xd7\xf0\x41\x5e\x82\xab\x09\x5f\x0d\x93\x6b\xd7\xe2\x69\x54\x5b\x47\xe5\xd9\x35\x26\x1a\x21\x6e\x79\xcc\x71\xbd\xb1\xf1\x04\x8c\x41\x75\x47\x9b\x04\xd2\x03\x2f\x99\x58\x9e\x85\x67\x7d\x16\xce\xba\xe0\xbc\x2a\x9c\x77\x49\xdd\x3e\xf9\xdd\xd5\xcd\xf7\xf5\xaf\x2e\x8b\xd3\x94\x4b\xff\x19\x7d\x89\xcc\x2e\xcb\xa6\xa5\x9b\x68\xf6\x95\xdb\x53\xe1\xbe\xa2\xc2\x13\x1e\x96\x99\xdf\xe3\xa1\x43\x82\xfe\xb5\xf1\x55\x22\xb6\x5f\x4b\x68\xab\x80\xb7\x14\xf7\x91\xd0\x11\xe6\x86\x9e\xff\x1c\x87\xfc\xad\x81\xf6\xcd\x80\xdd\xb7\xaa\xfc\xb0\xc1\xf1\x9e\x71\x30\x17\x86\x61\x4b\x75\x6a\xac\x75\x34\x32\xee\xd9\xe5\x9b\x6f\x9f\xe9\x50\xa9\xde\xf5\x77\xe7\xee\x6e\xca\x55\x9a\x49\xf1\x3a\xb1\x94\xd2\x87\xc2\x15\xb9\x8b\xb8\xa5\x98\xdc\xe8\x71\xd5\x3b\x1a\xf6\x62\x2d\x77\xab\xbe\x36\xbb\x74\x82\x3b\x6c\x09\x39\xaa\xc9\x29\xb9\x21\x5f\xbb\xdd\x5a\xd1\xc9\xf8\xb8\xf1\x48\x4f\xcd\x41\x3d\x94\x8c\x0f\x3a\x73\x43\xd4\xe5\x7c\xc2\x75\x2c\x8a\x03\xa7\xac\x0c\x89\x4a\x84\xaf\x33\x1a\xd3\xc2\x0a\xb6\xaf\xea\x60\x7c\x0b\x19\xa2\xff\x7d\x30\x39\xb3\xd0\x68\xd5\x7f\x1b\xb5\xce\xcf\xd7\xa1\x83\x9a\x19\xab\x0d\xe2\x41\xc9\x9b\x10\x6b\x35\x14\xc7\x8a\x81\x38\xee\xed\x20\x4c\x87\x00\xe7\x98\xde\x38\x98\x90\x17\x21\x10\xb0\xc7\xef\x8b\x88\x62\x02\x8a\x55\x9c\x25\xd2\xcb\x4c\x8c\x0f\x64\x24\xe3\x4d\x15\xa1\x12\xb8\x13\xa9\x47\x8d\x0e\xb4\x77\x18\x6d\xad\xe4\x21\xdd\xff\x59\x9d\x6c\x69\x58\x60\x6a\x76\x33\xd3\x11\x78\x5d\x1a\xbc\xf8\x9d\x46\xe1\xb4\x17\x32\x24\xbf\x8d\x2a\x84\x27\x9b\x76\x23\xe7\x5c\xfc\xde\x1c\x35\xa7\x76\xc0\xbf\xad\x3e\xe0\x79\xcd\x80\xe7\xcd\x03\x9e\xfb\x07\x3c\xff\x46\x03\x06\xdd\xd6\xb2\xa7\xba\x9d\x86\x53\x1d\x9d\x6f\x59\xda\x1b\x30\x7a\xee\x29\xe7\x0b\xf0\xec\x9e\xc2\x5c\x4d\x9f\x31\xf5\x7f\xda\x60\xea\x6f\xfb\x81\x7c\xda\xa4\x70\x94\x25\x9c\xf0\x26\x54\x51\x7f\x5f\x6a\x16\x1d\xb8\xf6\xc0\xa3\x49\xbd\xaf\x4e\xe7\xa6\xd3\x7b\xe0\xe5\x5f\x1b\xb9\x72\xeb\x32\x8f\x23\xe2\x8f\xcb\x31\x75\xd6\xe9\x96\xc9\xb3\x49\x96\x4a\x43\xaa\xca\x36\x99\x4a\x87\x68\xa9\x05\x49\x57\xa8\x6c\x71\x2e\x5b\xe6\x98\xea\xa8\xab\x33\xf9\x84\xda\xb5\x16\x6f\x88\x18\xd2\x18\x2f\xa4\xe9\xb6\x48\x8b\xce\x4d\x85\xc8\x28\x1b\xd5\xf4\xba\xb1\xe6\x62\x44\xac\xab\xe1\x0e\xda\x4b\xe0\xd2\x2c\x62\xb7\x81\x45\xe4\xda\x1d\xa0\xb5\xfe\x77\x7b\x56\x86\xa5\xbc\x51\xde\x07\x9d\x0a\x34\xdd\xd6\x7b\xe8\x96\xee\x71\xe9\x58\xe0\x5a\x8b\x56\xc3\x75\x9f\x4a\x59\x32\x76\xab\x73\x38\xbe\xeb\x5c\xe7\xdc\x0e\xa7\x76\x92\x69\x1d\xd7\xc9\x61\xd3\x2a\x45\xd2\x2d\xd6\x6c\x8e\xa1\x56\x71\x92\x6e\x74\x65\xf7\xc3\x55\x26\xda\x37\xe5\xfd\x88\x6e\x6a\x4c\xb7\x95\xdc\x5c\x59\xcc\xaf\xf7\x9d\x18\xe7\x98\xf7\x01\xbd\xa1\xcf\xfb\x01\xdf\xd5\x6b\x58\xba\x0a\x4a\x33\xb6\xc2\x82\x7c\x34\x0b\xed\x2d\xc0\xcf\x26\x6c\x12\x8b\x79\x14\x58\xc3\x2f\xc1\x9f\x60\x7f\x7f\xd6\x20\x2b\xe8\x18\x66\xb2\x68\xaf\x1a\xd5\x49\x3e\x0e\x56\x05\xcc\x03\x62\x8b\x07\x3e\x69\xe0\x81\xae\x58\xf3\xc4\xf3\x16\xa9\xe6\xa1\xe9\xce\x93\x86\xd7\x7e\xde\x77\xa6\xb2\x86\xef\xa1\x69\xe5\x99\xe9\xce\x13\x6a\x11\x8f\x85\xb6\xb6\xd8\xe9\xf1\xeb\x63\x65\x24\x2e\x8d\xfa\xaf\x46\x3c\x35\x6e\x38\x30\xeb\x0f\x90\x21\x8c\x46\x07\xc0\x22\xe2\x44\x96\xe2\xe3\x88\xd5\xd7\x56\x04\x6b\x4b\x3e\x9b\x02\xbb\xb5\xbf\xa1\x55\x97\x5c\x61\x96\xf5\x08\x79\x8e\xd1\x05\xcd\xbd\x16\xc5\x8d\x9d\x16\xe4\x76\x6c\x6f\x03\xf8\xb6\xef\x96\x52\x90\x7b\xe1\x69\xbe\x69\xe4\x7c\x7f\xa8\xbb\x8a\x04\x75\x87\x2f\xcb\xed\x11\xa3\x79\x01\x98\xe3\x54\xd3\xd9\x0b\x6f\x6a\x9d\x40\x57\x2c\xf1\x8c\x93\xfb\x9f\x4b\x3e\x70\xa9\xbd\xcf\x5a\x80\x26\xd0\x03\x38\x4f\x93\x1b\x58\x4c\xc5\x8f\xf7\xad\x0f\x88\xf4\xc6\xe8\x16\xf7\x3d\x72\x69\xee\xdd\xea\xdc\xb5\xb7\xe4\xb9\x6b\x6f\xa9\x73\xd7\x9e\xef\xdc\x25\x47\xa2\x03\xa7\x58\xf3\x59\x81\x0e\xb9\x8c\x55\x47\x1d\xe8\x2b\x10\xfa\xca\xca\x8c\xfb\x96\x29\x56\xd4\x1f\xd1\x13\x85\x38\xc7\x2b\x55\x85\xff\x74\x21\x4a\xcc\x2b\x25\x8c\x75\x04\xc5\x5d\x0d\x3f\xa8\x3d\x17\x2d\x38\x19\xd5\x9c\x8d\xcc\x16\xbf\x78\x21\x58\xfe\xca\x57\xd2\x92\xa8\xb0\x43\x48\xcd\x95\xf8\xe4\x8b\x75\x18\x72\x2d\xc5\x4e\x40\x3c\xef\x42\x22\xfd\x5a\x5e\x5a\xd6\x0c\xe9\xa5\x81\x34\xbe\x44\x3a\x1e\x31\x60\x7f\x95\x3b\xf0\xfd\xc5\x77\xe0\xce\x4b\x69\x5d\xb1\xfe\xb5\xb4\xe3\x37\xcb\xba\x3c\xae\xc4\x4d\xfc\xd7\x8c\x9a\x48\xb0\x6f\x82\x2c\xed\x5a\x21\xa0\x28\x26\xcd\x45\x20\x29\x2d\x2f\x01\xed\x79\xd2\x51\xa8\x68\x41\x99\x4c\x4b\x5e\x04\x05\x44\x93\x70\x8b\xaa\xf4\x2a\x88\x1e\x38\xfd\xc0\x36\x45\x9e\xda\xf5\x87\x9e\x1a\xc5\x11\xf7\x96\x16\x19\xd6\x54\x8f\x82\x42\xd3\xe0\x77\x50\x6d\x63\xa3\x42\x9e\xe6\x19\xb4\x72\x1f\x66\x60\xd2\x1f\x16\x5d\xfe\x70\xc8\xb6\xc1\x53\x18\xa0\xd4\xf7\xb8\xd7\xb2\x1c\xd0\x50\xb8\x97\xd9\x76\x1c\xb2\xa6\xd6\x68\x2d\x1a\x90\x4c\x4d\xe1\xc6\x86\x99\x23\xf2\xbb\x11\x34\xe3\xda\xc6\xe2\x1f\x4d\x9e\x95\x6c\x05\x2d\x0d\xc3\x66\xc5\xf1\x82\xe7\x4c\x10\x76\x8d\x0e\xd1\x8a\x40\xd5\x35\xc3\x20\xc1\x8f\x68\xe8\xa2\xbe\x07\xf3\x1e\xea\xed\xab\x1f\xe4\x34\xe7\x71\xee\x54\x13\xf5\xc8\x8b\x01\x25\xe8\x8a\xff\x9f\xd7\xb9\x89\xf2\x55\x39\xd7\x7b\x8b\x7c\x03\xcb\xc7\xa0\x82\x7c\xb0\xd8\xf3\xb8\xd8\x8f\xb6\x1e\xb1\x51\x90\x8f\xb3\x74\xae\xd7\x3f\x9f\x4d\xb2\x5c\xb0\x01\x36\x18\x5c\xf1\x8b\x49\x10\x7e\xfe\xff\xd9\x7b\xd7\xb5\x36\x72\xa5\x61\xf4\xf7\xe2\x2a\x14\xbe\xf5\xc6\x36\x18\x1f\x38\xe4\x60\x86\xc9\x72\x80\x24\x24\x01\x92\x40\x26\x93\x61\xf1\x40\xd3\x2d\xdb\x1d\xda\xdd\x9e\x56\x1b\xe3\x21\xfc\xda\x3f\xf6\x9f\xef\x02\xf6\x0d\xec\x67\xdf\xd7\x7b\x25\xfb\x51\x95\x8e\x7d\x30\xc6\x90\x99\x79\xd7\x47\xe6\x79\x06\xb7\x0e\x25\xa9\x54\x2a\x95\x4a\xa5\xaa\x13\x4c\x13\xfa\x94\x63\xf0\xd2\x85\x4a\x2f\x9a\x86\x5e\x01\xa0\x0b\x0b\x75\x38\xe1\xd6\x17\xc8\xda\x33\xb2\x50\x17\x49\xea\xcc\x5c\xee\x47\xde\x10\xae\xea\x11\x70\xd5\x68\x2b\xa6\xbf\x0f\xfd\x98\x9e\x9c\x70\xa4\xcd\xcd\x0f\x19\x25\x2c\x89\x7d\x37\x99\xe7\xc3\x42\xde\x59\xf3\x68\xc7\x0f\xa9\x08\xf6\x33\x2e\x2b\x30\xf3\x27\x27\x94\xed\x02\xf0\x79\x94\x45\x44\x04\x28\x7e\x6e\x9f\x83\x0b\x57\x60\x18\xbb\x43\xff\xb0\x47\xfb\x1c\xc2\x85\xef\xe1\x4b\x94\x6c\x0f\xca\xab\xcd\x15\x5e\xe5\x86\x46\x4b\x69\x68\x25\x6c\x9a\x86\xc3\x3e\x8d\x39\x29\xeb\x37\x78\x5d\x9a\x18\xe1\x01\xba\x34\x51\x4f\xda\xe4\x85\x84\x1f\x26\x34\x8e\x06\x9f\xb0\x13\xc2\x91\x63\x39\xd3\xe3\x8a\x34\x48\x85\x99\x37\x86\x36\xf2\x93\xde\x41\x32\x0e\xd0\xe7\x7b\xce\xa0\x9e\x4c\x33\x24\x0d\xe5\x47\x0c\x46\x43\x9f\x38\x0c\x18\x70\xc1\x28\x9e\x2f\x4f\x3b\x0c\x80\xf2\xa3\x46\x01\xc0\x0b\x07\x81\x97\xdd\x72\xea\x0a\x46\xd2\x7c\xfa\x7c\x9a\xa1\xd8\xb0\x7e\xc4\x78\xec\x16\xf2\x06\x65\x7a\x1d\xcb\x03\x11\x9d\x7d\xab\x90\x2b\x65\xb0\x79\xf6\x8d\xef\x0c\xd1\xd9\xb7\x9a\x5e\x96\xe4\x05\xa4\xb7\xc8\x95\xe4\x38\x2d\x48\xb8\x5e\xe7\xfc\xce\x66\x1d\xcf\xef\xc4\x3a\xea\x75\x11\xb4\xd5\x09\x48\x9d\x30\xbf\x3f\x08\x28\x71\xa3\x30\xa1\x97\x09\x39\xf3\x43\xcf\x0f\xbb\x30\x4d\x8e\x7c\xb0\x53\x30\x41\xcb\x2b\x7c\xc9\x60\xbb\x35\xd1\xac\x25\xad\x77\xc2\x2a\x49\x7a\x0e\xc4\x83\xd7\xde\x03\x15\xd8\x72\x27\x84\xdd\x81\x6f\x08\xbc\x18\x58\x9b\x0d\x43\x9c\x69\xaf\xa2\x9c\x58\x82\x7f\x1b\x36\xf2\x13\xb7\x47\xca\xb6\x1f\x42\xd7\x61\x94\x34\x5b\xaa\xa8\x36\x63\xce\xfa\xc2\x0c\x6b\xae\x13\x04\x65\xec\x90\x53\x31\x36\x08\x01\x67\x39\x0f\x4e\x95\x9c\xdd\x04\x8a\x17\xc9\x42\x5b\x29\x80\x56\x25\xee\x14\x00\x79\x29\x73\x0b\xd3\xfb\x96\x86\x56\x5f\x20\xb5\x5a\xcd\x89\xbb\x8c\x2c\xd4\x53\xb4\xdc\x09\x6b\xce\x60\x10\x8c\x25\xc8\xb8\x3b\xe4\x67\x09\x3c\x40\x5c\xe3\x26\x67\x53\xd5\x93\xc6\x9d\xa8\x0a\x0e\x5d\x4c\x5c\x20\xe4\xd3\xcb\x5a\x73\x32\xb9\xf8\x42\x65\x81\x07\x2f\x01\x8b\xa7\x56\x20\x3a\xc1\x88\x70\xb9\x7e\x3b\x8e\xa3\xb8\xec\x27\xfc\x98\x4c\x7c\x46\xc2\x28\x21\x0e\xac\x29\xea\x26\x8f\x4a\x30\x3e\xe5\x82\x31\x77\x9c\xcd\x29\xc6\x09\x43\x9a\xd0\x55\x7a\x49\xc5\x2c\x26\xf1\xd8\xc6\xfc\xa3\x47\x3c\x13\xad\x35\xaf\x89\xeb\x00\xd5\xd2\xd4\xf4\x70\x9e\x24\xf8\x47\xb6\x83\xcb\xd3\x76\x50\xc8\xd5\xfb\xa3\x50\xf2\x45\xb2\x41\xae\xae\x6b\x76\xda\x0d\x38\x87\xe8\xc1\xd8\x3d\xd1\x39\xbb\x3a\x52\xa6\x2c\x97\x8b\xd1\x95\xbf\xa3\x28\x23\x6c\x5b\xd4\xb9\xb2\xe6\x30\xe6\x77\xe1\x01\xbe\x1e\x7e\xe2\xc4\x5d\xf0\xaa\x45\x3a\x51\x4c\xca\x40\xc4\x64\x83\x34\xd7\x89\x4f\x7e\xd2\xab\x46\x3c\xee\x5b\x27\xfe\xe2\x22\x2f\x0c\x2e\x6f\xa2\x61\xec\xf2\xbd\x4b\x95\x3a\xf2\x8f\xd7\x35\x9c\x73\x3a\x26\x7e\x28\x8a\xf1\x4a\x3a\x74\x38\x3f\x7a\x25\x11\x58\x57\xe5\xe1\x1a\xab\x20\xbe\x79\x45\xec\xe4\xd1\x39\x1d\x73\x11\x13\x73\xe1\x6b\x9d\x5c\xc3\x7f\x92\xa8\xa0\xdc\x3a\x28\x54\xd0\xcb\xe5\x78\x40\xa3\x0e\xd9\x20\xe2\xc7\xc1\xb8\x7f\x16\x05\xc0\x66\xe7\x25\x0e\xe6\xe1\xd0\x65\xe6\xf3\xd3\xa1\x78\x17\xc2\x0b\x32\x48\x9c\x27\x2f\xcc\x87\x08\xd6\x7e\x26\x6a\x47\x67\xdf\xd6\xc1\x69\x52\x51\x39\xb1\xef\xdd\xd4\x19\xbe\x2f\xba\x51\xc8\x92\x78\xe8\xca\x5e\x88\xc2\x98\x0b\x7e\x79\x44\x5f\x15\x26\xc9\x0b\xdd\xd5\x96\xdd\x25\x5b\xea\xd8\x0c\x1c\xc6\xd2\xce\x13\xf4\x97\x45\x76\x3e\x65\x82\x44\x74\x94\x78\x9b\x52\x1a\x48\x29\xc2\x40\x3e\x4b\x25\x1e\x65\x6e\xec\x0f\xf0\x95\x0d\x5a\xb9\x71\x2a\xd1\xc9\x35\x2d\xaa\x90\x8d\x82\x74\x4e\xb2\xe0\xc9\xd9\xcc\x77\xa3\xb0\xe3\x77\x87\xb2\x26\x70\x14\xa0\xb1\x79\x58\x0f\xf3\x9c\xf8\x74\xf1\x8a\x59\x75\x14\xfb\x89\x55\x2d\x7f\xc9\xc9\x91\x1b\x35\xcf\xe9\xd8\xfc\xae\xac\x9b\xf4\xa7\x31\xba\xa9\xa7\x0f\x10\x97\x44\xc2\x6a\x95\x25\x4e\xe2\xbb\x1f\x24\x2a\x79\x77\x75\x76\x25\x8b\x7c\x03\x90\x9e\x6a\x13\x64\x65\x5d\x3a\x78\xd2\x70\x27\x41\xb1\xbb\xb0\xae\x0e\x83\xba\xc4\x3a\x88\x5c\x65\x2d\x70\x3b\x71\xe8\x87\xdd\x22\x21\x75\x35\x5d\x10\x2c\x13\x8a\x24\x63\x2c\xa2\xaa\x24\xd1\x26\x2b\x3a\x8e\x34\x9f\xae\xd8\xe5\x26\x01\x86\x02\x76\xf1\x5f\xc0\xd7\x5e\x81\xe4\xf6\xa4\x91\x53\xf8\xc6\x06\xa0\xd4\xfd\xcb\xbb\x2a\xd0\x9c\x29\xf1\xea\x26\xc0\x18\x73\xd3\x09\x82\xcd\x1e\x75\xcf\xcb\xbe\x70\xad\x5b\x35\x27\x4d\x12\xd3\x23\x95\x4d\xe4\x8f\xa8\x63\x15\x04\x86\x0a\xd2\x44\x48\x4d\x89\x62\x7e\xd3\x09\xb9\x2c\xc1\x39\x30\x71\xd0\x02\x94\x38\x8c\x38\x8a\xac\xe7\x91\xda\x11\x6d\x70\x4a\xfb\x34\x0c\xf2\xdc\xb0\xa8\x6f\x55\xa8\x0c\xeb\x46\xc4\xdd\x43\xe1\x5b\xbd\x05\x4c\x8f\x2f\xe9\xf9\xac\xaa\xab\x56\xac\xe7\x7b\x68\x9f\x2b\x62\xf1\xae\xeb\x0c\x9f\x7d\x88\x23\x97\x32\x46\x41\x5f\xae\xdd\xbe\xc3\x4e\xd5\xa3\x70\xd3\x22\x1a\xae\xc1\xb7\xd6\xdf\x7c\x02\x15\x12\x9c\xf5\x65\x09\x99\x64\xdc\x8e\xd1\x80\x22\x37\xd6\x60\x44\x92\xd9\x41\x34\x8a\x57\x31\xf0\x21\x4d\x94\xd7\x35\x8d\x3c\x19\xf7\x18\xfe\x6a\xe7\xde\x12\x74\x45\x94\x12\x9f\x87\xfc\x84\xb2\x41\x74\xc3\xc4\xbe\x36\x80\x31\xe0\x68\x5f\xe0\x5f\x9d\xd1\x82\xf9\x96\x03\x13\xe2\x19\xef\x79\x7d\x61\x81\xc3\x59\x20\x07\x34\xd1\xc3\xc4\xb0\x31\x35\xcc\x69\x27\x09\x0d\x31\x50\x22\x97\x55\x78\x8b\xe8\xe2\xd2\x75\x86\x3c\xb9\x46\x76\x23\x96\x90\xb3\x38\x1a\x31\x1a\x33\xe2\xf9\x5e\x58\x4a\x08\x9c\xac\xb8\x64\x80\x50\xac\x51\x30\x9a\x24\x94\x73\xa3\x08\xc1\xf5\x9d\xb1\x70\x77\xce\xf9\x76\x4c\xb1\xdf\x9c\xef\x44\x1d\xc2\x1b\x8f\x29\xd2\x04\x39\x80\x71\x01\xc8\x3a\xe8\xb3\xcc\x7d\xad\xac\xe8\xa6\x4a\x8e\x90\xbe\x30\xfe\x37\xdf\x7a\x4a\x55\x71\xb3\x25\x86\xcc\x3b\xf5\x9a\x26\x84\x0f\x97\x26\xc4\x11\x51\xa8\x07\x52\x18\x11\x65\xea\x82\x90\xec\x88\xe1\xbc\x54\x39\x84\x6b\x93\x90\x5e\x26\xc8\x1a\xd4\xb9\xa6\x5e\x27\x3b\x49\x89\xaf\x1e\x1c\x68\xcd\xd0\xfd\xa9\xe2\xd2\x9d\x82\xa9\x05\xac\xd7\xc9\x56\xc4\x91\xe7\x45\xc4\x09\xc7\x49\x8f\xa3\x40\xb8\xfe\x43\xef\xa1\x3d\x07\x85\x7e\xe1\x40\x41\x7b\x04\xc5\x63\xa4\x24\xaa\x23\xde\xb7\x63\x10\x15\x72\xfa\xc7\xff\xe9\x7e\x6c\x58\x84\x5a\xfb\xc6\x58\x6d\x10\x0c\xbb\x7e\xa8\xef\xd4\xa1\xa0\xee\x7a\x95\xe0\xd0\x79\x3d\xcb\x8f\x66\xa6\x03\x46\xf3\x96\xf3\xc8\x7a\x5d\x10\x23\x6c\xc4\x3e\x13\xbb\x96\xc7\x87\x01\x93\x08\xf3\x2c\x96\x0c\x39\x0d\xfc\xf0\xfc\x94\x17\xe3\x1b\xb6\xe9\x05\x55\x8d\x3a\x56\xd0\x2a\xf6\x9a\x40\x07\x43\xe3\x80\xa6\xcb\xc9\x41\x68\xfc\xac\x67\x7c\x48\xda\x1c\xc4\x42\x13\x24\x5a\x63\x12\x8b\x17\x0a\x3f\x7e\x2c\x56\xa0\x93\x24\x8e\xdb\xa3\x5e\x36\xd4\x67\xb9\x51\xd5\xbb\xe6\x91\xda\x05\x8e\x2b\x65\xf1\x2a\xb7\x04\x0c\x56\x1c\xf2\x38\x06\xa8\x57\x23\xbb\x3e\x63\x9c\x28\x98\x89\x9f\x79\x9e\x8b\x47\x80\xf9\x5a\xa9\x32\x21\x5a\x68\xe6\x1a\x52\x9f\xc9\xc0\x17\xbc\xcc\x9c\xcb\xe4\x99\xd3\x6a\xb9\xa5\x37\x96\x53\x9b\x9f\xb9\x49\xcc\xbb\x9d\x70\x02\x96\xf7\xbc\xc4\x0f\x03\x3f\xa4\x7a\x49\xcd\x19\x31\xfa\x71\x85\xc2\x71\xfd\x30\x12\xf6\x25\xe9\xe5\x26\x72\xcb\xe6\x2c\x9b\xf7\x9d\xdf\x18\xa8\x69\xc4\x23\xef\xb7\x07\xfb\x7b\xfa\xbd\xa0\x12\x58\xf9\x9a\xe5\xec\x85\x17\x36\xa7\xa3\x80\x5c\x4c\x4a\xe1\x55\xab\x50\xf1\x88\xff\x34\xbc\x95\x64\xb0\x97\xc5\xca\x27\x28\xc2\x08\xef\x16\x89\xe9\xc0\x78\x79\x24\xfd\x78\x72\x94\x49\xec\x90\x57\x4e\x10\x9c\x39\xee\x39\x23\x4e\x4c\x61\xf2\xd9\x70\xc0\x8f\x7f\x6a\xb9\x2f\x90\xcf\x8c\x76\x86\x01\x8c\x0d\x71\x8b\xdc\x8b\x4d\x42\x31\x22\xa6\x00\xc3\x12\x6b\x79\x68\xbd\xba\x2e\xc4\xa5\xa6\x8c\xf4\x95\xd2\x85\xc9\x5b\x90\x76\x00\x75\xeb\x16\xc7\x2a\x8b\xa3\x8a\x28\xbd\xb1\x41\x4a\x4a\x05\x56\x22\x2f\xac\xaf\x96\x3c\xd2\x95\xa1\x74\xa5\x02\xec\xad\x84\xba\x8f\x52\xc5\x98\x1e\xb2\x81\x00\xd7\xd5\x83\x4e\xb8\x35\xaa\xf9\x0c\x6f\x8f\x64\x7d\xab\x06\xac\x47\x43\x1c\xb4\x96\xe4\x85\x90\xfd\xec\xc5\x23\x26\x9f\x83\x29\x9a\x7c\x61\x06\x4c\xf9\x66\xb0\x79\x70\x60\xee\xac\x85\xd3\x74\x00\x65\x0a\x27\x0a\xb3\xcb\x29\x41\x6a\x6a\x56\x05\x2f\x9c\xfd\xf0\x3c\x23\x2c\xc8\xe2\x90\xd9\x32\xc5\x28\xe1\x15\x69\x00\xda\x13\xc8\x4e\x79\x70\x14\x55\xc1\xe3\x6f\x10\x44\xa3\xed\xfe\x20\x19\x9b\xee\x1b\x2d\xd9\x47\x21\x4e\xa3\xdc\xc6\xb6\x25\xf6\x54\x0d\x12\x82\x96\xd4\x23\xb0\x2c\xee\x64\x1d\x19\xa2\xcb\xd2\x79\x33\x9a\x18\xa2\x95\x69\x33\xa4\xc5\xbb\x8d\x8d\xac\xcc\x55\x51\x7e\xc6\xe7\x0c\x86\x51\x28\x95\x19\x70\x33\x3b\x93\xbd\x44\x7a\x0e\xc3\xed\xd5\x93\x33\x66\x71\x21\x01\x31\xbb\x6f\xa9\x41\xd8\x21\xdc\x77\x3a\x86\x00\x07\x72\x87\xdc\x3c\x94\x28\x46\xbd\xaa\x92\xae\xd2\x8c\x47\xda\x7c\x18\xbd\x7a\xfc\x98\x4c\x18\x82\x7c\x03\xaf\xb6\xf1\xf4\x20\x62\x3a\x08\x1c\x17\x8f\x00\x99\x41\x64\x64\x07\xde\x78\xc1\x2e\x2e\xa0\xeb\x8f\x42\x3f\xa8\xb9\x12\x5e\x9e\x58\xab\x24\x3b\xa4\x94\xe2\xdb\x91\xd4\x26\x68\xcc\xba\x41\x85\x22\xae\xb3\x28\xa9\xa4\xd0\xf5\x39\x3c\x49\x0b\xed\x9d\x41\xe3\x64\xc3\x2c\x95\x52\x28\xae\xde\xa3\x42\xb1\xbe\x40\x84\xe5\x07\xf9\xa5\xfd\x89\xec\xec\xbd\xdd\xde\x3c\xdc\xd9\xdf\x23\x0b\x75\x0d\x7b\x80\xa7\x27\xa8\x7e\x67\xfd\xa3\x28\x5a\x53\x96\x8b\x1b\x44\x27\x21\xef\x32\x92\x3a\x60\x95\xb4\xcb\x8c\x24\x6f\x18\x3b\xe2\xde\x45\x26\x51\x87\x61\x35\xb5\x1d\xc8\xf3\xfb\x39\x1d\x17\xa9\x10\x56\xb4\x06\x81\x97\x9a\x74\xbe\xe7\xf9\xaa\x30\x6e\x28\x5f\xfc\xa4\x17\x0d\x13\xad\x47\x59\x2e\xd2\xeb\xdf\x54\x71\x65\x42\xc3\x45\x6d\x29\x98\x3e\xdb\x73\x0a\x6f\xa0\x0c\x1d\x09\x94\x9b\x34\x44\x28\xf0\xa3\xd5\x3a\x3f\xfe\x26\xb0\x4e\x5e\x45\x7c\x87\x21\xbd\x24\x19\xb0\x56\xbd\xde\x77\x12\x1a\xfb\x4e\x50\xeb\x46\x51\x37\xa0\x35\x37\xea\xd7\xfb\x11\xef\x44\x5d\x12\xd2\x12\x92\x4f\xad\x97\xf4\x83\xff\x95\x4a\x5c\x0a\x9d\x64\x18\x3b\x81\xfc\x74\x87\xf1\x05\x65\xbc\x9d\x24\x22\x01\x75\x60\xe1\xeb\x0b\x42\x3f\x24\xa3\x9e\xef\xf6\x08\x75\xe0\x7f\x42\x16\x8f\x86\x81\x47\xce\x28\x3f\x1f\x7b\x35\x40\x9c\xa2\xd8\x0c\x09\xf3\x35\x53\xaf\x93\x43\x7e\xee\xe5\x27\x9a\x1e\x25\x7d\x7e\x7e\x76\xa3\x7e\x3f\x0a\x65\x45\xe8\x07\xe7\x54\xd4\x61\x74\x27\xdc\x87\x18\x94\xee\xf0\xcc\x77\x97\xce\xe8\x1f\x3e\x8d\xcb\x8d\xda\x6a\x95\x34\xaa\xa4\x51\x5b\xae\x92\x66\x05\xb6\xbc\x7a\x5d\x28\x33\x19\x3f\x35\x0b\x1e\xcf\xdc\x98\xd2\x90\x38\x09\xe9\x0c\x83\x80\x5c\xd0\x20\x72\xfd\x64\x4c\x3a\x71\xd4\x27\x51\xa7\xb3\x24\x0b\x84\x1e\x82\x60\x41\x34\x0a\xc6\xc4\xa3\x2e\x0d\x40\x78\x01\x69\x1e\x9e\xdf\xf3\xae\x81\x79\x90\xec\x5a\x6e\xc7\x1a\x93\x3a\x16\x80\x53\xd9\x09\x1d\xab\x91\xc3\x1e\x1d\xf3\x23\x30\xdf\xbb\x8c\x5e\x80\x49\xbc\xee\xb0\xc6\x4e\x11\x6a\x9a\x66\xfb\x87\xbc\xc5\x9e\x13\x0f\x10\xb7\x1c\xf7\x7c\xba\xc8\xd9\x58\x5c\x9f\x31\xb8\xad\x15\xba\x08\x64\xf9\x51\xaa\x9f\x4e\x38\x26\x89\xdf\x87\x89\x01\x58\xc5\x93\xf2\x04\xda\x46\x73\x9a\x62\xa2\xf5\xa3\x7a\x77\xe8\x7b\x94\x8b\xf0\xec\x56\x74\x8b\xe4\xb2\x24\x93\x6d\x92\x05\x4c\xf1\x7d\x60\xc4\x47\x94\xf8\x7d\x3f\xec\x82\x59\x0f\x65\x81\x1f\x26\x4b\x9e\xcf\x60\x4f\x0d\xa3\xa5\x81\x13\x3b\xfd\xa5\x98\x8a\xfb\x21\x2e\x92\x82\xe6\x3e\xcb\x84\x8d\xa4\x2b\x18\x3f\x3f\x92\xb0\xa4\x45\x9a\x6b\x10\x61\x12\x13\xe2\x16\x59\x6e\xe8\xef\x16\x59\xc6\xdc\x7a\x1d\xc9\xfc\xcc\x61\xbe\x4b\x62\xca\xfb\xcf\xf7\x73\x4f\x76\x0f\x6c\xd0\x43\xcf\x89\xbd\x16\x59\x69\xc8\x3a\x89\x5c\x26\x91\x5c\x5f\x7c\x0d\xba\x11\x97\x68\x2e\x89\x13\xfa\x7d\x31\x7c\x22\x13\x5b\x64\xe5\xe9\x9a\xa8\x6d\x36\x03\x38\x61\x51\x9f\x0a\xad\x8a\x58\x22\xb0\x80\x61\x82\xc1\x70\x02\x53\x0e\x20\xa1\x45\x96\x97\xa7\x83\xc4\x69\xda\x02\x24\x12\x24\x9c\xe6\xf3\xb5\x39\x79\x11\x93\xb3\xe3\x19\x49\x8a\x83\xca\xb4\x72\xdf\x0f\x02\x9f\x51\x37\x0a\x3d\x66\x5d\x54\x42\x80\x96\x38\x1a\x86\x5e\xaa\xcc\x22\x29\xf5\x59\x09\xee\x2a\xf1\x5e\x3a\xb3\xeb\x1a\x49\xaa\x41\x99\x26\xce\x3a\x66\x4b\xd9\x43\x1a\x4a\x52\x66\x1b\x39\x9b\xbd\x4a\x32\xda\xc0\xb4\x9c\x36\x1e\xc1\x61\x00\xb7\x31\x69\x63\x52\x29\x0f\x9c\x98\xd1\x57\x41\xe4\x24\xf2\xd0\x26\x2d\xd4\x16\xe6\xc8\x02\xf9\x17\x50\x2f\xb9\xc2\xee\x7c\x87\xd3\xdd\x35\x5e\x34\x99\xd9\xb8\xbe\xaf\x09\x7c\x66\xeb\x89\x0c\x30\x09\x35\x73\x31\x98\xb7\xcc\x95\xe4\x5f\x5c\x1f\x57\xe6\x04\x08\x34\x70\xc6\x73\x7c\x89\xa9\x25\x25\xac\xeb\x70\x45\x61\xfd\x96\xf8\xcb\x09\x4f\xb6\xd9\x52\xbf\x78\x2a\x6a\x3c\x0d\x79\x15\x13\xac\x18\x7f\xf2\xcd\x40\xfa\x12\x97\xfc\x8c\x16\xa3\xfa\xda\xb6\x81\x6a\x42\x25\x59\x91\x17\x76\x66\x8b\x1c\x95\x9c\x20\x90\xee\x2c\xc4\x49\x50\xe8\xb4\x73\xc0\x37\x6d\xf0\xcd\x49\xe0\x9b\x1c\xbc\x54\x2f\xa0\x0c\x85\xa0\xff\x69\x30\x1b\x79\x2e\x35\x51\x80\xff\x64\x8a\x72\xac\x91\x53\x3d\xd5\xb6\xcc\xa8\x49\x66\x43\x5a\xd9\x5a\xba\x05\x95\xa5\xb6\x6f\xd9\x1b\x3d\x49\xf8\x0f\xbf\xb3\x3d\x91\x15\x53\xfd\x10\xac\x5d\xed\xee\x66\x37\xd2\xa0\x75\xff\x38\x01\x99\x18\xe1\xdf\x06\x3a\x44\x76\xba\x7c\xaa\xe9\x86\x35\x64\x1b\x04\xc6\xac\x12\xca\x90\x22\x79\x56\x2f\x4f\x75\xee\x3f\x2a\x49\xdc\x95\xaa\xa4\x84\x03\xe0\xbf\x00\x7c\xe9\xb8\x22\x5f\x95\x88\x93\x46\x8d\x86\x17\xb5\xbd\xfd\xad\xed\x93\xed\xbd\x5f\x80\x3e\xe6\x07\x71\xe4\x0d\xc5\x35\xf8\x0b\x5b\x39\xaa\xdb\x53\x3c\x4a\x5c\x47\x7f\xff\x4e\x6c\xcd\xce\x40\x84\xbd\x2e\xed\x8a\x1d\x76\xe9\xf3\x4e\x4b\x11\x1c\xb4\x32\x60\xf3\xa4\x3f\xe4\x3b\x11\x05\xa5\x3f\x5e\x33\xc4\x08\xa8\x54\x21\x2d\xcb\x95\xdb\x9d\x3b\x2c\x18\x9e\x4d\xaa\x13\x7a\x28\x0b\x9a\x9d\x44\x36\x42\xce\x86\x09\xe9\x70\x7e\x4f\x4a\x64\x31\x45\xfc\xf7\xde\x6f\x81\x68\x93\xac\x27\xf4\x1a\x8b\x65\x11\xfb\xe3\xf0\xc9\x09\x6b\x12\x1a\x79\xfe\x8f\xef\x0f\x24\xc3\xe9\xd2\x58\x14\x7c\x0d\x55\x24\x43\xe4\xab\xaf\x91\xee\xe7\x30\xe4\xf2\x44\x37\xf4\xff\xa0\x9e\xea\x74\x99\x55\xc8\x11\x9f\xd9\x09\x40\xbf\x45\x7e\x58\x2e\x55\x4b\xb0\xc9\x1f\x5b\xa3\x31\x0d\xac\xca\x79\xab\x82\xbc\x10\xbb\x42\x8b\x80\xd2\x93\x1d\xa7\x9f\x2c\xa3\x38\x45\x3d\xbe\xd6\x33\xfa\x0f\x33\x13\xcc\xcf\x78\x57\x95\x94\x92\xa6\x46\x59\xc0\x62\x8b\xd9\x5a\x30\x8b\x42\x91\x62\x8c\x0e\xed\xd6\xd1\x6a\xb5\x3d\x4c\x22\xf4\xf5\xb0\xa5\x76\x43\x53\x53\x93\xcd\x2f\x0b\x2f\xb5\x62\x04\xa8\xd5\xb2\x92\xd4\xa0\x1a\x96\xde\x16\x5e\xf0\x44\x70\x73\xce\xf7\x64\xf1\xf6\xb3\x4e\x56\x9e\x08\xf4\xd6\xeb\x4a\x84\x1f\x8d\x46\xb5\x51\x14\x74\x62\xa7\xef\x04\x83\x9e\x03\x07\x4f\x3f\x1c\x0c\x93\xfa\x0b\x7f\xa3\xbc\xba\xf8\x5f\xcb\x2f\x17\x9b\x6b\x8b\x0b\x8b\xe5\xcb\xc5\xff\x5a\x7e\xb5\xb8\xf2\x64\xb1\xb2\xb8\xb0\xb0\xd8\xa8\x2d\xaf\x41\xa6\x4a\xaf\xc0\xdf\xb5\xca\xe2\xc2\x62\xb3\x61\x4e\xa3\x21\xe1\x95\x57\xc9\x22\x69\xae\x91\x05\x4c\x1c\x44\xa3\xb2\xec\x29\x9c\xb4\xd6\x38\xca\x55\xdf\xeb\x64\xad\x42\x16\x48\xb3\x51\x51\x66\x76\x13\x14\x41\xd7\x68\x78\x35\x49\xb3\x54\x5e\xa9\x54\x2a\x69\x3d\xd5\xda\xdf\xcb\xf0\x2d\x2b\x54\x3d\x7a\x24\xef\x17\x46\x7e\xe8\x45\x23\xbc\x30\x30\xae\x14\x1e\x3f\x16\x39\x35\x2f\x72\x91\x73\x64\x93\x6a\x96\x73\xb2\x3c\x23\xce\xac\x7e\x2f\xa3\xd3\x7b\x32\x09\x57\x39\x4f\x2a\x6e\xa1\xdf\x9b\xed\xa9\x86\xea\xc4\xa5\x25\x86\x6b\x99\x52\xd0\x52\xda\x4c\xfc\x52\x9a\xd0\x56\xb2\x96\x90\x4f\xef\x6c\x43\x7b\xc6\xe5\x21\xb6\xe7\xc8\xe7\x7a\x39\x94\xf8\x74\xf5\x59\x45\x29\x6d\x27\x99\xf9\x3c\x05\x8b\x5b\x79\x54\x78\x4d\x13\x54\xb6\x84\x08\x5c\xdf\x2d\x26\xe4\xf4\x9c\x8e\x4f\x49\xd4\x21\xa7\x28\xf2\x9c\xd6\xe6\x88\x38\x5f\xc4\xfe\x05\xc4\x45\xd4\x32\xfd\xbe\x38\x4c\x60\x51\x50\x2b\x88\x9f\x49\x44\x7e\x1f\xd2\x78\x5c\xcb\x3b\x22\x9c\xd3\x31\x94\xe5\x7f\xc5\xad\x1f\x3f\x40\x46\x1e\xaf\xd6\x05\x9b\x86\x05\xf2\xaf\x58\xdc\x15\x5e\x2d\x5c\xab\x7b\x43\x5e\x54\x9f\xa0\x3a\xc4\x4f\x4a\x4c\x8c\xa2\x8a\xfe\x22\x4f\x15\x49\x43\xcf\xeb\x73\x26\x7f\x44\x64\x96\xb1\x8f\x86\xb9\xab\x79\x49\x27\x31\x69\x95\x32\x6c\x89\xcd\x69\x91\x67\xb7\x17\xa2\x76\xcb\x54\xca\x5e\xe7\xd8\x0d\xab\x3e\x64\x09\x66\xe2\x2b\xa0\xfb\x59\x15\x7e\x5f\xae\x06\x38\x5f\xdc\xec\x91\x5a\x04\xeb\x2d\x52\x2a\x73\x9a\xba\x07\xf0\x27\x9a\x4b\xe5\x34\x53\x0b\x27\xbc\x03\x4d\x83\x9a\xad\x43\x4d\xf9\xf2\xb6\x48\x07\x7c\x47\xb0\x77\x18\xa0\x82\x31\x5b\x17\x96\xc1\x71\x08\xdc\x15\xb3\xc2\xe1\x35\xee\x03\xf6\x1d\xc6\x68\x03\x9a\xad\x33\x2b\x27\x31\xf5\x86\x2e\x3d\x71\x19\x3b\x71\x9d\xc0\x2d\x1c\xed\xb3\xd5\x19\xa7\x33\xa7\x89\x3b\x0c\x3a\x07\xda\x6c\xdd\x5a\x45\xb3\xc1\xd0\xe9\x4f\x98\xe2\xe5\xfb\x80\x7d\x87\xd1\xda\x80\x66\xeb\xcc\x5a\xd6\x33\x48\xa1\xc1\xec\x6c\x2d\x3c\xc9\x79\x54\x5e\xd4\xc4\xca\x6c\x4d\x3c\x95\x83\xd8\xdf\x9d\xdc\xc0\x32\x5e\x3c\x3d\xbc\x60\x78\x30\xd9\x7f\x30\xd9\x9f\xd9\x64\x1f\xb8\x8e\x78\xf4\xbd\x6c\x5d\xca\x16\x28\xf4\xb8\xd4\x07\xd4\xca\x24\x11\x20\x22\xd1\xf4\xcb\x24\x1f\x1f\x2e\x6d\x25\x22\x78\x8d\x1a\x78\x0d\xd9\xef\x94\xfd\x0a\x78\x23\xa8\xc0\x55\xa9\x1f\xca\xb9\x7d\x34\xd5\x8a\x81\x0e\xf8\x15\xb3\xb2\x58\x34\x3e\x5f\x32\xd1\xd9\x37\x20\xc2\xec\x4a\xf9\x5b\x5b\xca\xeb\xae\x0d\x22\xc6\xfc\xb3\x80\x1a\x0d\xa0\x74\x5f\x66\x34\xe8\x54\x01\x98\xea\x1a\x4f\xb2\x5b\xd7\x9e\x91\xb0\x0b\x70\x29\xd6\x73\x58\x58\x4a\xc8\x19\xa5\x21\xf1\x43\x3f\xf1\x9d\xc0\x67\xd4\x23\x4b\x84\x0d\x07\x34\x2e\x57\xac\x12\xbc\x05\xea\x61\xd7\x04\x12\x61\x04\x8f\x1f\x13\x79\x46\x86\x6f\x78\x90\x84\x74\x32\xcf\x97\x71\x26\x4f\x8f\x92\xbc\xc0\xe4\x16\xe1\x3d\x4e\x4d\x86\x1f\xf6\x68\xec\x27\xac\xcc\x86\x67\x9b\x48\x90\xd0\x2d\xf8\x2d\x87\x2a\x80\xeb\x0c\xd4\xbc\x59\xef\xa1\x52\x99\xc2\x62\x3a\x7f\x6a\x0e\x78\x59\x7e\xd0\x8c\x29\x63\xbc\x1b\xa0\xfe\xa3\x3e\x28\xb5\xcf\x28\x46\xaf\x8b\x62\x63\xae\xaa\x70\xc7\x3c\x4f\x16\x49\xa6\x2f\x80\x2a\xd9\x7b\xe3\xa5\x95\xda\x8f\xc4\xad\x8b\xd1\x41\xab\xbb\xe6\xf2\xbf\x22\xc6\x93\xae\x16\x2c\x32\xd0\x5d\x68\xe4\x98\x4f\xb6\x85\xfd\xaf\x64\x7a\xe2\x0d\x37\x31\xf9\xa7\xb4\xad\x23\xd7\x92\x9f\x18\xc8\x15\xfd\x63\x94\xaf\x71\xec\xc2\x7e\x47\x79\x7c\x4f\xa5\x17\x4c\x90\xee\x5b\xed\xe4\x04\x46\x02\xbb\xb6\x2e\x02\xf3\xad\xfe\x81\xe6\xcc\x09\xdc\x61\xe0\x24\xf4\x4b\x14\x7b\xe0\xb8\xd5\xda\xb5\x72\xb2\xa5\x62\xd2\x7e\x49\xca\x61\x8d\xa2\x18\xb6\xfe\x47\xb7\x3f\x51\x95\x2b\x65\xdb\xe7\x8e\x52\x7c\xaa\x94\x9a\x32\xa2\xac\xd4\xd8\x20\xf0\x93\x72\xfd\xdf\x6c\xb1\xce\x47\x7d\x64\x5c\x73\x41\x27\x38\xb7\xdc\x8c\xfa\x83\x61\x42\xb1\xd7\x64\x03\x33\x52\xba\x53\x9e\x96\x51\x2f\x5e\x41\xd1\x16\xfc\xbf\x3a\xb5\x3f\xb8\xac\xbc\x74\x34\xef\x4a\x3f\x94\xd8\xf1\x03\xff\x0f\xe1\xe3\x07\x41\xe3\xf8\xd0\x10\x57\x78\x7a\x93\x51\x86\xa4\x95\x20\xc8\x3c\x03\xc7\xa5\x72\x14\xf7\xdb\x8f\xd2\xbf\x2f\xdb\x8d\x52\x5e\x4f\x6c\xd5\xf4\x55\x01\x5a\x5b\x05\xe9\x55\xa3\xd3\x2d\x73\x00\xd7\x13\x9f\x18\x4b\x17\x55\xd7\xea\xde\x5d\x18\x6a\x96\x71\x5f\xe4\x12\xa8\x9b\x11\xac\x4e\x36\xa5\x27\x24\x04\xa7\xd9\x18\xaf\x5d\x25\x46\x3e\x8c\x4a\xd5\xe4\xd9\xd6\xfd\xeb\x49\x4c\x3b\x06\xe2\xa1\xd1\x2a\xfa\x84\xaa\xf2\x4c\x69\x8f\x9b\xff\xfe\x09\xcc\x4e\x45\x09\xb5\xfd\x9e\x04\xe0\x57\x2a\x2d\xd4\xc2\xf3\x76\x3e\x0c\xe1\x19\x27\xa0\x61\x05\xef\x0f\x50\xda\x83\x5f\x3f\x41\x6d\xfc\x00\x59\x4f\xd0\x29\xaf\x7a\x74\x22\x24\x53\x2d\x08\x43\x8a\xa5\x1a\x97\x4e\x22\x62\xaa\x91\x88\x3f\x7a\x18\x8a\xb0\x78\x8b\xc3\x21\x41\x20\x43\xb2\x01\x43\x33\x58\xca\xf7\xef\x92\x2d\x75\x6d\xb6\x04\x28\xa8\x80\x78\x20\xde\xf2\x73\x00\x55\x72\xc4\xc1\x29\xd7\x40\xbc\xff\x95\x4a\x45\x60\x56\xfe\x45\x4f\x60\x46\x9c\x18\x20\xad\x97\xe3\xf7\x7e\x48\x19\x5f\xe3\x38\x32\xe9\x18\xa7\x3a\xa9\xf7\xc6\x94\xe9\x57\x53\xd6\xa3\x23\x24\x0d\xeb\xbd\x91\x72\xa8\xf5\xc5\x0f\x82\xdd\x68\x18\x26\x05\xd6\xdc\xd9\x82\x86\xe1\x29\x0c\x05\xfd\x27\x7e\x31\x06\x80\xb6\xb4\xe8\xbf\xca\x0a\x75\x97\xb5\x87\xb6\xc0\x7f\xa2\x2e\xf5\x2f\x40\xcc\x64\xd3\x74\xc7\x2c\x0f\x6f\x7f\x3e\x68\x6e\x4d\x54\xcc\x6f\xea\x6d\x4a\xc6\x2e\x0d\x80\x6d\x66\xab\x1e\x21\x7d\xb0\x93\xb9\x70\xa1\x4b\xe3\xe3\x2b\xbb\xa8\xf1\x2c\xae\x18\x19\xaa\x78\xd5\xee\x4c\x31\x52\xb2\x40\x0a\xb0\x91\xd3\xda\x20\xaf\x25\xf3\xdd\xd7\x7e\x18\x8c\xc9\x80\xc6\x9d\x28\xee\xab\x2d\x0f\x8c\x25\xfc\x0e\x19\x82\x29\x40\x87\x3a\xc9\x30\xa6\xc2\xdc\x4c\x9c\x7e\x49\xd2\xa3\x7d\x52\xee\x0f\x83\xc4\x0f\xfc\x90\x56\x09\x73\x9d\x80\x1e\x46\xaf\xfc\xa4\x62\x98\x94\x97\x4d\x67\x9e\xdf\xbf\x4b\x76\xab\xcb\x72\x21\xe4\xd1\x8d\xac\x3d\xef\xd4\x7f\x34\x1f\x0a\x97\xa3\x07\x4c\xf8\x1b\xb5\xa2\x12\xe3\xeb\xb5\xdc\x81\x9b\x3b\xa6\xda\xf9\x8b\x37\x7c\xeb\xd9\x14\x07\xab\xeb\xa5\xdf\x49\xdd\xb8\x0f\x63\xb5\x5a\xc1\xe6\x91\x7a\x73\x45\xec\x1d\xd0\xa8\xaf\xd3\xb5\x03\x4c\x83\xf0\x26\x8b\x02\x99\x8c\xf5\x2c\x04\xab\x61\xb3\x35\x5d\x2e\x13\xfd\x29\x8f\xee\xc5\xe9\x4d\x4d\x42\x1e\x4a\x89\x7a\xb1\x60\x00\x37\x4c\xe6\xe7\x32\xd8\x15\xf4\x2d\x57\xb0\x35\x75\x36\xdf\x29\xda\xa5\x53\x83\x94\x82\x80\x19\x02\x57\xe3\x42\xc6\xfc\xbf\x4a\x71\x66\xab\x2f\x3a\x8e\x4a\x06\x31\x53\x23\xc5\x1c\xfb\x64\x56\x90\x06\x71\x33\x4f\x28\x68\xd4\xe2\x8f\x7f\xb9\x1c\x7b\x13\xc6\x8f\x44\x82\xc0\x3d\xb9\x3e\xd6\x9e\x49\x73\xf6\x93\x3c\xba\x28\xda\x4b\x72\x69\xe8\x66\x21\xaf\x4a\x38\xff\xfb\x82\xbe\x8d\xad\xb7\x4d\x8a\xc9\xd9\x1b\x8d\x4e\x4f\x07\xd9\xc8\x6f\xac\x86\x4a\x68\x43\x76\xc7\xa7\xc7\xb0\xc9\x77\x96\xd3\xaf\x74\x38\x10\x11\x08\x79\x19\xa8\xdf\x66\x2a\x66\xac\xe5\x65\x4b\xe0\x25\x3a\xee\x59\x4c\xc3\x44\xb8\xad\xc4\xb6\x8e\xf0\x8f\x34\x12\x59\x22\x4d\xd3\x1d\x22\x44\x4e\x34\x6a\xf1\x43\xba\x42\x0a\x11\xa7\x60\xce\xfd\x0d\x94\x7c\xff\x6e\x36\x24\x36\x88\x45\x22\xff\x1a\xec\xe7\x27\x03\xc1\x36\xbb\xad\xd7\x09\x9f\x2c\xe2\x3a\x21\x18\xcd\x78\x60\x9e\x8b\x2f\x39\x2f\x7d\xb4\xfe\xe6\x75\x8d\x2a\x56\x9b\x70\x2c\x1a\x0c\x59\x0f\x4f\x43\xeb\x45\xe5\xb0\x4f\x1b\x39\x9d\x33\x1e\xf6\x64\x99\x61\xbd\x4e\xda\x9e\x47\x3a\x7e\xcc\x12\x9c\x96\x24\x82\xfe\xf0\x33\x3d\x7c\x83\xa1\x70\x44\x82\x28\xec\xf2\x3c\x03\x3d\x51\xf1\x10\x50\x8e\x19\x89\xf9\x51\xeb\xe1\x88\xff\x3d\xb6\x83\x27\x9b\x01\xf6\x88\x98\x4a\x1c\xb0\x00\x60\x86\x7e\xca\xb8\xb7\xc4\xf2\x8a\x29\x55\xc9\xd1\x71\xf1\x52\xc3\xc7\x4e\x05\x6b\x0b\x33\xcb\x79\xbe\xf7\xad\xb5\x61\xf9\xae\xbf\x54\x3e\xf5\x6b\x9e\xed\xd5\x7e\x6c\xe4\x58\x21\x2b\x12\x7a\x99\xb4\x43\xb7\x07\xca\x60\x51\x42\xa7\x99\x25\x65\x40\x95\x74\x69\x3b\xdd\xac\x61\x2d\xe7\x93\xf4\x52\xce\xc4\x27\xd1\x85\x9c\x74\xc4\x49\x3e\x9f\x6f\xec\x08\x43\x35\x9d\x66\xc5\xe7\x70\x06\xe9\x82\x2a\xc9\x2a\x27\x23\xa0\x19\xe5\x64\x52\x1a\x3f\x2a\xa0\x61\x91\x76\xf5\x44\x08\x8d\x47\x25\xef\x12\x6c\x22\xc7\xfc\xff\x1a\x8d\xfc\xcb\x46\x13\x4f\xd1\xa8\xe0\x5f\x30\x66\xfe\x43\x8f\x8b\x7f\xa9\xce\xc3\x87\xec\x61\xe9\xb8\x62\xbd\xf6\xcc\xdb\xe1\x31\x6a\x96\x99\x93\x0a\xbc\x3b\x85\xeb\xe6\x1c\xa7\xf5\x54\x3b\xad\xdf\x8f\x0f\x12\x21\x46\x2a\x34\xd5\x2e\xc1\x66\xf3\x07\x01\x1f\x57\x6e\xe1\xf4\x9d\xaf\x06\xa3\x5f\x64\x51\x5e\xee\xdc\xb6\x57\x79\x7e\xfa\xbd\x4b\xbe\x59\x7b\x97\xa4\x45\x1a\x76\xbc\x29\xab\xd5\xf1\x3d\xb7\x3a\x86\x56\xc7\xa2\x55\x73\xeb\x4c\x9c\x38\xd9\x1a\x67\xc2\x14\x4b\xb7\x82\x36\xf9\x99\x58\x04\x67\x7e\x25\xa8\x5f\x6a\x99\xab\x57\x41\x9c\xe9\xf2\xb8\x5c\x29\x83\x30\x51\x2e\x91\x45\x63\x55\x2e\x92\x52\xc5\xf6\x5f\x70\x16\x53\xe7\x7c\x3d\xd5\x9d\xbe\xef\x79\x01\xfd\x61\xfd\x29\x9b\xcb\xc2\xd8\xa2\x2b\xa4\x4e\x96\xc1\x88\x71\x81\x80\x8f\x7a\x83\xf1\x2c\x82\x61\x63\x76\x38\xbc\x4a\x65\xf2\x98\xe4\x33\xb7\x3f\x7d\x34\x85\x23\x99\xd4\x5f\xcb\xdf\x7b\x12\x3b\x21\xe3\x47\x5d\xce\x57\xb4\xc8\x09\x0a\x69\xe3\x48\x6a\x0b\x54\x86\x24\x63\xb1\xa6\xa3\xc6\xb1\x94\x9f\x14\x7f\x55\xf0\x71\x97\x45\xae\x08\xc3\x32\x04\x40\xdc\x9a\xeb\x06\x60\x7b\x0c\xd7\x46\xb7\x80\x91\x5a\xde\x1f\xd2\x4d\xc4\x11\x08\xca\xbc\x0d\xdc\x78\x16\x09\xe7\xae\x64\x91\x5c\xea\x9f\xe3\x09\x4d\x18\x10\x6d\x77\x9d\xd6\x8e\x51\x53\xc5\xe0\x52\x53\x55\x41\x1b\x58\x52\xca\x7a\x8e\x96\x2a\xb8\xe9\x6d\x6f\x6a\x8e\x6d\xbb\x58\x56\xdd\x80\xed\xc7\x08\xe6\x62\xbd\xe6\x9f\x51\x7b\x30\x55\x6c\x5d\x35\xfe\x4a\x35\x1d\x86\xe1\x32\x15\x7c\x61\x9c\xbb\x23\xb7\x6e\x6d\xba\xc1\x57\x83\x8e\xb9\x0b\xe3\xd6\xe0\x2a\xf9\xe2\x4e\xcb\xf8\xad\x25\x3a\x33\xb6\x8b\xb9\xa8\xec\x9b\x00\x54\xdf\xa4\xa2\x32\xdc\xf7\x04\xe2\x24\xb2\x81\x13\x96\xec\xf3\xc8\x15\xa2\x92\x78\xe3\x16\xf6\x01\x2d\xd0\xc9\x0b\xc5\x54\x5a\xc6\x6a\xaf\xa2\xb4\x89\x05\xaf\x6d\x48\x81\x96\xe9\x15\x51\x1a\x05\xf2\xa2\x9c\x56\x0a\xdf\xc4\xe3\x83\xf9\xeb\x69\xac\xbe\x8e\xe6\x95\x96\x7d\xfe\xb8\x52\x15\x2a\x72\x58\xeb\x87\xe3\x01\xb5\x83\x47\x5f\x4f\x8a\x6d\x90\x4f\xa7\x78\x85\xf1\xe1\xd3\xf6\xc1\xf6\xde\x61\xfb\x70\x67\x7f\xef\xa4\x7d\x78\xf8\x69\xe7\xe5\xe7\xc3\xed\x03\x4e\xa5\x48\x99\x9a\x81\x4d\x22\xb9\x7c\x83\xb0\x9a\x53\x3b\x8b\xa2\x80\xe3\xd3\xc1\x98\xe3\x33\x40\xc0\x57\x1f\x1c\x86\x49\x97\x33\x00\x8a\x42\xba\xdf\x29\x1f\x89\x5d\xbc\xaa\xf6\xcf\x2a\x29\xd1\xd0\xe3\x7f\xc4\x35\x47\xe9\x18\x28\xdc\x96\x06\x7e\x44\x93\xd8\x0e\xe8\x77\x67\x03\x0f\x1c\x6a\xee\x5a\x53\x87\xc8\x33\x03\xc4\x5f\xb6\x08\xbc\x22\x1d\x8b\xbf\x9a\xea\x5b\xa4\xd4\xa4\x7d\x58\x38\x6a\xb3\x6e\x91\x52\xa3\xf6\x14\x92\xf9\x41\x73\xd7\xe9\xfa\xae\x7c\x78\x03\x2f\xa5\xbd\x95\x14\x51\xe0\x35\x6d\x6a\x7a\xe4\x88\x73\xd0\x08\x23\x47\xd8\x7e\x98\x38\xe2\x19\xab\x93\xa0\x33\x35\x75\x3a\x45\x46\x45\xea\xca\x9e\xfb\xe0\x97\xd7\xe4\x8c\xf6\x9c\x0b\x3f\x8a\xe7\xe4\xa5\xc5\xb2\x30\xbf\x9e\xd1\xfa\x5b\x5e\x30\xd9\xe6\xb8\x13\x3d\x6b\xdf\x8f\x39\xae\xe8\x5e\x59\x78\xda\xae\xd8\x1d\xd5\x86\x75\x5e\x39\xb7\xbd\x79\x67\xbe\xaa\x8e\xc1\x65\xc3\x97\x40\xdf\x19\xac\x83\xe6\xea\x1e\xdb\x3a\x2b\x68\x8b\x05\xbe\x4b\xb1\x35\x70\x14\x1e\xc7\xf0\xec\x0e\xdf\xdc\xa8\x5b\x7f\x71\xed\xd8\x87\x60\x50\x50\x86\xef\x13\x58\x05\x20\xa8\x64\x84\x97\x36\x8e\x7e\x3a\xd1\x23\xf5\x9f\x6d\x1c\xfd\x43\x8c\x85\x1b\xf7\x60\x2c\xdc\xb8\x9b\xb1\x70\xf3\x07\x1a\x0b\x37\xef\xcb\x58\xb8\x79\x0f\xc6\xc2\xcb\x3f\xd0\x64\x76\xf9\xbe\x4c\x66\x97\xef\xc1\x64\x56\xc6\x1a\xfc\x30\x8c\x29\xfa\x18\x2c\x26\xdb\xb5\x59\x4d\x84\x6f\x67\x33\xfb\x60\xcf\xfa\x60\xcf\xfa\x60\xcf\x7a\x57\x7b\x56\xf8\xbb\x2c\xe4\x9f\xf5\x07\xcb\xcf\x07\xcb\xcf\x07\xcb\xcf\xbf\xcc\xf2\x53\x3a\x60\xe9\xf8\x01\xdd\xbf\xa0\xf1\x85\x4f\x47\x64\x2b\x4a\xe6\xd0\x2f\xb3\xb4\x09\xc5\x70\x7a\x37\x2a\x94\xf2\xf6\xec\xbc\x08\x84\x65\x65\xb3\xa7\x2c\xd0\x04\x5b\x98\xd2\x8c\x6f\x2b\x9a\x64\xc5\xb7\x15\x69\xf3\xab\x7c\xc3\xbc\xad\x48\xd9\xe5\x49\x6d\xce\x8d\x86\x6f\x5b\xd1\x54\x06\x6f\x1c\x74\x45\x85\xad\xe1\x35\x75\xd8\x9a\x02\xcb\x33\x18\xcd\xd1\x0f\xbd\x35\x74\x8d\x5b\xc3\x9c\x58\xf7\x32\xc7\xd2\xd5\x19\xd7\x7f\xf1\xb4\xb7\x6a\xb6\x7b\x52\x67\x2c\x17\xd6\x24\x0d\x78\xbe\xd8\x69\xa9\xfb\xbc\xc8\xd6\xf6\x59\xee\x39\x5d\xd4\x8d\x2d\xba\x97\x7c\xfd\xba\x63\xf1\x35\xe6\x5f\xe8\x0b\x74\x31\xce\xb9\x51\xba\xc5\x79\x26\xa3\xbf\x2b\xb9\x7e\xec\x82\x1e\xe4\x76\x1a\xd7\x3c\x89\x73\x5a\x8d\xab\x9a\xd7\xca\xcc\x0d\x51\x11\x63\x34\x48\x68\x0c\x81\xba\x27\x36\x72\x95\xaf\xb7\xd5\xb3\x6a\x13\x18\x84\xb9\xb7\x08\x0b\x02\xde\x9b\x04\xd5\x22\xa6\x16\xb6\x50\x35\xae\xef\xfa\x72\x34\x90\x5b\xd1\x0d\x0a\xc8\xc6\x64\x05\xe4\x72\xcd\x0c\x53\xbc\x41\x4a\x5b\x40\x5b\x32\xd3\x54\x4f\x72\x04\x4c\xa5\xb0\xce\x3f\x21\xd6\x9c\x1a\xbe\x1a\x07\x05\xd5\xe5\x4c\x00\xb4\xf2\x90\xa3\xf3\x4e\x00\x26\x6a\x00\x6f\xa8\xaf\xf4\x55\x15\xb8\xf8\x45\x64\xdd\x25\xc2\xa4\x60\xc0\xb6\xa6\x64\x62\x4c\xab\xbf\xec\x19\x39\xae\xb5\xe2\x97\xe4\xcf\xee\xfc\x92\x5c\xb6\x70\x3f\x8f\xc9\x25\xb4\x59\x95\x1d\x0a\x90\x8c\x70\x57\x7c\x28\x7e\x72\x8f\x6d\xdc\x49\xaf\x92\x03\x6f\x56\x15\xc8\x0f\x75\x1f\x90\x06\x7f\x27\x1d\xcb\x7d\xb8\x0f\x58\x91\x50\x02\x87\x15\xd3\xf8\xf3\x95\x19\x67\x3a\x05\xfe\x4e\x6f\xce\x2d\x48\xb3\x2a\x7c\x14\xce\x40\xcb\x5b\x4c\xd9\x33\x2e\xea\x6c\x03\x77\x7a\x78\x9e\x06\x36\xeb\xe3\xf3\x1f\xa2\xf5\x5d\xbb\x07\xad\xef\xda\xdd\xb4\xbe\x4f\x7e\xa0\xd6\xf7\xc9\x7d\x69\x7d\x9f\xdc\x83\xd6\xf7\xe9\xc9\xc9\x7b\xe7\x8c\x16\x33\xa4\xb5\x19\x55\xa0\xcf\x4e\x4e\xdc\x08\x6e\xb1\x68\x7c\xf2\x9e\x4b\x76\xc5\x64\xf2\x7c\xb6\x26\x9e\xff\x78\xcf\x04\xcd\x86\x68\x03\xa2\x54\xdf\xe0\x9c\x00\xaf\xdc\xe6\x1e\xfc\x13\x5c\x5b\xca\xb7\x6c\x70\x76\x27\x56\xda\x36\xdb\x0f\x1d\xcf\xc8\x2a\x70\xf9\x41\x37\x5e\x56\x0f\xd8\x9c\x38\x96\x76\x33\x12\x4b\x71\x1a\x3f\xbc\x02\x3e\x0d\x77\xe2\xd8\x7e\x1a\xce\xb3\xd6\x95\xf5\xb0\x4c\xc5\x7e\x74\xe2\xa8\x0f\x9d\xc8\xa8\xe9\xfe\x13\x5f\xc6\x9b\x6f\x73\xd3\xa7\x13\xcf\x49\x9c\x49\x62\x7d\x3e\x13\xab\x39\x35\xb8\xb1\xdc\xef\x4c\xcd\xb6\x32\x97\xf6\x68\x61\xe0\x04\x43\xda\x76\x5d\xca\xd8\x64\x03\x83\x42\x60\x7c\xea\xe0\x74\x13\x44\xee\xf9\x17\x9f\x4d\x3c\x66\x15\x42\x91\x46\x1a\x1c\x1d\xef\xe8\xc4\x83\x52\xf1\xb0\x42\xba\xdf\xe1\xb8\x2d\x1f\xcd\x50\x5b\x1c\xf4\x66\x69\x58\x9c\xd0\x66\xc5\xde\x71\x45\x3d\x8d\xcd\x31\x9e\x48\xcd\x90\x5a\x29\x56\x7a\x99\x86\x49\x3c\x4e\xc7\x11\x9f\x41\xc8\x29\x57\x10\x54\x4d\xf9\x16\xbb\xb5\x68\x98\x06\xd1\x22\xc6\xa7\x7e\x09\xac\x06\x02\xdb\xe2\x7b\x9f\x25\xe6\xb3\x1d\x40\x86\x93\x38\xf2\xaa\xa8\xc6\x3f\xaa\x4a\x33\x65\x0c\x5d\x95\xb0\x52\x65\x51\x41\x4f\x16\x98\x77\x54\xe9\x34\x14\xd1\xaa\x02\x2a\x45\x16\x01\x7f\x9f\x13\xcd\xca\xb5\x55\xb9\x93\x38\x60\x43\x6e\xf6\x04\x0c\xcd\xb1\x55\xb4\x0d\x17\xf0\xa5\x6d\x38\x70\x20\x18\xea\xf7\xef\x04\x7e\xa4\x8c\x15\x33\xef\xa8\xe7\xa6\x98\xe1\x8c\x68\x97\x6f\xc0\x76\x3b\xb1\x22\x47\x11\x8c\x58\xba\x32\x95\x2c\x5a\xe7\x17\xf0\x99\x5d\x0a\x7c\x96\x94\xa4\x49\x1b\x8c\xcf\xb6\xd2\x03\xea\xc8\x98\xe9\x99\x4e\xf1\x6e\x7f\x1a\x2b\x57\xca\x02\xe7\xca\x3d\x9e\xbd\x54\x54\x7b\x53\x78\x01\xc8\x95\x4d\x8e\xe6\x47\x52\xe7\x07\x0e\xfb\x5e\x8e\xb7\x04\xa9\x81\x1a\x0e\x1a\x21\x8f\x1f\x0b\xda\x1f\x38\xe3\x20\x72\xbc\xaa\xa4\xc7\x4a\xfa\x81\xd4\x5d\x66\x72\x1a\xa1\x33\x6f\xea\x6e\xa9\xf9\xcc\x93\x02\xa7\xd4\x7c\x22\x77\xaa\x8a\xb5\x64\xea\x25\x61\x16\x84\xd9\x63\xd5\x30\x4e\x06\x7d\x39\xfc\x31\x52\x7d\x3a\x7a\x19\x4d\xd4\xc2\x4d\x1c\x70\x0d\x7c\xd8\xff\x82\x50\x6e\x71\x2e\x37\x88\x4a\xad\x5e\x4e\x56\x38\xc7\x2d\x1b\x8d\x82\xba\xae\xcc\xfd\x50\x73\x99\xeb\x8a\x61\xb9\x8a\x17\x05\xb8\x48\x4a\x64\x11\x91\x30\x97\xd2\xad\x82\x45\x67\x05\xfc\x39\x2a\x46\x69\xa9\x38\xd5\xef\x75\xa3\x40\x4a\x41\xaa\x32\x4a\x62\x9f\x01\x4c\xa8\x54\xf3\xca\xc6\xce\x29\x43\xef\x90\x6c\x8d\xa0\xf8\x90\x3a\x89\x3f\xf1\x52\x50\x08\x03\x79\xc5\xc3\xb4\x57\x88\xbb\xd0\xbb\xea\x1d\x47\xb3\x81\x44\x9e\xb4\xe4\xf7\x07\x81\xef\xc2\x5b\x1d\x14\xad\x80\xb5\x5e\x57\xac\xae\xdd\xae\x75\x9f\xfd\xe2\x04\xbe\x27\x9b\x17\x83\xff\xfe\x7d\x56\xfd\x58\xb9\x22\x60\xfc\xa5\x38\xa9\x62\x28\x9d\x30\x69\x11\x9c\xa9\xa9\x71\x34\x41\xef\xf9\x83\x87\xa6\x57\x9a\x35\xb9\x55\x22\xc8\x74\xc2\xd0\xe5\x8a\x32\xb7\x4f\x24\x59\x29\x7b\xe1\xa5\xdc\xa6\x13\x04\x2f\xc7\x1f\x9c\x98\x86\xd6\xba\xc8\xe6\x96\x07\xf0\x47\x98\x73\xe8\x15\x02\x2f\x4d\xcf\xa9\x7b\x0e\x39\xef\x71\x15\xe4\xc5\x67\x58\xb6\xe3\x33\x2c\x4f\x8a\xcf\xb0\x7c\x4c\xf0\xbe\x59\xcb\x0c\x46\xf3\x20\x3a\x18\xdf\xda\xb7\xc3\xe3\xc7\x99\xbe\x3c\x7e\x6c\x97\x9d\xbc\x98\xc5\x78\x24\xbc\x0d\x92\xd7\x0c\xbe\x58\x83\x68\x4b\x97\x88\xef\xcd\x9e\x1f\x60\xf9\x19\xf7\x95\x9e\xb8\xe8\x0a\xbd\x36\x47\x39\xe7\x70\xb8\x97\xc8\x36\xab\x5a\x70\x4c\x7b\x4f\x87\x22\x29\x89\x42\x0c\x6c\x8a\x37\x5e\xea\xee\xc9\x0d\xa2\x50\x52\xe1\xbc\x6c\x59\x6f\x5e\xc6\x52\x9a\xcb\x30\x74\x20\x3e\x9b\xa9\x8b\xf5\x05\xff\x87\x09\x4c\x4d\x4c\xaa\xa7\x29\x4c\x2a\xda\x85\x53\xae\xa0\x6a\x93\x83\xa7\x18\x77\x66\x86\x05\x89\x9a\x17\x71\x47\x19\x38\xca\x9d\x4b\x8e\x32\x21\xd5\x21\x19\x00\x46\x6f\x3a\xb9\x0b\x28\x9b\x68\xed\x53\xf6\x79\xc7\xfc\xbc\xcb\xdd\x94\xa6\x8c\xcc\x0d\xd5\xf2\x9d\x3c\x63\x63\x68\x27\x98\x53\xea\x11\xe9\xa3\x39\x89\x90\xac\xd0\x7e\xbc\x23\xa2\xc6\x82\x52\x22\x8c\xc2\x25\x38\xa9\x2f\x05\xfe\x39\x25\xdb\x07\x2b\x22\xfe\x01\x03\x9e\xb3\x23\x2a\x16\x59\x45\x3e\x15\x36\x8b\x92\x25\x14\x95\x7b\x9e\xe7\x0c\x5d\x2f\x08\xf9\xf4\x4b\xcc\xbb\x68\xb5\x2c\xa0\xf2\x6c\x31\x99\x29\x64\xad\xdc\x15\x59\x4f\x6b\xcd\x5a\x73\x85\x1c\x0a\x04\x95\x25\x43\xab\xfc\x80\x51\x4d\x3b\xa8\xfb\x0c\xea\xa8\x22\x4a\x9a\x71\xf3\x36\x24\xa3\x06\xed\x64\x97\x26\x5b\x96\x34\x96\xab\xd2\x5c\x7b\x52\xc9\xaf\x30\x29\xde\x9f\x5d\xf2\x4f\x09\xfb\x07\xaf\x98\x63\x67\x60\x0f\x49\x35\x9b\xca\x2a\xbf\x74\x18\x55\x57\xf8\x55\xd2\x8b\x5c\xe8\xa9\x39\x6d\x22\x8d\x2c\x92\x52\x59\xc5\xdc\x48\xe1\x40\x47\xdf\xb0\x00\x56\xf0\xed\x1f\xce\x72\x36\xe8\x40\xaa\x33\x19\x56\x30\x4d\xd4\x04\x49\xc8\x07\xa0\x8b\x6d\x41\xd0\x89\x56\xbd\xfe\x8d\x75\xe0\x19\x4d\x2d\xa4\x49\xfd\xe2\xcb\xe5\xb3\x5f\xea\x73\x22\x24\x45\xab\x5e\x67\x89\xe3\x9e\x47\x17\x34\xee\x04\xd1\x08\xc2\x51\xfc\x3e\xa4\x0c\x9c\x0f\xd5\xd7\x9e\x34\x56\x9a\xcf\xd7\xea\x9d\x61\x80\x47\xe3\xa5\xa8\xb3\xf4\xcd\xb9\x70\xd0\x90\x74\xe9\x9c\x8e\xdd\xc8\xa3\x4c\x19\x76\x6d\xf2\xa1\xfa\x34\x74\x95\x9b\x7a\xe9\x9a\xde\x8d\xe2\x98\xb2\x41\x04\x6f\x2a\xc4\x61\x99\xf3\x9c\xae\x7f\x41\x43\xbe\x19\x01\x5e\x23\x50\x50\x6f\x46\x1e\xd5\xbe\xf4\xd1\x21\xfe\xae\x7f\x49\xbd\x6b\x99\x4b\xae\xf6\x44\x8c\x2c\xac\x01\x95\xaf\xd0\xab\xc9\xb5\xe1\x12\x5f\xd6\x83\x24\x67\xe0\x93\xc1\xf0\x2c\xf0\x5d\x34\x37\xd3\xcb\xb4\x70\xdd\x96\x19\x75\x62\xb7\xb7\x13\x0e\x86\x62\xfd\xd6\xeb\xe4\x1d\x1d\x9f\x45\x4e\xec\x11\xb0\x69\x61\x73\x32\x1a\xb0\x2a\xc9\xe9\x54\x06\x98\xc6\x33\x85\xb0\x15\x4c\x03\x53\x01\x7d\xdf\x89\x61\x6d\x98\x65\x6a\x18\x33\xf2\xfb\x77\x2b\x51\x62\x20\x95\xec\xf6\x9c\x98\xa7\xcf\x49\x33\x25\x0d\xb5\x62\x16\x24\x1b\x46\x7b\x72\x9b\xae\xd7\x09\xe2\x53\x0e\xa6\x84\x5a\xc2\xe2\xde\x4b\xd1\xcb\xe9\x53\x76\x64\xe4\x1c\x0b\x70\xdb\x17\x34\x1e\x63\xa0\x3b\x50\xa9\x97\x5d\x87\x41\xa8\x03\xdc\x50\x2a\x42\x36\xc0\x9a\x10\xd6\x16\x1c\xd2\x98\x6d\x08\x48\x6e\x8f\xba\xe7\x04\xc9\x0c\x2b\x41\x30\x23\x3e\xe3\x1e\x2a\xcb\x20\x4f\x74\xa2\x96\x44\xef\xa3\x11\xdf\xc3\x19\x2d\x57\x8e\xc5\x70\xac\x1a\xaa\xf3\x56\xaa\xd5\x9a\x13\xf8\x0e\x2b\x6c\x4f\xe4\xde\x53\x8b\x23\xea\xc7\x1e\x3c\xdf\x72\xdc\x84\xc6\x2f\x2c\x72\x32\xc3\x01\x35\x15\x18\x91\x27\xa7\xbc\x9d\x94\x1b\x15\x43\x52\x52\x42\xf9\xdc\xb5\x19\xc7\x82\x9c\x8d\x61\xbe\xc4\xc2\x22\x2a\xe4\x1e\xc7\xdf\x51\x09\x82\x18\x96\x8e\x79\x97\x36\x7e\x26\xcd\x95\x39\x15\xd4\x11\xf0\x6b\x84\xe8\x73\x91\x52\xcd\x4f\xa9\xff\x2d\x41\x04\xfa\x81\xe3\xd2\x52\x8b\x3c\xe3\xa2\x66\x29\x71\xce\x4a\x2d\xf2\x1c\x7e\x63\x1b\x2d\xd2\x5c\x81\x4f\xd6\xf3\x3b\x09\xff\x7c\x02\x9f\x6e\x12\x07\xfc\xeb\x29\x7c\x39\x01\x64\x21\x90\x81\x33\x64\xb4\x0e\x2f\xca\x79\x22\x42\x73\x9d\x01\x23\x41\xe4\xf2\xa4\xe5\x06\x36\xc0\x5c\xfe\x81\x10\x64\x3f\x56\x96\x05\x8c\x2e\x25\xc3\x01\x4f\x58\xd1\x09\x5e\x34\x0a\x79\xd2\xaa\xe8\xa0\xc7\x3f\x20\x7c\x63\xa9\x17\xf5\xa1\x3a\xf6\x2e\xa0\xd0\xd7\x15\x84\x8d\x70\xb0\x73\x31\xb8\xd2\x68\x91\x15\xec\x96\x80\xb8\x8a\x3d\xf2\x43\x46\x63\x9e\xbb\x8a\x40\x3d\x1a\xd0\x84\x83\x5d\x15\x83\x8e\xfa\x7d\x07\x5a\x7d\xde\x54\xed\x90\x4c\x2a\xb4\x61\x26\xe3\x10\xc2\x61\x7f\xe0\x78\x64\x81\x23\xa5\xf1\xc4\x4c\x5a\x84\xa4\xa7\x66\xd2\x12\x24\x3d\x37\x93\x6a\x3c\xa9\xd9\x30\x93\xea\x90\xd4\x94\x49\x12\xc1\xcd\x55\xc4\x10\x73\xe3\x28\x08\x74\x2a\x8e\xaa\x3f\x86\x57\x89\x43\x31\xbd\xcf\x96\x55\xaa\x70\xe7\x14\x61\x3a\xf6\x7a\x1d\x7e\x63\x77\x37\xe0\x37\xf6\xb3\x0a\xbf\x11\xa9\xd0\xd9\x67\xd8\x59\xe8\xe5\x73\xec\x25\x74\x4f\x20\xe5\x14\x7e\x63\x5b\x47\x7c\xde\x05\x61\xfc\xfb\xdf\xfc\x43\x90\xc4\x31\xfc\x86\x0a\xf3\xa5\x79\xfe\x7b\x79\x0e\x43\x02\xbf\xa1\xc1\x80\xc6\x6a\xb1\xe3\xab\x3c\xfc\x30\xc8\x5b\xa7\x00\x81\x63\x94\x1f\xa6\x67\xe6\xbf\xff\xef\xff\x4f\x93\xf0\x7f\xff\xef\xff\x57\x13\xed\x7f\xff\xef\xff\x4b\x93\xf3\x7f\xff\xef\xff\x47\xd7\x71\x13\x83\xd0\xdd\x28\x4c\xe2\xc8\x48\xc0\xf0\x78\x29\xe2\xd7\x64\x9f\xb3\x0a\xf4\x02\x40\x16\xa0\x97\x18\x65\xae\x33\xa0\xe6\x9a\x70\x8d\x15\xd1\xb5\x96\x43\xd7\x33\x56\x82\x1f\x32\x8b\x68\x0d\x8a\xed\x23\x5d\x72\x2c\xce\xd5\x17\x1e\x71\x66\xf2\x21\x8e\xba\xb1\xd3\x77\xe0\xe5\x6a\x30\x26\x8e\xe7\x61\x00\x1a\x08\x60\x8b\xe1\x2d\xeb\x80\xf4\x80\xf3\x4a\x74\xc8\xc1\xf9\x17\x9b\x83\xdb\x50\x9f\x6c\x90\xe7\x4f\xf1\xe2\xb6\xb9\xbc\x22\x6e\x6c\x91\xb1\xe3\xd6\x00\xb7\xb0\x9b\x82\xe3\x95\xfd\x0a\x3f\x3a\xf9\x64\x89\xac\x2c\x03\xd8\x50\x6c\x5f\xd6\x1d\xf1\xea\x33\x84\xb8\xf6\xcc\x02\xc8\xab\xad\x3e\x03\x00\x50\x57\x09\x84\xe7\x74\x6c\xf4\x47\xdc\xb6\x37\xed\xde\x94\x3a\xa5\x45\x1f\x1b\x5f\xe4\xeb\x44\xb6\xce\x97\x8e\x5d\x5f\x3c\x31\x6a\x36\xec\xfa\xa2\xac\x01\xe5\xf9\x93\x34\x9b\x76\x61\x6f\x4e\xb1\x69\xce\xbb\x8f\x9a\x2b\x92\x43\x97\xb6\x81\x99\x6a\x36\x0d\x7b\xb1\x41\xb8\xe9\xef\xc4\x4f\x40\xde\xbf\xba\x86\x08\xb9\xf0\xc5\x3b\xcb\x59\xf6\x88\x8b\x33\xf8\xae\x18\x06\xb4\x09\x4a\x2d\x12\xd3\x0b\x1a\x33\x4a\xfa\xce\x60\xc0\x27\x51\x8c\x0d\xde\x20\x7b\x94\x55\xc4\xfe\x2f\xd0\x7a\xac\x51\xda\xf6\x3c\xb5\xae\xd4\x94\x40\x02\xaf\x2c\x72\x50\x06\xc2\xca\x90\x74\x6c\x6c\xae\x98\x20\x68\xcc\x14\x84\x27\x86\xc4\xfa\xd1\x61\xee\x27\x1c\xa0\x64\xd6\xf6\xaf\x3b\x87\x3b\x7b\xaf\x0d\xc4\x6f\xef\x1d\x6e\x7f\xda\xde\x4a\xa7\xa4\x0a\xfd\xba\x73\x68\x95\xf9\xbc\xb7\xbb\xff\x79\x0f\xd3\x32\xf1\xeb\x2d\xaf\x06\x05\x46\x48\x50\xf2\x83\x59\xd0\x3e\x66\x7d\xf1\x03\xcf\x75\x62\xaf\xac\xa1\xa9\x63\x1d\xa8\x95\x26\xd8\x6f\x19\xa5\x26\x9d\xf9\xa0\x80\x5d\x7c\x2b\xea\x17\x1d\x2b\x9f\x67\x4a\xde\x08\x7b\x2b\xea\xab\x4a\x1f\x6e\xc0\xc9\xf2\xd3\xe7\x7f\xca\xa9\xb3\xa8\x01\x85\x6f\xc3\xe2\x23\x17\xbc\xdd\xbc\x61\x95\x22\x5c\xce\xed\x9f\x7d\x13\x96\x24\x12\xc4\x23\xfd\xce\x29\x6d\xe8\x63\x34\x36\xbd\xe5\x08\x9a\xf8\x60\x53\xd2\xc0\x27\x12\x3f\xd1\xba\x07\xf3\x8c\xf3\x2b\xf4\x54\x9e\x0a\x20\xf3\xff\x08\x6b\x99\x87\xd7\x84\x0f\xaf\x09\x1f\x5e\x13\xfe\x45\xaf\x09\x39\x57\x30\xb7\xc9\xbc\xad\xb3\x34\x0c\xfb\xd1\x30\x4c\xa8\x57\x42\xed\x74\x66\xa3\x55\x09\x25\x7a\xe9\x1b\xe5\x72\xf6\x68\x9d\x54\x92\x31\xff\xcd\xd2\xd9\x3d\x5e\xc0\xe5\x65\xad\x0e\x64\xf7\x7e\x09\xf6\xd2\x4f\x10\xaa\x14\x09\x0f\x7b\x94\x1c\xc6\x4e\xc8\x7c\xdb\xd7\x3a\x09\x68\xc2\xc8\x38\x1a\x8a\x77\xdd\x10\xae\x38\xd1\x05\xc1\xfb\x4c\x14\x52\x5d\x83\x43\x43\x17\xf7\xe0\x9c\x15\x83\x76\x9f\x44\x17\x34\x26\x89\xdf\xa7\x27\x78\x23\xe0\x10\xe6\xf7\x07\x01\x25\x1e\x75\x03\x27\xc6\xb0\x97\xed\x0f\x3b\x35\xb2\x1b\x31\x3c\x82\x46\x61\x30\xe6\xc0\x20\xa4\xe4\x90\x49\x6f\xaf\x10\xe8\x17\x43\x54\x72\x8c\xfb\x61\x97\x38\xa1\x47\xc4\x04\x40\xbc\xec\x0e\xe7\x59\x5a\xc5\x7a\x36\x4c\xc0\x6b\xac\x13\xb0\x88\x03\x3c\xa3\x0a\x9c\x1a\x94\x1f\x2e\x0d\x02\xc7\xa5\xe6\xd8\x60\x14\xc0\xf7\x46\x34\x08\xa4\xaa\xf0\xa5\xbe\x79\xe1\x9d\x38\xd5\x58\x3b\x35\xd0\xe6\x45\x94\xc1\xb2\x73\x82\x84\x8f\xbc\x47\x95\x9b\x1c\x11\x61\x93\xc3\xd2\xe5\xfd\x44\x5c\x0b\xb1\x2a\x01\x8f\xb0\xc1\x98\x77\xc5\x3d\x67\x64\x1e\x26\x76\x1e\x46\x39\xcf\x67\x6e\x5e\xf6\x8c\x6f\x5a\x1c\xb2\x02\xc3\x20\x50\xe7\x0e\x20\x6c\xc0\xc7\xc7\x27\x2e\x89\x40\xfd\x49\xfa\xd4\x09\x25\xb6\x68\xa7\x23\x82\x82\x26\xbd\x08\x64\x55\x0e\xb0\x46\x5e\x45\x9c\xb5\x38\x30\x33\x23\xca\xb1\xc6\x01\xf2\x73\x16\xf8\x43\x62\x30\x05\x46\xb7\x47\x3d\xce\x98\x13\x02\x5d\x64\x04\x6a\xfb\x09\x6b\x09\x5c\x9d\x9e\x9e\x7e\x63\x97\x30\x89\x68\xf4\x7c\x98\xa2\x9c\x12\xc8\x57\x4b\x1a\xe9\x4b\xdd\x38\x1a\x0e\xea\xba\x5c\x69\x5d\xc0\x02\xe6\x42\x8c\xd0\xfb\x2b\x8d\x46\x2a\x0f\xa7\xe5\x00\xbc\xf5\xc3\x41\x7a\x41\xfa\xd0\xf3\x31\x34\xf3\x69\x34\x70\x5c\x3f\x19\x93\x7f\x5e\x49\x40\xd7\x7d\x46\xa8\xc3\xe8\x92\x1f\x2e\x45\xc3\xe4\xb4\x8a\xb5\x44\x41\xf4\xce\xb4\x40\xae\xad\x86\x34\xc8\x03\xc4\x8a\x6a\x4c\xae\x57\xce\xfe\x34\x08\xb0\xf4\x52\xd9\xd4\x6b\x11\x33\xbb\x29\xb2\xaf\xed\xd1\xbc\x72\x40\xff\x55\xbe\x22\x7e\xd8\x22\x3e\x08\x13\xe4\xba\xc2\x0f\x65\x65\x84\xf6\x93\x81\x4d\x3f\xdc\xb8\xc2\x32\xd7\xb0\xcc\xa2\x61\xb2\xa1\xc7\xf8\x33\x56\x20\xe4\x0a\x7c\x21\x50\x13\x0a\xff\xf7\x93\xe7\x5f\xe0\x0c\x6f\x5c\x5d\xe9\x64\x42\x6a\xb5\x9a\x89\xd5\x6a\x2a\x2f\x8d\x88\x23\x80\x7e\xac\x4b\x5d\xeb\xa6\xf9\xbf\x9d\x52\x9f\xb4\x49\x87\x8f\x4c\xf7\xfd\x91\xd1\x8f\xba\xe7\x5f\xa8\x1a\x95\x6b\x31\x4e\x83\x1c\x20\xb3\xb2\x2e\x88\x4b\x20\xac\x0d\x4b\x8d\x7a\x37\x2d\x48\x2e\x28\x9c\x78\xd1\x09\x71\x42\xa1\x35\x3e\x1b\x13\x3f\xe1\x3b\x3b\xdc\x61\x26\x0c\x6f\xf5\x75\x35\x58\x4f\x5f\x7a\x0e\x2c\x50\x58\xd3\x5e\x04\x8e\x9c\xf9\xd2\xcc\xe1\x15\x8a\xcd\x11\x86\x8b\x8f\xf3\x1d\x74\xcb\x9e\x5d\xf3\x65\x36\x74\x7b\x9c\xbd\x9c\x81\x2a\x83\xf7\x47\xac\xb2\x28\x46\x99\x8b\x9f\x5e\xe5\x12\x73\x7b\x4e\xd8\xa5\x4c\x2e\x55\x31\xf4\xc3\x1e\x8d\x29\x71\x62\x4a\x56\x49\xdf\xf1\x35\xd3\xb2\xb8\x39\xba\xcc\xf6\xc3\x16\x20\x74\x89\x9c\xca\x3d\xe6\xd4\x4a\xd8\xde\xd2\xdf\xb8\x59\x58\xdf\x98\x0d\xad\xa6\x06\x8e\xbe\xad\xbb\xdd\x80\x7a\xe4\xc2\x77\x70\x1e\xfc\xf0\x14\x2c\xb1\x6a\xe4\x0b\x1f\xc2\x29\xdf\xcc\x4f\x6d\x7e\x45\xce\x68\xd7\xc7\x28\xc2\x1c\xec\xfc\x36\x72\x3a\x96\x38\x5d\x5a\x23\x5b\x43\xbe\x94\xe0\xed\x37\x26\x55\x53\xb5\x47\x7e\x10\x10\x50\xef\x22\x37\x81\x09\x44\x5f\xde\x99\xb9\x01\xd2\x4d\x22\x72\xaa\xf7\xd4\x53\xc5\x40\x15\x57\x11\xc1\x8f\x8d\xca\x9c\x5b\x26\xbc\xff\xc0\x2b\xa9\xac\x4f\xbd\xd2\x29\x76\x8a\x44\xa1\x4b\xd5\x3e\xc5\x3b\x17\xd0\x84\xd6\xc8\x7b\xca\xbf\x13\xe7\x9c\xda\x3a\x2a\xc9\x5f\xb3\x3c\x12\xfa\xb9\x41\x70\xc1\x83\x7c\xa4\x79\x02\x62\x17\xf0\x73\x20\xe2\xc7\x94\x61\x15\x4b\x2e\x97\x72\xa4\xcf\x41\xa0\xf4\x84\x8b\x45\x32\x30\xf3\x99\xfd\x82\x11\x93\x5f\xae\xb9\x9f\xcc\x05\x98\x65\x31\x86\x7b\x66\x3f\x34\x38\xcd\x5a\xa3\x71\x4d\xea\x66\xc5\xb3\x61\x92\x70\x84\x86\x9b\x81\xef\x9e\x8b\x9a\xe9\x51\x5c\xff\x0c\xb9\x1c\xb7\x90\xf8\x53\x1d\xab\x29\x40\x26\x43\xd0\x03\x31\x96\x3e\x90\x16\xec\xae\xd8\x9e\xcf\x88\xcb\x41\x0a\x66\x90\x4b\x2b\xf6\x4c\x22\x25\x20\x19\x3b\xa1\x27\x26\x62\xcc\x8b\xc4\xa8\xba\x5a\x6b\x34\xfa\x8c\x94\x79\x1d\xbc\x51\x8c\x3a\xe4\x54\x0c\xfd\x54\x2c\xd0\x8e\x1f\x82\x4a\x12\x9d\x16\xe3\x46\x69\x90\x4a\xcd\xec\x2e\xac\x0c\x9f\x91\x53\x98\x63\x5c\x12\xcc\xe9\x73\x3a\xe1\xf4\xd1\x73\x06\x03\x1a\x32\x42\x2f\x5d\x3a\x40\x21\x03\x7b\xd7\x8f\x2e\xf8\xa6\xcf\x29\xfd\x54\x89\x70\xa7\xa2\x25\x14\x2a\x45\x88\x6d\x8c\x29\xa5\xa7\xce\xf2\x3f\x01\x46\x45\xff\x2c\x0e\x26\xa5\xaa\x55\x49\xa6\x6c\x2a\xb0\x94\x2a\x2a\x0d\xbe\xc1\x7e\xee\x32\x99\xec\xa7\x42\x57\xab\x58\x51\xa8\xa6\x0c\xd6\x94\xee\x14\x9e\xae\x31\x2f\xd5\x0d\x13\x3e\x5a\xff\xbc\xe6\xe2\x05\xdc\xe6\x41\x09\x63\x07\x83\x1c\x34\x30\xad\xd7\xc9\x4e\x28\xe8\x07\x8a\xa1\x48\x79\x68\x97\x25\xfc\x5c\x28\x04\x1f\xce\x80\x63\x8a\x4a\xe9\xc1\x80\x3a\x70\xc5\x89\xed\xe2\xb7\xb2\x12\xc3\xaa\xda\xe0\x0c\xbe\x6b\x3e\xdb\x95\xd2\xab\x8c\xa3\x01\x90\x49\x4b\x7c\x21\x14\x63\x38\xe2\x34\xcc\x97\xd1\x90\xa5\x7c\x67\x63\x9c\xa9\x90\x5e\x26\x2a\x1b\xad\xd7\xd4\xb5\x2d\x02\xf5\x43\x6d\x5c\x0e\xfe\x87\xa1\x11\x2b\xac\x4e\xaa\x15\xdc\x06\xb4\x73\xd5\x9c\x96\xe4\xd6\x52\x18\x1f\x25\x03\x13\xb7\x9e\x54\x3c\x14\xbb\x96\xee\xb3\x90\xf3\xf7\xc3\xed\x4b\x0c\x2c\x81\xc9\x32\x91\x23\x6d\xd2\x00\xd4\xa1\x6d\xfa\xee\x59\x43\x96\xd1\x5a\x0c\x3c\xab\x78\x5e\xb0\x4c\x87\xac\x95\x02\x71\xbd\x3e\x97\x9a\x95\x4d\x69\x0e\xb5\x61\x78\x85\x90\x66\xa1\xbc\x94\xb2\x6c\xd3\x24\x67\x28\x97\xba\x14\x0c\xce\xbc\x4d\x41\x9c\xc6\xea\x4e\x65\x95\x53\x06\x74\x57\x24\x45\xef\x2d\x54\x17\x5c\xaf\x73\x9a\x77\xf8\x0e\x85\xa7\x8a\x90\x32\x2e\x4f\xe9\xe6\x39\x3d\xe3\x40\x72\xbb\xa4\xf8\xec\x96\xef\x01\x25\x5b\xc1\x15\xd3\x99\xaa\x5b\x46\xa8\x1c\x44\x56\x59\x85\x0c\x9b\xa6\xb1\x74\x20\xb0\xdc\x46\x6f\x8e\x16\x26\x43\xe2\x29\x3f\x33\x14\xcc\x47\x70\x9f\x95\x91\xc0\xa4\x10\x21\xfe\x31\x49\x1e\xbc\x62\x0d\xbf\x8c\xf5\xa5\xe3\x84\xa5\xd7\x98\xac\xb8\x61\xd0\x62\x25\x1d\x3d\xc8\xd8\xc8\x25\x4d\x09\xfd\xc1\x75\xae\x57\x6f\x01\xf4\xd1\x86\x5e\x7e\xa0\xa7\x49\x25\xe7\xb4\x34\x79\xe9\x16\x2d\x45\x63\x10\xaa\xbd\xef\xdf\x49\x3a\xf9\xc6\xf6\x50\xc8\xcc\x89\x84\x34\x1d\xa5\x7d\x46\xc1\xba\x80\xd4\x30\x77\x02\xad\xdd\x8a\xce\x3e\x23\xdf\x29\x24\x31\x91\x6f\x37\xe7\x3a\xa1\x4b\x83\x3d\x63\xc9\xdf\xd8\x68\x97\x26\x87\x28\x5a\xb0\xd4\xc2\x96\xc9\x56\x28\x47\x21\x86\xd8\x41\x87\x44\xa2\xb1\x5b\x70\xf1\x40\x6d\x12\x9a\x8a\x71\x8f\xc9\xa6\xab\x3d\x4b\xee\x2a\x90\x23\x80\xc8\x4a\xaa\x90\xdd\x1c\xe8\x3c\x45\xaf\xc4\x8d\x01\xa7\x45\xa1\x7a\xd4\x39\x1b\x44\x9a\xff\x68\x22\x11\x2d\x88\x42\x35\xfe\x29\x89\x43\xb6\xaa\xf2\xf8\xb7\xcc\x4c\x77\x45\x6d\x97\x9a\xac\x14\x07\xe4\x40\x5b\xf0\xff\x2a\x02\x6d\xe1\x9f\xaa\x80\xd2\x92\xd0\xae\x6f\x98\x29\x93\x96\xcc\xa9\xb2\x69\xcc\x98\x2b\xa5\xa0\xca\x35\x7d\x6f\xd8\xa6\xef\x8d\x49\xa6\xef\x8d\x63\x22\x4e\x08\xc6\x1c\x5b\x4b\x2b\xb5\xd8\x52\xac\xe9\x40\x33\x06\xa1\x6b\x9e\x2b\x5a\xa3\x66\x88\x92\x7a\xdd\x6c\x04\x24\x6a\x27\x18\x39\x63\xc6\x4f\x97\x8a\x11\x44\x4a\xf9\x58\x33\xa1\x16\xad\x05\xd5\x7d\xb4\xf7\xd1\xb7\x72\x52\xf3\x50\xeb\xf8\xa1\xb7\xb5\xbf\xbb\x17\x79\x14\xc4\x3c\xdb\x51\x96\xd9\x5b\x83\x1f\x65\x38\x8f\x88\x7b\x08\x12\x42\x99\x37\x56\x55\x13\x72\x43\x2c\x37\x59\xf3\xd2\x4f\xa0\x62\x3a\x74\x1b\x56\x02\xba\xd7\x6b\xd0\x96\x53\xf8\x02\xd0\x47\x27\x93\x4f\x02\x5b\x4f\x4d\x40\x0e\xfb\xd7\xca\x66\x2b\x02\x5a\x31\x75\x9a\xc3\xb5\x1e\x33\x4d\x40\x83\xb9\x1f\xf2\x8e\x2c\x0b\x42\x32\x19\x89\x5c\x86\x7a\xa4\x62\x25\xa6\x04\x5e\xa4\x73\x9c\xf9\x7c\x59\x9b\xbc\x98\x98\x6d\xca\xc4\x2d\xd5\x47\xa3\x9d\x44\xb3\x49\x80\x63\xb1\x48\x51\x8e\x53\x6c\x24\x3a\x8d\xaa\x63\x50\x08\x9c\xfb\x03\x82\xb6\x4e\xfc\xe4\x89\x5b\x95\x2c\xef\x77\xc8\x08\x35\x2a\x96\x7e\x39\x1e\x86\xa1\xd2\x46\xf8\x09\x68\x53\x99\x64\x15\x27\xfd\x21\x4b\x4e\xf8\x2a\x60\x34\x51\x2b\xed\x91\x02\xc0\xc5\x7d\x6a\x8b\xa6\x38\xd1\x4e\x87\x1e\xe4\xec\xf5\x42\xa9\x7f\x5d\xb5\xfd\xd0\xda\x62\xf7\xb2\xc0\x7f\x84\x52\x2f\xf5\x52\xc4\xa9\x7e\x99\xf1\x16\x85\xe4\x6a\x4c\x9f\xa8\x2e\x68\x41\x4d\x9e\xc4\xe0\x8d\xfd\xe4\x4b\xbe\xa0\xa3\x79\xdd\xf4\xc3\x6e\x51\x53\x80\xfe\x57\x3b\xbf\xee\x6e\x2b\x1e\x2c\xe6\xf8\x85\x0d\x30\x0a\x35\xc9\x6f\x87\x9e\x80\x27\xe9\xa1\x26\xd8\xf9\x44\xd4\xcd\x8a\xf9\x89\xb8\xb7\xc7\x24\x2b\x5c\x67\xa6\xe4\xfa\x26\x21\xc0\xe0\x38\x79\x6b\x57\x31\xa2\xf4\x82\x5d\xc9\x59\xb0\x97\xe9\x90\x84\xb8\xab\xce\xb2\x8c\x38\xa8\xc2\x55\x04\x8c\x4c\xd3\x3e\x2f\x3c\x25\xb5\x0b\xc9\x76\xe2\x8c\xad\x68\x84\x83\xa6\x63\x3a\x5a\xcf\x92\xba\xc1\xc3\x6f\x26\x6f\x71\x61\x36\x89\xba\xed\x7e\x49\xe2\xd6\x14\x2d\x0a\xdd\x44\xb1\x20\x8d\x4c\x1c\xfe\x8c\xc8\x9b\x0a\x7d\x33\xd1\x68\x76\x3f\xb7\x03\xea\x67\x77\x7b\xd1\x2d\xb5\x51\x5a\x47\xe1\x09\xb2\x88\x2c\x23\x9a\xd4\x62\xc3\xe4\x03\xf5\x0d\x1b\xa4\x89\x50\xb3\xe7\x16\xa2\xa5\x70\x41\xd1\x7c\x81\xb7\x91\x59\x74\xab\xf6\xa2\xab\xd7\xc9\x17\x0a\x41\x98\x41\xd1\x08\x17\x05\xe2\x44\x29\x44\x43\x3c\x62\x4b\x93\x0c\x46\x46\xa8\xc3\x27\xee\x97\x4f\x1f\x48\xc7\x8f\x29\x23\xbf\x0f\x7d\xf7\x3c\x18\x4b\x80\x4e\x87\x6f\x60\xee\xd6\x2e\x6c\x45\x67\xb4\x13\x61\x50\x66\xa1\x18\xec\x04\x43\xd6\xa3\xac\x4a\xd0\x94\x7f\x14\x0d\x03\x8f\x78\xd1\xf0\x2c\xa0\x24\x89\xfd\x6e\x97\xef\x7e\x12\x96\xde\x66\x8d\xe5\x61\x9e\x78\x37\x94\x90\x47\xf5\x90\x0e\x41\x09\xdf\xe3\x90\xd1\xdc\x82\x84\xd4\xa5\x8c\x39\xf1\x18\x2f\x58\x13\x75\x11\x81\xa6\xe6\xb1\xe3\x82\xfa\xcc\x43\xf5\x01\xdc\xfa\x4a\x60\x52\xbe\x51\x38\x65\xe9\x2b\x5c\x3f\x24\x09\x85\x90\x23\x55\xc2\x22\x29\x65\xf6\x9d\x73\x4a\xd8\x10\xc6\xee\x24\x12\x1a\xde\x53\x0a\x8a\x23\x4e\x38\x56\xe8\xce\x6b\x07\x30\x39\xa2\xb2\x31\x14\x51\x5d\x4d\x3f\x52\x00\xb3\x48\x57\xcd\xfd\xfa\x5c\x56\x48\x33\x68\xa4\x90\x4d\xac\x66\x50\x6c\x88\xd5\x6e\x4a\x1e\xbe\x71\xe9\xa5\xba\x67\x51\x6f\x51\xcf\xd3\x54\xbb\x96\xdd\x2a\x1c\x17\x6e\xe1\x37\xf4\xa3\xda\xfc\x25\x66\xf8\xa9\xb8\x50\x0a\x64\xb9\xb2\x11\x88\xc9\x82\x14\x58\x71\x60\xb1\x18\xd3\x5a\xfe\xfa\x55\x85\x14\x6e\xb0\xa9\x94\xe4\x5d\xd4\x49\xc1\x29\xd2\x7e\xfc\xe7\x8a\x3b\x74\x6d\x3b\x4e\xce\x40\xbc\x61\x46\x52\xfc\xdd\x6c\x78\x22\xeb\xaf\x92\x9e\x13\x7a\x81\x16\x0c\x73\xc9\x4f\x96\x31\x4f\x71\xc6\xf6\x4f\xd2\x67\x0f\xc7\xf3\xb6\x43\xef\xbd\xcf\x12\x1a\xda\xea\xd0\xc2\x42\xb2\x5b\xe9\x71\xe7\x07\x91\xb3\x8f\xf7\x66\x03\x4c\x49\x0f\x59\x1e\xaf\x46\x9d\x7f\x80\x92\x40\x26\x83\x68\x4c\x77\xfc\xc1\x7b\xae\xec\x6b\x75\xeb\x40\xce\xac\xd3\xb2\x79\x36\x5b\x57\x88\x9e\xac\xaf\xcb\xf1\xed\xab\x97\xd9\x24\xe7\xd5\xc6\xeb\xf1\x13\x3b\x6e\x76\xaa\xcc\x2d\x22\xb8\x4a\x08\x25\x19\xb9\xb7\x5e\x17\x6e\x91\x51\x49\x0e\xdb\x0e\x60\x2b\x41\xfe\x8f\x7d\xc5\xb7\x22\x46\x6b\x35\x5f\x08\x50\xd9\x1c\x53\xcd\x5e\x54\xc6\x3a\xf9\x16\x15\x32\x15\x34\xd9\x5c\x3a\x09\x3e\x9d\x00\x56\xa9\xa2\x0a\x5a\xb5\x68\xbe\xa8\x54\x34\x79\x7c\xfa\x20\x73\x43\x09\xea\x4d\x28\x30\x61\x10\x4a\x96\x9c\x5c\x00\xec\xb4\xd5\x92\x14\x26\x8c\x8a\xac\x36\x36\x48\x49\xd2\x7e\x29\x43\xb0\xb2\x9c\x20\xef\xaa\x01\xbd\x92\x21\x64\xb4\x89\x90\xaa\x19\xad\x97\xd9\x94\x91\xde\xa3\x30\x18\x2b\x27\x04\x15\xfb\x3a\x23\x55\xc7\x74\x20\x20\xbd\x07\xa4\xda\xbe\xb6\x42\xf3\xa9\xc5\x0d\xfe\xb1\xd3\x3d\x30\x2f\x26\x0d\x3e\x20\x54\x0a\xa6\x53\xb9\xcc\xc5\x87\x32\xe4\x56\x01\xdb\xd6\x2d\x10\xc6\x35\xca\x44\x38\x8a\xc1\xa4\x72\x38\xa7\x41\xb7\x5e\x73\x36\x87\x32\xdd\xd4\x70\x11\xaa\x46\xc3\x8b\xda\xde\xfe\xd6\xf6\xc9\xf6\xde\x2f\x68\x1c\x3a\x88\x23\x6f\x28\xcc\x43\x5f\xe0\x83\xd0\x85\x05\x8e\xd6\x05\xd2\x26\xa7\xb2\xc5\x53\x69\xad\x82\xe6\x1d\x60\xd3\xc6\xa5\x4a\xea\x78\x78\x61\x09\x17\xa5\x84\x22\xb6\x6b\x58\x1f\x04\x39\xd5\x67\x9f\x09\xa3\x59\xb4\xca\x83\x2b\xcf\x7c\x03\x8a\x21\xc3\xfa\x65\x7d\x6b\x5e\xd5\x36\x87\x55\x6d\x53\x58\x55\x16\x8e\x55\xd3\x2c\xb2\x22\xa5\x53\xb0\x88\x61\xd4\x43\x70\x49\x44\x20\xaa\x80\xba\x69\x65\x03\xea\xfa\x1d\xdf\x15\x2c\xcb\xb6\x37\xc3\x31\x60\x4d\x69\x37\xc1\x7f\x9b\x66\x0a\xca\x26\xa1\xb9\xd6\xb8\xfe\x19\xf3\xa5\xe1\xd3\x90\x49\xcb\x27\x22\x0d\x0c\x76\xc7\x8a\x88\xb4\xc7\xae\x8d\xab\x53\x30\x52\xe2\xff\x5b\xfa\xe7\x15\x56\xbd\x3e\x45\x13\x07\xac\x5a\xb9\x16\x4d\xdb\xc6\x49\x44\x5a\x27\x10\xb2\x50\x9f\xd3\x7c\xde\xa2\x37\xed\x94\x4f\x27\xf2\x29\xa9\xf9\x4c\x58\xf1\x7b\x55\xa3\xbc\x9c\x40\x9d\x7b\x5c\x31\x8b\xce\x99\xf4\x71\xd0\x8b\x46\xb6\xe9\xc3\xba\x3c\x03\x80\x9d\x8d\x50\x86\x09\x4b\x3d\x61\x2e\xa4\xba\xeb\x5b\x1d\x45\x0f\x84\x26\xf4\x94\xf1\x63\xca\x5a\x8a\x93\x93\x98\x6f\xe2\xf7\xfb\xd4\xf3\x9d\x84\x06\x63\xe2\x40\xcc\x7b\x79\x02\x58\x80\xaa\x78\xfb\x5d\x60\xad\x55\x23\x3b\x1d\x30\x9f\x1a\x39\x21\x68\x17\xe6\x03\xe7\x8f\x31\xc2\x9e\x4f\x19\x76\x44\x21\x9a\x0f\x71\xc0\x18\x7d\xff\x14\x2c\x55\xe2\x21\xbd\x3e\x55\x36\x58\x8c\x26\xe4\xd4\xdc\xbd\x4e\x6b\xa4\xdd\x91\xa6\x99\x58\x0f\x31\x63\xd0\x7d\x9e\x05\x49\xe2\x8c\xb1\x2d\x31\xd0\x2a\xe1\x92\x29\xef\xc5\x3c\x92\xfd\x7c\x95\x0c\xc3\x80\x32\xb4\x9a\x75\x02\x16\x09\x9a\x1e\x93\x53\x6b\x6b\x3c\xad\x29\xb4\x9b\x1d\xbb\xd3\x04\xf0\xee\xe9\x39\xc0\xc3\x0e\x98\x96\x3a\x68\x94\x82\x66\x2f\xc2\x56\x04\x27\x5f\xf0\x85\x03\x8e\x20\xbb\x7f\x7c\x63\x19\x47\xc3\x92\x47\x06\x31\xed\x70\xd4\x44\xf2\xd8\x94\x42\x8d\x6a\xa8\xe3\x87\x3e\x3f\x8a\x12\xc1\x0d\xf4\x10\x2d\xd0\x93\xc7\xb8\x17\xc5\x7d\x34\xa5\xb0\x49\x2b\x8c\x4c\xae\xc4\x69\xac\xc3\xdb\xc4\x83\xe9\x28\x44\x43\x1c\x18\xa2\xc1\x0f\x7e\x36\x8d\x00\xa1\x0b\x4c\x8c\x38\x45\x62\xc6\xbc\x8b\xa9\x47\xaa\xc0\xf1\x02\xfd\xa0\xd0\x82\x16\x37\x60\xcd\x56\x95\xe6\x61\x08\x31\x45\x2b\x89\x69\x3b\x45\x1c\x46\x58\x14\xc1\xdf\x9c\x3e\x9a\x3d\x43\x60\x3f\x93\xbd\x28\xa1\x2d\xe3\x60\x1d\x46\x9a\x3b\xce\x63\x5f\xe6\x95\xe5\xae\xea\x1c\x98\x0e\x3b\x9e\xc7\xcf\xd4\x60\x56\xc8\x5b\x70\x02\x72\x0a\xe4\x7d\x6a\xf4\x4a\x4f\x8e\xbc\xf9\x9a\x34\x2b\xdb\x21\x04\x05\x8b\x62\xe2\xf9\x0c\x7e\xa6\xd7\x0b\xd3\x00\xe9\xcd\x94\x9c\x03\x8f\x33\xa4\x7c\x70\x37\xd2\xcc\xe1\x44\x2b\xbe\x2a\x9f\x80\xbe\x1f\x04\x3e\xa3\x6e\x14\x7a\x92\x04\x24\x0b\x95\x2b\xf6\x94\x0b\x88\xfc\xa0\x29\x45\x44\xb0\xd3\x1a\xc4\xd1\x85\xef\x89\x1d\x0b\x2b\x7e\x8d\x86\xa4\xef\x8c\xd5\xca\x76\x08\xf3\x21\x1e\xb7\x3c\x1a\x71\x51\xdb\xb1\x68\x80\x91\xc0\x3f\xa7\x2d\x65\x39\x86\x46\x73\xa7\x55\x04\x08\x0a\x21\xcf\xbf\xf0\xbd\x21\x90\x3e\x94\x2d\xd8\xed\x14\x80\x2b\xb1\x19\x09\x6c\xaf\x34\x1a\x55\x99\x02\x08\x5b\x53\x09\xd7\xd7\xf6\xd6\x84\x5f\xff\x82\xb7\x1e\x57\x22\x90\xec\x77\x72\x85\x90\x5e\xb4\x88\x74\xdf\xca\xe1\xa8\x4f\x09\x85\xcf\x88\xe8\x83\x29\xfe\x88\x33\xdb\xc0\x34\xad\x50\xcf\xaa\x4e\x02\x38\xeb\xa4\xef\x3d\x21\x8e\x10\x53\xee\x95\xa1\xd4\xcf\xa4\x49\x5e\x60\x85\x25\xd2\x24\x2d\xd2\xa8\x54\xc9\xc9\x39\x38\x45\x68\xae\xe3\xaf\x9f\x20\x1f\x3f\xc0\xeb\xb2\x3c\xda\xc7\x5d\x76\x04\x25\x96\x48\xf3\xd8\xf2\x4f\x7d\x02\xcf\xca\xd2\xb2\xed\x00\xde\x1f\x6a\xca\x92\x2a\xd9\x83\x9e\x33\xa0\xfa\x14\xf8\x28\xff\x60\x0d\xb5\x07\xe6\xce\x6c\x09\xbf\x83\x44\x84\x4c\x52\xb7\xb8\x55\x72\x04\x90\x94\x53\x29\xde\x61\xe1\x85\xcd\x26\x68\x78\xdb\x4a\xdc\x21\x4b\xa2\xbe\xc9\x49\x28\x67\x38\xb8\x9f\xd7\xc8\x66\x4a\x76\xd3\xe5\xe0\x31\x34\x87\xb3\xb5\xbf\x8b\x57\xab\x9c\x53\x39\xe4\xd4\x8b\x42\x7a\xaa\xd4\x2a\x35\xd2\xd6\x46\x3f\xfd\x28\xe6\x4c\x2f\xa4\xa4\x1b\x3b\x70\xe7\x6c\xb7\x8b\x00\x83\xa8\xeb\xbb\x35\xb2\xb0\x00\xec\x69\x61\x81\x28\x73\x05\xce\xa3\x58\xc2\x39\x1f\x88\xa2\xf8\x5e\x4c\x6a\x76\xfc\x8e\x5a\x47\x45\x52\x9c\x8d\xdd\x8d\x2b\xa1\x93\xe0\x3d\x96\xa6\xae\x28\x7b\xd5\xeb\xbc\x05\xdc\x83\x18\x33\xf7\x84\xd0\x83\xed\x18\x18\x7a\xdf\x89\xcf\x05\x1f\xe7\x9b\x12\x8a\xc4\xb6\xf6\x93\x03\xe3\x8d\xd4\xd2\xeb\xbe\x5c\xb2\x80\x96\xb0\x17\x55\xd4\x18\xe1\x09\x27\xbb\xa8\x80\x93\x5a\x63\x30\x79\x16\x3a\x85\x36\xa7\x58\x69\xbd\x3a\xc0\x83\x0c\xb5\xee\xbc\x94\xb1\xe7\xa5\x8e\xc2\x87\xbb\xc6\xc0\xa7\x5e\x8d\xb4\x43\x42\x2f\x93\xd8\x21\xe0\xb4\x86\x26\x34\x16\xfd\xf0\x59\x5b\xde\x3f\x01\xe3\x62\x43\xac\x22\x1c\x74\xf9\x2e\x98\x6a\x77\x0c\x31\x10\x2d\x98\x7d\x46\x22\x97\xcb\xfd\xf0\x7a\x06\x37\x3f\x61\xc3\x86\x1b\x53\x86\x67\x48\x0f\x8e\x30\x45\x2d\xf2\x26\xe9\x07\xe2\x50\x57\x25\x46\x2f\x5a\x84\x73\xea\x0a\x59\xfa\x19\x2c\x49\x14\x96\xa2\xac\xa8\x73\x23\x7a\x1c\x25\xad\xfd\x87\x61\x27\x8d\x15\xc8\xb9\x03\x62\xa8\xf7\x9f\x81\x97\x22\xaa\xa1\xde\xec\xcb\x0a\xa5\xd2\x3c\xfc\xdc\xa2\xb3\xb9\x3d\x4b\x49\x28\xb7\x9a\xb5\x1f\xda\xab\xbb\x90\x13\x1e\x68\x7e\x4c\xbf\xb2\xd3\x38\x77\x4d\x5a\xe4\xea\x7a\x1d\x7c\x3b\xec\xa1\x41\x3c\x35\xae\x36\x22\x21\xed\xbb\x01\x75\x62\x7e\xde\x40\x9a\xf3\x22\x17\xb6\x78\x90\xfd\xf4\xeb\xdc\x30\x8a\x84\x0e\xc6\xd4\xbf\xe4\x78\x93\x57\xaf\x2d\xaa\x99\x93\x98\x4a\x4e\x9d\x5e\x54\xba\x14\x9c\x55\x82\x10\xc5\xe0\x31\xab\x12\x5c\xf1\xcb\xe4\x7b\xbc\x73\xd5\xd4\x92\x4f\xa5\x71\xfc\x60\x92\x41\x60\x46\x19\x39\xb5\x76\x92\xac\x05\x8a\x27\x63\xdc\xe6\x63\xd5\x86\xa5\xe8\x52\x0f\x53\x9b\x76\xb2\x7e\x85\xba\x9c\xcd\x80\x0a\x2b\x19\x38\x58\x7e\x35\xd7\xf5\x9c\xa9\xc9\x9b\xe0\x11\xe3\x1a\xcd\xf9\x27\xb9\xd8\x28\xaf\x54\x2a\x95\xb4\xc3\x8e\xa7\x77\x72\xd8\xc1\x45\xc1\x33\x87\xd1\xd7\x34\x39\x74\xba\x45\xe1\x68\x56\x84\xa7\x6a\xe9\xe4\xf7\xbd\x7f\x5e\xe4\xbd\x70\x75\x55\xf8\xd9\x24\xa7\x58\xf6\x7f\x25\x11\xba\x98\x39\x25\x31\x65\x1c\x25\xb1\x7c\xf0\xce\x6a\xbc\xef\x70\x21\x31\xee\x9f\x45\x01\xf6\xa0\x74\x84\x7a\x49\x72\x00\x89\xc7\xc6\x63\x5d\x78\x4c\xc1\x38\x4f\x3e\x85\x07\x29\xa7\xb8\x2a\x1c\xc6\xfc\x8e\x2f\x25\xaf\x53\xac\x77\x4a\x06\xb1\xdf\xf7\xe1\xc6\x2b\x8a\x85\x7f\x4e\xe5\xf6\x0e\xc3\x1d\xc3\xcf\x3e\xe5\x32\xfe\x7e\x87\x9c\x60\x8e\x1f\xba\x94\xac\xd6\x1a\xb5\x06\x7c\xf3\x5d\xa0\x1b\xc5\x63\xf2\xde\x01\x3f\x3b\xca\x65\xde\xc2\xb5\x78\x15\x73\xa8\xde\xc7\x24\x11\x7a\x38\xab\x19\x3e\xf2\x18\xb9\xe2\x5c\x9d\x3a\xe1\x35\xf9\x24\x52\xc4\x93\x30\x7b\x1c\x8e\xc0\x42\x15\x6f\x85\xc4\x23\x19\x04\x25\x9e\x4e\x89\xde\x9f\xd4\x7c\x86\x83\x2c\xe3\x9f\x9a\x9f\xd0\xd8\x81\xc8\xd3\x3c\x1f\x3d\xd8\xf0\x36\xb2\x15\x4a\xce\x99\x5b\x32\x8b\x41\x33\xf0\x78\xc6\x50\x8e\x8a\xc2\x22\x6a\x83\xe1\xa1\x51\xa8\xdb\x85\x37\xfe\x0d\x52\xc2\x3e\x97\xc8\xf7\xef\x40\x21\x65\x93\x44\x64\xfd\xc7\x8f\x0d\x1a\x93\x89\x1b\x1b\x7a\xd6\xd1\xa7\x79\xc6\x4d\xa0\xec\x47\xd6\x6f\xe7\xb3\x7b\xf5\xdb\x99\x1f\xe7\x5b\x81\x99\xd7\xbe\x43\xe6\xab\x3a\x0e\x07\xb2\xb7\xb9\xeb\x8a\x76\x4e\x03\x4a\x7e\x79\x3b\xf0\xc5\x4f\x7a\x9b\x46\x70\xd5\xe2\x4c\x0d\xc0\x67\xbb\x43\x5f\xec\x1f\x80\x00\xfd\x99\x2a\xa4\x95\xb7\xa2\x98\x4a\xb8\x95\x93\x99\x33\xe7\x8c\x06\x1f\x82\x61\xd7\x0f\x5f\x05\xd1\x08\x14\xe7\x6a\x73\x82\x1b\x36\x3e\xe3\x27\x7b\xc2\x46\x35\x17\x54\xed\x36\x40\xc0\x55\x7a\x9e\x47\x9d\x9a\x13\x8e\x81\x41\x52\x16\xf8\x61\xb2\x24\x95\x23\xf8\x80\xba\x8e\x9a\xb8\x25\xc1\x56\x97\x94\xef\x5f\xc3\x2d\x45\x31\x82\x0d\x47\xd1\x3a\xea\xac\x49\xd6\x88\x2c\x7d\xb1\xd3\x77\x06\x46\x9d\x94\x37\xe9\xd4\xdb\x12\x70\x52\x8a\xf5\x6d\xef\xf0\x15\x59\xfc\xf1\x63\xb3\x90\x79\x13\x94\x71\x24\x6d\xc4\xce\x80\x1c\x71\x67\x6d\xbb\x55\x29\x97\x54\xb1\x12\x38\xea\x30\x4a\xea\x70\xbe\x8b\xa4\x44\x4a\x64\xd1\x08\xf0\xdb\xd2\xbf\xe7\x88\xe5\x85\xda\xf4\xee\x61\x12\x5d\x99\x4a\x31\xb5\x3f\xf4\x79\x3d\x66\xa1\x6d\xc2\xd0\xa9\x14\x82\x1e\x3f\x56\x75\x95\x3b\x19\xa9\xd8\x87\x1b\x6b\x91\x5b\x81\x1b\xa0\xa5\x66\x4e\x67\x14\x69\xdf\xd0\x9d\xc2\x76\xf2\x9a\xb0\x19\xca\xf3\xbf\xd2\xed\xd5\xbd\xf1\x1f\x26\x5f\xe5\x67\x3c\x5a\xd9\xb0\x97\x0b\xd6\xf2\xd3\x4a\x7e\xf9\x95\x09\x8e\xa2\x52\x90\x15\x04\xe1\x9e\xbf\xa8\xa9\xd5\x74\xc1\x49\x6d\x48\x58\xaa\x4e\x81\x4d\x40\x51\x63\x6b\x37\x55\x9c\xd4\x78\x51\x5b\x86\x3b\xad\xce\x3a\x97\xdc\xff\x25\x9e\x92\x52\x4f\x33\xe7\x0f\xce\x80\xc6\x3f\xd2\xeb\x97\x0e\xb6\x5d\xe4\x97\x2b\xa7\xe8\x24\xf0\xba\x94\xaa\x38\xf2\x93\x9e\x72\xf8\x90\xd7\xc6\x93\x9c\xa2\x93\xda\xd0\xa5\xb4\x7b\x31\x8e\xa8\xa2\xe9\x5b\xb5\x8b\x4d\x02\x0d\x05\x54\xf1\x83\x84\x0e\x36\xa3\x30\xa4\x6e\x12\x15\x41\x7f\xb2\xdc\xc8\x2f\x3f\xa9\x19\xab\xa0\x55\xbd\x28\xc6\x6c\xe3\x89\x55\xec\x26\xe0\x7f\x9a\x07\xef\x29\x37\x6f\xb9\x35\x82\xbe\xfa\xce\xa2\x80\x0d\xed\x06\x99\xe0\x6f\x29\xa8\xdc\xa6\x53\x5a\xa0\xbb\x5b\xbf\x24\x9c\x69\xba\xa6\xb6\x82\xcc\xde\xa0\xf5\x0a\x90\x52\x4e\x7a\x34\x25\x0d\x09\xf1\x26\x8a\x92\x96\x8e\x70\x81\xce\xd3\x5b\xa4\xd4\x09\xe8\x65\x49\x1a\x6b\x0d\xd0\x7f\x07\xdc\xd6\xf5\x69\x8d\x0d\x1c\xd7\x0f\xbb\xb5\x61\xe8\x27\x64\x81\xac\xa0\x98\x81\x85\x7b\x51\xec\xff\x11\x85\x89\x13\x68\xa8\x1c\xd6\x96\x1f\x53\xe8\x50\x8b\x94\xe2\x68\xa4\x40\x3b\x81\xdf\x0d\x77\x12\xda\x67\x2d\x52\x72\xa9\x70\xc7\xa9\xe1\x5d\x70\x3e\xec\x4e\x82\xe6\x46\xc1\xb0\x1f\x8a\x4a\x68\x60\x73\x7d\xbb\x99\xdb\x8f\x7d\xa9\x60\x29\x74\x05\x89\x66\x0d\xe5\xa3\x92\x1e\x20\x04\x7e\x13\xdd\xc3\xd8\x6e\xb7\x68\xd3\x54\xd1\x68\xeb\x06\x8a\x57\xcf\xc2\x84\x93\x71\x46\x53\xfe\x83\xc6\x11\x9c\xac\x3c\x11\xdf\xc4\xb8\xd8\x84\x72\x9c\x91\xb4\x8a\xba\x2d\x63\xc9\x9b\xcd\xec\x74\xe0\xc2\x37\x89\x48\x89\x0b\x17\x25\xb8\x3c\x89\x0c\x24\xf8\xcc\x98\xc7\xaa\xb2\x6a\x08\x85\x51\x36\x1d\x88\x00\x42\x70\x0f\x7c\x46\xc9\x20\x52\x97\xd6\x43\x30\x4c\x04\x65\xa9\x6b\xdd\xc1\x06\x09\x8d\x43\x70\x84\x05\xb1\x3a\x0a\x3b\x9c\x73\xf9\x39\x8a\x88\xbc\xbf\x39\xfd\x09\xb8\x6f\xdd\xbc\xf7\x36\x6e\x52\xb5\x3d\x8a\x38\xc2\xce\xc6\xf7\x2c\xeb\x32\xf2\x62\x26\x28\xc6\xad\xd9\x3d\x40\x68\xcd\x36\x92\x42\x2c\xb3\x9e\x33\xa0\xe5\x59\x60\x16\xdb\xe6\x7c\x66\xb4\x33\x0c\x38\x59\xa1\x24\x27\xa8\x65\x1c\x50\xa9\x58\x05\xd5\x49\xde\xb4\xa1\x37\xa0\xc2\xde\x8a\xb0\x2b\x56\x6b\xff\xf2\xbb\x61\x14\x53\x1b\x06\x9e\xa9\x8a\xc6\x8c\xf1\x3e\xed\x7b\x48\xc3\xaa\x21\x89\x80\x96\x03\xc7\x05\xbd\x7a\x32\xa2\x34\x24\xd4\x71\x7b\x40\xf2\x46\x6f\xa5\x44\x50\xdc\x5f\x6d\x02\x75\x3b\x3a\x54\x7b\xc8\x8c\x14\x28\xeb\xdf\xcf\xbc\xcb\x63\x5e\xf5\x96\xab\x09\xb7\xe7\x19\x87\x00\x95\xef\xa7\xff\x1c\x54\xe5\xb8\x92\xcf\xfc\x7a\x94\x9c\x72\x5e\x32\xa0\xf1\x29\x32\x32\xf0\x67\xc7\x98\xcf\x12\x74\xce\x0c\x1e\xc5\x03\xf4\x5b\x45\x85\x7d\x71\xe0\x87\xd4\x89\x09\x84\xf9\x50\x04\x11\x46\xe1\x7b\x48\xbf\x0d\x53\x13\x9c\x74\x00\xd6\x6a\x9a\xf5\x96\x03\x67\x0c\x16\x16\x41\x34\x22\x9e\xdc\xe6\x0c\x9e\x6f\x14\x9e\x4c\x7f\x93\xf6\x2a\x34\xdc\x54\x32\x82\xc0\x43\x3a\x1c\xab\xde\x5e\x54\xb0\x54\x9d\xa4\x37\x70\x9b\xb1\xeb\xa2\xa9\x8c\xaa\xa9\xfc\x50\x81\x0c\x85\x2e\x83\xb2\x6a\x5a\x37\x02\x1e\xe1\xac\x42\x3c\x55\x15\x33\xe2\x93\xe5\x1a\x98\xab\x55\x6a\xc3\x91\xa9\xb2\x98\x9a\x3b\x55\x44\xa5\xa8\x78\xb0\x96\x78\x20\x5e\x9a\xe9\x34\x2b\x6c\x2c\xd9\x40\x75\x49\xd1\x09\x54\xc7\xb5\x51\x76\xed\x1a\xa5\x7c\x92\xd2\x58\xc3\x08\xb2\x80\x21\xf5\x13\x54\x42\xfc\x43\x5a\xc4\x57\xc1\x01\x3e\x0e\x8c\x7f\xa8\x21\xf0\x0f\xa3\xab\x28\xa5\xc8\x08\x6f\x86\xd6\x12\xfa\x6c\x9c\x1c\x75\x37\x45\xdb\x35\x2e\x27\x56\xed\xc9\xa9\x66\xe7\xfe\x05\x3a\x44\x68\xc9\x49\x3e\x32\x1a\x17\xd1\x6f\x31\x18\x86\x3e\xac\xd9\xf3\xf4\xe2\x06\x93\x6a\xb3\x70\x95\x5c\xd9\xab\xc1\x9c\xa8\xeb\x0a\x69\xa9\x87\x0b\x66\x40\x3b\x75\xb4\x49\x29\x03\x93\x08\x8d\x74\x2c\x43\x6f\x94\xb1\x29\x48\x6a\x16\x80\x54\xfc\x39\x5e\x26\x15\x7e\x4e\x8c\x93\xf3\x10\x53\xd6\x23\x05\x21\x50\x8b\x06\xa2\x96\x19\x50\x89\x71\x15\x87\x34\x8e\xee\xd8\xbc\x54\xba\xd0\xaa\xa6\x93\x03\x87\x25\xa2\x59\xb2\x48\x9a\xc0\xa2\xed\x51\x09\xb3\xa5\x82\xa5\xdd\xca\xa4\x64\x16\x5b\xcb\x9e\x4f\x14\xca\x0d\x43\x7e\x93\xa5\x6c\x6c\xa4\x43\x00\x9b\xf8\xaa\xa5\xde\x6b\x11\xdb\x17\xc1\x23\xbd\x70\x1f\x3f\x36\x39\xd5\xcf\x13\x81\x2a\x8c\xdd\x1a\xee\x4f\x13\xe1\x4a\x8c\xdb\x60\xad\x47\x57\x47\x8f\x32\xcb\xe5\xf1\x63\x63\x29\x3c\x7e\x2c\xa6\x46\x38\xcb\x98\x6e\x21\x68\xa5\x32\xc6\x22\x14\x19\x10\x89\xb0\x8c\xf0\x96\x48\x13\xe2\x66\x2d\x25\x91\x0e\x50\x48\xea\xf5\x94\x0e\x7e\x89\xef\x6d\x60\x4b\x9b\xd4\xc3\x48\xc4\xb0\x83\xb2\x4b\xe7\x74\x2c\x54\xc9\xd5\xc9\xdd\xc2\x75\x00\xdc\x44\x2a\xfc\x34\x2b\xb9\xba\xae\x5a\x48\xab\xa2\x5c\x85\x9b\x4e\xe5\x58\x6a\xa9\xd3\xfa\x7a\xa3\xa9\x9c\x70\xd6\xa8\x2a\x92\x45\x90\x1e\x8b\xda\x27\xec\xf7\xa1\x13\x2b\x67\xcc\x34\xa0\x17\x62\xc1\x35\xaa\x96\x4e\x5e\x71\xc6\x6b\x11\xc1\x58\xdc\x8c\x02\x2b\x50\xd1\x79\xc5\xae\x39\xd3\xa3\x87\xb2\xf0\xc8\x74\x75\x9b\x53\x9c\x25\x79\xdf\xf2\x48\x95\xaa\x3b\x9d\xc4\x9d\xae\xa4\x57\xf9\x5f\x22\xd6\xce\x74\xa4\xca\xa9\x3b\xf5\x61\xea\xc7\x88\xd3\x29\xac\x4e\x27\x3d\xa6\x2a\xdd\x8b\x14\x68\xc0\x9c\xbb\x16\xcb\x36\x75\x25\xa0\x57\x0f\x27\x58\x2e\x9f\x98\xd2\xca\x44\x6a\xad\x4c\x0b\x31\x2b\xf1\x4c\xc0\xc3\xb4\x50\x0d\xd9\xe8\x41\x15\xf0\x27\xa8\x02\xa6\x9e\x17\x25\xcb\x4e\xe4\x3c\xb7\x02\x27\xe4\xe1\x89\xc7\xfe\xa9\x01\x1a\x72\xf4\xc3\xe9\xfe\x7f\xc0\xe9\x7e\xda\x89\x35\xcf\x44\xf7\xc0\x5f\xcc\x53\xd5\x64\x4a\x99\xc4\x81\x51\x9e\xea\x54\x84\x65\xa0\x94\x28\x72\xcc\xf8\x4c\x21\xa1\x91\xbf\xfb\x2b\x59\xdf\x54\x50\x4d\x14\xa1\x52\x37\x61\x4a\x8a\xc2\x77\xef\xa9\xcd\x49\x81\xb7\xf6\x1e\x73\x6c\xa0\x55\x90\x63\x10\xb7\xf1\x64\x83\x94\x44\x52\x29\xd7\x70\x0e\xb0\x6d\x5c\x28\x6a\x4c\xe3\xcd\x45\xa5\x2c\xaa\x57\x7e\x84\x61\xdd\xb3\xc6\xd4\x21\x61\x65\x24\x09\x9f\xa5\xc3\xb2\xea\xd7\x54\xf2\x3d\x06\xbe\x4a\x03\xaf\x9c\x2c\xcf\x1a\x0d\xcd\xcf\x1a\xb5\xa6\x30\x3f\x4b\x59\xa7\x29\x6b\xb4\xcf\x89\x1f\xe4\x5a\xa3\xb5\xc3\x31\xfe\x4a\x19\xa1\x2d\x18\xe6\x67\x68\x74\x96\x67\x5a\xc6\xcf\xa6\x91\x8c\x43\x7d\x45\x4a\x4e\x09\xfc\xf4\x9b\x1e\xfa\xa3\x80\xd6\x82\xa8\x5b\x3e\xa9\xf9\x1e\x0d\x13\x3f\x19\x97\x05\x67\x86\xb5\x2f\x7e\x67\x0d\xd1\x4c\x03\x33\x59\x31\x6b\x60\x06\x29\x05\xe6\x60\xa2\x56\xc6\x1c\xec\x59\x73\xd2\x54\xe5\x04\x07\xbf\x85\x25\xc7\x6c\x41\xc7\x55\x27\x9c\x2a\x39\xb3\xc6\xe7\x90\x9f\xc8\x19\x79\x41\x96\x9a\xa4\x45\x1c\xf2\x33\x7c\x88\xdf\x1b\xf0\xd1\x20\x2d\xb2\xe7\xec\xad\x83\x65\x47\x7a\xa4\x13\x43\x96\xdf\xcf\x48\x45\xc4\x8a\x85\x3a\x3a\x73\x28\x8c\x8e\xdf\x90\xd1\xf1\x27\x98\x34\xdc\x05\xec\x89\xe6\x04\x39\xe0\x6b\xe1\x84\xc0\xfd\x0a\xc6\x6c\x5d\x68\xc2\x56\x72\x92\xc0\xae\x52\x34\xbc\xc6\x7d\xc0\xbe\xc3\x18\x6d\x40\xb3\x75\x66\xd9\xd0\xec\x15\x0e\x74\xf9\x3e\x60\xdf\x61\xa0\x36\xa0\xd9\x3a\xb3\x22\x08\x82\xf5\xa3\x28\xe9\x15\x0e\x75\x65\xf5\x7e\xc0\xdf\x61\xb4\x69\x50\xb3\x75\x68\xf5\xe4\x64\x98\xf8\xc1\xc9\x87\x61\x4c\x3f\x81\xff\x97\xe2\x65\xba\x36\x5b\x13\x6b\xa2\x09\x10\xc2\xf8\x6e\x54\x4c\x41\xcd\x95\xca\xba\x65\xeb\xa5\xc3\x6c\x39\x8c\xf9\xdd\x90\x7c\xff\x6e\x18\x59\x62\xfc\x37\x2b\xda\x9e\x11\x30\x34\xfd\x92\x52\x84\xff\xc4\xd0\x76\x0c\x42\xb3\x5b\xcf\x1f\xfd\xe3\xf5\x4c\xd4\x3e\x2c\x76\xab\xc0\x7d\x58\x45\xc6\xee\xbb\x92\x11\xec\x44\xf4\x3e\xcc\x35\x02\xf8\x65\x83\xd9\x29\x2b\x2c\x90\xb3\x30\xa4\x58\xca\x4d\x93\xfe\xb2\x64\x4c\x9f\x32\x81\x13\xe1\xe7\x3f\x83\x1a\x11\x0b\x15\x2f\x20\x72\xd0\x82\xd1\x9e\x06\xa8\x56\x87\x52\x80\x16\x9d\x5c\xd3\x11\xca\xc8\x46\x41\x3a\x9f\x23\xf0\x1b\x65\xe6\x9b\x61\xcb\xa4\x86\x13\x90\x3a\x0f\x1b\xf9\x3c\xc7\xb6\x2e\x5e\x31\xab\xca\x08\x68\xaa\x5a\xbe\x19\xa4\x1c\xb9\x51\xf3\x9c\x8e\xcd\x6f\x8c\xc8\xa7\x82\x80\x2b\x8c\x1a\x71\x14\x00\x71\x49\xa4\x94\x8b\x5c\xdc\x92\xae\xd0\xa5\x8f\x7d\x91\x5d\xc9\x22\xdf\x00\x64\xc6\x7d\x33\xea\xac\x2b\x97\x49\x0a\xee\x24\x28\x76\x17\x54\x60\x47\xa3\xc4\x3a\x58\x68\x95\x6d\xdb\x3d\x79\x13\xb3\x5c\x25\x27\x09\xed\x0f\x96\xd7\x1f\x22\x24\x3e\x44\x48\x7c\x88\x90\xf8\x97\x45\x48\x14\x27\xbf\x7f\x75\xfc\x80\xee\x5f\xd0\xf8\xc2\x07\x6a\x75\x13\x27\xec\x06\x78\xe6\x11\xff\xf8\x22\xee\xd2\x44\xe4\xd1\x0f\x4e\xd2\x4b\x79\xb9\x37\xb3\xca\x97\x55\x32\xae\x92\x91\xef\x25\xbd\x2a\xe9\x51\xbf\xdb\x4b\xaa\x24\x76\x3c\x7f\x68\x5c\xc2\xf7\x9d\xcb\x4f\x90\x44\x36\xc8\xae\x93\xf4\x6a\x7d\x3f\x2c\xc3\x0f\xe7\x8c\x95\xa1\x72\x85\xd4\xc9\x72\x95\xa8\x44\x04\x05\xa9\xfa\x16\x93\x6f\xc0\x1b\xa2\x15\x08\xf3\x2a\x4e\x24\x4b\x4d\x75\x43\x1a\x44\xee\xf9\x17\x9f\xd1\xdc\x72\x0d\x59\x6c\x80\xa3\x32\x7c\xe7\xf3\xa9\xd1\xdd\x14\xd7\x57\x38\x0e\x93\xf1\xa0\xce\xd0\xb8\x1e\x0d\xe9\x48\x0d\xed\x48\x38\x2f\xb0\x77\xbc\x2a\x41\xc7\x0a\xab\xb8\xf5\x81\x53\x04\xdf\xf4\x88\xa0\x40\x60\x94\xd9\x58\xfd\xfe\xd9\x40\xdc\x0b\xe3\x77\x4b\x97\xb1\x2e\xe9\xc4\xa8\x4a\xbb\x25\xb2\x48\x2e\xc9\x22\x29\x55\xe1\x0a\x6d\x4c\x16\x11\x77\x0b\x46\x5b\x8d\x63\xcb\x59\xa1\x91\xce\x47\xaf\x7b\x07\x40\x17\x37\x48\xa9\x0d\x6f\x34\xac\x82\xb2\x85\x4c\x62\xa3\xda\xa8\xe2\x8b\x0e\x39\x1d\xaa\x33\x97\xa9\xf2\x15\x95\x35\xce\x0e\x86\xb7\xfb\x9e\xa8\x7a\x40\x29\x64\xc9\xa8\xdf\xb4\xeb\xe7\x8c\xa7\x39\xed\x78\x9a\x79\xe3\x69\x4e\x1a\xcf\xbf\x43\x22\xfe\xd9\x3d\xac\xdc\x80\xfa\xe6\x71\xc5\x74\x7f\x5c\x38\xd2\x14\x1c\x41\xcf\x4b\x59\x80\xcb\x05\x73\xb9\x3c\xed\xd8\x97\xf3\xc6\xbe\x3c\xcb\xd8\xad\xd9\x59\x3e\xce\x1d\xc2\x8d\xa3\xd7\x10\x56\x0a\x21\xe4\x0c\x77\x65\xda\xe1\xae\xe4\x0d\x77\x65\xfa\xe1\x5e\x4e\x3b\x31\x2b\x05\x33\xfd\x5b\x09\x6e\x8a\xf5\x95\x7d\x11\xeb\xe1\x3b\xf9\xa2\xf8\xad\x53\x8d\x51\x82\xcc\x65\x32\x21\xc5\x5f\x15\x48\xc5\x8f\xd7\x53\x6c\x22\x6f\x2c\x62\x08\x1a\x24\xe0\x5f\x0f\x9f\xff\x43\x74\x1a\xad\x4a\x08\xa9\xa4\x1b\xb8\x40\xaa\x0d\x5c\xc3\xd9\xd6\x72\xd6\xff\x94\x35\xef\xa9\x9f\x13\xd6\xf4\x44\x34\xdd\x72\x39\xff\x19\x28\x9f\x84\x40\x73\x79\x4d\x1c\xcc\xed\x2b\xdf\xbd\xf7\x37\xac\xb8\x54\x97\x88\xb5\xbe\xae\x26\x52\x3d\xd0\x0d\xe9\x41\x2a\xa2\x87\x7f\x5f\xc0\xb7\x68\x46\x17\x58\xd2\x25\x44\x13\x86\xa9\x07\x6f\x41\xdb\xed\x2b\xe1\x4a\xc9\xa1\x13\x74\x29\x79\x5a\x90\xa3\x79\x67\x9e\xd4\x17\x94\x3e\x77\xa1\x7e\x5c\x11\x8f\x9e\xc8\x06\x29\xe3\xb9\x8a\x6c\xc8\x93\x96\x1d\x41\xb0\x30\x76\xa0\xea\x56\x95\x9c\x14\x05\x0d\x54\x65\xca\xe9\xf8\x5b\x56\x30\x40\xda\x1f\x54\xd1\x45\x34\xdc\x00\xc9\x88\x05\xf9\x11\x05\x15\x4c\xc9\x85\x66\xf0\x3b\xa5\x9d\x4c\x35\xa6\x75\x32\x75\x93\x83\x29\x6d\xa5\x93\x28\xa4\xe2\x8f\x29\x43\x1d\x4a\x23\x18\x35\x3e\x43\x0a\xff\xfe\x5d\x4a\xf2\x5d\x5b\x92\xd7\xc8\xa8\x80\xce\x46\xf8\xa0\xc2\x6b\xb9\x23\x0e\x38\xe5\x7d\xaa\x22\x10\x2d\xff\xea\x88\x76\x62\xc0\x49\x94\x38\xc1\x7b\x40\x1c\x17\x87\xc5\xeb\x13\x9c\x24\x5e\xa9\x78\x18\xc6\x04\x56\x14\x45\x9b\xba\x1f\x93\x64\x8e\xb0\x3d\x69\xa6\x95\x0a\x1a\x57\xaa\x0a\x7f\xc5\xd9\xb7\xd1\xda\x26\xcb\xf3\xbd\x25\xf0\xd4\xb1\xc4\x68\xb2\x84\xe3\x00\xa3\x60\xf5\x58\x74\x8a\xa8\x74\x66\x88\x82\xc8\xa3\x2a\x78\x0f\x78\x8a\xea\xd2\xe4\x50\xa3\xc3\x74\x7d\x0d\xc1\x34\x74\x96\x0a\xc2\x94\xad\x55\xae\x18\x1e\xce\xa1\xad\x7c\x88\x99\x70\x40\x73\x26\xdf\xb3\x66\xc5\xf8\x30\x0a\x5d\x9b\x21\x1e\xe6\xcc\xbf\xf0\x0e\x48\x9a\xc6\x21\xc6\xd1\x41\xb6\x78\x77\x94\xc6\x56\xca\x7b\x76\x71\x90\xa0\x29\x7c\x5f\x13\x72\xa9\xdd\x5e\x5f\x9a\xe9\x63\x9d\x3e\x36\xd3\x91\x31\xaa\x3c\x3c\x10\x1a\xf9\x82\x95\xaa\x02\xe2\xa8\x68\x94\x90\x12\x8f\x2c\x81\xdf\x66\x09\xd3\xda\xf7\x24\x65\x53\x6d\xc6\xa9\xca\x99\x62\xf4\xa3\x69\x64\xac\x67\x50\xb1\x5c\x88\x0b\x15\x50\x65\xdb\x61\x18\x34\x49\xd4\xa8\xa5\x72\x72\x2b\x6d\xe9\x78\xe8\x99\x6a\x32\x2f\xb7\xe2\x4b\xda\xf5\x73\x6b\x41\x86\x59\xc5\x67\x6d\x99\xd7\x96\x16\xa7\xb2\x56\x26\xcf\xae\x88\x21\xf8\x26\x55\xcf\x2d\xb1\x3e\x67\x06\xf8\xba\x04\x8d\xcf\xe2\x25\xe7\x78\x63\xfc\x0d\x6f\x25\x91\x28\xe0\x1b\x7f\x7e\xff\x2e\x09\x01\x12\xc5\x6f\x55\x92\x4b\xbb\x0d\xa3\x10\x7c\x9b\xcb\x2d\xe3\xcc\x5d\x31\x72\x9c\xc9\xc0\x19\x4b\x15\xcf\xc6\xad\x6f\x7c\xca\x95\x72\x29\xa6\x6e\xcf\x89\x13\xb6\x14\x4b\xa6\x57\x32\x3d\x31\x58\x61\xcd\x1e\x15\xe0\x26\xa7\xc3\xb7\xb8\x44\xac\x39\x29\x03\x87\x12\x97\x2b\x4a\xda\x1a\x14\x6c\x50\x6f\x94\x28\xf2\x2e\x3d\x8e\xe6\xcf\x41\xa2\x80\xdd\x88\x32\x69\x00\xd1\x4e\x92\xd8\x3f\x1b\x26\x94\xa1\x8c\xa1\x17\x41\x65\xe6\x86\x28\x34\x84\xae\xed\xc1\x6d\xdf\xc4\x46\xae\xf2\x16\x79\xcb\x98\x4d\x93\x66\xbd\xd6\xad\x94\x50\x9a\xbb\x56\x2a\x19\x9a\xb9\x87\xe9\x51\xf0\x6f\x7f\xe9\x56\x73\xf4\xb8\x2c\x14\x38\xb8\xc4\xad\x3d\x83\x1f\xfa\x4c\x34\x74\xe2\xa8\xdf\x22\x57\x38\xea\x96\x3d\xf8\x96\x42\xc2\x65\x8b\x70\xe4\xb4\xc8\x58\x3e\x46\xc5\x7f\x49\x34\x7b\x5d\xe9\xc4\xb5\x95\xe5\x71\x13\xb8\x66\x2b\x9d\x90\x62\x60\xe2\x6d\x40\xc1\x9a\xd2\xb3\xa8\xab\x19\xe2\x6e\x4c\x3b\xcb\xf6\xb6\x0c\xca\xc0\x61\x1c\x7f\x91\xfb\x12\x2f\x92\xdd\x96\x00\xdd\xc3\x38\x7e\xa3\xb6\x27\x28\x97\xdd\x9d\x64\xc1\x5f\x55\x99\xcb\xbc\xec\xaf\x2a\x7b\xbc\x6e\xee\x6d\xf7\x48\x67\x77\xa7\xb5\x34\xbd\x4d\x4d\x73\x9a\xee\x4a\x8d\xc1\x25\x9e\x08\xad\xcd\x16\x9c\x96\x08\x65\xab\x25\x31\x2d\x92\xd2\x40\xbf\xc5\x96\xff\x38\x15\x9a\xf5\xa1\x14\x69\xe4\x94\x74\x24\xfb\x40\xce\x50\x62\x49\x1c\x9d\xd3\x2d\x87\xf5\xc0\xc6\x3f\x53\xfe\x0c\xc7\x52\xbc\x65\x92\xe9\x09\x99\xa4\x08\x74\xc2\x7e\xca\xff\xd1\x7c\x72\xb7\x4a\x5d\x57\xa7\x9c\xce\xbf\xe1\xf6\x60\x46\xd7\xfb\x81\x1b\x44\xaa\x99\x0c\xbd\xde\xb4\x4d\x90\xfc\xad\x02\xd6\x70\x15\xd7\x6a\x55\x73\x88\xaa\xc1\x05\xd4\xd6\x91\x06\x17\xd3\x8e\x25\x6f\x77\x52\x31\x7e\x8c\x09\xc5\xce\x8b\x80\xa9\xfc\xcf\x7a\xaa\xcc\xb5\x4d\x0f\x95\x8a\xf1\x9d\x73\x24\x30\x43\xea\x1c\x5b\x0f\x4c\xd4\xe9\x0c\xa2\x6f\xdc\x4c\x48\x47\xf3\xea\xd8\x3f\x7f\x5c\x51\x17\xb5\x35\xe1\x36\x41\xda\x3b\x7e\x32\xe4\x1f\x59\xc4\x7c\x24\x62\x91\xdb\x6d\x27\xdf\x85\xc9\xff\xf0\x69\xfb\x60\x7b\xef\xb0\x7d\xb8\xb3\xbf\x77\xd2\x3e\x3c\xfc\xb4\xf3\xf2\xf3\xe1\xf6\x01\x9f\xfe\xdb\x83\x44\x5d\xc9\xf6\x2f\xdb\x7b\x87\x19\x58\x57\xe9\xa7\xd5\xb7\x33\x79\xaa\x39\xea\xd9\x35\xe1\x9b\xe2\x0c\xf5\xa5\x07\x03\xc2\xb7\xd3\x3b\xd5\x17\x5b\xf6\x9d\x60\xc8\x8d\xfe\x4e\x40\x70\x8d\xcc\x04\xc4\x30\x3e\x9f\xbd\x0b\xb3\x34\x0c\x7b\xc5\x31\xac\xeb\x0c\x1b\x9f\x69\x24\xf8\x26\xba\xf0\x1c\x75\x27\x98\xf6\xde\x75\xc7\xd9\xca\x6c\x70\xf7\x05\x4f\x0a\x77\xb3\x92\x41\xf9\xa8\x44\x1d\x06\x4f\x81\xf9\xdf\x25\x3f\x54\x3f\xa3\x61\x62\x24\xcb\x4f\x7c\xbd\x0e\xef\xbf\x4d\xee\x95\xb5\x36\xbf\x14\x46\xe6\x63\xf1\x57\xac\x9c\x86\xb9\x02\xe0\x03\x62\x27\x52\xa9\x7f\x88\x3a\xe4\x2c\x8a\x3d\xf0\xbd\x9c\xc9\xe9\x44\xc3\x98\xb8\x51\x1c\xd2\x98\x61\x30\x0b\x79\x45\xcc\x88\x23\x7c\xf0\xe7\xd5\x0b\x68\x27\x59\x4a\xa2\x41\x15\xa3\xb1\x9a\x3f\xcf\xa2\x24\x89\xfa\x55\x2c\x82\x1f\x19\xc8\x21\x01\xca\x35\x56\x5d\xa3\x80\x86\x95\x81\x7b\x21\x45\x6a\xc7\xb8\x29\xfa\x6a\x14\xd0\x49\x53\xc4\x28\xc8\x4c\x39\x4e\xdc\x9c\x54\x33\x2e\x57\x2a\xe0\xef\x07\x66\x04\x3c\xa1\xce\x68\x92\x6c\xa9\x8a\x6d\xa3\xe2\x95\xbf\x93\x51\x71\x10\x79\x0e\xeb\x9d\xf8\x0c\x34\xd4\xc5\x36\x85\xcf\x66\x35\x2f\x4e\x37\x70\x27\x3b\xe3\x34\xb0\x59\x8d\x82\x15\x1c\xe9\x4f\xba\x78\xe0\x4f\xee\xb1\x8d\x3b\xd9\x1f\xe7\xc0\x9b\xd5\x54\xf8\x87\x58\x92\x2f\xdf\x83\x25\xf9\xf2\xdd\x2c\xc9\x57\x7e\xa0\x25\xf9\xca\x7d\x59\x92\xaf\xdc\x83\x25\xf9\xea\x89\xb7\x72\x02\x8f\xb4\x8a\x67\xf1\xf9\xf3\x59\x2d\x8d\x7f\x9c\x95\xfa\xda\x7d\x59\xa9\xaf\xdd\x83\x95\xfa\x93\x1f\x6f\xb5\xfd\xf4\x96\x56\xdb\x33\x34\xf1\x4c\x34\xb1\xe5\x24\xce\x0d\x2d\x80\xbf\xd1\xb9\x07\xd3\xf0\x07\xd3\xf0\x07\xd3\xf0\xfb\x35\x0d\x7f\xb0\x0c\x7f\xb0\x0c\x7f\xb0\x0c\xff\x9b\x59\x86\x6f\x0e\xe3\x0b\xcb\x2a\x1c\x57\xf0\xe6\xe7\x4f\xbf\x6c\x9f\xbc\x6a\x6f\x1e\xee\x7f\xda\xd9\x3e\x10\x07\x6d\x97\x17\x7e\xe9\x30\x9f\x6d\x06\x11\xa3\xde\x24\x65\x80\x29\x7d\x49\x3d\x60\xba\x3e\x2a\xed\x74\xea\xfe\x80\x4e\x54\x57\xd8\x30\xbd\x14\x4c\x5e\x3b\x0d\x71\x7a\x68\x67\x29\x68\x06\x24\x7c\x53\x7e\xdb\x21\x77\x34\x40\x13\x40\x06\xee\xf4\x10\x69\x1a\x22\xc0\x92\xf3\xb2\x1b\x85\x51\x12\x85\xf4\xd7\xe9\x01\x76\x35\x40\x55\xdb\xe8\x9f\x4c\xfb\x3a\x3d\xc4\x5e\x16\xe2\x57\x03\xe2\x9e\x93\x0c\x63\x27\x98\x1e\x9e\xaf\xe1\x89\xba\x06\x34\xe9\x84\x68\x3a\x50\xdf\x34\x28\x70\x91\x65\xc3\x81\xf8\xb3\xd3\x03\x3b\xb7\x81\x61\xf4\x5a\x73\x36\x78\xea\x4b\x88\x76\x35\x3d\xd0\xc0\x06\x8a\xd5\x39\x54\x65\x6a\x28\x3c\xe8\x9b\x92\x98\x48\x2a\x0f\xac\x27\xdd\x83\xda\x25\x5a\x14\xf3\x1f\x8f\x1f\x93\x41\x6d\x2c\xbf\xc7\x60\xb9\x28\x1e\x7f\xfc\x9a\x7a\xf1\xf1\x6b\x16\x8e\x59\xfc\x6b\xaa\xf8\xd7\x4c\xf1\xb1\xb6\x8b\xec\xd2\x04\xb8\xcb\x2b\x87\x33\xd2\x71\xaa\xaa\x99\x55\x46\xc6\x8b\xce\x24\x11\x20\x67\x93\x33\x2a\x0e\xca\x15\x80\x57\x49\xc5\xc4\xe0\x69\xca\xec\x0d\x1e\x74\x88\x0b\x10\x40\x78\x49\xec\x2a\x35\x16\xf8\x2e\x2d\x37\xaa\xa4\x59\xa9\x25\xd1\xe7\x01\x67\xa1\x0e\xa3\xe5\x8a\x5d\xa0\x59\x51\x8f\x49\x10\xce\x86\x84\x24\xe9\xbe\xc4\xf1\x6e\x0e\x49\xf5\x24\xc5\x5c\x8f\x4a\x60\x9e\x8e\xf1\x31\xa4\x47\x4d\x80\xa7\x7c\x6f\x90\x17\xa4\xf4\xb5\x44\x5a\xa4\xf4\x6b\x49\xf8\x1e\x9b\x2b\x04\xc7\x21\x1d\xa3\x43\xee\x3b\xf0\x15\x3d\x8f\x30\x53\xd3\xd8\xb6\xe6\x9d\x15\xa7\xb1\x6d\xbd\xb5\x69\x2b\xf4\x68\x82\x59\x2b\xe4\x2b\xfb\xb8\x7c\x33\x55\x28\x23\xcd\x7c\xe4\xad\xfd\x8d\x36\xa0\x50\x6b\x1a\xc3\x4f\x04\x5f\x11\xf6\x9e\x58\x5b\x9d\xf2\x2a\x05\xf6\x97\x62\x5c\x96\xed\x25\x87\x0b\xf7\xbe\xd2\xe0\x72\x01\x2f\x0a\x21\x56\x9c\x3b\x0c\x9c\x84\x8a\x18\xde\x09\x84\xd5\x74\x71\x43\xc7\x22\xff\x92\xde\xd3\x31\xdc\xd5\x35\x94\x12\x99\xf9\x96\x98\xa2\xb9\xb4\x71\xe1\x64\x13\x42\x21\x6a\x09\x4b\x3d\x58\xcc\x46\xee\x20\xf2\xc3\xc4\x30\xf7\xc3\x6f\xb3\xc4\x99\xc3\x80\xf2\x74\x19\x99\x62\x96\x92\x2b\x43\x96\xc1\x6f\xcb\x6c\x10\x9d\xc3\xec\x0d\x83\xc0\x68\xcf\x4c\xb5\x0c\x23\x5d\x9b\x3b\x4d\x64\x4a\xa6\x15\x61\x27\x8a\xfb\x4e\xf2\x41\x0e\xcb\x6a\xf5\x85\x18\x6e\x0d\x2f\xbc\x0d\xaf\x9b\x34\x4c\xe2\x71\x8e\xc5\x98\x64\xe0\x98\xaf\x0c\x97\xb8\x54\x87\xa0\xcc\xa6\x03\x3f\xa4\x92\xe3\xd9\xcf\xda\x08\xb9\x89\x69\x16\xab\x99\xcb\x95\xb2\x44\x78\x25\x6d\x45\xeb\xc4\xd4\x51\x43\x35\x47\x9e\x72\x2a\x0a\xdd\xaf\xa6\xdd\x4e\x9a\x8b\xcb\xbc\x47\x16\xa5\xaf\x60\xea\x5b\x8a\x00\x8e\xa0\xfa\xb1\x6d\x2b\x6b\xfc\xe6\x03\xcc\x65\x90\x76\x8b\x29\x2c\x4d\x61\x94\x6f\xb2\x43\x64\x58\x7c\xdc\xc8\xad\x2a\xb5\x71\x99\xef\x75\x95\xda\x65\x93\xff\xf8\xb5\x52\xbb\x6c\x18\x23\xf7\xd2\x76\x01\x72\x62\x81\x8a\xf9\x06\xaa\xb3\xac\x81\x99\x8f\x16\x7e\x4c\xc7\x2f\x45\x7f\xc7\x4d\x31\x82\xf1\x2d\x3a\x3e\x2e\xec\xf8\x5c\x5e\x7f\x6b\x92\x90\xc5\xdf\x4a\x0d\xd6\x57\xd9\x5c\x65\xa6\xad\xb5\x68\xcc\x04\x51\xd6\xc4\xa6\x17\x82\x7e\x3a\x95\xbf\x35\x3e\x7e\x7c\x33\x9e\x72\xf4\x7f\x52\x40\xf7\xd9\x1e\x06\xd4\x06\x94\xe5\x2e\x83\x3f\x83\x9c\x54\xc3\x39\xe3\xfe\x1f\x36\xbc\x3c\xa2\x2b\x1a\xde\x7d\xf5\xa2\x0f\xbd\x00\x9f\xb0\xe9\x5e\x60\x27\x32\x06\xa1\xb3\x93\x6e\x1e\xe1\x9a\x8c\xd1\xb4\xe0\xb9\xb3\x55\xff\x0d\x06\xeb\x59\x43\xf9\xe5\xac\xf7\x71\x92\xdd\x84\x97\x73\x76\x61\xf1\x6e\x4a\x15\x70\x6c\x03\x4a\xfe\xfd\x09\x5e\xc0\x98\x25\x3e\xc1\x53\x21\x63\xff\x29\x3f\x12\x4d\x7d\xff\x4e\xc4\x4f\xa1\xe3\x85\xb8\x6b\x8f\x78\xa5\xdb\x18\x7a\xc7\xd4\x09\xc4\xd3\x74\x01\x98\x1f\x67\x4c\xb8\xe4\x05\x22\x47\x8b\x2e\x2d\xf1\x42\x6b\x5a\xdb\xdf\xcc\xad\xdc\x3d\xd9\xde\xe5\xdd\x6c\xfc\x10\xd3\xec\xfc\x86\x66\x35\xcd\x9e\xca\x82\x2a\xff\x96\xca\xb2\xac\xc7\x83\x95\x69\x55\xaf\xe9\xc9\x6b\xa9\x99\xad\x1a\xb4\xd0\x69\x49\x3a\x53\x72\x50\xb1\x41\x1c\x48\x6b\x93\x8d\xe1\x96\x6f\x69\x0c\xb7\x29\xba\x7c\x07\x43\xb8\xfc\xb9\x98\xc2\x10\x6e\x6a\xe3\xb5\xfc\x5b\x56\xcb\x78\x8d\xe7\xcd\x04\x62\x2a\x8b\xad\xc9\xb5\xcb\x47\xa5\x33\x87\xf9\x10\x01\xe0\x4c\x2b\xfb\xd4\xe7\xfe\x00\x83\x00\x04\xca\xe9\x7f\x60\xe8\xc7\x20\x22\x00\xaa\x7a\xf8\xcf\xbe\xd4\x4b\x99\x1f\x5f\xcd\x0f\xfe\x9b\x89\x78\x04\x4c\xa9\x4d\xe4\x17\x68\x66\x4a\x30\xe3\xb7\x1f\x0e\xe7\xcd\x68\x44\x86\xa2\xc7\xec\x18\x9d\xe4\x56\x93\xc3\x97\xfb\xe3\x5f\x30\x67\x37\x5b\xd9\x15\x56\x35\xac\xec\x90\x23\xcf\xd4\x7d\x80\xb2\xdf\x99\xda\x1a\xc0\x1c\xb9\x70\xbf\x3b\x67\x9f\xfd\x66\xea\x86\xb4\xc6\xe3\xfc\xe7\x8e\xab\x4f\xb0\xb0\x99\xa0\x60\xf0\xf5\xc9\x06\x6f\xb8\xba\xd5\x02\x32\xd0\x7f\x74\x9c\xc5\x05\x46\x53\x56\x6f\x44\xef\xc9\x76\x4b\xe9\x4f\x6c\xbb\xad\xd5\xbf\x93\xdd\xd6\x83\x33\xc8\xff\xf1\xce\x20\x7f\xb8\xf5\xc9\xca\x2c\x3e\x03\x1f\xac\x22\x1e\xac\x22\x1e\xac\x22\x1e\xac\x22\x1e\xac\x22\xfe\x33\xad\x22\x7e\x25\xed\x4b\x9f\x69\xb3\x08\xbe\x7c\x7f\xe5\x49\xd3\x68\xa6\xf2\x36\xad\x1f\x72\x0d\x06\x3d\x9a\x70\x0d\x06\xf9\x37\x5c\x83\x41\x99\x5b\x5f\x83\x41\xad\x69\xae\xc1\x10\xfc\x2d\xaf\xc1\xc4\xb8\x8e\x66\x57\x9d\x65\x94\x4a\x39\xda\x03\x68\xe5\x7e\x9f\xd2\x01\xc8\x02\xed\x01\x84\x45\x08\x82\x68\xb4\x45\x5d\xbf\xef\x4c\x3e\xa4\xdc\xf8\x64\xa8\xe7\x7b\x77\x7b\x73\x24\x1e\xae\xc0\xad\x73\xd4\x21\x9e\x93\x38\x32\x9e\x32\x84\xee\xc5\xc8\xbe\xb0\x08\xa0\xd0\x5f\xf0\xfc\x4b\x9c\xa7\x66\x7f\xbe\x84\x27\x53\x31\x52\x08\xff\x7c\xd3\x48\x79\xa1\xff\x84\x91\xfe\x3e\xa4\xc4\xf7\xf8\x70\x2f\x97\xc4\xd0\x2e\x39\x6d\xee\x4c\xb4\x5f\xfa\x7b\x8f\xce\x8b\xfa\xce\x8c\xaf\xe3\x6e\xd6\x30\xfc\x5d\x87\x3e\x53\x55\xce\x17\x67\xaa\x28\x55\x55\xce\x30\x89\x4a\x55\x52\xe2\x6b\x65\x17\xdf\xe9\xc1\x4f\xe7\xb2\x74\x0c\x41\x6c\x34\xb1\x9d\xd3\xf1\x8d\xab\x8a\x67\xbe\xa3\xb3\xbd\x87\xfd\x9f\x8a\x7f\x6b\x45\xa2\xcf\x9b\xa8\x03\x08\x21\xa3\x9e\xef\xf6\x88\xcf\xc8\x90\x0d\x9d\x20\x18\x73\x11\x14\x0d\x39\x38\xe2\x20\x4e\x4e\x10\x8c\xef\xe9\x05\xb0\xe8\x81\x70\xb3\x23\xba\x50\x15\x7d\x08\x29\x46\xb9\x3e\xa3\x84\xd1\x84\xb7\x7f\x36\x26\x43\x06\x2f\x1b\xef\xe5\xe9\x70\xdf\xe7\x52\xed\x7d\x6c\x54\x66\xb4\x54\x31\x8a\x6c\x60\xb9\x99\x09\x3e\x89\x40\x7d\x8c\x8f\x32\x85\x4a\xf6\x26\x15\xfa\x8d\x40\x11\x0d\x10\xee\x56\x44\xc8\x29\x69\xaa\xf0\xdd\x73\x46\x5c\x27\xe4\xb8\x77\xc2\x31\x9a\xd0\x8c\x64\xd4\x7a\xa0\x13\x1f\x63\xf5\x40\x0e\x9c\x5f\x10\x88\x09\x00\x0e\x07\x70\x2a\xe0\x4d\xb1\xc9\x00\xd4\xa3\xd5\x84\xd7\x9d\x9d\x91\x1a\xb3\xe2\x46\xc3\x10\xa8\x0a\x40\x0a\xd0\x9b\x3c\xf1\x7e\xc8\x16\xaf\x55\x13\x1a\x6b\x59\x4f\x34\x26\xda\x7a\x25\x0b\xcc\xd4\x1e\x30\x4a\xd0\xd7\x7a\xde\xac\x6f\x9b\x31\x0a\x18\x0a\x9e\x01\xed\xdc\x75\xe0\x04\x1f\x0b\xdf\x01\x0a\x04\x26\xad\x2a\x69\xd3\x49\x1c\x7e\xac\xe9\x04\xd1\xe8\x4e\xeb\x90\xb9\x4e\xf0\x57\x48\x81\xb8\x9a\x6e\xa7\xbf\x93\xb6\xe1\x07\x9b\xed\xf7\xdb\x27\x87\x5f\x3f\xe0\x15\xdb\xc4\x4b\xa0\x29\xb8\x39\x27\xb8\xbf\x00\x03\x30\x03\x7f\xae\x1c\x00\x67\xb9\x99\xaa\x52\xbc\x30\x47\x84\x71\x2e\x74\xd3\xad\xd6\xdf\x0d\x69\x38\x76\x3d\xe1\xff\x93\xfb\xdf\xf7\x43\xbe\x4f\xbc\x76\x26\x9a\xc9\x4f\xc1\x95\x38\x22\x0e\xfc\x3f\x66\x43\x84\x06\x03\xd2\xcd\xc5\x64\xfb\xff\xbf\x9f\x2f\x11\xb9\x9f\x0f\x62\xca\x28\xd8\xe6\x3b\x31\x38\xa8\x90\x09\xdb\xa1\x67\x7e\x42\x3e\x4f\xe3\xb2\x32\x38\x50\xa1\x17\x34\xbe\xe1\xed\xc8\x44\x42\x80\xcb\xbb\xe2\xeb\xc0\x94\x5a\x01\x54\x6d\x4a\x47\x50\x10\x08\x51\x88\x3a\x45\xee\x32\x56\x1a\xa6\xf8\xa6\x60\xa8\x43\x64\xa3\x6a\x6f\xf6\x6b\x5a\x62\xd2\xd2\x8e\x79\x6a\x3b\x6a\x54\x09\x9e\x2b\x8e\xad\x1d\xf7\x4a\x6c\x9a\x8d\xaa\xdc\xf8\x1a\xe8\x33\x2b\x67\xf7\x52\xdd\x10\x7b\x91\x38\xa7\x58\x18\xfe\x31\x97\x9d\x4a\x4b\x66\x5f\x76\xae\x3d\x5c\x76\x3e\x5c\x76\xfe\x65\x97\x9d\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\x0f\x37\x91\xff\xc1\x37\x91\x5f\xed\x9b\x48\xbe\x7a\xbf\xfe\xed\x2e\x22\xbf\xde\x70\x11\xf9\x75\x8a\x8b\xc8\xaf\x33\x5d\x44\x7e\x9d\xf6\x22\xf2\xeb\x2c\x17\x91\x5f\xff\x94\x8b\xc8\xaf\xf7\x7f\x11\xf9\xf5\xe1\x22\xf2\xef\x74\x8b\xf0\x70\x11\xd9\x21\x63\x79\x11\x39\x7e\xb8\x88\x7c\xb8\x88\x7c\xb8\x88\xfc\xf3\x2f\x22\x1f\xae\x9c\xfe\x46\x57\x4e\x79\x37\xc3\xd3\x5c\xcb\xfe\xb0\x3b\xe1\x1b\xae\xa5\xc9\x66\xcf\x89\x93\xff\xd3\xee\x85\x03\xda\x01\x4d\x2f\xa8\x26\x7f\xf8\xbd\xf0\x7d\x5d\x43\x26\xd1\x5d\xf5\xfd\x84\xa0\x7e\xf8\xe1\x1a\xb2\x68\x47\xd2\x8f\xd7\x06\xd1\x08\x1e\x9b\xfd\x8e\x97\x02\x41\xd4\xe5\x7f\x7c\x8f\x86\x89\x9f\x8c\xf9\xef\xc4\xef\x53\x7c\xfd\x26\x2e\x0a\x22\x3f\x84\xb2\x51\xec\xf9\x21\xbe\x07\xfb\x7d\xe8\x84\x89\x0f\x4e\xf8\xc5\xef\x3f\xe0\xf7\x30\x71\x0f\x45\x75\x46\x7f\x1f\x72\xa0\x58\x21\xe9\xc5\x94\xf5\xa2\xc0\xbb\xe1\x71\xdb\xc3\xbd\xe6\xc3\xbd\xe6\xc3\xbd\xe6\xc3\xbd\xe6\xff\x21\xf7\x9a\xb8\x63\x6b\x41\xe9\x49\x36\x0a\x40\xe6\x56\x73\x3c\xcd\xad\xa6\xdc\xb5\xa7\xba\xd3\x84\x1d\xb8\x51\x55\xbb\xe8\xdf\xf1\x4e\xf3\x6b\xfe\x9d\xe6\x93\x49\x77\x9a\x02\xca\xf4\xf7\x98\x73\xb8\x6c\x97\xd0\x71\xf2\x5c\xd9\xad\x90\x03\x3f\xf4\x62\x4a\x0e\xa2\xb8\x37\x64\x73\xff\x0a\x7c\x97\x86\x8c\x92\xdd\x9d\xc3\x39\x50\x72\x66\x43\x8a\x86\xd1\xd2\x30\x1c\x32\xea\x2d\x5d\x38\x31\xe3\xfd\x13\xee\xe5\x0c\xb7\xc7\x07\xe3\xfe\x59\x14\x18\xae\x9a\x73\xb3\xf1\xd2\xcc\x76\x98\xac\xab\x14\xb9\x54\xc6\x5a\x9c\x8e\x77\xd8\xb6\x79\xb3\x95\xa9\x37\x10\x35\xcc\x72\xe6\xb5\x4a\x12\x09\xa5\xed\x85\x13\x70\x7c\xfd\xc3\xef\x10\xfe\x1b\x6e\x03\x40\xa1\xfe\xfd\x3b\x91\xdf\xc3\x50\xba\x23\xe1\x25\xff\x91\xa7\xa4\x2f\xd9\x7e\xa9\x5d\xbc\x4d\x39\xa3\xe2\x86\x82\x8c\xfc\xa4\xa7\x14\xf5\x0a\x5e\xa9\xb2\x3e\xf7\x8f\xeb\xb9\xb9\x7f\x08\x05\xa4\xd1\xa7\xf5\x39\xf3\xe2\x81\xf5\xa2\x61\xe0\x7d\x66\x74\xcf\x49\x7c\xe1\x51\xed\x1f\x49\x3c\x86\xfe\xc0\xf5\x8a\xd5\x3e\xf6\x53\x42\xc5\xdb\xbd\xb9\x7f\x40\x4b\xff\xa8\xd7\xc9\x16\x4d\xa8\x9b\x90\xb3\x61\xb7\x3b\x26\x12\x53\x52\x57\x8f\x02\x7c\xec\xd1\x98\x1f\x36\xa2\x80\xff\xf8\xe5\x19\xe1\x4b\xc0\x8f\x42\x56\x13\x30\x7a\x49\x32\x60\xad\x7a\xfd\x6c\xd8\x65\x35\xb7\x17\x47\x7d\x7f\xd8\xaf\x45\x71\xb7\x3e\xa8\x5f\x3c\xab\xfb\x8c\x0d\x29\xab\x7b\x34\x71\xfc\xe0\x85\xef\x6d\xac\x36\x9b\xcf\xe6\xfe\xf1\x0f\x88\x15\x4a\x59\xd2\x24\x1b\x80\x41\x74\x87\x56\x2e\x39\x67\x6e\xa9\xb2\x0e\x87\x09\x9b\xe6\x96\xc0\x95\x4c\x18\x2d\x85\x74\xb4\x34\x8a\x9d\xc1\x80\xc6\x8c\x4f\x02\x07\x72\xb4\xc6\x17\x50\xc9\xa3\xa5\x75\x81\x87\x5c\x9a\xdb\x73\xfa\x94\x95\xa1\x46\xe5\xa8\x71\x8c\x7e\x8b\xd6\x4a\x37\x60\xe9\xb6\x23\x5c\x69\xac\x3d\x31\x46\xb8\xcc\x79\xe7\x35\x07\x98\x77\xa5\xdb\x6c\xc8\x8b\x5c\xde\x05\x28\x7f\x54\x3a\x29\x91\x45\x81\x91\x5a\x27\x8e\xfa\xfc\xa4\xb7\x19\x79\xb4\xec\x57\xf8\x38\x7d\xec\x1d\x36\x01\x33\xb4\x5c\xb4\xca\xf4\x88\x97\x2b\x29\xf7\x60\x29\xe2\xc0\xa6\xc3\x63\x80\x5d\x91\x68\x44\xe8\xb5\x6f\x91\x1f\x96\x4b\xa5\x0a\xdc\x51\x95\x1a\xcd\xe5\x95\xd5\xb5\x27\x4f\x9f\x3d\xff\xc1\xa8\x5b\x51\xa8\xe3\x74\xe1\xd1\x4e\xb7\xe7\x7f\x3b\x0f\xfa\x61\x34\xf8\x3d\x66\x49\xa9\xc6\x06\x81\x9f\xf0\x8e\xd5\x3a\x51\xbc\xed\xb8\x3d\x63\x7c\x01\x3f\xa8\xc7\x06\x62\x57\x8e\x30\x89\xa3\x10\x7f\xd9\x63\x15\x08\x3c\xa7\x63\x56\xb6\x56\x11\xb8\x17\x01\x08\x95\x8a\x85\x0a\x0e\xb9\xa0\x6b\x93\x10\x23\x31\x1e\x0f\x79\xda\x35\x71\x9d\xc4\xed\x91\x32\x8d\x45\x6f\xeb\x75\xf2\x85\x12\x2f\x0a\x4b\xb0\x73\xf0\x25\xea\x84\xa0\x4b\x03\xad\xce\x59\x74\x41\x49\x12\xe1\x1d\x61\x95\x9c\x0d\x39\x7f\x01\xfd\x88\xd0\x50\x38\x1d\x5a\x9b\xcb\xb4\x7d\xcd\x19\x09\x6e\x1b\x35\xb1\x6b\x90\x8d\x1c\x86\xf2\x22\xe5\x5a\xbf\x95\xf1\xac\x5f\xd5\xfe\xef\xe7\x60\xae\x38\x8d\xae\xe3\xcf\x24\x22\x1b\x9a\xa9\x0a\x4f\xfc\x22\x8f\x49\x96\x3f\xa7\x97\x02\x43\xc7\xfc\x2c\xd7\x31\x3f\x93\x0b\x83\x37\xa0\xef\xd7\xb4\x6f\x7e\x06\xf7\x36\xc6\xca\x12\xfe\xf9\x79\x79\x31\x03\x7c\x66\xf3\xfc\xf1\xf3\x22\xca\x1b\x3f\x4c\x64\x12\x49\x6f\xfc\x3c\x0f\x7d\xf1\xf3\x8c\x6b\x39\x6f\x1c\x54\xee\x26\x26\x20\x30\xb5\xe3\xe5\x96\x82\x26\x81\xda\x72\x39\x81\xa8\x9d\x32\xef\x80\x9e\x09\x03\x06\x6b\xb3\x33\x47\x21\xaa\x1e\xf9\xc7\x6a\x30\x7c\x34\x3a\x59\x0d\xca\x48\x82\x8e\xc0\xe0\xc4\x08\xcd\x0d\x28\x89\xd0\xdb\x68\x4a\x14\x79\x7a\xaf\xa2\x08\x11\x22\x2a\xf9\xa5\xfd\x89\xec\xec\xbd\xdd\xde\x3c\xdc\xd9\xdf\x23\x0b\x75\x0d\x7b\x10\x47\x2e\x85\x1b\x75\x71\x17\xbb\x19\x0d\xc6\xa0\xfb\x21\x5c\x72\x59\x6e\x34\x57\x96\x06\xe8\xb4\xa9\x4a\x5e\x39\x2e\x3d\x8b\xa2\xf3\x2a\xd9\x09\xdd\xda\x1c\x81\x0a\x87\x3d\x9f\xc9\xb0\x0e\x6e\xe4\x51\xe2\x33\x22\x24\x1c\x0f\x36\xe0\x18\x56\xd5\xee\xce\xa1\x4c\x26\x9d\x68\x18\x4a\x45\x35\x07\xf1\x7e\x67\x73\x7b\xef\x60\x9b\x74\xfc\x80\x4a\xfd\x75\x1c\x45\x09\xf1\xfc\x98\xa2\xaf\x4a\x58\x9b\xba\xa1\x24\xa6\x54\x74\x00\x6e\x89\x45\xe7\x3f\x33\x5e\xff\xc2\x89\x7d\x07\x02\xaa\x27\x11\x71\x18\xa3\x71\x42\x30\x16\x3b\x2a\xfc\xc6\xd1\x10\x64\x9b\x6e\xec\xf4\x79\xfe\xb0\x4f\x99\x58\xda\x9c\x65\xc8\x81\x7d\x88\xa3\x0b\xdf\xa3\x84\x0d\x62\x3f\x4c\x3a\x4b\x2c\x19\x07\x52\x59\x4a\xca\x51\x18\x8c\xc9\x7f\x81\xfa\x97\x0d\x07\x7c\x62\xb8\xd4\xe2\x84\x9e\x5e\x66\x1c\x48\x12\xf1\x96\x00\x8e\x1f\x62\x5d\xbe\xd0\x9d\xb3\x68\x98\x90\x51\xcf\x49\xc8\x59\x1c\x9d\x53\xa8\x08\x9f\xe3\x68\x48\x46\x34\x06\xbc\x20\x6f\xe2\x9b\x94\xc2\xb5\x31\x3e\xd2\xa7\x8c\x39\x5d\x4a\x46\x7e\x10\x00\x5f\x4a\x62\x7f\x30\x40\xdd\xe5\x20\x8e\xbc\xa1\x30\x51\xe0\x0c\x2c\x31\x6b\x72\x50\x50\x29\xa6\x5c\xac\xe7\x9d\xa4\x21\x1b\xc6\x94\x04\x51\xd7\x77\x89\x17\x51\x06\x86\x0d\x9e\xdf\xe9\xa0\x78\xa2\xe1\xd5\x10\xe7\x7c\x71\x5d\x38\x81\xef\x39\x09\x45\xfd\xb0\x79\x73\x6e\xe7\x08\x5f\x71\x15\xd8\x6b\xe6\xc4\x62\xe3\x64\x57\xa3\xe1\x45\x6d\x6f\x7f\x6b\xfb\x64\x7b\xef\x17\xdc\xfb\x74\x43\xc2\xc3\xe5\xed\x1b\x99\x93\x8e\xd9\xc4\x5c\x65\x24\x4b\xbc\xa8\xd6\xd2\xa5\x90\x2c\x35\x66\xc5\xb2\x82\xe8\x64\x94\x67\x2a\x5c\xcb\xc9\x2d\x99\x3e\xba\x6c\x11\x52\x13\xa0\x1b\x85\x9e\x8f\x73\x80\x5d\xa9\x12\xa7\x4a\xce\xaa\xc4\xad\x12\xaf\x4a\x68\x95\x74\xf2\xc6\x28\x47\xa2\xdc\x2d\x3f\x52\x80\x64\xef\x39\xf6\xa1\x63\xeb\x53\x0e\x16\x47\xb1\x61\x0e\x77\xd7\x0f\xfd\x8e\x4f\x3d\x42\x2f\x5d\x3a\x40\x69\xd4\x75\x87\x71\x4c\xbd\x75\xc2\x39\x09\xa7\x99\x30\x0a\x97\xfa\xb2\xa0\x47\x2f\x08\x0d\x2f\xfc\x38\x0a\x39\x0e\x20\x46\x6e\x89\xb3\x5a\x5e\xb2\xc3\x65\xee\x14\xb2\xf8\x6a\xf0\xb0\xe7\x4e\x40\x7a\x34\x18\x74\x86\x01\x19\x39\x71\xe8\x87\x5d\x56\x53\x48\xb4\x3d\x23\xa2\x0f\xd6\x2e\xe7\xf3\x47\x69\x7c\x1d\xaf\xdb\x85\x76\x42\x8f\x5e\x02\x8f\x2f\x1c\x28\x22\xa6\x16\xd3\x41\xe0\xb8\xb4\x5c\xff\x2f\x56\xef\x56\x6d\xbb\xc1\xb4\x6b\x3e\xde\xfa\x91\x84\xbe\xb8\x78\xbc\x9e\x76\xcd\x26\xda\xa9\x49\x87\xda\x3b\x8a\x74\x7e\xf1\xa3\x00\xd6\x78\x49\x12\xc8\x9c\x2e\xde\x89\xb9\xb8\x78\x18\x7d\x88\x06\xb8\x2d\xd7\xeb\x64\x24\x25\x11\xd7\x89\xa9\x60\x0c\x8a\x84\x4a\x8c\x44\x23\xbe\xdd\x3a\x7d\xf4\x70\x8c\x44\xab\xa6\x3e\x5f\xe6\x50\xd5\x27\x6e\x02\xd7\xb8\xc3\x4d\xda\x55\xca\x2b\x95\x4a\x25\xbd\x47\x3d\x9b\x62\x8f\x82\xed\x28\xd3\x2f\x8d\xf3\x33\x3f\xe9\x3b\x83\x2a\x5a\x93\x58\xfe\xd4\x71\x2e\x4c\x73\xa6\x47\xa2\x34\x79\x4c\x9a\xc2\x9d\x9e\x6d\xca\x64\x14\x58\x16\x05\xb4\xed\x93\x91\xb9\x5a\xb1\x4c\x58\xe0\x8f\x58\xbe\xd9\x9d\xf8\xf9\x9d\x76\xe2\x7a\x9d\x34\x9f\xd7\x9a\xb5\xe5\x5a\x73\x95\xd4\x49\x73\xad\xb6\x5c\x5b\xe1\xbf\x2d\x19\xb8\x02\x5c\xf4\x9f\xfc\xa3\x28\x9e\xd6\xca\x73\x61\xf6\xca\x31\xf2\x72\xd8\x7d\x57\x5c\xb6\xf9\x64\x85\xb3\x8c\x0c\xd6\x8d\x26\xad\x30\x4e\xa2\x0f\x26\xf2\xff\x89\x69\x55\xb3\xb5\x4a\x1e\x7a\x9e\x37\x66\x26\x82\xab\x1c\x68\xcd\x7b\x14\x7b\xe6\xe6\xf2\xcd\x60\x15\x98\xf9\x93\x13\xca\x76\x01\xf8\x7c\x55\xb2\xdf\xa1\x30\x89\x9b\xbb\x56\x16\xa3\x0f\xa1\xb0\x1e\x4c\xad\x1f\x4c\xad\x67\x31\xb5\x06\xaa\xf9\x34\x04\x74\xe5\x72\xaa\xe5\x66\x4e\xe1\x65\x5e\x1a\xee\x15\xa2\xc1\x27\x2c\xbb\x85\xea\xdd\xb2\x51\x4a\x55\x0c\xfc\xf0\x7c\x42\x1b\xcb\x4f\x96\x33\x45\x27\xb5\x20\xcb\xa8\x4a\x07\x5c\xdc\x9f\xd0\x00\x72\x5b\xbb\xe8\xa4\x06\x54\x21\xcd\x60\x98\xeb\x0c\x8a\xc0\xaf\x3e\x7d\x9e\x2a\x38\x09\x38\x96\xa8\xac\xdb\x26\xd4\x79\x45\xa3\xb3\x6f\x9c\x8e\xc4\x2c\x46\x67\xdf\xc8\xe3\xc7\xfc\x4f\x4d\x73\x45\xf2\x02\xd2\x5b\xe4\x8a\x94\x84\x82\xbd\xd4\x82\xa4\xeb\x94\x95\xf6\xdf\xce\x64\x5e\x1d\x62\xc3\xc4\xf1\x43\x46\xe2\x61\x40\x19\x41\x8d\x3c\x43\x79\x34\x08\xa2\x11\x23\x78\x71\x51\x8f\x69\x3f\xba\xf0\xc3\x2e\xa1\x09\x1c\x68\xc9\x0e\xe3\xa2\xaf\x07\x2c\x8b\xd6\xba\x35\x72\x36\x26\xa7\x30\x75\x07\x3d\x4a\x93\x53\x12\xc5\xe4\x74\x53\x8a\xe3\x4e\xc0\x27\xf4\x14\x8f\x44\x7c\xaa\xf8\xe7\x7b\x9f\x25\x69\x6e\x39\x87\xe6\x1b\xfb\xb1\xdf\xf5\xb9\x28\x0c\x67\x49\xd9\xb1\x9a\x69\x38\x2c\x21\x94\x23\x10\xc9\xd9\x64\x13\x62\x59\x5a\x5a\x11\x83\x7b\x63\x2e\xed\xe0\x3e\xab\x92\x62\x67\x94\x4e\xf2\x85\xe4\x7c\x74\x6c\xd6\x15\xad\x92\x0d\x22\x7e\x19\x35\xa0\x07\xd4\xc8\x93\x29\xca\x94\x58\x84\xea\x58\x20\x9b\xb0\x5e\x01\xe1\x31\xed\xfa\x2c\xa1\x31\xcc\x45\x0d\xb2\xb1\xcc\x17\x7e\x02\xe5\xf3\x8a\x26\xc4\xc4\x81\x88\x42\x80\x6b\x02\xc8\x26\x23\x87\x89\x4c\xea\xe1\x19\xc3\x8f\x59\x42\x12\xbf\x2f\x00\xd5\xe7\x04\x62\x3f\x33\xb4\x1f\x12\xc7\x58\x37\x8a\x63\xea\x26\x72\xfa\x63\x8f\xc6\x35\x51\xf2\x13\x24\x61\xa7\xe2\x31\xcc\xb3\xe3\xf2\xb3\x28\x9f\xe9\x5a\x97\x26\xe5\x0a\xe9\xd3\xa4\x17\x79\x35\xac\xb0\x93\x70\x71\x13\xc9\x89\xf7\x81\x71\x91\x9f\x03\x56\x23\x43\x6b\x25\x38\x0a\xf0\x01\x9f\x8d\x09\xa3\x01\xe8\x2d\x6a\x73\x19\x03\x6b\x39\x63\x29\x1b\x6b\xc7\xf3\x0a\x0c\xac\x1d\xcf\x83\x78\x3b\x7c\x17\x71\x83\x2a\x49\xd1\x85\x70\x9a\xae\xe7\xcd\x9c\x46\xdb\x99\x79\xcc\xcf\x6c\x1b\xaa\x6c\x0d\x53\xcc\x32\x0c\xd0\x6e\x14\x81\x04\xb3\xc4\x37\x90\x04\x54\xfe\x37\x66\xb5\x81\x26\xf7\x34\x36\x8b\xc8\x34\xb3\x5c\x97\x86\x34\x96\x28\x91\xbe\xdc\x65\x85\x4c\xa6\xf6\xb6\xae\x47\xa9\x3d\x53\xdb\x3e\xbc\x29\x6b\x59\xc4\xaa\x5b\xc5\xd1\xb6\x48\x7a\xd4\x30\xc4\x16\x49\x8d\xf4\x1b\x63\x2d\x62\x8d\x4e\x8e\xa3\x45\xb2\x23\xca\x74\xb9\x95\x4d\x92\x47\x48\x3d\x83\x56\x10\x93\x47\x0a\xe5\x82\x76\x38\x5f\x36\x47\x82\x41\x8e\xcc\xc3\x6a\xa6\xc6\x06\x29\xd5\xf8\x99\xbc\xdc\xa8\xaa\x4d\xe3\x48\xb1\x70\xe9\xfd\xdc\x86\x97\xf1\x40\x2f\xf9\x85\x08\xaa\xb4\x01\x64\x67\x05\x91\x89\x71\x53\x84\x56\x8c\xed\xdb\x6a\x29\x8f\x62\xed\x48\x34\xc6\xd4\xe7\xc4\x74\xc9\x45\x07\x34\x6c\x6c\x1e\xc6\xc6\x6b\x36\x9e\xe7\xd7\x1d\x74\xc6\xa9\x19\x29\xc7\x70\xbe\x80\x99\x37\x62\x7d\x00\x9f\x9a\x1e\xa7\xda\xd5\x7b\x01\x2a\x05\x97\x10\xad\x99\xc5\x0d\x74\x48\x6e\x2c\x87\x2d\xbe\x4d\x65\x8e\x74\xfa\x0f\x59\x32\x10\x40\xcb\xae\xb1\x6e\xb6\x8c\x05\xd9\x00\xa2\x77\xc1\x47\x15\x1e\x1d\x0b\x19\x44\x8c\x16\x05\x01\x9e\x68\x29\x2c\x8c\xa8\x4b\xaf\x69\x42\x1c\xcd\xbe\x91\xef\x66\x22\x3d\x74\x69\x52\xc0\xc1\x38\x53\xe5\xf4\x90\x79\x23\x22\x77\x2b\x24\xb5\xa2\xe6\xb7\x68\x40\xf9\x5e\x72\x63\x0f\x60\x33\xa7\x85\xef\x54\x78\x26\x4c\x82\xa9\x02\xf4\x59\x6d\x18\x5a\x53\x54\x29\xc6\xa1\x4e\xd9\xef\x60\xd9\x2a\x69\x56\x26\xa1\x0d\xa7\x31\xea\x4c\xd1\x7b\x01\xb7\xa0\xfb\x56\xab\xb9\x78\xc4\x9e\x5a\xe5\x8a\x7a\xf6\x69\x18\x92\xd3\x88\x1f\x1a\xf9\xc6\xc7\xd7\x4f\xb9\x72\x4a\x06\xc1\xb0\xcb\x37\xb9\x28\x24\xf4\x82\xc6\xe3\x1b\x7b\x2c\x94\xb8\x05\x3d\x16\xb9\xa9\xe8\x1e\xb2\x11\x7b\x9f\xe2\xfb\x48\x4d\x64\x49\xf4\xe3\x25\x9d\x34\x0c\x76\x83\x28\xa4\x04\x2c\xa3\xc9\x19\x75\x9d\x21\x06\x8a\x19\x51\xd2\x8f\x3c\xbf\x33\x16\x0a\x6e\x8e\x6d\x16\xf5\xe9\xa8\x47\x63\x8a\x5a\x45\x6f\x18\x73\x01\xcf\x21\x41\x14\x0d\x34\xec\x11\x25\x34\xf4\xc8\x70\x80\x16\x03\x30\xe0\x9e\x13\x7b\x4b\x49\xb4\x94\xc4\x8e\x7b\xbe\xe4\x45\xa3\x90\x30\xdf\xa3\x84\x76\x3a\x5c\x7e\xac\xcd\xe5\x50\x06\xc6\xce\xd3\xf7\xa3\x62\x14\x35\x0b\xbd\x55\x39\xee\xe2\x29\x91\x52\x92\x23\xb9\x1c\x39\xe5\x4b\xe3\x14\x44\x8a\x53\xc9\xb4\x4f\x49\xdf\x19\xb0\xc9\x8b\x00\x01\x15\x2e\x83\x02\x6e\x64\xaf\x09\xbe\x28\x61\xfa\x85\xce\x40\xb3\x07\x64\xcf\xb7\xe7\xc4\x36\x58\xc9\x5e\xd3\xb0\x11\xba\xd1\x2b\x6b\xc7\x32\x7b\xe4\x6a\xe9\x40\x72\xdd\x7c\xcc\x7e\x56\xcb\x7b\x8a\x45\xa8\x79\x41\x01\xfe\xd2\xcc\x42\x8d\xd0\x43\x2e\x95\xc5\xde\xdd\xd0\x96\x0b\x56\x61\x6f\x3d\xb7\x5c\x06\x5d\x37\xa2\x68\xe0\xc9\x98\x7a\xe6\xe5\xca\x90\x32\x5c\x1c\x0e\x1c\xc8\x3c\x27\x71\x26\xe2\x0e\xa0\x14\xe1\x0d\x32\xa5\x58\xe0\x24\x4e\xbe\xfc\xba\x3c\x49\x80\x55\xac\x43\x95\x36\xf9\xc6\x24\x39\x76\x19\x05\x59\x4b\xc2\x10\x0f\x76\x75\x28\x4b\x7c\xb0\x62\xc5\x55\xd3\x8b\x19\x51\x54\xe6\x3d\xaf\xaa\xd8\x3b\xb8\xab\xe5\x48\x10\xc0\x96\x33\xe2\x80\x56\x83\xa9\x4b\x0b\xf1\xf3\xa7\xec\xce\x2e\xb2\xf0\x8e\xba\xb0\x3f\x88\x4f\x5d\x59\x44\x93\x4b\x77\xa9\x68\xe2\xdf\xfb\xe1\xb9\x38\x61\x81\x76\x0b\xcf\x4b\x30\xe7\x9b\x07\x07\xf2\xa8\x32\x69\xd2\x03\x3f\x3c\x2f\x98\x72\x9e\x55\x76\x91\x01\xa6\x8e\x2b\x78\x42\xb5\x76\x00\xe8\x70\x4d\x9c\xf6\x62\x8e\xdd\xcf\x21\x8a\x5b\xde\x3b\x3a\x66\xbb\xce\xc0\xd8\x7e\xb5\xf8\x92\xa7\x5a\x94\x6d\xa6\x6f\xfa\x25\x16\x41\xfc\xc4\x32\x9c\x91\x88\xd2\x47\xbe\xb1\x9c\x80\x26\xcf\xe9\xf8\xe6\x5e\xbe\xa3\x63\x39\xc8\x54\xd4\x3e\xbe\x5c\x39\x8c\xe3\x8a\x04\xa5\x52\xec\x86\x84\x3c\xad\xd6\x78\xaa\x88\x64\x1c\x15\x94\x41\x95\x32\xcb\x92\x42\x05\x3b\x4f\x75\xa4\x68\xde\x37\xa3\xf0\x82\xc6\xf2\x7c\x9c\x44\xc4\xe1\xf3\x4d\x70\x05\x4c\x9a\xee\x24\x42\xab\xa9\x82\x29\x97\xd9\x69\xe5\x05\x8e\x93\x25\x20\x4e\x97\xcc\x2b\x3c\xb9\x52\xb3\x58\xb6\xc4\x63\x3e\x68\x30\xa6\xe1\xa5\x5f\xe0\x5f\x55\x1c\x32\x5b\xd2\x0e\xe7\xde\x16\x5b\x7a\x6a\xcc\x05\xb6\x9e\x26\x26\xb1\x8f\xd5\x32\x18\x30\xc2\xff\xd5\xeb\x64\x2f\x52\x12\x8d\xd4\x7a\x84\x84\xf6\x07\x89\x25\x6d\xc9\x33\x90\x8b\x3e\x01\x1e\xf1\x01\x56\x40\x0b\xe1\x87\x43\x6a\x40\x44\x45\x6e\x5c\x01\xd4\x2e\x6e\x90\xd2\xbf\xc3\x92\xee\x9a\x48\x74\x19\xcb\xb0\x22\x21\x38\xb2\x24\x2e\x7c\xa3\x2d\x57\xff\xfa\x1c\xaa\x76\xc5\xfd\x89\x41\x75\x64\xc3\x28\x94\xba\xd1\x59\xfe\x1b\xdf\xe8\x2c\x17\xa9\x5c\xd3\x05\x57\x26\x69\x5c\x05\x2c\x55\xc7\x7e\x7d\x5f\xd0\xc4\xb3\x82\xe2\x93\x74\xbb\x76\x49\xdb\xa1\x89\xd2\x07\x16\x8d\xe9\x79\x41\xf9\x49\x43\x4b\x41\xae\xe4\xdc\x06\x15\x35\xd7\x6c\xe4\x95\x9e\xd8\x98\x01\x54\xd5\x2d\x74\x82\x50\xd8\x6e\xf3\xe6\xba\x93\x7a\x51\xdc\xa0\x82\x2b\x5d\x3f\x14\x76\x21\x5b\x74\x52\x8b\x0a\x9c\xaa\x05\xfe\x0e\x26\xf8\xb2\x32\x4a\x4d\x22\x17\x28\xa0\x8a\x8f\x62\x67\xb0\x65\x79\x4a\xc8\x03\xff\x74\xb5\xa8\xc2\xa4\x96\x52\x45\x53\x33\xbf\x3b\xf4\x0f\x7b\xb4\xb0\xc9\xa6\x71\xbf\x61\x57\xb8\xf9\x1e\x48\x96\x54\x00\x12\xfe\xc5\xf9\x10\x0d\x51\xf9\x98\xdb\xe0\x72\x7e\xf9\x49\xed\x59\x05\xef\xff\x7a\x45\xb0\x52\xf3\x72\xa5\x5e\x27\x64\x44\x9d\x73\xf8\xd5\x09\xa2\x11\x61\x4e\xe8\x27\x63\xe2\xf2\xc5\x48\xca\x5b\xfb\x64\x6f\xff\x90\x6c\x6d\xbf\xdf\x3e\xdc\xae\x28\x03\x60\x5e\x12\xec\x7e\x93\x78\x5c\xff\x5f\x8d\xb7\x5f\xbf\x8c\xb6\xba\xcf\xbb\x87\xdd\xf7\xdd\x97\xed\xb7\x1f\xdf\x7d\xdd\xde\xdd\x7a\xfd\xec\x65\xff\xf3\xce\xb7\xae\xeb\x07\x1f\x57\x46\xaf\x57\xdb\xd1\xe7\x83\x2f\xfb\xaf\xdb\x87\x7f\x6c\x1e\x76\x5f\x3f\x5b\x7d\xd9\xfb\xf5\xa0\xbd\x3f\x3e\x58\xeb\xbe\xfc\xfc\xfa\xb0\xfd\x7e\xed\x92\x0d\xdb\xe7\xbf\x7e\x1c\x8d\xd7\xf6\x3f\xbe\x19\xac\xb9\xed\xf7\x07\xbf\x37\x9f\x7c\xfb\x6d\xf8\xcb\xc8\x73\xdd\x28\xee\xbe\x5c\xf9\xba\xd5\x6e\x7f\x59\xfa\xdc\xe8\xbd\xdc\x6d\x6f\x77\xdf\x9c\x2f\xaf\xbd\x6d\xb7\x9f\xff\xfe\xa5\xfd\x6e\xcd\xdd\x1d\x6d\xbe\x1a\xef\x86\x7f\x1c\x2c\xb3\xf6\x9b\x6e\xfb\xd5\x9b\xad\x76\xfb\xb7\x51\x7b\xf8\xaa\xbf\xdd\xfe\xd0\x6d\xbf\x73\x83\xe6\xf2\x61\xf0\x9c\xbe\x7e\xe5\xef\xbb\xed\xf1\xe2\xc7\xcf\xbf\x75\x9b\xdf\x76\xe3\xb7\xaf\xfc\xa7\xed\xcd\xdd\xf6\xbb\xf1\xc7\xdd\xfd\x57\xdb\xed\xdd\x6f\xbd\x91\xbf\xf9\x6d\xb5\xfb\x72\x30\x6e\x6f\x0f\xd8\xf3\xb7\x6b\xcf\xa2\xc3\xcd\x9d\xf1\x07\xff\xcb\xfe\xa7\x46\xa3\xfd\x92\x7d\x3e\xd8\xf5\x57\xdb\x6f\x3e\xb7\xfd\xe6\xbb\xd5\x57\x97\x3d\xda\x7e\xb9\xbb\xb6\xf6\xfa\xbc\xbd\xdf\xfb\x63\x78\xf8\xee\xcd\x97\xf1\x07\xe7\xcb\x17\x7f\x73\x3c\xdc\xfe\xdd\x19\x46\x07\x97\xcd\x77\x3b\xc3\x2d\xe7\x63\xf4\xe9\xdd\x93\x37\xcd\xf7\x5d\xff\xf5\x1b\x37\xfa\xb0\xbc\xf9\xf2\x8f\xf1\xb3\xd7\x5f\x87\x7f\xbc\xfc\xad\xdf\x3e\xff\x65\xf9\xeb\xeb\xd7\x51\xef\x5d\xb3\xdb\xbe\xd8\x1d\xed\xfc\xb2\xb5\xf3\xad\xfd\x79\x3f\xf1\x2e\x36\xcf\xdf\xbd\x5d\xfb\xb0\xfd\xee\x5d\xd0\x6b\x1f\x3e\xf1\x83\x8b\xf3\x5e\xe7\xe2\xd9\xab\xf3\xe4\xfd\xf0\x53\xaf\x1d\x05\xaf\x06\xaf\x3f\x8f\x9b\x1f\xa2\x60\xf7\xeb\x1f\xbb\x49\xfc\xa6\xdd\x7e\xf7\xfb\xa7\x57\xed\xb6\x3b\xfe\xb8\xb6\xd9\xdf\xfd\xa3\xdf\xde\x7e\xf5\x0b\x5b\x6b\xb2\xe7\x09\xfb\xf8\xf5\x03\x5b\x3c\xf7\xfc\x81\x37\x4e\x7e\x71\x2e\x5e\xbe\xf6\x47\x9f\xdf\x6f\x0f\xf7\x57\x3f\xbe\xfc\xe5\xd7\xbe\xfb\xee\xdb\xef\xcf\x3f\x3a\xd1\x07\xaf\xff\xe6\xa0\xf1\x7e\xb5\xf1\xeb\xcb\xfd\xcf\xdd\xbd\xf3\xad\xc5\x8b\xf6\x76\x67\x75\xff\x37\x6f\xbb\xff\x6e\xd8\xfb\xb8\xf5\x61\xb7\xff\x32\xe9\x7c\xe8\xad\x6e\x8d\xde\x9c\x7d\xdc\x79\xd3\x1e\xbd\x7b\xb7\xba\xdb\x5e\x6a\xb7\xb7\xce\x5e\x5f\x36\xbf\xb6\xf7\x9a\xab\xaf\x46\xdd\xa7\xe1\xda\xe0\x5b\x97\x7d\x6d\xb3\xf0\x63\xf8\x5b\xb0\xdd\xf8\xd8\xde\x79\x3a\xfc\xfa\x72\x7b\xff\x6b\xff\xd7\xb3\xf3\xaf\xef\x97\x2f\x97\xdf\x5d\xf4\x46\xaf\x5e\xee\x74\x37\x77\xa3\xee\xef\x07\x3b\xed\xc3\xf7\xdf\x56\x2f\x0e\x7e\xd9\x1d\xbf\x7c\x12\x7c\xf9\xf2\xf4\x70\x87\xed\xf5\xbf\xae\x7e\xf8\xed\xcd\xe6\xea\xca\xfb\x8f\xbd\x37\xed\xf6\xf6\xdb\x83\xf6\xd6\x97\xf3\x97\xdf\xde\x47\x3b\x7f\x9c\xfb\x8b\x5b\xdd\xf6\xcb\x67\x9b\x6f\xb7\x3f\x6e\x5d\x3c\x5f\xea\x7e\x7c\x99\x7c\x1b\x7d\x7a\x7b\x31\x7e\xbf\xd4\x0b\xdf\xee\xfd\xb6\xff\xe9\xc9\xce\xe8\x77\xfa\xe1\x70\xb3\x11\x85\x2f\x7f\x75\x2f\x0f\x0e\x5f\x1f\xee\xb6\x3f\xbf\xdd\xfd\xba\xd6\x6f\xb7\x97\xde\x6f\x1f\x3c\x89\xde\x0d\xb7\xb7\xe2\x41\x63\xff\xdb\xeb\x77\x8b\xd1\xeb\xf7\xfe\xd0\x59\x7b\xf6\xb6\xe1\xbd\xdd\x7f\xb7\xda\x68\xd3\x57\xab\xbb\xed\xc5\x37\xab\x4f\xdf\x7d\x63\xed\xf8\xe9\xc5\xdb\x67\xfd\x4d\xba\xb7\x7a\xe1\xc7\xaf\x46\x83\x6e\xf4\x6a\xf5\x60\xeb\xcd\xab\x6d\xf6\xa9\xfd\x65\x71\x74\xf9\xf6\xdd\xc1\xef\x1f\x5f\x85\xa3\x8b\x83\xb5\xdd\x27\x2f\x3f\x35\xdc\x91\xfb\xaa\xff\xfa\xe5\xc1\xab\x8f\x07\x3d\xf7\x65\x37\x66\x4f\x9f\x7c\x6a\x9f\xef\xbe\x1a\x6d\x35\x9c\x43\xf7\xb7\xf3\x8b\x37\x8d\x83\xdd\xaf\x97\xec\xd7\xf6\xce\xef\x7f\xbc\x3a\xf8\xad\xb7\xfb\xdb\xbb\xc6\xe0\x6c\xa7\xeb\x46\xef\xba\x83\xce\xd6\x3b\x67\x77\x65\xad\xf3\xfa\xe0\x8f\xf1\xc5\xee\xa7\xb5\xf3\x2f\x74\xb0\x17\x75\xe3\xc5\xfd\xed\xf6\xe7\xcb\xdf\x46\x9b\xce\xd7\xc8\x1f\xfa\x7e\xe3\xfd\xd6\xeb\xc1\xb7\x3f\xce\xc3\x67\xed\x1d\xf7\x60\x73\x35\xa4\x87\x9b\x6f\xc7\xfe\xfe\xda\xc1\xfb\xd5\x1d\xba\xd8\x7e\xce\x0e\x7a\x3b\x6f\x0f\x0e\x9c\xf3\xa5\x9d\x57\x5f\xce\xb7\x9d\xc5\xcb\xb7\xdb\xc3\xdd\xdf\x76\x3e\x87\xab\x17\x5b\x9f\xcf\x3e\xbd\x7a\x19\x7d\xfc\xda\x5e\x0b\x68\x34\x7a\x3a\x7c\x33\xee\xc6\x9b\xc9\x6e\xff\xfc\x7d\x3c\xe8\x8f\xc7\x21\x1b\xfd\xf2\x6a\x7f\xed\xe3\xf9\x47\xb7\xb7\xfb\x32\xdc\xfb\xdd\xdd\x7c\x72\xf1\x7b\x2f\x7e\x1d\x36\x07\xbf\x5f\xbc\x74\x06\x6f\x3f\x6c\x3e\x3b\x1b\x75\xde\xff\xb6\x3d\xda\x3f\x18\x3d\xed\xd3\x4f\xee\xf9\xce\xe2\x81\xfb\xee\xf3\xcb\xdf\x0e\x46\x1f\xcf\x76\xdb\x07\xbf\x8d\xde\xf8\x83\xb7\x8d\xc0\x71\x9b\xbb\x1f\x9f\x8c\xbe\x74\xfc\xfd\xc3\x37\x17\x3b\xe7\x9b\x4f\x29\xdb\xef\x0c\x46\xed\xd7\xbf\xbe\x7c\x19\x36\x0f\x36\x7b\xdf\xda\xab\xce\xa7\xc1\x60\xf7\xec\xb7\xe1\x9a\xff\xdb\xce\x66\xbf\xd3\xeb\xef\xf7\xfb\x67\xbf\x85\xfd\xd1\x2f\xaf\xce\xbb\x83\xb3\xe0\xbc\x1b\x9c\x8d\xbf\x7d\xb9\x5c\x69\xb2\xdf\x9e\x6d\xed\xb1\xd1\xd9\x6f\xa3\x97\xcb\x7f\x6c\x79\x71\xb2\xf8\xb6\xdd\x06\xa6\x7b\xe6\x9c\xd1\xe0\x03\x1c\x60\x5f\x05\xd1\x08\x9c\x17\x7f\x90\x4e\x7a\xe0\xc9\x1c\x17\x70\x4e\xde\xf8\xdd\x1e\x8d\xf7\x63\x8f\xc6\xca\xef\x4f\xe1\x8e\xfb\xa4\x52\xbb\x0b\xd8\xef\xdf\x0b\x3c\x2b\xd6\x9c\x70\x2c\xf6\x0a\xc1\xa2\xe5\x56\xa6\xae\x2a\x4c\xed\xf6\x96\x51\x46\xe8\x3b\xb9\x64\x6e\x56\x95\x07\x0b\x1d\x01\x5f\x65\xa9\xdb\xd3\x54\x53\xc6\xfd\x8a\xda\x1a\xe5\x9b\xc1\x4a\x19\xce\x78\xb9\xd0\xae\xe7\x6e\x83\xef\x9d\x90\x8b\xd6\xd4\xb3\x82\x2d\x72\x40\xad\x22\xdc\x88\x4b\x6b\x9f\x89\xad\xcf\x13\xf6\x61\x75\x65\x31\x0d\xfe\x30\x60\x14\x58\x16\x2f\xeb\xd5\xfb\x27\x78\x5a\x41\x89\x1f\x0e\x86\x09\x71\xe5\x6c\xd4\xa0\xd7\x23\x3f\xe9\x49\x04\x28\x14\xab\xc4\xb2\x65\xad\x66\x5a\xcf\x58\x6e\xba\xf0\x54\xf6\x25\x0f\x54\x19\xbd\x66\xff\x33\x53\x83\x20\xbe\x95\xe8\xa6\x31\xad\xe0\x54\x49\xa6\xb2\x3e\x6e\xca\x06\x54\x69\x78\x50\xc0\xc0\xed\x5a\x42\x2f\x13\xf3\x64\x89\x33\x6b\xcb\xe3\xba\x3d\xbc\xd9\x57\x70\xcc\x13\xa4\x10\x5e\xc0\x17\x1a\x00\x29\x16\x76\xd3\xf0\xf4\x30\x6c\xdf\x61\x00\x26\x75\x18\xc9\x19\x7b\xa5\x82\xa6\x65\x08\x2c\x35\x34\xb3\x8b\xd0\xbd\x1a\x9a\xdb\x6b\x8b\x03\x9d\x33\x0c\xd9\xf0\x8c\xb9\xb1\x7f\x46\x77\x3c\xb2\x21\xfc\x84\x15\x55\x37\x74\x7a\x78\x1f\xc0\x0f\x86\xdf\xbf\x73\x82\xf2\x93\x12\x23\x81\xf3\xc7\x98\x50\x7e\xda\x73\x12\xea\xd5\x8c\xe2\x92\x86\x6d\x51\x4f\x8e\xac\x26\x3c\x1e\x96\xd5\xec\x7c\xff\x9e\x5d\xc9\x0a\xdc\x75\x5a\xb7\x87\xfd\xcc\x1c\xab\xeb\x75\xb2\x7d\x39\x88\xa4\x01\x49\x42\x59\x42\x06\xc3\x98\xa7\xb0\x9a\xba\xc5\x36\x16\x36\x1e\x8f\x72\x69\xed\x48\x0f\x1e\x75\x2f\x6a\xa5\x6c\xf9\xde\x6e\x34\x0c\xe5\x75\x5b\x9e\x22\x26\x53\xd6\xb2\x72\x36\x08\x49\x2a\x5c\x8d\x29\x50\xd7\x62\xf6\x44\x15\x61\x52\x95\x12\xb7\xcb\x88\x50\xd3\xc0\x3a\x31\x19\xa0\x35\xd1\xcb\x35\x46\x93\x03\x3e\xd9\xe5\x2b\x39\x63\xc8\x38\xae\x0d\x65\x1a\xb1\xbe\xae\x25\xd2\xcd\xf8\xdd\x29\x0c\x7d\xf1\x83\xe0\x73\xd8\x9f\x16\x49\x46\xf1\x14\x9e\x40\x51\x9c\xc5\x86\xe1\x49\x32\x3d\xa8\x5c\x1c\x19\xb5\x53\x58\xca\x02\xb7\x07\x3e\xcd\xb0\x2d\xff\x7c\x79\x03\xcd\xf8\xe8\x33\x09\x19\x0f\x94\xaa\xab\x76\x10\x78\xc5\xe9\xaa\xe2\x02\x5c\x28\x46\x34\xc5\x1a\xf3\x26\x17\x6e\x4d\x4c\x61\xd5\x88\xe0\x5f\xc9\x9b\x41\x6d\x7d\x20\x3a\xa3\xc8\x5f\x68\xa5\xca\xe9\xde\x65\x38\xaf\xe6\x6a\x02\xa5\x2a\x74\x79\xc1\x54\x98\xc5\xd6\x53\x20\x6c\x97\x82\x30\xe0\xf4\x71\x58\x0f\xdc\x40\x4d\x49\x6d\x50\xf2\x45\x83\x86\xb9\xe7\x9c\x53\xbe\x7c\x54\x71\x69\xcd\x92\x37\x64\x61\x8a\x2e\x14\x5b\x35\xed\x9c\x79\xa4\x4b\xa5\x14\x6d\x2b\x77\x52\xb4\x81\x8e\x33\x8a\x8a\x24\x2c\xb0\x3e\xe7\xd0\xc9\xcb\xa1\x1f\x24\x4b\xbe\xb8\x17\x22\xb1\xf4\x28\xcb\x6a\xd2\xf4\x0d\x1f\xe1\x91\x0d\x80\x57\xc3\xaf\x3c\x73\x74\x95\x93\x1a\xc8\xc4\x30\xca\x7f\x95\xc6\x70\xc7\x8d\xc2\x02\xdc\xac\xad\x81\x01\xe8\x0d\x0d\x29\x6d\x29\xb6\x62\xbe\x6b\x90\xce\x1d\xba\x34\x49\x19\x4b\xa4\x84\xc5\x22\xe5\x04\xef\x5c\x45\x12\x89\x78\x0d\xf2\xe7\xe8\x28\xac\x89\x9b\xe8\x12\xfe\xc7\x4f\x5c\x76\xea\xea\x75\xe3\x15\xe3\x72\xa3\xf9\x14\xde\xcd\x75\xa3\x25\x9a\xf4\x68\x4c\x87\x7d\xd2\x1e\x26\xbd\x28\x66\x73\xe0\x51\xcb\x67\xe2\xe1\x21\x23\x03\x27\x4e\xe4\x33\x60\xb3\x7c\xe0\x9f\xc5\x4e\x3c\xae\xcd\xd5\xeb\x73\xc2\x0b\x57\x4e\x36\x87\xd0\xf9\xff\xd9\x7b\xf7\xee\xb6\x71\x5d\x51\xfc\xef\xc9\xa7\x40\x7b\xce\xa9\xa5\x46\x76\x6c\xa7\x4f\x67\xd2\xec\xb4\xcd\xcc\xce\xd9\x7d\xad\x26\x33\x73\xf7\xc9\x2f\xcb\x95\x2d\x3a\x56\x23\x4b\xde\x92\x9c\xd8\xd3\xe6\xbb\xff\x16\x01\x3e\xf5\x70\x1c\x27\xed\x9e\x73\x6f\x3b\x6b\x4d\x2c\x3e\x40\x10\x04\x41\x90\x04\x81\x94\x31\xc8\x92\x51\x7e\xe9\xa7\xac\x87\xaf\xf9\x86\x3e\x97\xc0\x41\xc8\x3b\x39\x98\xe5\x0c\xc2\x1c\xfc\x38\xd8\x4a\x52\x61\xbb\xc0\x41\x86\xb9\xf1\x56\x32\x67\xe9\x24\x93\x78\xfc\xfa\xee\x37\x78\xc3\xb2\x8c\xa5\xf0\x2b\x5a\x30\x45\xf0\x61\x36\x88\xc2\x21\xbc\x11\xcf\x29\xfd\x0c\xa6\x3c\x25\x1b\xa3\x25\x22\x07\xc7\x2b\xfe\xc2\x51\x39\x12\xa8\xc0\x2f\xc9\x2c\x0e\x7c\x7a\x8c\x26\x3c\x1a\x0b\x4f\x03\xb0\x2d\x9b\x12\x00\x3d\x48\x52\x0e\xc4\xa1\xe7\x88\xa9\x30\x31\x72\xf1\x91\x74\xe4\xe7\xba\xea\x0a\x04\xd1\xfd\x56\xae\x09\xc7\xc9\x94\xef\x0f\xfc\x9c\xf7\x5a\x3e\x5e\x9c\x65\x6c\x34\x8b\x3c\x0e\x6d\x30\xcb\xe1\x8f\xc3\xe3\xbf\xbf\xff\xed\x18\xf6\xdf\xfd\x13\xfe\xd8\xff\xf8\x71\xff\xdd\xf1\x3f\x77\x50\x0c\x26\xb3\x1c\xd8\x85\xf0\xc0\x17\x4e\xa6\x51\xc8\x02\xb8\xf4\xd3\xd4\x8f\xf3\x05\x24\x23\x0e\xe1\xed\xc1\xc7\x57\x7f\xdf\x7f\x77\xbc\xff\xf2\xf0\xcd\xe1\xf1\x3f\x21\x49\xe1\x97\xc3\xe3\x77\x07\x47\x47\xf0\xcb\xfb\x8f\xb0\x0f\x1f\xf6\x3f\x1e\x1f\xbe\xfa\xed\xcd\xfe\x47\xf8\xf0\xdb\xc7\x0f\xef\x8f\x0e\x5a\x70\xc4\x70\xd7\xc2\xeb\x5f\x4f\xf3\x11\x8e\x5e\xca\x80\xde\xd6\x67\x92\x12\xff\x4c\x66\xe2\xc9\x37\x8c\xfd\x0b\x2e\x28\x87\x2c\xbc\x60\x01\xf8\x30\x4c\xa6\x8b\x95\x07\x95\xc3\xf2\xa3\x24\x3e\xa3\xdb\xd8\x3a\x86\x84\xc3\x11\xc4\x49\xee\x41\xc6\x18\xfc\x3c\xce\xf3\x69\x6f\x6b\xeb\xf2\xf2\xb2\x75\x16\xcf\xf0\x38\x50\x3c\xb9\xcd\xb6\x5e\xb4\x70\x8b\x16\x66\xef\x66\x51\xf4\x3e\xfd\x4d\x59\x95\x91\x18\xc8\xc8\x21\x74\x28\x78\x3f\xe4\x04\xc6\x47\x64\x03\x9a\x19\x25\x8f\x1a\xb4\x5d\x2b\x83\xdb\x95\x53\xbe\x55\x95\xa7\xed\x99\x8a\x99\x8e\x6c\xad\x20\xfc\x14\x12\xa6\xbf\x10\x71\x77\x6f\xe5\x35\xb4\xb3\x0f\x5a\x45\x39\x7e\x6f\x0e\xdf\x1e\x1e\x1b\x38\xc9\x6f\x6a\x62\xc2\x26\x49\xba\xe8\x41\xb7\xdd\xf6\xb8\xee\xfe\xd6\x9f\x87\x93\xd9\x44\xf8\x70\xe4\x63\x45\x25\xc8\xc5\x66\xe6\x4f\xa6\x11\x13\xc6\x37\x79\xea\x8f\x46\xe1\x70\x59\x5d\x51\xa4\xa2\x72\x94\x9c\x61\xc5\xea\x7a\x51\x72\x96\xb5\x78\x0f\xc4\xc4\xca\xc2\x80\x0d\xfc\x14\x26\x2c\x9e\xa1\x35\x10\x1f\x21\x7c\xb7\x8b\xba\x4c\x9c\x03\x9f\xdf\xca\x4e\x7a\xe0\xf3\xed\x47\x82\xf3\x23\x63\x20\xbc\x78\x65\x34\x5e\xc7\xfb\xbf\x1e\x19\xe4\x10\x9f\xe5\xb7\x90\x58\xd6\xda\x80\x8d\x13\xae\xe4\x7d\x81\x3c\xcc\xf9\xe2\x75\xff\xef\xc9\x84\xdd\x27\x1f\x3f\xf4\x6f\x38\x46\x0f\x41\xba\xc4\x2b\x9e\x60\x15\xc9\x53\x3f\xce\x7c\x6c\x2a\x33\x4b\x1e\x1b\xe9\x56\x85\x98\xe5\x97\x49\x7a\x6e\x96\x7d\x47\x49\x56\xb1\x6c\x91\xe5\x6c\x62\x96\x3a\xc2\x14\xab\x10\x27\xab\x59\xe4\x4d\x72\xc6\x1b\x23\x45\x93\xb4\x36\x34\x24\x0f\xe3\x33\xa4\x30\x3e\xbf\xca\x60\x18\xa6\xc3\xd9\x24\xcb\x7d\x74\x43\x47\x0f\xb2\x26\x0c\x86\x7e\xc6\x32\x0f\xb2\x84\xcb\xb0\x30\x33\x1c\x44\x84\x31\x3e\x38\xe7\x42\x3e\xca\x12\x3a\xfa\xc0\x15\xaa\x25\xdb\xc0\x25\xe7\xd2\x27\x9b\xb5\x49\x98\xe5\x8b\x29\x6f\x94\xaf\x3f\x29\x97\x6c\x6a\x27\x5b\x7c\x0a\x76\x6c\x6a\xf0\xc7\xf8\x82\xeb\xa4\x11\x06\x78\x13\x7b\xce\x16\xfa\x2a\x57\xcd\x9e\x63\x79\x7b\xcb\xa1\xbc\xde\x3f\xde\xef\xff\xe3\xe0\x9f\x26\x07\x98\x69\xd5\x6c\xf0\xfa\x1f\xc6\x3e\xfe\xe4\x3e\xcd\x88\xfb\x1e\xdc\x17\xfc\xcd\x7f\x72\xda\xde\x3f\x2d\xf8\x3f\x39\x67\x0b\x13\xdf\xd7\xff\x90\x0f\xd0\x34\xaa\x42\x5b\x16\xc8\xbe\xfe\x87\xc4\x96\x13\x89\x4d\xa6\x09\x2e\x22\x4d\xc8\xfd\x73\x46\x3e\x27\xe0\x2d\x5f\x7e\x42\x3f\x6a\xfe\x76\x48\x7d\xfa\xb8\xff\xc7\xc1\xc7\xfe\x1f\x87\xaf\x8f\xff\x6e\x76\xcb\x4e\xee\x3e\x6a\x97\x14\xe7\xa5\x5e\x9f\x7e\x44\xb2\xf9\x11\xc9\xe6\x86\x91\x6c\xf0\x3c\x2f\xf6\x27\x4b\x3a\xda\xbd\x0b\xd8\xb7\xe8\xa8\x0d\x68\x3d\x64\xaa\x82\x0f\xd6\xb1\xed\xb6\x0c\xd9\xf3\xff\xf6\x53\x5a\xbd\x1f\xa3\xe3\xf0\x3f\x48\x8b\x35\x9e\x5b\x26\x83\xcf\xd8\x44\x26\x3b\x44\xd5\x49\xf0\x9a\xe4\x08\x71\xbf\x26\x7b\xc0\x6b\x28\x8b\xef\xd0\x85\x17\xbb\xd0\x36\xec\x84\xc0\xf4\x57\xb6\xbc\x9b\x88\x40\xe8\x9a\x95\x45\x4f\x43\xde\xcf\x64\xf0\x19\x09\x5a\xee\x5e\x4d\x0c\x8f\xa3\x59\x3a\xf2\x87\x4c\x05\xf1\x50\xee\xe4\xcc\x90\x0c\xb7\x75\xec\x6c\x5c\x41\x78\x77\xe1\xa6\xb9\x00\x8f\x77\xe4\x65\x32\xbf\xb5\x6f\xe2\xf5\x20\x98\x9e\x89\xd7\x73\xdf\x6e\x42\xb8\x0b\x1f\xda\x77\x40\x61\xe5\x21\x79\xa8\x1f\x4a\xad\xef\x5a\x7e\x03\xe8\x1d\xe5\x7a\x3e\x48\xc9\x31\x2e\xc7\x65\x1c\x46\x41\xca\x6e\xe1\x36\x7b\x6d\x57\xa6\xb7\x08\x8e\x10\x27\x01\x5b\xcf\x0b\x32\xaf\x79\xea\xf2\x0d\x86\x12\x4c\x62\xba\x3a\xf2\xc5\xfe\x86\xb0\x6b\x14\x94\x91\x0f\xf1\x5b\x32\x41\x6a\xd5\xe4\xcb\x5d\xe6\xe2\x97\xcc\x12\xae\xd6\x65\x1e\x7d\xca\x4c\x31\xb5\x54\xae\xf8\x96\xd9\xe6\xab\x2d\xd1\xb0\x4c\x91\x45\xc8\x19\x93\xcc\xc6\x2f\x99\x95\xf0\x4d\x32\x99\x89\xd7\x88\x5b\x71\x7d\x75\xd2\x90\xfd\x69\xe0\x19\x6e\x90\x8f\xf9\x0f\x42\x95\xff\x12\x68\xa1\xdf\x72\x89\x00\xba\xa5\xe6\xcd\x35\x84\xb9\x24\xae\x3f\x17\x67\xbf\x73\xb1\xb7\xab\x7a\xf6\xf5\x2b\x7c\x91\xb3\x8e\xe8\xa2\x66\x8f\x20\x05\x97\x0b\x6d\x8f\xcf\xed\x36\xed\x3f\xd0\xce\xd5\x5f\xc8\x60\x50\xbb\x37\xd6\x08\x1c\xd7\x69\xa4\x6c\x38\xf6\xd3\x3c\x6b\x66\x34\xa4\x0d\xfb\xc5\x99\xf0\x9b\x93\xe7\xe9\x4a\xe1\x94\xaa\x23\x0d\x9f\x63\x38\x25\xbc\x33\x44\xc7\x60\x78\xaa\xb4\x9f\x8b\x63\x9e\x8c\x02\x2c\xd1\x28\x58\x16\xa5\x37\xd0\x54\x5b\x7e\xe1\x22\x02\xc7\xb6\x91\x5d\x48\xcb\x63\xfd\xfe\xf3\xca\xa3\xfe\xe8\x7b\x11\x43\xb8\x68\x7a\x5a\x2c\x2b\xc7\xc4\xe2\x55\x35\x32\x26\x8b\xf5\xc0\xe2\x2d\xb5\x26\x88\x11\x6f\xcd\x61\x13\x1a\xe8\x08\x49\xa6\x2c\x4a\x29\x34\x4b\x8a\xa9\x85\x19\x41\x07\x6a\x3d\x68\x74\x5a\x9d\x86\xd8\x1d\x09\x67\x37\x82\x49\x37\x00\xc8\x59\xa9\x98\xad\x56\x88\x23\xf5\xfb\x36\xfe\x71\x05\xe0\x92\x87\xdc\xe7\x4b\xdd\xd2\x7d\xef\xbd\x52\x3f\x4b\x87\xfd\xa9\x9f\x8f\x6b\x15\xcf\xa7\xa8\x79\x1a\xc0\x53\x26\x08\xe0\x0c\xc2\x38\x08\xe3\x33\xd7\x26\x85\x56\x9f\x03\xa7\xb2\x3b\xf7\xfd\xfb\xfa\x46\xd3\x31\x4e\xcf\x57\x44\x14\x49\xbc\x83\x1b\xde\xd2\xc5\xc7\x52\x7f\x4a\x77\x43\xdc\x6f\xd5\x7b\x7f\x90\x51\xa7\xee\xb0\xad\xa0\xae\xad\xdc\x8f\xbb\x77\xde\x1a\xab\x69\x6d\x98\xdc\x7d\xcf\xc6\x35\x6d\x4d\xfc\xf9\x9d\xb7\x15\xd6\xb5\x15\xc6\x77\xde\xd6\x79\x4d\x5b\xd9\x37\x68\x2b\xaa\x6b\xeb\x5f\x69\x7e\xe7\x8d\x8d\x6a\x1a\x63\xd3\x2c\x8c\x92\xbb\xef\xdc\xe7\x9a\xf6\xa6\xe1\x9d\x37\x75\x56\xd3\xd4\xd8\x8f\x46\x1f\xee\xbe\xb9\x49\x4d\x73\xb9\x3f\xab\x6d\x2b\x9c\x4c\x66\x39\xdd\x08\xd4\xad\x5b\x03\x5c\xb7\x7c\x3e\x59\xd7\x84\x30\x24\x08\x9c\x55\x71\x8f\xea\x0f\xf8\x6a\xfa\xd6\xcf\xc7\x2d\x2e\xdc\x28\x8d\x4b\x1e\x95\x8a\x62\x08\xd3\x87\x89\x2a\x8b\x18\xd0\xcb\xb6\xb9\x4c\xe3\xd3\x9a\xd2\xc2\x58\xa5\xc9\x76\x32\x9d\xa6\xda\xe6\x3c\xac\x12\x39\x3f\xd3\xb6\x59\x70\x1b\xec\x42\x87\x35\x3b\xa2\xed\x69\x28\x4b\x7e\x38\x94\x2e\xde\xf9\xc8\x71\x55\x20\x84\x2d\x10\xc5\x72\x7f\x06\xbb\xd0\x85\x87\x9c\x87\x8c\x93\x08\x4e\x32\x67\x6e\x59\xd3\xcd\xe1\x05\x74\x60\x0f\xda\xd0\x83\x39\xfc\x0c\x4d\xfe\x31\x0d\xa1\x27\xfa\x4d\x35\x6c\x57\x97\x9c\x6e\x65\x30\xbb\x08\x47\xe0\x83\xc0\x76\x09\x5a\x53\xa5\x11\x48\xaa\x8d\x20\x0b\x6b\xe2\x52\xef\x7b\x77\xb3\x26\xde\x4c\x35\x52\x48\x64\x2c\x0d\x59\xe6\x91\x53\x19\x6d\xeb\x79\xcf\x71\xf8\x08\x51\xae\x38\xa2\x72\x39\x45\x5d\xd7\x78\x0e\x6a\x1f\x6c\x79\xf0\xd9\x83\xac\xed\x41\xd6\x51\x55\x4f\x10\xee\x49\xfb\xf4\xd4\x83\xd8\x83\x09\xcf\xe8\xe8\x23\x2f\xf8\x19\xe2\x1d\xd8\xdc\x0c\xe5\xc9\x7a\xd6\xc6\x12\x55\x30\xd0\x05\xb1\xba\x46\xf8\x4c\x4f\xe0\x3e\xc3\xcf\x30\xe1\x10\x3e\xeb\xb3\xf9\xac\x73\xf2\xf9\xf4\xa4\x73\x0a\x9b\xbb\xe2\x77\x1b\xbd\xa0\x67\xef\xfc\x77\x4e\xd6\xa6\x4c\x17\xf6\x80\x7e\xb7\x4f\xa1\x07\x32\xd9\x78\x3e\x46\xc6\x07\xf6\x40\x76\xda\x4b\x1d\x05\xfe\x05\x46\x52\xef\x76\x4b\xe3\xe7\x41\x22\x1c\x89\xee\xf3\x7d\xba\x13\xe3\x06\xea\x72\x1c\x46\x0c\x9c\x66\x33\x16\xe7\x6d\xc9\x49\xcc\x01\xc7\x86\x41\x6e\xb2\x53\x4d\x8c\xdb\xf9\x39\xa4\x0b\xd7\x5f\xe4\xe4\xab\xf3\x02\x29\xb6\x0d\x61\xf6\x86\x5c\x84\xd4\x9c\x45\xd3\x93\x29\xe9\x30\x6b\xcc\x86\xe7\x19\xe7\xe4\x4f\x78\x57\xf5\x09\xc2\x8c\xbc\x2d\x34\xa3\xf0\x9c\xb5\x60\x5f\x18\xfe\x84\x19\x86\x22\x0e\xe9\xae\x51\x97\xe0\x55\xc3\xbc\x81\x3e\x8f\xe3\x24\x37\x7c\x73\xe1\x95\xe5\x18\xaf\xc1\x08\xb6\xa0\xee\x27\x34\x01\x68\xa0\x8f\xdd\x30\xce\xd9\x19\x4b\xe1\x0c\xf7\x7c\x29\xcf\x89\x21\x49\xd1\x07\xf2\xbf\x66\x7e\x04\x79\x02\x9f\xda\xe4\x0b\x21\x62\x59\x26\x0b\x18\xb9\xef\xe8\x08\xef\xed\xfe\xff\xe9\x1f\xed\xff\x72\xd0\x3f\x7c\x77\x7c\xf0\xeb\xc1\xc7\x4f\xd2\x75\xf2\xdf\xc8\x8b\x1d\xfe\x9c\x30\x5e\xf6\xfd\x08\xfa\x94\x13\xc6\x43\x06\x8f\x5a\xed\x56\x1b\xbf\x65\x8c\x32\x78\xe3\xc7\x67\x98\x32\xf5\x53\x7f\x02\x5f\x1e\x5e\x09\x2a\x1c\x8f\x99\xf8\x95\x27\xf4\x30\x07\x9d\x87\xfd\x4d\xde\xa5\x7f\x19\x24\x49\xc4\xfc\xf8\x0a\x3e\x8a\x94\x4f\x79\x8a\x54\xad\x21\xb0\x47\xbe\x2a\x3e\xe1\x1b\xd6\x4f\x04\x8c\xcd\xf1\xce\x58\xe0\xdf\x6f\x85\x19\xb2\xe1\x9b\xf0\x9c\x39\x27\x1d\x0f\xba\x1e\x6c\xa3\x05\xdd\x43\xd8\xda\x82\xdd\x17\x64\x00\x53\x55\x3a\x48\x86\x78\x2a\xde\x1a\x24\xc1\x42\x1d\xe2\xac\x54\x55\xc4\x8b\x58\xa1\x64\xbf\x15\x27\xc9\xd4\x2c\x4a\x41\x5c\x38\xcb\x1b\xd7\xfe\xba\x42\xd9\xf7\x2b\x91\xf4\x9e\xb8\xe7\x7f\xf0\x40\xf1\xb0\x63\x32\x8e\x8b\x6f\x62\xf5\x44\x10\x80\x76\xaa\x5d\xe1\xea\x06\x2b\xe6\xe3\xed\x5e\xa9\x92\x95\x7d\xc6\xde\xfa\xf9\x70\xcc\xea\xdc\xb2\x3e\xeb\x3c\x17\x33\xd2\x28\x6b\x44\x62\xa9\xac\xd3\x95\x8e\x6c\x65\x50\xb5\xba\x82\x6d\x35\xdb\xb1\x9f\x75\x42\xe1\x99\x28\x36\xbd\xa6\xdd\x6d\x53\x28\x70\x2e\xe7\x38\xa3\x95\x0d\x1e\xc3\xa8\xa0\x83\x9f\xfa\xad\x30\x47\x6f\x4a\x4c\xcf\xb0\x69\x1a\x5e\xf8\x39\x2b\xcc\x98\x13\x1c\x9e\xdd\x7e\x4b\x76\xe5\xb4\x30\x7d\xc4\x5b\xf4\x3c\x41\x49\x20\xa0\x16\xe6\x93\x1c\x6b\x3d\xa1\xd0\xfa\xc7\x28\x6c\x30\x19\xc7\xf9\x50\x64\x99\x5c\xb6\xb5\x05\xaf\xd1\xd3\x72\x96\x27\x29\xbd\x52\xf8\x44\x96\x24\x9f\x20\x65\x19\x5f\x42\xc2\x18\x6f\xeb\x85\x59\x09\x47\x09\x1f\x7c\xf8\xf0\xdf\x87\xc7\x30\x98\x9d\xf1\x02\x47\xfe\xc8\x4f\x43\x78\x2e\xfc\xc3\x1d\x31\x66\x87\xe1\xb8\x64\x83\xf3\x30\x47\xeb\x9b\x6c\x9c\x5c\xf6\x07\xb3\xb3\xd6\xf0\x2c\xdc\x0b\x83\xdd\xce\xe3\x27\xed\xed\x47\x15\xc6\x43\x96\x4b\x0a\x22\xcd\xee\x2e\x34\x64\x97\x1a\x25\xa3\x98\x68\x26\xde\x8d\x50\x4d\x55\xc5\xb4\x4a\x16\x85\x25\xdd\xcd\xf2\xa5\x96\xe8\xa8\xb4\xd8\x8e\xe0\x2a\x41\x44\xa1\x2e\xec\x55\x31\x32\x15\x39\x69\x9f\x0a\x9f\xce\x5c\x63\x10\xe5\x7b\x66\x79\x35\x59\x09\x17\xb9\xc1\xb1\xa0\xd4\x4c\x65\x73\x58\x2b\xe6\xf2\x52\x43\xd8\x1f\xf7\xf9\x77\x75\x9f\xff\xe3\xf6\xf7\x87\x23\xe5\x1f\x8e\x94\xbf\x93\x23\x65\xbc\xb8\xa0\x18\x78\x3b\x7f\x69\xbf\xbb\x1a\xb5\xda\x17\x69\x4e\xc6\xa2\x91\x87\xc0\x14\x6a\x3c\xc9\x6e\xfd\xa3\x7c\x58\x20\x50\xc0\xc7\x6e\x63\x3f\xe3\xcb\xf6\x80\x31\xbe\x55\xc0\x87\x5b\x61\xc6\x02\x68\x42\x36\x9b\xe2\xc3\x16\xb3\x04\x05\x82\x23\xd4\xe4\x69\xae\x4f\xfa\xa4\x5c\xf7\xf0\x7b\x77\x77\x17\xee\xd3\xba\x77\xdf\x30\x2a\xd5\x79\xba\x97\xb0\x47\xc9\x3d\xe0\x18\x17\x9c\x20\xcb\x27\x83\x4e\x36\x1b\xd0\x55\x13\xa1\x85\xbf\x65\x57\x05\x70\x9d\x81\x6f\x88\x74\x13\x1c\xbb\x42\xa6\x58\xca\xab\x87\xe6\x88\x97\xe5\x2a\x6a\xca\x32\x34\xe2\xc6\x20\xe5\xc2\xb0\x1b\x63\x95\x93\xbd\xae\x1e\x2b\x0f\xf7\x65\xf7\x61\x13\x4a\xb8\x20\xa9\x24\xf6\x9a\xd9\xb5\xc0\x26\xf1\xe5\x18\x08\x5a\xe8\x9a\xf3\xe3\x0b\xee\x0f\xc5\xc8\xf7\x50\x14\xa1\x75\xbe\x26\x8e\xf9\x06\x82\x62\x41\x1a\xe1\x1a\xf0\x51\x44\x21\xbe\x03\x5a\x26\x5f\xc1\x95\x9c\x70\x06\x71\x05\x7e\x99\xed\x7b\x65\xaf\x3a\xbd\x66\x80\x34\x6e\xc6\xcb\xc8\x5d\xa3\x48\xbd\x99\xcb\xab\x34\xc9\x32\x65\xe4\xc2\xe7\xec\x2b\xc6\xb9\x07\x1c\x9c\xb3\x7c\x65\x1c\x96\x64\x7e\xbf\xf0\xf6\x54\x33\x10\xaf\xec\x41\xbf\xf0\xc8\x49\xd5\xe4\xd9\xce\x72\x7f\xd0\xbc\x88\x7c\x1a\x25\x6f\xa8\xea\x67\xa4\x78\x19\xca\x2b\xd9\x8f\x42\x75\xa8\x3b\x93\x7c\x08\xdc\x6d\xf9\xd3\x69\xb4\x10\x75\xd5\x8a\xeb\xba\xea\x19\xb3\xe5\xee\x98\xba\x74\x62\x7b\x28\x34\x9e\xab\x5d\xfb\x54\x4d\xf4\x82\x9e\x89\x42\xb5\xab\x22\xde\xc8\xce\xc6\xd5\x2a\x6a\xcf\xc9\x7d\x45\xdd\xfb\x18\x45\x1a\xc9\x58\x78\xf9\xd5\xe0\x00\x1b\x2a\xd3\xbc\x67\xb5\xee\x9d\x6f\xa6\x27\x9d\xdc\x1f\xe2\xc5\xf9\x87\x8f\x07\x47\x07\xef\x8e\xf7\x8f\x0f\xdf\xbf\xeb\xef\x1f\x1f\x7f\x3c\x7c\xf9\xdb\xf1\xc1\x11\x5e\x9b\xcb\x80\xa7\xa4\xdf\xae\x79\xc2\x25\x99\xa0\xa0\x20\x2f\x7d\x60\xf5\x6f\x3d\x89\x2b\x9e\x20\x2b\x53\xff\x3d\x78\xe7\xbf\x83\x1e\x6c\xce\x6b\x0e\xd4\x96\xbe\x3d\xba\xdb\xbb\xd3\x95\xaf\x23\x28\x4e\x7a\x98\x8d\xd7\x05\xe3\x1b\x60\xd6\xdc\x28\x04\xdb\x7d\x3c\x5c\xaa\xd5\xce\x1f\x3d\x5d\x77\x03\x10\x6c\xd3\xb3\xb2\x69\x12\xf9\x39\xab\x57\xff\xdb\x4f\xd6\xb5\x76\xed\x0b\x23\xc4\x64\xb6\x64\x77\xf1\xe8\xd9\xda\xf6\xab\x79\x38\x3c\xa7\x48\x5b\xb5\xe0\x9f\x3d\x7f\x4a\x57\xf5\xc6\x42\xaf\xc6\xd5\xc1\xc0\xc5\xfa\xe0\x98\x82\x23\xf3\x25\x83\xa7\xb7\xe8\x13\xe5\x13\x25\xf0\xf6\xcc\x25\xc0\x19\x26\x33\xdb\x55\x41\xc0\xf5\x6f\xac\xe6\xd8\x26\xf1\xd7\x5a\xe8\x98\x43\x7d\x72\x7f\x8c\x02\x86\xda\x43\x2b\x9c\x00\x77\xe4\xc1\x49\x20\xfd\x45\x37\xa1\x73\xca\xd7\xd7\x59\x9c\x83\x9e\x65\x9d\x36\xf4\x28\xd1\x15\xcf\x50\x2d\xe4\x4b\xa1\xd7\xa8\x07\x1e\x64\x53\x36\x0c\x47\xa1\xbc\x08\x59\x1d\xed\xc2\x28\x70\x9e\xe7\x98\x4b\xf9\x41\xb8\x0b\x82\x08\x74\xcd\xd6\x8a\x48\xc6\xe1\x90\xd5\x12\x18\x3d\xca\x9a\x1d\x76\x65\xff\xa1\x23\x9d\x8e\x17\x07\x41\x3f\x1b\x09\xdb\x7c\xab\x65\x7c\x77\x78\x31\x83\x9c\xc6\x33\x94\xdc\xc7\x0b\xbc\xe0\x24\x6c\x9f\x9a\xc9\x18\xed\x2b\x38\x09\x3b\x56\x2a\x9b\x8a\xc6\x69\x17\x91\x4c\xe1\x67\x02\x61\xdc\xcc\xe4\x8c\x57\xc5\x54\x4f\xc1\xe7\x65\x3d\x09\x96\xe0\x58\xc5\xc3\xb6\x47\x68\x87\x1d\x8f\xf0\xd5\x85\x84\xab\x02\x51\xf2\x86\xec\x35\x52\xec\x75\x18\x0f\x53\x3c\x11\xa4\xa1\x52\x08\x72\xc4\x24\x1f\x19\x7d\x63\x53\x78\x01\x6d\xb3\x5f\xbe\xbe\xea\x1c\x45\x49\x92\x12\x08\xd8\x42\xcc\x5c\x78\x58\xe8\x17\x76\x95\x6e\x5a\x59\x18\x11\xb5\xea\xca\x7e\xfb\x9e\x81\x8e\x59\xa7\xfa\xf7\x73\x6d\xff\x04\xc6\x3c\xe5\xa1\x40\x79\xab\xb6\x7b\x92\x18\xc9\xb4\xb6\xf0\x77\xea\xdf\xb2\xf1\x43\x0e\x5f\x7d\xfc\x90\xf5\x57\x1d\x40\x31\x05\x83\x55\xe8\x6c\xe1\x71\x2d\x9d\x2d\x34\xae\x25\x74\x11\x0f\x4b\xa9\x46\xb1\xa3\xa5\x90\x9d\x7a\x55\x5a\x34\x1c\xbd\x58\x60\x99\x55\x06\xb0\xb0\x0e\x72\xed\xa2\x24\x22\x6f\x50\x7b\x28\x6a\x1b\x6b\xf7\x1b\xc4\x8d\x43\x5a\xae\xca\x16\x57\x7c\x09\xcc\x48\xa4\xdb\x37\x44\xca\x10\xcb\xf8\xe2\x75\xd7\x32\xfc\xb8\xd1\x2a\x51\xea\x04\xad\x12\x08\x96\xb8\x97\x37\xe3\x29\x22\xbb\xa5\x11\x29\xae\xd9\x15\xb6\x06\x9d\xf6\x5f\xea\x25\x18\x1a\x0d\xe2\xae\xa8\xfe\x19\x51\xe7\xe9\x5f\xc6\xbc\x51\x60\x6a\xd8\x37\xae\x77\xaa\xcc\x61\x2d\xd7\x58\xb7\x9f\x0a\x85\x72\x16\x63\x84\xa6\x52\xe7\x0d\x76\xa4\xbb\x30\x1c\xd5\x75\xf4\x4f\x8e\xcc\xc0\xcf\xc2\x25\x2f\xb9\xba\xed\x95\x91\x79\xc9\x21\xad\x89\xcc\xb6\x81\xcc\xab\x28\xc9\x58\xb0\x84\x3e\x8f\x6e\x86\x12\xc1\x5b\x13\xb1\x47\x84\x58\xb0\x6c\x0b\xb0\xfd\xf4\xe9\xca\x18\xbd\xf6\x73\xb6\x26\x2a\x8f\x09\x15\x7a\x61\xb2\x64\xc3\x70\xe7\x93\x66\x78\xe3\x49\x53\x40\xf5\x76\xb3\xe6\x09\x01\xa3\x13\xcc\x25\x83\xf0\x6c\xe5\x41\x20\x81\xbc\xe6\x30\x3c\x25\x74\xd2\x64\x16\xd7\x33\xe9\xb3\x67\x77\x3e\x0a\x75\xf6\xc2\xab\x62\x7a\xbb\x41\x78\x46\xb0\xe8\x45\xd2\x92\x41\x78\xbe\xf2\x20\x90\xff\xf0\x35\x07\xe1\x39\xa1\x83\x0f\xed\x47\x49\x3a\xe9\xe3\xeb\xc0\x25\xc3\xb1\x3a\x73\x1c\x4b\x98\xaf\x32\x29\xcd\x6e\x52\xeb\xe8\x62\xdd\x3e\x75\xc4\x52\xf3\x67\x92\x4c\x96\x6c\xd8\x3b\x2b\xf7\xe4\x7f\x92\x64\xb2\x2e\x2e\x62\xa9\x4a\xcf\x06\x4b\x06\x7b\x7b\x65\x54\x3e\x9e\x0d\x56\xa7\xe5\xc7\xb3\x81\xb9\x96\xdc\xa0\xc6\xad\x44\x7d\x47\xac\x88\xe3\x2c\x5a\x42\xfe\xee\xca\x7d\xfe\x7b\x16\xad\xde\x83\xbf\x67\xd1\x9b\x64\xed\xe9\xd0\x11\xeb\x67\xe4\xd7\x0f\xd7\xb3\xe7\xab\x0f\xd7\x1b\x7f\xb0\x2e\x26\x62\xc1\x1c\x0f\x97\x11\x71\xf5\x15\xfc\xef\xc3\x9b\x10\x71\x78\x2b\x22\x8a\x55\x6b\x38\x1b\xb0\x31\x8b\xc2\x25\xe2\xe4\xf9\xe3\x95\x3b\xf0\x4a\x42\x2b\x60\x75\xfb\x05\x61\x70\xe3\x05\xa1\xa2\x87\xb7\x54\x68\xc5\xda\xfc\xaf\x99\x1f\xe7\xe1\x9f\xf5\x2a\xd2\xb3\xe7\xd7\x28\xb5\x12\x82\x7a\x48\x6d\xff\x2b\xec\x64\xbe\xc3\x3b\xad\x1b\xdb\xd6\x8f\x67\xec\x76\xe7\xe9\x67\xfe\x64\xe2\xdf\xee\x2c\x3d\x4e\xca\x40\x6e\xb0\x25\xc3\x1b\x4d\x3f\x5e\xa6\x64\x3d\xc6\xe3\xe2\xe2\xb6\xdf\xf7\x20\xa8\x74\x59\xeb\xe4\x85\xbd\xb0\x0f\x9b\x90\xc3\x43\x08\xa4\x1b\x40\x03\x18\xef\x4e\xcc\xd0\xff\x0c\x87\x38\xf0\x60\x61\x01\xf5\xe5\x99\xc6\x34\xb9\xe4\x05\x16\xae\x07\x03\x33\x8d\x6a\x34\x81\xe7\xc1\x2e\x74\x60\x0b\x16\x5e\x3d\x2e\x1a\x96\x40\x0a\xeb\x57\x20\x36\x9e\x31\x44\xc8\x38\x0a\x87\x5d\x18\xf0\x96\x4c\xef\xc4\xb0\x67\xd2\x03\x5e\x40\xe7\x59\x1b\xbe\x7e\x85\x00\x5f\x19\x3c\x6b\xc3\x1e\x04\xd0\x84\xed\x27\x6d\x78\x48\x8d\xa3\x6a\xe6\x04\xb0\xc5\x13\x5d\xe8\x71\x2a\xf6\x56\x39\xf3\x32\x86\xaa\xf2\x4c\x99\x6c\xda\x7d\x17\xf6\x60\x00\x3d\xf0\x0b\xef\x19\x90\x4b\x1c\x9b\xba\x0e\x27\xd9\xe6\xc2\xc5\x5b\xa9\x0e\xec\x49\x66\x02\x7d\x6b\x69\x10\x41\x55\x43\x2a\xc0\x5e\xf5\xe0\x7d\xab\xbe\x94\x46\x48\xe0\x7a\xf3\x51\xfa\xa6\xf4\x2e\x8a\xad\xef\xf0\x02\x72\xdd\x37\x02\x16\x2b\x64\xad\x89\x9f\x0f\xc7\xce\x56\xeb\xcb\x93\xab\xad\x33\xd7\x72\x78\x24\x6f\x31\x55\xe9\xfb\xff\x71\x1f\x36\x01\x43\x72\xf2\x65\xa4\xf2\xfe\xf2\x3b\xbc\x73\xf9\x61\xb4\xf8\xff\x90\x13\xa2\xbe\x08\x55\xcd\xd2\xfe\x1b\x7f\xb1\xec\x38\xe4\xf9\x0f\xf7\x3f\x3f\x0c\x40\x7f\x18\x80\xfe\x2f\x35\x00\xfd\xbf\xd1\x91\xd4\x0f\xf3\xd6\x1f\xe6\xad\x3f\xcc\x5b\xff\x4a\xe6\xad\x1f\x45\x88\x4a\x38\x4b\x93\xd9\x14\x92\x11\x30\x3e\x3c\x30\xf0\xd3\x0d\xd3\xb1\x1b\x0e\xda\x4b\x3f\x5d\xdb\xf0\x55\x02\x58\x62\xfc\x2a\x8b\x5c\x63\x00\x2b\x8b\xdd\xd8\x08\x56\x56\x5c\xc5\x10\x56\x35\x72\x43\x63\x58\xdd\xcd\x0a\x83\x58\x99\x59\x17\x4f\xbd\x50\xaa\x10\x57\x1d\xb5\x47\x15\x56\x9d\x1c\x5c\x19\xc1\x1e\x92\xd1\x28\xa3\x88\xc8\xa4\x2d\xd0\xb7\x59\x22\xf2\x17\xc9\xcc\x28\x41\xdf\x66\x09\xe9\xec\xab\x5f\xe1\xed\x0b\x0d\x26\xfc\xdc\xff\x07\xc6\xb9\x15\x25\x44\x42\xb1\x8c\x5d\xa0\x98\xfb\x21\x09\xe3\x9c\xec\xc2\x72\x8a\xe5\xa7\xcb\xda\x79\x66\xcd\xf9\xfe\x1c\x83\xe2\x88\xc2\xf8\x69\xe6\x2f\xec\xfc\x45\x31\xff\x7a\x9f\x61\x7d\xe5\x34\x8c\x68\xd7\xf0\xa0\x41\x34\xb2\x9c\x87\x89\x3e\xcb\x9f\xf2\xaf\x8d\x39\x4f\x45\x14\xf9\x0f\xc4\x45\x3a\x13\x93\xc3\x29\x47\xf3\x7b\x79\xe8\x32\xa6\x0a\x86\xf9\xb6\x3d\xf9\xb2\x38\x4f\x17\x7c\x59\x2f\x44\xc7\xed\x57\x0e\x58\x39\x51\x02\x10\xc4\x71\x4d\xca\x03\xcc\x39\xd9\xcb\x95\x5a\x73\xbb\xd8\xa2\xa6\xd8\xc2\x2e\x26\x9e\x34\x56\x16\xc5\x3c\xbb\x38\x0a\xb4\xdf\xfd\xa8\xa6\x86\xcc\x2e\xc4\xdc\xbd\x27\xd3\x2b\x43\xaa\x68\x5b\x75\x30\x83\x03\x11\xcd\xe6\x6f\xc3\x40\xc5\x11\x2b\xf4\xb0\x3e\x6b\xfe\x16\x0d\x4c\x6b\x6a\xd5\x65\xcd\xdf\xa2\x37\x92\xea\x5a\xb5\x59\xd2\x42\xa9\x2a\x6f\x98\x24\x69\x90\x1d\xa3\xbd\x5a\x7d\x7e\x7d\x3f\x28\xff\x25\x06\x1c\xa9\xca\x8f\x92\xcb\x97\xc9\x2c\xae\xab\x3e\x0e\xcf\xc6\x76\x7e\x61\x60\xd0\xf0\x43\x3e\x4b\x77\xd4\x28\xd9\xc3\x64\x34\x22\x4b\x9c\xb4\x4f\xcd\xb0\x3b\x66\x3b\xaa\x48\xc7\x28\x22\xac\xd2\xae\x81\x7a\x1d\xc8\x4a\x26\xe1\xdd\x90\xc2\x78\x77\x17\x1a\x17\x5c\x00\x0d\xfd\xa8\x61\x77\x42\x8e\x12\xca\x91\x96\xb2\x47\xd3\x43\x4f\x63\x20\x1f\x0a\xeb\x71\xc7\xf4\x05\x6c\x8a\x35\xa1\x50\x49\x99\x31\x3b\x08\xa1\xa9\xba\xe5\x16\xa0\xf0\x82\x08\x6c\x93\x16\x06\x1b\x0e\x32\x97\x01\x67\x53\xf7\xbf\x00\x08\x4b\x2e\xa8\xad\x12\x20\x93\xdd\xbe\xc0\xbc\xd3\x43\xd0\x1e\x2c\x3a\x3d\xc4\xc1\x83\x79\x57\xa5\x75\x7b\x04\xee\xaa\x0c\x81\x3a\x2d\x21\xf0\x7a\x02\x42\x50\x86\x10\x06\x55\x10\x88\x65\x2b\x20\x28\x1c\x30\xad\x02\x07\xc3\x80\xd1\x1c\xd6\x71\x92\x86\x7f\x26\x71\x5e\x3b\xb0\x8b\xa5\x03\x3b\xaf\x1c\xc0\x45\xcd\xa8\x8b\x81\x9d\xd7\x90\x59\x8c\xd7\xbc\x66\x38\x17\x26\x5b\x2c\x96\xb2\x85\x31\xee\x8b\x65\xe3\x5e\x35\xb0\x9a\xa8\x7c\x30\xd6\x1a\xd8\xa0\x62\x58\x82\xe5\x10\xae\x1f\x58\x83\x35\x62\x6b\x60\xf5\x9c\xbd\x2b\x07\x97\xf4\xef\x66\x07\x7c\x15\xe7\xee\xa6\xd0\xd4\x0f\x96\x4c\xbf\x98\xda\x4f\x28\x13\x0a\x65\xc3\x23\x6d\x34\x84\x2b\x79\xde\xe4\xad\x84\xd3\xf5\x5d\x6b\x44\x61\x8c\x8e\x48\xe5\xa0\x7f\x23\xc8\x6f\xc3\xe0\x1b\x41\x7e\x99\xe4\x3a\x18\xa0\x62\xe4\x2b\xd7\x78\x91\x26\xdd\x8f\xde\xe2\x8d\xdb\x9d\xb0\xcf\x1d\x32\xcf\x35\x1c\x93\x35\xac\xd8\x1e\x7c\xdf\x51\xda\xa3\x6c\x58\x24\xab\x78\xba\x27\xcb\xde\xee\xf9\x5e\xd1\xb3\xb8\x50\x34\xff\x0d\x1e\x9d\x85\x6b\xea\x5b\x78\xda\x5e\xa7\x2a\x67\xad\x53\xb7\xe0\xbf\x9c\x13\x61\x2d\x0a\xa0\x1d\x2e\x87\x80\xba\xc5\x2d\xbd\x6b\x2f\xee\x00\x06\xad\x9b\xb7\x74\x15\x5e\xd6\xee\xd7\x02\xc8\x49\x4d\x9e\xc7\xd3\xe4\xfc\xf6\xee\xcb\x39\x90\x3f\xee\xc0\x39\xfb\x5d\x38\x78\x27\x7d\xe2\x36\xee\xdd\xaf\xf4\x83\x5a\xca\x32\xa3\x0a\x4b\x8a\x35\x06\x91\x3f\x3c\x6f\x94\xfa\xdf\x69\x3d\x36\x7a\xf2\xd8\xc4\xa8\x6d\x72\x81\xa9\x3a\x61\x8b\xb7\x7f\x31\x6b\x9e\x1a\xd9\x37\xb4\x9d\xef\xe0\xbf\xee\x5b\x19\xef\x8f\x90\xd1\xf9\xfc\x7b\xeb\x4f\xd7\xb6\x65\x6a\xf7\xfb\xaf\xfd\xdc\xbf\xe6\xae\x6f\xed\xe7\xa4\xfd\x57\x7c\x55\x59\x0e\xbd\xdb\xfd\x71\x93\x68\x07\x12\x29\xdc\x96\xc9\x6b\x1f\xe1\x7c\xc9\xb8\xd6\x31\x2e\x7a\xaa\x2f\xda\x74\x55\x75\x96\x4d\xc7\x24\xe5\x58\x95\x15\xe7\xd6\xc5\xb3\x6d\x3c\xc5\x96\x9b\x63\xbc\xed\x11\x1d\xa4\x2d\x89\xee\x56\x32\xf8\x8c\xe7\xce\x1b\xda\x05\xa1\x1f\x0d\x67\x91\x9f\x93\x63\x2e\xda\x05\xe9\xc3\xfd\x69\x92\x85\xf4\xcb\xf2\xa6\x0f\xc9\x08\xfc\x39\xcb\x0c\x9f\x63\xf0\x85\x3a\x7a\x25\x0e\xd1\xf8\xbf\x37\x3e\x85\x62\xe6\x09\x95\x45\x7d\x9a\x24\x00\xe8\x9b\x4c\xf5\x53\xba\x3b\xab\x6d\x42\x9c\xab\x8a\x7a\xe2\x2b\x19\x51\x78\x36\x8c\x26\x29\x62\x1e\x66\x17\x67\x32\x14\x9b\x05\x88\xac\xbd\x09\x01\xae\x74\x10\x20\xbc\x9e\x10\xed\x7a\x30\x6f\xf2\x5c\x48\x52\x58\xe0\xaf\x4a\x00\xa8\x9c\xa1\xff\x02\x0e\x20\xe6\x3f\x92\x11\xa5\x1a\xae\xd4\x34\xe6\xaf\xcc\x3e\x6e\xc8\x20\xae\x96\xc8\x30\x0f\xef\xad\x0c\x19\x40\x41\x50\xcd\x13\x1d\xf7\x54\x2f\x3c\x8d\x8e\xb6\x3a\x5a\x37\x58\x84\x3a\x99\x36\x0f\xa6\x55\xe8\x85\xd0\x94\x06\xe7\x6c\x91\x39\x02\x2b\x15\xed\x20\xcb\x99\x5a\x83\x00\x22\x36\xca\x7b\x02\xe1\x16\xff\xf0\x54\xf2\xdb\x90\x2f\x03\x15\x99\x29\x85\x07\xa0\x0e\x34\x65\x7e\xaa\x91\xc4\x9f\xb2\x7a\x7d\xb1\x3c\x99\x2a\xe8\x79\x32\x55\x89\x85\x86\x55\xd6\x20\xc9\xf3\x64\x22\xe3\x12\x68\x90\x94\x6e\x96\x91\x10\xaa\x4b\x16\x5f\xc5\x85\x01\x57\xd5\x83\xd9\x90\x19\x87\xbc\xe4\x01\xcf\x83\x30\x30\x5f\xa6\xfb\x74\x6e\x2e\x68\x7a\x12\x06\xe2\x10\x8c\xe7\x25\x69\xa8\x7c\x02\x52\x91\x96\x91\xa4\xb7\x06\xea\x7d\x3c\x16\xa1\x2f\x9d\xdb\xe7\xa9\xff\x39\xf5\x03\xbe\xf6\xc9\x42\xe2\x53\x97\xd2\xf9\x85\xf2\xbb\xbb\x3a\x26\x25\xec\xc1\x97\x2b\xe8\xd9\x45\x34\x8c\x09\x12\x49\x36\x41\x5f\x9e\xb1\x87\xbf\x60\x69\x86\x51\x2a\x31\x5f\x7e\x1b\x2f\xc4\x89\xa8\x74\xc7\xd1\x68\xc0\xa6\x45\x81\x4d\x70\x44\x03\x7b\xd0\xa0\xf1\x68\x40\x0f\x1a\x0d\xd7\x80\x90\xfa\xf1\x59\xd5\xd9\x6a\xd5\x59\xec\xa2\x22\x2d\x66\x2c\x38\x9a\xfa\x43\x56\x3c\x00\xe5\xe2\x5e\xc9\x10\x3c\x60\xa2\x0b\x06\x63\x93\x29\x9a\x3e\x31\xd8\x9b\x23\x2d\xc8\x44\xdf\x5f\xbf\x42\xdb\xf5\xc0\x2e\x22\xbe\x24\x5f\xab\x1a\x14\x60\x17\xab\x9c\x96\x1e\xeb\xda\xc8\x2c\x6a\x90\xa9\x39\x11\x83\x3d\x85\x66\x9e\x4c\x35\x0a\x8a\xbd\x15\x0e\xc4\xe0\x05\xbc\xa9\x8e\x2a\xc3\x3f\x09\x4b\xe8\x15\xe0\x96\xcb\x14\x80\xac\xd4\xb0\xdd\xfb\x62\x1f\x89\x9b\xf8\x47\xe9\x65\xb5\xe4\xb1\x8a\x51\xc2\x1f\x27\x9d\x53\x8f\x92\x4e\xda\xa7\xa7\x56\x75\xba\xf4\xf3\xd3\x8c\x1d\xad\xfa\xa2\xb8\xa0\x6c\x9d\xdc\xff\x13\xf7\xfe\x06\x10\xbc\x17\xe2\xf8\x9a\x02\xdc\xf0\x59\x20\x5a\x32\xda\xa5\x03\x4a\x73\x16\xf9\x11\x66\xd0\xd8\x5b\x45\xad\x3c\xc1\xb7\xa6\xcb\x0c\xe1\xf1\xc1\x25\x62\x39\xf8\x7f\x71\x72\x70\xf3\xbe\xd1\x13\x65\xf4\xcd\xfb\x1a\xc1\xbe\x1f\x19\x7d\x94\xaf\x81\x25\x25\xa5\x8b\x8e\x9b\xb7\x73\x21\xaf\xda\x8e\x39\x88\x72\x23\x5e\x21\x54\x0d\x12\xf7\x8b\x4d\xa7\x5e\x81\x6c\x57\xae\xbb\xf2\xb4\x36\x25\x82\x25\x90\x79\xe1\x3c\x99\x36\xd0\x5b\xae\x90\x4c\x5f\xbf\x96\xcb\x10\x23\x63\x31\x2a\x25\x8f\xb7\xb8\x4c\x32\x04\x81\x4c\x5e\x08\x7f\x12\xd9\x89\x12\x87\xa7\xd0\x34\xf0\x78\x48\x1c\x4f\x53\xe6\x86\x72\x61\x69\x6f\x38\x16\xd7\x76\x07\x85\x52\x4d\x6f\x56\x41\xdb\x3a\xfd\x5e\x68\x12\xe4\xc9\xb4\x34\xff\x46\x61\xec\x47\xf2\x66\xb9\x3c\xca\xc8\x54\x9e\x71\xca\x57\x3f\xe4\x18\x0d\x6a\x8e\xd1\xa0\x16\x1e\x4d\x8a\x1e\x58\x53\x4b\x6c\x8b\xab\x98\x01\xf6\x6c\x11\xdd\x33\x7a\x52\x0c\x71\x54\x45\x7e\x5d\x5f\x88\xb9\x9e\x39\x82\xd4\x69\x31\x57\xf0\xf2\x93\x32\xc3\x80\x71\x2a\x2f\xe7\xce\x12\xc5\x37\x77\xc1\xd1\x34\xdf\x83\x66\x07\x7a\xd0\x71\xe1\xa1\x26\x66\x1d\xe7\xe8\x76\x6f\x09\xdf\x18\x62\xdb\xab\x83\x35\x86\x52\x1f\x2a\xee\xb5\x78\x5e\x18\x78\x1a\x9e\xb0\xf6\xf0\xe0\x0b\x9a\x79\x97\x8f\x10\x6e\xe7\xf5\xbd\x74\x6c\x20\x44\x13\xfc\xbe\xff\x11\x0e\xdf\xfd\xf7\xc1\xab\xe3\xc3\xf7\xef\xe0\xe1\x96\x86\x3d\x4d\x93\x21\x43\xe3\x2c\xb9\xb7\x52\xe1\xf0\x9d\xa1\x0b\xdd\x76\x67\xbb\x39\x25\xcb\x00\x0f\x7e\xf1\x87\x6c\x90\x24\xe7\x1e\x1c\xc6\x43\xe9\xcb\x19\x43\x14\x8b\xcd\xf0\x30\x09\xd0\xef\xbb\x08\x25\x1e\x18\x81\xea\xdf\x1e\x1e\xcb\x64\x18\xe1\xe5\x26\x6d\x77\x38\x88\x37\x87\xaf\x0e\xde\x1d\x1d\x88\xd8\xfa\xb4\x0b\x4a\x93\x24\x87\x20\x4c\xd9\x30\x4f\x52\x11\x0c\x5d\x37\x94\xa7\xe4\xca\x59\x3a\xd4\xc3\xe0\x17\x93\x69\xbe\x10\xef\x92\x29\x0c\xf1\x86\x30\xdc\xe4\x3d\x6c\xb1\xf8\xa2\xf5\xee\xfd\xeb\x83\xfe\xc1\xbb\xdf\xd1\xaa\xac\x31\x4d\x93\x60\x66\x3a\x4d\x16\x5b\x83\x51\xca\xd8\x9f\xcc\x31\xe0\xd5\xb8\x19\x36\x4a\x2c\x25\xf7\x15\xed\xeb\x97\x8d\x9f\xb3\xed\xba\x6e\x89\x1d\x6e\xe7\x74\xfc\x9b\xb0\xc3\xa3\xff\x55\xec\x70\x4d\x04\x84\x47\xcf\x0d\x1f\xe6\x47\xe1\x24\x8c\x7c\x11\x98\x1b\x1d\x7b\xc7\x39\x0c\x66\x39\x24\x71\xb4\xc0\x98\xe0\xe0\xc3\xa5\x9f\xc6\x18\x81\x9b\xa2\xdf\x0f\x93\x38\x08\x85\xbb\x7a\xb4\x2a\x9c\xb0\xbc\xa5\xc8\x30\xf4\x63\x18\x30\xc0\xe7\x7a\x79\xc2\x41\x40\x98\x65\x33\x96\x91\xd1\xf3\x05\x8b\x92\x29\xfa\xd7\x61\xf1\x45\x98\x26\x31\x9e\x22\xf1\xbc\x61\x1a\xe2\x45\x3e\x87\x34\xf5\xf3\x71\xd6\x82\x8f\x6c\x92\x5c\xc8\x80\xe3\x51\x72\x76\xc6\x7f\x23\x81\x47\x09\x1a\x01\x09\x56\xb6\x61\x5d\x86\x51\x04\xe7\x8c\x4d\x25\x6d\x33\xbe\xdb\x8f\x92\xb3\x70\x88\x11\x12\x46\x49\x14\x25\x97\x74\xec\xc0\x73\x10\x20\xb5\x48\xb4\xc4\xdd\xb8\xe8\xf3\xae\x4d\xd3\x9b\xcf\x2f\x32\x57\x0a\xe3\xfc\x0f\x05\x51\x6d\x2a\xcd\x74\x87\x8e\x10\xa4\xec\x56\x47\x6a\xfd\x08\x03\x4c\x16\x8f\xe5\xd0\x9c\x8e\xcf\x47\x32\xe5\xc0\x52\x14\xa0\x06\x7f\x36\x81\x0b\x76\xae\xae\xf7\xcf\x71\x3f\xd6\xd9\xa1\x5f\x3f\x63\x3e\x7d\xe0\xb9\x9e\x58\x29\x38\xb4\x13\x2c\xd1\x04\xf4\x02\xa4\x4f\xf8\xfa\x78\xec\x56\x5c\xdc\xfd\xf4\xec\x30\x0e\xd8\x1c\x0d\xed\x55\xea\x84\x65\x99\x8f\x1a\x7a\x43\xf4\xab\x87\x51\xfd\xa8\x73\xad\x94\x4d\x23\x7f\xc8\x9c\xad\xff\xca\xb6\xce\xbc\x8a\x88\xea\xfa\xd1\x1e\xc7\x47\xb6\xb1\xb9\x79\xba\x53\x5a\x67\xa5\xc1\x6e\x12\x67\x49\xc4\x88\xfa\x6a\xab\x6b\xac\xb1\xa2\x00\xd9\x2a\x39\x02\x41\xd7\x0c\x06\x9f\xa7\x0b\x55\x7a\x6b\x0b\x9a\xcd\x26\xfc\xc1\xa2\x61\x32\x41\x17\xf7\x01\x1b\xcc\x88\xf3\xd0\x88\x8c\x67\xeb\xb2\xc8\xf2\x64\xf5\x79\xe9\x67\x64\xac\x1b\x93\x95\x34\x3a\xee\x8f\x43\x16\x0f\x19\x64\x09\x46\xf3\x80\x45\x32\xc3\x09\xc2\x85\x14\xcd\xe5\xdc\x1f\x9e\x6b\x70\x79\xc2\xd7\xcd\x80\xa6\x99\x1f\x45\x59\x88\xe7\x7d\x7e\x0e\x43\x9f\x66\x14\xc5\xc6\x27\x4e\xc2\xd2\xa9\x08\x9c\x0f\x86\xa5\xf0\x41\x55\x57\x61\xe8\xe7\xc3\x31\xe0\x3b\xac\x2b\x75\xe4\x71\x59\xe6\x4a\x91\xe4\xa8\x79\xee\x81\xcd\x9b\x9c\xfa\x23\xe1\xf3\xce\x3c\x5f\xd0\x34\x2f\xa2\xd2\xf8\x54\x0b\xd4\x83\x56\xab\xc5\x47\xdb\xfd\x04\x42\x48\x99\x32\x87\x33\x4f\x43\x72\x95\xe4\xc9\x46\xd9\x09\x97\x60\x30\x69\xa4\xdf\xf8\xc5\x0f\x23\x16\x00\x5e\x87\x22\x15\xe5\x1d\x68\x0f\x1a\xf4\x56\xb1\x5d\xe4\xb9\x1d\x3e\x02\x87\x67\x71\x92\x32\x5d\x4f\xdd\xa7\x22\x00\x3c\x78\x94\x01\x4d\x6c\x04\xee\xa9\x9e\x69\xb8\xd6\x24\xee\xae\x36\x8b\xbb\xf0\x02\xba\x62\x1a\x77\xa1\x09\x5d\x63\x1e\x73\x10\xdd\x1d\xf1\x93\x66\xb2\xfc\x34\xe7\xb2\x31\x9b\x11\x42\x79\x3a\x77\x95\xad\x96\xb2\xd2\x30\x65\x91\x30\xdb\x55\x03\xeb\xc1\x09\xd1\xf7\xb4\x35\x4c\xe2\xa1\x9f\x3b\x38\x60\xe6\xb5\x75\xb5\xb2\x20\x46\xf1\xdb\x28\x0a\x4b\x23\x1a\xdc\x58\x51\xf8\xdf\xa9\x08\xc2\xdf\x38\x4b\x22\x47\xe2\xb9\x37\x2d\x60\x5b\x0f\x59\x16\x85\x71\xde\x0c\xc2\x0c\x1f\x13\xc5\x49\x33\x63\xd1\xa8\x39\x4c\x26\x53\x3f\x65\x86\xc6\x60\xdf\xc5\xe8\xa3\xe2\xba\xdb\x1a\xad\x3a\x84\x71\x84\x87\x8a\xa2\x42\x98\xc1\x34\x89\x16\x23\xbe\xf8\xaa\xc0\x20\x44\x72\x5a\xb5\xe3\x6c\x36\x61\x69\x06\xd9\x38\xc4\x95\x39\x4c\x21\xb9\x8c\x39\x24\x19\x1e\x44\x68\x07\x2c\x6d\x4d\x92\x3f\xc3\x28\xf2\x31\x48\x08\x8b\x9b\xbf\x1d\x6d\x05\xc9\x30\xdb\xfa\x83\x0d\xb6\xfe\xdb\xbf\xf0\x8f\xf0\x8d\xd3\x96\x7a\x2d\xb2\xf5\x6b\x94\x0c\xfc\xa8\x4f\xa8\x64\x5b\xf4\x77\x2b\xcc\x8a\xd1\x75\x9c\xb9\x7a\x1c\xbe\xb5\x05\x47\xfe\x84\xfd\x8e\xf6\xb0\x7e\x74\x96\xa4\x61\x3e\x9e\x88\xf8\x1f\xe4\x63\x77\x21\xa7\x14\x2f\x8b\xa7\xe4\x9d\xe6\x63\x0f\x9e\x36\x3b\x6d\x3b\xf9\x49\x6b\xd0\x7c\xd2\x62\x3d\xd8\x6c\xc3\xbd\x5d\x68\xaa\xec\xfd\x20\x60\x24\xcd\xe3\x24\xfe\x93\xa5\x09\x2c\x48\x7c\x70\x12\x4d\xfc\x73\x06\xbf\x70\x55\x64\xec\x4f\xa7\x0b\x0f\xf5\xae\x30\xe7\x2c\x94\xb2\x60\x16\x07\x7e\x9c\x9b\xdb\xaf\x39\xae\x71\xf8\x34\x7c\xa1\x7f\x76\x60\x4b\xb8\x04\xc6\x77\xeb\xb8\xd7\x32\x0f\xda\x04\x92\xf0\xa4\xe5\xf7\xd0\x5d\xf0\xee\x2e\xff\x53\x06\x3c\xe7\xdb\x55\x02\x2c\x62\xa1\xe8\x77\x0f\x1f\x58\xca\x05\x40\x46\x01\xa5\xc2\x7c\x01\x83\x85\x08\x2f\x43\xea\x59\x9a\xcc\xce\xc6\xf8\xb2\x0a\x30\xa4\x15\x90\x75\x02\xea\x5b\xd4\x0a\x2f\x27\x23\x1e\xc1\xe5\x98\xf1\x52\x0b\xbc\x30\x1c\xfb\x19\xdd\x7f\x65\x70\x39\x0e\x87\x63\xe0\x1c\xca\xf5\x4a\x9a\x9d\xd1\x42\x84\xb1\x1a\xb0\xfc\x92\x31\x9a\x20\x5a\x90\x72\x70\x2a\xe8\x4d\x3a\x63\x04\x3b\x97\x21\x74\x32\xbc\x27\x42\x85\x70\x91\x21\x64\x1b\x6a\x21\x36\x4e\x36\xf6\xb9\x72\x78\xc0\xb3\x9c\x64\xf0\x79\xdf\xe3\x3d\x79\xa9\x03\xd9\x85\x99\x99\x5c\x78\xd2\x8c\x2f\xf6\xe4\xd3\x06\x43\x47\xe1\x35\x48\x41\x11\x71\x64\xf0\x68\x86\x27\x2a\x57\xce\xfa\x05\x12\x07\x5c\x55\xf8\xa5\x2a\x5c\x68\x95\xde\x1f\xca\x66\xc5\x35\x6c\xb6\x5f\xb8\xf6\xe1\xcd\xa9\x3b\x1f\x9e\xf2\xb2\x5c\xe0\x25\x9d\xab\xc9\x27\x6f\xfb\xd2\x8d\x2b\xc7\x06\xab\xa8\x10\x53\x4b\x10\xe0\x5a\x11\xcb\x72\x5c\xfc\xf6\x1b\x19\x11\x3e\x08\x47\x38\x57\x73\x18\xa5\xc9\x04\x5e\xb6\x8a\xd1\xfe\xc4\x63\x4d\xb3\x59\x79\xf3\xac\x97\xd8\x9a\x17\x75\x2f\xe9\x4d\xdf\xfe\x49\x78\xea\x72\x62\xdd\x13\x83\x74\x22\x53\x4f\x69\xb8\xf4\xb7\x5b\xd2\x37\x55\x1f\x64\xb4\xbe\x8d\xc2\xa8\x56\x2d\x6f\x26\xb7\x94\xcf\x35\x96\x3a\x14\xbf\x76\x7d\xda\xda\x82\xa7\xad\x4e\xab\xf3\x18\x8e\x13\x8a\xf2\x45\x11\x2b\x93\x43\x11\x0c\xae\x2e\xbe\x5d\xdb\xad\x0e\xab\x59\xc2\x5e\x6b\xdf\x61\x6e\xbd\xe3\x0f\x73\x78\x01\x6d\xd8\xe3\x20\x1c\xd5\x20\x2f\xe5\x41\x7b\xde\x19\x99\xff\x5c\xae\x9e\xa0\xe6\x34\x4d\x2e\x9d\xae\x07\x8f\xb7\x5d\xdc\x7d\xec\xee\xc2\xf3\x76\xfb\x69\xe7\xf9\xf3\xee\xe3\x47\x4f\x1f\xb5\x9f\x3f\xef\xe0\xe1\x4f\x91\x4a\x4b\x5d\x94\x0b\x64\x75\x78\xbf\x80\xb6\x1b\xb8\xa9\x52\x91\x44\x53\x3f\x0e\x92\x89\xe3\x2e\xed\xe3\x39\xb3\xfd\x56\x34\x8e\x16\x93\x41\x12\x39\x0d\xa9\xd2\xe0\x3e\xa9\x70\x5d\xd6\x68\x40\x8f\x6e\xff\x1b\x6e\xbf\xe1\x81\xb3\xb9\x89\x56\xbb\xd3\xb9\xdb\xca\x13\xba\x5b\x76\xb6\x9f\xb8\xe2\x60\xab\xd8\xb7\xa5\x9e\x33\xcd\xbe\x89\xdf\xad\x11\x1e\xe2\xb4\x64\xbc\xa7\xc3\xec\x40\x19\x19\x54\x80\x5f\xea\xce\xe6\x86\x0a\x90\xc6\xa1\xdf\x67\xd9\x5b\x04\x22\xdf\x20\x8b\xd7\xb6\x24\xef\x93\x3a\xce\x7b\xd4\xdd\x76\x8b\x45\xb9\xc2\x4a\xce\x51\x93\xa9\xb0\xbd\x7b\x2d\x82\xf1\xab\x32\xaa\x52\x86\x03\x52\x07\x9d\x42\xaf\x19\x05\x97\xc1\xa6\x12\xaa\x82\x90\xac\xbb\x52\xc4\x4a\x08\x2d\xe5\x8f\xa0\xf4\x1a\x53\x96\x54\x3d\xb1\xcb\x12\x80\xfb\xb0\x67\x70\x98\xb0\x23\x91\x52\x43\x49\xf3\x1d\xb8\x32\x9c\xa1\x14\xcb\x25\x83\xcf\x66\x7b\xd7\x63\x96\x0c\x3e\xb7\x8c\x47\x96\x58\xa2\x54\x8d\xca\xa1\xe0\x2e\xe6\x19\x2f\x3c\xf7\x74\x47\x7a\x36\xc2\x3b\xf6\x13\xd7\x2a\x22\x57\x76\x83\x23\x67\x30\xd0\x1e\xa6\xf7\xe0\x8b\x34\x38\xeb\x61\xc2\x15\xda\xb6\x48\x86\xd3\x4e\x21\x56\x27\x82\x18\x52\xa7\x3c\x3e\xee\x75\x03\x64\x08\x76\xd5\x63\xaa\xa3\x66\x3e\xaf\x66\x7e\xf5\x54\x7b\x1c\xc4\xce\x46\xd5\x78\x1a\xd1\x4d\xff\x7a\x23\x7a\xd3\xfe\x95\x17\xb3\xa5\x3e\x68\x56\x59\xcc\x3a\xcf\x5b\x9d\x56\xb7\xd5\x85\x2d\xe8\x3c\x6e\x75\x5b\xdb\xad\xc7\x85\xf7\xc5\xef\xe1\xc4\x03\xfd\xa4\xf0\xd4\xa5\xe8\xd2\xb1\x3a\xde\xae\x92\x0b\x6a\xb9\x0b\x3e\xd4\x45\x98\x7c\xd4\x7d\x2a\xca\xb0\x78\x36\x79\x39\x3b\xfb\x07\xd7\x48\xea\x96\x4f\xe9\x95\xe3\xf0\xa0\xff\xe1\xe3\xfb\xe3\xf7\xb5\x05\x3b\xae\xd3\x90\x85\x1a\xa2\xd2\xc1\x64\x9a\x2f\x4a\x0e\x2c\xb6\x1e\xd2\x21\x22\x70\x82\x52\x41\xac\x75\xfc\xcf\x0f\x07\x40\x67\x86\x34\x7c\x8d\x1d\x24\xd5\x2b\xa4\x87\x54\xa1\x2f\xc3\x7c\x0c\x23\xbe\x57\xf8\xc4\x95\xbf\x4f\xa0\x8a\xf7\xf0\x1c\x29\x1c\xa5\xfe\x84\x09\x5a\x52\xe9\x61\xc4\xfc\x94\x05\xba\x24\xc5\xe3\x46\xb0\xaf\xc3\x61\x5e\xc4\x50\x68\x6d\xe3\xd4\xcf\xc6\x1e\x5c\xfa\x59\xce\x50\x73\xcf\x92\x20\x99\x2c\x7a\x70\x78\x00\xbf\xbe\x82\xc1\xec\x4c\x1a\x15\x51\x93\x35\xd6\x88\xdb\xcf\x5c\xa7\x41\x45\x1a\x4a\xe3\xe4\x3a\x9e\x41\x7e\xa9\xe2\x89\x5c\x9c\xfd\x8d\x9f\x1b\xf2\xfb\x0c\xbf\x5f\xa8\x6f\x82\xf6\x5a\xc4\x69\xdd\x41\x1d\x95\xa7\xb4\xb2\x7c\x11\x31\x19\x9e\x86\xd7\x89\x93\x98\x61\xb5\x6a\x4e\x78\x86\x4f\x92\x59\x1c\xbc\x1a\x87\x51\xe0\x10\x14\xd7\x04\x98\x0e\x39\x98\xcf\xfe\x85\x4f\x9e\x34\x7a\x0d\xd4\x6e\xec\x0d\x75\x93\x6f\x7d\x71\x57\x8d\x65\x9a\xb3\x34\x22\x1a\x5a\x34\x16\x20\x87\x49\x9c\xb3\x38\xff\x23\x8c\x83\xe4\xb2\x25\xaf\x4e\xb0\xf8\x38\x9f\x44\xad\x94\x4d\x92\x0b\x56\x83\x90\xec\x73\x1d\xb8\xa0\x44\x13\x59\xa3\x95\x4c\x99\x88\x97\x51\xc8\xb8\x4c\xc3\x9c\x39\x51\x0e\x9b\xd0\xa0\x0e\x34\x60\x93\xd3\x7c\x13\x1a\x2a\x16\xee\x2f\xbb\xef\xc5\xf6\x63\x13\xa8\xe8\x96\x59\xb6\x0a\xee\x30\x4a\x32\x46\x2d\x56\xd0\x41\x15\xfb\xc5\x08\x13\x1d\x36\x9b\x2e\x04\x2c\x62\x39\x33\xea\x9c\xa8\xe9\x71\x7a\x62\x30\x8d\x0c\xd9\x2d\xdd\x3a\xa8\xf2\x8e\x90\x59\x25\xf5\xcf\x12\x30\x96\x15\xac\x94\x39\xa6\xc4\xd1\x07\xf6\x74\xb9\xb9\x23\xf6\x42\xef\x4d\x87\x0c\xb8\x45\xc0\x79\x6e\x60\x09\xbb\x4a\x4e\x39\xef\x55\x88\x92\x8c\x56\x35\x3c\x06\xe5\x15\x64\xf0\x92\x8a\xda\xfa\x4d\xec\xd6\x16\xf8\x41\x00\xf7\xd5\x3b\xfb\xfb\xb8\x51\xaa\x7c\x69\xaf\x4e\x5c\x8c\x06\x4f\xa4\x4c\xe2\x60\xdf\x1b\xc7\x01\x0a\x1f\x9b\x6e\x8a\x9c\x9a\x0e\x25\x35\x58\x54\xed\x71\x21\xab\x0c\xe1\x0c\xba\x55\x6b\xbf\x4b\x9d\x77\xad\x14\x3d\x38\x60\xa3\x3a\x8f\x82\x5d\xb7\x35\x92\x81\xfd\xeb\x84\xf9\x13\x69\x17\x7d\xbc\xff\x6b\x1d\x9c\xb6\xeb\x34\xa4\x26\x7f\xec\x9f\xa1\x35\xda\xd2\x9d\x92\x07\xb9\x7f\x46\xae\x6a\x8c\x53\x01\x5c\x9f\xf9\xfe\x94\xff\xc4\x88\x24\x39\xec\xf1\x8d\x54\x0f\xc2\xdc\x74\x90\x71\xbc\xff\xab\x8b\x6e\x70\x10\xd4\xf1\xfe\xaf\xc2\x67\x46\xc9\x70\x58\x18\x1b\xe7\xfe\x19\x5c\x55\x13\xb8\xbb\xd4\xf6\x7e\x25\x02\x0f\xf3\x79\x0d\x61\x1e\x3f\x17\xb4\x23\x87\x28\xd5\x92\xfe\x71\x47\x14\x12\x2f\x8a\x0f\xf3\xda\x7d\x69\xf7\xb1\x1c\x8c\x55\x17\xf4\x3c\x59\x1a\xa0\xbd\xd3\x79\x24\x0a\x9e\xb1\x9c\x37\xfc\x4b\xdd\x85\x67\xf7\xb1\x5c\xd3\x5f\x7e\x3c\xd8\xff\x87\xb8\x27\xe7\xdf\x1f\x0f\x8e\x7f\xfb\xf8\xce\x48\xd0\x43\xbe\x94\x07\x68\x47\xe6\x01\x8b\xf3\x34\x64\x99\x07\xa3\xd8\xc3\x6b\x1a\x0f\x0e\x8f\x0f\x3e\xee\x1f\xbf\xff\xa8\x65\x49\x28\x71\x93\x59\x96\x4e\x6a\xa8\xd0\x12\x2e\xed\x17\x54\xaf\x54\x7b\x6a\x2d\xe5\x93\x62\x98\xcf\x1d\xdd\xaa\x40\x04\xf6\xf0\xba\xa0\xa3\x57\x5d\xf3\x86\x0e\x17\x5a\x71\xed\x90\xe5\x6c\xea\x81\x54\x9e\xbd\x82\xc0\x13\x8a\xa3\xc0\xfc\x9e\x1d\x69\x99\xee\x76\xb4\x33\x1a\x89\x1e\x5f\x22\xe4\x8d\xb0\x4c\xbb\x47\x0a\xc0\xd6\x16\x8c\xfc\x2c\x87\xa1\x9f\xd1\xd5\x2d\x3e\xa1\xca\x48\x59\x91\x0a\xae\x44\x46\x1d\xb4\x29\x96\x72\x08\x11\xd7\xa5\x23\xa3\x48\xb2\x85\xe4\x10\x85\x82\x3c\x9e\xda\x11\xfd\x84\x17\x44\x81\x1d\xfa\xa3\x4f\x93\x94\x2c\xd4\x84\x1b\x39\x4a\x82\xcb\x38\x41\x02\xea\x09\x56\x3e\x75\x31\x56\x14\xcf\x3b\xe9\x9c\xba\x7c\x07\xe0\x14\x4b\xec\x18\x96\x8b\x99\xd4\xf5\x89\xe9\xbe\x7e\x05\x23\x8d\x18\xcf\x95\x23\xaf\xa9\x2f\x64\x35\xf6\xd3\xd8\x6f\x13\x01\xe8\xc0\x4b\xb3\x03\xdc\xb3\x50\xcd\x93\xb4\x15\xb3\x79\xee\xb8\x6e\x2b\x48\x62\xb6\x53\xea\xad\xae\x8f\x83\x3e\xa2\xee\xb4\xd4\x83\x06\xa4\xc5\x5d\xf4\x82\x8b\x2b\xb9\xbd\x93\x93\x0e\xff\xea\x64\x35\xf7\xe8\x47\x85\x78\xbb\x4b\xbb\xa0\x8d\x8d\xea\xe7\x1d\x0a\xcc\x7d\xbd\x6b\xbd\xef\x89\xb9\x4b\x02\x38\x9d\x31\x74\x4e\x29\x8a\x9e\x34\x04\xc3\x36\x4e\xd5\x5a\xfa\x71\x16\xa9\x53\x12\x7d\xa1\x5a\x1d\x66\xc1\x2d\x14\x5c\x76\x8c\x21\x8a\xa8\x2a\x47\x5c\xdb\xfd\x48\x27\x33\x95\xb2\x73\xbb\x5c\x74\x19\x7c\x55\xc8\xf0\xa8\x96\xc4\x0c\x93\x6b\x03\xe3\x3d\xae\x28\xbc\xac\x11\x5d\xca\xbd\xf3\x53\x05\x35\x16\xe6\xb9\x82\xbc\xcb\x23\xa5\xcf\x87\x74\x16\x69\xe7\x67\x85\xf3\x7e\x3d\x7e\x46\x0c\xa2\x98\x36\x37\xc5\xcb\x5a\x3c\x14\x7d\xf0\xc0\xb8\x4a\x6d\x9f\xa2\x66\x68\xaa\x4a\x56\x66\x0f\x1a\xb3\x98\x43\x0b\xd4\x4e\x26\x60\xc3\xc8\xba\x8e\x25\xb7\x19\x68\x3e\x3f\xe5\x28\x65\x56\x6e\x57\xe5\x7e\x46\x6f\x51\xa2\x4c\xeb\x73\x96\xa9\x27\x1e\x1c\xe4\x2b\x0a\x25\xe4\xb4\x3d\x6b\x58\x0c\x66\x75\x1d\x5e\xce\x55\xb5\x52\x62\xa3\xcf\x59\xd6\x9a\x46\xb3\xb3\x30\xce\x5a\x49\xfc\x4a\x93\x83\xa3\xed\x29\xd8\x9e\x6c\xd9\x95\x6b\x04\xaf\xaf\xa7\x3e\x4d\x00\x94\xf4\x87\x78\x83\xe5\xc7\xe0\xe7\x4d\x6c\x84\xef\x24\xc3\x1c\xf5\xb4\x38\x31\x07\x02\xe1\xf0\x76\x38\xad\xd0\x3e\xf2\x6f\xca\x6e\x03\x7b\x22\xa7\x88\xd5\x0d\xe1\x34\xac\x71\xf2\xdf\x47\x47\xa7\xf0\x5b\x7c\x1e\xa3\xc9\x85\x68\xec\xbf\xb2\x86\x87\x03\xa8\x7d\x4c\x49\xb7\x33\xec\xd2\x9c\x16\x06\xcc\x25\x7d\xbd\x2a\x49\xa5\xbb\x34\x4f\xbb\x03\xa9\xf4\xe3\xdd\xdf\x0f\x0f\xa2\x3f\x3c\x88\xae\xed\x41\x34\x0a\xe3\xf3\x25\x0b\x6a\x17\xb7\x90\x76\xd1\x65\x6b\x9d\x2c\xa3\x2a\xf1\x8f\x37\x61\x56\xb7\xd9\x79\xde\x29\x95\x5c\x06\x5e\x96\xf9\x4e\x0b\xe9\x5f\xd8\xe3\x28\x27\x19\xca\xf2\xa3\x31\x63\x55\xe7\x99\xea\x5b\x97\x72\xf0\xb0\x30\xd3\xe2\x7d\xa9\xa7\x44\x5d\x4f\x3e\x36\x41\x17\x1e\x7e\x9e\xfb\xc3\x31\x3e\x83\x33\xae\x8c\x31\x2b\x60\xd3\x28\x59\x54\x66\x71\xbe\xa8\xcc\xc0\xa6\xc9\x2f\xc7\x95\x91\xac\x55\x01\xcb\xe6\x5e\x24\xeb\x37\x13\x19\xc7\xaf\x87\x75\xe4\x4b\x86\xa9\x9f\xb2\xb8\x90\x26\x5a\xe9\x59\x6d\x5a\x06\x95\x86\x7b\x12\xdc\xc2\xf3\x81\x91\xba\xc6\x47\x91\x8c\x84\xb1\xca\xcf\x22\x44\x1d\x57\x56\xc5\xbf\xe6\xc2\x6a\x76\x46\x92\x51\x49\x58\x54\xb3\xf8\xaa\x81\xc3\x62\x1a\x0f\x4a\xd8\x2d\x3f\x08\xc4\xe2\x4c\x85\x4e\xf8\xc7\xa9\x6d\xfd\x67\x14\x17\x66\xb9\x8e\x5e\xfb\x51\x17\x04\x78\x08\xfb\x38\x6e\xc2\xb7\x0c\x8a\xc7\x3c\x21\x53\x2b\x72\xe2\x29\x6c\xaa\x80\x4c\xa3\x0a\x8e\x29\x35\x2f\x14\x5c\x53\x12\x37\xd4\xf8\xb1\xa1\x4c\xc3\xb4\x15\xb7\xd6\x26\x13\x29\xfd\x89\xa7\xee\x18\xa5\xee\x59\x0c\xe5\x9a\xfc\xe5\x28\xff\x3a\xd6\x98\xb5\x64\x6b\x65\x30\x82\xf9\x1e\x3c\xb0\x78\x0b\x93\x5d\xcd\x9e\x05\xb8\x06\x9f\x4b\xab\x16\xd3\xd0\x45\xe1\x2b\x06\x41\xd0\x19\xd0\x18\x67\x92\x5c\x30\x93\xd2\x68\xf2\x51\xa4\x33\x51\xba\xe4\x19\x28\x60\x4b\x28\x4a\x99\x05\x8a\xde\xbb\x9e\xa4\x36\xa5\x24\x94\xba\xfe\x1a\x73\x74\xa5\x0e\xef\x07\x81\xdc\x65\x08\x9e\x1a\xce\x52\xb4\x75\x21\xa6\xe5\x7c\x23\xbb\x0c\x7f\x84\x51\xc4\xe5\x22\x4b\x73\x59\xc9\x8f\xb2\x04\xfc\x51\x2e\x6c\x05\x75\x25\x54\x99\xd1\xa9\xb1\xc0\x3d\x80\x51\x98\x66\x39\xe4\xe1\x64\x29\x11\xfd\x20\xe0\xd3\xb1\x8e\x2f\x29\xd7\xd0\x7a\x4b\x22\x91\xb6\x08\xff\x9a\x31\xf4\x15\x89\x04\xc2\x0f\xe5\x4e\x70\x6b\x0b\x3e\xd0\xae\x01\xed\x99\xc5\x01\x3b\xcd\x42\x5d\xe4\x30\x86\x24\xc5\x51\x4f\x00\xed\x28\xd3\x0b\x72\x5f\x40\x36\x96\x98\xe7\xc1\x25\xc3\x67\x66\xbc\x10\xb5\xc8\xc5\xff\xa7\x96\x40\xf3\x13\x19\x42\x7b\x1a\x2a\x19\x89\x8d\xf1\x1e\xc7\xa0\x1b\x91\xe6\x93\x16\x1c\x2e\x55\x6d\x6d\xd4\x4d\x3f\x3c\xb3\xc5\x26\x5d\xa3\x8f\xb0\x0b\x27\xa7\x96\xb7\x51\xb1\x55\xaa\x94\x4b\x36\xf9\x2c\x96\x32\xf6\x6a\xc6\x16\xeb\x03\xc9\x28\x1c\x81\x54\xa8\x0a\xb5\xe2\x41\x5b\xf4\x56\x49\x05\x6b\xf3\x25\x0b\x6e\x6d\xc1\xeb\x24\x6e\xe4\x92\xc9\x10\x79\x32\x25\x8d\x16\xe2\x09\x47\xca\xe8\xa0\x0e\xc8\xd5\x4e\x38\x0a\x59\x00\x17\x2c\x45\x57\xd2\x0b\xc5\xad\x20\xf7\x73\xf8\xa2\x62\xc0\x04\x48\x16\xe0\x08\xe5\xc9\x19\x43\x7f\xd3\x68\x70\x27\x90\x06\x7c\x01\x12\x45\x2c\x68\x59\xa8\x0b\x2a\xe3\x9f\xd6\x74\x96\x8d\x45\xdf\x4b\x6e\x22\xb1\x8b\xd4\x8e\x49\x22\x5d\x40\x51\x49\x80\x34\x2b\x83\x31\x8c\xad\x51\x92\x1e\xf0\x79\x5e\x80\xe8\x81\xb1\x8c\x95\xab\x81\xb1\x9d\x37\xcb\x5c\x6d\x94\x7f\x55\xd0\xff\xca\x98\x20\x7f\x30\x3e\x37\x1a\x39\xde\xe7\xd0\x5a\x99\x27\xe0\x0b\x29\xc6\x02\x9a\xe9\x10\x27\x01\x6b\x59\xb5\x90\xdc\x29\xa3\x81\x26\x99\x80\xe2\x20\xe1\x3a\xd5\x2c\xe3\x24\xe7\x25\x24\xc5\xf3\x96\xc9\x75\x65\x2d\x64\xa3\x06\xdb\xb2\x24\x3b\x34\x58\x26\x8c\x85\x30\xd3\x8b\xdf\x12\x89\xa3\xe9\x5b\x23\x74\x8a\x43\x6a\x09\x1a\x63\xad\xd8\x2d\x08\xeb\x3a\x56\xa0\xe3\x49\x55\xad\x7a\x71\xc3\x43\x04\xa5\xb7\x5b\xa7\x08\x29\xb2\x82\x86\xe0\xd6\xd1\x44\x1e\x23\xc5\x81\x1e\x47\x5b\x9a\x8b\x95\xcd\x10\xe3\x74\x80\x46\xaa\xe9\xa5\x9f\x69\xf1\xad\xe5\xd4\x8a\x22\xbc\xce\xdb\xb5\xcc\xae\xd3\x69\xc5\x1b\x1d\x34\x3f\x26\x79\x46\xa9\xd7\x2a\x5f\x40\x95\x68\x8e\x92\x34\xb2\x96\x0b\x53\x0f\xd3\xad\x6a\x9f\x7f\x36\xb3\x21\xac\x3a\xca\xfe\xca\xd4\x12\x38\x58\x20\x42\xcb\x08\x72\xc6\x96\xb1\x97\xc8\x45\x24\x4b\xb6\x9d\x86\xe0\x3e\x63\xb9\xa3\x4e\x87\xaa\x90\x7a\x4d\x77\xd1\xd5\x78\x29\x43\xe3\x4f\x5c\x27\xfa\xd4\xe3\x5c\x88\xe5\xd4\x42\x4d\x57\xd9\x01\xa9\x3c\x7c\xb4\x5f\xbf\x7f\xbb\x5c\xdd\xe1\xe5\x97\x74\x4c\x17\x28\xf4\xad\x7a\x61\x32\xfa\x67\xaa\x48\xd6\x61\x9d\x2d\x16\x8c\xca\x64\x88\x70\xdd\xaa\xc4\xe7\x1a\x2f\xd2\x32\x26\x8f\xc1\x3e\x16\xcd\xb5\xca\xa5\x7a\x51\xac\x5a\x92\x9c\x05\x5b\xea\x3a\xce\xa1\xab\xad\x64\x24\x86\x6a\x19\x91\xc5\xa3\xa0\x5a\xc9\x44\x4f\x86\x6c\xb1\x54\x66\x1d\xab\x5c\x3d\xfb\xa0\xcc\x9e\xce\x52\x06\xaf\x8e\x8e\xc4\x02\x4b\x72\x5f\x77\x7a\x39\x47\x70\x08\xb5\xdc\x40\x5b\x80\xc2\x5e\x49\x93\xb9\x62\x87\x60\x2c\x08\x37\xd4\xe4\xdf\x84\xf1\xb9\x29\x9b\x79\x87\x68\x1d\x43\xf6\xa6\x45\x09\xef\xf0\xe8\x39\xc7\x30\x49\x53\x96\x4d\x13\x74\xd3\x06\x93\x24\x60\x51\xb6\xac\xab\x5c\x32\xd7\x74\x94\x76\x24\x16\xb3\x0f\x49\x69\xca\x4a\x4b\x84\x98\xfb\xb8\xed\x33\x74\xcf\xcc\x38\x97\x47\x15\xe5\xf7\x30\xcd\x67\x7e\x24\xb7\xb3\x5c\x55\x99\x65\x5a\x51\xe1\x8c\x2e\xdb\x70\xcd\x81\x47\x5c\x54\x8e\x45\x5b\xb5\xaf\xbf\x21\x65\x7f\x9b\x06\xd2\x93\x97\xea\xb2\x7c\x02\xc1\xe9\xe9\xe3\x9e\x1a\x5d\xcd\x2f\xa1\xdf\x0c\xa1\xd4\x50\x90\x32\xa5\x96\xea\xe7\x7e\xe5\x06\xbb\x5c\xea\x06\xbd\x78\x95\xc4\x17\x52\x5f\x10\xba\x8d\xe6\xf9\x65\x88\x4b\x83\x8b\x1a\xd4\x95\x65\x75\x69\x51\x2b\xcf\xca\x52\xd9\x5a\x57\xaa\x5a\x8f\xd9\xd9\xa0\x13\xc0\xca\x1b\x3d\xb3\x58\xf1\xec\x7f\xe9\x8b\xb3\x5b\x38\x3b\xac\x3e\xa1\xad\xf6\x66\x68\xdf\x08\x98\xf7\x01\x45\x0f\x86\xb7\xf5\x9b\x18\x66\x2f\xd3\xe4\x32\x63\x69\x8d\xff\x44\x95\x4f\xbe\x13\x2b\x2d\xad\x8f\x84\x4d\x77\x9d\x7d\x35\xe5\xb7\xf4\x55\xf7\xb7\x34\xae\xae\x45\xa6\xca\x00\x57\x14\x36\xcc\x6e\x05\xae\x2b\x9a\x4f\x93\x59\x8c\xa0\x10\xec\x2a\xa3\x8a\x4b\xb4\xdb\x5b\xd9\x20\x97\x8a\xbb\xae\x1d\xaf\xc8\x08\x66\x14\x28\x03\xc1\x15\x21\xca\x0a\x02\xa6\x7a\x65\xf4\xe0\x81\x82\xd5\xe2\x7b\x12\xe5\xb5\xe4\xf9\xce\x3a\xae\x43\x45\x31\x72\x20\xaa\x08\x51\x11\xe4\xb1\xbb\xf4\x9d\xcc\x5f\x63\x56\xd1\x60\xbe\x65\xe9\x19\xe3\x2b\xa1\x32\x60\x32\x9e\x16\x16\x32\x1d\xe9\x69\x72\xe3\x27\x35\x5d\xde\x25\xf1\xbb\x59\x14\x59\x05\x36\x7e\xfa\xe9\xc1\x03\xb8\x17\x66\x47\x53\x36\x0c\xfd\x48\x26\x5b\x16\xf8\xd5\x55\x0d\xd8\xf7\xee\x51\x5c\x0f\xcd\xeb\x22\xce\x87\x31\xc0\x56\xe0\xd3\x62\x7b\x1c\x16\x39\x03\xe4\xc2\xf4\x77\x11\x24\xa4\x74\x83\x27\xa5\x2d\xdd\xdd\x51\xd5\x9d\x0d\x85\x86\x55\x9b\x37\x7d\x22\x6c\x98\x3f\xb2\xb3\x83\xf9\xf4\xb4\xb1\xf1\xd3\x4f\x5f\xbf\xd6\x17\x7b\xed\xe7\x4c\x16\x0a\x33\x7c\x6e\x2f\x1d\x78\x4b\xb2\xa0\x81\x74\xc6\x98\x7a\x34\x7a\x16\xe6\xe3\xd9\xa0\x35\x4c\x26\x5b\x23\xf1\x42\x77\x0b\xbd\x61\x6f\x0d\xa2\x64\xb0\x35\x78\xec\x0f\x9f\x3f\xd9\x1e\x0d\x9e\x3e\xef\x04\x9d\xee\xf3\x67\xec\xe9\x68\xfb\xf9\x93\xee\xf6\x93\xed\x67\xdb\x83\xe1\xf3\xc7\x8f\x47\xcf\x3b\x4f\x86\x9d\xad\x2c\x1d\x6e\x85\x59\x32\x49\xd2\xe9\x38\x1c\x6e\xe1\x21\x79\x38\xdc\x12\x4e\x29\xb7\x4c\x64\x5a\x9f\xb3\xff\x78\xd3\xed\x34\xdf\x74\x1f\x0b\x13\xb9\xf8\xb7\x8c\x49\xe9\x52\x21\x6d\xb4\xf9\x14\x1f\x21\x21\x47\x46\x49\x2a\xad\xd0\xf6\x5f\x1d\xf7\x0f\xde\x1c\xbc\x3d\x78\x77\xdc\x17\x46\xe1\x16\xcc\x3d\xa3\x8e\xd3\xc0\xde\xb5\x04\x62\x0d\x7c\x80\x35\x67\xfe\xf0\xa9\xcd\x31\x15\xd4\x33\x18\x06\x13\x5a\xff\xf9\x9f\x52\x5e\xa3\x35\x4f\x11\x0d\x3b\xca\xf2\x64\x9a\x2f\x8e\xf1\xd2\x90\x83\x33\x81\xd9\x51\x45\x30\x73\x0f\x4e\x4e\xa1\x07\x5f\xae\x2c\x18\x68\x99\xf0\x5b\x1c\xb1\x2c\x7b\x9f\x8f\x59\x7a\x19\x66\x0c\xf9\x70\x14\xb2\xc0\x11\x66\x48\x62\x21\xdf\x17\x37\xcd\x8a\x35\xb1\x32\xec\xc2\xbd\x42\x01\x7c\x1e\x69\x27\xb5\xa8\x2c\x17\xda\x72\xb3\x23\x71\x75\x28\xeb\xc1\x83\xda\x29\xcb\xa7\xe4\x1e\x04\x8c\x4d\x27\x3c\xdf\x29\x74\x7c\xc6\x5c\x0f\x6a\x50\xdd\xf8\xe9\x27\xe1\x1e\xd6\xea\xb6\x10\x85\x48\x1e\x6c\x53\x5d\xbe\xca\xdb\xef\xaa\x3e\x5b\x17\xdd\xf2\x91\x9a\xb8\x61\xb7\x23\xeb\x0a\x56\xc0\x5a\xb2\xda\x72\x52\x8b\x1a\x55\x3d\xb8\x72\x2d\xdc\x91\x06\x82\x3e\xab\x60\x2d\xae\xc5\xf3\x30\x96\x8e\x2f\xbf\x5c\xed\x6c\xfc\x44\x16\x7d\x45\x82\x0b\x8b\x04\x42\xdc\x7c\x8b\x2a\x32\xd4\x19\x9e\xea\xaa\x78\xc5\xf7\xd3\x4f\x3f\x19\x8d\x48\x6b\x81\xe5\x7d\x36\x2c\x0b\xca\xa8\xef\x6c\xfc\xf4\x13\x17\xf4\x3f\x5d\x6d\x58\x88\x48\x7a\xd7\x23\x82\xfb\xeb\x72\xd7\x0c\xcb\x05\x7a\x93\x6a\x34\xbf\x6e\x0f\x0c\x98\x35\x3d\x90\x0f\xbf\xab\xa1\x6b\x9e\xb6\x68\x71\x3d\xd8\x0d\xa2\x8d\x8c\x80\xa5\x21\x17\xd8\xdc\x06\x7f\x3d\xa3\x50\xfe\x21\x09\x0e\xe9\x05\x43\x09\x12\x41\xfb\x1d\x2a\x4b\x30\xeb\xca\x0a\x86\x11\x65\xf5\xf5\x69\x85\xac\xf8\x42\xd6\xa7\x38\x60\xbd\xf2\xdc\xe4\xca\x9b\x81\xdc\x7e\x1c\xd0\xdc\xc7\xf8\x09\x6f\xd1\x85\xca\x6e\x11\xf1\xdd\x5d\x1b\x3d\x2e\x6f\x28\xc2\x65\x1d\x8c\x1b\xcc\xd5\x3a\x22\x6e\xfc\x64\x38\x7f\xb3\x10\x22\xe0\xe4\xa4\x47\x75\x4b\xdb\x8e\x19\x89\x5f\xbf\x96\x09\xb0\xa3\x11\xf3\x57\x97\x58\x1b\x26\xf3\x89\xea\x37\x91\x1d\x7c\xe6\x5d\x6d\x6c\x28\x1e\x6a\x91\xd9\x79\x99\xb9\xf6\xa3\xc8\xa1\x08\x0c\x95\x6c\x85\x64\xb7\x79\x03\x4b\x0b\x21\x53\x72\x4c\x43\xa7\xb1\xd2\xac\x09\xb2\x71\x32\x8b\x02\x18\x30\x34\x60\xe3\x15\x1b\x88\xda\x86\x45\x92\xa2\x77\x60\x67\x9a\xb2\x0b\x0f\x62\x36\xb7\x85\xb0\x9e\x11\xba\x40\x65\xd7\xd1\x39\xde\x86\xdc\x36\xa8\x6a\xfd\x8e\x39\x6b\x6f\xaf\x86\x1b\x80\xab\x14\xf1\x55\x9e\x62\x7f\x7f\x83\xdb\xd6\x90\x8e\x19\x5e\x25\x51\x92\x1e\x0b\x05\x94\xcb\xca\x8a\xe4\x52\xa5\xbf\xb3\xf9\x71\xf2\xf1\xd7\x97\xba\xbc\x4c\xd9\x31\xde\x9f\x0e\xd1\xdb\x0f\x43\x50\x48\x71\x33\x41\x17\x3c\x63\xf9\xab\x24\xce\x53\x3f\xcb\x3f\x72\xf1\x07\xbb\x50\x4c\xb2\x0a\xbf\x99\x4d\xc2\x18\x0d\x61\xb0\xa0\xfa\xd4\x85\xd8\x64\x3a\xf6\xb3\xf0\x4f\x46\x7e\xc6\xe8\xb7\xce\x1e\xf9\x01\xc3\x7b\x9c\xc0\x48\x0c\xfc\xf4\x1c\x5d\x82\xd1\x0f\x9d\x11\x85\x67\xe3\x1c\x73\xc4\xaf\x1d\xae\x2b\xc3\x25\xf3\xcf\xf9\xf8\x96\x5d\xc2\xcc\x32\xd6\x1c\xb0\x51\x92\xb2\x26\x8d\x92\x70\x1e\xf3\xd0\xf4\xa9\xe1\x03\x05\xaf\x80\xcb\x71\x92\x09\xa7\x1a\xe4\xe5\x66\x12\xe6\x74\x6b\x9b\x8f\x19\x9c\x85\x17\x2c\x26\x5f\xbc\xca\x35\x0d\xf9\x60\xff\x42\xf5\xaf\x44\xd5\x63\xe9\x99\x83\xd7\x1c\x30\x18\x46\xfe\x64\xca\x82\xaa\x0a\x93\x30\xc6\xe2\x51\x72\xc9\x52\x18\x24\xb3\x38\xf0\xa5\x37\x1c\x06\xc9\x2c\x9f\xce\x72\x6a\xb2\xb2\xb6\x3f\xc7\xda\xb3\xe9\x74\x95\xda\xa9\xe8\xaf\xaa\xbf\x2f\x3b\x2e\x7d\xf2\xa0\xeb\xe1\x93\x49\x18\x7b\x1c\xf6\x69\xc1\x90\x98\x77\x43\xaa\xb0\xb2\x8c\x7e\x20\x44\x3d\xfe\x99\xe7\x14\x9c\x67\xa0\x6f\x06\x3a\xb0\xd2\x05\x5f\xe8\xda\xba\xa0\x3f\x97\x05\x4d\x25\x7e\xc7\x70\xd3\x22\x0e\xe4\xc8\xfb\x18\xe7\x65\xf3\x09\x29\x1e\x59\xf8\x71\x20\x0f\x1a\xf1\xbc\x4e\x9d\xd5\x59\x23\x96\x08\x27\xf8\x04\xa4\x09\xaf\xe5\x84\x08\x28\xc9\x2c\x9b\x49\x07\xfb\x3c\xa3\x85\x8d\x34\xe1\x7d\xcc\x20\x19\x79\xd0\x48\xcf\x06\x0d\xfa\x83\xb1\x3e\xc7\x59\x24\xfe\xf8\x0d\x13\x08\x4a\x55\x09\x43\xe0\xd7\x84\x93\xd8\x8b\xbd\xf8\x14\x92\x54\xfc\xf4\xe2\x53\x7b\xac\x64\xe3\xfb\x78\xf0\x48\xe8\x52\x5a\x61\x74\x2a\x64\x85\x83\xc5\xb5\xd5\xb7\x88\x79\xac\xfb\xe1\xa9\xc3\x67\xc4\x67\xd7\x42\x6f\x67\xc3\xf4\xf1\xa2\xfd\x8e\xf1\x0e\xbb\xf0\x02\x9a\x1d\xc3\x79\xd0\xfb\x38\x5a\x48\x1c\x8c\x3b\xc0\x6d\x63\x28\xc2\x38\x07\x27\x6c\xb1\x16\xbe\x9f\xf1\xa3\xe9\xd8\xa7\xe8\x50\x55\x06\xa9\xdb\xfc\xcf\xe6\x2e\x74\xcc\x13\x72\x0e\x89\xa2\x88\xa3\x4f\xe9\x43\xb9\xed\xe3\x89\x1e\x74\xda\x6e\xc1\xbb\x09\xee\xa9\x78\x8f\x94\x44\x35\x3c\xa6\x97\x3b\xc6\x87\xce\xee\x98\x5d\xd9\x18\xff\x4d\x68\x38\x0d\xd8\x94\x38\xb5\x4f\x79\x8a\x07\x46\x52\x07\x93\xfe\xcb\x4a\xeb\x52\x5a\xa3\xe4\xc1\xe8\xd6\xed\x14\x9a\xb1\x3c\xf4\x50\xaa\xb4\xf0\xe7\x9a\xdc\xa3\xaa\xfe\x6d\xee\x4a\x30\x26\x13\x9c\x6c\x23\x7c\x77\x39\xce\xbc\xae\x28\x62\x1c\x47\x1b\x25\x96\x4e\x61\xbc\x6a\xe1\xdc\x3d\x66\x73\xe1\x32\x8f\xf3\x0b\xde\xc5\x9c\x0d\xa4\x63\x45\x31\x81\xab\x67\x25\x34\xe1\xef\x6c\x4e\xbf\x3d\x40\x26\xfb\x8f\x38\x8e\xf9\xbc\xe2\x7f\xe3\x38\xa6\xba\x35\xd3\x8a\x37\x73\xed\xd4\x92\xcb\xaa\x39\xab\xf0\x46\x05\xc9\x55\x45\x5e\x7a\x6f\x97\xb3\x38\x60\x81\x5c\x79\x1b\xff\xd1\xd8\x29\x73\xbd\xb0\x50\x37\x41\x95\x27\x80\x0d\x6a\x53\x32\xca\x70\xec\xa7\xfb\xb9\x13\xba\x6a\xe8\x54\x8a\xe9\x02\x72\x28\x10\xb0\xa0\x58\x3e\x95\x94\x14\x10\x42\xb9\xa7\xa7\x19\xc1\xcd\x66\x83\x2c\x4f\x9d\x8e\x07\x5d\xd7\x83\xce\x13\xe1\x18\xfe\xac\xae\xe0\x76\xa1\xe0\xa0\xae\xe0\x63\x55\xb0\x18\xa8\x82\x4b\x1b\x63\x06\xb4\xd2\x22\xb7\xb7\xce\x4a\x29\x03\xc9\xb1\x57\xe5\xa5\x3e\xb6\x17\x0c\x19\x69\xc5\x58\x34\xf0\xbe\x95\xb0\x13\x2c\xf7\x2e\xc9\x59\x0f\x5e\x27\x8c\x5e\xfe\x65\xb3\x29\xea\xa3\x9c\x69\xfe\x4b\xb6\x59\x58\x5e\x8a\xcc\xa9\x64\xb7\x60\xce\x04\x57\x8f\x1e\x32\xa7\x27\x59\xd4\xe3\x20\x1d\x17\xff\xf8\xfc\xef\x38\x8b\xc4\x1f\xdf\x71\xed\x65\xe1\x0b\x79\x47\x90\xc1\xe6\x08\x8b\x9e\x58\xcf\x4f\x4e\xaf\x38\x67\xbf\xfd\xed\xd0\x5a\x24\x6d\xae\xb6\x55\xc0\x6a\xa6\x16\x8c\xd4\x16\xe7\xe8\xff\xd1\x28\x2c\xd8\x25\x18\x55\x13\xc5\xb5\x98\x6c\xc2\x55\xba\x54\x49\x39\x25\x7c\x1d\xed\x48\xc1\x5a\xa6\x88\x43\xf8\x62\xd6\xf6\x44\x65\x55\xb0\xb0\x6c\xe9\xa2\xa2\x91\x4d\xe8\x78\xd6\x9c\x82\x26\x74\xdc\x56\x36\x8d\xc2\xdc\x69\x78\xb2\x45\x01\x44\x8c\xa4\x1d\xf8\x5a\x1d\x2b\x1a\xbd\x46\x1e\xfe\x25\x4a\xfc\x5c\x9d\x0f\x93\x99\xb1\x66\xdb\x2f\x40\xe3\x43\xe6\xfe\x72\x74\x44\x53\x57\x96\x34\x94\x41\x8f\x32\xe9\x79\x18\x55\x6d\xc0\xb0\x3c\xda\x21\xdc\x65\x42\x1d\x51\x9c\xf6\x4b\x92\x4e\x66\x91\xdf\xc3\x53\xe2\xde\xd6\xd6\xe5\xe5\x65\xeb\x72\x1b\xdd\x09\x1e\x7f\xdc\xea\xb6\xdb\xcf\xb6\x3e\x1e\xbc\x6a\xfe\xf1\x6a\xff\xd7\x6e\xbb\xc9\xbf\x3b\xdd\x4e\x67\xeb\x3f\x64\x03\x4d\x6c\x20\x60\xa3\x1a\xce\xe5\x3a\xf3\x59\x8a\x8e\x1c\xef\x8e\x7d\x0b\x6d\x0c\xfc\xe1\xf9\x9d\xb7\x51\xa1\xe5\x16\x88\x2a\x14\x7c\x53\xe7\x6d\x43\x13\xba\x1d\x12\x0a\x5d\x08\xc2\xb3\x30\x87\x69\xca\x86\x61\x16\x26\x71\xe1\x41\x5d\x71\x43\xe4\x68\x52\x79\x46\x97\xb4\xda\x15\xcd\x26\xfb\x85\xfd\x91\x51\x47\x71\x73\x34\x9b\xbc\x2c\x16\x33\xc0\xed\x28\x85\xc6\xde\x9f\x39\xe4\xff\xcc\x9f\x3b\xbc\x1d\x0f\xc1\xf0\xa5\xa0\xdd\x6a\x3f\x76\x61\x4b\xe6\x87\x71\x55\xbe\xc9\xb3\xef\x90\x5e\x8e\x05\xbf\x95\x27\xbf\x84\x73\x16\x38\x5d\xd7\x45\x27\x21\xc7\xe9\x2c\x1e\xa2\xb5\x58\x8e\x4c\x89\xa4\xca\x0c\x7e\x3e\x46\x83\xf3\xc8\xcf\xc3\x0b\x06\x03\xb4\x82\x8d\x59\x46\x62\x35\x5e\xc0\x34\xe1\x6a\x60\x18\xab\xc5\x3f\x9b\xfa\x43\xae\x87\x3e\x84\x98\xaf\xf3\x51\xf8\x27\xed\xb8\xda\xb8\x40\xe2\x06\x30\xcb\x01\x03\x06\xa2\x94\xee\x60\x3a\x6d\xff\xb2\x1c\x2e\xc7\x61\xce\x2a\xe7\x44\x66\x4f\x8a\x3f\xf6\x0f\xb7\x7e\x7d\xb3\x75\x19\x9e\x87\x5b\x1f\x05\x7e\xfd\x48\x12\xfa\x7b\x8b\x6f\xc9\x9b\x4b\xa8\x45\xd2\x80\xb7\x5f\xe2\xd4\x4e\x89\x21\x35\xc7\x14\x54\x7e\x25\xa1\x83\xea\xad\xbf\x28\xaf\x34\xe2\x42\xf9\xd6\x75\xaa\x3f\xda\x68\x9d\x0d\x4c\xb8\xa2\x66\x9d\x38\xb5\x14\x7a\xd8\xda\x85\xee\xe3\xc7\xc8\x5a\x7a\xfc\x6d\x53\x08\x5e\xec\xe7\x5d\xce\xaf\xdb\xcf\xbb\xcf\x60\x8f\xea\x41\xa7\xdb\x7a\xde\x85\x1e\xf9\xc7\x9b\x26\x97\x0e\x07\x2e\xf8\x1a\x19\xbf\xc3\x7f\x78\xd0\x6d\x3d\x72\x6d\xd7\xda\x05\x36\xde\x96\x4c\x6c\xb4\x29\xe6\x82\xd3\x6e\x75\x3b\xdd\x27\xf0\x90\xf7\x91\xb4\xef\x76\xeb\x69\xe7\x71\x57\xa4\x74\x28\xa5\xfd\xb4\x2b\x53\xba\xa7\xae\x9a\x33\xdb\x62\xe9\xd3\x67\x98\xcb\xa9\x5b\xde\x7f\x14\x97\x59\x8b\xb4\x7c\x3b\xb1\x05\x9d\x76\x5b\xad\xaf\xa5\xa3\xbf\xb7\x7e\xce\xd2\xd0\x8f\x9a\xbf\x1d\xf6\x60\x16\x0b\xcd\x85\x05\xf0\x49\xe9\xf9\x5c\x57\xfa\x24\x16\xc9\x86\x6b\xae\x4c\xaf\xe9\x14\x46\xcd\x36\x39\x67\x67\xa9\x07\x01\x9b\x32\xb2\x81\x4a\x62\x08\xf3\x0c\xd4\x4c\x42\x6f\xa5\x6f\xd0\xf8\x9d\x16\x2c\xf4\x48\x4a\x07\x39\x2c\xf0\xf0\x97\x99\x23\x60\xa3\x91\xd2\x77\x99\x83\x85\x33\x94\x61\xc2\x46\xa3\x70\x18\xb2\x38\xdf\x6d\xb7\x3a\x8f\xa1\x09\x93\x59\x94\x87\xd3\x28\x2c\x1e\x8c\xc8\xa9\xb7\xd2\xee\xbc\x85\x1b\x92\x30\x9e\xce\x72\xb9\xee\xf3\xee\x52\x4d\x16\x80\x9f\x71\x1c\xed\x89\xac\xce\xc7\x8a\xb3\xd8\x40\xb2\xfa\xd5\x76\xc7\x7e\xb5\xdd\x59\xf6\x6a\xbb\x73\x0a\x3d\xe0\x5d\x35\x85\x7f\x95\x0c\x79\x01\xed\xd6\x63\xd8\x13\x83\xe7\x08\xe2\x1b\xb8\xb8\xd0\x93\xe3\x57\x95\x6b\x32\xd3\x11\xa3\x63\x01\x7f\x90\x25\xd1\x2c\x67\x90\xa7\x7e\x9c\xe1\x4b\xae\xe1\xa2\xa0\x73\xc3\x3e\x9a\xf6\x84\x19\x7a\xde\xc5\x83\x02\x93\x84\xc9\x05\x4b\x2f\xd3\x30\xcf\x59\xfc\x6f\xe2\x19\x52\x20\x9a\xfa\x90\x2f\x93\xbd\x43\x5c\x87\x63\x3f\x8e\x59\x44\x67\x1e\x36\xff\x7c\x53\xf6\x19\xf9\x01\x93\xe3\x60\xe8\xad\xc3\xe5\x82\x1f\xa4\x21\x85\x7d\xc0\xd7\xf6\xd0\xc9\x8a\xb5\x1d\xc8\x55\x94\x1f\xbe\x10\xc0\xd7\xaf\x50\x4c\x27\x11\x66\x1c\x10\x88\x63\x8c\x5d\x68\xf8\x0d\x79\xb6\x57\x3c\x5f\x90\xb1\x41\xad\xa3\x83\xda\xd3\xac\xb2\x88\xca\x8a\x1b\xb6\x7f\x9f\x08\xf9\x77\x4a\x8f\x25\xd3\x74\x25\x36\xb0\x85\x0c\x31\x83\x91\x56\xcf\x12\xd7\x9e\xa0\x19\x0b\xd6\xc3\x5d\xe8\x40\xd3\x6c\xab\xb0\x44\x56\x81\x2d\xab\x1d\x2b\x1e\x19\x5a\xad\x87\x75\xad\xcb\x13\xc3\x9b\x72\xdf\x1b\x12\x7d\x3f\xd8\x4f\xd8\x33\xd7\x2e\x04\x7f\x21\xfe\xdb\xdc\x05\xa7\xd3\x6e\x23\x13\x58\x39\x2e\x3c\xfc\x77\x71\x25\xc7\xa9\xfb\xf8\x71\x11\xa7\xb0\x0a\xa7\xb2\xef\xee\x15\x98\xd5\xbc\x01\x5d\xd9\x61\x73\xa9\xe6\xdd\xfa\x62\xbe\x23\xb7\x20\x6f\x93\xc0\xaf\x73\xde\xf6\xb8\xdb\xe6\xe5\xae\x69\x49\x99\x46\x53\x33\xa5\x98\xd7\x1b\xc0\x95\x23\xfb\x21\x8e\x53\x50\xd0\xeb\xbc\x19\x20\x76\xae\x74\x62\x2b\xfc\x46\xdd\xbd\x6b\x83\x0a\xcf\xc3\x85\xb1\xbb\x9d\x6f\xdb\x6f\x34\x76\x61\xfc\xfa\xfd\xdb\x3a\x3f\x4f\x8f\xed\x62\x4b\xdd\x6c\xf3\x02\xdf\x85\xaa\x65\x7f\xce\x15\x4e\x66\xff\x7e\xfc\xf6\x0d\xf0\x9e\xf9\x71\x00\x47\xbf\xff\x8a\xbf\x27\xfe\x02\xc6\xfe\x05\x33\xc2\x04\xc8\x73\xe4\x88\x5d\x30\x7a\xfd\xbb\xb5\x05\x59\x62\x3e\x16\xa6\x40\x1a\x74\x05\x91\xb3\x39\xbe\x78\xcd\x99\x1f\x90\xc2\xac\xec\xa2\x31\x96\x8a\x30\x78\x6b\x6d\x98\x5c\xc9\x29\xa7\xb0\x35\x8d\xcd\x05\x40\x0f\xdf\x66\x9a\x11\x08\x44\x06\xfa\x60\xf5\xc3\x8a\x97\x09\xc5\x02\x0e\x42\x28\xc5\x6a\xd4\xc5\x30\x1e\x8b\x74\x8d\xfa\x41\x44\x71\xaf\x03\x4b\x11\x20\x92\x00\x0d\x77\xee\xdd\xbb\x0e\x0c\x35\x0e\x0f\xa0\xf3\xc4\x46\xa1\x1c\xfb\x20\x1a\xf8\xc3\xf3\x42\xbf\x0d\x89\x0a\x3d\x55\x48\x3e\x9e\x30\x14\xeb\xca\xda\xea\xb0\x9c\xbe\x82\xc4\x20\x23\x76\x81\xf7\x45\x54\x71\x4b\x01\x34\xa4\x7f\x58\x2a\x49\x6f\x64\xc9\xb3\xc5\x3b\x42\x6d\xa3\x18\xb9\xe1\xaa\x22\x54\x61\xe9\x7d\x47\xf9\x49\xc7\xed\x9c\x94\x7e\x33\x9b\x17\x3d\x87\x92\xcb\x98\xa5\xda\xf3\xb1\x22\xbb\x95\xee\x68\x92\x4b\x6f\x57\x09\xc5\x1f\x45\xca\x59\x65\xd1\xe8\x4b\xc1\x5b\x42\x36\x6d\x3b\x54\x22\xdb\xf6\xed\x5c\x8f\x7e\x23\x91\x79\x38\x4c\xe2\x97\xb3\x3c\xaf\x0d\x7d\xf8\x98\x1c\xe4\xfd\x1b\xd7\x3c\x8d\xe2\x5f\x60\xe1\xdb\xfe\x8b\x79\x58\x14\xa3\x88\x8a\x75\x8d\xfb\xc4\x67\x8f\xff\xdd\x03\xc8\xb1\xab\x1a\x3b\x8d\xfb\x7e\x90\xa4\xb1\xf0\xd9\x5d\xed\x5a\x77\x25\xcd\xcb\x86\xf5\xcd\xfa\xa2\x5a\x58\xde\xa9\x37\xfe\x80\xd5\xaa\x92\xe4\xc6\x6a\xa5\x0e\x21\x9c\x6f\xd6\x19\x84\xfe\x57\x98\x59\xff\xc6\x20\xb6\x77\xb8\x0a\xd1\x63\x7f\xdb\x25\x86\xe5\x70\xb0\x5b\xe7\x25\xb4\xe8\x99\x70\x7b\x89\x86\x2a\x61\xa9\x3a\x36\xe2\x75\x6d\x3c\xad\x29\xbf\xac\xa9\x02\x64\x05\x81\x4c\x00\xfe\x08\xf3\x71\x32\xcb\xb5\x6f\xb9\xba\xa6\x1f\x5f\x57\x71\x19\x0e\x75\x6d\x29\x98\x29\x1b\xa1\xe5\xe6\xdf\xc2\x78\xcc\xd2\x30\x67\x81\x0e\x42\x49\x6b\xc7\x4b\x3f\x63\xaa\xb0\x5f\xeb\x4a\xbb\x63\x80\xf4\x87\x4b\x3d\xcb\x61\x01\xc3\xb1\xab\x9f\x65\xb1\x3f\x61\x75\x9e\xd5\xbb\x15\x45\x97\xfb\x80\x95\xa5\xb4\xfb\xdb\x30\x1f\x1f\x49\xfe\xaa\xdc\xe4\x54\x14\x5d\xea\x2c\x57\x95\x52\x15\x35\xb5\xea\xf8\xf4\x71\x45\xd9\x65\x8d\xe8\x52\x86\xa7\x5d\x36\x5d\x26\x1d\xb7\xdb\x4f\xcb\x65\x97\x7b\xe5\x15\x85\xbe\x8b\xe0\xe2\x78\x0d\x78\x6b\xe4\xcf\xe9\x97\x28\xb9\xc4\xa7\x63\x1f\x44\xbc\xd4\xac\x2f\x03\x9f\xf6\xc5\x6b\xb2\x5a\x6e\x6b\xdd\x10\xce\xd7\xaf\x95\x80\xda\x6e\xcb\x8f\x17\x3b\x37\x42\xed\x7d\x1a\xb2\x38\x97\x4f\x8e\x2a\xc5\xc5\xf3\x95\xf1\x33\x81\xad\x82\x63\x98\xc9\xf1\x37\xde\xdf\x61\x92\x33\x1c\x87\x51\x60\x29\xe6\x98\x82\x21\x8c\xe8\x1d\x1f\xc6\xfd\x48\x59\xdc\x1a\x26\xb3\x38\x97\x15\x28\x9e\xe3\x83\x07\x54\x9c\xee\x09\xac\xaf\xd6\x64\x16\xbe\xf3\x27\x75\xa9\x78\xdf\xa0\x18\xa9\xb1\xa3\xde\x16\x28\x91\x5e\x92\xf1\x3a\x06\x22\xa6\x38\x16\xd6\x62\x09\x4e\x92\xbc\xa7\x76\x8f\x22\xea\x4a\x0f\x1a\xa3\x88\xcd\x1b\xd2\x5c\xd6\x8f\xc2\xb3\xf8\x30\x67\x93\xac\x07\x8d\x21\xe3\x5c\xdb\xd0\xce\x09\x83\x20\x8c\xcf\xde\xb0\x51\xde\x83\x76\x21\xf5\x63\x78\x36\x36\x93\xb5\x79\x47\x4f\xc4\x75\xa1\x0d\x29\xe5\xfb\x51\xce\xd2\x18\x6d\x03\xb0\x8f\x1a\xaf\x89\x9f\x9e\x85\x71\x0f\x1a\x6d\xf0\x67\x79\xd2\xd0\xdb\x58\x4d\x86\x15\x39\x81\xab\xeb\x35\xfc\xd4\x76\x5b\x49\xcc\xde\x8f\x78\x0d\xe7\x44\xbc\xa3\xbc\xe9\x44\xb2\xdf\x86\xee\xdd\xb4\x7e\xaf\x0e\xb3\x6c\xec\x4f\x99\x73\x33\x68\x6e\x75\xe8\x5d\x0e\x4d\xd8\xd1\xd5\x64\xd3\x51\xfb\xa9\x7b\x33\xd2\xa2\x8f\x56\x61\x4e\xa9\xbc\x34\xfe\x2d\xc4\xf0\xcb\xf4\xf1\xc1\xcf\x32\x86\x91\x72\x2f\x42\x1f\x3e\x71\x6e\xfe\x04\x4d\x98\x52\xb2\x8c\x39\x9a\x27\x94\x85\x4c\xf0\x49\xba\x70\x04\xf0\x87\x9c\x35\x6a\x29\x34\x48\x92\xc8\xdb\xa8\x6d\xfb\x08\x3d\xcc\x20\x87\x45\x11\x46\x3b\xe5\x6d\x4c\xa5\xb7\xb3\x30\x6f\x64\x78\x44\x15\x85\x2c\xd0\xd6\x92\x45\x9e\x04\x19\xc8\xcf\x40\xab\xc4\xb6\x2b\x23\xf8\x8a\x22\xeb\xfb\x66\x7f\x21\x49\xc1\xa7\xcd\x7e\x9e\x00\x06\x57\x87\x30\xce\xc2\x80\x59\xa5\xfc\x8c\x84\x44\x8a\xb7\xc2\x02\x15\x99\xa2\x7c\x17\x7c\x5f\xee\x6d\x85\x99\x58\xcb\x82\x5b\xd5\xed\xfd\x7b\x67\x8d\x81\x4a\x3d\x3f\x21\xb9\xa5\x13\xd6\x3a\x69\x82\x7a\xe1\x0a\x30\xb8\x80\xaf\xef\x03\xcd\xd5\xa5\x9c\x9d\xc1\x30\x99\x4c\xc9\x51\x15\x17\xf6\x78\xa7\x75\x98\xa9\x99\x95\x80\x62\x1d\x83\x5b\x64\x95\x75\xa7\xd4\x6b\x7a\x78\x44\x96\x9c\x03\x3a\xa6\xc1\x20\x63\x1c\x21\xf1\x2a\xe9\x06\xf8\xc8\x1a\x37\x40\xe7\x78\xcc\x20\xe4\x12\x5d\xac\x5c\x2c\xe0\x13\x9b\x7c\x6e\xb2\x29\x44\x76\x03\xbc\x64\xfd\x60\xfd\x10\xfd\xa6\xe8\x5f\xce\xb5\x91\x9f\xe5\x6b\x72\x0d\xaf\x4e\xef\x25\xfd\x9b\x88\xca\x12\x08\xad\xd1\xdd\x54\xda\x59\x9a\xe5\x9a\x83\x66\xc0\x58\x4b\xea\xd5\xd4\x5f\x59\xf2\x99\x7d\xb8\x1b\xc6\x31\x20\x9a\x12\x90\xc2\x54\x19\xbe\xb7\xd9\x94\x76\x4c\x8e\x74\xb0\x2f\x6c\xb6\x68\x75\x96\x5e\xf3\x5b\xf4\xa9\x35\xc8\xc2\x32\xaa\x8a\x15\x32\x94\x7f\x6b\xb1\x92\xa9\x82\x32\xc1\x72\x80\xcd\xe5\x26\xef\x8a\x2e\x25\x53\x55\x31\x25\x16\x55\x11\x99\x52\x70\xa5\x6d\xc3\x60\xca\x3d\xad\x92\x63\x32\x5f\x26\xc8\x02\x21\x69\x94\x94\xc9\x3f\x64\x06\x9f\x24\x2a\x83\x7f\xc8\x0c\xc9\xfe\x2a\x53\x26\xa8\x02\xd6\xde\x47\x94\xd1\x69\xaa\x18\x3a\x6b\x15\x31\x42\xea\xce\x2d\x54\x14\x55\x1a\x30\x0f\x4e\x1a\x34\x36\x0d\x0f\x1a\x45\xf2\xf3\x34\x49\x69\xfc\x2d\xe9\x89\x1f\x92\x72\x2a\x87\x65\xfc\xa7\x24\x08\xff\xcd\xfb\xcf\xff\xf2\xee\xf2\xbf\xb2\x67\xf8\x5b\xf7\xa0\x81\xba\xa5\xb4\xf6\x93\x8d\xe8\x70\x27\xea\x04\x42\x63\x2f\x1a\x6c\xf1\x1d\x8b\x47\xe5\x0a\xa7\x44\xba\xec\x97\x2b\x4f\x0e\x6b\x99\xc3\x4a\xcc\xe8\x7a\x36\x37\x69\xd3\x73\x4e\x09\x53\xab\xd5\x3a\xa8\xc9\xde\x65\x05\xb0\x9a\xab\x8d\xf5\xb6\xc0\x84\x7a\xe5\xb3\x99\x8b\x16\x2c\xcd\x53\x5a\x6e\xda\x1c\x63\x09\x43\xe3\x83\x76\x48\x46\x67\x60\xd7\xde\xc7\xa6\x2c\x76\x61\x4f\x9e\x26\xa9\xe8\xb3\xe8\xbe\x40\x7a\x9a\x51\x33\xcf\xa0\x87\xcb\x85\x4e\xb1\x12\xba\x55\x95\xb5\x10\x2f\xe3\x74\x44\x16\x13\xa4\x50\x90\x8c\xef\x94\x71\x84\xad\x9b\xc0\x55\xda\x30\x8e\x79\xec\x46\x90\x47\xe4\x69\xa5\xc1\x1c\x55\xe4\x36\xf5\x30\xcd\x8f\x57\x1e\xcd\x31\xd7\xc0\x92\x50\xbc\xda\xd8\xd0\xa2\x10\xa3\x7b\xa3\x38\xa5\xd9\x3a\x64\x59\xd6\x62\xf1\x45\xeb\xdd\xfb\xd7\x07\xfd\x83\x77\xbf\xa3\x75\xea\xfd\x69\x9a\x04\x33\xe1\xa2\x6c\x0f\x9c\x7e\x8a\xb1\x10\xbf\xac\xac\x48\x5a\x7a\xe9\x8a\xdb\xa1\x1b\x6f\x4f\x7e\x6c\x22\xee\x7c\x13\xb1\x71\x75\x9d\xbc\xe2\xac\x60\xc9\xd4\xa5\x7c\xe0\xde\x04\x9c\x10\xde\x4b\x95\xc1\x95\x01\x1a\x0b\xc0\x12\x26\x5a\x15\x9c\xb1\x6e\xdc\x01\x34\xb1\xf2\xfc\xd0\xee\x57\xd1\xee\x57\x25\xaa\x58\xc6\xef\x60\x78\x0c\x45\xe0\x2e\xa0\x19\xaa\x84\xf7\x43\xfd\xff\x76\xea\x3f\xe7\xb4\x94\x8d\x5c\xf4\xfc\x56\x65\xcc\x42\x51\xdd\xf4\x75\x8e\x1e\x2a\xe1\x87\xdc\xd1\xeb\xa4\xbb\xf4\xe6\xf3\x8a\x5c\x10\x2e\xbb\x4a\x75\xb6\x5d\xd7\x2d\xdd\xcc\x2e\xf5\xe1\x6a\x9a\x78\x2e\x89\x00\xcb\xe6\x6c\x48\x7b\x99\x3c\x5d\xd8\xd7\xd3\xf7\xee\xf1\x4c\x11\x81\x06\x86\xe8\x2f\xca\x29\xbe\x91\x55\x66\x4e\x55\x61\x7d\xb7\xbf\x95\x3f\x4c\x85\xff\x9b\x30\x66\x7e\xea\x28\xe3\x2b\xec\xc8\x38\xcc\x5a\x7d\x65\x67\x26\x2d\xb3\x50\x77\xa1\xf2\x86\xe3\x53\xd2\x43\xfc\x94\xf9\x47\xb9\x9f\x1a\x17\xf6\xea\xb2\x9e\xc0\x61\x94\x74\x11\x7d\x16\x8f\xed\x79\x95\x83\x38\xb8\xae\xc2\x3b\xff\x9d\xaa\xc2\x93\x96\xb7\x42\xaf\x26\xcd\x66\x78\x9d\xea\x66\x94\x37\x73\x6a\xea\xeb\x57\xeb\x93\x2b\x5e\x6d\x15\x4b\x40\x02\xde\xdd\x85\x8e\xeb\xda\x14\xa2\x58\xe7\x1f\xfc\x5c\xc5\x91\xb1\x3a\xd0\x81\xa6\x91\xa0\xf0\x42\x80\x06\x56\x73\x0f\x16\x12\xb3\x39\xec\xc2\x26\x4f\xe0\x7f\x17\x04\x33\xbb\x0c\x91\x7f\x0c\x74\x0c\x43\x69\x3f\x63\xd0\xee\x15\x88\xd0\xd9\x31\x31\xd9\x2b\x60\xcd\x13\x8f\x13\xd1\x6e\xaf\x90\x39\x49\x2e\x54\xe6\x0e\x0c\x52\xe6\x9f\xef\x98\x6d\x75\x8a\x6d\x75\xf1\x65\x22\xaa\xb0\xea\x59\xa2\xba\x61\xac\x6f\xd8\x82\x7d\xa5\xa6\xc1\xcd\x7d\x5b\xf9\xe4\xd5\x4a\x91\xd3\x62\x68\x23\xea\x63\x81\xdf\x77\xc8\x24\xa4\x38\xed\x96\x7a\xbf\xba\xc5\xb4\xbb\x7d\xbf\x5c\xf8\x52\x89\xf1\x52\x6b\xf5\xbb\xc1\x58\xfa\x90\x0e\x27\x93\x59\x4e\xae\xfe\xeb\xb0\x1e\x22\xd6\xc8\x1b\xeb\x82\xa0\x8e\xbf\xf4\xb3\x30\x33\xc4\x15\x82\x74\x28\xd0\xb5\x9e\x31\xfc\x5b\xf3\xd7\x80\xfd\x19\xb2\xf4\xd5\x2c\x45\x16\xa6\x0d\x5d\x17\x1e\x8a\x52\xf3\x36\x6c\xca\x9f\x1d\x17\xb6\x60\xdb\x2b\x16\x59\xe8\x22\x0b\xab\x88\x01\xc1\x00\x58\x51\x64\x61\x17\xa9\x85\xf2\xc8\x80\x02\x9b\x30\xe7\xc5\x9e\x94\x21\x3d\x32\x20\xc1\x26\xef\xf5\x16\x3c\x51\xdb\x49\x45\x1c\x24\xd6\xea\xa2\x1c\x8b\xff\x65\x25\xf9\xbc\x2d\x9d\xfb\x73\xda\xec\x1a\x39\x0b\x9d\xb3\xe8\x68\xb8\xeb\x2c\x01\xd7\x0b\xd5\xed\x9e\xe2\xb9\x30\xf3\x14\x42\x9e\x42\xc0\xad\x10\x7c\x58\xb3\x5b\x23\xf7\x2a\x41\x14\xa4\xe0\x8f\xc5\xe9\xae\x17\xa7\x72\xa9\x6e\xb1\xd4\xf6\x4e\x35\x12\xce\x63\x9c\x7e\x82\x29\x37\x15\x0f\xd0\x64\x05\x23\x7b\xa1\xb3\x69\xca\x3f\xa9\xe2\x0e\xb5\x2c\x9a\x8c\x55\xbd\x1a\x56\x4e\x06\xcf\x98\x16\x30\xdf\xa9\x9b\x19\x9e\x39\x47\x16\x3b\xb7\x58\x5b\x07\x2b\xae\xad\xb6\xfc\xa9\x59\x5a\x97\x3e\x8e\xfa\xee\x0b\xd5\xe0\xae\x16\xaa\x57\x7e\x1a\x84\xb1\x1f\xdd\x7e\xad\x32\xd6\x03\xfa\x79\x0e\x0f\xd5\xa2\xd1\xc5\xf9\x4a\xeb\x87\x38\x5b\x34\x16\x86\x52\xf9\x85\x2e\xbf\xb0\xcb\xcf\xbb\x95\xf0\xb9\x3c\x98\xdb\x80\x2b\x0b\x2e\x78\xc1\x45\x01\xa2\x5d\xad\xbc\x3e\x49\x1a\xe9\xd7\x21\x39\x8b\x33\xf5\xc6\xa5\x76\xad\x92\x59\xe7\x9c\x0b\x51\x62\xc9\x6a\x5b\xf0\x04\x9b\x90\x90\xff\xb7\xac\x66\xf2\x67\x77\xe9\xc2\x26\x7e\x76\xbf\xf5\x1a\x77\xcd\x4a\xd5\x55\x92\xa4\x5b\x29\x6e\x57\x59\x22\x7f\xac\x6f\xdf\x78\x7d\x33\x97\x84\x82\xe4\x5f\x71\xed\xfb\xb6\xeb\x54\x91\x97\x38\xeb\xaf\xba\x78\x49\xee\xf3\xcc\x19\x61\xaf\x68\xb3\x78\x96\xb1\x60\xc9\xc2\x86\x26\xb7\x54\x4a\x09\x71\x51\x4a\x08\x73\x2e\x5c\xb4\x03\x9e\xe1\x2c\xcb\x93\x89\x63\x08\x28\x33\x90\xf4\xb0\x20\xc9\x0a\x67\x3a\x7c\x31\xac\x17\x76\xca\x0b\x8d\x84\xd2\x12\x39\xc6\xb9\x92\x63\x49\x46\x6d\x30\x4a\x58\x6d\x5a\xa0\x2c\x77\x10\x6a\x19\xba\x72\x9d\xb6\x5b\xb5\x00\x2f\x7d\xe1\x7a\x37\x0b\x70\x38\xb1\xc8\xde\x17\x07\x77\xfd\xc3\xb7\x1f\xde\x7f\x3c\x3e\x78\xdd\x7f\xfb\xfe\xf5\x6f\x6f\x0e\xfa\xed\x7e\x94\x04\x7e\x36\xee\x87\xd9\xbb\x30\xea\xf7\xeb\xac\xa6\x3b\xee\x9d\x80\xef\xeb\xc3\xc7\xaa\xd8\x47\xb1\xb3\x3a\xa8\xf5\x10\xea\x68\x28\xbf\x08\xca\xd7\x76\x1a\xdf\x69\xde\x55\x1b\xb7\xe8\x79\x25\xbc\xf5\x50\xeb\xd2\xa5\x6c\x7d\x97\x6f\x09\xf6\x16\xbd\x54\x30\xd6\x43\x61\x1b\x8f\xc3\x31\xaa\x52\x56\xdb\xbd\xf6\x5d\xc0\xbe\x45\x1f\x6d\x40\xeb\x21\xf3\x48\xd0\x29\x9b\x24\x49\x3e\xae\x9f\xb1\x8f\xee\x06\xfc\x2d\x7a\x5b\x04\xb5\x1e\x42\x8f\xfb\x7d\xf1\xba\xe2\x38\x49\xa2\x3c\x9c\xbe\xe2\xd2\x3c\xae\xe7\xe1\x67\xdb\x6b\xce\xdb\x27\xfd\xfe\x2c\x0f\xa3\x3e\x5e\xb3\xfc\x96\x87\x51\x3d\x23\x75\xb6\xd7\x6b\xe2\xa9\x68\xe2\xb5\x9f\xfb\xd7\xb4\xf0\x74\xbd\x16\x9e\x89\x16\x3e\xcc\x52\x46\xb1\x15\xeb\x9b\xc0\xe7\x36\xf6\xcb\x30\x1d\x66\xca\xcf\xb2\xf0\x0c\x5f\x5c\xe8\x9b\x16\x11\xd7\x03\xbe\x54\x7a\x04\x2e\xfa\xfa\xda\x81\x70\x73\xd3\xc5\xf8\x5d\x32\x7e\x87\xe9\x11\xec\x24\x3c\xdd\xd1\x70\xce\xd9\x02\x03\xe0\x52\x94\x11\xf8\x82\xea\x69\x29\xe2\xd5\xd8\xcf\xde\x5f\xc6\xf2\x6e\x91\x2e\x9d\x64\x0c\x8b\x73\x86\x61\x25\xc0\x88\xa6\xa2\x62\x83\xe0\xd7\x0e\x5c\xe1\x7f\x56\x28\x1f\x1d\x1e\xae\x4f\x06\x2a\xaf\x22\x3f\xcb\x8a\xde\x12\xcc\xc8\x17\xc6\xed\x66\xc8\x32\x15\x4a\x43\x9a\xd4\x55\x7a\x56\x11\x76\x64\x65\xb2\x04\x2c\x1b\xa6\xe1\x14\xc3\xdc\x51\x29\x24\x8b\x4e\x6e\xe9\x67\x99\xe8\x90\xa6\x2a\x9d\x8f\x11\x3e\xbb\x37\xf3\x87\x49\x3c\x0a\xcf\x66\x2a\x8e\x73\x3a\x63\x3b\x48\xd4\xfb\xf8\xbe\xf0\x3e\xa7\xb6\x2e\xee\x9a\x55\x2f\xd3\x30\xb7\xaa\x55\x3f\x61\x94\x3d\x37\x6a\x9e\xb3\x85\xf9\xed\xee\x98\x04\xd7\x14\x7d\xa5\xa3\xfb\x21\xe1\xf2\x84\xec\x89\x20\xcb\xfd\x3c\x1c\x7e\x90\xa4\xe4\xe8\xea\x6c\xb7\x4c\x7c\x03\x90\xe6\x12\x13\xa4\x4b\x7d\xb6\xe0\x2e\x83\x62\xa3\xb0\x23\x51\x37\x4a\xec\xe0\x4b\x2d\xc7\x7e\x72\x27\x0d\xdf\xba\x1e\xf4\x73\x36\x99\x76\xad\xb7\x62\x98\xf5\xca\x8f\xa2\x57\x63\x36\x3c\x77\xc2\x38\xcb\xfd\x98\xb3\xac\x01\x56\x76\xf7\x9e\xca\x06\xf9\x23\x19\x59\x05\x91\xc7\x95\xf7\xc4\xe3\xc5\x94\x91\x07\xc5\xfb\xaf\xfc\x38\x4e\x72\x0c\xf8\x0e\x3e\xd9\x25\x81\x9f\x81\xaf\x08\x7f\x9f\xc6\xc3\x44\x6d\x9a\x64\x59\x38\x88\x98\xd1\x00\xf9\x9f\x76\x32\x16\x8d\x3c\x04\xa6\x50\xe3\x49\x76\xeb\x1f\x19\x3a\x08\x19\x4a\x14\xf8\xee\x00\xc6\x7e\x16\x37\x72\x8a\xc0\x1c\xc6\x61\x1e\xfa\x51\xc8\xb7\x06\x4d\xc8\x66\x53\x96\x3a\xae\x55\x82\xe2\xd3\x13\x6a\x4a\x85\x8e\x22\x33\xa8\x22\x7e\x5b\x11\x17\xbf\x7e\x85\x52\x9e\xee\x25\xec\x51\x72\x0f\x38\xc6\x3b\x76\x8f\xc5\x33\xce\xcc\xc9\x66\x83\x57\x34\x76\x88\x16\xfe\x96\x5d\x15\xc0\x75\x06\x59\x81\x59\x61\x2a\x0b\x99\xf1\x8c\x28\x55\x39\x34\x47\xbc\x2c\xdf\x0b\xa5\x2c\xc3\x7d\xc6\x64\x96\xe5\xc0\x42\x34\x02\x1d\x30\xac\x4c\x8f\x47\x64\x13\x1e\xfa\xef\xbe\x0f\x9b\x50\xc2\x05\x49\x25\xb1\xb7\xce\x5b\xc4\x3c\x25\x41\xe6\x18\x08\x5a\xe8\x9a\x33\xe5\x0b\x18\x91\x36\x7b\x3a\xd6\xa2\x26\x8e\xf9\x2c\x1c\xa5\x8c\x07\x52\x3e\x88\x77\xe2\x60\x8a\x1a\x19\xa6\x11\xae\xe4\xd4\x33\x88\x2b\xf0\xcb\x58\xfe\x41\xa2\xf0\x7e\x04\x7b\xd5\xe9\x35\x03\xa4\x71\x6b\xf5\xfb\xd8\x13\x5c\xe0\x74\x11\xf9\x00\x1c\x1d\x88\x8d\xc2\x88\xbd\xbf\x60\xe9\x45\xc8\x07\x84\x14\x08\xf4\x05\xa6\xfe\xf1\x49\x7c\xf0\xe1\x08\x97\x31\xfa\x32\x2d\x02\xc9\x1b\x18\x2a\x1c\xbd\x1b\x6b\x88\x2d\xdf\xb4\x5d\x5a\xa3\xb6\x0a\x0c\xb7\x46\x5d\xce\x48\xa7\x78\x3c\xc8\xfb\xfe\x32\x99\xaf\x85\x3f\xd9\xa1\x88\x63\x99\xb5\x20\x90\xd9\x12\x1d\x4c\x2e\x6e\x0d\xe1\x32\x0c\xf2\xf1\xad\xa1\x8c\x19\x3d\x6e\x5c\x1b\x0c\x3a\x51\xc7\x47\x0e\xda\x92\xf3\xc6\xa0\xa4\xd1\x66\xc6\xa6\x3e\xc6\xdb\x5d\x6f\x84\xc4\x13\x23\x10\xc1\x27\x72\xb6\x1e\x1c\xce\x2f\x1c\x4a\x32\x1a\x65\xec\x36\xb4\x41\xb2\x84\x39\x9b\xa0\x55\xd1\x7a\xb3\x46\x3c\xbe\x02\x7a\x05\x74\x17\x80\x2e\x53\x7f\x3a\x65\xe9\x5d\x80\x1a\xce\xd2\x6c\xcd\xc1\xba\x9d\x38\x40\x86\x59\xa7\xd9\xdb\xc8\x11\xea\xb7\x78\x54\x34\x4c\x12\x3c\xdd\xca\xd7\xa3\xe1\x5f\x47\x9a\x88\x09\x0c\x30\x15\xde\xb9\xfe\xef\xe8\x8f\x9c\x31\x6b\x41\xf2\xe3\x05\x52\xc4\x5f\x44\x89\x1f\xac\x07\x22\x4d\xfd\xc5\xfb\xd1\xca\x47\x20\x35\xb4\x8c\xc5\x9b\xca\x75\xbb\xa0\x7c\xa8\x7c\xf7\x29\x2a\xc6\xf3\x16\x82\x7c\x6d\xb2\x9f\x8a\xbb\xc0\x59\x1c\xae\x27\xbe\xfd\x78\x81\x6c\x44\x7c\x14\x66\xfb\x71\x38\x41\xa3\xd2\xfd\xdb\xaf\x71\xbe\x84\xf5\x7a\x96\xfa\x6b\xcf\x37\x3d\x5b\x14\xbc\x03\x3f\x0b\xe3\xb3\xf5\x47\xda\x39\x69\x30\x3f\xc3\x37\x52\xfc\x6f\x33\x8c\xd5\xcf\x64\x96\x1b\xc9\xf2\x33\x42\xf3\xb5\x06\x51\x1b\x97\xb9\x24\xbd\xed\x9a\x3b\x0a\xa3\x9c\xa5\xef\x66\xd1\x7a\x13\x97\x13\xd9\x08\x57\x89\xc9\xe6\xd3\x27\xa9\xa3\x90\xfa\x6e\xac\xf1\x9d\xb6\xa5\x1f\x7e\x81\x79\xa7\x07\x6d\x0f\xe6\x5d\xfc\xb3\xa0\xaf\x05\xff\xa2\x5b\x3b\x53\xfe\x7f\xe1\x22\x8f\x67\xeb\x5c\x5c\x18\xc5\x12\xfb\xe5\xaa\xa0\xdb\x34\xa0\x07\x8d\xf2\x52\x4c\xe5\x0c\x7d\x81\x12\xcc\x85\xff\xcb\x95\xb9\xec\x4a\xdf\x54\x15\x0c\x7a\x4f\x84\x37\xbd\xd9\x19\xdf\xc9\xfd\xf8\x3e\x6c\x3d\x84\x30\x3b\xca\x52\x78\xb8\x75\xea\x3a\x6e\x25\x8f\x09\x4e\xa9\x66\xe7\x47\xed\x76\x91\x23\xb4\xff\x11\x95\x58\xf4\x9f\xd5\xec\xa8\x1b\x51\x93\x09\xc8\xf7\x93\x18\xd1\x14\x8f\xf1\xc4\xb1\xa7\x79\x32\x65\x65\x38\x62\x9b\xa2\x4f\xa2\x84\xc7\xc7\x1b\x1c\xdb\xb7\xfc\x56\x98\xfd\xee\x47\x61\xa0\x1e\x90\x11\x50\xb7\xe8\xf6\xeb\x46\x30\xed\x27\x69\x36\x9a\x05\xe7\xc5\x6b\xde\xaa\x38\x6e\x1d\xa6\x22\xd9\x31\x5a\x33\xdf\xa8\xdd\xac\x1f\xd6\x0b\xb6\x75\x8e\xac\x4f\xee\xfb\xc8\x6a\xf2\x50\xfd\xe1\xd6\xa9\x26\x84\x1c\x6f\x51\x49\xed\xe7\x97\xb4\x54\x75\xda\x5b\xd1\x86\x2b\x7c\x3e\xc1\x2e\x38\x74\x3e\x05\xbb\xf2\xc4\xca\x3a\xea\xec\x2b\xdf\x56\x44\x46\x7d\x5a\x22\x90\xf2\xc0\x28\xb2\x63\xdd\xc8\x8a\x12\x8e\x19\x6e\x85\xbc\x67\xe9\x4f\xde\xb6\x07\x7d\xba\xc8\xee\xa7\x2c\x17\x99\xc5\x23\x32\x2a\x20\x20\xba\xa2\x90\x3a\x58\xed\x47\xf8\xb8\xb8\x78\xde\xec\xf1\x94\x4c\x06\xa3\x76\x78\x29\xd7\x83\xfe\x39\x5b\xd0\x41\x2c\xfe\xfa\x19\x6b\xd3\x07\x1e\xc3\xca\x57\xce\xe9\x59\x76\xd2\x17\x87\xc6\xfa\x8c\x1a\x53\xe4\x2d\xbb\x35\x03\x52\x96\x2b\x72\xd2\x8f\x71\x88\xce\xb3\xea\x8f\xd4\xa8\x57\xf2\xf1\xa0\xe8\x9d\x71\x8a\xf1\xf5\xab\x3c\x09\x39\xb3\x4f\x42\x24\x21\x5c\x3c\xf1\x6e\xf9\xd3\x69\xb4\x10\xcf\x69\x4e\x38\xd0\x53\x19\x90\x9e\xf7\xc2\x75\x5d\x41\x62\xf9\xb7\x95\xe5\x7e\xce\xd4\x3b\x58\x80\x41\x32\xff\x83\x36\xd2\xcd\x8e\xa7\xd3\xfe\x2e\xb6\xc5\xcd\x0e\x75\x58\x1c\x66\x72\x30\xf5\x9d\x32\x06\x53\x4f\x2f\xf3\x2c\x5d\xb3\xce\x09\xb5\x7f\xce\x16\x3d\x7a\x90\x86\x6c\xf4\x3a\x0c\xde\x26\xb3\x38\x6f\x58\x9a\x9b\x11\xd1\xb0\x50\xce\xd1\x83\x86\x9d\x9b\x4d\x03\x3f\x67\x2f\x5f\x26\x73\xc7\x74\x92\xeb\x41\x5d\x6b\xbf\x61\x85\x15\x9a\xa3\x82\x6b\xb5\xa7\x0b\xd5\xb4\x63\x42\x31\xa2\x0c\xa5\xd0\x97\x83\xa5\x47\x4e\x0e\x91\x39\x74\x9c\xd3\x30\xb3\x25\x53\x0a\xa5\x68\x30\xad\x62\x94\x44\x8f\xb7\x2d\x0b\x20\xb1\x22\xbf\x13\x5e\x6a\x8b\x69\x9c\x1d\x5f\x26\x33\x0c\xa2\xf3\x2a\x0a\x59\x9c\x7f\x64\x43\xc3\xfc\x86\x10\x1f\x24\x73\x89\xf5\xb5\x75\x1d\x39\xa7\x25\x1a\x18\x19\xc9\x1f\x64\xce\x20\x99\xb7\xf0\x90\x07\x9a\xaa\xaf\x2e\xbc\xc0\x23\xba\xaf\x5f\xc1\x2a\x47\xc7\x38\x54\x90\xfa\x26\x4a\x9a\xa8\x89\x51\xcb\x58\x7e\xc4\xe9\xe0\x98\x39\xe6\x4c\x50\x0d\x7b\xc5\x02\x72\x5a\xe8\x26\x8d\x12\x32\x50\x93\xb6\xc3\xb1\xd6\x33\x35\x5c\xf7\x76\x77\xa1\xd9\xe1\x5d\xd0\x63\x43\x69\x26\xb2\xf5\xa8\x56\x4d\xd9\xea\x69\x6b\x63\x75\x55\xc7\xa1\xa4\x3c\xd4\x70\x27\x65\x16\x39\x93\x63\xd7\x15\x63\xac\xc6\x0f\x73\xa6\x42\xdb\x44\xfc\xa7\xfa\x6d\x38\xfd\x13\x3b\x4a\x14\x8e\x78\x11\x26\x12\xcc\x32\x25\x6d\x4e\x97\x2e\x65\x99\xf5\x4a\x9a\x98\xae\x57\xca\xaa\xac\x47\xca\x5d\x45\x2d\xca\x30\xeb\x68\x0d\x4d\x17\xd7\x69\x16\x45\x46\x61\xec\x47\x1f\x54\xbf\x8d\x9a\x0f\x1e\x28\x7a\xe8\x9f\x32\x3a\xd2\x9e\x4a\xa0\x1a\x46\x38\x32\x16\xe7\xe9\xc2\xe4\x15\xf9\xc4\xed\xe6\xd6\x37\x8e\x4b\xd0\x5a\x3a\x24\x24\x31\x0d\xf4\x64\xfb\x3b\x46\x5f\xc6\x7e\x66\xf6\xc4\xe8\xd8\x83\x07\xd6\xb7\xbc\xe0\x2c\x71\x46\xb7\x96\x35\x86\x4a\xab\x15\x25\x5b\x52\x3f\x34\x0a\x89\x0d\x8a\x51\x48\xa4\xd8\x90\xe4\xd6\xc4\x02\x26\x13\x2d\x7e\x14\x67\x3e\x46\x41\x99\x64\xb1\x88\xcd\x87\xdd\x82\x5f\x14\xfe\x8f\x36\x52\x46\x11\x4a\x30\x8b\x98\xbb\x1d\xa3\xa0\x99\x6c\x71\x4e\x32\xcb\x8d\xd2\xe2\x5a\xde\x10\x05\x68\x0a\xc8\xd2\x83\x0b\xae\x9f\x48\x57\x7c\xba\xc1\x8b\x30\x0b\x07\x61\x14\xe6\x0b\xe9\xe8\x82\x8f\x92\x31\x84\x7b\xd0\xc0\x32\x11\xc3\x0d\xd9\x38\x0c\x02\x16\x1b\x00\xf4\x81\x58\x43\x06\xc0\x32\x72\xf3\x64\xda\x83\xb6\x64\x18\xcf\xea\x9d\x6b\x0e\x3c\xc6\xcc\x8a\xfc\x9c\xfd\x1f\x15\xca\xda\xa4\x8a\xca\xfe\xa7\x1d\xe9\x1a\xc4\x7a\xa0\x86\xe8\xc1\x83\xeb\xb5\xe0\x0a\xab\x8a\x93\xfb\x23\xb1\xa7\xa3\xf0\x78\xa4\x05\x4b\xa8\xad\xb9\xfb\x8d\x00\x2f\x5c\x4b\x9c\x9b\x44\xd0\x8d\xef\x94\x0b\xfc\xd3\x2c\xb0\xd8\xb1\x17\x12\x7b\x9d\xa5\xf5\xbc\x5b\xab\x21\x54\xe8\x08\xdd\x4a\x25\xa1\x4a\x4d\xe8\x56\xe9\x09\x60\x2f\x65\x2f\xc8\x30\x58\x57\x16\x09\x7a\xb2\x15\xd6\xdf\x2a\x2a\x7c\xbb\x81\xdd\x33\x28\x2d\x63\x2e\x4e\xfc\xb9\xa3\xd1\x6b\xcd\x61\x53\x13\x69\x53\xce\xe2\x17\x52\xd0\x60\xbe\xfc\x4d\xca\xc8\x1e\x58\xd5\xb5\x6e\x02\x4d\x59\xbd\x07\x85\x16\x84\x2c\xd0\x50\x4d\xa5\xa7\x66\xec\xbf\x19\x5b\x9a\x64\x59\xd4\x90\x65\x41\x64\x11\xa3\x5a\x41\x97\x85\x41\x17\xa1\x7c\x59\x84\x59\x98\xba\x58\x0d\x65\x16\x15\x94\x59\x98\x4a\x54\x91\xe7\xc1\x10\x89\x2d\x2d\xde\x60\x57\x09\xaf\x0a\x0d\x4c\x12\xba\x46\x9a\x5e\x79\x46\x8e\x77\x3d\xc5\x8b\xa6\x6c\x27\xf7\xd5\xe8\x21\x88\xfb\xa7\xae\x53\x98\xf6\xa3\x24\x9d\xf4\xa0\xa1\xca\x61\x64\x70\x63\x2a\x6c\x42\x63\x3a\xa7\x58\xe0\x06\x27\x60\xaa\xdb\x50\x2b\xb2\x6b\x49\xc5\xb2\x92\xf4\xe0\x81\x90\xf2\xe6\x94\xfb\xb7\x74\x5a\x74\x5b\xae\x1d\x8a\x06\xd8\xc3\xb2\x96\xb6\x09\x8d\x49\x66\xe7\x91\xc2\x65\xe8\xb0\x86\x12\x2b\x7e\xdc\xc1\xb1\x8d\x82\xdf\x08\xc2\x0b\x63\x65\x33\x7b\x62\x38\x14\x6a\xa4\x6c\x38\xf6\xd3\x3c\x6b\xe6\xb4\x8d\x6d\x8a\x25\xaf\x61\x8a\xd2\x8c\x0e\x2a\x0d\xf2\x1a\x99\x29\x1b\x59\xaa\xf5\xc8\x31\x03\xd9\xc8\x7f\xa4\x5d\x5b\x5b\x31\x8a\xb4\xb2\x63\xee\x36\x34\x75\x3c\x43\x11\xac\x3c\x06\xb4\x06\xde\xd0\xbe\xe0\x8b\xbe\xe2\xb1\xb4\xb9\x2b\xd7\x15\x30\xcd\x7d\xed\xa9\xe5\xd4\x49\xec\xe5\x77\x36\xae\x56\x39\x57\x3c\xb9\xaf\x0e\x8b\xee\x9f\xba\xca\x48\xaa\x25\x3c\x3e\x0a\xbf\x61\x0d\x01\xb4\xa1\x0b\x14\x9c\x32\xd1\x6f\xa3\xbe\x7d\xc6\x6d\x7e\x4a\x03\x2c\xd7\x45\x67\xd1\x58\xe1\x36\xcf\xd9\x8d\x33\xa8\x82\x15\xff\xed\x62\xd5\x60\x14\xed\x30\xcb\x5f\xf9\xc3\x31\x7b\x15\x31\x3f\xad\xf3\x94\xbd\xfd\x4c\x5c\xec\xa8\xe2\xaf\x59\xc4\xf2\x3a\x27\xea\x4f\xb7\x9f\x17\xcb\xff\xca\xea\xbc\x84\x3f\x7d\xd4\x2e\x16\xfe\xbb\x5f\xe7\x02\xfe\xe9\xa3\x4e\xb1\xf0\xd1\x12\xc8\x5d\x41\x33\x8c\x1c\x8f\x53\x30\x03\x3f\xc6\xba\x30\xe4\x95\x45\xa8\x7f\x1d\x8a\x30\x0d\x2f\xfc\x9c\xe1\x6f\xc3\x2a\xc9\x8c\x23\x88\x27\x7b\x57\x70\xc2\xb7\x2f\x21\xcb\x4e\xd1\x89\xe8\x39\x5b\x34\x29\x2e\xe8\xd4\x0f\xd3\x0c\x83\x51\x71\xf8\x85\x58\xe8\x6f\x24\xd2\x8e\xa8\xad\xfd\x1f\x62\x9c\x3c\xd8\x35\xb6\xd6\x62\x3f\xb6\x0b\xa2\x2c\x08\x0b\x2f\xd8\x83\x36\xf4\x64\xaa\xda\xf0\xc8\x07\x72\x43\x3e\x90\x74\x2c\x24\x42\x26\x6d\x6e\x12\xf0\x9f\x05\x48\xf3\x74\x14\x37\x61\xba\x8d\x13\x2c\x79\x6a\xbc\xc8\xc9\x58\x4e\x3b\xb5\x93\xf6\xa9\x47\xc5\x4f\x3a\xa7\xe2\x98\xed\x6a\x63\x63\x6b\x0b\xf6\x83\x00\x26\x2c\x1f\x27\x01\x76\xfc\x93\xea\xe5\xa7\xd6\x86\xfa\x6d\x58\xd0\x0e\x05\xab\xd9\xbc\xb7\x53\x55\xf6\xa4\x11\x20\xa3\x35\x4e\xcd\xf2\xc4\x7c\x95\x15\x5a\x67\xc8\x0e\x26\xdf\x55\x97\x1b\x23\x8f\x99\x2c\x57\x5d\x2e\xb3\xe1\x1d\xe1\x79\x71\xc9\x13\x8c\xaa\x59\x7e\x6a\xf3\xe8\x76\x91\x91\x70\x90\xfe\x55\x17\x75\x81\x62\xd2\x0b\x0e\xff\x95\xe5\xe4\x4b\x97\x86\xdb\xc7\x70\xef\x43\x72\x44\xfd\xe9\x9c\x2d\x3e\x41\x98\xc1\x28\x99\xc5\xe8\x42\xfb\x13\xde\xd8\x7e\x82\x64\x54\xe4\xde\xca\xd9\x60\x73\x3f\xd6\x45\xce\xa7\x5f\x18\xbb\x37\x9b\x8a\xa9\xa4\x4a\x3f\xbc\x42\xa3\x6a\x31\x43\x28\xf4\xaf\x9f\x0e\xc7\x30\x12\xa1\x8b\xcb\x21\xde\x3f\x8a\x04\xdd\x0f\x11\xdc\x7d\xe2\xe7\xc3\x31\x0b\x40\x04\xdc\x45\x0d\xed\x53\xb3\xf3\xa9\x30\xc5\xfc\x2c\x4b\x86\x87\x22\xe8\x24\x22\x47\x66\xd9\x6a\xa2\xa9\x69\x85\x99\xc6\x79\x81\x98\x2d\x94\xd0\x6c\x9a\x0e\x62\xd8\xbf\x08\xd4\x09\x65\x9e\xe2\x5c\x10\xc6\xde\xb6\x5a\x60\x1e\x3f\x14\xc2\xa4\x36\x3b\xf8\x4a\xb5\xc4\x3b\x26\xc6\x15\xec\x73\xbb\x90\x4c\xbc\xc7\x67\x2c\x7f\xe7\xcb\x73\x84\xaa\xb8\x1a\x4f\x89\x89\xe0\xe5\x2c\x8c\xf2\x66\x18\x8b\xd9\xcc\xf5\x04\x32\xad\xcd\xf0\x3d\x2f\x06\x35\xbd\x60\x69\x38\x0a\xc9\x09\xf3\x80\x01\x79\x06\x6c\x71\x1c\x79\x53\xf4\x49\xa2\x16\x76\x75\xcb\xc2\x8c\xde\x83\x06\x69\x42\x0d\xb7\x6a\x16\x99\xb5\x2b\x28\x71\xbb\x10\x3a\x14\x97\xe1\x1f\x6c\x21\xcc\xca\x2b\x57\x8c\x27\xed\xaa\xf9\x14\xf8\xb9\x8f\x57\x3f\x9f\x26\xfe\xf4\xd3\xb2\xe9\x41\xdd\xbc\x82\x89\x3f\x45\xae\xe7\x7f\xf3\x04\xfe\x35\x63\xe9\xa2\x55\x15\xec\x56\x4e\x0f\x45\x6a\x9e\x52\x98\x1a\x0f\xed\x59\xc1\x61\x72\x8c\x0a\x8c\x7f\xc6\xf2\xb7\xfe\x94\xef\xc7\x9c\x89\x3f\x2d\x30\x3d\xf6\x60\x97\x57\x6d\xf5\xfb\xfc\xa3\xdf\xdf\xd1\x9c\xa9\xc8\xe2\xf0\x4a\xc8\xbb\x7b\x58\x45\x3a\xbb\xc3\xfb\xab\x5d\x68\x10\xd6\x0d\xd8\xd3\x3f\x7b\xd0\x18\xfb\xd9\xb8\x71\x8a\xd5\x7a\x84\xd9\xc4\x9f\x56\xf3\xba\x46\xb2\x62\x7c\x57\x71\xc4\xf5\xd7\x0f\x91\x74\xe9\xa7\xb1\x11\x4d\xe3\x8c\xe5\xc7\x6a\x53\xf2\x3b\x3a\xed\x95\x59\x22\xb0\xaf\x91\x62\x6f\x6e\x8c\x8c\x89\x3f\x25\x04\x8d\xb4\x80\x0d\x66\x67\xa3\x62\x82\xf1\x1d\x25\x67\x16\x22\x31\x4b\xfd\x9c\x7d\x48\xd9\x28\x9c\x17\x1b\x38\x63\xf9\x6b\x3f\x1b\xbf\xf2\x2d\x7c\xc2\x80\xc5\x39\x6d\x74\x8d\x82\x87\x71\xce\xd2\x8c\x21\x0d\xff\xc1\x16\x95\xe1\xa0\x42\xa3\x4c\x6d\xbc\xa6\xe7\x66\xd4\x52\x5d\x7e\x59\xac\x24\x0b\x6e\x31\xa6\xd4\xff\xa3\x2f\x87\xbe\x79\x44\x20\xdd\x40\x61\x7a\x24\x83\xcf\x88\xba\x0e\xa0\x8f\x3d\x17\xe4\x10\xed\x56\xcf\x2c\x5d\x55\x19\xfc\xcb\x95\xbd\x18\x04\xae\xc2\xb8\xbf\xf8\x00\x00\x4d\xfd\xe5\xb1\x0d\x6f\x58\x52\x90\x42\xe5\x6b\xba\x25\x83\xcf\xc2\x38\x1f\x58\x16\x85\x71\x0e\x71\xd2\xe4\x9a\x7e\xc2\x41\xb5\xe5\x3a\xf6\xe1\xe3\xc1\x2f\x87\xff\xa7\xff\xe6\xf0\xe8\x18\x76\xe1\xa4\xf1\x07\x1b\x9c\x87\x68\x7b\xf5\x36\xf9\x93\xff\x79\xcf\xff\x37\xc9\x1a\xa7\x3b\x58\xfe\xf0\x5d\xff\xcd\xe1\xbb\x83\x7e\xb1\x5e\xf3\x12\x2b\x36\x79\xe9\xe6\x24\xf9\x93\x7e\x24\xe2\x3b\x6b\x1a\xf5\x5f\xbd\x7f\xfb\x61\xff\xf8\xf0\xe5\x1b\x0e\xe5\xfd\x87\x83\x8f\xc7\xff\x44\x10\xea\x14\x83\xd7\x51\x1f\xef\xd3\xf0\x8c\xec\xc4\xf4\x91\x07\x46\x33\x15\x0b\x7e\xc5\x1c\x5d\x3e\x83\xcd\x75\xa4\x98\xed\x4c\x53\xf6\x9e\x8f\x57\xcc\xe6\xf9\x7b\x1c\x55\xbd\x78\xa0\x07\x47\x6b\xfa\x6a\x1f\x8e\x62\xe8\xcf\x35\x0c\x57\x1e\xfa\x50\xa2\x04\x68\x98\x9e\x54\xc8\x1c\x23\x49\xdb\x33\x89\x34\x07\x17\x54\x0b\x23\x4c\xd9\x11\x4e\x01\x70\x29\x95\xcf\xc1\xf0\x5c\x48\x44\x00\x87\xa1\x3f\x61\x11\x79\x42\xc8\x13\x08\xfc\x6c\x8c\x1f\xbc\x02\x2d\x6e\xb0\xfb\x42\xfc\xda\x90\x7c\x51\x2d\x26\xed\x54\x93\x92\x32\xd9\x89\xfd\x49\x21\x1c\xab\x3f\x61\xad\x94\x61\x80\x16\x67\xcb\x39\xd9\x6f\xfe\xcf\xa9\xbb\x75\xe6\x19\x02\xeb\xa2\x60\x47\xd4\x68\x36\x60\x13\x2e\x5a\x79\xf2\x26\xb9\x64\x29\xc2\xa5\x8d\x98\x5b\xdf\x5b\x3f\x08\xd0\xa0\xc0\xcf\x43\xae\xf7\xe0\x29\x11\x4c\x71\x0d\xe0\x85\x1d\x69\xf2\x29\x5c\xf9\xf2\x3e\xd3\x9e\xd8\xe8\xf3\xf2\x85\xa3\x2a\xd7\xa0\x41\x29\x1b\x69\xa1\x25\x86\x30\x11\xab\x9e\x01\x2a\x7c\x3c\xd1\x6f\xd7\xba\xad\x96\x27\x71\x05\xc9\xf2\xe5\xca\x03\xb3\x09\x65\x11\x42\x1a\xa0\x5e\x8d\x51\xe3\x94\xa1\xb1\x8c\x69\xa4\x5c\x9e\x73\x06\x11\x07\x44\x85\xe1\xfa\xff\x2e\xdd\xad\x65\x43\xc5\x07\xe9\xb7\xe9\xb4\x38\x48\x04\x17\xc7\x80\x54\x01\x12\x4f\xc6\xe1\x96\x21\x40\x5a\x29\x0b\x66\x43\x66\xdc\xbf\xa6\x2c\x9b\x45\xc2\x6c\x8d\x77\xd5\x83\xd0\xdc\xa5\x98\x7d\xd3\x1b\x93\x62\x6b\x46\x2f\x94\x34\xf9\xaa\x7e\x35\x13\x14\x2c\xee\xd6\x59\x38\xf1\xaa\xc4\x1a\x46\xe0\x87\xc6\x7f\x76\x1a\x6e\xa5\x4d\x92\x79\xe2\x27\xf1\xad\x1a\x21\xd9\x07\xd8\xd4\x74\xf6\x14\xb2\x74\xee\x7a\xe5\x91\x9f\x43\x29\x1a\x6c\x85\x86\xbe\x14\x75\xa2\xe4\xcc\xd1\x0a\x6f\x5f\xc8\x74\xa4\xad\x23\xbf\xc8\x9f\x10\xff\xe5\xf2\xea\xd2\x8a\x49\xa4\x79\x7a\x79\x5f\x32\xa1\x78\xb3\x5c\x0d\xa7\x0d\x33\x46\x16\xbf\xf0\x53\x3e\xb9\x6c\xc9\xe1\xc7\x0b\xf1\x47\xcd\xa4\xa2\x82\x26\xbf\x8d\x97\xbd\x83\xd9\x59\x59\x56\x68\x0e\x08\x73\x36\x91\x43\xcb\x3b\x4c\x7c\x8e\xa9\x3b\xd6\x38\xf0\xa4\x1d\x1d\xe1\xac\xae\x23\x54\xdf\x4f\xcf\x32\x4f\xb1\xae\xee\x97\x6c\x97\xd7\x55\x38\xec\xbe\x30\xd3\x8d\x8e\x95\x54\xd1\x51\xa9\x6b\x23\x27\xf7\xb9\x88\xab\xe9\x9d\xec\xd9\x5f\xc3\xca\x8e\xec\x5e\x71\x6d\x14\x8c\xa2\xb4\x5c\x42\x40\x4c\x00\xda\xf7\xa2\x94\xc8\xfd\x33\xd4\x39\x5b\xf8\xfd\xf5\x2b\x34\xfc\x38\x89\x17\x93\x64\x96\xa9\x6e\x36\x74\x2d\x3f\x3d\x7b\x27\x62\x6a\x36\xf0\x6e\x86\x43\xe5\xba\xbe\xf3\xdf\x47\xef\xdf\x09\x6b\xfc\x70\xb4\x70\x5b\x9f\x93\x30\x76\xf8\x6a\xef\xf2\xc9\xe7\x36\xc4\x60\x4b\x16\xe0\x89\x3d\x10\x10\x08\xe4\x26\x34\xf8\x50\xf1\x34\x1b\x18\x97\x22\x6e\x81\x5b\x52\x96\x5d\xc3\x2c\x7c\xd3\x49\xeb\x02\x24\x31\xb0\x0b\x96\x2e\x64\x08\x7d\xae\xea\xa1\xe1\xa1\x3e\x4b\xd5\xfb\x37\x4f\xa4\x56\x2d\x2c\x55\x9b\x1a\x33\x4d\x31\x86\x4a\x74\x46\x04\xd0\xe2\x1f\x53\x9f\xe0\x79\x95\x72\xd3\xd8\x0f\xd7\xca\xaa\x6a\x41\x85\x3a\xea\x28\x76\xf0\xaf\xd4\x2c\xdd\xb2\x80\x5a\x61\xf1\xa5\x65\x17\x8f\xc1\xb8\x9c\xe3\xe5\x05\x4d\xcb\xc4\xa9\xdd\x0a\x96\x32\x54\x3f\xed\x1c\x72\xa0\x5d\x4b\x29\xca\xbd\x05\xad\xaa\x56\x76\xa4\x51\xca\x32\x41\x23\x41\xa2\x4c\x58\x66\x48\x31\x5e\xde\xf7\xea\x14\xdb\x08\x32\x93\x96\x8f\x96\x44\xe8\xae\x26\x12\xba\x42\x26\x74\xb5\x50\xe8\x0a\xa9\xd0\x15\x9f\x5a\x2e\x28\xa9\xd0\x2d\x8b\x85\xee\xa9\x52\x21\xf0\x0d\x3a\xce\x52\xfb\x28\x5d\x4a\x5d\xa1\x94\x5a\x2a\xc7\x28\xce\x08\x64\xd6\x4a\xf9\xc4\x91\x0a\xc1\xd6\x16\x8c\xc2\x34\xcb\x4d\x87\x52\x7c\x2a\x0e\x59\x78\xc1\x60\x32\x8b\xf2\x70\x1a\x2d\x34\x2e\x12\x1c\xaf\xf3\x0b\xba\x89\x8a\xb3\x93\xf6\xa9\xd4\x2a\x72\x3f\x8c\x32\x99\xde\xca\xa2\x70\xc8\x28\xde\xef\x12\x41\xab\x36\x93\x58\xb5\x86\x19\x46\x71\xe9\x94\x73\x14\xa3\x14\xd9\x91\x36\xba\x02\xa7\x4a\x31\x29\x16\x54\x77\xc7\x8e\xb7\xb9\xe4\x5c\xa4\x22\xcb\xd4\xa9\xad\x3c\x19\x95\x28\x90\xf6\x75\xc0\xf0\x0a\xd7\xde\x10\xa0\x99\x1c\x97\xab\xba\x6b\x3c\xad\x40\x06\x53\x5f\xa7\x6c\x2e\x44\xb9\x04\x0d\xca\x57\xc6\xd4\x0c\x29\x76\x52\x3c\x37\xcc\x6d\x4c\xf6\x9a\x5d\x2c\x8b\xe7\xd2\xd0\xf1\x5c\x1a\xa2\x4e\xe1\xe8\x48\x7c\x2a\x9c\xf9\xb7\x33\x4c\xe2\x80\xcc\xc4\xc4\x63\x5b\x0f\x7c\x0f\x06\x1e\x0c\x3d\x08\x3c\x60\x6a\x75\x25\x8d\x90\x23\xf1\xe0\x81\xf2\x54\x20\xd4\x20\x6c\x5f\x0d\x53\x83\x2c\x67\x30\x0b\x1b\x35\x95\x4a\x6a\x04\x75\x64\x55\xc1\xf0\x7a\x67\xd4\x72\x1a\x6f\x92\x33\xb4\x05\x01\x71\xc6\x83\x97\x6d\x2c\x4d\x93\x14\x26\x2c\xcb\xfc\x33\xa6\x18\xa2\xa0\x3d\xe2\xbc\x52\x5d\xd3\xf0\xaf\xc7\xa0\x88\xc3\xdb\x30\xa6\xf3\x69\x36\x1f\x32\x14\xc3\x90\x0c\x87\xb3\x34\x65\xc1\x0e\xcc\xf8\x5e\x6f\xcc\x20\x4e\xe2\xe6\x44\x16\x0c\xd8\x05\xb0\xf8\x22\x4c\x13\x8a\xd1\xcf\x47\xb7\xc1\x05\x0e\x2f\x39\x9a\x45\x51\xb1\x0b\x71\xc0\x05\x3b\x62\xea\x47\x30\x66\xd1\x74\x34\x8b\x70\x74\xc2\xf8\x2c\x6b\x35\xdc\xa5\xb6\x53\x42\x4e\x9d\x14\x47\xed\x74\xa7\x58\xec\x50\x5c\x09\xb6\x0d\x9b\x1d\xab\xb3\x44\x19\xad\xd0\xff\x57\x66\x6f\x20\xed\xfb\x7d\xc1\xe5\x28\xe9\x24\xf4\xcd\x4d\xa3\x59\xcb\xda\x01\x4c\x57\xec\xdf\x20\xec\xc2\xa3\xa5\x41\x0d\xcc\xb0\x0b\xe2\x34\x7e\x1f\xb2\x29\x1b\x86\x7e\x14\xfe\xc9\x02\xe0\x72\x14\xc7\x76\x04\x9f\xfa\x7c\x6a\x7f\xc2\x35\x02\x6f\x69\x32\x8c\xbf\x9a\xcc\x72\x0c\xc8\x9a\xa4\x39\x66\x85\x39\x2e\x57\xa4\xa5\x8f\x93\x34\x1f\xfb\x71\xb0\xca\x5d\xd7\x09\x3d\x6d\x2c\xdc\x76\x11\x34\x48\x2e\x58\x6a\x1d\xec\xcb\x87\x41\x57\xaa\x41\xac\xa8\xcf\x2d\xe2\x8b\xe4\x9c\x05\x30\x65\x12\xa5\x30\x89\x0b\x07\xfe\xa2\x61\xf3\xd0\x3f\x66\x97\x5c\x0d\x9a\xb2\x40\xdc\x5b\x15\x6e\xbd\x78\xda\x5b\x7f\x2a\x6f\xbc\x64\xdb\x2b\xdd\x2f\x53\xa7\xec\xdb\x65\xf3\x72\xcc\x53\xc2\x3f\x23\x2f\x5c\xb4\xc6\x8a\x15\x10\x99\xf3\x9a\x9b\x66\xaa\x29\x2e\x97\x61\x57\xa1\x27\x6e\xd5\x28\xdd\x23\x1c\x3d\x6a\x5b\x6c\xdb\x4d\x15\x75\x16\xe5\x35\x37\x68\xa2\xf7\x15\x77\x0a\x4b\x7d\xf8\xaf\x78\x67\x74\xb4\x98\x0c\x92\xba\x60\xee\x4f\xc5\xe5\xd9\x43\xf8\x2d\xe3\x83\x93\x99\xb7\x66\x9c\xef\xf8\xe6\x90\xeb\xff\x9f\xc8\x2a\xee\x13\x79\x3b\xf1\xb9\xea\x22\x75\xbd\xc3\x77\xbf\x1c\xbe\x3b\xc4\xf3\xbe\x0e\x6c\xe1\x7c\x97\x46\x0b\x74\x56\x95\xc1\x27\xdc\x96\x7d\xe2\xac\xe7\xcb\x4d\x26\x1e\xb3\x8e\x28\xf4\x70\x9c\xe4\x3a\x23\x49\x21\x43\x9c\x97\x71\xf7\xc3\x2b\xb1\xd5\x3b\x56\x9b\xd9\xe2\x2d\xae\x62\x48\x82\xfb\x95\x80\xda\x8c\x29\xae\xab\x0c\x5e\xcc\x93\x7f\xb0\x85\x53\x38\xde\x11\x0b\x10\xb5\x63\x5e\x25\x7d\xfd\xaa\x28\x2c\xea\x14\x8f\x52\xe8\x88\x84\x98\x41\xec\xc9\x44\xec\x18\x82\xb6\x09\x0d\x12\xb9\xf2\x40\x52\x16\xd8\x85\x46\x1b\xd7\x36\x87\x53\x55\x20\xb4\xbb\x0b\x4d\x49\x6f\x17\xf6\xa0\xd1\x6c\x37\xa0\xb7\x94\xbd\xb0\x43\x15\xbc\xb5\x34\xda\xc2\x9d\xf2\xd6\x86\x88\x55\x3b\xf0\x33\x06\xe1\x64\x4a\x1b\x2f\x52\x49\x92\x91\x32\xbe\x88\xc2\x73\x46\xe2\x70\xfe\x09\x97\x29\xfe\x3b\x8c\x3f\x09\x3b\x00\x7f\xc8\x57\xc4\x0c\x7c\x0e\xee\x13\xee\x4b\xf0\x5d\x2c\x72\x55\xc0\x72\x96\x4e\xc2\x98\x16\x48\x36\xcf\x53\x36\x99\x4d\xc4\x91\xd1\x7a\x06\x01\x37\x14\x91\xea\x63\x89\x88\x2c\x41\xd0\xbd\x40\x18\xc6\xe7\x4c\x44\x0a\xa6\x24\xc1\xe2\xd9\xf2\xab\xd5\x72\xb7\x0d\xbe\xe6\xc4\x3f\x10\x05\x8a\x72\xd6\x33\x5a\x5e\x5d\xe6\x9a\xb6\x3b\x2b\xd8\xea\x88\xc9\x03\x96\xd0\xd4\x9a\x01\xd7\x71\xf0\x19\x83\x92\xae\xf2\xfc\x53\xa9\x58\xb2\xcc\x3d\x21\xeb\xf9\xdc\xe0\x88\xcf\x30\xc2\xa9\xa9\x60\x19\x7a\xc3\x9e\xae\xc7\x8b\xc8\xdf\x0f\x1e\xc0\x3d\x35\x73\x45\xa2\xb2\xde\xa3\xbb\x60\x4d\x13\x59\x80\xe8\xc4\x9b\xd3\x25\x5d\xfb\x89\x8f\xc6\x47\x36\x65\x1b\x32\x8a\xc9\xaf\xc4\x42\xc9\xce\x62\xd9\x54\x36\xc7\xb0\x62\x46\x7f\x07\xb7\xf4\x6b\x46\x7c\xe1\xda\xa2\xb5\xa7\xf1\x61\x17\x36\x79\x2a\x34\x77\xf9\x0e\x40\xfb\x0c\x2e\xc8\x4f\x1f\x36\x61\x00\x0f\x21\x97\x1b\xb0\x0a\x77\xc0\x8f\xbe\x83\x3b\xe0\x1b\x07\x8e\x09\x18\xde\x2a\x4d\x93\xc8\xcf\x19\x45\xec\xb9\x9d\x77\xfe\x61\x32\x5d\xdc\x2e\x44\xc0\x30\x89\xf3\x30\x9e\x25\xb3\x6c\x4d\x57\xc4\xc1\x76\x1f\x67\x6f\xad\x43\xcc\x47\x6b\xfa\xdc\xec\x70\xd0\x06\xbd\xea\x3d\x6e\xb6\xd7\x74\x4d\xda\xed\x5f\x83\xfa\x93\xe7\xeb\xba\xb6\xed\x4b\x95\xa8\x16\x76\xb7\xbb\xa6\x5b\xe0\x47\xfd\x3e\x59\x96\xd5\x7b\xa9\x7d\xd6\x26\x1f\xa4\xc2\x11\xdb\x2c\x0e\xb9\x7c\x39\x69\x7b\xd0\x39\x35\x6f\xd7\x2b\xf8\xb1\x3c\x2d\x1d\x9c\x8f\x0e\xcd\x4e\x25\x0e\xf7\x0c\x27\xf3\xc6\x55\xbc\x33\x87\x26\xf8\x2e\x6c\xc1\x60\x47\xd9\x55\xf7\xae\xb7\x8a\xb7\x28\x56\xf9\xd6\x7e\x50\x08\xba\x60\xe1\xfe\x2a\xf2\x27\x53\xc7\x4a\xaa\x3c\x90\x37\x7a\x27\xac\x88\x8a\xb3\xd2\xd1\x52\x68\x17\x36\x07\x62\xfb\x58\x04\x63\x76\x79\x0e\x3f\xef\x82\x2f\x36\x19\x73\x78\xb1\x0b\x03\xd8\x83\x0e\xf4\x20\x70\xe6\xee\x0e\xc5\x1b\xbe\xb2\x91\x4f\xcb\xc8\xa7\x37\x47\x3e\x85\x5d\x1b\xd2\x6a\xc8\xe7\x06\xf2\x39\x47\xbe\x0d\x7b\xe0\x43\x0f\x72\x8e\x7c\x07\xf6\x60\xc0\xd5\x47\x27\xaf\x41\x7e\x10\x4e\xfc\xa9\x13\x24\x13\x3f\x8c\x3d\x48\xfd\xf8\x8c\x79\x36\x11\x3d\xa8\xe8\x0d\x92\xbb\xcd\xe9\x8d\x35\xd1\xe0\x30\xe8\xe8\xef\xce\xa9\x07\x29\xcf\x47\x88\x98\x9d\x76\xd4\x67\x07\x77\xf5\x7c\xc5\x0f\x3a\xf0\x33\x04\x6d\x57\x00\xb3\xfa\x1f\x74\x3c\x9e\x25\x01\x59\x79\x69\x87\x27\x23\x4d\xf0\x0c\xa3\xaa\x7a\x9b\xa3\x54\x53\xbd\xcd\xf1\x31\xb5\xf2\x4a\x6e\x48\xdb\x4e\xd0\x76\xe6\x2e\xd1\xce\x24\xdb\x34\x89\x16\x6b\x13\xee\x33\xec\x8a\xc7\x45\x61\x2c\x20\xa8\x63\x62\x04\xa4\x4e\x6f\x9b\xa0\x54\x33\xce\xdc\x7c\x97\x4d\x9b\xdb\xcf\xae\xda\xf5\xd6\xa4\x87\xa8\xd8\xa1\x72\xb5\xb5\x05\x1f\xe9\x64\x17\x1d\xcf\x32\x7c\x69\x2e\x46\x8a\x6b\x9c\x34\x12\x34\x70\x9f\x4f\xf9\x80\xc8\x41\x95\x0c\x4a\x09\x6a\x78\xc5\xf1\xad\x6b\x1f\x18\x03\x21\x2f\x47\xb9\xba\xd0\x95\xad\x4c\xc2\xcf\xf0\x59\x35\x72\x12\x96\xd6\x55\x89\x56\xc8\xf9\x4b\xfc\x84\x4d\x10\x16\xde\x00\x29\xd5\x29\x8c\x2e\x32\x19\xaf\x22\x7e\xe9\x1a\x57\x15\xe7\xcd\x38\xe4\x6a\x1e\x86\xab\x38\x15\x31\x57\x4a\xbe\xf8\x72\x01\x37\x08\x33\x36\x14\xf2\x4d\xb2\xc5\xdc\x83\x8e\xc7\x7b\xd8\x84\x8e\x35\x7f\x39\xde\x0e\xef\x30\x72\x57\x79\x5a\x72\x5d\x40\x19\x5f\x29\xcb\xb0\x0d\xb0\xed\xab\xc4\x50\xb7\xa8\x39\x51\x5e\x7e\x29\xe9\xde\x42\x2a\xc8\x5c\xfa\xd0\x99\x26\xe1\x44\x11\x33\x49\x17\x1c\xa2\x64\x13\x45\xe8\xc3\x25\x31\xbe\xb5\x55\x14\xbb\x5c\xb6\x71\xb2\xe6\xfe\x39\xcb\xc0\x97\xfc\x43\x3b\x84\x39\x84\x31\x9c\xf8\xde\xe0\x14\x37\x81\xa9\xb1\xc1\x19\x26\x69\xca\xb2\x69\x42\x1c\x8a\xbb\x29\xbe\xef\x03\xbc\xc4\x3b\x69\x7b\x9d\xd3\x16\x6f\x2d\xad\x68\x2d\xd7\xad\x55\xd5\xbb\xa6\xa9\x1a\x04\x5b\xe6\x88\x48\xdd\xca\x59\x51\x3c\xca\x39\xc3\x57\x6c\x35\x5b\xc5\x0c\x31\xd3\x8c\xda\xa8\x03\xac\xae\x43\xc9\xb5\xd5\x84\xf0\x70\x4b\x6d\xba\x70\x90\x60\x57\x3b\xb5\xe2\xff\xa6\x21\x1b\xb2\xcb\x50\x27\x24\xb3\x7c\x3a\x33\x90\x99\xce\x72\xdb\x6b\x4d\xca\xb2\xa1\x1f\x69\x27\x1f\x0a\xc2\xca\x62\xec\x05\x74\xf1\x71\x25\xca\x4c\xe8\xd1\xa2\x43\xf3\x81\x5a\xe7\xbb\xc2\x98\xfe\xc6\xe8\x27\xc0\x98\x2a\xd8\xb8\x9a\xbb\x0a\x2b\xc2\x69\x5e\xd8\x4d\x38\x02\xde\xd7\xaf\xea\xe7\xae\x46\xb8\x28\xae\x89\x40\x7b\x2b\xa8\x1f\xbd\xa2\x68\x37\x73\x5d\xd7\xd9\x9c\x6b\xf1\x82\x98\xb5\x42\xb2\xe2\x32\xa2\xa5\x14\xef\x2c\x1d\xea\x32\x47\x55\x76\x5e\x63\x2a\x17\x14\x81\x70\x85\x72\xa7\xd1\xbf\x5e\x01\xe9\x15\x98\x94\x63\xbc\x30\x02\xb3\x10\xca\x8a\x63\x15\xca\xfd\xe2\x66\xad\x70\xad\xc9\x37\xdf\xaa\xd6\x2a\xba\xb9\xe4\x58\xce\x07\x0f\xb7\x4e\xe9\x70\xbe\xbf\xcc\xa3\x9f\xa1\x21\x57\xa9\x92\x9e\x66\x4f\x1c\x25\x6b\x7d\x2a\x76\x50\xce\xbe\x1b\xf5\x4f\x56\x5a\xad\x7b\xb4\x16\x60\xfb\x46\x07\x8b\x68\x5a\x0b\x64\x25\x96\x1f\xf1\x1d\xcc\x12\x54\xef\x08\xad\xdb\x08\x9f\xa0\x28\x7c\x08\x69\xf4\xd8\xa5\xba\x5b\xec\x9d\x12\x4a\x37\x19\x03\x59\xe9\xde\xbd\x7e\x81\x92\x98\x53\x6c\xc3\xee\xd4\x8d\x5a\x2a\xd0\xa3\xd0\x9a\x91\x5b\x8a\x6a\x64\xf4\xf8\xaa\x7c\x82\xb1\xf4\x29\xe4\xf7\x0e\x68\xd4\xa7\x9b\xb9\xd7\x6c\x18\x4e\xfc\xfa\x90\x46\xdd\x6e\x57\x1c\xc6\xdc\xf6\x78\x68\x6e\x29\x2f\xf3\xd5\x54\xac\x22\x96\x95\x3b\x49\xe5\xed\x68\xee\xba\x1e\xcc\x61\x0f\xe6\x27\x9d\x53\xe8\x51\x30\xba\xaa\xc3\xa4\xc7\x4b\x1f\xbc\x7d\xef\xa1\xf8\x26\xc1\x86\xda\x77\x10\x6c\xa8\x7d\xbb\x60\x43\x9d\x6f\x18\x6c\xa8\x73\x57\xc1\x86\x3a\x77\x10\x6c\xa8\x4b\x0f\xa8\x63\x7f\xb2\xa4\xa3\xdd\xbb\x80\x7d\xab\xc8\x51\x26\xa0\xb5\xcf\xc1\x6e\x14\x36\x67\xbd\xd3\xb0\x6f\x1d\x5e\xe8\xb1\xec\x45\x12\xf9\xe9\xf2\x26\xb6\xd7\xec\xc5\x93\x9b\x45\x30\xfa\xf1\x42\xe8\x47\x6c\xa1\x1f\xb1\x85\xee\x34\xb6\xd0\x8f\xd0\x42\x3f\x42\x0b\xfd\x08\x2d\xf4\x17\x0b\x2d\x74\xc4\x84\xab\x92\x2d\x2b\xb0\xd0\x19\xcb\x5f\xb3\x28\xf7\xf7\xe3\xb3\xe2\xd3\x2c\x23\x83\x8b\x90\x34\xc7\x9f\x9c\x28\x01\xfe\xd2\x67\x6d\xb8\x56\xae\xb0\xa9\xa8\x58\x9a\x4f\xee\x8f\xc5\x89\x44\x3e\x3e\xe2\x60\x70\x5b\x21\x9b\xe0\xd3\x46\xb5\xac\x5e\x48\x05\x26\xc2\xea\x08\x4c\x6d\x45\xaa\x2b\x7b\xb0\xfd\xf8\x79\xeb\xf9\xf3\xe7\x96\xd1\x33\x62\xfe\xd0\x80\x68\x9b\x20\xf3\x4d\x7e\x9c\xbf\x0a\xd3\x61\x89\x38\x56\x1e\xba\x3a\xd6\xf4\x18\xa2\x27\xc8\x94\x8d\x5a\x43\xe5\x01\x72\xb8\x50\x69\x0b\x7d\x1c\x19\x84\xb3\x4c\xa6\xd3\x97\xcc\xf3\x45\xff\x30\x0b\x3f\x64\x8e\xa0\x36\x66\xf0\xdf\xea\xec\x30\x3b\x98\xe7\x2c\x8d\xd1\x24\x1a\x73\x75\x8a\xc2\x22\x49\x63\x96\x7e\xb4\xda\x35\xd3\x76\xa4\x59\xfa\x90\xf1\xbd\xb6\x2a\x68\xd5\x7b\x08\x8e\xd1\x16\xdd\xcf\x35\x3b\x2e\x6c\x8a\x0e\x29\x9b\xf3\x31\x43\xbf\x02\x34\x32\x59\x18\x3b\x16\x98\x2d\xab\x11\x17\xb6\x6e\xa8\x37\xca\x0d\xe9\xc7\xfd\xd7\x87\xfb\xef\x38\xe3\xec\x58\xc8\x4b\x0e\x21\x4a\x6e\xca\xb1\x46\xac\xec\x92\xab\xf0\x6e\x35\x06\x0c\x31\x98\xf2\xb4\xe3\xe4\x95\x9f\xe6\x2c\x0b\x7d\xc1\xc4\xc3\xb9\x07\xc3\x85\x67\xf5\xd2\x33\x71\x93\x76\xfe\x64\x9a\xa4\x9c\x83\x26\x23\x72\xa1\x29\xec\xb2\xc2\x0c\x72\xe2\x35\xc8\x13\x3a\x3b\x47\x9e\x93\x3d\xc0\x0f\xe2\x46\xe4\xb1\x6f\xd8\x93\xf4\xee\xfa\x20\x58\x3f\x0a\x63\xd9\x11\x0c\x77\xfe\x5d\xba\x61\xf1\xf6\x43\x62\xcf\x61\x92\x39\xc4\xaf\x0f\x6f\xcd\x86\xae\x47\x3c\x67\x49\x9a\x2f\xa2\xd9\x9e\xf8\xeb\x15\x46\xae\x57\xf8\xf6\x2c\x82\xf4\xac\x2f\x8f\x98\xb8\x27\x66\x98\xfd\x6e\x82\x04\xfd\x07\x1f\x0d\xc9\x4c\x89\xa5\x33\x50\x5c\x75\x2b\xe4\x55\xb7\x4a\x60\x75\x0d\x89\x15\xc6\x45\xf1\xd1\x6d\x19\x69\xc6\xa5\x46\xa9\x98\x91\xa6\x24\x99\x12\xcf\xaa\x94\xb1\xd0\x88\x42\x4a\x9c\xcb\x22\x32\x41\xc9\x2a\x29\x2a\x57\x58\xb2\xe4\x85\xec\x1f\x63\x16\x23\x1f\x52\x5d\xae\x62\x20\x75\x80\xfd\x6b\xe6\x47\xe8\xa8\x6a\xfb\x49\x1b\xf5\xe1\x54\x70\xb2\x1f\x07\x1c\x8e\xf8\x1a\x26\x61\x3c\x0c\x03\xc9\xbc\x5c\xed\x3d\xd0\x88\x1a\x1d\xdb\xa4\x26\xa4\xc0\x11\x0e\xf8\xfc\x34\xff\x20\xc2\xea\x7f\x43\x46\x37\x49\x5e\xb5\x90\x62\xfe\x41\x1c\x7c\x6f\x54\x4c\x6a\xb9\x6a\x18\xa7\xc4\xb2\x8d\xb7\xf8\xc6\xa2\x40\x28\xf4\x57\xda\xf0\xaa\x72\x16\x3c\xe7\xff\x8b\x39\xaf\xec\xeb\xaa\x82\xfb\xac\x4a\x46\x5a\xdb\xa3\x1a\x3c\x6f\x53\xeb\x0e\x34\x6f\xe1\x05\x74\x9e\xb5\x5d\x55\x79\xd3\x60\x26\x78\x61\xa3\x8f\x85\x34\x2c\x8b\xa4\x45\xa4\x55\xba\x42\x99\x9e\x6a\xe2\x63\x1c\x63\x66\xbd\x80\xb6\x75\x27\xce\xb3\xbe\x17\xcf\x98\xb3\xb9\xc8\x33\x06\x3a\xdf\x87\x6b\x2c\x64\x0a\x5c\x83\x77\xa1\x9c\x65\x36\x77\xa1\xf1\x06\x89\x6f\x61\x66\x10\xdf\x4e\x37\xf8\x45\xfe\xdb\xd7\xd5\x0b\x7c\x53\x4c\x93\x7c\x23\xff\xdd\x9c\x7f\x7e\xde\xad\x65\x20\x13\x68\x61\xd0\x8b\xbd\x29\xf2\x3f\xfc\x4f\xc3\x08\x54\xf3\xa5\x8a\x3a\x43\x0d\x62\x68\xd5\xd9\x30\x9d\x63\xe4\xe3\x8a\xd5\xe4\x8f\x30\x1f\xbf\x42\xdd\xad\x72\x4d\xd1\xd9\xb8\xb2\x6c\x57\xac\x2c\xdb\x55\x2b\xcb\xf6\xd2\x95\x65\x7b\xb5\x95\x65\xbb\x6a\x65\xa9\xd0\x73\xb7\x2d\x45\xb7\x76\x09\xda\xbe\x7e\x09\xda\x2e\x2f\x41\xdf\x6d\x07\x24\x1d\x18\x54\xec\x4e\x4a\x9b\x12\xe2\x82\xe1\xbc\x07\x34\x9f\x7a\x86\x12\xd7\xb3\x25\x32\xf2\x6d\x0f\xcc\x35\x93\x77\xa9\x87\xff\xf7\x2c\x72\xf6\xac\x2f\x15\xa6\x10\x89\x99\xe0\xcb\xec\x12\x72\xad\x82\x6a\xa3\x8a\x47\xd5\xc5\x2d\x5d\x47\x15\xae\x2e\x2b\xd4\xf9\x3a\xba\x74\xef\x86\x30\x72\x38\x24\x59\x9a\x37\xa2\x0b\xab\xa1\x4b\xb7\x86\x30\xac\x86\x30\xdd\x4a\xca\xb0\x6a\xca\x74\x0b\xa4\xc1\x6e\xed\xa7\x43\x6b\xe3\xcc\x65\x96\x31\x05\x9a\xc6\xe6\xbe\x89\x24\x6f\x72\xf0\x6a\x91\xb2\x61\xfc\xac\x97\x29\xfd\x46\xd6\xd0\x32\xd5\x33\xd0\x02\xa1\x8d\x69\xdd\xb3\x45\xbc\x41\xfa\x5e\x9d\xf6\x62\x73\xa9\xc4\x57\x0f\x11\x19\xfd\xdb\x7e\x5d\x6c\xd5\x82\xf3\x9d\x21\x4f\xf1\xd3\x54\x22\x50\x42\x9a\x02\x44\x89\xcd\x62\x62\xdb\x6b\x4b\x01\xcf\x67\x2e\x12\x44\x83\x1d\xda\xad\x0c\xcb\xad\xac\xa6\xa9\x50\x0b\x36\xed\xcb\x2b\x4c\x09\x01\x66\x23\xc0\xaa\x10\xb8\x7d\x37\x99\x4d\x4c\x66\x11\x73\x25\xf5\xa6\xc4\xb9\xdb\xf5\x73\xb6\x7e\xd6\x5a\x7c\x74\x8d\x38\xd3\xa7\x17\xfa\x14\x6f\xc9\x44\x36\xa7\x32\x40\x16\x56\x4f\xe6\xed\x9a\xc9\xcc\x6b\x54\x4f\xe7\xed\xca\xe9\xcc\xcb\xd7\x14\xd7\x13\xba\x86\x72\x8f\xee\x8a\x72\x35\xf2\xee\x56\x84\x63\x35\x84\x7b\x54\x4b\x38\x56\x43\xb8\x47\x35\x84\x63\xd5\x84\x7b\x54\x22\x1c\x76\xf9\x66\xb2\x30\x44\x59\x18\xe6\xc6\x7b\x29\x1b\x8a\x21\x0d\x2d\x75\x8a\xcf\x85\x37\x95\xfa\xd7\xff\x34\xac\x57\xee\x5a\x5d\xc3\x89\x14\xda\xf3\x2a\x8c\x0a\x9a\xeb\x5d\xcd\xdf\xd0\x96\x12\xe1\xb0\xaa\x9d\xd5\x54\x63\x6a\xc3\x26\x4b\xb5\xa0\x7a\x61\x49\x4a\x1b\x85\xac\x1a\x85\x3b\x90\xc8\x36\x49\x33\x45\xd2\xa5\xba\xf3\x92\xa1\xab\xd7\x9c\x69\x15\x5c\x45\x23\xac\xba\xd7\x5f\x25\x40\xe2\x8d\xe3\x23\x12\x4a\x4b\xc2\x23\x52\x01\x65\x67\x5a\x1d\xf1\x90\x0a\x15\x1c\x04\x5d\x1f\x51\x90\xaa\xad\x12\x49\x50\x34\xe0\x0a\x6f\x21\x54\xbf\xe8\x28\xa4\x14\xc1\x4f\x76\xee\xe4\x96\x01\xc4\x96\x87\x09\x1b\xea\x08\x4f\xc6\x76\x46\x6f\x69\x44\xce\xc2\x0a\x1b\x66\xef\x6b\x44\xc0\xb0\xf2\xc6\x06\xca\x9b\x1b\x2a\x5b\xb1\xbb\x81\x8a\x1d\x8e\x68\xbb\x62\x8b\x03\xa5\x6d\x0e\x95\x2d\xef\x73\xa0\xb0\xd7\xa1\x72\x6a\x2d\x30\x5b\x97\xf1\x27\x8c\xa6\x65\x92\x1d\xbe\xcf\xec\xd3\xcf\x16\x35\xbe\x7e\xb5\xd0\xda\xdd\x2d\xdc\x2c\x59\x92\x54\xdb\x25\x1b\xc1\x36\xf0\xd8\xd8\x5f\xc8\x8b\xbe\xe5\xd6\x98\x55\xb6\x3c\x8e\xeb\xe8\xf0\x19\x74\x02\xd8\xf0\x74\xe7\xac\x78\x51\x78\x47\xa4\xe8\x6d\x76\xab\x69\x76\xcb\xac\x32\x5c\x49\x02\x54\xee\x09\xc9\x62\x94\xcf\x0d\x96\x0e\x59\x9c\xff\x8e\xa6\xf1\x74\x38\x62\x8e\xb1\x89\x96\x07\x6d\x0f\x97\x65\x0b\x6f\xa1\xfb\x56\x84\xb0\x1a\xa6\x32\x30\xd2\x75\xeb\xdf\xcf\xb0\xfd\xa4\x6d\x8e\x8a\x00\x5a\x75\x02\x60\x85\x29\xb9\xbd\xe6\x5f\xc3\xf2\x3d\x7d\xf1\x37\x4c\x2d\x2a\xc0\x16\x74\xdd\x6a\xde\x5f\x69\xeb\x00\x76\x74\xc2\xa2\x93\x96\x62\xcf\x69\xa7\xf3\x9d\xf7\x38\x56\xf8\x44\x5b\xe5\xb8\x81\x59\x62\x29\xf2\x4c\x83\x77\xae\x51\x08\xcc\xb2\x42\x14\x9e\xaa\x88\xd5\xe7\x8a\x81\x53\x96\x49\x77\x04\xfb\x79\x9e\x86\x83\x59\xce\x32\x62\x65\x2d\x66\xdd\xb5\x1b\xa2\x73\x44\x8a\x46\x88\x31\xe7\x96\x36\x62\x38\x06\xd2\x21\x74\xb4\x0c\xd1\x7c\x13\xf4\x70\xa8\x25\x95\xdd\xfa\x88\x33\xc4\x07\xcb\x03\xce\xb4\x6f\x18\x70\xe6\x48\xca\xa2\xaa\x78\x33\xd6\xf0\xdc\x94\x5c\x43\x24\xd7\x87\x8f\x07\x47\x07\xef\x8e\xf7\x8f\x0f\xdf\xbf\xeb\xef\x1f\x1f\x7f\x3c\x7c\xf9\xdb\xf1\xc1\x11\x19\x8f\x73\x1a\x19\xd4\xb9\xa9\x25\x68\xcb\x17\xee\x04\x31\x26\xfa\x7c\x2d\x00\x3a\x8e\x3e\x9f\x50\xb7\x02\x60\xcd\xc4\x5b\x41\xb2\x66\xee\xad\x20\x99\x33\xfd\x56\x80\xb4\x68\xb8\x1d\x91\x2d\xc9\xba\x06\xa8\x24\x66\xef\x47\x9c\x3f\x9d\x93\xf5\x11\x59\x9f\xd3\x4e\xdd\x8d\x2b\xb7\x36\xfa\xd2\x17\xc1\x87\x6d\xc9\x4f\xed\x12\x5f\xb4\x4b\xe3\xdb\x2e\x8e\x53\xdb\xa6\x77\xbb\x4c\xb7\xf6\x86\x0a\x48\x7d\x47\xb1\x9d\xb4\xb6\x5d\x30\xa2\x5f\x1a\xf6\xe3\x7b\x1b\xd1\x57\x84\xbd\xaf\xb3\xb8\x5d\xd3\xbb\x40\x65\x1b\xb7\xb2\xae\xaf\x80\xb7\xae\x35\xbc\x00\x35\x09\xe3\x97\xf5\xee\x0f\x9e\x6f\x3f\xbb\x1b\xf8\xb7\xb2\xb7\xb7\x41\xad\x6b\x15\x2f\xa1\xf8\xf3\x25\x1d\xde\x7e\xbe\xa6\xfd\x76\x11\xfe\xad\xec\xee\x6d\x50\xeb\x5a\xde\x7f\x93\x57\x22\xdb\x77\xf0\x4a\x64\xfb\x76\xaf\x44\x1e\x7d\xc3\x57\x22\x8f\xee\xea\x95\xc8\xa3\x3b\x78\x25\xf2\xf8\xdb\x3f\x9e\x78\xd2\xef\xab\xc8\xfc\xfd\x63\x36\xaf\xe7\x97\x27\x6b\x4a\x82\xa7\x66\x0b\x6f\xfc\x01\xab\x7f\x3a\xf6\x78\xcd\x4e\x3c\x43\xd7\x21\xb9\x1f\xc6\x2c\xed\xbf\xe1\x5a\x71\x3d\x9d\xd6\xf4\xe7\xf2\xfc\xdb\x3f\x32\xe9\xb4\x6f\xf8\xca\x44\x1a\xc3\xfe\x78\x07\xf2\xe3\x1d\xc8\x8f\x77\x20\xdf\xe6\x1d\x08\xbd\x5e\xf8\x83\x5c\xaf\x1a\xcd\xca\x48\x3f\x99\x64\x06\x22\x28\x57\xdb\xaf\x76\x4c\x36\xd2\x21\x83\x44\x10\xa1\x4c\x85\xff\x08\x5d\x78\xb1\x0b\x6d\x57\x7a\x89\x10\x63\x7c\x6f\xa5\x99\x83\x08\x84\xae\x59\x59\x4c\x1e\xf4\x6d\x92\x0c\x3e\x23\x33\x96\x67\xcc\x8f\x57\x2e\x3f\x5e\xb9\xfc\x78\xe5\xf2\xd7\x7a\xe5\x82\x2e\x46\xe7\x61\x46\x06\xe8\x11\x3a\x8c\x54\x46\xe9\xd9\x22\xcb\xd9\xc4\x7a\x02\x43\xe2\x0b\xf5\x04\xda\xc5\xef\xf3\xca\x37\xb1\x69\xfc\xd6\xd7\x76\x05\xdc\x96\xdc\xdf\x15\x4a\x5e\x73\x91\x57\x28\x7d\xe3\x1b\xbd\x42\xfd\x55\xae\xf6\x8a\x4d\xde\xf0\x8e\xaf\x44\x09\xeb\xb2\xef\x8c\xe5\xc7\xe1\xf0\x1c\xef\x49\x5e\xf1\x31\x6f\x78\xe2\x1e\x0a\x19\x85\xff\x7b\x08\xaf\xfc\x68\x38\x43\xe7\x12\x79\xe9\xbd\x42\x1e\x0e\xcf\x65\x39\xe1\x49\x16\xbe\xbc\x13\x71\x67\x8d\xa2\xc7\xfa\xf5\x42\xb1\x96\x34\xf5\x97\x71\x3e\x9d\xb9\x07\x22\x62\x26\x67\x3a\xa8\xb8\x86\x2c\xa1\x6d\x3c\x25\x52\xd7\x48\xba\x71\xf5\x64\x47\xa6\xec\xac\x7e\x7b\xe9\xdb\xd7\x7a\x7e\xe9\x4e\x6f\xc5\xdb\x4d\x7d\xbf\x67\x05\x0e\x59\x76\xf0\x50\xa5\x90\xaf\xf8\x56\x43\xf5\x54\x3f\xaa\x50\xe7\xf0\xf2\x38\xdf\xe2\x00\xbe\xf7\xda\x8f\x87\xe3\xa4\xee\xe6\xb7\x54\xae\x70\x09\x9c\xa4\xa1\x72\x9f\x6c\xd2\xb2\x65\x64\xec\x98\x57\x90\xb9\x82\x54\xbe\x67\xcb\x2e\xc3\x7c\x38\x06\xc7\xa8\x6b\x45\x27\xf0\x33\x06\x8d\x88\x8d\xf2\x46\xcf\x20\xb8\x05\xb1\xc1\xe2\xa0\x61\xc6\xd8\x1f\xa4\xcc\x3f\xdf\x29\xc0\x48\xc3\xb3\xf1\x32\x20\x78\x94\xb9\x0c\x8c\x8c\xec\x58\x0b\x61\x12\x06\x41\xc4\xea\x41\x14\x6f\xa2\x74\xed\x65\x43\xf6\x7b\xc8\x2e\x5f\x26\xf3\xfa\xb1\x12\x05\x2a\x6f\xea\xbb\xab\x5c\xd5\x77\xeb\xb9\xb9\x5b\xb8\xac\xb7\xa7\x48\xb7\x3c\x47\xf8\x74\xcf\x8c\x02\xf8\x6d\x31\xc3\xc4\x9f\x93\x8c\xe2\x3c\x76\xcd\x95\x74\xf5\x41\x97\xe3\x3a\x08\xd6\x8c\xd5\x80\x91\xd5\x2b\xae\xc5\x31\xdd\x10\x07\x5c\xf8\xb6\xd5\x80\x58\xf7\xc0\x93\x30\x5e\x11\xb1\xba\x23\xc7\x3b\x45\xcc\xe6\x15\x63\x46\xd8\x17\xa9\xda\x28\xce\x38\x8a\x2f\x0c\x8b\x3e\x94\x2f\x64\x58\x47\xfc\x56\xff\x8b\x98\xe9\x3a\xd6\x25\x80\x35\x98\xc5\x3a\xb2\x33\xb5\xdc\x4d\x26\x26\x7c\xad\x7a\x13\xc6\x6c\xa9\x1d\x8a\x2c\x54\xc9\xe5\xdb\xab\x70\xf9\x76\x3d\x97\x6f\x2f\xe5\xf2\xed\xeb\xb8\x7c\x9b\xb8\xdc\x82\x20\xd0\x35\x81\x88\x24\xcb\x9e\x85\x2b\xbf\x08\xa8\x6e\xf7\x27\x6a\x7b\x70\xd2\x18\xce\x1b\x1e\x34\x86\x0b\xfe\x7f\xc4\x08\xc3\x97\xf2\x96\x31\x45\x52\xf1\xd4\xb5\xa6\x1b\x9e\xd8\xf0\xdd\x22\x96\xac\x0f\x8a\x58\xc7\xa7\x27\xca\x8c\x40\x44\xa1\x68\x9f\x7a\x25\xe6\x75\x3d\x61\x6d\xe0\xcf\x65\xb1\x4e\x55\x31\x15\x2d\xe5\xca\x83\x93\xc3\x78\xc4\xb7\x46\x0b\x0f\x9a\xf2\xe7\xa9\x6d\x98\x91\x84\x71\xde\x5e\x45\xd9\xbc\xc5\xfa\x49\xf4\xc1\x5e\x99\xcb\xa7\x81\x41\xe7\xfb\x60\xd0\x39\xb5\x5e\x45\x2a\x14\x84\xca\x72\x33\x93\x83\xaa\x43\xc4\x15\x4d\x0e\x88\x27\x2d\x4b\x80\x51\x18\x45\x3d\x68\xc4\x49\xcc\x1a\x7a\x00\xbf\x25\x12\x92\x9b\x2d\x34\xe6\x9d\x9e\xe0\x89\x96\x31\x93\x17\x3a\xd5\x98\xc4\xf3\xae\x48\xed\x58\x65\x75\xea\xa2\x56\xd4\xde\xe0\x46\xa2\x6c\x20\x12\xa1\x20\x33\x46\xcb\x34\x14\xd0\xa6\x54\xc8\x11\x4d\xd2\x92\x9b\xbc\xb3\x4d\xac\x08\x57\xf2\x84\xb0\x5e\x8b\x23\x79\xc8\xe5\xed\x61\xce\x26\x4b\x85\xa6\x2c\xe4\x24\x53\xda\x4f\x8b\x68\x5f\x46\x70\x11\xc9\x66\xb9\x28\x5a\x6d\x08\x75\x33\x92\x84\xd9\xef\x7e\x14\x06\x92\x26\xd4\xb8\x6b\xca\x16\xa3\xb5\x1b\x52\x3b\x4a\x62\x66\x03\x96\x14\x2b\x18\x24\x2d\x47\x7b\xe9\x7d\xa9\xe3\x5e\x83\x33\xe5\x3a\x95\xed\xde\x45\x27\x2d\x96\x32\x96\x8b\x1b\x5d\xae\x54\x6c\xb6\xcd\xa5\xc7\x92\x27\x82\x2f\x4c\xcb\x34\x58\x95\x71\x79\x37\x9b\xc8\x51\x0d\xa3\xfa\x95\x65\x61\x86\xd9\xea\xbb\xd6\x34\x4b\x52\x6c\x05\xde\xcf\xae\x65\xfc\xac\xa8\x2a\x70\x0d\x41\xea\xc3\x96\x88\xa5\x35\xf6\x51\xad\x12\x61\xaf\xf6\x8f\xca\xab\x7d\x2e\x14\x46\x23\xbf\x5e\x9d\x78\x54\xad\x4e\xfc\x82\xce\x04\xc9\xd7\x82\x09\x48\xa5\xdb\x16\x7b\x69\x72\x6e\x82\xa4\x84\x75\x54\x8b\x47\x5c\xb5\x50\x5a\x04\xff\x51\xd2\x2f\x14\x0a\x3c\x81\x5a\x2a\x6a\x19\xd6\x46\x08\xa9\x58\xb1\x89\x34\x57\x56\xce\x3a\xd2\xfc\xe4\x3b\xac\x66\x96\xd1\xe9\x2c\xcb\x93\x09\x47\xee\x7b\x20\xc0\x09\x68\xd3\x2a\xcc\xd9\x24\x53\x0a\x99\x1d\x56\x11\x35\x26\x23\x2e\x35\x98\x27\x1c\x7c\x30\x91\x89\x5b\xe5\x43\x11\x52\xdf\xec\x18\x78\xb9\xd1\x45\x3d\xdd\x2b\xb7\xaf\x3d\xe3\xb7\xc5\x99\x32\xb0\x35\x9f\x7c\x49\xee\xe7\x0c\x03\xed\x3a\xcf\xdb\xd0\x14\xda\x0a\x1a\xfe\xd3\xfb\x59\x8e\x89\x78\x3f\x60\x24\x2c\x28\xe6\xae\xb6\x1d\xf5\xf4\xe8\xdb\x32\x87\x78\x4b\x6a\x1a\x9e\xd0\x3b\x28\xd5\xac\x5e\x18\x41\x1b\x08\xde\x79\xf4\x20\xb4\x2a\x70\x44\xec\x62\x53\x7f\x11\x25\x7e\xd0\x23\x25\x55\x17\x76\x8d\x68\x81\x77\xa0\x10\xac\x24\xbd\xab\x6e\x95\x57\x16\xdf\xeb\xca\xec\x86\x67\xd5\x24\x01\x8b\xc2\x1c\xdf\xae\x98\xb2\x7c\x6d\x5d\x6f\x54\x34\x3d\xcd\xde\x8f\x5e\x8d\xc3\x28\x10\x47\xbf\xc4\xcd\x62\xf5\x51\xbc\x6f\x2d\x1d\xa2\x4c\x41\xa1\x41\x11\xab\x19\xdc\x2b\x88\xd0\x3d\xfb\x9b\x66\x47\x4b\xa8\x3d\x62\xc8\xc5\x67\xc5\xaa\x74\xa7\x1a\xe1\xc6\x37\x18\xfe\x95\x95\x4a\x92\xeb\x70\x65\xec\xf8\xb9\xf0\xd9\xb0\x7a\x5c\xbb\xce\xde\xfc\x61\xc8\xe3\x15\xd7\xd0\xff\x9f\xbd\x77\xed\x6a\x23\x47\x1e\x87\x5f\x0f\x9f\x42\xc9\xce\xc6\x76\x30\xc6\x36\x10\x88\x59\x26\x6b\x6e\x09\x93\x10\x12\x20\x93\x4d\x78\x38\x4e\xdb\x96\xed\x0e\xed\x6e\x4f\x77\x1b\xe3\x04\xbe\xfb\x73\x54\xa5\x6b\xdf\x7c\x83\xfc\x66\xe6\x1f\x66\xcf\xc6\xdd\x2d\x95\x4a\xa5\x52\xa9\x24\xd5\x65\x63\x8a\x1d\xf3\x46\xe2\x8e\xd9\x58\x6a\x11\x8c\xe9\x4e\xf1\x08\x5b\xba\xbd\x25\xf8\x2b\x92\x69\x98\x4c\xf0\x98\xf8\x9b\x8f\xb8\x31\xd6\x92\xa4\x4f\x9e\xe0\xa8\x44\x8f\x52\x8a\x86\xae\x1a\x29\xc6\x75\xa8\xe2\x14\xdd\x49\x32\xbc\x49\xe8\x0e\x07\xbc\x67\x39\xce\xee\xf8\x9d\xe5\x33\x62\x69\xdc\x22\xf5\x06\x79\xa0\x59\x48\x60\x54\xd3\xb4\x3c\x72\xe5\x91\x6d\x63\xbe\x36\xa3\x8d\x79\x04\xb8\x66\x6c\xce\x28\x7b\x8e\xf7\x8d\x39\x3f\xa9\xc0\x1c\xd6\xe8\xc9\x12\x74\x0a\x6b\xf4\x59\x41\xe2\xb8\x1c\xfc\x71\xf0\xf6\x3c\xd1\xb2\x3d\x1c\x0f\x32\xcd\xa5\x93\x0d\xd7\x84\x8d\x73\xfe\x22\x87\xd6\xca\x70\x58\x65\x85\xb4\xeb\xf9\xe3\xdc\x65\x61\xb2\xad\x7b\x2a\xdc\x69\x6d\xdd\xa7\x00\xd0\xb3\xdb\xf3\xf5\xad\xe9\x79\x10\x23\x4e\x8d\xf6\x51\x7b\x7e\x22\x4d\x32\x04\x4f\xad\xcd\xfd\x06\xe6\x27\x02\x1b\x88\x25\x22\xbc\x98\x17\xa2\x25\x93\x19\x7b\xde\xd0\x0d\xef\x01\x4e\xa6\x51\x7d\x2a\x0c\x48\x1f\x70\xd2\x99\xda\x36\x52\x27\x64\xcf\x1a\x08\xcf\x6f\xbe\xc0\xcd\x83\x80\xcb\x8f\x9c\xd4\x19\xe7\x02\xc4\x80\x90\x18\x30\x51\xb4\xcb\xb0\x85\x66\x22\xdc\x9b\x15\xc5\xdd\x57\x51\x5e\x51\xe1\x74\x14\xeb\xc3\xff\x01\x1f\xc3\x74\x9a\xab\x59\x50\x44\x11\x7f\xc6\x38\x7f\x3f\xdc\xe7\xaa\x4a\x51\xb7\x98\xab\x2e\x53\xdc\x90\x60\x62\x7f\x35\xbf\xe0\x59\x8a\x1c\x56\xcc\x05\x8b\x21\xc4\x20\x61\x32\x94\x1f\x3d\xf3\x17\x1b\xfc\xc9\x9e\x38\x13\x27\xa5\x35\x0c\x3d\x36\x17\xdb\x56\x68\x1d\xdb\xae\xfc\x69\xdd\xe4\x2e\x0b\x97\x28\x00\x20\x55\xc7\xff\x01\x6f\x47\x71\x74\x20\x95\x0f\xfb\x35\xf0\x46\x70\xfc\xf3\xa7\x0f\x82\xc4\xf1\xba\xec\x1f\xbb\x4d\xdd\xd0\x0e\xc7\x78\x54\xd4\x87\x23\xa3\xa6\xe5\xb6\xb1\x86\xed\x42\x59\x14\x8d\x0e\xfb\xf9\xe7\xd0\x72\x43\x1b\x8f\x96\xf0\xf7\x37\xf8\x3d\x0c\x5b\xe7\xbc\x7a\x40\xff\x1c\x32\xa0\x58\x21\xec\xf9\x34\xe8\x79\x4e\x3b\x07\x8a\xda\x22\xdc\x6f\x39\x8e\x37\xda\xb7\x42\xeb\xe4\x9a\xfa\x1d\xc7\x1b\xcd\xad\x08\x4c\xf2\xa5\x42\x0d\x4a\xea\x41\x31\xb5\xa1\x5c\x4c\x74\xb8\xb2\x34\xc7\x29\x63\x05\x10\xf2\x5b\x9b\xc2\xb9\x7f\xb5\x5a\xad\x9c\x29\xc5\xc1\x12\x4d\xca\x45\xfd\x89\x2f\xd3\x1b\xfa\xac\xbb\x28\x17\x09\x8e\xf3\x65\x0a\x75\x64\x5e\x2e\xce\x8d\x58\xfa\xde\x7d\xb8\x12\x0c\xad\x22\xce\x5c\xd5\x9f\xce\x5c\x7f\x19\x67\xae\x07\x71\xf5\xa9\xdc\x83\xab\x4f\x65\x31\x57\x9f\xea\x03\xba\xfa\x54\xef\xcb\xd5\xa7\x7a\x0f\xae\x3e\x3f\x26\x4f\xca\x43\x7b\xc9\x6c\x3c\xbc\x97\xcc\xb3\x46\x03\x76\x09\x8d\x7d\x2f\x9d\xe1\x37\xe7\x64\x89\x4d\x01\xfc\x9d\xe7\x8c\xbb\x19\x42\xa4\x5a\x5d\xc4\x55\xe9\x41\xfd\xad\x9e\xcf\xec\x45\xf4\xd3\x87\xe8\xa7\x0f\xd1\x4f\x1f\xa2\x9f\xb9\x64\x7e\x7a\xd9\xfc\xf4\xb2\xf9\x27\x7b\xd9\xd4\xb9\x87\x0d\xdb\xf6\x59\x0e\x69\xdb\x3e\x05\x5a\x47\x5c\x6b\x60\x5a\xf3\xb4\x08\x3c\xc6\xe2\xbb\x23\xb2\x4a\x2a\x5b\x65\xcc\xbb\x46\x61\x4b\x59\xa1\x2b\x1b\xdb\x9a\x23\x0e\xd8\xf2\x4e\xeb\x87\xf3\xc3\xc2\xe7\x99\xa8\x4d\x72\xc3\x91\x05\xa7\xf1\xc2\x91\x85\xe7\x73\xc2\x91\xd5\xa7\xf6\xc1\x51\x0d\xce\xe3\x82\xa3\x11\x21\xc9\x03\x87\x6d\xd6\xe7\x72\xc0\x71\x6c\x97\x12\xea\xb6\xe1\x60\x45\x54\x90\x9e\x38\xc2\xa7\xa6\x6d\x85\x16\xf8\xe0\xb0\xcd\x3c\x9b\x18\x70\xbe\x2e\x8b\xc7\x5d\x70\xca\x45\x32\x2e\x17\x6a\x50\x07\x8c\xc8\x79\x06\x07\xaf\x03\x46\x21\x45\x51\x35\xf6\x97\xbf\xa9\x14\xc9\xb8\xc2\xab\x6a\xa9\x1f\x1c\x2f\xa0\x90\xc7\x64\x42\xf5\x6a\x91\x8c\xab\xe9\xd5\xad\x1b\x5b\xe0\x9d\xe9\x1b\x24\x09\x9a\x67\x7d\x7f\xf0\x80\x85\x7e\x24\xa4\xa0\x1f\x0f\x53\x68\x38\xc8\x34\x62\xce\x31\xd1\x0b\x6d\xe3\xde\xbb\x24\xde\x98\x06\x56\xfc\xe5\x99\xfd\x8d\x72\xdb\x21\x79\xb5\xcb\x7f\x97\x02\xf6\xed\xf6\x96\x6c\x19\x26\xcc\x53\x99\x2f\x27\xa9\xf2\xb3\xa5\xbc\x61\xa4\xd7\x4d\xbd\x0d\x1c\xaa\x3f\x02\x07\xb2\x6c\x78\x11\xc1\x5a\x9d\x03\x0f\x87\x1c\x79\x41\x56\x2a\xa4\x46\x2a\x05\xf2\xd4\x20\x65\x12\xde\xa6\x25\xc0\x77\x34\x3b\xae\x94\x6e\x8a\x68\x6a\x5c\x29\x8d\x8b\x68\x5e\x5c\x85\x77\xf8\x6b\xac\xbb\x39\x18\x33\xfa\x25\x0d\x61\x2e\xb3\xc9\xb0\x62\xa1\x8d\x9c\xd7\x21\xd4\x6a\xf5\x92\x5d\xea\x8c\x89\x0c\x93\xd8\x4b\x9b\xc4\x67\x70\x2a\x7f\xa7\xc3\x96\x13\xe6\x3e\xfd\xbf\xe2\xf3\x6a\x66\x1f\xb0\x96\x17\x88\x35\xae\xe5\x05\xf9\x95\x08\xdd\x89\xc8\x0f\x64\x30\x4e\x96\xe3\x18\x04\x68\xf4\x02\xf2\x1b\x5b\x25\x0d\x43\x5d\xbd\x52\x8c\x21\xc0\x7d\x85\x31\x04\x77\xf8\x22\x35\xd3\x7f\x4c\x33\x1f\x66\xd0\xff\x43\x56\xe6\x04\xcf\x80\x32\xe0\xa6\x5f\x59\xdc\x4a\x38\xcb\x85\x6c\x0e\x8f\xb1\xfb\xf2\xa9\xb9\x6f\xcf\xb1\x88\xd4\xac\x26\x88\xcd\x98\x09\x50\x35\xd1\x04\x48\xbc\xe3\x06\x18\xd1\xa2\xec\xf5\x3d\x78\x50\x24\x1d\x30\xcd\x13\xb4\x71\x61\x2f\x8a\x05\x10\x91\x5e\x14\x05\x63\xd6\x98\x04\x64\x5c\x8b\xf1\xc5\x73\x09\x46\x52\x33\x9c\xd9\xc6\x0c\xa1\xa6\x3d\x5a\x4b\xb2\x7c\x4a\x36\x70\xcc\x30\x82\x82\xcb\x13\xcd\x95\x42\x37\xff\x4c\x30\x6f\xe7\x5e\x74\x06\xef\x9a\xfe\x74\x84\xf8\x35\xce\xb5\x9a\x75\xa8\x66\xbb\xae\x38\x4c\x18\xb7\x69\x62\x30\xee\xf7\x08\xca\x4d\xa6\xdd\x6f\x02\xf9\x7f\xc0\xc2\x1d\x73\xd2\x9a\xc7\x0e\x72\x11\x66\x88\x1f\x85\x4e\x60\x88\x59\xd8\x40\x1f\x7e\x3e\x04\x35\x31\x14\x77\x7f\x1b\x2f\x9b\x24\xf2\xde\x93\x97\x4d\xe2\xc8\xfd\xd3\xbc\x6c\x26\xb3\xe7\xf4\x76\xda\x3f\xce\xcb\x46\xe3\xe5\x7f\x8a\x93\x4d\xba\xa7\xee\x44\x97\x5a\xc3\xf2\x77\x2d\xe6\x64\x13\xdb\x47\xad\xc9\x8d\xd4\x64\x57\x9b\xb5\xa9\x5d\x6d\xd6\xb8\xab\x8d\xd1\xb7\x99\x9c\x59\xee\x47\xb1\x58\xd0\xa1\x65\x11\x24\xd0\xa1\xc5\x14\x6a\x6f\xf8\x31\x77\x4c\xcf\xd2\x3d\x3d\x0c\x0d\xe8\xa1\x75\x1f\x81\x55\x61\x71\xe7\x1b\x47\x9c\x2f\xc4\x1c\x70\xd4\xc9\x43\xa2\xff\x8d\xae\xda\x9b\x15\xb5\xbd\xd5\x3d\x7a\xee\xe8\x3a\xcf\x8f\x70\xb1\x29\x46\xbc\x68\xf4\x79\x73\x53\x53\x74\x2b\xc1\x49\x8f\xfe\x62\x5c\xd5\x74\xaa\x59\x3c\x6e\xee\x49\x92\x27\xdd\x50\xdf\xbb\xc7\x4d\x44\x7e\xdf\xaf\xc3\x4d\xf2\xd4\xb8\x07\x87\x1b\xfd\x68\x69\x91\x71\x88\xbb\x42\xcf\xbb\xee\x99\xfa\x3c\x90\xc7\x90\x39\x45\xc5\x58\xf1\xae\x40\x37\xfe\xd2\x3e\x44\x33\xb0\xf4\x3d\x32\xf4\xb4\x5a\xf4\x8f\x76\x21\x5a\xc0\x0d\x37\x72\xc4\xb0\x3e\xcd\x11\xc3\xba\x3c\x37\x30\xdd\x88\x38\xac\xff\xec\x90\xb2\xf2\x25\x7a\x38\xaf\xa2\xbf\x34\x0f\xcc\xed\x54\x14\x73\x26\x4a\xe0\x9a\x04\x7f\x1e\x79\x7f\x92\xed\xce\x53\x99\xc7\x9d\x47\xc2\x4e\xf1\xe6\xb1\x12\xbe\xcf\xe1\xcc\x93\x2c\x9d\x17\x72\xe6\x49\x06\xb9\xa8\x33\x4f\xb2\x69\xda\x34\xce\x3c\x92\x52\xd9\x8e\x30\xd9\x0d\x4c\x32\x54\x4e\xad\x3d\xd9\x11\x26\xb5\xaa\x72\x84\x21\x70\xc6\xfe\x9a\x66\x7a\x15\x3d\x50\x07\x26\x1b\x92\x3f\x44\xdf\x95\x35\x74\xb6\x2f\xd6\x24\xb4\x27\xfa\x62\x4d\x01\xc0\x9f\x98\x4d\xe3\xaf\x4a\x7a\xa4\xe0\x24\x5f\xb2\x54\x20\xc2\x97\x6c\xa2\x91\xff\x03\xf5\x1f\xa7\xf6\xac\x92\xa6\x0d\x92\xe6\x6c\xaf\xfe\xe6\xa0\x71\xfe\xe9\x1d\x0a\x99\x4c\x9b\xfc\x89\x5c\x38\xa5\x0f\xd2\x03\x91\x61\x92\x1f\x4f\x7a\xb3\x9a\x0f\x92\x7e\x96\xbe\x90\x9c\x1d\xe0\xe1\x27\x08\x5a\x3c\x8d\x57\x4e\x4e\x7f\x67\x02\x4d\x72\xd2\xfa\xab\xe1\x0e\xce\x49\xf3\x77\x7a\xae\xaa\xdc\xbb\x8b\x4f\x89\x89\xfe\x90\xa9\x70\x26\x7b\x45\xa5\x0b\xb6\x59\xfc\x21\xd3\x11\x98\xcd\x1f\x72\x82\x84\x56\xfe\x90\x93\x1d\xd7\x26\x2d\x96\xd3\x3b\x55\x4e\x9c\xa9\x68\x52\x50\x14\x77\xbd\x8a\xcd\xa7\xf2\x8a\xcb\x64\xbc\x29\x1d\x8b\xa4\x26\x16\xd3\xc3\xca\x31\x77\x9d\x64\x57\xa3\x14\x27\x20\xd3\xeb\x08\xfb\x97\xee\x63\x94\xe5\x75\x84\x8b\x23\x98\xf1\x3d\x8c\xc3\x90\x61\x13\x16\xf1\x17\x5a\xfb\x2b\xf9\x0b\x3d\x88\xc3\x4c\x2c\x55\xe1\x5c\x6e\x41\x0b\x39\xcc\x54\x1e\xd0\x61\x26\x39\x9b\xd9\x5c\x4e\x41\x8b\x3b\xcc\x54\x67\x74\x98\xf9\x69\xe1\xff\xd3\xc2\xff\xa7\x85\xff\x4f\x0b\xff\x9f\x16\xfe\xff\x60\x0b\xff\xcf\x60\xe3\x2f\xed\xf9\xd9\xec\xfd\x3c\xad\x49\x7e\xd2\x82\xf2\x20\x26\xf9\x9f\x27\x58\xe2\x7f\x9e\xc2\x00\xff\xf3\x5c\x76\xf7\x9f\xa7\x35\xb7\xff\x3c\x8f\x95\xfd\xe7\x04\xe3\xfa\xd9\xee\x1b\x62\x87\xf5\x09\x67\xd1\x9f\x27\x1f\x41\xcf\x9a\xb5\xf8\x73\xc6\xc9\xf2\x34\xa7\xb5\xd9\xe9\x65\xb3\x4e\x6b\x57\x57\xc1\xca\xde\x65\x88\x78\x1d\xb4\x2d\xe6\xc8\xd1\x36\x5b\xbe\x43\x9e\x18\x66\x89\x40\xa1\xff\x83\x24\xb7\x93\x8f\x35\x27\xe4\xc7\x35\x7a\x3a\x74\xed\x70\x62\x4f\x59\xa1\x7f\x42\x4f\xff\x1c\x52\x62\xb7\x59\x77\xbf\xad\xf0\xae\x7d\x9b\x7c\x34\xff\xb7\xe8\xdd\x15\x1d\x4f\x1c\xc6\x29\x4e\xf1\xff\xaa\x7d\x9d\xab\xaa\x3a\xc5\xe7\x44\xf2\x2d\xb7\x0b\xf3\x9a\x13\x04\x9e\xe7\x22\xc7\xe4\x23\xa4\x09\x1d\x9a\x2e\x7c\xcd\x03\x0d\xc7\xdf\x36\x7c\xcd\x84\xa1\x86\x23\x94\xf4\x63\xa1\x6f\xc6\xf1\x0f\x1f\xfc\x8b\x67\xeb\x45\xf2\x6c\xfd\x32\xf1\x44\xc8\x8c\x50\x73\xef\x27\x34\x9f\x53\x0e\x66\xd6\xb3\x0e\x66\x38\x98\x19\x0e\x63\x38\x35\xc9\x1f\xf5\x53\x72\xf4\xf6\xf7\x83\xbd\xf3\xa3\x93\xb7\xe4\xe9\xaa\x82\x3d\xf0\xbd\x16\x05\x5d\x9c\x6b\x71\x7b\xde\x60\x0c\xd1\x74\x48\xbe\x55\x20\xd5\x72\x65\x6d\x65\x80\x56\x64\x45\x72\x68\xb5\x68\xd3\xf3\xae\x8a\xe4\xc8\x6d\x95\x96\x08\x54\x38\x67\xdb\x10\x1e\x52\xa0\xe5\xb5\x29\xb1\x03\xe2\xd8\x2d\xea\xb2\x6d\xc8\x90\xa9\x15\x20\x89\x8e\x8f\xce\xc5\x6b\xd2\xf1\x86\xae\x10\x51\x0c\xc4\x9b\xa3\xbd\x83\xb7\x67\x07\x84\x29\x90\x42\x72\xf9\x9e\x17\x72\xbf\x50\xcf\x07\x09\x17\x6a\x0d\x85\x3e\xa5\x25\xa1\x5c\xf2\x8d\x2b\xeb\x47\x89\xba\xd7\xa5\xb7\x27\xfb\x07\x8d\x83\xb7\x7f\xc0\x56\x21\x37\xf0\xbd\xf6\x10\x3a\xcb\xcd\xf7\xe1\xb4\xc0\xbd\xb6\x7c\xdb\x72\x53\x8e\x4c\xf2\x5b\x9b\xa0\x59\xb1\xa2\x23\xcb\x77\x6d\xb7\x9b\x76\xa0\x51\xa9\xca\x92\x70\x1d\xf4\x4e\x68\x2c\x67\xb4\xe5\xd3\x34\xf8\x15\xc8\xaf\xcb\xad\xe7\xbc\x6e\x97\xb6\x59\x9d\x43\xcb\x76\x86\x3e\x2a\x3b\x77\xdb\x4b\x4a\xb5\xae\x07\x01\xf5\x43\x12\xf6\x2c\x74\x95\x02\xf5\x2d\x20\x7d\x2b\x6c\xf5\xc8\xc8\x0e\x7b\xe8\x40\xc5\x36\x26\xc1\x80\xb6\x02\x46\x1a\x02\xdb\x21\xd2\xa7\x41\x60\x75\x69\x40\x2c\x9f\x92\x3e\xed\x7b\xbe\xfd\x8d\xb6\x89\xe5\xb6\xc9\xc8\x66\x1b\x21\xd7\x19\xb3\x5d\x51\xd0\xf3\x46\x2e\xf1\xdc\x16\x15\x03\xcb\xfd\xad\xbe\x7b\xdc\xdd\x8a\x81\x3f\x63\xd0\xc9\xb1\x35\x60\x03\x02\xba\x52\xe8\x11\xcb\xec\x79\x52\x5d\x8e\xf0\xe9\xd0\x65\x52\x44\x3c\x42\x7f\x5c\x4a\xdb\x0c\x4a\x13\x3b\xb0\xd2\x62\xba\x35\x6d\xeb\x50\x02\xee\xc5\xe5\x78\x2d\xf4\x24\xa2\xa5\x6e\x89\x3c\x66\x12\xe1\x71\x91\x3c\x6e\x79\x6e\x48\x6f\x42\xf8\x09\xa6\x5c\xe2\x45\x12\x0c\x69\x9f\x0c\x2a\xe7\x5b\xae\xee\xa1\x2f\x29\xff\x02\x87\x4a\xd4\xa0\x5e\x49\x07\xf5\x42\xd8\x6a\xdf\x91\x2e\x0d\xcf\x42\xab\x75\x45\x50\xbb\x0f\x22\x80\x02\xf6\x8d\xd7\xf5\xed\x6b\x2b\xa4\xc0\xb3\x52\xed\x86\xbe\x4a\x8e\xc9\x4b\x0a\x73\xdb\xf8\xa0\x28\xbb\x5c\x34\x11\x2f\xca\x96\x91\xa7\x67\x9c\x02\x44\x9d\x9b\x89\x36\x81\x12\x6c\xee\x09\x1c\xd4\x5e\x40\x6c\xd2\xe1\x75\x24\xee\x47\x5e\xaf\x5f\x88\x1a\x86\x02\x11\x95\xe5\xe6\xea\x2a\x61\xf5\x90\x51\xaf\x2d\xc7\x6e\xe3\x70\xf6\xad\x31\x6e\xe5\x4b\xe4\xc8\xc5\x6c\x64\x61\x8f\x8e\x49\xdb\x2b\x92\x11\x25\x6d\xcf\xcd\x85\x64\xc4\x66\x6b\xe8\xe9\xc0\x3a\x96\xed\xa0\xb0\x80\xed\x0b\x19\xf4\x58\xd5\x51\x8f\xfa\x94\xd8\x4c\x7a\xb4\x59\x45\x28\xd5\xa4\x1d\xcf\xa7\x25\x72\xe6\x31\x88\x8e\xd7\x25\x76\x58\xd2\x61\xd5\x3b\x21\x4a\xaa\x80\x92\x9e\x75\x4d\xf9\x81\x89\x43\x2d\x97\xc9\xb1\x01\xc3\x24\xe7\x38\xc4\x41\x6f\xc5\x3e\x47\x58\xd9\xf2\xf8\x63\xc3\x04\x14\x14\x0f\x3b\x60\xd2\xd0\x76\x43\xb6\xe0\x79\xae\xe5\x38\x63\x62\xb9\x9a\xf4\x81\x19\xd0\xa5\x61\x40\x5a\xd6\xb0\xdb\x0b\x4b\xe4\x28\xcc\x21\x17\x05\x56\x9f\x9a\xf0\x9a\xb4\x67\x5d\xdb\x9e\x4f\xac\x00\x26\xbd\x37\x0c\xb9\x50\x0c\xad\x10\x2e\xc8\x08\xbd\x69\xd1\x41\x88\x22\xc1\x22\x4d\x0a\x86\x7a\x9c\x89\x4b\x86\x81\x2a\xc7\x40\x9c\xbe\xc8\xf1\xbd\xd0\x07\xf4\x12\xbd\x9f\x04\xbf\xb2\x05\xfb\xdf\x41\x8d\xfc\x3b\xc0\x21\xfc\xf2\xef\xe0\x0b\x76\x10\x06\x73\x9b\x11\x1d\x0e\x5b\x9a\xd4\x38\x5d\x19\x06\x43\xe8\x7a\xc7\xf7\xfa\x10\xf7\x3e\xc7\x3a\xf8\x85\xcd\xdf\x15\x58\xd1\xbf\x10\x26\x1f\xad\x2e\x2d\x92\xe6\x30\x24\x3e\x6d\x51\xfb\x9a\xb6\xa1\x81\x52\x2e\xc2\xfb\x6c\x05\xce\x81\xc4\xc1\x73\xb7\x9c\x3e\x4b\x74\xec\x8b\x24\xbb\x73\x05\x3d\x11\x1d\xce\xf7\x9d\xb4\xb2\x79\x31\x21\xcd\x06\x22\x93\x52\xe1\xc1\x36\xce\xc5\xc4\x15\x41\x6b\xf5\x8e\xb4\x40\x82\xe7\xe9\x4d\xc1\x60\x1e\x81\x0c\xbd\xd1\x0a\xcb\x5f\x7c\x45\xca\x3f\xc2\x62\xb7\xb7\xbc\xbc\x76\x86\x09\xb2\x9f\x8f\x96\x5c\x16\xec\x8e\xcd\xe5\xa7\xd7\x61\x63\x18\x1b\x3e\xb9\x88\xa0\x0c\xf6\x71\xac\xa4\xb4\x82\xa1\xe5\x7b\xff\x2f\xac\x83\x5f\xe0\x18\xcd\x25\x5f\xa0\xb9\x2f\x7c\xec\xd8\x77\xb6\xc2\x90\x7f\x07\x25\x84\xf0\xc9\x1b\xc2\x1c\x87\x79\xd5\xf1\xfc\xae\x17\x86\xd4\x65\x42\x7f\x00\xe7\xa6\xae\x3c\xd1\x00\xa7\xf8\x44\x2c\xe0\x78\x83\x09\x2d\xae\x80\x17\x65\x77\xd9\x6f\x5c\x67\xe0\x97\x4b\xe5\x3f\xe7\x70\xec\xc6\x96\x3a\x00\x01\x57\xb8\xc4\x72\x1c\xc2\x17\x62\xbd\xe5\xc2\x3d\xf0\x19\x0c\x83\x36\xbe\x4c\x70\x26\x0f\x0d\x79\xf2\x84\x3c\xc2\x6f\x25\x3e\x3d\x99\xf0\x8d\xab\x02\x85\x42\x54\xaa\x9c\xb0\x05\xbb\xef\xb9\x36\xa3\x06\x4c\xff\x0e\x96\x85\xc5\x9b\x34\x69\xcb\x1a\xa2\x00\xf5\x29\xc1\x40\x52\xb8\xba\x5a\xc4\xf1\x42\xbe\xd8\x99\x20\x99\xa8\x41\xe4\x75\x19\x11\x47\xe6\xc2\x40\xf8\x52\xdc\x58\x2c\x19\x3e\x36\x3e\xae\x7a\x64\x47\x2d\x8e\x2f\xe4\xcf\x7c\x81\xd4\x48\x2e\x67\x54\x11\xec\xcc\x0f\x3c\x73\xac\x35\xda\x16\x42\x86\x49\x9b\x7f\x9b\xb4\x37\xb0\x28\xf2\xe6\x1e\xe1\xa9\x30\x79\xc1\x9f\x59\x33\x85\xf8\xec\xb9\x53\x87\x59\x4c\xbf\x42\xd5\xba\xc4\x35\x6b\xb2\x13\x59\x91\x51\xc5\x4f\xd3\xa2\xef\x30\xe8\x55\x96\x5a\x9e\x5f\x2b\x14\x0a\x31\x2d\x7f\xe3\x5e\xb5\xfc\xbf\xab\xda\x9e\xa1\x32\xe7\xce\x0e\xf6\x4e\x0f\xce\x1b\xfb\x27\x8d\xb7\x27\xe7\x8d\x77\xf5\xb3\xb3\xc6\xf9\xab\xa3\xb3\xc6\xc9\x69\xe3\xd3\xc9\x87\xc6\xc7\xa3\x37\x6f\x1a\xbb\x07\x8d\xc3\xa3\xd3\x83\x7d\xc6\x4d\xb1\x71\x4c\x02\xbc\xbd\x14\x1b\x89\x67\x0b\x8d\xc4\xea\x2a\xd9\x2c\x55\x4a\x15\x72\xee\xbd\xf3\xed\xbe\x1d\xda\xd7\x34\x6f\xbb\x83\x61\x48\x2e\x8a\xe4\x9d\x4f\x3b\xd4\xf7\x71\x0a\x5d\x16\xa0\xbf\x76\x80\xa7\xbc\x29\xdb\x82\x0d\xb8\xed\x5e\x05\x71\x41\xad\xb6\xd0\x4c\x0f\xce\x9e\x81\x00\x27\xd7\xd4\x0f\x60\x0a\x30\xad\x08\xb5\x1b\xbb\x3f\x40\xe3\x18\xf2\xdf\xff\x86\x0a\x0d\xd0\xa2\x18\x28\x26\xfd\x40\x9d\xa0\x2d\xcf\x6d\x2b\x41\xbb\x42\x3a\x8e\xd5\x25\x2b\x64\x20\xd0\x44\xa1\x6b\x07\xc4\x22\xa8\x2c\xc7\xa9\xaa\xce\xd4\xed\xb0\x48\xce\x94\xee\xf9\x48\x74\x2c\x6f\x87\x85\x82\x58\x24\xec\x50\xec\x71\x3a\x2e\xa8\xb4\xdb\xbc\xf8\x19\x18\x47\xa3\xd0\xcc\x77\x5c\xb2\xc3\xb4\xb1\xd0\xc3\x68\x0d\x05\x62\xe8\x1c\x20\x2a\x25\xf8\x6b\xcb\x61\x78\xb8\x38\xf5\x58\x63\xb2\x35\x0d\x7e\x14\x34\x2c\xde\x27\x9d\x7b\x80\xfc\xe8\x21\x51\xc7\xeb\x2c\xf3\x96\x31\x17\xb2\xed\xcc\x35\xdb\xfe\xe1\x22\x07\xcb\xa6\x1c\x66\xbc\x5e\x2e\x6c\x2f\xdd\x25\x70\xf7\xe6\xa2\xdc\xdd\xb1\x1c\xa7\xc9\xa4\x29\xdb\x2e\xb8\x9e\xbb\x02\x8b\xef\x8a\x63\x5f\x31\xa6\x5c\x03\xe6\x62\xaf\xb5\xeb\x71\xcf\x69\x93\x3f\xb6\x38\x07\x05\x4b\x18\xd9\xa2\x93\xba\x0d\xde\x42\x86\xa7\x81\x63\xbb\xe1\x4a\xdb\x0e\x18\x90\x15\x97\xde\x84\xe0\xd5\x42\x5c\x6f\x45\xde\xa0\xad\x34\x87\xb6\x13\xda\x6e\x10\x67\x4c\x4e\xe2\xdc\xb7\x5c\x01\xee\x0c\xd8\xd6\xe4\x28\x38\x90\x68\xe5\xcb\x05\x79\xf5\x45\x6a\x06\x1f\x23\x13\x8b\xdb\x50\xaf\x03\xaf\xd8\x30\xe2\x90\xe6\xc8\x0b\x36\xc2\xc1\xc0\xb1\xc3\x7c\x2e\xc7\xd6\x2f\xc5\xe9\xc9\x64\xdf\x9a\x82\xec\x40\x61\xd8\x7f\x71\xd6\x81\x3d\xbf\x64\xa4\x24\x91\x96\x8a\xb4\xa8\x24\x19\xab\x14\x30\x91\x9d\xdf\x2a\x92\x95\x4a\x0a\x8e\xcf\xa7\xc5\x11\x64\x5c\xb5\x54\x21\xa7\x38\x6a\xd8\xf9\x3d\x8f\xfa\x2d\x9b\x11\x56\xea\x4f\xd3\x20\xcc\x66\x90\x1d\x32\xea\xb2\x15\xa6\x63\xbb\xb4\x5d\x48\xe5\x7a\xa6\xa8\xf5\x69\xd8\xf3\xda\xc4\x73\x09\x5c\xcf\xda\xa8\x3d\x6b\xe2\x25\xa1\x6f\xcf\xca\x33\xf5\xad\x52\x5a\x27\xe7\xde\x91\x1b\xd2\x2e\xf5\x91\x5f\xa9\xed\xc8\x50\x2c\xd4\x76\xd0\x62\xa5\xe3\x78\xa0\x93\xc3\x6b\x78\xd8\x9e\x61\x8c\xec\xe0\xad\xf5\x16\xfa\x4e\x96\xd9\xa7\x17\xa4\x4c\x6a\x40\x8c\xdf\x48\x99\xbc\xe0\xd0\x6b\xd0\x76\x21\x95\xb5\x9e\x55\x16\x9a\xd1\xa0\x9c\xf5\x2c\x26\xeb\xd3\x02\x32\x57\x0b\xf9\xdc\x15\x1d\x07\x39\x6e\xa7\x33\xb4\x53\xcb\x82\x2d\x4f\x06\x05\xae\xe8\xd8\x20\x01\xb6\x8c\xc1\x40\x6f\x6f\x49\x5e\x7f\xde\x61\x0d\x41\x8d\x94\x8e\x67\x46\xb8\x9e\xaa\xe3\x5d\xc7\x6b\x82\x04\x4e\x54\xd3\x9e\xf1\xfe\x9e\xbd\xaa\x9f\x1e\xec\x33\x15\xa4\xd1\x68\x79\x3e\x5d\xf9\x1a\x34\x10\xd1\x46\x23\x87\x45\x82\xd0\xf3\x29\x53\x6f\x01\xe0\x05\xd6\xc0\x2e\x45\x5e\xb1\x29\x3d\x23\x8d\x18\x6c\x8d\x44\xea\x91\xc3\x4a\xa2\x4d\xa6\x35\x5f\x84\xdf\x8f\x0e\xc8\xd6\x0a\x3f\x51\x61\x52\x9b\x34\x87\x5d\xc2\x06\x3c\x8e\x65\x7e\x89\x90\x9c\x66\xb1\x50\x34\x4f\x7e\x8a\xe0\x3e\x2b\xee\xa9\x8b\x49\x52\xb7\x18\x7a\x6f\xbc\x96\xe5\x50\x94\x4f\x45\x21\xa8\x8a\x7c\x3d\xce\x2d\x15\x84\x60\x2d\xe6\x0a\x09\x3d\x9b\xe6\x38\x1c\x7a\xc6\x7f\x97\x3a\xca\x30\xa3\x4b\x43\x0d\xdb\xb3\x71\xbf\xe9\x39\x41\x42\x1b\x8b\x29\xe3\x31\xaa\x7d\x27\x8f\xf9\x55\xc0\xe3\x5a\x22\xab\xad\x57\x9e\xc3\x4d\x07\x0d\x8e\xa1\xae\x30\xe2\x88\x5d\x06\x3c\x5b\x4c\x39\x35\xb7\x09\xc0\xb9\xbf\x5a\x69\x8a\xe7\x7a\x75\xa3\x90\x67\x78\xc0\x9d\xc4\x2a\xa9\x56\x4a\x95\xd2\x5a\xa9\xba\x49\xf8\xd2\x22\x17\xe1\x8b\xff\xfe\xd7\x0e\xa9\xcf\xf6\xe2\x97\xf9\xc2\x52\xb2\x14\xd9\x2c\xe4\xf9\x48\xcb\x65\xb4\x68\xc8\x46\x06\x80\xc9\x7e\xb8\xd3\xef\xd9\x41\xa9\xc1\x30\xc3\xa2\xea\xf3\x36\xdb\x9c\xa2\xe1\x9b\x2c\xc7\xed\xfc\x22\x7f\xab\xab\x84\xe9\x0c\xe8\x78\x2d\x3b\xb0\x01\x0b\xd7\xbf\x11\xec\x11\xc7\x5a\x32\xed\xbf\x4b\xac\x4a\x1e\xee\x8e\x0c\xfb\x43\xae\xb3\x9e\x08\x47\xcb\x86\x54\x63\x01\xbc\x7c\x6d\x8b\xd7\x70\x13\x26\x34\x44\x2c\xf3\xdb\x0e\x39\x91\x3e\x90\x32\x52\x1a\x37\xbb\x90\x8b\x5f\x91\xcd\x44\x8d\x03\x08\x8f\xf0\xb7\xc3\x86\x2a\x7f\x52\xc4\x06\x0b\xdb\x5a\xef\x97\x77\xb0\x8c\xb0\x6f\x5c\x22\x31\xf0\xf0\x5d\x80\x86\x5d\x35\x83\x7d\x97\x34\xc1\x16\xd3\x10\x13\x58\xec\xcd\xd1\xee\x69\xfd\xf4\x53\xea\xfa\xb2\xc5\xe5\xec\xaf\xfc\x9e\x2c\x25\xa6\xf7\x26\x2f\xe6\x53\xa4\x54\x5a\xb9\xf5\x2a\x2f\xd8\xb3\xdb\x69\x85\x36\xca\xa2\x8c\x15\xa4\x05\xf8\x16\x60\x04\x93\xa4\x15\x7c\x2e\x60\xfd\xca\x98\x74\x0f\x4c\x6e\x52\xa7\x94\x58\x53\x02\x1a\x9e\x73\xc9\x77\x6e\xa5\x5f\x24\x3d\xe7\xc5\x4d\x03\xa0\xd4\x9e\x0b\x4c\x8e\xce\x0f\x4e\xeb\xe7\x27\xa7\x69\x2b\x5b\xb9\x90\xcf\x89\x19\x2b\x56\xf5\xdd\x0f\x2f\x5f\xb2\x31\x7a\x94\xbf\xb8\x2c\x31\xe9\xcf\x76\x2a\x39\x36\x1d\x72\x6c\x23\xcf\x5f\xe6\x0b\x38\x03\xcf\xac\x8e\xe5\xdb\x40\xbe\xe6\xb0\xdb\x1d\x13\x5b\x52\x69\xb4\xea\x91\x2f\xac\xde\x17\x80\x7b\x78\xd8\xd0\xd0\xc9\x29\x51\xc1\x97\xce\xd7\x07\x9f\xce\xd8\x07\xd0\x30\xf0\xd5\x1f\xf5\x37\x1f\x0e\xe0\x25\x9e\xb0\xe6\x38\x23\x21\x53\xc3\x29\x45\xd4\x3c\x58\xa8\xbd\x3d\x3b\xc0\x90\xe1\x19\x0b\xec\xae\x15\xd0\x22\x79\x5b\x3f\x3e\x30\x2c\x40\x8b\x20\x2e\x8a\x64\xff\xe0\xb0\xfe\xe1\xcd\x79\x91\x1c\x9d\x35\xce\x0e\xce\x8b\xe4\xf0\xe4\x74\xef\x60\x1f\x85\x80\x36\xc6\xa6\xd5\x2a\x82\x63\x10\xe4\x25\x5e\x97\x86\xc7\xa8\xab\x1a\xcb\xbb\xed\xb6\xc5\x01\x1e\xec\x1e\x91\xf0\x4f\x9e\x10\xf6\x85\x91\x1a\xe4\xaa\x94\x10\xf0\x74\xc1\xbe\x5d\xe2\xd1\x55\x30\xb2\xe1\x80\x58\x07\x44\xf0\x86\x84\xd1\xb2\x16\xb3\xf6\xc5\x71\x53\x44\x72\xe9\x48\xef\x37\x37\x20\x03\x70\xdb\x22\x22\x23\x07\x88\x23\x11\x07\x89\xe3\x32\x2b\xd0\xb8\x21\x32\x75\x43\xdf\x9e\x15\xd0\x9d\x20\xf0\x79\xfd\x25\xd9\x01\xca\x93\x65\x92\x93\x13\x35\x27\xbe\xef\x1f\x1c\x36\x24\x2f\xf1\x61\x65\x1b\x0d\x7c\x27\x4a\xe1\x53\x63\xf7\x03\x03\x86\x66\xdc\x4b\x32\x08\x5e\xe8\x91\x1d\xc2\x18\x46\xad\x76\xe2\xeb\xaf\xae\x05\xdb\xed\x1d\x3e\x44\x82\xcb\x41\x4d\xc3\x57\x1a\xef\xc3\x5b\x81\xc3\x93\x27\xbc\x00\x7f\x71\x29\x61\x2a\xab\x7d\x01\xfe\xf6\x56\x31\x52\x9e\x97\x97\x2c\xf6\x2b\x27\xa0\xd6\xbf\x17\xe4\x91\xd6\xef\x17\x0a\x64\x4d\x83\x93\xe3\xf5\x60\xef\x2a\x97\x1e\x09\xd5\x72\xc7\x6f\x45\xe7\x80\xbc\x6c\xef\x5b\x67\xfb\x7c\xb6\xf5\x05\xd4\x4b\xa2\xe5\xdb\x5b\x89\x6a\x4d\xfc\x12\x80\x70\xab\x16\x40\xf0\xff\x22\x89\xad\xb6\xdb\x68\x8c\x73\x68\xdf\x10\xac\xc7\x97\x4b\xd5\xbe\xe0\xef\x58\x55\x3c\x4a\xd6\x8d\x22\x55\x25\xdc\xf3\x32\x3e\x62\x03\x97\x2f\x88\x88\x65\x0c\x74\x1c\xd0\xa3\x1d\xa9\x1e\x2a\x53\xde\x27\x4f\xe2\x4d\x82\x6a\xa0\x26\x1c\x13\x82\x14\x4f\xd8\x94\x1c\x0f\x3d\xde\x13\x25\x0f\x79\x71\x53\xe0\xc7\xf1\x28\x32\x6e\x2e\x12\xae\x6f\xc9\x26\x3a\xf6\x0d\x1c\xb4\x04\x5e\x1f\xcf\x51\xa8\xdb\xb5\x5d\x1a\x68\xd7\xb0\x8f\xc4\xfa\xfa\xe4\x09\x79\xd4\xb3\x82\x24\xd8\x82\x0b\x0b\x05\x58\x15\xb3\x8a\x14\x35\x31\xab\xc7\x1c\x58\x92\xf8\x00\x23\xfc\xeb\xbb\xb8\xfd\x52\x12\xfd\xae\xe4\xf2\x1b\xe3\x3f\xb6\xc8\x2a\x39\x3c\xe4\xe3\xa9\xf1\xe3\x93\x27\x92\x5b\xd4\x4f\xac\xf6\x48\xce\x4c\x41\x64\x63\x66\xe2\xb5\x02\x7b\xad\x4d\x92\x0c\x81\x24\x60\x03\x33\x84\xd0\x19\x2e\x3e\xb0\x27\xfb\xa8\x44\x08\xdc\x39\xaa\x8a\x9a\xb7\xb7\x52\xf0\x3f\x79\x42\xf2\x28\xa5\x6f\x6f\x75\xa4\x6e\x6f\xc9\xa3\xc8\xdc\x97\x77\x33\x40\x66\xf8\xa8\x93\x56\xa0\x5e\xd0\x10\x79\xe7\x0c\xbb\x30\xc6\x8e\xdd\xf4\x2d\x48\xab\x2d\x55\x8e\x0b\x36\xfb\xd8\x46\x4f\x54\xdc\x36\xbe\x9e\xd7\x5f\xb2\x8f\x6a\xc0\xb6\x15\xc5\x41\x4e\x70\x64\xf8\x3c\xe4\x96\x4f\x44\x18\xfb\x06\x35\x32\x59\x54\xf0\x21\x11\x11\x2a\xd8\x62\x52\xe3\x4b\x63\x5a\x15\xb6\x0c\xc9\x0a\x5c\x4e\xd4\xa4\xac\x42\x96\x52\x53\x52\x50\x19\xcc\x0f\x78\x9e\x11\x8e\xb0\x69\x6f\xf0\x48\x7c\xc5\x05\xb2\x20\x35\x41\x41\x67\x90\x32\xbc\x2a\xec\x90\x05\xff\x62\xfc\x3b\xae\x5f\xe6\xf9\xbf\xa5\x77\x64\x59\xbc\x2b\x1d\x92\xa7\x89\x63\x5c\x10\x2b\xbb\xc0\x48\x0c\x1c\xe7\x32\xfe\x3a\x79\x13\x3e\xf5\xa1\x5f\x4c\x59\xe1\x77\x68\x51\x80\xd3\x9c\xd0\xa5\xab\xe6\xfa\x86\x38\x45\x2d\x8c\xb7\xb9\x39\xcd\xc9\x59\xf6\x29\xcb\xf1\xc1\x79\x3d\xe3\xc0\x28\x9f\xeb\xd3\xd0\x12\x6a\xe8\x34\xb7\x21\x53\x2a\xee\x01\x0d\xf7\x69\xd0\x4a\xeb\x6d\xb5\x50\xea\xf0\x36\xdb\xb0\x81\xe4\xed\x1f\xdc\x84\xd4\x05\x4b\x7d\x75\x70\x60\xbc\x35\x72\xee\x98\xa7\xae\x30\x6c\x77\x08\xe9\xf0\xf4\xe0\xe0\xf3\x01\xd3\xa8\x13\xb1\xac\x14\xf2\x29\x50\xf4\xc6\x54\x8e\x1d\x7a\x4d\xdd\x90\x7f\xf0\xdc\x20\xff\x1d\x22\x71\xde\xa9\xbe\x1e\xd3\xd0\x4a\x3c\x6e\xe4\x74\x80\xfb\x19\x36\x16\x45\xb5\x2d\xe4\x6a\x68\x8d\xe4\x4e\x72\x64\x99\x2c\x2f\xdb\xed\x22\x93\x49\xfc\x5a\xe1\x68\x1f\xbe\x8f\x6a\xe4\xfb\x9d\xb1\xb1\x1e\x51\xeb\x8a\xb4\x3c\xc7\xc1\x14\x0d\x01\x39\xda\x67\xf3\x1a\xbc\x4e\x44\xff\x3b\x56\x10\xbe\xa6\xe3\xd8\x15\x11\x3a\x25\x20\x6a\xab\xab\x4a\xcd\x15\xd7\x17\x60\xa8\x32\xf0\x69\xc7\xbe\xc9\xbc\x49\xe2\x17\x2e\x78\x76\x9c\x0b\xe0\x30\x07\x4f\xe6\x49\x4d\x5e\xf7\x88\xaf\xf2\xdc\x3e\x77\x06\x01\xa6\xdf\xe5\x0a\x70\x76\x2c\xef\x70\xd8\xc2\x29\x08\x24\x85\xf8\xea\x2a\x69\xc1\xc1\x73\x40\x43\x36\xd5\x2d\xb0\xa8\x0e\x3d\x32\x74\xd1\x36\x87\x74\x7c\xef\x1b\x75\x39\xbd\x94\x4e\x6f\x0c\xa1\x8e\x74\xee\x90\xc7\xa9\x5e\x5d\x05\x07\x23\x97\xb6\x68\x10\x58\xfe\x18\x8c\xe6\xda\x6d\xd9\x8a\x82\x25\xe8\x25\x20\x1c\x28\x08\x50\xc1\x0e\x02\xdb\xed\x9a\x15\x39\x3b\xe4\xf9\xe1\xb8\x22\xb3\x3e\xb0\x77\xea\xd0\xfc\x82\x75\xfb\xb2\x64\xcb\xc1\xeb\xd2\xf0\x23\x1b\xe3\xac\xc1\xfb\x91\x74\x53\xab\xff\xdc\x84\x93\xaa\xfd\x9c\xa4\xeb\x59\x41\x2f\x9d\xf1\xa3\xa4\x1c\x01\x29\x45\x43\x82\x04\x9e\x4b\x3a\x3e\xa5\xdf\xe8\x4a\xc7\xea\xdb\xce\x58\xae\xcc\x4c\x4b\xb1\xdd\x2e\xd0\xde\x73\x0f\xa1\x4c\xea\x75\x09\x97\x2c\x4f\x9e\x00\xe0\xd2\xdb\x83\x83\x7d\xf6\x10\x25\x9e\x54\x08\xb5\xf1\x89\xf4\xce\xbc\x35\xe1\x2a\x3b\x93\x22\xf1\x33\xcc\x25\xc2\xb6\x97\x35\x94\x20\x4b\x84\xb0\x56\xb5\x74\x97\x7c\xb6\xd7\xc4\x0f\xf6\x8e\x33\x51\x4d\xfc\x00\x6f\x79\xde\xb9\x9a\xfc\x95\xb4\x74\x6e\x2e\x7e\xa9\x31\xdd\xd9\x7e\x0b\xcf\xed\x13\x8f\x53\xd6\x78\x99\x69\xcf\xaf\x46\x57\x6c\x00\x52\x8b\x89\xb3\x1c\xd3\x89\x37\x7b\x75\xca\x38\xc5\x60\x3a\xb3\x3a\x98\xfc\x15\x0f\xb3\xc9\x0e\xf4\xa8\xc4\x9f\x6e\x6f\x49\x5e\x7f\xde\x91\x7d\x79\xc1\x24\x7a\x8d\x13\x49\x2b\x0e\x17\x0a\xc8\x65\xac\x81\x52\xab\x67\xf9\xf5\x30\x5f\x2e\x90\x47\x3b\x24\xd7\xc0\xeb\xeb\xbc\x50\xf3\x79\xab\x85\x88\x4b\xef\x38\xcf\x3f\x14\xc1\x1e\x58\x5b\x6f\x90\x44\xa5\x0e\xc7\x3e\xe5\xf6\x62\x73\xb1\x9b\x9d\xc8\x11\xe4\x52\xb2\xf3\xb4\x04\xf3\x58\x9d\xbb\x3f\x2e\x72\x82\x02\xb2\x4c\xe6\xc0\x02\x2b\x14\xa7\xbd\x57\xf5\xb7\x6f\x0f\xde\x90\x1d\x7d\xcb\x8c\x4e\xc8\x26\xf0\x6a\x5a\xe2\xc3\x42\x72\xf9\x35\x56\xde\x76\x43\xea\x7b\x03\x7e\xa7\xba\xcf\x03\x3e\x47\x21\x4b\x08\x46\x80\xb5\x94\x28\x02\x91\x92\xd5\x8c\x66\x64\xa1\xc2\xb6\xe9\xad\x9b\x54\xda\x6b\x7e\xd5\x76\x5a\x5e\xf3\x2b\x63\x0b\xaf\xf9\xb5\xa4\x48\x49\x5e\xc0\xfb\x1a\xf9\x2e\xdc\x20\x6a\xf0\xe2\x0e\xdd\x43\x57\xc9\x99\x25\x8c\xbe\xc9\x30\xa0\x6d\xd2\x1c\x13\xf0\x0b\x5c\xf9\x1a\xa0\x89\x80\xa2\x76\x9c\xfe\xb9\x46\xe3\xfc\xd5\xc1\xf1\xd1\xdb\x97\x70\x05\x87\xb7\xe6\x3d\xda\xa7\x6f\xec\x20\xa4\x2e\x44\x29\x66\x23\xc9\xad\xbe\xa1\x63\x35\x92\x2f\x17\x63\x94\x17\xae\x21\x05\x08\x4e\xc7\x5b\x28\xea\x44\x13\x25\x78\xb0\x1a\xd8\xd8\x70\xb7\x6a\xcd\x6a\x80\xbf\xc9\xf3\x16\x8d\x13\x3e\xfe\xee\x82\x43\xbf\xcc\x74\xa9\xd4\x7d\x46\xa3\x15\x4b\x68\x33\x17\xd2\x3c\xee\x43\xc0\x4d\x65\xd8\x0c\x5a\xbe\xdd\xd4\x5d\x37\xe5\x3b\x81\x4e\x91\xb4\x9a\x0f\x84\x92\xd6\x56\x53\x61\x35\x74\x93\xf0\xd2\xde\x2a\xcc\xf8\x2b\x08\x5c\x7e\x64\x1c\x8d\xa6\x23\x19\xc3\x42\x87\x1c\x01\xa8\x9f\x61\x30\x61\x23\xb8\x49\x9d\x22\x18\x9c\x13\xbb\x73\xdb\x9c\xe6\x2e\xf5\xc7\x4b\xa3\x8b\x1c\xef\x40\x0e\x8c\x2e\xbd\x3d\xf0\x3e\xc2\x78\xe2\xec\xe1\x0f\x98\x5a\x29\x4b\xdb\x33\x25\x1d\x54\xe1\x2c\xf1\xa0\x4a\xdd\xbf\x7c\x90\x1d\x31\x24\x04\xda\x30\x1e\xb9\x6d\xea\x86\xd2\xfc\x0c\xfc\x26\x7a\x61\x38\xa8\xad\xae\x7e\x0d\x06\xd4\xef\x94\x5a\x5e\x7f\x15\x4d\x90\xbe\x7a\xb6\xbb\x72\x1d\xac\x74\x3c\xdf\x74\xa9\xb0\x01\xc8\x59\xe8\xe7\x83\xd0\x2f\xf2\x47\xb5\x76\xfa\x34\x40\x3e\xc8\x81\x66\xad\xc2\x87\xf0\x9b\xbd\xf2\x36\xff\xf9\x1f\x5e\x95\x3f\x43\x10\x11\x3e\x37\x00\xc2\xf2\x0e\xc9\x11\x02\x40\xee\x78\xdf\xc5\x17\x86\xbf\xee\xbd\xb3\x87\xf6\x5b\x01\xb1\xc8\x29\xa3\x46\xe8\x91\xbd\xb3\x33\xad\x97\xab\x1a\x95\x81\xf8\xf9\x80\x3a\x54\x44\xc8\x18\x3b\xda\xda\x8f\x31\xff\x03\x3d\x79\x2b\xbf\x09\x24\xbf\x91\x2a\x23\xbd\x4a\xea\x5a\xbd\x84\x73\x36\xb9\x7e\x91\x17\xe6\xc7\x1a\x78\x19\x25\x11\x46\x28\xfc\xbc\x71\xa3\x7f\xb2\x46\x83\xe3\xf2\x2b\x12\x4a\x26\x24\x08\x4a\xf8\x42\x1c\x0a\xc9\xcf\xb1\x0a\x11\xe4\xca\xa4\x16\x2d\x23\xed\x07\xb9\x21\x1a\xeb\x38\x20\x55\x92\x6f\x30\x2c\x2d\x16\x5f\x5e\x06\xec\x56\x57\x49\x7d\x30\x70\xc6\x5a\xb5\x8e\xed\x07\xe0\xf0\xc1\xfa\x25\x5f\x6b\x7b\x18\x38\xe8\x24\xc1\xd8\x0d\xad\x1b\xf2\x5d\x96\xa8\x91\x8b\xef\x6c\x79\xa8\xe1\xd4\xbc\xbb\xbc\x93\x12\x0b\x6a\x94\xec\x00\xfe\xd5\x60\x2a\xc9\x95\xc5\x5d\xb2\xbc\x0a\x54\x63\xf2\x99\xb0\xa6\x96\x36\x78\x3b\xaa\xce\x05\x94\xbd\x54\xe6\xcd\xb2\x25\x86\x2b\xd3\xd6\x44\x51\xd3\x7c\x9c\x95\xb8\xe6\xb2\x42\x94\xb8\x60\x55\x2e\x75\x57\x08\xd6\x39\x2c\xf5\x48\x86\xda\x30\x42\x53\x6b\x53\xe0\xff\x73\x21\x36\xb7\x9c\x74\xd0\xfe\x32\xc9\xd5\xc0\xe4\x1e\x16\x61\x4d\xe8\x68\x72\xac\x90\xe7\x91\xa2\x97\x49\x6e\x3b\x27\x27\xaa\x8e\xc7\x5d\x86\xf5\x36\x9a\xc2\xe3\x06\x37\x61\xd0\x8c\x31\xc3\xf2\x91\xb4\x18\x92\x62\x8d\x28\xc9\x82\x38\xcd\x1a\x51\xa2\x05\x17\x8d\x44\xb2\x35\xe6\xa5\x5b\x63\x06\xc2\x35\xe6\xa4\x1c\x2c\xee\x66\xbf\xab\x90\xe8\x59\x89\x18\xbd\xbb\x55\x31\xd7\xb0\xaf\xd5\x4b\x75\x8c\x2b\x0a\x08\xa3\xfb\x27\x4f\x04\x38\xf0\x37\x93\x54\xca\xe9\xaa\x46\x76\xdf\xab\x33\x75\xbe\x9a\xdc\x7b\xd9\x4b\x36\xa1\x1d\xc7\x1b\x11\xda\x1f\x84\x63\xec\x06\x9a\xa8\xdb\x01\xdc\x76\x16\xa5\xa3\xc4\x40\x86\x26\x42\x87\xc8\x26\x65\xdb\x78\xda\x26\xed\xb1\x6b\xf5\x6d\xb6\x59\x1f\x0b\xc1\xf1\x88\xf7\x82\x6d\x8c\x84\xb0\xb3\x58\x3b\x07\xac\x99\x24\x41\x89\xe8\xad\xac\xe0\x06\x9c\x8b\x58\x6d\x8d\xe2\x72\x1e\xee\x34\xbf\xb3\xce\xcb\x45\x84\x91\x49\xad\x5f\x3a\xbd\x72\x77\x7a\xbf\xd5\xce\x5e\x34\x7b\x17\xd3\x6a\xa6\xb6\xa3\x4a\xdd\x83\xf2\xd2\xac\xd0\x2f\x76\x27\xff\x88\x17\xe4\xea\xc6\x3b\xcf\x19\x77\x6c\x64\xf8\x5f\x7e\xe1\xdf\xda\x74\xe0\xd3\x16\x1a\x48\x48\x30\x05\x58\x73\x64\x99\x81\x15\xf6\x58\x33\x17\x97\xec\xe5\xea\x2a\x91\xef\x7d\x5c\x33\xd4\xfa\xd0\x94\x3e\xd6\x4b\xbf\xe8\x28\x80\xcb\xa7\x4f\xdd\x02\x89\xbc\x90\x60\x93\xb5\x30\xd1\xfd\xc7\x8e\x67\xb5\x69\x1b\x14\xb0\x5f\x7e\xf9\x45\x0f\xc1\x83\xb1\xfa\x7e\xf9\xe5\x97\x2e\x0d\x6b\x46\x1f\xd8\xcb\x5f\xc4\xb5\x00\x36\xeb\xb0\xa6\x7e\xb9\x5b\xfa\xe5\x17\xa6\xb8\x4d\x6c\xd5\x5e\xbc\x45\x3b\xd2\x62\xf2\x98\x40\x52\xf8\x25\x56\xcc\xa8\x9d\xbc\x19\xbf\x5f\xcf\x94\x29\xfc\xcf\xf1\x50\x02\x6a\x3f\x90\xb2\x8c\x67\xc3\x23\xdb\x6d\x7b\x23\x74\x67\x94\x3c\x95\x23\x2f\xc4\xd1\x51\x8d\x97\xc8\x44\x7b\x1a\x87\x9f\xf5\x4a\x82\xc7\xcf\xe6\xbd\x9a\xf2\x2d\x4e\x29\xdc\x0d\x9c\xf5\x28\x0d\x83\x53\xda\xb5\x83\xd0\x4f\x3b\x9c\xaa\x6e\x3c\x4f\xa9\x90\xb5\x85\x30\x4b\xfe\xd8\x6d\x84\x70\xbb\xb5\xc4\xd8\x06\x80\x0c\xf1\x39\x36\x25\x74\xa1\xdb\xf7\xfa\x18\x5b\x8a\xfa\x28\xf8\xad\x76\x5b\x14\x0d\x3d\x74\x0f\x7e\x4a\x4e\x5c\xee\x3d\xe3\x5f\x53\x9f\x78\x2e\x38\xca\x0f\x9d\x36\x61\x43\x62\xb9\xc4\x1b\xb9\x24\x42\x47\x19\x53\xce\x72\xdb\x00\x94\xbb\x4b\xe9\xb0\xd5\xf2\x33\xf6\x86\xd2\x05\xbe\x6f\x5d\x51\x12\x0c\x7d\xd8\x22\xe0\x89\x36\xb1\xc0\x48\x46\xe0\x4e\x70\xbf\x83\xc9\x51\xd9\x20\xd1\x20\x64\xeb\x9a\xe7\x83\xc3\x96\x07\xc7\xe5\x0e\xb5\xae\x44\x6b\x56\xcb\xf7\x82\x40\x14\x0d\x70\xb7\x91\x38\x51\x58\x33\xd1\x11\xd6\x4a\xe4\xe3\xd1\x2a\x36\xef\xdd\x7a\x10\x2f\x76\x4e\x9a\x8c\xdc\x3c\x26\x62\xe2\x1c\x7b\x0e\x47\x63\x19\x07\xa6\x1d\x17\x44\x26\xe7\xa6\x5d\xcf\x73\xa8\xe5\xe6\x3b\x2e\x63\xaa\x8e\x7b\x11\x6d\xe7\x32\xe5\x6c\x72\x9a\x4b\xdd\x1f\x3e\x6d\xed\xe0\xc8\xdd\xf5\xbd\x51\x80\xf9\xb9\x92\xce\x9f\xe1\x38\x3b\x56\x3a\x6b\xc2\x6a\xc5\x7e\xd0\x6c\x65\xd8\x7d\x0d\x70\xc3\xa9\xd2\x01\xcb\xbf\xa7\xe4\x00\x2d\x44\xbf\x5a\xd7\x16\x1e\xf1\x70\x35\x8e\x4d\xab\x56\x10\xf0\xa7\x6b\xea\xb6\x3d\x9f\xdf\x21\x42\xa0\x86\x08\x98\x5d\x2b\xa0\xe0\x41\xf2\x38\xf4\x2d\x37\xe8\x78\x7e\xff\x31\x09\x86\x03\x00\x1e\xd2\x20\x8c\x55\x59\x45\xe4\x5a\x41\x20\xb6\xc3\xab\xab\xe4\xa3\x9c\xf9\x6c\x8a\xb5\x3d\x62\xb9\xe3\xb0\x67\xbb\x5d\xa6\x18\x72\xd2\xb7\xb9\x9c\x08\xec\x36\x2d\x41\x58\x12\x83\xfc\xba\x1e\x2b\x6e\x44\x4f\x60\xe2\x62\x54\xe4\xa0\xc4\x5a\x11\xc2\x00\x3c\x51\xc9\x47\xda\xbc\xb2\x31\xe8\x87\x63\x05\x21\x48\x20\x2e\x3a\x10\x80\x07\x61\x0d\x91\x0a\x01\x48\x25\x7e\x47\xc6\x6b\x0a\xc2\xb0\xd7\x60\x58\xa4\xf4\x5d\xbe\xb7\xfe\x1a\xec\x05\xc1\xb1\x35\x90\x16\x23\xc7\xde\xb7\x1a\xc9\xad\xf4\xbd\x6f\x2b\x3c\x5c\x1c\x3a\x0e\xb4\xed\x36\xb1\x43\x32\xf2\x3d\xb7\x4b\xac\xae\x65\xbb\xa4\x54\x42\xea\xf5\x03\xa8\x11\x88\x0a\x27\xec\xd1\x13\x4f\x88\x0a\x7b\x35\x82\x5f\x2b\x39\xdd\xb2\x0f\xc7\x71\x87\xb4\xbd\x16\x9c\x4d\x44\xd3\x24\x0d\x72\x85\x12\x94\x11\x15\xd8\xa0\x41\x1c\x89\x1d\x92\x3b\x17\x63\x8a\xa7\x16\x72\x77\xc3\xad\x47\x44\xdf\xf4\x93\x46\xf6\x69\x59\x01\x89\x6e\x80\x08\x72\xe5\x15\x1d\x4b\xeb\x48\x60\x04\x01\x0a\x8c\x4d\xc4\xa7\xa6\x4f\xad\xab\x6d\xd3\xa7\x98\x2f\x43\x7f\xe8\x8c\xc9\x0f\x7b\x00\x3f\x08\x11\x32\xf4\x41\xc1\x6d\x22\x6b\xc8\x90\x2b\x60\x90\xf6\xfd\xfb\xd7\xa0\x46\x84\x01\x7d\x2b\x90\x0f\x6c\x27\xfb\x94\xfc\xd7\x1a\xd8\x64\x30\x6c\x3a\x76\x2b\x5d\x9a\x7f\x27\x0c\xc6\xd7\x80\xd7\x67\x5d\x88\x7b\x18\x6c\x2e\x66\x63\xb2\x50\xb8\xa1\x7b\x13\x87\x3c\xdf\x4c\xda\x35\xcc\x7a\xb4\x60\xd6\xfd\x8b\x80\x25\xeb\xe0\x35\xc0\x47\x0c\xb6\xa1\x82\xd8\xa6\x35\xb6\x31\xa9\x62\x56\xe3\x69\x6d\x69\xf7\x48\x74\xd0\xa7\x7e\x37\x6d\x59\xac\x54\xd7\xe3\x65\xb3\x84\xbe\x2c\x24\xab\x4d\x08\x76\xb4\x1e\x2d\x98\x05\x9d\x17\x51\xb1\x7b\x61\x5a\x9f\x8f\x07\x5e\xd7\xb7\x06\xbd\x34\x85\x73\xa3\xbc\x99\x5a\x25\xab\xb9\x68\xd9\x08\x90\x5d\x36\x53\x65\x8a\xe1\x64\x83\xfd\xf4\x2a\x93\x1b\xd6\x0a\x47\xc0\xbc\xb3\x1c\x1a\xa6\xba\x09\x6c\x94\xb7\x92\xcb\x4f\x6e\x92\x17\x8c\x54\x3f\xb6\x6f\x6c\x37\xad\x8f\x1b\xe5\xe7\x89\xc5\x27\x37\x86\xe5\x64\xe5\xa0\x67\xb5\xbd\x51\x6a\x33\x95\x72\xb4\x64\x56\x0b\xbc\x88\xba\xa6\x60\x42\xdd\x16\x07\xdd\x89\x16\x55\xeb\x49\x85\x33\x2f\x35\x54\x31\x59\xf5\xdb\x11\x3f\x97\x4d\xee\xc3\x5a\xa4\x60\x16\x78\x2c\xa1\x3a\x3d\xb0\x5a\xe9\xf3\x68\x43\x9b\x48\xbc\x64\x26\x79\xb0\xc8\x0f\xb9\xac\x55\xa1\xa9\x70\xd4\x87\xf6\x79\x8f\xf6\x69\x7e\xca\x1b\x88\xb2\x79\x03\x51\xce\xba\x81\x28\x8b\x1b\x88\xc8\x75\xc2\x40\xce\x17\x71\xc4\xc6\xdf\x88\x0b\x05\xfe\x78\x04\x81\x16\x76\x12\x2a\x46\x9a\x04\xeb\x87\x68\x29\x01\x4c\xbe\x6f\x1a\x02\x42\x34\xad\xbd\x2d\xea\x6b\x3e\xbe\x8a\xa1\x60\x00\xc9\x44\x23\x01\xb0\xfc\xd6\x17\x53\x58\x60\x81\x2f\x44\x39\x7c\x8a\xb5\x2d\x6a\x65\x36\x6b\x42\x92\xaf\x43\x5d\x2a\x8b\x56\xd5\x4b\x51\x5e\xbd\x89\xb5\xae\x43\xc8\xc4\x20\x0e\x95\x4f\x7f\x01\x52\x34\xcf\x5f\x8b\x52\xa8\xe8\xee\xe0\xe9\x70\xda\xf2\xaa\x6e\xf8\x39\x94\x22\xb9\xc8\xf1\x11\x87\xd8\x95\x8a\xea\xec\x11\xa9\x01\x71\x28\x25\x56\x10\xa3\x12\x9b\xce\x41\xbc\x63\xe1\x20\x22\xd9\x12\x30\x30\x65\xb5\x6a\x57\x67\x4e\xe9\xba\x61\xf2\x96\x56\x5f\x5f\x62\x14\x8c\x28\x87\x15\xe4\x9d\x5b\x9f\xcf\x47\x01\x45\xe8\x34\x9a\x65\x03\x90\x0b\x23\xb0\x60\x96\x12\x27\x14\x51\x9f\x39\x6e\x35\x62\xcc\x01\xd5\xf5\x9a\x8e\x9a\xb6\xea\xc6\x7a\x57\x8c\x72\x02\xb7\x00\x47\x7a\x1a\x60\xf8\xfa\x92\xd8\xb9\xa2\x12\x7f\xe2\x7b\x51\xe7\x6e\x0e\x55\xab\x51\x23\xb1\x79\xc3\xc7\xaa\x66\xb2\xd1\xed\xad\x5a\x79\x04\x6c\xcc\xc1\xc9\x0d\x43\x84\x7a\x14\xa5\x9c\xb6\x4e\xd4\xcc\xc5\x45\xa2\x88\xcd\x22\xe2\xb5\x84\x2e\xc0\x77\x5c\x10\x6a\x72\xed\x30\x91\x00\x66\xe6\x99\x97\x53\xe3\xf6\x3d\x56\x71\xfb\x1e\x93\x17\x88\xb8\xd0\xbb\x14\xda\x82\x25\xc4\x7c\x11\xc2\x98\xcd\xc2\xea\x46\x91\xe4\x8e\xad\x90\xfa\xb6\xe5\xac\x7c\x38\xaa\xe1\x61\x16\x5f\xbb\xe1\x26\x9d\x35\x7f\x6d\xb7\xf9\x9e\xd3\x10\xfa\x62\xc3\x2b\x36\xcb\xd5\x0d\x42\x1d\x7a\x6d\xe1\xf4\x04\x77\x22\x2d\x49\xbf\x38\x5d\xe6\x95\xb7\x97\xee\xd8\xb6\xf1\x3f\xa4\x72\xd5\x14\x59\x90\x89\x77\x4d\xfd\x1e\xb5\xda\x64\xd4\xa3\x2e\xc1\xdc\xf7\xab\xa8\xd2\xda\x01\xf9\x8d\xac\x5d\x35\x4b\x09\x36\x1b\x26\x5a\x0b\x1f\xd1\x26\xc5\x64\xda\x5a\xcc\xf4\xfd\xde\x8f\x7a\x56\x57\xc9\x47\xcb\x0e\xc1\xfe\x21\xa8\xad\xae\x76\xed\xb0\x37\x6c\x82\x01\x44\x87\x87\x73\x5a\xed\x38\xde\x68\xd5\x0e\x82\x21\x0d\x56\xd7\xb6\xca\x3c\xcc\x17\xdb\xed\xb7\x59\x9f\xcc\x98\x2a\x84\x95\x66\xdb\xcb\x55\x8e\xf9\x0a\x04\x7d\x5b\xe9\xd8\x0e\x5d\x81\x64\x16\x18\x1a\x4e\x9c\x7e\x74\x7d\x30\xe7\x66\xb8\x6d\x94\x6b\x24\xf7\xaf\x8e\xc5\xfe\x03\x49\x52\x29\xe3\x9b\x0d\xf6\x1f\xbc\xa9\xe2\x1b\x0a\x7f\xf0\x66\x8d\xbf\x29\xb3\xff\xe0\xcd\x3a\xbe\x69\xb6\xd9\x7f\xf0\x66\x03\xdf\x3c\xa7\xec\x3f\x78\xf3\x0c\xdf\x6c\x6e\xb0\xff\xe0\xcd\x26\xbe\x79\x56\x61\xff\xc1\x9b\x2d\x7c\xb3\x5e\x65\xff\xc1\x9b\xe7\xf8\xa6\x5a\x61\xff\xc1\x9b\x3a\x47\xb1\xbd\xc1\xfe\xc3\x57\x1c\x47\x0b\xfe\xf0\x15\x47\x69\xad\xcc\xfe\xc3\x57\xf1\xf6\x5a\x9e\x1b\xfa\x56\x10\x72\x1d\x6b\xcf\x73\x3c\xbf\x46\x72\x6d\xcb\xbf\xca\xa5\x18\x19\x31\xe2\xc5\x76\xdb\x5b\x8b\xd9\xb9\xde\x3b\x8b\xa1\x49\x6c\xbf\xef\xb9\x7c\x9c\x9b\x8e\xd5\xba\x62\x9d\x2f\x97\x91\x18\xa3\x9e\xcd\x56\x8b\xdc\xbf\x3a\x9d\x0e\x46\x45\x66\xe2\x10\xef\xe6\x6a\x24\xe7\x77\x9b\x16\x13\x4a\xfc\x7f\x05\x28\xd2\x19\x3a\xce\x2e\x07\x64\x16\xa8\x60\x01\x46\xb7\xe4\x02\xe5\xd2\xd6\x26\x96\x71\xec\x6e\x2f\x4c\x2b\xb4\xb1\x8e\x85\xfa\xb6\x9b\x56\xa4\xfa\x8c\x23\x63\xd9\x6e\x2a\x9c\x4a\x55\x61\xfc\x91\xf7\x14\xca\x54\x37\x36\x8a\x44\xfd\x9f\x86\x77\x56\xb1\x08\xf6\xd9\x45\x59\x1f\x52\x78\x07\x87\x24\xce\x3d\xf7\x6b\x27\x2b\xda\xd5\xf6\x05\xd2\x13\x09\xb4\x71\x88\xd5\x99\xb2\x7d\x59\x57\xe7\x1c\xac\x58\xd6\xde\x85\x7d\xff\x21\x1b\x97\x38\x21\xd5\x6d\x80\xe5\xfb\xca\xa0\xde\x34\xdb\x61\x9f\x62\x31\x71\x21\xc6\x44\x91\xad\x8f\xac\x6b\xb2\xa0\x88\xe7\x80\x59\xa6\xd4\x0b\x91\x63\x8a\x2b\xaa\xac\xda\x85\x7d\x09\x1b\x24\xff\xc2\xbe\x4c\xb2\xac\x64\x65\xc0\x74\x4c\x37\x4b\xe1\xdf\x60\x9d\x07\xba\xaa\x45\x9e\xa1\xb9\x2d\xad\x1a\x23\x9c\xf1\xd7\xb4\x59\xc4\x33\xdb\x20\xc9\x80\xfa\x41\x8f\xec\x7e\xbc\x75\xf6\x5f\xea\x90\x70\xaa\xe8\x11\x5b\x29\xc5\xb3\x66\xb2\x59\xd2\xcc\xc8\x25\x73\xe2\xa4\xf5\xf9\x79\x4a\xf9\xac\xae\x46\x20\x47\xce\xad\xf6\x44\x9e\x9f\xc4\x83\xca\x72\x52\xe9\xcc\xc6\x34\xa0\xca\x98\x3e\x2d\x8b\x4f\x6a\xbb\x95\xc9\x75\xb3\xb0\x48\x6f\x50\xdd\xe7\xf1\xdc\x45\xa9\x28\xc4\x8b\x66\xb5\x28\xc1\x15\x92\x17\x23\x20\xcb\x19\x44\xa1\x10\x60\xc1\x72\x3f\x23\x5b\xa3\x56\x2a\x8b\x9f\xa0\xc0\x0f\xf1\x70\x50\x7c\xe7\x5a\xfd\xd4\x16\xaa\x09\x45\x33\x8f\x45\x65\x29\x75\x28\x6e\x87\xbd\x33\x21\xf5\x12\x8f\x2d\x13\x8a\x66\x1e\xa1\xcb\x52\xb2\xe2\x51\xcb\x73\x77\x87\x61\x08\x5a\x5b\xe2\x10\xac\x95\x13\x0a\x67\xb5\xa2\x4a\xc9\x8a\x30\xe5\x76\xbd\x9b\x93\x61\xe8\xd8\x2e\xdd\x75\x2c\xf7\x2a\x4d\x9c\x3d\xdb\xc8\xac\x96\xd5\x72\x52\xf9\x18\xb0\xd4\x76\x9f\xc7\x8a\x4e\xd3\x96\x41\x9c\x34\x71\xb5\x6e\x94\x9a\x44\xbc\x1f\xa2\xe0\xc0\x39\x92\xd5\xa4\xce\x3b\x67\xd8\xb5\xdd\x43\xc7\x1b\x99\x41\x6e\x81\xe9\x99\x74\x6e\xf0\xab\xd3\xd4\x39\x5a\x9a\x11\xce\xed\x6d\xca\x9c\x2c\x59\xee\x78\x7b\x26\xd4\xde\x7a\xa9\x71\x9a\xa6\xc7\x0b\x80\x4c\x83\x94\x54\x41\x62\x3a\x09\xb8\x60\x7b\x5e\x28\xdc\xa2\x79\xe6\xa4\x1a\xc9\xd9\x2e\x63\xc5\x95\x8e\x43\x6f\xf8\xb1\x99\xe5\xd8\x5d\xf7\x28\xa4\x70\xc9\xdd\xa2\x6e\x28\xd3\xa8\xa9\xe3\xa1\x1a\xc9\xb9\x9e\x4b\x73\xc2\x27\x06\xa2\x00\x0b\xe0\xad\xa1\x1f\xc0\x9e\x91\x4b\x5b\x71\x1c\xe7\xc9\xba\x56\x33\xf0\x9c\x61\x48\xf9\x17\x6f\x60\xb5\xec\x50\xe4\x22\x26\x64\x64\xb7\xc3\x5e\x8d\xe4\x2a\xe5\xf2\xbf\x79\x91\x1e\x65\xbb\x0c\xf3\x5d\xe8\x0d\x64\x15\x87\x76\x42\xf9\xd0\xb7\xfc\xae\xed\xca\xc7\x81\xd5\x6e\xc3\xd9\x55\x59\xa0\x2b\xf9\xed\x3b\x3c\xf2\x1c\x1c\xe2\x91\x1f\x21\xc0\x33\x28\xa0\x33\x0c\xb8\x9e\x86\x87\x5b\x79\x3c\x25\x47\x1d\xf2\x85\xe9\x8b\x5f\x8a\x91\x84\x19\x76\x20\xda\x06\xbb\x82\xa7\xab\x3a\x32\x29\xc3\x6d\x64\x44\x4a\x2c\x21\x72\x9d\x27\x7e\xc4\x9b\x79\x9e\x5a\x5c\x62\x78\xde\xa3\xc4\x6e\x81\x3f\x86\xe0\x0d\x3c\xb4\xca\xc6\x97\xf5\x4c\xf8\xaf\xb0\x8f\xe2\x70\xad\x08\x86\x13\xdc\xbc\x18\x5c\xe0\x30\x59\xa8\xe7\x86\x6c\xbb\x68\x85\x43\x9f\xc6\x7a\xcc\x44\x4b\x4d\x18\x30\xce\x34\xbf\xcc\x28\xc4\x2f\x66\xaa\x9c\x4a\x67\xcc\x80\x3e\x03\xa8\x08\x49\x3f\x04\xb4\x33\x74\x18\x41\x51\x67\xc7\xb3\x48\x34\xe9\x19\x0c\x1c\x9b\x1f\x41\x0a\xda\x06\x1a\x3d\xd8\x52\x4b\x83\x74\x0e\xc0\xcc\xf2\x46\x6b\xff\xb5\xbb\xae\xe7\x53\x13\xc6\x5b\x9e\xb8\x2f\x83\x11\xb2\xa1\xf0\x79\xb2\x37\x81\x25\x81\xe1\x96\x32\x38\x9e\xc7\xf5\x12\x1c\x21\x26\x98\xea\xb2\x9a\x72\xf3\x36\xe1\xdb\x83\x81\x43\x09\xed\x74\x68\x2b\x9c\xdc\xd2\x29\x14\x9f\xa1\xb9\xe9\x67\xc8\xd0\x7d\x80\x39\x62\xff\xb3\x26\x47\xaa\x44\xb4\x06\x03\x6a\xf9\x01\xd8\xfb\x87\xd4\xef\xdb\xae\x15\xea\x64\xd0\x5f\x3f\xc8\xe8\x25\x34\x7c\x4f\x23\xa8\x03\xfe\x87\xc9\x3a\xb5\x33\xd7\x65\x1b\x64\xbd\x01\xcd\xe0\x0b\xa1\xa8\x5b\xe9\xe4\x18\xe0\x8e\x7e\x36\x39\xf7\x01\x72\x7d\x58\xa1\xb0\xeb\x1b\xab\xb4\x2a\xc4\xa7\x98\xb3\x19\xdc\xc7\x78\xfb\x22\x64\x19\xdc\x92\xc9\x81\x8e\xa0\x71\x4a\x3b\xa9\x48\x30\x5a\x73\x14\x92\x65\xa4\x3b\xab\x90\xdd\x93\x51\xe6\xc1\x86\x52\xb2\x21\xa4\x35\xc2\x25\xd6\x72\xbb\x42\x7c\xf0\x46\x23\x09\xc6\x20\x62\x0e\x70\x35\xfe\xe2\x09\x27\x44\x6a\x2f\xde\x82\x59\xb7\x89\x66\xc1\x77\x62\xbd\x85\xea\x5f\xf8\xc3\x17\xee\x28\xc7\x21\xa0\xc0\x96\x7d\xf4\xdc\xbd\x9e\x48\x21\x39\x89\x4a\x29\x64\x0a\xad\xa6\xb8\x22\x9c\x57\xaf\x51\x19\x32\x67\xd4\x6c\x8c\xae\x25\x30\x01\x3f\xd2\xcb\x84\x8b\x27\x91\xab\xe4\xed\x6e\x8d\xc9\x03\x3e\x46\x45\x32\x70\xa8\x15\x50\x32\x1c\xb4\xd9\xe8\xc1\x4a\xd9\xf4\x6e\x8a\x04\x0f\x11\xc0\x7a\xf7\xd4\x6a\xdb\x1e\xab\x1b\x78\x2a\xa7\x5d\xfd\xdd\x91\x34\x01\xc5\xab\x28\xb6\x74\x00\x94\x76\x69\x26\x95\xf3\x44\x5a\xa8\x7c\x57\x4b\xf6\x3c\x02\x46\xee\xa3\xe6\x94\x31\xbc\x7e\xc9\x0e\x4e\x85\x81\xf0\x22\x75\x6b\xb3\xe2\x7d\x3f\xe2\x8d\x43\x2b\x68\xa8\x14\x63\xaa\xd0\x4f\xf2\xde\x33\x79\x41\x0e\x9f\xf3\x74\xd7\x93\xa6\x21\x3f\x71\xc3\xf3\x5b\x3c\x79\x93\x91\x2c\x4c\x6b\xea\xe4\x23\x1a\x65\x7d\x01\x6e\xab\x1a\xc4\xb5\xe9\x21\x26\x40\x89\x58\x93\xa1\x08\xd0\x6c\xc9\x58\x0b\xf7\x66\x48\x26\x8d\x9a\x7c\xda\xf9\x55\x9b\xf5\xd8\x83\x4e\x49\x7b\x25\x8a\xc6\x4b\x99\x15\x23\x4d\x22\x89\x6b\xb1\x82\x49\x2d\xcb\x79\x11\x69\x5e\x9b\x2f\x11\x2c\xb4\x2f\x11\x64\x34\x58\x09\x18\xad\x45\x30\x92\xa5\x0d\xb4\x24\x3f\x09\x7c\xe4\x0b\xe5\xa7\x6f\x96\xd0\xab\x44\x9a\xcd\xb5\xb8\x58\xcf\x89\xb6\x65\xd9\xed\xa4\x45\x8f\xac\x40\x12\x44\xdf\xb5\x9c\xe4\xe5\xc6\xe7\xcb\xc3\x2e\x5b\x3a\x8c\xdc\xfd\x30\x6d\x7e\x8d\x64\xf0\x27\x78\x49\x26\x0f\xb8\xd5\x45\x99\x02\x53\x24\xb1\xba\x3c\xed\x98\x84\xae\x0a\x6b\x99\xef\x05\x5f\xae\xcb\x24\x65\x68\x66\x4a\xfb\x83\x22\x69\x60\x84\xe2\x06\x66\x93\xc2\xcf\x68\xec\x64\x5e\x6b\x28\x84\xb0\x82\x6a\xa9\x20\xeb\x29\x4f\x6c\x07\x9c\x55\xa3\xb3\x00\xf2\xfc\x07\xf2\x02\x92\x95\x2a\x14\x49\xe3\x0a\xec\x32\xca\xdb\xf8\xeb\x3f\x50\x1b\x1f\xcc\xd8\x01\xac\xf2\x45\x83\xe7\x8e\x50\x93\xa5\xa1\xbb\x2f\xdc\x2d\x49\xef\x6c\x38\x96\x6c\x60\xfa\xad\x3c\xf4\x16\x7f\x60\x00\x6e\xe8\x63\xfa\x95\x46\xb4\xbb\x79\x20\x20\xd9\xd1\xfa\x5d\x6a\x34\x20\x72\x67\xa3\x01\x91\xaa\x18\xbc\xc8\xdd\x53\xd2\x20\x16\x0a\x60\xcf\x53\x62\x4a\xf4\x18\xa1\x16\xc9\x05\x6b\xe4\xb2\xd4\xf2\xdc\x96\x15\xe6\x59\x3f\x0b\x85\x02\x1f\x1b\xf1\x6f\x09\x95\xc7\x1d\x26\x17\xf8\x1b\x9b\xdb\x17\x62\x6a\x46\x7c\xd7\x14\x27\xe9\xfa\x4b\x3b\xd8\xf3\xdc\xd0\xf7\x1c\x07\x12\xa5\xe8\x9f\x7a\x96\xdb\x76\xd0\xb8\x0f\x15\x40\x83\x59\x41\xf5\x8c\xc6\x6f\x10\xca\xe5\x0e\x6a\xa6\x25\xcc\x67\x50\xe2\xaf\xb5\x4c\x78\xe0\x60\x1e\xc7\xc0\x0c\x22\xc0\x3b\x27\x42\x03\x7d\x57\xa7\x63\xa2\x9d\x3b\x23\xeb\x9d\x01\x1d\x2b\xb3\x95\x27\x28\x09\x0d\x36\x09\xbc\x59\x02\xbb\x55\x14\x0d\x24\x25\xd5\x13\xd9\xb1\x8b\xd3\x33\x8a\x36\x93\x0a\xc6\x0d\xb9\x66\x3b\x88\xb7\x76\xc9\x93\xfb\x42\xa0\x7d\x45\xc7\x35\x92\x93\x52\xe5\xa3\xed\x38\xc7\xde\xd0\x15\x87\xac\x52\x99\x55\x6b\x51\xac\x68\x3e\x3a\x66\x03\x7e\x68\xa9\xa8\x81\x76\xa0\xf8\x97\xc4\x24\x48\x32\x31\x06\xc6\x5a\x15\x1d\xe2\x09\x23\xcc\x63\x1e\xb6\xe4\xe7\x22\x78\x75\x49\xf9\x09\x8c\xad\x95\x8f\x30\x84\xe1\xcc\x26\x99\x03\xd1\x33\x17\x88\xd8\x8a\x9a\x58\x88\x87\xfd\xd3\x83\x4b\xa4\xa7\x55\x2c\x12\x73\x54\x30\x2f\x6f\xea\x48\xe0\xe7\x18\xf5\x1b\xf2\xac\x4e\x1a\xff\x6a\xdc\x59\xe5\xe3\xa2\x91\x55\xde\x0b\x9a\x63\x56\x4c\xa2\x05\x77\x1c\x6b\x18\x03\x16\x29\x89\xc7\x8d\x5a\x29\x7c\x91\x50\x8a\x21\x19\x81\x28\x5e\x27\xb6\x2e\x16\x77\xa3\x75\x5d\x17\xc0\x3f\x71\x4a\x67\x82\x16\x6f\xcd\xb2\x76\xcb\x73\xcd\x72\x76\x0c\x9e\x3a\x5b\xd0\x4a\xc9\x77\x09\x65\x4f\x41\x2f\xd3\x4b\x9e\xd2\x8e\x59\x0e\xe2\x02\xca\x32\x6e\xac\xc7\x42\x7c\xa8\x32\xe2\x8d\x59\x4e\xec\x83\x55\x39\xf1\xc6\x2c\x27\x42\xb0\xf0\x42\xf0\x18\x69\x71\x36\x0b\x71\x04\x54\x24\x17\x39\x3e\x0e\xb9\x22\xc9\xf1\xa1\x96\x3f\xd9\x48\xc2\x83\x1a\x2a\xf6\x28\x86\x82\xfd\xb6\xf9\x3b\x45\x50\xf9\x74\x4a\x3b\xec\xb7\xcb\x81\x08\x02\x80\xc1\x39\xef\x24\xfb\x0d\x7d\xc9\xe9\xf9\x88\xb9\xad\xf7\xa1\xe7\xf7\xb9\x9c\x10\x9c\xcd\xa3\xa1\x95\xcc\xaf\x91\xc9\x20\xd0\x23\x3b\x06\x2b\x45\x24\x91\x09\xc2\x94\x42\x5a\x16\x45\x05\xcc\x0c\x9e\x10\x8d\x6e\xa3\x35\x6a\x42\x96\x8c\x9b\x16\xa2\x26\x65\xbd\x8c\xcb\xd9\x17\xc6\x2c\xae\x11\xb5\xd2\xab\xf5\xd4\x80\x25\x86\x50\x5a\xdd\xab\xab\x7d\xc5\x08\x7c\xcc\x4b\xbe\xe7\xb1\x65\x8e\x3f\xc9\xcd\x8c\x31\xd1\x99\x6e\xa3\xc4\x13\xd7\x2f\xb2\x63\x0d\xea\xe2\x4c\x42\x17\x82\x47\xae\xaa\x73\x41\x91\x12\x41\x12\xbf\x50\xd4\xc5\x67\xa1\x10\x61\x0c\x1b\xe5\x8f\xa0\xf1\x0b\x43\x2e\xd5\xa4\x2c\x89\x30\x8a\x88\xaf\x2c\xf6\x44\x22\xc4\x72\x84\x65\xe4\xc6\x25\x63\xb7\x68\xca\x73\xb8\x5c\x37\xed\xe6\xa5\x78\x61\x5a\x57\x4c\xd0\x69\x2f\x92\xd5\x1c\xa5\xc8\x4e\x87\x84\x6e\x22\x91\x84\x48\xa6\x97\x85\xf8\x93\x1a\x45\x8d\xe4\x82\x81\xe5\xe6\x52\x56\x8a\x1a\x49\x59\x1d\xd4\x6d\x4f\xb2\x8c\x57\x67\x85\x71\xb2\xf8\x9e\x63\xa4\x94\x8a\x7c\xf4\xf0\x30\x57\xad\xb9\xf8\x26\xef\x7a\x6d\x1a\x9d\xc1\x62\x85\xd5\xd4\x62\xaf\x4d\xb7\x8d\x32\x77\xfa\x1c\x16\x8e\x0c\xc5\x08\x1b\xe8\xcf\xd9\x43\x81\x72\x32\x57\x9c\x8e\xd0\x98\x10\x3a\xb6\x73\xc5\x3f\x3c\x77\x8e\x2f\x44\x52\x09\x9a\x2c\x4f\x52\xa8\xa8\x4e\x7b\x93\x37\x01\xd9\xc3\x4d\xf9\x0a\x3a\xef\x90\x67\x2c\x87\x3c\xc2\x99\x39\x24\xda\xc2\x1e\x8b\x3f\x66\x70\xc2\x24\x2e\x90\x1b\xa6\x18\x13\x88\x4c\x67\xb8\xc4\xc5\x01\x28\x2d\x02\x5b\x88\xd6\xbe\x4b\x67\xa9\x42\x41\x3e\x15\xb6\x4d\xed\x52\x2c\x90\x7c\x8e\xab\xdd\x00\x58\xc6\xe6\xa3\x8c\x16\xd9\xf7\x6b\x5b\x51\x5e\x42\x37\x4d\x88\x5c\xba\xa7\x1d\xd6\x44\x2e\x4b\x65\x44\x6c\x71\x1f\xa9\x1d\x0a\x89\x10\x07\x5a\xbb\x7a\x84\x5a\xd9\xae\xb9\x56\xd6\x32\xa2\xd1\x22\x44\xcd\xd7\x06\x3d\x82\x94\x25\x99\x9a\x36\x68\xe7\x52\x24\xdf\xf9\xac\xc8\x1d\x0f\x6d\x85\x48\x8e\xdc\x19\x9b\xec\x84\x90\x61\x5b\xd3\x84\x0c\xfb\xeb\x86\x06\x10\xf6\x3e\x76\xf0\xd1\x6e\x87\xbd\x7d\x6f\xe4\x6a\x56\x40\xfc\xed\x87\xc1\x0f\x37\x4e\xfe\x69\x2a\xfc\xd3\x54\xf8\x1f\x61\x2a\xfc\x70\x96\xc0\xf0\x74\x70\x4d\xdd\x50\x8b\xef\x9d\x38\x13\xd7\x32\xea\x4c\x6c\xcf\x28\xad\x39\x03\x34\xbd\xa1\xdb\x4a\x0d\xd6\x50\x8d\x95\xcc\x8e\xaf\x81\x65\x94\xd5\xaf\x6f\x0d\xf6\xd1\xda\x82\xef\x4a\x12\x7d\x13\xd6\xd3\x2a\x64\xda\x0a\x9b\x45\x0d\x4b\x63\xe1\x33\x9c\x38\xdf\xaa\xf1\xa2\x93\x6c\x92\xa1\xd0\x9c\x01\x36\xfe\x4a\x86\xb2\xaf\xec\x6e\x8f\xfa\x10\x83\x49\x6a\x0b\xa9\x93\xe5\xd9\xd4\xf6\xa9\x89\x60\xb3\xed\x55\xc9\xea\x2a\x81\x84\x23\x98\x77\xdf\xf1\x46\x24\xb0\x5c\x3b\x1c\xf3\x38\x50\xf9\xfd\x13\xf2\xf6\xe4\x9c\xec\x1f\xbc\x39\x38\x3f\x28\x48\xbf\x50\x56\xb2\xe4\xf9\xdd\xd5\xd0\x1f\xaf\xfe\xab\xfc\xfb\xa7\x8f\xa3\xfd\xee\xf3\xee\x79\xf7\x4d\x77\xb7\xfe\xfb\xfb\xd7\x9f\x0e\x8e\xf7\x5f\x6e\xed\xf6\x3f\x1c\x7d\xed\xb6\x6c\xe7\xfd\xda\xe8\xe5\x7a\xdd\xfb\x70\xf6\xf1\xe4\x65\xfd\xfc\xdb\xde\x79\xf7\xe5\xd6\xfa\x6e\xef\x7f\x67\xf5\x93\xf1\xd9\x46\x77\xf7\xc3\xcb\xf3\xfa\x9b\x8d\x9b\x60\x58\xbf\xfa\xdf\xfb\xd1\x78\xe3\xe4\xfd\xab\xc1\x46\xab\xfe\xe6\xec\xcf\xca\xb3\xaf\x9f\x87\x7f\x8c\xda\xad\x96\xe7\x77\x77\xd7\x3e\xed\xd7\xeb\x1f\x57\x3e\x94\x7b\xbb\xc7\xf5\x83\xee\xab\xab\xea\xc6\xef\xf5\xfa\xf3\x3f\x3f\xd6\x5f\x6f\xb4\x8e\x47\x7b\x87\xe3\x63\xf7\xdb\x59\x35\xa8\xbf\xea\xd6\x0f\x5f\xed\xd7\xeb\x9f\x47\xf5\xe1\x61\xff\xa0\xfe\xae\x5b\x7f\xdd\x72\x2a\xd5\x73\xe7\x39\x7d\x79\x68\x9f\xb4\xea\xe3\xe5\xf7\x1f\x3e\x77\x2b\x5f\x8f\xfd\xdf\x0f\xed\xcd\xfa\xde\x71\xfd\xf5\xf8\xfd\xf1\xc9\xe1\x41\xfd\xf8\x6b\x6f\x64\xef\x7d\x5d\xef\xee\x0e\xc6\xf5\x83\x41\xf0\xfc\xf7\x8d\x2d\xef\x7c\xef\x68\xfc\xce\xfe\x78\x72\x5a\x2e\xd7\x77\x83\x0f\x67\xc7\xf6\x7a\xfd\xd5\x87\xba\x5d\x79\xbd\x7e\x78\xd3\xa3\xf5\xdd\xe3\x8d\x8d\x97\x57\xf5\x93\xde\xb7\xe1\xf9\xeb\x57\x1f\xc7\xef\xac\x8f\x1f\xed\xbd\xf1\xf0\xe0\x4f\x6b\xe8\x9d\xdd\x54\x5e\x1f\x0d\xf7\xad\xf7\xde\xe9\xeb\x67\xaf\x2a\x6f\xba\xf6\xcb\x57\x2d\xef\x5d\x75\x6f\xf7\xdb\x78\xeb\xe5\xa7\xe1\xb7\xdd\xcf\xfd\xfa\xd5\x1f\xd5\x4f\x2f\x5f\x7a\xbd\xd7\x95\x6e\xfd\xfa\x78\x74\xf4\xc7\xfe\xd1\xd7\xfa\x87\x93\xb0\x7d\xbd\x77\xf5\xfa\xf7\x8d\x77\x07\xaf\x5f\x3b\xbd\xfa\xf9\x33\xdb\xb9\xbe\xea\x75\xae\xb7\x0e\xaf\xc2\x37\xc3\xd3\x5e\xdd\x73\x0e\x07\x2f\x3f\x8c\x2b\xef\x3c\xe7\xf8\xd3\xb7\xe3\xd0\x7f\x55\xaf\xbf\xfe\xf3\xf4\xb0\x5e\x6f\x8d\xdf\x6f\xec\xf5\x8f\xbf\xf5\xeb\x07\x87\x7f\x04\x1b\x95\xe0\x79\x18\xbc\xff\xf4\x2e\x58\xbe\x6a\xdb\x83\xf6\x38\xfc\xc3\xba\xde\x7d\x69\x8f\x3e\xbc\x39\x18\x9e\xac\xbf\xdf\xfd\xe3\x7f\xfd\xd6\xeb\xaf\x7f\x3e\x7f\x6f\x79\xef\xda\xfd\x57\x67\xe5\x37\xeb\xe5\xff\xed\x9e\x7c\xe8\xbe\xbd\xda\x5f\xbe\xae\x1f\x74\xd6\x4f\x3e\xb7\x0f\xfa\xaf\x87\xbd\xf7\xfb\xef\x8e\xfb\xbb\x61\xe7\x5d\x6f\x7d\x7f\xf4\xaa\xf9\xfe\xe8\x55\x7d\xf4\xfa\xf5\xfa\x71\x7d\xa5\x5e\xdf\x6f\xbe\xbc\xa9\x7c\xaa\xbf\xad\xac\x1f\x8e\xba\x9b\xee\xc6\xe0\x6b\x37\xf8\x54\x0f\xdc\xf7\xee\x67\xe7\xa0\xfc\xbe\x7e\xb4\x39\xfc\xb4\x7b\x70\xf2\xa9\xff\xbf\xe6\xd5\xa7\x37\xd5\x9b\xea\xeb\xeb\xde\xe8\x70\xf7\xa8\xbb\x77\xec\x75\xff\x3c\x3b\xaa\x9f\xbf\xf9\xba\x7e\x7d\xf6\xc7\xf1\x78\xf7\x99\xf3\xf1\xe3\xe6\xf9\x51\xf0\xb6\xff\x69\xfd\xdd\xe7\x57\x7b\xeb\x6b\x6f\xde\xf7\x5e\xd5\xeb\x07\xbf\x9f\xd5\xf7\x3f\x5e\xed\x7e\x7d\xe3\x1d\x7d\xbb\xb2\x97\xf7\xbb\xf5\xdd\xad\xbd\xdf\x0f\xde\xef\x5f\x3f\x5f\xe9\xbe\xdf\x0d\xbf\x8e\x4e\x7f\xbf\x1e\xbf\x59\xe9\xb9\xbf\xbf\xfd\x7c\x72\xfa\xec\x68\xf4\x27\x7d\x77\xbe\x57\xf6\xdc\xdd\xff\xb5\x6e\xce\xce\x5f\x9e\x1f\xd7\x3f\xfc\x7e\xfc\x69\xa3\x5f\xaf\xaf\xbc\x39\x38\x7b\xe6\xbd\x1e\x1e\xec\xfb\x83\xf2\xc9\xd7\x97\xaf\x97\xbd\x97\x6f\xec\xa1\xb5\xb1\xf5\x7b\xb9\xfd\xfb\xc9\xeb\xf5\x72\x9d\x1e\xae\x1f\xd7\x97\x5f\xad\x6f\xbe\xfe\x1a\xd4\xfd\xcd\xeb\xdf\xb7\xfa\x7b\xf4\xed\xfa\xb5\xed\x1f\x8e\x06\x5d\xef\x70\xfd\x6c\xff\xd5\xe1\x41\x70\x5a\xff\xb8\x3c\xba\xf9\xfd\xf5\xd9\x9f\xef\x0f\xdd\xd1\xf5\xd9\xc6\xf1\xb3\xdd\xd3\x72\x6b\xd4\x3a\xec\xbf\xdc\x3d\x3b\x7c\x7f\xd6\x6b\xed\x76\xfd\x60\xf3\xd9\x69\xfd\xea\xf8\x70\xb4\x5f\xb6\xce\x5b\x9f\xaf\xae\x5f\x95\xcf\x8e\x3f\xdd\x04\xff\xab\x1f\xfd\xf9\xed\xf0\xec\x73\xef\xf8\xf3\xeb\xf2\xa0\x79\xd4\x6d\x79\xaf\xbb\x83\xce\xfe\x6b\xeb\x78\x6d\xa3\xf3\xf2\xec\xdb\xf8\xfa\xf8\x74\xe3\xea\x23\x1d\xbc\xf5\xba\xfe\xf2\xc9\x41\xfd\xc3\xcd\xe7\xd1\x9e\xf5\xc9\xb3\x87\xb6\x5d\x7e\xb3\xff\x72\xf0\xf5\xdb\x95\xbb\x55\x3f\x6a\x9d\xed\xad\xbb\xf4\x7c\xef\xf7\xb1\x7d\xb2\x71\xf6\x66\xfd\x88\x2e\xd7\x9f\x07\x67\xbd\xa3\xdf\xcf\xce\xac\xab\x95\xa3\xc3\x8f\x57\x07\xd6\xf2\xcd\xef\x07\xc3\xe3\xcf\x47\x1f\xdc\xf5\xeb\xfd\x0f\xcd\xd3\xc3\x5d\xef\xfd\xa7\xfa\x86\x43\xbd\xd1\xe6\xf0\xd5\xb8\xeb\xef\x85\xc7\xfd\xab\x37\xfe\xa0\x3f\x1e\xbb\xc1\xe8\x8f\xc3\x93\x8d\xf7\x57\xef\x5b\xbd\xe3\x5d\xf7\xed\x9f\xad\xbd\x67\xd7\x7f\xf6\xfc\x97\x6e\x65\xf0\xe7\xf5\xae\x35\xf8\xfd\xdd\xde\x56\x73\xd4\x79\xf3\xf9\x60\x74\x72\x36\xda\xec\xd3\xd3\xd6\xd5\xd1\xf2\x59\xeb\xf5\x87\xdd\xcf\x67\xa3\xf7\xcd\xe3\xfa\xd9\xe7\xd1\x2b\x7b\xf0\x7b\xd9\xb1\x5a\x95\xe3\xf7\xcf\x46\x1f\x3b\xf6\xc9\xf9\xab\xeb\xa3\xab\xbd\x4d\x1a\x9c\x74\x06\xa3\xfa\xcb\xff\xed\xee\xba\x95\xb3\xbd\xde\xd7\xfa\xba\x75\x3a\x18\x1c\x37\x3f\x0f\x37\xec\xcf\x47\x7b\xfd\x4e\xaf\x7f\xd2\xef\x37\x3f\xbb\xfd\xd1\x1f\x87\x57\xdd\x41\xd3\xb9\xea\x3a\xcd\xf1\xd7\x8f\x37\x6b\x95\xe0\xf3\xd6\xfe\xdb\x60\xd4\xfc\x3c\xda\xad\x7e\xdb\x6f\xfb\xe1\xf2\xef\xf5\xfa\x92\x0c\x86\xb6\x2b\x83\xf7\x8a\x94\x93\x01\x26\xbd\xb6\x3b\x24\x68\xf9\x94\xba\x68\xe3\x4e\xec\x00\xcd\xad\xd8\xea\xe8\x81\x17\xba\x15\x52\x9f\x84\x3d\x0b\x6d\xc2\xba\xf6\x35\x75\xb5\x20\x10\x32\x72\x1a\xda\x74\x21\x2c\xd0\xee\xb5\xb7\xaa\xb8\xf6\xd2\x76\x5b\xce\x30\xb0\xaf\x29\x59\x11\xb8\x41\x90\x3c\xd8\x43\xb0\xcd\xcf\x0c\xeb\x88\x5a\xfb\xd2\x97\xbe\x69\x17\x0f\x0d\xd6\x34\x2e\x0e\xfa\x5e\x26\x69\x7f\xa3\x12\x23\x88\x97\x5a\x04\x8e\xa2\x4e\x30\x65\x96\xa1\x48\x73\x3f\x69\x06\xb8\x5f\xb1\x38\x35\xe0\xc0\x0b\xa6\xdb\x6b\x5c\x8d\x80\x24\xd4\x90\x4c\xe0\xe6\xa4\xa3\x61\x5d\x20\xff\xd9\x99\x58\x5c\xef\x58\x24\x8f\xe3\x4c\x2d\xcd\xd8\x10\x77\xcf\x5d\x84\xe7\x1d\x1a\x04\xff\x67\x0c\x9f\xb9\x61\xe6\x6f\xa3\x2c\xc5\x5e\xff\x4d\x99\xca\xc0\x74\x0a\xae\xd2\x58\x63\x46\xa6\x32\x5b\x9a\xad\x21\x6e\x69\x89\x21\x8d\x2c\x87\x5f\x4f\xdb\x6e\x08\xf1\x61\x30\x36\x3a\x18\x6a\xbc\x3a\xd9\x9b\x49\xfd\x3d\xd9\x4b\x74\xcf\xa9\x07\xe4\x0b\x86\xc3\x2e\xd9\xae\x4b\x7d\xc0\xfa\x0b\x9a\xf2\x5b\xd7\x96\xed\x40\x40\x11\x4f\x0f\x8d\x5c\xc4\x9a\x23\x2a\x58\x8b\x71\x16\xde\xef\xda\x6e\x97\x58\x2e\x8f\xc4\x2f\x8e\xca\x99\x46\xdc\x1e\xc2\x37\x06\x04\xd2\x73\x90\xbe\x37\x14\x66\x41\xe4\xc8\xc5\x70\xa5\x81\x1d\x0e\xd1\x1c\x74\xec\x0d\x49\xdf\xee\xf6\x42\x32\xb2\x5c\x80\xcf\x63\x30\xb3\x6d\x69\x10\xda\x2d\x88\x7c\x3a\x18\xf8\xde\x8d\xdd\xe7\x77\xe4\x4f\x11\x45\x7d\xb6\x09\xab\x57\xc7\xd6\x02\x70\x1a\x45\x74\x3b\xe3\x43\xcf\x97\x01\x9d\x8b\x80\x42\x0b\x62\xe2\x80\x81\xbb\xc0\x7e\x18\x50\x7f\xc5\xea\x32\x78\x22\xbe\x27\x40\x5f\xe9\xd9\xd2\x8f\x45\x64\xb2\x69\x59\xae\x3d\x84\xb3\xc0\xfe\xea\xbf\x02\x6a\xf9\xad\xde\x0e\x96\xfe\x77\xb5\xdc\x83\x19\x2b\x2d\xb1\x21\xcb\xd4\x47\xf4\xfd\x9a\xcd\xb4\x52\x5f\x90\xe6\xb4\xae\xd4\x40\xdc\x8f\xa1\xa3\x02\x18\xb1\x48\xde\x1d\x83\xbd\x3a\xa3\x1b\x0e\x51\xcb\x72\x5a\x43\x07\x47\xdd\xf1\xba\x76\x4b\x99\x8a\x8d\xfe\x81\xd4\x10\xe9\x18\xa7\xac\x79\xe4\x7e\xa5\xad\x10\xef\x2c\xc4\xd4\xfd\xbf\x27\xcb\x5c\x56\xb8\xc9\xd5\xa7\x36\xc4\x7d\xc8\x41\xd1\x10\xc2\xd0\xe0\x6c\x84\x46\x76\xd8\x83\xf9\xa8\xaf\x82\xf2\xe5\x03\x07\x49\x14\xa9\x4d\xa5\xb9\x59\xcc\x28\xd2\x08\xa3\xe8\xd3\xc0\xfe\x46\x8f\xdc\x90\xfa\xd7\x5a\x54\x3d\xfd\xb5\xa5\x5d\x25\x9a\xef\xf5\xc8\x7e\x26\xa0\x08\xa6\x95\x67\xcf\xf4\xe0\x7e\x7a\x59\x7e\x89\xbc\xba\x4a\xbe\x40\xd2\xb5\x2f\xe8\x4d\x84\xcc\x4b\x9a\xd4\xf1\x46\x6c\xe1\x92\xe7\x49\x4b\xb2\x0f\x31\x12\xa7\x9a\x81\xa6\x1b\x82\x02\x8c\x74\x1b\x50\xcd\x0a\x54\x1f\x3b\x71\xb7\x86\x26\xa0\x51\x13\xa3\x74\x1b\xd0\xe9\xac\x40\x85\x92\x28\x2b\x3d\xb0\x09\xe8\x74\x46\xa0\x29\xf7\xe7\xf7\x67\x08\x4a\x76\xb0\xe7\xb3\x98\x80\x22\xa9\x62\xd6\x9f\xb3\x1a\x7f\x6a\xa4\xe0\x22\x52\x32\xaf\xea\xbd\x69\xdc\x79\x0a\x2c\x2c\xba\x2a\x8f\x79\x15\x6a\xd1\x4c\xde\xe2\x0f\x81\xa0\xc7\x0a\xf2\x54\x4c\x87\xd2\x6d\x16\x8a\x91\x29\x57\xb8\x17\x23\x4a\x6d\x30\x33\x0c\x29\xf9\xe4\xb8\x50\xe8\x47\xac\x28\xf7\xed\xb6\x69\x44\x99\x61\x46\x29\xca\x46\xc8\x31\x1b\x35\x94\x25\x69\x2a\x4e\x1f\x6d\xc7\xf9\xe0\xf6\xa7\x45\x4b\x2b\x9e\x84\x99\x3e\xd8\xa5\x16\x53\xef\x9c\xfc\x74\x08\x69\x7d\xca\xc0\x43\xef\xb9\xd6\xe5\xb8\x91\x95\x32\xb8\x05\x29\x19\xbd\x4c\x8f\x87\x0f\x8d\xd6\xd0\x63\xd4\x6e\xc7\xea\x36\x46\x5c\x98\x62\x92\x4f\xe3\x7b\x2c\xeb\xc2\x53\x72\x16\x5a\x7e\x88\x69\xd9\x41\x73\x76\xbc\x11\x0d\x42\x6e\x7c\x67\x05\x04\x72\x6a\xb9\x6d\xd2\xa6\xd7\x76\x8b\x06\xc4\xeb\x84\xd4\x25\x3d\xeb\x9a\x12\x8b\x04\x7d\xcb\x71\xb8\x2a\x1d\xc9\xaa\x10\x6b\x48\xd1\x84\xdc\x96\xf1\xe5\x4d\x80\xff\x06\x7d\xfc\xb7\xdf\xc6\x7f\x9d\x2e\xff\xee\x44\x81\x68\x7f\xb7\x2b\xf8\x37\xe5\xbf\xbf\x45\x41\x21\x99\x10\x14\x47\x45\xfb\x17\x50\xba\xe5\x28\xdd\x72\x94\x6e\x13\x50\x5a\x8d\x0d\x80\xc8\xfd\x57\x31\xc7\x66\xd4\xb3\x1d\x4a\xf2\x62\x78\x76\x54\x26\x35\x91\x21\x30\x6d\x8b\xc8\xa3\x90\xc5\x8c\x2e\xc0\xe0\x0d\xf3\x0a\x88\x05\x34\x05\x84\x4c\x1f\x18\x81\xb0\xba\x4a\xfe\xdb\xa7\x6d\xdb\x22\x96\x4f\xd5\x86\xbd\x48\x02\xb6\x97\xc3\x68\xa4\x14\xf8\xa2\x49\x7b\xd6\xb5\xed\xf9\x6c\xef\x45\xa3\x09\x34\x70\x43\x2e\x87\xf7\x3f\x3a\xff\xa2\xdd\x66\x70\xa1\x23\x7a\x99\x64\x40\x22\xf9\x36\xb3\x0f\x64\x85\x54\x2e\xa3\xd6\x25\x46\x5a\x06\xf5\x77\x17\xed\x2e\x42\x58\x8e\x0d\x4d\xa4\xa0\xc2\x04\x7f\xdc\xde\x92\xdc\x8d\x93\x8b\x50\x0f\xec\xeb\xb1\x00\xd3\xe6\x34\xcb\xc4\x51\x7c\xe2\x93\x09\x76\xdb\x44\xad\x57\x08\x33\xda\x95\x42\x86\x51\xd6\x34\x32\x2c\x62\x98\x3d\x95\x69\xf6\x94\x76\xd6\xe6\xc6\x55\xb7\x22\x56\x6f\xa3\x35\x42\x71\x3f\xa9\x89\xb5\x68\x99\x91\x09\x6e\x94\x04\x67\x6e\x0b\x60\x1d\x39\xb0\xce\x65\x18\xb0\x1f\xd0\x0c\xc6\x81\x36\xe9\x20\xc8\x30\x95\xdd\x1a\x1f\x4b\xc9\x3f\x51\xee\x60\xef\x74\x14\x92\x6c\xec\x0c\x0c\x56\x57\xc9\xc7\x1e\x75\xb5\x13\x16\xd3\x6f\x3f\x7e\x36\xa3\x2a\x8e\x28\xca\x6b\xd7\x23\x76\x9b\x5a\xc4\x6a\x7a\xc3\x70\xaa\x33\x11\x05\xe3\x48\x4b\x39\x35\xf0\xd1\xe5\xba\xe9\xd8\xee\x55\x00\x0e\xbe\x3d\xea\x0c\x30\x08\x05\x65\x8a\x9a\xed\xd8\xb8\x99\xe7\x67\x2f\xa0\x93\x93\xd0\xa7\x34\x86\x19\x13\x3c\xae\x17\x46\x3b\xd6\xb3\x9d\x76\xc4\x73\x4c\x56\x33\x61\xd4\x5d\x62\x39\xe0\x2a\x81\x7e\xee\x81\x38\x28\xe2\xce\xf7\x8a\xc8\x5f\xa4\xcb\x7c\x29\xb2\x26\x6b\x1c\x66\x6e\x78\xe2\x09\x3d\x23\xf9\xb3\xf9\x98\xe9\x43\x35\xab\x45\x2a\x49\x34\x67\x48\x36\x92\xfd\x4e\xd0\x9b\xa8\xc6\x18\x95\x69\x57\xb9\x22\xf1\x5c\x54\x6a\x6a\x71\x3d\x87\xdc\x15\x13\x1a\x4a\xc3\x49\xee\x99\x8a\xc8\xec\x05\xad\x6e\x92\xa6\xa4\xec\xd7\x79\x97\x81\xca\xdc\xb7\x67\x92\x75\x9e\x24\x7c\x72\x28\xec\x9c\x0a\x85\xad\x59\x1d\xe3\xae\xa2\x6d\x18\x54\xa0\x4d\x5c\xc4\x6c\x42\xcd\x4b\xad\x53\x39\xb9\x71\xcf\x15\x92\x62\x74\x4a\xeb\x3a\x34\x89\x50\x30\xc4\xee\x64\x1b\x0d\xf2\x92\xc3\xb8\x4a\xe0\x0f\x13\xae\xfa\x3e\x13\x35\xfe\x8c\xf9\xf9\x33\xe6\xe7\x4f\x43\xbe\xff\x47\x0d\xf9\xc4\xcc\xed\x59\x98\x6d\x99\xec\x10\xf1\x53\x37\xa3\xdd\xb7\xfd\x70\x4c\x76\x08\xff\xa5\x7f\xaa\xb7\x3d\xdf\xa5\x6d\xdc\x39\xb2\x12\xfa\x8b\x9f\x41\x43\xff\x0a\x41\x43\x81\x6c\xaf\xa8\x33\xa0\x7e\x5a\x2b\x9b\x4a\x3e\x9c\xd3\x9b\xd0\xf2\xa9\x95\x26\xcb\xb6\xd6\x63\x45\xb3\xf0\x11\x65\xfe\x6a\xc6\x7f\x52\x15\x10\x31\x0f\xd2\x23\xf9\xe8\xe6\x79\x7f\xc9\x60\x97\xab\xab\xe4\x0c\xb3\x74\x04\x44\x45\xd5\xe2\x2a\xb7\xee\xf2\x92\x2f\x94\x58\x61\xcd\x07\x06\xbd\x3c\xac\x56\x8b\x0e\xc2\x80\xd8\x61\x20\x93\x13\xca\x43\x1f\x0b\x14\x40\x56\x91\xd5\xfd\x6f\x40\xa9\xb2\x3f\xe4\xc9\x28\x4a\x3c\x41\x85\xed\xad\x02\xb3\xad\xb6\xbd\x56\xb0\xda\xf1\xfc\x7e\x50\xea\x85\x7d\xe7\x5f\xca\x9f\x79\x45\x85\xf8\x03\x70\x68\x9d\x80\x8e\x2c\xec\x59\xd8\x4a\xa8\xf8\x4c\xd2\x6a\x02\x23\x8e\xe1\x6d\x7f\x9b\xfd\xcc\xe5\x0a\xc4\xf3\x09\x06\x42\xd2\x3f\x7c\xa3\xbe\x57\x50\xec\x26\x44\x5a\x9e\xa7\xce\xff\xae\xee\x53\x44\xc6\x7e\xfd\x5e\xe3\xc9\x13\xed\xb5\x38\x97\x79\x14\x09\x1d\xcf\x41\x89\xb2\x7a\xde\x95\x32\x77\xa9\x58\x25\xfb\x7c\x30\x00\xff\x8e\x4d\x9d\x36\xdb\x92\xb4\x41\x9a\xe6\xad\xd2\x55\xc9\x2a\x91\x8e\x0d\x5e\xe0\x82\xbe\xa7\x34\x18\x78\x6e\x40\xe5\x40\xd2\x80\x55\x76\x18\xbb\x60\xb4\x35\x1a\x50\x37\xa4\x6d\xb6\x73\xbb\xa6\x1c\xaa\xe7\xb3\x91\x1a\x38\x56\x8b\xf6\x3c\xa7\x4d\x7d\x39\x5c\x48\x5f\xaf\xf9\x55\x7b\x3a\x3b\x3b\x4d\xa1\xf5\xa1\xe5\x04\x14\x63\x70\xb1\x7d\x18\x6f\x8c\x81\x17\xa9\xf4\xd9\x18\x00\x13\x25\xfc\x9d\xb3\x91\x82\xca\x96\x3b\x16\xc3\xe2\xf9\x62\xe4\xe0\x5c\x11\xe9\x54\x5a\xd2\xcc\x48\x60\x4d\xe1\x93\x5f\xc4\x03\x39\x3b\x4d\xbe\x3d\xab\x98\xb7\x67\x95\xac\xdb\xb3\xca\xa5\xf0\x5f\xd7\x53\xd4\x70\xb1\x92\x97\x4c\xc1\x04\x8c\x1a\x4d\xf9\x84\x3b\x8f\x1c\x9b\x7c\x0c\x9b\x27\x4f\x88\x51\x83\x4b\x9f\x3f\x8c\x8a\xfa\x4b\x5e\x3f\x99\x17\x2c\x97\x60\xa6\x22\x3b\x20\x16\x2e\x98\x6c\xd7\x1e\xb0\x45\x13\xa8\x7b\x14\xe6\x02\xd2\xf2\x7c\x1f\xd8\x01\x98\x9a\x87\x70\x73\x68\x87\x1f\xd1\xbe\x39\x3f\x4d\x19\xe6\x09\x03\x8b\x4d\x22\x65\x27\x0f\x25\x47\x8f\x07\xea\xe2\x28\x6a\xc3\xa7\x2f\xf8\x6a\x14\x15\xb5\x4b\x50\xa5\x2e\x9a\x04\x7a\x64\x87\xe7\x95\xc0\xf1\x4d\x5e\x3b\x1a\x87\xc3\x17\xc5\xe6\xca\x7f\x8b\xe7\x65\xe1\xd2\x0b\xd2\xb4\x44\xc3\xe9\xe2\x79\x39\x4f\x62\x55\x0a\x45\x68\x9b\x1c\x64\xec\xc8\x91\x17\xa4\x5c\x5a\xaf\x92\x1a\x29\x97\x36\xe2\x01\x7e\xb1\xb2\x96\x11\x8a\xef\x97\xf3\x39\x0e\x3f\xa7\xce\xd9\xda\x43\xdf\x4a\xab\x25\xbe\x95\x82\x9e\xe7\x87\xea\x78\x86\x5a\x01\x04\xe5\x8d\xd7\xc0\x2f\xec\x1f\x3c\x30\xb9\x2b\xe8\xf9\x73\x35\x62\xbc\xb2\xdb\x6d\xea\x4a\x92\xa8\x30\xc2\x29\xe5\xff\xb0\x41\xf5\x8c\x57\x98\x81\x50\xdc\x2b\x4d\x8e\x37\xb7\xbf\xd2\x62\x2b\xc3\xb9\xcc\xb1\xdd\xb7\x5b\x68\xe4\x21\x36\xc9\xb8\xf2\x88\xe8\x93\x32\x7e\x21\x04\x8e\x6c\x8e\xc5\x31\x54\x00\xb7\xa4\x96\x8b\xc5\xc5\x51\x4d\x56\xbc\xe6\x48\xc4\xe6\xa6\x15\x50\x56\x44\x7e\xd5\xe2\x2e\xfb\xd4\x81\x73\x22\xf9\xad\xe3\xb9\xe1\xa1\xd5\xb7\x1d\x49\x04\x95\xe9\xac\xa4\x3e\x8a\xe2\x9c\xe9\x4c\x72\x21\xa2\xe8\xa5\x4a\x6f\x42\x1d\xf4\x19\x3f\x98\x89\x00\x1e\xdc\x9c\x7b\xa7\xb4\x9f\xaf\x3c\xc3\x43\x16\x7e\x4e\xd3\xd1\xfd\x02\x05\x2d\x73\xb8\x10\x2c\x93\x27\xb9\x9a\x76\x1c\x85\x21\x9e\xcf\xbd\x81\x00\xcf\xd3\x92\x95\x86\xae\x1d\x92\xa7\xa4\xba\xa4\x1f\xd7\xf0\x06\x6c\xf7\xaa\x69\xf9\x1a\xec\x27\x35\xab\x13\x52\xdf\x80\xdc\xb4\x5a\x57\x5d\xdf\x1b\xba\xed\xbd\xa4\xde\x0e\x7c\xbb\x6f\xf9\xe3\x8b\x89\x2c\x93\xab\x6f\x96\xcb\x39\x52\x23\xb9\x7a\xb5\x5c\xce\x5d\xaa\xb3\x28\x23\x56\x35\x34\xe9\x85\xa1\xd7\x37\x5e\x31\xf9\xe9\x89\xf3\x40\x3c\xe7\x1d\x59\x63\x62\x01\x62\xa4\xe5\x5b\x41\x8f\xc9\xcf\xa3\x83\x4a\x85\x3c\xce\xe5\x1e\x27\x65\xce\x6a\x05\x81\xed\x7e\x0d\x56\xbf\x06\x81\xc8\x9b\x55\x5d\xaf\xca\x26\xc0\x3d\x13\x9c\xb8\x1f\x3f\xd6\x8e\xc6\x45\xa4\xed\xaa\x7a\x95\x1e\xb9\x1b\x78\x1f\xcb\x6b\xc8\xcb\xcc\xe3\x35\x92\x0b\x5a\x96\x43\xff\x97\xe7\xe9\x92\xb4\xef\x13\xc5\x8c\x84\x92\x33\x1d\x7b\xe7\x11\x36\x53\x0b\x9c\x93\x61\xa8\x8e\xfa\x0a\x3a\x09\x40\x83\x87\x53\xca\x40\x44\x3f\x67\xa3\x74\xae\x72\x44\x89\x05\xab\xe7\x5d\x53\x2e\xed\x4b\xf2\x4e\x42\xb2\xdc\xaf\x1d\xaf\xc5\xe6\x7c\x02\xeb\x25\xd0\xad\x52\xc8\x25\x71\x32\xf5\x7d\x6f\x41\x46\x06\x10\xa5\xfa\x7a\x39\x7b\xe0\x2a\x05\xe8\x26\x94\x86\xc5\xdb\x19\x59\xe3\x00\x14\x10\xdf\x01\x0d\xc4\x76\x89\x2f\xed\x0b\x22\xf3\x4d\x8b\x0a\x8f\x12\x21\x16\x15\x3e\x73\x25\x83\x79\x10\xc0\x94\xc2\x63\x6e\x54\xf2\x43\x8f\x04\x03\xda\x12\x49\x09\xd9\x73\xdf\x0a\x5b\x3d\x72\x6d\x07\x43\xcb\xc1\x8f\x3e\x0d\x30\xff\x20\xd1\x43\xc0\x27\x08\x8b\x15\x52\x21\xcb\x24\x37\xb8\x21\x65\x92\x23\xcb\x24\x9f\x50\x66\x99\x54\x0a\x58\x48\x62\xd6\x84\x1b\x01\x8d\xef\x9b\xde\xcd\x99\xfd\x0d\x5a\xc9\xf1\xb9\xb5\xd2\xf4\x54\x85\x6b\xea\x87\x76\xcb\x72\xea\x4c\x5a\xd7\x48\xae\x6f\xb7\xdb\x8e\x9a\x48\x6a\xb8\x04\x7b\x89\x2f\x2a\x9c\x3d\x41\x7d\x99\x86\xb0\x48\x9c\x59\x1d\xcb\xb7\x15\xa1\x4e\x69\x9f\x29\xc8\x90\xca\xae\x67\x77\x7b\x40\x37\x71\x76\x0c\x99\xe8\xcf\xad\xc1\x2b\xf1\x21\x91\x29\x30\x1b\x57\x49\x4b\x7c\x56\x8c\xad\x40\x4d\xc7\x6b\x5d\x49\xe4\x12\x62\xf5\x03\x3f\xd6\x44\xf2\x7b\x60\x82\x15\x6d\x15\xce\xd5\xf4\x35\xd9\xa8\xd2\xf7\xbe\x65\x94\x64\x7d\x3c\xb4\x7d\xda\xf1\x6e\x48\xe5\xf9\xb2\xaa\xb8\xd2\x0f\x26\x36\xc3\x93\xfa\x57\x2a\x46\x7b\xd3\xd5\x3b\x68\x77\xa9\xaa\x06\xf3\xd7\x98\x69\x1e\x06\x97\x44\xc5\xc3\x98\xee\x72\xbc\x04\xde\xb6\x0b\x79\x08\x89\x2f\xac\xff\x50\x2b\x00\x61\xa1\x9a\xe0\xa5\xcc\xe9\xec\xdd\x9c\x41\x26\x4b\x2d\xf7\x42\x44\xb4\x28\xa2\xa3\xa5\xed\x4a\x9b\xb6\x3c\x9c\x33\x06\x28\xc5\x2b\x4c\x5c\xf1\xb9\xc1\x03\x11\x8f\x07\x74\x07\x6b\xab\x6b\x22\x0c\xca\x6d\xb9\x2d\x9a\xd6\x36\xdb\x90\xf7\xbc\x11\xde\x86\xd9\x6d\x0e\x58\x53\x5b\xc1\xae\xd5\x58\xd2\x2f\xda\x56\x68\xad\x04\x3d\xdf\x76\xaf\x76\x60\xd3\x72\x49\x96\xc9\xaf\x9a\x12\x10\x59\xf2\x67\x60\x2a\x54\x0c\x8b\x66\xd5\x4c\xe6\xe2\x35\x92\x59\x6c\x5a\x26\xd3\x80\xe8\xac\x36\x35\xb3\x69\xf5\x35\x96\x53\x4c\x37\x75\xff\xb9\xa2\x5b\x4c\x82\x90\x49\x06\x51\x31\x83\x0e\x08\x67\x8a\xde\xe8\xb0\x62\xe4\x90\xd8\x4c\x0b\x26\x42\x94\xf8\x3a\xb3\x4f\xdd\x80\x2a\x7e\xe1\x5c\x9d\xa6\x21\xae\x72\x0d\xf1\xce\x08\x74\xd1\x56\xf5\x13\x55\x5d\x08\x45\x25\xca\x9a\xaa\x2b\xae\xe9\x32\x2e\xab\x5c\x1f\x8d\x45\xba\x49\x3b\x9e\x4f\x67\x59\xa5\x51\xb9\x46\x05\xf1\x8d\xed\xd2\xbf\x9b\x16\x59\x59\x50\x8b\x9c\xa8\x25\x2a\xfa\xad\xb4\x50\x73\xf8\x71\xca\xe2\x03\x6b\x8a\x35\xf8\x5c\x73\xbd\x30\xff\xab\x0c\x78\x35\x07\x0f\x01\xd7\xf2\x7d\x4b\x82\x9e\x9f\xa0\xa2\xca\xe9\x90\xd9\x58\x8d\xe4\x34\x45\x41\x1b\x4b\x55\xe4\xa8\x6f\x75\xd9\xa2\xc1\x66\x82\xe5\xaf\x74\x7d\xab\x6d\x53\x37\xcc\x87\x1e\x0e\x78\x11\x34\xae\x6c\x96\x67\x7a\x17\x59\x5b\xfb\x77\x51\xcf\xc7\x4a\xca\xff\x2e\x24\xb6\xf8\x4e\x71\x19\x1c\x1c\x85\xde\x20\xb1\xdc\x29\x1d\x50\x0b\xd2\xba\xc2\x8f\x95\x9b\xc4\x52\xb8\x81\xcd\x6d\x0c\x6e\x48\x65\x70\x93\xa8\x8a\xf7\x87\x4e\x68\x9b\x33\x3d\x5b\xdb\xac\x4e\xd4\x36\x57\x94\xb6\x19\x17\x73\x31\x49\x25\x4f\x31\x2a\x4a\xdd\xb0\x4f\xce\xc4\xfb\x18\x84\x33\xdb\xed\x3a\xd4\xc4\x58\xa5\x57\xa2\xfd\x78\x9b\x67\xa0\x0f\xa8\xd2\x86\x3e\xc0\xb8\x0b\xce\x64\x81\xc9\x8f\xfa\x03\x1f\x14\x0b\xb6\x21\x46\x3d\x42\xe7\x6f\x1d\xea\x71\x9c\x70\x3e\x37\xe5\x30\xf5\x5f\x23\x7f\x93\x12\xb9\x43\x47\x38\x0b\x7d\x4f\xd2\x45\x97\xc4\x48\x71\x9b\x85\x45\x93\x38\x9d\xf7\x30\xf5\x07\x9e\xda\xf4\xa8\x33\x08\xc0\x13\x0a\x2c\x6e\x3a\xb6\xe3\xc0\xf9\x45\x40\x3a\x56\xc0\x64\x09\xa1\x6c\x17\x62\x5b\x8e\x33\x66\x22\xb6\xef\x35\x6d\x87\x0a\x3b\xd2\xd2\x92\xcc\x4d\x00\x71\x25\x5b\x96\x4b\x9a\x94\xc9\xd2\x0e\xb8\x59\x15\x89\x1d\xe6\x02\xd2\xf7\x7c\x4a\x1c\xfb\x0a\xdc\xbe\xac\x61\xe8\xb1\x66\x78\xdd\x4f\xde\x10\xaa\x39\xd4\xf2\x5d\x2c\x89\x96\x4d\x76\xc8\x76\x64\x60\xbf\x6e\xb1\x0d\x87\xc3\x3d\xc3\x84\x68\x6f\xd3\x6b\xea\xb0\x5e\x04\xa5\xae\xe7\x75\x1d\xf4\xcd\x1a\xd1\xe6\x2a\xda\xf0\x06\xab\xd5\x72\x65\x63\xb5\xfc\x6c\x15\x42\x31\x78\xc3\x70\x05\xbb\xb4\x32\xb2\xc3\xde\x8a\x40\x63\x49\x98\x7f\xb2\x17\x7b\x5e\x7f\xe0\xd0\x8c\x8c\x2c\x49\x79\x30\x22\x39\x60\x50\x11\x16\xe9\x54\xf8\x82\x9a\xe9\x34\x27\x5a\x3f\x04\x5d\x62\xfa\x64\x30\x3f\x36\x33\x13\x1b\xe4\xbd\xb3\x33\xac\x8b\xc3\xcd\xed\xc2\x46\x3e\x9b\x48\x7e\x3c\x37\xca\x7c\xc9\x9b\xce\x63\x67\x8d\x18\x34\x94\x71\x29\xeb\xaf\xbc\xe4\x10\x77\x53\x31\x3b\x3a\x2d\x4b\x92\x76\xae\xbf\x40\xc6\x0e\x8e\x66\x1a\x00\xbc\x30\x89\x66\xec\xc8\xe4\x8b\x87\x48\x1d\xa5\xb5\xc0\xc8\x83\xd6\xdd\xae\x52\xe1\x62\x6d\x7d\x50\xca\xdd\xd4\x6d\x1e\xb8\x6d\xf2\x05\xae\x40\xe4\xc5\xc0\x17\xd8\xc5\xc3\x4c\x4d\x18\x02\xea\xb6\x65\xc9\x7f\x50\xaa\xa0\x74\xda\xdb\x6e\xdb\x6e\x59\x21\xd0\x1e\x0f\xa7\x50\xe6\xda\x01\x71\x3d\xbf\x8f\x92\xb4\x19\x5a\x70\xe8\x74\x6d\x5b\x84\xc7\x97\x23\x1d\xdf\xeb\x2f\x09\xf7\x55\x19\x85\x55\x11\x12\xcf\xca\xee\x81\x3b\x42\xeb\x8a\x92\x21\x9a\x7a\xb2\xe5\x47\xb9\xd8\xc2\x3d\xb2\xe7\x02\x72\xbe\x6a\x5a\x5b\xa3\x66\x4b\x55\xd5\x16\x32\x22\x3d\x7f\x52\x3a\xc3\xa7\x09\x07\x65\x2f\x0b\xa2\xb5\xc3\x9d\x77\xb1\x83\xae\xd7\x16\xe9\xae\x0e\x6c\xd8\x29\xc8\x94\x57\xc2\xf5\x98\xec\x9f\x1c\x0b\x44\xe0\x02\x36\xca\xb6\x78\x89\x67\xb9\x12\xeb\xa6\x8c\x09\x10\xc9\xb8\xb4\xa7\x42\x88\x2e\x2c\x5c\x66\x9b\x1a\x11\x33\x88\x39\xe7\x88\x09\xe5\x7e\x26\x8b\x01\xb3\x10\x95\x8a\xff\x6f\xa4\xd8\xd2\xa6\x60\x9b\xed\xe7\xbf\x14\x71\xe6\x59\xed\xaf\xc3\x20\x94\x47\xa8\xe2\xe4\xf7\x9e\x24\x84\x38\x60\xcd\x62\xc5\xfc\x45\x0e\x30\x82\x00\xd7\x4c\x3b\xcd\x58\xb6\x2c\x12\x0a\x9b\x22\x31\x5d\xc4\xfa\x85\x86\xde\xfa\xfa\xa5\xed\x1f\xa6\x96\x11\x60\xfc\x6b\x85\xa1\x6f\x37\x87\x21\x9d\x28\x2b\x66\x4e\x51\x16\x4d\xde\xe5\x53\xab\x7d\xe2\x3a\xe3\x19\x50\x8c\x82\xf0\xdc\x5d\x67\x98\x2e\x86\xe3\x3c\x90\x96\x26\x0d\x6d\x15\xee\x3d\x4d\xda\x9c\x69\xce\xce\x4f\xf6\x4f\xf4\xfa\x0e\xb5\xd2\x19\x69\x62\x75\x30\x0c\x59\x20\xc9\x9a\xe7\x66\xeb\xc2\xd3\x40\x78\x4d\xc7\xfb\xde\x68\x96\x4e\x24\xc2\xf8\x30\x98\x85\x0c\x4c\x01\xef\x79\x7e\x48\x7a\xb6\x2b\xef\xc8\xf1\x6e\x49\x2d\x51\x78\x18\x21\x43\x50\x10\x48\x4d\xcc\xa4\x12\x1a\x24\xc9\xf6\xb5\xc3\xc3\x99\xb8\xfe\x2d\xb7\xdf\xe9\x10\xdf\x1b\x05\xb1\x54\x91\x72\xa2\x72\xe7\x72\xc6\x83\x6c\xaf\xcd\x63\xca\xa8\xf6\x59\xed\x1f\xad\x34\x1f\x5b\x37\x76\x7f\xd8\x97\x36\x48\xf7\xd1\x87\x63\x6b\x91\x6c\x7d\x73\x75\x03\xad\x6a\x67\xd2\x93\x4d\x63\x9b\x7f\x90\xa6\x0c\xaa\x05\x17\x55\x38\x01\x84\x60\x27\x47\x21\x9b\x2e\x3c\x30\x0b\xf0\xbf\xdd\x26\xaf\xce\x8f\xdf\x6c\xf0\x92\x0c\xa6\x22\x51\x38\x39\xaf\x5a\x82\x0e\xaa\x6f\x21\xe5\x75\x55\x87\xeb\x7d\xd2\x9e\x72\xe6\x74\x8a\xf7\xc4\x39\xa9\x9f\x2d\xdf\xb7\xc6\x27\x9d\xfc\x43\x33\x6e\xe1\xb2\x20\xcf\x95\x8e\x78\xe8\xf0\x49\x11\x1c\xd2\xa2\x37\x40\xfd\xb4\xe8\x0d\x12\x28\x94\xca\x1b\xd1\x2f\x54\xd4\x86\xcc\x88\x0d\xd3\x44\x6b\x00\xe8\x32\x67\xd8\x43\x46\x6a\x98\x1c\xa5\xc1\xf4\x4c\xba\xef\xe8\x0c\xd0\xd3\x59\xa2\x33\x20\x69\xee\x2b\x3a\x83\xbc\x2b\x52\x99\x86\x32\x93\x76\xa1\x4b\x1b\x2c\xec\x59\xe9\xb7\x62\xa9\xb2\x64\x3b\x60\x4f\xac\x7c\x68\xe3\xa9\xb1\x00\xb6\xee\xec\x97\xf0\x99\x37\x17\x89\x51\x6f\xe2\xc8\x34\xbc\xf9\x50\x04\x52\x64\xe2\xc8\x60\xa7\xa3\xc8\xbe\x4e\x83\xe1\xe4\x2c\x66\x29\x69\xc9\xf2\x85\x78\xe3\x70\x3e\x8a\xb6\xbc\xda\xe8\xc5\x23\x53\xac\xae\x92\x77\xd4\xef\x78\x7e\x5f\xe8\x33\x6c\x37\xf0\x01\x4e\x5b\x53\xfb\x1b\x4f\x57\x96\x9e\xac\x2c\xbb\xcf\xa7\xb4\x13\x97\x4f\x66\x26\x84\x08\xf3\x69\x09\x10\xa2\x88\x25\x25\x41\x48\xfa\x6e\x26\x42\xb8\x23\x94\x8d\x6f\x22\x30\x3c\x6c\x7f\xf2\x24\x0e\x06\xbe\x94\xfc\x09\x8d\xc9\x52\x91\x26\x15\x29\x16\x8c\x32\x02\xe3\x98\x11\x5d\x84\x0b\x6f\x1e\x5d\x64\x42\x7e\xb6\x99\xb2\xb3\xc9\x80\x19\xe9\x9c\x18\x65\x44\x45\x9d\x28\x25\x96\x34\xcf\xf8\xec\xf0\x27\xb3\x84\x3e\x49\x4e\xf1\x36\x05\x8e\xd1\xb9\x32\x09\x47\x46\x9f\x53\xda\xa2\xf6\x35\xe5\x49\xa7\x26\xd3\x53\x2f\x9f\x77\xe9\x0d\xf2\x4a\x41\xb7\xd3\x65\x9a\x4e\x93\x89\xad\x91\xe7\xe6\x42\xd8\x6b\xaa\xad\xa6\x4c\xf1\x24\x53\x73\x33\x5d\xd9\x73\x21\xc9\x3b\xde\x4f\x18\x56\xba\xab\xab\xe4\x23\x25\x2e\xc5\xb3\x99\xa6\xe7\x5d\x91\x2b\x4a\xf9\x79\x21\xaf\x80\xa0\xfa\x96\x3b\xb4\x1c\x47\xba\x62\x2b\x32\x9a\xb9\xcf\xd8\xbc\x90\x88\xcb\xb7\x31\xe2\x26\xc6\x55\x48\x58\x67\x88\x11\x4c\x61\x3a\xa2\xa3\x9c\x9a\x86\xdc\x58\x32\x89\xd0\xc9\x8c\xac\x0a\x66\x71\x8b\x2a\xa5\xa4\xc9\xea\x2a\x0a\x94\x01\x8a\x55\xb5\x51\x14\x72\x51\x13\xbd\xbb\xe9\xc3\xb0\x38\xf5\x17\x48\x5c\x16\x4f\x49\xc6\x9a\x8b\xa4\x12\x8b\xaf\x7b\xd1\x0c\x2a\x62\xf1\x4b\xcf\x52\x28\xe3\x92\xbd\xf2\x9c\x76\xa0\x6d\x27\x7c\xda\xa1\x3e\x75\x5b\x40\xad\x08\x0b\xe8\x03\x95\x2b\x2e\x49\x18\x75\x5d\xf7\x9f\xc1\x97\x8a\xa8\xd8\x05\xf7\xec\x53\x25\x40\xde\xa3\x1f\x55\x12\xa7\x9b\xe2\xcd\x48\x9f\x2b\x62\x63\xdc\x47\xec\x3b\x23\x05\x27\x36\xc1\xb5\x60\xe9\x8c\xa3\x25\x04\x94\x8e\xfc\xf1\x29\x2c\x27\x50\xda\xcc\x55\x33\x4c\xba\xb0\xcc\xc9\xd1\xda\x2c\xd2\x7d\x9b\x74\xae\x9d\x92\xd9\xa1\xf2\x04\x6e\xc7\x06\x12\xd8\x3d\x16\x60\x2a\x11\x5e\xfc\x7b\x32\x2c\xa4\x7a\x4c\x97\x9b\xb2\x23\x70\x0e\xa8\x37\x9c\x5c\x22\x1f\x91\xc5\x09\x5d\x88\x41\x8a\x7f\x8d\x42\x49\x60\x07\x23\x00\xce\xc4\xe0\x37\xd1\xac\xa4\xfa\x43\xd5\xcc\x13\x9d\x1d\x1e\x47\xb7\x0d\x50\xb1\x6c\xf4\xb7\xd1\xd2\x62\x9b\xa3\x15\x85\x57\x7a\xb9\x69\x12\x96\xce\x92\xae\xd4\x70\x62\x53\xe9\x47\xb5\xb7\x46\xe9\xa9\x93\x95\x46\x6f\x8b\x63\xa5\xe5\x17\xc3\xf2\x4c\xbb\xf7\x55\x35\xf4\xb7\x46\x69\xdf\xf7\x7c\x13\x15\x78\xa5\x97\x91\xb7\x90\xaa\x8c\x7c\x65\xa4\xb2\x6b\x6b\xe1\x8b\x8c\x9e\x98\x77\x76\x91\x54\xa9\x2a\xc6\x88\x56\x03\x0b\xfc\x9a\x9d\x89\x55\xb0\x6d\x7a\x61\xe3\x5d\x44\x72\x7e\xbf\x23\xb5\x78\xb1\x6d\x8d\x3b\xd5\xdb\x3d\x2d\x33\x66\xac\x4a\x32\x57\xa8\xef\x9c\xbc\x33\x45\x59\xfa\x55\x4f\x4b\x77\xa1\x25\x57\xbd\x2c\xc4\x1a\x99\x98\x7d\x16\xef\xa7\xcc\x51\xc6\x77\x46\x29\x79\xb6\xab\x0a\x89\x57\x7a\x39\x54\x18\xf4\x3c\xb5\xec\xd9\x2c\x11\x99\x86\xfc\x85\x59\x66\x9a\x7c\xb7\x5c\x42\x19\x85\xd8\x0b\xb3\x8c\x88\xb6\xd0\x30\xe4\xb2\x59\x86\x5f\x4b\xe8\xa5\xf8\xab\x58\xb9\x0f\x83\x48\xa9\x0f\x03\xbd\x8c\xe9\x4d\xc9\xcb\x25\x78\x24\x90\x89\x59\x7f\xc5\xb5\x98\x2a\x21\xde\x18\xa5\xbc\x91\x46\x4a\xf6\x14\xfd\x7a\x6c\xdd\x98\x05\x8e\x2d\x23\xfd\xa1\x79\xc4\xad\x8a\x9a\xef\xf5\x1a\x21\xf7\xf1\xe7\x01\xc6\x22\xc9\x23\x27\xe5\x16\x9e\x3b\xae\x98\x2e\xd9\x73\x45\x92\x93\xe2\x3b\x2b\xd7\xb0\x2e\x68\xa3\xc9\x86\xa3\x82\x92\xbd\xd3\x45\x21\x3c\x33\x79\xc7\x7e\x48\xa1\x06\x09\x89\xdb\x32\x2d\xb1\x14\x50\xd9\x69\x8b\x71\x46\xc1\x2f\x31\x6d\x30\x8b\x31\x9b\x1e\xf8\x4b\xf6\x45\x4f\x6d\xcc\x59\x1a\x7f\x72\x95\x8b\xfd\xe4\xec\x29\x1f\x3e\x0c\xd8\x4f\xdd\xce\x5d\xcb\x95\x2c\x18\x07\x7e\x7b\xa3\x40\xfc\x7b\x6c\x41\xca\x64\x73\xa4\x21\x64\xdb\x78\x40\x93\x92\x29\xcf\xbd\x23\xc9\x4c\xa4\xac\x8a\xa0\x23\xd8\x8e\x5a\x78\x8c\x86\x81\x84\x64\x47\x93\x58\xdb\xe9\x9a\x53\x54\x41\x9c\x29\x01\xf3\x2c\xe9\x97\xef\x12\xf3\xfb\xf2\x9e\x64\x35\x22\x3a\x1b\x69\x01\x5e\x4f\x02\x2f\x68\x91\x05\x5f\xd1\xcb\x6c\x00\xdf\x27\xed\xe8\x34\x62\xcf\x93\xed\xf9\x7e\xb2\x39\x27\xe6\x61\x9e\x03\x0e\x6a\x2a\x48\xe5\xf9\x20\x28\x3d\x46\x69\x39\x73\x42\xc2\x83\x81\xa2\x1e\xac\x90\xbf\x9b\x17\xa0\x1c\xcf\x62\x64\x7c\xe7\x03\x88\xde\xcb\x45\xf2\x28\x2a\x14\xe7\x03\xa7\x74\x03\xa5\x39\xcc\x07\x49\x1a\x4a\x26\xe3\xa6\x27\xe8\x8e\xa4\x17\x2f\x18\xd2\x07\x85\xf5\x4c\x5c\x8d\x99\x86\x0d\xb6\xae\xce\xca\xd7\xd5\xa2\x99\xb8\x78\x7f\x21\xee\x8e\x42\x53\xd6\xf6\x45\xf2\x68\x2e\x42\xc7\x20\x82\x55\x7d\x91\x28\x9f\x73\xb4\xb3\xcf\x2d\x02\xf4\x78\x41\x6e\x88\x11\x91\xba\x01\x83\xa5\x09\x41\x34\x9f\x32\x19\xa2\x5a\x28\x26\x69\xe9\x26\x5f\xc8\xcb\xe7\xa8\x9c\x4c\xd8\x7a\xab\xb2\x3b\x3b\x2a\x67\x8e\x80\x74\x14\xdd\xc7\xf0\x7c\xdc\xc9\x9b\x86\x8c\x70\xa7\x46\xde\x69\x4c\x94\xff\x5d\x3b\x3a\xe8\x44\xa2\x51\xe2\x05\x8c\x10\xe2\x05\x63\x4d\x34\x55\x14\x7d\x7d\x88\x61\x6b\x16\x8d\x9c\x25\x02\xaa\x7a\xe4\xab\x92\x1d\x1c\x0f\x6d\x05\x39\x6f\xc2\x63\xfa\xda\x19\x75\x68\x2b\x84\xf7\xb9\xcb\x42\x24\x5a\xf7\x34\x74\xd0\xca\x13\x12\x00\xb4\xd3\xec\xde\x93\xa9\xb2\x76\xbb\x43\x47\x0f\x35\x7d\x97\x74\xba\xa9\xee\x94\x14\xc7\x46\x34\x0a\x50\xbd\x9f\x3c\x21\x8f\xb8\x2a\x65\xf6\x30\xce\x0d\xc2\x6c\x2f\xa7\x35\x87\xcd\x2c\x46\x19\x69\x4d\x93\xa0\xdc\x13\x69\x2c\xf8\xd0\x94\x4b\xe8\xb1\x8a\x68\x26\x50\xcf\x50\x3a\x66\x0b\xed\x9a\x6b\xdb\xd7\x9a\x4f\x55\x1a\x9d\xa4\x61\x60\xe4\x1e\xb9\xa8\x8c\xd9\xa2\xb7\xe0\xc5\x58\xce\x79\x58\x2f\x12\xd2\xf3\xa7\x6d\x90\xb2\xbb\x10\x9d\x27\x53\x0c\xb1\xe9\x04\x33\xf1\x80\xab\x46\xd2\x0f\xb6\xb0\x5b\xe6\x5a\x98\xb4\xf1\x36\xe8\x92\xb4\xf3\xe6\x46\x78\x09\x3b\x60\xcd\xc8\x2f\x71\x17\x9d\x9d\xac\x5f\x88\xd8\x9a\x12\xcc\x2f\xf0\xac\x5d\x4b\x37\x11\xdb\x6e\xf2\xdc\xfd\xe6\x79\x53\x8d\x98\xe7\x4c\x68\xa8\x1a\xdd\x66\x9b\xce\x28\x69\xe7\x72\x86\xd5\x5f\xca\x76\x1e\x0d\xa1\xa2\xdb\x61\x65\xdd\x9a\xb6\x7d\xc7\x89\xab\x66\x86\x3e\x0b\x0b\x1a\xbf\xe9\x5b\x53\xfe\x52\x3f\xa2\xc7\x5d\x1a\x9f\x46\xc0\x65\xdb\x4b\x13\x42\x05\xa3\xad\x4a\x7f\x68\x73\x95\x28\x77\xc4\x17\x2c\xfc\x90\x90\xda\x3f\xee\xa3\x22\xd3\xf6\x6b\xee\x08\xf2\x9d\x66\x7e\x2c\xdf\x21\x99\x40\x1a\xe6\x30\x1b\x10\xb6\x96\x90\xd0\x7f\x86\x74\xfe\xc9\x81\x83\x67\x4b\xea\x8f\xbd\x27\x77\xc2\x26\x67\x3b\x16\x29\xf8\xd9\xbd\x46\x0a\x5e\x5d\x25\x47\xc7\xef\x4e\x4e\xcf\xeb\x6f\xcf\x71\xc2\x91\xfe\x30\x08\x49\x93\x12\xbb\x4d\x5d\x34\x46\x0f\x3d\x82\x9e\xfb\xa5\xaf\x01\xc1\x13\xc5\x25\xb8\x5a\x46\xd3\xf4\x1e\xf5\x29\x69\xd2\x96\xc5\x60\xb7\xbd\x56\x97\xba\xa4\x65\xb9\xb9\x90\x8c\x69\x48\xec\x3e\x43\x09\x95\x39\x98\x3b\xe8\x66\x4c\xac\x96\xef\x05\x01\xe9\xd8\x0e\x0d\x4a\x7f\x93\xe4\x9c\x53\xe7\x8b\x66\xc4\x4a\x74\xb2\x8c\x9a\x12\xcf\xe7\x09\xf7\x4a\x44\xa0\x88\x66\x93\xcc\x07\x05\x65\xa6\xe8\x65\x19\xb4\x6b\x66\x82\xff\xa8\xe4\x6b\x13\xcd\x26\xff\x51\xbd\x8d\x79\xd1\x1c\x75\x60\xa5\x12\x39\x3b\x03\x9c\xd2\x10\x2c\xde\x72\xdb\x64\x38\x90\x8e\x1a\x3d\x9c\xd1\x92\x5b\x6e\x82\x0c\x8b\xf6\x44\x27\xb2\x39\x1b\x0a\xfa\x3f\xa8\xa1\x7e\xfb\x07\x35\xe4\x74\x7f\x50\x43\x37\xce\x7d\x36\xd4\xf6\x46\x6e\x06\x3b\x64\x3a\x49\xdc\x6f\x63\x41\xff\x07\x36\xd6\x6f\xff\xc0\xc6\x9c\xee\x0f\x6c\xec\xc6\x99\xd8\x98\x48\x68\xac\x6b\x14\x9b\x7f\xad\xdc\x03\x18\x89\xfa\x8d\x1d\xa4\xad\xef\x1b\xcf\x21\x60\xf5\x84\x86\xc4\xb5\x0b\x8f\x97\x42\xdd\x61\x9f\xfa\x4c\x71\xc4\xa6\x98\x1a\x08\x99\x36\xa4\x95\x40\x97\x2a\xbb\x3f\xb1\x13\x4c\x09\x81\xcd\x90\x2b\xe8\x1b\xca\xbb\x08\xe6\x47\x21\xed\xa7\x85\x18\x7f\xbe\x35\x0d\xf6\x02\xca\x43\xa1\xcf\x60\x4f\xec\x42\xfd\xda\x0a\x2d\x3f\x75\x18\x36\x66\xe9\x08\xc2\x7a\xc8\xee\x60\x0b\x13\x3b\x75\x4e\x6f\xd2\x39\xeb\xd9\x2c\x5d\x62\x90\x1e\xb2\x43\x0c\xfe\xc4\xee\x1c\xb5\x3c\x37\xb5\x3b\x9b\xb3\x74\x87\x41\x7a\xc8\xee\x30\xf8\x13\xbb\x73\x46\x5b\x9e\xdb\xb6\xfc\x71\x1d\xdb\x49\xeb\xd9\x4c\x93\x28\x02\xf4\x21\x3b\x19\x69\x2a\xb3\xbf\x67\xc3\x66\x8f\x5a\xfc\x9a\x3e\xb1\x97\xcf\xa7\xed\xa5\x04\xf5\x50\x7d\x93\x0d\x24\xf5\xe8\xc1\xd3\x00\x44\x56\xac\xad\xbf\xe2\x8a\x75\xee\x79\x4e\x33\x55\x5a\x3e\x5b\x9f\x6a\x2c\x1f\x70\xd1\xe2\xf8\xfd\x15\xc6\xef\xf9\x14\xe3\x07\x43\xb5\xba\x9a\x14\xb1\xed\x9b\xe3\xd9\xbe\xd7\xba\x5a\x6d\x79\x3e\x5d\xf9\x2a\xc3\xb6\x6d\x3d\xfb\x17\xfc\x6a\x79\xfd\x3e\x75\xc3\x95\x4a\x65\x63\x73\xe3\x79\xb9\xba\x05\x03\xd4\x75\xbc\x26\x64\x42\xc6\x86\x4a\xbc\x1d\xb2\x23\x3c\x2a\x31\xe5\x16\x79\x64\xdc\x67\xb3\x9e\xf2\x4c\xa7\xc7\x16\xa4\x03\x20\xec\xdf\x25\x42\x5e\x88\x0a\xd2\x25\x33\xa0\x4e\x27\xa1\x3a\x7b\x6d\x54\x26\x2f\xe0\xdd\x12\xd8\xf5\xd2\xc0\xb1\xdd\x70\x85\x9f\x6a\xad\xb8\xf4\x26\x5c\x01\x23\x27\xd7\x5b\x71\xe9\x68\x85\xd1\x67\x89\x90\x1a\x39\x14\x84\xca\xf1\x71\x60\x9a\x61\xae\x90\x2f\x6c\x2f\x69\xb7\xf2\x8d\x46\x97\x35\x93\x43\xd3\xdf\x5c\x01\x5f\xf0\xce\x6f\x27\x34\x28\xda\x02\x9c\x97\xa2\x43\xf5\xbc\x3c\xed\x50\xc1\x8d\xbd\xe7\xd3\x24\x02\x7f\x27\xd7\xd4\x0f\x30\x68\x59\xb5\xb4\x51\xaa\xe4\xc8\x5d\x04\x6b\x1a\xc5\x9a\x01\x62\xf0\xe6\xc0\xb9\x32\x2d\xce\x31\x44\x95\xff\x90\x1d\x1a\x51\xef\x39\x9e\x36\x3f\x06\xc0\x13\xbf\x1c\x79\xc1\xde\xc8\xa4\x12\xb5\x68\x31\x79\x5a\x80\x11\xba\xa2\x78\x56\x17\x12\x63\x70\x02\x67\xb9\x57\xb9\x80\x1c\x1d\x6c\x81\x47\x23\xdb\x2a\x74\x86\xae\x3b\x26\xa6\x80\x89\x77\xf4\x51\x62\x12\x93\xb5\xb5\x78\x3a\x64\x4e\x80\x64\xc1\xf5\xfd\xae\x48\x72\x16\x93\x56\x11\xb9\x94\xd7\xe4\xc5\xe6\x36\xb9\x23\x77\x85\x92\xc5\xe6\xc6\xe6\x36\x8a\x9c\x28\x2d\xd6\x66\x10\x09\xd5\x72\xa9\xca\xfe\xdb\x82\xd9\x54\x0a\xec\xae\x9b\xbf\x29\xc4\x3b\x29\xbf\x92\xdb\x5b\x2d\x05\x01\x16\xc7\x73\xb9\xec\xf9\xc7\x66\x29\x98\xe2\x5b\x70\x64\x27\x12\xc9\xdd\x90\x1d\xb2\x7c\x53\x60\x1c\x5b\x66\xa0\x6f\x58\xc7\x6e\xc8\x0b\x72\x43\x6a\xe4\x86\xfc\x87\x94\xc9\x0b\xb2\x52\x21\x35\x52\x49\x1e\xf8\xf5\xd9\x3b\x5b\x59\xc7\xee\xd0\x9b\x41\xbf\xc2\x7a\xcb\xe6\xdb\xaf\xf0\x24\x7a\x0a\x0f\xdb\x71\x32\xe4\x1f\x61\x39\xec\xef\x89\xd3\x26\x87\x87\xa4\x39\xec\x2e\x11\x86\x3c\x7e\xcb\x57\xca\x05\xf2\x1b\xa9\x56\xcb\xd5\x8d\xd2\xfa\xb3\x8d\xcd\xe7\xeb\x5b\xe5\x67\x9b\x95\xe7\x91\x22\xff\x89\x17\x79\xb6\x51\x79\xb6\x85\xb0\xcf\x3d\x9f\xec\xf2\x6c\x93\xd1\x06\x56\xaa\x74\xa5\xb2\x59\x60\xa4\xc2\x9f\x4b\x05\xf2\x42\x8d\x8a\xe8\x97\xce\x73\x26\xa1\x05\x79\x7f\x23\x2b\x15\xba\xf2\x8c\x49\x56\x46\x6b\xf8\xcd\xbe\x2d\x93\x1b\xf2\x94\xdc\x90\x55\x52\x25\x35\x49\x11\x06\x72\x05\xc6\x81\xd4\x38\x2a\x09\x03\xb2\x58\xfa\x3d\x3c\x1a\x0e\xe8\x4b\x1a\x9e\x5b\xdd\x34\x65\x6e\x8d\xdf\xa3\xf0\x7c\x33\x69\x89\x84\xb6\x64\x31\x9c\x72\x6f\xec\xab\xb4\xa4\x43\xeb\xeb\xfc\x7e\x80\x7c\xc1\xb2\xff\x0a\xbd\x33\x38\x2e\xfe\xc2\xa3\x83\x2b\x17\x98\xa0\xc4\xba\x88\x59\x3a\x58\x09\x44\x34\x77\x81\x92\x8c\x60\xb5\xcb\x1c\xc2\x5b\x22\x4f\x09\x38\x51\x43\xa6\x9a\x2f\xa0\xef\x40\xba\x7f\x38\xae\xb6\x3b\x36\x6d\xa3\xef\xcb\x17\xd1\xdc\xc0\xb7\xfb\x36\x84\xc9\xf1\x7c\x82\x30\x4b\x4b\x04\x00\xfd\x37\x08\xad\xd0\x6e\xe1\x4f\xdb\x6d\x51\x52\x2e\x55\x4a\x65\x78\xee\x53\x26\xef\x4f\x3a\xa4\x01\x8f\x2d\x2b\xa4\x5d\xcf\x1f\x93\x37\x96\xdb\x5d\xd2\xe2\x9d\x3c\xbd\xe3\x36\x9d\xe7\x32\x40\x4a\xe8\xa1\x8b\x47\x09\xca\xc5\x9d\x63\x4e\xf9\x1b\x8c\x59\x13\xe9\x87\x08\xfd\x54\xc4\xcb\xef\x2f\x70\x33\xf4\x05\x41\xd1\x1b\xab\x3f\x70\x28\xc7\xbe\x51\xb2\x03\xec\x64\x3e\x67\x35\x5b\x90\x5a\xf2\x29\xe3\xf5\x9d\xdf\x50\x01\x8c\x15\xab\xe8\x45\xb8\x6b\xda\xd3\x55\x3d\xbf\x0a\x2f\x18\xcf\x5d\xc4\x97\x0f\x6e\xbe\xba\x43\x72\x88\x65\x8e\xdc\xde\x02\x4f\xe4\x1f\xc5\x93\x15\xe9\x7c\xa2\xbd\x56\xfc\x28\x5e\xee\xec\xa8\xa1\xc7\x1c\x36\x31\x49\x21\x50\x4b\x98\x21\x8b\x5d\x3b\xcd\x3a\x43\x1e\x88\xf5\x51\xbd\x88\xb0\x3e\x46\x45\x99\x9d\xf5\xb1\x5e\x26\xeb\x3f\x7d\xfa\xd6\x0b\x69\xed\xe9\x53\x72\xee\x11\x7a\xd3\x72\x86\x6d\x4a\xbe\x1c\xb9\x70\x0b\x36\xfe\x52\x24\x5f\x56\xb4\x07\xcb\x6d\x93\x2f\x6f\xad\xb7\x5f\x8a\x64\xd4\xb3\x5b\x3d\x02\xab\xce\xd3\x48\xcb\xd8\x87\xa0\xa8\x92\xe0\x32\xde\x3b\x64\x40\xe8\x17\xd2\xa7\x61\xcf\x6b\x27\x4d\xbd\xc8\x54\x8b\xce\xc4\x1f\x38\xf5\x44\x7c\x8b\x69\xa6\x1e\x12\x39\xbf\x96\x31\xed\x78\x11\xfc\xa7\x74\x7c\xf4\xb6\xf1\x47\xfd\xcd\x87\x83\xc9\x35\x04\xe9\x27\x97\xcc\xad\xe5\x26\x4e\x6a\x5e\x74\x8a\x49\xcd\x95\x5c\x39\xa9\x67\x99\xc1\x92\x83\x53\x67\x30\xe2\x91\x30\x83\x33\x8f\x79\xd5\x1c\xe3\xb0\x1a\x8d\x69\x37\xd0\xab\x4f\x49\xcf\xf2\xfb\x9e\x3b\x16\x77\xbd\x4f\x57\xd1\x77\xaa\xc1\xd3\xe4\x36\xf0\x8a\xf9\x60\xbf\x71\x7c\xb2\xff\xe1\xcd\x41\xa3\xdc\x70\xbc\xb6\x15\xf4\x1a\x76\x20\x76\x35\x8d\x46\xda\x82\xf8\xac\x70\x7f\x6d\x34\xd4\xbd\x7c\x42\x5b\x25\x37\x3f\x23\xbc\xf9\x50\xab\xa0\x45\x44\x7a\x97\x17\x04\xbb\x40\x2f\x25\x8c\xf9\x50\xa8\xc2\x2d\x65\x23\x84\x0b\xcb\xb4\xee\x95\xef\x03\xf6\x02\x7d\x34\x01\xcd\x87\xcc\x5a\xa3\x31\x0c\x6d\xa7\xf1\x6e\xe8\xd3\x53\x70\x2f\x4c\x1f\xcd\x8d\xf9\x9a\x58\x6f\x34\xf8\xf9\xcb\x1b\xda\xa5\x6e\x7b\x0f\x03\xd1\xa7\xb6\xb3\x59\x99\x93\x6f\x36\x78\x5f\xf6\xad\xd0\xfa\x10\xda\x4e\xfa\xc8\x55\x36\xe7\x6b\xe1\x19\x6f\x01\x6e\xb4\x27\x34\xb1\x06\xbb\x43\x3d\x75\x34\xd9\x11\xbb\x4f\xb6\x0e\x46\x76\x73\x79\xcc\x98\xce\xb6\x9b\x32\xa6\x8f\x4d\x76\x48\x65\x9b\xd8\xe4\x3f\x31\x97\xe5\x6d\x62\x43\xa4\x1e\x40\x98\x47\xcb\xd3\x63\xf4\xd8\x97\xdb\x0a\xce\x15\x1d\x13\xdb\xe5\xc5\x58\x25\xbb\x43\xf2\x1c\x95\x81\x08\xa4\x53\xea\x59\xc1\xc9\xc8\x15\x5b\x62\x4c\x00\x8e\x55\x8a\x0c\x42\xa1\x20\xd3\xba\x5f\xf0\x90\x40\xf8\x15\x9e\x60\x6b\x4c\xee\xe4\x5a\x01\xe5\xb6\xc9\x5d\x42\xea\x63\xe3\x78\x02\xfa\x2b\x9e\x8c\x4d\xb9\x4d\x03\x4e\x13\x91\xe7\x3d\x4a\x9a\x32\x92\x06\x7d\xa3\x12\xc8\xd2\xa6\x41\xcb\xb7\x07\x21\x78\x86\x40\x29\x20\x8b\x7a\x5d\x52\xe7\x92\x64\x27\xe5\x3d\x1b\x23\x48\xd4\xa8\x7f\x6f\x79\x6e\xc7\xee\x0e\x45\x4d\x30\x5f\x06\xa2\x3e\x86\x15\xee\x31\xa3\xb6\x2a\x5e\xd0\xab\x8e\x7c\x3b\x34\xaa\x25\x1f\x48\x88\x9e\x6b\x35\xaf\xe8\x58\x7f\x2e\x6c\xeb\x04\x57\x14\xd5\x22\xa6\x00\xe1\x42\x8f\xdb\xa0\xa2\x0e\x25\x02\x3e\x88\xbc\xf6\xfc\x73\x21\x4e\x7c\x0d\x90\xe2\x12\x1d\x64\x01\xfb\x6c\xc0\xcd\x82\x62\xa2\xb0\x2d\x50\xd7\x4a\x6c\xc3\x31\x6b\xde\x4c\x5e\x2c\xec\xd0\xab\x3c\x44\x4c\xd5\x38\xe8\x35\x83\x65\xe5\x6d\x37\x08\x2d\x97\xb1\xac\x06\x56\x74\xf7\x91\xfc\x4c\xc4\x0f\xaf\x63\x14\x04\x1e\xef\xf9\xde\x88\xb8\x74\x04\x81\xdd\x0e\x7c\xdf\xf3\xf3\x8f\xf7\x2c\x17\x22\x72\x5b\x8e\x43\x2c\x1e\x22\x1c\xd4\x67\x81\xc9\x63\x1c\x0f\x1d\xb5\xd4\x18\x36\xf9\x80\x3a\x9d\x22\x00\x93\xa8\xb1\x57\x66\xeb\xa7\x42\xef\xe7\x28\xc0\x05\x7a\xcf\x0a\xdc\x5c\x48\x9a\x94\xba\x04\x4c\xd0\x2c\xc7\x0e\x68\x9b\xac\x90\x60\x38\x00\xdf\x70\xbd\x04\x6b\x81\xb6\x11\x35\x4e\x6d\xe8\xc1\x93\x27\xf2\xc4\x12\x9e\x77\x76\x76\xc8\x63\x54\xf9\x1f\x33\x8e\x8f\x7d\x53\xbd\x24\x2f\xf0\x75\x0d\x8e\x7e\xb7\xcd\x1e\x8b\x88\x69\xf9\x60\xd8\xdc\xc3\xb1\x03\xb4\xe0\xb7\xe8\xaa\x38\x64\x96\x1f\xe0\xe0\x51\x35\x01\x47\xcd\xe6\x47\x77\x88\x94\x4a\x1c\x9a\xb3\x21\xc4\x66\xbf\x19\xf8\x34\x08\x18\x1a\x60\xf8\x47\x31\x36\x72\x93\xe2\x91\x26\x44\xc3\x13\x4d\x14\x21\x7c\xf8\x63\xb2\x4c\x62\xb8\x00\xa9\x04\xf6\x8a\xed\x95\xe8\xe6\xe9\x4c\x34\x04\x0d\x74\xf5\x99\xf2\x9d\xb4\xd4\xc8\xd7\x40\x28\xc1\x7d\x8b\x22\x8e\x7e\x2f\x82\x46\x9d\x44\xc8\x07\x7e\x51\x42\x74\x51\x23\x22\x84\x91\x3b\x31\xf5\x34\xe2\x72\xfc\x02\x33\xe7\xfe\x8b\xe4\xf7\x29\x03\xa4\x70\xd3\xa2\xae\xed\x68\x45\xc4\x25\x08\xec\x72\x3a\xb6\x43\x4f\xae\xa9\x7f\x6d\xd3\x11\xc1\xb5\x1d\x36\x13\xe2\x0f\x5d\x42\x98\x4e\xc1\x97\x7c\x5d\xf2\x1b\x1f\xf2\x3c\x39\x8d\x92\xf4\x4b\x3c\xa2\xd5\xf4\x4a\x62\xc9\x2a\xd9\xc1\x1f\x96\x63\xb7\x85\x79\x38\x07\x5a\x88\xde\x2b\xcd\x04\xb3\xe5\x78\x2e\x8d\x40\x14\x68\xc2\xcd\x93\x16\x31\x6b\x3e\x1d\x3e\x5f\x48\xc3\x94\xbf\xce\x6b\xad\x69\x09\x4d\x67\xec\x87\x61\x39\x3f\x87\xb6\x76\xf1\xd8\x7a\x4c\x56\x9f\xca\xcc\x05\x4f\x57\x2f\x15\x1d\xc4\x3a\x7f\xf0\xee\x0c\x74\x16\x0c\xb6\xb8\x77\xf2\xb6\x71\xfe\xe9\xdd\xc1\x19\xe8\x48\xb3\x28\x55\x17\x8f\x9b\xd0\xd8\x9b\x83\x97\x07\x6f\xf7\x39\x90\xa7\xab\x97\xa5\x8e\xed\x84\xd4\xd7\x0e\xf7\x19\x3f\xc7\xb6\xa9\x98\xe1\x18\xa2\x3f\x6f\xab\x9b\x4d\xec\x90\x9c\xca\x19\x44\x48\xd2\x8a\x13\xfa\x2f\x1c\xab\x64\xcc\x43\x48\x37\x8f\x8b\x95\x19\x64\x32\xe2\x36\xa4\x04\x25\xe2\x54\x24\x8d\xb4\x58\x92\x58\x60\xae\x60\x92\xd1\xb5\x11\x0b\x20\xc0\xbf\x57\xfc\xc8\x8c\xa5\xd4\x8c\x18\x89\x9d\x33\x43\x46\x72\x01\x68\x06\x8d\xe4\x84\xbf\xb7\x58\x91\x4d\xef\x86\x1b\xec\xaf\x54\xb4\x3c\x93\xaf\x78\xba\x9e\x15\xcc\xa9\xa6\x45\xb9\xcb\xe8\x52\x62\x5c\x3b\x5d\x83\x96\x5c\x93\x1c\xca\x6e\x81\x28\x71\xd0\x37\x4c\x2f\xb3\xbb\xeb\xdd\xe4\x33\xe2\x16\x69\x50\xa6\x8b\x3c\x26\x0b\xce\xd5\x5e\x97\x86\xac\x44\x4a\x23\xfc\x6b\x34\x34\x8e\x18\x25\x35\x64\xba\xc3\x88\x18\x33\xc6\x60\xe8\x47\x2c\xde\x44\x4a\xe1\x28\x1a\xc5\xf0\x95\x19\x53\x49\xc2\xfb\x6d\x07\xe3\x49\xa9\xaa\xec\x4d\xc1\xf0\x3c\xc4\x9c\xd4\x22\x13\x92\x6c\x58\x26\x78\x52\x75\xef\x62\xb1\x8d\x78\x6d\xa6\xd8\x64\xd1\x8b\xcb\x71\x91\x68\x2b\x9d\x74\x91\x82\xe8\xd0\x11\x21\x65\x76\xfc\x20\xc7\x1a\x7b\x43\x2d\xe0\x05\x3e\x1b\x2e\x55\x0e\xdb\xf1\xaa\x78\x41\xec\xd1\xf0\x3d\xd2\x93\xae\x6a\x21\x2f\xf4\xd7\xf1\x50\x2b\x59\x61\x56\x5a\x3d\xcb\x0f\x23\xe1\x74\xd4\xbb\x58\x49\x35\xc8\x5a\x51\x39\xcc\x8a\x12\xbd\x77\x1e\xa3\xc3\xb5\x67\xb7\xf5\x24\x78\x84\x5c\xeb\x1f\x0c\xcf\xd1\x47\x98\xb3\xe8\xf6\x96\x20\x69\x4b\x90\xf0\xcc\x0c\x93\x73\x7b\x4b\x22\xdf\x50\xe9\x65\xaa\x3a\x7e\xf0\x11\xbf\xe4\x5a\xea\x23\x54\x8b\xfa\x57\x72\xea\xb3\x55\xb1\x05\xd1\xd8\xc1\xa0\x43\x8c\x1a\x7b\x2d\x08\x1d\x09\x7c\x00\x17\x1e\xde\x8d\x18\x78\x35\xcf\x6e\x6f\x15\xf7\x96\x15\x8f\xb2\x3f\x4e\xa1\xef\x3c\xf3\x61\x3e\xaf\x8d\xc4\xed\x2d\x9b\x08\x2b\x0c\x66\x09\x6a\x17\xe0\x9e\xf3\x2e\xd3\x8f\x93\x03\xd4\x3a\xe1\x8b\xe4\xdd\xdf\x45\x3e\x42\xce\x0f\x4f\x9e\xf0\x5f\x9c\x22\xac\x3d\x72\x07\xe6\x3c\x88\x4d\xac\x1c\xd0\x1b\x8b\x65\xb8\x54\x26\x0e\x63\xe8\x0d\xd2\xc6\x43\x7c\x8a\x0e\x22\x66\xcb\x4b\xab\xa5\x7d\x4d\x1c\xc6\xc8\x24\x61\x94\xe0\xc9\x89\xe3\xa3\xd6\x48\x1f\x36\x21\x63\x22\xe3\x76\x2d\xc6\x2d\xf4\x06\x72\xd8\xf8\xb4\x10\xe3\xc6\xa0\x96\xb0\xfe\x34\x23\x27\xe6\x44\x1c\x6f\xec\x2a\x0e\xa1\x48\x88\x19\x1b\x1b\x4e\x0f\x6d\x10\x01\xb5\x58\x39\x46\xed\x89\x43\x28\x94\x0c\x7e\x1a\x07\x36\x1f\x8c\xb3\x8a\x80\x65\xfa\xca\xa3\x96\xa7\x14\x09\xaa\xaf\x5f\x09\xeb\x4f\x75\xfa\x05\xa8\x3a\xe5\x0a\x54\xd5\x97\x20\xd5\x9e\xe7\x32\x24\x70\x91\x35\x44\x75\x49\xff\x62\x2e\x5a\x50\x88\x27\x38\x83\x30\xf9\x4f\x9e\x90\xe8\x3b\xe0\x1f\x6f\xe8\xb6\x6d\xb7\xbb\xe7\xd8\xd4\x0d\x4f\x69\x2b\x8c\x86\xd7\xd4\xf8\x6d\x62\xdd\x7c\x21\xe2\x14\x0f\x66\x0e\x56\x33\xc8\x4b\xc1\x80\x42\x02\x03\x85\x90\xdf\x60\x67\x71\x7b\x4b\x8c\x72\xc8\x87\x58\xf0\x15\xe7\x49\x28\x99\x10\x49\x30\x31\xf2\xaa\xae\xb7\xc9\x86\x8b\xd1\x02\xaf\xd4\x92\xcc\x9b\xd4\x4a\xdc\x15\x49\xd4\xd2\x48\xfd\xb1\x9e\xe9\xa4\x8f\x7e\x27\xc6\x90\xb1\x3e\x19\x5e\xe0\x7a\x98\xc3\x89\xbe\xf5\x92\x99\xd8\xde\x67\xa5\xc2\x88\xa5\x18\x07\xdf\x4d\x17\x8e\x36\x49\x95\x25\x89\xea\xec\x84\xfe\x4f\xea\xbd\xd1\x77\x90\x77\x7a\xe7\x55\xd7\xa7\x08\x84\x3b\x47\xd8\x44\x46\x00\x31\x35\x13\x42\x25\x56\x53\x75\x9d\x96\x3c\xcc\xe0\x25\x4b\xe2\x58\x40\x2b\x34\x32\xf4\x8e\x6a\x9c\xb3\x7a\xa6\xba\x51\xe5\x9c\x65\xc0\xc0\x59\x04\xfe\xb6\x3a\x28\xed\xb5\x81\xb8\x37\x0c\xb5\xd2\x52\xcc\x49\x88\xd9\x79\x7d\xf9\x5a\x3e\x12\xcb\x34\xc4\x04\x4b\x48\x14\xdc\x93\x0b\x02\x96\x58\x92\x7c\x20\x96\x9a\xa8\x3a\xa9\x23\x5c\x28\x1a\xdd\x2a\x44\x83\xa7\x2e\x72\xa8\x21\x51\x8d\x44\x34\xd0\xb9\x4e\xf3\x53\xcd\xf9\x14\x56\xb8\x60\xc5\x81\xed\xd4\x0a\x47\x2c\x67\x46\x74\x1b\x3b\xb4\xa6\x91\xd6\xf4\x47\xef\x18\x6c\xd6\x89\x44\x6b\xc7\x3f\xe4\x34\x43\xc6\x9a\xa1\xdb\x23\xdc\xae\xa5\x5a\x4e\x3e\x23\xd3\x42\x87\xf3\xa2\x86\xef\x7a\x64\x5b\xd8\xa5\x10\x13\x0e\xa7\x6e\xfa\x1e\x40\x95\xc9\xdb\x21\xed\x17\x35\xf5\xd9\x9c\x38\x52\xd5\x67\xc5\x4a\xba\xba\x6f\x2e\x2c\x89\xca\x25\x5b\x5d\x26\x9e\xbe\x24\xdc\xe3\x5d\x3c\xee\xc0\xe1\x8b\x30\x0b\xc0\xd3\x17\x0d\x03\xae\x92\x24\xed\xb1\x62\x93\xae\x46\x62\x15\x15\xf5\x13\x22\xe1\xeb\x3d\xe9\x79\xbe\xfd\xcd\x73\xc3\x88\xa2\x9c\xd0\x16\x9f\x4f\x5a\x53\x72\x6a\x29\xd2\x26\xb4\x9b\xbd\xc9\xbb\xc4\x19\xc3\x3f\xe2\x39\x00\xc4\x26\x98\x3c\x6f\x2e\x1e\xcb\x33\xa6\xc7\x97\x32\xba\x4f\xb5\xc4\xf3\x0e\x89\xb8\x05\x08\x33\xa7\xbe\xcb\x40\x01\xfc\xb8\x43\x26\x12\x9f\xf5\x8a\xbb\x64\x99\x49\x5d\x66\xae\xcd\xd3\xea\x14\xe7\x69\x99\xf1\x3a\x86\xf4\xd4\xe5\xcf\x7c\x9d\xe0\xb9\xf8\xf4\x2d\xe6\x5c\x80\xb8\x01\xd1\x92\xb1\x03\x5d\x10\xd2\xe8\x1e\xb0\xe9\xdd\x07\x22\x76\xcb\x73\x31\x2b\xf7\xc2\x60\xce\x79\x5a\xa4\xf9\xd8\x2d\xaf\xce\xa1\x61\xfc\x71\x3a\x2f\x00\xef\x42\x97\x02\x45\x4d\xba\x21\x7f\xc1\x36\x75\x21\xf0\x7c\x8b\x5e\xc4\xcc\xe8\x10\x61\x12\x84\x37\xc2\x37\x36\x53\x0b\xb5\x03\x29\xd7\xe5\x56\xac\x28\x37\x93\xd8\x8e\x4a\xb6\x38\x73\x03\x18\x06\x00\xa5\x21\xec\xd8\x16\x62\x01\xc2\xb7\xee\x0b\x02\x11\xbb\xcc\x05\xc1\xf8\x0b\xce\x0d\x26\xc5\x81\xbe\x03\x6b\xec\x78\x56\x7b\x2e\x50\x2a\x77\xd6\x42\x63\x23\x13\x80\xcd\x8e\x80\xcb\x63\xef\xd8\x73\x76\x40\xd4\x0f\x17\x9b\xdb\xf7\x73\xad\x54\x80\x41\x81\x51\xe9\x78\x7e\xdf\x0a\x43\xcc\x48\x38\xd7\x2a\x53\x84\x90\x25\xc7\xde\x30\xa0\x07\xee\x3d\x01\x7a\x43\xad\xeb\xf9\xc8\xa4\x00\xed\x39\x76\xeb\x6a\x41\x18\x6a\xc3\x36\x37\xa0\xa5\x3b\x4d\xf5\x88\x47\x45\x52\xcb\x46\x65\x5d\x97\xd6\x86\xcc\x55\x52\x56\xca\xca\xb8\x60\x14\x72\x6d\x49\xdc\xba\x54\x0b\x70\xfe\x85\x8d\x83\x95\xb4\x34\x00\x13\x97\x7a\x68\x34\x4a\x9e\xae\x26\x19\x92\x5e\x3c\xb6\x1e\x5f\x92\x1d\x92\x57\x57\x68\x11\xd3\xd4\x4c\x7f\xce\x1f\x6d\x9a\xfa\x20\xb6\x99\xe5\x7b\xb0\xcd\x2c\x2f\x66\x9b\x59\x79\x40\xdb\xcc\xca\x7d\xd9\x66\x56\xee\xc1\x36\xb3\xda\x68\xaf\x35\x40\x5c\xa7\x8f\x22\x78\x56\xcf\x65\xf7\xa9\xc2\xb5\xa6\x42\xaf\xde\x07\xec\x05\x88\x68\x02\x9a\xdb\xfa\xf4\xa1\x0d\x5c\x37\x66\xb4\x0a\xfd\x69\x13\xfa\xd3\x26\xf4\xa7\x4d\xe8\xbd\xda\x84\xfe\x34\x09\xfd\x69\x12\xfa\xd3\x24\xf4\x2f\x66\x12\xba\x37\xf4\xaf\xa9\x6e\x11\xca\xe6\xef\xd9\xa7\xe3\xdd\x93\x37\x8d\xc3\xfa\xde\xf9\xc9\xe9\x11\x98\x06\x32\xb5\x3f\x18\xf7\x9b\x9e\xb3\x67\xfb\xad\x49\x87\x72\x4a\x27\xba\x78\x3c\x84\xdd\x9c\x5e\x17\xcd\x12\xf9\x1b\xdf\x0b\x82\xe9\x81\x5d\xeb\xc0\x20\xa6\xa7\x06\x6b\xdf\xb6\xfa\x9e\x3b\x61\xaf\xab\x43\x1b\x69\xd0\x78\x65\x80\x27\xfb\x7a\xf6\xe7\xd0\xf2\x67\xe8\xeb\x8d\x06\x10\xeb\xea\xf8\x9d\x85\xd6\x84\x8d\xa6\x0e\x6b\xac\xc3\x0a\x2d\x5f\x87\x74\xee\xdb\x96\xdb\x9d\x65\x14\xbe\x69\xd0\x44\x6d\x1d\xe2\xc7\xf1\x0c\xc0\xea\x1a\xb0\x8f\x63\x80\xb3\x74\x87\x3a\xd3\x69\x7d\xff\xa8\xfe\x56\x44\x09\x78\x77\x44\x56\x49\x65\xab\xcc\xd7\x85\x2e\x0d\xcf\xa0\xd2\xa1\xc5\xe6\xd6\x58\xd7\x28\xa2\xdf\x34\xa3\x51\xf0\xa6\xe5\x27\xdf\xd8\x68\x8e\xcb\x80\x52\xe0\xd8\x2d\x9a\x2f\x17\x49\xa5\x50\x0a\xbd\x0f\x03\xc6\xf0\x56\x40\xf3\x05\xb3\x40\xc5\x38\x91\x8f\xb2\xf7\x05\x03\x7e\x89\x41\x59\x17\xe1\x69\x65\x62\xdb\xb2\x9c\xd6\xd0\xb1\x42\x5a\xf7\xa9\xc5\x76\xca\x7a\x4f\x63\x1f\xf3\x81\xfd\x8d\x16\x21\xee\xde\x39\x48\x20\xd5\x75\x90\x16\xfc\x3d\x5e\x6e\x40\x44\xf5\x88\x0d\x32\x2b\x21\x8d\x10\x83\x91\x1d\xb6\x7a\xba\xd1\x2d\x21\x2d\x2b\xa0\x24\x07\x41\x70\x73\x35\xf3\xee\x62\x83\x3c\xc5\x88\x7f\xfc\x9f\x55\xf2\x7c\x5b\xab\xd3\xc6\x69\x11\xad\x55\x2e\xc5\xeb\x61\x04\x8c\x3f\xfd\x10\x3d\x68\x25\x88\x00\x26\x42\x14\x82\x56\xd7\x28\x1c\x5a\xbe\x2c\x6a\xda\x2e\x20\xcf\xee\x90\xca\x16\x79\xca\xf9\x4c\x33\x50\xe0\x60\x2b\xa5\x6a\x14\xb3\xa7\xdc\x72\x21\xb4\xdc\x3c\xc0\x28\x90\x15\x62\xbe\x21\x4f\x49\xb5\x40\x9e\xe2\xdb\x81\x37\x8a\x56\x28\x92\x6a\x21\x72\xc1\x8d\xe8\x86\x7c\x2a\x45\x7b\xa7\xd3\x22\x46\xa8\x75\xbd\xc3\xa3\x71\xac\x72\xbe\x5a\x21\x2b\xa4\x52\x16\x08\x71\x38\x71\x40\x5b\x08\x48\xc4\x40\x4a\x40\xe1\xdd\x51\x72\xeb\x77\x92\x55\x71\xd2\x05\xd3\x58\x5c\x27\x6d\xd3\xa6\xb1\xb8\x9e\xd9\xe0\x9a\xe3\x94\x61\x71\xcd\x4b\x48\x7b\x81\x64\x33\x6a\x5e\x4a\x5c\x60\x8b\xeb\xeb\x89\x86\xca\xbc\xde\x34\x26\xca\xa2\x89\x02\x37\x4f\x46\x08\x72\x3f\x57\x48\x31\x0e\x96\x3d\x8c\x5e\x03\xbf\xb3\xc2\x9e\x4a\x11\x8b\x81\x3a\x09\x79\x4a\xf6\x84\xd0\x00\x37\xfc\x81\x15\xf6\x08\xd3\xf4\x70\xf5\xc6\x22\xff\x15\x17\x9c\x18\x9b\xe0\x0e\x4a\xf1\x8f\xab\x69\x57\xca\xac\xbd\xa8\xd5\x45\xb6\x19\x69\x80\xe2\x4c\x64\x4d\x63\xa2\x2b\xf2\xf5\xdc\xc8\x97\x26\xc5\x9a\x6e\xed\x13\xcb\xa8\x66\x18\x49\x04\x91\x45\x22\x79\x6d\xd8\x8e\xd5\x98\x86\x89\x4d\x41\x1e\x6a\x82\x1c\x79\xb7\x00\xe8\xe4\x0d\x14\x0a\xd0\x89\xfc\x94\x82\x3b\x66\x2f\x81\xb0\x32\xec\xa6\xe7\xb0\x8c\x99\x64\xff\x12\x4b\xd1\x58\x4d\x4e\xcc\xd8\xba\xd1\x4b\x18\xb9\x34\x5a\x63\xfd\xd3\x38\x95\x07\xaa\x25\x14\xe2\xba\x61\x01\x03\xbb\xb3\x43\x96\x5b\x37\x4c\xcf\x66\x90\xe0\x69\x0c\x5a\x37\x54\x66\xcf\xec\x17\x9c\xa4\x46\x84\xf8\x0c\x47\x9b\x31\x03\x93\xdc\x00\x66\x90\x69\x42\x38\xb5\x39\x83\x79\x11\x71\x05\xdc\x01\x33\x9e\x06\xd4\x65\x9b\x60\xcf\xad\x87\xa1\x6f\x37\x87\x21\x0d\x90\x61\x34\x4b\x8f\xb9\x1b\xa2\xd0\x10\xfa\xcd\x1c\x5c\x53\x37\xcc\x6c\x24\xc5\x56\x66\xd6\xc3\xbe\x7c\x21\xaf\xcc\x6b\x90\x47\x83\x9c\x96\x0e\xc4\xc8\xad\x19\xfa\x96\x1b\x74\x3c\xbf\x5f\x63\x8b\x9e\xe5\x06\x6c\x1e\xe4\x99\x1e\xd6\xba\x21\xcb\x24\x57\x24\xf0\x7b\xcc\x7e\x17\x0c\xeb\x9c\x76\x4d\x1a\x1d\xa1\xb0\xd1\x6c\xc6\x0a\x73\x59\x54\x70\xe1\x99\x6d\x52\x51\x9e\xd1\xa4\xe2\x4c\x12\x20\xc9\xa6\xc2\xe0\xa6\x59\x47\xb7\x05\xa3\xfb\xee\xf4\xe0\xec\xe0\xed\x79\xfd\xfc\xe8\xe4\x6d\xa3\x7e\x7e\x7e\x7a\xb4\xfb\xe1\x1c\xaf\xb6\x70\x48\xa7\x1a\xca\xe4\xc3\xef\x92\x25\x43\xf7\x4f\xbe\xad\x4b\x05\x21\xaf\xb6\x41\xa3\x85\xd4\x92\xa0\x31\x16\x95\x1a\x58\x94\xea\x1c\xcf\xa3\x08\xd9\x13\x85\x12\x54\x44\x75\x06\xaf\xa6\x5b\x37\x73\x21\xa1\xd9\x5b\x8c\x17\x04\x10\x4c\xb0\x6c\x98\x12\xc4\x24\xcb\x86\x89\xf4\x04\x95\x9d\x13\x91\x86\xd4\xcf\x5d\x16\x96\xee\x0a\x99\x37\x6c\x3c\x69\x88\x18\x09\xd9\x99\x67\xeb\x26\x56\x08\x5b\xde\x9e\xdd\xd7\xe5\x99\xa6\x38\x45\x6e\xcf\x32\xa3\x69\xfe\xe8\xdb\xb3\x46\xe0\xb7\x1a\x96\xdf\xca\x08\x53\xc1\xaf\x47\x86\xee\x30\xa0\x6d\xd9\x84\x4f\x39\x1d\x2c\xbf\x85\x1d\x9a\xe3\x16\x8a\xb7\x4e\xad\xd4\xe6\xd7\xa2\xf1\x64\x64\xbb\xf9\xa6\x0d\xd6\xd6\x05\x73\x24\xd4\x95\x4b\x3b\x9f\x48\xcc\xc7\xd6\x63\x65\xcb\xab\xc7\x3d\x9c\x12\x51\x18\xe1\x6d\xb0\xd6\x9d\xeb\xb2\x0b\x40\x39\xb6\x9b\x7e\xdb\x55\x2d\x97\xef\xbb\xcf\xfd\x99\xfb\x6c\x20\xba\x58\x9f\xd7\x10\xd4\xc0\x4e\xef\xf2\x66\x65\x3d\x9b\xcb\x06\x36\x9d\x93\xcb\xd6\xd5\xe0\x9d\x5a\x6d\xdb\x72\x32\x90\xd8\x9c\xc4\xea\x02\x06\xc7\x25\xad\xa0\x0f\x85\x98\x8e\x3b\x27\xd2\x1b\x8a\xfa\x13\x90\x5e\xab\x6c\x65\x23\xad\x60\x4c\x85\xf4\x1b\xdb\x9d\x97\xd2\xcf\xf8\x38\x7b\xb6\x1b\x4e\xc4\xfa\xf9\x84\xf1\x56\x40\xe6\xc4\x66\x53\x92\xf0\xaa\x61\xbb\x6d\x7a\x93\x31\xee\x93\x49\x78\xf5\x4a\xda\x65\x4c\x20\x23\x2b\xfc\x07\x37\xd1\x98\xa2\xe8\x42\x7d\xdc\xc2\x3e\xa2\xe6\x99\xd1\xbf\xe7\xf7\x2d\x4f\xc2\x99\xe5\x49\x04\x55\x53\xa2\xa4\x11\x88\xab\xd4\x73\x52\xe7\xb9\xd1\x24\x2a\x02\xe9\x1c\x59\xad\xdc\x37\x91\x86\x33\x13\x29\x19\xe3\xc5\xa4\x6f\xa5\x6c\x02\x65\xfa\x68\x06\x15\xaa\xf7\x4d\x85\xeb\xd9\x97\xdb\x44\x8c\x17\xa4\x42\xc5\x80\xc9\x95\xf1\x0c\x3a\xac\xdd\x37\x1d\x46\xb3\xd3\x21\x05\xe7\x05\x29\x51\x35\xa0\xe2\x5e\x24\x83\x10\x1b\xf7\x4d\x88\x9b\xd9\x09\x91\x8c\xf2\x82\x74\x58\x33\x81\x86\x56\xba\xc9\xcc\x5a\x75\xfd\xbe\xa9\x30\x9e\x9d\x0a\x49\x08\x2f\x48\x83\x75\x03\xa4\xd8\x85\x66\xd0\xe1\xde\xb5\xf1\x6f\xb3\xd3\x21\x0d\xe9\x05\x69\xb1\x61\x80\x1d\x8d\xb3\xc8\xb0\x79\xdf\x64\xa8\xcf\x4e\x86\x04\x7c\x17\xa4\x00\x57\xe0\xe0\x48\xbc\xd1\xb4\x02\x3b\xd8\x73\xbc\x80\xa6\x8b\xc9\xcd\xea\xbd\xef\x54\x5a\xb3\x13\x22\x1d\xed\x05\xe9\xb1\x19\x03\x7c\x32\xa0\xe9\xa1\x4f\x37\xef\x5f\x85\x68\xcf\x4e\x8d\x34\xa4\x17\xa4\xc5\x56\x0c\x6c\x86\xf5\xdf\xbd\x4b\x89\xe6\xec\x74\x48\x42\xf8\xe2\x71\x73\x11\x1a\x3c\x37\x40\x0e\xdd\x76\x86\xa8\xdc\xac\x4e\x38\x37\x01\x28\xbb\x00\x64\x4e\xfd\xb6\x5a\xd6\xf1\x69\x59\x7e\xdb\x76\x2d\x67\xc2\x94\x5d\xab\x4e\xd8\xec\x00\xb4\x3d\x03\xd8\xbc\xf8\x55\x92\xf0\xcb\x9c\x42\x6b\xd5\x09\xfb\x42\x03\x3b\x06\x6a\x5e\xdc\xaa\x49\xb8\x65\xb0\xf4\x84\xa3\x01\x03\xaf\x79\x71\x5a\x33\x71\x0a\xfb\x43\xc7\x39\xf5\xfa\x13\x85\xf0\xda\x54\xb8\x99\xe0\xe6\xc5\x71\x3d\x19\xc7\x09\x82\x71\xc2\xe9\x4e\x04\xc3\x45\xc6\x75\x23\x19\xbf\x8c\xc3\xb6\x69\xe6\xa9\xc2\x6d\x5e\xbc\x8c\x45\xca\xb1\x5d\x6a\xf9\x13\xc7\xf5\xde\x55\xef\xce\xec\xc7\x80\x19\x78\x2f\x78\x12\xba\x19\x87\x9c\x31\xff\xee\x5d\x01\xa7\xb3\xd3\x22\x11\xe3\x05\xa9\x60\x2c\x53\x7d\xcf\xf5\x42\x2f\xe3\x68\x78\xf3\xfe\x15\xf0\xee\xec\x74\x48\xc1\x39\x99\x12\x8b\x63\xd8\xbb\x47\x0c\x17\x59\xff\xab\xc6\xfa\xef\x5a\xe1\xd0\xcf\x3a\x4d\xbe\xff\x4d\x82\x3d\x3b\x21\x92\x51\x5e\xf0\x3c\xdf\xd0\x3b\x82\x90\x0e\x32\x88\xb0\x75\xdf\x44\xf8\x3a\x33\x11\x92\xf0\x7d\x28\x5e\xbd\xba\x27\xec\x92\xf8\x74\x71\xec\x9c\x7b\xc2\xae\xb5\x08\xf7\x88\x53\xad\x90\x61\x97\xce\x38\xf7\x7e\x66\xed\xce\xde\x79\x13\xd5\x05\x67\x0d\xd7\x38\xbd\x4e\x27\xa0\x21\xc3\xcc\xca\x38\x80\xdc\x5c\xbb\xf7\x9d\xb5\x37\x7b\xff\x93\x51\x5e\x90\x0e\x6b\x06\xd0\xb6\x7d\x4d\xfd\xae\xed\x76\x33\x48\x51\x99\x70\x4b\xc0\x86\xe7\x04\xc0\xed\x0b\x68\x73\xaa\x69\x6b\xeb\x06\x72\x6e\xd6\x5a\x1c\xf5\x49\x5c\x7c\x84\x06\xb3\x8f\x50\x12\xbe\x0b\x8e\xcf\x86\x01\x32\xb0\x9d\x9e\x37\xa4\x61\x98\xa1\x94\xac\xdd\xfb\xa5\xc1\x9f\xb3\x53\x22\x1d\xed\x05\xe9\xf1\xcc\x00\x3c\xb2\xbb\x59\x27\xa4\x9b\x6b\xf7\x7e\x71\xe0\xcf\x4e\x8b\x64\x94\x17\xa4\x03\xd7\x7e\x3d\xbf\x4d\xfd\x86\x15\xb4\x28\x74\x27\x63\x63\x35\x61\x5b\x8a\xd3\x96\x41\xab\x0b\x60\xf3\xce\xda\x2d\x1d\xb5\x36\x9d\x88\xdb\xe6\xda\x84\x0d\xa9\xc2\x6d\x9f\x2e\x8a\xdc\x73\x1d\x39\xdb\x0d\xec\x36\x3d\x19\x66\xe4\x85\x59\xdb\x98\x16\xb7\x23\x01\x6c\x5e\xd3\x88\xb2\x8e\x5a\xa6\xb0\xab\xdc\xbf\x4d\x4a\x30\x33\x5f\x27\xe1\xbb\x18\x53\xaf\x57\x74\x88\x3e\xbd\xa6\x7e\x90\x35\xb9\x9f\x4d\x3b\x34\xa7\x08\x4a\x78\x85\x91\xd5\x55\x02\xb9\xe5\x74\xd3\x10\x3b\x20\x6d\x3a\xf0\x69\xcb\x0a\x69\xfb\x51\xac\x0c\x58\x62\x44\xca\x4c\xfd\x67\xd8\x9c\x55\xcb\x99\x69\x81\x7f\xb4\xcd\x59\x7b\xad\x31\xb0\xc2\x5e\xfa\xc2\x3a\x67\xda\xa2\x4a\xa3\x01\x6e\x87\x56\x46\xd6\xa5\x67\x73\xa6\x27\xab\x36\xe6\x3c\xa8\x98\xc1\x48\x0a\x6c\x5e\x32\xe4\x29\xb8\x60\xe1\xe0\xce\x69\x94\xa8\x4f\x37\xee\x15\x76\x93\x99\xb4\x40\x61\x25\xbc\x54\x6e\x84\x7b\x1f\xfb\x1b\x4f\x5d\x19\x03\xd2\x8c\xf5\xca\x22\x2c\xf0\x14\x1e\x07\xc6\xc8\x26\xfa\xcb\x84\xfe\x50\x59\x5b\x43\xe8\xb6\x9b\x90\xa0\xfb\xac\x7c\xcb\xc6\x2f\x13\xe1\xd8\x20\x27\x25\x83\xe0\xd0\xbc\x61\x38\x18\x8a\x26\x4c\xcf\x1a\x56\x3b\xdf\xb6\x42\x4b\xcf\x66\x60\x2b\x83\x6e\x97\xec\x10\xf6\x59\xe4\x1e\x90\x1f\xda\xda\x4f\x24\x4e\x99\xec\x70\xf7\x58\xf9\xa5\x39\xec\x74\x20\x61\xa0\x74\x14\x10\xbd\x15\xde\xc2\x12\x35\xe8\x4c\x1e\x2b\x4c\x43\x66\x6d\x6a\x8a\x9e\x83\x9b\x0c\x7a\x75\x18\xb9\x14\x54\x10\x82\x1d\xe2\x6e\x93\xe5\x65\x5b\x79\x57\x70\x87\x73\xf2\x1f\x02\xc1\x8b\x79\x57\xf2\x6d\xde\xed\x0b\xfb\xb2\x48\xec\x22\xfc\x2e\x14\xc0\x8d\x41\xf4\x36\x1a\x08\x5a\xa3\xc2\x23\x55\x06\xfb\x57\x62\x64\x3e\x0b\x2d\x3f\xcc\x6b\x01\x55\x21\x9a\xa1\x56\xe0\xc0\x6d\xe7\x23\x6e\x67\x26\x68\x09\x0e\x58\x35\xbf\x7c\x93\x6f\x2b\xec\x8a\x64\x79\xac\x3f\x17\x8c\x74\x0e\x10\x8e\x16\x88\x5b\x90\xb9\xf6\x75\xae\x28\xf2\xb1\x22\xcb\xe4\x31\x38\x97\x0b\x93\x7c\xa8\xcf\xb0\x2b\xdd\x68\xee\x5c\xf9\x46\xc4\x27\x31\x1a\xf8\x82\xbc\xc0\x14\xcb\x22\x09\x7b\xc4\x41\x9d\xbc\x20\x0d\x52\xbb\x8f\xc9\xb4\xdc\x28\x14\x01\xbf\x02\xa9\x91\x1b\xc0\x78\x5b\xa2\x3c\x9e\x15\xe5\xf1\x0f\x47\x79\x1c\x41\x59\x49\x9a\x99\x10\x57\xd5\x1e\x1c\xfd\x47\x8f\x74\xfc\x79\xc3\x91\x5e\x08\xf9\x35\x53\x1f\xa4\xd0\x2b\x4a\xa9\xf8\x88\xa7\xbf\x7f\xf2\x84\xe4\x23\xa2\x82\x17\x29\x68\xb8\xc0\x87\x28\x26\x52\xbe\xce\x84\x4b\x43\x88\x28\xf2\x42\x13\xd1\xc6\x94\x21\xb5\xa8\xf4\x52\x05\x75\x0a\xf1\xb7\x0a\x2f\xde\x2c\xfb\x9e\x98\xb1\xbe\x5a\xae\x3c\xbc\x0a\x24\x34\x62\xbb\xdf\x1f\x42\x28\x83\xc2\x84\x05\xf9\x66\xde\xea\x4d\xa8\x3e\xde\x56\x11\x28\x6e\xf2\x03\x23\x3f\xd0\xe0\xa2\x7c\x09\x39\x67\x65\x89\x71\xac\x44\x05\x4b\x44\x29\x55\xfd\x0b\x52\x0a\xa4\xf3\xbc\x3e\x0e\xfd\x4c\x6d\x73\x6b\x7e\x6d\x73\xba\x6b\xe3\x25\x6d\x10\x70\x95\x09\x7b\x56\x58\x24\x37\x45\x32\xd6\x14\xb1\x0a\xb8\x22\x5a\x61\xa9\x71\x23\x03\x92\x8f\xd5\xcb\xb1\x7c\x79\x53\x55\x25\xab\xb2\xa4\x7a\x39\xae\xc2\x94\xc0\xb0\xf7\xec\x85\x53\xae\x34\x2c\xf2\xdb\x34\x44\x12\x11\x88\xe9\x20\xb0\x1d\xcf\x05\xe9\xa4\x69\x31\x16\xd9\x21\x55\xf2\x94\x28\xb8\x55\x8b\x2c\x93\x35\xe3\x95\xa5\x9e\x2a\xd5\x06\xfb\xae\x9e\xaa\x96\xa9\x07\xc5\x6b\x1a\x38\xeb\x55\x2d\xbe\xfa\x02\xa1\xf2\x37\x15\xf2\x94\x58\x64\x45\x10\xa2\x6c\x34\x5a\x55\x55\x6f\xa2\xf8\x16\xc8\x2a\x71\x11\x14\x90\x37\x3f\x36\x41\x8d\x53\x41\x8d\x53\x41\xdd\x45\x08\x5e\x5d\xbb\x27\x82\x37\x4d\x82\x57\xd7\x62\x04\x87\xa6\xa6\x23\x78\xdf\x24\x38\xaf\x69\xe0\x9c\x48\xf0\x2a\x10\x9c\xa1\xd1\x54\x64\xad\x44\xb1\x5a\x61\x7b\x03\xa3\x65\x46\x9e\x3e\xa7\x34\xc0\x18\x9b\x30\xc6\x09\x30\xc6\x69\x30\x80\xc4\xf8\x85\x4b\xff\x52\x93\x7e\xb3\xa9\x0f\xf1\x57\xce\xbd\xfc\x4d\xa5\x48\xc6\x95\x22\xb9\xa9\x16\xc9\xb8\x5a\x54\x33\x44\x8e\x5e\xc1\x14\x88\xea\x52\x5f\xac\x32\x45\x62\x39\x83\x1e\xd7\xdb\xc1\xe5\xb2\xa1\xd6\x1f\x6d\xcd\xc1\x4f\x50\x16\x12\xb6\x0c\x7a\x16\x80\x56\x10\x8d\x00\x3a\x0c\x9a\xe5\x53\x0b\xb4\xd5\x1a\x89\xec\xc2\x04\x38\xb6\x76\x81\x56\xbd\xc4\xa3\xa3\xb3\x2a\x07\x6e\x7b\x52\x85\xb7\xd6\x5b\x59\x45\xea\xc4\xa9\x95\x6e\xca\xc2\xe3\xb9\xc1\x25\x0e\xfc\xac\x92\x1d\xad\xd0\x58\x15\x1a\xab\x42\x30\x86\xbc\x35\x89\x03\x4c\x53\x51\x02\xd9\x4f\x3e\x01\x47\xed\x44\x4a\x57\xcd\xe2\x55\xb3\x7c\xd5\xac\x00\xe2\xd2\x20\x0a\x57\xea\x13\xfa\x27\xa3\x76\xa8\x9a\x6a\x3f\x01\x91\x22\xaa\x35\x73\x50\x61\x87\x70\xee\xe5\x05\x0d\x8a\xb2\xa3\x85\x6d\xd2\xf4\xa9\x75\xb5\xad\x57\x5f\xe3\xd5\x85\x0c\xcf\xae\x74\x27\xf7\x08\xda\x68\xdd\xde\x1a\x8f\x8f\x76\x78\x0a\x2d\xa3\xb7\x3b\x3b\xa4\x52\x28\x44\x50\x6d\x39\x5e\x40\xd1\xfb\x77\x3b\xce\x03\x15\x90\x5e\xe2\x85\x24\x16\x00\xd4\x48\xa5\x56\x1c\x02\x1b\xff\x65\xf6\x82\xfd\x3b\xd6\xf6\x93\x89\xf4\x83\x15\xaa\xba\xa6\x33\xcc\x0a\x31\x7c\xdd\xc7\xda\xd7\x31\xfb\x3a\x16\xc4\x33\xb8\x41\x8b\xc7\x61\x8e\xba\x8a\x1c\xc2\xda\x79\x0a\xad\x2d\x03\xd4\xa7\xec\xff\x8b\xfa\xa4\x8b\x6c\xc4\x26\x8f\x7c\xb9\x16\x61\xa8\xca\xb6\x4e\xc0\x17\xc9\x7c\x81\xe4\x8a\x32\x4d\xdf\xbb\x96\x1f\x93\xd8\xa4\x12\x6d\xab\x9a\x54\xaa\x1a\x2d\xb5\xb6\x4d\x56\x57\xc9\xc0\xf7\x5a\x94\xb6\xd5\x11\x09\x84\x25\x21\x8a\xe5\xb8\xda\x10\x61\xb5\xec\x19\x59\x4c\x9f\x9e\xd1\xb9\x1c\x9b\x9d\xc5\xac\xb9\xba\x9d\x26\x58\x8a\x49\x22\xa6\xa8\x09\x1b\xdc\x56\x26\xca\x9b\x62\x92\xe4\x29\xea\x32\x68\xac\xe2\xaf\xc4\x0f\x63\xe3\x27\x62\xa0\xc7\x61\x29\xa9\xa3\xf1\x52\x5c\xd1\x64\x6b\x93\x4a\xb6\xd9\x1a\x06\xa1\xd7\xcf\xcb\xa5\x40\x3f\xdb\x69\xc5\xd6\x8c\xe8\xc6\x07\x16\x85\x17\x10\xaa\x2d\x63\x81\xa9\x41\x81\x29\xb5\x4b\xb1\x65\xd4\xec\x0b\x2f\x15\xc4\xb2\x0a\x90\xa2\xb0\x2b\x89\xc5\x49\xce\x7d\x6d\x65\x53\x99\x57\xb1\xa7\xcb\xf8\x2d\xb6\x9b\x52\xe0\xd8\x9e\x2a\x5f\x2e\x6d\x14\x92\x76\x56\x6b\x7f\xa9\xfd\x02\x6e\x8d\x82\x61\x7f\xde\xdd\xc2\x14\xf7\x20\xf7\x71\x04\x1b\x50\xdf\xa6\x81\xd2\xff\x83\x61\x3f\x60\x88\xc3\xeb\x52\xdf\x1a\xe4\x83\x61\x1f\xc6\x84\x8f\xc6\x14\xc7\x77\xda\x9d\x48\xec\x88\x81\xb7\x57\x0a\x3c\x3f\x54\x58\x58\x45\xd2\xd4\xee\x5e\x18\x12\x17\xd6\x25\x04\x55\xec\x07\x17\x4d\x7e\xb3\x02\x1b\x6a\x39\x07\x82\x61\x3f\x8e\x3d\x5b\xa4\x8b\x10\x9b\x74\xa5\x52\x04\xd5\x9e\xf7\x44\x24\x58\xbd\x66\x5d\x19\xf5\x6c\x87\x92\xfc\xf2\x32\x9c\x0e\x16\x30\xdb\x1b\x5b\x80\xb0\xf0\x85\x7d\x79\x51\xb9\x2c\x90\x80\x2c\xef\x60\x05\x81\x57\xe2\x46\x75\x3d\x8b\xf1\x38\xe9\xd3\x99\x0d\xd4\x6b\x2b\xa0\x47\xc1\xc1\x9f\x43\xcb\xd9\xa7\x74\x90\x7a\xef\xb3\xc9\xcf\x96\xed\x00\x47\xe1\x8d\x7d\x45\x53\x0a\xaf\xaf\x73\x9f\xff\x25\xf2\x94\x9c\xf7\x28\xb4\xc1\xf8\x0f\xa3\xab\x40\x00\x14\xe2\x75\xc8\x97\x46\xc9\xc6\x96\xbf\x30\xb2\xb4\x7a\x24\x18\x0e\x00\x65\x32\xb0\xfc\xd0\xb6\x1c\xc8\x29\x6a\xf9\x76\xe0\xb9\x01\x03\x66\xb9\x6d\x12\xfa\x56\xeb\x2a\x60\xff\xc0\xfd\x52\x9b\x60\xec\xca\xa0\xb4\x44\x30\x34\xe1\xc0\xb7\xaf\xad\x90\xe2\x6f\xcb\xb7\xfa\xe4\xfb\xd3\x3b\x8c\x88\x03\xd8\xe0\xaf\xd0\xe3\xc0\x69\x29\x52\xd2\x83\xe0\x91\xac\x24\xfe\xca\x2c\xdf\xf4\x3c\x87\x5a\xee\x1d\x69\xda\x61\xdf\x0a\xae\xb0\xbf\xfc\x77\xc7\xb1\xba\x80\x17\x01\xf5\xe4\x83\x0b\x97\x6c\xb4\xad\x75\x0b\x3e\x32\x5d\xe1\x5d\xac\xc7\x7a\x33\x22\x99\xf4\x1d\xb9\x40\x89\x65\x7f\xa3\xfe\x25\x34\x26\x99\x92\x61\x28\xbe\xe9\x84\x33\xf0\xc5\xc1\xbb\x23\x17\x70\x51\x77\x49\xce\xa3\xd4\xfc\x02\xdd\xfd\x02\xa4\xfe\x02\x04\xf8\xa2\x53\x58\x04\x88\x0a\xb4\xae\x9f\xf2\x37\x5f\x42\x9f\xd5\xb4\x3b\x10\x5e\x0a\xe0\x04\x4c\x85\x27\x8c\x33\xfe\x7f\xf6\xde\x7d\xbd\x6d\x1b\xe9\x03\xfe\xdf\x57\x81\x78\xb7\x91\x14\xd3\xb2\x0e\x96\x0f\x72\xdd\x6c\xe2\xb8\xad\x77\x93\x38\x4f\xec\x76\x9b\xd7\xf1\xeb\x42\x24\x24\xb1\xa1\x48\x95\xa4\x6c\x2b\x89\xbf\x7b\xfa\x6e\xe1\xbb\xb2\xef\xc1\xe0\x40\x80\x04\x29\xea\xe0\x24\xed\xeb\xee\xb3\xb1\x88\xc3\x60\x30\x18\x00\x83\xd3\x6f\xae\xb1\x07\x1e\x5d\x60\x7b\xfa\x77\xd8\xd1\xff\xbd\x0e\x98\x91\xb2\x02\x8a\x2a\x56\x21\xb7\xc5\x5a\xc0\x12\x02\xb5\x92\x0a\x32\x3c\x59\xfb\x43\x82\x70\xc7\x9a\x89\x9a\x8e\x90\x29\x35\xce\x03\xdc\xee\x1a\xb3\x49\xd5\xd4\x6c\xcf\xed\xf3\x67\xde\xd6\x4a\x40\xf5\x91\xaa\xea\x2c\x03\x38\x78\xd4\xc3\x59\x61\x69\x87\xde\x8c\x3c\x35\x6e\xd9\xaf\xc7\x8f\x79\x01\x8f\x04\x7f\x82\x19\x9e\x21\xd5\x0d\xcb\xd4\x5f\xc9\x22\x84\x01\x63\x04\xeb\xfe\x75\xde\xfb\xd1\xa1\x9a\xd0\x30\x77\x75\x4a\x0c\x21\x30\x5a\xf0\x0e\xfd\x86\x84\xfd\x20\x1c\x45\x08\xd3\xaf\x8b\xdf\xcf\xf0\x88\xfc\x4a\xb9\xfd\x1f\x12\x06\xbf\x5f\x56\x87\x71\x3c\xee\x6e\x6d\x11\x7b\x84\x37\x5d\x3f\x26\xa1\x0f\x1d\x1e\x7b\xf5\x20\x1c\xb0\xe0\xd6\x4e\x6b\x6b\xb7\xde\xd8\xfa\x47\x44\xec\xcd\x08\x8f\x08\xd4\xf6\x23\x09\x83\x1a\xa5\x99\xe8\x2e\xea\x91\xf8\x86\x10\x1f\xc5\x37\x81\x50\xa8\x38\x40\x0e\x89\x49\x38\x82\xc3\x61\xd0\xb5\x69\x4a\xcb\xe4\x50\xc0\x20\x87\xe1\xe7\x88\x8c\x7a\x24\x3c\xed\xa3\x2b\x16\xe3\xfa\x36\x41\xdb\xf5\x46\xbd\x01\xdf\x36\x8e\xc9\x20\x08\xa7\xe8\x25\xf6\x07\xf7\x3c\x74\xac\xb8\x07\xa1\x7f\x91\x5b\x4c\x07\x57\x5e\x6b\xf0\x10\x07\x0a\x0a\x3e\x3e\x2b\xb8\xd2\x45\x4d\xf0\x3b\xc5\xe3\x98\xa6\xa7\xa2\x68\xec\x55\x9d\xfc\x59\xe5\x4e\x8f\x38\x89\x1a\x64\xdb\xda\x42\x87\x3f\x40\x1f\x32\xa6\x84\x2e\xa0\x24\x04\xde\xd4\x94\x15\x80\xae\xc1\x95\x22\x6a\x90\x86\xcf\xf0\x34\x69\x21\xc1\xd7\xf8\xb5\x45\x17\xe2\x06\x82\xca\x80\x42\xfe\xd4\xfa\x91\xb6\xf7\x9b\x1a\x2e\xa0\xc7\xcf\xee\xb5\x39\x3d\x8c\xfc\x69\xe8\x58\x3b\x4b\xcf\xcd\x03\x12\xbf\xc6\xb1\x7b\x9d\x37\xd1\xee\x88\x49\x39\x0c\x82\x1c\xd8\xfd\x6a\x7b\x9f\x4d\xc6\xe8\xf9\xc4\xf5\xe2\x4d\xd7\x47\x23\x12\x0f\x03\x07\x85\x02\x62\x3a\x82\xdd\x21\x50\xb3\x6b\x12\xba\x7d\x97\x38\x54\x65\x7b\x04\xf9\x50\x78\x9d\xd6\x83\xb2\xf3\x0a\x8f\x19\x8e\x1e\x63\xaa\x4a\x4b\xb5\x50\xe5\x15\x1e\xd3\x86\xcd\x4a\xe5\x15\x1e\x1b\xc4\xb2\xbb\xb4\x58\x46\x78\x7c\x84\xed\x21\x39\xf2\x08\x0e\xf3\x0c\x96\x4e\x8b\xcb\x46\xa4\x7e\x41\x3c\x12\xe7\x49\x72\xb7\xb3\x9f\x4a\xfe\x13\xc9\x93\xe8\xee\x4e\x33\x95\xf6\x67\x1c\xe5\xa6\x4d\xb3\x71\x56\x40\xb7\xad\xd8\x4d\x47\x00\x48\x17\x21\x4c\x73\x22\x9b\x66\x15\xbd\x3a\x0e\x50\x14\x07\x21\x41\x1f\xc8\x74\x93\x69\xea\x18\xbb\xa1\xd9\x02\x52\x60\xa8\xd5\xc1\x0a\xbc\xfc\xdf\xa1\x0b\xe2\xc7\xd4\xec\x64\xa6\x44\x8a\x1e\x0c\x5c\xb4\xe0\xd4\x3c\xfd\x8a\x57\xa5\xca\x33\x27\x36\x30\xa0\x8c\x30\x03\x98\xaf\xdf\xf9\xd9\xd7\x21\xe2\x69\x95\x03\xb0\x06\xea\x8a\x50\x01\xe0\xbf\x26\x76\x16\x6d\xda\xb4\x6c\x9f\x27\x31\x98\x81\xf8\xf7\x9c\xa4\xba\x45\x4c\xa9\x4c\x93\x32\x2e\x20\xe5\xa5\xb2\xbc\x8e\x48\x0c\xcc\x4e\x2f\x1a\x97\x16\x4b\x4e\xad\x6c\xbe\x88\x5e\x5b\xdb\xda\x42\xcf\x1c\x87\xf7\x0c\xa8\xf7\xef\xa2\x92\xbf\xd7\xd7\xc4\x4f\xc5\x5d\x82\xcd\x55\x4f\x53\xc5\x03\x43\xca\x8b\x8a\x03\x7a\x57\xb9\x54\x52\x33\x55\x34\x25\xaf\x0f\x40\x3d\x14\x25\x34\xa6\x1a\x82\xc2\x29\xea\x67\x4c\x15\x69\xb4\xce\x28\x2d\x63\x27\x85\x68\x43\x4f\x2d\x74\x72\x53\xaa\xa7\x82\xf7\x2a\x6a\x26\xfd\x87\x4c\x73\xbb\xc8\xee\x0e\xef\x22\xd4\x4e\x29\x4a\xb8\xd7\x92\x6b\x90\x67\x82\x70\xee\x22\xb5\x69\xea\x4b\x3e\xe3\x88\x2e\x3e\xe8\x04\x1b\xdc\xf8\x0a\x0c\x3b\x78\x89\x20\x61\x3c\x05\x9c\xe8\x08\x56\x28\xac\xc7\xfd\x2e\x7a\xd6\x93\x27\x70\x3d\xed\xc9\x13\xf4\x3a\xf0\x37\x79\x77\x54\xa6\x69\x3b\x20\xa1\xcd\x86\x4f\x61\x33\xa3\x33\x02\x70\xab\x60\x2c\x1d\x9f\xa1\x68\x4c\xec\xf9\x8d\x24\x46\xad\xfe\x81\x4c\x23\x30\x91\xfa\x41\x88\x46\x74\x08\x70\x48\x8c\x5d\x2f\x32\x59\x3c\xcc\xc4\x69\xd4\x9b\xdc\xc4\x49\x59\x40\xd2\xe2\x61\x73\xae\x69\x91\xc0\x2b\x78\xae\x0d\x3d\x7f\x4e\x48\x38\x4d\x19\x32\x7c\x34\x11\x66\x0c\x95\xad\x14\xb4\x2e\x55\x93\xc1\x22\x07\x96\x1f\x83\x80\xed\x65\x3f\x11\x1d\x17\xc3\x46\xa5\x12\x00\xa7\x41\x10\x70\xc7\x73\xff\x18\x04\x6a\xc7\x84\x7d\x44\x69\x2a\x50\x81\x55\x7d\x72\x43\x53\xa9\xb6\xc2\x05\xb3\x48\x7a\x95\x4b\x54\x75\x63\x12\xf2\x35\x29\x5d\x9e\x21\x37\x02\x17\x01\x83\x09\x0e\xb1\x1f\x13\xe2\xd4\x74\x72\x95\xa1\x5b\xd1\x69\x35\x28\xad\x66\xe5\x52\x1f\x26\x21\x31\xb7\xa2\x54\xcb\x43\xd1\x5e\x19\xfd\x54\xef\x2a\x32\xbc\x2b\x3b\x45\x55\xda\x63\x26\x03\x84\x96\x65\xe8\xc1\x85\x40\x7b\x73\x6c\x0f\x3c\x13\x77\x19\x72\xfb\xf0\xde\x02\xdb\x03\xe8\x17\xba\xe0\xa4\xaa\xdc\xcb\xb5\x4d\xa4\xf1\xc1\xaa\x0f\xa8\xc9\x89\x43\x06\xd9\xee\x2a\x41\x3a\x6b\x0d\x89\xfd\x41\x74\x41\x28\x81\x76\xf5\xb1\x74\x4c\x22\xa9\xea\x6e\x6f\xd0\xa1\x5a\x4c\xca\x27\x0e\x2f\x42\x9a\x51\x6c\xa2\x34\x70\x2a\x14\xfe\x24\x3a\x56\x3d\xcc\xa8\x94\x4d\x49\x94\xe1\x8a\x72\x1f\xd1\x55\x80\x58\x8c\xbb\x11\xf2\xdc\x0f\xc4\x9b\xd2\x21\xec\x77\x79\xb3\x44\xac\xcc\x4b\xaf\x77\x92\xc1\x60\xde\xf5\x0e\x65\xa9\xfc\xea\x45\xe1\xdb\xc8\xb0\x05\x3d\x7a\xd6\x42\xe6\xaa\xee\x26\x9a\x57\x35\x5d\x94\x96\x84\xc1\x71\x4c\xee\xea\x42\x25\x73\xd1\xb4\x50\xcb\x42\xed\x4b\xd3\xfa\x82\x35\xa0\xab\xe9\x7b\xaa\x07\x94\xe1\x03\x3d\xcd\xf4\x1b\xe5\x08\x8a\xef\x24\x68\x23\x82\x71\xa3\xc1\xe4\x93\x89\xaf\x67\x2a\xe0\xdd\x85\x54\x68\x3a\xe8\x77\x8f\x4c\x2a\x65\xce\xc2\x3c\x0c\x64\x86\x10\xa5\xd6\xd9\x91\xa4\x59\x78\x7d\x3a\xb5\x4b\xc0\xba\x21\x8e\xd4\x25\x06\xed\x83\xd7\x38\x74\x83\x49\x84\x7e\x67\xae\x9d\x7f\x47\xe2\x4a\x58\xd2\x77\x5e\x3d\xfb\xed\xea\xec\xd9\x8f\xc7\x57\x27\xaf\xcf\x8f\x7f\x3a\x7e\x8b\x0e\xd1\x7e\xa3\xb1\xdb\xdc\xdf\x6f\x75\xb6\x77\xb7\x1b\xfb\xfb\xcd\x54\x57\x77\x48\x4c\x27\xa6\x89\x1f\xb9\x03\x9f\x38\x88\xce\xa6\x03\xb1\xf4\x4e\x08\x87\xe4\x24\xfa\x85\x1d\x33\x6d\xfd\x6f\xf5\x69\xb7\xf1\xf9\xa2\xb9\xb9\x7f\xf9\xde\x79\x52\xfb\xe7\xd6\x8c\xae\x87\x29\x31\xd7\x61\x43\xf4\x26\xed\x88\xcc\xd0\x5d\x60\xc7\x31\xe9\x46\x3c\x1d\x43\x89\xbd\x43\x17\xcc\xaa\x3d\x4c\x0b\x80\x19\xe6\x93\xf1\x98\x84\xa8\x17\x4c\x7c\x07\xec\x12\xc1\x91\x64\x63\xfe\x6e\xa9\x52\x28\xdc\x95\x73\xa3\x13\x9a\x46\xa8\x91\x6a\x7d\x4b\xe3\x5e\xfc\x90\xb6\x7d\xa6\x1d\xbb\x48\x98\xf8\x52\xeb\x1f\x3d\xe2\xd9\xb8\x0a\x0b\xe7\x40\x72\x6b\xae\xc2\x84\x53\xa1\x6b\x73\xd1\x7e\xf5\x98\x44\x31\xef\x23\x52\xf9\xf9\xc2\xfd\x07\xb4\xd9\xa4\xfd\x86\x7d\x7d\x87\x9a\x48\x1c\x2e\xb3\x10\xb9\x74\x30\xcf\xa1\xbc\xa2\x06\xe5\x2f\xbc\x38\xf7\x15\x94\x7f\x1e\x4d\x65\x55\xce\x1a\xb0\xe7\x43\x37\x12\xd3\x2d\x9d\x5e\x82\x20\xa2\xf3\x0b\x1d\xb7\x1c\xc4\x36\x9f\x2f\x7e\x3f\x0f\x5e\x42\xf6\x05\xb6\xf5\xe2\x80\x0b\xfb\x0b\x6c\xc6\x2d\x3e\x39\x71\x79\x89\x13\x9a\x32\x33\x12\x93\x08\x73\x4f\x92\x33\xdb\xf0\x24\xac\xa5\xeb\xaf\x4e\x5e\x5f\xfd\xfa\xec\xe5\x2f\xc7\xf9\x3b\x5a\x32\xcb\x89\xdf\x77\x7d\x37\x9e\x96\x48\x5a\x69\x57\xcc\x53\x98\xd2\x73\x79\xd2\xec\x8c\x93\xdb\xd5\x78\x8f\x2a\xd9\xa1\x0e\x33\x3a\x9b\xd7\xb5\x5e\x8a\x05\x7e\xba\x6f\x15\x5e\xb5\x34\x6c\x3f\x17\x9f\x27\x4d\x7c\x1c\x4e\x7f\x47\x37\x6e\x3c\x0c\x26\xb1\x38\x4f\x82\x0e\x18\xc5\x41\xe8\xfa\x03\xaa\xf3\x18\xde\x1e\x14\x8c\xde\xc9\x71\x0b\x65\x29\x7b\xcc\x82\xc7\xc9\x94\x4f\x89\xa7\x94\x2f\xc9\xae\xae\x88\xe8\x32\xc4\xc6\xe3\x31\xb5\x79\x79\x02\xc3\x01\xc8\x2f\xb4\x06\x20\x09\xad\xc1\x4c\xd6\x83\x16\xc9\x23\xf8\x09\x76\xde\x31\x00\x50\x37\xb4\x42\xe1\x01\x76\xa9\x85\x02\x5f\xd5\xe4\xad\xc7\x93\xf5\xc1\x99\xf0\xb2\x61\x5e\x48\xd4\x52\xf3\xfb\x08\xc7\xf6\x30\xbd\x34\xa7\xed\xeb\xfa\x49\xe8\x18\xc7\x43\x7d\xae\x7f\x41\xc8\x98\x5a\x4e\x74\xbe\x7f\x5f\xff\xfc\xfe\xa2\xfa\xb4\x7b\xf1\xbf\x17\xef\x2f\x2f\x9f\x7c\xae\x5e\xac\x57\x2e\x6b\xd5\xa7\xdd\xea\xd3\x47\xef\x9b\xb5\x8b\xff\x7d\xff\xfe\xf2\xf3\xfb\xf7\xf5\xda\x93\xa7\xef\x9b\xb5\xf7\x97\x5b\x7c\x53\x95\x9c\x44\x6f\x3c\xec\xfa\x82\xce\xff\xbe\xbf\x79\x52\xc2\x58\xd0\x78\x85\x73\x34\xba\x9c\xc4\x3a\xb7\xab\xb0\x1d\xe4\x59\x1e\x33\xaa\x2f\x4d\x0b\x75\x58\x19\x22\xa6\x69\x0b\x0c\x8f\x5a\x5d\x66\x98\x09\xff\x21\x53\xb9\xdd\xae\xac\x7a\xdd\x3e\xaa\x72\xe5\x90\xf3\xb6\xae\xbd\xe0\x61\x93\x1f\x87\xd1\xf6\xe3\x77\x06\xd5\x31\xea\x40\x5c\x2e\x65\x2e\xac\x34\xd3\x40\x86\x09\xb7\x5e\x6a\x18\xaf\x28\x0d\x94\xf7\xb8\x52\x27\x7f\x42\x25\xcd\xdc\xa9\x07\x87\x3c\x48\x53\x0c\xd5\x20\xa1\xd4\x1e\xa9\xda\x97\x8a\x64\xc6\x0a\x6f\x21\xe5\x11\x02\x63\xc9\x95\x17\x1c\xb8\xf8\x72\xed\x94\xff\x10\x53\x1f\x2e\xbc\x0b\xb0\xdc\x25\x94\xd4\x05\x23\x7e\xcf\x63\x40\xe2\xb3\x78\xea\x11\xe6\x2a\x28\xf5\x02\xf7\xbe\x50\x10\xa1\x50\x5a\xde\x99\xfb\x91\x64\x5e\xbd\xde\x17\xca\xde\x80\xc4\x0c\x5e\x61\xe5\x25\xe6\x61\xf1\x4b\x3f\x41\x47\x43\x1c\xc6\x47\x41\x00\x17\x9f\xe2\x6c\x95\xe7\xb8\xd7\xf3\xe0\xb7\xb8\xb4\xdf\xe2\xc4\xaf\x69\x1c\x1c\x05\x7e\x34\x19\xd1\x05\x35\x1b\xc5\x70\x28\xbd\xca\x42\x40\x5d\x0c\x6f\x34\x22\xeb\xa8\xd8\xa2\xe6\x78\x0b\x1d\x22\x99\xa8\x2e\xd6\x21\x5c\x4a\x61\x5a\x3e\x34\xc3\x85\x7b\x09\xc2\x09\x41\x2c\x77\xc9\x56\x43\xd8\xa2\x9f\x30\x14\x4b\x6d\x61\x7c\xf4\xc3\x60\x04\x4c\x70\x77\xb4\x6c\x66\x66\x4e\x5d\x60\x93\x9f\xdf\xc4\xbe\x71\x9d\x78\x08\x01\x5d\xf4\x09\xae\xc9\xc2\x31\xcf\x51\x30\xf1\xe3\x2e\x6a\x08\x37\x8c\xd4\xb6\x3b\x7a\x76\xf4\xf3\xf1\xd5\xeb\x5f\x5e\xa1\x43\xd4\x6a\x34\x1a\x2c\xe6\xec\xcd\xb3\xd7\x57\x67\xe7\xef\x5e\x1e\x73\x8a\xe3\x20\x72\xa9\xb8\xba\xa8\x82\x7b\x51\xe0\x4d\x62\xe6\x70\x24\x0e\xc6\x5d\x54\xd9\xa4\x39\x1b\xe3\x5b\x08\xf2\x48\x9f\x16\x02\x97\x73\xb1\x43\xfb\x0c\xff\x1a\xe1\x70\xe0\xfa\xfc\xa3\x07\x7b\xb1\x5d\x54\xf1\x03\x9f\x91\xba\x19\xba\x31\x39\x1b\x63\x9b\x74\x51\x65\x1c\x92\x8a\x60\x13\xf8\xb8\x7a\x79\x72\x76\x8e\x0e\xd1\x45\x65\xe4\xfa\xff\xa5\xf5\xab\x58\xa8\x32\xc2\xb7\xf2\xf7\x8d\x0c\x74\xfd\x9f\x89\x3b\x18\xc6\x3c\x45\xf2\x31\x94\xbf\xe2\x60\x4c\xff\x50\x5e\xe9\xdf\x7e\xe0\xc7\x74\xbc\x81\x30\xd7\x27\x49\x16\x5e\x05\x46\x8a\xf2\xaf\x04\xbe\xe4\xb9\xf9\xe7\xdb\x54\x9e\x73\x56\x06\xff\x7a\x1e\xc4\x71\x30\x4a\xe8\x88\xcc\xec\xeb\x6d\xc2\x2f\xfd\xe4\x59\xd9\x07\xcf\x79\xc9\x1b\xed\xf8\xd9\xd9\x2f\x6f\x8f\x5f\x1d\xbf\x3e\xbf\x82\x66\x3a\x79\x81\x0e\x91\xf4\xd1\x74\x35\x22\x38\x9a\x84\x60\x38\x5f\x45\x63\xec\x57\x54\x65\xc7\x13\xaa\xed\xd4\xb0\x8e\x09\x0c\xed\x55\x36\xef\x2b\x46\x27\xd5\xfa\x44\xe2\x75\xd8\x3f\x38\xed\x43\xba\x1a\xfa\x41\x5b\x1e\x80\x7b\x2e\x93\xbd\xca\xa2\x37\x50\x65\x7c\x5b\x91\x37\x37\xd5\x38\xfd\x95\x82\x8d\x47\xc4\x3b\x0f\x5e\xb9\x8e\xe3\x91\x97\xae\x4f\xaa\xc9\xad\x53\xae\xe0\xe0\x69\x8e\xdc\xc6\xf5\x68\xec\xb9\x71\xb5\x52\x61\x4f\x75\x69\x6c\x3f\x08\x47\x98\xce\x19\x70\xb7\x30\x0e\xa3\x7a\x48\x9c\x89\x4d\x92\xdb\xae\xd5\x90\x44\x13\x2f\xe6\x07\x83\x82\x57\x5a\x51\x7e\xb0\x78\xc8\x8e\x16\xa7\xba\x77\xd0\xe4\x82\x35\x67\xfd\xe2\xb2\x6e\x07\xbe\x8d\xe3\xaa\x61\xd0\x60\x65\xd4\x2c\x74\x51\xd9\xac\x58\x92\xde\xcb\xe0\x46\xd0\xbb\xd4\xaf\x74\xcf\x47\x14\xe8\xf1\x13\x4d\x0b\x5d\xe8\xbe\xae\x12\x11\xd4\xff\x08\x5c\x9f\x89\xe7\x2e\x71\xa7\xaa\x4c\xe2\x29\x67\xaa\x49\x4c\x35\xa2\xbf\xb5\x35\xc9\x69\x72\x28\xc5\x63\xf3\x45\x1b\xa5\x54\xa0\x52\x41\x1b\x88\x45\xa2\x0d\x43\x0b\x47\x35\xaa\x1f\x5d\x9a\x2a\xab\x94\xe0\xcf\x7c\xea\x91\x8b\xe8\x12\x92\x1d\x54\x78\xbd\x2b\x62\x77\x53\xd6\x4c\x58\x0a\x99\x8a\x89\x88\x8c\x2e\x4d\x3d\x6d\x52\x12\xaf\x37\x7f\x40\xb0\x14\x4e\x26\xab\xe6\x25\x5c\x0b\x99\xf8\xe2\x91\xec\x53\x3d\x92\x0e\xad\xc9\x2b\x34\xf6\x3c\x5d\x4d\x4e\xad\x54\x11\x2a\x4c\xd1\x32\x17\x5c\x75\xb7\x60\x3e\x5c\x73\x75\xa3\xb3\x28\x14\x8f\xd4\x75\x41\x7f\x62\xa3\x3d\x1d\x56\x11\x1b\xdf\xba\xa8\x01\x57\x7e\x98\xa2\xf1\x0e\x44\xc7\x08\x70\x88\xcb\xdf\xf7\x48\x59\x48\xbd\x30\xaa\x83\x48\x0a\xf3\xc7\x7f\xc8\x94\x75\x31\xda\x26\x9b\x94\x9a\x42\x41\x8a\x42\x99\x8e\xea\xc9\x44\x74\x21\x28\x5c\xa6\xdd\xd2\xce\x48\x9e\x3c\x8c\x0a\xa7\xca\x95\x00\x65\x98\x3b\x1b\x63\xc0\x1b\x08\x6c\x68\x9c\xfa\x80\xc4\xdc\xcf\xdf\xf3\xe9\x89\x53\x35\x0c\x98\xbc\x23\xc2\x2b\xfe\x14\xa1\xa4\xd3\x17\x94\x90\x72\x26\x08\xc3\xac\x7c\x82\x9f\xca\x57\x8f\x48\xe2\xa8\xaf\x5a\x71\x9d\x8a\x65\x1a\xc3\x65\x76\x59\x48\x2f\x70\xa6\x75\x3c\x1e\x13\xdf\x39\x1a\xba\x9e\x53\x4d\x73\xaa\x8d\x26\xc5\xa5\x42\x3b\x55\xac\x74\x1b\x6b\x0e\xeb\x92\x39\x9f\xf7\xbe\x9a\x78\x83\x92\xa6\x4d\x75\xe8\x28\xf0\x63\x02\xdb\xed\x51\x2c\xa0\x1a\xd8\xda\x1c\xae\xa5\xa5\xb3\x0c\x48\xfc\x3c\x98\x80\x05\x7d\xe4\xb9\xc4\x8f\xdf\xd2\x7e\xc0\xe9\xb3\x7c\x30\x54\x1c\x26\xfa\x4c\x29\x31\x8d\x48\x14\x1b\xc2\xd8\x07\xbf\xc7\x8f\x66\x2a\x10\x3a\xe4\xc4\x95\x07\x40\x1b\x1b\x6a\xae\xc4\x38\x42\x3f\xe8\x46\x51\xa2\x0d\x39\xe9\xf9\xbb\xad\x7c\x3e\x68\x8d\xee\x4c\xe3\xbe\xe0\x09\xa1\x3b\x64\xc3\x1e\x48\x35\x3d\x8d\x16\x76\x6d\x65\x14\x64\x2b\x97\xd4\x08\xc8\x02\xab\xc4\x4b\xc6\xbe\x61\x3c\xf2\xd0\x21\x22\x5e\x3d\xb8\xf1\x49\xf8\x42\x68\x9a\x50\x39\xae\xd0\xa2\xcf\xf7\x82\x5b\x68\x0f\xb0\xf1\x1a\x96\x30\xec\xb8\xe0\xb7\xb6\xd0\x49\x1f\xdd\x10\xe4\x04\x7e\x25\x46\x43\x7c\x4d\xd0\xe0\xf9\xd1\x5b\x0b\xfd\x31\x89\x62\x44\x57\x98\x0d\xab\x81\x42\x0c\x17\xec\xe2\x21\xf6\x11\x09\xc3\x20\x64\x59\x9f\x7b\xd8\xfe\xf0\x9c\x84\xe1\x14\x75\x2c\xe4\x9e\x9e\xa1\x36\xaa\x06\xa1\x3b\x80\xc7\x1f\xee\x9b\x61\xe0\x93\x9a\xb2\x27\x10\xf4\x29\xdb\x46\x2d\x82\x51\xba\x22\xc7\x5d\xe9\xf6\x9a\xb1\x9f\x97\xab\x5a\x4b\x1b\x26\xfc\x09\x21\xad\x6c\x2f\xb8\xad\xc7\xc1\x18\x6d\xa0\x1b\xd7\x77\x82\x9b\xfa\x18\x0f\xc8\x3b\x2e\xe6\x4d\x90\x63\xdd\x06\x52\xe7\xc1\x98\x6d\x26\x31\xe1\xd0\x8c\xf4\x97\x9e\xf3\x37\x53\x4e\x6a\xff\xf1\xbd\x3c\x65\xc7\x49\x3a\xf0\xb5\xe5\x82\x90\xbb\xf0\x8d\x82\x90\x2e\x97\xc0\xca\x53\x36\x89\x92\x5d\x22\x72\x4d\xfb\x23\x02\xcf\xa0\x7c\x83\xc6\x98\x8e\x41\xa6\xb1\xbd\x24\xf6\x33\xe8\xa3\x11\x76\x7d\xb8\x94\x4f\xcb\x88\x87\x04\x45\xd7\x03\x44\x98\x3e\xac\xa9\x6e\x83\x05\x15\xfe\xdf\x27\xe0\xe7\x37\x8b\xf1\xf5\xee\x4e\x9e\xb1\xe6\x2d\x6f\x8d\x3e\xce\x53\x69\xaa\x50\x15\x8b\xb3\xa7\x99\x24\xdc\x53\x39\x14\xda\x65\xef\xe9\x42\xda\xb6\x2c\x0b\x93\x36\xda\xe4\x39\xa1\x29\xf8\xbe\x24\xe3\x2f\x27\xcb\xbb\x24\x4b\x1c\x8c\x6b\x5a\xb3\xa8\x3b\x30\x85\x57\xa9\xbf\x34\xc6\xd4\x15\xdb\x22\x2b\x78\xc7\xb3\xbd\xa2\x77\x3c\xec\xa8\xd5\x42\x63\xbe\x50\x08\xfa\xa9\x5b\xf9\x41\x3f\x81\xe6\x91\x01\xe5\x98\x37\x3c\xe4\x11\x7b\x81\x8f\xaa\x74\xd2\xe5\xe7\xbc\x7c\x45\x2d\x60\x68\x44\x9a\xea\x18\x1d\xa2\x8d\x71\x0d\x7d\x4f\x57\x26\x9f\x3f\x23\x1f\x7d\x8f\x5a\x12\xac\x66\x83\x73\xc3\xab\x00\xb7\x03\x1b\xbc\x16\x51\x4d\x10\x19\xd3\x75\x4d\x33\x37\x93\x8f\x36\x51\xf3\xd2\x42\xf0\x57\xcb\x4c\x9b\xc8\x17\x37\x21\x5d\x2a\x33\x48\x53\x43\x4f\xd0\x58\x06\x37\xc4\xc3\xcf\xbe\x17\x04\x61\xd5\x95\x18\x4e\x40\x88\xc6\xa6\x0b\x74\x29\x9b\x6e\xc2\xa7\x96\xa1\x69\xcc\x80\x36\x80\x45\xf6\x43\xe3\x51\x5d\x76\xd1\xd8\x2a\xa7\xb2\xc9\x83\x28\xb3\x55\x17\x6d\x22\xb7\x51\x33\xe3\x8a\x34\x0b\x2f\x3a\xaf\xf6\xf5\xdb\xaa\xf7\xf5\xc6\x21\xe9\xbb\xb7\x6c\x4f\x8d\xdd\xdd\xa1\xdf\xe8\x10\xad\xff\x73\x5d\x5d\x18\xbf\xc2\x63\x9a\xed\x6e\x6d\xed\x15\x1e\x6b\x2f\xdb\x47\xa9\x6f\x70\xc2\x9b\xdc\xb9\xa5\x23\x0a\xb4\xf5\x10\x47\xca\x1d\x90\x0f\x64\x9a\x9a\xcc\xab\xbc\xe8\x0d\xd8\xb6\x62\xc3\xac\x1b\xc9\x77\xcc\x03\x12\x17\x66\xa7\x89\x2f\x54\x12\x97\x32\x6b\x94\xce\xaa\xad\xe7\x91\x21\xab\xe8\x56\x07\xe9\x12\x24\xcd\x90\x8c\x82\x6b\x62\xe6\x48\xbd\x03\x85\x0e\x91\x4a\x59\x23\x28\xd3\xf0\xba\x32\xa4\x2c\xb8\xa4\xcd\x59\x62\xf1\x49\x4d\xe0\xd6\xad\xe1\xdd\xbb\xdc\x6f\x4b\x93\x64\xcf\xeb\x44\xe8\x45\xe3\x12\x56\x5b\x8c\xa3\xda\x8c\xc2\xe8\xb2\xd6\x50\x16\xdf\x9a\x8c\xd0\x21\xba\xe0\x57\x8c\x17\x2c\x9e\x52\xa9\x8f\x27\xd1\x50\xa6\xa8\x47\x9e\x6b\x93\x6a\x53\x18\xd6\x5c\x50\xec\x72\x1f\x67\x8b\x75\xdd\x1c\xc6\xf8\x55\xd4\xa5\x59\xe3\x83\x2a\x30\xa7\x8b\x47\xe7\x8c\xa5\x93\xbc\xf1\xfb\xd7\x39\xcc\xc9\x1b\xe0\xcb\x72\x27\x2e\x8d\x03\x7b\x9f\xc0\xfb\x7d\x46\x82\x96\x70\x81\xaf\xb3\x7f\xa7\xf3\xcf\x29\x25\x5d\x05\xfc\x23\x1b\xb9\xe7\xde\xea\x1b\x4b\x71\xbe\xb1\xc1\xbc\xdc\xab\xeb\x5b\x1e\xc0\x04\x38\x1a\xc7\xd3\xd5\x29\x78\xfa\x80\x2d\x7b\xa8\x05\x85\x62\x7b\xa8\x94\xd9\x5f\xb2\xd0\x7e\x4a\x63\x2c\x53\xe3\x00\x99\x64\xa1\x22\xc7\xd9\x11\x1e\xcb\x67\x45\xfd\x64\x65\x32\x82\x97\x27\x3e\xb9\xe1\x6f\x4a\x60\x8d\x70\x14\x8c\xa7\xea\x50\x5b\xe7\xd3\x35\x3f\x5f\x73\xe1\x7a\x8d\x4d\x6d\x8d\x57\x78\x5c\x13\x57\x25\x69\x6d\x53\xa6\x0b\x3b\x29\x40\x9f\x60\x2c\xa7\x8b\x22\x65\x8c\x64\x53\x03\x5f\xcf\xc0\x03\x04\x76\xb1\xb9\x37\x45\x70\xcd\xce\xb5\xf9\xa3\x87\x20\x84\xab\xdd\xec\xf9\xcc\x07\x32\x55\xcf\xf8\xd9\x66\x7d\xf6\xbc\x40\x9c\xf3\xa9\x20\x89\xda\xeb\x09\x86\x10\xc4\x39\x4f\x63\x25\x06\xca\x82\x55\x31\xb0\xd2\x0f\x8c\x45\xa5\x5c\x71\x2c\x7b\xe1\x8a\x5e\x0c\x6c\xe5\xa5\xef\x57\x03\x59\xb6\x00\x2c\xe4\x0c\x5b\x28\x48\x96\x47\xd0\x12\xfe\x35\x09\x63\xe5\xec\x99\x12\x51\xeb\x2d\x0e\x84\xd3\xa7\x3b\x22\x5c\x93\x3c\x2f\x93\xce\x44\xda\x36\xe6\x88\xb6\xfd\xdd\x12\x16\xeb\x08\x8f\x4d\xf6\x4b\xe1\x8b\xa4\xaf\x00\x0d\x6b\x07\x5e\x90\x6f\xb7\x77\x16\xc4\x6f\x6d\x5e\x5d\x85\x83\x5e\xbe\xdf\xa9\xdd\xf6\xc2\xb8\xb0\xd0\x25\x0a\x28\x2f\xc8\x71\xfb\xea\xca\xc1\x05\xa8\xeb\xed\xdd\x05\x61\x72\xb7\x67\x2f\x8e\xb6\x17\x24\xdd\xb9\xba\x62\xea\x5b\xc0\xf5\x82\x70\x6b\x3b\x57\x57\x6c\x0f\xa9\x80\xf4\xfe\x62\xa4\x77\x4b\xe0\x06\xb7\x77\x3b\x02\x7d\x77\x35\x08\xbc\x1c\x78\x41\x5c\xfa\x48\x6e\x7c\xf4\x2c\x64\x2b\x4b\x93\x9e\x7a\x59\x83\xed\x97\xaf\xf3\x6b\x1d\xeb\xe8\xe9\xec\x3d\xf3\xdd\x99\xd8\x93\xbd\x1a\x1f\x54\xbb\xa8\xca\x0b\x60\xfa\x01\xf8\x96\x65\xd4\xc8\x40\x56\x92\xe4\x14\x59\xdb\x51\x8a\xd5\xaa\x5d\x1a\x8b\x96\x8f\x05\x82\x3e\x7c\x0a\xa6\x6b\x94\x56\x0f\x1d\x22\xdb\x2a\xd1\xef\x4d\x35\x47\xdd\x72\xfa\x66\xca\x2b\xeb\xd7\x53\xa7\xda\x05\xab\x53\x28\xe7\x82\x1a\x98\x99\x78\x81\x63\x52\x48\x51\x8e\x2c\x45\x24\xf5\xb9\xba\x57\x2b\xa4\x98\x8c\x82\x85\xaa\xc0\x15\xbc\x0e\xc6\xc5\x69\x1f\xf6\x26\x15\x34\xd5\xc7\x8f\x93\x24\x71\xc0\x8f\x5e\x52\x69\xe0\xc6\xd2\x6b\xfc\x7a\x16\x47\xca\x48\x54\xc4\xd2\xa2\xea\x5d\x63\xfd\x37\x67\x4b\xa0\xf0\xe9\xe0\x57\x02\xd0\x3c\xa2\xca\xb6\xd2\x5d\x85\x3c\xdf\xa4\x0e\x0e\x3f\x90\x70\xe5\x57\x85\xf2\xae\x44\xf5\x42\x77\x30\x8c\x0b\x0a\x2c\x21\x22\x02\x22\xb2\x73\x45\x54\x82\xc4\x10\x48\x84\x83\x1e\x37\x07\x17\xa5\x33\x10\x74\x96\xc3\x3f\x7a\xcb\x09\x98\xef\xae\x0d\x23\x4f\x58\xad\xe6\x7b\x6b\x25\xca\xe9\x43\x39\xc3\xc8\x5b\x74\x87\x96\x1d\x49\xe4\xe3\xdd\x37\xe1\xed\xbe\x02\xd7\x48\x9b\x87\xef\x43\x51\xe2\x4c\xcf\xe8\xaa\xb4\xbe\xcb\xf6\xaf\x84\x2a\x00\x20\xde\x96\x50\xc4\x35\x71\x2d\x16\x1d\xa2\xf5\xf7\xef\xa3\x27\xd5\x8b\x8d\xcd\xcb\xa7\xef\xdf\x3b\x1b\x35\xfa\xb9\x2e\x2e\xbc\xbe\xce\x24\x78\xf2\xfe\x7d\x1d\x12\x56\x9f\x76\x2f\xc8\xf1\x65\x92\xf1\xa9\x9e\xf5\xcd\x5c\x59\xbf\xd3\xf2\xfe\x4c\x6e\xdb\x70\xc1\xf6\x1f\xd5\x8b\xc6\xe6\x3e\xde\xec\x5f\x7e\x6a\xdf\xd5\xfe\xb9\xa5\x24\xd8\x49\x27\xd8\x51\x13\xbc\x1d\xf4\x4e\xf8\xc3\x1f\xb6\x4e\x7c\x4b\x06\xc7\xb7\xe3\xea\xfa\xff\x86\x83\xde\xfb\xf7\xd5\x75\xb4\x81\x2e\x42\x72\x62\x21\xf1\xcf\x25\xda\xa0\xfc\xd6\xfe\xb9\x5e\x53\x88\xbc\x21\xa1\xcd\x8e\x2d\xf3\x89\xbc\xa1\xf9\xd9\x3f\x66\x22\x38\x9f\x15\x6c\xe4\x85\xfe\xf3\x3a\x87\x56\x3e\x47\xd8\xc8\x52\x1e\xad\x9f\x23\x2f\x87\xd4\x30\xf2\x12\x4a\xaf\x0b\x2b\xf7\x73\xe4\xe5\x31\x34\x8c\x3c\x6c\x24\x93\x66\x88\x6b\xa3\x8f\x47\x00\x2c\x0e\xc8\xa0\x9e\x6b\x93\x1e\x6c\xd7\x34\x6e\xfb\x8d\xfe\x5e\xbf\x0f\xe8\x9f\x7e\xec\xfe\x39\x21\x70\xf1\x0b\x62\x30\xe9\x39\xbb\x10\xf3\xe7\x04\xd3\x90\x46\xa3\xdf\xe7\x69\xff\x9c\xe0\x11\x0e\x5d\x1f\x52\xee\xf6\xfb\x7d\x67\x1b\xc2\x3f\x4e\x42\x41\x96\x27\xed\x11\x77\xc0\x82\x3a\xfd\x8e\x63\x43\x90\x1b\xfd\xc9\x4b\xef\x93\x6d\x1b\x72\xf6\x3c\x6c\x7f\x60\x85\xd0\xff\x78\x90\x6f\x0f\x89\x83\xbd\x51\xe0\x3b\x3c\x79\xcf\x76\x58\x1c\x23\x40\xd3\xf2\x72\xbc\x09\xb9\x76\x03\x8f\xc4\x34\x7c\x0f\xb7\x7a\x04\xb0\x8a\x7b\x61\x70\xe3\xd3\x20\xdc\x69\x61\x06\x4e\xdb\x9b\x84\xde\xf4\x26\x08\x80\xa6\x43\x7a\x7b\x7b\xbb\xec\x56\x9e\x43\x62\x41\xb8\xd3\xdf\x27\x18\xd8\x80\xb3\xaa\x90\x4c\x22\x59\xd7\x06\x0f\x0f\xec\xc0\xc3\x4c\x58\x4e\x6b\x67\xbf\x09\x4e\x13\xec\x20\xc4\x1e\x63\x76\xb7\xdf\x69\xf0\x20\xbf\xef\x05\x37\x24\x14\xd4\x77\xb6\xf7\x3b\xc4\x11\x71\x91\xeb\x7d\x60\x39\xfa\x7b\x4c\x42\x76\xe8\x8e\xa2\x00\xd8\x76\xec\xe6\x76\x9b\x05\x4e\xb1\xaf\x37\x03\x1d\x70\x54\x49\xec\xf5\x44\x68\x92\x76\xaf\x97\x84\x0e\x02\xcf\x21\x7e\xc8\x2a\xde\xdb\xdb\xdb\x69\x24\x51\x21\x9e\x82\x94\xf6\xe9\xff\x92\x50\x42\x38\x9d\x9d\x6d\x56\x6d\x1e\x6c\x48\xfc\x61\x88\x3f\xb8\x40\xd9\xe9\xed\xee\x48\xca\x23\x3c\x20\x7e\x0c\x0a\xb4\xd7\x53\x79\x0c\x3c\xf7\x9a\xc8\x12\x3a\x9d\x9d\x5e\x4b\xd6\x2a\x08\xb1\xcf\xd5\xa6\xbf\x67\x27\x25\x07\xa1\x3d\x74\x81\xfd\xfd\xfd\x76\xcb\xb6\x45\x78\x48\x1c\x51\x40\x92\x38\x02\xcd\xa1\xe1\x64\x7f\x7f\x67\x17\xcb\x70\x82\x65\xb1\x7b\xfd\x9e\xbd\x27\x8b\x8d\x68\x7b\x0a\x89\x6e\xef\xb5\x9d\x84\x5b\x88\x12\x52\x6a\xf5\xb7\xfb\xdb\xfd\x54\x14\x31\x44\xc5\x93\xf0\xcf\x49\xe0\x46\xbc\x89\x6c\xe2\x34\x45\x54\xa2\xac\xfb\xdb\x8d\x86\xd3\x86\x70\x42\xc6\x63\xd7\xe7\xda\xd0\xdc\xde\x97\xa1\xd1\x87\x69\xd2\xd2\x3d\xd1\xfe\xee\x48\x70\xb4\xb3\x4f\xff\x27\x03\x49\x3a\x30\x70\x06\x89\xfa\x35\xc9\x3e\xef\x35\x7d\x37\x24\xbd\xd0\x65\x5d\xaf\xd7\xa2\xff\x41\xb0\x47\xb5\x38\x19\x0a\xfa\x7d\xdc\x07\xb1\xf6\x83\x90\x44\xb1\x94\x5e\xab\xb5\xd7\xe3\x39\x26\xf6\x30\x72\x31\x4b\x2d\xfa\xe4\x00\xbb\x7e\xd4\x0b\xc2\x80\x29\x32\xfd\x1f\x04\x0f\x83\x28\x4e\x88\xef\x89\x11\x88\xaa\x27\x23\xe0\xec\xb2\x56\xd4\x14\xd6\xc1\xb8\xd3\x62\xc1\xbc\xd2\x7b\x0d\xfa\x3f\x16\x22\x15\x75\x8f\x6b\x00\x04\x4d\x89\xe7\x05\x37\xa0\xab\x4e\xbf\xcf\xf4\x4b\x48\x27\xc9\x3d\x0c\x7c\x32\x75\xc8\x8d\x1c\xb9\x78\x68\x9c\xb4\xc5\xce\x7e\x0f\xc6\x29\x6a\x4c\x62\x9f\xab\x9b\xed\x74\xec\x8e\x2d\x82\x07\x50\xcd\x6d\xaa\xe3\x20\x12\xf7\x3a\x08\xa7\x5c\x7c\x9c\xa4\xec\x22\xfd\x06\xd9\xd9\x83\x9c\x1e\xbe\x26\x3e\x5c\xbe\x6d\xdc\x92\x1d\xb2\xd3\xc7\x6a\x68\xcf\x9b\x44\x43\x4e\xa3\xd1\xef\xb0\xa8\x1b\x5f\x56\x77\xd7\xee\xf3\xde\xe1\x91\x51\xe0\xdb\x43\xb7\xdf\x67\x2a\x4f\xdb\x8c\x8d\x95\x1e\x35\x52\x44\xd3\x63\xc7\xd9\x23\x3b\x32\x38\x19\xad\xa4\x30\x58\x38\x1f\x3f\x88\x1c\x6b\x20\x58\xb6\x47\x22\xd7\x3e\xee\x63\xa7\x95\xa4\xe0\x4d\xe3\xb4\xe9\xff\x94\x60\xce\xf0\x7e\x83\x90\xfd\x86\x1a\x6e\x4a\x9e\xc8\xbd\xb7\x63\x37\x65\x70\xd2\xa1\xfb\x7d\xdc\x60\x1d\x9a\x45\x28\x3d\xba\xd5\xe8\xb5\xb0\x12\x95\x74\x9c\xbd\x5d\x9b\xf4\x95\x18\xb5\x47\xef\xee\xee\xed\xed\xef\xa7\xe3\x88\x31\x2e\x26\xc4\x13\x34\x7b\x0d\x7b\xdb\x21\x32\x4e\x91\x4b\xbf\xdf\x27\xbc\xa2\x23\x22\xc6\xed\x86\x0c\x91\xfc\xb6\x5b\xb6\xd3\xe6\x02\xf4\x59\x10\xed\x6d\xac\x91\x94\xc1\x33\xe9\x56\x23\x1c\x06\x4c\x0c\x7b\x72\xb2\x1c\x11\xc7\x9d\x8c\xf4\x79\x79\x67\xc7\x76\x98\x24\x58\xac\x3a\x55\x30\xd5\x60\xe1\xc9\xa0\xda\xc3\x9d\x0e\x6b\x06\x16\x33\x9e\x84\x63\x0f\xf2\xec\xb7\x77\x1b\x4e\x2f\x89\x51\x25\xde\xb6\x7b\xed\xdd\xa6\x12\xa7\x8e\xa2\xbb\xbd\x9d\x3d\x42\x94\xc8\x31\x5d\x66\x2b\xfd\xb5\x8f\xf7\x15\x1e\xb5\x01\x73\x7b\xcf\x69\xb2\x31\x9e\x45\xb2\x21\x53\x74\xbe\xdd\x66\x67\x0f\x7a\xc4\xc8\x75\x7c\x55\xc7\x9b\xfb\xcd\xfd\x5d\x26\x15\xd7\x8f\xed\x90\xe0\x11\x37\x40\xfa\xac\xf9\x47\x6e\x14\x4f\xc3\x20\x92\x36\x08\x61\xdc\x07\xb6\x8d\x23\xd7\x17\xa1\x3d\xa0\xee\xe3\x6b\xfc\x47\xa0\x8c\x85\x0e\xc1\x0e\x8f\x98\xca\x99\x17\x8a\x0b\x3c\xc7\x83\x1b\xf3\x8d\xdb\xbe\xd3\xef\xb0\x26\x84\x69\x4e\x8c\x37\x8d\x86\x0c\x72\x42\xdc\x83\x56\xea\xed\x91\x16\xc8\x5c\x9d\xf4\x70\x87\x27\x85\x30\x5e\xe5\x7e\x7f\x5b\x06\x8b\x26\x73\xf0\x6e\xc3\x81\x82\xc6\xd8\x23\xda\x80\x49\x08\xd9\x63\xed\x0f\x51\xb2\x0b\xee\xf5\x7b\xfb\x7b\x22\x58\x13\x38\xee\x13\xc2\x1a\x8b\x46\x69\xe2\x76\x7a\xbb\x0d\x36\x1d\x8d\xf1\x18\x4f\xf1\xcd\xd0\x1d\x73\x41\xf5\x1d\x10\xd4\x98\x60\x7b\x38\x9e\xf4\xfb\x5c\x4c\xb8\xb7\xcf\x82\xc3\x09\x1b\x2c\xf7\x3a\x6d\xd0\xdf\xa4\x77\xdb\x0d\x1b\x74\x6a\xec\x4d\xa0\x89\x1c\x07\x37\x1c\x10\xee\x38\xb8\x71\x92\x09\xab\xd7\x20\xbc\x43\x24\x1a\xb9\x27\xc5\x1e\x92\x1e\xb1\x6d\x9c\x44\xed\xec\xb4\xdb\xac\xc3\x4a\xc1\x89\x7e\x12\x06\xd1\x54\x9a\x84\x74\xea\x67\x93\x7f\x18\x4c\xb1\xec\xd3\xdb\xcd\x9d\x7d\xa6\x11\x11\x76\x1c\x8f\xc8\xf4\x7b\xbd\xed\x4e\xb3\xcd\x22\xe4\x48\x84\xf7\x1a\xbb\x2d\x16\xe6\x3b\x09\xed\xfe\x36\xde\xde\x81\x22\xb5\xc1\x89\xec\xf5\x3a\xbb\x3c\x34\x1a\x12\x8f\x9b\x8a\xfd\x0e\x13\x7b\xe4\x12\xdf\x87\xee\x8e\x1b\x9d\x56\xcb\x61\x61\xde\x35\x9b\x1f\xec\x06\xfd\x1f\x84\xe9\xa3\x1a\x01\x29\x6a\xfd\x6e\x07\x77\xf8\xf8\xaf\x8f\x73\x8d\xbd\x06\x1b\x7f\xf5\x21\x2e\x09\xf6\xe5\xf8\x85\x59\x6f\xc9\xf6\xd8\xfe\x2e\x08\x4d\x1b\x08\xb7\x77\xf6\x5a\x6c\x8a\x8c\xd9\xd4\xe1\xb4\x7a\xdb\x6c\x8a\x8b\x09\x9b\x63\x1a\x72\x8e\x89\x87\x6e\x14\xb3\xb6\x72\xf6\x7a\x7d\x07\xb4\x31\x0e\x46\x38\x0e\xf8\x74\xdb\xde\x06\x29\xe9\xc3\x41\x83\x34\x1c\xc8\x9f\xd8\x4e\x84\xec\xb5\x98\xe8\x6e\x86\x04\xc7\xac\x9f\x3b\xa4\xd7\xb6\xc4\x23\x16\x39\x03\xf7\x65\x50\x34\x0a\x3e\xc8\x35\x09\x9b\x55\xf5\x81\x9b\xe9\x0a\x0b\x4b\xfa\x0d\xa6\x03\x35\x9c\xa0\x96\xb9\x39\x2e\xb6\x1b\x8c\xbb\x79\xb0\xb7\x60\xb1\x1d\x20\x0b\x56\x65\x8e\x1b\x8d\x3d\x3c\xc5\x3d\xcf\x74\x26\xae\xdc\x0a\xa9\x87\x83\x5e\xb5\x56\x57\xd2\xf3\xdb\x93\x4c\x86\x6c\x1b\xb3\x0c\x09\x70\x13\xc6\x4f\x85\x35\xbc\x65\xe0\xaa\xca\x9e\x31\x28\xa7\xc2\x07\xcc\xfe\x1b\x61\x80\x2f\xe7\xbf\x28\x8d\x5a\x3d\x0e\xdd\x51\xb5\xa6\x3f\xb0\x50\xce\x14\xaa\x23\xb8\xf6\xfb\x33\xb9\x6d\xd7\xc9\x2d\xb1\x05\x6d\xd8\x52\xa7\x71\x63\x1c\x46\xe4\xc4\x8f\xab\xa3\x8b\xe6\xa5\x85\x9a\x3b\x35\x8b\xad\x77\x07\xbd\x6a\x75\x84\x7e\xf8\x01\xed\xa1\xc7\xb4\x6d\x6a\xe8\x33\x62\x01\xdb\x10\xd0\xe8\x37\x6a\x96\x16\x22\x92\xc0\x6f\x88\x14\x1f\x35\xf4\xfd\xf7\x68\x5b\x8d\xae\x59\xe0\xf8\x60\x6b\x0b\xfd\xa3\xdf\x68\x24\xa7\x12\x92\xdd\x9d\x0c\xbb\xe1\xa0\xe7\x57\xb3\xec\x72\x22\x30\xcc\xa4\xe9\x24\xbb\x25\x19\x6a\xa2\x8e\x8c\xce\xe8\xa2\x05\xff\xb6\x29\x4d\xa0\x48\xdb\xa9\xd5\xe9\xc0\x35\xb9\x46\xcd\x40\x98\x6f\x0f\x14\x12\x46\x4f\x50\xab\xd3\x41\x5b\xa8\xd9\x68\xb0\x42\xd2\x21\xed\x54\x48\x52\x78\xb3\xd1\xf8\xce\x42\xec\xff\xa6\xf2\x71\x5e\xcd\xc2\x41\x0f\x1b\xaa\x35\xba\xd8\xbe\x14\xc4\x71\x52\x35\x5a\xa4\x89\x7a\x5e\xf5\x24\xf5\xf9\xeb\xa6\x72\xa0\x55\xcf\xc4\x43\xb2\x8d\x93\x61\x61\x18\x79\x6a\x05\xb5\x02\x35\x31\x0e\x23\xaf\xda\x6c\x35\x2c\xd4\xa1\x65\x74\x0c\x72\x54\xf6\x79\x16\x29\x46\xd6\x08\xd2\x6a\x45\x69\x75\x82\x3d\xa0\xd4\x13\x4e\xd9\xcb\xb9\x66\x43\x9a\x0b\x16\xa8\x1c\x3a\x89\x6e\x7f\x78\x88\xd6\xe3\x10\xfb\xd1\x18\x87\xc4\x8f\xd7\x15\x4d\x13\x18\xb1\xfc\x1f\x45\x5b\x99\x17\x42\xf5\x89\x19\x2b\x4a\xbb\x4a\x2c\xc8\xf8\xb4\x27\x37\x77\x58\xff\xec\x5b\xc8\x57\x3a\x3f\x7c\x8a\x5f\xcd\x5a\x86\x26\xae\x86\x16\x1a\x58\xa8\x67\x21\x9c\xdc\x89\xc5\x70\x1b\xb5\x86\x42\x74\x88\x06\xe8\x10\x3c\x1c\x71\xa7\x32\xa9\xb2\x95\xdc\x19\xda\x7c\xfb\xba\x1a\x24\x84\x1f\x55\x03\xf5\x18\x0c\x86\xf4\x5a\x0d\x05\x62\x67\xbf\x1a\xc8\x3b\xad\x8f\x82\x5a\xaa\x30\x1a\x03\x37\x3e\xd8\x58\x6c\xe0\x26\xa8\x87\x16\x0a\xea\x03\xfa\x4f\x8f\xfe\x13\x8c\xb1\xcd\xc0\x4a\x52\xbc\x25\x8c\x8b\x24\xaa\x64\x33\x6f\xab\xc0\xdf\x0b\x6b\x70\x51\xab\x50\x38\x88\x78\x6b\xa0\xa6\x00\x0d\x35\x51\x17\x99\xd9\x30\x65\x54\xdc\x1a\x51\xe1\x6f\x84\xd2\x95\x11\x6d\x87\x8d\x81\xfc\xa4\x4d\xb2\xd1\x93\x9f\xb2\x5c\xb4\xc1\x7f\x42\x59\x4b\x4f\xba\x6f\x07\x3d\x8b\xd6\xda\x2a\xf5\xf2\x2b\x21\xc5\x7c\xc9\xb2\xd7\x39\xda\xf4\xfd\x09\xf6\x17\xd9\x19\x80\x7a\x3b\x53\x4c\xb9\x1f\xd0\x21\xfd\xbf\x14\x9f\x3c\x2f\xe8\x26\xce\x67\x44\x98\x85\x3e\xe8\xb7\xe5\x44\x73\x70\xf9\x3d\x41\x1f\x2c\x21\xbc\xe4\x77\x4f\xf9\x9d\x34\x0c\x37\x06\xd8\x79\x44\x19\xc6\xf8\xd1\x86\xc2\x16\x0b\xb9\x07\xa6\xc2\x41\xaf\xd8\x38\x49\xd8\x2f\x63\x11\x55\x1b\xb4\x7b\x73\x76\x84\x63\xa3\x90\x86\xb5\x3a\x9d\x9a\xbc\xbd\xf5\xf8\xb1\x9a\x72\x20\x53\x0e\x66\xa4\xec\xc9\x94\xbd\x19\x29\x85\xd2\x8a\xf4\xe2\xfb\xfb\x43\x18\xaa\x66\xdb\x67\xc2\xdd\x9d\x9a\xfb\x00\x42\xd8\x01\x34\xae\xf1\x0e\x08\x6d\x34\xc2\xb7\xd5\x86\xc5\x7f\xbb\x7e\xb5\x49\x47\x2d\xbd\xad\xaa\x58\x76\xf5\x75\x3a\x4a\xac\xa3\x2e\xfc\xc0\xd5\xf5\xa4\x12\x1b\x66\x72\x30\x33\x2b\xaf\x33\x98\x58\x01\x72\xa3\x51\x03\xcb\xd1\x42\xeb\x0b\x11\x19\xac\x82\x48\x4f\x10\x51\x72\xab\xd5\xad\x41\x5d\x2d\xb4\x8e\x36\x10\xa6\x05\xd5\xd6\xc5\xfd\xc7\x9a\x66\xea\xc2\x94\x39\xb4\x50\x64\x21\xcf\x38\x6b\x0c\xd1\x21\xf8\x1a\xf1\x92\x59\x43\x5e\xb3\xf3\xe4\x3b\x07\x8f\xbf\x59\x10\xa9\xd3\x29\x23\x85\x5a\x76\xee\xf9\x39\xf2\x54\x1e\xf4\x81\x35\x39\x3a\x55\xe7\x1e\x6d\xe6\xf9\x39\xf2\x6a\x69\x7a\x41\x7d\x48\xe7\x8c\x88\xfe\xe3\xe9\xb3\xc7\xb2\xb3\xd7\xcf\x91\x77\x30\x8b\x8d\xc0\x30\xbf\xc1\xa9\x28\x0b\x42\x5b\xb4\x2b\x59\xbc\xf5\x06\x10\x38\xd0\x03\x7b\x10\xd8\xd3\x03\x47\xae\x2f\xde\x6f\x50\xdd\xe0\x13\x8e\x7c\x92\x31\xc2\xb7\x32\x1a\xdf\x66\xa2\xb9\xf4\xc5\x27\x03\x75\xbe\x45\x9b\x94\xac\x08\xf4\xd8\xcd\xc5\x5b\xb4\x41\x43\x6b\xb4\x78\x51\xd9\x48\x7d\xab\x1e\x82\xb2\x8d\xf0\x2d\x6b\xd4\xea\x00\x6d\xa2\x1e\x4d\x1e\x51\x55\x1c\xa0\xef\xe9\xd7\x13\xb4\xa3\x5c\xfd\xa4\xd9\x06\xa9\x6c\x3d\xb4\x89\x42\x91\xad\xa5\x24\x86\xd8\x10\x6d\xa2\x81\x88\xdd\x66\xb1\x11\xda\xa2\xda\xf8\x3d\x6a\xd4\x3b\xe8\x29\x92\xac\xa2\x2e\x38\x36\x91\x15\x62\xa9\x87\xe8\xc9\x21\xda\x61\xde\xec\x38\x88\xc5\x9a\xa8\xbb\x87\x7e\x60\xf8\x01\x94\x5a\x93\x43\x84\x0f\x53\xe8\x3b\x19\xfd\xcc\xb3\x43\x86\x5a\xa2\x79\xec\x10\x45\xc3\x87\xc2\x0e\xf9\xd9\x40\xad\x94\x1d\x62\xca\xa8\xd8\x21\x54\xac\x1b\x43\x69\x69\x44\xe0\x0a\x48\x7e\xd2\xc6\xdf\xf0\xee\xdd\x0e\xf9\x39\xf2\x2c\x5a\xeb\xbf\x8e\x1d\x42\xa5\xca\xe4\xc7\xa7\xf5\xc8\x12\x12\xfb\xf2\xf6\xc7\x62\xcc\x98\xed\x0e\x78\x88\x2b\x26\xdd\x21\xfa\x0e\xb5\x77\xe0\x59\x16\xff\xfe\x1e\xc1\x8b\xac\x36\xdb\xc8\x4b\x86\x0d\x36\x23\x0f\x6b\xc9\xf5\x30\xc6\x48\x8d\xf7\x22\xce\x96\xcc\xe3\x89\x22\xbc\x24\x6c\xd4\x82\x3e\xb8\x01\xf3\x08\xef\xcd\x1e\xea\x82\xef\x22\x8f\x96\xaa\xe4\x1f\x35\xb9\x5b\x56\x8f\x76\xee\x96\xd1\x24\x13\x83\x5c\xe4\xb5\xe8\x90\x3b\xa4\x53\x52\x6b\xbb\x41\x3b\x18\xda\x84\x5f\x5d\x34\x44\x1b\x08\x16\x88\xa3\xa6\x85\x46\xad\x64\x64\x14\x99\xf2\x63\xe8\x18\xd1\x62\xd4\x36\x24\xb5\x4d\x23\x35\xb5\x01\x20\xa8\xb6\xb0\x4d\x17\x49\x7b\x0a\xa6\xd0\x66\x46\xe0\x79\xe6\x98\x27\x33\x7a\xcc\x04\x5b\xd8\x6c\xe3\x26\xc3\xd6\x13\xf4\x63\x18\x8c\xd0\x8f\xd7\x2f\x50\xb3\x5d\x6f\xef\x5a\xe8\xe8\xec\x8c\xcd\x9b\xe8\x15\xdc\xb5\x43\x2f\xc9\x35\xf1\x50\x5b\x43\x6a\xcb\x8a\x56\x1d\x14\x41\xae\x3b\x54\xac\xa3\x26\x55\x85\x11\x8c\xe1\xf0\x66\x71\x88\xb6\xd0\x4e\xb2\x99\x04\x0d\xb0\x07\x29\x5b\x5a\x20\x6b\xe3\x4c\xf6\x2a\x0d\xdf\x44\xc3\x9a\x4e\x86\x45\xb6\x3a\x1d\x93\x83\xb3\x66\x21\x82\xf9\x57\xf2\xac\xc7\xc6\xbb\x83\x15\x5c\x81\x56\x5e\xaf\x58\xa8\x8f\xe9\xdf\x29\xbc\x97\x61\xcf\x09\x6b\xe9\xd7\x84\xda\x4b\x43\x9e\x5e\x0b\x53\x00\xd1\x11\x52\x50\xf1\x13\x12\xcc\x8d\xaf\xf8\x4a\x3b\xb6\x63\x55\xab\xb2\xcd\x14\x8b\xb9\xe1\x07\x60\xa7\x64\xd7\x55\x2d\x8e\x23\xc0\x30\xbc\x0b\x9e\x2b\xe1\xa7\xc6\xf7\x67\xb5\x17\x1f\x2a\xc9\xc4\x4b\x06\x7f\x75\x98\x44\x5e\x88\x27\x8c\xc9\x63\x41\x51\xb1\xac\x96\xb4\x0a\xd1\xa9\xbf\xd2\x75\xd3\x1e\x8e\xe8\xd2\x51\x05\xf7\x74\xa3\x6a\xdc\xb4\xd0\x75\xc3\x42\xd7\xf4\x6f\xcb\x42\xd7\x6d\xe5\x0a\x3c\x38\x30\x07\x8f\xd0\x4d\x0b\xc5\xe0\x4c\x16\x3c\x5f\x37\xd5\x9d\xeb\x2a\x1d\x8e\xc1\x87\x75\x53\xb8\xc1\xa6\x7d\x2c\x6e\xd3\x6e\x74\x2d\xfa\xd5\x06\xaa\x6e\xa3\x4d\xb4\xc3\xa2\x79\x3a\x96\xa4\x99\x24\x91\x14\x34\x52\x4a\xda\x96\x4c\x1b\xd3\x50\xca\xed\x16\x35\x21\x17\x7a\x85\xd3\x33\xbe\x1b\x4f\xea\x9f\x79\xce\x4d\x47\xf3\x03\x03\x06\x6a\x9c\x7e\x31\x15\xb3\x75\xcf\x53\xb8\xbe\x4f\x67\xc8\x2e\x8a\x61\x01\x24\x82\x9a\xfc\x79\x76\x4d\xcc\xe8\xec\xb1\x75\x8c\x9e\x20\xbf\x96\xcc\x6a\xd7\x4d\xc9\xc2\x85\x7b\xa9\x84\xb7\x94\x70\xf6\x96\x3a\x89\x6b\xd0\xe9\x17\x2c\xd7\xa7\x49\x9a\x4d\x04\x10\x40\x2d\x10\x38\xda\xa4\x6d\x9d\xe4\x68\x43\x8e\xef\x19\x4b\x6a\xae\x0d\xd4\x92\xb9\x68\x4b\x5c\x37\xb5\x89\x95\xa9\x50\x35\x46\x9b\xc8\x45\x5b\xc8\xa7\x4d\xe4\x67\xf4\x49\x40\xc0\x1a\xee\x65\xb7\x0a\x91\xac\x57\xd3\x51\x16\x1c\x0a\x6f\xcd\x70\xb7\xa9\x89\xf8\xb6\xa8\x72\x85\x50\xc2\xcb\x54\x6e\x0b\x1d\x05\xa3\xf1\x24\x26\x0c\xc8\xd7\x21\xb6\x3b\x02\x57\x8d\xa4\xdf\x77\x6d\x97\xf8\x31\xc0\xbc\x52\xc2\x3e\xa0\x6b\x30\xf7\x32\xc9\x7b\x40\x76\x8f\x1e\xdd\x02\x70\x2d\xa5\x17\xb9\x03\xdf\xed\xbb\x36\xf6\x63\xe4\xb8\x03\x37\x8e\xd0\xd8\x42\x37\x43\x12\x12\x74\x8b\xdc\x88\x03\xea\x5d\x33\xfc\xd8\x31\x0d\x71\x7d\x04\xbe\x0b\x9a\x97\x28\x08\x13\x1c\xa9\x3a\x25\xf7\x63\x10\x22\x8e\x54\x6d\xf1\xad\xf1\x17\x8c\xc9\x6a\xb3\xde\x6a\x8b\x45\x70\x84\x2e\xd6\x9b\xad\xf6\xba\x85\x1a\x97\xf5\x55\xb4\x99\x85\xc6\xc9\x0e\x40\x15\x10\x0e\xe8\x7a\x77\x8c\x9e\xa2\xdb\x7a\x1c\x1c\x73\x81\xb8\xd8\xab\x8e\x45\xf7\x4b\x47\xd4\x6a\x12\x44\x6e\x9d\xac\xd7\x6a\xcc\xc4\x15\xa6\xe4\xc4\xf3\xc0\x2b\x34\x6c\xe1\xff\x7f\xff\xaf\xc0\xc7\x16\xfe\xa6\x2c\xad\x11\x0e\xd1\x2d\x7f\x63\xda\xb0\x90\x2b\xdf\x6d\x9e\x0f\x09\x47\xdf\xe1\x64\x89\x83\x7a\x53\xa4\xb1\x81\x88\x0b\x40\x34\x43\xcc\xda\x98\x0a\x11\xbd\x77\xde\xd7\xdf\x3b\x1b\xe4\x62\x73\xe3\xf2\xbd\xb3\xc1\xa8\x55\x49\x7d\x50\xb7\x50\xb3\xde\x22\x1b\xed\x1a\x6d\x0b\x25\xbd\x48\x2a\x53\xd1\x34\xf5\x44\xaf\x2f\x18\xd8\x48\xc2\xb3\x0a\x2f\xf6\x54\x8d\xb8\x68\x5c\xa2\x0d\x2d\x25\xab\x59\x8b\xca\x50\x09\x66\xc3\xca\x86\xa8\x38\x8c\x4e\xd4\xb4\xbc\xcc\xe9\x24\x5f\xc0\x55\xf1\x1c\x37\xe0\xa3\xd0\xbe\x02\x34\xf9\x6b\xec\xe5\xdf\x83\xe7\xef\x07\x53\x37\xf9\x43\xc2\xd5\x35\x76\x47\xe4\x84\x13\x49\xdd\xe6\x9f\xe3\x71\x24\x65\x65\xe4\x7a\x9e\x1b\x11\x3b\xf0\x9d\x5c\x6e\xf6\x9b\x2d\xfd\x95\x85\xe4\x63\xe5\x0f\x3b\xe6\xe3\x17\xfa\xa7\x7c\x03\x52\x24\xac\x57\x49\xb6\x28\x25\xb0\xe5\x2b\xe3\x7f\xc1\xca\x4c\x62\xbb\xa0\x2e\x73\xbc\x60\xa5\xe5\xcf\x6c\xf7\xf6\xaa\xdb\x7d\x30\xb7\xa8\x52\xac\x96\x6f\xf2\xb3\x7b\x6a\xed\xf0\xcb\x54\x61\x12\xdb\xe6\x1a\xcc\xf1\x96\x98\xe9\x98\x3f\x29\x78\x51\xbc\xdf\xdc\x5e\x75\x1b\xe7\xbd\x11\x2b\xcd\xea\x3c\xdd\xda\x07\x1b\x65\x31\x09\x6d\xb3\x62\x87\xc1\x24\xff\x59\xf4\x7e\xb3\xb3\x6a\xf9\xe4\x21\xf3\x94\x64\xb4\xbc\x74\x7e\x0e\x26\xe1\xa2\xb2\xe9\xb0\x22\x9d\x82\x57\xee\xfb\xcd\x9d\x55\x8b\x26\x0f\x1a\xbc\x1c\x9f\xe5\x25\xf3\x02\x4f\x17\x15\xcc\x0e\x2b\xf0\x86\x90\x0f\x05\x92\xd9\x5d\xb5\x64\xfe\x98\x5b\x32\x1a\xa3\xb0\x14\x2d\x25\x9a\xff\x12\xf2\x61\xf5\x83\xe6\xf0\x4b\xb1\x7f\x36\xf1\x9d\x6c\xe3\x2e\x5f\x01\xb2\x6c\x05\x4a\x0f\x69\x81\x5a\x81\xa2\x94\xe7\x13\x12\x39\x78\x5a\x3e\x65\x19\xa2\xff\x25\x8e\x5f\x96\xac\x4c\xbb\x7a\x71\xbb\xcb\x8a\xdb\x2e\x29\xee\xf3\xe1\x24\x2c\x2b\x9b\x1f\x43\xb7\x9c\x60\x58\xc2\x32\x24\xcf\x70\x3c\x09\xcb\x11\x15\x49\x17\x1d\xb8\x76\xf9\x24\x1b\xf8\xf1\xb0\x60\xe4\xda\x5b\xf5\xc8\xd5\x9f\xbb\x29\x75\x4e\xe7\xea\x3a\xf1\x70\x51\xf1\xec\xb1\x42\xa7\x04\x17\x19\x03\xfb\xab\x96\xce\x87\xb9\xa5\xa3\x31\x5a\x5e\x38\xef\x08\x5e\xd8\x18\xd8\x67\x45\xc2\xda\xa3\xd8\x9a\x6c\x35\x56\x2d\xa0\x60\x6e\x01\x65\xb9\x9d\x63\x69\xb5\x8c\x3d\xd9\x6c\xc8\x92\x7f\x2e\xb4\x29\x5b\xcd\x55\x4b\x69\x34\xff\x12\x34\xcd\x6c\x69\x21\x2d\x63\x56\x36\x9b\xb2\xd4\x17\x45\xa6\x65\x6b\xe5\x3b\x0e\xde\xfc\x12\x4a\xf1\x5a\x5a\x40\x4b\x58\x97\xcd\x96\x2c\xf3\xbf\x85\x16\x66\x6b\xe5\x4b\xf3\xc9\xfc\x02\x4a\x33\x5b\xce\x4c\xe3\xc9\x57\x6f\x34\x44\x5f\xb0\x06\xf7\x65\x67\x8e\x57\x51\x87\xb2\xa3\x5d\x29\x53\x73\x12\xdb\xe5\x2c\xcd\x24\x61\x09\x92\x65\xed\x4c\x35\xe9\xea\xa5\x1d\xaf\x42\xda\x65\x4c\x4d\x2a\x9b\x92\x96\xe6\x24\xb6\x4b\x19\x9a\x32\x5d\x09\x82\x25\xcd\x4c\x25\xe5\xc2\x03\x58\x3b\x99\x7d\x8b\x2d\xcd\xd6\xca\x37\x9e\xfe\x9c\xbf\x35\x33\xdc\xce\xd3\x79\x16\x37\x36\x9b\xdb\xb2\xdc\x77\x85\x06\x67\x6b\xe5\xbb\x4f\xd7\xf3\x0b\x29\xcd\x6c\x69\x19\x49\x9b\x73\xc6\x7f\xa9\x03\x9b\x7b\x74\xeb\x77\xdf\x3e\xec\x60\xf5\x07\xa7\x91\x79\xf2\x51\x4c\xf2\x37\x38\x8c\xc8\x8a\x9d\x08\xe6\x6d\x2e\xd2\xd1\x42\xe7\xeb\xbe\x31\xba\x26\xb1\x0d\x15\x9c\x21\x88\xe4\x56\xe6\x82\x07\x6a\x5e\x60\x63\xaf\x00\x32\x73\x8f\x41\x4a\x51\x3a\x2c\x29\xc3\x8d\x52\x5a\x4a\x7e\x33\x7e\xe1\x33\x91\x97\xf8\xe4\x91\x6b\x9c\xe1\x97\x40\xab\x0a\xcf\x46\x71\x4c\xce\x01\x60\x60\xfd\xbb\x5b\x0b\x7d\xf7\xdb\xba\xc5\x43\x69\xc8\xe6\x68\xeb\xbb\x4d\x67\xeb\xbb\x77\x10\x1a\xf3\x74\x9b\x27\xdd\xef\x5e\x75\xbf\x3b\x43\xdf\x8d\xd7\xf9\x0b\x6d\x37\x70\xa2\x2e\xba\x58\x7f\xf6\x6a\xdd\x42\xeb\x6f\x5e\xad\x5f\x32\x32\x53\x08\x65\x06\x07\x8d\x61\xd3\x36\xfd\xc5\xa7\x5b\xfa\x53\x4e\x92\x10\xce\xa7\x1a\xfa\x9b\xcd\x11\xf4\x97\x18\xda\x19\xdd\x68\x18\x84\xf1\x8b\x84\x38\xa7\xcc\xc9\x72\x92\x9c\x18\xa7\xc3\x89\xb0\xfc\xb0\x3a\x87\xcc\xff\xc6\xfe\x04\x87\xac\x30\xd2\x0b\xc5\xef\x57\x38\xb4\x87\xf4\xc7\xb3\x71\xe8\x7a\x2c\x04\x22\xfe\x3d\xf1\x09\xfb\xeb\xc1\xf7\xb3\xc9\x60\x12\xc5\x40\x9c\x8c\x63\xf0\x93\x4d\x3f\x4e\xed\x38\xe0\x3f\x5f\x07\xd7\x32\xf8\x05\xb1\xd9\xef\xa4\x16\xaf\x54\x56\x38\x1b\x9c\x03\x5e\xbe\x5e\x3a\x2f\x9c\x97\xcd\x0b\xe6\x45\xf2\xe2\x78\x49\xeb\x97\xa9\xdb\x62\x7a\xe3\xa7\x2f\x8b\x31\xfd\x2a\x87\x74\x29\xf5\xd6\x78\x3d\x59\xa1\x7c\xc0\xb5\xe6\x47\xf1\xec\x97\x65\xac\xf7\xb9\x7a\x22\x65\x2c\x91\x91\x63\xa6\xac\x28\xd1\xe3\x24\x4e\x51\x6d\x24\x15\x5b\x8b\x7e\x23\x72\xf3\xae\x2c\xfa\x8d\xe1\x1e\xda\x37\xe5\x00\x24\x24\xb8\x00\x86\xb6\xb9\xa8\x17\x51\x4e\xf6\x4a\xb4\x90\x91\x7c\xdd\x2f\x6c\x6e\x4e\x63\x51\x20\xe3\x71\x18\x8c\xaf\xe2\xe9\x98\xe4\xfb\x31\x6d\xac\x82\xf6\x12\x75\xd4\x09\x2d\x8a\xac\x6c\x7b\x38\x8a\xc0\xe5\x75\xfe\xe5\x88\x55\xd0\x5e\xa2\xa2\x3a\xa1\x85\x81\x9e\x27\xb1\xeb\x5d\xbd\x99\x84\xe4\x2d\xa0\x0c\xe5\xab\x6d\x67\x61\xc8\x67\x28\xe2\xc1\x05\x6e\x69\x17\xb8\x20\x02\x76\xb5\xf7\x88\x36\xb1\xea\x9a\x09\x4c\x1b\x75\x1e\x70\x7d\xc2\x39\x70\x49\xc4\x65\xc2\x90\xff\xa3\xac\x47\x5c\x26\x1a\x88\x34\x89\xc5\x21\x91\x1d\xba\x63\x76\x59\x19\x52\x81\x58\x92\xe0\x3a\x01\xec\x7d\xdc\x83\xe9\xc5\x1c\x4e\xdb\x08\xfc\x1e\xa8\xf1\x76\xe0\xf7\xdd\xc1\x44\xe4\x04\x37\x08\x20\xd4\x75\xb8\x82\xb9\xce\x2e\x28\x8b\xe4\x35\x35\xeb\x4d\xe8\xc6\x5a\x36\xde\x0e\x5a\xdd\xa7\xb2\xe6\x4a\x4e\xc0\xb4\x57\xa8\x1e\xa8\x02\x4f\x24\x7a\xa4\xde\x05\x87\xd6\xa5\x44\xc1\xd5\x25\x8e\x5d\xfb\x8d\x10\x25\xf7\xbd\xc0\xa3\x6b\x59\xe1\x1f\x99\xee\x8b\xab\x24\x6b\x07\xdc\x11\xa3\x42\xb7\x88\x8a\xce\xc2\x81\x60\x5d\x49\x41\x15\x06\xdd\x55\x6b\x52\x6b\xa8\xbe\x58\xfc\x6f\xcb\x42\x57\x31\x19\x8d\x35\xaf\xca\x10\x73\x84\x3d\x0f\x9c\xe8\x57\xc5\xa3\x3d\x4b\xa5\x2a\x6a\xfb\x48\x46\xeb\xef\x03\x93\x84\xa0\xe2\xc3\x30\xb8\x81\xb7\x27\xe7\xd3\x31\x39\x0e\xc3\x20\xac\xae\x1f\x61\xdf\x0f\x62\x44\xfb\x04\xc2\x08\x0a\x45\x38\x42\x58\xca\x7d\x5d\xf8\x4a\x4e\x58\x1b\x07\x51\xe4\xf6\x3c\xa2\x14\xc0\xbc\xe4\x57\x23\xe2\xf5\x2d\x20\x26\x59\xa3\x41\x7a\xe9\x6f\x49\x9f\x84\xc4\xb7\x05\x0b\xe0\xda\x66\x88\x23\xbf\x12\xa3\x1e\x21\x3e\x02\x53\x06\x7b\x2e\x35\xff\x37\x51\x34\x19\x93\xb0\x5a\xd3\x52\xd0\x12\x88\xc3\x58\x4b\xdc\x81\xc3\x03\x12\xe1\xed\x0e\xbe\x01\xfd\x80\x81\x3c\xaf\x0b\xaf\xf7\x5a\x5c\x52\x4b\xf4\x94\x05\x77\x11\xe5\xf8\x40\xaf\xb1\xeb\x0f\x49\xe8\xc6\x51\x35\x9a\xf4\x8e\x58\xd3\x01\x5b\xf0\x5b\x54\x95\x13\x4f\x22\x0c\xe0\xd5\xa9\x48\xe6\x90\x22\xa7\x69\xce\x68\x5a\xba\xee\x09\x49\x14\x81\xef\x8f\x49\x14\x8b\x6b\x98\x3d\xc2\x1e\x62\x05\xa1\xd2\x56\x16\xa2\x6d\xb9\x8e\x36\x50\x86\x17\x10\x95\xe0\xbe\x9e\xff\x44\x41\x61\x50\x63\x57\xed\x28\x9f\x74\xff\x4d\x9f\x84\x27\x99\x44\x38\xc9\x30\xd3\x65\x83\x8c\x85\xc4\xf0\xd0\x85\xd1\xc1\x42\xea\x48\xc3\xc2\xa8\x9a\x89\x9e\xa7\x08\x97\xf3\x17\x91\xf8\x8d\x60\xe1\xb4\x2f\x61\xed\x53\xe1\x39\x0d\x94\xf0\x56\xbf\xba\x82\x9a\xc0\xe4\x96\x24\x81\xf6\xe6\x3e\x04\xff\xd5\x77\x3d\x72\x7a\x4d\xc2\x6b\x97\xdc\xa0\x37\x81\x37\x1d\x04\xfe\x5a\xb2\x2f\xc1\x9d\x46\xf2\x88\x37\x81\xeb\xc7\x51\xca\x77\xa4\x16\x57\x1d\xc3\x1f\xed\xfa\x36\x0b\x9a\xd7\xd1\x72\xfd\x96\xb9\x8c\x16\x1f\x8f\x1f\x73\x37\xc9\x53\x35\x7c\xaa\xfa\x5d\xa6\xe4\x98\x1f\xa0\x0b\x9e\x4b\xb8\x56\x9e\x9a\xdd\x29\x2b\x6e\x35\xc1\x4d\x32\x77\x88\x8c\x54\xc7\xc1\xbc\x7a\x65\x56\x2e\x26\xcb\xc5\xb8\x84\x61\x03\x1e\x3a\x44\x55\x18\x0b\xa9\xe9\xc1\x06\x47\x6d\x56\xbd\x3a\x0a\x46\xec\x4a\x32\xab\x64\xd2\x33\x39\x4f\x16\x52\x92\xc0\xfd\x66\x99\x99\xa7\x90\x37\xe6\xd3\x43\x2c\x1d\x87\x2c\x91\xaa\x76\xa0\x49\xa5\x60\xcc\x63\xd9\x44\xf9\x8a\x7e\x49\x77\xc5\xf5\x81\xae\xa3\xa2\x88\x5a\x1d\x8f\xc7\xde\x94\x53\x90\x26\x4e\x2d\x71\x1d\xa3\x5a\x17\x49\x0d\x2f\xf8\x8b\x4c\x32\xed\xa2\x4a\x08\x42\xad\x58\xfc\xb9\x07\x74\xc4\x04\x69\x04\x22\xab\x89\x42\xc0\xe4\x03\x16\x83\x78\xde\x08\x1f\xc9\xd3\x0b\xc4\x55\x93\xca\x9f\xd9\x1f\xec\x5b\x4d\x01\x72\x7b\x8d\x47\x24\x49\x24\x83\x0e\xd6\xd6\x78\x4a\x18\xfd\x39\xb1\xcf\x9f\x11\xff\x29\xfc\x10\x4a\x8e\x90\x76\x93\x9d\x07\xde\xad\x29\xfc\x7a\x78\x2a\x86\xa4\x22\x9f\x88\x66\x83\xbd\x5a\xab\x4a\xd7\xee\x9b\x63\x26\xc1\x8a\x95\x54\x41\xb4\x33\x9a\xbd\xb1\x99\x59\xd9\xd5\x71\xda\x91\x71\x52\x80\xe6\x19\x78\x66\x2f\x31\x19\xdf\x17\xeb\x1f\xa0\x97\x80\xf2\x90\x88\xf8\xd4\xc4\x08\x7c\xe9\x94\x38\x62\xfd\x26\x69\xc4\xda\xc2\x05\x11\x28\xa8\xef\x7a\x31\x09\xc1\xfd\x69\x61\x21\x49\xcb\x49\x29\x76\x95\x46\x4a\x34\x85\xb5\x78\x37\x77\x40\x14\x8d\x5d\x93\x03\x11\x42\x77\xba\x47\x23\x9e\xef\x60\xed\xae\xcc\x72\xf9\x62\x5d\xf6\xfd\xf5\xcb\x9a\x34\xaf\x04\xf0\x1a\x57\xd9\xca\x9b\xa4\x95\x78\x02\x5a\x35\x3a\xf3\x82\x86\xa9\x2d\x37\xaf\x24\x6d\x90\xe4\x9b\xb7\xc7\x67\xc7\xaf\xcf\x9f\x9d\x9f\x9c\xbe\xbe\x7a\x76\x7e\xfe\xf6\xe4\xf9\x2f\xe7\xc7\x67\x54\x96\x4c\x7c\x8a\xe0\xe6\x5d\x6a\xd7\x71\x9d\x3d\xd5\x60\x90\x8b\x4c\xc2\x0b\x10\x01\x67\x1c\xa7\xfd\xd2\x2b\x74\xb5\xfc\x21\x1e\xb3\xad\x4c\x84\x6e\x17\x2a\x9c\x3d\xf7\x61\x9a\x32\x5d\x82\xc2\x1a\x68\xcf\xda\x5d\x8d\x5b\xd0\x35\x78\xde\xcd\x5a\xf5\x60\x09\x17\x3c\xca\x24\x90\xda\xc0\xfa\x02\xae\x3c\xcb\xef\x34\x79\x81\x83\xa3\xe1\x95\x1b\x1d\xff\x39\x29\x78\x1e\xb2\xbd\xa0\x7b\xa9\x6c\x01\x4b\xed\x69\xa5\x89\x2d\xba\x01\x25\xe9\xfc\xc8\xe5\x9f\xbf\x51\xb1\xb0\x27\x30\x43\x19\x4b\xed\x75\x19\xe8\x2d\xba\x2d\x25\x49\xbd\x76\xf3\x9b\xbc\xbd\xe0\xee\x65\x9a\xfc\x52\xfb\x5e\x3a\xa9\x45\x77\xbe\xee\x65\x97\xb6\xbd\x82\x5d\xda\xf6\x72\xbb\xb4\xdb\xf7\xb8\x4b\xbb\xbd\xaa\x5d\xda\xed\x15\xec\xd2\x76\xb8\x9c\xa2\x51\x10\x14\x9c\xf0\xb7\xb7\x57\x43\x7e\x89\xda\xa6\x49\x2d\xea\x86\xee\xfe\x76\xa5\x77\x56\xb5\x2b\xbd\xb3\x82\x5d\xe9\xdd\xfb\xdf\x95\xde\xbb\xba\x02\x6b\xe3\xea\x68\x12\x5e\xe7\x9f\xda\xee\x2d\xe8\x9a\x71\x5f\x90\x7f\x11\xe4\x0f\x31\xbb\x8b\x1e\x95\x34\xc0\xaf\x5e\x8c\x5d\x9f\x84\x57\x2f\xa9\x81\x9c\x2f\x9f\x05\xfd\x12\x36\x9b\xb4\x0c\x6e\xf3\x5e\xbd\xc4\x3d\xe2\xbd\x74\xa3\x82\xba\x2c\x38\x5e\x36\x5b\x57\x57\xb0\x2d\xf5\xbc\xe0\xfa\x49\xb3\xb1\x68\x2d\xc4\x2e\xc1\x0b\x1c\xe3\x19\x67\x0f\x0b\xba\x9d\x6c\xce\x7b\xbe\xb1\x48\x19\x1d\x5e\xc6\x11\x5d\x6e\x16\x97\x01\x37\x56\xc5\x6e\xd2\xc3\x39\xca\xc3\x39\xca\xc3\x39\xca\xca\xce\x51\x5a\xda\x41\x0a\xdb\xfe\xff\xaf\x1b\x0f\x83\x49\xac\x94\x1b\xf4\xfe\x00\xb5\x8d\x84\x36\x30\x89\xa2\x43\xf4\xe9\xee\x40\xd5\x23\xe6\x85\x59\x48\x04\x9c\xd2\x0b\x3c\x06\xb7\x86\x7e\x00\x38\x15\x3a\xce\xbb\xbe\x68\xe4\x47\xa5\xba\x0e\x30\xe0\xd6\xd4\xcc\xbc\xf7\xb8\x97\xcc\xb1\x34\x68\x63\xb6\xcb\xa8\xb5\x8b\x03\x2a\x9d\xc9\x88\x6a\x0c\xf3\xc3\x89\x43\x79\x2e\xa4\x3b\xe8\xa4\x11\xd9\x2e\x62\x21\x1c\x86\x2d\x74\x88\x64\x22\xb1\x45\x27\xc6\x95\x30\xdd\x75\x68\x06\xc6\x23\x0e\x43\x9d\x47\x1a\x75\x20\x71\x0b\x45\x28\xe3\xa3\x1f\x06\x23\x60\x22\x73\xa0\xf4\x70\xd6\xf5\x70\xd6\xf5\x70\xd6\xf5\xf5\xcf\xba\x5e\xba\x3e\x59\x33\x5c\xc0\xa5\x83\xc5\x8f\xcf\x8e\xce\x4f\xdf\x52\x7b\xa3\xce\xfc\xfd\x35\xf9\x18\x4c\x33\x95\x39\x09\x32\xad\x16\xca\x9c\x04\xb5\xe6\x3e\x0a\xa2\x1c\x15\x9c\x03\xd1\x68\x0d\x4d\xf2\x2a\x24\x7d\x7e\x0c\x00\x9f\xb4\x54\x3a\x95\xc0\xb1\xcc\x55\x48\x62\x1e\x69\x3e\x30\xa2\xe4\xc4\x29\x82\x1c\x5a\xaf\x3c\xe2\xab\xe6\x16\x1f\x42\xe1\x94\x27\x92\x83\x2d\x4d\x55\xb3\xd0\x15\x35\xbf\xc0\x5a\x81\x5f\xdf\x43\x6e\xf6\x01\x03\x2e\xdf\x27\xa7\x59\x2f\xae\xb8\x65\x95\x18\x72\x57\x02\x08\x2e\x7d\x92\x47\x39\x57\xcf\xd3\xaa\x50\x23\x38\xb3\x99\x75\x98\x45\x25\x82\x0e\xa1\x6a\x65\x0e\xb4\x40\x04\x35\x98\xd5\xf8\x91\x16\x25\x60\xa1\x0b\x4a\xee\x92\x1a\x43\x36\x8e\xab\x94\xff\x5a\xad\xc6\x25\x2b\xfe\xd6\xe9\x94\x4f\xb8\x9f\x4b\x38\x37\x8a\x9e\xf9\xee\x08\xce\x3a\x7e\x74\x7d\x37\x1a\x12\x87\xf7\x23\x81\x55\x19\xc4\xd8\x7b\x09\xf2\xec\x22\x06\xe7\x76\x27\x88\xb9\x4e\x19\x55\x34\xad\x37\x2e\xd6\x5d\x50\xc5\x89\xef\xfe\x39\x21\x27\x1c\xad\x35\x39\x3b\xf2\x5c\x9f\x6c\x56\x24\xd7\x36\xb6\x87\xe4\x4d\x48\xae\x29\x09\x4d\x2f\xd5\xd3\x5e\xd0\x1a\x56\x4b\x12\x9f\xd1\x8a\x56\x3f\xa1\x71\x48\xae\xdf\xf0\x8d\x7b\x7e\x3e\x76\x27\x4e\x40\x04\xf9\x31\x8e\x87\x6f\xa1\x0d\x12\xc2\x7e\xe0\x90\x34\xd9\x11\x76\x7d\x58\x1a\xa3\x43\x44\xe3\x53\x64\x86\xd8\x77\x3c\x22\xe5\x79\xec\x3b\x69\xdb\x3a\x8f\xc9\xdc\x56\x90\xbc\x8a\x4c\xcc\xba\x0e\x7c\xb5\x94\x6a\xba\x3e\x29\x46\xce\x62\x1c\xc6\x4b\xb1\x02\x23\xed\x6c\x5e\xa0\x20\x8d\x1b\x32\x1a\xd3\x46\xcc\xef\x02\x4a\xbf\x4f\x0e\x62\x61\xb8\x44\xe8\x09\xe0\x9c\x05\x11\x61\x30\x67\xb4\xe9\x83\x3e\x22\xd8\x1e\xa2\x41\x18\x4c\xc6\x2c\xcd\xbf\xc6\x38\xc4\x23\xf4\x89\xe9\xe1\x1d\x5b\x59\x00\xc8\x16\xfb\x45\x0d\x21\x20\x20\x57\xee\x5a\xbe\x24\xe3\xed\xb3\x5b\x37\x42\x08\xb2\xca\x39\x04\xe4\x15\xf4\xd1\xed\x26\xbe\x75\xa3\x9c\x9c\xd3\xa2\x9c\x53\x53\x4e\x06\x72\x7f\x07\x95\xfa\x0f\x99\x42\x4e\xd6\x17\x60\x75\x18\xf4\x11\xd6\xea\xc8\x07\x99\x4f\x30\x92\xdd\x21\x21\x18\x07\x08\x40\x9a\xad\xb5\xcc\x11\x36\x1b\x99\xb5\xf3\x6b\x29\x83\x17\xae\xf3\x2a\x98\xf8\x71\xc5\xe2\x47\xc8\x5b\x4f\x10\x89\x3c\xd7\x8f\x37\x1d\x37\x82\x15\x11\x82\xed\xb9\x2d\x3f\xd8\x74\x5c\x67\x73\x44\x53\x6f\x46\x24\xde\x64\x43\xc8\x93\x2d\xe3\x19\x78\xa6\x00\x45\xd7\xc0\x6a\x53\x34\x47\x51\xb5\x67\x76\xec\x5e\x93\xec\x39\xb5\xf1\x88\x5a\x19\x92\xc4\xb9\xfa\x80\xc4\xe7\x49\x68\x55\x2a\x6a\x5a\xbb\xb5\xd1\x4c\xa5\x73\xa7\x9e\x8a\x8a\x53\xd7\x94\xcc\xfe\xeb\x7a\xde\x5b\x62\x13\xf7\x1a\x56\x54\x51\xce\x35\x80\xdc\xf4\x55\x9f\xdc\xc6\x62\xc1\x57\xfe\x8a\x00\x16\x42\x3a\x71\x92\x2b\x00\x4a\xe0\xec\xeb\x04\xfa\x35\x01\xc9\x85\x4a\x04\x8c\x46\xe5\x5b\x6d\x8a\xec\x10\x2c\x86\xdd\xa4\x79\x72\x64\xa7\xb7\x4b\x8e\xc0\xd2\x8d\xa7\x09\xc7\xa6\xe3\xed\x8b\x60\x24\xc4\x23\xc7\xe0\x83\x5c\x8d\x90\x59\x1e\x3f\x96\xbf\x53\x1a\x52\x10\x55\x65\xae\x13\xd2\x37\x15\x94\x22\x72\x35\x65\x40\x15\x2d\x0c\x3e\x90\x17\x38\x1a\xc2\x91\x6f\x7e\x8d\x53\x09\xab\xc2\x64\x51\xca\xb1\xc0\xe1\x65\x4a\x59\x68\x90\xac\x29\xc4\x67\xef\x35\x8d\x43\x62\x21\xda\xcc\x86\x8b\x1f\xe3\x90\xa0\x0d\x88\x94\x8d\x97\xdc\xca\x00\x81\xd3\x5e\xab\xba\x1c\xe3\x90\x80\x5b\x4a\xd1\x16\x6a\x36\x6a\x6a\x03\x84\x84\xb6\x4b\xc2\x17\xfb\xf1\x9d\x92\x45\x4f\x1d\xc5\x49\xff\x55\x5a\x65\x93\xe7\xd4\x18\xe2\xb4\x69\x55\xd1\x21\xba\xb8\x14\x94\xd2\x2b\xeb\x68\x32\x02\xbb\xee\x00\x7e\x6d\x70\xe9\x5c\xb8\x97\x16\xda\xd8\x70\x55\x51\xb0\x85\xc0\x08\x6d\xc8\x24\xe8\x07\xad\x0a\x6a\x62\x94\x61\x40\x98\x58\x86\xed\x00\xd6\x20\x0a\xe8\x63\xcd\x42\x17\x9a\x70\xe8\xb2\x73\x74\x29\x85\x47\xff\xeb\x85\x04\x7f\x48\x02\xee\x4c\x63\x1e\x19\x8d\xe3\xa9\x60\x41\x61\xa8\x2e\x45\xdd\x82\x75\x67\x03\x3d\x45\x17\x0d\x4b\x11\xf1\x25\xea\x52\x16\xe4\x67\x5a\xb1\x0b\xeb\xc3\xdc\x9a\x90\x31\xc1\x31\xab\x9b\xc5\xf4\x83\x19\x96\x99\xe4\x0a\x63\x35\x4b\xe1\xb9\x56\x1f\xe1\xb1\xa2\xa0\x94\x94\x41\x37\x69\x30\xda\x40\x95\xf1\x6d\x25\x51\x4e\x7e\x25\xce\x82\x3b\x71\x39\x1d\x8f\x71\x98\x7b\x2d\x2b\xcb\x7e\xa6\x4b\x45\xbf\xf8\x6e\x2c\x7b\x94\x22\xd4\x47\x42\xa8\x33\x9b\x9d\x36\x75\xe3\x92\x2e\x09\xe1\x33\xa5\xf0\xec\xe0\xe8\x22\x11\xbf\x69\xef\x14\x98\x3b\x48\xab\xab\x92\xbb\x80\x07\x96\xca\xdc\x2e\xb2\x86\xb5\x5a\x66\x46\xcd\xdc\x44\xcc\x91\x30\x5d\x43\x8a\x43\x89\xc2\x0b\x70\x22\x51\x6a\xe6\x2f\x9a\xf8\xe9\x70\xfc\x28\x59\x9f\xd4\x0d\x46\xe8\x3c\x77\xd8\xd8\xe4\xd7\x2a\x7b\xe9\xae\x65\xb8\x75\xc7\x8c\xc1\x24\x05\x7c\xab\x09\xa6\xa9\x04\xd3\x74\x02\x0f\x4f\x83\x49\xac\xa4\x60\x01\xda\xd5\xbe\xa1\xeb\x39\x21\xac\x5d\x45\x22\x11\xa4\x8d\x80\x84\x4b\xf4\x24\x26\xa3\x52\x2b\x2e\xf3\x75\x29\x97\x5f\x3c\xf3\x9d\x23\x5a\xca\xf3\xe9\xf9\x74\x4c\xd8\xca\x4b\x14\x5b\x74\x07\x4b\x3f\x95\x32\x6d\x26\x1c\x68\xb7\x11\x55\xae\xcb\xb6\x5e\x72\xf6\x80\x63\x0c\xcb\x36\xf6\x1a\x2e\x26\x61\x55\x06\x59\xc2\x6c\x36\x50\x55\xc7\xed\xdb\x6e\x42\xa6\x7e\xab\x35\x9e\x1a\x33\x55\x63\xb8\x4a\x27\xb1\x10\xa0\xa6\x80\x6a\xfd\x8a\xbd\x6e\x89\x76\x30\x1d\x51\x5d\xac\xdf\x88\x9b\x86\xbf\x52\xda\xcf\xa7\x2f\xf8\x22\x80\x3d\x2e\x94\x25\x8f\xf1\xd4\x0b\xb0\x93\xd4\x36\x99\x21\xf2\x3a\xf1\x1c\x57\x30\xea\xb8\x6e\x7b\x81\x2f\x6f\x53\xaa\xad\xa5\xde\x3a\xa4\x85\x8b\x95\x73\x22\x06\xe8\x0e\x5d\x94\xea\x15\x53\x16\x9a\xea\x0a\x4c\xef\xbb\x28\xad\xff\xd9\x26\xee\x1a\xc2\x14\x23\x05\x15\x0d\x4d\x2f\x82\x98\xb2\x5e\x38\x32\xf1\x34\xd5\x60\xcc\xf6\x34\xc7\x59\x5b\xdc\x61\x49\xd0\x21\xba\x0e\x5c\x47\x31\x03\xa9\x4a\xcf\x27\x5e\x37\xfa\x15\x7b\xae\x23\x04\xcc\x0a\xad\xa9\x3a\x9b\x14\xb6\x44\xc3\xe9\x95\x91\x9a\x91\xb8\x54\x5a\xf0\xe6\x55\xb5\x56\xcc\x32\x8b\xac\x1a\x8b\x4d\xd2\x83\x45\xa9\xde\x60\x9e\xf3\xb2\x45\x35\xb3\x2b\xe4\x04\x71\xc5\xe2\xa5\xd7\xd5\x9b\xc5\x4b\x4b\x55\xbb\x5d\x5c\xf6\x1a\x83\x61\x1c\x4c\xdd\x47\x66\xd3\x0f\xfa\xa4\xde\x43\x4d\x44\x72\x97\x3f\x25\xf3\x8a\xcc\x56\xfc\xbc\x95\x68\x92\x20\x7d\x29\x9d\xce\x8b\x62\x7e\xd4\xa6\x9a\xec\xd4\xac\x4e\xa2\xd9\x99\x5b\x5f\x5a\xde\xcb\xc4\xae\xb0\x0d\x4c\xb4\x73\xe7\x75\x27\x48\xe6\xdb\x76\xdd\x09\xe2\x82\x49\xbf\x9d\xac\x8d\x93\x02\x3c\x7e\x58\x1a\x2d\x31\xcb\xce\x7b\x8f\xfc\x40\x5b\xec\x46\x71\x30\x7a\x11\xc4\x5f\x84\x09\x27\x88\xb5\xd2\x9d\x00\xe4\xc3\x9f\x0e\xe8\x16\x3b\xbc\x62\xa1\x0b\x9a\x54\xdf\x76\x12\x5e\x13\xa5\x57\xa4\xce\x34\xd5\x09\xe2\xcd\x0a\xda\x40\xae\xda\x20\x61\x17\xb5\x93\x29\xcd\x4a\x84\x6f\xa5\xe4\x60\x69\xb3\x3a\x57\x72\xf6\xac\x26\x33\x3b\xdb\xb7\x22\xea\xd6\x42\xf6\x54\x7c\x50\xd6\x7d\x87\xdc\x76\x91\x6b\x21\x3e\xb1\x8a\x38\xfe\x99\xb0\x92\xd8\x31\xc9\xc4\x0a\x1d\xa6\xae\x4f\x23\x54\xc1\xa4\x00\x6a\x86\xe5\xf4\x62\xb3\xb2\x36\x0c\x49\x46\xe6\xbc\xf9\x64\x1a\x96\x24\x2d\x6d\x28\xca\x0e\xaf\x51\xc5\x4a\xda\x2d\xaa\x30\xc7\x54\xb2\x87\x45\xfc\x63\xd6\x84\x0c\x9b\x34\x67\x70\xc3\x00\x7b\x5e\xde\x4e\x88\x31\x2d\xdf\x5e\xb2\x90\x4f\x88\x73\xe4\xb9\x63\xe3\x54\xcd\xfa\xf1\x76\xee\x68\xc0\x4f\x21\x79\xb2\x3a\x9c\x30\xe6\xdb\xe7\xdb\x26\xfb\x3c\xf0\x7d\x62\xc7\xaf\x27\x9e\x17\x29\x09\xd5\x60\x7d\xeb\x84\x56\x23\xdb\x1d\xca\xbc\x49\x59\xd1\x60\xb2\x78\x49\x8b\xbe\x4a\xe9\xbb\x9e\xd7\x45\x15\x3f\xf0\x49\x25\x91\x5d\xbe\x7e\x81\x8c\xb4\x94\xee\xf8\x0d\x8e\x87\x5d\xd9\xd8\xe8\x29\xaa\x4c\x42\xaf\xfa\x0f\x11\x05\x43\x87\x38\x70\xda\x40\x95\x5a\x85\x3b\xcd\xce\x3e\x7e\x61\x7f\xd7\xe4\x98\x32\x4e\x8f\x1f\x54\x0b\xba\x88\x9d\x36\xa7\x0c\x53\xad\xb9\xbb\xda\xd7\xbd\x74\xed\xf2\xf7\x30\x67\xdb\x18\x89\xe6\x51\x43\x83\x9f\x67\x71\x37\x7b\xe2\x74\x4b\x7f\xf9\x93\xdb\x65\xff\xeb\xc6\x43\x39\x49\xcf\xee\xb5\x5a\xf2\xaa\x68\x43\x83\xb9\xd1\x36\x99\x1b\xac\x4b\x75\xca\xae\xd4\x3b\x86\x95\x7a\xa4\x6f\xa4\x2a\x69\x53\x31\x6a\x26\x93\x99\x23\xb2\x65\xe2\x8c\x9b\xf1\xcf\xc9\xc0\xf5\x95\x5c\x7a\x84\x31\xcb\x0b\x71\x2a\x64\xc8\x25\xe2\x8c\x19\x8f\x71\xe4\xfa\x03\x53\x36\x16\x33\xeb\xb4\xa0\x93\x77\x5c\x10\xc0\x8d\x8f\xc3\xfc\x6b\x5b\x3c\xbf\x85\x2e\x2a\x4c\xf2\x15\x0b\x55\xa2\xf4\x1e\x37\xaa\x64\x64\x46\x03\x75\x91\x68\x21\xa2\xba\x5a\x20\xab\x8c\x16\x74\xe2\x54\x2e\xf5\xed\xe9\x2b\x71\x82\x9d\x58\x95\x9a\xc2\xc8\xe3\x5e\x5a\x2d\x66\x74\x26\x61\xda\xf4\xa0\x9d\x19\xf0\xa4\xda\x2e\xff\x97\x9d\xc6\xf3\x6e\xd6\xd7\xb1\x32\x71\xab\xbb\xc6\x54\xa8\x5d\x94\xaf\x77\x0e\x97\x71\x37\xab\x81\xa9\xae\x00\x2d\xd6\xcd\x76\x0a\x6d\xdb\x03\x1a\xa7\x9b\x56\x4a\x35\x49\x3f\x0c\x46\x5d\xf4\x09\xc5\x5d\xd4\x50\x8d\x06\x2a\x6b\x1e\xde\xd4\xc3\xd9\xe0\xc3\x0e\xfb\xd1\x06\xca\xd3\x52\xed\xb4\x9b\x8f\x6a\xd9\xc3\xf6\x9c\x2c\x70\x28\x6d\xce\x04\x51\x8a\x09\x9a\x4c\x6a\xc9\xbd\x97\x90\xf4\x5b\xb5\x94\x01\x1a\x22\xb0\x1b\x68\x54\x3d\x56\x8c\x45\xc4\x6f\x71\x0a\x75\xd3\xf3\xb1\x9c\x51\x4c\xc6\xfc\x16\x43\xa1\xa1\x4d\xad\xd5\x74\xfe\x34\xfd\x0b\x48\x75\x99\x4d\x26\x5c\x23\x92\x6b\xb8\x6a\x9b\x4a\x7f\x60\x4c\x0d\x7e\x8f\xc6\x81\x87\xe3\x20\xfc\x6d\xf1\x7b\x1d\x0e\xcc\x54\x09\x31\xf2\x9a\x39\x1b\x03\x1b\x82\xb2\x92\xbc\x89\xbf\xad\xcd\xe6\xe4\xdd\x7d\x72\x32\x95\xaf\xf3\x6b\x5a\x2b\xb2\xff\x44\xb7\x57\xe7\x59\xde\x3a\x9f\x10\x5d\x49\xa8\x02\xab\xc6\x35\x0b\x4d\xf5\xc0\x77\xd5\xb8\xa6\x5c\x9a\x90\x7a\x96\x2e\x8a\x17\x04\xb4\xf5\xc4\xe9\xcc\xea\x6a\xa4\x5d\x37\xdb\xce\x42\xc1\x12\xeb\x59\x23\x72\xb7\x96\x2f\xec\x7b\x92\x75\x43\x3b\xd5\xd4\xb8\xe1\x56\xb3\x1c\x86\x55\x6e\xaa\xb1\x29\x69\x48\xfc\xf4\xd9\x69\x76\xb3\x4e\x74\x95\xd4\x4c\x65\xea\x8f\x1e\x3f\x53\x4b\x25\xad\x47\x63\xcf\x8d\xab\x5b\x17\xd6\xfb\xe8\x72\x63\x6b\xe0\x8e\xd2\x67\x58\xfe\x64\x94\xed\x78\xe2\x90\x15\x87\x11\xf9\xd1\x0b\x70\x0c\xc9\x8a\x1b\x35\xb7\x52\xbc\x99\x0d\x87\xc5\x52\x64\xc6\xf3\x62\xad\xb9\xd3\x1b\x72\x85\x25\x26\x4d\x01\xa7\x70\xa8\x02\xae\x9e\xb5\x03\x5a\x99\xa4\x96\x3a\xa9\xcb\xa8\x76\x19\x65\xcd\x2e\xf4\x74\x4e\x53\xad\xd2\xcd\x61\x7d\xcd\x2c\xdd\xbb\x79\x96\xaa\xb3\x4d\xdd\x3c\xeb\x16\x6c\xa4\x9d\xb2\x36\xec\x8e\xc1\x86\xcd\x37\x47\x77\x4c\x5b\x6e\x4a\xd9\x60\xb6\xb4\xe6\x31\x87\x5a\x73\xd8\x43\x2d\xb3\x41\x94\xbb\xd5\xc7\xab\x2a\x7f\x89\x83\xd4\xc7\x8f\x51\xf5\x91\xc2\xcb\xe3\xc7\x5a\x71\x3f\xa0\x06\x80\x56\x2c\xf2\x38\xba\x5a\x53\x26\x44\x8b\x97\x5b\xab\x19\x76\x15\xf9\x59\xf6\xac\x95\x4b\xde\x6e\x6c\x3a\x7b\x81\x16\xcf\xd2\xb7\xf9\xf1\x43\x76\x73\xb5\x6b\xe8\x3a\x89\xb6\xec\xd6\xe9\x67\xde\x96\xe8\xee\x8c\x2d\xd1\xdd\x52\xe8\x23\xbb\xc9\xa6\x7b\xfe\x81\xe9\xee\xac\x03\xd3\xdd\xec\x81\x69\x1c\x8c\x95\xe8\x38\x18\x6b\xbb\x35\xa4\xaf\x56\x84\x7e\xaa\xd1\x37\xae\xc3\xd4\x96\xc7\xc3\xb7\x26\x26\xe2\x0e\x86\x2a\x05\x16\x50\xae\x13\xee\xce\xda\xf7\x86\x46\x48\x60\x57\x96\x43\x60\x31\xec\x91\x6b\xfd\xdb\xb4\x89\xae\x2d\x91\x86\x38\x3a\x73\xfd\x81\x47\xa0\x53\x24\x86\x26\xef\x8c\x87\x87\x87\xa8\xa9\x0e\x22\x25\x21\x5f\x4a\x1e\xd0\xa4\xf0\x5e\x92\x62\xe4\xfe\xce\x21\x57\x96\xc7\x8f\xd9\x8f\x3a\xf6\xbc\xe0\x86\xda\x13\xa7\xd7\x24\xec\x7b\xc1\x0d\x15\xe0\x54\xa4\x99\x9a\xd3\xfc\xb5\x76\x59\x15\x19\x2b\xeb\x0c\x65\xcb\x6b\x25\xec\x23\x54\x71\x48\x3f\xaa\xa8\x6a\xad\x6f\x94\x15\x55\x71\xae\x82\x10\xaa\x88\xfd\x39\xad\x38\x5a\x6f\xd7\xe9\x26\xb1\xda\xee\xdd\x9d\x9e\x74\x19\x5e\xa8\xd6\xc5\x15\x6e\x8b\xc3\x78\x40\xed\x6f\x3a\x6c\xb0\xd1\xa0\xcb\xfe\x58\xbc\xeb\x77\xc5\x10\x70\x57\x53\x58\x48\x7e\xd7\x32\x7b\x8a\x8f\x52\xfd\x88\x4e\x5a\xa9\x39\x20\x99\x35\x92\x6c\x4a\x9a\xe4\x26\x4c\x12\x5d\x4d\x51\xfd\xfc\x99\x8e\xd1\xb5\x14\x75\x76\x66\xa7\xe4\x7a\x94\x1d\x9d\x3e\x7f\x36\x0d\x15\x40\x69\x81\x27\xcc\x06\x55\x16\x35\xc5\x9e\xf7\x7c\xfa\x06\xbc\xe9\x2b\xbb\xc0\x72\xae\x35\x18\x59\x3a\xac\xd0\x4b\xd7\x27\xc5\x98\x42\xed\x39\x31\x85\x5e\xb2\x71\x66\x09\x40\xa1\x9c\x5d\xf0\x12\x88\x42\x73\xd3\x64\x72\x3d\xfe\xf5\xf8\xf5\xf9\xe2\xf0\x44\x66\x8c\x09\x0d\x9e\x88\x6d\x6d\x2f\x40\x22\xf0\xc9\x69\x9f\xca\xaf\x7a\xb1\x68\xee\xea\x45\x05\xbc\xc1\x57\x2c\xc4\x7e\x1c\x79\x41\x44\x1c\xf9\x79\x3a\x26\xb0\xd7\x47\x27\x08\x1c\x26\xbf\x92\x64\x3e\x8e\x27\x21\xf6\xe8\xcf\x51\xe0\x07\x71\xe0\x93\xdf\xd4\x8f\x77\xea\x07\xdb\x85\x24\x63\xf1\xf7\x39\xe9\x07\xa1\x0c\x7d\xd6\x8f\x49\x58\x01\xf5\x99\xbf\x3a\xd4\x1a\xbb\x84\x9e\x37\xf1\xdd\xf8\x2b\xc8\x93\x37\xe8\x22\x05\x33\x98\x26\xc6\xbd\xbf\xa8\x42\x7d\x13\xdc\xc3\x9c\x7f\xe2\xfc\x75\x2b\x70\xfb\x57\xaf\x00\xbf\xcb\xb5\x08\xfb\xb0\x85\x24\x85\xb0\x24\x0d\x8f\x0c\x88\xef\x9c\x2f\x35\xb6\xcd\x7f\x1a\xda\x83\x31\xfb\xe5\xf1\x4f\xc7\xaf\x5f\x5c\x9d\xbf\x7b\xc3\xc6\x6b\x10\x8c\x38\x35\x5c\x62\xa8\x1c\x06\xa1\xfb\x91\xda\x92\x30\xdc\x5d\x93\x10\x16\x92\x15\x46\x5f\x3f\x85\x5c\xa0\x94\x5e\x10\x80\x15\x43\x17\x25\x4b\x10\x58\x43\x68\x6b\x0b\xdd\x0c\x09\x9c\x11\x0d\xf1\x35\x81\xc5\xa4\xcb\xae\x69\xaf\x21\x84\xc1\x0c\x79\x11\x7c\x8d\x41\x92\xeb\xc7\x22\x05\x13\x66\x3f\x2e\x3c\x39\x2c\x94\x91\x8a\x94\x35\xaf\xf3\x20\xaf\x39\xe4\xb5\x06\xdb\x02\x0b\x09\x2c\x41\x3d\xa4\x8b\x83\x25\x49\xf0\x15\xc5\x52\x34\xc4\x3a\x64\x29\x22\xb3\x31\x28\x73\x89\xcc\xc6\xa0\xcc\x9f\x53\xca\x62\x50\x96\xa8\xc1\x0c\x0c\xca\x52\x14\xf8\xce\xd9\x02\x54\x20\x27\x03\xb2\xa4\xa4\xb2\xe7\x84\x8b\x6a\xf9\x5a\xf6\x9c\x72\x61\x52\x6b\x86\xcd\xa8\xa5\xa6\x02\xfd\x90\x78\x49\xf1\x67\x4e\x93\x57\x45\xef\x98\x1f\x31\x2f\x31\xb3\x12\x1c\xc1\x32\x80\xfe\xdd\x64\x77\x0e\xe0\x67\x30\x89\x95\x60\xf1\xc9\x57\x23\x6c\x60\x56\x0e\x9f\x97\xa8\x10\x43\x47\x15\xab\x56\x16\x29\x6e\x84\x7d\x52\xed\xc2\x86\x66\xe6\x36\xb2\x33\x3f\x43\xb7\xd0\xe7\x59\xf1\x30\xdf\x51\x3f\x54\x0b\xa9\xc2\x76\xe0\xd6\xc4\xc9\x49\x17\x55\xfe\xd1\x6e\xee\xb5\x7a\x8e\x12\xf8\x5f\x36\x98\x35\x69\x08\xbf\xbe\xf5\x8f\x7e\xbf\x5f\x51\xc7\x97\x0b\xd8\xc8\x32\x68\xe1\xa3\x45\x2f\x98\xf9\xec\x88\x30\x3a\x8b\xf8\xb1\x60\xcd\xa4\x99\x8d\x1c\x0d\x6b\x76\x1a\x0d\xa3\xb2\xf0\x26\x97\xf6\x0e\x17\x9b\xb1\x6f\xcb\x9d\xf6\xec\x9b\x75\xf4\xe9\xce\xd4\x85\x4d\x39\xe0\xc5\x3d\xfa\x74\xb7\x76\x97\xb4\xf4\x80\xc4\xe2\x49\x76\x06\xa2\xe0\x2a\x24\xfd\x36\xdb\x00\x66\xa7\xf2\xfc\x7e\x20\x0d\xd6\xf7\xf3\xe5\x1e\x3a\x44\x69\x3b\xe8\x53\x2d\x4a\xdb\x3b\x87\x74\xe7\xae\xfd\x21\x95\x15\x82\xb4\xfc\x7a\xa2\x69\x26\x91\x78\x8d\x2e\x52\xf0\x6f\x11\xdd\xc3\xbe\x73\xe6\x7e\x24\x32\x5e\x04\xc8\xfc\x6c\x97\x46\xca\x80\x53\x51\x43\x45\xd2\xa0\xdf\x8f\x48\x2c\xd3\xb0\xcf\x83\x35\xb9\x21\xcd\xae\x66\x72\x2c\x31\xf8\x64\x3b\xee\x20\x41\x71\x6c\xa1\x51\x2e\x71\x8f\x82\x66\x86\x09\xa0\xd4\x41\xf7\x02\x8f\x77\x78\xa1\xe2\xc1\x0e\xdf\xa2\x76\xfb\xa8\x2a\xaa\x74\x78\x88\x54\xf3\x5f\x75\x1e\x90\x7a\xbf\x74\xbb\xf8\x03\x23\x4f\xf0\x78\x84\x63\x72\x14\x04\xa1\xe3\xfa\x38\x26\xa7\x7d\x40\x8f\x01\x4e\x3f\x21\xac\xbc\xe0\x41\x31\x55\x83\xae\xa2\x4a\x96\x6c\xed\xae\xfc\xc5\xaf\x3f\x74\x91\x2a\xdb\x2e\xfb\x03\x98\xcd\x82\xf5\xc2\x09\x3e\x0f\xf4\xb6\x5a\xab\x42\xdb\xd4\xd0\x53\x06\x40\xc4\x1f\x12\xd5\x23\x70\xe7\xc6\xe2\x92\x32\xb8\x09\x90\xba\x00\xae\x5f\xed\x16\xa7\x2b\x26\xbc\x16\x21\xe8\x42\x73\x66\x0e\x5e\x6f\x73\x79\x9d\x7e\x91\x86\x9c\x6a\x0d\x39\x5d\x45\x43\x9a\x44\x6c\x10\x30\x88\xf7\x4e\xdb\xf1\x4d\x36\x61\x53\x37\x73\xd3\x97\x6e\xd1\x9d\xc5\x87\x82\xda\xc1\x9a\x40\x0c\x69\xad\x0a\x58\x5c\x80\x05\xa5\x50\xc5\x77\x1f\x50\xc5\x1f\x50\xc5\x1f\x50\xc5\xbf\x20\xaa\xb8\xa4\x02\xcf\xd1\xf3\xdb\x7a\x6f\x55\x05\x2c\x05\x34\x9e\x26\xb6\x28\x2a\xf8\xbd\x60\xa9\x6f\xaf\x00\x4b\x7d\x7b\x39\x2c\xf5\xce\x3d\x62\xa9\x77\x56\x85\xa5\xde\x59\x01\x96\xfa\xff\x21\x6c\xf1\x7b\x05\x8d\x4f\x93\x5f\xa2\xb6\x69\x52\x0f\x40\xe7\x7f\x75\xa0\xf3\xfb\x06\xb5\x97\x17\x96\xef\x13\x8b\x7c\xfb\xfe\x21\xd5\x17\x81\x3b\x7f\xc0\x3b\x7f\xc0\x3b\x7f\xc0\x3b\xbf\x4f\xbc\xf3\x07\x30\xed\x07\x30\xed\x07\x30\xed\xaf\x0f\xa6\xfd\x2c\x24\xd8\x00\xa6\x4d\xbb\x31\x8d\x2a\xb5\xe1\x6b\x32\x46\xee\x07\x33\x9b\xb2\x54\x80\x99\x4d\xa3\x57\x88\x99\x4d\xc9\xfd\x4d\x31\xb3\x69\xd5\xca\x60\x66\x83\x08\x96\xc6\xcc\x2e\xc2\x69\x9e\x13\x13\xdb\x60\x30\xce\xc2\xc4\xc6\x21\xc1\x73\x60\x62\x5b\xa8\x87\x23\xf2\x52\x43\x5a\x4c\xa3\x3d\x27\xfb\xe6\x19\x94\x6c\x4b\x8b\x7b\xce\x49\x75\x25\x51\xb1\xb7\x3e\x03\x7b\x3a\x1f\x04\x9b\x2a\xa1\x7e\xaa\x26\x9e\xbc\x19\x41\xae\x93\x07\x17\x73\xa2\x67\x2b\xcf\x34\x96\x40\xc2\xd2\x78\xd1\x5e\x17\x99\xb1\xb8\x25\x26\xee\x02\x98\xdc\x29\xc9\x88\xa4\x45\xa0\xdb\x07\xf3\x09\x27\xc1\xf3\x5e\xb5\x74\x80\x9b\x3c\xf9\x68\xf8\xe0\x9a\x84\x16\xc3\x09\xd7\xd0\xae\xd9\x98\x6a\x46\xbb\xfe\xcb\x22\x37\xab\x29\x44\xcf\x4b\xd2\x88\x90\xfb\xc2\x77\x56\x86\x90\x99\x48\xcf\xff\x47\xc0\xc8\x32\x8d\x9f\x8f\x32\xaa\x3e\xbd\x6b\xcd\x78\x7a\xd7\x32\xa1\x91\xd1\x01\xbf\x3c\x10\x98\x69\x9b\xe3\x8b\xa3\x91\x2d\xc1\x04\x43\x23\x53\x8a\xff\xca\x70\x64\x52\xfa\xc5\x70\x64\x2a\xe0\x98\x1a\xac\x40\x8f\xa9\x6f\x0c\x05\x08\x99\x12\x56\x0c\x68\xb6\x38\x58\x99\x62\xfd\xaf\x1c\xb8\x2c\x73\x0a\xf1\x55\x81\xcb\xc0\x32\x5a\x06\xab\xec\x67\x79\x23\xe3\x2d\x3c\x2a\x2b\x18\xc0\xf4\xa4\x55\xec\x8d\x87\xd8\x34\x29\xe4\xa3\x14\x66\xc6\xf1\xb6\x1c\xc8\x0b\x46\x88\x76\x2e\xf4\xd1\x7f\xb5\xb7\xaf\xed\xba\x12\xaa\xf5\xa7\x88\xce\xbe\xbf\xc9\x1e\x75\xd1\xb8\xac\xdf\xaa\xdd\x9d\xf8\x8e\x12\xab\xbf\x19\xdd\x44\xcd\x54\x6a\xf1\xe2\x16\x04\x80\x9e\xa0\x57\x38\x1e\xd6\x71\x2f\xaa\xf2\x62\x36\x81\x9e\x36\x9e\x8c\xf0\xed\x3b\x74\xc8\x52\x8e\xf0\x2d\x37\xc4\xe1\xd1\x5d\x41\x2f\x37\x0c\xc9\xbc\x63\x71\x9c\x7e\xa1\xbd\xba\x35\xb3\xa0\x09\xde\xe7\xb7\xd4\x54\xfc\x0a\x39\x09\xaa\xac\xa4\x2a\x23\x13\x59\x10\x93\x0f\x88\x9a\xce\x67\x94\x86\x20\x36\x4b\x1e\x85\x12\x61\x97\x5c\x53\xec\xac\xb0\x87\xcb\x07\x98\xea\x95\x25\xde\xfa\xdf\x33\x6d\x7a\x2a\xbe\x65\xc4\x26\x4a\x3d\xcd\x9e\xf2\x3b\x7f\xec\x3f\xed\xe5\xa6\x0c\x15\x37\xa7\x41\x76\x1b\x02\xd6\x83\xe9\xfd\xe7\xcf\xa8\x59\x4b\x2f\x46\xf2\xfa\xf9\xaf\xfc\xa9\xc5\xcc\x5e\xae\x26\xcc\xef\xe3\xf9\xd8\x83\x99\x3e\xbe\x5d\xa6\x8f\x6f\x97\xec\xe3\xdb\xc5\x7d\xfc\x9d\xd6\xc7\xa7\xa9\x3e\xfe\xae\xb0\x8f\x6b\xa9\xe5\xa3\x79\x73\x27\x7f\xc7\x3a\xf9\xbb\x74\x27\xff\x6d\x85\x9d\xfc\xf6\x6b\x77\xf2\xdf\x72\x3b\xf9\x6f\x85\x9d\xfc\xb7\xfb\xea\xe4\xb7\x39\x9d\xfc\xb7\x2f\xd7\xc9\x1b\x5a\xf7\xe5\xba\xf0\x3d\x53\xae\xa7\xe2\x5b\x46\x6c\xa2\x34\xd6\x02\xef\xe5\x20\x25\x53\x77\xce\xf6\x7c\xf6\xb7\x6c\x37\x3f\xf2\xdc\xf1\xcc\x2e\x2e\x12\x99\xba\xb7\xbc\x80\xaa\xac\x36\xd4\x5b\xa8\xc8\x70\xab\x53\x3e\xe3\x2a\x86\x1e\x31\x8c\x2c\x25\x10\x47\x8c\x56\xc7\x0c\x29\xd0\x05\x71\x49\xfc\x55\x3d\x69\x66\xf5\xa7\x20\x9b\x18\x46\xc1\x7c\xf4\xc6\x14\xc4\x6a\xc7\x00\xb1\xaa\x81\xb4\x76\x32\x20\xad\x4c\x35\x32\x98\x8e\x9a\xa5\x6d\x02\x69\xed\x68\x20\xad\x3a\xca\xc7\x5b\xec\x0f\x74\xbc\x47\x08\x99\x03\xef\xef\x2b\x5a\xbf\x8b\x83\xa5\xaa\xa6\xf1\x32\x55\x5b\x25\x6c\xa9\x8a\x26\xf0\x29\x33\x2f\x66\xb7\x22\x93\x89\x35\xd9\x88\xcc\xaa\x4b\x16\x8e\x36\x07\x90\x16\xd6\x0d\xf4\x9f\x8a\x36\x9a\xae\xa5\xb4\xef\x11\xed\xde\x40\xb1\x18\x5b\xe1\xcb\xca\xee\x4b\xed\x08\xa4\x96\xbb\xb9\x72\x4c\x03\xfb\xe6\x3b\x7e\xd0\x50\x78\x73\x7a\xb2\x8e\xbf\xab\xa6\x32\x03\x0e\xe7\x40\x00\x97\x69\x50\x31\x22\x3c\xb4\xed\x37\xdf\xb6\xa9\xc3\x07\x68\xdd\x92\x4b\x7c\x3a\xc5\x95\x87\x36\xce\xa4\x5e\x10\xd9\x78\x29\x54\xb8\xcc\x22\x62\xc7\xb8\x88\x98\x0b\x3c\xce\xb8\x3d\xad\x63\x19\xef\x2c\x84\x65\xbc\xb3\x18\x96\xf1\xce\xbc\x58\xc6\x3b\xea\xae\x76\x16\x0a\x6f\x05\xc0\xc0\xea\x79\x97\x9e\xf6\x79\x66\xbf\xfd\xcb\x98\x0a\x79\xf7\x27\xff\xfe\xd0\xc0\xec\xcc\xf3\xff\x00\x34\xf0\xd6\x16\x9a\x8c\x1d\xaa\xc0\xb4\xa6\x31\x76\x03\x5f\x8b\x17\xd0\xc1\x52\x85\xff\xea\xe0\xc1\xc6\x85\xf9\x57\x01\x0f\x5e\x90\x93\xbf\x1c\x78\xb0\x50\x21\x65\x6c\x33\xc0\xe6\x7e\x99\x8d\x15\x73\x7b\xdd\x63\x73\x3d\x97\x4b\xd9\xcc\x91\xa6\xf8\x2f\x25\x9b\x02\x28\xe2\x1c\x58\xdd\x0c\x89\xa2\x1d\x9e\xdc\x5e\x9a\xf4\x53\x41\xa9\xa0\xa7\x66\xfa\x6a\x2a\x4f\xb6\x8f\x7c\x4b\xfd\xf5\x9b\xea\xb1\xf7\xd7\x67\x0d\xbd\xb6\xa8\xdf\x66\x7b\x6e\x2a\xbb\x09\x58\x39\xb5\x83\x93\x4c\x15\x96\xa6\x94\xb9\xa0\xe0\xd9\xdd\xc6\x95\xd8\x34\x68\xc5\x5b\x20\xc8\x00\x68\xb9\xdc\x76\x46\x4a\xf4\x59\xfc\x4c\x73\x91\x2b\x2d\x34\x1f\x4b\x13\x25\x78\x9a\xd2\x02\x3a\x52\x77\x7a\xb8\x12\x64\xa1\x35\x91\xb8\x0c\x24\xa1\xb7\xc5\x7e\x67\x5c\x4b\x25\xd4\xbf\x6b\xf7\x26\xdb\x55\x2b\x82\xbe\x23\xc6\xb6\xc1\x66\x49\x89\xed\x88\x65\x64\x55\xd4\x97\x0a\x76\x43\xd7\xf2\xc4\xb8\x00\x08\x39\x2d\x75\xe6\x9a\xb4\x10\x82\x3c\x1f\x24\xba\x04\xd0\x73\x66\xb1\xb9\x3b\xe7\x62\xd3\x08\x92\xac\xb0\xb8\x3a\xa4\x72\xe3\x02\xad\xa5\xad\xd0\xf4\x15\xc6\xdf\x08\xd8\x7c\x59\x72\x06\x3b\x68\x06\x56\x7a\xc1\x56\x48\x89\x83\x8b\xf2\x7d\x69\xe5\x98\xe9\x7b\xe5\x30\xd3\xf7\x0a\x31\xd3\xf7\x66\x5c\xdc\xda\x2b\x85\x99\xbe\x67\xc6\x4c\x57\x11\xcf\xf7\x0a\x11\xcf\xf7\x32\x88\xe7\x3a\xde\xfa\xde\x2c\xbc\xf5\xbd\x2c\xde\xba\x8e\x99\xbe\x37\x13\x33\x7d\x6f\x2e\xcc\xf4\xbd\x07\xcc\xf4\x72\x98\xe9\x70\xfe\xf0\xcd\x61\xa6\x7f\x0b\x17\xbc\x96\xc0\x4c\x9f\xcb\x36\x59\x06\x33\x7d\x4e\x23\xe8\x5e\x31\xd3\xe7\x38\xcd\xff\x52\x98\xe9\x4f\xd3\x73\x81\x62\xc0\xa4\xf3\x56\xe9\xb8\xfb\xf9\x73\xaa\x2b\xfe\xad\x91\xd1\xa9\x44\x8a\x91\xd1\xb7\xe7\x44\x46\x67\x56\xe4\x52\xc8\xe8\xe6\xa3\xa5\xe5\x90\xd1\xcd\x34\x57\x82\x8c\x6e\x46\x8c\xd0\x90\xd1\x39\x1e\xd7\x42\x54\x4a\xe1\xae\xce\xe2\x61\x91\x82\x39\x40\xe2\x22\x59\x19\x86\x79\xdd\x8d\xde\xb2\x27\xe1\xb0\xff\x3d\x0b\x1e\xfe\x9e\x24\xf0\xd7\x84\x87\x9f\x21\x5a\xab\x04\x3c\xfc\xb7\xaa\x51\xe5\xe0\xe1\xbf\x6d\xee\x4b\xc0\xc3\x7f\xdb\x15\x28\x01\x0f\xff\x6d\x57\x60\x26\x3c\x7c\x3e\xfb\xe5\xe1\xe1\x4b\xd0\x88\x62\x6c\x7f\xf8\x2a\x82\x5c\x62\x7c\x66\x6d\xc0\xe1\xe4\x4b\xe1\xdb\xcf\x18\x5e\xe7\x9e\x79\x0b\xf0\xed\xcb\xe2\xcf\xe7\xb2\x24\xe1\xe3\x4b\x01\xc4\xdf\xd7\xb4\x33\x13\xf0\x3c\x37\x6b\x09\xc0\xf3\xc2\xe9\x61\xa1\x8c\x09\x40\xfc\xd6\x16\x6c\x40\xc8\x87\xf7\x31\x3b\x0a\x9e\x81\x1b\x7f\x4f\x62\x5c\xb8\x3e\xcb\x08\x71\x89\xb6\x4b\xc4\xe8\x51\x03\xfe\x41\x62\x73\x48\x6c\x96\xbf\x88\x19\x1d\x1e\x34\x17\xdc\x44\xc0\x6d\xb1\x8c\x02\xcf\xf6\x9b\x31\xd3\x86\x2c\xf4\x9b\x91\xdc\x0c\xfd\x2b\x4d\x05\x00\xca\xcf\x2a\xc0\xef\x21\x2e\xd5\x04\xb3\xdd\x03\x14\x73\x52\x38\x97\xe4\xcf\x67\x65\xdd\x03\xcc\x92\x20\x50\x58\x6c\x9d\x36\x97\x7b\x80\x6f\x56\x0f\x16\xf3\x4c\x50\x3c\x18\xcd\xe5\x99\x60\x06\xa9\xf2\x38\xf9\x25\x1a\x6a\x2e\x1f\x07\x33\x55\xbf\xbc\x8f\x83\x12\xac\xcd\xe5\xe3\x60\x1e\x7a\xb3\x7d\x1c\xcc\x1c\x05\x17\xf4\x71\x30\xcb\x33\x81\xd1\x61\x80\x70\x0f\x90\x0a\x3a\x1d\x63\xdb\x8d\xa7\x5d\xd4\xa8\xef\x58\x33\xbc\x1a\x98\xdd\x13\xe4\xf8\x3a\xd8\xda\x12\x07\x2c\x41\x1f\x5e\x60\x67\x5c\x12\x80\x1d\x54\xe4\x1b\x21\xed\x06\x60\x31\x1f\x06\x66\xb3\xf9\x5e\x7d\x18\xa4\xfc\x09\x3c\xc7\x11\xf9\x95\x83\xd5\x2b\xd8\x2e\x6c\x83\x91\xc3\xb6\x83\xa4\x13\xd7\x02\x46\xdc\x7c\xb1\x55\xda\x53\xe8\x25\xf0\x11\x10\xc2\x0e\x66\xee\xe1\xde\x17\x50\x97\xe7\x8b\x7c\xd3\x53\x29\x96\x9f\xe2\xc0\x49\xc7\x64\x44\x42\xd7\xe6\x87\x56\x39\x70\xf9\xe8\x29\x3f\xe2\xe0\x78\xeb\xc2\x61\x80\x13\x8c\x30\xdc\x60\x56\xa8\x30\x2c\xf6\x3a\x8b\xaa\xb2\x6d\x57\x80\xc7\x50\x92\xb0\xd7\x47\xf0\x1a\x00\x38\xaf\xa8\xa0\x4b\x23\x7c\xab\xbe\xe1\x63\x84\x2e\x1a\x97\x16\x2f\xee\xa2\x79\xc9\x77\x76\x21\x35\x94\xcf\x52\xbb\x7e\x5e\xea\x35\x71\xfa\xa5\xb4\x06\x2d\xde\xc1\x31\x7e\xe5\xfa\x59\x7f\x00\x23\xd7\x4f\x76\x8f\xf3\xb3\xe2\x5b\x43\x56\x7c\x6b\x02\x5d\xa2\xd5\xfa\x1e\x35\xd0\x53\xf8\xd5\x4d\x3f\x52\xcc\xe3\xdd\x42\x8d\x04\x78\xa5\x44\x0d\x78\x69\x92\x16\xcb\x5b\xaa\x06\x7a\xd6\xe6\xa5\x2c\x36\x4b\xf3\x6f\xe7\x82\x63\xb6\x8f\x8d\x62\x1f\x1d\xb0\x1f\x92\x72\xc0\xa1\x84\xa9\x54\xc0\xac\x38\x01\xcc\x7f\x95\x58\x12\x2c\x13\xdf\xb3\x5b\x8f\xe4\x04\x96\x32\x8a\x0e\xb5\x4a\x3c\x7e\xac\x7e\x0a\x9c\x4d\x9e\x47\x1d\xd3\x00\x0a\x4c\x1d\x37\x8d\x63\xa5\xc8\x99\x3c\x03\x64\xf0\x9a\x2b\xf5\x2d\xa2\x5d\xab\x85\xb3\x6e\x5e\x37\xf5\x9a\x02\x4b\xaa\xd4\xed\x22\xd5\x28\x1b\x48\xbd\xc3\x99\xba\x71\xfa\x15\xdc\x98\xb0\xaa\x14\x5c\x3e\xc9\x87\x61\x97\xfe\x32\x74\xbc\x16\x56\x85\x0b\xd9\x8a\x16\x0b\xbb\xcc\x7d\x57\x9d\xb4\x1a\x80\x97\xca\x9b\x00\xca\x28\xf7\xe0\x6c\x45\xe5\x79\x96\x03\x13\x3a\xb2\x17\xf8\x5b\x81\x81\x5f\x6f\xb0\xaf\xed\x72\x45\xe7\x38\xe3\x75\x45\xe5\xf8\xff\x92\xe3\x15\x31\x1a\xa6\x2e\xf6\xeb\xc3\x0f\x3b\x18\x87\x2e\x24\xfa\x82\x92\xa7\x0c\x3a\x83\xa9\xe3\xe4\xdb\x6a\x02\xb0\x40\x6f\x27\x08\xa5\xe3\xba\x82\x78\x74\xd1\xb8\xd4\x55\x7a\x86\x01\x38\x83\x14\x92\xe0\x4b\x29\x7d\x64\x26\x0c\x1b\x56\x4a\x8c\x14\x8a\x74\xd4\x62\x13\xd3\x56\x21\x97\xc9\x71\x9b\x9f\xa3\x9c\xab\x1c\xc3\x5b\xe7\xf4\xbb\xcb\x64\xd3\x48\x0c\x8d\x69\x87\x3a\xdc\x3a\xd2\x00\xa0\x34\xdb\x28\x18\x33\x4c\xda\x71\x02\x6f\xc7\x91\xb4\x78\x52\x65\x36\x2b\x86\x09\x34\xdd\x3f\x71\xa3\x5f\xb1\xe7\x3a\xe2\x02\x0a\x2b\x4c\x4e\x03\x49\x21\x73\xde\x6a\xf1\x02\x9f\xe8\x34\x45\x05\x52\x0d\xbc\x04\xa8\x61\x1e\xab\x2c\xa2\x9a\x29\x6e\xc9\x2a\x95\x7c\x4c\xac\xfb\x16\x98\xfd\x94\x58\xbc\xae\x2f\x46\xce\xaa\x30\x68\x95\xb4\x9d\x0d\x55\xb9\x07\xc7\x4c\x02\x91\x36\xe5\x98\x69\xef\xc1\x31\xd3\x83\x63\xa6\x6f\xc3\x31\xd3\xfd\x38\x2a\xca\x16\xb0\x1a\xe7\x4c\x4b\x39\x2a\x6a\xdf\x8f\xa3\xa2\xf6\x0a\x1c\x15\xb5\x97\x73\x54\xb4\x7d\x8f\x8e\x8a\xcc\x7e\x60\x17\x72\xc6\x34\x5e\xda\x51\x51\xe7\x1e\x1d\x15\x75\x56\xe5\xa8\xa8\xb3\x02\x47\x45\x3b\xf7\xeb\xa8\x28\x4d\x7e\x29\xb7\x4c\xab\x70\x54\xb4\x2b\x66\xfb\xb7\xc4\x8e\xb1\x3f\xf0\x0a\x9c\x15\x2d\xd8\xbe\x7b\xf7\xef\x4e\x68\xff\xea\x0a\x9c\x25\x3c\xc7\x05\xb4\x1b\x8b\xfa\x2a\x6a\xa8\xf7\x76\x8f\x88\x97\x3f\x57\x37\x1b\x8b\xfa\xf7\xf9\x3b\xfa\x43\xba\x47\x5f\x45\x26\x0f\xd0\xab\x76\xb9\xb4\x88\x3f\xa4\x07\x77\x48\x0f\xee\x90\x1e\xdc\x21\x3d\xb8\x43\x7a\x70\x87\xf4\xe0\x0e\xe9\x6f\xed\x0e\x89\xd9\x0e\x08\xa3\x41\x18\x4c\xc6\x28\xe8\xa3\x1e\x0e\x0d\xfe\x91\xa0\x63\x3f\xc7\xe5\x90\x57\xbe\x9c\x7f\xa4\xe7\x38\x2c\x70\x8f\xf4\x1c\x87\x2b\xf4\x8e\xf4\x1c\x87\x7f\x53\xe7\x48\xcf\x71\x58\xc6\x37\x12\x15\xc0\x3d\xb9\x46\xe2\x7e\x66\xe6\xf4\x8d\x64\x30\x50\x67\xf9\x46\xea\xe1\xb0\x94\x6b\x24\x07\xc7\x38\xdf\x1d\x12\x20\x0b\xd0\x3c\x5d\x38\xfb\x5c\xc2\xb9\xd1\x9c\x3e\x8a\xd4\x4c\x63\x83\xf3\xa3\xea\x0c\x46\x8a\xbc\x09\xcd\xeb\x11\xa8\x90\x17\xcd\x83\xcf\x12\x9e\x7b\x60\xd0\x42\xe8\x09\xe2\x57\x36\x50\x3c\x24\x4c\xe6\x41\x1f\x11\x6c\x0f\xd9\xc0\xc5\xd2\xfc\x6b\x8c\x43\x3c\x42\x9f\x98\xe6\xdc\xf1\xeb\x1b\xec\xee\x1a\xed\xb2\x34\xaf\x5c\x9d\x99\xb3\xb8\x31\x19\x89\xd3\xa5\x67\xbe\xb4\x37\x68\x69\xcf\xe9\xc0\xa8\xe6\x81\xce\x7d\x47\x07\xcc\x37\x41\xe4\x82\x38\xd1\xf9\x90\x88\xbb\x0d\xd8\x77\x50\xe4\x7e\x24\x92\xd3\x5e\x9a\x80\x28\x94\xdd\x25\x61\xff\x9d\x0f\x53\x37\xa2\x69\xf6\xdb\x4d\x7c\xeb\x46\xe6\xcc\xd3\x59\x99\xa7\x86\xcc\x9c\x75\xf5\xfe\x04\x64\xe6\x01\x52\xc2\x98\x32\x0d\x42\xe1\xf9\xd9\x98\x23\xf2\x8b\x7b\x34\x90\x1e\x52\x6c\xad\x65\xfc\x2d\xc1\x18\xfd\x97\x75\xb7\xe4\xf0\xab\x2c\x2c\x11\xfd\x5a\xbd\x13\x25\x18\x6c\x4a\x3a\x4e\x92\xfb\x3b\x85\x38\x17\x32\x95\xe9\xd4\x4e\x48\x29\x14\x89\xb2\x00\x6f\xc5\x27\x62\x99\x1d\xdb\x99\xe7\x77\x6c\xba\x4a\x8a\x9b\x8f\xf6\x8c\x53\x3c\x84\xee\xe7\x24\x2f\xcd\x74\xe6\x3c\x0f\x99\xae\x9e\x2c\x51\xcd\x92\x27\x7b\xa6\xbd\x3e\xe3\xf9\x5e\x8a\xd3\x14\xa6\x83\x64\x74\x06\xa0\x8a\x2c\x25\x2a\x09\x12\x6f\xca\x90\x9a\x50\x8b\xdd\x79\x41\xed\x74\x50\x7d\x08\xd2\x12\xf5\x70\x44\xca\xfb\x9b\x32\x6d\x34\x2d\xe2\xf4\x4a\x17\xa1\xc3\x2f\x9e\x39\xf9\x57\xbf\xd2\x8e\xa7\xc6\x19\xaf\x53\x77\x56\x52\x17\x05\x47\x4e\x5c\xf9\x30\x7b\x6e\x5a\x42\xb1\x4a\xc1\x55\x98\x36\x7b\x67\xe0\x6c\x19\xfd\x68\xe5\x80\x45\x53\x33\x4c\xea\x5f\x45\x49\x5f\x0a\xd3\xda\xdc\x98\xec\x6e\x71\xdf\xf5\x62\x12\x1e\x5f\x53\x9b\xf9\xb4\x7f\x34\x74\x3d\x6e\x03\x72\x67\x57\x63\x4d\xcc\x6e\x0a\xd9\x3a\xd1\x7c\xce\x1b\x73\xff\xa5\x32\xa8\xc1\x9e\x71\xa2\xe9\x41\x17\xb4\x55\xf4\xbf\x04\x05\x43\x75\xa0\x55\xb2\xcb\x95\x47\xa2\xce\xc9\x63\xf2\xa1\x57\x80\x43\x5d\xe0\xa5\x4e\x9d\x08\x5b\x30\x13\x66\x71\xbe\x95\x04\x59\xc0\xef\x7c\x0c\xa0\xd6\x42\xf8\xd3\xad\x85\xf0\xa7\x5b\x8b\xe1\x4f\xb7\xe6\xc5\x9f\x6e\xe5\xe1\x4f\x8f\x93\xf5\x86\x82\x3b\x24\x42\xe7\x80\x8c\x9e\xa3\xab\xcf\x7f\x92\xf5\xf7\x87\x8c\x86\xa5\xe0\xdf\x02\x31\x5a\x00\xf6\x72\xad\x2a\x98\x8d\x4c\x48\xb2\x29\x60\x58\x71\x99\x5a\xfc\x96\x00\xb1\x5a\x26\x01\x3d\x3b\x1b\xab\xb7\x1c\x6a\xac\x71\x29\xbf\x14\x6a\xec\x62\x88\xb1\x0b\xf2\xa1\x21\xc6\x16\xf3\x21\x3c\x74\xdd\x1b\x2f\x1c\x99\x89\xf1\x03\x1f\x33\x79\xfa\x59\x00\xb8\xdd\x1b\x53\x1c\x11\x8e\x73\xc5\xbe\xb2\xe0\xba\x45\xc0\xba\xa9\xa4\xc8\x08\xb4\x9b\x49\x64\x00\xde\xcd\x26\xe2\x90\x56\x99\x56\x32\x26\x16\x88\x57\x59\xf9\x65\x01\x53\x67\xe0\xf3\x96\xba\x82\xae\xb6\xd9\xd5\xdc\x20\xd8\xf3\x37\x57\x23\xd3\x48\x59\x3e\x00\x0d\x30\x83\x7b\x3d\x47\x63\xa2\xc4\xeb\x29\xda\xd0\xca\x43\x9b\x48\x85\x15\x9b\x25\xc2\x85\x90\xc1\x97\x10\x8a\xa9\x3f\x81\x97\x4b\x13\x10\xf8\x5a\x69\x71\x08\x50\xb5\x54\x75\xef\x74\x22\xab\x35\xfe\x57\x6c\xfe\x1b\xf1\x96\x55\xb4\x5c\xe3\xb2\x50\x4c\x5b\x4b\x62\xe2\x26\xb4\x4b\xda\xc8\x46\x20\xd0\x7c\x57\xac\x9a\xf1\xdb\xce\x18\xbf\xf9\x96\x6d\xbb\x18\xec\xb6\xac\x2d\x98\x8b\x37\xab\xad\x40\xd3\x58\xb3\x40\x79\x49\x1c\x58\x78\xb4\x05\xe4\x67\xe1\xbf\xe6\x2e\x40\x4a\xa0\xbf\xe6\x6f\x19\xcc\x68\x78\x71\x5d\xa8\xb0\xd9\x45\x22\xa5\xd1\xe1\x44\xb3\xc0\x43\xf8\xbd\xb8\x00\xcf\x77\x03\xaa\xe9\xd7\x76\x46\xbf\x74\x0c\xd7\xed\x59\x18\xae\xdb\x59\x0c\xd7\xd4\xf2\x6c\xdb\xb0\x3c\xb3\xe9\x5a\x39\x24\xbe\x92\x48\x04\x69\x0b\x45\xc2\xa5\xc9\x6f\xaf\x2f\xba\x5c\x77\xf9\x72\xdd\x77\x60\x91\xfe\x7c\x7a\x3e\x1d\xf3\x17\x33\xa2\xd8\x22\x80\x04\xed\xaa\x98\xe9\x70\x51\x7f\x8c\xa6\x32\x3d\x4f\xc3\xc9\x77\x8a\x46\x0f\x8e\xe8\x29\xb4\xdc\x45\xe3\x52\xcc\x5e\x5b\xa8\x85\xba\x32\x90\x21\xe7\x6e\xa1\x96\x64\x26\xb9\x34\x83\x63\x0c\xb8\x95\x3f\x06\xe1\x08\xc7\x31\x09\xab\x32\x28\x79\x51\x97\xe5\x54\x35\x0b\x6e\xbb\x09\x19\xdd\xab\xf8\x54\x8d\xd1\x1c\x8b\xf3\x1e\x92\xc4\x66\x1c\x89\x83\xa8\x7e\xc5\xde\xe2\x8f\xa2\x0a\xdf\x0c\x1a\x6a\x99\x0c\xf7\xf3\x7b\x26\x9d\xb9\x5f\xac\xb6\xbc\x6a\x46\x3a\xf2\xf8\x2e\xa9\x3c\x07\x1a\x4b\x75\x2f\x0e\x61\x96\xea\x53\x79\x8e\xcd\x98\xc6\x74\xf9\x5f\x4b\x2b\x4f\x6f\xf0\xae\x21\xac\xec\x0e\xd1\xfc\x28\xd7\xf9\xde\x37\x35\x94\xeb\x4e\x16\xe5\x5a\x1d\x9b\x3a\x99\xb1\x29\x0b\x62\xdd\x31\x83\x58\xeb\x83\x58\x67\xd6\x20\xd6\x31\x0c\x62\x2a\xd2\x75\x27\x83\x74\xad\xa2\x64\x77\xd2\x28\xd9\x3a\x88\x75\x67\x26\x88\x75\x67\x2e\x10\xeb\x8e\x11\xc4\x9a\xe7\x52\x31\xac\x1d\x31\x25\x2b\x13\xf6\x17\xc5\xaf\x2e\x89\x47\x6d\xbe\xcc\x5d\x4d\x1d\xa5\x7f\x7b\x70\xd4\x2b\xd9\x13\x9b\xdb\xfa\x5d\x15\x1a\xf5\x5c\xf6\xfb\x32\x68\xd4\x73\x2e\x14\xee\x15\x8d\x7a\x36\x2f\xf7\x8e\x46\xfd\x2d\x1e\xa7\xcc\x7b\x8a\x92\x76\x46\xb3\x8c\x0b\x60\x75\x09\xaa\x8d\xb0\x26\x8b\xbd\xaa\x48\x36\x49\xac\x24\x4d\xcc\xef\x6f\x1c\x8d\xdb\x51\x16\xa2\xf9\x58\xdc\xcf\x71\x58\x0c\xc5\xdd\x9e\x13\x8a\x1b\x96\x2f\x4b\x21\x71\x9b\x2d\xec\xe5\x90\xb8\xcd\x34\x57\x82\xc4\x6d\x7e\x12\xa5\x21\x71\xcf\x06\x01\xcc\x25\x22\xe0\xaf\xa4\x95\x6e\x69\x3b\x6b\xa5\x71\x75\x8b\x0b\x98\x85\xfd\x96\x9b\x7b\x36\xf6\xdb\x0c\xf1\x94\x46\x36\xfe\x0b\x54\x60\x31\xf6\xcb\x03\x03\x97\xa0\x51\x02\x18\xf8\xdb\x16\x64\x0f\x87\x0c\x3c\x62\x71\x16\x4a\xa0\x94\xdf\x93\x0c\x66\xa3\x4c\xcf\xe0\xbd\x1c\x4a\xf9\xb7\xcd\x7d\x09\xb7\x03\xdf\x6a\x05\x16\xca\x6a\x74\x3b\x50\x0e\xdf\x7a\xc6\xa8\x3f\xf7\x7c\x56\x80\x6f\x3d\x72\x7d\x58\x9b\xaf\xa0\x73\x8d\xf0\xed\xf3\x95\xf4\xd2\x59\xd0\xbb\xb9\x24\x24\xd6\x36\x5c\x4d\xf9\x0a\x9a\x36\x0b\xee\x38\x37\x23\x87\x3b\x4e\x7a\xca\x42\xcc\xcf\x06\xad\xcd\xef\x23\x65\x41\x6b\x4b\xb4\xdf\x0c\x14\xa6\x52\x14\xf8\x92\x67\x49\x2a\x62\xa9\xb4\x24\x99\x10\x3b\xee\x64\xc1\x29\xf8\x6b\x4d\x9e\x0a\x94\x72\x09\x08\xe0\x6f\x8f\xff\x25\x06\xed\xa5\xd0\x83\x8b\xfb\xf6\x5c\xe8\xc1\x33\x48\x95\x47\x0f\x2e\xa1\xa4\x73\xa1\x07\xcf\x18\x40\xe7\x41\x0f\x2e\xc1\xda\x5c\xe8\xc1\xf3\xd0\x9b\x8d\x1e\x3c\x73\xf9\x74\x4f\xe8\xc1\xa5\x11\x80\xd9\x9e\x4f\x66\x1e\x6e\x64\xa0\x7b\x99\x27\x04\xfe\x60\x81\xbd\xb1\x60\xd3\x04\xc3\x01\x16\x2b\x49\x65\x3d\xb8\x30\xd8\xaf\xd9\x86\x58\x0e\xec\x77\xbb\x10\xeb\x17\xfa\x42\xb6\x93\xca\x0d\xff\xec\x93\x1b\xf4\xe9\xce\xd4\x17\x4d\x39\xe0\xc1\x10\xfa\x74\xb7\x7a\x74\x54\x97\x23\x5b\x41\x0c\xfd\x48\x60\x4b\x93\xc7\x32\x09\x72\xa9\x0c\x2b\x8d\x6e\xfa\xb5\xe1\x57\xbf\x4d\xf8\x54\x89\x4d\x5a\xee\x52\xbc\xf9\xf4\xae\x2f\x0f\x66\x45\xab\x9c\xf6\x9f\x63\x09\xd6\x9c\xb4\x15\xb4\x72\x4d\x60\x07\x3e\x1a\x07\x51\x0a\x98\xf7\xe2\x52\x43\x6e\xce\x81\x75\x15\x57\x9b\x62\x32\xfa\xa7\x50\x29\xfa\xa1\x6b\x94\x02\x67\x9b\xa4\x4c\x83\xda\xaa\x47\xd8\x4a\x2a\x79\x9e\xcc\x93\xa9\x23\x4a\x2a\xa9\x1a\x75\xb0\x12\xc8\x69\xa1\x15\x02\x79\x5a\xd5\x9c\xa7\x05\x38\xd4\x7c\x2b\xd6\x84\x60\xbb\x68\xcb\xfe\x21\xce\x65\x25\xf4\xad\xd2\xb2\x9f\x58\xb3\x74\x05\x10\x9c\xc2\x59\x57\x93\xc0\x9d\xc4\xc6\xb5\x89\xe7\x2d\xf3\xfc\x62\x28\x35\xed\x99\xe7\xcd\x7b\x01\xc0\x04\xe7\x92\x7b\x0f\x40\x3c\x77\x5a\x0d\x60\xaf\x72\x60\x6c\x08\x9b\x1a\xc2\xc4\xe9\x63\x3a\x5c\x1e\x3a\x66\x90\x80\x15\x35\xc9\x82\x01\x2f\xaa\x00\xcf\x41\x3a\x71\x38\xf1\x6d\x1c\x93\xe7\x53\xae\x94\x20\xf3\x12\x00\xc3\x96\xae\xcc\xb5\xbf\x0c\xe0\x70\x3e\x9c\xda\xa2\x80\xc3\xfc\x70\x40\x36\xd7\xcc\x6b\x9c\xb7\x4b\x88\xe4\x43\x1e\xc8\x6c\xd2\x79\x25\xef\xd8\x74\x83\x21\x0b\x24\x2c\xa3\x0c\xd8\xb3\x99\xab\x0c\xe3\x20\xaa\xa7\xaf\x33\x68\xf8\xb4\x32\x54\xc5\xa9\x4d\x5d\x65\x60\x1d\xc3\x88\x1c\x2c\x12\x88\x5e\x42\xcb\x8b\x60\x00\x4e\xf5\x92\x6c\xee\xc6\x65\x0d\x6d\xe6\x51\x55\x94\x03\x30\xeb\x71\x2f\xaa\xaa\x03\x7c\x0d\xfc\xae\x3f\x7e\x8c\x64\x2c\xbf\xf3\x8a\xbe\x47\xe6\x0c\xe9\xd7\x5c\x0e\xf1\x60\xaa\x5e\xf0\xce\x29\x1b\x00\x47\x38\x1e\x9e\xb9\x03\xde\x0f\x79\x65\x3f\x7f\x46\x3a\xab\x4f\x72\x2b\xb1\x99\xe1\x5f\xbd\x36\x3a\x45\x9b\x87\x8c\xcf\x83\xf4\xb0\xb3\x91\x8a\xb8\x33\xf5\xe7\xdb\x14\x42\xad\x94\xbb\xda\xac\x5f\x4e\xb3\xa7\x46\xcd\xce\x1a\x68\x5f\x54\xb3\x85\xe2\x1a\x51\xa6\xd1\x66\xb1\xfc\xa4\x76\x27\x6a\x3f\xbf\xe2\xb2\x7b\xc9\xa5\xf5\xf6\xea\x1e\x14\x97\x09\x61\x31\xbd\x65\xec\x2b\x17\x7f\x19\xb1\x8d\x43\xce\xa9\x71\xdc\x2d\xf1\x5a\xe0\xb6\x8b\x6e\xe1\xb2\xc0\xb4\xf8\xaa\x80\x25\x41\x5e\x34\xeb\x8c\x4d\x04\x1c\x60\xfb\xa2\x29\xcf\xe7\x4d\x18\xdb\x16\x37\x87\x1e\x3f\x66\x3f\xf8\xbb\x99\xf4\x77\x5d\x81\x03\xd6\x8e\x95\x15\x7c\x67\xb6\x7c\x05\x7b\x25\x0d\xe4\x9c\x81\x6d\x5e\x29\xdc\x2e\x87\x38\x49\xa1\xed\xee\x3f\xa0\xed\x3e\xa0\xed\x7e\x1b\x68\xbb\x80\xf4\x9f\x87\xe5\xb9\x20\x96\x62\x9e\x23\x81\xe5\x90\x76\x81\xd4\x03\xce\x6e\xd1\xa6\xe3\xdf\x1a\x67\xf7\x5e\xe1\x67\xd3\xe4\x97\x02\xdb\x5d\x05\xfc\xec\xce\x3d\xe2\x0a\xef\xac\x0a\x57\x78\x67\x05\xb8\xc2\xbb\xf7\x8f\xbb\xfa\x65\x70\x76\xef\x1d\x76\xb5\x71\x75\xf5\x3f\xd4\xec\x2d\x90\xcf\x12\x20\xbb\x0c\x00\xe5\x68\x12\x5e\x17\x00\x1d\x2f\x4a\xbf\x25\xe8\x9f\x4d\x47\xbd\xa0\x48\x38\xfb\x0b\xe2\xbb\x53\xab\xfa\x1e\x91\x8e\xb7\xbf\x00\xd2\x71\xe7\xfe\xd1\x81\x77\x1e\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x1f\x90\x7b\x67\x21\xf7\x46\x36\x3c\x21\x8c\x4c\xf0\xbd\xd0\xbd\xcf\x58\x82\x32\xdb\x7e\x26\x3b\xf7\x7e\x20\x7c\x39\x53\x05\x30\xbe\x3c\xc5\x0a\xa1\x7c\x39\xc5\xbf\x29\x9c\x2f\xaf\x5d\x19\x48\x5f\x21\x88\xe5\x61\x7d\x99\x83\xed\x13\xb6\x4b\xbe\xd9\xb4\x4a\xe1\xfc\x4a\x18\xcc\x37\xc2\x9b\xaa\xe2\xc0\x1a\x82\x66\x60\xf0\xbe\xd1\x3c\xe1\x7d\x59\x1c\xde\x2f\x85\xb1\x3b\x2f\x2a\xb2\xc1\x30\x9f\x85\x8a\xcc\x47\x0e\x8e\x8c\xfc\xe5\x90\x7a\xb3\x10\xb8\x65\xe1\x6f\xb3\xf8\xb7\x65\xb1\x6f\xd1\xa7\x33\xb8\x3f\x79\x27\xaf\x94\xd0\x9c\x4c\x32\x60\xb8\x03\xec\xad\xca\xab\x78\x79\xcf\x41\x6f\xcb\xa1\xde\xca\x61\xed\x2f\x8b\x7c\x2b\x3d\x1c\xf3\x64\xec\x7b\xa5\xe8\xb7\xac\xfb\x8a\xae\x5e\x12\x01\x97\x2d\xca\x4f\x62\x32\x2a\x7c\x04\x9f\x24\x2b\xc2\xc0\x8d\x20\xd5\x97\x01\xc0\x95\x65\x2d\x81\x66\xf0\x65\xd1\x6f\x25\xc7\xe5\xa0\x6f\x17\xad\x60\x49\xdc\x5b\xc3\xbe\xcc\x1c\x6e\x2d\x63\xb8\x56\xca\x2a\x22\x9c\x58\x22\x03\xd4\x04\xab\xc4\x0c\xf8\x05\xce\x40\x49\x40\xdc\x4c\xea\xcc\xe4\x56\x8c\x87\x3b\x0b\x9a\x53\xe0\xe5\x0a\xe0\x49\x06\x3f\xaa\x76\x7b\x98\x9c\xcf\x52\xc9\x94\xd0\x6c\x62\x79\x61\x51\x4b\x0c\xa1\x8b\xc3\xf0\x9a\xf6\x1d\x97\x47\xe1\xcd\xf7\x47\x5c\x0a\x7f\x97\x37\x2c\x6b\x77\x86\xf7\x8a\x0c\x98\xbc\x7f\x43\x14\x5e\x31\xed\xb3\xaa\xcf\x0b\xc3\x6b\x6e\xcc\x55\xa2\xf0\xaa\x4d\xa2\x32\x97\x0f\xc1\xab\x0c\xfa\x9a\x1a\x1f\x1e\x22\x17\x3d\xd5\xfa\x41\x17\x2d\x8b\xd2\xcb\xbb\x75\x79\x88\x5e\x53\x86\x39\xf1\x79\xf3\x21\xca\x52\xd3\x75\x9b\xcf\xd7\x0b\xc3\x94\x19\xcd\x06\x1d\x80\xb7\xbd\x10\x00\x6f\x7b\x31\x00\xde\xf6\xbc\x00\xbc\xed\x22\x00\x5e\xb9\xe0\x48\xc1\xae\xbd\x49\x19\x39\x5f\x06\x70\x24\xef\x3c\xef\xef\x0f\xc2\x3b\x76\xc9\xdf\x13\x84\xb7\x70\x52\x2a\x01\xc3\xcb\x15\x94\x03\xf1\xb2\xaf\x65\xa1\x78\x8f\xe6\xbb\x84\x3a\x27\xc4\xab\x2d\xc1\x78\xed\xd9\x68\xbc\x47\xf3\xdd\x1a\x9c\x97\x15\x89\xc7\x6b\xcf\x06\xe4\xe5\xaf\x00\xee\x8d\x99\xc8\xfd\x48\x04\x3b\xf4\xf7\x92\xb0\xb7\x76\x0a\xf7\xf6\xe8\xd6\x08\x53\x6b\xa7\x90\x6f\x8f\xa6\xc6\x64\x11\x5c\x90\x4c\x8b\x63\x6e\x24\xdb\x85\x60\x58\xe7\x97\x67\xa3\x48\x8e\x85\x00\xab\xd9\x7a\x56\xe3\xda\xdf\x19\x6d\x35\xbb\xe6\x58\x11\xd4\x2a\x27\x5c\xc6\xd0\x31\xe2\xd0\xe5\x83\x60\xa6\x2c\x98\xed\xb9\x2c\x98\xed\xd9\x40\xab\x65\xe7\xfc\x5c\xb0\xd5\x71\x32\x26\xb3\xd1\x3d\x0d\xb8\xca\x4b\x58\x12\x72\x95\x51\xb1\x78\x21\xb3\x60\x57\xcd\x46\x65\x09\xcc\xd5\xdc\x55\xe9\x3d\x41\xae\xa6\xe0\xeb\x64\xfb\x15\xc1\xb0\x1e\xcc\x6c\x93\x95\x83\xb4\xe6\xe3\x24\xa6\xf4\xb3\x63\xd0\xcf\xe5\x31\x0e\x33\x28\xac\x9d\xd9\x28\xac\x4b\xac\xbd\x97\x7b\x82\xd5\x5e\x1c\x84\x35\x2a\xdb\x32\x05\x88\xa9\xef\x96\x84\x4c\xb5\xf3\x31\x53\xed\x62\xd0\x54\x2d\x76\x1e\xc0\x54\xd3\x95\x96\x95\x02\xa6\x16\x88\xeb\xb7\xaf\x26\xae\xdb\x6f\x56\x5c\xbc\xce\x9a\x66\xa6\x8c\x76\x78\xbe\x9c\xdd\x48\x72\xdc\x90\xd8\x7c\x61\x9b\x3c\x57\xad\xcb\xe0\x64\x3e\x59\x05\x8a\xad\x9b\x42\xaf\xe5\x43\xb2\xab\x2d\xfa\xe0\xd9\x40\xce\xa0\x94\x79\x13\x96\x87\x6b\x9b\xbc\x98\x57\x6a\x78\x78\x88\x2a\xb7\x15\xf4\x54\xc5\x3e\xee\x6a\x2f\xdd\xd2\x8c\x64\xa0\x6e\x0d\xc4\x0c\x2a\x8a\x4c\xa0\xb8\xef\x92\x06\x2c\xbf\x3b\xf3\xd2\xf5\x8b\x7d\xe4\xd1\x04\x46\x0b\x65\xa7\xec\x0c\xb0\x63\x98\x01\x3c\xd7\x27\x4a\x02\xfa\x99\x8e\x3e\x9f\x8e\xd3\x49\x68\x50\x3a\xd9\xbf\x29\x6d\x43\x5a\x19\xae\xfb\x4c\x63\x7b\x79\x5f\x7c\x2b\x36\xe1\xc0\x9e\x44\x71\x30\x7a\xc9\x6f\x23\xdd\x37\x13\x54\x12\x5a\xf1\x34\x40\x5a\x78\xe9\x77\xb6\x4c\xa2\x1c\xb1\xdc\x70\xd4\x93\x34\x0b\x55\xce\x3f\x28\x19\xcd\x05\x87\x46\x3c\x7f\x69\xaf\x2f\xc1\xc5\x78\x4a\x47\x51\xb1\x30\xb6\x12\xcf\x17\xf6\x34\x19\x8f\x34\xcd\x4e\x57\xca\xe4\x31\x4e\x6d\x6e\x75\x5c\xe8\xbb\x9e\xd7\x45\x15\x3f\x90\xca\x8f\x00\xad\x20\x0c\x3e\x90\xae\xae\x24\x8f\x1f\x6b\xdf\x75\x9a\x55\xb0\x60\xa5\x5b\x53\x2d\x63\xcc\x0f\xdd\x13\xa1\x28\x7d\x52\x11\xea\x52\xe7\x67\xd0\xbe\xe9\x26\xe0\x0d\xb8\xc4\x38\x0a\xfd\x31\x11\xeb\x6a\x4f\xd0\x8a\x78\xa6\x3f\xab\xb9\xe5\xae\xa2\x9a\x65\x4f\xd1\xd2\xb7\xa7\x67\x9f\xa1\x79\x8a\x16\xf0\x73\x34\x7d\x80\x2a\x38\x4e\xbb\xe7\x9d\xd3\xe5\xa0\x9a\xb3\x47\x21\x1e\xcc\x1a\x89\x17\x40\x43\xac\xba\x5b\x28\x5a\xab\xe4\xda\x79\x7e\xd4\xf6\xdd\x72\xa8\xed\xbb\x19\xd4\xf6\xd4\x54\xb5\x3b\x6b\xaa\xda\xcd\x4c\x55\x59\x60\xf7\xdd\x32\xc0\xee\xbb\xb3\x16\x3d\xbb\x33\x80\xdd\x77\x0b\x81\xdd\x77\x8b\x81\xdd\x77\x67\x02\xbb\xef\x72\x60\x77\x33\x3e\xfb\x38\x59\xc1\x6b\x6b\xfc\x79\xd6\x91\x25\x21\xd6\xcd\xef\x5a\xaa\x86\x7b\x39\x0f\x30\xeb\xbc\xef\x9a\xb4\x53\x05\x5c\xd7\xd5\x77\x05\xf8\xd7\x0f\x00\xee\x2b\xe1\xe5\xde\x01\xdc\x61\x28\x7b\xfc\x58\xdd\xde\x62\xe6\xbd\x82\x14\x50\x0c\x48\xfe\x2d\x9e\xe5\x7f\xca\x9b\x87\x22\xbe\x07\x9b\x8b\xce\x2e\x37\x60\xd7\xd2\xd2\xcb\xc7\x35\xe7\x37\xd6\x56\x8b\x6d\x7e\x26\x47\xb0\x25\xf0\xcd\xcd\xcb\x84\x22\x28\xf2\x79\x69\x95\x80\x4a\xff\xb4\xf6\x55\x61\xc3\x57\x04\x35\xfc\xf5\x60\xc3\x57\x54\x81\x8f\x7f\xf5\x0a\xd0\xa1\xea\x2b\x70\x0f\xf8\x95\x4b\x20\xa5\x2f\x0c\xe6\xb9\x34\xe6\xaf\x58\x9b\x2f\x85\x66\xd9\x77\xe3\xd8\xf5\x07\x15\x4b\xac\xee\x13\xda\x72\x19\xf3\x15\x5a\x45\xb0\xd7\xc3\x91\x1b\x51\xe6\xe0\xc7\x91\x17\x44\xc4\x91\x9f\xa7\x63\xe2\x2b\x18\x9b\xf2\x57\x92\xcc\xc7\xf1\x24\x64\x9e\x0e\x46\x81\x1f\xc4\x81\x4f\x7e\x53\x3f\xde\xa9\x1f\xf4\x77\x14\x93\xb1\xf8\xfb\x9c\xf4\x83\x50\x86\x3e\xeb\xd3\xe1\x1a\x46\xf4\xc5\x1a\x9c\x0b\xf6\x7e\xd1\xbc\xcd\xa3\x78\x01\x98\xf7\x6a\xfc\x52\xac\x21\xfd\x9d\xc3\x72\x60\xad\xc9\x65\xb4\xaf\xa1\x79\x5f\xbb\x5b\x7f\x2d\x20\x72\xd1\xe5\x6c\x37\xb4\x3d\x50\x7b\x3b\x0c\x22\xe8\x7c\x8e\x8b\x47\x81\x0f\x3d\x2a\xfa\x73\x82\x45\xa7\x60\x7d\x2e\x0e\x5d\xf0\x77\x43\x7f\xdf\x4c\xc9\xa2\x5d\x84\xcb\x60\xc9\xee\x25\xb6\xe0\x16\x85\x80\x5e\x1e\x09\xdd\x5e\x1e\x0a\xdd\x5e\x1e\x0b\x3d\x5a\x1e\x52\x1f\x21\x3f\x58\x10\x54\x5f\x95\xc7\xa2\xd8\xf0\xdf\x84\x0b\x11\xb4\x30\x30\xfd\x37\xc3\xfe\xc7\xbf\x26\xfb\x6c\x31\xc6\x6b\x21\x61\xc5\x16\xe9\xd6\xfe\x34\x41\x75\x5f\xde\x4d\xc4\x3d\x81\xa6\x2f\x0d\xe6\xfe\x00\xbf\x7e\x7f\xf0\xeb\x1f\xf3\xc1\xd8\xc5\x64\xa9\x99\xe3\xdc\x92\x36\xd8\xd1\xd2\x54\x4d\x61\xb1\xf3\x39\x5f\x25\xa7\x41\xb9\x2f\x0a\xcc\x6e\x36\x07\xef\x09\x97\x9d\xd7\x6d\x41\xd0\xf4\xc5\x80\xcb\x3f\x6a\x51\x1f\xd5\xa8\x5c\xa8\xf5\x79\xe0\xc4\xfd\x93\x98\x8c\x5e\x05\x93\x88\xbc\x24\xf8\x3a\x81\x5d\x4f\x47\x18\x32\x1c\xfb\xec\x49\x79\x26\x03\x44\xc8\x0c\x26\xc0\x72\x11\xb9\x3c\x2c\xbb\x04\x79\x2e\x0d\x49\x3d\xe7\x75\x28\xe5\x86\x47\xa9\x9b\x51\x06\x04\x1e\xf3\xfd\x28\x45\x2b\x5e\x24\x10\xe7\x73\x83\xd5\x55\x6b\x55\xb6\xf1\x2f\xef\xf5\x3c\xd5\x6e\xa5\x70\xd2\xfc\x16\x88\xf8\x16\xc5\x4f\x57\x50\xfc\xb4\x54\xf1\x53\x53\xf1\x1f\xf5\xe2\x3f\x8a\x63\x8a\x8f\xa6\xc4\xbc\xc4\xb7\xd8\x1f\x90\xff\x91\xa9\x9f\xf2\xc4\x21\x0d\x46\x45\x23\xaf\x02\x4c\x65\x72\x11\xa9\x8e\x99\x8c\x5a\xaa\xe0\xff\x01\xe4\x1a\x95\x87\xc7\x8f\xf5\x80\x8b\xc6\xa5\x6c\xd7\xe7\x89\x23\x03\x05\x04\x16\xdc\x19\xb0\x83\xab\xa7\xe6\x70\xc0\x7f\x6f\xc8\xf6\x51\xc8\x4c\x73\xc8\x18\xc3\x75\x32\xf2\x4c\x70\x11\x08\xf4\x5b\x74\xc8\x2e\x2e\x5c\xa8\xca\xca\x21\x0c\x80\x49\x99\x60\x6a\x4e\xf0\x11\x1d\x16\xdd\x8b\x2d\xd0\x2d\x55\x41\xc0\x1f\x28\x2b\x47\x0d\xbe\x44\x9f\x3f\xa3\xca\x66\x25\x29\x2e\x0e\x02\x2f\x76\xc7\x6f\x98\x51\x85\x0e\xd1\xc5\x27\xee\x27\x8e\x49\x9c\xfe\xa6\x99\xb4\x1e\x61\x71\x47\x78\x2c\x90\xfe\x06\xba\x15\x09\x10\x7b\x6b\xa5\xd0\x5f\xe1\xa4\x97\x13\x9e\x6a\x84\xa7\x26\xc2\xd3\x3c\xc2\xd3\x2c\xe1\x4b\x05\x0f\xfe\x23\xbc\xaa\xae\x6c\x2a\xd7\x52\xf4\x0a\xd6\xc7\x93\x68\xa8\xbc\xfa\x63\x1c\x7d\xd4\x38\xfa\x68\xe2\xe8\x63\x1e\x47\x1f\xd3\x1c\x19\xae\x5e\xf1\x51\xb7\xdc\xc3\x12\xf3\x6d\x3e\x2f\x0f\x03\xfa\xa5\xeb\x13\x1d\x04\x5a\x05\x37\x37\x80\x9a\x2b\x90\xcf\xb2\xe3\x59\x3a\x9e\x73\x16\xc7\x59\xd4\x06\xea\x51\xee\x55\xca\x8a\xea\x31\x2d\x51\x8f\xe9\xdc\xf5\x28\x7c\x06\x41\x57\xed\xf6\xad\x05\x4b\xef\xe4\xce\x26\x5b\x45\x4b\x0d\x93\x83\x29\x03\xac\xfe\x48\xc7\x10\x31\xf8\x89\x2c\x6c\xcd\xfc\x49\x03\x58\xfe\x48\x69\xc8\x13\x29\x5d\x3b\xbb\xa9\xef\x74\x2a\xee\x53\x84\x93\xe4\xf7\xa4\xec\x69\x42\xee\x7e\x21\x97\xd7\x98\x51\x93\x18\x3a\xdd\x8c\x4d\x64\xa9\x69\xc0\xb6\xe9\x66\xcc\x20\xbe\x8c\xd3\x40\x49\xd8\x5d\x90\xfb\xc3\x6c\x56\xb0\x6c\x74\xdc\xe6\x76\xa3\x08\xb7\x99\x13\x2a\x8f\xd5\x0c\x10\x44\x47\xc1\x78\x1a\xc2\xd1\x6c\xd5\xae\xa1\x56\xa3\xd9\xde\x1c\xb3\x4b\x7a\x16\xfa\x11\xdb\xa4\x17\x04\x1f\x2c\x74\xe2\xdb\xf5\x35\x04\x19\xce\x87\x6e\x24\xe0\xf2\xec\xc0\x21\xc8\x8d\x90\xe7\xda\xc4\x8f\x88\x83\x26\x80\x60\x14\x0f\x09\x7a\x75\x72\x2e\x82\x51\x3f\x98\xf8\x0e\x72\x7d\x1a\x41\x49\xbc\x3c\x39\x3a\x7e\x7d\x76\x8c\xfa\xae\x47\x78\x30\x0a\x83\x20\xe6\x57\x4a\x83\x10\x20\x3b\x62\xa5\xa0\x38\x24\x84\x33\xb0\x25\xb0\x8f\x6c\xec\xff\x12\x91\x17\xa7\xaf\xe8\x24\xf4\x48\x60\x62\xdd\xb8\xbe\x13\xdc\x30\xc5\xa7\xdc\xf4\x5d\x9f\x38\x15\xaa\x40\x2c\xa6\xee\x04\x36\x00\xf6\x18\x82\xf4\x43\x60\x2e\x7f\xca\xf0\x99\x3b\x1a\x7b\x70\xcb\x6c\x30\x8c\x6f\xd8\x49\x36\x13\x3b\xc2\x51\xe4\x46\xb1\xeb\x0f\xd0\x8d\x1b\x0f\x19\x44\x0a\x89\xf9\xc5\x58\xec\x3b\xc8\x0e\xfc\x98\xdc\xc6\x28\xe8\x53\x4a\xff\x0d\xc2\x0f\x24\xac\xa3\x9f\x89\x37\x8e\x10\x86\x8b\x8b\x74\xed\x34\xf1\xc0\x1e\x19\x13\xdf\x21\xbe\xed\x92\x08\xf2\xc2\x7d\x8e\x88\x89\x39\x0e\x50\x48\x70\x44\xa9\xf6\x82\x49\x4c\x89\xdd\x0c\x09\x20\x74\x05\x21\xa0\x71\xc5\x43\x32\x45\x38\x04\x91\x62\x5e\x92\x85\xc8\x35\xf1\xe9\x7c\x03\xb1\x3e\xb9\x26\x21\x72\x7d\xdb\x9b\x38\x0c\xcf\x65\x84\x5d\x9f\xd2\xfa\x1d\xcc\x66\x96\xe9\xf7\x84\x93\x69\x1d\x44\x4e\xe5\x7d\x7c\x4b\xec\x09\x7b\x9e\x79\xed\x86\x81\x0f\x42\x3c\x64\xa7\xa8\xb2\x2d\xba\xc9\x4f\x2b\x89\x60\x64\xa3\xae\x00\x0b\x63\xdf\xe9\x46\x52\x32\xc0\x3b\xf3\x97\x6e\x14\x13\x1f\xf2\x25\x6d\xfd\xf8\x31\x6d\x6c\xde\x70\xd8\x71\xb4\x94\xb4\xff\x89\xa8\x38\xc6\xf6\x10\x62\x6b\x0a\xe1\x5f\x5d\x72\x43\xbb\x49\x86\x24\xcf\x16\xd9\x21\x21\x3e\x5f\xb7\x9e\xf8\x8c\xd1\x2e\x7a\x94\xa4\xde\xda\x42\x3f\x82\xc0\x6f\x2c\xa6\xa2\x6e\xc4\x50\x84\x36\xd1\x08\x14\xc3\x1e\x82\xc5\xca\xf5\xba\x3f\x89\x27\x21\xa9\xaf\xad\xdd\x1d\xac\xad\x31\x9d\xa9\xf3\x9e\x8a\x0e\x8d\x32\xcd\x76\xfb\xe6\x4a\xbb\x3d\xe2\xb3\x20\xfa\xf5\xd9\x5b\x74\xf2\xfa\xdf\xc7\x47\xe7\x27\xa7\xaf\xd1\x93\xad\x84\xf6\x38\x0c\x6c\x02\x70\x73\x6b\x7f\xd9\x71\x02\xfd\x8b\x2a\x9b\x3d\x24\xf6\x07\x8e\x9f\x06\x8f\x6c\x46\xe3\x78\x2a\xae\x7a\xe6\x21\xcd\xef\x2b\x5d\xff\x97\x71\x14\x87\x04\x8f\xd0\x35\x09\x23\x8e\x41\x44\xbb\x54\x8c\x3c\xae\x74\x75\xf4\x22\x20\x11\xeb\x81\xf8\x03\x65\x34\x0e\x10\xb6\xed\x60\xe2\xc7\x28\x1a\x13\xdb\xed\xbb\x36\x25\x05\x67\x7a\x84\x12\x18\x7b\x38\xee\x07\xe1\x48\xe9\x5c\x9a\x1a\xb3\x9d\x1d\x89\xbf\xc4\xc2\xe9\x08\x40\x15\x10\x4a\x8f\x90\x33\x09\xe9\xa8\x43\x65\xd2\x9b\xf4\x7a\x1e\x41\xe3\x21\x8e\x68\xed\x11\xe2\xf9\x38\x3e\xd2\xa7\x17\xa7\xaf\x80\xfe\x39\x20\x62\xde\x71\x68\x51\x46\x8c\x8d\x75\x6c\x74\x19\xd0\x72\x42\x59\x31\x14\xf8\x75\x9d\x50\xc4\x71\x96\x80\x05\x58\x4a\x03\x5d\xc4\xc0\xfa\x48\x7d\x50\x87\x9b\x47\xf6\x87\x0a\x1d\x93\x2a\x23\x3a\x8d\x06\xd7\x24\xac\xa4\xe8\x08\x45\xbb\x03\x20\xc4\x1e\xb6\x3f\xa0\x23\xf1\x43\xc4\x89\x2c\xe2\xce\x75\xc0\xd1\xa1\x98\x31\xc7\x46\x5b\x8c\x7e\x0f\xc9\x28\xb8\x26\xbf\xa3\x11\x89\x87\x81\xc3\x32\x6d\xc1\xfe\x15\xad\x84\x72\x25\x93\x05\x48\x54\x50\x59\x05\x4b\xf2\x20\xec\x70\x40\x58\x84\x64\x99\x01\x46\x31\xd5\xcd\x09\xaa\x06\xba\x16\xdb\x0c\x93\xf7\xfc\x32\xaf\x72\x58\x1d\xb4\xeb\xa3\x34\xa0\xaa\x5f\x3e\xe7\x25\xb2\xb8\xb9\x0b\x4d\x6e\xa1\xdf\x69\x4e\x9e\xd4\xca\x2a\x43\x66\xa6\x9e\x49\x5c\xb5\x12\xf8\x15\xb4\x61\x94\xe0\x6a\xaa\xe8\x90\xb9\x0a\xcb\x56\x0d\x2c\xb4\xb5\x79\xba\x90\x8d\xc7\xd0\x39\x1f\xfa\x90\xd2\x87\xb8\x50\x54\xf4\x32\x16\xf2\x75\x7a\x11\x9d\x65\xbf\x74\x27\xd2\xca\xcc\xeb\x43\x9f\x94\x7b\xc7\x7c\xea\xac\x13\xff\xba\xfe\xfa\xf4\xc5\xf1\xd5\xf1\xeb\x5f\x99\xa1\x33\x0e\x03\x67\x02\xac\x69\x0f\x51\xec\xc0\x8f\x02\x6a\x14\x00\x14\x6b\xe5\x59\x4c\xd7\x12\x31\x71\xa8\x3a\x79\x52\x6b\x67\x68\x2c\xa2\x66\x21\xa2\x1d\xa5\xd2\x0b\x83\x9b\x08\x26\x57\x1c\x23\x47\xcc\x4c\xd1\x64\x0c\x4b\x8f\xac\xae\xa3\x77\xc1\x24\x44\x78\x3c\xf6\x5c\x9b\xc1\xba\x00\x99\x1b\xd7\xf3\x20\x67\xc8\x30\xea\x50\x14\x8c\x08\x67\xa3\x5e\xc9\x3c\x6d\xc9\x6d\x0e\x6d\xc2\xcd\xeb\xa6\xa2\xdb\xbc\x60\xeb\x24\xad\x11\xb5\x18\xee\xdc\xd4\x68\x4a\xa9\x8d\x59\x68\xe7\xdc\x31\x60\xee\x22\xc3\xa9\xda\xae\xd5\x6a\x19\x3b\xac\xb5\x42\x3b\xec\xef\x64\x58\x6d\x3d\x41\x24\xf2\x5c\x3f\xde\x74\xdc\x08\x90\xb9\xfb\xbd\xcd\x9b\x9b\x9b\x2d\x66\xee\x6f\x4a\x13\x9f\xa7\x66\x6b\x2a\x3c\xa2\xab\x27\x24\x17\x5f\xec\xf6\x0c\x5f\x7c\xa1\xde\x24\x46\x37\x21\x1e\x47\x6c\x35\x13\x87\xd3\x4d\x1b\xc7\xf6\x10\xf5\xbc\xc0\xfe\x50\x47\x27\x3e\x3a\x39\x46\x6e\x8c\xdc\x08\x6c\x2b\xaa\xe3\xb8\x0f\xcb\x24\x00\x57\xce\x21\xcb\x16\x42\x21\x08\xcd\x0f\xe2\x21\xed\x4d\xfd\xc0\x9e\x44\xc4\x49\xe4\x4b\x90\x9e\x09\xfa\x82\x84\x41\xf6\xbd\x29\x27\x23\x0b\xa1\x23\xb5\xfc\xdd\x0b\x9c\x29\x27\x4f\xc9\x4d\x49\xcc\x21\xbd\x65\x09\x62\x08\x7f\xfa\xe2\xf4\xd5\x0b\x9e\xed\x8e\x12\x40\x5c\xcd\x23\xa8\xc6\x24\x0c\x29\x3d\x59\x93\x35\x75\x28\xa7\x79\x39\x7f\x77\xd0\x0a\xb2\xcb\x0c\x48\xfc\x4c\x65\xbf\xea\x04\x76\x0d\x6d\x3d\x51\x72\x3c\xd9\xa2\x1d\x95\x16\x78\x08\xff\x7e\xfe\x2c\x31\xa5\x65\x35\xd2\x2b\xe8\xa7\x49\x54\x17\xc9\x70\xe9\x2c\x36\xc9\xce\x5e\xdc\x25\x39\x53\x2e\x64\xc5\x23\x0b\xda\xfb\xe3\x70\xaa\x47\x3a\x81\x9d\x6a\xb0\xcf\x9f\x21\x90\x0a\x15\x72\x21\xa6\x05\x55\x52\xcb\xe6\x94\x89\xd6\xee\x0c\x03\x44\x5a\x2e\xd9\x75\x56\xfb\xa1\x7f\xd3\xdc\xc9\x6a\xc9\x8d\xce\xc9\x6d\xfc\x3a\x60\xef\x92\x4c\x4b\xa5\xc6\x0e\x5b\x2b\xa5\xfa\xbf\x1f\x6c\xf6\xdc\xf8\xc6\x8d\x88\xda\xe5\x01\xb0\x39\xa2\xea\x82\xd1\xc0\xbd\x26\x3e\x98\x4f\x3e\x25\xcf\x2f\xd2\x47\xb4\x27\xb9\x11\xc2\xb4\x6f\x92\x50\xc6\xd7\x75\x15\x17\xa9\x29\x67\xd5\x60\x12\x93\x90\xfe\xb2\x90\xeb\xfb\xec\x27\x53\x0e\x80\x28\x90\xd1\xf0\x04\x28\x95\x42\xaa\x0f\x73\x50\xb0\xa6\x99\xc5\x49\x4e\x40\x9b\xcb\xc9\x09\x2e\x08\xf4\x8c\x89\xd8\x12\x1a\xb5\x12\x05\x2a\xf9\x92\xd2\x52\xf9\x66\x56\xbd\x3e\xc6\x74\xd8\x80\xbc\x29\xfa\x15\x91\xb9\x42\x95\x22\x61\x4d\x2f\x41\x86\xd7\x45\x72\x85\x9b\x3c\x11\xd5\xed\x60\x44\x0b\x16\xc3\x99\xd8\xfe\x4d\xd1\x7e\xf4\x68\x76\x16\xa5\x34\xf4\x18\x81\xf7\xb3\x94\xa5\x95\x11\xa1\xb1\xbf\xab\x92\xca\xf6\xf5\xed\x87\xad\x54\xb6\x95\x2a\xa0\xe8\x95\x75\x0e\x9f\x56\x58\xcf\x74\xfd\xf1\x24\xde\x8a\xc9\x6d\x8c\x43\x82\xe9\xc4\x04\xf3\x25\xcb\x2e\x7b\x24\x84\x81\x4e\xfa\x52\xa3\xb6\xb6\xd0\xc9\xf1\x1e\xb2\xb1\xcf\xbd\x0e\xac\x1f\x61\xbf\x12\x23\x6a\x18\xb2\x0c\x94\x5a\xcc\x50\x9e\xe3\x30\xa0\x73\xac\x8d\xa9\x64\x61\x5a\x47\xae\x7f\xed\x02\x5e\xb5\xc5\x88\xd1\x39\x9e\xf8\x74\x7c\x71\x2c\x3a\x4e\x00\xac\x33\xb8\x16\xd0\x6d\x5d\x6c\xdb\x64\xcc\x4c\x5d\x28\xa5\xbe\x0e\x78\xf0\xd4\x2a\xf8\xe0\xfa\x4e\x04\x5b\xb1\x94\x20\xdb\x4f\x8d\x58\x76\x1c\x52\xe3\x21\xa0\x6d\x4f\xfc\x88\x5a\xbc\xd8\x77\x50\x3f\xc4\x03\x2a\x5a\xca\x28\x89\xe8\x1c\xac\x4c\x5a\x30\x32\x41\x11\xd5\x5a\x66\x72\x32\x2b\xa5\x94\x53\x56\x23\x3b\x4b\x69\x64\xa6\xa4\x4f\x68\x9d\x1f\x3b\xac\x77\xcd\x63\x77\x73\x1b\x2e\xbc\x92\xe8\x15\xe4\x15\x60\xe8\x59\xce\x76\x4a\x70\x66\x66\x42\xc5\xdc\x48\xc6\x64\x6e\x2b\xb8\xd4\xc8\x40\x15\x91\xa6\x52\xe3\x6a\x92\x38\xa6\x70\x63\xba\x14\xe1\xc6\x94\xe2\x7d\xe2\x11\x5b\x80\xf0\x71\xc0\x8d\x0f\x60\x49\x90\x66\x7b\x77\xb5\x02\x7d\x64\x5c\x27\xec\xc2\xe9\xb5\x31\x6e\xa7\x59\xab\xa6\x21\xe3\x39\xcb\x66\x8f\x35\x46\x37\x48\xed\xbd\x5a\xb5\xe2\xb8\xd7\x95\x9a\x85\x2a\x18\x9e\xdc\x0d\x88\xba\x44\x02\x07\x40\x9c\xee\x2e\x78\x50\xa9\xd5\x31\x95\xec\xee\xc1\x1a\x9c\x8e\xa5\xe5\xb2\xb7\x94\x5c\x98\x5d\xc0\x77\x10\xcc\x56\x41\xa7\x59\x3b\x80\x74\xd2\x62\xcc\x71\x96\xb7\x53\x93\x67\x2f\x07\x6b\x5b\x5b\x28\x65\x83\xea\xe7\x31\x54\x0d\x2a\x6c\x07\x83\xcd\x5f\x9e\x83\x4e\x8e\x39\x3f\xe8\x50\x32\x55\x15\xd9\xa1\x65\x32\xa1\x99\x43\x9e\x12\x4a\x2b\x14\x2d\x52\xac\xe0\xd4\x8b\x41\x9a\xb4\x8b\x3e\xdd\x99\x55\xb1\xd0\xe1\x6a\x29\x91\x0f\x71\x94\x23\xc5\x9d\x16\x97\x76\x1c\x9c\x14\x36\xcb\xae\x48\x08\x17\xc6\xe1\xc1\xc3\x69\x3f\xcf\xb0\x6b\xee\xd6\xaa\x62\x07\x91\xe6\x39\x39\xbe\x7a\xf3\xf6\xf4\xfc\x34\xd7\x49\x69\xb3\x56\xad\x88\x44\xb4\x7b\x16\xc9\x55\x3c\x55\x80\x97\xd2\xc9\x4d\x3a\x4a\x5c\x56\x82\x27\x92\x17\xaa\x98\xbb\x2a\xe9\xf9\x3f\x62\x1e\x03\x2f\xe4\xc5\x9c\x0f\xec\x42\x11\x78\xfe\xe0\xde\xba\x4e\x6b\x30\xdc\xd0\xaf\x47\x87\xb2\x06\xe0\xdf\xa7\x7a\xca\x3c\x72\x51\x15\x61\xc4\xd8\x6d\x8b\x0f\x84\xc1\x4b\x6e\x6d\xa1\x17\x01\x9d\xac\x88\x3f\x19\xa1\xde\x64\x80\x1e\xa3\xa1\xeb\x38\xc4\xa7\xd9\xa2\x35\x84\x6e\x86\x74\x5e\xa8\x42\x15\x04\x6c\xdc\x0f\xc8\x65\x45\x26\x25\xa0\x43\x56\xcb\x0b\x77\x63\xe3\x52\x1a\x73\xff\x8f\xda\x04\x55\xc6\x00\x67\xe8\xf3\x67\x23\x43\x77\x89\x1a\xb2\x68\xa3\xa2\x6d\x2f\x77\x42\xbc\xb5\x85\x9a\xfb\xf5\x66\xbd\x55\xdf\x47\x5b\xa8\xd9\xa9\xb7\xea\xed\x7a\x2b\xc7\xd3\xc8\x69\xad\xbc\x62\x16\xeb\x65\x7b\x51\x1d\x03\xa5\x01\xd2\xc0\x58\xe2\x62\x48\xba\x10\x32\xe9\xa1\xb1\x3a\xba\x27\xb9\x53\xd6\x50\x4c\x21\xb9\x3e\x9e\xca\xb5\x2e\x6f\x5d\xa9\x50\x35\x39\xac\x5f\x88\xb0\xcb\xd4\xba\xf8\xb4\xae\x38\x32\x42\x87\xea\xb4\x47\x55\xf0\x54\xf5\xa6\xa5\xa5\x4d\x19\xd0\x5a\x9c\x5a\x4d\x94\xf8\xa7\xd2\x89\x31\xc9\x3f\xd5\xe4\xd4\xe5\xab\x70\x93\x06\x2d\x77\xd8\xb8\xb5\x85\x46\x41\x14\x8b\x62\xd9\x8e\x72\x84\x7a\x53\x74\x7c\xb6\x83\xa2\x61\x30\xf1\x1c\x61\xa0\x8d\x43\x77\xe4\xd2\x05\x79\x04\x0d\xf9\x4f\x7e\x3b\x22\xc7\x1d\xe0\x2e\x6f\x6f\x3b\x08\xf3\x56\xa3\x2d\xa1\x48\x7d\xec\x7a\xb9\x5a\xd9\x2c\x1e\xf3\xff\x73\xfc\x8e\xd6\x93\xd8\xc9\xb8\xd4\xf7\xd1\x21\xaa\xd2\x82\xeb\xbc\x5e\x9f\x3f\xa3\x4f\x77\xb5\x8b\xff\x1c\xbf\xbb\x4c\x5c\xf1\xc0\xa7\x18\x8e\xc8\xed\x98\x1a\x61\xb0\xd5\x49\x6e\xc7\x2c\xe9\x21\x10\xae\xf6\x7d\x50\x25\x5e\xe1\x2a\xff\x5b\x3f\x43\x1b\x22\xac\xfe\x23\x7a\xc2\x6a\x51\x4d\x39\xfa\xf3\xab\xcd\xda\x01\x6d\x2d\x54\x61\xa5\x56\xa0\x55\x6a\xe6\xc6\x5c\x6e\xc7\x32\x23\x25\xe3\x64\xdf\x30\xd8\x18\xdb\xcb\x6d\xa5\x18\x67\xa4\xd6\x3e\x6f\xdd\x81\x17\xf4\xb0\x97\x6f\x53\xb0\x54\x02\x4d\x25\x8f\x65\x18\x70\x62\x12\xe2\x38\x08\xf3\xea\xb6\x2f\x12\x9e\x9f\x5e\x9d\x9d\xbf\x3d\x79\xfd\xd3\xd5\xf9\xb3\x9f\xf2\x4a\x6e\xd4\xaa\x95\x38\x60\xbe\x68\xce\xf1\xa0\x22\x7c\xf0\xbd\x38\x7d\x05\x05\xf5\x3c\x78\x22\x5f\xad\x1c\x9d\x9d\xbd\x9d\x78\xe4\xa5\x1b\xc5\xd6\xd1\xd9\xd9\x59\x3c\xf5\xc8\x0b\x62\x7b\x98\xe3\x79\x1f\x9d\x9d\x01\x0e\x1e\x4b\xe0\xb9\xc4\x8f\xdf\x12\x1b\x36\xb7\xad\x17\xa7\xaf\xd4\xdf\xac\x34\xf8\xaa\xa0\x8d\x35\x84\x2a\x2f\x4e\x5f\x9d\x07\x1f\x88\xcf\x52\xe0\x18\x9f\x87\xd8\x8f\xfa\x04\x90\xf0\x20\xf0\x47\x97\x97\xfd\xf3\xf9\xab\x97\xcf\x3c\xef\x28\xf0\x3c\x76\x61\x05\x42\x52\x9f\x3f\x06\xe1\x88\x1b\x39\xf0\x7d\x46\x68\xac\x08\xe1\x85\xbe\x22\x8e\x8b\x81\xe6\x2b\x77\x04\x8f\x09\xc0\xb5\x8e\xf5\x1a\x8f\x88\x43\x97\x3b\xaf\xf0\xd8\xa2\x7f\x21\xcd\x1b\xec\xd2\x1a\xfd\x39\x21\x11\xab\xc8\x1b\x6f\x32\x70\x7d\xfe\x87\xe5\x3c\xfb\xf5\xa7\x97\x30\xa9\x42\x82\xb3\x5f\x7f\x62\xa8\xc1\x6a\x4d\xcf\x7e\xfd\xe9\x0d\x8e\x87\x67\x64\x20\xd2\x00\x76\x95\xf8\x50\x44\x73\xf6\xeb\x4f\x4c\x0a\x41\xc8\x44\x70\x06\x6b\xe1\xe7\x93\x7e\x9f\x93\x84\x36\x38\x1b\x12\xc2\xb2\x9f\x93\xdb\xf8\x3c\xc4\xf6\x87\x23\xde\x0a\xbc\x48\x19\xce\x52\x05\x13\x1b\xf8\xab\xd4\xea\xd1\xd8\x73\xe3\x6a\xc5\x82\x56\x37\xf9\xd8\x54\xb5\x20\xe5\x6a\x93\x0f\x19\xaf\x9f\xbd\x3a\x46\x87\x5a\xc2\x0b\x57\x0e\x28\x49\xb3\xa0\x43\xde\x05\x2e\x68\x0e\x99\x60\xcc\xa7\x40\x25\xe1\xe3\xc7\xca\x97\x3e\x5b\x48\xdf\x95\xb0\x7c\x81\x5f\x17\x9a\x96\x5f\xd6\xa0\x0b\xb1\x44\x96\xde\x03\x2c\xe0\x15\x06\x31\xd9\x85\x18\x33\xe8\x30\x09\xa9\x43\x4b\x1e\xd0\x75\x70\x7a\x78\x28\xb3\xfb\x32\x6b\x45\xe9\x04\x3e\xe1\x37\x5b\x35\x2b\x5d\x3a\x09\x84\x3f\x16\xa2\xe9\xba\xe8\xd1\x23\xfa\x17\x99\xed\xf3\xed\xe5\xd6\xde\x5b\x5b\x68\xb7\xde\xaa\xb7\xd0\x49\xc4\xfc\xc9\x09\xa7\x70\x35\x3e\x63\xe5\x59\xd9\xcd\xce\x9e\x69\x32\x02\x22\x75\x97\x11\xd3\x0c\x13\x37\x29\x40\xab\xb3\x1d\xf4\x59\x18\xb5\x2c\x20\x49\xc5\x5c\xd1\x32\x4b\xf9\x32\xf6\xe1\x6e\x62\x1f\x6e\x2b\x06\x95\xe2\xfd\x96\x76\xfd\x48\x18\x89\xff\xa4\x46\x73\xee\xac\xbd\x9f\x0c\xd9\x0e\xf1\xff\x93\x9f\xb4\xb9\xd3\xae\x09\xff\x75\x15\xd6\x87\x2a\x16\x9c\xac\x32\xc5\x86\xce\xc7\x6b\x51\xef\x6b\xa6\x5e\x9a\x33\x4d\xac\x66\xce\x55\x01\x43\x05\xa8\xd1\x97\xf0\x98\x33\xe5\x2e\xb7\xeb\x00\x1d\xf9\xe4\x38\xaf\xfe\x4d\x31\xbb\xb1\xc5\xe7\x0b\x12\xd9\x79\xae\xb2\xf7\xe6\x5d\x15\xc6\xc1\x1b\x61\x90\xe5\xaa\xab\x9c\x5c\x67\x1b\xfd\x27\xc7\x7b\x57\x2f\x4e\x5f\x5d\xbd\x38\xfe\xf1\xe4\x75\x5e\x85\x5a\x6d\x61\xd6\x0d\x4e\xdf\xbc\xc8\x6b\xb0\x17\xd2\x63\x6f\xaa\x79\xf3\x76\x64\x9e\x32\x72\xdd\xbc\x16\x4e\x08\xd2\x26\x7d\xa3\x1a\xfb\x27\x9a\xb5\xff\x06\xc2\xa4\x5c\xaa\x6f\x94\x1b\x01\x74\x04\xd5\x2b\x59\xcb\x1e\x68\x51\x3e\x58\x19\x99\x0d\x42\xb4\xf5\x84\x9d\x8e\x23\xaa\x3e\xfa\xd2\xe2\x4d\xb2\xa6\x48\x5a\xba\xfa\x68\x7c\x72\x5c\xef\xb3\xd3\x6b\x48\x64\xa1\xd3\x8b\x37\x97\x39\x8a\x58\x66\x9b\x07\x74\x2e\x93\x73\x05\xbb\x15\x33\x8c\xaf\x82\x61\x5d\x5c\x2d\x89\x42\xdb\x82\x23\x5d\xd6\x3a\x19\x4f\xdc\xa1\xad\xde\x34\x81\xb3\xdf\xc7\x8f\x55\xef\xda\xb5\xb4\xab\xed\xd0\xbe\x48\x5c\x74\xc2\x71\x02\x4c\x70\xa2\x40\x70\x0e\x2d\x12\xd5\xb4\x15\x15\xf7\xc5\x6d\x12\x73\xa7\xcc\x8a\x7b\xf6\xe6\xa8\xe6\x6c\x99\x6d\x8c\x58\xb4\xce\x3d\x18\x6e\x7e\x74\x89\xe7\x28\x67\x5a\x55\x37\xce\x73\xbf\x0c\x67\xb9\x7a\x46\x38\xca\x4d\xce\xe0\x1f\x3f\x4e\x11\xa6\xe2\x74\x63\xb9\x37\x91\xde\x84\x85\xa7\x26\x1b\xa8\xd2\x45\xae\x6f\x07\x61\x48\x87\x12\xd7\xbf\x0e\xd8\x6d\x11\xbe\x15\x7b\x37\x63\x33\xb6\xb3\xf4\xb2\x12\x4e\xf5\xa3\x80\xae\x28\x5d\x7f\x80\xe8\x64\xc8\x0d\x0d\x70\xd2\xc2\x2e\x33\x81\x1a\xd8\x5e\x10\xf1\x24\x70\xa9\x86\xed\x79\xf9\x85\xa3\xe0\xce\x0c\xad\x14\x65\x59\xa8\xef\x5b\xc2\xb2\x20\x7e\x1c\xba\x62\x03\x2b\xd3\xf5\x79\x2c\x7a\x4a\x17\x6d\xa2\xf8\x2a\xb3\x57\x2e\x1a\x97\x9c\xca\x45\xf3\xb2\x46\x07\x2a\x9f\xc7\xf0\xcd\xa7\xdd\xfa\x76\x7d\x47\x9a\x52\x80\x0b\xa3\xf0\x60\x07\xa3\xb1\x47\xe0\x7c\xcd\x78\x26\xce\xb6\xc8\x62\x86\x63\x0d\x79\x2e\x2a\x8c\xab\x0a\x57\x7f\xaa\x46\x34\x85\xa6\x1a\x35\x29\x25\x1a\xc7\xc6\x19\x41\x40\xe0\x81\x32\xed\x10\xc7\x6e\x86\x86\x5e\x6e\xc9\x49\x1b\x7a\x48\xec\x0f\x88\xf9\xb2\x87\x57\x13\xcc\x0c\x12\x8c\xcc\xb7\x70\x3b\x39\x3f\x7e\xfb\xec\xfc\xf4\x6d\xd1\x9a\x4d\x50\x16\x3b\x4a\x50\x9e\xd8\x50\x62\xb6\x58\xe1\x7e\x52\xfe\x7e\x71\x9c\xed\x7a\xd5\x94\x79\xcc\xce\x96\x61\x47\x21\x29\xf7\x42\xb0\x7d\xc9\xa3\xcd\x43\x7c\x67\xb9\x55\x36\xd8\x11\x1e\x8e\xa2\x5c\xfb\xb4\xd5\xd9\x5e\x42\x8e\xa5\x1a\xa9\xd4\x1e\x43\xab\x5d\xa3\x26\x81\x20\xf8\x0a\x76\x95\x72\x8f\x97\xd8\xb9\x92\xa2\xd5\xb2\x39\x12\xb9\x82\x2e\x7f\xfe\x4c\xc3\x2a\xff\xfa\x97\xe4\x5c\x86\x27\xcb\x1a\x2e\x21\x5a\xc2\xa5\xb9\x15\x96\x3b\x4a\xde\xda\xa2\xc6\x09\xbc\x20\x89\xf1\x00\xdc\x6e\x31\x23\xbb\x5d\xdf\xc9\x6c\x67\xd6\xc5\xfe\x42\xb5\xdc\xd2\x02\xf6\x2e\xe6\xda\xb1\xd8\xda\x42\xc7\x67\x6d\x74\x13\x06\xfe\x00\x0d\x49\x48\x58\x97\x78\xfb\x13\x9c\xa8\xf7\xab\xc6\x63\x27\xe9\x04\xfb\x00\xdd\x55\x6b\x62\x15\xc2\xc3\x2a\x07\x50\xc9\xbe\xbc\x9c\x1a\x50\xe3\xb0\xd9\x44\x67\x60\x83\xa1\x67\xb6\x4d\xa2\x08\xbd\x20\xbe\x4b\x1c\x65\xc4\x8e\xc3\xe9\x4f\x24\xce\xcc\x93\x1f\x84\x8b\x83\xcc\x80\xeb\xc6\x72\x7e\x2f\x32\xb4\x8c\xb7\x07\xb3\x9a\x04\x7b\xcb\x16\x3a\xb7\xd0\x73\xed\xac\x11\x7a\x64\xd2\xa5\x9f\xa2\xca\x2f\xc9\x25\xa9\xae\x48\x00\x57\xc5\x9e\xa2\xca\xeb\x89\xc7\xdd\x30\x6e\x6d\xa1\x7f\xfd\x4b\x11\x36\xb2\x71\x44\x20\x46\x3e\x8b\xa9\x9e\x53\x73\x13\xaa\x5d\x3d\x4d\xde\x2d\xba\x71\xcd\xa2\xad\xc8\x05\xcb\x2e\x10\x57\xd0\x53\x74\x2e\x08\xf7\x26\xae\x17\xbb\x7e\x8a\x2a\x6d\xb4\xa7\xd0\x68\xa7\x35\x91\x92\xb6\xad\x6c\x2d\xd9\x26\x3c\x43\xf5\x39\x6f\xe4\x53\x5e\x14\xdf\x61\x04\xc3\x4a\xee\x63\x63\xcf\x23\x24\xb5\x85\xfd\x54\x6d\x6f\xd4\xa5\x22\x33\xf5\x94\xe5\x96\xd9\x65\x4f\x1e\x67\x18\x5a\xe7\xef\xde\x1c\x2b\xb6\x94\x3c\x20\xa4\x0d\x0f\x23\x42\xfd\x8a\x8d\xdb\x2c\x61\xda\x1c\xaa\x9c\xf8\x70\x71\x25\x76\x7b\x1e\x11\xb7\x63\x43\x0b\x6e\xcd\xd2\x1c\x70\x62\xcd\x39\x72\x4a\x1d\x54\x77\x96\x5b\x94\xa7\xef\x9d\x89\x05\x52\x72\xb2\x0f\x5a\x35\x21\x7c\xa1\x45\xe2\x17\x1a\xa2\xa7\xba\x46\x52\x62\xaa\x29\xff\xfe\xca\x61\x86\x8c\x61\x57\xfd\xb8\x42\xa6\x4e\x2a\x64\x22\xe9\x4f\x1c\xc4\x9d\xa2\x2a\x93\xcb\x1e\x25\x93\xa7\xe9\x68\x40\xa4\x9f\x3f\x2b\x11\xe2\x31\x74\x45\x06\xf1\xdd\x0f\x21\x0a\x61\x49\x1c\xa6\xea\x98\xb9\xea\xd0\x59\x6e\xf5\x9e\x6e\x0a\xf3\x31\xbf\x24\xb3\x9e\x34\xd1\xba\xc5\x07\x1d\xd8\xb9\xa2\xad\x05\x67\xf7\xfc\x72\x0e\xec\x48\x8c\xb1\x4d\xe0\xc6\x0c\x7f\x35\x18\xf8\x7d\xcf\xb5\xe3\x88\x9a\x4a\xe2\x12\x0d\xb9\x8d\x93\x37\x45\x7f\x00\x5c\xb5\x90\x01\xfb\xaa\xec\x6c\xe3\x4e\xc7\xe9\xec\xee\xf5\xf7\x3a\x3b\x4e\xab\xb3\xe7\xd8\xed\xed\x4e\xaf\xb1\xbf\x8d\x5b\xb8\xd5\x6b\x57\x98\x96\x44\x43\x42\xe2\xe8\x2d\xdc\xbe\x0e\xa7\x0a\x99\x4c\x44\xc5\xd9\xee\x39\x8d\x1e\xc6\x76\xcf\xee\xb4\x7a\x3d\x67\x7b\xaf\xd7\xeb\xed\x93\x5e\x6b\xbb\xbd\xbd\x4d\x6c\x87\x53\x1c\x61\x1f\x0f\x48\xa8\xb2\xa4\x04\x55\x7a\xbb\x3b\x7b\xbd\xdd\xbd\xfd\xe6\x7e\xa7\xb1\xdd\xef\xe1\x7d\x87\xb4\xec\x46\xbb\xb3\xdd\xb1\x3b\xb6\xd3\xc6\x2a\x5f\xa7\xe0\xf2\x39\x4a\x73\x95\x04\x57\x76\xfa\x76\x67\xb7\xe1\xec\xf4\x9c\x9d\x66\x7b\xaf\xbd\xd7\xdc\x77\x1a\xfd\x7d\xb2\xbb\xdd\xd8\xb5\xb7\x3b\x2d\xa7\x92\x6d\xf9\xe5\x6e\x45\xac\xbc\xe5\x45\xcd\xd8\xf2\x5f\xa9\x2a\x0b\xf8\x89\xf8\xd4\x40\x61\xae\xe9\x79\x47\xd6\x9b\x48\x09\x10\x87\x0d\x4a\x10\x6c\x75\x47\xaf\x58\x03\x64\xc2\x0d\xed\x4e\x3b\xce\xd4\xc7\x23\xd7\x86\xad\x72\x4a\x5e\xe9\xb2\xd0\x36\x57\x86\x34\xc6\x93\x1c\x38\xf0\x9d\x25\xa2\x4a\x9a\x5a\x85\x09\x8a\xf8\x93\x11\xdb\x1d\x67\xd2\xb2\xd6\x50\xea\x42\xcc\x80\xc4\xd5\xd4\xe8\x72\x05\x7e\x02\x83\xf1\x5b\xc6\x84\x78\x4d\x90\xe1\xb8\x76\x51\xe1\x63\x05\x5b\x28\xdd\xb1\x1b\x34\x50\xbb\x8c\x68\xcc\x16\xf3\x7e\x99\xba\xe9\xb4\xee\xa3\x66\x7a\x09\xb3\xeb\x95\xa8\x82\xb9\xc9\xb6\xcb\x57\x8b\x93\xba\xbf\x5a\xf1\x02\x8a\x2a\xa5\xa8\xbc\x71\xe9\xd1\x2c\x53\x1d\x41\xe4\x3e\x6a\x22\x68\x17\x55\x42\x76\x64\xa3\x81\xbf\xbb\x53\xa6\x0e\x8c\xc6\x7d\xd4\x80\x51\x2e\xe2\x3f\x7f\xa8\x32\x76\x9d\x9d\x52\xc3\x42\x0e\xd1\xfb\xa8\x61\x4e\x51\x45\x55\xfe\x77\x94\xbb\x86\xdd\xd9\x56\x53\xb5\x68\xb2\x9c\x72\xff\x1d\x81\x4b\x7c\xc9\x72\x4e\xba\xa0\xf7\x87\xb2\x06\x0b\x7a\x7f\x50\x3b\x3d\xe8\xfd\xa1\x5a\x7e\x4f\x21\xbc\x8b\x3e\x21\xc9\x73\x17\x82\xee\x0e\xa8\x95\x25\x6e\x2e\x43\x45\x23\x84\x91\x4f\x6e\xe4\xce\x22\x0a\xfa\xe8\xdf\x51\x94\x18\x14\x39\x73\x91\x6a\x43\xb2\x90\x6a\xc0\xa6\x62\x6d\x37\x84\x92\x86\x9a\x2b\xe2\x93\x09\x99\xbd\xc6\xd9\x79\x26\x8e\xf8\xa9\x34\x05\x37\x8c\x0d\x5e\xb2\x42\x82\x2e\x59\x58\xa1\x59\xc0\x8c\xce\x72\x3b\xd9\x2b\x9f\xd4\xd5\x6e\x21\xdc\x89\xa4\xee\x77\x48\x67\x7f\x6a\x21\x2e\x89\xe4\x36\x35\x83\x3e\xa1\x49\x0d\x87\xcc\x0c\x9c\x4b\x3f\x5d\xe6\x50\x57\xe2\xc4\x03\xbc\x51\x07\x63\x38\x5a\x56\x82\xeb\x49\xcf\x01\x38\x2c\x53\xf8\xe7\xcf\xfc\xce\xbd\x1a\x4f\xed\x50\x77\x30\x11\x39\x61\xa1\x01\xa6\xfe\x3a\xd4\x7e\x1d\xb9\xbe\x92\xbc\xa6\x66\xbd\x09\xdd\x58\xcb\x66\x16\xb0\xa8\xb9\x92\x13\xf6\xea\x15\xaa\x70\xed\x55\xbe\x0b\x90\x12\xd5\xf6\xd4\x61\x13\x85\x3b\x3d\x8a\xc0\x45\xea\x1b\x21\x4a\x79\x18\xce\x43\x32\xc2\x3f\x32\x5d\xba\x52\x49\xd6\x58\x9d\x35\xba\x45\x54\x74\x16\x0e\x92\xc5\x8e\x4c\x71\x00\x5d\xb4\xaa\x0f\x04\xb0\x19\x75\x84\x3d\x0f\x9e\xd2\x54\x45\xdf\xb0\xf4\x23\x80\x4f\xe2\x94\x40\x74\xe4\x9c\xb3\x02\x9a\x92\x2d\x6f\x69\xdf\x4c\x96\xb8\xeb\x47\xd8\xf7\x83\x98\x6d\xb9\x63\xb6\x47\x88\x70\xa4\x5c\xc0\x5e\x67\x12\x4f\x1e\xf3\xb1\x99\x2a\x14\xc6\x11\x43\x40\x20\x51\x44\x57\x26\x23\xb8\x7a\x8f\x63\x14\xf8\x04\x8d\x3d\x2c\xfa\x32\xd5\xcb\x8c\x51\x95\xbe\x30\x2d\xbf\xf5\x94\x72\x08\x4f\x8b\x24\x1e\xba\x91\x95\x4a\x2c\x9c\x98\x71\x77\x1a\xb2\xac\x8b\x4b\xb9\xd8\x54\x3b\x65\x55\xcf\x6d\xa1\x0b\xd5\xef\x13\x76\x00\xa9\x84\x6d\xa8\xb0\xe7\xe5\x08\x3d\x41\x6f\xc5\xcb\x6f\x8c\xc0\x94\x64\x2c\xd4\x79\xf4\x16\xdf\x96\xd7\xbd\x44\x61\xc7\xa9\xc2\x2c\xaa\xfb\x89\x52\x38\xd4\x38\x56\xfd\x04\x01\x0e\x12\x3a\x64\xeb\xa1\x3a\x1f\x45\xeb\x10\xaa\xbb\x3d\x16\x99\x59\xdc\x69\x5f\x14\xf8\xe8\xf0\x10\x6d\x36\xc5\xde\xe8\x81\x31\x0b\xbf\xd5\x4a\x17\xf9\x0d\xd8\x1a\x81\x42\x7f\xe0\x6c\x65\x7c\xde\xcb\x7c\x70\x71\x95\x95\x73\xa0\xc4\xb2\x82\xc4\xbb\x61\xfe\x63\x6b\x0b\xfd\xe8\xfa\x0e\xc2\x68\xcc\xdf\xff\x70\x99\x19\xc7\xb7\x14\x6b\xca\x05\x9a\x2c\xfb\x17\xee\xa5\x2e\x18\xf4\x83\xc9\x4f\xbf\x24\x19\x8d\x3d\xd7\x26\x55\xd7\xfa\xff\xd9\x7b\xf7\xb6\x36\x8e\xa4\x51\xfc\x7f\x3e\x45\x67\xcf\xbe\x1e\x29\x16\x42\x80\xb1\xb1\x08\xf1\x3a\xd8\xd9\xf5\x9e\x38\xce\x63\x9c\xcd\xd9\x1f\xeb\x03\xa3\x99\x16\xea\x30\x9a\xd6\x99\x19\x71\x59\x87\xef\xfe\x7b\xba\xaa\xef\x73\xd1\x05\x61\x93\x44\x79\xdf\x67\x8d\x7a\xaa\xef\xd5\xd5\xd5\x75\x25\xbd\x0e\xf1\x47\xef\x8f\xdf\x72\x05\xdf\xb0\xe6\xe3\x20\x44\x4e\xd1\x09\x45\xf7\xa0\x91\xa1\x2a\x9b\x58\x4e\x8b\xda\x64\x62\xb9\xc5\xb3\xd4\xa1\x71\xf5\x18\xc0\xd7\xa6\x06\x25\xab\x46\x21\xe0\x6b\x87\x01\xfe\xf4\x15\x08\xab\x90\xd1\x19\x98\x87\x70\x07\x55\x83\xd7\x6b\x2e\x40\x3b\x64\xbb\x5d\x37\x91\x23\x9e\x5e\xd2\xac\x90\x84\xa4\x08\xa3\x11\x8d\xa5\x8c\x02\x68\x0d\x39\x3a\x3e\x26\x28\x87\x6a\x9a\x9f\x12\xbf\xd6\xcc\x50\x0b\xd7\x1d\xf6\x85\x94\x72\x6d\xcb\xc1\x0f\x59\x52\xd0\xcc\x92\x88\x7b\x4b\xa3\xab\xe1\x21\x55\xe3\x36\xf9\x4e\xbd\x38\x8d\xcd\xd5\x4b\x83\xb3\xda\xf9\x95\xb3\xb4\x15\xfc\x27\x0d\xea\xd3\xd5\xc1\x12\x57\x11\xae\x23\xe9\x66\x3c\x62\xe7\x23\x9a\x17\x72\x33\x31\x04\xb2\x4b\xbe\xea\xf9\xe8\x9a\x05\x72\xe8\xc7\x0b\xd2\x23\x7d\x17\xe0\xa4\x12\x7c\x93\x6c\x7f\xf4\x29\x1a\xa9\x49\x70\xe4\x10\xea\x83\x0d\xbc\x2e\x2b\x79\x44\x1f\xd4\xe3\x14\x9f\xae\x32\xb4\xda\xea\xc4\x3f\xee\x1c\x0a\x7e\x94\xe7\x60\x19\x8a\xc2\x30\xb1\xed\xbf\xb0\x62\x74\x3c\x09\x23\x87\x0b\x77\x3e\xb4\xca\x26\x72\x50\x22\xb1\x86\x04\x2e\xf3\x2d\x8f\x5a\x8e\x5e\x22\x08\x0a\x87\x4c\x1f\x2f\x00\x3b\x1b\x87\x19\x44\x5b\x3e\x39\x09\xf6\x26\xd7\x41\x87\x04\xdb\xbd\xc9\x75\xf0\xf1\xe3\x19\xf9\xd6\x7c\xdd\x9b\x5c\x13\x51\x7e\x70\x06\x95\x06\x3c\x8b\x69\xd6\x27\x27\xc1\x36\xd6\xd9\x11\x55\xa0\x86\xfa\xb4\x3d\xb9\xee\x90\x1d\x59\xc3\xf2\xf9\x35\x93\xb7\x27\x04\x8c\x8e\x63\x2f\x27\xbf\xb6\x9d\xb9\x02\xd2\x6c\x6d\x91\x63\x19\x06\x03\x84\xa9\x24\xa7\x93\x50\xbc\xec\x62\x39\xcb\xae\x6c\xb0\xa2\xbd\x93\xde\x47\xdf\x13\xd7\x1f\x10\x9c\x66\x67\xe5\xdb\x6d\x5f\x98\x6d\x2f\x7c\x07\x57\xbe\x84\x89\xab\x8c\xf6\xb5\xb2\x37\x0b\xe6\x27\x7b\x37\xc8\x69\x76\x29\x59\xf6\x6a\x39\xd1\xd3\xda\x2a\x4d\x2f\x5e\x1f\xf6\x33\x3d\x7f\x2b\x4f\x99\x21\xc8\x35\x07\x47\xf4\x83\x48\x51\x9e\xa3\xd5\xd4\x47\x0d\x07\x14\x70\x9e\x1a\x2d\x73\x14\x6d\x8c\x58\x6d\xdc\x91\x95\xd1\x26\xed\x5f\xfa\x11\xb3\xe1\x5e\xbc\x9f\x26\x54\xeb\x2c\x7e\x60\xe9\x05\xc9\xc4\x26\x80\x65\x8e\xb2\x73\x7f\x0f\x41\x13\xd3\x98\xa4\x34\x17\x27\x4f\x40\xe4\x08\x02\xc6\x45\xf9\x84\xa7\x31\x4b\xcf\xd5\xf7\x28\xcf\xdf\x03\x08\x1b\x92\x01\x2f\x46\x84\x5e\xb3\xbc\xc8\xbd\x80\x00\xaa\xf7\x56\x06\x6b\x22\x2b\xc9\xad\x9b\x26\x54\x26\xd1\x93\x98\x2b\x3f\x2b\x23\x3e\x04\x80\x4e\x1e\x3d\x52\x1f\xbb\xaa\xe3\x36\x31\xdf\xbb\xa2\x9f\x56\x09\xa2\xea\x14\xaf\x32\x96\xc4\xc2\x31\xfb\x56\x74\xe8\xaf\xc2\x2c\x15\x5b\x51\x23\x80\x7c\xe2\x03\x36\x9d\x70\x09\x62\xa4\xce\xda\xe0\xbe\xae\xf9\x9d\x9d\x0a\xe0\xa6\x2e\x0c\x94\xae\xd8\xe8\x2a\xb2\xfd\x6c\xcf\x03\x6c\x6a\x1d\x21\x3e\x13\x61\x82\x54\xb0\xa0\xc9\xda\x19\x6e\x87\x51\xf4\x34\xda\x0d\x9f\xf6\x9e\x0e\x7a\xfb\x3b\x74\x8f\xd2\xe1\x1e\xdd\x7b\xf2\x64\xfb\xc9\x70\x38\x08\x0e\x36\x36\x20\xc7\xb5\x9c\x81\x45\x4e\x4e\xd2\xfc\x23\x91\xb6\x08\x6d\x52\x0b\x40\x7a\x60\xf5\xf1\x26\x05\xdb\x01\x72\x45\xc9\x28\xbc\xa4\x64\xcc\x33\x70\xac\x4f\xe1\xd9\xfe\xcf\xe3\x63\x15\x01\xb1\xab\x94\x8b\x47\x7c\xaa\x32\x05\x54\xb7\xfd\xf8\xb1\x5c\xde\x71\x78\x8d\x87\xf8\x90\x6c\xd3\xed\x9e\x2c\xa5\xe9\x25\x0a\xa3\x4a\x01\xb3\x0c\x37\xf2\x1e\x16\xd1\x16\x3d\x90\xab\x11\x8b\x46\xe4\x5c\x4a\x65\x73\x32\x4d\xd9\xff\x9b\x52\x29\xa5\x00\x5f\x4b\x32\x08\x73\x1a\x13\x08\x14\x02\x43\x04\x72\x41\x7e\x19\x51\x94\x42\xca\xba\x3c\xb3\x0d\xeb\xa5\x14\x31\xee\x20\xd1\x92\x35\xc5\x07\x78\x7f\x61\xf4\x1e\xf2\x0b\x85\xb4\xb1\x18\xeb\x4d\x3f\xf0\xec\x0a\xe2\xd9\x7a\x7c\xfc\x1e\xfe\xa5\x61\x34\x02\x5b\x00\x0c\x1d\x20\xde\x24\x33\xae\x1c\x63\x7b\x22\x1a\x35\x2b\xdc\xb3\xd9\x5e\x03\x8e\xe4\xce\x79\x38\xd8\xf5\x1e\x1f\x92\x6d\x2b\xe2\xb8\xfd\xe9\x5b\xbd\x29\x86\x89\x6f\xf5\x3a\xe6\x2c\x5b\x23\x94\x9e\xc0\x1d\x12\x9c\xfc\xf3\xf8\xf8\x23\xf9\x37\x9f\xca\x58\xa7\x80\x29\x21\x19\xd3\x31\xcf\x6e\x48\x42\xc3\x8b\x2e\x79\xef\x2d\x5f\x58\x90\xff\xc9\xbb\x41\xc7\x1e\x99\xfb\xd0\x13\x63\x03\x64\xa8\x0d\x93\x26\x27\x1e\x44\x01\x79\x6c\xa3\xde\x63\xbb\x51\xa7\x4d\xf4\x88\xa1\x43\xa6\xa5\x24\xe4\x85\x27\x2d\xd1\x19\xe4\x7e\x42\x38\x88\x95\x4e\xfa\x24\x08\x9c\xb8\xdb\xb2\x15\xec\xaa\x7b\x41\x6f\xc8\x63\x88\xa9\xed\x0d\x04\x8b\xbc\xe1\xa0\xbb\xc9\x3d\xc4\x22\x7b\xba\xca\xf8\x25\x2b\xbb\x30\xa4\x7d\xc8\xa1\xb2\x16\xc2\xa4\xb5\xb0\xaf\x7f\xd1\xa2\x43\xcb\x9a\x08\xbf\x77\xb5\x21\x2f\x00\x22\x87\xf4\x17\xf2\xc2\x75\x18\xb7\x48\xaa\xac\xcd\x07\xbf\x1e\x90\x5b\xdb\xca\xbf\x9a\xf4\xce\x1a\x8c\x20\xcd\xae\x77\xee\xa1\x02\xc6\xaf\x20\x2c\x93\x63\xd5\xd2\x5f\xf2\xc2\x0c\xb5\xef\x0e\x49\x2d\x87\x0c\x46\x6e\xdc\x1a\xc2\x3c\x67\xe7\xa9\xeb\x6a\x8c\xd2\xed\x92\x40\x7f\x1b\x05\x5e\xda\x56\xab\x4a\xa8\x2f\x23\xba\x1c\x1a\x28\x10\xea\x97\x4c\xe5\x01\x4c\x89\x85\x4b\x26\x85\xa3\x30\xb7\x5c\x23\x10\x1f\xb1\x0a\x1a\xdb\x81\x94\xd8\xb5\xa4\x87\xaf\x68\x6c\x07\x82\x77\xdf\x50\xde\x2c\xc1\x5a\xd7\xb1\xd6\x75\x2c\xa4\xeb\x00\xac\x61\xf9\x9b\xf4\x3b\x19\xc7\xb2\x8e\x3b\xdc\xad\x82\x6e\x62\xe0\x2c\xb0\xcf\xcc\x85\xa2\x5f\xeb\x2c\xd3\x91\x27\xfb\xbd\xba\x1a\x4d\xfd\x79\xa0\xba\x89\x6c\xda\x60\x81\xb3\xbf\xed\xc2\x35\x75\x90\xc9\x37\x0e\x82\x73\xfd\x72\xad\x6f\x7c\xa7\x0a\xba\xa9\x0b\x0b\x4c\x57\x55\x98\x5d\xdf\xcd\x6e\x19\xb6\xa9\x13\x0d\xb4\x90\x7d\x85\x05\xd8\x28\xc0\x40\x63\x08\x07\x55\xde\x4f\x6b\xe5\x24\x4f\x77\xcb\xa0\x33\x91\x0a\x9e\xb4\x77\xb2\xad\x68\xaa\xd9\xd4\x7d\x9d\x21\x84\xdb\xa4\x9e\x44\xe5\x39\xda\xae\x80\xde\x9d\xd9\x27\xb4\xa9\x6b\xbe\xe2\xe3\xf7\xf0\x90\xaf\x37\x54\xda\xdf\xab\x82\x6e\x9a\x9c\x05\xa6\xab\xfe\x8b\x65\xc5\x34\x4c\x66\x76\xf6\xb4\xae\x46\x53\x87\x1e\xe8\x67\x7a\x52\x3e\x60\x25\xf2\xa5\xc9\xc5\x25\xa9\x19\x24\x84\x03\xc2\x64\x3d\x43\x94\xe7\xef\x89\x43\x56\x2c\x80\x8e\x4d\x09\x6c\xb9\x9a\xda\xa5\x7f\x96\xb9\x10\x5b\xc5\xfc\xcf\x3c\xf7\x55\x3f\xd5\xea\x65\x69\xa0\xa3\xf5\x59\x2a\x37\xc0\x21\xf9\xcb\xf3\xee\x6e\x77\xe7\x2f\x07\xe6\xdb\x44\xcf\x08\x0c\x60\x7c\xca\x6e\x1b\xc3\xb4\xad\x6a\x5c\x1b\xb3\xaa\x37\x50\xcd\x21\xec\xd7\x9f\x68\x7b\x69\x64\x23\x0a\xe9\xfa\xee\xb5\x69\x3f\x47\x5f\xb8\x27\xc7\xfe\xd4\x2f\xe3\x79\x45\x1f\x72\xc6\x7d\x72\x82\xee\x34\xb7\xd6\xb4\xce\x2b\x08\x16\x3c\x3b\xe7\x98\x43\xbb\xa5\x16\x7d\x6b\xcb\x0b\x38\xbc\x99\xd2\xeb\x62\x33\x61\x29\x85\xe7\x1a\xcd\x36\xf3\x49\x46\xc3\xd8\x74\x3c\xcd\x69\x37\x9c\x4c\x92\x1b\xb9\x85\x2e\xbe\xd9\x2b\x9f\xd3\x62\x3a\x71\xb4\x6c\x65\x0b\x81\x7f\xe6\xb9\x67\x16\x00\xb5\x6a\xf4\x8a\xd8\xa2\xab\x33\x35\xfb\xeb\xb3\xf8\xe4\x5b\xd2\x13\xc7\xdb\x30\xf5\xbd\x8f\x9e\x1f\xd9\x0b\xf7\x23\xc6\x1d\xb3\x34\xf8\xfa\x85\x5b\x43\xb7\x2d\x1d\xa3\x8d\x6c\x0d\xb6\xc5\x33\x20\x8c\x5a\x7c\x6b\x8b\xfc\xf5\xfb\x84\x5f\x7d\xcf\xae\xdf\x52\xb7\x97\xaa\xbd\x9f\xd1\x6e\xab\x5d\x32\x18\xb0\xe7\xc7\xd2\x5c\xb0\x9b\x3c\x85\xc0\x1f\xe4\x2b\x25\xeb\x72\x26\xe5\x01\x99\x3e\xdd\x0f\x07\x15\xed\x5f\x22\xb2\x8b\xc7\x80\x2a\xd2\x54\xbb\x6e\x0d\xad\x3b\xa3\x54\xf4\xdb\x6f\xe5\xb6\x5f\x34\x9e\x29\x71\xe4\x6a\x4e\x63\x79\x69\x16\x3b\x16\xee\x54\xe5\xa1\x6d\x57\x9f\x16\x1f\x4a\x63\x9b\xa5\xf7\xad\xd5\xdd\xa3\x91\xe0\xdc\x46\x08\x88\x0a\x86\x8d\xae\x39\x54\x3e\x58\x2b\x47\x0b\xee\xf9\x4f\xd9\xb6\x7b\xca\xb6\x9b\x4e\xd9\xb6\x77\xca\x6c\xb3\x87\x0a\x5d\xb5\x1b\xe7\x12\xe0\x20\x9e\x36\xaa\xd5\x9d\xf8\xff\xaa\x15\xc5\x64\xda\x17\x9e\xfc\x66\xe9\xcf\xeb\xa1\x1e\x93\x6d\x3f\x28\xbf\x76\x98\x50\x97\x8f\xf5\x82\xb1\xef\x1d\x5c\xb9\x8e\x9b\x61\x4e\xce\xaa\x63\x0d\xf5\xd7\x3c\x47\x0d\x7e\x47\x17\x95\xce\x74\x5f\x2f\x47\xf9\xb8\xff\xf6\x5b\x0d\x21\xe8\x58\xab\x61\x9f\xc9\x7e\xd3\x49\x36\x95\xcc\xa5\x56\x79\x12\x3b\xee\x5a\xdb\x29\xf6\x20\xbf\xb6\x63\x9a\x22\x31\xbc\xcb\xd3\x9f\x50\x30\x2d\x91\x4b\x3d\xe8\x1c\xb4\x87\xd2\x3a\xbc\x7f\x05\x59\x4c\x40\x40\x6c\x61\x3e\xe8\xbe\xd0\x94\x86\xb0\x02\xdd\x3d\xe7\x37\x12\x12\xd5\x66\x9e\x0c\x1f\xcc\x37\x2c\x41\x29\x28\x26\x59\x31\x04\xb6\x0a\xb3\x1c\x93\x9f\x83\x25\x8e\xbc\xd6\xff\xf1\x69\xb1\x28\x05\x10\xac\x7f\xe3\xd9\x07\x85\x5f\xea\xdc\x67\x80\xf1\xd0\xc9\xea\x4e\xfc\x9c\xd4\x64\xc7\x6d\x7b\xa7\xa9\xed\x1d\x8f\x9a\x6c\x6d\x91\xd7\x10\xd8\xd8\x5d\x30\xf0\x6b\x1b\x72\x41\x69\x80\x86\xe3\x39\xed\x5a\x14\x46\x91\x18\x80\x3c\x2c\x45\xec\xb7\x7f\xf5\x95\x78\x16\x97\xac\x8d\xe0\x32\x9e\xaa\x4d\x90\xcc\x2c\xa1\x3f\x73\xb5\xab\x85\x4d\x9d\x0b\x1f\xbb\x76\xfd\xf7\xfc\x5b\xe9\x28\xcc\x25\xaa\x8b\x3d\xfb\x3e\x84\xc0\xd4\xca\x5d\xab\xe0\x50\x2a\x7f\x9a\x4a\xa3\xa2\x98\xe4\xfd\xad\xad\xbc\x08\xa3\x0b\x7e\x49\xb3\x61\xc2\xaf\xba\x11\x1f\x6f\x81\x3e\x45\x00\x6f\x3d\xd9\xde\xdd\xd9\x7f\xb6\xb3\xbf\x35\xe4\x59\x44\x37\xa3\x10\x52\xf1\x6d\xb2\x74\x53\x00\x5b\x5b\x97\x99\x1e\x0c\xc5\x36\xc7\xd9\x7c\x95\x7e\x72\x06\xbb\xdd\xaf\xd6\xed\x5e\x49\x6b\x6c\xf2\xff\x95\x5d\xb1\x44\xf3\xda\xa4\xf1\xb3\xea\xa0\xf4\xa1\xb6\x07\x78\xa9\x28\x7d\xb5\x57\xa8\x43\x11\xda\xeb\xe1\xb2\xde\xf0\x1e\x77\xb8\x6d\x0c\x42\x02\xbb\xde\xb1\x1b\x6d\x3b\xbc\xa6\x33\x86\x1c\x82\xc3\xf1\x0c\xc2\xaa\x4e\x13\xe7\xd1\x68\x49\x3a\xec\x6e\x6c\x7b\xb7\x69\x42\x4d\x13\x87\x24\xe8\x2a\x95\x4a\xed\x32\x81\x4e\xab\xcc\x09\x55\x93\x72\x6d\x21\x50\x22\xe4\xd9\x54\x21\x7a\x95\x11\xa5\xb4\xec\xc5\xf6\xba\xe4\x27\xb1\xa4\xb1\xa5\x90\x94\xe9\x41\x58\x7a\xc9\x2f\x68\xac\xd2\x2a\x39\xf3\x6f\x22\x77\xd3\xbc\x8e\xce\x4d\x73\xea\x3d\x1b\x4e\x21\x94\xbb\xc2\x4f\xf9\x41\x4b\xc7\x4f\x13\x9a\x56\x50\xa7\x0e\x31\x8f\x50\xb4\x69\x12\x80\xed\x0e\x39\xc5\x00\xb5\xbd\x03\xfc\xeb\x1b\x68\x00\x7f\xb8\x76\xb5\xb2\xfe\xc9\xa9\xd4\x00\x18\x52\x76\x6a\x42\xea\x58\xeb\xaf\x96\x7e\xc8\xb3\xd7\xe2\x96\x31\x4f\x6e\xfc\x62\xb7\xbd\xb5\x45\x5e\x5e\x72\x16\xe7\x90\x84\xe8\x86\xa5\xe7\x24\x17\x07\x00\x21\x49\x71\xc5\x22\xda\x21\x61\x41\x12\x2a\xc8\x88\xd6\xed\x66\x74\xd8\x35\x37\xfb\x90\xb4\x4e\x9d\x13\xa9\x86\xa0\xcc\x50\x55\xc7\x87\xd2\xf0\xd9\xb6\x01\xae\xae\x09\x66\xcc\xb2\xda\x41\x09\x5a\x41\x89\x3d\x2a\x01\x69\xe3\xe0\x46\x4e\xb9\x64\xcf\xf8\xcf\x3c\x6f\x34\x62\xfc\xa7\x4c\x2c\xeb\x68\x02\xef\xe6\x54\xbf\xf6\x71\x59\xeb\x7d\x1e\x82\xde\xe7\x81\x8b\x27\x31\x03\xb0\x94\xe8\xd7\xfb\xa8\x68\xa8\x16\xec\x9e\x8c\x13\x35\x97\x4c\xd1\xd4\x75\x44\x8b\xa0\x6a\x3e\x24\x41\x0e\x9f\x03\x4b\x4e\xc5\x72\x79\xad\x51\x08\x85\x83\xc9\x50\xcc\x67\x24\xed\x32\x2a\xba\x92\x53\xa2\x35\xa2\xb2\x89\x25\x65\x61\xa3\xe6\x8c\x24\x31\xd7\x09\x14\xff\xae\xed\x6d\x4a\xc6\xf6\x60\x1e\xde\x24\x7b\x48\xf9\xe6\x34\x9d\xe6\x34\xde\xbc\x0c\xb3\x7c\xa3\xec\x6f\xa3\xa7\xee\x09\xd5\x96\xb6\xd7\x2f\x5b\xf1\x9a\xf9\xb7\x6d\xda\x8f\x0f\x06\x60\x36\x02\x43\xbe\x0d\xd9\x91\x8f\x73\x41\x7a\xe0\xcf\x6f\xac\x85\x34\x34\x48\x7c\x72\x2f\x4c\x02\xad\x3e\x3e\x34\x7b\xf1\x98\x04\x10\x23\xc4\xd4\x57\xc9\xcd\x1f\x93\xe0\x20\xb0\x2f\x18\x90\x1d\x78\x60\xe2\x7d\xff\xb1\xad\x5a\x0d\xfe\x93\x06\xe5\xdb\xc6\xbc\x4b\x8b\xac\x74\x25\xdb\x16\xfa\xd5\xe3\xb1\x07\x52\x65\x6c\xaf\x77\xa9\xd9\xd0\xde\x02\xf3\xaf\xaa\xd5\x06\x3a\x59\xd1\x55\xb5\xb6\xd2\x58\xdf\xd6\xeb\xdb\x7a\x09\x2b\x8d\xb9\x62\x2c\x38\x90\x4d\x5a\x51\x1d\x10\xe1\x4f\xaf\x0e\x55\xa6\xaf\x62\x16\xe2\x48\xfd\xed\x82\xde\x0c\xb3\x70\x4c\x73\xed\x36\xfb\xbf\x55\xc9\x2c\x8e\xc4\x01\x44\xa6\x04\x7f\xcf\xc9\x95\x38\xf5\x2b\x19\x13\x3d\xb8\x3b\xf2\x26\x95\x3c\x88\xf2\x17\x94\xb6\x2c\x20\xc4\xd6\xc8\x64\x8b\xb0\x6b\x44\xd7\x04\x93\xe1\xa1\x60\x18\x65\xbd\x1b\xce\x05\x0f\xd2\x2b\x96\xca\x45\xf1\x7d\x2c\xc1\xe6\x3f\x8c\x63\x29\x0a\x41\xa0\x13\xf1\xe3\xa3\x27\x2d\xb7\xa7\x60\x8b\xcc\xed\xfe\x8d\x1c\x5a\xc9\x38\xfa\xd0\xbf\x2f\x89\xbe\xdd\xf0\x66\xde\x95\x36\xd2\xad\xf6\xa2\x7c\x59\x89\xd5\x72\xf6\x73\x49\x6e\xeb\x5e\x15\x99\xc0\x4c\x89\x15\xdb\x26\xbe\xb6\x25\x35\x62\x37\x5c\x96\x5a\x97\x48\x88\x02\x99\x42\xa6\x69\xac\xe6\xb1\x4c\x55\xbc\xd0\xa7\xff\x40\xa2\x71\x09\x4f\x82\xdb\x7a\x4e\xc8\x59\xc4\x46\x66\xc8\x83\xf4\xf9\xa1\x07\x16\x6d\x6c\xcd\x0f\xad\xf9\xa1\x35\x3f\xb4\xe6\x87\x1e\x26\x3f\x74\xc4\xd3\x18\x02\x44\x84\x09\xca\xd6\x81\x37\x1a\xd3\x98\x85\x1d\xf2\x37\x99\xe0\xde\xb0\x48\x16\xf8\x2c\x26\xc9\x03\x45\x36\x49\x29\xc5\xe7\x62\x93\xbc\x16\x2a\x19\xa5\xc8\xc0\xfc\xae\x59\x25\xdf\xce\xa2\x92\x55\x42\x20\x64\x95\x96\x63\x6b\x0a\xa9\x42\xa9\x65\x65\xbc\x35\xf7\x98\x99\x73\x5a\x34\x28\x90\xe5\x57\x4f\x7b\xec\x04\x31\x80\x11\x9e\xd3\x02\x61\xea\x94\x43\x62\x9c\x28\x9f\x81\x6c\xb4\x7a\xc0\x35\xaa\x1e\xa9\x8c\xa8\x19\x95\x52\x55\x64\xda\x77\xb5\x7a\x54\x0e\xdc\x2c\x1d\x3c\x98\x1b\x48\x0d\x16\xba\x8b\x65\xd3\x54\x2b\x68\x1a\xc6\x1a\xc6\x71\xc3\x0a\xca\xaf\xae\x92\xb0\x24\x87\xb3\x54\x8d\xf5\x68\x62\xea\x39\x96\x18\xdc\x28\x64\x9b\x55\x79\xce\x32\x35\x69\xf2\x1a\x78\xe5\x3b\x06\x0c\x79\xf8\x2c\xb1\x0a\x41\x0c\x55\x5e\x34\xb3\xbe\xff\x49\x6f\x6d\x3f\xb8\x0a\x0e\xd8\x3b\x7b\x8d\x3c\x70\x09\xd6\xe7\x82\x1f\x58\xe4\xd5\x35\x0b\xb8\x66\x01\x97\x65\x01\x21\x26\x48\xad\x43\xc9\xae\x0b\xd7\xc4\xfd\x01\xc0\x9a\xf5\x13\x8b\xf5\x3d\x4f\x8b\xef\xc3\x68\xa6\xf2\xcd\x86\xb3\x58\xb8\x39\x39\x38\xbb\x76\x25\xfb\x36\xe4\x69\xb1\x39\x0c\xa3\xbb\xea\xe0\x94\x15\x95\x65\x5c\xb5\x1a\x1d\x5c\x89\x41\xb2\xa7\x74\xcf\x8a\x35\x98\xcc\x2a\x14\x6b\xd0\xd0\x5c\x8a\x35\x30\x5d\xc2\x73\xe4\x58\x2d\xa9\x85\xef\x58\x0d\x4a\x4d\x5b\xbb\x52\xc9\x66\x41\xac\x4a\xc9\xb6\xc8\xd8\x7c\xee\xa7\xe2\xb6\xb5\x37\xb2\xf1\xaa\x75\x01\xfd\x7b\x76\x1d\x0c\x75\x7d\xcf\xae\xef\xd9\xf5\x3d\x5b\x73\xcf\xfe\x8b\xd1\x2b\x71\x78\x67\xdd\xb3\x36\xdc\xe2\xf7\xac\x5d\xbb\xf2\x9e\xbd\x94\x00\xbf\x9b\x6b\xd6\x9e\xd1\xaa\xae\xd9\xfb\xb9\x47\xec\x91\x36\xde\x23\x2e\xa0\x77\x8f\x3c\x7b\x60\xa1\x12\xb7\xb6\xc8\x2f\x21\x2b\xb4\xbd\xf8\x39\x2b\x46\xd3\x01\x18\x8a\x0b\x76\x6d\xc0\xf9\xc5\xd6\x30\xe1\x57\x5b\x2c\xcf\xa7\x34\xdf\xda\xdd\xef\x91\x82\x93\x01\x25\x43\x76\x4d\x63\x31\x27\xd7\x72\x89\x08\x68\x81\x8e\x5b\x72\xe4\x9b\x97\x61\xc2\xe2\xcd\x21\x4b\xe8\x26\x1c\x29\xc8\x7c\x08\xc8\x20\x79\x19\x76\xce\xa5\xa7\xe6\x5e\xaf\x4f\x82\xff\x45\xf7\x69\x38\x7c\x0a\xdb\xbe\xdd\x83\x92\x68\x2f\x0a\xe9\x73\x28\xd9\xc1\x92\xe7\xc3\x70\x3f\x0e\xa1\x64\x17\x4b\x9e\x3d\xdf\x7f\x1a\x0d\xa0\xe4\x09\x96\xec\x45\x4f\x07\x51\x0f\x4a\xf6\xb0\x64\x77\xb8\xb7\x3d\xd8\x83\x92\xa7\xb2\xe4\xf9\x93\xe7\x21\xd6\x7a\x26\x4b\x7a\xbb\xc3\xe7\x28\x64\xda\xc7\x92\x9d\xfd\xdd\xbd\xe7\xbb\x50\xf2\x1c\x4b\xb6\xc3\x9d\xdd\x67\x28\xdc\x79\x29\x87\xb8\x1f\x3d\xa7\x43\xac\xf6\x52\x8e\x71\x6f\xf7\x69\x3c\x94\x50\x72\x48\xbb\xf1\x5e\xa8\x8a\x74\x7f\x4f\x86\xb2\x28\xe2\x69\x91\x85\x79\x21\xc9\xe6\x11\x4f\x78\xd6\x27\x41\xc2\xce\x47\x45\x50\x93\x93\x07\xd7\xaf\x8c\x67\x0f\x2c\x10\xe2\x17\xc7\xb3\x09\x4b\x2f\x1c\x2c\x1b\x46\xf4\x09\x8d\x6c\x2c\x1b\xee\x0f\x06\x71\xcf\xc6\xb2\xe1\x93\xfd\xe1\x60\xdb\xc6\xb2\x61\xef\xe9\xce\xf3\x1d\x1b\xcb\x68\xf4\xa4\xf7\x2c\xb4\xb1\x8c\x3e\xdf\xa6\x4f\x77\x6d\x2c\x8b\xf7\xb7\x07\x4f\x7b\x36\x96\x45\x3b\xdb\xfb\x7b\x03\x1b\xcb\xc2\x78\xfb\xc9\xde\x33\x1b\xcb\xf6\xf7\x7b\xf4\xc9\xd0\xc1\xb2\xe1\x70\xbf\x27\xd1\x55\x61\xd9\x70\xf8\xa4\xb7\xbf\xed\x60\xd9\x70\xaf\xd7\x93\x4d\x29\x2c\x8b\xf6\xb6\xb7\x9f\xee\x2c\x8d\x65\x62\xf5\xca\x38\xf6\xc0\x42\x2b\x7e\x71\x1c\xcb\xe0\x86\xb5\x50\x6c\x48\x07\x94\x3a\x28\x36\x8c\xe2\x78\xc7\x46\x31\x3a\x7c\x1e\x3e\x77\x08\x19\xdd\x7b\xb6\xfb\x6c\xd7\x41\xb1\xe1\xde\xee\x9e\x43\xc8\x86\x4f\x9e\xec\xee\x3e\xb5\x51\x8c\xee\xed\x3e\xdf\xdd\xb3\x51\x2c\xde\xdd\x19\xee\x38\x84\x2c\x7a\xba\xb3\xbf\xb3\x6f\xa3\xd8\xe0\xd9\x76\xb4\x1d\xf9\x28\x16\xee\xf7\x3c\x14\xdb\xdb\xd9\xdb\x71\x51\x6c\xb8\xfd\xec\xc9\x13\x07\xc5\xe2\xbd\x5e\xaf\xd7\x5b\x1a\xc5\x32\x48\x85\xe4\x61\xd8\xdd\x02\x41\x96\x72\xd9\x7d\x22\x3a\xec\x66\xbf\x26\x05\xde\x76\x5b\xb4\xa7\x30\x0d\xb1\x8b\x94\xc3\x8a\x3e\x5b\x6d\x08\xb1\xcb\x55\xa7\x3f\xf9\x8c\x01\x7a\xca\xba\xc2\xea\x29\x3c\xab\xab\xd1\xd4\x5f\x85\x6e\x10\x9a\xf0\x6d\xb8\xaa\xbb\x7c\x5a\x0d\xdf\xd4\x61\xc9\x66\xeb\x33\x85\xa4\xf1\x1e\x10\xd5\xf3\x79\x5e\x09\xde\x1c\x2e\xc5\x7d\x31\xe0\x10\x6d\x7b\xfc\xea\x9e\xf6\x2a\x80\x1b\x27\xe4\x18\xe0\x43\x45\x4f\xf4\x58\xdd\xcf\x7e\x25\x78\x53\x4f\xbe\xac\xf1\xf3\x24\xfa\xb1\x8f\xfe\x83\xf4\x19\x7a\x95\x85\x57\xb5\xb1\x76\xf6\xb6\xe7\x4a\xac\xa6\xe6\x7e\x0f\xd9\xa0\x70\x78\x6d\x45\xef\xad\xcc\x4f\xab\xdd\x3f\xd9\x7e\xc3\xee\x3d\x30\x33\xfa\xf2\x45\x18\x46\x05\xbb\xa4\xaf\x13\x3a\x86\xfc\x9f\x32\x16\xd8\x55\x4a\xb3\x57\x3c\x02\xdd\x66\x2d\x35\x37\xf4\xc1\x81\x6f\x8c\x1e\x66\x03\x7e\x96\xfd\x30\x5a\x70\x7b\xa2\x56\xf0\xd6\x98\x47\x2b\xd2\xfe\x82\x08\xc0\x5d\x0a\xb5\xd0\x2a\x1e\x4e\x29\x11\x72\xcc\xa3\xae\xb7\x05\x5e\x4a\xe4\xad\xaf\x09\xa3\x28\x34\x82\xc8\xda\x29\x97\x53\x21\x14\x6b\x90\xaf\xb7\x6e\x37\x6e\xcb\xec\x47\x59\x5c\x50\xe6\x2b\x1e\x9a\x55\x63\x19\x3f\x8d\x6c\x2b\xe5\xb1\x18\xd4\x25\x4d\x8b\x0e\x19\x85\x69\x9c\xd0\xac\x43\xa2\x70\x52\x4c\x33\x69\x83\x81\x3b\x90\x5a\xcb\xde\x5c\xc9\x4a\xf8\xab\x76\x65\xcc\x2f\x2b\x32\xa9\x78\x81\x77\xf9\x70\xb8\x50\x1f\x52\xc4\x83\x11\xe3\xf1\xc4\xa4\x75\xc4\xd3\x8a\xbe\xc6\xd3\xc6\xb3\x94\x1a\xc0\x61\x5d\x6e\xf1\x3d\x8b\xe7\x12\xa3\x6e\x6a\x6f\x38\xfc\x12\x14\xf2\x41\x9a\x14\x48\xbb\xab\xba\x10\x79\x4f\x7c\xc0\xa6\xe8\x78\xaa\x2d\x2b\xd2\xa2\x18\xe3\x2f\x18\x39\xc2\x88\xd9\xeb\x3a\xdb\x9b\x55\xb1\xa9\xf3\xba\xbe\xda\x56\x22\xd8\x9f\x94\x62\xe0\x5d\x1d\x16\xed\xd7\x80\x37\x06\x61\x77\x20\x8d\x12\xc9\x91\x34\xd7\xcd\xf9\x79\x0d\x7c\x63\x14\x42\xb7\xe5\x2a\xb5\x55\x6d\xc8\xc3\x5e\x15\xf4\xec\x90\x87\xd8\xa8\xae\x3b\xe1\x79\xce\x06\x09\xb5\x24\xfe\x18\x14\xbd\xb6\xdf\xed\xd9\x75\x9b\x46\x51\xdf\xa1\x89\xb8\x9a\x8e\x68\xc6\x8a\xfa\xa9\x97\x41\x9b\x7a\xd4\xcd\x99\xa0\xa4\x34\xac\xcd\xf1\xbe\xed\x42\x35\x86\x2e\x15\x00\x1a\xfc\x43\x16\xa6\x98\x62\xac\xa6\x65\x2b\xe2\xa7\x81\x6d\x6a\xdf\x40\x19\x8d\x93\x2e\xaa\x7b\x09\x5b\x0f\xe1\x2b\x56\x8c\x3e\x8c\x68\x6d\xd8\xce\xe7\x3b\x65\xd0\xc6\x24\x0b\x0a\xe8\xb3\xd0\x5c\x31\xae\x41\x38\xa0\x09\x06\xd1\xfb\x3e\xe1\x57\xef\xc5\x82\x0b\x8a\xf0\xe1\x66\x42\xf3\xd3\x49\xc6\x27\xe2\xa8\x9e\x4a\x3e\xa4\x76\x47\xbb\x0b\xb6\xf3\xdb\x6f\x95\x0d\xf5\xda\xdd\x30\xbd\x01\x31\xda\xdf\x24\x52\xd1\xd8\x64\xab\x37\xdb\xb5\xd0\xe0\x4d\x35\x41\x08\x06\x61\x74\x51\xf7\x16\xec\xcd\x3d\x91\x8a\x36\x67\xcc\x69\xb9\x11\xbf\x9a\x66\x61\x03\xc6\x2f\x35\x62\xdd\xe6\x0a\x47\x0c\xaa\x5f\x29\x79\xd4\x8a\xb8\xbf\xb1\xf3\x94\x67\x54\xfb\x98\x87\x93\x09\x0d\xb3\x6a\xb1\x97\x98\x08\xe7\x49\xc7\xd1\xe4\xbd\x24\x39\x4b\xcf\x13\x4a\xa2\x11\x4b\x62\xcc\x90\x9f\x16\x8a\xc7\x35\xce\xeb\xf0\x39\xa3\xa9\x8e\xe3\xbe\x28\x5a\x1f\x1e\x92\x40\x9d\xb7\x80\xbc\x58\xb0\x7e\x97\xe5\xf2\x6c\xc6\x77\xaa\xdb\x5f\x74\xdc\xb5\x4b\x99\x8f\xc2\x09\x6d\x2d\xd6\x5a\xdb\x1a\x8a\xbb\x0d\x6f\x86\xe4\x4c\xf0\x42\x67\x1d\x08\x75\x16\xe9\x03\x09\x91\x73\x0c\xc5\x24\x2c\x35\x7b\xc2\xd2\xc6\x8d\xae\xed\xcc\x47\x1a\x9e\xbe\x16\xe4\x6f\xd1\xad\xad\x3a\xf4\x4b\xee\x72\x45\x53\xab\x59\xf8\x72\xc3\xed\xb9\xd6\x82\xa5\xe7\xeb\xe5\xc0\xe5\xb8\x66\xc5\x7a\x29\x36\x08\xa4\xe9\xa5\xb5\x7d\x23\xc3\xdf\xdc\x02\x18\x21\x2c\xd4\xc2\x87\x11\x25\xb1\xba\x4b\x86\x3c\x03\xe2\x60\xa8\x41\x87\xb0\x94\x8c\x59\x92\xb0\x9c\x46\x3c\x8d\xd1\x59\xe1\x6b\xcc\x3e\x13\xde\x90\x7c\x42\x23\x36\xbc\x21\xa1\x22\xf2\x05\x1b\x53\x3e\x2d\xa0\xa9\xd0\x21\x2c\x79\x87\x70\xd4\xd3\x5f\xb2\x78\x1a\x26\xc9\x8d\x0c\xd2\x05\x7c\x8f\x78\xdb\x99\x85\xc0\x46\x96\x47\x0a\x73\xe3\xde\x19\x29\x74\x53\xab\x46\x0a\xd5\x70\x1b\x64\x07\x52\xf1\x37\x4c\xf8\x95\x2d\x1b\xc1\x12\x10\x44\xb8\x79\xdc\x79\x4c\xbb\x79\x94\xf1\x24\xf9\xc0\x27\x4e\xee\x48\xb1\xa3\xdf\x87\x31\x75\x68\x7a\x4e\xa6\x39\x8d\xc9\xe0\x06\xf6\xf7\x2d\x8f\xc3\xc4\x5c\x01\x90\x54\xe9\x4d\x11\x08\x20\x96\x9e\x93\x13\x60\xd9\x37\x4d\xfd\xcd\xf3\x8c\x4f\x27\x1f\x5b\x15\x1a\x51\x00\xfd\x35\xdf\xaa\xae\xd2\x26\xc0\xf6\xa6\x62\xb7\x65\xee\x25\xb0\x26\x16\xc3\xb3\x25\x40\xa7\xb0\x5c\x7f\xd5\x5c\xa2\x25\xf4\xd1\x6f\x17\x23\x96\x11\xd5\x3b\xa4\x54\x07\xe4\x70\xc6\x12\x39\x8c\x8d\x74\x47\xbe\x54\x86\x07\x26\x2f\xd1\x69\x41\xc7\x93\x0e\xc6\x11\xeb\x88\x8f\x85\xfc\x88\xe1\xf8\xdc\xc7\xa9\xe9\x5b\x1a\x2a\x87\x31\x2d\xf9\x66\xd5\x06\x7e\x0b\xb3\xf3\x65\xa3\xbe\x89\xaa\xcd\x01\xdf\xa4\xd9\xab\x92\x9b\x67\xa0\xa4\x6b\xc1\xec\xf0\x0f\x8c\x55\x07\xb3\xaa\x7f\x8a\xfa\x13\x14\xcf\xb6\x21\x39\x84\x89\x76\x4f\x4f\xc1\xac\xf0\xf4\x14\x62\x27\x8b\x86\x3c\x61\x81\xbb\x35\xed\x36\x78\x02\xcb\xd8\xc5\xa2\xa1\x0e\x81\x2c\xb3\x3a\x78\xbc\x98\x55\xbb\xdd\x96\xab\xaf\xfe\xed\xa2\x84\xed\xb5\xcc\xb6\xe5\xca\x07\xcd\x92\x20\xea\x83\x89\x32\x9f\x84\x11\x2b\xc4\x3a\x06\x3d\xcb\xaf\xdc\x1c\x19\x27\x48\xa2\x0c\x19\x07\x06\xa9\xf2\x12\xb6\x8d\x9a\x2b\x3e\xab\x46\x6c\xe3\xe3\xdb\x8a\xd1\x62\x7e\xbe\xba\x01\xeb\x90\x81\x7f\x9d\x48\x06\xdb\xea\xaa\x63\x59\x43\x17\xea\x15\x6a\x80\xbb\x50\xe6\x00\x49\x02\xeb\x81\x61\xa9\x9e\xaf\xb5\x48\x85\xfd\xe2\x86\xe6\xac\x22\x15\xf4\xbb\x15\xc8\xb5\x0c\xec\xc0\x09\xea\x62\xd0\x84\x58\x77\x6e\xc5\x51\x26\x2f\x74\x71\x5f\xfd\xd5\xa5\x62\x59\x74\x4c\x05\xb5\x82\x4e\x5c\x72\xb2\x39\xdb\xc2\x62\x32\x4d\x92\xad\xbd\xed\xa7\xdb\xe5\x69\x5d\xd1\xc1\x05\x2b\x3e\x3c\x9c\xc9\x55\xe3\xe5\x76\x30\x0b\x07\x59\x7a\x3e\x03\x0d\x59\x7a\x3e\x0f\x26\x5e\xb3\xb2\x58\xbd\x16\x0b\x77\x16\x42\xc3\x9d\x39\xf1\x70\xe7\xe1\x21\xe2\x35\x2b\xfe\xb0\x78\x58\x35\xb7\x7a\xf2\x58\x8f\x86\xd7\xac\x68\x40\xc1\x6b\x56\xd4\xa2\x1f\x1d\x4f\xda\x9d\xf9\x2f\x17\xeb\xb6\x35\xfe\xc6\x56\xfc\x5b\x94\xce\xfa\x37\xfd\x89\x1b\x7f\x3b\x8d\x69\x56\x1b\x75\x5b\x7c\xf4\xc3\xb5\x2a\xb2\x5b\x8d\xee\x28\xd0\x10\x78\x8c\x33\xc6\xdf\x36\x84\x92\x4c\x18\x18\x55\x62\x43\xc9\xc3\x6a\x80\x64\x41\x05\x8c\xcc\xe7\xea\x1f\x72\x0f\x12\xcf\xf3\xa9\xbd\x0f\x1d\xc7\x05\xe7\x26\x01\x45\x88\x01\x42\x1b\xe4\xaa\xa3\x5c\x73\x99\xf0\x62\x04\x23\x46\xdd\x57\x8d\x12\xc2\xda\x3e\x5c\x3c\x72\x12\xe0\x22\x05\x1d\x12\xa8\xa5\x10\x7f\xcb\xa9\x58\x7f\x82\xdd\x35\xfc\xba\x66\x85\xf8\x0b\x86\x28\xfe\x80\xb1\x40\x02\x05\xdb\x9b\x56\x59\x8c\xc3\x80\x94\x0a\xc6\x0c\xe0\xd3\x6d\xc7\xcc\xbb\x6d\x87\xee\xfe\x9e\x67\x24\xa7\xd9\x25\xcd\x48\xce\x62\x2a\x31\xc1\x78\x16\xa3\x19\xbf\x85\xd8\x0c\x44\x67\x38\x0f\x1b\xf9\x1b\x38\x0b\xdf\xc3\x48\xca\xbe\xd5\xf0\xe4\x29\x57\x8a\x68\x73\x9c\x2c\x39\xb6\x82\x35\x9b\x50\x37\xd3\x12\x86\xf6\x49\x19\x33\xe5\x7b\xaf\xb4\xef\x46\xde\xe2\x71\x2a\xd5\xc8\x58\x86\xab\xc4\x46\x17\xcc\x10\x1f\xa0\x05\x80\x4a\x6d\x53\x49\xe1\x85\x2c\xf0\x0d\xe2\x8d\x5f\x55\x18\x83\x1d\xbc\xbf\x98\x0e\x5f\x0f\x6c\xa8\xca\x16\x63\x49\x29\xd5\xca\x28\xbb\x12\xfd\x70\xc4\xe5\xa3\xb8\x08\xb6\x3e\xa0\xab\xc8\x2d\xde\xe2\x2c\x3d\x3f\x8e\x32\xaa\x4e\x32\x85\x59\x56\xc3\x27\x34\xbc\xd4\xe0\x68\x77\x52\x65\x76\x81\xf9\x5b\xb5\xa2\xc0\xb2\x13\x68\xa9\x57\x83\xa7\x27\x5d\xad\x4b\x98\x1a\x91\xa5\x40\x90\xce\x4c\xfa\x93\xce\xb9\x9a\x1f\x8b\xa7\xab\xb1\x28\x50\xb7\xb7\x2e\xb7\x02\xca\x6b\x10\xbd\x36\x1f\x34\x07\x50\x2a\xd3\xba\x2f\xf5\x00\xae\x11\x7d\x1b\xed\x9c\x86\x6c\x52\xad\x68\xa0\xcf\x6b\x60\x52\x9a\x5e\xcb\x2a\xb9\x99\x50\x63\x72\x22\xd7\x4f\xa0\xa8\x8c\x1f\x1f\x18\x50\x08\xf4\xe9\x54\x24\x8f\x49\x20\x9b\x04\x22\x73\x09\x09\x99\xc3\x41\x42\xe3\x79\x9b\xa8\x4e\x49\xac\x5c\xf2\x36\x24\x75\x7c\x33\xf4\xe4\x3a\x84\xe5\xaa\xa7\x0d\x45\x1d\xd1\x09\xcf\xeb\xdf\x8a\x0d\x8f\xed\xa4\x5c\x73\x22\x5a\x6e\xc4\x72\x32\xc9\xf8\x25\x8b\xa9\x9d\xd5\x06\xdb\xf3\x96\xc4\x4a\x86\xfd\xc9\x77\xe6\x4c\xe9\x15\x41\xaf\x29\x7f\x1d\x1f\x93\x80\x5c\x85\x79\xfa\x9f\xa0\x20\xf9\x74\x32\x49\x18\xa6\x7f\x3e\x3a\x3e\x36\xc4\xf5\xef\x19\x9f\x4e\xfa\x10\x4f\x35\x80\x57\x6f\x14\xa6\x24\x0a\xc5\xf9\x98\xa6\x19\x4d\x18\xd8\x62\x87\x29\x1b\x87\xa8\x1a\x0c\xd3\x98\x5c\x71\x68\x74\x40\x89\x0c\x5e\x43\x63\xc2\x52\x6c\x24\x24\xc3\x69\x31\xcd\xa8\x4a\xba\x4d\xf8\x90\x80\xd0\xa1\x4b\x8e\x29\x45\x18\xc5\x3a\x0e\x07\xdd\x31\x95\x52\x10\xdd\x45\x49\x1e\xb2\x69\x8b\xc7\x20\xb9\x37\x34\xc2\xd2\x21\xcf\xb0\x4a\x37\x30\xd7\x9a\xbd\x75\xd6\x5a\xa7\x41\x41\x42\x82\x8c\xa1\xba\x99\x08\x4d\x72\x6a\xe7\xbb\xa9\x59\xfc\xba\x04\x38\x73\xed\xc0\x78\x9a\xc3\x4a\xa9\xce\x49\xcb\x13\x0e\xb6\x03\x9f\x47\x74\x84\x13\x62\xdb\x55\x42\x66\x3c\xf6\x3e\xbd\xa9\xa3\x43\x16\x79\xd0\x17\x04\x4f\xe9\xbb\xa1\x28\x6b\x9d\x54\x7d\xc6\x21\x76\x2a\xab\xa2\xc4\x0e\x8d\x13\xf1\x86\xa8\x6f\x60\x43\xdf\x0a\xb5\x30\x1b\xb7\xb6\xda\x45\x27\xba\xab\x27\xb3\xe5\x2f\x4b\x4c\x10\x3d\xe2\xee\x30\x41\xd9\x40\xe3\x04\x0d\x0c\x9a\xa6\x35\x41\x6d\xdc\xb6\x57\x33\x1a\x01\xf4\x72\x66\x77\xf3\x0e\x5c\xc0\xcc\x6e\x6d\xe3\xb6\xfd\xb1\x7c\x37\xef\x3f\x30\x37\xbb\x46\x33\xba\x8c\x46\x61\x12\xe1\xa9\x06\x6e\x37\x67\xff\x05\x17\x69\xfb\x83\x7c\xff\xb1\xf4\xd5\xbb\xb7\x86\x39\x71\x73\xf7\x80\x58\xf9\x15\xbb\x24\x87\x24\x96\xf6\x8e\x1e\x6f\x1b\xc4\xec\xd2\x22\x54\xba\x86\x7c\x78\x4e\xb8\x7e\x0b\x07\xe1\x20\xe7\xc9\xb4\xa0\x9a\x8b\xf6\x81\x0b\x78\xc1\x04\x9b\xcf\x9f\x3f\x7f\x3e\xb9\xae\x05\xbb\x62\x71\x31\x12\x80\x7b\xbd\x06\xa8\x11\x85\x94\xf8\xb3\xc0\x54\x26\x1b\x08\xea\x0e\xdf\xcc\xfb\x58\x4f\x79\xc0\xe3\x1b\x78\x0d\xa6\xf1\x91\x60\x66\x5b\xba\x15\x4d\xe5\x60\x85\x0f\xad\xe6\xf9\x70\x98\xd3\xe2\x17\x18\xeb\xa6\x55\x1e\x25\x8c\xa6\x58\x7e\x50\xd9\x0f\x9a\x23\x56\xf7\x73\xab\x5e\xca\x2a\xe8\x01\xfb\x2f\xb5\x2c\x0e\x61\x2f\xeb\xec\x5c\xf6\xda\x0e\x58\x63\x6e\x66\x01\xf0\xd9\x8c\x56\xe4\xd2\x5d\x72\x16\x93\xde\x41\x85\x93\xcd\x1c\x56\xae\xfb\x0f\xcc\x3b\x71\x6d\x62\xb8\x36\x31\x5c\x9b\x18\xce\x67\x62\xa8\x6e\xb2\x9c\xa2\xf0\x34\x09\x0b\xfa\x2f\x99\x1a\xa3\x54\x76\xaf\x26\x89\xf0\xeb\x15\x1f\xd7\x99\x67\x3d\x77\x21\x5f\x5f\xd2\xb4\xf8\x81\xe5\x05\x4d\xeb\x93\x52\xef\x36\xd4\x99\x39\x32\x07\x5a\x37\x14\xd3\x01\x9f\xa6\x51\x9d\x99\xe2\xde\x4e\x09\xb2\xa9\x23\x05\xf3\x79\x0d\x33\xef\xd5\xd6\x72\x21\xd3\xcf\xb5\x61\xe6\xda\x30\xf3\xcb\x1b\x66\xfe\xfd\xe7\x0f\x1f\x5e\xbf\x27\x87\x64\xe7\x89\x60\x6e\xb6\x88\x26\x7b\xf0\xe8\x4f\x79\x4c\x49\xce\xc9\x88\x92\x28\x4c\xa5\x98\x82\xd2\x94\xf0\x14\xbe\xe7\x20\x8b\xec\x8a\x8a\x3f\x84\x85\x78\xed\x5e\x51\x72\xce\xd3\x34\x44\x51\x0f\x34\x04\xcb\xa7\x5b\x2b\x38\x19\xb1\x9c\xf0\x8c\x9d\xb3\x34\x4c\x48\xc2\x23\x18\xae\x68\x03\xcc\x71\xce\x74\xcd\xdd\xb8\xd5\xeb\x10\xf1\xff\xed\xb3\xee\xd9\x86\xed\xae\xe7\x52\xe7\x96\x54\x0b\x18\x85\x23\xb8\x5f\xb1\x8c\x46\x72\x75\x51\xe4\xae\x4b\x80\xd7\x46\x83\x17\x20\xe7\xa0\xb3\x3a\xa7\xc5\x77\x7c\x9a\xc6\x2c\x3d\x3f\x02\x6e\xf9\x3d\x8d\x0a\xe9\x5d\x05\xb2\x02\xd1\xe7\x90\x67\x63\x9b\x6b\xc4\xe7\x0c\xd4\x1f\x86\x17\xf4\x83\x82\x51\x2f\x1a\xbb\x52\x19\x0a\x5d\xb2\x40\x74\x62\xec\x44\x22\x3e\x9e\x4c\x0b\x1a\x1f\x4b\x55\xc4\x15\x4b\x63\x7e\x25\x86\x77\x64\x7f\xb1\x55\x62\x76\x2f\x4e\xf5\x2e\x32\x32\xc0\x48\xe2\x52\x05\x9b\xa8\x30\xdc\xd4\x75\x82\xb6\x40\x95\x59\xd5\x2c\x70\xad\x38\x13\xa3\xc5\x07\xc7\xff\x01\x53\x12\xa7\xe8\xdf\x58\x24\x57\xc8\x8c\xf0\xd1\x23\x6b\xb8\x28\x0e\xe2\x29\x0d\xa0\x5c\xea\x1f\xcd\x6c\xc4\x67\x7c\x1f\x07\xb6\x29\x8d\x86\x80\xc1\xe5\x4a\x02\x2c\x4a\xba\xf9\x24\x61\x45\x2b\x68\x05\xed\x93\xed\x8f\xea\x57\x3b\x68\x9f\xf4\xf4\xaf\x8e\x12\x13\x99\xc1\x4f\xc2\x2c\xa7\x6f\xd2\xa2\xe5\x35\x7d\xf2\xe4\x63\x87\x00\x87\x65\xe0\xff\xdd\x04\xbf\x67\xe0\x6f\xd5\xe4\x2d\x4c\x14\x13\x4a\xe8\xd0\x24\x5b\x95\x04\x3e\xd0\x58\xff\x7f\x5a\xdb\xbd\xde\xe5\x55\x9b\x58\x25\x9b\x01\x79\x0c\xef\xeb\xa2\x2b\x2a\x93\x4d\x35\xf2\x36\x79\x4c\x82\xc9\x75\x3b\xb0\x30\xa9\xa2\xc7\x0c\x02\x16\x34\x74\xe9\x77\xf0\x18\x4e\x86\x7c\xf3\x3e\x56\x64\x62\xd1\x6e\xa7\x93\xfa\x3e\xff\x0d\xd3\x1c\x59\xd3\xfc\xb7\x3d\x0a\xf1\x28\x57\xdd\xfd\xdb\xed\x6e\x03\x13\x8d\x79\x7d\xc5\xfc\x2a\xdd\xa8\xe8\x07\x89\x08\x34\xdc\x23\x9b\x56\xeb\x72\x8a\xf8\x60\x6f\xcb\x2e\x04\xad\x09\x40\x3a\x68\xe7\xed\x9f\x87\xda\xd8\x47\xb0\x99\x40\x95\xcf\x84\x5a\x24\xdf\x56\x41\x36\x57\xd8\xe4\xa2\x4e\xf7\x5f\x05\x7b\xbb\xb1\x18\x1f\xf0\xca\xa2\x98\x75\x26\x9c\x29\x7d\x37\x6c\x9d\x20\x0e\x77\x14\x66\x75\x60\xaf\x3b\xb8\x0b\x81\x16\x40\xde\xc5\xec\x7f\x6d\xb5\xff\x20\xac\xf6\x0d\x4a\x80\xd1\x3e\xec\x05\xdc\xe3\x60\xb5\x0f\x92\x52\xc8\xe9\x6c\x36\x44\x9f\xcb\x7a\x33\xe0\xb9\x70\xa8\xd6\x7b\x20\x1f\xf1\x2b\xd7\x85\xe0\x80\x14\x19\x3b\x3f\xa7\x59\x0e\xe5\x38\x2a\x9e\x81\xe4\xd5\xe8\x5b\xd6\x5e\x05\x6b\xaf\x82\xcf\xbd\x1c\x34\x5e\xaf\xc6\xda\xc7\xa2\xbc\x14\xeb\x63\x62\xaf\xc6\xfa\x94\xac\x9d\x67\x7e\xaf\xce\x33\x77\xf7\xa8\x5a\x95\xfb\x8d\x68\xe1\x38\x61\x77\xf2\x6c\x81\xfa\x33\x5d\x5b\x00\xea\xde\x7c\x5b\xa0\xf5\x3f\x85\x73\x0b\xcc\x74\x11\xef\x16\x5c\x9a\x65\xdd\x5b\xf2\x22\x2c\xa8\x7c\x67\x49\xe3\x9e\x5f\x28\x99\xe6\x14\xb3\x3d\xe1\xe7\x82\xcb\x40\x33\x28\xe0\x03\x8b\xd6\xcd\x6a\x8b\xd6\x21\xcb\xf2\xe2\x2d\x9f\x42\xbe\xa8\x6c\x4a\x5d\xa7\x00\xc7\xda\x3e\x9d\x26\x89\xeb\x2d\xf0\x9e\x4a\x05\x2c\xcc\x58\x6b\x0c\xcc\x5c\xfd\xd0\xd3\x72\xc4\xc7\x17\x6c\x42\x74\x84\x75\x00\xb8\x1a\xd1\x0c\x87\xab\xf5\xfe\x62\x3a\x20\x9b\x44\x35\x2f\x4b\x2f\xc3\x8c\x85\xf2\xdd\x58\x61\x83\x8e\xc6\xb8\x76\x49\x85\x78\x21\x98\x01\xe3\x4a\x59\x0c\xde\x94\xcc\x77\x05\x3e\xc3\x23\x4a\xce\x5e\x29\x80\xba\x43\x96\xc6\xaf\xde\xbd\xfd\x51\x1c\xf7\x96\xbf\x8c\x4e\x62\x4b\xa8\x6e\x85\x02\xff\xc7\x87\xb7\x3f\xa8\xc7\x9c\x6d\x4c\x5c\x92\x44\xd8\x3e\x17\xa4\xda\xaa\x7e\xfb\xe9\xd3\x05\x5d\xa2\x16\xe9\x66\xed\x1e\xb5\x94\x57\x8a\x91\xbf\xae\xd0\x87\xc8\x0c\x9c\x86\xb9\xb4\xc3\xf6\x07\x80\x5f\xc4\x3f\xf4\xdd\xf4\x01\xb9\xb2\x94\xe5\xd8\x0f\x6b\x61\x6a\x84\x79\xbe\x64\xb2\x27\x45\x8e\x4d\x8b\x31\x57\xd5\xb5\x77\xd7\x97\x39\x47\x8e\x57\xcc\x4c\x6c\xc9\x47\x61\x36\xf9\x13\x1c\xa2\x55\xac\xca\x7c\xb7\x4a\x3d\xfa\x2f\xef\x55\xe6\xa2\x3d\xe6\x9b\xa8\x41\xfc\xad\x2d\xf2\x23\x27\x29\xa5\x31\x3e\xc0\x2c\xf5\xff\xd5\x88\xa6\x5e\xac\x13\x96\x93\x11\x8b\x63\xed\x95\x52\x87\xbf\x26\x5d\xd2\x3d\xa3\x46\x30\xcb\x2f\x8f\xc6\xcd\x6b\x48\xe3\x2f\xe5\x9b\x27\xdf\x2a\x8e\x73\x9e\x5e\xe9\x57\x2c\x06\xce\xb4\xc6\x4f\xaf\x04\xe7\x32\x99\xc0\x0a\x77\x0d\x7f\xab\x58\xe2\xe3\xe3\xf7\x1d\xc2\xd3\x88\x96\xb7\x75\x2c\xe0\x68\x0c\x1a\x70\x81\x0d\xa6\xb1\x82\x83\xfa\x99\x66\xc9\x8d\xd8\x7c\x4a\x58\x51\xef\x13\x66\x2f\x36\xf2\xe7\x80\x5a\x05\x17\xa7\x81\xb0\x94\x15\x2c\x4c\x2c\xe5\xfa\x25\x2a\x40\x95\xd6\x14\xb7\x55\x2a\x49\xec\x86\xc0\x3b\xea\x8a\xe5\xa5\xc0\x3b\x03\x0a\x02\xf5\x14\xb1\x95\xa5\x87\x90\x58\xa5\xbb\x61\xc8\x35\xcb\xbb\xd3\x49\x1c\x16\xf4\x27\xc9\x5d\xb7\x4a\x46\xf6\xa5\x94\x99\xba\x93\x5f\x58\x92\xbc\xa7\x11\x65\x97\x60\xd0\x98\xcf\xda\x0f\x1f\xbe\xe5\xa5\x98\xcd\x69\x71\x2c\x36\xc7\xf2\x4f\xb3\x9f\x21\x30\x78\x8f\x90\x34\x0d\xef\x15\x8b\x7f\x86\xb9\xcd\x81\x27\x08\xd8\x9a\x64\xf4\xf2\x27\xdb\xbd\x45\x39\x9b\xc8\x62\xeb\x55\xf0\xd5\xa1\xed\xf3\x69\x7d\x78\xf4\x88\xcc\xbb\xed\xb8\xf4\xee\xeb\x86\x4b\x97\x0c\x0c\x95\xac\xc9\x8c\x69\x3f\x1a\x85\xe9\x39\xa4\x7d\xb5\x5b\xc5\x1d\x2e\x02\x45\x83\x56\xba\xc9\x3f\xa7\xe3\x79\xce\x9b\x05\xea\x6f\xad\xfd\x2e\xec\x46\xe2\x5d\x93\xb4\xea\xb7\xd0\x1d\x6d\x4d\xb7\xfe\x94\x1c\x76\x85\x6a\xab\xa7\x86\x47\x58\xd3\x1b\x4c\x35\x30\xfb\x19\xa6\xb4\x96\x48\x86\x2f\x59\xce\x06\x2c\x91\xee\x9d\x52\x0a\x63\x25\x99\x2b\xdf\x7b\xf6\xb5\x27\xdb\x9a\xbd\x3d\x4b\x38\x2a\x8b\x7e\x76\xa4\xa3\xb2\x93\x64\x76\x86\x0b\xf3\xc3\x74\x50\x56\x17\x94\x0f\x43\xe3\x07\xe3\xc6\xbc\xa0\xf3\xb2\x1a\xff\xbd\x39\x32\x57\x38\x29\x3f\x7a\x44\x8c\xf4\xc8\xba\x13\xcb\x3e\xcb\x2e\x5e\x23\x8d\xb9\xb3\xef\x72\x85\xf9\x6a\xd9\x87\xf9\x13\xc1\x8c\x78\x7d\x12\xa0\xb5\x54\x20\xae\x69\x24\x25\xfd\x32\x75\x21\xb7\x1d\xaf\x83\x99\xe3\x98\xe5\x45\x3d\x97\x1f\xf5\x9c\x7e\xd1\x0b\x79\x46\xd7\xfa\x46\x57\x01\x81\xa2\xc5\x67\x6e\x5d\x40\xdf\xa3\xd9\x3b\x28\xd2\xd7\xdb\xfa\xa0\x5c\xaf\x3b\xc4\x9d\x6a\x46\x87\x0e\xbd\x19\x7a\x8c\xb3\x5e\x57\x20\x3a\x9e\xb8\x90\xc7\xf4\xc0\x81\xbb\xb5\x7b\x6c\x57\xd1\x1e\x5d\xd4\x96\x7f\xd5\x7a\x7c\x03\xe3\x38\xd3\xe5\x1b\x85\xb3\x15\x3e\xdf\x96\x81\x03\x8a\x05\x1f\xbe\xe3\xb7\x16\xa9\x7b\xee\x2b\x77\x4b\x7c\xb4\xf5\x35\xf9\xe5\xf5\x77\x3f\xbd\x3c\xfa\xdf\xe4\x5f\x2f\xdf\x93\x37\x3f\xfe\xf3\xf5\xd1\x87\x37\xef\x7e\x24\x5f\x6f\x99\xd6\xce\x13\x3e\x08\x13\x88\x36\xff\x35\x79\x45\x0b\x1a\x15\x64\x98\x51\xc1\xb9\x66\xe8\x10\x7b\x86\x20\x67\x60\x47\x42\xc4\xb5\xdb\xfd\x35\xef\x8a\x91\x09\x3a\x26\x60\xff\x0e\x00\xe2\xf6\xc1\x67\xe8\xb9\xfc\x7d\x48\x02\x24\xb6\x60\x3d\x28\x4b\xf5\x5f\x5d\x74\xa7\x81\xc7\xaa\xfc\x53\x7f\xab\xf2\xf7\x31\x3d\x1d\x34\xce\xed\x16\xc4\xef\xad\xa6\xe5\x69\x3d\xd9\x6e\xb7\xdb\xa5\xe5\xbe\x5b\x16\x20\xb1\x1a\x2c\x57\x93\xaa\xec\x76\x77\x5f\x1e\x0d\x96\x1f\xdf\x8c\x07\x3c\xa9\x33\xa5\x7f\x26\x91\x81\xfc\x9c\xd3\x98\x84\xb9\x38\x9f\x34\xa3\x69\x44\x73\x78\xc6\x8a\xcd\xe1\xd3\x9c\x9c\xfd\x08\x8f\xfc\x33\x12\x71\x60\x72\x0a\xb3\x31\x3f\xbe\xfc\x91\x1c\x92\x1e\xd9\x02\x2b\x4f\xdd\x56\xc1\xc9\x18\x52\x0c\x24\x34\x8c\xc5\x35\x1e\xa6\xb1\x78\x9b\xb0\x44\xfc\xb8\x1a\xb1\x82\xe6\x93\x30\xa2\xba\x9d\x8c\x7e\xc8\xd8\x98\x1c\x92\xad\xff\xfb\x9f\xfc\xf1\x6f\xff\xc9\x1f\xff\x75\xeb\xdc\x6b\x31\x46\xbc\x19\x84\x31\xc9\xd9\x79\x4a\x63\x32\xa2\xd7\x61\x4c\x23\x36\x0e\x13\x99\x9a\x51\x3e\x85\xac\x76\xdf\xe4\xdf\x85\xf1\x3f\x20\xc3\xf0\xd6\xff\x3d\xd9\x7c\xfc\xb1\x77\x7d\xd2\xdb\x7c\x1e\x6e\x0e\x3f\x3e\xfe\xeb\x16\xab\xe9\x83\xa5\x61\x76\xd3\xd4\x26\x02\x88\x36\x7b\x83\x93\xde\x76\x43\x5b\x3c\x2a\x1a\x87\xf7\x0e\xbe\x43\x4b\xfc\xa4\xb7\xf9\xcc\x6e\xea\xbb\x29\x4b\x8a\x4d\x96\x92\x31\x2d\x46\x3c\xb6\x37\xe8\x0a\x59\x0b\x12\x92\x98\x4e\x04\x1f\x97\x46\x37\x84\xa7\xe4\x2c\xe3\xbc\x38\x73\x4e\xce\x4f\xd2\x4c\xd5\xb2\x58\x35\x81\xfa\x8e\x78\x7a\x49\x05\xee\x9f\xc1\xd8\xce\xc4\xc8\x95\x6b\x75\x77\x83\x00\xcc\xdf\x30\x29\x2b\xfc\x39\xa6\xe2\xcb\xbb\x21\x39\xc5\x2f\x4c\x3c\x84\x9f\x74\x7b\xdd\x1e\xfc\x8e\xc2\x82\x9e\xf3\xec\x86\xfc\x10\xa6\xe7\x50\x32\x09\xb3\x70\x4c\x3e\x7d\x7d\x8b\x93\x07\x75\x35\xfe\x85\x6f\xe2\x88\xe6\x39\xc4\xfe\xfb\x1b\x52\xe6\x9c\x7c\xc2\xde\x6f\xc9\x7b\x59\x00\x76\xe3\x7a\x44\xe4\x6f\xf4\x3a\x1c\x4f\xc4\xfd\x03\xa3\x3b\xed\x16\x1c\x31\xb4\xb5\xdb\xdd\x11\x34\xfe\x6b\xf1\xd0\x39\xfc\x96\xec\x76\x77\xca\x30\xf8\x4f\xf7\xed\x9b\x1f\x4f\xff\xf5\xf2\x87\x9f\x5f\xdb\x15\xf6\xe8\xe6\xee\xce\x93\x72\x9d\x37\xe9\x50\xbc\xba\x6f\x6c\x58\x55\x56\x86\x0e\x76\xbb\x3b\x41\x79\x1c\x5b\x56\x2c\x07\x05\x0a\x0b\x61\x9c\x65\x25\x69\xc3\xe5\xa9\x70\x92\x97\x77\xd7\x25\x7a\x23\xe1\xb5\x26\xea\xa9\x93\x2e\xdb\xf3\xc0\x7f\x7c\xf9\xa3\x0b\x8c\xe4\xc3\x03\x06\xa3\x6d\xc9\xc2\xda\xe3\xe8\xc2\xff\xbe\x1b\x12\x5f\x0f\xef\x7c\x6d\xb5\x49\xdf\x8c\x8b\xa8\x29\x68\x5a\xd5\xc2\xc8\x2c\xe4\x05\xc1\xbf\xc8\x63\x12\x04\xa2\x0e\xfc\xb2\x87\xe7\xac\xc1\x57\x65\xd3\x6f\x7b\x0d\x80\xac\xf7\xd4\x58\x48\x9f\x3c\x76\x96\x46\x0d\x02\x47\x9a\xd1\x49\x12\x46\xb4\x85\xb4\xa6\x23\xfa\x57\xc6\xea\xcc\x1c\x68\x73\xba\xbb\x05\xcd\xd5\x22\x59\x8c\x43\x4b\x03\x83\x53\xb3\x3c\xc0\x36\x30\xf2\x1e\x2f\x9c\xb3\x87\x9f\xba\x79\xc2\x22\xda\xda\x69\x77\x4c\x97\x2f\xc8\x0e\xe9\x93\x7d\xac\xd4\x27\x2d\x43\xb2\xec\x36\xc9\x0b\xa0\xb5\x6a\x86\x6d\x30\x4f\x2e\xdd\x5e\x0a\xaf\xc4\x2b\xc0\xbb\x76\x56\x9b\xe2\x6d\x45\x4e\xaa\x2f\x27\x93\xef\xc2\xda\x3c\x4f\xbb\x7b\x5f\x38\xcf\x13\x0e\xef\x01\xe4\x79\xda\x5f\x65\x96\xae\xb9\x38\x36\x49\x98\xa1\xfa\xca\xd2\x42\xc1\xab\x21\x77\x23\xfa\x7c\x06\x6f\x65\x77\xe0\x75\x7d\x3c\xab\x81\x6f\xea\xca\x6b\xf9\x61\xfa\x47\xa3\x55\xce\xfd\x79\xae\x82\x25\x4f\x1a\x8e\x6b\xe3\x2b\xed\x54\x80\x36\x35\x6f\xa0\x1c\x3f\xcc\x63\x85\x3d\x95\xfe\x94\x15\xa0\xb3\x7c\x36\x11\xca\x0c\x8e\x27\x3c\x7b\x1b\xa6\x6c\x32\x4d\xc2\x82\xd7\x91\xa5\xed\x9d\xbd\x3f\xb9\xeb\xe6\x12\x43\xfb\x80\x29\xdd\x57\x32\x3c\x68\x6b\x9e\x21\x6a\x72\x53\xa2\x3f\xc6\xaf\x07\x4a\x5a\x20\x3d\x73\x6c\xeb\xe4\xfd\xc0\xb9\x7e\xcd\x13\x2d\x7a\x07\xb1\x6a\x12\x16\xec\x52\x69\x0c\x08\x89\x59\x3e\x49\xc2\x9b\x3e\x09\x86\x09\xbd\xd6\xc5\x61\xc2\xce\xd3\x37\x05\x1d\xe7\x7d\x12\x44\x14\x45\x7b\xf2\xdb\xaf\xd3\xbc\x60\xc3\x9b\x23\x74\x6a\x29\x7f\x17\x0d\x1d\x8f\x32\x96\x5e\xf4\x49\x4f\x15\x82\x33\x56\x9f\x3c\xd1\x05\xe8\xba\x64\x97\x0c\x21\xa7\xe4\x98\x25\x37\x5a\xd9\x7a\x33\xe1\xe7\x59\x38\x19\xdd\x74\xcd\x47\x1b\xfc\x58\x8a\xc8\x3c\xe0\xc9\xf5\x07\xfe\x9e\x8e\x5b\x3b\x3d\x2d\x6c\x19\xf0\x2c\xa6\xd9\xfb\x30\x66\x53\x31\xa5\xbd\xde\xff\xe8\xf1\xaa\x70\x26\x7d\x2d\xf6\x53\x5f\xa6\x39\xcd\x8e\x69\x42\x23\x31\x4b\x70\xf4\x93\xfa\x41\xf8\x07\xce\xdd\x2b\x75\x00\xd4\x62\x47\x98\x66\x17\xc7\x34\x09\x13\x5a\x14\xb4\x3b\x08\xa3\x8b\xf3\x8c\x4f\xd3\xd8\x17\xbe\x99\x2f\x32\x3f\x2f\xea\x0c\xbd\x23\xdd\xa5\xe3\xc9\x28\xcc\xd9\x7f\x41\xa8\x3f\xa3\x65\xd2\xeb\xee\x3c\x6d\xdb\x23\x65\xe3\x73\x33\xc0\x71\x78\xfd\x0b\x6e\x46\xb0\xdd\xb3\x96\xe1\xaa\xaa\x50\xed\x52\x10\x4e\x0b\x1e\x18\x91\x94\x31\xda\xbc\x8b\x9b\x14\xbc\x38\x19\x28\x58\xc4\xcb\x15\xed\xe1\xc0\x8d\x36\xcf\xa2\x33\xc2\x33\xf8\xe3\x98\x16\xe2\x75\x87\x55\x64\xa4\x34\x12\xa6\x24\x4c\x0a\x12\x16\x45\xc6\x06\xd3\x82\x6a\x03\x62\xd4\x0d\xd0\x98\x9c\xb1\xf1\xf9\x59\xd9\xe5\x2a\x14\x9b\x55\x67\x4e\x2b\xc3\x1e\x95\xc6\x58\x70\xd9\x2e\x61\x11\x4f\xc5\xc0\x0a\x7a\xad\xfd\xb9\x72\xc2\x52\x30\x32\x14\xfd\xbf\xbc\x0c\x8b\x30\x93\xb6\xca\x38\x8f\x30\x8d\xc9\x59\x98\x14\x67\xe8\xc9\x8b\xaa\xcb\x94\x83\x43\x32\x04\x96\x17\x00\x29\x97\x23\x16\x5f\xb1\xf6\xc0\x9a\xcd\xe0\x46\xd1\x5a\x6c\x7a\x43\x9a\x50\xcb\x40\x6d\x03\x58\x11\x39\x1e\xb0\x76\x16\xa7\x94\x84\xf2\xfd\x5e\xe5\x71\xd6\xe4\xdf\x24\xe3\x66\x35\xae\xd2\x97\x71\x59\x5b\xb1\xeb\x98\xef\xa9\x65\x9b\x40\xc3\x8b\x5f\x07\x1b\x53\x7a\x4b\xf4\x22\x73\xd0\x0a\x71\x64\x70\x43\x8e\x46\x6c\x02\x9b\xf9\x03\xcb\x0b\x41\x3d\xdf\x44\xf0\x68\x96\xfa\x0c\x83\x1e\x80\x46\xe5\x4d\x39\x52\x9d\x2d\x8a\xa1\xc3\x69\x22\xba\x41\x0e\x12\x6d\x5f\xa1\xc7\xd0\x04\xfb\xd3\x4a\xcc\xdc\xea\x57\xf4\x47\xf3\x3b\x25\xcd\x88\x96\x1a\xf3\x07\xc7\x02\x01\x0e\x81\x3e\xc0\x9c\x17\x68\xf7\x81\xa0\xaf\x19\xbc\xbb\x15\x2a\x83\x5a\x39\xa7\x24\x24\xaf\xde\xbd\xd5\x6a\x50\x2e\x00\xec\x94\x0c\x6a\x74\xaa\x68\x49\x0f\x4b\xbc\xff\xef\x86\xb2\xd0\xc6\x4a\xd1\x16\xc2\x66\xba\x0b\x6a\x18\x68\x7b\xd3\xc5\x7a\x3a\x74\xb0\xc2\xac\x07\xeb\xab\x1c\x17\x05\x57\x2c\x81\x20\x28\x6c\x1c\x9e\x53\xcb\xf5\x70\x7c\x0e\x74\x7c\x61\x37\x8f\x33\x71\x75\xe5\x67\x15\xe4\xba\x86\x4a\x03\xfc\xc2\x18\x25\xc9\xed\xdc\x9d\x64\xd1\x52\x5d\xc0\x85\xb4\x48\x2f\xc7\x74\xd6\x9d\x83\x6e\x14\x9a\xbd\x43\x2a\x61\x07\x22\x15\x57\x6d\x08\x9a\x12\x19\x67\xdb\xb0\x10\xf2\x14\xeb\x4f\xf2\xb7\xf3\x59\x1c\x50\xa9\x26\xb6\x80\x44\xa9\x06\x93\x34\xc8\x85\xf2\x14\xe1\x25\x42\x55\x09\x7d\xe4\xb7\xad\x55\x53\x2e\xb8\x2a\x55\x60\x0a\xbd\x34\x84\x2a\x50\x00\x80\x15\xfa\x2b\xfc\xd2\x9f\xb2\xc8\x7c\xc8\x22\xab\xf8\x98\x16\xf6\x97\x63\xaa\xfb\x5b\x50\xf1\x6d\xc2\x77\x83\xd4\x26\x90\xeb\xac\xff\x14\x33\xf6\x63\x7a\x97\x96\x04\x0a\xd5\xc4\xc5\x0f\x35\x47\xd0\x8a\x8b\x19\xc1\x1f\x59\x24\xff\x39\xa6\x85\xd6\x8e\x3b\x61\x31\xd5\xb8\xad\xa7\xa9\x19\xaa\x1c\x5a\x57\xd0\xd2\x8e\x72\x52\x70\x84\x03\xae\x32\x5d\xc1\xdb\x2c\x6d\xc7\x45\x89\x47\x8f\xc8\x57\x62\x91\xe5\xbf\xc7\xb4\x68\x77\x5c\xdc\xd2\x52\x49\xcb\xa0\x02\x83\x96\x4a\x09\xa9\xdd\x9e\x1d\x4f\xb1\x1a\xab\x4c\x48\x0d\x67\x1c\x5f\x59\x51\x35\x04\x8c\xaf\x06\x65\xf9\xbf\xc2\x84\xc5\x4a\x07\xee\xf4\xe9\x19\x8c\x94\xfa\x6d\x5e\xd3\xaa\x51\xba\x8b\xd4\xf5\xce\x96\x36\x73\xb1\x4d\x4c\x7c\x95\x7d\xc2\x53\x5a\x35\xda\x0e\xf9\xe4\x5c\xae\xe5\xd1\x6a\x1b\x31\x3b\x08\x8b\xd3\x99\xdd\x9e\xa5\x50\x36\x31\x2f\xc4\x8e\xfe\xf6\x9b\x3c\x26\x6a\x79\x9a\x46\xeb\x06\xb2\x64\xe3\xf3\xa0\x33\xcb\x78\x00\x38\x6e\x8b\x5e\x01\xd9\x2d\x9d\xd1\x3e\x71\x0f\xa7\xbc\x01\x9c\x43\x6e\x2d\x87\xc2\x58\x36\x3e\x97\x2f\x1d\x4d\x3e\xda\xc6\x00\x73\x7e\x73\x0d\x87\x44\x61\x7f\x75\xd3\x2a\x0d\x03\x37\xc3\x0d\xe2\x6e\x29\xf6\x51\xe6\x2d\xdf\x05\x76\x4c\x6f\xa5\x44\xa2\xe9\x65\xf7\xc7\x77\xaf\x5e\x9f\xbe\xfe\xf1\x5f\x80\xdf\x7f\x99\x64\x3c\x9e\xc2\x55\xf0\x17\xf2\x42\x7b\x5c\x7d\x9a\x9b\x65\x73\x82\x00\x3c\x1c\x2e\xe8\x2e\xf1\x26\xfc\xfa\x8b\xc6\x9c\xb8\x27\x2e\xcc\x5b\xe9\x79\x5e\x97\xeb\x47\x58\xc5\x23\x6c\xf1\x47\xd0\xc6\xed\xac\x9b\x0d\xbd\x0b\xad\x7b\xba\xf1\xcc\xb4\x17\x69\x4e\x5e\xe5\x8d\x03\x9c\xbb\x41\x8b\x1d\xf8\xa3\x3d\x52\xe6\x5d\x03\x8b\x0b\x5a\xc9\x26\x29\x4e\x6a\x25\x1b\x84\xdc\xd8\xaa\x9a\x12\x1c\xdd\xec\xd6\x04\x7c\x9b\xf4\xc9\xa7\xdb\x03\x75\x75\x54\x58\x73\x59\x84\x1d\x82\x4a\xc3\x33\xa2\xc1\xb8\x4a\xea\x17\xcc\xb0\x50\x8e\x2c\x58\x8d\x14\x4e\x5c\xf0\x76\xca\xb0\xbb\x80\xdc\xb6\x5b\xf8\x67\xbb\x51\xf7\x36\x8f\x45\xd1\x6e\x95\x41\xd1\xd3\x2f\xa9\x1b\x6c\x48\xf4\xe1\x28\xec\x88\x32\xbf\xea\x86\x79\xce\xce\xc1\xd3\xd6\x78\xd3\xa0\xe1\x66\x9b\x7c\x32\xae\xde\x8c\x1c\x92\xed\x03\xc2\xc8\x37\x25\x77\xef\x03\xc2\xc0\x81\x1b\x4d\x5c\xf9\x34\x83\x70\xa4\xc6\x75\x9b\x7d\x3c\x30\xed\x5c\xd0\x1b\xc2\x52\x09\x26\x2a\x09\x76\x4d\x0e\x65\xa2\xfc\xab\xbb\xa3\x30\x7f\x77\x95\x2a\x7c\xc3\x9d\xc0\x2a\x1d\xd1\x82\xe0\x78\xa5\x75\xe9\x89\xf4\x14\xc7\xaf\xf0\xeb\x80\xdc\xc2\xff\x49\x2e\x09\xe1\x0e\xc8\xed\xe7\xc8\x3f\x72\x7f\x6a\x3d\x88\x02\xfe\x36\x9c\x4c\xa4\x19\x76\x95\xde\x72\xaf\xf7\x79\x73\xa0\xd4\xbd\x2e\x45\x17\xb0\x51\xb9\x42\x0b\xdc\x04\x71\xbc\x6f\x0f\x6c\xa4\x62\x30\x00\x85\x07\xa2\x46\x97\xa5\x31\xbd\x7e\x37\x6c\xb1\x36\xf9\xf6\x90\xf4\xda\x10\x66\x8c\xa5\x53\x7a\x80\x96\xd0\x73\x21\x0b\x0c\x80\xb5\xed\xca\x12\x5f\x98\xc0\x16\x3e\xf8\x15\xd0\xb2\x8c\x24\xf6\xec\xdc\x98\x08\x2d\xe5\x52\xd0\x21\x96\xc7\x94\x1a\xfa\x57\xfa\xb3\xed\x7a\x60\x03\x02\xce\x8e\x32\x7e\x05\x09\x35\x04\xc6\x60\x52\x8d\xbf\x1c\x85\x69\xca\x0b\x22\xc6\x4d\x42\xe4\x84\x49\x98\x93\x50\x1f\xc8\xbf\xb4\x01\xa5\xed\xa1\xd5\xfa\x6e\xb5\x72\x9a\x0c\x3b\xd0\x98\x1e\x9a\x28\x72\x7b\x7f\xaf\x0c\xd7\xe4\x10\x20\xd6\xc0\x28\xcc\x31\x9c\x28\xf8\x1c\x81\x53\x13\xcb\x69\x4c\x36\x49\x3e\x9d\x80\x5f\x82\x0d\x21\x7a\xa0\x31\x0e\x4d\x2e\x22\xcc\xe0\xd1\x23\x6d\x33\x04\xbf\xc5\x05\xfe\x17\xc4\x93\xbf\x08\x2a\x53\xfa\x66\x66\x49\x5e\x60\x71\x9f\x88\x11\x7b\x9b\xa1\x02\x63\xb4\xf2\xe9\x00\x78\xa9\x0e\x0e\x0b\xfe\x56\x53\x95\x8d\x9b\x0f\xf8\xee\xd0\x5d\x88\xd1\x79\x1f\x65\xda\x99\xea\xad\x39\x16\xb0\x82\x68\x67\x34\x87\x64\x2f\x90\xed\x84\xa2\xe8\x76\x40\xa1\x32\x0a\x69\x55\x17\x1d\xd0\x80\xfc\x85\x3c\x26\xa5\xb1\xc0\x52\xa9\xd1\x1b\xfc\x35\xa4\x58\x3a\x80\x5a\x03\x74\x86\x6b\xaa\xc0\x1b\xda\xec\x7c\x1f\x0e\x19\xd8\x78\x98\xc5\xb1\x2d\x6f\xc0\x03\xab\x43\xae\x32\x56\x58\xa6\x38\x26\x62\x83\x2e\x13\x68\xd6\xc6\x73\x66\x2f\xae\x1c\x5f\xee\x46\x76\x7f\x51\x5d\x5e\xb3\x41\x66\x6c\x56\x70\x8d\x43\x0b\x44\x6b\xd9\x2f\x55\xfc\x50\xd9\xbc\xfc\xed\xdc\x50\x48\x34\xcc\x53\x58\x82\x0a\x02\x02\xdf\xba\xe3\x70\x62\x45\xab\xb8\xf0\x2c\x8c\xc4\xf9\xbf\x80\x70\x22\xb7\x6d\xa3\xf3\xb3\x2f\x06\x47\xa1\x77\xf6\x8d\x97\x50\xe8\xdb\x33\xa9\xc2\x12\xc7\xf4\xec\x9b\x98\x5d\x7e\x7b\x66\xeb\xb2\x20\x9a\x0f\x64\x1a\x42\xa7\x2f\x71\xbe\x94\xf2\x6b\x14\x5e\x32\x9e\x09\x68\x54\xfa\x81\x3d\x2e\x39\xd3\x3c\x0f\xaa\xd3\x2a\x65\xfd\x55\x99\x4a\xc2\x14\x54\xc7\x76\x8c\x46\x5a\x10\x3e\x74\x06\xfd\xed\x99\xa5\x28\xe9\x90\x62\x14\x16\x24\xcc\x28\x29\xf8\xf9\x79\x02\x4a\xc5\x14\xf5\x79\x60\xc2\x0a\x16\x9e\x37\xd8\x5c\x42\xc3\x4b\xda\x45\x41\x70\xc5\x2a\x80\xce\x8f\xa5\x60\xfe\x8c\x91\x8b\x58\x64\x7b\x3d\x4a\xe1\x62\x2e\xd5\x9c\x19\x45\x7b\x55\x50\x1e\x4d\x32\x1a\x82\x56\x67\x0c\x87\x6f\x7a\x3e\x12\x88\x77\xc3\xa7\x30\xb4\xab\x4c\xde\x75\x7e\xd7\xdf\x9e\x91\x50\x2e\x26\x28\x55\xf9\x34\x23\x67\xdf\x7c\x1f\xc6\xf4\xdb\x33\x22\x4d\x51\x2b\x15\x83\x15\x8b\x97\xf2\x98\xba\xc2\xf0\x97\xe2\x54\x5c\xd2\x94\x09\xea\x08\xc3\xc7\xd5\xc2\x0c\x58\xb9\x38\xec\x31\xcb\x21\x1b\x96\x4a\x12\x69\x92\x47\x61\x13\x2a\x50\x93\xea\xba\x4b\x7e\xe4\xe0\x2d\x18\xaa\x35\xba\xc1\x79\x31\xa9\x33\xe5\x97\x34\xcb\x50\xfb\xab\x51\x28\x17\xdb\x88\xed\xf1\xd4\x8a\xf1\x64\xa4\x58\x1f\x2c\xb7\x04\xa3\x06\x96\x9e\x22\x55\x93\x1d\x70\x9e\x74\x96\x9d\x2b\xc6\x6f\x7c\x48\x53\x6d\x48\x1b\xe4\xcd\x74\xd1\xa9\x3a\x11\x2a\x73\xd9\xc2\x6a\xa7\x3a\xff\x5c\xe5\x64\x6b\x73\x1a\xe1\x5c\xed\x6d\x55\x91\xc4\x94\xb7\x2a\xc4\x24\x22\xc0\x4d\xb2\x4b\x2a\xfd\x2f\x73\x34\x2c\x47\xb5\x6f\x98\x13\x06\x0e\xd3\x14\xc3\xe0\x75\x2d\x35\x3c\xcb\xc9\x39\x4d\x69\x06\xe1\xc5\x62\x9e\x52\x41\xb9\x30\x25\xfc\x99\x2d\xe4\x3d\x23\x23\x7e\x45\x2f\x69\x26\x78\x3a\xd0\xc4\x85\x39\x68\x97\xc3\x54\x35\x8b\xad\x62\x97\x10\x13\x54\x8a\x5d\x46\x82\xdb\x49\x04\x35\xb8\x41\xde\x02\xf3\xde\x28\x03\x82\x82\x84\x91\x78\xe0\x08\x7e\x47\x69\xff\xc4\xed\x27\xee\x37\xdb\x6a\xe0\x0d\x12\x8f\x98\xfb\x7e\xba\xee\x34\x81\xa2\xe5\x00\x2a\x28\xb4\xb6\xbc\x20\x67\x00\xf5\x7d\x28\xae\xd4\x9b\x33\x6c\xb3\xe0\x40\x88\x88\x98\xd8\x0d\x36\xd3\x11\x3f\x70\x8a\x3c\x15\xeb\xa8\x88\xa9\x74\x09\xb2\x87\xf4\x37\xb8\xe0\xbf\x57\x2f\x35\xa8\xdf\xc7\x74\x71\xda\x23\x75\xf3\x5b\xa7\xc0\xa5\x5c\x72\x34\xd5\x5b\x2f\xee\x37\x7d\x79\xcd\xf1\x8c\xee\x94\x5a\x35\xbe\xc0\x56\x31\x0e\xd3\xbb\x31\xa1\xec\x40\x39\x3a\x29\x6f\x85\x0f\x35\xd7\x82\xd1\x81\x8f\xc3\x34\x3c\xa7\xe2\x9a\x9c\x75\x2d\x89\xf6\x58\x4a\x42\x92\xb0\xbc\xe8\x92\x1f\xd8\x05\x45\x02\x5f\x71\x01\x18\x1d\x5b\x55\xf7\x1d\x81\xb4\xa1\x68\x0f\xc3\x67\x8d\xc3\x68\xc4\x52\xd4\x68\xc2\x78\xd4\xb5\x02\x2e\xcf\xca\x1f\x66\x9a\xea\x9f\x82\x3f\xd5\xe3\x82\x83\x2c\x1a\x2b\xd8\x98\x2a\x17\x0c\xc1\x77\xb3\x98\xa2\x86\x54\x5e\x3a\x64\x40\x13\x7e\x25\xcf\x06\x0c\x5a\x5c\x4a\x67\xe4\xe8\xf8\xd8\xbe\x12\xc1\xa3\x6a\x40\x87\x3c\x83\xd6\xc8\x4b\x81\x95\x74\x9c\x03\x0e\x29\xcc\x17\xc4\x26\x8e\x8d\xb6\xfb\x03\x8f\xf9\x0f\x2c\x2f\xa4\x46\x36\x45\x26\x41\xcc\x53\x5e\xe1\xa2\xa5\x70\x5a\x70\x41\xb4\x22\x38\xab\x83\x9b\xba\x5b\xdb\xb0\x27\xd3\x9c\x92\xd3\x30\xbd\x39\xf5\x16\x58\xb4\x66\x45\x52\x48\x81\xcb\xa9\x58\x67\x71\x38\xc1\x22\x27\x42\xa7\x11\x51\xef\xec\xec\xec\xd7\xfc\x1a\x76\x73\x3c\xe1\x99\x9d\x43\x02\xea\xe1\x02\x04\x98\x15\xd1\xcf\x85\xb8\xe5\x01\x07\x07\xb2\x55\x7c\x16\xe9\x65\x50\x62\x0c\xcc\xbc\x68\xf2\x55\x7c\x12\xb0\xc4\x66\x8e\x2d\x6d\xf3\xd7\xa8\x81\x81\xc7\x0c\x96\xaa\x32\x37\x14\x1b\x43\x03\xc1\x93\x60\x44\x93\x84\x07\x1d\x12\x5c\xf1\x2c\x89\x51\x23\xca\xa2\x0b\xf1\xc7\x98\x06\x1f\x6f\xb1\xba\xfc\x07\xdd\x37\x5f\xc6\x71\xcb\xea\x0c\x06\x22\x5e\x15\x60\x74\xa8\x7c\xb5\xd1\x6d\x17\xba\x51\xe1\xe1\x4e\x54\x0d\x22\x76\x76\x3c\x29\x5a\x01\x3a\x66\xe7\x7c\x4c\xc1\x2c\x2b\xd0\xa3\xfd\x88\xce\x2c\xa4\x1c\x7f\x81\xc8\xa1\xeb\x0e\x6f\x15\xa8\x33\xc8\xf7\x80\x65\xe2\x85\xad\x07\x9a\xd0\xe6\x61\xa2\xa7\x84\xe9\x58\xc1\x42\xf8\xfe\x88\xb6\x58\x87\x6c\xd7\x0e\xcb\x1b\x95\x3f\x28\xdb\xef\x1d\xeb\x2b\xdf\x0e\xb3\x28\xc0\x63\x9b\x9f\x84\x7c\x33\x98\x16\x05\x4f\x09\x4f\x8f\xc4\x9e\x1c\x7e\x6a\xb5\xc9\xe1\xb7\xb6\x27\x2d\x6c\xc5\xed\xb7\x2f\xe3\x98\x88\x6e\xbf\xd9\xc2\x1a\x6e\x2b\x3e\x52\xdb\x1f\x09\xf9\x54\x5a\x07\xf1\xae\x68\x89\x3f\x3b\x84\x41\x87\x2d\xb7\x06\x21\xc0\x8a\x5a\xf1\x5c\x2e\xe8\xcd\x21\xac\xc0\xed\xb7\x3e\x68\xc5\xb4\x74\xcf\x50\xe3\x53\x40\x82\xdb\xaa\xcf\xb3\x67\xaf\xf7\xb8\xaa\x5b\x5c\x63\x01\x50\xd9\x78\xd5\x4a\xa9\x4f\x55\x03\xfe\x66\xcb\x9d\xb3\x07\xd0\x6e\x3b\x73\xf8\xc6\x3f\xe4\x16\xb8\xdb\xbe\x83\x27\xb7\x92\xb8\x48\x82\x60\xb8\xaf\xaa\x0b\x88\xc4\x9c\xe6\x40\x9e\x50\x74\x0d\x4c\x98\xe6\xe9\xf4\x2b\xec\x2b\xd1\xd2\xeb\xeb\x30\x2a\x92\x1b\x72\x3a\xe2\x57\xa7\xf2\xfe\x81\x83\x24\x2b\x50\x60\x82\xa6\x13\x45\x8b\x2d\xae\xad\x81\x6a\xe6\x5d\xe4\x9f\xc6\x34\x4c\x0d\xb7\x31\x66\xd7\x70\xd9\xa0\x3b\xa6\x9d\x76\x36\xca\x78\x9e\x93\x98\x0d\x41\x32\x53\x88\xb6\xf4\x40\x80\xb6\x6e\xe1\x3d\xef\x53\xd3\xd9\x71\x45\x8d\xe8\xc4\xab\x3b\x33\xa6\xa8\x07\xaf\x4c\x45\x20\xee\xff\xb5\xd6\xab\xfb\x72\x32\x0c\x19\xe4\xd5\x55\xe1\x0c\xb6\xb6\xc8\x1b\x19\x30\x47\xb3\xbc\xf9\x88\x4f\x05\x7b\x86\x91\x6f\x94\x27\x76\x47\x7b\x52\x16\x82\x57\xc6\x97\x8d\x76\x8d\x53\x51\x3e\x1b\x24\x61\x32\x74\x91\x37\x45\x94\x0f\xe2\x37\x6f\x3e\x6a\x8c\x33\x62\x4d\x5d\xd0\x1b\x0c\x74\xd5\xd1\x19\x73\xfe\x01\xb0\x99\x6b\x88\x11\x4d\x33\xb1\x93\x9e\xe0\x16\x94\x16\x76\x19\x24\x91\xb1\x7e\xb7\x9d\x80\x4f\x6a\x91\xdc\x70\x10\x52\x8a\x5e\xd1\x43\x5b\xc7\xb7\xb4\xc0\x4b\xc3\xf4\x0a\xbc\xc0\x8f\xa7\x2e\xf9\x36\x33\x07\x42\x68\x47\x0b\xf0\xcc\x62\x94\x76\x41\x46\xb2\x10\x54\xb3\x3c\x7e\x42\x62\x9a\xd0\x82\xea\x8a\x27\x26\xb4\x2b\x31\xb4\xff\x93\xf5\x74\xd7\x5d\xdc\xea\xc8\x15\xca\x46\xc4\xd9\x32\x3f\x98\xaa\x69\x61\x8e\x55\xf7\x4c\xc3\xac\x0d\x77\xf8\x61\x35\x6d\x2b\x90\x89\x86\x74\xa3\x6f\x39\x51\x15\xca\x38\x85\xcd\x76\x2d\x6c\xc2\x02\x2f\xd0\x97\x59\x98\x5b\x6b\x09\xd5\x05\xa9\x83\xe4\x38\x06\x37\xd2\xaa\xc7\x8d\xfe\x60\xa2\x4d\x54\x45\x5c\x61\x69\x39\xbc\x84\x16\x26\xc0\xd8\x65\xfa\x21\xd5\x74\x80\x5f\x03\x27\xee\x83\x0e\xb1\x50\x55\x01\xdd\x29\x5c\x78\x19\x61\xa1\x12\xfc\x9a\x01\xcf\x43\xdc\x1d\x17\x7f\xa9\xad\xb7\x56\xe2\x14\xc3\xe3\x48\x03\x19\x8f\xf8\x58\xca\x02\xb5\xed\x47\x78\xe6\xed\xdd\xf3\x3e\xf9\x5e\x89\x3a\x2e\x52\xe6\xe5\x16\xff\x44\x58\xfe\x56\x3e\x1d\xfa\x32\x86\x14\x2e\x0e\x8d\x55\x24\x20\x99\xe1\x1a\xe8\x9f\x60\xba\x75\x02\x95\x21\x3b\x27\xd3\x34\xa1\xb9\x78\x7c\x0b\x56\x4a\xdc\x44\xe2\xa9\x24\xd9\x77\xe8\x63\x63\xe6\x9c\xa4\x05\xa2\x3d\x17\x7b\x31\x27\x96\x69\x9a\x92\x74\xe6\x15\x91\x9b\xc9\xb7\x64\x87\x3c\x7a\x64\x29\xef\x76\x30\x3d\xb8\xf6\x10\x24\x2f\xdc\x8f\x7d\x2b\xfa\xd0\x81\x13\x98\x19\x8a\x4e\xc4\xff\x8a\x26\x50\x54\xfe\xc2\x29\xed\xdb\x18\x8f\x65\x72\x9d\x1a\xa7\x5b\x8a\x13\x67\x4f\xbc\x3e\x88\x9c\xbb\x2f\x4a\x2b\xba\x40\x77\x7e\x18\xb4\xca\x6e\x4b\xb1\xd2\x52\x7a\x5d\x38\xa1\xc9\xea\x82\x3a\xe1\xbe\xd0\x4b\xef\xbe\xb0\x38\x50\x45\x9b\x0e\x34\xbc\x68\x7c\xf1\xfb\x45\x0f\xa9\x44\x9d\x3d\x7a\x5e\x6e\x6b\x4c\xb3\x73\x6a\x97\xe4\xed\x96\x3f\xe8\x4e\x69\x58\xaa\x79\x5b\x4a\xaf\xbb\xee\x0e\x79\xf6\x3a\x8c\x46\x2d\xe7\x86\xf5\xae\x52\x38\x2e\x87\xfe\x95\x61\x5d\x71\x5f\x59\xa4\xd0\xb5\x95\x94\xc4\xb0\x5d\xba\x19\x17\xa6\xe2\x32\x2a\xce\x1d\x88\xf8\xad\xd3\xf9\x28\xcc\x7f\xca\xe8\x25\x39\x54\x5a\x71\x7f\x25\x0f\x5c\xe0\x1f\x91\x60\x49\x60\x7f\x91\x9d\xa6\x75\x4b\x60\x8f\xe7\xb6\xea\xdc\xb7\xe8\x6e\xff\x03\x8a\xae\x9c\xb0\x6b\xa5\x65\xd4\xed\xb4\xc1\x5a\x56\xff\xd4\x61\xa9\xf4\x08\xb6\xb6\x90\x7f\x66\x39\x28\xd4\x5a\x8a\xa5\x6b\x5b\x1b\xa6\xe6\xf3\xe8\x11\x69\x7d\xa5\x56\xe2\xb7\xdf\xcc\x60\xda\x5e\xfc\x3d\xf1\x94\xe6\x09\xed\x26\xfc\xbc\x15\x50\x13\x8a\x4b\x20\x8b\x86\x73\x10\xc4\x9d\xce\x3d\x5c\x90\xd6\xf5\xb5\x53\x7d\x7f\xe1\x59\xc0\xf3\x5f\x77\x51\x56\x54\x95\x31\xc7\x4c\xdd\xaa\x6b\xb0\xbc\xd8\x3c\x89\x49\x4b\x0a\x5b\x55\x15\x6d\x13\xfb\x95\xb5\xe2\x6a\xbd\xc5\x3e\x9a\x05\x77\x56\xc3\x5f\x71\x29\xdd\xf4\x17\x7c\x89\x25\x87\xa5\x04\x95\xa4\x35\x1b\x3b\x9a\x94\x9a\x91\x54\x37\xa3\x0e\x2d\xb6\x65\x68\x40\x0f\x73\x17\x3b\x26\x37\x20\xa9\x83\x5b\x33\x09\xf3\xa2\xa4\x86\x32\x5d\xe9\x35\xa9\x5e\x92\xb9\xce\x80\x1f\x34\xcb\x5f\xaf\x69\x2a\xc7\x5d\x5e\xb1\xbb\xa1\xe9\x6c\x54\x55\xe8\x5a\x3e\xa1\x3e\xd4\xf2\x08\x7c\x27\x24\x76\x11\xd9\x6c\xfe\xad\xba\x28\x7c\xb1\x56\xd5\x53\xa0\x3d\xcf\xe5\x2d\xdd\x1b\x0f\x6b\x83\x2c\xce\x0c\xa4\x68\x64\x8b\x26\x8e\xa2\xef\xe1\xe1\x8a\xd5\xbd\x80\x8b\xb2\xd4\xc0\xea\x88\xf6\x75\xd6\x33\x56\x28\x42\xdb\xa5\xc2\x6e\x0d\x9d\x27\x48\xf9\xca\xae\x64\x17\x10\x52\x3e\xbb\xa4\xa3\x0d\x30\x42\x07\xe5\x0f\xb0\x6d\x55\xe5\xd7\xac\x38\xf0\x33\x6f\xcc\x8e\xd2\x77\xe4\xaf\x95\xb3\xbc\xa8\xda\xb7\x78\x81\x71\x28\x11\x48\xce\x13\x71\xc6\xda\x6a\xd9\xb7\xb7\xe3\x33\x03\xc7\xf9\x18\x12\x59\x8c\xbe\xad\xf2\x2f\x31\xf7\x55\x7a\x97\x92\x31\x3a\xba\x39\x55\x60\xe1\xc2\x36\xf1\xa6\x0e\xda\x48\xfa\x6d\x7a\x5a\x1e\xfb\x67\xa5\x89\x64\x69\x9d\x4a\x31\x6a\xe4\x5f\x27\x3a\x70\xcb\xc7\xfb\x31\x8b\x7c\xf6\x10\x03\xde\x7c\x87\x52\xd4\x3a\x73\xba\x27\x5f\x38\xe0\x0d\x0e\xef\x21\x04\xbc\xd9\xff\x83\x07\xbc\xf9\xfc\x31\x69\xee\x35\xc4\xce\x3a\xe0\xcd\xef\x2b\xe0\xcd\x67\x89\x5e\xb3\xf2\xf8\x2b\x61\x1c\x5b\x29\x24\xf2\x49\x18\xb1\xf4\xbc\x3b\x4d\x59\x41\xbe\x26\x3b\xea\x8e\x0f\x1e\xf5\x05\x3b\xbe\x09\x57\x6e\xd0\xb7\x78\x59\xd9\xc0\x77\xbc\x28\xf8\xb8\xa6\x99\x5d\xe7\xb5\xb3\xda\x20\x1d\xbf\x83\xf0\x02\x9e\x03\xf5\x51\x98\xc5\x32\x40\x8d\xef\x45\x3d\xaf\xbb\x74\xbd\xab\xf4\xb2\x7e\xc3\x95\x0e\xc3\xca\xb9\x77\x2e\x5e\x11\xad\x53\xe6\xf2\x4c\x9c\xd7\x39\xd8\x38\xab\x1a\x17\x46\xf4\x58\xb4\xd6\xf0\xf3\xbb\x2d\xfe\x1e\xbc\xbb\x6c\x1f\x9d\xbb\x3a\xdd\x58\x8b\x0d\x9e\x37\xd6\xef\x7b\x72\xbf\x79\xbe\x52\x3e\x73\xa6\x3f\x8d\x7c\xa4\xb2\xa8\xee\x6a\x7d\x6a\x98\x06\x0d\xdb\x74\x31\x68\xa0\xcf\x77\x2f\xd0\xe2\x15\xc6\xc6\x90\xf4\xc1\x4e\xb3\x6f\x7d\x69\xc5\xe6\x6f\xe7\x72\x00\x94\x30\x93\x33\x18\x11\x58\x35\x82\x0e\xb1\xeb\x1f\xd4\xf8\x74\xb9\x5d\x96\xa2\x63\x3f\xef\xfd\xae\x19\x51\xc4\x03\x37\x95\x64\x0d\xe2\xec\xd7\x80\x37\xe1\x8e\x0b\xe9\x72\x3d\x5a\x3f\x5f\xc7\x04\x3e\xaf\x81\x6f\xe2\xfd\xbc\x96\x4d\x0b\x26\x39\x50\x5d\x77\xdb\xbd\x2a\xe8\xc6\xce\xac\x46\x8d\x8b\x56\x9d\xfa\xbf\xb6\xdf\xed\xd9\x75\x9b\x46\x51\xdf\xa1\x6e\x57\xd9\x5b\xd4\x0e\xa1\x0c\xda\xd4\xa3\x6e\xee\x7e\x1d\xcc\x54\xae\x95\x3a\x26\xfa\xb9\x0b\xe9\xa4\x7f\xa8\x7b\xc4\xec\x36\xd4\x99\x39\x32\x07\xfa\xa1\xc5\x78\xfc\x11\x53\x85\xde\x2d\x82\x22\x34\x32\x4f\xe8\x44\x96\xbf\xa2\x79\x44\xd3\x38\x74\xb5\x9d\x76\x79\x8b\x26\x1d\xa2\x3d\x37\x55\xf4\x66\xf4\xbb\x53\x8e\x4e\x10\x7d\x04\x8a\xba\x93\x30\xa3\x69\xf1\xa3\xa5\xe2\x92\xeb\x46\xd1\x2f\x4b\xd6\x04\x8d\x4c\x65\x27\x76\x0b\x2a\xc2\xb3\x6c\x02\x84\xfb\x77\x62\xd3\x8d\xc0\x77\x31\xd7\x71\xdc\x96\x25\x7d\xc6\x21\xcd\xc1\x32\xb1\x1c\xfc\x8a\x73\x07\x71\x80\xe1\xae\xc6\x3d\x1d\xf6\xc1\x0b\xdb\x20\xad\x03\x5f\x5e\x85\x37\xb5\x9d\x88\x75\xf2\x45\x99\xd2\xba\x1b\xcf\x1e\x98\x4d\x83\xdd\x2b\x18\xbe\x17\x96\xc5\x7b\x91\xb1\xf3\x73\x88\xe3\xc7\xa7\x05\x84\x0a\x54\xd1\xe4\xb4\xd0\x5c\xbb\x4b\x6c\xa8\x10\xf8\x7a\x48\x16\xf1\x58\x36\x35\x76\xa9\xad\x99\x26\x6d\xa5\x1a\xf7\x96\x32\xbb\xd4\xd3\x9f\x22\x7d\x76\x69\xd6\x8b\xa4\xd2\x2e\x2f\xd9\xb2\x69\xb5\x65\xe6\x3f\x81\x5a\xe8\xfb\x68\xdb\x5f\xe9\x6e\x1c\xcc\x03\xe4\x76\x32\x0e\xbe\x81\x37\xbb\x83\xf5\xa3\xf0\x92\xa2\x8f\xca\x19\x14\x77\x27\x19\xfc\xab\xae\xa0\xf6\x19\x19\x87\xd9\x05\x8d\xed\x6c\x82\x08\xa9\x65\xf5\xf0\xd3\x4d\xe1\x58\x93\x93\x5a\x8c\xe1\xf5\xf6\x36\xc9\xa7\x13\xc1\x62\x76\xc8\xd5\x88\x45\x23\x75\xec\xe0\xa4\xf9\x33\x02\xdf\x94\x70\x58\xc8\xcf\xd3\x74\xc0\x74\xc2\x39\x93\x4c\x52\x2e\x8f\x6f\xd3\x26\x48\xff\xcc\xec\xd7\xb6\x25\x9f\x99\x9d\xbc\x2e\xaa\xd3\xae\x89\x6b\x27\xe6\x11\xe0\x62\x57\xfd\x31\xc7\x37\xb1\xc9\x45\xc8\xd2\xdc\xe9\xa4\x2d\xd5\xd6\xde\xad\xe4\x80\x54\x19\xdf\x29\x9b\x0c\xbd\x58\x72\xcb\xcb\x2a\xe8\xcf\x97\x2f\xb3\x82\x80\xad\x3c\x77\xa6\x77\x20\x94\xdd\xd3\xe7\x48\x1f\xe8\x1d\xc3\xda\x6e\x17\x4b\x8b\x77\x2f\xd9\xca\x2c\x74\xd1\x79\xcb\x14\x3a\x06\x6e\x06\xbb\xb7\x7c\x9a\xd3\xe9\xc4\x49\xdb\xa5\x37\xd2\x05\xfd\xc0\xa7\xd1\x88\xa6\x71\x35\xac\x41\x3c\x53\xab\xc2\xf6\x57\x7e\xab\xcd\x9d\x55\x42\xa2\x99\xea\xd0\x32\x95\x5e\x46\x12\xb6\x66\xd4\xbe\x28\xa3\x56\x2b\xa2\xab\xc0\x87\x7b\x90\xb4\x3d\xdf\x7e\x88\x1a\xdd\xef\x79\x36\x56\x8e\x11\xd5\xcf\xd8\x9d\x79\x94\xba\xba\x99\xfb\x50\xeb\xea\xc6\xab\x34\xbb\x7a\x16\x3f\x08\x74\xaa\x93\x2a\xee\xef\xce\x3b\x0b\x68\xe6\xbe\x66\x01\x8d\x37\xce\xe2\x88\xa7\x45\x56\x9b\xf3\x6c\xe7\xf9\xdc\xf3\x90\x0d\xdd\xd7\x4c\x64\xf3\x8d\x73\xf9\x07\x4d\x26\x34\xfb\x80\x56\x98\xd5\xd3\x99\xcb\x62\xc0\x6d\xeb\xbe\x66\x64\x7a\x98\x67\x83\x9a\xb1\x6d\xae\xcc\x3f\x7e\x6b\xf7\xbc\x55\xb5\xb8\xf7\x99\x6d\x23\x9e\xdf\x2d\x61\xe3\x97\x16\x49\xaf\x93\x01\xad\x6d\x23\xd6\xb6\x11\x0f\x52\xea\x5b\x6f\xb0\x01\xca\x37\xcb\x18\xa3\x32\xdd\x8d\xf8\xf3\x95\x95\x17\x37\xe2\xc9\x74\x9c\x5a\x1f\x7f\xc9\xc2\x49\x9f\x04\x57\x59\x38\x09\x36\xe4\x23\x24\xe3\x57\xaa\x51\xbf\x7e\xc6\xaf\x02\x1d\x00\xe2\xae\xe6\x17\x98\x29\x01\x14\xc1\x25\xa1\x61\x55\xf4\x9e\xcf\xfc\xba\x58\x25\xaf\xff\xfb\x4f\x6b\x21\x35\xb2\x04\x42\x34\x88\xed\xb2\x32\xc4\xc8\x04\x15\x82\x76\x65\xfc\xca\x8c\x16\x10\xa9\xa6\x8f\x01\xe7\x09\x5a\xb6\x48\x49\xf3\x99\x66\x89\xcf\x20\xde\x4a\x0e\xb8\x91\xf1\x24\x27\xf9\x34\x1a\x91\x30\x27\x67\x20\x65\x1d\xf0\x6b\x99\x78\xe6\xf8\x8a\x15\xd1\xe8\x0c\x42\x68\xbc\x29\x54\x18\x97\xdc\x1e\x0c\x49\xc2\x1b\x3e\x2d\x00\xe4\x7b\x95\xcd\xe0\x7d\x18\x33\x7e\xd6\x01\x8f\x6c\xe9\x78\x0c\xf9\x6a\x74\xd0\x0e\x00\x90\x63\xb1\x63\x60\xe4\x05\x0d\x63\xc4\x55\x96\x13\x9e\xd2\xae\x9b\x44\x54\x4f\x61\xf5\x96\x39\x96\x7d\x77\x75\x02\x03\x31\x59\xf5\x2d\xe3\x57\xf7\x62\xd1\xe3\xa5\x00\x10\xd4\x40\x1a\xa1\x8b\x49\x0a\x6a\x34\x67\xc0\xf9\x25\x83\xf8\x8b\x79\x89\x89\xda\xf1\xf9\xdb\x07\x8b\x85\x43\xd7\x61\x70\xe6\x0b\x83\xee\x4e\x6a\x56\x28\x74\x8d\x00\x5f\x28\x1a\xfa\x1f\x81\x56\xfe\x1e\xec\xa3\xe6\x6a\x50\x1c\x8f\xda\xa6\x04\xfd\xf3\x0c\xad\x0c\xf2\x54\x04\x72\x02\x5a\x0a\x12\xd4\x95\x44\x42\x36\xc2\x0d\x72\xdb\x6e\x19\x69\xc4\xfd\x88\x89\xee\x96\x60\x7d\xe5\x62\xa2\xf5\x7b\xe7\x4b\xbe\x77\xd6\xa6\x4f\x6b\xd3\xa7\x87\x67\xfa\x74\xef\x11\xc1\xff\x00\xcf\x70\xa8\xf8\x26\x9d\x4c\x6b\x57\x7f\x7f\xcf\x5d\x7f\x14\x40\xd6\x8d\xe6\xd9\xfe\x9f\xfb\x71\xff\x27\x4c\xd8\x6b\xa4\x14\x2c\x4d\x58\x4a\x37\x9d\xdc\xbc\x8d\xe2\x8a\xe6\x6c\xbf\x5b\x5b\xe4\x3d\xcd\x69\x41\x86\x8c\x26\xb1\xf8\x43\xb1\x46\x30\x3e\x09\x35\x66\xa9\xcc\x10\xab\x73\xf3\x6a\x17\x16\x5d\x32\x0e\xb3\x73\x96\x5a\x05\x98\x61\xb7\x4f\x7a\x1b\x96\xa2\x16\xa1\x7e\xe4\xd9\x38\x4c\xec\x14\xb4\xa2\xf4\x03\x9f\xcc\x72\x89\x41\xc0\x7a\xbf\x97\x72\x57\xaf\x68\x9a\xd3\x39\x7b\x9a\xb7\x17\xb2\x45\x76\xec\x9e\x86\xd3\x24\x91\x0b\xa4\xfa\x71\x92\xe7\xde\xc1\x03\xe7\x2d\x0c\xa5\x96\xba\x62\x62\xa0\xd6\x09\x26\x23\x06\x9f\xca\x34\x87\x3f\x52\x58\x62\x7c\x68\xae\x50\xe4\x94\x2b\x99\xd3\x90\x67\x63\x25\x6b\x58\x8b\x9d\x1e\x98\xd8\x69\x9d\x4d\x75\xc5\xd9\x54\xdf\x0c\xc9\x99\x78\x08\x9d\x75\x64\x94\x8c\x01\x4d\x3a\x84\xc1\xa5\x1e\xa6\x31\x19\xc1\x8d\x8d\x49\xa0\x8d\x6c\x4c\x92\x6d\xcc\x69\x1d\x9a\x38\xd9\x18\x65\x40\xaf\xa2\x2a\x6f\x94\xfa\xcd\x1e\x4f\x6d\xc7\x29\xa1\x59\xc6\x33\xbf\x5b\x28\x5c\xbe\x4f\x2b\x92\x70\x98\x93\x2b\x9a\x24\x18\x26\x3a\x27\x8e\x8c\xed\x6b\x8c\xe9\x5d\x84\x17\x14\x22\x41\x0a\xd2\x31\x4d\x12\x24\x90\x82\x98\x40\x0d\xb4\x56\x53\x51\xa9\xb7\x36\x1c\x9a\x3a\xf7\x08\xfd\xc3\xc3\xd3\xef\x92\x69\xfd\x14\x05\xce\xcd\x6a\xe0\x7b\x1e\x4d\xeb\x4f\x70\xb9\x85\xca\x8d\x91\xb1\xfe\x63\x16\x85\x2a\xf4\x26\x86\xc3\x14\xe8\xc3\x72\x22\xdb\x8c\x2d\x19\xb0\x2c\x59\x70\x7b\x80\xfa\x63\x9e\x74\xa4\xff\x67\x1d\xec\x3c\x8c\x21\xd8\xf0\xa5\x78\x55\x46\x61\x42\xe4\x6d\xa6\x85\xb2\x02\x87\xd5\x26\xc4\x95\xc4\x4c\x5d\xef\x4b\xdf\x43\xb6\x7d\xf4\x4f\x46\xe6\x8c\xc1\xe4\x94\xac\x3a\x66\x59\x71\xb3\x35\x14\x8b\x4e\xe3\x2d\xc0\xd0\x2d\xb5\x16\x40\xc2\xe0\xda\x81\x85\x83\xd0\x9e\xe4\x3d\x4d\x20\x7a\x3c\x57\x49\x8c\xb1\x3d\x2d\xd4\x1e\xb1\xf3\x11\x30\x48\x6c\xc0\x92\xe2\x06\x26\x4a\xd3\x7c\x9a\xa9\xf8\xe3\x48\xcd\x21\xd8\x79\x72\x15\xde\xe4\xe2\xc7\x0d\xc6\x23\x4d\x73\x06\x5a\x16\x19\x61\x54\x27\xfb\xce\x68\xaa\x6e\xc1\x33\x4b\xad\x8e\x12\x75\xcc\xc0\x2e\x87\xa1\x92\x28\xcb\x90\x74\x43\x9e\x24\xfc\x4a\x0c\xd7\xac\x70\x1f\x02\xb5\x6e\x12\x6d\x14\x62\xfd\x36\x86\x08\xb2\x10\x5e\x11\xf6\xdf\xaa\x06\x1a\x88\xbb\x66\x23\xcb\x9a\x86\x5b\xad\xcc\x34\x0a\xb7\x60\x6b\x62\x9c\xce\x63\xf0\x6d\x9b\x91\x98\x68\xa7\xbf\x50\x1d\x8e\x9e\x15\x34\xc3\xa3\x83\xd9\x2e\x9c\xad\x10\x5b\x3a\x64\xf2\x62\xc6\x77\x16\x4b\x09\x30\x9f\xaa\xa9\x82\x03\x3d\xb9\x51\xf6\xc0\x24\xa7\xd9\x25\xcd\x08\x58\xde\xa3\x95\xa4\x8a\x3f\xef\xc4\x48\x5d\xd4\x94\xdb\x9a\xc8\x22\xd6\xdb\xf6\xfc\xdb\x73\x87\x59\xf5\x63\x76\x86\x31\xcf\x52\x1a\x1f\x17\x61\x56\xa8\xcc\x35\xfa\xfd\x90\x15\x37\x5e\x99\x3c\x64\x4a\x3c\x4a\x4a\x31\x41\xd1\xe4\x12\x08\x60\x93\xb9\xb7\xb1\x8d\x56\x66\xc2\x50\xa5\x14\xfe\xcd\xfd\xec\x59\x10\xdf\x5a\x8d\x7d\x65\x4d\xaf\x2b\x47\x59\x6e\xcd\x8a\x71\xa4\x67\x82\x89\x78\xbc\x46\xab\x26\x25\xae\x85\x19\x26\xec\x82\x85\x82\x52\x32\x66\xe7\xa3\x02\x54\x5d\x4a\xde\xd9\x35\x60\xdf\xf3\x8c\x98\xf4\x56\xa1\x0e\x4f\xa9\xa3\xf8\x43\x65\x48\xce\x84\xa9\xa2\x38\xbf\x30\xb5\x21\xf9\x7a\x98\x9a\x9b\x40\xb3\x08\x83\xa9\x78\x82\x09\xd2\x3d\xc2\x00\x73\x48\x3f\xa2\x69\xde\xad\x5d\x77\x98\xd5\xa3\x47\xc4\x9b\x8c\xbf\xfe\x02\xac\x61\xf9\x97\x5e\x7d\x3f\x30\x59\xfd\xf2\xbf\x12\xe8\xe8\xac\xbf\x8b\x4e\x0e\x06\x00\xee\x36\x8e\x40\x62\xf7\xdc\xbb\x7f\x94\xd0\x30\x6d\xe8\x7e\xa9\xde\x9b\x67\xef\x87\xfb\xad\xb0\x55\x96\x90\x76\xfe\x6b\xd3\x6f\xc9\x26\x59\x39\x07\xa9\x10\x90\x73\x45\xdf\x15\x6d\x1b\x27\x05\x29\x65\xea\xb2\xfc\xed\x94\xf9\x71\xd3\x4e\x02\xa0\xa4\xe2\x06\x3f\xa6\x09\x8d\x8a\xe0\x63\x5b\x47\x78\x83\x4f\x5d\x96\xc3\x3e\xca\x2a\x32\xfa\x17\xec\x42\xa5\x13\x81\xb5\x9e\x8e\x2d\x3d\x71\x22\xd8\x2d\x31\xc4\x8a\x81\xbd\xb4\x48\xa1\x33\xbe\x86\x91\xd9\xe4\xb3\x76\x80\xb7\x96\x29\x79\x4d\x04\xdd\x06\x9f\x05\xe7\x66\x75\xbc\x15\xbc\x08\xba\x35\xf6\xfc\x75\x71\x76\xe7\x08\xc6\x66\x5e\x19\x26\xc8\x9a\x2a\x71\xc2\x2b\xc2\x4b\x41\x83\xc0\x4f\xfb\xbb\x66\xc6\x34\x48\x66\x69\x52\xd5\x7f\x63\x2d\xb5\x40\x18\xfc\x6d\x47\xce\x3c\x55\xb7\x97\xd9\x01\x27\x80\xb2\xbb\x19\xa7\xe5\x2d\x72\xa7\x86\x48\x75\x6a\xe1\x98\xfd\x5d\x92\x28\x03\x21\x0b\x54\x7c\xb7\x52\xa4\x62\x42\xc6\xa8\xec\x93\xbb\xd5\x77\xb0\xc6\xbd\x68\x1b\x07\xd5\x27\xa5\xc1\x98\xd7\x5e\xed\xfa\xf7\x49\x69\xdd\x0d\x95\xc5\x3f\xca\xab\xdd\x97\xff\x56\xed\x56\x9f\x54\xed\x12\x4f\x5f\x49\xca\xe9\x91\x66\x17\x08\xc8\xa5\xe7\x86\x41\xc3\xd4\x05\x92\xef\x24\x9f\x71\x70\x81\xf0\x35\xe6\xdd\xc3\xe5\x33\xb6\x22\x67\x17\xa3\x14\xf8\x31\x1c\xd3\xdc\x89\xf2\x8a\x78\xb9\x53\x7b\x58\x6c\x5a\x8d\xa0\x25\xcb\x11\x42\x88\x65\xa0\xa2\xa1\x5c\x13\x15\xe2\x99\xa9\x38\x60\xb6\xa1\x0a\xf1\x53\xce\xdb\xc0\xe5\xa8\x89\x15\xc7\x79\x67\x8e\xf3\xbc\x53\x3e\xd0\xfa\x9d\x6d\x01\xe9\xb2\x86\x33\xbd\xd3\x2d\xa3\xdb\x82\x56\x33\xb2\x21\xb0\x9b\xb1\xec\x63\x6a\x6d\x68\xec\x90\x8e\x6a\xae\xe2\x6f\x98\x93\xf8\x43\x8f\x1b\xf2\xcc\xc0\xf0\x74\x38\x1d\xb2\xb0\xfb\x93\xb3\x1d\x66\x9a\x75\xe6\x2f\x55\x3b\x3e\x7f\xd4\x9d\x96\x85\xa9\x90\xec\x75\xa6\xb5\x84\x81\x37\x96\x3e\xb6\x74\xbd\xa3\x77\xec\xf0\x50\x3f\xc3\x67\x1b\x61\xd4\x37\x0b\x92\x74\xb7\x55\x7c\xe5\x2f\xd7\xa8\x41\x32\x83\x83\xed\x8e\x7d\x62\x1d\x7b\x25\x43\x26\xa4\x31\x91\x1f\x82\x78\x15\x14\xa8\xed\xc5\x25\x9d\xc3\x85\xcc\xba\x25\x66\x3a\x8f\xd9\xcf\xc3\x39\xb3\x8e\x99\xdb\x42\x3f\xde\xe4\x15\xa1\x7f\x5b\x92\x32\x5d\xa6\xae\x04\x29\x8f\x71\x24\x4a\xda\x1c\xc6\x1e\x4e\x5d\x58\x4f\xff\x1e\x9c\x3b\xaa\xe7\x2a\x4c\x6d\x94\xe7\x8a\x32\xb6\xb1\x64\x04\x9e\xa9\xcc\x93\xb5\x27\xc1\xda\xb2\xe6\x81\x7a\x12\xac\x6d\x24\xd6\xae\x0a\x9f\xcf\x54\x20\xe2\x09\xcf\x94\xd2\x7a\x12\x26\xb4\x28\x68\x17\xe4\x4b\xdd\x91\x16\x27\x1b\x19\x60\x5a\x7c\x1f\x8e\x59\x72\xa3\x6a\x14\x37\x13\x7e\x9e\x85\x93\xd1\x4d\xd7\x7c\xb4\xc1\x8f\xd9\x7f\x69\x05\xf0\xe4\xfa\x03\x7f\x4f\xc7\xad\xed\x1d\x7d\x87\x8a\xab\xe4\x65\xc2\xce\xc5\x35\x94\xd0\xa1\xf1\x05\x9f\x4b\x07\x9f\xb0\x94\xfe\x83\xb2\xf3\x91\xb8\x0d\xb7\xe9\xd8\xd4\x66\x69\x75\xb9\xb2\x3f\xc0\x8b\x1a\x8b\xe3\x05\xb4\xff\xbe\x56\x5f\xde\xb3\x8d\x0b\x0b\x30\xdd\x97\x4f\x7a\x6e\xaf\xfa\xd2\x9e\x63\x57\x14\xb0\xe1\x2f\x56\x13\xa6\x73\xed\x27\xf2\x3b\x52\xd8\x7b\x6a\xc3\x2f\xa8\x4e\x9e\xa7\xeb\x15\x2a\x94\x51\x63\xd9\xac\xa5\xec\xea\x7c\xca\xf8\x8a\x49\x6e\x08\x1f\x48\x55\xe5\x25\x0b\xb5\xb6\x6d\x98\xf1\x31\xb6\x6c\x73\xb6\x1b\x0b\x6a\x30\xf1\x4d\x23\xf5\x95\xae\x93\x8a\xd1\xc7\x55\x2a\xbb\xaa\x04\x0e\x9e\xe0\xb7\xda\x09\x65\x5e\x3f\x17\x29\x17\xa8\xf1\x75\x51\xfb\xee\x40\xf9\x32\x01\xd8\x23\x07\xc2\x91\x08\xe0\x1a\x39\xdf\xdd\x67\xfe\xd2\x8e\x31\x73\x3c\xf0\x2b\xdf\xf4\xd6\x33\x1e\x57\xd3\x7d\x91\x90\x43\xb5\x07\x5d\xf7\x03\xbe\xfa\x45\x05\x4b\x52\x62\x2f\x91\x6a\x4f\x49\x48\xf4\xca\xe8\x8e\x94\xc0\xc3\x2c\x0a\x6c\x29\x1b\x92\x96\xdb\x97\x92\x39\x41\xdc\x38\x24\xa3\xa6\x53\x41\x23\x35\x3f\x1f\xb4\x6d\x9b\x3e\x35\x2c\xb7\x35\xbd\x67\x4e\xd4\x29\xab\x6d\x39\xe2\xba\x86\xd5\x84\xbc\x56\xa1\xb8\xae\x49\xfb\x51\x5f\xd5\xa6\x59\x0b\xb7\x51\x5b\xb0\x7b\xab\x24\xe0\xda\x75\x6b\x51\x8f\xa6\x95\xc8\x40\x34\xc6\xeb\x15\x5e\x4e\x3e\x81\xe7\x02\x57\x73\xb9\x16\xe2\x06\x81\x49\x8d\x98\x43\x34\xbd\xb0\x6b\xd6\x64\x01\xc7\xac\x68\x21\xa7\x2c\x43\xf0\xd6\x9e\x59\x6b\xcf\x2c\x8b\x3e\x37\xbb\x67\xcd\xd5\x9a\xa2\xf0\x2b\x68\x4a\xde\x11\xf5\xeb\xe6\x5d\xed\x15\x1e\x64\x16\xa6\x47\x77\x91\x82\xad\xcc\xcd\xcc\x0a\x73\xa2\xc4\x5f\x56\x5c\x92\xfb\x71\x38\xdb\x7b\x58\x0e\x67\x28\x4e\xf8\x07\x8b\x63\x5a\x9b\x69\x66\xff\xe9\x17\xce\x34\x83\xc3\xab\x0d\x14\x83\x9f\xff\x59\x2b\x99\x79\x3e\xd7\xf8\x55\x2b\xf7\x37\x81\x7f\xe6\x0f\x21\x20\xcc\xd3\xdf\xb5\x18\x57\xc6\xaa\x07\x9a\xca\x86\x37\xb5\x28\xfb\xac\x0c\xdb\x18\xd7\x5e\x01\xe9\x6a\x17\xf4\xa6\x0e\xa1\x76\x77\x1d\xa8\xa6\x76\xc5\xf7\x87\x29\x91\xbd\x57\x69\xf7\x55\x98\xa5\x98\xb1\xb3\x52\xc2\xf7\xc4\x07\x6c\x14\x62\x22\x88\xe7\x94\xf8\x5d\x46\xc3\x8b\x09\x67\x69\x51\xb7\x4b\x4f\x76\x1c\x69\xa9\xd6\xbf\x56\x3a\x87\x3d\x29\xc3\xce\x12\xac\xa2\x32\xed\x4f\x2d\x57\x9d\xb3\x3d\xa4\x7e\x4a\x80\x56\xbd\x01\x4f\xe7\x1e\x9d\xdd\xda\x0a\x07\xa9\x86\x57\xc7\xe0\xdf\x76\x96\x9a\xee\x61\xad\x57\x51\x98\xde\x90\x17\xe4\xd3\xed\xfc\x61\x1e\xad\x86\x3b\xbf\x2b\x39\xe4\x1f\x28\x1a\x66\x9d\x58\x52\xfa\x5a\x88\x9a\xca\x30\x1e\x4c\xd2\x0d\xe9\x89\x69\xc4\xb3\xb0\xe0\x99\xde\x8f\xab\x46\xd7\x0b\xbc\x92\x1c\x8d\x6f\xdb\x0a\x4a\x23\x3b\x27\x9b\x04\xa8\x4e\x1a\x26\xce\x96\xdb\xb1\x5f\x14\xf7\x51\x0a\xfd\x32\x4b\x66\xc6\xd3\xe4\x46\x7f\x14\x3f\xd4\x87\xeb\xfc\x67\x23\xbc\x12\x3f\xd4\x87\x7c\x6c\x7d\x10\x3f\xb4\xd0\x2b\xb6\x3e\x88\x1f\x5a\x07\x71\x6e\x7d\x10\x3f\x74\x1f\x89\xdd\x47\x62\x7d\xc8\x5f\xf1\xab\xd4\xea\x5e\xfc\x34\x03\x70\x3e\xe2\x4f\x33\x08\xe7\x23\xfe\x34\x03\x71\x3e\xe2\x4f\x33\x18\xb7\xcf\xc4\xfe\x78\x25\xaf\x16\xfc\x76\x65\x1b\xf5\xac\x42\x94\x27\x16\x5e\xfc\x2b\xd6\x59\xfc\x2b\x96\x15\xa4\x76\x31\xfe\x2b\x16\x0d\xbe\x27\xf2\x5f\x58\x10\x84\x54\x7f\xe1\x54\x11\x5a\xfd\x85\x93\x10\x7f\xc1\x90\xb5\x15\xcf\xdc\x92\x07\x78\x6f\xc9\x0b\xdc\xcc\x01\x8a\x81\x2f\x32\x65\x28\x04\x51\x69\xfc\x05\x29\xe9\x75\x48\xf0\x36\x2c\x68\xc6\xc2\x64\xf3\xe7\x37\x7d\x32\x4d\xa5\xdf\x00\x8d\x61\x21\x71\x6d\x48\x86\xd9\xea\x63\x12\x90\xc7\x32\x95\x8f\xe6\xe7\xfc\xf6\xc9\x63\x12\x88\x33\x77\xf6\x8d\x7c\xcf\x6c\x7d\x7b\xd6\x0d\xc4\x0b\xf4\x92\xb3\x98\xf4\xb4\xb0\xf8\x92\x81\xb3\x81\x49\x96\x04\x86\xe2\x67\x62\xa1\xcf\x48\x34\xa2\xd1\x05\x61\x39\x19\x86\x39\x04\x2a\xe7\x82\xd3\x27\x7c\x5a\x90\x9c\xf3\x94\x66\x84\x0d\xc1\xe3\xa4\x2b\xe5\x94\xa2\x9a\x2d\x9d\x84\xc0\xf8\x5d\x96\x63\x80\x7c\xf8\x6a\x84\x7c\x3a\xbc\x3e\xc3\x70\xf9\x8c\x7c\x03\xc7\x4c\xae\x8d\x28\x78\x7c\x48\xb6\xfd\xd8\xe7\x03\xcd\xee\x90\x43\x80\x3f\x61\x1f\x8d\xe5\xac\xe8\x55\x22\xe1\xe1\xa1\x05\xeb\x1a\xe2\x9a\x59\x5b\xe1\xae\xf1\x3f\xa8\x52\x1b\x69\xdc\x64\xa4\x06\x82\xf0\xe8\x11\x31\x9d\xd9\x93\xaf\xe9\x42\xcb\x2c\xb7\xb6\xc8\xcb\x24\xe1\x57\x6a\xa5\x0b\x4e\x06\x70\x51\x0d\x40\xcd\x20\x48\xa5\x3c\x30\x78\x92\xc8\x9b\x21\x09\x93\x8c\x86\xf1\x0d\x19\xc1\x8e\x76\x48\xca\xb5\xc3\x0a\x6e\x14\x54\xc8\xd5\x5e\xc8\x01\xa8\x11\x6d\x6d\x91\x98\x16\x34\x1b\xb3\x94\xe2\xe0\x58\xc2\x8a\x1b\x32\x08\x73\x1a\x2b\x7f\xa6\x7c\x1c\x26\x09\xcd\x0b\x92\xb3\xff\x52\x32\x9d\x6c\x38\xfb\x74\x2a\x37\xea\x54\xec\x54\x99\xf9\xec\x0a\x4c\xd7\x9b\x77\xea\xef\x1e\xb4\xe0\x6c\x5e\x4d\x13\x27\xa7\xcc\xc9\x7a\x6f\xea\x18\x2a\x78\x62\xb7\xf4\x98\x04\x3f\x4f\x82\x9a\x3a\x36\xb1\xf2\x6b\xc1\xa1\xd7\xf5\xc4\xa2\x39\x7d\x29\x33\x6f\x7d\x71\x75\x59\x0e\xff\xfe\x3c\x69\xb7\xac\xa6\x3a\x88\x04\x6d\xc1\x83\x79\x1d\xd7\x36\x21\xbe\x56\x36\xe2\xa0\x7b\x1d\x9a\x3a\x48\x7a\xeb\xa2\x16\x78\x34\x78\x9b\x2f\x19\xee\x74\x9a\x24\xda\x70\x5c\x96\x19\x7f\x80\xdb\x46\x49\x12\x3e\x04\x0c\x9d\x69\xb7\xf4\x4b\xfe\x7e\xa4\x43\x0f\x32\x0f\xf1\xdf\x33\x16\xd7\xbd\x51\xe7\x0b\x58\x7d\x8f\xb2\x21\x31\xb8\x87\x20\x56\x59\x65\x0e\xe2\xb5\xb9\xdb\xef\xdc\xdc\x6d\x1d\x48\x6a\x1d\x48\x6a\x1d\x48\xea\xf7\x68\x24\x09\x15\x31\xb3\xfd\x77\x61\x5e\x27\x4b\x7b\xb2\x57\x01\xdb\xd4\x89\x81\x5a\x47\xa1\x5a\x47\xa1\x9a\x2b\x0a\x95\x13\x7e\xea\xd7\x69\x5e\xb0\xe1\x8d\x4c\x4e\x2c\xbf\x6e\xe6\x45\x98\x19\x93\xcf\x30\x61\xe7\xe9\x9b\x82\x8e\xf3\x3e\x09\x22\x2a\x70\x65\xae\xf8\x54\x05\xbd\x2e\x5e\xa1\x70\x0a\x21\xc0\x9f\xc1\xb6\xb5\xd4\xa1\x43\xac\xf4\xea\x15\x0d\xda\x55\x2e\xe8\xcd\x80\x87\x59\xfc\xbd\xf2\xa9\x53\x15\x07\x61\x74\x71\x9e\xf1\x29\x66\x1d\xb2\x4d\x35\xc1\xc0\x28\x66\x97\x4c\x05\x15\xd0\xf6\xa5\x12\x63\xbd\xd4\xee\x60\x62\xba\xbd\xe3\x45\xcb\x52\x11\xa5\xb6\x77\x1a\x6c\x54\xed\x16\xea\xcd\x63\x67\x66\x80\x6f\xb6\x47\xe5\x02\xb2\xb8\xe9\x93\x5e\x77\xcf\x85\x84\x29\x5a\x4b\x02\x71\x14\x54\x37\xc1\xf6\xe4\x9a\xe4\x3c\x61\x28\xf3\xa8\x58\xa3\x84\x9d\x8f\x8a\x57\xe5\x85\x3a\x9f\x16\x05\xcd\xf2\xd2\x34\x7f\xa0\xc3\x62\x56\xd0\x2f\x09\xfa\x1e\x8d\x7e\xab\x61\xed\xbe\x06\x40\xd0\x4c\x57\x45\x16\xa6\x0a\x23\xa4\xe1\xb2\x2e\xc9\xa5\x45\x4d\x2b\x30\x9b\xbf\x09\xd6\xba\x81\xed\x60\x14\x4f\x15\x06\x96\x1b\x50\xdf\xba\xf9\x88\x67\x05\xcd\x0b\xf5\x0c\x6c\x5b\x89\xfc\x47\xfc\x92\x66\x4e\x0e\xff\x6a\xd4\x36\x0e\x48\x66\x3c\x47\x55\xc6\xc3\x36\x46\x9a\x4a\x3a\x9e\x1b\x4f\xc9\x98\x0b\xc6\x3d\xa6\x97\x2c\xa2\xb9\x86\x08\xfe\x36\xa6\x31\x0b\x49\x0b\x46\xd4\x27\xa2\xd7\x76\xe0\x3a\xb8\x96\xba\x0e\x60\xbe\x98\xb6\x34\x30\xa2\x18\xd3\x6f\xf0\xe8\xaf\xda\x3a\x64\xb9\xb6\xdc\xb7\x33\xb6\x9c\xd3\x88\xa7\x71\x98\xdd\xbc\x94\xa1\xed\xac\xf8\x0c\x2f\xe3\x98\xe4\x7c\x4c\xc1\x48\x94\x92\x82\x93\x10\x24\x69\x11\x4f\x12\x96\x0b\xda\x16\xe6\xe4\xec\x07\x96\x17\x82\xec\x1c\xbb\x2d\x9d\x99\x76\x58\x4e\xc2\x41\xce\x93\x69\x41\x93\x1b\x4d\x3a\xac\x20\x0f\x73\x60\xdf\x93\x55\xdb\x6e\x7b\xe6\xc0\x6a\x16\x68\x25\x3b\xa0\x24\x94\x38\x6e\xf4\x27\x0a\xe7\xe7\x36\xbe\x7d\xe0\x6a\x99\xb5\x79\xf8\x3a\x9e\xdb\xe7\x89\xe7\xa6\xd2\x1e\x68\xab\x73\x79\xe0\x49\x4c\x73\x76\x9e\xca\xa5\x56\x3c\x03\x44\x1b\x42\xca\x8a\x41\x5b\xd4\x91\x54\x52\x77\x69\x83\x8f\x77\xfa\xd2\x91\xcb\x56\x10\x12\x8e\x0e\x31\x34\x5d\x06\x11\x68\xd4\xa4\x20\xda\xd8\x98\x5f\x3a\x83\xc5\xce\xfe\xae\xae\xe8\x65\xba\x0c\x89\x60\x0d\x12\x0c\x95\x03\x3c\x03\x50\xd6\x38\xc6\xe3\x24\x46\x34\x00\x26\x42\x11\x9b\x84\xe5\x05\x61\x05\x1d\xdb\xe3\x90\xcc\xc7\xac\xe4\x17\x82\xbc\x6a\x9a\xb8\x7c\xa0\x2b\xd5\xc4\xcc\x28\x57\x0a\xb0\xb5\x48\x50\x2b\x55\x49\x7a\x0e\x4b\xbe\x7a\xd1\x88\x52\xaa\x95\x45\xc2\x49\xe9\x9e\xdb\x32\xfd\x2f\xb6\xa5\x73\x1a\xb7\xe7\x4a\xb0\x6a\x56\x67\xa5\x91\x4a\x4a\x91\x36\xe4\x51\xb1\x22\xe2\x40\x89\x98\x26\x94\x29\xf3\x7e\x5d\x6a\xe2\x55\x7d\xce\x58\x11\xb5\xa1\x22\xf0\xe6\x35\xb1\x4e\xf0\x77\x55\x30\x09\x27\xac\xc3\x5c\xf1\x24\x1a\xc3\x49\x78\xcd\x55\x45\x94\x88\x2a\x23\x4a\xd4\x04\x94\x80\xf5\x35\xc1\x61\xc0\x78\xdd\xfe\x3e\x57\xfc\x18\x79\x86\x6d\x20\x8f\x45\xf5\xe9\x4d\xa9\x3d\x59\x7e\xe7\xc0\x12\x1d\x72\x12\xe0\x66\xf8\x19\x58\xe6\x8b\x30\xa1\x22\x18\xda\x6e\x29\x72\x36\x56\xb1\x1c\xad\xca\xe8\xa2\x90\x86\xe5\xaf\xe4\x7a\xce\x83\xcd\xb6\xa6\xcc\x0e\x3d\x52\x17\xf5\xa9\xe0\xa8\xc0\xb5\x31\xcb\xed\x7f\x14\xe6\x2f\x2f\xc3\x22\x14\xab\xa6\x33\xc9\x0b\x7e\xb9\x65\xa8\x25\x9c\x8a\x72\x32\x6d\x32\x2b\xfe\x12\xd4\x13\xab\xab\x48\x04\xf6\x24\x7d\x74\x88\x15\x26\x49\x8f\xc5\xe3\xbf\xed\x41\x49\xc5\xbb\x52\xcc\xcd\x8a\xfb\x94\xd1\xf4\xc4\xaf\xbb\x49\xb6\x3f\xda\xe3\xf1\x7a\xf3\xf7\xe6\xcb\xf9\xa6\xc8\x57\x70\x87\x7c\xe5\x62\xcf\x92\xfe\x25\xf2\x68\xa9\x43\xb7\x6c\x2b\xab\xf1\x97\x91\x74\x4f\xd2\xc3\xe5\xda\xf0\x1e\x7c\x9d\x0a\xd4\x59\xac\x61\x75\x0c\x7f\xfb\xcd\x3a\x11\x2f\x5c\x0f\x1d\xd2\xb7\x7e\x43\x23\x32\x8a\xd9\x1c\x5e\x3a\x0a\xa5\x12\x89\x79\xb3\x2c\xf5\x2a\x5d\x71\x3a\x15\x31\xa1\x8c\x7b\x8e\x7d\x92\x34\x83\xf2\x36\x04\x6f\x2c\x87\xbe\xeb\x01\x81\xde\x1c\x77\xc1\x3a\xdc\x7e\x5d\x5b\x3a\x6c\xeb\x28\xf1\x3f\x67\x42\xe6\xc2\xf0\xfb\x14\x0b\x1b\x24\x2c\xa8\xab\xe8\x89\xda\xec\x3c\x57\x6a\xcd\x3d\x90\x52\x2a\x7f\x31\x9b\x0a\x34\x28\x93\xad\x39\xc3\xfa\x38\xb9\xac\xf0\xbf\xf2\xb6\xd0\xbc\xab\x05\x8b\xb6\x9c\xa3\x1c\x89\xaf\xb6\x17\x6f\xc5\x3b\xce\x27\x67\x95\xdc\x4f\x5e\xe0\x19\xf1\x5f\xbb\x8a\x9b\xe8\x4e\xf8\xa4\x65\xc2\xe2\xb4\x4b\x0b\xb7\x64\xb4\x23\x77\xb0\x35\x03\x9d\x37\x3a\x8e\xa2\xc8\x33\x43\xe3\x68\x3e\xb7\x22\x2e\x8e\x92\x6d\xe8\xe8\x36\x76\xa0\x9c\x84\x61\x9c\x1c\xe4\x22\x35\x48\x45\xdc\x1c\xff\x99\x63\x7d\x90\xef\x0e\x93\x28\xca\x8c\xa7\xc2\x1b\x48\x3d\xee\x2a\x9c\x80\xf4\x13\xc5\xd4\xaf\x09\xac\x33\x4f\x23\x77\xf5\x23\x52\x83\x00\x0f\x22\xeb\x3d\xe2\xdb\x07\x3c\x7f\x58\xf6\x01\xa8\x83\x7a\x4b\xd3\x69\x9d\x93\x43\xaf\xf7\x85\x2d\x3b\xc4\xe0\x6a\x7d\x7e\xc4\x47\xb1\xda\xb5\xa3\x9f\xcb\x2e\x45\xb5\x72\x5f\xc3\x17\x6d\x37\x4e\x41\xbe\xae\x2b\xf5\x98\xbd\xb9\xdc\x96\x54\x2b\xf7\x35\x05\x40\xe7\x2f\x6e\x5f\xb3\xdb\xeb\x3d\xac\xf3\xf3\x85\xed\x6b\xd6\xd6\x2e\x6b\x6b\x97\xb5\xb5\x4b\xa3\xb5\x0b\xfc\x7a\xc5\xeb\xc8\xeb\x8e\xc1\x8f\x3c\xca\x78\x92\x0c\xc2\xec\x98\xfd\xb7\xce\x82\x60\x67\xbf\x57\x0d\xdf\xe8\x55\x68\x03\x7e\x56\x0b\x96\x9f\xf8\x84\x5f\xa2\x88\xa8\xf2\x76\xdc\xf6\x21\x9b\xda\x97\x20\x0b\xde\xbd\x0e\x68\x53\xf3\xfa\xa2\xfc\xb3\xda\xba\x6c\x6d\x91\xbf\xc9\x43\x41\x63\xcd\xb1\x13\xb9\xec\x0b\x8d\xf9\x83\xd6\x99\x0b\x2a\x36\x08\xa3\x8b\x3a\x7c\xee\xcd\x3d\x85\x8a\x36\xef\xc1\xef\xae\xe4\xcf\x66\xeb\xd2\x40\x1b\x57\x70\x92\x53\x4c\x26\xa2\x54\xc8\x4a\xd1\x31\xa6\xe9\xd4\xe8\x38\xc2\x34\x1a\xf1\xec\x75\xa2\x15\x6c\xff\xf8\xf0\xf6\x07\xf9\x18\x2b\x6b\xce\x6a\x26\xa2\x12\x0e\xbc\x1b\xb6\xac\xea\xed\x7a\xad\x59\x98\x82\x7b\xd4\xd6\x16\x19\x87\x45\x34\xd2\xdb\x67\x4d\x0b\xd8\x6d\x95\xe4\xab\x63\x22\x2d\x9d\x29\x46\xeb\x2c\x5f\xab\x85\x57\xa6\x16\x36\xac\x8a\xdd\x3a\x64\x94\x51\x24\xe7\x4c\x61\x98\xe9\x49\x7d\x02\xbc\x5c\xa8\x3f\x7d\x3a\x86\xe0\xaf\x38\xa0\x43\x9e\x51\xe8\x0f\xf6\x1d\x0c\xb2\xac\x29\xf1\xf4\xb5\x28\x59\x74\x7b\xab\x4e\xf8\x92\x9b\x5d\xd1\xd4\x6a\xb6\xbe\xdc\x70\xbb\x71\xa9\x20\x45\x87\x5e\x28\x96\xe3\x5a\xa9\x6c\x31\xf6\x6a\x41\x3a\xc4\xf5\x82\xb9\x0b\x36\x0a\xe5\x8a\xd9\x0a\x67\xb9\x60\x90\xb2\xe5\x4f\xbf\x5e\xa5\xb3\x78\xcd\x0a\xf7\x28\x5e\xb3\x85\xed\x31\xfe\x88\x0b\x55\x3e\x89\xd7\xac\xf0\x0f\x22\x16\xad\x97\xab\xf2\x1c\x5e\x0b\x26\xce\x5f\xae\xf5\x29\x74\x56\xcb\xa8\x3a\x44\xe7\x34\x2f\x72\xe5\x0b\x9a\x70\x6d\xe2\x23\x8d\x76\x26\x61\x16\x8e\xc9\x27\xbc\x70\x6f\x65\xba\x28\x93\x38\x2a\xe7\xd3\x2c\xa2\xda\xba\x4e\x76\x68\x2d\xff\x7b\xec\xe1\x48\xb4\xbc\x7c\x8e\xc1\xb1\x3c\x0e\xd2\xc5\xd0\xda\xdf\x09\x5d\xc4\x22\xd0\xb7\x41\xfa\x29\x9c\xd0\x6c\x71\x56\xe3\x4c\xf2\x43\x67\xca\x55\xfa\xa6\xc4\xe2\x48\xf6\xb3\x82\xc3\x91\x5f\x8e\x56\x60\x69\x07\x96\x9a\x0b\xb5\xf0\x01\xcc\xa6\x40\xa3\x2c\xf7\xcc\x98\xf9\x12\x96\x92\xb3\x71\x7e\xd6\x21\x3c\x23\x41\x38\x2d\x78\x60\x7a\xd2\x50\xaf\xb4\x99\x70\x53\x24\x32\x81\xaa\xad\x93\x1a\x88\x74\x3a\x1e\xd0\xac\x3e\x62\x1b\x1c\x02\x94\x90\x52\xe4\xd1\x9a\x1b\x42\x48\xb8\x42\x1a\x01\x37\xc0\x60\x79\x56\x04\x35\x98\xf8\xc7\xb6\x8a\x8e\x2a\xde\x52\x59\x91\xbc\xcb\x18\x46\x87\x04\x69\xa4\xb4\xa3\xeb\x93\xa0\xe0\x18\x9a\x70\xc4\x33\xf6\x5f\x9e\x16\x50\x08\xf6\x68\x81\xb6\xe3\x4a\x8a\x6c\xa1\xea\x10\x49\x5a\xd7\xae\x77\x71\x10\x6d\x4d\x04\x06\xf7\x8d\xbf\x75\x3e\xa1\xd1\xff\xd7\x87\x7d\x1e\x87\xd7\x6c\x3c\x1d\x93\x11\x84\x92\x16\xfb\x1d\x92\x9c\x8d\x27\x89\x3c\x4f\x26\xf4\x2d\x4f\xa9\xd8\xf3\xb1\xb8\xa4\x33\x7e\x95\x93\x84\x42\x32\xc8\x10\xe9\xc5\x25\xa3\x57\xaa\x7d\x6c\x4c\x86\xab\x55\x59\x26\x43\x52\x84\x93\x49\x38\x10\x0f\x89\x8c\x86\x84\x4f\x0b\x48\x3b\x28\x51\xcc\xee\x14\xbc\xcc\xaf\x46\x2c\x1a\x89\xa3\x12\xb3\x7c\xcc\xf2\x5c\x35\xee\xbc\x25\xc5\xf8\x75\x14\xec\x28\x4c\xa2\xd6\x76\xaf\x77\x39\x22\x9b\xe4\xf9\xd3\xc9\x75\x5b\x6a\x37\xa5\x99\x34\x7b\x77\x4c\xc6\x5c\x1c\xb4\xe9\x98\xa0\xdc\x47\x67\x3b\xfc\x85\x0e\x2e\x58\xf1\xee\x92\x66\xc3\x84\x5f\x1d\xab\x8f\xb0\xfa\xd3\x68\x14\xa0\x50\x5d\xae\xb6\x54\xc9\x2c\x6b\x6f\x27\xaa\xcf\xb4\xb5\x13\x40\x5a\x07\x70\x69\xe2\xf3\xeb\x9f\x05\x1d\x4f\x3a\x98\x73\x0b\xcc\x45\x0a\xf9\x71\x1e\x9b\x3c\x50\xdb\x48\x78\xe3\x45\x9f\x80\xb1\x8d\x36\x8f\x93\x56\x25\x60\x30\x27\x30\x09\x4d\x6d\x04\x54\x1b\xa3\x47\x48\xa7\x7b\xf1\xd7\x37\x50\x1b\x7f\x3c\x7e\x6c\x94\xd2\xa2\xea\x89\x28\xfc\x68\xb7\x8c\x25\x4e\x0c\x56\xa3\xa4\x05\xf5\x1e\xcc\x0e\xff\x58\x2e\x03\xa5\x8c\xb8\x29\x26\xba\x88\xc9\x20\x2c\x0c\xa6\x9e\x94\x36\x83\x18\x5a\xf1\x44\x34\xfb\xb1\x1b\xf1\x34\x0a\x8b\x96\x98\x55\x1b\xa2\x27\x8a\x62\xf5\x6f\xf7\x9c\x16\xd2\xf9\xe7\xa5\x94\x6e\xcc\xce\xed\x37\x56\x72\xba\xdf\x7e\x23\x5e\x51\x37\x87\x84\x73\x34\x06\xf5\x8e\xa5\xe7\xdf\xda\x22\x7f\x15\x77\xfe\xf7\xec\xfa\x2d\xad\x37\x5a\x7a\xc5\xc7\xdd\x21\x4b\xe3\x57\xef\xde\xc2\x3b\xbf\xe5\x36\xdf\xee\x0e\x59\x96\xa3\x79\x62\x9d\xce\x7c\xee\xc6\xdc\xb1\xca\x9d\x55\xeb\x32\x36\xb2\x48\xad\x81\x51\xdf\x86\xa5\xb4\x9a\x55\x39\x08\x75\x0b\x8f\x1e\x91\x3b\x2d\xd2\x92\x13\xc2\x61\xb6\xda\x07\xde\x6a\x97\xd6\x0d\xe2\x25\x9b\xe9\xce\xbf\x19\x76\xac\x07\x7b\xb6\x7a\x3c\x66\xb3\x66\xcf\xb2\xa2\x92\x3f\x83\x5b\x77\x8b\x30\x09\x10\xbc\x46\xdd\x7c\xa0\x4a\xa4\x66\x1b\x88\x02\x47\xe1\x65\x6f\x84\x32\x93\x61\xea\x0e\xeb\xb0\xa1\x67\x86\x29\x57\x73\x64\x96\x90\x5e\x03\x5b\x3a\x2d\x42\x5b\xb0\xa8\xe4\xe8\x57\x3c\xbb\xc8\x09\xf0\xf7\x13\xd8\x3a\xe5\xb9\x62\x61\x5a\xcb\xe9\xe0\x07\x5a\x04\x39\x91\x41\x9a\x20\x0b\xf2\x84\x51\xe4\x54\x13\x7e\xce\x22\x19\x45\x26\xcb\xc5\x8d\xa5\xc3\x9c\x88\xce\x32\x16\xab\x64\xa4\x10\x1d\xc3\xb4\xe9\x4b\x3b\x6b\x36\xc9\xdf\x67\xc5\x01\x46\x09\xa3\x69\x81\x57\x1a\xf9\xc6\xec\xa4\x53\xfe\xe8\x11\xf9\xca\x20\xaa\xb8\xe9\xbb\x32\xd0\x87\x1b\x91\x26\x47\x5d\x09\x86\xe4\x71\x14\x22\x56\xb8\x0c\xf2\x98\x04\x93\x6b\xcb\x72\x69\x06\x4e\x41\x7f\x27\xe8\xff\x13\xb3\x8c\x4a\x43\x46\xf1\xf0\xc9\x8a\x44\xbc\x79\x02\xcb\xa7\x2d\x20\x7d\xfd\x1b\x5c\x87\x02\x71\x13\x88\x81\x2d\xd6\x61\x57\x05\x70\xd2\xb7\xfc\xff\x40\x28\xa1\xc7\x38\xc9\xc7\x24\x68\x07\x95\x26\x53\x6e\xce\x57\xc0\xf0\xfa\x94\xb0\xf0\x59\x23\x7d\xe3\x59\x11\x43\xfb\xdf\xf4\x46\x46\x71\xf1\x32\xe8\x76\xc8\x05\xbd\x71\x09\x19\xdc\x97\x62\x91\x8a\x70\x10\xd8\x23\x80\x0a\xdd\x49\x06\xff\x2a\x1d\x8a\x41\xd3\xaa\x59\xd8\xef\xa5\xaa\x44\x9e\x55\x70\x5e\xa6\xdb\xb2\xa7\x19\x72\x14\xca\xac\x70\x9e\xab\xd6\xe2\x3d\xe6\xb2\xa4\x47\xbe\xc7\xb1\xa2\xd7\xaf\xcc\x57\x2c\x7e\xcb\xa7\x69\x9d\x1d\x7d\x09\xce\xbb\x26\xec\x69\x4f\xa8\x63\x15\xe7\x1e\x7e\x67\xce\x65\x6b\x79\xbb\x9f\x9f\x27\x71\x58\xd0\x39\x06\x84\x80\x2d\xb1\x85\x3f\x99\xe8\x6d\x6a\x68\x5f\xe9\x72\x18\x9a\x38\xbc\x0d\xa3\xdd\xda\x22\x3f\x52\x1a\xc3\x63\x3b\xa3\x78\x3b\x86\xb9\x4c\x90\xac\x9f\xb8\x68\xb7\x0f\x59\x28\x0a\x4e\xc2\x14\xed\xc2\xdf\xf2\x38\x4c\x1c\x1f\x48\x48\x96\x2c\xee\x00\x32\x16\xdf\x54\x16\xe6\x51\x98\x9e\x53\x93\x49\x59\xf4\x25\xf1\x8f\x84\xe9\x0d\x49\x68\x78\xd1\x5d\x6e\xfd\x96\xf0\x36\x10\xed\xab\x04\x94\x8b\xf8\x1b\x94\x52\x53\x2e\xed\x49\xe0\xa8\x13\x0c\xa4\x53\xec\xa6\xcf\x53\x17\xe5\xa9\x43\x38\x1c\xf3\x48\xf8\xf2\x57\x23\x3b\x30\xd0\xa6\xcc\xae\x50\x01\xe9\xd4\x3e\xb4\x98\x27\x15\x93\xb2\x04\xe6\x34\xe8\x88\x10\xac\xee\x9d\x72\xbb\x86\xbe\xd7\xad\x2b\x7d\x25\xde\x07\x35\x3e\x07\xce\x02\x63\x14\xbd\xd7\xe8\x11\x4f\x02\x33\x27\xf8\xe5\x8c\x59\x94\xc0\xe0\xee\x90\xd4\x52\xeb\xd4\xb5\xad\xb3\xcb\x23\x36\x27\xb6\x2c\x73\xfa\xd2\x71\xa7\xfc\xa1\x02\x19\xfb\xa4\x7e\x0f\x8c\xc6\xc9\x63\xcb\x6c\x20\x54\x9e\xa2\xb8\x40\xb9\xe2\x56\x5f\xc5\x46\x28\xd1\x37\x12\x06\x67\xcf\xb3\x30\xcd\x87\x3c\x1b\xaf\xa4\x35\x5b\x54\xd6\x10\xa4\xd5\x42\x58\xe7\xf6\xb2\x56\x68\xae\xda\xfa\x30\x7b\xad\xa8\x80\x0d\xca\x84\x19\xe4\x1f\x0e\xc4\x6d\x7b\xa3\xf2\x87\x97\x0c\x82\x2c\x62\xe8\x6c\x0c\x29\xca\x38\x35\x17\x56\x89\x61\x27\xb4\x4f\x02\x41\xe6\x03\xd7\x1a\x9a\xa7\x92\xd9\x70\x30\xc3\x62\x42\xec\xf9\x74\x5c\x92\xe6\x2f\x4f\x46\x87\x0e\x55\x1e\xb6\x52\xc1\x8a\x97\x16\x11\x49\xb3\xfd\x7c\x13\x70\x07\xee\x42\x3a\xeb\x58\x45\x9f\x75\x91\x5a\xe5\x5a\x23\x69\x31\xe8\x99\x06\xd2\xf0\xa2\xaf\x30\x8e\x46\x21\xaf\xb6\x65\xae\x92\x45\x4a\x71\xe5\xd2\x49\x39\xc5\xe7\x0f\x28\x4d\x05\xb3\x4d\xcb\xc2\x58\x8c\x0a\xac\x8b\x95\x64\xc5\xb3\x8c\xdc\x7e\x58\x96\x91\xf3\x18\x20\x3d\xfd\xe2\xc6\xc5\xca\xa6\xe9\x01\x58\xb6\xee\xfc\x01\x02\xf2\xff\x79\x8c\x5d\x0b\x2e\x9e\x2d\xd3\xb1\xc0\x43\x90\x5a\xd6\x5a\x45\xee\x37\x54\x6a\x1a\x42\xb9\x87\xb5\xa5\xed\xda\xd2\xf6\x0f\x61\x69\x7b\x41\x6f\xa2\x7a\xab\xca\x67\x7b\x3e\xe0\x8c\xd4\x1a\x02\xc4\xe0\x02\xfa\x92\xd5\xa6\x18\xd8\xd9\x2f\x81\x36\x86\x9e\x93\x30\xba\x52\x18\x15\xec\x92\x6a\x33\xc2\xea\xa9\x3e\x7b\x5a\x0d\xdf\xd4\x93\x03\x68\x68\xd7\x55\x4a\xb3\x57\x3c\x9a\x36\x74\xb7\x6d\x2d\xad\x03\xdf\xd4\x9d\x03\xa8\xab\x37\xd8\xf3\x6e\x5b\xc9\x54\x66\xd9\xf2\xae\xed\x78\xcb\x76\xbc\x62\x4d\xee\x6e\x12\xab\x8d\xae\xff\xc4\xf6\xa3\xab\x09\xf4\xe3\xb7\xc2\xd3\xef\x92\x69\xbd\x8e\xbf\x6c\x1b\x52\x6e\x40\xbf\x9f\x1a\xda\x70\x34\xbc\xf2\xb8\xdd\x45\xcb\x2b\x9a\x98\x4b\xd3\x2b\x00\xef\x55\xdb\x6b\x2b\x57\xfe\xf0\x1a\x5f\x50\x1b\x2c\xa8\xf5\x85\x05\x5a\x56\xf3\x0b\x09\x80\x25\x35\x80\xb7\xef\x34\xcb\x68\x5a\x7c\x08\x07\x6f\xd2\x98\x5e\xf7\x8d\xe8\xce\x55\x25\x24\x35\x5a\x51\x5b\xf9\x58\xf5\x7d\x90\x4c\xb3\x0f\x6c\x0c\x6f\xb7\xd2\x47\x14\x0d\x88\xf3\x52\x56\x4c\x98\x7d\x2a\x37\x94\xd3\x42\xfc\xc9\xa7\x45\xab\x4a\x1b\x6b\x2b\x22\xc4\xb8\xbd\xc4\x05\xd2\xf9\x7f\x1e\x65\x5f\x62\x2b\x3c\x55\x65\xb9\x64\xdf\x4b\x7d\x30\x34\xe2\x5e\xcf\x5e\xfa\x0a\xf7\x32\x35\x1f\xa1\x75\xa7\x79\x90\xc2\xe3\x41\x51\x4c\x85\x0b\xde\x71\x7a\x6f\xfb\x92\x10\x1c\x75\x46\xc5\x02\xc9\x1d\x6d\x39\x1d\xdc\x96\x95\x2a\x1d\xb2\xdb\x6b\x1f\xd4\x2b\xa2\xc4\xf6\xd4\xeb\xa1\xc4\x57\x4f\x61\x53\xa9\x84\xaa\x55\x40\xb9\x32\xf6\xa5\x36\x46\x54\xc4\x23\xaf\xb2\x85\x00\xb7\x67\x56\xce\x1d\xdf\xbd\xec\xa1\xb5\x7c\x46\x81\x36\x9d\x04\xe2\x48\xeb\xdf\x31\xbf\x4a\x83\x36\x04\x4e\xf9\xca\x19\xc1\x6f\xbf\xb9\x23\x7a\xf4\x88\x2c\x84\x06\xd5\xb8\x5f\x67\x70\x50\xa7\xc7\x9c\xc3\xe8\x60\x86\xad\x81\x4c\xee\x31\x4f\x57\x49\xb3\xd6\xdf\x42\x50\x93\x30\xc4\x5f\xc8\xd9\xaa\x49\x7b\x51\xec\x25\xeb\xa6\xf4\xba\x90\x5b\x7d\xcc\x06\x09\x4b\xcf\xdd\x15\x9a\x01\xbc\xd8\x70\xa7\x93\xbb\x0d\x56\x80\x32\x3e\xcd\xe7\x1e\x70\x75\x85\x86\x41\xd7\x1f\x7f\x79\x70\xeb\x29\x80\x04\xb0\xd5\xc9\x8d\x94\x40\xa0\xce\xf7\x25\x5b\x9a\x55\xd1\x02\x31\x01\x9f\xe6\x57\xa3\x60\x55\xee\x1c\x40\x4a\x2f\x56\x51\x55\x12\x9d\x7a\xb4\x56\xfd\xeb\x56\x4e\xd8\x47\x40\x02\xdc\x74\x7d\xdd\x66\xe7\xb4\xa8\xa6\xde\x36\xed\x66\x6d\x57\x86\xed\x65\xd6\xa9\xa4\xe7\x9f\x55\x49\x8e\x6c\xe3\xca\x15\xe5\xf5\xd7\x58\x93\x26\xfc\x17\x96\x24\x3f\xa7\xe3\x79\xfa\xb4\x40\xad\x6e\xa3\x84\x86\x99\xe2\x2c\x5c\xae\xa3\xbe\x7b\x6b\x90\x35\xbd\x3a\x3b\x2a\xfe\xd7\x9b\x68\x4e\x8b\x63\xc1\x96\xb5\x3e\x95\xd9\x31\x80\xd7\xd1\xb9\x2a\xba\x87\x33\x5d\xd3\xb1\x3c\xef\xce\xa9\xf2\x7a\x50\x4a\x6b\xe0\x0b\xbb\xde\xc7\x52\xc0\xa4\xe6\xe3\x58\x7d\x1a\xbf\x4a\x94\xd1\xa0\x73\x2e\x4c\x49\xb5\xbd\x58\x8d\xd9\x9a\x45\x1b\xf5\x14\x1e\x3d\x2a\xcd\xea\xdb\x43\xd2\x9b\x4d\x02\xdc\x83\xea\xb5\xf1\xb1\x64\x4a\xe0\x5f\x6e\x0d\x8d\xce\x34\x67\xab\x32\x48\x98\x8d\x49\xde\x91\x58\x90\x5c\x56\x73\x4e\xf7\xc4\xce\x56\x2d\x0e\x50\xdb\x82\x8e\x45\x3f\x27\xfa\xa5\x02\x8d\x96\x65\xda\x6e\xc3\x7a\x9b\xda\xb5\x83\x57\xf8\x0c\x3d\x74\xe1\xe0\xbc\x1b\x3a\x17\xa9\xcb\xa7\x95\xeb\x7e\x75\x78\x48\x36\xb7\x2b\x02\x55\x95\x08\x73\xa9\x6e\x39\x98\x93\x36\xf6\xa9\x63\xc3\xea\xda\x76\xc7\x3f\x6b\x3f\x9d\xd6\xdb\xb5\x31\xa5\x4a\xbd\xf4\xea\x49\xca\xc3\x34\x8d\x91\x41\xc8\x9a\x82\x67\xe2\x73\xc4\xb6\x76\x11\xbf\x5d\x08\xf3\x10\x39\xf5\x38\x98\xfb\x31\x20\x51\x91\x2a\x71\x2c\xf8\x97\xec\xf0\x2e\x46\x21\x35\xda\xfb\x39\x74\xf7\x75\x9a\xfb\x8c\xf3\xe2\xbd\xab\x6f\xc7\x92\x4a\x9d\xbb\xd4\xb8\x27\xd5\xda\xf6\xdb\xca\xdd\xb3\x03\xe8\x55\xed\x89\x63\x30\x50\xb5\x29\x52\xb4\xe6\xc9\x0e\x0c\x0b\x34\xdb\x24\x42\xc7\xe3\x1c\x87\x13\x1d\x9d\xb2\x63\xf1\xa1\x50\xd6\x21\xde\x35\x4d\xb4\x29\xbc\xd7\x1e\xcb\xff\x15\x26\x2c\x56\xfb\x03\xb5\x4b\xaf\x72\x2f\x75\x9c\x1e\xee\xc6\x46\x09\xa6\xb4\xfd\x09\x4f\xa9\xd3\xba\x6f\x22\x51\x78\xac\x02\xe4\x08\xc6\xcd\xa9\xbc\xd3\xc9\x0b\xd2\x23\x7d\xb2\xb9\xdd\xf1\xc6\x38\xec\xe3\x69\x94\x8c\xbd\xa2\x2b\xe4\x85\xb5\x3a\x8d\xd6\x17\x9e\x28\xa8\xc2\x02\x83\x58\xe2\x25\xdf\x68\x04\x48\x69\x5f\xb5\xe5\x3d\x15\xec\x55\xb3\x9f\x2f\x73\x19\x6a\x88\xa3\x32\x97\xb1\x06\x08\xe3\xec\xb4\x46\xf3\xe6\x2e\xfd\xf4\xc7\x11\x90\x2f\x22\x06\x9f\x53\xd8\x3d\xbf\x48\x9b\xf4\xc9\xa7\x4a\x9b\x17\xb3\x8d\xab\x4f\x93\xb8\xdb\xdb\x7d\x88\x26\x2f\xc7\x70\x9a\x6a\x83\xe2\x3c\xf9\xc2\x16\x2f\x38\xbc\x87\x60\xf0\xf2\xe4\x77\x6d\xf0\xb2\x8e\xfc\x76\xcf\xe6\x04\x32\xa5\x74\x5d\xb3\x4f\x7c\xc0\xc6\xd0\x58\x08\xe2\x9d\xd1\x37\x90\x55\xa2\xc6\x34\x6d\x7b\xaf\x0a\xba\xa9\x13\x0b\xec\xb3\x06\xf9\x6a\x9a\xc6\xf6\xee\xb6\x0b\xd7\xd4\xb6\x3b\xf4\xdf\x65\x62\xba\x66\xbb\x8c\x85\xf3\xbf\x2d\xa9\xea\x87\x85\x5c\x68\xdc\x8a\xbd\x85\x17\xf4\x9d\x47\xef\xb6\xd6\x3c\x07\xf1\xde\x7f\x33\x16\xb4\x0c\x02\x32\xa5\x43\x9e\x45\xe8\xb8\x71\x74\x7c\x4c\x58\xfa\xab\x34\xd2\x86\x44\x23\x1b\xf7\x93\xed\xae\x29\x2d\x1d\x38\x65\xf5\x49\xb0\xdd\xeb\xfd\x8f\x93\x5a\x0e\xb9\x56\xd3\x48\xb0\x39\xe6\xff\xdd\x0c\x27\x13\x1a\x66\x61\x1a\xd1\x40\xe7\xf9\xc2\x54\x5d\x63\x7e\x49\xc9\xf7\x2c\xa3\x43\x7e\x4d\xa2\x69\x5e\xf0\x31\x8e\x52\xd7\xbf\x02\x07\xed\xda\x26\xbe\x67\xd7\xe4\xf8\xf8\x3d\x61\x79\x3e\x55\x95\x0c\xac\xd7\x5b\x4e\x0b\x23\x4f\xf9\x65\x44\x53\x02\x87\x23\x8c\x0a\x41\xd3\xfe\xdf\x94\x45\x17\xc9\x0d\x06\x95\x28\xe8\x75\x41\xa2\x30\x25\x34\x8d\xc9\x74\x42\x14\x3b\x6e\xf9\xf6\xfd\x08\x6b\x22\xbf\x08\xd8\xa0\x20\x03\xaa\x21\x09\x85\x4c\x44\xaa\xc2\x34\xa7\xd9\xb1\x5c\x1d\x37\xd5\x99\xf4\x92\xeb\x93\xa0\x67\x65\x95\xf3\x53\x6c\xa1\xbb\x1e\xd9\x99\x5c\x93\x5e\x69\x1f\x8c\x6f\xdc\xe6\xcc\x26\xda\xba\xf6\x98\xa5\xbf\x60\x03\x35\xf9\xe7\xc4\x2c\x8f\x39\x61\x05\x89\x39\xcd\xc5\xfc\x22\x9e\x24\xe1\x24\xa7\x6a\x56\x23\xd7\x07\x9f\x8e\xa5\x73\x5e\xab\xba\x45\xb2\x49\x76\xda\xfe\x30\xa2\x69\x96\x43\x62\x34\x48\x3b\x6e\x25\x46\x0c\x1e\xf5\x51\x1e\xdb\x77\xc5\x84\xc7\x23\x7e\x85\x6e\x9b\xac\x08\x72\x92\xf2\x82\x84\x29\xee\x18\xe4\x24\xd2\xb0\x0d\xf9\x0c\x75\xa2\x26\x48\xd9\x03\xde\x8b\xd9\xf9\x20\x14\x2f\x7e\xf9\xff\xdd\xde\x5e\x1b\xbc\x18\xa1\x7c\x67\x6f\xaf\x43\xcc\xff\xe0\x57\x2b\x59\x1d\x9c\xc4\xf7\x61\xcc\xc4\xb3\xab\x67\xf2\xd0\x1d\x8d\x32\x48\xd2\x66\xe1\xb4\x7e\xce\x97\x4f\x00\xba\x65\x61\x63\x66\x11\xe0\x0c\xc1\x27\xf1\x52\x70\x56\x23\xaa\xc8\x29\x67\x46\x25\x96\xe4\x78\x14\xc6\xfc\x0a\x90\x4b\xfc\xdf\xff\xea\xf5\x7a\x41\xfd\x40\xde\xbc\xde\xde\x26\x61\x96\xf1\x2b\xd3\x7d\x7f\x73\x9c\x6f\xd2\xeb\x49\x98\xba\xb9\xed\x4c\x3a\x4c\x93\x94\xb2\x94\xc0\x4e\x20\xbc\x78\x6f\x98\x8a\x0a\x67\xc1\x28\xdf\x9c\xe1\x70\x18\x66\x0c\x46\xac\x82\x31\x6c\x98\x49\xa8\xa2\x3e\x09\x68\x92\xb0\x49\xce\x72\x73\x06\x46\xac\xa0\xc7\x93\x50\x9e\xf6\xab\x2c\x9c\xe8\x6f\xdc\xd4\x1b\x41\x72\x78\xfd\x25\x61\x29\xfd\xc7\x1d\x90\xd7\x9e\x65\x39\xbd\xa4\x46\x69\xf5\x66\xb0\xc1\x59\x64\xa7\xf2\xb3\xc8\xac\xca\xc3\xa7\x07\x99\xe1\xf8\x7a\x3a\x1b\x28\x9f\xf4\xc9\x13\x7d\x6e\x6a\xd3\x22\xea\x34\x12\xfa\x24\xc9\xa3\xb5\x09\x7a\xb3\x5c\x93\x50\xb1\xfa\xaf\x38\x10\xae\x84\x47\x17\x64\x02\x50\xa8\x5d\xcb\x09\xc7\x08\x1f\x92\xc0\x09\x56\x1a\x53\xae\x89\x09\x74\x8d\x88\x60\x65\x29\xff\xd0\xb9\x42\xfb\x56\x2b\x97\xea\x89\xf2\xf3\x66\x49\x42\x04\xd6\x8c\x43\x88\x90\x92\xdc\x20\xb9\x2d\x48\x18\x45\x3c\x8b\x65\xb6\x37\x18\x21\x88\xc5\x59\x0a\x81\x46\x8a\x11\x9a\x83\x81\x17\xa5\x14\x6a\x5d\xb1\x5c\x40\x99\x84\x82\x05\x49\x68\x98\x17\xe5\xde\xe5\xec\x81\xb0\x58\x61\x2c\xa7\x05\x97\xb4\x73\xa1\x8c\x83\x7c\x02\x17\xb1\xf4\x34\x46\x0f\x4c\x3e\x99\x26\x61\x41\xed\xde\x04\x43\x29\xf3\xd9\x1d\x85\x29\x4c\x53\x50\x11\x63\x4b\x88\x8e\xa1\x67\x29\x5c\x41\x67\x84\xe5\xe8\x01\x03\x09\xcf\xce\xb0\x93\x0a\x18\xb1\xc0\x0d\x46\x88\x7f\x7d\x4f\xc3\xf8\x5d\x9a\xdc\x48\x86\x67\xf1\x68\x9c\x6e\x0b\xed\x2e\xcb\x25\xdb\x19\x37\xc6\xe6\xb4\xe0\xbe\x64\x50\x4a\x2f\xae\x94\xbe\xc8\x05\x36\x89\xe5\x93\x04\x4f\x5c\xed\x97\x82\x77\x18\x12\x56\xe4\xf8\x06\x85\x70\x6c\xe3\x49\x71\x23\x77\xed\xdf\x7c\x0a\xdc\x03\x4f\x93\x1b\xc8\x3f\x28\x70\x4d\x85\xd8\xd2\x5b\xa2\x03\x44\xb1\x9c\x9c\xc1\x06\x9e\x91\x96\x12\x33\x3b\xf9\xe9\x44\xbf\xaf\x45\xfb\x0b\xe0\xdb\xcb\x94\x9c\x01\xd3\xab\xe3\x4c\x1d\xc0\x3d\x0e\x17\xe6\x28\xbc\xa4\x32\xb0\x57\x48\xc6\x61\x41\x33\x16\x26\x9b\x53\x06\x31\x82\xd8\x90\x45\xaa\xae\x19\x06\x1c\x81\x25\x13\x23\xde\x35\x29\xe2\x6a\x13\x22\xb6\x17\x8e\xd8\xe5\xae\xa3\x59\x13\x28\x5f\x26\x5a\x97\x87\x6b\x26\xea\x9a\xc9\xa7\x28\xe8\x59\x48\x10\x57\xc8\x19\x62\x63\xc5\x10\x10\x60\xb1\xac\x85\x48\x69\xcf\x00\x75\xcf\xc8\x78\x9a\x03\xe7\x1a\xa6\xe2\xea\x0f\x6f\x80\x8a\xe8\xc8\x6a\x30\xa0\x7c\x3a\x81\xd7\xc8\x78\x9a\x14\x6c\x92\xa8\xc3\x01\xf9\x7f\xef\x01\xe3\x55\x37\x0b\xcc\x6a\x46\x44\xd9\x9a\x68\xb2\x8b\x87\x77\x7b\x4f\xf5\x3d\xa8\x09\x04\xac\xe3\x7d\xac\x03\xaa\x07\xff\x85\x52\xae\xb9\x6d\xa0\xc5\x45\x83\xc9\x39\x65\xa6\xb2\x4c\x11\xe1\xa1\x4c\x7c\x9a\x16\x19\x4f\x12\x1a\x57\xe5\x40\xbd\x6c\xec\xcd\x0a\xe0\x76\x5f\xb7\x46\x73\x18\xe7\x19\x62\xf4\xe6\x20\x6f\x2a\x6e\x9b\x7e\x11\xe3\x8b\xac\x35\x31\xe1\x1b\x04\x1f\xa3\x6f\x77\xd4\x5a\x4c\xf2\xae\x2e\xd1\xcc\x97\x51\xb5\x56\x6b\x5a\x4d\x00\x82\xca\xf8\x03\x36\x4d\xd7\x30\x76\xa1\x02\x64\x52\x90\x84\x10\xf0\x4b\x7d\xb2\x89\x8f\x86\xb0\x0b\x15\xa0\xa4\x21\x0a\x04\x7f\xea\x57\xa0\x3a\xd2\xea\xb3\x2a\x50\x00\xfa\x9c\x68\x08\x5d\xa2\x19\x55\x83\xa7\x1a\xc8\x2a\xd3\xec\xf8\x62\x7a\x60\xad\x06\xd6\xab\xdf\x90\xc8\xd0\x5e\x3b\xf1\x1b\x56\x4a\xfc\x61\x2f\x88\xf8\x9d\x4a\x51\x06\x09\xd4\x44\x55\x4c\x02\x1d\x76\xc0\x1a\xba\xca\x9d\xb7\xb5\x45\xde\xa4\x79\x41\xc3\x58\x30\x86\x67\xf2\x22\xf9\x46\x9e\x01\xe8\xe3\xdb\x33\x41\x71\xe0\x62\x85\x60\x79\xc3\x84\x5e\xb3\x01\x4b\x98\xe0\x0a\x36\xc8\xdc\xfa\x2f\x74\x49\x96\xf2\x53\xcf\x5a\xa4\x21\x3b\x20\xa2\x06\x39\xc1\x09\x07\x1f\xdb\xe2\xef\xb7\xea\x66\xff\xf9\x4d\x9f\xdc\xf0\x29\x0e\x6f\x92\xf1\x4b\x16\xd3\x58\x50\x7c\x96\x5e\x86\x09\x93\x34\x4c\x93\x4c\x86\xf7\x9d\x22\x53\x5d\xb1\x2a\xbf\x50\x19\x61\x49\x54\x53\xd1\xdf\xd5\x31\x56\xec\xb2\xba\x29\x0d\x61\x09\x3e\x76\x7f\xe5\x2c\x6d\x05\xff\x49\x83\xb6\x38\xdc\x90\xa6\xbc\x07\xab\x3a\x8f\x9e\x56\xce\xab\x51\x17\xbf\xb5\x45\xde\xf2\x5c\x27\xf2\x96\x41\x9c\x72\x02\xb1\x05\x45\x2b\x10\x32\x85\x9c\x59\xd2\x60\x64\x6c\x44\x4d\x41\x2e\xe5\x17\x6b\xdc\x90\xbe\x57\x45\x27\x7c\xf9\xd3\x1b\x22\x1e\x96\x13\x41\xf9\x39\x48\xd8\x72\xe4\xc9\x8b\x91\xb8\xa6\x07\xe2\xed\x05\x9f\x04\x0e\x1a\xf6\x1d\x4f\xef\x91\x49\xd7\xe5\x88\xad\x5d\x83\x03\xcd\xb1\xda\x08\xbb\x61\xf4\xf0\x4a\x55\x0d\x4d\xce\x8e\xb5\x80\x74\xe3\x85\x7c\xb8\x58\xd4\x03\x8f\x72\x1f\x52\x38\x6a\xe7\x0d\xf3\x9c\xa9\xa5\x74\x7d\x52\x43\xe2\x74\xbc\x85\x2a\xda\xd6\x27\x55\x44\x4d\xf1\x2c\xd5\x94\xa8\x4f\x6a\x49\x50\x9f\x34\xd1\x9e\xbe\xfd\x03\x1f\xa8\x6d\x88\xeb\xd9\x3e\xd8\xb8\xdd\xd8\xc0\xb5\xaf\x0a\x22\x60\xcd\xdf\x4e\x97\x66\xcd\x42\x17\x4b\x2e\xb8\xd9\xb2\xe4\xd4\xdb\x60\xb0\x56\x00\x7d\xb0\x9a\xb9\x6e\xcf\x4c\xda\x64\x5f\x93\x03\x1d\x4f\x99\x34\xd3\x09\xb0\x24\x58\x41\x4e\x34\xd9\x12\xb9\x6d\xb7\xa4\xd6\xf1\x7e\xd4\xc0\x7b\x6b\x45\xe2\x1f\x44\x91\xe8\xae\x62\xdd\x18\x9e\xd5\xc0\x37\x75\xed\xb5\x6c\x69\xb9\x86\xf5\x99\x57\x20\xa6\xcb\x3d\xaa\x38\x4d\x32\xdc\x3a\x47\xe2\x0a\xd0\x46\x6f\x65\x0d\xf5\x79\xd3\x0c\x89\x85\xaa\x43\x98\x27\x2e\x58\x63\x86\x21\x01\xa0\xc1\x3f\xdc\x4c\xf8\x79\x16\x4e\x46\x75\x0a\xb1\x27\xbd\x0a\xd8\xa6\xf6\x0d\xd4\x43\xd3\x5b\x7e\x36\xe7\xe4\xe5\xf5\x77\x88\xe0\x9c\xa3\x5b\x28\x04\xe9\x04\xcd\xc6\x1c\xea\x8e\x38\xcc\x2e\x40\xbf\x81\x45\x07\xb2\xbe\xd1\x99\x1c\xf1\x84\x67\xa5\xa6\xf2\x51\x18\xd3\x1c\x1e\x7f\x1f\xbb\x06\xd8\x98\xae\x54\x6b\x15\x5b\x30\x4a\xcb\x55\x52\x4a\xa4\x5f\x83\xa8\xb9\x2f\xf8\x75\x56\xb0\x30\x09\x1a\xa5\xdb\x32\xcc\x56\x16\xe6\xc5\x07\x7a\x5d\xb4\xbc\xc1\x6a\x53\x45\xaf\xbc\xef\x17\x78\x9c\x4a\x9f\x04\x82\x59\xd7\x7d\x87\x09\x3b\x4f\xdf\x14\x74\x2c\x06\x16\x51\x47\x29\x25\x00\x7f\xc9\xc2\x49\x9f\x04\x8e\xaa\xc1\x68\xf1\x9e\x4e\xae\xeb\x95\x70\xbb\x32\xec\xa6\x54\x08\xcc\xca\xe5\x8c\xc9\xb7\xb1\x25\x70\x57\x81\x65\xcb\xbb\xd3\x49\x2b\x18\xc7\x41\xdb\xb0\x70\x46\x99\xb7\xb3\xbf\xaf\x39\xaa\xf0\x5a\x16\xee\x3d\xd5\x85\xae\xae\x6a\x47\xf2\x49\x4b\x0f\x25\xe6\x57\xa9\x3f\x18\xb1\x48\x7f\xcf\xf8\x55\x9f\x6c\xeb\xe6\xa1\x01\xb9\x43\x63\x9a\xe7\xe1\x39\xb5\xb4\x20\x6a\xf5\x2a\x16\x0d\x15\x9f\x3d\x47\x87\x12\x46\xa8\x33\xf9\xb4\xfc\x46\x8e\xc3\xec\x9c\xa5\x3f\xd0\x61\xa1\x95\x51\xee\x60\xf0\x53\xf5\x2e\xba\x8d\xbc\x47\x3d\xcd\x66\x19\x76\xd5\x5a\x12\xf1\x56\xc1\xb9\xcb\x08\xe9\x62\xd6\x96\x5a\x42\x2e\xcb\xef\xda\x68\xf2\xcb\x29\x00\x56\x13\xc3\x00\xc2\xeb\x23\x82\x57\x6e\x92\x46\xfe\xcf\xbc\x4b\xb6\x36\x66\xe9\x8a\xfd\x2f\x85\x17\xd6\x20\x7c\x19\x5e\x1a\x46\x17\x83\x30\x93\x01\x18\x4b\xc2\x3c\x19\xcf\x50\x49\xf2\x30\xb3\xfe\x7c\x52\x3a\xdb\x55\xa2\xc6\x53\x42\xed\xb4\x96\x9e\xe1\xef\x3b\x8b\xbc\x70\x87\x5d\x19\x97\xe3\x02\x21\x3b\xd2\x6e\x0f\xf3\xbb\x3c\x48\x9e\xcf\x15\x3f\xcc\xf0\x75\xb0\x52\x8e\xdb\x7c\x9d\xef\x33\x31\xa2\x61\x9c\xb0\x94\xbe\x0d\x27\x13\xa0\xe7\x9f\x2c\x13\x89\xf8\x66\xbb\x8f\xc9\xe7\x7d\x03\x04\xe9\x45\x11\x26\x34\x2b\x62\x16\x26\xfc\x5c\x13\xe3\xfc\xff\x4d\xc3\xcc\xb2\xb1\x15\xff\xd1\x84\x5e\xca\xd8\x7e\x4f\x4b\x5b\xd5\xb7\x62\x63\x20\x6f\x6e\x66\xa3\x02\x43\xe2\x5d\xa6\xab\xb4\xd5\x6d\x6c\x3b\x3c\xcc\xe5\x3b\xe2\xa4\xd2\xaf\x4c\xa3\xaf\xf0\xe3\xd6\x43\x18\xf8\xd5\xb6\x6f\x33\xf2\x62\x55\x7d\xca\xf6\x74\x97\xf8\x1b\x7b\x24\x7d\x10\x46\x6c\x80\x99\xff\xed\xc6\x86\x77\x7a\x96\xb2\xd8\x57\x31\x38\x3e\xcd\x4d\x77\x1d\x8d\xef\x1f\xe2\xde\xda\x98\x83\x99\xa3\x43\xe7\x3c\x37\xae\xd0\x1c\x0c\x99\x69\x4e\xd2\x84\xc6\x4b\x6a\xde\x06\x15\x5d\xe9\xac\xef\xa7\x25\xef\x27\x60\x76\xe9\xb0\x5d\xeb\x80\xb1\xa0\xc4\xce\x3d\xa1\x28\xba\x73\xcb\xee\x49\x86\xf7\x74\x2d\xc3\x5b\x5e\x86\xf7\xf9\xc5\x66\x0f\x4a\x6a\x88\x71\xac\xd6\x62\xba\x06\x31\xdd\x9f\x57\xd6\xf5\x30\x1d\x07\x16\x19\xda\xbb\x8c\xd1\x54\xe6\xa3\xa9\x39\xd9\xcf\xe7\x1e\x9f\xdd\xd8\xbd\x89\x0a\xab\x4c\xfd\x25\x87\x68\x27\x98\xfb\x34\x9f\x10\xc4\x93\x95\x48\x09\x48\x3d\x5c\xf0\xa8\x0f\x51\x1c\x36\x41\x89\xe8\xd8\x11\x3b\x3d\xf5\xfc\xa7\x41\xf0\xa8\x9f\x84\x4d\xf5\x64\xd7\xba\xa2\x23\x26\x4a\x0a\x9a\xa1\xca\xed\x07\xb1\x15\x7d\x47\x42\xd5\x27\xda\x6d\xb7\xc9\xd9\xc1\x16\x14\xf5\x56\x2d\xd0\x39\xa6\x45\x2e\x85\x1a\x74\x42\xc2\x9c\x60\xb0\x88\x2e\x79\x93\x93\x89\x60\x14\x51\xc0\x21\x26\x5f\x29\xe6\x40\xf0\x25\xb3\x5c\x8a\xde\xd1\x05\x22\x45\x73\xda\x1b\x72\x5c\x50\xd0\x72\x83\xc9\x12\x98\xd7\xe7\x53\x29\x68\x81\xec\x7c\x62\xa8\xfe\xaa\x1a\x33\x01\x33\xac\xd2\xc2\xcf\x3d\xc0\x63\x9d\x79\xf0\x4c\x0c\xe6\x8c\xe4\xd3\xc1\xa6\x99\x3a\xc9\xa7\xd1\x48\x2c\x14\x7c\x85\xc6\xcf\x3a\xf8\x43\x32\x43\x67\x7f\xbe\x38\x9b\x5f\x44\xce\xf5\x36\xcc\x2e\x1c\xd4\x15\x9b\x94\xd0\x82\xc6\x73\x63\xaf\xae\xb1\x2c\x02\xff\x84\x9d\xc4\xfc\x2a\x25\xc3\x8c\x8f\x35\xfe\xb2\x61\x19\x4d\x59\x4e\xc2\x24\xe7\x24\xa7\x85\x3d\x84\x34\xa5\x51\xc1\x17\x4e\xf6\xfe\x7b\xb0\x6c\x2d\x6d\x91\x72\x55\xe8\x48\x6b\x7a\xb1\x1c\xb2\x0c\xe0\x06\xd3\xa2\xe0\x29\x61\x43\xac\x0f\xc7\xea\x3b\x28\x3b\x43\x83\x18\xdc\x4b\x3e\x94\x87\x73\xee\x9d\x36\x3e\x12\xcb\x6d\xf4\xcf\x39\x66\x3d\x52\xa4\x6a\xc8\x33\x82\x36\x7d\x4e\x06\x6c\x86\xc1\x1b\x66\xa4\x84\x6d\x3a\x0b\xe2\xb2\x59\x60\x90\xaf\x80\x17\x87\x20\x1a\x7a\x91\xd1\xfe\x3e\x4c\xec\x4c\xc4\x58\x72\x87\x6c\xc4\xdc\xf0\x08\x8b\x62\xaa\xc3\xab\x2c\x89\xad\x76\x1b\xab\xc1\x58\xab\xc5\x92\x55\x66\x41\x27\x55\x62\x5c\xcb\x86\x11\x7f\x1a\x3d\x8f\x77\xd4\x35\x98\xf7\x61\x55\xe6\x9b\x9a\x62\x8a\x89\xd5\x0b\x87\x35\x7d\x33\x20\xaa\xc4\x80\x48\xfa\x63\x81\xc8\x12\x4b\x4b\x09\x67\xc7\xb6\x13\xc5\x53\x2c\x01\x64\xac\x12\x6d\x23\x1a\xd3\x6b\xed\xe7\x14\xe6\xc6\x7a\x54\xfc\xd0\x82\x69\x87\x81\x95\xc1\x7b\x4c\x99\x06\x93\x98\x6b\x60\x64\xc1\x2a\x04\xdc\x68\x86\xe9\xef\x51\x83\x91\xa7\x23\x00\xd7\x4b\x89\x3f\xe4\xa2\x49\x5b\x50\x58\x1f\xb4\x03\x85\x00\x60\x24\x10\x93\x87\x80\x41\x66\x92\xf0\x53\xce\x47\xcb\xd1\x21\x10\x96\x25\xf7\x5f\x48\x9a\x4c\xf3\x13\xab\xfd\x8f\xb3\x44\x6e\x9f\x6e\x3b\x46\x68\xeb\xa3\x6a\x09\xab\xdb\x1d\x17\xef\xda\x8d\x36\x94\x65\xd1\xb1\x25\x38\xae\x93\xf6\x57\x86\x17\x9a\x25\x19\x9f\x2f\x0c\x90\x89\x74\xb3\x40\x74\x9e\x99\x11\x98\x14\xff\xeb\xd2\x83\x2a\x06\xb4\x8e\x14\x38\x5c\x48\xe9\x78\xda\x37\x97\x7f\xec\x94\x2b\x1f\x1e\xbf\xc7\xc4\x0a\x02\x84\xb7\x88\x7d\xde\x3c\x0a\x5e\x71\xd4\xec\x6b\x42\xfd\xa5\x5f\x43\x76\x34\x21\x15\x97\x4c\xe5\x5d\x32\x24\xe4\xd1\xa3\x32\x29\x7c\xf4\x88\x7c\x05\x54\xe0\xd1\xa3\x19\x4b\xae\xe9\x0e\xf9\x54\x3f\xd8\x39\x56\x16\xad\x2e\xa5\x7a\xa1\xa0\x93\x3b\xeb\x14\xe6\x78\xe4\x78\x0a\x85\xf9\x18\x4b\xbf\xd2\x32\xaa\x8b\xb9\x18\x1b\xaf\xce\x5c\xec\x80\xa3\xf0\x9c\x53\x76\xaf\x89\x6a\x43\xbb\xf3\xea\x01\x2a\xc8\xf2\x0a\x5a\xb5\x08\xfb\xef\xf8\x49\xb6\x90\x72\xe6\x01\xeb\x7a\xec\x2b\x74\x15\x9b\x6b\x5d\xc2\x7f\x84\xc7\xd4\xbc\xf3\xb6\xf8\x8d\x15\xac\xa2\xe2\x58\x1a\x1f\x31\xf3\x36\x26\xb9\x9e\x15\x0c\x4b\x33\x4a\xab\x69\xcd\xe1\xc2\xfe\x68\xef\x19\x4f\x03\x08\x97\x60\x95\xdb\x41\xe4\x39\x03\x58\xd7\x96\xed\x87\x20\x2f\x18\x5d\x64\xee\x0f\xe3\x33\xb0\xb8\x96\xb1\xdd\x12\xe3\xba\x27\xd5\xe1\xb3\xb5\xea\x70\xad\x3a\x5c\xab\x0e\xef\xd5\xc2\xff\xbe\x6d\xf1\x31\xce\x5a\x41\x27\x6f\xa2\x5a\x2d\xd7\xd3\x9d\xed\x12\x68\x63\x3c\x36\x09\xb3\xd6\x7f\x3e\x74\x25\xe3\x9c\xcd\x36\xe0\xc6\xf6\xee\xce\xdc\xa3\x83\x66\x3e\xab\xee\x73\x71\xcb\x71\x5b\xb3\xe8\xa8\x4c\x65\xd9\xa5\x20\x64\x91\x5d\xa2\x2e\x78\xad\x75\xe4\x69\xf1\x8b\x8c\x3a\xb4\xd7\xeb\xd9\x0d\x5a\x57\xff\x1c\xd0\x4b\x84\x1c\x3a\xc2\xe4\x37\x34\x33\xc3\x73\x8a\x7f\xe4\x2f\xcd\x8b\xaf\xa4\x07\xae\x55\xf0\x36\xa9\x5b\xdf\x3b\x2b\x2d\xd6\xf7\x95\xca\x2f\x0e\x99\x26\x92\xe9\x38\x0d\xe6\xd3\xd7\x16\xf4\xba\x78\x29\xf6\xa4\xce\x90\xff\x03\x9f\xd4\xc5\x31\x5b\xb5\xce\xd6\x57\xa1\xae\x15\xb8\x6e\x7c\x91\x94\x8c\x79\x5e\x90\x28\xcc\x69\x2e\xc3\x87\xb0\xf1\x04\xc3\x35\x85\x04\x5f\xa8\x44\xe6\x62\xc2\x20\x27\x05\x2b\x12\x0a\x3a\x1d\x70\xdf\x16\x1d\x3e\x00\x25\xee\x1f\xc6\x20\xd1\xdd\x9f\x23\x2b\xcc\x62\x0e\x8b\x5e\x11\x05\xe4\xcb\xa9\x95\x1d\xfc\xfe\x42\x3a\xe6\x95\xe8\x4d\xe1\xdc\x34\x28\x4f\xd1\x76\xe1\x3e\x35\xa8\x1f\x64\xb0\x36\x2b\x72\xd5\xe0\xc6\xcc\x0b\xce\x19\xd9\x24\x6c\x08\x21\xa1\x72\x6a\xa2\x0f\x89\xbf\x25\x31\xa9\xc2\x0e\x94\x7b\x2f\x76\x1c\x91\x51\x58\xf2\x38\x42\xe5\xd5\x1c\x0e\xe0\x3e\x57\xaa\x03\x2e\xa9\x6a\xd7\xda\xde\x45\xb5\xbd\x70\x16\x7c\x95\xef\xa9\x26\x20\x79\xc7\xfe\xb1\xa3\x9d\x5d\x1b\x95\xc2\x0f\x47\xc7\x3b\x5b\x81\x1b\x59\x5a\x58\xf1\x63\x41\x2d\xed\xc2\xfa\xef\x7a\xb5\xf0\xfd\xeb\x7b\x17\xd6\xed\x3a\xea\xdc\x48\xaa\x6d\x5d\x2d\x6e\x95\x0e\x59\x2b\x7c\xef\x59\xc3\x6b\x61\xa6\xe0\x14\x67\xeb\x6a\x6c\xb4\x56\x3d\x98\x0b\x46\xfd\x35\x5b\x92\x5a\xd5\x8e\xc1\x3d\x83\x98\xcb\xb5\x54\xc5\xcc\x57\xea\xa4\x17\x68\x3b\x70\xce\x54\xe0\xeb\xb3\x9d\x53\x8e\x5a\x4e\xc8\xc5\x25\x3a\x3a\x9a\x6b\xc3\xec\xee\x76\x16\xdd\x8d\x9d\x05\x95\xf1\xcb\x34\x7c\xd7\xfd\xb1\xc7\x88\xd4\x4e\x12\x41\x77\xf1\x76\xda\x5f\xca\x38\x00\x48\x59\x95\xaa\x79\xb6\x2b\x9b\x51\xc8\x2f\xe2\xcb\xe7\x3c\x62\x17\x31\xb8\xa8\x7f\xfd\x76\xc8\x57\xa5\xed\x6e\x6b\x55\xbc\xfc\x63\x46\x04\x20\x2d\x0c\x33\x41\x80\x3e\xcd\x69\x71\x50\x67\xd3\x20\xad\x0d\x22\xdb\x64\x60\xb6\x36\x5e\x8d\x1b\x27\xb0\xb4\x73\x63\x3a\x4d\x92\xf9\xa6\xae\xc7\xd6\xe4\x28\x4a\xc8\x27\xe0\x6b\xfa\x24\x00\xc7\x50\x9b\x16\xf4\xfd\x13\x6f\x25\xc0\x52\x97\x87\x2c\x68\x97\xee\xad\x79\x51\x6f\xee\xe1\x45\xe1\x44\xde\x32\x15\x9e\x96\xba\x5b\x6b\x88\xc1\x3b\x75\xe1\xa8\x41\x6e\xa8\xff\x35\x36\x11\xb0\x35\x5f\xc0\x30\x62\xa1\x77\xfd\x2a\xec\x23\x96\xb2\xc4\x58\xc6\xa8\xe2\x8b\xbc\x49\x96\x12\x11\xf8\x15\xe7\x16\x11\xac\xfa\x15\xe4\xad\xe0\xcc\x67\x8f\x6f\xc6\xf2\x60\x1e\x29\x4b\x6d\x43\x4d\xfd\xb9\x77\xe3\x7e\x1f\x49\x6b\xf3\x9f\xb5\x30\xaf\xce\xbb\x78\x6d\x7b\x74\xef\x36\x38\xd1\x12\x76\x29\x0f\x4a\xc2\xb5\x36\x10\x7a\xc8\x22\xb0\x0a\x03\x21\xe4\x08\xe7\xb1\x12\x2a\xf3\x70\x8b\x1a\x10\xe1\x4d\x5f\x67\x4f\x54\xba\xdb\x03\xa3\xed\x0c\x30\x40\xa9\x1e\xaf\x1d\xa3\x54\x15\x2e\x17\xa6\x14\xcd\x91\xf0\xb1\x75\x3f\x36\x49\xfb\x0f\x2b\x33\xe5\x6c\x23\xa3\xcf\x6f\x07\xf4\xe7\x89\x6a\x7a\x4e\x45\x71\xc1\xc5\xd1\x7c\x37\xac\x19\xc2\x7e\x0d\x78\x93\x85\x8b\x0b\xe9\x5a\x12\x1d\x85\x49\x72\x34\xa2\xd1\x45\xdd\x9c\x9f\xd7\xc0\x37\x4d\xd5\x6b\xd9\xb4\x00\xcf\x5e\x78\x45\xd7\x75\xb7\xdd\xab\x82\x6e\xec\xcc\x6a\x54\xd7\x9d\xf0\x3c\x67\x83\x84\x1e\xf1\x34\x2f\xb2\x69\x54\xf0\xec\x3d\x08\x9e\x6a\xfb\xdd\x9e\x5d\xb7\x69\x14\xf5\x1d\xea\x76\x65\xe8\xd8\xfa\xa9\x97\x41\x9b\x7a\xd4\xcd\xdd\x6f\x7e\xcd\xcf\x61\x9a\xf6\x21\x0b\x53\xf4\x76\xaf\x23\x28\x4f\x2b\x60\x1b\xcd\xc6\x34\xd4\x67\xb5\x7f\x2b\x74\xb7\xb5\x9d\x3c\xf9\x3c\x39\x74\xab\x43\x15\x9b\x65\x59\x26\xea\xc5\x07\x0c\xe4\xba\x92\xc8\x17\xd0\xd6\x0a\x8d\xbe\x1e\xa4\xb5\x9c\x59\x6e\x41\x0c\x07\x61\x74\x51\x77\x86\x7a\x73\x8f\xb1\xa2\xcd\xcf\x63\xa4\x16\x59\xd6\x5a\x52\x8c\xa8\x72\x2d\xea\x74\x70\xf5\xd9\xed\xcc\xc9\x50\x36\x51\xd6\x59\x91\xf2\xd0\x56\x80\x0d\x06\x6d\xdb\x02\x0b\x4c\xab\x6c\xbb\x32\x9d\xe1\x11\x42\xa4\xda\xa0\x32\x21\x82\x01\xdd\xda\x22\xff\x10\x2b\x54\x70\x72\x4e\x0b\xa3\x7f\x05\xbb\xa3\x90\xa4\xf4\x1c\xf3\x90\xa0\xc1\x96\x00\x4b\x79\x01\x2c\x27\x1b\xa2\x59\x02\x76\x06\x5c\xec\x54\x4a\x66\xaa\xcd\xf4\x2a\xc6\xf1\x26\x75\x56\xab\x22\x45\xe9\x52\x16\x60\x06\x03\x5e\x4d\xb3\x26\x53\x4c\x37\x39\x4e\xb3\x07\x7a\xf3\x7b\x02\xd3\x8b\x17\xb4\x3e\x15\xbc\x72\x64\x27\x84\x5e\xb3\x7a\x99\x1d\x82\x6d\x40\xf4\xdd\x86\x11\xb7\x30\xc3\x4a\xf0\xb1\xfd\xb1\xbd\x62\xf3\x38\x30\x25\x83\x74\xac\x0b\x9a\xad\x44\x18\xcb\x83\xa4\x82\x48\x60\x9e\x32\x95\x7b\x34\x5e\x9b\x86\xdd\x97\x69\xd8\x83\x09\xb7\x2b\xb7\xf3\x18\x6d\x05\x97\xc8\x29\x85\x35\x67\xe4\x92\xaa\xc0\x3a\x75\x77\x4f\x73\x99\x2e\x4b\xac\x00\x84\x2e\x17\x98\x28\x73\x7c\xbd\x86\xcc\xbe\xc6\x96\xb1\xe0\x90\xe9\x2b\x24\xaf\xde\xbd\xd5\x99\x71\x64\xaa\x2d\xc7\x76\x0a\x3a\x51\x4f\x62\x9d\x38\x30\x24\x67\x68\x3f\x76\xe6\x5a\xad\xc9\x78\xab\x4b\x79\xd2\x7d\xd0\x11\xdf\x97\xf7\xa6\x83\x36\x56\xea\x51\x27\x4a\xdb\xe5\x65\x97\x64\x5f\x66\xef\xd1\x57\x1f\xda\xb0\x56\x1d\x7b\x55\xa4\x32\xb8\x2e\x60\x5e\xd8\x9c\x78\xcf\x5c\x93\x84\xa5\x76\x58\x91\xf9\xf5\x22\x8d\x66\x5d\xe9\x6b\xa4\xeb\x8b\xed\x69\x15\x67\xb3\xe4\xd6\x56\x34\xb5\x9a\x1d\x2e\x37\x3c\xc3\xc8\x4e\xae\x05\x46\x7d\x5f\x2f\x87\x5c\x0e\xc1\x7a\xad\x57\x43\xac\x06\x30\x36\xeb\xa5\x90\x4b\xb1\x3e\x26\xb8\x1a\xc0\x8c\xdc\x89\xcb\x80\xf7\xd0\x42\x2d\xc0\xa5\xad\x98\x7f\xc5\x13\x98\x9b\xa2\x43\x58\x4a\xc6\x2c\x49\x18\xe6\xdd\xb6\x33\xa2\x8e\xc3\x1b\x99\x51\xf7\x06\xb2\xc9\xa5\xe7\x09\x25\x05\x1b\x53\x3e\x2d\x30\x1b\xa7\x73\xe9\xe4\x1d\xc1\x36\xb0\x34\x66\x97\x2c\x9e\x82\x4b\x07\x3e\x9e\x40\x2c\x41\x23\xc9\x46\x18\xdf\x8f\x82\xcb\x87\x99\xf8\xcb\xcd\x8d\x1d\x85\x49\x24\x13\x4b\x9b\x4b\x4d\x74\x4d\x06\xa1\x60\x6e\x78\x2a\xef\x5d\x73\xcd\xc9\x81\xcd\x93\xfc\xf3\xae\xef\x9b\xf9\x5f\x38\xf3\xbd\x71\x64\x8e\x91\x39\x5f\x39\xfa\x11\x78\x24\x39\x09\xfb\x65\xde\x3a\x05\x6c\xfd\xab\x16\xe4\xe0\xf3\x1c\xf4\x17\x5a\x54\x68\xb4\x17\xaa\x89\x0e\x29\xd5\x03\x13\x3c\xdd\xae\x02\x6c\xa9\x48\x38\x96\xb3\xab\xfe\x59\xd0\xf1\xa4\x43\x4e\x8b\x11\xcb\x41\x45\x54\xc8\x8f\xc6\x0e\xce\xc8\x84\xcd\x18\x10\x5c\x75\xd0\x96\x75\x04\x7e\xb5\xa0\xd5\x04\xac\xa0\xc3\xec\x7c\x0a\x69\xc7\xbb\x09\x4d\xcf\x8b\x51\x47\x94\x88\xe7\x1b\xe4\x5d\x6d\x09\x28\xb1\x86\x17\xf4\x86\x1c\x92\xde\x01\xfe\xf5\x0d\xd4\xc6\x1f\x8f\x1f\x9b\x20\x3e\xa2\xea\x89\x28\xfc\x68\xb7\x8c\x25\x32\x3c\x0d\x8e\xc2\x98\x20\x82\x16\x08\x66\x88\x7f\x8c\x58\xae\xf4\x42\xf5\x52\x60\x7f\x92\xca\xfc\x49\x4d\xb6\x7b\x2a\xa8\x49\xc1\x4f\x4f\xc9\x6f\xbf\x61\x63\x9e\xac\xbe\xbc\x55\xed\x36\xa8\x90\xba\xe2\x4d\x73\x23\x15\x8e\x27\xa2\xf9\x8f\xdd\x88\xa7\x51\x58\xb4\xc4\xec\xda\xa0\xa5\x13\xc5\xea\xdf\xae\xca\x01\x79\x88\xe6\x70\xb2\x54\xa0\x55\xa5\x98\x40\x2b\x74\x14\xe4\x28\x4c\xe3\x84\xc2\x45\xef\x60\x9c\x78\x5b\x98\xa5\x85\x97\x06\x10\xba\xae\xe4\x8c\x0f\x65\x7d\x65\x5f\xee\xb0\xbf\x72\xb7\x09\x61\x43\xb9\xaa\x12\x4e\xb2\x14\x6d\xcb\xf0\xb0\xe2\x33\x76\x7e\xa0\xcc\x04\xa5\x64\xa5\x3c\x60\x78\x88\xd5\x8e\x19\x91\x77\xc4\xf2\xbf\x4e\xa4\x4c\xc0\xea\xca\xd8\xc6\x69\x1a\xa3\x00\x10\xbc\x2b\x4b\x1d\x40\x41\xa7\x7d\x30\x51\xa6\xe7\x2b\xfa\x94\x3b\xf2\x0f\x77\x9d\xd4\x3e\xbd\x70\x7f\x77\xa3\x84\xd1\xb4\x90\xc0\x7d\x99\x84\x54\x2d\x9d\x1e\x99\xb8\x24\x81\x54\xd8\x2b\x27\x3a\x53\x97\xc0\x8e\xce\x8a\x65\x8b\xd5\xce\x69\xf1\x72\x5a\x70\x6c\x5d\x61\x41\xcb\x19\xa0\x5e\x66\x67\x93\x8b\x2a\xdc\x31\x7d\x3d\x26\xc1\x38\x0f\x0e\xbc\x3d\xac\x45\x3a\x5d\x51\x6f\x29\xa1\x49\x4e\x71\x8a\xc8\x40\x38\x33\x45\x02\xea\xcc\x75\xd6\xd8\x54\x7d\x77\x64\x76\x3f\x08\xb0\x44\x9b\x5d\xb8\x16\xaa\x5b\x36\x8d\xc9\xac\xad\xca\x7c\x12\xdf\x6e\x57\x61\x26\x5e\x6d\x18\x8b\x31\x0a\x73\xda\xd5\x38\xdd\x70\xb0\x5c\x04\xc2\xe4\x5c\xb3\x4e\x14\x48\x16\x1a\x0f\x15\x4b\xcf\xe7\x3d\x57\xe0\x16\xb2\x08\x29\x40\xdc\x9c\x35\x46\x1a\xcf\x18\x22\x8d\xe7\x19\xe1\x35\x2b\x66\x9c\xfa\xbb\x9e\xc0\xd5\x6d\xcd\x35\x2b\x1a\xe6\x7c\xcd\x8a\x39\x27\xbc\x10\xa5\xdb\x59\x90\xd4\xed\xcc\x49\xeb\x76\xd6\xc4\xee\x4f\x40\xec\xae\x59\x4d\xc3\xf7\x42\xeb\x96\x64\x22\xf0\x48\x34\x1f\xad\x59\x04\x2f\x8c\xe3\xd7\x69\xfc\x03\xcb\x0b\x9a\x56\x30\x3f\x1d\x92\xd2\xeb\xc2\x3d\x64\xe6\xf8\x58\x19\xc3\xab\x86\xd8\x8c\xcb\xde\x29\xac\xc3\xa5\xdf\x7e\x33\xc4\xa8\xb4\x07\x7e\x1b\x4e\xbf\x07\xfe\xd2\xe7\xb4\xf8\x80\x9f\x5a\x62\x56\x1d\x55\x5d\x85\x6d\xec\x20\x9b\xaf\x2c\xe1\xe6\xe1\x7d\xad\x07\x01\xb4\x02\x7d\xe1\x9b\xc0\xb2\xdb\xa8\x7a\x94\x9c\xe0\x2c\x2e\xe8\x4d\x5f\x25\xb6\x97\x6a\x42\x69\x8f\xa4\x37\x02\x3f\xb6\x2a\x28\x1d\x92\x00\x96\x3b\xc4\xe8\x54\x31\x7a\xd5\xc4\x0f\xb5\x3e\x62\xc5\xa4\x27\x22\xfc\xb6\x21\x2c\xff\xcc\xd3\x6a\x07\x4d\xe2\x38\x69\x9e\x56\x7a\x69\x12\x2f\x4d\xdb\x69\x8d\x9b\xa6\xf8\x4f\xbf\xcc\xa4\x47\xe7\xa9\xf1\xd7\x84\x62\xa7\x4d\xf7\x7c\xd8\xd0\xce\x07\xbb\x8e\xbc\x59\x0d\xac\x2c\xa8\x80\xc1\x3b\xe6\xd4\x67\x1a\x2a\x20\x81\x3f\x38\xf5\xae\x6e\x0f\x0e\x6f\xe9\x53\xfb\x40\x96\x21\xfc\x2e\xb1\xc8\x86\x43\x4d\x8f\x86\x81\x9f\x35\x17\xda\x6c\xb6\xdd\xe2\xd8\x9d\xb1\x2c\xe6\x3f\x7a\x6a\x1c\x48\x01\x81\x16\x71\x20\x85\x3d\xc5\x1f\xce\x96\x81\x53\x28\xae\xa4\xf5\x27\x4b\xcf\xad\x5f\xe8\x6d\x8a\xab\x64\xfe\x92\x30\xb0\x30\xe2\x0f\x39\x7f\xf8\x53\x4c\x54\xbb\x98\x92\x86\x30\xb7\x75\xde\x48\xc6\xd4\xa6\xec\x8d\x34\x33\x0e\xae\x51\xb3\x96\x0f\x9a\x23\x69\x2f\xbf\xea\x2a\x40\xcb\x70\x95\x88\x59\x06\xab\xc2\xcc\x52\xbf\x65\xc4\xd3\xe2\x5e\x17\xca\xa1\x27\xce\x05\x22\x41\xdd\xc2\x12\x2a\xf7\xeb\x5d\x19\xc7\x2c\x55\xca\x23\xff\xa4\xdf\x76\xb0\x76\x5b\x37\xe7\xb9\x38\x8a\xff\xcc\xf5\x95\x17\x61\x41\xed\x0b\x67\xd1\x9d\x27\x3e\x65\xea\x38\x9f\x3e\x39\xbf\x16\x74\x8e\x8c\x96\x71\x8c\x94\x36\x20\x62\x19\xc2\x42\x6a\x11\x65\x59\xd0\x2e\xa5\x4d\x34\x8b\xe4\xfc\x5c\x60\xf2\x9e\xa7\x61\xdd\xc4\x49\x95\x03\x9e\xe4\x38\xfd\xba\x62\x0f\x86\xce\xdd\x36\xf4\xd8\x78\x67\xac\x70\xc9\xd9\xd2\x1d\x1e\xd3\x83\x12\xe0\xad\x57\x72\xeb\xf7\xba\xd0\x9c\x6b\x66\x5d\x93\xd2\xd1\x36\x72\x29\x77\x5c\xf2\x8b\x54\xff\xb9\x5b\x64\xff\xb2\xb8\x73\x35\x2f\xc5\x9f\x08\xfe\xe2\x23\xfc\x90\x88\xac\xb8\x89\x83\x8d\xdb\x56\x29\xf8\xb7\x2d\xed\xd4\x42\xb9\x2a\x33\x76\x49\x9f\x1c\x5b\x75\xa9\xe2\xd6\x2b\x51\xd2\xec\x06\xbd\x09\x06\xe5\x32\xb2\x69\xfb\x19\xa2\xf8\xff\x6e\x5e\x84\x69\x1c\x66\x90\x1b\x76\xa9\x84\x7b\x1b\x04\x44\xed\x1f\x50\x3b\xa0\xb2\x8d\x9a\x2c\x7c\x6a\x6a\xc1\xc6\xad\x25\x48\x3c\x28\x19\x99\x3f\x5f\x07\xbe\x5c\x07\xbe\x7c\xa0\x81\x2f\x6d\x77\xe3\x6a\x55\x49\x09\xb2\xa9\x71\x0d\xf4\x87\x8b\xac\x39\xa2\xc9\x84\x66\xb5\x93\xf8\x3c\x56\xc5\xbf\x77\x7b\xdc\xdf\x81\x1d\x33\x64\x0c\xbb\x2e\xe4\x0d\x55\x84\x83\x99\xba\x65\x3f\x0d\xf9\x22\xc6\x92\x18\x49\x71\x86\xf9\x68\xeb\x44\x47\x70\x84\xa7\x0e\x8d\x2e\x06\x1c\x12\x98\xc4\x34\xcd\xe1\xd5\x91\xf2\x54\xbe\x34\xee\x6a\xaa\xf9\x61\x44\x71\xd6\x24\xa2\x49\xa2\x8c\x2e\xf3\x07\x60\x60\x79\x7f\x09\xd4\x1e\x8c\x8d\xe3\x02\x46\x6b\x9f\xc3\x36\xf1\x4f\x65\x75\x68\x59\x01\x2a\x4b\x63\x19\xd8\x8f\x9d\x83\x65\x3a\x2c\xad\x6b\x1d\x91\x4e\xc7\x34\x63\xd1\x22\xa9\x0c\x55\x6c\x50\x19\x44\xd5\x46\x30\x30\x3e\xa4\x89\x15\xe7\x52\x02\x35\x5b\x5f\xcc\x4f\x1e\x04\x79\xba\x8f\x80\xb9\x03\x9e\xc5\x34\xfb\x8e\x17\x05\x1f\xf7\x49\xb0\x3d\xb9\x26\x39\x4f\x58\x4c\x02\xf2\x58\x2a\x0a\x26\x61\x42\x8b\x82\x76\x05\x6d\xed\x26\xa0\x21\x60\x97\x2c\x36\xcf\x34\x3b\x9a\x6b\x42\x87\x6e\xb0\x5a\xbd\xce\x55\xb1\x5f\x33\x14\xe0\xc8\x2f\x7e\x48\xd9\x8c\x5f\x6d\x66\xf4\x92\x66\x39\x0d\xc8\xd6\x16\x89\xc2\x94\x0c\x28\x89\x6f\xd2\x70\x2c\xcd\x62\xb4\x9f\x0e\x09\x0b\x92\x4d\x53\xb4\x88\xb9\xd1\xb4\xcf\x1e\xc9\x88\x86\x35\xe1\x78\xa5\x42\x44\x07\x90\xe9\x9a\x8f\x6f\x69\xcc\xa6\x63\x35\xc2\xaa\xc4\xa2\x62\x64\xbf\xf0\xec\x22\xcc\xf8\x34\xc5\x93\xfc\x81\xf3\xa4\x60\x13\x0d\x2e\x90\x85\xe5\xf9\x54\xca\xf5\xe5\x78\x24\x86\xbc\x52\xbc\x82\x17\xa3\xb7\x32\xfe\xed\x16\xd9\x41\xd5\x99\xb5\x3f\x5e\x80\xdc\x67\xcd\x00\x73\xb4\xb0\x2b\xb5\x73\x6a\xd6\xf3\x26\x6d\xad\x6e\xcc\xd3\x20\xb8\x53\x4f\xf3\x05\x82\x13\xeb\xd6\xdc\x56\x8e\xe4\xb1\xa9\x58\xc1\xa0\x47\xb6\x77\x26\xae\x83\xc9\x90\xf3\xc2\x76\x2d\x71\x4f\x40\x29\x25\xac\x3e\x56\x1f\xc4\xcd\x7a\x44\x93\x44\x45\xc1\x8b\x90\xdd\xa8\x8c\x70\x78\xe0\x44\xa6\xbb\x7b\x54\xc2\x59\xc1\x0f\xe5\x29\xd3\xdf\xe5\xef\x8e\xbb\x20\xfa\xb3\xfc\x6d\x07\x3d\xc4\xcb\xc8\x0e\x7a\xe8\x08\xd1\x97\x0d\x14\x58\x2b\xd1\xb5\xa4\xbe\x72\xb0\xe2\x4f\x39\x30\x57\xe6\xfb\x51\xc7\x8e\x43\xee\xe6\x50\x2d\x7d\x17\x7e\xeb\xb5\x3e\xb2\xa6\xa1\x94\x4c\xa8\x5f\x8a\x5c\xe3\x2f\xe2\x80\xea\x8f\xa0\x8a\xb1\x95\x45\x36\x14\x76\xfd\xe8\x11\xfe\xd1\x15\xc4\x84\xbc\x20\x41\x31\x0a\x48\x9f\x04\x45\x1c\x68\x45\xce\xb2\x01\x09\x57\x13\x7a\x50\xed\xbc\x42\x89\xa5\xc2\x05\x9e\xe8\x8d\x20\x8f\xb1\xba\x7c\x43\x75\xa3\x70\xc2\x8a\x30\x61\xff\xa5\xdf\xb3\x2c\x2f\x7e\x10\x37\x43\xd6\x6e\x49\xf0\xf6\xc7\x8e\xc6\xb5\xaf\x40\x43\x2b\x6e\x2f\xb1\x6a\x4e\xa9\xba\xf3\x96\x0b\x65\xe8\xd2\xcd\xaa\x0e\x97\x6b\x57\x6c\x69\xa7\x6a\x9f\x97\x6b\x0e\xe9\x4c\xa9\x41\x2c\xf6\x82\x23\xde\x31\x15\xe0\x91\x7b\x5a\xef\x14\xf1\xcf\x12\x3d\x62\x7c\x33\x4d\xf7\xee\x1c\xdf\x6c\xa9\x88\x63\x2b\xe6\xa3\xbc\xd6\xe7\xe1\x02\xfd\x10\x68\x7f\x84\x47\xd4\xdc\x41\xa8\x7e\x0f\x71\x87\x94\x66\xf0\x8f\xf6\xc8\x99\x77\x0d\xcc\xfd\xb9\x82\x48\x3d\xe6\x06\x5e\xcd\x81\xf3\x62\xe3\x18\x6a\x52\xa1\x54\xd0\xa7\x51\x6b\x15\x0c\x27\xa7\x13\x61\x08\xa6\xcc\xb4\x22\x39\x01\x45\x96\x6c\xc1\x8f\x91\x7a\x6a\xda\x59\x2d\xf5\x59\x4a\xc3\x60\x29\x13\xf4\x68\x02\x72\xdb\x6e\xe9\x5f\xf7\x13\xf7\x66\xbb\xf7\xb0\xe2\xde\xdc\xa7\x80\x7b\x9a\xd5\xc9\x1a\x77\xf6\x1d\xa8\x46\xb9\xf6\x34\xa3\x26\xa9\xd1\xe5\x79\x43\x8a\x9b\x9d\x3d\x1f\xb0\x31\xf9\x11\x82\x7c\x9e\x98\x14\x5f\x7f\xfd\xff\xb3\xf7\xae\xe9\x6d\x23\x49\xa2\xe8\x7f\xaf\x22\xcc\xe9\xb2\x00\x09\xa2\x48\x4a\xb2\x65\xc9\xb4\xc6\x25\xdb\xdd\x9e\x63\x97\x3d\x7e\x54\x57\x0f\x9b\x23\x81\x44\x52\x42\x89\x04\x58\x00\x28\x91\x65\xeb\xfb\x66\x21\xe7\x2e\xe3\x6e\xe0\x2e\x65\x56\x72\xbf\x8c\xc8\x27\x5e\x22\xf5\x70\x57\x9f\x33\x35\xd3\x16\x98\x8f\xc8\xc8\xc8\x88\xc8\xc8\xcc\xc8\xc8\x07\x7a\xff\x09\x36\xd5\x33\x21\xd6\xbe\xcf\xfa\x96\x3a\x79\xe0\x78\xd7\x1a\x0e\x6b\x53\x3f\x3b\x5b\xe3\x8c\x1c\x70\x2e\x6e\xef\x36\x77\xda\xd0\x7e\xdc\x6c\x3d\x1d\x6f\xee\x34\x77\xf7\xf8\x3f\x4f\x41\x7d\xbd\x6d\xef\xc0\x6e\x73\x77\xbc\xf9\x18\xf0\xff\x7e\xe7\xbc\x2e\x88\xf5\xbf\xd8\x62\x10\xfb\x49\xf0\x22\x49\xe2\xcb\xb7\x6c\x64\xf9\x98\x16\x32\xcd\xb8\xf0\xcb\x9b\x38\x6a\x40\x6c\x6f\x0a\xc3\x51\x89\xf7\x5a\x18\x2d\x07\x0f\xca\x50\x22\xf7\x2c\xce\x2d\x5a\x9c\x0b\xe5\xdc\x92\xba\x56\x58\x2c\x42\xa3\x3c\x28\x56\xa1\x66\xe1\x40\xb1\xdd\xfe\x1f\xe9\xfd\x1f\xe9\xbd\x73\xe9\xdd\xe3\xb2\xda\x7e\xdc\xdc\xde\x19\x2b\x89\xdd\x34\x64\xb7\x05\xbb\xcd\x27\xbb\xe3\xc7\xf0\x78\xb3\x4e\x76\x3f\x0a\xdf\xb8\x72\xe1\xc5\xdc\xef\x2f\xbd\x12\xa9\x6b\xc5\xf7\xa3\x70\x53\x2e\x26\xde\x4c\x80\x3f\x0a\x4f\xda\x9c\x04\x77\x6e\x25\xc1\xe8\x8b\xcd\x06\xf1\x2c\x1a\x56\x49\xc7\x6e\x47\x06\x5f\x4f\x49\xbe\x2b\xca\x6d\xef\x09\x87\x05\x78\x95\x24\x71\x02\x13\x96\xa6\xfe\x29\xde\xb8\x4f\x33\x3f\xca\xd2\xa6\x64\xa9\xd7\x5f\x7e\x3a\x3a\x7e\xf5\xf1\xe3\xfb\x8f\xc7\x9f\x5f\xfd\xf2\x99\x93\xe1\xd5\x7c\xca\x86\xb8\x6f\xaa\x46\x7b\xed\x40\x71\xea\x11\x0e\x61\x0a\x3e\x64\x67\x49\x9c\x65\x63\x16\x68\xa6\xc8\xce\xfc\x0c\xe2\x08\x77\x5f\x2f\xe2\x73\x96\xc2\x09\xcf\x3b\x01\x3f\xa3\xa7\xa2\x62\xde\xb7\x29\x4b\x38\x24\x76\xc1\x92\x05\x9c\x5c\xfa\x61\x76\x62\x5f\xab\xa4\xe3\xaa\x22\xf8\x61\x3c\xc1\x87\xa6\x30\xca\xcc\xc9\xd0\x8f\x86\x6c\x7c\xc2\x41\x4d\x58\x76\x16\xd3\x71\x0e\x26\x42\xc0\xe8\x15\x1c\xd1\x3c\xc7\x66\xe8\x53\x00\x29\x3f\xe2\x3d\x3b\x19\x8d\x67\xe9\xd9\x89\xae\xc9\xc1\x84\x93\x09\x0b\x42\x3f\x63\xaa\x03\xb8\xd5\xd8\x84\x0f\x49\x7c\x11\x06\x0c\x4e\x28\x80\x62\x7a\xc2\x9b\x0a\xa3\x20\x1c\xfa\x19\x83\xcb\x33\x86\x5b\x60\xd4\x18\x07\x94\x9e\xc5\xb3\x71\x00\x03\x26\xc0\xe0\x25\x4c\x7c\xf1\x8a\xf9\x74\x3e\x10\x05\x5b\x71\x02\x59\xe2\x87\x63\xfe\x9b\x05\xa7\x4c\x86\x45\x20\x8a\x70\x30\xd2\x7b\x1c\xe9\x21\xbb\x92\x2a\x98\xea\x99\x2f\x7c\xe4\x43\x5d\xcd\xe3\xb2\xc3\xb1\x95\xa7\x0f\x08\xa9\x40\xcc\x26\x7c\x9a\x0d\x52\xf6\xdb\x8c\x45\x19\x70\x7b\x33\x95\x87\x15\x25\x84\x17\xe2\x2c\x80\x25\x2c\xe5\x32\x21\xd0\xc5\xc6\x0b\x74\xe6\x4a\x8b\x97\x5d\x5f\xff\x29\xce\xd8\xfe\x3a\x9d\xc4\x88\xee\x9f\xe0\x20\x9c\xc8\xde\x9f\x88\xb8\x94\x29\xf8\x09\x53\xc7\x35\xaa\xbf\x38\x32\x36\x19\x4b\xe9\x26\x9d\x56\x89\xff\x46\x15\x7d\x41\x68\x9a\x86\x13\xae\x75\xb3\x33\x3f\x22\xd6\x0c\x66\x74\x96\xa6\x86\x41\x8d\x81\xe8\x0f\xef\x05\x65\x84\x29\x9c\xb4\x44\x4f\x54\xbf\x78\x22\xae\x50\x8c\x0e\x28\x9a\xf0\xdc\x80\x8d\x58\xc2\x57\x17\xb0\x0e\xb3\x28\x0b\xc7\x92\xea\x11\x9b\x67\x90\x85\xc3\x73\x0f\xd2\x70\x12\x8e\xfd\x84\xe7\x9c\x68\x17\xf3\x13\xc9\xf8\xaa\x9f\x23\x8e\x80\x44\xec\x13\x63\xd0\x7b\xe9\x5f\x84\x01\x1c\xc5\xc9\xc0\x1f\x9e\xc5\x6b\x9c\xa0\x59\x38\x1c\xb3\xbe\x73\x96\x65\xd3\x74\x7f\x6b\x6b\x98\xa6\x9b\xdc\x48\x38\xc7\x8d\xdc\x2d\xa1\x6f\xc2\xe8\x74\x53\x90\x8a\x7f\xb2\xf9\x74\xec\x87\x11\x0b\x36\xd9\xdc\x9f\x4c\xc7\x2c\xdd\x72\x79\x1b\xa3\x98\x6b\xa8\xcc\x0f\xc7\x29\xc6\xa4\x42\xc4\x83\x70\x34\x62\x09\x8b\x86\x2c\x85\x01\xcb\x2e\x19\x8b\xe0\xe4\xb8\x29\x29\x2f\x28\x74\xdc\x94\xaa\x4d\x61\xfc\xaf\x69\xe6\x67\xe1\x10\x3f\x27\x6c\x32\x60\xc9\xfb\x11\x1c\x53\x4e\xc8\x07\xa3\xd5\x6c\x37\x5b\xf8\x9b\x8b\xd9\x69\x9c\x2c\xe0\xb5\x31\x8a\xff\x3a\xf5\x13\x7f\x02\x5f\x65\xda\x15\x8e\x31\xca\x8a\x56\x48\xb1\x62\x81\xa6\x59\x87\xae\x87\x5c\x41\x8f\x8f\x65\xb7\xd5\xc7\x5a\x94\xc8\xe9\x6a\x6a\x23\x13\x86\xa5\x48\xb2\xd8\x02\x49\x0a\xf9\x0a\x7a\x82\x99\xbb\x5f\xaf\x08\xac\x64\x6e\x75\xb1\x5b\xd7\xe1\xab\x6f\xe6\x47\xba\x52\x53\x70\x52\x97\x0b\x41\x9f\x17\x85\x4f\xe2\x56\x39\x72\x2c\x67\xce\x9c\x2a\x29\x11\x81\x6b\xda\x90\xd2\xb3\x44\x23\x75\x82\x46\xad\x90\x6a\x48\xcd\x61\xf8\x28\x92\x88\xad\x2f\xcb\x94\x0f\x56\x15\xcc\x25\xd8\x61\x6b\x0b\x5e\xe0\xd6\x3c\x9b\x0f\x59\x9a\x86\x17\x5c\x0b\xcf\xa6\x81\x9f\x49\x89\x94\x67\x66\x70\x79\x16\x8e\x19\xa4\xc3\x24\x1e\x73\xe4\x10\xda\xaf\xff\x3e\x63\xc9\xc2\xb9\x0c\xa3\x20\xbe\x74\x9b\x71\xe4\xac\x51\x81\x35\x0f\x34\x37\x3a\x08\x90\x7d\x88\xe5\x8d\xfe\x76\xab\x85\xef\xcf\x48\x14\xde\x90\xda\x3f\x49\x58\xc4\x2e\x3f\xc7\xe7\x2c\x3a\xa1\xe8\x34\x78\x8c\x3b\x0e\x87\xe7\x7c\xde\x8a\x32\x2e\xcb\x23\xdc\xf7\x83\xc1\x2c\xc3\xf8\x66\x39\x55\x42\xd3\xdb\x2e\x4c\xc2\x68\x96\xb1\x14\x91\xc4\x83\x0a\x45\x8d\xae\x89\x98\x6e\xd0\x83\xed\x16\xff\x8f\x9b\x70\x6b\x72\x00\xd6\xc4\xce\x07\x9a\x67\xba\xbb\xe2\x9c\x9f\xfa\x8b\xe8\xad\x79\xba\x05\xb3\x63\x47\x34\x31\x5a\x83\xaa\x51\xb1\x15\x77\x19\x31\xa7\xf1\x14\xbd\x84\x4d\xf8\x4d\x9a\x6d\xb1\x99\xad\x07\x86\x15\x20\xfa\xc4\x53\x3c\xe0\x22\xe6\x49\x29\xd0\x47\x62\x92\x7f\xbb\xca\x07\x13\x28\xa0\x1d\xe1\x46\xc9\xb8\xdb\x6d\xdc\xf1\x42\x09\x7f\x68\xee\xc8\xc9\x63\x1b\xde\xe8\x25\xb2\xdb\xe7\xc5\x94\xa1\xd9\xe3\xe4\x8c\x1b\x71\xa1\x86\x00\x4a\x0b\xca\x91\x88\x49\x40\x1a\xaf\x35\xf1\xb9\x06\x61\xa4\xa4\xf8\x10\x1e\x3e\xcc\x09\x2b\xec\xcb\x4a\xe4\x57\x6b\xf4\x41\x8f\x5f\x15\x0c\x55\x78\x5f\xd5\x93\x68\x8a\x59\x57\x2a\x4e\x8b\x9c\x84\xab\xc2\x50\x61\x40\x74\x5c\x9b\xf8\xf3\xbf\xfa\x61\xb6\xb6\x4f\xc5\x29\xd1\xe0\x25\xf9\x89\xe1\x14\x70\x2f\x9f\xcc\xd4\xa6\xb0\x52\xf1\xb6\x0f\x8d\x22\x5f\x4c\xe6\xec\xdc\xed\xff\x71\x7d\xfd\x67\x72\x7d\x4d\xd8\xe8\x80\xab\x00\xb8\x64\xfe\xf9\x3f\x7b\x50\xdb\xff\xab\xbc\x42\xef\xda\xa5\xc7\x70\x52\xf1\x07\x69\x3c\x9e\x71\x7d\x2e\xf2\x64\xfc\xcf\x8e\xa7\xbc\x1f\x84\xdf\x83\x4c\xb0\x22\x6d\xae\x14\x81\xd4\xd5\x20\xc6\xe3\xa3\x33\x3f\x3a\x65\xc2\x21\xc8\x23\xa8\x96\x1b\xc6\x30\x1e\xc7\xc9\x8b\xe1\x10\xdd\xd3\x94\x2f\x86\x3f\x3c\x3f\x45\x3f\x9a\x23\x9e\xbd\x9f\xf3\x40\x22\x63\xcd\x4f\x16\xcd\x17\x9d\xfc\x7b\xdb\xe3\x38\xf9\x90\x84\x13\x3f\x59\x2c\x0d\x6e\x4a\xe5\x7b\xbb\xad\x56\x3f\xef\xf6\xb1\xca\x9b\xe9\xb4\x44\x8c\x93\x4f\xe2\xc2\x1d\x6f\x9e\x77\xfb\x9a\x28\x37\xb9\x73\x45\x41\xf8\x65\xab\x48\x87\xb0\xe5\x1d\x46\x71\xb9\x68\x1e\xb7\xac\x7c\x1e\xbb\x7a\x9b\x45\x27\xd5\x7f\x46\x87\x4d\xeb\x11\x63\xf2\xde\x1c\xc7\x89\xb2\x94\xfd\x81\xdc\x26\x88\x13\x2b\xac\x61\x5c\x1d\x11\xe9\xfa\xe0\x4b\x2a\xcc\x11\xca\xc8\x5a\xff\xfa\x80\x48\x82\x9f\xeb\x8a\x52\xef\xfa\xd5\x31\x43\x0b\x5d\xa5\xa1\x11\x5d\x45\xf7\x54\x61\x8e\xea\x9e\xd6\x47\xf1\x32\xa3\x44\xad\x2e\x15\xab\xcb\x05\x37\x76\xf2\x27\x7c\xcb\xef\xc0\x9a\xee\x5e\x4a\xb0\xf3\x4f\xd9\xde\xd5\x53\xb3\x9c\x89\xb4\xc7\xd5\x38\x56\x1e\x95\x48\x51\xab\x36\xa6\x68\xaf\x32\x52\x77\x4c\x98\x34\xd0\x05\x3d\xfa\xf8\x72\x14\xb1\x4c\x33\x8c\x02\x36\x7f\x3f\x72\xb0\xbc\x8b\xfe\x19\x9b\xed\x83\xdb\xf8\x28\x2d\x7b\xed\xb0\xb7\x86\x6d\x2e\xeb\x3f\x44\x08\xf6\xbd\x7c\xcf\xca\x3d\x63\xd4\xac\x89\xde\x5b\x36\x29\x0e\x0d\xe2\x55\xdf\x18\x95\xb7\x42\xf1\x82\xa6\x98\x2f\x0a\xb3\x05\x82\x16\xc6\xf3\xb2\xdb\xdd\x74\xf7\xad\xe4\xd6\x1f\x8e\xbc\x14\x15\x42\xfe\x4a\x39\xd8\x28\x4e\xfb\xfe\x3e\x36\xff\x07\x79\x82\x70\x7e\xab\x57\x92\x7f\x08\x85\xbb\x6c\x87\xe4\xbd\xf4\x6b\xf5\xea\x77\xb0\x35\x72\xf8\x9b\x1e\x1d\x77\xe0\x3d\xa1\xd8\x5f\x3a\x50\xa8\x84\x7b\xf2\xa1\xd8\xb9\xfd\x19\xce\x87\xaa\x95\xc9\x1e\x5f\xff\xa0\x7e\x45\xc5\xf0\x92\xa5\xc3\xca\xa2\x7c\x01\x58\x58\x93\x97\xae\xd6\x9e\x76\x5c\x38\x34\xee\xa9\x0b\x63\x07\xce\xd9\xc2\xa3\xc5\xaf\xb5\x2e\x08\x3e\x34\x47\x76\x19\x8d\x8d\xd3\x96\x35\xb8\xfe\x81\xfd\x25\xa0\x52\x7a\x4f\xc4\x07\xc4\x0c\xe3\x42\x31\xe5\x1e\xa8\x99\xd6\xa4\xf4\xee\x12\x94\x46\xa2\x6e\x6d\x41\xa7\xd5\xec\xf0\xff\x6b\xc1\x3b\x3f\x3b\x6b\x8e\xe3\xd3\xf6\xd4\x99\xbb\x45\x0a\xe9\x6c\xf8\xf6\x4d\xa3\x2f\x2b\x98\x84\x70\xe6\xd0\x85\x8d\xb9\x0b\xcf\x61\xb3\xcd\x36\xf7\xf8\x02\x6d\x0e\xcf\x00\xbf\x0f\x61\x0e\x9b\x30\x87\x75\x98\xa3\x5f\xfc\xbe\x82\xec\xb4\x61\x03\xe6\x6e\x79\x9f\x1e\xd7\xf5\x49\x8f\x9e\xc0\xf7\xf8\x78\x85\x5d\x92\x33\x3f\x99\xc4\xd1\x02\xc2\x09\xaf\x0b\xeb\x5b\xe4\x58\x7e\x2c\x24\xe0\xf8\xcd\xbb\x0f\xef\x3f\x7e\x7e\xf5\xf2\xf8\xdd\xfb\x97\x5f\xde\xbe\x3a\x6e\x1d\x07\xdb\xc7\x53\x3f\x3b\x3b\x3e\xae\x7a\x83\xe8\x89\x7b\x23\xc8\xed\xe3\x63\x79\x90\x58\x09\xfb\xf1\xe3\x9b\xc1\xee\x1c\x1f\x0f\x67\xc9\x05\x3b\x1e\x87\x11\xf3\x93\x4a\xf8\xed\xed\x9d\x9b\x35\xb0\x7d\x8c\xa0\x2b\x01\x77\x5a\xad\x9b\x01\xde\x39\x3e\x9e\xc6\x61\x0d\x49\x3a\x2d\xdc\x58\xc1\xff\x0c\xf8\x52\x39\x12\x4f\xf0\x76\x4a\xf8\xa4\xd7\xf0\x1b\x5c\xbe\x34\x53\x69\x93\x73\xde\xc2\x06\xaf\xc7\x8b\x03\x81\x2d\xce\xd1\xeb\x5b\x7d\x69\x4f\xce\xdb\x32\xc8\xa5\x48\x58\x70\x70\x62\x6f\x74\x49\x1e\x90\x80\x65\x57\xd6\xb7\xfa\xae\xd3\x52\x8b\xfe\x45\x7b\x69\x04\x07\x08\x67\x61\x22\xa8\x0d\xd9\x3b\x40\x2a\x4b\x66\xcc\xd5\x56\xb6\xbc\x14\x6a\xf6\x1f\xd9\xaf\x16\xe1\x02\x8f\x96\x34\xa5\x2e\x47\xcc\xb2\xe9\x4c\x36\x61\x87\x89\xf5\x13\xe6\x3b\x81\x9f\xf9\x66\x98\xd8\x50\x47\x7c\xf8\x55\x7f\x9e\xeb\x4f\x0c\x86\xe6\x67\xbe\x0c\xed\xaa\x32\x8c\x80\x2c\x82\x64\x7c\x20\x95\xbb\xa4\xd8\xf6\x98\x8d\x46\x66\x10\x8d\x79\xeb\x77\x8e\x1b\xbb\x14\xa1\x61\x23\x23\xf2\xc9\xa2\x90\x27\xc2\x42\xd1\xb5\x09\x41\x3b\xea\x99\xab\x3b\x8a\xa4\x71\xa8\xa1\x65\x06\xcd\xd0\x53\x92\x8e\xfc\x17\x8d\x97\x6b\x85\xb8\x0d\x29\x5c\x6d\x08\xcf\xba\x10\x1d\xc0\xc6\x46\xa8\xc3\x7c\x70\xa4\x1e\x3a\x21\x3c\x03\x7c\x95\x5e\x90\xc0\x09\x04\xb9\x7a\x61\xdf\x83\xd0\xc3\x6f\xd7\x45\xaf\x5e\x49\x25\x33\x54\x08\x87\x62\x50\xef\x61\x59\x19\x80\x5f\xa1\x0b\xa1\x19\x36\x84\x3a\xdf\xe4\x23\xfa\x29\xf3\x93\xcc\x71\x4b\x72\x39\xb7\x14\x72\x0b\x11\xc8\xac\xe2\xaf\xa2\x60\x79\x50\x82\x48\xe7\x1c\x39\xd8\x84\xf6\x01\x9c\xc3\xf3\x2e\xfc\x7a\x00\x9b\x9b\xe7\xf9\x78\x28\x02\x10\x0a\x9e\x33\x6f\xfd\xde\x3b\xef\x7b\x7c\xc4\x7b\xe7\x7d\x0b\xe4\xd5\x6a\x88\x71\x0a\xe4\xf2\xae\x1e\xd8\x7f\x4d\x12\x9b\x58\x71\x24\xc2\x3e\x4e\xc9\x2d\x27\xd0\x83\x45\x68\x51\xce\xc2\xca\xd1\x6d\xd8\xbd\x69\xc3\x21\x6c\xcc\xdb\x66\x51\xd8\x17\xf0\x3d\xae\x8d\x0e\x61\x63\x91\xcf\xa6\x46\xf2\x51\xed\x34\xc3\x13\x43\xbb\xca\xb0\x31\xe5\xda\x13\x72\x05\x1b\xd0\x68\x70\xbb\x83\x84\x5d\xd4\xb7\x04\x9e\x13\x4f\x45\x5e\x13\xb0\xae\x15\x11\x35\x67\x95\xea\x34\xb7\xa9\x98\x5d\xac\x8c\x9b\x24\x83\xf8\xaf\x2b\xfd\xa0\xa5\xc8\xea\xb0\x72\x1c\x9f\xe6\xdc\xd8\x4c\x76\x8e\x73\x98\xe5\x03\x49\xf3\x15\x25\x4e\x37\xe2\x38\xee\x18\x05\xa9\x21\xeb\xf3\x15\xe7\x31\xec\xdf\x85\xa2\xde\x38\x76\x3d\x63\x6e\x42\x5c\x69\x14\x0f\x68\x27\x56\xe1\xdf\xfa\x03\x77\xa0\x1a\xeb\xf6\xca\x58\xe3\x24\x2a\xf5\x2d\x1c\xd2\x9f\xfd\xef\xdd\x91\x76\xae\x23\x8b\x55\xfb\xb1\xf8\x7e\xd4\x5f\x14\xd9\x67\x91\x1f\x88\xc5\xca\xec\xf3\x1d\x3b\x50\x8d\xf5\xca\xec\xb3\xf8\x43\xb0\xcf\x22\xcf\x3e\x5c\xad\xfd\xd2\x82\xae\xf9\xfb\x6f\xd6\x90\x14\xfa\x26\x75\x68\x73\xee\xcc\x5b\x6e\x73\xe1\x2c\x5a\x6e\x09\xd4\xbf\xb5\x57\x84\xd2\x2e\x83\xf2\xcb\xf2\x50\xda\xe5\xb8\x68\xf3\x75\xa5\xf1\xd2\xd5\xee\x7d\x84\x1e\x3e\x34\x87\x48\x1d\x85\x5b\xbd\x90\x46\xf1\x4a\x7d\x50\x96\xb4\xba\x10\x0d\x0f\x05\xff\x3d\x7a\x04\x4e\xce\x62\x94\xd3\x93\x81\x0b\x66\xe4\x31\x51\x46\xfb\x4a\xb8\x98\xac\xaf\x41\x58\xb3\x38\xec\xe7\x8d\x58\x5d\xd0\xa4\x90\x48\xd5\x78\x19\xec\x70\x40\xae\xf3\xf9\x6d\x81\x27\xf7\xbf\x2d\x20\x96\x8f\xce\x20\x8c\xf0\xba\xad\xbd\x90\x54\x40\x9a\x81\x53\xda\x5e\xc3\x6f\x78\x16\xa3\xcb\x5e\x21\x25\x3e\xfa\x41\xe8\x8f\xdf\xe2\x72\xe7\x00\x37\xa7\x4b\x5a\x0e\x27\x93\x19\x5e\xb0\x72\x2b\x17\xb1\x03\x5c\xc4\x1a\x20\x6f\xb8\xb3\xb1\xdc\xee\x00\x6d\xc7\x15\x3a\x60\x63\x50\xbb\x32\xa9\x5b\xe1\x59\x4e\x00\x02\x16\x59\x5c\x74\xd5\xec\x2c\x4c\x9b\xc7\x52\x04\x04\x27\x5f\x3d\x78\x40\x25\x9b\x53\xf9\x6e\x85\x0c\x9a\x27\x97\x0e\xfb\x45\x75\x63\x80\xca\x2f\x31\xf0\x8c\x5b\x18\xdd\x4b\xd4\x54\xa6\x39\xd6\x53\xab\x88\x6b\x6a\xe6\x56\x1b\xaa\xee\xf5\x6d\x5a\x4b\x05\xac\x87\x26\xba\x51\xcb\xf7\x20\x29\xab\x49\xa6\x7c\x02\xeb\xb4\xef\x96\x86\x91\xc3\x97\x02\x3c\x61\x13\x53\x86\x71\xea\xf8\xae\x30\x66\xad\x68\x0c\xe6\xe0\xaa\x01\x31\xed\xf0\x44\xe4\x99\x41\x1a\x94\x14\xf3\xf5\xae\x59\x59\xeb\x25\x65\x37\x53\xfd\xc2\xe0\x6a\x4d\x90\x08\xde\xbe\x2a\x6a\x82\xda\xa7\xe9\xef\x56\x13\x2c\x21\x8f\xb4\xa9\xc4\x47\xe9\x76\xe2\x48\xdb\x21\xd4\xed\x4a\xa1\xdc\x6e\xdf\x7c\xbf\x71\x89\x2d\xbb\x07\x06\x0b\xe8\x1e\x39\x63\xe3\x6c\x96\xf7\xb5\xa9\x47\x6b\xdc\xf4\xf1\x99\x26\x9e\x3a\xf7\x20\x60\x63\x96\x31\xfe\x7d\x80\x99\xbc\x3b\xb3\x14\x73\x17\x46\xee\x42\xd4\xbd\xc9\x94\x38\x74\x96\xd8\x0e\xc9\x51\x53\x6e\x8a\x59\x73\xf6\xb1\x8b\x33\x91\xe3\x0a\x2e\x2c\x4c\x46\xc4\x7d\x5b\xeb\x30\x8b\x30\x8a\x54\xf5\x6e\x23\xd2\x9e\x4a\x29\xda\x8a\x52\x82\x55\x4a\xf6\x1d\x65\x2b\x9a\xce\xcb\x18\x22\xb5\x8b\x58\x92\xb6\x95\x08\x43\x70\x8a\x0a\x9e\x43\x74\x2b\xa6\xe2\xda\xb0\x9d\x77\x23\x80\x37\xdc\xd1\x9d\x7b\xb0\xb0\xa8\xdb\x73\x16\xb8\xe9\xe1\x4a\x2d\xc8\x75\xde\x1c\x36\xc5\x29\xc7\x87\x37\xb0\x05\x1d\xbe\xce\x31\xb5\xe4\xdc\xed\x97\xf7\xbc\x53\x7b\x3b\xf8\x8f\x6d\x84\xa4\xe3\x70\xc8\xc8\xf0\xc0\x03\x7e\xfe\x53\x3e\x67\xa5\xa7\xd2\x26\x15\x2b\xf6\xbc\xf6\x66\xe5\xf7\x3e\x95\x39\x9e\xd4\x9e\xc9\xec\x89\xa1\xbb\x21\x37\x71\xf6\x09\x12\xff\xd2\x98\x62\xc5\x04\xe6\x41\x1a\xfe\xce\xcc\xbd\xe6\x44\x9e\x97\xa5\xbf\x25\x99\xc3\x73\x61\x6b\x19\xd4\x7b\x8d\x5f\x69\x9b\x36\x14\x76\x10\xe8\xcd\xf4\xe6\x24\xbe\x60\x9f\x63\x27\xf1\xa0\x95\xcb\xf1\x93\xa1\xd3\xf2\xa0\xe5\x41\x82\xff\x2e\xd5\xd2\x04\x5b\xca\xfc\x99\x6a\xea\xaa\x9c\xbb\x6b\xef\xde\xfd\x23\xe4\xfa\xd6\x23\xb1\xeb\x72\xf9\x2e\xa5\xee\xe6\x36\xac\x73\x2a\x6e\x26\x39\x1a\x73\x0d\xcb\xf3\xaf\xcb\xc3\xfa\xe5\xf9\x4b\x64\x57\x64\x5d\x83\x94\xc8\xae\x86\x5b\x9d\x53\x83\xcf\xe6\xf5\xd9\x55\x59\x15\x08\x0d\xc7\x71\xca\x3e\xf8\xd9\x99\x53\xc7\x6f\xb5\x3e\xf0\xb7\xe0\x37\x8a\x65\x15\x6d\xb7\x2c\x96\x68\xc3\x16\x6c\x8b\xb3\x19\xcc\x3d\xc6\xa7\x3a\xb0\xdc\x3a\x67\x92\xef\xc3\xa7\x8b\x32\x3e\x15\xf8\x18\x27\x47\x73\xe8\xe2\xa4\x84\x39\xa5\x0c\xdc\xf2\x60\x73\x51\x3e\x2c\xf3\xa2\xe6\x10\x39\x2d\x3e\x41\x96\x0f\x65\x49\xa5\xe5\x86\xb1\xd6\xdd\xe3\x0f\x39\x35\x70\x20\xe7\x3e\x74\xa1\xd5\xdc\x7b\xda\xda\x6b\x6f\xb7\x9e\xb6\x77\x3b\x4f\x3b\x7b\xbb\x9d\xce\x5e\x5b\x38\x6b\x9f\x6b\x8d\x12\x46\xf5\x46\x55\x99\x4e\x87\x2d\x68\xb7\xb8\xfa\x51\x20\x9e\xc0\xfa\xea\x53\x03\x81\x11\x18\xcd\x57\xc6\xc8\xd2\xfd\x02\xa5\x75\x38\x17\xc7\x97\xe7\x9c\x19\xf5\x5a\xf0\x56\x10\xbf\x97\xfc\x94\xe8\xf9\x75\x38\xf7\x73\xa2\x73\x3e\x47\xc5\xa4\x0f\x62\x79\x1a\x97\xa7\xa4\x52\x96\x2a\x54\xdc\x5c\x4b\x8c\x7a\x23\x34\x84\x2e\xb4\xf1\x10\x15\x76\x73\x67\xa8\x3c\xdb\xaf\x3d\xfa\xae\xa4\xe5\x3a\x84\x7c\xca\xb2\x1e\xd6\x91\x9d\xa5\xa5\xba\xf5\x68\x87\xc9\x0b\xfa\x20\x2f\x87\x7d\x2a\xe6\x93\xa1\xa1\xde\x0b\x85\x86\xe8\xa2\xb3\x09\xbc\xf0\xc2\xc3\x3f\x73\xd8\x00\x9e\xbc\x30\xde\x39\x58\x55\x2f\xd4\x3a\x27\xfd\xd1\xcd\x89\xcb\x02\x9b\xe5\x38\x6c\xf3\xb2\x68\x5a\x24\x7c\xf9\x36\xf7\x60\xee\xc1\xa5\x07\x97\x75\xc4\xb9\x2f\x2f\x27\xb4\xed\x7f\x4b\xb2\x6d\x0b\xff\x6d\xf7\x7b\x4e\x6f\x9b\x85\xf9\xcd\x21\x94\xd6\x61\xdb\x2d\xb7\x75\x5b\xb4\x04\xeb\x54\xcc\x4d\xb2\xfa\xa2\x7a\xce\xab\x2b\xb2\x1c\xbf\xde\xd7\x0e\xb3\xdc\x37\xd9\x6c\x35\x85\x70\xa7\xb9\xc1\xe1\x9c\x24\x34\x32\xd7\x2c\x6a\xd2\x40\xb3\x45\x5a\x05\x5c\xab\x38\xe7\x22\xc2\x6c\x9b\x2b\xdd\xed\x7f\xa0\xce\xdd\x02\x4b\xe5\x72\x53\x2b\xd1\xdd\x00\xe9\x04\x95\x70\xe5\x6c\x94\x6b\x43\x17\xe6\x2d\xa3\x50\x5b\x16\x82\x0d\x53\x5f\xcf\xb9\x6d\xb6\x39\x6f\x1b\x25\x79\x0a\x1d\x7e\x15\xb8\x67\xce\xd9\xa7\xc2\xe2\x99\xb7\x3d\x10\x07\x53\xc5\xbc\x8e\x07\x8b\x0a\x9e\x43\xa5\xd8\x92\x5a\xb1\x25\xd4\x62\x4b\xea\xc5\x8a\xd6\xb0\x56\x5b\xd6\x6a\x8b\x5a\x6d\x59\xab\x02\x0f\xac\xd5\x91\xb5\x3a\xa2\x56\x47\xd6\xaa\xc7\x70\x43\x61\x48\x88\x09\x30\xf3\x7a\x0c\x37\x14\x86\x84\x98\xac\x55\x8f\xe1\x86\xc2\x90\x10\x93\xb5\xf2\x18\x2e\x27\x70\x7f\xc4\x8d\xdc\x23\x3f\x09\xc2\xc8\x1f\x1f\xf1\x1e\x04\x37\x35\x42\xa3\x38\x9e\xd6\x9c\xac\xec\xde\xdc\x69\x54\xa0\x57\x03\xfc\x49\x6e\x23\xd7\xee\x91\x16\xf2\x8c\x45\x69\x18\x47\xd6\x51\x8b\x3a\xac\x33\x0e\xe8\x28\x8b\x2b\x26\x87\x73\x89\xaa\xb6\x05\x8f\x71\x83\xd4\x86\x5f\x77\x2a\xb3\x04\xc9\x2a\xdc\x00\xd5\xf1\xcc\xcd\x41\x5c\x7f\x52\x43\x4e\x2d\xf4\xd9\xd6\x9f\x1d\xfd\xb9\xad\x3f\x77\xf4\xe7\x2e\x9e\xbd\x4b\x28\x0b\x0d\x65\xa1\xa1\x2c\x34\x94\x85\x86\xb2\xd0\x50\x16\xbb\xd0\x85\x9f\xfc\x9f\x0e\x0c\x50\x78\x80\x83\xfe\x7a\xd7\x1f\x19\xa5\x97\x61\x36\x3c\x03\xc7\xa8\xa9\x8d\xd2\xa1\x9f\x32\x68\x9b\xa1\xc5\xad\xf1\x96\x6a\x54\xf6\xd2\x53\x98\x1a\xfe\x61\x76\x8d\x9c\x80\xd3\x7f\x83\x84\xf9\xe7\x07\x39\x5f\x35\x6c\xbb\x53\xdd\xb6\x50\x30\xf7\xd7\xf6\x76\xa1\x6d\x3a\x18\xbb\xbe\x45\xab\xdc\x8e\x2a\xb7\x53\x5b\x6e\x57\x95\xdb\xad\x47\xef\xaa\xea\x3c\x4f\x6f\x62\x93\xa5\xb9\xc1\x13\x70\x17\xfb\x60\xc9\xa1\x6e\xed\xe7\x38\xa8\x7d\x60\xb2\xf0\xdc\x33\x59\x71\x71\x60\x63\x27\x99\xc5\x86\xd0\x39\xa8\xe5\x99\x1d\x0b\x2c\xff\xb5\x70\xcb\xe0\x76\xf2\x70\xb7\x0f\x0c\x31\x32\x40\xec\x96\x60\xa6\x6e\x78\x2f\xe5\xb1\xa1\x34\xa5\x3c\xfd\xa1\x26\xc9\x87\x19\x5f\x88\xa5\xa5\x9d\xd9\xc6\x55\x95\x3a\xf0\xca\x14\x83\x67\xaa\x88\xf9\x41\x95\x12\xf0\xca\xd4\x81\x67\x2a\x86\x85\x3e\x82\xbd\xbb\xe3\x26\xc7\x38\xcd\x4d\xb3\x78\xe2\x18\x0a\xdf\x3c\xca\x95\x84\xaa\x39\xcc\xbd\x6e\x0a\x51\xc7\xba\x12\x56\x53\xe4\x98\x67\x7b\xd6\x7c\x03\xda\x37\x02\x71\xdb\xb0\x40\x99\xa7\x70\x12\xe4\xc1\x83\x2b\xd7\xc1\x40\x33\x05\x3b\xe2\x3b\x9c\x47\xdd\xd8\x8e\x78\x3f\x65\xd1\x8d\x8f\x84\x97\x9d\xec\x0b\x73\x3d\x6f\xf5\xfe\x66\x7a\x0e\xfd\x06\xde\x17\x5c\xd3\x5b\xb3\xd9\x75\x4e\x17\xa2\x82\x98\x15\x97\xf4\xb7\xa8\x9e\xc5\x97\x9b\xa4\x6f\x31\x07\x63\x90\x1d\x8d\xf9\xb7\x6f\xd6\xcf\x87\xdd\x2e\xb4\x30\x52\xbd\x09\xb8\xdb\xe5\x6b\xe2\xeb\x66\x38\x8b\x1e\x38\x36\x2a\xa1\xd2\x2d\xe4\x7e\xa6\x91\xe5\xa6\x8a\x55\x14\x3f\xf6\xea\xb0\xd6\x2a\x30\xb4\xa5\x0b\xfb\xb5\x13\x91\x59\xb4\x0c\x8f\xed\x3c\x1e\x3b\x18\xd7\x05\x2f\x03\xe3\xf5\xf6\xd5\x26\x9a\xd6\xff\x4c\x34\xf7\x31\xd1\x94\xeb\xaf\x7f\xec\x34\xb3\xfd\x87\x0c\x0d\x1e\xa6\xaf\x7e\x9b\xf9\xe3\xca\x38\x4b\x8f\xf3\x25\xeb\xa2\x1f\x49\x60\xf9\xe0\x4c\xea\x0e\x52\xd3\x4f\xd3\xf0\x34\xb2\xee\x85\x3a\x99\x9f\x9c\x32\x3e\x9a\xa5\x1b\xe4\x79\x17\x9e\x03\x08\x37\x36\x78\x61\xdc\xa9\x8c\x67\x09\xba\x21\xa8\x52\xbd\xb0\x7f\xa0\xe1\x9c\xb3\x05\x84\x91\x28\xc6\x2b\x71\x15\x2b\x50\xd1\x3e\x0b\x67\x7e\xfa\xfe\x32\x92\x34\xa4\x5b\xcb\x54\x05\xef\xda\xba\xbc\x22\x21\x29\xef\xd8\x52\x2e\xfe\x3a\x80\x2b\xfc\x3f\x19\x9f\x13\xcb\x1d\xc0\x95\x8a\xb2\x84\x37\x7b\x8f\xc6\x7e\x6a\xc5\x0c\x42\xd7\x0a\xf5\xcb\x1a\xc5\x90\xa5\x82\x26\x1e\xc8\xd0\x16\x36\x69\xe8\x02\x96\x88\x3d\x51\x42\x96\x80\xa5\xc3\x24\x9c\x66\x3a\x80\x05\x92\x45\x27\x37\x19\x06\xf3\x17\xef\xf5\x94\xa7\xf3\x31\xf2\xc7\x29\xb3\xea\x0d\xe3\x68\x14\x9e\xce\x64\x4d\x8c\x0f\x87\x44\x6d\x20\x7b\x35\x38\xb5\x75\x71\xd7\xac\x7a\x99\x84\x99\x55\xad\x9c\x83\x65\xcf\x8d\x9a\x78\xdf\xd9\x80\x7a\x60\x12\x5c\x53\xf4\x28\x8e\xd2\x2c\x99\x0d\xb3\x38\x41\xc2\x65\xf1\x07\x7a\xe7\x88\x82\x5c\x7e\x90\xa4\xe4\xe8\xea\x6c\xb7\x48\x7c\x03\x90\xe6\x12\x13\xa4\x4b\x7d\xb6\xe0\xd6\x41\xb1\x51\x38\xd0\x4f\x3d\xab\x12\x07\x18\x71\xca\xb1\x63\x73\xc9\xa0\x1f\x1d\x0f\x8e\x33\x36\x99\xfe\x73\xbf\x57\xfb\x22\x0a\x27\x7e\xc6\xde\xf9\x91\x7f\x8a\xd7\x12\x4b\x63\xae\x3d\x6d\x55\x54\xa8\x6b\xcc\x2e\xa9\x00\x7c\x98\x25\xec\x23\x8b\x82\x9a\xd6\xb6\x4b\x0a\xd7\xb5\xa4\x4b\x69\x1d\xe7\xa7\xd5\x2f\x8d\x6e\xef\xe8\x16\x48\x76\xbe\x60\xf4\xcb\x8a\xe2\x7b\xed\x4e\x69\xf1\xda\x00\x6d\x46\x39\x55\x79\x96\x85\xe3\x2a\x0e\x21\x94\xee\x3d\x78\x9a\x6e\xa0\xe2\x41\x32\xde\x04\x2a\xd8\x54\xea\x2d\x92\x7d\x7c\x5d\xeb\xc0\xd4\x78\x21\x22\x20\x65\x97\xd7\x50\xb1\x73\x42\x17\x9e\x77\xa1\xe5\xe2\x3a\x24\x8c\xa4\x3a\x7a\xb8\x94\x92\x47\x04\x42\xd7\xac\x2c\xf4\x3c\xde\x75\x8c\x07\xbf\xa2\xde\x2c\x2a\x77\xb3\x77\x59\xcc\xe5\x78\x36\xe1\xba\x8d\x6e\xe9\xfa\x49\x22\x71\x25\xf7\xb8\x30\xd5\x19\x45\x65\xee\x81\x9f\x20\xd3\xa9\x42\x42\xa7\xbb\x72\x06\x4c\xf2\x4a\x9e\x57\x20\x1c\xfd\x24\xb1\x71\xe4\x59\x07\xea\x4e\xab\x4c\x25\x3c\x46\x49\x3c\x41\x24\x50\x83\x9a\x9d\xc8\x29\x61\x39\x32\x3a\xcc\x84\xa4\xbc\x31\x16\xe5\xfa\x5b\x57\xfd\x2a\x4d\x0e\xfc\xe3\x81\x9e\x5b\xc4\x9b\xef\x60\xce\x26\x32\x4d\x4e\x13\xf4\x1b\xae\x5c\xa3\x33\x7c\x40\xac\x28\x17\xba\xdb\xf1\xe0\xd7\xdc\xb8\xa0\xea\x3c\xf2\xc7\x63\x7c\x81\xd0\x09\xf1\x02\x0e\x9f\xd2\x0d\xb5\x2b\x3b\xf6\x50\x65\x83\xfc\x88\x47\x56\x41\xb4\x01\x4a\xe2\x9b\x36\x8e\xfc\x28\x8a\x29\x7c\x37\xf8\x14\xe0\x07\xfc\xd4\x08\xdc\xde\x28\x52\x7b\x1a\xa7\x69\x38\x18\x33\xa3\x01\x0a\xd8\xeb\xa4\x6c\x3c\xf2\x10\x98\x42\x8d\x27\xd9\xad\x7f\x64\x22\xda\xb3\x40\x81\x1b\xe8\x70\xe6\xa7\xd1\x5a\x06\x03\xc6\x22\x08\xa3\x30\x0b\xfd\x71\xc8\xad\xf3\x4d\x48\x67\x53\x96\x38\xae\x55\x82\xb7\xc0\x02\x42\x4d\x59\xb0\xe2\x52\x90\xb8\xed\x84\xbf\xf1\xc2\x13\xc9\x2f\xde\xaa\x2d\xe4\xe9\x5e\xc2\x21\x25\xef\x03\xc7\x38\x37\x18\xe2\x25\xd0\xd4\x49\x67\x83\x23\x9a\xdb\x10\x2d\xfc\x96\x5d\x15\xc0\x75\x06\x85\x53\xd2\xf7\xad\x1e\x3d\xca\x67\xd2\xc5\xf7\x8a\xa1\xf9\xc4\xcb\x72\xcb\x3a\x61\x29\x9a\xf9\x93\x59\x9a\x01\xa3\x47\x7b\x07\x8c\x6e\x1c\xe1\xf3\xbc\xb2\x09\x0f\xa3\x08\x37\x60\x03\x0a\xb8\x20\xa9\x24\xf6\xd6\xee\x85\x90\x03\x11\x67\xd1\x40\xd0\x42\xd7\xb4\x24\xbe\xd2\x2b\x00\x34\xf2\xfb\x5a\x50\x34\x71\x4c\x59\xa1\xf8\x01\x39\xc1\x28\x13\x1e\xce\x66\xd2\x34\x31\x88\x2b\xf0\x4b\x19\xd7\xbd\x84\xc2\xfb\x11\x1c\x96\xa7\x57\x0c\x90\xc6\xad\x79\x7c\x8c\x3d\xc1\x4d\x25\x5d\x44\xc5\xcb\x14\x73\xb1\x0c\x34\x64\x4c\xab\xf9\x17\xf9\x78\x11\xb4\x6b\xf8\x44\x45\x86\x8e\x65\x21\x1f\x1f\xd9\xef\x42\x6a\x26\x12\x6d\x78\x60\x14\xb1\x03\x3b\x88\x12\xa5\x8f\x81\x42\x41\x37\xd0\x2a\x5b\xd4\x91\xe1\x0e\x70\x1e\x45\xd1\xea\xd6\x49\x2c\xd5\x95\x28\x19\xd4\xf9\xf6\x4d\x52\xf8\xd4\xa6\xb0\x6c\xc7\xa5\x49\x88\x00\xe4\x10\x2d\x20\xf1\xa7\xa9\x08\xd7\x78\x4c\x47\x06\xfa\x6d\x0e\xdc\x39\x4a\x5f\x0c\xb3\x90\x6e\xfa\xe9\xd2\x4d\x99\xac\x0b\xfa\x59\x96\x84\x83\x59\xc6\x44\x64\x39\xb3\xb4\x95\xa7\xab\xf0\x49\x23\x57\x92\x27\xe9\x02\x59\x9c\xcb\xce\x62\x9d\x99\x66\x4c\xa3\xfd\x27\x19\x2d\x8f\x99\xc8\x1b\xcf\xa7\x9a\xa5\x64\x32\x5f\xec\xe2\xa0\x61\xc7\xcf\xfc\x28\x18\x33\x0c\x5d\x45\x41\x4c\x15\x49\x0a\x39\xcd\x41\x18\x05\x0e\x66\x8a\x6d\x30\x2a\x38\xc4\x5c\x19\x0e\xb4\x90\x66\x57\x53\x1b\x73\x0f\x25\x31\xf5\x26\x17\x55\xc5\x90\xdc\xdc\x66\x91\xe1\xe3\xbe\x5e\x89\xad\x01\xfe\xdf\xd6\x16\xaf\xad\xba\x18\x9a\x33\x03\xbd\x83\x81\xdc\x20\x9e\x26\xe0\xda\xc7\xa7\x21\x83\x94\x65\x22\x12\x5d\x16\xc3\x5a\x16\xaf\x09\x88\x86\xa6\xd4\x94\xeb\x96\xc5\xe3\xae\xc1\x31\x8b\x39\x8e\xf2\x38\x49\x7c\xc8\x10\x7a\xd5\xcc\x6e\x12\xd3\x08\xcc\x40\x83\xcc\xd5\x1d\xff\x90\xd6\xcb\x75\x74\xc2\xc2\xbd\x56\xbf\x29\xe2\xed\x09\xb0\x34\xd9\x73\xb0\x9c\xcd\xec\xe8\x22\x37\xee\xb7\xe9\xf8\x46\xad\x73\xe0\x2a\x55\x8f\xd7\xaa\x54\xd0\x87\x85\x55\x2d\x8a\xf6\x6c\xc9\x3b\x2c\x98\x5c\x5f\xaf\x3c\xbb\x8c\x07\xd4\x7f\x0b\x55\x9b\x48\x4b\x31\xa2\xc6\x51\xf6\x8c\x97\x56\x7b\x61\xe6\x06\x85\x56\xac\x3d\x02\x7d\xce\x16\xfb\xc6\x2b\x8e\x2f\xc3\xe0\x5d\x3c\x8b\xe4\x9b\xe0\x62\xd6\x32\xdf\x86\xb1\xcb\x39\xb6\x5f\xe3\xb1\xd4\x61\x65\x2a\xcc\x56\x62\x55\xfa\x0b\x60\xe8\x47\x3f\xb2\xd3\x30\xd2\xa5\x64\x8a\x54\x14\x62\x6f\x73\xc2\x31\xa0\xeb\xdb\x32\x8a\x7d\x41\x96\xb9\x92\x7e\x28\xeb\x9b\xec\x43\xa4\x2a\x48\x08\x02\x4e\x66\xd1\x0b\x29\xb4\x8e\xee\x8a\xe1\xe9\x78\x25\x83\x56\xe6\xe8\xf7\xd7\x70\x3c\xfe\xc8\x86\x2c\xbc\xc0\x71\x4f\xaf\xa3\x63\xbe\xbc\x13\xb1\x79\xf6\x41\x47\x3b\x95\x84\x35\x28\xa7\x4a\x5c\x47\x3c\x5d\x50\x26\x9a\x05\xf3\xf3\x84\x2e\x5d\x31\x4b\x80\x78\x70\xe7\x23\xd3\x06\x80\xae\x94\xcb\xd3\x23\x85\xa3\xb1\xc2\x00\x54\x68\x62\x31\x32\x29\xcb\x3e\x71\x21\x70\x4a\xe4\xfd\x06\xf2\xa7\xf1\xcf\x62\x2e\x87\xe6\x6f\xad\x3a\xdc\x82\xee\x28\x60\x8d\x4e\xbd\xd4\x75\x19\x75\xb9\xc7\x35\xba\x07\x6b\xb2\xef\xfc\x5b\xf6\x6b\xad\x6f\x71\x2b\xda\x51\x72\xf7\x55\x1b\x51\x9a\xf3\xf8\x84\x9b\x43\x56\x1e\x13\xd9\x12\x92\x4b\x2e\xa3\x63\x4d\x0f\xc2\xf4\x73\x12\x9e\x9e\xb2\x04\x85\xea\x61\x19\x7c\x2e\x4e\x25\x0d\x58\xdd\x21\xe1\x14\x5b\x35\xf9\x11\x14\xe9\xcd\x34\x8b\xa7\x8e\x5b\x3a\xfc\x42\xd7\xc5\xd3\x7f\xfb\xa4\xc4\xb0\xc8\x09\x76\x7e\x09\x28\xde\x23\x61\xda\x98\x1d\xfb\xf6\xad\xc0\xc8\x87\x06\x6d\xb1\xc6\x3e\x58\xb4\x3f\xb0\xb4\x43\x09\x0f\xde\xed\x0c\xe0\x1e\x54\x6b\x23\xb9\xe1\x8e\xb0\x14\xd6\x9e\x41\x1d\x0e\x89\xe0\x19\x11\xc9\xf8\xd8\xc9\xc7\xf5\x79\x0b\x4b\xaa\xb2\x2f\xd1\x64\x99\xd9\xc0\x28\x6a\x4c\x08\x39\x1d\x4d\x5b\xcd\x85\x71\x9e\x45\x9f\x66\x83\x74\x98\x84\x83\xa2\xb4\x1b\x79\x75\xac\xb2\x1a\xab\xd9\x99\x2a\x68\xdc\x3d\xf0\x61\x05\x85\x93\x59\x64\x54\xa8\xa0\xad\x5d\xc8\x0c\x80\x0d\xe6\xa2\x41\x3a\x8d\x1d\x94\x30\x7d\x99\x25\x2f\x6c\xf9\xa2\x15\x0f\x10\xcc\x12\xb2\x52\x65\xb6\x4c\x30\x0b\xa9\xad\x50\x2a\x42\x3f\xcd\x02\x03\x31\xf9\x50\xfe\x20\x3f\xeb\xc4\x9a\x95\x5f\x45\x81\x2a\x67\x27\x57\x54\xc0\x53\xfd\xb2\x2a\x98\x61\x51\x20\xe5\x29\x2a\x5f\xc5\xd7\x36\xf7\x5b\xb5\x9a\x45\x0a\x01\xd7\xb0\x14\xad\x1a\xfb\x24\xce\x41\x5e\xe1\x0f\xd7\xa1\x44\xd7\x53\x54\x12\x87\xa6\xc6\xaa\xc2\xb5\xc7\x20\x8c\xfc\xf1\xa7\x3c\x1a\x6a\x78\x4b\xb2\x9d\x82\x71\xdb\xc9\x33\x17\x5f\x8f\xe7\xea\x1c\x68\xb3\xf1\x41\x29\xeb\xfb\x49\xe6\xf4\xf2\xc4\xf2\x68\x9c\xbc\x32\x3c\xcc\x3e\xda\xe3\xd2\xaf\xd6\x1a\xc9\x2c\xfa\x94\xb1\xe9\x12\x5c\x6d\x15\xab\xe4\xeb\xed\x32\xbe\x96\x2b\xcd\xd2\x35\xe6\x2a\xac\x77\x1d\x27\x19\xc8\x60\x2b\x7f\x42\xc2\xd3\x5a\xc6\xb2\x67\x69\x17\x4e\x2d\x34\xa9\x30\xad\x76\xcc\x72\x22\xe3\x4f\x86\x88\xc9\xb2\x65\x42\x26\xc0\x7e\x0e\x27\x06\x54\xa3\x72\xd7\x78\x4d\x07\x0e\xa1\x05\xfb\x85\x42\xda\xfe\x42\xcb\x24\x08\x24\x8e\x7a\x65\x2a\xd2\x1c\x7a\x9e\x70\x28\xac\xa1\x37\x19\x9b\x78\x80\x7b\xef\xf9\x90\x8d\x98\x88\xad\xe7\x22\x35\xca\xfb\xe3\x02\x90\x56\xb4\x57\xda\x6e\xc2\x43\x4b\xdd\x7d\xd9\x54\x69\xff\x01\x8e\x65\xfe\x9f\x94\xc2\x51\x35\x8a\x3a\xc7\x50\x4b\xc5\x8a\x39\x62\xad\x31\x3f\x65\x6b\x9c\x62\xb9\x92\x36\x40\x19\xdd\x5e\xb5\x5a\x18\x53\x50\xb3\x2f\x9d\x75\x98\x85\xa7\x2a\xd5\xae\x51\xd0\x7e\xaa\x86\x9d\xa3\x47\x8f\x08\x37\x4d\x18\x2f\xc5\x0d\x19\x1c\x83\xe7\xd0\xc2\x38\xfb\x9c\x23\x29\x65\x13\xda\x7d\x61\xbf\xf2\x92\x07\xb9\xea\x39\x24\x0d\xac\xf5\x1e\xd6\x39\x5b\xa4\x14\x20\xdc\xb4\x77\x8d\x35\xb9\x41\x51\xe3\xad\xfe\x6f\xdf\xac\x8c\x74\x9a\x84\xd1\xe9\x5a\x29\x83\xf4\xfa\x5c\xab\x0e\xfd\xcc\x29\x39\x52\x91\xdc\xe3\x7a\xd0\x23\x15\xd0\xb4\xe7\x40\x63\xd7\x66\xdb\xcb\x05\xda\x24\x9b\x47\x90\xa9\x6c\xac\xb2\x58\x04\xfd\xb7\x93\x25\xf7\xed\x43\x39\x1f\x52\xcf\xf6\xc5\x5f\x23\xeb\xca\x98\x0a\xfa\x6e\x25\xc7\xeb\x57\x7a\xe4\x1c\x34\xcb\xc2\x71\xf3\x94\x65\x9f\x55\xce\xcf\xfe\xd8\x75\x0c\x8e\x31\xd4\xaf\x98\x75\xec\xd1\x8c\xd8\xa5\x52\x38\xa6\x31\x68\xf7\x5e\xf4\xd6\xa2\x93\xf5\x8a\x90\xfa\xae\x5b\xe7\x2c\x3f\x64\x12\xab\xba\xd9\xa3\x39\x0a\xc7\x19\x4b\x1c\x22\x42\x18\xb0\x28\x0b\xb3\x45\xc9\x14\xa6\x5e\x42\xbd\x7e\x26\xab\xc5\x0f\xf7\xaa\x12\x16\xcc\x86\xcc\x91\xfa\xce\x83\x9e\xa9\xb6\x3d\xba\xb6\x34\xf1\xe7\x8e\xa1\x76\xc5\xfc\xe8\xf6\x5d\xde\xb7\x32\x1b\xa5\x5f\x63\x42\x9b\x06\x7b\xf5\x44\x58\x39\x09\xe2\x0a\x78\x19\xc3\x56\xf2\x54\xee\x18\x5d\x5b\x36\x85\x1d\x2c\x7c\x3c\xa8\x7e\x9a\x5c\xca\x0c\xcc\x6f\x1e\xd4\x6e\x2f\x8b\x77\xa6\x5f\xd7\x59\xa5\x98\xfa\xb9\xca\x34\xbd\xd6\xea\x5c\x7a\x6e\xbf\x95\x2d\x7a\x8d\xfd\x61\xec\x72\x97\xef\x6f\x13\xfd\xf5\xe0\x99\x63\x69\x9b\x6f\xc6\xc2\x07\xba\xa0\x44\x40\x2d\x86\xca\xb7\xc3\x5d\x7b\x75\x75\x8d\xd6\xae\xdf\x69\x5d\x42\xaf\xcb\xc5\x69\x71\x9d\x72\xb0\xcc\x26\x8f\xb9\x93\x0c\xcf\xa1\x5d\x06\xba\xcc\x58\xbc\x16\xf8\x05\xbd\xea\xdb\xbd\xc9\x72\x5c\xf0\x21\x5f\x91\x8b\x4f\xd3\x1a\x5c\x5a\x9d\x9b\x53\x6a\x16\xbb\xa5\x3a\x5d\xc0\x5d\xd6\x52\xb7\x74\x3d\x5f\xac\x7c\xad\xd0\xe7\xd6\xdc\xb4\x82\x09\x5f\x60\xa7\x0a\xd5\x55\x28\x27\x8c\x06\x7b\xdd\x6f\x2c\x8c\x94\x51\x51\xd1\xb0\x51\xb4\x6a\xa3\xa1\x00\xcc\x3e\x33\x30\x36\x1a\x56\xda\x31\xc4\x3f\xd6\xfc\x27\x59\xa9\x02\xd5\x04\xcf\x39\xab\x74\x3a\x66\x96\xee\x88\x77\x2a\xb7\xc4\xcd\xa3\x31\x2a\xaa\xd4\x46\xd9\xda\x46\x96\xa9\x53\xdb\xb2\xcc\x32\x8a\x5b\x96\xad\x54\xdd\xda\xb2\x16\x25\x8b\xca\xb7\xb0\xab\xdf\x29\xdd\x99\x56\xe7\x84\xa2\x4c\x41\x7f\xca\x63\x48\x91\x5f\xba\x71\x21\x33\xed\xf9\xa1\x70\x62\xd0\x29\xdd\xf2\x2e\x28\x7c\x59\xb8\x46\xe5\x17\xb6\xbc\x15\xfa\x76\x4e\x45\x3b\x1f\x99\x9c\x8f\x4a\xda\x12\x99\x56\xd5\xec\x4c\xbc\x89\x59\xe5\x52\x25\xe0\x78\xd0\x5b\x93\x8c\xb2\xe6\xc1\xda\x40\x6e\x31\xcb\x51\xc7\x77\xc8\xcc\x51\xe5\x09\x34\x78\xd6\x4e\x34\x3e\x74\xc4\xa6\x29\xff\xe0\x24\xe7\x7f\x8b\x1b\xd7\x36\x85\xb0\x92\xdd\xff\x5c\x21\xd1\xb5\xb5\xbe\xbd\x2b\x32\xe4\x42\xca\x7b\x87\x9e\x89\xcd\x23\xd1\x81\x26\xa6\x3b\xb2\x3f\xee\x81\xbd\x95\x93\xa9\xa3\x5c\xad\x73\x51\xdf\x8d\x65\x96\xeb\xe8\xf3\xb1\x66\x6e\x0d\xb3\xda\xa9\xa2\x74\x95\x11\x25\x1d\xdd\x7c\xf9\x06\xa4\x75\xd0\x24\xba\x97\x5f\x21\xe7\x60\x96\x4e\x58\xc3\x71\x1c\xb1\xa3\x38\xca\xfc\x30\x42\xe3\x40\x2b\x3f\x2b\x07\x7d\xde\xf1\xcb\x6c\x41\xba\x13\x52\x8e\xf2\x24\x50\x29\x45\xbd\x03\x85\xf2\x7f\xe2\x74\x43\x47\x0d\x3b\xbd\x6c\x39\x25\x97\xc7\x15\x30\x72\x6b\xee\xaf\x57\x7c\xbd\x5d\x56\xd4\x86\x6a\x3e\x88\x57\xc0\x42\x65\xe6\x17\xc7\x09\x2e\x6b\x91\x33\x88\xab\x90\x60\xe2\x3d\x38\x57\xd3\x2b\x37\x85\x92\xa4\x79\x65\x07\xc7\x56\x39\xb5\x9c\x52\x7c\x60\x69\x9e\x92\x57\xe6\x8c\x09\xa5\x60\xac\x70\x6c\x8b\xeb\x1d\x7a\xeb\x43\xf2\x4e\x3b\x3f\xb2\x71\x34\x5e\xa0\xa8\x94\x48\x0e\xcf\x33\x05\xa7\xc0\x74\x36\xf7\xd4\x57\x2f\xb2\xf8\x52\x6f\xee\xa9\x36\xe9\xf1\x3d\xf5\xd3\x7c\xf0\x05\x0a\x98\x4f\xfc\xa9\x6a\xd9\x33\x9c\x82\x30\xad\x74\xff\x20\x2f\x09\x58\xd0\x58\x7b\xbb\xe2\xd3\x34\x35\xfa\xd6\xdb\x81\xea\x74\xf2\x4a\x51\x42\xb9\x17\x29\x5f\xec\x66\x10\xa6\xd3\xb1\xbf\x10\x9c\xb8\xa6\x35\x9c\x2c\x60\x7a\x52\x73\x3c\x69\xfb\xc1\x70\x9b\x56\x84\x32\x5f\xbd\x2b\xcb\x16\xef\x7d\x95\xe5\xc9\x97\xeb\x38\x05\xb3\xf8\x5e\xc1\x5b\xf3\x44\x79\x4b\xf2\x59\x56\xf4\x77\xd1\x1e\x2d\x72\xb6\x79\x60\xee\xa5\x94\xd5\xa7\x37\xed\x78\x7d\x71\x16\x55\x5f\x48\x6e\xbc\xdc\xa0\xd3\x02\xd3\xd2\xaa\x9c\xcb\xa8\xcb\x38\xe7\x95\xc3\xf7\x93\xc4\x5f\xbc\x1f\x39\xa5\xc0\x8d\xc7\x54\x97\xe9\x70\xe1\x35\x55\xa9\x62\x2a\x47\xab\x50\xe3\x16\xa4\x90\xef\x24\xe2\x9e\x27\x4d\xff\x6c\x93\x26\x74\xfc\x8c\x67\x99\x91\x2c\x7f\x52\x38\x6e\x7a\x54\xb1\x96\x86\xc8\x0b\xc6\xc2\x63\x98\xa6\xc6\x5e\xa3\x13\xf8\xe9\x19\x5e\xa9\x73\x3d\xf1\x28\xbf\x3f\xc6\x5a\xba\x4c\xfd\x00\xac\xd1\x50\xae\x89\xc6\x6c\x1b\xa4\xbc\x2a\x47\x0e\x5f\x0c\xc5\x3a\x52\xbd\xdc\x88\x78\x51\x1c\xb0\xeb\x28\x20\x27\xff\xf2\x06\x06\x71\x8c\xfa\x4f\x1a\x52\xf5\xa5\x96\xed\x9e\x90\xc1\x80\x0d\xc3\x00\xbd\xa8\xc2\x4c\x98\xa9\x90\x30\xe1\x83\x00\x97\x61\x76\x26\xcf\x11\xc8\xb0\xa6\x29\xfb\xf2\x8c\x45\xb4\xb2\x15\x8b\xaa\x07\x05\x1b\x77\x69\x2c\x65\xcc\x8e\x1a\x3c\x8b\x16\x61\xcd\xb0\x5d\x19\x1a\x98\xd2\xcd\x07\xac\xe5\x11\xb6\x67\xa9\x9a\x76\xab\x85\x29\xa4\x81\xd7\xd6\xa4\xb2\xa4\xaf\x9c\x5e\xa3\x44\x29\x4f\x42\x2a\xac\x51\x44\xbf\x5b\x6b\xc4\x64\x8a\xd0\x17\xbd\x7e\xd9\x50\xa9\xc9\xcb\xce\xe0\x4b\xc1\xab\x72\xa2\x95\xd5\x10\xd1\xdf\xe1\xeb\x15\x92\x22\x63\x93\xa9\xeb\x72\xb3\x92\xa8\x72\xf0\xa0\xe4\xa9\x4f\xed\x6e\x93\xbb\x8a\x58\x1b\x8d\x77\xa9\x17\x36\xdf\x86\x69\x76\xe4\x0f\xcf\xaa\x6e\xb2\xb4\xb7\x9f\xba\x52\xa7\xf9\xc3\xf3\xa3\x31\x45\xfd\x2f\xbd\x85\xb3\xb3\x6d\x16\x7d\x49\x51\xbe\xab\xca\xee\x98\x65\xff\xcc\xaa\xee\x41\x3d\xd9\xd9\x35\x0b\xfe\xc5\xaf\xba\xd7\xf4\x64\xe7\xb1\x59\xf0\x53\x0d\xc4\x27\x14\x05\x0d\xdf\xaa\x3e\x42\x1b\x27\x05\x9f\xaa\xc1\x10\x69\x41\x4a\x9a\x2f\x46\xd3\x2c\x4e\x18\x9c\xb3\xc5\x26\x6e\x04\xc0\xd4\x0f\x93\xb4\xf9\x00\xe8\xa1\xeb\x69\x12\x5e\xf8\x19\xc3\x6f\xc3\x15\x9c\xf2\xfc\xc4\x9f\xc0\x57\xdc\xa4\xbe\x82\x1e\x8b\xb2\x24\x64\x69\x1f\x9f\xfb\xce\xc1\xc3\xb7\xd8\x79\xc3\xb9\xd7\xb1\x3f\x71\x94\x1c\x51\x53\x07\x5f\x0f\xfc\xcc\x57\x37\x7b\x8f\xf9\x2f\x74\xe2\x8e\xd8\xa5\x1e\x4e\x55\x4b\x5d\xe8\xc7\x70\x5d\xe2\xc1\x3b\xfe\x4d\x51\xcd\xb7\xe0\x45\x10\xc0\x84\x65\x67\x71\x80\x78\x9c\x60\xa3\x27\xcd\x07\xf8\xd7\xb8\x78\x33\x14\x43\xaf\xf9\xe0\x20\x5f\xa6\xb7\x46\xa1\xdd\xd7\xfa\xb2\x1c\x31\x41\xa1\x60\x93\xae\x07\xc9\xb1\x2f\xe6\x9f\xe1\x38\xcb\x21\x2f\xe6\xa7\xba\xfe\x27\x5e\xbf\xf8\x7a\x29\xd6\x28\xb9\xbd\x5b\x1b\xdc\xd8\x7a\x2a\x75\x1d\x9f\xd1\x0f\xf0\x96\xcf\x60\x16\x8e\xb3\xcd\x30\x12\x94\x82\x44\x5e\xdd\x48\x9b\x1c\x1e\xfa\x02\xcc\xa2\x21\xba\x87\x43\x17\x5e\x0b\xc0\x1a\xe3\x03\x03\x60\x16\xf3\x05\x42\x3c\xbe\x60\xf8\xdc\x7b\xc0\x86\xf1\x64\x1a\x8e\x59\x20\xef\xc1\xc6\x23\xa5\x3a\x6c\xf8\x9f\xe3\x4f\x38\x59\x8a\x95\x23\x36\xd7\xcc\x44\xa2\xc1\xd4\x71\x74\xc1\x38\x19\x4e\x78\xa9\x13\xde\x60\x98\xa5\x12\xfa\x30\x0e\x58\x29\x07\x0b\x8e\x95\xc8\x5f\x61\x1b\xc8\xaf\x8a\x23\x39\xa3\x12\xf0\x26\x56\x21\x8b\x3b\x85\xaf\x34\x89\x5f\xc1\x47\x91\xc0\x3b\x96\x6b\xcf\x60\xec\x2c\xfe\x84\x79\x38\x02\xc4\xd8\xe8\x28\xcc\xdb\x7b\xa8\x6e\x83\xa0\x34\x67\xc9\x42\xad\x12\x8c\xab\xa2\x92\x12\xe4\x7b\x8f\x60\xa4\x4b\xed\xd0\xc7\x78\x06\x0c\x75\x6c\x05\x08\x6a\x6a\x03\xd6\xd6\xaa\xaa\x5d\xe9\xf5\xc4\xda\x1a\xca\x4a\x81\xc5\x64\x2f\x4a\xb8\xac\x36\xa4\xf1\x52\x8a\xf9\x13\xab\xd5\xcb\xdb\xdb\x52\x81\xa2\x1d\xf5\x29\x9e\x54\xaa\xda\xc7\x52\x31\xa2\x8a\xa9\xd6\xa0\xdb\x18\x8f\xcc\x62\x53\xf4\xfd\x4a\x19\x0c\xc2\x6c\xe2\xa7\xe7\x29\xca\x02\x29\x2e\x9e\xe5\x27\x61\x6a\xb2\xe8\xd1\xfb\x77\x1f\x5e\x7c\x7c\x75\xfc\xe1\xc5\xc7\xcf\x6f\x5e\xbc\x3d\x7e\xfd\xf6\xc5\x9f\xa1\x0b\x22\x7a\x9f\xcc\xfd\xf2\xd3\xfb\x8f\x2f\x5f\x7d\x7c\xf5\x52\xe6\x77\x34\xe7\xbe\x80\x74\xca\x86\x21\x3e\x5d\x1f\xc0\x05\x4b\xf0\xbe\x4f\x3c\x82\x93\x81\x9f\xb2\x37\xe4\x3c\xf9\x92\xb1\xe9\x09\xa2\x82\x7d\x4f\xc9\x0e\x4a\x67\x53\x8c\x44\x30\x22\xfd\x3b\xf5\x13\x34\x8b\x02\xc6\xa6\x16\xb2\x35\x9c\x2f\x74\x35\x42\x45\xbe\xa7\x2f\x41\x08\x3f\x61\xcd\x92\xd2\xb8\xc5\x80\xa5\xe9\xab\xb6\x0e\xad\x17\xae\x24\x41\xb1\x9a\xfc\x1e\x8d\xfd\xd3\xb4\x09\x9f\x18\xb3\x7a\x4b\x3d\x9d\xf0\x69\x28\x60\x99\x1f\x8e\xd3\x66\xb9\xb4\x52\x6c\x83\xf0\x77\x81\x8d\x25\xb3\x32\x2b\x4f\x89\x12\x30\x8c\x37\xfa\xba\x4c\xf2\x03\x96\xb1\x64\x12\x46\x8c\x97\x09\x2f\xfc\x31\x8b\xb2\x94\x0f\x0e\x72\x84\x0d\x8f\xce\x46\xae\xc4\xac\xfa\x39\xf1\x87\xe7\x29\x5f\x45\xf0\x21\x65\x01\x9c\x20\x95\x4e\xf0\xe6\xc4\x09\xd2\xed\x44\x4c\xba\x69\x4e\xb1\x70\x93\x94\xf9\x91\xd6\x2c\x27\xdc\x58\x3b\xe1\xfa\x22\x93\x23\x94\x82\x9f\x98\x48\x79\xe4\x56\x7f\x82\xce\x88\x27\x39\xdd\x83\xfd\xc3\xb1\x4b\x1d\xac\x2d\x76\x89\x3c\x39\x10\x9e\x41\x49\x4f\x93\xc3\xa3\xbe\xe8\x69\x38\x4c\x3f\x08\x1e\xeb\xaa\x31\x7c\x54\x2a\x03\x72\x7b\xc4\x4f\x92\xb7\x74\x12\xd6\x25\xc4\x73\x2f\xcf\xc6\xd9\x99\xca\x47\x9c\xe4\x7d\xd1\x07\x42\x41\x6a\x00\x0f\xbb\x46\xe9\x47\x8f\xe0\xa1\xa3\xd1\x79\xf4\xc8\xc8\x7b\xae\x5b\x75\x73\xc1\x30\x84\xaf\x26\xe9\x3a\x6e\x09\xa4\xe9\x6c\xc2\x60\xb8\x18\x8e\xc3\xa1\x18\x54\x49\x59\x7f\xdc\x7c\xa0\xb6\x6a\x87\xe7\xe8\xeb\x89\x5f\x7c\x2a\x27\x3a\xa2\x26\x15\xf7\xe9\xb1\x04\x5e\x24\x91\x45\xb0\x3f\x79\x0c\x14\x2c\xd1\x5f\x89\x0c\x92\x97\x1c\x91\x60\x53\x05\xff\x4c\x58\x4a\xf6\xb0\x34\xd7\xd1\xda\x63\x78\xac\xe2\x14\x47\xc0\xd6\x33\x2e\xfa\xff\x5e\x6a\xbd\xba\xaf\x77\x2f\x91\xbe\x84\x6a\x2a\x7b\x23\xb8\x02\x3b\xa5\xb3\x04\xa7\xc8\xfe\x12\xdd\xde\x9c\x46\x5c\x3a\xa3\x38\xda\x24\xa4\xf5\xd2\x97\x13\xed\xf2\x2c\x1c\x33\x70\x36\x36\x28\xf3\x99\x31\x20\x46\x6c\x55\x3f\x49\x7e\x46\xc5\x2a\x58\x83\x5c\x7e\x0c\x47\xb4\x38\x3b\x93\x05\x10\x0b\x51\xc0\x7c\x48\x58\xb1\xad\x7d\x3a\x25\x14\x51\x80\x2e\xd2\x82\x49\x14\xd8\x43\x83\xdb\x1d\xd9\x86\xa7\xd0\x11\x5e\x62\x4a\x46\x04\x6d\x48\x14\x14\x90\x7d\x13\x88\xae\xaa\xc1\x09\x20\xb6\xbc\x11\x10\xf3\x66\x0b\x6d\x91\x0a\x6c\x1f\x9a\x1b\xcc\xf6\x59\xa0\x2c\x63\x6e\x20\xaa\xbb\xdf\x39\x6f\x08\xc5\x35\x8a\xdd\xc1\x0e\xc4\x77\x25\x37\x39\x3e\xb2\xe1\x2c\x49\xc3\x0b\x36\x5e\x48\x9a\x49\xfd\xe2\xa4\xb3\x74\xc8\xa6\x59\x38\xa0\x7b\x5c\x78\x43\x96\x74\xdb\x38\x9c\x84\x59\xea\x36\x55\x07\x38\x47\xe6\xfc\x3c\xd4\x1c\x2d\x19\x48\xd9\x04\x9a\x44\x71\x76\xf6\x26\xef\x90\x07\xfa\x6a\x05\x4d\xdd\x08\xdc\x2c\xfb\xe8\x91\x55\x98\xff\xe7\x68\x56\x22\xb9\xa2\x1f\xdf\xbe\x69\x5d\x56\x3a\x46\xa5\xea\x8f\xc6\xc8\xcd\x23\x65\xb8\x03\xb2\xa8\x39\x9d\xa5\x67\x8e\xc2\xe9\xc0\x2a\x69\xbe\x7a\x7c\xe5\xda\x07\x26\x65\x03\x53\x1e\x23\x51\x5f\x26\x7b\xe8\x98\x07\x9d\x15\x3d\xb5\x30\xb8\x71\xaf\x15\x14\x03\xed\xa5\xb8\xe9\x4a\xea\x0c\xbd\x20\x32\x54\x64\x3e\x47\xeb\x19\x7d\x7a\x30\x1b\x67\xe5\x36\xa7\x31\x7b\x95\x98\x9d\xb5\x4f\x30\x2c\x65\x76\xbe\xf3\xa7\x75\x66\x67\xa7\xf5\x44\xae\xb2\x85\x1e\xe5\xcb\xc7\x2a\xc3\x73\x27\x57\xb6\x66\xf5\xfe\x78\x57\x2f\xca\xad\x75\x79\x24\x0c\xaa\xf2\x85\xf9\x2c\x0a\x7f\x9b\x31\xc3\x00\x59\x75\x59\x4e\x35\x69\x55\x2e\x66\xbc\xaa\xc5\xb8\xe8\x84\x43\xc5\x0c\x3b\xa0\x30\x51\x8d\xe5\x24\x2e\x20\xea\xf7\x32\x5b\xb0\x2f\x91\x35\xa6\xf6\xb2\x95\xbc\x1c\x88\x83\xb2\x19\xc4\xbe\x99\x89\xd5\xfd\x20\x10\x98\x89\x89\x41\x46\x5c\x2e\x5f\xe4\x8b\xce\xf0\x75\xbe\xf8\x34\x56\xd7\x3e\x8e\x69\x49\x06\x17\x74\x3e\xf1\xeb\xb1\x3f\x28\xab\x2f\x56\xef\x7a\xd4\x4b\x17\xe8\x22\xbb\x84\x8d\x6b\x5f\x0c\xc8\xad\xd1\x91\x59\xce\x18\x37\x2f\xc3\x11\xf8\x70\x82\x63\x77\x22\x56\x29\xdc\x74\x3e\x39\x67\x8b\x13\x60\xf3\x30\xcd\x6a\xad\x7f\x69\xb2\x12\xa7\x71\x86\xa0\xaf\x2c\x86\xdf\x66\x2c\x59\x58\xf6\xad\x5c\xef\x9e\xb3\x85\xdc\xd1\xe1\x96\x30\x37\x49\x59\xc4\x17\x9c\x9c\x8b\x38\x5a\xcb\x9b\xb3\x7e\x24\xaa\xe6\x91\xae\x35\x67\xd5\xcc\x80\x1f\x14\xe8\xca\x7c\xf9\x8c\x58\xf9\xcc\x4f\x1d\x9e\x53\xae\x54\x86\x7a\x98\xf2\x43\x51\xfb\x3e\x41\xc9\x50\xbc\x98\x4e\x31\x52\x18\x12\x82\x4e\x0e\x71\x89\x70\x42\xbc\x89\x7b\x11\xc2\xf8\xbf\xd9\x4a\x6c\x12\x07\xe1\x68\x51\xb6\x10\x13\xc2\x66\x4b\xb2\x8f\xf8\xe4\x06\x41\x54\x50\x43\xa0\xf1\x31\x08\x8b\x89\x1f\xf8\xcc\x26\xac\x96\x95\xe5\x3e\x6f\xdd\x8f\x46\xb4\x6d\x65\x9a\xfe\x28\xff\xd7\xc8\x37\xd9\x83\xa2\xfa\x06\xb5\xab\x62\xa7\xa4\xca\x0e\xb4\xf6\x2c\xb0\x4e\xf9\x68\xab\x8e\x95\x0c\x77\xed\xdb\x07\x65\xc3\x5d\xb9\x5e\x3f\x16\x7e\xc0\x85\x85\x7a\x3c\xcb\xf2\x6b\xf5\x30\x63\x89\x9f\x31\x06\xe9\x59\x9c\x64\x67\x7e\x14\x2c\xb3\x4c\xef\x21\xd0\xbe\xcd\x1e\x02\x14\xc4\x17\x2c\xa9\x58\xe0\x4e\x13\x16\x84\x43\x5e\xc8\x5a\xe0\x86\xd1\x45\xcc\xd7\x22\x53\x96\x08\x28\x61\x1c\xd5\x33\x0e\x67\x72\xae\xab\xa9\xa7\x2c\x10\x23\x5b\xc2\x47\xaf\xc9\x27\x5a\x70\x92\xc2\x60\x29\x66\xa2\xbe\xd9\x73\x48\xd9\xea\x31\x61\xe9\x1b\x01\xa5\x55\x58\x32\xf5\xfa\xcb\x70\x1a\xc7\xe4\xa2\x64\x15\x72\xa0\x8c\x5b\x85\xba\x73\x51\xb4\xec\x0b\x76\x52\x4f\xe2\xb4\xb1\xa1\x83\xfd\x58\x66\xd2\x12\x26\x8f\x41\xc0\x12\x8e\xad\x7d\x3c\xe0\x5a\x93\x67\x6b\x1d\x44\x48\x4f\xf8\xf9\xc5\x47\x78\xf3\xd3\xbf\xbd\x3a\xfa\xfc\xe6\xfd\x4f\xb0\xbe\x95\x87\xe6\xc2\x57\x74\x44\x89\xe3\xaa\x93\x05\xe3\xa8\x64\x36\x78\xcd\x95\x75\x95\xb5\xf3\xe4\xa9\xdc\x69\x7b\xc9\x32\x6e\xd0\x8c\x12\xc6\xb5\x56\x12\x62\x64\xbd\x13\x81\xf7\x89\xde\xfc\x4d\x18\x7b\xa5\x37\x1e\x85\xd3\xaf\x4c\xe8\xc2\x1a\x19\x46\x6b\x7c\xcd\x2d\x93\x1f\x3d\x82\x87\xf2\x2c\x29\x8a\x03\xf6\x79\x31\x65\x46\x7e\x2d\x02\xd4\x65\xbb\x7d\x11\x2c\xac\x6b\x21\xf3\xe8\x91\xc4\x66\x22\xb2\x6d\x64\x44\x2a\xc7\x45\x0c\xac\x89\x0a\x25\xd9\x98\x70\xa1\x9a\xc6\xd3\xd9\xd8\x4f\xe0\x28\x9e\x4c\xe2\xe8\xdf\x3e\x01\xfa\xea\xa0\x6e\x39\xb1\xf9\x43\xa3\x48\xe9\x9a\x48\x06\xca\x8f\x1e\x19\xbf\x34\x67\x75\xad\xae\x08\x2c\x7e\x94\x3b\xfd\x24\x07\x25\x1b\xfd\x3f\xce\x46\x23\x74\xde\xb2\x5b\x3c\x44\xd6\x68\x8a\x5c\x7b\x77\x61\xcb\x80\x5b\x38\x41\x40\x05\x99\x9d\xc5\xa9\x38\xd0\xc5\xad\x73\x7f\xc2\x20\xe2\xff\xf8\xa9\xd8\x57\x3c\x19\xc7\x81\x9f\x9e\x9d\x48\x3b\x4e\xe1\x13\xf9\x59\x78\xc1\xde\xa4\x0a\x2f\xf1\x71\x28\x3e\x9a\x61\x5a\x81\x54\xce\x78\xa2\x39\xfa\x84\x82\x9b\x0c\xa8\xae\x54\xc3\x14\xf8\x10\x3f\x27\x6c\x32\x60\xc9\xfb\x11\x1c\x53\x4e\x18\x0d\x19\xec\x34\xb7\x9b\x2d\x32\xb8\xfd\x8c\x9d\xc6\xc9\x02\xde\xfa\xd1\xa9\xa9\x81\xd7\xc5\x14\xad\x67\xe8\x1b\x18\x49\x25\x38\x16\xcd\x23\xf8\x57\x36\xf7\x27\xd3\x31\x13\xd8\x1f\x2b\x12\x38\x5c\x5d\x8b\xcf\x0e\x7a\x42\xad\xf3\x95\x7f\xf7\x39\xc5\x53\x2d\x2d\xfe\x25\x8c\xb2\x3d\xba\x6b\x62\x57\xc1\x06\x1f\xc8\x61\x08\xf5\x00\xe4\x46\xe4\xdb\x37\xad\x11\xca\x2c\x61\x59\xf3\xa0\x56\x1f\x5d\xd1\x51\x47\x9d\x4a\x73\xda\x4f\x76\x5c\xa9\xae\x5c\xb7\xa0\x2b\x6b\x03\xa4\x2f\xb5\x3c\xa4\x7d\x69\x2e\xbe\xc1\x0b\x9a\x96\xca\x15\xdc\x9e\x7c\xab\x8e\x57\xf8\x12\xf9\x49\x55\xc9\x8e\x7a\xd7\x88\xeb\x85\x2f\xd5\xe1\x0e\x9f\xec\xb5\xc5\xe3\x55\x3f\xc5\x01\x6b\xfe\x9a\xc2\x19\x1b\xf3\xb9\xba\x44\x42\x39\xa8\x1c\x96\x0a\xfa\xa3\x47\xea\xbb\x19\x1a\x65\xae\x11\x08\x3c\x9c\x0f\x47\x21\x9f\xe4\x39\xeb\x71\xa5\x67\xcc\xf7\x4b\xc9\xc8\x76\xb3\xf5\xfd\x65\xc4\x40\x74\x39\x41\xd1\x24\xc9\x71\x7f\x8d\xb4\x18\x75\x7a\xfd\x3a\x11\x29\x8c\x89\x35\x4c\x87\x9a\x5d\x9c\x7c\xa6\x0b\xfb\x05\xee\x2b\x17\x26\x2b\x3f\x27\x02\x3b\xcb\x04\x6f\xb6\x96\x96\xca\x3f\x60\x86\x5c\xac\xcf\x43\xce\xfc\x4c\xd8\x8c\xea\x9c\x95\xfc\x71\xb2\x54\x85\x31\x26\xbf\xa9\x51\x9c\x4c\x58\x70\x8b\x23\xd7\xcb\xc4\x9f\x56\x18\xb3\xaa\x01\x61\x06\xe7\xdb\xcd\x71\x8d\xae\x58\xb0\x61\xe5\x91\xb5\x6d\xbd\x72\x3b\xfa\x45\x72\x8a\xb4\xf2\x34\x58\x6b\x89\xa9\xe8\xe8\x27\xa7\xf9\x23\x86\x59\x34\x74\x54\x2d\x2c\x20\x63\x6e\x97\x99\x7a\xa2\xb5\x92\x71\xbb\x9d\xa7\xcb\x52\x66\xde\xe9\x38\x1e\xf8\x63\x61\xe6\x45\xf1\x65\x65\xb0\xd9\x8e\xfb\x00\xc0\x93\x96\xa0\x30\x7f\x2e\xc3\x28\xe0\x75\xb8\xfd\xa3\x66\xd9\x35\x38\x04\x02\x0b\xfb\xa2\x04\x56\xbd\x60\x51\x10\x27\x14\x3f\x66\x12\xff\xbe\xe6\xc1\xda\x25\x1b\x9c\x87\xd9\x5a\x1f\xf3\xd3\xd9\x68\x14\xce\xb5\x5b\x6a\x18\x47\xaf\x13\x7f\xc2\xd6\xa8\x61\x7f\x04\x5d\x6c\xbe\xb7\xc6\xf1\x62\x69\xb6\x06\x1b\xa2\x12\x01\x18\x1a\x45\x86\x7e\x34\x64\x63\xa3\x04\x9f\x90\xcc\xac\x8f\x45\x18\x0f\x46\x71\x62\x86\xa9\x7e\xc8\xdb\x7c\xf4\x08\xe3\x98\x0a\xe4\x73\xb1\x4c\x39\x3b\xe8\x46\x45\x99\x5e\xd8\x87\x0d\x58\x2b\x69\x00\x4c\x14\xed\xd2\x47\x79\x7c\xc5\x92\x42\x62\x5d\x56\xba\xa4\x05\xda\xf8\xc2\x83\x71\xb1\x2e\xc5\x8d\x88\xd7\xaf\xe1\xcc\xbf\x60\x90\xbc\x78\x0d\x83\x59\x86\xa1\xda\x86\x2f\x5e\x3f\x08\x47\x0e\x76\x92\x22\x49\x8d\xf4\xca\x6c\xec\xa7\xf8\xf0\x03\x62\xe1\x41\x18\x18\x3f\x7e\x9b\x31\x5c\x2b\xf5\xfa\x22\x61\xc4\x47\xe9\xa5\xbe\xa5\xd3\x6e\xb5\x5a\xb0\x05\x8f\x5b\x0f\x14\x7d\xf4\x33\x7b\xfe\x78\x3c\x50\x27\x8a\x7c\x79\xe5\x20\x3c\x79\x5b\x2e\x77\xc3\x00\xbd\xff\x89\x2d\xa3\xf8\xd2\xd1\xbb\xd3\x74\xa5\x5f\x3e\xcd\x37\xf1\xe7\x4e\x2b\x8f\xc8\x26\x38\x58\x75\x13\x7b\xe3\xca\xba\xa2\x6b\x58\x7d\x03\x81\xab\x43\xb5\xec\x73\x38\x61\xf1\x2c\x73\x0a\xaf\x5b\x48\x5c\x86\x53\xe8\x12\x01\xe8\xb1\x78\xa7\xa5\x51\xda\xda\x02\xf2\x14\x23\x02\x9d\xb1\x04\xe7\xb1\x69\xc2\x2e\x58\x94\x99\xc5\x24\x11\x52\xf2\x5f\xa4\xed\x9a\x30\x3a\x85\x71\x98\x66\x2c\x62\x49\x6a\x96\xce\x62\xd4\x57\xc3\x59\x92\x70\x2d\x87\x9d\x5c\x4b\xa9\x15\x55\xce\x26\xa2\x0a\x87\x83\xef\xb6\xe6\x43\xaf\x0f\xa7\x45\x36\x96\xff\x71\x8e\x18\x4e\x7b\x61\xbf\x49\x62\x32\x66\x41\xfe\x18\x24\x4b\x16\xf9\x73\x11\x59\x83\xba\xe5\x20\xbd\xed\x03\x11\xf2\x34\x71\x58\xf1\x4c\xa5\x82\xec\x22\x2a\x2a\x83\x2b\x0f\x5a\x6e\xf5\xe9\xca\x83\xfc\xd7\x95\xb8\xf7\x9c\xc4\xb3\x28\xc0\xa0\x63\x62\xe8\xa9\x00\x11\x0a\x0f\x6f\x24\x26\x74\xed\x6f\x1f\x36\x36\x42\x75\x43\x4a\xf6\x65\x5f\x7d\xe9\x1c\x41\x97\x7d\x39\xd1\x6b\x07\x7d\x31\x01\x84\x81\x7e\xac\xc1\xe2\x7e\x6a\x49\xd2\xa0\x64\x68\xcc\x61\xcc\x8d\x8e\x94\x14\x4e\x69\x82\x83\xc2\x62\x83\x54\x3d\xb4\x46\x50\x9c\x1e\xdb\xa7\x4b\x72\xa3\xbc\x30\x1f\x29\x6c\x47\xe2\x44\x6f\x6b\x0b\xfe\x9a\xf8\x53\x08\x23\xf0\xad\x69\xd3\x66\xef\xad\x2d\x38\xa1\x26\x4f\x60\x1a\x67\x2c\xca\x42\x7f\x3c\x5e\xc0\x80\x71\xd6\xa6\xc7\x13\xf0\x95\x11\xcd\xd3\xb4\x66\x40\xb5\x24\x61\x1a\xdb\x23\xfe\x88\xac\x7f\xae\x00\x3d\x18\x45\xee\x83\xab\x1c\xb6\xa2\x8b\x26\xd2\x84\xf2\xd0\x1f\x35\xfd\xe9\x74\xbc\x10\x95\xd5\x13\x0b\x25\x30\xa6\xf1\x78\x31\x0a\xc7\x16\x14\x5a\xcc\x6b\x27\xad\x87\x66\x02\xc8\x13\x19\xd2\xe4\x72\x13\x52\x38\xb9\x8b\xc9\xc9\x9e\xc3\x78\x51\x7f\xa4\x0b\x11\xde\x85\x32\x43\x7f\x84\x2a\xfc\x76\x0b\xa2\x9d\x76\xc9\x3a\x68\x67\x19\x1f\xc0\xeb\xd7\x41\x7f\x66\xd9\x67\xbf\x2a\x60\xfc\xae\xf4\x85\x35\x83\xc6\x56\x5a\x14\xf2\xa0\x2c\x4c\xe9\x10\xe2\x6d\x78\x5e\x55\x78\x67\x47\x6e\x1d\x9d\x50\xd9\x7f\x91\xfe\x7f\x27\x72\xb7\xaf\x64\x45\x44\xb4\x26\x74\xd7\x7a\x62\xcc\xa8\x7e\x7f\xed\xe0\xae\x9d\x1d\x3d\x83\x33\x64\xa9\x7c\x20\xf7\xef\xe6\x10\xa9\x9d\xd9\xf8\x2a\x4a\x7a\x19\x61\x47\xe3\xcb\xc8\xf4\xd5\x90\x80\xed\x10\xf3\x14\x40\x5e\xf6\x24\x17\x7f\x3e\xd7\x44\x18\xf1\xf5\x3e\xef\x83\x18\x9c\x13\x33\x42\x74\x6e\x34\x8e\xb2\x38\xb1\xb0\xb7\x7d\x1a\x09\x80\x7b\xed\x46\xcd\x74\xec\x53\x2c\x77\xbc\x04\x44\xcb\x92\xd4\x03\x5f\xa6\x01\x5d\xe3\x0a\x60\xb0\xe0\x98\x71\x48\x65\xc8\x01\xff\xff\x48\x6c\x41\xf9\x70\xd2\xeb\x29\xb6\xed\xf7\x4f\x70\x4b\x3f\x9a\x8d\xc7\x27\x4b\xaf\x76\x5b\xcd\xbd\xef\xbf\xda\xb5\x89\x71\xdd\x72\x57\x29\xef\xd7\x71\x4c\xda\x72\x5d\x1d\xa7\xe2\xcb\x35\x3c\xe1\xca\x58\xe7\x7e\xe0\xe0\xc5\x63\x50\x5c\xfb\xbf\x8e\xe3\xb2\xd5\x6e\x59\xf1\x5e\xdb\x83\x8e\x07\xdb\xa5\xcb\xe3\xb2\x0a\x5f\x61\x6d\xbe\xb6\x0f\x2d\x0f\xd6\x16\xfc\x2f\xdd\x5c\xaf\x58\x80\x9b\x15\xed\x38\xe6\xe8\x4b\x5b\x52\xd3\x58\xe3\xd9\xd5\xe5\x4b\x01\x0f\xd4\xd5\x57\xad\x93\x64\xe6\xb7\x6f\x86\x06\x94\x89\x0f\xbb\x5a\xcd\xd4\x79\x9a\x89\x60\x45\xa8\x15\x4c\xed\x28\xe0\x48\x2f\x32\x51\xa4\x6b\xbb\x03\xcb\xa0\x31\xc9\xcc\x82\x77\x44\x6f\xe4\x94\x3d\x0e\x81\x70\x3c\x58\x33\x78\x7d\x0d\x03\x6b\x62\x46\xd3\x48\x36\x5c\x30\xc4\xa2\x8e\xc0\x5a\x11\x33\x1e\x3d\xa2\x54\xf3\x7d\x01\xfe\x5b\x38\xe2\x14\xe5\xf8\x08\xdf\x27\xe8\x76\x0b\x52\x5f\xbe\x04\xb6\x06\xa3\x64\x21\x7c\x3b\xcf\xe2\x3b\x7f\x7d\x4a\x59\x1f\x46\x20\x3d\xe8\x82\x9d\xfc\x69\x9a\x94\x25\xff\xc8\x7e\x0f\x71\xbf\xd4\xdc\x95\x5e\xf9\xd9\x93\x7f\xe2\x77\x3b\x30\xce\xfe\xd1\xd1\x97\x8f\x2f\x8e\xfe\xc6\xf5\x0d\xdb\xdc\x11\x14\x18\xce\x06\xe1\x90\xe8\xf3\xda\x1f\x12\x73\x1b\xcf\xab\xe5\x32\x9d\x61\xdb\x83\x61\xc7\xda\x94\xe9\xb5\x3c\xd8\x86\x75\xe0\x59\xf8\xb7\x03\x9b\xf0\xd8\x4c\x68\xc3\xa6\xcc\xd9\x80\x76\xff\xe0\x81\x7c\xeb\x6a\x32\x1b\x67\x0b\x11\x97\x4e\x35\xaa\x12\x1d\x54\xde\xa9\x07\x99\xd5\x1e\xa5\xe2\x7d\x5f\x7d\xcb\x17\x13\x3d\x08\x73\xd2\x4b\xea\x7f\x9d\x16\x27\xd3\xf8\xd2\xc9\x78\x19\x94\x67\x57\x46\x72\x32\x80\x24\xcc\xc3\x25\x5f\x1e\x4a\xc2\x60\x03\x33\xa8\xa6\xee\x80\x41\xa0\x0a\xba\x95\x51\xcc\x78\xc9\xcc\x3c\x0f\xa5\x8e\x71\x8b\xb4\x8a\xec\xc2\x05\x53\x80\x29\x23\x94\xdc\xf2\x12\xf8\x05\x0c\xb7\x00\xc3\x0b\x76\x54\x8e\x69\x69\x81\x3b\xc6\x19\x74\xa4\xb1\x0f\xb2\x78\x6d\x20\xb0\xa5\x46\xb8\x30\xc6\xa1\x38\xef\x75\xc5\x2e\x41\x1b\x83\x6d\xb5\xfa\x95\x54\x53\xf8\xe4\x08\x47\x9b\x05\xc3\xd9\xd8\xcf\x18\xf5\x6b\x73\x40\x84\x9b\xa1\xd2\xf9\x89\x5d\x66\x71\xb4\x96\x0a\xab\x95\x18\xc1\xd6\x33\x15\xea\xc7\x08\x75\xab\xd3\xc5\xea\x49\xa9\x8a\xe3\x31\xfa\x19\xe7\x9f\xb1\xc3\xf5\x54\xaa\x94\x07\x2f\xe5\x7a\x70\x7c\xce\x16\xb4\x92\xc5\xaf\x67\x58\x9b\x7e\xe8\x75\x2c\xaf\xd8\x3b\x16\xef\xe0\xe8\x87\xef\x30\x45\x85\x75\xe7\x4d\xe3\x1b\x90\x58\x5a\x07\xa6\x5c\xa8\xb4\xb6\x4a\xc3\x67\x21\x31\xad\xa3\xcb\xa9\xb4\xed\x3e\xc5\x54\x20\x3f\xf2\xd3\xd4\xdc\x66\x6a\xe7\x9f\x0f\x17\xad\xe5\x1e\x02\x95\x97\x86\xf7\xd5\x02\x1b\x51\x6b\x35\x5b\xda\x7b\x73\x51\x48\x41\xb4\xda\x56\x19\x95\x52\xee\xf4\x49\x8d\xe1\xcd\xcd\x42\x53\x9d\xdd\x42\x5b\xed\x5c\x5b\xb9\x42\x4b\x37\xb6\x19\x46\xc5\xf6\x76\x3a\xf7\xd5\x37\xbc\x89\x7d\x93\xf6\x5a\xcd\xdd\xbd\x1b\xf6\xaf\xbc\xcd\xeb\x87\x6f\xb5\x26\xe5\x2b\x62\x2a\x57\x47\x74\xb9\xf4\x93\xc8\x75\xc4\x53\x38\x6b\x3d\x53\xe2\xfa\xfb\x5a\x0a\xe4\x5d\xe7\x01\xc3\x45\x49\x3c\x82\x35\xd8\x80\x35\xbc\xcc\x0d\x7f\x17\x7c\xf8\xf7\x35\x0f\xfe\x8e\x3d\xd3\x5f\x9b\x61\x64\xfc\x88\x67\x19\xff\x85\x75\xff\x6e\xd2\x80\xa7\x72\x0b\x8e\xf9\x7c\x79\x8b\x91\xf9\x03\xf8\x21\x5d\x23\x71\x36\x43\x4b\xf0\x2e\xe6\xd1\xef\xcd\xdb\x1e\xcc\x3b\x1e\x2c\xda\x1e\x2c\x3a\xfd\x26\xbb\x60\xc9\xc2\xd0\x8a\xd1\x6c\x92\x37\x58\xc9\xa0\x8c\x66\x13\x3a\x22\xa0\x8b\x40\x68\x4e\xf2\xb4\xe7\xe2\x4d\x60\xfe\xfd\x8c\x56\x1e\x18\xe1\x6b\x29\x0a\x71\x6c\x16\x12\xa3\x0e\x27\x16\x9f\xfc\xdb\xfd\xfa\x1e\x0a\xe5\x32\x9c\x25\x17\xec\x17\x7b\xaa\x70\xa8\x7f\x48\x06\x55\xe6\x6f\xb9\x32\xd4\x77\x55\x26\x60\xc9\x91\x04\x55\x3e\x7d\xe5\x80\x26\x7e\x74\xca\xe4\x8d\x06\x1d\x5e\x4b\xa5\x9a\x0b\x11\xd2\x5a\xb4\x42\xb4\x82\xc8\x09\xea\xb6\x0b\x6f\x8e\x50\xd9\x67\xe6\x06\xba\x28\xdb\xb2\x9e\x3d\x11\x89\xca\x33\xe9\x4a\x11\x66\x50\x98\x1e\x28\xc5\x39\xb6\xa6\x5a\x74\x06\xca\x38\x56\x70\x08\x6d\xd8\x87\xe3\x4c\xcf\xad\x73\xe8\x82\x8c\x59\x5d\xf6\xf2\xe7\xde\x01\x6c\x6c\x84\xf6\x1e\x3f\xbb\xf0\xc7\x9f\x91\xd6\x9c\x9a\xce\xdc\x85\x4d\xb0\xa2\x15\x07\x2c\xf9\x19\x2f\x1d\x29\x92\x3b\x73\x3b\x10\x12\xda\x55\xfe\x20\x75\x08\xd6\x26\x37\xd5\x9e\x69\x4b\xf3\xdb\x37\x09\x43\x27\x96\x45\x32\xc2\x51\x77\xe6\xc5\x78\x31\x73\xdc\xc3\x53\x03\x35\x87\x4d\x81\xf5\x96\x00\xec\x96\xd1\xd8\x82\x47\x74\x26\x8a\x36\xc3\xf4\x53\xc6\xa6\x53\xa2\xb6\x0a\x20\x2f\xaa\x51\x19\xc3\xb8\xab\x5b\x52\xa8\xe4\xdc\x9c\x4e\xe9\x8e\x3e\xd5\xa1\xe4\x92\x09\x1d\xc3\xee\x3e\x7a\x64\x4c\xc8\xad\xbe\x7d\x15\x05\x0e\xed\xcc\x7d\xf8\x7a\x25\x99\x5a\x44\x1f\xff\x53\x9a\x85\xa3\x11\xc5\x66\x1a\x85\xa7\x4d\xfc\xa9\x6e\x2c\x89\xbc\x5c\xd9\x5c\x13\xed\x56\x4b\xc4\x53\x52\x65\x24\x00\x99\x18\xf8\x93\x29\xf5\x56\x34\x23\x12\x64\x39\x9d\x5f\xa8\x91\x6b\x6c\xcf\x68\x2a\x07\x44\x25\x67\x46\x3b\x2a\x9a\x19\xa6\x9a\x45\xf2\xbd\x78\x62\x42\xce\x94\x70\xa5\x7a\xbc\xe5\x40\x89\x24\x87\x1b\xf4\xbf\xe0\x3b\xb1\xd9\x2f\x64\xf7\xff\x6c\xca\xdb\x6b\x35\xc4\x9b\x54\x14\x36\xa9\xac\x0b\xeb\x44\x5a\x2d\x7e\xaf\x5f\x6a\x0a\x71\x38\xb0\x2e\x69\x62\x99\xbf\x3f\xab\xfc\x0d\x70\x24\xfc\x4d\x55\x9b\x03\x0e\x32\xd8\xc2\xc3\x3c\xab\xe2\x2f\x26\x60\x59\x42\xac\x49\x7e\x31\x2e\x66\x29\x79\xc4\x3a\x0a\x5f\x43\x24\x1f\x3d\x02\xb3\xd0\xcf\x6e\xa9\x68\xca\xa5\x9d\xa0\x4d\xab\x5f\xf2\x2a\x50\x8f\xb7\xe1\x61\xb7\xfa\x5a\xd0\x04\x71\x2d\x49\x93\x7b\x28\x32\x0f\xc7\x52\x8c\x91\xba\x9f\x87\x59\x79\xe1\xab\x58\xe6\xab\xe4\x9c\xf0\x51\x7a\x99\x41\xdd\x59\xce\xa2\xee\x08\x93\xba\xa3\x6d\xea\x8e\x30\xaa\x3b\xe2\x67\x89\x59\xdd\x29\xda\xd5\x1d\xdb\xb0\x56\x61\x0f\x85\xb9\xab\x0d\xe4\x92\xb0\xaa\x32\x4c\x4d\xce\x52\x16\x91\x3e\x73\x86\xb2\x65\xbb\x56\x5b\x60\x15\xc6\x60\xb9\x49\x5a\x61\x82\x4b\xed\x6a\xae\x5d\x72\x21\xa5\xa9\xa6\x08\xee\x5a\x51\x53\x6a\xc8\x9b\xda\x70\x34\xc8\xfd\x7d\x18\x85\x49\x9a\x69\x4f\x94\x82\x21\x57\x61\xb1\x99\x36\x9a\x30\xd0\x0a\x16\x9b\x36\xfc\xf0\xe2\xf0\xdf\x45\x97\x4c\x63\x6e\x09\x6b\xee\xba\xb0\xb9\x39\xcb\x8d\xca\x1c\x54\xd9\x82\x4b\x92\x01\x8f\x7f\x34\x2d\xb4\x7f\x4d\x42\x3d\x97\xf1\xac\xae\x33\xd9\xe4\x23\xf9\xf8\x9a\xc9\x55\x21\x22\xcc\xce\xed\x6f\x80\xc9\x88\xdd\x55\x4f\x1b\x4b\xcf\xbe\xf8\x82\x25\x1f\x59\x5a\xe5\x0c\xbd\xd7\xda\xd6\xb7\xbf\x8c\x63\x9a\xf2\xb2\xc6\xed\x2f\xba\x13\xcf\x39\x36\x9c\x4c\xe9\x06\x09\x39\x31\xd0\xad\x82\x84\xa5\xd9\x09\x5c\x9e\x85\xc3\x33\x08\x62\x86\x4f\xa1\x5e\xf8\xe3\x10\x5f\x63\x8e\xb9\x86\x62\xc9\x90\x19\x5a\xe5\xe6\x6e\x57\x78\x6a\x0a\x3e\xf0\x26\x69\x3f\x83\x65\x2c\x81\x2c\x2e\xbd\xd2\xdf\xc3\xd8\xbe\x5d\x0e\x40\x68\xb2\xcd\x36\x5d\x4e\xc0\x0c\x98\xc6\x22\x80\x96\xb8\x26\x64\x43\xbd\xad\x9f\x16\x27\x18\x1f\x0d\xe1\xa8\x85\x4d\x5a\x3b\x45\xc6\x28\x38\x72\xe8\xcc\xc2\x9e\x1a\x78\x97\xae\xa7\xca\xe8\x18\x65\x9b\xd4\xb2\xb5\x92\xfd\xe9\x65\xee\x6e\x5d\x7f\xb6\xfa\x3a\x4e\xde\x5f\x46\x95\xaf\x6b\xcb\x98\x40\x74\xc6\xf1\xa3\x9f\xb2\x57\xfe\xf0\xac\xb2\xf8\xde\xd2\xdc\x35\x8a\x13\x0e\xe9\xa4\xec\xa6\xca\x8d\xae\xa9\x7c\x53\xb7\xca\xe2\xf1\x98\xd1\x58\xe1\xd5\x32\xfd\x73\xb9\x5b\x2b\xaa\xf1\x9b\x5d\x5a\x51\x78\xa8\x03\x34\x8d\x81\xb8\xf9\x24\x69\x2f\x48\x69\xd3\xd6\xd1\xa3\xe2\x96\xb9\x5d\xca\x8a\x25\x1c\xb1\xcc\x15\xb2\x6b\x54\x92\x38\x82\xaa\xba\x77\xb1\x77\xdd\x29\x69\x3a\xa3\x37\x77\x71\x18\xe9\xf8\x83\x6e\xd2\x72\x3d\x67\x84\xc4\xf0\x20\x6c\xb2\x26\x9c\x74\xbb\xdd\xda\xeb\x69\x77\x7b\x70\x39\x2a\xc3\x0f\xcf\x22\xcb\x71\xac\xb9\x0d\xc8\xed\x3b\x5e\xfb\x08\xcb\x73\x90\xe6\x32\xda\x5c\xec\xe2\xa4\x47\x5f\x8f\x1e\x81\x3a\xe5\x53\x87\x70\xe5\x67\x53\x79\xe8\x25\xc3\x7d\x77\x57\xc8\x26\x7e\x36\x3c\x63\xa9\x3c\x96\xa2\x9b\x64\xc2\x23\x40\xdc\xf0\x93\x84\xc3\xd3\xdc\xbb\x19\xdb\x9a\x9b\x9d\x53\xe9\x12\x90\xc5\x70\xca\xb2\x66\x8e\x25\xd2\x64\xf8\x73\x91\x2b\xb0\x17\x4b\xab\x77\x4e\x8b\x2a\x1d\x2f\xe8\x51\x18\x61\x7c\xa5\x5d\x36\x5e\xee\x99\x6b\xfb\xec\x70\x0b\x48\xfa\xed\xd8\xc7\xab\xc5\x13\xdb\xdc\xf2\x82\xaa\x89\xd7\xdb\xbb\x5d\xdd\x67\x15\x88\xc0\x51\x49\xf6\xaa\xf9\xdb\x37\xf5\xf0\xbc\x60\x35\x81\x54\xad\x47\x70\x45\x9f\x4b\xf8\xee\x76\x17\xc1\x0c\xa7\x9e\x2a\x2d\xb3\xf3\xd4\x50\x33\x7f\x66\x19\x0d\x1a\x8d\xb3\x9f\xc1\xc9\xd4\xcf\xce\xc8\x51\x82\x3a\x76\xd2\x84\x37\x6a\xaa\x8f\xc7\xdc\x98\xa3\xc2\x61\x8a\x4e\x18\x8a\x34\x27\x1e\xb9\x8c\x08\x93\xfb\x67\xa5\xb6\x88\xe6\x2c\xe0\x34\x0b\xb3\x14\xa6\x63\x7f\xc8\x56\xb8\x6e\xf0\x24\xef\x80\x41\x84\x2f\xbb\xf4\x2c\xd8\xe1\xb3\x75\xc7\xbe\x78\xed\x99\xe6\x12\x29\x22\xbc\xc7\x58\x05\x3f\x96\x13\x92\x9e\xd9\x4b\xe3\xde\xbd\xee\x2c\x5e\x7f\xd6\xc4\xc9\x51\x2f\x1f\x1f\x68\xdd\x96\x21\xbb\x70\x99\xd3\x87\x76\xc0\xc1\x37\x76\xd7\xfc\xb5\x7d\xe8\x7d\x85\xb5\xc1\xda\x3e\xff\x39\x5c\xdb\x87\x6d\xb8\x82\xab\x3e\x3e\xba\x2b\x3c\x2c\x30\x82\x8d\xf0\x2a\x59\xf3\x7b\xad\x7e\x73\xd0\x1c\xae\x99\x6e\x15\xdb\xa5\x65\x7b\x6b\x3e\x5f\xdb\xb4\x30\x78\x3b\x86\x5b\x5f\xeb\x5f\x5f\x6b\xcd\x47\xf0\x1e\xac\x09\x62\x59\x2d\xa9\x44\x5b\x3b\x98\x00\xf8\x78\x78\x60\x52\x5a\xef\x7c\xa9\x2b\xa1\xb6\x06\x80\x43\x43\x56\xf7\xa5\x2c\x58\x10\x8b\x31\x2a\x0a\xfb\x3d\x66\x93\xb0\x5f\x7b\xad\xf3\x94\x95\x99\x8f\xb7\xbf\xa2\x34\xf4\xd3\xec\x83\x9f\x55\x59\x83\xdb\xbb\x72\x01\x93\xc5\xff\x8b\x55\xad\x72\xda\x3b\xcb\xaf\x48\x4e\x59\x56\x6e\x2f\xca\x00\x9e\x35\xd1\x29\xbe\xaf\x14\x2e\x2f\x34\xb9\x95\x45\x81\x13\x90\x9b\xa6\x44\x65\x49\x70\x87\xb8\x2e\x56\x7e\x6b\xf6\xcd\xe6\x56\xe1\x62\x33\x2f\x5f\x72\x0d\x5e\xf4\x5c\xc4\x01\xc4\x5b\x07\xa5\x97\x95\x95\x10\x8b\x39\x09\xc7\x13\x91\xa0\x5b\xcb\x1b\x1b\x7d\x37\x7f\x2d\x5e\x3c\x6f\xa7\x60\x76\xbb\x0a\xe8\xa1\x04\x68\xdd\x92\xac\x5a\xfd\xfc\xb9\x8c\x7b\x77\x97\xb9\x5d\x74\x9d\xa9\x5b\x77\xaf\xae\xbd\xa7\x1c\x45\xab\x79\xb7\xd3\xd6\x71\x58\x39\x87\x7c\x8e\x6b\xc4\x61\xaf\xb3\xad\xc4\xa1\x7e\x8d\xde\x79\x6c\x5a\xd9\x7e\x9a\xa5\xca\x82\xe5\x6b\x65\xe2\x06\xba\xab\x8e\xe1\x8a\xd7\xe8\x19\xfc\x38\xaa\x0d\x36\x59\x6e\x49\x87\x11\xb7\x83\xb2\xd2\x88\x72\xc2\x7b\xb5\x5f\x26\x25\xdc\x58\x4b\x61\x99\x6b\xfb\x9c\x69\xb5\x90\x68\xdc\x0b\xd1\x35\x04\x6f\x8b\xdb\xee\x79\x67\x68\xe9\x59\x44\x56\x73\x6e\xe7\x48\x1f\x2a\x69\x06\xc4\x81\xcb\x43\x3b\x14\x71\x68\xfa\xb0\x6f\x8d\x99\x23\xc7\x44\xc2\xaf\x0a\xdf\x41\x48\x96\x30\x64\xed\xb5\x29\x3d\xcc\x02\xd6\xf1\xf1\xb2\x9e\x63\x4b\x5d\xa8\x9a\x26\xf1\x90\xa5\xdc\xd8\xdf\x5a\x87\x33\x3f\x99\xc4\xd1\x42\x48\x01\x38\x83\x10\xef\x79\xb8\xb0\xbe\x55\xd6\x66\x33\x70\x4a\xd1\x6b\xf8\x0d\xcf\xf2\x70\x97\x84\xbd\xf4\x93\xe8\x00\xbd\x80\xb6\xd6\x81\xa5\xe3\x30\xca\x20\x8a\x37\x87\x71\x94\xc6\x63\xb6\x0f\x2d\x7d\x09\xf1\x25\xbb\xa0\xd7\xbb\x38\x76\x4d\x16\x5d\x34\x7f\x7a\xff\xf2\xd5\xf1\xab\x9f\x7e\x46\x93\x75\x6d\x9a\xc4\xc1\x8c\xf6\x02\xc5\xb6\x37\x07\x6e\xee\x6b\xf3\xdf\xce\x30\x8e\x02\xdc\xd1\xf1\xb8\xb6\x9f\xf8\x99\x07\xbe\x07\x03\x0f\x86\x1e\x04\x1e\x30\x0f\x46\x26\xa3\xf0\x56\xf5\x6d\x79\x81\x17\x35\x68\xdc\x17\x7b\xf4\x48\x66\xd1\xfe\xa2\x61\xb1\x53\x23\xf6\x94\x6b\xec\x3b\x1b\xb5\x9c\xb5\xb7\xf1\xe9\x97\x2c\x1c\x73\x13\x12\x09\x8a\x81\x94\x58\x92\xc4\x09\x4c\x58\x9a\xfa\xa7\x7a\x87\x6c\xcd\x3e\xac\xa3\x70\x63\xb2\x6b\x76\x1c\xb3\x7a\x0c\xf2\x38\xbc\x0b\x23\xba\x30\xcb\xe6\x18\x3a\x8d\x4f\x98\x43\xbc\xba\x13\x1c\x00\xe7\x26\x5c\xf3\xc4\xd1\xe6\x44\x16\x0c\xd8\x05\xb0\xe8\x22\x4c\xe2\x08\x37\x4d\x71\x67\x94\x6e\xc7\x33\x18\xf1\xc9\x20\xd7\x85\x28\x00\x3f\x20\x4c\xfd\x31\x5e\x08\x1e\xcd\xc6\x38\x3a\x61\x74\x9a\x36\xd7\xf4\xd1\xa5\xf0\xc7\x53\xa8\x52\xc8\x3d\x3c\x67\xe8\xe5\x47\xad\x7f\x90\x2f\xa6\xe2\x6a\x18\x1e\x0f\x56\x67\x89\x32\xcd\x84\xa1\x89\xee\x6c\xfd\x90\x6e\x9d\x9a\xcf\x5d\x94\xbe\x74\x81\xa7\x0e\x12\xfa\xc6\x46\xdf\x7c\xe4\xa2\xec\x95\xaa\x07\x57\xb5\x82\x27\xee\x43\x2c\x2b\xd5\xce\x76\xc9\xd5\x88\xdd\xbb\xb9\x1a\xf1\x7a\xec\x67\x19\xab\xdc\xbf\xdb\x35\x6f\x87\xbf\x4f\x02\x96\xfc\x58\xb9\xdd\xbc\xdb\x31\xca\xd6\xec\x37\x6f\xef\xe8\x4b\x14\x6f\xc4\x5e\xd9\x91\x3f\xae\x72\x23\xdd\xde\xdd\x2e\x8b\x02\x2e\xa3\x8d\xc5\x23\x15\xbd\xc8\x83\x34\x4e\x32\x5a\x84\xf9\xe9\x50\x5c\x4f\x8b\x39\xd6\xc2\xa5\x5e\x98\xb9\x29\xc4\x23\x0e\x2c\x99\x45\x9c\xfd\x80\xf9\xc3\x33\x09\x85\x2e\x0c\x99\x9b\x7e\x67\xc9\x8c\x4a\xc8\x8d\xbd\x26\x7c\x3e\x0b\x95\xf7\x1a\xac\xc3\x94\x25\x9c\xad\x44\x6c\xf2\xc1\x98\x21\x22\x86\x8b\x7f\xc8\x67\x30\x96\xb2\xe4\x82\xd1\xa4\x16\x27\xe1\x69\xc8\x25\x81\x17\x14\x28\x12\x4e\xb8\x21\xa2\xba\xd4\xc4\xb9\x53\x36\x4c\x31\x3e\xe5\x4e\x22\xfa\xff\xc7\x91\xd6\x0f\xfb\xc2\x99\xc2\x5d\xc1\xf3\xbf\x9d\x5f\x78\x1e\xa9\x9e\xdf\xf5\x0e\x69\xb3\xd9\x74\xe4\x76\xca\x37\xf9\xd1\xeb\xbb\x57\xd0\x53\x1d\xec\xf6\x8e\xd5\x43\xa4\xfd\x3e\xee\xac\xd9\x04\xc8\x62\x22\xd9\x60\xb1\x5c\xc0\x1f\xc1\x11\xca\x62\x28\x5b\x63\xce\x52\x7a\xe3\xab\x47\xb7\x0a\xbe\xc2\x1a\x4f\x59\xdb\x87\xb5\x51\xc2\x82\x35\x0f\x00\xd6\xfc\x53\xb6\xb6\x0f\x3b\x7b\x70\xe5\x15\x4a\x0d\xfc\x24\x62\x0b\x7c\xe0\x0b\x4b\x6d\x3f\x2e\x2b\x55\x80\xd5\x5a\x0a\xd6\x0e\x5e\x6b\x80\xbe\x5e\xe1\xf2\x2e\xfd\xb8\x70\x10\x6b\x0f\x7a\x7a\xe7\xc8\x98\x63\xe3\x26\xcf\x3e\xa0\xf7\x76\xd4\x7a\xd4\xbc\x51\xd3\xeb\xe9\xb6\xb6\x1f\xf7\xf9\x02\x58\xff\xde\xc1\xdf\x02\xe3\x9d\x3d\xeb\x57\x0b\xc7\xa5\x14\x15\xea\x85\xc0\x7d\xb9\x96\x77\x72\x2d\x3f\xce\xb5\x65\xe3\xd1\x57\xdb\xdf\xd4\xb2\x71\xc0\xa1\x75\xa0\x66\x47\x4f\x33\x8e\x9e\xdf\x0d\x6e\x2d\xbf\xb1\xd0\xeb\x9b\xf7\x15\xd4\x1a\x48\x81\x52\x0b\x21\x82\xa7\x5f\xcc\xc4\xc5\x8a\xa5\xd2\xca\x71\xe9\xf1\x6e\xe9\x5f\xed\xbe\x32\x47\x35\x9f\x77\x25\x1a\xda\x51\x4a\x35\xd4\x29\x69\xa8\x1a\xb8\xf9\xab\x53\xd1\x94\x59\x3b\xbf\x10\x33\x34\xbf\xd5\x1d\x63\xf6\xd0\xad\x7b\xd0\x76\x3d\xc0\xc8\x12\x57\xa5\xa7\x0f\x34\x6e\x25\xf6\xef\xed\xe3\xb0\xb3\xdf\x2a\x43\x61\xee\xaa\x09\x07\xd5\x44\xcd\xa5\xbd\x76\xab\xad\x27\x27\x61\x4b\x94\x2f\xdd\x5a\xb9\x9b\x80\xab\x1d\x79\x70\xfd\x74\x1a\x5e\xb0\xc8\xf0\x13\xe4\xca\x9d\xee\x56\x47\xfa\x10\x89\x5b\x0a\x4b\x2f\xcb\xd4\x0d\x56\x5d\x5f\xec\x7a\x8a\x46\xf2\x7b\x7c\xb4\xb6\xae\xa8\x4a\x99\x71\x82\x1b\xeb\x55\x10\x8c\x8d\x90\x12\x10\x22\xd7\xae\xbc\x7c\xc4\xf0\x6b\x29\x43\x0a\xb4\xf6\x98\xc5\x12\x13\x3b\x14\x5a\xe1\xc2\xac\x3a\x5b\x91\x1b\xde\xd7\x5c\x8e\x12\x57\x45\xc5\x4a\x01\xa1\x1e\x18\x7e\x0b\x60\xf8\x8f\x2a\x8b\xf1\x50\xad\x45\xf1\x9e\x96\xc4\x81\x44\x9a\x43\x70\x2c\xec\xe4\x0d\x17\x33\x84\xb3\x06\x2e\x5c\x5d\xf4\x36\x89\xba\x53\xa7\x1e\x5f\xcb\xf9\x48\xfc\x26\x5a\x94\x51\xab\x41\xdf\xe5\x32\x84\x5e\xf4\xb4\xfc\x68\xc9\xa4\x68\x89\x24\x2f\xe3\xd8\x60\x1e\x2b\x5d\xb3\x67\x57\xf0\x21\x58\xc5\x6f\xa0\xe2\xf8\xaf\x24\xde\xff\x7a\xf1\x7d\x80\xf2\xf2\x2b\xde\x74\x3c\x45\x83\x95\x2f\x8c\xfc\x48\x06\xd0\xbf\x96\x6b\x71\xdf\x2a\x53\x9b\x0f\x18\x76\xb8\x78\x2e\xf8\x5c\x86\x62\xaf\xdc\xfa\x2a\xdb\xf9\xba\x9b\x63\xff\x57\xf3\x2c\x61\x93\xd9\xa4\x72\x57\xf6\xb1\xb1\x18\x78\x5b\xa9\x1c\x77\x65\xb1\xeb\x7d\x59\xcc\x47\x53\x26\xd3\x59\x26\x2c\x69\xbe\x24\xe5\x78\x10\x49\x38\xcf\x88\x18\xa1\xf0\x46\x7d\xf3\x71\x60\x93\x69\xb6\xe0\xca\x0c\x09\xbe\xf0\x72\x07\x3b\xe6\x21\x4e\x99\xf9\x9c\xb7\x97\x73\xe6\xb4\x32\x9f\xdf\xf9\xd9\x59\xc1\x70\x2e\x0d\x8f\x5a\xb4\x93\xab\x36\x7d\xad\x2e\x96\x07\x83\x9a\x84\x91\xd3\xdb\xc1\x7b\xab\x7b\x1e\x3c\xb6\x6c\xaf\x8e\x5d\xca\xca\x53\x04\xc8\x9d\x5f\x86\x91\x08\x83\x6d\x72\x1d\x25\x91\xcb\xad\x0e\x6a\x49\x8a\xe6\xd0\xe2\x0a\x19\x3e\x53\x8e\xaa\x27\xd8\x80\xca\x5e\xbb\x6d\x3b\x09\xa3\x12\xc6\x5d\x35\xc0\x6d\xbd\x5e\x19\xff\x93\xeb\x95\x31\x4b\xd3\xd5\x95\xca\xdb\x6b\x95\xca\xb3\xeb\x94\xca\xdb\x32\xa5\xb2\x8c\x2b\xc1\x77\xbc\xeb\xfa\x7f\xce\xa5\x53\x43\x2f\x6a\x9b\x46\xa4\x39\xa1\x35\x7e\xa1\x76\xfe\xfd\xf0\xf6\xc5\xd1\xab\xe3\xbf\xbc\x7f\xfb\xf2\xd5\x47\xc3\xf9\x37\x97\xcc\xeb\xae\xfd\xeb\xbf\x4a\xb8\xfe\x78\x0b\xf7\xc4\xce\xe2\x71\x80\x8b\x51\x22\xe7\x81\x3c\xee\xf8\xc0\x33\xff\x82\x99\x16\x36\x66\x06\xe7\xae\x3c\x53\xe1\x2e\xa4\xd9\xb4\x79\xfd\x33\x49\x16\x2d\xfb\xe6\x27\x4f\x51\x51\x5c\xf2\x97\x27\x8f\x79\x7e\xc8\x02\xc7\xdc\x6e\x2d\x5c\x0c\xc0\x78\x4c\xf0\xed\x5b\xf1\xca\x00\x5e\xa1\x23\x5b\xcb\xc4\xba\x50\xee\x19\x07\x60\x9f\xb3\x9a\x37\x09\xdc\x82\x17\x86\x44\xac\xec\x3a\xc5\x28\x12\x61\x5d\x14\x38\x33\xb6\x4b\xee\xc6\x29\x12\xe0\xa7\x02\x49\x7e\x72\x22\x8c\x26\xa3\x6c\xd5\xc8\xbe\x0e\xa8\x9a\x52\xee\xaf\xfa\x2e\x07\x12\xb4\xb0\xc1\x79\x8f\xf7\x25\xaf\xbf\x31\xa9\x48\x24\x77\x77\x8d\xd7\x76\x4e\x53\x11\x90\xda\x40\xda\x88\x57\x67\x6e\xca\xe2\xa6\xbc\xcd\x5a\xb4\x29\x6b\x1e\x56\xea\x8b\x94\xf2\xa1\x9d\x2e\x44\x45\x37\x9a\xf2\x41\x4a\xab\x2e\xc8\xe0\x90\xc0\xa6\x81\xbc\x57\x4d\xeb\xa5\x9c\xe9\x13\x96\x66\x2f\x6e\xe5\x50\x4f\x18\x12\x94\x7a\xc7\x7a\xc8\xbf\x77\x1e\xb1\x4b\xd1\x36\x0e\x80\x7d\x75\xd8\xa2\xbe\x71\x40\x96\x13\x21\x17\x0e\x55\xf3\xcd\xf4\x2c\x1c\x65\x8e\x4b\x82\xa3\x9a\xd4\xb7\x9f\x6a\xc8\x5e\xa2\xb3\x05\x7a\xae\xbc\xf4\x2c\x9b\x91\xbb\xef\x62\x1b\xde\xbe\x5a\x9e\x60\x2c\x53\x75\xf3\x41\xfc\xb6\xe5\x2a\xaf\x69\xc4\xc8\x8e\x22\x35\x2c\xa3\xc8\x00\x8a\x77\xa9\x0c\xa0\xf2\xb7\x7d\x2b\xce\xc1\xc7\x51\x3d\x60\x51\xa0\xbd\x39\xfc\x24\xd1\xd1\xbd\xad\x29\x06\x4b\xd3\x64\xc2\xa2\xc0\xba\x68\x86\xf3\x07\x6c\x52\x11\x3e\x98\x61\x5e\xbe\xfd\xc4\xb8\xf4\x31\xf1\xa7\x06\x72\xf4\x4b\x74\x53\x0d\xe6\x28\xc2\x19\x4d\x6b\x92\xd2\x49\xf0\x81\x25\x68\x09\x31\x44\xe4\xe6\x5b\x17\x33\xf5\x39\xa3\x27\xba\xdc\x1c\xe3\xa8\x27\x0e\x4c\x58\x3d\x75\x6d\xda\xd5\x60\x91\x33\xe4\x13\x48\x71\xca\xac\x2b\x2b\x32\xc5\xb8\xad\x82\x49\x65\x17\x55\xb6\x97\x53\x65\xdb\x42\xae\xb6\xb5\x5c\x6d\x0b\xb9\xda\x16\x3f\x4b\x2e\xaa\x6c\x17\xe5\x69\x5b\x5f\x54\x11\x0f\x08\xa9\x0b\xdb\xb9\xae\xcb\x69\xdb\xba\xd8\x32\x8a\x94\xcc\x25\x0c\x9f\x5c\xa3\x8b\x1d\x5b\x5b\xe2\x5e\x82\x71\xc0\x1d\xc9\xbb\x06\x78\x07\x3f\x44\x97\x77\x89\x8b\x04\xc7\xeb\xbc\xc6\x13\xd0\x88\xee\xc9\x88\x8d\x0a\x3f\x1c\xa7\x32\x5d\xdd\xef\x37\xef\x29\x14\x95\x96\xbc\x0f\x4b\x55\x8b\xd1\x1e\x12\x96\xea\x29\xc9\x12\x69\x9e\x25\x05\xd3\x93\x38\xd5\xcd\x81\xf9\x49\x50\x90\xc2\x14\x34\x95\xa2\x45\x4d\xd0\x6b\x75\x66\xb6\x28\x7d\x25\xde\x06\xe3\xf4\x1d\x30\x71\xaa\x6f\xc9\x57\x33\x9d\x8e\xc3\xcc\x59\x5b\x73\x65\xcd\xe6\xaf\x71\x18\x39\xe4\x74\x2f\x45\x8f\x4d\x62\x7a\xb7\x55\x89\x9f\x4a\xd1\xeb\x2a\x4a\x52\x4a\x47\x46\xad\x14\xaa\x97\xee\x8a\xe8\xe4\x8f\xd2\x01\x8c\x32\xea\x06\xcb\x92\x81\x9d\xe5\x64\x60\x47\xc8\xc0\x8e\x96\x81\x1d\x21\x03\x3b\xe2\x67\xe9\x9c\xbe\x53\x94\x82\x9d\x7e\xe1\x68\x5a\xf5\x8b\xae\x68\xa6\x85\xab\xd7\x17\xfe\xb8\x2c\x1c\x85\xb4\x18\x65\x7d\x6e\x3f\x4b\x1d\x9f\x2f\xab\x89\x64\x35\x6f\x90\x94\xb7\x7c\xa0\x12\x15\x41\x6b\x66\xfb\x07\x95\xf0\xaf\xca\xee\xf1\xec\xd6\x7a\xb3\xde\xc2\x71\xa3\x7c\x11\x54\xee\x6a\x61\x2f\x88\xcc\xe5\x90\xf4\xb3\x90\x4e\x1d\xe1\x04\x9d\x3a\xd6\xb7\xe8\x12\xec\xb1\x38\xa2\x3e\x7e\xf3\xee\xc3\xfb\x8f\x9f\x5f\xbd\x3c\x7e\xf7\xfe\xe5\x97\xb7\xaf\x8e\x5b\xc7\xc7\x69\x32\x3c\x1e\xf8\x51\x80\x0f\x1d\x95\x6e\xca\x3c\x6e\xdb\xc0\x13\x76\x5b\x9f\x91\x74\xe8\x8f\xd9\x8f\x7e\x14\x54\xf8\x8e\x2c\x89\x70\xaf\xe1\x37\xfa\x07\xf9\xbe\xdf\x11\x7a\x1f\xe2\x30\xca\x6e\x8b\xdf\xa0\x04\xbf\x65\xc7\xa6\x4d\xa0\xe4\x7c\x52\x3d\x3e\x7b\x3b\xf7\x42\x80\x37\xa2\xe1\x95\x69\x50\x40\xbc\x7c\x9c\x96\xa5\x43\x87\xc0\xd1\x4d\xc3\x4a\x2a\xb4\xf1\xca\xda\xdd\x53\xe1\x2d\x36\xbb\x32\x0d\x72\x48\xdf\x8e\x02\xdb\x02\x58\x7c\x5a\xd9\xfd\xa7\xad\x27\xf7\xd3\xfd\xf8\x74\xe5\xbe\x9b\xe8\xde\xae\xe3\x3b\x04\x29\x4e\x82\x30\xf2\xc7\x95\x9d\xdf\x7e\x72\x3f\x1a\xea\x3d\xb5\xbb\x32\x01\xf2\x68\xdf\xab\x9e\x7a\x33\x99\x8e\xc3\x61\xb8\xba\xaa\x2a\x62\x79\x1b\x6d\xb5\x4b\xd0\xa6\xf1\x65\x0d\x8f\xee\xdd\x93\xa6\xbe\x5c\xb9\xf3\x26\xba\xf7\x3a\x3c\x9f\x7e\x4b\x56\x1f\x1a\x1b\xbb\xdb\x0c\xcb\x63\x82\xf4\xdb\xcc\x8f\xb2\x70\xcc\x6a\xc6\xe6\xe9\xbd\x74\xff\xdf\x45\xc3\x2b\x93\xa0\x80\xf8\xed\x34\xc9\x13\x13\xdc\xef\x35\x74\x68\xb7\xee\x91\x0e\xbf\xaf\x4e\x87\x02\xe2\xb7\xa3\xc3\x1e\x81\xcb\xce\x12\x96\x9e\xc5\xe3\x6a\xab\xef\x69\xfb\x7e\x74\xea\x67\xd9\xf2\xca\x94\x28\xa2\x7e\x3b\x52\x3c\x15\xf0\xc2\x49\x35\x3b\x6c\xef\xdd\xcf\xb4\xfa\x39\x9c\xac\xce\x0a\x16\xc2\xb7\xb4\x2d\x85\x9d\x3a\xcb\x86\x9f\xeb\xfa\xff\xb4\x73\x3f\xfd\xff\x92\x0d\x57\x37\x2b\xf3\x38\xdf\x6e\xf8\xdb\xc2\x4c\x95\x67\xba\x1c\x7c\x25\x15\xee\x61\xe2\x3a\x63\x13\x76\xa4\xda\x5e\x9d\x1a\x25\xe8\xdf\x92\x20\x1d\x1b\x62\xa7\x35\xa8\xa1\xc8\x3d\x4c\x17\x26\x45\x3a\xad\xc1\xea\x24\x29\xeb\xc0\x2d\x69\xb2\x9d\x07\x39\xac\xa6\xc9\xf6\x3d\x4c\x1d\x36\x4d\x6e\x20\x34\x65\x1d\xb8\x25\x4d\x76\xf2\x20\x6b\x48\x72\x0f\x93\x88\x4d\x92\xd5\x29\x52\x82\xfe\x2d\x09\x22\xcc\xb5\xe1\x6c\xc0\xce\xd8\x38\x9c\xd7\xd0\xa3\x73\xd7\xf4\x08\xa3\x8c\x25\xd3\x78\xec\x67\xec\x48\xb6\xff\x92\xee\x39\xae\x4e\x9a\x62\x47\x6e\x49\x19\x61\xc5\x25\x7e\x18\x0d\xea\x56\x06\xdb\xdb\xf7\x48\x97\x8f\xd4\xfa\xea\xe4\xc8\x63\x5f\x3e\xe7\xde\x29\xae\x7f\xf5\x93\xc9\x5d\x20\x3a\xbc\x6f\x44\x8f\xe2\x78\xf5\x85\x71\x09\xa2\xb7\x62\x2f\x61\x1c\x5f\x84\x49\x18\x84\x69\x0d\x7b\xdd\xf9\x0e\x99\x41\x89\x9f\xa9\xf5\xd5\x89\x91\xc7\xfe\xbe\xd6\xa1\x06\xae\xef\xfc\xd3\x49\xd5\x85\xbd\x95\x30\xbd\x77\xfe\x7a\x13\x8d\x58\x12\xc5\x77\x81\xeb\xbd\x0b\xed\x87\xb1\x9f\xde\x0d\x59\x83\xdb\x48\x83\x58\x20\xa5\xec\xb7\x19\x39\x68\xd7\x08\xc4\xfd\x6c\x96\x7e\x52\x4d\xaf\x4e\x8c\x12\xec\x0d\x81\x58\xf2\xbf\xdc\xa1\x4d\x6d\xf0\x82\xdb\xdd\xb6\x9d\x45\xb3\x94\x05\xf9\x5b\xb4\x83\x30\x65\xc3\xec\x63\x78\x7a\x96\x51\xd3\xb5\xe5\xde\xb2\x91\x2c\x76\x83\x83\x1b\x75\xf7\xad\xfa\x64\xa0\x7d\xe3\x93\x07\x42\x30\xae\xde\x6f\xdf\x7e\xdc\xa2\x61\x41\xa7\x07\x89\xca\x8f\x58\x4d\xbd\x2e\xe4\x2c\xd9\x06\x1f\x68\xd8\x5a\x57\x01\x1a\xd6\xb7\xfa\x6e\x4d\x5d\xbb\xf3\x65\x95\x0f\xc8\x83\xd9\x18\x8d\x6e\x1e\xc9\x66\xc2\xd3\xcd\x82\x38\x1c\xc5\x72\x63\x36\xca\x2c\x32\xca\x86\xc4\x58\x5a\x82\xa2\x58\x09\x79\x17\xba\x5c\xa0\x14\x12\x6e\xd1\xa5\xf2\x71\x6d\x84\x82\xdb\xb1\xe8\xfd\xf1\xd4\x83\x9b\x93\xc3\xb8\xbf\x85\x5e\xb1\xe6\x8d\x2d\x72\x93\xb5\xc3\xe0\x8b\x54\x73\x5c\x44\xd4\x21\x7c\x3c\x41\x00\x31\x02\xa1\xd0\xd9\x31\x1f\xb4\x7d\xe3\x21\x54\x0f\xe6\x1e\x8c\x63\x0f\xce\x42\xfb\x0a\xf5\x38\xd6\xf7\xc3\xf8\x37\xa8\x48\xeb\x3c\xf7\x2c\xd4\xb9\xfc\x1b\x7c\xe3\x5a\x18\xff\x4f\x84\xc8\x18\xc7\xf0\xcc\x02\x4d\xa7\xfb\x13\x7c\x9c\x72\x1c\xc3\x06\xaf\xfd\xfc\xf9\x73\x30\x42\xe3\x1b\x7d\x76\xfc\xde\x24\x0c\xfa\x1e\xcc\x5d\x0a\x91\x8d\x98\xf0\xda\x1b\x66\x0d\xf4\x26\x45\x34\x26\x61\x60\xdf\x47\xd6\x67\xd9\xb1\xf4\xc8\xa0\x13\x6e\xce\x77\xff\x9c\x84\x78\xce\x09\x91\xef\xad\x20\x42\x19\x7d\xaa\x08\x21\x8e\xf4\x2d\x7f\xe1\x32\x5e\x1a\x95\x47\xea\x0a\x10\x19\xcb\xb9\xe4\x5a\xe5\x76\xbd\x82\x72\x46\x4e\xe0\x72\xc8\x3a\xd4\x56\x5e\x33\xdc\x63\xa8\x88\x7c\xec\x87\x70\x32\x99\xe1\x8d\x66\xf7\x1a\xf1\x9d\xfa\x61\x52\x36\xfd\x15\x75\x00\x3d\x1b\x84\xa5\x14\x38\x51\x4a\x80\xb5\xb4\x81\xb8\x49\x60\x04\x68\x18\x69\x86\x1b\xa9\x96\x45\x04\x1b\x72\xd8\x26\x77\x56\x7d\x45\x01\x36\xa1\xed\xc1\x54\xa6\xe2\x15\x49\x5e\x0d\x7d\x6e\xd8\xa5\x70\x89\x89\xb8\x84\xc1\x21\xb4\x60\x1f\xc8\xd3\x4d\xb0\x6e\x08\xcf\x20\x72\xa9\x06\xb9\x75\x8f\x9c\xa9\x09\x6f\x63\x23\xec\x9b\x9a\x06\x4b\xe6\x39\x8b\x27\x72\x29\x1b\xd8\x8f\xff\xf0\x94\x7e\xe9\x30\xd7\x5e\xf0\xff\xee\x13\xc0\x85\x9f\x84\x7e\x34\xac\xd9\x11\x7f\xbc\x7d\x47\x13\x80\x3d\xe4\x1c\xb3\x8b\x65\x0c\x07\x0b\xc9\x52\xd1\x52\x80\x8d\xb1\xba\x80\x43\x0a\xe8\x9d\xfe\x96\x64\xce\x85\x0b\xfb\x70\x21\x86\x2e\x3f\x20\xb5\x57\x54\xbf\xfb\x80\xd0\xbd\xc2\x1a\xb7\x87\x9d\x3b\x1a\x0e\x0a\x8a\x25\x2e\x0a\xc6\xc6\xa8\x70\x31\x13\x11\xb3\x84\x8f\x99\x50\xb4\x13\x33\x88\x14\x97\xc9\xcd\xb6\xca\x62\x7e\x64\xe6\xd2\x6d\x14\x15\xc9\x7a\x9c\xf9\x2a\xf8\x3e\x5e\x2e\xa3\x38\x1e\xea\x9d\x88\x78\x94\xbf\xb4\x2d\x64\x74\x63\x43\x48\xa9\x39\x73\x3d\x0c\xd3\x9f\xfc\x9f\xc4\x0b\x13\xcb\x71\x90\xa4\x6a\x29\xff\x50\x67\x7b\x61\xdf\x75\xcd\x79\x0c\xd1\x96\xb4\x80\x4d\xec\xa3\x9e\x96\xb0\xc7\x1b\x5d\x51\x6a\x0b\x36\x36\x26\x3a\x93\x77\x52\xe5\xad\xcb\xc7\x30\x08\x44\x69\x60\x91\x07\x60\xc6\x47\xf9\xee\x9d\x8f\x47\x9a\x08\x1e\x84\x82\x29\x52\xf7\x1f\x4a\x10\xde\xdb\x09\xbd\x36\x22\x43\x28\xcf\x26\xb0\xc5\x13\x37\xa1\xed\x56\x48\x73\xed\x35\xd5\xbb\x91\xe6\xef\x26\x70\xb6\x8c\x59\x32\x35\x09\x23\xf5\xe9\xcf\x57\x96\x26\xd8\xda\x82\xd7\x61\x14\x50\x60\x1f\xf4\x48\x1e\xaa\xd8\x9e\xea\x46\xa2\x62\x3a\xc5\x6e\x5a\x54\xcc\xf0\x70\xe2\xde\xaa\xc8\x36\x59\x66\x12\x46\x18\x43\x74\x2e\xeb\x6a\x96\x28\xc5\xe9\x48\x58\xff\x14\xd4\x65\xe2\x87\x18\xc8\x45\xc5\xef\x03\xd3\x84\xac\x41\xca\xcd\xbd\xec\x8d\xac\x14\x46\xf0\x5c\x62\x48\x78\xe5\x30\x52\x25\xfd\x39\x3c\x53\x25\xcb\x70\x2f\x7d\xeb\x7b\x79\x71\xbe\x15\xf5\x2b\x65\xf5\x8f\x36\x22\xd7\x22\xfa\x07\x18\x25\x69\xae\x71\x71\xe2\x40\xfa\x15\x5a\xa5\xf6\x76\xf5\xdd\xda\xe6\x37\xdd\x90\xab\x3a\x3f\xc5\x5b\x01\x85\x4d\xc6\xfb\x8a\x02\x37\xf1\xa7\xd4\x96\xb8\x1b\x83\x91\x14\xc9\x7b\xdf\x7c\x79\x1a\x63\xbd\x70\xc4\x94\x49\x4f\x68\x1a\xd7\x5d\x28\x99\xc3\x2b\x0e\x47\xed\x9d\xe1\x7f\xa8\x92\x17\xa1\xfc\xd3\x2c\x9e\x7a\xf8\x7a\x0b\x31\x39\xbd\x40\xd0\x85\x0d\x23\x9f\x7e\xca\x72\x1c\x4a\xd9\x7d\x3d\x17\x9e\x41\x07\x0e\xc1\x11\x55\x14\x00\x02\xd8\xf2\xf8\xfc\xb8\x0f\x7c\x95\xb3\x2d\x1e\xc0\xda\xe0\xf0\x74\xf8\x4f\x6b\x12\xe1\x4d\xa0\x5d\x3c\xf1\xe7\x4e\xcb\xa3\xef\x21\x0b\xc7\x0e\x35\xb0\x29\x5f\x2e\xd8\x22\xec\x5d\xf8\xa6\xad\x3a\x79\x2d\xca\x58\x5c\xb9\x66\xe0\xd0\x9c\xc1\x82\xc5\x69\x65\x45\xe8\x6e\x40\x88\x6f\x04\x71\xec\x6c\x01\xc4\xa2\x15\xb2\x57\x7b\x09\xf9\xbb\xaf\x8b\x07\x38\xe0\x59\x38\x3c\x7f\x13\x0d\x13\xbc\x7f\x7e\x53\x50\x43\x05\xea\x13\x92\x04\xa3\xdd\xb4\x5b\x72\x84\x70\xe5\xa2\x22\xb5\xb1\x5d\x2b\x5d\xc5\xa9\x61\x1d\x2b\xbd\x43\x01\x15\xee\x94\x8d\x87\xf1\x2c\xca\xcc\xf8\xc5\x78\x59\xa6\xdc\x48\x51\x56\x09\xef\x56\xaa\x5f\xdc\x12\x0c\x99\xe7\x7b\x5b\x2a\xb0\x21\xfe\x1b\x3f\x64\xc8\x15\x51\xaa\xdb\xa5\xda\x18\xa0\x91\x97\xc3\xfd\x22\xa9\xc0\xb1\x50\x5f\x56\xd1\xd7\x8a\xb0\xca\x33\xc9\xd4\x51\x51\x80\x24\x26\x88\x57\x24\x01\x38\x42\x24\xad\x71\x2e\xa3\x8a\xab\x6f\x25\x3f\x0c\xd3\xd7\x61\x14\x66\xcc\x11\x92\x63\x04\x9e\x52\x5d\x61\x53\xc2\x5b\xbc\x61\x24\x90\xd0\x52\x48\x29\x42\xf8\x0e\x44\x21\xc4\x0d\xcb\x8c\xc6\x71\x9c\x90\xa4\x5a\x65\x90\xda\xb9\x6d\x0f\x1b\xac\x96\x6d\xd8\x80\xb6\xbc\x60\x99\x17\x5c\x84\x43\x22\xeb\x28\x99\x75\x4d\xa1\x35\x0d\x1b\x0b\x7d\x89\x1a\x4f\x5a\xaf\xc2\x5f\x23\xb3\xbe\x1a\xfa\x1c\xea\x26\x81\x5a\x09\xfd\x4d\x8e\xfe\x96\xad\x73\x0c\x0e\x11\x55\xcc\xab\x63\xc6\x1b\xe4\x3c\x2b\xbf\xdf\x73\x2d\x47\x28\x39\x91\x5a\x3d\xaf\x57\x4d\xf5\x4b\x55\xa4\x98\x4c\xe3\x4b\xbc\x84\x6f\xd0\x13\x3f\xc7\xf1\x29\xf1\x94\xac\xfd\xf6\x27\x25\xff\x20\x42\x72\x76\xa9\xbd\x2d\xfd\xa6\x73\xbb\xe5\x11\x44\x6b\x0f\x0b\x9b\x78\xde\x85\x96\xa8\x7d\x08\x0e\x01\x78\xde\x45\xe5\x73\x08\xed\x16\xec\x83\x4e\xdb\x85\x43\xd8\xb5\x52\xf8\x74\xd4\x81\x7d\x3e\xf1\xac\x97\x35\x27\x20\xef\xc3\xa6\x95\xb9\x49\xb9\x7c\x05\x77\xf3\x16\x71\x4b\xcd\x1a\x0c\xae\x3b\xaf\x1d\x07\xa5\x54\xfd\x41\xba\xc2\x80\xf0\xaa\x6d\x59\x55\xf6\xa3\x6a\x74\x5a\xf6\xf0\x94\x8e\x4f\x4b\xf0\x62\x5b\x2a\x1a\x93\x12\xae\x68\x6f\xbd\x0b\x6d\xdc\x8c\x57\x31\xe2\x0c\xda\x18\x85\x76\x2b\xca\x74\x8c\x32\x9d\x03\xf3\x31\x39\xad\x0b\xe1\x10\x36\xa9\xd0\xbe\x44\xa8\x64\xaf\xf2\xbe\x2e\xc1\xdd\xd5\x62\xda\xda\x73\xd5\xea\x42\x0d\x8b\xb5\xaa\x36\x86\xa7\xe3\xd2\x41\x42\xa9\xbd\x71\x8f\x87\xc8\x7f\xb0\x1d\x84\x3f\xf8\xb6\xc1\x77\xdc\x30\xe0\xe8\x58\x4b\x4f\x7b\x65\x5a\xb1\x10\xfd\x27\xdf\x04\xf8\x07\x2f\xff\xef\x89\xe6\x72\x21\xca\xd9\xbb\x4c\xbe\x9f\xfc\xb1\x4e\xe0\x27\x61\x54\x73\xf6\xf2\xf4\x8e\x36\xfb\x27\x7e\x96\x84\x73\x23\x24\xa2\x43\xbb\x40\x3c\x55\x85\x22\xb4\x23\xa5\x5a\xb1\x2c\x36\xdb\x1e\x6e\xff\x2f\xb3\xdd\x8c\x3d\x2a\xdd\x6b\xa6\xf6\x3c\xf9\xe2\x83\x07\x59\xe2\x47\xa9\x88\x02\xa1\x6d\xbf\x89\x8b\xc1\x32\xe0\x19\x4c\x0e\x0a\x17\xe1\x7f\x15\xd8\x44\x1e\x24\xf1\x25\xbe\xa2\x2a\x60\x90\xdd\x67\xad\x4d\x61\x63\xe3\x57\xce\xcc\x07\xc6\x15\xf3\xf8\xb2\xf7\x6b\x5f\x75\xbe\xf7\x6b\x5f\xdf\x44\xb7\x83\x25\x2a\xc0\x79\x13\x90\xd0\x77\x02\x6b\xf6\x09\xd4\xf9\x78\x71\x1e\x7d\xf2\x1d\x8f\x76\xef\x7a\xfb\x28\x14\xd7\x0d\x2b\x77\x90\x96\x3e\x4b\x16\x17\x0f\x6f\x28\x28\xc1\xf6\xb1\x0e\x53\x5b\xed\xad\xf2\x64\xef\xc6\x2e\x50\xb8\xe1\x54\x09\x59\x88\x22\x05\xcd\x12\x34\x81\x2e\x7c\x8d\xfc\x09\xdb\x87\x86\x4c\x6a\x5c\x99\x9c\x22\xba\xec\xe0\xf6\x86\x9e\xae\xe5\x8b\x2c\x4b\x48\x53\xae\xdb\x52\xac\x26\xfe\x94\x44\x4a\x59\x99\x41\xcc\x95\x33\x86\xa2\x91\x49\xb3\xe8\x3c\x8a\xf1\x11\x47\x35\x88\xa8\x20\xc5\x2e\x8e\xf8\xab\x5e\x1f\xea\xf5\x61\x7f\x29\x0a\xf5\x1a\x03\x44\x82\x36\xf0\xd6\xb7\xfa\x14\xf7\x9e\x3a\x49\x71\x70\x24\x01\xd0\x4b\xd0\x51\x6f\x14\xf0\xce\x53\xa4\xa9\x00\x36\xa0\xd1\xf0\x50\xb9\x20\x39\xf0\xfd\xa5\x73\xb6\x10\x2b\x3b\x3a\xea\xb2\x8f\xbe\x64\x7f\x1e\x76\x75\x8f\x94\xd2\x12\x99\xca\x87\x05\x61\xa6\x04\x93\x9a\x21\x0a\x35\xa7\xb3\x94\xcb\xae\x5b\xf2\xb6\x1a\x6d\x58\x39\x21\x9e\x2f\xc1\x0f\xf4\x5b\xc8\xb5\x8e\x07\x83\x7d\x6a\x2a\x7a\x2b\xa1\x39\x36\x83\x97\x3d\x2c\xee\xe3\x49\x45\x41\x68\x50\xb0\x16\x81\x85\x39\x78\x77\xca\x1d\xfa\xb5\x6c\xa9\xc5\xf1\x4d\x00\x15\x3c\x24\xf0\xf8\x78\x94\x2f\xa6\x69\x08\x90\x8e\x67\x7e\xea\xd0\xb8\x39\x01\xaf\x8f\xa6\x13\x1f\x40\xd7\xcd\x53\xba\x94\xca\x72\x01\xc2\x29\x67\xbc\x89\x8d\x84\xcc\xc7\x5a\xd2\x74\xd4\x01\xc1\xec\x28\x6e\x87\xe0\xc8\x4a\xb7\x60\xd7\x63\xd7\x23\x0c\x5c\xd8\x17\x23\x6d\x8c\x89\x89\xa1\x96\xa3\x95\x70\xd4\xd5\x8e\x8d\x96\x0c\x3e\x35\xdb\x18\xc6\x53\x33\x8a\x55\x3e\x5a\x8f\x54\x24\x3a\x5c\xb0\x60\x40\x87\xfe\x18\xe9\x14\xaa\x8a\x84\x51\xa7\x8a\x66\x25\x52\x46\x1f\xed\xb1\x29\x99\xbc\xbe\x83\xc3\xca\x7d\x9d\x46\x04\xec\xb4\x93\xf8\xc1\x9d\x9f\x7e\x54\x4d\x96\x89\x1f\x74\x02\x76\xaa\x4f\x40\x04\x02\x72\x0b\xe1\xc3\x1b\xd8\x82\xf6\x5e\xeb\x40\x44\x1d\xc3\xd2\xd0\xe5\x49\x72\x71\xfa\xe1\x4d\x89\xc9\x7a\x8f\x2e\x2a\xe5\xfe\xca\xc9\xe9\xe0\x47\x3f\x0d\xd3\x5a\xa7\x66\x59\xe8\x68\x1c\xf3\xdc\x9b\x3a\x36\x93\x12\xab\x71\x3d\xde\x7d\x7c\x73\xb7\x66\x8e\x5f\x25\xe0\x4e\xa7\x75\xe3\x10\x25\x03\xdd\xf3\x9a\x38\x15\x3b\x37\x0e\x00\x52\x4f\x92\x36\x86\xff\x10\x2e\xf0\x37\x5c\x1c\xe8\x98\x4d\xc9\xe9\xe0\xcf\xfe\x64\xe2\x3b\x0b\x6d\xa3\x60\xfb\xcb\xcc\x42\x1a\x57\xa9\x68\x4f\x39\x2c\x9a\x80\x16\x39\x7b\x20\x39\x1d\xc8\xbd\x3a\x15\x45\x4f\x9c\x2a\x40\x97\xda\x74\xe4\x86\xff\xf2\x13\x20\x35\x3e\xc2\xc6\x93\xd3\x01\x35\x4d\xdb\x7b\x6e\x33\xf1\xc0\x61\x51\x70\x6b\x78\x1c\x5f\xb7\x99\x28\x83\x0b\xe0\x54\xa1\x8c\x6d\x35\x4f\xb1\x53\xcd\x53\xa3\xc8\x20\x57\x64\x40\x45\x06\x46\x91\x78\xea\x0f\x29\x12\xec\x4a\xa4\x2e\x59\x5e\x51\x13\x02\x1e\x35\x24\x7e\xd8\xd3\xb0\xd2\x20\x99\xb6\xaf\xa8\x2e\x1f\x84\xc4\xc9\x94\x47\x8e\xe8\x17\x74\xe1\xb4\x90\xca\xbb\x36\x28\xa4\xea\xde\x88\x2f\xa3\x84\xda\x86\xa4\x73\x85\x46\x43\x98\x60\xfa\x30\xf0\x74\xd0\x24\xe6\xe9\x2a\x9e\x34\xe7\xa8\xe4\x74\xc0\xd7\x62\x0e\xee\xff\x3f\x30\x99\xea\xd3\x74\x1c\x46\xcc\x49\xf1\x4f\xb9\x5f\x2f\x52\x2e\x35\x59\x2e\x92\x83\x93\xdf\x35\x03\xe4\x46\x73\x25\x69\x0f\x7a\x79\xce\xa0\x32\x27\xf4\xa8\x9d\x03\xbd\x94\x0d\x29\x38\x1b\x9a\x5a\x56\x68\x48\x58\x5e\xf2\x6a\xd9\x95\x3a\xd6\x13\x1e\xac\xd8\x27\x5a\x20\x63\x46\x33\x81\x6f\xdf\xb4\xc7\xf7\xa9\x99\x75\x6a\x65\x0d\xcc\xac\x81\x91\x25\x2c\x67\xe8\x02\x51\xdd\x49\x44\x4b\xa7\x3a\xe9\x54\x24\x0d\x74\xd2\x40\x24\x11\x40\xcd\x2e\xed\x6b\x59\x54\x22\x6e\xb3\xa8\xc4\xd9\x66\x51\x89\xae\xcd\xa2\x32\x18\x28\x12\x38\xcf\x80\x68\xfb\xa0\x26\x92\x73\x5f\xd7\xe0\xac\x65\x66\x19\xa9\xff\x8a\x17\x53\x72\x33\xe5\x72\x80\xf3\x93\x4c\xf9\xbd\x97\x82\xad\xf0\x1d\x1c\xe0\x56\xd8\xde\x5a\x66\x02\xbe\x3b\x6f\xd6\x9a\x1d\xf1\x83\x12\x95\x90\x99\xda\x20\xb4\x0f\xde\x1c\x27\x83\x1f\xf0\x46\x0a\xb9\x8f\x6f\x6c\x64\xb0\x0f\x99\x0b\xeb\x60\x8a\xf6\x45\x4b\xef\x27\x3b\x21\x6c\x40\x24\x17\x8f\x51\xdf\x28\xd5\x36\x76\x9d\xf3\x79\x9d\x1c\x84\x62\xed\xed\x5c\x89\x0e\x95\xb0\x24\x66\x99\x9d\x39\xc5\xa7\xc4\x48\x03\x61\xe1\xf5\x5d\xde\xd9\x4d\x08\x61\x8b\xaf\xfb\xd6\x21\xf2\xe0\xa2\xe5\xc1\x45\xdb\x83\x8b\x8e\x07\x17\xdb\xea\xd6\x42\x19\xc3\x7d\x07\xdf\xa8\x1b\x32\xc5\xbc\x7c\x26\xc8\xad\xad\xe6\x75\x9d\xfb\x0e\x9e\x46\x2b\x79\xeb\x8f\x67\xd5\xae\xfa\x9d\xf6\x93\xbb\x72\xd5\x57\xf7\x19\x50\x96\x50\x8f\xc2\x21\x0c\xe4\xea\x76\x5f\xfb\x04\x45\x7c\xb2\xf6\xa5\xb7\xfd\x24\x8c\x9c\x68\xe0\xa9\xdb\x42\xae\x59\x74\x6e\x4f\x90\xda\x08\x1a\x56\x65\x84\x3a\xaa\xb2\x39\x61\xfa\x62\xc6\x9c\xd3\xdc\xb4\xdc\x15\x02\xa4\x5c\xf9\xfd\x01\x3c\xa1\x18\xc8\xb9\x12\x9b\x13\x2d\x0d\x44\x4b\x43\x6a\x69\x80\x7b\xc5\x75\x9a\xa4\x12\x57\x01\x81\xa3\xac\x66\x24\x39\x1f\xd5\x31\xe0\x77\xf0\x7e\xba\x13\x26\x09\xc4\x18\xbe\xf4\x33\x66\xe8\x5a\xce\x1d\x1b\xbc\x24\x6c\x76\xc1\xf7\x4a\x28\xa6\xf6\xcf\x53\x96\x7d\x0e\x27\xcc\xf1\x61\x03\x06\xb0\x0e\x99\xeb\x41\x50\x47\x9a\xef\x70\x3a\xfd\x87\x97\x4d\xce\x6a\x5f\xaf\x4c\x41\xd2\xbf\xce\xd5\xf9\xae\x8f\x5e\x4a\xb8\xcf\xfb\xed\x9b\x7c\xd7\xca\xc7\x8d\xd4\x06\xbd\x1b\xd5\x70\x71\xa8\xbe\x5e\x49\xc7\x84\x41\x59\x95\x41\xae\xca\x40\x54\x91\x52\x73\x0e\x61\x24\xb1\x23\x30\x98\xe2\x1b\xfb\xb8\xbd\xf3\xbb\x11\xd9\x73\x14\xd9\x73\x69\xde\xe6\xde\x97\x1d\x52\x33\xbc\xc0\x41\xe9\xf1\x60\x85\xe4\x22\xba\x28\xad\x58\x9f\x63\xbb\x92\xb4\x7e\x07\xdf\x81\x3b\xbc\x4b\xb4\x43\x3c\x49\x4e\x7d\x2f\xa0\x0b\x5b\xbd\xcd\x8d\xfe\xa1\x73\xb8\xff\xf7\x60\xe3\xef\xcd\xc3\xbf\x07\xeb\xdf\xf0\xcf\x86\xeb\x1c\xee\xf7\xd8\xab\x3e\xe6\xf3\xdf\x87\x5b\xa7\xe2\xc2\x29\xfb\x51\x48\xfe\x47\x76\xfa\x6a\x3e\x75\x12\xf6\xa2\x99\xc6\xb3\x64\xc8\x3c\x68\x9c\x36\xac\x95\xda\xef\x2c\x89\x9d\xc1\x52\xb3\xf2\x40\x1b\xe5\xfa\x38\x05\xd7\x0f\xa5\xb5\xf3\xea\x84\x9b\xfd\xca\xc4\x27\x30\x77\x2d\x7a\x03\x2e\x7b\xbc\xb7\x63\x3f\xcd\xe4\xa3\x82\x09\xfb\xd1\xfa\xdd\xf2\x60\x6b\x0b\xd2\xa1\x1f\x89\x7d\x7d\xce\x66\x11\x9b\x67\x40\x83\x83\x02\x23\x98\xd6\x9f\x60\x61\x7c\xa1\x39\xca\x60\xe2\x67\xc3\x33\x14\x1f\xb9\x14\xab\xc8\x97\xf5\x07\x29\x35\x46\xaf\xc8\x4f\x13\x36\x64\xf8\x54\xae\xac\x60\xb4\xe8\x71\xe1\xf4\xa3\x85\xed\x26\xc2\x6b\xab\xf7\xe6\x52\xb9\xae\x17\xc7\x12\x1a\xf2\x30\x8e\xd2\xcc\xc7\x07\xfc\xa2\x00\x8c\xc7\x65\x64\x95\xdf\xe8\x45\x04\x5e\x45\xb5\x29\x83\x67\xc4\x49\x2a\x22\xb3\x1f\xd1\xc3\x4c\x61\x34\x9d\x65\xf4\x02\x2c\x82\x47\xb7\x02\x32\x2a\xe8\x88\x88\xac\x0f\x1a\x4b\xaa\xf9\x46\x87\xe2\x10\x17\x3e\xe3\x91\x68\x29\xa5\x87\x7e\x1f\xc1\xa0\xa9\xfd\x92\x1d\x7f\x22\x86\x8a\xcd\xd9\xd0\xf1\xd5\xab\x7b\x8f\x1e\x81\x33\x98\x88\x61\xc3\xbc\x81\xbe\xf2\x84\x2e\x0d\x03\x7c\x1f\x69\xd2\x44\xb2\xb8\xf0\x1c\x06\xa1\xf0\x8c\xf0\x6d\x42\x33\xf9\x38\x6d\xe9\xd0\x12\x18\x71\xc0\x30\x08\x3d\x18\xa4\xae\x79\xdd\x9a\x9c\x51\xd0\x75\x71\xa3\x0b\x83\x14\x69\x37\x8c\xfd\x31\x4b\x87\x8c\x9e\x04\x9e\x26\xec\x22\x8c\x67\xa9\x0e\x65\x0f\xf2\x76\x74\x8a\x57\x55\x01\x2b\x1a\x6b\x73\xec\x00\x76\xdd\x9f\xf4\x5a\x7d\x72\x55\xa5\xfe\x0e\x26\xe2\xb9\x1b\x3d\x46\x9a\x72\xc4\x59\xd5\xd8\x4d\x6e\x8a\xdd\xc4\xd6\xd5\xc4\x6e\x7a\x28\xf1\x29\x72\xde\x34\xa7\xaa\x40\x4a\x32\xa1\x84\x21\x63\xe9\x23\x9b\xd1\x29\xd3\xd7\x70\x1f\x42\x0f\xe6\xfb\xb7\xbf\x0c\xc7\x25\x70\x30\x71\xaf\xac\xc3\x41\x21\xe7\x86\x5c\x9b\xef\x0b\xbc\x08\x02\xe1\x18\x83\x5c\x88\x6c\x87\xf3\x27\xb7\xfe\x06\xb9\x27\x23\x72\x6c\x60\x9c\x75\xde\x90\x01\xca\x86\x5f\x62\xf6\x69\xca\x86\xa1\x3f\x86\x78\x9a\x85\x93\xf0\x77\x7a\x25\x8d\xab\x9f\x38\x1a\x2f\x38\xfb\x86\xd1\xe9\x98\xd1\x60\x37\xa9\xca\xfb\xec\x8c\x25\x97\x61\x8a\x6f\x69\xea\x81\xc1\x67\xb2\x63\x7a\xbd\x53\x32\x0b\x17\xfd\x84\xfd\x1a\x87\x11\x26\x13\x4e\x4d\xe3\x3c\x49\xbd\xb9\x44\xd7\x17\x7e\xeb\xb5\xfa\x62\xdc\x0e\x51\x91\xf3\x84\xe6\x5c\x3b\x8b\x8a\xb9\x41\x27\x70\x13\x04\x7e\xd3\x0f\xb6\x94\x6c\x09\x01\x40\xe1\x59\xaf\x98\x0c\x6f\x69\xb9\xa7\x3d\x27\xe6\x70\x38\x7d\x9b\x48\xa5\xb8\x39\x37\xf6\x84\x8c\x39\x23\xa5\xf7\x1f\x1a\x0d\x23\xf3\xaa\xe2\x9e\xe1\xde\x77\xf0\x22\xba\x93\x55\xef\xc6\xbc\xa2\x03\xdf\xc1\x27\x65\xc5\x57\x09\x44\x7f\xdf\xc6\x43\xbf\x26\x72\xf1\xde\x53\xe1\xe2\x91\x3b\x94\x52\x21\x8d\x46\x71\x32\xf1\xb3\x97\x26\xb0\xdc\xd9\xd4\xed\xa3\x1f\xad\x1e\xfc\xa9\xbc\x8f\xf7\x15\x02\x6c\xf5\x60\x9a\x55\xf8\xdd\xc1\x8b\x06\xe3\xfa\x01\xdd\xde\xeb\x2c\x33\xa0\xa5\x23\xb9\xe2\x9b\x02\x04\x09\x15\xe3\x28\xac\xb1\x8c\xb7\xf7\xee\x3c\x3e\xe1\xea\xa1\x3c\xab\x70\xbe\x93\xb7\x05\xb8\xd1\x12\xa6\x61\x1c\xbd\x0e\xe7\x35\x27\x98\x4f\x5b\x77\x1e\x49\x6f\xf5\x40\xd0\x15\x28\xdf\xc9\x53\x03\x0a\xe8\x87\x84\x8d\xea\x22\x79\xde\xfd\x73\x13\xab\x07\x84\xae\xc2\xf9\x76\x94\xd8\xcd\x41\xfd\x18\xcf\x6a\x5e\x87\x79\xda\x7a\x7c\xd7\x84\x18\xdd\x38\x5e\x7e\x0e\xe5\x92\xf8\x71\xb9\x49\xef\x8f\x15\x7c\x85\x37\x13\xb1\x28\xab\x59\xa1\x3f\xbd\xb1\xe6\x25\xbd\xf1\xe7\x24\x9e\x4d\x6b\xe6\xd2\x1b\xc2\xef\x48\xf8\x3f\xcd\x26\x2c\xf1\xc7\x35\xb1\x38\x5b\x37\xf4\xb1\xd8\x3e\xbe\xb9\xba\x5e\x41\x09\x50\x1b\x9f\x17\x53\x56\xdd\x87\xed\xfc\x8b\x3b\x2b\x88\x16\xc1\x27\x49\x7d\x31\xcb\xe2\x9a\x46\x76\x6f\xfc\xe4\xc3\xb5\x6f\x06\x3d\x6d\x6d\x1b\x42\xc1\xe1\x4d\x11\x23\x86\xab\xfb\xc6\xa2\xe1\x35\x7e\x6f\x78\xdc\xac\xe1\xd2\xd8\x98\x36\xbc\x46\xd4\xf0\x1a\xff\xdf\xff\xdb\xf0\x1a\x93\x86\xd7\x68\x78\x8d\xf3\x86\xd7\x78\xd7\xf0\x1a\x7f\x6e\x78\x8d\xcf\x0d\xaf\xf1\xa1\xe1\x35\x5e\x35\xbc\xc6\x7f\x34\xbc\xc6\xdf\x1a\xfd\x3b\xb9\x76\x4a\x96\x82\xde\x62\x39\xe5\xdc\x8b\x81\xc4\xd0\x49\x0e\x7f\xf2\xc5\xe1\xa3\x47\x32\x29\x3b\x8b\x67\xa9\x1f\x05\x29\x1c\x2e\x15\x83\xd0\x92\x8a\xd2\x35\x60\xae\x2d\xaf\xd0\x92\x5b\xeb\x26\x6b\x8d\x46\x49\x03\x6a\xab\x16\x37\x65\x86\x0b\xdd\x3b\x99\xa2\xc3\xe6\x0c\xc3\x89\x3f\xd6\x05\x44\x82\x3a\x79\x11\xa2\xa7\x0b\xa8\x94\x25\x68\x51\x22\xc1\x75\xe4\x90\xa0\xef\xa6\xf3\x53\x96\x0c\x19\x5e\xf5\x15\xe0\x65\xc2\xb7\x6f\xd0\xf8\xa1\x61\xfb\x0c\x45\xec\xf2\x35\x62\xea\xa4\x52\x13\xa8\xfb\xb3\x32\x61\x49\xef\x99\x52\x5b\xaa\xe8\x47\xa3\x9a\x39\xd0\xaf\xd9\x8e\xc2\xf1\x18\xbd\x18\x44\x5e\x93\x27\xe8\x33\x5a\x7f\x1c\x9e\x46\x56\x3e\xa6\xe8\x02\x69\x3e\x3f\xb5\xb3\x17\x93\x41\x6c\x37\x40\x49\xba\x08\x5f\x20\x5b\x05\x78\x82\xce\xbe\x0c\x03\x7c\x69\x57\xe7\x63\x8a\x2e\x30\x8c\xc9\xb3\x46\x17\xc0\x14\x5d\x40\x4d\xa7\x56\x21\x95\xaa\x0b\x66\x8b\x29\xb3\xca\x88\xa8\x0e\x3c\x4f\xdc\x19\x9a\x65\x74\x67\x88\xd4\x0c\xee\x16\xa4\xb3\xd1\x28\x9c\x37\x65\xa9\xd7\x71\x02\x9f\xde\x6c\x52\x01\x8f\x36\x11\xb0\x04\x3e\x83\xee\xff\x1e\x8e\x17\x78\x21\x6a\x96\xe1\xd3\xfd\x62\x18\x04\xbc\xae\x22\x58\xb7\x0b\x8d\x3f\x35\xe0\x50\x09\x54\xaf\xd5\x87\x7d\x2b\xfb\x5f\x1a\x5c\x61\x6c\xf5\x06\xf1\xfc\x97\xfe\x56\x33\x63\x69\xe6\x70\x8c\x5d\x38\x84\x46\xab\x01\x1b\xd8\xa1\x66\x16\xbf\x8d\x2f\x59\x72\xe4\xe3\x0b\xa4\xfb\xd0\x68\x18\xc3\x43\x98\xd5\x35\xdb\xe6\xcd\x6e\xf5\x7e\x98\xe6\x9b\x90\xbc\xbd\x2f\x77\x30\xb1\xfb\x7f\x3d\xf3\xe5\xca\xc6\x70\x97\x3f\x8b\x67\xe3\x00\x2e\x19\xcc\x52\x76\x28\x8b\xbe\x49\x21\x3b\x0b\x53\xc0\x3d\xe4\x8c\x9d\xb2\x04\x11\x56\xf9\x47\x7e\x44\x05\x70\x5c\x4e\x59\xc4\x12\xdc\xb5\x11\xd6\x45\xe8\x8f\x21\x8a\xe9\x95\xfc\x43\xcd\xcf\x6a\xde\xab\x75\xa3\xce\xcf\x90\x25\x02\xd3\xe3\xcd\x1a\xee\x0a\x13\x7f\x31\x60\x9f\x24\xc1\x1e\x22\x52\xdf\xbe\xc1\x56\x2f\x60\xa3\xd3\x69\x92\xfe\x60\x11\x48\x53\xe4\x13\xcb\x90\x0b\x24\x68\xcd\x8e\xe1\x88\x77\x40\xf1\x5b\xe0\xc9\x2a\x71\x02\xc3\xb1\x3f\x99\x12\xf7\xc8\x6c\xa3\x66\x16\x0b\xc6\x9a\xf2\x39\x87\x05\xc2\xd1\xdb\xe4\x41\x2e\x87\xe1\x28\x1c\xfa\x91\xd1\xa4\x07\x61\x06\x93\x59\x9a\xc1\x80\x41\x18\x41\xaf\xed\x41\xa7\xdd\xb7\x2a\xf2\xe9\x33\xa8\xa9\xd2\xf2\xa0\xd3\x12\x55\x4c\xd1\x32\xbe\xd5\xdd\x0b\xa4\x05\x1c\xc2\x63\xd8\x87\x76\x47\xfb\x6d\x73\x8e\xe2\x34\xcb\xf3\x94\xba\xb2\xdc\xf6\xf4\xc1\x7b\xa7\xed\x69\xe0\xae\x09\xa4\x10\xf1\x03\x8b\xb7\xac\xe2\x62\x20\x14\x2f\xd2\xb0\x3b\xb9\xbb\x79\x18\xb6\x8f\x27\x7d\x90\x82\x28\x04\xd8\xd8\x4e\xc3\x7c\xc5\x00\x24\x3a\x66\x7e\x88\xb7\xb7\x86\xea\xcd\xe8\x70\x24\xfa\x8f\x52\x35\x6c\xd8\xc1\x44\x4d\x58\x9a\x15\x25\x5e\x1b\x66\x89\x03\xbb\x1a\x74\x95\x8b\x57\xe1\x80\x50\x17\xd9\x10\x57\x0c\x55\xc6\xd6\x16\x7c\x60\x09\x6f\x0a\x79\x27\x8c\x42\x14\x21\x6a\x3b\x13\xbb\x9c\x39\x6a\xfc\xc4\x4e\xfd\x2c\xbc\x50\x97\x1f\xe1\x99\xf6\xa0\xd3\x4d\x19\xe8\xab\xcb\xe8\xd4\x0f\x73\x24\x6c\x54\xde\x8c\xc0\x87\x48\x82\x27\x48\x09\x5f\xee\xe0\x91\x09\xce\x09\xc1\x0c\xcf\x21\x34\x82\x1e\x64\x09\xf3\x33\xf0\x53\x98\xc6\x69\xc8\x6b\x6a\x9c\xd5\x7d\x5f\x85\xf3\xa3\x47\x82\x08\x14\xcb\xc2\x2d\x74\x69\xe4\x8f\xd3\x1c\x85\x96\xd0\xf1\xaa\xe7\x8a\x55\x72\xed\x1e\x82\x43\xb3\x22\x1f\x76\x87\x2b\x53\xfc\xb9\x0f\x8d\xcd\x06\x57\xc0\x3a\x73\xb3\xc1\x35\x48\xae\x70\xa3\x21\xca\x28\x2e\xa0\x86\x0e\x2a\x98\xc7\xfc\xb5\x61\x72\x5c\xca\xa1\x49\x7b\xb8\xb7\x07\x1b\xab\x5a\xf4\xd2\xf1\x8f\x60\xbc\x12\x7a\x97\xeb\x46\xd8\x82\xed\x3e\x6a\x7e\x8e\x64\x91\xee\xf9\x2e\xb9\x0d\x2a\x6c\x13\xfb\xc7\x84\xf9\xe7\x74\x4f\x98\xc6\x98\x05\x82\x13\xc2\x48\x68\x38\x39\x31\xfc\xf7\x7f\xfd\x6f\xcc\xf9\xef\xff\xfa\x7f\x60\xea\x27\x5c\xa3\xfa\x99\x78\x04\xd9\x04\x89\xe6\x2d\x3e\x8f\x1b\x05\x30\x4a\x7c\x94\x79\x7f\xcc\x35\xaa\x39\x6f\xfc\xf7\x7f\xfd\x6f\x1a\x52\x1b\x5e\x98\x72\x85\x6c\xf3\x94\xa1\xf6\xed\x0d\x7a\xf3\xe6\x11\x5d\x6b\xb6\x23\x09\x43\x4d\xc4\x43\x0d\x7e\xa8\x6a\x0f\xcf\xfc\xe4\x28\x0e\xd8\x8b\xcc\x09\x5d\x0f\x76\xf6\xe0\x39\x0c\x39\x7f\x0c\xe1\x39\xec\x3e\xc9\x57\xce\xb3\x01\x87\xd4\xed\xc2\xce\x63\x38\x54\x26\xb6\xe0\x1f\x71\x30\x23\x9c\xf0\xf6\xed\x44\xb7\x52\xd9\xd8\x42\x6e\x56\x6a\x79\x10\xba\xf9\x82\x03\x3e\x9a\x76\xe2\xd5\x83\xb2\x6f\x7d\xc1\xf9\x81\xa9\x0e\xe8\xbe\xf8\x78\x0c\x9c\x10\xfe\x30\x63\x89\x18\x0f\x6e\xcc\x78\xa0\x16\x49\xdc\x62\x98\x4e\xc7\x7c\x42\x1c\xb0\x51\x9c\x30\x98\xfa\x41\x60\xe8\x2f\x11\x87\x79\xe2\x73\x4e\x7c\xc8\x55\x89\xab\x7a\x81\x50\x88\x5f\x3d\x78\x13\x8d\xb8\x16\x5c\x68\xb6\xcc\x6b\x00\x1b\x30\x3e\x74\x2d\xa2\x7a\x9b\x92\x29\x8f\x84\x36\x2c\x3e\xb0\xc9\x5a\x70\xc5\x06\x09\x9d\xaf\x16\xe4\x91\x12\x19\xbb\x87\x86\xd7\x18\xa5\x6c\x82\x82\xd9\x76\xe9\x38\x87\x93\xca\x35\x8d\xaf\x7a\x3a\x56\xd2\xd0\x1f\xf1\x12\x75\x24\x2c\xa3\xa0\xc4\x5d\xf4\xd1\x53\x00\xd4\x3d\x31\x89\x78\x91\x06\xb0\xaf\x29\xef\x19\x54\xb0\x7b\xf2\x91\xe1\x79\x7c\x32\x1b\x66\xa2\x4b\x28\xc7\xb3\x6c\x3a\xcb\x60\xe0\xa7\x2c\x80\x38\x12\x86\x55\x1a\x26\xbc\x27\x7c\x65\x32\x61\x91\x12\xe0\xf4\x32\xcc\x86\x67\xe0\x60\x86\x29\x3f\x43\x3f\x65\xd0\x78\xd6\xd8\xb7\xb9\x5b\x28\x74\xd1\x27\x7b\xfc\x60\x43\x62\x7a\x90\xe7\x74\x82\xd6\xad\x84\x96\xa3\x55\x4e\xdc\xca\xa1\xfd\xa7\x01\x4d\x92\x56\xc9\x9e\xe2\xc1\x1c\xd1\x9f\x63\x50\xd1\x8d\x55\x3a\x23\x80\x8a\xe3\xdc\x02\x32\xc2\x66\x2d\xe0\xb2\x4c\x23\x39\x60\x4a\xda\xc5\x2e\xa8\x5c\x79\x0b\x4b\xc1\x7a\x11\x9d\xa6\x83\x66\x16\x7f\x22\x57\x84\x92\x0b\x84\xfa\x74\x53\xad\x95\x2d\xcf\x77\xd3\x69\x86\xc0\xa9\x33\xe4\x9c\x29\x48\x7d\xd0\xab\x63\xcf\x8e\xdb\x80\x8b\x0a\x72\x05\x12\xcb\x75\xe7\xbe\x97\xe7\x5e\x6e\x09\xca\x65\x63\xd4\x30\x52\x5d\xc3\x53\x9b\x99\x91\xef\x36\xf7\x0c\x43\x78\xcf\x8a\xe9\xb3\x8c\x13\x81\xde\xb8\xad\x8e\xa9\xeb\xf2\xb9\xdf\x75\x5d\x58\x87\x6d\x8d\xc5\x79\x3e\x9a\xd0\x26\x73\xad\x15\xb8\x69\x54\x0b\x6b\x84\xa1\x15\x51\x7e\x3f\x22\x67\x9e\xcb\x6c\xe7\x1c\xd6\x41\x99\xc8\x53\xc3\x2e\xba\xca\x87\xde\xfb\x6a\x70\xd2\xbe\x1e\x3d\xcf\x48\xa6\x91\xdf\xb7\x7e\x55\x3b\xc1\xed\x7d\x87\x80\xda\x2b\x07\x1f\xc8\xb1\xd6\x4d\x77\xec\x97\xdf\x2d\x7e\xf0\x60\x6b\x0b\x7a\x3d\x3e\xc1\xf4\x51\xaf\xf6\x7b\x29\xfd\x8b\x3b\x08\xfd\x5e\xab\xdf\x43\xd5\xdf\xef\x79\xfd\x9e\xde\x65\x11\xcb\x69\xe1\x94\x07\x5d\xd8\xfa\x4f\xe7\x70\xdf\x69\xba\x87\x4e\xef\xd9\xf3\xee\x7f\xf6\x5d\xfe\xb5\xf1\xf7\xcd\xbf\x3b\xd0\xe7\x9f\x7f\xfa\x17\xfe\xa7\xe5\x1e\x3a\xe8\x97\xe7\x78\xfc\xab\x49\xdf\x3d\x7f\xf3\xf7\x1f\xfa\xee\xe1\x9f\xb6\x42\xd3\x0d\x2f\x47\x8c\xfc\xbe\x9a\x54\x3c\xec\x12\x5e\x57\x96\x24\xcf\x3c\x3b\x5b\x87\xf8\x84\x6e\xbe\xaa\x11\xfe\x93\xfc\x7e\xd2\xcc\x8f\x86\x2c\x1e\x19\x78\x55\xb7\x66\x04\x2e\x21\xb7\xb7\x2e\x24\x8c\x3c\xb6\x0c\x61\x77\x21\x3b\x4b\xe2\x4b\xc4\xfc\x55\x92\xc4\x89\xd3\x08\xa3\x0b\x7f\x1c\x06\x8a\xbf\x1b\xb0\x01\xb9\xfd\x3d\x0a\x39\x9a\x0d\x95\xcd\x21\xb6\xfa\x30\xad\xd7\xee\xe3\xa6\x24\xa8\xcd\x20\xb9\xd3\x47\xd9\x1d\xca\x7e\xae\xb2\x53\x33\x77\x9b\x72\x37\x75\xae\xdc\xe6\xa3\xfc\x1d\xca\x57\xd9\x62\x8b\xef\xe1\x43\xca\xde\x55\xbb\x2a\x72\x73\x8f\xd2\x1f\xf7\x71\xcd\x26\x7f\xa8\x2d\x65\xb1\xc1\x27\xab\x3f\xd1\xfb\xad\xc6\xf6\x03\xe5\xed\x99\x20\xf6\xfa\x62\x7a\x6b\x2b\x5d\x24\x06\x91\xf2\x9f\x0a\x34\xa5\xff\xdd\xe7\x33\x06\x8d\xa8\x41\x85\x68\x63\xca\x1f\x87\x7e\x8a\xbe\x38\x0d\xef\xb4\x21\x9d\xa0\xf4\x1a\x2b\x6a\xb8\x0a\xbf\x2c\xe1\x86\x90\x54\xd8\xa7\x0a\xec\x3b\x7f\x0a\x72\xbc\x78\x6e\x2a\xb7\x6f\xa4\x72\x15\xd3\x9d\x19\xf5\xec\xe1\xf2\xe2\x5a\xb9\x75\xe5\x2a\x5c\xb4\x87\xe1\x88\xc6\x02\x59\x21\x4c\x8d\xad\x27\x35\xb3\x9f\xc6\x2c\x15\x46\x21\x8e\x39\x5f\x48\x09\x3b\x3b\x08\x4f\xc3\x2c\x95\x44\x40\x40\xdf\xbe\x81\x43\x7c\xc5\xa9\xd1\xc2\x1d\x49\xc1\x49\x3c\xa1\xdb\x70\x5d\x39\xfa\x44\x1e\xc1\x84\x68\x8e\x4a\x96\x6b\x74\x09\xc1\xec\x2c\x4c\x9b\xa2\x00\xff\x73\x20\xd3\x64\x41\xfc\xab\x52\xe5\xd6\xb3\x95\xa6\xf6\x9b\xf1\x43\xa5\x0b\x1c\xf8\x1f\x95\x26\x99\x0f\xff\xaa\x54\x39\x9a\xf8\x57\xa5\x96\x6e\x74\xa9\x5c\x41\x67\xda\x2e\xbe\x7a\xf0\xa0\x52\x47\xd4\x98\x34\x32\x3a\x8f\xa4\x81\x60\xd8\x0d\x83\x02\x76\x52\x5a\x4c\xc1\x3e\xab\x34\x47\xf7\x9c\x36\x84\x71\x09\x9e\xcb\x16\x44\x50\x3b\x76\xb8\xfb\x60\x6e\xc3\x19\xa5\xbe\x41\xcb\xcd\xd7\x27\x72\x1d\x42\xc3\x2b\x87\x5f\xb6\x2b\x88\x6d\x34\x9a\x5c\x67\x99\x3b\x78\xb9\xf2\x76\x6b\x8a\xce\x07\x0f\xae\x4a\xe6\xe6\x3f\xd6\xed\x40\xcb\x55\xab\xe6\xf0\xf2\xe6\xef\x9a\xdd\xff\xf1\xab\x3a\x48\x43\x27\x84\x5a\x5f\x9a\x8e\x38\x83\xbd\xf1\x41\x29\xe7\xff\x46\xa3\xee\x04\xae\x48\xd4\x8a\x63\xb8\xc6\x0f\x0d\xe3\x99\xa8\xb9\x07\x53\xc3\xf3\xc2\x99\xc3\x3a\xb4\x5b\x2d\xb7\x99\xc5\xe8\x6d\xe3\x4c\xdd\x03\x7a\x62\xaa\x31\xb0\xea\x19\x95\x90\x45\x71\x6b\xd2\x99\xbb\x4a\x80\x9d\x8e\xaa\x39\xac\xaa\x39\xa7\x25\x89\x28\x16\xac\xd8\x40\xbb\xa5\x5a\x60\x35\x7d\x9a\x37\xb3\xf8\x95\xde\xda\x32\x7a\x34\xba\xa6\x56\x9e\x02\xa7\xd7\x94\xff\x20\x45\xd3\xa8\x13\xaf\xd8\xa9\x3d\x55\x73\x5a\xd3\xda\xf2\xa7\xbc\x8a\x39\x4b\x17\x2c\x62\xb8\x39\x70\xd9\x6c\x52\xcb\x66\x4b\xc1\x45\x38\x69\x2d\x9c\x52\x09\xad\x02\xf5\xcb\xaa\x8c\xf1\x98\xff\xf8\x32\x9d\xca\x43\x3d\xd9\xb7\xf9\xea\x80\x0e\xe0\xaa\x7c\xb1\xf3\x4f\xfc\x32\x80\xbd\x5d\x7d\x63\xff\x31\x43\xe5\xe0\x6e\x6a\xcd\x6d\xef\x8e\xba\x6f\x94\x6b\xfb\x2e\x9c\x47\x84\x6c\x18\xf7\x11\x97\x59\xca\xe7\x50\x2f\x17\x0f\x14\x0c\xb9\x02\x09\xdc\x9c\xde\x52\x11\x53\xd8\x68\x14\x0e\x43\x72\x6c\x08\x7a\x2d\x65\x7e\xcb\xed\x02\x4c\x6e\xf7\xcd\xe0\xac\x2a\x6b\x13\x9c\xdc\xf1\xc1\x72\xdb\x15\x0a\x80\xde\x6d\xc0\xe0\xb6\x66\xc0\x7f\x03\xb3\xe2\x6d\xf8\x90\x2e\xfa\xc1\xa1\x59\x4c\x39\xe1\x87\xf0\x3c\x9f\x07\x1b\xc6\xb6\x6b\x08\x9b\x10\x19\xbb\xad\x8d\x56\xc3\xb5\x2a\xb7\xec\xca\xe6\xc6\x38\xa7\x1e\x1a\x37\xc5\xfc\x50\x03\x69\xb4\xb0\x8c\x6e\xb2\x8d\x41\xbd\x75\x73\xb0\x71\x97\x03\x6d\x1a\x5a\x53\x7c\xb1\x60\x13\xda\xae\xdb\x6b\xd1\x7d\xa6\x31\x4b\x53\xc8\xce\xfc\x08\xda\x8b\x87\xe5\x1a\xe1\x8f\xfb\x38\x05\xc5\x0a\x13\x77\x3b\x2e\x7c\x11\xe7\x57\x05\x9f\xcb\x47\xa6\x93\x57\x4c\x5b\xd6\xbb\x5f\x6d\x5d\xd2\x78\x86\x4f\xe4\xce\x5b\x2a\xb7\x17\x6a\x01\x98\xb7\x8d\x64\x2d\x00\x99\xba\xa0\x3a\x6f\xc3\x33\x98\xab\xb8\xf8\x9c\xf9\x43\xce\x23\x1c\x5c\xd8\xf6\xa8\xd5\xec\x40\x65\xce\x5b\x1e\xb5\x35\x6f\x7b\x04\x5d\x6f\x5b\xea\xe6\x31\xb6\x20\x75\x55\x48\xcb\xbc\x85\x72\xac\x51\x31\x8b\x60\xec\xe8\x79\xdb\x0c\x97\x4e\x05\x2b\xf6\xb9\xfe\x58\x0f\x53\xd0\x60\x0f\xfd\x31\x8b\x02\xff\xa6\x1b\x5c\xc1\xf6\x35\x61\x30\xf1\xca\xe8\x8d\x4c\xf1\x60\xfb\xd8\xb8\x53\x54\x13\xd9\xea\x86\xd1\xbe\x3a\xbc\x85\x2c\x9c\xd4\xdc\xc1\xee\xdc\xd0\x4d\x74\x5b\x81\x26\x25\x52\xb3\x88\xb8\x61\xf8\xd1\x9d\xa5\xc2\x8f\xde\xcc\x03\x75\x18\x47\x59\x18\xcd\xe2\x59\xf5\x96\x65\x7b\xe7\x86\x78\x3f\x3e\x3e\x8e\xc2\xba\xd7\x23\xf7\x1e\xe7\xfc\x4e\x83\x59\x82\x9e\x48\x9f\xd8\x30\xc6\xa8\x5c\xed\x56\x4b\x28\x17\x99\xf5\x2e\x8c\x66\x19\xe3\x1a\xc3\x2e\xbb\x0e\x8f\x73\x25\xff\x12\xcf\x12\xa3\x9c\xa8\x58\x2c\xf7\x12\x9f\x21\xb2\x6a\xad\x43\x67\xc7\x2e\xf4\x57\xc6\xce\x8d\x52\xbc\xce\x3a\x3c\xc9\xa1\x16\x47\xb8\x15\x62\x17\xda\xce\x35\xf7\x37\xe6\x27\xc5\x42\x8f\x77\xcd\x3d\xd8\xc0\xcf\x98\xbc\xca\x66\x6c\xb8\xbe\xa4\x64\xfb\xde\x33\xdd\xb9\xcb\x95\xce\x8c\x3d\x54\xac\x06\x87\x80\x31\x6a\x36\x14\x9c\x8d\x3c\x20\xa9\x1d\x9c\x05\xf3\x13\x0f\x26\xbc\x37\x1e\x5c\x32\x76\xee\x41\xe0\x2f\x3c\x38\x8b\x67\x3c\x1d\xe9\xe8\x41\x8a\x74\xe7\xbf\xc7\xe3\x50\xfe\x20\x11\x30\x9e\x57\xc0\x6b\x39\x4b\x18\x5b\x39\x56\x2c\x8b\x96\xb4\x4a\xed\xa1\xa8\x6d\x28\x95\xb7\x61\xc4\x29\xcf\xd7\x0b\x2b\xa9\x22\x09\xcc\x48\xfc\x89\xae\xf0\x72\xa4\xd4\xcc\x17\x5d\x30\x7a\x32\x06\x5d\x56\xe9\x67\x21\xfc\xae\x19\x1d\x56\x4d\xa1\x44\xb3\x77\x9a\x8c\xea\x44\xc2\x69\x34\x7f\x78\xdb\x50\x6d\x88\x0d\xf5\x7c\x99\xfd\x1f\x3e\xe5\xcb\x28\x21\x91\x65\x7e\x78\xb3\xff\xc3\xbb\x7c\x29\x21\x20\xba\x0c\xfc\x30\xcd\x97\x21\xe1\x50\x45\x7c\xf8\x21\xc8\x17\x11\xa2\xa1\xca\x0c\x4a\xca\x48\xd1\x50\x85\x7e\xcc\x97\x10\x62\xa1\x0a\xfc\xad\xa1\x8d\x0c\x7a\x56\x85\x26\x62\xf4\x49\xc7\x9a\x3d\xc9\x74\xd0\xf6\x04\x9d\x2d\x95\x20\x2c\x09\x5d\x6c\x97\xff\x0f\xd6\xaf\x29\xd6\xde\xe5\xff\xbb\xb6\xd8\x76\x8b\xff\xaf\xb2\x98\x94\x92\x02\x6e\x34\x34\x85\x62\x79\xdc\xca\x8b\x15\x70\x2b\x2f\x56\xc0\xcd\x2e\x06\x42\x92\x0b\xb8\x21\x43\x40\xa1\xd8\x36\xff\x9f\x01\xad\xa2\xd8\x63\xfe\xbf\x6b\x8b\xb5\x3b\xfc\x7f\x35\xc5\x48\xd7\x14\x70\xe3\x8c\x58\x52\xac\xc3\xff\x67\x40\xcb\x17\x23\xf5\x55\x80\x86\x3c\xab\x8b\x09\x5d\x57\x1c\x2c\x64\xdb\x42\xb1\x3c\x41\x72\xc5\x80\x14\x68\x01\x1a\xb2\x38\xf4\x1f\x00\xf4\x6d\x27\x76\xce\xdf\xe2\x58\x9c\x6b\xfe\x5c\xb4\x0a\x87\x58\x4e\x64\x3d\xc3\xc9\x01\x0e\x8b\x6a\xc3\x70\xe9\x24\x46\x28\xaf\xf1\x29\x5f\x98\x8f\x4b\x15\x70\x0e\xc6\x28\x1a\xf8\x8b\xf2\x92\x7c\x10\xcd\xf6\x39\x41\xf2\x25\x1d\x3e\x16\xe5\xd5\xf9\xa8\xed\x1b\xea\xc4\x74\x4f\xe5\xc4\xac\x40\x8f\xb7\x62\x94\xd4\x8a\xc4\xa5\x0a\x45\x67\x05\x53\x93\x38\xd2\xb6\xf7\xa0\xe2\x61\x3e\x5a\x7e\xc8\x62\xfa\x01\x14\x9d\x82\x6f\xf1\x60\x49\xe9\x8d\x29\xfd\x68\x78\x4b\xe2\x2d\xb2\xdc\x11\x11\xcf\xf0\x21\x61\x7e\x1a\x47\xf8\x9c\x07\x16\x95\x30\x25\x30\xcb\x39\x87\xcd\x33\xbe\xb6\x16\xb7\xec\xc5\x74\xe2\x47\x01\x87\x13\xcf\x4e\xcf\x80\xa5\x59\x38\xe1\xb4\xe1\x45\x38\xb8\x34\xfc\x5d\x7b\x32\x1b\x37\xf7\xfd\x34\x9d\x4d\x98\xee\x41\x98\x82\x3f\x4e\x98\x1f\x2c\xc0\x07\x6e\xc5\xea\x2c\x0e\x9f\x2f\x3d\x42\xe1\x0a\x24\xcf\xec\xe2\x91\x41\x00\x3c\xbe\xc3\xe9\xb0\x61\xfb\x01\x67\x7e\x72\xca\xb2\xba\x97\x95\x14\xf9\x73\xee\x80\xcb\x85\xb6\x54\xf1\xbb\x69\x76\x1e\x70\x21\xc8\xe2\x44\xbc\xa7\x2f\x17\x5c\xa1\xf9\x58\x41\xaf\x83\xf7\xff\x9a\x49\x78\x7a\x96\x39\xd6\xa4\xe2\x09\x7c\xad\xb8\x1b\xb4\xf9\x61\x95\xcb\x85\x6c\x00\xf1\x0c\xd4\xea\x58\x9f\x22\xd6\xf2\x89\x2a\x23\x44\x2b\x6c\x59\xfa\x42\xbc\x3e\x97\x4f\x54\x8b\x74\xed\x65\x64\x30\x25\x17\x99\x9c\x6b\x33\xf6\xc7\x44\x3b\x84\x5c\xd7\x7a\x62\xc4\xb6\x72\xc9\xb8\xc7\xd1\xef\x75\xfa\xf0\x2c\x9f\x83\xa9\x5b\x72\xa8\x0f\x69\x3b\x04\xf6\x41\xbe\x99\x61\x90\x27\xec\xb5\xfb\xa5\xb8\x86\xbd\x56\xbf\xd2\x0d\xfb\x8e\x69\x2b\x25\xbc\x9e\x7a\x86\x41\xab\xdd\xae\x40\xfb\x55\xa9\x48\xb5\x1c\x37\x75\x1c\xa7\x00\xec\xeb\x3d\x03\x76\xc1\x92\x85\xa3\x9e\xb2\x33\x1e\x08\x50\xe6\xa2\xe2\xd4\x45\x4e\xeb\x2b\x3b\x9d\x8a\x3a\x0b\xb7\x10\x7a\xbe\xe6\x95\x81\xea\xc8\xf3\x22\x32\xfc\x32\xab\xcd\xdc\x8b\x01\x22\x32\xbe\x27\x56\x1c\xae\xcb\x27\x04\x82\xe6\x36\x27\xfe\xd4\xd0\xb9\x06\x92\xf2\xf5\x3e\x2d\x92\x86\xd6\xd5\x8a\x56\xee\xca\x4a\x80\xc6\x7d\xa2\x56\x6e\xc3\x14\x20\xc3\x1d\xa3\x5e\x60\xec\x31\xf5\xed\xf0\xbc\x59\x9b\x73\x6b\xcb\xa8\xa2\xa3\xa9\x24\x2e\xee\x12\x65\x2d\x8f\x60\x67\x6d\x8f\x20\x1a\x5b\x48\x15\xf3\x04\xd6\x69\x7b\xd6\xeb\x84\xbc\x34\x1c\x42\x26\x62\xeb\x53\x11\xe9\x24\x2c\x02\x1d\x85\xd1\x70\x3c\x4b\xc3\x0b\x86\x0c\x68\x8e\x50\x42\x55\xe5\x0b\x83\xb0\x2f\xf6\xaa\x72\x14\x24\xeb\xc0\x24\x23\x4e\x2d\xa6\x37\x9b\x3d\xf2\x86\x77\x9d\x62\x51\x03\x90\x9c\x2c\x2d\x9f\x1d\xbb\xd9\x88\x1e\xe0\x5d\x71\xdc\x2c\x47\x34\x63\xea\xac\xa2\x28\x0e\x6c\x61\x2c\xc5\xf3\xb2\x6a\xf4\x14\xdb\x5e\xab\x09\xd4\x9e\x43\xe9\x16\x6e\x60\xc8\xbe\x69\x63\x94\xbe\x3d\x71\xcd\xab\x0b\xab\x2f\x69\x09\x21\x04\x4b\x3a\x89\x37\xe3\xdd\xe5\xba\xbb\xee\xe5\x86\xd5\x77\x88\x07\xb9\x1d\x62\x6b\x87\x41\x61\xbd\xd4\xa6\x5b\xaf\x71\x2e\x94\xf2\x84\xfd\x6d\x89\x65\xb8\x55\x75\xa4\xaa\x92\xa1\xbd\x4a\xdd\x5f\x55\x5d\x34\xf9\x57\xa9\xea\xab\xaa\xb8\x47\xb3\x42\xcd\x81\xaa\x49\xbb\x49\x2b\x54\x0d\x74\x5f\xc5\x7e\xd5\x0a\x95\x4f\x55\x65\xb9\x29\xb6\x42\xe5\xa1\xd1\xb2\xde\x8a\xb8\x06\x42\x71\xf3\xd3\xa4\x9b\x50\x36\x9c\xd9\xe5\x8b\x24\x3d\x35\xaf\x75\x5a\xad\x96\x47\x4f\x54\x7b\x50\x4c\xed\xb8\xfd\xaa\xe8\x4a\x7f\xac\xd0\x9e\xcb\x07\x27\xea\x74\x76\xea\x63\xd9\x68\x9a\xfd\x33\x06\x28\xaa\xeb\xd5\x07\x3f\x49\xef\xbe\x1f\xf7\x13\xc8\xa8\xaa\x1f\xb3\x6c\x58\xd6\x8d\xbb\x8e\x77\xf4\x74\x59\x1e\xb9\x8b\x98\x47\x61\x1a\xbf\xbe\xe6\xd4\xe2\x69\xab\x1e\x21\x05\xe2\x86\x98\x6c\x2b\x4c\x90\xba\xd5\x1e\x52\x9d\xc7\xd7\x22\xa2\xc6\xa7\x34\xbe\xcb\x77\x88\xbf\x7a\x43\xd7\x73\x1a\xca\x9b\x1f\xcb\x2d\x71\xb2\x65\x3e\x51\xc8\x5b\x43\x6d\x1b\x68\xdf\xe9\x16\x3c\xeb\x42\xd0\x5c\xc0\xa3\x47\xf8\xe7\x19\xba\x78\x99\x56\x9e\x9f\x31\x23\x8c\xb3\xb3\xd9\xf6\x20\x68\x4e\xf8\x3f\x01\xff\xe7\x2f\xfc\x9f\x77\xfc\x9f\x4f\xfc\x9f\xb7\xf2\xf5\x32\x3f\x63\xcd\x94\x65\xaf\x67\xe3\xf1\xdf\x70\x2b\xa7\x99\x7b\x71\x24\x10\x41\xa1\xaf\x4a\x0e\x3b\x82\xe6\xe2\xda\x56\xcc\x33\x8c\x59\x36\xbc\x75\xc7\xf8\x3f\xcd\x2f\x9f\x8f\xae\xef\x61\xae\x8b\x5f\x3e\x1f\xdd\xac\x97\xaa\xc5\xeb\xbb\x9b\x3f\xfc\x61\x97\xd8\xdc\xc2\xb2\xcd\xbe\x2e\xf6\x61\xe1\xc1\x64\x9f\x4f\xa4\xc1\x3e\xb4\x3d\xf8\x0b\x7e\xbf\xc3\x7f\x3f\xe1\xbf\x6f\xf7\xa1\x95\x0b\xa1\x6b\x32\x63\x21\xdc\x8a\x50\x5c\xbc\x1f\x9f\xc3\x09\x33\x22\x8f\x88\x14\xb9\xd8\x32\x0a\xda\x85\x72\x05\x32\x0b\x4a\x56\x84\x30\x65\x49\x18\x07\xa9\x15\x08\x84\x27\xe4\x8a\x71\x4b\x39\xf0\x17\xa9\xd9\xd8\x22\x5f\x28\x3d\x8b\x13\xdc\x5a\xb4\x4b\x62\xf2\xcb\x62\x71\x34\xc2\x8d\x72\xf4\xbb\x0c\xe6\xbb\x5c\x49\x23\x51\x9d\x5f\x10\xde\x1f\xf5\x81\xcc\x47\x49\x5e\xd9\x47\xd7\x08\x7e\x12\xc6\xc1\xdb\x38\x3e\xc7\xd8\x36\x72\x44\xf8\xcf\xaa\x2a\xa2\xff\xa5\xe0\x25\x6d\xf2\x85\x6b\x1b\x28\x54\x32\x89\x57\xda\x8c\x45\xdd\xd2\x6a\xb5\x0d\x96\x57\x47\x9a\x97\x36\x47\xa3\x61\x17\xac\x6d\x20\x57\x41\x8f\x51\x75\x6f\xde\x55\x55\xb9\xbe\x27\xa2\x6a\xee\x80\x8f\xf3\x08\x29\x9d\x86\xdf\x90\xeb\xef\x4f\x46\xcf\xa9\xa9\xc6\x8b\x86\xb9\x13\xae\xd3\x07\x76\x25\x6c\x44\x64\xfd\xa8\xb2\xcc\xd4\x61\x63\x1f\x57\xfe\xe2\x67\xa0\x0a\xbd\xf4\x17\xef\x47\x66\x49\x56\x9d\x35\xd2\xa0\xc3\x61\x12\xd3\xaa\x40\x08\x42\xe3\x2f\x2a\x93\xaf\x73\xe4\x91\x79\xe3\x8d\x95\xdc\xee\x88\xe4\x5f\xed\x56\x70\x23\x93\x72\xde\x1a\x8d\xa8\xa5\x87\x6c\x64\x62\x77\x8e\xce\x5e\x45\xde\x3b\xa3\x22\x5f\x2d\xc9\x3a\x53\x95\xfe\x01\x85\x45\x24\xff\xbb\x4a\xfe\x12\x85\x73\xae\xb3\xd2\xcc\x9f\x4c\x45\x6e\x5a\x9e\xfb\xc9\xc2\xe6\x93\x1e\x05\x2b\x7d\x96\x1f\x35\xc2\xf3\x5d\x1c\xe9\x11\xfc\x62\x95\xa1\x02\x9f\x66\x46\x81\x9f\x4b\x0a\xbc\xf9\xf4\x5e\xe4\x5e\x96\x37\x61\x41\xf8\x6b\x09\x04\x0b\x87\xb9\xcd\x14\xbf\xd8\x3f\x17\x0d\xf3\x14\x45\x24\xfe\x4d\x25\xca\xd9\x4d\x64\xfc\x87\xca\xf8\x8f\x38\x12\xca\x9b\x3c\xc7\x49\x32\xc2\x8c\x25\xfe\xf8\x03\x45\xb8\x51\x1b\x13\x5c\x22\x66\xd9\xf0\x75\xb5\x50\x7c\xf9\x7c\x54\x2b\x17\x5f\x3e\x1f\x55\x89\x86\xac\x5a\x2e\x1d\x5f\x3e\x1f\x2d\x25\x20\x5f\x3e\x1f\xd5\xc8\x48\x59\xee\xc8\x6a\xa3\x4e\x52\xbe\x7c\x3e\xaa\x10\x16\x91\x53\x22\x2f\xb2\xc5\x52\x91\xc1\x06\x6b\xa4\x46\x76\xba\x42\x70\xb0\x7a\xb9\xec\x7c\xf9\x7c\x74\x7f\xe2\xc3\x47\xaa\x42\x82\xf4\xf8\xd6\x0a\x91\x28\x56\x2b\x47\x56\x99\x32\x51\xca\xb7\x55\x21\x4d\x16\x9c\x1b\x09\xd4\x97\xcf\x47\xa5\x32\x65\x18\x8d\x05\xb1\xfa\xf2\xf9\x68\x55\xc9\x9a\xf2\x15\x50\x4e\xaa\x30\xad\x42\xa2\x30\xaf\x28\x4d\xba\x4a\x5e\x92\x30\x27\x2f\x45\x98\x48\x76\xe3\x4b\xcb\x1a\x44\xa1\xc2\xdc\x52\x81\x2a\xcf\x19\xa9\x66\xca\x05\x09\xf3\x0a\x42\x54\x4c\xfd\xd5\x6a\x21\x27\x3c\xa2\x81\x52\xc1\xd1\x7d\x2c\x08\x8d\xa8\x96\x17\x18\x4c\x2e\x08\x0b\xa6\x56\xc9\x4a\x31\xb3\x28\x2a\x34\x0c\x05\x31\x31\x07\xad\x42\x44\x54\x91\x0a\xf1\xc8\xe5\xdb\xa2\x51\x84\x5f\x10\x8b\x5c\xfd\x82\x48\xe4\x38\xc2\x90\x0e\x23\xc7\xe0\x93\x85\xcc\xc9\x09\x09\xa6\x95\x08\x08\xa6\xe7\x84\x83\x20\x97\xcb\x06\x5d\x4c\x4d\x19\x24\x6c\x38\x4b\xf0\x28\x26\x08\x13\x36\xc4\x58\x3b\x01\xc3\x40\x1a\x61\x1c\xa5\x2a\x48\x57\xc0\x46\x2c\x49\x28\xba\x9c\x30\xe0\x9a\x73\x2b\x82\x81\xb1\xce\x91\x1b\xf0\xa9\x7c\x23\x0a\x8b\xff\x52\x56\x1c\xd7\x39\xa5\xc5\x87\x55\xd0\x3f\x17\xaa\xe8\xf9\xb3\x0e\x27\x5d\x2a\x5f\xa9\x06\xb3\xea\x4a\xd7\xe0\x67\x55\xbc\x26\x44\xa3\xee\x8d\x7d\xa6\xa2\x9d\xd1\x0d\x37\x18\xe1\x49\x28\x6f\x7c\xf6\xfa\x79\x87\x81\xcd\xb6\x99\xf2\xab\xe9\x90\x0e\xe2\x92\x83\x0e\x05\x51\x8c\x20\x33\x34\x7f\x4c\xfd\xc0\xfc\x49\x68\x5a\xc1\xc8\x1e\x22\x72\x79\xff\x4a\xd7\x2d\xec\x23\x6c\x88\xf3\x50\xb9\xf2\xaa\x8c\x62\x84\x4f\x3c\xe8\xb8\x8b\x66\x04\x23\xf4\x40\xd8\xce\x85\x2d\x12\xcf\x29\xe0\xfb\x16\x46\x44\x48\xf4\xcc\xff\xd5\x83\xd0\xb5\xa2\x0a\xe1\x43\x1f\x53\x7c\x66\x7a\xea\x07\x69\x6f\x68\x47\x79\x3c\xf3\x93\x17\x19\xc7\xca\xed\xbb\xf0\x50\x7a\xb8\x54\x16\x32\x21\xe3\x61\x3d\x41\xa6\xb0\x49\x0d\x86\x71\xaa\x00\x6f\xa6\xb6\x1a\x79\x2c\x46\xea\x10\x93\x06\xbf\x37\xec\x53\x4b\x23\xed\xfb\x84\x57\xa8\xad\x56\xcc\xde\x0e\xad\x1c\x3e\xd2\x18\x8e\xc9\x78\x91\xe1\x81\xfc\xfb\x60\x55\x5a\xa9\x63\x7d\xac\x60\x3f\xf6\x70\x55\xf4\x24\x8a\xd8\x25\xee\x36\x9a\x4c\x1d\xb1\xcb\x97\x45\xff\x2d\xc5\xd4\x04\xda\x66\x6b\xf1\x32\x1a\x6e\xe2\xb4\x9f\xb6\x5a\x6e\x9e\xb9\x69\x0a\x50\x51\x0f\x02\xe3\xc8\xd7\x93\x42\xb1\xd1\xc5\xb7\x70\xec\xca\xea\x00\xd1\x76\x69\x79\xd8\x95\x5d\x94\xae\x2c\x2a\x94\xcc\x78\x9c\x0b\x82\xe4\xc3\x97\x9f\xde\xfc\x82\x5b\xce\x38\x41\xe5\x3c\x99\xa4\x5f\x4d\x66\x06\x3c\x6a\xfc\x7b\x03\xc2\x08\xf4\x3d\x28\x63\x2f\xef\xdf\xad\x18\x51\x9f\xcf\x18\xf8\x93\xcd\xe9\x04\x46\x63\x1f\xa3\x29\xb5\x30\x46\xc0\x8b\x77\x14\x78\xac\x8d\xbf\x3e\xbc\xb3\xa0\x4f\x25\xf4\xa0\xf9\x17\xe8\xe2\xbf\x3f\x40\xbb\x03\x1b\x10\x34\xa7\xb0\x0e\xed\x8e\x1d\x86\x8a\xfc\x2c\x02\x7f\xb1\x19\x8f\x36\x39\x49\x10\x34\xff\xe0\x09\x0b\xe6\x27\x90\xc5\x32\x9f\xff\xb4\x5a\xfb\x59\xb6\x66\x0b\x6b\xd0\xfc\x19\x9e\x41\x1b\xbe\x7d\x03\xfe\xf9\x1c\x76\xb7\x73\x64\x34\x4b\x3f\x74\x1a\x97\x02\x0e\x47\xfb\x52\xbf\x67\xab\xda\xf9\x8f\x62\x3b\x34\x80\xd0\x55\x5b\x9a\x92\x4b\x82\xe6\xc2\x75\x71\x60\xa1\x8b\x65\x9a\xa7\x4c\xac\x10\x1c\x4b\x3c\x44\x7d\x5e\xf0\x39\xec\x20\xb2\xbc\x4e\xb7\x8b\xd7\xae\x96\xda\x51\xee\x71\x7a\x6f\xad\x73\x1c\x68\x86\x27\x3f\x10\x16\x8e\xd1\x99\xcf\x85\xa5\x9e\xd5\xa9\x07\xe7\x12\xa8\x12\xcc\x97\x84\x39\x96\x30\xc5\x31\x6d\x33\x1e\x8d\x52\x96\x39\x24\x00\x38\x58\xf8\xea\xea\x3a\x3c\xb1\x5a\x09\x9a\x39\x0a\xaa\xcd\xdb\x5c\xb1\x89\x5d\x0c\x0d\xc3\x7c\x99\x20\x3f\x18\x19\x73\x30\xaa\x1f\x1f\xf0\x0d\x78\xec\xc2\x0f\xf0\xc4\xd0\x53\x79\x4f\x27\xd5\x69\xa1\x43\xea\x87\xfb\x7e\xc6\x9a\x99\xe7\xec\x77\x30\xd8\x65\xf0\x6e\x3d\xda\x85\x53\xf9\x9b\x0d\xf7\x32\x63\x7d\xed\x40\x5f\x3b\xca\x0f\xac\xd1\x46\x51\xff\x2b\x89\x3a\xc6\x4c\xf9\x52\xae\x5e\x4a\x14\x46\x63\x26\xaa\x1d\x42\xd0\x9c\xf1\x56\xf8\x14\xfb\x57\x95\xd8\x86\x7d\x33\xa6\x28\x71\x8b\x54\x2b\x70\x58\xae\x44\x4c\xc5\x01\xfb\xe5\x9c\x57\xc2\x6d\x44\x24\xb3\x35\x24\x8a\x81\x8d\x45\x0e\x54\xcd\x7f\xe5\xc3\x01\x9b\xe0\x70\xcc\x36\x60\xd7\x15\x5d\xa0\x82\x41\xf3\x8b\x9d\x6f\x13\xf2\x2a\x3f\x2b\xe1\xc9\xc1\xef\x71\xc4\x72\x13\x92\x3f\x1e\xc3\x28\x64\xe3\x20\x05\x3f\x11\x9e\xac\xd3\x84\x65\x2c\x00\x3f\x85\x2f\x9f\x8f\x50\xf9\x67\x67\x2c\xd2\x00\x89\x7b\xc0\x1f\x0e\xe3\x04\x43\xb7\xc8\xa8\xc0\x2a\x60\xb0\x6a\xcd\x9a\x1a\x4a\x54\x36\x9f\x8c\x36\xf8\x9c\xf4\x1f\xb0\x05\xed\x56\x0b\xbe\xd9\x54\x7a\x27\x73\x7f\xe0\xb9\x3a\x47\xcc\x1c\xfa\xec\xaa\xac\xe3\xa6\x0f\x6f\xbe\x9b\x74\xf6\x80\x88\x36\x6d\x6b\x46\x8e\x69\x50\x6d\xc8\x2c\x61\x60\x78\xf0\x6b\xfe\x31\x6c\xc3\xc2\xae\xb7\xaf\xff\x7f\xf6\xbe\xb5\xaf\x71\x1c\xd9\xfb\x3d\x9f\x42\x9d\xdd\x21\x76\x63\x42\x12\x68\xba\x27\x99\x74\x6f\x5f\x98\x5d\xf6\xe9\x69\x38\xc0\x5c\xfa\x30\x1c\xda\x89\x15\xe2\xc1\xb1\xb3\xb6\x03\xc9\x00\xdf\xfd\xf9\xa9\x74\xb1\x64\xcb\x8e\x73\xeb\xcb\x0e\xbd\xe7\x0c\xb1\x2d\x95\x4a\x52\xa9\x54\x92\x4a\xff\x22\xb2\xa2\x18\x1c\xc9\x27\xc9\xf0\x06\x26\xd8\xcc\xcd\x0c\xe5\x94\x99\x4c\x1a\xfd\x0f\xf4\xb2\x83\x86\x62\xaa\xdd\x16\xd3\x68\xd6\x5c\xe5\x16\xf4\xd6\x96\xe2\xd2\xdb\xd3\x18\xd4\x5a\x5b\x57\xce\xc8\xd8\xe3\xc6\x18\x31\xa1\x5d\x1f\x8c\x69\xf4\x4a\x9f\x13\xb5\x50\xef\x22\x65\x05\x50\x1a\xf7\xf7\xc8\x30\xfe\xe0\xa4\xa0\xb5\x45\x13\x43\x34\x71\x53\x53\x3d\x49\x7f\xf4\x24\x03\x4e\xaa\xe7\x1f\x5b\x5b\xa6\x5c\xa7\x2c\x89\x0d\x94\xf1\x60\xfd\x23\x47\x18\xe8\x3e\x86\xcc\x9b\x2b\x77\x3f\xa0\xf7\xb0\x13\x2d\x86\xb2\x45\xf9\x11\x58\xa8\xca\xc1\xa7\x4f\x15\xc2\x48\xe4\xa2\x27\x26\xe7\xfe\x79\xfd\x42\x85\x55\xbf\xb0\xc0\x9c\x87\x0f\x49\x84\x68\x5a\x07\x9d\xcc\x4a\x3b\x5a\x85\xcc\xaa\xc7\x57\xe5\x59\xbe\x4d\xe5\x5d\x15\xe3\x65\x78\xbe\x5d\x8c\xdd\xdb\xd5\x72\x9a\xec\x00\xce\x6e\x60\x76\x9e\x56\x9e\xdf\xa1\x92\x73\x55\x2c\xcf\xe6\x76\xb8\x08\xa3\xc3\x55\xf2\xa8\xee\x94\x6a\x99\xe5\x28\x1c\x19\xe5\x9c\xd9\x77\x49\xb2\xce\x2c\x6d\xe1\x92\x4a\x97\xb2\x70\x7d\xe2\x99\x75\xc9\x1e\x98\x1a\x4e\x8a\xba\xee\x38\xf9\xdc\x11\x26\xcc\x45\x1e\xd1\x19\xf4\x6e\xe7\x20\x25\x8f\x98\x02\xee\xe8\x11\x31\x25\xc8\xcc\xcc\x5c\x92\x85\xd4\x86\x73\x10\xe2\x7a\x5d\x4f\x89\xb9\x15\x9c\x6f\x19\x40\xec\x5f\xc1\x38\x8c\x0c\x93\xcc\xb8\x8d\x66\x3e\xcd\xd4\x59\xdd\x1c\x5d\xc2\x2d\xcf\x22\xd2\x73\x75\x4c\x19\x82\x0b\x74\x4f\xb2\xe2\x2b\x22\x5c\xba\x93\xca\x91\x9b\xab\xab\xd8\xc1\xa1\xae\xb7\xb4\x30\xae\xc9\x86\x54\xfa\xf2\x80\x0e\xa8\x57\x82\x06\xa6\xdb\x4c\xf2\x46\x34\x90\xcd\xc3\xe3\xcb\xdc\x45\x68\x53\xfb\x53\xaa\x50\x9f\x99\xa5\xd4\x12\x04\xed\x30\x9b\xbf\x11\xe5\x2f\xb5\xfd\xc6\xd9\x13\xde\x6d\x82\xc1\xd1\x12\x0c\x8e\x14\x06\xc5\x1e\xf7\xd2\x8d\x98\xda\x66\x5f\x6d\x3b\x72\x4f\xd5\x45\x9b\xd2\xe2\x6b\x91\x95\x36\xa1\x88\xb5\x4e\xcf\x29\xc1\xb1\xeb\xae\xb2\x5d\x81\x60\x3a\xa8\x72\x49\x7e\x20\xf2\xab\x5e\x81\xed\x63\x56\x19\x7a\xdb\xe8\x84\xa2\xdd\xfe\x1e\x3d\xfd\xdd\xd9\xda\x81\x80\xe3\x7e\x10\xe3\x16\x72\xaf\xfc\x20\xc4\x11\x8d\xad\x2d\x8e\x74\xa8\x38\xd1\x33\x20\x96\xf5\xbb\x1d\x8b\x0d\xa5\xff\x8c\x83\x18\xd3\xb7\xe7\xbf\xff\xfe\x7f\x7f\x7f\xba\xf5\xea\xfe\xfc\xf7\x0b\xc3\xac\xdd\x3d\x5c\xec\x5c\xc9\x40\x0c\x23\xdb\xe1\x38\xf7\x10\xd2\x89\xc2\x5c\x4a\xf8\x06\x14\x3d\x53\x84\xf5\x40\xaf\x20\x1e\x85\x1c\x1f\x48\x1c\x5c\xd0\x78\x16\xaf\xd0\x36\x4d\xdd\x4a\x20\x98\x93\xc4\x02\x94\x5c\x59\x32\x49\x98\x33\x40\x63\x0b\x19\x8b\x83\xdd\x6f\x71\x8e\x5a\xec\x47\xca\xa5\x90\xb5\x8f\x11\x29\x2e\x85\x51\x2d\xc4\x10\xcc\xdd\x10\xed\x67\xa1\xca\xef\xbf\xff\x7d\xb3\x62\xea\x9c\x08\x4f\xb0\xe1\xdb\x43\x1c\x65\x30\x2c\x4e\xf0\xd5\xc1\x64\x64\x54\xfe\xcf\x78\xd5\x02\xe8\x26\x92\x0a\xae\x8f\x31\xc2\x1c\xbc\xe9\x1e\xc0\x9b\x2a\x26\x91\x08\x57\x5f\x08\xf3\xbd\x92\x0a\xa2\x70\xbd\x44\xaa\xef\x1e\x2c\x25\xb8\x04\x2d\x27\x69\xcf\xf4\x71\xcc\xd0\x1e\x9d\x43\x9a\x73\x37\x6d\xdc\xa1\x0e\x72\xa5\x2e\x18\xda\x23\x95\x99\xbc\xe3\x52\x8d\x21\xc4\x6d\x50\x2e\xd4\x3a\x23\x94\xda\x92\x0d\x53\x86\x1a\x92\x4c\xfc\x2d\x1f\xae\x4c\xe5\xd8\x9b\xc5\x7c\xd1\x7d\xb8\xd5\xf3\x35\x5e\x8c\xaf\x95\x35\x56\x53\xc7\xd4\xcf\xcb\x30\x75\x78\x7a\xb4\x7a\x8e\x7e\x59\x86\xa3\x15\xf4\x9d\x96\xa9\x5f\xe7\x67\x2a\xf1\x72\x5e\x82\x99\x3d\x1d\x33\xd3\xf9\x99\x59\x9a\x11\x6d\xab\x08\x46\x88\xb2\xa5\x3f\x5e\xa2\xfd\x17\xe8\x15\x6a\x7c\x5f\xaf\xa3\x16\x6a\xd6\xeb\x75\xb3\x3c\x97\xff\x1b\xf8\xba\x85\x11\xe7\x72\xe7\xff\x8c\xff\x35\xef\x8d\xf3\xad\xed\x8b\xdf\x9d\xdf\x1d\xd3\x78\xd5\x6a\xbd\x32\xe0\xa7\xf9\x6a\x27\x9f\xf7\x7d\x1d\xef\xff\x4b\xaa\x7d\xde\xb8\x40\xaf\x10\xe1\x74\xdb\xf0\xcf\x9b\x50\x0f\x9f\x63\x8e\xd7\xeb\x15\x73\x0e\xe6\x25\x57\x98\xd5\xb7\xf4\x10\xb8\xad\x5f\x00\x52\x5c\x69\x96\x12\xa7\xa1\xd5\x73\xe4\xcc\x2f\x84\xc2\xc3\x68\x29\x6e\x76\xf3\xda\xa7\x6e\xa1\x85\xd8\xa2\xee\x50\xab\x6f\xa1\x7f\xcd\xcf\x0a\xf3\x99\x5a\x3d\x2f\x3f\xcd\xcf\x0b\xf3\xa8\x5a\x3d\x2f\xa7\x8b\xb4\x4b\xe2\x82\xb6\x7a\xe1\x79\xbf\x08\x43\x89\xd3\xdd\x52\x0c\x69\x75\xd3\x7b\x8e\x08\x42\x21\x17\x61\xe0\xc3\x61\xc9\x3c\xca\x54\xf5\xf1\x2a\x60\x52\xac\x00\xe6\xb1\x67\x52\x5c\xe4\x31\xa1\xb8\xee\x2d\xd8\x50\xba\x16\xfa\x9f\xf9\xbb\x4c\xe7\x45\xb8\x62\x8e\xe8\x1c\x68\x52\x28\xe8\x7a\x29\xd6\xd2\x37\x0a\x08\x47\x23\x65\x3d\x40\x56\x57\x4e\x72\x90\x6a\xa1\x91\x85\x9a\x5a\x4b\x3f\x51\x64\x39\x14\xd8\x06\xc8\x0c\x12\x8d\xe6\x6c\x12\xd4\x9f\xe4\xfe\x1e\x90\xaa\x72\xa9\x29\x0a\x3f\x4b\xb0\x51\x18\x27\x70\xc6\x81\x36\x40\x3b\x94\x09\x35\x54\x78\xbd\xde\x34\x1c\xd3\x42\x0e\x6d\x92\x5d\x6d\x25\xd2\xba\x27\xa7\x61\x94\x64\xc5\xf4\x54\xd5\xa1\xd2\xcb\x2d\x73\x8b\x18\x24\xf5\x8a\x96\xa2\x6a\x79\xe4\x31\x48\x37\xd4\x00\xd9\x38\xbf\xcb\xa4\x19\x28\xb7\xa2\x34\x45\x91\x18\x9d\xce\x6c\xae\x53\xa5\xa5\xf4\x54\xb4\xab\x32\x09\x9f\x9a\x42\x52\x2a\x87\xef\xe2\x1e\x61\xe2\xd7\xf1\x9c\x42\x72\xe5\x15\x90\x5e\x5e\x65\xf9\x2d\x29\x5c\x83\x04\x57\x60\x9c\x38\x86\xac\x5e\x4a\xf3\xdb\x4a\x59\x94\x8d\x8a\x1b\x8a\xd8\x49\xe0\x47\xf0\xb2\x93\x72\x85\x31\xcb\xc4\x3e\x57\x18\x76\x05\xc3\x67\x83\x71\x18\x09\x27\x16\xa7\x38\xd4\x79\x09\x1a\xd4\xb1\xc6\x91\xbb\x76\x8e\x1e\xc9\xa3\xb9\xd2\x3e\x21\x4b\x86\x55\xd0\x12\xbd\x43\x63\x6b\x96\x1e\x17\x5c\x72\x15\xb1\x95\xfb\xba\x48\x56\x92\xe5\xf2\xc2\x62\xaf\xf7\x87\xfa\x5c\x62\x9f\x3f\xb9\x38\xaa\x03\x13\x75\x27\x29\xa0\x24\x2f\xd7\x4b\x52\x63\xf4\xf6\xb4\xf4\xe8\x5a\x36\x19\x84\x7f\xf2\x21\x48\x6c\x90\x3f\x03\x1f\x1f\x51\x8f\x2c\x59\xb6\x8d\x3f\x19\xdc\x3b\xdd\x1e\x35\xfe\x44\x4f\xe9\xde\x5c\x65\xab\x22\x05\xa8\x21\x0c\xfd\x89\x76\xd0\x3e\x38\xcf\x58\x34\xc2\x51\x33\xfd\xfd\x3b\xb4\x9f\x7c\xd3\x71\xa8\x5c\xd1\x2a\xa8\xb6\xf0\xd4\x2b\x68\x3d\x71\x61\xab\x98\xce\x6c\x03\x44\xdc\xef\x2a\x45\xa8\x9c\x19\x22\xdf\x0c\x5b\xda\x12\xc9\x38\x52\x2e\x22\xeb\x37\x9c\xc8\x1c\x76\x48\xea\x0a\x5b\x71\xfb\x94\xb6\x46\x52\x37\xf1\xf2\x0c\x12\x7d\xe1\x05\x36\x89\x7a\xa1\x6e\x06\xb3\xa5\x2c\x93\xe4\x0e\xde\xac\xaa\xcf\xb6\x4f\x92\x7b\x75\xc5\xb4\xca\x58\x29\xfa\x8b\x78\x8a\xa1\x12\xdc\xf2\xc1\x2f\xbb\x20\x0b\x80\xfc\x5b\xd5\x56\x09\x6e\x0b\x8a\x59\x99\xb9\x12\x71\x11\x5c\xd2\x5a\x29\x16\xe5\xc2\x26\x2b\x61\xaf\xc8\xed\xb5\x4a\x93\x25\xe6\x5c\x2f\x6e\xb1\x68\x49\x2c\x67\xb0\xe4\x90\x5c\x65\xaf\xcc\x6f\xae\x68\x49\x29\x5e\xb1\x33\x0d\x16\xfd\xfd\x51\x9d\xcd\x92\xf4\xf7\x0c\xa9\x59\x81\xe5\xa2\xf5\xda\xff\x7c\x23\x60\x86\xb1\xa1\xb8\xda\xcf\xb4\x5e\x14\x54\x95\x79\x68\x16\xda\x30\xec\x6a\xad\x8a\x69\x57\xd9\xaa\xe7\x29\xfd\xd4\x96\x93\x9a\xed\x3b\xfd\x3c\xa1\x6e\x10\x29\x59\xb6\x9c\x99\x39\x84\x16\x57\x32\x4a\x7b\x67\x5b\x0e\xdf\x39\x03\x5a\x29\xb4\xa3\xef\xeb\x5f\x7f\xec\xa9\x3c\x1c\x32\x37\x0a\x4e\x25\x7f\x82\x85\x23\x4f\xcd\x03\xcb\x46\xdd\x12\xe4\x92\x51\x07\x55\xbe\xfb\xb8\xfd\xdd\x70\xfb\x3b\xe7\xec\xbb\x7f\xb5\xbe\xfb\xa9\xf5\xdd\x69\xed\xbb\xf7\xff\x5b\xc9\x86\xcb\x3d\x8c\x82\x0f\x76\xec\xde\x60\xe9\xe6\xa2\x04\xfc\x53\x8b\x83\xc3\xd3\x23\x16\x30\xcc\x14\x4e\x10\x22\x2f\xea\xc0\x15\x29\x25\xc4\xa5\xc8\x00\xc6\xef\xab\x74\x41\xf0\xb6\xd4\x8d\x0c\x1d\xda\x19\x1b\xd6\x12\x40\x9f\x21\x57\xdd\xa4\x31\xb7\x52\x48\x5b\x59\xd8\x48\xe8\x01\x9a\x4a\x34\x2c\x4b\xc5\x3a\x1a\x00\x24\x39\xe7\x1a\x30\xbf\xef\x1b\x5f\x13\x98\x9f\x17\x38\x76\x34\xb8\x74\xa3\x1f\x19\x27\xf9\x41\x51\x16\x0c\x44\xa3\x2d\x83\xb7\x99\xbe\xac\x5a\x11\x5a\xaf\x96\xde\xa2\x51\x78\x42\x6c\xf7\xf2\x91\xe0\x16\x8e\xb3\xc9\xc8\x2e\x51\x4b\x41\x63\xd1\xe8\x3f\xa3\x30\x18\x5d\xc6\x85\x91\xb9\xeb\xab\xa0\xbd\x44\x1d\x55\x42\x8b\xc6\x22\xea\x79\x76\x14\x81\x1f\x4b\xbe\xbe\x5b\x05\xed\x25\x2a\xaa\x12\x5a\x38\x24\xd2\x38\x76\xbd\xcb\xe3\x71\x88\x4f\xb0\xef\xe0\x30\x5f\x6c\x17\x0c\xdd\xca\xe0\x7b\x6d\xd7\xc7\xe1\xe5\x7b\x7b\x5a\x54\xc4\x82\xf1\x97\xf6\x2f\x2f\xa3\x81\x3d\xc2\x97\xef\x82\xfc\x61\xf7\x7c\x41\xc1\x7c\xce\x9a\xe8\x84\x8c\x9c\x9f\x63\xd7\x2b\x88\xf0\xb4\x60\xe8\xab\x17\xa4\x89\x86\x34\xc4\xe0\xe5\x7b\xbb\x8b\xf3\xc3\x3b\x3e\x5b\xb0\x17\xbe\x67\xb5\x78\x67\xc7\xf6\x8c\x4a\x2c\x1a\x7c\xac\xce\x8a\x78\x3b\xb0\xc3\x19\x0d\x25\xc5\xa8\xbc\x84\x98\x0c\xe0\xc4\x48\xe7\xe0\x9a\x1d\x81\x73\xde\xfd\x7d\xe2\xcf\x6b\xb0\xa8\x02\xe8\x0e\xee\x32\x1b\xfc\xf6\x54\xa3\x8d\x5c\xf4\x43\x06\x9e\xbd\x8d\xe0\xf2\xd0\x1d\x75\x2d\x0c\xc6\x21\x20\x70\x8b\x54\xe7\xee\x45\x3b\xa1\x73\x8d\xa7\xc8\xf5\x59\x32\x92\xc9\xed\xf3\xf5\x8f\x64\x47\x0c\xec\xe8\xe8\xd6\x3f\x0e\x83\x11\x0e\xe3\x29\x85\x70\xa7\x59\x2c\x42\xc1\x24\x19\x29\x93\xe7\xd7\x78\x7a\x81\x3a\x8c\x20\x3c\xb5\xd1\x03\xfc\x8f\x07\x95\x82\x74\xe0\xe0\x49\x9b\xa0\x17\x62\x3b\xc6\x6f\xc9\x68\x96\xdc\x42\x11\x98\x72\x49\x2c\x2b\xdc\x77\x7d\xcc\x38\x70\x71\xc4\xda\xc4\x42\x44\xdd\x45\x99\xa6\xa9\xd3\xa6\x81\x8f\xba\x66\x71\x70\xd4\x0b\xdd\x51\x1c\x84\x10\x44\x3c\x18\xd1\x66\x49\x5e\xd7\xb0\x3f\x1e\xe2\x10\x22\x6b\x74\x72\xde\x93\x3e\xb2\xbd\x08\x2b\xf9\x7a\x81\xdf\x77\xaf\xc6\x3c\x67\x1c\x8e\x71\x9b\xde\xf5\x03\x47\x4d\x7a\xdf\x4f\x24\x37\xe5\xac\xb7\xa1\x1b\x2b\xd9\x58\x3f\x28\x75\x9f\x8a\x9a\x4b\x39\xaf\xf1\x54\x7e\x36\xdb\x72\x83\x27\x2d\xfa\x36\xf0\xa3\x38\x1c\xf7\xe2\x20\x84\x86\x8b\x03\x42\x34\x82\xc8\x25\xb1\xdb\x3b\xe6\x4d\x49\xd8\x4d\x3e\x9b\xd9\xc6\x97\x08\x25\x52\x22\x93\x34\x69\x9d\x15\xba\x45\x54\x54\x16\xda\x9c\x75\x29\x05\x11\x18\xf4\x00\x31\x23\xa9\xd4\x10\x79\xb1\xd8\xdf\xa6\x85\x2e\x63\x3c\x1c\xc9\x26\x35\xfd\xf2\xd6\xf6\xbc\xb7\x03\xdc\xbb\x36\x38\xd4\x86\x25\x53\xe5\xb5\x7d\x22\x3e\xcb\x90\x1c\x72\x42\x10\xf1\x41\x18\xdc\x82\xff\xe9\xd9\x74\x84\x0f\xc2\x30\x08\x8d\xca\x5b\xdb\xf7\x83\x18\x91\x31\x81\x6c\x04\x85\x22\x3b\x42\xb6\x68\xf7\x0a\xed\x0e\x99\xb5\x51\x10\x45\x6e\xd7\xc3\x52\x01\x27\x50\x63\x23\xc2\x5e\x1f\xc0\xdc\x3d\xc1\x1a\x79\xa5\x96\x7e\x82\xfb\x38\xc4\x7e\x8f\xb3\x10\x0f\xdc\x08\x0d\xec\xc8\xaf\xc6\xa8\x8b\xb1\x8f\x00\x87\xc6\xf6\x5c\x62\x77\x6f\xa3\x68\x3c\xc2\x64\x3d\x2b\xa7\x20\x25\x60\x87\xb2\x96\x60\xb1\x7b\x68\x73\x53\x84\x67\x81\x67\x00\xe4\x08\x40\x0e\x2b\x44\xe0\x33\xdf\x92\x5a\xa2\x57\xf4\x75\x0b\x11\x8e\xdb\x6a\x8d\x5d\x7f\x80\x43\x37\x8e\x8c\x68\xdc\x7d\x4b\xbb\x0e\xd8\x82\xdf\xbc\xaa\x8c\x78\xf2\x01\x3d\x51\x8a\x20\xdc\xa5\x3e\x52\xa0\x91\x9c\xae\x39\x25\x69\xc9\x42\x23\xc4\x11\xc4\xb1\x07\x58\x1e\xec\xc6\x03\x1c\xa2\x2e\xa6\x11\x0d\x82\x50\xea\x2b\x0b\x91\xbe\xac\xa0\x2d\x94\xe1\x05\x9a\x8a\x73\x9f\x48\x7d\xa2\xb9\xa9\x1e\x33\x24\x06\x15\x76\xe5\x81\x72\x87\x7a\x49\xcf\xb7\x40\x27\x79\x63\xdc\x42\x49\xe3\x24\x6a\xa6\x45\x95\x8c\x85\xb8\x7a\x68\x81\x76\xb0\x90\xac\x69\xe8\x3b\x22\x66\x7c\xe4\x49\x8d\xcb\xf8\x8b\x70\x7c\xcc\x59\x38\xea\x8b\x1d\xc1\xd4\xfb\x9c\x0e\x4a\x78\xab\x5d\x5e\x42\x4d\x60\x7a\x4b\x92\x40\x7f\xef\x3c\x7d\xba\x81\x9e\xa2\x7f\xf4\x5d\x0f\x1f\xdd\xe0\xf0\xc6\x95\xa5\x15\xbd\x0b\xe2\x8d\x04\x57\x39\x09\xd8\x28\x52\xbc\x0b\xe2\x32\x81\x5a\x74\x76\x9b\x36\x52\x03\xd5\x01\x64\xf5\x08\xea\x81\xcc\xc7\x54\x5f\x28\x13\xcd\xe5\x5b\x6e\x7e\xd0\x25\x77\x22\xac\x32\x63\x16\x92\xd2\xa9\xd8\x44\x72\x32\x11\xe0\x21\xad\x7f\xc8\x20\xb5\x94\xa4\x1c\xc7\x84\xe3\x8d\xe7\x6b\x05\x9a\x57\x61\x47\xea\x86\xfb\x7b\xde\x95\x57\x6a\x57\x2a\x85\x99\x35\x7b\x34\xf2\xa6\x8c\x96\x30\x07\xcc\xe4\x92\x9c\x3c\x13\xa7\xaa\x7e\x4e\xeb\x74\x8d\xa7\x2d\x54\xbd\xc2\xf1\xdb\x00\xee\xb9\xdb\x31\xae\x5a\xec\x5a\x24\x08\xb0\x68\x12\x25\x8d\xa1\x5e\x17\x81\x25\x0a\xe9\x15\xc2\x4a\x0d\x1e\x64\xc8\x99\x09\xe9\x26\x3a\x73\x4f\xe4\xf7\xd3\xe4\xfd\x54\x49\xff\x7a\xe2\x46\x52\x1e\xf2\xa8\xe4\x53\xbf\xc3\xa3\x80\x77\x21\xfc\x4c\x4e\x59\x7c\x49\xc8\x5a\x13\x61\x3c\xf8\xf7\x29\xff\x3e\xd5\x7f\x0f\x71\x44\xd7\x30\xd2\x6d\xf0\x49\x8b\x91\x35\x26\xb0\xa5\x4c\x1f\x6a\x5d\xdb\x77\xf8\x5d\x8b\xf4\x2b\xc3\x44\x3b\xa8\x89\x5a\x0a\x02\x4f\x6f\xda\x62\xe5\x1b\x53\x20\x34\xcd\x12\x4a\xbf\x92\x08\xf1\x7b\xdb\x0a\xf6\xd4\xcc\xf1\xa5\x35\x66\xcf\x2b\x6f\x61\x80\xdd\xd8\x9e\xeb\x10\x31\x11\xdd\x7b\xe8\x9f\xd8\xfe\x15\xa6\x43\x8e\x36\x46\xad\x37\xb1\x58\x05\x4d\xa2\x06\x3f\x4b\x91\x53\x8b\x35\x85\xee\x12\x3b\x4d\x94\xc1\x44\xc8\xe0\xed\xc0\x05\x23\x0b\xc9\xf2\x1e\x82\x8a\x79\x17\xc4\x39\xb2\x2e\xbe\x1b\xc1\x88\x4e\x22\xdc\x28\x95\x84\xc4\x01\xd5\x76\x13\xb8\x0e\xaa\x2b\xbd\x31\xc7\x9e\x47\xcd\xae\xb9\xd1\x2f\xa4\x31\x0e\x3c\x4c\x46\x2f\x2b\x50\xa9\x2f\x2d\x68\x3e\xaa\x3d\x2f\xf0\xb1\x4a\x93\x57\x42\x83\x1e\xb0\xe0\xbe\x94\x61\xe6\xb3\x4b\x3f\x18\xda\x22\x97\xac\x1a\xe8\x34\x5e\xb7\xb2\xab\x68\xcd\x6c\x62\x89\xc5\x9a\x71\xf7\xc0\x5a\xc7\x52\xb0\x77\xc8\xa0\xa7\x3a\xa6\xa7\x28\x2e\x32\x86\xd9\x7b\x45\x71\xc1\x04\xf1\xc1\x1e\x62\x90\xb1\x1e\x11\xfc\x68\x3b\xe4\x7a\x77\xdb\x09\x62\xf2\xff\xd5\x04\x08\xc6\xcc\x62\x7a\x88\x33\xd2\x78\x86\xf8\x16\xca\xae\x56\x41\x37\x4b\x68\xe8\x66\x9e\x8a\x6e\xaa\x3a\x3a\x94\x3e\x84\x8a\xf2\x75\xa3\xdf\xca\x4c\xf9\x9a\x15\x3c\x77\xad\x71\xa3\x0f\xe3\xe1\x51\x78\x1a\xb3\xb3\xa5\x89\xd9\x56\xe8\x7f\x5c\x31\xfd\xa9\xa9\x22\xf9\x91\x1a\xdc\xdf\xa3\x27\x6e\xf4\x51\xa3\x77\x64\x24\xaf\x07\xb9\xe2\x3d\xa1\xcc\x78\x3b\xa7\xe6\x4c\xb5\x94\x24\xf9\x3c\x85\xd0\x36\xdf\xcd\xed\x49\x10\x79\xd1\x37\xbb\x35\x78\xd6\xca\xa8\x94\x48\xbc\x6b\x6f\x6c\xa8\x1a\xee\x98\x4d\xec\xca\x48\x99\xd9\xf6\xba\x3d\x26\xee\xee\x04\x16\x0d\x8e\xb0\x1f\x43\xdc\xc2\xd7\x71\x1c\xba\xdd\x71\x8c\x23\xda\x17\x49\xad\xcc\x85\x0b\xa2\xbd\xdc\x77\xbd\x18\x87\x07\x37\xd8\x8f\x0b\x0b\x91\xfa\xa1\x9d\x1a\x84\xcb\x28\x26\xd1\xe4\xf3\x6d\x25\xea\xf4\x94\x20\x75\x27\x6b\x98\x79\xb7\x64\x0d\xd3\xc8\x51\x4a\x55\x2b\xa1\x6b\xf2\xcb\xc2\xe4\x1f\xb4\x53\x32\x19\x52\x59\x12\x62\x21\x19\x35\xf3\xed\x05\x6a\xea\xc8\x4a\x21\xc6\xf5\x9b\xe9\xb1\x1d\x92\x16\x94\x04\x5c\xd1\xca\x93\x96\xd4\x67\xb5\xde\x04\x6d\xa3\x50\xd1\x59\xea\xf7\x69\xfa\x3b\x98\x54\x2d\x08\x0f\xac\xbc\x1f\x60\xf7\x6a\x10\xb3\x0f\x92\x8e\x66\x3f\x4d\x49\x1f\x5f\x98\x72\x30\x35\xd9\xb2\x6e\x6f\x3c\x94\x31\x00\xce\x2b\x62\xe9\x51\xb9\x30\xc5\xae\x47\xcd\x71\xa3\x91\x67\x4f\xd9\xf8\xac\xca\x94\xab\x49\x2a\xd2\x28\x64\x55\x9c\x19\x99\xf3\x8e\x14\x1a\xdc\xeb\xf8\xe4\xe0\xf4\xe0\xc3\xd9\xeb\xb3\xc3\xa3\x0f\x97\xaf\xcf\xce\x4e\x0e\xdf\xfc\x7c\x76\x70\x3a\x2b\xc8\x97\x9e\x24\xed\xda\x83\x5f\x0e\x3e\x9c\x65\x68\xc1\xf1\x67\x91\xe4\xea\x4f\x4d\x6a\x76\xcd\x67\x80\xcb\x1b\x6c\x75\xb0\x10\x11\x90\x5f\xe3\x8e\x06\xbf\x5b\x88\x02\x99\x65\xe1\x8c\x92\x2d\x42\xbe\x34\x1b\x1b\x08\xb9\xd1\x8f\x61\xe0\xc7\x0b\xd1\xe9\x06\x01\x20\x92\xdb\xde\xad\x3d\x8d\x4e\x07\xc1\xed\x52\x64\x26\x0b\xe5\x06\xc7\x50\x22\xcd\xc6\xf9\xe2\x82\xb1\x50\x3f\xc0\x31\x3a\x8d\xd5\x3f\xfd\x56\x59\xdf\x40\xe5\xe6\x84\xaf\xb9\x0e\x6c\x30\x1d\x3a\x5f\xa0\x02\xfc\x2e\xd4\xc2\x75\xa7\x15\x98\x7c\xeb\x15\x00\xa5\xf4\x05\xd8\x27\xaa\x6c\x21\xe6\x31\xb5\xb3\x2e\xcc\x8d\x07\x79\xfe\xa4\xdf\xb9\xd9\x7a\x27\x2b\x48\xba\xeb\x9a\x52\x77\xe2\xa5\xe8\xc1\xba\x22\x90\xf0\x14\xb6\x50\x03\x7e\xf4\x5d\xcf\x6b\xa1\xea\xdf\xfa\xfd\x3e\x2c\xbf\xa2\x38\x0c\xae\xc9\x6a\xef\x6f\xbd\x5e\xaf\xca\x53\x1c\x8d\xec\x9e\x1b\x4f\x5b\xa8\x91\xa4\xf9\x95\x1a\x1d\x8d\x8d\x07\x76\xb2\x61\x9a\x64\x8d\x41\xf9\x6e\x2f\x12\x86\x95\x06\x8a\x33\xd2\xfb\x8f\x29\x3f\x9a\xe6\xa3\x1f\xcd\xa3\x1f\xcd\xa3\x1f\xcd\xa3\x1f\xcd\x5f\xd3\x8f\x66\xdd\xae\x2e\xcf\xd7\xef\xea\xf2\x62\xed\xae\x2e\xdf\x2f\xe6\xe9\x02\x57\xc3\x9d\xb3\x00\xe0\xa5\xf2\x1d\x3d\x20\xd9\x61\x8c\x43\x3b\x0e\x42\xc3\x0e\x43\x7a\xf1\x9c\xf2\x64\x87\x21\xc4\xee\x68\xd3\x47\x5f\x78\x4a\xc0\xa3\x43\xa8\x52\x87\x0c\xea\x5b\x83\x3a\x68\xec\x53\xb7\x03\xa7\x8d\xe2\x70\x2a\xbb\x89\x5c\xba\xe0\x15\x13\x9e\x9f\x4e\x87\xdd\xc0\xab\xb9\xac\xcc\x0b\x83\x18\x08\x51\x1b\x3d\x31\xa0\x00\xe3\x12\xd6\xcd\x6e\xcd\xc7\x93\xd8\x30\xcd\x9a\x13\xf8\xd8\x6c\x27\xa5\x13\xee\x08\x67\x34\x3c\xc4\x65\x54\xa3\x88\x5c\x6d\x16\x2a\x61\x73\x93\x7e\xe5\xa0\x5c\x9d\x0e\xa9\x50\x37\xc4\xf6\x35\x75\xd3\xe8\xd9\x71\x6f\x80\x0c\x1c\x82\x37\x02\xd4\x82\x56\x0a\x2a\x80\xc3\x90\x24\xeb\xbb\xbe\xed\x79\xa4\x02\xb4\x1a\xb0\x27\x78\xe9\x03\x75\xf7\xbc\x42\xb7\x16\x2a\x17\xa6\xf2\x64\x98\x6a\x56\xd8\xbc\x77\x4c\x76\x58\x7e\x89\x15\x37\x11\xc2\x64\x5b\xe7\x35\x92\xf4\x01\xc9\x0f\xdd\x57\x73\x23\x8a\x12\x66\x87\xd4\x33\x82\x65\x62\x24\xc4\x49\x41\xaa\x69\x91\x2b\x02\xde\xa7\x32\x6a\x7b\x5d\x90\xca\x39\xde\x3f\xf4\xe1\x60\x08\xd9\x31\xb1\x90\x62\x08\xc1\x80\xe9\xc9\xe9\x38\xc4\xc8\x0f\xfc\x6d\x28\xb9\xeb\x25\x5e\x1d\xcc\x19\x43\x75\x25\x79\x74\x40\x7a\x74\x40\x5a\x99\x03\xd2\xa3\x5b\xdf\xa3\x0f\xd6\xa3\x0f\xd6\xa3\x0f\xd6\x57\xea\x83\xf5\xde\xf5\x71\xda\x09\x8b\x3a\xb1\x10\xbb\x9d\x7c\x95\xe7\xc0\xe4\xad\xce\xb7\x01\x02\x7a\xd3\x1c\x92\x63\xc3\xaa\x9d\x1a\x58\x09\x2b\xf5\x68\x58\x87\x37\x03\xe3\x33\xe3\xca\xa0\xb8\x31\x2c\x56\x19\xe5\xa8\xb0\x4a\x68\x54\x8b\xdd\x11\x66\xb8\x16\x10\x0a\xf0\x1f\xea\x5c\xf0\x20\x39\x81\x71\x8c\x68\xd7\xc7\xed\x0d\xee\xa3\x2d\xc4\x87\xc9\xc7\x57\xe8\xa1\x47\x38\x2b\xe3\xa2\x07\xb2\x5c\xd2\x47\x8f\xa4\x5d\xdc\x49\x8f\xe4\x9e\xcb\x4b\x0f\x8a\x5b\xd4\x4d\x8f\xd6\x3f\xed\xa7\x77\xe0\x3b\xc7\x81\xeb\xc7\x51\xbe\x9b\x9e\x48\x62\xb8\xd1\x6f\x16\x52\xbc\x18\xca\x78\xeb\x2d\xe0\x7d\x27\x7f\x27\xea\xe9\x4d\x20\xf9\xfc\xb1\x17\xb2\x0f\x07\xf9\xca\x5e\x67\xfd\x4d\xf8\x87\x69\xe6\xd0\x56\xfa\x08\xcf\xd9\xd3\x5b\x29\x05\x7d\x91\x78\x34\xc0\xe2\x4d\xf5\xe8\x20\xac\x50\xd4\x65\xb9\x31\x6a\xd3\xb6\x92\x22\xd2\x39\x0b\x2a\x29\x58\xb0\xa0\x0e\x4d\xaa\xb8\xf2\x45\x79\x9e\x7c\x6a\x19\x70\x60\xcd\x09\x18\x02\x01\x9a\x12\x96\x4a\x2b\xe5\xed\xa7\x5b\xcf\x97\xf4\xbc\x03\x3e\x2c\xca\x86\xa9\xc6\x9d\x63\xe3\x85\xb6\x42\x10\xba\xdc\x83\x03\x2c\x96\xaa\x87\xfb\x71\x15\xbd\x42\xe7\x77\x68\xd2\x42\x13\x4b\x9c\xc2\x83\xf3\x12\xbc\x43\x5b\xb4\x17\xe5\x6f\x17\xa8\xc5\xb3\xe8\x3e\xf3\xac\x4a\x96\xc2\x40\x5a\x6e\xf4\x5b\xba\x87\x2f\x35\x5d\x3c\x51\x9b\xff\x32\xd2\x39\x8c\xaa\x49\x44\x27\x5f\x66\x7b\x39\xfd\x2a\xaf\x9b\x2f\x79\x3f\xd3\x0c\xc6\xa5\xe8\xe9\xcb\xcf\xde\xd5\x97\xac\xaf\x2f\x0b\x3a\x7b\xa2\xef\xec\x38\x18\x25\x7d\xcd\xe9\x4c\x5b\x68\x2a\x7a\x4c\x79\xb9\xc5\x07\xa7\xd4\xdd\x39\x09\x74\xd9\xb5\x3d\x3e\xbf\xbb\xe7\x97\xf5\x97\x53\xfd\xb2\x9a\x65\xfc\xb2\x9a\x8a\x5f\x56\xc2\x5c\x49\x07\x3b\xcd\xbe\xe1\x4a\x1d\xec\xe6\xa0\xaf\x73\xb0\xdb\xdc\x9c\xdb\xc1\x0e\xf3\x89\x4d\xf2\xaf\xd3\x4c\x76\x6a\x59\x22\xd3\x5c\x5e\x76\x72\x51\xea\x46\xa7\x21\x3e\x59\xa8\xa9\x44\x56\x8d\x62\x1b\x2e\xb6\x27\x99\xcf\xeb\x4a\x50\x62\xec\x3b\xea\xe7\xc6\x85\xd2\xb1\xa3\x85\x9c\xed\x74\xbb\xdc\x6b\x71\xb6\xd3\x17\x34\x9f\xb3\x5d\xd2\x05\x93\x46\x8b\xb6\x98\x3c\x80\xa6\xe2\xa5\x34\x78\x26\xcd\x16\x69\x3a\x25\x1d\x7b\x35\xe5\x9d\xf7\x97\x74\xdd\x63\xcb\x06\xbd\xef\x9e\xb4\xd0\x63\x7e\x7b\xa3\xd2\x4e\x7b\xba\x53\x8d\xe5\x9d\xf6\x00\xa3\x64\xe8\xb2\x95\x54\x6d\xd2\x60\x2c\xd5\x26\xea\x38\x9a\x66\x92\x4e\x45\xd2\xa9\x9a\x94\xb9\xf2\x41\x72\xbb\x1b\x71\xca\x4d\xb4\xcd\x49\x37\x4c\x9d\x8b\x5f\x2a\xc3\x34\xc9\x30\x6d\x98\x0b\xb9\xfe\xbd\xa7\xcb\xab\x75\xf8\xfe\xbd\x67\xab\xc3\xc5\x9d\xff\xf4\x23\xb7\x84\xf3\x1f\xec\x09\x50\x7b\x7a\x19\x57\xb7\x0d\x26\x01\x4b\x38\xfe\x31\xc1\x58\x92\x02\x93\x97\x25\xa9\x70\x29\x5a\x98\x0c\x91\x23\x73\x49\x67\x46\xba\x7d\xb8\x9c\x27\x22\xa7\xf1\xe8\x46\xf8\xe8\x46\xf8\xe8\x46\xf8\x15\x78\xe1\x7d\xe3\x6e\x84\x4b\xf9\x11\x92\x15\xd9\x67\xf0\xe5\x63\x2e\x7c\x7e\xe0\xe3\xaf\xce\x85\x8f\x6f\x4f\xa6\x7c\xf8\x76\x1f\x7d\xf8\x1e\x7d\xf8\x1e\x7d\xf8\x1e\x7d\xf8\xfe\x9a\x3e\x7c\xeb\x76\xb0\xfb\x3c\x88\x58\x5f\x99\x0f\xdf\x82\x88\x58\xf4\x46\xf5\x09\xee\xc5\xb6\x7f\x55\x00\x9e\xf9\xe2\x11\x11\xeb\x11\x11\xeb\xd1\x21\xed\x11\x11\xeb\xd1\x1b\xeb\xd1\x1b\xeb\xaf\xee\x8d\xa5\x7a\xdc\xbc\x0e\xb1\xfd\x75\x7a\xdc\x10\xce\xca\x78\xdc\x90\x74\x65\x3d\x6e\x48\xda\xc5\x3d\x6e\x48\xee\xb9\x3c\x6e\xa0\xb8\x45\x3d\x6e\x68\xfd\xd3\x1e\x37\xc4\xd8\xc9\x77\xb6\x21\x5f\x8d\x81\x1d\xfd\xd6\xb0\x88\xf2\xf9\xad\x09\x7f\x3e\xd2\xa7\x8f\xcd\xf9\x3c\x6f\x7e\x21\xf4\x1b\x92\xef\x4d\x23\xfb\xb9\x29\x7d\x6e\x2a\xc7\x26\xe9\xdc\xd3\x46\xf6\xb3\x94\x7b\xda\xfc\xaa\x30\xb7\x26\x47\xdc\xbf\x62\x2e\x64\x2d\xa5\x08\x41\x62\x2e\x4c\x2d\x85\x0b\xea\x20\x21\x98\x08\xc9\xa3\xa1\x1c\x8f\x4f\x79\x92\x69\x6e\x92\x49\x43\x38\x50\x2a\x6d\xdc\xd4\xbe\x9e\xea\x53\x4f\x9b\x7a\x78\x29\x10\x36\x53\x39\x49\x15\xfc\x1a\x4c\x84\x4c\xb4\xc5\x1b\x34\x17\x7b\x89\x66\x83\xca\x9c\xd7\x2f\x32\xc7\xe0\xbc\xa8\xa6\x52\x54\x33\x5d\x54\xb3\x54\x51\xcd\xa4\xa8\x46\x6e\x51\x1f\x95\x5a\x41\xab\x70\xa0\xb4\xa4\x56\xd3\x19\x45\xd1\x6c\xb3\x6a\xf5\x51\xa9\x15\xb4\xb4\x52\x54\xb3\x54\x51\xcd\xa4\xa8\x9c\x5a\xad\xd3\x7f\x67\xd2\x98\x0f\x90\x6d\x99\xa2\x9a\x9f\xad\xa8\x69\x43\x60\xbe\xad\xbd\xa8\x66\x11\xbc\x5c\xde\xe1\x35\x34\x7b\xfe\x81\x35\xf0\x5f\x7c\x48\x0d\xc7\xd3\xb3\x0e\xa6\xe1\x48\x5a\x39\x8c\x5e\x02\xe9\xae\x60\x0a\x4b\x12\x14\x61\xdd\x85\xb8\xf7\x99\xc0\xee\x58\x49\xdf\x0c\xda\x1d\xe3\xb7\x1c\xdc\xdd\x62\x95\x2b\x89\x77\xa7\xdd\x9e\x59\x0c\xf6\xae\xd8\xd7\xdc\x0e\xb1\xbd\x4d\xaa\x52\x0a\xc8\x8e\x24\xfc\x9c\x9e\x79\x0d\xd9\x35\xaf\x91\x99\x7e\xc5\xa7\x66\x66\x0a\x16\x7e\x7b\x8d\xcc\x34\x2c\x3e\x35\xe7\x71\xd9\x93\xd8\x86\x49\x7b\xd5\x5e\x7b\x0d\xc5\xe8\x80\xc9\x7a\xd5\x45\x34\xd3\x45\x7c\x5c\x75\x2d\xa6\x99\x5a\x7c\x5c\x75\x2d\xa6\x99\x5a\xfc\x86\x3a\xac\x4b\x36\x37\x69\xc3\xa5\x79\xa0\x09\x3e\xf2\x04\x1f\x9b\xaa\x57\xa1\xc8\xfc\x84\x36\x3b\xfb\xf5\x51\xbc\x53\x2d\x8c\x59\xfe\x86\x4c\x31\x70\xa7\xc6\x59\x8b\x0a\x95\x17\x92\x79\x9e\xc2\xb8\x2b\xaa\xe4\x0e\x0d\xaf\x12\x89\xfd\x0b\xf9\xd0\x11\x65\x56\x06\xff\x0e\xba\x84\x39\xd2\x29\xfa\x53\x76\x78\x83\x9e\x28\xe5\x61\xa7\x3b\xd6\x58\xc0\xc3\x0e\x0a\x2c\xef\xa4\x46\x16\xb8\x6b\x72\x52\x7b\x4d\xdb\xf1\x4b\x20\xd4\x3d\x3a\xa9\x3d\x3a\xa9\x7d\x7e\x27\xb5\xc6\xb7\xeb\x26\x35\x69\x7e\xbb\xbc\x4f\xbf\xe1\x76\x9f\x7e\xb3\xed\xfe\xe8\x1e\xf8\x15\x78\xd7\x7d\xf3\xee\x81\x8f\x28\x83\xf3\xa1\x0c\x6a\x1d\x12\xeb\xb5\x67\x8a\xdb\x62\xca\x91\x71\xfd\x4e\x8a\xfc\x44\x27\xe5\xa4\xb8\xf7\x35\x39\x29\xae\xc5\x4b\xaf\xbe\x02\x2f\xbd\xfa\x72\x5e\x7a\x8d\x35\x7a\xe9\x35\x56\xe5\xa5\xd7\x58\x81\x97\x5e\x73\x8d\x5e\x7a\xcd\x55\x79\xe9\x35\x57\xe0\xa5\xb7\xbb\x7e\x2f\xbd\xbd\xb5\x3b\x9f\x3d\x9b\xd3\x83\xee\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xd1\x2d\xec\xbf\xd9\x2d\xec\x6d\x18\x44\x91\xec\x0d\x46\xc6\x2f\xbc\x2c\x73\xc2\xa1\x33\x0d\xd6\xe2\x00\x06\x1c\x15\x38\x7e\xc1\xf7\x19\x0e\x5f\x90\x66\x6e\x47\x2f\xc8\x55\xc6\xc1\x8b\x92\x9f\xd3\xb1\x8b\xd5\x2b\xed\xd0\x75\x6c\xc7\x83\x7c\x87\x2e\xf2\xd5\x98\x58\x68\x6a\x71\x38\x1a\xba\x93\x6a\xa1\x38\x18\x59\xc8\xc3\x7d\xe9\xb0\x85\x55\xb4\xfa\x53\x15\x6d\x01\x82\x4d\xd5\x22\xbf\xe2\x60\x44\x7e\xdf\x54\x13\x64\x93\x2d\x96\x88\xe4\x17\xe9\xa6\xe4\xd7\xa0\xca\x91\x6f\x56\x7e\x4c\xba\xb2\x88\x8c\x1c\x7d\x89\x7d\xcb\x07\x5f\x62\x09\x58\x93\x49\x29\x48\x93\x88\xcf\xa4\x25\xa5\x6f\xd0\x26\xe2\x23\x79\x2a\x3e\x65\xd5\x1d\xb2\xc2\x7c\x51\xda\xa7\x52\x39\x34\xec\x27\x87\x86\x5d\x2c\x10\x51\x20\x02\xd8\xea\x08\x4e\x57\x4d\x10\xfa\x60\xd5\x44\x69\xbf\xad\x9a\x6a\x1c\x8c\x56\x4d\x12\x86\x61\xd9\x43\xcf\x99\xc7\x99\x99\x95\x7d\x16\xa2\x6f\x04\x4a\x63\x4e\x68\x16\xdd\xba\x68\x11\x68\x16\x29\x0c\x69\xb9\x5d\xd8\x99\x07\xa0\x3d\xa2\x1a\x95\x73\xcf\x64\xc8\x39\x2d\x71\x10\x5d\x46\x19\xf2\xd6\x36\xf3\x0f\x20\x41\x11\x17\x1f\x3c\xd6\xe7\x3c\x78\x7c\xcb\x2a\xb0\xc4\x81\xa3\xbe\x77\x4a\x1e\x38\x16\x1e\x14\xea\xb7\x52\x94\x03\xba\xc2\x63\xc2\x12\xf9\x67\x1e\x12\x96\xa0\x31\xfb\x88\xb0\x04\x91\x38\x18\x2d\x49\x81\x48\xd1\x92\x24\x4a\x0d\x8b\x5c\x3a\x74\x73\x7b\xd6\x0e\xef\x84\x6f\xda\xb2\xbf\x50\xf1\x7a\x52\x81\xba\xd4\x2d\x75\xb9\x79\xeb\x2b\xdf\x8b\x15\xc6\x56\x6a\x0f\xf6\x59\xd1\x1e\x2c\x23\x93\xbf\xef\x4a\xec\x86\xae\x1d\xe1\x83\x49\x1c\xe2\xe1\x78\x98\xb7\x83\xb3\xb7\xcf\x94\x05\x49\xfc\xcf\x9c\x8d\x33\x63\xf7\xd9\x9e\x94\x8c\x22\xc1\x63\x9c\x47\xb3\xde\x64\xd5\x21\x46\xf4\x19\x59\xd4\x0d\x71\x3c\x08\x1c\xe4\x46\xc8\x73\xaf\x31\xfa\x74\x59\x1b\xda\x93\x4f\x08\x4f\x7a\x78\x14\xa3\x78\x60\xc7\xc8\x8d\x91\xdd\x23\x8f\x11\xfa\xe4\xb2\x02\x3e\xa1\xdb\x81\xdb\x1b\x20\x97\xd8\xdd\xc8\xf5\x6f\x82\x6b\xec\xc0\x0e\x09\xb6\x7b\x03\xc4\xf6\xf3\x91\xeb\xa3\x4f\x76\x18\xda\xd3\x4f\x28\x0e\xd0\x15\xf6\x21\x37\x8a\x07\x18\xf5\x42\x42\x8b\x58\x56\xdd\x29\x25\x46\x28\x91\x2f\x14\x47\xd0\x8d\x50\x68\xfb\xd7\xd8\xa9\xa1\xb3\x01\x46\xbc\x60\xf2\x9e\x17\x77\xeb\xc6\x03\x14\xf8\x58\x98\xa8\x2d\xc4\x30\x1d\x6b\x1b\x88\xae\x13\xe8\xa2\x1f\x7e\x0e\x31\x11\xe3\xa3\x3e\xba\xa4\x5f\x5c\xb2\x16\xdf\xab\xd5\x6b\x75\x78\xee\xd9\x31\xbe\x0a\xc2\x29\xf8\x86\xc2\x9b\x91\x1d\xda\x43\x74\x07\x70\x64\x0f\x08\xaa\x01\xac\xd0\x5f\x71\xc0\x79\x42\xc1\x0d\x0e\x6b\x72\x16\xee\xd5\xf8\x80\xce\x39\xdf\x9d\xcb\x9a\xeb\x60\x3f\x76\xe3\xe9\x45\xaa\x42\xac\x36\xb0\x92\xa4\xed\x46\x89\x51\xad\x1e\xa1\xbb\xa7\x0f\xe8\x84\xfd\x26\xed\x33\xb4\x27\x2e\x91\x1b\xa8\x2a\x4d\x8a\x27\xf6\x70\xe4\x61\x56\x6b\xc0\xca\x84\x49\x93\x0c\xaa\xf3\x3b\x54\xf5\xab\x2d\xd4\xa0\xb0\x7f\xf0\xbb\x49\xd1\xfe\x20\x35\xf4\xf8\x9b\xa9\xc1\x72\x58\xc2\xe4\x35\x02\x29\xd0\x40\x50\xf3\xdb\x80\xff\x85\x9e\xa2\x9d\x1d\xd4\x79\x29\x91\x62\x84\x76\x76\xa0\x62\x9f\x2e\x61\x96\xc0\x61\x3c\xfd\x94\xd4\x32\x1a\x04\x61\x3c\xb0\x7d\xa7\xa6\x2d\xb3\xea\x57\x73\x69\xef\x24\xab\x7c\x9a\x0b\x3a\xc0\x12\xb4\xa9\x7d\xc2\xf8\xa4\x1f\xc9\xc2\x18\x7e\xb0\xad\x39\x3a\x7b\xbe\x52\xc6\x1d\x27\x23\x8f\x1b\x83\xd3\x04\xd0\x39\x36\xf2\x68\xe6\x96\x14\x12\x63\xe3\x61\x63\x83\x8e\xf7\x1a\x1b\xee\xa8\x43\x79\x23\x96\x72\x4a\x5b\xec\x7f\x4d\x27\x36\xc2\xf1\xf6\xe0\x3f\x63\x3b\xff\x8e\xf7\xde\xf2\x98\x12\xac\x80\xd5\x00\x4a\x30\x62\x8b\x9e\xb8\x08\x3a\xc7\x9e\xed\xfa\xd4\x9e\xcc\xad\xfb\xee\xde\xa2\x17\xb7\x73\xca\x59\xea\x8c\x47\x4f\x72\xd1\x13\x99\xf5\xa3\x8a\x68\xcb\x58\xea\xf0\x67\x65\xa8\x22\xbb\x09\xa9\x0f\x6e\xbe\xec\xef\x2e\x78\x6e\x99\x26\xbf\x14\x2e\x85\x4a\x6a\xd1\x03\xa9\xb5\x9c\xcf\xee\xad\xe0\x7c\x76\x6f\xb9\xf3\xd9\x67\x6b\x3c\x9f\x7d\xb6\xaa\xf3\xd9\x67\x2b\x38\x9f\xdd\x67\xed\x14\x0d\x83\x20\x1e\x14\xa8\xac\xd5\x90\x5f\xa2\xb6\x69\x52\x8b\x62\x84\xac\xef\x3c\xfa\xf9\xaa\xce\xa3\x9f\xaf\xe0\x3c\xfa\xc5\xfa\xcf\xa3\xbf\x5f\x3f\x6a\x4c\x72\x17\xe6\x14\xf7\xe2\xa0\xa8\x0e\x8b\x7a\x4b\x34\x78\x09\x6f\xc7\xe1\x4d\x01\x10\xca\x82\x88\x31\x8d\xa6\xec\x21\x7e\x86\x27\xf9\xea\x72\xff\xc5\x82\x45\xec\xae\x1f\x5b\xa7\xb1\x97\x29\xe3\xbd\x1b\xe5\xd7\xe5\xf9\xa2\x08\x5a\xcf\xe4\x72\xde\x62\x2f\xbf\x2a\x8d\xfa\xa2\x5d\xf2\x19\xe2\x09\x36\xb8\x17\xfc\x71\xe0\xd9\x61\x71\x19\xbb\x8b\xf6\xc9\xfa\xd1\x88\x1a\x9f\x01\x8e\xa8\x59\x67\x65\xbc\x0f\xae\x66\x35\x54\x03\xd0\x88\x1e\x01\x89\x1e\x3d\x4f\x1e\x3d\x4f\x56\xed\x79\xd2\x7c\x74\x3d\x79\x74\x3d\x79\x74\x3d\xf9\xca\x5c\x4f\xa8\xed\x8e\x22\x30\x7f\x23\x14\xf4\x91\x8d\x46\x6e\x16\x9a\x48\x72\x4c\x39\x76\x4b\x45\x02\xd3\xad\x10\xca\xb8\xa5\x34\xe7\xf6\x4b\x39\x76\x8b\x02\x80\x1d\xbb\x49\xd8\x2f\xd0\x4e\x21\xee\x33\xff\x13\x78\x24\x65\x12\x15\x05\xbe\x22\x97\xa1\x88\xad\xa3\xf7\x5f\x39\x76\x45\x60\xb0\x24\xa0\xb0\x87\x7d\x79\x16\x67\x93\x1a\x78\x9e\x90\x7a\xd1\x78\x20\x24\x95\x69\xa1\x4b\x32\xab\xc3\x24\x08\xbf\x7e\x80\xdc\xf4\x01\xa6\x40\x76\x4c\x4a\xb2\x9e\x5f\xb2\x09\x3b\xb1\x0f\xe0\x0d\x3f\x3f\x55\x7c\x68\x42\x00\xb4\x11\x9e\x3d\x06\x54\x08\x5c\x21\x66\x39\xd7\x90\x06\x41\x1d\x52\xb3\x32\x1e\x36\xa4\x01\x4c\xb0\x32\x98\x93\x0d\xc9\x6e\xa1\x73\x42\xec\x82\xcc\xb0\x3d\x3b\x36\x08\xf7\xa6\x69\xb2\x66\xe5\x7f\x6b\x64\x1e\x21\xb2\x73\x87\xdc\xe8\xb5\xef\x0e\xe1\x44\xfb\x47\xd7\x77\xa3\x01\x76\xd8\x50\x42\x0f\x3c\x75\xcf\xee\x0d\xf0\x71\x88\x6f\x88\xfd\xa9\x88\x02\x93\xd6\xa4\xb5\x18\x79\x1c\x9f\x92\x12\x8c\x3b\x34\x0a\xf1\x0d\x5d\xd2\x45\x2d\x21\xdc\x0f\xfc\xe4\x99\x97\xe0\x3a\x65\x04\x59\x67\x07\x9f\x57\x5c\x10\xe4\xb1\xef\xfe\x67\x8c\x0f\x1d\x2a\xc9\xc9\xb9\xf9\xc8\xc5\xdb\x55\x51\xef\x81\xed\x3b\x1e\x16\x35\x3e\x80\xf8\x2e\x8a\x31\x95\x53\x0f\x71\xd6\xae\x6d\x2f\xa2\x55\xc4\xa9\xba\x54\x35\x3c\x1c\x91\xa2\xf3\x3b\x5e\x12\xf6\x1c\x97\x28\x18\x52\x8a\x43\x94\x58\x35\xfd\xea\x7a\xde\x09\xee\x61\xf7\x06\xec\x85\xbc\x00\x73\xb9\xe9\x0d\x1f\x4f\xe2\xe3\x2c\x76\xc8\x0c\x57\x24\x9b\xd7\xff\xd0\x49\x1c\x7c\xa4\x97\x4a\x84\x1d\xd6\xe1\x22\x1d\x7b\xa1\xba\x01\x09\x3e\x6a\x52\xeb\xbe\xee\xc5\xee\x0d\x86\xd9\x4b\xba\xf7\x9e\x49\x20\xbb\x94\x64\x85\xd5\x38\xbf\xd0\x01\x8a\x24\x05\xca\x95\x21\x45\x49\xcf\x33\x28\x73\xd1\x4f\x9c\x57\x90\xde\x17\xec\x0a\xc7\x67\x78\x12\xbf\xf6\x7b\x83\x20\xcf\x25\x4c\x49\x63\x4c\x2c\xd4\x9b\x24\xc5\x13\x8e\x27\xe8\xa5\xf2\x2e\xf1\x64\x83\xe8\x3b\x55\x4d\x25\x27\xe8\x87\x9c\x2c\xd8\x77\xaa\x79\x3e\x37\xd5\xa1\xeb\x38\x1e\xae\xe6\xba\xb6\xb9\x11\x6d\xf8\x43\xdf\xc1\x93\x9c\xea\x28\x69\x0c\x57\x15\x2f\x3b\xf9\xa4\x62\x1a\x48\x1f\x54\xf9\x48\x05\x3c\x4f\x92\xe9\x1c\x8a\xa4\xcf\x35\x97\xfc\xf7\xa8\x4f\x38\x20\x9d\xbb\xdd\xc8\xab\xb5\x0b\x56\x9a\xc2\x40\x4e\xf5\xd9\xfd\x7e\xcf\x1d\x15\x78\x25\xaa\x89\xe6\x04\x44\xe9\xc9\xb1\xca\x7a\x8a\xb7\x5f\x4f\x8e\x56\xd6\x53\x1c\xfe\x86\xf6\xe4\xc4\x76\xdc\x71\x24\xa5\x10\xef\x32\x41\xaf\x5e\xfb\x57\x9e\x12\xdc\x4c\xbc\x94\x93\x66\x47\x63\x92\x23\xf3\x4d\xab\x22\xde\x8d\x43\x16\x85\x4e\x64\xcc\x7c\xd3\x66\x3c\xb0\x23\xd7\xbf\xd2\x65\xa3\x5f\xb4\x99\xde\xe0\x2b\x57\x5b\x14\x7c\x98\xa5\xc3\x9a\xb2\x32\x98\x03\x5a\x23\x73\x8a\x91\x0f\xad\x51\x75\x70\x9f\xab\x69\xf2\x8f\x58\xd6\x65\xc0\x27\xe6\x28\x02\xa1\x6a\x4f\x15\x4e\xfa\xef\x0e\xb9\xdc\x4d\xcc\x75\x64\xc8\x8c\x95\x95\x5b\x8c\x9e\xa1\x3f\x1e\xa8\xd9\x96\x42\xe1\x4e\x79\x42\x08\x43\x67\xb7\xd2\x72\x61\xa5\x92\x71\x7d\xd3\xca\x8a\x6c\x3a\xa9\xc3\xa4\xae\x95\x15\xd2\x74\x52\x18\xf0\x39\x13\x5b\x56\xee\x5a\x28\x5f\xdc\xc8\xbf\xc0\x97\xcd\x0e\xd6\x15\x59\x7b\x24\x9d\xad\x1f\x06\xc3\x56\xa6\x5d\x20\x34\x1d\x8c\xd7\x96\x34\xa0\x53\x89\x1e\xd2\xb4\xe2\x40\x47\x29\x18\xc7\x38\xa4\x7a\x82\xc3\xa2\xd9\x13\xc9\x9d\xb1\x26\x25\xb0\x24\x3d\x73\x7f\x8f\xea\x66\xba\x08\x84\x5c\xdf\x4f\xc8\xd5\xb3\xdf\x13\xc6\xa5\x22\xf8\xcb\x74\x0d\x36\x0a\xea\x23\x2d\x48\x42\xdc\x6f\x9a\x99\xaa\x81\xf3\x4a\xc2\x3b\x19\xe8\x24\xa1\x52\x9f\x0c\x7b\x4a\x05\x44\x16\xe9\x9d\x2e\x0b\x67\x5f\xa4\xe7\x2f\xda\xa9\xc4\x2b\x50\x26\xf3\x9c\xa1\x68\xc1\xc4\xb2\x12\xd0\x9b\xb4\x90\x3a\xd1\xb0\xf7\xd3\x16\x52\x67\x19\xfa\x4f\x91\x98\xc2\xd6\x54\x84\xa1\xb0\x11\x13\x29\x96\x25\xba\x48\x7c\xf2\x64\xc6\x54\x1b\x5d\x96\xa1\x04\x9c\x4f\x87\xc1\xa3\x9b\xe8\xd9\x01\x88\x8f\x0f\x63\x3c\x2c\x9c\xed\x95\x94\x79\xd0\x7c\xc5\x68\x76\xba\xce\x2f\x03\xc0\xb7\x88\x4c\xad\x08\x80\xaf\xd0\x49\x23\x0f\x80\x8f\xba\x81\x69\x01\xf8\x56\x38\xeb\xce\x71\x14\x58\x1e\x74\x0f\x36\xbc\x5a\x08\x02\xc0\xdb\xa1\xec\x8f\x2d\x43\xef\x91\x45\xa7\x47\xe4\x81\x46\x7c\x4c\xb9\x5a\xe7\xca\x59\x39\x19\xcb\xca\x97\x85\x58\x54\xe2\x6f\x52\xcc\x24\xd3\x18\xda\x0c\x75\x68\x75\xda\xa5\x2a\xb3\x80\x00\xf2\x52\xb4\x12\xb8\x82\xc6\x03\xfa\xfa\xf0\xcc\xf0\x69\x76\x70\xe4\x95\x58\x64\xf3\x1d\x55\x17\xe2\xb8\xcd\xc2\x9f\xb4\x3d\xf7\xca\x27\xa5\xbf\xb1\x23\x4c\x44\xbe\x25\xd6\x91\xda\x8b\x41\xfa\xb1\x12\xe3\x89\x82\x50\x69\xa9\x3d\x36\x8f\xc6\xce\xdb\x0b\x91\x93\x64\x37\xaf\xe8\x2e\xe4\xc0\x15\x8b\xb3\x54\x14\xe7\xec\x6a\xa8\x68\x67\x22\x1d\xc8\x3e\x9d\x7b\x73\x13\x3d\x49\x36\xe3\x6a\x9a\x8d\xa5\x99\xd7\x65\x24\xb6\x81\x89\xdd\xdc\x45\x25\x97\x79\x96\xae\x06\xcf\x99\x04\x64\xfa\x4a\x27\x22\xef\xe4\x84\x8e\x1d\xdb\xff\x0f\x4f\xa5\x64\xec\x8d\x9c\x08\xda\x5d\x4d\xc5\x5f\xa9\x01\x94\x5d\xcc\x3d\xf6\x67\xef\xfe\xad\x26\x6e\xb2\x8c\x1b\xd9\x1b\x47\x71\x30\x04\x71\xf8\x2c\x6c\x50\xcd\x90\xc3\xc1\x7b\x76\xee\xf7\x79\xb8\x60\x91\xeb\x12\x4e\x68\x38\x7b\x61\xf7\x52\x81\xd9\xdc\xa4\x3f\x6a\xca\xd7\xfb\x7b\xd4\xac\x2b\xfd\x08\x89\x48\x36\x36\xa6\x6a\x43\x7b\x64\x24\x06\x3a\xf6\xe3\x70\x6a\x21\x37\x1d\xe8\x7f\xe8\x0a\xbb\x99\xa6\x91\x36\x22\xd0\x16\xa2\xaf\xb8\x9d\x07\xf0\xef\x6a\x74\x7e\x1e\x98\xbb\x54\x8b\xe9\x1c\x35\x38\x00\xe9\x88\xbc\x3b\x0b\xde\xda\x61\x8c\x23\xd7\xf6\x69\x43\xd1\xf2\x7b\x13\x8b\x71\xd2\x9b\xf2\x5f\xf2\xb2\x62\x4b\x69\x3a\x4b\x54\xca\x54\x79\xf5\x64\x29\x53\x15\x2a\x1b\x04\x8c\xb8\xaa\x5a\x55\xd8\xa0\x44\x3b\x5a\x19\xe1\x55\xf3\xc1\xd6\x57\x0b\xb9\xca\x95\x4e\xb1\xc5\xd8\x62\x7a\xae\xa6\x6e\x3c\xf2\xf6\xac\x25\x55\x9e\x98\x72\x99\x3c\x41\xba\x6e\x92\xe8\x96\xaf\x5a\x3a\xb0\x63\xba\xca\x94\x03\x92\x2a\xa7\xda\x62\xc4\xcc\xae\xfa\x08\xe2\xb7\xb7\xd0\xf9\x17\x93\x13\x49\x30\x92\x76\xbc\x90\xa6\x3b\xb5\x49\x43\x6c\x7b\xef\x84\xaa\x65\x2a\x36\x49\xb2\xb3\x83\xce\x8e\xde\x1d\xb5\x60\x77\xdf\x8e\xdd\xae\x87\x51\x1c\x20\x2f\xb8\xc5\x21\xba\xc1\x61\xe4\x06\x7e\x54\xd2\xa4\xc9\x73\x37\x36\x4c\x83\x95\x0b\xc8\xee\x0b\x11\xe0\x5a\x3f\x63\x0e\xc9\xb5\xab\x42\xaa\xaa\x64\x17\x95\x59\x7a\x94\x60\xbb\xa8\xd0\x64\x3e\x12\xa5\x6e\x2c\x69\xec\xe6\xed\x8c\xcd\xe7\x59\x59\x68\x89\x21\x74\xc7\xac\x1d\x6a\x33\x55\xd1\x16\x72\xd5\x9d\x91\x64\x26\x27\x9d\x46\x87\xb9\x6e\x89\x9a\xcc\xee\xc9\xf8\x55\xf6\x73\xb2\x79\x93\x7c\x96\xa4\xcf\x4a\xdc\xab\xd5\xba\x97\x9d\x57\x6e\xf9\x74\x05\x31\x1c\xde\x4c\x79\xef\x24\xa3\xca\x92\x7b\xcd\x94\xd6\xef\xc2\x08\x4a\xb0\x95\x3f\x8f\xf1\x3c\x77\x97\xdd\xcd\xb0\x7b\xa3\xaa\xdc\x7f\xf4\x55\x49\x5b\x97\xee\xf3\xcc\x5c\x36\x26\xc9\x1e\xf7\x25\x16\xdc\x97\x28\x53\xe6\xac\x5b\x3b\x85\xc5\x7e\xd1\x2d\x41\xdd\xfa\x8e\xb3\xfa\x99\xb7\x66\xca\x31\x2c\xf7\xce\x8c\xd1\x11\x9d\x82\xcf\x9c\xed\x79\xd3\x12\x83\x44\x4a\x5d\xb0\x3e\xdc\xd5\xad\x0f\xe9\xe9\xe1\x69\x16\xab\x5d\xfa\x90\x39\x56\x2a\x6f\x2f\x7f\xc5\x53\x52\x22\x3e\xca\xce\x6b\xae\xda\xa3\x95\xae\x4a\x89\xcb\x60\x33\xe4\x2c\x79\x28\xd8\x44\xdf\xf5\x62\x1c\x1e\xdc\x60\x3f\x8e\x8e\xfa\x6f\x07\xae\xc7\x3c\x41\x68\x7f\x71\xf8\x75\xd1\xb0\xe9\x6d\x70\x2a\x37\x94\x31\x3a\xa9\xca\xdc\x65\xa7\xc5\xdd\x5a\x46\xb5\xb2\xf7\x99\xb3\xef\x57\x8a\x64\xb4\xe8\xa1\x1f\xe5\x24\x67\x3e\x2b\x23\xd5\xbf\xba\xf1\x40\x6c\x18\x94\x11\x6c\x25\x43\xfa\x48\x9a\xb0\xbe\xa7\x13\x6a\xba\x7a\xdf\xcb\xdd\x57\x48\x3b\x78\xec\x71\x0f\x8f\x72\xe7\xc8\x7b\x25\xcf\x91\xd5\x93\xdd\xbd\x32\x27\xbb\x99\xa3\xe7\xbd\xc5\x8e\x9e\xf7\x4a\x1d\x3d\x4b\xe7\xc8\x7b\xea\x39\x72\xd2\x96\x92\x2b\x14\x6f\x4f\xba\xf5\x23\x7d\x58\xcf\xb9\xf3\x72\x07\xb3\xf2\x48\xe9\xce\x3a\xea\x2c\x79\xbe\x5a\xf2\xc4\xb6\xc4\xf9\x2f\x3b\x20\x45\x71\x0b\xd5\x55\x43\x18\x8e\x3b\xc9\xfb\x86\xfa\x9e\x8e\x26\x70\x0c\x43\x5b\x79\x07\xbc\x25\x8f\x6b\xa5\x95\xa9\xf8\xa9\x1e\x4c\xee\xaa\x8b\x10\x22\x08\x31\x3b\x27\xdc\xad\xc5\xed\x8d\xd4\xb7\x28\xc6\x23\xe6\x66\x77\x7e\xd1\x4e\x7d\xec\xbb\x61\x14\x27\xbb\x2c\xe0\x39\x4b\x7f\x4a\xa1\xd3\x90\xd8\x5a\x0a\xf9\xe6\x0a\xe4\x93\xf6\x56\x94\x52\xf9\x14\xd4\x0f\xc2\x03\xbb\x37\xd0\x4c\x43\xe0\x6a\x93\x52\x98\x5c\xa0\xe1\x66\x40\x22\xd7\x9b\x9b\xf2\xe3\x39\x64\xbd\x68\x67\x73\xda\x8e\xe3\xfa\x57\x9c\x3f\x48\x86\x5e\xa2\x3a\x7a\xc5\x16\xce\x4a\x82\x96\x14\xc2\x8a\x89\x0f\xf8\xde\xe3\x1b\xfd\xa1\x2f\x84\x52\x3a\x1c\x2d\xee\x52\xe8\x50\x00\x23\x3f\xc6\x21\x59\xf1\xc7\x58\x46\x32\x22\xe5\x8a\x4d\x29\xb4\x0d\xf5\x95\x1d\x68\x52\xdb\x56\x68\x1b\xa5\xb7\xb6\xcc\xf4\xb1\x30\xdd\x1f\x8a\x31\x74\xae\x62\x8c\x69\xb6\x4d\x58\xaf\x49\xe7\xa5\xa2\xa7\xb7\x94\x86\x2d\x3a\x3c\x95\xb2\xb0\xd6\x32\x62\x33\x95\x3f\x95\x5d\x5a\x69\x25\x4c\x50\x61\xad\x8d\xc6\xd1\xc0\xa0\x35\xc8\x54\x4e\x92\x43\x9a\x22\xe7\x74\x3c\x13\x7c\x2b\x69\x1b\xe9\x7c\x5d\x6d\x5c\xdd\x61\xbc\xe2\xe0\x94\x6e\xfa\x4c\x15\x60\x67\x5f\x74\x74\x20\x58\x5d\x87\xe4\xd4\x2d\x24\x49\xc5\x0c\x79\x70\xb0\x17\xdb\xc9\x00\x49\x71\x68\x64\xdb\x99\x3a\x40\x7f\x29\x29\x92\xd8\x5d\x4e\x8a\x2e\x67\x8b\xd1\x65\xb1\x1c\x6d\xe4\x96\xb6\x5a\x1b\x7a\xc5\x56\x74\xda\x1d\x0c\x71\x5b\x73\xaf\x96\xbb\x42\x61\x2d\x67\x4a\x99\xcc\xec\xf1\x62\x49\x93\xb2\x8c\x15\xa9\xf5\x65\x7c\x56\xda\x3c\x7c\x36\x9f\x79\xf8\x4c\x77\xaa\x96\x94\x3e\x9f\x41\x95\x7b\x0a\x97\x9d\x4d\xd9\xbd\x01\xb8\xe6\xf3\x44\x2e\xe5\xfe\x1e\x3d\x59\x04\xb3\xc4\xa0\xd3\x06\x23\x63\xf1\x72\x4c\xdd\x4e\x80\x14\xc3\x4a\x6f\xba\xa7\xcf\xff\x72\xf3\x69\xd6\xb2\x2b\x47\xac\xdc\xcf\xed\xfb\x81\xeb\x24\x3d\xb9\x5f\x23\x8f\x45\xa2\xb1\xaf\x13\x8d\x2c\x94\xe4\x7e\x82\x25\x99\x7f\xbe\xb9\x9f\x3d\xdf\x94\xbc\x6a\xf7\xf3\xbd\x6a\xf7\x53\x5e\xb5\x29\x5f\x30\x96\x26\xc7\x91\x29\xe5\x6b\xc6\x12\xe7\xf8\x47\xe5\x0b\xfd\xfe\xac\xa3\x64\x68\x58\x22\x89\x91\x24\x95\x29\xc9\x2d\x05\xde\xa8\x9f\xc2\x74\xe8\x8d\xbd\xb2\xf0\x9a\x73\x90\x2c\x0b\xb0\x59\x9e\xa4\xd4\x2f\x2b\xa7\x2d\x75\x63\x69\x18\xcb\x94\xd7\x00\x3f\xd6\x57\x75\x95\x26\x41\xea\x68\x75\xca\x2f\xca\x15\x05\x22\xd5\x63\x52\x18\xa9\xab\x30\x0a\x80\xe4\x37\xb5\x71\x2e\x35\xc3\xc3\xea\x5d\xa6\xaf\x52\xbe\xd2\xdc\x85\xba\x85\xaa\xe3\xd0\x33\xfe\x06\x18\xc1\xcc\x77\x7a\x0b\x55\xcd\x6a\x6a\xa5\x99\x51\xbd\x86\xb4\xb5\x93\xda\xdc\x27\xb3\x8a\x94\x21\xe5\x8c\x52\xa6\x6e\x5a\x1c\x88\x05\x82\x11\xd2\x9d\x28\xb8\xec\x25\x95\x6b\x3c\xc9\xea\xa6\xfb\x7b\x9d\x20\xcf\x38\x16\xcc\x85\x92\x58\x80\x55\x3e\x37\x30\x6e\x35\x86\x8d\x0a\x60\x7a\xec\xe2\x62\xf8\xd2\xbd\x39\xe1\x4b\x8f\x61\xf0\x2c\x01\x5e\x9a\xb3\x7d\x59\x02\xbd\x74\x6e\x9a\xb4\x75\x0f\x7e\x39\xf8\x70\xa6\x85\x42\x2d\x05\xbe\xa9\x47\x2f\x4a\x22\x4b\x6d\x28\xbb\x5f\x0b\x51\x92\xe0\x40\x0b\xd1\x59\x73\x09\x94\x8a\x31\x35\xab\xf8\xc5\xdb\x80\x86\xc8\xea\x15\x22\xc3\x7e\xdd\xbc\xcb\xeb\xbf\xa5\x3a\x30\x59\x13\x2e\x45\x46\x5e\x38\x2e\x49\x4a\x71\x3d\xff\x56\xfb\x47\xf1\xb4\xff\x56\x2b\xd1\x0b\xc2\xff\x82\xae\x60\x3e\x25\x5f\xa0\x02\xb3\x43\xf9\xad\xa3\xee\x64\xf1\x77\x61\xd6\xdc\xe8\x84\xc2\xf2\xc0\xee\x38\x31\x2f\xff\x7a\x8d\x40\x6a\xce\xdd\x85\xfe\x82\x55\x27\x92\xbf\x50\xb5\x01\x16\xf7\xa8\x5f\x1a\xd9\x30\x13\x43\x18\x8a\x1f\xba\xfe\x2a\xe6\x03\x0f\x5f\x61\xdf\x39\x9b\x16\x87\xb3\x2c\xee\xc2\xf9\x4f\xa7\xbb\x60\x8a\xbd\x3f\xf8\xe7\xc1\x87\x77\x97\x67\x1f\x8f\xa9\x19\x46\xeb\xc5\x6f\xd2\x2d\x55\xb1\x0d\xb1\x93\xf2\x05\xbb\x68\xe0\x3a\x8b\xb5\x2a\x0f\xce\x2c\x7c\xd1\xbe\xc0\xf0\x62\xe1\xaa\x17\x1d\x23\x0b\x65\x64\xe8\xdc\x0b\xe5\x25\x6d\x46\x25\x08\x5a\xed\x4b\x28\x24\x29\xfe\xba\xec\xfb\xbc\x84\x20\xd3\xd8\xe5\xdf\x60\x1f\x48\xbe\x1d\x7f\x2d\xd9\x95\xab\x7f\x48\x3d\xae\xbf\x25\xd3\x6e\x09\xc5\x47\x4b\x35\x59\x98\xed\xcc\x66\xc9\x52\x8a\x30\x7d\xa7\x7c\xa9\x29\x2f\xe3\x81\xb1\x2a\x7a\x07\xcc\x2d\x63\xe1\x79\xf4\xbc\x8a\xed\x08\x57\x2d\x04\x7f\xb7\x5d\x5f\xfc\x0c\xc6\xb1\xf4\x9a\x3f\x46\x23\x62\x02\x91\x5f\xec\xe2\xe5\xec\xf8\xce\xe2\xe2\xc4\xdf\xfa\xfd\xbe\x88\xca\x4c\x9e\x5f\xd4\xc9\xff\xaa\x69\xa3\xa0\x1a\xe2\x5e\x0c\x6f\x59\xf8\x01\xbb\x1b\xf5\xdc\x28\xb2\x51\xd0\x47\xa3\x00\x4e\x32\x7b\x93\x16\xaa\x3e\xab\x7f\x27\x27\x0b\x42\xc7\xf5\x21\x78\x43\x92\x6c\x9a\x4d\x06\x4b\x6d\x7a\xd8\x4e\x52\x52\x57\x0e\x3a\x75\xa7\x16\xe2\x75\x29\x97\xe3\x12\xae\xdc\xc0\x27\x79\x9c\xd0\xbe\x75\xfd\x2b\x3e\xe1\x2b\xcb\xee\xdd\x7d\x39\x1b\x2c\x7e\x51\x48\xcf\x22\x82\xbe\x94\x23\x7b\x3d\x9f\x57\x83\x2c\x35\xb5\x59\x94\x45\x68\xf5\x05\xab\x96\xba\x54\xaf\xa7\x66\x71\xc0\x5e\x13\x96\x81\x88\xa6\x9d\xd8\x72\x90\x41\x33\x76\x4a\xec\xd9\xeb\x2d\x2d\x9f\x6d\xda\x9f\x46\x6c\xc7\xde\xd4\x8d\xa7\xbd\x7a\x3d\x67\x64\x34\x9e\xa5\x3e\x71\x21\x67\xa2\x2a\xaf\x7e\xaa\xe4\x57\x15\xa2\xc4\xf0\x0d\x41\x3b\x8c\xf0\x3b\xf9\xc8\x5e\xf5\x02\xda\xa3\x67\x06\xd4\xc3\x47\x06\x60\x21\xdf\x34\xf0\x2b\x29\x44\x81\x3d\xe9\xac\x9b\x93\x71\xaf\xfc\xc5\xfd\x14\x06\xd0\x5a\x43\x3b\x1e\x9c\x12\x3a\xcc\xe1\x3e\xcf\x37\x21\xe3\x8f\x40\x61\x22\x5c\xdf\x80\x1f\x76\x37\xca\xc9\x6c\x11\xb9\x54\x36\x66\x81\xed\xa7\x12\xb5\xb6\xdc\x8c\x57\x38\x3e\xc1\xb6\x77\xec\xe2\x0c\xd4\x98\x1b\xe3\x61\xd2\x88\x97\xe4\xf1\xef\x23\x36\xde\xc9\x83\x7a\x00\xe9\xd0\xec\x52\x32\xb8\xa6\xc8\x3f\xf7\x06\xae\xe7\x84\x00\x16\x27\x27\xe1\xaf\x45\x23\x8f\xa4\x6b\x74\x9f\xe5\x6e\x5e\x52\x13\xd1\xf0\x3d\xec\x79\xcb\x94\x3b\x60\x0e\xb2\xbe\xf3\xda\xf3\xde\x4c\x89\xb2\x63\x27\x70\xac\xb6\x85\x3b\xcc\x1a\x98\x66\x1d\x76\x20\xb4\x98\xdb\x47\x70\xf5\x06\x6d\x6e\x42\x07\xf0\x90\x29\xec\xb8\x8c\x49\x00\x7c\xd1\xfb\x3b\xab\x8e\x66\xfc\x58\x2a\xeb\x5d\x3c\xb2\xa7\x5e\x60\x3b\xec\x8a\x18\x3f\x76\xb3\xb2\xdd\x25\x5c\x5f\x68\x23\x6e\x6e\xd2\x1f\xcc\x2f\x2d\xfd\xac\xdc\x10\x7d\x48\x00\xd9\x48\xbd\x54\x02\xfa\x9a\xd1\x4f\x6a\xd5\xc8\xbb\x82\x2a\xe9\x99\x26\x99\xf2\x98\x61\x24\xce\x2f\xda\x19\xfd\xf3\x36\xe0\x73\xd1\x51\x9f\x62\x43\xaa\xc3\xc7\x62\xd6\x7a\x32\x8c\x68\x90\x47\xfa\x56\x0e\xf2\xc8\x02\x3c\xb2\x0f\x72\x80\x47\x1e\x58\x92\x7d\x52\x02\x4b\x8a\xa0\x92\xec\x23\x7d\x16\x83\x69\x68\x4f\x8e\x5d\x2c\x0e\xc8\x17\xbd\x89\xd7\xe3\xe3\xe8\x27\x01\x45\x93\xc4\x57\xe4\xf1\xee\x92\xd1\x33\x41\x1d\x1e\xc3\x73\x41\x5d\xd9\x15\x03\x17\x87\x3d\xec\xd3\xcb\x4a\xe9\xe1\x0a\xd7\xff\x18\x0b\xb4\x8d\x76\x50\x33\xe1\x62\x8a\x3a\x2c\xc8\xe8\x7a\x99\x98\x26\x01\xff\x58\x6f\xc8\x6c\xa8\xee\x0c\x6b\xe5\x44\xf6\x91\x50\x7a\xde\x42\x75\xc1\x8f\xea\x31\xb1\x56\x7e\xd2\x20\x46\x12\x3f\x8a\x5c\x3e\x45\xf5\xda\x0b\xc1\xa0\x8c\xaa\x26\x11\x53\x40\x90\x60\x0a\x8c\xfe\x13\xc6\x54\x02\xd1\x53\xd6\xff\x22\x92\xec\x53\x2e\x93\xf4\x02\x73\x32\x86\xef\x38\xf2\x0e\x47\xda\xc9\xc7\xcb\xc9\xc7\xdc\x91\xf7\x91\x12\xbe\x1e\xd2\xd3\x2a\x1c\x72\x46\xd8\xc9\xcc\xab\xc4\xbc\x78\x96\x68\x04\x52\x4b\x66\x74\x3c\xab\x81\xd2\x60\x83\x9b\x8e\x69\xf1\x89\x3e\x8a\x8f\xfe\x61\x8c\x87\x3f\x05\xe3\x08\xbf\xc7\xf6\x0d\x4e\x92\xa5\x3e\x68\x32\x1c\xf8\xc4\xf0\xd4\x64\x80\x0f\xc9\x54\x2c\x6c\x82\x63\x17\xa7\x0c\x05\x6a\x1c\xb4\x99\xaa\x7e\xc2\x93\xde\xdf\x23\xfe\x5b\xaf\xb0\xa9\x87\xf5\xc3\x46\xd6\xa8\x68\x6a\xad\x0a\xf9\x24\x43\x35\x1d\x9a\x35\xf9\x1b\x4f\xaf\x9a\x7a\x72\xea\x62\x8b\x4f\x4e\x99\x76\x75\x4d\xb9\x4e\x2b\x69\x75\x7e\x9b\x12\x5e\x83\x9c\x34\x05\xda\xc0\x4c\xdb\x74\x2a\xf6\xda\x12\xfe\x28\x09\xac\x83\x9c\x4c\xc1\x76\xa0\x17\xfb\x7d\xc5\x54\x24\x16\xa2\x3c\x7e\xd8\xe7\x44\x3f\x8a\x99\x8b\xf5\xaf\x6e\x3e\x53\xe7\x30\x9e\x95\x42\xfe\xaa\xdd\xac\xb5\x59\x05\xd9\xc4\x4c\x37\xee\xf2\x70\xa7\x34\x38\x53\x6c\x12\x06\x07\xf3\x6e\xf4\x2e\x63\x0e\x93\x3a\x26\x05\x8a\xb4\x71\x10\xdb\xde\xb1\x2d\xf7\x99\xa1\xe6\x7f\xd9\x21\x56\x32\x7a\x05\x55\x69\xc1\x7f\xb7\x51\xc3\x44\x4f\x95\xbe\xe6\xf4\x42\x6c\x7b\x67\x84\x26\xa7\xa6\x12\xdb\x86\xfc\x4f\x93\x1e\xd8\xce\x70\x20\x53\xd2\x5c\x31\xdf\xf8\xaa\xee\x8b\xcf\x9c\x14\x34\x51\x25\xb8\x81\x7a\x6b\x87\x6c\x69\xc3\xb0\xc1\xab\x3f\x47\x18\x55\x18\x93\x15\x14\x07\x28\x1a\xe1\x9e\xdb\x9f\x4a\xd1\x22\xc9\x2a\xde\xc5\xd6\xef\x3e\x77\xed\xc1\xf4\xb6\x21\xaa\x70\xde\x2a\xe8\xd6\xf5\x3c\xd4\xc5\xc8\xc1\xa3\x10\xf7\xec\x18\x3b\xc8\xf5\x51\xa3\xd6\xa8\xd5\xab\xcc\x62\xcb\xbd\xe1\xbe\xea\xbb\xed\xff\x1d\x0d\x24\xdf\xc6\x17\xfa\x38\x82\x90\xa6\x7c\x68\x87\xd8\x19\xf7\xb0\x64\x5a\x87\x38\x1a\x7b\x31\xbf\x4a\x27\x01\x8b\xdf\xd8\x5e\x29\x73\x62\x25\x97\xd2\xb9\x3d\x23\x26\x15\xca\x16\xda\xe2\x11\x42\x56\xe2\x7e\x78\x63\x7b\x26\x7a\x05\x35\x6b\xb1\x02\x1f\x64\x4b\x2a\xf1\xa6\xa5\x73\x9a\x74\x3d\xe7\x26\x70\x1d\x76\x81\x86\x42\xde\x0f\xd1\x4b\x54\xe7\xed\x95\x64\xe4\xed\x3c\xeb\x2a\xea\x17\x6c\x61\x5a\xb8\x4f\x5d\xb2\xd6\x59\x3a\x9f\xf7\x90\xab\x94\x3c\xa2\x16\x26\x51\xe1\xeb\xeb\x5b\xb4\x43\x04\x5f\x2e\x36\xc6\xc3\xd1\xa9\x6c\x4a\x48\x5d\x8a\xb8\x67\xbb\x02\x57\x9d\xce\xa0\xde\x59\x5a\x78\x11\xa2\xdb\x35\x92\xa6\x3c\xcd\x8c\x85\x74\x17\x7b\x32\xec\xc9\xf7\x73\x58\x9e\x8d\x54\xfd\x0f\x12\xf3\x28\x95\x7d\x8d\xb5\x31\xc4\x2c\xba\x25\xfa\xfe\x69\x6a\x06\x56\x04\x44\x06\x34\xca\xb0\x29\x57\x43\x01\x33\x62\x39\x1d\x2f\x59\x1c\x1b\x89\x45\x24\x2f\xa5\xd0\x96\x64\x2a\xc9\x6b\x9a\x0c\xbd\x38\x08\xbc\xd8\x1d\x1d\xd3\x9d\x12\x1a\xbc\xd7\x07\x97\x3f\xf2\x5f\x8b\xbb\xf8\xdf\xd8\x9e\x95\xda\x4e\xa1\x01\x7d\x33\x84\x82\xc8\x65\xd7\x69\xd7\x01\xa1\x23\xd5\x0a\xd6\x43\xd2\xe3\xd4\x52\x1a\x47\x01\x58\xe2\x36\x31\xd5\x74\xba\x9d\x22\xda\x6b\x2d\xfe\xc3\x4a\x79\x23\x29\x56\xbb\xd2\x40\x6a\x03\xb6\x52\xcf\x09\x17\x2d\xf1\x4b\xe5\xb3\x95\xe2\x3a\xd5\x8e\xad\xf4\x8b\x64\x17\x8b\x6f\x59\x89\x36\xb0\x14\xd8\x2c\xe8\xb7\xcf\x85\xb8\x92\xb8\x05\xcb\x86\xb2\x2a\xda\x49\x1a\x09\xdb\x57\x92\x75\x2b\x67\xdf\x4e\x7e\x2f\x9f\x25\x7c\x16\xe5\xc4\x9b\x3b\xe3\x05\x4f\x64\x29\x6f\xd3\x4d\xd9\xb7\xcb\xf6\x4f\x94\x8a\x73\x41\x2b\x18\xf8\xc9\xf2\xb7\x95\x59\x29\x2b\x69\x60\xc5\xdb\xca\x2c\x8e\x37\x28\x2f\x3c\xa4\x44\x73\x55\x51\xe9\x59\x08\x95\x54\x94\xe9\xe7\x8f\x51\xa6\xbf\x9a\x28\xd3\x6b\x0b\xae\xac\x2d\x63\x35\xe1\xa5\x97\x0d\xae\xdc\x5c\x4f\xb0\xe1\xe6\x0a\x82\x0d\x37\x97\x0b\x36\xbc\xbb\xc6\x60\xc3\xbb\xab\x0a\x36\xbc\xbb\x82\x60\xc3\x7b\xeb\x0d\x36\x9c\x26\xbf\x82\xf0\xd1\xcb\x05\x1b\x7e\xb6\xc6\x60\xc3\xcf\x56\x15\x6c\xf8\xd9\x0a\x82\x0d\xef\xaf\x3d\x10\xe9\xf3\xf5\x87\x33\x7e\xb1\xfe\xa8\xb0\xdf\x7f\x86\xa0\xb0\xf5\xf5\x47\x6c\x4d\x80\xd2\x8f\x03\x6f\x7a\x55\x30\x0f\x35\x9b\x8b\x56\xa3\xc9\x8b\x78\x17\x14\x44\x19\x5e\x34\xe8\xf3\xee\x67\x08\x5d\xbd\x48\xc4\xe4\xc7\xc8\xb6\x8f\x91\x6d\x1f\x23\xdb\x3e\x46\xb6\x7d\x8c\x6c\xfb\x18\xd9\xf6\xbf\x3e\xb2\xad\xed\xd8\xa1\x2e\x8e\x2d\x19\xc8\xf0\xb1\xcc\xa6\xa2\xce\x30\x5c\x4f\x14\x5b\x60\xa9\x20\x8e\x2d\x7c\x5f\x61\x24\x5b\xa0\xf7\x5f\x1a\xcb\x16\xea\x56\x26\x9a\x2d\x6d\x84\x2f\x1d\xcf\x96\xc2\xc4\xcf\x08\x67\x7b\xcc\xb0\xe4\x69\xe2\x6c\x30\xdb\x85\x83\xcc\xe6\x07\x97\x9d\x59\x08\xec\xc6\x2e\x55\x0c\x6b\x23\x7d\x39\x8a\xa3\x8e\x74\x38\xa8\x9e\x0a\xca\xbb\x98\x44\x48\xe4\x18\x72\xbe\xe2\xd2\x23\x1d\x5c\xc9\x5f\xe4\x33\x2c\xf9\xbd\x71\x29\x63\x41\xe0\x74\xcc\x55\x0d\xaf\xdc\x0b\x69\x16\xaf\xc2\x5b\x29\xcb\x2b\x7c\xd2\xf2\x0a\x5f\x34\xbc\xc2\xfb\x12\xbc\xae\x20\x2c\x30\xd3\x51\xdf\x6c\x60\x60\x36\x76\x44\x32\xfa\x9c\x17\x16\x78\xf1\x28\xbd\x6c\x40\xcf\x0c\xd2\x4b\xe1\x47\xde\x05\xf1\x4c\x30\x75\x96\x26\x0f\x49\x1d\x56\x17\x34\x89\xfe\xa0\x76\x8e\x1d\xca\x52\x30\xeb\x49\x61\xf3\x51\x5e\x15\xd2\x7a\xe1\x4e\xb2\x1e\xf2\x3c\x61\xb9\x08\x6c\x7d\x05\x55\x2c\x0b\x3a\xae\xee\x41\xcc\x11\x0d\x4e\x0b\x71\x1d\x92\xb1\xb9\xed\x04\xb1\x14\xf8\x2d\x8b\x9f\xce\x2a\x35\x03\x90\xed\x5d\x10\x17\xe3\xf2\x91\x04\x99\x69\xab\x38\x90\x95\x13\xc4\x2a\x40\xb9\x13\xc4\x4a\x82\xae\x1d\x95\x8f\x44\xa4\xdb\x4d\x5b\x45\x54\xa6\x77\x41\xfc\x39\x78\x70\x82\xd8\x4c\xb7\x0e\x78\xc3\x40\x93\x96\x8c\x63\xe4\x24\xbc\x6a\xb1\xd0\x69\x8f\x3a\x41\x4c\xa1\xc5\x65\x45\x18\xb6\xd0\xae\x78\x7c\xb0\x92\xb6\xb7\x52\xed\xa0\xc2\x77\xf6\x26\x3c\x3e\x4e\x0a\xca\x8e\xbf\x4e\xc1\xd8\x69\x22\xe2\x78\xba\x4b\x14\x29\xc8\x4c\x6e\x07\xca\x91\x40\xb8\x02\x74\x82\xd8\x12\x35\x5f\x28\x1e\xc7\xec\x31\x5b\x1a\x0c\x6b\x05\x01\x39\xc4\xb0\x55\x03\x72\x90\x17\xec\x61\x16\x7a\x22\xdb\x24\x2d\x19\x70\x20\x93\x5a\x3f\x8c\x85\x3b\x72\x0e\xc2\x26\x8b\x37\x20\x22\x79\x93\x67\x05\x90\x1b\x46\x3b\xff\x4c\x87\xba\x44\x3f\x64\xeb\x2f\x3e\x53\x31\x81\x59\x76\xa2\x02\x36\x54\xa0\x3c\x56\xd0\x12\xb3\x14\xad\x9b\xaa\x8a\x65\x63\xeb\x4e\x84\x79\x12\xa6\xf9\x6a\xe7\xb2\xfc\x5a\xd1\x2b\xf1\xcb\x70\xb6\x74\x4b\xcd\x1d\xfc\x54\xec\xe9\xcf\x9e\xf0\x16\xd4\xc0\x38\x1d\x9b\xa1\x60\x06\x50\xf5\x9b\xea\x10\xa1\x5d\x89\x58\xd9\xe4\xcc\xc7\x42\xbb\x18\x90\x95\xec\x67\x9a\xd4\xd4\x2a\xa9\x12\x20\xe9\xdb\x05\x42\xac\x7c\x8d\x9a\x73\x44\xc5\x49\x51\x9e\xf0\x45\xd1\xa5\xe8\x95\x0c\x7e\xa8\x58\x2f\x34\x34\xc6\x7c\xba\xb6\x7c\x18\x0c\x5d\x06\x5d\x18\x0c\x6d\x6c\x97\x59\xe1\x35\x53\xcb\x99\x5d\xb6\x9e\x29\x07\xf8\xba\xbb\x50\x10\x8c\xdd\x85\x82\x60\xec\x2e\x16\x04\x63\x77\xde\x20\x18\xbb\x45\x41\x30\x8e\x79\x6b\xa5\x20\x9b\x8f\x53\x8b\xc0\xcf\x33\x0c\xf2\xbc\x09\xfe\xfb\x43\x60\xd0\x71\xbb\x7c\x10\x8c\x9c\x2c\xb0\x27\xa5\xcf\x04\x9f\x24\x8d\x2c\x7e\x16\x06\xf5\x97\x63\x67\x34\x8b\x63\x67\x14\x9a\xef\x25\xe2\x59\x30\x11\x65\xe1\x2c\xe8\x93\x88\x66\xa1\x64\x2c\x0e\x45\x71\x29\x23\xf7\xff\x56\x66\x2d\xa3\x71\xb1\x28\x13\x90\x42\x04\x9f\x9c\xe8\x03\x03\xc8\x7c\x7c\x5c\x23\x1f\x22\xf4\xe5\x34\x0b\xf4\xaf\xf3\xa2\xcc\x0d\x4d\x30\x69\xa5\x1a\xcf\x88\xcd\x6c\x2c\x82\x69\x2a\xd5\x47\x23\x36\x53\x89\x1e\xcc\x74\x7c\x80\x4c\xc7\x7f\x86\x4e\x4a\xc7\x08\x4d\x77\x53\x9a\x8d\x35\xf5\x51\x3a\x40\x69\xa6\x97\xe6\xe8\x23\xb2\xa2\x9c\xd1\x41\x53\x35\x49\xa6\x77\xd4\xbe\xc9\x89\xd6\x20\xc7\xdb\xca\x2e\x9a\x44\x0c\x84\xf9\xe3\x1e\x30\x62\x65\xcc\x06\x2d\xf6\x7d\x7e\x58\xac\x94\x3d\xb0\x37\x97\x3d\xa0\x09\x8a\xb5\xe8\x0c\x9a\x1b\xf3\x60\x94\xe8\x37\xaa\x29\xd3\x11\x0f\x58\x09\x4b\x06\x3c\xa0\x54\x2c\x56\xc8\xac\x70\x07\x7a\x13\x2d\xcf\x3a\xce\x66\xcc\x2e\xa5\x57\x1e\xee\x20\x3f\xd4\x85\x12\xee\xe0\x59\x26\xdc\x41\x36\x92\xc1\x33\x7d\x24\x83\x94\xe8\x3c\x9b\x4b\x74\xb4\x01\x33\xb4\xb1\x03\x46\x49\xff\x2a\x12\xf0\x35\x62\xdb\xeb\x5d\x20\x15\x6c\x7b\x30\x65\x16\x44\xb7\xff\x1a\x16\x53\x7a\x78\xfb\xac\x88\x1b\x5f\x3b\x50\x3b\x1b\x78\x1a\x0d\xac\x02\xb4\xc3\x01\x56\x31\x44\x7b\x73\x4e\x88\xf6\x13\x26\x03\x4b\x80\xb4\xeb\xd7\xfd\x25\x30\xda\x4b\xc3\xaa\xeb\xfd\xb4\x15\x58\xf5\x12\x48\xc3\xb9\x54\x4a\xe1\xe9\xe5\xe6\x9e\x8d\xa7\x37\x8b\xfd\x45\xb2\x6a\x91\x86\x01\x28\xed\xf5\xc4\x8d\x8a\xb1\xe5\xd7\xd4\x10\x4b\xd4\x86\xb6\x21\x45\x47\xa4\x68\x6a\xdf\x76\x2d\x36\x92\x9d\xab\x05\xe8\xcc\x86\x59\xcc\xe7\x5e\x42\x19\x2d\x04\x97\x9c\x25\xce\x40\x61\xb1\xe1\x24\x53\x28\x8e\x51\x50\x8e\xc4\xf2\x5c\xd8\xb3\xa0\x90\x4b\x51\x09\x67\xe2\xb5\x96\x22\xc3\x0c\xa7\x25\xa9\x88\x5b\x81\x8b\x0c\x10\x58\x22\xc1\x05\x39\x1a\xd0\x60\x16\x10\xeb\x9a\x86\x5a\x09\x30\xd9\x19\xfa\x2f\x41\x53\x7d\x17\xc4\x5f\xa0\x06\xb3\xa1\x64\xd7\x56\xf9\x85\x32\x26\x10\xbc\x3b\x3b\xe8\x76\x80\xc1\xa7\x73\x60\xdf\x60\xd8\x65\x76\x7d\x34\x0a\xbc\x29\xf2\x5c\x1f\x6f\xc0\xc6\xf3\x63\x93\xce\xd1\xa4\x33\x91\xa5\xbf\xd2\x61\xb4\x50\xc6\x25\xba\x49\x6a\xb1\x52\xf0\xf2\xc5\xcd\x36\xf7\x81\x54\x01\xba\xfc\x2c\x48\xf6\xc2\x2a\xc1\xac\xaf\x1e\xc1\x2d\xda\x21\x1b\xe9\xc3\xb9\xa5\x08\xbd\xf5\xdc\xde\xf5\x52\x34\xe6\x82\x6b\x9e\xd1\x48\xa5\x23\x20\x95\x98\x06\xcb\x03\x3f\xcf\x43\xac\x0c\xf0\xf3\x3c\xf4\x66\x03\x3f\xcf\x90\xf0\x79\x81\x9f\x4b\xc3\x3d\x2b\xeb\x85\x7a\xd6\xf8\xae\x6b\xd0\x88\xa5\xe9\x96\xe3\x15\xc3\x44\x21\x12\xe8\xe1\xa1\x17\x42\x2d\xd6\x0f\xe0\x72\xa0\xc5\x0b\x42\x16\xcf\x83\x00\xb8\x9b\x20\x00\x26\xed\x26\xc2\x94\x27\xaf\xf8\xee\x83\x68\x6e\x91\x46\xbc\x11\xc0\x73\x74\x75\x2e\x0a\xa4\xc9\x94\xb7\x1a\x8c\x3a\x9a\x88\x63\x91\x49\x18\x9e\x82\xbe\x14\xbd\x13\x60\x35\xa5\x0f\x09\x00\x9d\xd8\x45\x53\xca\x9b\xe1\xce\x35\x17\xb8\x90\xee\xfa\x65\x39\x7c\x8d\x84\x61\x0e\xc2\x27\x60\x86\x18\xb6\xd2\x78\xdd\x2c\x38\x69\x64\x25\x11\x36\x5d\x69\xd0\xa8\x67\x7b\xd8\xf0\xe9\x76\x1a\x42\xb2\x7c\xa0\x8e\x24\x28\x2c\x21\x70\xce\x37\xde\x74\x07\x09\x33\xab\xa4\xbb\x37\x3b\x03\x38\x06\xd0\x33\x2d\xc6\x0c\x6b\x5c\xc9\xf3\x42\x8f\x79\x03\xd7\x67\x52\xd8\x9b\x7c\x4d\xa4\x50\x6a\xd1\x3f\x09\xf8\x62\xc6\x67\x8e\xa1\x84\x98\x2a\xb0\x67\xda\xdd\x67\x0d\xe8\x1d\xe2\xda\x48\x0a\xbf\xe3\xc5\x23\x7e\xc7\x23\x7e\xc7\x17\xc5\xef\x10\xa4\xe0\x8e\x52\x7e\xdd\x5f\xac\xaa\x80\xa5\x20\x3d\xd2\xc4\x16\xc5\xdf\x58\x0b\x6a\xc9\xee\x0a\x50\x4b\x76\x97\x43\x2d\xd9\x5b\x23\x6a\xc9\xde\xaa\x50\x4b\xf6\x56\x80\x5a\xf2\x17\x42\xf1\x58\x2b\x3c\x4b\x9a\xfc\x12\xb5\x4d\x93\x5a\x18\x53\x84\x7a\xbc\xd2\xe0\xcc\x05\x80\x22\x0b\x8a\xf1\x8b\xf5\xa3\x4c\x7c\xbf\x7e\xd0\x12\x61\x4f\xae\x11\x7b\xa5\xd1\x58\x00\x2c\x63\x41\x58\x91\x74\xdc\x8a\xbc\xaa\xd4\x17\x6d\xaf\xdd\xb5\xa3\xe1\x34\xf6\xe6\x04\x79\x79\x04\x16\x79\x04\x16\x79\x04\x16\x59\x33\xb0\x08\xdd\x30\xfe\xd5\x8d\x07\xc1\x38\x96\xca\x0d\xba\x7f\x80\xd8\x46\x5c\x1a\x68\x8b\xa2\x0e\xba\x7b\x68\xcb\x72\xe4\xfa\x28\xe8\xfe\xc1\x5b\x84\xe4\xa8\x81\x6f\xe9\x51\xdf\x70\x4d\xf4\xb2\x83\xea\x26\x22\x13\x8a\xeb\xf3\x4e\x7e\x52\x6a\xe8\x00\x03\xae\x29\x67\x66\xa3\xc7\x25\x63\x27\xe8\xfe\x01\xd2\x98\x1d\x32\x8f\xb0\x29\x8f\xb0\x29\x8f\xb0\x29\x5f\x19\x6c\x0a\x58\x60\xc8\x46\x57\x61\x30\x1e\xa1\xa0\x0f\x3b\x53\xb6\x87\xba\x5a\x34\x15\x06\xa6\xe2\xda\xde\x9b\x72\x80\x2a\x5a\x73\x6f\x6d\x88\x2a\x94\xaf\x62\x54\x15\x9a\x66\xb5\xc8\x2a\x94\xe6\x7f\x2f\xba\x0a\xad\x5f\x49\x84\x15\xd6\x18\x4b\xa3\xac\x6c\x64\xfc\x50\x53\x38\x22\xb4\xb6\xb3\xf1\x56\x1c\x3b\xb6\x67\xa0\xad\xbc\x83\xe8\xe3\x10\x56\xee\xbf\x17\x69\x65\x35\x88\x20\x7c\x8c\x7d\xb3\xa8\x20\x3c\x6a\x63\x12\xb0\x71\xf5\x88\x20\x8e\x7c\x57\x20\x17\x0f\xe4\x0a\xc7\x49\x50\x9d\x9c\x96\x52\xd2\x68\xbd\xc5\x0b\xae\x6d\x2b\x91\xa1\x72\x83\x42\xa1\x54\x60\xa8\x54\x4c\x28\xc5\x99\xba\x74\x40\x50\xcd\xb2\x75\xde\x80\xa0\xbc\xcc\x65\x83\x82\x4a\xda\x50\x13\x18\x34\xa7\x6f\xa8\x07\x32\xdd\xcb\x81\xc0\xdb\x85\x6e\xfc\x52\x3a\x7e\x81\x5c\x03\xd9\x12\x25\xa9\xe6\x85\x6d\xc9\x6c\xd1\x96\xb9\x0d\xaf\x96\x37\x1f\x71\xdd\x9d\xf8\x35\x00\xb7\xcc\x62\x9a\xfa\x67\xce\x80\x6e\x59\xaa\x9e\x25\x6f\xb4\x67\xb6\xf7\xb4\xf7\xd9\x53\x8c\xa6\xa5\x2f\xe1\xb3\x94\xdc\x45\x25\x41\x1e\x32\xa9\x0d\x16\x1b\xa0\x2c\x58\xcb\xac\x9b\xc7\x2a\xfe\xc3\x6e\x16\xff\x41\x0a\x50\x2f\xdf\xce\x4d\xde\x66\x13\x43\x38\xf7\x4c\x62\x78\xab\x5c\x69\x49\x45\xc3\x63\xa9\x75\x81\xf0\xc8\xbf\x80\x2c\x1f\x20\x61\xde\xfa\x99\x51\xb0\xd0\x79\x35\xa2\xe3\x1a\x55\x25\x46\x93\x47\x60\x85\x3c\xca\x65\x55\x2f\xcc\xc5\x51\x6c\x74\xdb\xab\x25\x2f\xfc\xd3\x7a\x65\xf5\x19\xed\xe7\x92\x08\x32\xa3\x0c\x7c\x8c\x8a\x05\x73\x97\xd3\xee\x6a\x04\x93\xe4\x06\x9c\xb8\xb4\xb7\x60\xcd\xfb\x69\xe4\x86\xe8\xa8\xff\x76\xe0\x7a\x0e\x5b\x11\x50\x40\x98\x91\x12\x63\xd7\x4d\x01\x1e\xd0\x51\x43\xdb\x21\x0b\x7c\x93\x87\x24\xe0\xda\xde\x76\xd7\x0e\xb7\x69\xbe\x6a\x52\xa5\x59\xb8\x34\xb2\xa2\x77\x61\x91\x2d\x4b\xf3\x2b\x65\x20\xb4\x90\x5e\x6f\xce\xba\x30\xc6\x86\x73\x79\xd4\x01\x5d\x86\x39\x51\x07\xf2\x6f\x19\x2a\xe6\xd2\x9e\x12\xe0\x1a\xcd\x7b\xc3\xb0\x04\xe2\xc0\xde\x42\x88\x03\x7b\x8b\x21\x0e\xec\xcd\x8b\x38\xb0\x57\x84\x38\xc0\x16\x1e\xa9\xdb\x92\xef\x14\x03\x73\xe6\x3d\xb1\xd9\x73\x54\x89\x7b\x62\x79\x87\x63\x7f\x09\xb4\x01\xba\x40\x29\x89\x38\x30\x0b\x3e\x60\x01\xa0\x02\x49\x3f\x8a\x9f\xab\x42\x1c\x28\x1d\xd6\x5c\x95\x4c\x86\x37\xf0\x8e\x85\x4d\xe7\xbf\x17\xc1\x1a\x90\x6f\x5a\x2b\xe1\xd5\x16\x5c\x12\xcc\xbe\xec\xaf\x06\x4c\x8d\xc3\x69\x4d\xb3\x4e\xc8\x63\x51\x8a\xe8\xb6\x36\x06\x45\xf0\x5c\xc6\x1e\x7f\x5e\x12\x9b\x40\x8e\x85\xa5\x6f\x75\x2d\x58\x41\x12\x1e\x4b\xd7\x0e\x65\x90\x0b\xd2\xed\x29\xad\x0d\xd5\x0a\x66\x0b\x57\x56\x9c\xe9\xce\x6a\x17\x63\x22\xac\xa9\x8b\x74\xf1\x76\xe7\xc1\x23\xc8\x69\x50\x23\x36\xcb\x01\x0b\xac\x42\xd3\xa3\x42\x6d\xaf\x73\x0c\x28\xbc\x14\x4c\xfe\xf9\x63\xcf\x53\xdf\x28\x10\x08\x9a\x25\x05\x87\x40\x90\x32\x2d\x00\x87\xc0\x08\x97\xb1\x67\xe6\xbc\x1b\xaf\x18\x2a\xcf\xe6\x30\x54\xb4\xf7\xd9\x93\x72\xcb\x4e\xed\xb9\x30\x08\x0e\x53\xbb\x4e\x12\x3b\x3a\x81\x40\x10\x31\xc4\x97\x00\x40\x00\x2f\x67\x20\x3f\x0b\xfc\x40\x6f\x29\x96\x00\x3f\xc8\xca\x83\xb4\xc5\x95\xdb\xd9\x6f\xec\xde\xf5\x55\x18\x8c\x7d\xa7\xb0\xbf\x93\x64\x05\x0b\xd7\x3d\x9d\xf1\x9a\x5a\x1d\x4a\x70\xa3\xf2\x97\xd4\x8a\x8d\x17\xf6\x39\xd6\x6d\x12\x47\x49\xc1\x4b\x2c\xe3\x76\x76\x10\x8e\x3c\xd7\x8f\xb7\x1d\x37\xb2\xbb\x1e\xde\xf6\xf1\x24\xde\xf6\x5c\x1f\x23\x3f\xd8\x1e\xfb\xe3\x08\x3b\xdb\x37\x76\x18\x29\x2b\x3f\xee\xee\x4d\x55\x32\xf5\x4d\x56\x06\x7f\xc2\x9c\x48\x95\xbc\xb2\x52\xca\x32\x8a\x8b\x16\xd8\x8c\xed\x73\x16\x8e\xda\x42\xd5\x84\x92\xbc\x7c\x66\x71\xf4\xa5\x66\x51\x26\x41\x0d\x2e\x84\x02\xab\xa3\x5f\xd0\xce\xbd\x82\x25\xb5\x51\x67\xdf\xbe\xeb\x79\x2d\x54\xfd\x1b\xc6\xb8\x2a\xa7\x94\xda\x23\x2d\x44\x6b\x5d\x01\xef\xcd\x58\x01\xeb\x70\x57\x97\x5b\x15\x27\xb5\x2b\xbf\x40\xde\xd3\x2c\x90\xe5\x16\x9b\x73\x0d\x3c\x3f\x68\xca\x7e\x39\xd0\x94\xfd\x0c\x68\x8a\x32\x6f\xec\x67\xe6\x8d\x2c\xa6\xca\xbe\x1e\x53\x45\x19\x42\x3c\xa5\x7e\x10\xe5\xcf\x45\xfb\xa5\xb1\x55\x1c\x3e\x71\x48\xd3\xca\x37\x8a\xab\x62\x87\xd8\x5e\x10\x56\x65\x25\xcb\xe5\xb9\x0d\xa8\x12\xa8\x2a\x92\x34\x14\xc2\xa2\xcc\x65\x05\xae\xd4\x06\xcc\xc7\xd9\xcc\xea\x81\x6a\x6a\x0d\x9e\x18\x06\xd2\xdc\xed\x28\xd6\xa1\xb4\x34\xf9\x36\x6b\xcf\x26\xe5\xfc\xaa\x73\x33\x35\xb7\xde\xab\xc3\xce\xc9\x73\x68\x2d\x89\x9d\x93\x0f\x19\xac\x28\xba\xa0\x77\xfd\xab\x1b\x71\x6c\xdb\xf4\xc9\xe3\x0f\xa8\x2e\x4d\x03\xcc\xde\xd4\x58\xfd\x19\x08\x1e\xba\x21\x53\x0c\xc3\xb3\x3b\x3f\x0c\x0f\x25\xbb\x1c\x14\x8f\x7e\x56\x5e\x25\x14\x8f\xfe\xf2\x81\x02\xc5\x53\x12\x85\x26\x97\x52\xa9\xdb\xf0\xb3\xf8\x58\xa4\xe0\x45\x50\x68\xbe\xee\x5a\xcc\x44\xf6\x58\x13\xfb\xb3\x60\x05\x72\x33\x32\x2c\x03\x19\xd9\xe3\xf4\x0b\xd5\x61\x36\xc2\xc1\x67\xa9\xfe\x21\x35\x87\x17\x16\x84\x92\xe0\x58\x5f\xab\x1c\x2f\xdc\xfe\x29\x70\xac\x8d\xf4\x02\xea\xb3\x37\xc5\x12\xf5\xa1\xad\x48\xa5\x62\xe8\xfa\x00\x10\x79\xea\xfe\xb9\xd8\xa8\x48\xc4\x62\x68\x4f\xde\xd8\xe1\x0a\x08\x39\xe0\x6e\xb6\x00\x89\xd9\x48\x57\xf9\x6d\x22\x21\x5d\x15\xa3\x4c\x95\xa8\xc0\x2c\x94\xa9\x52\x24\x5c\x7f\x39\xf1\x92\x69\x05\xe3\x78\x65\xb4\x66\x02\x4e\xe5\x52\x81\x9c\x09\x4e\x54\x39\xb8\x96\xe2\xe1\x33\xf7\x96\x42\x01\x5c\xcb\x4c\xc0\x9d\x35\x8d\x64\x00\x32\xf9\x12\xf3\xc2\x42\x79\xe9\x3c\x46\x5b\x2c\x59\x01\xfd\x25\x9a\x6d\x89\x29\x5c\x99\x89\x67\xe1\x02\x15\x57\x79\x1e\x5c\xa0\xe2\x36\x98\x03\x17\xa8\x04\xa1\x99\xb8\x40\x33\x68\xcc\x0b\x0c\x34\xa3\x95\xe6\x81\xf3\x29\xa1\xf7\xe6\x82\xf3\x99\x87\xde\x6c\x38\x9f\x19\x1a\x70\x41\x38\x1f\x0b\x55\xa3\x11\xb1\x03\x56\x05\xec\xa3\x5a\x12\x3a\xac\x1f\x3d\x94\x0f\x9d\xed\xcf\x2f\x16\x86\xf5\xd1\x2b\xfa\xaf\x11\xd6\xc7\x65\x11\xf4\x00\x60\x87\x3c\x08\x4c\x13\xbe\x53\x0f\x5f\x94\x2d\xda\x52\x50\x40\xc9\x9b\x33\xb7\x77\xad\x4b\x09\xef\xe7\x40\x0e\x12\x2f\x54\x82\xea\xeb\xd5\xc1\x0c\xf1\xcf\x51\x6c\xf7\xae\x53\x74\xa4\x77\x3c\x59\xd7\x0e\x8f\x83\xc8\xe5\x4e\x4e\x90\x4c\x7a\x97\x24\xf3\x1d\x22\x8e\x52\x1a\xfa\x42\xe6\x06\x1c\x06\x84\xbb\xa5\x60\x2a\x79\x2d\x01\x1a\x95\x3a\x0f\xd3\x5e\x18\x4e\x0e\x33\x7c\x87\xb3\x79\xd4\x7f\x63\x33\xe1\x94\x99\x07\x31\x81\x2d\x23\x38\x01\x1a\x05\xe2\xbc\x8f\x6d\x1a\x9d\x5f\x88\xeb\x07\xf3\x42\x33\x89\xbd\xe9\x60\x1c\xf3\xdb\xb1\x35\xfa\xc8\x3f\x5e\x92\xe2\xff\xce\x25\x92\x3c\xa8\x02\xd9\x1b\xb8\x9e\x13\xc2\xd5\x1d\x29\x69\x8d\xbf\xe6\xc9\x64\x75\x90\x4a\x2a\x7f\x12\x8d\x0b\x97\xc6\xdc\x1e\x93\x4a\xce\x61\xa7\xc3\x9d\x96\xaa\xe8\x95\x24\xb7\x2d\x49\xe4\x39\xe3\x5c\x4e\x82\xa1\x0d\x1e\x73\xb2\x2c\xbd\x92\xe9\x53\xa8\xa4\x9a\x03\x09\x0d\x1e\xf4\x88\x93\xe9\xda\x11\xfe\xa5\x34\xfe\x93\xbe\xaf\xff\xe0\x87\x9f\x6f\x38\x31\xa9\xaf\xef\x68\xb3\xb7\x78\x08\x4b\x89\xb3\x96\xd2\x0c\xf4\x18\x08\xba\x18\x7b\xde\x12\x67\xb1\x03\x21\x7a\xaf\x3d\xef\xcd\x94\x68\x60\x86\xdc\xc4\x3b\x6d\xce\x6b\xfc\xba\x2b\x6a\xa2\x1b\xe8\xbe\x6f\x49\xdc\x2f\xd9\x2f\x4b\x3e\x8a\xa5\xee\xff\xc9\x66\xb1\xb4\x1a\xd2\x7c\x95\xd6\x37\x9a\xaf\x8a\xdb\x4d\xfa\xa3\xe4\xbe\x93\xfe\x94\x98\xb7\x74\x2f\x3b\x7d\x2b\x81\xdd\x82\xe6\x42\x26\x1f\xbb\x2d\x27\x3e\x6f\xa0\x71\xe3\x70\xec\xf7\xec\x18\xbf\x99\x32\x91\xe6\x0e\x3b\xbc\xc0\xf3\x94\xfa\xda\xa2\xcd\x79\x61\xa9\x43\x81\xef\x3e\xab\xf7\x02\x96\xe5\x71\x0e\x88\x33\x53\x0e\x69\x58\xe0\xc9\x91\x0f\x2a\x64\x98\x0c\xd8\x4c\xf5\xd9\xa6\x35\x38\x17\x23\x96\xc1\x8b\x5d\xa4\xaf\x16\x89\xde\xd2\xa8\x95\x84\xa2\x2a\x62\x8b\xb6\x8b\xf0\x7b\x78\x6b\xc7\xf8\x6d\x10\x84\x8e\xeb\xdb\xb1\x32\xfe\x45\x0d\x6c\x18\xf2\xd9\xe9\x1c\xa1\x98\x4c\xaf\xad\xf4\xbc\x2e\x8b\x26\x9d\xc8\x5a\x28\x3d\xa5\x21\x14\xf4\xfb\x11\x8e\x5b\x64\xba\xaa\xd1\xdf\xb2\xb4\xc7\x21\x8f\x4f\x2a\x0f\x2e\x7a\x46\x4e\xfe\xa4\x8e\xa0\x95\x01\x92\x46\xa5\x83\xd6\x3e\x6f\x5c\x88\xb4\xca\x48\xd3\xa7\xae\x27\xa9\xd5\x51\x2b\x37\xff\x16\x30\x1f\xc1\xfc\xc0\x3b\x3b\x75\xd3\x49\x7b\xaf\x49\xb9\x2e\x24\xae\x40\xc9\xf3\x8d\x89\x5e\xa2\x3a\xda\xdc\x44\xe2\x6b\x42\xd5\x44\x3f\x20\x7d\xa6\x4c\xb0\x59\x92\x67\xb5\x17\xbd\xa4\xca\xdd\xdf\x23\x95\xe5\xa7\xb9\x95\xd9\xd6\xd6\x43\xf6\x42\x10\xed\xb4\xd5\xa1\x6c\xab\x83\x43\xab\xe5\xee\x34\x2a\xb0\x95\x89\x7d\x2b\x03\xf7\x29\x9b\x55\xd2\x83\xa5\x6e\x3d\x49\x0f\x96\xe2\xc1\x49\x0d\x83\xe2\xcb\x77\x3c\x15\x7f\xce\x38\xd7\x3d\x68\x15\x9d\x3a\xac\xf5\x80\x89\xf9\x52\x99\x93\x3e\x4f\xe6\x3f\x9f\xd6\xc8\x58\xec\x42\x69\xe8\x6d\xf4\x2f\xa5\x33\xa4\xe6\x29\x18\xd5\xa2\xbd\xe5\xd6\xdf\x96\xfb\x6e\xe1\xa1\x4d\xb3\x97\x1f\xdb\x97\xeb\x1a\xdc\xac\x56\x4b\x8c\x6e\x56\x15\xc9\xaf\x54\x6e\xae\xad\x0e\xe3\x5d\x3b\xfd\x15\x38\xf1\xa6\x35\x40\x72\xf0\xad\x62\x6d\x5a\xb2\xe9\xd0\x4a\xd9\xd7\x74\x36\x66\xc8\x9e\xe7\x0d\xe1\x4d\xb0\x6a\x4d\xa1\x73\x58\x6e\x21\x45\x27\x3c\x58\xcc\x60\xde\xdc\xa4\x3f\x98\x27\x7f\xfa\x59\x8a\x7b\x9e\xc6\x0e\xa5\x9b\x12\xcc\x94\xb5\xd8\x72\xa4\xc5\x97\x25\x6b\x82\x12\x4d\x70\x12\x52\x70\xa2\xdf\x7f\x85\x70\xa2\xa1\xed\x5f\xe1\x7c\x30\xd1\xfa\x82\x30\x6e\x69\xfa\xab\xc0\x12\x65\xa4\x1e\x91\x44\x17\x02\xfa\x5c\x0b\xa6\x66\x26\xde\xd7\x42\xb0\xa1\x4b\x61\x6a\xee\xae\x11\x53\x53\x8f\xc0\xbe\x10\x6e\xe8\xf2\x98\x9a\x7b\x6b\xc4\xd4\xdc\x5b\x15\xa6\xe6\xde\x0a\x30\x35\x9f\x5d\x3a\xbb\x97\x60\xa5\xe5\xe3\x69\x3e\x5b\x10\xf0\x76\x7f\x4e\x10\xc0\xc5\x20\x32\xd7\x0d\xfd\xf8\x79\x40\x32\x93\xdd\xa2\x33\x3c\xc9\x57\x1d\xfb\x2f\x28\x58\xe2\x23\x56\xe2\x23\x56\xe2\x23\x56\xe2\x4a\xb1\x12\x15\xa8\xc4\x54\xb3\x71\x84\x44\xb6\x59\x26\x21\x20\x4a\x98\x88\xfa\x16\x4f\xb2\xde\xa5\x80\xfc\x65\xcc\xb7\x3c\x88\xb7\x34\x0c\x1c\x00\xbe\xf1\xc5\x3a\x00\x23\xb2\x31\x03\x34\x25\x74\xbf\xa0\xfb\xc7\x23\x3e\xe2\x23\x3e\xe2\x23\x3e\xe2\x57\x87\x8f\xf8\x26\x1c\x47\x83\x14\x10\x22\xd1\x4a\xf0\xbe\xcc\x16\x8a\xce\xe6\x29\x83\x7f\x38\x37\xfc\x21\x70\x54\x00\x7d\x08\xdf\x0d\x05\x95\x4a\x8f\x67\x08\x09\x4d\x05\x0f\xb1\x2c\x62\x20\x64\x2d\x03\x13\x48\xcb\xa0\x10\x81\x2c\x33\xe5\x8c\x97\x2b\xa3\xe2\xbd\x0b\xed\x2b\xa5\x11\xb0\x74\xa4\xd1\x67\x88\x86\x35\x0f\xdb\x37\xf8\xcc\x1d\xe2\x50\xde\xef\xea\x79\xd8\x0e\xc9\xdb\x60\x1c\x67\x13\x26\xdb\x4c\xe9\x4f\xa8\xa3\xbf\x39\x95\x94\xc7\x2f\x49\x9d\x85\xf6\x0d\xf6\x3c\x1c\xfe\x14\xdc\xb8\xfe\x95\x5c\xb8\x5c\x09\x39\x19\x36\xb0\x16\x45\x4b\xa1\x7b\xea\xb9\x0e\x2e\xa6\x09\x49\x48\xeb\xc8\xf4\x36\xd8\x46\x71\xa6\x19\xcf\x82\x71\x6f\x40\x4a\x2f\x6a\x4b\x5c\xeb\x0d\x6c\xff\x0a\x3b\x90\x1a\x13\x3d\x45\x35\xcd\xe6\x26\x4a\x7f\xe3\x77\x99\x5f\xa2\x7a\x1e\x87\x94\xb9\x54\x3e\x79\x2f\x3a\x9f\x5d\x92\xb5\x3c\xd6\x62\xb2\x6b\x9b\xee\x10\xc9\x3d\x87\xa7\x90\x9a\x56\x86\x92\x94\xae\x25\x6a\xf8\x01\x0f\xb2\x5f\x43\x7b\x34\x02\xe9\xd0\x31\x35\x53\x38\x60\x23\xad\x7c\x2f\x2b\xe2\x18\xe1\x58\x95\x63\xa5\x99\x2c\xd4\xa8\xd7\xeb\x25\x9a\x15\x3c\xea\xa0\xd4\xa3\x50\x70\xb7\x40\x23\xe3\x49\xcc\x1d\x98\x88\xf6\x2e\xdb\x80\xab\x2d\xb9\x6c\xdf\x89\x81\x92\xc5\xd5\xc4\xea\x5d\x52\x7c\x83\x7d\x92\x20\x33\x0e\x0a\xe4\xff\x55\xe6\xcb\x79\xfd\x02\xb5\x50\x72\x58\xb7\x3a\x69\xe5\x21\xe4\xe8\xbf\x88\x7d\xc2\x50\xaf\xdf\x5a\x94\xfd\xda\xc8\xbe\xc2\xbf\x15\x36\x4b\xcc\x4b\x15\x8d\xf2\x2f\x68\xa8\x30\x92\x0e\xc7\x22\x46\x54\xab\xc6\x44\xc6\x5a\xd7\xf5\x1d\x0e\x1d\x5a\xa5\x79\xaa\xe2\x12\x1c\xf6\x9d\x39\x29\x90\x1c\x55\x53\xc3\x33\x07\x86\x4d\x70\x3b\x29\x96\x0d\x7f\x4a\xba\x83\xa6\x1f\x8f\x1c\x3b\xc6\xa7\x70\xa6\xc5\xa6\xbd\x16\xba\x63\x47\x68\xf2\xd5\x65\x3d\xd4\x29\x9b\x4f\x3f\x33\xcc\xe9\x0c\x88\xbe\x72\xe0\x17\x99\x3b\xcc\xb7\xae\x13\x0f\x92\xcf\xf0\x28\x7f\x4f\x70\xf8\x6a\x0a\xf8\x9e\x10\x93\x5f\x55\x02\xea\x7b\x39\x07\x6d\x74\x19\x85\x95\xbf\x51\xaf\x31\x4b\x28\xab\xc0\x3a\x31\x87\xf9\x8d\xe6\xe4\x93\xa0\x46\x3e\xf3\x07\xb8\x2b\x99\xca\x9e\x79\xa3\xb9\x10\xad\x8e\xc1\x8c\x88\x24\x3d\xa2\x9b\x9b\x13\xea\xb4\x2d\x09\x43\xf4\x97\xc2\xf0\x04\x3e\x4c\xd4\x97\xa9\x56\x24\x29\xd4\x57\x59\x2e\xc1\x7d\x0b\x76\xf5\x8d\x73\x89\xba\xa5\x14\xb5\x85\xd2\x5c\x6d\xe7\x96\x7a\x21\xd9\x3a\x49\x11\xe0\x53\x22\x84\x4a\x75\x1a\xd3\xb9\x33\x69\x11\x1a\x18\x3e\x1e\x3d\x3c\xa6\xc9\x24\xc0\x06\xf9\xa4\x3e\x4f\x0b\x26\xaa\x26\xe1\x43\x6a\xf1\x48\x38\x00\x99\xa9\x53\xf3\xbc\x1c\xd8\x77\x68\x7a\x85\x0f\xf6\x6b\x03\xe9\x81\x07\x94\xc1\xfa\xb3\x3f\x0c\xc6\x7e\x5c\x66\x5c\xb3\xa4\xd2\xec\x95\xf0\x94\x32\x23\x35\x2d\x4f\x3f\x4b\x23\xa3\xac\x31\x9b\x6f\xcb\xce\x32\x65\x73\xea\x7f\x85\x69\x23\x1f\xfa\x27\x44\xf0\xf2\xf1\x88\xe5\x54\x06\x08\xa9\x85\x26\xaa\x1e\xa3\xc0\xe7\xf0\x8d\x6f\xca\x49\x5f\x23\x36\x0b\xd7\xe5\x97\x18\x6c\x3d\x92\x71\x1b\x35\x44\x8b\xdc\x0e\x5c\x0f\x13\xe9\x73\xb8\x1b\x0c\x7a\x89\x1a\xe9\x13\xed\xa1\xeb\x38\x09\x3a\x70\xdf\x0b\x82\xd0\xa0\xc0\x4f\x68\x8b\x10\x36\xd1\x0e\x6a\xa6\x91\x47\x80\xbb\x73\x9a\xf5\x02\xbd\x44\x29\xf4\x34\xca\x0f\xfd\x2c\xc9\x73\x1a\x7b\x16\x89\xda\x64\x92\xa6\xd7\x0e\x6c\xbc\x4c\xd0\x4b\xd6\x34\xe7\xd8\x77\x2e\x88\xf9\xe0\x3b\x88\x9d\xfb\xe6\xc2\x62\xf0\x76\x9f\xd1\x2d\xe0\x90\x9d\x42\x1d\x86\xb1\xc5\x5c\x7f\xe9\x60\xfa\x2d\x3d\x8e\xf8\x57\xf2\x5b\x99\x76\x86\xe0\x68\x2a\x40\x97\x59\x6e\xc8\xa3\x60\x34\x0f\xed\x89\x48\x67\x4f\x0a\xd2\xb9\x3e\xf7\x44\xe6\x97\xcc\x15\x71\x4a\x8f\x10\x8b\xe4\x48\x97\x34\x2f\x05\x7b\x92\x41\x94\x90\xc0\x83\x85\x76\x69\x09\xee\x14\xe7\x49\xfe\x8d\x95\xcb\x7b\xb5\xa8\xa7\x88\x8d\x7a\xd4\x3f\x73\x7b\xd7\xf9\xdd\x95\xa4\x31\x52\xd8\x7d\x65\xa0\xbd\x95\xf9\xbe\x99\x99\xf0\x63\xb7\x77\xfd\x63\x10\x0e\xed\x38\x06\x05\xc0\xd3\x29\xef\xd3\xf4\x98\xd7\xba\x44\x12\xc2\xe3\x4a\x5c\xc5\x78\x12\x97\xd9\xf4\xd0\x9d\x25\xcd\x70\xa8\x74\x12\x3c\x42\x29\x72\x2c\x6d\x99\xf2\x70\x20\xb3\xe0\xa6\x95\xfa\x9b\xe8\x95\xda\x50\x06\xa9\x1f\xb1\x12\xc9\xdf\xdc\xfe\x4d\x2d\x29\x72\x7a\x38\xbb\x42\x57\xfb\x97\x5b\xb3\x89\x69\x2b\x77\x47\xca\xb0\x27\xdd\x42\x57\x8c\xa9\x0f\x56\x66\x0e\x95\x92\xe6\x8e\x74\xfa\x9d\x8e\xf5\xb4\xc8\xe5\x83\x40\xcb\x60\xcd\x93\x7c\xeb\x72\x37\x6b\x5e\xe6\x98\x91\xbb\x05\x76\x64\xa4\xdc\x59\xe0\xb0\xd3\xe2\x65\xaa\x56\xe9\x84\xfc\x95\x8a\xde\xf9\x16\xd6\x68\x52\x32\xfe\x4a\x91\x71\xee\x1c\x85\xe9\x32\x8a\x4c\x3b\x6a\x9b\x2b\xb3\x35\x4d\x9d\xda\x01\xe1\x24\x84\xda\x84\x17\x16\x22\x26\x1b\x37\xd4\x52\x6d\xb2\x0d\x9d\x33\x23\x09\xed\x51\x9d\x79\x4a\x4b\xfc\xa1\x88\x0d\x7b\x92\xb0\xc1\x49\xd1\xdf\x8a\x92\x7e\x90\x9a\xc2\xc7\xb7\x5a\x55\x6b\xa4\xb4\xe7\x6f\x2d\x2e\x7c\x5b\xb4\x50\x45\x7f\xfe\xd6\xa2\x82\xc7\xbe\x49\xeb\x52\x75\x3d\x40\xcb\x92\x3a\x19\x2c\x65\xe9\x11\x8c\x6a\x96\x4a\x74\x3a\x49\x23\xcc\x3d\xb2\x0e\xe0\x9d\x2a\xb7\x04\x7f\x27\x4a\xc9\x42\xde\xe5\xd9\xa6\xf3\x57\xb0\x68\x79\xae\x5f\x9a\xe7\xe9\x98\xec\x52\xb9\x50\xd9\x64\x93\x1b\xae\x63\xa1\xcf\xb2\xc3\x91\xbf\xc1\x91\xdd\x6c\xb3\x8a\xb6\x3f\xd4\x0d\x8e\x21\xbc\x15\x89\x0e\x9d\x16\x72\x25\x24\xad\x2e\x59\xa3\x97\xdc\xff\x98\xd9\xc8\x84\x4e\xb9\xf6\x65\x5b\xb8\x29\x85\xce\x2a\xaf\xae\xda\x41\xd5\x36\x73\xf5\x7c\xaa\x02\x42\x39\x37\x6b\xa9\x2f\x72\xa6\x4c\xa3\x48\xd9\x32\xdf\x14\x76\x46\x21\xbe\xe1\x37\x7f\x12\x86\xce\x33\x99\x2e\xb2\xf3\x42\x3e\x40\xf8\x44\x42\xc7\x2e\x98\x17\xf6\x4a\xcf\x0b\x7b\x05\xf3\x42\x46\x8b\xef\xc9\x5a\x5c\xae\xaa\x1d\xda\x43\xd8\xcd\x4a\x2d\x2e\xe5\xb9\x51\x59\x43\x8a\x49\x91\xdb\x76\x79\xf3\x41\xaa\x6b\xd6\x34\x1f\x88\xbe\x5a\x89\xbe\xd7\x50\xe3\x6c\xd3\x96\xd2\x08\x01\x43\x8d\xa6\x02\xb3\xa5\xfa\xd6\x17\x4e\x0f\x94\xa2\x99\xa3\x1c\x0c\x31\x54\x20\x66\xa1\x95\x39\xbf\x17\xdf\xad\xac\xa8\x5b\x59\x96\xcc\x42\x0a\xd5\x54\x6f\x55\x2d\xde\x93\x24\x1f\x4f\x67\x5a\xda\x6d\x68\xda\xa7\xba\x19\xa5\x68\x4e\x91\x96\x7e\xf9\xca\x47\xda\x7a\xca\x51\x3a\x9a\xfd\xcb\x72\x88\xfe\x6c\x6d\xa0\xdf\x0a\x54\x0c\xab\x51\x6a\x7f\x25\xc7\xac\x1a\x29\x9b\x2a\xe9\xb1\xaf\xd9\x37\xe4\x23\x3f\x67\xbb\x31\x33\xee\x75\xbb\x8a\x2a\xd6\x20\xec\x27\x48\x1b\x7b\xd9\x1d\x95\x32\xeb\x12\xd9\x7f\xee\xbc\x02\x3f\xc0\x19\xbd\x72\x61\x1a\x26\xdf\xf9\x9a\xdf\x75\xd7\x30\x8d\xba\x45\x78\x34\x4d\xbe\x69\x37\x29\x1a\xdd\xc9\x66\xdc\x6a\xb6\xe2\xe4\x8d\xb8\x5d\xed\x46\x5c\xb2\xfd\x95\x59\xff\x6a\x4e\x54\x8a\xcf\xca\x0a\xa7\xef\x54\x0a\xcd\xbe\x9e\x76\x37\x2f\xb3\x97\x97\xde\xc1\xcb\x5f\x6e\x2f\x8a\x34\x3c\x1f\xb8\xf4\x44\x42\x8b\x56\x44\x7d\x2a\x7d\x98\xe6\xcf\x7e\xcf\xb2\xa3\x60\x80\xdd\xab\x41\x2c\xa5\xa0\x2f\xe4\x24\x7d\xd7\xf3\xa4\x04\xe4\x51\x1d\xcb\x61\x70\x2d\xe3\x58\xd3\x17\x73\x44\x9b\xc8\x78\x29\x67\xf0\x17\x19\x8c\x81\xb2\x61\x42\x0a\x69\xb1\xbf\x09\x3f\x14\x37\x57\xe5\x71\xd2\x42\x52\x6b\x4d\x5b\x48\x6a\x22\x68\x90\x16\x4a\xb5\x0b\x6d\x84\x16\xfb\x3b\x5b\x8f\xd2\x7e\x3d\xb6\xfd\x20\xb4\x87\x76\x61\xe7\xf3\x44\x73\xc2\xc7\x4e\x24\x70\xd6\x9c\xae\xdf\x2f\xea\xfa\xfd\x99\x5d\xbf\xaf\xe9\xfa\x59\xa8\xb4\xd2\x1d\x75\x0e\x4a\x9b\xba\x9f\x8e\x60\x6e\x77\x1c\x39\xe0\xc9\x7e\x8d\xbd\x51\x51\xb4\x07\x76\x18\xb3\x0e\x2f\xc4\x72\x6d\x4a\x28\x8d\xac\xb4\xca\x45\x2d\xf0\xbd\xa9\xb8\x68\xad\x2e\xeb\x9e\xc8\xa4\xcb\xa2\xd3\x2e\x26\xb5\x72\xbc\x32\xb9\x54\x59\x74\x97\x15\x47\x69\x61\x62\x87\x00\xaf\xc1\x9a\x33\xf9\xd0\x0b\x86\x23\xbb\x17\xa7\x17\x32\x8e\x08\x30\x59\x56\xa4\x85\x6a\x2d\x94\x69\x91\xca\x10\x53\xcc\x6f\x16\x72\x1d\x9d\x88\x3f\xcf\x15\xf1\x44\x92\x9f\xab\x92\x9c\x63\xa1\x3f\x2f\xb0\xd0\x53\xb2\xfd\x5c\x23\xdb\x29\xbd\xf5\x3c\xd1\x5b\x09\xcb\x9e\xeb\xe3\x8f\xea\x8e\xfe\x14\x6d\x71\xea\x3b\xa8\x69\xd2\x73\x82\x24\x87\xb2\x01\x2d\xb7\x86\x84\xc1\x3e\xcf\x5e\xe2\x6c\xdd\x28\xaa\xb4\x4a\x68\x61\x79\x90\xeb\x10\x6a\xc1\x9e\xdd\x8e\x53\xd2\x41\xff\xa9\xa8\x49\xb3\xbc\x3e\x34\x39\x19\x4c\xd2\x2c\xaf\x0d\x4d\xce\x77\xc1\xad\xcf\x32\xe6\x3b\x17\x9c\xbb\xce\x85\x9a\x17\xb6\x13\xe4\x20\x3c\xe5\x33\x47\xf1\xd4\xc3\x2d\x74\x87\x7a\xe3\x30\x0a\x42\x38\xc1\xf3\xb6\x43\x1c\xb9\x7f\xe2\xaa\x14\xc6\x44\x82\xef\x5d\xed\x44\x98\xd6\x27\x69\x8d\x22\x74\xca\xac\xc1\x92\x55\x2f\x7c\x36\x4d\xcf\xb1\xc9\xec\x5b\xf5\x03\x5f\xc6\xa7\x2f\x05\xb7\x5c\xa2\x96\x64\xdc\xa5\x6b\xd9\x68\x81\x31\xdb\x50\xaa\xda\x68\xd1\x31\xaa\x4c\x95\x4d\x9a\x32\xb3\x98\x55\xb3\x36\x35\x59\x19\xea\x3e\xd4\x4a\x5b\xdf\xbf\xf5\xfb\xfd\xaf\xa1\xbe\x68\x0b\x35\x97\xa8\x73\x3a\xfb\xdc\xf5\x66\x3f\x67\xc6\x59\x21\x43\xb6\x38\xca\x0a\x49\xa1\x9e\xd4\x69\x26\x8d\x17\x25\x26\x8d\x17\xea\xa4\x91\x9a\x01\x5e\xcc\x9e\x01\x5e\x7c\x1e\xcb\xb5\x40\x9f\x46\x52\x73\xa1\x25\x34\xe9\xa2\x7a\x34\xab\x45\x75\x9e\x6b\x72\xfa\x8c\xe6\x2c\xce\x90\xd5\x96\xc3\xe0\x06\x2b\xe0\xe6\xaa\x6a\x49\x1b\xf6\x3a\x73\xff\x68\x64\xf7\xdc\x78\xda\x42\xf5\x5a\x53\x31\xfa\xf5\x07\xc6\x33\x4c\x2f\x39\xa2\xef\x6f\xc9\x71\xc7\xb2\x6b\x03\xb2\xbc\x2d\xb6\xa1\xf0\x24\xd6\xae\x09\xbe\x2f\x8e\xac\xac\x9e\x3a\x7d\x5f\xf6\x78\xea\x7b\xed\x4e\xca\x54\xfa\x5e\x34\x9a\xbe\xd7\x8c\xa6\x1c\x2b\xed\xfb\xc2\xf3\x35\x65\x00\x7e\x2f\x06\xa0\xd4\x06\xb0\x23\xba\x9b\x7f\x46\xa9\x6e\x59\xef\xce\x3a\x70\xdc\xcd\x7a\x17\x50\x20\x06\xd4\x41\xcf\xe4\x82\xed\x38\x56\xfc\x10\x11\x1a\x05\x10\x7a\x8b\x46\x48\x29\x16\xd0\x64\xbf\xe0\x2b\xb7\xf3\x0a\xad\x3b\x3c\x89\xd5\xc0\x03\x2b\x61\xbf\x88\x8c\xe6\x56\xe3\x8c\x08\x0a\xda\xa0\x3b\x08\xce\xce\x5f\xfb\xbd\x01\xe8\x18\x2c\xf6\x63\xf8\xbf\x1b\x1c\x42\x04\x29\x91\x84\xba\xcd\xa4\x52\xe5\xaa\x10\xb4\x8d\xd2\xe8\x1d\x88\xe9\x13\x65\x75\x20\x7d\x7d\xb0\xa8\x44\x29\xce\x63\x7c\xc3\x5a\xf2\xc2\x90\x36\xa6\x44\xc2\x15\x59\x19\x5f\xb0\x07\x22\xe9\xd8\x70\xc1\x3e\x48\xfb\xf3\x64\x8d\x9d\xad\xb5\x75\x4a\xd6\x93\xaf\xac\x01\x34\x7f\x04\xa1\x46\xbd\x9c\xbb\x4d\xa3\x5e\x22\x48\x50\xa3\xae\x8f\x12\x94\xd9\xb8\x21\x09\xd9\xbb\xac\xf6\xdd\x2b\xab\x7d\xf7\x66\x69\xdf\x3d\xd0\xbe\xf2\x67\x79\xe3\x57\x4a\x26\xbf\x56\x93\x4b\x5b\xc1\x4a\x7a\xe9\x7d\x8a\x7e\xea\xf6\x83\x52\x88\xfa\x4d\xf5\x0e\x5e\x3a\xb8\x51\xc9\xd8\x44\xfa\xcb\xfd\x4a\x6c\x22\x50\xc8\xa9\xe0\x44\x49\x39\x6e\xc4\x36\x15\xdd\x5e\xb9\x8d\x33\x49\x45\xf0\x1d\xb4\x5a\x0f\xdc\x47\xc5\x06\x1a\x5c\x4d\x6c\x7c\xf5\xf3\x97\x7e\x9f\x22\x69\x78\xcd\x1e\xc1\x4f\x41\xca\x28\x26\x76\x6a\xf9\x5d\x08\x76\xf9\x46\x93\xe1\xe7\x51\x86\xec\x81\xef\x68\x76\x1a\xd2\x71\x7b\xf3\x53\x66\x78\x15\x6f\x75\x1b\x0b\xfa\x80\x48\xa6\x7c\x54\x92\x08\xca\xe6\xa6\x9c\x3e\xd9\x95\xd6\x92\xd3\xac\xd2\xb4\xe9\x92\x8d\x40\x9e\x36\x73\x17\x23\x27\x3d\x75\x3c\x62\xf7\x2e\x92\xb4\x86\xa2\x1f\x20\x6c\x91\xac\x00\xe0\x45\xe6\xee\x9b\x5a\x35\x6a\x58\x6b\xf4\xb5\x1a\x22\x08\x6e\x5a\x14\x87\x07\x6a\xce\x19\x1e\xe8\x0d\x1b\xb5\xba\xd0\x40\xa5\x43\xf7\xe8\x31\x4e\xa4\xd0\x3d\x1b\xdc\xf4\x5c\x82\x46\xb2\xec\x5a\x8a\x48\x61\x40\x87\xdc\xfc\x14\xad\x5b\x89\xfb\x01\xd3\xf6\xaa\x48\xb1\x85\xdd\xaa\xc8\xf1\xf5\xdf\xaa\xe8\xa9\x56\xcc\x12\x74\x09\x31\x76\x12\xb0\x58\x3f\x4a\xb1\x39\xe2\x60\xb4\x24\x27\x08\x85\x4b\xb6\x13\xa5\xd2\x0d\xe2\x38\x18\x2e\x4d\xc6\xc3\xfd\x65\x78\xd9\xa0\x9b\x7d\xe5\xa2\xf2\xe4\xd2\x2a\x15\x89\x61\xd6\x38\x5b\xa2\x25\x16\xc9\x4a\xa3\xf2\x58\x25\xe2\xc5\xe4\x92\x80\x78\x31\x54\xc9\x24\x5e\xee\x4b\xf5\x67\xe2\x10\xbf\x14\x19\xc5\xef\x7a\x21\x5a\x22\xa6\x02\x37\x9c\x16\xe3\x28\x70\x30\x0b\x38\x41\xdd\x79\x96\xe0\x25\xb9\xfd\xf6\x2d\x8a\xe8\x85\x29\x63\xfe\x6b\x62\x24\x4c\x58\x30\x81\x29\xfb\xcb\x94\x7b\x5d\xd6\xcc\x7b\x75\x9d\x5e\x7d\x66\x6d\x24\x61\x75\xfb\xfd\x7e\x55\x9e\xf6\xaa\x7f\xdb\xdf\xdf\xaf\x2a\x1a\xf4\x8e\x2a\xc1\x86\xc5\x15\x59\xc3\x12\xca\xa8\x61\x31\x85\xd2\x40\x0f\x02\xa3\x70\x55\x10\x85\x02\xfa\x40\x81\x27\xdc\xab\xd7\x8b\xe0\x09\x19\x99\x7c\x48\x42\x38\x62\x07\x83\xfc\x84\xbb\x2e\x6a\xc0\xa2\xbe\xdf\xfd\x9e\x95\xbc\x81\x9e\xa2\xb7\x90\x3e\x42\xb6\x8f\x60\x0c\xa3\xa0\x8f\x68\x3f\x45\xc8\x18\x01\x90\xfe\x0d\x46\xb6\xef\xec\x04\x21\xf2\xf1\x95\x4d\x9e\x4d\x34\x0a\x83\x2b\xc0\x0b\xf1\xaf\x50\x3f\x0c\x86\x84\xd4\x27\x18\xfb\x9f\xd0\x78\x84\xe2\xc0\x42\xdd\x71\x0c\x38\x21\xae\xdf\xf3\xc6\x70\x76\x8d\x3e\x61\xdf\xf9\x54\x43\xaf\x51\x14\xe3\x11\x29\xe9\xd3\x76\xe3\x13\x72\x23\x34\x8e\xb0\x43\x16\x64\xb6\x28\x42\x26\xe8\x46\x28\x1a\xe1\x9e\xdb\x77\xb1\x83\x6e\x69\x1c\x68\xc2\x30\x90\x43\x41\x48\x12\xe2\xd1\xa7\x1a\x3a\xec\xb3\x77\x6e\x04\x45\x8b\x5c\x16\x21\xe7\xc6\xd5\x08\x45\x38\x46\x71\x20\x48\x13\x6a\xe2\x21\x1e\x60\x5f\x24\xa8\x7f\xaa\x6d\x20\x68\xa2\xa7\x4f\x3f\x04\x31\x6e\x3d\x7d\x8a\xfe\x6d\xdf\xd8\xa7\x80\x88\x84\xfa\x81\xe7\x05\xb7\x11\xc9\x83\x0e\x0f\x0e\x0e\xb6\x9f\x3f\xdb\x23\xca\xcf\x77\xec\xd0\x01\xe4\xa8\x10\x47\x81\x47\xac\x55\x42\xa3\xef\x05\x76\xec\xfa\x57\xdb\xb0\xc3\x48\x37\x0b\x22\x74\x3b\x70\x7b\x03\xd4\xb3\x7d\xd2\x9e\xce\xb8\x87\xd1\xd8\xc7\x93\x11\xee\xc5\xd8\x21\xf9\xc7\x5e\x1c\x71\x2e\xfe\x41\xe1\x8c\xe8\x4f\xd7\xef\x61\x54\xaf\x35\x6a\x75\x78\x1e\x62\xd2\x61\x47\x7d\x74\x09\x8f\x3d\x3b\xc6\x57\x41\x38\x45\x3f\xc7\xae\x07\x6f\xc0\x51\x12\xdd\xd1\x8e\x7d\x40\xe7\x50\xe1\x4e\xfd\x02\x9d\x0d\x30\xbb\x57\x16\xf4\xa1\x2e\xf4\x2a\x9d\x2e\x13\xf6\x1d\x48\x4e\xfe\xce\x4c\x7c\x4e\x7a\xa4\xd3\xa0\x05\x50\x40\xd3\x38\x20\xa2\x10\x52\xe7\x8f\x20\x44\x0e\xe6\x0f\xdd\x29\xa5\x41\xcd\xf4\x08\xdd\x01\x66\xf9\x03\x3a\x61\xcf\xa2\x28\x49\x38\x69\x8e\x08\x63\x74\x59\x73\xe9\x8d\x2c\x0b\x5d\x52\xaf\xb8\x13\xba\x6b\xff\x14\xfd\x03\x4f\xec\xe1\xc8\xc3\xac\x09\xd9\x67\x63\x8f\x2c\x11\x9e\xa2\x9d\x1d\xd4\x79\x89\xce\xeb\x16\x19\xeb\x4d\x0b\xed\x5e\xa4\xd2\x6d\x67\x12\x6e\x37\x2c\xb4\xdd\xb4\xd0\x76\x26\x6d\xc3\x42\xcf\x94\xd4\x8c\xa6\x85\xf6\xd2\x49\xeb\x16\x6a\xd6\xd3\xc9\xc9\x0b\x0b\x35\x08\x33\xcf\x34\x19\xb6\xf7\x48\xe1\x73\xb1\xb3\x67\xa1\x7a\x9a\x23\xf2\x7f\x19\xea\x4a\xa2\x0b\xc0\xa0\x21\x9a\x24\x64\x3a\x44\xd2\x28\x80\x95\x45\xd5\x51\x8d\x69\x23\x7e\xfb\xb2\xbd\x91\x51\x66\x8d\xaf\x10\x6b\x75\x8d\xd0\xa3\xda\x32\x56\x01\xba\xba\x3c\xf4\x68\x63\x3d\xd0\xa3\x8d\x15\x40\x8f\x36\x96\x83\x1e\x6d\xae\x11\x7a\xb4\xb9\x2a\xe8\xd1\xe6\x0a\xa0\x47\x77\xd7\x08\x3d\xba\xbb\x2a\xe8\xd1\xdd\x15\x40\x8f\xee\xad\x1f\xbb\xf3\x19\x07\x1b\x3f\xfa\x69\x06\xfe\x68\x63\x6f\x61\x8c\xd3\x75\xa3\x83\x3e\x9f\x0f\x1d\x74\x51\x88\x53\x25\x16\x78\x6e\x11\xcf\x16\xec\x09\x5d\x90\x9d\xbc\x76\xda\x5d\x50\x49\xd5\xb3\xd0\xf2\x79\x45\x3c\x07\x18\xd5\x47\x14\xd5\x47\x14\xd5\x47\x14\xd5\x65\x51\x54\x33\xe0\xa9\x14\x1f\xf3\x57\xba\x7c\x93\x4a\xe3\x50\xa8\x11\x97\x01\xda\x8e\x70\x67\xab\x2d\x4b\x4f\x82\xa9\xca\x50\x56\xa3\x1a\x5c\xdb\x3f\xea\x1b\xae\x89\x5e\x76\x50\xdd\x44\x44\xeb\xba\x3e\xef\xda\x27\xa5\x06\x0c\x30\xe0\x9a\x72\x66\x36\x66\x5c\x32\x62\x82\xee\x1f\x20\x83\xd9\x81\xf2\x88\xa3\xfa\x88\xa3\xfa\x88\xa3\xfa\x75\xe1\xa8\xbe\xb5\xc3\x18\x47\xae\xed\xa3\xd7\x13\x37\x4a\x01\xaa\x52\x15\x25\x92\xb0\x08\x89\x29\x1c\xd4\x92\x30\xa8\x0a\x95\x02\x38\x54\x25\x9d\x51\x8c\x88\xaa\xa4\xe5\x37\x08\xf8\xb9\xfc\x4c\x50\x54\x25\x77\x19\x70\x54\xb5\x38\xb3\x66\x8f\x46\xde\x94\x51\x13\x66\x09\x45\x29\xcb\xc2\xd6\xa5\xea\xaf\xc0\xd7\x45\x83\x60\xec\x39\xa2\x45\x7e\x86\xdd\xea\x1c\x3f\x19\x6d\x5a\x40\x17\xa2\x73\x4f\xea\xfa\x3b\xe9\xe4\x37\x01\x0f\x30\x5a\x63\x8f\xf2\xb9\x7a\x88\x23\xb1\x9d\x9c\x3b\xe9\x50\xfa\xe7\x55\x96\xbf\x7a\x91\xdc\xd7\xd8\xd9\x61\xe6\x09\x2f\xca\x8d\x50\x14\x0c\x71\xec\x0e\x71\x84\xae\xb0\x8f\x43\x3b\xc6\x0e\xc2\x37\x38\x9c\x22\xf2\x16\x6d\x27\x59\x7b\xa4\x3b\x51\x3c\xb0\xd9\xee\xa3\xed\x79\x53\xa2\xa1\x29\x23\x08\xff\x67\x6c\x7b\x6e\x3c\x25\x44\x3d\xf7\x1a\x7b\x53\x14\x07\xa8\x6f\xbb\x5e\xc6\x4b\x28\xd7\x47\x88\xf1\x75\xe4\x49\xe0\x77\x45\xed\xc0\x12\xe6\x36\x05\x0b\x9e\xa9\x6d\x0c\x26\x7c\xb3\x43\x07\xeb\x96\x6d\x3c\x46\x7c\x34\xb0\x3d\x2f\xb8\x3d\x20\x75\xa7\x20\x3c\x9c\x5d\xa9\x2e\xb0\xb3\xbe\xea\x72\x44\x1b\x58\x4a\x73\xac\xa5\x2c\xea\x39\x25\x79\x51\x09\x47\x04\xf8\x03\xda\x8a\xfc\x7b\x8a\xde\xda\x5e\x6f\xec\xd9\x31\x86\x9d\xcd\x9e\x88\x51\x16\xa1\xa0\x8f\xb0\xef\xc0\x1e\x71\x44\xec\x1d\x88\x43\xc6\xb3\xb1\x3d\x56\x74\x47\x19\x7f\xa0\xce\x62\x67\x03\x4c\x7f\x04\x7d\x64\xa3\xc8\x1d\x8e\x3c\x0c\xf9\x44\x36\x7e\x13\x97\x67\x33\x26\x0d\x0b\x4d\x1b\x66\x0b\xf2\x26\xc5\xcb\xa5\xa3\x9e\x17\x44\xb0\x67\x4b\x48\x81\xa7\x1f\xa7\x87\x8c\x49\xd3\x42\xd3\x66\xc9\xfc\x36\xa8\x61\xc8\xba\xb3\xa1\x07\xb1\x72\x7b\xd7\xef\x5d\x9f\x06\x6b\x2b\xc0\xb1\x92\x93\x01\x8c\xd3\x7c\x48\x56\x13\x09\x73\x2a\xc7\x23\xba\x59\x74\xbd\xb2\x39\xf3\x7a\x65\x53\xe3\x32\x1d\x84\x2e\xf6\x63\x9b\xc7\x57\x66\xe9\xa4\xb7\x8a\x5f\xa2\xdb\xbb\xe6\x51\x7e\x25\x20\x2d\x35\xc0\x1c\x42\x43\x97\x58\x1c\x52\x22\xfa\x42\xf1\x78\x9e\x34\x34\x61\x58\x11\x9a\x34\xb5\xaf\xa7\xfa\xd4\x53\x7d\xea\x78\xa2\x7f\x3d\x4d\x87\x75\x65\xb8\x70\x64\xdd\xdc\xe1\x5c\xbf\x42\xdb\x0d\xd4\x52\x6f\xd4\xf5\x5d\xdf\xf6\xce\x92\xca\x83\x33\x9e\x68\x0c\x62\x08\xb2\xdf\x72\x26\xf2\x0e\x64\xa1\x54\x80\x39\xcd\x2e\x00\x0f\x24\xed\x46\x1f\xe0\x4c\x21\xc1\x07\xab\x09\xda\xc4\xce\x54\xdf\x20\x7a\xbb\xb2\x96\xc8\xbd\xa8\x6c\x74\xeb\xc6\xbd\x01\x32\xa4\xde\x55\x50\x15\xed\x08\xa3\x6a\x1c\x8c\xaa\x2d\xb9\x47\x48\xd3\x43\xb7\x64\xc8\xa6\x3a\x62\x8a\xb6\xd0\x13\xd6\x8a\x4f\x99\xec\xb5\xd3\x9d\x08\x9d\x30\x6d\x12\x43\x1c\x62\xe6\xa9\x6d\xdb\x4e\xf7\xa2\xa8\x96\xfc\xa5\x1b\x62\xfb\xba\x9d\xe2\xdb\xc3\xfd\x58\x61\x1c\x8a\x9b\xce\x60\x1c\x2a\x36\x51\x18\xbf\xa5\xa0\x0b\xa9\x16\x00\x6e\x26\xa5\xf8\x9e\xce\xc5\x37\x9c\xec\x2e\xc1\x78\x49\xbe\xb7\x56\xc7\x37\xdb\x7f\x5d\x5c\x48\xca\xca\x48\x09\x9e\xcb\xc9\x48\xfa\x46\xf5\x1d\x5c\x41\x23\x4b\x0d\xb8\xe2\x06\xd3\x4d\x0b\x4d\x1b\x16\xbd\xc4\x06\xd3\x47\x8b\x70\xf0\x60\x01\x75\x48\xd9\x42\xf1\xc4\x42\xd3\x16\x61\xef\x61\x06\xec\xa1\xdb\xbb\x3e\x13\xce\xe7\xc5\x53\x46\x92\x4e\xeb\x8b\x9d\x0f\x43\xa7\xd3\xdc\xbb\x79\x9a\x3b\xa5\x92\x77\x75\x2a\x39\x71\x97\xcf\xea\xc9\x52\xaa\x23\x33\x04\x15\x8a\x42\xbf\x32\x57\x7c\xc4\xae\x45\x2c\x30\x42\x72\xe8\x12\x6a\x48\xb8\xfa\xcf\x27\xc1\x0a\x49\x7e\x0f\xa0\xb4\x40\x25\xb9\x67\x89\xc5\x2f\xca\x95\x83\x62\xd1\x50\xd3\x6a\xc5\x23\x1f\x8d\x4a\x27\x1e\x7b\x25\xc5\x63\x4f\x27\x1e\xea\x65\x09\xd2\x4a\xb4\xf7\x96\x90\x90\xbc\xfe\xcd\x16\x35\xab\x43\xf2\x66\xaf\x0c\xa5\x05\xa4\x50\x23\x2d\x05\x64\x4b\x0a\x61\x5a\x82\x54\x8a\x33\xae\x74\x90\x25\xed\x7b\xd7\x2f\xbe\xd6\xca\x13\x7d\x13\x00\x2f\x3a\x69\x7d\x96\x27\xad\x36\xab\x99\x94\x92\xbf\x2a\x10\xea\x67\x3a\xa1\xe6\x2b\x59\x25\x58\xee\x4c\x6b\x4d\x77\x2c\x24\x45\x76\x3e\x0e\x71\xc4\xf9\x7e\x1d\xc7\xa1\xdb\x1d\x93\xc5\x13\x98\x6f\x49\xa3\x9b\xf2\x8d\x5c\xf9\xf6\x33\x97\x90\xf5\x32\xc2\x5b\xcc\x54\x81\x4a\x94\x8e\xe8\x74\xe8\x88\x22\x26\x6e\xe6\x03\x75\x44\xab\xa6\x21\xa8\x7d\x8c\x9d\x7f\xf1\x0e\xd7\x53\xdb\xdc\x14\xe6\x56\x01\x61\x92\x8c\xf7\x18\x2f\x40\xdb\x5d\x6c\x7f\x20\x73\x73\x3d\x7d\x6b\x7d\x0a\x40\xf1\x82\xbb\xa7\x1a\xb0\x01\x7e\x87\x3d\x23\xc2\x60\x0f\xe8\xf3\x8b\x54\x0f\x69\x80\xba\x6c\xc3\xf0\x7b\xa9\x99\x3a\x83\x62\x9c\xd5\x30\x54\x51\x2e\xdd\x2e\xac\x1a\x94\x97\xa7\x9a\xba\x36\x52\xe8\x0d\xbc\x55\x8a\x73\x35\xe5\x5b\x6e\xba\x46\x99\x03\xbc\xb8\x2c\x5a\x41\x52\x5f\xfd\x2d\xd2\x1e\xdf\x04\xdc\x26\xe2\xbe\x0d\xb9\xd0\x83\x14\x63\x09\x15\x5e\x98\x76\x7b\xd7\x87\x31\x1e\x16\x5f\x9a\x66\x89\x8c\x60\x44\xf7\xcc\x59\xb3\xf3\x90\x7b\xa9\x15\x21\x49\x9a\x35\xaf\x20\x60\xce\x5c\xed\xe1\x46\xbf\xd8\x9e\xeb\xf0\x06\xa1\x85\x2b\x11\xce\xa5\xd2\xe6\x6c\x6a\x19\x41\x48\xa9\x95\x36\x58\xd3\x62\x0e\x47\x86\x39\x83\x67\xfa\xd5\xd0\x96\xbb\x8a\x4a\xce\x7f\x2f\x55\xe3\xd1\x50\xfa\x5e\xaa\x7e\x38\xe6\x20\x31\xa4\xa4\x96\xd4\x71\x1b\xc4\xa9\x2a\xe5\x7d\x50\x6e\x8c\xc2\x67\xf1\x9c\x3b\xe6\x78\x73\xe5\xed\xfc\x51\x91\x86\x6d\x3f\xdd\xd6\x1e\x77\x7c\x84\x6f\xb0\xbb\x46\x7f\xc5\x01\xb2\x7b\xf1\x18\xf6\x92\x19\x09\x23\xb8\xc1\x61\xe8\x3a\xe0\x45\x6a\xc7\xe8\xd6\x8e\xd0\xc8\x8e\xc0\x8f\xd6\x67\xd2\x24\xa8\xf3\x65\x19\x4c\x63\x62\xab\xfd\x81\xd1\xc2\xce\x99\xc4\x8b\x6e\x93\x2e\x19\x89\x79\x01\x68\xa4\x14\x80\x7d\x3e\x67\xb8\x99\x7c\x50\xb4\x98\xed\xfa\x49\xc8\x62\xfc\x55\x01\xcc\xc0\x7e\x2d\x0b\x68\x03\x1b\x99\x2a\x95\xf4\xe7\x2c\x92\xfd\x7e\x3e\x92\xfd\xd8\x77\x65\x64\x35\xf2\xa8\xd4\x4c\x2c\xaa\xc9\xc4\xa1\x9e\xcd\xb0\xf5\x47\x64\x28\x02\x2c\x35\x00\xba\xa3\x3d\xdf\x62\x02\xf0\x60\x2a\xb7\x41\x95\xc5\x94\xb8\xcc\x9c\x5a\xec\xb6\x8b\xd6\x16\x72\xa6\xf4\x32\x48\x81\x48\x98\xb8\x11\x3f\x4c\xf9\x4c\x66\x9b\x5c\x7c\x6f\x1c\xc5\xc1\x90\x30\xf9\x59\x98\x70\x7b\xd7\x66\x7a\x8b\xf1\x3d\xf3\x8d\xc8\x4c\xff\xa2\x69\x48\x6f\xc9\xf6\xe5\xba\x2d\x4b\xce\x95\x2a\x13\x6e\x8c\x01\x86\x38\x11\x3b\x1d\x9a\xa7\x85\xdc\xb4\x41\x79\x99\xde\x5b\x27\x15\xa5\xa1\x76\x32\xbb\xee\x14\xec\x53\xbd\x7d\xef\xc9\xf9\xd2\x39\x6a\x5e\x6a\xa0\x22\x65\xdf\x36\x9b\x9e\x7c\x95\xe2\xa7\xf0\x5e\xc8\xf6\x80\x76\x6f\xa1\x25\xfd\xb6\x72\xd7\x93\xad\xd4\x73\x62\x4c\xa9\xbd\x9a\xd1\x2f\x02\x11\x44\x87\x04\x02\xd9\x53\x02\x6b\x25\xb5\x55\xe9\xb9\xf4\x6a\x93\x6b\xa1\x91\x3d\xf5\x02\xdb\x69\x21\x68\x5b\xc5\xae\x13\x0f\x2b\xb0\xe8\x4a\xcd\xc0\x3a\xb7\xc5\xc5\xa0\x21\xca\xce\xbb\x29\x28\x08\x3a\xdd\xc0\x84\x5c\x45\x5b\xc8\x95\xe7\xe3\x85\x07\x15\xdd\xe5\xef\xbb\x9e\x40\x76\x39\xea\xc3\x9d\x78\x16\x0f\x95\xca\x3a\x53\xbc\x62\x94\x98\xda\x59\x68\x73\x73\xc5\x76\xf5\x62\xd6\x0a\x90\x51\x1b\x47\xd1\x55\x56\x32\x2a\xb3\x15\x81\x4a\xd0\x4a\xa7\x4c\x6c\x98\x13\x93\xf1\x66\xa1\x2a\xe9\x85\x25\x4c\xd0\x19\x61\x50\xa0\xb1\x6b\xcc\x92\x67\x23\x80\x3f\x6e\x21\x03\x66\xd8\xfb\x7b\x54\xad\x9a\xa6\xc6\xf6\x9a\x2b\x5c\x4b\xe9\xf1\x51\xbd\xaa\xce\x04\xcf\xd1\x74\x89\x8a\xa2\x03\xca\x78\x43\x61\x78\x85\xf8\x21\xf9\xf8\x9a\x99\x9d\x9b\xe7\xda\x9d\x9b\xdb\x14\xc8\xe6\xac\x1d\x25\x1d\xb6\x26\x54\xfa\x9f\xd4\x1b\x42\xda\x05\x7a\x5e\x53\x3f\x14\x83\x97\x3c\xd7\x63\x97\x0c\x5c\x47\x4e\x43\x1e\x55\xdc\x0e\xf2\x66\x1e\x98\x8e\x59\x10\x73\x31\x33\xd3\x38\x4a\x1c\x3c\xcb\x09\xfc\x00\xa6\xd4\xd9\x7e\x25\x94\x80\x85\xce\xab\x54\x2a\x24\x5f\x8a\x8c\x51\x08\x29\x4a\xae\x51\xcb\x8c\xb4\xa4\xd5\x95\x45\x5f\xb6\x4c\x80\x4f\x00\x13\x21\x89\xac\xcb\x06\x67\x42\x43\xb6\xc9\x50\x2b\xfd\x51\x6e\x90\xec\x72\x88\xd4\x85\x0a\xd9\x0f\x1d\x54\x27\x63\x98\x49\x14\x7f\x7c\x22\x31\xa5\x3e\xce\x09\xc2\xb2\xca\xa1\xbf\xc2\x89\xf1\xae\x2c\xf2\xc3\x4c\x5c\x18\x55\xd7\x28\x00\x31\xb2\xc6\x11\x23\x5f\x45\xc6\x48\x36\xa9\xf5\xe0\x1c\xb0\x0a\x49\x1a\xbf\x14\x0c\x95\xee\x5e\x80\xa6\x31\x58\x11\x6f\x6d\xcf\x7b\x33\x3d\xb6\x43\xd2\xd4\x92\x48\x69\xb4\xe3\x45\xca\x8d\x8c\x2f\x93\x8a\x4f\x71\x22\x5d\xd0\x02\xb6\xd8\xa3\xce\x51\xba\xa5\x5e\xa4\x7c\xd5\xf9\x57\x89\x04\x1a\xdf\xaa\xa1\xeb\x93\xa2\xff\x69\x8f\x44\xaa\xe4\x55\xfe\xbe\x3b\x4d\x99\xb3\xeb\x0e\xc8\x73\x37\xb6\x27\xd2\xf1\x17\x45\xab\xd4\xa4\x0a\x45\x6b\x54\x9a\x8a\xad\x50\xa5\x21\xfa\x24\x16\x03\x50\x51\x07\xfc\x85\x66\x10\x9e\x5f\x68\x07\xfb\x0a\x1d\x30\x78\xb5\xcd\xc4\x71\x71\x6e\x93\xcf\x67\x74\x4f\x23\x46\xd4\xd4\x54\x25\xb3\x26\xa7\x5c\x1c\xb2\xf2\xa5\xcd\x8c\x12\xa6\xe7\x22\xf5\x7b\x95\xf4\x79\x0b\xd5\xf5\x5a\x34\x91\x8a\x4e\x07\x55\x47\x64\x59\x18\xb2\x10\x23\x07\xbe\x53\x2d\x53\x2d\xa8\x08\x0d\xd3\x74\x97\x1e\x05\x4c\xaf\x5b\x69\x9c\x04\x55\xa2\xf8\x90\x68\x21\xe1\xb8\x27\x09\x71\x4b\x7e\xb0\xa4\xb1\xd1\x92\x7e\x5b\x20\x8b\x2d\xf8\xaf\xbc\x60\x8a\x43\x7d\xe0\x99\x82\x7a\x7f\xeb\x95\xce\xdd\x3d\xd4\x57\xe2\xc0\x77\x0c\x75\x43\xf6\x8b\x56\xa0\x00\x06\x55\x3f\x84\xf2\xb5\x77\xc1\x78\x4b\x06\xc9\x5d\x76\x87\x35\xaa\xd1\xc5\xdc\x8c\xcd\x0d\x96\xc3\x45\xdf\x49\xe2\xb4\x85\x1a\x14\xf8\xac\x9e\x0e\x59\x92\xef\x53\x10\x15\x85\x44\x53\x65\xed\x32\xc4\xfd\x26\xc4\x0e\x02\x79\x3d\xf0\x9d\xec\xbc\x14\x31\xe7\xe5\x66\x76\xea\xc9\x6c\x42\x8a\x64\x5a\xf5\xae\x3a\x43\x37\x75\x33\x55\xea\xe0\x17\x92\xe5\x3a\x29\x48\x93\x1a\x4d\xa9\x9f\xd4\xf8\xce\x27\x24\xa1\xb3\x4a\x52\x43\xf0\x0d\xa4\x7c\x64\xcf\xb7\xf9\x07\xed\xf9\x36\xff\x98\xbf\x1a\xe1\x29\xb8\x5f\x93\x54\x6c\xe4\xfe\x89\x69\x5c\xd1\xb9\x4f\x58\xd1\x2b\x54\x85\x32\xc1\xaf\x80\xd2\xae\xca\x55\xa2\x48\x0c\xa8\x83\x0c\x31\x5f\x9e\x5f\x98\xb5\xc8\x73\x7b\x58\xdd\x2e\x25\x8d\xc1\x7c\x18\xa1\x91\x5e\x95\x09\x15\x94\xbe\x8c\x7a\x5e\xe9\xf1\x6d\xc0\x53\x00\x5b\x01\x8a\x30\x77\x10\xa2\xe6\x39\xab\xeb\x05\x99\x35\xe4\xd2\x59\x30\x64\xe0\x56\x17\x0d\x99\xfa\x61\x92\x54\x2f\x3b\xa8\x59\x86\x39\xfd\xac\x36\x00\xf6\x86\x76\x3c\x38\x05\xff\x31\xe6\x69\x3d\xf6\xe2\xf3\xc6\x85\xe4\x9c\x86\xb6\x19\x33\xe7\x75\xf9\xb5\x49\xdd\x3f\x65\xce\x58\x64\xe3\xac\x4f\x29\x0d\x8e\xac\x39\xcd\xa3\x95\xe9\x74\xd4\x18\xcd\x9c\x90\x90\x06\xd2\xcd\xac\x6f\x5f\xa1\x09\x6a\xa1\x69\x72\xa8\x4b\x69\xe7\x25\xe5\x31\x95\xe4\x53\xd7\xdc\x63\xb2\x59\xe5\x16\x11\x9b\xc5\x88\xc4\xb3\x62\x19\x68\x75\x0c\xdc\x41\x38\x0b\xe1\x56\xc1\xd5\xd8\x0e\x6d\x3f\xc6\xd4\xcd\x3c\xb6\x5d\x8f\xbc\xed\x62\xc4\x30\xec\xb0\xa3\x6e\xb3\x92\x04\x6c\x81\x78\xce\xc2\x63\x5f\xb4\x33\x49\xde\x06\x7e\x3c\x2b\x7c\xcb\x92\xdb\x42\xa4\x98\x64\x57\x28\x79\xca\x32\xc3\xc6\xda\x6a\x07\x99\x54\x4b\x69\xac\x6d\x89\xc1\x9d\x65\x83\xaa\x4c\xe6\x4c\x49\xd9\x97\x46\x81\x70\xb3\x14\x1c\xef\xa0\x26\x0d\x87\x2a\x85\x72\x63\x23\x85\x37\x3c\xe9\x09\xda\x21\xea\x19\x91\xed\x7a\xea\x4e\xb2\xd8\x60\x6e\x09\x56\xd8\x6a\x3e\xc5\xc6\xb6\xf8\xfe\x94\x32\xd4\x4a\x27\xd1\x6f\x3e\x53\xf8\xd1\x33\xc2\xfb\x20\xb8\x4d\xd7\x33\xd9\xcd\xdf\xce\xa9\x26\x8c\x0d\x7a\x3f\x13\xee\xa8\xe9\x73\x17\x35\x12\xec\x1a\xa4\x82\xaa\x27\x1c\xe9\xa2\xa9\xe7\xb1\x66\x28\xd4\xb7\xa4\x29\xcf\x94\x3d\xc9\xb2\x7d\xa1\xeb\x04\xb2\xbe\x18\x04\xb7\xfc\x36\x9c\x2e\x2c\x9f\x12\xfc\x28\x18\xfb\x74\x31\x26\xc6\x2d\x7a\xc5\xe3\xd0\xa3\x16\xf9\xc5\x29\xe8\xae\x4c\x43\x76\x7e\x57\x5a\xe9\x1c\xb0\x7d\x84\xe2\x3f\x77\x53\x83\xb6\xb7\xfe\x01\x9b\xbf\x8f\xab\xb2\x12\xad\x63\xb8\xf6\x0a\x87\xaa\x2a\x34\xd4\xf2\x53\x25\x86\x30\x76\xa5\x0c\x60\xca\xbf\x32\x74\xd8\xa7\x28\x2d\xd6\x1a\xa9\x81\x4b\xc3\xbc\x4f\x14\xb9\x61\x46\x6a\x0a\x44\x3b\x19\xbf\x84\x8b\x1f\x60\xec\x6a\x38\xb8\x92\x07\x6e\xfa\xbb\x7c\x14\x20\xcb\x61\x7a\x9e\x9a\x83\x49\x99\xb1\x0c\x3b\xaa\xb0\xa7\x54\x45\x4a\x4d\xd0\xcc\x9a\xc1\x98\x69\xcc\x8c\x8e\x48\x67\xdd\xd2\x64\xcd\x57\x10\x59\xe5\xc0\xa7\xe9\x5c\xba\x46\x54\x56\x37\xb8\x19\xad\x20\x1a\xae\xbc\x5a\x60\x2b\x14\x66\xb1\xe9\x17\x35\x9a\x15\x0d\x65\x9f\x16\x33\xc7\x2a\xe6\x20\x37\x66\xa1\xbc\xd4\x24\x56\xfd\x6e\xfe\xa2\x65\xb7\xdc\xa2\x65\xb7\xec\xa2\x65\xb7\xdc\xa2\xa5\xc0\xf1\x3e\xb5\x68\xd9\x9d\xbd\x68\xd9\xfd\x2b\x2c\x5a\xbe\xec\x52\xa4\xfc\x92\xe9\x71\xd1\xf2\x57\x59\xb4\x28\x56\x0d\xb3\x7b\x88\x6d\xf3\x92\xda\x38\xdb\xdb\x8f\x86\xcd\x72\x86\x0d\x6b\xd3\xb9\xcd\x9b\xbc\x69\x75\xe5\xc6\xcd\xcb\x47\xe3\x66\x7d\xc6\x0d\x1d\x90\xb9\x0c\xfd\x97\x98\x36\x2a\xa2\xbf\xb2\x63\x5e\x8c\xec\xdf\x28\x46\xf6\x4f\x03\xfb\x2b\x94\x05\xc0\xbf\x82\xef\xaf\x34\xd1\xbc\x27\x54\x74\xd4\x1f\x9f\x1c\x9c\x1e\x7c\x38\x7b\x7d\x76\x78\xf4\xe1\xf2\xf5\xd9\xd9\xc9\xe1\x9b\x9f\xcf\x0e\x4e\xe1\x2c\x79\x6e\x92\xf4\x04\xf6\xe0\x97\x83\x0f\x67\x19\x5a\xa5\x63\x11\xe8\x41\x0f\xcb\x87\x00\xc8\xcd\x9f\x40\x72\x17\x02\xab\x97\xc8\x3f\x13\xec\xbf\x04\x8d\xd9\x08\xff\x25\x88\x28\xa7\x29\x0b\x50\x02\x20\x6e\xe3\x1c\x6c\x3d\x4b\x58\x76\x16\xbb\xad\x62\xf1\x0b\x29\x14\x9a\x7d\x67\x87\x62\xe9\x32\xeb\x39\xe8\xa3\xe8\xe6\x6a\x03\x25\x87\x3c\x8b\xf4\xa9\x14\x0e\x60\xd9\x5e\x5d\xbe\x5f\x57\xd3\xb3\x2b\xe8\xdb\x0d\xee\xfd\x4f\xef\x26\x2f\xda\xb3\xb3\x20\xd6\x73\x73\x77\x83\xc0\x2b\x1a\xfe\xb9\x19\x01\x1e\x7e\x21\x7e\xc1\x70\x59\x28\x2b\xa6\x5e\x34\x54\x48\xb9\x17\xca\xb7\xd4\x68\xb4\xee\x17\xa2\xc3\xbf\x65\xfe\xe9\xbd\xb5\x85\xb8\x87\xf2\x37\x36\x90\x72\x12\xbc\xd4\x48\x64\x47\xd5\x0b\xd0\x10\xd1\x24\x38\xee\xc7\x92\x9c\xcc\x8e\x7c\x53\x62\xda\x2b\x1d\x49\xa2\x78\x78\x6e\xa4\x5d\x27\x97\x22\xc5\xcf\xb5\xbf\x80\xc0\xce\x0e\x38\x32\x73\xe2\x53\xdd\x3a\xac\xc4\xcf\x03\xb6\xaa\x34\xee\x2e\x17\xe6\x85\xb9\xf1\x20\x19\x6d\x8b\x45\x8f\x80\x07\x31\x71\xde\xd1\x3c\x34\x47\x92\x3e\x49\x4d\xfd\xec\xd8\x04\x2c\x6f\xc8\x04\x7d\x0e\x6f\xa4\x98\x02\x62\x26\x4f\x72\xf1\xdb\x5e\x6c\x4c\x9c\x5f\xc0\x50\xcb\x86\xa6\x48\x14\x10\x0f\xeb\x9f\xa8\x54\xfe\x86\xce\x4a\xfc\x89\x0f\x79\x8a\xdb\x97\x1e\xc0\xcf\x24\x1e\xe8\x6a\x3e\x08\xf9\xd6\x54\xd0\xe7\x38\x51\xc9\x30\xdb\x57\x85\x4a\xe9\x90\x24\x0a\x06\x05\x7b\x5f\x30\xf6\x45\x06\xe4\x2e\x05\x1b\xdf\x5c\x2a\x06\x86\x0a\x15\xcf\x30\x49\xc1\xf2\x2f\xc0\x3e\x97\x52\x35\x49\x32\x68\x80\x60\xc4\x42\x38\xbd\x63\xbb\x05\x34\x81\x9a\xfc\x5d\x30\xcc\xc3\x8e\xfe\x5e\xa4\x84\x90\xc8\x51\x1e\x74\xf2\x0b\x91\xee\x9d\x1d\x0d\xba\x81\x4d\x6f\xc6\xe8\x92\x52\x80\x62\x35\x6d\x11\xc3\x22\x91\xd9\x56\xe1\x31\x75\xa9\x19\xb6\x2a\x5b\x59\x05\xdd\x3f\xc8\x62\x35\xe8\xfe\x51\xbb\xbc\xc4\xd1\x4f\xd0\xfe\xe8\x15\xbc\x27\x43\x86\x83\x36\xc0\x8b\x07\x8a\xc7\x08\x62\x36\xc4\xb0\xd1\x13\x03\x2c\x19\x2b\xbe\x46\xbe\xbd\x0d\x46\x53\x30\x68\x51\xb3\xde\x78\x0e\x12\x79\x15\x6c\xe3\x78\x80\x43\x3c\x1e\xa2\xd7\xe3\x78\x10\x84\x11\xa5\xe2\x46\xa8\xef\x7a\x18\xb9\x11\x1a\x49\xc1\x29\xe4\xf4\x9e\xdb\x0d\xed\x70\x4a\x48\xb3\x92\x75\x9f\x09\x85\x7e\x88\x31\x8a\x82\x7e\x7c\x6b\x87\xb8\x85\xa6\xc1\x18\x42\x6e\x84\xd8\x71\x23\x76\xb3\x0a\xb9\x31\x8f\x71\x32\x0c\x1c\xb7\x3f\x25\x24\xdd\x18\x8d\x93\xeb\x9a\x38\x1c\x46\x9c\x8f\x7f\x7e\xf8\x19\xbd\xc7\x51\x84\x43\x44\xd5\xb8\x87\x8e\xc7\x5d\xcf\xed\xa1\xf7\x6e\x0f\xfb\x11\x46\x76\x84\x46\xe4\x4d\x34\xc0\x0e\xea\x02\x39\x92\xf1\x47\xc2\xca\x29\x63\x05\xfd\x18\x8c\x7d\x87\xf9\x5f\x31\x9c\xd0\x1b\x1c\x02\x76\xe8\x2e\x2f\x8a\x11\xb4\x50\x10\x12\x22\x86\x1d\x93\x0a\x84\xec\xfa\xae\x89\x6c\x7f\x8a\x3c\x3b\x4e\xb2\x96\x68\x90\xa4\xde\x70\x59\x94\x14\x33\x08\x46\x98\xa2\x16\xba\x31\xba\x75\x3d\x0f\x75\x31\x1a\x47\xb8\x3f\xf6\x2c\x42\xad\x3b\x8e\xd1\xaf\x87\x67\xff\x3a\xfa\xf9\x0c\xbd\xfe\xf0\x11\xfd\xfa\xfa\xe4\xe4\xf5\x87\xb3\x8f\x6d\x11\x8f\x05\xdf\x60\x4a\xca\x1d\x8e\x3c\x08\xd4\x42\x66\x71\x3f\x9e\xa2\xa0\x4f\x28\xfc\x74\x70\xf2\xf6\x5f\xaf\x3f\x9c\xbd\x7e\x73\xf8\xfe\xf0\xec\x23\xd1\x43\x3f\x1e\x9e\x7d\x38\x38\x3d\x45\x3f\x1e\x9d\xa0\xd7\xe8\xf8\xf5\xc9\xd9\xe1\xdb\x9f\xdf\xbf\x3e\x41\xc7\x3f\x9f\x1c\x1f\x9d\x1e\xd4\xd0\x29\x75\x5e\x20\xf9\x67\xb7\x79\x1f\x7a\x2f\xc4\xc8\xc1\xb1\xed\x7a\x11\x6f\x89\x8f\xc1\x98\xa1\x4c\xa2\x81\x7d\x83\x51\x88\x7b\xd8\xbd\xc1\x0e\xb2\x51\x2f\x18\x4d\x4b\x77\x2a\xa1\x65\x7b\x81\x7f\x45\xa3\xc6\xe4\x09\x24\x3a\xec\x23\x3f\x88\x2d\x14\x61\x8c\x7e\x18\xc4\xf1\xa8\xb5\xb3\x73\x7b\x7b\x5b\xbb\xf2\xc7\xb5\x20\xbc\xda\xf1\x28\xb9\x68\xe7\x65\x8d\x0e\xe6\x18\x46\x4d\x07\x19\x75\x8b\x2b\x0b\xe6\xa2\xfe\xd3\xd8\x85\x21\x65\xb2\x45\xda\xc8\xf6\x70\x1c\xe3\x96\x7c\x43\x7b\x3a\x22\x33\x88\x63\x87\xd7\x55\xb6\x4d\x02\xc7\xf7\x3b\x3b\x88\x62\x16\xd2\xf8\x29\xb7\x83\xc0\x53\x46\x24\x14\xc6\x75\x58\x6d\x30\x75\x42\x3b\xc6\x26\x53\x72\x22\x2e\x93\xce\x55\x9e\xb3\xc8\x99\x3b\x0e\x83\x1b\xd7\xe1\xab\xaf\x3b\x5a\x9d\x16\xab\x15\x73\x51\x2f\x26\x2b\x69\x33\x9e\xc2\xa2\x60\xbb\x1b\xa6\x85\x9c\xa0\x07\x50\xa4\xb5\x2b\x1c\xb3\x1c\x6f\xa6\x87\x8e\x51\x15\xb5\xa9\x9a\x9a\x79\x64\x77\x85\xf3\xc8\xce\xd3\xa7\xe8\x1f\xac\xdf\x10\xec\xba\xa0\x9b\xc6\x7e\xad\x51\x6b\x6c\xc0\xad\x6e\x9b\x82\x4c\x3b\x63\x28\xa5\x36\x74\xfd\xda\x1f\x11\x8b\xb3\x92\xe8\x3d\xa3\x67\x12\xdd\xb7\xbb\x3d\xa2\xb7\x3b\x2d\xf4\xa3\xdd\xc3\xdd\x20\xb8\xb6\xd0\xa1\xdf\xe3\x91\x7e\x40\xfd\x31\x7c\xf8\x5e\xe0\x60\x8a\x15\x0a\x65\x3b\x92\x46\xfa\xe9\xf0\x8c\xbf\x46\x7d\xa2\x49\xd8\x58\x26\x24\xde\x1f\xbe\x3d\xf8\x70\x7a\xc0\x94\x28\x1d\x97\x61\x10\xc4\xc8\x71\x43\xdc\x8b\x83\x90\x49\x7d\x52\x50\x1c\x62\x88\xe4\x43\x63\xbf\x0c\x3b\xba\xf9\xe7\xc5\xbe\x69\xf9\xda\x2f\x8d\x46\xc3\xb4\x46\xda\x4f\x7b\x64\x1e\x14\x73\xcf\x7f\x0c\xdb\xbc\xeb\x07\x21\x9c\x03\x74\x3b\x69\x88\xfc\xed\x86\x85\x3b\x95\x9f\x5c\x9f\xc6\x7a\xa2\x2d\x8d\x01\xb0\xe3\x6f\x95\x2d\x7b\xab\xd2\x46\x37\x6e\xe4\xc6\x88\x0d\xab\x3e\x6b\xbf\xda\x95\x1b\x0f\xc6\xdd\x9a\x1b\xec\x40\x67\xec\x38\x41\x2f\xda\x81\x8c\xdb\x0e\x26\x8d\x18\xd6\x06\xf1\xd0\x7b\xe5\xfa\x37\x76\xe8\xda\x7e\xfc\xfb\x64\xd7\xa9\x6c\xd9\x96\xd3\xa9\xb7\x9d\x1f\xba\x6d\x67\x6b\xcb\xc4\x5b\x9d\xca\xef\x93\xe6\xbe\x1d\x5e\x45\xe7\x17\x34\x05\xf6\x49\xee\x9f\x4f\x0e\xc5\xa6\xa1\x91\x20\xf6\x3b\x5b\x8d\x0b\xb3\xdd\xed\x50\x04\x68\xbc\x55\x11\x53\x5f\x7f\xec\x79\x68\x88\xa3\xc8\xbe\x22\x26\x23\x51\xa5\xf0\xde\x0f\xfc\xed\x21\xaf\x9e\x83\x6f\x10\xf6\x6f\xdc\x30\xf0\x21\x0e\x12\xc9\x0c\x19\x81\xf1\x88\xcc\x48\xc8\x76\x1c\x97\xb4\x9c\xed\xa1\x01\xf6\x46\xfd\xb1\x47\x14\xab\xef\xfa\x57\x51\xad\x62\xb6\xbb\x35\xdf\x1e\xe2\x4e\xe5\x90\xd7\x0b\xfd\xe2\x06\x1e\xcc\x29\x95\x76\xb7\xd6\x0f\xed\x21\x8e\xce\x82\xe3\x60\xd4\x69\xb4\x29\x6c\x75\xb7\xfd\x40\xe3\xfb\x74\xee\xdc\xe8\xa7\x60\xec\xc7\xd8\x69\x89\x01\x62\xde\x51\x03\xe0\x49\xe3\xc1\xc2\xfe\x7f\xc6\x78\x8c\x7f\x0c\xc2\x1e\xa6\xb8\xbc\x72\x3a\xf1\xfd\x04\x8f\x3c\xbb\x47\x8c\xf4\x9c\x04\xa7\x38\xce\x7e\x7c\x68\x0b\xa1\x88\x0d\xdb\xea\x5a\xd8\xbc\x4b\xae\x87\x74\xec\x36\x3c\xc0\x19\xc8\x24\xee\x74\xdb\xec\xd6\x4a\x3f\xea\xf8\xf4\x37\x8d\x81\x17\x76\xf0\xfd\x7d\xf8\x20\x63\xbc\xbb\x91\x8a\x73\xd0\xb9\x7b\x68\xcb\xdf\x23\xc6\x4e\x47\xb0\x63\x5b\x5d\xf3\x8e\x03\x8f\x3f\xe9\x74\x18\x1c\xb7\xbd\xb9\x99\xc0\x81\x2b\xaf\x89\x6e\x7a\xd2\xb1\x5f\xfd\xc7\xa8\xbc\x78\x56\x31\x5b\xec\xac\x4f\xe6\xab\x96\xaa\x3c\xc5\x55\x26\x15\xad\x70\x06\x2a\xa6\xca\x58\x3f\x69\x68\x89\x37\xd6\x2c\x29\xb2\x52\xa7\x70\xca\x15\x29\x3f\x21\x9d\x8c\xba\xf1\xf2\x0d\x2c\x68\xdd\x90\xce\xbb\x49\xb8\xee\x48\x35\x68\x13\xb9\xba\xed\x8c\xa5\xaf\x3e\xbe\x45\x37\xed\xdb\x9a\x04\x41\xde\x19\xb7\x87\xc6\xad\x25\xe5\x33\xdb\xb7\x35\x37\xa2\x30\xbb\x4a\xcf\x3d\xa9\x27\x52\x32\x59\xbe\x12\x84\xbd\x69\x67\x92\x61\x6f\xaa\xb0\x37\x69\x0f\x8d\xa9\xca\xde\xb4\x36\xf6\x23\xc0\x43\xbf\x74\xa3\xd7\xd1\xd4\xef\x65\x19\x9d\xb2\x0b\x4f\x9d\xcc\x58\x92\x2e\x1d\x8a\x10\xec\x0f\x6d\x18\x84\x7f\x76\xee\x7a\xe3\x30\xc4\x7e\xdc\x22\x32\xf5\x60\xbd\xee\xcc\x88\x59\x60\xbd\xe9\x24\x42\xd9\x11\x42\x79\x3a\x1d\x76\x03\x6f\x73\x93\xfe\x3d\x27\xb2\x50\xb9\x48\x3d\x1a\x15\x3a\x53\xb1\x2d\xbb\x8a\x79\x7f\xbf\x5f\x6f\xd4\x77\xad\xb7\x9d\xbb\x6b\x3c\x6d\x3d\xa9\x5b\x21\xee\x93\x3f\x97\x97\x11\xf6\xf8\x2f\x98\x20\x5a\x4f\xea\xb2\x44\xbd\xe3\x9d\x01\x41\x3b\xac\x5e\xe7\xee\xc1\x1a\x74\x48\x15\xac\x6b\xf8\xd3\x76\xfb\x06\x1d\x25\x5d\x93\xe8\x7b\x98\x9d\xe8\x30\x79\xd2\xe9\x74\x49\x1f\x6d\x6e\x1a\xd7\xf4\x97\x69\x49\x5f\xae\xf1\x74\x73\xd3\x18\x74\x2a\x95\x2d\x78\x30\xad\xae\xf9\x9a\x46\x6a\xe8\x5a\x8e\xb9\xb9\xf9\xe4\x6d\xaa\x49\x0c\xf2\xd6\xe8\x9d\x3b\x17\x9d\xee\xb9\x73\x61\x82\x18\xf6\xb3\x93\x4b\x93\x30\xd5\xe8\x74\x3a\x7d\xb3\x27\x3a\xa2\x83\xdb\xec\xd2\x89\xd1\xf8\xa1\x9f\x4c\x4e\x57\x1d\x00\x63\x31\xfa\xa6\xe5\x75\xea\x6d\xef\x87\x7e\xdb\xdb\xda\x32\xaf\xce\xbd\x8b\x84\xf2\xb9\xb7\xd5\xbc\x68\x4b\xc4\xae\x1e\xdc\xbe\x61\x6f\x6e\xda\xca\xd6\x44\xd2\x02\xfd\x8e\xfa\xc5\xea\x9b\xb4\xea\x9d\x4e\x87\x54\x80\xd7\xa3\x0f\xf5\xa0\xe2\x73\xf7\xf7\xbf\xd3\x4e\x6e\xbd\xb1\xc0\xda\xb3\x2d\xd2\x5b\x03\xe8\xac\x6b\x0b\xe4\xaa\xd5\xb3\x2e\x83\x5b\x1f\x87\xad\x3f\x6b\x4c\xa0\x1e\x92\x31\x7b\x40\xb4\x08\x25\xc6\xb5\x5c\x27\xab\xce\x3a\xc0\x37\x2f\xac\xd3\xe9\xbc\xa1\x13\xc5\x8f\x25\x04\xae\xe6\xc6\xec\xbe\xef\x3f\x57\x2f\x9e\xff\x5a\x9a\x24\x31\xf6\x6c\x8f\x53\xdc\x4f\x94\x0a\x8e\x7a\xf6\x08\x93\xe6\xa1\x06\xc9\x5d\x05\xa6\xfd\x16\xfc\xa9\x57\xac\x4a\x8b\xfd\x6e\x56\x1e\x58\x77\x54\xfe\x5e\xd9\x32\x2a\x95\x2d\xdb\xac\x85\x74\xe6\x33\x76\xce\x3b\xad\x8b\x9d\x2b\x4b\x56\xda\x6c\xe8\x77\xcf\xed\x8b\x07\x13\x34\xcf\x61\x67\xe7\xf7\x9d\xad\x9d\x2b\xeb\xdf\x9d\xf3\x0b\x69\x2c\xfd\x3f\x3a\x96\x2c\xc7\xbc\x73\xfb\xc6\xbf\xf9\x05\x58\xe0\xa8\xd7\xf9\x77\x6d\x14\x8c\x0c\xb3\xdd\xab\xd1\xb3\xd4\x8e\xdd\xee\x91\x61\x71\x1c\xe2\xbe\x3b\xe9\x74\xdb\x3d\xd8\x0c\xec\x60\x22\x86\x4c\x0f\x3a\xf0\x7b\xec\xc7\x9d\x7a\x9b\xc7\xdb\x78\x60\xc2\x44\xa9\x50\x19\xa2\x34\x5a\x5d\x60\xbc\x85\x2d\x96\xbf\xe5\x58\x90\xbb\x55\x97\x64\xe8\x3d\xa9\x94\xcd\x99\x80\x21\x6e\x4b\x7c\xb0\x17\xc0\x0a\xfb\xcd\xb9\x11\x8f\x94\xa1\x46\xfd\x25\xaf\xe3\xe6\xe6\xbf\x6b\xa3\x71\x34\x30\x6c\xf3\x21\x69\x8f\x9f\x92\xf6\xa0\x4d\xc0\x05\x95\x0c\xdf\x0a\x31\x80\xfb\xae\x8f\x1d\x22\x0a\xbd\xfb\xfb\x4a\x37\x08\x3c\x6c\x83\x64\xf4\x4c\x5b\x51\x3e\x9d\x4e\xc7\xbe\xbf\xaf\xd0\x3d\x5c\x9e\x9e\xee\x5b\xf2\xa7\x64\x38\xf4\x52\xd2\xff\xcf\xc2\xaf\xff\x32\xf9\x89\xb5\xe1\x90\xb9\x97\xa4\xe9\xbe\xaa\xd4\x2a\x5b\x1f\x0c\xdb\xaa\x9b\xad\xae\x69\x35\x40\x11\x0d\x3a\xf5\x76\xb7\x93\x24\x68\x75\xb7\x2a\xad\x0a\x61\x11\x14\x4c\xcd\x8d\xa8\xa2\xb1\x4d\x93\xeb\x9e\xeb\x4e\xbd\x7d\xfd\x83\xcd\xdd\xa1\xae\xb7\xb6\xcc\xbb\x5e\xc7\x3e\xbf\xbe\x60\xaa\xad\xbb\xf5\xc1\xe8\x59\xd7\x66\x7b\xb0\xd5\xf9\xc9\xe8\x59\x7d\x68\xae\x07\xae\xc8\xfa\x9d\x1f\x37\x37\xed\xf3\x1f\x2f\xee\xef\xed\xf3\xca\x3f\xfe\xc1\x07\x67\xe5\xc2\xd2\x8d\xa4\x3e\x14\x6c\x77\xfa\x54\xcb\xda\xa6\x45\x18\x78\x62\xf4\x3a\x76\xcd\x87\xd0\xfa\x66\xcd\x09\x7c\xdc\x36\x7b\x9d\x1e\x75\x7f\xb1\x04\x0f\x5b\x5b\xa6\xa5\x70\x01\xea\x54\x6d\x39\x03\x13\x6d\x6e\x5b\xff\x31\x2a\xbb\x8d\x8a\x55\x39\x67\xd1\x10\xe8\x54\x77\x41\x52\x6d\xe0\x57\x2c\x0f\x5d\x5d\x5f\xe3\x69\x84\xee\x2a\x5b\x6c\x36\x24\x8f\x86\x6d\xd6\xfe\x08\x5c\xdf\xa8\x58\xa8\x62\x6e\x55\x1e\x2a\x2d\x6c\x55\x2a\x26\xd7\x93\x68\x90\x48\xeb\x07\x6a\xd3\x95\xd2\x79\xcc\x98\x23\x65\xbc\xe2\xfa\x00\x26\x9e\x56\xb7\x16\x07\xd4\x2b\xc7\xd8\xdd\x37\x13\xea\x47\x94\x3a\x15\x77\xd6\x68\x5c\xdc\xad\xae\xc5\x64\x7d\x6b\x4b\x96\xea\x63\x65\xc6\xec\xf0\x91\x64\xf5\x3a\xd2\x30\x6a\xdb\x9d\xd9\x44\xdb\x69\xb9\x79\xf5\x3f\x86\x6d\x39\x16\xb6\x46\xb5\x78\x60\xc7\x2c\x6c\xea\x6b\x36\x49\x99\x2d\x56\xc1\xcd\x4d\x83\x4c\x04\x9b\x9b\x46\xb7\xd3\xdb\x32\x9e\x40\xb9\xf7\xf7\xdd\xcd\x4d\x98\x67\xc9\x60\x81\x36\xa8\x54\x5a\xa0\xdf\xa0\x0d\x84\x8e\x3b\xb4\x2a\x7f\x27\x8b\xa3\x1d\xd2\xf4\xe4\x3f\xd8\xb2\x3b\xd9\xa9\xa9\x06\x31\x67\xc8\xfc\xd4\x85\xf9\x89\xd4\xb3\xcf\xe6\x28\x9b\x01\x2f\xb0\x99\xca\xae\xd1\x1f\x0f\xa6\xe5\x70\x35\x20\x35\xf2\xff\x70\x35\x60\xf5\x68\xa3\x11\x93\xa0\x4d\xeb\x82\xc1\x42\x20\x5c\xe2\x7c\x0e\xdb\xdd\xce\xff\x33\xba\xd6\x00\x28\xb4\xa9\x3e\xb0\xef\xef\x89\x7a\xa9\x54\xac\x63\xab\x6b\xb6\xdf\x1b\x5d\xf3\x61\xd9\xc9\xa5\x1f\xda\x57\x74\xc2\xa2\x36\xdd\x49\xe7\xee\x2d\x0f\x15\x7e\x37\xb4\x47\x2d\x79\x9d\x41\x24\x40\x68\x27\x9b\x2b\x11\xbb\x4d\xa5\xe2\xfc\xa2\x4d\xfb\x12\x2c\x29\x92\x98\xcb\xb6\xf3\x60\xf5\x83\xf0\xc0\xee\x0d\x4a\x91\x23\x55\x07\x1a\x09\xa1\x74\x03\x1c\x89\x06\x60\xda\x5e\x33\x7b\xb1\x3c\xaf\xea\x2d\x96\x49\x91\xb0\x0f\xbc\x00\xf3\xc1\x8a\x03\x90\x46\x85\x08\x9d\x52\x59\x9d\xba\x94\x15\xbd\x88\xf2\x5a\x76\x1f\xac\xc0\xf7\x54\x2a\x44\x66\x5f\x51\x23\xa9\xf5\x1f\xa3\xd2\xd8\xdb\xad\x88\xf4\xf6\xc3\x83\x25\x8c\xf0\x56\x6c\x91\x25\x44\xf2\x3c\xb6\x84\xd5\x0e\x36\x7b\xf2\x65\x62\x29\x1b\x50\xad\x77\x96\x0c\xca\x98\x69\x61\xda\x39\x43\xe3\xee\xc1\xb2\x39\xb8\x2c\x1b\xb7\xd6\xa0\x43\x45\x7c\xe3\xba\xc3\x05\x5a\xb6\x7d\xef\x32\x36\xef\x80\xfe\xb2\xae\x3b\xc2\x54\x33\xdb\x19\xfb\xb7\x97\xd8\xbf\x84\x1c\x1d\x57\x64\x0e\x82\x25\x81\x62\x5c\x32\x6b\x37\xfb\xa5\x4d\xd4\xfa\x15\x31\x3b\x25\x0b\xfa\x4a\x6b\x41\x93\xb7\x86\x73\x7e\x75\xd1\x11\xe6\x68\xf7\xfc\xea\x62\x73\x53\x30\xd6\x7f\xd5\x3f\xbf\xba\x68\x91\xb7\xd4\x9c\xb9\x2a\x30\xb0\xaf\x4c\x47\x6f\x60\x5f\x99\x77\x7d\x66\x58\x5f\x99\x6d\x3e\xdf\x51\x03\xfb\x0a\x0c\xec\xbe\xc6\xc0\x96\x88\xf5\x1f\xf2\x8c\xe2\x44\xf3\xf4\x40\xf3\x0c\x98\xd6\x71\xb8\xbe\xb9\x7e\x78\x60\xdd\xfe\xa3\x0d\x7b\x60\x1a\x61\x7d\x57\xeb\xba\xbe\x43\x87\x8e\x6d\xb6\xbb\x40\xb4\x63\x4b\xf2\xa9\x02\x83\xb6\x0e\xac\x0d\xb6\xf1\xde\xaa\xd0\x1d\xc1\x8a\x75\x79\x79\x7a\xf0\xf6\xe4\xe0\xec\xf2\xf0\xc3\xd9\xc1\xc9\x87\xd7\xef\x4f\x2f\xdf\x1d\x5d\x7e\x38\x3a\xbb\xfc\xf9\xf4\xe0\xf2\xe8\xe4\xf2\xe3\xd1\xcf\x97\xbf\x1e\xbe\x7f\x7f\xf9\xe6\xe0\xf2\xc7\xc3\x93\x83\x77\x2d\x06\xcd\x48\xc5\xe1\x88\x1a\xf2\x16\x0d\x39\xd9\x1a\x3e\x3c\x58\xa7\x7c\x59\xd8\x0f\x31\xfe\x13\x1b\x77\xfc\xfc\xe5\xe4\xc1\xb4\xce\x3a\xa7\x9b\x9b\x27\xf7\xf7\xa7\x6d\x35\x36\x73\xe7\xec\xbc\xc2\xd2\x55\x2e\x5e\xc9\x0f\xad\x33\x4d\xbc\xe6\xbd\x95\x6e\x98\x22\x76\x2a\x8c\x7e\x79\x7d\x82\x0e\x3f\xfc\xfb\xe0\xed\xd9\xe1\xd1\x07\xf4\x74\x27\xa1\x3d\x0a\x83\x1e\x86\x80\x6c\x65\xf6\x57\x1d\x7c\x83\xbd\x60\x04\x3b\xc1\xdf\xec\xe6\xea\xc6\xc6\x06\x0b\xe2\x48\x6a\x5e\xc3\xfe\x4d\xed\xc3\xd1\xbb\x83\xcb\x83\x0f\xbf\xd0\xf0\x73\xc9\x2e\x72\x85\xba\x47\x26\xcd\x45\x9e\xab\x49\x2b\x57\xf9\x51\x20\x8b\x4c\xaa\x3f\x33\x7c\xb1\xcf\x66\x25\xb1\xf3\x99\x97\xf0\x39\x4b\x88\x87\xa3\x78\x4a\xa5\x2d\xef\xc8\xb4\xd1\x60\x69\xd9\x56\x64\x6e\xba\xa6\x4c\x93\x3b\x60\xe7\xa4\x86\x8d\x62\x30\xf8\x07\x98\x02\x90\x09\x47\x4b\x6d\xec\xdf\x3d\x76\xca\x71\x76\xf4\xee\xa8\x45\x9b\x9b\xb4\x38\x0d\xba\x85\xba\xb8\x67\x93\xb6\x72\x63\x74\x85\xe3\x88\x85\x8b\xc5\x0e\x72\xc6\xc4\x9e\x43\xdd\xb1\xeb\x39\xec\xfc\x05\x04\xee\x17\x76\xf2\xd6\x41\x55\x2a\x79\xd5\xb6\x08\x31\xf7\xeb\xeb\x93\x0f\x87\x1f\xfe\xd9\x42\xef\x8e\xd0\x87\xa3\x33\x34\xb4\x7d\x0e\xc6\x0a\xfc\xd0\xd2\xd9\xe0\x13\x52\xe6\x46\xc8\x46\xcc\x38\x11\xfb\xbb\x9f\x44\x3f\x18\xb5\x5a\xcd\xfc\x84\xc6\x11\x9c\x10\x82\x14\xd1\x9d\x6e\x10\xcb\x68\x1a\xc5\x78\x48\x68\xd9\xbe\x43\x4f\xe4\x2e\xc9\xd4\x78\x89\xba\x98\x17\x2b\xf2\xf5\x82\x30\xc4\xd1\x28\xf0\x1d\xa8\x9a\xdd\xc5\x1e\x80\xc1\x02\x2f\x87\x31\xb2\xbd\x5b\x7b\x1a\xd1\xb0\x85\x11\x13\xc4\x9d\x1d\x74\xc0\x42\xb8\x43\xfd\x6b\x3f\x32\x33\x86\x76\x98\x4f\xa6\x4d\xf8\xc0\xdf\xa3\x0e\x8b\xaa\x9a\xc9\xfa\xee\xe8\x27\x76\xa0\x73\x12\x04\x31\x91\xf1\x9d\x1d\xf4\xd3\x38\xb6\x63\xc2\xce\x90\x54\xc7\xa0\x83\xfa\xdd\xd1\x4f\x16\x1b\xdf\xaf\x4f\xce\xf8\xcf\x0f\x76\xec\xde\x60\xb3\xc5\x99\xc2\xa1\x4b\x0a\xb4\x3d\xe4\x07\xc1\x88\x11\x60\x53\xa5\x37\x45\x63\x9f\xb4\x99\x2e\xf9\x88\xf4\x61\x04\x97\x02\x68\xa6\xb7\xa7\x24\x19\x49\x77\xe4\x93\x9c\x0c\x1e\xf7\xf6\xf6\x96\x0a\x40\x54\x13\x7d\xfc\x63\x10\x5e\x63\x07\xf5\xc3\x60\x88\xfa\xdd\x3f\xa2\x1d\x26\xdb\x2d\xf2\x71\x10\xc7\xa3\xa8\xb5\xb3\xc3\x8e\x19\x7a\xc1\x50\x1c\x3d\xec\x40\xe2\xae\x17\x74\x77\xf0\xfe\x7e\xd7\x6e\xd6\x6d\xe7\x59\x17\xef\xed\xee\xe2\xee\xb3\xbd\xbd\xe6\x6e\xbf\xd9\xad\x7f\xff\xdc\x79\xd1\xfc\x7e\xb7\xb9\xe7\x7c\xef\xe0\xfd\x1d\x22\xcb\xf6\x15\x8e\x68\xde\x28\xec\xed\x5c\x5e\xf6\x83\xf0\x3a\xba\xbc\xe4\xc5\x26\x2a\x0e\x38\xef\x0d\x20\x1a\xbf\x1b\xa1\x5b\x38\x97\x85\x90\x8e\x81\x87\x6b\x24\x39\x44\x11\xc5\xb6\x43\xd4\x0e\x7f\x0f\xa2\x64\x71\xf9\x71\x02\xe4\x07\xf1\x80\x74\xc7\xed\x00\xfb\xa8\xca\x92\x55\x09\x45\x3f\x88\x51\x34\x1e\xd1\xf1\x91\x88\x6f\x88\x41\xc4\x21\xa2\x98\xdb\x77\x71\xc4\x44\xcd\xa1\x22\xbe\xbd\xbd\x4d\xfe\x9c\xba\x43\xd7\xb3\x43\x14\x07\x92\x86\xe9\x8e\x63\x44\x84\x15\x79\xc1\x15\x19\x04\x5c\x4d\xb8\x7d\x46\xc3\xa7\x87\x1a\xbc\xf4\x21\x8e\x93\x72\x7b\xb6\xcf\x0e\x9f\x1d\x42\xd5\x0b\xae\x90\x1b\x45\x63\x1c\xd1\x08\xbd\x62\x12\x90\x8f\x4e\xe0\x5b\x2f\x74\x01\xd4\x93\x50\x1a\xd9\xf1\x20\xaa\xa1\x13\x3c\x0c\x6e\x48\xc9\xa4\x58\x2f\xb8\xba\x22\xbf\x61\x7c\x91\xb1\x98\xe8\x5a\x95\x16\x8c\xb6\x6b\x8c\x47\x5c\xe3\x47\xf6\x10\xb2\xbb\x3d\x68\xcd\x7e\xe0\x79\xc1\x2d\xd0\x84\x2f\x40\x90\x96\x48\xc7\x16\xd8\x34\xc1\xed\x71\xe8\x06\xa1\x1b\x4f\x7f\x15\x5a\x52\x09\xa2\xfc\xd0\xde\xd8\x20\x1a\x9e\xc6\x49\x70\xfd\x58\x97\xae\x0f\x1e\x67\xdc\x53\x5e\x5c\xa1\xb9\xa4\xd7\xa6\xd2\x16\x18\xc4\x6d\x24\x2a\x93\x9a\x58\x90\xea\x25\x6a\xa0\x57\x34\x03\xbd\x68\x5c\x37\x2d\x74\x79\x0d\xd7\xce\x1a\x6d\xfa\xeb\x07\xf8\x4e\x1f\xe4\x0b\xc6\x70\x12\x06\x29\xd8\x3d\xe8\xc4\x30\xbb\x84\x10\xd2\x1b\x92\xd3\x3f\xe0\x05\x87\x57\x87\xbe\x83\x27\x48\x00\xac\xc0\x71\x22\x3b\x08\xeb\xa0\x2a\xab\x63\x0b\x55\xd1\x16\xa2\x95\x4b\xb6\xd1\xbe\x8b\x76\xae\x2c\xb5\x91\xd4\xeb\x04\xc0\x0f\x2f\x63\x6b\x8b\x97\xcf\x2e\x08\x48\x51\x5d\x99\x7c\xc3\x9c\x5a\x15\x5b\x46\x12\x72\x90\x3c\x7e\x0c\xc6\x9f\x74\xcf\x00\xa1\x38\x9c\x8a\xc4\x3b\x3b\x44\xdc\xd1\xaf\xd8\xeb\x05\x43\x88\x6a\xe7\xe0\xee\x98\x4a\x13\x55\x61\x30\x1a\x78\x5a\x10\x63\xaa\xcb\x6f\x6d\xa6\x76\x7d\x1a\xa6\xb7\x17\xf8\x37\xd8\x77\xb1\xdf\xc3\x28\x0a\xa8\xc7\x05\x77\x48\xa1\x67\x84\x64\x0e\x8b\x6d\x1e\xbe\x8f\x90\x8b\x03\xd4\x77\x7d\x87\x0e\x1d\xdb\xf3\x22\x37\x66\xbe\x1a\x30\xc5\x39\x34\x13\x1f\x63\x90\x3a\x24\x63\x94\xba\x07\x88\x50\xb5\xf4\x90\x32\x55\x55\xd4\xb3\x21\xaa\xcc\x84\xc8\xe3\x06\x82\xe0\xdf\x68\x96\xec\x8a\xf1\x6b\x21\x55\x3c\x49\x07\xd0\x37\x70\x1f\x49\xb4\x7b\xd2\xec\x69\x76\xaa\x9f\x18\xdf\x59\xa2\x16\xaa\xd5\x6a\xa4\xc3\xcd\x4f\x7c\xc2\x93\x75\x09\x91\x9f\x2a\x17\x2c\x2e\x96\x55\xa5\x0b\x01\xe2\x4c\xd0\x4d\x98\x50\x46\x51\xb3\xdc\x30\x6a\xa2\x97\x70\xfb\x90\xfe\xde\x46\x4d\x69\x20\x11\x12\xcd\x36\xfb\x49\x87\x12\x7f\x54\x6f\xeb\x8b\xe1\x04\x14\xb2\xe3\xa9\x99\x05\x57\x93\x15\x03\x0b\xd0\x2a\x9a\xd5\x42\xe7\xb4\xa9\x2e\x6a\xbd\xc0\xef\xd9\x70\x34\xad\x86\x5d\x68\x6f\x3c\xe4\xa9\xa3\xbf\x37\x50\x47\xf3\x9a\x59\x95\x8e\xeb\x90\x17\x70\x4e\x49\x8f\x14\x7f\x0c\xc2\x9f\xfd\x21\x3d\x2f\x16\x2b\x69\x1a\xa5\x5b\x72\x2e\x23\xdd\xf3\x21\x08\x46\x06\xb8\x3f\xf5\x0e\x45\x1c\x6c\x88\x01\x1d\x52\xdc\x42\xd2\x22\x77\x42\x3b\x48\x67\x6f\xa8\x83\xd4\x7c\xf2\xc1\x5c\x5b\xca\xc1\x8a\x67\xb7\x75\x64\x0a\x9b\x9b\x20\xa0\x22\x0c\xba\x7c\xaf\xe7\xfe\x5e\x4e\x0a\x47\xe7\x80\x32\x57\xa5\xab\x2f\xcf\x8e\xa2\x6a\x52\x0a\x93\x34\x7a\x41\x57\x2d\x72\x0b\x55\x6b\x44\x00\x93\x4a\x25\x1a\xa8\x64\xcb\x9d\x27\xe4\x2f\xd2\x7a\x4e\x16\x62\x3e\x3e\x58\x5c\xe6\xea\x77\x11\x18\x8e\x2d\xf4\xd6\xf6\xe9\x24\x4b\x8f\x38\x91\x8d\x58\x11\x08\xfc\xa0\xc6\x7e\x4c\x27\x3b\x56\x5e\x8d\x8e\x18\xd0\x4d\xe3\x88\x9a\xaf\x43\x6c\xfb\x11\xd3\x3f\x9e\x87\x1d\xf4\x5d\x64\x98\x28\xf0\x11\xd1\x46\x9c\x63\x3d\x09\x30\x6e\xfd\x60\x3b\x18\xd5\x7e\xf7\x7f\xf7\x8f\x3d\x6c\x13\xab\x84\x45\xbf\xc5\xc9\x24\x4b\x1e\xbe\x8b\x24\x22\x55\x59\x16\x52\xbf\xe5\x46\x66\x62\xbc\x40\x73\xf2\x38\xfd\x10\xb7\x38\x09\x14\xcd\xf9\x26\x1c\xd9\xdd\x28\x0e\xc1\x0c\x3d\x3e\x04\x36\x49\x8d\x69\x3b\xc2\xf1\x7a\xe2\x0a\x03\xa2\x41\x24\x9a\x16\xfe\x3f\xe4\x2b\x73\x35\x66\x81\x1d\x9e\x22\x88\xe1\x1c\x11\xd3\x0a\x9c\xf8\x82\x10\xac\x1a\x50\xcb\x50\x25\xd0\xd8\xa2\x72\x08\xd6\x0a\xc0\x7e\x6d\x43\x09\xff\x90\x88\xe1\x43\x6a\x1c\x80\x3b\x9f\x88\x1a\x7f\x8b\xd1\x2d\xb1\xb3\xe2\x00\xc5\x38\x8a\x39\x15\x1e\xe6\x81\x9d\x88\x3c\xa0\xb3\x70\x0c\x68\x7a\xac\x34\x8b\x1a\xf0\x28\x20\x5c\xde\xba\x11\x16\xc5\x87\x41\x8c\x7b\x31\x05\x04\x82\x88\xda\xbe\x0d\x01\x89\x9f\xee\x6c\x20\x94\x78\x89\x48\x73\x80\xca\x1e\x17\x60\xc6\x01\x5b\x27\x20\xf4\x00\x0e\xc9\xa2\x9d\xc0\x69\x21\x4a\xda\xba\xc6\x96\xe3\xd4\x39\x0f\x84\xb9\x4b\xaa\x79\x13\x10\x53\x1c\x2c\x55\x17\x9a\xeb\xda\x27\x33\xe8\xad\x1b\x0f\x28\xa1\x1e\x0e\x63\xdb\xf5\xe3\x29\x9d\x07\x6f\xc9\x0c\x80\xd1\xd3\xa7\x7e\x10\x3f\x7d\x4a\x6c\x41\x9b\x2c\x35\x50\x1c\xda\x7e\x64\x53\x9f\x2c\xc8\x48\x73\x7f\x0c\xc6\x68\x68\x4f\x45\x1b\x42\x20\x79\x3a\x89\x92\x22\xc9\x78\x20\x05\xb2\x28\xce\x64\xc6\x77\x30\x1e\xe1\x10\xd9\x64\x75\xc9\xbd\x51\x19\x27\xbc\x57\xab\x11\x0d\x57\x8d\x06\x76\xc4\xcc\x75\x07\x0c\xe1\x4f\xdc\xdd\xe3\x13\x58\x03\x3c\x7c\x3f\xef\x7c\x4a\x06\xda\x01\xec\x4e\xf2\x9d\xb6\x00\xfa\xa4\x8d\x8d\xfd\xc9\x02\xb2\xdc\x4f\x93\xa6\xa5\x54\x3e\x09\x6e\x7e\x75\x3d\x8f\x25\x07\x93\x35\xf9\xf2\xce\x75\xd8\x07\xb9\xfc\x79\x25\x90\x36\x0d\xed\xb7\x10\x53\xc7\x87\x94\x30\xbf\xe2\xc2\xf2\x00\xf5\xed\xda\xbd\x6b\xf4\x96\xaa\x19\xbb\x1f\xe3\x50\x1d\x10\x54\x20\xd2\x03\xe2\x15\x3d\xba\x7b\x90\xb4\x04\x22\x5a\x9b\xfb\x6c\x92\xd7\x44\xcb\x09\xb9\x64\xdb\x31\x94\x75\x32\xb8\x39\x41\xf0\x79\x96\xa5\x5a\xe3\xdc\x94\x2b\xde\x96\xa8\x41\x76\x1e\x43\xf9\x53\x5e\x55\x72\xc8\xa1\x96\x49\x6a\x3c\x30\xcf\xa9\x08\x11\x01\x64\x55\x02\x21\xaa\xa1\xd7\x74\xc9\x2e\x6c\xc2\x20\x94\x05\x29\x0e\xd0\x70\x0c\xd2\x46\x93\x27\x72\xcd\xfa\x24\x26\xcb\x71\xf4\x29\x09\x46\xfd\x89\xd8\x9f\xee\x90\xe4\xea\x7a\x58\x15\x3d\x1c\x62\xba\x12\x53\x20\xc3\xd2\xf9\xb9\x57\xb0\x3b\x1c\x62\xc7\xb5\x63\x2c\xa6\x1e\xc7\x42\x51\x40\x89\xd9\xbd\x1e\x8e\x22\xd2\x25\x6a\xd9\xb4\xc3\x59\x6f\xd1\xdd\x12\x1c\x0f\x02\x07\xc6\xa1\xf0\x92\xc1\x28\xf0\x1c\x8a\x4e\xb2\x66\xe1\x0c\x58\x2c\x6c\x22\x83\x1e\x8e\xa9\xf3\x1a\xfa\x80\x27\xb1\xd2\xa2\xdf\x96\x2c\x2b\x8e\x78\x45\xc2\x2c\x57\x7a\x51\xd9\x0e\xa5\xc2\xb4\xc2\x7d\x8a\x63\x62\x23\x44\xe3\x6e\x84\xe3\x94\x74\x83\xba\x03\x7d\x8f\x27\x6e\x14\x47\x62\xbb\xee\x72\x84\x61\x13\x8b\xf6\x07\x8d\x1c\xfe\x14\xf1\x0a\xb3\x8c\x23\xea\x70\x4c\xa8\x0f\x71\x08\xab\x30\x32\x9b\xc7\xf8\x8a\xcd\x07\x6c\x5b\xc1\xbe\xb1\x5d\x8f\x88\x3b\x5d\xb1\xe1\x11\xa5\x36\x12\x70\xed\xe8\x76\xe0\xf6\x06\x08\xa6\x69\xbf\x3f\x26\x72\x5b\xfb\xff\xec\xfd\x7b\x5b\xdb\xc6\x16\x28\x8c\xff\xfd\xe3\x53\xc8\x3a\xdd\x46\x2a\x83\x03\xa4\xb7\x48\x55\x39\x04\x48\x43\x73\x21\x05\x92\xb4\x9b\xcd\x8f\x8c\xa4\xb1\xad\xda\x96\x5c\x49\x86\xb8\xd8\xdf\xfd\x7d\x66\xad\xb9\xca\x32\x21\x69\xf7\x39\xef\x79\x9f\xb3\x9f\xdd\x60\xcd\xfd\xb2\x66\xcd\xba\x8f\x90\x27\x1e\x7f\x9c\x16\x15\x73\xac\xe1\x14\xa5\x93\x16\xf9\x66\xed\xa0\x60\x11\x5b\x13\xf2\x44\x3e\x39\x3e\x98\xff\x55\x80\x3b\xa5\x65\x9d\xd1\xb1\x01\xb7\x22\x45\xdc\x42\x18\xe9\x0f\x46\x94\xa2\x46\xfd\xbf\x0e\xd7\xaf\xff\x51\x60\x56\x46\xa3\xf7\x00\xb2\xb9\x08\x5f\x0a\xc7\x12\xa9\x0a\x18\xde\x58\x6a\xb1\xef\x53\x20\x69\xf9\xb6\x81\xed\x2d\x2b\x2b\x45\xd1\xc2\x52\x20\xe0\x89\x97\xef\xa9\x41\xe2\x02\xf1\xa8\x86\xad\x2d\x87\xc5\x1b\x23\x52\xa9\x2f\x16\xb4\xc4\x41\x6a\x23\x41\x19\xb1\x3b\x94\xa9\xa2\x02\x72\x3a\xfc\x97\xca\x29\x59\x9f\x17\x37\x64\xf6\x21\x3a\x7c\xbd\xe7\x60\x95\xf1\xd5\xc9\xfe\x42\xd3\x63\xe9\xa5\x25\x3a\x05\x22\x02\x54\x17\x8c\x8e\x9d\x22\x67\x42\x4e\x9e\xff\x01\x94\xa0\x10\x2d\x63\x63\xe2\x9d\x30\x80\x45\xd3\xaa\xd2\x89\x54\x6b\x8b\x45\x2b\xa5\x0c\xfc\xa7\x5a\x80\x7b\x8c\x74\x25\x23\x29\x96\xfe\x3e\xe4\xd1\xbc\x1a\xd5\x65\x08\xa2\x3a\x2c\xf3\x59\x57\xa1\xe0\x0e\xfe\xa1\x6b\xf0\x9f\xbd\x04\x3f\x35\x36\x10\x08\xf1\x25\x30\xc9\x4c\x3e\xc4\x72\x96\x3b\xd5\x3c\x4f\x86\x65\x91\x17\xb3\x6a\x3c\x47\x61\x30\xb0\x3f\x73\xe8\x91\xdd\xb0\x5c\x3c\x2a\x17\x33\x27\xa6\x75\x32\x04\x91\xeb\x00\xb8\x98\x9e\x03\x8b\x98\xd0\x5c\xe2\x5b\x4e\xb7\xa3\xdb\x11\xca\x58\x15\xc6\x40\x1a\x5c\xac\x0b\xfb\xc8\x12\xf0\x2c\x02\x5a\x5a\xe2\x02\x3e\x42\x39\x40\xe0\x1d\xc5\x73\x76\x1b\x82\x84\xe6\xd7\x51\x2a\xa7\xfb\x9e\xd7\xa4\x06\xee\x50\x28\x3f\x35\xdb\x21\xa6\xaf\x92\x60\x60\x25\xc1\x3e\x2d\x32\x8e\xb3\x72\xde\x1c\xda\xe3\xd7\xb3\x92\x39\x1e\xc8\xba\xcd\x55\xf1\x7b\xce\xc9\x4a\x2b\xca\xbf\x67\x36\x85\xab\x43\xc0\x96\x46\x86\x4a\x6c\xe3\x78\x15\x0e\xc5\x3e\xda\x3e\xbf\xa9\x58\xc5\x70\x1b\x95\x4c\x3b\xcd\xfa\x7d\x8e\xd6\x6b\xde\x1a\x68\x1a\x00\x3e\xbe\x56\xd7\x1f\xb8\x76\xa9\x79\xf3\x4d\x32\xa6\x06\xe0\x23\x9c\x97\xd0\xe3\x95\x1f\xe1\x98\xf5\x8b\x12\x41\xbf\x8d\x5b\x20\x40\xfe\x03\xb0\xe5\xec\xd6\xb1\x47\xcb\xb3\x24\x6e\x51\xcc\xc7\x9c\xf1\x46\x11\x58\xaa\x6c\x90\xe3\xa2\xc3\x40\xc5\xfe\xd8\x77\xd1\x42\xdf\x21\x9f\xba\x94\x0a\x63\x72\x35\x1c\x15\x47\x4a\xb9\x8a\x74\x96\x30\x27\x7f\xc8\x45\x26\x34\x41\xea\x42\xfb\x8c\xeb\xac\x92\xf0\xa7\xaf\x32\xcd\xee\xda\x8c\xf0\xd7\x8f\x5a\xf1\x96\x02\x62\x53\x20\xda\x7e\x0f\x21\x5a\xef\x48\x91\xb4\xb5\x38\x10\x2f\x0b\xd7\x0f\xc2\xbc\xad\x2d\x23\x3b\x81\x52\x8d\x6c\x74\x91\x82\x67\x04\xa4\x4e\x51\x4a\x89\xe4\x30\x85\xac\xa8\xa6\x23\xe4\xbb\x85\x89\x5d\xd1\x17\x4b\x01\xf5\xe2\x31\x03\x14\x22\x04\x20\x45\x69\x1e\x3e\x24\x91\x10\x3b\xdd\xdf\x44\x6f\xd3\x77\x02\x15\xf6\xcc\xbe\x29\xda\xbd\x21\xd6\x5e\xe0\xd6\xad\x6c\x5c\x0b\xff\x88\x00\xe1\x0b\xc5\x07\x30\x80\x7f\x4a\x74\xf0\x77\x05\x07\x5a\xa0\xf5\xb7\x84\x06\x5f\x20\x32\xf8\xfa\xb3\x0e\x9c\x00\x29\x21\x08\xe3\x58\xfe\xf3\x8f\x9c\xc1\x45\xdb\x6a\x08\xeb\x9c\x3d\xc8\x49\xc6\x04\xb1\x06\x73\x6e\x40\xd9\x11\x9b\x96\x2c\xe1\xf8\x81\x13\xaa\x95\xc4\xe5\xfc\xb7\x52\x4b\x02\xdf\xe2\x14\x39\xd2\x87\x59\x22\xf4\x40\xf0\xc5\x10\x33\x57\x59\x9e\xc0\x1a\xdf\x32\xe7\x16\x00\x74\x9c\x8d\x04\x2f\x22\x3a\x00\x27\x49\xe2\xdc\xb2\xcd\x92\xc1\x26\x0e\x0a\xa1\xc3\x99\x14\x37\x98\xeb\x14\x37\xac\x94\x18\x98\xb7\x36\x29\x52\x56\xe6\x4e\xac\x88\xd3\x9e\x73\x82\xfa\x5f\xde\x90\x83\xba\x01\x87\x72\x72\xae\x06\x6b\x16\x78\x1d\x96\x1f\xde\xac\xef\x64\x1c\xdc\x90\x3e\x41\x38\x7a\xa4\x54\x90\x6a\x50\x29\x4c\x34\x92\x3a\x1d\x2d\xfd\xbb\xdc\x54\x1f\x9b\xc4\xd9\x54\xbd\x4e\xe8\x88\x39\x15\xbf\x5f\xf9\x89\x18\x33\x38\x9e\x40\xbb\x25\x65\x06\x04\x03\xfa\xb2\x09\x66\x0a\xb4\x39\xac\x42\xa5\x2d\x48\x94\x6d\x18\x44\xd9\x2e\x6f\x6b\x5a\x02\x8d\xe2\x4c\xd8\xa4\x28\xe7\xce\x98\xd1\x51\xd5\xdb\x14\xcf\x2c\x95\x16\xb7\x7b\x69\x33\xa4\xc4\xd9\x3c\x63\x7d\x30\xf3\xc2\x4b\x15\xe4\xd1\x1c\xc7\x55\xcc\x20\x44\x84\xde\xdc\xab\x18\xc3\x91\xdc\xa7\xe8\x47\xcf\x42\xd4\x45\x3f\x7a\xbc\xf7\xf8\x3b\xbf\xb7\x79\x85\x4a\x16\xb9\x82\x7c\xe9\x25\xf4\x64\x45\xde\xa6\x3c\x43\x92\x0f\xe5\xdd\x59\xde\x2f\x24\x87\x22\xec\xbb\xb0\x0d\x65\x97\xd7\x72\x1e\x88\x63\x36\x21\x15\x07\x03\x56\x07\xad\x9a\xd3\x36\x6d\xde\x57\xbb\x4d\x75\x02\xb8\x85\x6b\xb0\xcf\x72\x67\x3a\xa6\x59\xee\xfc\x42\x6f\xe8\x39\xec\xa2\x0d\xe0\x3d\xe7\x5f\xd5\x26\x4e\xe0\x72\xe7\x4a\xfc\xd8\xbd\xb2\xe2\x99\x03\x3d\xab\x94\x55\x5a\xb3\xa5\x55\xb6\xb0\x72\x4a\x1b\xd7\xcf\x81\x83\x04\x2d\xbf\x09\x8a\xa6\x76\xd1\xce\x69\x5a\x31\x62\x0b\xc6\x5b\x3f\xeb\x76\x44\x94\x24\x8d\x9e\x2e\x31\xf9\xca\xd4\xa0\x19\x0a\x84\x7f\x88\x1f\xb4\x8c\x54\xef\xe7\x09\x1f\x3d\x72\x8e\x66\xd3\x71\x86\xbb\x02\x14\xe3\xa1\xd1\xea\xff\x87\x79\xc6\x55\xee\xf9\x68\x36\x99\xcc\xc1\x6e\x62\xc3\x4e\xd3\x47\xc3\x89\x9c\x96\x03\x83\x56\x65\x53\x73\xd5\xdf\x18\x35\xac\xed\xb0\xda\xe2\x04\x73\xb3\xfb\x70\xa3\xbd\xa1\x9e\xad\xc5\xb4\x1a\x05\x8b\xa9\x03\x20\x8c\x68\xee\xb0\x8f\x75\x49\x1d\xdd\xcf\x1f\xb3\xc9\x54\xc2\x51\xc5\xc4\xe1\xae\x7a\x1b\xc2\xae\xcf\x6b\xef\x8f\xb4\xcd\x74\xfd\xe8\xda\xbc\x2b\x95\x9a\x4c\x2f\xb6\x6d\x26\xfd\x7f\x61\xb3\x1d\x36\xc1\xd0\xc5\x5a\x29\x13\x9e\xec\x35\x7c\x00\x40\xad\x69\xaa\x01\x51\x76\xb3\x7f\x0f\xa4\xd6\xf4\xb8\x0e\xa6\xd6\x0d\xf0\x7e\x9f\x58\x05\x5e\xeb\xaa\x8b\x97\xec\xa3\x95\x6b\x6b\xbd\xd7\xac\x45\xa6\xbd\x60\x6c\x5a\x71\x22\x3d\x19\x29\xb1\xa3\x60\x0d\xc1\xe0\xdb\x90\x9e\xd8\x19\x52\x09\xac\xf9\xf9\xdb\x61\xa1\x98\x88\xdb\x1c\x82\xaa\xa8\xcc\x0a\x49\x28\x8a\x4c\xb6\x36\x43\x8c\x19\xea\xd7\xc5\x26\x49\x72\x4a\xe9\x8c\x4d\x63\xee\xa6\xc2\xd8\x96\x7a\x3a\xff\x13\x76\xad\xf9\x3c\xbf\x92\x88\x4a\x0f\x61\xe0\xf7\x60\x05\xc0\x1d\xc6\xba\xfb\x54\xf4\xe1\xb5\x8e\xc3\xa1\x8c\xd0\x23\x9c\x5b\x14\x29\x5b\x53\x14\x5f\x43\xf7\xc2\xae\x1d\x18\x52\x08\x65\x52\x1b\xb2\xa7\x1c\x0c\x35\x45\x7d\xde\x5a\x5e\x94\xce\xb4\x18\xcf\xfb\xd9\x78\x4c\x78\x51\xce\x3a\x21\xe5\x80\x6e\x76\xc0\x6b\xf3\x7e\xc0\xde\x8e\x95\x60\xaf\x92\x27\xac\x87\xeb\x74\x7c\x70\x78\x71\x7d\xfc\xf2\xf8\xd5\xf1\xeb\x8b\xeb\x8b\xdf\xdf\x1c\x83\x51\x8a\xe5\x83\xd3\x64\x83\xbb\x5d\x91\x71\xc9\x29\xf8\xcd\xab\x95\x04\x6f\xd3\x72\x23\xdd\x04\x0b\x8f\x9d\x8f\x8c\x26\xdf\x8b\x95\x3b\x3b\x3e\x3f\x3e\x7b\x77\x7c\x74\xfd\xe6\xec\xf4\xcd\xb9\xd8\x1b\x88\x95\x2f\x83\x6a\x95\xac\xaf\x3f\x84\x33\xb4\xf9\x8d\x2e\xd1\x90\xa2\xf6\x43\x58\x1e\xf3\xe5\x7e\xc1\x24\xa5\x75\x3e\x2c\x6e\xf3\xb0\x99\x7f\xc6\xfa\x76\xbe\xc6\xc0\x43\x8a\xfe\x05\x67\xac\xef\x25\x45\xde\xcf\x06\xa6\xb9\x0c\xbc\x7d\x6b\xed\x2a\xba\x75\x60\x49\xd0\xca\xf4\x37\x7d\x3b\x7a\xbf\xe0\x03\x14\x7c\x0c\x58\x6d\xd4\x3f\x62\x48\xa4\x17\x65\xa3\x11\x5e\x4e\xd2\x6c\xbc\x5b\xd1\x4c\xb7\x2b\x1a\x94\x12\x5c\x31\x91\x96\x58\xbe\xca\x0a\xc0\x20\xfb\x36\xf0\x3f\xe9\x94\x0a\x3d\x72\xa4\x0f\x86\x7a\x06\xad\xb8\x6c\x59\x92\x17\x6c\xfe\x25\x4b\x32\x62\xf3\xbf\xbf\x24\xd0\xc8\xff\xc2\x25\x19\xb1\xf9\x7d\x4b\x82\x89\x2f\xd8\x9c\x8f\x59\x74\xf7\x33\x8c\x41\xde\xd9\x86\xd9\x13\x8e\x43\x5a\x34\x1d\xc4\xc5\xac\x3e\x90\x12\x6a\x34\x6e\x5a\xe5\x1b\xc0\x74\x6e\x3d\x44\xeb\xa9\xad\x2f\x63\x58\xe1\xb4\xdb\x31\x05\xce\x87\x11\x9b\x7f\x50\xda\x3a\x20\x12\x7a\xce\x45\x39\x17\x3c\x30\xf2\xa9\x4a\x68\x21\xde\x14\x00\x3e\x2d\xcb\x9d\x0f\x6a\x6d\x3e\x08\x5c\x8c\x4b\xc8\x52\xc0\x5b\xf3\x62\xe6\xe4\x0c\x31\x9c\x68\x48\x19\xec\x42\x13\x20\x9a\x05\x91\x90\xd0\x4d\xc1\x25\xa3\xf1\x3e\x81\x26\xc4\xad\x30\xa5\x38\x10\x30\xe2\x54\x62\x5c\x6c\x08\x87\xed\x49\xd6\xb1\x1f\xf7\x26\x0c\x99\xc5\x6d\xb1\x3a\xdb\xe8\x33\xb6\x69\x6f\x8b\x65\xa6\xe7\xb4\x6f\x4e\x03\xa4\x8c\x35\x6d\xe7\x17\xc5\xee\x03\xbc\x4a\xe6\x10\x58\xc3\xd6\xd6\x91\x91\x46\x90\x9b\x95\xfc\x2a\x17\x38\x0d\x19\xb4\x55\x88\x3b\x63\xfd\xbf\x0b\x71\x67\xac\xff\x20\x88\x6b\xe0\xc8\x56\x88\x6b\x94\x79\x08\xc4\x95\xac\xff\x7f\x21\x6e\x2d\xc4\x9d\xb1\xfe\x97\x42\x1c\xbf\x34\x3e\x01\x71\x67\xac\xff\x69\x88\x93\x92\x5e\x74\xd1\x93\x1a\xb2\xba\x70\xd0\xc3\xc4\xa1\x40\x45\x8b\xc8\x50\x78\xc5\x0b\x29\x70\x5e\x38\xe3\x22\x1f\xb0\xd2\xa1\x29\x27\x5a\x2a\xa1\x63\x80\x95\x06\xae\x7d\x0a\xb1\x5b\x73\xe2\x54\x85\x70\x89\x00\x79\x10\x6f\x50\xca\x72\xb3\xba\xe7\x1c\x8c\xab\x82\xf0\xe6\xa4\x62\xbe\xe8\xa3\x65\x23\x08\xf3\x38\x60\xdc\x16\xe5\x48\x89\xdd\xc0\x06\xcf\x91\xfe\x88\x4e\x3f\x63\xe3\xd4\xa1\x03\xca\x6b\x0b\xd2\xa4\xd7\x2f\xca\x55\xba\x84\xf7\x29\x9b\xcd\xfa\x20\x2e\x46\x1f\x0d\x30\xae\xc4\x29\x0a\x7a\xac\x29\x78\xfd\x7a\x09\x54\x52\x23\x69\xc4\xe6\x66\x0a\x2a\xe6\x17\xd2\x64\xa0\x64\xfd\x46\x79\x4e\xd7\x38\x07\xce\xd7\x35\x9b\x4c\x8b\x92\x96\xf3\xaf\x85\x60\x03\x85\x94\x35\x4b\x6a\x47\x58\x28\xdd\x02\x19\x08\xfa\xcc\x0f\x0e\x0a\x22\x35\x50\x0a\x55\x16\x73\x3e\x00\x7d\xfd\x01\x85\xe1\xe8\x56\x64\x39\xda\x82\x20\x18\xe4\xc3\x44\x99\xbf\xdf\x22\x5d\x4d\xd1\x76\xb8\xc7\x39\x3d\x29\x5d\x1f\xb0\xda\x29\x33\xf0\x6b\x41\xc2\x9d\xe6\xa9\x94\xfb\x39\x38\x3b\x3c\xd1\x15\x6a\x86\x68\x59\x16\xb7\xa0\x5b\x13\xe8\x45\xe8\xb8\x68\x05\x90\xc1\xff\x8a\x19\xf0\x54\xd1\x64\xc9\xd4\x31\x25\x82\xda\x95\xea\xc0\x1c\xe0\x47\xfa\xde\xe4\x4e\xcc\x86\xf4\x26\x2b\xca\x5e\x73\x1d\xd1\xcd\xef\x80\x73\x0e\x79\x21\x83\xc3\xa2\x9e\xc4\xa3\x69\x8a\xec\x27\x45\x85\xc2\x34\x1b\xa3\x8d\xa8\x32\xc3\xf4\x01\x00\xf2\x94\xb3\xd2\x60\x34\x91\x8d\x59\x0e\xc3\x19\x67\x39\x73\x64\xa0\x5d\x11\xa0\x12\xaa\x81\xc0\xad\x9c\x50\xa9\x9b\x30\x47\x03\xf3\x6a\xa4\xc1\x29\xdd\xb0\x39\x0f\x93\x59\x91\xfb\x63\x62\x66\x64\x09\x47\x6c\x4e\x38\xe8\x10\x80\x16\x22\xe6\x4a\xb0\x17\xa1\x49\xd4\xf8\x9e\xa9\x76\x10\x13\x48\x6f\x08\xce\x63\x50\xf0\x9a\x99\xa1\xaa\x29\xcf\xfe\x9c\xb1\xf1\xdc\xc9\x52\x96\xd7\x59\x7f\x8e\x4a\x14\xba\x02\xf8\xd0\x8a\xf2\xf5\x6d\xe5\x18\xc8\x86\xec\xea\xe9\x2c\x1b\xd7\xdb\x59\x6e\x9a\xf8\x00\x8c\xc5\x0c\xf6\xbf\x40\xb4\xcb\x8c\xa6\x31\x7c\x22\x4c\x15\xbe\x81\x0d\x18\xc9\xab\x11\xf8\x80\x52\xa2\x2d\xf4\x27\x16\xca\x53\xd5\xe9\x19\x4b\x8a\x32\x6d\x30\x94\xe8\x8e\x57\x65\xf1\x18\xad\xa0\xe1\x14\x28\xb5\x3f\x53\x87\xda\x71\x1c\xe1\x9d\x2c\xb7\x4d\xb8\x60\x18\xcb\x07\x5a\xe4\x0c\x03\x85\x3a\xfd\x31\x05\xfc\xa0\xf9\x50\xb0\x7d\xc8\x6e\x18\x9c\x9c\x29\x2a\x79\x8a\x5c\x56\x47\xe9\x00\xec\xb8\x13\xd3\x64\x84\x32\xca\xa2\x64\xc6\xf9\x83\xc3\x87\x8e\xc5\x46\xac\x48\x84\xdf\x9e\xb5\x8d\x42\x8f\x2d\x8e\xa0\xd0\xc7\x52\xe7\x3d\xa3\xa3\x57\x74\xea\x14\x68\xc4\xc4\xe6\x70\xaa\xb2\xc9\x14\xe7\x09\x02\x65\xd9\x4e\x52\x4c\x26\x85\x72\xc6\x5b\xe7\xcf\x85\xdd\xca\x75\xba\xc6\x11\x0b\x13\x11\x39\xa0\x02\x15\x0f\x7c\xd1\x69\xa9\x5c\x71\x04\xdc\x54\x0e\xa3\x55\xc6\x4a\x14\x83\xb0\x0a\x16\x7f\x3a\x2b\xa7\x45\xc5\x2a\x50\x94\xf0\xca\xb2\xad\xba\x65\x91\xf3\x22\xdf\x66\xf9\x6c\xc2\xe0\x9a\x72\x3c\xc4\x80\xd3\xa2\x82\x5d\x25\x42\x31\x8a\xb7\xb5\x6c\x27\xcb\x93\xf1\x2c\x65\x0e\xbb\x61\xe5\xdc\x8a\xed\x77\xcb\xc0\x22\xa3\x16\x7a\x0f\x5f\xe0\x3f\x86\x97\x07\xc4\xe9\xe3\x97\x8a\x6a\x68\x90\x17\xfc\x06\xcb\xc4\x06\xb4\xdf\xbd\xf6\xfa\x10\xa0\x30\x32\x50\x6c\x6f\x12\xd3\xd3\xc9\xb8\x6c\x45\x98\x68\xcc\xd2\xd3\x6b\x64\xdc\x96\x59\xad\x2f\x67\xa2\x58\x27\x7c\x36\x8e\x97\x34\xa4\xf8\x30\x60\xb8\x4a\x38\x56\x15\xb8\x90\x03\xc0\xd1\xf1\x3b\xd4\xc9\xea\xe3\xf8\x80\xd9\x10\x67\x13\x18\xee\x7f\x6c\x0a\x56\xb2\x98\x03\xef\xa0\x39\x85\x8b\xdb\x42\x42\x5c\x25\xa8\x0d\x74\xfb\xbe\x2d\x8c\xbb\x4e\xdc\x87\x82\x4a\x8b\xd1\x13\x33\x4b\x59\xc9\x14\x14\xb0\x3f\x67\x74\xdc\x0a\x78\xc2\x18\x83\x95\x60\xb4\xc1\x81\x62\x98\xa5\xe0\xa4\x0c\x57\xa8\x98\x8c\xb2\x57\x7f\xc0\x42\xc1\x6a\xff\x77\x97\x0a\xba\xb0\x16\x8b\xd3\xea\x56\x3c\x02\x4d\x9d\xdb\x61\x0a\x24\x80\xe2\x2d\x11\xde\x57\xc6\xd2\xb9\x68\x7e\x58\xe4\x5a\x82\xbf\x43\x41\x09\x02\x31\x80\x7e\x81\x9a\x28\x94\x37\x99\x0c\x19\x9d\x41\x5c\xe2\xf9\x14\x15\xcf\xe7\x8c\x29\x67\x5e\x20\xc7\xfe\xa8\x20\x26\x2f\xc4\x0b\x45\x0a\x9a\x4e\x33\x88\x15\xfa\x3f\x10\x04\xd4\x65\x61\xaa\x70\xec\xf0\xb5\x78\x51\x4a\x59\x81\x94\x55\xea\x4b\x91\xcf\x1e\x7d\x84\x36\xc4\x8d\x01\x31\xd5\x53\x30\xff\xad\xe0\xa8\x80\x04\x57\x78\x60\xc8\x2a\x95\x46\x78\x10\x14\x0a\x58\x75\x08\x6f\xb5\x21\x1f\xd9\xeb\x37\x52\xe0\x14\x36\x92\xf0\x3c\xca\xc4\x0d\xdc\x3d\x1c\xac\xd3\x91\x36\x24\x96\x2c\xa5\x29\x80\x32\xdd\x93\xfa\x28\xb4\x17\x62\x9b\xa6\xb7\x5d\x8b\xa8\x46\x57\xc6\x09\x6c\x82\xdf\x94\x92\x72\x58\x1e\xa4\x62\xf8\x22\x17\xe5\x6e\xb6\x27\xa1\xb3\x0f\x03\x76\x02\xbb\x10\xb6\xa2\xa6\xaa\xf3\x44\xca\xa7\x9a\x80\x62\xa1\xbe\xd1\x27\x34\x03\xe6\xc7\xa0\x23\xf8\x2e\x21\x29\xc7\xd9\x3b\x80\x37\xdc\x24\xbc\x27\xa1\x2e\xa8\x32\xe5\x6e\x83\x4b\xb2\x21\xae\x7a\x88\xb0\x4a\xd6\xf5\x9d\x6e\xd7\xe9\xd8\x72\xca\xa6\xb2\x53\x95\x35\xe5\x4c\x30\xa4\x4b\x99\x75\xa5\xd6\x42\x27\xb5\x49\x9f\x10\x2c\x65\xd0\x22\x79\xcb\x43\x2c\xed\x7a\x08\x6e\x66\xda\xc5\x52\x1a\x94\x15\x15\x22\x79\xa0\x69\xfb\xac\x2c\x59\xea\x14\x39\xe7\xb8\xe4\x85\x9a\xb3\xdb\xf1\x1c\xa8\x3e\x54\x11\x99\xcb\xd5\x13\xd0\x29\x0f\xcb\x4b\xf0\xbb\x6c\x71\xc5\x74\xb6\x9d\xbd\x50\x02\x6d\xa3\xb0\xf9\x90\xa2\xad\x27\xe0\xf3\x56\x2a\x03\xf5\x54\x5c\x4b\x1b\x3f\xe9\x16\xd4\x70\xc0\xe9\x53\x39\x7f\xda\x15\x04\x96\x6a\x7d\xa0\xd9\x2a\xd8\x78\xa9\x59\x37\x8c\xcf\xab\x69\xbf\xcf\xcc\xd9\x72\xf6\xae\xcc\x83\x64\x02\xcb\x1a\x2c\xdb\xc4\xa1\xba\x79\x7f\x75\x7f\xd7\x2d\x0e\x94\x0f\x0d\x00\x38\x63\x55\x31\xbe\xd1\x9a\x35\xc1\x34\x28\xbf\x6a\x0e\x94\xab\xe1\x87\x8c\xe5\x6b\x3c\xc7\xb1\x1a\x90\xa8\xfd\x94\xb4\x35\x27\xdf\xb8\x6f\x80\x73\xbb\x57\x71\x1b\xdc\x9b\x8d\xde\x0f\xfd\xa6\x24\x99\xe3\xa8\xc5\x82\xe3\x39\x7b\x20\xd2\x3e\x0f\x16\x52\xb1\xfa\x91\xed\x5d\x0e\x26\x7a\x76\x89\x4e\x14\xb5\xf2\x2c\xcd\xa7\x2e\xed\xd7\xe7\x44\x65\xd4\x1a\xda\xea\x8f\x7d\xb1\xaa\xb6\x57\x2b\xa4\xe5\xe2\x63\xf3\x6d\x0e\xe6\x6e\x9b\x0e\x32\x36\xda\x26\x43\xcc\xd0\x7e\x37\xf0\xf3\x64\xc9\xab\x4f\xfe\x61\xb3\xd6\x8a\xe9\x66\x1f\x2a\x30\x6c\x7b\x49\xd0\x59\x95\x8e\x9b\x37\xfc\x27\xf8\xd3\x15\x1d\x9c\x0c\xb6\x25\x79\x56\x53\xda\x74\x26\xc9\x08\x6d\x9e\xca\x59\x23\x61\x96\x5a\x35\x38\x0b\xb0\xee\xf8\xdb\x84\x05\x5a\x27\xcd\x45\x58\x20\x4d\x5a\x8c\x8b\x9c\x1d\xe4\xa9\x70\xe6\xe1\x37\x69\x31\x96\xe1\xa6\x08\x47\xaa\x2f\xe4\x0e\x72\xc0\xc9\xd9\xad\xe6\xdd\xad\xe5\xd1\xb5\x30\x32\x96\xa8\x4a\x1c\x23\x03\xd6\xcd\xf8\xbe\xc6\x35\xb4\x52\x24\xbf\x6f\xa4\x09\xde\xdf\x48\x92\x4b\xaa\xb7\x4a\x0f\xcc\x5c\xe8\xc3\x31\xdc\x25\xf7\x52\x6e\xe0\x87\xa3\x24\x09\xb4\x92\xb6\xff\x25\x92\xd2\x45\x86\xe2\xb0\xcf\x5b\x72\xde\x6f\x3b\x29\x67\x04\x7e\xd3\x94\xf5\xc3\x89\xb9\xd3\x32\x1b\x64\x9c\xbb\xc6\xeb\x8d\x5f\x89\x49\x31\xcd\x56\x28\x39\xa9\x7b\x87\xf7\x34\x57\x57\xed\x61\x64\x21\x92\x50\xb2\xba\x20\x9f\x34\x29\xc8\xf4\xb6\x0a\xb3\x89\x73\x4e\x41\x81\xfd\xbc\x6c\x1c\xac\x12\xd1\xcd\x40\xea\xc2\x55\x66\xcf\x26\x23\x99\x09\x15\xb2\x41\xa4\xa8\x5a\x9a\x34\x17\x12\xd4\xbe\xf9\x38\x1b\xb1\xf1\x5c\x58\x70\xd7\xb4\x1c\x30\x61\x88\x41\x05\x91\xa0\xc4\x61\x92\xa8\x80\xe7\x95\x70\x39\x2b\xa3\xa3\x22\xa6\x31\x27\x25\x9c\x18\x35\x6e\x42\x56\x56\x94\xda\x15\x17\x9a\x9b\x31\xa5\xf9\xb7\x69\x5f\x66\x43\xb3\xda\x3b\x58\x01\x29\xed\x53\x13\x22\x7c\xec\xac\xaa\x60\x55\xb3\x0a\x2c\x30\xcb\x2c\x4d\x59\x2e\xda\x2d\x84\x4e\x9f\x59\x07\xe2\xef\x12\xd7\x7c\x75\xb3\x31\x0a\x75\xaa\x9a\xd1\xb1\x30\x67\xe9\x6b\xf9\xea\x94\x96\x4a\x6e\xb4\x8e\x1a\x77\xd4\xf0\xd6\xa2\xc0\x7f\x98\x6c\x5f\x47\x32\x8b\x75\x63\x68\x2c\x2b\x33\xab\x56\x72\x41\x33\x96\xcc\x40\x5a\x9c\xe2\x30\xbf\x5b\x29\x0f\xa7\x49\x77\xac\xad\x61\xce\xfb\x7f\x3f\xad\xae\x41\x65\x1d\x85\xc3\x5b\xb6\xe6\xd6\x59\x47\xff\xdc\x4b\xbf\x7d\x29\x91\xd4\xfa\xc6\xf2\xc3\x39\x8c\xf6\xbb\xfc\xff\xf2\x1a\xff\x6f\xe2\x35\x1e\xc2\x19\xb4\xd1\x5e\xcc\xa2\x2c\x1e\xa4\x23\x30\xc9\x80\x77\xac\xd4\x21\xc5\x84\xa2\x44\x2b\xbd\x0c\x9d\xd7\x67\x5d\xf2\x59\x05\xf2\x4f\x7d\xcd\x6b\x3f\x05\xa9\x03\x93\xcc\xfa\x7d\xd1\x32\x3e\x60\xa1\x0f\x38\x22\x68\xd2\xb6\xe5\xd5\xee\x0b\x06\x1d\x61\xc7\x05\xf5\xb0\x0d\xdb\x9e\x0d\xa9\x7a\x31\x5d\xcb\x03\x08\x5f\x5a\xe3\xc9\x1d\xe1\xd6\xa3\x93\x6c\x76\xa3\x8d\x99\x50\x46\x89\x18\x8d\x8f\xc5\xb3\x81\xc0\xfa\xcf\x4a\x64\x28\x54\xac\x31\x78\x87\x4d\x2a\x29\xa4\xaf\x34\xea\xb2\x6f\x31\x00\x1e\xa8\x0e\xda\x1b\xea\x0d\x98\xbc\x4e\xce\x6b\x9a\x8c\x4c\xa1\xd2\xfa\x1a\x50\xf4\x80\xdf\x9e\xe9\x6c\xd2\xaa\xfa\x07\xe0\x9e\x4c\xc7\xf2\xca\xfa\x64\xc7\xfa\xb2\xe0\xd5\x56\xa2\x84\xf1\x44\xcf\x8a\x04\x65\x84\x33\x0e\xad\xb0\x48\x27\x17\xc7\x67\x07\x17\xa7\x67\xd7\xe7\xbf\xbf\x7a\x7a\xfa\xf2\xc1\xc6\x67\xea\xbd\x03\xb4\xed\x7a\x76\xf0\xf6\xb7\xeb\xd5\xb6\x36\x75\xe8\xf5\xcd\x10\x14\x54\x28\xf7\x15\x8d\x57\x53\x96\xf4\xfe\x0f\x30\xca\xfb\xef\x9a\xe4\xe9\x3e\xdf\x9c\x9e\x5d\x1c\xbc\xfc\x67\xbb\xc4\x97\x1f\x8c\x1e\x29\xf6\x78\x7e\xfc\xe6\x00\x76\x8b\x6f\x53\x6f\x53\x24\xbe\x7d\x6a\xa5\x07\x46\x0c\xd0\x63\x88\x0c\x8f\xd1\x38\x4b\x3a\x05\xb2\xa8\x2a\x84\x7b\x59\x45\xfb\xca\xbb\x84\x62\xd8\x4f\x9a\xd4\x59\xda\xd0\xda\x4b\x4f\x79\x5e\x17\xa9\x62\x8c\x37\x2f\xfc\x10\x25\x46\x92\xc5\x40\x57\x89\x05\x78\x95\x86\x1b\x81\x08\x55\x3f\x32\xb9\x41\x4c\x3b\x63\x03\x88\xc0\x27\x9e\xa5\x08\xad\xcc\xf2\x65\x51\x8c\x66\x53\xa5\xa1\xdd\x8c\x36\x03\x67\x33\xda\xd9\x44\xb1\xff\x66\x00\x9f\x7b\x9b\xa6\x63\x8b\x18\x04\x86\xc2\x77\x22\xc7\x03\x6a\xd0\x0a\x0f\x6f\xf4\x6c\x46\xf0\x9b\xd0\x3a\x19\x36\xa2\x03\x59\xe3\xb8\x84\x12\x70\x27\x2d\x2d\xfe\x71\xf3\x2b\xde\x87\xd5\xb3\x79\x83\x60\x94\x86\x0b\x56\x09\x34\x46\x39\x17\x32\x18\x4b\x9b\x1a\xd0\xfa\xe7\x0e\x3c\x24\x8c\x5a\x4a\x4e\x57\x64\x35\x9b\xe0\x1b\x80\xca\x30\x47\x98\x4c\x08\xcb\x10\x23\x7e\xa3\x88\x3b\x05\x16\x2c\xaf\x28\xd0\x95\xc2\x7a\x0f\xb2\x67\x15\x2b\xc5\xc3\x77\x9c\x6c\x3e\xb6\x17\x1e\xde\xf9\x08\x9b\x7b\xf5\xd6\xae\xe3\x81\xa7\xb0\x79\x43\xe0\xba\xa2\x03\xb1\x5c\xd8\xf5\x1d\x11\x67\xf3\xab\xee\xa3\x4d\x5f\x21\xb3\x37\xa7\xa7\x2f\xaf\xcf\x4f\xfe\xcd\x4f\xcf\xee\x0e\x82\x74\x5d\xd2\x1b\x56\x56\xec\x10\x0d\xed\xdf\x14\xfc\x2c\x39\xd6\xfb\x23\x03\x06\xc9\x2c\xbd\xb0\xcb\x7a\x13\x3a\x3d\xc3\x47\x0a\x1c\xf5\x42\x01\x71\x26\x74\x2a\x23\xf9\xc2\x87\x28\x8d\x13\x01\x59\xd9\x6a\x97\xf2\x4d\x13\x03\xe1\x37\x4a\x81\x9d\xd1\x6a\x3d\x7c\xfb\x04\x35\xf5\x76\xb6\x78\x3f\xc1\x89\x1c\x35\xcc\xf6\x72\x6a\xe8\x4e\xa4\xa7\xd1\x5e\x94\x2f\x09\x36\x28\x67\xd8\x5e\x4e\xfb\x2f\xe8\xf9\xaf\x2b\x39\x03\xc9\x8c\x08\x86\x29\x29\x01\xbb\x94\x41\x36\x5a\x07\x45\x5f\x6b\xf0\x64\x8b\x9e\x28\xd1\xac\x99\x78\xc2\xc5\xd8\x20\x91\x07\x4f\xba\x58\x9b\xa5\x35\x84\xf0\xc8\x8b\x31\x76\x9d\x35\xcb\xeb\xc0\xd9\xc1\x9b\x53\xc5\x4f\x53\x90\x52\x32\x08\xf3\xd6\x84\x93\xc6\x74\x84\x3f\xe6\xba\xed\x92\x97\xf0\x7d\xfb\xb4\xae\x8c\xd8\xa0\x75\xd9\x7a\x5f\xd6\x97\x30\xf6\xe3\x7e\x60\x75\x7e\xd4\x07\x4a\x02\x6e\x2b\x88\xce\xaa\xe1\xca\x12\x34\x63\xcf\x29\x42\xf4\xeb\xa5\x22\xde\x35\x13\x54\x97\x0c\xf4\xc8\x35\xcd\x84\xdf\x82\xaa\xd0\x91\x97\x41\x4e\x27\xec\xbc\x78\x46\x4b\x2b\xce\x0a\xbf\x49\xa6\xb4\x1e\xf2\xab\xa8\x4f\x1b\x55\xd7\x38\xe7\x62\xcc\x86\x42\x3a\x0c\x03\x76\x64\x34\x19\x0a\xd4\x09\xe1\xce\x7b\xcd\x41\x37\x8f\xeb\x5b\x41\xa7\xa0\x99\xa2\x36\x46\x82\x08\x9f\xb3\x01\x3c\x09\x0b\xe6\x0d\x58\x4f\x44\xe5\x15\x61\xcf\xad\xdb\xae\x83\x44\xc9\x12\xa8\x20\x41\xa0\x80\xc1\x9d\x58\x9c\x2c\x17\x51\x51\x67\xb1\x8e\xa3\xae\xe5\xb4\x62\x5c\x07\xe3\xb1\x5c\xce\x13\x4e\xfe\xc9\xea\x44\x2f\x9c\xe9\xfd\xdb\x0a\xb2\x80\x96\xd0\x53\x47\x86\x91\x55\x8c\x9d\xa9\x06\x69\x11\xfb\xeb\x74\xc1\x4e\xa8\x50\xb3\x8f\x1e\x39\x07\x3a\xba\x17\x8d\x8b\x1b\xe4\x65\xa7\xac\x94\xcf\xd0\x56\x00\xae\x28\xd5\x31\x58\x31\x45\xad\x6e\x34\x78\x52\xe8\x08\x98\x04\xab\x67\x84\x94\xc6\x70\x70\x41\x79\xa2\x7e\x08\x1c\xe3\x17\x0b\x43\xc3\x2c\x1f\x83\xa8\x01\x64\x4c\x16\xfb\x85\x26\x3f\x18\x23\x52\x18\x09\x15\xd3\x3a\x9b\x64\x7f\x09\x81\x1b\xf8\xb7\x83\x05\x23\x84\x5a\xa6\x49\xed\x3c\xcb\xf8\xf6\xd1\x31\xa7\x8c\xa0\xe1\x0a\x37\x0f\x83\x27\x73\x7a\xb3\x12\x01\xa3\xa5\x49\x04\xf8\x60\xa9\xe1\x1a\x0c\x91\x9c\xed\xa7\xf8\x1f\x7b\xbe\x0f\x6c\xc0\x20\x35\xe5\x46\x49\xe0\x68\x9e\x65\x2d\x04\x26\x72\x43\x4f\x84\x23\x35\x70\xaf\x18\x9e\x3b\x1b\xa7\x44\x84\x9a\x01\x79\x04\x3f\xa3\x54\xb8\x5c\x83\xfb\x3e\x27\x1a\xa7\x68\x50\x22\x09\x13\x65\x3b\x53\xc8\xa7\x97\x37\x2b\x34\x27\xc1\x18\xe6\x22\x5c\x76\xcb\x99\x18\x88\x40\xee\x8e\x63\xe0\x05\x98\xff\xa6\xb3\x6f\xd0\xb6\x5b\xfc\x72\x57\x0c\x1f\x88\xf7\xd4\xb9\xd8\xf1\x9d\x40\xd7\xf6\xad\x0b\x6a\x57\xc1\x9d\x92\x54\x84\x4a\xe1\xf0\xb1\x96\x01\x4f\x41\xc6\x8a\xc7\xf2\x50\x21\x56\xe4\x31\x67\x68\x82\xa1\x46\x6c\x3e\xa2\xa0\x23\x78\xa8\x23\x6d\x35\xad\xaf\x81\xfb\xe6\x66\x0c\xde\xd9\xb2\x48\x77\x75\x5a\xed\x87\x92\x94\x2c\x7f\x25\x9a\x76\x8b\x64\x45\xbe\xbd\xd5\x22\x5a\x31\x04\x3e\x97\x99\x92\x76\xc9\xc1\x83\x9b\x9f\x35\x8f\x35\x9b\x40\x9c\x4c\xa9\xbd\xac\x45\xdc\x8a\xee\xc7\x6a\x44\x75\x70\x1f\x46\x33\xcc\x69\x4c\xd2\x02\xa6\x2b\x78\xd2\x67\x1c\xcb\x34\xb9\x56\xe3\xe0\x5c\x36\xf2\xae\x20\x80\xae\xcc\x6c\xe3\x79\xaf\x56\x02\x71\x9b\x7d\x59\x2c\x9c\x5e\x54\x2d\x5d\x7c\xf4\xc8\xe1\x34\x37\xc7\x92\x33\xa9\x07\x02\xda\x1b\x22\x63\x60\xbf\x96\xf8\xb4\xd1\xba\xda\x3c\x96\xd7\x65\xc6\x2a\x5b\x42\x2a\xfd\x01\x9a\x94\x3d\x71\x36\xdf\xb6\x76\x85\x5a\x0c\x15\x1a\x5f\xbf\xc4\x20\x14\x1b\x73\xb0\xf4\x06\x8b\xfc\x59\xce\x3e\x4e\xd1\xd1\x14\x09\x9d\xaa\xe7\x1c\x16\xf9\x0d\x2b\xc1\x1e\x13\x4c\x46\x2a\xf6\xe7\x8c\xe5\x09\x7b\x04\xa3\x8e\xc7\x70\x89\x8f\xd8\x9c\x89\x36\x6c\x25\xa3\x88\x4d\xd0\x03\x3f\xfb\x07\x4a\x57\x3c\xdf\x50\xa4\x3a\x6d\x2c\x8c\xe9\x1f\x61\xca\x67\x95\xc9\x97\x86\x0e\x27\x32\x36\x4f\x88\xbe\xe5\x09\x0a\x8d\xf2\x55\xcd\xa6\xe6\x77\x96\x69\x7a\xd7\x71\x6e\x87\xd9\x98\x39\x5e\xc7\xe3\xc5\x8c\x26\xad\x87\xe5\xcc\x7d\x92\x47\x8c\x97\xc7\xb7\xe6\xf4\x78\xbf\xe4\x8c\xf1\xf3\xab\x5b\xf8\xaf\x1d\x34\x25\xe4\xd6\xe2\xdf\x95\x4b\xc9\x76\x42\xa3\x5a\x24\xb6\xb9\x19\xae\x9c\x05\x33\x5b\x7a\x97\xf0\xbb\x18\x80\x49\xb8\xce\x52\x27\x29\xc6\x63\x86\x94\x90\x81\x6d\x09\x0a\x22\x24\xff\x2b\xfc\x57\x10\x9e\xf8\xc7\x83\xc1\xc9\x9e\x9b\x2d\x46\x57\xd2\x00\x54\x0d\x19\x22\x70\x38\x9d\x2b\x21\x89\xd0\x62\x05\xf5\x9a\x79\x51\x0b\xc1\xaa\x61\xf1\x8d\x3b\xef\xc1\x4d\x11\x38\xff\xaa\x7c\x84\xfd\x66\x7f\x7c\x41\x1b\x0f\x08\xf2\x8b\x61\x73\xf5\xf5\x40\x3e\x2e\xf3\xfd\x40\x05\xbe\xf8\x8c\xe0\x26\x71\x36\x7d\xbe\x34\xcb\x4d\x27\x68\x74\x43\xd4\xfa\xaf\xb1\x4b\x34\x01\xc9\x92\x4b\x08\xe8\x30\xb0\x88\x74\x1f\xe6\x54\x4a\x96\xe0\xa3\x1a\x53\x96\xe0\x1b\xe0\xb4\x72\x3e\xd8\x42\x78\x0c\xd5\x03\x91\x5e\xe0\x61\x23\x20\xa6\x62\x66\xd4\x11\x24\xb6\x43\xeb\xba\xcc\xe2\x59\xcd\xaa\x40\x08\x9a\xb6\x9d\x0f\x2d\x10\xed\xb5\x78\x52\x43\x74\x7d\xff\xc3\xc3\x2a\x8d\x59\xbf\x7e\x43\x73\xa6\x32\x75\x6d\xe9\x60\xfd\xa1\x71\x2c\x50\x7a\xae\x03\xc6\x29\x2d\x84\x92\x3a\x73\xce\xc1\x98\x8c\x08\x8b\xc4\xf2\x3a\x2b\x0d\xb6\x01\xc2\xb3\x35\x9e\x04\x41\x6b\x70\x9a\x24\xb3\xc9\x0c\xdf\x3a\x87\xf8\xb8\x34\x9f\xa3\xfb\x0c\x9c\x40\xde\x8d\xf2\xfe\x91\x5c\x0f\xae\x28\xbc\xa6\xc0\x79\xd9\x1b\xba\xea\x59\x73\x0f\x87\xa6\xd4\x49\xf7\xf3\x58\x17\x8a\xb5\x9a\x4d\x35\x87\x02\x03\x53\x5c\xd6\x27\xf9\x2b\xf9\x17\xac\x88\xd5\x62\xfc\x77\x19\x27\x83\x38\xfc\x04\xa7\xd4\xe0\x46\x2c\x3d\xb7\x18\xde\x4e\x53\x7f\xf4\x69\x4e\x6d\x73\xf3\x7e\x3c\xab\x4f\xd9\xcf\x2c\xe7\xd7\x08\x73\x28\xca\x61\x6b\x11\x83\x95\x43\x16\x3a\x94\x80\xc9\xa6\xe9\xe1\x8f\x5e\x77\xfc\x16\x6e\x73\xa6\xd2\x05\x0f\x8c\xdf\x18\x61\x11\x0c\xbd\x05\x77\xee\x50\xf1\xf8\x93\x14\xc8\xaa\x46\xe4\x66\x64\xf0\xfc\x09\x3e\x82\x22\x41\x1d\xdf\x1d\xea\x5b\x95\xa5\x13\xa2\x8c\x6c\xd8\x2a\x02\xb6\xb7\x6c\xe5\x8a\xd3\x8e\x83\xd0\xab\x8e\xcb\x51\x20\x6f\xc6\x6f\x20\xe0\xcf\xf8\xea\x80\xca\x00\x4d\x35\x6e\x99\x11\xb8\x2c\x1e\x67\x79\x3a\x9e\x5b\x8e\x57\x2c\xaf\x66\xa5\x34\xab\x10\x4e\x22\x18\xfa\x36\x1e\x17\xc9\xc8\x99\x16\x9c\x41\xc9\xe8\x58\x06\x56\x3c\x3e\xc7\x50\x59\x1b\x8d\x57\x58\x54\x2c\x88\x26\x6f\xa6\x72\x4c\x85\x97\xd6\xb2\xa1\xff\xb3\x05\x57\xf8\xd8\xd3\x38\x4b\xb2\x1a\xa5\xb6\x4d\x89\xb2\x67\x55\x17\x22\x18\xe4\xd7\x26\xba\x1e\xf8\xb5\x95\x13\xe0\x79\xc5\xf3\x59\xb8\x65\x82\x37\xa9\x58\xad\x61\x16\x72\xac\x47\x60\x6d\xaf\x58\xf1\x24\xe7\x39\x88\x9e\x01\xaa\xbd\xb8\x28\x46\x2f\x18\x9b\xc2\x25\x22\xc9\x08\xcb\x27\x56\x08\xb1\x8c\x82\x20\xd7\x6a\xc8\xe7\x1a\x25\x54\xa0\x94\x0d\x14\xed\x29\x5b\x04\x83\x45\x25\x8d\x1a\xe2\xb9\x58\xe3\xdc\x9c\x00\xf5\xc5\x2a\x85\x75\xbf\xf8\x92\x92\x67\xe8\x73\xf4\xb3\xa8\x91\x51\x44\x7a\xbf\xe0\x09\x43\xe3\x12\x51\x51\x3e\xc5\xba\x3e\x9b\xe5\x89\x22\xe4\x10\xc2\x1b\x91\x3a\x39\x7a\x14\x8d\x38\x63\x46\xfb\x1a\xbb\xfe\x2d\xa9\x9b\x7a\x73\xef\x6b\xde\x71\xed\x2f\xcd\x11\x35\x50\x87\xc8\x69\x43\xdc\x76\x56\x03\x01\xcb\xcc\x55\xe4\x6b\xf4\x45\x1a\x6d\x3c\x18\xfd\x5a\x26\x09\x1b\xeb\x44\xee\x6b\x45\xff\xf0\x00\xa6\x83\xff\xde\x37\x1c\x53\xc6\xda\x7e\x93\xac\x1e\x91\x76\x12\xfa\x81\xb2\x65\xfb\xfc\x4d\xe8\xd4\x68\xf8\x24\xaf\x0b\x59\xaf\xed\x18\xc2\x1f\xcb\x7a\x52\x09\xa5\xcd\x83\x53\xb6\xcb\xd8\x1b\xa5\x5a\x05\xee\x7f\xe3\x58\x8b\x11\x4d\x40\x4a\x74\x28\x98\xa0\xcf\x3d\xe9\x6d\x62\x0f\xa3\x45\x25\xf9\x98\xd0\x29\x5f\xac\xf7\x59\x3d\x7c\x21\xe7\x71\x22\x1c\x43\xcd\x0a\x44\xac\x90\x5e\x3b\x62\xbf\xe5\xd8\xfe\x9a\xaf\x6d\x06\x63\x4e\xa9\xc5\x26\xae\x61\x38\xd1\x36\x5c\xa7\xb1\x2c\x2d\x36\xb2\xe6\xa0\xb5\x3d\x1d\x5f\x21\x27\x2e\x44\x34\x5f\x51\xc8\x47\xef\xdf\x71\x8a\x6c\x02\x4a\xd9\xe6\xc2\xc5\x8b\x38\x7f\xcc\xaa\xda\xa1\x95\x6e\xa4\x05\xbe\x15\x29\x9a\x16\x70\xd0\x0b\xc9\xdb\xac\xc8\x29\x34\xf8\x6c\x59\x2b\x01\x37\x5c\xb7\xeb\x78\x1d\x64\x7b\xa4\x64\x45\x45\xfe\x68\x94\xf5\x9d\xfd\x35\x5a\xc4\x95\x82\x5b\xce\xe6\x23\xce\xd1\x6c\x02\x77\xa3\x80\xde\xb6\x87\xe0\xbb\x8a\xaa\x0b\x73\xc1\x57\x55\x3e\xf7\x42\x8a\x3e\xe5\xc0\x68\x12\x67\x2a\x74\x84\x00\xf8\x2a\x18\x72\x43\x3d\x9d\xaa\xf3\x84\x7c\x2f\x1a\xfa\x43\x52\x03\x3c\x9a\xe5\xdb\x17\x00\xeb\x8a\x79\x7f\x21\xbe\x13\xe3\xb7\x3a\x6c\x4e\xe3\xd3\xb8\x6e\x2d\x3a\xfa\xfb\x28\x4f\x5c\xe0\x20\xc6\xf9\xdf\x79\x69\x4f\xe8\xb4\xed\xc2\x36\xf4\x8c\xf2\xc2\x06\xa3\xb0\xff\xdd\xb7\x36\xc7\xc9\x7c\xa0\x13\x3a\x55\x56\x09\x4d\x7f\xf9\xa4\xe5\xe6\x36\xe6\x63\x13\xe6\xd2\x90\x4c\x3c\x90\x2b\x06\x22\x5f\x80\x28\x4a\x70\x04\x85\xee\x8a\xbe\x12\x05\xda\x17\xff\x84\x4e\xdb\xee\xc9\xd5\x23\xf3\x85\xd7\xbc\xba\xd4\x2e\x41\x1c\xfb\xc0\x13\x2c\x11\xbd\xb8\xf3\x57\x20\x5f\x74\x58\x0a\x4d\xbb\x61\xd2\x8f\xd1\x5a\xdb\x79\xd0\x4f\x40\x28\x44\x20\xfe\xe7\x81\x14\x2e\xc4\x2f\x86\x26\xb9\xd5\xf7\xb3\xd7\x8d\x4d\x85\x2e\xdb\x18\x69\x73\x43\xd7\x73\xc2\x46\x8d\xb5\xf7\xeb\x6b\x45\x93\xd9\x91\x52\xc6\xb4\xae\xc1\xc6\x4b\x4d\x4f\x86\x9e\x78\x20\x5a\x80\x0b\x71\x03\x1e\xda\x46\x9f\x0c\xcb\x70\x86\x4e\x79\xf1\x52\x3c\x75\x50\xb2\x6d\x14\x59\x9b\xeb\xf0\x37\xb7\xab\x2e\x84\x3a\xcc\x92\x4f\x14\x0d\xad\xcd\x2a\xd1\xf6\x37\xe0\xfb\x61\x44\xcc\x5a\x98\x17\x85\xf1\x69\x81\xac\xac\xa4\xf0\x12\x04\x04\xed\x32\x59\x20\x3a\x6e\xb4\xdd\x2b\x2a\x0a\x31\xa8\xa0\x7c\x0c\xa7\xc8\x99\x6e\x08\x03\x4a\xc8\xa6\xfe\x81\x65\xe6\x5d\xb4\x84\x44\x54\x61\x1a\xa8\x1c\x32\x88\x05\xd4\x46\xd0\xaa\x9a\x4d\xe4\x90\x1b\x66\x56\x03\x56\x57\x68\x3e\x05\xb2\x3c\x0e\x2f\xc5\x8c\x97\x42\x6d\x67\x49\x54\x54\x4e\xa1\xee\x55\xcd\x8b\x38\x33\xe6\x1b\x0f\x18\xad\x47\xbd\xcc\x47\x6f\xe9\x5c\x3a\x3d\xd4\x59\x32\x1b\x83\xae\xa1\x9c\x25\x20\x70\x68\x9c\xc4\x56\x63\x5f\xfb\xb8\x9b\xfb\xa2\xda\xb1\x4f\xbc\xa9\x81\xc1\x73\x8f\x9b\x0b\xf4\x22\xdf\xa0\x0f\x66\x89\x0f\x0a\x71\x98\xaf\xc3\x5b\x4d\x1b\xf0\xcc\xeb\xa3\x84\xc0\x86\xe8\x4e\x83\xfe\xd5\xb9\x6d\x71\xfd\x31\xa6\xce\xa1\xb9\xa5\x8e\xd2\x3c\x81\x62\x00\x8c\x0a\xf4\x3e\x59\x81\x92\xc4\x3d\xdb\x88\xd3\xbf\x72\x95\x08\x73\xb2\x14\xe2\xe0\xc5\x3a\x9c\xac\xb4\x26\xd6\xe6\x7d\x18\xa5\xc6\x32\xf7\xd6\xf1\xbf\xa4\x21\xdf\x7f\x72\x54\x08\x80\x1e\xc2\x5b\xf1\x52\xe4\x84\x9b\x27\x3c\x75\xf6\x9d\x4d\xc7\xa3\x18\xe5\x0a\x93\x7a\xfd\x6c\xcc\x78\x9b\xfa\x95\xe0\xff\x7f\xef\xeb\xcb\xff\xfc\xe7\x3f\x8f\xae\x1e\x11\x41\xe3\x6e\x06\x46\x85\x71\x96\xb3\xd7\x88\xae\xb7\x9c\x4d\x9f\x53\xc2\x6a\x60\xd8\x81\x8c\xed\x10\xa3\x6a\x44\xe7\xca\xf2\x9b\x32\x20\x7c\xab\xe8\x8d\x17\xf5\xfa\x59\x2c\x03\xe1\x1a\x66\x23\x90\xda\x43\xa7\x4b\x5b\x14\xb6\x62\xa6\xd1\xb8\xc8\xa5\xa3\xe6\x72\x5d\xb5\x15\xc5\xa9\x51\x71\xad\x3b\x68\x68\xbb\x4f\xa2\x45\x89\x89\xc6\x34\x34\xbf\xc3\xd0\x21\xf8\x2c\xb6\x7c\x5e\x4b\x1c\x63\x87\x96\xa0\xbe\xa7\x0a\x90\xb4\xf3\xa2\x88\x83\x22\x23\x8f\x20\x4e\x44\xf7\x0b\x29\xe1\x2f\xcc\xa8\x3b\x3d\xf5\x0e\x67\x96\xd7\x2c\x17\x0e\xf5\xf8\xe0\x08\x70\x55\x00\xd3\x59\x0e\xd1\x43\xf0\x81\x12\x11\x68\x43\x45\x9d\x81\x58\x4a\x15\xc7\x57\x09\x2e\x10\xc8\x38\x45\xac\x97\x31\xcd\x07\x33\x3a\x60\x15\x0a\xff\xa9\x7a\xdb\x1c\x63\xa9\x7c\xfd\x48\x3f\xba\xad\x62\xe8\x88\xb9\x67\xf9\x40\xfb\x52\x2a\xcb\x76\x11\x30\xf2\xc8\xf2\xd0\xd5\x47\x40\x86\xaf\x30\x38\x5a\x15\x04\xc9\x26\xd9\xf4\x89\xf8\x1f\x70\xfd\x08\xa5\x5f\x43\x63\x58\xf4\x75\x10\xa5\x16\xab\x9e\x66\xb6\xb0\xef\x69\xe9\x83\x93\x1d\x9f\xea\xa2\xb7\x16\x2c\x9b\x01\x38\x7a\xda\x93\xd8\x68\x6d\xa5\x19\xb4\xae\x79\x76\x76\xf0\x73\xab\xb3\xb3\x1c\x1c\xa2\xb1\x67\x25\x1d\x80\x3d\xb8\xd5\xee\x3d\xfd\x37\xe1\xdc\xca\x5b\x41\x2c\x56\xb4\x3b\xbd\x91\x0f\xf3\x47\xa8\x84\x83\x83\x54\xcd\x02\x2d\xbe\x16\x5e\x6c\xcd\x6e\x8e\x30\x62\x03\xcd\x7d\xb5\x4d\xf5\xb9\x74\xde\x5b\x5f\x5c\xb9\x1b\x0a\x95\x36\x8c\x74\x2b\x5a\x83\xaf\x05\x8e\xbe\xaf\x39\x0b\x7f\x8b\x70\xa6\x36\xb6\x83\x1c\xdf\x12\x21\xa8\x6e\x1f\xac\x4c\x86\xcd\xd9\xb4\xec\x8c\x2a\xe9\xcd\xa1\x77\xa8\x15\x82\xfe\x31\x77\x80\xbe\x04\x39\xed\x10\x10\xab\xae\xdf\x1d\xbc\x3c\x39\xd2\x5d\xcb\xe8\xc0\x39\xbb\xe5\x7c\xb7\x77\x79\xb9\x29\xef\xc8\x4d\x02\x96\x14\x57\xc4\xb9\x14\xa1\x36\xe1\xf3\xca\x5f\xe7\x58\xf2\x19\x53\x78\x80\x6b\x09\xb4\xf6\x20\xe7\x12\xeb\x06\x3b\x62\xc9\x98\x62\x78\x21\x78\x7d\xdd\xd8\x1a\xc9\x6e\xae\x75\x19\x35\xcf\x86\x86\x6f\x1b\x4a\xd6\x57\xd6\x67\x28\x37\x1e\xe5\x33\x49\x84\xff\xe4\x87\xea\xed\x68\x61\xdd\x20\x42\x3f\x16\x7d\xe7\x03\xbf\xa6\x73\x71\x43\x7f\xe8\x99\x27\xdb\xa0\x33\x36\x6d\xd9\x30\x07\x40\x00\xec\x93\xbc\x5f\xd8\xf3\x15\x78\xc3\xf0\x22\x35\x90\x99\xf6\xb4\x94\x6a\xa9\x95\x0c\xcb\x41\xd3\xcc\xd5\x21\x67\x5a\x3d\x35\xdb\x7c\x92\xed\x7a\xa1\x2a\x27\xe9\x1e\x27\x7a\x30\x25\xa4\x2b\x1b\x34\x50\xb4\x4a\x17\x59\x47\xd0\x58\x7b\xfd\x50\x8a\x20\xc1\xd4\x18\x24\x89\x65\xd3\x56\xbd\xcd\xb0\x75\x0b\x04\x75\x01\xa6\x5c\x99\x70\x56\xda\x04\x5f\xa5\x11\x03\x72\x15\x94\x71\x9c\x2b\x65\xf0\x84\x4e\x3a\xcf\xe9\x24\x4b\x90\xe9\xac\x2c\xa6\xa9\x80\x40\x86\x82\x9f\x05\x71\xad\x65\x3e\x22\x88\x09\x88\x2c\x58\x89\xd0\x82\x23\xc6\xa6\x3a\x2a\xbc\x6a\x29\x66\xf5\x2d\x63\xf0\x20\x1c\xc6\xf8\xaf\x74\xbc\x76\x40\x6f\xcf\x69\xf5\x82\xcd\xdf\x56\x4c\x47\x3e\xbd\x5b\xa1\x01\x11\x9e\x15\xd8\x03\x58\x71\xf8\xf2\xd0\x33\xfb\x62\x3e\x35\x14\x7d\x59\xde\x2f\xc4\x3d\xb0\xf6\xe4\x29\x3a\xb1\x63\x3e\x06\x03\x81\x03\xa0\x45\x3b\x22\x88\xee\xc5\x26\x0e\xf6\xcd\x9c\xc0\xf8\x68\xde\x98\x46\x4e\x6e\xbd\x5a\xaf\x7b\x33\x3c\xa0\x71\xfc\x8d\xd3\x59\x17\xd3\xed\x31\xbb\x61\x63\x79\x4e\x41\x95\x8c\xc6\x7a\x3f\x72\x20\x31\x06\xbe\xe5\x6c\xfe\xb4\xe6\xb8\xf2\xc6\xd7\x40\x8b\xa2\x70\xd2\x82\x55\xf9\x66\x8d\x2e\x3b\x10\xc9\xd0\xd0\xe3\x9a\xaf\xd3\x21\x69\x87\xc0\xc0\x74\x08\x02\xc3\xd6\x16\x1e\x71\x12\x62\x0d\xa4\x28\x07\x65\x71\x8b\x11\xeb\x86\x65\x96\x8f\x9c\xa2\x14\x54\x68\xc9\x84\x18\xaf\x07\x96\xdb\xb6\x2c\x8b\x0f\x85\x0f\x89\x8e\x4b\x46\xd3\xb9\x13\x33\x96\x2b\xe2\x37\x05\xe8\x2c\xd9\x9f\xb3\xac\x84\x81\xf1\xe6\x70\xf0\x8e\x3b\x62\x73\x57\x7a\xc7\xaf\x8c\xde\x01\xb0\x00\xa2\x76\x56\x89\xe0\x0f\x09\x85\x07\x19\xab\x82\x13\xe2\x08\x93\x2a\x00\xad\x7c\xea\xac\x82\xb8\xc7\x05\x38\xef\x09\x2e\xd8\x08\xf0\x69\x3f\x40\xab\x18\x5b\xb9\x42\xca\xad\x90\x4f\x4c\x8c\xba\x42\x93\x8a\xa6\x8c\xd4\x00\x2f\xe9\xc4\x57\x89\xc4\xcd\x4a\x45\x41\x31\xd8\x5d\xb9\x24\x52\x65\xff\x82\x19\x71\xeb\x9a\x87\x05\xe0\xbf\x11\xec\xd1\x20\xef\x30\xa5\xa7\x57\xd9\xc8\x6b\x31\x14\x40\x00\x93\xa8\x69\x6d\x23\xea\xf5\x13\x8b\x19\x58\x3d\xda\xe2\xa6\x7b\xc8\xc9\x97\xda\x8c\x56\x7c\x72\xb9\xb6\x87\xab\xf6\x91\x7f\x6e\x2b\xe6\x8c\x1e\x3d\x72\xde\x56\xf8\xb6\xe7\xca\xbb\x18\xf2\xf9\x8b\xa2\xdf\x87\x03\x2c\x9e\x86\x03\x4b\x75\x9a\x24\x6c\x5a\x1b\x2a\x06\x5a\xc9\x68\x1d\x12\x74\xe1\xd9\x4d\xf1\x34\x25\xb4\xcd\xb9\x69\x15\x8a\x43\x08\x86\x38\x48\x6d\x56\xcd\x30\xa8\xd8\x10\x82\x3e\xb8\x1f\xd4\x0a\xda\xb4\x69\xa1\x7c\x30\x43\x2b\x87\x24\xbc\x1a\xc1\x20\xae\x15\xad\xda\x48\x81\x80\x4b\x9f\x22\x62\x1e\x3d\x72\x7e\xce\x84\x17\x60\xc3\xda\x47\xc6\x1f\x19\xcf\x55\x08\x48\x90\x57\x49\x0d\x85\xb4\x50\x55\xa3\x84\xe7\x43\xa9\x62\x76\xa9\xf4\xa2\x29\x8b\x09\xdc\xa1\x2b\x54\x92\x3d\x60\xdf\xbc\x48\xf5\x5b\x1f\xed\x3c\xa9\x0a\x86\x28\x0d\x45\x9b\x21\xce\x8f\xb5\x1b\x8f\x81\xfb\x38\x6a\x53\x56\xbd\x22\x70\xa5\xc0\x4a\x18\x87\xd7\x40\x4e\x60\x1f\xba\xf9\xaf\xea\x5f\x95\x25\x6a\x34\x43\x8c\x8b\x4e\xb7\xe1\x3a\x06\x65\x09\x3f\xaf\x66\x40\x62\xb4\xdb\x5c\x07\xa8\xc4\x58\x41\xb2\xc2\x91\x09\x1b\xe6\xe5\xa7\xd6\xa2\x29\xcb\x38\xce\xf1\x05\x3a\xbe\x89\x22\xfc\xaa\x28\xcb\x32\x8c\x98\xac\xf6\x08\xed\xc0\x50\x7e\x00\x01\x23\xc0\x95\x11\x16\x0c\x24\x90\x86\xec\xdb\xbe\x73\x2a\x8d\xbf\x05\x65\x47\x60\x6d\x73\xe3\x5d\xcc\x31\xac\xf4\x18\x31\x75\x2d\x04\x23\xe8\xa7\x25\xc3\x88\x7c\x12\x53\xbf\x2e\x52\xb6\x74\x72\x4e\x89\x9d\xc3\x30\x01\x1e\xc5\xe8\x71\x7b\x8b\x3e\xbc\x52\xa3\xe2\x4f\xb5\xe3\x6a\xde\xc4\x03\x11\xf5\xa1\xd0\x13\x57\x1e\xaf\xd4\x8e\xa3\x05\x15\x02\x03\xeb\xb4\x18\x36\xdb\xf8\x6b\xd5\x14\x81\x57\xbc\xd7\xfb\x82\x17\x68\xf7\xbc\x50\xe8\x81\x6f\x7d\x91\x32\xc3\xf3\xa2\xc5\x88\x20\x69\x98\x0f\x38\xad\xf7\x91\x50\x54\x36\x10\xb8\x63\x07\x2c\xd1\xc2\x8e\x46\x1f\xd6\x64\x64\x80\x64\x09\x73\x06\x46\x00\x68\x43\x28\x90\xc0\xd6\xd3\xec\x10\x9f\x30\x5e\x4d\x7a\xb4\x46\x62\xcb\x7d\xd5\x32\x32\x18\xca\x03\x1d\x3c\xbe\xda\xe5\x58\x13\x96\x70\x25\x07\x1c\x3c\x20\xab\x9d\xeb\xfc\x22\xf7\x8e\x47\x8f\x9c\xe3\xbc\x2e\xe7\xaa\xac\x7e\x44\x53\x3e\x2c\x9d\x19\xf6\x79\x95\x61\xbe\xc1\xef\xa5\xbc\xb8\x75\x6e\x99\x33\x2d\xb3\x1c\xd4\x0f\x8c\x03\x7a\xcd\x24\xea\x93\xcf\x5c\x4d\x9c\x31\xbc\xfc\x69\xc2\x84\x1e\x1b\x70\x73\x7c\x55\x5b\x1c\x43\x3e\xe1\xf3\x00\x6b\x1b\x5a\xa5\x4d\x8f\x87\x2f\xf0\x70\x68\x85\x58\xed\xee\xe0\xdb\x65\xdb\x41\x57\x17\x6f\x85\x5f\xc7\x8a\xcf\xd7\x16\x86\xc7\xb0\xa5\x85\x40\x76\x54\x49\xda\x88\xea\x50\x7a\xa5\x55\x42\x9e\x8b\x7e\x83\x4a\xc0\xcb\x7b\xac\x10\x11\x66\xc2\xc1\xf8\x6b\x6d\x11\x20\x6c\x2b\x25\xc6\xf9\x24\x35\xda\x8e\x95\xde\xc8\x7e\x6c\x39\x2b\x60\x03\x79\xb1\x1c\xc2\xdb\x0e\xd1\x8a\xa4\xb2\xcd\x10\x15\xcb\x76\xee\x11\xa8\x9b\x9a\x74\x21\xe8\xb0\x6b\x37\x59\xaa\x46\x6e\x6e\xf8\xc6\xe9\x55\x5a\x69\x44\x65\x29\x06\x50\xa5\x28\x87\xc4\x07\x92\x02\x0e\xca\xbf\xf5\x52\xa9\x96\x1a\x91\xe6\x08\xbe\x1c\xb2\x89\x06\xa9\xab\x57\xaf\x00\x9f\x07\x5c\xbb\x2b\x7a\x8a\xc6\xec\x80\xe5\x35\x63\x72\xb5\x2e\xb8\xa4\x5e\xee\xaf\x2c\x1f\x24\x81\xcc\x83\x29\x07\x30\x7e\xef\x6e\x36\xfb\x90\x4a\x54\xa1\x44\xb0\x1f\xe6\x15\xcf\x50\xe0\xf6\x03\x89\xa3\xe1\xb6\xea\x39\x6f\x2b\xa6\x49\x02\x75\xc7\xf3\x55\x4a\x9d\x0f\x66\x90\xac\x0f\xca\x2f\x6b\x73\xc5\xc7\x5b\x1c\x24\x47\xca\x18\x57\x0f\x12\xfa\xd0\x0a\xd6\x4d\x9d\x14\x20\x13\x64\x25\xe3\xa5\x86\xd6\xd3\x22\xcb\xb5\x1f\x17\x29\x51\x87\xb1\x7a\xb2\x2c\xae\xf7\xbd\xdb\x2a\x8b\x2a\x76\xe8\x5a\xa2\xb1\xd7\x9c\xaa\x1b\x1f\xe2\xeb\xcd\xbc\x2f\x7d\x0f\x41\xb9\x34\x4b\x4f\x44\x51\xe4\x61\x23\xfd\xca\x95\xd5\x90\xcc\x35\x9e\xb4\x02\x83\xaa\x79\x93\x1e\xb8\x36\xb0\xb1\xe9\xbe\x23\xc7\x28\xc2\x26\x5e\x36\xc4\xa5\x57\x9e\x4f\x9c\x6b\xc0\xcd\x4e\xc7\xbb\x6f\xfc\xde\xb5\x40\xd5\xd7\xed\xb8\x3a\xfc\xe4\xec\x6d\xba\x04\x23\xe4\x5d\x9b\x1e\x6b\xc6\x35\xd4\x69\x13\x2b\xf7\x86\xb4\x82\xd0\x2d\x26\xb2\x6f\x52\xf3\x27\x39\x92\x0d\x7c\xbe\xce\x87\x7f\x55\x1f\x40\x95\x35\xce\xf0\xf2\xfc\x60\x2b\x51\x3e\xf4\x0c\x2f\x42\x95\xaa\x21\x0e\x08\x7e\x7c\x70\x0b\x5f\xf7\x96\xd6\x1f\x22\x06\x18\xd0\xec\x60\xb3\x75\xaf\x57\x61\x5c\x32\x3a\x6a\x23\x93\x12\x5a\x27\x43\xc7\x63\x65\x29\xa7\xd4\x06\x1a\x9a\x84\x59\x81\x0b\x56\x96\x68\x38\xda\x17\xfc\x97\x0c\xb9\x30\xb7\x42\xf2\x75\xd6\xef\x4d\xb7\xab\x5b\xbd\xdc\x44\x74\xbe\x79\x65\xae\x70\x4b\x76\xd3\xc9\xad\xd9\x3f\xf6\xba\x32\x17\xb3\xd5\x7a\x58\x16\xb7\x8d\x09\xb5\x2c\x91\x44\xf4\x0a\x8e\xe5\xbb\x77\xa6\xf0\x62\x1d\x0c\x28\x5f\x2f\xf1\x84\xd5\xbd\x90\x00\x7b\xb9\x96\xb1\x7a\x30\x67\xd5\x1e\xee\xfe\x7d\x56\x0f\xdf\xa9\xb7\x32\x44\x14\x5e\xf9\x52\xec\x8a\xb1\x0e\x8c\xfe\xc2\x0a\xaa\xb0\x36\x62\xc1\x9a\x90\xc7\x6d\xb9\x15\x9c\xfd\xf6\x3c\xa1\x12\x0d\xd5\xc3\xb1\xb7\x20\x5a\x14\xde\x50\x09\xad\x18\x10\x96\xe8\xcf\x02\x7b\x07\xbe\x2f\x68\x46\x61\xc9\x1f\xf1\xd5\x16\x30\x46\x12\x11\x0f\x66\x49\xc2\x84\x27\xb0\xf1\x54\x90\xf0\x07\x8e\x19\x07\x62\x4e\xe0\x66\xb9\x10\x8e\x4a\x87\x98\x8e\x5a\x07\x8b\x4e\x17\x02\xd6\x4d\x9b\xae\x6e\x04\x81\x6c\x9b\xa3\xe1\x4a\x03\x89\xa6\xba\xc2\xc4\x99\xf0\x82\xab\x0c\x68\xc2\x6b\xee\x34\xc4\xbb\x5b\x91\xb3\xe9\xfc\x5e\xcc\xe4\x1c\xfa\x45\x39\x28\xd0\x07\xe8\x23\x68\xcd\x85\x52\x40\x0a\x49\x54\x28\xd2\x3e\xa7\x7a\x39\xc6\x71\x21\x6c\x81\x1c\x6c\x96\x03\x4b\x0c\xde\xaa\xe0\x6c\x07\x78\x67\x92\x7d\x64\xa9\x33\x9b\xaa\xd0\x94\x7c\x01\xf1\x7a\xcd\x26\xbc\x9b\xaa\xe7\x5a\x21\x45\xb5\xa6\x44\x8b\xe0\xd6\x69\x73\xcc\xc7\x25\xf8\x12\xea\x7a\xab\x73\xd5\x79\xad\x3a\x67\x59\xec\x13\x22\x7b\x63\xa0\x46\x8d\x35\xea\xce\xd6\x63\xdd\xf2\x36\x16\x06\xeb\x46\xb1\x35\x9e\xf9\xed\x6d\x6d\xdb\x43\xa5\x93\x9b\xc7\xef\x49\xc0\xf4\xb1\x7c\xed\x48\x3f\x55\xeb\x83\x1f\x24\x92\x3e\x8f\xb4\x62\x1b\x5e\x20\xe2\x85\xaa\xac\x66\x8d\x27\xf7\x2b\x1f\x4e\xc3\xa0\xa8\x03\xe7\x5f\xe2\x1a\x10\x70\x86\x10\x85\x11\xc7\x45\x2c\x71\x01\x84\xe2\xe9\x7a\x2b\x4a\x84\x7e\xfa\xc9\x9a\x56\x8f\x4e\xa7\xe3\x39\x78\x93\x12\x1d\x8a\x52\x05\x3d\xbe\x00\x7d\x1f\x18\xf4\x09\x2f\x4f\xde\x69\x56\x0d\x85\xbf\x5c\x91\x8c\xc4\x9c\x66\x55\x5d\x4c\x2c\x83\x31\x4e\xe9\xf5\x44\x33\x10\x0e\xec\x88\x5f\x94\x70\xca\xe1\x01\x32\x7c\xfd\x18\x15\x46\xea\x69\x38\xce\xc2\xa0\x19\xa4\x64\x4f\xd4\xa8\x7a\x1b\xf7\xda\x6f\x34\x5f\x24\xd1\xd1\x4c\xcf\x47\x19\x06\x84\x93\x4c\xa9\xd0\x63\x88\x0d\xe5\x78\x06\x77\x14\xdd\xef\xf8\x89\xe2\xa5\x8d\x17\x87\x20\x3e\x0a\x36\x26\x95\x1e\x02\x1f\x51\x78\x88\x08\x37\x5f\x6f\x29\x8e\x3b\x4f\x61\xd1\xf0\xfe\x49\x8a\xbc\x2f\x42\x67\x03\x12\xea\x29\xfc\x87\x98\x0e\x7c\xfb\xd8\xc7\x84\x81\x47\xae\x7a\xcb\x0c\xbc\x18\xc0\xf5\x41\xaa\xc8\x9c\x94\xdd\x40\xdb\xd3\xb2\x90\xeb\xeb\x9d\x01\x3a\x83\x38\x91\x19\x78\x0e\xf2\x2e\xc5\xf3\x4f\x43\x36\x9e\xf6\x67\x63\x67\xc2\xaa\x8a\x0e\x98\x7c\x72\xad\x2a\xc0\x7a\xd0\x5c\x09\x6c\xac\xcf\xb1\x01\x51\xf1\x8b\xc4\xa2\x55\xd8\x32\x9d\x4e\x19\x2d\x7b\xbe\xd8\x8b\x15\xbc\x69\x89\x8d\xf6\x50\x6c\xd4\x0c\xe4\xba\x22\x3b\x6a\x8a\xb8\x8c\x90\xa8\x57\x08\xee\x4d\x37\xef\x76\xd3\x2d\x71\xeb\x48\xac\xfb\x49\x8b\x97\x76\xba\xdc\x7c\xf1\xa6\x11\x9c\x63\x1d\xd7\xdb\x74\xa6\x65\x46\x68\xf5\xc6\x35\x2d\x5e\x4e\x6c\xb9\xa6\x1b\xb7\x32\xad\x59\x2a\x9f\x59\x8c\xee\xbb\xe3\x7b\x71\x96\xa7\xc2\x25\x4c\xad\xd5\xa3\x47\xce\x4b\x36\xa0\xc9\xdc\x19\x16\xc5\x48\x1c\x40\xad\xc4\x43\x13\x2f\x7c\x06\x53\x84\x2f\xb7\xbb\xec\x19\x91\x96\x8c\x17\xcf\xda\x5f\x3c\x6a\x56\x26\xce\x26\xaf\x67\xbc\x7b\xb4\xf6\x71\x23\x78\x8b\x72\xd5\xc6\x87\xff\x6f\x5c\xdc\xbe\x29\xb3\xa2\xcc\x6a\xf9\x70\xed\x57\xbb\x0a\x43\x5b\xc3\xcc\xf8\x05\x37\x2d\x19\x04\x17\xee\x39\x07\xfa\x75\x4f\x7c\x58\x32\xcd\x4a\x96\xd4\x63\x11\x6a\x21\x46\x43\x8c\x29\x85\x57\x2f\x45\xfc\x0f\x6b\x73\x7a\x9b\x06\x49\xdd\x3e\x65\x44\x98\xcd\x69\x3a\xfa\x5d\x26\x7c\xff\x51\x8a\x78\x8c\xf6\x1a\x16\x85\x06\x15\xba\x02\x46\xcd\x75\x6d\xc0\x93\x11\xd1\xbd\x01\x4e\x5a\x95\xb7\x8e\xf0\xb3\x1e\x26\x30\x5b\x5a\x7b\x21\x7c\xc1\xd9\xfe\xd4\xc9\xd6\x83\xe8\x29\xc0\x5d\x6e\xb4\x1d\x34\x5d\xd2\xb4\xfc\x6e\x3c\x62\xb0\xc6\x3e\xe9\xbf\x6d\x9d\xa4\x42\xfb\x8a\xa0\x9d\xd2\xfc\x37\xd0\xde\x7c\x81\xe9\x55\x42\x24\xa2\x3c\xa6\xc9\x30\x68\x3a\x9a\xca\x27\x58\x21\xd4\x9f\xe5\xb6\x80\x39\xc2\xf0\x3e\x90\x3f\x30\x95\xf3\x90\x81\x36\x62\xe6\xeb\x08\x4f\x20\x2a\xf5\x4e\xa0\x7f\xf2\x1a\x6f\x66\x25\x33\xf2\xac\x4f\x9e\x3f\xcb\x2b\x78\x73\xec\xfa\xa0\x9a\xe7\x89\x51\xd2\xfe\x86\x3e\x1a\x64\xd2\x3d\x98\x8a\xb7\x6c\xc2\x5a\x70\x0f\x0c\x13\xd5\xb2\x00\xfe\xe0\x3e\x04\xca\x4b\xdb\x22\xdb\xa0\xf1\x0d\x43\x85\x48\x0f\x45\x1e\xe0\x7e\xbd\xc3\x2f\xc8\xb9\xbe\x3e\x3f\x3e\x3c\x3b\xbe\xb8\x3e\x79\x7d\x71\x7c\xf6\xfa\xe0\xe5\xf9\xf5\xd1\xe9\xf5\xeb\xd3\x8b\xeb\xb7\xe7\xc7\xd7\xa7\x67\xd7\xbf\x9f\xbe\xbd\x7e\x7f\xf2\xf2\xe5\xf5\xd3\xe3\xeb\x67\x27\x67\xc7\x47\x72\x7b\x57\xd4\x99\xc1\x6a\x92\x0a\x4d\x06\x71\xf9\xe2\xb9\x60\x3f\x58\x09\x26\x31\x14\x8c\xbd\xe3\x59\x9e\x8e\x39\x42\x42\xe6\x61\x1b\xf5\xb0\x4e\x7d\x9b\x25\x10\x00\xff\xed\xab\x23\x2c\x03\xf1\x44\x1c\x47\x28\x6a\x03\xf9\x74\x05\x8a\xbb\xc2\x8d\x0d\xa0\x91\x72\xbe\x7b\x30\x8e\x67\x96\x98\xa9\x21\x7f\x68\xbd\x20\xe1\x30\xf1\xc2\xf2\x51\x0c\xac\xf4\xf9\x4b\x44\x4c\xf5\x0b\x27\xf6\x84\x76\x33\x2f\x6a\x4e\x4a\x8a\xe7\x18\x41\x07\x83\x6f\xb9\x68\xed\x4b\xbb\xd9\x62\xb0\x26\x5d\xad\xef\xf9\x30\x9b\x00\x9e\xc2\x03\x79\x74\xfa\xca\xd9\xfd\xae\xb7\xd3\xdb\x91\xef\x41\xd6\x9c\x88\x49\x99\x72\x03\x48\x1d\x0f\xd5\x18\xf0\xd6\x70\xea\xc3\xdd\xa8\x5f\xd5\x84\x6b\xb3\x64\x93\xe2\x06\xf6\x00\x5b\xdd\xfd\xbe\xb7\x63\x8c\x52\x9d\x86\x8b\x92\xb1\xe7\x45\x31\x0a\x9c\xbb\xa5\x7e\x31\xd9\x40\x10\x5f\xed\x69\x99\x99\x78\x1a\xea\x6e\xe3\xff\x27\x98\x2e\x31\xb7\x0d\x88\xb3\xab\xab\x3c\x76\x22\xc7\x53\xd5\xbb\x5d\x31\x06\x40\x41\x22\x35\xdc\xd8\x50\x63\x4d\x59\x92\xa5\x4c\x3e\xa5\xaa\x8d\x81\x04\xbb\xd8\x2f\xca\x89\x88\x69\x8d\x24\xc0\x90\x26\xa3\x39\xb0\x18\x13\x3a\x62\xf8\xb6\x76\x51\x8e\x90\x76\x04\xd7\xdc\xb3\x62\x3c\x9e\x4d\x81\x6a\xfc\x85\x55\x35\x46\xa1\x2e\x05\xbe\x13\x63\xbc\xdc\x14\x93\xd8\xbc\x72\xf6\xdb\x12\x03\x99\x18\x6e\x6c\x4c\x8a\x74\x36\x66\x3d\x1c\x51\xe5\x44\xd8\x18\x86\x18\xf6\xa4\xef\x94\xf3\xfe\xf8\xe9\x9b\x83\xc3\x17\xce\xbb\x83\x33\xe7\xe4\xf5\x2f\xc7\x87\x17\x27\xa7\xaf\x9d\xaf\x1f\x2d\x51\xef\x23\x6a\x13\xe7\xfa\xfa\x96\xc5\x53\x9a\x8c\xae\x85\x89\xcc\xf5\xb5\xf7\xd8\xf7\x7d\x90\xfb\x7e\xfd\xc8\x59\xfa\x84\x37\xf7\xcd\xce\xb7\xce\xd7\x8f\x44\x9a\xa7\x5c\x11\x71\x2c\xc4\xb9\xaf\x39\x7e\x70\x36\xdc\x59\x85\x6f\x1a\x27\xb5\x1b\xf2\x66\x9c\xff\x39\xce\x12\x96\x57\xd2\x87\xe3\x66\xf7\xbb\xde\x6e\x6f\x17\x2d\x94\x68\x52\x6f\xa7\xc5\xa4\x67\x40\xf5\x24\xcb\x7b\x7f\x54\x42\xd5\x72\x58\x4c\xe7\x25\xf0\xdf\x5e\xe2\x3b\x7b\x3b\xbb\x8f\xb7\xe1\x79\x13\x7e\x65\x3f\xa3\x09\x8b\x8b\x62\x44\x9c\x93\x3c\xe9\x29\x8f\xa0\xac\x92\xb6\x89\x60\x02\x98\x55\x8e\xe8\x3f\x05\x59\x04\x68\xd9\x9c\x57\x27\x17\x32\xd9\x0a\xe9\xc7\x9b\x78\x79\x72\x78\xfc\xfa\xfc\x18\x25\x03\xc2\x81\xa9\x2c\x8a\x5a\x50\x47\x9c\xcc\x94\xde\x3f\xa2\x23\x1d\x96\xe6\xd1\xd7\x1b\xce\xab\x22\x65\x65\x9e\xfd\x55\x3a\x8f\xf9\x81\x9a\x96\xcc\xf1\x0e\x91\xeb\x7b\x3a\xcb\xc6\xa9\xef\x2c\x78\xff\x1b\xc2\x68\x8f\xd2\xa8\x6d\x6b\x76\x7d\x32\x69\xcd\xd8\x7b\xbc\xe3\x93\x83\xd6\xac\x1f\xbe\xf3\xc9\xd3\xd6\x9c\x6f\x9e\xf8\x24\x69\xef\x68\xef\xf1\xae\x4f\xd2\x75\x79\x7b\x3e\x61\x6b\x06\xb8\xfb\xd8\x27\xc3\x75\xf5\x1e\xfb\x24\x5b\x97\xf7\x8d\x4f\x0e\xd7\x34\xb9\xeb\x1b\x01\x9d\x8f\x3c\xea\xdf\xf5\x8b\x12\x48\xa9\x38\x6a\x52\x50\xdb\xbb\x24\x89\xdc\x57\x59\x8e\x0e\x81\xc2\x43\x08\xa4\xb0\xff\xc3\xdd\xa2\x5b\x6e\xe8\xdc\x64\x55\x56\x83\xf1\x47\xf0\xe8\x51\x5f\xc0\x4b\x6f\x90\xd5\xc3\x59\xdc\xcb\x0a\x34\x04\x41\x9f\x33\xa8\xb8\x9d\x32\x0e\x34\x25\xf8\x9d\xed\x2b\xb7\xa5\xff\x7c\x7c\x9c\xba\x5b\x94\xa4\xd1\x4e\x98\xfe\x18\x87\xe9\xd6\x96\x9f\x6c\x45\xee\x7f\x3e\xee\x7d\x47\xcb\x41\x75\x79\x85\x25\x58\xce\x6b\xbf\x3d\x3b\x51\x98\xce\xa0\xe3\xd2\xad\xdd\x2b\x3f\x8c\x23\x90\xc2\x78\xc9\x96\x2b\x55\xbe\x4e\x7f\x36\xd6\x4c\x67\x01\x31\xb9\xd1\x0f\xb5\xc8\xb7\x27\x72\x7a\x9c\x99\x35\x1f\xe2\x85\xb8\x1c\xbc\xa2\x10\xd5\x01\xb3\x9a\xa6\x99\x08\x53\x25\x79\x59\xc9\x94\xf6\x5c\x3f\x8c\x41\xa9\x17\xb9\x27\x72\x5e\xce\xbb\xac\xc0\xc0\x53\x6e\x18\xf7\xe0\xf1\xde\xea\xa2\x78\x53\x4c\xa3\xdd\x10\x39\xe3\x38\x5c\x52\xba\x8f\x3e\x56\xc1\x91\xe7\xee\xed\x7d\xef\xfa\x68\xd0\x3d\xa6\xd1\x9d\x24\x97\x83\xce\x0e\x49\x69\x3e\x60\x65\x31\xab\xc6\xf3\x73\x56\x9f\xe4\x39\x2b\x9f\x5f\xbc\x7a\x09\x59\x88\xde\xde\x01\xc1\xaf\xbf\xc1\x16\x93\xa5\x3c\x25\x33\x8b\x57\xb3\x29\x3f\xe4\x15\x38\x32\xe7\xf5\x71\x8a\xcf\xba\x0a\xde\xc6\x2c\xf1\x7c\x9e\xa2\x68\xcb\xcc\xab\xe7\x63\xde\xcb\x32\x54\x80\xf4\x27\xf5\x28\x89\xfd\x3b\xa4\x86\x3d\xda\x8d\xfd\x28\x8a\xe2\x25\x62\x68\x1a\xdd\xbd\x7a\x7b\x8e\x97\xf3\x9b\xb3\xd3\x37\xc7\x67\x17\xbf\x07\xbb\xe4\xf9\xc1\xf9\xf5\xd3\xd3\xd3\x97\xc7\x07\xaf\xaf\xdf\x1d\xbc\x7c\x7b\x1c\x7c\x03\x69\xaf\xdf\xbe\x3a\x3e\x3b\x39\x14\x69\x3f\x40\xda\x9b\xd3\xf3\x93\x8b\x93\x77\xc7\x8d\xcc\x3d\xac\x71\xfa\xee\xf8\xec\xe5\xe9\xc1\xd1\xf1\x51\xa3\xc1\xc7\x7b\x90\x7f\x7e\x71\x76\xf2\xfa\xe7\x46\xde\x77\xdf\x90\x2c\xe7\x17\xe0\xd1\xe9\x2b\xc9\x4c\x1d\xc2\x0b\x35\x81\x42\xca\xd4\xbf\xc3\xa3\x51\x52\x92\x44\xb4\xf7\x46\xbd\x59\xb4\x58\xdc\x2d\x49\x1a\xd1\xde\xd1\xe9\xab\x03\x29\x72\x7f\xcd\xf7\x77\x4a\x13\x91\xcd\xda\xb2\x79\x4e\x48\x31\xe7\xd5\x0c\x7d\x29\x5f\x81\x01\x3b\x66\xc9\xe3\xd8\x87\xa7\x86\xfc\xbb\x8a\x36\xdf\x08\xea\xfb\xfb\x47\x9e\xfb\xcd\x0f\x2e\xe9\xfb\x81\xf0\xce\x03\x97\x95\xa8\xdf\xab\x8b\x97\xc5\x2d\x2b\x0f\x69\xc5\x3c\x9f\x8c\xa2\xe4\xb2\x7f\x15\x0e\xa2\x3b\x6a\x8e\x21\x18\x10\xba\x32\xe4\x00\xd8\x76\xa9\xd2\x84\x62\x7d\x32\xb1\x06\x88\x45\x26\xb3\xaa\x7e\x5b\x29\xfe\x33\xf8\x93\x7a\x23\x12\xf7\x56\x76\xd8\x27\x1b\x43\x5a\x3d\xc5\x28\xc7\x08\x99\xa2\xe8\xca\xc6\x73\x34\x57\xbd\xe6\x7c\x79\x96\xac\x94\xb4\x76\x1c\x4a\xbe\x29\xaa\xac\xce\x6e\xd8\xba\x1a\xed\xc0\x02\x55\x4f\x6f\x58\x39\x2e\x68\xca\xd2\x75\x03\x5b\x07\x4b\x50\x1d\xc3\x3b\xad\xab\xda\x06\x66\xfe\x32\xdc\xfd\x29\x1a\xf4\x1a\x4b\xb1\x05\x29\xe6\x04\x30\xa5\x7d\x7c\x06\x7e\xf8\x76\x87\x6f\x7b\xc8\x56\x81\xa2\xdb\xf5\x06\x3d\x6b\x5f\x23\x76\xd9\xbf\xf2\xc3\xf4\x21\x65\x01\x06\xa2\x14\x2a\xb4\x40\x1c\x54\xb0\xa1\x21\xa2\x50\xb8\xe2\x7f\xa2\xc1\x72\xb9\x24\x15\x8d\xee\x96\xc6\xf5\x52\x0b\xac\x90\xf5\xbd\xf1\x4a\x9b\xd4\x5f\x2c\xf6\x7e\xa4\xe2\xaa\xe9\x76\x3d\xb7\x70\xa3\x28\xa2\x97\x3b\x57\x8b\x85\x7b\x2a\x7f\xf3\x9e\xdd\x1c\xbf\x76\x79\xce\x6b\xf9\xdb\xf7\x11\xdb\x74\x76\xc3\xac\x0f\x42\x27\x8e\x72\x64\xe2\x4e\x58\xdd\x66\x75\x32\x94\xb2\xb9\xd8\xbf\x03\x85\x8e\x2b\xc2\x6e\xbb\x81\xe0\xdc\xdb\x46\xb6\x4f\xa3\xce\x4e\xe0\xc5\xd1\x8c\x7a\xd4\xe7\x9f\x71\x73\x03\x17\x0b\x48\x5a\x05\x08\x91\xb1\x06\xd0\x3c\x7e\xf2\xad\x43\xda\xab\x38\x99\xe4\xed\x90\x6f\x7d\x42\x23\x37\xa5\x35\xdd\x86\x29\x2e\x16\x2e\xbf\x44\xf0\xc3\x27\x34\xc4\xf1\x2b\x75\x8f\x1b\x60\x02\x6a\xb1\xe4\x17\xca\x7f\xe5\x17\x32\x70\x72\xae\x9d\x9d\x50\x52\xf8\x72\xe9\x96\x4b\xb5\x5b\x30\xd7\x3b\xe9\x6f\xd5\xb6\x2a\x15\xbd\xa4\x57\x80\x04\x10\xb1\xdf\x50\x8e\x17\x6f\x69\x74\x43\x57\x8f\x3f\x79\xce\x93\x57\x8e\x3a\xf9\x48\x65\xba\x75\x3a\xc9\x5c\xa5\xb7\x1f\x5f\xf2\x97\x2a\xb0\xee\x88\x92\x03\x55\xa4\xed\x28\x92\xa7\x34\xba\xd3\x18\x3c\xb8\x03\x11\xff\xb3\xd9\x78\x7c\x9e\x94\x8c\xe5\xc1\x73\x42\xab\x79\x9e\xf0\xbf\xb3\xba\x78\x56\x24\xb3\x4a\xfc\x7e\x33\xa6\xf3\xe0\x39\x49\xe8\x94\x73\x6a\xc1\x5f\x94\x24\xe2\x6a\xbd\xa5\x8b\xe7\x24\x29\xc6\x55\x30\xa7\x24\xb1\xef\xd3\xe0\x00\x93\x4a\x9e\xfd\x9c\xb8\x62\xf1\xdd\xe0\x39\xbf\xa0\x59\xc9\xff\x66\x15\x2f\x99\xf2\x9f\xc5\x6d\xce\x21\x86\xb7\x9e\x96\x74\x30\x90\x4d\x70\x4e\xe9\x75\x21\x24\x0c\x2c\x78\x4e\x86\xf0\xc4\x60\xf0\x9c\x8c\x8b\x62\x1a\x3c\x27\x93\xd9\xb8\xce\xa6\x63\x86\x83\x99\xcc\x6a\x39\xae\xdc\xac\x55\x4c\xa1\xce\x74\x4c\xe7\xd5\x09\x84\x5c\x0f\x9e\x93\x92\xd1\xf4\x34\x1f\xcf\xe1\x27\x7a\x23\xc0\x4f\x08\x3b\x01\x3f\x8b\x5b\x98\x5a\x59\xdc\x9e\x4f\x69\x1e\x7c\xa4\x64\xa3\x4a\x8a\x29\x64\x56\x8c\x4e\xc6\xac\xaa\xe0\xe7\x18\xf4\x4f\xd8\x71\x95\xfd\xc5\x78\x2d\x78\x8c\x93\xd7\xa9\x78\x5d\x9e\x30\x65\xe3\x31\x90\x25\x7c\x66\x48\x49\xec\x90\x9a\xc6\x10\x07\x31\xd8\x21\x59\xcd\x26\xe7\xbc\x7d\xbe\xf2\x60\x63\x7e\x38\xa4\x65\xc5\xea\x60\x87\x80\x08\x15\x6e\xa6\x1d\xc2\xe9\xc7\x67\x45\x09\xbf\xea\xe9\xf1\x9f\xb3\xec\x26\xd8\x21\x28\xf1\x3c\xa0\x4b\xb2\x72\xef\x06\x77\x76\x73\x2e\x7e\x6e\x27\xf8\xed\x1a\xad\xbb\xf0\xd3\x55\x7d\xb8\xfd\xa2\x74\x8d\x7e\x5c\xfe\x73\x9b\x2f\xd7\x8d\x0b\x3d\x35\xee\xf1\xe0\x0e\xc7\xa1\xc9\x08\x81\x05\x11\x49\x49\x1c\xe5\xd0\x1e\xf2\xf3\x6a\xa0\x9e\x0b\x15\x5d\x3f\x94\xa7\xba\x13\x71\x7c\x31\x9f\xb2\xc5\xa2\xb3\xcb\x11\x01\x3f\x96\xab\xe5\xf7\x69\xaf\x62\xf5\x4a\x3a\x71\xdd\xad\xd8\x0f\x28\x1a\x87\x66\xf5\xbc\xdb\xed\xe8\x8f\x5e\x4c\xd3\x93\x7c\x3a\xab\xbb\x5d\xda\x03\x1b\xf3\xa3\x22\x41\xfd\x16\x4d\xf8\xfd\x2a\xe4\x55\x7c\x0c\xdd\xee\xc6\x7d\x5d\x70\xec\x7f\x78\xff\xe1\x7b\x11\xdd\x7d\x1c\x67\xf9\x08\x57\x2f\x78\xf4\xe8\xf6\xf6\xb6\x77\xfb\x18\x62\x52\xec\x3e\x79\xf2\xe4\x11\xe4\xba\xe4\xe3\x64\xdc\x56\xe4\xb7\x57\x2f\x79\xb1\x1f\x1e\xe5\xf2\xb2\xe2\x4b\xdf\x3c\xd0\xb3\xba\x38\x43\xd8\x0d\x0e\x29\x61\x1f\xd1\x6c\xfa\x8c\x21\x1b\x59\x9d\x49\x10\x3f\xa4\x44\x3e\xe2\x79\x30\x9e\x0e\x69\x70\xb8\x06\x64\x8c\x06\x5d\xe3\xc3\xbd\xa7\x6d\x77\x6d\x96\xdb\xe8\xd4\xb5\x3e\xdd\x96\x11\x00\x2d\x19\xe0\xc2\x1d\x24\xf5\x8c\x9f\xe4\x17\x3d\xf8\x24\x98\x58\x26\x65\x31\x6e\x24\x3e\x2f\x59\xdf\x4e\x39\x5b\x29\x73\x3e\x2c\x6e\xed\x94\x8b\xac\x6e\x16\xba\x98\x4f\x75\xca\xc6\xc7\xc9\xf8\x29\xad\x20\x61\x32\xe6\xfb\xf4\x92\xe6\x03\xfd\x75\x0e\x54\x24\x7c\x2e\x97\xe4\x98\x46\x8f\x2e\xff\xb3\xfd\x9f\xe0\xca\xbb\xa4\xdb\x7f\x5d\xf9\x8f\x06\x9a\x5d\x78\x6e\x5e\x35\xfc\x2e\xef\xd5\xc5\xdb\xe9\x54\x5e\x89\xcb\x0d\x38\x9c\x79\xbd\x3d\x64\x22\xb2\x71\x36\x00\xa6\x6c\x3b\xa6\x15\xe3\xa8\xcb\xa1\x25\x8d\xb3\x64\x9b\xe3\x46\x47\x26\x6e\x57\xc3\xac\x5f\x3b\x09\x9d\xca\x8a\xc9\x38\x9b\x6e\xc3\xb3\x27\xf0\xab\x9c\x8d\x21\x54\x4a\x51\x6e\x83\x49\xfd\x54\x30\x67\x6d\x69\xdb\xfd\x6c\x5c\xb3\xb2\x12\x79\xd3\xb2\x00\x71\x05\x7e\x95\x4a\xc9\x99\x16\x93\x2c\xa7\xe6\xc8\x50\xe0\xb9\x1d\xd3\x64\x34\xc0\x68\x08\xfd\x6c\x3c\xde\x2e\xa6\x34\xc9\xea\x39\x7e\xc0\x40\xfa\xe3\xa2\x48\xb7\xa1\x41\xf1\x5b\x95\x29\xf2\x7a\xbb\x4f\x27\xd9\x58\xfc\xe6\xf8\x54\xff\xda\xa6\x29\xc4\x9e\xc3\x84\xba\x64\x75\x32\x94\x1f\xf3\xb1\x28\x28\x39\x50\xf8\xb8\xc5\xe5\x18\x8c\xe7\xd3\xe1\x36\x18\xab\xe2\xcf\xa2\xcc\x64\x3c\x97\xed\x61\x51\x66\x7f\x15\x79\x4d\xc7\x2d\x99\x37\xfc\x88\x25\x9c\xed\xe5\xa5\xb6\x69\x7a\xb3\xfd\x51\xfc\x46\x47\x98\xed\x8f\x4e\x36\xa1\x03\x66\x2c\xcd\x18\xde\xe0\xdd\xe6\x40\x0c\x9f\x7c\x08\x59\x3e\x10\x33\x9e\xd0\x72\xc4\xca\x6d\x96\xa7\xf2\xe7\x24\x53\x3f\xe1\xde\x80\x67\x61\x61\x5f\xc1\x1e\x01\x62\xa3\xc8\x94\x7a\x98\x25\xa3\x9c\x55\x95\x33\xa5\x59\x5e\x6f\x83\x23\x9e\x33\xa5\x79\x51\xb1\xed\x5d\x7c\xfb\x99\xb7\x7e\x03\x21\xf2\xd5\x98\x60\x8b\xf3\xda\xa9\x86\x74\x6a\x0e\xb5\xaa\x8b\xa9\x18\x17\xfc\x94\x1b\xc1\xa9\xa9\x11\x13\x31\x50\xf5\x30\xec\x64\x3d\x96\xaa\x2e\x8b\x11\xdb\x4e\x69\x35\x44\xdf\x10\x23\xa1\xe8\xf7\x2b\x56\xcb\x14\x3e\x89\x84\x4e\xcd\xcf\x3f\x8a\x2c\x97\xdf\x93\xac\xe6\x13\x9d\x64\xaa\x82\x31\x22\xfe\x79\x9b\xa5\xf5\x10\x1e\x00\xdb\xa6\x79\x32\x2c\x4a\xfc\x9d\xb2\xa4\x28\x85\x25\x12\xff\xd6\x33\x04\xc9\x9c\xbd\x98\x3a\x49\xcf\x60\x96\x67\x49\x91\xb2\xed\x38\x4b\x33\xf5\x51\xd2\x7c\xc0\xf8\x57\x5d\x6d\x4f\xf9\xaa\x4e\x9c\x9b\x6d\xca\x71\x56\xcc\xea\x2c\x71\x6e\xb6\x87\x34\x1f\xf0\x5e\x6e\xb6\xb3\x94\x15\x83\x92\x4e\x87\x90\x3e\xa1\xf5\x90\x4d\xd0\x31\xc5\xb9\x01\xd9\xde\x36\xeb\xf7\x59\x52\x3b\x1c\xa2\x00\x8e\xe6\xf8\x53\x81\x91\xf9\x35\x77\x6e\x8b\x32\x55\x20\x74\x5b\x66\x00\x41\x93\x22\x65\xce\x47\x79\xc8\xf1\x5a\xa1\x88\x1e\xe5\x17\xe2\x45\xf1\x35\x2c\x59\x5f\xfc\x34\x52\xab\x61\x71\x2b\x7e\xd6\x1c\xf7\xc9\xdf\xf3\x29\x73\xf8\x2d\xc4\x4f\x34\xff\x91\x57\x01\xe4\x40\xe2\x98\xe6\x03\xf8\x81\x77\x50\xaf\x9a\x8e\xb3\xda\x73\x1d\xd7\xef\x09\xf5\x99\xb7\x2a\x3d\xa0\xca\x13\xfb\x98\x92\x8d\xe7\xd4\x0f\x8f\x4c\x59\xc2\x65\x7c\x15\xed\xf0\xa4\x15\xfc\xcf\x73\xe8\xd2\x0f\x6f\x68\x6f\x8d\xac\xc2\x7b\x4a\xef\xcd\x3e\xa2\x42\x9a\xf4\x3a\xba\xbb\x4e\xe8\x6c\x30\x44\xff\x2a\xe4\xe5\xaf\x87\xb4\x3a\x34\x12\x3b\xbb\xe4\xba\x04\xc0\xbe\x6d\x94\x3a\x33\x53\x3b\xbb\x42\x74\x92\x15\x79\x70\x87\x3f\x21\xe7\x6d\x9d\x8d\x2b\x4b\x7c\xe2\xca\x0f\x4e\xca\x08\x5e\x8c\x8f\xf6\xa6\x18\xb1\x9f\x67\xb4\x4c\x59\x2a\x9f\x9a\xda\x3f\xf2\xdc\xdd\x27\xdf\xbb\x4a\xa8\x71\xc2\x99\xa5\xd6\xa2\xcb\x25\x69\x4d\xb7\x48\x2e\x92\x90\x94\x30\xd2\x27\x03\x32\x22\x43\xff\xee\x84\x0a\x8d\xf2\x6b\xa2\xb5\xc9\x6b\x1a\x3a\xc8\xd3\x43\x5a\x27\xc3\x67\x59\x59\x89\xb5\xb9\xaf\xe9\xd7\xed\xc3\x34\x35\xd8\x86\x02\x3b\xeb\x7b\xaf\x7b\xf6\xca\x7b\x3e\xc2\x4a\x19\xbd\xee\x25\x63\x46\x4b\x2b\x2f\x7c\xdd\x6b\xee\xc1\x62\xe1\xad\x26\x46\x9d\x1d\xf2\xba\x67\xed\x60\xb4\x51\xfa\xcb\x25\x11\x49\xe6\x5e\xab\xf9\xa8\x9b\xf8\x97\xf6\x05\x6a\xc0\xc8\x6a\x3d\x1c\x88\x51\x66\x49\x9a\x73\x30\x6b\xc1\xf4\x1b\x35\x70\xf6\x34\x7a\xdd\x33\x81\x34\xb4\x3f\x23\x30\x38\x5d\xa9\x1b\x75\x76\x43\x49\x4b\x2c\x01\x86\x7e\x70\xfd\xa5\x21\x9d\x3c\xa1\xed\x7b\xd6\xd2\x4e\x5b\x87\xb8\x2f\xe8\xa0\x36\x2d\x8b\xba\x00\x57\x15\x60\xdb\x51\x03\xa4\x16\x8b\x3c\xf6\xc3\xba\x9c\xdf\xc5\x62\x1d\x13\x52\xfa\x4b\xb0\x77\xf6\x72\xe8\xd0\x6a\x9b\xb4\x8c\x60\x67\xb9\xd4\xf2\x93\x5f\xa8\xb9\x5a\xe6\x46\x1b\xcb\x65\x6e\x76\xd8\xdc\x7c\x63\xc1\x6c\x38\x91\xe2\x67\x1a\x2e\x97\xbc\xa9\x17\x14\xca\x92\x97\x0d\x11\xce\x2b\x31\x84\x17\xd4\x97\x82\x49\xea\x64\xb9\xf3\x52\xe1\xb6\x97\xf4\x92\x5e\x91\x24\x7a\xc1\x8f\x6a\xca\x3e\x9e\xf6\x3d\xea\x87\xdb\xbb\x3f\x26\x86\xd4\xea\xc9\x77\x2e\xa1\x00\xf8\x9d\xd7\xf4\x32\xb9\xf2\xef\xe2\x1e\xfb\x08\xe1\xdb\x8e\xe1\x8a\x36\xcb\x7e\x0f\x65\xa1\x5c\x14\x87\x49\x14\xf7\xe0\x1a\x47\x27\x18\x39\x8a\x54\x88\x47\xc1\xa0\x30\x32\xa4\xa0\xfd\x28\xb9\x4c\xaf\xc8\x20\x8a\xc9\x28\x4a\xc3\xd3\x15\x41\xc6\x08\xc4\xa7\x4f\x9e\xb8\x64\xa4\x30\xcd\x29\xbd\x1c\x5d\x45\x7d\x68\x60\x18\xf5\x7b\xd3\x21\xad\x58\x7a\xc6\x06\x59\x55\xe3\x7d\x0a\xe8\x98\x4f\x60\x88\x1a\x13\x50\x5c\x0d\xfd\x61\xb3\x75\xe6\x77\xbb\x6f\xa8\x37\xbc\x64\x57\x1c\xd0\xfc\x90\xf1\x4d\x05\xd3\xad\x7e\xaf\x6c\x34\xb8\xef\xbd\xa1\xde\x6a\x32\x54\x24\xbc\xa2\x1f\x30\xbe\x57\xa6\x00\xf0\xc9\x0f\x2e\x49\x09\xe5\x2c\x97\x01\x2a\x6f\x04\x88\xfb\x77\xbf\xf2\xfd\x00\x54\xba\xb3\xc3\x17\x52\x4e\x11\xd2\xa3\x38\x3c\xc3\xbf\xc6\x9a\x5e\x26\x57\xbd\x94\x4d\x39\xa9\x90\x27\x19\xab\x00\x20\x5e\xd3\xe8\xf2\x8a\x9c\x72\x70\x20\xbf\xc2\xbf\x67\x00\x1a\xaa\xc7\x73\xa0\xe1\x5f\x50\xec\x6a\x57\x63\xed\x17\xf4\xde\xb3\xe2\x87\x1c\xa6\xb4\xd8\xe9\x82\xea\x7b\xb2\xb3\x4b\x12\xd8\xe1\x04\x9c\x21\xfd\xac\xef\xad\x6c\x5f\x22\x30\x65\x1a\x71\x00\x09\x5f\xb6\x14\xe8\x76\x5f\x02\xf0\x44\x51\xba\x58\x78\xf0\x1b\x47\xb9\xe7\x92\x44\x8e\x93\x60\x99\x94\xc4\x7c\x9d\x97\x71\xb7\x0b\xe3\x82\xbb\xf2\x2d\x8d\x1a\xba\xf1\xe9\x78\x36\xc8\xf2\x2a\x78\x4d\x09\x2c\x1c\xdf\xa6\xa3\xac\x9a\xf2\xb3\x8d\x37\x6d\x15\x9c\x52\xd2\xdc\xc9\x57\xa0\xd4\xad\x82\x5f\x57\xb3\x8e\x8c\x15\x0f\xce\x28\x99\x16\x15\xb8\xbf\xaf\x00\x1d\xde\xc1\xe2\x92\xe5\x7d\xbf\x81\xb1\x9c\x72\x8a\x37\x38\xa7\xab\x39\xd5\x53\x14\xdf\x5f\xd0\xa5\x4f\xde\x89\x83\xfd\x5e\xfc\xfd\x0d\xff\xea\x7d\xfc\x5d\x21\x47\xff\x2e\x56\xc2\x06\x77\x86\xb1\xb1\x90\x82\x76\x43\x2a\x3d\xe3\x2f\x68\x39\x60\x75\xf4\x1b\xf5\x52\x7e\x2d\x3d\xf0\xf2\xf4\x78\x07\x62\xdd\xa9\xbf\xd2\x1a\x8a\x14\xd5\x90\xfe\x2d\xe4\xc6\x42\x5c\xc2\xf7\xee\xf1\x8e\x06\x30\x25\x48\xa1\x52\x90\x12\xf3\x34\xdb\x83\x98\xfa\x80\xb7\xec\xc4\xd8\xd7\xa2\x97\xe9\xac\x1a\x0a\x34\xcd\x3b\x23\x34\xc4\x34\x2f\xf6\xf5\x6d\x22\x7e\x34\x5b\xd9\xbf\xa4\x57\xbd\xa4\xc8\x13\x5a\x7b\xb1\x1f\x5c\x52\x12\x5f\x69\x88\xfe\x4a\x9d\xc5\xe6\x90\xf6\xa9\x22\x12\x79\x7e\x40\xbb\xdd\x58\x44\x6d\xe7\x27\x1a\xb0\x6b\x8c\xfb\xa3\x57\x23\x8e\x95\xfc\x48\x1c\x94\x24\xa2\xbd\xeb\x54\x40\xdf\x4b\x78\x03\x90\x95\x15\x68\xa3\x54\xf2\x49\x5e\xd5\x34\x4f\x10\x67\x35\x9e\xb7\xf3\x15\x2e\x67\xd1\x4e\xc8\x7e\x4c\x94\x10\xbe\x43\x7b\x59\xc5\x4f\x12\x1d\x00\x00\x9e\xd7\xc5\x74\xca\x52\xcf\x0f\xd9\xd6\x96\x2f\x41\x85\xe3\xb6\xf4\x92\x5d\xf9\x21\xe0\xb5\xa4\xdb\x35\x80\x28\x6c\x1b\x1b\xce\xa9\x6d\x78\x32\x27\xab\xde\xb0\x52\xbc\x67\xe8\xf9\x8b\x05\xe5\xeb\x8b\xb6\x31\x45\xd9\x13\x01\xb0\x3d\x8e\xf6\xb4\xd5\x61\x6c\x48\x11\x60\x95\xf8\x41\x56\xd9\xe9\x6a\xf6\x2e\xae\x71\x16\x47\x77\x5f\x76\x9e\x8c\x6d\xf9\x43\x6c\x8b\xdc\x90\xaa\xa6\x35\x7b\x5d\xa4\x0c\x6e\xb9\xc4\x37\x23\x29\x22\xbe\x7a\x47\xbd\x04\xef\xc0\xd4\xca\x4d\xa2\xf4\x32\xbe\x0a\x69\x20\x34\x16\x4a\x55\x51\xe4\x87\xe3\x2c\x19\x29\x61\x3e\x7e\x1e\xa2\x10\x5a\xa7\x1e\x15\xb3\x78\xcc\x1a\x45\x8d\xc4\x95\x0a\xaf\x8a\x59\xc5\x8e\x8a\xdb\xbc\x25\xa9\xbd\xf0\xab\xe2\xa6\x2d\xa9\xbd\xf0\xdb\xe9\x4a\x82\x2a\xe8\xa5\x51\x27\xed\x49\xa9\xb7\xbf\x58\xa0\x42\x64\x3e\x65\x24\x8d\x3a\x9e\x1b\xcf\xea\xba\xc8\xa5\xfe\x23\xcb\xa7\xb3\x5a\x7e\xa0\x84\x59\x7e\x71\xf6\x96\x96\x8c\xa2\x76\xc4\x0f\x69\xd4\x49\x43\xf0\x39\x73\xa8\xd2\x72\xd0\xa8\xb3\xbb\x84\x73\x63\xad\x77\xb7\xdb\xc6\x95\x24\x1c\xcf\xec\x3d\xde\x75\x49\x4c\x64\x92\xc2\x39\x1b\x32\xf6\xa9\x86\xaf\x51\xac\x11\xa7\x3a\x4f\xa4\x1f\xed\x84\xfd\x1f\x5f\x4b\xbd\x56\xd8\xdf\xda\x42\x18\x19\x44\xaf\x29\x28\x63\xbb\x5d\x6f\x10\x0d\x6c\xf2\x47\xb5\xe4\x77\xbb\x1e\x8b\xfe\x4d\x3d\x46\x06\xbe\x2f\xf1\x0f\xd3\xbd\x8e\x01\xaa\x69\xb7\xeb\xd1\x98\x97\xa3\x31\xa1\xbe\x01\xf5\x93\xd8\x60\x3b\xe3\x50\xa2\x13\xba\xff\x15\xe5\x38\x27\xf6\x03\xf8\x91\xc6\x7e\x48\x01\xb3\x3e\xf9\x56\x63\xd6\xd7\xbd\x55\x3e\xc1\xc3\x33\x93\xc7\xcd\x2b\x51\x73\x80\x59\x4c\x06\xac\x96\x87\x3d\xf8\x23\x26\xd6\xe4\x82\x51\x4c\x58\xfe\xe7\x8c\xcd\x98\x48\x18\xc7\x44\xbc\xf0\x0b\x09\xbf\xf2\xac\x60\x12\x2f\x7d\x52\xc4\xd1\x2b\x5a\x0f\x7b\x25\xcd\xd3\x62\xe2\xf9\xd6\x93\x3a\x42\x55\xb6\xe7\x93\xd3\xc8\xbd\xbe\x06\xdb\x12\x19\xc0\x59\x22\x94\xaf\xdc\xad\x22\x26\xd3\x58\x15\x80\x1e\x9e\xd3\x3c\x1d\xb3\xb2\x82\x5c\xe3\x10\xff\x09\xab\xc5\x21\xe4\xf2\xf4\x4a\xdd\x0d\x97\xa7\x57\xa1\xb6\x8a\xb9\xbc\x0a\x3b\x90\xc4\xc9\x91\x18\xef\x08\xea\x13\xda\x13\xe1\xab\x8a\x94\xf9\x1c\x88\xf5\x27\xa2\xc5\x26\x02\x48\x04\x95\xca\xf1\x34\x6f\x2e\xeb\x7b\xdf\x72\x12\xa5\x57\xd3\xc1\x62\xf1\x9d\xfc\x29\x47\x91\xc2\x10\x42\xbe\xd3\x58\x81\xc3\x78\x8c\xef\x9c\xfb\x49\x94\x86\xab\x10\x59\xca\xd9\x7c\x0b\x9a\x02\xd5\x2e\x35\xdb\x35\x31\x15\xbf\x58\x1f\xbb\x06\xf4\x54\xb1\x25\x98\x9d\xc6\x57\x8b\x85\xd6\xf7\xd5\x2b\x30\x00\x96\xee\xc9\x90\xc1\x6b\xbe\xbc\xc9\x86\xce\x23\xbe\x3c\xbd\x8a\xe8\x92\x83\xc7\xe1\xb8\xa8\x58\x55\xcb\x7d\x7a\x56\x16\x13\xa8\xf0\x27\x00\xcf\x4a\xb2\x29\x43\xa0\xb8\x60\x42\x67\x49\x17\x8b\x6f\x3b\x62\x52\xdd\xee\x77\xf2\xe7\x3e\x1f\x67\x80\x7d\xf1\x16\x78\x4b\xb2\xd5\xa0\x84\x4e\x60\x94\xc2\x58\x13\x1c\x2c\x54\x6f\x55\x4c\x30\xd6\x1b\x14\x81\xbc\xc6\x4c\x60\x31\xa2\x78\xb9\xf4\x35\xe9\xf4\x2b\x1f\x5c\x5a\x38\x7c\x7c\x2e\x8e\xce\xbd\x0a\x21\xcc\x83\x47\xbb\x5d\x35\x4a\x4d\x50\xec\x53\x54\x9f\x6a\xa5\x6b\x2c\x69\x05\xc5\xd8\x70\x80\xa3\xa1\x9f\x6a\x48\x8b\x78\x47\x00\x0e\x34\x4a\x25\x62\xd9\xf9\x91\x6e\x6f\x87\x7e\xec\xa5\x9c\xff\x72\x85\x6a\x32\xe5\x14\xae\x28\xba\x13\xd2\x1f\x55\x71\xba\xb5\xa5\xca\xc6\xb3\x98\x63\x5f\x5e\xd4\xa0\xba\x6e\xd4\x50\x38\x9c\x47\x70\xbf\x25\xbd\xd4\x22\x72\xd7\x31\x46\x97\xf1\x95\xef\x27\x6d\x17\xff\xbf\xa9\xd7\x96\xce\x29\xae\xa4\x8d\x1c\xb0\xcb\xab\x74\x4e\x1e\xa9\x91\xde\x4a\x1c\x48\x1f\x38\xbc\x6e\x97\xaf\x73\xef\xba\x06\x72\x93\x37\x4a\x6e\x62\xab\xc9\x8f\x0a\x11\x3c\xbc\x55\x2d\xdd\x33\x1a\x0e\xe3\x28\xde\xff\x95\x53\x85\x70\xf0\x67\xb1\x17\x8b\xbe\x8c\xa5\x9e\xab\xa5\xa6\xdd\x6e\xd2\xed\xae\x2c\x73\x93\x59\xe8\x76\xd7\xee\x48\xb3\x28\x5c\x21\xff\xe5\xad\x30\x16\xee\xaf\xb5\x7b\xb1\x3a\x87\x79\x73\x13\x80\x23\x31\xb7\xe1\x00\x5a\x03\x02\xfa\x36\x36\x81\xf3\xa9\x71\xd9\x66\x7d\x2f\xe9\x76\x53\x9f\x06\x82\xfb\x4f\xb4\xd1\x54\x94\x92\x41\xb4\x43\x46\x11\x0b\x47\xe1\x28\xfa\xd5\x1b\xf9\xfe\x60\x6b\x2b\x1c\xf1\x6b\x59\x14\x1a\x46\xfd\x70\x18\x0e\xa3\x5f\xbd\xa1\xef\x8f\xb6\xb6\x10\xd1\xee\xfc\x38\xd8\x1e\x85\x3e\x8b\x7e\xf5\x98\x4f\x06\xdb\xdb\x32\x79\xb4\x3d\x08\xfd\x7e\xf4\xab\xd7\xf7\xc9\x48\x26\xf3\x7c\x18\x09\x8b\xa2\xa8\xbf\x58\xc0\x9f\x1e\x1d\xc3\x65\x54\x33\x5f\x52\x22\xd8\x5c\x88\xd5\x97\x0c\x39\x1d\xb8\x1e\x98\xe0\xc3\x22\x06\x2d\x32\x7e\xec\x39\x28\x74\xa2\xa8\x1f\xfa\x77\x83\x28\xd1\xcd\x49\x96\xa7\x13\x45\x83\x6e\x77\xc0\xfb\xc2\x1e\x42\x86\x58\x22\xf1\xc3\x24\xfa\xd5\x4b\xfc\x25\x70\xcf\xbc\xad\xb4\xdb\x4d\x55\x5b\xe9\x43\xda\x4a\xb0\xad\xd4\x0f\xd3\xe8\x57\x2f\xc5\xb6\xd0\x22\x53\xc5\x5a\x4a\xb7\xb6\xfc\x79\xec\xb1\xcb\xd4\xc4\x23\x0a\x3b\x25\x0d\xec\x34\x8f\xbd\xa4\x81\x9e\x62\xc1\x63\x1f\xae\x5c\x26\xea\x9d\x4e\x76\x71\x5b\xbc\xe1\x67\x4e\x72\xd8\xac\x0a\x0e\x62\x72\x5f\xfe\xf9\x28\x9b\x22\x33\x69\xdd\x1c\x00\x49\x1f\x63\x7f\x69\x54\x3e\xe6\x14\xc3\x4b\x46\x6f\xcc\xe6\x9f\x9a\xcd\x1f\x81\x19\xb2\x91\xbb\xd2\xe4\x5f\xb1\xbf\x5c\xfa\xe4\x28\x6e\x30\xd3\xc7\xb1\xe7\xdf\x75\x8e\xe2\x6e\x77\xd2\x4b\x68\xfe\xb6\x62\x47\xa7\xaf\xba\x5d\xef\x28\x8e\x80\x62\x15\x06\x97\x6e\x96\x3b\xa9\xd4\xb5\xcb\x1f\x42\xdb\xbe\x6f\x15\x0c\x5c\x30\xdc\xbc\x60\x1f\x6b\x57\x5d\x23\x47\x31\x90\x64\x67\xd1\xdd\x75\x59\x14\xb5\x10\xd2\x83\xce\x8c\x17\x14\xdf\x7d\xc1\x8d\xab\x24\x93\x7b\x79\x16\xa3\x5c\xef\xac\x67\x95\x93\x44\x42\x23\x19\xe8\x17\x4a\xe2\xe8\xac\xa7\xbb\x21\x49\x14\x8b\xed\x26\x29\x61\xd1\xcf\xb1\xe7\x93\x7e\xa4\x40\x45\x5f\x42\x49\xb7\x1b\x5f\xd2\xab\x28\x8a\xd8\x25\xbd\x82\xab\x48\x18\x2c\x26\xdb\x34\x44\x28\xdb\x0d\xd3\x1f\x39\x40\xc6\x97\xc9\x76\x8a\x45\xfb\xdb\xe9\x15\x00\x5c\xd8\x18\x4e\x24\x24\x4a\x1e\x25\xbb\x3f\xa6\xfb\xbb\xdb\xa9\x20\x60\xd5\x0a\x35\x2a\x68\x04\xc3\x07\x29\xe8\x1b\x61\xc0\x90\x41\x69\xbe\x8e\xfb\xe2\x2f\x86\xe6\x08\xc4\xd7\x25\xdf\xd3\x2b\x84\xd9\xe7\x71\xe4\xda\x58\xce\x31\xd0\x99\x93\x53\xb0\x9a\xb8\xc1\xa0\xa2\x2a\xe6\x0c\x88\x50\x58\xea\xb4\x71\xd6\xce\x2a\x3e\x76\x56\x51\xae\xa9\x66\x22\x27\x71\x74\xc7\xf9\x13\xdc\x66\xec\x1e\x7f\x5b\x42\x95\xe0\xe9\xca\x93\x30\x30\x10\x38\x38\x58\x1e\xcf\xaf\x10\x30\x25\xbc\xa7\x31\xd8\x1c\x61\xc3\xd9\x84\x9d\xd7\x74\x32\xb5\xa0\x5f\x11\x91\x2a\x7b\xb1\x38\xa2\x35\xeb\xe5\xc5\xad\xe7\x2f\x49\xda\x98\xb4\x10\x5e\x55\x17\xe5\xac\x92\x9f\x26\x1c\x9e\x6b\xb4\x0e\xee\x2e\xf6\xea\x46\x34\x84\x54\x63\x91\xa3\x18\x93\x8c\xb5\x8e\x92\x90\x46\x90\x68\x8a\x0c\x80\x31\xe8\xd3\x84\x29\xbc\xcf\x50\xa8\xb8\x22\x30\x64\xfc\xc6\xf4\xe2\x88\x5e\xb2\x2b\x7f\x9f\x37\x74\xc9\xae\xa2\xd8\x4b\xfc\xc0\xc5\x8e\x39\x93\xc9\x20\xa7\x87\x09\x51\x1a\xc8\x72\x09\x08\x42\x20\x6f\x75\xcf\x23\x81\x6a\x93\x5e\x73\x61\xf6\x57\x93\x02\xb0\xf0\x49\x7a\xb8\xc6\x60\x2f\xe8\xef\x5b\xbb\x78\x51\xce\x98\xbd\xaf\xcf\x20\x82\x8e\xe8\x7d\x15\xbc\xa2\x96\xc2\xd2\xeb\x73\x98\x55\xcb\x8d\x03\xef\x5c\xcb\x69\x09\xa7\xe7\xf9\x58\xc4\x34\x4c\xa5\x0d\xee\x4e\x73\x7a\x1d\x94\xb9\x8b\xe5\x37\xf6\x04\xf8\x16\xda\xb3\xdb\xdb\x6f\x26\x78\x7e\x20\x05\x8d\x96\x7a\xd0\x58\x01\x68\xc6\xf8\x8e\x3a\xbb\x3e\x59\xb7\xda\x2b\x8b\xe5\x2f\x49\x55\x17\x53\x63\x61\xcc\x39\xdd\x3b\xf4\x46\xbd\xfd\x95\x94\x75\x83\xc7\x83\xf4\x14\xce\x16\xb4\x64\x26\x44\x9d\x1d\x35\xfc\x4f\x6d\x97\x98\xc0\x14\xe5\x62\x2b\x9b\x61\x4a\xcc\x56\x2b\x2e\x89\x99\xdf\x02\x34\x64\x43\xfa\x9e\xd9\xda\x39\x63\x51\x5a\x8f\x13\x89\xe1\x40\xc5\x78\x98\xe0\x14\xc4\x57\xe2\x1a\x54\x18\xff\x79\x6c\xf2\x1d\x50\xe8\x39\xbf\x02\xb0\x20\x67\xa2\xce\x75\x8b\xd1\x49\x1c\x9e\xf7\xe8\x0c\xfc\x00\x21\xf0\x56\x64\xf3\x5e\x5a\xe2\xe7\xf9\x77\xcb\x44\x03\x6c\x24\x9f\x1e\xc7\x4f\x21\x67\xcb\xd9\xad\x93\x84\x07\x5e\xca\x79\x74\x99\xe7\x87\xc6\x47\x94\x9a\x5f\xe6\x3c\x23\x1a\x52\x63\x64\x07\xde\xdd\x12\xb7\xcb\x98\x3f\x6f\xca\x1a\x2d\x14\x30\x53\xc2\x5f\x38\x1d\xbb\xe4\x7f\xce\x4d\x7e\xd1\x26\x62\xa1\x1a\xe2\xe4\xa2\x18\x8b\x05\x93\x1a\xad\x46\x26\xb0\xfd\x78\xce\xd1\xe9\x8c\x28\x79\xab\x92\x11\x69\x57\x64\x38\xdc\xaa\x2f\x83\x8c\x3e\x43\x6a\x1d\x62\x93\x71\xa8\x14\x6e\x56\x96\xff\xc9\x63\x97\x4f\x50\x03\x87\xe7\x87\xbb\x3b\x3f\xb5\x0e\xb6\xdb\x6d\x0e\x13\x59\x56\x7d\xdf\xfe\x82\x1d\xea\x22\xc0\xdd\xf6\xd4\xf3\x8a\xd1\xaf\x71\x48\xa5\x78\x37\x3a\x8b\x75\xcd\x73\x63\xb1\xc4\xcc\xce\x71\xee\xa8\x4e\x97\x93\xb3\x21\xc7\x3b\x8f\xc9\x5d\x4a\x6b\xc1\x67\x1b\x8b\x7f\xf1\x65\xed\x5d\x34\xda\x03\xf5\x50\x1c\x5d\x3e\x21\xbb\x8f\xc9\xde\xf7\xe4\xf1\xde\x15\x79\x17\x47\x16\xb9\xe7\x1e\x8a\x10\x2a\x59\x91\x03\x4a\xe1\x44\xc6\x6d\x96\xa7\xc5\x2d\x79\x2f\x48\x46\xbb\x82\xa4\x01\x5f\x15\x29\x33\x89\xc3\x6e\xd7\x7b\x1f\x47\x2b\xa4\xe2\x2b\x08\x35\xc9\x87\xf2\x5b\x1c\x6e\x64\x7d\xef\xb7\xe6\x08\x38\xd5\xd3\xe8\xba\xdb\xed\xbc\x17\xf2\xea\xdf\xe3\x08\xd3\x7a\xfc\x0a\xa4\xe1\x6f\x71\xd4\xf1\xa4\xb1\x78\xa4\x70\xd9\xef\xb1\x29\x29\x35\xd3\x7b\xc2\x7d\xb9\xdb\xdd\xdd\xfb\x29\x9a\xd2\xb2\x62\x27\x79\xed\xe9\x0c\xcf\x27\xbb\x3b\xbe\x20\xf5\xff\x1d\x47\xbf\xc5\xe4\xab\xc6\x18\xbd\xce\xbb\x78\xb1\x78\x1f\x77\xbb\x3f\xfc\xc8\xff\xdd\xdd\xfd\x29\x7a\x1f\xfb\x84\x26\x11\x8a\xfc\x7a\xfd\xb2\x98\x1c\x0e\x69\x79\x58\xa4\xcc\x7b\xbc\xe7\x93\x38\x89\xee\x30\x66\x02\xd8\xad\x06\x77\x6b\x38\xf3\xe0\x4e\xb0\x26\x81\x5b\xe4\x4f\x75\x05\x57\x5a\x70\x37\x33\xa4\x7c\x9a\x13\x30\x86\x5a\xee\xd2\xad\x8b\xa9\xb9\x99\x79\xea\x12\x9e\x86\xef\xc7\x55\x15\x7e\xf1\xc5\x16\xed\xf3\xcf\x37\xb4\xaa\x99\x7b\xb5\x24\x89\x55\xf3\x61\xa3\x6d\xf6\x66\x0e\xd8\xce\x5b\x33\x66\x3e\x82\xa7\xe3\x59\xe9\xac\x0c\xdd\xc1\x81\x1f\x15\xb7\xb9\x63\xcc\x41\xfc\x7e\x3b\xe5\x3f\xb4\x6a\xc0\x20\x39\xad\x99\x9c\x83\x49\xf7\xe7\xce\x05\x6a\xb9\x64\x63\xcd\x74\x20\xfb\xf3\x26\x04\x55\xfe\x99\x29\xbd\x05\xd1\xdf\x67\xcf\x09\xab\xad\xdd\x22\xcc\xfe\xbc\x49\x61\x9d\x2f\x9f\xd5\x92\x24\x49\xd4\xd9\x35\x08\xec\x34\xc1\x3b\x54\xe8\x96\xa8\xd4\x2d\xc9\xb6\xa4\x6f\xc8\xf6\x6e\x27\x8a\xde\xc6\xca\x86\x23\xee\x8d\xd8\xfc\x10\xf0\x8c\x59\x01\xb5\x46\x02\x7f\xee\xed\x3d\xe9\x44\x91\x2a\x69\x15\xc4\xe3\x11\xa8\xa4\x15\x9d\x93\x58\x80\x87\xf9\xa6\xb0\x44\xc8\x81\x7b\x29\xab\x69\x36\x16\x97\xde\x2a\xca\xa2\x1c\x99\xd2\x9a\x72\xb4\x47\xf7\x69\x4f\xa3\x6e\x10\x0f\xc1\xe2\xe8\x77\x3a\xd6\xaf\x4d\xe3\x18\xca\x19\xb3\xc4\x8b\xfd\xb6\x79\x66\x7d\xef\xf1\x1e\x2c\x06\x78\xf7\xdb\xfa\xa6\x84\xd3\xc9\x92\x73\x4a\x74\x75\x8d\x37\x64\xfb\x34\x8a\x61\xc8\x84\x46\x51\x44\x93\x6e\x37\x49\x84\x5c\xbb\xb1\x3a\x0e\xd2\x51\x7a\x9f\x87\x89\xd2\x12\xf7\xa5\xf2\xb1\x65\x22\xa8\x3d\xeb\xbc\x8b\xbb\x5d\x01\x19\xfb\x1e\x8d\x9e\x71\xd6\x5d\xf0\xbb\x68\x26\x60\x32\xfa\x2a\xc5\xe2\xc1\x21\x11\x16\x94\x50\x21\xec\x6c\x59\x47\xc4\x85\x81\xb5\x1c\xad\xab\xd7\xf1\xe2\x5e\x52\x97\xe3\x17\x6c\xbe\x58\xc4\x3d\x3a\xae\xc5\xaf\x09\xab\xe9\x0b\x36\xf7\xf9\x6f\x51\xa0\xdb\x95\x05\x50\x56\xdd\x4b\x86\xb4\xec\x76\x77\x7f\xc4\x5f\x92\x92\x92\xaa\x5f\x48\x0c\xa1\xa0\xb5\x39\x6d\xb7\x8c\x2c\xb2\x6c\x1d\xf1\x1a\xa8\xf8\x2a\xc6\x4d\xc2\xbd\x5b\xb3\x53\xa0\x78\x4e\xa2\x3b\x6d\x77\x13\xc4\x49\x43\x51\xd6\x34\x31\x14\xc4\x20\x1f\xfb\xbb\xd8\x8f\x83\x4f\x40\x2a\x22\xd9\x00\x05\xa1\x71\xd2\x6b\x62\x6d\xa1\x1f\x8d\xd7\x4f\xa8\x59\xed\x38\x4f\xef\xad\x24\x50\xe0\x4a\x3d\x4c\x97\x55\x97\x7d\xa1\xfa\x12\x76\x50\xc9\x3e\xc0\x5e\xc2\xf9\xee\x96\x1e\xfd\xc0\x44\x36\x11\x78\x9f\xec\xed\x3d\x01\xde\x58\xa0\x9a\x96\x8a\x30\x43\x3f\xec\xef\x7b\x5f\xc5\x3c\x3b\x59\x2c\xfa\xfc\x40\xae\x16\xda\xef\x47\xcd\xf4\xe3\x3c\xed\x76\xfb\x09\x28\x5f\xf9\x61\xf0\x03\x4f\x1e\x87\xd4\x3e\x0b\x28\xe5\xe2\x27\xda\xf7\x49\x3f\x3a\x8f\x35\x2d\xeb\xf5\xc5\xae\x11\xb6\xdf\x07\x50\x88\x36\x58\xe0\xb1\x88\x25\x5e\xe2\x13\x21\x74\x85\xb1\x63\x2e\xf3\x7d\x72\x10\x7b\x7d\x9f\xb0\xa8\xef\x07\x42\x22\xec\xd1\xe8\xdf\xf1\xfe\x00\x57\x28\x18\xe2\x5f\x7f\xdf\x8b\xa3\x0b\xb3\xb3\x38\xe9\x19\xa4\x90\xec\x19\x41\x30\xa2\xbc\xdd\xd8\xf7\x03\x41\x6d\x22\x28\x5e\x32\x12\x5f\x2d\x97\xe4\x8f\x04\x4f\xef\x48\xfc\x1d\x27\x0d\x31\xe6\x24\x91\xda\x90\xe8\x3d\x78\x40\xde\xfd\x91\xb4\x93\x82\x7f\x24\xbd\x92\x41\x00\xfa\x43\x74\x74\x1b\xb3\xf4\xbc\xa6\xb5\x69\xb1\xb6\xfb\xe4\x1b\x17\xa9\xd5\x38\x7a\x47\x3d\x43\x01\xe9\x87\x6b\xeb\x9b\xc5\x88\xb0\x10\x88\x7d\x34\x56\xcc\x13\x69\xbf\x81\x1a\x3d\x55\xf3\x79\x51\xe9\x18\x28\x96\xdc\xea\x8f\x24\xa2\xa6\x49\x68\x01\x33\x1c\x25\xfb\x63\xfe\x7f\xc9\xb7\x04\xe3\x24\xba\xa4\x57\xc1\x88\x97\xd6\xb8\x75\x9a\xa0\xb0\x74\x94\x48\xf6\x78\x94\x90\x38\x1a\x27\xe1\x38\x89\xc4\x22\x86\xb0\x66\x80\x65\x7c\xcd\x07\x5b\x6c\xf0\x24\xf1\x38\x0f\x2c\x26\xf1\x67\xb2\x5e\xa1\x9e\x27\x52\x61\x0e\x6b\x71\x86\x2b\x14\x14\x09\x11\x8b\x05\xc9\x27\xfd\xd7\x8c\xa5\x2c\x0d\xa6\x89\xc9\xe8\x94\x89\xe9\x8b\xef\x50\x2f\x46\x0d\x7e\x65\x5f\x7e\xb5\xbe\x30\x2a\x65\xad\x22\xea\x86\x15\x5c\x59\x75\x39\xbf\xb3\x33\x96\x22\xe4\xed\x1d\x34\x46\xf8\xc2\xe0\x6c\x66\x49\x74\x07\xfe\x13\x18\xa8\xa0\x66\xf2\x6f\x9d\x4d\xe0\xb7\x2b\x3f\xb6\xc7\x45\x42\xc7\x2e\x4f\x63\x13\x9a\x8d\xf9\x8f\x49\x91\xd7\x43\xfe\x03\xbd\xde\xf8\xaf\x29\xad\xaa\xdb\xa2\x84\xd8\x05\xe0\x7f\x00\x91\x07\x18\x2d\x13\x28\x58\xb3\x31\xfe\xf9\x58\xc3\x5f\xd1\xcb\xac\x84\xe4\x5b\xc6\x46\x10\xa0\xc0\xd0\x6e\x26\x86\x5d\x44\xb7\x4b\x7b\x79\x91\x32\x54\x4b\xe9\xdf\xb6\x67\xae\x24\x32\x94\x15\x4a\xbc\xdf\xe9\xcc\x92\x4b\x84\xc6\xab\xc0\xb2\x41\x89\xf7\x3b\x3b\x41\x67\xd7\x50\x52\x2a\x92\x05\x45\x86\x8b\x05\xed\x55\x65\x22\xa4\xfc\x8b\x05\x32\x60\x21\xed\x25\x45\x89\xaf\xdf\xa4\x59\x3e\x78\x5b\x49\xaf\xbb\x6e\x17\x4c\x63\xd6\xe4\x2a\xb6\xff\x31\xe8\xf7\xf9\x04\xf8\x9d\xb2\x6f\x9a\x21\x04\x14\xb6\xe6\x63\x62\x33\x9b\xde\xc7\x44\x73\x94\xf6\x9b\xce\xdd\xee\x9a\x8c\xde\x90\x56\xcf\x18\xe5\x94\x6c\xb7\xdb\xd9\xe9\x44\xeb\x5a\x30\x0a\x7a\xae\x4b\x5c\xd7\x37\xe3\x8d\xcc\x35\xcc\x75\x8c\x31\x2d\x16\x71\xb7\xdb\xf1\x5c\x9a\xa6\x70\x11\x4a\x51\xb8\xc9\x09\x1b\xde\xde\x71\xe4\x16\xb9\xbb\x45\x85\x55\x05\x48\xa2\x64\xb1\x30\x59\x2c\x3c\x63\x7e\x56\x08\x30\xcf\x4d\xb3\x1b\xd7\x27\x89\xed\xc9\x18\x13\xa1\xbc\x0f\x79\x5e\xd4\x86\xe6\x92\xcb\xf8\xca\x0f\x3b\x49\xb7\xfb\x91\x23\xc2\xdb\x21\x63\x63\x71\x33\x79\x6b\x57\xd3\x5a\x0b\xbc\xe1\x7b\x58\x93\xb8\x8f\x7b\x3b\x7c\x69\x56\x6d\x38\xfe\x32\xe1\x14\x5f\x28\x90\x41\x35\x22\x0d\xa8\x7e\xb7\x6b\x18\x47\xd9\x60\xdb\xed\x7a\x2e\x78\x27\xc7\xc5\x47\x80\xcc\xc5\xc2\x2d\x69\x9a\x81\x7b\xbd\xa5\x54\x3d\x30\xfa\x82\x7e\xf7\x5d\xe1\xd6\xec\x06\xd2\xbd\x53\x61\xa9\x01\xab\x0d\xa1\xf9\x11\x3c\x21\x3a\xad\x39\xa6\xb3\xe4\x84\x5a\x98\x1c\xfb\x24\x8d\x5c\x77\x8b\x5e\xc6\x60\xec\xd2\x59\x11\xbc\xc7\x7e\xfb\xa5\x92\xf0\xce\xd6\x65\x55\x4c\x69\xa9\xda\xe3\x21\x72\xda\xe9\xce\x88\xf2\x98\xf4\xf4\x07\x49\x40\xaf\x30\xc3\x9c\xce\x0e\xb1\x14\x86\x0a\x67\xc2\x00\xb4\x70\xc8\x5f\x92\xaa\xa1\x58\xc4\x99\x85\x30\x1c\x53\x8a\x04\x6a\xc1\xbb\x01\x13\xa1\x58\x56\x9b\x4e\xa1\xad\x46\xae\x6a\x10\xc5\xd5\x17\x25\x4d\x46\x59\x3e\x30\xab\xd3\xde\x35\xec\x08\xe4\x31\x61\xd9\x9f\xb2\x31\xab\x99\xc3\x57\xd8\xb2\x06\x7f\x8a\xb8\xc7\xae\xb2\x58\x78\xcd\x46\x00\x00\x0c\x69\xdd\xa1\xbc\xf7\x3b\x54\x1f\x37\x65\xe4\x60\x56\x85\x0d\x35\x82\x2d\x88\xa3\xd8\x93\x33\xf7\x7c\x21\x8c\x75\x5d\x61\xc2\x84\x00\x46\x7b\x02\xc2\xf6\xdd\xba\x9c\x31\x37\x70\x21\x8c\xa6\x8b\x3e\xca\x33\xe6\x87\x54\x9b\x36\xd1\x4e\x14\x25\xfb\x5e\xdc\x93\x2b\xe6\x51\x9f\x74\x76\x7c\x8e\x67\x79\xeb\x47\xfc\xd2\x19\xc2\xe5\xf0\x30\xde\x1d\xca\x36\x18\x76\x48\x7b\x08\x97\x0e\x05\xe1\xd7\x38\x4b\x46\xfc\x07\x44\x08\xe0\x3f\x80\x04\x5b\xe5\xda\x91\x53\x3f\x67\xe2\x31\x79\xd1\xbd\xc5\xaf\x1b\xc8\xf1\x38\x51\x46\x21\xd1\xb9\x41\xe8\x1d\x25\x3d\x9c\x24\xca\x28\xfd\x10\xd1\x42\xe4\x62\xaa\x1b\x16\x9c\xbc\x0c\xc1\x74\x42\x5b\x2e\xc3\x8b\xb0\x82\xbe\xfb\xb9\x49\xdf\x3d\x87\x7d\x06\x53\xc2\x70\x12\x7b\x9d\x5d\x03\x06\x4e\x0c\xa4\x00\x06\x65\x7c\xab\x0f\x13\xd3\x76\xda\x10\xef\x6a\x84\xee\xaa\x35\x42\x93\x4c\xc9\x7d\xc1\x48\x7e\x05\xda\xc3\xbe\x86\x7e\x4d\xa2\x79\xe2\x09\x34\xc6\xb1\x56\xa7\x55\xce\xb9\x58\x3c\xf9\xb1\x5d\x00\x6a\xd0\x3c\x67\x9c\x42\x7b\xc6\xe9\xf7\x67\x09\x88\x08\x92\x21\x20\x5c\xcf\x2d\x72\x19\xd2\x46\x2c\x17\x39\x4f\x7c\xbe\x22\x62\x71\x8c\x99\x9f\xc3\xcc\x05\xe2\x03\xbc\x6a\x46\xc3\xe9\x76\x4f\x12\xef\x67\xe0\x59\x68\x74\xcc\x7f\x12\x4a\xe0\x92\xf7\x49\x9d\x78\xcf\x13\xb0\x8b\xd1\xdb\x79\xa1\xb6\xd3\x95\xa0\x02\x8d\xee\x7b\x7c\xb0\xe4\x59\x12\xc5\x7c\x18\x09\x79\x96\xf4\x68\xfd\xa9\x11\xfb\x0a\x16\xc5\xb5\xc3\x1b\xd1\x43\x7f\x2b\x0f\xae\xdb\x02\x70\xd2\x62\x56\x4a\x7c\xac\x6f\xc5\x63\xc9\x0d\xc3\x59\xea\xa6\xdf\x35\xb6\x18\xcc\x8c\x1b\x15\x62\xa3\xfc\x7b\xbb\xfc\x89\x69\xc2\xdb\x0e\x22\xd8\x00\x30\xc8\xbf\xd9\x0c\xf2\x51\x42\xae\xb3\x0a\x9a\x80\xc5\x39\xc7\x07\xda\x59\x1a\xfc\xfa\x40\xd6\x39\x8a\xf7\x4b\xce\x09\x05\x42\xfc\xde\x8f\x98\x41\xf9\xb1\x75\x94\x1f\x1f\xbc\xb6\x37\xee\x9b\xa6\xc8\x7d\x7e\x31\x65\x63\x98\x02\xc3\x60\xb1\x68\xcb\xf0\x4b\x12\x8a\x77\xb6\xbc\x9b\xc4\x63\xbe\x9f\xf5\xbd\x5f\x13\x7f\x10\xbd\xc7\x8c\xbb\x41\xf4\x36\x01\xac\x38\x8a\x2e\x12\xc1\x0a\x1b\xc3\x21\x1d\xdd\x4f\x27\x6a\xc6\x72\x5a\x2c\xf4\xa5\xde\x91\x3d\x77\xbb\xe2\x66\x57\x29\x8b\x85\x37\x88\xde\xa1\x99\xb9\xb0\x34\x86\xed\x50\x87\xf7\x38\xf1\x06\xa8\x37\x1a\x75\xbb\x23\x8f\x12\x50\x68\x35\x80\x0b\x59\xd5\x18\x40\x3d\xee\x5d\x8b\xc7\xfd\x81\xe9\x58\x2c\x98\x9d\xe0\x73\x02\x3a\x51\x2c\x58\xb7\x2b\x43\x57\x44\x7a\x94\x1e\xe5\xb7\x1b\x13\xef\x50\xc1\x93\xdf\xab\x31\x2c\x3a\x51\xb4\x41\xf9\x9e\xb4\x86\x99\xe0\x87\xcb\xe0\xdf\x7e\x4f\xbe\x48\x9b\xf3\x7b\x42\xee\x6e\x32\x76\x8b\x66\x09\x28\x4b\x34\x35\x3b\xff\x4e\xa2\xbb\x83\x71\x1d\xb8\x28\x5e\x72\x89\xe0\x2d\x03\x57\x88\x9e\x5c\xf2\x8a\xd5\x34\x70\x85\x54\xca\x25\xe7\xc3\xac\x5f\x07\x2e\x44\x1e\xe0\x09\xc6\x18\xbf\x32\x30\xe9\x8a\x92\x59\x09\xa7\x06\x8c\x63\xb3\xac\x9f\x89\xf5\xdc\x5f\x4d\xe2\x9c\xa9\x47\xa3\x7f\x27\x9c\x7b\xdc\xef\x74\x38\x17\x69\xf1\x1a\x34\xd5\x04\xc6\x57\x06\x31\x19\xa7\x0f\x5b\xa5\x8d\xdf\x13\x7b\x9d\xe2\x94\xdc\x55\x10\x14\xe7\x37\x5c\x2a\xfc\xf8\x5d\x98\x8a\x8c\x33\x96\xd7\xbf\x99\x1f\x22\x67\x4a\x07\xec\x37\xfd\x53\x96\xc7\xb5\x13\x2d\x89\x95\xc2\x2f\x5c\x67\x11\x58\x0c\xd7\x14\x3f\x9a\x6b\x10\xd0\x94\xa0\x73\x80\xb4\x5d\xe1\xbf\x85\xed\x4a\xc9\xc6\xb4\x66\x69\x8b\x01\x98\x11\x69\xc5\x28\x02\xa4\x50\xbf\x2c\x26\x82\x31\x00\x64\xaf\x99\xb3\x7d\x4e\x51\xcb\xe0\xbd\x56\x41\x4e\xde\xa1\x3b\x75\x92\x46\x77\x93\x62\x56\xa1\x39\x59\x70\xd7\xb4\x76\x0c\xa4\xf3\x03\xe4\xbb\x2d\x7a\x25\xc8\x3d\x95\x4a\x23\xfc\xba\x61\xa5\x7b\xb5\x24\xd0\x30\x98\xa8\xdd\xd3\x30\xe4\x7f\x5e\xc3\x4b\x92\xa6\x16\x82\x4d\xd2\x4f\xa2\x51\x81\xc7\x75\x33\x92\xed\x69\x2e\x69\x62\x2d\x14\x62\x7b\x35\x14\x8c\x21\x63\x37\xd4\x31\xee\x00\x65\x25\xcf\xa2\xb4\x87\xb8\x3a\x8a\xa2\x74\x3f\x0d\x3c\x9e\x62\x45\xa7\xf1\xf7\x99\xb4\x44\x79\x97\xb1\x5b\x8e\x91\x90\xe9\x7d\x0f\xf5\x04\xaa\x0f\xad\xfe\xf1\xe6\xa5\x51\x4c\xe2\xc8\x8b\xa3\x96\xc1\xab\x1d\xf7\xf7\xff\x8c\xa5\xfd\xae\x1f\x08\x77\x39\x90\x85\x45\xd1\x46\xbc\x32\xe0\x7e\x24\x9c\xd1\xf6\x59\x80\xf4\x12\x8b\xa4\xe3\x1a\xa4\xc4\xd2\xd8\x2d\x4e\x0d\xaa\x2e\x49\x7b\x7a\x97\x09\x45\x94\x3c\x10\x94\x1d\xe4\x8c\x61\x7f\x79\x1a\x9a\x1c\xf5\xc3\x81\x3d\xea\x88\x85\x49\x7b\xa3\x00\x73\xd2\x3e\x20\x31\x1b\x65\x00\x8d\x3c\x4d\x35\xd1\x68\xb4\x1f\x3e\x8d\xe1\x8a\x00\x41\x90\x10\x1c\x0e\x48\xc2\xa1\x87\xa5\x11\xa5\x5f\x10\x7d\xb9\xb7\x12\x86\x5a\x63\xc9\x7e\xaa\xe4\x24\x9a\xd9\x95\x61\xcc\x0c\xc5\xce\x3e\x0d\xda\x18\x42\x50\xf2\xe8\x77\xf6\x16\x0b\x0a\x31\x38\x83\x86\x4b\xe1\x20\x35\xd8\x6a\xd8\x4d\xc3\x58\x17\x2c\x7a\x63\xc3\x84\xdf\x8f\x23\xf3\x13\x6e\xef\xac\xef\xed\x74\xa2\xc8\x8b\x7b\x18\xc0\xe2\x82\x0e\xba\x7b\xea\x5a\xdd\x0d\x57\x1b\x01\x33\x7a\x23\x85\xdc\x57\x7f\x69\xc8\x73\x62\xf0\x67\xd8\x0b\x1e\x6b\x4c\x3e\x4c\x35\x36\x03\x49\x80\xed\xfd\x02\x72\x50\x7f\x7f\x2f\x8a\x22\x98\xa9\x75\x3b\x64\x50\x77\xaf\x23\xf2\xc0\x15\xf6\x87\x1f\x94\xd7\x8f\xb1\x4a\x7f\x98\xab\x64\x9b\x0c\x2b\x66\xcf\x89\xb1\x19\x02\x23\x6d\x36\x46\x76\x21\x55\xe8\xac\xa4\xe5\x5d\x12\x51\x92\x46\x71\x18\x4a\xaa\x2c\x31\x56\xa5\x1f\xb1\x7d\xa6\x3b\x0b\xe4\x79\xeb\xb0\xc5\xa2\x23\x6d\x93\xb3\xbe\xc7\x7a\x10\x0c\x15\x0c\xad\xf1\xd9\x56\xe5\x33\x31\x88\x44\x66\x38\x40\xab\xec\x41\x14\x45\x4a\xa8\x99\xa5\x1e\xf3\x09\xec\x3a\x4f\x4f\xed\xf4\x38\x1c\x44\x83\x5e\x95\xc5\xe3\x2c\x1f\x2c\xe5\x74\x96\x59\xdf\x33\x06\xd9\x89\xa2\x54\x7f\xf9\x49\xc4\x48\x1a\xf5\x25\x59\xd7\xd9\x55\x33\x1d\xa9\x91\x8c\x70\x24\x23\x18\x09\x2f\xb4\x13\x26\x11\x0b\x79\x35\x98\xd2\x52\x64\xa6\x22\x33\x85\xe3\x2c\x33\x47\xd1\x48\x8d\x89\xaf\xc5\x00\x27\x3b\x92\x73\x6f\x6f\xbe\x0f\xad\xac\x69\xbe\x0f\xfd\xaf\x36\x3f\xd8\xdf\x30\x64\xf5\x3f\x3c\xe1\x6c\xa9\x61\x7b\xce\xa7\x8e\x91\x39\xb4\x0b\xee\xf2\x31\xe7\xcc\x01\x4a\x1b\xfb\xaf\x24\x5a\x5a\x7a\x2f\x7d\x7d\xf9\x48\xf7\x69\x60\x98\xf8\x8c\xc4\xd1\x07\xb0\x0b\x4d\xb1\x83\xa3\xec\xc9\xe4\x91\x0d\x95\x63\x53\xac\x1d\x9b\x62\xd3\xb1\x29\x0e\x85\x2e\x90\x83\x86\xf8\xab\xf7\x0c\x30\xbf\x48\x55\x07\x3a\x06\x36\x04\x21\x0c\xce\x6f\x27\x96\xcb\x82\xfd\x75\x8c\xe3\xbb\x58\x18\x1f\x51\xf3\xee\xb2\x4e\xfa\x52\x35\x63\x0e\xc0\xc0\x0d\x7c\x28\x72\xfd\x4d\x55\xa3\x71\x16\xc7\xff\xb5\xc5\xe9\x76\xbf\xe9\xc8\xec\xff\x53\xd7\x89\xcf\x7c\x02\xae\x52\x7a\xc5\x72\x0b\x7b\x19\x2e\x39\x69\x81\x63\xf4\xef\x68\x0f\xec\xa9\xeb\xa2\xac\x94\xb3\x37\x9e\x08\x40\x53\x18\x7b\x20\x8a\xc3\xc4\xc4\xe3\x89\x89\xae\xc2\x24\xd2\xc0\x0f\x68\xce\x02\xf5\x22\xaf\x69\x96\x33\x78\xbe\x5c\x38\x02\xe3\xb2\xb5\xf6\x1c\xfd\x19\x7b\x89\xbf\x44\x8f\xb1\xd8\x17\xdd\xef\x84\xc9\x8f\x66\x71\xa1\x42\x4a\xb6\xb6\x7c\x40\xcb\x32\xe3\x32\xb9\x22\x45\xea\x71\x62\x75\xfa\x92\xdd\xb0\xf1\x05\x88\x5d\x09\x35\x19\x0d\x10\x51\x98\x09\x3e\x6a\x83\xa6\x69\xd4\xd9\x21\x45\x2a\x43\x67\x68\x97\x48\x58\x45\x9e\xdd\x31\x04\x3d\x6f\xa5\x30\x43\x9e\xef\xfd\x84\xf6\xc6\x20\xa7\xf7\x12\x12\x93\x32\x35\xde\xfe\xa1\xbe\xdf\x70\x73\xab\xd2\xb6\xfa\x42\x0e\x77\x4f\x03\x7a\x73\xcb\x54\x89\x15\xa6\xa9\xf4\xba\xbe\x45\x73\x0c\x5c\xc6\x50\x84\x80\x4d\x16\x0b\x23\x7a\xa2\x92\x1b\xc3\xb9\x10\x17\x64\xe2\x83\x96\x00\x28\x3c\xbe\x4b\x93\xd4\xb2\xbe\x4c\xa3\x49\x2a\x2c\x2e\x53\x6b\x71\x23\x1a\xa6\x96\xe5\x79\xcc\x0b\x68\xdb\xf4\x24\xa4\x51\x8a\x9c\x3d\x8d\xee\xcc\x9a\x01\x25\x46\xbd\x20\x26\xba\x56\x90\x10\xb5\xa5\xc1\xe5\xd5\x12\xd4\x6e\x75\xe2\xe5\x10\xe5\x43\x2a\xdc\xec\x5d\x46\xb9\x9e\xb5\xaf\x32\xc9\x18\x8e\x48\x69\x42\x52\xb4\x43\x76\x77\x7e\x52\x73\xee\x76\x27\xca\xd7\x70\x29\x0c\x15\xea\xb4\xa9\x9c\x1c\xb0\xda\xb9\xc6\xd0\x76\x06\xb3\x39\x4d\xc1\xdf\xd2\xb9\x1e\x82\x83\xed\x85\x18\xa2\x2e\x50\xa0\xbc\xfb\xb9\x95\x6d\x71\x68\x45\x1a\x51\x28\x73\x8c\x8d\x07\x7f\xa6\x24\xab\xe4\xc7\xaa\x00\x9d\x77\x59\x97\x74\x8a\xf6\xd4\xa8\x30\x0a\xde\x42\x92\x90\xe2\x8a\xb4\x2a\x25\xd2\x9b\x00\x13\xca\xd4\x54\x93\xce\x52\xd3\x7f\xff\x6e\x19\x82\x62\xcf\x14\xb9\x5c\x71\x1c\x69\x89\x85\x92\x4b\xf7\x3d\x8b\x47\x59\xed\x6e\xd1\xab\xc8\xbd\x15\xbf\x01\x5f\xbc\x2a\xfe\xc2\xd4\x09\xff\x01\x49\x93\x0a\x53\x5e\x9d\x8b\x84\x53\xfc\x2e\xdc\xad\x66\xcb\x4a\x11\x84\x81\x75\xd3\xe8\x8e\xe6\xd9\x04\x98\x3e\x96\xa7\xc1\x2c\xf5\xdc\x03\x99\xe0\x12\xfd\xfb\x38\x4f\x5d\x9f\xa8\xb2\xf8\xb2\x68\x56\xe4\xeb\x6b\x9c\xc8\x22\x66\x3d\x8c\xd3\xba\xb6\x0e\x1a\x96\xf8\x7c\x91\x73\x34\x98\x90\x83\xba\x50\x29\x2e\x31\x3e\x60\x58\x4b\x72\x9b\x46\x77\x4b\xf2\x91\xff\xdb\xd4\x41\xa6\xf7\xeb\xe8\x7a\x10\xc9\xd0\x9c\xa8\x6d\xcc\xba\x58\x78\x42\xf9\x71\x93\xf6\xcc\xa5\xd2\x1f\xa4\xa5\x80\x5a\x9f\xfb\x8b\xc1\x72\xe8\x4f\xdf\x9a\x5a\x73\x20\xba\xbe\xb5\x3c\xc6\x97\xa5\x02\x4d\x85\xa4\xf6\x36\xbd\xa4\xca\xe5\x1c\x3e\xe0\xbe\xb8\x31\x93\xa9\x50\xbe\x40\xa2\x19\x1a\x27\x46\x5f\xf4\x96\xc8\x37\x90\xfd\x31\xb5\x1a\x8e\xe2\xcb\x44\xba\x4f\xbb\x2e\x82\xd8\x5f\x29\x20\xa8\x83\xb8\x28\xeb\xc0\xa5\xfc\x8f\x4b\x78\x82\x01\x59\xc1\x3c\xf5\x5c\x73\x71\x5d\xce\xd6\x5b\x09\x56\x15\x05\x5a\x76\xc5\x4c\x43\x9c\x59\x5d\x27\x5b\x8d\xa0\x7d\xa9\xd5\x40\x85\xe0\x67\x56\xc6\x24\x22\xc4\x96\x81\x1b\x8f\x67\x25\x7c\x1e\x82\xb3\x45\xe0\xa2\xd3\x85\x4c\x82\xf8\xcd\x3c\x8d\xf3\x89\x66\xe2\x05\xc6\x70\x54\x79\x22\xa6\x23\x16\x41\xd5\x92\xd4\xb3\x10\x29\xfd\x0e\xdc\x04\x84\xe0\x98\x50\x54\x10\x30\xb8\xa8\x44\x09\xdb\xe6\xd7\x35\x8c\x8c\xe4\x7a\x35\x2d\xb6\xac\x42\x7a\x62\x2b\x66\x56\x56\xb9\x99\x30\x3e\x85\x82\x79\xcd\x3e\xd6\xaf\x58\x3e\xe3\x45\xe0\x63\xc2\xf2\x99\xc8\x9c\xf2\x99\x17\xd3\xb9\x4b\x36\xf8\xf7\x8c\xf7\x37\xc3\x2e\x8c\x20\x21\x81\x9b\xc6\x63\x3d\xaf\xa3\x92\x0e\x02\x37\x2d\xe9\x40\x7d\xc2\x74\x78\x8a\x9c\x07\x26\xd6\xac\x94\xc9\x20\xe8\x92\x19\x1f\xb3\x5a\xa4\x7f\xcc\x6a\x95\x8c\x42\x2d\x48\x47\xf9\x86\xcc\x38\xbd\x91\xed\x14\x37\x46\x33\x62\x81\x78\xba\x5e\x99\xa3\xb2\x98\xf2\xb4\x62\x8a\x9f\x33\x84\x23\xb9\x5f\xa9\xf8\x36\xf6\xed\x78\x32\xad\x33\x88\xcd\x8b\x3f\x30\x31\x4f\xca\xf9\xb4\x86\x64\xf9\x53\x64\xa4\x98\x98\xca\x04\x08\x61\xe7\xc2\x43\x20\x90\x80\xb1\xc1\xdd\x3e\x68\x75\x88\x54\x73\x04\x42\x7a\x4f\xb4\x6a\x25\x70\x47\x6c\x9e\x16\xb7\xb9\x4c\x04\x8b\x47\x48\x9d\xa2\x01\xb9\x54\xcb\x40\xda\x0c\x67\xf4\x12\x02\xc7\x1f\xd1\x9a\x06\x2e\x06\x91\x07\x9b\x56\x99\x85\x89\x46\xc9\x57\xac\xa6\xa9\x51\x7a\x22\xbe\x55\x11\xb1\x8c\x3c\x57\x2c\xe3\x86\x69\x93\x1b\xa0\x70\x48\x8d\x53\x05\x78\x11\x19\x93\x42\xec\x94\x94\xa7\x89\xf4\x42\x4c\x56\xc9\xf4\x64\xba\xdc\x42\x11\xfe\x45\x24\x8b\xd9\x81\x4d\x68\xe0\x4e\xc1\x34\x14\x13\x66\x15\x24\xcc\xc4\x21\xc2\xe3\xaa\xce\x2a\xff\xcc\xf2\x01\xa6\x64\x39\x82\xe4\x9b\xb2\x18\xe0\x5a\x4e\xc5\x2f\x48\x3e\x83\x47\xfe\x10\x10\x4a\x5a\x33\x03\x08\xce\x93\xb2\x18\x8f\x03\xb7\x82\xbf\x98\xc4\xd8\x88\x6f\x75\x05\x7f\x55\x12\x74\x56\xe1\x0f\x91\x68\xa9\xd4\x02\xa1\x1c\xb2\x81\xec\xbc\xa6\x63\xd0\x34\x57\xf8\x03\x13\x67\xd5\x94\x5f\x96\x6e\x85\x3f\x20\x51\x19\xfe\xa2\x0d\xd1\x89\x82\x9a\x8b\x6c\xc2\xe4\x61\xaf\xb3\x09\x33\x4e\xf9\x45\x31\x18\x8c\x79\x32\xfc\x15\x49\xb3\x64\x28\x11\x5e\xcd\x3f\x0c\xac\x07\x99\x70\x66\x21\x47\x75\xcd\x3f\x70\x6b\x21\x1d\xb7\x76\x43\xe6\x08\x40\x81\x2c\x7d\xe0\xac\x8b\x1d\x70\xb3\x75\xd5\x01\x6a\xb6\x53\x78\xad\x77\xc5\x78\x36\x51\x9b\x71\x03\x5f\xc6\x72\xbd\xa7\x10\xcc\x35\x70\x6f\xf1\x07\x26\x0e\x19\x9f\x0c\x9a\xc9\x2c\xc9\x01\x10\x10\x4f\xd3\x68\x87\x1c\xa6\x91\x8b\x42\x2f\xe5\x29\x7b\x72\xe4\x6e\x79\xae\xbb\x65\x45\x8c\xd1\x51\x62\x34\xad\x77\x04\x97\xae\xa0\x68\xb5\xdf\x97\x7d\x7d\x8a\xf8\x74\xe4\x10\xc3\x12\x5d\x1e\xa6\x57\xd1\xd3\x74\x6b\x8b\x1c\xa4\x97\xf0\x75\x15\xdd\x2d\x15\xa5\xa6\x12\x35\x93\x73\x9c\xca\xe7\x94\x42\xb0\x30\xeb\x67\x65\x85\x4f\x26\x86\x10\x20\xc6\xf8\x56\x9a\x74\xc3\x23\xdb\xa2\x47\xa1\xad\x90\x1a\x51\x0b\xd2\x30\x41\x5e\xfb\x31\x18\xc2\x4a\x8b\x2f\xff\x2e\x8d\xe8\x56\xd2\x33\x9c\xc6\x25\xc3\x98\xf5\x3d\xfa\x63\x14\x77\xbb\xe9\x4f\x2a\xe6\xfc\x1d\xaf\x17\x24\x04\xa3\x11\x07\xf1\x36\x5d\x02\xcf\x42\x03\x1c\xb8\xe8\x23\xe9\xe5\xec\x63\x7d\x8e\x9c\xb7\x7f\x97\x44\x56\x82\x8c\xb3\xb4\xe4\xe9\xda\xde\x6c\x29\x23\xdc\x2c\x61\xfc\x89\x19\xab\xeb\xe7\xf4\x4b\xcd\xef\x9c\xb8\xdb\xf5\x0c\x1b\xbc\x6e\x17\xce\x8c\x30\x7c\xc2\x60\x75\x96\x21\x1e\xc0\xa2\xd4\xe0\x37\x5e\x64\x10\x6a\xe6\xe7\x69\xf4\x50\xff\xab\xdd\xdd\x9f\xda\xfd\xaf\xc8\x49\x1a\xdd\x21\x1a\x78\x98\xf5\x09\xe2\x10\xdb\xfa\x04\xd3\x1e\xe4\x23\xa2\xee\x78\xcb\xf2\xa4\xcd\xe0\x44\xa1\x75\x47\x63\xe0\x4f\x1a\xa2\x90\x5f\x52\xe4\x17\x5f\x88\xbf\x2f\xc5\xdf\x57\xa9\xed\x50\xf2\x5a\x33\xe2\xaf\x52\x8c\x0e\x14\x45\xbf\xa4\x8b\xc5\x2f\x69\x27\x8a\x52\xea\xf9\x2b\x2a\x92\x24\xfa\x25\x0d\x35\xca\x44\x6e\x22\xcb\x9d\xa4\xdb\xfd\x99\xc3\xc9\x7e\x12\xdd\x21\x07\x92\xf4\xec\x52\x84\xa3\x4e\x23\xf1\x38\x4f\x97\x42\xbf\xd3\x1b\xb0\x5a\xcd\x68\xdf\x4b\xa2\x96\x64\xcf\x27\x09\xe7\xa4\x92\x61\x81\xd1\x89\x92\x9e\xfe\x20\xf8\xf3\x14\x4f\x82\xcc\xc1\x4f\x02\x37\xbb\xa8\xa2\x7e\x63\xaa\xaa\x60\x7c\x2d\xfd\x40\x02\xbf\x04\xdb\x97\x69\xb7\xcb\xa8\xf7\x32\x25\x89\x8f\x82\x22\xef\x65\x1a\x25\xc4\x36\xee\x39\x49\xc5\xe4\xc8\x8b\x94\x60\x1c\x42\xa1\xae\x11\xe6\x07\x8a\xa3\x8f\x7e\x49\x09\xd8\xf8\x10\x2a\xa0\xf8\xd4\xd6\xe5\x9d\x7c\x5a\x97\xd7\xa6\x60\x53\x40\x1d\x3c\x81\x10\x54\xca\x94\x34\x0d\x1a\x7a\x37\xd2\x07\x0e\xc5\xeb\x47\x1d\xe6\xfb\x77\x34\xb8\x63\xd1\x51\x8a\xe1\x4d\xce\x68\x4f\x42\x73\xa8\xa5\xf2\x3b\xe1\xe0\xc7\xbe\x44\x47\x03\x19\x09\x6d\x14\xf5\x2f\x07\xc8\xed\xac\x3c\x63\x34\xf2\x17\x8b\x0e\xbb\x1c\x5d\xf9\x77\x10\xf9\x54\x62\x9a\x25\x84\x51\xe5\x3d\x2f\xb3\xbe\xd7\xb7\x40\xac\x69\xe4\xd1\xe6\x87\x82\xf6\x37\x81\xb4\xcd\x30\x70\x04\x5b\xc1\x11\xbf\xa4\x11\xe3\xc7\x20\x96\x67\x20\x14\xf1\x51\x6c\xbf\xa5\x97\x69\xf4\x22\x8d\x7e\x69\x2f\x62\xb8\x3b\xbd\x02\x37\xf9\x46\xbe\x71\x9e\x9b\x4e\x52\xda\x27\xcb\x81\xb3\x47\x5e\xa7\x1e\x2a\xf2\x64\xb1\xe6\x41\xe6\xd3\x7a\x9e\x0a\x41\xe3\xc6\xaa\xbb\x56\xbb\xc7\x97\x23\xda\xb5\xe4\xaa\x86\xf9\xc2\x9b\x07\x1a\x0f\x34\x4c\x2c\xde\xa4\x44\xcb\x2e\x5e\x4b\x55\x1c\x61\x63\x3a\xad\x58\xca\x09\x1c\x61\x1f\x50\xb1\x59\xaa\xb4\xec\x4d\x6f\xdd\x5f\xbf\xac\xf3\x5f\x53\x72\x97\x8c\xb3\x69\x5c\xd0\x12\xe9\xe7\x55\x63\x00\xd7\x2a\x20\x1d\xc5\xec\x5a\x02\x97\x58\x89\x56\xe8\xaf\xb3\x07\x8e\xaf\x69\x58\x71\x96\x92\x3b\xdb\x5a\x41\xcc\xdc\x08\x89\x61\x89\xb1\xa5\x6f\x1d\xe7\x42\xc1\x45\x09\x07\x8c\xb6\xe1\x22\x89\xec\xa0\x4e\x7e\xf7\x31\x5e\x90\x1e\x8d\x76\x1f\xfb\x7e\x40\xa3\x58\x99\x89\xef\xfd\x18\xd1\xc5\x02\x4a\xd0\x7d\x1a\xec\x20\x0a\xb9\x48\xa3\xbb\xe3\x2a\x09\xdc\xe3\x2a\xa1\x53\xe6\x12\x78\xc4\x23\xa6\x65\xe0\x3a\x2e\x79\xc9\xfa\x75\xe0\x1e\x94\x65\x71\xcb\x7f\xba\x84\x53\xf2\xf0\xf9\x76\xea\x92\xb3\x6c\x30\x94\xd9\xf0\xdb\x25\xc8\x4b\x40\x0a\x40\x1e\x39\xe2\xc4\xdc\x11\x08\x48\x5c\xf2\x3e\xcb\x03\xf7\xf4\xdc\x25\xc8\xa9\x9a\x47\x80\x1c\x4c\xa7\x55\x23\x49\x92\xeb\xf8\xf7\x65\xc1\x39\xd3\x57\xc5\x5f\x6f\xca\x2c\x87\x73\xfa\x82\xcd\x03\xf7\x6d\x9e\xa5\x2c\xaf\xe1\x05\x47\x77\x49\xde\xa6\xd1\xdd\x0f\x81\xfb\x94\x26\x23\x8c\xcf\x4f\x9e\x04\xee\x05\x8d\x5d\xb2\xbb\x17\xb8\x87\x63\x46\x4b\x97\xec\x3e\x0e\x5c\x61\x95\xb1\xfb\x5d\xe0\x82\x05\x8f\x4b\x76\xbf\xc7\xfe\xcb\x62\xec\x92\xdd\x1f\x02\xf7\x60\xcc\x53\x9f\x04\xee\x1b\xe4\x4b\xf6\x76\x02\xf7\x90\x4e\x2b\x1c\xc9\xde\xf7\x7a\xd1\x1e\xef\xc1\x72\x3d\x7e\xcc\xcb\x0e\xf8\x01\x26\x8f\xbf\xc1\xdf\xb8\x0c\x8f\xbf\xe5\x3d\xa6\x2e\x79\xfc\x5d\xe0\x3e\x2f\x26\xbc\xce\xf7\xd6\xca\x3e\xfe\xc1\x58\xd9\xc7\x4f\xec\x65\xfd\x66\xc7\x5a\xd4\x6f\xbe\x0d\xdc\x93\xbc\x62\x9c\x38\xff\xe6\x3b\xbd\xbe\xbb\x7c\x8e\xcf\x76\xf9\x8f\xc7\x81\xfb\x6c\x8f\xff\xf8\x26\x70\x9f\x3d\xe6\x3f\xbe\x0d\xdc\x67\xdf\xb8\x64\x63\x97\x4f\xf9\xd9\xb7\x3c\xe9\xfb\xc0\x7d\xf6\x1d\xff\xf1\x43\xe0\x3e\xfb\x9e\xff\x78\x12\xb8\xcf\x7e\xe0\x6b\xb5\x13\xb8\xcf\x9e\xf0\x1f\xbb\xbc\xc5\x1d\xfe\x0b\xda\xe6\x8d\xef\xf1\xc6\x77\x79\xeb\xdf\x7c\x13\xb8\xaf\x67\x13\x5c\x90\x5d\x3e\x2c\x73\xaf\xf6\xf6\xbe\x09\x5c\xce\x99\x9a\x36\x51\xef\xbe\xd4\x22\xe9\x5d\x4a\xee\x46\x6c\x6e\x9d\x67\x50\xe3\x8f\xd8\x5c\x9e\x96\x8b\xf4\x12\xbe\xaf\x16\x0b\xf8\x0b\x66\x7c\x16\x84\x74\x8c\xd7\x97\x62\x81\xf8\x34\x2f\xae\x48\x4a\x7e\xbc\xe0\x18\x12\x71\x60\x04\xbc\x04\x6d\x2e\x83\xd4\xf7\x35\x97\x6f\x52\xa5\xc8\xcf\xeb\x46\xdf\x8a\xe1\xf1\x5a\x57\x8b\x85\x3d\xb2\xc0\x75\x97\x64\x5c\x24\x28\x3f\xfb\x62\xb3\xa9\x92\x4d\x19\x15\xe1\x80\xc0\xd1\x86\xad\x37\xa7\x92\xe8\xa3\x0d\x47\xb6\xac\x09\x2c\x48\xb0\xb3\x24\x62\x0a\x6b\xaa\x7d\x72\x19\xd4\x1a\xf0\xb6\xc0\xdb\xf2\x53\x03\xd8\xb0\x46\xf0\xd9\x9d\x98\x78\xfb\xfd\x03\xe1\x2f\x4e\x6d\xf0\x7b\x9f\x62\x18\x08\xe0\x84\xfb\xac\x5c\xb9\xb0\x7e\xfb\xc2\x0b\xe1\xb7\x94\xdc\x21\x83\x5e\x99\x01\x9d\x2e\xcc\x24\x64\x9a\x53\x2b\x6d\x2d\x04\xdc\x03\x35\x2d\x40\x60\x4e\xe1\xf7\x2f\xbb\x73\x7f\x4f\xc9\x9d\xf5\x6c\xe8\x67\xdc\xf7\x46\xcc\xef\x2f\xdc\x98\x7f\xf3\x8d\x61\xe3\x9a\xfe\xd6\x06\x45\x98\xa3\x9c\xc1\xb1\x1c\x4a\x17\x8e\x8c\xac\x6d\xda\x33\xd2\x38\x5c\x42\xd1\xdf\xd7\x36\xf9\xbb\xd5\xe4\xef\x66\x93\xbf\xb7\x34\x69\x15\x68\xc9\x57\x3d\xfe\x5b\x1a\xa6\x8e\x6b\xca\x99\x4c\xd3\x36\xf5\x2b\x90\x85\x50\x06\x0f\x34\xa0\xc4\xde\xa1\x86\xb4\x5e\x7f\x28\x39\xbc\x4e\xc2\x68\x09\x31\xe7\x26\x51\x46\xc4\xff\xbc\x19\xd3\xb9\xfc\x2b\x04\xe1\x0e\x88\x80\x1d\x90\x67\x3b\x89\xc1\x74\x26\xc5\x74\xee\x24\xb3\xda\x49\xb5\xcc\xd8\x49\x4b\x3a\x80\x7f\x78\xf7\xa9\x14\x07\xe3\xaf\x8f\x59\x0d\x3f\x40\xe2\x0b\xbf\x4e\x6f\x44\x1e\x0e\x26\x2d\x8b\xa9\x93\x5a\xb2\x5b\x47\x88\x67\x1d\x25\x8f\x75\x40\x08\x2b\x1e\x9d\x06\x86\xcb\x01\x51\x80\x93\xe5\xf0\x8c\x9d\x33\x12\x0c\xf0\x48\x06\x49\x18\x01\x1b\x3c\x2e\x68\xea\x8c\x95\x18\x55\xfc\x94\x72\x52\xf8\xc4\x51\x4c\x14\xb3\x3c\x91\x42\x4f\xfc\x75\x3a\x13\x99\x30\xec\x89\x60\xa3\x41\x68\xe9\x80\xa4\xd2\x99\xf2\xe5\x13\x22\x49\x47\x0a\x21\x9d\x52\x09\x20\x9d\x92\xc1\x8b\x4f\x70\x27\x3a\x28\x62\x74\x84\x54\xd1\x11\x32\x42\xa7\x9a\xc5\xf0\xca\x13\x4a\x07\x9d\x5a\x09\x00\x1d\x14\xf4\x39\xb5\x16\xf2\xe1\x6f\x8c\xe4\x21\xa4\x78\xf8\x4b\xc4\xc2\x30\xa5\x74\xce\x8d\x21\x7d\x73\x84\x88\xcd\x41\xb9\xda\x03\x1f\x2d\xba\xdc\x69\xbc\xcb\xb6\xb5\x41\x85\x70\x6d\x17\x1c\xe5\x8a\xdc\xdd\x8a\xc3\x38\xe2\xac\x05\x68\x38\xa3\x4f\x0b\x42\x12\x2d\xff\x48\xb6\xdc\x75\x71\x57\xe2\xab\x65\xf8\x15\xa8\xae\x92\x90\xb2\xcb\xf8\x2a\x4a\xa4\xe1\x6d\xcc\x2c\xae\xf7\xab\x87\x72\xbd\x94\x49\x15\x1b\xb3\xb8\xc7\xf6\xc0\x18\x3a\x30\x01\xa7\xad\xcf\x53\x2f\xb1\xc5\x1a\x9f\x66\xb2\x68\xf4\x2e\x6d\x67\x1c\x9b\x4c\x29\x8d\xce\x56\x4a\x8a\x68\xee\x59\xdf\xdb\x03\x71\x1f\x9a\x3b\xb7\x0f\xa1\x25\xfe\xfb\x9a\x80\x1b\x2b\xb1\xdc\x4d\x9e\xd3\x4e\x39\x9d\xd5\x2b\x49\x37\xcc\x1c\xbd\xc5\xc2\xd2\x28\x5e\x99\xc3\x51\x49\x07\x46\x79\xa1\x43\x5a\x49\xa9\xad\x56\xa5\xee\xa8\x91\x84\xc6\xce\x76\x5a\x63\x3c\x4a\x5d\x64\xa5\x15\xb0\x15\x1b\xef\x57\x46\x67\x08\xcf\x8d\x0a\x52\x6a\xde\x4c\x6a\x2c\x9a\x96\x95\xf3\xd6\x7f\x5b\x69\xdc\xd2\xcf\x07\xab\xc9\x5a\x09\xdf\x92\xa9\xda\x7d\xb3\x3a\x68\x4b\xc3\x1e\xd0\xe8\xf7\x95\x22\x48\x82\x43\x5e\xd2\xcc\x03\xe9\x3a\xcf\xfa\xf7\x2a\xc0\x15\xd3\xb9\xb9\xb9\xd6\xf6\x8b\x28\x1e\x34\xfa\x55\xd6\xd3\x11\xf6\xcf\x97\x9c\x4d\xd5\x12\x2d\x26\xed\x8e\x21\x02\x81\x12\xe2\x2e\x97\x61\x91\x46\xab\x87\x93\x46\x46\x1c\xfd\xd0\x72\x49\x0b\xb3\xb8\xd7\xfe\x4c\x83\xe7\x9e\xa1\x4f\x34\x2b\x8d\x2c\xe7\x1c\xfc\x6f\xcd\x94\x0b\x3a\x35\x3f\x75\xe8\x57\x33\x15\x71\xa4\xd5\x10\x08\x58\xcc\x14\x23\x56\x94\x91\x6c\x62\x52\x3f\xdc\x78\x47\xa3\x1a\xbc\x37\xd6\x06\x1a\x0f\xdf\xcb\x22\xcd\x80\xe7\xe1\x6f\x32\xa7\x19\xbc\xbc\x75\x19\xc4\x9b\x14\xde\xdd\xca\x9c\x83\x98\x91\xd6\x79\x06\x69\x4a\x56\xa6\x1a\xfc\x96\x90\x95\xd9\x06\xa7\x29\x69\x9f\x70\x90\x25\x82\x1a\x49\x58\x74\x79\x45\x52\x16\x6d\x1b\x31\x05\xde\x71\x34\xba\xf3\x53\xca\xc0\xc1\x42\xda\x7d\x26\xec\x32\x65\x57\x04\xff\x44\x82\xc0\xd9\xde\x36\x7d\xc6\x50\xa4\x9c\xb2\xad\xad\x50\x14\x53\xd5\xf5\x63\x31\x51\xbc\xcc\xd9\xad\x73\xce\x30\x1e\x2d\x63\xd1\x9d\xc8\x09\x0e\x97\xe4\x37\xfd\xd5\xd9\x5d\x92\x3e\x8b\x0e\x8d\x48\x3f\xcc\x70\x06\x19\xf2\x8f\xfd\x3e\x0b\x98\xb2\x4d\x35\xf4\x30\x19\xb3\xdf\xf5\x90\x11\x02\x39\xae\xc3\x27\xa8\xac\xf7\x3d\x0e\x85\x9f\x6b\xe3\x01\x90\xb4\xdb\x4d\x7b\x8d\x27\x0a\x5e\xb1\x49\x91\xfd\xc5\xd2\xb7\xf9\x84\x56\x23\x96\x82\x2a\x48\x60\x51\xe3\xe9\x72\x67\x6d\xc5\x57\x2b\xd5\x84\xcb\xc4\xdd\x92\xf4\x41\xec\xda\xc7\x57\xb1\xd8\x65\xff\x2a\x8a\x2f\xfb\x10\x05\x1a\x44\x45\x66\x2c\x8d\xcf\x19\x56\xbc\xbe\xfc\xea\x68\x22\x66\x44\x23\xd4\xa6\xeb\xe6\xda\xef\x45\x2a\x72\x3f\x3a\x99\xc9\x05\x36\x9a\x81\x55\xd6\xf5\xff\x80\xfa\xd0\x4a\xb7\xeb\xbd\xf3\x7e\x23\xd4\x27\xef\x3c\xc6\x1a\x0e\x97\x23\x26\x6d\x0c\xb1\x65\xdc\xdd\xaa\x28\xc1\x46\xf9\x3b\xc3\x46\xf9\x3d\xaf\x1c\x13\xea\x87\xef\xbd\xdf\x48\x62\x45\x20\x1f\xb3\x35\xcf\xba\xc0\xf3\x3a\xed\x63\x05\x39\x83\xf2\x4d\xe8\xd8\x7e\xec\xe6\x02\x69\x6b\xdc\x24\x5a\xc9\xf4\x7c\x3b\x52\x6d\xe2\xc3\x9f\xd4\x8c\xa4\xb2\xf3\x83\x4b\xc0\x61\x02\xc4\x07\x18\x7b\x94\xe8\x55\x87\x70\x95\x7c\x09\x8c\xf7\x40\x98\x74\xe9\x86\x15\x5c\x75\xeb\xd6\x60\x1b\x47\x71\xb7\x1b\xaf\xdd\x6e\x56\x0e\xec\xed\x5e\x2c\x0e\xc3\x3e\x8b\xf4\x29\x6a\x2c\xec\x6f\x32\x9d\x28\xc7\xe4\x8e\xe9\x6d\x90\xaf\x5b\xea\xd0\x7c\x3a\x6e\xf7\xbb\x27\xae\x88\xab\x22\x8c\x33\x61\x8b\xfa\xcc\x0f\x93\x87\x8f\x35\x4a\x43\x84\x9c\x50\x40\x0e\x8e\x15\x4c\x2c\xc1\x5e\x53\xe4\xf2\x71\x43\xb4\x7e\x3d\xcc\xdf\x25\x58\x89\xf8\xbf\x2a\x2a\xf1\x88\xcd\x65\x34\x62\x35\x74\x74\xf4\xab\xa5\x89\xa6\xc8\x45\xb5\xa9\x08\xaa\x0a\x4e\x0c\x10\x12\x55\xdb\x3c\xeb\xb2\x10\x7f\x2d\xda\xc1\x8f\x89\x98\x0f\x70\xeb\x58\x1d\x2d\x02\xe0\xc5\x94\xc8\x2a\x03\xf7\x8c\x08\x88\xca\x20\x5a\x88\x91\x52\xb2\xbe\xd5\x07\x2e\x97\x84\x61\x3a\x88\x12\xcc\x51\xae\x29\x72\x04\x63\x5a\xd5\xc7\x90\x88\x0d\x81\x0e\xdb\x4c\xc8\xd9\x47\xf9\xad\x3b\x60\x1f\xa7\x19\xd2\x37\x9c\xff\x97\x6d\x29\x97\x82\xe6\x7b\x5f\x85\x3a\xb9\x12\x97\x6a\xd7\x13\x61\xd4\x9b\xee\x7b\x18\xd8\xf5\x77\x0f\xd0\x07\x01\x01\x0f\xa1\x2d\x73\xf1\x49\x8a\x1b\x20\xdf\x15\x32\x76\xc7\x3a\xcf\xc6\x80\x28\x31\xfa\x8c\x52\x3f\xf0\x52\x73\x2d\x48\xda\x9c\x27\x49\xad\xa5\x10\x49\xc6\x6a\xa1\x6d\x71\xda\x5c\x8a\x24\x4c\xed\xed\x89\xc3\x54\x80\x04\x15\x46\xf7\x69\x63\x4b\xa9\xfd\x6d\xe4\x23\x58\x50\xfb\x3b\x4c\x2d\x18\xa1\xe6\x57\x98\x2a\x58\xa4\xca\x80\x3f\x15\x30\x27\xde\x6f\x0c\x53\x80\x16\xca\xff\x0d\x55\xd0\x0a\x23\x18\x52\x63\xb3\x84\xdf\x8f\x5a\xee\x3e\x2a\x2d\xc2\x36\x67\x2d\xc6\x77\x91\x69\x0b\x8c\x6e\xd7\xf8\xe8\x65\x15\xba\x89\xc9\x00\x4e\xfb\xb8\xdf\x7b\xa4\x4f\x62\x3f\xc0\x8f\x1d\xf8\x90\x3b\xcc\x37\xd1\x5a\x4d\x74\xd9\xaf\xfc\x60\xd5\x81\x8c\x69\x08\xfa\xf6\xa1\x8d\xac\x84\x17\x64\xf2\xda\x8a\x98\xe5\xe8\x2c\xb3\xc1\x2b\x80\xcf\x71\x6d\x9b\x1c\xa3\x3d\xde\x71\x09\xc2\x35\xdb\x67\x81\xac\x4b\x5c\xb7\x15\x60\xd4\x1e\x68\x13\x7d\x66\x3e\xd9\x87\x73\xda\xdd\x21\x29\x89\xfd\x30\x6e\xf4\x1b\xc6\x6b\x5b\x8c\x4d\xf3\x7a\xb5\xab\xb2\xc1\xef\xf0\x75\x8e\xcf\x6d\x52\x9b\xfc\xaf\xb4\xf8\xbd\x38\xb4\xd0\xa4\x38\xa1\x68\x37\x5e\x7e\x61\x1f\x35\xd3\x21\x33\xb0\x8f\x27\x6a\xd4\x74\x6d\x03\x86\x5b\xc3\x6c\x65\x90\xdf\x98\x83\x6c\x6c\x21\x9c\xcf\x92\xe5\x8b\xc5\xe5\x55\xdb\x00\x63\x03\xd3\xdc\x59\xae\x20\x01\xb5\x5d\x43\x88\x68\xf9\x50\xb4\x28\xc2\xe4\x5b\xe1\x83\x02\xda\x88\x27\xb4\x0c\xad\x98\x1a\x37\xc2\x0b\xe0\x96\x35\x5f\x0c\xfc\x68\x52\x5c\x8a\xe5\x8a\xfd\x3b\x23\xa0\x17\x84\x05\xc3\xa7\x69\x13\xff\x6e\x69\x98\xea\xcc\x25\xc5\xe0\xce\x72\x0c\xad\x93\x1a\x20\x7e\x7d\x7d\x76\x7c\x70\x78\x71\x7d\x74\xfc\xee\xe2\xf4\xf4\xe5\xf9\xf5\xcf\x2f\x4f\x9f\x1e\xbc\xbc\x7e\x7e\x7a\xfa\xe2\xfa\xba\x49\x5e\xdc\x5f\x1a\x7d\x92\xb2\xea\x48\x3c\x07\xb7\x58\x74\xe2\x5e\x85\x31\x1e\x2a\x74\x69\x54\x01\x66\xf8\xd0\x65\x90\x19\xe4\x86\x38\xa7\x78\xc3\xa2\x8f\xcc\x6b\x71\xf8\x8e\x7b\x10\x8b\x75\x92\x21\x2f\x76\x56\x14\x35\xbe\xb1\xe8\x87\xb7\x0f\xac\xf3\x36\x9f\x14\xb3\x5c\x56\x13\x6b\x95\xfa\x77\x4b\x45\xca\xe8\xa0\x4d\xcc\x7e\xea\x5a\x2f\xd7\x0d\xeb\x76\x6f\x98\x15\x12\xfb\x60\x6d\xe1\x5b\xd6\xed\xde\x42\x61\x23\x94\x8f\xb1\x97\x77\x31\xad\x98\x90\xdc\x13\x1b\xfa\x82\x1d\x02\xf7\x91\xd0\xfc\x50\xf9\x2b\x11\x21\x3b\x5f\x66\x32\x65\x48\xab\x67\x45\x99\x48\x33\xc3\xce\x2e\xc9\xaa\x93\x3c\xab\x33\x3a\xe6\x77\x48\x60\xc5\x5d\x3d\x64\xe6\x4b\x9c\x11\x85\x1b\x6e\x5f\x98\xb2\x89\xcf\x28\x0e\x3c\xfc\x05\x97\x24\xb0\x0c\x98\x0e\x64\x1b\xe8\xa6\x1b\x67\x65\xb1\x68\xa6\xfc\xd4\x3c\x4e\xfe\xca\xf9\x6d\x96\x30\x16\xe9\xa8\x41\x49\xaa\xab\x1c\x88\x76\xf3\x02\x94\xe4\x04\xbe\xaa\x66\xdd\x94\x4f\x19\x38\x1f\xf9\xe8\x48\x84\xa1\x87\x68\x94\x98\x65\x88\x5c\x07\xe0\xaa\x92\xf6\xea\xca\x67\x9c\x46\x14\x9c\x27\x31\x00\xad\xec\x9a\xee\x1f\x32\x2f\x25\xc2\xc1\x1c\x4c\x6e\xf8\x6a\x49\x4b\x2a\xb9\xc6\x9e\x28\x45\xc4\x16\xf8\x81\x4a\x51\xcb\x6b\x98\x1e\x32\x53\xa2\x02\x41\xe0\xf8\x86\x22\x41\x20\xa8\xcc\x35\xce\xd3\xa0\x63\xc1\xaa\x81\x69\x8f\xf8\x92\x99\x8f\x66\x4b\xa6\x0a\x8d\xf7\xcc\x79\x47\x51\x02\x41\xd0\x62\x2b\xd5\x00\xd5\xa4\xa7\x7e\x37\x81\x36\x69\x6c\xa9\x80\xe1\x04\xe1\x0b\xc1\x38\x81\xd9\x36\x80\x34\xe9\x59\xdf\x0f\x01\xf3\x25\xe7\x17\x56\x08\xd3\x46\x43\xfb\x7c\x57\xf5\xd0\x3d\xeb\x33\x8a\x6d\x4a\x8b\x34\x2a\x47\x9d\x1d\xdf\x30\x7e\xea\xec\x90\x51\x24\xa7\x32\x8c\x3a\xbb\x12\xae\x46\xa1\x7c\xeb\x7d\xd4\x18\x10\x3f\x2f\xe5\x4f\x7d\xcc\xce\xa3\xe6\x78\xe5\x71\xca\x17\x8b\xfc\xa7\xd2\x5f\x99\x4e\x19\x0e\x17\x0b\x6f\xc8\x7b\x36\x87\x2d\x58\x9c\x3b\x9e\x29\xc6\x13\x8d\xe0\xac\x4a\x78\xde\x10\xc9\x10\xd6\x01\x80\x4b\x9c\x84\xac\xef\x8d\x80\x2e\x9b\x8e\x69\xc2\x7c\x1a\x1d\x33\x6f\xc4\xb9\x26\xc2\x7c\x02\x7e\xc5\x32\xe4\x4d\x69\x66\xf9\x34\x1a\xec\x03\x33\x4a\x49\xe9\x07\x07\x1e\xff\x43\xc0\x51\x9a\x37\x07\x1b\x93\x42\x67\xf6\x36\xc1\x0a\xca\x55\xea\xc9\x4d\xed\x76\xbd\x32\x4a\x7a\xe6\x1e\xcb\x81\x97\x2d\x79\xd1\xe5\x95\x4f\x4a\xf4\x68\x1b\xf9\x3e\xf8\x3a\xf3\xc9\x2e\xe5\xb1\xb6\x4a\xef\x1b\xfe\xf8\x8b\xe8\xf1\x5e\xa0\x4a\xc1\x8a\x2c\x16\xcd\x31\x2e\x16\x9e\x0d\xea\x48\xe9\xe3\xe2\x9a\x8b\xde\x66\xe4\xfb\xaa\x81\xa8\xcc\x91\x18\x0f\x73\x25\x18\x42\xd4\x9e\x16\xaa\x7d\xf1\x41\x25\x33\xac\xa8\xa0\xc3\xe1\x9d\x2d\x16\xa5\xaa\x52\xa8\x7f\x22\x3e\x6a\x13\x51\x30\x74\xed\xde\x75\x09\x53\xe2\x11\xf1\x52\x77\x6c\x3d\x59\xf7\xda\xc0\x30\x3a\x2c\xb7\x78\xe5\x51\xac\x47\x19\xf5\x43\x83\xc3\x8a\xe2\x30\x6e\x8b\x53\x10\x61\x74\xb2\x7e\x74\x97\x55\xaf\xf8\x15\xcb\xd2\x60\x98\xaa\x88\xa7\xac\xc6\xc3\xa7\x6e\x68\x40\x41\x68\x84\xdc\xd2\x5a\x28\x5f\x7f\x87\x37\x7a\xc0\xd0\x92\xc9\x80\x1b\x5e\xe2\x87\x47\xcc\x4b\xc8\x5d\x03\xf1\x0c\x88\x89\x21\x03\x8d\x40\x02\x46\x14\xb8\xe3\xdd\x88\xc0\xca\x7f\x73\x20\x92\x4f\x5c\x23\x92\xc9\xd5\xd3\x5a\x7e\x48\xbd\x84\x0c\xfc\xa5\x9c\x86\x68\xe3\x9f\x99\x4a\xff\x9e\xa9\xf4\x1f\x36\x95\x9d\xcf\x98\xca\x06\x9f\x4b\x5f\xcf\xc5\x44\xa4\xe6\x54\xd6\x4f\x24\xd5\x13\x49\x71\x22\xa9\x10\x55\xae\x9f\x08\xb3\x27\x62\x91\x2f\x41\xba\x6e\x5b\x76\x1e\xb0\x2d\xcc\x5f\x4a\xda\xf9\x8e\xa6\xc5\x14\x4d\x07\xd4\xe3\xa0\x10\x15\x12\x03\x58\xda\x19\xa6\xb6\xc2\x16\x08\x93\x34\x02\x91\x32\xe9\x47\x6b\x25\x9a\x86\x80\x90\x0c\xa2\xfe\x3e\x08\x96\x53\x3f\x38\x0c\x91\xd7\x48\xbc\x98\x0c\xfc\x10\xcf\x50\xd8\xff\x9b\x82\xda\xf4\xb3\x04\xb5\xff\x0f\x7b\x6f\xdf\xdd\xb6\x8d\x3d\x08\xff\xaf\x4f\x41\x73\xbb\x32\x19\xc3\xb2\x9c\xa4\x49\x4a\x16\xd5\x2f\x4d\xec\xd4\x6d\x1c\x67\x62\xa7\x9d\x5f\x5d\x6f\x0a\x92\x20\xc5\x8a\x22\x15\x92\xb2\xad\x58\xfa\xee\xcf\xc1\xc5\x0b\x01\x92\x72\xdc\x99\xd9\x3d\xcf\x9e\xb3\x73\xa6\xb1\x08\x80\x17\x20\x70\x71\x71\xdf\x70\x6f\xa2\x19\x66\x10\xb0\xb9\x5b\xbf\x7c\xb0\x95\xaf\x6a\x86\xca\xc8\x4e\xc5\xa3\x83\x71\x47\x13\xc6\x82\x68\xb2\x93\x9f\xe8\x0a\xbd\x6f\x5f\x88\x70\xd0\x33\x3e\x89\x7e\xc4\x85\x63\x9c\xf8\x02\x4c\x5b\xa7\x81\x29\xd7\x4a\x54\xf8\x15\xa3\x6a\xe2\x23\x60\x42\x67\xf2\xc0\x20\x22\xd6\x98\xb1\x08\x9a\xa6\x61\x67\xac\xbc\x83\x34\x9d\xc3\x92\x7d\x71\x90\xd1\x4f\x69\xf5\xb2\x5a\xe5\xa1\xa9\x81\x80\xf4\x4d\x5d\x0d\xd3\x1a\x1f\xba\xbd\xfa\x8d\x88\xc7\x14\xcf\x21\x16\x51\x96\x01\x71\x83\x98\xe2\xe2\xbb\x50\x5f\x03\xc7\x45\x10\x64\x83\x37\x19\x0e\xe3\x51\x0f\x09\x71\x22\xa9\xc7\x82\xa3\xcf\x45\x2d\xcd\x8e\x1e\x5d\x5c\x4e\xe2\x5b\xb6\xcb\x08\xa2\x28\x42\x09\x84\x80\xfb\xda\x98\x5f\xa7\x91\x1c\x32\xd1\x4f\xc5\xc1\x53\x77\x23\xf2\xe3\x6e\xdf\x20\x8c\xae\x09\xb2\xab\x69\x72\x13\xb1\xb4\x41\x4b\x89\x95\x88\x31\xb6\x58\x2a\x81\x16\xad\xd6\x68\x8a\x4d\x59\x5c\xf0\x39\x33\xc1\x06\x4c\xe1\x10\xfb\xf6\x3b\xa5\xe1\xe7\xe8\xb5\xc4\x89\xc4\x15\x74\xcb\x50\x2d\x70\xfd\x5b\x86\x35\x01\xba\x75\x7b\x4f\xc3\xc4\x5c\x9e\x0f\x34\xa4\xe9\x35\x44\x96\xad\xd6\xeb\x19\xc6\x78\x3a\x1c\x2e\x31\xc6\xb7\xeb\xb5\xc3\xa0\xf3\x05\xb9\xe7\x2d\x67\x8a\x6e\x5d\x24\x1a\xee\x60\xbc\xdc\xb6\xbc\x89\x6c\x84\x04\xe7\xb5\xec\x4c\x0d\xe7\x34\x20\x72\x87\xb6\xf0\x13\xc1\xa7\x1b\x85\x28\x41\x53\x76\xa0\x2f\xb9\xc3\xfe\x6c\x07\xe3\xe9\x7a\xbd\x64\xf8\xb1\x5e\x2b\xb5\x3c\xdf\xac\x6d\x80\xc3\xa1\xf1\xd8\xe2\x7e\xa4\x01\xc1\x98\xbd\x41\x77\xfa\x5e\xa7\x91\x64\x97\x66\xb0\xef\x8c\x05\xe5\xb3\xd8\xda\xe4\xc0\x58\x69\x58\xf7\xd4\x45\x42\x8f\x70\x8c\xa7\x92\x39\xc2\x18\xcf\xfe\xa5\x71\x1f\x4b\x66\x15\x90\xf4\xad\x8e\xa4\xe8\x0d\xe6\xfa\x28\xff\xb8\x37\xf8\xf3\xdb\x51\x35\x2d\x96\x8c\x78\x8a\x8f\xe3\x20\x27\x5b\xca\x9d\x63\x44\xd1\xad\xeb\xbd\xd1\xa9\xcf\x1b\x43\xcf\xf9\x7e\x59\xd2\x96\xae\x73\x87\x12\x67\x86\x8e\xe1\xfa\x03\x71\x96\x6c\xf5\x76\xc6\x9b\xe3\x89\xd3\x37\xa2\x16\xc6\xf1\x7e\x87\xc3\xde\x62\x67\x0a\xc3\x41\x5f\x81\xa3\x16\x6c\x38\x6c\x2f\x83\xeb\xf5\x5a\xb7\xfa\x57\x7b\xf0\x6f\x2c\x37\x3b\x11\xa7\x2e\x8a\x1c\x46\x4c\x5c\x45\x3b\xa6\x8a\x5a\x30\x7a\x22\xa9\xff\xad\x3c\xc1\x8e\x37\x3c\x04\xfd\x19\xed\x5d\xbd\xf3\xd5\x3c\x28\xb2\xe1\x90\xff\xbd\xb4\xe3\xa2\xb4\xaf\x5a\x8f\x8e\x0d\x07\xe7\x68\x51\x94\x35\xc9\x6c\x77\xbd\x7e\x36\x3e\x1c\x3f\xd3\xee\x42\xb4\x94\xde\x4f\xbe\x27\x65\x02\x97\x62\x2a\x15\x45\x83\x93\x1e\x26\x22\xcb\xaa\xcb\x27\x57\x13\xfd\x81\xeb\x01\x04\x23\xf2\xcd\x37\x7c\x80\xde\x19\x45\x33\xe1\xa1\xa9\xb8\x25\xdb\xde\x8b\x90\x54\x37\x7a\x04\x99\xca\xc4\xa0\xad\x29\x0c\xf9\x0c\xfc\x83\xe2\x97\x65\x49\x56\xa3\xb4\x82\xbf\xe8\xc3\x43\xa6\x64\xc4\x2f\xe2\x17\x25\x3a\xa7\xe8\x82\xa2\x8f\x14\xfd\x4a\xfd\xc1\x83\xe7\x72\xe2\x9c\x53\xdc\x3b\x9d\x94\x8f\xd1\x76\xd1\xc5\x96\x16\x8c\xbf\xb3\x5d\xf4\x71\x4b\xb5\xa0\x35\x2e\xfa\x75\x4b\x83\xb8\x24\x09\xef\xc2\xf5\xd8\x30\xd8\xb2\x3d\x61\xbd\xb1\x1f\x4f\x19\x5c\xf6\xe3\x5b\xf6\x3e\xfb\xf1\x5c\xf7\x04\x96\x6a\x4e\xa9\x77\x59\xaf\x7b\x15\x9e\x66\xf8\x22\x82\x3f\xd0\xe1\x90\x5c\x7e\xa0\x57\xeb\x35\xb9\xb4\xff\xeb\xbf\xe4\xec\xd9\x57\xf7\x2b\x5a\xda\x01\x6d\xfe\x69\x88\x82\x01\x98\x5b\x34\x09\x50\x0f\x7f\xae\x59\x94\x45\xc2\x9b\x4f\x70\x31\xcb\xbd\x0b\xb0\xfc\xed\xeb\xd6\x18\x3f\x18\x0e\x9d\xc7\x32\xc8\x13\x9c\x8e\x87\x4d\xf4\x2e\x14\xe9\xd4\xcf\xf5\x0d\x0b\xf3\xd3\xe7\x90\x41\x9e\x33\xeb\xb6\xbd\x17\x6a\x83\x52\x91\x61\xb9\x75\x68\x38\x84\x3f\xa3\x4f\xdc\xd6\xf2\x81\xc6\x4c\x6e\x71\xb5\x90\x9b\xb1\x4f\x70\xd7\xb1\x50\xb0\x72\x18\xbf\x9a\x88\x9f\x77\x1b\x8f\xff\x6a\x94\x64\x22\xaa\x46\x70\x49\xaf\x3c\xf6\x0f\x26\x1b\x9f\xe8\x5d\xd1\x46\xbe\x96\xc6\x1e\x6d\x9e\xe0\x9b\x9f\x6a\x36\x7f\x39\x4f\xc6\xb7\x7e\x07\x29\xf0\x9b\xd8\x2b\x8d\xcd\x57\x2c\x4e\x73\xb3\x74\x07\x2b\x0e\xf3\xb5\x63\x3f\x39\xb4\x91\x7d\xc9\xcd\x43\x22\x0c\xfd\x15\x5b\xee\xce\x15\xe3\xba\x10\x57\x06\x84\x48\x3d\x11\x36\x25\xeb\x26\xad\xa7\xd6\x8c\xae\x2a\xeb\xce\xde\x13\xaf\xb1\x47\x27\x70\x47\x7f\x15\x69\xee\xd8\xc8\xb2\xdd\x3d\x7b\x63\x7b\x01\xb2\x6d\x5d\x25\xfc\x3b\xed\xa4\xc5\x94\x91\x3a\x03\x19\xbd\x5d\x43\x6c\xcd\xce\x29\xd6\xc6\x8f\xf4\x42\x1e\x0e\x0a\x87\x9a\xf5\x52\xea\x60\x16\x13\x67\xa1\x5b\x3e\x23\xa4\xb7\xc2\x91\x2b\x55\x75\xa2\xc0\xac\xf5\x3b\x56\x53\x5f\xb7\xaa\xbe\xd0\xf4\xcc\x11\x88\x46\x77\x46\x9c\xc1\x5c\x46\x39\x93\xa3\x89\x7c\x37\x84\x76\x88\x8d\x5f\x9a\x2f\xf5\xdb\x6b\x6d\xc5\x04\x4f\xc4\xc2\x84\xad\x53\xb2\x90\x60\x02\xdf\x55\xfc\xc3\x8c\xae\x26\x64\x54\xd1\x9a\xe7\x3b\x43\x81\xeb\xc9\x47\x30\x86\xa2\xc0\x45\x5a\x0c\xb2\x1e\x0b\x52\xec\x34\x71\x52\x9b\xa0\xe7\xb8\xa0\x8e\xca\xc8\x23\x4c\xfa\x48\x81\xe1\xaa\x9c\xa0\x6b\x42\x8a\xfc\xc0\x30\xc1\xcb\x77\x07\xec\xa7\xfe\x72\xdb\x36\xd5\x67\x1c\x4b\x1c\x22\x14\xc2\x02\x4a\x64\xc6\x71\x0c\xfd\xa8\x1d\xe4\x51\x4e\xb4\xf2\x44\xc2\xc2\x38\x8c\xa2\xef\xc3\x89\x2e\x14\xe0\xc7\x28\x74\xbd\xc8\x37\x8a\x7a\xd2\x59\xcc\xd8\xb6\x0f\x38\xdd\x00\x1e\x40\xf5\x67\x0a\x19\xf8\xb1\xdb\x33\xb9\x53\x23\x0c\xad\x80\x11\xac\xd7\xcf\x76\xda\xe1\xed\x30\x84\x11\xeb\x13\xd6\x60\x0d\x34\x57\x0b\xc2\x26\x1e\xcb\x65\xf3\x8d\xaa\x9e\x59\x2c\x3b\x43\xd8\xc1\xdc\x4f\x06\x2c\x98\x10\x09\x6e\xb5\xa0\xcd\x8c\x01\x64\xce\xb9\x00\xaa\x82\x35\xfd\x9f\x80\x0e\x2e\x8a\x8c\x81\x44\x7e\x84\x17\xf7\x8c\xdb\x1f\x18\x6f\xfb\x51\xdf\x58\x35\xbb\x70\xbe\x65\xba\x9e\x77\xa7\xab\xfa\xdf\x34\x5d\xab\x2d\x43\xf8\xae\x3b\x84\xfa\xde\x21\xf0\xe9\x0d\x45\xc8\xf0\xfe\x11\x71\xaf\x0b\x65\x4d\x16\x8d\xbf\x3a\xc6\xe5\x96\x31\xaa\xa8\x88\xeb\x75\xb0\x2d\xa6\x1f\xd7\x1f\xeb\x25\x66\x63\x93\x31\x83\xd6\x66\x51\xf3\xfd\xcb\xad\xdf\x3f\xd8\xbe\x06\x86\x0d\xfa\x21\x0b\x72\xdb\x58\x71\x5a\x9f\x7b\x38\xee\xae\xc9\xe7\xed\x6b\x82\xe8\xbf\x85\x18\xc7\x92\x81\x86\xd0\xfa\x6d\xe7\x8c\xa0\x89\xd9\xa7\x15\x1a\xbb\xdb\xb6\xf7\x82\xfe\xa1\x85\xdd\x81\xb1\x4e\x3a\xce\x1b\x81\x62\x5f\x9a\x9c\x8f\xc1\x48\xf2\xe1\xc2\xff\xff\x9c\x7a\xc0\x61\x89\xdd\xfd\x2b\x35\x26\x27\xe0\x1b\x5b\xad\xc2\x96\x01\x21\x38\x4d\xba\xc3\x0a\xd9\x76\xdf\xfa\x15\xfe\x20\x94\xdb\x5d\x3a\x31\x84\x7d\xb3\x2a\x32\x48\x5e\x50\x4f\xdf\xce\x0f\x9f\x1c\x78\xfb\xa3\x7a\x3b\xc4\xf5\x7d\x6f\x8b\xf0\xd1\x81\xd8\x89\xc6\x88\x90\x18\xca\x99\x36\x94\xe5\xdf\x18\xca\x26\x8d\x9d\x7f\x50\x27\x70\xd7\xeb\xdf\xa8\x96\x61\x84\xcf\xf5\xb6\xc9\xe5\x0a\xb0\xf6\x57\x09\x96\x6d\xd3\xcb\x0f\xbc\x6d\xdf\x06\x91\x88\x30\x81\x95\x52\x31\x87\xbb\x98\x19\xf6\x61\x66\xa8\xf3\x28\x3b\x4a\x59\xcf\x8f\x2b\xc6\x34\xb3\x1d\xd1\x8b\x83\xa1\xc2\xc1\x50\xe1\x60\xd8\x83\x83\x72\x6d\xc0\xc9\x10\xe3\x01\x9d\x84\x0d\x4a\x4e\xc4\xa6\x6e\x23\x23\xdb\xa3\x5e\x73\x60\x79\xcd\x35\x91\x8b\x0e\x44\x3a\xc9\xfb\x1a\x36\x68\x21\x08\x05\x9d\xac\xfa\xda\x9d\xf5\x00\x5c\x9a\x0d\xc5\xe2\x86\x7c\x71\xcd\xfb\x33\xcd\x9c\x35\xf4\x89\xdb\xd1\x60\x19\xc3\x2d\xcb\xf8\xa6\x45\xcc\xba\xcb\x15\xf5\x2d\x97\xe2\x67\x08\xbf\xa9\x00\x63\xe2\x56\x62\x86\x65\x08\xa4\x6d\xba\x65\xc5\x22\xb5\x62\x91\x5a\xb1\x68\xfb\x8a\xc9\x2e\x14\xf3\xcd\x58\xcc\xd0\x83\xbf\xb2\xd7\xc8\x58\x4a\x36\x82\xa8\xbd\x94\x14\xf1\x37\xbc\x41\xc9\x1b\x20\x99\x88\xf7\xe2\x6f\x75\x95\xb7\xde\xfe\xd8\x79\x5b\xcd\xc5\xaa\xd5\xf4\xec\x6f\x75\xb4\x54\x6f\x8b\x75\x8f\xf8\xba\x47\xee\xd6\xc9\xbf\x95\xaf\x34\x4b\x1f\xb4\xe3\x51\xa8\xa5\xbf\x70\x08\x8a\xd1\x35\x9a\x35\x51\xbf\x17\x9c\x8f\xfe\x22\x92\x58\xe2\x18\x4d\x71\x8c\xc7\x48\xc8\x1a\x62\xd5\xb2\xe1\x70\xfa\xfd\xb5\x34\x98\x4e\xf7\xf6\xdc\xbb\x8c\x33\xb5\x3f\x4c\x27\x4e\x8d\xd9\x9b\xd0\xbf\x57\xe3\x4c\x31\xfa\x0c\xfe\x0d\x66\x64\x23\x43\xd7\x97\xd3\x2b\x34\x73\x35\x15\xe4\x8d\xf2\x88\xc9\x86\x43\x27\xc3\xb5\x8c\x22\x1c\x0c\x87\x99\x62\x76\x6f\x74\x66\x97\x49\x2e\x99\xeb\xc7\x38\x71\x6e\x50\x8c\xa6\x2a\x5c\xed\x97\xc9\x02\xdf\x78\x5f\x14\x7b\x7f\xe3\x7f\xc1\x37\xfe\x20\xc3\x35\x9b\xc8\x29\xc6\xf8\xba\x95\xd0\x36\x02\x50\x68\xa1\x0d\x28\x13\x71\xa7\x5a\x5f\x9a\xc6\x4e\x86\xd9\xc9\x2b\x3e\xc1\x65\xdd\x67\xd0\x3d\xd2\xba\xcf\xb4\xee\xd9\x7c\x4a\x1d\x95\xb5\xd8\x30\xa8\x19\xa6\x7c\xf0\x5d\xe8\x35\x7e\xe3\x64\x88\xa0\xa9\xea\x01\xa4\x50\xb5\x65\x6a\x4d\xf6\xcc\x2e\x6d\x2e\xd4\xdb\x57\x72\xd8\x20\xf2\x4e\xa6\x1e\xfc\xe5\x93\x53\x77\x26\xa7\xd6\x46\x57\xfb\x5f\x70\x0d\xb3\xdc\xbd\xb8\xd8\xa4\xbc\x14\xb9\x2a\x5d\xed\x33\x24\x1a\x9d\x34\x68\xc4\x51\xe8\x37\xea\x5c\xf7\x1b\x03\x16\xdc\xaa\xd0\xe8\x4d\xfc\x6b\xbc\xe0\x72\xfc\xb5\x1c\xe0\x35\x6f\x73\xd8\xb4\x91\xc8\x39\xc5\x8b\x06\x2f\xbf\x68\x78\x89\x6e\xf0\x35\xc8\xc5\x8e\xab\xa1\xe8\xce\xcd\x28\x2a\x72\xea\x7f\xd9\xdb\x43\x83\xa6\x45\x83\xab\x5f\xee\xc7\xd5\x5c\xe0\xea\x8d\x38\xa6\x0d\x74\xcd\xdd\xbb\x6c\xbd\xde\x8a\xa7\xf9\x16\x3c\xcd\x51\x8c\xbe\xa8\xa5\x98\x4e\x16\x38\xf7\xa6\x8d\x18\xea\x4f\x71\xee\x0b\x34\xe5\xa3\x7f\x00\x82\xea\xdf\xa9\x7d\xe6\x0d\x60\x69\x33\x78\x69\xce\xba\x81\x44\xbf\x7c\xcb\x7c\x51\x38\x3b\x85\x2d\xd3\x0c\xe5\x06\x4d\xf1\x8d\xbb\x05\x69\xb7\xf4\xc8\x06\x2d\x90\xf7\x4b\x5f\xc7\x2d\x44\xbe\xb9\x1f\x91\x6f\x00\x91\xbf\x78\x37\x0d\x22\xdf\x74\x66\xcf\x18\xb2\x3f\xc5\x37\x0f\x42\xe4\x81\x89\xc9\x6d\xaf\x4e\xb0\xbc\xa1\x84\xa3\xf3\x14\xdf\xeb\xb2\xcc\xd6\x63\xea\x8a\x33\x8c\xf6\x9c\x61\xc4\x03\x30\xd7\x98\x82\x0b\x37\x9b\xc7\x29\x0e\x24\x9a\x4e\x79\x6c\xb8\xa9\x38\xf0\xaf\xd9\x1c\x1e\x8e\xd9\xc7\x81\x96\x91\x36\xa7\x9a\x37\x95\xbf\x45\x86\xac\x3b\x86\x12\xea\xeb\x5d\x10\x1c\xa6\x48\x7b\x63\x42\x5b\x27\xa0\x27\x0a\x10\x6b\x2d\xd9\xe2\x29\x3b\x9c\x4c\x49\x83\xe0\x40\x05\x89\x02\xf3\x0e\xf4\x24\xf1\x1c\xbc\x93\x42\x5e\x32\xc5\x6a\x00\x1b\xbd\x67\x87\x32\x6e\xb3\xdd\x7f\x3f\xf3\x99\x20\xca\x39\x7b\x6a\x70\x9f\x04\x53\xd7\x73\x12\xc6\xdd\xd3\x2d\x2f\xba\x28\x69\x64\x79\xea\xa2\xa4\x05\x20\x51\xe7\xde\xcc\x21\xae\x88\xe2\x74\x01\x4b\xc2\x97\x81\x2f\x49\xa3\xc3\xe2\x8a\x60\xbe\x14\x53\xb6\x14\xcf\x55\xcc\x7f\x98\x83\xa0\x99\x6d\x0a\x62\x1a\x05\x6f\x83\xd6\xe4\xd1\xee\xe4\x05\x9d\xc9\x83\x50\xf5\x4d\x20\x7e\xca\xc4\x8d\xad\xdf\xd9\xed\xc2\xf8\x30\xc9\x85\x10\x4f\xd7\xa7\xb0\xf1\x7f\xb7\x75\xfc\x9a\xb4\x9f\x28\x69\x9f\xf6\x4a\xfb\x6d\x74\xb0\xe4\x17\x31\x21\x67\xfb\x98\xbf\x06\xb3\xfb\x09\x67\x7f\x67\x69\x9e\xca\x4f\x1b\x0e\xb7\x6a\x16\x54\x28\x32\x55\x32\x1c\x0e\xb6\xab\x16\xa0\x79\x4b\xb5\xb0\x65\xdd\x4d\x9d\xc1\x7f\x0c\x09\x96\xff\x32\x12\x6c\x7a\x59\x77\xda\xc7\xba\xab\x33\x05\x8c\x11\xca\xcd\x21\x18\x0e\x55\x8a\x8b\x89\x63\x7e\x36\x6a\xd0\xdd\xf5\x78\x1d\x2b\x2b\xef\x19\x6e\xcf\x7e\x46\x33\x91\x76\xe3\x1f\xd4\x51\x56\x6f\xe0\x42\xc5\x4e\x4a\x63\xe7\x37\xbd\xea\xa4\xa9\x9a\x0e\x87\x20\xc6\x08\x91\xa2\xcf\xaa\x44\x25\x19\x26\x1c\xe3\x01\xa7\x1e\xf3\x1b\xd7\x87\x1e\x95\x21\x6f\x10\xb0\x17\x8f\x6d\x44\xcd\x24\x47\x14\x92\x1c\xad\xd7\xb6\x32\x20\xdb\x8a\x7e\xf0\x2f\xe6\x16\xc1\x6f\x28\xfe\x9d\x3a\x3b\x63\xb4\x33\x76\x11\x89\xe1\xe1\x10\x1e\x02\xf5\x70\xa8\x87\x61\x09\x63\x5d\xc4\xd2\xb4\xdc\x42\x7b\x93\x88\xea\x8e\xbb\xb6\xa9\x77\x96\x97\x53\xc4\xd5\x26\x65\xd5\x09\xd8\xca\x88\x52\xe1\x72\xac\xb2\xfa\x88\xe2\xc9\x37\xb4\xd3\xa6\xfd\x96\xa1\x5f\x6e\x1b\xd1\x72\x95\x06\x82\x08\x0b\x15\x7f\x32\xcd\xcd\x87\x8f\x5f\xb8\xbd\x8a\x66\x0e\xd1\xbc\xe4\xcb\x64\x40\x36\xaa\x9d\x43\x17\x71\x6f\x30\x3f\x34\xdc\x5c\x68\xd4\x5c\x52\x16\xb6\xb3\x70\x54\xd2\x3c\xa2\xa5\xe3\xfa\x66\xc7\x7e\x2c\xdc\x65\xfc\x96\x87\x07\x16\x99\x44\xfc\x96\xfb\x0b\x16\x82\xbe\xaf\x86\x31\x6e\xdc\xb7\xf8\xac\x18\xfa\xea\x26\x78\x9c\x76\xb7\x53\xda\x0b\x04\xde\x4f\xe0\xb6\xec\xa0\x5d\x8c\xda\x05\xa0\x22\x14\x26\x77\xd7\x53\x3f\x87\x43\x7e\xdb\x56\xf9\xd7\x30\x2c\x7a\xa3\x4a\x14\x09\x73\x5b\xca\x69\xdd\x8d\x5c\x0c\x1d\x0c\x6b\x7c\xe5\x01\xd9\x9f\x34\xbc\xb4\x76\x40\xc8\x8c\x4f\x44\xe5\xa6\xe1\x4b\x0e\x57\x07\x4d\x67\x33\xd4\xbe\x39\xc0\x26\x9a\x23\x99\x88\xa0\xaf\x27\x9b\xf1\x95\x45\x53\x25\xb4\x21\xcd\x03\x0a\xd9\xa2\x08\x9e\xed\x41\x7d\x21\x13\x7a\x68\x98\x6d\x36\xdb\x56\x6d\xc5\x27\x47\x29\x25\x1b\x9a\xf0\xc4\x2b\x55\x92\x1a\x5f\x50\x89\x39\x6d\x15\x3d\xf5\xde\xc0\x0e\xd9\x72\xb4\xb8\x9d\xd4\x39\x4b\x46\x60\xb8\xf7\xca\x39\xad\x2f\x9a\xd8\xc1\xe8\x16\x93\xd1\xb2\xa2\xe7\xab\x3c\x3c\x0f\xa7\x34\x5a\xc2\x34\x1c\x63\xd9\xfc\x35\x5d\x94\x69\x51\xa6\x75\xfa\x85\x9e\x2f\x83\xba\xa4\x14\xbd\xc5\x01\xb8\x5b\xff\x54\x54\xb5\x44\xa4\x37\xad\x32\x18\x0c\xba\xc0\xe1\x08\xe2\xc4\xff\xb4\x8a\x4a\x19\xec\xa2\xa6\xe8\x04\xb6\x4b\x45\xeb\x56\xf9\x17\x1c\x8e\xea\x72\x75\x51\xbc\xca\x48\x3a\x7f\x47\x6f\x45\x03\x12\x64\x54\xc5\x47\x20\xf8\x1d\x75\xe0\x96\x82\xe1\xaf\xd9\x72\x42\xc1\xc1\x66\x6b\x03\xe1\xde\x2f\x42\x1b\x2c\x30\x19\x75\xdd\x44\xd1\x35\xd6\x32\x9d\x9b\x55\x35\x26\xa3\xae\x17\x25\xfa\x25\x50\x4e\x7a\x46\x85\x74\x01\x09\x68\x92\xe6\xbf\x15\xe5\xac\x15\xb4\x06\x18\x88\x31\x90\xc4\xf6\xbd\x99\x76\xc9\x0f\x8a\x46\x71\x14\xf2\x7b\x50\x68\x2c\x7d\xda\xc9\x64\x00\x5b\xec\x5b\x4d\xa4\x05\xaf\x01\xce\xfe\x20\xda\x72\xb3\x43\x89\xf0\x9a\x4b\xb8\xd7\x5c\xe2\xfa\x11\x8e\x1c\xca\x39\x26\x83\xa6\xdd\xab\x37\xeb\x4f\xe5\x1e\x09\x02\x39\xe1\x83\xc5\x8f\x11\xc5\x80\xd9\x68\x01\x7a\x20\x54\x73\x9b\x59\x80\x39\x75\xde\x19\x23\xca\x4e\x74\xde\xfa\x10\x71\x32\x0a\xb6\x22\x73\xa1\x69\x93\xc1\xaa\xa1\x93\xbe\x38\x5a\x21\x6a\xad\x70\xf7\x0a\xdb\x6e\x85\x51\xc7\x4f\x31\x8d\x1d\xe5\x2f\xe7\xca\x93\x85\x27\xfd\x77\xd5\xdd\x87\xe6\xc4\x89\x78\x3a\xb6\x00\xe7\x1a\x0f\x65\x91\x4d\x24\x26\x32\xe2\x13\xc9\xde\xc5\x94\x47\x75\xfd\xfa\xe1\x20\x4d\xbc\xea\xab\x36\xe6\x47\x3d\xf6\x14\x8f\xc4\xe7\x4f\x5d\xca\x15\x03\x1b\x90\x89\x46\x1b\x1a\x32\xeb\x5c\x03\xd5\xd0\xa7\x40\xcd\x3a\xdc\x66\xf1\x22\xfc\x8b\x88\xce\xe2\x22\xbe\x0a\x8d\x7e\xf0\x89\xec\x96\x11\x28\xc0\x9d\x3e\x7f\xd4\x89\x13\x75\xee\xcd\x80\x6b\x2a\xe7\x96\xb8\x92\x12\x5c\xbd\x59\x9f\xf0\xc2\x89\xc3\x16\x3d\x97\xd7\x9e\x22\x4c\xa5\x27\x11\x32\x9c\x4b\x91\xe6\xba\xa3\xec\xcb\x7c\xd9\x87\xc3\x64\x34\x05\x4a\x41\x87\xc3\x0b\x27\x70\x27\xe6\xe9\xff\x58\xb2\x13\xd8\xe0\x48\x22\x14\xb2\x1e\xd9\x00\x24\x76\xe9\xe8\x25\x7c\x91\x35\xf4\x12\x8d\xd5\x68\xa5\x75\xe5\x5b\xef\x2d\x5b\xee\x5c\x5d\x17\xfb\xc2\x1e\x15\xe2\xb1\x5d\x97\x75\x70\x2d\x6a\xa3\x63\xae\x5f\x56\xcb\xe4\x6a\x8a\x73\xf2\xa9\xe6\xed\x9a\x60\xb5\xc3\x5b\x54\xcf\x1b\x80\x2e\xb4\xeb\xf3\x19\x0d\x87\xf0\x67\xe2\x64\x38\x6a\xa4\xde\xa5\x43\x51\xe4\x4e\xb8\x9a\xc9\x4b\x86\xc3\x25\x6c\xf7\xb6\x53\xe0\xe1\x33\x17\x71\x46\x09\x3d\x3e\x7c\xfa\xfc\xe9\x8b\x27\xcf\x9e\x3e\xe7\x6e\x4b\x3b\xb7\xc3\xe1\x31\x87\xe2\x74\x1c\x1c\x9a\xc6\x6c\xce\x40\x93\xe5\xf0\x99\xce\xba\xfb\x38\x32\x26\x5a\xed\x29\x13\xf9\x9f\xb5\xec\x15\x62\xae\x11\x69\xd3\xb2\x5c\xbf\xba\xd7\xea\xaa\xdb\x37\x41\x8d\xad\xe3\x85\xc7\x49\xce\x73\xfe\xf8\xdc\x6b\xd3\xc9\x5e\x2a\x41\xc1\xf1\x1b\x58\x50\xd3\x99\x59\x19\x56\x3a\xcb\xd8\xa2\x27\x40\xee\xcd\x61\x61\x4c\x5d\xda\x83\x38\x8d\x8c\x67\x5c\x42\x1e\xb4\x19\x6f\x2d\xfa\x01\x0a\xef\x61\xbe\xdb\xed\xfa\xde\xee\x50\x28\xda\x30\xa5\x5a\x28\x0f\x36\x65\xdf\xe9\x8b\x24\x59\x16\xe2\xdd\xdd\xcf\xb5\xf8\xff\x89\x79\xfe\x97\xa7\xb9\x4b\xc4\x9b\xc9\x94\x11\x1b\x74\xda\x41\xd9\x44\x6d\xa5\xde\x74\x2b\xf5\x3e\x1c\xb3\x99\xe8\x1c\x45\xdb\x0f\x9e\x36\xee\xf6\x1c\x43\x83\xee\x07\xf5\x9d\x4a\x52\xaa\x7b\xd8\x59\x23\x43\x7e\xc1\x7c\x3e\x83\x9c\x01\xc0\xc0\x1c\x93\x34\xa3\x51\x2f\x1b\xd3\xc3\x8c\xf4\x70\xaf\x06\x8b\x6b\xf4\xf2\xdc\x76\x37\x06\xdd\x79\xf6\xd4\xef\xac\x02\x50\xaa\x8e\x30\x01\x14\xcb\x08\xac\xa1\x6e\x23\xff\x0b\x5c\x55\xd0\x89\xf6\xe1\x07\xed\x68\x1f\x3e\x17\x7c\xc5\x61\xe6\x3f\x6e\x74\x3e\x40\x70\x9a\xcd\xd3\xa1\x35\x42\xd3\xd9\x3e\x68\x84\xfc\xd6\x91\xf5\xf4\x6b\x79\x91\x92\xcc\x75\x5f\x3a\xc6\xdb\xea\xae\xd5\x1b\x11\x02\x51\xa4\x5a\x53\x0c\x6a\xac\x8a\x78\x46\x1a\x51\x9c\x30\x06\x78\xc1\xd0\x51\xdc\x6e\x85\xbb\x43\x68\x06\x39\x4c\x72\xb8\xec\xaa\x57\xb0\x73\x63\x0a\x5f\x41\x17\xa4\x14\x0e\xf7\xa8\x84\x3b\x40\x65\x05\xc9\x5a\x42\x8a\x72\x0c\xd1\xcd\x3e\x14\x45\x6d\xca\x04\x2b\x86\xfa\xc5\x42\x17\x1e\x96\xbc\xad\x5e\x74\x6b\xb6\xe2\xaf\x1e\x83\x68\x0c\xbd\x5e\x14\x5c\x32\xa0\xac\x85\xfa\x92\xb7\x5b\x1a\x18\x9f\xfb\x86\x35\x2a\x16\x2d\xd1\xe3\x42\x32\x51\x27\xf2\xc7\x17\xe9\x5d\x4b\x46\xf3\x25\x57\xb9\x4d\x9c\x0b\xac\xa5\x28\xdc\xa0\x13\xdc\xde\x03\xad\xdb\xa2\xa1\x3b\x1c\x46\x4e\xe0\x6e\xd0\x97\x76\x34\x3c\xea\xde\x85\xfc\x0a\x0f\x34\x70\x3d\x88\x5c\xf5\xf8\x09\x63\xd7\xe1\xc7\x33\xdb\xf5\x07\x42\x76\x08\x8b\xf9\x22\xa3\x35\xed\xdd\x77\x5c\x8a\xe9\x52\x14\xb1\x77\x16\xee\xa2\x73\x86\x48\x22\x62\x1c\xe7\xdd\x9d\xd2\x54\x03\x4d\x69\xb9\x21\xe6\x5a\x40\x4d\x7d\xd3\x1f\x76\xe9\xbf\x62\x5a\xff\x02\x96\xb5\xa9\x78\xe2\xdd\x32\x6a\xf0\xab\xf3\x4f\x14\x88\x68\x4d\x81\xeb\x2f\x0c\x75\xcb\xa2\xa5\xa5\x18\x0e\x9d\x85\xba\x18\xd0\xae\x44\xed\x82\x26\xef\xe7\x56\xfe\xf1\x0d\x1b\x93\x9e\xa9\x1b\xef\x3f\xf1\x2f\xb4\x78\x86\xcd\x78\xbf\xf5\x56\x3c\x09\x69\xee\x70\xf1\xf1\x5a\x72\x79\x3d\x8e\xd3\xba\xdf\xf5\x1d\xe7\x02\xdb\xc7\x56\x6d\xd0\x8a\x12\x2f\x1d\xd7\xaf\xf1\x60\xea\xd4\xe8\x1a\x65\x68\x81\x42\x54\xba\x3e\xd7\x36\xaa\x22\xd7\x07\x45\x17\x2c\x19\x78\x66\xf7\x28\xbb\x64\x32\xdf\x9d\x85\x6b\xb2\x4c\x6d\xd9\xe0\xd9\xb3\xc6\x55\x3c\xe7\x4e\xef\x6c\x10\x69\xec\xb0\x69\x71\x8f\xc1\xe5\x8b\x08\x3c\xe6\x77\x6a\x08\xa6\xce\x35\x8c\x0d\xc8\x25\xf1\xb8\x09\x4e\xea\x6a\xa4\x9d\xb3\xc9\x53\x9c\x35\x79\x8a\xe1\xa7\xcb\x88\x67\xa6\x7b\xa5\x4b\x84\x7c\xba\x23\x9a\x28\x79\x32\x93\xca\xa0\xac\x93\xbc\x38\xf3\x33\x59\xed\x33\x7c\x48\xf3\x25\x24\x0c\x81\xcf\xd4\x13\x18\x4b\xb3\xa4\x99\xc6\x58\x96\xea\xc9\x8c\x33\x23\x99\xb1\x00\x62\x11\xd6\x91\x96\xc8\x38\xeb\x49\x64\xac\xd5\xc3\xb0\xa4\xea\x9c\x31\xce\x30\x59\x72\x0a\x75\x96\x8d\x6c\x94\xca\x0b\x16\x72\xd0\xb3\x92\x1d\x1c\x7c\xe6\xa5\xb1\xd3\x8b\x64\x5f\x00\x4f\xda\x38\xb6\x70\x55\x6a\xe7\xae\xef\xfc\xbf\x80\x1e\x0c\xf5\x43\x40\x12\x86\x21\x13\x26\xfb\xf0\x4f\xf3\xf4\x4f\x8b\x9d\x05\x22\x28\x6c\x39\x69\x49\xa6\xda\xe9\xd0\x24\xd7\x88\x02\xf7\xad\x0d\x66\x1a\x92\xe0\x17\xfe\x35\xbe\xbc\x12\x48\x06\x58\xd6\x7c\xef\x70\xe8\xe8\x0b\x16\xb8\x0f\xc0\xbd\xf5\xfa\xa9\x42\x43\x46\x67\x9f\x3e\xb7\x1b\xf4\xfb\x4e\x55\x5d\xf3\x90\x02\x19\xb7\x68\x1a\x5c\xd7\xbf\x80\x94\x5f\xc7\xc2\xc1\xff\x66\x34\xcc\xf0\x42\x85\x5f\x5a\xe0\xcc\x59\x08\x36\xe4\xba\xd1\x97\x82\x34\xa0\x89\x96\x50\x2a\xc2\xb9\x33\xa2\x63\x32\x26\x52\x5a\x52\xa5\x20\x34\x69\xa4\xbd\x47\x0c\x38\x1c\xf7\x89\x06\xa2\x88\x1d\x04\xe8\xc2\x3c\x1e\x04\x36\xb0\x25\xea\x32\xa4\x3a\x67\x44\xe3\xce\x2d\x09\xd2\xdc\x64\x6e\xdd\xb6\x71\xeb\x72\x75\x17\xf2\x00\x2e\x22\xd2\xcf\xb5\x7b\x17\xb0\x8d\xea\x9a\xd7\x14\xfa\x23\xf7\xbc\xa4\xc3\x21\xc4\xf5\xf1\xfb\xcd\x3a\x10\xab\xa8\x2f\x4e\xe8\x03\x6e\x11\x8b\x38\x44\x30\x44\x79\x53\xba\xbd\xa1\xb7\xdc\x9b\x6e\xdf\x37\x96\x21\x8d\xba\xdf\xa8\xb1\xe3\xdf\xf2\xe1\x6a\x25\xcf\x3d\xea\x10\x9d\x36\x1b\xaa\xe7\xe9\x70\x98\x40\xea\x68\xfd\xf6\x45\xe3\xa5\xc5\xf3\xd3\xa7\xb1\x13\xc9\x85\x6c\xc4\xcd\xf5\x7a\x3a\x1c\x3e\x6d\xec\xbe\x7d\xa9\xe6\x1b\x2a\xd4\xb3\x47\x8c\xb4\xf3\x83\xfe\xbc\xf3\xff\x46\xca\x79\xd8\xe3\xf7\xa6\xc8\xd7\x2f\x82\x34\x91\xa4\xbe\x95\x31\x01\xd6\xeb\x27\xcd\xcf\xa7\xf2\xa7\x61\x2b\x33\x66\x0a\x85\x78\xe7\x10\xc5\x92\xe3\x4c\x24\xc7\x29\xb2\xec\x87\x2e\x13\x14\xb5\xc1\x72\x1a\xc8\xaa\xa5\xf0\xc7\x49\xb4\xe6\xb4\xa4\x9c\x4c\x1b\x84\xfc\xd6\x8b\x71\xa8\x5f\xd2\xd6\x32\x6d\x49\x26\xcc\x68\xd1\xca\x6b\x9f\xa8\x84\x56\xb2\xfd\xd3\x07\xb7\xdf\x18\xd9\xf4\x37\x21\xde\x19\x6f\x04\x5d\x0e\x1a\xba\xcc\xf1\x01\x38\xc3\x64\x72\xe2\xc4\xba\x96\xc0\xf5\x2e\x5a\x05\xfe\x40\x31\x0b\xca\x28\x1c\xe3\xad\x8a\x05\x4f\x61\xa2\x6e\x59\xea\x59\xe6\x46\x0a\x36\x98\x89\x7f\x03\x45\x1f\x82\xa1\xbe\xe6\x2d\xe0\x30\x7c\x70\xff\x16\xce\x6e\xf8\x15\x7a\x1e\x92\x7b\x19\x64\x69\xa8\x04\x1d\x26\xa4\x49\xc9\xc5\x27\xa6\x7c\x06\x57\xea\x49\x57\xe0\xe0\x74\xab\xc4\x53\x46\x49\xe6\x69\x0d\x01\x02\x50\xae\x9e\x85\xb4\xb7\xc2\x53\x6e\xc0\xd1\x6d\x49\x4b\xd5\x8a\x95\x8a\x96\xb7\x78\x2a\x84\x4b\x2e\x55\x1e\x9b\xcf\x17\x45\x23\xde\xbd\xc5\xd3\x51\x0a\x89\x8e\x78\x34\x6a\xf4\x46\x15\x9c\xe4\xaa\x99\xa8\x1b\x5c\xc0\x10\xe6\xc5\x35\xe5\x80\x4f\xcc\xe7\xe3\xb2\x98\xab\x77\xfc\x46\x8a\x9a\xa7\xf5\x87\xd6\xc0\x8d\xb4\x1f\x2b\x83\xf4\x6d\x10\x7f\xe5\x7d\x46\x42\x9e\xc9\x44\x6f\x2b\x3c\x42\x64\xfe\x84\x66\x81\x4c\xdf\x90\x98\xb1\xd1\xd2\x66\xad\x36\x86\x49\xa6\xe4\x36\xf6\x55\x52\x4d\x61\xaa\xc1\xf7\xed\xeb\xc0\xd8\xd7\x91\xda\xd7\x72\x57\x07\xf7\xec\xd2\x76\x9a\xba\xa7\x0f\x6d\xad\x9f\xc3\xcf\x0e\x6d\x77\x13\x6a\x82\xd3\xe1\xb3\xe1\xd0\x61\x12\x12\x0a\x0d\x71\xea\xf0\x39\x13\x13\x02\xa0\x5f\x21\x1c\x11\x77\xfa\x5e\x0a\x7b\xf7\x52\xa8\xef\xa5\x58\x37\xe4\xba\x8c\x32\x72\x5d\xf7\x16\x42\xd3\xb3\x85\xb4\x7a\x6e\x18\xd6\xba\xfd\x16\xee\xee\xc0\x26\x7c\x26\x7f\xca\xdc\xa8\xcd\x77\x3c\x76\x25\x61\xb0\x02\x4d\xa0\x0c\xe5\xf1\xf6\x14\x8b\x57\xf5\x76\xdc\xa5\xa6\x43\x6e\x42\x30\x36\xf3\x53\x05\xc2\x36\x98\x1d\xf1\x60\x3b\x9a\x45\x5f\x66\x46\x54\x41\xa3\xf9\x2c\x0a\x62\x4a\x1b\x62\x4a\xf9\x00\x26\xd1\xe4\x0d\xb8\x03\x35\xd2\x65\xe8\x7a\x6f\xbb\x45\xd1\xe4\xd8\x2c\x74\x99\x48\x6e\x14\x18\xd2\x19\x35\xa4\x33\x2a\x09\x2a\xed\x7c\x21\xf5\xa9\xac\x36\x08\x2a\xdd\x42\x50\x69\x2f\x12\x50\x1d\x09\xa8\x41\x50\x07\x8a\xa2\x52\xbd\xd9\x86\xf6\x2c\xbe\x56\x0f\xc3\x52\xf4\x53\xec\x70\xc8\xaa\x96\x16\xb9\xb1\xc1\x13\xc8\xca\xdb\x0e\xdc\x4c\x34\x4d\xa4\xdf\xbe\xe2\xa8\x9e\xb4\x46\x7a\xb4\xe1\x16\x30\x45\x61\x3a\x8a\x9d\x2d\xea\x54\x83\x73\x93\x7e\x30\x06\x8f\xc9\x17\x46\xc5\x2e\x68\x6b\x7e\xc8\x76\xe3\x91\x0a\xda\x24\x43\xfb\x1a\xba\x2c\xbf\x1b\x07\x4d\x12\xba\x78\x38\xcc\x9d\x10\xc5\x88\x82\x87\x7f\x60\x30\x98\xcf\xbc\x6d\x92\xe5\xe3\x86\x6d\xe9\xe8\xb9\xfd\xa5\xa3\x2b\x46\xb6\x1b\xbc\x42\xd0\x68\x1b\x54\xaf\x4b\xa6\x9e\x80\xfe\x9a\xcf\xf4\xdb\x34\xa6\xaf\x56\x61\x46\xab\x87\xcc\x77\xef\x14\xeb\xaa\xa2\xa7\xae\xa6\x59\x72\xc3\xfe\x00\x38\x28\xec\x0f\x80\x83\xc2\x6e\x38\x1e\xc7\x6d\x02\x97\x44\x9d\x70\xd0\xa4\x13\x00\x7a\x4b\x97\xfe\x96\x2e\xfd\xb0\x27\x90\x87\x03\x91\xd1\x83\xd6\x82\x37\xde\x77\xa7\xe2\x4a\xaa\x31\xcf\x61\x7f\xf3\x10\x9a\x87\x2d\x8e\x4b\xea\xef\x9b\x89\xf4\xb8\x5e\xce\x14\x45\x8c\x99\x6e\x6c\x78\xc6\x84\x0f\x87\xa5\x13\xa2\x81\xc0\xd2\xf6\x4c\x9b\xc6\x86\x67\x9e\x79\xc4\xdd\x8f\x1a\x2f\xeb\x9a\x84\xd3\x0f\x34\xf6\x7a\xf2\x23\xb5\x84\xc8\xde\x48\xf6\x3d\xe2\xe0\xb7\x5e\xe0\xcc\x9c\xd0\x6d\x5b\x3c\x02\xc8\x98\xdd\x90\x9f\xbe\x9e\x89\xe8\xb5\xd1\x2b\x12\x21\xb4\x72\xbe\x2f\x8e\x21\x3b\x58\x23\x5f\x80\x54\xa2\x1e\x03\x0e\x03\xe3\x38\x86\x0d\xf7\xbc\x31\x8b\x35\xb7\xaf\xe5\x47\xc8\xf4\x04\xba\x16\x3e\xe2\xe5\xba\x12\x9f\x15\x6b\x99\x38\xe2\x78\x83\x62\xf3\x31\x31\x1e\x25\xeb\x65\xea\xf7\x3d\x4d\x8b\x2e\xf5\x07\x8e\x4a\x2c\xe0\x6e\x50\x9f\xe9\xa0\xf7\xa5\x44\x7b\xa9\x6d\x30\x30\xe6\xf2\x57\x87\xf2\x7c\x00\x31\xff\x93\x30\x8c\x47\xa6\x25\xc2\x78\x21\x56\x3e\x7e\xdc\x8c\xcc\x01\x20\x0e\x80\xbd\xda\x76\x77\x6a\x91\x93\xdf\x9c\x84\x27\x47\x08\x30\xa8\xfd\x7e\x63\x2f\x8a\x54\x04\x3c\xe9\x00\x6a\x79\x51\x75\xb0\x2e\xc2\xfa\x07\xa2\x19\xd6\x27\xc9\x1f\x44\x38\x74\x66\x48\x86\xa8\x73\xfd\x19\x37\xf4\x3b\xb2\x27\xc4\x7a\x8a\xf8\x68\xb9\xbb\xd5\xb6\xe9\x54\x50\x71\x1c\xfb\x89\xf6\x60\xe8\x58\xa6\x1d\xf4\x6a\x9c\x31\x65\xa8\x75\x38\xef\xc6\xae\x2f\xee\x2f\xda\xaf\x8f\xde\x1e\x5d\x1c\xbd\xb6\xfd\xd0\x88\x14\x69\xde\x74\x0d\xf5\x38\x11\x8d\x8b\x5e\x63\x71\x9b\x38\xfa\x93\x1e\x67\x22\x44\x7a\x0d\x06\x2b\xb7\x6e\xbc\x33\x6b\x37\xba\x7a\x48\xa3\xf9\xe6\x86\x95\xc8\x05\x8e\xc5\x62\x7a\x49\xcb\x6f\x46\x52\x81\x89\x63\x84\xc0\x44\x3b\x63\xd7\xdb\x39\x6c\x39\x2b\x04\x38\x01\x48\x7f\x0b\x84\x24\x14\x1c\x86\x11\xa7\x39\x92\x7a\x04\xd2\x27\x76\x90\xe1\xf0\xdb\x1d\x15\xa5\xf0\x89\xfc\x09\x9e\x8e\x5a\xeb\x95\x08\xcc\x49\x71\xbf\x6f\xa0\x3f\x60\xe4\x67\x2a\xcd\x64\x3e\x8f\x34\x22\xb6\x73\x8f\x57\x5f\x77\x7b\xee\x1c\x4a\xbc\xdb\xda\x70\x83\xbe\xe6\xef\x67\xb6\xbe\xcf\xfc\xa7\xb7\x04\x72\xf7\xad\xed\xf6\xbf\xa1\xdb\x03\x3b\x6f\x3d\xb3\x05\x5d\xf8\xfa\xd7\x6d\x44\xb8\x4e\x32\x0a\x49\x2e\xe0\x1b\x66\xd5\xa6\xd8\x30\x41\x0a\x79\xdd\xfc\xe0\x73\xe1\x83\x3a\xe5\x95\xc7\x0c\x89\x9b\x5a\x2e\xe4\x96\x6a\x45\x9a\x7e\xf2\xa6\xcc\xe8\x64\xc5\x79\xcf\x25\xff\x73\xcb\x84\xc3\x87\x2c\x1e\x71\xef\x96\x78\x30\xd5\x71\xb2\xed\xa8\xb1\x6a\x2e\xa7\xdf\xe2\x9d\xf1\x57\x17\x79\x89\xf9\x58\x7c\x36\x88\xbf\xb3\xe2\x3c\xb0\xcd\xad\x24\x86\x10\xdf\x4e\xc4\x8d\xe1\xa1\x61\xdc\xbb\x08\xcf\x1c\x6e\xeb\xdf\x89\xd6\x6b\x55\x6c\x18\xc4\x1f\x43\xc7\xda\xb0\x37\x81\xb3\x42\x4b\x77\xc3\x4a\x96\x78\xea\x44\x22\x2b\x8c\xf9\x16\xcc\x19\x62\xdb\xe4\xa1\x78\xa7\x92\x0b\x94\x8e\x19\xda\x53\x90\x90\x16\xa7\x02\x76\x35\xdf\x8c\xaf\x1d\xe8\x26\x47\xa0\x0e\x3b\x63\xc8\x70\xf5\x70\x3c\x6e\x14\x93\x79\x6b\x18\x66\xff\xe4\x7e\x3c\x17\x19\x97\x77\x30\x1e\xac\x9a\x40\xff\x6c\xa2\x6f\xb5\x9b\x7f\x2e\x9b\xa5\xb1\x0c\xdd\x27\x03\xa6\xb2\x66\x8a\x06\xad\xd7\xf6\x94\x12\xc8\xc6\x1c\x0e\x87\x76\x50\x44\x2b\xf1\x7b\x87\xc7\x9f\x30\xcd\x40\x2e\x97\xcd\x97\x7e\xe8\xbb\x01\xdc\x0e\x47\x21\x66\x1c\x94\xcf\xba\xf3\x97\x78\x35\x99\x19\x4a\x1a\x3d\xce\xda\xce\xd8\x38\xb1\xfe\xea\x61\x88\xde\x06\x78\x4e\xf0\xce\xb8\x2f\x25\x92\x7e\xe4\x73\x96\xe9\xb9\x1e\x53\x0a\x52\x96\x44\xab\xe3\xa2\xe4\x89\x03\x18\x56\x69\x77\x01\x72\x11\x56\xe0\xf0\x7b\x0d\x91\x5c\xcd\x2e\xac\x9d\x45\x0c\x45\xfb\x4f\x34\xa2\x66\x52\x3b\xc7\xc4\xc5\x1c\x4c\x7c\xf9\x43\xaf\xf5\xaf\x13\x91\x4e\xea\x33\x0e\xe5\x31\xf0\xd9\x97\xfb\x66\xe7\x10\xc9\x50\xc3\x90\x58\x41\x8f\xb2\x24\x5b\xc5\xf8\x73\x33\x66\x3f\x06\x45\xce\x4d\xe2\x7c\x86\xad\x15\x0f\x0f\x1f\xbf\x90\xf1\x3e\x3f\xb7\xd2\xf5\xec\x60\x9c\x0c\x87\xb7\x89\x93\xb8\x1b\x71\x9c\xc6\xc3\xfd\xc7\x4f\x1f\x2b\x19\xea\x27\xca\xe0\x7c\x6e\xd9\xd7\x0d\x2e\xbd\xbf\xc9\x09\x75\xb4\xde\xd0\xe7\x96\x29\xa2\x55\x3d\x30\xeb\x5f\x78\x6f\x43\x86\x9a\x2b\xf6\x15\x88\xfd\x3e\xdc\x7c\xc6\x9f\xb5\xa9\xde\x08\xbb\xc8\x69\xc8\xe8\xc8\xce\x18\x51\x7c\x1a\x6e\x18\x07\x25\x24\x8f\xcf\x1c\x07\x9a\xb8\x62\x68\xe6\x7c\x46\x54\x1d\xdd\x9f\x87\x43\xc7\x04\xe9\xba\x9b\x2f\x09\xdc\x01\x91\x48\x41\xfa\xd6\x85\x0d\x46\x45\x4d\xde\xba\x26\x53\x63\x4d\xa6\xc3\x27\xcf\x86\xc3\x97\x49\x7b\x4a\xa6\x6c\x71\x86\xc3\x1f\xe5\x62\x4d\x87\xcf\x9e\xaa\x5b\x9f\xf8\x73\x63\x5e\x10\xd0\xdf\xc3\x25\xdb\xf7\x70\x39\x9f\xba\xe8\xbd\x76\xbd\x95\x4a\x8b\x4d\xac\xe9\x77\x74\xfd\x06\xd5\x9f\xd1\x56\x28\xae\x82\x03\x13\xf8\xa2\x91\x3b\x10\x35\xa4\x6b\x6a\x1c\x32\x8d\x54\xfa\x0a\xd6\x25\x1e\x41\x22\x60\x74\xa7\xaa\xce\x6b\x12\xce\xbc\x78\x64\x16\x6c\x5c\x7f\x60\x48\xa6\x52\xe1\xc0\xd8\xf6\x80\x60\x01\x67\xab\xcf\x19\x04\x1d\x25\xc6\x3a\xfa\x9f\x3b\xc1\xcc\x3e\xe3\x63\xa2\x63\x0c\x20\x57\xc4\x30\x26\xfc\x1a\xc6\x44\xf7\x63\xcc\x9c\xe0\xb7\x01\xc3\x88\x3e\xf3\xe0\x17\x3a\x1c\x7e\x69\x19\xe4\x62\xf6\x61\x31\x51\x77\x89\x8f\x5d\x14\x13\xe1\xe7\x22\xcf\x0d\xe1\xf9\x4a\x50\xc0\x6b\xd0\xb5\x43\x5c\x7e\xa9\x4f\xa0\x66\x3b\xdd\x00\x38\xcb\xb1\x4f\x21\xf8\xbd\x00\x26\xf9\xd7\x8d\x69\x56\x95\x56\x28\x4e\x41\x8b\x44\xd7\x7b\x21\x82\x7e\x66\x14\x5b\x63\x35\x79\xf8\x68\xed\xfa\x3a\xc5\xc4\x37\x9c\x8f\x30\xc6\x3f\xeb\xde\x46\x80\x78\xad\xab\x36\xec\x34\x7a\xdc\xe8\x1f\x19\x5f\x3b\xe0\xd8\xc4\xe9\x97\x48\x4e\x10\x63\x6a\x78\xa6\xc7\xf2\x3a\x5a\x3c\x19\x7b\x71\xfb\x9b\x9b\xfc\x0d\xd4\x74\x5e\x49\x7c\x77\xcc\xfe\xb4\x5e\x18\x0e\xc1\xa7\x30\x5e\xaf\xe3\x1f\xda\x75\x2e\xbf\xbd\xde\xb9\x22\x94\xe0\x44\x7d\x7d\xfb\xab\x70\xbc\xd1\x55\x0a\xca\xfb\xb2\xd1\xa5\x34\x4a\x66\x8d\xe0\x43\x32\x05\x53\xcc\xd1\x9e\x14\xb6\xe9\x47\x8c\x80\x04\xca\x6d\xa3\x34\xdc\x76\x0e\x99\x20\x8d\x60\x7f\xc6\x49\x86\x8c\xf3\xae\xbf\x9f\xc9\xd6\x5e\x5a\x31\x05\x49\xab\x23\xd7\xed\x8d\x54\xe7\x0f\x74\x73\x3e\xc1\xa1\x70\x4c\xd2\x2f\xd0\x76\x0e\x6b\x61\xc1\xd8\xf4\x87\x1c\x89\x1a\x5d\xcf\x4d\x07\xa1\x95\xd1\x8f\x51\x14\x1c\xc2\x56\x6a\x9f\xfc\xdd\xcd\x42\x1b\x90\x79\x77\x93\xfc\x6b\x30\x63\x2d\x8e\x29\xa3\xe6\x9c\x1d\x06\xac\xfc\x79\xbd\xfe\xf9\x07\x02\xc1\x0e\x7e\xfe\x1e\xbf\xe3\x69\x25\x24\x2a\x1d\xf9\xee\x11\x9e\x3a\x47\xee\x84\x3a\x47\xae\x17\x39\x47\x42\xad\x6f\x34\x1a\x0e\x77\x16\x8e\xdb\x6d\xba\x91\x16\x80\x87\xf6\xf4\x55\xf8\x00\xd5\xbc\x45\xea\xde\xcd\xb9\x49\xf2\xa9\x76\x2b\x90\xf3\x6a\xa4\xbb\x9c\x03\xce\x8d\x32\x06\x95\x06\xeb\x75\xb0\x03\xc3\x12\x73\x7a\x24\x88\xd4\xfe\xe1\xf7\x11\xf5\xdd\x76\x32\x5a\x1f\xf2\xc5\x36\xa9\x2c\xf1\xab\xe6\xce\x04\x23\xc4\x73\x76\x86\xd3\x00\x13\xff\x67\x1c\xf8\x47\xb8\xa0\x0e\x55\x74\x53\xe6\x1c\x13\xaa\xb3\x9d\x43\x24\x6c\x01\x70\x8e\x37\x89\xb6\x7e\x69\x0e\x89\x5f\x42\xee\x01\x14\x0a\x8b\x60\xe0\xde\x05\x04\x8b\xec\xca\x1b\x4e\x80\x8e\x34\x8b\x52\xe2\xc6\x81\x11\xc1\x7a\x8a\x67\x0e\xc4\x08\xcc\x65\x80\x09\x38\x58\xcd\xdb\x93\x3b\xb1\x48\xfa\x15\xe2\xa9\x1f\xe1\x40\x44\x74\x08\x35\x9a\x26\x15\x1e\x89\x71\x0c\xff\x45\x9d\xa4\xa5\x89\xcd\x5a\x25\x4f\xbc\xe3\x76\xa3\xa7\xbc\x88\x11\xb0\x04\x43\xc8\xf1\x44\xcb\xaa\x88\xf1\x54\xd8\x78\x12\xac\x19\x62\x36\x47\x98\x32\x5e\x9e\x09\x72\xad\x79\xf2\xd9\x3c\x35\x96\x22\xb1\x57\x37\x01\x0e\x88\x1f\x73\xa6\xfd\xd0\x1f\x88\xe3\x4c\x53\x4e\x5f\x6b\x8e\x9a\x5d\x3c\x99\xa8\x84\xc2\xcd\xe0\x3c\x73\xe7\x1b\xb7\x8a\x5b\x3b\x10\x09\xf6\x19\xfc\x34\x24\x83\xaf\xbc\x3c\xdc\x10\x13\x54\xf2\x54\xb5\xb0\x62\x1a\xce\xf3\x55\xed\xd1\xcf\x24\x2a\x14\x0b\x43\x87\xc7\x6c\xb9\xc1\x87\xa1\x3f\x64\xf7\x3d\x0c\x12\x5c\x14\xda\x19\xa3\x18\xc7\x91\x93\xb0\x43\x37\x41\x90\x54\xc7\x7b\x22\x81\x82\x4f\x01\xbf\xbe\x5e\x3a\x09\x8f\xd7\xf3\x36\x54\xd7\x82\x24\x23\x31\x25\x95\x93\xb8\xaa\x38\xd1\x99\x3e\x59\xad\x85\x44\x69\x25\xc7\xe7\xf3\xc2\xe6\x68\x63\xae\xb5\x4e\xa3\xa5\xcb\x4a\x4e\x38\x8b\x21\x72\x3b\xbb\x7e\x4e\x46\x24\x8a\x1c\x11\x85\x78\x8a\x6d\xdb\x4f\x30\xf1\xa3\xe2\x8e\x78\x3d\xd8\x3a\x96\xb7\xe6\xf5\x3b\xf4\xdc\x14\x36\xc3\x83\x64\xf4\x29\xa2\xc1\x32\x39\xbb\xc9\x69\x89\x32\x2c\x9f\xcf\x8b\x65\x19\xf2\x9b\x58\xc7\x84\x4f\x97\x08\xa4\x03\x63\x9f\xb1\x31\xb1\xe2\x99\xeb\xfa\x33\x9c\xf9\xc7\x04\xdb\x7f\xe4\x96\x65\x59\x69\x6e\xd9\x7b\xce\x31\xd1\x52\xf0\xba\x7b\xce\x6c\x62\x5b\x0e\xa9\x2d\x7b\x6f\x36\x8a\xd3\x8c\xbe\x23\x73\x3a\x2a\x79\x88\x7f\xe7\xe0\x7f\x8d\x1e\x5d\xfe\xf1\xc7\x1f\x07\x57\x07\xc8\xb6\xdd\x3d\xdb\x63\xcd\xb2\x34\xa7\xef\x20\xe0\xc1\x9e\xed\xda\x5e\xce\x20\x70\x6f\xfc\xc8\x0a\x56\x96\xbd\x97\x43\xb9\x6d\xab\x1b\x1b\x8a\x53\x65\xa3\xb1\x37\xd3\x3d\x7c\x4c\x5a\xbb\xe9\x66\x9a\x66\xb0\x2f\x13\x3c\xf5\xe1\xc3\x88\xa2\x11\x8c\xd1\x7f\x2f\xc3\xe1\x32\xce\xaf\xe1\xa3\xd9\x70\x21\xce\xb8\xc1\x57\x27\x08\xf8\x64\x2f\xe0\x7f\x7f\x2c\x96\x79\x44\xca\x95\x17\x4d\xc2\x96\xd9\xc6\x6c\x70\xcc\xfe\x7a\x91\x59\x08\x5d\xc4\xe8\x06\x52\x24\xd4\xe5\xca\xa3\x1b\xff\x3d\x04\xdb\x0d\x51\xe0\x02\xad\x0c\x8b\xbc\x2a\x32\xca\xb9\x73\x27\x10\x5c\xba\xa0\x0a\xaf\xd8\x82\x1b\x0d\x5e\x25\xee\xe6\x6d\x30\x91\x34\x52\xe0\xae\x42\x24\x34\x88\x25\x26\xb9\xde\xb1\xd3\xf8\x2b\x86\x9b\x96\x3c\x60\xfa\x75\x1b\x61\x01\x1a\xd5\x49\x23\x2c\xbd\x07\xfc\x27\xcd\xf6\x30\x6c\xbe\xa2\x56\xdf\x1d\xad\xeb\xf9\x26\x44\x81\xff\xf7\xc2\x94\xd5\xfd\x40\x35\xfb\xc7\xe3\xf1\x23\xc7\x71\xde\x3a\xee\xde\xe1\x78\xec\x1e\x3c\x1e\xaf\xc7\xee\xde\xa1\x6b\xdc\x34\x57\x8d\x19\x3f\xfb\x17\x99\xfc\x45\xbc\x39\x99\xbc\x0d\x26\x87\xde\xcf\xde\xce\xeb\x64\xbd\xee\x0b\x93\x31\x3c\x9c\xe4\x8e\xeb\x1d\xb6\xe2\xa8\x2a\x60\x3c\x90\xdf\x8e\xde\xd7\x6d\x13\x85\x59\xa9\xa2\x7d\x75\xb9\xf9\x21\x49\x01\x7b\xb2\x00\xfa\x7d\xf3\x23\x00\x36\xb6\xf6\x36\xe8\xc1\xf6\xca\x1f\x02\xb7\x65\xa8\x6f\x77\x69\xdc\x15\xd0\x7c\x4e\x0c\xc2\xdf\x63\xfc\xdb\x99\x93\xe1\x30\xc4\x8c\x1d\x19\x0e\x83\xef\xf1\xcf\xc3\xa1\x73\x84\x29\xbf\xf9\x88\x7e\xc6\x63\xe9\x14\x1a\xf8\xa7\xc1\x0f\x47\x09\x84\x16\x3f\x7c\xf1\xad\xed\x1a\xbe\x24\x8c\x39\x16\x77\xf1\x69\xf4\xa1\x28\x6a\x37\x1c\x95\x74\x4e\xd2\x3c\xcd\x93\xa3\x56\x04\x69\xe9\x61\x79\x3a\x71\x0a\x82\x4f\x71\x88\x7a\x00\xe0\xd0\xf5\x9c\x53\x7c\xda\x57\x83\xfa\x4a\x0b\xa2\xd9\xa0\x79\x6c\x8b\xde\xfe\xe5\x15\x2b\xba\x5e\x47\xdf\xd3\xfb\xc6\xb9\x79\x43\xd6\x6b\x67\x46\x26\xef\x82\xe1\xf0\x8b\x13\xa2\x43\xd7\x3b\x84\xdb\xad\x27\xce\x21\x0f\x08\xe8\x25\xc1\x7a\xed\x24\xec\x14\x45\x3f\x53\xe7\xc2\x75\x05\xd7\xc9\xb9\x08\xc3\x78\xb1\x31\x22\xcd\xba\x77\x0c\xf5\x0e\xd1\x60\x67\xec\xea\x41\x40\x15\xb2\xbe\x0b\xb1\xe3\xfc\x42\x1d\x77\xff\x38\x71\x0f\x0e\x61\x97\x3c\xd6\xe3\x4c\xf2\xe5\x24\x78\x2c\xee\xa9\x6a\x32\xc7\xa9\x2b\x0f\xf3\x10\x9f\xa2\x08\x17\x44\x0b\x50\x2e\x26\x28\xfa\xea\x04\x35\x1e\x9b\x8a\x45\x3d\xe5\xac\xee\x53\x83\x85\x8b\x20\xe0\x62\x17\x05\xee\x60\x75\x7b\x6a\x70\xe3\x04\xa5\x78\x74\x06\xa4\x20\x6e\x41\x30\xed\x7b\xa5\x77\xc9\x29\xda\x0a\x5c\x07\x7b\xea\xde\x9d\xe2\xd0\xef\x47\x1a\xff\x21\xe3\xeb\xc3\xcf\xbe\x41\x6e\x85\x15\xf5\xed\x11\x75\xdd\x65\x0c\x7e\x41\xeb\x35\xfd\x9e\xb8\x04\x2e\x6f\x47\xbe\x1a\xbb\x60\x5e\x71\x04\x21\xf1\xbb\x40\x36\x21\x5e\x10\x4d\xf6\x66\x9b\x39\x98\x9c\x06\x7b\x7b\xde\x69\x80\xc7\xfe\x82\xe0\xc0\x3f\x0b\x30\x31\x02\x55\xba\x77\x27\xce\x18\xe9\x39\x5f\x4f\x38\x25\x9c\x06\x82\x07\x7f\xd3\x04\xff\x5b\x90\xe1\x90\x11\xe2\xb3\x40\x92\xb1\xf5\xfa\x2c\xf8\x1e\x33\x16\x72\xe7\x2c\xf4\xdd\x2f\xce\x82\xa0\xb3\xc0\x45\xda\x4b\x53\xd6\x98\xed\x8c\x43\x75\xb8\x2f\xc8\x7a\xdd\xd9\x30\xfe\x54\xa0\xef\x19\x28\x18\x61\xcc\x69\xec\xbc\x0f\xdc\x7a\x5a\x16\x37\x16\xc1\xef\x43\xf4\x9e\xf3\x6b\xe8\x3d\x83\x87\x88\xaf\xe5\xb5\x05\x6d\xfb\xdd\x1b\x21\x84\x69\x71\x23\xde\x80\x10\x96\xc6\x4e\xf8\x3d\x7e\xeb\xb8\x4d\xe6\xf6\x38\xcd\xd3\x6a\xca\xef\x83\xaa\x7d\x31\x71\xcc\x0a\xe9\x04\xb5\x8d\x3a\x04\x0e\x5c\xad\xef\x7b\x29\xc2\x09\x37\x01\xe4\xea\x1e\xbb\xb3\x1d\xd0\x00\x20\x09\xb2\xd1\x1e\x1e\xfa\x3f\x34\xbc\x85\xe3\x4e\x5a\x6d\x23\xef\x2b\xd0\x5d\x98\x61\xed\xb0\x5d\x38\x06\xdf\xc0\xa4\xa9\x60\xbd\x9e\x06\xa3\x3a\x9d\xd3\x0f\x12\x94\xe3\xfe\xf0\x26\x99\xec\x1c\x7a\x67\xe0\x58\xad\xde\xbe\x66\x48\xa9\x10\x85\xaf\x66\x73\x8d\xc7\x5f\x6c\x1f\xcd\xd8\x7f\xcf\x90\xea\x3d\x20\xd5\xfb\x10\x13\x2e\xe5\xd6\x18\x5c\x4b\xd0\x2f\x01\x06\x27\x00\x74\x4c\x71\xdd\xbd\xa0\x99\x99\x85\xf4\xb6\x46\xf3\x04\xd7\xa3\xae\xf3\x01\x7a\x43\x31\x04\x9f\xaa\xd1\x2f\x01\x5a\xa2\x95\x8b\x6e\xf0\x1b\x3a\x52\x31\x52\x50\x9e\xa8\xe7\xe6\xca\x31\x2a\x12\x1c\xc9\xd7\xdc\x91\x7e\x2b\xd2\x1f\xd4\x18\x2e\x81\xcc\xf8\x31\x7b\xc3\x3a\xee\x77\xf8\x45\x3f\x51\x55\xa7\x3c\x7b\xd1\xaa\x79\x41\x3a\x03\xa2\x93\xa6\x21\x74\xff\xb2\x69\xd3\xb8\x91\xa1\x1f\x9b\x52\xe5\x41\x84\x6e\x75\x70\xb2\xf0\x17\x8a\xc9\x28\x2f\x6e\xd0\xcf\x60\x75\x17\xc4\xe7\x35\x8d\x69\x59\xd2\x48\xa6\x35\x44\xaf\x93\xde\xb0\x3c\xd7\x49\x73\xed\x56\xc9\xb7\xe8\x4b\x02\x5e\x42\x15\xad\x5f\xc6\x35\x95\xa5\xc7\x09\x66\x07\x1e\x7a\x17\xe2\xc7\xe8\x2f\x76\xb2\x81\xfc\x8c\x8e\x38\xe2\x6a\x5c\x09\xfa\x2c\xe8\x01\xff\x93\x0b\x75\xb1\x50\x28\x2b\xf5\x71\x0c\xe4\xe2\x2d\xff\x17\xb4\x1e\x85\xa8\x39\xe5\x7f\x80\x3e\x21\xc0\x63\xb4\x10\x55\x67\x01\x1e\x23\x20\x46\x82\xdc\x48\xe2\x23\x08\x15\x9a\x41\xf3\x77\x50\x77\x94\xe0\xc3\xa3\x27\x88\x51\x2d\xf4\x26\xc1\x87\x9a\xd7\xf6\x62\x59\x53\x48\xd8\xd7\xa0\xab\x97\x23\x51\xd1\x94\x1d\x17\x25\x24\xa4\xf4\x56\x68\x20\x27\x17\x1c\x2b\x97\x28\x60\x42\x05\x15\xee\x6e\x6d\xcf\x3f\x7e\xba\xcf\x88\x3f\x03\x3a\xd7\xce\x9b\x0e\xb7\xa0\xb3\xd5\x9d\x33\x23\x38\x74\xd7\x6b\xc6\xcb\x28\xb6\x65\xb3\x41\xcb\x7c\x2b\x74\x60\x7f\x67\x64\x38\xdc\x79\x17\xb8\x77\xef\x82\x0e\xf8\x06\x3a\x4c\x82\xd2\x4d\xb2\x1a\x14\x67\xcb\x6a\xca\x90\xa0\xc7\x1f\xcd\x18\xad\x88\xe4\x19\xe2\xbf\x88\xff\x17\xc1\x87\x2a\x7f\x7a\x84\x89\xa3\x45\x00\x10\x5d\xfd\x45\x70\xb8\x91\xe6\x27\x15\x48\x4e\x55\xcf\x08\x0e\x10\x3f\x05\x0e\x5f\x34\x06\x50\xa4\x7f\x73\x24\x70\xb6\xef\x93\xf9\x00\xf9\x50\x72\xc7\xdd\xf6\xc1\x7f\x11\x1c\x98\x97\xb8\x66\xbd\xfe\x6b\x33\x10\x6a\x5b\x71\x3f\x78\x38\x71\x8d\xfd\xd6\x1d\xd9\xcc\x8b\x10\x3e\xc1\x60\x07\x56\x57\xb2\xfa\x11\x0a\x72\x2c\x6e\x45\x29\xb8\x3c\xaf\xe3\x94\xc2\x4e\x10\xe1\xb7\x39\x81\xe9\xce\x51\x4f\x94\x73\x14\x69\x5c\xe4\xc2\x56\xb2\x2f\x82\xe4\xed\x65\x19\x19\x15\x5e\xda\x42\xaf\xbd\x31\x6a\xeb\xbb\xbc\x9d\x43\xa4\x1f\x3e\x22\xb3\xaa\xf0\x30\x83\x07\xf3\x7e\xb4\x48\xa0\xcd\xbd\x0a\xbc\x00\x75\xd8\x22\xae\x2d\x53\xd2\xb4\x71\x7b\x55\xe6\x89\xec\xfd\x7c\xb8\xbb\xac\xb2\x44\x8a\x2f\x06\x2e\x02\xdc\xf7\xfb\x73\xc9\x82\x12\xc8\x0f\x3c\xae\x18\x63\xd2\xfc\x70\xf8\x58\xfa\xd5\xeb\x57\x44\x9f\x8f\x6d\x57\x69\x38\x9f\xec\x88\xb8\xb4\x22\x68\x2d\x75\xa6\xae\x7b\x07\x31\x60\x95\xfe\x6c\x5b\xbe\x54\x5a\x26\x66\xbe\x54\xb1\x5f\x82\x8d\x33\xc5\x53\x4d\x00\x34\x7a\x3f\xb4\xdd\x8d\x09\x5f\xcc\xf1\x26\xc4\x53\xea\x84\xee\x24\xa3\x4e\x88\xa6\xae\x37\x95\xc6\xfb\x57\xcd\xd5\x21\xd1\x76\xa2\x7e\xe1\xd0\x6b\x07\xe3\x83\xb8\x1c\xa5\x1f\x34\xc9\x75\x03\x8e\xf5\x81\x5f\x0a\x27\x6e\x62\x26\x40\xfd\xcf\xa6\x43\x9d\x44\x8e\xeb\x81\x72\xe9\x35\x75\x92\x4e\x02\xdf\xd2\x4c\xe0\x7b\x27\x82\x36\x79\x64\xd3\xe4\xf1\x0d\xb6\xa7\x57\x1e\xdc\x9f\xc8\x37\x76\x12\x54\xba\x9b\x36\xdd\x26\x23\xb3\xa0\x4b\x7b\xc9\xa8\x5d\xd4\xa1\x55\x64\xd4\x2a\xd1\x08\x2d\x19\xa9\xdf\x48\x51\x12\xb6\x0b\x7a\xfd\x6c\x08\x26\x3a\x5e\xef\xc8\x80\x02\xba\x7a\x54\xb9\x18\x72\xff\xe7\x1e\x47\xc3\x50\x55\xea\x69\xda\x0c\xf7\x3f\xab\xd3\x62\xb3\x61\xdb\x3c\x32\x1c\x91\x82\x4e\xd1\x6f\x69\x3d\x7d\x57\xbc\x87\x44\x87\x55\x6b\xe8\xd9\xc3\xe8\x2a\x4a\xf3\xbf\x28\x6c\x9b\xe2\x35\xbd\xbe\x28\x8a\xac\x4b\xed\xb9\x3f\x4a\x1e\xc1\x16\xfe\x71\xa5\x8f\x40\x76\xb0\xa2\x0e\xa4\x88\x1f\x10\x74\xd7\x1e\xe5\x8f\x2b\x7e\x6c\xf7\xb8\x30\xb1\x33\x80\x7f\x69\x0f\xec\xbe\x17\xc2\x49\xe8\x10\x91\x92\x62\xe3\x4a\x4f\xe9\x2c\x96\xc9\xda\xe2\x92\xd2\x2f\xd4\xb9\x93\xf3\x3b\x8b\x37\x2e\x9a\xc7\x38\x8b\x87\xc3\x59\xbc\x5e\x67\x31\xca\x63\x3c\x8f\x2f\x6d\xd1\xc2\xbe\x9a\x18\x4f\xde\x3c\x46\x45\xdc\x13\x7a\x7b\x41\xcb\xb8\x28\xe7\x6c\x60\xfd\x21\xf0\xb4\x06\xc0\x04\x2e\xa4\x6b\x86\xbf\x88\x71\x11\x4f\xba\xfe\xcd\xad\x37\x1c\x77\xd3\xe3\x04\xfd\x9a\xd4\xb2\x16\xa8\xe7\x67\x05\x76\x90\xc6\xce\x7c\x14\x92\xfc\x63\x45\x5f\x9f\x9d\xba\xc6\x0d\xe4\x26\x04\x40\x49\x3f\x2f\x69\x55\x9f\x44\x19\x95\x1b\x92\x2f\x6b\xc9\x4d\x1e\xa8\x8a\x19\x7f\x56\xc3\xbf\xcb\x18\x8f\xd1\x75\x8c\x9f\x3c\x41\x37\xf0\xef\x6d\xec\xdf\xc2\xf0\xef\x0c\xd9\xa4\x67\xa0\xcb\x78\xbf\xfb\x41\x1b\xef\x21\xef\x69\xdf\xc8\x3f\x72\x15\x63\x5b\x12\x74\x6d\xdc\xdf\xd8\x7b\xa7\xa4\x9e\x8e\x4a\x92\x47\xc5\xdc\x71\x55\x46\x3e\xe7\xc9\x33\x77\x54\x65\x69\x48\x9d\xc7\xae\x7f\x93\xe6\x51\x71\x33\x22\x51\x74\x74\x4d\xf3\xfa\x2d\xdc\x8a\xa4\xa5\x63\xcf\x69\x55\x91\x84\xda\xc8\xd8\x2a\xa3\x0a\xcc\x07\x18\x63\xfe\xe2\x70\x48\x46\x11\xa9\x09\xc6\x78\x15\x0f\x87\x0e\x9f\x1f\x82\xcb\x18\xc9\x29\xcb\x35\x97\xfd\xdb\xd8\x75\x37\x10\x33\x95\x8d\xfc\x4b\x6c\x24\x49\x84\x59\x95\xbe\x68\xfb\xcb\x78\xef\x26\xf6\x83\xef\x6f\xe2\xe1\xf0\x3a\xfe\xfe\x26\x9e\x38\x2f\x7e\xe0\x06\xe2\x17\x2e\x9b\xf0\xe0\xfb\xeb\x78\x72\x1d\x7b\x81\xeb\x5d\xc7\x38\xf0\x97\x31\x26\xec\x95\x2a\x5e\xaf\x61\x1c\x63\x34\x10\x5f\xb7\x28\xaa\xfa\x94\x7f\x8f\xb3\x8a\x91\xfd\xc8\x76\xdd\x8d\xff\xd9\xec\xbe\x8c\x31\xf1\x6b\xf6\x72\x0d\x2f\x0b\x5c\x78\x99\xa7\x73\xce\xff\x94\x64\x4e\x9d\x2f\xb1\xab\x28\xc5\x78\xc3\xcf\xb3\xcf\x31\xee\x41\x1c\x5f\xd6\xe9\x9d\x30\xf1\x2b\x9d\xd3\x62\x59\x3b\xda\xea\x12\xe7\xab\x2b\x7f\x92\x33\x56\xa6\x5e\x6d\x36\x5a\x54\xfc\xf1\xc6\x1f\xb0\xf9\x7a\x19\xe3\x83\xff\x75\xe9\xbd\xdc\xff\xfd\x13\xd9\xff\xf2\xc7\x72\x3c\x7e\x35\xde\x67\x7f\x5e\x3f\x83\x7f\x5f\xc0\xc3\x31\x3c\x1c\xc3\xc3\xe3\xe3\xe3\x3f\x96\xe3\x27\xcf\xa1\xd9\x93\xe7\xaf\xe1\xdf\xe3\xfd\x3f\x96\x87\xc7\xac\xe6\xf1\x78\xfc\x6a\x1f\xfe\xbc\x66\xff\x42\xb3\xc7\x87\x2f\x58\xcd\xab\x31\x3c\x1c\x1f\x1d\xff\xb1\x7c\x32\x1e\x1f\xee\xff\xb1\x7c\xfd\x9c\xbd\x73\xfc\x1d\xd4\x1c\xbf\x7e\xc5\x1e\x5e\x1f\xc3\xc3\xf1\xf1\xeb\xab\xff\xbf\x0e\xec\x8f\xfd\xd1\x78\xff\x3b\xd6\xf5\x8f\xcf\x59\x37\x63\xde\xe7\x33\xe8\xe6\xc9\x31\x74\xf3\x74\x7c\xf5\xe8\x9b\x03\xf4\x63\x8c\xef\x36\xe8\x15\x5c\x32\x51\x4c\xf9\x6b\xe9\x80\xf0\x2a\x1e\x4d\x49\x75\x76\x93\xbf\x2f\x8b\x05\x2d\xeb\x95\x43\xa4\x5d\x90\xeb\x8a\x7e\xbc\xa7\x01\x98\xee\x5f\xc6\xa3\x9a\x56\x75\x53\x6c\xbd\x8a\x2f\xc9\x15\x13\x6a\x7e\x94\x3f\x94\xaf\x75\x23\x25\x1c\xc5\x66\x76\xde\x25\x13\xd2\x40\xc9\x37\x1c\xd6\x04\x2e\x2a\x35\x8a\x59\x79\x01\xfa\x94\xd6\xd3\x22\xf2\xe9\x84\x27\x1c\x12\x2e\x62\xe1\x7a\x1d\xb1\x41\xfe\x58\x14\x19\x25\xf9\xaf\x24\x5b\x32\x66\x49\x16\xbf\x5b\xce\x69\x99\x86\xa2\x38\xad\xde\x91\x77\x90\xcf\x06\x2a\xdf\x17\x55\x5a\xa7\xd7\xd4\x6c\x74\xf8\x83\x7c\xf9\xec\x9a\x96\x59\x41\x22\x1a\xb5\xa0\x1f\xc2\xc5\xfd\x63\x1e\xb0\xc2\x63\x43\xac\xea\x8f\x15\x95\xb3\x34\x21\x97\x3c\xee\x03\x7b\x78\x47\xe6\xf4\x0a\x87\x9e\x13\xe0\x68\x44\xea\xba\x4c\x83\x65\x0d\xd6\x46\x04\x79\xe6\x8d\xa2\x6a\x41\x42\xea\xf2\x0c\x97\x2f\x55\xc5\x39\x5c\x37\xb1\xed\xbd\x90\x75\xd6\xfa\xd8\xaf\x8d\x75\x0c\x63\x35\x21\x3a\x90\xa1\xd4\xeb\x29\xdc\x0b\xa5\xf2\xed\x0d\x5f\x23\xb1\x1c\x93\x90\x5f\xf6\xd2\x16\xf1\x8d\x5a\xc4\xd7\x31\xc4\x8f\x11\x06\x10\xd6\x19\xbf\xc6\xad\x81\xde\xde\x59\x63\x06\x88\x75\x81\x8b\xa3\x44\x38\x71\x02\x1c\xb6\x50\xc0\x9d\x40\x0c\x0c\x1e\x1c\xd0\x0b\x7b\x66\x3f\x6c\xcf\x7e\x7b\xd2\x26\x3b\x87\x9e\x6d\x7b\xdd\x81\x86\xe6\x7a\xb8\x3d\x4d\x02\x7d\x12\x7e\x8a\xcd\x78\xe6\x3c\x2d\x49\x04\x77\xe6\x68\x38\xa3\x91\x24\x79\x2f\x9d\x3b\x76\x56\x4b\x41\xbc\xaa\xe9\x42\xfe\x9e\xa7\xb9\xfa\x49\x6e\xc5\xcf\x0d\x0a\x90\xe4\x70\x5e\x71\x50\x2a\x1b\x30\x2f\x85\x0f\x91\x65\xd0\xaf\x08\x1b\x1c\x4e\x18\x13\xfc\xe9\xa6\x24\x8b\x05\x2d\x81\xb7\x1f\xa5\x3c\xfc\xdb\xaf\x3c\x25\x9c\x80\xc7\x9b\x47\x93\x68\x5b\x73\xd1\xf1\x46\x57\x8c\xb7\x3e\x58\x1f\x8c\xdf\x02\x83\xef\x4c\x38\xa2\x43\x35\x37\x13\xf5\xcb\x53\x80\x44\x53\xa4\x0f\x58\xbd\x07\x5f\x39\x11\x7f\x85\xe0\x5d\x16\x59\x46\x23\xcf\x06\x48\x41\x71\x6b\xf3\x60\x0c\xab\x05\x5d\xaf\xed\x92\x44\x69\xd1\x94\x4c\x5a\x03\x30\x01\xeb\x7a\x8c\x9f\x5b\x9f\x29\x57\x53\xcc\xf0\x70\x08\x24\xcc\x16\xc5\x36\x0a\xd7\x6b\xc6\x1d\x28\x14\xd0\xaf\xf1\x0a\x9b\x46\x38\x1c\xda\x36\xc8\x70\xd0\xc2\x15\x7f\xb1\x3d\xb6\x95\x81\x46\xcb\xa7\x10\x88\x44\x2c\x10\xbf\x62\x41\xca\x8a\x1e\x67\x05\xa9\x1d\xf9\xfa\x7a\x3d\x46\xe1\x0e\x0e\xd6\xeb\x10\x7c\x68\x44\x39\xeb\x50\x41\xb6\xf7\x42\x79\x2d\x42\x54\x42\x19\x68\xe0\x9b\x26\xc2\xe3\x85\xef\x5e\x31\xfe\x26\x34\x95\xbe\xc0\xc0\x35\x69\xcf\x1c\x5e\xbb\x8d\x63\x36\xea\x36\x91\xbe\xc5\x6a\x5a\x3b\xbd\xbd\x92\xe5\x0d\x2c\x51\x84\x77\x76\xda\xad\xf4\xfd\xf8\x4b\xdc\xbe\x09\x0c\x93\x08\xd2\x9a\x5d\x2d\x83\x79\x5a\xdb\xdc\xe1\xc4\x06\x85\xab\xad\xdf\x2e\xb5\xc3\x22\x2b\x4a\x59\xcf\xe4\x4a\xfd\x37\xe3\x74\xda\xcf\xfb\x59\x11\x92\x4c\x96\xce\x8b\xbc\x9e\xca\x07\xbd\xf9\x0d\xa5\x33\x46\x6d\xe4\x9c\xfb\xf2\xa7\x39\x53\x2d\xef\xe6\xa6\x11\x47\xcf\x00\x13\xc8\x22\xe1\xdb\x36\x77\x9b\x72\xf8\x33\xb6\x6d\xd7\xef\xce\x53\xbb\xe4\x21\x4d\xda\x90\x03\xdd\x1a\x1b\x37\x9a\x41\xf6\x09\x64\x24\x15\x5c\xca\x8b\x99\x18\x4c\x37\x5f\x64\xb2\x5e\x77\x43\x96\x91\xe1\x50\xa2\xba\x56\xb8\x5e\x3b\xc1\x1e\x26\x1a\xa3\x18\x68\x4b\x7b\x2a\x96\x96\xe0\x97\xce\x9d\xca\x3a\xa4\xa8\x25\xf0\x0f\x01\x7e\x1b\xcb\x30\xa2\x25\xcd\x5d\x97\xa8\xdf\xcd\xbd\x1c\xcd\xf6\xf7\x2e\x6e\xf2\x48\x10\x4c\x46\xc5\x82\x15\x43\xe8\xc5\xc0\xbd\x0b\x80\x6d\x52\xd1\x1a\xc6\x3e\xfd\x3e\x94\xf9\xd4\xe8\xde\x9e\x1b\x5c\xda\xdf\xd8\x7b\xe1\x25\xbd\x02\x46\x87\xdf\x7a\x19\xfb\xe1\xf7\x44\xb6\x0a\xf7\xf6\x20\xfc\x6f\x8b\x8b\x62\xaf\x91\xcb\xf0\x4a\x6c\x65\x04\xbf\x2b\x9a\xd1\xb0\xa6\x11\x8f\x28\xe9\x18\x65\x98\xba\x88\x0e\x87\x91\x2c\x17\xcb\x76\x2e\xab\x77\xc6\x22\x5c\x60\xc8\x53\xc0\x0b\x23\x22\x1b\x11\x1f\x37\xd1\xc7\x0d\xb7\x82\x2e\xa9\xe8\x9e\xc7\x9a\x85\xe7\xaa\x81\xe7\xf3\xbe\x68\x6f\x5f\xf2\x12\x96\xf4\xe0\x5b\xaf\x79\xcb\xb4\x22\x41\x46\x23\xb6\x8e\x98\x95\xb8\x9b\xc6\xc7\xcf\x09\x74\xf0\xae\x4e\x6c\xcf\xfa\x0e\xd1\xad\x87\xc9\xaf\xad\xa3\xce\xa4\x2d\xe8\x86\x54\xa7\xcb\xac\x4e\x17\x19\xf5\x18\xad\x98\x8b\x07\xcd\xe1\xe0\x7d\xac\xa7\xb6\x08\x46\x11\xc9\x13\x5a\x16\xcb\x2a\x5b\x9d\xd3\xfa\x24\xcf\x69\xf9\xd3\xc5\xe9\xdb\xc9\x6b\xc7\xfe\xee\xb0\x73\xe1\x1a\x74\x20\x01\xba\xbb\xd6\xcf\xdf\xbe\x33\x59\xe1\xa8\x6d\xef\xdd\x77\x1e\xeb\xc7\xeb\x3f\xb6\xf0\x13\xa1\x50\x3c\xca\x88\xc2\xc6\x27\xab\xa8\x47\x25\xcd\x85\xd8\x1a\x28\x27\x6e\x08\x30\xf5\x5d\x13\xa8\x01\xbd\x2c\x4b\xb2\x1a\xa5\x15\xfc\xe5\x8c\xdb\xe1\x0f\x38\x10\x08\xa2\x69\x48\xbf\x7b\x62\x43\x32\xf5\xcb\xf1\x95\x8b\x00\xb1\x54\x3c\x30\x3e\x0c\xdb\x76\xd9\xd0\xdc\xaf\x2c\x95\x6d\xef\x45\xfa\x72\x7f\xe8\x5d\x6e\x75\xb2\x3a\x1c\x87\xd9\xe1\x26\x49\x9f\x76\x60\x85\xcd\xe1\x71\xff\xa9\x13\xba\xd2\xf8\xfe\xb5\x96\xad\xc3\xa9\x59\x8c\xf3\x58\x0f\x1e\x50\x6b\x17\x6b\x21\xa2\xd4\x3d\x4b\xaa\x0d\x58\x78\x19\x5f\xc4\xf8\x6e\x5a\xcf\x33\xcf\x9e\xd6\xf5\xc2\x3b\x38\xb8\xb9\xb9\x19\xdd\x3c\x19\x15\x65\x72\x70\xf8\xdd\x77\xdf\x1d\xdc\xb2\x5a\x1b\xcd\x49\x3d\xdd\xda\xea\xc5\xc1\x29\xa9\xa7\xf0\xcf\xe9\x5b\x1b\x55\xd7\x49\x5f\xc3\xc7\xe3\xf1\xf8\xa0\xba\x4e\x6c\x3d\xb0\xc0\x47\xf8\x16\xa9\xc9\x54\x27\xe2\x75\x62\x0b\xfd\xe4\x7d\x80\xc4\xf1\xc8\xc6\x76\x4f\xf3\xce\x00\x5b\x1a\xd0\xfb\xbf\x5c\xdb\x9f\xbf\xc6\x86\xa3\x5a\x73\x8e\xdc\x0b\x00\x74\x9f\x1f\x19\xe1\xbe\x77\x52\x78\x2c\x00\x3b\x2e\x4a\x9a\x26\xf9\x99\x52\x01\x06\x93\xfb\xc1\x7b\x64\x03\x3a\x8b\xdf\xd4\x6d\xac\x7f\xb6\xf4\x30\xfc\x23\x9b\xe4\x51\xcd\xc9\x76\x7a\xfe\x72\xb1\x18\x0e\xe1\xcf\x88\xde\xd2\xf0\x63\x5e\x91\x98\xbe\x65\xcc\xc3\xb1\x00\xd1\xe8\x0e\x55\x36\xa7\x7b\xdb\x3b\x5d\x5d\x0b\x51\xaf\x6e\xdc\x8d\x47\x36\x8e\x69\xc9\x62\x54\x1f\x8e\x75\x90\x32\x3f\x7e\x38\xd9\xc1\xf8\x22\x1e\x55\xd7\xc9\x7a\x6d\xa7\x92\xea\xd9\x69\x6e\x11\x97\x8c\x54\x01\xe6\x01\x90\xee\x7e\x8b\xf1\x6f\xf1\x7a\x1d\x15\xe1\x72\x4e\xf3\x5a\xc4\xa1\x3e\xe2\x36\x03\xc7\x8e\xd2\x6b\xdb\xf5\x7f\x8b\xb5\x17\xed\x3f\x6e\x9f\x84\xd5\x75\xf2\xc7\xed\x13\x6a\xef\x05\x7b\xf0\x7c\x20\x0b\xe0\x74\x0a\xf0\x6f\x31\xbf\x3d\x02\xcc\x84\x4f\xf4\x07\x97\xe8\xf1\xc0\x1c\xbd\x8e\xdb\x8d\x64\x98\x6f\xd5\x5c\x8b\x4b\xe6\xe8\x75\xee\x66\xe3\xa2\xff\x8e\xf1\xc1\xa5\xbd\x3b\xfc\xfe\x87\xab\x03\x6d\x67\xfc\x1e\xab\xe9\x09\x74\x5d\xb8\x82\x9b\xc6\x8e\xf0\x24\xe2\x97\x66\x5e\xf1\x70\xe5\x4f\xb8\xaf\x5f\x11\xd1\x0b\xce\x63\xc2\x6f\x41\x52\xe4\x09\xb9\x31\xe8\x06\x0e\x36\x03\x4d\x9b\x3b\x1c\x3a\xb6\x56\xcb\x66\x5e\xcd\xae\xfc\x21\xe6\x77\xbd\x76\x7e\x8f\x71\x67\x3d\xb9\x37\xa3\x1a\x03\x31\x86\xa0\x22\xc6\x06\x5c\xf2\xfd\x7a\xfa\xf6\x00\x88\x3c\x7f\x51\xfc\xe6\xf3\xf1\xdf\x31\xa0\xa1\xd0\xd2\x28\xbd\x8d\x6d\x23\x8a\x62\x3c\x16\x8c\x46\xc8\x53\x9f\xfa\xf4\xfb\xc0\x60\x37\x14\x33\x1e\x4e\x49\xf9\xaa\x88\xe8\xcb\xda\xa1\xae\xcc\x97\xf4\xd4\x0b\x19\xa6\x3c\x7e\xf6\x79\x59\xd4\xbe\x6d\x5c\x59\x78\x21\xeb\xc8\x7c\xd1\xaa\xfa\x4e\x56\xfd\x8f\xdb\xc7\xcf\xcd\xba\x67\x63\x59\x97\xb5\x00\x3e\x7b\x2c\x6b\x92\xa6\x46\x52\xa9\x26\xd4\xab\x60\xc1\xa2\x3d\x1c\x8c\xaa\x65\xc0\xd9\x57\x27\x46\xd4\x75\xfd\x18\xd3\xbd\x43\x3f\xda\xc3\xe1\x26\xc0\xd0\x72\x12\xed\xb5\x9b\x79\xd1\x66\xf3\xcf\x58\xe4\x75\x73\x5d\xae\xed\xfc\x26\xc6\xbf\xc7\x88\x24\xf8\x8e\x48\xdd\xec\x49\x4d\xb9\x3d\xee\x55\xb1\xcc\x6b\x6f\x67\x8c\x82\xa2\x8c\x68\x79\x32\x27\x09\x3d\x5b\xd6\x15\x6d\x17\x9e\x67\x69\x48\x5b\x65\xbf\xa5\x51\x3d\xe5\x65\xb7\xc7\x19\xbd\xd5\x7e\xbe\x29\x8b\xe5\x42\x3c\x9f\x95\x51\x9a\x93\x4c\x15\x85\x45\xb6\x9c\x37\x3d\xf3\xc7\x8a\xfd\x8c\x05\x90\x98\x43\xb8\x91\xbf\xa5\xc2\x4c\x3e\x9f\x4f\xcb\x34\x9f\xc9\xa7\x77\x34\x21\x7a\xed\x19\x1b\x20\x7b\x48\xca\x34\xfa\xc0\xa1\x88\x9f\x47\x79\xa4\x3d\x9d\x2f\x48\xae\x3f\xd6\xa4\xac\xe5\xf3\x2b\x18\x95\xf9\xa4\xbd\xcd\x0b\x74\x00\xa2\x44\xc2\x88\x8b\xbc\xfe\x8d\xa6\xc9\x14\x9e\xb2\x34\xa7\xaf\x32\x32\x5f\xc8\x87\x9f\x54\x55\xb1\x20\x61\x5a\xaf\xe0\xa7\x1c\x78\x51\x2e\xa6\x84\x4f\x49\x4d\x82\xf3\xf4\x0b\x7c\xdb\x4d\x1a\x15\x37\x50\xf8\xe5\x84\xe1\x3b\xfc\x2a\x8a\x39\x74\x97\x66\xd9\x59\x03\x69\x10\x67\x45\x11\x69\x05\x55\x5d\x2c\x8c\xc7\xb2\x98\xd1\xd7\xa4\x9a\x12\xc6\x8d\x99\x45\x45\x1c\x8b\xf5\xe7\x65\xa7\x69\x4d\xcb\x2c\x05\x0f\x01\x59\xd6\x81\x25\x71\x61\x83\x82\x04\x5f\xda\xbf\xd1\x60\x96\xd6\x36\xb2\xe7\x95\x8d\xec\xd3\xe2\x8b\x8d\xec\x33\xfb\xca\x17\xa6\xb4\x19\x5d\x55\x0e\x49\xdc\x6e\x4e\x5b\xe2\xde\x05\x49\x6f\xaa\xdb\x00\x07\x7b\x04\xb6\xf2\xcb\xda\x19\xbb\xa3\xba\xf8\xc8\x98\xa0\x57\xa4\xa2\x8e\xbb\x47\xb4\x9d\x70\xe8\xfa\x24\xb9\x0c\xae\x30\x49\x2e\xc9\x15\x18\x00\xb4\xc4\x85\x89\x14\xe7\xc8\xa8\xaa\x57\x59\x73\x93\x33\xb4\xd2\xdc\x82\x0c\xa3\x1d\xc1\x29\x54\x8e\x8b\xa0\x51\xe1\xf4\xe6\x2c\x76\xec\xfd\x7d\xdb\x95\x79\xfc\x44\x48\x8f\xe0\x32\xbc\xf2\xa9\xb8\x3b\x1a\xaf\xd7\x3d\x64\x90\x95\xda\x70\xb1\xd4\xb6\x3d\x2d\x13\xfd\x8e\xde\x42\xdc\x16\x25\x49\x7b\x30\xd4\x1d\x0e\x49\x72\x49\xaf\x26\x8e\x6d\xef\xc5\xee\xa8\x2e\xd3\xb9\xe3\x7a\xf1\x9e\xbd\xb8\xb5\x7d\x3b\xce\x0a\x02\xac\x85\x60\x6a\xc3\xaa\x02\x15\x8e\xed\xfa\x11\x57\xc8\x36\xdf\xc5\x68\x06\x93\xec\x30\xe5\xd6\xce\x28\x61\x52\xee\x9c\xe6\xcb\xb4\xa6\x73\x58\xcf\x3b\x52\x52\x02\x5b\x99\x54\x9c\x02\x94\x62\xdb\xb2\x3f\x74\x1e\x50\xd8\x15\x53\x28\x4d\xe7\x09\xfc\xc9\x17\x4b\xc0\x96\x19\x5d\x25\x34\x17\x58\x0f\x3b\x76\x4e\x6b\x80\xb6\x20\x25\x01\xd4\xe5\x16\x32\xc0\xf5\x92\x84\xd0\xe6\x06\xba\x30\x96\x8d\x26\x2a\x46\x06\xa3\x90\x6c\x61\x95\xa8\x11\x68\x89\x4b\x1f\x20\x5b\x1d\x3e\x79\x6e\x23\x82\x42\xc7\x55\xa9\x5e\xd0\x57\x5e\xeb\xe9\x8a\x41\xd2\xc2\xe7\xa2\xae\x55\xf7\x1e\x68\xf6\xa7\x4f\xc0\xdc\x31\x84\xdb\x3a\xd4\x46\x22\x7a\x76\x68\xbb\xcd\x18\x01\x6b\x87\x43\xd9\xe1\x8e\xd6\x21\x54\xc1\xc8\x1e\xdb\xc6\x07\x6a\x62\x50\x9c\xa8\x63\x7c\xff\x10\xce\xf1\x06\x9b\x6d\x69\x4f\xe9\x66\x5d\x0d\x46\x69\xe5\xb7\xf9\x78\x92\xe7\x05\x57\x91\xef\xdf\xce\x95\x3e\x0a\xd4\x59\xfb\x8b\xb2\x88\xd3\x4c\xe9\xa2\x18\x41\xdc\x8f\x49\xd8\x2d\xd8\xaf\xca\xb0\x5b\xb8\x2c\xd3\x6e\x21\x58\x80\xeb\x6e\x39\xe3\x2e\x95\x36\x2c\xad\xaa\x34\x4f\xf6\x93\x6c\xb5\x50\x62\x43\x37\x2a\xd2\x98\x23\x7c\x92\x30\x5e\x94\x2d\x06\x9a\x26\xf8\xc7\x51\x3d\x25\xf5\x07\x68\x51\x39\xb6\xad\x63\x60\xaa\x08\xc7\x77\x06\xf7\xb3\x5e\x1f\x1e\x1a\x05\x13\xe2\x91\x51\x71\x93\xd3\xf2\xb5\x60\xa6\x04\x37\xf3\x1a\xdc\x26\x02\xfc\x81\x5c\x06\x57\x8a\xec\x44\x78\xec\x47\x0d\xe7\x12\x31\xce\x45\x44\x53\xbc\x8c\xae\xfc\xb0\x6f\xfb\x87\x97\xf4\x6a\xbd\x76\xec\xba\x58\xfc\x36\xa5\x14\x84\x10\x3a\x59\x85\x8e\x7d\x03\x8f\xee\xe4\xa3\x56\x89\x44\x29\x22\xae\xc7\xda\xcc\x8b\x65\x45\xfb\x1b\x6a\x55\xac\xb5\x59\xf9\xfa\xec\xf4\x94\xd5\x9f\x87\x65\x91\xf1\x06\xac\x5a\x3c\xc2\x10\xaa\xc8\xd1\x8a\x90\x5d\x99\x4d\x8f\x8b\x70\x59\xd9\xfc\xde\x07\x7b\xfe\x31\x5b\x96\xfc\x45\x47\xbc\xc9\x5b\x20\x3b\xe6\x7f\x89\x8b\x44\x05\x34\x45\x76\x00\x7f\x88\x8b\xc2\x91\x28\xc4\x8c\x18\x8d\xe4\xab\x70\x89\x91\xb5\x7f\x45\xf2\x50\x4e\x8c\xc3\xbe\x3a\xe4\x05\x68\x67\xec\x0e\x87\x02\xa8\x68\x84\x54\xa5\x04\xcc\x2b\xf0\x40\x41\xcb\x8a\x8a\xea\xc0\xe0\xd9\x84\xc5\x8b\x64\x95\x82\xc4\x1e\x61\x54\x5f\xa2\xbe\xa5\xfc\xe8\x50\xf4\x25\xba\xa4\x57\xf0\xc6\x25\xbd\x12\x5a\x2a\x86\x02\x7f\x25\xf8\xae\x2e\x16\x2f\x83\xa2\xac\x3d\x9b\xb0\x3f\x36\xe2\xa3\x7b\x9f\x91\x95\xc7\x86\xbd\xc8\xc8\x4a\x2f\xbc\x98\x96\xc5\x32\x99\xaa\xba\x9a\x3f\x43\x93\xd7\x4b\xc1\xf5\x4d\x19\xc9\xf1\xec\x48\x3c\x87\xf0\x0c\x4d\x8e\xe6\x8b\x3a\xa5\x91\x67\x53\xfe\x83\x17\xe6\x61\xb9\x5a\xd4\x50\x2c\x7f\x8a\x8a\x88\x17\x46\xb2\x00\xae\x01\xda\x70\xed\x0e\x0a\xde\x82\x6d\xf0\x35\xa9\x89\x67\x73\x3b\x61\x44\x6a\xa2\x55\x9d\xd2\x9a\x44\x5a\xf5\x5c\x3c\xab\x26\x9c\xa5\x82\xda\x8a\xfd\x84\x8a\xf7\x64\x59\x51\xcf\x5e\xb0\x3f\xbc\x00\xe6\x43\x4d\x06\x7b\x4c\xf3\x84\x97\x30\x42\x06\x85\x65\x91\x94\xb4\xaa\x3c\x7b\x21\x7e\x41\xf1\x07\x52\x53\x39\x23\x25\xa9\xa9\x36\x1b\xe7\x94\xce\xd8\x07\x56\xf0\x57\x15\x01\xe4\x8a\xff\xe0\x85\x35\xe1\xd6\xa0\x8a\xff\xe0\x85\xcb\x8a\x49\x85\x9e\x5d\xf1\x1f\x50\x78\x91\xce\x45\xe2\x23\x0f\x54\xf5\xdc\x0b\x12\xaa\x7e\x65\x1c\xa4\x1a\xc9\x35\x3c\xc9\xb1\x0c\xd8\x36\x24\x69\x0d\x3d\xdf\xf0\x1f\xb6\x66\x5b\x9f\x69\xc9\x94\x43\x20\x50\x8d\x88\x38\x09\xbd\xb0\x45\x8f\x22\x8c\x71\x92\xc0\x2d\x60\x50\xd0\xb8\xa2\x64\xc2\x36\x6c\xba\xa8\xb9\x52\xc3\x21\x38\xec\x15\xb7\x11\xe9\x48\xdb\xf0\x1a\x93\xaf\xb9\xac\xad\x1e\x6d\xc4\x43\x51\x6e\x11\xa7\x5d\x8f\xe0\xfe\xb3\x66\xd2\xee\x9a\xa0\xbb\xb4\xf2\x58\xd5\xc6\xf5\x3a\x95\x0c\x50\xab\xf0\xdd\x39\x04\x27\xed\x51\xbf\x67\x89\xae\xe8\x11\x09\xe5\xd5\x74\x05\x5e\x60\x4e\x97\xab\xe5\xbe\x7a\x57\x44\xd4\x21\xfa\x79\xba\xd0\xa6\x9e\xd3\xed\x38\xe1\x31\x4f\xa5\xfc\x29\x4f\xcb\x34\x2e\xb5\x73\x4a\x1c\xdf\x82\xc6\x32\x4c\xb7\x11\x60\x39\xa3\x1d\x82\x97\x0c\x75\x21\xd2\xbe\x4e\x23\x5a\xc8\xd7\xc9\x32\x4a\x0b\x1b\xc2\x62\xc7\x8c\x71\xfd\x2b\x71\xff\xea\xb0\x8a\x31\x10\x98\x18\xfd\x95\x5c\xc6\x8c\xc0\xf8\x6d\x90\x9c\xf9\x92\x83\x38\xe2\xdb\x56\x6e\xdf\x9e\xf6\xe9\x3c\x91\x03\x48\x99\x08\xb8\xfd\xcd\xfe\xcf\x6a\xc3\x63\x07\xba\x84\x01\x97\x2d\x6c\x24\x0c\x64\x0d\x8c\x73\x6e\x3e\x43\xd2\x8e\xd6\x07\x27\xa2\x35\x49\xb3\x4a\x82\xba\x28\x92\x24\x63\xc4\xb8\x16\x3f\xfa\x3e\x85\xf1\xa8\xb6\x07\x86\xe5\x90\x55\xff\x24\x7e\x71\x10\x27\xf9\x35\xc9\x52\x36\xf8\x54\xfe\x22\xae\x3f\x48\x13\x27\x42\xb6\x24\xa1\xb6\x11\xd6\xc0\xe6\x66\x1c\xdb\x8b\xf1\xa9\x80\x65\xcc\x35\x98\x21\x6c\xef\x4c\xf5\x08\x2a\xfd\xd0\x54\xe9\x6f\xee\x1f\xc0\xbd\xfd\xd7\xf4\xb6\x66\xdc\xba\xed\xfd\x43\xf5\xf1\xfe\x01\x5f\xb5\x05\xa8\xe4\x98\x62\x1c\x6e\x28\xc3\xe9\x18\x4d\xc5\xed\xf7\x04\xc7\x88\xc7\xe0\x9e\x31\xe4\x83\x58\x65\x1d\xec\x9b\xb9\x32\x1a\x55\x72\x39\xbb\xf2\x6d\xe0\x4e\xd9\x36\x9f\x4d\x40\x0a\x9b\x32\x70\x9e\xbd\x85\xff\xe5\x0d\x9d\x29\x9e\x4e\xa6\x23\xce\x2f\x7b\x46\x3c\xaa\xe9\x70\x08\xba\x8e\xa9\xeb\x7a\xb6\x64\xcb\xf9\x5b\x5d\x92\x32\x9d\x38\xcd\xf4\x70\xdb\x11\x18\x1d\xa7\xee\x70\xf8\x0d\x87\xe2\x75\x55\x53\x53\x51\x39\xb0\xed\x3d\xd6\xa0\x5a\x2e\x16\xec\xdc\x10\x9a\xb3\xa3\x28\x05\x2f\xe8\xdf\x48\x99\x0b\x43\xe3\x6c\x38\x54\xad\x54\x7c\xbc\x56\x3d\x59\xd6\x05\xe7\x73\x78\x81\xf3\x0f\xd2\x9d\xba\x89\xfa\x48\x58\x9d\x99\xeb\xd1\x09\xb8\xbe\xcc\xd8\x50\x55\xe5\x91\x2c\x52\x21\xd4\x1a\x72\xc3\x11\xfc\x47\xc8\xd2\xf2\x4b\x0f\x42\x36\xe8\xc2\xdb\x9c\xf7\xb4\x91\x28\x2d\xcc\x24\xd2\x2e\xd2\xf2\xaa\xb1\xa1\xd8\x46\xa2\xbe\x1f\xef\x89\xb2\x89\xe1\x9d\x9d\x50\x3d\xf8\x81\x04\x2b\xed\x26\x13\x30\x8f\xea\x6d\xf8\x85\x71\x35\x08\xd3\xae\xd2\x6d\x6d\xb6\x80\x34\xf8\x26\x46\xf7\xf9\xd8\xc6\xa3\x22\x7f\x95\xa5\xe1\x0c\x8c\x28\x45\x1e\xb2\xdf\x78\xf0\xa3\x61\x32\xfc\xac\x88\x3d\xa2\x32\xfc\x9d\xee\xab\xdd\x9e\xfc\x50\x51\x95\x88\xff\x8a\xd8\x9e\xbc\xbc\xea\x9d\xe3\x50\x91\x8d\x88\xff\xea\x6b\x2c\x67\x33\xdc\x46\x3d\x22\x5e\x11\x75\x2a\x3a\xa0\x9a\xf5\x0f\x15\x99\x88\xf8\x2f\xb3\xe7\xee\xb4\x35\x42\x67\xd8\x4c\x5b\x7f\x8e\xa2\xbe\x59\xfd\xd1\xe5\x04\x25\x6a\x08\x0a\x9a\x89\x00\xf3\x40\x55\x12\x46\x55\xc0\x85\x65\xa7\xc3\x35\x27\x4c\x00\xea\x2b\x14\xe8\x71\x99\xc0\x8d\xfb\x86\xdc\x24\xae\x22\x54\x01\x54\xa3\xc0\xed\xa8\x78\x66\x70\xb9\x7f\xbd\x76\x08\xbe\xdb\xb8\x88\x5c\xce\xae\xf0\xc0\x16\x09\xbe\xb6\xd2\x28\x1e\x94\xa5\xa1\x3e\xe2\xf9\xeb\x74\x22\xf9\x0a\x9d\x48\xda\x74\x22\xe9\xa5\x13\x89\x3b\x89\xd7\x6b\x87\xad\x95\xeb\x39\x31\x8e\xd7\xeb\xcb\x2b\x97\x27\x20\x4b\xf8\x95\x2b\xb7\x99\xd0\x48\xd2\xe3\xe8\x32\xb9\x12\xc6\x7a\x30\x66\x5f\x26\x57\xfa\x55\xf2\xbe\xc9\x9d\x0a\x73\xba\xa0\x3c\x4a\xd3\xe2\xb6\xe7\x9a\xdb\x33\x9a\x19\x77\x77\x7a\xe6\x1a\x12\x3a\x4d\xfb\xca\xdb\x6b\x60\x8b\xbb\x3a\x00\x6c\xea\xf6\xbc\x33\x1c\x06\x97\xb3\x2b\x46\xcb\x2f\x67\x57\xdd\x45\x64\xa5\x32\x4a\x2b\x9b\x2a\x39\x5d\x28\x96\xd3\x44\x5c\x17\x11\x3c\xbd\x7f\xa5\x31\xc6\x83\xa4\xff\x38\x0a\x70\x30\x09\xb6\x1d\x51\x01\x1b\x18\xc4\x77\x33\xd7\x06\x4e\x94\xd6\xc1\x95\x4c\x02\x1e\x0e\xa9\xeb\xb9\x32\xed\xf3\x5c\x99\xc2\xb7\xf4\xc0\x7d\xc8\x49\xf5\x00\x0c\xec\x47\x38\x47\x3f\x99\x28\x4a\x5c\x14\xaf\xd7\x62\xe0\x7c\x6a\x7b\x50\x91\x1d\x50\xa4\x33\x0d\x02\x6f\x34\x2e\x3d\xd6\x88\x6d\x69\x10\xdb\x38\xe1\x79\xf0\x23\x0c\xbf\xa8\xab\x34\x28\x60\x09\x6a\x34\x28\xf1\x1e\x7e\xac\x2e\x8f\x31\xbe\x77\xc6\xfe\xec\x1d\xea\x1c\x48\xc2\x39\x90\xd9\x57\x39\x90\x64\xf2\x4f\x7e\x35\xb8\xbd\x52\xdf\x88\xe2\x48\x1c\xd4\x33\x7e\x3a\x27\xac\xac\xeb\xbc\x99\xc8\xc3\x6b\x36\x39\x52\xcd\xc0\xf3\xb4\x89\x7d\x1a\xb6\xce\x0e\xf0\x05\xa4\xae\xff\xaa\x9d\x66\x4d\x23\xdc\x1f\x44\x9b\xfe\xf3\x76\xbb\xa3\x00\x56\xa8\xdb\x6e\xa5\xf9\xb1\xa0\x7b\xea\xf0\xce\x0e\xd5\x0e\x5c\x4c\x85\xcb\x88\x24\x29\xe2\x50\xd6\xdb\xc0\x11\xce\xb6\x83\x5e\xac\x28\xca\x80\x1a\x87\x76\x0f\x00\xda\x39\xd5\xbd\xbe\x46\xf2\xe7\xe4\xf2\xca\xb3\x6d\xd6\xa9\x71\x82\x57\x06\x52\xfd\x3b\x22\xda\x43\x44\x33\x40\xcf\x87\x8b\x67\x7f\x47\x34\xfb\x4f\x8a\x65\xff\x09\x91\xec\x6f\x8a\x63\xf7\x88\x62\x5f\x11\x55\xe8\x56\xf9\xa7\x2d\x61\x0d\xfe\x65\x48\x1d\x49\x0a\xdd\x03\x0a\xb5\x41\x71\xe6\x26\x04\xe6\x26\x6a\x98\x1a\x20\x49\x9c\xb1\xe9\xe5\x5f\x9c\x98\x73\x27\x2d\x4a\xd3\x15\x66\xe2\x89\x61\xde\xe7\x79\x74\x9c\x08\x5f\x36\x6f\xa2\xf8\xaa\x4f\xa0\x89\x19\xeb\x6e\xbe\x6a\xdb\x7b\xdd\xb7\x59\xe1\x95\xeb\xf5\xd1\x7f\xc9\x67\xc5\x8a\xfe\xf7\x68\x3a\xfe\x13\xa2\x87\xe2\x74\x0d\x26\xf9\xeb\x8c\xbc\xc6\x91\x0e\x4c\x9e\xb3\xb9\xaf\x2e\xa9\x41\x6d\x68\x82\x2c\xcd\x91\x81\xb1\x3b\x5c\x0b\xbb\x4c\xda\x37\x00\x0d\x35\x93\x37\x4b\x90\xa9\x1f\xf2\xb2\x04\x55\xec\x1c\x01\x7a\x2b\xa6\x2e\xa5\x95\xb7\x48\x50\x94\xc6\xb1\x56\xf2\x39\x11\xf7\xa0\xb5\xb2\x92\xb7\x12\xd1\xda\x23\xad\xa6\x32\x6b\x58\x7f\x5e\x9d\xa0\x1b\x52\xe6\xc7\x45\xf9\x31\x9f\xf3\xdb\xab\x17\xad\x3c\x29\x1b\xd9\x02\xa2\x53\xd0\xa8\x09\x9c\x2f\x3f\xe1\x41\x8d\xb7\x82\x3d\x81\x4c\x7b\xb2\x29\x8d\xee\x83\xda\x6e\xdb\x05\x5a\xd2\xaa\x2e\x4a\xb8\x18\xce\x7d\xec\xdb\xd1\xe5\xb9\x19\x70\x0b\xca\xfd\x2c\x11\x09\x87\xdc\x69\x99\x71\xa7\xca\x1d\x3f\x34\x2e\x3b\x0b\x36\x35\x84\x3c\x22\x0b\x52\xd2\x1c\x96\xcf\x77\xe1\x8a\xb9\x56\x10\xe2\x70\xf4\x79\x49\xcb\x15\x77\x46\x2d\xca\x97\x59\xe6\xf0\x1e\x2f\x59\x27\x7f\xdc\x3e\x89\xec\xbd\x9f\xcf\xcf\xde\x8d\xf8\x5e\x4d\xe3\x95\x03\x7e\x8b\x7b\xbb\x57\x97\xac\x4b\x68\xc1\x87\x71\xb5\xeb\x0a\x17\xa4\xb1\x1f\x34\x8e\xbd\x81\xb4\xfb\x44\x38\xbc\x0c\xae\x80\x0f\xe7\xd7\x00\xa3\x11\x23\xc9\x60\x62\x62\x3f\xa4\x96\xb1\x0a\x9c\xc8\xf5\xa9\xee\x38\x39\xb6\x5d\xff\xe7\xd8\x01\x4f\xac\xcd\xe6\x1e\x8e\x61\xcb\x4e\x53\x92\x78\xe3\xcd\xb9\x45\x14\xdf\x6c\x36\xae\x9f\x87\x23\x7e\xc3\x17\x2e\xd8\x36\x0b\xc6\xe3\xb5\x88\xbb\xe0\xce\x52\x48\x78\x3f\x25\xfc\x7e\xe3\x49\x22\x28\xa2\xba\xf3\x90\x34\x6e\x6c\x3b\xce\x0e\x59\xaf\x0f\x77\x74\x7b\xda\x70\xf8\x5d\xeb\xf9\xb0\xdd\xc0\x79\xb1\x63\x9a\xe4\x6c\x0b\x2e\x78\xee\x43\x1a\xdb\xfd\x45\x91\xe6\xf5\xbe\xbc\xb3\x6e\xd9\xaa\x31\xf7\xbc\x34\x1c\xf9\x13\x71\x3b\x7b\xf2\x5d\xcb\xa8\xd7\x76\x8d\xf2\x74\x45\xb6\x91\x49\xa0\xe7\x1b\xd6\xeb\x1d\x20\xa5\x9a\xca\x24\x22\x35\xd9\x87\x51\x96\x45\x51\xdb\x6c\x14\x6c\x9a\x7e\xc7\x79\xec\xdc\x75\x73\x27\xf5\x26\x96\x92\xe0\xdb\x04\xf8\x3b\x11\xea\xf2\xd0\x23\xd8\x21\xb8\x33\x76\x77\x62\x7a\xe4\x79\xbf\xf2\x6b\x23\xc8\xee\x28\xff\x02\xfc\x02\xbc\x14\x89\xb6\x21\x3c\x82\x08\x0e\x0c\x08\x5c\x1e\x04\x97\xe0\x9a\x24\x70\xcd\x8c\x60\xe1\x50\xa9\x22\x93\x40\x76\xa6\x76\xae\xa8\x56\xdc\x0b\xd1\x56\xbe\x8a\x3a\x41\x39\xfa\xae\x6e\x13\x95\xe5\xa2\x89\x66\xa1\x11\x95\x9f\x12\xbc\xe0\x29\xea\x08\x8e\x88\x48\x51\x1f\x39\x84\x47\x35\x15\xe8\xcf\xf3\x58\x94\x35\x77\x44\xe4\x33\x7c\x07\x16\x27\xb8\x43\xa6\x37\x41\x34\x8f\xf4\xc2\xa3\x3c\xda\xf0\xcb\x2c\x2a\x9c\x8a\xb8\x49\x9b\x50\xe1\xc0\x9e\x16\xf9\x70\xd8\x53\xe8\xb8\x70\xd7\x3a\xe4\xb1\xbd\xc2\x51\xc9\x38\x08\xf0\x8d\x72\xef\xd8\x76\x24\x79\x38\x2d\x4a\xa0\x42\x82\x38\x88\xa2\x33\xf0\xd2\x41\x14\x87\x23\xb0\x95\x2a\x42\x05\x4f\xbc\x16\xe2\xa7\x34\x96\x0d\x44\xd5\x4f\x11\x2a\xf3\x96\x75\x92\xeb\xc9\x30\x85\x3c\x85\x12\xbc\x7f\x88\x66\xec\x9f\x29\x1e\xa3\x12\x8f\x51\x8e\x89\xc8\x0c\xe3\x07\x2a\x9b\xb0\x64\x6b\x96\x90\x5a\x98\xeb\x55\xc7\x3c\x9c\xd5\x93\x1d\x8c\x73\x6d\x03\x38\x09\x8e\xf7\x22\xd7\x67\xad\x28\x6f\x15\xf6\xb4\x9a\xe1\x78\x2f\x74\xfd\x27\x58\x2f\x67\xbc\xd1\x9e\x78\x86\x3d\x2b\xa8\xa6\x1e\xff\xd0\x59\xe2\xdc\x30\x2d\x71\x3c\x5e\xe1\xdc\xcf\xf1\x72\x23\x47\xcc\x5e\x68\xd2\x48\x5a\x81\xbf\xe2\x81\xb4\xf7\xf6\xa6\x98\x87\xe1\x4a\x70\xec\x42\x29\x65\xa5\xa5\x70\xa4\x99\xb1\xd2\x26\xb8\x1f\xf4\x06\x01\x4f\x78\x7c\x76\xd9\x5d\x8e\x57\xac\x4b\x6d\xb3\x6c\x58\xef\x01\x06\x5f\x8b\x64\xbd\x86\xbf\x33\x1e\x2c\x61\x20\xf0\x2b\x01\x84\x9a\x89\xeb\xd1\x7c\x45\x36\x01\x9b\x4b\xd1\x60\x0c\x0d\xc6\x46\x03\xff\x24\xc1\x77\xb0\xd8\xfc\xc4\xf5\x08\x52\x08\xf9\x01\x6c\x88\xc1\xc6\xff\x1c\x39\x8c\x5a\xa3\x76\x94\x27\x7d\x77\xf0\x7d\x71\x92\xa0\x00\x36\x07\x02\x37\xd4\x06\x2e\x8f\xc1\x6f\x40\x86\x7b\x2a\x7c\xfd\xa6\xc4\xd9\xe6\x3b\x0a\xb7\x69\xf9\x4e\x0b\x41\x4b\x14\x60\x88\x42\x51\xd6\x88\xe0\x68\x44\xf3\x08\xa9\xf8\x24\x22\xe7\x80\x8b\x7a\x36\x23\xe3\x96\xcd\x52\x1c\xa0\xd0\xd8\x7d\x18\xae\xee\xcf\x53\x46\x43\xc4\x11\xa6\x30\x44\xde\x71\xeb\xd9\x7c\x0c\xfb\xfb\xf7\xa4\x70\xe9\xba\x3c\x0a\x1c\xf7\x4a\x1e\xd1\xa4\xe9\x46\x7e\x08\x75\x55\x32\x0e\x88\xbf\x48\xf3\x68\x42\x3c\xad\x19\xfb\x4a\xea\xfa\x3b\xc1\x88\xde\xd6\x34\x8f\x86\x43\xf2\xc3\x20\x82\x84\x18\x11\x9b\x59\x44\x30\x75\x7d\x8a\x8f\x23\x27\x6c\xec\x7e\xf0\xc4\x93\x13\xd1\xe1\x90\xb1\xe7\x87\x90\x10\xb1\xa1\x0e\xeb\x75\xa0\xd1\x06\x48\x6e\xc0\x36\x47\x53\xcc\x29\x00\x54\x70\x87\x3e\x56\xa5\x28\x05\x13\x19\xd4\x0b\x1a\xc5\x80\x72\xde\xde\x95\x3a\x94\x96\xe7\x35\x60\x80\xe3\xfa\xc9\xa8\xa2\x35\x2c\x87\xc3\xfb\x46\xb2\x27\xd7\x0f\xa4\x02\x24\xcb\xa0\x79\xe5\xb8\x3e\xf9\x21\x9a\x38\xc1\x88\x44\x11\x87\x90\xb8\x48\x4e\x8a\xc3\xc7\x82\x9a\xae\x3d\x07\xc0\x1f\xf5\xd4\x21\x03\x86\xbb\xd9\x04\xf8\x92\x7b\xd3\x10\x1c\xf2\x6c\xd5\x1a\x2b\x67\xba\xe6\x0c\x87\x01\x57\x3c\x35\x31\x67\x50\x46\x63\xa0\xf0\xe0\xa9\xf2\x96\xc6\x35\xaa\x8b\x85\x2a\xb8\x28\x16\x1b\xd7\x4f\x09\x44\x1e\x57\x17\xad\x02\xfd\xa2\x15\x01\x97\x3f\x44\x46\x02\xa6\x06\x0a\x93\x11\x03\xdf\xa9\xbb\x28\x16\x78\x40\x46\x75\xb1\xd8\x48\x76\xe8\x73\xe4\xfc\x94\xb8\xbe\xe0\x92\x36\x42\xa4\xd8\x92\x29\x8a\x2b\x2f\x08\xd6\xcc\xfe\x3e\xb9\x3c\xbb\xc2\xd4\x27\x97\x8b\xe0\x4a\xbf\x74\x86\xb8\x73\xfa\x89\xbc\x12\xcb\xb8\x15\xf3\xc8\x6d\xf9\xaf\xf3\xa8\x29\x24\x4b\xbf\x50\xfd\xa5\x92\xe6\x9d\x51\xb8\x77\x0b\x7d\x04\x5e\x87\x2b\x0f\x96\x75\x0d\xa6\x0d\xc3\x28\xd2\x23\xde\x35\x0c\x2a\x01\xeb\x90\xd2\x7d\xab\x93\x09\xc2\x1c\x76\xce\x7b\xe1\x4b\xd1\x37\x3d\xa2\xad\x61\xb2\xd9\xa0\xbe\x84\x75\xbd\x2c\x48\x33\x24\x6c\xdc\x26\xd4\xdd\x14\x1a\xbf\xc3\x1e\xb7\x76\xbd\xb6\x71\x0e\x1c\x7c\xdd\x3b\x50\x5e\x5e\xbb\xc7\x7f\xb0\x67\x2c\x5b\x1a\x0b\xbd\xb4\xfc\xf0\xd7\x74\x51\xa6\x45\x99\xd6\xe9\x17\x7a\xbe\x0c\xea\x92\xd2\xde\xaf\xdf\xd9\x09\x46\xd3\x34\x8a\x68\xbe\xd1\xa4\xdb\xad\xe8\x08\x51\x81\xb8\x2c\xcd\x11\x31\xd2\x10\x30\x2f\x6e\xbc\x45\x8c\xe4\x6d\x7a\xef\x4e\xcb\x10\x6f\x46\x16\xe2\xa4\xc8\x51\xb9\x8d\xef\x59\x5d\x8e\xe7\xd4\x2f\xcd\xe5\x6d\xe7\x96\x6f\xc1\xd7\x2f\x45\xd8\xb6\xec\xa6\xc9\x3a\xdf\x11\x33\xf5\xab\x0d\xa1\xdc\x4b\x0f\xdb\x44\xfd\xc9\xea\xf5\xd7\x06\x81\x7b\xf7\xa2\x2d\x66\x34\xd4\xcb\xc8\x69\xef\x04\x88\xb8\x5e\xb7\x17\xbd\x4d\xcf\xe8\x5b\x20\x42\xf5\x46\x27\x31\x7e\xe7\xe5\xbf\x31\x32\x48\x9e\xd9\xd3\x95\xe6\xf7\xd3\x99\x2e\xdd\x27\x28\x30\xdb\x1a\x29\xf8\x5b\x2f\xde\x37\x2a\x13\xa4\xd7\xe9\x63\x83\x54\x52\x4a\xef\xae\x9b\x78\xb1\x5f\x12\x69\x0b\x72\xc1\xa8\x2e\xde\x16\x37\xd2\xf3\x5c\xd5\x42\x20\x7f\xa3\x4a\x44\xc4\xda\xa0\xfe\x64\x8e\x6d\x4c\x10\x64\x07\x2e\x85\xad\xd7\x4f\x8c\x6e\x15\xa8\x6d\xc9\x1f\xcd\x04\xb4\x3c\xc1\xa7\xce\x9f\xfa\x64\x38\x6c\x4b\xcd\x66\x17\x90\xe5\xd3\x78\xc5\x10\xdb\xfa\xb2\x4a\xf6\x76\xaa\xdf\xaa\xfa\x77\xfa\x9c\xde\xb3\x38\x7c\xbb\xa3\x98\x91\x81\xb3\x2b\x1c\x8b\x53\x2f\x94\xaf\x2b\x25\x3f\x45\x91\xab\x40\xdd\x43\xc1\x04\x20\x05\x40\xe8\x05\x37\x28\x4a\xa3\x77\x45\x7d\xca\xa4\x25\xa9\xb2\x52\x98\xb9\x2d\x19\x68\xef\x5b\xdb\x1b\x0f\x78\x6b\xd1\xf0\x55\x13\xd4\x71\x3b\xe4\xad\x88\xdb\x34\x39\x4e\x73\x4d\x77\xf7\x20\xa8\x5b\x5e\xf9\xda\x67\x9a\xaf\x3d\xbc\xe5\x56\xb8\x1b\xb4\x2d\xbe\xad\xf7\x39\x46\x9d\xe8\xb6\xfc\xaa\x40\x19\xe2\xdf\x5b\x21\xfe\x34\xe7\xed\xb7\x86\xd5\xe7\xe7\xc4\x09\xf5\x98\x8c\x8f\xc7\x63\x5b\xb9\xdc\x89\xd8\x92\x1f\x8a\xa2\x09\x3a\x0c\xa9\x0c\xdd\xdf\x47\xad\x98\x95\xe0\x12\x05\xf6\x37\xb8\xba\x16\xe1\x68\xbd\xfe\x85\xc1\xe6\x59\x45\xc1\xed\x40\x85\x54\x8b\x45\x5a\x2b\x71\x69\x30\x34\x88\x53\x2c\xdd\xaa\x7e\x1f\xb5\xc2\x82\x72\x41\x60\xcb\xb8\x70\xe2\xff\xde\x89\x5a\xa8\xdf\xd0\xec\x1b\x72\x02\x43\xde\x28\xb5\xcc\xef\xa3\xde\x70\x85\x4e\xac\x5d\x49\x3e\x4d\xf4\xbb\xd3\x8f\xbf\x27\x65\x02\x32\x41\x25\x18\xe1\xe1\x90\x7f\x25\xdb\xdd\xb2\xea\xf2\xf1\xd5\x44\x7f\xe0\x3a\xb2\x9f\x13\x27\xe8\xce\xbd\x18\xca\x7b\x0a\xcb\xc4\x03\x8f\xea\x6a\xb9\x77\xa2\xff\x7a\x9a\x56\xbd\x13\xd1\x9d\x37\xd8\xbf\xef\x12\x2d\x68\x65\x49\xf3\x88\x96\xad\xdb\x8c\xdd\x19\x22\x68\x5b\x2f\x2a\x7f\x93\x6f\xc0\x5d\xe6\xa0\x66\x34\x6e\xe5\x76\xc1\xc2\xbb\xf7\x43\x26\xae\x08\x50\x76\x96\x60\x61\x64\xe0\x01\x18\xbd\xd3\x04\x22\x19\xbe\x3e\x3b\x05\xfd\x5b\x2b\x4c\xb0\xb8\xa9\x6c\x04\x8f\x4c\x63\xc7\x94\x7d\x64\x2d\x51\xe9\x4b\xfb\x82\xa8\x82\xf7\x86\x42\x8c\x76\xb8\x45\x27\x70\x7b\x53\x0d\x12\x31\xb7\x3c\xf0\xef\x0b\xdb\x85\x95\x3d\x7c\x62\x23\xe3\xc2\x97\xdb\xd0\xe2\x0e\xfd\x15\x7d\xbe\x4d\xf8\x44\x41\x8e\x90\xb1\x60\x22\x18\xe8\x07\xbd\x70\x08\x2f\xa8\xe0\xa4\xfc\x4d\xc1\xe6\x9e\xe4\x75\x3f\x17\x26\x18\x58\x75\xdd\xbb\x51\x4a\xf4\xcd\x10\xfb\xc4\x27\x2f\x3a\xd1\x19\x14\x81\xd9\x39\x84\x23\x47\xe0\x84\x52\x83\xbf\xac\x3b\x0b\x07\x7a\x6f\xb9\x13\x06\xaf\x1d\xfb\xa9\xb6\x13\x48\x1f\x96\x4c\x9c\xfb\x77\xbb\x9c\x0b\x31\x21\x3b\x87\x48\x0f\x9a\xd7\xbb\x6f\x78\xd0\xd4\x8d\x2b\x72\x87\x6b\x93\xd7\xc6\x3f\x55\xd1\x0a\x9b\x5a\x87\x4d\x55\x3b\x5e\xea\xef\xf7\xc4\x4b\xfd\x5d\x8b\x97\xfa\xe9\xd3\xf9\xd1\xab\x0f\x47\x17\x9f\x4e\xde\x5d\x1c\x7d\x78\xf7\xf2\xed\xf9\xa7\xd7\x67\x9f\xde\x9d\x5d\x7c\xfa\x78\x7e\xf4\xe9\xec\xc3\xa7\xff\x3e\xfb\xf8\xe9\xb7\x93\xb7\x6f\x3f\xfd\x78\xf4\xe9\xf8\xe4\xc3\xd1\x6b\xef\x0e\xe2\x2f\xbe\xcf\x96\x49\x9a\xff\xb4\x0c\xbc\x3c\x40\x5a\xc9\x07\x9a\xa4\x55\x5d\xae\xbc\x8f\x44\x14\x97\xc5\x82\x24\xa4\x2e\xca\xca\x7b\x15\x20\x11\xaf\x56\x5a\x2c\xd4\x32\x79\x9f\x43\x5e\xf7\xfa\xec\x54\x15\x5e\x30\x21\xa9\x0e\x54\x85\x11\xf9\xd1\xab\xa3\xcd\xc6\x1f\xfc\x3e\xea\x06\x3b\x75\xee\xb6\x45\x1f\xfd\x1c\xa0\x60\x99\x47\x19\x6c\x4c\x6f\x8c\xae\x69\x59\x31\xa6\xd4\x3e\x7c\x36\x3a\x1c\x1d\xda\x02\xe7\x69\xf9\x9e\x84\x33\x92\x00\x6f\xe9\xd9\xdc\xa4\x11\x15\x73\x7b\xc3\x8f\x8b\xf7\x1d\xcb\xa4\xd4\xda\x9f\x25\x1b\x17\xfd\x23\xc1\xef\x93\xe1\xf0\x2c\x59\xaf\xdf\x27\xfe\xbc\x60\x27\xea\x88\xde\x2e\x8a\xb2\xae\xf0\x3f\x12\x3d\x4e\xa9\xf1\xe4\xfd\x23\xf1\x07\x83\xc1\xc1\xa3\x47\x8f\x0e\xac\x8d\x8b\x06\x07\x8f\xac\xa7\xe3\x67\xd6\xa3\x03\x51\xd6\xe0\x1c\x07\x8a\x2c\x01\x15\x59\x9f\x3e\xdd\xd0\x60\x41\xc2\xd9\xa7\x92\x7e\x5e\xa6\x25\xfd\xf4\xc9\xb5\xee\x06\x03\x7b\x59\x51\x8b\x49\xad\x61\x6d\x0b\xe0\x03\xeb\x91\xf5\xaa\x58\xac\xca\x34\x99\xd6\x96\x13\xba\xd6\xe3\xf1\xe1\x93\xfd\x05\x13\xe1\xf2\x1a\x59\xc7\x24\xa4\x41\x51\xcc\x90\x75\x92\x87\xa3\x81\x05\x2f\x5c\x4c\xd3\xca\xe2\xae\x11\x56\x58\x44\xd4\x4a\x2b\x2b\x4b\x43\x9a\x57\x34\xb2\x96\x6c\xd2\xac\x7a\x4a\xad\xd3\x93\x0b\x59\x6c\xc5\xc5\x32\x8f\xac\x34\x67\x15\x0c\xc4\xdb\x93\x57\x47\xef\xce\x8f\xac\x38\xcd\xa8\x28\xb6\xca\xa2\xa8\xad\x28\x2d\xc1\xba\xb7\xb2\x8a\xd8\xaa\xb5\x8e\x18\xf9\x90\x03\xf8\x2f\x46\xf2\x20\x7e\x54\x35\x60\x33\x02\xf4\x3a\x05\xa5\x9a\x85\xfb\x3e\xdf\x79\x3a\x7e\xee\xfa\xea\x8b\xff\x0b\x2e\x3e\x5a\x77\x8f\x36\x16\x57\x0a\x58\x17\x53\x2a\x7f\xd6\x85\x05\xa0\x47\xd0\x52\x90\x82\x3b\x71\x81\x74\x63\xfd\x36\xa5\xf5\x94\x96\x56\x51\x5a\x79\x51\xc3\xc0\xc5\x8b\x69\x65\x11\xeb\xf5\xd9\xa9\xc5\x04\x5c\x8b\x91\xfc\x11\x8c\xae\xb9\xbd\x56\xa9\xdb\x0b\xfc\x15\xb6\x2a\x96\x25\xba\xe0\xe3\x57\x35\xc3\xa1\x80\xab\x0e\x0f\x0b\x63\xeb\x89\x3f\xd8\x0c\x06\x26\x1a\x59\x58\x83\xec\x77\x70\xe6\xf9\xff\xc3\x99\x5e\x9c\xf9\x3f\x83\x0b\xbd\x68\xd0\x41\x01\x30\x2b\x15\xa1\x85\xe5\xfb\x13\xb9\xf8\xc6\x25\x18\x6b\xbd\x96\x0d\x3c\x15\x2e\xc2\x97\xef\x0b\xc7\xac\x94\xde\x58\x98\xd5\x8e\xf4\x92\xf5\xda\xe2\x5a\x76\xbf\xc1\xb8\x9d\x1d\x31\x08\x86\x6c\x8e\x74\x16\x6e\x5e\x1a\xf1\x0d\x85\xb1\xb5\x2b\x07\xbf\xab\x46\x66\xa5\x82\x90\xf6\xbd\xe3\x59\x02\x9a\x68\x0b\x30\xf8\xef\x5d\xd6\x99\x51\xab\x23\x38\xb6\x76\xb9\x12\x6f\x4b\x33\x46\x84\x79\x33\xae\x7d\xdb\x75\xdd\x6d\x3b\xa2\x7f\x37\xbc\xf8\x0f\xee\x86\x83\x47\xd6\x6f\x47\x3f\xbe\x7f\xf9\xea\x17\xeb\xd7\x97\x1f\xac\x93\x77\x3f\x1f\xbd\xba\x38\x39\x7b\x67\x3d\x3a\x68\x60\x2f\xca\x22\xa4\x55\xe5\x5a\x77\x07\x8f\x1e\x59\xff\x25\x91\x1b\xce\x31\xeb\x9a\x9f\x35\x0c\xbb\xd4\xc1\x32\x8a\xe8\x35\xcd\x8a\x05\xa8\xaa\xff\xaa\x04\xfa\xfe\xdf\xb5\xe1\x0e\x06\x83\xc1\x20\x8d\x2d\xf9\xf5\x23\x9a\x5f\x8f\xde\x9d\xbd\x3e\xfa\x74\xf4\xee\x57\x6b\x07\x63\xcb\x5e\x94\x45\xb4\xe4\x3c\x2c\xdf\x03\x1a\x13\x65\xdd\x0d\x76\x9b\x99\xde\xf5\x39\x81\xe7\x53\xd6\x4f\xdf\x0f\x45\x9c\x8d\x34\xbf\x26\x65\x4a\xf2\x6d\xed\x5e\x3c\x17\x0d\x6f\xb8\x93\xed\x36\x70\x87\x8f\x45\xbb\xa3\x5b\x1a\x2e\xb9\x85\xeb\x3a\x2d\x8b\x1c\xb6\x61\xff\x4b\x8f\x9f\x8c\xc5\x4b\x9f\x48\x55\xa5\x49\xbe\x6d\x0c\xcf\x44\x33\x3a\x5f\xd4\x2b\x19\xd3\xe7\x9b\xc3\x6d\x47\xd7\x77\x72\x28\x3a\xcb\xb3\x75\x0c\x72\x26\x12\x5a\xbf\x0c\xeb\xf4\x5a\xfa\x17\x6d\x7d\x41\x7e\x69\x35\x25\x59\x56\xdc\x1c\x7d\x5e\x92\x6c\xeb\xb4\x3c\x11\x8d\x45\xda\x8b\xfb\x8e\xdc\xc7\x4f\x64\x63\x65\xf1\xda\xda\xf2\xa9\x3e\x23\x67\x82\x66\x6c\x19\x82\xfc\x40\x20\xcc\x8c\xa5\x64\xa4\xa3\xda\xd6\xfc\x5b\x09\x7a\xba\x5a\x4c\x69\x4e\x6a\x7a\x5e\xaf\x32\x41\x47\xb6\xb0\x0a\x72\xc2\x43\x32\xa7\x59\xfa\xe5\xeb\x6f\xc0\x98\xe4\x81\xf2\xdb\xcb\x0f\xef\x4e\xde\xbd\xf1\xac\xd7\x67\xd6\xbb\xb3\x0b\x6b\x4e\xf2\x25\xc9\xb2\x95\x25\x5e\xe0\x1b\x46\x10\x2c\xb5\x53\xe1\xc0\x10\x29\x48\x61\xb9\xe2\xa2\xb4\xfe\x54\xe8\xec\x8c\x46\x23\xf7\x4f\x6b\x59\xf1\x74\xa3\x6c\x27\x82\x3f\x29\xdf\xda\xd5\xaa\xaa\xe9\x9c\xc1\x22\x79\x64\xdd\xa4\x59\x66\x7d\x2a\xf2\x6c\xf5\xc9\x0a\xa8\xec\x56\xbd\x17\x16\x65\x49\xab\x45\x01\xc9\x2a\xac\x80\x04\x34\xb3\x16\xa4\xaa\x60\x2c\x27\xb5\x45\xb2\x1b\xb2\xaa\x2c\xc8\x39\x56\x89\xcd\xbc\xc3\xf7\xde\xa4\xd9\x5f\x4e\x4c\xb2\x8a\x22\x6b\x57\x32\xe4\xd6\x0d\xa9\x2c\x7e\x7d\xd8\x0a\x40\xff\xcc\x37\xec\xc8\x3a\x25\x33\x6a\x55\xcb\x92\x5a\xab\x62\x09\x4d\x60\x1c\x1c\xe4\x82\x33\xd7\xf2\x15\x56\xcb\x86\x25\xa1\x8e\x76\x5d\xcb\xb3\x64\x40\xfc\xc1\xc1\x01\x3b\x9d\x2b\x6a\xa9\x48\xbd\x95\xc5\x6d\x2a\xec\x4b\x49\x96\x59\x59\x71\x43\x4b\x30\x67\xd5\x85\x05\x08\xcd\x66\x92\xbd\x08\x85\x69\x5e\xd1\x9c\x07\xb2\xb1\x04\x33\x00\xa4\xe5\xe8\xfc\xe8\xc3\xaf\x47\xaf\x3f\xbd\xff\x70\xf6\xfe\xdc\xc2\x40\x90\x54\x0c\x3f\xab\x2e\x97\x14\x0d\x2c\x6b\x8b\x79\x47\x6b\xa0\x87\x02\x6c\x97\xca\x48\xb8\xaa\x3c\xed\x02\xb8\xff\xca\x40\xb7\x5d\xfb\xd2\x80\xd6\x82\x21\x2d\x7f\x1c\x6c\xfc\x81\x16\x7c\x85\x0d\xe3\x94\x54\x33\x87\xbb\x99\x59\x41\x5a\xcf\x49\x35\x33\x98\x51\x5e\x67\x0d\x9b\x4a\x76\xe8\x8a\x07\x38\x71\xd9\xb4\xbd\x3e\x3b\x95\x4e\xa9\x27\x20\x79\x31\xf8\x7c\xf2\x60\x33\x58\xd6\x23\xeb\x94\x2c\x16\x6c\x45\xe3\xb2\x98\x5b\x79\x51\xce\xc1\xa8\x19\x21\xbe\xbb\xd8\xa2\x44\x96\x8c\xd8\x6c\x81\x37\x13\xac\x1c\xa3\x30\x71\x9a\x88\xcb\xf1\x56\x3d\x25\x35\x87\x57\x2d\x68\x98\xc6\x29\xad\xac\x69\x71\x03\x88\x44\xaa\xaa\x08\x53\xc8\xc4\xcb\xf0\x50\x01\xd3\x10\x23\x64\x87\x10\x8d\x18\xa3\x26\xa4\xba\x68\x04\xe0\x0e\x06\x96\x75\xfa\xf1\x9c\xcb\xb8\x6c\xf1\x8f\x3e\x5c\xfc\xb7\x67\x8d\x6f\x0f\xd9\x1c\xfe\xf4\xf2\xfc\xd3\x8f\x67\x67\x6f\x8f\x5e\xbe\xfb\xf4\xeb\xcb\xb7\x1f\x8f\x58\xcd\x53\x59\xf3\xee\xe3\xe9\xd1\x87\x93\x57\x4d\xcd\x0b\x59\xf3\xfe\xec\xfc\xe4\xe2\xe4\xd7\xa3\x6e\x93\xc3\xb1\xb5\xd6\x5b\x9e\xfd\x7a\xf4\xe1\xed\xd9\xcb\xd7\x47\xaf\xbb\x1d\x3d\x1e\xcb\x56\xe7\x17\x1f\x4e\xde\xbd\xe9\x19\xca\x18\x0d\xf4\xb9\xe6\x8b\x60\x55\xc5\x9c\xf2\x79\xe2\x73\x6d\xcd\xf2\xe2\x26\xa3\x51\x42\x2d\x12\x14\x4b\xce\xa8\xb2\xcd\xc5\x49\x4f\x4d\x66\xb4\x52\x33\x2e\xb8\x2d\x0e\xf0\x26\xad\xa7\xd0\x3a\x2e\xd8\x56\x62\xeb\xb8\x68\x5c\x61\xa1\x0d\x6f\xa8\x39\xc8\x4a\x9e\x6f\x2e\x16\xde\x58\x13\xb6\xc0\x6c\x7d\x8b\x9c\x72\xde\x81\xf2\xf7\x7b\x31\x29\x2c\x80\xc5\xac\x2b\x60\xb0\x97\x59\x36\xb2\x4e\x62\x46\x44\xca\x66\xff\x5b\x69\x95\xef\xd6\x70\x2f\x89\x96\x80\xf8\xd6\x23\x2b\xad\xad\x9b\x82\x15\x27\xb4\xb6\x6e\xca\xb4\xae\x69\xce\x7a\x95\xdf\xad\x0d\xfc\xf5\xd9\xe9\x4b\x23\x0a\x7b\x67\xfc\x9c\x4e\x35\x1d\xca\x4f\x10\xc0\x38\x18\xb3\x7a\x64\xbd\x34\x9e\x2b\x10\x0f\x24\xe6\x46\x8c\x8c\xc3\xeb\x8f\x1e\x29\x72\x25\x97\xb0\xd9\x21\x1c\xd2\x7d\x43\x5d\x90\xf0\x3f\x33\x5e\x80\x64\x7d\xfc\xf0\x76\x64\x39\x5f\x1f\x79\x5e\x34\x2f\x8d\x5c\x73\x80\xef\xb5\xd8\xeb\x95\x67\x55\xe9\x3c\xcd\x48\xc9\xba\xef\x8c\xde\x0a\x96\xfc\x94\xd3\x10\x24\xa5\xd5\xc8\x40\xa8\xd5\xbd\xf3\x77\xff\x64\x9d\x1a\x91\xe3\x2b\x4f\x43\x52\xa0\x27\xea\x40\x16\x5b\xc5\x92\xc6\x71\x6b\xce\xdf\x60\xe8\xc6\xa1\xfd\x09\xe4\xf0\x4f\x76\x4a\xab\x18\x8f\x08\x86\xd0\x7a\x47\x12\x9d\x65\x5e\x51\xbe\xcf\x24\xea\xeb\x83\x93\x32\x27\x5f\xb9\x8d\x15\x15\x73\xf9\xbd\xaf\xf8\x26\xe4\x07\x35\xfc\x24\x95\x15\xd1\x2a\x2c\xd3\x80\x46\x6c\xff\x5e\xd3\x86\x74\x71\x7d\x97\x36\xef\xfc\x75\xcf\x52\xd4\xde\xe9\xc0\xe6\x74\x9e\xcb\x8c\x3a\xd5\xee\xdb\x82\xbe\x6a\xa9\xcd\x1d\xee\x8e\x77\xa4\x55\xaf\xd7\xd6\xdd\xa6\x79\xb1\x1f\x6b\x7b\x81\x6c\x69\xfa\x35\x80\x0f\x83\xd5\x03\xa6\x85\x20\xdb\xe0\xb4\x9b\x09\x40\x00\x89\xe1\x2f\x38\x5f\xb2\x65\x06\x16\x31\xcd\xb5\xb9\x92\x73\x6d\x59\x3b\x3b\x1a\x8a\xb7\xee\x73\xc8\x77\xdd\x3e\x06\xcb\xde\xb2\xc6\xc0\x11\x7a\xd6\x7f\x17\xcb\x5d\xc6\x53\x96\x2b\xb6\xf7\xeb\x42\xa0\x84\x49\x75\x77\xff\x67\xb5\x6b\xdd\x4c\xd3\x70\x6a\x4d\x49\x65\x91\xac\xa4\x24\x5a\x59\x01\xa5\xb9\x68\x4f\xa3\x11\x03\x65\xcd\xc9\x4a\x1c\x98\x69\x44\xf3\x1a\xf8\x56\xde\x02\xc0\x4f\xa9\x55\xb1\x8f\x34\xa0\x0b\x3c\xad\x6f\xd2\x90\x22\x46\xaa\x57\x0d\x20\xed\xdd\x9b\x42\xb4\x14\xbb\x6f\x4a\xae\x39\x8e\x67\x29\x6f\x61\x72\x01\x23\x1b\x59\xcd\xc4\x68\x3c\x20\x9f\x4f\x48\x0b\x25\xcd\xfc\x91\x85\x55\x5b\xd3\xfc\xef\x6b\xcd\x59\x0b\xb1\xbd\xb0\xb6\x46\x97\xf2\xcd\x2b\x03\xf8\x42\xed\x85\xb8\x10\x3c\x0d\xff\x9f\x91\x24\xc2\xd3\x06\x81\xfa\x9b\x00\x16\x7b\x70\x7e\x35\x2d\xf4\x1c\x15\x9e\x1a\x7b\x53\x6f\x66\xbd\x90\x6f\x6b\xd5\x46\xda\x0b\x4f\x63\xea\x9a\xaf\x44\xcd\xf6\x1e\x75\x78\x1c\xb7\xe9\xab\x95\x1f\xe3\xeb\xc0\x3a\x6c\x91\x09\x4c\x4f\xa9\xf2\x30\x60\x06\x9b\x64\x02\xeb\xcb\xd3\xf2\x30\xa0\xfd\x4c\x98\x09\xbd\x3f\x73\xca\xc3\xe0\x6f\x63\xdd\xcc\x1e\x78\xfe\xaa\xbf\x0f\xbd\x8f\xe5\x73\x05\xe0\x8d\xc4\xea\x1d\x47\xc7\xd2\x76\xa2\x13\x6b\xcf\x6a\x57\xeb\xb3\xd8\x53\xdd\x3f\x1d\xd6\xf7\xd8\x3a\xec\xa7\x4d\x1a\x55\xf2\x2c\xde\x38\x24\x39\xdb\xf8\x82\xc1\x13\xaa\x52\x64\x15\x0a\xb4\x56\xc6\xb8\x3a\x18\x90\x25\x45\x91\x65\x0d\x47\x3d\x63\x46\xe7\x41\x9a\x73\x37\x21\xeb\x7f\x56\xf7\x13\x83\x34\xb6\x9c\x0e\xc1\xdf\x4a\x65\x5d\x6d\x33\x83\xdf\xb5\xfe\x1a\x3f\x08\x4d\x48\x3d\x14\xc2\x32\xe7\xae\x0d\xc2\x78\x96\xab\xb5\xb9\x77\xb8\x70\xd6\x3d\x68\xcc\xdb\x7b\xe6\x7c\x5c\xcf\x17\x00\x70\xfd\x33\xfa\x47\xd4\x3a\xe9\xfe\xfe\x68\x4c\xb2\xc5\x47\xd2\x02\x7a\xcf\x28\x0e\x0e\xac\xd7\xc5\x4d\x0e\x82\x7a\x49\x63\x5a\xd2\x3c\xe4\xe2\xe0\xcd\x34\xad\x69\x96\x56\xb5\xc6\x28\x2a\xe5\x3c\x1c\xc2\x73\x3a\x0f\x68\x59\x4d\xd3\x45\x03\x8c\x49\x2f\x4c\xdc\x61\x00\xf7\xa5\xdc\x9f\xd6\x2b\x21\xf7\x80\x76\xa0\x82\x43\xad\x81\x5f\x17\xd6\x22\x0d\x67\xd6\x52\x83\xf3\x27\xb4\x8c\x97\x59\x56\x85\x25\xa5\xf9\x9f\x48\x1c\xa6\x8d\x84\x29\x85\x8c\x65\x25\xcf\xc9\xd6\xf1\x28\x04\xd9\x06\x28\xe8\x77\x00\xf0\x71\x03\x78\x60\xcc\xa9\x71\x38\x89\x23\x4e\x4e\x35\x9f\xbc\xcd\x80\xfd\xb7\x01\xe5\x93\x45\xab\x2c\xcd\xeb\x7d\x91\x89\xc1\x9a\x93\xdb\xfd\x8c\xe6\x8c\x51\x84\x7c\x6b\x17\x17\x1f\x4e\x7e\xfc\x78\x71\xf4\xe9\xdd\xcb\xd3\xa3\x4f\xe7\x17\x2f\x3f\x5c\x7c\x7a\xf5\xd3\xcb\x0f\x16\xb6\x6c\x95\xed\x4c\xa6\x3b\x13\xf9\xce\x64\xc2\x33\x91\xf1\x4c\xa6\x3c\x13\x39\xcf\x64\xd2\x33\x91\xf5\x4c\xa6\x3d\x13\x79\xcf\x64\xe2\x33\x91\xf9\x4c\xa6\x3e\x13\xb9\xcf\x64\xf2\x33\x91\xfd\x4c\xa6\x3f\x13\xf9\xcf\x64\x02\x34\x91\x01\x4d\xa6\x40\xe3\x39\xd0\xb8\xe6\x5d\x7c\x2d\xcd\x1f\xf0\xb1\xe2\x33\xb7\x4f\xc1\x9e\x65\xff\x21\x52\xab\x89\xdc\x6a\x32\xb9\x9a\xc8\xae\x26\xd3\xab\xf1\xfc\x6a\x60\x09\x03\xbd\xd1\xd9\xd9\xc5\x27\x13\xac\x85\xad\x5d\xf3\x5a\xd9\x6e\xa3\x1b\x3c\x25\x0b\xae\x08\x51\xd8\x61\x33\x09\x37\x22\x25\x97\x60\x6c\xd0\x7d\xe4\x52\xa4\x03\xf1\x3b\x65\x0c\x08\x97\xdb\x41\xe3\x51\x58\x15\xad\x19\x30\x03\xcb\x84\x7a\x1e\xa4\xfa\x23\x12\x4e\x25\x08\xa9\xa8\xf5\x84\x59\xc0\xe4\x5e\x58\x89\x65\x7d\x64\x1c\xd4\xcd\x94\xe6\x42\x39\xc2\x50\x78\x4e\xca\xd9\x72\xc1\x48\x34\x0c\xe2\xcf\x47\xcd\xad\x39\xf7\xcf\x51\x07\x12\x50\x18\x56\x6a\x30\x36\x1a\xf8\x22\x57\xe6\x30\x65\x39\xaa\x46\x96\xc3\x95\x9f\x79\x98\x2d\x23\x5a\x19\xbb\x9b\xf1\x88\x40\x4f\xa8\x15\x2d\x99\x04\xcb\xa1\xd1\x5b\xee\x08\x62\xc5\x24\xac\x8b\xb2\x62\x12\xe8\xa3\x36\xbf\xc4\x9b\x9e\xc4\x56\x5e\xe4\xfb\xc0\x3b\x71\xd5\x29\xeb\x99\x92\x48\xa8\x1e\x9a\xd9\x63\x7b\xd1\x08\xa6\xe4\xfe\x69\x91\xb8\xa6\x25\x07\x24\xa2\x36\x88\xe9\x19\xf1\x0e\x4d\x0e\x8c\x37\x94\x06\x41\x03\x38\x6b\x6a\x68\xa1\x48\x1e\x89\x2f\x8b\x98\x74\xd7\xac\xb7\x26\x2b\x3e\xea\xb0\x65\xf7\xf4\xd0\xd0\x21\xee\xcf\x26\x56\x13\x44\xd0\xc2\x22\x16\x1c\xd7\x2b\x7e\xc8\x4a\xd8\x06\x43\xf5\x80\xd1\xcb\x93\xba\x28\x2d\xc8\x48\x05\x23\x57\xa5\xec\x93\xd4\x28\x38\xb4\x87\x0f\xa5\x97\xc7\x7b\xc0\x90\x16\xe2\xbd\x2d\x63\x93\xd5\x1c\x52\xef\x48\xff\xc6\x20\xb7\xb0\x8a\xf7\x0c\x53\x70\x42\x80\x78\x30\xa0\x38\x23\x20\xce\xdf\xd0\x2c\x83\xbf\x6c\x67\x11\xad\x1b\xcb\xfa\x60\x8c\x07\xcc\x5f\xd9\xca\xa2\x60\x93\xa9\x0b\x3e\x30\xdf\x12\x96\x3f\x75\xc0\x09\x18\xf0\x16\x87\xd3\x7d\xb5\x2e\x97\xad\x37\xd5\x6b\x05\x1b\xfb\x4d\x5a\x09\xd3\x9d\x26\xfd\x70\x71\xff\x6e\xd3\x50\x30\x50\x62\x57\xac\x27\xf8\x60\xd2\x52\xed\x81\x19\x83\x1d\x86\x14\xc8\xb2\xa2\x11\xdc\x80\xce\x75\x24\xa6\x35\x5c\xdd\x05\x69\x36\x1f\x83\x84\xf8\xd8\x38\xa7\xc1\xd8\x93\xb4\xfa\x40\x2b\x5a\x5e\xf3\xcb\xf8\xd0\x46\xf1\x21\x32\x6e\x0d\xcc\xce\x80\x1f\x8b\xec\x1d\x50\x0a\x71\xe7\x48\xeb\x07\xeb\x31\x98\xb9\x59\xd9\xe5\xf8\x4a\x98\xa4\x77\x99\x34\x6f\x14\x9d\xed\xba\x4d\xbb\x43\x51\x98\x37\xed\x64\xd1\xbb\xdd\xaf\x76\xcf\x67\x97\xb5\x86\x20\x50\x66\x6b\x58\x0f\xd1\x98\xdf\xd8\x51\x26\x78\xed\xcb\x2d\x6e\xb6\xd8\x15\x3c\xf3\xae\x27\x38\x04\xe9\x63\x0d\x93\xa7\x66\xee\x65\x18\xd2\x45\xad\xe3\x27\x9f\x27\x5f\x83\xa4\xf4\x57\x02\x16\x2f\x15\x46\x77\xbd\x48\x18\xd8\xf5\x22\x61\xc1\x6f\x0d\x42\x7e\x89\x32\x74\x78\x1a\x97\x23\x96\x19\x59\xd5\x6a\x1e\x14\x99\xf9\xa6\x36\x63\x1b\xcd\x42\x91\x34\xd1\xd1\x19\xab\xc3\xbf\x41\xb7\x4e\x6c\x57\xa5\xe4\x42\x8d\xa2\x71\x50\x39\x70\x4f\x5c\x84\xf6\x8d\x7e\x1e\x38\x7b\x7f\x07\x05\xf5\x55\xed\xd1\x22\xf4\x7e\x99\x2f\xc0\xeb\x6d\x5b\x60\xef\x15\xf3\xd6\xeb\x4e\x7d\x57\xea\xec\x6b\xd5\x4f\xd2\xcc\xe1\xd3\x38\xbd\xb5\x30\x57\xaf\x1a\x9a\x15\x91\x8e\x79\x8c\xac\x6f\x5d\x5f\x5f\x1a\xfe\x06\x96\x6c\xd0\x2e\xef\xb9\x29\x65\x22\xe4\xfe\x2e\xac\x84\x49\x53\x80\xb3\xa1\x6c\x2a\x7a\xa8\x0a\x23\x58\x82\xc7\x01\x3e\xbd\x88\xb5\x35\xe6\xfe\x13\x7c\x69\x80\xb1\x4e\x85\xb7\xa8\x50\x86\xb3\x76\xc0\x1e\x54\x23\x61\x3f\xd4\xe8\x1b\xc7\x82\x01\xe8\xde\xe1\x58\x61\xc7\x40\x91\xb3\x63\xf9\xa7\x8b\xd3\xb7\x96\xbc\x35\x28\xfd\x88\x16\x65\x7a\x4d\x6a\xaa\xfb\x0e\xf1\xad\xb2\x81\xc1\xf6\x7b\x0a\x9d\x70\x86\xa3\xf5\x35\x6a\xcc\x6c\x38\x55\xdb\x4b\xa8\x8b\x6c\xfa\x1e\x30\x4d\x96\xbd\xfb\x40\xd9\xe9\xd2\xaf\xaa\x79\xa1\x59\x47\x49\x64\xe1\xe6\xd5\xae\x0a\x89\x1b\xc9\x3b\xca\x20\xe3\xa5\x4e\x6d\xf3\x92\xa1\x96\xe9\xbc\x64\xd4\x36\x2f\xf5\x2b\x75\x3a\x6f\xf7\x37\x6b\xc0\x6c\xd3\xdd\x74\x00\x6d\x6b\xd8\x80\xea\x53\xd4\x74\xc0\xf4\x35\x12\x93\xce\x70\xac\xa3\xdc\x95\x46\xd4\x03\xc6\x59\xe4\x16\x89\xc0\x28\xae\x19\xbd\xc1\x9e\x03\x1e\x3d\x55\x8d\x00\x69\x97\xa5\x30\x79\x57\x05\x6b\xcf\xd0\x6d\x0e\x4c\x33\x83\xc2\x70\xef\xcf\x45\x51\x55\x69\x90\xd1\x73\x21\x71\x00\xdf\xfe\xa7\xf0\x44\x60\xef\xd2\x1c\xa0\x84\x04\x84\x58\x02\xbe\x40\xe0\x2d\x00\xe6\xc0\x83\x03\x8e\xbe\xc2\x73\x06\x0c\x35\xba\xd9\x8f\x13\x2c\x25\xd1\x9e\x83\x44\xeb\x75\xf1\x83\xab\xc7\x0e\x0e\x34\x4b\x6e\x4d\xca\x84\x72\x59\x85\xde\x72\xa3\x50\x96\xe6\x33\xc1\x21\xfd\xb9\x28\x29\x23\x53\x7f\x82\x3f\x18\xef\xa5\x5a\xe5\xe1\x7d\xb0\xdf\x15\x35\xf5\xd8\x67\x97\x82\x27\x91\x36\x1e\xee\x1a\xc0\x64\x8b\x45\x49\xaf\x69\x5e\x57\x56\x5a\x73\x99\x2c\xa0\xec\xb3\xbb\xe6\x42\x09\xb3\xe0\xe4\x27\xcc\x52\xc6\x41\x55\x69\x44\xad\x80\x86\x44\x1a\xa3\x82\xb2\xb8\xa9\x68\x59\x59\x84\xf5\x99\x87\x45\x5e\x81\xaf\x4e\x3d\xb2\x4e\x84\xd8\x71\xc3\x26\x37\xcb\x2c\x71\xc3\x72\xc4\xbf\x45\xde\xb2\xdd\xfa\x3d\xac\x05\xc4\x56\xdf\xd6\x20\x24\x8b\x7a\x59\x52\xef\x5e\xdc\x16\x4d\xa5\x13\x42\x77\xb3\xaf\xb7\x82\x2f\x32\x31\xb8\xfe\x7d\x25\x5b\x19\x2e\x0b\xde\xd6\xdd\xd1\x34\x2f\x15\xe0\x9e\x06\xbb\x82\x9b\xd8\xdd\xda\x02\xfc\xda\xb7\xd7\x8a\x8c\x94\xdb\x1b\x14\x37\x39\xc3\xab\x87\x4c\x5b\x54\x92\x24\x79\xc8\x67\xc5\x45\x39\x7f\x57\xfc\x4a\xb2\x14\xae\xb2\x6e\xeb\x9b\x5f\xeb\xdd\x5a\x9d\x15\xc5\xe2\x3e\xf4\x7e\x45\xc0\x27\xcd\xb7\xfe\xe4\x21\xb9\x54\x7a\x4d\x30\x51\xb2\x73\x8c\xdf\x7c\x89\xd8\x69\xfa\x27\xaf\x54\xd1\x83\x58\x1b\x09\x48\x4e\x92\xd8\x69\xad\x90\x89\x7f\x72\x0c\x95\x2f\xfe\x2d\xa4\x99\x2f\xeb\xbf\x89\x66\xf9\xd7\xa7\xad\x58\xdc\x33\x69\x8b\x8c\xac\xaa\x93\x3c\x4b\xf3\xed\x00\x4a\x4a\xa2\xb3\x3c\xdb\xbe\x95\xa4\xb7\xd4\x3d\x0d\xae\x69\x59\xdd\xd7\xa0\xb8\x79\xc0\x6e\x29\x45\xea\xab\xee\x51\xc8\xeb\xab\xb0\x58\xdc\xd3\x49\x45\xc9\x3c\xa3\xd5\xf6\xdd\x23\x11\xe2\x6f\xad\x40\x95\x7e\xa1\x5f\x1f\x3a\x0f\x87\xb2\x6d\xe0\x8c\xb0\x2f\x17\x8b\xa2\xe4\x74\x7c\x51\x16\xd2\x02\x58\xd2\x64\x99\x71\xcb\xab\x25\x9c\x12\x2b\xeb\x3a\x25\xd6\xaf\x87\x70\xb2\x44\x56\x95\x15\x75\x65\x39\x56\x35\x25\x51\x71\x63\x45\xc5\xdc\xe2\x36\x8f\x4a\x4d\xd5\xbd\x03\x5b\xd0\x8c\xe7\x1b\xff\xda\x2e\x3d\x38\xb0\xc0\xa9\x4f\xa9\x12\xe8\xed\x22\x4b\xc3\x94\x49\xcc\x8c\xfd\x13\x9c\x66\xe3\x25\xc1\xce\xd9\x91\xe0\x26\x43\x79\x27\x45\xed\x22\x7a\xbb\xa0\x21\x13\xc3\xc1\xe9\x4a\xf3\xa0\x91\x5e\x58\x63\xd5\xed\x2f\x94\x2e\xd8\x89\x23\x7a\x68\x14\xcf\xf2\x28\x49\xc1\x79\xdc\x50\x59\x53\x98\xc9\xf3\x5f\xdf\xf0\xed\x58\x93\x80\xe7\x1e\xd3\xc0\xa6\x35\x9d\x9f\x33\x94\x61\x2f\xb3\xd6\xec\xbf\xd3\x34\x2c\x0b\xc6\x84\xcb\x15\x19\xa9\x8f\xa7\xd4\x12\x19\x2f\xab\x70\x4a\xe7\x04\x32\x5e\x46\x45\x58\x1d\x24\x15\x64\xe2\x81\x96\x0a\xea\x7d\xb4\xa8\xe3\x90\x07\x73\x5a\xd5\x64\x65\x7c\xe4\xbe\xf1\x95\xf5\x94\xae\xc0\x02\xdc\x10\xa2\x18\x14\xfe\x6d\xcf\x95\xca\x72\x98\x50\xd0\xe3\x3d\x42\xb3\xe2\x86\x63\x07\x01\xc1\xed\xd5\x94\x94\x15\xad\xd5\xac\x84\x19\xa9\x2a\x6e\x5f\x15\x25\xec\xbb\x8e\x8b\x52\x7b\xae\x17\x47\x9f\x97\xe9\xb5\x3e\x93\x2f\x9b\x0f\x01\x9a\xd8\x76\x0a\x51\x28\xd3\xb8\xa3\xb4\xd7\xb2\x99\x65\xee\x02\xc2\xc5\x03\x69\xf7\xe2\x6a\x20\xe5\x9d\x08\xac\x03\x9d\x92\xeb\xb4\x28\x85\x73\x02\x18\x09\xb7\x21\x30\x93\xce\xd8\x60\x7b\x1c\x97\xee\xfa\x66\x63\x97\x3f\xef\x87\xbc\x60\xb7\x33\x39\xbb\xf0\x7b\xb7\x35\x45\xbb\x71\x51\xee\x76\xa6\x69\x97\xfd\xde\x67\x24\xf2\x7a\x57\x1b\x48\xc7\xd3\xe6\x4e\xff\x92\xc6\x17\x05\x82\xc8\x98\xea\x0d\x53\x53\x62\x28\x4a\x34\xf9\x37\x6f\x22\x0b\x34\x6a\xa2\x5d\x78\x6b\xd7\xed\xb3\x23\xbd\x03\x7d\x86\x05\xc1\x4e\x2a\x70\x03\x93\x0c\x60\x5d\x52\x52\x83\x87\x2d\xd7\x2a\x73\x6f\x39\x70\x8e\x63\x9b\xae\xb2\x52\xcd\x48\xf3\x6a\x5a\x16\x73\x3a\xb2\xde\xd2\xda\x62\x74\x7f\xc5\xc4\xb6\xc4\xe2\x61\xc6\xb8\x8f\x37\x5b\x3f\x3e\xfc\x06\x71\x49\x25\x5c\x93\x46\x0d\x28\x36\x73\x95\x77\x70\x90\xa4\xf5\x74\x19\x8c\xc2\x62\x7e\x10\x0b\xbf\xfd\x03\x30\x15\x1c\xa4\x55\xb5\xa4\xd5\xc1\xf3\xc7\xdf\x3e\xf9\x1f\xf0\x3b\x2c\xe6\x6c\xa0\xfb\x8f\x9f\x3c\x1b\x3f\x7f\xfa\xe4\xf1\x33\x6d\xc6\x60\x46\x18\x3f\x0c\xde\xf4\xea\xd2\xc4\x7a\xcd\xe7\xca\x08\x73\x27\x27\x0a\xe4\x6f\xd0\xb9\xe8\x53\x0c\xed\x0d\xe5\xb7\x68\x8f\xac\xdd\x5d\x6b\x4f\x2c\x97\x9a\x64\x4b\xc4\x72\x12\x43\x80\x00\xac\x69\xbd\xb2\x86\x43\x6b\xc7\x28\x19\x05\x24\x3a\x61\xf3\xcf\xaa\xa0\xc6\xb8\xcb\x32\x22\x86\x77\x3a\xfb\x0a\xd6\x48\x1f\x19\xd8\x03\xf3\xdd\x5a\x4e\x35\xc9\x75\xbf\x3f\xd0\x93\x31\x76\x01\xc2\x54\x53\x7e\xf1\x23\x20\x91\xfe\x3a\xac\xff\x48\x2c\x23\x77\x8c\x0e\x33\x4a\xca\x66\xd5\x46\xd6\xcb\x28\x4a\x19\x0c\x92\x65\x2b\x64\x45\xac\x43\x1d\x04\xd7\x1d\x50\xc6\xfd\x0b\x6c\x6a\xbc\x57\x80\x8f\x47\x8d\xfe\x54\x76\x34\x4f\x93\xa9\x01\x84\x51\x80\x85\x55\xc4\xb1\x55\x97\x24\xcd\x18\x0e\x45\x34\x4c\xe7\x24\xb3\xc0\xe3\xbb\x02\x69\xab\x91\x25\x96\x15\x2d\x77\x2b\x1d\x42\xb8\x2c\x2b\x76\x9c\x82\x4e\xbb\x00\xf1\xe4\xaf\xe5\x7c\x21\xc5\x94\x80\x26\x69\x0e\x17\x1a\x84\x69\x83\x7f\xb9\x06\x41\x07\x76\x92\x2b\x07\x6b\x58\x21\xc4\x24\x13\xf8\x22\x92\x5b\x45\xfe\x63\xb6\x2c\x2d\x10\x8e\xf8\xb7\xc2\xbc\xd5\x65\x9a\x24\xb4\xd4\xc1\x80\x04\xaa\x76\x37\x49\x48\x9a\x73\xc5\x35\xcc\x0b\x5c\x38\x29\x2a\x6d\x10\x7f\x13\xd3\x5a\x16\xce\xfb\x04\x6e\xb8\x3c\xf1\x20\x91\x1b\xc0\xbc\x93\x2e\xde\xb7\x90\x11\x91\x93\xb5\xbe\xec\xcf\xac\x1a\xa8\xe0\xed\x3c\xeb\x6d\xf6\xcf\xd3\xb7\x3c\xf7\xb5\xf2\x88\xdc\x1d\x68\xda\xf2\xc6\xb5\x5f\x2a\xad\x98\xf8\x77\xfe\xeb\x1b\x43\x96\x67\x73\x9c\x53\xc6\xff\x34\x42\x6a\x9a\x27\x08\x74\x52\x02\x2e\x7b\xb6\x8a\x52\x1d\x22\x82\xe4\xc0\xc6\xd0\xd5\x53\xff\xbe\xbe\xe0\xd1\x7f\x42\x5b\xf0\xa8\xa3\x2b\x80\xd1\xb1\x2f\xd7\x0e\xd8\xb7\x69\x55\x83\x05\x45\x12\x47\x6d\x66\x2f\x3e\x1c\x9c\xff\xfa\xe6\x80\xd4\x35\xa4\x46\x14\x4c\xc9\x23\xeb\xfc\xf4\xe4\xad\x75\xbe\xa0\xe1\x3d\x2f\x56\xf3\x34\x1b\xe8\xb6\x60\xb6\xde\x97\x70\x12\xe6\xf5\xfe\x14\xf2\xbe\x32\xa4\x23\x99\x98\xbd\xfd\x80\x54\x94\x09\x0e\x50\x5a\x92\x20\x0d\x21\xcf\x21\x7b\x94\x55\xfb\xd5\x34\x8d\xe1\xb5\x90\x2c\x34\x20\x61\x96\x2e\xf6\x17\xa4\x9e\xaa\x87\x72\x99\x01\x20\x9e\x83\x11\x74\x91\x8b\x22\x03\x42\xb5\xa5\x78\x3f\x4e\xb3\x9a\x96\x55\x53\x2d\x32\x37\x36\x05\xca\x34\xcb\x8a\xa2\x62\x9e\xe6\xa4\x35\x6e\x6e\x0a\xdf\x0f\x48\x38\x4b\xca\x62\x99\x47\xac\x30\x4e\xb3\x6c\x5f\xe4\xb7\x55\xcf\x72\x80\x90\xa1\x76\x1f\xe0\x37\x8f\x7a\x63\x9e\xdc\x71\x9e\x66\xcd\x23\x93\x11\x8c\x87\x7d\x12\xfd\xb5\xac\xea\xa6\xac\x2e\x69\x1d\x4e\xb5\xe7\x55\xd6\xbc\x21\x3c\x88\xd4\xf3\x8d\x9a\x47\xc8\x15\x09\x59\x24\x9b\xa7\xa2\x4c\x69\x2e\x92\x5b\x4e\x8b\x32\xfd\x52\xe4\x35\xc9\xfa\xeb\xaf\x69\x59\xa7\x21\xaf\x85\xb6\xfb\x24\xba\xde\xbf\x6d\x1e\x8b\x32\x4d\xd2\x9c\x97\x40\x84\x76\x73\x4e\x33\x5a\xd7\xb4\xdc\x17\x9b\x0d\x4a\xd8\xd0\xd2\x3c\x69\x66\x68\x4e\xca\x19\x2d\xf7\x29\x9f\x5b\xf1\x34\x4f\xf5\x27\x90\x8e\xd8\x33\x78\x3c\x31\xbc\x91\x34\xdb\x28\xac\xa7\x69\x38\xcb\x69\x05\x4b\xbe\x20\x69\x5e\xef\x43\xea\x61\xfe\x98\x17\x15\xdd\x3f\x84\xdf\x05\x20\xca\x3e\xd7\x55\xb1\x12\x35\x68\x40\x21\x3e\x95\xd5\x94\x2c\x5a\x9f\x53\xd5\xc5\xa2\x19\x38\x3c\x69\x2b\xcb\x0e\xa4\x19\x15\x79\x09\x8d\x11\x9a\x35\xc6\x30\x79\x96\xe1\xfd\x48\xa6\x2c\x6e\x95\xf1\xd8\x80\x5a\x21\xfb\xd0\x90\x2c\x5a\x25\x7f\x15\x69\xae\x15\xcd\x55\x66\x63\xad\xd0\x1c\x29\x2b\xb9\x49\x23\xbe\xc3\x6a\x7a\x5b\xef\xf3\xf0\x8a\xea\x31\xa2\x61\x51\xaa\xfd\x05\x45\xc6\x5c\xc0\x75\xc7\xce\x5a\x34\xa5\xc6\x57\x2e\xf3\x34\x2c\x22\xba\x1f\xa4\x51\xaa\x3f\x43\xdc\x47\x51\x50\x57\xfb\x0b\xb6\x28\x40\x20\xae\xf7\x49\xb6\x98\x92\x80\xd6\x69\xc8\x9f\xa7\x24\x4f\x44\xd7\xd7\xfb\x69\x44\x8b\xa4\x24\x8b\xa9\xac\x9d\x13\x46\x6b\x89\x42\xd6\x6b\xb8\x4b\xb9\x4f\xe3\x98\x86\x35\x2f\x28\x6b\x40\xde\x95\x7a\xd2\x71\x57\x2f\x80\x16\x37\x45\x19\xe9\x78\x7b\x53\x42\x6e\xc2\xfd\x79\x11\xc1\x80\x6f\x35\x6a\xc5\x4f\x3c\x12\xd6\x4b\x52\x53\xad\xa0\x0c\xcb\x22\xd3\x0a\xa6\x25\x8d\x9b\x27\xb3\xae\x9a\x16\x37\xcd\x53\x9d\xd6\x7a\x25\xe3\x49\xe1\x69\x9e\x79\x8c\x3a\x89\xdf\x79\xe5\x89\xd3\x94\x57\x65\x84\x8f\x95\xfd\xe6\xe7\xe6\x95\x38\xe3\xcf\x7f\x7d\xb3\x4d\x1f\xde\xa3\x6e\x5e\xd6\xc5\x07\xae\x91\xd9\x2e\x32\x7d\x73\xc8\x05\x19\xe9\x3a\xf2\x81\xf2\xeb\xaa\xd5\x07\x43\xd9\x73\xdf\xab\x0b\x61\xaa\x79\xc9\x56\xfa\xbe\xe6\x5f\x17\xcf\xf4\x11\xef\x6a\x4f\xbb\x5f\x1d\xe4\xee\xd6\xba\xdd\xde\x51\xee\x1a\xcf\xbb\x5b\x87\x26\xee\x91\xf0\xf1\xc1\x2a\xbd\xe4\xf8\xe1\x59\xef\xce\x47\x50\x80\xb4\x3a\x8e\x2a\xbd\x75\x3f\x95\x34\xee\xad\xf8\xb0\xed\x8d\xf3\x69\x71\xd3\x5b\x71\xc1\xd0\xaa\xbf\x66\xb5\xe8\x56\xcc\xb3\x1f\x49\x25\x8a\xe7\x99\x2a\x7c\x4b\xf2\xa4\x53\x78\xce\x3d\xb2\x79\xa9\xc1\x5f\xbe\x7a\x79\x7a\xf4\xf6\xe4\xf7\x23\x0b\x5b\x07\x97\x7f\xec\xff\xe1\x5d\x39\x97\x64\xff\xcb\x95\x7b\x90\xc8\x2b\xa1\x8b\xb4\x86\x2b\x27\x16\xd6\x04\xdb\xba\x98\xd1\xdc\x30\xcf\x41\xc9\xe5\xe1\x95\x99\x22\xdd\x87\x9e\x80\x23\xe9\xe4\x57\xb7\x1c\xbe\xa7\x49\xd6\xc4\x04\x00\xc1\x50\xf8\x94\xca\xda\x91\xb8\x25\xea\xc8\xc1\x22\x6d\x54\x2e\x78\xa8\xf6\x6d\x21\xed\x8a\xc6\xa5\x02\x7b\x65\x61\x6b\xec\x6f\x7b\xa3\xeb\x08\x6b\xbc\x28\x07\xe4\x0f\x36\xac\xdb\x86\xfd\xde\x76\x63\xa1\xd7\xd4\xe5\xfa\x0f\x78\xb3\x6f\x78\xae\x7e\x2d\x1c\x92\xac\x7c\xac\xd3\xac\x6a\x4c\x67\x1f\xc5\x65\x59\x08\xfe\x02\x92\x7e\x3a\x5f\x66\x4c\x96\x23\x56\x5d\xae\xf6\x21\xfc\x36\x93\x4e\x3e\x85\x64\x99\x4c\x39\x8c\xc6\x51\xff\xd3\x94\x54\xaf\xf4\x0a\xee\xf4\x3c\x30\x81\x73\x31\x89\x5f\xc0\x05\x8f\x54\x6e\x8a\x39\x28\xe1\x08\xe5\xea\x1d\x88\xc6\xc7\xef\xeb\x42\x77\xa2\xae\xa7\xbf\x0f\x46\x4d\xd3\xa1\x9a\x21\xb9\x4b\x79\x41\xf3\xd5\xba\x96\x45\xde\xe8\x68\x6a\xb5\x6b\x28\xd2\xc7\xa4\xdb\x68\x94\xe6\xd7\xc5\x8c\xbe\x59\x92\x32\x6a\xa2\xbd\xb5\xc2\x3f\xf4\xba\x81\xef\x9e\x08\x60\x56\x2f\x08\xc7\x6d\x5c\xe0\xd4\x30\xcd\x8b\xbd\x42\xaf\xd1\x3f\x80\x07\x8f\x55\xf3\x89\x35\xef\x45\xb2\x06\x5a\xdf\xd6\xcd\x34\xcd\xa8\x95\xb0\xb7\x41\x76\x61\x92\xab\x5c\x21\x25\xdf\x2f\x16\x34\x57\x96\xfa\xb4\x16\xf7\xd2\x44\x5e\x72\x26\x28\xf3\x0b\xd8\x69\x6c\xa5\xb5\xb8\x2d\xad\xab\x02\xe0\xbe\xe2\xa0\xb9\xf3\x75\x02\x5e\x1c\x22\xe4\x01\xe2\xd2\x18\xfb\xff\x7c\xc1\x35\x20\x70\xad\x0d\x46\xa3\x21\x27\xc4\x22\x29\x29\xa9\xd8\xa0\x69\xa3\x9c\x78\x04\x57\xe0\xb4\x96\x22\x24\x43\xb6\xb2\x20\x18\x83\x90\xdb\xb9\x37\x7e\x75\x43\x16\x16\x77\x13\x53\x5a\x56\x0e\x44\x75\xce\x95\x28\x69\x6e\xbd\x3e\xfa\x95\x89\x78\xb4\xef\xb6\xda\xb9\xe6\xe5\x20\xd5\x0c\x30\x87\x0c\xef\x97\x15\xd7\x52\x67\x45\x92\x80\x1a\xa2\xb4\x22\x1a\x2c\xe1\xc1\x04\x23\x03\x1e\x6c\x60\x3d\xe0\x0b\x9b\x54\x30\x85\x40\x02\xf3\x95\x47\x1b\x65\x1b\xbe\xe0\x17\xe3\xe0\xb7\xe8\x16\x54\x0e\x21\xc9\x32\xe9\x7a\x2d\xc1\x99\x40\x46\xa3\xd1\xa3\x8d\x45\xca\xa4\xb2\x5e\xca\x88\x78\x5c\x55\xae\x37\xe7\xb7\xea\x7a\x90\xcb\xd0\x63\x82\x83\x1a\x7b\x46\x72\x30\xc8\x22\xc8\x0a\x90\x15\x22\x2b\x42\x16\xab\x75\xd5\x56\xed\x81\x36\x22\x8b\x45\xb6\x72\x5a\xb4\x0b\x59\x2a\x56\x1f\xa8\x41\x5a\x68\x7c\xce\x26\x9e\x54\xfd\x10\xf9\xe5\x09\xcd\xc1\x95\x1f\x44\x5c\x36\xe7\xb8\x8a\x18\xa6\x42\x62\x97\x6a\x20\xef\xc9\xa6\xb9\x45\xac\x24\x2b\x02\x92\x31\xbc\x49\x6b\xe9\xb6\x28\x88\x54\xce\x88\xdc\x9f\xe2\x41\x23\x87\x7f\x5a\x8c\x92\x96\x62\x57\x5c\x9c\xbd\x3e\xf3\xc0\xaa\x90\xc6\x06\x39\x05\xbd\x80\x41\xf0\x94\x5b\x64\x0e\xca\xf3\xff\x87\x68\xed\x85\x7c\x99\x47\xaf\xd8\x96\x86\x60\xaf\xf2\x24\xf8\xd7\x50\xaf\x85\x5e\xfd\x54\x53\xa0\x22\x23\x48\x6d\xfc\xe3\xaa\xe6\x36\x14\xf3\x5c\x74\xb4\xdb\x20\x10\xc2\x03\x16\x19\x77\xfa\x06\xbd\xab\xf1\x9e\xaf\xa9\xb3\x77\xda\xcd\xdb\xa7\xa1\xae\x17\xfe\x5a\x5b\x0b\x6b\x3e\x89\xbd\x2f\x94\x66\x6b\x18\x73\x8f\xde\xd1\xdc\x7e\xaf\x97\x60\xc6\xa1\x32\x22\x0c\x43\xcd\x84\xcf\xa5\x5a\xa0\x8a\x11\x5d\xae\x67\xe6\x8c\x40\x9b\x01\xe0\x37\x47\x38\x40\xd9\x54\xf1\x0a\x05\xdb\x18\x53\x92\x47\x59\x13\xae\xa3\x2e\x16\x56\x46\xaf\x69\x26\xde\xe7\xd5\x65\x73\x07\xb8\xbb\x37\x75\x7c\x69\x39\x12\x76\x1b\xff\x1d\x4a\xd4\xe1\x88\xb6\x75\xd3\xb7\x42\xda\x9b\x0d\xc4\x36\x56\xf4\xc1\xec\xc3\xc1\x16\xc0\x87\xa1\xa0\x4e\x98\xe4\x6a\xdf\xd7\xc6\xc2\xc2\x69\x74\x3b\xda\xbd\x32\x5a\x2b\x7f\x56\x6d\x2a\x34\xdc\x12\xb6\x93\xbb\x86\xdd\x69\xf1\x51\xed\xd9\x80\x98\x2a\x8c\xe0\x30\x74\x80\xab\x71\x12\x89\xa0\x1c\x10\x2c\x12\xb7\x99\x04\x37\x52\x59\x59\x3a\xa3\xd9\x8a\x1b\x13\x00\x8b\x88\x15\x2c\x21\xe5\x9d\x88\xc7\xf2\x3e\xa3\x84\x11\x51\xc6\x03\x91\xdc\x02\x53\xd3\x48\x9a\xd1\x4c\x7d\xfb\x36\x8e\xec\x5f\xa2\x47\x7f\x63\xfe\x1e\xb8\x2a\x10\x5c\x68\x99\x87\x2f\x19\xad\xc5\xd6\xcb\xb2\x24\x2b\x2d\x26\x2c\x78\xa8\x8e\xd8\xfc\x39\x0a\x9b\x91\xf5\x04\xbe\xb4\x2e\x57\x62\x21\x18\x00\xb1\x09\xd4\x07\x48\xa0\x1c\xf7\x2d\xce\x62\x39\x54\x47\xb5\xaf\x0c\x51\x5b\xf6\xaf\x7f\x77\xe3\x35\xcc\x26\x5e\x88\x2f\x27\x0d\x37\x06\xf6\x19\xc5\xc6\xf5\x2f\x0a\x3b\x60\x1a\x37\x37\x11\xcc\x52\x7a\xff\x91\x9a\x7b\xc7\x58\xf3\xa2\xa4\x56\x9e\x86\x0c\x43\x54\x70\x0f\xe1\xb9\xb6\x5b\x59\x32\x6a\x26\x67\x3c\xd3\x88\x12\x86\x51\x75\xa1\x34\x0b\x1c\xa0\xfd\x1e\x2c\x55\x45\x6e\xd1\xdb\x90\x82\x07\x52\x65\x2b\x2b\xf6\xc8\xfa\x51\x58\xf9\xb9\xbf\xc4\x4d\x49\x16\x70\xdb\x0e\xcc\x5a\xfb\x8b\xb2\xb8\x4e\x23\x1a\x0d\x0c\x07\x71\xc6\xd5\x6c\x63\x6c\x18\x0f\x21\x6e\x56\x08\xfe\x59\x7e\x9f\x55\xc4\x03\x61\xe8\xeb\x9b\x93\x65\x05\x81\x4d\x14\x97\x8c\xd4\x28\xb4\x81\x83\xbf\x1e\x58\x85\xe5\x98\xd8\x0e\xb2\xf8\x72\x6a\xed\x9a\x71\xc8\x59\x12\x41\x46\x16\xf0\xad\xcb\x3c\xa3\x15\xbf\x4d\x28\x02\xb8\x81\xb1\x8c\x4d\x3f\xc4\x57\x81\x90\x4d\xb7\x75\x49\xac\xaa\xa6\x0b\x76\x76\x80\xbe\x1e\x2e\xbe\xcb\xd9\xec\xf4\x39\x92\x16\x24\x0e\x69\x99\xd7\x69\x5e\x2f\xc1\x27\x84\x89\x10\xc5\x32\x99\x22\xe5\x53\xc1\x44\x51\x51\x28\x66\x7e\x0a\x64\x02\x60\xaa\x88\x51\x08\x9c\x1d\x1b\xb7\x50\x35\xd8\xdd\xca\x5a\xd0\x92\x21\x90\x04\x4f\x1b\xa2\xb2\xcc\x39\x9c\xd1\x40\xd8\x12\x0f\x0e\xac\x8b\x06\x2d\xc4\xd7\x2d\xb8\x14\x78\x3f\x7a\x20\x25\xc9\x70\x21\x46\x0c\x45\x49\x32\x5c\x0a\x51\x4e\x93\x1c\xf7\x57\x79\x38\x2d\x8b\x1c\x42\x2f\x59\x51\x5a\x2d\xa0\x29\xb1\x62\x32\xa3\xd2\x54\x59\x88\x67\x0e\x50\xde\x36\x43\xc2\xb4\x9a\x65\xca\xb2\xaa\x50\x10\x8a\xf9\xee\x29\x8b\x39\x63\x9e\xd3\x08\x68\x22\x87\x28\x8e\xda\x81\xba\xaf\x09\x1b\xa9\xe9\x72\x24\xdd\xba\x15\x18\x29\x06\x1a\x73\x67\x4b\x4a\x6d\x73\x09\x8f\xc3\x53\x5c\xb7\xd1\xd7\xc8\xfa\x71\x69\x78\xc9\xa8\x53\x9f\x8b\xa3\xc0\xae\xeb\x52\xdc\xc1\xc1\xff\xc7\xde\xdf\x77\xb7\x71\x23\xf9\xe2\xf8\xdf\xf1\xab\x80\x3d\x59\x93\x4a\x28\xca\x4e\x76\x67\x27\xd4\x68\x7c\xf5\xe4\x44\x37\xb1\xe5\x6b\x2b\xe3\xdd\xeb\xf5\x11\x41\x36\x48\xf6\xa8\xd9\xe0\x34\x9a\xa2\x39\x13\xbf\xf7\xdf\x41\x55\x01\x28\xa0\xbb\x29\xd9\x49\x7e\xf7\x9c\xfd\x6e\xfe\x88\xc5\x6e\xa0\x1a\x8f\x85\x42\x3d\x7c\x8a\x08\x14\x5a\xaf\x02\x07\xce\x6b\x91\x69\xc2\x4d\x01\x03\x42\xb5\x5e\xd5\x0c\x33\xc5\xee\xa5\xb9\x95\x56\x67\x85\xde\xe0\xa4\x8a\x73\x50\x40\xe7\xb7\xaa\xd8\xd2\xfd\x74\x9e\xdf\x2a\x23\xd6\x86\xcd\x8e\x9b\xc5\x10\x7b\x34\xad\x11\xde\x8c\xf5\x8d\x5d\x60\x5f\x2a\x59\x3f\x24\x9d\x09\xb8\x66\xe1\x20\x32\xb6\xe3\x9c\x93\x70\x8b\x1c\xbf\xba\x00\x19\x0a\xec\xa1\x56\x4a\x77\x57\x54\xa1\xd7\x95\x63\x6f\x34\xc3\xe7\x7f\x65\x7c\xa0\x9d\x05\x50\x68\x05\x29\x3d\x10\x01\x13\x3d\x26\x42\x1c\x0c\x43\x9a\xa4\x44\x54\x6e\x81\x01\xe2\x5e\x0a\x80\x19\x4a\x3b\x04\xce\x1d\x04\x93\xbc\x4d\x6d\x04\x39\x1e\x8b\x5d\x5b\x04\x94\x97\xd6\xc4\x51\xe8\xf7\x40\x05\xd7\xdb\xa3\x48\xf4\xce\x43\xfa\x4c\xdd\x7e\xee\x39\x2d\x82\xa7\x9a\x9d\x79\xbb\xae\xed\xd0\xb0\x10\xb7\x8e\x4d\x54\x2f\x2a\xb5\xf1\xb7\xcd\xa1\x78\xab\x02\x35\x84\xc3\xc1\xc3\xc4\x1e\x77\xc2\x2d\x02\xe7\xb8\x00\x9b\x06\x63\xf0\xf2\xda\xc7\xba\x09\xc4\xbc\xa4\x58\x4c\xef\x0c\xd1\x72\x07\xf3\x9b\xd1\xf7\x19\xd5\x39\x03\x31\xce\xf2\x8c\xee\xac\x20\x6e\x97\xea\x56\x55\x10\xa6\x18\x35\x8e\xbe\x48\x2c\xd7\xd4\x95\xac\xd5\x7c\x2b\x36\xba\xba\x31\xc8\x5b\xf3\x59\xb4\x6e\x73\x23\x66\x85\xbc\xd9\x5a\x06\x13\x68\xcd\x64\x5e\x60\x6c\xba\x65\x39\x76\xd1\xba\x7d\xce\xc5\xf7\x01\xf7\xf7\xb3\x3b\xd5\xb2\xc3\xca\x9e\xca\x3c\x46\x3c\xec\x7f\xdc\xe3\xb2\xb6\x07\xd8\x90\x89\xba\xae\x6b\x5e\x88\x60\xbe\x4b\xb0\x6e\x1a\xdc\x0c\x18\x99\x6d\x16\xe7\x63\x6f\xe9\x26\x12\xf1\xd9\x40\xca\x33\xdc\xb8\x1e\x29\xac\xc6\xd1\x76\x19\x03\xe7\xb6\x7c\xd4\xb6\xde\x77\x77\xa3\xe2\xe9\xdb\xb1\x8e\x78\xff\x3e\x53\xba\x73\x72\x1d\xc2\x88\xc9\xa2\x60\xba\xc8\xc8\xbf\xe8\xad\x12\xf9\x72\xa9\xb2\x5c\xd6\x0a\x20\x1a\x97\x9a\x4e\xb3\xf8\x68\x20\x1e\x4b\xe0\x9b\x5e\xc5\xc6\x49\x95\xca\xd8\xc3\x6f\xdc\xba\x1d\xc7\x40\xcf\x88\x4c\x03\x4b\x9e\x16\xd2\x2c\x86\xe2\xd2\x69\x0b\x07\x70\x0c\xa6\xa4\x60\x9c\x36\x10\xaa\x4a\xde\x37\xb8\xc0\xc3\x04\xd0\xf0\x1a\xf0\x2c\x29\xb7\x58\x63\x91\xcf\x17\xb1\xa3\x0e\x39\x28\x9a\x9a\x8d\xae\xf0\xcc\x86\x1c\xeb\x22\x78\xd1\xbe\xba\xad\x21\x5d\x65\x34\x7a\x03\xf2\x1e\x0b\x37\xeb\x3b\x85\x67\xfc\x8f\x2d\xd3\xe8\x8e\xf4\xb1\x65\xbd\xc6\xfb\x25\x39\x1d\xdf\x2a\x02\xff\xca\x0d\xd3\xb6\x07\x77\x2e\xbe\x77\x64\x0d\xf7\x24\x54\x63\x0d\xc5\x45\x6d\x25\x1c\xf2\x6a\x71\xa7\x90\xbf\x38\xb9\xdd\x01\xdb\x60\x96\x57\x0a\x44\xe5\x88\x5c\x29\x74\x39\x55\x87\xb0\x81\xd4\x07\x69\x0f\xa6\x81\xe5\x09\xa5\x2e\xf7\x9d\x67\xb0\x15\x1f\x0a\xa3\x69\xb6\x93\x9d\x11\xa8\x59\x91\x44\x46\x3b\x12\xda\xe3\x7c\xae\x00\x79\xd3\xf6\x95\x07\x2a\x9b\x1c\x03\x4f\x6a\x2d\x96\x1a\x9c\x89\x78\xeb\xb4\x21\xff\xc5\x21\xe0\xc4\xda\x76\xd9\xcd\xda\x32\x88\xd0\x3b\xba\x09\xf8\x5e\x0d\x1c\x14\x1f\xd2\x2b\xa4\xd7\x57\x60\x5d\x80\xcb\x00\x5c\x50\x7b\xab\x6c\x0a\x3e\x5e\x0a\x00\xa9\x03\x05\xcd\x40\x6e\xa3\x00\x82\x30\x1c\xfd\x6d\xf4\x3d\x36\xe9\xb4\x16\xba\x54\x9c\x43\xf6\x40\x90\x09\xf4\xfc\x2c\xc2\xa5\xa7\xe4\x5e\x99\xb5\x46\x47\x36\x14\x98\xd0\x39\x77\xa2\xea\x8d\x52\x25\x0c\xc8\x34\x08\x06\x44\x0c\x9a\xe1\x5c\x98\xb0\x11\x19\xad\x0f\x44\x3d\xc4\xa6\x25\x73\x89\x5b\x0d\x9c\x90\x1d\x4c\x5c\xe0\xd9\x7e\x58\x1c\x67\x27\xc9\x7b\xb2\xae\x1b\x3c\xdd\x2e\x51\x3b\x23\x28\xe8\xe2\x30\xe9\x40\x2e\x9f\x97\x76\xa2\xf2\x20\x14\xa6\xc7\xd9\x44\x91\xa1\xa8\x0b\x29\x2e\xd1\x8a\xc4\x36\x17\x34\x65\xb1\xa3\xd9\x36\x9b\x9f\xf5\xc9\x2c\xc1\xd9\x89\x2a\x89\xe4\x1c\x7a\xa3\xda\xf5\x20\x88\xcd\x7f\x5a\x69\x63\x2e\xc1\x62\x98\x94\x4a\xd9\xb5\xc6\x02\x7d\xf8\x24\x67\xd7\xae\x03\x78\x66\x45\x3a\x3b\x91\x34\x20\x56\xff\x59\x09\x90\x2a\x93\x8b\xb1\x95\xd0\x90\xcc\x54\x17\xa5\x86\xe7\x4f\xc2\xc3\x22\x2f\x95\x7b\xca\x5b\x20\xda\x3b\x12\x7f\xed\xe3\x2e\xde\xc6\xef\x2b\xf6\x10\xe3\xf3\x83\x1c\x57\x1c\x09\x94\xf1\xf6\x7b\xe2\x6b\x94\xdb\xc4\x33\x54\x85\x8f\x44\x0f\x0f\x17\xd2\x3a\xba\x65\xe6\xa5\x41\xe7\xc0\x2e\xe9\xa8\x8e\x0f\x09\x2a\x42\x32\xae\xcc\xb2\x98\xe3\xf7\x60\x88\x7a\x03\x37\x01\xe1\x20\x75\xe7\x44\xa3\xca\x1d\x87\x44\x68\xd3\x9b\xf6\xfb\x5b\x2a\x86\x10\x57\x89\xc5\x02\xae\x35\x67\x3b\xd6\xc0\x25\x87\xbb\xa6\x76\x0a\x5b\xc9\x28\xb7\x08\xd7\xb7\x20\x5a\xc3\x3f\xc1\x9f\x5c\xdd\xd6\xc3\xbc\xcc\x6b\x7c\xeb\xfb\x4a\x9b\x2d\x3e\x09\xfd\x18\x45\x5c\xc2\x56\xda\x8b\x50\xaa\xdc\xde\xe5\xab\x0a\xf4\xdf\x6c\xfd\xc6\x2b\x0e\x23\x2c\x02\x4b\x81\x9e\x59\x6e\xd1\xc6\x4c\x50\xb4\x05\x76\x32\x64\x34\xdc\xce\x29\xd5\x46\xe0\xe6\xea\x1d\x97\x4c\x95\x48\x96\x1e\xba\xff\x12\x74\x17\xe0\xac\x86\x58\x17\xfc\x20\x9e\x73\x76\x65\x3e\x72\xbc\x0d\x58\xd6\xc6\xb2\xcb\x1c\xb8\x99\xd7\x59\x38\x4d\x24\xf9\xd9\x3b\xb1\xf9\x91\xf8\x5a\xf4\xac\xe0\x9c\x97\xca\x18\x17\x54\x03\xe7\x46\x5e\x1b\x31\x51\x84\xc2\xc4\x55\x0b\x41\xa3\x60\x3f\xdd\x6b\x53\x2b\x38\x43\x91\x53\xce\x38\x8c\x26\x0a\xe8\x32\xe8\xe7\x0f\x2d\x3f\x3b\xff\x2b\xf8\x46\x09\x5d\x16\x5b\xbb\x7a\xa6\x37\xa6\x43\x3e\x50\xc6\xe9\x2a\xec\x3d\xc0\x1e\x26\xd0\x7c\x18\x1b\xea\xd0\x50\x5c\x55\x5b\xb7\x06\xdd\xad\x84\x2e\xff\xdc\xe6\x4b\x9a\x3c\xe8\x80\xae\x08\xf3\x81\x40\x1b\x25\xbc\xac\xca\x40\x13\x81\x6e\x85\x59\x83\x42\x86\x89\x2b\xb9\x41\x12\xfe\xc4\x75\x2a\x5c\xd4\xe7\xc1\x68\x0e\xc4\x6a\x97\x8e\x57\xc4\x7e\xfc\x4d\x9e\x16\xaf\xc0\xe6\xea\x79\x74\x2c\xa6\xb6\x0a\x79\xa1\x35\x56\x12\x9f\x54\x3b\x76\xe8\x5a\x0e\xf0\x37\xb6\xb7\x30\x84\x10\x5f\x05\x7d\xa0\xea\x3e\xad\x84\xe0\x09\x10\xb0\xb3\x2e\x5e\xc9\x8c\x0e\x0e\x66\x93\xe1\x52\x61\xc8\xc4\x3e\xb4\x82\x5c\xe1\x90\x0a\x60\x81\xc1\x89\x59\xce\x74\xb5\x94\xe4\x6b\xd0\x64\xcf\x9f\xa2\x97\xed\x28\xdf\xa9\xf1\x6d\xa8\xfa\x3f\xd9\x78\xf0\x49\x86\x09\x7e\xd2\x20\x80\x0c\xe3\xfe\xfe\xce\x12\xb3\xff\x36\x99\xbf\xe3\x04\x70\x58\xa7\xdd\xee\x19\xed\xfa\x07\x0f\xec\x81\x9e\x4c\xa9\xe1\x29\x52\x4f\x04\x90\x8d\xfb\x1a\x02\x77\x1a\x7a\xb8\x7d\xaf\x43\x09\x9f\x98\x00\xc3\x78\xde\xc3\xba\xc8\xa6\x0a\x2d\x77\x7e\xee\x3f\x72\xef\x7f\x74\x8b\x01\x20\x1c\xf0\xed\xa5\xf0\x0c\x9c\x97\x15\xe4\xc8\x32\x01\x72\x47\x85\xcc\x59\x97\xb6\xb4\x6f\x54\x0b\xb9\x65\x04\xaa\xee\x40\xd3\x39\x61\x72\xd4\x67\xf4\xa1\xd8\x95\xc6\x2f\xa4\xb0\x3e\xaf\x95\xe5\xf4\x14\x8e\xa0\x1c\x0d\x08\x5a\x08\x90\x76\xce\x0f\xc7\xb5\x1d\x24\x66\x2a\xea\x3a\xd8\x02\x93\xc1\x40\x2d\x2a\xf7\x19\xd6\xcf\xbc\x9c\xb3\xe9\x7f\x98\x0e\x83\x9b\x6f\x7b\x59\x97\x79\x0d\x3a\xf0\xc2\xf2\xb4\x71\x5a\x12\x62\x9f\x3d\x9c\x2d\x33\x47\x3a\x44\x93\x00\xd6\x0b\x95\x1c\x5c\x6f\x3c\x30\x7c\x7d\x61\xb9\x17\x18\xf2\x70\x94\x14\x7c\x17\xa8\xbc\x3f\x4c\xaa\x40\x7c\xa6\x13\x55\x59\x13\x87\x10\xcb\x70\x39\xeb\x87\xba\xb4\xc9\x1e\xf6\x79\xcd\xbf\x88\xfd\x76\xc4\xcd\x5e\x5b\x7e\x35\x71\x2a\x4b\x54\xf4\x02\x07\x8d\xd6\x17\x9e\x1c\xa4\x76\x50\x1f\xec\x84\x92\x36\x20\x99\xb8\x81\x18\xff\x8b\x19\x0f\x7b\x03\x36\x3a\xa9\x8b\x16\xa0\xd4\x44\xbd\x87\xe6\xbe\x0f\xe7\xc5\x54\x97\x75\x5e\x3a\xae\x89\xbc\xf6\x21\x1f\xc6\x21\xd8\x40\xa6\x28\x54\x99\xfb\x77\xf1\x3c\xea\x14\xf8\x93\x05\xd5\x30\xac\x06\x4e\x77\x4c\xd1\x9a\x28\xb4\xd8\x8e\x79\x75\xf8\xee\x1e\xb6\xf5\x4e\x1c\x45\x0b\x81\xcd\xf5\x7a\x52\xe4\x66\xa1\x32\xea\x4c\x5c\x6e\x08\xf3\x00\xc9\x49\xb0\x8a\x5f\x7e\xf0\xc2\xad\xbe\x84\x08\x73\xd5\xa3\x37\xf0\xfc\xb9\xae\x70\x44\xfa\x49\xf9\x77\x9e\xd8\xfb\x41\xf4\xf9\x41\xf8\xcc\x27\xac\xa4\xe7\x32\x2f\x50\xf1\x4e\xdf\xa1\xd5\x04\x43\x08\xf1\xdc\xb8\x6a\xdc\x5a\xf1\xdf\xd8\x35\xa8\x1f\xdd\x41\x40\xcc\xe6\x15\x75\xc1\x04\xe5\xa4\x73\x59\x0b\xfe\x47\x4e\x90\x0e\x9e\x10\x66\xbd\x5a\x15\xb9\x67\x3f\x81\xd3\x24\x60\xea\x54\x91\x3c\xc7\xcf\xdc\x65\x23\x4e\x28\x81\x3a\x17\x77\xf3\x68\xa3\xf3\x8a\x6f\x7e\xfc\xe1\x06\xc5\x4b\x79\xa1\x72\x03\xf1\xe7\xaa\x5a\x2b\xa7\x31\x0e\x37\x7d\xb3\x06\x29\x68\xb6\xb6\x92\x9b\x9f\xca\x61\x37\xc7\x6c\x5f\x04\x71\x1f\x77\x4c\xbc\x5d\x4c\x0f\x1f\xfa\x07\x67\x51\xbd\x06\x7a\xd6\xfd\x57\xcc\x0f\xeb\xc9\x48\xbc\x60\x2a\x24\xcf\x4f\x64\x5d\xab\xe5\xaa\x8e\x17\x91\x07\x0e\xa7\x6b\x0a\x2c\x98\xc6\x1a\x8a\xd7\x4d\x57\xa3\xd9\x8a\xb7\x37\xb9\xe8\x25\x48\x2a\xb0\x35\x17\xd2\xa8\x8c\xd6\x35\xcc\xb8\x87\x8a\x8f\x2a\x0c\x3b\x0a\x7a\x4c\xae\xf6\xd7\x6e\x97\x86\x13\xc5\x96\xf3\x5b\x7a\x77\xa5\x9d\x94\x1b\x98\xbb\x8e\x70\x03\xb6\xb8\x9d\x80\x65\x42\xed\x94\xdf\x79\x52\xef\x83\x94\x49\x13\x94\x16\xee\x68\x5d\xf7\x42\x6b\x3a\x4f\x35\x21\xd1\xc2\x8d\x23\x99\x83\x2a\xf9\x8c\xeb\x69\x57\xe3\xee\xa8\x7e\x57\x2b\x5b\xa0\xda\x62\x3c\xba\x56\x4e\x25\xf8\x67\x28\xa9\x06\x70\x2c\x54\x89\x82\xad\x32\x53\x65\x9d\xcf\xb6\x9c\x77\x61\xdc\x56\xca\xab\x1c\x60\x58\xda\x74\xf1\xba\xf9\x11\x08\xcf\xfc\x0d\x38\xd4\x2e\xf6\xd2\x18\xe2\xfb\x8f\x29\xb1\x98\xb4\x02\x16\x34\xef\xd2\xe7\xef\x7f\x2f\xce\xd2\x98\x9e\xc0\x60\x9a\xeb\x8b\xf3\x99\xfb\xb7\xbc\x29\x07\xa4\x65\xce\xd4\x4a\x95\x99\x2a\xa7\xf9\x3d\x08\x30\x01\x81\xf1\xb4\x61\xc6\x68\x00\x3f\x0b\xf2\x68\xc8\x35\x40\x5b\x3d\xfd\x44\x5b\xf2\x03\xa7\xd2\x68\x32\x84\x98\xdc\xfb\x16\x7a\xee\xe6\x37\x13\x8d\x15\x41\x00\x9a\xe5\x99\x5e\x4f\x0a\x75\x5a\xe4\xd3\x9b\x5e\x60\x51\x9d\x1f\x1d\xea\x32\x9b\x14\x53\x5b\xbc\xf5\x7b\x6d\xf2\x02\x12\x51\x95\xf1\xf2\x9f\x13\x17\x00\x46\xc4\x0a\x0c\x24\xfd\xc1\x8d\xc4\xab\x17\x93\xbd\x67\x94\x12\x49\xc6\xe2\x8f\x51\x2a\x50\x10\xd1\x55\xe6\x63\xb5\xd3\xfb\x0e\x83\x47\xf5\x97\xa8\x77\xef\x23\x74\xe7\x70\x2b\x0b\x27\x9d\x5d\xae\x59\x2c\x85\xc4\x97\xbe\x96\x43\x2e\xb9\x9e\x45\x94\x5b\x18\x91\x8e\x6f\x7d\x9e\x7c\xc7\xda\xfe\x64\xea\xa1\x33\x9d\xa4\xf9\xd2\xdf\x45\x3f\x24\x68\x6b\x7c\xc9\x38\x34\x03\x44\x67\x04\x27\x46\xcb\x5a\xc9\xc9\x03\xe2\xe1\x1d\xaf\xdd\xc8\xaa\x74\x37\x19\xa0\xa6\x67\x62\x99\x1b\xb8\xab\xc6\x6a\xef\xa1\x38\xbe\x95\x79\x61\xef\xcd\x96\x00\xe8\xfc\x72\x64\xff\x43\x9f\x18\x56\xfc\x13\xb3\x0e\x7e\x0c\x53\xdc\xb5\x82\xa9\x73\x07\x07\x56\xc4\x33\x75\xec\x44\x85\xb9\xad\xc0\x1b\x46\xed\x20\x41\xdf\x4f\xae\xf6\x08\x05\xcd\x34\x05\x6e\x99\xf5\x27\x5b\x37\xc1\x00\xec\xd8\x04\xb0\x77\xb5\x20\x7c\x1f\xdc\x88\x33\x35\xd5\xeb\x95\x15\xe6\xc9\xb7\xc9\x41\x40\x92\x9e\x94\x74\x6f\xe9\x8e\xf2\x9f\xcf\x01\x55\x93\x8c\x7e\x99\xaa\x55\xb5\xcc\xcb\xdc\xd4\xf9\xd4\x4e\x9c\xac\x32\x70\x77\xb3\x8d\x84\x0c\x7e\x88\x4f\x50\xee\xd7\x0b\xb5\x3f\x0b\x49\x63\x74\x39\x10\xaa\x9e\xa6\xe7\x1f\x84\x0f\x7f\x14\x2e\x6e\xe8\x3c\xb9\x26\x43\x51\x87\xe1\xd9\xb5\x77\x87\x69\xd8\x58\x4a\xe5\x63\x02\xa8\xd9\x5a\x28\x44\x4b\xb5\xea\x1d\x1e\x36\xf4\x11\xbf\xc5\xad\x3c\x8c\x72\x6c\x85\xc5\x1c\x3c\xb2\x52\x4e\x75\x1e\xd2\xfa\x40\xda\xc4\x65\x74\x2c\x4e\xf5\x0a\x12\xb0\xa2\x5b\x6f\x12\x4f\x75\x70\x20\x4e\x0b\x5b\x8a\xaf\x8e\x10\xe1\x41\x50\xa7\xd9\xb6\x94\xcb\x7c\x0a\x7a\x64\x42\x24\x1f\x3a\xd1\x3b\x56\x45\xed\xf0\xbe\xe8\x1c\x41\x3c\x21\x3b\x34\x3e\x5c\xcc\x72\xcb\xdf\xeb\x2c\xb4\x07\xce\x9e\x6c\xc5\x38\x9e\xf7\x31\x3a\xa7\xb2\xfd\xe0\x31\x99\x2c\x2d\xe2\x09\x61\x1d\x3b\x26\x6e\x29\xb5\xaf\x81\xb1\x5b\x9e\x4e\x37\x46\x57\x50\x5f\x55\x1a\xb1\x92\x15\x82\xce\xca\xb9\x72\x78\xf0\xf9\x3f\x90\x77\xe9\x8a\xad\xfc\xae\x6b\xa9\x23\xf6\x32\x56\xc3\xf9\x8c\x00\x9e\x01\x36\xf5\x77\xbf\x6e\x2f\x98\x13\x00\xe3\xbf\x6b\x37\x50\xb1\x7e\x7b\x3b\x43\x48\x6a\x6e\xdc\x1c\x9e\xe5\x55\xbd\xe5\xda\xd0\x0e\xfd\xda\x2e\x8a\xa4\xf4\x6b\x2f\xd2\xb8\x0b\x05\x0d\xc3\x6e\x8d\x53\x8b\xee\xae\xfd\x0b\x4d\x1d\x1e\x34\xa7\xbc\x6f\x33\x1c\x2a\x78\x3b\x45\xf0\x0b\xe4\xed\xe0\xe9\xc0\x76\x54\xfb\x4c\x0e\x53\x6f\x34\x83\x51\x8b\xb5\x80\x41\x89\x0b\xc2\x72\x2c\x1f\x77\x6b\x6e\xc4\xae\xde\xb5\xa9\xc5\x44\xcb\xfa\x08\x56\x94\x8f\x0c\x1c\x3d\x29\x17\x02\x48\x3a\xf9\x05\xb3\x26\xb4\x8c\x86\x38\x12\x78\x84\x0f\x67\x95\x52\xff\x50\xfd\x7f\x3e\xf8\x82\x7a\x3f\x72\xc3\x30\x78\xf0\x45\x97\xc0\x35\xea\x14\xc5\x06\x0f\xbe\xe8\x10\xa3\x46\x5d\xf2\x55\x4b\x15\x2e\x1e\x35\xeb\xf1\xb7\x83\x07\x5f\x74\x0a\x0e\xa3\x6e\x99\x62\xf0\xe0\x8b\x76\xee\x36\xea\x38\xf9\xda\x2a\x10\x13\x68\xa9\x42\x6f\x30\xd4\x9b\xf2\x4b\x43\x60\xf5\xe9\xba\xb2\xeb\xcd\xee\x0e\xf3\xbc\xd2\x4b\x72\x5f\x45\xd3\x05\x15\xbc\xa0\x84\x1f\x5d\xef\xed\x33\xfb\xce\x95\x0b\xa6\x8f\x08\xbd\xfa\xcb\x6f\x28\xb8\x1b\x9f\x9c\x3a\xdb\xf4\x55\xa5\x22\x98\x39\x27\x56\xb8\x35\x75\x47\x53\x5d\xf1\xe1\xae\x72\x87\x8e\x52\x4b\x5f\x38\x81\xf4\xb5\xaf\xd7\xd2\x47\x5e\x2f\x7d\x4d\x37\x2f\xc7\x2f\x08\x48\xa9\xdf\x46\xe8\xf1\xe3\xb6\x76\xc5\x3c\xc3\xc5\xff\xc5\xa7\x44\x34\x82\x94\x50\xd0\xc7\x72\x83\xe1\x95\xe0\x9e\x72\xe3\x85\xeb\xb6\x16\xe8\xd6\x59\x6e\x89\x29\x82\xff\xec\x9c\x12\x74\x1b\x1a\x20\xdd\x86\xb3\xf7\x5d\x3c\x66\x5a\x5f\x46\x06\xc3\xc8\x3b\x08\x3d\x90\xb0\xdc\x4f\xde\x47\xd3\x79\x0a\x5d\x37\x5e\x1d\x36\x6a\xb9\xb6\xb7\xd4\xf2\xaf\x98\xcb\xb5\x37\xaa\x5e\x98\xe3\x2a\x88\x47\xb9\x81\x7f\xfb\x8d\x0f\xee\x1d\x36\xab\xfe\xa4\x4a\x71\x94\x52\x7a\xd6\xec\x87\x4b\x60\x31\x6a\xe9\xe2\x33\xf1\x54\x8c\x7c\x22\x34\xdc\x2c\xd4\xda\xdd\x2d\xf3\x9d\x62\x2d\xf3\x55\xb1\x65\x09\xa5\x67\xcd\xb1\x6a\xb6\x2c\x0c\x63\xdc\x32\xb7\x7c\xd3\xd6\x1d\x35\x06\xe0\xf1\xe3\xa4\x1d\xbc\xc8\x4f\xaa\x6c\x59\xd6\x76\xcd\xc2\x92\x21\x93\xe0\x98\x16\xde\x47\x2e\x62\x7a\x33\x40\xd0\xc7\xd3\x65\xd3\x51\x8f\x54\x6c\x6f\xb6\x65\xbd\x50\x75\x3e\x85\x8f\x7d\xa4\x1a\xf1\x53\xf4\x35\xb4\x97\x4c\x5e\xd3\x1b\x00\x1c\xda\x44\xe6\xdc\x9a\xbc\x0f\x5d\x78\xd3\x9f\x2e\x64\x39\x57\x46\xa8\x0f\xa5\xf7\x64\xd9\xe3\xe4\x66\x3e\x88\xd9\xb5\x53\x1c\xaf\x56\x45\x3e\x45\xd0\x2b\x8c\x0c\x0d\x4e\x8d\x51\x28\x33\x80\x1a\x5c\xb8\x54\x08\xde\x95\xc7\x0f\x70\x2c\x11\x62\x5c\xab\x3f\xfd\x70\x87\x0d\x42\x63\x07\xbe\x05\x03\xa0\x10\x44\xc2\x1a\xdd\xd6\x70\xdf\xc0\x8f\x5f\x7e\x11\xbd\x75\x79\x53\xea\x4d\x89\xc8\x55\x3d\xaf\xd1\x1f\x4e\x91\xbb\x5e\x21\xe6\xfb\x51\x1b\x43\x81\x75\xb2\xd7\x16\x08\x78\xcf\x88\x69\x08\xf8\xe0\x0d\x66\x59\x7b\x91\x73\x74\xb7\xc7\xe7\x09\xa1\x95\xe3\x00\xf0\x0e\x0c\x18\x1c\x45\x5e\x2b\x9f\x94\x1c\x40\xb2\xbc\x15\xab\x67\xc4\x54\x17\x88\xbb\x1c\x74\xc0\xa4\x36\xea\x1a\x67\x65\x2e\xe8\x26\x9a\x0e\x78\x18\xe0\x4f\xe5\x6d\x9f\xce\xd9\x82\x96\xb1\x95\xf5\xf6\xc3\xa0\x39\xf9\xed\x2e\x8e\xd7\x30\x91\xe4\x80\x35\x23\x72\xf1\xe7\x4e\x1e\x77\x28\xf2\xaf\xbf\x8e\xcd\x24\xd8\xe4\xdc\xd8\xc3\x58\xce\x61\xdc\xdf\xd4\x7a\xb5\x52\x59\x3f\xb2\x88\x4c\x2a\x25\x6f\x62\x2b\x04\x5c\x82\xc3\x90\xc9\x32\x13\x61\x30\x20\xe8\x6f\xa3\xed\xbd\x4e\x16\x85\x2a\x04\xa8\x24\xc8\x5c\x6e\x5f\x92\xe6\x23\x2f\x21\x28\xc2\x79\xd3\xdd\xbd\x49\x1a\x7d\x7b\x97\xbf\x1f\x34\x67\xe3\x5d\xfe\x9e\x9f\x8e\x4d\xdb\x48\x18\x49\xea\xe5\x67\x7c\xba\xe5\xbb\x7e\x0e\xbb\xd6\x0f\xf3\x85\xe9\x5a\x2e\x2d\x9b\x04\x2e\xa5\x5d\x2b\xdb\x4e\xd8\x71\x7d\x55\xad\xd5\xc5\x72\x85\xc0\x8c\xbe\xe2\x39\x8f\xa6\x97\xe2\x11\xe2\x98\x3c\x0a\x0a\xd3\x7d\xca\xe2\xe0\x21\x64\x6a\x72\x7f\x2f\x83\x8d\x18\x34\x55\xd3\xe9\xda\xb1\x55\xca\xd4\x80\x0c\x57\x57\x0e\x53\x5b\x83\x7f\x63\x05\x19\xd8\x5c\x8c\xd2\x05\x0f\xbf\x41\x3d\x08\x84\x10\x7e\x25\x8c\x2a\x8d\xf3\x30\x77\x16\x5c\x04\x84\x46\x34\x7c\xb6\xc3\x45\x7f\xb2\x9e\x4c\x0a\xbb\x65\x6b\x2d\x6e\x94\x5a\x85\xb8\x29\xf0\xab\xff\xca\x59\x98\x20\x48\xc1\xd8\x4e\x28\x09\xa8\x2d\x4e\x55\xed\x86\x81\x60\x3c\xc8\x21\xb2\x56\x25\x68\x3b\x6d\x9b\xa8\x41\x2e\xc7\x57\xa6\x24\xc4\x40\x41\x9b\x1a\xc3\xa6\x82\xda\xdb\x59\xa6\xbf\xfa\x48\x68\x32\xa1\x21\xe0\x8d\x84\x5f\x76\xb7\xc3\xbc\x9c\xb3\xae\x0d\xe3\xc9\xda\x79\x3a\xee\x34\x83\xcf\x04\x22\x14\xdb\x2f\xb2\x71\xe3\x93\x96\x1b\x31\x07\x6f\xdc\x0a\x55\x5c\x4f\x86\x91\x72\xfe\xd8\x17\x35\x80\x4b\xee\x33\x04\x9a\xda\x25\xee\x01\xcf\x6e\x5d\x05\x66\x2f\xf2\x92\x0e\x79\x44\x60\xd0\x25\x85\x77\x81\xa2\x28\x18\xee\xec\xca\x00\x5f\xd3\xa5\x5a\xea\x6a\x0b\x41\xf3\xf6\x1a\x0c\x51\x01\x96\x2f\x80\xaa\x15\x8f\x5c\x1f\x07\xbc\x36\xc2\xc8\x69\x95\xcf\xf2\x29\x66\x20\x3a\x7e\x75\x01\x78\x06\x25\xfa\xb5\xbe\xc9\xad\x68\x3c\xa6\xe3\x65\xec\x94\x4a\xd0\xc8\x89\x9a\xe9\x4a\x51\xc6\x91\x95\x34\x98\x9b\x10\x08\x43\xa0\xc3\x57\x58\x0c\xc2\xde\x62\x98\xdd\x01\xad\x05\x07\xdf\x8a\xc8\xc8\x79\x2d\x30\x02\x4f\x87\x0f\xba\x8c\x8f\x63\x29\x8e\xd8\x40\x5f\x94\xb5\xee\xcb\x81\x98\xec\x1d\x8e\xa9\x04\x28\x93\x6d\xeb\x43\xb8\x89\x59\x49\x7b\xed\x46\x45\x76\x86\x2e\xae\xe3\x40\x04\x7d\x41\x8c\x5e\x2a\x0c\xbd\x80\x6e\xa3\x08\x15\xaf\xb9\x5f\x60\xf8\xfe\xfc\xd5\x5f\x3e\x8a\xe3\x32\xb4\xc2\x85\x6c\xda\x79\xa4\x69\x0e\x38\xc2\x71\x53\xa9\x3b\x03\x51\xaa\x0f\x24\x73\x3c\xec\xdb\xbf\xc5\x43\x07\x17\xde\xa6\x2f\x49\xa8\xe0\xdd\xe6\x98\x2f\x37\x58\x43\x3b\x97\x4f\xac\x53\xa5\x73\x8f\xda\x93\x82\x95\x3b\xa0\x72\xf5\xa1\x46\x0e\x8b\x3a\xd8\x13\x5d\x2f\xe0\x38\x01\xf7\xab\xe5\xaa\xde\x0e\xc5\x5b\x14\x86\x47\xe2\xa5\x0f\xa6\x10\x1f\x86\x53\x5d\x4e\x65\xdd\xdf\xee\x21\xcc\xcc\x96\x14\xc1\x18\xf7\x72\x70\x20\xa6\xaa\xaa\x25\x28\x37\x65\x2d\x3e\x40\x40\x4e\x89\xc2\xbd\xe8\x7f\x10\x53\x37\x71\xd2\xa1\xcd\x03\x5f\x40\xa2\xe4\x0c\x05\xf9\x66\x9a\x47\x37\x75\x68\x8f\x2b\xe4\xe2\x12\x30\xf2\x4c\xe3\x86\x15\x86\xab\xb5\x59\xb8\xd8\xaf\x68\x92\x12\x04\x0c\x7a\xc9\x15\x74\x9c\x44\x9f\xd5\x69\xd6\xf8\xf8\xa0\xb5\xd1\x51\x93\x0e\x0e\xc4\xb1\x98\x40\xd4\xa8\x16\x99\x15\xa8\x2b\xbd\x06\x5d\x2a\xe5\x0f\x1d\xdb\xe2\x63\xee\x12\x28\xde\xd1\x37\xde\xbb\x81\xf7\xad\x80\x2f\x26\xa5\xb0\x63\xef\xa3\x13\x2f\x36\x65\xc8\x0a\xce\x89\x47\x7c\x89\x3f\xf2\x6b\x9c\x7c\xd1\x73\x23\x54\x8e\x79\x13\xdd\xdc\x69\x30\x76\x48\xc7\x78\x6d\xe9\xa1\xf8\xd9\xa8\xd9\xba\xc0\x85\xb0\x92\x79\xe5\xf2\xb3\x40\x1c\x12\xdf\x85\x78\x3d\x0f\x1e\xf7\x12\x0e\x2e\x94\x53\xd7\x75\x5e\xe4\xf5\x96\x24\x1a\x34\x15\xe1\xa8\x10\xa0\x18\xe6\x94\x95\x4e\x66\xe5\x7b\x12\x4e\x21\x4c\x7c\x59\x66\x3e\xd4\x16\xec\x6c\xd0\x28\x9f\x58\x49\x7d\x90\x80\x3a\x66\x4f\x63\x5b\x53\xf4\x2d\x0f\x83\x00\x7f\x58\xf2\x14\xc6\x8d\xa6\x24\x60\xa1\xe0\x8f\x0e\x83\xb6\x37\x6c\xbf\xe8\x4c\x27\xc2\x7b\x17\xa3\xbc\x4f\xdd\x87\x23\x53\xb9\x70\xf0\x2a\x6a\x7a\x44\xeb\xd9\x47\xf1\x0e\x12\xa8\xbc\x17\x98\x14\xc3\xe5\xe0\x1c\x5b\x5e\x3a\xc6\x28\x7a\x16\x6e\xca\xc5\x73\x82\x65\x64\xac\xa2\x2f\xab\x6a\x20\xa6\x93\x01\x26\x65\x09\xbe\xaa\xf1\x92\x94\x55\xe5\x57\xa4\xac\x2a\x8f\xef\x18\x2a\x26\x5e\x30\xb6\x82\x4b\xf2\x38\x41\x53\x0a\x94\x1b\xd8\xea\x41\xdf\xe9\x6d\x24\x74\x8f\xfb\xfb\x5a\xd1\xc9\x8d\x5e\x87\x01\x8e\x9e\x9f\xa6\xf5\x42\xe5\x55\x74\xd4\x96\x99\x65\x28\x96\xd4\x46\xe6\x35\x99\x95\xa0\x5e\xa3\x2c\x09\x72\x59\xe2\x9c\xfc\x7f\xe0\xcb\xa9\x5b\xf2\x19\xff\x86\x0b\x54\x2e\x33\x51\x29\x88\x41\x30\xfe\x70\xf2\x87\xf1\x4a\xeb\x62\xe0\x00\x33\x56\xaa\x72\x79\xb2\x12\xcb\xc9\x33\x67\x3a\x49\x2e\xdf\xe1\xfa\x1e\xb9\x09\x0e\x7f\x97\x5b\x38\x73\x9a\x81\x71\x48\x45\xdc\xe3\x32\x7b\x8d\x1d\x6d\xaa\xa7\x1a\x77\x39\x7f\xa1\xe9\x90\xe9\x77\xdc\x05\x99\x27\xc6\x43\x7f\x27\xf2\x43\xc7\xef\x42\x2e\xae\xad\x34\x75\xb5\x9e\xd6\xba\x1a\xd2\x4c\xb0\x4b\x1c\xd3\xc9\xdd\xd1\xab\x37\x7e\x94\xa2\xee\x45\x58\xa7\x3b\xaa\xf7\xd5\x00\xf4\xff\x88\x7c\x7a\xc7\xb7\xae\xf4\xea\x27\xd0\x67\x7c\xf6\xa7\x5c\x50\xd6\xc7\xc3\x07\x3c\x93\x22\xec\x1d\xcc\x37\xd1\xaf\xe5\x3c\x06\x6a\x95\x73\x74\x65\x99\xac\xeb\x5a\x63\xa2\x57\xff\x0c\xb2\x28\xc4\x8f\x30\xb1\x52\xfc\xac\x56\x1f\x6a\x59\x29\xd9\x6b\xcb\x2f\xfa\x0a\xf3\xcc\xbd\xd0\x6b\x43\x81\x66\x68\x7d\x41\x15\x05\x64\x7e\xc4\x06\xb9\x2c\xb0\x25\x73\x81\xa3\xbc\xab\x25\xfa\xd7\x8c\x9a\xcf\x4e\x31\x02\x3a\x79\xc5\x9d\x72\x3a\xdf\xb4\x57\x85\x76\x9e\xe9\x4d\xd9\xf5\x7c\x47\xb5\x17\xfa\xb6\xf3\xf9\x8e\x6a\x3f\xaf\xda\x9f\xc6\x55\xfc\x8c\x3d\x7c\x08\xa9\x52\xcd\xd0\x27\x2f\x7b\xfc\x38\x9d\xe4\xed\x4a\xed\xed\xb5\x26\xa5\x6d\x4d\x3d\xdb\x48\xd7\x40\xe8\x84\x88\x9d\x32\x93\x53\xbc\x08\x26\x9e\xf5\x1a\x8d\xc4\xa6\x46\x84\x2e\xc0\x99\x21\x27\x63\x64\x47\x70\xc1\x8d\xea\xd8\x4b\x40\xf0\x5b\x87\x9b\x09\xc4\x18\xc3\x3d\x20\xa0\x5b\x53\x5d\xd1\x70\x6b\xf7\xc7\x64\x1f\xc5\xbc\x81\x38\xbb\x7c\x01\x2f\x51\x7f\x35\x10\xee\x39\x32\xcf\xbd\x91\xf8\xea\x23\x92\x12\xc2\xa1\x45\x0f\x29\x4b\x84\xa8\xf5\x8a\x34\x88\x9e\x2b\x52\x28\x32\xdc\x39\x50\x6c\xc4\x63\x9e\xa0\x7d\x5c\x16\x76\xe1\x3d\xae\x4c\xcc\x96\x0d\x4b\x19\x62\xa5\x55\x3b\xd6\x13\x85\x87\x56\x16\xb9\x67\x85\x21\x12\xa4\xb8\x05\x57\xb8\xb1\x37\x99\xbb\x2f\x5d\x42\xa8\x9f\x2c\x06\x71\x4c\x03\x04\xe9\xd3\x37\x41\x8c\x77\x2e\x81\xd2\x87\xc7\x00\x0a\x66\xb0\x93\x39\x82\x64\x6a\x77\x9a\x1e\x77\x0b\xac\xc8\xcd\x2c\xe8\x9b\x87\xe2\xaf\x78\x5f\x87\x7b\xbc\x1d\x11\x22\x6c\xbf\xe7\xa8\x4d\x5c\xc2\x2f\x22\x49\x19\xf7\xc5\x38\x35\xf2\x8d\x21\xcd\x7c\x87\x77\xee\x98\x0f\x46\xcc\xe4\xf8\xac\xe3\x97\x06\x3c\xaf\x32\xcc\xf7\x5e\xcb\x68\x91\xcc\xc7\x96\xab\xbe\x55\x55\x95\x67\x4a\x2c\xf4\x26\x1c\xd6\x73\x55\x1b\x3e\x2b\xe2\x64\xeb\x88\xd1\xde\x19\x44\x8a\x72\x3a\x3c\x57\xe0\xe5\x03\xe2\x99\x5f\xeb\x56\x40\x23\xff\x05\xe7\x1c\x9b\x07\x6c\x60\x7b\x3b\xc5\x85\x1c\x9c\x39\x10\x03\x37\x20\x70\x40\xba\x9d\x49\xa1\x82\x30\x60\x67\x75\x1a\xa9\x02\x28\xcd\x14\x65\xfa\x75\xe9\xe5\xb8\xdf\x64\x10\x5c\x82\xf1\xf0\xa9\x43\x86\xfe\x2a\x81\x1b\xbd\xd3\x19\x49\xf0\x76\x78\xe8\xce\x4f\xb3\xb5\xb6\x7d\xf8\xd7\xbb\x86\x74\x35\xe6\x1e\x76\xdc\xc3\xc6\x4d\x26\x34\xc7\x20\xfc\xa9\xb3\x13\x0c\xc2\xf5\x05\x74\x44\x80\x3d\x1f\x24\xd0\xe1\xbd\x3c\x9b\x5f\x12\x98\xab\x5f\x45\x7d\x35\x9c\x0f\xc5\x98\xce\xb1\xf1\x5e\x1c\x47\xf1\x2c\xdc\x07\xae\x00\xba\x44\x57\x31\x44\x0c\x97\xd9\xe7\x2a\x04\x31\xda\x46\xb7\xb9\xfc\x3a\x5d\xba\xfb\xfe\x21\xdd\xd0\x11\xba\xb6\xe3\xa8\xb6\x5d\x3e\xbb\x7c\xb1\x4f\xb9\xde\xa6\xc8\xc0\xd4\x2c\x2f\x73\x58\xad\xa4\x30\xf1\x97\xf4\x22\xbf\x55\xc2\xde\x8d\x0e\xe1\xe6\xe3\xce\x08\xcc\xe9\x0f\x71\xbe\x13\xc8\x32\x82\x59\x9f\x84\xd1\x10\xd6\x6e\x9b\x65\xec\x45\x95\xec\xc9\xb6\x0b\x43\xff\xc0\x85\x22\x3c\xf4\x4f\x78\x48\x1c\x45\x25\x03\x9c\x97\x15\xa7\xfb\xea\xc3\x48\x68\xc8\x6b\xea\x98\x23\xb8\xe0\x4c\x2b\x04\x7a\x2e\x20\xd2\x78\x2f\xba\x0b\x3b\x7d\x2f\x4f\x5a\x6e\xd0\x32\xd3\x69\x0f\xef\x87\xd6\xf8\x06\x32\x59\xa6\xb5\x71\x9d\x1f\xf5\x6b\xe2\x08\xbf\xdd\x74\x9d\x76\xdf\xe8\x12\xa9\x9a\xfe\xea\x30\x88\x5c\xc6\x4a\x35\x35\xec\xfb\x0f\xfb\x0f\x7d\x13\xac\x5c\x87\xd8\x5d\xa1\x55\xf7\x80\x40\x3f\x77\x27\x24\x44\x4a\xf9\xaa\x38\xff\x92\xf1\x6b\x87\xd0\x3c\xd7\xf6\xee\xed\xd5\xb0\x50\x0d\x3c\xeb\x5a\x1c\xd6\x07\x69\x93\x52\x0f\x76\xe8\x51\x58\xd9\x41\xa2\x39\xc6\x33\xc0\x1d\x6d\x51\xec\xa6\xd0\x80\xbb\xb6\x2e\x41\x4b\xa0\xfd\x89\x4e\xcb\x06\x58\x8f\x97\x10\x30\xa5\x13\x24\xa3\x74\x81\xfc\x89\x7b\x35\xd3\x33\xb7\xa8\xfa\x52\x31\xa1\xe1\xd7\x16\x59\xc8\x98\xcc\xd3\xaf\xe9\x56\x80\xe8\x0b\x98\x2a\xfa\x02\x36\x39\xb6\xe7\x1c\xaf\x4a\xec\x07\x8a\x42\x61\xcb\xe3\x17\x23\x0f\x35\x66\x8c\x72\xce\xdd\x2d\x26\x28\x4c\x24\x8d\x99\xff\x1c\xf3\x4d\xfd\x0b\x97\x72\x6b\xa7\x18\xf3\xe8\x0b\x59\x8b\x6a\x5d\xd6\xf9\x92\xa0\x3d\xb8\x27\x31\x45\x68\x1c\xf9\x20\xc3\x9c\xf9\x9c\xc5\x85\x12\x3c\x5b\x1c\x0f\x1e\x67\x18\x95\x1e\xfe\x46\x03\xc6\x01\x99\x93\x6f\x46\x38\x2c\xae\x15\x89\x8e\x15\x9f\x0f\xd2\xe6\xb6\x26\x74\x0b\x17\x3a\x9a\x9b\xb0\x64\xcf\x4b\x10\x16\x21\x69\x77\x7a\xe5\xb7\x32\x45\x50\x52\xb3\x30\x1b\x67\x15\x19\xaf\x2a\x3d\x55\xc6\x9c\x7b\x7d\x05\x45\x05\x47\x72\x0a\xb3\x91\x53\x67\x7e\xed\x8a\xc5\x36\xd3\x04\x28\x36\x64\xfe\xca\x1f\xec\x78\x5c\x95\xd2\x36\x84\xf0\x8e\xec\xd4\xa6\xa1\x07\xe2\xea\x16\x44\x6c\x8b\xc5\xef\xc8\xf6\x05\xad\xf2\xbd\x6e\x6f\x7b\x63\xc4\xfa\x89\xd6\x82\x32\x99\x8e\x15\x1b\xd3\x5a\x47\x86\x0c\xa2\x01\xfe\xb6\x75\x9a\x7f\xa0\x56\xf6\x2e\x30\x73\x80\x5a\x0e\xb1\x12\xd3\x72\xd2\xc8\x65\x94\x93\x21\x10\x1a\x86\xc3\x88\x9e\x9c\xf3\x81\x0b\x8d\xf1\x96\xca\x58\x3d\x45\xe7\x45\xdc\x15\xd1\xa6\xde\x6b\xfb\xc2\xe0\x5e\x3a\x11\xae\xd1\xfb\xed\xc8\x3b\x35\x88\x37\xd5\x92\x13\x3a\xf6\xaf\xed\xf0\x69\x4e\xe1\xde\x88\xe5\xb5\x74\xe3\xbd\x51\xf6\xc6\xd4\x35\xe0\xe1\x42\x80\xab\x46\xbc\x61\x69\x9c\xe1\xf6\xb3\x90\x08\x28\xba\x55\xb5\x98\x28\x55\xf2\xe4\x15\x2d\xfe\xe7\x70\x9b\xde\x04\xc3\xc4\x5c\xeb\x4c\x58\xd6\x88\x97\x2d\x44\x4e\xc8\x11\xb8\x4e\x73\xe5\x9c\x47\xb5\x03\x40\xc9\x61\x8b\x1b\x48\x13\x4d\x82\x1c\xca\x13\xe7\xd0\x1f\xd6\x93\x36\xbf\x50\x96\x4e\x85\xdd\x0f\x06\x0f\xbe\x60\x82\xe4\x88\x4b\x95\x83\x07\x5f\x44\x3c\x76\x14\x9f\x51\xf6\x35\xe7\x00\xa3\x98\x21\x0c\x1e\x7c\xd1\x98\xa1\x51\x73\xdf\x05\xdf\xca\x8b\xd2\x05\x5c\xc8\x5a\x79\x27\x3d\x3c\xb2\x0e\x0e\xc4\x09\x6e\x3a\x07\x17\xe6\xd0\xba\xd0\xca\xed\xf6\xb5\x04\x5b\x16\xe4\xf6\x05\x9a\xcf\xfd\x73\x4e\xf0\x29\x2a\xe5\x4e\x6d\x31\xfe\xfc\x1b\x7c\xfe\x83\x36\xf5\x6b\xad\xed\x93\x6f\xe1\xd3\xf0\x03\x2c\xf5\x0b\x6d\x6a\x51\x57\x4a\x0d\xc5\xa9\x9b\x63\xc2\x2d\xf4\x38\xba\x90\x0d\x05\xd3\x7e\x7a\x72\xaf\x74\x65\xa5\xd0\x23\xf1\xaf\x87\x68\xb8\x31\xeb\x49\x42\xc6\x2e\xc4\xb2\xb6\x47\xae\xce\x1d\xb0\x6f\x70\x6c\xc6\xcc\x6e\xaa\x0a\x24\x79\xc3\xff\x2d\x34\xfc\x4a\x7d\xb0\x4f\xfe\x48\x5d\x94\x45\xd4\xf3\x7f\x0f\x8f\x7f\xc0\xf5\xf6\x6a\x81\x5a\xdc\x3f\x1d\x52\x5e\x21\x7b\x40\xf1\x2a\xdf\xe1\x8b\xe7\x95\x9c\x2f\x69\xf8\x9e\xd0\x8c\x55\xb2\xcc\xf4\xf2\x47\xb5\x15\x47\xe2\x85\xac\x17\x43\x7c\xd0\xdf\x1b\xd6\x1a\xd3\x59\xf4\xbf\xfd\xe3\x1e\x46\x4d\xf4\xbf\xd9\x3b\xa4\xbb\x29\xf2\x63\xe7\x58\x81\xd5\x7b\xd7\xd7\x00\x6e\x73\x91\xbc\xfd\xb2\x27\xbe\x0e\xdf\x89\x29\xc0\x22\xa2\x6e\x98\x98\x4c\xf4\x2a\xa5\xc1\x4f\x01\x35\x95\xd3\x85\x02\x81\xdf\x8a\xf5\x5f\x3e\xed\xdb\x29\x26\xc1\xc1\xdf\x3a\xec\x5f\xef\x5a\x1a\xfe\x5e\x1c\x09\x57\x9e\x9f\xe6\xdf\xe7\xb7\xa0\x6a\x0a\x70\xcc\x4e\xef\xba\x50\x62\x5a\x68\xa3\x4c\xed\x93\xd1\x86\xc1\x46\xb3\x98\x7b\x6e\x67\xf2\xb4\xe1\xbe\x26\xc0\x19\xa5\x86\xa4\x4a\xc9\x6d\xf0\x14\x09\xa7\x1e\xa9\xfd\xd0\x0f\x97\xc0\xb8\xb5\x2f\xe9\x55\xa1\xab\x1c\xb7\xf4\xbe\x95\xc5\x8d\x58\xaf\x30\x67\x43\xa5\x14\x01\x95\x6c\x94\x98\xe5\x25\x78\x9c\xb8\xe6\x8a\x0d\xa0\x35\xfa\x6e\xb8\xdc\xbb\x30\xfe\x99\x3f\xf7\x64\x45\x62\xd6\x3b\xf8\x0e\xb2\xeb\xfe\xc3\x3b\x1b\x4d\x15\xc9\xb6\xea\x2e\x68\x2c\x6b\x34\x16\x78\x19\x25\x5b\x2e\xc9\x2b\x3b\x7e\xdf\x9a\xb6\x00\x90\xbf\x57\x8e\x63\xe3\xd6\x05\x56\x0f\x34\xb8\x41\xdd\xc5\xcc\x48\x82\x83\x82\x61\xe9\x03\x28\x76\xa0\xb5\x2e\x97\x7a\x5d\x82\xff\xd2\x4a\xd7\xaa\xac\x73\x59\x14\xdb\xbd\x61\xac\xae\x0d\xf0\x3c\x1f\xdd\x98\x43\x3a\x36\x5a\x40\x1c\xd5\xd0\xb9\xb2\x52\x77\x3a\x27\x0e\x82\x10\xe0\x92\x48\x6a\xfc\x98\x95\xfc\xf2\x8b\x68\xbc\xbd\xf2\x2e\x08\x0e\xa1\x1f\xb6\x0b\xa9\x4b\x41\xe7\x49\x6e\x63\x13\x45\x71\x81\x6a\x65\xdb\x57\x69\x5d\x47\xb7\xdf\x1c\xb6\x09\x83\xa5\x39\xc4\xe1\x7b\xfc\x18\x1b\xb5\xab\xf1\x7b\x87\x6e\xba\xfc\x54\xeb\x55\xb0\x00\x85\x31\x09\x1f\x09\xf2\x36\xbd\xbd\xf7\x16\x6d\xdb\x9a\xed\xfb\x12\x83\xaf\x9c\xc6\x48\x57\x28\x20\x12\x02\x06\x34\x78\x43\xf2\x03\x71\x70\x02\xf6\xc8\x0d\x45\xb0\x35\x76\x71\xba\x7d\xbf\x7c\xca\x36\xf0\xa7\x4e\x33\x77\x6f\xf8\x15\xd3\xde\x98\xc1\xc6\xfe\xe8\x58\xb1\xc9\x8b\xe6\xf0\xdf\x7f\xa4\x63\x1e\xaa\xab\x4a\x99\x95\x2e\x33\x0a\xff\x74\xd3\xd8\x1c\xcf\xd4\xcd\xf6\xcb\xa7\x6c\x64\x7e\xbb\xed\x20\x30\x95\x50\x6e\xc4\xdf\x5c\x7c\x2c\x28\x8b\x70\x11\x20\xa0\x77\xa9\x37\x00\x70\x2b\x8d\x59\x2f\x95\x47\x72\x24\x50\x6e\x80\xc7\x07\x01\x63\xca\x07\x03\x45\x0e\xf5\xa1\xb9\x95\x62\x6d\x99\x67\xc9\x04\x51\x8f\x0e\x54\xe0\x01\xe6\x65\xe7\x01\xb8\x5d\x61\xbe\xb5\x52\x97\xfb\x67\x97\x2f\xf6\xc3\xc7\x08\xcd\x0f\xf5\x9d\xa5\xfa\x50\xfb\x2c\x13\x58\x9b\xb2\x6d\xb8\x98\x08\xdc\x87\x4c\x4d\x6a\xd6\x2b\x55\x81\x31\x68\xed\xee\x32\x4d\xa9\xbd\x65\x46\x82\x2b\xbb\x83\xb4\x06\x5f\x76\x6e\x54\xdc\xa5\x94\x8b\x36\x48\xdb\xe1\x95\xca\x09\xef\x21\x80\xcd\x2d\x48\xff\x8d\xf5\x2a\x93\x35\x8a\x02\x40\x9f\xe8\x46\xd6\xca\x3b\xe8\x92\x26\xcf\x0b\xe5\x8d\xd5\x7d\x65\x0f\x83\xb6\x98\xad\x54\x10\x19\xb5\xc9\x26\x28\xab\x77\x1c\xf3\xa3\x1d\x22\x00\x56\x6c\xad\xd1\x64\x37\x58\xb8\x39\x49\xad\x7b\x09\x0b\x77\xce\xcd\xe8\x8e\x99\x1b\x3c\xf8\x22\x1d\xf6\x51\xcb\x44\xe0\x25\x81\xaf\x86\x57\xb0\xf8\xd8\x4e\xce\xb4\xcf\x3c\xe7\x8f\x81\x77\x3d\x5c\x0e\x3d\x52\x39\x79\xc5\xf7\xc5\xcc\xc3\x4a\xca\x20\xee\x6f\x94\x58\xc2\x3e\xdd\x48\xf2\xb4\x90\x79\x21\xf4\x9a\x76\x1e\x5c\xee\xd0\xbc\x83\x56\x17\x30\xb6\x01\xe8\xf4\x46\x61\x1d\xba\x0a\x90\x70\x6f\x44\xbf\x90\x5b\x70\x66\xb6\xc4\xc0\x59\xd6\x51\x72\x66\x43\x4d\x7e\x28\xb8\x99\x80\x3b\xa0\x57\x1b\x00\x6a\xcf\xb5\x77\xb7\x0f\xf2\x09\x29\x3b\x1c\x25\xe0\x0f\xc0\x64\x10\x1b\x55\xd6\x78\xfd\xf4\xf0\x9d\x33\xc7\x51\xc5\x4b\x54\x65\x82\x3a\x9f\xdc\x7f\x0b\x55\x8b\xb5\x71\xb4\x32\xe7\xaa\x02\xb7\x95\x99\x92\xf5\xba\x02\x9d\xde\x47\x27\x89\xc1\xe8\x52\xb8\x0a\xb0\xc5\x87\x29\xd3\xdc\x6b\x3b\x7f\x5a\x04\x80\x8e\x83\xe1\x75\x60\xf2\x85\xde\x28\xe4\x86\x4b\xcd\x04\x49\x3d\x13\xc7\xd0\x87\x93\xf4\xc0\xdd\x82\x65\x33\x47\x4f\x61\x7f\x75\x82\xa9\x68\xb1\x9d\x00\xf5\x53\x20\x7e\x4c\xb4\xa1\xcd\xc7\xa8\xae\x3e\x61\x91\x08\x6a\x55\x2f\x8e\x5d\xd6\x58\xaf\x4e\xad\xd5\x72\x75\x4c\x4b\xed\xf8\x10\x7f\x1e\xfa\xa7\x61\x91\xc2\x13\x2f\xa9\x20\xb1\xaf\xbf\xe6\xb6\x07\x78\x76\xd2\xfa\x81\x13\xfa\xc0\x09\x52\x76\xff\x34\x3e\x70\x12\x7f\xe0\xc4\x7d\x80\xd2\x2a\xd9\x31\x83\x85\xab\x56\x56\x74\x9b\x56\x72\x53\x88\xf5\x6a\x18\x64\x6c\xea\xe4\xbe\x6b\xcc\x5f\x02\x0a\x34\x74\x30\xfa\x22\x3c\xf1\xae\x06\xb6\xe2\xfe\x7e\xf2\xbd\x93\xfb\x7c\xef\xc4\x7d\xef\x38\xfd\xde\x49\xe3\x7b\x27\xfc\x7b\x27\xf1\xf7\xe0\x1e\x92\x97\xa2\xd0\xd3\x1b\xc8\x34\x94\xdc\x43\xc4\xd2\xa5\xbd\xf5\xc3\x2d\x8e\xe8\xcb\x87\x49\x9b\xf6\xf7\x53\xa9\xe9\x18\x0e\x7f\x6c\x15\x89\x04\xec\xd1\x50\x16\x70\x1e\xd4\xaa\x55\x5c\x3a\xe6\x2e\xa0\xbb\x47\x72\x57\xbf\xef\xde\x32\x39\xcd\xb1\x8c\xf7\xca\x49\xe2\xce\xce\x36\x18\xf2\x94\x70\x27\xa3\xdb\x0d\xba\x66\xef\xe7\xa5\x7f\xd3\xdc\x3d\xd8\xbe\x38\x74\x89\x1f\xc0\x09\x8b\x8e\x42\x8b\x72\xe7\xd1\x8e\x57\x29\x79\xab\x2a\x23\x0b\xbc\x33\xd5\x1b\xbd\x0f\xce\x02\x03\x9f\x54\x18\x19\x27\x69\xc9\x62\x1f\xfd\x90\xd9\x12\xa9\xa8\xab\x8d\x06\x85\x06\x19\x44\x67\x25\xa4\xf4\x0b\x3b\x79\x25\x61\xe2\xa3\xcb\x25\xe7\x53\xf6\x3d\xde\x21\x7d\x30\x96\x3f\x51\x1a\x5d\x0a\xfb\x37\xf7\xdb\x36\x87\x0b\x4a\xbd\x08\x86\x95\xfd\x7d\xbb\xb4\x0f\xbd\x2a\xb6\xec\xdb\xf7\x10\x1f\xd3\x73\x39\x92\x7a\xd8\xcc\xe8\x6e\xc4\x8d\x35\x11\xc1\x60\xa9\x89\x68\x51\x30\x46\x44\x8a\x39\xf9\xd0\x00\xe1\xa0\x5f\x9c\x89\x45\xae\x2a\x59\x4d\x17\x90\xc8\x85\x4c\x05\x26\x46\x1c\x1c\x4f\x27\x63\x01\x9c\x77\x2b\x2e\xce\x0c\xe5\xfe\xf8\xca\xd9\x22\x50\xc9\x59\xa9\xa9\x82\x43\x45\x8c\x97\x60\x99\xb4\xc2\x11\x3a\x7d\xc0\xef\x9f\x94\xbc\x55\xe3\x00\xc9\x05\xc2\x7a\x48\xd2\x64\x3f\x1b\x67\x0f\x20\x55\x7e\xa9\x64\xd5\xc6\xfd\x5d\x42\x80\x52\x83\x13\xbe\x25\xf7\x48\x95\x60\xe5\x7b\x64\xbf\xfa\xa8\x50\xb3\xfa\x11\x65\x96\x40\x3d\x6d\xc7\x5a\x81\x96\x42\xf3\xfa\xb3\x4a\x2f\x07\xa2\xd6\x7e\xc5\x3c\x87\x07\xb2\x9a\x5f\xe9\xb0\x78\xa8\x29\x47\x68\x24\x7c\xfc\xd8\x9e\xde\xcf\x3a\x8f\x12\x47\x73\x4f\x8c\xa2\xd4\x7d\x76\xc6\x2c\xf9\x74\x19\x82\xc3\x20\x87\x87\xb0\x04\x02\x47\x61\xa1\x5e\x1f\x7d\x19\x68\x88\x65\x44\xd8\xb4\x1d\xa5\xed\x97\x3d\x9f\xa2\x2e\x04\xc6\x15\x74\x25\xa1\xcc\x43\x96\x35\x80\xd5\xbc\xcf\xc7\x5c\x17\x71\x27\x41\x3f\x08\x0c\x14\xfb\x1d\x76\x92\x7f\xf7\x91\x8d\xce\x95\xbe\x73\x6c\x6a\x7d\xc7\xc8\xd4\xfa\xfe\xe3\x72\xcd\x07\xa6\xd6\x6d\xc3\x72\xdd\x3e\x2e\xd7\x9f\x31\x30\x57\x1a\x87\xa5\xd6\x34\x28\xb6\xa9\xfc\x30\xd7\x7b\x0d\xe8\xde\x84\x17\xc0\xd8\x76\xf3\x03\xfb\xba\x85\x27\x3c\xe7\x63\xed\x49\x5f\x3b\x8e\x75\xa5\x3d\xc9\xeb\x0e\xa6\x75\xa5\xdf\x5d\xb7\xf0\xad\x2b\xdd\x60\x37\x6f\xf4\x92\x67\x7c\x30\xe4\xaa\x6d\x77\x2d\x19\x1a\xb9\x6a\xbb\x81\x88\x65\x5b\xc7\xf2\xbd\x7d\x25\x1e\xc1\x99\x60\x20\xb6\x60\x15\x82\x22\x49\x07\x67\xcf\x78\xc3\xf2\x14\x41\xfa\xcf\x39\x68\x18\xa0\x5e\xc2\x00\x5c\xc1\xe3\x9a\x9f\x15\xe4\x7c\xcc\xa8\xc3\xdb\xb0\xfd\x9b\x58\x70\xc4\xd5\xee\x07\xae\xf9\x2e\xa5\xfc\xfe\x30\x3a\x2e\xef\xf2\xe5\x89\x1c\x1c\x84\x59\x82\x1d\x54\xd5\xc9\x88\xd8\xa9\xb4\x4b\xd2\x0c\x30\x70\x00\x72\x98\xd9\xfb\x39\xea\xe9\xa6\x53\xb5\xaa\x85\xa4\xea\x12\x94\x90\x80\x0f\x36\xe3\xd0\xf1\x18\xec\x35\xb7\xad\xc1\x04\x1e\xf4\x9d\x47\x3e\x72\xaf\x52\x32\xdb\xba\x50\x43\xf4\x03\x7c\x24\xf6\x5d\x9a\xdf\xaf\x40\x0e\x37\xaa\x36\xed\x1e\xfb\x05\x56\x07\x6b\x1a\x80\xb9\x80\xab\x35\x44\x3b\xf8\x6f\x05\x33\xb7\xa5\xe7\x5d\x4b\x7c\xe6\xcc\x83\x3c\xa3\x84\x9d\xc7\xaf\x2e\x50\xd4\x34\xf9\xbc\x84\x20\x80\xdc\x88\x8d\xdc\x12\x02\xdd\x54\xaf\x2b\x39\x57\x98\xd6\xc0\xd2\xe2\xa3\x45\x09\xcf\x72\x45\x9e\x1f\x3e\xbf\x40\x1c\x20\x18\xa2\x04\x06\xc2\xe4\xa8\xbe\x66\x40\x61\xee\xbe\x48\x81\x19\x68\xd4\x2b\xeb\x1c\x07\x21\x89\xfe\x23\xe3\x71\xf8\x80\x02\x4d\x18\xc6\xb0\x40\x38\x8c\x2e\x55\x1c\x05\x78\x25\xe7\xf6\xa2\x3a\x8e\x23\x10\xc7\x38\x62\xcc\x1f\x80\xb9\x70\x42\xee\x15\x6c\x3e\x33\x8f\x41\x70\x8b\xaa\xd4\x20\x0e\x8d\xb1\x47\x31\xc6\x44\x68\x31\xb1\xf2\xb2\xae\x04\xe6\x08\x61\x99\x4a\xc1\x15\x58\x3a\x80\x41\xf0\x0b\x78\xb1\xae\x65\x1d\x81\x6e\xf6\x8c\x58\xaa\xe5\x04\x22\x8f\xbb\xbe\x30\x75\x69\x61\x36\x15\x3a\x96\xc2\x06\x77\xdd\x78\xe4\x52\x22\x60\xfe\x56\x99\x93\x3e\x8a\xc5\xa2\xa6\xf8\x05\x07\x6d\x61\x74\x67\x10\x1b\x0a\xa6\x3f\x16\xd1\x8d\x7b\x8b\x04\x4c\x16\x94\xf0\xcf\x06\x60\xc3\x40\xf4\x5c\x3d\x04\xd4\x32\xcd\xb0\xcb\x5e\x74\x74\x31\x7f\xae\xdd\x1c\x06\xd8\x8a\xbb\x25\x07\xe7\x26\xe6\x28\xd1\x1e\xa1\xdc\xe6\x36\xd1\x52\x32\x20\x00\xd0\x01\xb3\x23\xa2\x79\x37\x49\x5f\x92\xb0\x0f\x52\x2e\x7f\x4a\xeb\x9d\xc7\x04\xbb\x88\x65\x5c\xff\xc5\x96\x81\x03\xd0\xca\xcf\xd8\xb0\xee\x0b\x03\x46\xa3\x1c\xb8\x50\xad\x4c\x6d\xf6\x86\xe2\x27\xf9\x8f\xbc\xd8\x86\xd8\x29\x40\xee\x83\xc0\xb1\x66\xd8\xea\x50\x88\xb7\x64\x80\x81\x64\xa0\xa4\x2f\xb1\xe4\xc2\x6a\x45\xcc\x7e\x55\x59\x0e\x97\xdc\x3a\xfc\xb2\x86\x30\xd9\xb7\xca\xe1\xc4\xb9\xd2\x7c\x63\xc6\xb5\xd8\x2e\x8f\x83\xc9\x88\xe1\xf9\x0c\xb5\xa1\x19\x4b\xb9\xc5\xf8\x32\x38\x0c\x99\x8a\x02\x5c\x91\x3a\xd7\xb2\xbb\xd5\x84\x85\xfc\x06\x1a\xc4\xc3\x6a\xbc\xcb\x4d\x48\xe8\x74\xbf\x73\xc9\x2d\xbc\xc6\x15\x8a\x16\x03\x77\xa5\xba\x63\x7b\x71\x98\x89\x48\x1a\xb0\xa7\xa5\x34\x3c\x8a\xaf\xab\x4b\x63\x0c\x05\x37\x37\xf9\xca\x80\xe7\x36\x4e\x17\xb6\xe1\xec\x93\x47\xe8\xcd\x4d\xbe\x42\x3f\xaf\xdf\x74\xac\x40\x39\xe3\xc7\x25\x60\x4c\x84\x67\x0c\x2f\xdf\xdf\x94\xad\x74\x19\x2a\x3d\x6b\xb9\x46\x87\xd7\xfc\xd6\xd0\x32\x37\x81\xe8\x67\x4f\x0a\x0f\x2d\x77\x69\x6d\x11\xe3\x12\x0f\xce\xca\x21\x59\xfa\x94\xba\x85\xd6\xa8\x4d\xc4\xd1\xc1\x00\xff\x54\x76\x1b\xb6\xcd\x36\x36\xac\x31\xd7\x30\xd5\xf4\x6d\xa4\xf6\xf7\x75\x4e\xd9\x84\x28\x67\x9e\x4f\x40\xf7\x42\x56\x37\xf6\x62\x49\x36\x46\x43\x1f\x89\x4e\xe7\x4c\xec\x58\x22\x8d\x53\x00\x93\xcc\x65\x67\xa1\xa7\xc9\x12\x71\xba\xce\xdd\x4b\xa5\x0b\xc7\xfb\x53\x44\xc6\x76\x44\xe0\xe4\x50\xb9\x97\x8c\xe8\x2e\x2c\xe9\xb1\xf2\xbb\x1c\x2c\xbf\xf1\xd1\xd2\xc4\x40\xe6\x6b\x94\x1d\x32\xa0\x0f\x68\x88\x43\xc8\x39\x00\x87\x96\xd8\x33\xf8\x46\x26\x0b\xe8\x6e\xc0\xa3\xdd\x12\xc5\xaf\xe3\xc1\x5d\x8b\xa5\x75\x99\xb6\x30\x60\xcb\x12\x1a\x1b\xfa\x5e\xfc\x30\xf2\xc7\x6c\x71\xd8\x73\x7e\xac\x77\xf3\xd4\xc4\x34\xb7\xb3\x42\xc2\x7e\x7f\x8b\xcf\x07\x9a\x9d\x0d\x09\x9a\x1d\xd6\xff\xc2\xfe\x1e\x08\xd0\x15\x61\x3a\x78\xd4\xce\xd8\x06\xed\x54\x09\xb5\xcd\xcd\x40\x70\x72\x9d\x0d\x49\x97\xcc\xa7\x8f\x42\xfb\xa2\x4b\xdd\xfe\xe8\x46\xa3\x61\x37\x37\x8c\x8b\xbb\xc6\x74\xb4\x73\xc4\x07\xbb\x2b\x87\xa9\xd8\x4d\x26\x94\x8b\x08\xb6\x4d\xd3\xe8\x8e\x69\x8c\x08\xa4\x83\x33\xda\x31\x70\xc1\xcf\x10\x52\xf6\x96\x35\x3a\x8c\xc5\x51\xdd\xdf\x2b\x4a\xc8\x7e\xa3\xb6\x3e\x42\xce\xa5\x70\x53\x1f\x6a\x57\x17\x38\x50\xe4\x73\x10\x87\xf1\xb8\x78\xa0\x1f\x77\x93\xd9\xe5\x5c\x3d\x57\x35\xba\x3f\x40\xc9\x63\xa8\xac\x2b\x9e\x33\x8a\xf5\xe3\xf1\xe3\x00\x29\x74\x5e\xde\xe6\x95\x2e\x31\xd1\xa3\x2c\x7f\x36\xea\xec\xf2\x05\x73\x58\x78\x55\xa9\x99\x15\xab\x02\x71\xc8\xe2\x50\x96\xaa\x02\xdf\x41\x27\xb6\x2e\x65\xb9\x75\x51\x0f\xc6\xa5\xab\x17\x13\x5d\x2f\x10\x26\x81\x72\x5c\xfe\xf5\x7b\xf1\x67\x4b\xeb\x2f\x4e\xdb\x6a\x28\x75\xa0\xab\x11\x28\xc3\x45\x17\x90\x14\xfe\x9c\xe5\xb7\x7f\x01\xc1\x02\x4d\xab\xd1\x94\xf4\x58\xd3\x7a\x90\x19\xcf\xe5\xad\x74\x7f\x50\x5a\x78\xf1\x2c\x29\x0b\xa9\x42\xe9\x6b\xbd\xc4\x68\x12\x3e\x71\x98\xc6\xbe\x2e\x54\xb1\x52\x3e\x15\x1f\x04\x5d\x19\xae\x0e\x21\xcc\x88\x78\x01\x80\xb1\x02\xd1\xd3\xc0\x4b\xc0\x81\x3d\x40\x50\xeb\x54\x2f\x57\xb2\xca\x0d\xde\x07\x5c\x1d\xba\xff\x00\x26\x01\x60\xdc\x38\x25\x55\xa4\x1c\xbf\x70\xf9\x34\x82\x07\x11\xe0\x4e\x60\x08\x36\xa4\xf6\x46\x53\x7a\xb1\xc5\x3c\xf2\x86\x92\xc8\xeb\x09\xdc\x8b\x2c\x0d\x98\xa5\xbc\x4e\x16\x2d\x28\xfa\x6b\xe3\xea\x8b\x95\x36\x39\xc1\x22\x63\x12\xc9\xcb\x17\x0e\xc0\x87\x0e\x4f\x17\xf4\xb2\x94\x5b\x8a\x9c\x80\x74\xe1\x18\xc7\x15\x04\x73\x6c\x66\xb6\xae\x5c\xdf\x89\xf0\x80\x9c\xe1\x09\xc2\x1e\x3e\xee\x3f\x5a\x6b\xb4\xcd\xd9\x87\x44\x72\x19\x86\xc1\x87\x32\x32\x72\x6f\x6a\x54\xd1\xda\xa5\x7c\x5d\x69\x5d\xa3\x88\x3c\xb0\x3f\x4d\x2d\x2b\xd8\x30\xec\xd9\x8c\x4c\x0a\xe1\x71\x12\x22\xef\x00\xad\x55\xbf\x23\x8e\x26\xfd\xf8\x10\x3e\x0b\x49\xd1\x92\xf2\x87\xad\xa5\x7d\xab\x50\x7c\xb3\x7f\xf5\xf7\x98\xda\x0f\x41\x82\xf9\xd9\x51\x29\xa3\xea\xfe\x5d\x5f\xa7\x8b\xc1\xee\x0f\x76\x97\xe2\x03\xc3\x61\xcd\x38\xf3\x39\x93\xb5\x64\xdc\x66\x37\x91\xc4\xcc\xbf\xbb\xf0\x21\xf7\x65\x84\x06\x1f\xf2\x1f\x10\x7c\x2c\x8e\x76\x75\x2e\x2a\xff\x13\xc2\x71\x1e\xb1\xda\x4e\x91\xed\x22\xa1\xca\x8c\xfd\xe9\xe8\x47\xf3\x41\xef\x3c\x2d\x57\xce\x53\x72\x2a\x73\xf8\x08\x6a\xe3\xf1\xcf\x3f\xf3\x56\xd0\xc3\xa0\x91\x87\x68\x0c\xdf\xae\x77\xf0\x27\x22\x64\xbb\x2f\xd0\xb3\x4e\xa3\x81\x1f\xa9\x65\x5e\x9e\x97\x99\xeb\x27\xb5\x74\x3f\x0c\x20\x34\x4f\x41\x89\xa7\x87\x96\xbc\xf8\xf3\x11\x55\x82\x9f\xbb\x1b\xe5\xe9\xa9\x32\x4b\x1a\x18\xc6\x05\xdf\xde\xdd\x54\x70\xf8\xbe\x92\x79\x81\x23\x29\xfe\x22\x9e\x02\x34\x2a\xd4\x17\xa3\x80\x35\x75\xaf\xe5\xe9\xe7\x02\xfd\xc8\xa1\xb9\x83\xf0\x0d\xbe\x9f\xee\x5a\x78\xc9\x1a\xc7\xf9\xf7\x6b\xbc\x07\x71\x89\x70\xe4\xb4\x6f\xbd\x3b\x97\x39\x78\xbc\x02\x95\xc6\xe9\xd3\x56\xf4\x5d\xd7\x21\xef\x30\x97\x84\x32\x45\x5e\xd6\x08\x50\xb9\x8f\xe1\x90\x23\xf1\x04\x74\xc3\x94\x80\xfc\xad\xac\xca\xe7\xba\x3a\xce\x32\x95\xbd\x54\x1b\x87\xd7\x1e\x10\xea\x11\xbe\xfe\x55\xa5\x3f\x6c\x29\xb6\x05\x60\x4d\x28\xb6\x12\x9e\x27\xb1\x9e\x58\xe7\xfc\xaf\xe7\x2f\xaf\xae\x5f\x5d\x5e\xfe\x74\xfd\xe6\xe2\xff\x9e\x73\xbf\x7f\x34\x00\x9f\x28\x0a\xdd\xc9\x5e\x79\x0c\x07\x71\x24\xde\xf5\xe2\x3b\x4f\x6f\x20\x7a\xec\x0e\x63\x7f\x32\xee\x69\x7f\xe6\xe6\x0c\x23\xee\x29\xc2\x15\xec\x4a\xbd\x36\xf4\x4b\xa0\xd5\xb8\x97\x46\x4f\xfd\xc5\xb2\xc7\x72\xd4\xfc\xaf\x80\x68\x71\x7e\xeb\x50\xfb\x0c\xa5\xd7\x1d\x1d\x1c\x6c\x36\x9b\xe1\xe6\xdb\xa1\xae\xe6\x07\x57\xaf\x0f\xce\x2e\x5f\xec\x43\x2c\xd2\xfe\xb7\xfb\x18\xcb\x72\xe0\x8f\x23\xf8\x7d\xe1\xa9\xe1\x61\x64\xc7\x32\x9c\x3b\x35\x49\xc4\xee\xf7\xc1\x81\x88\xd1\x56\x73\x03\x66\x01\x90\x84\x98\x32\xf4\x50\x94\x1a\x8f\xc9\x12\xb2\x5c\x50\x5c\x99\x3d\xfc\x1f\x88\x98\xc4\x08\x51\xd5\x5c\x74\xcb\x97\x4f\x87\xf5\x42\xd6\xe8\xd9\x61\x5e\xd2\x77\x61\x2c\x41\x12\x0f\x6d\x41\x83\xa0\x09\x0f\xa6\x76\xac\x20\x4d\x0c\xeb\x40\xbe\x54\x6f\x6a\xb9\x5c\x8d\xba\xa0\xa7\x79\x18\xe3\xd0\x17\x17\xbf\xfc\x22\xce\xec\xe2\x2e\xf5\x86\xa0\xeb\x2d\xb9\x2c\x99\xdc\xf0\xa1\xdc\x40\x32\x19\xf7\x88\x87\xe7\xbf\x49\x23\xfc\x64\x95\x66\x47\x8c\x70\x49\x20\x58\x98\x72\x7a\xe4\x70\x8c\xae\x74\x69\x10\x2d\x10\xd3\xc3\xc4\xa0\x1f\x99\x2a\x14\xd9\x80\x42\xbe\x74\x12\x09\x95\x51\xc2\x6c\x0d\x40\x98\x91\xaf\x03\xda\xc2\x0a\x9f\xe2\x46\x17\x04\x25\x55\xa9\x6c\x4d\xb2\xd0\xac\x52\x7f\x5f\xab\x72\x0a\x71\x5d\x73\x59\x4d\xe4\x1c\x84\x28\x06\xd7\x85\x51\xfd\x40\xda\x51\x9e\x2e\xd4\xf4\x46\x8c\x39\xae\x11\x04\x1a\xba\x58\x28\xe5\x23\x9d\x48\x26\xc3\xf6\x87\x78\x50\xc2\x39\xca\x62\xa4\x29\x92\x30\x11\x6b\x91\xc3\x5c\xfc\x6c\xd0\xc3\x17\x5d\x39\x00\xa9\x4c\x7a\x38\xaa\x2c\xa6\x4e\xee\x19\x63\x7a\xed\xd1\x3a\x1a\x93\x03\xf8\x67\x66\x3d\x81\xc0\x2b\x65\xf6\x12\xb4\x17\x7b\x51\x42\x8c\xa3\x6f\x05\x45\xf3\x1e\xbf\xba\x10\x13\x50\x86\x97\x56\xcc\x2e\xf2\x7f\xd8\x86\x3a\x79\xf3\xef\xeb\xbc\xba\x31\x43\xf1\xc6\x93\x0c\xd0\x6a\x96\x47\xca\x2a\x2f\xb6\xde\xa0\xc4\x52\xa2\x3a\x57\x70\xbf\xdf\x0f\xc5\x74\x6d\x6a\xbd\x14\x92\xe1\x47\x7b\x60\x03\x6a\xfe\x54\x96\xe8\x6f\xe9\xba\x00\x56\xb3\x7b\xa6\xda\x3c\x8d\x32\x6c\xba\xdb\x5e\x16\x90\xb7\x73\xd3\x92\x6f\xf3\xab\x8f\x5c\x17\x8c\xba\x29\x9f\x4a\x2f\x32\xa9\x31\xe3\x40\xa3\x29\x8c\x91\x3a\xe7\xce\x28\x4e\x3d\xaa\x14\x63\xe6\x7c\x6c\xca\xb0\xe2\x2a\x48\xf3\x89\x1a\x35\x56\x94\x35\x32\x71\x7e\x6a\x7c\xba\xbf\x8c\x62\xae\x79\xb2\x87\xcc\x01\x25\xe2\xc0\x20\x58\xc4\x0c\x92\xab\x83\x41\xce\x90\xdf\x5f\xa1\xc0\x18\x94\x9b\x21\xa3\x7b\xd8\x78\xb9\x42\x4e\x43\x87\x4a\xf3\xbd\xa9\xf5\x8a\x9d\x2d\x5e\x1e\x85\x97\xc9\xec\x36\x73\x6d\x52\xb9\xeb\x48\xff\x1f\x2b\xfe\xd3\x26\xc6\x17\x06\x9f\xae\x93\x1f\x23\x50\x85\xc3\x97\xf9\x97\x91\x47\xe8\xaa\xd2\x2b\x97\x61\xc6\x97\x88\x3c\x63\xfc\xd3\x46\x02\x17\xaa\x7a\x47\x16\x19\xf7\x8e\x0d\xd8\x3b\x57\xf5\xfd\x21\xce\x19\x45\xc5\xde\x39\x63\xc1\xc5\xc6\x6d\x72\x4c\x00\x41\x2d\x64\x74\x59\xac\x16\x15\x0c\xad\x8c\x9b\x00\x91\x2f\x54\x86\x5f\xdb\xf6\x5a\xc3\x52\x00\x64\xc0\x8d\x19\xa2\x96\xc1\x4c\xf5\x78\x68\x3f\x8c\x7d\xed\x91\xd0\xdb\xae\x76\x2d\xa4\xdb\x1a\x16\xaa\xa6\x7d\x8b\x81\x00\xbc\x1f\x6a\x7c\x32\xc6\x24\x86\x8d\xd7\x84\xfd\x2a\x9e\xed\x2e\x36\x8a\x5e\xe3\x59\x4d\xb7\x9e\x23\x96\xb8\x08\x70\xb7\x93\xba\xde\x18\x68\x87\xa4\x29\x97\x59\x69\xbc\x5b\xf0\xb8\x8a\x73\x9e\xfe\x0a\x4a\xcf\x03\x4e\x99\xa7\xd0\x94\x06\xef\x49\xc3\x87\x0d\xe5\x18\x98\x71\x8d\xf0\xc1\xfd\x98\xa7\x85\x2c\x5f\x03\x68\x79\xcc\x44\x46\x8d\xac\xfd\x8e\x5d\x34\xfb\x15\x32\xff\x78\x18\x0e\xb7\xc1\x1b\x6c\x2b\x20\x1b\xa6\xbe\xc3\x6e\x4f\xfa\x62\x8a\x5a\xc9\x9b\x95\x5a\x77\xe2\xb7\xfd\x78\x4f\x80\x5b\x1c\x4a\xfd\xaa\xb1\x32\xec\x8d\xcf\x25\x2f\xe8\xa5\x64\xa3\x25\x14\x16\x90\x5b\xd3\xbf\x6e\xb1\x00\x4a\x54\xc2\x92\xdb\x86\xfb\x77\x18\xcc\xe4\xab\x69\xb7\x93\xd7\x77\x0d\x27\x8a\xd2\x27\xe8\xad\xdc\x31\x9e\x10\x43\xa2\xc4\x29\x40\x6f\xb2\x90\x7d\x8f\x55\x63\xb9\xea\x23\xc2\xc4\xdb\x22\x42\xe7\x23\xea\xf6\x4c\x57\x81\xca\xc5\x39\xf9\xbe\x91\x38\xeb\x6c\xb4\x5e\x4f\x6b\x9b\x01\x01\x2a\x15\xc9\xf8\x05\x00\xe4\xc9\x32\x0b\x44\x64\xb9\x15\xa0\x0d\x56\x60\xb3\xab\xb5\x88\xfa\x80\x58\x05\x8f\x5e\x80\x43\x0f\x50\x9f\xe9\x75\x99\x3d\x1a\x0a\x71\x1c\x88\xd0\x18\xa0\x1c\xab\x67\xe2\x11\xf5\xfa\x91\x98\xe6\xd5\x74\xbd\x74\xde\x5f\x10\x6e\x63\xd6\x0a\x85\x45\x48\xe4\x68\x34\xef\x90\x70\x62\x99\x0f\x83\x6d\x19\xd7\x38\xb1\x16\x5f\x7e\x9f\xca\x1f\xe2\x05\xe8\x61\xca\xde\x7a\x89\x1a\x90\x46\xd8\x95\x23\xb5\x37\x1a\x92\xb1\x99\x7f\x47\xa1\xf5\x6a\x20\x64\x86\x51\x89\x96\x5c\xbd\x50\xcb\x16\x20\xd8\x38\x97\xa5\x74\xee\x6a\x0b\x5d\x64\x42\x97\x10\xfb\xef\x27\x86\x84\x75\x4b\x6d\x03\x9a\xf5\x89\xb2\x9f\xb0\x97\xa0\x26\xdd\x07\x0e\x1d\x8d\x64\xf6\x4e\xc6\xc5\x2f\x1c\x9f\x35\x50\xa7\x76\xc2\x0d\x46\xde\xf8\x75\xd8\x72\x2d\xe9\x6a\x24\x52\xd9\x95\x42\x3e\x37\x0c\x6a\x8c\xd3\x24\xc8\x53\x01\x48\x0b\x9b\xdc\x28\x06\x0a\xc7\xba\xb5\xf3\x96\x0c\xc7\x43\xdc\xa3\xf1\x2b\xdb\x86\x0c\x60\x21\xc6\xe0\xed\x80\x5e\x6f\xe3\x4c\x39\xb1\x0c\xfc\xe1\x61\xc2\x7d\xd0\x44\x5e\x7b\xd0\xdf\xd0\x8c\x50\xa3\x8b\x95\xdd\x5f\xf8\xbb\xaf\xf8\x27\x98\x68\x42\x36\x40\x54\xb3\x79\x11\x10\x43\x54\x1d\x91\x01\x38\xa0\x40\x97\x09\x9c\xdd\x15\x3c\x43\xac\x37\xcb\xf3\x42\xe1\x16\xb1\x6d\xaf\x35\x03\x7a\x9b\xd7\x72\xb7\xc6\xa8\x3d\x09\x0a\x88\x56\xdd\x95\xde\xe5\xef\xdf\x33\x0d\x77\x2a\xbb\xee\xea\x7d\xa2\x7c\xba\xc7\x10\x24\x35\x00\xff\xde\x77\x7c\xe7\xa7\xe2\xe3\xf8\x9e\x5f\x6b\x54\x4a\x16\xf1\x3d\xbf\x9d\x1c\x5e\xf7\xfc\x78\xb3\x56\xc7\xd7\xc9\x53\x63\xef\xf0\xc1\x83\x44\x8e\xe2\x0b\x3b\xd6\x96\x05\xed\xce\x0f\x68\x71\x0b\xfa\x93\x89\xce\x0b\x55\xad\x0a\x59\x13\xd6\xfa\xd4\xf9\xaf\x06\xad\x42\x7a\x1f\x0f\x58\x89\xb0\x63\x5b\x41\xb4\xfd\xb7\xe1\x3a\x9b\xb4\x54\xae\x01\xd1\x04\x6a\x47\xe8\xcb\xf0\x64\x90\xee\x30\xbb\xa4\xdf\x40\x88\xf3\x11\x09\x93\xf4\xf0\x3c\xaa\xbc\x07\x89\x92\x85\x38\x0f\x12\xa5\x38\xc2\x8a\xe1\xc9\x61\xc0\x79\xf2\x45\x4a\xb5\x11\xe7\x7d\xc4\xbc\x76\x32\x2a\x13\x4a\xa1\x51\x81\x02\xcc\x43\xf2\x0c\xe3\x8f\xc3\x17\x92\xd7\x9c\xc5\x88\x23\x7c\x0b\x5f\xc3\x72\x7c\xe2\xdc\xf7\xff\xf9\x71\x40\x4d\xf7\x6f\xf9\xb8\x84\x8f\x24\x63\x89\x75\xf8\x43\x5b\x54\x66\x84\x33\x8a\xfa\xb3\x2b\x8d\x23\x4d\xd0\xd5\x07\x5f\x7d\x85\xea\x68\x88\x4f\xc7\xa3\xf5\x56\x55\x5b\x4c\xb6\x01\x8e\xd4\xa9\x22\x02\x35\x7b\xa2\x52\x46\x17\xb7\x8a\x94\xd9\x28\x65\xe8\x12\x32\x75\x88\xb7\x6a\xf2\x63\x5e\x7b\x43\x36\xe2\x35\x90\x4f\x3c\x14\x20\xa8\xe2\xa0\xc2\x26\xdf\x75\x4b\x38\xe4\x54\xe9\x7f\xff\xc3\x1f\x9e\x3e\x79\xf2\xf4\xc9\x1e\xac\x24\xef\x22\x96\x28\xd6\xbd\x9d\xfd\x2b\xd4\xdc\xef\x13\x5a\xb3\x28\xf5\xbe\x5d\x22\xfb\x94\xba\x04\x0e\x09\x91\xa6\x56\xc3\x35\x00\x14\x93\xdb\xc9\x80\xdf\xd9\x71\x0e\xf9\xc1\x52\x13\x0c\xb2\xac\xe6\x11\x68\x1d\xbb\xfa\x50\xce\x0a\x57\x92\x78\x07\xfa\x62\xd3\x53\xb6\xb8\x88\x94\x67\xef\x03\xfa\x03\x88\xf0\x2f\xb3\x25\x35\x00\x41\xa5\xb3\x11\xa1\x6b\xfc\xa4\xa3\x56\x85\x8a\x03\x56\x53\xd8\x79\x68\xeb\xa7\x9d\xad\x01\xc2\x48\xee\x45\xe5\xc3\x8d\x1f\x25\x70\x2e\x0e\xf4\xc4\xe3\xc7\xe2\x21\x75\xb5\xf5\xb4\x6d\x53\x99\xec\xd9\x5a\x3b\x8e\xaf\xbc\xcc\xd4\x87\xcb\x19\x95\xb5\x17\xec\xfd\xa7\x69\x9b\x82\x67\xf9\x0e\x83\x0d\x40\xab\x43\xdb\x62\x8c\xfb\x81\x78\x04\xb2\x62\x0a\x0b\x98\x1b\x51\x29\x50\x37\x82\x4b\x26\xba\x2b\x83\x44\x82\x99\x2e\xcc\x50\x5c\xcc\xc4\x56\xaf\x7b\x95\x12\x8f\xc4\xd7\xe2\x91\x51\xca\x45\x04\x0c\xdc\x0b\x94\x55\x85\x84\xe9\x71\xf7\x0e\xe7\x10\x90\x7e\x12\xb9\xea\x10\xa8\xf5\xae\x7c\xca\x7a\x5b\xc1\x88\x12\xf2\xba\x38\x11\x6d\x28\xde\x28\x85\xd9\x34\x17\x75\xbd\x32\xa3\x83\x83\xd9\x64\xb8\x54\x07\x00\xcf\x84\xe9\xf1\xf6\x9d\x1e\xdd\x76\x00\xb2\x7c\x33\xa7\x0b\x9f\x47\x33\xfc\xb7\xd3\xda\x15\xae\x05\xee\xbf\x8f\xd1\x2f\x1c\x5b\x90\x5d\xac\xe8\xe0\x8d\x74\xe1\xbf\xc8\x26\xdf\x46\xe6\x63\x2a\xee\xd0\x6f\xbf\xd9\x55\xd9\xb9\xd7\xc1\x51\xaf\xc9\xff\xe2\x5d\xbe\xd7\x76\x42\x5a\x79\x23\x9f\x6d\xc3\x64\x10\x46\xaf\x93\x3f\x19\xe7\x42\x8b\x12\x89\x9e\x18\x58\x11\x79\x3b\x92\x57\x92\x93\xdf\x5a\x4f\xcc\xb9\xaa\xff\x4a\x29\xb7\x9d\x68\xee\x15\xdf\x91\xa0\x41\xab\xa1\x19\x19\x7c\x6f\x89\x12\x3f\xc5\x80\x6d\x8c\x93\x33\x82\x7d\x12\xcb\x34\x0c\x94\x7e\xb6\xfe\xe9\xfc\x87\x50\x07\x0f\x76\x2c\x3b\x83\xc8\xb0\x80\x7d\x18\x55\xe3\x2f\x30\x9c\xcd\x55\x8d\x59\x32\x1f\x88\xc0\x58\x8c\xaa\xfb\xb7\xb2\xe0\xf2\xb9\x74\x0d\x61\xad\x7a\x26\x7a\x46\xd5\x3e\xe2\x05\x91\xe2\xc1\xed\x88\x3f\x76\x9b\xa2\x77\xe8\x83\x4a\xfa\x92\x3c\x8c\x7b\x0e\x6c\x5f\xcd\x66\x6a\x4a\x0e\x35\xd2\xae\x18\xbd\xea\xc5\xe9\x80\x6e\x65\xe1\x35\xd3\x7c\x7c\xfb\xf7\x68\x25\xfa\x9a\xb5\xb4\x33\x7e\x91\xb4\x14\x3d\x96\xcd\xba\xa8\x1b\x04\x43\x8e\x00\x68\xaa\x6f\x10\x10\x75\x2f\xe9\xd0\x84\xc8\x98\x96\xbe\x23\xe9\xb8\x93\x38\xbd\xcd\x7e\xb6\x55\x64\xdd\x26\x76\x7a\xaa\x4b\x44\x7b\x8c\xb5\x52\x8e\xd9\xa6\xa5\x7e\x13\x4e\x1a\x31\x51\x60\xab\xf4\xe2\x5f\x0c\xc2\x19\x83\x6b\xa0\x63\x83\x07\xb8\x7b\x73\x95\xa5\x5f\x1d\x8a\x7f\x31\xc4\x49\x91\x38\xc6\xb0\x60\x1a\x3d\x80\xda\xcd\xe7\x79\x29\x1b\x58\xa7\x42\x56\x7a\x5d\x66\x03\x30\x44\x92\xd6\x0f\x4f\x8b\xfe\xde\x10\x19\xee\x1b\x32\x6c\x7f\x0e\xd3\x1d\x08\x37\xea\x61\x9f\xb2\x89\xfb\x98\xba\x50\xe0\x6e\xff\x2c\xab\xd0\x45\x94\x4e\x15\x5e\x9d\x46\x02\x2a\x0a\xd9\x78\xa4\xa7\xaf\x87\xca\x31\x52\xba\x40\xf2\xe5\x91\x87\x6c\xd3\x3b\xea\x01\x7e\x18\xae\x98\x46\x29\xc8\x4b\x14\x70\xbd\x3e\xa7\x67\xd1\x3a\xcf\x7d\x82\xeb\x18\xc9\xc1\x8a\xfc\xc9\xb7\x3f\x6b\x18\x53\x27\x32\x58\x7d\x7c\x6e\x98\x5a\xf4\x8e\xd1\x7e\x48\x2e\xec\xae\xc9\x7a\xd6\x28\xdd\x0e\x06\x7e\x55\x6d\xbd\x51\x9c\x14\x68\x0e\x5b\xd5\x4f\x08\x2a\x82\x24\x9a\xa8\xc1\x87\x92\x05\x41\x01\x0e\x78\x0c\xa8\x4a\x4e\xf4\x5e\x9b\xd2\xdf\xbb\xf7\x82\x10\x7f\x4e\x5d\x58\xdc\x12\xd9\xb5\x26\xd6\x66\xd1\xef\x74\xaf\x6f\x1c\xdf\xcd\x81\xb1\x5f\xe8\xa6\xef\xe3\xda\x1b\x45\xfc\x56\xa2\x58\xf0\x30\x75\xad\xc5\x2b\x9f\x7d\xa9\x39\xd7\xde\x37\x3c\x16\x2e\x20\x15\x44\xfc\xe8\x37\x74\x90\xf9\x03\x9a\xd2\xf7\x99\xa3\x13\x3e\xf1\x9e\x33\xa7\xe1\x4d\xab\x13\x4d\x26\x6b\xd9\xf4\x03\xf9\x5d\x8c\xef\xce\x3d\x3b\x0e\x0d\xf9\x9d\xad\xf0\xea\x43\xad\xca\xcc\x34\x82\x4e\x3a\x0c\xed\xe9\x70\x35\xd8\x42\xdc\xf8\xfb\xd9\xdd\x89\xed\xa4\x0b\x03\xd9\x1d\x1e\x69\xbf\xf2\x33\xb0\xf8\x1a\xf4\xb9\x22\xa0\xdf\xd9\xc5\x41\xf7\x1a\xd9\xfb\xdc\xa5\xfa\xcd\x93\xa7\xdf\x1e\xbc\x3d\xdb\x6f\x2e\xd9\x7d\xfb\xea\xe9\xd3\x27\xff\xe6\xd2\xbe\x08\xbf\x88\x21\x01\x56\xb2\x7c\x2f\xec\xb3\xff\x59\xb8\x77\x2f\xdc\x30\x50\xff\x0d\x97\x6c\xe8\xdc\xa0\x6d\x45\xb8\x10\x93\xf3\x97\x67\xd7\x3f\x9e\xff\xe7\xe9\xe5\xd9\xf9\x1b\xcb\xf3\xbf\x1b\x88\xa7\xdf\x0e\xc4\x37\xff\x3e\x10\xdf\x7e\x83\x5e\x14\x57\x72\x32\x20\x2c\xa6\x81\x38\x37\xd3\x81\x78\xb3\x92\x53\x85\x8c\xfb\xea\xf8\xf5\x95\x23\x20\x8e\xc4\x37\xdf\x7c\xe7\x62\x57\x20\xa0\x23\xdd\x26\x56\xce\xd9\x19\xfe\x21\x1e\x3f\x16\xbd\xb4\x16\x38\xba\x6e\xf2\x32\xd3\x1b\xa2\xee\xe2\x2b\x5e\x10\x2e\x2e\xa8\xd7\xe1\xb0\xbd\x9b\x3a\xaf\x1b\x45\x6d\x38\x78\xbe\x88\x74\x23\xa4\xe3\x05\xa0\x58\x7e\x7c\xf0\xe0\xe0\x40\xbc\x55\x93\x9b\xbc\x16\xda\x0a\x06\xf6\xca\x01\x89\x28\xd6\x98\x1d\x74\x5c\xab\x0f\x35\x8c\xfc\x98\xa7\x47\xa0\x34\xc3\xb4\x8f\x2c\x11\x0c\x60\xc5\x70\x85\x4a\x19\x5b\x72\x8c\x01\x18\x58\x1b\x7d\xf1\x2e\xce\x91\x62\xce\x29\xe6\x68\x4a\x95\xc6\xd2\xc1\xef\x0e\x84\xd1\x98\xe0\xb3\xec\xd5\x14\xcb\x30\x64\x33\x72\xe5\x5a\xf5\x09\xf3\x61\xeb\xa4\x13\x01\x2a\xaa\x68\xac\xec\x83\xdc\xbc\xaa\x94\xa9\x35\x28\x87\x11\x73\xf4\xe2\xfc\xbb\xaf\x07\x1e\x44\xd9\xc5\x16\x69\xee\x68\x2c\x5c\x34\x19\xe2\x02\x2a\x60\x54\x1e\xdd\xc9\xd2\x99\x50\x90\x09\x6e\x7d\x7e\x74\x97\x59\x88\x58\xc7\x7c\x6f\x80\xb8\x3a\xad\x87\xe2\x7f\xcb\x95\x2c\x95\x1d\x81\x4c\xe9\x79\x25\x57\x8b\x7c\x6a\x89\x19\xbb\x7c\xcd\x80\xf2\x53\x91\xbc\xd7\xff\xaf\xf5\xb7\x4f\x9e\x3c\xd9\xf3\xd9\x80\x2b\x35\xd5\x55\xa6\x32\x41\xf4\x8a\x2d\x0e\xe3\xda\xa8\xe7\xe4\xaa\xcd\xd6\xe9\x99\x6d\xf1\x7d\x06\xb3\xff\xb0\x63\x67\xfc\xf2\x8b\x48\x87\x33\xfa\xfd\x17\xf1\xa7\xc6\xb3\x3f\x1f\x89\xa7\x4f\xd9\x89\x73\xb9\x52\x95\x84\xa7\xdf\xd8\x81\x28\xd6\x99\x32\xc2\xcf\x5e\x98\x3c\x1c\x69\x6f\x8a\x9f\xe5\x98\x78\x14\x62\x70\x60\x81\xb9\x9c\x1a\xe2\x35\x24\xfd\x2a\xc5\x8d\xda\xae\x20\x81\x11\xe5\xc7\x49\xbc\xee\xc2\xbc\x7b\xc1\x1d\x32\x85\x89\x23\xfa\xe2\x10\x7e\x72\x27\x17\xd4\x9a\x50\xa9\xa3\x23\xd1\x43\x5e\x0f\xba\x4f\xfe\x72\x78\x6b\x2f\x8d\xf6\xe6\x1c\x69\x56\x6c\xb1\x95\xac\x8c\xba\x28\xeb\x7e\x54\xb0\xbf\x37\x10\x4f\x9f\xec\xe1\x30\x04\x11\xf3\xd5\xf1\xe9\xf9\xc9\xf1\xeb\x6b\xe2\x54\xdf\x12\x84\x7e\x78\xfe\xc3\xf1\x6b\x2b\x77\xc2\xc1\x35\x9c\x55\x7a\x79\xba\x90\xd5\xa9\xce\x54\x3f\xaa\x4b\x2b\x9b\xbc\x43\x31\xd7\xb8\xca\xab\x18\xe8\x37\xe8\x1b\x31\xd4\x3c\x24\x69\x85\x24\x7a\x74\x1e\xb3\x5d\x3e\x72\xb0\x6e\xed\xe1\xfc\xa3\x10\xc9\x80\x40\x49\x23\xd1\xd3\xe5\x49\xa8\xdf\x73\x7a\x6f\x07\x78\x94\x16\x70\xc9\x1a\x1f\x30\x2d\x39\x4f\xc9\x36\x12\xef\x7a\xb5\x5e\xf1\x65\x59\x82\x17\x7b\xad\x57\x3f\xaa\xad\x9d\x5e\x43\x3f\x3d\x0b\xa1\xdf\xaf\xa4\xa9\x55\xef\xbd\xf3\xa2\x9e\x46\x24\x3e\xab\x63\x69\x2b\xda\xfa\x16\x97\xb9\x67\xf7\x4e\x8a\x75\x45\xad\xee\xea\x29\xe4\xd6\x6c\xed\xf7\x8f\x6a\xfb\xf3\x8a\xfe\x0e\x69\x38\xdb\xfa\xfd\xa6\x96\xd5\xe7\x4d\xe9\x69\x42\xe4\xce\xbe\x43\xa9\x5f\xd5\x7b\xfa\xce\x6f\xd9\xff\x9f\x01\x17\xf7\xd7\x0e\x00\x52\xb9\x73\x04\xb0\xd8\xaf\x1a\x02\xf7\xa5\x5f\x35\x06\x28\x53\x1f\x88\xab\x4a\x4e\x6f\xbc\x2f\xfc\x46\xf5\x6e\x41\xc0\xad\xc8\x7d\x3f\x13\x32\x70\x53\x82\x10\x84\x13\xc9\x3e\x45\x46\xb1\x90\x06\x44\xac\x1f\x5d\x31\xaf\x34\x4c\xa0\x31\xdd\x47\xa4\x3b\x19\x3d\x61\x2f\x1f\x20\x82\x77\xe6\x33\x9d\x4d\xf5\x72\x29\x4b\xcc\xc6\xec\xd4\xa1\x15\x25\x1e\xf5\x11\xb5\xcf\xf3\x4a\xcd\xf4\x07\x38\x18\x8c\x18\x3b\xaa\x63\x9f\x7b\x4c\x57\x10\x78\x4c\xc4\xc0\x56\xd9\x9f\xae\xeb\x01\x84\x83\x0c\x28\x02\x74\x5f\x02\x04\x40\x3d\x1d\xee\x61\x44\x6d\xbd\x00\x80\xe0\x52\x8b\xe9\x42\x42\x0e\xaa\x0a\xb3\x3f\x19\x55\xf9\x74\xd6\xec\x4c\x71\xfd\x3f\xc5\xcf\x44\x4e\xb4\x5c\xe4\xe6\x2f\x86\xd3\xba\x2a\x7e\x54\x60\xa5\xe2\x8f\x65\x51\xb7\x3c\x5d\xaa\x5a\xfe\xa8\xb6\x7b\xe2\xf1\x63\x8a\x7f\xa1\xda\x08\x25\x68\xff\xb2\xd7\x9b\xbf\xaf\xf3\x5b\x59\x50\x00\xf2\x71\x51\x7f\x5f\x21\xf0\x98\x93\xbf\xd8\xa8\x8a\x87\xad\xad\x79\xfc\xb8\xa5\x35\x11\x52\xda\x55\x25\x4b\x03\x6e\x05\x34\x97\xb5\x5e\x09\x16\x08\x62\x50\x23\x45\xa2\xa4\x3d\x45\x52\x37\x03\x77\xe7\xe2\x09\xc6\xda\xcc\x23\xcd\x74\x1c\x89\x2c\x62\x2b\x46\x69\xca\xe2\x04\xc8\xcd\x37\x2e\x35\x70\x1b\x63\x49\x12\xfb\x86\x43\x70\x98\x32\xcc\xc3\x4e\x4a\x96\x41\xdf\x8b\xce\x39\x06\x50\xb6\x53\xa1\x5d\x7e\x2f\x42\x58\x36\x45\xa2\x01\x38\x50\xbd\xae\x84\x0b\xd6\x13\x13\x65\xea\xfd\xf9\xda\x6e\xb9\xa5\xce\x54\x61\xef\xc3\xe5\x4d\xe4\x68\x96\xcf\x21\x59\x71\x08\x65\xe1\x92\xef\x42\x1a\x31\x51\xf3\x75\xf9\xec\xbe\x93\xd9\x7d\x33\x7e\xd0\xe6\xa5\x96\xee\xa9\x16\xd9\x15\x06\x3f\x49\x4b\xd7\xb5\xd5\x78\x29\x72\x53\x0f\x1c\x33\x5d\xe5\x37\x6a\x7b\x0a\xb7\xa8\xa3\xa3\xf8\xa6\x78\xb8\x73\x4c\xed\x40\xfa\x71\x94\x35\x1f\x4c\x4a\x71\x6a\xa5\x7e\x08\x57\xf7\x7d\xf8\x7f\x38\x7c\xe7\x65\x76\xd7\xe0\xdd\x6b\xe7\xe0\xd1\x32\x0a\x8e\xa6\xc4\xf6\x2c\xa7\x75\x4c\x12\x73\x46\x29\x59\x89\x8b\x17\xe7\x28\xaa\x27\x99\x58\xf8\x85\xde\x9b\xfc\x5b\x26\x65\x0f\xdc\x0e\xf6\x9f\x1e\x36\x1a\xc1\x92\x8b\x43\x33\x30\x75\x26\x7c\xd0\x4d\xa8\x73\x2d\xbc\x51\xdb\x4c\x6f\x4a\xb0\x3a\x6d\x14\x24\x8c\x83\x6c\x61\xf6\x50\x0a\x04\xa6\x00\x0d\x40\xd0\x67\x70\x0b\x54\x1f\x72\x08\xe1\x92\x55\x91\x43\x3c\x1b\xef\x41\xdb\x0a\x7a\xd8\x5c\x41\x69\xb3\xf1\x94\x1e\xc5\xcf\xdb\xb3\xa5\x3b\x39\x80\x77\xf2\xd6\xc7\xee\x01\xa6\x1a\x25\x70\xf4\x78\x53\xc1\x33\xd9\x0e\x44\xd2\xe2\x60\x88\xff\x84\x64\xe6\xdf\x6b\x3d\x2f\x14\xea\x66\xc4\x95\xd6\x85\xb1\x97\x86\xdb\xdc\x5e\xd9\x38\x87\x80\xbb\xf0\x6d\x2e\x85\x14\xa7\x10\x20\x86\x4a\x1d\x4b\xc2\x63\x0c\x8e\x6d\xa1\x71\xb8\x74\xac\xf4\x0a\x71\x5a\x9c\x7f\xc4\x38\x53\xb5\xcc\x8b\xb1\x77\x8c\xa0\xbc\x02\xe0\x64\x64\x84\xbc\x95\x39\x84\x56\xc6\xe9\x09\x5d\x36\x6b\xd2\x22\xd8\x4a\xa5\xae\x07\x2c\x23\xc1\xaa\x90\x08\x62\xdf\xb8\xcd\xc3\xf9\xe8\x6e\xfd\x04\x81\x8c\x7e\xd3\xb2\x60\xd9\x4c\xbb\x42\xd7\xba\xf6\xa5\x03\x2c\x69\x9c\x61\xf6\x02\xfe\xdc\x5e\xda\xc2\x18\x35\xe5\x05\x0c\x65\xa9\x31\xde\x3b\x8e\x4c\xb1\x0f\x9d\xc5\x86\xae\x9f\xae\x64\x72\x39\xed\xd9\xc1\x46\xc5\x11\x14\x48\x42\x4d\xf1\xe1\xd0\x16\x4a\x6d\x68\x1e\x0d\xdd\x09\x89\x00\x27\x4d\x18\x17\x76\x7f\xf1\x51\x34\xb5\xac\xd7\x66\x40\x19\xf8\x86\x14\x1d\x4d\x7c\xa7\x9c\x37\x65\xc2\x30\x46\x6e\x10\x8f\xbb\x95\xf4\xc3\xd6\x94\xae\x0d\x55\xfe\x6f\x94\xdc\xf5\x8a\x39\x12\x3a\x36\x7f\x06\x03\xe4\x40\x1b\x5a\x75\x22\x11\xd2\x24\x9e\x38\xf7\x13\x57\x58\x6c\x0f\x84\x5a\xb0\x71\x8b\x10\xf3\x3f\xe7\x34\x4c\x62\x2f\xa8\x59\x77\x8a\x35\x1f\xe3\x26\x7d\xc6\x49\xd2\x36\x1a\x3b\xa5\xa0\x8f\x6e\x74\x1f\xfa\x62\x9d\x49\x96\xa9\x64\xb7\x72\x8b\xe1\xf2\x5c\xb1\x55\xcb\x57\x6c\x6e\x5c\x1e\x70\xbb\x76\x29\xc4\xd9\xb2\x01\x86\x46\xea\x68\xe8\x5b\x55\x6d\xaa\xbc\xae\x01\x68\x27\x2f\x22\xa5\x9e\x0f\xf7\x23\xd0\x9d\x74\x0e\x3d\x68\x99\x97\x42\x76\x0c\x7f\x98\xaf\x78\xf7\xec\xc4\x54\x69\xc4\xcf\xdc\xe7\x73\xe7\x65\xb6\x17\xc5\xf3\xb5\x2c\x3b\xfb\x1f\xdf\x01\xb8\xa2\x11\xc2\x64\x47\xfc\x9d\x0b\x27\xea\xde\xcf\xde\x14\x1b\x9a\xfa\x89\xc9\x85\x69\x09\xf0\xd6\x45\xd9\xa3\x00\x73\x08\x4e\x23\x87\xb7\x9c\x21\x14\xb1\x17\xdc\x20\x67\x81\x0f\xa0\x48\xdd\x48\xc2\xf2\xc9\x0d\x66\xb9\x20\x18\x7f\x7f\x6c\xe9\x99\xbb\xfb\x74\x9a\xd7\x86\x61\x0b\x00\x8b\x45\x36\xc8\x18\x4a\x12\xd4\x07\x8a\x6f\x38\x12\xe2\xd1\xde\x75\x54\x84\x18\x2d\x56\xd3\x81\xa9\xa7\xa1\x57\xd4\x88\x50\x32\x41\x19\xb9\x1b\xe9\x8e\xc3\x82\x28\x6f\x16\x4f\x8c\x73\x57\x8c\x2d\x98\x58\xac\x15\xaf\x41\x53\x8d\x73\x31\x3e\x41\xb3\x58\xb0\xc3\xcb\xb2\x36\xe3\x5f\x61\x54\x6b\x40\x85\x61\xbe\x7f\x42\x50\xe2\x3a\x4f\x98\xf7\xdc\xc4\xd6\x8b\x40\x2a\x49\x76\x06\x1f\xe4\x0a\xca\x85\xac\xd2\xe4\xd8\x9f\x27\x48\xef\xbe\x38\xde\x7b\x01\x74\x09\x97\x3e\x0e\x47\x40\x2c\xce\x85\x5f\xb4\x0d\x8b\x0f\xca\x93\x5e\xb8\x1a\xc0\x35\x67\xae\x65\x01\xf7\x18\x2d\x96\xf2\x46\x05\x42\x56\xca\xc2\xbc\x26\xcb\xa1\xf8\x41\x6f\xd4\x2d\xa6\x2e\x54\x95\x42\x61\xcb\x49\x4f\x53\x00\xca\xf0\x7a\xa3\x89\xac\x50\x75\x14\x9a\x54\x92\x65\x6a\xe0\x82\x43\x01\x5b\x01\x65\x53\x74\xfb\xf2\x35\x1b\x8d\x0e\x64\x50\xe6\x35\x5c\x59\x03\x97\x10\x70\xba\x9a\xac\x6b\x91\xd7\xe2\x2b\x59\x18\x6d\x8b\xae\x5d\xc6\x0e\x5a\x42\x81\x4c\xad\x61\x8b\x62\x78\x55\xad\x01\x46\xcb\xb5\xc5\x37\x63\xa2\x16\xf2\x36\xc7\x3c\x30\x66\x5a\x69\x14\xb5\x5d\xf2\x28\xa0\xb3\x92\x73\x15\x3a\x19\x9e\x83\x28\x05\xae\xc1\x5e\xee\x16\x5f\x79\xb7\x32\x7b\xf9\x18\xce\x41\xd6\xb6\xbc\xfa\x60\x75\x30\x5d\x54\x7a\x99\xaf\x97\x07\xe0\x7e\x6f\x0e\x50\x60\x7b\x96\x67\x47\xdf\xfe\xdb\xbf\x3d\x7d\xf2\x6d\xdb\x27\xb4\x90\xe0\xea\x13\x82\x03\x51\x2a\x26\x04\x3e\xae\x73\x93\x10\x69\x56\x6a\x3e\xb2\x81\x52\xd0\xcb\xb9\x55\x11\xba\x74\x40\x7f\x81\xdf\x20\xb8\xfd\xc7\x42\x2a\x3c\x3b\x64\xe7\x0b\x16\x82\xbb\x51\x64\xa1\x68\x71\x69\xf7\xf1\x47\x3e\x18\x51\xb4\xa9\x19\xb9\x4b\xb1\xb3\x67\x73\x03\xc9\xe1\x83\x78\x6b\x04\x53\x00\xbb\x4b\x11\x3f\x02\xe1\xd6\x2d\x1d\xe3\x14\x90\x10\x0e\x48\x27\xc4\xd9\xe5\x8b\x21\xeb\xb3\x2d\x6c\x52\xc1\xdc\x49\x89\xee\x18\x9a\x89\xbc\xee\x19\xbe\x82\xfd\x37\x06\x2e\x5d\xa1\xcb\x6e\x1e\x61\xf8\x93\xf6\x35\x90\xca\x6b\x41\xd0\xbd\x7e\x06\x51\xdd\x66\x45\x16\x48\xa8\x96\x2f\x97\x2a\xcb\x65\xad\x8a\xed\x50\x1c\x97\x59\x65\x97\xc0\xa9\x5d\x3e\x2a\x90\x71\xf9\xc9\xe6\x96\x05\xac\x8d\x25\x66\xd7\x9c\x71\x86\x58\x00\x2e\xb1\x9d\x2f\xe4\xf4\xa6\xc8\x4d\x0d\x06\xd9\x30\x89\xd4\xeb\x68\x12\x7f\x38\x7e\x6d\x65\x9c\x74\x82\xee\x3b\xb1\x0e\xca\xc9\x52\xa6\xc1\x4b\x2e\xa6\x07\x07\xe2\xb9\xdd\x6c\x98\x00\x1a\xd9\x17\xd3\x2c\x0e\x08\xc4\x64\x41\xc9\x11\x5b\x3e\xc8\xaf\xb2\x96\x94\xc7\x5f\x84\xc1\x27\x0c\x14\xba\xd0\xe2\x15\x34\x65\x34\x03\x77\xeb\x70\x78\x31\x72\x65\x25\x81\xca\x0e\xb8\x3b\x60\x6a\xc4\x19\x9a\xe9\xaa\xcd\x6d\xe3\x3e\x0a\xd0\xff\x17\xa7\xa3\x17\x88\xa8\x17\x3e\x43\xfb\xbd\x4e\x46\x27\x80\x7f\xea\xd9\x88\xbb\x63\xa3\xe0\xd0\x09\xc8\x8b\x53\x2f\xf3\xf6\x2f\x5e\x9c\xef\xc1\xea\x5e\x53\x66\x4d\xdf\xd0\x5a\xdb\x29\x33\x9a\x50\xa0\xea\x6a\xcb\xee\xe8\x94\xc7\xd4\x92\x51\x19\xdf\xd2\x30\xa6\x35\xef\x30\xa9\x17\x7c\x6b\x9a\x6a\x01\xce\xfa\xc0\x2d\xc0\x7d\x44\xba\xd1\x02\x5c\x64\x49\x29\x3d\x53\x2f\xbd\x41\x08\xa5\xf5\x35\x71\x23\xfb\x36\x90\xe9\xfa\x41\xa7\x0c\x8e\x59\x77\x5a\xf4\x98\x89\xe0\x20\x7e\xf9\x45\x74\x59\xeb\x1f\x3f\xfe\x1c\x65\x60\xd8\xc0\x9c\xdf\x35\x2e\x00\x04\xad\x78\xd8\x7a\x6f\x61\xee\xe3\xe9\x4e\x17\xfe\xf2\xd0\x76\xbf\xbb\x97\xec\x84\xb6\xdc\x51\xc4\x70\xa5\x58\xd9\xa7\x4e\x29\x34\x9d\xae\x2b\xe3\x71\x41\x1d\xef\x1c\x50\x10\xbe\x26\x17\x0e\xd0\x4d\x32\x1d\xa0\x6d\xe1\x50\xbc\x0a\x84\xa2\x90\xe9\x42\x49\x60\x92\x6c\xcd\xb3\x79\x6c\xe5\x77\xf7\x14\xcf\x8e\x21\xb3\xcb\xed\x37\xff\x3e\xf0\x56\xad\xa5\xdc\x82\x65\x2b\x39\xb9\x0d\x83\x7d\xe5\x26\xaa\x40\x8b\x72\xe0\x06\x83\x95\x38\x16\x33\xb5\x21\x6d\x61\x5e\xe4\x75\xae\xcc\xa8\x45\x7e\xd8\x17\x63\x38\xab\xc7\x76\xf9\x8f\x9f\x8c\x87\xe2\xb8\xb2\x83\x75\xa3\xb6\x06\x7c\xaa\xec\x5f\x68\x2a\xbb\xab\x36\x5e\x98\x94\xb1\x5b\x11\x4d\x70\x99\x42\x69\x8c\xda\xdc\x21\x5c\x08\x21\xce\x3f\x8c\x44\x0f\xac\x57\xe2\x6b\x91\x8d\x45\x5e\x8a\x57\xba\xc8\xcd\x02\x3c\x8c\x50\xca\x2c\xb5\x58\xea\x0c\xe3\x00\x82\xdc\x17\x00\x1d\x80\x10\xf0\x32\xb2\xff\x4d\xf2\x92\xa0\x67\xcb\xac\xd3\xb2\xe7\x2f\x85\x9c\x8a\xf3\x64\xc1\xd6\x3f\x7f\x4e\xd6\xc6\xe8\x40\xb6\x9c\x13\x3a\x05\x3a\xe4\xf1\xd3\x27\x4f\xc6\x42\x96\xdb\x8d\xdc\x46\x3d\x7b\xa9\xc5\x38\x72\x8c\x82\x99\x82\x95\xfa\x2b\x06\xd4\x9b\xf5\xa2\x7e\xfa\xe4\xe8\xf0\x65\x84\x2d\x5b\x43\x1c\x99\x1d\xdf\xf1\xe9\x32\xfb\xfa\x74\x3c\xb4\x4d\x6a\x1d\x8a\x01\x0d\x14\x27\x72\x77\xdb\x0f\x98\xc0\xf0\x70\xb7\x61\x94\x0b\x09\x88\x56\x11\xc6\x35\xb5\xe4\xe2\x62\x97\xb6\xfd\x15\xa5\xbf\x92\xa5\x50\x4b\xfd\xb7\x5c\xdc\xe6\x92\xd3\xb9\xd2\x6b\x54\xf8\x4f\xb4\xac\xc0\xfa\xf2\x16\x1c\x7b\xcc\x50\xd8\xfb\x86\xb1\x6f\x25\x6c\xca\x01\x7e\xca\xf6\x3e\xa8\xa4\x39\xa9\x85\x2e\x32\xf6\xa1\x30\x4c\x45\x7e\xa3\xc4\xf8\xbf\xd6\x67\x7f\xfa\xf6\xec\xbf\xd6\x67\xe7\x4f\x8e\xc7\x43\x21\x4e\xc8\x28\x6d\xef\x0d\xe8\x30\xcf\x89\xe5\x46\x7c\x33\x88\xd5\x08\x6e\x72\xbd\x7f\x53\x70\xac\x0b\x1f\x0d\x4e\x5d\x7c\xb0\x92\x8e\x6c\x14\xf7\xce\xf3\xd9\x28\x93\xbe\x39\x9f\x28\xa1\x67\x9c\x18\x1e\xb2\xd4\x98\xf0\x19\xc0\x8e\xe2\x16\x62\xbb\xbc\x13\xc3\x99\x7d\xe6\x82\x03\xfe\x22\x92\x28\xcd\x16\x33\x89\x2d\x1f\x22\x01\x99\xda\xaa\x71\x7d\x68\x25\xd5\xe6\xf3\xd4\xac\xc9\x3e\xf0\x20\xfe\xb7\x9b\x37\xef\xbe\x8a\xef\x70\xa5\x7b\x86\xf8\x51\xa3\x96\xcb\x80\xe8\xb4\xb3\xb4\xc9\xa6\xe7\x5e\xbc\x68\x11\x20\x11\x34\x83\x0b\x65\x03\x31\x01\x2c\x10\x2b\xaf\xe4\x4c\x3a\x86\x04\x0d\x4c\x82\xd5\x91\x0d\x18\xef\xae\x4d\x74\xf5\x16\x45\x7c\x2c\xbd\x36\x55\xf0\xec\x04\xfc\xad\x54\xf0\xe1\x1e\x10\x54\xed\xb1\x1b\xa8\x17\x03\x82\x44\xf2\xc9\xfa\x99\x86\xea\x8d\x11\xfb\x0c\x91\xf6\x30\xce\xd1\xcb\x4f\x16\x54\xab\x20\xe7\x0d\x6c\xb5\x6c\x91\x1e\x48\xc4\x40\x2a\x13\x05\x9c\x30\x1b\x7a\x58\x7a\xdb\x84\x5d\x1a\xf1\x56\xcd\x2b\x9b\xc0\x16\x9d\xab\x19\xb2\xd5\xf4\xe9\x0a\xd8\x58\xa7\xe8\xa4\xba\x5f\xa9\x43\x3c\xa5\x34\x66\xa5\x18\x47\x2e\x81\xde\x2f\x59\xa3\x3a\xf6\x01\xa9\x4d\x3e\x27\x34\xa1\x2d\x22\x21\xe0\x94\x7a\xfb\x3d\x62\xa0\x5a\xa6\xed\xb7\x19\xf3\xeb\x6d\xd1\x45\x7d\xc5\x6c\x93\x79\x49\x97\xef\x81\x78\x23\x67\xb2\xca\x07\xe8\xf0\x8a\x47\x6a\x82\x33\x85\x87\x1e\x48\xa9\xb0\x77\x75\xe9\xe4\xc4\x31\x14\x1f\xa7\x1e\x84\x94\x95\x85\xa0\xef\xc7\xba\x24\xef\x6b\xea\x44\x7c\x75\xcb\x0d\x68\xe3\x7a\x19\x49\x5e\x75\x80\xf6\x44\xa3\x2b\x4f\x49\x40\x58\x56\x5f\xe1\xd9\x11\x9d\xf5\xfe\x88\x72\x37\x65\x5b\x8f\x1c\xc8\x9b\xb8\xfe\x1b\x4c\x4c\x08\x56\x5b\x9f\xff\x0f\x73\x13\x66\x99\xdd\x03\x53\x5d\xd6\x95\xc4\xcb\x1b\xea\x07\xd5\xd4\x8e\xca\xda\x0c\xa2\xc1\x25\xb1\x67\xa2\x4c\x32\xc4\x7e\x41\xe4\x1c\xdb\x9f\x6b\x71\x42\x6e\xc4\xa8\x01\x6e\x1f\x22\x6a\x05\x7d\xbe\x8e\x51\x3a\xfd\x5a\x08\xab\x00\xb0\x4c\x09\x02\x17\xec\xed\x90\xe4\x6c\x99\x63\x8c\xf2\x98\xdd\xfe\xc6\xde\x49\xbc\x5e\xac\x4d\x94\xc3\x00\x13\xf7\x99\x05\xdc\x7b\xd9\x85\xd3\x33\x68\x10\x1e\x2d\x65\xc8\x36\x10\xcf\x24\x4d\x4d\xcb\xa7\x82\x93\x15\xc6\xd5\xa4\x9c\x99\xf0\xd0\xd0\x95\x37\x30\x80\x11\xfb\x1b\x50\x9b\x88\xb1\xe3\x86\x89\x30\x22\x7e\x15\x67\xf7\xfb\xfd\xdd\x6f\x6e\xbc\x1d\xfc\xf6\x87\xd1\xfb\x43\xee\x22\xf9\x33\xe2\x1d\x83\xcb\x38\x4c\x5a\x59\x57\xba\x28\xc8\x72\xa8\xfc\xe5\x12\x61\xe5\x68\x3a\x16\xd2\x38\x06\x0e\xf3\x31\xcb\x27\xaa\x8a\x12\xfa\x87\x2c\x29\xf6\xfd\x6b\x05\x83\xe2\x48\xfb\x52\x68\xc9\xc2\x58\x6c\x40\x47\x81\xdf\xcf\x2d\xb5\x50\x3a\xa2\xcb\x27\x6d\xc1\x5f\x5c\x2c\x57\x45\x62\x18\x85\x56\x05\x6e\x80\xdb\xd7\xe9\x08\xad\x18\x9b\x6d\x4b\xb9\xcc\xa7\x21\x82\x2a\x52\x13\x3a\x52\xd8\x28\xbc\x49\x47\xb4\x50\x90\x6c\xed\x7b\xa3\x69\x61\xcc\x29\x60\xde\x8e\xf6\x95\x87\x0f\x85\xa1\x62\x6f\xfe\xcf\x5a\xad\x43\x34\x4d\x94\xe9\xc1\xbe\x06\x38\xf8\xcb\x19\x65\x49\xaa\xd9\x52\x84\x48\x18\x96\xb5\xd0\xb2\x17\xf2\x66\x04\xe6\x55\x73\xa7\xad\xe0\x5e\x02\x59\x10\x8d\x76\xea\x5a\x24\x44\x89\x4a\x5d\xb2\x6e\x54\x3d\x81\xac\x4e\x43\x4b\x28\xe3\x18\x3d\x8d\xf9\x68\x2e\x42\x14\x35\xad\x47\xfb\xeb\x79\xa5\x97\x2f\xad\x28\x5b\x07\x9b\x2e\xde\x9f\x92\x6a\x6c\x06\x7f\x2e\x21\xd1\x2c\xa9\x89\x03\x24\xe3\x47\x70\xec\x6c\x19\xf5\x10\xac\xd0\x7c\x39\xa4\x81\x0b\xab\x8a\xf2\x82\x44\x81\x0c\xed\x21\xca\xb0\x1c\x61\x51\x38\xcd\x39\xae\x08\xd4\x25\xa3\x2e\x5b\x48\x1a\x12\xe2\xb3\x70\x59\x0e\x5b\xc9\x85\x70\xe0\xa1\x58\x55\x1a\xee\xa1\xf6\x8e\x55\x6c\xd1\x60\x93\x61\xfe\xe1\xc9\xda\xca\x51\xb8\x5f\x86\xe2\x15\xc6\xeb\xce\xf2\x02\x44\x06\x30\x76\xa4\xc1\xce\x0e\xe1\xcd\x89\x77\xb0\x77\x50\xe3\xf8\xca\x3e\xf6\x43\x9f\x0e\xf5\x10\xf6\xb7\x7d\x05\xd3\x71\xef\x31\xdb\x41\x68\xd0\x58\x06\x43\x84\xa1\x82\x06\x86\xfc\x53\xb9\xdb\xf6\x5f\x7e\x2b\x8e\xee\x66\x0e\x7c\x03\xa8\xf2\xef\x76\x6b\x40\x4b\x5e\x63\xfb\xa2\xf5\x6f\x57\x55\xb4\xbb\xb8\xa6\x91\x6f\x2e\x8e\xf6\x19\x9e\x52\x96\xed\x16\xcf\x83\xb6\xd2\xe2\x48\xbc\xc3\xb2\xef\x1b\x9e\x25\xee\x5c\x88\x37\x7a\xed\xc1\x81\x3f\xa6\x19\x5c\xfc\xbe\xbe\x98\xbd\x54\x2a\x53\x19\x4f\xdb\xd4\xda\xa5\x78\x4f\x84\xf4\x92\x10\xe0\xcd\xca\xbb\x65\x02\x23\x97\xe1\x33\x13\x0a\x41\x57\x50\x68\x6d\xe3\x4a\x8d\x2e\x13\x4f\x12\x3b\x99\x91\xdb\xe1\xd1\x37\x7d\x66\xf0\x16\xb0\xbf\xa8\x60\x3b\xbe\x5f\xeb\xf7\xa2\x7a\xef\xf2\xf7\x69\x52\xc0\x5d\xc7\x4f\x5b\xde\x33\xbf\x36\x47\x7c\x99\x0e\x1e\x7c\xd1\xb2\xf2\x46\x6d\xcb\x71\xf0\xe0\x8b\xb6\xd9\x1c\xb5\xce\x31\x82\xe1\xe1\x31\x9c\x09\xc9\x50\x3d\xa7\x68\xa7\x05\x14\x51\xf4\x80\x26\xa8\x1e\x1f\x50\x48\x00\xe8\x0c\xf2\x13\x62\x18\x2d\x9b\xae\x54\x99\xa9\x4a\x55\x43\xf1\x06\x74\x28\xbe\x6a\x2f\x49\xa5\x4b\xda\x56\xcb\x8f\xc0\x0b\xb1\xca\xc4\x4a\x56\xf5\xd6\x12\x2a\xf2\x49\x25\xab\xdc\x4a\xc5\x64\x37\x6b\x69\xd3\x10\xdd\x35\x41\xfc\x24\x6f\xc4\xe3\x57\x17\xa8\x38\x9b\x6b\x21\x6d\x6f\xec\xb7\x2d\x41\x06\xcc\x06\xb7\x0e\x9f\x94\x81\x54\x08\x43\xf1\x56\xf5\x8a\x02\x13\x53\x51\xef\x4c\xbe\xcc\x0b\x59\x01\xd1\x5a\x0b\xbd\xaa\xf7\xad\xf8\xad\x67\x10\x3d\x68\x09\xac\x2d\x83\xdd\xe8\xea\x06\xc3\x00\x48\xff\x93\x69\x61\xb6\xe5\x74\x51\xe9\x52\xaf\x0d\xbc\x1f\xc2\x40\x13\x44\xa2\x09\x72\xcb\x49\x3c\xc8\x1c\x96\x6f\x56\x0e\xc4\x44\xeb\x9b\x1b\xa5\x56\xde\x6a\xe1\x3c\x49\xcb\x3e\x7f\x75\xe8\x0f\xf7\xdc\xbc\x54\xc6\x0a\xcd\x44\x38\x18\x0a\x3c\xe1\x78\x0c\xdb\x3f\x83\x16\x93\x98\x14\x77\x02\x6a\xb1\x2f\xe5\xa5\xc1\x8b\x0b\x1a\x13\xe1\x2b\x03\x6e\xf8\xdc\xc8\xbc\x16\xeb\xb2\xce\x0b\x91\xfb\x6c\x6c\xb3\x75\x41\xb6\xa9\x42\xd5\x21\xd7\x38\x2e\x57\x70\x15\x85\xe4\x33\xa8\x98\xb6\xaf\x80\xa4\xcc\x32\x7e\xb1\x08\xe2\x92\xc4\xad\x0c\x49\xe4\x61\xd4\x99\x7c\xdc\x32\xde\x8d\xce\x3b\x7e\xd6\x32\x8c\xce\x24\x5e\x57\xdb\x58\xee\xbe\x37\x5d\x31\xcb\x4b\xb8\x29\xf9\x71\xfc\x41\x55\xe0\x11\xcd\x86\xc6\xae\xf2\x35\xad\x06\x58\x86\x2e\xf9\xbb\xbd\xd7\xa1\xa1\x3f\x37\x56\x16\xd4\x55\x2d\x4b\x3f\x8e\xb0\xc5\x50\xd3\xc8\x8e\xfe\xa9\x63\x36\x98\x30\x37\x2f\x45\x21\xb7\xaa\x22\xdb\xc4\xc1\x81\xf7\x8e\x98\xe7\xf5\x62\x3d\x01\xc7\x88\x99\x9c\x2a\xdb\x74\x84\xe0\x71\xce\x11\x4f\xff\xf8\xdd\x9f\x98\x78\x0b\x9c\xc0\x89\xed\x28\xab\x6b\xf0\x4f\x6d\xfd\x3a\x79\xef\x75\x2e\xcd\x94\xbf\x86\x43\xe8\xb0\xc1\x49\xbf\x57\xa5\xaa\xf2\xe9\x09\x31\x91\x1d\x42\x7c\x3c\x25\x5c\x76\xbf\x8e\xb7\x80\x3f\x19\x5a\x37\x64\x52\x38\x96\xa5\x03\x97\xfe\x57\x27\x4c\x74\x35\x90\x39\xe8\xa6\xd8\x0f\x0b\x59\x6f\xe6\xa0\x64\xb1\x17\x75\x73\xb0\x51\x93\x7d\xb9\x5a\x99\x03\xda\x5d\xfb\x76\x2d\x1f\x2c\xd7\x45\x9d\xaf\xe4\x5c\x1d\xd4\x0b\x85\xfa\x95\x7d\xca\x60\x38\x5c\xd4\xcb\xe2\x0f\xf8\xc8\x0a\x3d\xfb\xb2\xae\xab\x7d\xb3\x5e\x2e\x65\xb5\xf5\x17\x57\xe3\x30\x1f\xe1\x22\xc7\x03\x50\xa7\xba\xd0\x55\x80\x21\xc3\xa0\x3d\xfe\xab\xce\x97\xec\x49\xcf\x3d\xda\x2f\xf4\x54\x16\xbd\xf0\x46\x2d\x65\x5e\x84\x9f\x4b\x5d\xd6\x8b\xf0\xb3\x5c\x2f\x27\x8a\x7d\x67\x25\x8d\xd9\xe8\x2a\x0b\x4f\x2a\x7b\xcf\x0b\x3f\x8d\x92\xd5\x94\x11\xa8\x55\xc1\x7f\x7c\xa8\xd9\xaf\xa8\x85\xeb\x8a\x15\xdc\x28\x75\x83\xbf\x92\x6c\x7a\x26\x68\x3f\x71\x1c\xfb\x76\x3c\x83\xc2\xb4\xd4\x99\x72\x49\x90\x0b\xb5\x04\x77\xd3\x42\x2d\x87\xfe\x79\xfa\x60\x58\xeb\x9f\xf4\x46\x55\xa7\xd2\xa8\x7e\x70\xa5\x0c\x74\x00\xe1\x11\xfc\x64\x92\xcb\xfb\xc3\x87\x2d\xb3\xf3\x0e\x88\xdb\x09\x7d\x1f\x79\xe7\xc6\xf4\xec\x38\xc8\x4a\xc9\x94\xa4\x63\x58\x1f\x1f\x3c\x48\x23\x10\x82\x4e\xf0\x87\xab\x17\x3f\x41\x3f\xc1\x00\x0e\x18\x83\xa4\xdc\x09\xc6\x12\xe0\xb4\xf6\x35\xdd\xda\x6c\xf1\x07\x3e\xa3\xd7\xf9\x4f\xe7\x2f\xce\x5f\x5e\x5d\xbf\xc4\x78\xea\xa7\x78\x95\xbc\x3a\xff\x0f\xff\xe8\x5b\x7c\x74\x7a\xf9\x82\x17\xfc\x13\x3e\x3d\xbb\x3c\xfd\x99\x3f\xfe\x2e\x79\xfc\xfc\xf5\xf1\xf7\x11\xfd\xa7\x2d\xc9\x4f\x79\x52\x47\x70\x46\xf0\x81\x90\x91\xab\x06\x5c\x73\xa6\x53\x7b\xb3\x23\x77\x0c\x54\x53\x4d\x75\x89\xe0\x95\xd3\x1c\xf2\x68\xfa\x5a\x67\x97\x2f\xec\xe1\xdf\x99\x58\xe7\xd3\x7c\x43\xd2\x74\x36\xdd\xc9\x6b\xe6\xaa\x66\x25\xdb\xe3\x17\xda\xd2\x7f\xb8\x9c\x20\x49\x74\xa3\xa9\xa6\x2e\x01\xe9\x2f\xbf\x04\x00\x0d\x60\xe6\x2f\x7d\x9e\x13\x48\x8c\xba\x36\xca\xe7\x45\x75\x02\xda\x1f\xfe\xf5\xbb\x3f\x7e\xeb\x42\x22\x1c\x18\x29\x73\xf8\xfc\xd9\x28\x22\xef\xf1\xda\xe3\x2b\x47\x57\x71\xae\xdb\x47\x4d\x6e\xb0\xc9\x3b\xe1\xb0\x44\x34\x02\x3b\x48\x46\xf4\xed\x45\x6f\x18\xd6\x56\x6e\xc4\xb7\x7b\xe4\x65\x92\x72\x55\xcc\xc8\xb4\xb4\x15\x2c\x67\xfd\x9b\x39\x40\x92\xd7\x01\x7e\x12\xd8\x26\x8b\x69\xc3\xc6\xfa\xdd\x60\x77\x57\xf8\xd6\x33\xf7\x1e\x33\xd9\xdb\x96\x88\x91\xbf\x53\xd1\x11\xb5\x36\xea\x07\x69\x9e\x2b\x59\xaf\x2b\x75\x1f\x24\x12\x1c\xb1\xa8\x1a\x07\x1b\x49\xf4\x47\x0c\xf7\x21\x79\x35\x5c\x84\xfa\x2e\x86\xd5\xab\x50\x00\x3e\x1e\xf8\x81\x5d\xdc\xa5\xda\x28\xe6\xa7\x25\x8d\x58\x61\xae\x2e\x7b\x90\x97\x99\xac\xb2\x96\x11\xcd\xf4\x72\x08\x5a\x64\x76\x58\xfd\x21\xd3\xcb\xfd\x4c\x2f\xe3\x96\xec\x2f\xa4\x99\x61\x4b\x18\x8a\x4a\x77\x73\xfb\xbd\xde\x40\xf4\x7a\x18\x87\xe6\xd3\x8b\x3a\x93\x85\x87\xec\x97\xcc\x71\xc8\xb3\x4a\x17\xd6\xe4\xa2\x10\x94\x1b\x6b\xa1\xd8\x60\xd3\xe6\x7d\x79\x79\x75\x3e\x42\x2d\x08\xdc\x10\x4a\x5d\xa3\xe8\xee\x6d\xc0\x70\x37\x2c\x75\xb9\x3f\xc7\x33\xdc\x3b\xa8\xd0\x3d\x66\x8c\x7a\xc8\x31\x04\x5d\x8d\xc1\x3b\x67\x3c\x10\xe3\x42\xcb\xcc\xfe\x0b\xba\x95\x31\x5a\x21\xc6\x18\xfa\xec\xcd\x06\x27\xba\xb2\x03\x8e\xdc\xe9\x85\xce\x54\x55\xe6\xff\xa8\xba\x1c\xd7\xe0\xbb\x96\xc3\xbf\x59\xcf\x66\xf9\x07\x42\x7c\x2e\x01\xdb\x50\x0d\xe7\x43\xf1\x68\x5a\xe4\xd3\x9b\x47\x91\xc3\xda\x33\x9f\x90\x80\x22\xe4\x71\xf4\xf0\x72\xa5\xfc\x43\x88\xc2\x8f\x46\x71\xd8\x1a\xf1\xc8\xd2\x1a\xa8\x96\xa1\x6f\x64\x82\x16\xff\xab\xc8\xa7\xaa\x34\x2a\x74\x4f\x7c\x3b\x7c\x32\x7c\xb2\xaa\x94\xe8\xa3\x8b\xb5\x38\x59\xe7\x45\xb6\x27\x7e\x11\x2f\x2e\xae\xd2\x90\x4a\xe8\xa4\xc7\xa5\xee\x27\x63\x30\x70\x1d\x60\x8a\x89\x3b\x50\x56\x7e\xf9\xc5\x77\xfa\xf1\x63\xf1\xb0\xdf\x73\x70\x78\x2e\x0f\x63\x8c\xfa\x93\x1c\x9f\x2c\x58\x8f\x9b\x00\x49\x1e\xe8\xe9\xb2\x27\xbe\x4e\x27\xea\xd0\xe3\xc2\xf2\xc4\x95\xa1\x1e\xfb\x9c\x17\x0e\x1e\xb2\xc2\x51\xe6\x18\x62\xc2\x8c\x1b\x20\xf6\xb5\x93\x55\x7a\x59\x7e\xeb\x10\x58\x9d\x1c\x68\x54\x7d\x5c\xd7\x55\x3e\x59\xd7\x2a\x8c\xe0\x40\xf4\x48\x5d\xe3\xca\xc7\x0d\x74\x49\x61\x90\xc8\x3b\x5f\xef\x7d\x0b\x8a\xed\xc7\xb6\x76\xdb\xf1\x8d\x79\x98\x8b\xcc\x61\x8b\x18\x68\x6d\x16\x4a\x15\xbd\x48\x57\x8e\x31\x84\x80\x20\x5a\x16\x5b\xa7\x82\xa8\x95\x09\xb9\x61\xd0\x71\x52\x89\x31\x54\xf7\xa8\x47\x08\x2a\x34\x6c\xe9\xd1\x7d\xd8\x0e\x1a\x62\x86\xd8\xa2\x81\xe8\x7d\x3b\x7c\xd2\xdb\x4b\x05\x26\x46\x36\x46\xac\xcc\x0d\xec\x2e\x39\x29\x54\x22\x35\x12\xae\xbd\x97\xdd\x0e\xdb\xa5\x49\x2f\x34\x32\x93\x2d\x17\x2c\xdb\x65\x4a\x2e\x42\x02\x8c\x50\xed\x1d\x17\x21\x9f\xcd\x44\x7f\x00\x7f\xc5\xf0\xb8\x92\x59\xae\x7b\x7b\xcd\x54\xb2\x95\x9c\xde\xa8\x0a\x84\xc9\x48\xb7\x00\xf2\xc8\x35\x88\x82\x54\x26\xae\x9b\xa9\x5a\x4e\x17\xcd\xea\xcd\x7a\x5d\x99\x9a\x21\x2f\x93\xd7\x0d\x07\x0a\x76\x94\x6e\x29\x67\x53\xaf\xe7\xf5\xf4\xa1\x00\x87\x1a\x66\xc2\x2d\xf9\x77\xfa\xf9\x80\x0a\x61\x2f\x21\x41\x68\x1e\x8c\x91\xca\x20\x0f\x7b\xb5\x56\x00\x06\x0c\x1b\xbd\xd7\x12\x31\xc4\xea\xc5\xdf\x8b\x1b\xc1\x3b\x57\xdb\x8e\x43\xf7\x2e\xcb\xae\xce\x3d\xcf\x55\x91\x01\x5e\x71\xd2\x62\xdb\x2a\x6a\x20\x34\x0c\x93\xfb\x1e\xfa\x78\x55\x33\xad\xf2\x15\x42\x9f\x92\xe6\x70\xae\x6a\x86\xfe\x7e\xe6\x4b\xf4\xb1\xb3\x0c\x7e\x93\xa5\x65\x08\x8d\xd8\xf3\x09\x21\xe8\x00\xfd\xab\x1f\x7c\xf1\x35\x74\xfc\x5d\x28\xfc\xde\x49\x8c\xf9\x0c\xd2\x10\xe8\x52\x61\x4e\x3d\xf2\xab\x77\x79\x07\x24\x8d\x9c\xae\xbc\x75\x1e\x74\x6a\x13\x99\x17\x24\x97\x94\x19\x69\x11\x61\xb8\xa8\x3c\x9c\xc9\xe8\xe1\xa5\x11\x97\xdd\x6e\x3b\x70\x04\x9e\x91\x01\xd0\x90\x5b\x32\xc6\x9c\xf4\x8c\x98\x60\x1a\xbf\x1a\xbd\xd7\x16\xb2\xca\xc4\x4c\xe6\x05\x8a\x1e\x07\x07\xa2\x5f\x82\x1e\x01\x2d\x22\xaa\xaa\xa5\x95\x17\x94\xa9\xe9\x8a\x63\x56\xdb\xcb\x92\x80\xae\xe8\xea\x63\xdb\x86\xcd\xde\x63\x97\xad\x14\x66\x9f\x0d\xa1\xdb\x6c\x10\x27\xec\xc6\xdf\x4e\x0c\xc2\xf9\x07\x9c\xaa\xd6\x72\xa6\x51\xae\x4d\xbf\xfe\xa0\x2b\x73\x0a\xe4\xf1\x67\x13\xea\x52\x11\xa8\x72\xbd\x54\x84\x2d\xce\xbe\x16\x1e\x23\x2e\x4e\x17\x08\xf9\x5c\xb5\x66\x61\x62\xa1\xcd\xbc\xa3\x01\xd8\xd0\xa9\xbf\x19\x94\x79\xa0\x92\xe4\x3e\x68\x5b\x71\x11\xc4\x7d\x3c\x4a\x1c\x3d\x11\x29\x31\x55\x7b\x58\xc7\xb5\x67\x3c\xff\x74\x3d\x81\x2f\xec\xec\x0e\x6f\x4a\xda\x83\x46\xed\x4f\xeb\x86\x23\x54\xeb\x95\x0b\x4f\x6a\x6f\x4a\x0b\x53\x0d\x03\x01\x79\x2d\x9b\xdb\xd1\xf7\x9f\xc3\xa9\xb5\x71\x6c\x78\xc8\x58\x91\x5d\xd6\xe9\x09\xd0\xb1\xee\xec\x09\x7d\x79\x76\x39\x12\x97\x98\x39\xaa\x67\xc4\xdf\xd6\xa6\x16\x68\x97\xdc\x28\xc0\x31\x5c\xea\x5b\x45\xe6\x5e\x4d\xc7\xc0\xa6\x92\xab\x95\xaa\x40\x9d\xd7\x75\x36\xb4\x33\xcb\xb8\xe9\xa8\x0a\x85\x42\x17\x33\x4c\x42\x97\x25\x3d\x69\x3b\x1f\x9a\xc2\x5b\x58\x19\x69\xcf\x0f\x3d\x5b\xab\x99\xf7\xb3\x2b\xef\x70\x47\x56\x3a\x2f\x89\xeb\xac\x4b\x34\x9e\x52\x8c\x04\x40\x93\x20\x92\xb4\x9c\x4b\xc0\xd6\x2b\x0a\x7b\x67\x98\x2a\xb0\x1f\x43\x1b\x89\xdc\x2e\x15\x8d\x6d\x65\x21\x8d\x5f\x4b\x54\x65\xe8\xd6\x70\xc8\xfb\x5f\xaa\x0f\xbe\x54\xfb\x71\xea\xce\xce\x50\xd2\x72\x19\x4f\xdd\xdf\xd3\xe9\x13\x6e\xa1\x87\xf2\x31\x18\x78\x68\x67\x8b\x26\x29\x86\xb4\x03\xd0\x66\xd0\x29\x2e\x50\x97\xf7\x39\xd8\x5f\x50\xb5\x03\xf0\x0b\xde\x7d\x06\xca\x17\xd1\xc4\x1f\xf6\xf6\x44\x7f\x3f\xd7\xd3\xb5\x43\xf5\xe2\x68\x76\x0d\xf8\x2f\x8f\xf7\xf5\x46\x51\x76\x6c\xa2\x19\x50\xbf\xfc\xb2\x45\x49\xfd\xb8\xcc\x8e\xbd\xcb\x1e\xcb\xa0\x08\x38\xed\x89\xab\x4c\xdd\x86\x97\xd0\xc0\xbf\xfe\xf2\x69\xab\xb3\xe1\x97\x4f\x87\x38\xdc\x03\xd1\x4d\x3a\xa0\x93\x93\x84\xda\xc3\x3a\x3d\xda\x00\xcf\x0b\x39\xe7\x18\x3b\xe0\x96\x21\xd1\x00\xe7\x2d\x31\x4e\x4f\x6f\x85\xee\x1d\xe6\xf0\x5f\xe1\xad\xc8\x62\xc9\x2e\xce\x85\x59\xe4\xcb\x00\x69\x2c\x21\x01\xc5\xb9\xbf\x19\x05\xd7\x95\xe8\x0d\xa5\x38\x26\x5b\xb1\xcb\xcf\x7e\x7e\x7a\x75\x71\xf9\x72\xe4\x9c\x26\xdc\x65\xde\x7b\x18\xb2\xcb\x28\xba\x8b\xfe\x6c\xa2\x49\xdb\xa9\x1b\xbe\xbf\x4e\xb8\x29\xec\x83\x98\x8e\xfa\x02\x10\x13\xda\xd4\xc5\x9e\x6c\x10\xec\x67\x79\x61\xe7\x8e\x73\xcb\xa5\x2c\xd7\xb2\x70\xc3\xcc\x1b\xdf\xaa\x42\x74\x6b\xec\x8e\xd5\xda\x18\xdb\x64\x7d\xed\xd0\x56\xee\x1d\x06\xd7\x5d\x72\xe2\xb2\x12\x56\x9c\x2e\xd4\xed\xfd\x81\xd8\xa8\x5e\x86\xe7\xcb\x24\x2f\x33\x0c\x12\xc6\x68\x00\x89\xa6\x59\x24\x86\x16\x46\x17\x5a\x5d\x66\x68\x28\xcb\x6b\x31\xd7\x10\x7d\xb4\x9e\x2f\xd0\x16\xc3\xc3\xfc\xce\x97\xb9\x15\x16\x87\xe2\x4d\x8e\x47\xd9\x03\x1e\xb6\x09\x66\x45\x1c\xbe\x62\x2b\x0a\x50\x10\xf8\x6b\x27\xfb\x12\x3a\x69\xb9\x3c\xee\xb4\x03\x28\x47\xe9\xc1\x81\xed\x18\xe2\xda\x2e\x94\x90\x13\x83\x2e\xe7\x0e\x97\x16\x89\xa3\x72\x0d\x8b\x3b\x23\x11\x66\x23\xc2\x3c\xf1\x5b\x81\xa7\x50\x29\x74\x95\x61\x42\x1d\x55\x1a\x7b\xa7\x86\x93\xc6\x0e\x84\xf3\x83\xb3\xeb\xb8\x32\xa2\x5a\x97\xce\xb3\x19\x8c\xa7\xa0\xa3\x57\x1f\x6a\x51\x29\xb4\xc5\x8b\x3e\x82\xc0\x7a\xa3\x7b\xa8\x2b\x6b\x2b\x77\xa0\x81\x56\x96\x53\xd8\xc5\x48\x8c\xb4\x01\x86\x45\x35\x84\x20\x08\xf2\xd7\x85\xb5\xb9\x37\x14\x6f\x09\x1d\x09\xe5\xb3\x60\x02\x64\xb1\x7b\x68\x85\x44\xb1\x1f\xb4\x6e\xb8\x06\xc0\x70\x6c\x6b\xfc\xcd\x27\x52\xc9\x6b\x97\x9c\xd4\xa7\x84\x25\x3c\x42\x77\xe0\xaa\x40\x12\x61\x0b\xc9\xe5\x20\x73\x30\xac\x74\xa5\xa8\xd4\x2d\x86\x1d\xd1\xc0\xd0\x22\xf2\xf1\xed\x07\x07\x61\x20\xac\x1c\x53\xad\x4b\xcc\x02\x75\x6f\xb3\xe8\xbf\x3f\xf9\x93\x9d\xcf\xc4\xa4\x5e\xad\x1d\x5a\xc5\x09\x5a\xc1\x1d\xb7\x8b\xbc\x6e\xe2\x42\x3c\xdf\x05\x2d\x2b\x54\x50\x30\x56\x49\xab\x0b\x9e\x83\x43\x0c\xba\x89\x35\xef\xf6\x76\x93\x5e\xcc\xe0\x20\x77\x32\x53\xf0\xd1\x4c\x4d\x08\x2f\x11\xe0\x9a\xfe\xb2\x72\x84\x73\xa0\xfa\xf2\x29\xaf\xe6\x64\x8a\x56\x91\x2c\x90\x4a\xf5\x68\x71\xa2\xf9\x46\x3a\x96\x2b\xff\xfa\xb9\xae\x38\xd7\xe9\x72\x31\x0d\x82\x5f\x7b\xec\x26\x9e\x69\x77\x37\xa2\xeb\x58\xc8\x63\xbf\xf3\x03\x72\xab\x08\xce\xaf\x5c\xcf\x44\x52\xd0\x7d\xf5\xfc\x10\x87\xf5\x9d\x98\x16\x32\x5f\xa2\xb3\x32\x29\xb8\xfc\x66\xf2\x2b\xbf\x86\x9b\x2c\x14\xaa\xab\x7c\x3e\x57\x95\x65\x70\xe0\xcd\x82\x7c\xcb\xde\x0a\x20\x34\x5a\x7d\xa8\x5d\x8c\x79\x3e\x2f\x21\x3f\x0e\xec\xda\x38\x76\xb2\xab\x07\x0d\xbd\xab\xb7\x4f\x02\x48\x75\x2b\xec\x39\xc7\xa8\x1e\x26\xe0\xd4\xdf\x45\x60\x96\x7d\x3a\xc6\xff\x7c\xf4\xdd\x9e\x00\x18\x1e\x83\x42\x27\xc7\x46\xe6\xde\xbd\x1e\x0a\x75\x25\x8d\x51\xd9\x7e\x5e\x3a\x46\x04\xae\xde\x65\x06\xca\x81\xca\x05\x93\xe3\x3e\xf7\x01\x58\xc1\x89\x14\xf6\x73\x96\x83\xbf\xc1\x3a\x37\x0b\x0c\x6d\x73\xb0\xa5\x95\x5e\x5a\x72\x58\x9b\x74\x0b\x96\x0f\xfd\xef\x37\x89\x21\xce\xd8\x26\xbf\x25\x2e\xfd\x5c\x57\x6c\x4b\xf9\xd4\x7e\xe9\xd2\x4c\x85\x94\xe0\x76\xd7\x26\xa4\xc4\x2b\x33\x2a\x31\x44\xe6\x8c\xdb\xa1\xa7\xcb\x78\xbc\x7a\x03\x5a\xb2\x4e\x1b\x80\xcd\xea\x1e\xfe\xd7\xca\xde\xd3\x0c\x77\xbc\x25\x3d\x38\x8b\xe0\xf6\xfe\x3c\xfb\x78\x37\xc8\xdc\xf0\x83\xcd\x03\x31\xc8\x84\xfa\x90\x9b\xda\x34\x86\x4a\xaf\x3a\x46\x8a\xdd\xd5\xa2\x0e\xb6\xfb\x12\xc6\x63\x80\x17\xe3\x4f\x1e\x83\xe6\x34\x38\x87\xc2\x6e\x49\xb1\x63\xdc\x7e\x80\x2f\x00\xca\x5d\xcb\x82\x1d\x08\xa3\x4a\xca\x48\x18\x8b\x94\x22\x9f\xb9\x60\x0f\xd2\x88\xa1\x2d\x05\x1b\xe0\xf5\xfb\x0b\x69\x68\x09\xa6\xc0\xb7\x6d\x5d\x6b\x0a\x72\x69\x78\x9f\x6b\x24\x48\x90\xa0\x5b\x42\x3d\x62\xfb\x60\x93\x2a\xa0\xe5\xc0\x68\x8c\x93\x67\xec\xf7\x93\x32\x9b\xdc\x1e\xfb\x83\xa7\xda\x73\x5d\xb1\x08\x0a\x5d\x6c\x67\x79\x51\xb4\xf2\xfc\x4f\xe0\xfd\x78\x95\x8b\xc0\xaa\x2c\xbf\x1d\xa4\x13\x87\x31\x41\x98\x4e\xcc\xc4\x48\xf7\xa8\x5b\xb4\xff\xcc\xe7\x5b\x9f\x7b\x9e\xc1\x7b\x80\x71\x1a\xbc\xad\x10\x25\xdf\x90\x7e\x26\xc3\xb0\xa1\xa9\x2e\x6f\x55\x99\xc3\x16\x72\xf8\xc7\xb9\x2e\xf1\xc3\xde\x4b\x6d\xb5\x52\x12\xa1\x50\x80\x5c\x5e\x82\x68\x42\xeb\xa3\x52\x4b\x99\x97\xe0\xc9\x25\x8d\x32\xc4\xda\xa7\x94\x65\x45\x1b\xc5\x9b\x35\xd3\xd5\x46\x12\xc8\x8a\x5b\x75\x6c\xc9\xb1\xc5\xc5\xc6\x84\x22\x1a\x43\x6c\x2b\x4a\x65\x12\x43\x7e\xa6\x91\x98\xe4\x24\xa4\x88\xae\x8f\x4e\xf0\xd4\x91\x83\xfc\xef\x37\xd4\xda\x4a\xa1\xa6\x52\x48\x61\x50\x47\x0b\x11\x96\xa8\x47\x1f\x23\x93\x26\x2f\x37\x47\x4b\xaf\x93\x5b\x1c\xea\x2d\xc0\x21\x1e\x30\x22\x92\x38\x1f\x3a\xeb\x70\x44\x88\x87\x13\x2d\x47\x92\xb3\xa4\xfe\x1e\x4b\xf5\x2e\x45\x69\x2f\xb7\x20\x68\xdb\x59\x83\xf1\x2d\x0a\x7b\xc2\xc2\xed\xc3\x8a\xa4\xd2\x28\x0c\x46\x00\x52\xcb\x1c\x02\xc3\xa5\x98\x14\x6b\x77\x71\x32\x7a\xa9\x16\x7a\x33\xf4\x2a\xbe\x2e\xf6\x77\x48\x25\x3e\xe9\x2c\x49\xb0\x0b\x5b\x17\x3c\xe8\x37\xdc\x7a\xbf\xab\x05\x1f\x09\x72\x12\x79\xdb\x9f\x28\x58\xee\xbb\x61\xb7\x38\x76\xcf\x1d\x7a\x8f\x9d\x99\xaa\x4c\x40\x1b\xde\x01\x21\xfc\xf3\x6a\xe7\x6b\x50\xca\xb0\x3d\x7e\x49\xd0\xe9\xf1\x56\x73\xcc\x99\x79\x07\xe5\xa4\xba\x74\x02\x8b\xf7\xa6\x2c\x7b\xde\x8d\x72\xa1\x8a\xd5\x6c\x5d\xc0\x6a\x5d\xc3\xd6\x83\x2a\x60\x95\x49\x4e\x94\x90\x00\x23\x5a\x73\xdf\x7d\xf7\x2f\x6e\x23\xd7\xf9\x52\x0d\x1c\x36\xae\x20\x04\xdf\xf5\x4a\xc8\x4a\xd9\xfd\xe6\x2f\x7c\x43\x98\x0e\x2f\xee\x61\x16\x0e\xe1\xee\x93\x9c\x71\x91\x6c\x34\xcb\xab\x98\x6d\x51\xa0\x94\xcb\xe9\x39\xa6\x6d\x86\xae\x50\x7e\x37\x80\x3a\x1d\xda\x81\x0c\x10\xcc\xad\xd4\xbc\x01\x03\xf0\x80\x56\x0e\xc5\xa9\xbb\x9c\x62\xab\xd7\x06\xae\xaf\x8e\x1a\xb8\xf1\xe7\x48\x6e\xca\x4a\x42\x5f\x0b\xfb\x72\x8d\x61\x5a\xc1\x73\xc3\x5d\xa7\xa1\xf9\x8e\xce\x8d\xda\x9a\xba\xd2\x37\xb0\xca\x41\x48\x83\x58\x48\x00\x14\x11\x95\x5a\x29\x59\x8b\x7e\x5e\xf7\x10\x71\x43\x8a\x22\xaf\xeb\x42\x59\xa6\x2b\xb7\xe0\xd8\x9e\xcf\x17\x9e\x18\xbb\x00\x1b\x35\xd5\x84\x99\x0c\xe4\xf7\x86\xe2\x12\xb8\x1e\x0e\x1b\x66\x18\x35\xa2\xaf\x86\xf3\xe1\x00\x81\x4d\xf6\x84\x51\x6a\xc9\xbc\x89\xa1\xf9\xe9\xc2\x2a\xc1\x61\xca\x01\x06\x04\x30\xb9\x7b\x1d\xa1\x77\xde\x3e\xc0\xaf\xe3\x0e\x9d\x94\x2d\x92\xaa\xa4\x5c\x30\xdd\x22\xa1\x01\x88\x3e\xaa\x56\xd3\xda\xcb\xb9\x96\xc5\x93\xa9\x18\x66\x0f\x0c\xc4\x38\x2c\x86\x3c\x7f\xc0\x28\x0f\x30\x4c\x72\xba\x80\xeb\xba\x11\x72\x5a\x69\x63\xe0\xa0\x0a\x01\xad\x1b\xcb\x42\x99\x67\x4c\x9a\x4b\x06\xf0\x0f\xc0\xaf\x79\x6c\x19\xe7\x18\x6d\xf6\x70\x67\xfe\xfd\x4c\xe2\x89\x9e\x2c\xb2\x8b\x27\xef\x3a\x8d\xe3\xd1\xad\x34\x0c\xf8\xe7\x5e\x4a\x41\xdf\x9c\xdc\x49\xef\xbc\xa7\xdf\x7d\x5f\x06\x06\x7d\xf9\x5b\x5c\x9b\x51\xf3\xdd\xc9\x77\xdb\x6f\xd5\x9f\xd1\x03\x5c\xe7\x21\x1c\x06\xbe\x6b\x8f\x31\xa7\x13\xf7\xb6\x1c\x6f\x79\x02\x21\x0e\x15\xdb\x96\x87\xeb\xe9\x54\x9a\x5c\xa3\x27\xbd\x15\xdc\x87\xe2\xed\x62\xfb\xcc\xb9\x01\x80\x40\x1f\x43\x74\x36\x4d\x5a\x68\xbd\xb2\x8b\x1f\xd4\x84\x67\x97\x2f\x30\x8d\x2d\x59\xad\x48\xd5\x9d\x97\xc2\xa8\x95\xac\xec\xdf\xab\x42\x4e\x41\xbe\x00\x47\x6a\x0c\xdf\x83\x26\xc5\xa6\x2e\xa7\xbe\x8d\x9f\x06\x5f\x1f\xe3\x0a\xe1\x5f\x43\xe6\x2d\xef\x6a\xc2\xe2\x04\xb9\x1d\xdd\xa5\xbb\x2c\xc2\x0e\x58\xcb\x11\x00\xd4\xbb\x7c\x5e\x32\xe9\x4f\x3a\x57\x20\x17\x07\xee\xfc\xe4\xe8\x3e\x52\x82\x34\xd3\x70\xbc\x20\xdb\x7f\x70\x7a\xf0\x66\xf0\x39\x77\x2f\xf2\xf7\x0a\xdb\xd8\xc8\x2c\x0a\x65\x4d\x4b\x59\x6e\xbb\xe5\x6c\x90\x47\x83\xa3\x32\xda\x10\x4c\xc1\x69\x74\xa3\x02\xb9\xb1\x74\x1e\xab\x26\x8a\x0b\xa6\x68\x78\x60\x52\x10\x7f\xea\x14\x98\x6d\x70\x00\xb5\x90\x70\x3c\xa3\x24\x0f\x56\x3d\x0f\xf5\x6e\xf9\xff\x57\x8e\x34\xc8\xc1\x48\xa8\x67\xbc\xa7\x02\x6a\x3b\x29\xb1\xb2\x14\x33\xbb\xbd\x95\xf7\xe6\x0b\xea\x15\xaf\x43\x95\x95\x1a\x3d\x00\xc4\x21\x3c\x7e\xfa\x46\x29\x31\x6e\x3a\xa0\x8f\xf7\xb0\x94\xf3\xe9\xc6\x5f\x78\x04\x85\xbc\xa4\x61\xbb\xdf\x23\xf6\xfc\xcb\xa7\x10\x7d\x7e\xdd\xaa\x00\x1a\xb5\xeb\x85\x7e\xdf\x78\xf5\x86\xea\x31\x90\x10\xcf\xee\xd6\x43\x8a\x11\x77\x61\x46\x72\x31\x63\x5c\x97\xd3\x01\xbf\x6d\xda\x07\x01\xcc\xb7\xd5\xb8\xd3\xa2\xbf\x14\x4d\xaa\x64\x3d\xee\x50\x59\x36\xc0\xa2\x5b\x02\x0c\x5a\xbf\x83\x65\x5b\xe6\x81\xa3\xf4\xdc\xa7\x31\xcd\xf3\xc0\x63\x42\xc6\x81\xa4\x9f\x40\x2e\x92\xff\x03\xf6\x4f\x32\xbc\xe2\xe8\xee\xeb\x7d\x82\x6b\x1d\xc6\xa9\x4d\xb4\xf9\xfc\x09\xf1\x34\x9c\x87\x84\x9f\xf9\x46\xf5\x18\x87\x0f\xcf\x8e\xe6\x47\xba\xcf\x54\x0e\xc2\x9a\xfb\x43\x36\x50\xbc\xa7\x81\xad\xc5\x66\xdb\x05\x45\x2e\x44\x6a\x31\x8d\xc6\x34\xf4\x35\x99\x9f\xd0\xb2\xe4\x45\x6b\xe7\x30\x9e\xba\xd1\x51\x22\x7f\x70\x20\xde\x82\x47\x57\xb1\xae\xaa\xbc\x9c\x0f\x30\x8f\x7e\xcb\xb1\x03\xfe\xd4\x70\x8a\x91\x7c\xe9\x9b\x77\xf7\x75\x56\xec\x90\x15\x38\xcf\x61\x0b\x25\x8a\xbe\x0d\x96\xdf\x17\x3a\x5b\x17\x64\x3e\x03\x04\xb6\xbf\xa9\x69\x4d\x48\x32\xb5\x16\x63\xc6\x49\x7f\x58\x4f\xc6\x03\xe7\x1c\xa6\xa6\x98\xaf\x07\xb8\xb0\x15\xa2\xab\x65\x5e\xe6\xa6\xce\xa7\x68\x9a\x23\xdf\x34\x5e\x7f\x6c\x86\xe2\x98\x29\x81\x9c\x37\x2b\xa6\xe5\x47\xf8\x16\x4b\x0d\xcf\x3a\x2b\x40\xd3\x59\xb2\x90\xb7\x84\x73\xba\x92\xd3\x1b\x89\x87\x5a\xb5\x15\xba\x64\x60\xd0\xce\x57\xd6\xbb\xbd\x49\xc8\xb9\x41\x75\x89\xa6\xbd\x26\x41\xf3\x82\x7b\xbc\xb1\xf2\x33\x59\x13\x31\x91\x8e\xda\x42\xf4\xa6\xc7\x12\xf0\x06\xb6\xaf\xb0\x84\xef\xdf\xc6\xa9\x4c\xf2\x72\x56\xac\x55\x39\xc5\xa0\x59\xd4\xd0\xdb\x86\xc2\x20\xd8\xd2\xe0\x10\x3e\x7e\x8d\x61\x1e\x64\x73\xa5\x41\x41\xe0\x7f\x80\xb2\xf3\xb8\x3a\x6f\xc0\x33\x37\x2a\x45\xda\x7b\x18\x9f\x56\xb8\x6a\x52\xd1\xe5\x86\x8f\x70\x5e\xb6\x12\x73\x86\xbd\x80\xdb\xe2\xc2\x6f\xb0\xc4\x25\x0c\xc7\x91\x78\xd7\x6b\x6b\x72\x6f\x20\x7a\x0d\xa2\xf6\xe1\x95\x5c\x25\x4f\xce\xcb\x5a\x55\x3f\x29\x79\x9b\x16\x6d\x1c\xd3\x40\x14\x8e\xf2\xe4\x61\x3b\xa2\x4c\xef\x7d\x6b\x0a\xe9\x9f\x2f\xce\x6f\x3f\x27\xdf\xb9\x1f\x07\x22\x90\x26\x85\xbe\xcd\xd5\x06\x93\x42\x43\xd0\x1f\x80\x61\xff\x4f\x92\x68\xff\x92\x46\xed\xbf\x61\x86\x68\xea\xd9\xa0\xb1\x30\x58\x42\xd9\x2b\x06\xe3\x02\x5a\x25\x02\x07\xc5\xf4\x7f\x74\xbb\x90\xc6\xe8\x69\x0e\xf9\x20\x18\x24\x62\x98\xb3\xe1\xa7\xe7\xe8\xbf\x51\x5b\xb3\xff\x82\xbe\x65\x42\xd0\xa1\xfb\xfc\x8f\x6a\x7b\xa5\x5f\x55\x7a\x45\x8b\xf8\xb8\xa8\x47\xa2\x87\x59\xf5\xc0\x7f\x8c\x4e\x8f\x91\xe8\x51\x06\x3e\x78\xfa\x42\xd5\x72\x24\x7a\x94\xf5\x0f\x1e\xbd\x59\xe4\x33\x5b\xd7\xd8\x7f\xed\x43\x87\x51\x74\x71\xfe\xa7\xa0\xd5\xf0\xe1\x04\x56\x4a\x70\xed\xc2\x9b\x1f\x2a\xbe\x8d\x2d\xb1\x15\x4b\xb9\x12\x79\xed\x06\x46\x97\x05\x80\x1a\xf0\x41\x33\x42\x7d\x40\x20\x65\x62\xa7\xa4\xbd\xaf\x8d\x2a\x66\x83\xf0\x45\x67\x21\xfe\x49\x4f\x6f\xf6\x6d\xbd\xa1\xa5\x74\xea\xcc\x74\xa0\x16\x17\x4b\xf9\x37\x0e\xbd\xad\x3e\x4c\xd5\xaa\x26\x90\x34\x50\x6a\x45\xc6\x66\x46\x2a\x78\x0e\xf1\xbe\x7c\x0f\xe7\x4b\xff\x46\x6d\x8f\xab\x79\x70\x17\x30\xd1\x7a\xb2\x72\xfb\x22\x37\xde\x27\x91\x6d\xba\xa3\xa4\xe8\x90\xbd\x3c\x6c\x31\x59\xa5\x63\x99\x62\xf1\xed\x28\xea\x1a\xc9\x81\x48\x6e\xd4\x96\x96\x44\x63\x99\xbc\xc3\xe2\xef\x99\x82\xc9\x95\x7e\x26\x1e\x3e\x64\x5f\x7a\x47\xcf\xdf\x8b\x11\xf3\x75\x6c\x44\x68\xc6\x8d\xe9\xca\x96\xd7\x32\xba\x51\x72\x8f\xc0\xdd\x21\x51\xd9\xaf\x64\xf0\x81\x46\xca\xe3\xcd\xb4\x52\xaa\xfc\x8f\xc0\xe6\xf1\xc1\x7f\x86\x07\xd3\xc2\x1e\xaa\xff\x91\x3e\x60\x25\x56\x72\xae\xfe\x23\xfe\xc9\xeb\xe3\x2e\x63\x5f\xa0\xfd\x14\x9e\xe0\xee\x0c\xbf\x69\x17\x86\x07\xe9\x1c\x8f\xda\x47\xdb\x16\x9d\xac\xeb\x5a\x97\xa1\x2a\xfe\x36\xe1\x41\xa5\x20\xff\x19\xb2\x45\x7e\x89\x65\xee\x36\xb1\x44\x3d\x8c\xaa\x88\x5f\x7e\xa1\xb2\x00\x8b\xea\xcd\xc9\x2e\xf9\x0f\x8f\xad\x7d\xe6\xdc\x2b\xb5\x7b\x42\xf7\x70\x5e\x75\xef\x30\x15\x4f\xff\x3b\x1f\xa9\x74\xa4\x74\x1d\xaa\x61\xa5\xfe\x2e\xe7\x2a\x7d\xfd\x77\x3b\x57\x1d\xfd\xf6\x73\x35\x74\x6e\xd0\xb6\x25\xf7\x0e\x1b\xae\xd3\xdf\xd0\x36\x5d\x42\x69\x5b\x70\xe4\x17\x68\xec\x38\x0d\xae\xd0\x2f\x7c\xb1\x5e\xa7\x07\x34\x94\xb9\xf4\x4e\xcd\xf8\xf3\x56\x55\x21\x5d\x33\x7c\x0c\xe4\xd7\xbb\x3f\x06\xc5\x3e\xf7\x63\x1e\x34\xa3\x55\x62\xde\xad\xc3\xfa\x06\x34\x52\x04\xe8\x8e\xce\xc1\xb2\x00\xe3\x3d\x5e\x93\x80\x81\x4a\x72\x20\x54\x62\x0a\xf9\x76\xec\x65\xcb\x25\xce\x71\x90\xed\x80\xfc\x28\x45\xad\x57\xfb\x90\xe4\x03\xe9\x8d\x61\x10\xf4\xad\xaa\x08\x14\x14\x7f\x33\x68\x54\xb8\x14\x01\xe2\xfd\x50\x5c\x96\x05\x80\x73\xf2\x62\xfe\xee\x02\xf8\xf0\xca\x25\xbe\x70\xa9\x09\xb2\xf5\xaa\xc8\xa7\xd2\x63\xde\xb3\xc4\x3e\x4b\x7d\xeb\xb6\x21\x90\x8b\x30\xd2\xbf\xf2\xdb\x0c\xa4\x2e\xbd\xae\x01\x64\xc7\xc7\x2f\xa3\x81\xad\xd1\xde\xa1\xb8\x28\x91\x33\x78\x1b\x3f\xba\x4f\x3a\xf0\x51\xd6\x5f\x3f\x14\x2c\x3d\x17\xe0\x8c\xff\x6e\xfa\xbf\xce\xfb\x7f\x58\x30\x60\xc7\xe1\xe7\x7e\x83\x29\xf3\x97\x9c\xbd\x36\xa2\x7b\x02\x1a\xf5\xc7\xf6\xaf\x3f\x8c\xbe\x4e\x46\xa4\x1d\x25\x6e\x15\x57\x52\x1c\x1c\x88\x17\x21\xad\x9d\x90\x7e\x12\x05\xb8\x97\x40\x38\xdb\xba\x16\xfb\xe8\xaf\xd0\x9d\x47\xc5\x6b\x57\x20\xeb\x4f\x5e\x06\x7d\x65\x63\x1c\x87\xa8\xfe\x84\x61\xeb\x1c\x64\x68\xd9\xb8\xf1\x1a\x30\x5f\x57\x95\x9e\xc8\x49\xb1\x15\x92\x34\xa9\x2c\x5f\x87\xfd\x6f\x03\xdb\xb1\x51\xb7\x15\x92\xce\x9b\x69\x9e\xdb\x43\x0a\x3b\xbb\x59\x6c\xc5\x58\x6f\x4a\x55\x9d\x91\xad\x1d\x91\x72\xf5\x12\x50\x63\x8c\x58\x97\x2e\x5a\x30\xd8\x03\x5d\xdf\x33\x3d\x6d\xfb\xf8\x30\xa2\xc7\x15\x6f\x99\x9e\x72\xbd\x1b\x36\x3e\xd3\xd3\x21\x69\x0e\xfe\x9a\xab\x0d\x79\x2c\x12\x76\xc3\x5b\x52\x1f\x77\xa8\x46\x91\xc2\x26\x2e\x94\x4e\x91\x5d\x73\x87\x41\x9d\xad\x0f\xef\xb3\xb4\x19\xee\x8b\xc0\x1d\x9d\x3a\x00\x3a\x82\xb4\xde\x13\x78\x8f\x9d\xbb\xc0\x8b\x1d\x8e\x4e\xad\x01\x67\x0f\x09\x81\x62\xfd\xb4\xd0\x46\x99\x26\x32\x26\x15\xda\x13\x23\xbe\x1e\x1b\x13\xfd\x42\x3b\x25\x95\x64\x58\x2b\x8e\x29\x59\xc6\x82\x83\x36\x8c\x7b\xc8\x73\x13\x41\x9b\xd2\x2e\x33\xb5\x25\x56\x39\x3a\x12\xb5\x8e\x56\xf2\x4b\xca\x1c\xbb\xc2\x28\x4e\xb8\xcf\xe8\x75\x25\x96\xb2\x94\xf3\x08\xe9\xea\x3e\xfb\x6b\x46\x1d\x17\x47\xd4\x46\x6c\xa4\x78\x06\x73\x3f\xea\xb0\x41\xd8\xa2\x7b\x7c\xce\x9d\xf9\x42\xdf\x93\x40\xad\xf7\x98\xcd\xa2\xb0\x27\x20\x8f\xf0\x09\x42\x42\x7b\x90\xcf\x37\xc3\x70\x56\x0f\xa0\xe1\xf7\x54\x1a\xc3\x97\x7c\xd4\x0f\x10\x81\x47\xbd\xe8\xb5\xc3\x6c\x71\x83\xc3\x5f\xc6\x0b\xef\x88\xfa\xce\x3a\xa3\xec\x01\xfc\x19\x9d\x01\x59\x60\x20\x6a\x7d\xcf\xae\xc0\x77\xe2\xae\xc0\xa3\x5e\xf4\x3a\x6d\x66\x78\x95\x76\x24\x74\x16\x0a\x85\x98\xa5\x20\xa4\xb0\xa8\xa5\x02\x87\x5e\x61\xa3\x71\x06\xc2\xa4\x3a\x1c\x66\x5e\xea\x7d\x43\xdc\x1f\x83\xc9\xd9\xad\x8a\x17\x72\x35\x16\x4b\x99\x97\xb8\xaa\xa5\x58\xca\xd5\x0a\xc0\x89\x10\xc6\x68\xb5\x9e\x14\xf9\x54\xcc\xe4\xd4\x87\x60\xcd\xd6\x05\xc2\x16\x11\xd8\xad\xbd\x02\xef\xf9\xc8\x07\x87\xc8\x11\xf0\x9b\x24\x0f\x5c\x25\x25\x32\xf8\xd2\x19\xa2\x6e\xa9\x39\x7f\x18\xbb\xb7\xa7\xa0\x3d\xb0\xc4\xc0\x1f\x87\xbe\xed\xbf\x27\xc1\x36\x2b\xab\x39\x7a\x51\x41\x62\x57\xb9\x02\x15\x35\xe4\xf6\x7b\x80\xb9\xfe\x7c\x43\x88\xb4\x87\x61\xd1\xb5\x62\xf9\xdc\x97\xa8\x9c\xb7\xa2\x8a\x87\x12\x04\x08\x6f\x0c\xe6\xc0\x4c\x6e\x19\x61\xdf\x42\xff\x0b\x65\x80\x98\xcb\x5d\x2d\x26\x6a\xaa\x97\x68\x31\x46\x30\x72\xf1\x42\xae\x48\x8b\x8f\x72\x5f\xa5\xe4\x0d\x2a\x82\x23\x8b\xf3\xf1\xab\x0b\xe6\x14\x68\x6f\x09\x2a\x13\x63\xf4\xe7\x1c\x93\x63\x60\x2f\xf3\xd1\x3e\x4b\x79\xa3\x04\x46\xe2\x68\x02\xd7\x81\xbe\x56\xb2\x34\x84\x78\xac\x10\xd0\x1a\x6f\x5f\xe8\x62\x7a\x71\xee\x14\x2f\x43\x34\x9b\x04\x5c\x64\xa8\x94\x1b\x04\x41\xb4\xa4\x02\xb0\x0d\x79\xb0\x57\xaa\x04\xdc\x10\x4a\x12\x11\x2b\x20\x70\xe2\xff\x19\xa9\x32\x86\xd7\x15\x2e\x2f\x1c\x7c\x70\x74\x38\x4c\x3c\x30\xcc\x7d\x2b\x82\xe0\xe3\xcf\xea\x98\x8c\xc1\xef\x0f\xb8\xe5\xbf\x8b\xcc\x11\x83\x4a\xf0\x40\x7e\xae\x88\x71\xc0\x79\xc3\xeb\xeb\x37\xe7\xa7\xaf\xcf\xaf\xae\x2f\x5e\x5e\x9d\xbf\x7e\x79\xfc\xd3\x9b\xeb\xb3\xcb\xeb\x97\x97\x57\xd7\x3f\xbf\x39\xbf\xbe\x7c\x7d\xfd\x9f\x97\x3f\x5f\xbf\xbd\xf8\xe9\xa7\xeb\x93\xf3\xeb\xe7\x17\xaf\xcf\xcf\x22\x84\x6f\x5c\x3e\x97\x56\x4c\x70\x24\xfd\x37\x86\x8d\x22\x87\xa1\xe6\x99\x9a\xac\xe7\xf4\xee\x79\x85\xee\x48\x6d\xd5\x1b\xe5\x0e\xe3\xf9\xf0\xd0\xae\xf6\xd2\x84\x20\xd1\x0d\x54\x10\x78\x4a\xb0\x20\x71\x96\xf1\xe0\x94\x84\xab\xa7\x11\xc2\x42\x50\x22\x1f\xbb\xaa\x75\x40\x08\x40\x89\xa1\xbd\xe7\x16\x12\x9d\xc2\x09\x89\x60\x58\x92\xa7\x55\x47\x6a\xf2\x33\xf0\x0a\x0e\x7e\x10\x76\x69\x6f\x34\x01\x25\x8c\x60\xf8\x5e\xea\xf3\xd9\x4c\x4d\x6b\x44\xd2\x3d\x38\x10\xe1\xbf\x27\x93\x27\xf4\x1f\x94\x7c\x85\xa0\xe0\x2a\x7b\xab\xab\x1b\x80\x89\xf3\xc5\x7d\xc9\xa7\xf0\xd9\xff\xd4\x6b\x58\xfa\xcc\x01\xa3\x52\xa6\x16\x7d\x60\x07\x59\x26\x96\xba\x52\x7b\x98\x07\xfd\x55\x21\xa7\xce\xbf\xff\x9b\xb8\x01\x8e\xea\x53\xfc\x3e\x86\x66\x89\x23\xf1\xaf\x49\x3b\x7d\xc9\xa7\xae\xa5\x8e\xe6\x71\x99\xf9\x5a\x7f\x84\x5a\xae\x24\xd1\x3c\x83\x10\x1c\x80\x9e\xfc\x53\x6b\xef\x9f\xba\xde\x9f\xea\xb2\x56\x65\xfd\x5a\x19\x38\x74\x9e\xfe\x31\xe9\xfd\x53\x3f\x4e\xa7\x2e\x57\xc1\x91\xf8\xb6\xa5\x47\x4f\xc3\x88\x9e\x57\x76\x99\xff\xb1\xd9\x1f\x28\xf9\x94\x8d\xfd\x6b\x35\xb3\x1f\xfd\x26\x6d\x24\x94\x7c\xea\x66\x09\x55\x87\x97\x3f\xbf\xbc\xba\x78\xf9\x7d\x00\xf2\x83\x27\xe7\x67\x30\xc0\x38\x92\x2f\xc3\xa3\x6f\x63\x38\x45\xd8\xed\x2f\x10\x38\xfd\x62\xb9\x2a\xd2\x3d\x50\x92\xc8\x85\x4c\x89\x5c\xa2\x70\x47\xc8\x02\xb6\x5a\xad\x62\x94\x59\x1e\x91\xef\x8b\x10\xd4\xef\x32\x9f\x2f\xe8\xce\x55\xaa\x8d\xa8\x2b\xe5\x6d\xbc\x76\xe1\x86\x4c\x14\x48\x6d\xab\xec\xb5\x78\x26\x72\x5b\x80\x30\x49\x72\x3a\x20\x08\xef\x77\x45\x91\x1c\x3e\xbd\xad\x50\xb8\xbc\x6d\xef\xea\x90\x83\x1c\x9d\xa1\xf0\xdd\x95\x9c\x8b\xc7\x61\xd1\xa0\x37\x94\xdb\x17\x8d\xcb\xa8\x1b\x5f\x7e\x21\xc5\xb4\xe7\x40\xf3\x1d\xe1\x34\xf5\xde\x87\x9a\x34\x68\xf1\x6b\x7e\xff\xf9\x8c\xd6\x74\xb4\x27\x4a\x39\xce\xa5\xff\xcf\x6f\xe2\x47\xc6\xb1\xd0\xbd\x4d\xce\x81\x5d\xfd\xa0\x4d\xfd\x5a\xeb\x9a\x43\x41\xc1\x3d\x92\x81\x96\xe5\x46\x6c\x00\x96\xba\x54\xc6\x1e\x8a\xae\x8e\x43\xbb\xb5\xe7\x64\x4e\x69\xc0\x0e\x0e\x08\x78\xda\xee\x35\x99\x97\xaa\xba\x28\x6b\xfd\x66\x3d\xb1\xeb\x22\xf2\xd5\xa5\xe5\xeb\x38\x9f\x87\x33\xce\xf2\x0c\x90\xad\x73\x94\x7d\x2a\xad\x6b\x12\x22\x96\x4a\x96\xc6\x45\x96\xf5\x28\x60\x03\xc2\xcb\xa6\xba\x2c\x09\x8d\xbf\x52\x8a\x01\x42\x2c\xa4\xc1\x84\x28\x6b\x97\x49\x60\x18\xb8\xac\xdf\x42\x29\xa4\x14\xdf\x40\x7c\xf3\x78\x30\xaa\xae\x1d\x66\x47\xb4\x83\xa6\x23\xe7\x6f\x48\x48\x32\xb8\x62\x69\x7e\x62\xf2\x23\x72\x48\x12\x59\xb8\xda\x62\x51\x97\x02\x5d\x3c\x7e\x8c\x95\xfd\xa4\x82\x06\xf4\x34\xfe\x50\xf4\x19\x27\x0f\x68\x3c\x82\xc3\xdb\x3c\xa4\x6e\x08\x05\x03\xb8\xbf\x2b\xba\x91\x55\x99\x97\xf3\xbe\x2b\x3e\xbc\xb6\x4f\x54\x76\x3c\xd1\xeb\xfa\xb5\x9a\x99\x8b\xf2\x35\xac\x82\x81\xe8\xfd\x0b\x78\x0a\x58\x69\xd6\x18\x8c\xb1\xa6\xa1\x70\x50\xd5\x79\x6d\x68\xcd\xf4\xf7\xbc\x7a\x6b\x28\x7a\xe2\x6b\xd1\xf3\xcf\x79\xd0\xc8\xca\xca\x7e\x7e\x68\xf5\x8c\x72\x1f\x40\x5c\x38\xc2\x54\x5f\xb8\x54\x53\x48\xa5\x54\xb7\xaa\xa2\x26\xa0\xfa\x63\x81\xba\x3e\xc0\x57\xfd\xfb\x1a\x9c\x11\x4d\x2d\x0b\x85\x09\xf5\x7d\x18\xde\xaa\x52\xb7\xb9\x5e\x1b\xde\x98\x81\xc7\x21\xac\xd4\xcc\x0c\xed\x6d\x9c\x50\x57\x0a\x3d\xcf\xa7\xe0\xd7\xed\x86\xfe\x2c\xcf\xa0\xb3\xd0\x36\xa0\xc1\x5f\xd1\xb1\xe6\x22\x18\x7a\x83\xa6\xf4\x12\x26\x01\x10\x8e\x7a\xc7\x81\x76\x2f\xb8\x3d\xdd\x35\x0b\x51\x26\xe9\x8f\x1c\xe8\x64\x46\x0b\xc1\x8a\xb1\x61\x65\xc6\x87\x42\x37\xa6\xcb\xaf\xd9\x11\xd2\x58\xe6\x7e\x61\x5a\xb6\xd9\xc3\xfe\xbd\xe8\xb5\x67\xea\xf8\xb9\x94\xe8\x3d\x2a\x66\x39\x64\x76\xcc\xc0\xc3\x56\x32\x16\xc0\x10\xb1\xa3\x44\x1a\xbc\x79\xb6\xb2\x93\x31\xed\x97\x7f\xb6\x6b\xf7\x4d\xa1\x37\xaf\x64\xbd\x48\x0f\x54\x7f\x24\x7a\xc9\xd2\x3f\xf1\x43\xf9\xa9\x27\x2b\x62\x7b\x43\x6c\x88\x87\xde\x77\x2c\x19\xce\x4e\xc1\x18\x5a\xe2\x0f\xdd\x35\x7a\xb8\x00\x1e\xf6\xb1\xa0\xe5\x1f\x9e\x05\xfe\xe6\x83\xe9\x78\x95\xf1\x39\x56\xdc\x21\x77\xa7\x6a\x98\x03\xba\x37\x8e\x07\xbc\x05\x6e\x74\x70\x14\x9e\x54\xb2\x9c\x2e\x94\x01\xdc\x8a\xa2\x10\x1b\x59\xdc\xc0\x0d\x78\x23\xab\xcc\x88\xf5\xca\xd9\xff\xed\x51\x42\x67\x83\x16\x46\x29\x4c\xe0\xb5\x92\xf5\xc2\xbf\x46\x7c\x21\x7b\xff\x1e\xba\x88\x26\xc8\x5e\xa0\x00\x11\xd7\x9e\x49\xc1\x13\x0c\x49\x81\x7f\x9a\x2c\x28\x48\xd0\xee\x73\x6c\x45\xa6\x64\x81\x20\x0a\xe0\x34\xe6\x56\x0a\x97\xbb\xec\x83\x89\x38\x12\xd1\x62\xa1\x33\xde\xee\x57\xee\xa8\x8b\x1a\xd3\x63\x5b\x3a\x3d\xdb\xc3\xeb\x13\x71\xe4\x0b\x3e\x73\x7f\x85\xb5\x18\xa9\x15\x61\x51\xba\xc2\xbf\xfc\x22\xe8\xef\x93\x48\xdd\xf7\x16\x8e\x59\x19\x4e\x62\xa7\xd5\x83\xab\x7c\xea\x8d\x78\x31\x43\xbb\xce\x54\xaf\x72\x65\x5c\xf8\x15\xd2\x25\x4e\x83\xf0\x4d\x2e\x1d\x9a\xbd\x05\x4d\x17\x79\x01\x90\x23\xf6\xb6\xe1\x28\xf1\xc4\xf1\x98\xf1\x2c\x2f\x32\xa6\x9c\x20\xf5\xc9\x42\xae\x56\xaa\x0c\x39\x31\x26\x32\x2f\x20\x33\x44\x29\x0a\xbd\x71\xc4\x56\x55\xae\xab\xbc\xde\x8e\x30\xc9\x9a\xcc\x0b\x95\x81\x7e\x1c\x9a\xd4\x33\x44\xbd\x52\x6b\x43\x61\xd9\xce\x3f\x1f\x5e\x04\x79\xd3\x0d\x28\x96\xb7\x4b\x9a\xc6\x0c\x9f\xa4\xd9\xa4\xa1\x90\x88\x2a\xf9\xf3\x13\x27\x39\xa9\xe6\x12\xd0\x3b\xea\x32\xce\x0e\x8a\xf3\x71\xab\xbc\x0f\xa4\xe5\x0a\x76\x84\x8e\x1d\x70\xa7\x6b\x37\xee\x88\x21\xab\x9b\x72\x5b\x6a\x15\xf3\x66\x6d\x6e\x3b\x2e\x8a\x36\x1b\x37\xb9\x67\xe3\x4e\x7e\xd3\xc6\x45\x5b\x25\x6d\xa0\x1b\x72\x9c\x36\xcb\x1c\xf2\x72\x1e\x8b\xd4\x2e\x39\x96\xcb\x75\x0d\x82\x01\x5e\x3b\x18\x71\x50\x18\xc9\x72\x8b\x2c\xd6\x8a\x0a\x20\x33\x8b\x37\xcc\x8f\xc8\x53\x03\xd7\x52\xb0\xf1\x01\x49\x62\x4b\x5b\x5a\x9c\xe0\xe9\xca\x84\x68\xcf\x37\x07\x10\xc5\x0f\x40\x32\x43\x7f\x8e\xff\x5a\xfe\xdb\xd0\xe3\x33\x66\x01\xfc\x7e\xd2\x76\x6f\xa0\x54\x69\x34\xc4\xb0\x45\x55\x65\xb7\xef\xb1\x57\x67\x36\xdf\x9d\x84\xbd\x9c\xe5\x33\x48\x3f\xc3\xf2\x8b\xc3\x22\x32\x43\x3b\xd4\x7c\x2f\xc7\x64\x0c\x8d\xff\xb4\xca\x8d\xd9\x87\x90\x11\x40\xd0\x38\x06\x47\xd5\x40\x6c\xa2\x0a\x8d\xf6\x8e\xc0\x0b\xec\x0d\xde\xb6\x70\x88\x24\x11\xed\xf9\x04\x3d\x5c\x5b\xca\x07\x62\x54\xf1\x84\x2a\xba\xb1\x97\x61\xab\xba\x15\x33\xf1\x8f\x4e\x3a\x4d\x6e\x8d\xa1\x31\x2d\x2c\x0e\x45\x02\x4a\x6c\xe3\xb4\x98\x6b\x0c\x13\x0c\xb4\xc8\x4c\x36\x10\xa6\xd0\x1b\x38\x95\x46\xc2\x4c\x65\x19\x77\x1a\xd8\xaa\x92\xd3\x85\xe3\xab\x61\xd1\xe2\xa1\xc6\x16\x26\xc4\xd5\x62\x4d\x1c\x12\xd0\x2b\xe3\x63\xa3\x3c\x2f\x3f\x38\x08\x75\xde\x40\xa6\x07\x47\xfb\xd8\x33\x47\xa3\x6a\x6e\x1b\xcc\xb3\xe7\x56\x3e\xa2\xfd\x16\xa5\xc0\xb7\xef\xaf\xef\xc3\xfc\xae\x5b\xb9\xdf\x75\x27\xfb\x4b\x3e\x1a\x04\xda\xce\x09\x6c\x9d\x44\x7a\x1c\xce\x2f\xd1\x60\x72\xd7\x9d\x5c\xee\x8e\x36\x4c\xda\xdb\x20\x3f\xb1\x0d\x7e\xf8\xae\x77\x72\x32\x38\xc1\x79\x8b\x78\x5b\x1b\x73\x79\xd2\x32\x97\x22\x9d\xa9\x93\x78\xa6\x76\xcc\xd5\x5d\xb3\x75\xe7\x58\x75\x0e\x4b\xe7\x30\x36\x46\x8c\x8f\xd9\x5d\x33\x77\x8f\xf6\x74\x2c\x95\xce\xa5\x75\x47\x7b\xee\x98\x45\x5e\x38\x9a\xc5\x56\x41\x1c\xdf\xd8\x03\x04\xdc\x4d\xf4\x1a\xd2\x5c\x39\x04\x09\x9a\x62\xbb\xa7\x29\x38\xa1\xcc\xc0\xcd\xc5\x24\xe9\x04\xbd\x19\xda\x49\xc4\x11\xef\xba\x5f\xb2\x41\x91\x9a\xe1\x1f\xf6\x25\x93\x31\x69\xec\xdb\x3a\xf1\x9a\x09\x18\xc6\x1d\xc1\x94\x1d\x61\xa2\x90\xab\x01\xa6\x9c\xf9\xaf\x5e\xe0\x6b\xbf\x4f\xca\xc4\x70\xa7\xf0\xa2\x7f\x8e\x83\x2b\x21\x71\x27\x44\x74\x82\xfe\x6a\xc0\x94\x4d\x4d\x5d\xd3\x50\x5c\x0c\xd5\xd0\x45\x58\xb3\x2b\x99\x1d\x95\xa6\x92\xed\x37\xbf\x64\xc1\x21\x1f\x14\x34\x4e\x57\x14\x6f\xc9\xcf\x93\x1c\x3b\xae\x61\x10\xbe\xbf\xc9\x8d\x12\x27\xa0\x5e\x43\x93\x60\x93\x40\x53\x62\xeb\xb8\x5f\xdb\xd1\x81\x0b\x2b\x09\x7e\xe1\x5e\x4d\x44\x5f\xe1\xf2\x3e\xba\xe3\x52\x4e\xb5\xfd\x8d\x3b\xaa\x9d\xfa\x32\xf3\xbc\xe2\x07\x07\xe2\xa5\xfa\x50\xbb\x8b\x5b\x95\xdb\xff\xeb\x8d\x73\xdd\xf2\x18\x77\x6e\x86\x02\xf6\x43\x94\x2b\xf3\xe0\x4a\x7d\xa8\x87\xb1\x8e\x3d\x6a\x43\xc7\xf5\xae\x55\x27\x1b\xf2\x13\xfa\x80\x64\xf6\xd6\x7e\xa9\x79\x8d\xf6\x0a\x3a\x16\xd3\x47\x70\xeb\x11\xf7\x0e\xcf\x98\x74\x78\xc4\xea\x47\xaa\xe4\xf8\x48\xb0\xdb\x22\x2f\xb9\x2e\x29\x74\x00\x9a\xd7\x3a\xea\x9d\x57\x7d\x1a\x8e\x87\x18\xaa\x8c\x1c\x32\x0e\xc8\x7c\x18\xab\xb3\xdd\x70\xf0\x96\x77\x7f\xb5\xe5\xbb\x81\xef\xde\xa1\x2e\x77\xf1\xd3\xd8\xa8\xc6\x48\xa5\x55\xf8\x88\x31\x56\xff\xd1\x81\xba\xea\x8d\x4b\x1f\x1b\xf8\x2e\x68\x6f\x17\xaa\x52\x08\x5a\x74\xfe\xe6\x27\x2b\x3a\x42\x16\x3e\x74\x43\x80\x34\xe3\x68\xf2\x38\x38\x10\xca\x14\x79\x59\xef\x67\xb9\xb1\x0c\x63\xbf\x54\x1f\xea\xfd\x22\x2f\x95\x28\xf5\xfe\xba\xac\x2c\xff\xb4\x2f\x5a\xcc\x88\x3b\xb7\xdd\xdb\xbc\x5e\xbc\xd4\xaf\x74\x55\xcb\xc2\xfc\xcf\x1e\xfc\x3d\xf7\xa0\x43\xcf\x00\x42\x0f\x89\x10\x8e\xfc\xff\x6c\xcf\xff\xef\x6e\x4f\xb0\x38\x1f\xff\xf4\xd3\xc9\xf1\xe9\x8f\xd7\x27\x97\x97\x3f\xfe\x78\x7e\xfe\xea\xe2\xe5\xf7\xd7\xaf\x2e\x2f\x7f\xba\x7e\x73\xf1\x7f\x21\xe3\xda\x13\x34\xfc\x4e\xc9\x34\x7d\x12\xf2\x5a\xbe\xd2\xba\x10\x47\xe2\x1d\x8b\x54\x7c\xee\x36\x49\xa6\xd4\x4a\x99\x9a\xe4\xbf\xb0\x91\x5c\xae\xcf\x62\xeb\x44\x1d\xe7\xfe\x0c\xc2\x90\x53\x71\x7e\xc5\x10\x20\x83\xab\x13\xe2\x32\x11\x6c\x83\x2a\xeb\xbc\x52\xf4\x01\x2b\x13\x01\xce\x82\x33\x16\x52\xc2\x4b\xdb\x7b\x4b\x0d\xe4\xbb\x3d\xb0\x00\x37\x2a\xe8\x9a\x2a\x0d\x7c\xb2\x2c\x00\x16\x89\xa3\x16\xec\xf6\xb7\xc2\x94\x37\x30\x52\x66\x6b\x53\xa7\x80\x25\x35\x28\x6d\xc1\x64\x34\xd7\x3a\x13\x79\xa6\x24\x22\xab\x4d\x17\x01\x28\x9f\x62\x5c\xc5\xba\x0c\xd0\xbf\x67\x97\x2f\x48\x51\x5c\xc9\x5b\x55\x19\x59\x10\xac\x9c\xf4\x38\xc1\x59\x3e\x9b\xe5\xd3\x75\x81\x1a\x10\xcd\xb2\x57\xb9\x58\x62\x4c\x03\x2a\x91\xd0\x72\x4d\x0e\x60\x7a\x62\x54\x75\x8b\x80\xc2\x0c\xdf\x58\x16\x05\xa4\xb9\x23\x74\xa0\x61\x60\x53\xb6\x67\x4d\xad\x0d\x05\xc9\xc7\x2f\xb9\x5f\x0a\x80\xa2\x70\x36\x93\x5a\x79\xd1\x2d\xbd\xf4\x7a\xaa\x59\x24\xe7\x2a\x87\x47\x9c\x9a\x6d\x03\xd7\x0e\xd6\x1f\xfb\x29\x26\x82\x06\xcb\xef\x4c\x3b\x2f\x96\x9f\x29\x60\x06\x53\x95\x3a\x88\x63\xb1\xc8\x55\x65\x6f\xa9\x18\xa1\xa8\x57\x02\x5d\xe0\xdd\x1a\x8f\x21\x77\xc8\xa1\xf7\x94\x6d\x80\x1f\x71\x03\x24\xbe\xf0\x2d\xb0\xeb\x31\xf6\x4e\xc7\x1e\xa2\x94\xd3\x5c\xef\xce\x0c\xa2\x5d\x95\x56\x7a\xe5\xb0\xe5\xbc\x25\x2e\x76\x3e\x8e\xdc\xd8\x93\x92\x71\xc0\x5e\x12\xa1\xc7\x29\x06\x70\x8e\xa6\xe7\x2e\x9b\x08\x5b\x38\x99\x1f\x4a\x32\xc0\xda\x30\x8a\x7e\x61\x20\x09\xfb\xf4\x28\x1a\x41\xac\xed\xbf\x38\xe2\xa1\x06\xf0\xce\xcd\xa6\x19\x89\x77\xef\x31\x11\x46\x9c\xd7\x1c\xee\x63\xbb\xa6\x2f\x8f\x52\xff\x77\x8d\xa2\x5b\x7a\x5d\x63\x97\xbe\x8e\x86\xac\xf1\xd6\xb7\x9a\x66\x1d\x9c\xa7\xee\xb5\x3e\xc4\x9f\xef\xe0\xd6\x6e\x01\x75\xae\x98\xb5\x59\x84\x3e\x1f\x76\xa0\x33\xb9\x01\x03\x03\xde\x24\x8c\x56\x0a\x1c\x4d\x1d\x64\x25\x86\x7c\x7d\x20\xff\xf9\x49\xeb\x95\x07\x65\xb7\x5c\xde\xef\xbc\x81\x87\x59\x04\x5b\x64\xcf\x80\xe6\x9b\xb8\x77\xec\xcf\x6d\x2f\xcc\x75\x8f\xa5\x3d\xf6\x30\xbf\x93\xb5\x95\x6e\x20\xfa\xb8\xaa\xe4\x16\xb3\x10\xd3\xf8\x3a\xac\x01\x3b\x1a\xc0\x11\x4b\x4a\xd9\x11\x63\xa0\x0f\x1c\xfa\x41\x8a\x8d\x8e\xa9\x4d\xb2\x7c\x86\x01\xba\x67\x97\x2f\x06\xa2\x50\x32\x43\x1f\x78\xca\x1a\x92\x24\x0f\x05\xc3\x1b\x1c\x30\x60\x54\xe8\x19\x14\x00\x80\xf3\x23\xb6\xf8\x1f\x9e\x3e\x7d\xf2\x6f\xde\x2c\xe7\xf8\x51\xba\xb5\x32\xcd\x04\xc4\x87\xae\x58\x90\x60\xf8\xa0\x87\x05\x05\xf3\xeb\x0b\x7b\x7d\x32\xb7\x99\x39\xfe\x02\x87\xed\x51\xc7\xa1\x96\x90\x80\x36\x54\x8c\x8d\xb7\xd0\xbc\x7f\x83\x58\x9f\x77\x85\x24\xd8\xcf\xc1\x0a\x75\xe7\x11\x23\xf3\xa0\x3d\x8d\x7f\x7b\x1b\x5a\xd2\xf9\x77\xae\x5f\x5f\xeb\x5d\x4e\xf2\xdb\x75\xbc\x27\xfa\xd1\x6a\xef\x0c\x84\xe2\xa5\x76\xe5\x4a\xe8\x28\xb7\x17\x01\x76\xa2\x54\x61\x57\xe3\x46\x01\xca\x27\x84\x8e\x63\x6e\x2c\xf0\xcb\x7c\x06\xf2\xd9\xb5\x02\x7d\x4e\xd0\x31\xc2\xc3\xb8\xf9\xe2\xc8\xab\x70\x22\x57\xde\x1f\xe2\x4e\xc6\x95\x70\xd4\x9a\x94\xe2\x07\x0d\xf7\xe0\x73\x6c\x4e\x9f\x9a\x45\x54\x42\x23\x1f\x3e\xa4\xbf\x53\x8f\x25\x57\x31\xf2\x7d\xba\xe6\x85\x03\x2a\xc1\xca\xa4\x01\x6c\x46\x4c\xb6\x24\x02\xc5\x59\x04\xba\x92\x6d\x46\xcc\xfe\xb5\x9a\xea\x8a\xd0\x6c\xc7\x3c\x7d\xc4\xa9\x86\x15\x5a\x9b\x71\x6b\x9c\x2d\x31\x8d\x13\x69\x10\xad\x10\xcf\x06\x70\xde\xee\xf3\x8c\x9d\x7b\xad\xe1\xb5\x0e\x0b\xda\xc5\x0d\xeb\x92\xac\x25\xb5\xa6\x0c\x0d\x1e\xab\x3b\x4e\xd6\xf9\xcc\x51\x38\x2e\x29\x86\x0b\x39\x90\x14\x15\xa0\x7d\x07\x6f\x25\xa4\x07\xde\x8e\x33\x5d\x4d\x95\xf7\x39\x6f\xfc\x47\x35\x2d\xcb\x8b\x3f\xca\x92\x7d\x1e\x44\xc9\xa5\x56\x27\x98\xc0\xa3\x0d\x81\x30\x19\x98\x81\xeb\x2b\xc3\x04\x57\x6d\x68\xe0\x6d\xf2\x1e\xd0\x77\xc9\x3b\x87\xd8\xb8\xbe\xc3\x27\x6f\x7e\xc9\xc5\xf6\x62\x14\xca\x24\x2f\xb3\x3e\x84\x85\x47\x33\xbe\xb7\xd7\x5c\x51\x32\x5d\x53\xe9\x92\xc2\x8c\x44\xff\xb3\xa6\x7e\xcf\x35\x45\x29\x9e\xfe\xff\xbc\xa8\x28\xd7\xd4\x6f\xb4\xaa\x42\xce\x4c\x5e\xa9\xfb\xd2\xc0\xda\x7f\x1d\xb1\xcd\x06\xfa\x63\x02\xb9\xe1\xe3\x99\x76\xe4\xe2\x39\x6c\x13\xde\x76\x9c\xc0\xed\x21\x58\x21\x09\x38\x50\xe0\xbe\xa0\x2e\x22\xc1\xbf\xf5\x6a\x2b\x07\x65\x09\x79\x78\x13\x37\x57\x76\x4d\x8a\x3d\xd4\x36\xca\xb6\x2e\xc0\x07\xf7\xd5\x87\x91\xc8\x97\x73\xa1\xcb\x42\xcb\x6c\xcf\x8b\x77\x7a\xb9\xcc\xeb\xda\x39\x56\x3a\x0a\xc1\x5f\x91\x3c\xd6\x06\x21\x3d\x06\x25\x7a\xde\x88\x3e\x39\x8c\x0f\xec\x7d\xd3\xfe\x55\x0b\x69\xc8\xd3\x0d\x5c\x8f\xbd\x67\x10\xb6\x41\x97\x10\xfa\x58\xee\x07\x1d\xc2\x1e\x38\x1b\xa0\x33\xba\x2c\x8c\xbd\x90\x83\x7b\x69\x25\x20\x89\x8b\x67\x1a\x26\x42\x93\xa7\xf5\x40\x47\xf8\x92\x00\x9c\x29\x08\x9c\xa2\xb0\x45\xeb\x3d\xc2\x4f\x3f\x93\x1d\x08\xb5\xee\x57\xdf\x53\x41\xb2\xaa\xab\x6d\x98\x07\xe4\x39\x98\xe5\x68\xa2\x28\x6b\xc7\x54\x01\x18\x3a\x47\x17\x9b\x6e\xa7\x85\xa2\xb0\x32\x57\x77\x4c\x1a\x8e\x33\x74\x30\x18\x63\xa7\x92\x5c\x39\xcd\x2b\x47\x24\x3d\x91\x08\x38\xcb\x11\xef\xd5\xed\x85\x3b\x2f\x76\x0d\x12\x51\xec\x91\x83\x02\x73\xdb\x3e\x64\x54\x9d\x55\x4a\xfd\x43\xf5\xff\xf9\xe0\x0b\xbb\xf6\xbc\xb4\x62\x65\x91\x86\x24\x22\x3e\x0e\xa8\x58\x22\x1a\x45\xa5\x13\x29\x09\x2a\x35\x24\xae\x51\x53\x08\xc3\x62\x24\x0b\x8d\x98\x40\x35\x78\xf0\x85\x97\x91\x46\x41\x5c\x1a\x3c\xf8\x22\x3d\x8a\x47\x8d\xc3\x99\x0a\x45\xbc\x75\xd4\x64\xb7\x83\x07\x5f\x44\x1c\x6b\x14\x33\xb0\x07\x1f\x19\x34\xd4\xf7\x76\x00\x65\xad\x58\xec\xa2\x9e\xf9\x54\xf2\xe2\x56\x95\x99\xae\xc4\xaa\x52\xb3\xfc\x83\x32\x74\x8c\xa2\x82\x10\x43\xc0\x4d\xbd\x2d\x58\x0e\x17\x59\x66\xb4\xd9\xec\x49\xd7\x75\xc0\x42\xa5\x57\x95\x5e\xed\x4c\x9f\xce\xce\x35\xe3\x4f\xc6\xf8\xa8\x59\xca\x1b\xf5\x0a\x1a\xf7\x42\xae\xfa\x9e\xec\x20\x10\x09\xd7\x5e\xdf\x89\x23\xf1\xcf\x8f\xb0\x57\xdc\x93\x77\xbe\x62\x8c\x4d\xfd\x9e\xa7\xff\x6e\x66\x82\xf3\xd5\x7b\x6f\xd5\xe4\x26\xaf\x7b\xe2\xeb\xd0\x33\x5b\xb7\xb7\xf1\xcf\x3d\x99\xb8\xe2\x0b\xfd\x8f\x66\xad\x25\x3e\xec\xa8\xb2\x34\xcd\x1a\x2f\xde\xec\xa8\x70\xd9\x2c\xaf\xa3\xe2\x69\xcf\xc2\xe9\xea\x88\x70\x21\xeb\x18\x64\x00\xf0\x27\xf2\xf3\x8c\x91\xa7\x51\x46\x5a\x5f\x2a\x59\x42\x01\xd1\x0f\x5f\xbc\x62\xb3\xf2\xc0\x5e\x2f\xf3\x25\x68\x3c\x55\x99\x8d\x92\xe9\xed\x1d\xbb\x97\xbd\x81\x08\x3f\xce\xcb\xac\xb7\x37\xe0\x75\xf3\x5a\x21\xfe\xc9\x3d\x29\x5c\xb8\xf2\x09\x1d\xc8\xf9\x70\x4f\x1a\x90\x1e\x09\xeb\x43\x74\x68\xde\xd5\x89\x2b\xff\x16\x10\x09\xfd\x2f\xe8\x06\x0f\x35\x3e\xe7\xc3\x8b\x51\x29\xb7\xca\x27\x6c\x86\xf0\x14\xc4\x86\xa7\x60\x5b\x1a\xe1\x4c\xf4\xf3\x99\x90\x2b\x80\x2c\x99\x14\x6a\x2f\x8c\xb8\x2b\x71\xee\x66\xde\xef\x05\xf7\x49\x92\x36\xbd\xd7\xf8\x8c\x6f\x7e\x5d\x06\x52\xb8\xed\xe3\xda\x27\x5a\xd7\xc6\x72\x23\xf0\x51\x04\xbd\x34\xcf\x35\x74\xdf\x34\x5b\x8e\xf4\xce\xc4\xf9\x43\x28\xe5\xd4\x54\x97\x25\xc4\x67\x88\x55\x21\xeb\x99\xae\x96\x06\xb4\x53\x2b\x59\xd5\xf9\x74\x5d\xd8\xe6\xda\xb7\x74\xf0\x80\x2f\xdc\x71\x99\x55\xf6\x2a\xfd\xaf\xc3\x0f\x83\x90\x98\x6e\x5d\xee\xfb\x51\x7c\xe4\x97\xc1\x23\x18\xde\x47\x61\x5a\x1f\x39\x7e\x97\x93\x0d\xc2\x31\x43\xcc\xf0\x40\x1e\xde\xd0\x0d\x12\xc1\x27\xeb\x9a\xe7\x22\x84\xe9\xc4\x5c\x34\x90\x6d\xb6\x26\x7c\x1b\xf7\x71\x97\x11\xac\x54\x2e\x0b\x1f\xf7\xe3\x4f\x5b\xea\x04\x94\x4a\x89\xb5\xa1\x6c\x2b\x65\x66\x4b\x96\xba\x66\xc2\xfb\x32\x44\xa8\x2c\xe5\x6a\xe8\x64\x55\xb6\xa2\x61\x61\xf4\x04\x64\xc1\x2d\x33\xbd\xf1\x32\x1d\x65\x31\x8e\xb7\xec\x90\x6f\xd6\xf0\xe3\xf0\x3e\x35\xfc\x16\xfd\xc4\x7a\xb0\x25\xe3\x3a\xce\x10\xfc\xc6\x4a\x32\x12\xec\x6b\xb7\x2a\x74\x8e\xed\xb0\x4f\xeb\x5d\xb4\x8d\xd9\xaf\xc3\x04\xfe\xfc\xb8\xae\xd5\x72\x05\xde\xff\xc1\x53\x86\xf2\x1c\x82\x71\x27\x61\x81\xf7\x39\x20\x3b\xce\x40\x7a\x1d\x9f\x81\x73\x55\xff\x95\xb7\x3c\x6c\xef\x7e\x72\x0a\x82\x37\x7a\x83\x07\xbc\xf3\xa5\xde\x27\xf7\xad\x9d\x65\x0f\xe3\x0c\x37\x0f\xe3\xd1\xeb\x26\x1a\x9d\x52\x5e\x1c\x5e\x39\x06\x29\x8e\x44\x27\xa5\x58\x75\xe8\x8f\x34\xd8\xeb\xae\x3e\x37\xcd\xfb\x87\x69\x06\x78\x5f\x15\xf2\xe4\x45\x84\xe0\x47\xc3\xc2\xbd\x73\x24\xc4\x51\xf8\x7c\x10\x25\xde\x27\x71\x53\x44\xa9\xd7\x8b\x34\x16\xdb\x15\xf2\xa3\x4a\x6e\x84\xc9\xe7\x10\x51\xef\x77\xa9\x43\x8f\x9a\xca\x35\xdc\x4f\x90\x87\x78\x7b\x97\x5b\x3c\xcf\xb5\xcf\x8d\x07\xd9\x56\x7b\x66\x3d\x59\x5a\xb1\x03\x6f\xf8\x98\x1f\xca\x2b\xba\xeb\x62\x4b\x29\x5b\x45\x9f\x54\x00\x8a\x80\x10\x56\x08\xad\x5f\x58\x61\x00\x35\xdf\xf5\x42\x96\x62\xec\x38\xf1\x78\x6f\x00\xa9\x5d\x41\x1d\x5f\xb3\xe7\x08\x34\x0c\xc0\xfb\xa0\x8a\x4f\x01\xb3\x88\x9d\x61\x4b\x30\x9b\x29\x71\xa4\x85\x82\x6c\xc4\x74\xaa\xf0\x7b\x4e\xc8\x45\x5d\xeb\xd5\xf1\x44\x57\x80\x0d\x6a\xff\x05\x08\x33\xfb\x90\x49\x00\xa3\x5d\xdb\xa0\xc7\x19\x55\x0f\x43\xe2\xa2\x47\x29\xc1\x8b\x20\x40\xdc\x8b\x6c\x1e\x04\x88\x98\x78\x78\x91\x7e\xe2\x0d\xca\x16\xf7\x22\x6f\x50\xb6\x88\x49\xe3\x43\x22\x7b\x52\xac\xab\x91\xe8\x4d\x20\x63\x36\x3e\x3a\x95\xe5\x54\x01\x74\x2a\xfc\xc1\x1e\xbf\x2a\xe4\x16\x9f\xaf\x0a\xb9\x4d\x5e\x5c\xa1\xb1\x27\xbc\x27\xeb\x8f\x2f\x46\x89\xc1\x5d\xfa\x69\xf7\xb8\xc8\xa7\x37\xf6\x29\xe6\xe6\x76\x0f\xb5\x81\xa2\xf6\x5f\xff\xd0\xde\xec\xbd\xc8\x33\xa2\xd8\x46\xcf\x68\x5b\x8a\xd1\x50\xf1\x82\x51\xe7\x59\x51\xbc\x97\xc6\x65\x31\x53\x59\x28\x5c\xd6\xea\x43\xfd\x42\x95\x6b\x28\x06\xbf\x96\xaa\x5c\x87\x02\x2b\x18\x1d\xbd\x0a\x43\xb3\x86\xcf\xaf\xfd\x17\xcf\xf4\x7a\x52\x28\xd7\xe7\x6c\x52\x44\xdd\x3e\xab\xe4\xdc\x3e\xae\xe4\x9c\x3f\xc2\xde\xda\xa7\xac\x9b\xf8\x02\xb0\x02\xe9\x95\x03\x04\x74\x2f\x3f\xe4\xb5\x7b\xf7\x21\xaf\xf9\x2b\x82\xfd\x83\x77\x85\xc7\xf6\xa3\x97\x97\xb7\x9e\xa6\xbe\x8d\x49\xba\xf1\xb4\xef\xa2\x81\x3c\xab\xf4\x0a\x9e\xeb\x95\x7f\x44\xd0\x95\x7e\xda\x33\x7a\x10\x4f\xff\xf9\x72\x55\xe7\x90\xe3\x5d\xe1\x5f\xfe\x45\x39\xad\xb6\xab\x1a\x5f\xb9\xbf\xc3\xcb\x8c\x5e\x64\xec\x61\x55\x69\xdb\x72\x70\xdc\x75\x0f\x21\x37\xe0\x48\xf4\x66\x98\xee\x1d\x1f\x02\xe4\xf6\xc8\x25\x0f\xa2\x87\x94\x63\x6c\x24\x7a\x94\xce\x8a\xbd\x78\x55\x29\x63\xf0\x0d\x24\xcb\x62\xaf\x7e\x5e\xe1\xf3\xb5\xef\xf9\x4f\x5a\x66\x2a\x3b\x93\x80\x35\x5c\xc0\x8f\x4c\xd6\x92\xbf\xa6\x17\x71\x8d\x17\xaa\x96\x19\xaf\xb5\xa4\x07\xbc\x98\x9b\x02\x5b\x22\x9a\x02\x00\x5e\xa2\x0e\x00\x3e\x12\xef\x02\xbc\x7c\xa1\x61\xd2\xe1\xa5\x95\xec\xa2\x97\x97\x30\x20\x0e\x4f\x30\x7e\x85\x0b\xc2\x63\x07\x46\x2f\xa1\xfb\xf0\x2a\x0c\xc0\x2b\x69\x60\x2b\x41\x76\xad\xf0\x70\x6d\xf0\xe1\x3a\x6c\x69\x62\x28\x9c\x9b\xd8\x47\x79\x39\xa7\xa7\x79\xe9\x77\xc2\xab\x4a\xcf\x69\x1a\x56\xf4\xa7\x7b\xf5\xda\x27\x56\x18\x89\x5e\x25\x6b\x15\xaf\xb1\x37\xd3\x4a\x17\x96\xa1\x19\xf8\xc3\x3f\x56\xea\x06\x56\x91\x81\x3f\xf8\x63\x6c\x80\xc1\xbf\xc2\x8b\x28\x99\xdd\xc8\x25\x6f\x6f\xac\xe9\x37\x35\x40\x0a\xd9\x02\xf8\x97\x7f\xb1\x36\x2b\xb8\xd9\xf5\x0c\xfe\xe5\x5e\xf8\x7c\x21\x23\xd1\xab\xdd\xdf\xfe\x65\xbe\x54\x9e\x3d\xd5\xf9\x52\xc5\x7c\xe9\x4a\xcf\xe7\x05\xbc\x82\x3f\xc2\xe3\xf5\x74\xe1\x59\x79\x6d\x7f\xc5\xfc\x1c\x0a\x20\x6b\x81\xb7\xbc\x39\xf6\x37\x2d\x17\x78\xc7\x97\x0b\xbc\x74\xcb\x10\xde\x46\xeb\x30\xba\x97\xee\x3e\xa6\x22\x39\x99\x4e\xa9\xf8\x19\xd1\xfc\xab\x2e\xd6\xcb\x30\xc3\xb7\xf0\x33\x1e\xf3\xb7\x32\xaf\x71\xd6\x36\xf8\x97\x7f\xb1\x50\x30\x02\x1b\xfb\x6f\xcf\x83\x91\xb6\xda\x63\x82\xd8\x10\x84\x89\x51\x2a\x5b\x00\x89\x46\x3a\x6f\xc8\xcb\x1d\xe5\xf4\x36\x28\x0b\xb6\x24\xf5\x36\x77\x67\xf5\x76\x79\xe2\xea\x4a\xc9\xa5\x11\x12\xee\x7c\x59\xc3\x3e\xd5\x92\xc6\x02\x73\xb3\xf9\xac\x10\x18\xfe\x85\x9e\x75\x1a\x50\xa6\xd6\x65\x5e\x03\x76\x3b\xde\x8e\x09\x98\x0c\xa8\x8c\x9d\x77\xbd\x53\xfb\x75\xe4\xa6\xf5\x06\xe3\x5f\x07\x09\xea\x61\x70\xed\xc0\x47\xb0\xa3\x9f\x4f\xd8\x8e\xec\xae\x39\xf1\xfe\x8f\xd1\xac\x8a\xa3\xf6\x05\x11\x99\xfa\x4d\x50\x58\xbc\x59\x2f\x97\xb2\x02\xb7\x13\x1c\x3e\x5e\xfb\x7c\x99\xd7\xb5\xaa\xc6\xdc\xaf\xc4\x2e\x4d\x12\xba\xc5\xbe\xb8\xf2\xd3\x68\x2f\x90\x73\x49\x06\x70\x8f\xf2\x0c\x12\x35\xc0\xdc\x96\x2d\xa0\xcb\x14\xa0\x42\x06\xb7\xa5\xdc\x62\xd4\x3e\xe6\xd9\x20\xe5\xfc\x52\xc2\x1f\x95\x92\xa8\xe2\xc9\x9d\xa3\xa9\x59\x59\x71\x7e\x92\x17\x76\x11\xe8\x19\x11\x69\xd5\x8e\x0f\x7c\xa6\xcc\x90\x30\x04\xd3\x3e\x96\xe8\xba\x03\x66\x18\xc2\x2e\x23\x42\x76\xd9\xcd\x41\x8b\xe7\x72\xa5\xae\xab\xa9\x0f\xa9\xa1\x56\x40\x73\x37\xba\xba\xf9\xff\xb1\xf7\xae\xfd\x6d\xe4\xc6\x9e\xf0\x7b\x7f\x0a\xd8\x67\xc6\xa4\xc6\x14\xe9\xcb\xe4\x26\x45\xf1\xf1\x48\xf2\x89\x36\x96\xe5\xb5\xe4\xe3\xcd\x3a\x5e\x1b\x62\x83\x62\x47\xcd\x06\xa7\xd1\x94\xcc\xc4\x7e\x3e\xfb\xf3\x43\x5d\x70\x6b\x90\xa2\x3c\x33\xd9\xec\xc9\x99\x17\x63\xb1\x1b\x8d\x6b\xa1\x50\x55\xa8\xfa\x57\x88\xaf\x1b\xf6\x9c\x2a\xc3\xfe\x0f\xfd\xbc\xbd\x55\x3e\x0b\x18\x74\xa5\x50\xdb\x1d\x8d\x01\xa1\xec\x00\x05\x63\xe2\xd1\xf1\xc5\x8f\x8b\xb2\xb9\xec\x4e\xdd\x39\x28\x17\x8a\x5b\xb7\xbd\x82\x0b\x99\xa4\xe5\xe7\x3e\xdf\xae\x51\xbc\x2a\xd4\x60\x9f\xa3\xee\xc3\x4c\x08\x7e\xa7\x02\x52\x17\xad\x2c\x0f\x0c\x4c\x5d\xed\x56\x6e\xff\xba\x59\xaf\x05\xa8\x7d\x60\xe7\x91\xe6\xd2\xed\x68\xb4\xe3\x2c\x21\x6f\x2f\xd7\xa7\x1d\xe2\xb0\xac\x97\x1e\x85\xdf\xe7\x81\x77\x94\x37\x55\x19\x8e\x51\x62\xe6\xdf\x9a\x79\x12\x86\x46\xb9\x2b\x70\x59\xd7\xba\x95\xad\xbb\xb4\x42\xf0\x1d\x68\xf9\x9e\xe3\x14\xe6\xde\x00\xb2\xfe\xfe\x08\xd9\x62\xec\xce\xf0\x69\xc6\x21\xe5\xec\x01\x59\xaf\x3c\x48\x33\xfe\x76\x40\xe2\xeb\xba\x08\xbd\xf3\x6d\x05\x26\x31\xfe\xd2\x4a\x29\x57\xa5\xba\xb6\x2d\xe3\x2d\x1d\xc7\x12\x13\x25\x2e\x4d\xab\x66\xbc\x09\x1f\x6c\x07\xff\x3d\xb0\x23\x81\x7b\xe9\xcf\xf6\xaf\x83\x93\x63\xd0\xe0\x3f\xbb\xc7\x2b\x4a\x0b\x5f\x8c\xfe\x0b\x1e\x5f\xa5\x8f\x57\x36\xe9\xf9\x6f\xd0\xe4\x67\x21\xdc\x2d\xd5\xfa\x9e\x74\x6f\xdd\xe9\xbf\xb0\xec\x83\x15\xfd\x5d\xf5\xc9\x83\xcf\x41\x1a\x9c\xcf\x9b\x7d\xec\xdf\x7d\x26\x6c\x6f\xf8\xdb\x77\xfb\xf3\x9a\x6e\x5f\xad\xee\xf6\xe7\xb0\xf6\xcf\xee\xe3\x68\x2a\xa8\xd6\x75\x53\x10\x56\x16\x3e\x1f\x6e\x6f\x6f\xff\xe1\x73\x4c\x70\x9f\x73\x95\xc1\x43\x5c\x27\x1a\xd6\xe7\xce\xeb\x61\x3a\x49\xee\xe7\x83\xb8\xaf\x9f\xc5\xab\x46\xcf\xe5\x85\x6c\x75\x63\x3e\xaf\x20\x84\x95\x95\x7d\xe6\x7c\x44\xf8\xe4\x73\x38\x4c\xee\x19\x1d\x43\x6b\x7b\xf6\x7b\x58\xea\x70\xb5\x84\xf8\xac\x31\xc6\x13\x1e\xfe\xf4\x61\x8a\x45\x6b\x0f\x9b\x52\x99\x70\xce\xba\x0b\x90\xab\x6c\xc3\xd5\xbc\x91\x34\x36\x23\x41\xf1\x7f\x72\x0d\x6d\xb8\x73\xfc\xcb\xcf\xa0\x95\x8f\x40\xc7\x0e\x76\xce\x83\x75\x1f\x3f\x70\xdb\x2e\xbf\x73\x42\x22\xbf\xc5\x86\xff\xcc\xb7\x39\x20\x60\x7c\x76\xbc\x25\xaa\xf3\x73\xc4\xfc\xa2\xf1\xac\x7b\x9c\xe9\x58\xd6\x05\xc8\x3d\x46\xa6\xbc\x6f\x65\x06\x9a\x03\xbc\x42\xae\xc4\xab\x45\x33\xd7\x86\x1d\x9d\x68\x06\x4e\x81\x5f\xfb\xd4\x3f\x74\x7d\x85\x4c\xb1\xac\x2f\xce\x34\x5d\x22\x21\x6c\xb6\x1c\x83\x1f\x04\x1f\x39\xfb\xe0\x65\xd2\xa0\x8f\xb5\xb3\x99\x6a\xa1\x6a\x00\x72\xad\xc1\x5d\x63\x52\x95\xe3\x96\x7c\x77\x89\xe8\x75\xab\xea\xb6\x94\x15\xf5\x96\x7d\xa6\x0d\xa7\xe0\x9e\xcb\x0b\x15\x19\x1d\xb9\xc1\xa3\x83\x3f\xa9\xa5\xd8\x13\x3d\x04\x42\x0d\x9e\xf7\xc4\x03\xd1\x87\xec\xaa\xc7\xb2\x9d\x0e\x1b\x59\x17\x7a\xd6\xdf\xda\x1a\x9a\xaa\x1c\xab\xfe\xe3\xad\x04\x4e\xd4\x8d\xf0\xb9\x76\xb8\xe7\x7d\xf0\x0e\x79\xe6\x23\x4e\x20\x39\xee\x6f\x07\x80\xe8\x6f\x5f\x00\xd0\x3a\x45\x12\xd3\xcd\x11\xc8\x47\x5a\x01\x28\x22\x68\x01\x1f\x63\x5b\xf6\xc7\x3b\xe4\x92\x82\x61\x24\xee\x56\x87\x3c\x22\xe6\x8d\x6e\x35\xe0\x85\xc6\x9f\x61\x56\x0d\x6a\x76\xd0\x9d\x03\x77\x37\x42\x45\xde\x75\x4a\xbc\x07\x78\xf2\xfc\x82\x3d\x78\x40\xce\xc2\x9d\xd5\x7e\xb7\xba\xbe\xf7\x44\x09\x91\x7f\xd7\xed\x6a\x08\x95\xae\xb7\x2a\x0c\x94\x41\x8b\xb7\x15\xde\x16\x2c\x13\x39\x6a\x70\x29\xe5\x1d\x8e\x3e\xc5\x42\x59\xd9\xf8\x93\xb8\xfa\xed\xf0\xe1\x23\x04\x30\x75\x28\x2d\x18\x6f\xbe\x25\xd4\xa7\x69\x79\x5e\xb6\xe0\x07\xd1\x00\xe2\xe9\xb9\x9a\xca\xab\x52\x37\x10\xe4\x04\xd8\xcc\x0c\x06\xf3\x51\xd7\xce\x68\xf3\xd1\x5d\xda\xb5\x78\x37\xc9\xd6\xf6\xd6\x45\xeb\x87\x3d\xb3\xf5\x90\x4f\xdb\x10\x24\x2b\xb3\x9c\xcd\x5b\x3d\x33\xe2\x5a\x35\x8c\x9b\x39\x11\x4b\xc0\x54\xc7\x0c\x06\x58\x09\xa5\xa7\xd0\x57\xaa\xf1\x08\x76\x60\xa7\x27\x8f\x71\x17\x69\x85\x50\x89\x20\x6f\x23\x14\x09\x44\x6b\xa9\x4f\xd2\xca\x0f\x3c\x53\xe7\x72\x7c\x79\xd1\xe8\x45\x5d\x6c\xb1\x36\xea\x25\x64\x2f\x28\xda\x2f\xe3\xd1\x5e\x83\xe5\xdf\xc1\x34\x07\x09\x34\xb0\xdb\xb6\x26\x4c\x5c\x42\x7e\x54\x1f\x83\x8f\xf3\xcb\x94\x80\x80\xea\x89\x18\xeb\x45\x83\x59\x10\x21\xa5\x3d\x04\x47\x05\xf5\x18\x87\x9e\xad\xeb\x0b\x64\x17\xe5\xc9\x29\x69\x14\x03\xf1\xd7\x85\x69\x31\x63\x64\xa3\x4c\xdb\x94\xe3\x96\xa6\x2a\x37\x42\x02\x42\x48\xba\x04\x2a\xd1\xc0\xae\x69\xa5\xa4\x71\x29\xf3\xb1\x4f\xb6\x0f\x78\xb9\xce\x77\x3e\xde\xb1\xcc\x13\x96\xed\x73\x2c\x11\xa7\x59\xa4\xb0\xbf\x33\x5d\x28\xc8\x26\x75\x5e\xe9\x8b\x91\x6c\xc6\xd3\xf2\x4a\x99\xd1\xe3\x87\x8f\x1e\x8e\x1e\xfe\x6e\x04\xf6\xe8\x0f\x50\xd1\x87\x42\x55\xc3\x69\x3b\xab\xa8\xbe\x67\x95\xd1\x03\xf1\x11\x6c\x9d\x1f\x47\x1f\xd9\x16\x8a\x7f\x16\xfa\xba\xfe\xc8\xe9\x4f\xe8\x96\x88\xc6\xca\xb9\x26\x30\x9f\xf7\x39\x66\xc2\x04\x15\xc6\x97\x73\x57\xf6\x2b\xae\x35\xd3\xdc\x34\x02\xfe\x17\x28\x19\xe4\x1a\xfb\x51\xd7\x60\x5c\xff\x98\x77\x8e\x1d\x23\x20\x2f\xb3\x55\xf4\xbc\x12\xfc\x93\x34\x2f\x7d\x5d\x13\x48\x01\x07\x47\xc4\x36\x10\x6c\xf2\x4c\xf7\xd3\x4e\x0d\xf2\xf5\x7b\x63\x07\x31\x20\xb1\x97\x2f\xc8\x9e\x9a\xa5\x71\x5c\x0b\x3d\xfc\xd6\x1e\x09\xfc\x55\x98\x98\x07\x38\x6c\xdc\xb9\x83\xe0\xf5\xbb\xf4\xe5\xfb\x95\xb1\x15\x61\xad\xb9\x90\x8a\xa8\x65\x7b\x00\x86\x1f\xb8\x68\x0a\xbc\x51\x0f\xc6\x95\xde\xab\xfa\x2a\xe0\x62\x35\x28\xf9\xce\xbf\x7a\x9f\xe4\x4e\x0e\xdb\xa5\x7c\x1b\x60\xed\xeb\xa5\x20\x3f\x25\x5a\xd9\x5c\x7e\xe5\x3e\x59\x03\xb7\x62\xcc\x96\x8e\x4b\xbb\xaf\x71\xc0\x06\xc4\x81\x08\xe7\x1d\xff\x8b\x52\x3f\xa7\x2d\x01\x1b\xf9\x8a\xe6\x82\xef\xd6\xb4\x99\x40\xa2\xf1\xc9\x43\xa1\xc5\x9a\x3c\xd6\x15\x20\x89\x10\x68\x16\xf1\x79\xb4\x85\x07\xc9\x7f\x7c\x2d\x37\x30\x8e\x42\xcf\x46\xc8\x69\x46\xad\x32\xad\x19\x61\x55\xc4\x2a\x36\x1c\xde\xc1\xc9\x31\xdc\x1f\x9c\x92\x49\x3e\x37\xc4\x3b\x9d\xe9\xcd\xac\x38\x55\x10\x4e\x6d\xd7\x8d\x3c\x28\x38\xf0\xd7\x00\x9d\x36\xd7\xb7\x04\x57\x49\x3d\x48\x29\xd3\x7d\x99\xe4\x30\x5e\xd5\x09\xac\x63\xe0\xee\xa3\x32\xc3\xce\x7f\x08\xf5\x0f\xf8\xa2\x36\xf8\x2c\x44\x60\x8a\x92\x15\xd8\x92\x70\x44\x40\x53\x64\x05\x09\x6c\x32\x0d\x19\xe2\x30\x28\x00\x7c\x90\xc6\xca\x6f\x9b\x60\xaf\x52\xf3\x1d\x10\xa3\xa4\x0c\x8c\x2d\x29\xb4\x7e\x46\xf1\x7a\x62\x83\xed\xca\x37\x17\x50\x77\x66\x1b\x75\xe7\x6b\x9f\xbf\xf0\xdf\xae\xa6\xb0\xce\x50\xf0\xeb\xdb\x8d\x05\xae\xaa\x37\x18\x0a\x5e\x69\xdf\x62\x24\xf4\x81\xfb\xf2\x36\xe3\xb0\x9f\xac\x1e\x46\x64\xdd\x5e\xc3\x92\x53\xba\x8e\xb6\xb5\x2f\x17\xc7\x42\x98\x90\x73\x67\xf6\x1a\x53\xee\x0a\x5e\x9f\xc1\x10\x8e\xc3\xc5\x02\xc9\xfe\x59\x55\x85\xc7\x5b\xe6\x60\x8e\xf4\xa7\xff\x6b\x67\xec\xff\x5b\x47\x6c\x8a\xbf\xec\x51\xdd\x39\xc3\x44\x43\xc9\x3d\xd8\x25\xbc\xbc\x52\x35\x46\xf3\x5a\xa5\x84\x4b\x39\xe4\x94\x4a\xc9\x09\xbe\x62\xc8\x02\xc0\x12\x69\x54\x9d\x8a\x7d\x07\x27\xc7\xe4\xb5\xf9\xf9\xe0\xe4\xf8\x4c\x7d\x82\xb4\x4a\x5f\xe0\xe3\x28\x68\x69\x45\xc1\x8e\x9f\xdb\x0b\x25\x27\x18\xdd\xa2\x0b\x12\xc8\x02\x70\x7b\x07\x93\x02\xfd\x8c\xb0\xed\x42\x1c\x0f\xff\x36\xd1\x35\x11\x2a\x25\x98\x08\xca\x8b\x5f\xab\x4f\xad\x20\xf4\x0f\x56\x97\xa4\x17\x2b\x49\xad\x00\x2d\x04\x40\x84\x17\x73\x56\x8e\x0e\x4e\x8e\xd1\x17\xd6\x56\xdd\x33\x5c\x09\xdd\xe7\x81\x0b\xaf\xfa\x34\x95\x0b\x83\xe8\x5f\x5f\x37\x79\x4f\x37\x9d\xbd\x53\x6c\x7d\xf5\x04\x76\x60\x6d\xec\xc8\x4f\x53\xfc\x96\x60\xb6\xc2\x02\x29\xc6\x0a\x4f\x37\x62\xfb\x30\x0c\xfc\x97\x64\x7e\x49\x71\x2a\x94\x19\x37\xe5\x39\x07\x17\xd8\x0f\x0d\x23\x51\xe2\x3c\x8b\xf1\x54\x36\x72\x0c\x58\x99\xb2\x15\x7a\x32\x41\x2c\xca\x8d\xe6\x0c\x21\x9c\x7d\x39\x0c\x68\xfa\x42\xb5\x64\xe3\xe7\x3a\xb3\x07\x19\xc1\x74\xb3\xcf\xdd\x38\x81\x6f\xfb\x98\x68\x00\x2b\xea\xe4\xca\x08\x49\xd6\x85\x44\xf3\x7b\xb8\x7c\x67\xf8\x00\x7e\x78\x58\x17\x64\xed\xba\x61\x65\x74\xa1\x5c\x8a\xba\xb3\xc3\xff\x75\xf6\xe1\xe5\xc9\xc1\x61\x8c\x06\x84\x75\xf9\xa6\x1e\x10\x88\x90\xfa\xd4\x52\x4a\x13\xe6\x53\x77\x02\x71\xdc\x97\xff\xfd\x1e\x8d\x8b\x37\x96\xad\xf0\x0f\x7b\xd1\x60\x23\x92\x08\x4f\x41\x5b\x7e\x07\xfe\x3f\x08\x9e\xe2\xa7\x3b\x5c\xef\xb6\xef\x9d\x3f\x05\x3b\x47\x4b\x38\x59\xd4\x8d\x08\xb1\x36\x33\xd9\x39\x6a\xdf\x4a\xe9\xaf\x4b\x35\x5f\x84\x5e\xb4\x18\x45\xbf\x19\x51\x20\x11\x98\xbe\xfb\x2c\xc8\xb7\xcd\x5e\x25\x2e\x1b\xe1\xd0\xf6\xca\x3d\xbd\x7f\x3f\xf7\x98\xe2\x2f\xe0\x18\xf0\x35\x7c\xfe\xec\xab\x1b\x82\x9d\x09\x0c\x6d\xb0\xf8\x0f\xd7\xe1\x63\x11\x4a\xc1\x54\x37\x94\xed\xce\x57\xe3\x1f\xef\x46\x05\x71\x48\x99\xa2\xf8\x82\x0b\x83\x38\x6a\xbf\xfe\x06\xfc\x34\x7d\x61\xf7\x22\x2a\x99\xa9\x35\x78\xce\x7e\xfc\x47\x35\xeb\x3e\x83\xb0\xdb\x4e\xfc\x7d\x89\x68\x0c\xb5\x38\x57\xe2\x9e\xac\x75\xbd\xb4\x5a\x90\x28\xca\x2b\x73\x6f\x20\xc0\x74\xe0\xfc\xef\x17\xf3\x11\x20\x81\x51\x52\x69\xc2\x46\xfc\x3d\x38\x8b\x81\x0d\x66\xef\x1e\xb2\x81\x7b\x7f\x18\x8a\x67\x51\x5d\x6c\x00\x31\x4a\xcd\x1c\x56\x04\x26\x7c\x0f\x3c\xff\xad\xf0\x57\x5e\x5c\xa8\x06\xdc\x61\xc5\xbd\x57\xaa\x99\x95\xc6\x40\xc0\xa8\xaa\x4b\x55\x20\xf6\xe4\x3d\x38\x01\x6a\xf0\x32\x28\x5b\x73\x87\xc0\xc5\xa3\xf8\x01\xcc\x31\xa1\x0a\x34\xee\x81\x3c\x6f\xdb\x2e\xeb\x8b\x6a\xe9\x11\xeb\x01\x32\x5a\x0b\x09\x18\x00\x50\x37\x58\xa8\x00\xc8\xc2\xe5\x7e\x33\x46\x48\x1f\x8e\x85\x50\xe8\xcb\x79\x39\x86\x00\xbc\x6b\xdd\x5c\x1a\x0a\x9f\xac\xb7\xe3\x09\xa4\x00\xc7\xd1\x88\xad\x67\xf5\x92\xc0\x33\xd1\x34\x28\xc9\xea\x09\x18\x8e\xb2\x29\x0d\x22\x62\xe0\x27\x56\xcd\x34\x3b\xa3\xd1\xf9\xe2\xe2\x6f\x65\x55\xc9\xe1\x4c\xe3\xbf\x56\xd3\x34\x53\x7d\xfd\xe1\x7c\x71\x31\x1c\x5f\x94\x4f\xcb\x62\xef\xf1\xc3\xdf\x7e\xff\xf8\x37\x71\xac\xe2\x77\x09\x0e\x16\xa2\x5f\x2d\x8c\x2a\xb6\xd5\x27\x30\x50\x95\x76\x11\xbf\x1b\x31\x08\x05\xd1\x86\x63\x84\xc8\x11\x42\xaa\x4c\x5e\xf9\x26\x30\x02\x70\x5d\x0b\x5f\x68\x0e\xfa\x9d\x64\xf6\xe1\xe6\xa2\x67\x98\xf0\x5c\x35\x35\x31\x83\xe7\x8d\x9e\xbd\x82\x7c\x00\x9e\x2d\x84\xe4\x3c\x88\x36\xda\x20\xea\xf3\x20\xdc\x2d\x91\x0f\xd1\x6b\x1f\x03\x20\x9b\x76\x20\x54\x5d\x7c\x21\x27\xa1\x8f\xf0\xe8\xa3\x03\xe5\xe4\x13\x6a\x34\xd6\x85\x42\x63\x6e\x59\x17\xea\x13\x39\x8a\xf4\x57\x75\x65\xcb\xdb\x82\x95\x08\x4e\x09\xf0\x8f\x71\x43\xf9\x38\x40\x4a\xf9\x4e\x7c\x54\x75\xe1\x5a\xe5\x16\x44\xdf\x8d\x27\x1e\x0c\x9f\xd5\xaf\x03\x8c\x2e\xb2\xfe\x02\x58\x98\x28\x6b\x71\x21\x9b\x73\x79\x61\x2b\xb3\x9b\x14\x53\xf8\x31\xe2\xab\x4b\x7b\xfb\xd7\x85\x69\xc5\xb8\x91\x66\xca\x55\x1e\x7e\xa2\xbc\x7b\xb0\x73\xc0\xea\xaa\x4c\x4b\x01\xfe\x31\xc3\xfe\x85\x56\xca\x71\xfd\x18\x14\x88\xd2\x6b\xc0\xc9\xb5\xfd\x88\x9f\x28\x38\x97\xfd\x6f\x98\xba\xb7\x30\xf5\xcf\xa0\xbd\xf0\xf3\xe0\x25\x6b\xe6\x91\xc0\x20\xf6\xfc\x99\xc5\xcf\xbd\xc8\xe5\x22\x8f\xef\x08\x2c\xb6\xb3\x2a\x53\x04\x08\xb9\x41\xe9\x2c\xde\x61\x82\x0a\x18\xb0\xe8\xfb\xf7\x99\xae\x98\xd3\xdb\xa3\xc9\x21\x20\xae\x10\x57\x42\x19\x82\xe7\x89\x66\xf0\x81\x48\x4f\x1d\x91\x80\x58\xbb\x6e\x44\x47\x91\xed\x48\x74\xe2\xdc\xb6\x1f\xb8\x3a\xae\x17\xd1\x29\x95\xea\xbc\x9b\x4a\x63\xc2\xd5\xb7\xe7\xfb\xf1\x9f\xb2\x5a\x28\x27\x81\x65\xaa\xee\xf3\x9a\xa4\x3a\xcd\x1e\x85\xed\x87\x0d\x44\xa0\xd2\x41\xd6\x02\xca\xfa\x8b\xf0\x15\xb6\xa6\x8f\x90\xde\xb3\x35\xa4\xcd\x21\xc0\xe4\x47\xdb\xd4\x47\x36\x20\xc6\xf4\x93\x01\x90\x54\x9f\xe2\xdc\xbf\x37\x93\x4a\x22\x20\xb9\xee\x1d\x45\xac\x05\x90\x81\x59\x9b\xa4\x44\x71\x70\x63\x03\x60\xcf\x10\xae\xae\xc6\xba\x2e\x44\x5b\xce\x94\xb8\x2a\x4d\x89\x97\x34\xbe\xbe\xd2\xa5\x89\x9b\xc2\x3d\x5a\xa6\x36\x8c\xb6\x0b\xf4\x59\xad\xe7\x03\xe7\x66\x14\x64\x69\x80\x0a\xaf\x64\x55\x16\x81\x30\x67\xbb\xb3\x4a\x32\x81\x34\x26\xea\xc7\x85\xac\xf0\xd2\xa4\x34\xa4\xad\xf9\xea\xec\x07\x50\x0c\x25\x60\x23\x1e\x42\xa8\x22\xa9\x3a\xd2\x28\xcb\xf1\x7c\x56\x3b\x74\xd4\x2c\x30\xa6\x6d\x18\x2f\x36\xce\x69\x6e\x67\x84\xeb\xd7\xd9\xa6\x0f\x1e\x64\xf8\x8d\x2b\x75\xd2\x91\xed\xe3\x7d\xb9\x41\x73\xe9\x76\x8c\x1a\x24\x1e\xc6\xc5\xba\xcd\x85\xdb\x2f\xd7\x58\xb4\x29\x22\xfd\xf4\xee\xa6\xbb\x82\xa8\x38\x56\x4c\xb3\x74\x3f\x4c\xcb\xf8\xac\x35\xab\xf7\x55\x64\x2e\x08\x37\x56\xb2\x7b\xbe\xb0\xa0\x4f\x33\xbc\x67\xcf\x04\xcb\xa9\x60\x0a\xe0\x57\x0a\xbc\x98\xe4\x1f\x99\xcf\x55\x3d\x14\xfd\xb7\xf0\xd0\x03\x32\x82\x0f\x23\xac\xe6\x08\x8d\xc6\xa8\x4e\xdb\xa1\xf4\x1c\xc0\x06\xe6\xda\xad\x96\x9c\x4e\x0d\xdd\x22\x18\xb3\x13\x06\xbf\x75\x93\xe4\x83\x9d\xa3\x28\x69\x94\x4b\xee\xd0\x1a\xee\xd8\xff\x39\x50\x3f\x92\x61\x8e\x00\x91\x4d\x81\xf1\xa0\xde\x3e\x3a\x64\xaf\x4e\xc3\x89\x7c\xd8\x0d\x15\xb7\xc8\x84\xbc\x35\x61\xcf\x50\x62\x26\xc8\xb3\xcb\x9b\x31\xca\x4a\xbc\x23\x8e\x0e\x1f\x3d\x7c\xc0\x55\x20\xbb\xf0\xea\x16\x5f\x1a\x9f\x03\xf6\x2a\xb8\x54\xa0\x8c\xef\x1d\x5f\xe1\xde\x59\x7d\x6a\x41\xac\xc1\xbc\xc7\xec\xc6\x19\xe4\x10\x54\x57\x76\x96\xdd\x48\x8e\x0e\x07\xa2\x44\xa4\xb8\xd6\x89\xea\x94\x44\x19\x02\x1c\xe4\x6c\x26\x5b\x92\xbf\xc9\x57\x5b\xba\xe1\x04\xea\x90\x38\x9b\x2e\xcc\xc0\xa1\x7a\x1e\x1d\xda\x4a\xae\x54\x03\x62\x29\x4c\x10\xe5\xfe\x10\xba\x2a\xc4\xd1\x21\xe4\x3f\xf6\xfe\xdf\x7a\xd1\x64\x26\x66\x63\x63\x52\x72\xc3\x4a\xdc\x29\x16\x9f\x8c\xd7\x77\x41\xaf\xe7\x52\x01\xee\x4d\x46\xa3\x5d\x03\x81\x73\x83\x8a\xdc\x77\xe6\x12\x27\x55\x01\x46\xef\x85\x02\x14\x65\x92\x4e\x9f\x81\xd2\xa3\x9b\xfe\xd6\xfb\xe0\x30\x0d\x25\x2f\x70\xd8\x99\x95\x75\x9f\xfa\x3b\x24\x11\x9a\x60\x3b\x63\xb1\x8c\xcb\xf0\x26\x74\x09\x94\xc5\x53\xaa\x70\xa7\x5b\xa1\xaa\x8b\xa0\x3a\xd2\x65\x0f\xc5\xa3\x47\x02\x92\x43\x11\xa9\xb8\xe1\x22\x15\xb2\x57\x0f\xd3\x3c\x38\xb9\x02\xf5\x11\xf1\x0d\x19\x65\xb8\x9c\x67\x08\xc6\x70\x90\x38\xec\x1b\xe5\x60\x9e\x8c\xd5\x1a\x95\x00\x2b\xc1\xb0\x63\x4a\x18\x52\x0b\x10\xf6\x6a\x47\xf3\x07\x3b\xee\x50\x10\x6c\xd5\x6c\x2e\xf6\xec\xd3\xdd\x3b\x9e\x21\x43\xe1\xdd\x3b\xe1\x81\x60\x0b\xc6\xcb\x69\x5f\x1c\x4b\x70\xbd\xde\x5b\x63\x32\x43\xe2\x81\xd2\xe1\xe4\x6f\xfc\xa5\xed\xf0\x6e\xc4\x3c\xe9\xd3\xfb\xf7\x7d\x3d\xa1\xc5\x6c\xa5\xed\x04\xce\xa7\x9c\x49\x04\xde\x06\x55\x0f\xd9\xbe\x9c\x37\x8a\x74\x8a\x7b\xbb\x59\xc6\x30\x02\xa5\x5d\x47\x33\x55\xa7\xf2\xab\x2f\x9b\x9a\xde\xfc\xa6\x8a\xd0\x21\xc1\x13\xa9\x83\xa0\xf0\xda\x3e\x66\xcc\x59\xa4\x0f\xa3\x5a\xb0\xac\xf5\xd3\xb1\x0e\x32\xc3\xa1\x2f\x83\xd9\x04\xc7\x9a\x67\x55\x05\x35\x9b\x3e\xdf\x63\xfa\x43\x2d\xa2\xae\xf0\x53\x59\x14\xd8\x1d\xe8\x87\xbb\x4e\x4a\xe9\xb4\x1f\x4f\xd3\xa0\x3b\x15\x11\x6c\xba\x9b\x16\x1e\xdc\xe1\xe6\x55\xdc\xd8\xbb\xdc\xed\xd5\x51\xed\x2e\x99\xbc\x99\x96\x4e\x47\x32\x5c\xc3\x92\xf7\xdd\x52\xf0\x1f\x87\x0c\x51\x06\xdf\x85\xa7\xe4\xbf\x53\xf6\xf2\xf9\xc2\xb3\xc2\x1d\xe7\xc9\x68\x15\x63\xcf\x37\x31\xff\xfe\x50\xfc\x20\x0d\xc2\x4f\xb8\x2f\x86\x7f\x35\x03\x5b\x9b\xe5\x34\x00\x83\x5a\xfa\x3c\xfc\x8b\xb2\x05\x0b\x88\x3d\x6b\x1a\xe7\x64\x3f\x85\x64\xbd\x63\xbd\x00\x87\xaf\x09\x64\x47\x41\xe0\x8f\x3e\xb1\x2a\x5b\x1f\xe5\xe5\x62\xab\x1a\x48\xa9\x48\x6f\x9e\x33\x21\x92\x94\x2a\xd0\x7b\xe7\x28\xdb\x67\x68\x1c\x33\xaf\xa0\x77\x68\x98\xe2\xde\xc7\xe8\xc9\xb9\x3c\x27\xc7\x63\x40\x75\x8b\x4d\xec\x2f\x31\xdd\xbb\x7d\x01\x9b\xbf\x52\xb3\xa1\x7b\x9e\x3e\xe8\x02\xf8\x04\x37\x19\xfc\x45\xdf\x57\xbb\xb7\xc7\xa1\xa5\xae\x2a\x9f\xae\xbd\x55\x9f\xda\x1e\xab\x95\xbe\xbc\x7d\x2c\x1b\x25\xe1\x15\x7c\x42\x2e\x42\x87\x05\xcd\x39\x16\x6b\x16\xaa\x97\x80\xcc\x85\x27\xdf\x51\x3d\xd1\x0d\x86\x79\xf7\xfd\x88\x81\x2d\xa8\xc2\x52\x0e\x72\xc9\x67\x63\x88\x9b\x22\x60\x94\x70\x48\x7f\xf7\xd6\x30\xfc\x60\x27\xfc\x31\x88\xf7\xf1\x6b\x0c\xc8\x5b\x39\xef\xc1\x97\x5b\xe2\x69\xd4\xd1\x6f\x1e\xc5\x6f\x31\x55\x64\x2a\xf7\xfd\x7b\x03\xb0\xac\x2a\x20\xe7\x23\xb4\x89\x06\x7a\x95\x1f\x32\xb8\x40\x3a\x1f\xde\x6a\x29\x2a\x0d\x98\xd1\xdf\x09\xaa\x07\xb4\x3c\x0e\x45\x5a\x18\x35\x59\x54\x88\x29\x3f\xc7\x3c\xf5\xe0\xf2\x38\xa7\xc8\x7b\x8e\x57\x01\x21\x99\xc0\x50\x0a\x3d\xb3\xd5\x91\x5c\x5c\x17\x62\x5e\xc9\x31\x21\x12\x40\xfe\xf6\xb2\x1e\xd8\xc6\x16\x55\x8b\x19\xc5\xc9\xfb\x02\x31\xd4\x6c\x77\x12\xcb\x52\x3a\xc0\x3e\x64\x8f\xcc\xad\x67\x94\x22\xe3\xf9\x06\x2b\x8a\xe8\x18\xa5\x4e\x0a\xaf\x6c\x60\x18\x2c\x48\xf4\xfd\x69\xb4\xde\x6b\xab\x88\x49\xc3\xc1\x5b\xc7\x1d\xb6\xfa\x56\xa7\x63\x70\x25\x1d\x70\xc5\xb4\xc0\x56\x78\x2e\xaf\xa4\xb8\x95\x5f\x59\xaa\x6d\x93\x59\x0e\xca\x0d\x72\x23\xdd\x4a\x55\x37\xf8\x00\x8d\xf6\x35\x5f\x28\x60\x18\x2a\x9a\x18\xd0\xa5\x8a\xe1\x03\x82\xf8\x39\x2b\x0b\x9a\xb2\xa1\x74\x0c\x31\x06\xb4\xa1\x4c\x0a\xe9\x73\xd1\x9d\xa4\xdd\xd0\x66\x12\x94\xe3\x3f\x03\xad\x33\xb6\xa6\xb8\x02\x91\xbd\xe9\xf0\xc5\xe1\xf1\xe1\xcb\xae\xc9\x29\xc1\x71\x0e\x2f\xe7\xc8\x97\x78\xc7\x95\x09\xef\xe8\x2a\x35\x09\xde\x0c\x71\x3a\x5e\xa8\x49\x1b\x16\x6a\xf5\xbc\x53\xe6\x4c\xcf\xfd\x2d\xde\x56\xac\x75\xd3\xec\x3b\x19\xa8\xbb\xc4\xbb\x5c\xa2\xeb\x5a\xb1\x16\x0d\x9a\xcd\xa4\x13\x1d\x4c\xa1\x77\xa8\x10\xf0\x6a\xc8\xde\xd3\x7e\x34\x90\x06\x61\xa2\x87\x76\xb8\x6b\x8a\x9e\xe9\x39\x97\x6c\xf5\x3c\x91\x04\x98\xbf\x85\x2c\x71\x47\xfc\x87\x6a\xd9\x58\xc5\xdc\xed\x5c\x2f\xea\x02\x9c\x7e\x25\x33\x62\xc1\x67\xc5\x80\x4e\x75\xdd\xb0\x63\x76\x78\x5e\x80\x26\x6e\x5f\x6c\xff\x7b\x89\xa1\xe5\x2f\xb4\x06\x1f\x83\x5c\xed\x68\xe3\xb2\xe5\xf0\x13\x3e\x0e\x58\x47\xe7\x4f\x4e\xdd\x25\x42\xf0\xf0\xb0\x2e\x32\x4e\x03\x01\xab\x87\x8a\xf3\x37\x9c\x0e\x97\x1a\x29\xb5\x17\xb7\x04\xa0\x4b\xc1\xd7\x64\x41\x01\xad\x88\x23\x3b\xd1\x21\x9b\x66\xc2\x4d\xce\x30\x3e\xaa\x28\xb4\x3b\x30\x3b\xc0\x17\xc3\x64\x60\x77\x9c\x2d\xa9\x53\xe0\x90\x60\x3c\xbf\x04\xf8\x45\xae\x4b\x7c\xe1\xa1\x78\xf6\x75\xc3\xda\xf6\xea\x0e\x05\xd7\xc0\x38\xc4\xd4\x4c\x12\xdd\xe3\xfe\x9d\x3b\xfe\x90\xa6\xff\x61\x72\x56\x9a\x88\x96\x4e\xd7\xd3\x12\xf7\xca\x76\x14\xe7\xce\x59\x24\x95\x61\x9b\x06\xce\x40\x40\x43\x30\x39\xa7\xaa\xbd\x81\x84\xc2\x75\xc0\xaf\xd9\x68\x29\x08\x70\x13\xb0\x22\x21\x57\xa9\x6e\x66\x14\x86\x60\x68\xd8\x8a\x30\x93\x2f\x54\xfb\x5d\xc7\x8e\xe0\x59\x38\xb4\x94\x98\x12\x42\xe5\x3d\xd6\xd9\xfd\xc2\xc6\xaa\xba\x23\xbc\x8e\xda\xce\x04\x97\xa8\xb1\x5f\x36\xa6\xd4\x1c\x81\xc5\x0a\x71\x97\xc2\x42\xa3\x03\xd8\x06\xb0\xc8\x55\x60\xf1\xdf\xea\xd0\x9f\x49\xe8\xc8\x4f\x4a\x04\x81\x6a\x2e\xcb\x14\xc3\x82\x53\x59\xac\x47\xd7\xb3\x67\x73\x8f\xd5\x0f\xbb\xf9\x60\xac\x2e\x84\xe1\xfe\x7d\xd1\x51\x52\x6c\x29\xf1\xfb\x3d\xf1\xe8\x11\xe1\x2d\x80\xfb\x29\x22\x28\x3c\xa1\xbd\x88\xe3\xde\xa1\x41\xcc\xa7\x56\x13\x79\x9d\x38\xcd\x99\x1d\x9f\x7a\x00\x9d\x0e\x77\x44\x4f\xd7\x38\x8c\x1e\xaf\x2a\x79\x39\x87\xef\xc8\x8f\xb2\x87\x5b\x16\x0b\x86\x7e\x73\x3b\xe2\x5d\xe8\x56\x1b\xe3\xfb\xd0\x13\xe7\xac\xeb\xd1\x61\xfc\xaf\x37\x73\xfa\xdb\x01\xaf\x84\xbf\xdd\xdb\x64\xc2\x7b\xef\x71\x45\x68\x56\x64\x28\xb5\x81\x3b\x04\x5a\x4b\x3b\xef\x8e\x6a\x93\xbe\xaf\xa4\x09\x9c\x42\xc2\x37\x33\xee\x91\xcf\x95\x1b\x7a\x4e\x49\x8f\xef\xcd\xf2\x89\x14\x8b\xba\xfc\x71\xa1\x44\xa3\xe6\x8d\x32\xaa\xe6\xe4\x41\x93\x28\x5b\xa3\xd7\x73\xc9\x4a\x18\xe4\x23\x06\x12\xc5\x0b\x08\x08\x01\x51\x01\x70\x98\x90\x90\x6c\x99\xc4\x66\x1f\x94\x6f\x7c\x38\xc8\xb5\x16\x65\x61\xe5\xf6\xb1\xac\x42\x85\x50\x07\x60\xc3\xe4\x3a\x58\x55\x2e\xff\x8c\xfb\x02\x07\xb4\xc6\x7a\x99\x71\x7f\x5b\xe5\x9a\xe3\x59\x8c\xd7\xcc\x57\x6d\x78\x36\xc1\xac\x14\x48\xd1\x81\x28\xf6\x05\x48\x0e\x22\xcc\x11\xb6\xfa\x1c\x8a\xdf\xe7\x8e\x21\xdb\xbb\x35\x06\xd4\x8d\x2d\xa6\x9d\x1e\x7a\xbb\xd6\x4e\xd6\xda\x35\x88\xca\x9d\x90\x8f\x56\xde\xd4\xc5\x65\x9d\x24\xb7\x93\x33\x71\x45\xa5\xba\x15\x06\x8f\x83\x59\x08\x4e\xc1\x57\x56\x02\xf7\x83\xc5\x1c\xd5\x56\xc7\x83\xf8\x4e\xb0\xb7\xa3\xc4\xde\x71\x9b\x64\x0b\x76\x80\x29\x12\xbb\x72\x9d\x32\xac\x02\xbc\x4b\xe8\xc6\x12\x7b\xdb\x2c\xc6\x34\xa5\xe8\x1a\xbd\x09\x08\xca\x68\x24\x0e\x31\x28\xf5\x5a\x39\xb4\x16\xd1\x00\xae\xb8\x43\xa3\xc7\x3b\x46\x82\xf1\x5b\x58\xa1\x87\xc2\xf4\x8a\x46\x5e\x5c\x04\x69\xbf\xfc\xc8\xfb\x70\x1c\xcf\x08\x2f\x81\x10\x2b\x3e\xe2\x7b\x86\x26\xe1\x90\xc3\xad\xa1\x38\xaa\xc5\x1f\xcf\x8e\x5f\xfc\x6a\x40\x55\xdc\xa1\xb4\xea\x0d\xc4\xbe\x56\x4b\xa1\xeb\x40\x4e\x70\xd2\x43\x3b\x5d\x30\x22\x05\xa4\xf2\xa9\xb5\x93\x52\x39\x11\xc1\x35\x79\xfa\x60\x24\x1f\x63\x38\xb0\x81\xd9\xf3\xaa\xcf\x9f\xbb\xec\x90\x40\xe6\x33\xaf\xac\x0e\xd9\x55\x7b\x6f\xc8\xf8\x78\x02\x5e\x1e\x80\x9e\x6a\x95\x7e\x3f\x59\x60\xc1\xe2\x7b\x2d\x4f\x1f\x61\x42\xca\xd3\x58\x70\xf3\x3b\x27\xe9\x99\xcf\x45\x19\x33\xe8\xcf\x9f\xc5\x5d\x33\x05\xfb\xd6\xe1\x8f\x0b\x59\xf5\xa3\xd7\x83\x4e\x33\x6e\x2c\x29\x9f\x4f\x0b\x92\xfa\x03\x9b\x3c\xa2\x50\xb1\x27\x62\x92\xfd\xe6\x91\xdd\xf3\xaf\xb4\x86\xf4\x2c\xc1\x81\x4c\xdc\x65\x90\x3b\x73\x36\x40\xdc\x41\x21\x24\x6a\x8a\x0c\x5e\x0c\x91\xd5\xdb\xcd\x96\xe1\xec\x05\xc9\x14\x52\x8d\x72\x3c\x5e\xcc\x16\x95\x6c\xd5\xd9\xb5\x7e\x65\xc5\x83\x03\x07\x00\xd2\x8f\xab\xe2\x4e\xb0\xdc\x1c\xbd\x4c\xa5\x6a\x97\x06\x91\xc3\xc2\xed\x46\x41\xb8\x03\xba\x13\x33\xf6\x8c\xfc\xc8\xa2\x04\xef\x16\xd8\x80\x0e\x7f\xc6\x10\xf9\x50\xd0\x25\x58\x38\xf1\x94\x03\x91\x96\xa8\xdf\x9d\x48\x2e\x02\xc4\xbd\x11\xb2\x51\x3b\x20\x1d\xd3\xc6\xea\x5b\x4e\xf5\xb1\x34\x0e\x0c\x8c\x26\xe4\xe3\x16\x96\x8a\x24\xea\x54\xdd\x73\x07\x32\xa5\x0a\x84\x68\x5a\x2b\x45\x27\x08\x42\x80\xea\x31\xe3\x03\xde\xa1\xee\x4c\xb4\x25\x4c\x70\x53\x97\x4b\x43\xdd\x7a\x4e\xbb\xbf\xa3\x5a\x4e\x4a\x55\x15\x46\x48\x23\xae\x15\xa0\xd3\xe0\x08\xcc\x30\xfc\xce\xea\xe3\x63\x5d\x55\x72\x6e\xb9\x41\x24\x3a\xb8\x32\x98\xfe\x00\x19\x1a\xeb\x1a\x18\x5b\x1f\xb0\x51\x02\x04\x40\xa1\xd1\x93\xed\x4e\x24\x53\x0e\xec\x02\x47\x18\x52\x3b\x3e\x61\xc9\x4f\xc4\xa9\xa2\x10\x0c\x3d\x8e\x13\xe6\x61\x91\x21\x85\xb7\x82\x6b\x4d\x27\x33\xc7\xd3\xcc\x07\x4e\x70\xde\xc9\xbc\x8c\x0c\x34\x07\x27\xfb\x6f\x9c\x85\x26\x57\x57\xb6\x0a\x7d\x5d\x2b\x17\xc2\xb2\xeb\xdc\x00\x1a\x39\xbe\x74\x07\xa1\xac\xc2\xa0\x64\x04\xdb\xa6\xa8\x63\xb7\x19\xc0\x1f\xa6\xd6\xb5\xc2\xf7\x03\x04\x62\xe5\xfa\xec\xe9\xc3\xa0\x43\x0c\x4b\x05\x79\xce\x9e\xfc\xfa\xc9\xef\x86\xce\x52\x77\xd7\x4e\x9b\xe5\x7d\x6b\x03\x76\x02\x91\xde\xce\x73\x37\x08\x25\x4c\x14\xeb\x2f\x1c\x61\xbc\xe4\x75\x11\x24\xcd\x78\xea\x2e\x02\x1b\x3d\xe3\xfc\x26\xdf\x3c\x0a\x53\x8e\x88\x1d\x92\x82\x98\x7b\x5d\x97\xe0\xb6\x19\x25\x73\x71\x9d\x70\xd3\xe7\x94\xe2\x20\xec\xde\x9e\x1d\x70\xe6\x0d\x9d\x36\x62\x54\xa0\x3f\xec\x38\xd3\x16\x06\x84\xa5\xdb\xbb\xef\x87\x01\x10\x78\xfe\xe7\xba\x2b\x80\xc8\x65\xbe\xab\x46\xf8\x4a\x76\x57\x95\x73\x2a\x45\x9a\xdc\x11\xff\xcb\xab\x17\xce\x4a\x97\x77\x94\x71\x43\x07\xbd\xca\x8f\x7c\x95\x9e\xb3\xbe\x63\x71\x99\xf5\x1d\x8a\xba\x31\x1a\x89\x03\x90\x36\xe0\xac\xf7\x18\x50\x68\x39\x0d\x65\x28\x96\x9f\xe8\x56\x60\xe6\xe1\xa5\x7c\x55\x46\xcd\xa4\x55\x33\x0c\xab\x43\xc4\x52\x43\xfe\xdf\x59\x7b\xaf\x15\xfa\x59\x08\xf5\xb2\x38\x92\x32\x3f\x89\xa1\x46\xba\x93\x6d\xe0\xcd\x7c\x45\xf5\x41\xd0\x56\xb0\x8b\xbe\x46\x48\x0d\xe6\x74\x7f\xda\xe8\x19\xba\xae\x1d\x1d\xe2\xdc\xd6\xba\xde\x76\x39\x3f\x78\x92\x23\xd1\xaa\x74\x02\x37\x20\x61\x04\xd3\xaa\x67\xaa\x2d\x67\x10\xae\x83\x70\x0c\x53\x69\xea\x5e\x6b\x85\xd1\xc3\x1e\x07\xac\x92\x04\xba\x00\x8b\x91\x6e\x0a\xb6\xf7\x35\xca\xcc\x51\x4c\x15\x2e\xf6\xf5\x52\x61\x1a\x11\xdc\xa1\x1e\xaa\x03\x50\xda\x41\xc8\x22\x34\xe9\xd2\x8c\x6d\x7f\x4b\xb7\x6c\xa3\x91\xaf\x88\x63\xa8\x53\x2f\x8b\x04\xec\x13\x2a\x43\x64\x7d\x3f\x58\xd3\xca\x76\x61\x7c\x5d\x78\xbe\x01\x9a\x9a\xed\x9c\xaa\xdb\x66\x49\x38\x1c\xee\x1b\xca\xc0\x4b\x65\x09\x4a\x01\x5d\x97\x00\x61\xcf\xd7\x06\xc8\x0b\x03\xf6\x6e\xc6\xb6\x75\xed\x3f\xa1\xe3\x98\x8e\x74\xa0\x14\x3d\x11\x53\x5d\x01\xee\x36\x96\x89\x6a\x1b\xe0\xd4\xcf\x16\x55\x5b\xce\x2b\xe5\x6a\x0a\xf2\x02\x20\xee\xa4\x6d\x92\xb4\x00\x85\xdd\x10\xa5\x19\x06\xdc\xd1\xf9\x5b\x1a\x0d\x0e\x45\x72\x3e\x6f\xb4\x1d\xb6\x3d\x53\x8e\x0e\x1d\x08\xe2\x80\xa1\x2d\x44\xa3\xa4\xd1\x75\xec\x9f\xe8\x88\x3b\xb5\x9a\xc4\x3c\x74\x95\x21\x2b\x66\x8a\xd1\x9e\x8a\x3c\x5b\x27\xb2\xaa\x0c\x27\x27\x4d\x9b\x66\x43\x4f\x67\xc3\xa1\xcd\x67\xe7\xe7\xdb\x53\x5f\xee\xe4\x75\x95\x20\x31\x06\xe6\x49\x9b\xc8\x31\x81\x23\xe5\x60\x3d\xae\x9f\x40\xac\xc4\xd9\xeb\xd1\xd8\x98\x27\xdb\x1e\xe6\x7b\xf4\x6f\x71\x7a\x86\x6d\x57\x59\x54\x8d\xd9\x19\x8d\x0a\x7b\xe6\xe9\xb9\x6a\xa2\xf0\x0b\x55\x6f\xbf\x39\x1d\x15\x7a\x6c\x46\x6f\xd5\xf9\xe8\xd9\xab\xa3\x51\x5c\xa3\x93\xd6\xe2\xc7\x47\xae\xd3\x49\x6a\x96\x97\x72\xa6\xf0\xa2\xd7\xaa\xf9\x0a\x45\xc3\xb3\x32\x7c\x38\x37\x6a\x51\xe8\x43\xbe\x66\x82\x4b\xe1\x70\x42\x12\x65\x9d\xd5\xc9\x7d\x48\x20\x23\xf6\x39\x8f\x0c\xec\x2c\x86\xd3\xe4\x42\x28\xdc\x38\xbc\xc1\x0e\xc8\x08\x97\x23\xa7\x20\xfa\x07\x8d\x4c\x93\x25\x87\x18\x92\x32\x80\xb2\xd6\x0d\x06\x04\xf1\x32\x83\xdf\x89\x1f\xa1\x9b\x8a\x11\x7f\x5f\x6b\x56\x70\x2f\xe3\x19\xee\xc7\xe3\x1e\x24\x5d\xdf\x4c\xac\x25\xc2\xeb\xe8\x88\x00\xf0\x64\xa7\x6a\x20\x7e\x62\x33\xa0\x65\x75\xea\x97\x8b\x0b\xbb\xb8\xfb\x95\x34\xa6\xbf\x62\x80\x83\x55\x24\xb5\xf5\xd5\x9b\xa3\x2a\xe7\xe7\x5a\x36\xc5\xb6\x9c\x97\x66\xe4\x48\x77\x9f\x9f\x67\x49\xd7\x7d\x85\x70\xde\x5e\xa3\x50\x57\xdd\x2c\x83\xbd\xa8\x34\xd8\x07\x91\x58\x9e\xd2\xc2\x47\xef\x9d\x08\x1a\x3f\xee\xf2\x80\x7f\x55\x92\x8f\x57\xe6\xbf\x20\xc9\xc7\x03\x1c\xac\x22\xc5\x3c\xc9\x83\x72\xb1\x01\xdd\x1f\x9c\x1c\x6f\x83\x4a\xb3\xfd\x64\x1b\x15\x63\x4f\xfb\xbe\x8e\x94\xee\x1b\x55\xc9\x56\x15\x38\xa8\x7f\x2d\x36\xfc\xe6\x68\x2d\x55\xfa\x39\xfb\x45\x28\x92\x5a\xff\xc5\x28\x92\xeb\xcf\x53\xa4\x1f\xdc\x20\x47\x1c\x01\x25\x7e\x1c\x4f\x65\xb3\x0f\xd1\x0b\xee\xce\x08\xef\x9b\xd1\x8e\x2a\xee\xb9\x68\x42\x31\xd6\x85\xba\xc7\x30\xd4\x46\x4e\x00\xf1\x6b\x61\x94\x03\x12\xfe\x78\x0a\x4b\x3f\x9c\x34\x7a\xb6\xcf\xf5\x0e\xc5\x33\x23\xcc\x62\x3c\x1d\xa0\xe8\x79\xa9\x96\xce\x23\xab\x41\x20\xeb\x02\x7d\xe5\xcb\x9a\x4d\x60\x61\xac\xff\xbc\xd1\xc5\x62\xac\x84\xa4\x48\x1c\xdf\xe3\x81\x47\xa1\x56\x9f\xc6\x6a\xce\x37\x05\x1c\xe7\x03\x00\x9e\x43\xbe\xdf\x3a\x93\xe7\xdb\x56\x78\xb7\x8a\x0c\xa5\xf8\x54\x05\x28\x3e\xae\x65\x87\xb5\x08\x56\x11\xcc\xb6\x16\xb6\x67\xab\xb2\x73\xb4\x98\x41\x1c\x22\xe7\x9d\x0f\xa3\x09\x7c\x6f\x5b\x79\xbe\xed\xe7\xae\x74\x7e\x0e\x9d\xcb\xad\xdb\x11\x3a\x5f\x63\x30\x82\xc1\x4b\x36\x64\x86\x33\xe3\xe2\x7f\xbb\xf1\x8f\x08\x8c\x4e\x05\xfb\x9d\xe4\xb5\x60\x29\xa7\xb7\xec\x3c\x76\xa9\x96\xfb\x14\xb9\xe2\x8b\x0f\xe9\xa9\xf7\xf8\xe0\xcf\xf0\x42\x2d\xad\x58\xb8\x6a\x93\x7a\x7c\x6b\xce\x3d\xeb\x79\x10\x9d\xa1\xda\x70\x5c\xac\x75\xc0\xd2\x6e\x83\xea\x83\xfa\x93\xbc\x90\x65\x6d\x5a\x80\xb5\x43\xb2\x73\xa6\x2b\xdf\x2e\x44\x02\xde\xbf\xef\x07\xb4\xb7\x27\x1e\x3d\xf1\xea\x46\xd0\xc3\x47\x4f\x02\x4f\x9f\xc4\x49\xe4\xe8\xf0\xb7\xbe\x83\xce\x10\x1b\x11\xa6\x55\xb4\x5c\x57\xc0\xb4\x14\xa5\x03\x03\x37\x80\x74\x52\xdc\x84\x06\x19\xcd\x10\x19\x32\x24\x51\xd8\x3e\x56\xa3\x6b\x14\x19\xa2\xcb\x3a\x68\x7a\xe4\x5a\x1d\x38\xfd\xb8\x9d\xaa\x19\x85\x12\x1c\x2f\x4c\x8b\x17\x4e\xfe\x9d\xe8\xdb\x16\xb6\x7c\x13\x6e\x72\xf9\x72\xc7\x75\xf2\x0f\x7b\xe2\xc9\x63\xf1\xf9\xb3\x88\xe6\xd4\x4f\x21\xeb\x52\x01\x01\x85\x16\xfb\x87\xa1\xb9\x9e\x09\xd7\xdd\x50\x17\x96\xff\x8c\x01\x75\x1d\xae\xb0\x60\x02\x3f\xe2\x64\x99\xaf\x57\x75\xfe\xa4\x96\xfe\x30\xfe\xb7\x3f\xa9\xe5\x07\xc8\xa8\xe8\x0e\x4f\x77\x13\x80\xc0\xaf\x76\x20\x87\x66\xbc\x23\x7a\x87\x66\x2c\xe7\x98\x98\xe2\x74\x2e\xc7\xea\x5c\x36\x3b\xa2\x27\xe0\xc1\x0b\x70\x91\xeb\x3d\x6b\x1a\x7d\x6d\xff\x86\x87\x90\x43\x05\x1e\xbd\xc1\x1c\x2a\xaf\xcb\x8b\xa9\x2b\x06\x3f\xe0\x31\x65\x77\x81\xa7\x07\x9c\xdd\xe5\x00\xb2\x5b\x1c\x40\x22\x3a\x78\xf0\xb6\xb4\x85\x4e\x4e\xe1\x07\x65\x2b\x8a\x7c\x1b\xee\x08\xf1\x6c\x3e\x37\x99\xc7\x2e\x51\x0a\xfe\xf1\x42\x53\x6a\xa2\x63\xfd\xb7\x57\xbc\xca\x7f\x52\xcb\x1d\xd1\x7b\x53\xd3\x79\x5c\xaa\xa2\x17\x4a\x06\x90\xfe\xa3\xc2\xb5\x81\xfb\x87\x4a\x5d\xc8\xf1\x32\x20\xea\x56\x87\xcb\x64\xbf\x81\x6b\x39\x33\x57\xe3\x52\x56\x48\xa7\x86\x6f\x4b\x06\x60\xa9\x46\xd0\x54\xf2\xdf\x20\x93\x07\xac\x8d\xa8\xe4\x52\xa3\xbf\x11\xb1\xbc\x5f\x6e\xbd\x5b\x1a\x99\x3a\xd3\x7e\xc5\x7b\xbf\xed\xed\x88\xde\x0f\x72\x7c\x69\xec\x52\xc3\x6c\xf5\x7e\x67\x9f\x9d\xc9\x73\xfc\xf5\xe8\xb1\xfd\xb9\x5f\x29\xd9\xd0\x83\x27\xf6\xc1\xa1\xcb\xd7\xd4\x7b\xf4\x6b\xfb\xe0\x74\x5a\x12\x3d\xf4\x1e\xfd\xa6\x47\xab\xd3\xe8\x8a\x1e\x41\x43\xcf\x2a\x2e\x01\x6d\xbc\x72\xb9\x74\x7a\x8f\x1f\xc2\x27\x72\x6e\xdc\xaa\xf5\x1e\x43\x35\x01\x39\xf6\x9e\x40\x5f\x04\xfd\x78\x82\x75\x5c\x28\x22\xbb\xde\x93\xef\xf9\x89\x23\xaf\xde\x93\x5f\x61\x6f\x0b\xfa\x09\x7d\xfd\xa3\x9e\x71\x8d\xd0\x46\x4c\xcf\xbd\x27\xbf\xed\x25\x14\xdd\x7b\xf2\xbb\x5e\x97\xa0\x7b\xdf\x3f\xec\x75\x08\xba\xf7\x3d\xb4\x78\x54\x1b\xd5\x70\x31\x68\x34\xa0\xf1\xde\x23\x9c\xd5\xe7\x8f\xf8\x27\x8c\xe5\xf9\x63\xfe\x09\x03\x79\xfe\x84\x7f\x42\x8d\xcf\xbf\xe7\x9f\x50\xdd\xf3\x5f\xf1\x4f\x18\xc2\xf3\x5f\xf3\x4f\xe8\xfc\xf3\xdf\xf0\x4f\xe8\xf8\xf3\xdf\xf2\x62\x42\x8f\x9f\xff\x8e\x7f\x3e\xc2\x6e\x3c\xe4\xdf\xd4\x2d\xee\xd7\x63\xec\xd7\x23\xee\xd8\xf7\xd0\xb1\x97\x8b\x99\x5f\xa5\x47\x38\xde\x64\xcb\xf5\x1e\x3f\x86\xa2\xc7\xaa\x95\xbd\x75\xa2\xf7\xed\x4e\x7f\x96\xb1\xc3\xd3\x1f\xb8\xe5\x0d\x07\xff\x9f\xd4\xb2\x7b\xe6\x43\x9c\x76\x7c\xb2\x07\x5e\x9a\xae\x09\x51\xd6\x81\x2b\x10\xb2\x65\x7f\x0a\x9d\x2f\x9d\x80\x23\x8a\x85\x42\xd4\x14\x8c\xc8\x4e\xae\x2a\xc1\x6f\xf1\x5a\x37\x97\x60\xcd\x6c\xe4\xa4\x45\xa6\x31\x21\x80\xf3\xa1\x17\x04\xca\x46\x3d\xd7\x9f\x7c\x0d\x86\x46\x69\x8f\x57\xce\x89\xf9\x31\xe1\x6a\x1f\x39\x82\x92\x6b\xf1\x07\x5b\x20\x55\xf6\x6b\x3f\x73\xad\x16\x1f\x43\x46\xf8\x71\x2b\xc8\x35\x3f\x74\xd7\x54\x97\xc0\x2d\xc2\xe3\xe2\x5d\x32\x6b\xef\x21\x1e\x24\x7e\xe6\x51\xdd\xec\xf7\x77\xf7\xf6\x12\xa6\xdb\xb9\x22\x73\xdf\x7c\x09\x04\x01\xca\x4b\x93\x15\x3b\xec\x8c\x0c\xc4\x5c\x57\xcb\x09\xe6\x18\x11\xb3\xc5\x78\x8a\x68\x33\x68\x4c\x16\x63\x59\x0f\x33\x0b\xed\xa3\x59\x5c\x42\xb4\xf0\xa6\x34\x90\x4d\xd6\x0a\x8e\x5e\x72\xb3\x72\xb6\x62\xe9\x01\x80\x41\xd4\x78\x5a\x53\xec\x2b\x84\xf4\xc6\xb2\x76\x57\xfa\x1e\xfb\x94\xfd\xe0\x93\x02\x88\xd1\xe8\x15\x68\x49\xcc\xa3\x15\x0f\x44\xad\x09\xed\xbd\x23\x20\x51\x98\xf4\x30\x27\x93\x90\xc4\x22\x9e\x32\xeb\x16\x3b\x22\xa3\xb6\x38\x99\x67\x8b\x31\xe2\xd6\x4e\x1e\x24\x69\x4b\x57\x3f\x2a\xb1\x98\xf7\x82\x4d\xf5\x16\x6e\xb0\xe0\xf6\x2a\x3d\x03\x5d\x06\xd9\x48\x0d\x9b\x29\x59\x53\x6e\x76\x25\xc7\x53\xae\xc7\x1f\xc7\xb0\x1f\xed\x31\x0b\xf9\x86\xec\x69\xeb\x36\x3f\x1c\xc5\xa4\xcd\x2c\xea\xf2\x4a\x35\x46\x56\xa1\x10\xea\x70\x00\xc3\x93\x31\x25\x6e\xdb\x0c\x10\x78\x4c\xbf\x09\x84\x5e\x9c\xdd\x34\xb0\x73\x44\xc7\xf2\xd7\x9b\x3a\xa2\x6a\x52\x6b\xc7\xa5\x95\x69\x02\x56\x67\x19\x70\xa5\xc7\x94\xc8\x93\x4d\xd3\xe3\xb6\xa9\x40\xfa\xe1\x07\xc6\x9e\xd8\xd1\x13\x59\xc5\xbf\x67\xaa\x95\xd1\x83\x46\xcd\x95\x6c\xfd\x6f\xdb\x4a\x15\x98\xbf\x11\x68\xc6\xce\x50\x73\xda\x42\xc6\x37\xee\x56\xf4\x78\x80\xbb\xfb\x05\xca\x56\x47\xde\xae\xef\xc8\x75\xa5\xad\xd2\x2e\xbe\xd7\x8b\x7c\x5e\xa8\x45\xd5\x22\x87\xe5\x74\x87\x64\x61\xb1\x9b\x2b\xd1\xf0\xd1\xd5\x53\x4f\xfc\x86\x73\xe4\x96\xe1\x99\x9e\x2d\xbb\x9a\x4b\x13\x08\xed\x1c\x59\x0f\x67\x42\x25\xc7\xc8\x9d\xc8\xbf\x6d\xa9\x5a\x31\x29\x6b\x59\xd1\xb6\x6f\x3b\x87\x03\x2a\x32\xb2\x5e\x8a\x99\xfc\xab\x97\x03\x87\x28\x55\xba\x26\x11\x1f\x04\x87\xed\x55\x3c\x75\x13\x3b\x0b\xb1\x9a\x62\x46\xa6\x88\x85\xf9\xbb\x25\xaf\xac\x90\xc7\x31\x11\xff\xda\xa5\x70\xfb\x30\xbf\x12\x56\x2a\x1a\xbd\x99\x6f\xbe\x16\xf3\xe9\xd2\x80\x47\xac\x63\x0f\xa0\x8f\x85\x8c\xb6\xcb\x19\x7c\x45\x28\x62\x3b\xb7\x5b\xcb\x68\x4c\x2f\x65\x35\x5c\x19\x63\x8f\xd4\xe4\xf0\xcb\x49\xe5\x87\xe2\x99\x31\x8b\x19\x5a\xea\x24\xa0\x26\x80\x8f\xf1\x9b\xd3\x55\x35\xcd\x1b\x7d\x55\x42\x48\x9d\x30\x8b\x66\xde\x94\x06\x11\xcc\xe4\x78\xbc\x68\x64\x0b\x69\xc7\xe7\x80\x9a\xa1\x1b\x5b\x8d\x9d\x88\xc3\x85\x15\x59\x64\x8d\x9d\x1c\x72\x55\x07\x0b\xc5\xb6\x9c\x01\xb5\x5c\xa9\x49\xcb\x60\xf4\xc0\x3a\x5b\x1d\x9c\x83\xe0\x55\x69\x67\xbf\x9c\xad\xa7\x0c\xc7\xab\x33\xef\x02\x2e\x1d\xe7\xab\x1e\x06\xda\xf9\x4a\x42\x81\x89\x5c\x4b\x26\x50\x02\x93\x7c\xd4\x42\x56\xa5\x44\x6f\x1d\x55\xc2\x41\xe6\xa9\x48\x37\xe1\xee\xc6\xd5\x84\x45\xae\x9d\x4f\x83\xdd\xb0\xb6\xeb\xb4\xee\x81\xfb\xc2\xcf\xbe\x23\xfe\xa1\x13\xf9\xdf\xf6\x69\x78\x1d\x1d\x74\xff\x05\x4d\xd4\xd1\xf8\x06\x2b\xce\xf5\xfc\x95\x09\x64\x45\xfe\x69\x62\x84\xab\x22\x15\x21\x0a\xd9\x4a\xb0\x7d\x4c\x54\xf3\xaf\x75\x5f\x02\x8e\x48\x6b\x49\xd2\x4d\xda\x2f\x42\x8e\xbe\xfd\x5f\x8c\x22\x83\x26\xf2\x44\xe9\x46\x38\xc8\x50\x48\x9e\x18\x31\xfd\xee\xcd\xd4\x08\x79\x87\xb6\x55\x42\x87\xfe\xeb\x94\x10\x31\x97\xaf\xf1\x22\x25\x2e\xf9\x59\xfa\x98\x9c\xb2\x3a\xcf\x6f\x14\x61\x37\x10\x83\x37\x94\x62\xff\x55\x76\xc8\x0d\x1c\xdb\xaf\xe5\x7f\x41\x76\xed\x07\x37\xc8\x11\xed\x57\xbb\x73\x3c\x7e\xf8\xf0\x77\xa3\xb7\x07\xdb\xe0\xf3\xe4\x93\x46\x9b\x6d\xfb\xe2\xe1\x93\xc7\x0f\x47\xff\xe6\x9f\xd2\xf6\xd9\xfe\x7a\xe3\x70\x90\xd5\xfa\x2a\x74\x7c\x4a\x9e\xa7\x9b\x91\xad\x6a\xff\xed\xf8\xb4\x6e\x7f\xac\xdf\x1d\xf1\x0c\xff\x17\x74\x03\x49\x46\x38\x58\x49\x54\xf9\xcd\x02\x29\x75\x7e\xa2\x58\xe3\xeb\xe8\xc8\x35\xaa\x6a\xe5\xff\xba\xd1\xf3\x09\x8b\x65\x5c\x9e\xf0\x85\xd8\x01\xb3\xac\xac\x2a\x00\x49\x69\xb5\xd5\x68\x94\xaa\x0e\xe0\x2d\x5a\x5e\xdf\xaa\xf3\xcb\xb2\x25\x3d\x9f\x4d\xc7\x7d\x0c\x84\x2b\x0d\xa1\x6a\x5c\xa9\x2d\xd4\x55\x7a\xc1\xf7\x51\xb3\xb8\xd7\x87\xc1\x6b\xb1\x13\xa8\x5a\xd0\x9f\x3f\x6f\x36\x9e\x3f\xaf\x1a\xcf\x9f\xd7\x8e\xe7\xcf\xeb\xc6\x03\xfe\xb5\x6b\x87\xf3\xe7\xf5\xc3\x59\xdf\xf6\x47\x72\xb8\xfd\xfd\xef\x6e\xdf\xf0\xfa\x76\xbb\xb3\xf8\xbf\x99\x79\x45\xa6\x66\xe3\x92\x7b\xdc\x83\x52\xc7\xe0\xfc\x51\xb2\xc5\x9f\x50\x71\x1a\x79\x2d\xa0\x6e\xac\x8a\xf0\xa8\x75\x4d\xb1\x82\xb5\xb6\x5c\x8b\x63\x7f\x11\x56\xc5\xc3\xb9\x3e\x18\x6d\x8b\x47\x8f\x1f\x0e\x04\x38\xf0\x56\x4b\xa1\x7e\x5c\x94\x57\xb2\xa2\x8c\xf8\xf3\xf2\x93\xaa\x0c\x5d\x5c\x3f\x13\x17\x5a\x17\xe8\x8f\xfc\x89\x3c\x0a\xad\xea\x7b\x70\x72\xfc\xe1\xe0\xf0\xc5\xd9\xb3\x0f\x2f\x8e\x5e\x1e\x8a\xfe\xa3\x2d\xdb\xc0\xaf\xbe\xb5\xef\xae\x4a\x75\x8d\x2e\xdf\x76\xe6\x74\x83\x35\xfd\x7f\xdf\x3f\xa4\xaa\xd1\x89\xd9\xd7\x70\xba\xff\xfa\xf0\xf0\xa5\xe8\x3f\xde\x22\x83\xc3\x6f\x7f\x33\xcc\xd4\x34\xe4\x89\x3b\xc6\x0c\x07\xff\x42\x1c\xfe\x66\x1d\xc1\x73\xa0\xff\xb2\x4a\x82\x1f\xe2\x20\xc7\x70\x03\xee\x7e\xb6\x68\x6a\xf0\x5c\x78\xd7\x93\xe7\xba\x69\x7b\x03\x31\x1c\x0e\xdf\xdb\x27\x65\x8d\x59\xe4\x7d\xec\x1b\x32\xea\xef\xec\x5e\xc6\xc2\x3b\xfc\x7b\x3d\xa8\x02\xe7\xea\x0d\x71\x15\x9e\x61\x6b\xfe\x65\x84\xac\x00\x6f\x19\x58\xc1\x15\xfa\xe2\xfe\xca\xe0\x2b\x60\x85\xef\xa9\x08\x17\x1d\x0e\x81\x50\xbe\xec\x22\xdc\x29\x86\x5c\xe1\x99\x74\xa6\x0f\x62\xba\xf7\xa3\x73\xd5\xed\x88\xbf\x03\x20\x00\x95\xf8\xe2\xea\x1a\xa5\x50\x13\xdf\x07\x39\x82\x6f\x6e\xe7\xcb\xee\x1d\x3f\xe1\x3d\xe7\xb5\x0e\x77\xdf\xc1\xef\xa3\x96\x00\xc2\xa2\xa7\x88\x09\xe0\x33\xb4\xf9\xbc\x63\xf6\xaf\x57\x95\x5c\x06\x7f\x9e\x61\xec\x01\x66\xf5\x2a\xc7\x97\x61\x7a\xaf\xde\x38\x06\xa2\x18\xeb\x39\x7e\xba\x80\xea\x0b\xbd\x38\xaf\xd4\x3e\x7f\x55\x34\xf2\x82\xff\xa5\x8e\xe2\x9f\xe0\x5d\x40\x3f\x3e\x95\x2d\xff\x0d\x69\xa9\xf9\xc7\xc9\x95\x2f\xe4\xfa\x5f\x34\x1a\xc0\x2b\x0a\xe2\x35\x14\x82\x31\x10\x3d\x35\x9b\xb7\xa5\x82\x36\x54\x3d\x6e\x96\xf3\x96\x7f\x14\xf4\x47\xd3\xe8\x26\xcc\x6e\x47\x30\x78\xf0\x07\x78\xe1\xd9\x3f\x2f\x3d\x94\xc6\x25\x99\xe7\xe9\x6f\x44\xcd\xa8\xb4\x2c\xf8\x5f\x85\xae\xd4\xee\xd7\xb1\x6a\x65\x11\x3c\x71\xbd\x9e\x85\x28\x1c\xf0\xe3\x58\xe3\x40\xe1\xc7\xc9\xc2\x97\xe2\x51\xcf\x3c\x50\xc7\x5c\x9a\x56\xe1\x1f\x0b\x5c\x84\x39\x2d\x98\xfd\xb7\xac\x61\x8a\x01\x94\x97\x3a\xdb\xc8\x56\xf9\x89\x69\x94\x51\x6d\x94\x59\xb0\x67\x94\xba\xc4\x49\xb1\x7f\x51\x0d\xa6\x85\x24\xb6\xf0\xe7\xe2\x7c\x86\xab\x62\x16\xc6\x6e\x1b\xc0\x0b\x29\x67\xea\xcd\xbc\x90\xd8\x97\x56\x5f\x5c\x54\xf4\xd7\x62\x3c\xf5\x19\xed\xe0\x27\x2d\x36\xfc\xcd\x43\x85\x1f\x6e\x4a\xbc\xfe\x43\x65\xaf\x74\xb5\x98\x05\xdd\xbe\x96\x80\x82\xee\x93\x5b\xbe\x1f\x4e\x74\x73\x28\xc7\xd3\x7e\x56\x3c\x82\xbb\x5d\x39\x2f\x5b\xbc\xff\xc6\x63\x60\x0f\xf7\xdb\xbb\x87\xef\x87\xad\x7e\x33\x9f\x33\x4c\xa2\x78\x40\x47\x02\xa6\xb9\x7e\xe4\x20\xe9\x48\xaa\x15\x7b\x96\xa5\xf4\xc4\x83\x4e\x95\x5c\xb0\xd5\x73\x57\xb2\xd5\xf3\x7c\x51\x2e\x8b\xe1\xe6\xb7\x85\x92\x61\x91\xbb\x83\x23\xc3\x9d\x7c\x00\x3e\x35\x37\x21\xc9\x70\x4f\xdf\xdf\x21\x44\x8a\x90\x05\xbd\x83\x1f\x90\xcf\x8e\x52\x8a\xac\xe7\x44\xbe\x36\xf7\xc9\x17\x38\x1b\x08\xbf\x00\x8e\xfe\xb2\x16\x07\x87\xff\x89\x77\x00\x98\x07\xac\xbc\x52\xb5\x32\x06\x9d\x5d\xc9\x1f\x02\xbc\x0f\x6a\x7d\x5d\xff\xf1\xec\xf8\xc5\x59\x98\x9b\x4f\xec\x85\xfc\x79\x20\xe2\x94\x89\xf8\x83\x79\x96\xff\x15\xb0\xad\x30\x31\x61\xab\xe7\x07\x1d\x66\x61\x47\xe1\xf9\x85\xfd\x15\xb2\x0c\xf8\x5d\xf8\xbf\x99\x71\xb4\x7a\x7e\xc4\x2c\x03\xfe\x76\x5c\xc3\x4e\x1a\x31\x06\xfa\xd3\xf3\x06\xf7\x20\x64\x0f\xf4\xd0\x6f\x07\x3d\x7f\xc5\xbb\xdb\xfe\xed\x47\xf7\xca\xef\x71\xfb\x2b\xd8\xe6\xad\x9e\xbf\x8e\x76\xba\x7d\xc0\x9b\x1d\xe2\xd4\x78\x97\xd3\x0f\x5f\xcd\xa9\xdf\xeb\xf6\x97\xdb\xee\xf0\xc3\xef\x78\x3d\x3f\x4b\x36\xfd\xfc\x2c\xd8\xf7\xf3\xff\x4c\xf6\x6c\xab\xe7\x6f\x69\xdb\xbe\x27\x10\xa1\x53\xb8\xcb\x02\x92\xd9\x24\x54\xfe\xfb\x7f\x40\xa8\x7c\x7a\xb4\xde\x4c\xf1\xae\xcd\x30\x9d\x61\x5c\xcf\xda\xa0\x70\x6e\x1a\xaf\xa4\x38\x26\x4f\x53\x96\x83\xf5\xe1\xdd\x61\x88\x1f\x1e\x47\x3e\xca\x2f\x08\x08\x75\xd8\x10\x82\x2f\xc5\x38\x46\x55\x37\x89\xd3\x44\xab\x35\x45\x14\x23\x6e\xa8\x09\xeb\x83\x6b\xc8\xfa\x5a\xc2\xdd\x75\x5c\x95\x19\xa2\x13\xad\x55\x22\xa6\x98\xe8\x3c\xe3\xfe\x12\x56\x16\xf9\xb0\x0c\xc5\x49\xad\xc4\x35\x00\x96\xaa\x4f\x73\x35\x6e\xc5\x99\x3c\x27\xf0\x5e\x0e\x0f\xed\x13\x90\x7d\x89\xc1\xb6\x51\x64\xe5\x7a\x3f\xef\x28\x69\xd8\x8a\x95\x10\x61\xa8\xe5\x77\x71\xa8\x25\x27\x61\xfa\x9a\x68\xcb\x74\x5d\x43\x70\x93\xe8\x0e\xe8\xa6\xa0\xea\x28\x32\x7d\x65\xa8\xfe\xba\xe6\x7c\x60\xc4\x8d\x01\xdc\x20\xa5\xdd\x40\x4c\x20\x00\x12\x25\xe9\x9a\x90\x7f\x30\x47\x33\xbc\x32\x31\x25\x05\xb1\xe9\x98\xad\x8c\x29\x29\xa8\xc7\xc4\xab\x1a\x3a\xe4\x20\xfc\x32\x2c\xe5\xe3\x9f\x77\x29\x0f\x02\xc1\x34\x1f\xad\x9e\x5f\xe9\x63\x27\xac\xdd\x18\xe3\x3e\x1a\x89\xb3\x93\x83\x93\x1d\x71\x80\xb9\xbe\x02\x30\x15\x4e\x70\xa1\x5b\x11\xc4\x86\xe0\x34\x32\x42\xcb\xa6\x23\x39\x66\x89\x31\xdf\x21\x90\x1f\x3b\xaf\x72\xc1\xfa\xeb\xe9\xc8\x2b\x8c\x37\xd1\xd1\x81\x15\xf2\x3b\x2d\x1e\x90\xc8\xbf\xe2\x45\x9b\xeb\xe5\x01\xab\x03\xd9\x37\xa8\x1c\x64\x5f\xe5\x07\x7d\xe0\x14\x87\xcc\x2b\xbd\xe9\xfe\x75\x57\x66\x37\xcd\xc3\x59\x20\x07\x77\x1a\x3c\x63\xa9\x38\xff\x26\x4f\x61\x67\x5e\x62\xde\xac\xaf\xfe\x0e\xe3\xa6\xce\x3e\x0b\xf5\xc7\x4e\xc3\xcf\xba\xda\xe4\xea\x32\xb7\xe9\x60\x1c\x37\x7b\xe3\x8c\x46\x3a\xc2\x86\x53\x10\x9b\xa7\x6f\x6a\x82\xf2\xae\x6f\x56\x37\x5d\x26\xdd\x54\x27\xa6\x91\xdf\xac\x4a\x6f\x6a\xb9\x19\x6f\x63\xbe\xcc\x6c\xec\x1c\x23\x78\x05\x0a\xe3\x66\x1d\x88\xc3\x3a\x57\x74\xa2\x50\x13\xb9\xa8\x5a\x5f\x63\xc8\x9a\xc1\x0b\x38\x2b\xc7\x0f\x21\x43\xd2\xc9\x24\x91\x6c\xe2\x24\x40\xfc\xdf\xb5\x6c\xea\xb2\xbe\xe8\x03\x38\xc8\x40\xf4\x3a\x82\xe3\x8e\x78\x53\x73\xe2\x28\xb2\x05\x82\x14\xf8\xf1\x5b\xf3\x91\x93\x15\x63\x1d\xc2\x6a\x63\xbd\xd2\x88\xaa\xbc\x54\xd5\x52\x40\x40\x1b\x78\xda\x4a\x80\xff\x2f\x6b\x82\xe8\x17\xaf\x2a\x65\x27\x6d\x52\x82\xec\x22\x4a\x63\x16\x6a\xd8\x8b\x53\x85\x6f\x85\xc0\x33\x5f\x3a\x87\x0f\x30\x7e\x3b\x74\x9c\xe6\x48\x98\x5a\x7d\xdf\x31\x6d\x67\xd5\xaf\x46\x30\x3f\x43\xfb\xf7\xbf\xd1\x25\xe0\xc3\x8d\x16\x8d\xae\x6c\xb2\xab\xe5\xa5\x4d\x45\xfa\x69\x5a\x53\x80\xb3\x96\xda\x18\x6f\x21\x51\x63\x6b\x6b\x61\xd0\x42\x9f\xab\xd0\x5b\xca\x7b\x44\x19\xd5\xfe\x11\x96\x94\xe9\xa6\x3f\x8d\x7e\x06\x66\xc7\xa3\x1a\x50\x41\x31\xcd\x82\xa1\x24\x0f\x46\x57\x90\xaf\xea\xe0\xe4\x58\x4c\x4b\xd5\xc8\x66\x3c\x5d\x12\xf4\x3d\x28\x1b\x00\xca\xe2\x52\x26\x96\x50\x07\xa0\x3e\x0f\xf1\xef\x80\xbe\x4e\x6c\xd1\xfe\xc1\xc9\x71\xfa\x6c\x6b\x37\xf8\xf0\x31\x7d\xb8\xaf\x67\x73\x5d\xdb\xe9\x68\x94\xea\x03\x39\x1d\x9c\x1c\x47\x4f\x83\xce\x43\xc8\x5b\x39\x9b\xeb\xa6\x95\x35\xa1\xbf\x50\x17\x8d\x28\xeb\x71\xb5\x28\x90\x40\x69\xa7\x89\x3e\xdf\x53\x4c\x25\x0c\xb0\xd5\xa2\x51\x3f\x2e\xca\x46\x11\xfc\xf1\x6c\x6b\x83\x21\x99\x1f\xe0\x72\x17\x40\xd2\x33\xfb\xa9\xf3\x68\x70\x47\xa0\x88\x0f\x67\x6d\x54\x36\xfb\xd8\x96\x0f\x20\x4e\xb8\x6c\xe7\x11\x84\x6f\xa5\x98\x69\x3b\xdd\x47\xb6\xdc\x0f\x80\x2b\x83\x18\x54\x61\xe1\xfc\x73\xb4\x3e\x60\xaa\x1d\x2b\x74\x3d\x33\xcb\x7a\x7c\xba\x38\x6f\x1b\xa5\x9e\xbd\x3a\x72\x58\x46\x69\x89\xf1\x54\x15\x8b\xaa\xac\x2f\x7e\x58\x1e\xe0\x94\x1f\xd5\xbc\x88\x1e\xa1\x68\x34\xa2\x24\x9c\x86\x18\xc6\xf3\x46\x82\xf1\x3c\xa8\x0f\x5e\xf0\xf3\xd5\x9f\x1e\x9c\x1c\x73\xbe\x1a\xad\xc3\xef\xf7\xdd\x43\xff\xb1\x7f\xfb\xc6\xa8\xe6\xac\x9c\x95\xf5\x45\x38\x9a\x3b\x10\xf4\xd8\x4a\xb8\xb0\x9a\xe9\x42\x09\xa4\x40\xbb\x0f\x06\x94\x53\xe5\xd9\xeb\x33\xfe\x13\x2f\x43\xb6\x76\x82\x7a\xf9\xeb\xd7\x6a\xac\xeb\x71\x59\x41\x86\x22\xac\x1c\x7b\xae\x9a\x12\xa2\x5b\x2a\x51\x6b\x3d\xa7\x46\x08\xdd\xb1\x5a\x0a\x4c\x31\x1b\x55\xf9\x52\xeb\x79\x54\x5d\x34\x13\xbe\xbe\xb9\x6a\x38\xdc\x06\x6b\xdd\x3f\x8d\xea\x79\xe5\xde\xe7\x6a\xeb\x58\x9a\xae\xaf\xaf\xc5\xf9\xa2\xac\x0a\x33\x44\x42\x00\x5f\xe1\xd3\x56\x8e\x2f\x29\x77\xc1\x1d\x97\x69\xa4\x3c\x07\xe7\x1e\xf7\x86\xb0\xa7\x31\xc9\x2b\xe6\x2e\x0d\x40\x53\x61\x61\xf6\x17\x8d\xd1\x4d\x9f\xf6\x25\x24\xb7\x8c\x2e\x71\x28\x0a\x18\x27\x66\x47\x84\xe5\x5c\xbe\x90\xa0\xd2\xb9\x9e\xdb\x59\x34\xba\x19\x60\x77\x7c\xb0\x12\xf6\xe2\xf7\x5e\x89\xe5\xf3\x31\x3d\x19\xdf\xd4\xa8\x3e\xab\xc2\x56\x37\xec\x65\xfc\xbc\x5d\x8c\xaa\xcf\x4a\x01\xad\x41\xa8\x8e\x9f\x86\x77\xd0\xe6\xfb\xad\x4d\x9a\x7a\x0e\xdf\xcf\xf5\x7c\xae\x8a\xa8\x4d\x68\x07\xc7\x34\x64\x2c\xe6\xbd\x60\x15\xa8\x11\xb2\x86\x26\x4f\xc3\xdc\xac\x94\xdd\x25\xed\x5d\x80\xa6\x86\xf0\xe6\xf6\xe9\xf6\x76\x9c\x66\x06\x72\x41\xf0\xc4\x52\xd4\x48\x38\xbf\xf6\x9b\x07\x0f\x56\xf6\x21\xee\xfe\x0d\xbd\x81\x67\xbb\xeb\x47\x1e\xf7\x0e\x4c\xf0\xdf\x3c\xa2\xa4\x37\x94\x22\x03\xd7\xfb\x0f\x81\x28\xb4\x76\x76\x3c\x3d\xac\x9b\x21\x07\xdc\xe4\x66\x29\xc0\x58\x2f\x94\x19\x37\xe5\xb9\x72\xa7\xd4\xf3\x06\x33\x0d\x79\x03\x5b\x2d\x67\x00\x1e\xb6\x68\xc6\x6a\x20\x00\xac\xd1\x9e\x20\x11\xc9\xf7\xfe\x52\x63\x0b\x20\x67\xc1\x27\x14\x41\x03\x62\x60\x6f\xcb\x3e\xc5\x2a\xc4\x53\xd1\x13\x7d\xd9\x42\x49\x7c\x34\xb4\xc2\x16\x24\x2e\xa2\x88\x8a\xfe\xe8\xff\x0c\xbf\x7b\xf7\x97\xbf\xfc\x65\xf4\x7e\x34\x10\x3d\xf8\xbc\xb7\x13\x7c\x50\x95\xb5\x7a\x09\xc0\x00\xf6\xcd\x56\x4f\xec\xf8\x8e\x61\x03\xb8\x55\xe1\x00\xb5\xdf\xf9\xb7\x5c\xbe\x07\x69\x89\xc2\xdd\xcd\x73\x01\x64\xdd\x0f\x48\x85\xad\x71\xf0\x68\xd8\x4a\x67\xd9\x03\xf1\xfa\xa8\xe6\x48\x26\xcb\x1b\x78\x1e\x77\x7c\x81\xe7\xd4\x80\xac\x72\x6f\xe1\xd2\x35\xf7\xe2\x8f\xda\xb4\xc9\x73\xba\x90\xb0\x63\x61\xa2\x1b\x7e\x28\xd4\xf9\xe2\xe2\xc4\x3e\xdb\x0d\x0a\xd1\x64\xc7\xa5\x4e\xe1\x61\x58\xac\xc6\xd5\xbe\x50\xbe\x29\x10\x0f\x70\xf4\xbb\x69\xab\x94\x86\x2a\xb4\xb9\x58\x46\x02\xef\x42\xe9\x3d\x2c\xdc\xa9\x1b\x4b\xa7\xb9\x4a\x89\x92\xf2\x04\xb9\x92\x08\x77\xef\x64\x94\x91\x20\x44\x8b\xc1\xb6\x09\xf2\xcd\x73\x72\x59\x23\xa0\x06\xc4\xdd\x55\x56\x81\xa0\xac\x82\xd7\xba\xb9\xdc\x2e\xeb\x6d\xbe\x3d\xc3\x09\x04\x33\xe6\x68\x84\xdf\x14\x0b\xc8\x84\x7f\xae\x50\x9c\x14\x63\x6d\x85\xa6\x56\xe1\x45\xce\x50\x1c\x60\x52\x7d\x5b\xaf\x28\x5b\xc8\xd0\xd0\x60\x62\xfc\x76\xaa\x1a\x5b\xcd\xb8\x6c\xc6\x8b\x19\x02\x7d\x9a\x61\x8c\xe6\x6e\x77\xf1\xb3\xa2\x50\x75\xb1\x98\xfd\xb0\x7c\xab\x9b\xcb\xa3\x9a\x6d\xfc\x48\x9a\xd7\xd1\x33\x7f\xd7\x45\xa9\x61\x70\xdc\x41\xda\xec\xb8\xbc\x7d\x59\x68\x97\xf3\x61\xa2\xc5\x83\xbd\x84\xf6\x6b\x8e\x07\x44\x14\x6a\x97\x0c\xbf\x9d\xba\xa4\x17\x02\xd2\xad\xab\x46\xcc\xc0\xfe\x87\xc9\xd7\x29\x66\xe5\xba\xd1\x56\x3e\x6d\x94\xc2\x15\xa9\x7d\x9e\xd9\x77\x3d\xfc\xbc\xf7\x1e\xe1\xe0\x89\xf1\xb9\x06\x19\x28\xbf\x9e\xe8\x4e\xd2\xb0\x7d\xe4\xa7\xd0\xc5\x13\xa6\x00\x62\xa0\xde\x96\x8f\xcb\xb5\x47\x22\x96\xa5\xfa\xf0\x3b\xcf\xcf\xe3\x43\xb0\x9b\x68\x7a\x8d\xcd\xfe\x86\x0d\xe8\x76\x84\x4b\xd4\x2b\xee\xdf\x07\xcd\x54\x4f\x84\x7f\xd1\x73\x99\x3b\xb2\xb1\x2a\xab\xf7\xcc\x97\x38\x12\xd1\xc1\x43\xaf\x9a\xab\x88\xa2\xfe\xd1\xf3\x35\x1a\x89\x53\x39\x51\x1e\x43\x66\xe2\xb2\x33\x60\x4d\x88\xe5\x0b\x60\xbd\x88\xf6\x81\x02\x5e\x59\x5f\x0c\xb8\x02\x40\xe2\x01\x47\xa5\x8b\x85\x6c\x64\xdd\x2a\x97\xe1\x0f\xc8\x2d\xdd\xb1\x94\x4b\x36\x8a\xf9\xdc\x6c\x67\x79\xb6\xb7\x76\x82\xe1\xf0\x0e\xa7\x89\x66\xb5\x3b\x87\x96\x79\x0d\xfd\x7a\xb0\xa4\xc9\xb3\xb4\x7e\xd2\x6f\x2e\x08\x0c\xc7\x15\x0b\xbb\x98\x76\x30\x38\xce\x36\xee\xe5\x3a\x3a\xda\xa8\xf7\x4e\x2c\xfa\x09\xdd\x07\x0b\x42\x1f\x4a\xae\xea\x7e\x54\x17\xfc\xeb\xe4\xf8\x7c\x61\x06\xcb\x63\x11\xdd\xf9\x34\xdb\x6f\xc3\xe0\xd7\x64\x16\x77\xba\x8f\x20\xa0\x20\x2d\xb5\xb6\xcc\x2b\x6c\x24\x79\x40\x61\x08\x59\x1e\xb7\xb3\xf2\x4d\xe6\xab\x68\x95\x3a\x5f\x46\x6f\xd1\x9b\x6f\x24\x5e\x35\x6a\x52\x7e\x12\x33\x25\xcd\xa2\xe1\xfb\x09\xcd\xb1\x90\x3d\xe3\xb2\x3d\xdb\x4d\x37\x29\x2b\xcb\xf6\x11\x6b\x67\x34\x12\x2f\x74\x7d\x61\xb5\x00\xa8\x03\x93\x6f\x8b\x29\x20\xee\x68\xd1\x28\x89\x57\xff\xea\xea\x4c\xeb\xca\xe0\x0d\x3f\x24\xe2\x3c\x9c\xe9\xbf\x96\xf6\xb0\xfa\xcb\xe2\xf1\xaf\x7f\xf7\x43\x0f\x35\x5c\x52\x36\xa2\x97\x07\xdf\xd3\x4b\xce\x77\xed\x15\x60\x72\x38\xd0\x13\xce\x87\x68\xcf\xd3\x94\xb9\x06\xcc\x37\x28\x35\x9c\xc9\xe6\x12\xa3\xf8\x98\xe8\x56\x95\x1c\x57\x4a\x36\xc7\xb2\xb9\x34\x9b\x95\xa7\x79\xbc\x4d\xe5\xf8\x45\x5a\x3f\xae\xce\x9f\x94\x9a\x8b\x16\xe0\xbc\x75\xca\x3c\x79\x95\xae\x15\xf8\x4d\x50\x6e\xf3\x76\x0a\x80\x65\xf5\x75\x89\xe8\x33\xe0\x24\x04\x8b\x85\xb7\x51\x70\x8c\x57\x5a\x5f\x1a\x9f\xab\x46\x62\x3a\xf7\x37\x75\xd9\x9e\x4c\x2c\x6b\xb4\xeb\x66\xd0\x26\xa2\x9a\xa1\xd8\x97\x35\x64\xe6\xae\xcb\xc9\x12\x16\xff\xe9\x9d\x20\xd9\x04\xef\x2a\xdc\xc8\xa3\x91\x38\x9a\x88\x6b\xd5\x6b\x14\x83\xfb\xce\xca\xa2\xc0\x64\xab\x10\xd0\x3a\x86\xfc\xb4\x18\x8f\xeb\xe4\x2b\x4a\x06\x6d\xf9\x7c\xd9\x3e\xb5\xb5\xbc\x56\x98\xbe\xf0\x63\xd8\xcc\x47\xba\x30\xc6\x8c\x3d\x13\x2c\xe1\xa0\xe0\xf9\x9c\x71\xcd\x60\xfd\x20\x74\xf9\xec\x87\x24\xc1\x8d\xf5\x6c\x56\xb6\xb8\xed\x45\xab\xb5\xc3\x2a\x2e\x00\x8d\xbb\xa6\x73\x86\x66\xb2\x6c\x45\xdf\x94\xf5\x58\xd9\xca\xaa\x72\xa2\xc6\xcb\x71\xa5\x5c\x4a\x82\xa8\x32\xac\xc0\x72\x8b\x19\x5c\x82\x83\x34\xb4\x35\x0c\xe7\xec\x55\xc4\xfc\xd2\x17\x9d\x19\x3d\x28\x0b\xdf\xa8\x98\x6a\x7d\xe9\x96\x47\xc8\x5a\x2c\xc0\x23\xe3\xa9\x43\x36\xd6\x93\x56\xd5\x42\x46\x1b\x63\xde\xe8\x73\x48\x8a\x0a\x68\xd6\x76\x9c\x90\x9c\xe8\x32\x22\xb0\x92\xd2\xb7\x90\x09\x12\x0e\xde\x9a\x42\xbd\xed\xf6\x43\x3a\x82\xd2\x38\x62\x13\x18\xd3\xc7\xd2\x8c\x25\x04\xf0\x62\x7f\x68\xc7\x97\x56\xc1\x99\x95\x6d\x8b\x7b\x36\x30\x69\x4d\xa5\x21\xc3\x9b\x2a\xd0\xa9\xe4\xa8\x26\x7e\x85\x9f\x6c\x5c\x9c\xa7\x33\x28\x8d\xfd\x83\x24\xd8\xae\x98\x25\xed\x17\x1a\x52\x1d\x3e\x24\xab\xda\x64\x02\xc6\xdb\xb0\x94\x6b\x9b\xca\x94\x86\x9c\x58\x9e\xeb\x66\x9f\x3d\xd9\x43\x73\xd6\x41\x48\x50\x28\xcd\x80\xaa\x60\xa6\xfa\x5a\xc8\x90\xb5\x0a\x0d\x4b\x61\x25\x67\x24\x77\xab\xda\xdc\x41\x40\x70\x09\xc9\x05\x4d\xdb\x28\x74\x91\x4e\x88\x0a\x34\x94\xa8\xaa\x2b\xd5\x4c\x95\x2c\x86\x94\x60\xeb\x5c\x55\xa6\x3b\x86\x5a\x5d\x8b\x53\x05\x49\x56\xef\x60\x76\xdd\x66\x26\x21\xe1\xf5\xcb\x54\xd7\x9f\xd1\xc3\x48\xb9\x0f\xf8\xf5\x03\xd1\x03\x75\x9a\xcb\xed\xba\xcc\x60\x58\xe9\x0b\xdb\x85\xa8\x46\xe8\xd4\x80\x19\xfb\x37\xdf\x3c\xf2\xea\x0a\x1e\x19\x56\x3f\x71\x2f\xc5\xd3\xf8\x08\xc0\xf6\x76\x3a\x5d\x60\x05\xc7\x2c\x26\x99\x2a\x7a\xe2\x2d\xfe\xdc\x81\xce\x06\xef\x76\x48\x39\x72\x1a\xa2\x78\xc0\xdd\x78\x80\xf3\x27\x1e\x50\xa5\x7e\x68\xa0\xe7\x1d\xc3\x71\xb1\x72\xaa\xd2\x93\xa5\x1f\x4f\xb2\x2f\xbd\xe5\xeb\x75\xe7\xca\x86\xf5\xfa\x73\x68\x93\xda\x29\xf9\x77\x6e\x31\xb8\x78\x7e\x59\xb0\xee\x56\x15\x21\x85\xac\x68\x6f\x37\xfd\xc6\x11\x80\x27\x87\x0c\x09\x80\x53\x61\xb3\x64\xf7\xc7\xee\xd9\xd9\x8f\x2b\x1c\x74\x3b\x45\x59\x05\xc7\x10\x4c\xd0\x57\x8d\x95\x6d\xbf\x60\xe0\xc3\xd1\xc4\xae\xe9\x55\xa9\x17\x06\x86\x0a\x59\x96\x67\xa5\x71\x07\x85\xd1\x33\xc6\x73\x1f\xe0\xa9\x01\x7c\xb0\x9d\x36\xfa\x9a\xc2\x30\x80\x8d\x62\x26\x65\xd8\xc7\x53\x39\x9f\xab\xda\x6a\x2f\x68\x3f\x1f\x37\xd2\x4c\x19\xca\x43\x2c\x02\xf3\x2b\xe4\x57\x56\xb2\xa9\x4a\xc0\xe4\xf4\xb9\x1d\xe6\x56\xd3\xd5\x35\xed\x62\xdd\x28\x01\xee\xc7\x66\x48\xf1\x28\x80\xb8\x06\x1d\x36\xa2\x9c\xcd\x54\x51\xca\x56\x55\x4b\xcf\x17\x2e\x1a\xcc\x78\x73\xbe\x98\x4c\xb0\xee\xb5\xd4\x91\x4e\xd6\x4a\xa9\x23\x99\xec\x80\x86\x2e\x14\x1e\xb9\x59\x5e\x41\xcb\x0a\xda\xef\xd1\x41\xc4\x31\x78\x27\xf5\x44\xff\xdf\xec\x16\xa3\x32\x68\x7b\xeb\x56\xdf\xe5\x1a\xe3\x50\xf9\x1d\x88\xd2\x1c\x5b\xf6\xac\x8a\x81\x08\x14\x01\xab\x8d\x92\xd4\x9f\x68\xa3\x08\x1c\x62\x50\xa3\x84\xba\x4c\xd9\xd2\x5f\x35\x46\xdd\xb4\xb2\x02\x04\x8d\x48\xea\x8d\x81\x94\xc2\x3e\xc0\x60\xde\x81\x71\xd3\x75\xc6\x72\x1a\x3c\xe6\xc0\x9e\x38\xb3\x4f\xd1\x54\xf9\xbe\x97\xcf\xb9\xda\xed\x08\x9e\x01\x37\x34\x3c\x04\x36\x85\x7a\x4d\x98\x8d\x11\x18\x93\x5b\xa0\x68\x02\x41\xe8\x89\x66\x8b\x0e\xc4\xa0\xe6\x95\x66\xbf\xc8\x74\xcb\x5b\x9c\xd7\x30\x36\x7b\x1c\x1d\xf0\x7b\x3f\x2d\x5c\x42\x5a\x45\xa1\x96\xad\x72\x76\x10\x2e\x5b\xd1\x82\x47\x04\x70\xe3\xa2\x3b\x04\xd6\x48\x9c\xb8\x7f\x3f\x7f\xf0\x0d\xa7\xd2\x20\x8d\x6e\x05\x64\x41\xe7\x74\x7a\xb4\x0e\xbc\xd0\x07\x27\x76\xb1\x98\x57\xe5\xd8\x76\x1d\xeb\x66\xb1\x92\xab\x81\xf4\x71\x08\x12\x63\xb5\x9e\xc2\x9d\xc4\xe8\xe1\x7c\xa5\x9a\x65\x48\x58\x28\x51\x71\x13\x5c\xc9\xb5\x44\x93\xd9\xca\xf3\xfe\x5c\x2d\x75\x5d\x88\x5a\x8d\x95\x31\xb2\x59\x46\x54\xe2\x32\xa6\x58\xae\x97\x9f\x01\x59\x14\x34\x03\xce\xef\x7c\xe6\x77\x72\xba\xb9\xd3\x0d\x6d\xeb\x76\x47\x5f\xcc\xf2\x1d\x8e\xd6\x42\x25\xc7\xd9\xbf\x12\x35\x7e\xd5\x8c\x3a\x36\x1d\xce\x68\x70\x66\xdf\x3c\x81\xf9\x53\xfb\x5f\x72\x32\x49\xc6\x59\x2b\xd7\xf8\xd9\x45\x97\xcb\x23\x00\x3c\x64\xf5\x2a\x99\x62\x97\xe2\xf2\x8f\xda\xb4\x7e\x4e\x9d\xbb\xe6\xb9\x82\xac\xc4\x73\x3c\xf9\xed\x86\xb5\x67\x48\x55\xd6\x8a\x8e\xfa\xb7\x8a\xa4\x06\x44\x6b\x26\x85\x9f\x2e\x8e\xc0\x37\xc9\x6a\x98\x80\x6e\x88\x82\x87\xd5\xb4\x41\x22\x78\xfd\xf2\xe9\x8d\x57\x4d\xb6\x57\xaf\xb5\xbe\xe1\x96\xc8\x3d\x3f\x53\x9f\xd2\x47\xaf\x74\xd3\xca\x2a\x78\xf8\x1a\xb6\x72\xf6\xda\x8a\x1c\x18\x92\x5b\x15\x9f\x08\x2a\x7f\xeb\x12\xf0\xa5\x88\x33\xbc\x42\x64\x27\x50\xd3\x8e\x03\x1d\x26\x5c\x03\x7f\xae\x47\x3a\x72\x68\x46\xef\xea\xc8\x77\x93\xc3\x3f\xe6\x43\xfd\xce\x07\x83\xa8\x0e\x67\xec\x5d\xad\x7c\x8b\xbc\xc6\x2e\x6e\xa1\x8d\xf2\x4c\x80\x25\xe6\xac\x9c\xa9\xc6\x64\x06\x3e\x1a\x89\xd3\x56\xcf\x0d\xa0\x1a\x7a\xc7\x0a\x4c\x36\x96\x37\xcf\xb5\x53\xb5\x04\xc3\xc6\x39\x42\xb1\xcd\x54\x81\x15\x95\x13\xc0\xc3\xd4\x75\x5b\xd6\x0b\x30\xc3\x48\x51\xc9\x56\xd9\xdd\x3e\x51\x4d\xa3\x0a\x51\x59\x35\x18\x30\x8f\x9d\x15\x68\x51\x97\x80\xe5\x66\xc9\x72\x78\x27\xbe\x20\x08\x6d\x30\xbb\xfe\xce\x3a\xd8\x37\xc1\x05\x01\xf3\x10\xb3\xcf\xc3\x40\x8b\x9d\xbf\x2f\x08\x79\x1d\xf3\x37\x30\xbc\xe2\x62\x86\x77\x08\xdc\x03\xf8\x37\xb9\x41\x72\x53\x8b\xa3\xc7\xb9\x7d\xad\xc6\x8b\xc6\x94\x57\x56\x7c\x5e\xb1\xc7\x5d\x4f\x7d\x7d\x1d\x4a\x5a\x51\x65\xfa\x5d\x84\x9c\xb9\xd1\xe8\x63\xc1\x2d\x1c\xfd\xd6\xea\x41\xe5\x09\xe6\x35\x94\x40\x92\x89\x28\x84\xec\x82\x8d\x62\xfa\x29\xbc\xe8\x53\x49\xd3\xc6\x74\x30\x8c\xf7\x5d\x7e\x67\xad\x9a\x8f\xf0\xa3\x60\x00\xc1\x75\xc9\x58\x37\xc5\x21\xd8\x59\x82\x3d\x9e\x71\x67\x72\x39\xec\x57\xda\x64\x1e\x3c\x70\x97\xba\x49\xfd\xbc\x15\x71\x27\x6e\xd6\x4e\x2a\x4d\x7a\xf2\xdc\xc4\x30\xe5\x59\xa1\x87\x8f\xdb\x88\x71\xa1\x89\xda\x1d\x2f\x6f\xcb\xaa\x82\x03\xb1\xb7\x41\xc1\xd7\x6a\xac\xca\x2b\xf5\xaa\xd1\xf3\x10\xe4\x6e\x03\x5e\x14\x77\x37\x9e\x42\x48\xed\xfd\x5a\xfd\xb8\x50\xa6\x65\x03\x17\x2c\xf4\xe6\xf3\x98\x31\xcf\xdf\xbf\x2f\xee\xe6\x4c\x67\xbe\xdb\x2b\x0c\x6b\x61\xb6\x41\x2f\x83\xf6\xfa\x54\x18\x91\x8f\xcd\xb2\x1e\xc3\x25\xbb\xfd\x68\x38\x1c\x6e\xc5\x2e\x48\xf1\xf0\xf4\x3c\x3b\xba\xa2\x2c\x0e\x3f\xcd\xcb\x46\xfd\x84\x61\xde\x38\x9a\x28\xb9\x61\x70\xcd\xf1\x0d\x64\x8d\x74\x5d\xb0\xfa\x24\x5a\x17\xae\xa5\x11\xe7\x95\x1e\x5f\xa2\x55\x75\x26\x41\xd8\x68\x94\x2c\xac\xa6\x19\x7a\x5f\xb0\x04\x74\xe3\xd4\x0c\xc4\x06\x45\x12\x13\xcd\x4a\x42\x79\xab\x1b\x9a\xbf\x84\xa3\xde\x30\x77\x77\x33\x34\xf2\xf9\x73\x57\x30\xa3\x6a\xd3\xcb\xe5\xe4\x5e\x19\xee\x18\xf0\x48\x1d\xb8\x5c\x28\x90\x1c\x18\xb8\x97\x37\xdc\xdb\x33\x6e\x18\x3a\xe5\x3d\x0f\x0f\x94\x20\x7e\x6f\x0d\x5f\x5e\xd7\x97\xb5\x3c\x3f\xa0\xe6\x78\x26\x31\xde\xfe\x9f\x63\x2a\x5f\xab\x99\x02\x6f\xaa\x6b\x45\x55\x58\x55\xd8\xf9\xb5\x84\x36\x67\x77\xd3\x82\xa3\xee\x3a\x89\x4c\x2a\x39\x53\xe3\xa9\x6c\x5a\x34\xab\x01\xd0\xaa\x42\x48\x58\x34\xbf\xcd\xec\x61\xe5\x2e\x08\x36\x99\xc1\x60\x07\x25\xe2\x5d\xe6\xec\x4c\xf6\xfd\x3f\xc7\x0c\x47\xc4\x5a\xb6\x46\xcc\x65\x43\xb8\xc1\xb7\x27\xd9\x58\x06\xa2\xee\x6e\x28\x77\xdd\x9e\x7c\x83\xc9\xdf\x40\x68\xeb\x2e\xc0\x73\x59\x56\xaa\xf8\xef\x65\xf8\xf9\x96\xa1\x73\x86\xf4\x9e\xd5\x68\x4d\x86\xa3\x03\x0c\xd9\xb5\x28\x21\xf9\x13\x21\xed\xc0\xcb\x73\xbd\xa8\x0b\xd9\x2c\x7b\x37\xad\x66\x72\x10\x64\x8e\x00\x10\x2a\x82\xf5\xec\x58\x66\x6f\xbf\xac\xeb\x26\x67\x9d\x0a\xd9\xdf\xba\x91\x85\x63\xdf\xd6\x36\x90\x51\xff\x82\xe3\x21\xd1\x00\x43\x63\x6c\x42\xed\xc1\xc4\xfc\x52\x93\xf1\x13\x15\xe4\x0c\xfd\xdc\x28\x3d\x3e\x15\x3d\x57\x40\xc8\xce\x3d\x6f\x46\x2c\xd9\x58\x03\x5f\x21\x76\xac\xd4\xba\xd7\xab\xea\x2b\xa4\x95\x17\x1a\x81\x0b\x9a\x7e\xec\xe5\xb0\xd1\x12\xa5\x4e\x0e\x51\x0d\xbb\x5f\x4d\xd2\x37\xde\x4e\x8b\x38\x59\x71\xab\xe7\xa2\x52\x57\xaa\x02\xb1\xcd\x9d\xbc\xcf\xd8\xb1\x34\xd6\xff\x64\xa3\xf8\xca\x87\x9c\x5b\x4b\xf2\x88\x0b\x05\x6a\x94\x37\xcf\x1a\xa5\x04\x87\x56\x94\x10\x8d\xe9\x84\x69\xa7\x63\x22\x66\x7d\x5e\xc5\x2c\x6b\xe1\xbc\xef\x52\x3d\x93\xd5\xcb\x58\x7f\xec\xaf\x39\xad\xfd\x62\x81\x8b\x69\xb3\x98\xb7\xaa\xf8\x61\xf9\x4b\x6d\xa7\xce\x6e\xf0\x94\x86\x41\x18\x41\x1f\x32\x9b\xa9\x53\x66\xd8\xca\x0b\xb8\x92\x62\x73\x5d\xe8\x19\x9d\xb0\x6d\xbb\xa8\xdb\xb8\xa8\xb8\x93\x44\x50\x15\xba\xf3\xf0\x55\x66\xa3\xea\x42\x35\x3d\xe7\x37\x1d\xde\x2e\xf1\x30\x6e\xb4\x02\x27\x13\x9a\x5a\x83\xb3\x7d\x64\xe7\x12\x7b\x2e\x02\xa8\x4d\xe7\x62\x6c\xe3\x3e\xdf\x09\x7a\x0e\x5c\x6c\xdd\x1e\xf8\x83\x78\xd4\x09\x43\xa1\x3e\x9d\xc1\xfd\x0b\x90\x5e\xc7\xe5\xa4\xf7\x55\x9b\x0c\xa0\x56\xba\x24\xbe\xa8\xdb\xb2\xc2\x24\xfa\xea\x53\x48\xcb\x81\x25\x8f\xcf\x1f\xaf\x8b\xad\xd9\x55\x56\x0f\x5b\xfb\xfa\xe6\xa3\x17\xed\x0f\xbf\xf0\x11\x13\x7b\xec\x78\x7d\xfc\x16\x0e\x3b\xb6\x78\xfe\x62\x0a\x4e\x73\x9e\xb6\x90\x1d\x05\x8d\x62\xc4\xa0\x21\x3e\xd4\x65\x14\xbf\xf4\x2c\x6c\xc2\x1a\x6e\x9c\x8c\x55\xf4\xfb\x22\xef\xc8\x95\x3d\x5a\x77\x6f\xb9\x69\x1e\xae\x6a\x74\x3f\x88\x79\x4e\x5b\x01\x28\x4d\x74\x5a\xa0\x3d\x13\x6d\xa3\x5b\xae\xfa\xba\x1e\xa2\x01\xaf\x43\x61\x9b\xd3\x4c\xb2\xd7\x72\x24\x63\x37\x59\xfe\xf9\xa6\xbb\xcb\xb2\x6e\x34\x58\x9a\x5f\x76\xa3\xdd\xe4\x7d\xb6\x66\x87\xc0\x1d\x15\x75\xf2\x86\x6d\xf2\x0f\x1b\x0e\x1e\x42\x0b\xc4\x59\x5b\x39\xb4\xdd\x8d\x87\x9e\x5d\xe7\x70\xe0\x3b\x74\x24\x2d\x10\xfc\x4c\x9c\xe9\x56\x56\x1d\x0a\x88\xa7\x6a\x8d\xb6\xea\x08\xc0\xee\xd0\x7d\xf0\xef\xfc\x27\x5b\x7f\x59\x55\x76\x44\x9e\x83\x1c\xa3\x0b\xc9\x0d\x14\xf0\x8f\x1a\xcf\x2f\x48\x00\xab\x46\xbe\x8e\x04\x56\xcf\x56\x4a\x04\x7c\x91\x6e\x39\x84\x2a\x9e\x9d\xeb\x45\x7b\x8c\x3e\x63\xff\xa1\xda\xfd\x69\x59\x15\x84\x98\x43\xc8\x9b\x18\x55\xf6\x8c\x82\x3d\x39\xf4\x89\xdd\xb3\x67\xaa\xb9\x50\x85\x20\x68\x4c\x81\x78\xb4\x0e\x20\xb8\x95\xe3\x4b\xf2\x05\xc6\x02\xe0\x96\x8f\x71\xc5\x62\x2f\x0e\x33\x56\xb3\x79\xbb\x3c\x81\xef\xb7\x76\xd3\x26\xa5\x38\xd7\xba\x52\xd2\x2a\xfb\x05\xa4\x15\xac\x2f\xc4\xf5\x54\x81\x3a\x80\xfe\x24\xd8\x01\x4a\x27\x55\x5f\x28\x72\x16\x2d\xca\xe2\x15\x6a\x07\x96\x31\xaf\x69\x1f\x18\x33\xb6\x1c\x7b\xa2\x47\x82\x5e\x32\x50\xd4\x0c\xa4\x49\x46\x8c\x17\xe4\x0b\x8e\x24\x6b\xb5\x15\x50\x85\x1c\x8f\xad\xde\x40\x33\x48\x06\x19\xae\x50\x4e\x5a\x34\x4b\x62\x5e\xb7\xaa\x51\xb2\x58\xda\x8a\xe6\x0b\x70\xc0\x73\xa2\x19\x7f\x40\xa9\x99\x9a\x01\x01\x4a\x5f\x3b\x37\x6e\x58\x13\xfb\x41\xe9\xe6\x9d\xfc\x93\x79\x18\x7e\x85\x83\x59\xdf\x8d\x23\xab\xde\xd4\x33\x69\x2e\x15\x53\xc3\xca\x60\xbc\xa9\x34\x27\xd7\xb5\xaf\xb1\xe4\xda\x5f\x51\x07\xd3\x2f\x77\xef\x38\xa1\xc2\x7f\x18\xb8\x2e\x1d\x4d\x02\x13\x15\xb8\x1e\xa5\x43\x16\x65\x6b\x54\x35\x19\x58\x0a\x00\x6f\x7d\x8c\xbf\x68\xdd\xf2\x70\x55\xc9\x74\xf2\x5c\xda\x92\xfa\xba\x16\x63\x4b\xed\x7e\x49\xc3\x25\xb4\xd4\x17\xd7\xe5\x1a\x0f\x10\xad\xee\x19\xa5\xee\xe5\xab\x1b\x0a\x90\xdd\x27\x1a\xe4\x77\xec\x61\x90\xe9\xc9\x11\x54\x1f\xe9\x60\xcb\x75\xa3\xac\x4d\xcb\x0e\x56\xdd\xa1\x47\xae\x51\xc9\x72\x26\xe1\x5c\xdd\x2d\xe7\x83\xdc\x62\xfb\xfc\x78\xaa\xf2\xab\x3c\x10\x8b\x98\x0a\x06\x22\xfa\x19\x86\x64\x62\x90\x67\x27\x0a\x73\x68\x5a\xd9\xaa\x97\x94\x20\x8a\x8b\x0d\x3f\x7c\x00\x57\x67\x00\x59\xae\x65\x75\xac\x66\xba\xfc\x9b\x2a\x1c\xd1\xc5\x7c\x28\xe9\xc5\x26\x35\x1d\xe7\xea\x49\x6a\x49\x62\x09\x8f\xd7\xd0\x7b\x67\x26\xfc\xd0\x09\xe2\x34\x19\x36\x63\x8a\x06\xcc\x8f\x01\x3e\xed\xab\x61\xf8\x8c\x77\xc4\xdd\xf0\x61\x82\x7c\x1f\x6d\x54\x9f\x47\xf4\x19\x78\xcc\x36\x0a\x58\x19\x40\x62\x40\x27\x1d\xdd\x2c\xea\xca\xf2\x1c\xee\x7c\x9e\x4f\x22\x00\x9e\x84\x60\x44\x00\x2f\xd7\x81\xb7\x30\x25\xbe\x2b\x6b\xb1\xa8\x9d\x87\x1e\x58\x66\x80\x95\xad\xbc\xb3\x0d\x1d\x8c\x67\x72\x29\xda\xa6\xbc\xb8\x80\xc4\xf9\x93\xb2\x2e\x5b\x05\x3a\xa6\x81\x38\xc9\x55\x55\x50\x2b\x06\x42\x1a\x5b\x35\xbc\x25\xad\x81\xbd\x82\x8a\xde\xbf\xff\x95\xb4\xb7\xd7\xa1\xbe\x64\x61\x6e\x4f\x88\x6e\xfd\x02\xda\xa0\xc3\x56\xc0\xb6\xef\x73\x76\xda\xb2\x16\x39\x92\xa0\x67\xef\x20\x43\x6d\xa7\x7f\xf0\x78\x37\x46\xc1\x58\x17\x02\x9f\x32\xf6\xae\xad\x04\x7c\xbc\xec\x8a\x40\x2f\xfa\x61\x97\x06\xdc\x19\x8f\x8f\x6d\x25\x0e\x70\x4e\x5b\x11\xc0\xb8\x2e\x52\x6f\x2b\xa4\xed\x7d\xcb\x98\xba\xa4\x8b\x11\x3d\x63\x59\x93\xbb\xf8\x8d\xc4\x1f\xf9\x95\x82\x7f\x32\x71\x5a\x23\x1c\x7a\x02\x32\x6a\x90\x24\x2a\x69\x4c\xe0\xb9\x5c\x1a\x5a\xe2\xb6\x84\xa2\x46\x93\xcf\x9b\x5d\x29\xb7\xf8\x09\xbd\x79\x6f\xb6\xdb\xf0\x56\xea\xb7\x9f\x84\x98\x93\xc7\x0c\x6b\x2a\x99\xef\xa3\xda\x57\xf4\x23\xd7\xf4\x95\x72\x4f\xfe\x10\x70\xa7\xf6\xbe\xae\xcd\x22\xb9\xbd\x62\x8f\x37\xf6\xd5\x83\x5d\x11\xe3\x39\xd8\x0d\xe6\xbd\xff\x22\xee\x26\xee\xe6\x02\x5f\xbb\x62\xc2\x4f\x6b\x30\xd8\x5f\x6b\x5a\x9d\x3b\x3c\xc8\x5c\xb3\xc0\x83\x57\x75\x2c\xde\xf6\x6e\x89\xe6\x7a\xde\x5f\x39\xd7\x0c\xc4\xb2\x4b\x05\xbb\x47\xb2\x2f\x91\x74\x93\x61\xc0\xa8\x33\xc8\xf9\xc3\xce\xfe\x32\x0d\x2f\xcc\x74\x4d\xcb\xc1\x6e\x2f\xca\x02\xe9\x0e\x7b\x73\x37\xd3\xc4\x90\xe4\x77\x67\x49\x7e\x2a\xca\xfa\x4a\x36\xa5\xac\xdb\x1c\xcc\x0e\x6f\xdb\x89\x5e\x60\x3c\x27\x89\x62\x67\xfe\x62\xef\xeb\x81\xed\xb6\xc4\x8e\x00\x76\xf1\x10\x2c\x2b\x08\x9a\x93\x99\x15\x37\xc0\x60\x02\x6d\xd9\x35\x53\xed\xa6\x62\xc5\x9c\x36\xda\xf2\x9f\xf0\x04\x70\xd7\x75\x12\x55\xc1\xd5\xc2\x14\x92\x78\x74\xae\x61\x26\xef\x94\xdc\xf7\xd6\xee\x86\x5d\x62\xa9\x67\x27\x07\x27\xa2\x7f\x7e\x25\x17\x17\xd3\x7a\x4b\xbc\x46\x18\x1a\x8e\x28\x9d\xca\xab\x52\x37\x04\x10\x52\x07\x8b\xb5\xc5\x5e\xc0\x93\x45\xbb\x68\xd8\x07\xf8\x08\xc5\x08\x82\x17\x51\xb5\x90\x45\x81\x0e\xc3\xcf\xf9\x7a\x79\x26\xd9\xe1\xbf\xbf\xa8\xcb\xba\x55\x35\x02\xc4\x6c\xf9\xd6\xca\x5a\x9c\xa2\xd6\x84\x1b\x90\x5c\x89\x1d\x67\xbd\x48\xb4\xd2\xbb\x51\xe8\x70\x0a\x18\xf5\xf5\x2e\xe2\xc1\x2d\xc7\xdd\x1b\x75\xe3\x77\x51\x1b\xef\xd3\x8b\x8f\xdb\x7c\x9b\x78\x81\x75\x81\xa8\xbe\x35\x19\xee\x56\x1a\xce\xb1\x6f\x37\xc1\xa2\xf5\x91\x1a\x35\x28\x9b\x11\xb5\x6d\x71\x08\x26\x80\x43\x92\x9e\xe3\x26\x58\xfc\x59\x2f\xe0\x38\xa5\xa4\xb5\x18\x4f\x9e\xa9\x44\xd7\xe2\x5b\x23\x00\x7c\x70\xa6\xaf\x14\xd6\xd6\xed\x1a\x78\xda\x96\xed\xb0\x37\x10\x89\x3b\x7c\xf4\x33\x01\xc6\x89\x12\xc7\x46\xfb\x22\x16\x97\x62\x81\x9e\x77\x34\x13\xc0\x0a\x91\x23\x45\x59\xe8\x25\x83\xeb\x39\xd7\xd6\x15\x77\xfe\xf9\x0f\x92\xce\xac\x22\x59\xbc\x00\x48\xef\xcc\x6f\xdd\xe9\xc0\x8c\x13\x88\x89\xc4\xaf\xfe\x44\xd2\x62\xd0\x2c\x13\xa5\x63\xcd\x99\x32\x24\x56\xe6\x18\xf3\xb7\xa6\x3b\x8e\x1d\x90\x4a\xef\x7d\x6b\xee\x71\x1e\x70\x02\x1f\xc8\xd6\x6b\x29\x60\x93\xbd\x37\x08\x06\x11\xb2\x69\x1c\xe9\xcd\x02\xec\x8a\x88\x8f\xae\xdc\x9a\x76\x70\x10\xf5\x79\x40\xc4\x2c\x12\x39\xd6\xd9\x25\x2c\x2b\x97\xe3\xb6\x1c\x83\x1b\x1e\x6d\x37\x5d\x2b\x0c\x23\x28\x6b\x8a\xf3\xbf\x56\xe2\x1a\x22\xac\xc0\xe6\xc3\x87\xd8\x51\xdb\x33\x60\xaf\xe0\xea\x8c\x9e\xa9\x73\x5d\xb0\x2a\xb5\xb0\xc4\x73\x5e\xa9\x0f\x78\x95\x48\x38\x8e\x47\x75\xab\x6d\xf7\x64\x59\x83\x2d\x93\xc2\xab\xe8\x48\xe1\xaa\xdc\xc1\xc9\x3e\xee\xce\xb6\xe4\x84\x58\xb7\xd9\xcf\xd8\xc4\xe1\x9c\xd6\x28\x62\x94\x2b\x73\x00\x36\xb6\xc3\x7a\xd1\x82\x6f\x0d\x99\xc1\x9a\xe8\x16\x0f\x2d\x4f\x86\xcc\x59\x04\x93\x64\x4f\x84\x20\x1d\x3c\x9c\x0b\x46\xb5\x43\x77\xbb\xdf\xc8\x06\xc0\xf2\x21\x38\xc4\x4e\x13\x84\x64\x36\x43\xf1\x56\xf5\xaa\x4a\xc8\xca\x68\x66\x30\x60\x5d\x7b\xf6\xea\x68\xb8\x6e\x9b\x6c\xa6\x4e\x10\x63\xf9\x20\x8d\x29\x2f\xea\xfe\xdf\xbf\x24\x87\x6f\x4c\x0a\x19\xa9\xe8\x06\xa3\xd6\x3a\xf9\x31\x29\x9a\xe8\x8f\x41\x1c\xc9\xed\xf4\x5b\x34\x32\xda\xbe\x45\x16\x50\x69\xe0\x82\x6b\x69\xff\x08\xf1\x4c\x54\x0d\x60\x1d\xb8\xf6\x76\xad\x2e\x9a\xb2\x65\x95\x88\x6c\x6e\xae\x65\x08\xdc\xb1\xfb\x1b\x50\x8b\xc4\x52\xb5\x03\x07\xa3\x00\x2d\x82\x17\x8e\x6c\xc5\xa4\x6c\x0c\xa4\x69\x21\xf8\x22\x02\xb6\x13\x65\x6c\x4f\xa3\x90\x0c\xb0\xd7\x51\xc6\x21\xd4\xd8\x82\x9e\xb3\x7a\x3f\x63\xc5\x19\x4c\xcb\xfb\x79\x1e\xbb\x89\x42\x9f\xa9\xe0\xf3\xe7\xc4\xe2\x19\x7b\x85\x66\xec\xb2\x5e\xdb\x44\xb3\x2a\x08\x47\x65\x8b\x03\xe2\xd9\xab\xa7\xaa\x29\xdb\xe0\xf3\x9e\xb1\x52\xe1\x36\xf9\xa5\x6c\x43\xf4\x13\x26\xf2\x77\x51\xce\x65\x2d\x8b\x2b\xd5\xb4\x18\xfb\x02\x5e\xd0\x11\x9e\x84\xc8\x58\x6b\xd7\x99\xf4\xd6\xc8\xb4\xab\x67\x74\x20\x32\xc6\xd9\x0d\xe4\xdd\xf5\xaa\x65\xa6\xd6\x4e\x30\x65\xa8\x0a\x32\x41\xa8\xf5\x3b\xa7\xa3\x74\xdc\x62\xb3\xdc\x75\xe5\x72\x67\xdd\x21\xab\x20\xad\x26\x83\xb1\xb7\xeb\x58\x15\x03\xe4\x63\xe0\x70\xbf\x8c\x36\x62\x19\x47\x32\x36\x20\x2c\x58\x30\xa6\x48\xbb\xbd\xc0\xcc\xec\xb7\x0b\x86\x52\x5d\x96\x73\x72\x0b\x67\x30\x1a\xbb\x73\x81\x90\x2c\x45\x15\x48\x75\x66\xff\xcd\x30\xf2\xb4\x02\x32\x34\x81\x55\xaf\xac\x96\xc0\xe1\x67\xf3\x05\x5a\x53\x88\x6c\x90\x72\xc9\x83\x19\x77\x28\xd0\x91\x23\xcb\x9c\x86\x93\x2e\x5d\x42\xcc\xec\xca\x78\xfb\x2d\xbc\x17\x37\x4f\x82\x3b\xec\x62\x56\x66\x94\xd0\x55\x21\xfa\xba\xc1\xcd\xee\x6d\xeb\xb0\x79\xf1\x26\xe5\xda\x9e\xdc\x6e\x42\x8e\xd0\xce\xe3\x50\xaa\xbd\x67\x6c\xc8\x5a\x1d\x3e\xcc\x95\x6a\x8c\x42\x80\x6d\xf2\x92\x59\xaf\x8c\x67\x36\xd9\x6a\xbd\x3c\x5b\x78\x34\x12\x2f\xf5\xb5\xe7\xf6\x76\x00\x8e\xe3\xd7\x05\xe2\x3f\x10\x90\x55\x6a\xdc\x5d\xcb\x19\x82\xa9\x5c\xd5\xcf\xcd\xd5\xdf\xcc\xf7\x91\xfb\xd6\x57\x4d\xd3\x4f\x6b\x3e\x83\x67\xe7\x14\x9a\xbf\x67\x99\x6c\x62\x69\x5f\xcd\x73\xbb\x65\x6f\xe4\x8c\x41\xa4\x64\xd0\xad\x49\x59\x17\x24\xc3\xa4\xb7\x6e\x71\xb4\xae\x73\x96\x76\x61\x20\xda\xe1\x41\x03\x6d\xaf\x16\x1e\x77\x81\x29\x80\x08\x50\x4e\x44\xd9\x62\x85\x33\x79\xa9\x8c\x30\xaa\x36\x0a\xd6\x09\xd2\xbd\x82\x39\xa7\x44\xa4\x40\x8a\x5f\xe6\x7e\x78\xa3\x5b\xd6\x28\x97\xd7\x24\x1c\x77\x35\xd8\x2f\x66\x68\x94\xfe\x48\xcc\x28\xe8\x3a\xb1\xbc\xfe\x32\xac\x36\x80\x0b\x9d\x24\x11\x9e\xf6\x31\x0c\xec\x6e\xc6\xa7\x91\x23\xe8\xe2\x03\x0a\xf0\x3c\xbb\xd8\x90\xb6\x22\x77\xfc\x6c\xce\xdb\x52\xff\x02\x9a\xa7\x1c\xa2\xa8\x10\x77\xe9\x6d\x6e\xc6\x9f\x83\x05\x2d\x40\x6b\x29\x54\x2b\xc7\xd3\xce\x12\xfc\x02\x53\x2c\x3c\x0e\x2a\xb6\x91\xdc\x4a\x26\x73\x13\x9a\xb6\xed\x90\x5f\x6a\xc0\x64\xdb\x13\x0f\x77\x7d\x56\xa1\x37\xe0\xb1\x28\xf4\x5c\xfe\x68\xcf\xb2\xe5\x5c\x21\xb8\xd4\xe1\xe9\x8b\xb2\x6e\x85\x55\xb3\x2a\x46\xcd\x43\x99\x73\x59\xb7\xf2\x13\x65\x61\x5b\xd6\x63\xb1\x27\x1e\x21\xc0\xd5\x4b\x48\xdd\xb5\x27\x1e\x3f\xfa\xfe\x37\xdf\xff\xf6\xc9\xaf\xbf\xff\x0d\xb4\x73\x2c\x3f\x59\x99\xf8\xc9\xe3\x1d\x71\x2c\xdb\xe9\x70\xae\xaf\xfb\x8f\x07\xe2\xc9\xa3\x2d\xb1\x2d\x1e\x61\x45\x6f\x5e\x1e\x9d\x7d\x38\x3d\xfa\xdf\x87\xb6\x36\xc2\xcb\x3a\x7e\xf6\x1f\x47\xfb\x1f\x5e\xbe\x39\xfe\xe1\xf0\xf5\x87\x93\xe7\xcf\x4f\x0f\xcf\x6c\xe5\x08\x68\xf7\xc8\x85\x19\xab\x4f\xf3\x92\x12\x04\x03\x16\x4b\xa3\xe6\x96\x15\xd5\xad\x11\x8f\x1e\xce\x42\x60\xdc\x99\x39\xd3\x87\xae\xf4\x59\x39\x53\xfd\x99\x71\xfb\xff\x19\xe6\x59\x96\x45\x01\xf3\x31\x99\x18\xd5\x86\xd8\x78\x88\xec\x61\xf7\xd1\xd4\x9f\x75\x33\x79\x51\x8e\x45\x8d\x28\xd2\x13\xcd\x73\x3c\xf4\x6b\xd2\x9f\x19\x31\x0a\xc6\xf7\x59\x3c\xdc\x12\x0f\x72\x83\x4b\x6e\x8e\x15\x5c\x19\xf6\xeb\xc5\x0c\x0e\xf8\x71\x69\x4a\x5d\x47\x26\xfc\xbe\x7d\x29\x46\xfe\x2d\x57\xfe\x68\x4b\x7c\xe7\x9f\x26\xf5\x82\x08\xa2\xfc\x3c\xfc\xb0\x18\x5f\xaa\x96\x1d\xec\xed\xac\x0c\x82\x39\x3d\xaa\x8f\xcd\x40\x9c\x43\x99\xd3\xf2\x6f\xea\xd8\x44\x5d\xe0\x5e\x06\x5f\x8b\x07\xc9\xe7\xe1\xf0\xe3\xaa\xc2\x37\x5b\x01\x99\xfa\xf3\x82\x48\x01\x92\x2b\xa0\xcf\xa0\x41\x7a\xbb\x13\xb8\x48\xfc\x20\x8b\x63\x39\x7f\xa5\xab\xe5\xc4\xea\x50\x81\x1f\xa0\xc7\x87\x42\xd6\x54\x1f\x7e\x6a\x55\x0d\x6a\x1b\x1e\x2c\x62\x4f\xe0\x1f\x43\x7b\x56\xa9\xba\xa5\x02\xba\x36\xfd\xbf\x7f\x61\xf9\xe0\x3b\xa1\x4c\x55\xd6\xed\x76\x81\x29\xb8\x44\xad\xb7\xad\x90\x40\x59\xb4\xec\x9f\xc7\x72\xde\x7f\xf7\x2e\xd3\x02\xba\x08\xbd\x7f\x4f\x75\x31\x8e\x5a\xae\xe8\xfb\x4e\x7b\xe8\x56\x15\x35\xe7\xe1\xaa\x42\xa0\x22\xd8\xca\xfb\x1a\x82\x75\x9c\xb7\xa9\x90\xe7\x7a\xd1\x8a\x73\x59\x88\x39\x4d\x8e\x61\x4f\xcc\xce\x9c\x45\xf1\x85\xe0\x21\xf4\x9c\x9d\x44\x40\xc3\xd2\xb5\x90\xc2\xdf\x10\xc1\xae\xa8\x95\x2a\x0c\x1d\x35\x85\xae\xad\xd4\x06\x0e\x3b\xf6\x6f\xf2\xd1\xb0\xda\xdd\x1d\xb0\x55\x20\x5c\x55\x3b\x05\xd0\x6c\x04\xaf\xf3\xc7\xd1\x1d\xbf\xa0\x10\xbb\x04\xfe\x5c\xc0\x4c\x1e\xc5\xe4\x0b\x9d\xb2\xdc\xad\xdf\xca\x8b\x81\xb8\x54\xcb\x01\x7a\x8e\x03\x32\x3a\x9a\x9f\x18\xf0\x02\xb4\x47\x94\x81\x2d\x2d\x4c\x4b\x83\x47\xab\x68\xe5\xc5\x2e\x3f\xb9\x54\x4b\xb1\x67\xeb\x71\x4f\xc8\xe7\x80\xbd\x74\xe1\x99\x63\xaa\x21\x74\x3e\x64\xb6\x3b\x57\x0d\x15\x0a\x40\x00\x92\xaf\xd1\xf4\x95\x56\x59\x9e\x57\xe8\xb6\x1a\x3d\xe6\xa4\x11\x78\xa2\xc2\xa3\x46\x4d\xc2\x66\xe1\xd9\x9c\xc2\x98\xe0\x2a\x3f\xa9\x82\x75\x8b\xec\x4b\xd4\x81\xff\xe7\x42\x2d\x3a\x83\xe4\xef\xc0\x21\xa0\xd3\x62\x77\x96\xc1\x64\x90\x3e\xe4\x99\x21\x47\x49\xfe\x1a\xdd\xf4\xf0\xa3\x97\x1a\x5f\xba\x86\x6b\xf5\x89\x3c\x4b\x3b\xad\x82\x0d\x24\x79\x47\xaf\x2a\xd9\x79\xe3\x5a\x8b\xb8\x3c\x34\x89\x61\x36\x5c\xc0\x63\xcf\x74\x12\x45\xc0\xfb\x0f\x1e\xce\x26\xa4\x47\xf6\x3b\x0e\xca\x9c\x32\x46\xbe\xf7\xea\x0e\xde\x9e\x10\xca\x77\xf6\xe5\x0d\x01\x7a\x60\xf1\xea\x6e\x55\x0f\x01\xbb\x8a\x73\x25\x08\xb0\x5e\x84\x5a\xc9\xea\x6c\xa7\xd2\x68\xed\x20\x68\x08\x5c\xa5\x5c\xc2\x28\xae\x78\x20\x1a\x49\x3e\x82\xd2\x32\x87\x57\x27\xff\xe3\x24\x2c\x38\x10\xa6\x2d\xab\x0a\xfc\xec\x50\xb4\x21\x33\x19\x1c\xa6\x78\xe5\xa5\xab\x0a\xf0\xe8\x76\xe0\x4c\xdf\x12\x2f\x35\x98\x6d\xc9\x0d\x0c\xcf\xe2\xa5\x37\x17\x10\xd2\x19\x9a\xbf\x4a\x33\x74\xfb\xdb\xbd\x41\x18\x13\x5b\x9b\x10\xc8\x71\x8a\x72\x32\x29\xc7\x8b\x0a\x64\xe2\x79\xa3\x8a\x72\xdc\xa2\xb1\x0c\x70\x4f\x2e\x54\x2b\xf4\xbc\x2d\x67\xa0\x8d\x4b\xd4\x4a\x97\x10\xf9\x24\xab\x99\x36\x2d\xd5\x55\x83\x70\x53\xd6\x15\x98\xe4\xe7\x8d\x9e\xab\xa6\x02\x9b\xbf\xe5\x0d\xe5\x18\x98\x59\x59\xa9\xc6\x80\x8b\xe2\xe3\x74\x2c\x8d\x15\xfe\x74\x2d\x3e\xf2\x60\xf4\x44\x10\x14\x2d\x44\x43\x5b\xa6\xd3\x2a\xd3\x96\xf5\xc5\x50\xbc\xe5\x08\x6a\x6a\x5c\xa2\x6c\x02\xf0\xbc\x68\xe7\x6b\x19\x38\x0c\xe2\xa7\x47\x23\xf1\x64\xcb\x7e\x85\x40\xfa\x0c\x0a\xa6\x5c\x7e\x1c\x94\x58\x10\xe6\xb6\x5e\xcc\x54\x53\x8e\x31\x69\x2b\x60\xd1\xfa\x21\x2b\x69\x4a\x04\xba\xb5\xa4\xaa\xdd\xcc\x20\xf6\x4b\xad\xeb\xed\xff\x71\x74\x26\x54\x7d\x55\x36\xba\x9e\x01\xe7\x1e\x8d\xc4\xf7\xd0\x36\x5c\x73\x49\x53\x56\x4b\x71\xa1\xd1\x5e\x1e\x13\x0e\xf8\x9a\xa2\x57\x08\x9e\x2d\xe4\xe8\x59\x95\xad\x6a\x64\x65\x09\xde\x1e\x2b\xd4\x7a\x69\xc4\x44\x9a\x96\x86\xf7\xab\x2d\x71\xd4\x06\x08\x4a\x4a\x1a\x40\x35\x24\xb1\x14\x1d\x41\xa5\xd8\x17\xd8\x1a\x2c\x24\x60\xd2\xda\x67\x90\x8f\x0a\xd2\x04\x59\xba\xa5\xfa\xed\x7a\xc9\xd6\x9e\xbe\xe4\x45\x1b\x74\x2c\x44\x49\xd9\xe8\x9c\xf9\xe6\x79\xa5\xaf\x9f\x97\x9f\x8e\xd5\x0e\x0a\xc9\x53\x39\x27\x1c\x6b\xf5\x49\x8e\x5b\x01\x67\xe1\xf9\xa2\x15\xb6\xa0\x33\xcf\x5b\x9d\x20\x9c\x22\x13\xc8\xf2\xea\x7a\xd3\xc3\x2e\x49\x41\x82\x93\xe4\x12\xb3\xf5\x03\x0d\x32\x90\xdc\xee\xde\xf5\x2f\x86\xf3\x46\xb7\x1a\x48\xf0\xfe\x7d\x91\x79\x3c\x2c\x0d\x28\x29\xbe\xaa\xdd\x84\x45\x80\x52\xd3\x6a\x9a\x45\x2b\x41\x7b\x16\xeb\x02\xa2\x0b\xcd\xb2\xc4\x30\xcd\x87\x14\x03\xe9\xf7\x9d\xb1\x33\x3c\xe7\x42\xb9\xd4\xf2\x75\x6f\xa8\x8c\x8d\x13\x1e\x67\xc8\xf3\x79\x76\x5a\x4b\x4b\x76\x41\x1f\xc9\xb9\x58\x8a\x02\x72\xbb\x12\x52\xa6\xdd\x38\x73\xad\xd1\x8b\x4f\x8d\xa7\x75\x69\xd5\x25\xbe\xcf\xf1\xd0\xd9\xa0\x2b\xf4\xaa\x8a\x6b\x03\x1b\x02\xb0\x0e\xf0\x20\x96\xad\xb0\x3c\x45\xb4\xd7\x9a\x33\x0c\x18\xab\xc4\x20\xb6\x33\x6c\x7c\xdb\x0a\xd0\xd0\x3d\x08\xc8\xbc\x47\x39\xb1\xb8\x42\xd0\xff\xb8\x9d\x46\x89\x89\xd5\x38\x01\x26\x7d\x61\x94\xbf\x09\xaa\xe4\xdf\xec\x46\x64\x1f\x2c\x67\x19\x97\x55\xa5\xd1\xc5\x9b\x2b\x84\xa4\xd8\xb4\x15\x0d\x23\x33\xd4\x17\x14\x99\x69\x29\x18\x59\x1f\x0a\x0e\xc5\xd0\xee\x43\xb8\x48\xb2\x55\x5d\x8b\x85\xdd\x79\x5c\x57\xa3\xc6\x95\x2c\xf1\x9e\x0c\xeb\xb5\x32\x45\xb3\xb4\x53\x6f\xc7\xcf\x36\xb3\xee\x7a\xf9\xcd\xc7\x6b\x3f\x04\x9a\xe7\x1f\x40\xfb\xfc\x23\xbb\x07\xba\xf5\xb2\x24\xe7\x2a\x24\xb7\xd1\x4e\xb9\x50\xba\xe3\xc2\x81\x85\x3b\x72\x82\x18\x8d\xc4\xc1\xe1\x7f\x6e\xc3\xba\x4e\x4a\x55\x15\x9c\x99\x31\xa9\x33\x90\x20\xb8\xca\x10\x12\x6f\xe5\x17\x4e\x9e\x88\xbf\x8a\xb3\xee\x64\xbf\x64\x59\x23\xfe\x30\xc8\x29\x42\xf1\x68\xc9\xc7\xa1\x28\x14\x25\xea\xe8\xec\xa1\x6c\x16\x98\x14\xa0\xf4\xad\xf7\x08\x67\x6b\xbf\xab\x60\xe8\xcd\xc9\x56\xb9\x06\x2a\x41\x01\xae\x95\x17\x39\xca\x58\x21\x36\x7a\x53\xbb\xab\xa0\x2a\x4d\x4b\x1e\x1a\x15\x26\x13\x80\x7b\x8f\x6c\xa5\x19\x71\x33\x53\x2a\x2f\x79\x76\x8a\x65\xa4\x50\x9a\xe9\x74\x28\xa9\x4c\x1a\x3f\xd8\xed\x7e\x91\xc8\xf8\xe1\xcf\xdd\x4c\x03\xac\x65\xf0\xba\xc1\xef\x4c\xb5\xa9\x7a\xc0\xe5\xa3\xe7\x6b\xbe\x63\xf5\x20\xfd\x0e\x9e\x67\xbe\x8b\x35\x0e\xfe\x2a\x78\xea\x1c\xa8\x00\x6e\x97\xaf\xce\xf5\x95\x6a\x9a\xb2\x28\x54\x1d\x46\x83\xbb\x2b\xc0\xf8\xba\xbc\xdb\xaa\x57\xaf\xdc\x8e\xc6\x27\x99\x1e\xb2\xce\xe5\xf9\x4b\xa1\x3e\x65\xca\xa1\x22\xc6\xa5\x1a\x35\x09\xef\xde\xd2\xad\xf1\xa5\x93\xf3\x8f\xcd\x9e\x61\xb6\x97\x08\x1c\x2f\x60\x82\x5c\x96\xc1\x34\x9c\x51\x24\xc4\x4e\x25\x23\x6b\xb7\x25\xa8\xe3\x79\xa3\x67\x87\x28\xf7\xf4\x29\x65\x78\x4e\x7c\x58\x7d\xaa\xea\x44\x79\xc1\x3d\xce\x4f\xa9\xca\xe1\x07\xcd\x1c\xc6\x5d\xb2\xf3\x80\xbc\xdd\x32\xf0\xe5\xe7\xef\x00\xc9\x92\xf8\x19\x2a\xe1\xfc\x06\x94\xf1\xd8\x63\x0d\xbf\xcd\xaa\x35\xdc\x58\x2a\xf6\xb4\x90\x14\xf8\x69\x34\xab\xb1\x45\x7d\x8d\x58\xb7\x13\x7d\x96\xcf\xce\xb6\x4e\x20\x73\x1d\xe3\x33\xc8\x9f\x3d\xf8\x38\xd9\xdb\x3c\xf4\x39\xef\xbd\x20\x54\xb7\x33\x05\xa6\xb5\xdb\xa1\x33\x01\x29\xf9\xfc\xdf\xef\x28\x0a\x15\x2e\x6b\x49\x2e\x95\x15\x48\x97\x7c\xe1\xd1\x43\x43\x6a\x2f\x90\xc6\xfc\xad\x8c\x34\x80\x4c\xe9\x6e\x36\x08\x96\x12\x2d\xbf\xa4\xb7\x51\x4c\x90\x57\x8d\xf8\x2c\x1a\xc6\x96\x32\x7b\x70\x2c\xed\xe1\x2d\xcc\xd2\xb4\x6a\x06\xee\xea\xae\xa5\xf3\x46\x5f\x12\xcc\x14\x79\x0c\x80\x9a\xa7\x67\xe8\x8d\x64\x86\xe1\xf9\xd3\x28\xf4\x13\xa4\xea\x5a\xdd\x28\xd7\x7a\x92\x0a\x84\xd4\x37\x9f\xaf\x04\xef\x14\x8d\xbb\x85\x0c\x83\xff\x20\x42\x29\xe6\x29\x4f\xc5\x5b\x52\x5b\xe3\xc1\x5f\xa8\x96\x51\x12\x54\x21\xe8\x96\x89\x63\xb4\x82\xa6\x09\xce\x53\xd6\x28\x2c\x62\xf3\xd8\x13\xdd\xd0\x5b\x8e\x73\x1b\x57\xba\x56\xa2\x6c\xc3\xb1\xe2\xcc\xce\x1b\x7d\x2e\xcf\x2b\x08\x00\xaf\x40\x32\xbc\x96\x4b\x94\x40\x71\xe7\x2d\x1a\x74\x7a\x1d\x46\xd4\xf9\x95\x74\xe5\xad\xb7\x51\x62\x3a\x11\x21\x67\x38\x8a\x73\x09\x7b\xc4\xe7\xcf\xe2\x56\xe4\x48\xa6\x11\xab\x13\x23\xe7\x18\x56\xaa\xbe\x68\xa7\xf0\xe5\xc3\xd0\x07\x95\xb3\xdd\xf5\xc0\xb7\x93\x6e\x75\x26\xba\xb9\xd0\xac\x73\x5b\x95\x74\xa9\x17\x81\x7d\xd3\x7b\x8f\xc1\xed\x4e\x4f\x3c\x10\xf7\xc0\x07\xcc\xbb\xf8\x0d\xec\x1a\x2c\xf5\x82\x54\x78\x90\x9d\x66\x00\x0b\xbe\x98\xbb\xf4\xcd\x10\x8d\x28\xed\x2e\xc0\xeb\x74\x33\xbc\x17\x7b\x7a\x76\xd3\x2c\x22\xbb\x7e\xba\x2a\x1b\x5c\x82\xb9\xe3\xd2\xce\xf9\xec\x11\xc9\xa8\xff\x52\xff\xa5\xde\x47\x5c\x62\xa0\x7e\xc8\x4b\x48\x2e\xb0\x7a\x22\x3e\x76\x12\x65\x7e\x1c\xa6\xd0\x1d\xe4\x9d\xd0\xb9\xca\x44\x12\xc0\xb5\x81\xc8\x10\x10\xe1\x76\x84\xbb\x69\x93\x02\x59\x9f\xe8\xdb\xbd\x79\xbe\x28\xab\x76\xbb\x0c\xb0\xee\xcd\x16\x6e\x1b\xb8\xec\x1c\x05\x90\xad\x94\x5f\x31\x01\xce\x37\x5b\xb0\x3f\x2f\x74\xbb\x23\xbe\x35\xc3\x6f\x4d\x6f\xc0\xd4\x82\x74\xf1\x14\x7f\xee\x84\xa4\x34\x80\xa9\xd8\x4a\x62\x80\xba\x09\x32\xc3\x13\xd2\x04\xc2\x7b\x27\xdf\xdf\xea\xa3\x14\x8b\xde\x28\x37\xde\x46\x1e\x60\x3c\x66\x16\x08\xcc\x26\x12\x01\x9c\x1f\xeb\xc5\x15\xae\x77\xfd\x51\xb3\x6e\xe7\x9b\xdd\xcd\x47\x7c\x8b\x01\x9f\xa9\x4f\x2d\x7a\x67\xdc\x56\xfa\x59\x75\xac\x9e\x81\x37\x07\x4a\x65\xb7\x19\x27\x75\xe2\x97\x19\xa6\xed\x18\xdb\x42\x9f\xeb\xe6\x40\x55\xca\x16\xdb\x40\xc8\x0c\xa4\x84\x9c\xa4\x19\xc9\x06\xbd\x83\xc3\x17\x87\x67\x87\x07\xbd\x5b\xf5\x6d\x5f\x56\x55\x7f\x2c\xf3\xf3\x75\xbb\xf9\xb7\x55\x05\x1d\x06\x08\xab\x9b\x09\x8e\xcd\x00\xb6\xf4\x54\xd6\x45\x85\x7b\x2c\xbf\x4a\x12\x99\xe1\xcf\xbf\x44\x08\x92\xde\xc7\xf2\x2f\x21\x77\xd9\x4f\x9d\x8e\x04\x77\x7d\x23\xaa\xfc\x39\x87\x84\x40\xf0\x7d\x70\xec\xfa\x19\x56\xd7\x63\xcb\x0f\x04\xd6\xb9\xc1\xe2\xa6\x4a\x32\x7e\x07\xba\x6f\xa3\x6a\x2b\x07\xbc\x7b\x7f\xab\xd1\x27\x51\x41\x94\xe6\x11\x7d\x95\xc0\xdb\xe7\xa8\x9e\xe8\x1d\xd7\x50\xf8\x14\xd5\x19\xea\xd1\x3e\x75\x81\x52\x41\x5a\x19\xea\x0d\x79\x7e\x04\xa9\xea\x49\xc0\xc4\x23\x31\x32\x53\xbb\x26\x12\xeb\x35\x64\x7f\xdf\x70\x91\xac\x06\xd9\x8f\xbb\x28\xa6\xcb\xa2\x91\xad\xf2\x7e\x4f\xcb\x71\x05\xd7\x17\xa4\x38\x95\xba\x26\x33\xe2\x78\xaa\x64\x8b\x98\x96\xb0\x85\x48\x56\x6e\x40\x40\xb1\x02\xa5\x4f\x68\x32\x1a\x09\x3f\x63\x56\xfc\xae\x97\xec\x72\xbc\xa8\xcb\xba\x6c\x4b\x59\x95\x7f\x53\xc5\xf3\x68\xd9\x13\x85\x98\x15\xc5\x46\xeb\xd6\x4f\x3b\xe7\xd7\xec\xd6\x33\xc8\xad\xcb\xc6\x0b\x42\x7e\xe2\x33\x59\x42\xaa\xb0\x88\x0e\x76\xe8\xc2\x10\x0b\x81\xf1\xbb\x58\x3e\xd7\x0d\x02\x8b\xec\xe0\x2d\xdd\x80\xce\xf3\xba\x34\x53\x84\x26\x0d\x6b\x26\xe7\x9b\xf0\x11\xf7\xa3\xfb\x86\xd6\x64\x87\xff\x18\x90\xaf\xc0\xa7\xd6\x21\x26\x41\xca\x06\xf8\x84\x29\xa0\x3b\x21\x11\xd5\xda\x59\x0c\x08\x05\x7f\x92\x8b\x85\xae\x71\x24\x8e\x48\xa2\x14\x82\xd1\xdb\x37\xf5\x8c\x90\x58\x7c\x81\xa9\x34\x2f\xf4\xc5\x85\x2a\x0e\xc1\xb9\xc9\xdd\x5a\x86\xb8\x07\xed\x78\x0a\x6f\x4d\x7f\x12\x7b\xad\x78\xb1\x4c\x36\x0e\x05\xc6\x3b\x6a\xf8\x72\x35\x14\x20\xd3\x65\x9c\xa4\x2b\x94\xfd\x9b\x05\xdc\x5a\xdc\x8d\x3b\x15\xca\xae\x9d\xee\xae\x8f\x09\x43\x64\x35\x4e\x37\x2a\x54\x3d\xc6\xcb\x5f\xb8\x1e\x44\x7f\x2e\x2b\x2f\xf6\x06\xf6\xef\x4c\xa4\xd5\x97\xd4\x03\xdb\x6a\x16\xec\xa0\x66\xfa\xcc\xcd\x82\xb8\x06\x12\x2f\x3f\x7c\x78\x7d\xf8\x6c\xff\xec\xc3\xc1\xe1\x7f\x9e\x9d\x9c\xbc\x38\xfd\xf0\x1f\x2f\x4e\x7e\x78\xf6\xe2\xc3\x1f\x4f\x4e\xfe\xf4\xe1\x03\xea\x30\xdd\x7c\xcf\xe0\xbd\xea\xba\xbb\x22\xfa\x81\x7c\x65\xb4\xbe\x14\x7b\x37\xb4\xc3\x37\x25\xb6\xf0\xb0\x34\x07\xe8\xf2\x52\x84\xde\x26\x78\xc7\x60\xf5\x4a\x29\x1a\x25\x2b\xba\x0e\x6d\x97\x1c\x97\x60\xbf\x45\xe5\xb7\x6c\x39\xb3\x04\x58\x7c\xe1\x46\x51\xe8\x85\x8b\x61\xd1\x13\x3f\xd3\x18\x38\xe1\x15\x7a\x69\x8c\x1e\x63\x60\x38\xad\x91\x81\xe7\x95\xbe\xf0\x3a\xf8\xb4\x6d\xe7\x66\x67\x34\xba\x28\xdb\xe9\xe2\x7c\x38\xd6\xb3\xd1\x44\x8e\xd5\xb9\xd6\x97\x23\x70\x0d\x1c\x81\x23\x9d\x19\x3d\xf9\xed\x6f\x7e\x13\xce\x8e\x77\x78\xe1\xab\x76\x3b\x60\x06\x2a\x7a\x5e\x06\x19\x29\x12\x28\x34\x47\x29\x67\x1c\xd6\x01\xb9\xdf\xe9\x3e\xc7\x0e\x29\x21\x21\xb8\x9d\xd4\xe0\x38\x0d\x41\x46\x65\x55\x81\xc7\x28\x5c\x86\x41\xa4\x9f\x73\x28\x63\xf5\x3f\xad\xcc\xb9\x07\x12\xd4\x5a\xdc\xc2\x10\x6b\xe1\xb9\x98\x9c\x0f\x67\x0a\x47\xbf\x5d\xa8\xab\xd6\x16\xe9\x45\xb0\xa8\xa3\x51\x40\xe0\x94\x3c\x1b\xb0\xb5\xdb\xa9\x5e\x5c\x40\x10\x06\xdf\x51\xb2\xef\x1f\x72\x98\x55\x33\x18\x7b\x5a\x91\x31\xa2\x81\xeb\x0f\x24\x24\xd8\x05\x01\xf1\xef\x06\x17\x06\xa0\xec\x9a\x05\x40\xf8\x4c\x16\x15\x5c\xab\xff\x15\x54\xbe\x81\x30\x1a\x8e\x1a\xbc\xf0\x36\x72\x82\xfe\xf6\xca\x9e\x9c\x50\x33\x51\x42\x8e\xa3\x45\x4c\xc8\x71\x9d\x26\x02\xd3\xa4\xa1\x40\x1f\x3b\x75\xf4\xfd\x38\x06\xc0\x40\x79\x0e\xe9\xdf\x15\x8c\x32\xdf\x6e\x94\xe3\x64\x4d\xc3\x54\x4f\xd4\xb6\x8f\x97\xe6\xc6\x73\x0c\x11\x60\x1d\xec\x43\x59\x55\x94\x17\x30\x88\x38\x83\x5b\xda\x9a\x67\x10\xe0\x9d\xd9\xb0\xee\xce\x11\xd8\x7b\xc3\xb5\x34\xbf\x21\x77\x1c\x46\xec\x91\xb3\xcd\x77\xc9\x6e\x5d\xec\x0a\x4f\x0b\x2e\x85\x5b\xb6\x80\x63\x66\x56\x3d\x6b\x23\xce\xac\x2c\xaf\xe6\x97\x6c\x93\xbc\x08\x09\x80\x41\xae\x59\xb7\xee\x37\xb7\x1c\xd7\xba\x9b\xa2\x86\x15\x65\xf1\x56\x36\x35\x63\x23\x9a\xb2\xa0\x3c\x24\x91\x67\x3b\xac\x32\x66\x5c\x40\x07\x03\xcb\x49\x38\xc8\xa7\x20\xb0\xd1\xb2\xbe\x82\x6b\x5e\x5d\xdf\x81\x2f\x4e\xcb\xfa\xa2\x5a\x8a\xaa\xac\x2f\x55\xb1\x0d\x97\x65\x7a\xe2\xe2\xa1\xd0\xae\xe8\x12\x00\xc3\x4e\x63\xb9\x63\xc0\xbe\x26\x10\x7f\xde\xea\x3b\x64\xa7\xfc\x11\xee\x73\x28\x76\x31\x4e\x28\x4d\xc6\xd8\x6e\x4e\x7d\x14\xad\xc1\x6c\xda\x5e\x6b\xac\xc2\xd8\x0a\xed\x30\x8c\x9a\x4b\x2b\xfb\x70\xc4\xf5\x52\x98\x29\x78\xe1\x84\xe2\xb2\xb3\x30\x0e\xef\x8c\x46\x41\xce\xdc\x34\x78\x92\xed\xb6\xb6\x02\x0c\x78\x2c\xbc\x0d\x2e\xdf\x2f\xc8\x68\xec\xda\x46\xc1\x90\xcf\xb3\x68\x7c\x76\x00\xb2\x25\x67\x26\xba\x26\x2f\x27\x64\xad\x0d\xeb\xb5\x15\xda\x99\x3b\xd7\x0d\xb0\x32\x5b\x13\xfd\x48\x3a\x38\xd6\x57\xb0\x83\xce\x97\x60\x78\x85\xfc\x1a\xb6\xb7\x7c\xd5\x44\x83\x3d\xcb\x75\x1e\x17\xc2\xb6\x43\x0e\xcc\xc2\x2c\xce\x2d\x83\x4c\xd6\x06\xca\x71\x4d\xce\x90\x0c\x0e\xeb\x90\xa6\x14\x70\x0e\xb9\x9b\x9d\x56\xce\xd5\x58\xcf\x94\x09\x6b\x1c\xde\xe9\x28\x1d\x6f\xfc\xa5\x5e\xff\x5c\x1a\x05\x57\x82\x5e\xe9\xfb\x91\xee\x00\x71\x6b\xb8\x02\x3b\xfe\x4f\x14\x7c\xd5\x1a\x61\x1c\xae\x65\x43\xd9\xb9\x92\xf1\x6f\x4e\x47\xf2\xa2\x8c\x9f\x4f\xa5\x79\xae\x9b\x31\xf5\x31\x92\xe1\x4b\x73\xe4\x25\x69\x7a\xc3\x52\x36\xf6\x15\x27\xaf\x34\xaf\x30\x1a\x2b\xf1\xd5\x0b\x5c\xf0\x7f\xc4\x0b\xcd\x58\x00\x34\xaa\x69\x79\x57\xb7\x1a\xa7\x07\x0a\x32\xa1\x7a\x27\xf4\xb9\x55\x12\x60\x96\x3d\x5e\x32\xdc\x93\xd7\x05\x2f\xa8\xdd\xbd\x0c\xe8\x80\xfd\x02\x88\xec\x8c\x2b\xcb\xff\x64\xd2\x80\x50\x9a\x60\x20\x30\x89\x62\x4f\x84\x9f\x53\x83\x1d\xdb\xbb\x2f\x03\x17\xe7\x51\x41\xb1\xb2\x86\xa8\x7f\xa9\xd6\xbd\xc7\x0e\x99\x56\x3d\xcf\x16\xf9\x03\xd5\x35\xcc\xd9\x0f\x44\xfe\x9b\xbd\xfc\x37\x5d\x26\x9f\x2e\x48\x90\xfa\xa1\xb3\x20\x18\x38\x8d\x9e\x0c\xad\xb0\x22\x58\x0b\xee\xcb\x20\x9f\x06\xce\x3c\x45\x69\xda\xb2\x1e\xb3\x42\x4f\xbc\x8d\x75\x60\xe7\x01\x11\x65\x05\x88\xbd\x93\xdc\x06\x79\xe4\xde\x47\x77\xe4\xc1\x84\x3e\xca\x26\xab\x85\x9b\xad\xb7\xc9\x65\x13\xa6\x77\x83\x0d\x86\x1a\xba\xbb\x5f\xc7\x83\xe2\x5a\x21\x32\xa8\xcb\xd6\xc6\x21\x7b\x85\xb2\x94\x08\xae\x96\xe1\x95\x15\xe5\xb8\x40\xb4\x44\xe2\x03\xc2\xef\x1e\x87\x6f\xe2\x29\xce\x72\x55\xd7\x3a\x70\x97\x9a\x75\x01\x88\xa0\x88\xbc\x0a\xc0\xb9\x11\x25\x1f\x70\x84\x7c\x09\x71\x55\x73\xf0\xb1\x46\x71\x5f\xce\xe7\x4b\x8e\xbf\xb0\x4c\x6f\x3e\x6f\xb4\x1c\x4f\x87\x9e\x2e\xb2\xf3\xe7\x6c\x0e\x21\x8b\x0a\x50\x1f\xc2\x05\x78\x1c\x5d\x5d\xdb\x59\x4f\xd6\x2f\xc5\x6f\x77\x5f\xc5\xe5\xd2\xf5\x0b\x56\xf0\x71\x67\x05\x37\xaa\x65\xfd\x28\x48\xce\xea\x6c\xde\xc7\x91\x67\x4a\xf0\x90\xfe\xb0\xc3\xa1\x99\x7b\xca\xcf\x76\x22\x37\x77\x2b\x96\xc0\x19\x97\x15\x11\x08\x95\x04\x33\x85\xb8\x22\xde\x51\x78\xe8\xd8\xa8\x1d\x3f\x91\x70\xcc\x4c\x99\x0f\x3c\x8e\x2e\xe5\xf0\x51\x54\x12\xc2\xe4\xee\xae\x94\x94\x3a\xb0\xd5\x4e\x6e\xf5\x08\xf4\x7d\xc6\xbc\x1b\x70\x44\x3d\xfd\xd2\x10\xc2\x33\x76\x55\x5d\xcb\x70\x90\xa0\x61\x65\x47\xea\x07\x2a\xde\xc4\x0f\xc2\x9c\x9f\xf3\x45\x63\xfb\xe1\xb4\xbd\xbf\xa9\x46\x0b\x5b\xd1\x36\xba\x30\x99\xa1\x0f\xe0\x40\x47\x5d\x77\x51\x75\x50\x12\x60\x36\x5e\x6f\x21\x36\x0c\x67\xdd\xea\x39\x13\xc4\x3a\xf9\x31\xcd\xdb\x16\x42\x13\x34\xaa\x47\xc1\x8e\x96\xb3\xd1\xc1\x24\x8b\xee\x31\x24\x49\x8a\x00\xee\xa7\x3e\x95\xf1\x31\xd4\xa5\xe9\x35\x27\xdf\x23\xc7\x69\x77\x03\x95\x72\x37\xee\x1b\x81\xe6\xfc\x18\x1d\x63\x83\xf0\x9a\x1a\x7a\xa9\xc5\xb9\x6e\xa7\x01\xcb\xf5\x8c\x32\x3e\x1a\x3d\x99\xe5\x8f\xcc\x5b\xf4\x77\x4d\xd1\xc7\x9b\x0c\x0d\x7a\x6c\x4f\x72\x2f\xc3\xd3\xe8\x5c\xce\x0b\xbf\xd3\x5c\x6a\x4d\xb8\xf6\x74\x5f\xde\x89\x30\x45\xf4\xc4\x49\xc7\xb2\x02\xd9\x19\x38\xe8\xa9\x1e\xf8\x84\x5c\xb8\xca\x92\x84\x0c\x0d\xeb\xad\x27\x77\x9c\xf3\x01\x54\x3b\xbc\x73\x8b\x99\x18\x8d\xc4\x0f\xe8\xe3\x00\xce\xfe\x6e\x61\x98\x6c\xa6\x4a\x7c\xb4\xa3\xf9\xe8\x40\x4c\xf4\x84\xd7\xc0\xb1\xa2\x54\x7e\x48\xb0\x43\xb1\x1b\x49\xe4\x5e\x2e\x0d\xa7\x0b\x30\x5d\x09\x67\xb7\x22\x00\x95\x84\x37\x8e\x12\xf1\x16\xb3\x98\xf7\xae\x3c\x95\xa3\x62\x9d\x84\x97\x99\xba\xe9\x61\xf0\x5d\x47\x6a\x49\x26\x01\x78\xd4\xf3\x46\xcf\x28\x35\x25\x7e\x3a\x70\xb1\x11\x88\x02\x40\x9c\x0c\xbc\x28\xbc\xdc\x3d\x97\x8d\x3d\x9f\xd9\x71\x8f\xc4\xa4\xf0\xe9\x6e\xac\xe0\xc6\x1f\x64\x15\x5b\x3f\x3b\xcf\x6b\x8c\x47\x8d\x2a\x4b\x86\xf8\xbc\x1e\x5a\x86\xd5\x5f\xd3\xdb\x8e\xe0\xe9\xf1\xaa\xa2\x9a\xbf\xe4\x00\xe0\xc2\xf3\x70\x05\x50\xc6\x80\x39\x5b\xd8\x07\xf0\x2a\x47\x79\xe3\x30\x23\x69\x06\x49\x92\x72\xf9\x91\x86\xe9\xba\x43\x0b\xb1\x2f\xb9\x73\xa8\x21\xc7\xf8\x15\x0a\xdc\x20\xd4\xfd\x32\x6a\x1b\x4f\x39\x3d\x66\x8a\xfc\xd1\xcb\x16\xac\x5c\xad\xf5\xbe\xe4\xd3\x31\xd0\xbd\xc2\x1a\x87\x89\x22\xd6\x55\xc5\xa2\xd2\x89\x9b\x00\x7d\x42\x1a\x5a\x54\xd2\x41\xd9\x78\x8d\x2d\x7a\x6f\x1f\xf1\xeb\x44\x1b\x8b\xca\x45\xef\xf8\x03\xe7\x3a\x8a\xfe\xd8\xc4\x50\x23\x3f\x60\xc7\x25\x41\xb9\xc7\x8c\xb6\xe4\xa5\xec\x34\xdf\xa1\xaf\xce\xf9\x27\xcf\xf8\xe1\x2a\xad\x72\x85\x5e\x89\x27\x6d\xe2\x24\x32\x1a\x89\x53\x45\xd1\x2a\x93\x4a\x5e\x04\xf8\x37\xd7\x24\x60\xb1\x68\x02\x2a\x39\x9a\x95\x5d\x06\x36\x3e\x8b\xb9\x2e\x6f\xb4\xb2\x82\x19\x66\x6f\x0a\xe1\x7c\x57\x68\xad\xde\x6a\x7b\x27\xf1\xc5\x76\x97\x61\x69\x4c\xf5\x90\x52\xde\x99\xcb\x72\x0e\x7e\xb9\x10\x95\x45\x26\x8c\x81\x0b\x78\x18\x8d\x44\x59\x5b\x3a\x67\x6c\x76\x39\x1e\xeb\xa6\x00\xd3\x93\x63\xf6\x6b\x63\xf3\x7e\x3e\x35\xe6\x67\x55\x62\x7e\x36\x15\xe6\x06\x05\x06\x12\xcc\x13\x93\x8e\x15\x90\x1f\xbb\xd4\xcf\x6c\x86\x3f\xf8\x31\xde\xc0\x1d\x76\xba\xa2\x5c\x97\x63\x74\xfc\xb9\x3d\x21\x05\xcd\x47\x94\x44\xf6\x4b\x5d\xb7\xc7\x0b\xfb\xd5\x2b\x66\xee\x41\x29\x7f\x60\xb8\x4e\x00\x57\xd8\xf5\xd6\x4f\x40\xdb\x09\xec\x2a\x84\x1d\x41\x5f\xa5\x5a\x97\xaf\xf0\x70\x63\x43\x40\x78\x5c\x1f\xa6\x26\x87\xd5\xe7\x40\x78\xf1\x45\xbd\x71\x28\x5e\x74\x79\x31\x99\x94\xe3\xd2\x32\xec\x79\x53\x6a\x40\xff\x42\xf0\x20\x76\xa1\xe4\x8b\x91\xec\x7d\xb3\x9b\x91\x5c\x8f\xb1\xcf\x2b\xbf\x8c\x8c\x29\xab\x4a\xfd\x21\x3b\x53\xe1\x25\xe9\x68\xc4\xca\xcb\x7a\x56\xe0\x3e\x58\x6b\x83\x39\xcc\x8e\xe3\x4b\x30\x9e\xbb\xb4\xde\x61\x1f\x3c\x09\xc4\x37\xb4\x5d\x92\x35\x9e\x36\x7d\xb5\x04\x3f\x0d\xb9\xea\x69\x6b\xc2\x16\x27\x6a\xa0\x52\x8e\x06\xe9\x71\xed\xc0\x41\x84\x4b\x75\x1f\xc5\xcb\xe4\x16\x7e\xe5\xa2\xbb\x4f\x8e\x26\xf6\x0c\x72\xa9\x08\xd8\xde\x0b\x47\x8f\xe5\xa3\x73\x55\x0c\x44\xd1\x68\x82\x97\x62\x4d\x92\x6d\xd4\x78\x9a\x9f\x3b\x13\x8a\x2c\xae\x64\x3d\x66\xe1\x60\xaa\x64\xc7\x1c\xb8\x6a\x5a\x63\x8b\x5f\x66\xd0\x9e\xbf\x50\xa1\x8e\x65\x22\x31\xf3\x85\x0e\xa3\x5f\x92\x99\xa2\xa3\x26\x3d\xae\x2c\xed\x7f\x48\xc4\xd0\x10\xd5\xc4\xef\x4a\x08\x35\x04\xad\xdc\xb7\xcf\xac\x6b\x23\x31\xd8\xa4\x42\x25\x50\xd6\x5a\xd6\xd4\x49\x84\x97\x76\xf5\xeb\x1b\xb6\x03\x8b\x6a\x8b\x9c\x6a\x27\xa2\x9f\xe9\x59\x58\xa4\x13\x5d\x7a\x54\x5c\x8a\xa9\xbe\x06\x02\x87\x98\xe1\x29\xfa\x64\x43\x38\xf2\x30\xf8\x8e\x27\x2d\x84\x65\xa4\x2e\xc6\x1d\xf2\xfb\xac\x93\x0e\xb0\x5b\xcb\x4d\x35\xf8\xbd\x9c\x9d\xf1\x28\x8b\x79\xe4\x0e\x1c\x12\x00\xc8\x53\x45\x4a\xc2\xb1\xa0\xb5\x22\x75\x3e\xd5\xc1\xe2\x5a\x26\xd5\x62\x60\x65\xd7\x82\x6f\xc2\xb8\xbc\x09\x99\xf5\x87\x50\xe8\x73\x2c\x3a\x7c\x18\xad\x72\x5c\x3a\xb3\x89\x6e\xae\x4f\xec\x91\xb7\x5a\x38\x97\xd1\x67\x43\x80\xec\x8a\xec\x0b\x58\x6e\x15\x5b\xfb\x72\x27\x12\x21\xa2\xd6\xd2\xc9\x59\x19\x7c\xf7\x79\xcf\xdd\x39\x26\x31\x1f\x39\xc6\x01\x26\xba\xdc\x9a\x45\x3e\x24\x2a\xb1\xeb\x0c\x39\x86\x1c\x80\xc4\xdc\xb9\xb9\x56\x9d\x89\xe2\xed\x72\xec\x2f\x77\xa2\xac\x39\x4d\x62\x61\xfd\xa5\xd3\x21\xe6\x4e\x80\x5e\x23\x58\xc7\x60\xa3\xa4\xbd\x52\xd5\x09\x02\xcf\xac\x6c\xdd\x1d\x2e\xdf\x04\x8d\x53\xa4\xf2\x8d\xa8\x0f\x34\xd4\x75\x84\x17\x5a\x9f\x02\x15\x04\xcf\x0d\xbb\x05\x60\xc5\x00\x4e\xfc\x52\x21\x86\x19\xe8\x48\x85\x83\xd9\x25\x3d\x24\x84\x6f\xc1\xa4\x0c\x59\xfa\xe5\x25\x71\x20\xca\x25\x02\x4e\x95\xe2\xf7\xd1\x88\x28\xbe\x62\x57\x94\x0f\x1e\x74\x25\x3a\xf2\xc4\xe5\xc2\xef\x4a\xda\x15\xd1\xb6\xf4\xc4\x3e\x0e\x88\xb3\x73\x60\x63\x40\xc5\xb9\x43\xf6\x55\x85\x90\x17\xb2\xac\x87\x62\xbf\x52\x92\x52\x5c\x71\x95\x46\x13\x38\x6f\x5d\xb9\xb3\x97\x26\x80\x87\x2d\xd2\x56\xa3\x23\xf1\xae\xf3\xe6\xf2\xaf\x13\x03\x4a\x0e\x55\xec\x08\x83\x1d\x84\x6c\x2e\x16\x10\x05\x31\x97\xd8\x53\xe3\xfa\x36\x14\x87\x3e\x10\xc2\x9b\x9c\x8f\x28\xa7\x51\x83\xc9\x5d\x0a\xf2\x4d\x73\xcd\xa7\x00\x62\xee\x05\x5a\x64\xe2\xbc\x18\xe4\x1f\x38\x91\x97\x8a\x3d\xd6\x8e\x3c\x08\xe8\xdf\xbf\xa0\xff\x5f\x69\x9e\x35\x8d\x5c\x8a\x3d\x01\xff\x0e\xe9\xf7\x6e\xc7\x95\x01\x90\xda\x61\x97\x3d\x83\xe3\xc3\x8e\x0c\xdd\x28\xc9\x32\x87\x75\x06\x59\xd3\x4e\x6a\x9a\x89\x7d\x3f\xb9\xde\x87\x86\xbb\x8e\xae\xdf\x71\x94\x0a\x1b\xfc\xa3\x69\x67\xab\x2f\xad\xc9\x8a\x25\x01\x44\xee\xfe\x70\x38\xdc\xda\xf1\x73\xec\xec\xb0\x7a\x8e\xb8\xfa\xe2\x23\x7f\xfe\xd1\x2f\x13\x47\xa3\xe1\xed\xc0\xda\x45\x01\xd0\x76\xd7\xed\x81\xeb\x0c\x4e\xbd\x0f\x82\xc5\x00\x7e\xa3\xc5\x45\xa3\x8d\x21\x2f\xba\x9e\xf1\xf7\x8f\xb5\xae\xb7\xc7\x4d\xd9\x96\x63\x59\x81\x29\x9e\x3c\xec\xd8\xd1\xa1\x24\x8b\x2e\xf8\xde\x2d\x8c\xc2\x98\xad\x4a\xcd\x8c\xc7\x07\x98\x29\xc2\x08\xb9\x28\xaf\x6c\xff\xeb\x72\xac\x1a\x02\xab\x9b\x29\x63\xe4\x05\x58\x9b\xd9\x44\x20\xc7\xed\xc1\xc9\xf1\xa3\x5f\x0d\x37\x81\xd2\x6e\xb8\xf8\xaf\xbd\x6b\x3a\x56\x64\xa7\x78\x8b\x54\x71\x30\x58\x5c\x97\x60\x2b\x68\xf4\xb5\x11\x52\xdc\xfb\x90\x41\x3b\x65\x34\x74\x4f\xf3\xf7\xee\x10\x70\xc1\x58\xcd\xf9\x7e\x89\xe2\xb7\xd0\x39\xf2\x15\xb9\x23\xf6\x73\x74\x3c\x10\xbd\x5c\x33\xbd\x01\xd1\x91\x02\x7c\x14\x3b\xc6\xc8\x47\x00\x70\x5a\x77\x02\x5a\x0c\xdc\x50\x3b\xbb\x79\xed\x38\xae\x64\x59\x01\xac\x17\x43\xff\x89\x47\xbf\x7e\x40\x2b\x43\xe1\x64\x76\x75\x0c\x44\x83\x61\x1c\xd8\xa2\x6a\xcb\x79\xa5\xc4\x58\xcf\x4b\x65\xbc\x87\x21\xdc\x42\x37\x4a\xc8\xb6\xb5\x67\x28\xa5\x98\xaa\x95\xb1\xd3\x45\x75\xff\x8a\x7c\x3c\xe8\xd2\xca\x35\x89\x8f\xf1\xa6\x69\x83\x55\x1d\xd0\xb2\x95\xa6\xfe\x8b\xf7\x0a\x54\xc5\x50\x9c\x35\xcb\xf8\xfc\x70\xfd\x76\x77\x4a\x63\x3d\x5f\xfa\x5e\xf7\x6d\xb7\xcb\x42\xc9\xaa\x5a\x0e\x84\xb9\x2e\x21\x8f\x85\x76\x64\x36\x44\x5b\x29\x86\x02\x6c\x0d\x43\xcf\x45\x74\x7e\xa3\xc5\x9e\x34\x4a\xfd\x4d\x65\x17\xd9\xa3\xc9\x41\xa5\x70\x91\x9a\x5c\x0a\x84\x7c\x85\x6f\xf9\xc0\xcd\xa4\x0b\x91\xf7\x5c\x37\x94\x73\x9e\x6c\x23\x04\x47\x42\xbf\x02\xa1\xdd\xaa\xa0\x49\x8e\x23\x94\xa0\xe9\x4e\x34\xb2\x83\x34\xce\x20\x5b\x1a\xc2\x02\xdd\xf1\x7f\x92\x2b\x4c\x0d\xa7\xec\x29\x29\x20\x21\x01\x06\x76\xec\x40\x18\x0f\xf8\x4a\x94\xb8\x83\x03\x2e\x2e\x54\xeb\x33\x29\xed\x26\xd6\xcd\xe0\xd8\x4d\xe2\x29\x9f\x22\x2b\xdd\x11\xf1\x51\x2b\x92\xe4\x1c\x1d\xf6\x1d\xb0\xec\x1e\x1b\x27\x7b\x5b\xb9\xa0\xc5\x8e\x25\x61\xe5\x32\xf4\x43\x77\xc8\x44\x6a\xf0\xdd\x49\x2d\xd7\x79\x63\xb5\x88\x26\x6f\x27\x9e\x4a\x57\x86\x07\xe1\x87\xef\xdf\x39\x7d\x35\x62\x17\xf8\x06\x15\x99\xce\x0b\x2b\x9b\xef\xbb\x2a\x43\x63\x32\xbe\x73\x7e\xfe\x82\xad\xc8\x22\x73\xe5\x98\x73\x5b\xe1\xb2\x21\x41\x73\x91\xc4\x95\x86\x36\x55\x44\x66\xaf\x83\xfb\xf0\x3c\xa9\x99\x7f\x72\x1a\x0b\x6f\xf4\xff\x99\xe9\xcc\x7c\x15\x81\x59\x25\xe6\xff\x65\xfa\x8a\x2f\x4a\x32\xe4\xf5\x4f\x4b\x57\x81\x63\xc8\x3f\x33\x59\xc5\x6b\xfd\x53\xd9\x56\x4c\x6e\xff\x4c\x54\xe5\x24\x66\xaf\x55\x4f\xd5\xf8\xf2\x94\x30\x40\xe8\xec\x25\x53\x5d\x7a\x0f\xac\xab\x82\x0e\xf0\x5a\x5d\xd3\x5f\xba\x2a\xe8\xf8\xac\xd5\xb5\xff\x2b\x49\xf7\x03\xe1\xf1\x15\x23\xe7\x04\xfa\xc5\x1a\x2b\x45\x78\x6f\xbc\xba\xd8\x0a\x4b\x49\x98\x40\x24\x01\xcd\xf2\x28\x4b\x46\xc8\x9a\x8d\xf7\x68\xb3\x19\x84\x4e\xf5\x54\x51\x12\xb4\xe1\x8c\xb6\xb7\x48\xf4\xb0\x49\x4e\xd6\x7c\xa2\x31\x93\x5b\x98\x95\x38\x95\x69\xa2\xa8\x74\x01\x7b\xd9\xea\x7a\xd1\x96\xc2\x22\xce\x56\xb8\xbe\x27\x7d\x4f\x08\xd9\xe5\x77\x04\xda\xc9\x33\x95\xe5\x24\x56\x0d\x8d\xda\xbf\x1b\xf2\x23\xcc\xff\x94\xef\xc7\xd6\x8e\xc0\xa0\x5e\xf0\xe4\xf7\xe8\x10\xa8\x4d\x02\x50\x1c\x68\x9a\x9c\xb1\x1b\xb4\x92\xa1\x38\xf6\xb6\x1b\x1d\x2e\x34\xb8\xb4\xd9\xdd\x9d\x4d\x17\xb5\x2e\x39\x69\xc0\xe3\x62\xfa\x09\xc7\x15\xd1\x11\x2f\x7b\x0c\x26\x18\x3f\x19\x96\xe6\xd5\xa2\x51\x09\x96\x60\x1a\x13\x73\xd7\x4c\x01\x5b\xee\xf0\xc7\x85\xac\xfa\xdd\xdd\x0a\x3d\xed\x14\x4a\xb6\xef\x56\xd4\xb9\x4e\xc4\x52\x87\x75\x80\xd8\xce\xea\x43\x36\x03\xd1\x2f\xb0\x55\xc2\x43\x6e\xc3\x14\xb2\x21\x8d\xa3\xb6\xf6\x0a\xe1\xce\x43\x22\xc7\x17\x71\xde\xbd\xa8\x70\x7a\x0b\x91\x5f\x38\xc6\xe7\xf1\xeb\x47\x78\x1f\xab\x36\xae\xc8\xa6\xd8\x23\xcb\xca\x4b\x2d\x3e\xe2\xf7\x1f\x19\x30\xc4\x65\xa3\xc4\x3b\x47\x22\x7c\xaf\x3b\x01\xad\xf3\xa8\x76\x44\x51\x16\xa0\x5c\xca\xf1\xb8\x2c\x54\xdd\x5a\x05\x92\x97\x56\xd6\x0c\x27\xea\xee\xd0\x02\x60\xcd\xa7\x94\x70\x6c\xfd\x65\xc7\x2f\xd8\x75\x40\x76\x91\x84\x89\x87\x68\x31\xad\xaa\x01\x14\x13\x53\x02\x72\xfd\xc3\x4c\x4f\xd3\xad\x88\x60\xe6\xff\xa1\x5a\xba\x8f\x07\x82\x3f\xa9\x0f\x4f\x7f\x2d\xf6\x7c\x36\x9e\xe1\x45\x5c\xc0\xee\x9a\x55\xef\x1c\xc0\xa7\xdd\x05\xcf\xe6\xf3\x06\x0c\x49\xe1\x07\xd1\x8d\x2b\x4f\x54\xbe\x13\x98\xd2\x2f\x6a\x1a\x50\xc1\x89\x9b\x41\xaa\xc3\x81\x90\x62\x5e\xc9\xb2\x16\xff\x43\x5e\xc9\xd3\x71\x53\xce\x11\x5c\x9f\x63\x19\xcf\xc2\x24\x1c\xce\xda\x00\x66\x65\x28\xa6\x7c\x82\x61\xb4\x61\x60\x98\x24\x3e\xdb\x0f\x2a\x3a\x20\xa2\x99\x59\x7e\xe9\xe7\x5b\x92\x62\xee\x42\x57\x89\xc9\x76\x28\xc5\x4d\xf6\x01\x82\xf0\x00\x0b\xca\x4e\x76\x58\x20\x9d\xec\xf0\x5d\x76\xb2\xb3\x53\xdb\x69\x12\xa7\x36\x6a\xe8\xff\xe2\xd4\x42\xee\x08\xc6\x3f\x76\x13\xe9\xe7\xb8\x08\xfb\x49\xf3\xdb\xa1\x6f\x9c\x5f\xe6\xbc\x2e\xa3\x60\x34\xb9\x73\x7e\xda\x9d\xa5\xce\x87\x03\xd1\x73\xc5\xa3\xc9\x41\x39\xc9\xf1\xef\x30\x66\xf9\x5b\x33\x14\xd1\x60\x60\x78\x99\x11\xf9\x9a\x37\x1b\x4e\x92\x46\xd6\x8f\x28\x4d\x51\x9f\x1f\x54\x9c\x50\xb1\x17\x65\x7e\xfe\xb9\x87\x16\x55\xbe\x7e\x74\xee\x80\x3a\x8d\x85\xac\x54\xea\x1b\x67\xcb\xc5\x49\x66\xbb\x83\xcf\xd6\x0e\xdc\x18\x65\x5d\xe6\xc0\x74\x2d\x83\xde\xf0\xb9\x6f\xfa\x5b\x43\x11\xed\xfe\x15\x32\xd7\x53\xde\x16\x0a\x0f\xe1\xd2\x88\xf9\xb4\x91\x74\xfd\x22\xc5\x8f\x0b\x65\x40\x50\x08\x9c\x08\x45\x90\x6c\x1b\x3f\x57\x41\x9e\x33\x3e\x93\x48\x3e\x4b\x67\xf1\xab\x45\xa5\xe0\x60\xbe\x41\xb4\xbe\x9b\x07\x0b\xc8\x9f\x72\xd9\x79\x5d\x31\x59\xb4\xf5\xf3\xad\x92\x97\x79\xad\xe1\xbe\x0d\x53\x27\x4d\x55\x2d\xd4\xa7\x16\xb1\x2f\x88\x95\xd8\x91\x79\x98\x69\xac\x91\xe2\xdb\xb1\x28\x95\xf3\x03\x2f\x27\xf9\x0e\x31\xf6\xf4\xc6\x02\xee\x33\x08\xc4\xf0\x07\x75\x5e\x9b\x0f\xa8\xf0\xa0\x2c\x7c\x68\xf7\x4a\x0a\x0f\x4a\x6d\x4c\xdf\xfe\x9b\x4d\xa9\xdb\x7f\x61\x17\xe2\x87\x24\x35\xb1\x59\x8c\xa7\xa2\x2a\x27\x6a\xbc\x1c\x57\x0c\x89\x9f\x3b\x05\x5d\x7d\x6f\xcb\xaa\x72\x15\xae\x38\xf9\xc2\xee\xbe\xc6\xeb\x2c\x06\xdb\x59\x37\x1b\x51\xd1\xdb\x4c\x49\xf8\xe1\x2d\xe6\x25\xfc\xec\xb6\x93\x73\x34\x71\x73\xd3\x26\xc1\x0b\x28\x24\x94\xe0\x95\x30\xd7\xb5\x01\x0d\x0b\xf2\xbf\x01\x22\x38\x75\xd2\x56\x62\x19\x43\x34\xb1\x69\x8f\xd2\x56\x26\xaa\x1d\x4f\x45\x21\x5b\x69\xd5\x34\xa8\xa3\x59\xd4\x51\x48\x90\x7d\x31\x5b\x20\xf0\x8f\x11\x72\xd2\x2a\xba\xd0\x80\x39\x21\x44\x6e\xe8\xe7\x9b\xa3\x81\x88\x7a\xe0\x62\x86\xfa\x5b\x37\x71\x71\xea\x6c\xa9\x36\x58\xd9\x4e\xd9\x8d\x97\x36\xfd\x72\xd3\xb5\x4d\xbf\xeb\x70\xf5\x35\x93\x9e\x25\xe9\xa9\x34\xe8\x98\xe4\x10\x90\x23\x39\x03\x87\xb4\x06\x8a\x39\x1d\x63\xf2\x75\x07\x87\xf2\x6e\xd2\x60\xa8\x58\x40\x1c\xb6\x1d\xb6\xa5\x26\xf0\x12\xc6\x7c\xf0\x1f\xbf\x35\x1f\x07\xa1\x4b\x86\x06\x87\x00\x44\x8e\x5c\xcc\x7d\x44\x10\xb6\x09\xa1\x59\x31\xe4\x64\xcf\x44\xb9\x17\xac\xb4\x80\x2e\x05\xc3\x7b\x94\x7b\x79\x9d\xdc\x12\x49\x98\xa1\xdc\x12\x8a\x74\xab\xe5\x96\xf0\xf3\x81\xe8\x9d\xaa\x16\xb3\x65\x86\xb5\xae\x95\x59\xf8\xb2\xd4\x4b\xa7\x0e\x38\xe5\x5c\x89\xf2\xa2\xd6\x8d\xe5\xf9\x96\x50\xf8\xae\x7d\x90\x95\x3a\x81\xbc\x52\x09\x15\xc5\xa2\x5e\x66\x1e\x02\x9b\x18\x7b\xbe\xe5\x34\x20\x7b\x80\xe3\xfb\xfb\xf7\x9d\xb1\x0b\x1f\xdc\x0d\x91\x46\xad\x12\x80\xbe\x11\x58\x7c\x6b\x6b\xdd\xad\xf1\xb7\x64\x43\xd8\x11\xb3\x85\x69\x03\xcc\x1c\xaf\xdb\xea\x06\x6c\x89\x1b\x1c\x76\x5b\xa9\x67\xdc\x4d\xb9\xff\x57\xe9\xf4\xce\xa1\x25\x63\xc5\xc8\x24\xcf\x0f\x91\x56\x6f\x93\xfc\xbc\x5b\x13\x4f\x42\x90\x06\x1d\xb2\x82\x02\x87\x36\x99\x24\xfa\x9b\xc8\x00\xa9\x37\xcc\x97\x8e\x35\x08\xdc\xcf\x8e\xea\xf9\xa2\x7d\x85\x11\x6b\xa6\x63\x7f\x74\x77\x10\x3e\x6e\x30\xe2\x00\x6b\x11\xd7\x77\xe3\x4f\xcc\x86\x4e\xf8\x71\x27\x65\xa1\xe7\xed\x3a\x93\xd5\x9a\x4e\xfa\xcb\x67\xfa\x0b\x7b\xb4\x26\x27\x02\x7f\x1a\xb8\x57\x05\xf9\xac\x31\x0b\x98\x1c\xa3\xdf\x2f\x25\xf6\x81\x1b\x1b\xce\x9e\x47\x20\x50\x6c\xde\x8f\x40\xef\x4c\x70\xa7\xb3\x22\x4b\xa9\xdf\x31\x9c\xd0\x36\xca\xf9\x18\x38\x28\xe5\x5c\x01\x56\xad\xb3\xe3\x8e\xeb\xa7\x31\x08\xa5\x23\xb7\xbc\x16\x30\xc4\x56\xda\xf4\x10\xf3\x2e\xca\x34\x8a\x66\xbd\x34\xfd\x68\x76\xac\xc0\x86\xed\x84\x06\x69\xb9\xf9\xef\x7d\x5d\x9b\x45\xd7\x1e\x1e\x7c\x39\x76\x1f\x45\x75\x00\xfa\xef\xf1\x9a\xc6\x07\x69\x8f\xed\x36\x49\xf2\xaf\x76\xcc\x9f\x90\x26\xb7\xd5\x4d\x9f\xa4\xa0\x71\x64\x2c\xbf\x0d\x85\xfa\x8c\x0e\xfb\x72\x3c\x55\xae\x33\x99\x44\xe1\x98\xc5\xa4\x51\x60\x8c\x80\x44\xca\x71\xc9\x45\x5d\x59\x32\xe4\xb4\xcb\xcb\x20\xe5\x84\xf3\x03\xe1\xa2\x66\x01\x06\x44\x76\xcd\x07\x4f\xea\x31\x74\xe0\x7c\x01\x14\xdb\x6b\xc1\x28\x52\xab\xeb\x6a\xb9\xcd\x26\x11\xee\xb5\xf1\x4e\xf7\xe1\x64\x7b\xc6\x09\x55\x6d\x38\xdf\xe9\xec\xc5\x66\xeb\x70\xff\x25\x44\x1c\x02\xa2\x5a\xf9\x07\x9c\x47\x6e\xe4\x05\x37\x5e\xb0\x8c\x3b\x75\xf6\x02\x32\x63\x6b\xfb\xaa\xd3\x31\x2b\x35\x62\xcf\x78\xad\x57\xdc\xa4\xd0\x05\xdb\xa9\x3b\x4a\xe3\xfa\xfd\xe4\xae\x53\x67\xb3\xed\xee\x08\x74\x41\x04\x39\xa4\x6c\xd4\x18\x32\xfd\xea\x20\xbd\x1f\x6b\xf2\xf7\x0a\x35\x6f\xd4\x18\x16\xbb\x8f\x4e\x66\xde\x7b\x2a\x94\xaf\xee\xa1\x9c\xea\x84\xac\x2d\xb4\xb4\xf8\x18\x3e\x6f\x44\xd9\xf0\xb4\xf6\x4a\x28\xb1\xe6\x61\xc6\x31\x23\x60\x97\xf1\xec\x20\xfe\xeb\xd6\x4a\x86\x97\xd2\x4a\x24\x2b\xaf\x22\x99\xf0\x92\xb4\x7b\x21\x7a\x3b\x42\x0a\x1b\xfc\xc9\xf4\x14\xf5\x3e\xdb\xc7\xdd\x9b\x28\x2d\x39\x84\x2d\xbd\x71\x57\x72\x94\x86\x1c\x36\x58\xc5\x0d\xae\x6b\xc0\xe6\xe0\x4a\xf4\x76\xa3\x5b\x97\xbb\x1b\xba\xc9\xbe\x8b\x5a\x7d\x7f\xd3\x7d\xcb\x9a\x79\x5a\xb9\x0d\x80\xf0\xe3\xbd\xf0\x0b\x6c\x83\x68\x1c\xc1\x0d\x87\xd8\xd4\x61\x38\x99\x89\x4e\xa4\xd8\x97\x5f\x6c\x1b\x41\x32\xd1\x2b\x7d\x49\x18\x58\x68\xea\xa9\xca\x89\xda\x06\x83\x82\xc1\x04\xa9\x1c\xef\x55\x2d\x29\x6b\x96\x4b\xcb\xe0\xda\x08\xb7\x24\xd4\xb2\xfe\x90\x5c\x17\x94\x18\x04\x84\x77\x25\x92\x00\x5c\x28\x92\xa2\x6e\xbe\xed\xfc\x69\xee\x01\x79\xbd\xc9\xee\x03\x87\x28\x43\xa8\x04\x79\x61\xb9\xab\x6a\xdf\xc5\x92\x39\x5d\x02\xb3\x52\xb0\xa6\x40\x9f\x52\xcd\xf6\xe8\x06\x0d\x13\xee\xa1\x70\xae\x7f\x99\xbc\xe7\x3f\x45\xe8\xcb\x2b\x10\xf3\xaf\xd4\x14\xe2\xd0\xc8\xe0\x3e\x78\x62\xba\x19\xf5\x23\xce\x1a\xf4\xf9\x76\x92\x62\xc0\x4f\x31\x5d\x31\x24\x6b\x26\x17\xe2\x67\xaf\x8e\x32\x7e\x2f\x94\x7d\x63\x95\x5b\x4c\x62\x1a\xdf\xb4\xa0\xf7\x4d\x2f\x0d\xf4\x21\xb1\x9d\x5b\xcd\xd4\x72\x8b\x00\x23\x28\x4d\x03\xd5\xc9\x70\xfb\x79\x2f\xca\x3d\x9d\x75\x78\x58\x69\x27\x3b\x5e\x83\x0b\x29\x6e\x2d\xba\xed\x46\x0e\x41\xd7\x4a\x4c\x25\x64\x48\x2d\x29\x3a\x21\xf4\x33\x36\x3e\x65\x16\x10\x39\x73\xa9\x81\xa8\x54\xdb\x33\xbe\xa6\xb9\x0f\xd7\x9c\x89\x5a\x5f\x87\xe1\x6f\x71\xa8\xd5\x6a\xd7\xa5\xf0\x56\x23\xe7\xf8\x14\xa7\x11\x49\x88\xf9\x36\xf8\x1d\x41\xe5\x9b\xa2\x78\xac\x0a\x35\x5c\x67\xb9\x5e\xbf\x6c\xeb\x62\xe4\x62\xaf\x18\x7f\x70\xec\x73\x00\x11\x9e\x10\x80\x7c\x0a\x00\x4f\xe0\x2a\xee\x3a\x41\xae\x3f\x06\x5d\x76\x10\x53\xb2\x51\x98\xf5\x08\x47\x87\xd5\x8d\x19\x52\x0a\xd2\xf8\x14\x04\x77\x10\x1a\x30\x16\x33\x75\xdc\x3d\x5a\xb0\x5c\x3a\x84\x1d\xe1\xc0\xd4\xe1\x2d\x87\x32\xbf\x50\x57\xaa\xda\x11\xaf\xc2\x9f\x54\x68\x6b\x47\xb0\x03\xd2\xdf\xf9\x33\x10\x00\x36\x3d\x29\xe0\x8b\xdb\x18\x5a\x38\x3a\x46\x58\x02\x76\x3e\x3e\x1b\x98\x4d\xc2\x6f\x5e\x6d\x76\xe0\xc0\x27\x20\x9e\x79\x87\x23\x37\xcc\x08\x36\x8b\x41\xb0\xeb\x25\x28\xc3\x44\x88\x00\x0f\x01\x98\x18\x2e\xcf\x92\xc7\x88\xc0\x42\xc3\xa8\x3a\x04\xdb\xe7\x45\xc5\xc4\xb9\x1e\x9c\x64\x5e\x29\x40\xc0\xf6\xc0\x16\x02\xf3\xc8\xaf\x18\x4e\xc7\xd8\x44\x5f\xf8\xc3\xd3\x3f\x0b\xea\x21\x2e\x3b\x08\x5f\xd2\xf1\xca\xd9\x98\x11\x5f\x34\x38\x67\x21\x56\x28\x1a\x57\x72\xbc\xf6\xc4\x83\xb0\x3e\x21\x7a\x5f\x79\xe0\x06\xdd\xda\x72\x63\xfa\x12\xd3\x5e\xad\xae\xdf\x7c\xa5\xdd\x25\xae\x65\x7f\xf3\xc3\xb0\xdb\x66\x40\xaa\x58\xa1\x0e\x4c\xac\x9d\x03\x77\xb7\x53\x76\xb3\x55\x0d\xc9\xd4\x4f\xcd\x4d\xb7\x36\xc1\xdd\x5d\xc4\xdd\xc4\xfd\xfb\xbe\x12\xef\xe0\x0a\x0c\x9c\xe9\xe3\xf3\xe7\x70\x24\xf4\x8a\xc7\xcc\x5f\x47\x1b\x65\xbd\xbe\x19\xd2\x45\x32\xab\xe1\x2b\xc7\xe6\x73\x44\x9b\x3e\x64\x63\x4a\x9e\x58\xf8\xaf\x2c\x4a\x01\x03\x2e\x60\x02\x39\x77\x23\x93\xbb\x72\x8e\x97\xec\x36\xa7\xa4\x5b\xb2\xd5\xc7\xa4\xdf\xde\xa7\xab\x4f\xc8\x0d\xe7\x2e\x3c\x2f\x37\x99\x53\x17\xf4\xb2\x7e\xa2\xe7\x99\x13\x61\xcd\x5c\x23\xa0\x0f\xfa\x65\x40\x42\x3a\x25\x2b\x42\xd8\xf1\x3a\x22\x98\x89\xa7\x00\x4c\xa7\x0a\xba\xe8\xe4\x00\xcc\xa0\xae\x8c\x78\x25\xeb\x82\x57\x0d\x0d\x78\x9d\x22\x4f\xed\x72\x43\xca\xba\xa0\xa6\x45\x1d\x5e\x2d\x2d\xaf\x25\x42\x77\x64\x36\xd5\xdd\x35\x9e\xe5\x1b\x2e\xc4\xba\xbd\x7c\xf3\x7c\xaf\x3b\xe2\x36\x5a\xc2\xcc\xb6\xc8\x6e\xd8\x18\x02\xc6\x49\x29\x4c\x2e\x3d\x13\x41\x5c\x0c\x30\xf4\x94\x18\x02\xa1\xfb\x19\xc8\x22\x10\x55\x49\x19\x05\x30\x5b\xf5\xb9\x2c\x61\x63\xe9\x45\x3b\x0c\x8f\xa6\x44\xfd\xe1\x79\xd8\xcd\x94\x61\xc9\x91\x47\x9b\x2b\x13\xda\xc1\x79\xf8\x41\xb9\x34\x3f\x46\x97\x68\x83\x79\x28\xad\x84\xe2\xc7\x57\xeb\x6b\x77\xaf\xe1\xd2\xe6\x8f\x75\xd3\xa8\x71\x8b\xce\x2e\xd7\xc8\x3f\xd6\x92\xad\x23\xb5\x1b\x47\x7e\xf3\xb8\x6f\x18\x75\x48\xd5\x5f\xa9\xae\xac\x62\xe8\x1b\x68\x2c\x9e\x0e\x32\x6d\x39\x87\x58\x76\x39\x62\xf4\xb2\x95\x0c\x3a\x20\x1a\x7f\xe8\xdf\x96\x03\xb3\xd1\x3e\xfa\x32\xcb\x86\x6f\xc3\x88\xd7\x72\x00\x91\x74\x34\x79\x99\xe5\xc8\x2b\x36\xf4\x0a\x2e\xb1\x9a\x2f\x87\x9c\x39\x10\x9a\xbe\x6c\x46\x19\x6b\x15\x22\xaa\x73\x33\x9d\x28\x6d\x75\x35\x61\x7b\x0d\x21\xf2\xda\x1f\x8d\xb2\xa6\x38\xa2\x8f\xd0\x16\x67\x39\x53\x93\x2a\x53\x65\x4b\xe7\xb9\x95\xd9\x1b\x85\x1a\x55\x64\x8e\xc3\x9a\x62\xa5\x69\xa5\x36\x7a\x93\x61\x6e\x63\xa3\xd9\xad\xf5\x20\x67\x34\xdf\x54\x03\xe0\x6b\xc5\x4d\x35\xa0\xac\xfa\x23\x12\xdd\x47\x36\xea\xeb\x95\x1f\xf1\x15\x9a\x8f\x88\xd5\x1e\x1e\xff\xae\xf3\x53\x48\x75\x99\xbc\xfb\xc1\x4f\xd5\x69\x7e\x06\x93\xa1\x70\xb6\x08\x5a\xc8\xf5\x0a\x82\x5b\xbe\xaf\x55\x6f\x5c\x05\x3f\x83\x66\x43\xc8\x38\xad\xda\xe1\xdc\x1b\x2d\x60\x6f\x06\xdb\x6f\x90\x1c\x6b\xa3\x64\xab\xdb\x13\xf3\x7a\x2a\x5d\x0e\x28\x30\x94\x43\x72\x77\x6f\x3d\x27\x44\x03\x76\xa7\x85\xa8\x93\x6d\x70\x09\xb2\x05\xef\xd1\xae\xbc\x37\x14\x7f\xd4\xd7\xf6\xfb\x01\x57\x46\x86\xaf\x0c\x76\xf6\xb5\x42\x1f\xaa\xa8\x02\x26\xc9\xcd\x2c\x7a\xeb\x75\xa8\xaf\x52\x9d\xd6\x18\x04\x7f\xca\xfd\x5c\x64\xa9\x04\x60\x3c\x88\x46\xf5\xa0\x78\x64\x2e\x34\x0c\x29\xe7\x88\x9e\xd6\x28\xce\x42\x91\xa0\xd0\x06\x17\x76\x37\x83\x47\x3a\x1d\xe0\x15\x83\xe1\x61\x13\x84\x5a\x62\x77\xea\x30\x24\xd2\x55\xf8\x70\x1b\xc4\x58\xfa\xc9\x5c\x7f\x6e\xaf\x64\xea\xab\xdb\xc8\xcf\xf8\x1a\xa3\x63\x12\x5f\x14\x74\x88\x67\xaf\x63\x4d\x8e\x43\x4b\x99\x7c\xee\xdf\x0f\xe6\x7b\xcf\x9f\x93\x9c\xf5\x8e\xbd\x43\xa6\xb2\xbe\x50\x45\x1f\x11\xf2\x37\x99\xad\xdb\x45\xa4\xa6\xa7\x80\x87\xbf\xbf\x96\x3e\x1a\xb5\x04\x48\x66\x9e\x4d\xc7\x67\x9d\xeb\x8f\x8b\x54\xf5\x75\xa1\xb8\x10\xa5\x1f\xeb\x28\x0b\x03\x27\x73\x8f\xdf\xbe\x19\x8d\x0f\xde\xa0\xd8\x0d\x62\xe3\x30\xf1\xaa\x5f\xe9\x9f\xbd\x3e\xe8\x34\x59\x02\x3b\x49\x8c\x0d\x1b\x1d\xa8\xb4\x9d\xbd\x8b\x42\x5a\x2a\x83\xe1\xb7\xa9\xd1\x58\x64\xae\x30\x53\x65\x25\x76\x52\x8c\x03\x30\x7e\xd9\x20\xe8\xe0\xa6\x27\x6c\x37\xc9\xc7\xb8\x8e\x7f\xde\xb8\x04\xb7\xf3\x27\x48\xe3\x7e\x57\xb9\x0a\xdc\x2e\xc8\x37\xe7\x32\x10\x2f\xc9\x4f\xa6\xb4\xcd\xe9\xe1\x4b\x8e\x97\xfc\xf7\x06\xfc\xc7\x6c\xc0\x68\xba\xf3\xe1\x27\x2e\xf2\x93\xc4\xcb\x60\xc6\x21\x1f\x82\x0f\x25\xf0\x95\xc5\xf2\xe5\x08\x4f\xc3\x56\x8b\xb2\x2e\xca\xb1\xb3\x86\x81\x35\x0b\x32\x44\x3a\x78\x2f\xbe\xed\xb1\xff\x85\x48\x44\x39\xe1\xed\x55\x04\x43\x1a\x22\x15\xe5\x4a\x67\x42\xa6\x7f\x4e\x6b\x10\xd4\xb6\x32\x84\x27\xd2\xd4\x86\xf9\x0b\xf1\xd0\x2e\x72\x83\x51\x64\x13\x8b\xc8\xca\x70\xf6\x10\xbb\xf1\xef\x2b\x1c\x19\x77\x32\xcf\x5c\xd2\xdf\x8c\x4f\xe9\xce\x8a\xe7\xf8\x4d\xd7\x07\x64\x27\xf3\xcc\xc9\xb7\xab\x6e\xf7\xb0\x40\x46\x83\xdd\xc9\x3d\xa4\x34\xb5\xbb\x77\x38\xad\xdc\xe9\x72\x76\xae\x2b\x0c\xd9\x6a\xb5\x68\x25\x4a\x85\x66\xae\xc6\xa5\xac\x28\xe8\xc4\x6e\x6e\x33\x0c\xaf\xbf\x44\xad\x45\x2d\xdb\xf2\x8a\x6b\xb0\xf5\xd5\xba\x11\x73\x5d\x2d\x27\x65\x55\x91\x46\xc8\x11\xa9\xf5\x62\x46\x00\xec\xd0\xd2\xc4\x96\x54\xcd\x44\x37\x33\xf4\x8d\x01\xc4\x2e\x48\x4e\xfb\xea\xe4\xf5\xd9\xb3\x17\x1f\xce\xfe\xfc\xea\xd0\xc7\xa3\x50\x2f\xbb\x92\x37\xbe\x78\xd7\x9b\xe8\xa6\xf7\xbe\xf3\xa0\xdf\x03\x87\xe1\x21\x26\xd4\xee\x81\x53\xd6\xc3\x4f\x4a\x8e\xe5\x6e\x27\x85\x1d\xa2\x8e\x7d\xf3\xa8\xcf\x29\xc4\x07\x69\x4a\x69\x27\xcf\x4e\xca\x8b\x45\xa3\x2c\x77\x84\xb9\x7a\xf6\xea\x08\x63\x68\x1b\x6d\xcc\x36\xa7\xef\x4c\xb2\x7a\x0f\xef\xc4\xbf\x3d\xdc\xe7\xa5\x5a\x8a\x3d\x07\x2c\x68\x08\x1f\x53\xfc\x41\x3c\xb1\xe3\x71\xcf\xdf\x3d\x79\x1f\xc3\x49\x88\xa7\xf1\xcb\x20\x73\x53\x44\xc7\xac\x6e\xdb\xa5\x05\xe4\x04\xb1\x00\x77\xed\x45\x5d\xfe\xb8\xb0\x1a\x2d\x84\xd4\x97\x93\x25\xe1\xd2\x1b\x87\x15\x87\x53\x02\x95\x7c\xf3\x0d\xae\xc4\x4e\x77\x95\x90\x00\x2f\xd5\x72\x07\x87\x42\x32\xa6\x03\xdf\xe9\xf5\xc4\x03\xfb\x86\x76\x8a\x4b\xc6\xed\xe6\x99\x77\xd0\x0d\xd9\xbc\xd3\x2c\xe9\xb9\xf4\xe8\x84\xfd\x76\xa1\xda\x7d\x3c\x1b\xe0\x8a\xfb\xb4\x95\xe3\xcb\x67\x45\xa1\xea\x62\x31\xfb\xe6\x91\xd8\x23\xc4\x39\x75\xbe\xb8\x08\xcb\x0d\xd7\x7d\xb7\x7b\x27\x8f\x72\x79\x2c\x81\x4f\x79\x9b\xf2\x77\xdf\xd9\xee\x7e\xe7\x72\x67\x71\xa2\xa5\x5a\xc3\xfc\xa8\x4f\xf3\xaa\x1c\x97\x6d\xb5\x84\x28\x0f\x5d\x8b\x62\x59\xcb\x59\x39\x16\xb2\x69\xe4\x12\x40\xfe\x5c\x16\x7b\x00\x62\x14\xdf\x71\x14\xc8\xa5\x5a\x26\xa9\x3f\xc9\x48\x01\xeb\x6a\x68\x61\x2f\x95\x9a\x8b\xb6\x91\xe3\xcb\xa8\xae\x73\xd5\x5e\x2b\xe4\xca\xdf\xb9\x0c\xa0\xf0\x6b\x44\xc3\xd2\xd7\xb5\x6a\xfe\x28\xcd\x9f\xd4\xf2\x8d\x51\x6f\xd1\xbf\x90\xa0\x3a\xe3\x12\xcf\x69\xef\x9c\x2d\xe7\x49\xb9\x00\xd2\xf3\xb9\x6e\x8e\x4b\x00\xc9\xfd\x13\x90\x78\x00\xe7\x69\xfb\x14\x62\xeb\xc0\x83\x2c\x70\x27\xbc\xb8\x1b\xc5\x96\xc4\xa8\x21\x69\xb8\xcb\x5d\xf8\x64\xf8\xc1\xb4\xba\x01\xef\xb3\xf0\xf7\xd0\xe7\x4b\x75\x6f\xec\xa2\xdc\x4d\xd5\xc8\x6e\xdd\x2e\x1c\x26\xaa\xff\xe6\xa8\x17\xdc\x4a\x41\x40\x6b\x9d\x99\x1c\x12\x1d\x30\xdd\xa0\xa0\xbe\xfe\x32\xf6\xa7\x15\xd3\xc1\x0e\x95\xa9\x7f\xa1\xeb\x38\xe4\x35\xb6\xbb\x51\xec\x89\xde\xa1\x1c\x4f\x69\x6d\x4a\x80\xe0\x00\xda\x15\xb6\xa3\xad\x6a\x64\xab\x9b\x64\x48\xc8\x6c\x30\xc2\xef\xde\xa5\x5a\xa2\xfd\x65\x28\x4e\x95\x12\xb9\xec\xd5\xe4\xdc\xba\x0d\x14\x3f\xe1\x30\x49\x80\x22\x2e\x6b\x38\x36\x80\xa9\xda\xa7\xfd\xf5\xbb\xbd\x8f\xae\xb8\xac\x2c\x80\xa8\x99\xa3\xf3\x77\x2b\x07\xfc\x7e\x1d\x59\xdc\xb6\xae\x78\xa2\x53\x1f\xde\x7f\x96\x79\x05\x24\xe1\x9b\xe6\x95\xf1\x6b\x89\xe9\x52\xc0\x1b\xf0\xd7\x14\x1e\xd8\xbe\x3f\x3a\x3b\x7c\xfd\xec\xec\xe4\xf5\x87\xd3\x3f\x1f\xff\x70\xf2\x62\xe3\xc3\x7d\xc8\x43\x47\x0c\xe2\xe7\xcf\xde\xfc\xaf\x0f\xdd\xba\x7a\xff\xfe\xef\x5c\xae\xb7\x6b\xcf\xbc\x1f\xf0\x6e\x98\x2a\xb7\xf2\xcc\xf0\x26\xa1\x07\xf6\xd1\x21\x1e\x2a\xdb\x76\xbb\xfd\x43\x05\x9f\xc3\x17\x87\xc7\x87\x2f\xcf\xe0\x4c\xdd\x0d\x9e\xef\x3f\x7b\xf1\xa2\xf3\xf0\xf5\xe1\xd9\x9b\xd7\x2f\x3b\x8f\x9f\xbf\x7e\xf6\x1f\x41\x25\x81\x62\xb6\x99\x04\x85\x94\xde\xed\x8f\xd8\xcb\x0b\x56\x0a\x27\x0b\x37\x57\xd2\xdd\x55\xdf\x58\xdd\x31\xfc\x20\x18\xca\xaa\x4f\x70\xdb\x85\x1f\x45\x03\x5d\xf5\xd9\xa4\x91\x17\xdc\xbd\x40\x93\xce\x0e\x0f\xc4\xc2\xdf\xe4\x87\x01\xef\x7e\xbb\xaa\xc7\xf0\xf6\x77\xab\xbb\x06\xef\xcf\x3b\x79\xdd\x8e\x88\x5a\x9f\xd7\xfd\x99\x5c\x9e\x2b\xf8\x7d\x5e\x05\x09\xc8\xa2\xc7\xb9\xc3\xb1\x5b\x20\x83\xfc\x40\xb2\x60\x98\x07\x14\x76\xab\x6b\x5e\xec\x75\xb6\xe6\xfd\xfb\x71\xdd\xef\x92\x02\xef\x6d\x27\xe2\x12\xb9\x6d\x09\xd8\xed\xa1\x71\x20\x68\x33\x6b\x0b\xe0\xb0\x27\x57\x6e\x37\x4e\x9b\x87\x83\x88\x31\xf5\x55\x33\x56\xaf\xd5\xc4\x9b\x76\x89\x26\xbd\x80\x3d\x2b\x3f\xa9\xe2\xb5\x9a\x88\x3d\x7e\x37\x6c\xd4\x84\xfb\xe6\xde\x86\xd6\x51\x9e\xe0\xf0\x5d\xb7\xbb\xe0\xfa\x4c\x35\x7e\x80\x83\x20\x86\xaf\x84\x47\x41\xab\x58\x26\x0c\xbc\xb6\x0a\x6b\x62\xf1\x0e\x8e\xa8\xad\x24\x06\x05\x1e\x72\x26\xe1\xa8\x2e\x2b\x9e\xf8\xb7\x90\xee\x70\xaf\x93\x0e\x31\x2f\x9f\x80\xfa\x0c\xb1\x73\x61\xa2\x02\xfc\xc2\x88\xb1\xac\x5d\xae\xa3\x46\x4d\x4c\x57\x9e\x60\xbd\x9b\xbb\x84\x3d\x48\xae\x3a\xbd\x71\x05\x22\xca\xb3\x1d\x21\x71\x88\x66\xcd\x32\x4a\xd3\x52\x8e\xf7\x09\xa0\xd9\xfc\x2c\xe2\xd0\xc0\x2d\x6a\x77\x20\x18\xc5\x60\xdb\x44\x6a\x01\xcd\x85\x8b\x07\x6e\xd8\xfb\x53\x35\xbe\xb4\xcb\x34\xf7\x17\x1b\xae\xa7\x33\xd9\x8e\xa7\xca\xc0\xdd\xa8\x7f\x1c\x2c\xed\xba\xbc\x82\x4d\x42\x87\xc1\x73\x2b\xb2\xb9\xae\xed\xed\xf9\x8e\x86\x54\x42\xfb\x24\xf8\x2c\x07\x72\xd2\xc0\xe8\xbc\x38\x0e\x60\x35\x29\xb1\x51\xe8\x80\x5d\x2e\x0a\x23\xd8\x8b\x02\x09\x60\x0d\xdd\x3b\xf1\xf7\x2f\x62\xc7\x3f\x88\xc3\x9d\xa0\xfe\x6c\x66\x14\x21\x0a\x55\xa9\x16\x69\xeb\x9d\x1b\xd2\xfb\xc0\x28\xd7\x45\x6b\x4b\xca\xda\xfd\x63\x1b\xc8\x18\xf2\x76\x9d\xd8\x16\x4f\x9f\x9f\xbc\xdd\xd8\xd8\xee\x26\x2c\x69\xd6\x09\xff\x9e\x97\x58\x8e\x80\xd5\xac\x10\xfc\x5d\x42\x01\x3b\xdd\x9c\x2e\xc0\xe7\xee\x6b\x00\x9f\x00\x52\xc5\x65\xf6\xd4\xdd\x98\x67\xe4\x1b\xc0\x22\x50\x3f\xa4\x2c\x9e\xab\x71\x39\x29\x19\xbd\x88\x88\xaf\xff\xad\xd9\x82\xb8\xd6\x5a\xd3\xd6\x82\xb2\xaa\x1d\x8a\x3f\x87\xd8\x74\x2b\xb1\xe6\x2b\x2d\x0b\x55\x0c\x45\xbf\x50\xad\x2c\x2b\xb3\x93\x15\x2c\xed\xa2\x6c\xcf\x16\xa6\xdd\xb6\xb5\x6d\x23\xff\x5a\xb7\xdd\xbe\xc4\xac\xdd\x6f\xb3\x90\xbd\x43\x86\x00\x87\xcf\x8b\x84\x67\x75\xce\x3e\x7e\x45\xe0\xec\xb5\xba\xde\xf7\x1a\x25\x26\x4d\x73\xaf\x39\xe8\x64\x4f\xf4\x5a\xf5\xa9\x95\x8d\x92\x51\x2e\x53\x49\x12\x2d\xec\xf7\x38\xee\x3c\x7c\xd5\x41\x71\xa1\xbb\x69\x29\xc6\xba\xaa\x94\x4b\xc8\xe8\xad\x47\x0b\xa3\xbc\x04\xef\x50\x01\x21\x20\xee\xd6\x5a\x0b\xa9\xb7\x1d\x12\xc0\x19\x49\x6c\x02\xa1\x09\x07\x75\x89\x3e\x80\x16\xee\x88\x6f\xcd\x16\x8a\xf6\x04\xa4\xef\x43\x68\x5a\x7d\x8a\xb4\x08\xb9\x41\xfc\x84\x02\x99\xbf\x23\xf3\x03\x7e\xf5\xbe\x27\x9e\xb2\xce\x8b\xfe\x9c\xa0\x4c\xfc\xdd\x8e\x8a\xea\xb5\x0f\x7c\x25\xc3\xbf\xea\xb2\xee\xf7\x06\xa2\xb7\x65\x67\xe1\x4b\x4f\xec\xb8\x25\x1b\xb8\x49\xf6\x89\x48\xdc\xea\x23\x38\x73\x68\x6b\xe8\x07\x59\x72\xd6\xe9\xa7\xcf\x5d\x1e\xee\xf5\x33\x43\x87\x0a\x6e\x82\xf9\x5c\x81\xc1\x06\xd6\xca\xae\xb5\x43\xf3\x0a\xb5\x77\x87\xc8\xfa\x7b\xff\x74\xf4\x07\xf4\x61\x21\xd7\x22\xac\xe1\xa4\x41\x11\x29\x26\x1b\x3b\xbf\x94\x09\xd4\xc5\x6d\x48\x48\xe1\x09\x29\x76\x9c\x04\x74\x4b\x22\xb9\x13\x6b\xb6\x19\xfb\xcc\x06\xfa\x6d\x9c\x32\xe8\xeb\xea\x0a\xf5\xdb\x54\xbb\xfd\x2f\xb0\x2a\x1b\x29\xc6\x6e\x55\xbe\x90\xc6\x59\x1a\x71\xdd\xd8\x91\xf8\xdc\xf8\x78\xb1\x62\x1c\xb4\xdc\x91\x40\x1c\x39\xe8\x4d\xa5\x6b\x45\x48\xa6\x05\x80\x50\x29\x39\x9e\x8a\xb9\x6c\xa7\xb6\x3e\x3a\x4b\xac\xcc\xdf\x6a\xc8\x52\x33\x2b\xff\xa6\x7c\x19\xb8\x4f\xba\x2a\x0b\x44\x39\x38\x5f\x8a\xf3\x46\xd6\xe3\x29\x24\x75\x94\x4d\xb5\xa4\xe9\x05\xf0\x02\x5b\x1f\x46\xf5\x96\x95\x6a\xec\xa9\x44\x78\x0b\x85\x16\x65\x2b\x66\xb2\x86\x5a\x86\xe2\x8f\xaa\x9a\xab\x86\x10\x87\x30\x47\x14\x66\x38\xb6\x55\xb9\x06\x6c\x75\x95\xd5\x8d\xf5\xa2\x85\x88\x61\xc8\x55\x18\x4c\xeb\xd0\xef\x6e\xd8\xff\xaf\xd5\x58\xd7\x63\xdb\x36\x5d\x2d\xef\xdb\xb1\x0f\xc8\xca\x71\xd6\xc8\xf1\xe5\x69\x59\xa8\x43\x84\xc5\x42\x42\x75\x35\xa0\xec\x00\xf5\xc4\x07\x02\x50\xd1\x99\x3e\x80\xf7\xa1\xb4\x7e\x77\x5d\xbd\x82\x7d\x9c\xf4\x7c\xb8\xde\xc4\x18\x74\x35\xfa\xf4\x2d\x39\xc1\x35\x56\xa0\xc1\x81\xe1\xd5\x99\x80\xf0\x63\x0c\xde\xbb\xe2\x64\xd0\xe1\x95\x2d\x64\x4a\x19\x8a\xb7\xc1\x6d\xa1\x1c\xb7\xb8\x82\xd7\x40\xa4\x41\x6a\x68\x2c\x9b\x18\x25\xc2\x97\xce\x1d\xcf\xd7\x16\x2e\x99\x26\xeb\x30\xcc\x9f\x9d\xc8\x10\x7a\x2c\xbc\xd4\x8d\xe6\xd1\x07\x16\x67\x45\xb9\x70\xaa\xbc\x08\x16\xd5\x00\x8e\x0a\xd9\x1a\xc3\x19\x1e\x8d\xc4\x01\x75\x0c\x19\x85\x3d\x21\x0a\x84\x62\xbb\x52\x8d\x95\xf6\x11\x0e\x08\xc1\x41\x64\x51\x58\x4a\x65\xfc\x99\x46\xd7\xad\xc3\xfe\x78\x46\xb7\xa9\x70\x2d\x39\x08\x10\x7b\x11\xa7\xa6\x67\xf8\x0a\x1c\x72\xa2\x71\x42\x3a\x4a\x30\x44\x69\x90\x70\xf6\xb8\x43\x83\x00\x92\xe4\xaf\x0b\xd3\xba\x9c\xfa\x53\xe5\xa7\x93\xfa\x02\x09\x3a\xc1\xde\xe4\xb2\xaa\x72\x7d\x0c\xf3\xc6\xbe\x94\x30\x42\xcc\x68\x8c\xdb\x1e\x7d\x20\xc5\x7c\x2a\x8d\x1a\x8a\x93\x1a\x89\xc7\x5d\x79\x44\x97\x82\x65\x7d\x31\xc0\x71\x5a\x8e\x49\x18\x8c\x96\x09\x7b\xef\x2a\x4a\xe0\x19\x8a\x45\xf6\x11\x92\xbf\x37\x8c\x42\xb1\xae\x4f\x95\x7d\x0c\x79\x05\xb1\x7c\xba\x8c\xb1\x0c\x9d\xd6\x9e\x2f\x9d\xc8\xd7\xe1\xa7\x90\x53\xd0\x7d\x7b\xab\x4a\xef\x74\x48\x2e\xee\xb6\xcf\xd6\x16\x17\xf2\x6e\x01\x7b\x8e\xf6\xba\x98\x2b\xc8\x6e\x5e\xf3\x5a\xee\x93\xa4\x97\xb0\x1e\x3e\x18\x1a\xd3\xee\xa7\xd7\x1c\x5f\xc7\x7e\x82\x6e\x07\x99\x69\xe1\x26\xf2\xb9\x46\x07\xca\x80\x21\x89\xb1\x34\x6a\xc0\x31\x31\xe4\x61\x3b\x2b\xc7\x8d\xde\xe6\xa3\xa2\xb0\xba\x72\xd9\x86\x59\x66\x0d\xd2\x11\xb2\x77\x1f\x86\x83\xf9\x1d\x51\x88\xbc\x56\xbd\x2b\x9f\x3d\x1d\x49\xd6\x6e\xc8\x65\x3b\x75\xf9\x11\x41\x30\x4b\xb7\x7c\x3a\x23\x04\x3b\x85\x39\x9e\xe3\xd2\x5d\xda\xdb\x90\xc7\xef\x6e\xc4\x6f\x4c\x79\x6e\x19\x72\x48\x2d\x1d\xf3\x58\x04\xd3\x20\xe7\x5f\xbb\xdc\x96\xfb\x14\x45\x92\x53\xd9\xdd\xc5\xb5\x5a\x48\xd1\xaa\xd9\x5c\x37\xb2\x59\xda\x76\x9c\x9b\x0d\x31\x97\x49\x89\x5c\x65\x16\xac\x12\xc8\xd9\x3f\x2e\xca\xf1\xa5\x3d\x91\x8f\x66\x78\x91\x28\xfa\x38\x63\xf0\xf6\x42\x31\x37\x21\x88\x1b\xb8\x64\xa4\xac\xe3\xaa\x6c\xac\x6c\xa0\x3e\xb9\xb5\x62\xef\x0e\x1e\x1c\xa1\x3b\x1d\xcb\x79\x3f\x74\x39\x8f\x8a\xdd\xb8\xa4\x71\xe9\xee\x92\x82\xd9\x2c\x2c\x43\x57\x70\xdd\x33\x25\xed\xde\xd0\xa8\xb6\xfb\xe9\x20\x2e\xe7\xbd\xb6\x52\xd3\xc1\x06\xd5\xc1\xf4\xac\xac\xf0\x4e\xa6\x1e\xb1\x17\xff\x5e\x43\x64\x69\xfb\x5d\x82\x5b\x18\x15\xe5\x49\x09\x1d\xf4\x3b\x29\x51\x3c\xa5\xbd\x75\xb2\x01\xdd\x2a\x53\x1f\x5c\x9a\x4f\x48\xbc\x66\x87\x66\x9f\x3c\x14\x20\x36\xb0\xe4\x59\xe2\xc9\x27\x8d\xa3\xb3\x56\x03\x52\x3d\x62\x10\x16\x9a\xc3\xec\x70\x14\x20\xd0\xb4\x43\x71\x38\xbc\x18\x82\x95\x0e\xf8\x4f\x59\x5f\x54\x8a\x18\x85\x65\x40\x1e\x23\x2b\x2b\x2b\x01\x9f\x00\x6e\xb5\x47\xee\x17\x6f\x23\xdf\xa4\x8d\xc6\xef\xf6\xbc\xad\x08\x57\x0e\x52\x8e\x46\x8f\x79\x26\xe2\xec\xd5\x6c\x27\xb3\x45\xb2\x07\x12\x4e\xaa\xbe\x52\x4d\x63\xc5\x58\xf4\x84\x8a\x12\xa2\xa3\xdb\x1c\x86\x97\xc0\xfc\x35\x55\xf9\xff\xb3\xf7\xee\x5d\x6e\xdc\x56\xbe\xe8\xff\xfa\x14\x90\xd7\x44\xdd\x7d\x42\xb1\x13\xdb\x99\x7b\xae\x3a\x6d\x2f\x59\x8f\x44\x77\x22\x59\x57\x92\xc7\xf7\xac\x4c\x96\x02\xb2\xc0\x66\x9d\x2e\x16\x98\x42\xb1\x29\x8e\xa5\x59\xf3\x21\xe6\x13\xce\x27\xb9\x0b\x7b\x6f\x00\x1b\x28\x54\xb1\xd8\x0f\x1f\xc7\xb1\xfe\xb0\x25\x16\xde\x8f\x8d\xfd\xfc\x6d\x3b\x64\xbf\xac\x8b\xd0\x54\x97\x25\xb4\x54\x56\x54\x00\xc7\x07\x8d\xc1\xd5\xc7\xec\x7f\xcc\x09\x4c\x1a\xce\xc0\x6d\xeb\x87\x14\xea\x63\x69\xb8\x7b\x23\x60\xa5\xba\xe9\xd8\xf3\x09\xe5\xa9\x30\x7b\xee\x5e\x69\xce\x04\xb8\x12\x9d\xc5\xc4\x9f\xf3\x8b\x89\xdf\xf8\x56\x89\x73\x91\x03\x4e\xe5\xbc\x57\x02\x96\xe0\x6f\x00\x30\xca\x48\xee\x6b\xb5\x25\x2a\x6b\x1f\xfe\xd7\xf6\x43\xf1\x02\xef\x67\xad\xb6\xf0\x37\x77\xa2\x5c\x51\x3f\x70\x57\xe0\xec\xa6\x6f\x6f\xd2\x75\x1a\xc3\x11\x50\x78\xfc\x10\x12\xa6\x36\xa7\xf2\x4d\xcc\x04\x15\xb6\x1d\x08\x2b\x4e\x23\xb2\x07\xb8\x32\xbf\x4f\x47\x94\xe4\xf2\x77\x18\xff\x52\xac\xf4\x15\xcb\xda\xef\x87\xc7\x37\x1f\x9a\xb1\xfc\xe4\x59\xaa\x41\xce\x4e\x3b\x43\x52\x7d\x8f\xad\x5a\x21\xd6\x63\x2b\x77\x5e\xe0\x99\xa6\xcd\xba\x69\xec\xf3\x72\xf5\xb3\xa8\x29\x8f\x14\x65\xfb\x1c\x3f\x93\x7d\xdb\x97\x39\x75\x6f\x81\x88\xc5\x67\xef\x24\x71\xa2\xb2\x0f\x2a\x70\xe1\xcd\x00\xed\x03\xd2\x51\x03\x14\x14\x3e\xc4\x85\x16\xd2\x35\xb3\x76\x23\x85\x06\x68\x76\xf5\x05\xa2\x2a\xba\x87\x29\xa1\x9e\xe9\xa1\x15\x0f\x1e\x64\xce\x5b\x46\x2c\x1b\xb3\x56\x31\x1f\x44\x15\x32\x4f\x13\x78\x0c\xbd\x53\x1f\xda\x57\xba\x50\x59\x2e\x68\x22\x08\xad\xb2\x45\x43\x5c\xf6\xb9\xe2\xf7\x81\xdb\x34\xdd\xd1\x6f\xe5\x05\xdc\x93\x3f\x6a\xd3\xbe\x8b\x70\x15\x21\xfc\xcf\x2e\x17\x7f\x44\x08\x9c\xd1\x3d\x23\x30\xa0\xe7\x8d\x5e\xd9\xaa\xc7\xd1\x70\xb8\x24\xd1\x45\xfc\xe9\x7f\x5d\xb0\x87\x3f\x1f\x91\x11\xfa\x2f\xb1\x50\x92\xbe\x28\x58\xba\xef\x4d\x89\x3c\xb0\x39\x67\x25\xce\xc3\xdb\x3f\x6a\x35\xcf\x12\x5e\x64\xe4\xf8\x5c\xf1\xbe\x8b\x80\xbb\x4c\x96\x85\x9e\x4d\x26\xd3\xc4\x98\x0d\xce\xd9\xb2\x30\x37\xd2\x79\x30\x8b\xda\x1f\xa2\x5d\x7e\xa9\xaf\x94\x98\x41\x1e\x06\x5d\x33\x8e\x75\xc4\x92\xb9\x36\xd7\x83\x1c\x83\x6b\x62\x8a\x96\xb0\x01\x23\xf2\xa1\xcb\xdc\x65\x36\xa7\xef\x0b\x35\xdb\x5c\xbc\xd5\x9b\x06\x62\x42\xbd\x61\xc7\xc0\x2f\x67\x7d\x15\xbe\x1d\x34\x1e\x7f\x1a\xdc\xd6\x6e\xd4\xc0\xe8\x7b\xe3\xb6\xde\x6f\xf2\xcd\xae\xcd\xf8\x15\xbe\xc9\x3d\xeb\x39\xc6\x4f\x64\x55\xf5\x9c\xe1\xb9\xac\xaa\x01\x86\x3a\xc2\xae\x40\xb7\xd8\xca\x68\xd0\xcb\xc8\x46\x89\xa5\xac\x8b\x0a\x01\xa9\x0b\xd5\xaa\x66\x55\xd6\x4a\x6c\x97\x0a\x35\xc6\x1a\x3d\xf6\xbf\x3e\x88\xdc\x3d\xe1\x41\x80\xd7\xa4\x79\x30\x5f\x9c\xd9\x4f\x81\xd8\xdd\xe0\x1a\x67\xb7\xe7\x4e\x49\x1e\x42\x70\xf5\x9c\x16\xfc\xd5\xbe\x7b\x37\x7d\xd5\xb0\x9b\x9b\x6e\x74\x34\x58\x1c\xd6\x0d\xaf\x29\x25\xac\x0b\x2d\x4e\x23\x9b\xfa\x4f\xe5\x5c\x00\x52\xd5\x5e\xaa\xbe\x67\x32\x77\x72\x7e\xd0\x57\xbe\xe7\xfc\x60\xfc\xc1\x6d\x70\x44\xd8\x0d\xff\xea\x3d\x6d\xa6\x91\xcf\x3c\xd4\xc0\x7e\x93\x0f\xd9\xba\xb1\x33\x3d\xaf\x9c\x0b\x5b\x38\xf8\xc0\xd2\xea\xb8\x75\xf8\x29\x50\xa7\xc3\x58\x31\xb7\x92\x4e\x4f\xf6\xf1\xa3\xf8\xf3\x5f\x7e\x5c\x0a\xf5\x9c\xbc\x19\x7b\xce\x98\x73\x76\x4c\x07\x35\x11\x97\x6a\x77\xe8\x51\x73\x7d\x5d\x73\xbb\xfd\x50\xc3\xa0\x0e\xdb\x72\x1c\xf4\x4f\x60\xdf\xfb\x56\xf5\xae\xb6\x9a\x72\xed\x75\xd5\xdd\xc1\x61\xa2\x9f\x88\x90\x8f\x92\x2b\x1a\xf9\x28\x31\xb7\xd1\xf8\x3b\x3a\x28\x1f\x45\x3b\x6d\x85\x27\x51\xeb\x42\x19\xb2\x1b\x82\xd5\xf2\x52\xed\xbc\x2f\x74\x70\x7d\xab\xc1\x44\x6d\xc0\x36\x45\x71\x2d\x97\x6a\xa7\x0a\xae\xfd\x02\xcd\x80\xa5\x42\x65\xbd\xa1\x54\xb5\x68\x10\x2d\x51\x37\xad\x37\xad\x90\x33\x8d\x82\x70\xac\x57\xab\x75\x0b\xaa\xf2\x0f\x6d\x68\xd0\x76\x39\x1d\x2d\x04\x82\x17\x5f\x58\xbe\xff\x03\xb4\xa7\x03\x32\x11\xef\x80\x4b\x1a\x83\x42\x7d\x9f\xd6\xdc\x6c\xcb\x76\xbe\x14\xde\xad\x66\xea\x42\xb2\xb8\x02\x68\x2e\x8d\xca\xf8\x37\x3f\xf2\x05\x44\xe4\x49\xe7\x01\x91\xb0\x45\x2f\x99\x65\x1c\x99\x4f\x92\x8a\xb8\xf2\xef\xf7\x93\x00\xdf\x3a\x02\x6e\x04\xff\xa8\x43\x29\x82\x6f\x88\x93\x06\xf7\xe7\xfd\xc8\xfd\x71\x7f\x68\x9f\xde\x47\x1b\xe5\xfe\x64\x7c\x0e\xd3\x09\x7f\xde\x2f\x39\xdd\xf8\xa8\xa5\x73\xfa\xbc\x23\x44\x21\x1b\xe4\x1d\xac\x7a\x2b\x5e\x73\x35\x3e\x4f\x96\xe3\x1e\xff\x7b\xee\xac\x79\x67\xf9\xfe\x83\xc6\x17\xef\x8b\x1e\xd1\xe5\x96\x56\xce\x77\x33\x6e\xfa\xc9\xe4\xbf\x38\xdb\x3b\x5d\xe6\xff\x3f\x6e\xc2\x5f\xf6\xb2\xf0\xb7\x3c\xe5\x2f\x1d\xef\xeb\x2f\x4b\xe2\x1a\x1b\x15\xbe\xd6\xfa\x7c\xb9\x7f\x7d\x58\x70\xe8\xb8\xf5\xf9\x5d\x2f\xc7\x78\xcb\xeb\xf3\xbb\x6b\x4d\xf9\x77\xf1\x94\x93\xa9\x43\x42\x09\x17\xfb\xc4\x5c\x27\x3f\x7e\x4c\xc2\x3c\xfc\xa7\xd4\xd5\xda\xf5\xf3\xcf\x23\xc8\xe8\x35\xe8\x66\x48\x6a\xc0\x97\xe2\x9f\xf7\x2f\x45\xb2\x0c\xff\x7c\x96\x4e\xfd\x40\xf7\xdc\xe8\x39\xcc\x60\x87\xc4\xcf\x62\x1e\x40\x23\xe3\x12\x9a\x18\x13\xa2\x30\xff\xbc\x5d\x1f\x19\xea\xb7\x95\x4e\x98\x69\x5d\x15\x23\xd9\xad\x18\x24\x01\xb3\x5e\x61\xac\x2f\xda\xe1\x21\x0a\x60\x22\x74\xbb\x54\xcd\xb6\x34\x8a\x8f\x67\x1a\x0c\xeb\x18\xfb\xed\xba\x0d\xea\xd2\xaf\xfd\x6f\x60\x1b\x7f\xc4\x53\x28\xfc\xa3\x72\x7a\x76\xde\x7d\x8e\x02\x1d\x47\x99\x8e\x86\x74\xc8\x7c\x11\xb6\x3d\xe1\x15\xb3\x34\xe5\xef\x86\x9d\xc3\x68\xfc\x73\x2e\xff\xf5\x94\x3c\x8c\xf1\x4b\xd6\x34\x2f\x97\x76\xaf\x52\x87\x01\x1c\x12\xf9\xdc\x9f\x4f\x79\x4e\x65\xc0\x4c\x31\xe2\x0e\x8f\xe2\xf6\x32\x47\xaa\x3b\xa4\x6b\xb3\x43\xe3\x37\x2a\x9a\x71\x57\xa3\xfd\x13\x98\xee\x28\x76\x08\x32\xb1\xb5\x00\xf7\x72\x53\x42\xe3\x1b\xbc\x39\xb9\x49\x5b\xdc\x95\xaa\x2a\xa6\x9d\x9d\x72\x1b\xd4\x0d\x5f\xea\xec\x50\x4e\x8f\xfc\x13\xd8\xa3\x51\x2c\xd9\x35\x0f\x65\x4e\xf5\xf9\x23\x4f\x39\x99\xfa\xcd\x58\xb2\xa1\x87\xa6\x67\x44\x6c\xd1\xaf\x45\x1b\xf7\x70\x6d\x3f\x13\x86\xcb\x32\xb4\x2f\xe5\xfa\x38\xf5\x83\x8b\x78\x5a\x74\xee\x29\x3e\xfc\x64\x54\x5e\xce\xe5\xbb\x56\x25\xd8\xf7\xe0\x03\x24\x03\x57\xf3\x4b\x20\x5c\x1a\x52\xdf\x37\x8c\x6d\x51\x5b\x24\x62\xce\x47\xe4\x52\xa1\xc3\xfe\x4c\xb7\x4b\xf0\x69\x6f\x7d\x77\x13\x44\x13\x07\x86\x91\x2b\xb5\x30\x8e\xb4\x70\xe1\xbe\x1d\xdf\xc5\x0b\x05\x42\xc1\x8b\xe2\xc3\x49\xc8\xb1\x95\x39\x82\x79\x96\x87\xb7\xfe\xf7\xcf\xf6\x80\x10\x35\x72\xc1\x62\xea\xe6\xa0\x8a\x60\x21\x59\x5c\x1a\x28\x99\xd2\x75\x0d\xf7\xe7\x9a\x9c\xd3\x08\xda\xf0\x3e\xde\x99\xd1\xcc\xd3\x80\x76\xec\x53\x4e\xb6\x1d\xe0\xa0\x7a\x86\x30\x48\xc0\x6f\xa6\x17\xe2\x1d\x7e\x7e\x97\x7b\xb7\x87\x99\x8a\x07\x72\xa3\xa9\xdf\x90\x29\x3a\x94\xe8\xf8\xf6\xf6\x93\x1e\x9c\x71\x96\xee\xf4\x6c\xc9\x17\x07\xd2\x9f\xcc\x5a\xe7\xd8\xa2\xb8\x8f\x1b\xad\xf6\x78\x8d\x13\xef\xf3\xcb\x1f\xed\xa8\xe5\x58\xa4\x78\x28\xa3\xa7\x9f\x2c\xc3\x2d\x68\x9f\xf8\x38\x7e\x77\xf0\x56\x1f\x4a\xd3\x7e\xf7\xb3\xe7\x7a\x22\x04\x38\xe3\x21\xe0\xd0\x2b\xb7\xd8\x58\x99\x46\xb6\x0a\x00\xe7\x09\xf2\xe2\x52\x81\xef\x3d\x00\xb1\x25\xd1\xcf\x34\xe9\x7f\x51\x3b\x0c\x95\x99\x88\xcb\x5a\x6f\xeb\x7f\x51\x3b\xef\xba\x9c\x99\x62\x17\x36\xcd\xe3\x9d\x0d\x04\xef\x85\xa6\x53\x25\x8a\x7b\xb6\xe7\xd7\x7f\xb3\x87\x9f\x85\xfd\x77\xb9\x03\x9a\x46\x28\x72\xfc\x76\x04\x95\x9a\x87\x76\xe3\x9f\xd9\x02\x39\xfe\x3e\x40\x38\xc4\xb4\x62\xd6\x28\x79\x99\xbb\x78\xae\x1d\xbf\x54\xbd\x82\x21\x2b\x01\x54\xf9\xad\x6a\x8f\x93\x97\xd9\x17\x99\xca\xa2\x38\xee\xbe\xdc\x7b\x47\x71\x3f\xb4\xb0\x94\x06\x5a\xe8\x1d\xc6\x75\xfa\xe8\xe0\x93\xd5\x73\xbd\xa9\x5b\x48\x6c\xdb\x6e\x75\x08\x68\x72\x11\x46\xc2\xc8\x15\xbc\x39\x13\xf1\xd7\x5f\x99\xbf\x52\xd0\x35\xac\x02\x01\x97\xcd\x94\x03\x2d\xf3\xc0\xc2\x01\x6e\x66\x25\x4b\x70\x55\x71\xc1\x4a\x80\x4c\xd9\x12\x7c\x82\x04\x80\x4d\x0f\x5d\x28\x5e\xe9\xfa\x21\x35\x45\x3a\x57\x82\x83\x89\xe2\xac\x66\x84\x8e\xe6\x2f\x5e\x21\x64\x5d\x9c\xea\x46\xe8\x55\xd9\xda\x7f\xfe\xf7\x7f\xfe\x17\x0c\x7d\xa6\x96\xf2\xaa\x44\x74\x99\x38\x4d\x54\x81\x4d\x60\x38\xdd\x1c\xf0\xd6\x01\x9f\x4d\x2c\x36\xed\xa6\x51\xe2\x4a\x35\xc6\xc3\xa6\xc1\xe4\x47\x61\xa7\xf5\x6c\x41\xa1\x16\x72\x53\xb5\x8f\xfa\x4a\xf0\x9c\x96\xb9\x8b\x1b\x8b\x5e\x2e\xea\x44\x39\x72\x0e\x6f\xc5\x9e\x28\xb6\x40\x4d\x33\xcc\x66\xea\x13\x2f\xab\x0b\xdd\x94\xed\x72\x45\xa9\xf3\x7d\x44\xfa\x6c\x27\x8c\x92\x0d\x86\x9e\x43\x28\xbe\x65\x42\x8c\x50\x75\x61\x84\x29\x31\xa8\xd5\x35\xc5\x18\xa0\x99\x9c\x5f\x7a\x24\x61\x4d\x01\x23\x66\x2a\x5e\x1c\xad\x44\xdb\xec\x28\xb0\xc9\x28\x25\x96\x7a\x2b\x16\xd2\x07\xad\x5f\x28\x1f\x19\x4b\x07\x52\xb6\x62\xa5\x0b\x55\x01\x0b\x54\xb6\xd8\xf5\x66\x4d\x51\xb2\xb6\xa5\xad\x6e\xe8\xe8\xb6\x8d\x2c\x94\x5e\x2c\x10\x3f\x7b\x2e\x3d\x80\x31\x85\x18\x43\xb8\xce\xd4\x47\x60\x3e\xbb\x72\xe7\x5e\xc2\x5d\x50\x75\xa1\x0a\x37\x79\x58\x2c\xdb\xce\x51\x41\xf1\xdb\x2c\x52\xdf\xb1\x66\x96\xe8\xf9\xf1\xc2\x13\xe1\x33\xac\x88\x05\x84\x03\xd8\x93\x86\x59\x6d\x66\xcd\xa6\x85\x9a\x73\xe5\x43\x84\x65\x53\x1a\xf0\xa0\x73\xe8\x07\xae\xb1\x0b\x0d\x2b\x4e\xdd\xbc\x94\xeb\xa9\x78\xd1\x1e\x15\x02\x31\xed\x34\x60\x90\xea\x46\x89\x65\xd9\xb6\x3e\xea\x13\xa0\x03\x30\xe0\xb3\xf4\x53\x5f\xe8\x66\x2b\x9b\xe2\x21\x84\x33\xd8\x95\x84\xc1\xc0\xbf\x2e\x34\xef\x41\x68\x8a\x51\xae\x75\x5b\xce\x95\x8f\x65\xac\x15\xe9\xed\x4e\x4f\x45\xa5\x5b\xc0\x95\xa9\xb4\xbe\x14\x72\xa9\xa4\x43\x7a\x28\xb4\x32\xb8\xfb\x75\x51\x29\x8a\xf3\x96\x95\x90\x46\x6c\x55\x05\xff\xf7\x2b\xec\x1a\xc3\x93\x05\xc8\x36\xb6\xaf\x23\x7b\x67\x37\x66\x23\xab\xa9\xf8\x46\x99\x12\x24\x6b\x37\xbe\xfc\xf6\x88\x56\xfb\xd5\xd7\xcd\xa5\x3d\x69\x0e\xce\xcc\xd0\xd6\xb9\x00\x8e\xb9\x5e\xef\xa0\xa5\xed\x52\x57\x90\xe2\x3c\x9c\x83\x17\x35\x41\x1c\xe0\xd2\x01\xc7\xe5\x36\xbf\xaa\x30\x4a\x1c\x30\x11\xe0\xac\x84\x25\xb7\xe7\xbc\x88\xce\xc0\xb1\x2c\x0a\x52\x54\x52\x54\x2d\x06\x8a\xbe\x94\xeb\x13\x4b\x6f\xec\x74\xe0\x1b\x85\x8d\x9c\x62\x88\x8f\x1f\x08\x22\xd4\x10\x7d\xa2\x00\xe0\x42\x4d\xd0\x77\x79\xe3\x30\xb7\x13\x72\xe0\x58\xc4\xe3\x13\xb1\x5d\x96\xf3\xa5\x6b\x6d\x63\x28\xcd\x12\x50\x74\x7f\xc7\xa7\x31\x5b\x75\x7a\x2a\x80\x6a\x4c\x84\x83\x12\x45\x9d\x2e\x53\x64\x44\xef\x20\x0f\x1b\xd3\x8d\x38\x06\x10\x34\x08\x34\x13\xa5\xf8\x3d\xa7\x3a\x84\x83\x7c\x26\xca\x5f\xff\x3a\x65\x59\x89\x91\xe1\xc5\xff\x5c\x32\xd0\x28\xde\xe5\x7e\x36\x2a\xcb\xd8\x21\x04\x96\xd9\x54\x76\xb7\x02\x61\x8c\xe6\x80\xc9\xcc\x51\x69\xfd\x8a\x02\x67\x7c\x01\x5f\xc2\x5b\xf7\x7a\xe3\x66\x5d\x84\x3e\x0b\x54\x0a\xb1\x77\x94\x1c\xc5\xca\x1d\xc9\x6f\x1f\xda\x6f\x43\xd3\x61\x54\xb0\xae\x67\x19\xa3\x22\x6a\x66\x6c\x43\xf9\x85\xc6\x8f\x7c\xb5\x29\xf2\x8c\x87\xd6\x7d\x25\x9c\x24\x10\xb6\x24\x19\x8a\xab\x11\xf6\x43\xe7\xc6\x99\xd1\xf9\xf6\x34\x14\x87\xd4\xc6\x58\x66\x75\x58\xf7\xf1\x56\x5d\x7b\x5e\x70\x1a\xfd\x3e\x9c\xa4\xe6\xa1\xc6\x33\x3c\x9e\x0f\x13\x78\x87\x10\x28\x4a\x5e\xc2\x6b\x85\x18\x12\x06\x88\x1d\x10\x5c\x58\x7c\x1f\xda\x25\xde\x01\xb5\xe2\xcd\x6c\xea\x85\x6e\xda\x0d\xc4\x70\xb1\xa8\xdc\xb6\x29\x2f\x2e\x10\x73\x45\xd9\xf6\xb6\x48\xa2\x11\xaa\x46\x41\xdc\x28\x84\x9a\x79\x12\xeb\x9e\x2b\x31\x53\x6d\x0b\x40\x5f\x3b\x24\x5e\xab\xd5\xa6\x46\xa1\xc3\x07\x29\x50\x7c\xa9\x90\x20\x84\x58\x61\xc4\x65\x01\xf6\xed\x50\xaa\xe7\x49\x80\x1c\x9f\x08\xd5\xce\x83\xb2\x80\x1f\x8f\x1e\x36\x98\xef\x3c\xdb\x5c\xae\x39\x1f\xe0\x71\x86\x62\xe0\x32\xf9\x23\xb0\xa7\xb1\xb1\x71\xc2\x87\xf9\x92\x78\xea\xd6\xb9\x9d\xc0\xab\xb2\x55\xa2\x28\x29\x67\x9c\x4b\x68\xe6\x7d\x45\x29\x3e\x19\x94\x34\x71\x7b\x3e\xe6\x0f\x21\x08\xa2\x5a\x28\x95\xb0\xf2\xbd\xe8\x06\x6e\x36\x27\xdd\x95\x72\xff\xef\x52\x8c\xf1\xb1\xb3\xc5\x87\xe8\x9c\x77\x89\xd8\xd0\x79\x07\xff\x7d\xbd\x69\x11\xdc\x47\xd9\xe7\x7c\x4d\x0f\x39\x30\x06\x88\xd9\x64\xfc\xeb\x8b\x0f\x63\xb3\xa9\x79\x38\x68\x96\xb2\xb2\xe0\xc3\x2c\x7d\xf0\x43\x78\xaa\x16\xaa\x71\x51\xee\x20\x62\x63\x88\x35\x18\xf5\x10\x2c\xa7\x29\x2f\x96\x2d\x05\xbd\xe3\x48\x4a\x03\xbb\x3b\xe5\xcd\xbd\x98\xaa\x29\x56\x87\xb4\xfa\x70\x55\xc1\x65\xca\x50\xd4\xbb\x87\xd2\xf1\x6c\x5c\x01\x7d\xdb\xe6\x78\x43\xf0\x36\xcb\xf9\x92\x35\x11\x72\x94\x01\x4e\x8d\x7d\x84\x91\xc9\xdd\x72\xd4\xa9\x40\xb5\x78\x73\x5e\x9e\xf2\x46\x51\x5d\xb3\x70\xda\x74\xc3\x78\x64\x76\xba\x88\xf7\xf2\x55\x32\x45\x07\x2f\x2b\xd3\xff\xbb\xe7\xe8\xfc\x3c\xf3\x8e\xc4\x80\x48\x80\x19\xd2\xd8\x85\xa1\xfb\xa5\xea\xc2\x9d\x9b\x28\xe2\x15\x30\x0c\x64\xcd\xaf\x4d\xa3\x8c\xdf\xac\x51\xd8\x2b\x9d\x4b\x43\xd2\x51\xe6\xb4\x75\xe6\x34\x40\xc7\x90\xb5\xb2\xe4\x20\x88\x28\xb2\xb6\xec\x70\x93\xde\xed\xc6\xa5\x81\xad\xc5\x7c\xa9\xb5\x01\xc8\x47\x69\x90\xb9\x0e\xcd\xa1\xec\xe3\xe6\x28\xb6\xa5\xe5\x71\xab\xca\xca\xaa\x3e\xdc\xd9\xf3\x50\xf4\x9e\x1f\xf8\x74\x93\x6e\x8f\x3d\x8f\x7b\x5d\xcb\xc7\xbc\x8a\xa4\x76\x78\x9f\xc6\x47\xe3\x1f\x67\x89\xcf\x91\xf7\x41\x72\xf5\x7e\x3c\xbd\x3a\x80\x62\xdd\x2e\xcd\xea\xa3\x5a\xef\xd3\x6b\x94\x35\x66\x0f\xdc\xd8\x5c\x03\xbd\x37\x3d\x57\xfe\xd3\x61\xc7\x9d\xa0\x69\x24\xe3\x4a\x50\xce\xb8\x54\x08\x45\x63\x17\x01\x60\x66\x40\x52\xdb\xb8\xcc\x9d\x3d\x80\x31\xfb\x41\x72\xd8\xbd\x74\x03\xf8\x17\xa5\xd6\xc2\xcc\x65\x0d\x78\x22\x56\xa6\xf4\x39\x43\xe5\x1a\x1d\x39\x30\xc1\x02\x5e\xfc\x02\x00\x06\x20\x39\x89\x95\x79\x68\x40\xd7\xbb\x19\xd1\xbd\xf8\xdc\xf3\x8d\xd7\x34\x4e\x8f\x65\x25\x43\x8f\x29\xe3\xb2\x9f\xbd\x49\x5b\x60\x6c\x4d\xde\x47\x81\x74\x33\x48\x62\xc9\x39\xd1\x64\x50\xe7\x90\xd1\xf1\x0a\x6a\x82\x24\xec\x78\xc5\x84\x80\xf4\x04\xa5\x64\xeb\x92\x53\x05\x2f\x48\xcf\x91\x06\x1e\x28\x6d\xae\x6c\x51\x19\x04\x6a\x0c\xb8\x44\x00\xbf\xc6\x00\x90\x90\xd0\xc6\xc8\x6e\x0e\x5d\x2d\x6d\x0d\x50\xd6\xa2\x1f\xd3\x1d\xfc\xf3\x11\x8e\xe3\xe8\x2f\x7c\x0d\xfb\x4c\x3b\x71\x91\xac\xf1\xe5\x70\xb2\xf6\xf9\x2d\xd3\xb5\x3d\x94\xe8\xf3\x1b\x93\xa2\xcf\x0f\xa5\x45\x9f\x67\xa5\xe8\x31\xe7\xdb\x92\xa3\x7a\x97\x79\x48\xe9\x34\x20\x44\xde\x5c\xd7\x66\xb3\x52\x85\x90\x33\x4b\xca\xed\xcf\x8e\x36\xa4\x42\x10\x22\x18\xc9\x82\xf0\xb3\x92\xf3\x13\x1d\x98\x8e\xa9\x6b\xa1\x9b\x67\x72\xbe\x3c\xee\xc9\x55\x23\x02\x95\x1d\x06\x26\x0b\x4a\x85\xd8\x1c\x35\x4c\xa2\xf7\x68\x6e\xbd\xaa\xe6\x00\xe5\xad\xd3\x68\xed\x53\xe2\x96\x4c\xd9\x93\x04\x83\x4a\xd3\xa7\x44\x3e\xf1\xd9\xc9\x2c\x1d\x09\x39\x65\x7d\xb2\x12\x87\x78\x1c\xb4\x21\x51\xde\x81\xbc\x85\x92\x8d\x9a\x16\xef\xfe\x88\x0c\x02\x39\x84\xec\xc7\xb5\xcb\x9c\xe4\x1c\xfe\x28\xb9\xc0\xac\xba\x8b\xf4\x3a\xa9\x66\x0c\x32\x40\xc9\x99\xf6\x6b\x03\xb9\xa2\xa4\xf1\x47\x9c\xbd\x0f\x89\x6d\x92\xad\xc1\x54\xd5\x6d\x53\xaa\x34\xef\x70\xca\xea\xad\xb5\xb1\xf7\x58\xbd\x94\xeb\x58\x33\xe6\xda\x49\x08\x4d\x28\x1e\x75\x10\x56\x38\x49\xa4\x48\x96\xa0\x34\xf5\xd5\x44\x1c\x7d\x97\x9d\x5b\xce\x8a\x02\x8c\x2e\x2d\x34\xb8\x5a\xa2\x5d\x65\x53\xab\x80\x95\x6e\x2f\x86\x99\x8a\x27\xba\xbe\x52\x4d\x4b\x0f\x80\x14\x46\xfd\x6d\xa3\xea\xb9\x3a\x75\xfb\x27\xd0\x8a\xa7\xa8\x0d\x9e\xbb\xc5\xf8\x73\x37\x3e\x8f\x8d\xfb\x93\x49\xed\xe5\xd2\xd0\xc7\xe4\x90\x67\x89\x1c\x52\x81\xa2\x14\x54\x55\x08\xcd\x27\x8a\x72\xb1\x50\x10\x7f\xeb\x2f\x09\xc2\x80\x39\xce\xd3\x72\x52\x90\xaf\x7a\x9a\xf0\x2b\x8c\xe5\x0a\x9b\x14\xe3\x75\x77\x6f\x4e\x60\x1d\x5c\x81\xf4\xdc\xf4\xa9\x67\xa9\x63\xd3\xaa\x35\xd1\x79\x4f\x24\xad\x70\xc8\x4d\x99\xc4\x87\xdd\x87\xc2\xd3\x42\xd7\xea\x6c\xa8\x62\x7c\xb0\xb8\x3e\x17\x1b\xe8\x84\x2c\x5d\x4f\x9d\x9b\x6a\x4c\x98\x62\xf7\xba\xab\x79\x9f\x7f\x1b\xce\x36\xff\x38\x50\x1a\x47\x83\xd6\x8d\xbe\x2a\x0b\x55\x88\x5a\xfb\x3e\x33\x04\xe4\xef\x53\xf3\xec\xbf\xd2\xbe\xf7\x9d\x97\x21\xed\xf4\x7d\x76\x7e\x1c\xdf\x3e\xe9\x6f\xf0\xe7\xab\xa7\x0e\xd7\xe0\x17\xf5\xf4\xcd\xd4\xd3\xf7\xbd\xec\xf9\x8b\x5a\xfa\x17\xb5\xf4\x2f\x6a\xe9\x9f\xb3\x5a\xda\xbf\x1e\xbf\xa8\xa0\xef\x46\x05\x7d\xed\xf7\x39\x51\xba\x7d\x31\xa4\x8d\x1e\xf1\xf6\x25\xfa\xb0\x2f\x7a\xa8\xe8\xcd\xb5\xd1\x5f\xfc\x3d\xab\xa3\xbf\xb8\xb1\x12\xe8\x8b\x43\x95\x40\x5f\xfc\xa2\x91\xbe\xd9\x45\x89\xae\xc9\x97\xd7\xd5\x4d\x8f\x64\x1f\x59\x47\x39\x35\xf2\xb5\x74\xd3\x5f\xfe\xa2\x9b\x66\xad\x5d\x4f\x37\xfd\xe5\x7e\xdd\xf4\x97\xb7\xa8\x9b\xfe\xf2\xc7\xd5\x4d\x7f\x79\x63\xb2\xf4\xe5\xa1\x64\xe9\xcb\x5f\x74\xd3\x77\xa6\x9b\x46\xd0\xec\x41\x58\x68\xae\x99\x1e\x01\x10\x8d\xe4\xc1\xa5\xcc\xf7\x1e\x98\x10\xf8\x64\xe9\x2b\xf8\x7a\xeb\x9a\x85\x50\x7a\x5f\xe2\x88\x3d\x72\x8d\x91\x98\x89\x32\x22\x2c\x7b\x80\xd7\xee\x8c\x30\x87\x58\x1c\xbe\xfa\xc4\xaa\x59\x70\xea\xef\x43\x76\x14\x62\xd0\xc2\xc1\x81\x90\x2c\xa3\x45\xa5\xda\x23\x83\x3e\xa1\xe4\x90\x59\xb6\xf0\xd8\x44\xe4\xc8\x9e\x92\xeb\x70\x9f\xdd\x01\xd3\xf5\xf1\x5b\xbe\x07\xf0\x6e\xec\x56\x9d\x25\x67\xf4\xda\xe8\x77\xfe\x35\x60\x22\x6c\x48\x39\x13\xa1\x82\xf8\x35\xdc\x06\x22\x8e\x5c\xa4\x15\x42\x5c\x5b\x61\x2d\x63\x19\x57\xd7\xee\x8d\xbe\x66\x1a\x9f\xa0\xff\xba\x6b\xcc\xf1\x51\x50\x66\x5d\xa0\xb9\xc1\x0b\x3a\x84\xe8\xcd\x37\x7d\x0f\xb6\x77\x08\xb0\x71\xb0\xd4\x3e\xc4\x86\xeb\x71\x47\xa4\xfc\xc9\x70\x07\x9e\x3b\x7e\x81\xf1\x39\xfe\x05\xb4\x7b\x3a\xef\xc4\xe3\x91\x08\xdc\x7a\xa6\x59\xae\xd7\x55\xa9\x8c\x73\xeb\xf6\xd7\xc8\x3b\x66\xaf\x04\x46\x96\x44\x64\xd6\xe7\x39\xeb\x43\x3c\x08\x05\xdc\xed\x77\x51\x6e\xe2\xeb\x08\xc3\xbc\x2f\x0e\x58\x3c\xa2\xd1\xef\x41\x3e\x1f\x7f\x38\xb3\x57\x7b\xf0\x7a\x47\xbb\x3b\x3c\xda\xaf\x63\x10\xf5\x80\x79\xfa\x68\x24\xba\xba\x18\x44\x58\x8f\x46\x92\xad\x33\x06\xa3\xeb\x87\x2c\x57\x35\x1a\x6b\x3d\x53\x69\x18\x6f\x5d\x24\x81\x51\x59\x82\x26\xf2\x3c\xcd\xf8\x3d\x1d\x8a\x0a\xfa\xd4\xa7\x7d\x1a\xfb\xd8\xd3\xff\xfd\x1d\x5d\x66\x92\x15\xf9\x87\x71\xcc\x49\x49\xd2\xf9\xec\x45\x82\xcc\x1f\xab\xc3\x01\xcd\x18\xe9\xb9\x03\x88\x58\x0e\xc8\xf6\x7f\xdd\x1d\x3e\xbe\xef\xa2\x0f\x21\x3f\x43\x95\xbb\x95\x47\xce\xd7\x97\x0f\x0f\xef\xe0\x6b\xd1\x0b\x9c\xcf\x07\x35\x04\xa1\xcf\x02\x31\x65\x55\xfd\x43\x3e\x12\x3d\x80\xfe\x87\x11\x84\xeb\x10\xf9\x41\xec\x7c\x71\x20\x9d\xfd\x39\xd3\xb9\x3b\xcd\xa5\x70\x17\x4c\xdc\x40\x8e\x02\x7e\x31\xf1\xfb\x50\xb6\x82\xb1\x22\x16\xf8\x68\x98\xa0\x2b\xde\x1d\x35\x4a\x00\x68\x7c\xa5\x8c\x99\x8e\xbd\xd2\xfe\x72\xf4\x24\x03\x8c\x2f\x4e\x6f\x8a\x84\x1b\x5e\x9c\x3d\xd7\x66\x30\xb5\xc0\xf8\xe4\x02\x87\x5c\xaf\x9e\xcb\xd5\x73\xf2\x0f\xba\x58\x1d\x97\x87\x3b\xcf\x25\x31\x2a\x93\xc4\x5d\xdc\x8a\x81\xcc\x0b\xfc\x56\x0c\xe7\x60\x08\x0f\x16\x21\xfd\xff\x23\x3e\x59\x2c\xc1\xc4\x83\x07\xee\x1e\xf5\xa4\x97\x38\xef\x4b\x2f\x91\xa9\x99\xf8\x13\x9e\xef\x4f\x2e\x71\xe3\xcb\xbe\xf7\xba\x1f\x96\xd0\xe1\xb0\x7b\xfd\x0f\xfc\x6c\xde\x46\xa2\x8f\x9b\x10\x09\xe7\xce\xfa\xf8\xf5\x0b\xb4\x69\xda\xb3\xed\x95\xf9\x31\x52\x45\x48\x7a\xee\xcc\x70\x3e\x43\xa7\x24\x6d\x3e\x58\x04\x8c\xaa\x16\x90\xc7\x7b\x87\x4d\xce\x14\x4f\xb1\x1b\x37\x04\xd6\x02\x08\x5b\x07\x1f\x3e\x80\xae\xd9\x5c\x40\x87\xd8\x9c\x1f\x87\xa4\xac\xe1\x6b\x09\x99\x37\xfa\x1d\x7f\x61\xd2\x66\xb4\xcf\xef\x3e\x47\x5f\xdf\x0b\x29\xd7\x1a\x35\xdf\x34\xa6\x74\xb9\x22\xd1\xd2\x0c\x0e\x3c\x7a\x2d\x2a\x75\xa5\x2a\x22\x31\x90\x8d\x51\x36\x8d\xdc\x81\xe3\x40\x6b\x57\x1e\xb4\x97\x06\xdc\x33\x61\x11\xbd\x50\xe7\xda\x02\xf5\x9d\x2d\xe0\x12\x69\x4c\xc5\x2b\x65\xc0\x1f\xd4\xb6\x84\x8a\xdc\xa5\x42\xa0\x64\x88\xff\xf7\x6b\xdc\xd2\x19\xa3\x24\xa8\xa7\xa7\xbe\x0d\xd4\xfa\x4e\xc5\x1b\x1c\xba\xae\xbd\xbd\x94\x9c\x2c\x6a\xdd\xac\x64\x25\x16\x95\xde\x86\xf0\xf8\x3f\x22\xb8\x40\x98\xd6\xa6\x46\xff\x51\xd7\x2c\x18\xf3\xd0\xe0\xb4\x43\x25\x3e\x8e\x71\x1a\xad\x5f\xa5\x64\x61\x40\x89\x5f\x0b\xb9\x9a\x95\x17\x9b\xb2\xdd\x89\x99\x6a\xb7\x4a\xd5\xe2\xf7\x5f\xfd\xf0\xe7\xe9\x74\xfa\x97\x4f\xbf\x3f\xfd\x0a\xb6\xf8\xf7\x5f\x4d\xa7\xd3\xdf\x9f\x7e\xe5\x1b\xf9\xde\x2d\x9d\x1d\x28\x36\xa0\x37\x06\x70\x00\x0c\x19\x10\x9c\x23\x76\xd0\x53\xab\x5a\xce\x2c\xff\x27\xe7\xad\x57\x3e\x3d\x78\x90\x47\x37\x1c\x02\xe2\xe3\x3f\x0e\x6b\x81\x78\xc1\x3c\xfc\x69\xe8\xb5\x0f\xa5\x2e\xb5\xf1\xd2\x0e\x90\x3b\xa4\xed\xde\x78\x8a\x52\x1a\xc4\x75\x12\xe7\x87\xcf\x8a\x01\x63\xbb\x66\x6e\x1f\x71\x90\x08\x4e\x27\x53\xe8\x35\x15\xad\xbd\xd7\xd5\x99\xa4\xc5\x08\x28\xbd\x91\x63\x1a\x25\xce\x0f\x0d\x28\x33\x9e\x1e\x7c\xbb\x91\x23\x1a\x29\xc9\x1c\x38\xa6\x1e\xe4\xa8\x91\x63\x1a\xc9\x47\xee\x1f\x53\xc7\xca\x78\x3b\x20\xa5\x23\xa7\x31\xda\x14\x37\x0c\xfa\xd9\x45\xfd\xcc\xa0\xcc\x75\x06\x77\x43\xb0\xa1\xfd\xd0\xa3\x7b\x31\xed\xfa\x06\x72\x70\xec\xcc\xfe\xb1\x74\x69\xcd\x4f\x13\xa8\x6e\xb0\x55\xef\x3c\x7b\x94\x7a\x9b\x45\xfe\x71\x18\xcd\xe1\xfd\x6c\x1d\xf3\x42\xab\xcd\xdc\x38\x00\xcc\xcb\x94\xdc\x94\xe9\xf1\xbd\x26\xb8\x40\x60\x18\x6d\x1a\xdd\x00\x28\x13\x5a\xeb\xa9\x21\x78\x13\x00\xff\xa8\x28\x8d\x7d\xf2\x8a\x49\x68\x67\x1b\xec\xab\xed\xb2\x51\x5b\x7c\x2d\xa7\x09\x9d\xe7\x2c\x67\x2b\x2f\x3a\x54\xfe\x49\x25\x8d\xf1\xda\x85\x7e\xb4\xc8\x14\xbb\x15\x1e\xa9\xda\xb4\xb2\x9e\xab\x98\x21\x0d\x92\xce\x59\x52\x07\x4e\x09\xd5\x99\x36\xaa\x2e\x54\x33\x7d\x5f\x9a\x97\x7a\x7e\xe9\xb6\x2c\x07\xaf\xef\x6c\xc9\x95\x5d\xab\x4d\xab\x1f\xae\xf4\xfc\x12\x78\x8e\x75\xa3\xe7\x0a\x78\x22\xc7\xa8\x1c\x45\x89\xf9\x31\xbd\x44\xda\x5e\x07\xe2\x4d\x74\x50\x61\x73\x70\xda\x84\x6e\xd4\xaa\xda\x0e\x54\x56\xd5\x4e\x2c\xd0\xbb\x9b\x78\x5a\x4d\x67\xe4\x43\x0b\x4b\x3b\x41\x00\x21\x42\x71\x32\x00\xf6\xc5\x9b\x72\x07\x18\x01\xad\xe6\x76\x1f\x54\xe4\xac\xaa\x4c\x55\xd6\xed\x43\xda\xfa\x87\xb6\xe1\x87\x95\x3d\x70\xa2\xd6\x0f\x6d\xd7\xd4\x73\xbc\xa1\x6e\x25\x65\x35\x62\x57\xed\x2e\xfa\x62\xc9\x36\xda\xc3\x17\xaf\x52\x37\xac\xe3\x57\xe6\x78\x3a\x9d\x9e\x3c\x12\xaf\x34\x02\x34\x6d\x21\x3a\xce\x36\x02\x9c\xa4\x5e\x09\xda\x67\xe4\x16\x01\x91\xaa\xda\x91\x63\x92\x74\xe7\x1c\x4e\x0c\x70\x71\xa5\x71\x28\x90\x53\xf1\x6d\x33\x41\x47\x33\xdb\x80\x65\x9d\x6d\x0f\x93\x28\x75\xc8\xd1\x24\x0c\x7f\x5a\x94\x66\x5d\xc9\xdd\x2b\xb9\x52\xf6\x19\x09\x1f\x6a\xfa\xe5\xc8\xff\x74\xd4\x83\x22\x2a\x22\x06\xcd\x0b\xa1\x8e\x1d\x6d\x14\xfa\xf3\x7b\x56\x1c\xc3\x07\xa6\x5c\x04\xbb\x81\x3d\x1d\x7a\xce\x52\x6c\x14\x7a\xce\xee\x7d\xba\x77\x0f\xe3\x61\xba\x1f\xc5\xb9\x80\x7f\xbd\x71\xdf\x9a\xe3\xb6\xd9\xa8\x09\xc4\x6b\x59\x2e\xaa\xaf\xe2\x8b\x1a\x7c\x9d\x32\xf5\x69\x97\x79\x03\x2b\xbd\xa9\xdb\x43\x2a\xc3\xff\x6c\xed\x90\xd3\xaf\xd2\x75\x24\xca\x79\x9f\xb5\xad\x6e\x2e\x5f\xd4\xaf\xc9\xe3\x0d\x49\xc1\xfd\x6c\x82\xc6\xb8\xe4\x34\x20\x79\xba\xcc\x8d\xe4\x0a\x94\x0b\x45\x7a\xa3\xcc\x66\x45\x50\x77\x97\x20\x91\xed\x54\x1b\x82\x3c\x55\xd1\x09\x42\xb2\x74\xab\xb7\x47\x2e\x05\xe0\xde\xf9\xad\x04\xd5\x00\x0e\xc8\x89\x06\xb9\x66\xce\xee\xc5\x61\x58\x5e\x8d\xf0\x7d\x54\xf8\x98\x37\x35\x89\x1a\x9e\xae\x55\x5d\x94\xf5\xc5\x6b\x34\x44\x47\x9f\x32\xcf\x76\x7e\x2e\xbe\x7f\x98\xb3\xfb\x47\xa4\x76\x88\x2b\x42\x53\xa4\xeb\xe3\x3d\x3a\x1f\xb5\x54\xf5\x97\x2c\x45\xae\x0e\xde\xca\x9c\x28\x15\x1c\xdf\xee\x76\x6d\x46\xcf\xfc\x13\x5b\x24\xee\xd8\x0f\x02\xd8\xa7\x7b\xf7\x7e\xa0\x5d\xb5\x2c\x89\x2a\x20\x80\xf2\xad\x33\x15\xbc\x51\x0b\x7b\x5f\x7f\xf8\xe4\x6f\x34\xca\xb2\xf6\x3e\x7c\xa3\x2e\xca\xda\xce\x4e\x9c\x0b\xe6\xda\xa6\xeb\x45\x79\x31\x11\x4b\x6d\x5a\xd2\x18\x4d\xc4\x72\x57\xe0\xe8\xfd\x2f\x66\xbe\x54\xc5\xa6\x82\xd5\x99\x00\xa7\xb1\x69\xd5\x33\x3f\xcb\xe7\xba\x61\xd1\x3f\x10\x9e\x06\x1e\x7f\x6f\x15\xb8\x6f\x91\x9f\x0e\x98\x5f\x6d\x77\xd3\xdc\x57\xc7\x81\x6c\x8c\x7a\xbb\xab\xe7\x6f\xb1\x47\xda\x1a\xac\xd6\xf9\xe4\xea\x60\x7b\x4f\xd5\xba\x29\x75\x53\xb6\xe5\xbf\xab\xb7\x9b\x59\xdb\x28\x95\x76\x99\x29\xe2\x6e\xc9\x7a\x63\x96\x7f\x0c\xab\x20\xce\xf9\x9a\x4c\x93\xaf\xae\x63\xfe\x33\xe8\x66\x07\xaa\xc1\x77\xd7\x9b\x25\x08\xcd\x1f\xdd\x3a\xc3\x06\xda\xaa\xc9\xc2\x4f\x33\xc5\x26\x9e\x03\x37\xaa\xdd\xdf\x42\xa6\x98\x6b\xa1\x6d\x76\xef\xf4\x93\x4a\x96\xab\x57\xea\x03\x95\xb1\x1c\xc1\x8b\xc0\x7e\x75\x9a\xdb\x57\xe7\xcc\xd1\xa7\xf7\xe1\xe4\x05\x56\x50\x9c\x8b\xdc\xcf\xf6\xe5\x3c\x1e\x79\xc4\x26\x62\xa5\x56\xba\xfc\x77\x45\xf7\x8e\xfe\x05\x13\x3b\x71\x33\x93\x85\x5e\xb7\xd0\x3e\x9b\x4b\x76\x44\xd3\x6e\x51\xd7\xc8\x5c\xd7\xa6\x6d\x36\xf3\x91\x0d\xe5\x8b\xbb\xc6\xf0\x7d\x1b\xd5\x50\xb7\xa8\xbf\x1a\x88\xa7\x3f\xaa\x95\x4c\xd9\x33\xa7\xb9\x05\x2b\xc9\x1b\xb5\x42\x25\x58\x69\xbc\x1b\x7e\x57\xae\x6c\x9f\x45\xa4\x4c\x14\x65\xa3\xe6\x6d\xb5\x9b\xde\x1b\xc6\x50\xe8\x7b\x7c\x27\xc0\xc7\xa6\x41\xd2\x7b\xfb\x1d\xd7\x5c\xfa\x35\x47\x87\xf7\xa1\xf6\x5e\xb3\x63\x64\x26\x9f\x8d\x4e\x3c\xde\x95\x02\x11\x1c\x42\x8a\x45\xa3\xcc\x12\x25\x42\xcf\x40\x83\x1b\xf4\x52\x02\x78\xeb\x4c\xa9\x9a\xba\x53\x85\x65\x31\x26\x21\x08\x11\x20\x56\x6d\x21\xef\xf4\x4a\x40\x01\xa0\x38\x9e\xa1\x8d\x0b\x80\x7d\x57\x65\x5d\xae\x64\xc5\x95\xea\x66\x2a\x5e\x60\x3c\x7f\x2c\x0c\x62\xcc\x92\x73\xa5\x06\x3e\x55\x33\xc7\x7d\x0c\x94\x13\x65\x2b\x2e\x54\x6b\xfc\xc8\x30\xc2\x15\x19\xf2\xa8\xb9\xb9\xac\x03\x44\x2f\x4c\x3b\x36\x07\xa0\x42\x7f\xb6\x03\x0e\xaa\x6d\xe4\xfc\xd2\x8e\x37\x1a\x27\xb5\xd7\xc3\x6e\xf4\xb0\x92\xc7\xe9\x06\xe6\xaa\x8f\xda\xd6\xc8\x9f\x89\x6d\x2e\x63\xde\x72\x6d\xe7\x04\x7f\x77\x2c\xbc\xf0\x1f\x90\x60\xf1\xef\xdd\x70\x8d\x92\x87\x5f\x44\x2b\xbb\x94\x57\xe0\x27\x6f\xd9\x4e\xd3\x4a\x82\x83\xd8\x79\xd4\xdd\x76\xa9\x18\x68\xf7\x14\x7d\x13\x30\xca\x71\xab\xec\xfd\x8f\xed\x9e\xc0\x4f\x33\xd4\xe9\xe0\x07\x2c\x11\xa8\x57\x2f\x7c\x14\x72\x34\x0f\xdb\xf8\xbd\x68\xaa\x14\x5f\x69\x07\xe3\x26\xa2\x0a\x1c\x17\xa9\x1a\x28\xb0\xc4\x5e\x02\xd4\xea\xa0\x8d\xa1\x34\x02\x10\xaa\x85\x61\x46\x59\x74\xee\x46\x1d\x47\xd9\x0a\xbd\x69\xf7\x9c\x88\xac\xa1\xe7\x6e\x8e\x43\xb4\xc5\x93\xae\xd9\x65\x42\x69\xd1\x9c\x86\x05\x01\x4b\x24\x2e\x76\x14\x5d\xb3\x55\x47\x57\x6c\x47\x5c\x85\x99\xba\xd8\xd4\xc2\xe8\x95\x62\xfb\x6a\x0f\x8e\xe5\x76\xc0\xae\x93\x64\x6b\x43\xc4\xeb\xad\x12\x95\x5a\xb0\xf3\xa2\x17\x0b\x7b\xc9\xfc\xdd\xb3\xa3\xb8\x90\x65\x6d\xda\x4c\xd0\x32\xec\xe8\xc1\x4b\x7c\x57\x17\x6f\x5f\xe2\xfe\x41\xb9\x2f\x60\x2b\xb0\x48\xb6\x64\x44\x9c\xb3\x0f\xae\x35\x4b\x69\x88\x0b\x7a\x02\xd0\xcf\x05\x8f\x28\x3b\x3d\x15\xaf\xc0\x1a\x56\xed\xdc\x0e\xcc\x64\x59\x61\xf0\x21\x5c\xdf\xb5\x11\xea\x6f\x1b\x59\x81\x19\x0b\x43\xae\xe6\xc4\x6a\x2e\x01\xcf\x05\xda\x8c\x2e\x34\x86\x59\x14\x9a\x50\xac\xcb\x0a\xf2\xec\xe1\x1e\xbb\x4c\x35\x18\x9d\xee\xb7\x0b\x3b\xf2\x78\x40\xa4\x5f\x01\x10\x03\x3e\xe3\x4c\x44\xd1\xf0\x92\x10\x9b\x55\xb0\x35\xf1\x7a\x8d\x40\x08\xb3\x9d\x64\xe4\xea\xa8\x35\x02\xb8\xec\x72\x05\x5e\x67\x41\x53\xff\xb6\x7e\x8c\x97\xe0\x79\x59\x97\x66\xa9\x0a\xcb\x2a\xf6\xee\x36\x0f\x7e\xb8\x2e\x7b\x82\x6d\x70\x86\xb3\x73\x98\x33\xe5\x69\xd4\x7d\x22\x79\x7c\x76\x57\xb2\xb9\x64\xee\xa8\x43\x87\x16\x3d\x58\x93\x66\x1b\xb5\x08\x47\xd4\x96\xe0\x36\xc8\xe3\xfb\x8e\x30\x7f\xfc\xe8\x55\x18\xae\x50\xa3\x16\xf1\x01\x26\xb9\xca\xd2\xf7\x37\x6a\x21\xf0\xb5\xcd\x5f\x7b\xfc\xf6\x4e\x5e\x88\x8f\x96\xa5\x5f\xec\xb9\x99\x5d\xd5\xe1\x98\xf9\x2e\x32\xe7\x30\x28\x0f\xdd\x35\xa6\x33\x34\x7c\x87\x7d\x8d\xe4\xe4\x8d\x38\xe6\x3f\x8f\xab\xcf\x6e\x5a\xe6\xde\xbb\xd5\xd8\x7f\xcb\x7f\x18\x6c\xd7\x1e\xb3\xfc\xdd\x86\x7f\x65\x42\xe8\x6e\x70\xb5\x83\x7e\xd5\xcb\x34\x56\x06\x2b\x0b\xd5\x88\x59\x53\xd6\x17\x10\xe6\x54\x93\xe4\xef\x4f\x1e\xe6\x93\x3e\x3e\x81\xf4\x17\x0c\x3d\xea\x45\x2b\x30\x8c\x15\x72\x99\xd8\x47\x73\xca\xd5\xb6\xf6\xf0\x6c\xea\x95\x34\x97\xaa\x08\x2a\x82\x0b\xd5\x7e\x17\xff\x78\x9c\x1d\x2b\x68\xec\x78\xad\x97\x03\x75\x26\x69\x47\x27\x67\xf7\xb2\x2f\x57\x02\x85\x06\x72\x20\x41\x70\x41\x98\xc5\xd4\x4b\x1d\x19\x3d\x93\xaf\xf1\x54\xcd\x36\x17\x1c\xb9\x6b\x6a\x3c\x92\xd7\xeb\xa5\x34\xea\xf8\x08\x5f\xe3\xa0\xdc\x4e\xde\x8a\x45\x1d\xce\xc2\xc4\xcd\xf3\xe4\xc0\x4e\x58\x4e\xaa\x4f\x41\x51\x2e\xe7\xad\x78\xaa\xae\xde\x69\x5d\x59\x41\x01\x7c\x42\xc0\xbd\xa6\x92\x17\xb8\x3f\x43\x94\xe9\xb5\x6a\x16\xba\x59\xe1\x71\x3a\xfb\x31\x9e\x02\x3c\xe7\xd7\x78\x07\x98\xbc\xbe\x97\x48\x0e\x8b\x9b\xa7\xa7\xe2\xf5\xc6\x2c\xfd\x79\x23\x3c\xac\xc6\x08\x25\x9b\x6a\x87\xf6\x2d\x75\x05\xec\x3a\x15\x31\xad\x9c\x5f\x8a\x55\x69\x10\x0b\x27\xb8\xe2\x3c\xdd\x34\x20\x2d\x5a\x91\x0a\x54\xdb\x8e\x32\x5d\xd6\x7a\xcb\x84\x40\xd7\x90\x15\x3d\x48\x72\xf1\x46\x3c\x97\x75\x04\x08\x15\xf7\xcf\x01\xc1\x92\xd8\x7d\x97\xe2\x3d\x6e\xae\xac\xc5\x02\x08\x42\xb2\x2e\x27\x84\xef\x22\x17\x2d\x18\x35\xed\x62\x94\xf5\x45\xf0\x94\x0e\x04\x5b\x9c\x83\x92\x8e\xfe\xf5\x9a\xd6\xa2\x7b\x4b\x7d\x55\x24\x17\x94\x75\xfe\xdc\xab\xeb\xc5\x5e\x41\x1e\x70\x90\x92\xcd\xf6\x26\xcb\x04\x4a\xe7\x45\x4d\x6b\x54\xb6\xa5\xac\x50\xe4\xdd\x2a\xb1\x82\x59\x85\x6c\x28\xa4\x51\x8a\xd6\x33\xd8\x1d\xf3\x1a\xa7\x7d\xec\x36\x7f\x18\x99\xb5\xaa\xab\x75\xea\x34\x34\xc0\x93\x0b\xaf\x84\xf5\x0b\xc7\xe1\xfc\x3a\xde\x92\xd7\xb3\x9e\x9c\x25\x4b\x28\x21\x88\x7a\xa5\x5c\x0e\x98\x34\x2c\xd8\x1f\x41\x7a\x96\xe1\xc1\x8c\x00\x80\x92\x31\x63\x73\x2f\x6f\xb8\x14\xd9\x07\x33\xe9\x29\xa3\x9e\x3b\xf0\xb6\xc7\xfc\x2d\xf9\x07\x64\xee\x4a\x6f\xab\x7c\x44\x13\x76\x63\x32\x6a\xb2\x5b\x6a\x38\x10\x28\x30\x54\x50\xa6\x32\xd2\x55\xb9\xb4\xe1\xd9\xe7\xda\x65\xd3\x44\xb3\x1f\x92\xe2\x3d\x8c\x33\xf3\x56\xbb\xcf\x47\x14\x31\x6e\x4f\x3a\x34\x92\x06\x45\x30\x4f\x5a\x98\x27\xdf\x41\xac\x86\x27\x32\xec\xb6\x77\xa7\xe6\xce\x36\x52\xb4\x61\xa2\x13\x6c\x98\xee\xd8\xdc\xa2\xd4\xe3\xc9\x19\xf3\xa5\xe8\xa3\x4d\x67\xcc\x30\x8d\xd3\xbc\x77\x1d\x76\x22\x23\x57\x73\xe2\xf9\xc3\xed\xf2\x1c\x89\xbf\xc7\xf1\xcf\x92\xdd\x38\x3d\x15\x2f\x91\xe3\x20\xee\xde\x4a\x00\xb0\x6f\x0c\x05\x98\x00\xcb\xb6\x8a\xf0\x0e\x88\x89\x25\xff\x88\x7b\x11\x83\xfc\x46\xe1\x8b\xb1\x69\x42\x88\xff\x15\x3c\xa1\xb2\x70\x0d\x79\x60\x96\xf8\xc5\xe1\x86\x96\xce\x49\xf6\x45\x61\x70\x63\x98\x25\x5f\x63\x4d\x0f\x91\x1f\x28\x64\x5d\xc3\x6b\x89\xef\x21\x90\x73\x12\x92\x12\x60\x82\x46\xcd\x65\x35\xdf\x54\xa8\xec\x9e\x66\x04\x36\xf6\x3e\x8f\xbe\x97\xe4\x98\x20\x3a\x98\x1d\xe3\x58\x39\x67\xf4\x7b\xa3\x75\xdb\x23\x15\x70\xa9\x5e\xeb\xee\x8d\x4a\x7d\x9d\x40\xb8\xd7\xba\x75\xaf\x77\x67\x72\xb6\xcf\x77\x7a\xfd\x27\x75\xa5\x9c\xe7\x3f\xfa\xc5\x75\x9f\xae\x6e\x33\xd9\x1f\x51\x47\x60\x7f\x8f\x19\x7a\xa6\xee\x89\xbe\x46\x9a\x04\x24\xa2\xb2\xda\xca\x9d\xb1\xe2\x94\x51\xed\xf5\x06\x3a\x77\x23\xe4\xb4\x12\x2f\x6c\xc7\xb6\xda\xdf\x82\x0f\x9b\xc9\xbc\x6d\xf8\xfc\xb8\xfd\xba\x1e\xcb\x3d\x62\xc7\x03\x8d\xc4\x0e\xff\xdf\x8d\xda\x64\x88\x32\xfb\x18\x76\x9e\xd7\xe8\xc6\x3d\x39\x90\x5a\x67\x02\xee\x51\x69\xc0\xe7\x33\x56\xc7\x50\x79\x70\x76\x33\xe6\xbb\xd0\x49\xff\x22\xb0\x91\xb8\x50\x3e\xfc\xef\x20\x43\xe4\x50\x8d\x68\x84\xe7\xe7\xd8\x77\xca\x13\xa3\x49\x04\x87\x95\x98\x42\x02\x1a\x23\xa4\x20\x94\x5e\x25\xe2\x80\x52\xd1\xc2\xc0\x9b\xab\x35\xb2\x92\xa0\x52\x07\x43\xa0\x32\xde\xa8\x00\xa8\xa9\x4c\x17\xd1\xb1\x91\x73\xdc\xe5\xdb\x54\x55\x80\xed\x1f\x59\x5a\x41\xcb\x30\xa5\x7f\xf3\xbd\x19\x45\x14\x70\x61\xb3\x7e\x4c\x5d\x8b\x14\x9e\x99\x07\x0f\xf0\x52\xa0\x5d\x5f\xd9\x7f\x67\x5c\x0c\xd2\xb3\xdb\xdd\xa8\x2e\x44\x62\x6a\x01\xc2\x75\x46\x02\x3e\x53\x2c\x90\x8e\x63\x6e\x07\x1f\x4c\x20\x14\x6d\x03\xd2\x29\x0d\x6e\xca\xec\xa2\x80\x05\x16\xbc\x11\x5c\xd0\x0f\x58\x36\xec\x38\x78\x7b\x33\x1a\xd0\x32\x20\xdc\xb9\xe9\xa2\xe3\x64\x69\x48\xb7\x59\x5e\xa9\x6a\x17\xce\x19\x7a\x1a\x4a\x13\x9f\xa2\xd6\x75\x6b\xe5\x4b\xfe\xe9\x9d\x37\xd9\xce\x4a\x88\xca\x91\x62\x29\xe7\x97\x53\x0c\x3d\x91\x94\x3f\x7e\xa9\x4d\x8b\xdb\x09\xf1\x39\xe0\x56\x0e\xbb\xef\xc3\x0c\xa1\x31\x92\xa7\x01\xed\xea\xa8\xf1\x06\xb5\x6a\x87\x09\x70\xbd\x00\x8e\x27\x06\x6d\xab\x5b\xb9\x13\xa5\x01\x69\x25\x86\xfe\xb5\xdb\x07\x51\x36\x0e\xef\x1d\xc6\xb4\xb2\xdc\x01\x1c\x75\x5c\x55\x32\xdc\xce\xf5\x6a\x85\xc9\x32\xa3\x5d\x71\x48\xab\x04\xf1\x53\x1a\xb1\x25\x24\x54\x82\xfd\xf1\x3d\x03\x53\xb2\x28\xeb\xe2\xe9\xb7\x2f\x21\x0e\xd1\x37\x33\xc8\x2b\xb9\x85\x38\x8b\x16\xf5\x59\x6d\x36\x0d\xa5\x35\xf5\x3b\x08\xb3\x17\x65\x0d\x76\xe7\xd2\xe0\x72\x6e\xcb\x76\x69\x29\x80\x33\x11\x47\x62\x5d\x64\xd5\xc6\x04\x04\xd0\xb0\x49\xf0\xe5\x10\x6a\xd0\x8f\x85\xce\x85\x11\x0c\x63\x0e\x0e\x41\xe1\x6b\x52\xd4\x14\x9d\xa8\xa2\x77\xb2\xb7\x63\x8d\x66\xf0\x17\x43\x02\x67\x06\x29\xf7\x5b\x7b\x3b\xb6\x25\x38\x75\xd8\x2d\x0f\x77\x87\x08\x6c\x8d\x6e\xbd\x5b\x25\xe4\x2c\xa4\x0e\x40\x09\xd8\xfe\x1d\x6c\x96\xbc\x45\x20\x1c\xe3\x69\xe6\x68\xbe\x37\x45\xdd\x70\xa4\x72\x90\xe1\xe4\x7c\xe6\x5e\xf6\x2c\x88\xc9\xbd\x63\xf6\xef\x0f\x26\x90\xaf\x7d\x22\xd7\xbf\xe1\x5b\xd7\xfb\xf0\x80\x7b\xbe\x3d\x8f\x4b\x09\xd5\x30\x34\xeb\xde\x6d\xbc\x1b\x7d\x7c\xca\x0d\xf5\x83\x89\x2b\x5b\x8f\x2a\x6c\x58\xd7\xb5\xcf\x0d\x2c\xcf\xfd\x30\xb1\x94\xc2\xd7\x07\xad\x3b\x87\xdb\x6a\x0e\xb2\x09\x89\x11\xe6\x91\xbd\xc6\x91\xfb\xac\x7a\x60\xcd\x72\xee\xc1\xdf\x2b\xa7\x5b\xa0\xd7\x0e\x9e\x4e\x1a\x92\xd0\xde\xa3\x97\x4e\xd0\xed\xa7\x4d\x09\xf7\xc0\x71\x8c\x6e\x66\xae\xe7\xfb\x01\x0b\xd3\x31\x10\xf1\x1e\x3c\x4a\xe3\x00\xff\x5e\x0d\x63\x89\xcd\xfa\x9a\x56\xac\x5b\x55\xd4\x24\xfa\x0d\xdf\x5d\x12\xe6\x89\x41\x9c\x4f\xc1\x0d\xef\x9d\xab\x62\x59\xc9\x8c\x4b\x2d\x84\x22\xc5\x76\x09\xbf\x73\x9d\x36\x52\x8c\x45\xb3\x56\xf3\x52\x56\xf8\x4a\x48\x72\xfc\x43\x84\x40\x7c\xdb\x90\xe3\xb1\xec\x8d\x7d\x1f\xa7\x8c\x1f\xb2\x2c\x85\x7f\x41\x4f\x4f\xa1\x09\x60\x41\xb6\x9a\xa5\x1f\x77\x31\xcd\x8d\x2a\x17\xa5\x72\x10\x0d\xcc\x30\x80\xe9\xd6\xb1\x74\x68\x0c\x39\xc2\x3a\x30\x57\xaa\xbe\x2a\x1b\x5d\xaf\xbc\xa3\x1c\x60\xad\x23\x63\x3a\xb7\x92\x8d\x70\x7c\x83\x3d\x08\xc8\x3b\x85\xe6\xa4\xbd\x1e\x06\xa2\x80\xe6\xc0\xe4\xb9\xa7\xcf\x83\x4f\x52\xd8\x15\xc4\x62\x35\xf2\x4a\x35\xa0\x79\x29\xfd\x5b\x98\x6e\x9c\xcf\x68\xc1\x0e\x59\xb8\x6d\x0f\x1e\x0c\x6d\x95\x2f\x77\xd2\x05\x25\x07\x50\x18\x88\xbe\xf2\x79\xfe\x73\xdb\x02\x80\xce\x14\x99\x4d\x5c\x84\x6e\x22\x50\x0b\x88\x2d\x99\x70\x35\x8a\xf3\xbd\xc5\x80\x74\x68\x8b\x5c\xb6\xd1\x1a\x0a\x0f\x67\x8f\x07\x50\xc4\xd5\xd1\x6c\xde\xd8\xf2\xd1\x09\x1f\xa9\xad\x3d\x3d\x15\x4f\x00\x1e\xc7\xef\x2e\xba\x6f\xc3\x20\x95\xa2\x68\x2c\x16\xdd\xdf\x28\xa1\x17\x0b\x33\x6f\x94\xaa\x4f\x97\x65\x51\x38\x4f\x25\x74\x87\xe8\xbe\x82\x40\xe4\x5e\x81\xd2\xeb\xc1\x03\x71\xbf\xeb\x6d\xee\x37\x28\xe3\x2b\xde\xb9\x50\xd1\x2e\x3d\xd5\xdb\xfa\x61\xa8\x13\x8d\xb4\x6f\xf1\xe2\xb1\xd1\xc8\xce\x42\x9b\xdf\x30\x0a\x37\xd7\x2b\x05\x56\x6b\x7f\xa0\xf1\x64\x42\x62\xa3\x69\x4c\x93\xd8\x29\xbc\x77\x0b\x8a\xc8\xbb\xb6\x7b\xba\xbb\xb6\xcf\x2d\xe4\x6e\xb8\x92\x3b\x67\x1d\xf6\x73\x2e\x9f\x0e\x5f\x66\x78\x5e\x51\x66\x6d\xb5\x7d\x11\xc1\x67\x21\xa4\x99\x53\xcd\xaa\xac\x65\x35\xa5\xbc\x58\xf4\x64\xce\xf5\x6a\x4d\x28\xc8\xa6\x55\x6b\xd7\x52\xb9\x5a\xa9\xa2\x94\xad\x65\x32\xc0\xaa\x1a\xb1\xb0\xee\x34\x25\xae\x4b\x56\xb4\x79\x51\x17\x8a\xba\x6a\xd5\x0d\x39\xd3\x6e\x4c\x56\x7f\xd2\x27\xde\x2d\xf3\x94\x26\x16\x0b\xb5\xda\xf0\x06\xac\x50\x4a\xbd\x23\x86\x6a\x9c\x9f\xd2\x7a\xec\xa1\xfa\xa9\x78\x99\x10\x96\x54\x64\xb8\xb1\x07\x7e\x51\x4f\xd7\x8d\x6e\x35\xb0\xef\x01\x19\x83\xff\x4c\x06\x99\x3d\x69\xf4\xfc\x8e\x41\x54\x25\x0c\xf6\x09\xff\x29\x3f\x41\xc1\x32\xe4\xd1\x61\xf8\xec\xdd\x52\x89\xdf\xff\xca\x88\xd3\xaf\xd8\x31\x90\xeb\xb5\x92\x0d\xbc\xfc\xc8\x08\xb8\x68\xcf\x95\x6a\x97\xba\x40\xd0\xfb\xe0\x98\xd0\xaa\xba\xa0\x7d\x0f\xd1\x9d\xe2\x33\xf1\x6b\x71\xe4\xae\x13\x9d\x17\xc8\xdb\x02\xdc\xa5\x3d\x48\x66\x2a\x90\xef\x15\xbf\x82\xbe\xf2\x2d\x79\xd6\xf3\x68\x12\xcf\x3b\xf9\x67\x47\x02\x3e\xdc\xa1\x07\xf6\x0d\x3d\x72\xd6\x39\x6f\x9c\xbb\x32\x75\x79\x8a\x48\x07\x82\xc6\x91\x20\x8a\xe0\xaf\xdc\x41\x91\x17\xdf\x77\x70\x4e\x4f\xc5\x6b\x8a\xcb\xde\x40\x41\x40\x76\x31\x66\xb3\x5a\x03\x39\x02\xde\x2f\xc4\x51\x40\xe0\xb3\x37\x33\xe5\x9f\x5f\x40\xe4\x4a\x42\xd5\xcf\x98\xeb\xfa\xed\xf8\xd1\xdc\xa5\x27\xcd\x1d\xfb\xd2\x5c\xd7\x9b\x06\xeb\x76\x63\xab\x3a\x34\x08\x76\xde\x57\xb8\xa9\x13\xca\xb5\xfc\x20\x30\x9a\x39\xf1\x7f\xc8\x39\xf4\x1f\x72\xfa\x16\xde\xe5\x35\xdc\xf1\xa1\x33\x98\x71\x91\x75\x93\x8a\x09\x27\x8f\xaa\xcf\xbe\x39\xbe\xb4\xbd\x8e\x3d\xc8\xa8\x8e\x86\xde\x0f\xd4\x0e\x0e\x8b\xc3\x0c\xdb\xad\x95\xe1\x51\xf8\x9d\x8f\x56\x98\xaf\x35\x68\xf6\x09\xac\xc2\x4a\xf4\xf9\x69\xdf\x4a\x30\xfd\xa7\x68\x5a\x5d\x1f\xe8\x9e\x2c\x28\xe8\x01\xb1\xd0\xe2\x5c\x1c\x1d\x9d\x25\x1f\x00\x79\x9a\xde\x9f\x1e\xaf\x81\x24\xa7\xe9\xb7\xae\xc6\x71\x14\xe7\x0f\x59\xa5\xdc\xa7\x14\x69\x02\xba\xff\xf5\xb9\x38\xfa\xb7\xfa\xdf\xea\x20\xdc\x44\xef\x91\x95\xa5\xff\x7a\x24\x7e\xcd\x86\xf4\x6b\x71\xf4\xd7\xe9\x51\x8c\x26\x90\x8c\x9f\x76\xf1\x5f\x00\x4f\x31\xd4\xec\xba\xdb\x23\xf2\xf6\x8b\xa7\xb0\xbc\x9d\x65\x88\xb1\xbc\xb3\x55\xdf\x76\x70\xbd\xed\x94\xd9\xa7\x74\xd2\xd1\xd0\x58\xb9\xa9\x65\xa7\xdc\xfc\x1e\xd9\x19\xf3\x8f\x55\x59\xab\x57\x80\xc7\x93\x43\x51\x10\xde\xc7\xae\x27\xf2\xf9\xcf\xa1\xd7\xbf\xe4\x06\xb4\xaf\x4e\x27\x07\xad\xe8\xb2\x1b\x47\xbe\x76\xe0\x83\xfd\x49\xe7\xd7\xe2\xa2\xbc\x82\x38\xbd\x85\x99\x62\xe6\xdc\xc7\x6d\x6b\x05\x6f\xc4\x34\x23\xbd\x04\x46\xbf\x2d\x90\x7a\x2f\x64\x59\x4d\x7f\x65\x20\x97\xae\x3d\x34\x93\x91\x87\x32\x4a\xb4\x9b\xa4\xd9\xed\xa6\xab\x09\x29\xa3\x46\xcb\x83\x09\x8d\x1e\x92\x51\xd6\x91\x57\xe1\x28\xb5\x7c\xd6\x0d\x96\x83\x3a\x5f\x4f\x96\xf0\x2a\x35\x59\x55\xff\x40\x11\x3e\x30\xdb\xbe\xe8\x1e\x5c\x0a\xc7\x43\x86\xcc\x2b\xf9\xe8\x1e\xa7\xdc\x86\x6a\x7f\x07\xba\xed\xbe\x78\x24\xbe\x24\xe3\x63\x91\x64\x2a\xcb\xe7\x0f\x52\x76\xe5\xbc\xf9\xf4\xfb\xa5\xc2\x53\x02\xcb\xb0\x81\x50\xdd\xc4\xc9\xd7\x21\x32\x39\xcf\x87\x57\xba\x50\x6e\x77\x43\x73\x9a\xe9\xbd\xa6\xe2\x9d\x03\x91\x2e\x5b\xf0\x4d\xb4\x63\x62\xec\xe0\x5d\xab\xa5\xed\x4a\x30\xad\xb4\x13\x29\xac\x20\xb6\xd0\x55\xa5\xb7\xa0\x1f\x05\x2e\x08\x22\x14\x17\x23\xe2\xca\x7d\x62\x7b\xd7\x5a\x58\x8c\x56\x93\x99\x36\xac\xc0\x08\x5d\x50\x9f\xeb\xc4\xf5\x4d\xb2\xbe\x89\x1f\x27\x48\x78\x60\x02\xd7\x89\x67\xbd\xc1\xe8\xaf\x39\xa2\xbb\x5c\xd6\x7b\xe3\xd4\x65\x70\x8b\xcf\xc2\x01\x2d\x8d\x97\xa1\x5a\x79\xa9\x84\x6c\x66\x65\xdb\xc8\x66\x07\x0e\x41\xe4\x5b\x38\x07\x42\x66\x76\xf5\x7c\xd9\xe8\x5a\x6f\x4c\xb5\x43\xcf\xca\x99\xba\x28\x6b\xd7\x98\x92\x17\xca\x4a\x81\x44\xbb\xb7\x74\xd2\xb3\x5e\x00\x12\x30\x5d\x29\xe8\x1d\xe6\x32\x1d\x50\x94\x46\x5e\x3e\xb9\xd7\x11\x11\x14\x6f\xd1\x0a\x9c\xf7\x9e\xeb\x1b\x56\xc6\xa3\xee\x97\xa0\xda\x71\x41\xb5\x07\x3f\xbd\xcb\x31\x39\xf0\x7f\xd2\xaf\xef\x4f\x2c\x1a\x78\xc4\xcb\x61\x25\x7d\xb8\x61\x08\xcc\xe6\xec\xa0\xcc\xd3\x90\x72\x53\xae\xed\x12\xc7\xf6\xa8\x82\x69\x79\x42\x73\xf6\x64\xca\x96\x3c\xad\x18\xee\x02\x37\xc1\xa1\xc7\x58\xc8\x09\x4c\xbe\x6a\x01\x66\x39\x34\xb7\xa8\xf4\xd6\xd3\xb1\x42\x47\x9d\x4e\x63\x2a\x87\x80\xcd\x3e\x29\xb6\xd6\xde\x71\x25\x34\xe7\xbf\xd0\xe9\x01\xe8\x08\x83\x00\xde\x52\x7c\x46\x0b\xf5\x99\xfb\x21\xe4\xb1\x9f\xa6\xec\xce\x13\x17\x7e\xb9\xa9\xcb\xc5\x0e\xfd\xd3\x4b\x6a\x69\x49\x5a\x2e\xf4\xdd\xd2\xcd\xe5\x3e\x18\x8f\x1f\x11\x51\xe0\xf0\x10\xef\xe4\x65\xbc\x99\x71\xed\x1a\xdd\x8f\xb6\xb3\x9d\xfe\x8f\x18\xee\x66\x63\xfc\x18\x29\x0b\x27\x07\x10\x14\x8f\x04\x81\x2c\x2d\x42\xaa\x46\xfa\xcd\x5d\x90\x4a\xb5\x1e\xbd\x7e\x91\x64\x68\x28\x34\xbf\x45\xdc\x97\x2f\xf8\x7f\x5a\x52\x5b\x49\xe3\x7c\xed\x1c\x6b\x8b\xf8\xec\x62\xae\x9b\x46\x99\xb5\xae\x0b\x86\x1a\xc3\xf1\x66\x1a\x55\x1f\x99\x7c\x53\x9c\x32\xdf\xe7\x88\x93\x50\x1a\xa7\xdb\x0d\x41\xee\x14\xf1\xa8\xfc\xec\xb7\x54\x33\x1f\x92\x3a\xd8\xfe\xbb\x4d\xa3\xf5\x39\x34\x9f\x2f\x15\x0f\x21\x94\x81\x7c\xc5\xfb\x07\xc3\xc5\xfb\x7c\x43\xbe\x76\xf8\x29\xa5\xd6\x51\x52\x8d\xf3\x4c\xa2\x07\x5b\xf0\x7f\x9c\x46\x6c\xc8\xb5\x28\xb0\x03\xeb\x93\xf5\x5c\x55\xb6\xa4\xbd\x80\x7d\x81\x98\x41\x82\xf2\x6f\x5b\x59\x28\x60\x04\x66\x4a\xc8\x19\x00\xcc\x07\x66\x00\x15\xf2\xa9\x73\x00\x3c\x83\xb5\x76\x0d\x42\x12\x77\x74\x09\xd7\xa2\xd0\x2c\x3f\x7f\x36\xaf\xa9\x30\x6a\x2d\xc9\x65\x52\x2f\x42\xc6\xff\xd3\x53\xbc\x0f\x47\x46\x90\xad\x7f\x07\x07\xd1\x63\x2d\xd9\xae\x77\xaa\x15\x0f\x13\x1d\xbf\x73\x58\x2d\xb4\xa5\x8c\x95\x6e\x7d\x7b\x74\x05\xc0\x09\x19\x06\x08\x15\x85\xac\x77\x5b\xb9\x9b\x8a\x6f\x69\x74\xc8\x9d\xd8\xdb\xc4\x86\x46\x7c\x91\x65\x50\x5d\x73\x7e\x59\xd0\x9b\xb1\xb3\x2a\xe0\xa7\x18\x56\xc3\x03\xed\xb8\xd9\x00\x6c\xbf\x0f\x1c\xca\xe8\x5b\x5d\xc9\x6f\x17\xfe\x79\xff\xfd\xb9\xaf\x0f\xa1\x1d\x2c\xd6\x2f\x76\xae\x84\x27\x95\xb9\xe7\x92\x2b\x0f\x03\x26\x72\x68\x57\xb0\x79\x68\x08\x99\x29\x55\x47\xcd\x91\xd3\xb2\x2a\xf8\x13\xaa\x62\x7a\xb3\x13\x17\x0a\x79\x1e\x60\xd4\xdb\x46\xd6\x66\xa1\x9a\x46\x15\x62\xb3\x9e\x86\xe6\x38\x37\xc0\x18\xb3\x90\x66\x66\x48\x4e\x83\x16\x44\x9e\xb0\xa6\x84\x9c\x67\x02\x81\x7a\x9f\xc2\x5f\x3b\x6e\x1b\xa7\xa7\x8e\x5b\x19\x8d\x6b\x7a\x0d\xef\x0b\x7f\x93\xff\xa4\xb7\xaf\x69\xff\x6e\xf9\x06\x53\x36\x82\xc8\x71\x55\xb4\xf2\xc2\xe0\xf1\x84\x24\x1e\x2e\x49\x8f\xac\xaa\x8e\x7b\xea\xc9\xd7\xae\xbd\xb7\x4a\x89\xd7\x6f\xc4\xff\xfc\xdd\xff\xfd\x1b\x51\x94\x66\xbe\x31\x90\x94\x62\xa1\xbd\xd5\x1b\x4a\x3a\x84\xea\xae\x9d\x25\xd0\x5e\x70\x6a\x73\x11\x3b\x01\xc6\x78\x74\x1c\x8f\x48\xe1\x9e\x07\x31\xaf\x0f\x30\x99\xe5\x9a\x0d\xf9\x82\xba\x23\xbd\x25\xf1\x2d\xe9\xf8\x53\x42\x84\x01\x9a\x2b\x80\xd4\x45\xc1\x09\x0e\xd0\xcb\x6f\xd3\x1f\xf5\x16\x48\x12\x5d\x63\xcb\x80\x7e\x0d\x3f\x96\xa4\xf1\x46\x0d\x39\x80\x4b\xd9\xa3\x5d\x7c\xcd\xcf\x6d\xe4\x6a\x92\xc6\x21\x70\x3e\xe9\x14\xa3\x89\xec\xb9\x41\x20\x43\x1d\xd8\xb0\x53\x27\xd7\x05\x45\x5a\xf0\x5a\x19\xe7\x63\x43\x47\x65\x58\x54\x09\xe5\x33\xde\x31\x43\xee\xeb\xb6\xde\x5b\x1e\x03\x35\x14\xb4\x45\xfd\xb0\x00\x2e\x70\x36\xb3\x0f\x8b\x0b\xe7\x50\x71\x64\x96\x73\xee\x0f\x24\xd7\x49\x83\x58\x0c\x92\xba\x18\x05\x51\x1f\x9e\xce\x1b\x72\xb5\x04\x21\xb0\x1b\x14\x36\xed\x12\x0f\x87\x28\x7b\x3d\x0d\x44\xe6\x61\x49\xdd\xe1\xce\xcf\xc5\x2b\x0d\x98\xb5\x5d\xa9\x31\x29\xfb\xd5\x60\x5f\x5d\xe1\x71\x0c\xc1\x8b\x84\xc6\xd1\x64\x25\xef\x11\xf5\x28\x61\xd5\x6e\xd1\x7b\x2a\x22\x16\x83\x30\xed\xd4\xf5\xe1\xa8\x4c\xa3\xc8\x5c\xd4\xfa\x8d\x90\x4c\x3a\xe4\x2f\x26\xd3\x51\x47\xd7\x8c\xdc\xec\x74\xb1\x6f\x42\x37\x89\xbc\xe8\x74\xf6\x4e\x7d\x18\xea\x67\xd0\x15\x32\xde\x0b\x59\x55\xf8\xc2\x36\x10\xd7\x1e\x1a\x8d\x22\xd4\x1a\x05\x52\x3d\x5d\x7b\x74\xf3\x95\x17\x4e\xb0\xf2\x30\x24\xb6\x85\xde\x88\x26\x72\x96\xe1\xa6\x39\x66\xf0\x18\x48\x60\xe0\xf2\x5a\xe2\x60\x9c\xbb\x4b\xc8\xbc\xc4\xa6\xb2\xf7\x54\xdd\xc0\x30\x18\xad\x5b\x92\xfd\x32\x5a\xb6\xc7\x3e\xeb\x59\xf0\xe0\x32\xa8\x02\xa6\x00\xbe\xa5\xae\x0a\x2b\x38\x30\xe6\x5b\x34\x9b\x3a\x49\x43\xe6\x1b\x84\xd4\x0d\xba\x56\xdc\xcb\x72\x9a\x4e\x30\xb0\x7e\x03\xcf\x7e\xb4\x18\x37\xd3\x03\xc7\x54\x83\xb0\x13\xfb\x48\xc5\x3e\x68\x45\xd7\x58\xa1\x16\x72\x53\xb1\x66\xba\xda\xca\xef\x6a\x2b\x0d\xd5\x62\x53\x63\xd4\x24\x4a\x64\xf2\xe2\xb6\xf4\x92\x7d\x96\x65\x78\xad\x9e\xcb\xb2\x1a\x96\x53\xaf\x8b\xad\x04\x2f\x6d\xab\x31\x9e\xc0\x9e\x93\x8d\x59\x9e\xae\xf5\x9a\x61\x19\xa0\x57\xd8\xf4\xb0\xd7\xe4\x0e\x79\xca\xdb\xe2\x7d\x47\x6c\x3a\xa5\xea\xc1\xb0\x2f\xda\xf4\xdb\xde\x70\xb7\x41\x8f\x8b\xc2\xa7\xbe\x71\x4a\x26\xb2\xec\xc8\xda\x05\x9f\x00\xc6\x29\x94\x20\xed\x29\xf9\x46\xaf\xca\x16\xc9\x60\x8e\x2b\x8b\x3c\x20\x9f\x35\x0d\xb7\x7d\x3a\x4a\xbb\x55\x65\x53\x50\x68\xa5\x43\x5e\x2d\xb4\xf8\x0c\x03\x2b\x3f\xc3\xe3\xfe\xdf\xff\xf9\x5f\x2c\x38\x7d\x01\x87\xd2\xc5\x9c\x9e\x9e\x0a\xbd\x69\x9c\x86\x0b\x9d\x46\xa6\xe2\x9b\xa0\x7d\xae\xb5\xa8\x74\x7d\xe1\xfc\x9b\xa5\xe5\xa7\x49\x49\xf1\x59\x40\xd7\x75\x6d\x41\xb4\x6e\xa9\x6b\x33\xf9\x8c\x71\x8b\x3e\x54\xa4\x0b\x42\xdc\x6a\xb1\x92\x97\x4a\x80\x2c\xed\xc3\x7d\x3d\x97\xd8\x22\x4c\xec\x94\x18\xf3\xe7\x65\x6d\x4f\xfb\x4c\xb5\xad\x6a\x20\x22\x19\x5c\x6e\x69\x8d\x4b\x33\x11\x6b\xd5\x2c\xe5\xda\xb8\x75\x96\xa0\x79\x70\xcd\x5d\xa8\x5a\x35\xb2\x12\xfa\xca\x96\xda\x54\x76\x12\xb8\x2d\xd0\x86\xf7\x43\x3c\xc8\xd6\xeb\xf3\x4e\xe4\x22\x71\xb2\x65\xef\x77\x33\x7c\xec\x69\x3b\x2a\xdd\x31\x2e\xfc\x1d\xb1\xb5\x49\x3c\xbf\xd3\x1d\x4d\x28\xe0\xe8\x02\x94\x55\x33\x84\x86\x5f\xad\x37\x2d\x7a\x32\x34\x41\x5b\x13\x00\x59\x5c\x7b\xad\x16\x45\xa3\xd7\x50\x8c\xe5\xeb\xcc\x3a\x15\xc7\x7a\xd7\xb0\x63\x49\xb1\x48\xa5\xc9\x62\x10\x4f\x4f\xc5\x77\x35\x86\x87\xe7\x60\xa8\x43\x02\x27\xf6\x96\x7b\xec\x74\xdb\x0e\xb4\x92\xf3\x73\xf0\x23\xb9\x5b\x88\xf8\xb3\xde\x43\xe3\x13\xdc\x47\x0f\x40\x0c\xfb\x31\x0a\xdc\x29\x7b\x8e\x53\x41\x36\x86\xe3\xd9\x53\xc9\x49\xa5\x31\xea\x4f\x12\x6e\xb4\x5f\x0b\x45\x65\x70\x42\x5e\x98\x7c\x14\xfe\x3a\x09\x5f\xc2\xc3\xfd\x28\xfd\xc1\x36\x77\x76\xef\xd3\x59\x9a\xf0\xe4\x09\x46\xba\xa8\xeb\xe5\x3c\x09\xa9\x4c\x10\xf4\x9c\x25\x5c\xa0\x8c\x22\xf1\xef\x3e\x6b\x04\xfc\x6a\x19\xf8\xbe\x1a\xfc\x9b\x4f\x58\x01\xb6\xc4\x17\xc8\x87\xfb\x44\x36\x58\xab\xfb\xcd\xd5\x5a\x94\xb5\xac\xca\x7f\x57\xfc\x1b\x19\x9a\xb1\x6a\x4f\x01\x9f\xbd\xa4\x51\x6b\xd9\x28\x0f\x4a\x47\xb5\xa2\x9f\x7d\x02\x8b\x8d\x4b\x2b\xed\x8a\xb9\x5f\x7c\x6b\xaa\x31\xa5\x69\x55\x34\x65\xf6\xe3\x19\xad\xe7\x85\x02\x1e\x63\x28\x6d\x4a\xae\x88\xef\x46\xaf\x07\xd2\xb4\x44\x1f\x5d\x95\x0b\xd5\xf6\x57\x89\x3f\x66\x7a\xc9\xe6\x75\x49\x3e\xbb\xb9\xd1\xd2\xbd\xd3\x18\x7c\x06\xc2\xdc\x50\x3a\x95\xa1\xf2\xc9\x2e\x45\x65\x92\xf3\x35\xaa\xdd\xdc\xb9\xb3\xf3\xd8\x9b\x42\xa6\x53\xe8\xec\x5e\x07\xc2\x9a\x50\x75\xf3\x1a\x63\xcb\x20\x51\x7e\x68\x8c\x58\x44\x53\x72\xed\xa1\xff\xd0\xea\x85\x5c\x14\xe2\xfc\x49\x06\xca\x51\xd6\xad\x37\xe2\xc8\x5a\x60\x57\x8f\xeb\xc2\x97\xd8\x1f\xae\x82\x75\x32\x4a\x3a\x0a\x4b\xcd\x8f\x7b\xa8\x45\x02\xbd\x8e\x9b\xc3\xab\xfa\xb8\xaa\x50\xbc\x74\xb6\xd5\x8e\x36\x36\x72\x52\x45\x0f\xaa\x61\xfa\x0d\xee\x14\x11\x8c\xa8\xfd\xd7\x9e\x4c\x52\x4e\x8f\x4b\x26\x3e\xe8\xa8\xeb\x26\xef\x9a\x8e\xd2\xd3\x07\x4d\xfd\xc7\x8f\xa2\xf3\x15\xa2\xa2\x73\x1f\x50\x22\x4d\xc1\x10\x93\xe0\x3d\x54\xf3\x93\xa7\x34\xb0\xb0\x14\xe8\xeb\xba\xf4\x31\xb3\x47\x29\xc2\x49\x67\xac\x89\x18\xdf\xb5\xee\x1a\x48\xc1\x44\x95\x76\xeb\x0e\x66\x8a\x6f\x31\x30\x82\x1d\x1f\x1e\xff\x39\x5a\xef\x3a\x4a\x44\x49\xbb\x18\xca\x86\x4f\x2e\x13\x43\x6a\x43\x66\xdb\x12\xf2\x7c\x65\xfa\x77\x43\xe4\xbd\x33\x67\x9a\xcc\xa7\xfc\x61\xe3\xcb\x92\x33\x21\xb3\x29\x84\xf6\xd2\x41\xf3\xd1\x76\x96\xa3\x5b\x8d\x2f\x4b\x92\xe4\xbe\x1b\x4d\x7a\x05\xea\x9d\x77\x9a\xeb\xb3\xae\xef\xfc\x3d\x1f\xeb\xaf\x7b\x1f\x4a\xe6\x1c\xab\x08\xc6\x0e\x03\xe0\x75\x75\x85\x62\x69\xad\xb7\x77\xe0\x43\xe5\x08\x1c\xa4\x6e\x84\xd0\x5c\xef\xf4\x6b\x87\x07\xde\x6c\xc4\xd0\x14\x53\xf1\x4a\x6f\xb9\xe5\x93\xbc\xd9\x8c\x65\x55\x8b\x04\xf2\xf1\x45\x2b\xb6\x6e\x1a\x75\x39\x57\x2c\x26\x72\xb5\xa9\xda\x52\x98\x56\x5e\x50\x2f\x8d\x5a\x5b\x19\x11\x50\x9d\xec\x2c\x5c\x4b\x06\x52\x1e\xf3\x0c\xb3\xba\x11\xb2\x15\x76\x56\xad\x68\xad\xcc\x00\xf5\x7d\x5e\x9f\x1a\x93\xcf\xeb\x5a\x99\xa9\x78\xe2\xcc\x45\x5e\x40\xb0\x52\x6f\xa3\xfe\xb6\x41\x4c\xb6\xa2\x28\x29\x66\x68\x51\xaa\xaa\x48\x31\x9a\xb6\x12\x71\x08\x20\x05\x91\x0e\xaf\x88\x9f\xe7\x5b\x07\x0b\xe5\x5a\xa4\xde\x51\x0c\x6d\x02\x9a\xf5\x2b\xdd\xaa\x47\xb1\x83\x14\x30\x31\xa8\x0e\x90\x55\xab\x1a\x08\x27\x46\x3c\x8b\x17\xd4\x7f\xbb\x2c\x6b\x70\xb5\xb6\xab\x6d\x44\x78\x8b\x98\x5e\x13\xd7\x10\xc6\x60\x45\xec\x85\x6e\x84\xba\x52\xcd\x8e\xa1\x9d\xf5\x6a\x53\xf9\x71\x0f\xe7\xe0\x9b\x4d\x09\xd8\xb8\x2c\xff\xaf\x49\x76\xd6\x92\x3d\xd9\xd0\x08\x00\xf6\x01\xc5\xe9\x56\x37\x76\x7f\xf4\x5a\xfe\x6d\xa3\xc4\x52\x55\x96\x09\x83\x33\x2a\x9e\x44\x70\x04\x98\x54\x02\x1f\xdc\x73\xf1\x67\xba\xb5\xa3\x1f\xb1\x24\x02\xda\x9e\x80\x29\xad\x79\x37\xf4\x19\xbe\xae\xbb\x50\x3d\x31\x8c\x3c\x05\xad\x52\x8f\x3c\x22\xb9\x93\xd9\x74\x18\xb7\x66\x4e\xae\x4b\xbd\x12\xe5\x41\xb9\x81\xb2\xf9\xab\x47\x3a\x97\x1d\x64\x8f\xf7\x6b\xef\x1d\xc9\xd0\x2f\xaa\x8f\x81\xc0\xe0\x4f\x5d\x57\x3b\xe7\x1d\x62\xef\xf7\x9a\xb2\x3d\xe3\x3d\xb2\x94\x83\x12\xcb\xce\x36\xad\x27\x1b\x8d\x9a\x6f\x1a\x63\x2f\xd9\xb6\x16\x65\x70\x46\xe1\xb8\x79\x0b\xd0\xee\x50\x8e\x27\x07\x28\x80\x70\x68\xd3\x3d\x0c\x0c\x7b\x04\xef\x84\xff\xe0\xaf\x5a\x57\x42\xf2\xcb\x86\x2f\x8f\x47\x61\xdf\xc7\x4f\xe4\x99\x18\x96\xc4\x0a\xe8\xe6\x1a\x4a\x38\x74\x95\xd6\xe1\xe2\x45\xd4\x8a\xa0\x62\x22\x3b\x80\x5b\x6a\x96\x83\xcb\x65\x5c\x23\x04\xf3\x0b\xd5\x72\x1f\x50\x00\x79\x51\x72\xbe\x74\x09\xc2\x22\x58\x3a\x70\x9b\xc3\xa1\x84\xb4\x7c\x3f\x15\xee\xc6\x75\xbd\x87\x21\x89\xd9\x91\x5f\x58\x23\xce\x1a\x05\xb0\xd8\x54\x14\x0d\x8e\xd7\x69\x99\x10\x1c\xdc\x57\xe6\x1d\x8a\xc0\xe1\xb3\x5d\x44\x27\xcb\x73\xdb\xbc\xaa\xe5\xac\x52\x2f\xe1\x4b\x7d\x11\x32\x30\x47\x9e\xd2\x2f\x9d\x5a\x60\xa5\x0b\x77\xd6\xf3\x63\x0e\xfa\x97\xfe\x3d\x80\x37\x5a\xaf\xdd\xc2\x9e\x65\x1a\x0c\x13\x64\x0a\x9d\x61\xb8\xda\xd7\x72\x57\x69\x7b\xc7\x10\xbd\x47\x57\x05\x65\x2a\xa9\xd5\x96\xfe\xd6\x90\xd1\x83\xfc\x62\x50\x48\x4e\x46\x86\x8f\xee\xbb\xdd\xda\xbd\xf9\x6b\x35\x2f\x17\xe5\xdc\xa3\xf1\x38\xe3\x46\x88\x7c\xf6\xd5\x13\xe2\x18\x43\x00\x47\xa3\x3c\x4b\xa8\x4e\xf0\xed\x10\x6b\x2c\x21\xca\xba\x28\xe7\xb2\x75\x90\x94\x1e\xb4\x50\x52\xbc\x83\x7d\xfc\x4b\xf2\xb7\xe3\xad\x41\x91\x5a\x6d\x31\xe4\x54\x81\xf0\x4b\xf9\x3f\x4d\x90\xc6\xa7\xe2\x31\x11\x7c\xb0\x50\x00\xaf\x54\x23\x5e\x24\x98\x47\xbe\x67\xc1\x66\x1c\x9e\x98\xc6\x1f\x5f\xa9\x7e\xd5\x40\xf7\x9a\x65\xb6\x9b\xce\xea\x88\x9d\xd6\x55\xf1\x0e\xf4\x78\xb5\xda\xa6\xcf\x43\x58\x48\x50\xff\x14\xe5\x62\xa1\x1a\x33\xc1\xf9\x13\x0a\x59\xdf\xec\xeb\xbd\xb3\xa7\x9e\x91\xb8\x76\x3b\xbf\xd6\x1a\xa4\xc9\x96\x3a\x92\x89\xbb\x95\x81\x7d\x01\x39\x84\x52\xfa\x17\xb1\x19\x94\xc1\x90\x05\x6d\x5c\xf7\xa6\xbf\x76\x1f\xdb\x9e\xbb\x1e\x0a\xa0\xc4\x0e\x29\x07\xd9\xbd\x07\x36\xad\xd2\x35\xd7\x95\xb2\x1e\xa7\xd1\xb7\x09\x5b\x21\x64\x4f\xfc\xfd\x83\x17\xfc\xad\x6a\xd3\xea\xf9\x52\xbc\x21\x64\x04\xe0\xcb\x3b\xbd\xaf\xbd\xe1\xc2\xbc\x59\xa7\x46\x8d\x0b\x21\xd3\xca\x5b\xec\x2d\xc7\x31\x45\x1e\xd7\x62\x53\x2f\x74\xd3\x6e\x40\xd6\x70\x21\x92\x1d\xce\x2f\x86\xb6\xb6\xbc\xdd\x56\xd3\xd9\x85\x58\x1e\xf4\x97\xb7\x34\xc7\x78\x5c\x62\xbb\x03\x9d\x86\xd8\xe4\x52\x35\x78\x32\xe5\x81\xd7\xf1\xb6\x19\x4d\x71\x0d\x66\x53\x8c\x65\x38\xc5\x5e\xa6\x53\xdc\x0e\xe3\xb9\xff\xcc\xe5\x56\xb9\x87\x27\x15\x07\xf3\xa5\xe2\xb6\x78\x53\x71\xfb\xfc\xa9\xd8\xcb\xa3\xe6\xe6\xdb\xcf\xa7\x8a\xb1\xbc\xaa\x18\xe6\x57\x45\x86\x67\x15\x19\x94\x89\x11\xbc\xab\xc8\xf0\x8c\x71\x43\x63\xf9\x58\x71\xeb\xbc\x6c\x7e\x6c\xf1\xe8\xf6\xf0\xb5\x69\xf1\x03\xf9\xdb\x74\x1f\x22\x1e\x57\x0c\xbf\xfb\x87\xf2\x8d\xa0\x68\x80\x53\xf6\x6d\xf3\x66\x1c\x74\x3e\x3d\x57\x74\xd0\xbf\xab\x5d\x7e\x91\x4e\xcd\xc8\x42\x7d\x7e\x1e\xf9\x69\xb1\x40\x20\xde\x48\xbc\x15\xc0\xd4\x12\x6b\x66\x26\xe4\x2c\xa6\x1c\x76\xb4\x0f\x32\xed\xe6\xf7\xea\xc0\x7a\x07\x84\x37\xb7\x38\x7c\xd2\xb1\x63\xf7\x59\x52\xab\x56\x5b\xf6\x0e\xf6\xbc\xa5\x81\x5a\x75\xf0\x6d\x7a\xdf\xb6\x50\x67\xc2\x3b\x39\x49\xcf\xe3\x18\x36\x28\x3e\x70\xd1\xe4\x5c\x72\x12\x0e\x45\xe0\x3b\x3b\x8b\x97\xfb\xc5\x82\x61\xc7\x77\x52\xc8\x4c\x78\xa4\x6f\x2e\xaf\x39\xc3\x3a\x15\x5c\x1f\x96\x79\x50\x8f\xd9\x20\x7a\x9d\xe2\x68\x54\x21\xbd\xaa\x37\x7c\x51\x7a\xe8\xb0\xa3\xad\x16\x66\x2b\xd7\x10\xbd\x13\x7d\x99\xde\x1e\x53\xfd\x7f\x52\x86\x8a\xc2\x80\x6a\xed\xf1\xf6\xa5\x31\x7a\x5e\x02\xeb\x00\xb6\x41\x8a\x13\x28\x14\x3d\x61\xb5\x65\xc2\xf5\x22\xf6\x3c\x71\x29\xc5\x9d\x4f\x7b\x24\xac\xd9\x06\x2e\x36\xb2\x91\x75\xab\x18\xec\xbf\x4f\x03\x07\x1b\x8e\x1a\xf6\xd5\xf4\x76\x69\x02\x53\x57\x72\x1f\x00\xd2\x4c\x66\x28\x51\x96\x88\x88\x07\x0f\xe2\xb5\xef\x79\x39\xae\x4d\x5e\xbc\x4a\x9c\x61\x97\xe1\x6d\x69\x14\x9a\x2b\x24\x00\xdc\x95\x7a\x63\x90\xaf\xe7\x75\x07\xc0\x20\x92\xb9\x9f\xed\x23\x68\x8d\x9a\xef\xe6\x15\x07\x6a\x1d\x45\xbf\x3d\x5d\xe3\x8b\xcc\x45\x8c\xe3\x64\x20\x07\x9c\xe5\x6c\xe8\x16\xdf\x9d\x49\x66\xd4\xbd\x34\x33\x71\xbf\x38\x66\x63\x76\x83\xd8\x77\x8d\x6e\x4e\x4d\x07\x36\x8c\x8d\x27\x9d\xc2\x9e\xb7\x2d\x7b\xa9\x11\x3e\x3b\x8a\xef\xa3\x04\xf5\x11\xe8\xf4\xa2\x92\x17\xe1\xa2\x5b\x29\x7c\x29\xaf\xc0\xbd\x2c\x3e\x69\x18\x4b\x7c\x05\x81\x81\xe0\x5d\x8d\x9e\x69\xb5\x6e\xc9\x3b\xad\xd5\xc2\x1e\x77\x02\xc3\x91\xf5\x0e\x40\x71\x3b\x4d\x84\x8c\x18\x28\x3b\x19\x82\x23\x0f\xa9\x57\xd8\x2c\xd4\x36\x92\x4d\xd6\x8d\x5e\xcb\x0b\xc8\xbb\xb6\xde\xca\xa6\x30\xd3\xeb\xec\x46\xf7\xf8\xdf\xc1\x73\x95\x79\xb0\xe2\x03\x37\xea\xbc\xdc\xb9\x52\x66\x94\xea\x24\xd1\xdc\x38\x50\x72\xaf\xc1\x41\xa1\x04\x99\x19\xd2\x6d\x11\xd6\x25\x51\x04\x7b\x20\xca\x68\x79\x5c\x76\xa5\xce\x15\x43\x10\xda\x8e\xdb\x51\x8c\xf4\xc7\x48\x7b\xec\x51\x14\x7b\x11\xc5\x95\x86\x48\x65\xc7\x23\xec\x98\x16\xa2\x87\x10\x4c\x32\xdd\xef\x63\x3c\x10\xff\xd9\x1d\x21\xa6\xf5\xa2\xfb\x26\x6b\xba\xac\x13\x4c\xc2\xe9\xaf\x19\x5d\x10\xff\x96\xe0\x83\xd7\x77\xc9\xdc\xab\x5b\xa9\xd6\xb0\x90\x7e\xc3\x2e\x98\x37\x19\xd3\x73\xde\x2e\x55\xd9\xc4\xa1\xc9\x74\xea\x6f\xc8\xef\xec\x55\xa0\x31\x5d\xd6\x78\x15\x5a\xaa\x31\x7b\xa5\xf5\xba\x47\x57\xf6\x4a\xa3\x8e\x4c\xaf\x15\x5a\x04\xcd\xcf\x5b\x39\x3e\x3c\xb2\x5b\xd3\xe3\x76\xbb\xd9\xbb\xd3\xb6\xca\xa8\x3d\x8e\x0c\xb1\x73\xe6\x3c\x7a\xed\x50\x91\x3f\x90\xb7\x7d\x65\xd9\xd3\x96\xa7\x06\x22\xce\xe5\x40\xb0\xf9\x6d\x3f\xd6\x7c\x5f\x53\x39\xa8\xf9\x5e\x67\x78\xd5\x97\x29\xe1\xe3\xc7\xec\x54\xd1\x93\xdd\x96\x88\xce\x7e\x88\x31\x73\x51\xa7\x64\xd6\xdf\xd4\x95\x87\xbd\xdc\x42\xee\x8f\x22\x4a\x99\xc0\xa0\xb1\x3a\x54\x93\xaf\x49\xec\xdb\x7f\x60\x78\xe6\x98\x00\xc9\x4e\x2c\x56\x5f\x14\xce\x0f\x29\xa5\x05\xee\xa1\x52\x48\x58\xd1\x4c\x84\xa9\x23\x26\xc2\x68\xc1\xe3\x81\xca\x85\xa5\xa2\xd3\x48\xde\x5d\x8f\x8e\xe8\xc9\x0e\x35\x90\xc1\x9e\x18\x9f\x1f\xe2\xde\x86\x02\xc8\xa3\xbe\xd6\x7a\x3d\x26\x67\x67\xe7\xa9\x04\x3f\x9d\xd1\x0a\x19\xc7\x34\x53\x9d\xde\x5c\xa7\xf8\x27\x94\x0b\x90\xf7\x7d\x75\xcf\x7a\x6a\x26\x19\x4f\x53\x41\x2e\xc1\xdc\xcd\x05\xa1\x0c\x25\x5b\xec\x53\xd4\x52\xea\xb8\x09\x1c\x07\xa3\x23\xd9\x94\x92\xeb\x59\xb1\xb6\x51\x2b\x59\xd6\x10\x26\x4f\x0f\x64\x57\xb9\x0a\x15\x1b\x05\xa8\x25\x9d\x8c\x74\x22\xe7\xe0\x3b\xb4\x65\xe1\x0d\x07\x37\x26\x7c\xc5\x97\x72\x7e\xb9\xa3\xa4\x71\xa0\xa5\xff\xc0\x52\xff\x0d\xe4\x10\x14\xa2\x1b\xbf\x7f\xcd\x3c\x82\x62\xc8\x17\xf7\xc1\xb9\xf8\x0f\x96\x4c\x90\xef\x5d\xf8\x7b\xe6\xd5\xbd\xf9\xdd\xda\x43\x0f\x62\x5f\xf4\x7d\x57\xe5\x66\x3c\xe9\xbe\x74\x6a\xdd\x03\xcc\x51\xf8\x7b\x19\xd4\xfb\xfb\x8e\x32\x25\xda\xf7\xae\x73\x98\x28\x4f\xac\x94\xac\x4d\x40\x43\xf7\xfa\x2e\x82\xd9\x23\x09\x30\x6d\xd3\x67\x21\x92\x1c\x21\x86\xf9\x37\x76\x14\x3d\x6e\xfa\x8e\x6b\x61\x6a\x96\x1e\x5c\xbd\x68\xf8\x17\xaa\xa5\x36\x0b\x6f\x6d\xcb\x29\x9a\xa8\xcc\xc4\x5b\x52\xd2\xe6\x10\xac\xc6\x3d\xc2\x10\x11\xc5\x59\x6e\xaf\x8e\x59\xf5\x5c\x8f\xb7\xeb\xaa\xe4\x30\x0e\xe2\xf1\xeb\x17\x96\x41\x27\x9c\x1f\x94\x63\xe0\x41\x85\x0e\xae\xcc\xb4\x93\x58\xc8\xb7\x08\x92\xb2\x8b\xc7\x73\x8e\x9f\x25\x13\x31\x1d\xc1\xe0\x09\xbe\x0a\x01\x79\xb3\x2a\xcb\xfb\x77\x97\xf7\x80\x30\xa3\x50\xe9\x60\x31\x89\x3b\xaa\x78\x95\x57\x1c\xa3\x72\x5c\x26\x6a\x93\xd1\xec\x6a\x4e\x6e\x3a\x39\xbb\x17\x75\x7f\x50\x9c\xff\x0d\xb9\xe7\xa4\x6b\x0e\x10\xeb\xd0\xec\x93\xa5\x6e\xd4\xa2\x6b\xe2\xe9\x89\x5f\xe8\xb7\xf9\x64\x75\x10\x00\x98\xe6\x46\xdc\xed\xe4\x7e\xca\x54\x71\x02\xb1\x07\x98\x12\x92\xce\xba\xeb\x41\xc7\xd7\x1e\x66\xfb\x2f\x88\xdb\xbb\x3b\x3c\x4a\x7e\xcb\x6c\x0f\x18\xfd\x0b\x78\x88\xee\x09\x82\xcc\xa7\x11\x7c\xb2\xfb\x93\x7d\x01\x44\xca\x11\xe0\x91\x7d\x7f\x8d\xa3\xee\xaf\xfe\x4b\x7d\xa5\xd2\x10\x33\x48\xba\x46\x31\x70\x40\x33\x2f\x95\x5a\x5b\x99\x1d\x72\x2c\x70\xac\x23\xd6\xdc\x67\x90\x7c\xe4\x33\x97\x34\x04\x85\x6f\x00\x9b\x74\x6e\xa5\x51\x58\xa4\x25\x7f\xda\xae\xaa\xef\x29\x6d\x50\x37\x91\x14\x24\x0a\xe5\x21\x45\x61\xf1\x22\xbf\xec\x25\xe8\xc9\xd6\x0f\xbf\x02\x1b\xb2\x6e\xd2\xc6\x66\xba\x6d\xf5\xea\xe1\x57\x9b\xf5\x54\xbc\xf3\xe5\x4a\x23\x16\xd2\x58\x4a\x55\xd6\xe2\xc5\xb3\xdf\xfe\xb6\x4b\x7b\xb6\xd2\x50\x0c\x13\x50\x83\xc3\xd8\x19\x90\x71\x42\x03\xdd\xa3\x1d\x6f\x03\xfa\x42\xd9\x85\x8a\xf7\x03\xbc\xf1\x29\xfd\xb0\xc2\x05\x7b\xed\x63\xc4\xa3\xc6\x5a\x6d\xb7\xc7\x68\xcc\xc2\x92\x1e\x2a\xca\x04\xd8\x1b\xf1\x95\x4d\x60\x9f\x21\x65\x99\x03\xd7\x51\x10\x0b\xa6\x5b\x04\xd3\x80\x53\x17\x3a\x3e\x11\xb5\xae\xce\xa7\x1d\x60\xf5\xd6\xeb\xaa\xc4\xa7\x80\x03\x58\xb0\xd6\x90\xcf\x7b\x08\x01\xf2\x1d\x0f\x32\xb3\x71\xe0\x06\xfc\xcf\x38\xd5\xa8\xe8\x98\xa6\xb3\x84\x8a\xee\x1b\x7b\x8f\xe2\x9d\x3a\x1e\xa5\x4c\xcf\x2e\x60\x5f\x46\xc2\xf0\xa7\xab\x56\x7d\x5f\xf6\x2b\x55\xbb\x67\xe3\x89\x6a\xec\x38\x5c\xfc\x71\xe3\x03\x16\xdc\xb2\x02\x06\xb5\x53\x9b\x83\xe6\x92\x70\x59\x10\xd9\xb5\xdb\xe2\xb1\xba\x10\x4f\xbf\x7d\xe9\x5b\x14\x66\xb3\x5e\xeb\xa6\x35\x42\x6e\x5a\xfd\x70\xa1\xe7\x1b\x6c\x68\x4e\x5d\x53\xaa\x65\x73\x92\x69\xec\xa5\x0f\xfa\xb7\x1b\xc9\x46\x69\xb9\x24\xc7\x9a\x15\xd0\x1c\x24\x1c\xcc\x92\xcd\x21\xab\xc7\xfb\xf4\xf1\x3e\xd4\xe6\x71\x93\xe3\x34\xa8\x85\xf5\x23\x1b\x24\xf5\x07\x25\x9e\x11\x89\x69\x84\x50\x78\x16\x48\xc2\x7d\xd6\xd4\x6c\x12\x4e\x09\xc1\x12\x33\x39\xbf\xbc\xf1\x6b\x7f\xb0\x4c\x13\x03\x13\xa5\x96\x3a\x52\xca\xa1\xc9\xa8\xc3\x59\x27\x40\x8a\x87\x4a\x15\xc4\xc8\x53\x07\x87\xf0\xf1\x37\x10\x43\x3a\x22\xb5\xbe\xa6\x18\x32\x0e\xbc\x29\xa3\xe0\xdc\x6b\x21\x62\x69\xd5\xdc\xfa\xdb\x33\x77\x64\xda\xa6\xac\x2f\x8e\x7e\xe1\xd7\x7a\x4f\x77\x7a\x05\xe8\xf9\xb8\xbe\xa8\xdd\xcb\xef\x7d\x3e\x4a\xb6\x79\x7f\x63\x66\xe6\xfd\x20\x37\xd3\xc7\x5f\x44\xf6\xa5\xa4\x8f\xdb\x24\xb2\x3d\x6f\xf6\x35\xed\x5f\xf9\x7d\xca\x3e\xde\x9f\x0f\x9a\xc0\x6e\x42\x13\x87\x41\xc9\x6e\x25\x66\xf5\x2c\xed\xaf\x17\xcf\xad\x03\xde\x56\xeb\x2d\x30\x6e\x84\x16\x84\x7c\x19\x44\xda\xdd\xeb\x59\xfc\x01\x10\xb7\x7e\xed\xf7\x10\x58\xda\x53\xad\x00\xd1\x33\xb6\x06\xf6\xb5\xd4\x8b\x33\x36\x0a\xfd\x6c\xbc\xca\xfa\x20\x7d\x5f\x66\x08\xa7\xa7\xe2\x19\x10\x38\x3b\x16\xc3\xc7\xb5\x0f\xdd\xf1\x3a\xd9\x6a\x81\xde\xce\x14\xe4\x77\xe6\x05\x83\x76\x15\x52\xf6\xd6\xb7\x8c\x91\x86\x79\x4c\x4c\x55\xd6\xed\x43\x32\x89\x3d\xac\xd5\x87\xf6\x61\x55\xd6\x4a\xd4\xfa\xe1\x42\x56\x15\x41\xda\x51\x85\x9f\x1e\xbe\x5b\x04\x22\xc3\xe5\xd5\x47\xd1\xbf\x62\x90\x98\xb2\xbe\xd2\x97\xea\x0f\x1b\xd9\x14\xaa\x78\x42\xcc\xd6\x3f\x7d\xee\xf2\x00\xc2\xd6\x7f\xd7\x96\x95\x99\x66\x4b\x9e\xdd\x73\x59\x31\xe5\xe6\x62\x89\xc5\xff\xe9\xb7\x99\xda\x71\x11\xac\x36\xaf\x94\x6c\xf6\x55\x4c\x0b\x9d\xdd\xcb\xa0\xdb\x50\x38\x4a\x16\xdb\x66\x2e\xd7\xed\xa6\x51\x50\x39\x40\xd9\x5c\xa8\xf6\xf5\x66\x56\x95\xf3\x2e\x36\x4d\xe7\xd3\x6d\x02\xbf\xb8\x68\xb6\x39\xa7\x3b\xdf\x97\x55\x45\xe0\x4d\xdf\x97\xed\x12\xc0\xa4\xf3\x46\xe2\x32\xb1\x39\x03\x96\x25\x90\x47\x44\xa0\xf6\x05\x8f\xe6\x99\xc6\xdd\x91\x89\x21\x8e\x86\x59\xcc\x18\xd9\x28\x53\x96\x81\xf1\xfa\xb2\xb9\xce\x1d\x1b\x60\x5a\xbd\x66\x23\x46\x64\xfd\x33\xc2\x38\x7e\x82\x9b\x45\x39\x85\xd1\x24\xa4\x76\xe4\xb4\x5f\xd6\xad\x6a\x9a\xcd\xba\x15\x9b\xda\x65\x8f\x9d\x72\x53\xb5\x91\x0b\x55\xed\x9e\xf4\x2c\x6d\xff\x2a\x32\x93\x79\xee\x32\x1c\x5b\x7a\x38\xd9\xbf\x65\x13\x41\x05\x3b\xfd\x38\x2a\xe3\xf2\xfc\xf0\x33\x7f\x7c\x92\xfa\x6f\xd3\xec\x90\xec\x9e\x67\xae\x09\xe7\xa8\xf8\xf1\x0e\x33\xe4\x4d\x24\xc9\x94\xbb\x16\x7e\x5c\xb6\xa7\xaa\x95\xf3\xa5\x15\xaa\xa8\x15\x0e\x21\x61\xe5\xb5\xb0\xf5\x0d\x22\xbe\xb8\xe4\x0e\x39\xc9\x2f\xc2\x3d\x19\x58\xd4\x46\x2d\xdc\xb2\x41\x03\xb1\x2b\xe8\xf0\x5a\xf9\xa1\x8d\x5b\xa9\xbe\xb5\x72\x0d\xe4\x7c\x68\x7a\x56\x0c\xd5\x14\x7f\x2a\x17\xea\xc9\x6e\x5e\x29\x06\x44\xbf\x60\x09\x20\xfc\x25\x25\x83\x3c\xff\x76\x00\xbe\x65\x3a\x61\xa6\xf3\x89\x5a\x1c\xb0\x23\xb3\x52\xcc\x5c\x48\x58\x40\xb9\xf0\x8b\x7e\x84\x41\xf7\x27\xa5\x3c\xbc\x13\x4e\x7e\x9e\x96\xc5\x4b\x4e\x7b\x58\x3f\x29\x15\x8a\xc6\x39\x20\xed\x66\x88\x52\xb6\x2a\xa3\x4c\x99\xaa\x9d\x11\xa6\x72\x4a\x9e\x54\x85\x3f\x03\x7a\xb9\x75\xa3\xae\x0e\x30\xc3\x85\x4a\x6f\xf7\x13\xd9\x6b\x6d\x01\xee\xf4\x4f\x7a\x0f\x48\xcc\xf2\x4b\x37\x09\x0b\x72\xe8\xc6\xf4\xc8\x38\xc1\xa8\xe6\xe2\x8d\xa3\x21\xb3\x4f\xe9\x0d\xe2\xb5\xfa\xb4\x5c\x48\x13\x1c\x81\x33\xc7\x09\x0c\x7d\xc6\x31\xba\x2b\x7f\x5d\xcb\x7d\x05\xe4\xe9\xeb\xcd\xeb\xfd\x98\x89\xa5\x8a\xe6\xa8\xf1\x38\x4c\x4d\x7c\x9d\xf9\xca\xc4\xdc\x47\x19\xb5\x44\xba\x6e\xef\xa3\x85\x7b\x7f\xf3\x95\x1b\x41\x52\x7d\x2f\x9f\x0f\x10\x55\x56\x07\x24\x50\xa7\x15\x5e\xc9\x5d\xd0\x94\x6d\x29\xab\xce\x4c\x61\xb8\x34\xe6\x92\x8f\x61\xbd\x30\x9b\xda\x0a\x7d\x3d\xe2\x56\x3b\x7a\xec\xa8\xf1\x44\x97\x5d\xd6\xeb\x4d\x8b\x66\x9a\x85\x6e\x56\x60\x0e\x6b\x74\x15\xeb\xb4\x31\x1d\xa9\x09\xea\x74\x92\xb4\x20\x80\x75\xa6\x78\xfe\x98\xa5\xaa\xd3\x41\xa2\x34\x4d\x43\x9d\xc4\xcd\xca\x4b\x89\x75\xbc\x5e\xb7\xd6\x8e\x70\x9d\x7a\x05\xe4\xb4\x47\x2d\x7a\xce\xbc\x2e\x0e\x7c\xa0\x98\x9b\x47\xfc\xa4\x26\x4e\x1e\x31\xec\xce\x58\xca\x86\x0b\x82\x2f\x42\x38\x17\x4e\x53\x4f\xfe\x7b\xd1\x33\xdf\xeb\x26\xb5\xf7\x68\xf6\xeb\x98\xd1\x85\x8e\x52\xff\x88\xaa\x5c\xa8\x87\x73\x60\x35\xba\x01\x42\xea\x43\x64\x11\xd9\xdb\x69\xaa\x4b\xb8\x5e\xb7\x18\x92\x66\xc6\xf4\xdc\x11\x95\xa3\xd8\xe3\x8e\xd8\x0c\xc2\x71\x2a\x33\xbb\x63\xeb\x91\xf2\x78\xe6\xa4\xdb\x56\x06\xec\x63\xfc\x1e\xb7\x8e\x55\xce\xb1\x7b\x81\x5f\x8e\x8e\xdc\x08\xa6\xf9\x20\xee\x6e\x3f\x57\x39\x4c\x03\xed\x7e\x2d\x8e\x3b\xc2\xae\x77\x2c\x89\xd3\xa7\x47\x30\xe7\x99\x2d\xc5\xd6\x3a\xc4\x7a\x78\x1d\x07\x45\x0e\xfa\xe9\x4d\xbf\xe4\xc1\x4a\x74\xd7\x32\x7c\x3c\x66\x82\xc5\x27\x96\x4f\xe7\x3b\xa3\x9a\x87\xba\x29\x2f\xca\x1a\x11\x24\x48\xe8\x3c\xb6\xc7\xde\x9d\xfa\xba\x80\xcc\xf5\x27\xfc\xfc\x79\x39\xf4\x5e\x84\x2b\x0e\x7e\xad\x28\xa9\x56\xa8\x9c\x5c\x41\x1a\x84\xed\x14\xb6\x20\xd7\x15\x36\x8a\xcd\x04\xe9\x36\x6a\xb0\x6c\x8f\x8c\xd0\x97\x72\xd7\x5d\xbe\x44\xae\xe5\x38\x16\x64\x25\xd1\xf5\x13\x5e\x12\x88\xee\x91\x6b\x85\xd9\x4b\x92\x72\xbe\xc5\xac\x5f\xb1\xdb\x8b\xeb\x49\x30\x7d\xc2\x66\xea\xc7\x57\x8e\x8a\x17\x8c\x66\x3b\xa8\x7e\xe8\x9d\x3b\x1f\xd6\x01\xaa\x83\xbb\x62\x47\xc6\xac\xcf\x60\x1f\x3d\x7a\x7a\xde\x07\x1e\x9f\x57\x80\x0d\x48\x33\xf4\x22\x6c\x0f\x1c\xc3\x4d\x5f\x15\xf4\x2d\x71\x06\x48\x04\xc2\x28\xaf\xd2\x18\x4c\xf2\x1a\x97\x95\xd1\x70\xd3\x20\x0f\x3a\xe5\xe4\x43\x94\x8f\x38\x67\xab\xe8\x40\x2b\x6c\x4b\xc2\x66\x58\x6f\x2c\x51\xcc\xe7\x19\x19\x46\x75\xb2\x1c\x49\x8a\x02\xe5\xfe\x90\x5e\x25\xda\x47\x93\xdd\x23\x16\x5b\xd0\x0f\x2a\x63\xbb\xca\x20\xd1\xb8\x3f\x6a\xb5\x6e\x77\x2e\xb7\x89\x53\xde\x67\x3b\xdb\xbb\x53\x7d\x24\x38\x39\x04\x8d\xd6\x2d\x47\xd4\x03\xd4\x06\x8c\x32\x2c\x21\xa3\x2d\xd8\xee\x57\xfa\x4a\x15\xb1\xe9\x3e\x86\xd5\x98\x4b\xc2\x93\x87\x1c\xfc\x60\x1b\x02\x39\x81\xa2\xbc\xcb\xba\x56\x08\x5e\x62\xbc\xb7\x69\xbb\x54\x3b\xdb\x8d\x6b\x7d\xb6\x73\xc8\x2a\xae\x21\xc0\xd5\x74\x99\x20\xbf\xa7\x53\xc2\x7b\x14\xd9\x7b\xaf\x6b\xc1\x46\x03\x45\x4c\xd9\x42\xcf\x0b\xed\x30\x23\xc3\x5c\xe0\x74\xe2\x10\x00\xd3\x03\x06\xd1\x28\xc5\x92\x15\xfb\x27\x8a\x40\x1d\xec\xa2\xe1\x7a\x13\xca\x45\xdb\x6c\xd8\x5e\xc6\xc4\xba\xe6\x37\xeb\xf4\x54\xfc\x6b\x69\x4a\x06\xd3\xcf\x97\x03\x98\x7f\x8a\x7b\xc7\x2c\x95\x7e\xf4\x42\x37\x61\xcc\x86\xa5\x1f\x7e\x7b\x59\xae\x1d\x6f\xe6\x1b\x8b\x47\x70\xc2\xb2\xd6\x5d\xd9\xde\x0d\xbe\x55\xfe\x52\x86\xab\xd2\x83\x46\x62\x8f\xed\x71\xe8\x13\x5d\x0f\x6c\x47\x5e\x43\x6e\x4f\x44\x63\xaf\x22\x3a\xb7\xd5\xad\xf6\x83\xc2\x3b\x1d\x0d\x49\xc8\x99\x0e\xb4\x20\xc9\xc3\x30\xb6\x5d\x14\x42\xe2\xcc\xe4\xf7\x7d\x45\x8e\x61\x73\x3f\x86\x91\xf9\xd1\x31\x00\xf9\x25\xeb\xde\xd8\xbb\x47\xfe\x4b\xfb\xff\xe9\xe1\xfd\x79\x22\x55\xc0\x3b\x08\x66\x9e\x94\xcd\x39\x3d\x15\x4f\x36\x56\x46\x58\x30\x60\x58\xb1\xd6\xc0\x47\x81\x23\x5f\x51\x9a\xb9\xae\x6b\x35\x6f\x21\x22\x3a\xbe\xcd\x2f\x30\x89\xee\x44\x6c\x7d\x0a\x16\x62\xf1\x40\x8b\xcc\x72\xc3\x50\x93\x49\x7a\xe6\x80\x91\xdb\x6a\xe2\xf7\x42\x5a\x5c\xfb\x00\xfd\xe1\xc9\xa3\x00\xff\xc4\x93\xdf\x42\x36\x73\x2b\xbf\x63\x5e\x19\xf8\x27\x35\x5a\x1a\x9e\xbc\xc3\xb5\xa6\x6b\x15\x3c\xe9\x8d\x6a\xdb\x0a\xdd\xe0\xff\xf0\xe4\x91\xcb\xd7\x43\xa1\x55\x2e\x3d\x2f\x25\x2f\x26\xef\x11\xfb\x77\xd7\x56\xd9\x1a\x55\x2d\xf0\x99\x9c\x29\x1a\xa4\x93\xe2\xdd\x30\xc8\xad\x07\x53\xae\xab\x0f\xad\x68\x4b\x97\xa1\x8c\x86\x16\xef\xb2\xd7\xe9\x24\xf1\x3f\xec\x0b\x77\xeb\xf6\x4b\xd7\xe1\xd6\xc3\xa7\x4c\x13\x99\x52\x3d\xc3\xf0\xe7\x08\xdc\xb9\xd3\xb7\x1c\x91\x63\x40\xe9\x94\x05\x92\x14\x7d\x00\x71\x4e\xb4\x83\xc4\x67\xfb\x10\xd0\xfa\x8a\xdd\x1a\xda\xdb\x19\x87\x3a\xcb\x71\x0a\x39\x0b\x62\x1e\x2a\x68\x98\xc7\x8e\x90\x76\x5e\xd4\x0b\xed\xd1\x76\x52\x9c\x9d\xa8\x0a\x0c\xe9\x10\xa0\x9d\x24\x09\x6b\xdf\x02\xc6\x15\x26\x71\x3f\x41\xf0\x3c\x8b\x5e\xdf\xfc\xa2\xe4\xa4\x77\x31\x52\xb4\xde\x23\xf2\x88\x84\x05\xce\x51\x59\x91\x70\x6e\xc3\xd2\xfa\x0d\xda\x8b\xd5\x4c\x37\x6a\x2a\x56\x43\x0f\xf0\xff\xb9\x5e\x32\xe0\x54\xfb\x2d\x58\x62\xf0\x08\xe6\x00\x9f\x26\x49\x6d\xfb\xe7\x7d\x17\x35\x69\x08\x54\xa9\xe3\xb5\x3c\xf6\x34\xa6\xfd\x74\x4c\x17\xfb\x56\x3a\xa3\x59\xe9\x2e\xe4\x4f\x53\x69\x26\x86\x70\x33\x12\x6b\xd9\x75\xae\x65\x3e\xea\xdd\x53\xec\x01\x31\xeb\xe3\x47\x31\x8c\x53\x10\xf9\xce\x84\xf1\x81\x9b\x99\xbd\x3d\x4f\x10\x6f\xe3\x51\xff\x28\x3f\x4d\x92\xba\x3e\x12\xf3\x90\x4a\x4f\x49\xf5\xf3\x68\x98\x74\xa3\xbf\x19\xf0\x46\xa0\x9e\x0a\x39\xc3\xf3\x9e\x17\x4e\xf0\xda\x2e\x75\xe5\x99\x85\xe9\x48\x8d\x40\xb4\xc3\x39\x86\x8c\xf1\x8d\xe9\x7c\xd0\xfd\x28\xe3\xc8\xd2\xb7\xc7\x9d\x93\x71\xdc\xa3\x6a\xff\x34\xb9\x97\xf4\x15\xcc\xf1\x8f\x3a\xbf\xa4\xe3\xf2\x1a\xdc\x47\xe9\x0f\xdd\x1d\x49\x4a\xfa\x1f\xb2\xe7\xbb\x97\x75\xb8\x11\xf0\xc6\xed\x21\x3b\x70\xf6\xe7\x25\xea\xc5\xbc\x74\x35\x65\x3f\x4f\x62\xe1\xd5\xe5\xc5\x4a\x8a\xc6\x89\xb1\x9a\xe4\xb6\xf0\xf2\xe9\xb7\xb8\x7d\xfb\xa1\xaf\x8f\xf0\x2d\x4e\x11\xe6\x52\x1f\xf8\xe2\xec\xe7\x4c\xc9\x18\xfb\x35\x57\x89\x95\x98\xf8\x95\x36\xaa\x69\xbf\x41\x45\x01\xab\xc5\x7f\x8f\xcb\xbe\xa8\x7d\x23\x7d\xd5\x3a\x45\xc2\xfa\x05\x4d\x49\xb4\x74\xfe\xe7\x4c\xc9\xe7\x8d\x5e\x65\x67\xd6\x57\x26\x49\x59\x45\xbe\xda\xaf\x25\xa6\x75\x98\xc1\x8d\x9b\x05\xda\x08\x6f\x36\x8a\x05\x84\x2a\x90\x0a\x74\x24\xa8\x52\xa1\x7c\x5a\x83\xd2\x84\x4e\xa8\xe4\x49\x57\x04\xa6\x8e\x52\xf1\xd2\x77\x8f\x7f\x49\xfb\xa7\x17\xa0\x73\x29\x9e\x7d\x58\xab\x79\x4b\x08\x5b\x98\x9c\x13\x54\x26\x21\x1e\xf0\xb6\x9e\xbf\x58\x66\x8d\xe6\x1a\xad\x25\xcd\x12\x73\xb6\xf4\x62\xed\x76\x3f\x03\xaf\x94\xfd\x82\x5c\x57\x77\x0c\xb4\xab\x6f\x51\xba\x8e\x47\x81\x38\x48\x3e\xa3\x65\xab\x85\x51\xb2\x41\x99\x74\x2b\x9b\x22\xc4\xf7\x81\x48\xb9\xa9\xdb\xb2\xb2\x32\x2c\xad\xa1\xd3\x45\xd8\xb5\x74\xed\x61\x9a\x98\xef\x02\x98\xb3\x15\xac\xcb\x05\xa6\xd5\x59\x57\x8a\x23\xe5\xca\x46\x79\x24\x71\x29\x1a\x4c\xdf\x43\xf1\xe1\x5e\x12\xc7\x01\xad\x21\xa7\xce\x52\xad\xa6\x0e\x4f\x49\x62\x88\x9e\xfa\x80\xcb\x55\xca\x8a\x0d\x3e\xc8\xab\x34\xc6\x4e\x66\x0e\x58\x07\x72\x43\xc4\x22\xe6\x51\x5e\x69\x17\x94\x50\x65\x61\x45\x77\x9c\x3c\x61\x3d\x4d\xac\xc0\x7f\x64\x44\xdb\xec\x7a\xfa\xbc\x35\xf5\x4d\x74\x98\xe2\x72\x27\x39\x84\xb0\xad\x02\x2c\x0d\x0d\x9a\x11\x54\x8c\xd8\xc3\xa3\x1b\xb1\xa4\xb8\x7a\x07\x97\x1d\x52\xd0\xa1\xd2\x3d\x0e\x74\x3c\x3d\x15\x95\x5d\xfd\x64\x56\x62\x5f\xa8\xc0\x8f\xac\x31\x8a\xd7\x99\x2b\xf7\xc2\x95\x7a\xf0\xa0\xab\xfa\xcb\x03\xe3\x97\x2d\x7a\x31\xb4\x4c\x1f\x2c\x6b\x44\x3b\x60\x70\x74\x3c\x6a\x8d\xb4\xe2\x1c\x59\xed\xf4\x54\xbc\x6b\x76\xec\x5e\x15\xe8\x04\xce\xaf\x51\x04\xec\xe7\xb5\xac\xdc\xf5\xc1\xb3\x8f\x3d\xbb\x8c\x1a\x25\x1a\x8f\xc3\xb8\xa6\xf3\xe8\xce\x76\xaa\x0e\x15\x4c\x43\xe9\x0b\xe5\xf6\xf0\x86\xbd\x90\x25\xa7\x32\x5a\x98\x9c\x3e\x1a\x94\xdb\x92\x90\x0b\xd7\xb2\x69\xbd\xde\xca\xa3\xe9\x67\x56\x27\x06\x95\x19\x99\x75\x6f\x78\xc2\x5d\x0f\xbe\x91\xc0\xda\x03\x2a\xe0\x4f\xc9\x51\x3f\x3d\x15\x4f\x96\x6a\x7e\x89\x89\x28\x52\x5b\x83\x69\x2d\x97\x06\x49\xc4\x66\x00\x75\x0b\xae\x43\x20\x6b\x16\x5c\x0b\x7f\x7f\xe8\x84\x24\x27\xf9\xb9\xde\xd4\x85\x28\xdb\xfb\xe9\xf3\x1a\xc3\xad\x8f\xb3\xd1\xfb\x5e\xb2\x62\x19\x38\x42\x79\xb3\x01\x91\x79\x80\xcf\x08\xd6\x89\xf0\x9e\xd0\xcb\x9b\xf0\x15\x08\x9c\x7f\x9e\xe7\x44\x3a\xbc\x7f\xc4\x8f\x70\xa5\x1d\x18\x8d\x4d\x9f\x4a\xcf\xa9\x74\x58\x97\x19\x03\x76\x8f\xf2\x25\x61\x40\xb0\x76\x0e\xbd\x36\xea\x1e\xf8\x90\xf0\x71\x54\xe6\xf9\xc1\x8e\xfa\x60\xad\xe3\x6e\xed\x3b\xb6\xaf\xd7\x4e\x38\xd1\xdd\xf6\x7b\x40\x5a\x7c\xc6\xa1\x11\xbb\x73\xeb\xc1\x32\xa4\xdf\x65\x33\xe5\xb7\x8a\xe4\x13\x90\xfc\x7b\xb0\xdc\x22\x04\xce\xd8\x2a\x40\x36\xc5\x42\x23\x9a\xe4\x8e\x31\x3e\x3d\x42\x92\xe3\x86\x99\x49\xf0\x09\x18\x20\xf8\x40\x82\xf1\xc2\x85\xe0\xca\x8b\x88\x39\xee\xcc\xe3\x5c\xfc\x07\x6f\x20\x72\xe4\xb0\x37\x65\xe6\x84\x93\x0e\xa7\xd8\xb9\x71\x23\x13\x5e\xe0\x4c\xef\x38\xb5\x1a\x1f\xde\x80\xc9\xf5\x16\x12\x5a\xd8\x26\x70\x91\xba\xb9\x32\xd8\xc1\xef\x38\xcf\xe7\x45\xbc\x9e\x2c\x6c\x13\xda\x87\x11\xa1\xcf\x4c\xe2\x3c\xa8\xb1\xa1\xc7\x6e\xcf\x5c\xf2\xb2\xf1\xbe\x84\x72\xbd\x53\x60\xcd\x8d\x6a\xa3\xfb\xa2\x5e\x23\x55\x1d\xba\x1b\xd0\x1d\x74\xd6\x2f\x80\x20\x40\xa6\xe4\x97\xa4\x75\x23\x0c\xd6\x7d\xca\xba\x1f\xdb\x70\xdd\xaf\x34\xfc\xc9\x1a\xb0\x87\x1d\x86\xb8\x44\x7e\x9b\x14\x96\x51\x4c\xea\x2a\xa4\x53\x7d\x66\xcf\x63\xd9\x12\x18\xaf\x8f\x56\x7b\xed\x2d\xd0\x6b\xbd\xde\x54\xc1\xd1\xd7\xb6\x73\x64\xa2\x87\xb9\x5c\x58\xce\xdd\xd3\x72\xde\xc0\x0b\xf3\xaf\xf6\x1d\x0f\x84\x3b\xf7\x35\x66\x8e\x3a\xa5\x32\x8c\x5d\xd2\x4a\x8e\xcb\x1b\x7e\x0d\xee\xe7\xc6\xd1\xb1\x86\xba\xee\xfb\xf2\xb8\xd8\xa7\x0a\x5b\xe8\x51\x1b\x08\x00\x9d\xe8\xa8\xc2\x72\x10\x13\x3f\x8e\x7a\x2a\x8b\x2d\x11\x33\xc3\x5d\xcb\xe6\x7e\x53\xa4\xe8\xec\x18\xb5\xd5\x6b\xc2\x1b\xd8\xc1\x84\x51\xc6\x3f\xc0\x40\xb2\x05\x3f\xcb\x8f\x2f\xb5\x47\x8e\x19\x5a\x7f\x7a\x98\x3d\x03\x8d\x59\xdc\x83\xc6\x99\x33\x8f\xfe\x84\x46\x1a\x25\x9b\x19\x56\xb7\xc6\xc5\x7b\xae\x37\xef\xdf\x87\x44\xdc\x02\x57\x96\xb5\x53\xd5\x31\xeb\x70\x7a\x2a\x1e\x43\xd4\x8d\xe3\x29\x19\xaa\xfa\x95\x72\x14\x59\x15\x13\xaf\xef\xd9\x82\xd7\x2d\xe2\x53\xae\x10\xfe\x2c\x7a\xf8\x81\x94\xc6\xfe\x43\xd1\x2b\xd6\xb7\x11\xe9\x1b\x95\x57\xc8\xc7\xd5\x07\x78\xa2\x0c\x57\xc5\xda\x1c\xdf\x0c\x9f\xda\x53\xe0\x7a\xae\xf2\x4e\x88\x5b\x25\x64\xd5\x28\x59\x90\xa3\xa0\x2a\x22\xe8\xce\x83\xf9\xb1\xef\x89\xd5\x02\xb8\x3d\x48\xd3\xed\x98\xb0\xb2\x25\xd4\x07\x13\xe9\x28\xfd\x86\xd8\xc5\x4f\xf5\x4b\xe0\xc3\xd4\x28\x69\x4c\x79\x51\x43\x0b\x72\x7e\xe9\x01\x72\xd6\x7a\xcd\x39\x2c\x67\x00\x95\x3b\xb1\x59\x4f\xf3\xc7\xd7\x3f\xe9\xfb\xae\x5f\xbf\xdb\xa6\xd3\x74\xa1\xb6\xd0\xf9\x6e\x26\xe1\x5f\xbd\xba\xad\x7c\x04\xde\xcd\x55\x52\xb9\x3c\x6f\x09\x53\x9d\x5e\xb1\xac\xbb\xea\xd0\xcc\x01\x03\x6f\x87\x2f\x19\xf8\xaa\xa6\x31\x6f\x33\x55\xe9\xed\x4f\x6b\xea\x39\x5e\x37\x63\x6d\xff\xb1\xd9\xdc\xac\xc1\xff\x9a\x1c\x6e\x0f\xd5\xcd\x29\x4a\xe3\x0b\xca\x2c\x08\xee\x92\x32\x84\xb6\x46\x99\x16\x9d\xa7\x63\xad\x9e\x6f\xe9\x6d\x59\xcf\x99\x63\x38\xc0\x76\x4a\x01\xc0\x9c\x2e\xd7\x14\x34\x08\x97\x98\x99\x70\xe2\x14\x25\xfb\x99\xc7\xdc\x7e\xde\x1d\x37\x1f\x3b\x69\x64\xd8\x78\xae\x0c\x75\x00\xe6\xb1\x32\xd4\x3f\x23\x7c\xd9\x6e\xcd\x9b\x63\x4c\x7c\x42\x9f\x0b\x47\x6e\xaa\x71\xd2\x87\x3b\x06\x37\xb8\x8d\x48\xde\x83\xc1\x11\x7c\x85\x7e\x84\x6f\x8c\x8d\x0a\xa9\x90\x09\x58\xac\x10\x4a\x36\x55\x19\x67\xa4\xeb\x24\xb4\x18\x1b\x76\x0a\x7a\xfb\x86\x30\x49\xc9\xd5\x3d\x24\x2f\xf3\x79\xaf\xdb\xa5\x93\xfe\xda\x46\x21\x3c\xa9\xc7\x5a\x4e\xdb\x93\xce\x83\x17\x07\x03\x11\x0c\x09\xaa\x34\x5c\x3f\xf7\x4c\xa1\x1b\x35\xa4\x4c\x85\xe4\xd9\xb9\x1c\xa6\x80\x46\x67\xd4\x18\xe0\x71\x1e\x15\x9e\x05\x41\x10\x8f\xb2\xe0\x89\x87\x04\xf8\xa6\xc9\xc8\x55\x14\xe0\x8f\xc6\x14\x9e\x9d\xbc\xf7\x25\x16\x3d\xa0\xdb\x63\x22\xe9\x45\x6f\xa9\x4c\x1e\x85\x4c\xa2\xf0\x01\xe0\x4c\xee\x66\xc3\x20\xbf\x47\x43\x6e\xf7\xc6\x29\xef\x43\x82\x1b\xb8\x85\xfd\x41\xcb\xf7\x8f\xf3\x77\x6e\x8f\x24\x0c\x92\x2e\x07\x00\x93\xa8\x62\x27\x03\x2b\x60\xa7\xda\x43\x73\xa7\x32\x31\x9c\x39\x86\xbe\x37\x8a\x80\xc4\x48\xa0\xe3\xae\xfa\xed\x5e\xf4\xdb\xbe\xe6\x7d\x97\x3c\x0b\x49\x3a\xf2\x86\xbf\x4b\xf2\x8e\xa4\x7e\x5d\xc7\x7c\xdd\xf7\xe0\x82\xde\x00\x27\xe3\x1f\x26\x3c\x3d\xf5\x5a\x4d\xf9\x94\x8e\x09\x2a\x1f\xfa\xe9\x23\x28\xfa\x02\x25\x13\xb7\xa6\xd8\xb5\xb7\xeb\x3a\x9b\xff\x3d\x76\x04\x64\x4e\xb3\xc9\x0f\x71\xb9\xe0\x27\x1b\xff\x3b\x2e\xe5\xc1\xef\xe8\xef\xf1\xd7\x31\xfe\xa2\x63\xbd\x45\x47\xf9\x8a\x82\xa7\x68\x9c\x40\xad\x73\xba\xdc\x2a\x0f\x7b\x73\x7e\xf2\xf8\x7d\xaf\xbe\x7d\xff\xe4\xdb\x57\xef\x9e\xfd\x7f\xef\xc4\xb9\xf8\xc1\xfd\x1a\xc0\xf1\x62\x24\xfe\x14\x1d\x2f\xc2\xc3\x03\x2d\x42\x5c\x3e\x20\xe2\xa5\x1f\xdd\xc4\x13\xa4\xd8\xb4\x5a\xf2\x8d\xe1\xdf\xe1\x0f\x6f\xad\x40\xf0\x64\xd3\x18\xc4\xef\xc2\x10\x11\xf8\xe7\x71\x98\x19\x4c\x99\x55\x82\x89\x1d\x56\xb3\xd1\xda\x53\x98\xb1\x35\xf9\xc5\x22\x7c\xf2\xc2\x41\xda\xce\xdd\xd9\xbf\x7f\x3c\xc7\xec\x60\xa1\xe6\xb0\xb6\x97\x38\x10\x5c\x2a\x70\x65\x2b\xcd\x5d\x69\x7b\xe9\x62\xce\xb3\xfe\x81\x19\x80\x5f\x0e\x60\xc1\x16\x4c\x9c\x77\xe6\xdf\xb3\x9e\xd3\x58\xd2\xa0\xfe\x79\xe1\xee\x50\xd6\x1b\xb3\x8c\xc7\x01\x76\xff\x09\x78\xd5\xbd\x61\x55\x99\x98\xf5\x7a\x63\x96\xfe\x11\x02\x07\x37\xcf\xc6\x6b\xe7\x6c\x02\xb2\xa6\xb7\x60\xc3\xfa\xca\xaa\xd2\x5b\x23\x36\x86\x44\x58\x45\x95\x41\x67\xe4\x54\x37\xb2\x01\xe5\xd1\xda\xf9\xdf\xd8\xf1\xf5\xcd\xb7\x3b\xc8\x09\x7a\x2d\x38\xd8\x7b\x64\x10\xb0\x48\x94\x10\x23\xb9\x18\xc7\x9d\xc9\x06\x83\xcd\xbb\xc6\x0a\xcd\x2e\x07\xb6\x6d\xc1\xca\x87\xf6\xdf\xcc\x3e\xb4\xc6\x3c\x69\x85\x17\xa0\xdd\x9c\x91\x78\xbb\x49\x83\x6f\x60\x5d\xed\xb0\xaa\x89\xea\xda\x47\xed\x6f\x1b\xdf\x8b\x61\xd3\xef\xb9\x78\x34\xd9\x30\xe7\xb4\x42\x76\xa9\x7c\x9a\x81\x50\x2b\x39\x11\x29\xb8\x6d\xe4\xbe\xba\xd6\xeb\x6c\xf3\xd1\x18\x42\x99\x9e\x31\xb3\x82\xbd\x7b\xdb\x37\xbe\x14\xde\x3a\x8a\x2b\x74\x7b\xdc\xa1\x18\x9d\x21\xe7\x2f\xcb\x3c\xe4\x69\xeb\xbf\x27\xb6\xc1\x8e\x97\xf6\xad\x5c\xd9\x1b\x4e\xc2\x9d\xf7\xe8\xac\xa7\x6f\x87\x6b\x66\xe2\x1c\x9a\x41\x7c\x69\xf2\xa7\x1f\x15\xd4\x76\xf2\xc8\x98\xc2\x7e\x1e\x19\x3f\x48\xca\xa4\x08\x30\x29\x78\x80\xf1\xdc\x82\x5e\xde\x8d\x02\xb2\xea\xfa\x51\xa5\x61\x3f\x91\x73\xcc\xcf\xec\xc2\x1d\x72\xd9\x3a\xa7\x0a\x96\x1f\x9d\x34\xf5\x3a\xca\x59\x89\x0b\xe1\xd7\x80\x05\x2d\xbb\xd9\xf8\x45\x49\xcf\xed\x09\xae\x07\xe0\x73\x98\xf1\xcb\xc2\xf6\x33\x5d\x95\x29\x17\x47\xa2\x09\x64\x77\xf8\x16\x09\xc8\xa7\x84\x49\x30\xaa\xe7\x49\xed\xbf\x38\x82\xf3\x0e\x44\x09\x86\x6f\x6a\xa7\x46\x17\xfd\x39\xa6\x50\x8f\x92\x7f\x4f\xee\x65\x38\x37\x18\xef\xa3\xec\xaf\x13\xb7\x24\x49\xd9\xf4\x97\x4e\x39\xe8\x3b\xfe\xf7\xc4\x1f\xd9\xb4\xb1\xf4\xa7\x6e\x49\x6c\x2e\xfe\x61\x12\x24\x9a\xa4\xc1\xee\x6f\x31\xf2\x35\xe3\x91\x9d\x28\x3e\x86\x51\x46\x41\xef\x6d\x1a\xe8\x44\x2c\x6f\xee\xab\x63\x95\x83\xc4\xef\x8b\xfb\x9f\x1c\xfe\xf1\x0b\xf2\x11\x2e\xb4\x32\xde\xf3\x3a\x54\x5c\x41\x32\x48\x17\xd8\xee\x7f\xef\x11\xc4\x54\xdd\xb2\xc9\x01\x92\x26\x8f\xc5\xcb\xc4\xdf\x44\x8a\xf5\x4f\x51\x5c\xd7\x60\x3b\xbe\x68\xdb\xec\xde\xe9\x27\x95\x2c\x57\xaf\xd4\x07\xaa\x63\xc9\xa1\x3b\xce\x7d\xf5\x86\x72\x41\xf5\x8d\x79\x80\xc9\x1e\x4c\x2d\x75\x02\xf9\x02\x20\x9b\xef\x0c\x73\x04\xdc\x9e\x6a\xa9\xb3\x76\xfb\x92\x50\xdc\xd2\xe4\xa2\xbc\x11\x3f\xee\x04\xd3\xd4\x1d\x71\xb8\xeb\x2c\xb6\x82\x67\xcf\x19\x13\x8e\x03\x3c\x7a\x4d\xb3\x63\x1c\x8d\x3f\xef\xd3\xee\x67\x2f\x88\xfb\x2f\xef\x62\x65\x5e\xae\x32\x2f\xc2\x04\xda\xf8\xe8\xbe\x75\xb6\x3d\xd6\x44\x5f\x21\xd6\xc8\xf3\xb2\x31\xac\x80\x8b\xea\x8b\xda\xc8\x95\x89\xa9\x45\x7e\xfa\xcb\xfc\xdc\x97\x7b\x26\x9e\xf9\xee\xaa\x16\x65\xf1\x4a\xb7\x2f\x65\x3b\x5f\xba\xa4\x2a\x9e\x6c\xf6\xb6\x37\xb6\xd2\x40\x27\x87\xb4\xdd\xdf\x24\x95\xc8\x65\xb2\x49\x5b\xec\x2b\x9a\x6d\x70\x7f\x3b\xf9\xea\xcf\xcb\xba\x60\xdb\x3a\x62\x58\x7b\x6a\x8c\x6a\x7e\xcf\x5a\x8e\xa8\x35\xd4\xcd\xe8\x96\xc7\x34\x76\xd0\x50\x79\x61\xf7\x4e\xbe\x5b\x2a\x51\x28\xb5\x56\xa6\x25\x5e\x94\x6c\xa2\x68\x61\x2e\xeb\x2b\x5d\x5d\x59\xe6\x1c\x72\x8c\xf9\xf7\x93\xf1\xa6\x8e\x5d\x5f\xc9\x9d\xcb\x3a\xa2\x6a\xa0\x74\xde\x5b\x58\x37\xbc\xf2\xd4\xd1\x26\xff\xcb\xeb\x28\x7c\xc5\x19\x7a\x9c\x08\x94\x5d\x3a\x5e\xa8\xa4\xfc\x45\x48\x5c\x88\x24\x72\x7e\x32\xf3\x7e\xf7\xc5\xe6\x46\x56\x8b\xbd\xc1\x1b\xbd\xc3\xeb\xa1\x49\xc7\x71\x27\xf4\x08\xf4\xac\x03\x8b\xb1\x8c\x67\x18\x7c\xc2\xe8\x15\x70\x3f\xa4\x90\x4f\x95\x6a\x55\x77\x78\xc7\x58\xeb\x39\x0a\x40\x7d\x29\x1c\x9c\x39\x9a\x15\xee\x05\x45\x4d\x7d\x07\x87\x29\x44\xd4\x64\xcf\xf2\xf6\xe0\x43\x26\xe0\xa9\xc3\xce\x95\x59\xfa\x12\xcf\x07\xe5\x65\xf6\x4b\x64\x74\x89\x3f\xb1\xf0\x80\xfd\x63\xfb\xc4\xe5\x24\x78\x87\xd1\xf9\x9f\x92\x96\x3b\x6d\x29\xb4\xfc\xbc\xd1\x2b\xce\x57\x3d\xd7\x8d\x77\x8c\xa0\x1e\xa2\xda\x51\xb6\xab\x38\xcd\x60\x54\x2e\xf2\xd8\x60\x33\xc9\x35\x19\x02\x5e\xce\x85\xeb\x9c\x29\xce\xe0\x7e\x83\x27\x96\x51\x6a\x05\x3c\x0f\x7a\x9a\x55\xba\xbe\x30\x96\x64\xac\x29\x07\x92\x2a\xe0\xdc\xbb\x36\xa6\xe2\x8f\x7a\x6b\x19\xa8\x89\x6b\xab\x05\x0c\xed\x90\x36\xb6\x13\xbc\xa8\xbc\xc6\xbe\x44\x5a\x53\x95\x06\x3e\xc5\xe9\xa9\x5d\x5a\xea\x72\x11\xb2\xb8\x21\xc8\xac\x57\xf8\x47\x3e\x8b\x94\xbf\x0f\x0c\x78\x2d\x46\x95\xd2\x33\xee\x9a\x93\x17\xd2\x52\x39\xd2\x50\xa0\x93\x89\x1d\x9e\x69\x6d\x1d\xb2\xf7\xf9\xb8\x4a\x4a\xa9\x62\x94\x83\x00\x73\xcd\x34\x0a\xf7\xb6\x08\xe2\x36\x3f\x46\x95\x34\xed\x33\x8c\x3d\xea\x5a\xab\xf3\x05\xa7\x96\xcc\x50\x9d\xf3\x78\xe3\xce\x06\x2b\xe6\x4b\x27\x8e\x6a\xbc\x2a\xa0\x94\xfb\xba\x07\x35\xda\x8d\xde\x07\xf2\xff\x4a\x3b\x1e\xb1\xc8\xd3\x9f\x88\x0e\x2f\x92\xe8\xab\x8f\xe7\x22\xc9\xc3\x7f\x1b\xe4\x29\xf6\x0d\x08\xb4\x9f\xfb\xfd\x8e\xa0\x51\xb1\x17\x40\x70\xdf\xc9\x0c\x65\x0c\xb9\x0a\xa3\xf1\x1e\x1b\x8e\x46\xa5\x0e\xc8\x29\x1e\xbb\x2d\x47\x70\x49\xd9\x0c\x13\x23\xd9\xa9\xe3\x64\x19\x22\xa8\xf6\x0e\xfe\x52\x87\x1a\x27\x93\xec\x62\x65\x09\xe6\x1d\x70\x1b\xe3\x8e\x64\xb5\xee\xd8\x53\x8b\x77\xef\xa0\xe3\x8c\x83\x9d\x02\x9f\x46\xbe\x37\x7d\xc7\xea\x1d\x6e\x67\xfa\xf0\x74\x3d\x75\xb0\xb8\x73\xfe\xe9\x7d\x96\xfa\x2a\x46\x2a\xeb\xcc\xe9\xbd\xb3\xf3\xfa\x7e\xe4\x81\x7d\x7f\xd3\x13\x9b\x6c\xf6\x3b\x3c\x9d\x61\xd5\x26\xc9\x4a\x4c\x70\x68\x13\xea\xf9\x16\x8f\xf0\xfb\x1b\x9e\xe1\xcc\xd1\x1d\x35\x9b\xdb\x3f\xd3\x59\x00\xfa\xae\x9b\x6e\x97\xbe\xb7\xcd\x8e\x28\x3b\xb7\x33\xa6\x36\xc6\x81\x63\x76\x88\x37\xe2\xe0\x09\x1b\x4f\x0c\x53\x3c\xf4\x8e\xf6\xe3\xb8\x8e\x3c\x68\xfa\xe8\x5f\xe2\xef\x98\x77\x3a\x4b\xe4\x87\x0e\xb3\x16\x2f\x77\x27\xd2\x24\x93\x54\xb4\xc7\x5d\x77\x64\xa6\xe5\x51\x47\x36\xe3\xbd\x95\x57\xf3\xa4\x2b\x95\x9e\x4c\x80\x93\xe7\x0d\x8d\x5f\xa6\x36\x92\x53\x6f\x75\xa9\x3a\xa7\xbd\x5b\x3c\x7b\xd2\x07\x75\xb1\xb1\x2c\x09\x1a\x65\x26\xb0\xf5\x99\x50\x04\xb3\xf2\x71\xc1\x36\xdb\xc5\x59\x68\x3a\x77\xcb\x08\xd2\x0f\x30\x75\x18\x67\x3b\xc5\x0c\xec\x65\x1b\x89\xe3\x1e\x0d\xa3\x97\x41\xcb\x09\xa4\xb1\x59\x27\x15\x49\xa3\xe5\xde\x2f\xcf\xe6\xd6\x02\x26\xb7\x87\xa8\x64\x60\x85\xe6\x12\xd4\xfb\x58\x89\x70\xf1\xdd\x6a\x66\xc0\x85\x18\x5e\x0c\x06\xbf\xa0\xbf\x60\x69\x84\x34\x42\x8a\xa5\xda\x34\xa5\x69\xcb\xf9\x54\xbc\xb0\x75\x67\xd2\x28\x40\x5b\x2f\xeb\x76\x53\xc2\x69\xb0\x02\x82\x95\x58\x0a\xd9\x4a\xcc\x2b\x11\xda\x43\x19\x69\xa6\xc4\xa2\x92\x5b\x5b\xb1\x11\x9b\xba\x56\x73\x65\x8c\x6c\x7c\x50\x72\xb2\xe3\x7d\x3a\xd0\xe8\x86\x45\x99\x0f\xa3\x33\x20\x3e\x7e\x14\xe3\xd7\xed\x5a\x27\xe5\xa6\x67\x65\xf0\xb4\x8c\x3b\x2f\x7d\xc1\x23\xb8\x89\x2b\xd9\xce\x97\x64\x3e\x75\xdb\xec\x42\xc9\x6b\xbd\x15\xd2\x98\xcd\x4a\xa1\x04\x88\x78\x4d\x8d\x81\x42\x62\x2b\x4d\x68\xc9\x6c\xd6\xaa\x59\x54\x1b\xbd\x31\x94\xd0\xdd\x36\x40\xe1\x07\x65\x3b\x0d\xc1\x18\x78\xea\x94\xbc\x50\x4d\x08\x50\xe0\x27\x01\xab\x12\x1a\x17\xcf\xff\x5e\x78\xc9\xf8\x1d\x65\x7f\x97\xed\x04\x4f\x20\xb8\xe9\xd6\x4a\x15\xf6\x24\x16\x9b\xd5\x6a\x17\xda\x43\x84\xa9\x34\x77\x50\x08\xf2\xe8\x55\xf6\xe4\xf7\x27\x4f\x65\x22\x6c\x8f\xfd\xbb\x72\xb0\xf6\xab\x73\xa0\x13\x0b\xfa\x90\xb1\x89\x8e\x75\x4f\x02\xef\x65\x30\x64\x72\x9d\x5e\xd9\xab\xcd\x0b\x5e\x16\xa9\xa3\x7a\x62\x13\x60\xce\xe2\xdc\xc9\x62\x91\x55\x17\xed\x1d\x5c\x7c\x33\x52\xa7\xfb\xd2\x44\x3e\xf6\xf0\x03\x70\x3e\x7a\x11\x7c\xed\xa7\x4c\x52\x8e\x3d\xe4\xa3\x99\xf8\x1e\x08\xbb\xc1\xfb\x43\xe3\x3c\xcb\xba\x28\xe7\x84\x4d\x8e\x97\x02\x33\x8f\x49\xe7\xcc\xac\x1b\xc4\x59\x52\x8d\xd7\x6c\xc0\xe7\x5a\x6d\x21\x29\x13\x84\xa9\x35\x97\x81\x76\xd6\xd4\x45\x50\x7b\xec\xf3\xcd\xef\xbc\xe6\x78\xf0\xd2\x27\x79\xff\x21\x89\xf8\x92\x8e\x62\xb7\xe3\x8c\xde\x73\x10\xda\xc8\x0e\x9d\xd9\xe0\x50\x14\xad\xd3\x1e\x68\x33\x63\x0f\x4a\x5c\xb1\x59\xdb\xf1\x11\xe0\xa1\xf5\xbc\xd5\x34\xe0\x53\x45\x34\x6c\xdf\x22\x08\x70\x3c\xaf\x2a\xa7\xb8\x77\xee\x37\x5b\xd8\xe6\x24\x28\x37\x68\xf5\x63\xf0\x7c\xfa\x57\x1c\xe9\x91\x00\x8c\x45\x29\xd3\x10\xd4\xdd\x4b\x9e\xdc\x1e\xc1\x68\x48\x1c\x50\xc7\xcb\xe7\x39\xc4\x11\x9a\x1e\xb1\x2f\x90\x3d\x95\x6c\x6f\x4d\xeb\x23\x0e\x30\xf9\xe5\x55\x14\xd9\x33\x32\x56\x52\xfd\x94\x5f\x82\x5e\x79\x7d\x68\x1d\x46\xa9\x29\xc4\x4d\x54\x15\xe2\x06\xea\x8a\x9e\x85\xbe\x9e\x1c\x7d\xab\xeb\x9e\x81\xd7\xe9\x12\x33\x7e\xb5\xb3\xae\x63\xef\x34\xf0\x80\x3d\x78\xa7\xd7\xc5\x8e\x85\xb4\x48\x1e\x9b\x22\x0f\xe9\x98\xf9\xfe\x26\xca\x6b\x32\x0a\x35\xb6\x87\x5b\x08\x38\xb4\x5d\x67\xb9\x01\x7b\x1c\x26\x5b\x76\x34\x21\xd7\x76\x24\x09\x20\x0a\x2b\x98\x31\xc1\xa9\xb0\x8e\xfc\xe8\x3a\x56\xcb\x89\x4f\xc1\x54\x7b\x28\x98\xd0\x18\x47\x25\xc8\x4b\x87\x43\x32\x9e\x93\x4b\x8e\xc8\xae\x11\x32\x04\x2d\x3d\x03\x8c\xe1\x48\x98\x0a\x2a\x67\x55\x45\x28\x25\xce\x4b\x8a\xad\xa5\xdb\x91\x4d\x15\xc5\x90\xad\x0f\x24\x06\xc7\xc2\xb5\x68\x14\x18\x3b\x59\xa3\x7a\x21\xf4\xa6\x61\x4c\x2e\xa1\x37\xba\x39\xf6\x1f\xbe\xbc\xa8\xc7\x85\xef\xdc\xfa\x84\xf7\xb4\xab\xb3\xb9\xc7\x97\x88\x42\xd4\xea\x9d\x68\xd4\x4a\x96\x35\x60\xe1\x7a\x8e\x11\x0d\x30\x51\xac\x34\xb1\xd9\x90\x63\xa9\x76\x21\xf0\x0c\xf2\xa7\x20\x96\x89\x1f\x84\xa5\x92\x05\xac\xd5\x4c\x17\x3b\x61\x80\x7f\x07\xd4\xcc\x56\xd5\xd0\x28\x0c\xa2\x91\x75\xa1\x57\xae\x3d\x6d\xb9\x1e\x0f\xb9\x48\xb8\xb9\x0e\x87\xb3\xbc\xa8\x7d\x02\x29\x8c\xc7\xc7\x2c\x9e\x9b\x26\xc1\xb3\xa3\x68\x30\x58\xf1\x42\xb9\x58\xed\x69\xcc\xf8\x7d\xa3\x5a\xd8\x2d\x2f\x76\xc6\xc7\xbf\xe7\xd6\x7e\xfc\x88\x8b\x6b\xbf\x1c\xd9\x19\x1e\xd9\x8b\x1c\x7e\xb2\x73\x85\x9f\xee\xe7\xdc\xe8\x8e\x7b\x39\xd8\x93\x38\x41\xcb\x01\x9a\x89\x10\xc5\x9f\xd5\x4e\x0c\xc8\x27\x39\x71\x35\x90\xdb\x1b\x89\xca\x91\x11\x76\xdf\x31\xef\x15\x66\xb2\x94\xed\xeb\xfe\xa1\x24\xfc\xe5\x49\x94\xab\x79\xd0\x60\x9f\x71\x0f\xf4\xae\x6c\x7b\x7c\x25\x06\xc6\xcf\x52\x07\xe5\x85\xf0\xae\xd7\x6b\xd6\xdf\x31\xf3\x23\xf7\x19\x4d\x4a\x67\x7e\xc4\xd2\xfb\x1d\x1b\xf7\x95\x20\x7f\xd6\x41\x47\xc7\xa1\xaf\xfd\xf5\x63\x7f\xc2\x7d\x25\x82\x97\x6e\x32\xf7\xce\x4f\xc1\x5f\xd6\x19\xd3\x2b\xd5\x82\x63\xfb\x52\xeb\x4b\x84\x70\x21\x8f\x78\x4b\xe5\x66\x9b\x0b\xb1\xb5\x6c\x3e\xf8\xe2\x03\x04\xe6\xd4\xd6\x7c\xab\x94\x58\xb6\xed\xda\x3c\x3a\x3d\xbd\x28\xdb\xe5\x66\x36\x9d\xeb\xd5\xe9\x42\xce\xd5\x4c\xeb\xcb\xd3\x46\xc9\x79\x7b\xba\xde\x54\xd5\xe9\xff\xfc\xcd\x17\x5f\x4c\x7d\x6f\x84\xc5\xcc\x6d\xec\x6b\xc8\x55\x2b\x1e\xbf\x7e\x31\x81\x6f\xea\x4a\xd5\x80\x1b\x01\x5e\x8b\xe2\xa9\xba\x7a\xa7\x75\x65\xa0\x8d\xff\xa5\x37\xe0\xdd\x03\x44\xb6\xac\xff\xb7\x9a\xb7\xa0\xc8\x98\x6d\x2e\x6c\x21\x4b\xae\x76\x7a\x83\x21\x9c\x9a\xfc\x1e\x69\x3e\x88\x13\x38\x4d\xfc\x84\xed\x0a\x36\x9b\x95\xaa\x5b\xe7\xc6\x6b\xcf\x9d\x6f\x10\x2f\x4c\xc6\xbf\x38\xa9\xf7\xfe\xb7\xe2\xbc\xff\x2b\xd5\x26\x8d\xef\xdb\xa5\xde\x3e\x2d\x65\xa5\x2f\x62\xa7\x64\xb9\x6e\x37\x8d\x2a\x9e\x35\x8d\x26\x9e\x22\xba\xa2\x6e\x0c\x86\x57\xef\x34\x79\x76\xef\x9e\x6f\xb2\xd2\x17\x4f\x78\xa3\xb9\x2e\x6c\x8b\x95\xbe\x80\x5f\xc4\x39\x6b\x3c\x29\xec\x9c\xb4\x1e\x57\x95\xde\xd2\xca\xab\x82\x97\x07\x0f\xd5\x75\x63\x77\xaf\x75\xe3\xb2\x2f\x90\xd1\x95\x9a\xa2\x8f\x6a\xa5\x2f\x2e\x08\x78\x3c\x8d\xac\x68\x7c\xea\x75\xf0\xe8\x80\xa5\x7c\x25\xdb\xf2\x8a\x22\xfe\xe1\x6d\x5a\xc9\x5a\x5e\x28\xd1\xa8\x62\xa6\x3f\x88\x99\x5a\xca\xab\x52\x03\x54\x83\x7d\xa6\xc2\x34\xce\x89\xa4\xc4\x3e\xd4\x9e\xc0\xf0\xd0\x1e\x7a\xc7\x5e\xc9\x15\xda\x17\xd8\x9c\xa7\xd1\xd7\x28\x87\x08\xfe\x0c\x7e\xfc\xfd\xb5\xe0\x73\xa8\x06\x4b\xf0\x8d\xde\xd4\x85\x6c\x76\xd9\xfe\x3a\x25\x7a\x2a\x23\x16\xf4\x60\x6d\x28\x12\xaa\x6f\xcb\xaa\x7a\xa3\xda\x66\xd7\xa9\xe5\xbf\x60\x18\x67\x66\x59\x5e\x2a\x63\xec\xaa\x9f\x27\xab\xf5\xb5\x38\x7a\xb7\x54\x98\xe6\x91\x7c\x90\xf5\x1c\x78\xcc\xc2\x79\xa8\xfc\xfe\x48\xfc\x3a\xa9\xf5\x6b\x71\xf4\x55\xf8\xe9\xd1\x91\x78\x34\xdc\x8c\xae\x81\x5f\xd9\xe9\x8d\xa3\x07\x81\xdd\x79\x74\xc4\x22\xf2\xa2\xe9\x87\x31\xf3\xd0\xc9\xd3\xd3\xdc\x3a\xce\x11\xc8\xdb\x08\xb3\x59\x2c\xca\x79\x69\x85\x84\xcc\x66\xf9\x62\xad\x16\x46\xb6\xa5\x59\xec\xc4\x73\x8f\x7e\x04\x21\xd5\xdd\xb6\x1f\x3c\xe8\xb6\x14\x63\x18\xfa\xf5\xe7\x1c\x4a\xcf\x5c\x8e\x70\x01\xb8\xdf\x90\xf3\xf0\xa1\x00\x7f\xcf\x96\x81\x5b\x10\xc0\xd2\x98\x79\x63\xa5\x54\x61\xb7\xe2\xf8\xc8\x25\xdf\x75\x4b\x3d\xa3\x4e\x80\x6a\xba\xd0\x9f\x09\x14\xee\x2e\xc1\xaf\xc5\x11\xf7\x16\x4f\x41\xa6\xfa\x46\xcd\x9c\xd4\x11\xf1\x12\xc0\x1f\x00\x17\xb3\x2e\xaa\x90\x16\x36\x19\x51\xff\x18\xfe\xad\xb6\xdf\x8e\xde\xe0\xdc\xdd\x84\xba\x53\x5e\xc8\xd2\x36\x6f\xb4\x60\x0b\x47\x68\x3a\x01\xf5\xed\x28\xe1\xd1\xe2\x69\xf5\x4d\xea\x89\x06\xb9\xad\x11\xb2\x28\x10\x17\x3a\x1d\x7f\xab\xf1\xd4\xc2\xb8\x5a\x2d\xe6\x1b\xd3\xea\x55\xf9\xef\x6e\xa2\x30\x7b\x90\xc1\x1c\x1d\xa3\x79\x21\x18\x97\x7b\x5d\x17\xb3\xe9\x4a\xe1\x7b\xfa\x10\x2a\x3e\xa4\x1e\x4a\x65\x30\x4d\xa5\x6c\x28\x93\x2c\xa2\xcd\x47\xc3\x28\x95\x71\x13\xfc\xc4\xaf\xf7\xac\xac\x55\xc1\xa6\xd3\xb9\xa8\xee\xdb\xaf\x53\x72\xf7\x6b\x71\xf4\x6f\x35\x8e\xf4\xf8\xa8\xb3\x47\x54\x8d\xc5\xfa\xbd\xa8\x45\xa1\xae\x54\xa5\xd7\x10\xf1\x0f\x30\x6e\x14\x13\x66\x57\x47\x6f\x6b\xb1\xa2\xbe\x40\x7a\xf9\xdf\x1b\xcc\x0f\xc2\x0e\x33\xf8\xff\x72\x11\x0b\xf1\xa7\xca\x7a\x5e\x6d\x0a\x74\xad\xa3\x3c\xec\x15\xcd\xde\xb5\x68\xa5\xad\xff\xe7\x2d\x39\x10\xb3\x4c\x05\x62\xd6\xe8\xad\x51\x8d\x6b\x73\x29\x8d\x47\xc5\x5b\x37\x65\xdd\x62\x0c\xa0\x77\xeb\xb3\x55\xe4\x7a\x5d\x95\x73\xe4\x12\xcc\x96\xc2\x8e\xfd\xb9\x75\xc0\x83\xe0\xa1\xe7\x9a\x2d\x4a\xb3\xae\xe4\x2e\x1c\x71\xea\x16\xe4\xc1\x4b\x23\x28\xaa\xf9\xe9\xb3\x7f\x7d\x08\x0c\xcd\x42\x5e\x2a\x81\x0f\x68\xdb\x94\xe0\xf3\x8c\x47\x17\x68\xf5\x77\x6d\x59\x91\xa8\x1c\x3d\xab\xc7\xc9\x7e\x3a\x34\x01\x64\x17\xca\xfa\x4a\x5f\xaa\x3f\x6c\x64\x53\xa8\xe2\x89\xac\xaa\x99\x9c\x5f\xfe\x93\x67\x57\x58\xcb\xd9\x92\x67\xd0\xc8\x52\x9a\x27\x72\x73\xb1\x6c\x1d\x9f\x90\xd6\x8d\x0b\x60\x25\xc8\xb9\x3a\x5c\x2d\x2d\x62\x1f\x21\xc7\x95\x14\x65\xf1\xbd\x6c\xea\xc7\xf6\x50\x03\xeb\xfa\xae\x91\xb5\x29\x89\x4b\xf3\x22\x03\x2b\xfa\x56\x61\x41\xb0\xf0\xb0\xb8\xaf\x5c\x51\x5b\x0e\x75\x60\xcf\x75\xf3\x9d\x83\x8f\x0c\x72\x2d\x01\x2f\x60\xa5\xad\x1b\x07\xd6\xf8\xb6\xf6\x15\x92\x1c\x77\x89\x9e\x2c\x65\x2f\x2e\x54\x90\x9c\xed\x4f\xae\xc6\xc7\x8f\x44\xdb\x01\x51\xeb\x28\x58\xd8\x47\x8e\xf6\xcf\x51\x47\x7f\x19\x32\xf3\xdb\xa9\x80\x68\x48\x11\x48\x4f\x64\x8d\xcc\x34\x19\x65\xa4\x70\x33\xb3\xd7\xc8\xfe\xd5\x92\x28\xa0\x4b\xc1\xec\x83\xac\xdb\xc6\x6c\x80\x8c\xaf\x94\xac\x0d\x3c\x20\xa4\xe7\x37\xb4\x0f\x13\x97\x61\x91\xfe\x05\xad\xe8\xc6\xf2\xf6\x73\x9a\x0e\x64\xf2\xae\x03\x7e\xa7\x48\x3b\x41\x43\x8f\x7e\xa8\xd7\x53\x4b\x76\x28\x82\x09\xc7\x03\x2f\x32\x92\x8a\x42\xf9\x64\x41\xbf\x62\xef\xe0\xf4\x68\x12\x6f\x82\x83\x4b\xbb\xd6\xba\x32\x8d\x53\xe6\x6c\x50\xb6\x83\xef\x28\xcf\x2e\x3f\x18\xa9\x63\xbb\xb3\x23\xc0\x9e\x3f\xb5\xb2\xc6\x13\xd4\xcd\xa1\xde\x79\xbd\x94\x46\x25\xce\x49\x47\x2e\xe6\x9a\xce\xf5\xd1\xa3\xc8\x76\x31\x70\x03\xc6\x42\x0e\xa6\x27\xc3\xed\xe2\xf1\x74\x3a\x3d\x79\x24\x9e\xc8\x1a\x94\x88\x12\xf3\x15\x3b\x95\x00\xa9\x2f\x93\xd1\x1d\x9f\x70\x64\x9b\xe1\xeb\xb9\x2f\xb7\xc5\x11\x8a\x06\xf9\x09\xe7\xa8\xc3\x75\x27\x4c\x33\xa4\x8b\x50\x6c\x1a\xf7\xae\x7f\x28\x0d\xdc\x02\x50\xa4\x88\x36\x90\xa1\x63\xb3\x99\x2f\x85\x44\xbd\x5b\x59\xc3\xb1\xfc\xec\xaf\x38\xde\xbf\x42\xa8\x49\x8d\x0a\x3c\x7f\x8e\x30\xc8\xdd\x0a\x87\xf3\x56\x37\x27\x53\xf1\x06\x0a\x8b\x95\x6a\x97\xba\xf0\x88\x59\x9f\xd9\xf3\x3d\xb3\xb7\x11\x94\x79\xfe\x24\xe9\x05\x79\x97\xd9\x87\x0d\x86\x73\xc6\xdb\x8b\x10\x8a\xc0\x61\x1c\x2e\x8a\xb4\x77\xac\x2d\x1f\xae\xa5\x95\xa2\xea\x09\x68\x7d\xe7\xb2\x16\x33\x25\x30\x2b\x7e\xab\xc5\x5f\x23\x5c\x42\xc8\x17\xf8\xd7\x69\x66\x17\x7b\xe8\x71\xef\x2e\x7e\x22\x8d\x43\x2a\x40\xbf\x25\x3f\x84\x66\x30\x32\x77\x19\x61\xd0\x64\x21\x70\x5c\x9d\xb3\x34\x94\x27\x5b\x2f\xf9\x98\x56\x4e\xc3\x9f\xc5\x39\x1f\xc2\x34\x1f\x1d\x9d\xc6\x47\xf7\x57\x62\x20\x3b\xdd\x50\xe6\xa4\x5a\xb7\x80\xa7\x39\xef\xc3\x84\xbe\x51\x17\x65\xfd\xbd\x6e\x2e\xa3\x69\xfa\x5f\x69\x7e\x89\xe1\x3f\x5d\xa2\x89\xf7\x0a\x01\x44\x25\x38\xae\x9b\x56\x3d\xfb\xb0\x2e\xb1\xdc\x73\xdd\xa0\xa9\xc3\x8d\x7e\xc6\xba\xcd\x8d\x66\xea\x0b\x44\x35\x9e\x03\x47\xbe\xb7\x5e\x28\x96\x9b\xb2\x25\xcf\x95\x6a\xd5\xf7\x3a\x9a\x73\xf8\x79\xec\xb4\x4f\x18\xd2\x93\xaf\x1a\x0f\x2c\x34\x3a\xe5\x85\x7a\x86\x45\x90\x54\xe9\xb0\x3c\xe6\x26\x0d\x8a\x24\x70\x54\xac\xc4\x68\x53\x29\x92\x56\x67\x34\xd4\xd6\xf4\x20\xe0\xad\x3d\xad\xec\xc1\xe3\xda\x53\xbb\x1f\xa6\x6b\x4f\xc5\x21\xf4\xae\x3d\x55\xf7\x82\x7a\xed\xa9\xbf\x0f\xeb\x6b\xef\x94\xa9\x9c\x3f\x07\xb5\xde\x06\x04\x80\x5a\x6f\x5d\xbb\xee\x5e\x3d\x55\x0b\xd5\x34\x81\xad\x66\xe8\x02\x3d\x25\x5c\x0b\x1b\xa3\xde\xee\xea\x39\x91\x4b\xd4\x97\x53\xd5\xce\xa7\x24\x40\xfd\xb9\xa6\xa1\x87\x2a\xe9\x97\x88\x1a\x01\xc2\x7a\x5a\x23\xfd\xe2\x14\x81\x6f\xd4\xda\x7e\xaa\x5b\x13\x59\x38\xdb\x72\x05\xb6\xc4\x95\xf1\xb1\x95\xa6\x95\x4d\xfb\xae\x5c\x21\x20\xef\xf6\xd8\x13\xdb\x95\x36\xed\x1b\x35\x57\x75\x4b\xec\x0f\x15\x5a\x99\x77\x3a\xd0\x1e\xfb\xe3\xf1\x6f\x4e\x7a\xfa\x55\xbe\x1c\x76\x0d\x3e\x29\x65\x3d\xd7\x2b\xbb\x54\x1b\x62\xc6\xe8\x59\xdd\x18\x35\x15\xc7\x84\xc7\x70\xcf\x39\x12\xbd\xd2\x48\xf5\x9c\x6c\xe8\x74\x97\xa6\x6d\x64\xab\x2e\x76\x8f\x84\x34\xbb\x7a\xee\x1b\x2b\x6b\xfa\x61\x05\x11\x78\xf6\xaf\xd8\x16\x2b\xe0\xbf\x4f\x4f\x68\xb2\x61\xa0\xe1\x95\xc0\x9e\xfd\x21\x2a\x8d\xfd\x67\x1a\x3a\x4a\x91\xb1\xe0\x4b\x08\x7a\xed\x32\x84\xb8\x91\x2f\x1e\x86\x93\x81\x19\x37\x18\x79\xb7\xd4\x16\xfa\x4e\x3a\x23\xda\x77\x75\xd9\x7e\xbb\xa0\xdb\x99\x86\xb7\x52\xfe\x76\xf7\x33\xf5\x0c\xeb\x6a\x3b\x58\x96\xf3\x65\xa7\x1b\xe4\x76\x6c\x47\xb6\x43\xde\x15\xb2\x36\xf1\x46\xc6\x93\xe6\x53\xa3\xbc\x95\x65\xbb\x04\x9e\x8b\x52\x62\xe5\x26\x86\x77\xb0\x25\x45\xb2\xeb\xcd\x47\x84\xe1\xe8\xb1\xf5\x7f\x51\x6a\x6d\x19\x36\x04\xa8\xc6\x09\x2c\x10\x9d\x06\x8c\xad\x4e\x17\x1a\xd4\x37\xd0\xa3\xb3\xf2\xce\x94\xd3\x51\x91\xca\x1a\xd6\xad\x34\x84\x60\x5f\x38\xe0\x67\x50\xbd\x55\x95\x42\x26\x46\x42\xa2\x02\xcf\x4e\x3d\x2d\x8b\x27\xa0\x8e\xf2\x8e\x50\x53\x0f\x88\xc0\x34\xb1\x26\x5e\xf8\x7d\x23\x27\xdd\x16\x71\xa9\xfc\x06\xce\xa0\x33\xc2\xb1\xe4\xaa\x76\x10\xa5\x8a\x72\xb1\x50\x50\x0e\x33\x9f\xc9\x3a\x19\xc6\xc4\xeb\x49\x42\xe6\x4c\x84\x55\x83\x6c\x97\xf7\x7c\x9a\x23\x55\x17\xce\x82\x03\x5d\x06\x81\xcd\x2e\x1f\x79\x02\x34\x7a\x2d\x2f\x2c\xd7\xac\x70\x8e\x73\xdd\x60\x56\x24\xcb\xc4\xcb\x7b\xe4\xea\x3a\x43\xdd\x9d\x2c\x2b\x83\x9a\x2c\x18\x97\xae\xe7\xca\x2d\x15\x4e\xf7\x9b\xa0\xf9\x8a\x16\xeb\x59\xa2\xf2\xc2\x5d\xec\x6e\x6e\x66\xb5\xf0\x30\x4d\xa3\x1c\xda\xaf\xad\xfc\x95\xed\x0b\x86\x52\x36\xa6\xfd\xae\x9e\x47\x8a\x0d\x5e\xa0\x28\x8b\xe7\xb2\x95\x55\x74\x8b\x5d\x26\x43\x77\x74\x53\xbd\x44\x69\x48\xfc\xcc\x5c\xff\xef\x8c\x3d\x6a\xba\x11\x6b\xd5\x2c\x74\xb3\x02\x6b\x2a\x9c\x0d\x76\x07\xca\xba\x55\x4d\xb3\x59\xb7\xaa\xf8\x66\xc7\xaf\x41\x6c\xd3\x7d\xc2\x40\x8b\x8e\x23\x90\x73\x97\x09\x0f\x94\x65\xc1\x9a\xfa\x4f\xbf\x3d\x0e\x2e\xa2\xa1\xd4\x1c\xe0\x8b\x4c\x28\xe7\x25\xbf\xb3\x7b\x79\xf6\xf6\xb8\x17\x90\xfc\x71\x55\xd9\x92\x78\x83\x8d\x1f\x15\x33\xe3\xf7\x46\xa9\x06\x49\xaf\x47\x96\xb6\x23\x63\xff\x66\xad\x9d\xa4\xfe\xdb\x8d\x9a\xeb\xa6\xc0\x8f\xc7\x4e\x83\x49\xc4\x9b\xc5\x24\x87\x16\x42\x74\x28\xf7\x88\xdf\x9f\x78\xb0\x8f\xd9\xcb\x0f\xae\xa7\xe9\x37\x6a\x91\xa6\x3a\x0a\x58\x52\x6c\x8c\xb2\xb2\x32\x9f\x6c\x55\xec\xec\x98\xa2\xfd\xe6\xf2\xf5\x7b\x36\x27\x01\x9b\x17\x91\x83\x59\x70\xe7\xb1\xb4\x7c\xa1\xab\x4a\x6f\x41\x5a\x46\x25\x07\x48\xa9\x2b\xf2\xe5\x04\x4d\xd3\xdc\x5e\xec\xa6\xb6\x17\x13\x14\xd6\xeb\x94\xfd\x0c\x4f\xe9\x04\x04\x5d\xe7\xa7\x6e\xc0\x51\x5d\x82\x49\xc7\xd2\x18\x8a\x1b\x90\x45\x21\x24\xea\x0a\xec\x25\x51\x57\xaa\x61\xde\xea\x6b\x6d\x4c\x39\xab\x94\x98\x95\xed\x4a\xae\xc5\x95\xac\x36\xe0\x90\xcf\xf2\xc2\x08\xa3\xe6\x1a\xb5\xf6\x4e\x78\x76\x90\xfe\xa1\xa1\x90\xa5\x11\xa5\x6f\x9c\x1e\x40\x54\xc8\x16\x9b\x9d\xb2\x23\xb3\x6e\xca\x95\x6c\x76\xcf\xd8\xc9\xe1\xdb\xf7\x1f\xc7\x9e\x15\xfc\x68\xe9\x97\xf8\x18\x27\x87\xfc\x68\x37\x58\x7c\x14\xaf\xf1\xca\x27\x68\xdf\x3e\xd9\x53\xd2\x49\x27\xe6\x38\x60\xef\xb2\xdd\x4d\xbc\x55\x93\x94\xb0\x99\x43\xe8\xd7\x00\xb3\x58\xda\x15\xfb\xcc\xef\xda\x67\x94\x12\x2f\x2c\x8f\xd1\xee\xe1\x16\x97\x96\x31\x26\xb7\x6e\x7c\x1c\x9c\x97\x9b\xcb\x6c\x98\x76\x21\xeb\x9d\xa8\xca\x85\x7a\x38\x47\x41\x00\xcc\xc1\xfc\x31\x05\xd5\x84\xb8\x50\x2d\x7f\x4e\xa3\x26\xd0\x9f\x69\x51\xd6\xc5\xd3\x6f\x5f\x42\x20\x97\x83\xde\x6a\x54\xb5\xc3\x2d\xb3\x8f\x61\xbd\xc3\xd7\x66\xb6\xb1\x87\xf3\x25\x2a\xff\xd2\xc6\x6c\x55\xd8\x70\x5f\x02\xb0\x7b\x2d\x17\x3a\x87\xe8\x07\x59\xef\xb6\x72\x67\x27\xbd\x55\x8e\xd1\x9c\x29\x21\x67\x55\x67\x6e\xad\x16\x97\x60\xbc\x5b\x96\x09\x4c\x7d\x8e\xa8\x40\xc2\xcf\x24\xe6\xdc\xfd\xd9\x17\x19\xec\xab\x3d\xae\x49\x23\xd9\x7f\x00\x4e\x4f\x43\xf1\x9f\xf3\xc9\x18\xb3\xc6\x69\x9f\xb8\x76\xd1\xaf\x20\xf6\x8f\x25\xb5\x22\x12\x88\x8f\xdf\xfb\xb4\x1b\xbd\x6b\xb9\x6f\x67\xf7\xed\x26\x1f\xde\xe7\xd7\x1d\xdf\xe7\x37\x18\xa0\x87\xf1\xee\x1d\x62\xc2\xeb\x74\xf3\x9a\x25\x29\x59\x7a\x87\x92\x67\x9a\x46\x0d\xd6\xe7\x95\x89\x44\x87\xb0\x56\xe1\xaf\x91\x33\xa9\x9b\x48\x0f\xb7\x81\x9c\x10\xe7\x37\x4e\xfa\x22\x39\x3d\xeb\x13\x74\x19\x07\x71\x3e\xe3\xd8\x92\x1e\xe6\xe1\x98\xac\x2f\x1f\x85\x7b\x85\x4e\x62\x44\xb7\x98\x13\xe2\x67\x6b\xec\xc9\x4f\x15\x35\xc7\x43\x47\x7f\x2c\x97\xd3\x37\xb0\x44\xab\x73\x10\x23\xf5\xac\x69\xc6\x77\x01\xfc\xfe\x1f\xc9\x72\x3f\xd8\x8d\x93\x4b\x87\x8f\x15\x8a\x2f\xb5\xd9\x34\xca\x53\xc6\x79\xa5\xd0\x6d\xdc\x28\xb1\x59\x73\x9a\x89\x76\x6f\x39\x9f\x97\x85\xaa\x5b\x30\xbe\x41\x12\x26\x9e\xc0\xed\xf4\x54\xbc\x38\x5a\x81\xd8\x26\xe7\x2d\x5a\xe8\xa8\x79\x40\xc6\x6a\x5b\x2b\x43\xb2\x0c\x5f\x18\x3f\x88\x22\x1e\x03\x5d\x09\xcd\xd9\xc7\x8f\x61\xae\x04\xc7\x65\x2b\x96\xeb\x1a\x19\x2e\xf0\x51\x46\xff\x3d\x6f\xc1\xc7\x55\x5e\x6c\xaa\xd0\x96\xae\x95\x99\x8a\xb7\xda\xfb\x5c\xb7\x9a\xe6\x0b\xad\x60\x2c\xa8\x34\x21\x7f\x06\x61\xdf\xc0\x1b\x3b\xed\xdc\xd9\x69\x46\xf2\xef\x5b\xd6\xc6\xcb\x2e\x61\xf7\x21\x06\x89\x2d\xf0\x5c\xd6\x9e\x47\x50\xc9\x32\xb4\xf2\x82\x30\xc6\xa5\xb1\x52\x3e\xa6\xf6\x67\xa2\x64\x78\x9b\xba\x03\xa5\x53\x30\x4c\x0c\xde\x68\xdd\x9b\x91\xff\x7b\x45\x5b\xdd\xf8\x6c\x5b\xa5\xf1\x43\xe7\x1a\x65\x98\x04\xa9\x23\xe0\xcd\x0c\x72\xb1\x6b\x8c\xd7\xc9\x4b\xc7\xa8\x04\x04\x43\x24\xe6\x1e\xa1\x59\xe3\xa9\x94\x8d\xaa\x8f\x7c\xae\xd8\x4a\xcf\x65\xe5\x83\x04\x03\xe8\x4e\x38\x65\x24\xfc\x43\xb7\xe0\xdc\xe5\xfa\x9a\x7f\xff\x9d\x6d\xcc\xb5\xe4\x25\x76\x55\x19\x05\x01\x62\x13\xee\x54\x08\xb1\x83\xe4\xbe\x03\x9c\xc5\x4c\xd9\x46\x98\xe4\x4b\xce\x58\x4c\x8f\x16\x1e\x97\x44\xfa\x0e\x1f\x40\x3f\x89\xdf\xde\x95\x2b\xa4\xd9\xf7\x04\x03\xe0\xde\x93\x36\xe6\x3e\xc0\x70\x27\x80\xc5\x7c\x13\x73\xb9\x03\x9c\x39\x35\xa4\xa1\x32\x72\x45\x4e\x4c\xd2\x10\x07\x14\x54\x2a\xeb\x46\xcf\xe4\xac\x72\x90\x9e\x8d\xc2\x64\xbe\xe4\x40\xe2\x62\x1f\x4a\x55\xdd\x55\x42\x1d\x98\x62\x69\xde\x28\x59\xec\xb8\x5e\x39\x28\x2a\x22\x05\x01\xfa\xc9\x41\xdc\x0f\x65\xa5\xb7\x1c\x99\x5d\x79\x7b\x4b\x90\x81\xbb\xe7\x1f\x52\x7a\x31\xbf\xdd\xd6\x8a\x23\x22\x7b\x15\x06\x53\xbc\xf8\xeb\xc4\x07\x87\x41\x0a\x6c\x87\xc2\x0d\xff\x2a\x91\xa0\x78\x74\xcc\x63\xd4\xa8\x1d\x19\xc7\xa2\x02\xbc\xd7\x5c\xd7\xa6\x34\x2d\x09\xab\x7a\x11\x65\x07\x47\x0a\x47\xae\xc4\x96\x8e\x95\x0b\x46\x21\xec\x56\x68\xc8\x16\x63\x82\x12\x33\x8a\x1b\xb1\xb2\x6a\xd9\xba\x7d\x63\x2a\xb4\x8a\x32\x46\x30\x81\xb3\x51\x66\x53\xb5\xb8\x66\xc6\x87\x42\x92\xda\xae\x15\x5b\x92\x34\x2a\x8d\x62\xb0\xeb\xfd\xc8\x08\x97\x89\x9d\x0f\xae\xb4\xc3\x2a\x2c\x01\x3e\x23\x25\xb9\x95\xae\x29\x9b\xaa\x93\x7a\xc9\x6f\x13\x4e\x21\xba\x57\x39\x8a\x00\xfb\xcf\x5e\xd0\x68\xb9\x07\x81\xc4\x92\x4c\x5a\x7d\x58\x62\xbc\xd0\x19\xab\xca\xf7\x3c\x6a\x88\x7d\xea\x75\x49\xec\xaf\x3e\xe8\xf4\x87\xba\x0c\x8c\x42\xae\xb5\x3b\x1d\x84\x46\xc9\x57\xe2\x90\xe1\xb9\xe0\x8f\xc4\x02\x73\xcc\x7c\xe5\xe8\x56\xb9\x5d\x89\xac\xf9\xe4\x62\x20\xd1\x69\x51\x7c\x8f\x78\x00\xda\xc1\x4c\x88\x76\xab\xc5\x5a\x1a\xa3\x0c\x83\xae\x77\xf0\x02\xf6\x83\xd3\x1e\x1a\xdf\x3e\xc4\xcd\x86\xd4\xf6\x93\xa0\x75\xf1\x1a\x17\xfb\xf8\xdf\xf3\xe7\x71\xe1\xc8\x2f\xf5\x91\x6c\x60\x32\x61\x46\x57\x99\x7a\xcf\x93\x58\x71\x00\xa3\x5b\x94\x85\xd3\xb4\x46\x4c\x3e\x08\x3b\x8a\xbe\xc4\xf9\xbf\x22\xd8\xe5\x9c\x07\xdc\xb1\xed\x66\x92\x55\x41\x4e\x70\x08\xb1\xc6\x2c\x76\x71\x3b\x3e\x89\x35\x66\x6c\x84\xa9\x3c\xe3\x07\x98\x7a\xbb\x1d\x67\xf5\x69\xa1\x47\xd7\x26\xef\xe9\x7e\x7e\xb1\x72\x4f\xcc\x5b\x96\x7d\x0d\x38\x51\x3c\x4a\x77\x98\x71\x8d\xb3\x21\x6c\x9c\x13\x5a\x82\x38\xe7\xec\x13\xcb\xf6\x3d\xdc\xac\xa3\x45\x1e\x3c\x09\x9d\x23\x37\xc8\x58\xe7\x83\x60\x4d\xab\xd7\xfd\x67\x12\x9f\xba\xc4\xe2\xc9\x6f\xe8\x3b\xca\x17\xf9\xb0\xac\x1f\x7a\x23\x1c\x92\x4b\x4c\x3a\x1d\xd9\x42\xe1\xa6\x22\x62\xe5\x06\x23\xd7\x15\x5a\x87\x02\x23\x16\xdd\x50\x7a\x0b\x38\xf7\x35\xf1\x3c\x1e\x84\xca\x34\xea\xaa\xd4\x9b\xd0\x65\xe4\x6e\xea\xfa\x75\xcc\x55\x26\xd1\x28\xfa\xfe\xd0\x93\x1c\x34\x9f\xd0\xbd\xef\x2a\x1e\x1d\xd2\x34\x32\x3d\x9a\xde\x4e\x9c\xfe\xe5\xf4\x3b\x06\xbd\x10\x31\x46\x29\x01\x76\xdd\xbc\xa8\xd3\x91\x10\x64\x09\x11\x2c\xa0\x57\x5c\xf1\x83\xd8\x9a\x0b\x60\x29\xec\x5d\x0e\x14\xef\x4f\xac\xd4\x52\xae\xd7\xaa\x46\x2c\x1d\x63\x69\x2e\x62\x4e\x98\xc0\x35\xdb\x76\xbd\xb2\x8a\x91\x3f\xd7\x5a\xa4\x7b\x76\x6f\xa3\xaa\xdb\xb2\xa1\x27\x12\xa3\x46\xc9\x6f\x18\xb0\x86\x91\xd6\x14\x71\xf6\x10\xe8\x14\x22\x36\xdb\xa6\xbc\xb8\xb0\xf2\x17\x86\x9a\x62\xc8\xcb\x43\x0f\xb4\x41\xae\xf1\xee\x39\x3e\x90\xc8\x06\x59\xfb\x5a\x34\xf6\xfd\x7e\x22\xfb\xf9\xcd\xa9\x2c\xf3\xdc\x38\x9c\xc8\xbe\xdf\x4b\x65\x3f\xbf\x06\x99\x7d\xff\x73\xa3\xb3\x9f\x27\x8b\x7a\xa7\x44\x35\x27\x5b\xb1\xe3\x93\xf1\x69\x88\xc9\x70\xcf\xa9\x0d\x05\xa2\x9f\x01\xca\x6d\xb7\x56\x7a\x21\x74\xfd\xc4\x4b\xcd\x10\xf2\x75\xe4\x44\xcf\xa3\x30\x3b\x5e\xa8\x27\x91\xe9\x49\x1a\x4d\x6f\x4f\x96\x78\xf0\x60\x28\xd8\x6f\xea\x03\x04\x4f\x62\x95\xe0\xbe\xe2\x53\x37\x20\x50\xb7\x66\x32\xb9\x7e\x4a\x02\xd3\xd1\xcc\x0c\xf4\x82\xa4\x68\x2f\xa6\x63\xc0\xcf\xaa\x64\xee\x7b\x96\x42\x95\x4d\x4e\xe2\xd7\x1d\x48\x9c\xac\xad\xfb\x24\xc9\xf8\x98\x7c\x9e\x2e\x74\xf3\x4c\xce\x97\xc7\xae\x43\x38\x82\x6f\xd4\x5c\x5f\xa9\x66\xe7\x8f\xdd\x3e\x33\x7a\x38\x37\x20\x49\x74\xec\xe9\x3d\x04\x0a\x16\xe0\x0b\x47\x05\xa3\x2a\x67\x9c\x21\xef\x33\xce\xe3\x81\x88\xbe\x1e\x53\xa3\x27\x1d\xc8\x00\x0f\x04\x40\x6e\x2b\xfc\x29\x9b\xaa\xc8\xa9\xe5\x2c\x4c\x26\xa9\x75\xee\xdc\x5d\xb8\x37\x77\x8f\xd3\x07\x0c\xbf\xdf\xcd\xc1\x0f\xce\x25\xe0\xe3\x3d\xf5\x04\x70\x27\x4e\x54\xf6\x09\x7f\x51\xbf\x26\xb6\x65\x42\x0f\x90\xfd\xc4\xc1\x2e\xc2\xaf\x98\x04\x11\x72\x8e\x3c\x78\x20\xe2\xda\xc9\x12\xe0\x54\x6d\xd1\x93\x44\x8a\x0a\xf8\xda\x4e\x69\x15\x02\x7b\x64\xa3\xc4\xb2\x2c\x0a\x55\x4f\x29\x27\xd8\x6c\x33\x9b\xb9\x63\x1c\x9a\x49\x9c\xbc\x4c\x8c\x89\x91\x5e\x9c\x27\x10\x17\x80\xfe\x12\x80\x2c\xe9\x1e\xf6\xa9\xdf\xdc\x5a\x6d\x3b\x7e\x49\x17\x8a\xc2\x3b\x06\x57\x8d\xf3\x82\x60\x66\xb4\x4f\x9d\xf1\xf2\xfd\x15\xc4\x6e\x79\xda\xe2\xcb\x7e\x83\xf3\xda\xac\x91\x87\x80\x1c\xe3\xa6\x4d\x27\x16\x06\x38\xa7\xd4\x22\xc9\xa2\xc3\xcf\xd1\xb3\x8e\x05\xbb\x17\x06\x6e\xb8\xfd\x96\x6e\xd4\x7d\x7f\x26\xed\xa6\x1e\x67\x56\x22\x14\xf8\xf8\x31\xb3\x52\x5f\x89\x5c\xbb\xd1\x4b\x9d\x5b\xde\x5c\xa5\xd4\x03\xc3\xcd\x1a\xcb\x76\xf2\xf6\x8b\x7d\x67\xb0\xdb\x71\xd6\xe5\x04\xdc\x78\x83\x23\x5c\xba\xc3\xb1\x11\xc6\xbe\x06\xdd\x33\xed\xb3\xe7\x57\x1b\x4b\xc0\x27\x14\x1b\xe0\x8e\x38\x3a\xb3\x91\xc6\xc6\x1b\x47\xb8\x8a\xbe\x50\xa0\x99\xaf\x09\xfe\x90\xec\xc6\xdc\x3e\x8d\xac\xba\xfd\x05\xbd\xf8\x40\x83\xa3\x1a\xa6\x20\xc2\xc0\x9b\xd8\x38\x00\x07\x51\xd6\x10\x96\x68\xe7\x2b\x2b\x54\x0b\x3a\xed\x05\x79\x10\x86\x46\x9c\x14\xc3\x7d\x17\x02\xc7\x9e\x2c\x78\xc7\xce\x73\xb0\xff\x4d\xe7\x36\xc5\x27\x80\x59\x4d\xe6\x91\x3f\xb7\x5b\xf0\x94\x86\xf5\x39\x1a\x9e\x8c\x1e\x61\xaf\xcd\x2e\x31\xe6\xc4\x70\x62\xf1\x38\x52\x20\x22\x72\x7c\xc5\x03\x9c\xaf\x12\x8e\xb7\x27\x66\xfb\x29\xf6\xc0\x6c\xd9\xbd\x87\x05\xcc\x71\x7a\x96\xa9\xb2\xcb\x89\x2c\x55\xcf\x56\xdc\x88\x09\x12\x87\x31\x42\x61\x83\x7b\x07\xf3\x89\xeb\x0c\x5e\x2c\xdc\xb1\xf0\x2c\x10\x1c\x68\xb3\x96\xdb\x5a\x15\x80\x08\xb8\x05\x67\x5e\x82\xb3\x84\x15\x73\xda\x32\x2b\x7f\xf3\xd6\xc0\xfb\x06\xf4\x7c\x90\x6f\x21\x78\x0b\xd0\x13\x5b\xb3\x1c\xe7\x91\xf9\x70\x1f\x52\xdc\xe9\xa9\x78\x6c\x85\xcf\xa2\xa3\x60\x25\x09\xdf\xb9\x3c\x62\x86\x07\x4f\x30\x7c\x9e\xdb\xc8\xf6\x84\x46\x16\xca\x3c\x11\xd0\xf0\xd0\x2e\xe3\x96\x03\x52\xdb\x14\xb6\x8d\x45\x94\x6b\x42\x48\xea\x39\x41\xda\x63\xba\x45\xac\x38\x8d\xb6\xbf\x37\x13\x43\x56\x7e\xe8\xcf\xdb\x90\x9c\xf9\x8c\xce\x96\xef\x30\x04\xc4\xc7\x35\xf6\xa8\x96\x0f\x4c\x6a\xd1\x1d\x6e\x9f\x3a\x7a\xcc\xc0\x73\x68\xcf\x99\x14\x15\xbd\x33\xe2\x4b\x90\x9c\x72\x76\x28\x96\xb2\x88\x34\xc1\x60\x4f\x90\x78\xbc\xca\x56\x3c\x7e\xfe\xee\xd9\x9b\x68\xcb\x8f\x4c\xcf\x46\x1b\x80\x8e\x9a\xcb\xda\x6b\x56\xe6\xaa\x69\x65\x59\xc7\x9a\x66\xe4\x4e\x9a\x60\x3d\x80\x76\xd0\xa9\x77\x62\x05\x57\x80\x81\x11\xab\x4d\xd5\x96\xeb\x4a\x91\xd6\x59\x58\x11\x80\x1d\x5e\xb2\x68\xf8\x68\xed\xad\xac\xa3\x03\xcd\xa1\x68\x5d\x20\x78\x74\x28\x6b\xff\x33\x9c\x7d\xef\x95\xbc\x00\xb3\x09\xd3\x1b\x82\x6a\x1a\x81\x0d\xfc\xa9\x47\x05\x12\x13\x8b\x4a\x13\xd4\xf8\xad\x26\x0b\x0e\xd9\xb2\xc1\xc1\x9c\x37\x47\xda\x36\x55\x17\x31\xa2\x24\xf7\xb7\x48\x59\x91\xd4\x15\x14\x1a\x7a\x7b\x59\xae\xc5\x4c\xb7\x4b\xc7\x51\xd9\x0b\x1f\x19\xa4\xd0\xac\x0c\xc9\xaa\x23\x34\x03\xbe\x88\xbc\xc5\xb8\x32\x95\x02\x8f\x74\x09\x4a\x85\x18\x33\x07\x58\x08\xe4\x2d\x80\xbb\x76\xba\xc5\x96\xfb\x46\xc5\x0e\x11\xbd\x06\xb3\x1f\xed\xb2\x45\x17\x2c\xb5\xe8\x1c\x42\x6e\x6e\x78\x53\x07\x9c\x5d\x47\x3d\xa4\x37\x7a\x46\x6f\xf3\x11\x8d\xde\xae\x88\x29\xe9\x79\xbc\x5e\x2c\x02\x0a\x2f\x78\x48\xc2\x23\xdb\x02\x48\x74\x49\xde\x93\x51\xe6\x9c\xe8\xb5\x4d\x9f\x51\xde\x63\x62\xa9\x1b\xf9\x98\xba\xf1\x1c\x81\x39\x2e\x8c\x28\x33\x96\xa9\x70\x2b\xc2\x2c\xe3\xf8\xc5\xb7\x18\x2f\x53\x2e\x23\x95\xa0\xf4\xbe\x65\x1d\x94\x8c\x9d\xa3\x88\x68\x8f\x57\xe0\x1b\xe1\x21\xbf\xb9\x75\x30\xf2\x20\x48\xb9\xbf\x2e\xb6\x68\x9f\x89\x3d\xd6\x74\x3a\xde\x84\x69\x0d\x3e\x25\x02\xf0\xf7\x65\xbb\x44\xe7\x14\x4b\xf5\x3e\xac\xab\x72\x5e\xb6\x68\x8c\xa7\xda\xcf\x2b\xbd\x45\xd6\x41\x96\x35\x70\x25\x25\x46\xaf\x7b\xc8\xa9\xdd\x5a\x71\x39\x57\xbc\x09\xce\xd2\x08\xd5\x03\xe2\x11\x49\x47\x95\xd6\x6b\x57\x5a\x99\xaa\xac\xdb\x87\x45\x69\xe4\xac\x52\x0f\xed\x89\x78\x58\x95\xb5\x12\xb5\x7e\xb8\xa9\x61\xa9\xbc\x6b\x6c\x32\x97\x04\x97\x13\xc9\xd0\x5e\x39\xed\x16\x44\xb2\x5b\x10\xc8\x6e\x41\x1c\xeb\x08\x63\x63\x45\x31\x57\xfb\xad\x82\x1b\x05\x21\xb4\x75\x86\x41\x66\x97\x79\x4a\x4a\x56\xd9\xb4\x7b\xe8\xd8\x1e\x8f\xc7\x51\xf2\x5d\x9c\x61\x42\x9c\x87\xf0\xe1\x6b\x0b\x76\x37\x71\xc4\xfc\x51\xd4\xbc\x21\x04\xbb\x67\x49\xfc\x40\x6a\x9f\xce\x3e\xa2\x7c\x99\xcc\xd1\xb0\x8b\x4c\xc8\x99\x73\x52\xe7\x4e\x4a\xd8\x5e\x91\x8a\xd2\xfd\x77\x29\x1a\xd4\x48\x9f\x9c\x44\x4a\xca\xde\x5e\x8c\xe4\xfe\xe5\x0e\xff\x5c\xef\x70\x88\xd4\xff\xe5\x26\xff\x4c\x6f\xb2\x6d\xff\x4f\x5a\xaf\x8f\x13\x85\x2f\x33\x19\x24\x36\x8d\x2e\x17\xc7\x79\x4a\xd9\x28\xb1\xa9\x1d\xf6\x9b\xa2\xa0\x53\x8a\x68\x22\xfd\x87\xb1\xfc\x09\x1c\x7a\xcb\x5a\x30\xbd\x29\xea\xdc\xff\xa8\xb7\xe0\x4c\x07\x76\x51\xb4\x29\x20\x3a\x1f\x5e\xc8\x85\x04\x87\x8a\x76\xf9\xb5\x78\x29\x77\x33\xc7\x09\xa2\xb5\x3d\xb4\x35\x07\xea\x70\x99\x09\xb4\xb5\x9c\x18\xc5\xd9\xa6\x23\x05\x09\x0e\x40\x70\x64\x68\x69\xa1\x9b\x4b\x55\x88\x2b\xd5\x18\x42\x69\xc1\xde\xde\x30\x66\xd0\x4e\xe9\x7b\x5a\xca\x77\x4b\xd9\x82\x95\xc2\x3c\xd7\x0d\xbb\x42\x2a\xaf\xc2\xcc\x27\x28\xea\x0f\xb1\x4e\x14\xf8\x3d\xc5\xbe\x12\xf9\x0d\xcd\x9a\x55\x06\x3b\xfc\xfd\x79\x3e\x94\x3f\xda\xff\xe7\x96\xa4\x83\x3e\x0c\xba\x25\x8f\x12\xb7\x3a\xcc\x49\x81\x45\xa8\xe7\xc4\x81\x4e\x10\x7b\x97\x4f\x8c\x8b\xa4\x18\xcc\x1d\x57\x3f\x1a\x99\xd9\xd5\xf3\x65\xa3\x6b\xbd\x21\x7a\x0b\xf1\xce\x84\x08\x20\x0b\xe0\x61\x9b\x8d\xe5\x96\x37\xa8\x89\xf3\x06\x9b\x7d\xc3\x67\xf0\xd7\xff\xcb\x3e\x1c\xc7\x27\xb7\x3a\xa1\xce\x8d\xbd\xc6\x51\x63\x97\xf9\x1f\xf4\x5c\x79\xef\x13\x0e\x98\x9b\x2c\x7c\xac\xdb\xc0\xc8\x6c\x21\x33\xd7\xbf\xb3\x85\xac\x5a\xdf\x7e\x77\x58\xa5\x9e\x5d\xcf\x2a\x45\xae\x7f\x88\x3a\x1e\x1d\x3f\xb5\xfb\xf1\xcb\xc6\xf4\xdd\xf3\xf0\xc8\x00\xc0\xc4\x37\x95\x9e\x5f\x42\x2c\xc2\x84\x1c\x09\x10\xd7\xc4\x21\x92\x4e\x7a\x2e\xa6\xcf\x5a\x71\xa1\x29\xa2\xba\x51\xc0\x55\xe6\x50\x59\x63\x64\x05\x5f\xc0\xf3\xe0\x4f\x74\x3d\x57\x6b\x8c\x3b\x9a\x10\x74\xc7\xa6\xde\x96\xb5\xf7\x24\x47\x34\x4f\xf1\x7d\x70\x8a\xc7\xef\xde\x42\x01\x4f\x33\x42\xa4\x40\xd9\x89\x68\xb5\xc6\x0e\xb0\x24\x41\x0d\x98\xe3\xdc\x2c\x4f\xa2\x60\x84\xbe\x69\xa0\xba\x38\x73\x42\x3c\x17\x9f\x6e\x13\xce\x1c\x73\x07\xa0\x00\xe2\x1a\x3b\x0a\xe1\x01\x68\x93\x41\x17\x41\xd7\x92\x43\xa1\xdd\xcc\x1a\xe5\x33\x74\x07\xc4\xc3\xa9\x78\x9a\x8f\xbb\x99\x08\x89\x29\xb8\xa4\x77\xf0\xf4\xb1\x13\x84\x17\xc7\x72\x2b\x91\x2c\x12\x4f\x73\x42\xfc\x8c\x73\x3b\x74\xed\x48\xd1\xa8\x87\x78\x7a\x82\x8f\xe1\xa8\xa3\x9f\x59\xe5\x27\xa4\x27\x73\x80\x33\xd8\x62\x1f\xd7\x98\xf3\x54\x71\xa7\x98\xce\x6e\xfe\x94\xde\xbf\x1f\x5c\xc9\x72\x5e\x78\xa1\x19\x40\x19\xa6\x65\x69\xd4\x7c\xd3\x98\xf2\x4a\x55\xbb\x3b\xf2\xc7\xeb\x06\x1b\xc5\x97\x8a\xe2\xc4\xb4\x58\x6d\x10\x3e\xb0\xcf\x83\x78\xea\xd2\xa3\x35\x6e\x0e\xe4\xbe\x12\x2e\x05\x3a\x7b\x95\xad\xa8\xb5\xa8\x74\x7d\x01\xc2\xf0\x23\x97\x5c\x90\x6e\x93\x17\x25\xca\x96\xdb\x35\x47\x06\xf0\xa0\xf3\x4c\xe9\xf2\xc6\xc0\x05\xb2\x93\x83\x78\x2b\x29\x16\x8d\x32\x4b\x77\x2d\x31\x2f\x1b\x16\x6c\x94\xd9\xac\x5c\xc1\x20\x0a\xa3\xbb\x72\xb5\x13\x3b\x4b\xd8\xa3\xc7\x19\x74\xbf\x76\xaa\xf0\x0c\x38\xf4\xa1\x8f\x1f\x45\xc6\x61\xa5\x97\x45\x20\x46\x84\x9f\xdd\x9c\xf0\x91\xa0\x9b\x38\xf8\xc4\xa6\xf5\x28\x49\x0e\xef\x21\x52\xe0\x66\x10\x53\xce\x98\x3c\x46\x70\x49\xb6\x46\xf4\x73\x1e\xf7\x28\xef\xfa\xd2\xb9\x79\x88\xe7\xfd\x7d\x24\xd4\x1d\xbb\xde\xa6\x21\x88\x16\xdc\x6a\xb3\x02\x03\xb1\x56\x5e\x31\x00\x6c\x20\x28\x07\x3a\x2f\x8d\x97\xe9\xf3\xbe\xbf\x1e\x57\x3d\xf2\x43\xf3\x2e\x46\x83\x1e\xbf\x8e\x00\x0c\x0e\x75\xbf\xd3\x6f\xaf\xc7\xef\xfe\xa0\x8a\x54\x2d\xfe\xb8\x66\x28\xe4\xed\xb2\xd1\xdb\x9a\xc7\x3c\x22\x01\xa1\x98\xc7\x7b\x8c\x6b\xe9\xba\x07\x53\x70\x06\xa0\xfc\x24\xa6\x0a\xa0\x31\x5b\x70\x3a\x5f\x00\x08\x10\x3e\x8f\xe4\xde\x26\xdb\x56\xad\xd6\x2d\x21\xb7\x83\xc5\x14\x0e\x5e\xc9\x6c\x06\x59\x17\x46\xc5\x9d\x1c\x93\xb0\xf6\xc8\x4b\x65\xc1\x11\x16\xe3\xfd\xe6\x4b\xce\x8b\xf5\x38\x30\x64\x56\x6b\xb6\x69\xb9\x21\xc6\xe9\x12\x36\x75\xd9\x7a\xc0\x29\x5c\x81\xb9\xac\x79\x63\xe4\x8b\xdf\x13\x61\xea\xb3\x3b\x1e\x99\x40\x84\xb9\xcc\x3e\xe5\xc7\xc1\x61\x2b\xc5\xc7\xa1\x63\xad\x61\xb8\x34\x9f\x11\xef\xf8\x19\x7f\x22\x77\x00\x10\xe2\x86\x53\x2b\x69\x99\x1e\xff\x72\x4e\x23\x1b\x58\xad\x43\x63\x9d\x17\x56\x79\xe0\x38\x4e\x3a\xec\x5e\x78\x6e\xe3\x3c\xf6\xd8\xe6\x6c\x4b\x1c\x18\x73\xdf\x3f\xb0\x07\xf8\x9c\x2f\x20\xd5\x40\x07\x80\xfe\x0e\xde\xbb\x31\xc7\xdf\x2d\xf0\x56\x61\x20\xb8\xe7\x15\x33\x97\x02\x06\x88\x67\x23\xf2\x59\x00\x73\x78\xd8\x2b\x8f\x22\x66\x78\x9c\x63\x06\x29\x6c\xcf\x51\xe8\x0b\x70\xe8\x92\xb8\xf1\x81\x0d\x39\x1e\xdc\x91\xbc\x03\x58\xf1\x5b\x0a\x35\x1b\x13\x69\xd6\x5d\xa0\x6e\x58\x84\xe7\x5e\xa2\xf0\x1f\xcb\xdc\x89\x67\x1f\x4a\xce\x51\x73\xfd\x5c\x84\xfa\xeb\x1f\x90\x4d\x42\xca\x72\xce\xdb\x31\xcb\x54\xe8\x5a\x39\x0e\xd4\x03\x0b\x0a\x78\x46\x3d\x5c\xc0\x66\xed\xd4\xdf\x68\x89\x0f\x8f\x5c\x04\x84\xe6\xc2\x06\xb2\xe0\x68\xa2\x3f\x3e\xa1\x8b\xe1\x26\x86\xbd\xcb\x3d\x4b\xb3\xd9\xe3\xc9\x9e\x3a\xa0\x47\xe5\x4f\xb2\x9e\xde\x59\xce\xed\xeb\xd8\x23\xdd\x9b\x12\x58\x8e\xaf\x4f\x1e\x32\xd3\xb6\x13\x0b\x2d\x7d\x82\x1c\x70\x75\x20\x94\x53\xda\x03\x4f\x3f\x30\xdb\x5c\x11\xf9\xd2\x0e\x53\xb5\x20\x5f\xbe\x20\x28\x41\xc7\xb5\xa2\xad\x99\x81\x50\xa8\x0f\x65\x4b\xc3\xd8\x18\x40\x4f\x2c\xe8\x46\xef\x57\x61\x8b\x1b\x19\x11\xdc\x10\xdf\x2a\xd9\xcc\x97\x1e\x45\xde\x3d\x08\x09\x4d\xbd\x97\xa1\xed\xec\x00\x9c\x9e\x8a\xd7\xd2\x18\x64\xc4\x3b\xe9\x97\x4e\x62\xa6\x2a\x4d\xe7\x93\x30\x5e\x3c\x67\x4f\x8e\x27\x4b\x52\x09\xc5\xa3\xf8\x23\x66\xca\x25\xe8\x3d\xc4\x02\xf7\xe2\x24\xe0\xf4\x78\x71\x83\xe4\x53\xb4\x62\xa1\x5b\x14\x20\x45\x2e\xb5\x69\xb9\x3c\xee\x12\xc5\x5a\xda\x5c\x02\xb8\x08\x24\x5b\x2e\x5b\x03\x4e\x5a\xec\xe5\xac\x41\x1d\x47\xc8\xe7\xd2\x60\xea\x44\xd7\x14\x25\x2d\x0c\x86\x33\xec\xd2\x72\xe4\x10\x70\x6f\x70\x1f\x2c\xc7\xb1\xb9\x58\x32\x7f\x47\xc3\x12\x12\xfa\xa3\x06\x59\x09\xcf\xb3\xb9\x42\xd9\x0e\x2d\x62\x3c\x69\xd7\x4c\x69\x9e\xf3\x78\x8b\x1d\x6b\x37\x4d\x53\xef\xec\x37\xf0\xf0\xb8\x88\x3f\x2c\x3e\x21\x3e\x01\x42\x3c\xe1\x41\x86\x48\x40\xff\x1e\x6f\x43\x02\x4d\x72\x2e\x03\x1e\x90\x54\x2d\x0e\xcf\xa2\x8c\x12\x1e\x6c\x75\x63\xda\x87\x00\xa7\x64\xe6\xaa\x96\x4d\xa9\x7d\x24\x36\x35\x43\xc6\x4d\x58\xb3\x99\x0a\x30\x77\x37\xe6\xa5\xb2\x6a\x40\xc4\x38\x2e\x54\xb4\x98\x5d\xaf\x67\xa7\xe7\xb3\x25\xb9\x76\x2f\xec\x45\x8f\xe6\xd5\xd6\xf0\x7b\x09\x59\x30\x7c\x12\x86\xf8\xf1\x4b\x52\xa9\x43\xbd\x6c\x9e\x5e\x16\x29\xe6\xca\x4f\xbb\x98\xac\x7d\x71\x63\xec\x39\x4d\xaf\x69\x17\xae\x2a\x77\x1d\x3b\xa9\x3e\x6a\x0c\x35\x8b\x2a\x9e\x9e\x8a\xe7\x79\xe6\xed\x7e\x54\x8e\x13\x9b\x4e\x3a\x62\x4e\x27\xd2\xb1\x7d\x4a\x55\x93\x9d\xb5\xee\xde\x1b\x1a\xd8\x3b\x2b\x87\x06\x66\x0b\xc0\xd6\x28\x13\x47\x32\xd6\x7b\x23\x06\xca\x1c\x5c\xb3\x37\x0f\x56\xa7\x3b\x06\x7b\x21\x7c\x9b\x65\xc8\xd1\x03\x40\x08\x4e\xb1\xd6\x82\x0f\x40\x5c\xd3\x27\xbe\x0d\xb0\xc1\x1b\x0f\x15\x36\xc1\xc7\xcf\xd9\xfa\x79\x76\xaa\xb8\x15\x12\x7b\xf0\x54\x87\xfa\xac\x6f\xf4\xe3\x06\x6d\x26\x5d\x48\xa4\x6f\x69\x3b\x91\x9a\x94\xaf\x43\x00\x30\xcb\x3b\x4e\x46\x4c\x69\xb2\x92\xf1\x4c\xe9\x9e\xc7\x2a\xc4\x00\x49\x48\xd9\x52\xb4\x30\xe0\x61\x90\x0e\x90\x2f\xb4\x5b\xe5\x01\x00\x5d\x1f\x7b\x38\xcd\xec\x18\xd0\x2d\xc8\x9a\x11\x20\x80\xbc\xb7\xb0\x03\x02\xc6\xf4\x13\x91\x18\x1e\x37\x25\x85\x29\xeb\x8b\xca\xcf\x68\x4b\x5e\x6d\x9e\x97\x2b\x75\x9d\xae\x67\x3e\xf0\x90\x53\xa2\x7c\x91\xe9\x52\x1a\x3c\x83\xa0\x51\xb2\x17\x24\x30\x54\xbc\xfa\x70\xed\x50\xe9\xe4\x24\xdd\x4e\xdc\x2a\xa3\xf9\x9e\xf8\xb7\xd0\x1d\xc1\xe9\x75\x4e\x40\x90\xb9\xa8\xd9\x80\xba\x4c\xe2\x12\x38\x0f\xf8\xed\x7d\xf8\xdf\xff\xf9\x5f\x80\xc0\xa8\xd4\xda\xf2\xef\x41\x69\x8b\x7f\x3a\xac\x4d\xf8\xd4\xc3\x93\x24\xa3\xa2\x87\xc2\xfe\xaf\xfb\x44\xc4\x71\xc3\x0b\x91\x93\x78\x39\x46\x4f\xe1\x51\x8e\x18\xc4\xb6\x5e\xb8\x1b\xc8\xf2\x9c\xc5\xe9\x4c\x3d\xbe\x64\x68\xcb\x6c\x66\x46\xfd\x6d\x63\x79\x47\x3a\x85\xce\x81\xd4\xc5\x63\x8c\x5a\xc0\x69\x47\x8f\xc2\x03\x36\x73\xf8\x37\x99\xa8\x4e\xb5\x15\x6f\x55\x9b\x2a\xab\xba\x65\xa7\xb2\x28\x3a\x5a\xf7\x70\xd5\x82\x1d\x60\x53\x1b\xb9\x50\x42\x6f\x5a\x96\xe3\x19\x9d\x74\xd0\x67\xc1\xa9\x85\x81\x32\x98\x29\x97\xf4\xc4\xaa\xbc\x58\x82\x7b\x78\x86\x88\xa0\x34\xee\x49\x00\xdc\x6f\xa4\x0b\xdc\x2f\xc3\xbe\x13\xa5\xc1\x04\x89\x0e\xad\x82\xce\xef\x5a\xb6\x4b\x86\x94\x8e\x9e\xbe\x2b\x09\x7e\x5a\x80\x94\x3a\x9f\x6f\x9a\x38\x3c\xee\x9d\x6d\xc2\xb5\x27\xe7\x73\xb5\xc6\x44\xdc\x17\xe5\x15\x69\x06\x66\xaa\x56\x0b\x54\x3b\x61\x3a\x39\x88\xf3\x34\x96\xd7\x5d\x61\x52\x6c\xcc\xa2\xc2\xf8\x97\xf7\x9d\xc4\x9d\x17\x0a\xff\xfa\xb8\x28\x54\x5d\x6c\x56\xdf\xec\x62\xbd\x2b\x8a\x0a\x8c\x2b\x3c\xcb\x36\xd7\x9b\xdd\x8b\x57\x1c\x71\xa4\x03\xfc\x19\x9c\xce\xc0\x10\x9a\x56\x03\x19\xb6\x2c\xdd\x45\xa5\x67\x92\x21\xea\xad\xe4\xda\xd6\x65\xde\x29\x18\x03\x9e\xa4\xcf\x03\x94\x36\xe8\xe8\x52\xf1\x84\x74\x71\xa4\x78\x17\x1d\xce\x67\x1c\x5f\x69\x03\xaf\xa8\x21\x7a\xf5\x52\xae\x71\x40\x6f\x55\x7b\x86\xe9\x81\x25\xfc\x08\x1c\x69\xcb\x34\x66\xe8\xa6\xe3\xf2\x24\x92\xef\x1c\x4f\x33\x0c\xd3\xeb\x3e\x92\x19\xcf\xa2\xdc\xed\xea\x06\x54\xab\xad\x1d\x48\x4f\x18\x5f\x54\x9c\xd2\xfd\x52\x43\x7c\xf3\x1e\x25\xfb\xdb\x97\xfe\xf5\x51\x7a\xac\x92\x9c\xad\x8f\x48\xac\x8e\x7f\x75\x7c\xcf\xa3\x1c\x8b\xf9\x75\xa0\x34\x9e\xb3\x25\xa9\x7e\x28\x21\x6c\xae\xad\x81\xec\xb3\x8f\xba\x3f\x65\xf2\xc5\x3e\x0a\x7f\x75\x8b\xe9\x8f\x72\xbc\xf0\x53\xa3\xda\xe3\xa0\xdf\xca\x64\x0f\x16\x98\x72\x9b\xad\xf8\x9e\x04\xc5\xc1\xf3\x7e\x0e\xcc\xfa\xb1\x4a\xa4\xb2\xd7\x04\x0c\x88\x36\xd1\x72\x91\x11\xb9\x91\xc3\x30\x51\x0c\xcd\x63\xaa\x60\x69\x10\x00\xe8\x10\x28\x61\xa6\x01\x12\x9b\xec\xd9\x66\xc9\x55\x91\xc0\xc5\xed\xc6\x29\x19\x55\xf7\xf0\xed\xe5\xd5\x0a\xb5\x50\x8d\x8b\x59\xa2\xdc\x63\x1b\x9f\x25\x2f\xc2\x22\x0f\x76\x6c\xf0\xc1\xc0\x8c\x13\xac\x45\x8a\xb2\xb7\xf4\x3e\x92\x77\x03\x4a\x47\x2a\x80\xf5\x40\x36\x0c\xa0\xc3\x67\xe0\x1d\xd2\x47\x2d\xc2\x06\xce\x72\x4e\xc9\xeb\xe6\xf6\xbb\x1b\x69\xf1\xad\x15\x6a\xb7\x25\x00\x22\xb9\xa8\xae\xb0\x3e\xb5\xcb\xc3\x2b\xb8\x9b\xe0\x0b\xe2\xee\x3d\x0e\x6a\xad\xe6\xca\x18\xbb\x6e\x3d\x76\x9f\xaf\x6d\x9d\x32\x8a\x53\xf3\x82\x75\x70\x54\xc0\xe7\x94\xac\xde\x21\xff\x89\x64\x38\x8e\xeb\xa6\xd4\x4d\xd9\xee\x26\xbc\x29\xc7\xc1\xce\x35\xf2\xaf\x0e\xbb\xb2\x96\x15\x4a\x31\x5f\xfb\xd2\x59\x7c\x8d\xcc\x4a\xd1\xff\xe9\xa5\x75\xdf\xcf\xb8\x08\xdf\x83\xb1\xd1\xe7\xa6\x5a\xeb\x48\xe2\x02\xe3\xc2\x24\x31\x31\xc3\xd9\x0f\x04\xdb\xb1\x2e\x7b\x0c\x57\x9f\xb8\x52\x33\x1f\xf3\xd1\xf1\xf3\x89\x52\x6a\xfa\x8d\x4d\x48\x3e\x71\x6d\xe1\x19\x09\x13\x70\xf9\xf1\x83\xbb\x28\x25\x0e\x70\x0d\xb6\x5a\x84\x3c\x92\x89\x4b\x39\x0d\xb5\xc7\xbb\x15\xa5\x89\x98\x06\x5a\x41\x20\xe4\xf4\x84\xbf\xf5\x09\x12\x3d\x15\xb9\x08\xd1\x5d\x9f\xae\xc6\x2a\xbb\x3e\x1d\x86\xf3\x90\x15\x72\x4d\xb1\x0c\x0b\xfb\x56\xa8\xd3\x5f\xb4\x46\x1d\x96\x76\xfc\x2a\xf5\x57\x1d\x5e\xa7\x1c\x58\xb3\x47\x23\x7e\xde\x49\xd3\x9a\xb0\x04\x29\xb4\xe8\x5e\xf7\xe6\xb4\x81\x64\x73\x2f\x54\x9b\xf6\x7e\x96\x7d\x43\xff\x7c\x84\xfe\x45\x47\x7f\xe9\x2b\xdf\x19\x8e\xe8\x51\xa8\xc5\xf5\x33\xcb\x1b\x93\xf4\xb8\xb8\xcf\x55\xd1\xad\x1f\xd9\x91\xae\x3d\xed\xeb\x4c\xbd\x07\x7a\xea\x7e\xb2\x1e\xf7\x87\xcc\xa6\xaf\x34\x49\x31\x0b\xdd\x90\x30\x91\x31\x5e\xdf\xba\xc9\xd4\xa5\xeb\x48\x16\xb5\xe5\x09\x3b\x40\x69\x12\x6b\x3e\x03\x82\x7e\xa2\xf5\x4c\xda\x61\xfa\xcf\xa4\xc6\x42\x47\x1c\x6e\x97\x79\x8d\xd6\x6e\x1a\x7f\x0d\xeb\x7e\x16\x85\xa7\x3f\xae\x2a\xa2\xfe\x3c\xd7\x39\xba\xc9\x73\x43\x92\xcb\x0f\x3c\xdb\x31\xa6\x26\xd2\x84\xfb\xf7\xdb\x47\x64\x87\x33\xdc\xab\xb3\x8d\xf7\x7b\xea\xb2\x6f\xd7\x0b\x7d\x92\x46\x49\x9e\xf1\xb5\x75\x9a\xce\x38\x8f\xec\xa8\x97\xb1\xf7\x75\xcb\x0c\x25\xc7\xfb\xc4\xa3\xa1\xfc\x72\x6c\x1c\x9d\x73\x4a\xb9\x84\x21\x0c\xf3\xb6\x0f\x67\x78\x8c\x63\x9a\x99\xfa\x56\x36\x7a\x65\x1f\x05\x4e\x28\x9d\x05\xa0\xd1\xab\x08\x84\x28\xd2\xf7\x87\x65\x73\xc7\xde\x29\x9c\x3b\xd9\x69\xfa\x8e\x3b\x24\x54\xa5\x91\xbc\xc6\x64\xf1\x8d\x53\xa0\x87\x32\x49\x6e\x07\xbf\xc9\x7d\x0d\xf2\x9c\xb1\xa3\x1b\x8b\x4f\x8c\xe8\x24\x88\x1d\xdf\xd2\x6b\xdd\xb4\xb2\xba\x41\x5b\x1c\xb3\x10\x77\xe2\xfc\xdc\xde\x9c\xae\xc6\x12\x3f\xa4\xc8\x2f\xc1\xfb\x9f\xbc\xc1\xe2\xde\xe2\xbe\x52\x16\x3c\x8e\x78\x8f\xaa\xfa\x54\x1a\xfd\x6a\xbf\x2c\xe2\xfd\x7a\xd3\xaa\xc7\x66\x57\xcf\x83\xab\x1c\xcf\x48\xf6\x07\xaf\xeb\xf1\xb9\xda\x2a\x6d\xd9\x90\x72\x05\x99\xc5\xd1\xa6\x0d\xf9\x99\x63\x10\x2d\xf1\x3d\xba\xe4\x34\x96\x3a\xc5\xac\x1e\xe6\xc6\x03\x5b\x86\x4b\xd6\xd8\xea\x0b\x65\x65\x0b\xef\xc1\x4c\xae\x35\x5e\x5f\x46\xc0\xcb\xff\xf1\xdb\xdf\xfc\xe6\x37\x2b\x33\x15\xbf\xfd\xdc\xfe\x5f\xac\xe4\x87\x4e\x84\x9f\x83\x8a\x53\x73\x59\xcd\x37\x95\x6c\x15\x8b\x5a\x70\x62\x51\x9c\x0c\xf2\xa5\x15\x9c\x6c\xd3\xe1\xe3\x6c\x33\xbf\x54\xed\xdb\xf2\xdf\x15\x7c\xfc\xdc\x7d\x73\xec\x68\x9a\x9c\xf7\x1b\x28\x7f\xcc\xc6\x30\x89\x3a\x98\x44\x2d\xe6\xb9\xa5\x7c\xba\xdf\x6e\x46\xfb\x0e\xe2\x56\xca\x2b\x75\xd3\x5c\xde\xcf\x80\xe0\x91\x7f\x99\x0b\x4d\x67\x3b\xe8\x3c\xbf\xb7\xd2\x08\xa3\xbc\x5f\x65\xa7\xdf\x4e\x3f\x1d\x99\xc7\x7b\x76\xc4\x7e\x7b\x7d\x42\xb0\x4f\xf6\x93\xcb\x53\xd0\xd1\x89\x1a\xe6\x7f\x05\xb9\x3e\x9d\xc0\xc7\xdb\x9b\xed\x1c\xad\x0f\xc2\x69\x67\x22\x6f\x77\xf5\x7c\x48\xf0\x75\x83\xea\x91\x58\xdd\x48\x30\xf8\x25\x92\x41\x31\x6f\x67\xe4\x58\xe5\xad\xee\x84\x00\x4f\x19\x14\xc8\x36\x5c\x0c\x0c\xb3\xcf\xb1\x75\x5f\x70\x95\xe5\xb8\xf6\x6f\x33\xe6\x79\x43\xdd\x08\xa4\x45\x70\x56\xbb\xd0\x50\xc7\x1f\xe8\x89\xbb\x63\x42\x82\xe6\x21\x8b\xa5\x47\x3e\x39\x9d\x1c\xba\x0f\x1e\x88\xfb\x24\x48\x38\x11\x9c\xce\x11\x26\x85\x01\xba\x44\x4b\x9f\xfa\x02\x04\x33\x3d\x4b\x0b\x7b\xfd\x0d\xf6\xcd\xd5\x51\x9e\xd9\xfe\x06\xfb\x48\x67\x37\x2c\xcc\xd3\x8c\xae\xef\x71\x12\x31\xc6\xd2\x7f\xe3\xb2\xf4\xb9\xe1\x3b\x4c\x0f\x56\xe1\xc5\x6a\x5d\xe5\x2b\x4d\xd0\x48\x94\x21\x39\x63\xeb\x97\x26\x46\x18\xf5\xa3\x98\xeb\xa6\x70\x29\xe4\x71\x9f\x3c\x4c\x37\xbf\xed\xf7\x93\x06\x40\xa8\x74\xcc\xf7\x1e\x67\x83\x84\xe9\x5e\xa4\xbc\xb6\x2b\xb7\x75\x59\xf1\x89\x6b\xa3\x63\x73\xec\xea\xe6\x1d\x92\x39\x3f\x15\x80\x47\x86\x19\xaa\xd3\x53\xf1\xbd\xac\x2e\x99\x53\x0c\x1a\x57\xb8\x57\xa4\x04\x70\x24\xe0\xaa\x95\x9c\x2f\xa1\x8f\x23\xa6\xdd\x1f\xb8\x26\xc0\x45\xe4\x70\x3d\x43\xd0\x5f\xa6\x44\x7f\xbc\x9f\xc8\x96\xef\xf3\x84\x4f\xd9\x9b\x3d\x32\x6b\xb7\xd8\x88\xa1\xf7\x96\x1d\x9a\x84\xd8\x53\xb7\x6f\x42\x79\xb4\xe9\x98\x3d\x1a\xe7\x10\x93\x77\xd2\x60\xe0\x32\xc3\x6e\x30\x2c\x72\xe6\xc1\x03\xaa\xc2\x63\x2e\x1e\x3c\x48\x89\xcc\xef\xfb\x09\x7e\xc6\xae\xcd\xe3\xac\xa0\x75\x1f\x4c\xd1\x06\xe7\x50\x36\xb5\xfd\xc1\x98\x39\xe2\x18\xd9\xfd\xc5\xf1\x70\x52\xdc\x93\xa4\xa9\xd4\x01\x74\x11\x63\xfd\x88\x04\x21\x4a\xe4\xd2\x61\xc7\x1f\xb3\x89\xb4\x93\xfa\xc3\x09\xb0\xf3\x5d\x37\xea\x6f\x1b\x65\x10\x1f\x3a\x1b\x0f\x35\x18\x6e\xf8\x43\x67\xb5\x6f\x42\x01\xf1\x8f\xa7\x6f\x48\xd8\xbe\xad\xbf\x73\xb1\x6b\xc4\x1f\xf6\xaf\x63\x17\x75\xab\xff\x72\x1c\x24\x3e\xe4\xf5\xe3\x11\xbb\xda\xf7\xc4\xd8\xf7\x78\x02\x9e\x52\xd9\x60\xb4\x3c\xeb\x1e\xc4\x92\xb7\x9b\x99\x3d\x65\xad\x07\xeb\x07\x36\xcb\x68\x51\xb6\x62\x51\x42\x0e\x1d\x30\xc0\x7f\xf1\xf9\xac\x6c\x8d\x27\xf5\x2b\xe3\xb2\xdf\x8b\x87\x21\x23\x3e\x4e\xef\x80\x3c\xf8\x2b\x73\x12\x09\x03\xd9\xaa\xdd\x69\x81\x69\xa9\x51\xfe\x69\x5a\xd4\x9c\xa9\x77\x61\x5a\xcf\x32\x29\xea\x7b\xf8\xec\x5c\x36\xfb\x61\xbe\x84\x5b\xfe\x9c\xda\xd8\x7f\xfc\x24\x16\x65\x0d\xca\xa2\x1f\x3a\x0c\x7f\xe8\xa0\x77\x9c\xbd\xa7\x24\x30\x71\x77\x33\xe5\xc0\xdb\xfd\x88\xd3\xf3\x6a\xfe\x67\x21\x65\xde\x4c\xa1\x4e\x0e\xa9\xe5\xb6\x29\xdb\x16\x73\x5f\x94\x0b\xcc\xfc\x64\xd0\x2b\xb5\x2a\x17\x21\x6f\xd8\x3d\xc2\x4e\x44\xc7\x50\x33\x15\x2f\x92\x9c\x42\x92\xd2\x39\x3f\xdc\xac\xa7\xd4\xf3\x9f\xca\xfa\x52\x15\x0f\x1d\x1c\x29\x20\x65\xf0\xc4\xe8\x8e\x27\x2b\x12\xe2\x69\x0b\x54\xb2\xef\x7b\x48\x90\x4e\xf1\x15\xbe\x58\x37\x4f\xfa\x1b\x6f\x70\x4b\x3e\x59\x92\xfb\x1c\x81\x83\x32\x9d\xb3\xaf\x03\x14\x19\x62\xe1\x28\x9a\xfd\x69\x89\x25\x55\xda\xd1\x52\x9a\xef\x1c\x2c\x48\x27\xa0\x04\x43\x1e\x92\xaf\x51\x7a\x78\x17\x2c\xdf\x99\xfc\x37\xb2\x9d\xdb\xdd\x74\x22\x5f\x26\x45\xfc\xac\xaf\x88\xcf\x14\x4f\x29\xfa\x58\xda\x3c\x78\x3b\x17\x96\x5c\x29\x08\xd7\xb0\xfb\x56\x2b\x63\xcf\x01\x29\x41\xa8\x83\x57\xcf\xde\xbe\x7b\xf6\xf4\xfd\x77\xaf\x9f\x3e\x7e\xf7\xec\xfd\x9f\x5e\xbc\x7c\xf1\x8e\x29\x27\x70\x11\x6d\x35\xec\xfc\x09\xf8\x2d\x9f\x93\x92\xdb\x7e\xb5\x94\xf0\x8f\x6a\xd3\x94\xa6\x2d\xe7\xcf\x75\x13\x3d\x91\xbf\x75\x63\x64\x0f\x1c\x8b\x5f\x26\x7f\x14\x47\xb4\xd1\x6d\x1a\xa0\xe7\x25\xf2\x14\x8d\x9a\xab\xf2\x0a\xb2\xbf\xb0\x54\x06\x10\x5b\x70\x64\x00\x58\x5d\x47\x7e\xce\x60\xb7\x92\x00\x79\xe7\x03\x83\x65\x2b\x8c\x5e\x29\xb1\xd6\x65\xdd\x7a\xb4\x98\x4d\xbb\x69\xa0\x31\xf6\x0a\xec\x79\x83\x23\xb8\x8c\x74\x49\xbe\xca\x2d\xe4\x09\x0f\x9b\x4c\xb4\xbd\x2f\xe5\x87\x72\xb5\x59\x39\xb6\xbd\x50\xeb\x76\x29\xfe\x7f\xf2\xfe\x75\xbd\x8d\x1b\xd9\x17\x87\x3f\xbf\xba\x0a\x38\x93\x84\x52\xc2\x83\xe5\x24\x33\x13\x29\x4a\xb6\x22\xc9\x89\xd6\xb2\x25\xbf\x92\xec\xcc\x6c\x27\xdb\x02\xbb\x41\x12\x51\xb3\xc1\xd5\x68\x8a\x62\x26\xbe\xf7\xff\x83\xaa\xc2\xa9\x1b\x4d\xc9\x8e\xb3\x66\xaf\x67\xfb\x83\xc5\xc6\xf9\x58\x28\x14\xaa\x7e\x25\xee\x32\x40\x5c\xf5\x06\x75\xd6\x8a\x0e\xf5\xb1\x02\x7d\x84\x4a\x2c\x04\xaf\x45\x0e\xd2\xe0\xa2\x80\x1b\xf5\x25\x18\x1b\xd3\x59\x14\x7b\x02\x22\x95\x82\x2a\xf2\xdd\x43\x5e\x7b\x08\x3f\xb4\x90\x73\x89\x98\xc1\xac\x5c\xce\xc7\x08\x2b\x1c\xaf\x99\x70\x85\x45\xcb\x4b\x07\x32\x66\x7b\x68\x82\xca\x93\xe5\x0e\x2d\xc6\x0f\x4d\xb5\x87\x0e\xb0\xa6\xc7\x5e\xd3\x3e\x50\xf9\x5d\x18\x0e\xd3\xc2\x27\x47\x59\xad\x21\x31\x60\x8a\x36\xe8\x4b\xea\x0a\x75\x15\x16\x5f\x06\xfa\xfc\xb6\xd8\x7c\x08\x0d\xf6\xca\xad\x50\xba\x73\xb8\xf0\x40\xcb\x5e\xd3\xac\x04\xc5\x4b\xfa\xc7\x4b\x10\xce\x14\xb1\x0c\x2d\x8d\xa9\x55\x89\x3e\x47\xc9\x5a\x3c\x62\xab\xdc\x7b\x8b\x48\xe4\xb9\x3f\x45\xb2\xd4\x76\x47\xef\x13\x1f\x5d\xa5\x96\x82\x9b\x27\x44\x73\x33\x2b\xd5\x8a\xdf\x40\xa7\x07\xa4\x72\xb2\xcc\x2a\xc1\xb5\x17\x6a\x45\x4e\x3d\x5a\x73\xb8\x69\x8a\xc3\x19\xed\x2c\x21\xba\x6c\x36\xaf\x53\x5d\x15\x27\x05\x90\xe4\xe9\x0b\x3b\x34\x8c\xa7\xfb\x5d\x17\x61\x4b\xdb\x36\x38\x3f\xa3\x4d\x61\x55\xa9\x2a\x21\xca\xba\xe2\x65\xb6\x36\xb4\x80\x2a\x43\x99\xa1\x85\xae\x70\xc3\x1f\xe0\x24\x5b\xe4\x0c\x27\x65\xf4\x7a\xf7\x5e\x41\x06\x0e\xaf\x0d\xbe\x3b\xb0\x7d\x8d\x53\x30\x01\xf6\x03\xad\x89\xea\xc6\xd7\xc8\xb0\x78\xab\x5d\x3f\xee\x2a\x0d\xca\x1b\x0e\x87\xcb\xb2\x10\xe8\x71\xac\x72\xf4\x72\x89\xd9\x1c\xbf\xdc\x37\x67\x05\x42\x69\xc0\x73\x8e\xd3\xe0\x0e\xcb\x02\xcc\x42\x04\x67\x08\x94\x91\xe8\x76\x6a\x16\xc6\x79\x19\x80\x5c\x18\xce\xb1\x43\x8d\xa7\x49\x3c\x91\xd9\xfb\x41\xd4\xac\x92\xd0\x59\x93\x17\xe5\x3c\x3a\x70\x36\x27\xe7\xa4\x3f\x14\x8b\xe1\xdd\xea\x84\x1a\x5d\xf7\x83\x76\x6d\xe3\x8d\x28\xf0\xc6\x15\x48\xd1\x1f\x25\x78\xb2\xe0\x2c\x4b\x32\x6c\xa1\x15\x0a\x5c\x75\x2e\xf0\x3c\xb5\x69\x23\x8f\x4e\xfe\xa2\x76\x4c\x97\x14\x9b\x6c\x9b\xda\x08\x17\x8a\xc8\x45\x52\x93\xcf\x9f\xc8\x32\xff\x51\x4e\x67\x42\xd7\x2f\x68\xdf\xc0\x50\x87\x1c\xff\x2c\x8e\x27\xae\x24\xbc\x8b\x27\x52\x35\x99\xd4\x2e\xaa\x9e\x76\x58\x64\x19\xfa\x7b\x49\x7b\xa8\x56\x5c\xdd\x47\x2a\x49\x44\x58\xa5\xeb\xfd\x10\x74\xee\xa1\x94\x2e\x6d\xaf\x03\x0d\xf3\xa6\x9e\xe6\xea\x81\x02\x7b\x82\x10\x96\x81\x7c\xc8\xb1\x7b\x4d\xfb\x1d\x5c\xf3\x57\x01\xb4\x9f\x66\x95\xc8\x97\x39\xb7\x3e\x0c\x01\xc2\x18\xf4\x1c\xcb\x89\x7d\x01\x07\x2a\x60\x88\xd7\x2c\x2e\x0d\x6f\x47\xe0\x50\x1a\xf6\xae\xa8\x13\x47\x1a\xf9\x2b\xee\x33\x81\xef\x8e\x60\x7e\xb8\x12\xf8\x2e\x1a\x97\xe7\xda\x0f\xec\x74\x05\xca\xf3\xa0\x83\x19\x0a\xbb\x1e\x6d\xa7\xe7\x3f\xd4\x6f\xda\xb4\x92\xee\x33\xfb\xe7\xde\x1b\xa4\xf5\xd0\x8e\xb3\xfb\xe7\xf9\x9d\x0b\x40\x5b\xcc\x2a\x48\x33\x20\x09\x01\xa1\x95\xe2\x99\x21\x03\xf5\x70\x3c\xd1\x91\xff\x8e\x21\xee\xd9\x26\xc6\xa6\x2d\x66\x7b\x30\xeb\xd4\xce\xda\x78\xa7\x8f\x31\xc9\x6d\x17\xdb\xe5\xdf\xd3\x3d\xf4\xe6\xb9\xb9\x7f\x01\x88\x6a\xba\xab\x0f\xe8\x63\xe8\x9b\x04\xff\x3d\x8c\x05\x6b\xe7\x7b\xf0\x68\xa7\xc6\xa7\x55\xe9\x3d\xc3\xe3\x56\x69\xf7\xe8\xa4\x66\x2f\xb9\x93\xde\xa7\xfb\xdd\x64\xf5\x9d\x97\x5e\xd7\xfa\x89\xfb\x9f\x6c\x79\x27\xcb\x7d\xdf\x52\x78\xf8\x5c\x6d\xc5\x99\xba\xc6\x70\x53\x85\x89\xfe\x00\x38\x45\xea\x20\x8d\xb8\xdf\xae\x93\xe3\x9b\xd4\x21\x9c\x58\x30\x09\x36\xb8\x8f\x82\xac\x9e\xc6\x22\xaa\x28\x4b\xfa\x68\xbf\xf7\x90\x4b\x64\x4d\xde\x6d\xe2\xd1\x7c\xb7\xe5\xdf\x5e\x24\x5b\xf7\xac\x8d\x44\xf5\xd5\xc3\x16\x48\x52\x3d\xd2\x21\xef\x22\xc5\xb1\x57\x29\xa7\x24\xc0\x35\x8b\x1c\x0b\x23\x77\x5a\xbb\x27\x6e\xbc\xf4\xdb\xa2\x48\xf0\xc2\xae\xba\xa5\x4b\x7d\xbc\x79\xcd\xd1\x50\x42\xc4\x52\x03\x96\xa9\x65\x59\x0f\x5b\x62\xd8\x86\xd8\x2e\x16\xe4\x79\xe5\x92\x54\xf2\xf0\x38\x4d\x16\x77\x70\x90\x9a\x65\x3f\x51\x2d\x01\xce\xe7\x9f\xef\x77\xdc\x46\x11\x46\xcc\x49\xa6\x0c\x2b\x81\x2a\x6e\x20\x06\x1d\x76\x15\x88\x42\x32\x3f\x35\x6d\x41\x65\xa2\x81\xfb\xcd\xa4\x2d\x56\x2e\xb1\xec\xdb\x92\xff\x26\x0f\xbd\x9d\x3b\x66\x31\xbc\x02\xe0\xe6\xed\xb3\xbc\x48\x3c\x8a\x84\x09\xe7\xb2\x3c\x69\xbc\xd1\xfb\x12\x03\xd1\x66\x1e\x80\x51\xfc\xa7\x10\x0b\x07\xb4\xa6\x4a\x82\x57\x76\xf0\xa1\x2d\xbf\x1e\x80\x41\xe2\xd1\x45\x57\xe4\x61\xc3\x16\x17\x22\x8e\xe2\x98\x77\xf2\xff\x01\xd3\x2e\x4a\x3e\x2e\xc4\x4b\x0d\xae\x2d\x65\x39\x3d\x7c\x71\x6a\x96\x8c\x6b\x72\xb7\xe3\x79\x2b\x03\xee\x9e\x8b\x6f\xee\x51\xf9\x42\xf5\xb9\xe4\x2d\xc8\x55\x10\xcb\xcc\x02\xc0\xd4\xae\xc5\xde\xdd\x9c\x86\x8b\xc7\xd6\x94\x25\x90\x7c\x3b\xfa\x75\xc0\x5a\x99\x77\x40\x77\xa6\x25\x23\x4f\xde\x2c\xe9\xc6\xdb\xe8\x45\xbf\xbb\x46\x37\x5e\xe6\xae\x4f\x98\xa0\x48\xb8\x68\xb1\x7b\x41\x4f\x88\xf2\xbb\x61\xfe\x63\x52\x18\xe0\x0b\xc1\x75\xdd\x6b\x13\x9d\x48\x80\x2b\x31\x6b\x8d\x97\x21\x84\xad\xb3\x11\xb6\xde\xc6\x9d\x7b\x70\x44\x8a\x69\x7b\xa5\x29\xc4\x04\xad\xd5\x99\x5e\x4e\x26\x32\x93\xa0\xa7\xe1\xe4\x39\x01\x59\x8e\x84\x0e\xdc\xd7\xc0\x10\xad\x50\x82\x90\x15\x78\x7f\xe7\xa9\x8a\x40\xb5\x48\x39\xd1\x0b\x29\x01\x93\xab\x7b\x2d\xdf\xf3\xb2\x62\x29\x53\xec\x6b\xc7\xf7\x46\xdd\x8a\x2a\x34\xbc\x02\x85\x2b\xdb\xdc\x61\x20\x0b\xef\x5e\xae\xff\x57\x0a\x12\x9c\xe8\xb9\x10\xbc\x1c\x58\x4c\xa9\xd6\x0b\x4d\x18\x98\x7c\x15\xea\x24\xfa\x6e\x68\x5a\x6f\x46\x29\xdf\xc6\x5f\xb2\x83\xc6\xdb\x91\xed\x5a\xe7\x8b\x12\x30\x31\x9b\xde\xa3\xcc\x3f\xb4\xd7\xa2\x3a\xba\x84\x28\x5d\x92\xaa\x6e\x38\x56\xff\x12\x97\xba\xab\xb6\xca\xfb\xef\xc3\x65\xc5\x51\x8f\x5e\x0a\x63\x68\xd6\xf8\xa9\xc1\x30\x3a\xa0\x79\x07\x0b\x5e\x55\xf0\x6e\x3c\x6a\xc3\x89\x3b\xb9\xc4\x0b\xae\x75\x24\x78\x03\x4b\xe8\x6a\xba\x44\xae\x47\x05\x6f\x4e\xd6\xf5\xbd\xf9\xdd\x25\x9d\xfb\xa6\x5b\x65\x38\x21\xfd\x74\x2d\x0d\x05\xdb\xa1\x27\x71\xcb\x2a\x86\x61\xa1\x08\x3b\x4a\xdb\xe1\x71\x2b\x29\x77\xb7\x54\xc7\xb9\x11\xb4\xd6\xa6\x75\x43\x4a\xdd\x68\x4d\x7c\x39\xb9\x47\x8e\x9d\xa5\xfd\xb5\x77\x1b\x87\xde\x5f\x63\x73\x70\xee\x01\x1c\x8e\xc5\x60\xf7\x8e\x96\x3d\x58\x6e\x45\x40\x96\x1d\x1c\x24\x3b\x6a\x8f\xd1\x1f\x1e\x83\x77\xc2\x6c\x6f\xad\x95\x37\xef\xb2\x58\xde\xfc\x8f\x59\x2d\x6f\x3e\xd4\x72\x69\x8d\xcf\x3b\xad\x97\xfb\x07\xec\xbe\x05\xe3\x8c\x2d\xdd\x39\x64\xf8\x15\x44\xbb\x94\x73\xd1\x14\x6d\x4e\x10\xee\xc2\xea\xb4\x37\x21\x71\xba\x81\xf5\xa9\x84\x4b\xb0\x80\x07\x2a\x66\xce\x7a\xb7\x62\xdb\xde\xec\x3e\xc4\x7c\x24\xe7\xc4\x2d\x23\xc7\x4d\x05\xcd\x79\xce\x41\x5f\xdd\x81\xaf\xe9\x68\x65\xb5\xfc\xfa\xda\x71\xb1\x30\xcf\x6e\xd5\x31\x43\x5c\x9b\x08\x3b\x89\xc5\xf0\x26\xb5\x15\x58\x0c\xa6\x95\xba\x69\x77\x68\xa6\x58\x95\x9d\x9f\x66\xa2\x0c\x2f\x41\x7e\x6f\xf6\x49\x6f\x21\x53\x65\x26\x0b\x51\x31\xae\x6f\x74\xac\xcb\x80\x5a\x3c\xee\xcd\x69\x34\x62\x80\xa7\xcd\xc4\x9d\xc8\x96\xa8\x10\xf9\x54\x55\xec\xf8\xfc\x39\xc0\x0b\x49\x33\x3e\x74\x03\x97\x1a\x79\x51\xd2\x69\x38\xcd\x0b\x71\x14\x30\x6e\x5e\x57\x2a\x5c\x26\x81\x7e\x83\x67\x86\x5a\x4b\xd9\x59\xff\x36\xb8\xc8\x30\xdb\xd0\xcc\xa4\x7b\x48\xdc\xde\x61\xdf\x6e\x50\x13\xb9\xbf\xe8\x14\x17\xe6\xb9\x44\xeb\xbc\x90\x02\x62\x6d\xa9\x33\x55\x83\x06\xc5\xda\x42\xb2\x03\xf8\xac\x52\x37\xc3\x86\xd3\x82\x40\x61\xc4\x79\x10\x83\x72\x39\x16\x57\x2f\x17\x05\x58\xe5\x6d\x37\x41\x39\xfb\x0e\x9b\xd5\x42\x60\x86\x23\xdc\x44\xfe\x8c\x40\x32\x1f\x75\x32\xcf\x1b\x5f\x02\xc6\x22\x5a\x53\x7f\xe6\x03\xc0\x68\xc4\x5e\x96\xb1\x47\x5d\xd8\x90\x5a\x79\x57\x69\xc8\x40\x95\x0e\x7a\x3e\xbe\xe4\xdb\x62\x78\x89\xd8\x90\x5e\x8d\xa7\x25\x13\xd9\x40\x62\xc2\x27\x3b\x20\x70\x1b\x58\xeb\x14\x67\x1c\x5e\x2a\x5a\x6c\x75\x03\xae\x20\x5e\x41\xf6\x65\xda\x2e\x8b\x71\xb0\xd3\xfc\x6b\xb8\xdb\xb4\x85\xb8\x15\x45\x1f\x34\x4c\xf0\x8a\xb7\xe5\xc4\x17\x7e\xb3\x47\x7b\x30\x7e\x75\xde\x9e\x94\x7d\xc6\x53\x5a\x8b\xa7\x09\x55\xb1\xd6\xc3\x39\x8d\x50\x22\xa9\x1f\x81\xb4\xd6\x22\xef\x54\x5b\x4c\x95\xd6\xd9\xa8\x90\x8d\x78\xd4\xce\x89\x77\xc2\x84\x36\xc2\x3d\x8f\xd3\x2d\x7f\x28\xff\x7d\xf3\xd3\xd4\x0b\x08\x94\x4a\x93\xba\x0b\xd4\xc7\x0d\x5a\x08\x69\x9d\xbe\x70\x89\xc6\x88\x39\x2d\xd5\xd2\xd4\x2c\x75\x15\x1b\xdd\x09\x13\x56\x42\xb6\xd4\x0f\x35\xaa\x68\x39\x79\xef\xa8\x82\x24\xc6\x4c\x73\x87\x8e\xee\x9f\xb9\xda\x1b\x1a\xc2\x1f\x74\xdd\xdf\x7f\x45\x76\x3d\x0f\xaf\xc6\xe8\x10\xc0\xca\x84\x9a\x2e\x5f\x86\xec\xb4\x36\xdc\x34\x61\xa7\x51\x1e\x50\x09\x44\xd5\xbd\x80\x03\x77\x9a\x37\xa9\xd7\xdc\xcd\x0a\x20\x76\x15\xd0\x30\xe1\x38\xa4\x15\xbc\xf7\x3a\xc2\xfb\x61\x9e\xb6\x6d\xe9\x5e\x77\x14\xe6\x0c\xf5\xf7\xf7\xa2\x2f\x8c\x8f\xb7\xe2\x5e\xe3\x1b\xd3\x34\x37\xec\x5e\x5b\xb5\x07\x05\xc8\x76\x22\xf6\xfc\xcf\x3e\x31\x1c\x91\xe6\xfc\x5e\x33\x60\x0b\xe0\x11\xde\xee\x6f\x6d\xfd\x6b\xcb\x89\x8c\x7f\xb2\x16\x13\x67\x81\x54\x28\xd8\x81\x6f\xb7\xb6\x46\x23\xf6\xd8\xcc\xd5\x8b\x8b\xf3\xe3\x3e\xdb\x35\x3f\x8f\x4f\x5e\x0d\x4d\xf8\x73\xd4\x27\xc8\x73\x13\xf9\xf4\xf4\xd9\x89\xe5\x5c\xb7\xb6\xdc\x9e\x99\x3a\xbf\x24\x4f\x55\x75\x89\xe8\x85\xdb\x68\x12\xd6\xb0\xe4\x00\xea\x9b\x8c\xf1\xd6\x81\xf3\x45\xbd\x3e\x1f\xff\x2a\x32\xef\xfe\x11\x85\x0a\x88\x05\x32\x15\x75\xab\x6c\xab\x11\x6c\xc3\xad\x12\xfb\x44\x96\x39\x49\x30\x5e\x96\x73\xae\x6f\x84\x85\x14\x08\x8c\x45\xa8\x5e\xa9\x9b\x36\xfe\x64\xc0\xf1\x1d\x5b\x54\x2a\x13\x5a\x1f\xcd\x64\x11\xe7\xef\xc7\x35\x9a\x75\x1d\x05\xc0\xe0\x9a\x86\x79\xef\x9e\x17\x8e\xec\x7c\xbc\x6b\x5a\x68\xc7\x70\x3b\x53\xe5\x44\xd2\xc1\x63\xb2\x4c\x45\xfd\x62\x39\x2e\x64\x76\xea\xad\xfe\x30\xcd\xb0\x15\xe5\x94\x9e\xdf\xf8\x8a\x2e\x9d\xf2\xf2\x01\x4b\x84\xda\xfa\x2c\x26\x54\x7a\xdb\x98\x1b\x48\x22\xf3\x70\xd3\x26\xdb\xb0\xcd\xee\x29\xae\x6b\xf3\xc5\xdb\xaf\xab\x90\xf6\xa6\x6c\x6e\xcb\xae\x9c\xa9\x4d\xd8\xde\xae\x5d\xb9\xd3\x9b\x38\xd8\xc6\x5d\x19\x1b\x9b\xbb\xb5\xbd\xbb\xf2\x35\x92\xed\x27\x6d\x91\xae\xd4\xe2\x99\x39\xfc\xc8\x1c\xd5\xb9\xea\x11\x78\x56\xf6\x9d\xc0\xdc\x6e\xbf\xd0\x50\xb5\x03\xb8\x1e\x6d\xbc\x01\xa5\x1a\xa9\x79\xcf\x39\xba\x6d\x27\xb6\x12\xc9\x48\xec\xde\x49\x8e\x1a\x5e\x76\x3a\x69\x56\x8c\x29\xbd\xe2\x15\x5c\xe4\xec\x11\x86\x07\x1c\x1d\x4e\x3a\xe0\x11\x38\x5b\x2c\x2b\x11\xdc\x7e\x00\xa8\x73\xa1\xad\xef\xa5\x5a\xec\xb3\x1e\xfb\x9c\xf5\xc8\x39\x99\x39\x23\xe9\xad\xd8\x6b\xb6\x5b\x5d\x73\x38\x13\xc9\xec\xdd\x29\x6d\x17\x6a\x25\xf2\x21\x16\x72\x3a\xf1\xe0\x6e\x7d\xeb\xef\xac\xa9\xb1\x2e\xcb\x94\xca\xfb\xcf\xe5\xcf\x25\x94\xe1\x05\x2f\x55\xd8\x29\xd3\xf2\x4f\xf4\xb0\xd7\x6f\x03\x7c\x6e\x9e\x07\x40\xb7\xea\xbd\x2c\x6f\x4a\xb5\x2a\x7b\x69\x2b\x60\xbb\x24\x00\x4b\xc6\xfe\x3c\x38\x60\xcb\x32\x17\x13\x59\x8a\x9c\x7d\x87\x53\xb9\xe7\xe2\xf7\xa3\xb5\x63\xe7\x23\xca\x0d\x39\x7e\xff\x9d\x11\xfe\x79\x14\xe7\xd1\xce\x9d\xd3\xb4\xed\xe1\x70\xb8\xb3\xc7\x4e\xee\x16\x22\xb3\xb2\x28\x50\xd4\x51\x60\x6c\xc9\x0b\x76\x6d\x8b\xb8\x8e\xc4\xdc\x30\xcd\x30\x76\xb6\xd0\x21\x33\x04\x52\xf0\xdc\xda\x6b\xe4\x7b\x34\x78\x6e\xf1\x47\x6f\x2f\xf7\x62\x4a\xc4\xc2\x7a\xb0\x28\x1d\x00\x8b\x69\xb7\x55\x64\x3a\xbf\xaa\xf8\x62\x21\x02\xcb\x86\x21\x81\x2e\xdb\xb2\x6a\x40\x35\x0f\x4c\x18\xbc\xdd\x34\x3d\x02\x84\x30\xfc\x63\x59\xb3\x95\x90\x55\x0e\x1a\x87\x84\x2c\xec\x6e\xb1\x08\x6b\xca\xb4\x58\xf0\x8a\xd7\x82\x5d\xe3\x68\x02\x85\xbe\x66\x87\x2f\x4e\xfd\xc3\x18\x3e\x3e\x43\x0c\x1d\xd6\xf4\xfc\x6c\x3b\xf1\xc8\xef\x58\x0a\x1a\x02\xf6\x4f\x47\xf8\x70\x51\xa9\x5a\x3d\x2c\xc5\x70\x69\x8e\xac\x71\x21\xde\x48\x0d\x2d\x40\x8f\x1a\x6e\x8f\x01\x58\x4c\xb5\x0c\x5e\x70\xdf\x11\x71\xa0\x21\xce\xeb\xca\x9d\x80\x17\xb1\x1b\xa5\xb5\x24\x48\x5b\xe4\xa0\xa3\xd0\xbd\x26\x4e\x80\xe5\x69\x79\x55\x4b\x5e\x80\xed\xcb\x1e\xfb\x97\x1d\x90\x3d\x37\xcc\x6f\xdd\x79\x49\xab\x71\xaf\xf1\xac\x8b\x62\xbc\x45\xc1\x33\xb1\x87\xdc\x9a\x0f\x7f\xaa\xaa\xcc\xac\xe7\x28\xb8\x14\x77\xee\x39\x32\xc6\x68\x35\x31\x18\x82\xbd\xa3\x1b\x4a\xa9\x45\x45\x96\xb4\xa7\x65\xad\xa2\x81\xe8\x53\xc7\x69\x40\x22\x54\x06\x7f\x9c\xdc\xe7\x50\x11\x5e\xc3\x95\xae\x2d\xab\xd2\x46\x71\x99\x29\x5d\x5b\xee\x20\x60\xd8\x7e\xb4\xc1\x91\x5d\x2f\xbc\x5e\xfa\x0c\x5d\x52\x40\x2f\x43\x8f\xee\x94\x2e\x67\x6c\x9e\x9e\xb8\x5c\x80\xdf\x3b\x87\x85\xb4\x17\xf3\x69\x18\x78\x5a\x4e\x54\x9f\xcd\xd6\xb9\xd9\x6f\xad\x16\x60\x09\xc8\xf2\x29\x55\x77\x65\xa3\x46\xd2\x05\x81\x1e\x6c\x13\xb5\xfa\x63\xdb\x3b\x3f\x69\x70\xc1\xed\x23\x3d\x44\x1f\x9d\xb4\xd4\xa8\x62\x3f\x2a\xe0\xd7\xbf\xec\xd5\x6c\x9c\x76\x1f\xe6\xfd\xdc\xb8\x6c\xf6\x68\x71\x80\x6c\x31\x68\xc0\x3b\x3a\xc0\xb7\xd9\xda\x3e\x84\xd2\x10\x68\x0f\x77\x99\xff\x5c\x2d\xcb\x00\xd7\xca\xb5\x3f\xf5\x0c\x00\xf4\x91\xf6\xe7\x1f\xad\x97\x2c\xd3\x1f\x58\xf3\x7b\xd6\x11\x2f\x99\xae\x2a\x12\x8f\x05\xe1\xdc\xba\x0b\xd3\x83\x6e\x72\xa1\x28\x2d\x58\x0c\xb6\x90\x14\x2a\x76\x3b\x95\xad\xb4\xf3\x69\xcc\xe7\x21\xcf\xa3\x47\x9d\x59\xb7\x1a\xb7\x84\x87\xf3\xbe\x6e\xfb\x6d\x3d\xe8\x16\xff\xe0\x6b\xfc\x83\x6e\xeb\x94\x2c\x7d\xdd\x87\x28\x77\xd1\x33\x24\xc4\x52\xd0\x24\x31\x8a\x15\x38\x5c\xb0\xa5\xab\x89\x3d\xeb\xe7\xf0\x51\x9c\x7c\x08\xfe\x83\x77\xda\x72\xbe\xf0\x61\xd2\xae\x23\x8b\xaa\x97\x2a\x22\x89\xb2\xd7\x89\x89\x47\x95\xb4\xee\xb6\xe9\xa2\x1d\xfd\x0e\xd6\x79\x0b\xca\x30\x40\x29\xdb\x54\x44\x83\x17\xb6\x8b\xa1\x79\x72\xed\xb5\x42\xfa\xe9\x84\x3f\xc9\x7a\x76\xa6\x10\x61\x4f\x87\xb3\x15\x1d\x7d\x0f\x3b\xfc\xa2\xb2\x1a\x08\x17\xf7\x9d\x85\x1b\x27\x6e\xf3\x89\xe8\x8e\x24\x59\xfe\x2a\xb2\xda\xf0\x06\xc7\xe2\xd6\xd0\x9c\xa8\x43\x39\x85\x1d\x05\xb2\x0b\xe6\x95\x40\x72\x28\xf9\xfb\x75\x38\x38\xec\x80\xc5\xb9\x86\x1d\x09\xdd\xa9\x62\xe5\x33\xb6\x25\x80\x8f\xa5\xb7\xdf\x70\xad\xe5\xb4\xdc\xfe\xd7\xdb\x7e\xa3\xc4\x7e\x64\xcd\x1a\xcf\xcd\xf7\x6b\x92\xf7\x75\xce\x4a\x50\x65\x07\xef\x12\x28\x3e\xf4\xa3\x8a\x12\xbd\x08\x2b\x72\x10\x4c\xad\x33\xef\x51\x47\xee\xc4\x03\x39\xca\xe3\x48\xe0\x1a\x8a\xbe\xc9\xe2\xa8\xed\x59\xab\x63\x21\xb0\x24\x22\x4a\x57\x3f\xda\xf8\x51\xc1\x59\xb2\x13\x0a\x6a\x51\xfe\xd8\x29\xf4\x7a\xc2\x0e\x18\x4a\xf7\x86\x93\x4a\x88\xdf\xc4\xf6\xbf\xb6\xfe\x7f\x76\xe7\x76\xc8\xc9\xb6\xde\xee\x6c\x2a\xf2\x0b\x76\xc0\xb6\xbb\x6a\xb3\x02\x8a\xb6\xf0\x0d\x6e\xc4\xe9\x5c\xfb\x20\x12\x45\xce\x69\xbc\x04\x28\x59\xb0\xf0\x32\x37\x18\x7a\xc1\x46\xd4\xab\xec\x86\x4f\xc5\x70\x6b\x2b\x48\x9f\x8b\x0c\x5c\x9e\x94\xcd\x1b\xe2\xdd\x42\x55\x35\x9b\xa8\x6a\x0e\x82\x55\x7b\xb1\x9b\xf1\xec\x66\x0d\x57\xba\x39\xbf\x11\x9a\xc9\xda\x1a\xb8\xd6\x33\x36\x56\xf5\x8c\x5d\xa8\xa2\x58\x2e\x40\x54\xf1\x1f\x42\xd7\xc3\x2d\x34\xaa\xe3\x59\xed\xdb\x1c\x09\xf9\xc2\xb1\x79\xdd\xa3\xc1\xed\xfd\xc2\xbe\x7b\x40\x9a\x8e\x39\xf8\x22\x1c\x12\xcb\x49\x5a\x0f\x7e\xd6\xad\x92\xac\x0d\xf9\xd6\x66\x59\xaa\xca\xac\x49\x82\x09\x1c\x2f\x0d\xbd\x0d\x66\xf0\x15\x79\xb8\x3f\x60\xbd\xdd\xbf\x0e\x77\x87\xbb\x3d\x2c\x9e\x5b\xc5\x80\xc3\x52\xce\xf1\x76\x56\xf1\xb9\xe8\x03\x56\xb8\x05\x1c\x04\x6d\x0c\xeb\x19\x11\xb1\x9e\xc8\xe6\x76\x82\x89\xeb\x99\x28\x4d\x69\xa1\xf3\x02\xb6\x50\xba\x7e\x2e\xb4\xe6\x53\x41\xc6\xb3\xd0\xd4\xc0\x7c\x18\xdc\x16\x2c\xb8\x34\xf7\xf4\x9f\x10\x66\xb3\x9e\x89\x2d\x44\xdd\x77\x79\xf1\x89\xb6\x62\xb9\x32\x97\xf4\xf9\x32\xb3\x16\xc0\xda\x83\xf3\xd3\x3b\xb3\x69\xe7\xe7\xd8\x28\x86\x2e\x65\x46\x23\xf6\xfd\xda\xde\xd1\x6d\x7f\xa4\x59\x5e\x00\x0e\x21\xcb\x5a\x85\x77\x78\xb4\x69\xa8\x65\x76\x03\x5e\x29\x4b\x8d\x3e\x50\x78\x6d\x0a\x2a\xf8\x5a\x2d\xeb\x3e\xb6\x18\x3d\x16\xc2\x3b\xf6\xb8\x52\x2b\x2d\x2a\xf2\x67\xa8\xd1\xc8\xc1\xf4\x6f\xca\xcd\x1e\x46\xe0\xf4\x5b\x2e\x0b\xf0\x61\x83\xa8\x6b\xe4\x33\xc7\x37\xd5\x64\xcc\xd7\x25\x9f\xcb\x0c\x9e\x9e\x78\xfe\xeb\xd2\xdc\x19\x86\xf8\xb2\x60\x68\xd6\x89\xd5\xf6\x38\x29\x6f\x65\xa5\x4a\xb8\xec\x67\xbc\x7c\xa9\xc5\xf1\xf9\x73\xb3\xef\x48\xe0\x93\x9c\x52\x10\x0b\xb6\x7d\xdd\xb5\x05\x7a\x3c\xab\x59\x2e\x0c\x0b\xa8\x99\x07\xc3\x88\x0b\x1b\xb2\xe7\xfc\x46\x30\x37\x3c\x6c\xad\x96\xac\x50\x3c\xb7\x02\xa1\x85\x2a\xd6\x13\x09\x23\xcc\x54\x91\xfb\x51\xd2\x43\x36\xab\xeb\xc5\xde\x68\x34\x19\x0f\xe7\x62\x04\xbb\x6a\x60\x93\xeb\x1e\x5d\x68\x49\x8a\x3f\xe3\xfa\x8c\xd7\xf2\x56\xbc\xf0\x28\x5f\x67\x6a\xc5\x0e\x6c\x57\x43\xf4\x2f\x10\x6f\x29\xa0\x74\xbd\x60\x34\x82\x24\xc3\xd2\xe4\x8d\xc6\x81\xc8\x1c\x44\x38\xc9\x13\x69\xec\xa6\xaa\xc6\x71\xc3\xe4\xfe\xa0\x69\xbc\xa8\x34\xaa\xa4\x67\xd5\xfd\xad\x80\xe5\xbe\xa7\x84\x63\xb3\x7a\xa3\xac\x01\x35\x08\x14\xa5\x56\x7c\x8d\x48\x27\x65\x26\x8a\xbe\xa3\x0b\xc8\xa0\xe4\x4a\x68\x74\x3b\x3e\x27\x12\x76\x7a\x14\xf4\x12\xba\xf9\x68\xf3\xaa\xc2\x66\x61\xbe\xe0\x00\x37\x6b\xe0\xa8\x71\xf7\xd5\x02\x94\x56\xd5\xb2\xde\x6e\x77\x8b\xb1\x28\xcf\xb6\x3f\x65\x23\x05\xa1\xbd\xc4\x88\x44\x87\xe5\x29\xda\x1a\xad\x53\x67\x22\x1d\x89\x31\x42\xd6\xe3\x78\xe8\x03\xb7\x90\x09\x8d\xa8\xe4\x1e\x19\x8d\xd8\x0b\xbb\x9a\x93\x5a\x54\xf4\x12\xe4\x08\xdb\xc5\xe9\xd1\x91\x97\xeb\x36\x40\x7e\x4c\xd6\x0d\xe8\x46\xf1\x36\x4b\x24\xb4\x6f\x73\x26\xfa\xd8\x2b\xaa\x43\x37\xd1\x99\x17\x11\xe8\x65\xcd\xb8\xd6\xcb\x39\x12\x3d\x5e\x83\x6d\xc3\xb2\x64\xbc\x66\x5f\x3c\x9e\x2c\xb4\xf5\xe6\x8e\xa7\xe6\xcc\x2a\x64\x39\x0c\xbd\x2d\xf2\x59\x52\x14\x44\x8b\xf0\x10\xba\xe5\xc5\x12\xe0\x85\x38\x9b\x70\x6d\x08\xb8\x29\x4b\x4e\x4c\xf1\x53\x41\x5e\xb9\x27\x15\xf9\x59\xe3\xb6\x3b\x5b\x64\x38\xcd\xe7\xe8\x7b\x2c\xb2\xfe\x32\xa1\x24\x2c\xfc\xe2\x0b\x3b\x16\x3c\x33\x9b\xaf\x19\x97\xea\xbe\x7f\xba\xbc\x77\xdf\xb2\x54\xce\x40\xce\xf8\xa0\xc5\x88\xc3\x0c\x83\x4b\xd4\x0f\xbb\x6f\xcd\xb2\x43\x40\x42\x39\x07\xcf\x3c\x56\x4b\xe2\xf0\xa9\xbb\x09\x87\xc5\xc1\xc1\x98\xca\x09\xa3\x3d\x04\xdd\x35\xa0\xb5\xa1\xca\x7a\xb1\xe2\x6b\x0d\xa2\xdb\x61\xf3\xfa\x11\xaf\x8e\x41\x9a\x1e\xf9\xcd\x03\xb2\xc9\x48\x1c\xf0\x61\x46\xe9\xa9\xdd\x05\xb5\x0a\x08\xda\x7d\x8d\x8d\x49\x5f\xb3\x95\x5b\x6e\x9d\x5b\xb7\xfb\x21\xaf\x50\x57\x12\xab\x43\x67\x4a\x70\xd0\xc3\xb1\xdc\x74\x94\x54\x09\xe4\x3b\x68\x3d\xcd\x31\xff\x7f\x8a\xb5\xe1\x90\xde\xbc\x81\x53\x29\xdc\xe5\x1f\x9b\x53\xed\x39\xaf\x67\xc3\x8a\x97\xb9\x9a\x6f\xef\x0c\x6b\x75\x59\x1b\x16\x69\xfb\x8b\xbf\xee\x0c\x75\x21\x33\xb1\xfd\xc4\xbd\x8b\x9b\x9a\xaf\x24\x10\x80\x40\xa4\x78\x1b\x3c\xbe\x83\xdc\xcb\x04\x0c\xb5\x5a\x56\x19\x9e\xcf\x2b\x59\xe6\x6a\x05\x10\x32\x10\x95\xf3\x9a\x43\x84\x6f\x60\x53\xee\x19\x69\x5e\x76\x93\x17\xeb\xea\xc4\xd1\xa5\x14\xb9\x8a\xe5\xce\x49\x42\xc6\x9c\x17\x92\x80\x64\x36\xdd\xa1\x10\x91\x4f\xac\xa2\xf8\xde\x82\xe0\x50\xb0\x91\xb4\x23\x52\xb8\x8d\xf2\xfc\xc4\x8c\xc0\x33\xa9\x6b\x51\x9a\xa9\x24\x33\x2c\x11\x9c\x52\xf6\x6a\x26\x04\x69\xc5\x6a\x35\x17\x16\x10\xaf\x06\xda\xa4\x2a\xc3\x7e\xb0\xd3\x13\x33\xd3\x38\xba\xc3\x66\xd9\xdb\x3d\x1a\xdd\x5e\xdf\xcd\x9b\x87\x2e\xb6\xe4\xc8\x52\xb2\xd6\xac\x56\x7c\x12\x81\x82\xdd\x4f\xc3\x59\x00\x02\x10\x12\x38\x2a\x89\x0d\x1a\x7b\xe2\xf3\x26\x31\xf4\xd3\x10\x17\xf1\x4d\x8b\x6a\x86\x56\xb1\xdd\xc9\x62\x88\xf4\x66\x99\x7f\x6f\x6c\xeb\x63\x31\x11\xa5\x96\xa0\xbf\x9e\xcb\x72\x0a\x1a\xfe\xa8\x00\xaa\x97\x0b\xb8\x73\xa1\x95\x76\xc0\xde\xc2\xf4\x96\x6c\xf7\xc9\xe3\xd9\x6f\x91\xab\xae\x53\x77\x72\x14\x6a\x85\xb4\xb2\x84\xa5\xd0\x67\xe8\xc8\x6c\x51\xa9\x31\x1f\x17\xa4\xb6\xea\xf3\x36\x07\xef\xef\x4d\x79\x0b\x16\x0e\xb6\x7e\xd0\x8c\xa9\x12\x1a\x50\x49\xfa\xfe\xd8\x03\xdb\x42\x93\x84\xfc\xd1\xea\x99\x69\x3d\x30\x54\x75\x36\x63\xcb\xc5\x30\x2a\xac\x5e\x29\x3a\xc3\xc0\xa3\x3a\xa6\x96\xa8\x78\xbb\x72\xc5\x72\x70\x86\x58\x32\x59\xe6\x92\x9c\x2e\xd2\xda\xf6\x85\x39\x9f\x64\x74\x68\xb4\x06\x0c\x07\x62\x85\xf9\x62\x4f\xc6\x6a\x51\xcb\xb9\xfc\x2d\x50\xf6\xa7\x13\x09\x8f\x69\xb5\xac\x82\xe3\x3c\xba\x53\x64\x99\xaa\xcc\x8c\x15\x6b\x54\x18\x17\x77\x7c\xbe\x28\x44\x1f\x0f\xb0\x5e\x15\x34\xb0\x5a\x96\x25\xa9\x15\xc3\xa4\xb1\x5c\xea\x45\xc1\xd7\x4c\x55\xec\x6b\xf3\xfd\xea\xc2\x06\x85\x8e\x3b\xcd\xad\xc0\x0c\xec\x9c\xdf\xd9\x3b\xa2\x19\x34\x59\xa2\x2c\xd2\x0c\x35\x06\xcf\x41\xe7\x8d\x97\x8c\x97\x6a\xce\x8b\x35\xcb\x81\xad\xf0\x45\xcd\x25\x38\xd2\xc7\x11\xb1\x7a\xdf\xce\xc8\xba\xcd\x1d\x34\x57\x6d\x7b\xd9\x7f\x97\x08\xdb\x8b\xf3\x25\x5f\x34\x53\x7c\x4a\x2a\x57\xfb\xe4\x0c\xf6\xf4\x86\x3d\xfc\xa8\x41\xb6\x43\xf5\xd0\x26\x3d\x0f\xb5\x31\x88\x9c\x05\xe7\xdf\xb6\x3f\x26\xfa\xac\xf7\x59\x2f\xa6\xb6\x09\x46\xbe\xf9\x7e\x65\xa5\x24\xbc\x41\x93\xd1\x35\xbf\x55\xfe\xc6\x0d\x43\xf4\x9f\xd7\x8c\xe3\xcd\xdb\x5e\x3e\x70\x07\xd8\xf2\x66\x6a\x45\xd7\x91\xa5\x06\x61\xcb\x70\xd3\x21\x13\x6b\x39\xd0\xe8\x74\x10\xd4\xa6\xeb\x3a\xc3\x5d\xe5\x32\x87\x1b\x4f\x03\x2a\xce\x34\x19\x4c\x23\xac\x0b\xbb\xc0\x96\x15\x66\x6c\xd8\xf5\x7c\x07\x85\xd2\x3d\x6a\xce\x6b\x51\x49\x5e\xc8\xdf\xc2\xce\x0a\x27\x00\xa8\x67\x95\xaa\xeb\x42\xe8\x7e\xb4\xd7\xd1\xbb\xee\x8a\xa3\xd2\x04\x7a\x9c\x44\xcf\x11\xee\xc6\xe4\x54\x56\xcc\x04\x81\x5b\x55\x33\x08\x88\x6a\x89\x52\x08\x5f\x9c\x9d\x13\xf0\xdf\xdc\x74\x8b\xe0\x16\x4e\xf7\x21\x14\x2e\xa1\xe4\xe5\x7e\x3b\x3a\xeb\x76\x12\xaf\xba\x8f\xdb\xf7\x59\x5c\x59\x89\xfb\x11\x5e\x5d\x3f\xfb\x6c\x8b\x7d\x66\x68\xce\x8d\x55\x71\x9d\x8c\x7f\xd5\x23\x92\x3e\xec\x99\xc8\x59\x5d\x2f\xf4\xde\x68\x34\x95\xf5\x6c\x39\x1e\x66\x6a\x3e\x9a\xf0\x4c\x8c\x95\xba\x19\x41\xe2\x71\xa1\xc6\x23\xf1\xd7\xbf\x8e\xf9\x93\xc7\x3c\xff\x6a\x2c\xbe\xfc\xe2\x0b\x31\xfe\xea\xcb\x2f\x9f\x7c\x31\x79\x32\x7e\xfc\xf5\xdf\xf2\xbf\x3f\xf9\xfa\x8b\x27\x5f\xe6\x5f\xe7\xe2\xaf\x23\x12\x15\x6a\xcc\xab\xab\x6c\xf4\xe6\xcd\x44\x55\x37\xfa\xcd\x1b\x5b\xed\xf0\x57\xbd\xc5\xa0\x61\xe7\x66\x7d\x67\x33\x5e\x4e\x41\x10\xb3\x42\xee\xd2\xfa\xf4\x34\xc9\xc1\x15\x80\xe0\xa0\x0e\x14\xf9\xfa\xec\x9b\xfc\xbc\xcc\x59\xae\x58\xa9\x90\xfb\x00\x7d\xdc\x1e\x25\xeb\x59\x95\x25\x3a\x1c\x01\x92\xf0\x33\x32\x9a\x13\x40\x98\xb5\x9c\x2f\x0a\x39\x91\x42\x93\xab\x91\x5c\x40\x9a\xc1\x60\x60\xfe\x5c\xca\xb9\x2c\x38\x40\x9a\x3a\x25\x62\xb8\xbe\xc1\xb6\x2c\xd4\xd4\x2c\x18\xea\x93\x55\x94\xc9\x54\x99\xcb\x1a\x9d\x06\x42\xed\x73\x51\xfb\x7a\xe9\xb8\x03\x8b\x90\x5a\x99\x22\xd0\xec\x03\x94\xa4\x72\x71\x2b\x0a\xb5\x80\x17\xd9\x80\xdd\x42\x05\xaa\x4a\xd6\xe6\x34\x31\x25\x2d\x78\x3d\xd3\x84\xeb\x65\x45\x6b\x85\x9a\x4e\xcd\x6f\xd3\x05\x84\x67\xaf\x54\xbe\x44\x6a\x13\x95\x05\x17\x4b\x58\xc2\x80\x44\xfc\x19\xc2\x91\x14\x6a\x2a\x11\xdb\x0e\x91\x87\x3d\x50\x09\x14\x88\x35\x6e\xb1\xcf\x46\x28\xb5\x29\xd4\xca\xc1\x5f\x50\xf7\x1b\x32\x95\x50\x33\x77\x51\xc9\xb2\x4e\xa5\x83\xbb\x91\x63\xcc\x4d\xab\xb7\x41\xb5\xb3\x10\x25\x3b\x70\x1a\x4f\x7a\x58\x88\x72\x5a\xcf\xfa\x26\x44\xb3\x03\x76\x58\x55\x7c\xbd\x0d\xa9\xbe\x65\xbb\xec\x3b\xcc\x30\x60\xbb\x6c\x8f\x3d\xde\xe9\xb3\x37\x37\x70\x9d\xd8\xdd\xc7\x5f\xdf\x40\x3c\x7e\x7c\xfe\xb9\x27\x5e\xa6\xb4\xd7\x90\x62\xc0\x76\x7f\x09\x2b\x84\xd0\x5f\x5a\xda\x31\xbc\x9a\x9e\x96\xb9\xb8\xf3\xb8\x22\xc1\x15\xc6\xdc\x5f\xa8\x8f\x7b\x20\x8a\xc3\xce\x0d\x2b\xd4\x6a\xd9\x1e\x7d\xa2\x47\xd3\x7e\xf2\xce\x66\xcd\x9c\x4c\x7b\x6c\x1d\x9f\x7f\xfe\x4b\x2c\x56\x09\x04\x28\xb4\xbe\x51\x68\xe2\x34\xd6\x7a\xc1\x45\x20\xd8\x3f\xf6\x68\x8a\xc8\x49\xa8\x91\x3f\x1a\x99\xe5\xce\x7e\x12\x45\xa6\xe6\x02\xef\x70\xe3\x25\xae\x26\x14\x4a\xc2\x6e\x60\xe1\x31\x85\x36\x4e\x2b\x00\xb1\xa9\xd4\xaa\x44\xd2\x99\xa9\xf2\x56\x94\x52\x98\x6b\xb4\x56\x5e\x3e\x69\x16\xbd\xf3\x5f\xad\x03\x17\x77\xe8\x1c\x6a\x62\x01\x27\x00\x44\x57\xd6\xc2\x7a\xc2\xc6\x5d\x02\xfa\x1a\xb4\x78\x20\x75\xe5\x0e\x0d\xb4\xaf\x2f\xc5\x8a\xa1\x65\x57\xa3\xab\xd6\x7d\xf1\x9d\x59\x8f\xee\x28\xbe\x67\xed\xba\xfd\xdb\x67\xf1\xf2\x04\xa3\x64\x08\x89\x35\x05\xfd\xb0\x37\x9b\xd3\xbb\x76\x5a\x82\xcd\x42\xfb\x6c\x38\x1c\x9a\x09\xdf\xb9\x06\xda\x2d\x2b\x11\xd2\x12\x10\xe5\xda\x85\x65\x97\x65\x6f\xa7\x69\xec\xf7\xc8\x95\x1b\x88\xfb\xc2\x5d\xf4\xe4\x61\xdb\xe8\x09\xfb\x96\x3d\xa1\x7d\xf4\x84\x0d\xd8\x93\x60\x23\x99\x22\x9e\xec\xd3\x4f\xdc\x4a\xf6\x33\xdc\x4c\xc1\x76\x82\x12\xda\xfb\xe9\xc9\x2f\x2d\x2d\x86\x90\x30\x0c\xf9\x62\x51\xac\xb7\xdd\xb0\xf6\xd9\x6b\x1c\xaa\x5f\x86\x99\x2a\x33\x5e\x6f\xc3\x70\x35\xde\xdf\xba\xc8\x11\x68\x9c\xb7\x83\xf1\xed\x45\xea\xc3\xba\xae\xe4\x78\x59\x8b\x33\x73\x46\xf3\x89\xd8\xde\x81\x07\x04\xc7\xea\xe7\xcb\x45\x61\xee\x10\x22\x37\xc4\xf7\xf8\xfc\xf9\x73\x5e\xdd\x2c\x17\xe7\x0b\x81\x2a\x60\x7a\xe8\xa5\xc2\x00\x98\xc2\xed\xcd\x17\x76\x3b\x3d\xda\x48\x8d\xe2\xdf\x57\x87\xcf\x4e\x8f\xdf\x1c\x5e\x5d\x5d\x9c\x7e\xff\xf2\xea\xe4\xcd\xd9\xe1\xf3\x93\x37\x17\x27\x3f\x9c\xfc\x83\xbc\x37\x5f\x88\xe9\xc9\xdd\x62\xbb\xf7\x7f\x5e\x9b\x99\x6f\x24\xbc\xbc\x3a\xbc\xb8\x7a\x73\xf4\xe3\xe1\x85\x59\x15\xbf\xa4\x92\xb8\xc8\xcf\x3e\x36\xab\x04\x04\x21\x45\x21\xa6\xbc\x88\x7a\x7a\xc4\xb3\x19\x68\xf7\xbd\xc5\x34\xe0\x36\xc7\x74\xb2\x33\x55\xe0\x01\xb7\x3d\x66\x3c\x0c\xf1\x56\x0f\x1b\x4a\x1d\xce\xb8\x3e\x5f\x95\x2f\x2a\xb5\x10\x55\xbd\x6e\x94\xd0\x10\xc5\x7b\x73\x52\x32\xf3\xea\xea\xd1\x3b\x95\x1a\x18\x08\x63\xb1\xdd\x93\x33\xac\x85\xae\x3b\x4a\xdb\xd0\xc9\xd7\x51\x8e\x5f\x36\x5b\xca\xb2\xee\x89\xea\x2e\x27\xfd\x82\x64\x9d\x57\xba\x6c\xac\x04\x7f\xf3\xd7\x9f\xe8\xeb\x5e\x9f\xc5\xfd\xb0\xb5\xc7\xa3\x82\x8f\x1d\xa8\x4c\x7e\x3a\x2d\x55\x25\x5e\xf1\x62\xf9\x27\xee\x8e\x86\x19\x74\x58\xe7\x82\xa6\x13\xb5\x08\x41\x20\x4b\x8f\x22\xd8\x64\x14\x88\x07\x5a\xd7\x61\x06\xb3\x24\xbe\x57\xaa\x10\xbc\x84\xd2\x40\x25\x1f\x73\x24\x52\x9e\x2d\xe7\xa2\x92\x99\x4b\x29\xf5\x19\x3f\xdb\xa6\x2a\x13\xe9\x5f\x28\x2d\xcd\x9d\xb2\x99\x0f\x2b\xf8\x86\xed\xa6\x32\x9d\xdf\x8a\xaa\x50\x3c\x17\x79\xb3\x61\xb6\x27\x91\x9d\x12\x32\xee\x7e\x48\x61\xd0\x72\xc1\xe1\x91\x17\x5e\xcc\x8f\xcf\x9f\xdb\x4a\xa4\xb0\xdc\x19\x3c\xd0\x63\xde\x1f\x04\x0a\xbf\xb1\x78\x93\x9d\xbb\x46\xa1\xd5\x32\xb8\x2f\x42\x1e\x1c\xce\x5a\x33\x99\x27\xaf\x20\xe9\xe5\xe5\x85\x5d\xe3\x52\x95\xc4\xc0\x0a\xf6\x91\x20\x65\xf5\x8f\xbc\x42\xba\xd4\x98\x1b\x78\x80\x99\x2c\xd1\xad\xaf\x15\xbd\xdb\x0c\xd4\x0c\x09\x0d\x65\x97\xe0\x0e\xc0\x35\x1e\xaf\x65\xf3\x65\x51\xcb\x45\x21\x98\x39\x10\x6f\x79\x61\x0a\x87\x5c\xd4\xb9\xd0\x0a\x0b\x06\xef\xa9\xaa\xdc\xa6\x37\x7d\xe9\xc3\x8a\xef\xbb\x3a\x71\xbd\x84\x96\x8d\x7e\x4a\x50\x05\xf0\x45\x10\xb2\x5d\x72\x87\x2a\x81\xa8\x77\x3e\x2e\x56\xf8\x99\x2f\x51\x43\xf1\x39\x1a\x2a\x1c\xc4\x73\x1d\xc7\x86\x2a\x4c\x8d\x7c\xcd\x45\x32\x5f\xea\xfa\xa5\x16\xb6\x4d\x29\xf5\x26\x95\x8b\xd7\x51\x1e\xfb\x01\x24\xa2\x53\xc3\x10\xb8\xd7\x70\xff\x37\xdb\x1c\x45\x36\xdc\x19\x6b\x90\xb6\xe3\x6a\x8d\x30\x99\x53\x03\xd5\xbd\xd2\xdb\xba\x40\xb0\xfc\x66\xdc\x9f\x2c\x1d\xb4\x36\x6c\xcc\xad\x6d\x86\xc9\x3b\x15\x75\x57\xde\xfd\x28\x27\x1d\x4b\xb4\xcb\x7a\xbd\xb6\xb3\xa5\x06\x61\xf6\xff\xde\xb6\x0a\xba\x8f\x54\xb9\xd5\xd7\x59\x0b\x34\xe5\xbe\x6a\xc2\xf6\xb2\xcf\x1b\x6b\x3a\x51\xa8\x4d\xb0\xa9\xdc\xae\xfa\x03\xad\x59\xff\x5c\xfb\x6e\xd3\xf3\x87\x46\x06\xe5\xa8\x33\x9e\x83\x60\xd2\x9d\x5f\xe6\xaa\x8d\x65\x96\xbd\x1a\x69\x84\x49\x03\x32\x25\xad\xcc\x25\x3e\x67\xb2\x6e\x96\x64\x15\x66\xf0\x92\x42\x5c\x74\x5a\x49\xec\x1d\x16\x51\x13\x8b\x74\xd3\x69\x93\xe8\x9e\x15\x6b\xad\x50\xc8\x84\x89\x41\xd4\x1e\x08\xb9\x6a\xf0\xbf\xc2\x43\xb2\x2d\x75\xb3\x24\x50\xff\x31\xd7\xb2\xe8\xdd\x46\x26\xe1\x45\xed\x80\x27\x7b\x9f\x5a\x30\x61\x2f\x47\x23\x76\x72\x2b\x4a\xf7\xf6\xe9\xce\x0e\x90\x27\x72\xa0\xb5\x7a\xc1\x11\x1e\xcf\xdc\xef\xc2\x91\x8c\xcb\xb1\x42\xbb\x95\x7b\xbe\x95\xb5\xf6\x05\xe4\xf0\xb3\xd9\x01\xb5\xac\xac\x19\x68\x5c\xda\x95\x6a\x55\x77\x76\xe9\x85\x8c\x20\x0d\xc9\x78\x81\x85\xa2\x06\x94\x43\xca\x30\x83\x15\x97\x26\xcb\xa0\x26\x54\xd9\xf0\xf1\x0d\xda\xf7\xe0\xf5\xf2\x36\xa6\x90\xef\xb9\x31\xac\xb1\x7c\xd8\x08\xcb\xf0\x7c\xe7\x4f\xd6\xbd\x30\xc5\x7e\x6a\x2b\x37\x4b\xd8\x40\x51\x3a\x17\x47\x42\x79\xbf\xdd\xbe\x84\x7a\x88\xbf\xaf\x05\x7c\x4d\x8a\x37\xf1\xfb\xfe\x3d\x99\x93\x7a\x26\xab\xfc\xfd\xf9\x12\x60\x4a\x40\xa8\x68\x1b\xf2\x07\xf8\x12\xbf\x44\xee\x63\x4c\xac\xac\xbd\x75\xbd\x2a\x63\x22\x9b\x78\x75\x36\x39\xdb\x54\x3a\x99\xcf\xf7\xb7\x69\xe6\xe8\x7f\xef\xb5\x8c\x89\x36\x9f\xb8\x0d\x7e\xe9\xde\x03\x2b\xb9\xb4\x22\xf9\xb6\x3b\x98\xc2\xb5\x72\x29\xc8\x25\xd2\x3d\x8c\x2c\x89\x94\xff\xd7\x82\x57\x7c\xce\xfe\x75\x7c\xfe\xfc\x04\x55\x86\xdf\x42\x7c\x18\x87\x2b\xf6\x2d\xcc\x4a\x18\xfe\xd9\x5b\xac\x24\x9e\x56\x7d\x0f\xbb\x19\xdc\x4d\x1e\xce\x65\x6e\xb5\x8f\x11\x73\x17\x40\x4a\x71\xd9\x1c\x66\x5b\x49\x68\x4d\xf6\xee\x5c\x68\x9b\x07\xf5\x93\x13\x87\x53\xff\xb0\xd2\xe8\x71\xee\x21\xe4\x2c\x6e\x2b\x63\xb9\x28\x44\x2d\x36\x8c\xe1\xce\x7e\x6a\x91\xfb\x0a\x1f\xc6\x26\x8f\x46\xec\x48\x95\x75\xc5\x2b\xd0\xcd\xbb\xd6\xc1\x28\x5e\xf7\x19\x6a\x28\x86\xb7\x0e\x5e\xd9\x4b\x48\xe8\xf1\xfa\xda\x2a\x98\x5c\xa3\xae\xf9\xe9\xc9\xdf\x47\x5f\x3b\x90\xe9\xcd\x1c\x38\x3b\x08\x99\xab\x06\xc9\x7c\x57\x2e\xdc\xe7\xf2\x47\xed\xa6\x1c\x90\x62\x3f\xe8\x48\x34\x00\x78\x69\xc4\x41\xd0\xe6\x44\x56\x73\xa1\xf1\x25\xe3\xfa\x35\x06\xff\x72\x6d\xa8\x2c\xf4\xb7\xef\x8b\xd9\x86\xed\x4c\x8b\xdc\x69\x6e\xab\x65\xbd\x40\x45\x36\x96\xa9\xaa\x32\x23\xeb\x14\x73\x76\x06\xa8\x3f\x15\x5c\x7d\x5c\x0f\xc2\xd3\x06\xdd\xe7\x46\xc7\xb8\x4f\xd8\x90\x58\xf4\x59\xd0\x8c\xc6\x45\xe7\x3e\x7e\xec\x7d\xaf\xe3\xb1\x79\x6e\xa2\xbd\xdb\xad\x26\x76\x03\x20\x3e\x20\x73\xbb\x7f\xfe\xf0\x0c\x8b\xd3\xf7\x9d\x33\xf7\x50\x11\xf6\x1d\x75\x72\x2f\x04\x9f\xf1\x7b\x0f\xb8\x17\xac\xca\xd2\xe2\x14\x31\x4c\xd7\x1d\x50\xc3\x87\x1d\x6d\x61\xbd\xf1\x49\x12\xe9\x37\xc1\xf8\x55\xe0\xcb\x26\x71\x04\x45\xe3\xd3\x1e\xea\x32\x35\xc2\x89\x6e\xd2\x91\x73\x0c\x04\x4b\x47\xb7\x11\x42\x43\xf8\xc3\x87\x4d\x70\xb0\xc4\x74\x31\x35\x9c\x56\xeb\xb9\xbb\xeb\xed\x46\xff\xa9\x47\x65\x67\xeb\x53\x54\xfd\x1d\x8f\xc4\x6e\xb1\xcb\x7f\xd3\x71\xe7\xdf\x74\xde\xf3\x04\xb2\x7d\x4d\x11\xf7\xf0\x9c\x08\x85\x42\x0f\xbd\x48\xba\x93\xc7\x1e\x34\x31\xac\x58\x8a\xdc\x44\xc9\x7b\xbd\x06\x55\x89\x73\x24\xd7\x58\xf7\x59\x13\xbe\xc3\xb4\xb6\x5e\xf7\x2e\x8d\x50\x82\xe0\xb0\x56\x45\x21\x72\xe8\xac\x19\xce\x2b\x30\x3b\x42\x8d\x57\x70\x40\xe5\x02\xc9\xa4\x3f\x7c\x57\x9e\x71\xc0\x81\x34\x57\x04\x7b\x43\xc3\x46\x8c\x97\x75\xad\xca\x3d\xa0\xdf\x04\x87\x65\xca\x1a\xab\xbb\x30\x4c\xce\xf9\x54\x84\x01\x33\x99\xe7\x22\xca\x56\xf1\x5c\xaa\x28\x40\x68\x51\x87\x01\x7a\x39\x9e\x4b\x0a\x71\x4f\x8c\x76\x19\x84\xbd\x61\xb8\x27\x43\xad\x5d\xc0\x65\xe9\xbb\x05\xd3\xf7\xf0\x19\xfe\x41\xc5\xf1\xf9\x90\x38\x98\xd0\xdf\x7f\x6f\xf5\x1f\x62\x35\xc0\x50\xfc\x62\x8f\x3c\x3d\x54\xe5\x11\xea\x57\xb8\x90\x8a\x32\xf9\x90\x5c\x6a\x3e\x2e\xc4\x43\x4d\x61\x6d\x94\x7f\xe9\xfc\xa7\x5a\x9a\xa2\x6e\x65\x6e\x2e\x5c\xec\x1a\xfa\x7a\x0d\xa5\x93\xce\xba\xaa\xe6\x6c\x02\xe0\xa9\x86\x0f\x01\x2d\xf9\x12\xdf\x39\xaf\x6d\x0b\xaf\xad\xc9\x11\x61\x81\xac\xa4\x73\x23\x0b\xf6\x52\x3c\x1f\x00\xbb\x02\xc5\x00\xc2\x08\x02\xd9\x80\xfb\x27\x53\xb2\x47\xc1\x31\xdb\x1b\xec\x93\xb4\x60\xd7\x64\xf2\x05\x63\x74\x3d\x64\xe7\xf5\x4c\x54\x2b\x09\x6f\x26\x26\xbf\x16\x35\x13\xe8\x86\x20\x68\x8a\xaa\xd8\xb5\x1d\xa8\x6b\xef\x5a\x35\x58\x4e\x80\x49\xf1\xc1\x26\xf3\xdf\x38\x59\xd4\x9b\xff\xcb\xa6\xeb\x88\x5a\xf5\x07\x27\xcc\x6d\x4a\x38\x25\x19\xfb\x8c\x11\xea\x19\x80\xfc\x95\x37\x22\x77\xab\xd5\x0b\x20\x26\x0a\x2d\xcb\x91\x3a\xc1\x68\xe8\x21\x33\xe3\x46\x6d\x2e\x55\x6d\x1a\x8b\x05\x82\x74\x4c\x2d\x6b\x80\x0e\x24\xe5\x4b\x84\x28\x3a\x7f\xde\x2c\xc6\x2f\x0b\x54\xa9\xfc\x6c\xb4\xc5\x36\x53\xc3\x61\x4c\x07\x23\x65\x85\x9a\x4f\x71\xb1\xd1\xea\x9b\x82\x03\x62\xaf\x56\x18\x67\xdd\x76\x34\xc9\x65\xe8\x99\xbf\xbd\x3e\x73\x05\xb9\x12\x12\xe6\x4f\xb9\x04\x36\x1f\x6d\x1e\x11\xdf\x16\x34\xbf\x07\xa4\xf2\x05\xca\x5e\x9f\xc1\xad\x6a\xcc\xf3\x21\x7b\x2a\xef\xd8\x5c\xe0\x13\xf8\x54\xd4\x21\x56\xd3\xf9\xaa\x14\x95\xa9\x11\xac\x64\x3b\xf0\x9c\xba\xf2\xec\xa7\x4a\x84\x56\x1f\x1a\x02\x9e\x2f\xe7\x60\x28\xfb\xb0\x52\xa3\x7c\x64\x94\x46\xb0\x5c\x30\x0f\xc7\x01\xf1\xf0\x87\x6e\x90\x8a\xd6\xe9\x71\xb4\x6a\xd3\x29\xdd\x0c\x5f\xa9\x97\x65\xb0\x30\x52\x89\xc3\x04\x57\xea\x28\x91\x38\x7c\x9c\xf7\xf1\x48\x88\x3c\xeb\xb5\xd4\x42\xfb\x46\xf9\x13\x02\x05\x35\xf6\x5c\xec\x79\xf2\xe2\x23\xe1\xf4\x03\xae\x81\x68\x48\x58\xd6\x77\x94\x9c\x88\x87\xc3\x43\xda\xa3\x70\xe4\x40\x1f\xd9\x07\x23\xcf\xa6\x9e\x5a\x4b\x6e\x60\xaf\xbf\x91\xe5\x62\x59\x7f\x0b\xd6\xf9\x01\x00\x19\xc8\xb6\x01\x6a\x0c\xbc\x6a\x5b\x0b\x52\x2d\x1c\x36\x16\x28\xc2\x99\x9a\xf6\x3c\x01\xeb\xdb\xad\xdc\x6f\x51\x91\x3e\x28\xb7\x35\x8e\x02\x62\x83\x4f\x27\x01\x0d\x34\x64\xc4\xd2\x83\x4a\x38\xfd\xc1\x42\x8a\x9c\x6d\xab\x0a\xba\x33\xf2\x8c\x62\xdf\x0c\x0a\x1a\x4d\xa9\x52\x6f\x01\x35\x30\x4d\x9f\x4c\xe0\x46\x6c\x6e\xc7\x34\x40\x80\x3a\x60\x8a\xc7\x91\x01\x6a\x69\xb5\x4f\x1b\xc0\x58\x16\x50\xca\xb7\xaf\x9e\x89\x35\xaa\xbe\xbb\xb6\x98\xfe\x98\xd6\xb5\x1a\x14\xd8\xc6\xe7\x0e\x81\x09\xaa\x2b\x55\x0d\x2d\xdc\x5c\xab\x85\x12\xeb\x93\x87\x32\xb5\xd0\x6c\x0e\xde\x6f\x48\x4f\xb3\x64\xaa\xca\xd1\xc8\x03\x3b\x9c\xa8\x0f\x51\xca\xb0\x86\xdc\x76\xe4\xaa\xb3\x65\x63\x53\xac\xac\x51\xc7\x17\x44\xb6\xcb\xd2\x0e\x9c\x19\xf5\xe6\x74\xee\x98\xe2\x40\xa0\xc1\x09\x47\x93\x86\x35\x4c\x8c\xb3\xbc\x63\x6b\xbf\x14\xc2\x9a\xc0\xae\x56\xab\xe1\xea\x8b\xa1\xaa\xa6\xa3\xab\x8b\xd1\x93\xc7\xbb\x4f\x46\x3f\x1d\x0f\x66\xf5\xbc\xf8\x6a\x60\xbe\x76\x1f\x3f\xf9\x6a\x54\xcf\xc4\x00\x56\xe7\xc0\x8e\x8c\x49\x80\xcf\xec\xa1\xc8\xf7\x47\xa5\xe1\x3a\xa3\x3d\x74\x51\x63\x0f\x1a\xa6\x98\x1d\xd8\x1e\x5b\x53\x25\x2b\x58\x0d\xf6\x8b\x8d\xca\x1a\x1b\x96\xbe\x1d\x73\x39\xb3\x55\xb2\x03\xe6\xd0\x21\xb6\x48\x5e\xe3\x2d\x84\xc9\xe7\x2a\x6e\x69\xf2\x58\xc0\xcb\x35\x99\x4f\x07\x82\xb0\x6d\xbb\xc7\x86\x24\xfe\x8c\x9c\x1c\x60\xfe\xb9\xe0\xa5\xa6\x04\x00\x6f\x6e\x76\x2c\x88\x8b\x76\x77\x61\x73\x81\xb7\x57\xb4\x32\x33\x19\xf6\xfc\x75\xaa\xdf\xdd\x34\x5d\x8b\x85\xab\x87\xa6\x30\x6e\x8c\x8b\x35\x49\x6d\x41\xcd\xc6\x54\xca\x54\x96\x9b\x2b\x2e\x20\x11\xf5\xd9\x98\x6b\x80\x20\x54\x25\x83\x3a\x16\x95\xc8\xa4\x96\xaa\xc4\x16\x9a\xb0\x87\xb5\x70\x2e\x4b\xf6\x29\x1b\xce\xf9\x5d\xb3\x9d\x4e\x47\x9c\x86\x12\xb7\x85\x2d\x09\x50\x0f\xab\x52\x54\x60\x81\xa1\x99\x5e\x66\x33\x30\xa4\x87\xfd\x03\x86\x1a\xb9\xa8\x24\x68\xf0\x82\x64\x01\x4a\xed\x33\x31\x9c\x0e\xd9\xa9\xd6\x4b\xc1\xfe\xf2\xb7\xdd\xbf\x3d\xc6\xf6\xce\x65\xd9\x6a\xee\x9c\xdf\x05\x61\xe6\xbc\x76\xe7\x3a\x2e\x86\x78\xd3\xb4\xf2\x87\xdb\xa4\x15\x49\xb7\x95\x88\x8c\x87\x72\x23\x73\xcf\x7b\x43\xb8\x7f\x00\xfc\x36\xa4\x0d\x0c\xc5\x35\xd8\xe4\xe6\x21\xf1\x9d\x0b\xd9\x54\x12\xb5\x7b\x0b\x95\x60\xb7\x22\x24\x17\x58\xfd\xfb\x91\x64\xca\xe4\xfa\x29\x28\x26\xb9\x1d\x71\x60\xde\x85\xe1\xda\xee\x01\x11\xe8\x85\x4c\xd6\x06\xc6\x23\xf4\x7d\xd7\x3c\x21\xc3\x87\x17\x30\x10\x03\x76\x3e\x66\x1c\x5a\xa9\x1e\x6d\xe2\x33\x76\x5a\x80\x94\x56\x1b\xec\x13\x6d\xb1\x80\xc8\x26\x6a\x41\xbe\xd5\xcc\x5e\xfe\x44\x07\xa0\x1b\xb6\x7d\xa0\x4b\x1f\x37\x06\x5b\x48\x50\x9f\x50\x82\xb0\x67\x37\x9c\x08\x63\x61\x19\xf1\x80\x9b\x01\x27\x82\xc1\x37\xe4\xde\x06\x04\x8d\xc9\xda\xa6\x0f\x4f\x46\x53\x4b\x9f\xdc\xba\xa5\x5a\x80\x8e\xa7\xcd\x59\x07\x45\x99\x46\xef\x0c\xd9\x31\xa2\x8f\x8c\x45\xbd\x12\xc2\xf0\x26\x88\x7e\xb1\xa1\x21\x38\x06\x50\x86\x3d\x7c\x4c\x9f\x51\x5a\x11\x98\x48\x69\x61\x3b\xfe\x5c\x81\x9f\xb8\x89\x42\x95\xee\x9e\x35\x95\x08\x21\x14\x7c\x05\x03\xcf\xdb\xf7\x5a\xcb\x24\xe0\x78\xb7\x11\xa1\xf4\xd0\xf3\x3b\x76\x71\x01\xa5\x75\xd2\xdf\x7b\x18\x4c\xaf\xab\xf2\xb6\xb1\xe2\xec\xa6\xdd\xb4\xde\x5e\xa5\xd3\x3c\xea\xe2\x7d\x3f\xc4\x4a\xc3\x76\x05\xeb\x0c\x1b\xf1\xe7\xae\xb2\x5b\x57\x47\x73\x8d\xbd\x0a\x62\xfe\x9f\x5e\x61\xa9\x8b\x4e\xbc\xba\x1c\x36\x79\x1e\xa7\x6a\x2f\xa9\xfd\x4e\x9e\xa7\x4d\xe8\x9d\x68\x2c\x26\xf8\x7b\x1d\x57\x8b\xe6\x95\x63\x2f\x49\x41\xfb\x61\x89\x74\xb6\x25\xae\x24\xae\x34\x7b\xa2\x85\x9d\xb0\x18\xfa\x76\xdc\xf7\x52\x57\x2c\x77\x41\xf6\x7e\x2a\x80\xdd\xa5\x33\xe8\x1d\xb8\x41\x2f\xe4\x8e\x2e\x85\x89\x3a\x83\xc3\xe5\x51\xe2\xe0\x0c\xb2\x7f\xfa\x29\x8b\xbf\x1e\xdd\x73\xb1\xec\xde\xe0\xc1\x32\x02\x3d\x60\x73\x0d\x80\xad\x50\xa6\x56\x7f\xb0\xf3\xf1\x12\xe0\x53\xa4\xf7\x78\x20\x52\x21\x8c\x3d\x60\x87\xa2\xa2\x6b\x15\xf6\xc6\x30\xf9\xb7\x32\x13\xec\x56\x54\x9a\xef\x50\xb1\x1f\x64\xbb\x5a\xe5\xb1\x42\x4e\x04\x18\x57\x2a\x6b\xd6\xe5\x90\x8d\x83\x2d\xfb\xe0\xdd\xfa\x89\x8e\x36\xe0\x7d\x4c\xc4\xf6\x4e\x73\x8b\x6e\x10\x07\xa4\xce\x81\x7b\xd7\xc6\xa3\xf4\xe2\xe8\x12\x51\xbc\xc7\xe2\x60\xf7\xaf\x8c\x70\x32\xde\x69\x6d\xc4\x2b\x23\x9a\xd3\xff\x07\xd7\xc6\x06\xb9\x52\x07\x15\xef\xbc\x5f\x12\xc6\x44\x4c\x78\x77\xda\xcf\xce\x8d\xd7\xbe\x1e\xe5\xe8\xf5\x5d\xd1\xbf\xff\xee\x90\x1c\x82\x8a\x3b\xee\xbc\xfe\xd1\xb7\x51\x65\xac\x57\xf4\x18\xfc\x2f\x9b\xa5\x9d\x56\xe6\x0d\xa3\x58\xef\x71\x2f\xd0\x85\x38\x53\xb5\xd8\x63\xa7\x27\x5f\xb3\x4a\xa0\xf8\x92\xb3\x72\x39\x1f\x03\xc2\xc5\x62\x69\xbe\x35\xeb\xd5\xe2\xce\x9c\x94\x5a\x61\x37\x48\xf8\x41\x16\xa8\xc3\xd4\x9b\x60\x28\x2f\xc3\xf2\x7a\x91\x42\xca\xa5\x9c\x83\x77\x51\x76\x0d\xd5\x60\xeb\x0e\xf5\x19\x24\xbd\x1e\x42\x8b\x72\x25\x22\x43\x55\xaf\xd3\xea\x86\xcc\xe6\x30\x43\xc7\x2b\x2d\x9e\x16\x8a\xd7\xdb\xbe\xbf\x70\xde\x3f\x76\x7a\xd9\xa6\x75\xbe\x0d\x42\x17\xb2\xac\x07\xf4\x6e\x30\x28\xc5\x5d\x3d\x28\x64\x29\x5c\x25\x34\xf0\x71\x4d\xbf\xff\xfe\x8e\x25\x1c\x34\x4b\x88\x27\xcb\x56\xd0\x00\xb5\x38\xe2\xba\x76\x12\x37\x04\x85\xab\x2b\xb2\xf5\x73\x38\x70\x5e\x1b\x16\xee\xe4\xa4\x70\x52\xac\x87\xec\xa7\x99\x2c\x44\x58\x9e\x85\x3b\x33\xa4\x86\xe0\x17\x72\x85\x22\x7a\xae\x43\x67\x05\xbf\xea\x5c\xcd\xad\xf6\xed\x30\x56\xd3\x70\x6b\xc8\x29\x0c\x24\xdf\x4e\x1d\xa5\xf5\x0c\x77\xa8\x2b\x13\xea\x25\x7d\xb8\x5e\xfe\xe1\x3e\x6e\xec\x61\xeb\x41\xb7\x79\xab\x88\xdc\xfe\x27\xee\x13\x0d\x4c\x9a\xd1\x88\x9d\x96\xec\x68\x56\xa9\xb9\xe8\x33\x14\x55\x99\x7e\x47\xb9\xcc\xe9\x2e\x2a\x73\x83\x20\xb2\x8b\xe8\x93\x24\xa7\xd4\x14\x18\x69\x7c\xda\xc2\x9f\x82\x48\x36\xd8\xc7\x28\xb5\xb4\xa0\x19\xd8\xe6\x42\x69\x28\x8e\xcb\x02\xeb\xce\xe4\x9c\x17\x6c\xa1\x64\x59\x6b\x42\xe4\x98\x73\x59\xd8\x22\x82\x79\x83\x86\xb3\x8a\x4b\x53\xc2\x47\x57\x33\x81\x50\x90\x13\xe9\x34\x47\xbf\xb9\xfb\xd6\xf9\xc6\xc0\x36\x52\x61\x3c\xcf\x2b\xa1\xf5\x47\xbe\xb5\xbe\xdc\x1f\x05\x4a\x98\x90\xcc\xd4\x8a\x69\x21\xac\x05\x79\x34\x34\x33\xae\x3d\x66\x09\x0a\x60\xf3\x3e\xfa\x40\xf0\x32\xf1\x45\xa5\xc6\x85\x98\x6b\x5f\xfe\xca\x02\xad\x80\x74\x5a\xd2\x10\xa2\x18\x5d\xdc\xd5\x89\x16\x6d\x42\x01\x80\xc3\x6b\x84\x86\xea\xa3\xbf\x3d\xf9\xea\x8b\x50\xb1\xcb\xac\xa6\xd6\x9d\x12\x96\x55\x7b\x7d\xb4\x94\xa9\x1a\xd7\x89\x8e\x6c\x6d\x75\xa8\x94\x7c\xa5\x6b\x65\x1e\xa5\x4f\xb3\xb8\x05\xfe\x5a\xfd\xe8\x51\x2a\x77\x78\x88\x86\x2c\x3f\x80\x80\xa8\x65\x59\xbf\x2b\xd7\xbf\x45\x90\x3e\x35\xcf\xec\xc5\x18\x58\x9b\xb0\xdf\x00\xf0\x83\x58\xf5\xb9\x62\xbc\x5c\x23\xca\x81\x05\x8d\x09\x5c\x50\x12\x0c\x13\x28\x23\x18\x56\x06\xf4\x14\x82\x93\xad\x9e\x29\x4d\xe4\x45\xb3\x4f\xa3\x4a\x50\x0d\x12\x9f\x42\x87\xec\x6a\x26\xd6\x58\x98\x7d\xfd\x80\xa2\xe0\x75\xd6\x74\x41\xa3\x65\xb7\xd4\x4c\x59\xd3\xb4\xa6\x05\x83\xb9\xf1\xda\x25\x8b\x45\xe1\xfd\x57\x5b\xba\x35\xa0\xea\x6d\x7b\xb6\xc5\x94\x7d\x74\x89\x6d\xff\xff\x2f\x45\xb5\xfe\x68\x07\x17\x70\xa9\x42\x2b\x88\xd1\xc8\xbd\x5a\x03\xf6\x9f\x05\xe4\x0e\xee\xb5\xf6\xd9\x93\x6b\xc1\x7a\x38\x1a\xbd\xbd\x20\x08\xfa\xd2\xb3\xb0\xd9\xe3\x4a\x70\x02\x3c\xc1\xe8\x4c\x15\xaa\x8a\x32\x98\xfb\x5c\x2b\xc0\xf0\x7e\xc9\xc0\x01\xd8\x1d\x44\x51\x73\x55\xd6\xb3\x28\xa4\x95\x7b\x25\xc4\x8d\x6b\x93\xb5\xb0\x9f\xc8\x3b\x52\xe5\x2a\xd5\x40\xcf\xd4\x0a\x71\x22\xc0\xc9\xe7\xf9\x25\xbb\xe4\x13\x5e\x49\x18\xea\xc3\x32\xaf\x94\xcc\x89\x54\xed\xbd\xd7\x8e\xfe\xe2\x8b\xf4\xd9\xb0\x9f\x0a\x6e\x6d\xdc\xfd\xf6\x78\x36\x00\xca\xdb\xf9\x6f\x93\x19\x2d\xca\xdc\x99\xaa\xe6\xe8\x14\x76\x25\x7a\x39\x03\x78\xa5\x5c\xb1\x6b\xc8\xea\x99\xd7\xf0\xf3\x1a\x65\xfd\x74\xef\xb7\xaf\x00\x85\xd0\x1a\x97\xeb\x78\x39\xb5\x1e\x11\x11\xc7\xaf\x14\x22\xc7\xfb\x03\xa2\xda\xc2\x13\x82\xb9\x13\x20\xc9\x1f\x2f\x01\x4e\xa4\x12\xee\xfd\x31\x26\x08\x01\x4c\x23\xa0\x9f\xc9\x39\x80\x78\x4c\x8a\x25\xe0\x1f\xf8\xd3\x5c\x4d\x1c\x4f\x0c\xb8\x73\x04\x86\x97\xc3\xce\x37\xb4\x60\x67\x88\x65\x5d\x88\x89\xa8\x04\x20\x69\xdb\xa9\x1b\x2f\xa7\x86\xbe\x55\x6a\x2e\x97\x73\x78\xae\x5a\x8c\xec\xa7\x9d\x3d\x53\x90\x2c\xbe\x93\xf9\xc1\x5f\x1f\xff\xfd\xcb\xdd\xbf\x3a\x9c\x3e\x0b\xb9\x53\x8b\xf9\x42\x55\xbc\x92\xc5\x9a\x2d\x4b\x43\x17\xc0\x30\xc6\x70\x21\x80\x48\x9a\x4b\x5d\x2d\x17\xd0\x45\x78\xf1\x25\xf5\x29\x36\xad\xd4\x72\xe1\x40\x23\x4b\x54\x69\x83\x21\x2f\x49\x85\xcd\x2a\xf6\x12\xc9\x8f\x34\x35\x29\x3d\xae\xa1\xb7\x5b\x9d\xd4\x36\x11\xbc\xff\xce\xa9\x1f\xd0\x10\xdb\xe6\x98\x7c\x57\x42\xd7\xaa\x12\xfe\x06\x05\x77\xe5\x8f\x77\xdf\x41\x78\x13\x0b\x7d\xf0\x3e\x64\x85\x35\x36\xf6\x8c\xcf\x45\x7e\xa4\xcc\xb5\x53\x37\x92\xb4\xe5\x47\x51\xe2\x4a\xa9\xfa\x2c\xc8\xe0\x1b\xe2\x55\x0c\x75\x34\x21\xe9\x57\x7c\x60\xc6\x71\x84\xa2\x53\xd0\x14\xf5\x5f\x86\xe6\x82\xef\x63\x74\x4a\x8f\xd0\xf8\x10\xbd\x32\x8c\x27\xdb\x76\x29\x86\xe8\x21\x03\xdc\x11\xb8\x73\x34\xcc\x9f\x4a\x19\x01\xa9\xa0\x2d\xdc\xb5\xad\x67\x38\x51\xd5\xfc\x1a\xcc\xe2\x4a\x55\x0e\xc0\x91\x0f\xe2\xb9\x19\xee\x08\x2e\xff\x75\xb5\x66\xd7\x00\x26\x6e\xc5\x02\xd7\xee\xb9\x0e\xb1\x54\x79\x1d\xec\xc1\xb1\x98\x71\x73\xd8\xe8\xba\x32\xdc\x52\xb1\x26\x9d\x76\xf4\x87\x0f\x25\xf2\xc2\x1c\x62\xd5\x1a\xe5\x00\xb6\x2c\xac\x63\x2a\x6a\xd2\x85\xd5\xdf\x83\xae\xe6\x75\xdf\xd7\x02\xdb\x1d\x94\x9a\xe8\x29\x8a\x54\x62\xc0\xcd\x42\x25\x4a\x5b\x94\xa1\xcb\x78\x6e\xcb\x32\x2b\x96\xb9\xb0\x47\x31\x94\x62\xe1\xab\x7e\xbc\x7a\xfe\xec\x2b\xac\xf6\x20\xd0\x3e\x1a\xb2\x4b\x59\x66\xee\x11\x16\x80\xb3\x81\x01\x9e\x3b\x40\x7c\xa0\x23\xf0\x66\x4e\xba\x5a\xe0\x9e\x34\x19\x0f\x28\x3f\x58\x52\xae\xb2\x25\xbe\xf0\x3f\x13\x75\x4f\x23\x59\xb5\x8d\x41\x93\xb9\x6b\x98\xbf\x4b\x51\x88\xac\x56\xd5\x61\x51\x5c\x07\x37\x14\x6b\x44\xe7\x1e\x61\xa5\xd6\x8e\x2b\x19\xba\xe5\x04\x74\x23\x5a\x0a\xcd\x42\xe9\x49\xed\xb5\x59\x90\x07\x86\xe5\xfb\x8f\xcb\xf3\xb3\x21\xde\x88\xe4\x64\x8d\x06\x07\xa8\x41\x0c\x88\x17\x66\x31\x1f\x7c\x04\x0b\xf9\xa3\x5f\x7a\x56\x08\xea\x90\x4e\x24\x00\xf2\x30\xc9\xbe\xc1\xba\x09\xe8\x64\x9f\xc9\x10\xa1\xc4\xa4\x84\x87\xef\x33\xdc\xc2\x90\xf4\xb5\xfc\x25\xd4\xc5\x0d\xe2\x0f\xfc\x5e\x30\x77\x6b\x17\x03\x0b\x16\xe8\x4c\xb4\x84\x9b\x3e\x60\x64\xd9\x64\x5b\xfd\xd9\x8e\xaa\x1f\x00\x16\x23\x27\x11\xcd\xd5\x5e\x3d\x62\xbc\x66\xb9\x9c\xc0\x89\x60\xae\x82\x0b\x29\xb4\x39\x4a\xe0\xe5\xd2\x97\xc7\x09\x3a\x07\x6c\x26\x61\x7f\x1b\xb6\xcd\x15\x02\x30\xeb\x2e\x1e\x5a\xbe\x6d\xcd\x2b\xff\xb2\xfb\xf5\x17\x5f\xef\x84\xf8\x6b\x08\xa0\xe8\x70\x1f\xd5\x0d\x5f\xef\x7b\xcb\x49\x2f\x9c\xc0\x85\xc3\x75\x2b\xce\x97\x35\x97\x77\x1e\x3f\x28\xee\x21\x3c\x07\x99\xbd\x8e\x91\x2a\x00\x17\x74\x53\x64\x75\x1b\xa6\x02\x45\x60\x24\x0e\x83\xe0\xa7\x95\x9a\x9b\x61\xff\x78\xd7\x4f\x97\x93\x88\x3d\x0a\xb2\xa7\x3c\xff\x5a\xb5\x3c\x10\x33\xee\xb1\xe7\x61\x33\x51\xa1\xc6\xb6\x0b\x1b\x4d\xdb\xd6\xf9\x41\x80\xc1\xbb\x36\x03\x7d\xdd\x46\x17\x4b\x78\xfb\x0d\x2c\x7f\xa5\x8e\x05\x8e\xed\xb3\x16\xc0\x81\x32\x07\x96\x8f\x37\xe1\x19\x0f\x86\xd5\x90\x49\x8b\x8a\x08\xf7\x41\x3c\x18\x6b\x65\x3d\xb7\xc1\xd2\x72\x2e\x0a\xac\xfc\xdd\xdc\x60\xc5\x20\x73\x8c\x8b\x5d\x3c\x9a\xf1\x85\x39\x2e\x2a\xe9\xfc\xc1\x37\xcf\x33\x37\xc4\xfd\x60\x66\x76\xba\x6e\x43\x93\xc2\x5c\x01\xca\x23\x22\x87\xdb\x96\x2e\xfa\x63\x0b\x1c\x1a\x81\x73\x2d\xc3\x19\x20\xaf\xf2\x14\x73\x39\x2a\x8a\xe4\x13\xb0\xdf\xbc\xe6\x13\x2c\x33\xa0\x10\x9a\xb9\x3b\xbf\x26\x28\x5b\x49\xd0\x27\x28\x37\x30\x5b\x40\x82\x71\x5a\x3e\x74\xdc\x50\xc6\x4b\xa6\x65\x81\x00\x26\xfa\x46\x2e\x10\x0c\xd3\x39\x74\xa0\x12\x8e\xcf\x9f\x83\xd3\x30\x40\xd9\x40\x51\x37\x16\x01\x58\x52\xc8\x92\x6b\x41\x2a\x1d\xb2\x44\x84\xc5\xa1\xd5\xe1\x1c\xda\x9e\x1b\x9a\x70\xc2\xb3\x99\x1b\x81\x10\xf9\x2b\xf2\x3a\x84\xf2\x56\x59\xe4\x4d\x7b\x97\x2e\x8b\x4f\x0b\x02\x46\x79\x0e\x58\x0f\x87\xa5\x17\x7a\x9e\xf4\x91\x2d\xa1\xa4\x9d\x81\xcf\x0f\x30\x59\x30\x97\x91\x96\x05\xa5\xdb\xa0\xba\x87\xaa\x78\x69\xdd\x3d\x33\x76\x1a\x6f\x71\xd7\x1a\x28\xbf\x61\xd1\x51\xb2\x35\x6c\xe8\x50\x59\x2c\x9d\x6e\x25\x2a\x52\x41\x65\xdb\xeb\x65\x39\xd5\xb5\xa8\xf4\xce\x1e\xe2\xdf\x09\x47\x97\xcc\x71\x10\x56\xe5\x1b\x38\x6c\x41\xe6\x20\x8f\x64\x13\xdb\x91\xef\xb3\xde\x4b\x3a\x0d\x63\x15\xb2\x50\x29\x10\x45\xc2\xaa\x64\xdf\x60\xf6\x6f\x43\x80\x42\xab\x9e\x0c\xcb\x27\x68\x8c\x0a\x1a\x13\x78\x5a\xe8\x94\x22\x74\x30\xa0\xa3\x11\xde\x29\x0e\x3e\xfa\xc8\xbe\x8c\xcc\xf9\x8d\x40\xb9\xd3\x52\x04\x0a\xcc\xdb\x7f\xf9\xeb\x93\xdd\xaf\x77\xb6\x52\x5a\x01\xd1\x2a\xb3\xaa\x6d\x91\xb5\x54\x0f\x92\xba\x57\x89\xd0\x62\xea\x6d\x87\xee\xdb\x06\x96\x39\xa9\xac\xe6\x36\x7b\xa0\x78\xe4\xf4\x97\x3c\xfa\xb3\x27\x17\x4d\xd2\x62\x65\x3f\x44\x60\x9c\x41\x2d\xe5\xb0\xfd\x73\x95\xbb\xa4\xd6\xab\x5a\xe9\x9d\x6e\x27\xf5\x8a\xfe\x5c\xb5\xe7\x87\x2b\x28\xbf\x8b\xda\xf3\x97\xef\xad\xf6\xdc\x74\xa3\xde\x52\x09\x40\x1f\xde\x0e\x9f\x28\x5c\x04\xc7\x22\x2b\x38\xca\x82\xc0\xc2\xc0\x16\xbb\xed\xd7\x80\xb2\x9d\x20\xcf\x7b\xe9\x31\xd9\x76\x46\x60\x2e\x7d\x03\xbd\xab\xf7\x73\xf9\x73\xb9\xc1\x61\xf0\xb5\xd9\x81\xbe\xb2\xcf\x59\xef\x7a\xd8\x6b\x60\x5d\x99\x83\x87\xcc\x90\x6e\xad\xe2\x17\x98\xcf\xb2\x03\xf6\xda\x2d\xfd\x5e\x48\x01\x7a\xbf\xec\x3b\x22\xf8\xca\x89\xa1\x03\xd7\x9f\xa1\xd6\x70\x52\xcf\x38\xb0\x9b\x83\x73\x18\xb9\xe1\x58\x35\x9f\xf6\xcc\xbb\x29\xa7\x21\x91\x79\xa0\x76\xda\x97\xb8\x4f\x52\x9c\x73\x3c\x14\x29\x16\xba\x61\xdc\x16\x67\x70\x8c\xb4\xa3\x37\xa1\xf1\x59\x0b\xa9\x3e\xe2\x90\x3d\xd6\x80\xd4\x00\x4a\x68\xc1\x09\x87\xf4\xdd\x2c\xb0\x01\xd2\xa4\x87\x0e\xa1\xe1\xd3\x4f\xd9\x23\xca\xd4\xfd\x64\x7d\x65\x08\xfc\x27\x9a\xec\x5d\x9c\x46\x75\xad\x3c\x4d\xb7\x7a\x47\xbc\x64\x1c\x5a\x24\x89\xb8\x5f\xdb\xaa\xe0\x30\x03\x27\x10\xee\xfd\xd6\x59\x50\x74\x6f\x88\xb6\x61\xe1\xa3\x76\x0f\x3e\x68\x07\x98\xce\x78\xc1\x2b\x6c\x3d\x49\x53\x27\x2c\xee\x06\x94\xfb\x5e\xfd\x68\x9d\x09\xc8\x3d\x9e\xc3\x59\x67\x45\x1d\xb6\x2e\x2c\x1d\x15\x6c\x0c\x1f\x40\xe4\xe5\x92\x8e\xc9\x80\x5a\x60\x76\x2b\x6e\xa2\x4f\x47\xe2\x6d\x79\xe1\xc2\xb4\x67\x2d\x89\xb4\x0f\x7c\x55\xfb\xe9\x34\x04\x70\xd8\x75\x91\x8c\xcb\x4b\xdf\x28\x47\x23\xf6\xa2\x12\x13\x79\xe7\x65\x69\xd9\x8c\x2b\xba\x2e\x58\x97\x61\x37\x62\xed\x2e\x38\x51\xa9\xaf\x7b\xe0\xdc\x22\xae\xe9\xb5\xfc\xe5\x97\x84\x4e\x87\x47\xf5\xa4\x36\xbe\x31\x8d\xa4\x81\x71\xad\x7b\xd3\xba\xf0\x7a\x16\x27\xae\xa7\x09\x99\x88\x4d\xa1\xf2\x5e\xbf\x91\xbf\x0c\x63\x43\x74\xa0\xc9\x41\xac\x2b\xd7\x5c\x84\x75\x34\x81\xf8\x2f\x99\xd8\x27\x6d\x5e\x8d\x01\x55\xc2\x26\xfb\xf4\xd3\xce\xd5\xd1\x2e\x3c\x8f\x93\x35\x70\xb6\x3b\x0c\xe8\x47\x23\x76\xac\xf0\xf6\x26\x6a\xcb\xa8\x0d\x2d\x01\xd7\x4c\xdc\x99\x2b\x20\x48\x92\xa4\x32\x64\xc9\xdc\x3e\x32\x55\x6a\xf0\x5c\x51\x33\x9e\x55\x4a\x6b\xc6\xc9\xc7\x74\xf8\x24\x0b\x36\xd7\x70\x09\xd3\xf6\x62\x0b\xf3\xd6\x5c\x7c\xee\xa9\xab\xb1\x48\xdb\xfd\xf1\x46\x7d\xc1\x2a\x78\x62\x97\xc1\x93\xe4\x3a\x88\xb0\x59\xe3\xc9\x7b\xf2\x4b\xa0\x3d\x11\x37\x2b\x3d\xc6\x4f\xa2\x19\x8c\x11\xd2\x70\xde\x36\xcd\x55\xa3\xa4\xcd\xd3\x15\x02\x50\x85\xb7\x9f\x78\xa1\xb4\xca\x08\x5e\xfe\x1e\xc5\xb5\x25\x4c\x25\xdb\x2d\x08\xb3\x74\x3d\x35\x36\x73\xb5\xbd\xaf\x34\x52\xa4\xc7\xac\x89\x83\x14\xde\xa8\x3c\xf1\xde\x60\x0c\x65\xcd\x9f\xcc\x25\xd6\xdb\x45\x39\x63\xa8\x4d\x5c\x08\xc8\x5d\xdb\x74\xdf\x9b\xf9\xf8\x43\x03\x70\xc1\xe1\x56\x69\x86\x2f\x91\x13\x0c\xa0\x13\x19\xed\x71\xa9\x26\x41\x7e\x1d\x1a\x5a\x51\xfb\x02\xe1\xc9\xc3\x4c\xab\x08\x14\x1a\x4d\x90\x2c\x74\xb9\x1d\x62\x1c\x95\x8d\x36\x55\x4e\x26\x66\x37\x8b\x6f\x13\x62\xa7\xbd\xab\x65\x95\x3d\xa4\x42\xcb\x2a\x92\xc2\x48\x78\x58\x58\xa8\x52\xc3\x33\x4b\xd8\x8d\x86\x75\x55\x64\x28\x1d\x1b\x59\x99\xf2\x9c\x9d\x55\xba\x6a\x27\xf7\x09\x07\x38\xbe\xb9\x22\x6e\x1b\x3c\x9a\xf6\xd1\xf6\xc7\x35\xdb\x8a\xb4\x6c\xbf\xe9\x35\x96\xec\xb1\xc2\xf1\x6d\x5e\xd8\xa3\x8b\xdf\x93\xe4\xc5\x8f\x78\xed\xd0\x75\x6d\x64\x9a\x72\xdb\x30\x3a\x21\xf1\xc3\x26\x7b\x8e\x77\x7a\x95\x09\xec\x5f\xd3\xac\xf6\x43\xd4\xd2\xee\xd7\x58\x7e\xb5\xd9\x4a\xa6\xad\xca\xd0\x27\x39\x84\x7e\x4e\xdb\x69\xcf\x29\x1c\xd8\x0d\xe6\x2c\x96\xd3\x0a\x38\x1f\x56\xad\xff\xe3\xdd\x6e\x36\x13\x07\xee\x7f\xac\x32\x3e\xae\xde\xff\x26\x6d\xfc\x7b\x55\xea\xe1\xfe\x9c\x38\x08\xba\x65\x40\xe9\x8d\xb5\x41\xb7\xde\xdd\x21\x0e\x5a\x6b\xea\x1e\x9b\xc3\x4e\xfd\xcb\x14\x3b\xdf\x2c\xbb\x6f\x2d\xd7\x02\x7d\xcf\xa6\x92\xe4\x26\x25\xb1\x87\xd5\x91\xd8\x4a\x88\xcf\x94\x96\xa6\xbd\x7c\x4f\x55\xfc\xd1\x88\x1d\x3a\x67\x75\x0d\x65\x82\x95\xd3\x65\x77\x94\x71\x50\x0a\xad\xd9\x9c\x97\xa8\xa0\xa5\x15\x3d\x88\x2c\xb8\xd6\x81\xba\x01\x8e\x6d\xae\x56\x65\x92\xaa\x44\xa6\x73\x2c\xd8\xba\x4e\x0e\x16\x10\x0c\x7b\x2b\x8a\x4b\x08\x12\xa4\x29\xd7\x30\x2e\xa2\xbd\x40\xfe\x6d\x2b\x24\x6c\x98\x21\x5c\xcd\xdc\x81\x8f\xa4\xa7\xaa\x22\x9f\x2d\x99\xac\xd7\x7d\x56\x09\xf0\x1a\xd0\x3a\xf4\x5a\xec\x8a\x9a\x4e\x0b\x0b\x83\xfa\xb0\x55\xf9\x41\xd6\x65\x0b\x65\x07\xd4\x3c\x6e\x45\x85\xa6\xe1\x44\xa1\xac\xab\x46\x59\x6b\x4b\x0d\x41\x51\x83\x98\x1b\x30\x1c\x1f\xbe\x47\xa3\x1c\x3d\xf8\x8e\xbd\xfe\x85\xed\xb1\x5e\x2f\x9c\x81\x14\x0d\xea\x50\x87\x78\x17\x4a\xd4\xb9\x86\xfe\x8c\x45\xf4\x67\xc9\x69\x63\xa9\xd9\x57\x1f\x08\x4c\xc2\x1f\x07\x01\x88\x43\xf2\x22\x50\x8b\xbb\x9a\x57\x82\x3f\x08\x17\xc1\x61\x1e\xf0\x32\x37\x45\x35\xd9\x7e\x78\x73\xc6\xb7\x64\xc2\x30\x03\xef\x70\x15\x47\xd7\x21\xbc\x80\x47\xaf\xc3\x17\xa7\xee\x31\xcc\x2b\xdd\x7d\xc6\x96\x7a\x69\x6f\x1b\xe6\x66\xfc\xe2\xe8\xf8\xf0\xea\xd0\x49\xef\x3f\x1c\x67\xef\x11\x13\x4c\x79\xef\x83\x91\x10\x34\xe0\x8f\xa0\x24\x98\xd2\x4c\x8e\x77\x42\x49\x78\x3f\x3e\xfe\xc3\x80\x25\x24\x60\x10\xfc\xd5\xac\xbd\x20\xcc\x2e\x74\x3a\xcc\x8e\x0b\x73\xaf\x23\xf6\xc5\x65\x3b\x17\x8b\x4a\x80\x93\x87\x9d\x8d\xfc\xff\x17\xef\x40\x1c\x1e\x59\xc2\x6b\xc6\xa6\x82\x47\xec\x4b\x51\x9f\x96\xa5\xa8\x7e\xbc\x7a\xfe\xcc\x0b\x8a\x53\x6f\xf7\xd7\x1d\xb9\xae\xbd\x01\x05\xbc\x86\x69\x51\x82\xc7\xc3\x60\x1b\xc5\x4f\xf3\x74\xcc\xa3\x1f\x5f\xd0\xb4\xb7\x9d\x0f\xb5\x25\x50\xab\x85\x9d\x96\xec\xf4\xe4\xeb\x7e\x40\xaf\x81\x50\xc2\xe4\xe2\x72\x21\x47\xc2\x56\xe7\x76\xc2\xae\x4d\xbd\x47\x38\x8e\xb0\x1c\x01\x6c\x4e\xe4\x43\x16\xa8\x20\xe5\xa8\x6b\x28\xb2\x1b\x73\x5d\xd4\xa2\xbe\xf2\x99\xb6\xac\x6b\x24\x74\xff\x17\x61\x25\xcb\xc9\xc8\x29\x77\x13\x5b\xd1\xdc\xda\x30\xee\x84\x51\x40\xf0\xd7\xa6\x4e\x7a\xc7\x56\x86\xd2\xd4\x02\xb8\x95\xe2\x96\xbc\x32\x9d\x9e\x7c\xcd\xc6\xcb\xe9\x0e\xf2\xde\x97\x62\xcc\x75\x2d\x79\xf9\xf9\xa5\x5a\xcc\xa4\xe9\xb8\x98\x93\xc7\x32\x79\x83\x59\xac\xe3\xd7\x02\x7c\x98\x83\xe2\x30\xd5\x49\x3e\xce\x1c\xca\xb9\x59\x62\x84\xbd\x4a\x5e\xa1\x7a\x9a\xad\x66\x6b\x26\xcd\x8f\x89\xaa\x32\xab\x4d\x89\xfb\xc0\xda\x46\x0c\x37\xbd\x1f\xde\x77\x9f\x7c\x00\xc2\x81\x7f\x81\x44\x7d\xa3\xcd\x6c\xd9\xfb\xa2\x10\xbc\xd3\xe1\xf9\x3e\xe8\x04\x76\x91\x3f\xf0\x09\xe8\xab\xd6\xe3\xc9\x87\xb9\x56\xfa\xc3\x6d\xc3\xbb\x05\x35\xf5\x7f\xec\x95\xd2\x8e\x35\x16\xf3\xdf\x79\x99\x8c\x78\x87\x0e\xab\xbe\x0d\x80\x32\x8d\x0b\x86\x67\xc9\x46\x23\x84\x58\x1f\x23\x26\xcc\x44\xd4\xd9\x2c\x50\x76\x76\x44\x87\x2c\x0e\xa6\x8a\x8c\x96\x50\xc3\x68\x13\x5e\xeb\x83\xad\xc5\x1f\xae\xde\xd1\x3a\xa4\x64\x44\xe4\x5d\xb5\xc1\x53\x7f\xac\x26\xb0\x1f\xab\xdc\x98\x24\x2d\xb6\xdf\x4b\x8a\x9b\xcb\xf7\xa1\xca\x21\x81\x42\x88\xe5\xd1\x60\x01\xb8\x3a\x9b\x67\x53\x53\xc8\xfd\x68\x3b\x1e\xb8\x4d\xa7\xe2\xe9\x04\x7c\xec\x01\xc7\xd3\xba\x08\x01\xe2\xab\xaf\xaa\x4f\xbe\x32\xe1\x7a\xea\x79\xb8\x84\xde\x9a\x19\xa2\xf8\x09\xd6\x69\x5a\x84\xb2\xf4\x47\x2e\x98\xde\x1e\xd8\x37\x07\x6c\x37\xdd\xd0\x80\xa9\x35\x27\x04\x1c\x6d\xe8\x84\xb9\x66\x73\xc3\xe5\x82\x77\x5b\x53\x5c\xaa\x41\x2c\x9c\x54\xfb\xf3\xf5\xe3\xb6\x4f\xb9\x94\x45\x51\x3c\xfd\x2d\xa1\xfe\xab\xd4\xf2\x4d\x94\x14\x65\x8f\x37\x54\x73\x4d\x43\x73\x1e\x2c\x3e\x84\x46\x36\x0f\x9b\x0d\xd0\x02\xef\x24\x09\x7d\x9f\x4b\xfd\x87\xb4\x58\xfc\x83\xf6\x8a\xe8\xaf\x7d\x15\xcd\xa7\x27\x5f\xd6\x1f\x08\xbe\xbe\x02\x00\xa3\x80\x8b\x84\x66\xdb\x16\x70\xa9\x50\xda\xda\xbd\x79\x0e\x6e\xa7\xef\x99\x2b\x47\xe3\xc8\xbe\xce\xad\x0f\x57\x2f\xbc\xf6\x04\xc6\xb6\x49\x83\x63\x9b\x3a\x8d\xc9\xb2\x79\xad\xa5\x8c\xe1\xda\xe5\xbd\xdd\x7a\xa8\xf4\x22\x55\x5e\x9a\xfa\xde\x23\x84\x7c\x17\xee\xde\xea\x37\x83\xb9\xa1\x2f\x2a\xf4\xfe\x02\x36\x29\x3c\xcb\xc0\x2c\x07\x99\x6d\xd0\xb8\x84\x1b\x3f\xf2\xaa\x78\x7f\x24\x1b\xb4\x5b\x2e\x0b\x44\x06\x2d\x6b\x59\x90\xe9\x4c\x64\x73\x0f\x16\x92\x20\xa0\x43\xf9\x8e\x69\x5a\xc0\x7f\x5b\x69\x59\x10\x14\x9d\x7b\x60\x0e\xe3\x67\x51\x4e\xa2\xcc\x52\x33\xf1\x5f\x4b\x5e\xb8\xcb\x1f\xb9\xae\xb0\x5a\xa7\x28\x1e\x84\xac\x74\x53\xd8\x7d\x3c\x02\x40\xb4\x1a\x4c\x87\x40\xe7\xd7\x5b\x12\xc1\xa5\xac\xe0\x99\x98\xa9\x02\x50\x52\x03\x6f\x39\xd6\x98\x68\xa1\x16\x68\x30\x1e\xb6\x03\x74\xad\x8b\x82\xb4\x59\x2d\x23\x41\xfe\x82\x45\x35\x9c\xcb\xac\x52\x5a\x4d\x6a\xb0\xf2\x72\x5f\x03\x91\x4f\xc5\x68\x51\xf0\x7a\xa2\x2a\x67\x30\xb4\xfb\x78\xf7\xab\x27\x5f\x8d\x68\x2d\x45\x63\x75\x90\x94\x2d\x86\x94\x29\x5a\x60\x76\xe5\x47\x83\xfb\x40\x99\x52\x7a\x61\x8d\x46\x0c\x41\x53\x03\x48\x09\x74\xdc\x4d\x53\xbc\x4f\x94\xb0\x69\x78\xd3\x26\x89\x4e\xc9\xcb\xdc\x11\xc1\xab\xe3\xe5\x8b\xc3\xa3\x13\x90\xc3\xf7\xda\x38\x80\xbb\x5f\x7f\xfd\xf5\xe8\x6e\x56\xcf\x8b\x1e\x2a\xda\x3d\x3f\xbc\xfa\xd1\x67\xeb\xcc\xf4\xf7\xd1\x73\x5e\xcf\xe0\xbf\xe7\xcf\x28\xeb\xe5\xab\x1f\xee\xcb\xf9\xe4\xf1\xe3\xc7\x23\x7d\x3b\xed\x91\x94\xc8\xf9\x6f\xb0\x78\xd1\xa6\x25\x7b\xad\xb6\x9b\x9b\xcb\x9c\xd7\x33\x13\x17\x37\xd0\xc4\xe8\xdb\xe9\x5e\x5c\x39\xe0\x65\x9b\xcb\xae\xf3\x2b\x4f\xcb\xb2\x54\x0c\x0d\x74\xbc\x6f\x89\x61\x74\xc1\x3f\x2d\x0d\xb9\xd7\x32\x73\x2d\xdb\xf6\x26\x96\xd6\xf4\x32\x61\x74\x79\x3b\x75\xb6\x8c\x74\x51\x8a\x1a\x14\x9a\x5b\x9a\x8e\x34\x13\xc7\x9d\x4a\x1a\x13\x52\xca\xe6\xd0\x24\xf5\x53\x41\x5d\xd4\xf7\x80\x6c\x92\xbc\x8b\x09\xdf\x01\xa0\xab\x71\x74\xe4\x5c\xb2\x15\x75\xd0\x6a\x41\x70\x7a\x9e\x29\x90\x7b\x51\xcb\x77\x5a\x63\xbd\xc7\x16\xca\x6c\x17\x43\x3e\x44\x59\x57\x6b\x34\x46\x1f\x86\xba\x8e\x1b\x26\x21\x74\x96\x90\x6a\x59\xbc\x00\x3f\xfd\x94\x79\x73\xb0\x89\xaa\x84\x9c\x96\xe7\x70\x21\xef\x05\x4d\xfe\x09\x18\xfc\x42\x70\x40\x24\xbc\x7c\xf5\x43\xd4\x98\xf4\x68\x43\xc6\xef\xd7\xb6\x9f\x7d\x64\x2c\xbd\xb7\x12\x80\x84\x1c\xfa\x3b\x73\xa3\xad\xa4\x5b\xce\xa6\x85\x1a\xf3\x42\xb3\xe7\x97\x87\x8b\x05\x88\x9a\x48\x2a\x7a\x54\x09\x43\x0a\xb9\xd7\xb4\xc4\x33\xc2\xd0\xfc\xde\xb2\xd4\x7c\x22\x7a\x6c\x51\xc9\x5b\x59\x88\xa9\xd0\x6c\x9b\x7c\x29\x83\xf9\xcc\x4a\x96\xb9\x5a\xe9\xbf\x33\xbe\x00\xb4\xa6\xcf\x46\xb0\xd3\x32\x28\xf3\xb9\xa5\x91\x2f\xa1\x94\x67\x2a\xe3\xc5\x53\x5b\x49\xe4\xa3\x7c\x59\x66\x7e\x85\x90\x7e\x3d\x36\xb4\xe1\x7f\xdb\x8c\x33\x44\x0c\xc5\x9d\xc8\x12\xe5\x36\x3d\xd1\xba\x3a\x78\x35\x7d\x0c\x6e\x99\x77\xe1\xff\x27\xf0\xff\x17\x9e\x3b\xd8\x58\xea\x76\xca\xa5\x78\x54\x49\x57\xf9\x8e\x77\xb6\xef\x01\xfb\x4d\x3d\xa9\xa0\x10\xda\x5e\x48\x4e\x2e\x5f\xfd\x00\x66\xa5\x16\xf8\x8d\x84\x9b\xa7\x27\xac\xe0\x19\x98\xa4\x4b\x2b\x9d\x83\x31\xaf\xc4\x12\x14\x71\x2e\x5f\xfd\x70\xe4\x72\x1c\x78\x81\x9c\xf7\xf4\x44\xef\x6e\x56\x20\xb8\x70\xbe\x2b\x26\xe4\xbb\xe2\x3d\x5c\x57\x10\x6c\x2b\xfb\x5f\xb2\xac\x45\x85\xd8\xc1\xb8\x16\x74\x24\x7c\x7c\xc0\xd2\x08\x06\x1b\x79\x16\x53\xb6\x3b\xba\x4e\x4f\xbc\x28\x12\xbd\xf2\xb9\xc2\xc1\x6d\xd9\xab\x1f\xd0\x86\x1e\x10\x66\xec\x2d\x71\x65\x92\xfd\xea\x64\xdf\xa6\x9c\x52\xac\xd8\x1c\x5c\xea\xa2\x85\x1f\x0c\x35\xf0\x5b\x64\xef\x55\x32\xb8\x1b\x3b\xc1\x2d\x99\xe6\x93\x5a\x9a\x2c\x6b\xb5\xe5\x6c\x07\x6b\x5e\x4d\x89\xc9\xb1\x6f\x30\xce\x2e\x16\x76\xe1\xcb\x8b\x53\x20\x0d\xfe\x08\x1a\xea\xdb\x29\x88\x77\xb6\x7b\xae\x07\x3d\xd3\x14\x93\x31\xf0\xdb\x92\x9c\xd4\x64\xf0\xef\xbf\x7b\xeb\x43\x1c\x65\x9a\xb5\xed\x5e\x2e\x6f\x7b\xce\x03\x4d\x3b\xeb\x50\x06\x13\xd4\xfb\x46\xdf\x4e\xbf\x35\x57\x00\x33\xee\xe6\x4e\xfd\xcd\x08\x42\x02\x25\xcf\xdb\x29\x19\xf8\x25\x4b\x9b\xc8\x4a\xe3\xa9\x80\x59\xc8\xc0\x15\x46\xc4\xc7\xed\xa4\xdc\x62\x40\x4c\x2b\x65\xc8\xed\x53\x61\xd4\x84\xee\xf2\x0c\xc7\x52\xe6\x58\x5e\x22\xf1\x26\xd7\x1a\xe1\x68\x98\x31\xa0\x6d\xb9\x83\xfb\x32\x33\x3d\x07\x63\x41\x84\xf3\x9c\xab\x1c\xa1\x4a\x40\x36\x2c\x74\xc6\x17\x02\x60\x8e\xed\x8e\x7b\xae\xf2\x65\x61\x6e\x71\x95\x74\x9a\x5a\xec\x7f\x19\x8a\x0a\x3c\x96\x21\xc5\xe0\x7b\x85\xd7\xd9\xec\xc7\x7a\x5e\xa0\xa3\x72\x76\xc0\x46\xaf\x3f\xea\x7d\xfa\xcd\xb7\xbf\x8c\xfc\xee\x3d\x81\xe2\x9d\xde\x6b\x36\xe3\x15\xcf\x6a\xc4\x6f\x81\x95\x38\x95\xb7\xc2\x7a\x0b\x34\x1b\xda\x34\xa4\xe1\x8a\xc6\x6f\x5a\x4a\x06\x88\x2b\xfe\xe2\x89\x55\x98\xcd\x24\x4b\x2d\xaa\x1a\x49\x4d\xad\xe0\x7c\x82\x72\x88\x64\xd9\x72\xb0\xec\xe5\xb8\x90\x59\xe3\x11\x03\xcb\x32\x9d\x22\xf7\x88\xfe\x6a\xa3\xeb\xca\x5e\x35\x31\xca\xde\xa3\x61\x1c\xd8\x41\x73\x3c\x80\x34\x9b\x52\xbc\x19\xca\x23\x48\xd2\xa0\xf8\xba\xae\x22\xb5\x23\x6c\x82\x2d\x1c\x96\xb4\x95\x33\xa0\xd0\x2e\x17\x77\xa0\xe7\x49\x01\x05\xd7\xf5\xa9\x0f\xb4\x9a\xfc\x36\x1d\x54\x39\x84\xaf\x7d\xca\xfc\x8d\xa9\xd3\x6b\x2f\x9b\x30\xaf\x19\x6a\xb9\x38\x93\xc4\xcc\xd6\x91\xca\xc5\x61\x8d\xc5\x05\x62\x1e\x60\xd6\xbe\xf8\x72\xcf\x1d\x2d\xa3\x11\xfb\xc8\x7d\xd0\x94\x1c\xb0\xde\xa7\xff\xb5\x54\xf5\x7e\xcf\x4b\x6c\x02\x3c\x08\x5b\xca\xdf\xa3\x52\x3e\x4d\x95\xc2\xe7\x8b\x7b\x0a\xf9\x3a\x2a\xa4\x97\x2a\xe4\x2f\x77\x4f\xfe\xb6\xdf\xdb\x07\x53\xd4\xae\x3d\xb0\x8f\xee\x21\xf1\xd1\xa1\xf7\xe9\x5f\xbe\xf8\xba\xb7\xa1\xd6\xbf\x3e\x8e\x6a\xfd\x26\x55\x6b\x71\x4f\xf7\xff\xfa\x24\x2a\xe3\xdb\x54\x19\xd3\xee\x32\x1a\x7c\x70\xdb\x8c\xc2\x89\x1c\xfc\x42\x31\x3c\x0a\x4e\xa8\x9b\x4f\x24\x9d\x07\xb0\x32\xf4\x72\x8c\x2b\xdc\x67\xe9\x53\xfa\xa8\xd0\x70\xe5\xe1\xca\xfa\x9c\xed\x62\x0a\x5b\x9c\x5f\xcc\xa1\x4d\x55\xa2\x25\xec\x3b\x4b\xbd\xef\x69\x01\xdb\x23\x12\xf7\xd6\xd0\x36\x51\xe6\xef\x40\xdf\x62\xa2\xa4\x51\xfa\x53\x2b\xb0\x9e\x35\x9c\xb8\xce\x2a\x89\x98\x17\xbc\xae\x79\x76\xa3\x9b\x3e\xb1\x3e\x7b\x8b\x79\xae\xcc\x7f\x78\xd1\x75\x04\x68\x98\xa2\x34\xec\xd0\xd2\x94\xdc\x3f\x60\x85\x76\x3f\x18\x19\x3c\xf3\x3d\x55\xd5\xf7\x28\x19\x83\x5b\x78\x8b\xcb\x84\xfa\x81\x69\xa7\x97\xb4\xd0\xc4\xd3\x47\x36\x2c\x3c\xad\xce\x91\x9e\xa9\xaa\xce\x64\x95\x2d\x65\xcd\x66\xa2\x58\x68\xb6\x10\xd5\x04\x5f\xa1\x11\x5f\x8b\x1c\x08\xdf\x94\x6a\x45\x6a\xac\xe2\x56\x54\xde\x47\xee\x68\x94\xa0\xe6\x7d\x26\x28\xb0\x58\x13\x49\xaf\xd1\xa9\xaa\xd4\x2c\x70\x49\x81\xbb\x4b\x4d\x6a\x0f\x8b\x30\x41\xc3\x5d\x51\xc9\x8c\xe5\x6a\xce\x64\xae\xa3\x4b\x06\x50\x5c\xd3\xb1\x86\xc5\x56\x40\xaa\x61\xa0\xf6\x63\xef\xa0\xc8\xe6\x04\x72\x8c\x36\xd7\xd8\x47\x99\x25\xaa\x4b\x9b\x5e\xcf\x64\x4d\x77\x14\xd0\x90\x15\x5a\x54\xb7\x02\xd4\x27\x00\x3b\xc1\x42\x46\xc0\x71\x0b\x4b\x00\x44\x39\x0b\xa5\x2a\x06\x2b\x56\xd6\xd6\x4f\x4c\x24\xa7\x29\xf3\x3e\xe3\x73\x55\x4e\xd9\x9c\x97\x6b\x53\x1c\x0a\x5d\xfa\x74\x5e\x69\xf6\xcd\xb8\x8a\x4c\x46\x11\x50\xb2\x16\x15\x37\xc3\xbf\x2a\x24\x48\xc1\x79\xa5\x87\x01\xf7\x48\x98\x16\xe0\x9c\x16\xbc\x2f\xa2\xf5\xe7\xfb\xf8\x71\x43\xf8\xaf\x0e\x66\xf8\x2a\x12\x9c\x35\x79\xdd\xc6\x22\x75\x5f\x78\x38\x79\x06\xc6\xca\xdc\x42\x5e\xcb\x91\xa6\x20\xd9\xa7\x9f\x46\x99\xac\xf0\xc9\xd0\x81\x44\x82\xa1\x89\xbc\xb2\xf7\xd8\xab\x93\x7f\x5c\xbd\x39\x3b\x3f\x3e\xf1\x74\xad\x91\xf4\x55\x20\x9c\xda\x8f\x44\x07\xb1\x40\xb5\x29\x1e\x74\x59\xcc\x5d\xc7\xb4\xf8\xe4\x4e\x64\xf0\xc8\x7d\x52\xde\xca\x4a\x95\xc8\xc4\xf2\xf2\xa5\x16\xc7\xe7\xcf\x03\x4f\x87\xf8\x16\x4b\xc5\x00\xbf\xec\x78\x5e\xfb\x83\xa6\x67\x27\x80\xd4\x7c\xe8\x98\xb3\x10\x70\xed\xbe\xb1\xb0\xd8\x37\x1d\xe3\xd0\x65\x5d\x11\xde\x87\xa8\x01\xf7\x52\xad\xe8\xf2\x68\x65\x6e\x71\xbf\x40\xe6\x16\x07\x79\xb6\xf1\xe8\xf2\x32\x74\x45\x81\x17\x7c\x9e\x65\x62\x51\x5b\x2b\x7f\x78\xbd\xb5\x78\x64\xb2\x64\xcb\x52\xd6\x80\x86\xf1\xd1\xe2\xee\xa3\xa1\x5b\xc0\x52\xbf\x2c\x65\x5d\x08\xed\xc1\x32\xcd\x78\xf0\x52\xce\xc1\x86\xed\xb4\x26\xc4\xb2\x23\xb5\x2c\x03\x2f\x6e\x63\x50\xcf\x39\x9d\xf3\xa9\x38\x5f\xd6\x91\x83\xb7\x20\xea\xb2\x90\x99\x48\xc6\xfc\x24\xf3\x7a\x16\xc6\xdc\x3d\x2d\xc4\x5d\x2b\xe0\x87\x4a\x2d\x17\x51\xe8\x79\x95\xcb\x92\x17\x8d\x88\x4c\x15\xcb\x79\xb3\x8d\x18\xa8\x7d\xc0\x24\xaa\x62\x82\xe5\xaf\xe2\x90\x17\x4a\xcb\x5a\xde\x8a\x38\xf4\x72\x56\xc9\xf2\x26\x0e\x3b\x13\x53\xde\x4e\x79\x6e\xba\xe8\x83\xa6\x95\xcc\x2f\xc2\x3a\x28\xe0\xa4\xcc\x5b\x61\x97\x0b\x5e\xb6\x03\x6b\x5e\xd5\x71\xe8\x11\xf4\x2b\x15\xd6\x2a\x15\x83\xdb\x05\x53\x78\x5c\xf6\x44\x95\xf5\x4f\x42\x4e\x67\x41\x98\xa1\xad\x47\x05\x9f\x2f\xe2\xa0\x1f\x1b\xc9\xd4\x82\x67\xb2\x5e\x07\x01\xf1\x30\xa8\x6a\x31\xe3\xe1\x54\xd4\x7c\x7c\x29\x7f\x0b\xc6\x6e\x25\x73\xb5\x0a\x12\xfc\x06\x6c\x4d\xf0\xad\xd4\xdc\x7e\xe1\x45\xfd\xf2\xd5\x0f\x83\x4a\x14\xbc\x26\x97\x07\xb8\x19\x4c\x3f\x64\x51\x9c\x37\x1b\x34\x29\x94\xca\x5b\xa1\xba\x56\x8b\x44\x60\xa5\x6e\xc4\x31\xd7\x33\x30\xcc\x49\x45\xa8\xc9\x24\x5a\xf3\x18\xf3\xdc\x9c\x49\x85\x74\xce\x0d\x7d\x4c\x47\x1d\xc1\x2e\x40\x31\xd1\x67\x9f\xa5\xce\x9f\x05\x5a\x4c\xde\x8a\x32\x57\xd5\x80\x14\xd1\x32\x0a\xee\x33\x31\xdd\x63\x3f\x89\xf1\x8d\xac\x53\x99\x6f\xc4\x9a\xe9\x7a\x5d\x08\xeb\x4f\x7d\x6a\x2a\xe4\xa5\x06\x4d\xc6\xe3\x25\x6e\xef\x24\x77\xe6\xb3\x51\x5d\x56\x73\xee\x1a\x3f\xaf\xfb\x34\xf0\xc5\x9a\x65\x7c\x2e\x8a\x23\xae\x45\x0e\x55\x98\xf2\xb0\x4d\x57\xa9\xba\x02\x16\x0f\x8b\xfa\x4f\xb1\xde\xb6\xfd\xb9\x11\xeb\xc8\x20\x86\xba\xff\xb9\x89\x80\x4b\xd7\x61\xbd\xfd\x78\x67\x58\xab\x97\x8b\x85\xa8\x4c\x9d\xdb\x3b\x14\xeb\x39\xe3\xdd\x98\xe3\x21\x8d\x08\xdf\x23\x62\xe5\xe6\x7c\x8d\x60\x2f\x0b\xae\xc9\x63\xbe\xeb\xea\x78\xcd\x78\x0e\x90\xa1\x0b\x51\x59\xe7\xa7\xc0\x50\xa8\x09\x4d\x86\x4d\xac\x3d\x45\xb5\x21\x60\x19\x8f\x43\xd0\xeb\xb3\xde\x5c\x9b\xff\x9f\xab\xdf\xcc\x9f\x73\x34\x8e\x1f\xb1\x97\xf0\xcc\x8a\x82\xe5\xe1\x8d\x58\x6b\x36\x13\x95\x00\xa5\x1c\x90\x62\xe0\x73\x71\x29\x8b\x02\x30\xab\x06\xb2\x64\x85\x52\x0b\x72\x29\x7d\x7a\xf2\x77\x36\x55\x78\x99\xe7\xe5\x16\x3c\xaf\x4d\x64\x29\x6b\x01\xa9\xfa\x1e\xa9\xa5\x66\xc0\x2e\xd5\x42\x33\x75\x4b\xcf\x81\x86\x73\x82\x1e\x5a\xa7\x25\xac\x56\x6a\xb8\x15\x34\x66\xbb\x79\x3a\xec\x38\x8c\x96\xd8\x89\x23\x4e\x97\x1b\x8b\x54\x22\x13\xe5\xf0\x5b\x1a\xc5\xbe\x6e\xaf\x01\x28\xf5\x17\x00\xf4\x6f\xa5\x55\x0b\x50\x61\x00\xdb\xa7\x9d\xe0\x50\x54\x25\x68\x89\x5b\x64\x0f\x07\xe4\x84\x6b\x94\x65\x5a\xb3\x55\x25\x11\x97\x93\xde\x1f\x51\x54\xe2\x56\x39\xa2\x14\x81\x19\x97\xf3\xb3\x58\xa8\xa9\xcc\x78\x61\x98\x08\x36\x5b\x2f\x66\xa2\xd4\x3b\x7d\xc3\x52\x3a\x85\x50\x60\x59\x4b\x76\x7d\x74\x79\x69\x8d\x83\x87\xcd\x66\x5f\x37\xf9\xce\xd0\x47\x70\x78\x9e\xaf\x31\xc4\x3e\xc4\x5f\xd7\x6a\xf1\x9c\x57\x53\x59\x5e\x0f\x53\x5e\xf7\xe3\xac\x18\xe4\xf2\xee\x3e\x5e\xdc\x5d\xa7\x2f\x5e\x88\x16\x09\xba\xb0\xd8\x7f\xab\x3d\x5c\xcf\x58\x2e\xe7\xa2\xd4\xa0\x66\xcc\x51\x27\xb8\x71\x2b\x73\x4a\xa5\x97\x26\x2b\x7a\xb3\x0f\x1c\x59\xf7\x99\xd4\x47\x4b\x5d\xab\x79\xec\xed\x97\x20\xc5\xed\x1d\xaa\x77\x2b\x48\x15\x2c\x0f\x38\xa6\x80\x55\xda\x61\x19\x2f\x0a\xdc\x12\x4c\x4b\x82\x88\xa4\x77\xdf\x99\x2a\x9c\x94\xcb\x6a\xf8\xda\xab\xa4\x53\xf6\xf4\xe0\x2e\xf0\xbe\xfe\x2b\x1a\x07\xc4\xb2\x5e\x14\x1a\x83\xbd\xe6\xda\x3b\xf9\x64\xf8\x52\x82\x4a\xd7\x39\xaf\x39\xb3\xaf\xd1\x6b\x50\xc5\xc1\xc2\x2c\xea\xeb\x58\xa2\x07\x7d\x33\x19\xc8\x8c\x19\xba\x32\x76\x28\xc3\xbc\x96\x19\xdb\x3e\x45\x3d\xd6\xb2\x57\xb3\x4a\x2c\x2a\xd4\xe6\xd8\xd9\x8b\x1f\xa8\x57\xab\xd5\x50\xad\xb8\x5e\xc0\x93\x27\x5c\xea\x87\x8b\xd9\x62\xf4\x8f\xcb\xcb\x37\x4f\x65\x51\x8b\xea\xcd\xc9\x2d\x37\xb3\xf3\xe6\x68\x26\x78\xfd\xe6\x72\x26\x44\xed\xcb\xa0\x22\xea\x99\xb9\xaa\x19\xbe\x74\x98\xa9\xe1\xf2\x66\xf4\xe4\xf1\xe3\xbf\x8d\x76\x77\x47\x4f\xfe\x3a\x5a\x16\xb5\xe1\xee\xc4\xe0\x4e\xeb\x41\xa6\xf5\x00\x3b\x23\x55\x39\x8a\x35\x12\x00\x9f\xb9\x64\xff\xb8\xbc\x64\x30\xdc\x86\xa5\xb4\xd7\x30\x1e\xbc\xc6\x99\x6e\xbb\x32\xf0\xf6\x66\x67\xc9\xbe\x3c\x15\x26\x0f\xa8\xc4\x4c\x41\x94\x5d\xb1\x5c\xea\x6c\xa9\x4d\x47\x18\x1f\xab\x65\xcd\x66\xe6\x46\x1d\x69\xcc\xd1\x24\x55\x4b\x5d\xb3\x97\x17\xcf\x34\x9b\x2b\x74\xfd\xa5\xaa\x15\xaf\xf2\x21\xb8\xa7\xfb\xcb\x93\xdd\xdd\xaf\xbe\x7e\xbc\x6b\x05\x84\x52\x9f\x80\x52\xf7\x01\x8b\xc1\xb7\xbd\x18\x20\x00\xc2\x0f\x85\x04\x21\x3e\xbe\xd5\xf4\xa1\xc2\x9a\x88\x2a\x3d\x27\xb2\x21\x77\xed\xf1\x72\xb7\xaf\x87\x71\x5d\x24\x73\xf0\xee\xf2\x1f\x59\x78\xfe\x47\x2d\x42\xdb\xc4\x1a\x40\x60\x3f\xc0\xb9\x68\x90\xc3\x12\xc0\x3d\x1a\x0d\xc4\xf2\x3f\x67\xbd\xc5\x1d\x0a\xf4\x5e\x54\x02\x1f\xb3\xad\x21\x10\x44\x31\xbd\x9c\x98\x93\x75\x02\x3a\x9b\x58\xac\xbd\x3f\x34\x64\x52\xdb\x01\x48\xfb\xb0\xae\xe4\x7c\xdb\x2b\x0b\xac\x50\xdd\x52\xe6\x40\x0e\xd8\x01\x6a\xd5\xdb\xe7\x9f\x8f\x77\xc9\xfd\xf4\x68\x64\x4e\x41\x60\x07\x26\xaa\x9a\xf7\xc0\xf5\x05\x6a\x3f\x59\xb8\x48\xe1\xdc\xec\xd1\x19\xea\xc9\x70\xc6\x17\xb2\x46\x8a\x45\x13\x3d\xe6\xf9\x2b\x38\x84\x05\x56\x7c\xc6\xe7\xe2\x05\xc0\x29\x97\xec\x80\x8d\xfe\xcf\xf6\x77\x7b\x2b\x38\x7e\x7f\x9f\xab\xdf\x7e\x57\x3b\xaf\x0f\x07\xff\x1b\x64\xef\x28\xa4\xf1\x54\xcf\x56\x43\x80\x05\x80\xa9\xce\x99\x16\x73\x99\xa9\x02\x70\xa2\xa9\x3a\x4f\xee\x7e\x92\xf5\xec\xd2\x26\x08\x2a\xdd\xff\x59\x7f\xf6\xf1\x28\x30\x41\xab\xca\xa0\x75\xda\x01\x68\x34\x22\x1d\x02\x47\x33\xf6\xa9\xaa\xce\xf8\x59\xc3\x91\x6a\x23\xc1\x29\x9e\xf9\xeb\x46\xaa\x20\xd9\x8f\x70\x6c\x19\x46\xd9\x35\x25\xbe\x36\xc7\x6e\x6c\x03\x23\xda\x66\x07\x3a\xd7\x65\x33\x21\xad\xcb\x0e\x5c\x36\x7c\xf9\x49\x66\x89\x54\x75\x5b\xda\xa4\xa5\x43\x0e\xa4\x09\x74\x47\xdf\x27\x7a\xc8\x8e\x65\x0e\x34\x7c\x2e\x78\xc9\x3e\xd1\xdf\x01\x3a\x0b\x76\x0e\xd8\x53\xf9\x9b\x70\xd5\x61\xd3\x7d\xaf\x09\x9f\xe5\x6d\x34\x70\xdf\x27\x96\xd8\xff\xfc\x91\xa3\x7b\x84\xe3\x73\xdf\x6d\x24\xcd\xff\x1b\xb8\x70\x88\xd6\xe6\xde\xbf\xbd\x7b\xdf\xf0\x76\xec\xa7\xc4\x08\x13\x5f\x71\xcf\x40\x13\xf0\x4c\x63\xa4\x49\xff\x30\x1e\x6a\x42\x8e\x81\xb8\x07\x0f\x76\x94\x69\xd3\x70\x7f\x74\x19\x0f\xe9\x43\xc8\xcc\x90\x7d\x64\x28\xf6\x55\xb5\x66\x1f\x7d\xa2\xf7\xd8\x27\xfa\x23\xe7\x45\x25\x18\x7e\x64\x5c\x2b\x01\x3a\x71\xdb\xf7\x12\xa5\x3e\xeb\xf5\x1e\x3e\x0d\xa7\xfa\x8c\x9f\xbd\xcf\xf0\x07\x74\xea\x01\x83\x19\x53\xb5\xee\x45\x7b\x7d\xc6\xcf\xc0\x18\x08\x18\x2e\x04\x9b\x24\xd8\x7f\xb2\x5a\x00\x44\x27\xc3\xd8\xc7\x6b\x38\x1c\xb0\x07\x77\xdd\xd2\xd1\xf7\xec\x7f\x44\x86\x1f\x36\x08\x4d\xca\xbd\x61\x24\x6c\xd2\x3f\x67\x38\x5a\x27\xf8\x3b\x0c\x00\x6c\x78\xe0\x53\xcf\x27\xdb\xbd\x41\x6f\x87\x7d\xcb\x06\x0d\x84\x84\xc4\x01\xd4\x24\x9d\x2d\x90\xaf\x0d\xc7\xfb\xb0\x16\xba\x46\x0a\x1a\xd7\x93\xa2\xd7\x0f\xa9\x68\xf3\x1e\xc2\xea\x90\x8c\xc4\xf5\x75\xe4\xeb\x18\xb4\xd6\x93\x63\x27\x8f\x18\x4b\xaf\xa5\xd9\x95\xad\xfa\x9b\x2d\x80\xbd\xbb\xb1\xe6\x18\x43\x4d\xea\xa7\x20\x2a\x78\x40\xc1\x76\xf1\xdd\x57\xba\x7f\x23\xe8\xe0\x0d\x41\xa8\x1d\x07\xf9\xfb\xfb\xb9\x75\x8e\x81\x80\x50\xb9\xe0\x05\x5e\xee\xea\x59\x43\xe0\x4d\xb6\x95\x94\x0f\x6e\x2b\xa8\x20\xa3\x03\x95\x7b\x73\xc9\x94\xda\xa9\x1f\xd3\x9b\xb5\xf8\xaf\xa5\xbc\xe5\x05\x59\x90\xd6\xf6\xfa\x0f\xaf\x44\xee\xb2\x38\x15\x25\x08\x4b\x40\x04\x04\xaf\x5c\xd5\x00\xf4\xe4\xd1\xb6\x14\x6d\x1c\x6b\x36\x5e\x0f\x40\x6a\xa4\xed\x76\xd5\xd6\x9c\x58\x8b\x6c\x59\x19\x52\x02\x86\x67\xe0\xff\x03\x0c\xf7\xc0\xc8\xd7\x5c\x2b\xc9\x1a\x28\x00\x3a\x00\x0c\x2c\xeb\xad\x44\x91\xa5\x16\x07\xb9\x5c\xa6\xe6\x0b\x5e\x49\x6d\xce\x88\x53\xe8\x14\xa8\xe1\x2f\x49\x5e\x75\x7c\xf2\x0a\x55\xa5\x2e\x2f\x62\x7f\x3f\x11\x80\x22\x8c\xcf\xb1\xbf\xb8\x9b\x5e\x3c\x55\x15\xcc\x81\xde\x86\x41\x88\xdc\xfd\xe2\x8b\x44\x65\x0d\x66\xbd\x2d\x07\xda\x28\x81\x94\x53\x54\x41\xb8\x03\xda\xd2\x8e\x53\x92\x25\x0b\x0b\xb6\xeb\xf9\x11\x06\x36\xcf\x69\x97\x6f\xe7\x21\xc0\xe0\xae\x26\x4b\x3c\xb1\xd0\xd7\xae\x94\x08\xa4\x3c\x48\xd9\x32\x5e\xb2\xd7\xc6\xc6\x1d\xee\xc0\x77\x24\x20\x6f\x86\xbe\x81\x5b\x35\xff\x2c\x14\x8c\xd2\xe7\x07\xc1\xd0\x7c\x4e\xe2\x22\x5e\x07\x5c\xa7\xef\xa4\x39\xec\xf7\x7a\x9d\xc5\x24\x44\x2c\x2e\x6f\x3f\xe8\x79\x42\xd8\xe2\x5c\x9a\xb1\x78\xa2\xbc\x92\x44\x88\xd4\x65\xf5\x6c\x7c\xf5\xbf\xff\xee\xf0\xd3\xde\xc6\xaf\xc6\x3a\xb0\x5f\x31\xf3\xed\xd0\x12\x70\xf0\xd1\x76\x0a\x5e\xd1\x18\x3b\x9d\x78\x49\x5c\x20\x2c\x63\x1c\x24\xa8\xbd\x1e\xdb\x46\xe3\x6b\x52\x24\xea\x93\x89\x42\x85\x28\x50\x20\x76\x6d\x30\xa6\x56\xcc\x03\x0e\x39\xde\xe5\x1d\x17\x2d\x69\x49\x9e\xad\xe3\x8d\x11\x38\xe8\xa3\xbd\x80\x6f\x78\x98\xb6\x79\xe4\xb9\x55\x67\xdf\x6b\x35\xd2\xb0\x87\x2d\xff\x77\x5c\xfc\xdd\x88\x9f\xef\xb3\x54\xa3\x1d\x98\x16\xd0\x79\xea\x1f\x92\xec\xd6\xba\x0b\x37\xd9\xc6\x63\x20\xb1\x4b\x1f\xb2\xae\xe3\xf2\x13\xcb\x3b\xda\xd5\x78\x27\x03\x35\xed\x42\xf1\x3a\x38\x3b\x83\x68\xd6\xcb\xb4\x06\x07\x80\xbd\xa6\xa9\x51\xf7\x50\x40\xfe\xa1\x16\x75\x7b\x96\xc2\x1d\x98\x46\x2d\x81\xf8\xa0\x23\x76\x92\x5a\xe6\x49\x08\xc7\xf1\x54\xa1\xd1\x45\xdf\x79\x75\xab\xf9\xd4\xc9\x3f\xd4\x5c\x82\x78\x44\x56\x2c\x2b\x94\x39\x38\xf8\x14\x7c\x73\xdc\x08\xb1\x60\x1c\x55\x33\x0a\xa9\xc1\xe4\x73\x0b\x04\x9b\x26\x15\xe9\x9c\x0c\x40\x91\xca\x94\x37\xc4\x43\xd9\x14\x57\x8b\xfc\xc8\x14\x75\x65\xaa\xa1\x47\xdf\x4a\xf0\xe0\xad\x95\xeb\xf0\xe9\xb6\x8a\xde\x55\xfd\x87\x98\x8f\x45\xf0\xe8\x38\x0b\xd2\xc9\xf9\x34\xf8\x40\xef\x01\xf6\xf3\x46\xac\xa7\xa2\x8c\x1e\x15\x83\xe7\xd5\xb9\xa8\x83\x96\xc0\x2e\x0e\x9e\xce\xd4\xb2\x0a\x5f\x95\xeb\x8a\x67\x41\xde\x95\x6d\xaa\x55\xbc\xee\x18\xda\x8c\x97\x4e\xe7\xd8\x59\x64\x22\x33\x31\xe3\xda\x63\x1a\x2c\x96\xd5\xc2\x0c\x26\xd7\xa6\xb0\xeb\xe6\xd8\x5d\x33\x71\x07\xef\xee\xc0\x70\x5c\xcf\x45\xb9\x94\xb5\x98\x5f\xdb\xa9\x43\x4b\x1c\xd4\x6c\xae\x35\x4c\x1f\xb0\x27\x7c\x4a\x93\x71\xab\x64\x4e\x94\x8b\xe6\xc2\x19\xec\xc3\x48\x60\x79\xb6\x4b\xfd\xd6\xe4\xed\xec\x7b\x93\x1d\x34\xd4\x79\xf3\x86\x4c\x72\x3c\x95\x33\x6c\x4a\x55\xc3\xae\x46\xc4\xf8\x9a\x4f\x43\xdb\xf7\x80\xc4\x79\x80\xdd\x58\xa8\x18\x58\x2f\x90\x14\x1f\xa4\xe3\x80\x20\x7d\x70\x70\x4d\xb2\x5e\x62\x78\x26\x04\x60\x82\xd6\xe0\xa4\xed\x3f\xb4\xe6\x93\x71\x8f\x5f\xd7\x7c\xea\xae\xe0\x8f\x1a\x20\xe5\x09\x0f\x75\xef\x83\x83\xf1\x09\xf9\x92\x00\xed\x79\x07\x21\xc2\xa7\xa8\x11\xb7\xd4\x35\x2b\xc9\x3c\x1e\x66\xea\xda\x56\x7f\xcd\x4a\xd3\x03\x2d\x58\x27\x92\x06\x5e\xae\x60\x3c\x83\xbb\x55\x64\x8c\xdb\xb0\x41\xec\xe8\x40\x83\x31\xe9\x1a\x89\x74\x07\x8f\xac\x79\xb0\x16\xb5\xb5\xac\x0f\x7a\xa1\x2a\x76\xbd\xb1\xf6\xeb\xb6\x01\xf1\x23\x7b\x3f\xb9\x6f\xdc\x0f\x58\x0f\x4f\x58\x90\x6d\xd3\x3a\x84\x87\xd4\x0d\xf9\x3a\xf0\x4a\x36\x37\xd2\x61\x1f\x90\x76\x34\x78\x67\xb9\xfe\x17\x2e\xf8\x3d\x36\x1c\x0e\xdf\x5e\x0f\xd9\x8b\x42\x18\x82\x77\x2b\xb5\xac\x93\x2e\x85\x5d\xbd\x83\xa0\xa2\x81\x16\x26\xa6\x14\x15\x68\x43\x22\x7f\x63\xe1\x08\x2a\xd4\x86\x69\x0e\xd2\xdb\x2e\x2f\x09\xcb\xc5\xa2\x12\x5a\x93\xe2\xce\x49\x8e\xaf\x8e\x3f\x61\x22\xc3\x60\x11\x50\x53\x16\x27\x00\xab\xa9\xe4\xac\xb7\xbd\x46\x5f\x37\xf2\x22\x7e\x29\x09\x96\x74\x38\xf9\x73\x5e\xf2\x29\x5e\x66\xc0\xa6\x1e\xdd\x6e\xd0\x55\xa2\x54\x2b\xb6\x56\xcb\xca\xa2\x6f\xca\xb1\x2c\xcc\xcd\xa5\x56\x6c\xba\xe4\x15\x2f\x6b\x41\x2f\x76\x25\x2d\x2b\x28\x03\x0f\x18\x32\xa1\xa8\x0c\x4f\x66\x2f\x5a\xc5\xda\xab\x98\x9a\x6b\xdc\x72\x51\xc8\x0c\xa1\x5c\xec\xbb\x12\x94\xe0\x7c\xe6\xa0\x82\x12\xbc\x25\xa9\x92\x17\xb8\x9f\x9a\x62\x8a\x00\x08\x87\xf8\xaf\xd6\xb3\x4e\x1c\xeb\x17\x65\x7a\xa5\x01\x1e\x38\x24\x26\x04\x22\x6c\xbf\x21\x12\x73\xbe\x58\xc0\x33\x53\xa5\xe6\x31\x0f\x2a\x11\xd3\x08\xc5\x79\x7d\xf2\x5f\x4a\x8a\xab\xe8\x12\xf5\x8e\xcf\x01\x77\x0b\xb2\x1d\xfc\xeb\x5f\x73\x78\xbb\xbd\x40\x6d\x19\xbd\xe0\xe0\xaa\xe6\x73\xf6\x73\x4f\xcc\x7f\xee\xbd\x7d\x8b\x4f\x95\x88\xa2\xf1\x1f\x97\xff\x68\xf5\x3d\x58\x6d\x11\x60\x0a\xf1\x2c\x47\x76\x41\x18\x7a\x8e\x7c\x49\x40\xb9\x41\xc4\x80\xe1\xb1\x80\xc6\x8c\x8e\x17\xd1\xd0\x05\x20\x1a\x45\xa9\x23\x37\x29\x76\x0a\x9c\x0d\x23\x96\x1a\xa8\xcf\x5e\x01\x8a\x07\x3a\x52\x42\xbd\x50\x30\xdd\x31\x4b\x12\xcd\x3c\x1d\x7e\xc9\xd0\x66\xf9\xc9\x7a\x42\x9a\x4b\xb0\xd0\x91\x3a\xe0\x63\x6a\xa5\xd8\x7c\x99\xcd\x42\x43\x68\x9c\x21\x72\xd2\x83\x6a\xb7\xd3\x0a\x6d\xe5\x6c\x1b\x18\x2f\x40\x43\xb3\x96\xb7\x02\x41\xec\x90\x3d\x40\x85\x07\x67\x63\x87\x3e\xc0\xc4\x0a\x2d\x8b\xb5\xb7\xa2\xce\x54\x79\xab\x8a\x65\x6d\x71\xef\xc2\x87\xd9\x2f\xb2\x21\xb9\x85\x94\x6a\xb4\x12\x63\x0f\x3e\x32\x32\x8c\xd6\x28\x83\x29\x19\xfd\x05\xff\x0e\x6c\x7f\x07\x99\xaa\xc4\x20\x53\xa5\xe1\x12\xd0\xdd\x2c\x9a\x72\x02\xff\x01\x64\x65\x70\x37\x8f\x3d\x60\x82\x53\xcd\xc1\xa2\x52\x13\x59\xc4\x8e\x2f\x27\xaa\xac\x07\x13\x9e\x75\x84\x0e\x74\x95\x75\xc4\x2c\x2b\xd9\x11\x83\xe4\xad\x23\xd2\x0c\x5a\xec\x9d\x53\x6a\xb3\x5c\x07\xd3\x62\xbd\x68\x99\xa2\xba\x17\xaa\x2e\x0b\x54\x2b\xe2\x74\x5a\x8f\x66\x5b\xbe\xf0\xbb\x0b\x39\xd1\x9e\x09\x1d\x64\x08\xc8\xd3\xdb\x63\x8f\xfb\xf8\x64\x87\x46\xcc\x18\x8b\x3e\x1c\x35\xc4\xfa\x40\x02\xaf\xee\xc8\x33\x93\x79\x2e\xca\x8e\x48\x12\xa9\x76\xc4\xde\x88\x35\x6a\x87\x2f\xeb\x46\x9d\x05\x1f\x8b\x22\x0e\xaa\x54\x21\x72\x41\xfa\xf2\xaa\xb4\x91\x66\xd1\xcb\x7c\x2a\x6a\xe6\xfc\xc6\x68\x97\x87\x2f\x6b\x65\x81\xa6\xe2\xd2\xac\xa3\xf8\x28\x50\xdc\x2d\x78\x99\x37\x43\x67\x5c\x2f\xd4\x62\xb9\x68\xb4\x50\xdc\x36\x5b\x38\x57\x39\x6f\x06\x99\xcb\x7c\x21\x4b\x91\x08\x46\x0c\x08\x33\xb4\x71\xa4\xaa\xa4\x28\x71\x11\xc7\x11\x81\xc9\x7e\x23\xc2\x9c\x8b\xcd\x66\x57\x82\xe7\x86\x7b\x69\x86\xa2\x61\x6a\x1c\x6a\x31\x1e\x1b\xa1\xaa\xaa\xe3\x10\x20\xd2\x73\x7e\x97\x0a\x95\x65\x22\xb4\x54\xab\x44\x28\xb8\xb7\xf7\xf3\xf7\xcc\x10\x96\x0b\x31\x35\x54\x38\x35\x89\xb5\x9a\xcb\x2c\x2e\x66\xbc\xd4\x8d\x8e\x15\xf2\x56\x34\xbb\x5a\x88\x5b\x5e\x86\x35\x1d\x57\x7c\x3a\xe0\x65\x3e\x38\x36\xa7\x53\xa2\xae\xdc\xec\x1a\x00\xee\x88\xcb\x9a\x56\x7c\x3c\xf6\xe3\x03\xf0\x99\x05\x0a\x56\x67\x32\x59\x12\xcf\x0c\xbd\x34\x0b\x56\x94\x79\xd0\x0a\x5a\x7e\xaa\xc8\xd4\x32\x11\x0a\x67\x4a\x2b\x54\x2f\x78\xd9\x0c\x04\x18\x83\xe6\x56\x85\xfd\x31\x16\xf9\xb8\x31\x3a\xa2\xaa\x54\x35\x17\x5a\xf3\x69\x63\x94\x26\x85\x5a\xd5\x2a\xb1\xfb\x8a\x76\x29\x6a\x55\x36\x2a\x5c\x98\x9b\x17\xf8\x32\x8e\xb7\xea\x2a\xd1\xbb\x4a\xad\x12\xbd\xab\xd4\xaa\xdd\x3b\x2d\x6a\x2d\x7f\x83\x96\xc2\x8d\xd3\xbf\xcd\xc7\x64\xed\x2d\xe2\x1c\x54\x87\x17\xa7\x87\x88\x54\xc2\xd0\x12\x6e\xbb\xf7\x7f\xb6\x4d\x49\x3b\x83\xd7\x86\x31\x3a\xbc\xba\xba\x38\xfd\xfe\xe5\xd5\x09\x98\x8e\xbf\x39\xfa\xf1\xf0\x02\x3c\x3a\x7e\xf6\x71\x6f\x27\x28\xe2\x88\xcf\x45\x91\x2e\x07\x14\x1d\x1e\x50\x16\x14\x16\xcb\xa1\xd8\x81\x55\x46\x5c\x54\xaa\x56\x86\x27\x68\x48\xaa\xf6\x63\xb0\x80\x08\x28\x6d\x3b\x14\x92\x99\x53\x37\x85\x01\x5a\x19\x76\xa4\x9d\x73\x7f\x2b\x30\xf9\x33\x79\x3d\x32\x38\x7e\xef\x59\x27\x44\x49\x1f\x68\x20\x9e\x71\x4c\x50\xe9\x98\x13\xc3\x03\xc5\x1d\x18\x66\xbc\x28\xb6\x9b\x33\x64\xf3\xb8\x57\x62\x1f\x15\x3f\xc8\xb7\xce\x31\xaa\xc4\x4f\x4a\xe2\x75\xca\x1e\x74\x56\x18\x05\x0b\xa7\x17\xbf\x96\x7f\xb9\x33\xac\xd5\x33\xb5\xb2\x6f\xe9\x5e\xda\x4e\x4a\x32\x94\x39\x3e\x30\x9b\x72\x44\x5b\x8b\x61\x7a\x5d\x8d\x7b\x24\xcf\xb5\x2c\x4d\xe8\x5e\xb1\x84\x64\x83\xe0\xf9\x03\x95\x71\x48\xfd\xcb\x30\x63\xf8\xcc\x60\x38\xa8\x9b\x52\xad\x4a\x76\x7c\xfe\xdc\x96\x74\x7c\xfe\x3c\xe0\x8d\xc9\x0b\x2d\xfa\x06\x08\x1e\x29\x9b\x35\x78\x4c\xe1\xa8\x6b\x4d\xc1\x7c\xf3\x11\xf4\x94\x8a\x83\x1d\xe4\x5f\x6b\xae\x3f\xd1\xd7\xc3\x46\xa0\x66\x13\x55\x14\x6a\x85\xfa\x9f\xa4\x9f\x63\x9b\x61\xaf\xfc\xa0\xdc\xb9\x12\x95\xe1\x6b\x52\x4f\xa4\x2d\xd7\x3d\xac\x63\x6d\x34\x3c\x72\x34\x96\x88\x15\x36\x82\xa6\x60\x3c\x10\x3a\xd2\x33\xa5\xa6\xec\x33\xbd\x9c\x4e\x85\xae\xc9\xc7\x2c\x05\xb3\x5b\x51\x69\x7c\xd8\x61\x0d\xef\xcd\xc1\x28\xbe\xe7\xe8\x45\xfa\x1e\x26\x28\xd2\x9d\xf1\xc5\xff\x49\x83\x13\xef\xa2\x8e\x0d\x54\xd8\xbd\x91\x9f\x79\xf7\xd4\x5d\x7b\x46\xd7\xbc\xcc\x79\x95\x3f\x68\xd3\xc4\x25\x9b\xad\xd3\xa8\xeb\xff\xde\x0d\x14\xf7\x33\xb5\x83\x1e\x3a\x23\x01\xeb\xfe\x67\xaf\xd7\xb0\xd1\xdd\x0b\xf6\x65\x89\xa3\xf5\xee\x0b\x36\x2c\xff\xcf\x5c\xb1\x51\x4c\x78\x32\x99\x72\x69\xbf\x99\xd6\x93\xc8\x75\xbd\x68\xbb\x24\xa7\x19\xb6\x58\xad\xaf\x7f\x89\x9d\xcd\xdd\x88\xb5\x93\xa4\x85\x7b\x41\x6a\x90\xe5\xa2\x92\x6b\xe3\x10\x84\x6a\x6e\x44\xf8\x50\xf2\x88\xd2\x07\xef\xb0\x41\xbd\xc3\xc5\x52\xcf\xb6\x7d\x8e\x08\x20\x73\x89\xb3\x60\x12\xe2\xa3\x31\x58\x33\x07\x99\xe7\x7c\x91\xb4\x06\xf0\xda\xb2\xd7\xd6\x6d\x13\x38\x83\x43\x61\xc2\xce\xf0\x57\x25\xcb\xed\x5e\x9f\xf5\x3c\x00\x40\x54\x2e\x81\x23\x1e\x1c\x00\x3a\xe2\xbf\x92\x6a\x31\xa7\xc1\xfe\xc0\x1a\x3e\x41\x3f\xa3\x9f\xe8\x6f\xf1\x8d\x04\x44\x4d\x4f\x41\x9d\x00\xae\x8b\x7d\xa6\x85\x68\x08\x05\xa9\xda\x01\xdd\x4f\xd4\x02\x96\x52\xab\xe3\x88\x7c\xd4\xb9\x9e\x02\xdd\x8a\x54\x3f\xbe\x7d\x87\x5e\xe8\x7f\x67\x37\x36\xb1\x58\x52\x24\x96\x71\xf8\x88\x16\x08\xa4\x82\x64\xe9\x87\x84\x7b\x37\x89\x53\x22\x09\xfd\x83\x9c\x19\x9e\xd0\x2b\xb9\x76\xf2\xa2\x1f\xef\xfe\x7b\xb9\x51\x29\xf4\xc7\xbb\xe9\xc1\x02\x60\x29\x00\x42\x82\x47\xb1\x9e\x03\x9b\x82\x30\x87\x4d\x1c\x07\x93\xcf\xca\xd4\x50\x86\xaf\x0b\xae\xa1\xee\xbd\xc4\x6b\x17\x39\x7f\x5f\xcd\xf1\xb4\x85\x26\xc6\xd9\x53\x3d\xd7\xf2\x83\xa0\x39\xbe\x9a\xa6\xe7\x89\x84\x0e\x5b\x88\xf7\xae\x90\x6a\xdb\xf3\xc4\x9c\x94\x63\x01\x2d\xa4\xc5\x7e\xa4\x4a\x2d\x73\x51\x59\x88\x61\x8b\xd5\x8e\xbe\xb2\xd0\x49\x72\xe4\xaf\x02\x20\xbf\x15\xbb\x36\x2d\xbe\x26\x21\xb5\x62\x59\x21\x78\x13\xfd\x50\x55\xec\xda\x3d\x4a\x5d\x93\xf6\x7b\x80\x58\xec\x05\x7b\xf4\xb6\x93\xdc\x2f\x66\x81\xa5\x9f\x7e\xff\x9c\x8e\x7b\x44\x97\x07\xf4\x09\x4a\xfa\x00\x1d\x0b\x5e\xa8\x7f\x32\x43\x4e\xf6\x70\x01\x43\x40\x5a\x54\xf0\x14\x44\x78\x4d\x4e\x8a\xdb\x37\x5d\x43\xd8\x53\x65\x8a\xe0\x85\x56\x80\xe2\x0e\x6e\xc4\x6b\x82\x33\x9d\x23\x9e\x8e\xc7\x48\xcd\x38\xf5\xdc\xb0\x4d\xc4\x7c\xc2\xc9\xbe\x05\xee\xdc\x51\xd5\x0a\x7d\x50\x2c\x94\xd6\x72\x5c\x88\xcb\xe0\xc4\xb7\x42\xc4\xd1\x88\x10\x6e\xc8\x32\x7a\x8f\xf5\xf0\x47\xaf\xef\xc2\x00\x35\x40\xf8\xa8\x23\xfc\xee\xe1\xf5\x1e\x82\x06\x94\xa6\x97\x4c\x84\xb8\x9c\x37\x62\x4d\xb1\x5a\xff\xa7\x58\x53\x8c\x21\x0b\x10\x0c\xe2\x31\x08\x33\x77\x92\xc9\xb2\x28\x74\x56\x09\x40\x51\x87\x90\xa7\xcb\xa2\xb8\x84\x10\x4a\x05\x0d\x2a\xa8\x06\x6d\x3e\x34\xfd\x5e\x97\x19\x7c\xae\xcb\x0c\x43\x96\xb5\xf2\xa6\x11\x26\x6a\x59\xab\x23\x17\xe0\xd3\x90\x64\xd1\xa6\xb0\x82\x46\x1f\x0f\xc3\xec\xa2\xe1\xcb\xc5\x4e\x54\xb6\xd4\x14\xf7\xd4\xfc\x76\x31\x8b\x82\xaf\x29\xe2\x45\xc1\xd7\x2e\x5c\xf3\x5b\x5b\xd7\x25\xbf\xc5\x7a\x32\xbe\xa8\x97\x95\x09\xa6\x5f\x18\x2a\x8a\x62\x81\xeb\xca\xc4\x88\xa2\x78\x81\x5f\x2e\x96\x9e\x4d\x28\xf6\x12\xbf\x30\x76\xc6\x0b\x73\xbe\x42\x99\xf6\xb7\x8d\xa1\x89\x35\xbf\x2e\x69\xb6\x48\x92\x0a\xa1\x28\x53\xc5\x50\x07\x6a\x6f\x7f\x62\xb8\x84\xf1\x32\x7f\x70\x41\x64\x05\xd7\xda\xac\x03\xf8\x61\xd6\x1a\xa6\x33\x5f\x32\xb7\xe1\xa7\xc7\x3e\xd4\xac\xda\x76\x7a\x55\x98\xc1\x34\x7f\xdc\x37\x58\x68\x9b\xa0\xcb\x05\xa7\xda\xf1\x79\x0f\x42\x11\x1d\x21\x08\x15\xf4\xe8\xe7\x63\xed\x33\xa0\x4f\x75\x57\xcf\x45\xb9\xb4\x29\xee\xea\xe7\xa2\x5c\xba\xd8\xca\xb6\x81\x44\x73\x61\xb8\xd9\xba\x41\xdc\x33\xa9\x6d\xdd\xaa\xca\x31\x97\xf9\x81\x61\x95\xd2\x5a\x55\x72\x2a\xa1\xfd\xe6\xeb\x1c\xbe\x20\x36\x78\x5e\xd5\xa2\x86\xc7\x55\x7c\xa9\xed\x75\xbc\xf0\x52\xae\x9a\x43\x92\x9a\xdb\x6f\x51\x4b\x18\x48\xf3\xf3\x4a\xd2\x38\x5a\x77\xd3\x66\x46\xec\x4f\x48\x8f\xbf\xfd\x64\x53\xc0\x51\x30\xe7\x14\x44\x2e\x10\x62\xc7\xd5\x14\x2f\x2a\x8c\x10\x15\x86\x48\xf8\x96\xf6\x0b\x1f\x1a\x20\x88\xde\x1c\x20\x5c\xad\xca\x42\x71\x08\xa7\x9f\x18\x5e\xf1\xe9\x94\x66\xcc\xfd\x86\x18\x51\x66\x86\x0e\xef\xb1\x9e\x28\xb3\xab\xf5\x82\xfa\x36\x51\x95\xe9\x97\x19\xae\xa7\x0a\xeb\x9c\xa8\x6a\xbe\x07\x31\x73\xf7\x8d\x6e\xbc\x29\xf4\x39\x7c\xb8\x38\x47\x81\xcc\xc7\xa1\xa7\x42\xe6\xd3\xd7\x6a\xbe\x4e\x82\x9a\xcd\x77\xa9\x2c\x37\x43\x09\xce\x14\xb9\xf0\xf6\x69\x10\x23\x8f\xe2\xaf\xe0\x03\xe3\x0c\x4b\x35\x26\xfb\xff\x1e\x7c\x7d\x0f\x5f\x10\x3b\x13\x3c\x17\x95\x59\x44\xf4\x8b\x42\xf1\x81\xb4\x87\x3f\x30\x0c\xde\x6a\x4c\x18\x3e\xda\x60\xd8\x74\x06\x21\xd3\x19\x7e\x57\x62\x62\xbe\x2b\x31\x71\xdf\x05\x07\x52\x61\x7e\x3e\xe3\x44\x27\xcc\x28\x4e\x54\xd5\x18\x4f\xc3\x3e\x83\x3e\xf0\x1e\xa2\xcd\x9e\x98\xdf\x38\xfa\xe6\x73\x00\x71\xbd\x56\xa4\xcc\x60\x50\xcd\x1f\xfc\x36\xc3\x2f\x71\xd8\xc3\x25\x2e\xa3\x45\x0d\xac\xde\x5c\xe5\x62\x8f\xd8\xbe\xe7\x2a\x17\x14\x53\x8b\x69\x05\xe8\x00\x3d\xf7\x1b\x63\xcc\x38\x49\x1c\x22\x59\x8b\x39\xd6\x54\x8b\x39\x91\x18\xf3\xd3\x30\x15\x14\x6a\x38\x4f\x17\x8e\x23\x63\x7e\x5d\xd0\xe0\x98\xdf\x3a\x53\x30\xe9\xe6\xf7\xa5\xf9\xed\x62\x68\x35\x98\x9f\x6e\x29\xdc\x88\x35\xe8\x5e\x99\x66\xdc\x88\xf5\x0b\xf8\x6d\x63\x28\xc3\x8d\x58\xfb\xf4\xb2\x34\x2d\x34\x7f\xe0\x1b\x64\xf3\x7b\xac\x87\x2f\x64\x18\x02\x93\x53\xd8\x89\x21\x52\x53\x58\x12\x53\x28\xe8\x8d\xf9\x43\xdf\x2b\xf8\x5c\xc1\xd7\x9c\x97\x72\x22\x20\x87\xfd\x49\xe1\xd5\x54\x96\x2b\x04\x53\xe8\xe1\x17\x40\x2b\x04\xb1\x6e\x89\xe1\xe7\x8f\x7e\xa1\xcd\xf9\x1d\x04\xdf\xd9\x2f\xbc\xb1\x61\xd8\x33\xf8\x8d\x31\x22\x97\x86\x2e\xc1\x5f\x1f\x32\x45\x24\x12\x0c\x06\x58\x12\x8a\xa3\x8d\x39\xf7\x9b\x72\x0e\x44\x72\x4e\xc4\x71\x2e\x4b\x5f\x93\x2c\xc3\x9a\x9c\x9f\xcb\x9e\xfd\x49\xe1\x35\x50\x1c\xf8\x0b\x21\x74\xbe\x94\xf6\x68\x29\x55\x99\x41\x80\xf9\x4b\x21\xc1\x56\x2e\xe3\x6d\xac\x16\xb0\xc1\xcc\x1f\xfa\xae\xe5\x7c\x39\x87\x20\xf8\x05\xa1\x24\x3e\xdd\x63\x3d\xfa\x85\xa1\xfe\x81\xcf\xc4\x04\xcf\x7d\x14\xbb\xd6\xb2\x2c\x64\x29\x30\x76\xad\x4f\xe1\x0b\x63\x95\xae\x31\x1b\xfc\xc0\xb0\x4a\x10\xdd\xa4\x5f\x14\x0a\x4f\xe0\x10\x8a\x8f\xe1\x26\xb4\xe2\xb9\x54\x76\xdc\xe1\xc3\x8f\xbb\x7d\x4a\x34\x31\x82\xe7\xe7\x65\xb1\xa6\xf0\x89\xa8\x2a\x51\x2d\x54\x21\x33\x8c\xc5\x80\x17\x10\x40\x69\x0a\x88\x28\xe8\x0b\x9f\x1f\x21\x88\x5e\x22\x31\xfc\x56\x54\x9a\xc2\xf1\x27\x86\x2b\x68\xa8\xf9\x43\xdf\x2b\x0d\xdf\x2b\xed\xbe\xf1\x98\xaf\x10\xeb\x05\x42\x35\x2f\xf3\xb1\x32\x2b\x90\x7e\x61\x28\xed\x53\xed\xf6\x28\xfc\xca\x6d\x50\x4e\x61\x86\xb1\x47\xd6\xc8\xfd\xc6\x18\xc1\xe7\x85\xd0\xa6\x7e\xfb\x93\xc2\xf1\xf1\x74\xcf\xde\xe0\x6c\x49\x33\x8e\xf5\x99\xbf\x18\x82\xec\xa4\xb6\x4c\xa4\xf9\xa1\x29\x80\xca\xc2\xce\x68\xd7\x93\x85\x28\x0a\x38\x74\x21\x54\x14\x05\x1c\xb8\x18\x57\x19\xb6\x55\x57\x99\xfd\xca\x15\x05\x1c\x2b\x17\x46\xc4\x41\x57\x99\x23\xdc\xba\xca\x90\x8b\xd3\x55\x66\x99\x38\x8d\xa8\x35\x3d\xf8\x4b\x21\x62\x01\x01\x62\x41\xdf\x6b\x98\x0a\xf8\x8b\x21\xcb\xf9\x9c\x57\x66\xda\xe9\x17\x84\xd6\x7c\x2c\x11\x65\xa6\x57\xf3\x31\x00\xce\x50\x38\x1d\x6d\xb5\x3f\xd6\x6a\x59\x43\x99\xf0\x17\x43\x90\x00\xd6\x96\xfa\x2d\xb5\x98\x73\xd3\x8e\xa5\x16\xcf\x39\xb6\xc4\xf2\x17\xb7\x8e\xb1\xb0\x54\x6a\xe5\xe8\xd3\x8a\x4e\x05\xf8\x8b\x21\x15\x94\x63\xfe\xf4\x02\xb4\x1b\xc3\x5a\x8f\xd5\x12\x98\x74\xf3\x17\xd2\x9a\x4b\x47\x59\x3b\xea\x86\x9f\x01\x75\xa3\x90\x01\x9d\xac\xa9\x24\x3c\xcb\x96\x73\x00\xd0\xc7\x58\xfa\xc0\xb8\x3c\x27\x38\xa4\x9e\xfd\x89\xe1\x85\x9c\x02\xaa\xd7\x98\x6b\x41\xdb\xdc\x85\x7d\x4f\x61\xd4\x00\x1b\x3c\xb0\x69\x7b\x9d\x89\xe1\x3a\x54\x09\xcb\x3d\xc0\xe7\x85\xf0\xec\x03\x2f\x16\x33\x3e\x16\xb5\x84\x5b\x90\xfb\xc0\xb8\xf9\xa2\x90\xf5\x12\xc6\xd2\xfd\xc6\x98\x8a\x8f\x65\x46\xec\x13\x7e\x3c\xb5\x4c\x14\x7d\x83\x12\x4c\xaf\x1d\xcd\x75\x86\x4c\x38\xfe\xc0\x30\x7b\xfb\x25\xea\xeb\xbe\x1d\x87\xef\x42\x68\x8d\xb8\x6f\x77\x54\x9a\x8b\x11\x51\x0f\xba\x26\x5d\xe0\x17\xc6\xfe\x26\xe7\x4b\x58\x26\xf4\x0b\x42\xcd\xf0\x4d\x0c\x29\x12\x25\x50\x30\xf3\xfd\xd4\x7e\xbb\x14\x66\x2c\xf5\x4c\x4e\x6a\x4a\x61\xbe\x2f\xcd\x37\x76\xd7\x06\x0d\x20\x4d\x2f\x99\xc8\x84\x78\xca\x6b\xbe\x5e\x04\xd4\x77\x8c\xe4\x6a\x6c\x69\xd5\x58\x20\xf3\x0f\x7f\x31\x44\xc2\xa5\xd5\xfc\xc1\x6f\x68\x2d\x36\x31\xe3\x45\x46\x0b\xde\xfc\x74\x5c\x50\xc6\x17\x6e\x11\x67\x7c\x11\xae\xe0\x8c\x2f\x82\xe5\x1b\x47\x66\x85\x5c\xc0\x05\x4b\x2e\xdc\xf7\x82\xc3\xd0\x99\x9f\x2f\x38\x8d\x1d\x7c\x0d\x16\x80\x9e\xdf\x88\xb2\x59\x00\x21\x2d\x88\x7c\x69\xbe\x5d\x8a\x6a\x89\xb7\xad\x42\x2e\x2e\x96\x85\x08\x0a\x35\x31\xbd\x66\x14\x68\x70\xed\x91\x26\x97\x0f\x01\x00\xc1\x85\x42\x75\x0c\x1b\x7d\x1a\x06\x52\xc1\xa0\x00\x16\xa5\xee\x75\x27\x6f\x17\x3d\x01\xa4\x10\x9d\xcc\x82\x28\x22\xba\xb3\xa2\x01\x65\x4e\x57\x18\xe6\x86\x58\xbf\x50\xe0\x33\x5c\x29\x4d\x3d\xb6\x44\x12\x08\x70\x66\x75\x36\xc5\x85\x0d\x08\x8b\x71\xa9\x7a\xe9\x64\x74\x11\x46\xad\x2b\xda\x78\x14\x76\x09\x61\x6e\xf3\xd9\x94\xe6\x78\x68\x24\x34\x41\x3e\xdd\xb2\xd2\x38\x8b\xf0\x03\xc3\xcc\xda\xcf\x70\xe5\xc3\x2e\xa4\xad\x07\x37\x3e\xfc\xc5\x6b\x4e\xa5\xda\x9f\x18\x2e\x32\x51\x80\x5d\x21\xdc\x2b\xed\x07\xc5\x59\x3a\x43\xbf\x30\x54\x4e\x26\x4b\x2d\x32\x55\xea\x9a\x63\x2c\x86\x1c\x51\x08\xa5\xaa\x84\xbd\xe9\xb9\xdf\x14\xa3\x49\x3e\x43\xbf\x28\xf4\x56\x62\xb7\xe8\x17\x86\xaa\xb9\x2c\x79\x44\xcf\x6d\x50\x4c\xce\x6d\x68\x44\xcd\x93\x49\xf3\x25\x54\xb2\xa4\x0a\xcc\xc0\xe5\x38\x70\x39\xb4\x09\x9b\x23\xf2\xa9\x20\x82\x60\x7e\x3a\x82\x00\x1a\x51\xd4\x2d\xf7\x1b\x63\x4a\x73\x79\x1e\xf3\xec\xc6\xf0\x80\x70\xe5\xc0\xa0\xef\x5d\x10\x36\x15\x43\x07\x3e\x65\xaf\x2b\xa9\xa0\x52\xe8\xeb\x0e\xc5\xa4\x26\x88\x7e\x52\x38\xc2\x7f\x56\x02\x6d\x50\x74\xc0\x22\xda\xb8\x0b\x1b\x77\x11\xf2\x8c\x13\x59\x18\xd6\xd2\xfc\x71\xdf\x0e\x33\xaf\x17\x00\xd6\x61\xc3\x4d\xc0\x80\xe2\x7b\x89\x04\xe6\x9b\x08\x92\xf9\xe9\x09\x12\x64\xb4\x04\x29\x8a\xc2\x4d\x8d\xa1\x96\xe7\xc6\x9f\x15\xf0\x75\xf8\xfb\x82\x78\x3b\xfc\xb2\x14\x11\xbf\x3c\x3d\x04\x2c\xbd\xa0\xf9\x01\xb4\x1e\x35\xc3\x84\x44\x1d\x68\x26\x81\x00\x4b\x24\xe1\xe3\xc8\x51\x4a\xca\x8e\xa4\xb3\x1d\x0d\xc2\x48\x12\xa5\xb8\xdf\x14\x53\xd6\x13\x3e\x97\xc0\xfd\x9b\x8f\xa7\xf0\x41\x85\xa2\x4a\x2b\x04\xb4\xa3\xcd\x27\xb1\xbc\xe6\xe7\xa5\x65\x7b\x31\x1b\x29\x78\xc5\x51\x36\x0b\xcf\x7f\x5d\xea\x3a\x88\x3d\x84\x80\x46\xf6\x01\x26\xeb\xa5\xd3\x41\x59\x75\x25\xea\x6c\x66\x13\xe0\x57\x58\x0a\x85\x24\x12\x60\xf6\x75\xe1\x9a\xef\x18\x5f\x9b\x75\x5d\xf8\x0e\xb8\x48\xf3\x45\x7a\xf1\x14\xf7\x0a\xbf\x82\xac\x14\xdf\x4b\x24\x30\xdf\x2b\x7b\x66\x7b\xf0\xc8\x20\xf3\xca\x9d\xda\x8d\x68\x54\x39\x26\xe1\x11\xb7\x82\x23\x05\xe2\xad\x4a\x91\x78\xcb\x10\x8c\x09\x12\x8c\x09\xcc\x28\x4e\xd5\x74\x77\x8f\xf5\xa6\xbb\xf8\xfb\x89\xf9\xfd\x04\x7f\x17\xeb\xc5\x8c\x58\x32\xf8\xed\xd8\x31\xfc\x24\x55\xe6\x66\x24\x7c\x05\x7a\xac\xe6\xf7\x6f\xaa\xac\x79\x61\x93\x9e\xfb\xc8\x1f\x5d\x64\x58\x70\x90\x7b\xe0\xb3\xf7\xee\xcf\xdf\xac\xfb\x56\x54\xb5\xcc\x92\x35\xbf\xa2\xa8\xae\x7a\x6d\xd6\x54\xad\x51\x5e\x88\x44\xe9\x10\xfc\xb4\xe2\xa1\xa9\xb9\x48\x8b\xb2\xae\x2d\x40\x93\x49\x40\x61\x1e\xb4\x29\x4c\x69\xc9\x83\xfd\xf6\x04\x62\xc6\xcb\x29\x1e\xe7\xf4\x0b\x43\x4d\xe7\x79\x7e\x6b\xe6\x15\x7e\x1f\xe6\xb7\xff\xc0\xfe\xc0\xe7\x80\xe7\xb7\x83\xbb\x5e\x2b\x16\x87\x14\xa4\xca\x2e\x2b\x0a\x99\xa3\xdc\x98\x22\x28\x20\x4c\x23\x73\xa1\xa6\x15\x5f\xcc\xe0\xe6\x10\x7c\x61\xec\x9c\x4f\x45\xc8\x85\x40\x40\x83\x0b\x81\xb0\x98\x0b\x49\x24\x93\xe5\x13\x90\xe3\x3d\xa1\x4c\xc0\xb7\x11\x5f\x2c\x4b\x92\x77\xe1\x0f\x0a\xab\x45\x45\xcf\x53\xee\x37\xc4\xdc\x98\x75\x7e\x83\xeb\xfc\xc6\x14\x7a\x83\x65\xde\x7c\x61\x7e\x7f\x81\xbf\xbf\x34\xbf\xbf\xc4\xdf\xe6\x27\xfe\x12\x55\x29\x8a\x39\xaf\x2b\x79\x07\x22\x3a\xf3\xf9\x1c\x3e\x83\x78\x44\xfc\x22\x01\x14\x06\x99\x19\x0c\xe4\x50\x26\x10\xc7\x83\x7e\x51\xe8\x1a\x1c\x2f\x59\xa9\x20\xfc\xb6\x31\x7a\x01\xf7\x0f\x8c\xba\xc4\x0f\x1b\x57\xcb\xb9\x8d\xb9\x32\x3f\x21\x1c\x5b\xe0\x68\x28\x7e\x06\x94\xb1\x10\xb5\xe1\x37\xdd\x13\x10\x7e\x87\x8f\x40\x14\x34\xa0\x34\xbd\x64\xa2\xc2\x90\x1e\x59\x4e\xed\x91\x63\xbf\x83\x53\xc7\x06\xf9\x83\xa7\x9d\x08\xac\xe9\xa1\x98\x52\xf0\x72\x0a\x04\xd7\x86\x1d\xa9\x52\x1c\x9a\x30\x4c\xa9\x70\x1f\xc3\x5f\x08\x99\xf3\xea\x06\x16\x19\x0a\x21\x6f\x44\x75\x62\x19\x15\xfc\x1c\x08\xe4\x50\xe2\x48\xfc\x0a\xc5\x97\x37\xa2\x8a\xc4\x97\x26\x00\x65\xc3\xf8\xfb\xb9\x8c\x8b\x9d\xcb\xa0\x58\x1b\x89\x5f\x56\x96\x82\x5f\x97\x4e\xa2\x62\xb3\xa2\x8c\x25\x91\x00\xbf\x2d\x05\xc0\x2f\xbf\xff\xf1\x3b\x10\xc8\xde\x88\x2a\x14\xc8\xea\x1b\x08\xd6\x37\xee\x9b\xf8\x6f\x5f\xa0\xbe\x21\xe3\xb9\xb0\x54\x7d\x13\x26\x08\x63\xea\x19\xa2\x2c\xc2\x98\x87\x9f\x18\x8f\xfc\xa5\x13\xb0\x94\xcb\xb9\xca\x6a\x7e\x0b\xcb\xb1\x5c\xce\xcf\xf1\x03\xe2\x2c\xb4\x6f\x0f\x7f\x60\x98\xe3\x75\x54\xc0\xc3\x28\x00\x2c\x81\xe5\x64\x7f\x62\x38\x49\x2f\xbc\xd8\x02\x09\x35\x04\x49\xcb\x4c\x06\xc4\xdb\x45\x78\x1e\xd7\x3d\xa9\x29\xff\x9a\xa6\x6e\x45\x35\x41\x89\xb8\xfd\xe9\xc2\xcd\x46\x5b\x28\xc4\xd9\xa5\x78\x13\xf4\x82\x82\x70\x52\x6d\xe8\xc0\xa6\xec\x75\x25\xb5\x81\xf5\x4c\x66\x37\x25\x0a\x12\x6d\xd8\x95\x0d\x6b\x14\xea\xd2\xf6\x3a\x13\x2f\xb8\x2c\x6b\x3b\x3c\xf0\x71\xee\xc6\x08\xbf\x07\x38\x68\xed\xe8\x05\x2f\x95\x16\xbb\x10\x01\xbf\x6c\x26\xf3\x31\xd8\xed\x35\x22\xcc\x85\xde\x11\x37\xf3\x11\x90\x35\x12\x63\x37\x96\x1c\x85\xb6\x56\x1d\x85\x87\xc7\x22\x05\xc5\xa7\x22\x05\x36\x8a\x0b\xca\x51\x40\xde\xc1\x95\x06\x24\xc0\xef\x13\xf8\xa6\xce\x60\xd0\x00\xd3\xf4\x92\x89\x1c\xe9\x5d\x78\xba\x8b\x3f\x79\x7d\xe7\x82\x0f\xeb\x7f\x44\x31\xeb\x20\xe6\x9f\x51\xcc\x6f\x41\xcc\xff\xc6\x18\xc0\x85\x43\x41\xfc\x84\x4e\x0c\xeb\xed\x01\x44\x6e\x18\x05\xdf\x87\xe6\x3b\x4e\xa1\x17\x22\xab\x01\xc8\x27\x4c\x07\xa1\x17\x26\x94\x52\x03\xd1\xbc\x15\x6e\xb8\x6c\x40\x30\x60\xa4\xd1\x88\xc2\x7f\xf8\x09\xe1\x66\xed\xe0\x9a\x30\x7c\x07\xe8\x25\xe0\x0f\x0c\x13\xc0\x37\x56\x62\xf2\x0f\xfb\x4d\xd2\xfe\x7f\xd2\x37\x9d\xd6\xd2\x3e\xaf\xbb\x90\x53\xff\xcc\xee\x03\x07\x98\xae\xd7\x91\xb0\x12\x0b\xc1\xeb\x0c\x81\xe7\x7b\xf8\x05\x30\xf4\x41\x2c\xde\x83\xf1\xf7\x31\xdd\x86\xed\xcd\xd1\x5c\x1b\x11\x6b\x37\x78\x66\x38\x71\x81\x51\xda\x89\xe0\xf5\x12\x6f\x6b\x36\xe8\x29\x05\x51\x3a\x0b\x8d\xd0\xb3\x3f\x6d\x38\x91\x79\xfa\x65\x43\x97\x05\x05\xda\x97\x73\xfc\xa9\x5d\xa0\x7d\xb8\xa8\x51\x68\x81\x3f\x30\x0c\x06\x19\x17\x07\xc8\xd5\x49\xa4\xae\x33\x8e\xa2\x77\xf3\x17\x43\x08\x0b\x09\x9e\x1c\xf0\x27\x85\xd3\x33\x44\xf8\x04\x11\xf2\x60\x10\xd0\xe0\xc1\x20\x2c\xe6\xc1\x12\xc9\x74\x41\xaf\x27\x85\x7b\x3d\x71\xfc\x83\x0e\x98\x02\xb3\x28\x97\x05\xaf\x02\x01\x8b\x0d\x8a\x24\x2c\x36\x30\x90\x0b\xd8\xa0\x93\x50\x3e\xa0\x17\xd4\xa7\x85\xeb\xd4\xa2\x12\x3c\x77\x6f\x81\xf8\x19\x3c\xd3\xc3\x74\xb8\x13\x07\xbe\xce\xfd\xb1\xa3\xeb\x3c\x17\xb7\xd2\x9e\x11\xba\xce\x8f\xed\x27\xc5\x8b\xf9\x0c\x1f\x3e\xe6\x33\x17\x72\x4b\x21\xb7\x14\x22\xeb\x6c\x56\xcb\x02\x5f\x6f\xe0\xeb\xca\x7c\x51\xac\x5a\x58\x96\xc8\xfc\x0e\xd8\x21\xf3\xe9\x59\xa1\x38\xd2\x7c\xf9\x33\x31\x00\xd1\x0f\xb2\x06\xb7\xff\x66\x02\x5d\x57\xf2\x46\xd4\xb3\x4a\x2d\xa7\xb3\xe0\xd4\x8a\xc2\xe3\xa3\x2b\x8a\x8a\xce\xaf\xee\x4c\x51\x4c\x78\x92\x45\x11\x8d\xe3\x2c\xae\x28\x3a\xd3\x36\x64\x43\xe5\xbc\x3d\x67\x30\xdd\x77\x10\xff\x18\xa6\x6e\x44\x10\x96\x7b\xd7\x02\xbd\x86\xb3\x01\xd7\x08\x75\x23\x06\x2e\x5d\xaf\x23\xa1\x2f\x2e\x58\x43\xb1\x8f\x82\x56\x81\x14\xdc\x95\x14\x03\xcd\xd1\x9d\xf1\x85\x4b\xf4\x0c\xbf\xa3\xc2\x28\x4d\x2f\x99\xc8\x17\xf3\xab\x92\x65\x94\xc4\x04\xb4\x0a\x82\xc0\x74\x32\x0c\x9a\x07\xbe\x15\x7a\x4d\x77\x0b\x51\x71\x3e\x65\xaf\x2b\x29\x06\x5a\xfe\x34\xf0\xc5\x10\x15\x84\x4f\x74\x89\x04\xf8\x1d\x6e\x80\xc0\xc7\x43\x54\x44\xb4\x09\x9a\x89\x2c\x4a\x44\x43\xa7\x8b\x34\x1c\xe1\xad\x72\x13\x8c\x44\x54\xc6\x6c\x9d\x23\x78\x5e\x3b\xf7\x8f\x36\x2a\xce\x57\x4d\x78\x26\x1c\xb9\xc6\xcf\x4b\x4f\xb5\xd7\x86\x84\x14\xbc\x9c\x2e\x39\xa8\xd7\x61\xc0\x33\x0a\x80\x34\xd0\x18\xc4\x42\xc0\x17\x54\x8b\x90\x4a\xb1\xd5\x54\xd4\x77\xee\x15\xf5\x1f\x41\xe8\xda\x85\xe2\xa1\x0c\x3a\xcf\x65\x36\x03\x3a\x64\x3e\x0e\xe1\x03\x87\xd2\x7c\x0f\x30\xb6\xd7\x8e\x36\x9f\xb9\xc8\x54\x65\xa9\xa4\x09\x38\x76\x01\x41\x11\x3e\x55\x2f\x9d\xcc\x04\x39\x9e\xd1\x7c\x04\x3c\xa3\xf9\x0c\x0f\x27\xf3\xdd\x38\x9b\xa0\x92\xe8\x68\x6a\x27\xaa\x0d\x53\x54\x23\x0f\x14\x72\x94\x75\xc4\x4a\xf6\x10\x8b\xa1\xb7\xe7\x7e\x99\xd0\xa5\x61\x7e\x97\xc8\xde\x2e\x9f\x98\xdf\x28\x0f\x58\x9a\x0a\x1a\xfc\xbf\x0b\x8b\xa9\xa8\x0b\x8e\x28\x68\x3a\xb1\x0b\x0d\x29\xa7\x0b\x6c\x50\x4d\x5f\x70\x44\x31\x3b\x92\x2f\x4b\x99\xe1\x8d\x8c\x7e\x85\xa1\x63\x99\x4b\x1f\xf3\xbd\xcc\xa5\xad\x02\x02\x06\x26\xbe\x97\x48\x40\xdf\x15\x47\x75\x50\xfa\xbc\xe0\x56\x23\xd4\x15\x00\x29\x7a\xa9\x24\xc0\x8c\x1a\x26\x64\x8e\xb1\xb5\x7e\x21\xaa\x93\xb9\xcb\x5e\xeb\xc1\xc2\xb0\xe7\xf3\x5e\x3b\x7e\x59\x7a\x1b\x79\x88\x0d\x4c\xe6\xfb\xa8\x09\x10\x3c\x5d\xdf\x1e\xc6\x6f\xd7\xbd\xdb\x41\xf0\x9a\x9d\x48\xe0\xb6\xd9\xad\xdf\x61\xb7\x22\xab\x55\x85\x26\xe0\x26\x06\x3e\x4f\xd0\x22\x1c\x0b\x85\x90\x81\x33\x12\x6f\x27\x21\x1b\x2d\x88\x82\x5f\x36\xb4\xe6\xf9\xed\x1a\x83\xeb\xc3\xfc\xf6\x9f\xb6\xc0\xaa\x06\x29\xdd\xba\xd7\x8c\x33\x1f\x5e\x46\x67\xbe\x22\x11\x1d\xe4\x0c\x25\x74\xcd\x14\x3e\xff\x3a\x8a\xfd\x67\x3b\xff\xba\x97\x48\x71\xeb\x65\x8e\xb7\x3f\x06\x42\xc7\xde\xed\xc0\xca\x20\x9b\x51\xb7\xb1\x50\xf0\xf6\xb4\x21\x15\xec\xdd\x0e\x42\x41\x61\x2a\xc9\xad\x14\x2b\x7c\x0e\x37\xbf\xbe\xa7\x17\x71\xf3\xdb\xe9\x90\x98\x8f\x40\x3d\xf2\x56\x5a\x88\x1d\x88\xb3\x1f\x18\xd7\x90\x63\xdc\x3e\x6f\x0a\x32\x7a\xb7\x83\x48\xb8\x91\x4c\x74\xab\x32\x3e\x36\x31\xe6\x2f\x84\xc0\x49\xa6\xad\xd6\x09\xae\x9e\x95\xaa\x72\xcf\x16\x9b\xaf\x48\xa8\x66\x02\x42\x91\x5a\x33\xc1\xaa\x02\xa1\x97\xd5\x5d\xc1\x2f\xf7\x78\x67\x03\x06\x20\x72\x49\x24\xb8\x33\xc4\xec\x0e\x89\xd9\x9d\x21\x66\x77\x48\xcc\xcc\x50\xe2\x20\xde\x65\x33\x5e\x96\xa2\xc0\x7d\x04\x27\xc3\xdd\x11\x06\x5d\x52\x10\xa6\x73\xa2\xb1\xbb\x50\x69\xe0\x2e\x50\x19\x08\x23\xee\x0a\x59\xde\xf0\xac\x5e\xe2\x95\x06\x3e\x0f\xf1\x93\x32\x02\x14\x1d\xa5\xe8\xa5\x92\x60\x11\x55\x46\x0a\x5f\x18\x8f\x9f\x51\x11\x14\x94\x4a\x02\x01\x24\x85\x87\xdf\x3f\x5a\x15\x56\xca\x0c\x2a\xad\xad\x48\xf8\x0a\xab\xbd\x68\xd4\x19\x55\x78\x11\xd5\xa6\x67\x20\x39\x82\xdf\x97\x33\x12\x1d\x51\x36\x13\xd7\x6b\x45\xc2\x97\xd5\x7b\x82\x8f\x2b\xa7\xfc\x44\x19\x51\x1b\xaa\x1d\x8d\x59\xf1\x11\x1c\xa3\x9c\x62\x33\x65\x34\xdf\xad\xc8\xbb\x79\x81\xb0\x83\xbd\xbb\x79\xf1\x3d\xd7\x36\xcb\xbc\xd8\x33\xe1\xbd\x46\xc4\xdd\xbc\x20\x9d\xb1\xbb\x79\xe1\x74\xc6\x20\x39\x68\x98\x36\x22\xee\xe6\x05\x5c\xb3\xe1\xaf\x4f\x0a\x90\x40\x94\xf6\x12\x7e\xbb\xc4\xd8\x56\xca\xf1\x0f\xf3\xe1\xb2\x95\x7a\x0f\x62\x7b\xed\xe8\xbb\x39\x98\x2c\x88\x66\x91\x6b\xb3\xe6\xd7\xb8\xe6\xd7\x66\xcd\xaf\x71\xcd\x1b\x4a\x80\x04\x60\xdd\x5e\xf3\xeb\xd4\x9a\xff\x6d\x8f\xf5\x7e\xc3\x5f\x4a\xcd\x79\x99\xa3\x2a\x9e\xf9\x38\x2c\xf3\x17\xbc\xec\x01\x14\x45\xb7\x71\xdc\x93\xff\x1e\xe3\xb8\x7f\x45\xbe\x2a\x42\xcb\xb8\xc8\xd7\x45\x6c\x8e\x0d\x91\xf7\xa2\x50\x60\xce\x93\x57\x27\x67\x57\x08\x6e\x71\x71\xf2\xc3\xc9\x3f\xc0\xf1\x87\x2a\xad\xab\x0f\x4c\x04\x46\xe5\x50\xea\x7b\x82\x6e\x04\xc5\x00\xc2\x43\x57\x59\x0f\x06\xde\xc0\x02\x9b\xa6\xbb\x50\xac\x37\xa5\x8d\xd0\x2c\x08\x75\x3b\x44\x92\x6d\x8e\x5a\x1a\xd8\xe2\xe3\xdd\x0d\xd0\x16\x1f\xef\xa6\xbd\x4d\x44\xc6\xce\xae\xc2\x4a\x4c\xa5\x46\xd1\x5e\x69\x5a\x86\x8e\xd0\xd3\x9e\x2d\x1e\x56\xe2\xa2\x58\x4e\x65\x19\xd9\xfa\x82\x43\x9c\xe6\xb4\x26\x01\xdf\xd1\x0e\xbf\x54\x0c\xbd\x13\x53\x59\x08\xe0\x38\x16\xa2\x74\x0e\x9f\xfa\x6c\x25\xd8\xdc\x9c\x00\x04\x1d\xc8\x09\xd4\x9b\x89\xc0\x3b\xa9\x2f\xf5\x18\x50\xc9\x40\x93\x15\xcb\x26\x6f\xec\x52\x03\x04\xd6\xf0\x9e\x8e\xbd\x33\x56\x41\x73\x5c\xd9\x81\xb3\x6b\xbb\x68\x44\x3d\x00\xba\xa0\x33\xeb\xeb\x38\xed\x2f\x31\xaa\x41\x6a\x82\xdb\x58\xd9\x5d\xa6\xcb\x38\x05\x33\x5e\xe6\x05\xb8\xef\x21\x34\x99\x07\xd8\xea\x37\xeb\x4c\xd8\x23\x3e\xd9\x60\xb1\x6f\x57\xf0\xfd\x36\xfb\xae\x97\xf1\x30\x78\x64\x3c\x55\x5a\xc0\x64\xb3\x04\x1b\xa9\x9c\x15\xf7\x93\xfb\x01\x0b\x36\x0e\xc6\x69\xed\x70\xac\xe5\xb4\x54\x95\xc8\x37\x41\x8f\x7c\xc8\xbe\x8f\x46\xec\x19\x39\x7e\x6e\x40\x2a\xcc\x94\xba\x71\xd4\xa8\x89\xa4\xe2\x57\x07\x92\xd1\x60\x2f\xb2\xdf\x7f\x8f\xa8\x62\x72\x9b\x3e\x7c\x2a\x08\xb5\xb1\x04\xa5\x1e\x89\x4e\xb9\x36\xa4\x50\xcb\x10\xec\xb9\x39\x19\x70\x9a\xb1\xa5\x06\x54\x72\xb0\x59\x04\x83\x52\x55\x7e\x5f\x2c\xab\xd0\x99\x34\xc5\x9e\x96\x14\x0f\x5f\xe7\xcb\x9a\xcc\x71\x0f\x8b\x02\x4f\x46\x4b\x0a\xd0\xa7\xae\xf3\x9e\x57\x2b\x36\x5e\x8e\xc7\x80\xf9\xa8\x3a\x0b\xc3\xb2\xac\x3b\xde\x52\x88\x5c\xe4\x23\xef\x91\x67\xbc\xc6\x3a\x86\xbd\x3f\x6f\xa1\xe3\xd8\x39\x03\xa5\x0d\x43\x77\x0c\x4a\x84\x88\x25\x0b\xee\xde\xfd\x12\x96\x1e\x8a\x95\xf0\x4d\x16\xa2\x42\x40\xe2\x00\xa4\xa0\x09\x9b\xda\x67\x85\x52\x37\xcb\x85\xf3\xed\x0c\xa1\x60\x0a\xbd\x01\x8e\xf6\x4f\x1e\x09\x73\x62\x6f\x18\x04\xc0\x07\x35\x69\xae\x63\x2f\x82\x0e\xde\x72\xa2\x2a\x36\x59\xd6\xcb\x0a\x61\x90\x65\x49\x53\x88\xc3\xf0\x82\x6b\x73\x6a\xe4\xf2\x56\xe6\x4b\x5e\x60\x51\x83\xeb\xd0\x72\xda\x3a\xf7\xf9\xf3\xe7\x5c\x37\x9c\xce\x59\x20\x00\x1f\xe2\x4c\xc7\x5b\xae\xeb\x1e\x05\x30\xa0\x9b\x76\x5b\x26\xa4\x19\x15\x8e\xd6\xed\xe0\xcd\xc2\x9a\xac\x07\xd8\x2d\x12\x48\xa0\x47\xcf\xb1\xa0\xb1\x7d\x73\xb2\xd6\x16\x5a\xd6\xba\x18\x00\x7f\x81\x04\xaf\xea\x0c\xd6\x6d\xcb\xfe\xfc\x83\x62\xa3\x0b\xbf\xb4\x53\x96\xce\x71\x39\xe3\x67\xb1\x97\x1e\x8f\xe5\xf3\x07\xc6\xe3\xcf\x3f\x34\x10\x6c\xe6\xc2\x2e\xfa\x83\xe0\xc3\x94\x89\xc4\xde\x03\x23\xfd\x27\x1c\x80\x6d\xbc\xa0\x39\xaf\xb3\x19\x42\x16\xa0\x71\xbf\xf7\x07\x41\xc8\x48\x8e\xc6\x64\xaa\x9c\xc8\xa9\x47\x0d\x4a\x9a\xf8\xdf\xc3\x06\xf9\x09\x49\x60\x41\x25\x0b\x6c\x32\x47\xb1\xf3\x90\x20\x3f\xec\x9f\x08\xb7\xa8\x9b\x2b\x0a\xc0\x9d\x1e\xc4\x0b\x6d\xc6\x2d\x8a\xa6\xf5\xc1\x13\x9b\x98\x5a\xe7\xa2\x21\xf2\x06\xe4\xe6\xf8\xd3\x4f\x99\x43\x6a\x6a\xb2\x97\x01\xef\x6d\xb9\x9d\xf6\x64\x03\x07\xee\x71\xa0\xec\x8c\x93\x03\x57\x5e\xf7\x34\xf8\xfa\xac\x67\x62\xed\x8b\xb3\x4c\x91\xc9\x92\x33\x5e\xae\x57\x7c\x8d\xbe\x7f\x88\x57\xf7\xbe\x77\x36\x9e\xf8\xb9\x12\x78\x30\x55\x22\x53\xd3\x52\xfe\x26\xfc\x9e\xb3\x00\x1c\x1c\x66\x86\x00\x7a\x9d\xe7\x57\xd8\x6c\x01\x10\x75\xb1\x66\x2b\x5e\x5a\xbc\x61\xbe\x58\x08\xc0\x6b\x82\xe2\x4c\x7e\xae\x19\x67\x08\xf6\x4b\xc7\xbb\x07\x00\x03\xf3\x37\x93\x93\xeb\x60\x24\xa0\x11\x96\xec\x63\x1e\xaa\x9b\x67\x99\xcc\xcd\xc1\x68\x6a\xb5\xae\xa8\x6b\x44\xa0\xe6\x6c\xc1\xcd\x75\xdc\xc3\x77\xf4\xc9\x6f\x2e\x35\x99\xd2\xd9\x76\xd9\x7e\x05\x0b\x2b\x9e\xc6\x7f\x07\xe5\x74\x8e\x56\x3f\xfd\x94\x3d\xc2\x75\xe2\x80\x48\x0f\x01\x55\xe3\x7b\x4c\xe1\xbd\x09\xef\xc4\x5e\x83\x6e\x63\xbf\x6a\x1b\x68\x6d\x70\x02\x95\xaa\x1c\x50\xd5\x4d\x08\xb1\x9f\xcb\x9f\xcb\x70\x0a\x60\xae\x6b\x05\x82\x4d\x41\x93\x4e\x43\xda\x87\x29\xf1\x07\x1a\x4d\xe1\x1e\x8e\xff\x27\xfa\xe0\xa3\x4f\xf4\x47\x4c\x55\xec\x13\x7d\xf0\x2f\x74\xd0\x57\x2b\x44\x5b\xda\xde\x79\x8b\x13\x41\x67\x56\xd9\xbc\xd1\x3f\x88\x88\x37\x00\x66\xfe\x07\xf5\xbd\x59\x13\x38\xad\xaa\x95\xa1\xf2\xb9\x74\xfb\x0c\xfc\x9b\xc8\x1a\xf7\xbb\x29\xc8\x45\x3b\x36\xe5\x6d\x9f\x60\xe3\x4d\x6b\xe2\x24\xdf\xd1\x42\xdb\xf3\x6c\xcc\xdb\xd8\x75\xe2\x7d\x83\x1f\xfe\xbf\x79\x22\x3e\xd8\x55\xec\x0c\x28\xa0\x73\x84\x6d\x6f\x5f\x39\x91\xcb\x3e\xcb\x15\x90\x31\x1b\x61\xf3\x81\x2f\x6a\xb3\xbf\xd0\xc9\x86\x63\x47\x01\x85\xc9\x6d\x40\x4f\xce\xef\xbf\x88\x8d\x46\xec\x27\x5e\x95\x88\xa9\xc4\x59\x83\xaa\xa3\xdf\x8c\x31\xcf\xa1\x52\x8f\x28\x87\x7b\xf8\x52\xd4\x6e\x1b\x87\xde\xe1\x76\xba\x31\x08\x37\x0f\x55\x84\x42\xb8\x95\x68\x76\xec\x5a\xee\xa5\x47\x37\x73\x48\xbb\x81\x04\x2d\x85\xb8\x17\x00\xa2\x59\xc4\xbd\x3f\x04\xb8\xe7\x50\xbe\x6e\xc4\x9a\x2a\x7b\x7d\x23\xd6\xbf\x6c\x84\xdf\x0b\x1b\xf1\xce\xf0\x7b\x51\xe6\x0f\x01\xbf\x87\xad\x8c\x8a\x7d\x17\xf4\x3d\xef\x0f\x2c\x09\xc1\x77\x82\x8e\x55\xe8\xc8\x0a\x4f\x2b\x3a\xa9\x68\x67\x9b\xfc\x11\xa9\x01\x1f\x32\x86\xe1\xf6\xec\x2f\xf8\x3b\x32\xb4\xc2\x1d\xc3\x0f\xc3\xc6\x43\xbf\x1f\x6e\x51\x0f\xc6\x62\xc6\x6f\xa5\xaa\xde\x0d\x22\xcf\x91\x82\x80\x73\x4a\x8d\xda\x03\xb0\xfe\xc8\x23\xac\x1d\xb4\x36\xe2\x5f\x3c\x6a\x00\x98\xf5\x47\xc7\x0d\x0a\xf9\x77\x8f\x5c\xfc\x30\x91\x00\xcd\x7b\xf2\x61\x11\x06\x5b\x14\xa2\x0d\x31\x38\x1a\xb1\xab\xf3\xe3\xf3\x3d\xb2\xa4\x64\x72\xbe\x50\x55\xad\x59\x21\x6f\x04\xd3\x6a\x2e\x06\x0b\x9e\xdd\xf0\xa9\x18\xe9\x2a\x1b\x7d\x06\x12\xa0\xb1\xe1\xe0\x9e\xca\x3b\x36\x17\x88\x44\x36\x15\xb5\x7d\x36\x91\x63\x51\x9d\xaf\x4a\x51\x19\x66\x0b\x84\xfa\xed\xa7\x15\x93\x66\xd8\x95\x67\x3f\x55\x62\x63\x3c\x1f\x5c\x6a\x94\x6f\x3f\x02\x54\xa4\xc5\xe8\x14\x84\x3c\xae\x62\x90\xe8\x72\xc6\xf3\xb5\xe1\x2b\x3d\xe8\xa2\x89\x3d\x3e\x3c\xfb\xe1\xe4\xe2\xfc\xe5\xe5\xb3\x7f\xbe\xb9\x3c\xb9\x7a\x73\x7a\x76\x76\x72\xf1\x06\x3d\x02\x75\xc3\x3b\x61\xc9\x97\x2f\x5f\xbc\xb8\x38\xb9\xbc\x7c\x73\x74\x7e\x76\x75\x72\x76\xf5\xe6\xe4\xf8\xf4\xea\xf0\xfb\x67\x27\x6f\x7e\x3a\xbc\x38\x3b\x3d\xfb\xc1\x14\x71\x8f\xf2\x53\xa3\xa4\x1f\xff\x79\x7c\x71\x78\x75\x7a\x7e\x66\x8b\x40\x57\x58\x9d\x3a\x50\x98\xfd\xf0\xe5\xd5\xf9\xd3\xf3\xa3\x97\x97\x00\xca\xed\xc0\xcd\x30\xf2\xe8\xc7\xd3\x67\xc7\x17\x27\x67\xe0\x3d\xce\xe2\x82\x51\xb5\x57\xff\x7c\x76\x02\xe5\x83\x2d\xdd\xbe\x73\xc0\x15\xbb\xdf\xb2\xa1\xf0\x92\x71\xf9\xe2\xf0\xc8\xe4\x39\xb3\x5e\x48\xf4\xd0\xa4\xdb\xdf\xda\xb2\xb3\x7d\x49\x0f\x71\x0d\xf7\xf9\x43\xc3\x26\x5c\xc0\xc2\xd6\xdb\x3d\x78\x3f\x32\x8b\x3d\xc8\xb0\x79\xa5\x34\xbc\xd1\xd3\x86\x08\xfc\xbe\x01\x0b\x70\x34\xab\xd4\x1c\x7d\xa6\xcc\x04\xba\x92\x9a\xf3\x5f\x55\xc5\xc6\x95\x5a\x69\x51\xa1\xef\xd2\x99\x44\xd7\x38\xdf\xd4\x72\x2e\xbe\x1d\xb2\xef\x97\x70\xc5\x51\x13\xf6\x1f\xcb\x62\x6d\xcb\x7a\xf2\x78\xf7\x6f\x48\xa5\x6b\x51\xe6\x80\x11\x08\xae\x07\x64\xcd\x72\xa4\x47\x2b\x99\x0b\x54\x86\x65\x4b\xcd\xa7\x02\x9c\xd9\x45\x77\x2f\x5b\xd6\x67\xe0\x23\xe6\x33\x68\x3c\x90\x4b\xac\x1a\xa4\xb1\x86\x30\x80\x5f\xd5\x65\xe9\x6e\x7b\x20\x4c\xa5\xce\x90\xef\x18\x5b\x94\xac\x99\x56\xaa\xb4\x57\xcd\x3e\x22\x81\xf3\x72\x6d\x2e\x77\xe1\xc3\x11\x22\x2f\x9a\xdb\x1b\x5c\x43\xf1\xc2\x89\x08\x64\xd6\xcb\x9c\x75\x38\x53\xa1\xd3\x9b\x95\xaa\x6e\x40\x52\xaa\x8a\xf5\x44\x16\x05\x52\xf6\x6f\x72\xc9\x0b\x35\xfd\x76\x08\x82\xf7\x85\x50\x8b\x82\x84\x85\xf4\xdc\x84\xf1\xe4\xdb\x2d\xf4\x4d\xdd\xa6\x8b\xa7\xe5\xb1\xb8\x15\x85\x5a\x80\xeb\xb2\x8d\x5c\x0e\xbb\x0f\xb6\x75\xbf\x23\x51\x03\xb0\xb4\x33\xd9\x93\x56\x32\x6c\x39\x21\x2e\x9a\xfb\x2a\x8c\xa0\x13\x93\x6b\x76\x74\x01\xa3\x7d\x74\xf1\xec\xa9\x99\xff\x67\x4f\x87\x98\xfe\xb4\x46\x54\xc8\x8c\x97\x0c\xd8\x95\x9f\x97\x8f\x1f\x3f\x7e\x6c\xd6\x82\x62\x3f\x2f\x9f\x3e\x7d\x7a\x6c\x58\x79\x99\x8b\x40\xd0\x40\x79\x9d\x67\x9e\xd5\x6a\xb8\xfa\x62\xa8\xaa\xe9\xe8\xea\x62\x64\x36\xd5\x57\x23\x53\x7f\x61\x08\xf7\x54\xc0\x36\xfb\xcb\xa2\x12\x8b\x4a\x65\x02\x9d\xd7\xd4\x33\x31\x00\x14\x2e\xb0\xaa\xe5\xf3\x2d\xfb\x9c\xb8\x12\xb8\x0e\x38\x9b\x4b\x0d\x52\xab\xbe\x59\x08\xee\xf5\x10\x16\x14\xac\x31\xb3\x2b\xa9\x21\x3f\x09\x5c\x53\xe8\xeb\x6f\x01\xb2\xae\xe5\x22\x7a\x34\x04\x48\x70\xb3\x85\x26\xb2\x42\x89\x04\x71\x06\x43\x9a\xf1\xb3\xf3\x8b\xe7\x87\xcf\x4e\xff\xf7\xc9\x9b\xb3\x93\x9f\x9e\x9d\x9e\x9d\x5c\xfa\x17\xed\x9f\xab\x9f\xcb\xef\x46\xd3\xfd\x76\xd2\x97\xcf\x9e\xbd\x39\x3c\x3b\x7e\x73\x71\xf2\xe2\xd9\xe1\xd1\xc9\x73\x43\x4c\x7d\x36\x18\xca\xdf\x71\x14\x4d\x76\xca\xef\xa6\xe5\x39\xaf\x6e\x96\x8b\xa7\xaa\xba\x12\x77\xf5\x79\xe5\x38\xf9\x68\x79\xcd\x21\x51\xc8\x0b\x63\x88\x63\x47\xe9\xb2\x8f\xa1\x91\xdb\x28\xf6\x9d\x0d\xdd\x63\x3d\xc3\x6c\xe0\xd7\x7e\xc8\x9e\x86\x85\x39\xb7\xf6\x5d\x83\xd1\x67\xbd\x9f\xcb\xde\x4e\x2a\x5d\xe7\x48\x80\x07\xfc\xb6\xe7\x77\xea\xf5\xb1\x9c\x4c\x44\x25\xca\x2c\xee\x34\xca\x9c\x4c\x82\x3e\xcb\x0a\x30\x81\x15\x77\x75\xf8\xfa\xde\x71\x84\x76\x39\x7e\xb7\x63\xe7\x5f\x8e\x8e\x5c\xb1\xe0\x4b\xf6\x9e\x29\xd9\x0e\x5a\xb1\x9f\x28\xed\xd2\x35\xf8\x41\xa5\xf9\xfe\x05\xd7\x94\x74\x69\x07\x07\xc9\x46\x6f\xea\x68\x37\x7b\xd1\xed\xe1\x1e\x2a\x23\x4d\x68\x53\x00\x6c\x16\xd8\x80\x43\x86\xcd\xd9\x63\x20\x6a\xc0\x26\xe0\x47\xaf\x9f\x1c\x82\x7e\xba\xc5\xc9\x45\x60\xc8\x5a\xc7\x22\x30\xe4\x8d\x9c\xbd\x42\xd1\xe4\x6f\x19\x67\xe2\x55\x53\x1d\xe3\x03\x2d\x08\xeb\x28\xf7\xa1\x2b\x22\x74\x41\x9b\x5a\x12\x0f\x2f\x2f\xe8\xe4\x86\x45\xf1\xca\xc3\x49\xa7\x5a\xfe\xa1\x97\x85\x99\x1e\x14\x6a\x75\xac\x89\x4f\xb4\x5b\x11\x70\x25\xf1\x93\xf6\x1f\x97\xe7\x67\x43\xa4\x44\x72\xb2\x4e\x77\x64\x67\x43\xb2\xb0\x57\xe9\xb5\x73\x72\x57\x57\xdc\xfb\x53\x8a\x16\x4f\x04\x0a\xa5\xff\xe0\x42\x79\xc8\xc8\xc1\xe4\x13\xfc\xf1\x6b\x7a\xbf\x88\x1b\x31\x9c\xa8\xea\x84\x67\xb3\x40\x5e\x10\xbf\x64\x40\x76\x14\x47\xd0\xbb\x0e\x34\x61\x27\x3d\x35\xd0\xfb\xc8\xe5\x8a\xbd\x9f\x6a\x37\x37\x24\x81\xd6\xe9\xf1\xa3\xfe\x80\x75\xe3\x33\xa9\x6b\x51\x82\xa3\x72\xdf\xbc\xb6\x72\x48\x41\xc9\xc2\x01\x2d\x5c\xd6\x03\xba\xa3\x74\x3f\xc8\x9d\xd0\x03\x1b\xae\x29\x97\xb3\x56\xe6\x70\xe7\xae\xea\xbe\xd3\x10\x98\xaa\x9a\x5d\x43\xee\xb6\xd8\xf4\xdf\x23\xcc\x6c\x0f\xca\x43\x42\x36\xdf\x11\x1e\x0a\x65\xfe\x5e\xc3\x67\xdd\xc0\xab\x09\x66\x03\x7d\xbe\x8e\xae\x10\x33\x61\x4b\x7e\x78\xbb\x43\x26\xf4\x05\xaf\xb4\xf0\xb0\xe4\x86\xf1\x84\xab\x86\xac\xd9\x18\x9c\x41\x2a\x4f\xbc\x7c\x32\x92\x9e\x68\x85\x72\x59\x59\x63\x61\x86\x33\x1d\x0b\x9c\x6b\xc3\xd4\x67\x6a\xbe\xe0\x95\xd4\xe8\xd9\x24\x22\xb9\x74\x03\x0c\x4e\x10\x78\xb8\xe9\x03\xfe\x6c\xe0\x2c\xf3\x27\xc1\x32\xff\x52\x96\x55\x02\x04\xbf\x9c\x69\xb1\xe0\x15\xaf\x85\xd3\x93\x60\x70\xc1\xa8\x15\xe3\xb7\x4a\xe6\x36\x7b\x65\x78\x57\x59\x83\xbb\x7e\xd3\x62\x7a\x83\xb2\x0e\x27\xcd\x9e\xa8\x67\x62\xcd\xc4\x9d\xd4\x35\xde\xd1\x80\x0f\x1d\x57\x82\xdf\x68\x5b\xca\x4c\xad\xd8\x37\xa5\x42\xb8\xac\x6f\xcd\xc5\x6f\x2c\x4c\x69\xa8\xb7\x94\x0f\xd9\xa5\x32\xdc\xf0\x92\x46\x12\x7c\x61\xdb\x76\x39\xe7\x98\x97\x02\x63\x73\xa9\xb3\xa5\xd6\xe0\x9b\xb4\x74\x8c\x39\xb9\xcb\xcc\xd4\x7c\x34\xe1\x99\x18\x2b\x75\x83\xf2\xa4\xd1\x62\x59\x14\xa3\xdd\xdd\xdd\xaf\xfe\x36\x74\xc4\xab\x16\xba\x26\xb7\xd0\xec\x80\xde\xbc\x86\xce\x67\xe7\xcb\x8b\x53\xd8\xdf\x8d\xfb\xf4\x77\x36\xa1\x5a\x95\xa2\x3a\xb6\xed\xc3\x31\xa5\xd2\x68\x1a\x86\xce\x6b\xe9\xde\x03\x32\x9d\x5d\x6e\x27\x9a\xd0\x67\x8d\xb2\x70\xf5\x05\x4d\x1f\x4a\xef\x19\x99\xe1\x05\x3f\x94\x62\xa7\x12\x7a\xb1\xb6\x5b\x39\x88\x84\x8f\x34\x51\x96\xd3\x2b\xb5\x5d\x29\x55\x1f\xa1\x73\x5f\x51\x9d\x58\x01\x60\x73\x03\x05\x8e\x65\xb4\xed\xd7\x79\xf5\xb4\xe2\x53\x1a\xd6\x54\x31\xc3\x52\xe5\x00\x7a\x06\x03\x7c\x7c\x7e\xf4\x12\xb8\xe7\xb3\xf3\xe3\x13\xd0\xf0\x7a\x78\x96\xa7\x17\x87\x3f\xb8\xbc\xf6\xba\x92\xab\x0c\xf4\x06\x12\xed\xf9\x2e\x59\x38\xdb\x4b\xd7\x19\xcd\xd6\x3e\xa1\x07\x8b\xd2\x0c\x4e\x8b\x8e\xe4\x2a\xdb\x89\x87\x74\xfa\xff\xb1\xf7\xed\xef\x6d\xdb\xc8\xa2\x3f\xaf\xff\x0a\x24\x9b\x46\x52\x22\x53\xb1\xf3\x6a\xe5\xb8\x39\x6e\xec\x6c\x7d\xda\xd8\x3e\xb1\xd3\xdc\xbd\x3e\xbe\x0e\x44\x42\x12\x6b\x8a\x50\x09\xca\x8e\x36\xf6\xff\x7e\x3f\xcc\xe0\x49\x82\xb2\x1c\xbb\xdd\xdd\x73\xba\xfb\x7d\x8d\x4c\x82\x03\x60\x30\x18\x0c\xe6\xc9\xca\x7d\x17\xc0\xdb\x82\x4f\xde\xbb\xdd\x04\x51\x8c\x08\x55\xab\x77\x53\xe4\xdd\x6a\x7a\x4a\x31\x69\x54\x0c\x82\xa3\xae\x02\xf2\x0c\x2b\x67\x34\xbc\x9b\xd2\x33\x26\x88\x60\xb9\x00\x56\xf1\xeb\x4c\x94\xf2\xcb\x09\x4d\xa1\x03\x42\x01\x4f\xa4\xa0\xa0\x50\x2e\xc7\x34\x57\x2c\x87\x50\xf2\xa9\x2c\xe8\xf4\x07\xf0\x5f\xc3\x63\x18\x8d\x87\x8c\xc6\x63\xd0\x4a\x41\x67\x98\x7d\x40\x29\x8b\x4a\x3e\xdd\x1a\xf0\x42\x25\x21\x55\xb1\xe4\x25\x9f\xbe\xa1\xf9\x01\xe6\x9a\x8b\x69\x6e\x72\xcd\xd9\x17\x47\x18\x36\x6b\xdf\xab\x38\x5a\xdd\x6c\x7b\x86\xcb\xf7\x66\xac\x02\xb8\x12\xf5\x20\x1e\x9b\xf8\xac\x92\x4f\x77\x26\xd3\x32\xc5\x84\x6b\xf8\xcb\xbc\xc8\xe3\x62\x3e\xc5\xd4\xb6\x4c\xff\xb6\x2f\x13\xf5\x22\x71\x1e\x16\x05\x78\xd8\x43\xbd\x49\xfd\xf0\x67\x4e\x13\x96\x6c\x63\x06\xfa\x0c\xfe\x30\x79\xe8\xcd\xeb\x77\xac\xa4\x89\xdb\x64\xa2\x1e\xb8\xcd\x0e\x55\xcc\xbd\x6c\x61\xa3\xee\x4b\x3e\x3d\xa0\x33\x08\x71\x98\xca\x7f\xcd\x43\xc4\x9d\x8b\x38\xf9\x08\x83\x73\xa6\xf8\xcb\xbc\x28\xf8\xa8\xc0\x78\xbc\xa9\xfa\xa9\x5f\xbd\xa7\x25\x33\x18\x94\x47\x89\x8f\xbd\x43\xc6\xce\x74\xd4\xfd\x99\xc5\x84\x7c\xac\x62\x46\xf1\x97\x79\x51\xd2\x0c\x93\xdc\x0b\xfc\x65\x5e\xcc\xc4\x14\x33\xd9\x08\xfc\xa5\x5f\x1c\xa5\x13\xf6\x61\xaa\xd2\x4d\x97\xe9\x84\xcd\xa6\x26\xdd\x74\xc9\xa7\xbf\xf0\x6c\x36\xb1\x23\x3c\x87\x3f\xfd\x31\x7e\xa4\x10\x29\xd4\x27\xad\x0b\xfc\x55\x89\x65\x90\x14\xfb\x26\x4b\xe3\xb3\xfd\x7c\x8f\xe7\x90\x9b\x12\xeb\x97\x6a\x6e\x2f\x37\x64\x47\x57\x00\x79\xc7\x07\x69\xc6\xc8\x21\x1d\xd2\x22\xb5\xce\x21\xa0\x85\x41\xd7\x9c\x6c\xae\x1c\x38\xe5\xc5\xce\x7a\x7c\xf3\x1c\x01\xe4\x3c\xc7\xf4\x98\xd8\x89\x39\x65\xbb\xaa\x68\xf4\x84\xd1\x5c\x90\x84\x65\x6c\x84\xe6\x5b\x00\xa2\xe5\x17\xa1\xcc\xb8\x08\x4b\xf6\x1a\x41\x99\xea\x0b\x5e\x9c\x51\x48\x3f\xa8\xbc\xc2\xe4\xf1\x3b\x1b\x91\x34\x3f\xe7\xd9\x39\x13\x52\xac\xa6\xf1\xd8\x2b\x00\x03\x90\x11\x90\x11\xbc\x38\x5a\x73\x30\xd8\x0c\xca\xb1\x3b\xba\x31\xa5\x1a\xfb\x6d\x96\x16\x67\x62\x22\xdf\xf1\x62\xd4\x1b\x64\x7c\xd4\xa3\x45\x3c\x4e\xcf\x99\xe8\xad\x3f\x59\x7b\xd2\x7b\xf2\x5d\x0f\x80\x9f\xc2\xdc\x4f\x13\x96\x81\xce\x0c\x21\xfd\xe7\x4c\x94\x50\x5c\x27\x2d\x95\x62\x14\x15\xc4\x38\x51\xe3\xde\xa4\xc5\xa6\x0b\x5d\xd5\x1b\x64\x9b\x92\xab\xea\xf3\x84\xe6\x73\x84\x27\xa5\x80\x33\xc6\xb0\xc2\x3a\x2f\x48\x5a\x46\x64\x8f\x97\x58\x27\x26\x05\x0d\x5c\xce\x94\x5c\x0d\x85\x6e\xa4\x28\x3d\x66\x38\x51\x33\xf1\x54\xac\x28\x59\x68\xc2\xcf\xb1\x5a\xb7\x31\xe3\xec\xe7\xd9\x5c\xe2\x1d\xb0\xaa\x9d\xee\x74\x85\x5d\x45\x0a\x82\x4c\xe8\x7c\xc0\x5e\x43\x86\x74\x89\x19\x35\x9f\x9a\xf6\xdd\x3f\x44\x04\x2b\x77\x51\xf4\xda\xde\x7f\xe7\x6a\x57\x29\x58\xec\x27\xf6\x60\x0e\x1e\xd7\x39\xfb\x5c\x82\xa5\xb0\x5b\x2f\xe1\x7e\x44\x47\x48\xb5\xc6\x16\x2d\x71\xfb\x13\xda\xa3\xcd\x87\xee\xbd\xe7\x9e\x79\x5a\x75\x87\x53\x5f\x3a\x56\xf8\x98\xe7\x65\x9a\xfb\x05\x29\x41\x76\x55\x20\x20\xa0\x45\x41\x3b\x56\x9f\x9f\x58\x2d\x80\x1e\x8a\x3c\xe3\xc0\xf8\x61\x21\x5b\xa7\x14\x50\x17\x28\x20\xae\xa3\x0e\x2c\xcd\xdb\x82\x31\x25\x6d\xcb\x36\xaa\xae\x3e\x96\xe8\x77\x89\x47\x8a\xdb\x54\x88\xd9\x04\x4c\xc5\x17\x40\x4a\x03\xe6\xc3\x9a\xcc\x4a\x0a\x1e\xc7\x1f\xb5\xb6\x36\x93\xf2\xfd\x5c\x59\x38\xec\x96\xd2\xbe\x85\x54\x98\xf8\x0e\xf9\x3f\x15\x5c\x34\x84\x21\xd9\x21\x5b\x97\xb9\xab\x8a\xbb\x07\xd6\x50\x4e\xc1\x97\x9c\x7c\x42\x96\x06\x69\x14\xc5\x0f\xf3\xdd\xed\x4f\xa8\x97\x90\x83\x92\x44\xfd\x09\xa6\x86\x4c\x50\x7c\xd2\xfd\x0a\x86\xaa\x84\xb7\xbc\xc0\x2f\xdb\x2e\xb9\xe8\x31\x58\xcb\xa9\x7f\x1f\xab\xae\x41\xb3\xf5\xcd\x77\x7d\x94\x70\x7f\x2c\x27\x99\xb3\xbc\xe4\xb5\xf9\x79\x2c\x3f\x38\x71\xaf\x9a\xae\xdb\xa3\xf9\xb6\x16\x05\x42\x70\x1f\x28\xf1\xb5\x36\x11\xf9\x51\xa7\xd1\xd5\xd0\x9d\x86\x36\xb1\xf9\x9e\x5e\xea\x0e\x68\x49\x33\xe8\x82\x0c\xab\xb2\x25\xef\x45\xc6\x4f\x5d\xdd\x8a\x20\x58\x5f\x99\x0d\x2d\xeb\x90\x0f\xc1\xc5\x56\xee\xef\x88\xec\xe6\x64\x77\x67\x6d\x4d\x7f\xeb\x02\x75\x3f\x07\x6f\xc1\x57\xba\x26\xdb\xf7\xa8\xe7\x07\x23\x00\x52\x96\xad\x7b\x80\xb7\xca\xd2\x05\x24\xe4\x1d\xeb\x22\x2d\xc7\x8a\x0e\x1d\x38\xb3\xbc\x4c\xc1\x41\x70\x4c\x05\x1a\x9d\x20\xa6\x01\x5c\x1f\x13\x32\xc8\xe4\x95\x37\x21\x74\x44\xd3\x3c\x72\x41\x5e\x7f\xb5\x4a\x85\x98\x31\xd1\x7b\xf1\xf2\xe9\xda\x5f\xe1\x77\xcc\x27\x90\x7d\x7d\xfd\xf9\xb3\x6f\x5f\x3e\x7b\xfe\xfc\xa9\x81\x07\xc5\x85\x69\x7e\xc8\x40\x3f\xaa\xa7\xbc\x49\x4a\x3a\xaa\xd6\xa2\xbb\xbc\xb4\xeb\x01\xaf\x5a\x1b\xde\xbe\xaf\x81\xf1\x19\x80\xf0\xde\x3d\x58\x0b\x12\x7f\x68\x03\x5a\xba\x09\x52\x85\x72\xc8\xae\x90\x66\x73\x57\x60\x85\xa8\xf5\xb7\x90\x46\xaf\x37\x56\x5f\x5e\x92\xe0\x07\x01\x9b\xb4\xe7\x41\xbb\xc7\xf9\x74\x51\xcf\xc6\x3a\xed\x7d\xf5\x91\x19\x2b\x23\x58\x34\x95\xce\x20\x9b\x6b\x61\x00\xf5\xc2\x24\x99\x81\x3a\x43\xae\x7e\xea\x46\xb7\x7d\x64\x64\x90\xd1\xf8\x0c\x2e\x05\xa9\x52\x31\xb8\x97\x83\xaa\x43\x36\x34\x54\xa6\x54\xc9\xa1\x99\xd2\x6f\xa5\x39\x39\x3c\x7c\x1f\x55\x67\xb0\x64\x94\x60\xfd\x88\x72\x8f\x8f\x10\xcf\x01\x22\x28\x66\xcc\x09\x51\xf0\x49\x52\x9f\xd2\x2d\x9f\xf6\x16\x28\x1b\xf5\x28\x16\xd2\x20\x59\xfa\x36\xae\xe7\xd4\x48\x57\xcd\x87\x7e\xe5\x88\xb0\x5a\x79\x97\x7a\x9b\x46\xeb\xf4\xd0\x8c\x40\x6d\xdf\x6c\x15\x8c\xc0\x09\xa6\xaa\x09\x42\x30\x08\x54\x0a\x54\x67\x00\x84\x4b\x2a\x57\x6e\xeb\x7e\x64\xe8\xc1\x82\xf3\xbc\x8e\xa5\x14\xe5\x86\x55\xa5\x39\x4d\xce\x59\x21\xf7\xa0\x13\x49\xe4\x46\x30\x90\xa3\x71\x2a\x2c\xb4\x81\x7c\x28\xc8\x0c\x4e\xed\x2c\xcd\x19\x2a\x50\x8d\xee\x49\x3b\x1e\x19\x13\x2d\xe8\x9a\x90\xe1\xa3\x6f\x78\xe0\xa8\x35\xe4\xb6\x14\x1a\x6b\xe5\x4f\xf1\xa4\xf7\x45\x3d\x17\x12\xbe\x3f\xa0\x73\x79\xc9\xeb\x92\x0b\x1a\x58\xdf\x45\xa2\x9e\x11\x59\x7f\x04\xa5\x5b\x18\x80\x2b\x12\xa6\x64\x93\x3c\xd9\x20\x29\x79\xe5\xf7\xad\x3c\xcf\xe4\x9b\xc7\x9b\x36\x46\xd1\x95\x22\x37\xfd\x2f\x8e\xd3\x93\x0d\xaf\x8d\x36\x14\x55\x5a\x91\xc7\x64\x6d\x39\x41\x70\xb1\x84\x63\xba\xb8\x4b\x11\xa7\x51\x0c\x31\xbd\x2d\xee\xa3\x2e\x7f\x2c\x3c\x3d\x16\x40\x5d\xbc\xb3\x75\xbf\xbf\xa8\x90\xaa\x90\x3c\xb5\xe4\xd6\xaf\x8e\x21\xe0\x1c\x2e\x2f\xa3\x25\x5b\x0a\xde\xe2\x23\xb0\x61\xb8\x4b\xef\xaf\x06\x7c\xfd\xef\xe3\x48\xfe\x8a\x2c\x42\x5a\x23\x2b\xf2\x94\xd3\xbe\xa3\x4e\xd3\x6d\x13\x55\xd5\xc6\xdf\xcc\xb0\x9c\x8f\xda\xe6\x20\x05\x3d\x73\x49\x32\x6a\x6e\x89\xab\x72\xcc\xd2\xc2\xc6\x9d\x28\xc8\x5d\xc2\x3e\xc7\x6c\x5a\xea\xba\xaa\x92\x75\x78\x5a\x4b\xf4\x45\xfb\x1a\x35\xab\x55\x16\x6b\x94\xe8\x27\xbe\x05\xa0\x3a\x29\xed\xbc\x7c\x8d\x9d\x40\x13\x6f\x05\xd8\x48\xf2\x0f\xb9\xf6\x22\x8d\x0d\x48\x40\x6d\x47\xfb\x90\xde\x00\xb8\x7b\xf1\x0a\xf1\x03\xd0\x82\x2f\xf2\x62\xdd\xb0\xb4\x77\x88\xd4\x8e\xfe\x43\x90\x89\x60\xc0\x08\x6a\x98\x06\x73\xbd\x30\x66\x5c\xaf\xad\x06\xe5\x82\xe9\x68\x0e\x0b\x0c\xca\x28\x91\x57\x87\xbf\xfc\xed\x7b\xb9\xaf\x5e\x4d\xb6\x8e\x7e\xfc\xbe\x1a\x46\x15\x1c\xf1\xe5\x25\x31\x35\x9f\xc1\x6c\xe7\xa5\x30\xe8\x92\xd6\xab\x6f\x04\xe9\x81\xf5\x08\x75\x43\xb3\xe9\x54\x05\x3b\x49\x1c\x45\x64\x2b\xbb\xa0\x73\x01\x56\x24\x1b\x07\x05\xd6\x11\xa0\x3d\x15\x73\xa5\xa3\x9f\xd1\xfe\xd7\x09\xc6\x13\xa9\x6b\x20\x98\xab\x5a\x9e\x58\xf3\x46\x11\xb3\xdc\x97\xf0\x9a\x9c\xa7\x94\x38\x86\x18\xc1\x49\x5a\x0a\x72\x7f\x4a\x0b\xc1\x8a\xd5\x34\x17\x92\x0d\x24\xf7\xc9\x30\xa3\x23\xe2\x6e\x79\x55\x44\x1a\xc4\x4c\xa8\x3f\xec\x04\x94\xb1\xcf\x2c\x9e\x95\xcc\x59\xe4\x24\x3d\x27\x9b\x64\x91\xe5\xa9\x95\xa4\xe7\x36\xbe\x37\x49\xcf\x3d\xf3\x50\xeb\x95\xb2\xbe\xbd\x02\x3c\xf4\xd4\x5f\xad\x0d\x39\x14\x26\xb2\x34\x2f\x57\x55\x75\x51\x48\x92\x68\xc7\x79\xa4\xe2\x45\x47\x33\x5a\xd0\xbc\x54\xfa\xb2\x79\xca\x32\xb0\x23\x22\x16\x74\x20\x98\x33\xe2\x61\x5a\x88\xf2\xcd\x38\xcd\x12\xb2\x09\xc3\xb1\x0f\xcc\x20\xcd\x0e\x54\x4d\x90\xe3\x42\x9b\xb6\x6d\x5e\x3f\x02\x95\x4c\x8e\xe5\xc0\x53\xd1\x70\x6d\xef\xf5\xc8\x83\xb7\x19\xbf\xd8\x95\x57\x53\xf2\xc9\x43\x97\xa9\x8a\x3d\x50\x07\x82\xd2\xe5\x7c\x64\x03\x62\xc8\x52\x84\xc6\xb9\x68\x0d\x70\x87\x7d\x81\x6a\x9a\x66\x70\x57\x8d\x47\xd2\xa1\x36\xc2\xc2\x8b\x41\x41\xf3\x78\xec\x1e\x23\x48\xe7\x9f\x0c\xa4\xcb\x4b\xe2\x14\xde\xa6\x03\x7e\x6e\x1c\x4f\x65\x73\x4a\xde\xa6\x05\x1b\xf2\xcf\x64\x30\x1b\x45\x6e\x37\x5f\x69\x35\x7d\xf1\xed\x77\x2f\x9c\xad\x9d\x27\x0d\x60\x06\xb3\xd1\x3f\xd2\x2c\xa3\xd1\x84\xe3\xbf\xbc\x18\xf5\xc4\x98\x5f\x9c\xca\x81\xc4\xa3\xf4\x75\x9a\x6c\xae\xad\xbf\x7c\xb1\xfe\xec\xc9\xd7\xa0\xd4\x3d\xa9\x5c\x24\x2e\x0b\x64\xef\xb0\xed\x5b\x56\x1d\xb6\xbb\x42\x1c\x35\xe7\x92\xdc\xd7\x84\xda\x04\xd8\xd8\xc3\x87\xf5\x84\x42\x3a\x4a\x0d\xd3\xe6\xd8\x51\x63\x0e\x90\xd6\xb1\x52\x4d\xca\xce\x94\xcb\xb4\x6a\x70\x82\x41\x8c\xd7\x64\x28\x72\xb3\xf1\x38\x2e\xd7\x6a\x9a\xd5\x38\x46\xaf\xcd\xb1\x6c\x52\x8f\xe3\x0d\x65\x28\x28\xe9\x08\x63\x46\xd2\x8a\x13\xb4\xf6\x3d\x55\xde\xdb\x7e\xb4\xe9\x84\xa9\x78\x3f\x94\x52\x08\x55\x19\x2e\x9c\x00\x53\xb0\x58\x01\xd7\x84\x58\x60\x10\x7c\x30\xc8\x35\x77\x78\x3c\xd6\x59\xa8\xf0\x6d\x23\x4c\xea\xa5\x54\xd6\x53\xf7\x68\xaf\x4b\x36\x52\xea\xde\xe3\x09\x93\xa2\x0d\xb8\xf0\x5d\x6b\x8d\xfd\x4a\x49\x23\xf2\xfb\x83\xde\x3a\x4d\x5a\x7e\xcf\x37\xda\x15\xd7\x40\xe1\x5f\xd0\x8b\x83\x66\x01\xcc\xb5\xc5\x2f\x2b\x0c\xb8\x50\x01\x9d\x4d\xfe\xdc\x9e\x3b\x78\xe0\xbb\x86\xa0\x19\xb5\x19\xee\x55\x63\x3b\x1e\x3e\x74\x96\x27\x12\xf2\xb1\x44\x65\xb3\x1f\xd5\x37\xc2\x9e\xf9\xd0\x1c\x23\x8a\x3e\xf8\x0f\x90\x6e\x14\x71\xd1\x1c\x29\x48\x6b\x4f\x41\xb8\x2e\x39\xba\xa5\x10\x31\x1b\x94\xd9\x5c\x92\x52\x73\x24\x4d\x1b\x32\xce\xb4\xb6\x2c\xa1\xba\x67\x6b\x35\x5a\xc5\x0d\x74\x54\x94\x68\xee\xdb\xef\xe8\x19\x43\x79\xc9\xd8\x1d\x40\xc8\x4a\xc5\x3b\x3e\xcb\x41\xca\x62\x43\x5e\x30\x79\x60\xa2\x11\x6e\xae\xc4\x62\xc1\x94\x85\x50\x7b\xff\xc0\x41\x20\xfb\x11\x17\x69\x19\x8f\x21\x6f\x97\xc6\x1b\x6c\x92\x56\x0a\x45\xb0\x5b\x7d\xe7\x11\x32\x17\xf5\x08\x52\xc1\x7a\x56\xf8\x76\x4b\x19\x91\x5b\x5d\x34\x20\xb7\x5c\xeb\x92\x99\xf3\x54\xc5\x30\xea\x95\xd7\xcf\x01\xa3\x1b\x4e\x77\x90\xe9\xd2\x1b\x00\x9d\x25\x29\x37\xfd\x5b\x21\xca\x18\xd8\xb4\x1b\x80\xeb\x6f\xa0\x5a\x1b\x6d\x04\x26\x3a\x4a\x73\xd7\x4d\xa0\xaa\xb1\x73\x5e\x55\x55\x80\xf0\x79\xc7\x57\xd6\xd5\x30\x01\x8d\xba\x6e\x0f\xc7\xf0\xe8\x24\x88\x91\xba\xe9\x66\x69\x1c\xa9\x84\xf9\x0b\x97\x64\x07\x5d\x05\x8c\xcf\xc0\xad\x16\x25\x9d\x8c\xbc\x25\x81\x62\x42\xb7\xef\xff\xf7\xa6\x25\x2c\x94\xba\xa8\xb3\xf7\x0c\x92\x89\x43\x11\x01\xf8\xb1\xec\x28\x0f\x67\x03\xc8\xd0\x4d\x5a\x42\xff\xba\xcd\x48\x55\x54\xe3\xe2\xc1\x1e\xf1\x11\x94\xec\x21\xad\x52\xff\xba\xd5\xa2\xe6\xd3\x99\xdd\xd7\x69\x9e\x96\x1f\x0b\x2a\xcf\xcb\xc3\x92\x56\x54\x30\x15\x7e\x6d\x3b\x19\xb1\xf2\x47\x2e\xd0\x16\xbb\xf8\x8b\xe0\x8c\x94\xa2\x5b\x4e\x29\x35\x3f\x03\x73\xea\xf5\xc8\x5b\xf0\x67\xcc\xcb\x82\x67\x19\x4b\x2c\x5b\x15\x92\x23\x52\xbc\xba\x69\x63\x3c\x2a\xc1\x95\xba\x26\xd3\xba\x70\x0b\xab\xe4\x44\x7b\xef\x44\x64\x47\x45\x67\x95\x60\x5d\x80\x54\x51\x86\xb5\x68\x21\x78\x59\xad\x7a\x4b\x83\xb5\xcc\xbe\x86\x76\x3e\xc5\x64\xd6\xe6\xaa\x63\xcf\xcb\x6b\x50\x18\x42\x7a\xe5\xac\xaf\x7d\x53\xe7\x1d\x90\x9c\xb3\x71\xd9\xaf\x83\x17\x1c\xc3\xfa\x9f\x4b\xbf\xd4\xd2\x1b\x1b\x65\x23\xf6\xaf\xc1\x64\x10\xfb\x4f\xff\xc4\xfe\x35\xd8\x4f\xd8\x90\xce\xb2\xb2\xbf\x80\x43\x82\xcc\x45\x85\x60\x45\x09\xf9\x0f\x70\x3b\x82\xb0\xaa\x14\x97\x8e\x29\x60\x85\xdc\xd6\xbb\x66\xba\xc0\xb3\x06\xe1\x37\x4a\x68\x1e\xd7\x0e\x48\x89\x56\x40\xb4\xb9\xba\x30\xda\x6f\x96\x4f\x94\xc4\xc8\x0b\x92\x70\x90\x14\xe3\x8c\xd1\xdc\x02\x9b\x4d\x49\xce\x62\x26\x04\x2d\xe6\x2a\x0d\x12\x38\x39\x9d\xb3\x02\x2a\xa9\x48\x6a\x8a\xcf\x94\x98\x39\xe1\x85\xc9\x30\x0a\xcf\xdb\xa1\xe3\x88\x8b\x12\x04\x55\x45\xe7\x37\x64\x57\xb5\x2d\xf3\xef\x37\xe3\xeb\x36\xe8\x75\x27\x44\x0d\xde\x2d\x59\x7e\x0d\xde\x35\x4c\xa7\x79\x23\xd5\x54\x69\x3c\x7f\x83\xae\x69\x8d\x36\x6e\xb3\x7c\x47\x2a\xdc\xb4\x24\x13\x3a\x07\xa5\xe5\x80\x11\x61\xdc\x0c\x0f\x7f\xf9\x5b\x97\xbc\xa3\xe5\xf8\xdd\xcf\x72\xed\x2a\x71\x03\xd6\xcf\xe4\x5a\x17\xcb\xc0\x02\x5d\x55\x27\x76\xa5\x3c\x98\xdf\xd0\x2c\x9e\x65\x5a\x41\x9b\xa4\xc3\x21\x19\xb0\xf2\x82\x69\xb7\x9c\x0b\xae\xbc\xc0\x44\x64\x6f\xe0\xb2\xd9\xe2\xbb\x77\x46\x45\xf9\xde\xdc\xbf\x73\xf6\xd9\xf9\xab\xf9\x36\x7e\x83\xeb\xb4\x0b\xd2\xaa\xa5\x20\x27\x8b\x6b\x21\x25\x9b\x36\x8b\x2e\x64\xfe\xa5\xea\x08\x31\xf6\x0b\xed\x56\xb7\xf8\x8e\xe8\x71\x20\x03\x64\x91\x34\xe8\x62\xc0\x2c\x83\xe9\x6d\xd1\x97\xb5\xa9\xc9\xff\x55\x67\x75\x7c\xb2\xec\x5e\x6a\x1a\x6d\x65\xd9\x6e\x34\xde\x80\x8b\xd0\x6d\x46\x5c\xd9\xad\x8d\x23\x5e\xbf\xc5\x88\xd7\xef\x74\xc4\x35\x1e\xdd\x38\xe6\xa7\xb7\x18\xf3\xd3\x3b\x1a\x73\x85\x87\xb9\x63\x75\x07\x14\x1a\x8f\xdb\xe9\x46\x9d\x07\x1a\x50\x86\x0f\xfa\xbe\x3e\x01\x6f\xa0\x7f\x63\x96\xd9\x28\x2f\x39\x9e\xc3\xbe\xcc\xe4\xb8\x78\x6c\x98\x84\xfe\xf3\x8c\x61\x1e\x19\xe7\x81\x72\x48\x35\xfc\x4a\xe9\x71\x1c\x27\x63\x83\x6a\xd7\xc9\xf8\x5a\x1f\x63\x72\x79\x49\xee\xd9\x55\x5a\xd0\xca\x34\x32\x0e\xc6\x64\xb3\xea\x5b\x10\xf2\x53\xbe\xc6\xef\x44\x73\x5d\x70\x3a\x51\x04\x17\xf2\x63\x56\x13\x36\xd8\xd1\x53\x86\xef\xaa\x6a\x2b\xf3\xa2\x3a\x21\xf3\x79\x45\x71\x85\x49\xd1\x1c\x44\xfb\xaf\x49\x75\x11\xb0\xfa\x81\xfe\xdf\xd5\x4a\xb8\xe1\xb1\xe9\xee\x84\xf8\x4e\x97\xbe\x9e\xeb\xc6\x3e\x34\x55\xa7\xc5\xba\x27\x8c\x72\x50\x8c\x8c\xad\x51\x05\x06\x62\xee\x0b\xa6\x9c\xf3\xc1\xab\x16\x43\x38\x52\x31\xa9\x39\x03\xfe\x2b\x3b\x52\xe2\xec\x76\xd1\xc2\x9b\xb7\x4a\x08\xca\x20\xc6\xeb\x4b\x78\xd9\x5f\xee\xc2\xc1\xd1\xb1\xdb\x52\x4c\x80\x4b\x33\xac\x28\x40\x76\x87\x20\x46\x1b\xed\xab\x1e\x82\x13\x0c\x81\xb7\x36\xe7\xda\x37\xa6\x98\xcc\xfd\x7e\x8c\xda\xf2\xfb\x64\x98\x0e\x58\xa1\x0b\xcd\x4a\x3e\x21\x8c\x19\x55\x70\x03\x8b\x2a\x9f\x50\xef\x06\x89\xed\x50\xd2\xaf\xd8\x8d\x81\xb2\xbd\x53\xc0\x25\xed\xe6\xe3\xc1\xa3\xcc\x2f\xfe\xdd\x97\x66\x19\xe1\xe0\x72\x8a\xae\x31\x89\x76\xe6\x49\x71\xd2\x34\x49\x9c\x34\x94\xbf\xcd\xd8\x0c\x53\x04\xe9\x6c\x3e\x0a\x03\x8c\x5c\x8c\xd3\x92\xa1\x2b\xab\xf2\x7e\x85\xb9\x91\xe9\x98\x0a\xe3\xfd\xa3\x67\xd2\xae\x0e\xd6\xff\xfb\xf2\x92\x1c\x9f\x74\x30\xfe\xdd\xfa\x08\x4a\xf6\xe4\x9a\x11\xea\x7c\xb3\x16\x9c\xb1\x64\x60\x85\x2b\x2e\xba\x7c\xcb\xa9\xa7\x12\x60\x99\x35\x6f\xfd\xe5\x42\x41\x3c\x0f\x6e\xb9\x29\x4c\xcf\xfe\x0b\x93\x1c\xdc\x8e\xec\x0e\x78\xf4\xff\x86\x20\x11\x7d\x6c\x54\x67\x06\xb9\x92\x05\x53\xb3\xc1\x10\x12\xdd\xee\x93\xc9\x0b\x24\x9f\xea\x4e\x3e\xd9\x71\x84\x8f\xac\x3a\xf2\xdc\xce\x9b\x8f\x2c\xb9\xae\x96\x56\xe0\xe4\xd6\x7f\x2c\x38\xe7\xaa\x27\xd9\xb5\x47\xdd\x35\x87\x9d\x7f\xdc\x2d\x7b\xe0\xb9\x5f\x5d\x79\xc8\x45\xd6\xa5\xb0\x0b\x24\x82\x11\x85\x89\x52\x3d\x58\x6c\x2f\xc2\x6b\x98\x28\x5d\x72\x5d\x8c\x57\xdd\x89\x3b\x03\x48\x16\xae\x83\x6d\xec\xf3\x7f\x1e\x42\x03\x83\x59\x8c\xe1\x9a\x73\xe9\x1d\x84\x42\x5d\x3b\xe1\xc5\x27\x0e\x59\x78\xea\x54\xb1\xe1\xbb\x49\xfb\xbc\xdd\x1b\x41\xc8\xf1\xbf\x2a\x38\x2b\xec\x2d\x15\x37\xf2\x7b\x87\x68\xe9\xd3\x43\x7d\x6b\xd8\xb5\x3d\x34\xbe\x3e\xbc\x4b\x73\x13\xf5\x7e\xd3\x86\x75\x79\xeb\xf0\x35\xe7\xa9\x89\xc0\xf1\xa2\xc4\x16\x13\x1c\xde\xd4\x76\x9d\x34\x6c\x25\xe7\x04\x75\x4a\x3a\x4a\x14\x59\xb9\x4d\xe0\xa6\x33\x36\xba\x70\xb4\xe3\x9f\x3e\x0a\xa2\x65\xd6\x31\x1c\xa3\x66\xd0\xed\x6e\x71\x60\xaf\x8b\xa2\xd7\xb4\x3f\x65\x63\x1c\x93\x8b\xdf\x5b\x61\xf7\xe0\x5f\x34\xbe\xe9\x77\x8b\x0e\x42\xbf\x66\x46\x47\x10\xd1\x8d\x82\x34\xca\x8f\x52\xa2\x3d\x07\x6d\x23\x9f\x8d\xc6\x9a\x40\xa0\xc4\x17\xc8\x8a\x92\x20\xe6\xac\xf4\xb9\xd3\xbf\x63\xa0\x51\x88\x71\x7a\x92\x9c\x4b\xab\x55\x65\xc8\x1d\x5d\x4c\x9a\xae\x26\x68\x1e\xba\xe1\xd5\x64\x89\xcb\xc9\x57\x5f\x40\xf2\xb9\xba\x80\x98\x38\x37\x6b\x79\x0b\xdc\x3e\xc0\xd1\xb2\x1c\xb3\x9c\x5c\x38\x37\x90\x61\x9a\xc9\xe9\xa4\x25\xe1\x33\x37\x3a\xde\xde\x4a\x54\x14\x9e\xbd\x99\xdc\xea\x2e\x12\x8a\x57\xd2\x35\x4a\xea\x87\xe9\x0d\xba\x00\x71\x3d\x70\x20\x5e\x59\x77\x3b\xef\x63\x9d\x9e\x64\x6b\x3a\xcd\xe6\x46\xb1\x1f\x55\x23\xa7\x1a\x55\xf8\x95\xc0\xa9\x6b\x34\xfa\xd6\x93\x2e\x18\x20\xd5\xec\x4a\x57\x53\x86\xde\xdc\x1b\xaf\xa6\x13\x0d\xcc\x9a\xfc\x9e\x81\x62\x1b\x9e\xe3\xda\x4e\x6e\xbd\xd6\xa8\x46\x33\xee\x27\x11\x8f\x99\x64\xa6\x89\x24\x08\xeb\xb0\x66\x36\xb4\xae\x10\xd0\xeb\x69\xf9\x38\xba\x91\x4d\xf4\x83\xde\x85\x8c\x5c\xa0\x91\x8b\xa8\x14\x16\xd0\x54\x90\x47\x74\x58\xb2\xe2\x91\x8d\xe5\x41\xfb\x15\xf2\x96\x31\x15\x5e\x4c\xc2\x58\x42\xc8\x09\x7c\xa2\xe5\x48\x0f\x7f\x9f\x22\xb2\x2f\x37\xe8\x45\xaa\x22\x06\x9e\x63\x3f\xda\x7a\x93\xf2\xdc\x71\xdc\x2f\xa8\x6c\xa6\xbc\x14\xb1\xd4\xdb\xb4\x40\xff\x34\xbc\x4d\x5e\xe8\x34\xf5\x05\x9f\xa8\x4c\x57\x54\x88\x74\x94\x33\xa3\x1e\xc0\x41\x84\x4c\xaa\x15\x22\x58\x71\x8f\x1c\x4c\x5f\x0b\xa6\x52\x7d\x3d\xd5\xe7\xcb\x24\x85\x42\x2e\x3a\xff\x19\xc2\xef\x12\x31\x8b\xc7\x50\x3d\xc6\xc2\x79\x4f\x93\x94\x93\x51\xc1\x67\x53\x22\xc6\xe9\xb0\x34\x4c\x43\x02\x66\x89\x53\x00\x2a\x47\xb6\x95\xd3\x09\x4b\x48\x01\xdf\x01\x5e\xfc\x59\x40\xac\xd1\xee\x10\xed\xf7\x49\x48\xfb\x7c\xbd\xc5\xc1\xc3\xc7\x32\x06\x99\xeb\xcc\x2e\xbd\x1e\x79\x85\x8f\xbe\xf7\x50\x02\xcc\x1f\x7c\x41\x79\x1c\xcf\x0a\x45\x14\xaf\xd0\xcc\xf4\x7d\x55\x94\x83\xac\x1f\x31\xcf\xe3\x34\x4b\x81\x0c\xd4\xf3\x29\x17\xe5\x87\x65\x97\xb0\x32\x60\x3f\xd6\x4a\xee\x6a\x4c\xb2\xe8\x17\xae\x58\xe4\x01\x5c\x89\x4b\x5a\xc6\x08\x59\x90\xa6\xf4\xe4\x8e\x1f\xc5\xf1\x22\x71\xeb\x04\x03\x73\xbc\x1c\x90\xb7\x70\x36\xfe\xd3\xd1\xf8\x5f\xd5\xd1\xf8\x8f\xf7\x2d\xfe\xd3\x87\x38\x60\xa0\xbb\x6b\x5f\xe1\x7f\x71\x9f\xe0\x7f\x3d\xdf\xdf\xdf\xd3\xc7\xf7\x4e\x7d\x79\xff\x74\x10\xbc\xb5\x67\xee\x5d\x7b\xd9\xfe\xb9\x24\x77\xe5\x31\xfb\xbf\x1e\x93\x0b\x1c\x35\xac\x44\xe8\xfb\x69\x58\xa1\x8f\x79\x59\xc3\xf7\x54\xca\x6e\x79\x43\x39\x64\xa5\x5b\x17\x9e\xba\x99\xc5\x1d\xa9\xc9\x3e\xc7\xb6\xa1\xec\x20\x4e\xb1\x0c\x93\x1a\xe4\xf1\xe3\x8a\xe6\x19\xeb\xa1\xda\xa6\xc7\xe9\x49\xd4\x54\xa8\xde\xca\x20\xd5\xea\xa7\xbd\x1e\xf9\x61\x96\x66\xe5\x2a\x26\x04\xf2\x4b\xc7\x19\x4d\x08\x4b\xcc\x07\x8a\x73\xd3\x92\xae\x42\x5c\xab\xc4\xbf\xa1\xc5\x0a\xc5\xaa\x0e\xde\x58\x6a\x71\xb0\xa2\xeb\x69\x9b\xe2\x79\x75\xa5\x31\xe4\x02\xc4\x42\xeb\x58\xff\x8a\xe7\x2e\xe9\x95\x74\xe4\x38\xf1\x28\x41\x47\xde\x4c\x16\x8d\x07\x9b\xa9\x9b\xd9\xf5\x0d\x91\x6d\x2d\x6e\x59\xf1\x9f\x52\x53\xd8\xf5\x8a\x91\xea\x9c\x63\xbc\x48\x47\x69\x4e\x33\x58\xbf\xc8\xff\xe2\xab\xa3\x8a\xd7\x9e\xbc\x78\xf9\xc2\x05\x16\xa0\xd2\x88\x26\x49\xbb\x4e\x2d\x4d\x61\x9f\xcd\xae\x92\xe1\x1c\x87\x85\xa7\xed\x51\xca\x4c\xfd\xf0\x4e\x32\x1c\x9a\x3b\xd5\xe2\x04\x87\x41\x5f\x18\xc9\xb3\x4a\xb7\x46\x85\xbe\x95\x82\x4c\x0f\x39\xc1\x19\xe6\x6b\x13\xa5\x9b\x41\xae\x9a\x54\x04\x4d\x18\x58\x0f\x99\x26\x3a\x6d\xbc\x4a\x89\x00\x79\xc7\x05\x19\xa7\x49\xc2\x54\x41\xc6\x0b\x66\x72\x97\xc3\x25\xc8\xe1\x7c\x6e\x27\x3b\xd1\x28\x22\xf7\x87\x9c\xdf\xc7\x14\x75\xd8\xc1\xfd\xe1\x2b\x31\xa5\xf9\xf7\x9c\xbf\xea\xc1\x8f\xfb\x60\x6f\x86\x7e\xc0\x99\xdb\x42\x13\xb4\x4c\xc5\x10\xec\x7a\xb3\x82\x14\xec\xb7\x59\x5a\x20\xbb\x21\xfb\xfe\x03\x5d\xf9\xbd\xe4\x72\xf5\x92\x59\xcc\xc8\x94\x15\x43\x16\x3b\x1e\x25\x26\xef\xba\xc3\x87\xc8\x6e\xc2\xb0\xaa\xae\x49\xe6\x32\x55\xe5\x2b\x89\x28\x8b\x59\x0c\xb5\xd4\xe5\xf8\xd2\xb2\xe5\x60\x8c\x9f\xe9\xee\x90\xb3\x93\xf3\x14\xea\x37\x9b\x95\x30\x9e\xe9\x2c\x07\x0d\xbf\x6c\x99\x27\x69\x2c\xef\x22\x17\x63\xea\x0c\x0b\xec\x00\x36\x37\x2b\xde\xb2\x72\x9e\x30\x61\x4d\x4b\x17\x69\xc1\x12\x32\x9b\x92\x92\x3b\xe1\xfa\xc8\x4d\xa0\x4e\xa6\x7b\xbe\x4c\x90\xaf\xd0\x9c\x50\x82\x25\x87\x60\x59\xf6\x78\xc2\x54\x7d\x60\x49\x25\x35\x38\x2a\xbb\x87\x4a\xaf\xee\xb0\x76\x9b\x5f\x01\xf2\x4a\xff\xa2\xb5\x3e\x8a\xc0\x5e\x3b\x7a\xfe\x65\xb3\x24\x42\xc9\x09\xdb\x83\x9b\xdc\xb0\xc9\x1e\xe0\x9b\x40\xee\x35\x69\x29\xaa\x46\xd9\x60\x59\x9d\x86\xbe\x83\x86\x90\x05\x96\x5b\xb2\x49\x8e\xf5\xbe\xb4\xdf\x9e\x34\xda\x0f\x6f\x92\x31\xf0\x1a\x0c\xf9\x36\xb5\x7f\x27\x34\x79\x23\x0f\xe1\x6a\x85\xfc\x99\xbb\x6f\x99\x84\x58\xce\x39\xf0\x8b\x92\x35\xac\x91\xcb\xf1\x5c\x8b\x79\x51\x30\x31\xe5\x79\xa2\x8c\x47\x69\x61\x4a\xfa\xab\x92\x9f\x6e\x36\x16\xa7\xe2\x8e\x6b\xd5\xd7\x16\xa9\xdd\x7c\xc8\x5d\x8b\xfd\x32\x04\xd6\xeb\x91\x6d\x74\x87\x42\x35\xb1\xaa\x56\x91\x8f\x22\xf2\x11\x44\x68\x90\x85\x40\xd3\x94\x65\x8a\x01\x6a\xad\x79\x54\xdf\x42\xbf\x9b\xa1\x98\x5c\x5e\x3a\x7a\xa3\x1b\x49\x77\x5f\x23\xdb\xb9\xc3\x52\x02\x5e\x75\xb4\x46\xa0\xab\xbd\x30\x02\x5c\x05\xd1\xc6\xbe\x7d\x2b\x1f\x10\x5c\xf3\x82\x5e\x5c\xeb\x04\x72\x79\x29\x77\x74\xdf\xf3\x8a\xb2\x64\xa4\x72\x0a\x39\x7c\xc4\x2b\x30\x61\x9b\x6b\x82\x54\x1f\x78\xd5\x4b\xaa\xf7\xbe\x8a\x93\x86\x9c\x9f\xf7\xb9\xdc\xbb\xb6\xfb\xe0\xde\x3d\xf0\x0a\x6c\x39\xce\x37\xe6\xb3\xae\x37\xa4\xc5\x59\x60\x17\xf8\x18\xda\xdc\x42\x6f\xd3\xcf\xef\x18\x59\xd5\xc7\xec\x80\x91\x34\x1f\x32\xcc\xa8\x8b\xb2\x8b\xf1\x88\xb1\x22\x6f\x40\xe0\x3d\x6e\xa1\x77\x6a\xeb\xa4\x5d\x65\x0f\x3e\x2a\xb5\xeb\x39\xa6\x16\xd9\xd6\xc5\x4f\x31\xc1\x8c\xcd\x87\x18\x60\x54\xc2\x2b\xd2\xe5\x2c\xde\xc8\xad\xac\xad\xea\x8c\x36\xac\x04\xf6\x6e\x97\xe2\x97\x6a\xa5\xfc\x25\xd7\x42\xa5\x67\xf4\xc0\x2e\x5e\x8d\xc5\x59\x0f\xff\x88\x05\xf1\xaf\xaa\x8d\x88\x1d\x7d\x4d\x6a\x55\x0f\xd9\xde\x71\x75\x27\x78\x5e\x2e\xed\x71\xa0\xce\x7a\x7d\xac\xd5\xa3\xd6\x3d\x41\x70\xf6\x07\xce\x93\xc0\xf9\x7d\xeb\xc5\x5a\x66\xb9\x74\xff\x91\x57\x96\xcc\x13\x6c\x1a\x57\xed\xe0\x26\x89\x5c\x49\xc8\x8f\xcc\xa4\x2b\x34\x36\xba\x70\x36\x41\x17\x8f\x7e\xeb\x05\xa9\xa7\xf0\x7f\x15\xe0\x0d\xd9\x05\xc1\xa6\x6f\x3f\xba\xba\x5d\x9f\xb7\x5c\xb5\xdb\x6e\xb3\x20\xa2\xff\xa8\x51\x35\xe2\xf1\x0e\x36\xbf\x05\xfb\x4f\x64\x03\xbe\x42\x05\x7b\xf8\x6a\xd4\xe2\x91\x51\xd7\xea\x88\xf4\x1f\x8c\x7c\x4f\x9e\x2c\x79\x89\xb9\xc5\xd2\x86\xcb\x26\x86\x06\xd5\xa9\xd8\x53\xff\x8c\xdc\xff\xdf\x1b\xb9\xef\x99\x7d\x82\x46\x25\xa5\x9e\x43\xf7\x20\x70\xd4\x53\x68\x02\x5c\xa0\x89\x5f\xdb\x15\x20\xc3\xe7\x98\x29\xff\x13\xe3\xfc\xe7\x6a\x89\xe4\x88\x09\x60\x4a\xde\xe2\x86\xbc\x88\x99\x72\x07\x4c\xd2\x73\x56\x8c\x94\x13\x91\xab\xda\xfa\x91\x5f\x48\x14\x75\x65\x6b\x47\x73\x05\xc3\x84\x11\xe1\x24\x6c\x75\x9c\xdf\x66\x29\xd4\xf9\xb3\xd9\x84\x4b\x55\xed\x47\xb7\xb5\x60\x94\xbe\xad\x60\x22\xc5\xd4\xfe\xca\x31\x71\x7b\xff\x1d\x11\xa5\xbc\x8b\x82\x3f\x97\x2a\x5e\x68\xba\x48\x54\xbc\xcc\x98\xd9\x55\x32\xe4\xf2\x86\x43\x51\x6d\x2c\xeb\x9e\x70\x74\x37\x52\xe5\x72\xea\x78\x8c\xea\x6b\xd3\x9c\xb5\xc0\xa8\x6c\xff\x9d\xa3\x70\x1b\x9d\x1e\x83\x4e\x42\x47\xec\x73\xa9\x12\x17\xee\xf1\x84\x75\x01\x71\x5e\x2d\x3e\x75\x0a\x40\x75\x0d\xd5\xca\xd1\xf0\xc9\xc3\x44\x3e\xde\xb0\x3d\x3b\xdf\xf8\xfd\x2a\x26\xfa\x21\x07\x15\xef\xc2\xbe\x11\xd1\x61\x7d\x53\x7d\x14\xea\xcb\xba\x3b\x94\x02\xb0\x8d\x91\x7a\x38\x67\x3a\xc8\x9c\x64\xd4\x4a\x8c\x82\xee\x41\xe3\xe9\xf6\xff\x3b\xd6\xbc\xad\x3a\x0b\x6d\xab\x1a\xc1\x78\x85\x51\xe7\xac\xd2\xad\x73\x9d\xc7\x9a\x50\x95\x32\x33\x87\x7f\xa3\x96\x1a\x33\x60\x62\xaf\x66\xfe\x32\xae\x5d\x1a\x59\xf5\x26\x37\xc0\x99\x5a\xad\x7f\x2f\x84\x99\xf2\x39\x90\x52\x1d\xaa\x70\x07\x91\xa7\xc8\xe8\x16\xf8\xda\x55\x11\x1a\x7a\x63\x85\x49\xcc\x66\x10\xfa\x27\xa1\xcd\x94\xc1\x6d\xa4\x30\xd8\x9c\x92\xab\x56\x49\x0d\xc7\x7e\x77\x18\x0a\x10\x54\x95\x01\x00\x6f\xd6\xb5\xdc\x5b\xad\x6a\x35\x19\xb5\xf6\x60\x35\x91\xb0\x55\xb9\x39\xb3\xe0\x42\xc9\x01\xe5\x98\xcd\x5b\x4a\x27\x57\x30\x30\xdd\x80\x2c\x91\x3a\xe2\x83\x2e\xa6\x5b\x3b\x6f\xde\xeb\xb4\xfd\x52\x18\x71\x22\x0c\x54\xc8\x4e\x4c\x73\x28\x5c\x89\x85\x6e\xd5\x40\x24\xfa\x60\x2c\x0e\x7c\x33\xa8\xa8\x71\x41\xff\x35\xe9\xc0\xee\x1f\x79\xa0\x55\xf7\x10\xa6\xbc\xfd\x1a\xb2\x28\x98\x28\x79\xc1\xac\x0a\xb5\xee\x9c\x54\xdd\x2e\x4b\x0a\xd3\x61\xc8\x81\x92\x18\x56\x76\x73\xb1\xda\x20\xb0\x36\x40\x7d\x7a\x23\xa8\x15\x4f\xa0\x06\x98\xeb\x4b\xc1\x04\x74\xca\x53\x1a\xbc\x47\xb7\xf7\xdf\x81\x33\xa8\xd1\x68\x91\xcd\x4a\x24\xf0\x97\x95\xbf\x78\x79\xac\xfb\xd5\xd2\x0c\x5d\xdd\x40\xa7\x18\xee\xd7\x52\x1c\x77\x57\xfe\x12\xca\x31\xdc\x6f\xc8\x3c\xdc\x5d\xf9\x8b\x9f\x10\xa9\x5f\x4b\x90\xd4\x5d\xf9\x4b\x35\xe4\xa2\x1f\x08\xc2\x50\x90\xea\xce\xcd\xfd\x46\xa7\xe7\xca\x27\x72\x12\xfd\x80\xf0\xd3\x5d\xf9\x4b\x48\x32\xe9\x37\xc8\x2b\xb6\x79\x93\x58\xd1\xbf\x5e\xee\x58\x00\xc4\xeb\xbb\xe1\x14\xb6\x9f\x37\x1c\x3b\xfd\x6b\x8f\xa5\x66\x10\xde\x00\xc2\x4c\xbb\xbb\xf2\x97\x30\xe5\xf6\x1b\x28\x7a\xe5\xaa\xb3\x81\x55\x81\x81\xa7\x26\x69\x21\x19\x77\x3a\x99\xf2\xa2\x14\x24\x4b\xe5\x0d\x90\x4f\xd8\xea\x94\xc6\x67\x74\xc4\x7a\xa2\x88\x7b\x8f\xc0\x8e\x32\xa0\x49\x44\xde\xa6\x9f\xc9\x84\x45\x40\xec\x0b\xcb\xaa\xbf\x20\x9b\x6a\x37\xb0\xc1\x6c\xe4\xb6\x8b\x16\x7d\xb7\x81\xfb\x48\xdb\x6b\xb6\xf7\xdf\xed\x31\x51\xa2\x3b\x7b\xad\xaa\xe6\x8a\x2a\x46\x02\x92\xbf\x0d\xe9\x20\xb1\x64\x91\x17\x54\x90\x8b\x22\x2d\x4b\x96\x93\x01\x15\xf2\xc2\x9a\x9b\xb3\xe5\xb9\xe4\x93\xe8\xfe\x3d\x65\x71\x7f\xc5\xab\x8b\x37\x2e\x27\x59\x24\x9f\x47\x17\x63\x5a\x5e\x8c\x20\xeb\xfd\x64\x96\x95\xe9\x14\x30\x32\xcf\x4b\xfa\x19\xaa\x9b\xfe\x75\x4c\xc5\x2a\xcd\x57\xd5\x2d\x62\x35\xcd\x57\x45\xcc\xa7\x0c\xe0\xad\x28\x03\x8f\x5c\x0b\x38\xb3\x4c\x15\x88\x18\x3d\x37\xb2\x8c\x28\x2f\x37\x92\xe3\x24\xbb\x24\x87\x5b\x35\x13\x70\x59\x2c\xe6\xf2\x20\x68\x53\xa1\xbd\x19\xa0\x96\x6c\xa9\xa2\x55\xe5\xe0\xc8\x14\x2e\x27\x31\xcd\xc8\x80\xe5\x6c\x98\xea\x8b\x98\x00\xc7\x8a\xf3\x34\x61\xa2\xb3\xa1\x73\x58\x74\xb1\xb2\x47\x91\x13\x9e\x67\xaa\x94\x2a\x94\xa3\xa7\x82\x09\x72\x81\x85\xe2\x21\x8d\x41\x21\x58\x81\x4e\x20\xa3\xf4\x9c\x11\x8a\x8f\x48\x59\x30\x8c\x57\x62\x60\xfe\x83\x2b\x2c\x0c\x03\x56\x7a\x45\x05\xc8\x96\x50\x22\x39\x82\xfb\x34\xfb\x4c\x27\xd3\x8c\x75\xc9\xab\xc1\xf7\xaf\x92\xf4\xfc\xfb\x57\x3d\xfc\xef\x00\xf2\xcd\xeb\xf9\x0f\x66\xce\xbd\x56\x8e\x50\xd5\x79\x55\x35\x10\x52\xe5\x6a\x82\xc3\x50\x36\xd2\xb8\xcc\xe6\x1b\xf8\x15\x4e\x4a\x4e\x45\x59\x2c\x61\x42\x40\xcc\x12\xb3\x60\xf6\xeb\xf5\xc8\xab\xe9\xf7\x58\x32\xc4\x4e\x75\xc0\x46\x69\x0e\xe1\x12\x3a\xd2\x89\xc5\x3c\x4f\xf4\xbd\x50\x6e\x8c\x2c\x8d\xd3\x32\x9b\x93\x38\xe3\x02\x92\x03\x30\x53\x89\x57\x94\x5d\x28\xe4\x08\xb7\x6e\x79\x62\x0f\xf1\xf7\x84\x09\x11\xad\x7c\x35\x55\x29\xe1\x46\x67\x5e\xc2\xbf\x8e\xe4\xc0\x37\xc9\x71\x8b\x26\x09\x96\x6b\x26\x2d\x3a\x9d\x66\xe8\x2a\x0d\xe7\x23\xfc\x5b\xa6\x31\xfa\x29\x53\x79\x39\x97\x3f\x24\xf5\xeb\x7f\x87\x3c\x87\xf6\x83\x11\xdc\x8c\xe1\x67\xc6\xe3\xb3\xdf\x66\xbc\xc4\x46\x3c\x99\xc3\xbf\xe0\x0f\x3e\x98\x95\x25\xcf\xe5\xaf\x98\xa2\xbe\x44\xfe\x94\x32\x1b\xbc\x8e\x79\xa6\xfe\x81\xb0\x23\xf9\x3b\x01\x98\xda\xa5\x5a\xfe\x4c\x0b\xfc\xe7\x1c\xfe\x81\x0f\x12\x18\x03\x9b\x0c\x18\xb4\x1e\xa6\x2c\x4b\x94\xcf\xf7\x30\x1d\x39\x5d\x0d\xd3\xd1\xac\x80\x71\x0d\x39\x57\x9d\x82\x03\xb9\xfc\x17\xa2\x16\xf4\x0f\xf5\xf9\x78\x0d\xfe\xbb\x0e\xff\x7d\x0a\xff\x7d\x06\xff\x7d\x0e\xff\x7d\x01\xff\x65\xe8\xb4\x2e\xff\x45\x90\x63\x33\xfc\x31\xfe\x5d\x4e\x60\x9c\xa9\xe9\x23\x9d\x8c\xd0\x2b\x55\x4a\x37\xf2\x87\x48\xf3\x84\x7d\x06\xdf\xf7\x14\xff\x9b\x9f\xe1\xbf\xb0\x93\xe5\xcf\x09\x4d\x73\xfc\xb7\xf8\x6d\xc6\x00\xcc\x84\xe5\x33\xfd\x6f\x5a\xb2\x09\xfe\x2e\x61\xe9\x72\x0a\x18\xca\xb9\xc1\x4b\xce\x71\x6a\xf8\x5b\x95\xad\xe9\x9a\xe8\x0c\xf9\x0b\x86\x09\x23\x9f\xd2\x82\x02\xbc\x69\x46\xe5\x1e\xfc\x0c\x0d\xa6\x88\x3d\xfb\xad\x60\xb1\x46\xae\x92\x80\xba\x26\x16\x41\xfe\x02\x23\x21\x78\xd0\x4f\x26\xb4\x00\x52\x80\xe3\x0e\x7e\x68\xe2\x28\x61\x78\x25\x9b\x4c\x33\x8a\x64\x63\x64\x34\xf9\x5b\xae\x15\xfc\x18\xe3\x7f\x15\xbe\xcb\xb4\x54\x70\x0a\xfc\x2f\x8d\x01\x65\x33\x98\xc4\x05\x52\xdc\xe7\xc9\xb4\x75\xb2\xf1\xf5\x7b\xa7\x99\x23\x83\x16\x25\x3f\x94\x7f\xd9\xbd\x64\x36\x90\x43\x74\x7a\xf5\xed\xbc\x13\x3b\x1b\x67\x31\xed\x32\x58\x4c\xdc\x62\xe0\xe5\x24\x83\x2a\xe1\x23\xbc\x34\xac\x42\xa0\xb3\x1b\x07\xb4\x8d\xa4\x35\x4b\xc5\x98\x0c\xe6\x4e\xb1\x2d\xe0\x66\xab\xab\xc0\x00\x5f\x01\x96\xbf\xef\x92\x34\x8f\xb3\x59\x02\x25\x6d\x51\x7f\x87\xa0\x58\x51\x08\x7d\x12\x4a\x06\x21\xf9\xde\x90\x5d\x48\x76\xaf\x5c\x38\x56\x08\xec\x31\x96\x8e\xf2\x7d\x33\xc3\x84\x89\xd8\xae\xe1\xdd\x2e\x10\x32\x19\x6f\x9d\xf0\x91\xbb\x56\xce\xca\x45\x31\xcf\x63\x5a\xb6\x8f\x35\x7b\x3a\xe9\xdc\x62\x3c\x23\x96\x33\x29\x50\xad\x02\xab\x67\xc9\x2a\xcb\x93\x55\x79\x4a\x68\x92\xc1\xc7\x3b\x79\x62\xa8\x46\xf1\xb8\xd2\xee\x7e\x6e\x88\x87\x4f\x4b\xc3\x4c\xe0\x3f\x05\xfe\xb7\x54\x48\x03\x93\xbf\x14\x64\xb6\xf2\x18\x04\x34\x65\x5f\x55\x77\x28\x94\x8b\xfa\xe0\xfc\xd4\x45\xb3\x91\xe4\x77\x47\x74\xa4\x9f\xc9\x47\xf4\x88\x8e\x76\x11\x21\xee\x63\x44\x47\xf8\x5d\xce\x07\x45\xf8\xcd\x14\x1e\xff\x60\x31\xee\xf5\x2e\xf9\xd9\x6e\xc9\xe4\x08\xb6\x66\x25\x97\x87\x20\x54\xd6\xb7\xdf\x27\x59\xd3\x7b\x79\x33\xda\xf0\xdd\x78\x13\x77\xda\x0f\xd6\xc8\x26\x31\xb7\xd0\x36\xcf\x12\xf9\x54\x5d\x36\xa5\xcc\x42\xf3\x98\xb9\x09\xb1\xa8\x8f\xb3\x53\x8c\xbe\x6d\x7f\xb9\xea\x12\xf5\x31\xb9\xbc\xac\xa3\xd7\xf1\x87\x4f\x15\xb6\x65\x1f\x7d\xbf\xa3\xbe\xf9\xa5\x46\xad\xc2\x12\x1d\xc2\x03\x9e\xbf\x3f\xc4\x5b\xef\xbd\xcd\x4d\xb2\xea\x64\xab\x70\x07\x17\x39\x2b\xe4\xb8\x2c\xd7\x9a\x55\x57\x6c\x51\x5b\x7f\x05\xbd\x96\x56\x69\x51\xd9\x38\x37\x18\x71\x8d\x0c\x2a\x3d\x68\xc3\xe1\x21\x63\xa4\x98\x65\x0c\xf5\xfc\x8a\xfe\xcd\x8e\x50\x45\x7f\x54\x51\x40\xfd\xcd\x57\x6c\x4b\x25\x9f\xaf\xca\x43\x74\x35\xcd\xe5\xc9\x63\x26\xe9\x48\x44\xa1\x09\x82\x83\xa0\x2e\x3f\xad\xa5\x25\xef\xa1\x14\x46\xbc\x07\xd3\x56\x03\x56\xc2\xe4\xbf\x68\x99\x42\xdb\x21\x84\x4a\xef\x23\x6d\x60\xda\x04\x02\x75\xa8\x4f\x8e\x10\x6d\x1f\x52\xea\x69\x18\xa4\xe2\x10\xe6\x6b\x9f\x24\x0c\x08\xda\xf4\xbd\x4f\xac\x0b\x61\x28\x8e\xdb\x00\x28\x40\xce\x0b\xa1\x49\x92\x6e\x82\x55\x23\xf7\x85\x90\x1a\x17\x30\x44\xd6\x0b\x21\x65\xe9\x8d\x69\x61\x21\xbc\x04\xbd\x01\xed\xdf\x65\x13\xfc\x06\xca\x71\xa1\xaf\x58\xbd\x93\xf7\xed\x86\x61\xb5\xbd\x47\x8f\x64\xa3\x47\xe4\x3d\xb4\x82\xbb\x8e\xbc\x13\xc1\xc3\x9e\x31\x26\x1d\xd1\x11\x78\xa1\x7e\x4c\xcb\xf1\x01\x55\xb4\x67\x59\xb1\xa3\x61\x76\xdc\xb1\x7a\x3d\xf2\x16\x2f\x3d\x52\x68\x12\xd6\x44\x8c\x91\x55\x69\x0e\xe9\x24\xf2\x99\x98\xd1\xcc\x5c\xb0\x27\x3c\x61\x51\x84\xaa\x56\xad\x35\xac\x41\xbe\x23\x2e\xe1\x59\x3d\x83\x6a\x3e\x83\x3d\xb3\x1e\xea\xe8\xf6\xd6\xc8\x1c\xe2\xde\xd3\xbf\x82\x50\xbd\xe1\x81\x37\x2d\x6f\xd6\x81\x0f\x4a\x72\xd5\xb2\x48\x63\xa8\x29\x3b\x65\xf4\x0c\x54\x01\x82\x61\x86\x89\xdc\x66\x31\xd0\x59\x46\x27\x8c\xe6\x0e\xd2\x4d\x46\x04\x0b\x6f\x30\x2b\xab\xe3\x74\xad\xdd\xf5\x51\xd6\x46\x74\xfb\xd5\x28\x93\xbb\x84\xa6\x04\x74\x0b\x72\x8f\x1b\x2b\x80\xa9\xa2\x6b\xac\x0c\xc2\x1c\x52\x34\xcb\xc8\x80\xc6\x67\xa4\xe4\xe4\x7e\x9a\x13\x79\x92\xdc\x07\xaa\xf4\x0d\xed\xb2\x9d\x2a\x4d\xab\xc1\xc2\x05\x40\xd9\x2f\x2e\xc6\x69\x3c\x26\xa8\x8e\x18\xd0\xc4\x90\xb7\xe9\x5a\x67\x7a\xbd\x53\x0c\x16\xde\x22\x96\xc5\x82\x05\x2c\xc7\x3e\x89\x95\x15\xbe\x83\x37\x3b\xff\x11\xde\x0a\xfd\xcf\xf4\x55\xe6\x6e\x49\xc1\x9c\xdf\x66\x2e\x70\x97\xec\xfb\xcf\xe0\xa6\x58\x79\x36\xf4\x23\xfb\x6a\xd3\x2e\xfe\x85\xa6\xa9\x15\x21\xde\x0c\x8c\x76\xa4\x79\x12\x31\xcf\xfe\x90\x55\x90\xf4\xec\x63\x17\xae\xb8\x0b\x06\x46\x03\xcc\xcb\x4c\xc8\x1f\x32\x2c\xa8\xff\x08\xd6\xce\x7f\x04\x4b\xfc\xaf\xb3\x62\x72\x38\x1e\x46\x3c\x12\xac\x23\x04\x74\x69\xde\xb8\x8c\x56\xcd\x7f\xaa\xf4\x6b\xde\x43\xd0\x11\x79\x4f\x40\xf7\xe3\x4f\x13\x2e\xd8\xde\x23\xa3\xfa\xa9\x3c\x55\xca\xa1\x3f\x1a\x99\x6c\x42\xf3\x32\x8d\x05\xe2\xb3\x1c\xb3\x55\x50\x5d\xa8\x0b\xbd\x8f\xcc\x72\x92\x2d\x40\x66\x9d\x16\x80\x86\xfc\x13\xf6\xaf\x89\xaa\xcd\xb9\x08\x90\xec\xa7\x7a\x51\x39\x28\xf8\x80\x0e\xb2\xb9\x4e\xce\x6b\x99\xbf\x2b\x9a\x74\x95\xbf\x13\x9f\x95\x19\xbd\x00\xc5\x38\xc0\x8d\xf9\x64\xc0\x85\x86\xe5\xeb\xc6\xe5\xb7\x78\xba\x28\xf5\xb4\x52\x12\x13\x3e\x65\xb9\x00\xef\x22\xa5\x2b\xe6\x64\x00\x89\xa8\xb5\xff\xe2\xdd\xde\x85\x02\x46\x58\x83\xf9\xb5\x0a\x1f\x1d\xaf\x57\x1f\x3c\xad\x3e\x78\x56\x7d\xf0\xbc\xfa\xe0\x45\x7d\x0d\x8c\x28\x87\x17\xa9\xf1\x1a\x5c\xac\xaa\x4f\xd7\x83\x4f\x9f\x06\x9f\x3e\x0b\x3e\x7d\x1e\x7c\xfa\xa2\x65\x5c\xec\x71\x88\xc5\xb4\x32\xe6\x22\x40\x37\xbe\x4a\xc7\x5c\x21\x1d\xa9\x74\x13\x2e\x92\x15\xd8\x81\x13\x4b\xf3\xc7\x7e\x95\xe3\xd7\x9f\xf8\x67\x80\xca\x85\xe2\x24\xde\x09\x32\xa0\xc0\x36\x5a\x70\x7c\x2e\x3e\x3b\xf5\x19\xbb\xcc\xa1\xeb\x0a\x1a\x60\x60\x93\x02\x15\x5c\xea\x69\xc1\x70\x93\xa0\xe1\x06\x72\x26\x51\x32\x64\x17\x6a\x6d\x54\xf6\x64\xc8\x9f\x6a\x9c\x34\xc6\x69\xe6\xc5\xd5\xfb\x9b\x68\x75\xd5\xde\x21\x12\x7e\x91\x83\xb6\xb2\x8b\x99\x12\x73\x9e\x33\x34\xcd\x70\xc1\x88\x32\xff\x12\x9a\x7b\xe0\x70\x07\x63\x85\x7a\xb9\x0b\x21\xa6\x6b\x68\x0d\x4a\x67\x39\xbf\x40\x3b\x95\xda\xc1\x18\xf1\xdb\x85\xf0\x5a\x9d\x45\xde\x05\x88\xf6\x23\x0a\xe2\x35\xcc\x33\x6a\x26\xfb\xcd\xc0\xdd\x5e\xf3\x27\xe5\xf4\x71\x83\x9b\xd9\x30\xcd\x13\xe5\x3e\xa2\x35\x58\x6f\x79\x81\x97\xfb\xca\xf5\xcc\xbd\xff\xe9\xed\xbf\x80\x23\x68\x45\x88\xbf\xd2\xda\x5e\x54\x79\x0a\xa6\x23\xff\x99\x63\x26\xaa\xd0\x36\x9a\x83\xfc\x87\xd5\x9c\x3a\xea\x69\x4a\x33\x3e\xaa\x3d\xac\x7d\x9c\x9e\x57\x9f\x54\xe9\xdf\x98\x8c\xaa\x8f\x47\xe1\x2d\xa9\x0c\x49\x95\x87\x68\x53\xaa\xef\xbf\xfa\xc3\xd0\xee\x05\xfb\x4e\xe5\x11\xcb\x67\x95\x47\x39\xad\x4e\xa6\xc6\x1d\xaa\x80\xb5\x8d\xa6\xf2\x54\x59\x64\xfc\xa7\xb3\x1a\xb0\xda\x34\xb5\x49\xaa\xbf\x40\xf4\x53\xd3\xac\xce\xfb\xf3\xa4\x3a\xb6\x3f\xec\x60\x59\xac\xc5\xa9\xb0\x66\x2f\xa9\x54\x18\x84\x56\x92\x5d\x5e\xde\x0c\x74\x96\x5e\x03\x38\xac\x16\xaa\x40\x49\xaa\x2c\x36\x09\x9c\x4b\xd7\x6a\x83\xaa\x07\x12\x2a\xe3\x16\xc3\xa9\xea\xe4\x2a\x30\xa8\xcf\xe9\x0f\xa7\x2c\x26\x02\x9c\xdc\xf9\x84\x29\x7f\xf2\x01\x9f\x95\x44\x02\x44\x3b\x37\x24\xa5\xe5\x43\x32\xa1\xc5\x19\x2b\x44\x57\xe5\x5b\x40\x5f\x6b\xe1\x42\x63\xbf\xcd\xd2\x73\x9a\x19\x7f\xf3\x54\xe9\x8c\x6a\xec\xb4\x49\x1d\x59\x19\x2c\xe8\x0b\x17\x4f\xd7\x57\x1b\x86\xb8\xb2\xe6\xd6\xd6\x34\xa1\xdc\xf6\x54\x4e\xfc\x15\x12\x76\x3f\xb1\xec\x17\xce\x33\xc8\xb6\x8a\xbf\xc0\xf1\x2e\xc4\x8e\x2b\xf6\x0a\xef\xcf\x90\xa1\xc2\xda\x29\xf0\x7c\x09\x7c\xa7\x55\xc5\xd5\xa6\x78\x44\x38\x9f\x19\x69\x09\xbe\x2a\xe9\xc8\xd1\x2a\x9b\x61\xd7\xe3\xec\xb5\x7b\xa2\x9e\xa3\x3e\xdf\xba\x10\xf3\x5c\xc1\x4a\x1f\xf3\x8b\x58\x70\xa9\x20\x53\x2a\x04\x4b\x34\x6a\xe8\x48\xe7\xe9\x18\x30\x80\x63\x03\x50\x6d\x0f\xbe\xf6\x49\xad\x16\x5a\x6b\xa0\x4f\xa3\xa0\x0c\xe9\x2d\x9d\xd5\x70\x04\xb8\xd7\x58\x83\xa4\xef\xe0\x60\xa3\x0a\x56\x63\x1e\x74\xac\x6e\x47\xe6\xe3\xc6\xd3\xd8\xe9\x94\x36\x19\x9a\x1c\x88\xfb\x45\x63\x5f\x97\x97\xd5\xe1\xd8\x84\x32\xf7\x1a\x80\x34\xb9\xa0\x9a\xce\xf5\x98\xb4\x51\x20\x08\x05\x69\xc2\x7c\xa2\x1c\xb0\x30\xd6\x6d\x81\x5f\x57\x5b\x47\xb5\x62\x2e\xe5\x22\x87\x50\x6a\x72\xcf\x1f\x2c\x79\x4c\x5a\x97\x2d\xf2\xd8\xae\xb2\x7e\xe0\x8e\xcd\x3c\x33\xde\x5f\xc4\x77\xbe\x3d\x56\x1d\x9c\x2c\xe1\x75\x6b\xda\x1a\x77\x5b\x33\xcc\x92\x8e\xb6\x53\x31\xcd\xe8\x7c\x0f\xf3\x55\xe9\x51\xd9\xf9\x43\x92\x29\x30\xa7\xab\x4d\xa7\x23\xe4\xed\x7e\xf1\x55\xa5\x7e\xe2\x8a\xde\x7f\x1f\xf6\xa2\x92\x89\xd2\xee\x2d\x2f\x34\xb6\x36\x82\xd6\x91\x71\x43\x36\x17\xde\x5a\x18\x64\xfd\xab\x8f\x66\x98\x8e\x1f\xb3\x13\xcb\x5f\x9b\xc6\x7d\x27\xaa\x6b\xce\x67\x4a\x22\xc6\x62\x36\xf9\x1c\x63\x24\x9d\xaf\x6c\x5d\x4d\x29\xec\xf3\x9c\xdc\x97\x8b\x04\x09\x38\xb3\x14\x45\xf1\x39\x9f\x15\x04\x3d\x46\xc0\xd3\x2e\x6a\x2d\xcc\x77\x51\x9f\xc3\xab\x2a\x5d\x7c\xef\xef\x7c\xb4\xba\x3a\xc4\xe4\xa7\x1c\x4b\xfd\xf5\xc1\xf6\x1e\xc5\x83\x86\x03\xc4\x1b\xc9\x05\xfd\xc5\x2b\x2b\x79\x5b\x24\xb0\xc7\x9b\xa4\x45\xb6\x92\x84\x50\xf2\x0a\x2e\x56\xdf\xcb\xe3\x0a\xe6\x09\xae\x84\x25\x57\xb9\x90\x74\xc4\x14\xf8\xc1\x69\xc7\x01\xa8\x66\x06\xc9\x62\xc1\xa1\xac\xe0\x17\x82\x15\x55\xa4\xd4\xfd\xbe\xeb\xdc\xb4\x1d\x45\x51\xa7\x4f\xbe\x11\x24\xa6\x79\xce\x4b\x42\xa7\x53\x26\xb7\xa6\x49\x02\x24\xd1\x0f\xee\xde\xdf\x08\xf9\x7f\x0c\x05\x70\xb0\xdb\x75\x77\x57\xb7\x42\x0c\x5d\x98\x6c\xd7\x6c\x36\x1d\x1f\xe9\x2f\xd7\x2d\x87\x99\x30\x11\xb3\x3c\xa1\x39\x48\x08\x80\x15\x35\xe0\xeb\x06\x5b\x1d\x96\xbd\x37\x69\xff\x17\xbc\x53\x61\xb9\xa5\x92\x13\xaa\xf2\x57\xb3\xcf\x53\x5e\x94\xc1\x53\x3b\x0a\x38\x1d\x98\x1c\xf6\x15\x57\x04\xdd\x17\x26\xe9\x82\xcf\xc3\x30\xed\x21\xb4\x9b\x43\x8a\x9d\xcf\x01\xdb\xd9\xbf\x81\x34\xe0\x88\x44\xc1\x73\xb5\x6a\x03\x7c\xf8\x90\xdc\x6b\x3e\x10\xeb\xb3\x56\x32\xd6\x55\x93\x47\x2f\x78\x7f\xd4\x1f\xdf\x95\x77\xb2\xe7\x51\x6f\xf2\x6a\x18\xaf\xeb\x0d\xa7\x91\x76\xaa\x37\xad\xac\x97\x3d\x36\x0b\xb9\xd4\x93\xcd\x06\x4f\x7b\xfc\xc4\x77\xae\x27\x9b\x35\x6f\x7b\x6c\x56\x75\xaf\xb7\x15\x16\x82\x10\xeb\xce\xf5\x0a\x72\xc8\xeb\xbe\xfe\xd9\x11\xd2\x6a\xdd\xf3\x1e\x9b\x86\xdc\xec\xc9\x66\x83\xf7\xbd\xf7\x49\x93\x7f\xbd\xfd\xba\xd9\x03\x7f\x31\x20\x7f\x0c\x0d\x5e\xf8\x1e\x88\x06\x47\x7b\x0b\xa4\xd1\x13\x7f\x21\x18\x7f\x20\x61\x6f\x7c\x77\x4d\xab\x4c\x27\xb4\x01\x42\xfc\x09\x61\x4c\x0b\x16\xd3\x78\xcc\x40\x02\x53\xb4\x59\x7b\xe6\x77\x08\x8f\x0f\x54\x45\xdc\xea\x23\xe0\x6f\x2b\x3a\x98\xb4\x39\xab\x92\x3c\x58\x9b\xe2\xf7\xe1\x48\x73\x82\x74\xdf\xd1\x6a\xe2\x2d\xc9\xc6\xde\xd1\x69\x34\x2d\x78\xc9\x65\x2b\x53\x0c\xd0\x16\x2d\xf2\xde\xcb\x5b\xf9\x8e\x14\x2e\xea\x70\x54\xf3\x43\x56\x06\x5e\x1e\xb2\x72\x61\x27\xde\xfb\x08\xfd\xe5\x17\x75\x71\xed\x88\x3a\x4e\x20\xac\x7b\x3c\x62\xba\xf8\x84\x4d\x59\x9e\x80\xbc\x24\x91\x42\xf3\x04\xc6\x3d\xd0\x29\x4d\x25\x60\x11\x55\x13\xb9\x4b\x71\x0c\x12\xae\x51\x3c\x28\xa7\x3c\x9b\x0f\x53\x88\x0a\x20\x3c\x4b\x58\xa1\x85\x09\x11\x81\xd5\xa0\xdf\xeb\x0d\x07\xd1\x84\x61\xce\xcd\x55\xdd\x5c\xb4\x6c\x48\x57\x9a\xff\x8a\xba\xa3\x07\x4f\x23\xfc\xad\x22\x91\x74\x0c\xc8\x8f\x5c\x94\x36\x7d\x7f\x38\x5c\xa9\xa3\x82\x30\x30\x75\xfc\x4e\x2e\xf7\x99\x4d\xbc\x89\xfc\x30\xc3\x6e\x24\xc1\x16\x13\x1d\xe4\xa6\x8a\x98\x83\xa2\xf3\x11\x39\x2a\x66\x4c\xa7\x5b\x94\x24\x95\xa5\x2c\x01\xe9\x09\x22\xd8\xa0\x4e\x90\x0a\x7e\x90\x7f\xdb\x9a\x3c\xf0\xf1\x7f\x80\x3b\x33\xf9\xf2\x7a\x7b\xff\x9d\xda\x9f\x57\xd8\xf0\x68\x0c\xa1\x7e\x09\x66\x50\xd3\xf0\x22\xf8\x48\x1d\x67\x5f\x06\x9c\x67\x8c\xe6\x57\xde\x18\x64\x53\xa7\x57\xff\x4b\xa8\x29\x94\xd3\x6c\x85\x3c\xea\xd9\xc0\xb8\x54\xc0\xa1\x68\x32\xbd\xb5\xe5\x07\x48\x0a\xaa\xab\x7b\xf7\xe0\x19\x54\xed\xca\x75\xd0\xdd\x11\x12\xe5\x26\xd9\xf9\x79\xe7\xdd\xce\xde\xd1\xe9\xde\xfe\xf6\x0e\xd4\xc8\xac\xb5\xd8\xde\x7f\xf3\x61\xd9\x26\x6f\xdf\x6f\xfd\xed\x9a\xb6\x6f\xf6\xdf\xd9\x16\x0f\x1f\xda\x16\x2a\x8f\x89\xa4\x69\x82\xe4\x03\xc9\x09\xd0\xc9\x78\x75\x96\x0b\xf4\x75\x68\x75\x3a\x7e\xa4\xf8\x88\x95\x40\x24\xef\x39\x2f\xd5\x3a\xa0\xd4\x83\xf8\x88\xf5\x2f\x44\x0a\x5c\x5a\x2b\xcf\xea\x7a\x97\x15\xd5\xd2\x34\x5c\x80\x92\x0a\x0c\xfb\x89\xb6\x0a\xaa\x41\x01\x60\x57\x92\xad\x7d\x60\xd3\x62\xd6\x03\x20\x51\x45\xa1\x78\xf9\xf6\x8c\x1d\xf1\x9f\xd9\x88\xc6\xf3\x1f\xd9\xac\x48\x45\x99\xc6\xd5\x89\x42\xba\x35\x8b\x12\xbc\x34\x2f\x87\xa8\x0d\x8f\x78\x5c\x20\x0f\x1f\xba\x30\x17\x50\x52\xa5\xe1\x98\x0a\x9b\x93\xe6\xfd\xfe\xfe\xd1\xe9\xd6\xd1\xd1\xfb\xdd\x1f\x3e\x1c\xed\x40\xce\x9f\xea\x9a\xe2\x6c\xb7\x66\x25\x7f\xcb\xe3\x99\xf0\x59\x82\x64\x55\xe1\x48\xcf\xf9\x94\xf9\xa1\x9e\x9e\xfa\xb1\x1e\xfd\xd9\x98\x79\x23\x10\xcf\xa9\xd0\x81\xc5\x7e\xa8\x1e\xd9\x86\x5f\x3d\x0a\x78\xae\x11\x28\xb7\xf7\xdf\xbd\x67\x79\xc2\x0a\x56\x90\x4d\xa4\xe9\xf7\xaa\xa4\x0b\x2b\xda\x72\x9c\x72\x49\x38\x2f\x71\x7e\x20\xa7\xf7\x1d\x31\xdd\x4b\xe1\xb8\x1b\x70\x36\xc6\xa3\x85\x40\x30\xf1\x13\x2b\x60\xe7\x4e\x76\xa6\xda\x3b\xb3\x64\x24\x08\xde\xac\xe9\x86\x67\xad\xd1\x4f\x2b\x26\x1b\x6f\x23\xf4\x83\x6f\x3c\x96\x60\x15\xa3\x5e\x25\x0b\x1c\xcf\x02\xae\xf3\xda\x35\xb2\x93\x3e\x69\xfd\x75\x58\xd0\x11\xfc\xe5\x26\x47\xd2\x34\xdf\x38\xb9\xc0\x96\xd4\xff\x73\x91\x06\x30\x5e\xc3\x3f\x91\x79\xfe\xe1\xfd\x2e\xe9\x83\xe6\x49\xee\x50\x9b\xe9\x4a\xa9\x1e\x5b\x5e\x9a\xa6\x4a\xe2\x6b\x7d\xc3\xae\x25\xc0\xae\x26\xee\x32\x9b\xb0\x8a\x0f\x8f\x6d\xbe\x6e\x98\x9e\x8d\xac\x26\xfd\x70\x93\x2a\xb6\x2a\xb9\xbc\x1c\x7e\xe7\x4e\x5b\x32\x72\xc7\x99\xd8\x59\x33\xfb\x41\x49\x47\xba\x18\x7f\x08\xa5\x75\xbc\xb9\x5d\x77\x01\xde\xf5\x18\xc4\xff\xba\xaa\x16\x93\x36\x13\xef\x93\x20\x1f\x05\xf3\xba\xcb\xc6\xa7\xf4\xda\x5b\xb6\x5a\x4e\x17\xac\x57\x1d\xdb\x6c\xf5\x2f\x76\x7a\x7d\xfb\xd3\xbf\x60\xf6\x2b\x3d\x5e\xb9\x3a\x41\x7d\xe6\xb8\x59\xd9\xae\xba\xc8\x14\x00\x55\x0d\x5c\x01\x17\xd9\x79\xa9\x90\xa7\xd0\xe2\x22\xa7\xd6\x74\x9b\x9d\x9b\x4b\xb7\xf3\xd8\xc3\xd1\xe2\x55\x0b\x81\x8c\xf2\x86\x75\xac\xe1\x7c\xbd\x01\xe9\x41\xa8\xee\x87\x08\x78\x89\x95\x38\x5d\x6e\x29\xd6\xfd\xb5\xb0\xc8\xaa\xa7\xcd\xab\xe1\x49\x75\xdb\x84\x9b\x10\x51\xeb\x75\x3d\x98\x0d\xb2\x34\xde\x35\xe1\x1c\x76\x55\xab\xb1\x24\x5a\xed\xe1\xec\x5b\x00\x32\x2d\x98\xec\xe6\x2d\x97\xc2\xf0\x24\xf5\x28\x43\x7f\x5b\x95\x8a\x53\xfd\x5b\xef\x86\x06\xe1\x78\xc4\xca\xc3\xc0\x1b\xfb\x55\xa9\xe1\xc0\x39\x67\x67\x06\x55\x70\xb6\x86\x25\x5b\x30\x28\x15\xeb\x6d\x3a\x68\x87\x06\xb1\x78\x7c\x96\x07\x39\x43\xf1\x26\xab\xbe\x0f\x5f\x0b\xd4\x60\x51\x7f\x12\x5a\x03\x47\xb0\xe8\x86\xd9\x67\x97\x8c\xdd\x7d\xa7\x45\x72\xfd\xfa\x47\x9a\x27\x99\x77\x42\xd7\x89\xca\x3d\x90\x1d\xcf\x72\xa5\x3f\x94\xd7\x2f\xbb\x01\x51\x89\x18\xc7\x90\xa4\x0b\xec\x58\x3a\x84\x3c\x1f\xb9\x19\x96\xc7\xd5\x1d\x3e\x0e\xed\xed\xfa\xe5\xbe\x6d\x37\x55\xb7\x02\x24\x0a\x18\x8d\xbc\xab\x35\x0a\x42\xa6\x3c\x40\x43\xfd\xdf\x50\xab\x40\x6e\x72\xb8\xb1\xc1\xc7\x44\x65\x22\xf7\x3f\xdc\x58\xa9\x1c\x5a\xd7\xab\x4b\xdb\x0b\xe6\x13\xe4\x26\x0d\x28\x42\xe4\xe0\xe0\xba\xd5\xae\x6b\xe9\xb5\xea\xeb\x3d\x6e\x60\x95\x55\xf6\x63\x93\x78\x54\x35\x81\x4b\xd1\x65\xa5\x63\x35\xb0\x9a\x3e\xa6\x1d\x26\xd9\x40\x09\x9b\xaa\x7a\xa6\x31\xcb\x88\xe2\x54\xf6\xb5\xd9\x69\x50\xfb\x32\x51\xfa\x47\xe0\x95\xf5\x73\xcc\xce\xc0\x49\x10\x45\x88\xff\x32\x42\x48\x00\x02\xad\x57\x96\xf7\x0c\xd3\x1c\xf2\x3a\xbb\xdd\x14\x2c\x77\x7b\xf2\xb2\xc4\x5c\x8b\x4b\xe3\xa8\x14\x50\x9d\xde\x14\x94\x87\xa1\xa5\x2f\x35\x55\x66\x8f\xe5\x1e\x17\xcf\x88\x67\x89\x29\x29\xab\x4b\xf3\x5c\xcf\xc2\x42\x42\xc3\x32\xcc\xc4\xab\x3b\xa0\xf2\xe0\x99\x4d\x0e\x69\xde\xf0\xa5\x1e\x95\x7d\xe9\xd5\x0e\xaf\x7e\xd9\x58\x44\x3c\xd8\x30\x54\x4d\xbc\xce\x48\x6a\x1f\xff\x9b\xf0\x12\x4f\x48\xf4\x35\xf3\xb7\x59\x7e\x4b\x5c\x26\xe5\xf2\x91\x2d\xc4\xd0\x70\x1a\x56\x84\x92\x52\x5f\x4a\xec\x3d\xf9\x1a\x96\x7f\xa3\x83\xa1\xd6\x2a\xd1\x99\xc6\xb3\xf9\xa1\xdc\x94\xb9\x4e\x03\x0f\xb1\x4b\x18\x00\x0e\xe6\xa3\x85\xad\xef\x69\x1d\xac\x2d\xce\xb0\xf0\x83\xe8\xf4\x74\x0c\xb9\xea\x9d\x09\x54\x90\xb7\xcd\xa6\x45\xca\x8b\xb4\x4c\xff\xc1\x0e\x67\x83\xb2\x60\x4d\xf2\x44\x05\x83\x5a\x8f\x80\x25\x70\x2a\xa2\x89\x5c\x8f\xa0\x78\x02\x32\xc7\xed\xe5\x92\x9b\x6e\xf6\x05\xa4\x8c\xdd\x5d\x2f\x39\xd8\x63\xae\x6c\x32\x64\x2d\x9a\xde\x8d\x4f\x33\xdd\x8b\xcf\x80\xf5\x53\x85\xef\x95\x15\x42\x72\x7e\xd1\x97\xff\x81\x50\xf2\xc9\xac\x04\x51\xb3\xaf\x75\x48\x20\xcc\x42\x56\xd7\xc5\xcc\xd7\xee\xb9\xc5\x98\x27\x5e\x11\x1c\x79\x08\x68\xd9\xfa\xaa\xeb\xf4\xb8\x98\xdf\x57\x8b\x8a\x37\xee\xff\xeb\xc6\xe2\x17\xbb\xc6\xd2\xf5\x63\x68\x43\x04\x37\x85\x5c\x95\x67\x72\x1a\x8f\x55\x13\xaa\xc2\x0c\x78\xce\x04\x38\x57\x5b\x70\xe0\x6a\xad\x03\x85\xb1\xe4\x29\x02\x2c\x84\x5f\xb7\xb9\x41\xac\xd0\x63\x77\xab\xe8\xf9\x55\xc8\xdd\xa4\xb0\x4a\x35\xee\x80\x5d\xae\x2c\x79\x13\xc6\xfc\xa5\x80\x3b\x4d\x03\x6b\x74\x84\xa5\xd0\xca\xba\xa5\x75\xac\x17\x88\xb7\xc4\x12\x70\x7d\x99\x4b\x67\xe7\xc3\x08\xd1\x6f\x2f\x67\x17\x47\xce\x61\x4d\x88\xdb\xce\xd5\x9d\xeb\x96\x5e\x87\x8e\xec\xb4\xb4\xf8\xb5\xa4\x00\x16\xea\xe3\x88\x9b\xed\xeb\x76\x67\x14\x45\xb5\x9e\x16\xe8\xd9\x5d\xa5\x97\x7b\xca\xdb\xe6\x4e\x2e\x41\xcc\xa6\xf8\x03\xd4\x19\xc6\x31\x76\x89\xaf\xd3\x26\x21\x07\x26\x0b\xab\x69\x8e\xe6\x44\xc6\xb9\xba\xfd\x5c\x8b\xd0\xae\x2a\x7c\xfc\x66\x21\x76\x43\x43\x77\xbf\xdb\xa8\xf7\xef\x68\xee\xeb\x43\xa9\x22\xbb\x61\x14\xbf\x27\xe6\xeb\xc3\x5f\x88\xfb\xa5\x41\xf8\x5b\x74\xc2\xcf\xd9\x2d\x29\xdb\x01\x12\xa2\x6c\xe7\xf5\xdb\x82\x4f\xfe\x49\xb4\xdd\x34\xc8\x85\x38\x5d\xf0\x91\x39\x94\xaf\xe0\xe0\x1b\x6b\x33\xba\x39\xf9\x68\xae\x4c\x4d\x8b\x74\x55\xde\x15\xc8\x9f\x74\x5a\x35\x27\x80\xf8\x55\x35\x36\xd6\xb5\xb5\xd0\xcc\xfb\x38\x90\x1e\xd4\x99\x6d\xc5\x70\x47\x9c\xab\xb8\xce\xba\x37\x86\x3c\xfd\x17\x64\xc0\x58\x4e\x0a\x4c\xd5\x2f\x8f\x11\x9a\x9b\x14\x6a\xee\x49\x12\x50\xbc\x59\xde\x6d\xd0\xd2\x24\xa3\x39\xa8\xf1\x38\x76\x25\x39\x2d\xfa\xd4\x86\x50\x74\xb4\xf3\x7f\xea\x34\xd1\xeb\x91\x1d\xc8\x56\x8b\x62\xa8\x2d\x1a\x05\xc9\xe6\xc0\xbb\x0f\x44\x5c\x38\xb6\x59\xc1\xc8\x05\x16\xc7\x62\x90\xf2\x0d\x12\xd1\x29\xf7\x40\x37\x4b\xfa\xed\xb0\x67\x9d\x3b\x97\xc1\xdc\x88\x95\x7b\xec\x73\x69\xbd\x62\x0e\xd3\x41\x06\xee\xd9\xcd\x2a\x50\x6b\xb0\x22\x2e\x4d\xb0\xcf\xa5\xfa\xd8\x4d\x4e\x70\x96\x4e\x49\xce\xf3\xd5\xb1\xe9\xc1\x4f\xa0\x7b\x31\x4e\x33\x46\x8c\x25\xdc\xb7\x4b\xd7\x68\x33\xd8\x22\xb8\x34\x6a\x78\xd8\xba\x3e\xb4\x2b\x1f\x37\xb9\x92\x3e\x5d\xbc\x40\xbe\x0a\x8b\x98\x6b\xd8\x59\x05\x39\xe8\xf1\x53\x61\x69\xbe\x1d\xf9\xa6\x18\x92\x20\xe5\xfc\xd9\xe7\xf2\x1a\x0c\xd5\x5a\x84\x31\x84\x63\xc4\xd6\xd7\x63\xa8\x2a\xbe\x8c\x6f\xc8\x87\xee\xe2\x86\x74\x93\xab\x46\xea\xdf\x51\x1c\x65\xee\x01\x17\x22\x1d\x64\x73\x92\xb0\x21\x2b\xd0\x2d\x74\x96\x97\x29\x14\xa4\x53\x72\x20\x99\x8e\xa9\x60\x2a\x78\x57\xd5\xaa\x53\xea\x6b\x0b\x6e\xc4\x4a\x42\xcb\x52\x8e\x27\x69\x94\xa3\x2d\x32\xfc\x14\xc0\xd7\x6b\xa1\x49\x45\x7f\xb2\xcc\x9d\xf0\xe6\x9a\xce\xda\x4a\x87\x7d\x02\x9b\x16\xb5\x66\x5b\x59\x74\x51\xf4\x49\x67\xd1\x7d\x7a\xd7\xe3\xd7\x77\x49\x17\x2e\xf4\xaa\xc5\xaa\xea\xdd\x18\x18\x8a\x3f\x93\x24\x4d\xf6\x78\xf9\x4e\xb2\x70\xfd\x9d\x99\x7b\xd3\xf4\x10\x63\x6f\xac\x6c\x12\xe8\xc4\xcc\xcb\x52\x40\xc8\x95\xb2\x79\x7c\x15\x89\x2c\x30\xce\xc5\xc3\x3b\xc2\x35\x86\xdf\x07\xee\x4a\xfb\xbd\x35\x0d\xdb\x2d\xb8\xe9\x00\x39\x6e\xf6\x1e\x3c\x41\xf5\x64\xe1\xd7\x32\xba\x83\x49\xab\xf9\xd6\x48\x72\xe1\x92\xd4\x8f\x3c\xbf\xc2\x59\x5d\x46\x90\xf2\xc3\x5a\xb0\x0c\x53\x93\xfb\xea\x82\x5e\x1d\xf3\x7a\xbd\xbc\xd5\x22\x7f\xd6\xe5\x60\x5e\x8b\xac\x5b\xd1\x45\x1d\x77\x77\x45\x0d\x77\x8c\xf9\xc0\x90\x6f\x8b\xf8\xc5\x20\x9b\xf1\xfe\x36\xcd\x1d\x80\x37\xa3\xd5\xa0\xac\x5f\xdb\x42\x0d\x9e\xcb\x8b\xc1\x2d\xd8\x56\x0d\x23\xbe\x11\xd3\xbb\xc1\x70\xc3\xc4\x7d\xdd\xde\xf7\x07\x79\x3b\x6e\xd7\x74\xa3\xba\x43\x36\xb7\x78\x8d\xc2\x63\x59\x7a\xf6\x77\xc2\xef\xff\xb0\xa9\x07\xf7\x54\x68\xb9\xcd\x5d\x59\xc8\xf3\x61\x96\xb1\x6d\x86\x65\xe0\xde\xd0\x2c\x1b\xd0\xf8\xac\x4f\x8a\xdd\x37\xd0\x62\x26\xd8\xe1\x3c\x8f\x0f\xb1\x21\x5c\x72\xee\x31\xf0\x45\xd8\x12\xde\xf3\x1f\xe6\xdb\xe8\x0f\xb6\x9b\x6b\x37\x67\xcc\x7d\x6f\x7d\xa4\x9f\xb9\x3e\xd2\x3f\xe0\xe1\x84\x7a\x43\xd1\x76\xdc\x0b\xa3\x81\xf7\x4a\xbb\x47\xcb\x49\xb3\x64\x6b\xc0\x67\x9a\xe3\x6e\x1d\xec\x92\x4d\xed\xa6\xe8\x96\xd7\x90\x70\x94\x09\x63\x37\x2f\xad\x0e\xcf\x6c\x06\x65\xa8\x54\x2a\x8e\x82\xe5\x8e\x76\xad\x8b\xe5\xc3\x54\x1f\x5d\x12\x2b\x9c\xe0\x02\xdc\xab\xf9\x28\x3b\xae\xaa\xaf\x21\xf6\xb3\x48\x69\x5e\x1a\x8f\xf5\x23\x5a\x48\x91\xd7\xfa\xc2\xa9\xd2\x60\x14\xd4\xbe\xda\x0d\xbb\xd5\x21\x7d\x23\xc7\x7a\x55\x60\xac\x0a\xe4\xb4\xd0\x0e\xaf\xa6\x73\x88\xb7\xab\xab\x64\xee\x35\xaa\x64\xb4\x48\xac\xe9\x83\x6c\xba\x8e\x9d\xd1\x50\x52\xbf\xf3\xfa\x63\x5a\x8e\xf7\xf8\x01\x2f\x4a\x9a\x89\xc5\x43\xd1\xa1\x51\x9e\x7b\x85\xdb\x55\x95\x80\xd3\x7c\xe4\xbd\x77\x1d\xfe\xe4\xf1\xe4\x2c\x48\x0b\x97\x54\x45\xc2\xed\x96\x24\xe3\xfc\x4c\xc5\x27\xc9\x3b\x06\x10\xdc\x2a\x36\x62\x09\x7c\xc9\x30\x22\x0e\xee\x29\xe0\xed\x6f\x17\xe0\x82\x0a\xa5\x09\xc3\x7c\x2a\x7c\x56\x12\xcc\x23\x0f\x70\x22\xd4\x15\xa8\x65\x82\x6f\xc5\x6c\x3a\xe5\x72\xa7\x41\xa8\x01\xe4\xe9\xc7\x4c\x44\xac\x28\x78\x21\x22\xb2\xab\x13\xfe\x4b\x62\xc1\x6f\xf4\x26\x88\x54\x05\x3f\x43\x74\x5b\x38\xc5\x92\xab\xa2\x3d\xd4\x59\xc1\x56\x6d\xa7\xae\xe8\x55\x4b\x85\x44\xb7\x5a\xa9\xe4\x87\xf9\x21\x9f\x30\x8c\x86\xd8\x24\xf7\xee\x2d\x5c\x1a\xeb\x30\x8b\x6e\xcc\x37\x75\x9f\x56\x64\x43\xc5\x1e\xcf\x71\x10\x34\xc6\x2b\x39\xf4\xad\x9c\xaa\x25\x2d\x42\xf9\x54\x5c\xce\xb7\x05\x9f\x60\xd0\x8c\x7a\xdf\xd1\x81\xcc\x7a\xf1\xef\x05\x21\x5e\x5e\x36\x4f\xb5\x4a\x09\xef\xd9\x34\xa3\xb1\x59\x39\x87\x02\xb4\x29\x56\xe5\xcb\xc9\xd9\x05\xfa\xc1\x2a\x52\x50\x4b\x11\x91\x5d\x88\xaf\x35\x45\x14\xe4\xaa\xcc\xac\x19\xc9\x80\xd1\x94\x94\x43\x06\x2b\x00\x22\x3f\x53\xa1\xf6\xaa\xdc\x03\x46\xf9\xc2\x9d\xf7\x33\xa6\x00\xb1\x00\x2c\xd0\xb4\x50\x05\x00\x01\x8a\xa4\x27\x1c\x35\x7c\x28\xc7\x69\x46\x27\x0c\x60\x3e\x04\xc2\x32\x13\x95\x64\x85\x5f\x01\xc5\x78\x58\x6d\x60\x07\x55\x6d\xe5\xbd\x9a\xb3\xab\x7c\x5a\x7b\x18\x95\xfc\xc3\x74\xea\x29\x34\x5b\x3f\xec\x6f\xff\xbd\x65\x97\x02\xd6\x41\xfe\x82\x09\xdb\xc1\x63\x30\x21\xe4\x03\x2b\x39\xd1\xce\xca\xd1\x80\x27\x73\xa2\x37\x65\x92\x8a\x98\xcf\x0a\x3a\x62\x49\x57\x25\x93\x4c\x4b\x61\xd1\x06\xd9\x8f\x86\x25\xcb\xc9\x84\xe6\xe9\x74\x96\xe9\xf8\xdf\x72\x9c\x16\xc9\xea\x94\x16\xa5\x8a\x05\xc6\xac\x6b\x02\x36\xa8\x0a\xe3\x21\xec\x73\xc9\x72\x91\xf2\x5c\xa8\x3d\x3d\xa1\x73\x92\x49\x84\x96\x9c\x88\xd9\xa0\xcc\xd4\x2a\x14\xca\x91\x3d\xa5\x2a\x0c\x45\xcc\x98\xfc\xa6\x98\xab\xc5\x81\xb4\xee\x18\x04\x6b\xf9\x88\x56\xb8\xa2\xe9\x37\x41\x50\x43\x5e\x60\x24\x33\x9d\x4e\x23\x1d\x29\xb4\xe2\x79\x73\x5f\xbb\x57\x21\xac\x43\x36\x76\x9d\xef\xbc\x98\x09\x79\xec\x39\x87\x94\x5c\xba\x9b\xc4\x54\xe0\xa6\xd6\xe9\x65\x55\x7d\x13\x0c\x4f\xd7\x84\x8b\x2c\xd4\x56\xa1\xbd\xe7\xc1\xf7\x0f\x14\x3c\x99\xed\x51\x6c\xdf\xc8\x49\x28\x15\x59\x4d\x4f\xa3\x54\x74\x7e\x13\x8b\x9b\x8c\x2a\xb5\x9f\x7b\x6e\xb8\x37\x0b\x18\x95\xea\x5a\x45\x68\x28\x38\xd7\x87\x72\xe8\x86\xd7\x87\x72\x78\x5d\x12\x3b\x55\x5b\x60\xac\x7a\xa6\xe9\x83\xdf\x6e\x0f\x25\x02\x80\x76\x75\x4c\x05\x24\x72\x99\x4d\x89\xe1\x56\x83\x39\x51\xec\x6d\x30\x2b\x95\xd2\x1b\xb9\x43\xc1\xc8\x2c\x2f\x18\x92\x3d\x26\x46\xa5\x82\x5c\xb0\x2c\xb3\xa7\xd4\x84\xcb\x25\xe4\x93\x09\xe4\xe1\x82\x73\xc9\x86\xc8\x43\x48\xfa\xaa\x76\xc0\x44\x71\x91\xd0\x02\xaa\x74\x62\x01\x34\xcb\x34\x71\x58\x51\xab\xa1\x44\xf3\xd5\x35\x56\x19\x07\xaf\x41\xef\x1f\x57\x08\xf6\x89\x19\x22\x9d\x5d\x72\x96\x0f\x82\xe2\x5e\x55\x86\x08\xc9\x83\xfe\xca\x64\xfc\xe2\x00\xdd\x5a\xe6\x2a\xac\xf2\xc1\x5a\x60\x89\xde\x84\xd9\x6b\xbb\x23\x59\x85\x52\xbd\x35\x20\x4c\x21\x5a\x0a\x05\x50\x6d\xf7\x82\x17\x67\xc8\x2f\x10\x1a\x39\x5f\x7b\x19\xa9\xa3\xca\x11\x57\xbc\x4e\xac\xd8\x00\x07\x96\x69\xa0\x7a\x6e\x77\x24\xd6\xe4\x89\x73\x41\x73\x55\xfd\x07\xec\x16\xa0\x47\xd5\x6e\x04\x4e\x41\xbb\x80\x20\x41\x8c\x96\xfd\xe2\x3d\xf2\x21\x57\xf0\x43\x1e\x16\x10\x00\xba\x3e\x63\xd1\x3e\x28\x4b\x70\x32\xb4\xe0\xcb\x47\x86\xdd\x28\x17\x44\x55\xa8\x57\x9d\x9e\xaa\x72\xac\x12\xfa\x91\xe3\xb8\x43\x9b\xe5\xfe\x7d\xa0\x5d\x77\xc7\xae\x7c\x00\xed\x9c\xb9\x18\x19\x5f\x8d\x47\x5f\xd3\xdc\x7b\x80\x16\xf2\x95\xa6\xb2\x53\x0b\x70\x5b\xae\x87\x62\x09\xf0\x4e\x88\x95\x0b\xd4\x78\xd4\xcb\x21\x6a\x29\x0a\x76\x55\x25\x9e\x0c\xd7\x0a\x85\xf2\x76\xe0\x02\x63\x43\xe6\xce\x20\x55\x0c\x2d\x46\x33\x2c\xba\x9b\xb1\x7c\x54\x8e\xc9\xf7\x64\x5d\x6e\x31\xf3\xfc\x78\x1d\xaf\x99\xa6\xf8\x37\x79\xed\xbf\xec\xeb\x50\xd3\x3f\xe6\xfe\xe3\x98\x1d\xa6\x54\x08\xb3\x1d\xc8\x14\xe6\x0c\xf9\x24\xe1\x33\x3c\xae\xa9\x40\x71\xc0\x8c\xd9\xe2\xd7\x45\xd5\x83\xb5\x10\xb2\xb4\xc3\xf8\x19\x94\xa6\x77\xd1\x6c\xe4\x63\x77\x33\x8c\xdd\xf3\xcf\x39\xd3\x97\xdc\x4b\x63\x67\x17\x49\x81\xb2\x61\xdf\x14\xb0\x69\xae\x56\xcc\x10\x9c\x78\x69\x25\x2d\xd6\xf2\x63\xe1\xb4\xbc\xbb\xaa\x33\xbe\xa6\xce\xe4\x40\x6e\x42\xd9\x88\x2c\x87\x9c\xaf\x36\x82\xa3\x54\x97\x1e\x7f\x98\x77\x3d\x38\x1c\x4c\xf3\xc0\xbc\x12\x91\xaa\xe6\x8b\x4b\x11\x7d\xef\x2f\x50\x77\xc8\x0b\xf0\xf6\xfe\x3b\x2c\x01\xe9\x3a\x45\xa8\xad\xbc\x5f\x54\x7c\xa5\x5c\x39\x88\x5f\xe0\xf2\xe1\x6d\x06\xaf\xc3\xfb\x17\xce\xdd\xd8\xbd\x1a\x63\x63\xed\xc7\x59\x75\xfb\x75\x0e\xb7\xf7\x6c\x28\x76\xf3\xf7\x7a\xd9\xe1\xbb\x08\xae\x10\xe0\x4d\x71\xda\xd0\x74\xa3\x76\xd9\x6e\x68\xd8\x25\xad\x6f\x40\x90\xa0\x71\xcc\x04\xdc\x83\x1d\x2c\x48\xa9\x21\x4d\x50\x2c\xd7\xc7\x55\xa4\xa5\x66\x75\x7a\xd9\x8c\x63\x94\x4c\x67\x05\xb3\x88\xd3\x6e\xa9\x58\x23\x5d\x8e\x39\x92\xd7\x77\xf5\x01\x40\xc1\x3a\xf5\xd8\xb7\x93\x04\x0f\x3c\xf6\x0a\xf6\xdb\x2c\x2d\x98\x90\x9f\x66\x8c\x24\xb4\xa4\x58\x04\x0f\x7d\xfc\xd8\x79\xca\x67\xc2\x1d\x4c\x97\x88\x59\x3c\x26\x70\xc1\x1f\x8a\x88\xbc\x33\x05\x6c\x33\x3e\x4a\x63\xac\xf3\xaa\x96\x72\x3b\x4d\xc0\x1b\x12\xc6\xe6\xdf\x0b\xb7\x53\x75\xd8\xe8\x1b\x58\xd4\xea\x42\x88\x94\x6e\x20\xaf\x46\xb8\x82\x1d\x29\x7b\xb7\xb6\x2c\x58\x57\x7c\x5a\x76\xad\x2a\x52\x8b\x7b\x64\xa3\x0a\xa8\x4a\x7d\xa4\x46\x36\x35\xef\x87\x45\x9f\x37\x0b\xc8\x35\x80\xf5\x8f\x37\x6a\x9a\x89\x5c\xa8\x88\xec\xd0\x3e\xd9\x30\xe3\x90\xed\x6a\xf0\x17\x69\x9f\xf0\x0b\xaf\x3f\xc7\x57\x3f\x30\x2d\xcd\x1b\x1b\x8a\xd7\xd7\x0f\xa7\x0f\xa0\xc9\x94\x64\x21\xfb\x46\x09\x9d\xab\xb2\x1a\xc0\xc0\x40\x9b\xa4\xb5\x05\xad\x70\x0a\xa7\x3a\x58\xbd\x4a\x98\xa9\x49\xe7\xa5\xce\x59\x0a\xd5\x12\x91\x3d\x98\x62\xb5\x39\x87\xe0\x6a\x20\x10\xf2\x13\x9b\x8b\x3e\x81\xec\x4d\xaa\x84\xed\x19\x9b\x8b\x10\x5e\xdd\xbc\x4d\x5d\xe3\xf6\xe4\x71\x2d\xa6\x7d\x46\x5d\x9f\x2e\x8f\x09\xbb\xd1\x5a\xe3\x82\x5f\x10\x8e\xac\x47\x97\x78\x96\xdb\x14\xf2\x97\x21\xf0\xd7\x2b\xce\xca\x2d\x50\xb3\x22\x33\x0e\x75\x2f\xc9\xbc\x2a\x0e\x61\xd0\x9d\x04\x76\xd3\xc1\xdf\x66\x24\x6a\xad\xea\x43\xd1\xc9\x19\x4e\x9b\xc1\x86\x8c\x34\x46\xd6\xab\x77\xa6\x6a\xc6\x57\x06\x7f\xaf\xfa\xa9\x4e\x0e\x29\x65\xb3\x31\x15\xd5\xd7\x9d\xb0\x7c\x55\x05\x32\x99\x09\xe5\x2c\x85\x79\x37\xf0\xb2\xf0\xc6\xb2\x27\x4f\xd0\x5a\x06\x87\x4b\xcf\x70\x01\x4a\x43\x2a\xd0\xa0\xd7\xa1\xc1\xce\x4d\xe5\xcc\x70\x1f\x4a\x51\xf8\x75\x4a\xf8\x25\x14\xf0\x21\x6b\xdc\x6d\x14\xad\xe6\x7b\xa3\xfc\xdc\x86\xf2\xaf\x2c\x2f\xb5\xb2\xd7\x6a\x5b\xef\x2d\x54\xb7\xd6\x05\x80\x7b\x4d\x50\xbb\xe4\x7e\x03\xfa\x24\xee\xc6\xe8\x5b\x25\xef\x9f\xad\x82\xc9\x4b\x27\x9b\x4c\x41\x4b\x54\x72\xbd\xb4\x98\xb7\x10\x35\xeb\x56\xab\x41\x73\x55\x1f\x96\x4f\xe7\x52\x16\x40\xfd\xba\x7b\x37\x55\x3f\x7a\x3d\xf2\x21\xbf\xf6\x56\xf8\x15\xf7\x42\x72\x3d\x73\x50\x92\x63\x8d\x33\x84\xc1\x91\xeb\x2f\xbd\x5e\x72\x81\x2b\x3b\x59\xd7\xa9\x4a\xe9\x9d\xe1\xde\xdf\x64\x20\xb8\x48\x41\x69\x43\x7e\x9b\xa5\xf1\x99\x14\x6c\x40\x3c\xe3\x79\x17\x56\x02\xca\xfd\x11\xeb\x53\xf5\x49\xb2\xd6\x4f\xf8\x55\x44\x8e\xc6\xb4\x6c\x09\x29\x7c\x61\x4d\x06\x79\xad\x7b\xed\x9f\xbc\x56\xe2\xa8\x9c\x67\x3e\x25\x9f\xde\x96\x94\x9b\xed\x06\xa7\xd7\x19\x0e\x4e\x2b\x96\x03\x35\xdd\x37\xba\x0e\x16\xba\x9e\x99\x3d\x5d\x0a\x96\x0d\x31\xe7\x10\x6e\x16\xb8\x5f\xb8\x5e\x9d\xda\x94\x62\x46\x6d\x26\xe4\xe7\x8b\xf0\xdc\x24\xe4\xf8\x9a\xb9\x91\x63\xb6\xc2\x9c\x7d\xf7\x82\x4e\xcf\xc1\xeb\x4d\x7d\x87\x86\x90\xf5\x7b\xed\x4e\xc4\x91\x94\x7e\x0d\x37\x2c\xf9\x74\x35\x63\xe7\x2c\x73\x90\x81\xd2\x48\x10\x67\xaf\x49\xeb\xef\x7c\x06\x6a\x75\xcc\x70\x1a\xc7\x69\x22\xef\xe5\x59\x36\x57\x89\x89\xb1\x60\x56\x65\x39\x8c\x61\x03\xc4\x6e\x3e\x44\xa5\xbf\xb5\x82\x91\x3e\x69\x19\x93\x9a\xb1\xaa\xa8\x42\x02\x46\x16\xd2\x46\x15\xf9\x31\x9a\x54\x8c\x24\x5f\x30\x25\x0a\xa6\x39\xe1\x05\x58\x57\xb8\xb2\xf9\xa9\xb4\xd8\x35\xa1\xce\xe1\x46\x7e\xfe\x1b\x47\xca\xd2\xe9\x31\xd9\x64\xca\x0b\x5a\xcc\x09\xcd\x52\x2a\x94\xe1\x02\x4a\x22\x14\x8c\x26\x73\x22\xc6\xe9\x74\xca\xf4\xd9\xbb\xf6\x82\xbc\x7f\x83\x96\xa8\x14\x34\xea\x46\xe6\x52\x23\x32\x9a\xc2\xb5\x97\x91\x2b\x80\x5c\x73\x57\x35\xed\x7c\x3e\xd8\x27\xfe\xdf\x7e\xdb\x44\x59\xfa\x4d\x63\x97\xa5\x56\x5e\xe2\x8d\x38\x9b\x89\xf1\xe1\x3c\x8f\xfd\xa6\xe6\x31\x34\x3a\x3d\x3d\xdc\x79\xf3\x7e\xe7\xe8\x74\x77\xef\x68\xe7\xfd\xde\xd6\xcf\x87\xa7\xdb\xfb\xa7\x7b\xfb\x47\xa7\x1f\x0e\x77\x4e\xf7\xdf\x9f\xfe\x7d\xff\xc3\xe9\xc7\xdd\x9f\x7f\x3e\xfd\x61\xe7\xf4\xed\xee\xfb\x9d\xed\xbe\x95\x3f\xdf\xf2\x82\x1c\xd1\xe9\xce\x39\xcb\xcb\x83\x6c\x36\x4a\x73\x15\xa2\x95\x0a\x32\xe5\xd3\x59\x46\x71\x1d\xa7\x2c\x57\x79\x70\xe1\x4b\xa7\xfd\x8f\xb3\x41\xbf\xf2\x77\x57\x43\xff\xa0\xd4\xe1\x25\x13\xe5\xea\xac\x4c\x33\x51\xfd\xfa\x3d\x1b\xa5\xa2\x2c\xe6\xfd\xd0\xc3\xae\xd3\xba\xe0\x53\x3a\xa2\x25\x2f\x44\xbf\xf6\x04\xdb\x29\xd1\x5e\x67\x7f\x33\xfb\xb5\xdf\xf8\xc6\xf9\x6e\x7b\xff\x9d\x79\x7c\x04\xd1\x97\xc1\xc7\xfe\x17\x30\x8e\x9f\x53\x51\x32\x90\x4b\x83\x8f\x31\xff\xd6\xc6\xca\x8a\x14\x67\xd0\x79\xe3\x0d\x10\xd3\x7b\x63\x63\x32\x1a\xe7\xd8\xbc\x70\x75\x37\xf6\xa9\xab\xcd\xc2\x22\x77\xc2\xb5\x52\x8d\x8d\x7d\x4a\xbd\x74\x85\x5a\xf5\x28\x32\x8d\x36\xdd\x7b\xaf\xf1\x99\xbe\x58\xac\x7a\xdb\xf0\xf2\x9c\x0e\xf9\x2c\x4f\xb6\xd9\xf9\x11\xe7\x99\xa8\x28\xe2\xd0\xdb\x44\x9e\xf9\xba\x01\xe4\xa9\x92\x57\x3d\x74\x41\x99\xbb\xb7\x4d\x4c\x87\x04\x85\x84\x6a\x67\x91\xc4\xf9\x60\x96\x27\x19\x1c\x0b\x7d\xb2\x26\x1f\x9c\xb3\x42\x40\x98\x09\x0c\xf7\x17\xfc\xcb\x5e\x66\x58\x71\x80\x59\x53\xf7\xe8\x84\xf5\x25\x4f\xa2\x71\xb9\x9a\xf0\x49\x0b\xfd\x62\x4c\x02\x37\x7f\x0a\x0f\x1f\x92\x9d\xcf\x2c\x9e\x49\x54\xed\xe4\xe7\x69\xc1\x73\x10\x4e\x63\x9a\x7f\x10\x4c\x8a\xab\x0f\x1f\x92\x8b\x34\x4f\xf8\x45\x54\xf2\x29\x20\x51\xfd\x29\x8f\x3f\xe7\x5e\xb7\xeb\x14\x8a\x7c\x33\x2e\xf8\x84\xc9\xeb\xdd\xdb\xb4\x60\x43\xfe\x19\x5c\xa1\xce\xd3\x44\x5e\x14\x12\x7e\x91\x43\x62\xc4\x2c\xcd\xe1\x5c\x95\x87\x01\xf8\xe2\x49\x52\xb5\x36\xc0\x9c\x9e\xa7\x40\xed\xd1\x4c\xb0\x62\x6b\x24\x87\xa5\x8b\xf9\xb4\xb0\x87\x56\x87\x7c\xaf\x4a\xc2\x2e\x6c\xbd\x93\x8c\x64\x5b\xac\xfb\x03\x29\x99\x16\xb5\x56\x63\x56\xc0\x7d\xe3\x23\xe8\x1c\x63\x2e\x05\x14\x85\x86\x8c\xc7\xa0\x18\x8e\xf4\x2b\x47\xee\xda\x86\x58\x12\xbc\xe2\xe6\x84\x7d\xe6\x65\x1a\xab\xf2\x33\xe0\x4d\x12\xc3\x2c\x56\x8d\xe5\xb8\xdf\xeb\x45\x8e\xd2\xae\xf7\xff\xda\x50\x4f\xea\xf5\xe5\x30\xcd\x58\xa7\xff\x40\x25\x21\xd7\x3d\x75\x2a\xc1\x4f\x82\x67\x2c\x4a\xf3\x21\x6f\xb7\xbe\x89\xb7\x35\x9a\x8d\x0d\x88\x98\x55\x37\xb6\x63\x4a\x06\xac\x2c\x59\x41\x12\x79\x0c\xf3\x29\xe8\x11\xd8\xe7\x29\x2b\x52\x06\x44\x0a\x2d\x75\x51\x2b\x37\x3f\x65\xc2\xce\x4b\x09\x4b\x36\x68\x5b\xac\x80\x2e\x24\xcd\x58\xbf\x25\x8f\xeb\xff\xce\xe1\xc0\x4e\x47\xe3\x92\xe4\x4c\x39\x3c\x08\x49\x04\x12\x6b\x19\xf9\xf1\xe8\xe8\x40\x1b\x92\xda\x8e\xfb\x01\x40\xe8\xf5\x3a\x4b\xf4\xbf\x3a\xa4\xbf\xc1\x09\xde\xea\x74\xe5\x9c\xf2\x72\xf5\x82\xc9\x0e\xfb\x03\x9e\x25\x21\xc3\x14\x24\x07\xf4\xb5\xb5\x0f\xd6\xc9\xa6\xd6\x80\x0c\x0b\xc6\xfe\xc1\xda\x5f\x56\xfe\xa2\x33\x8e\x11\xdf\xc3\xcc\xfb\xf0\x29\xd9\x24\x6d\x17\xce\xc3\x87\x56\x07\x0c\xda\x3a\xfb\xce\xcb\x7d\xcc\xe2\x14\xb5\x3f\x72\x79\xac\x20\x84\xe9\xae\xa1\x2a\x78\xb4\xa2\x03\x89\x20\x96\x28\x3e\x9b\x83\xc1\x76\x42\xcf\x98\x20\x69\x09\x96\x3f\x3c\xe7\x07\xbc\x1c\x93\xf7\x3c\xcb\x66\x98\x9d\xf4\x3f\x99\x28\x31\x4d\x32\xe0\x6a\x9b\x4f\xb4\x9a\x18\x86\x7c\xdc\x52\x33\x6b\x9d\x90\xd7\x0d\xcf\xfb\xce\xf3\x8d\x95\x95\x09\x4f\x66\x19\x8b\x70\x74\x42\x67\xe4\xdb\xe6\x90\xd3\xff\xaa\xd3\x46\x63\x46\xef\x11\xf9\xb8\xf3\xc3\xc1\xd6\x9b\x9f\xc8\x2f\x5b\xef\xc9\xee\xde\x7f\xee\xbc\x39\xda\xdd\xdf\x23\x8f\x7a\x57\x91\xbc\x7c\xb4\x15\x80\x2e\x39\x3d\xbd\x60\x83\x29\x8d\xcf\x4e\x95\xd6\xf5\xf4\xb4\xfd\xb4\xd3\xe9\x40\x7e\xd1\x47\x3d\x72\xd5\xe9\x4a\x70\xcf\x9e\x7c\x47\x1e\xf5\xd4\x33\x73\xe5\x6a\xe3\x70\xba\x64\x11\x38\xb9\x37\x56\xee\x4b\x6a\x13\x50\x7d\xf5\xfe\x86\x4e\x5d\xfa\x86\x4f\xe7\x05\xd0\x64\x3b\xee\x90\xf5\x27\x6b\x4f\x57\xa7\x05\x13\xa0\x63\x78\x4b\x63\x36\xe0\xfc\xac\x4b\x76\xf3\x58\xa7\x2b\x85\x45\x70\x72\xe2\xcb\x05\xc9\xd2\x98\xe5\xf2\xb0\x9f\x19\x77\x9a\x77\xbb\x47\xfa\x31\x1e\x14\xaa\x36\x9d\x04\xf1\xf3\xee\x9b\x9d\xbd\xc3\x1d\xa0\x6c\x5d\xb2\x0e\x04\x54\xf4\x5b\xe1\xc5\xdc\x78\xfd\xa8\x8e\xe4\x05\xd2\xe4\x4b\x2d\xe7\x53\x06\xb5\x55\x04\xa4\x30\x55\xe4\x3b\x9e\x4f\xc7\x2c\xc7\x03\x30\x84\xd0\x67\x6b\x4f\x34\xc1\x4e\xc4\x81\x94\xd5\xa1\x0c\x4a\xef\xff\x4d\xc4\x6a\xcf\xa6\x72\xfd\x51\x83\x81\x4c\xf4\x74\xc2\x32\xc9\xa2\x12\xf2\xe6\xf0\x10\xf4\xe9\xac\x28\xe7\x90\x59\x09\x7c\x15\x09\xfb\x4c\x27\xd3\x8c\xf5\xd5\xd8\x08\xf9\xde\x0e\xe4\xb0\x9c\x67\x70\x02\xb5\x5b\x03\x1a\x9f\x8d\xc0\xf4\xff\x86\x67\xbc\x68\x75\xb0\xf1\x2b\x72\xdf\xbe\x59\x8d\xe5\xab\xfb\x8b\xc0\xbc\xe3\xff\x38\x2a\x68\x2e\x52\xd4\xae\x1a\x20\xab\x13\xfe\x8f\xd5\xd2\xbc\x59\x08\x63\x22\x1a\x40\x88\x0a\x04\xf9\x6a\x4b\x90\x77\x3c\x61\x45\x9e\xfe\xa3\x20\x62\x36\x1a\x31\x51\x0a\xd2\x56\x29\x7a\x27\xfa\x55\x14\xf3\x49\x2f\xe1\xb1\xe8\xfd\x75\x5a\xb0\x61\xfa\x99\x25\x9d\x2e\xa1\x39\xf9\x34\x11\x9f\x08\x3e\x92\xe0\x40\xfa\xcf\xcf\xd1\x15\xa2\xe4\xe4\x93\xec\xf5\x53\x35\x11\x2e\x06\x27\x5e\xa9\x20\x45\x2f\xdb\xad\x7a\xe5\xa7\xae\x0d\xcc\x12\xdb\x79\xe9\x6b\x4d\x2b\xfd\x32\x2a\xd0\x2f\xa0\x6d\xc8\xa1\x4b\x5a\x72\x40\x2d\xdc\xc0\xb5\x6d\x5e\xef\x67\xa3\xba\x43\xd7\x9e\xdc\xe1\x0e\x5d\xf9\x1f\xb4\x47\x41\x9d\x31\x9b\x4e\x59\x21\xb7\x93\xb3\xfd\xda\xc7\x5b\xab\xff\xf7\xa4\xd3\x1b\x5d\xbf\x05\x75\xbe\x9b\xeb\xf6\xdd\x4d\xb7\x9b\x7c\x29\x2f\x42\x72\x8b\x43\x51\x51\xcc\x9c\xd6\x85\xd3\xf9\x53\x7d\xd5\x3f\x99\x3b\x34\xde\x95\xe4\xd9\x23\x14\x73\xc8\xe6\x12\x1a\xba\x3e\x66\x19\x39\x67\x79\xc2\x0b\xb5\x03\x18\xe4\xd2\x88\xb3\x59\x92\xe6\x23\xd8\x1a\x77\x46\xf9\x21\x82\xc7\x47\x86\xca\x6b\xd8\x97\xd4\xfe\x60\xad\xd5\xa9\xa6\xb9\x5c\x48\xfa\x75\x8a\x5f\xfb\xf3\x4c\x6a\x3c\x93\x80\x78\xd3\x7f\x34\x1f\x49\xeb\xe1\x23\x69\xd5\x3f\x93\xde\xe8\x3d\x20\x37\x84\x59\x8a\x9b\x9c\x49\x7a\x20\xc1\x23\x09\x77\x42\x70\x93\xbc\xf1\x8e\xa4\x00\x94\xca\xc9\xe3\x00\xf1\xce\xaa\xc5\x20\x44\x18\x82\x7b\x52\x39\x07\xd2\x56\x9e\xa4\xe4\x70\x22\xb7\x98\x3e\x91\xe4\x1b\x7d\x28\x5d\x5c\x5c\x44\x34\x4f\x52\x21\x5b\xc0\xc1\x34\xc8\xf8\xa8\xb7\xfe\x64\x6d\xbd\xf7\x64\xdd\x9e\x59\xab\xfa\xa4\xea\xa9\xa3\x6a\x75\xf1\x59\x95\xc9\x3d\x02\x29\x89\xef\x62\xe7\xd6\xf1\x10\xd8\xc1\xba\x51\xbb\xb2\x95\xdd\x03\x0b\xce\xab\x86\x5d\x5b\xeb\xa4\xbe\x7b\xd7\xff\x3c\xaf\x9a\xcf\x2b\xdc\x6a\xce\xc6\x5c\x6d\x47\xde\x49\xd5\xb4\x31\xaf\x39\xa9\xcc\xba\xde\x70\x13\xde\x05\xc1\x2d\x73\x52\x78\xf3\x76\xad\x31\xa7\x5d\x12\x8f\x69\x41\xe3\xb2\x96\xf2\xde\x3c\xf7\xdd\xd6\xf1\x4a\xb4\x98\x3c\xeb\x54\xf9\xf4\x4e\xcf\x94\xc6\x7b\x98\x85\x3d\x2d\x78\xcc\x04\xa8\xd3\x56\xd4\xd5\x17\xfd\xf1\x54\x40\xf9\xdc\x5e\xd6\xee\x9f\x9e\x32\xf1\x0e\xc6\x72\xbf\xab\xdc\xa9\xb2\x19\xeb\x83\x3a\xcd\x5e\x8a\x4f\x41\x8f\x91\x88\xf5\x26\xde\x5f\x6d\x28\x2f\xcf\xa7\x10\x04\xce\xa7\xef\xb1\x99\x8a\xea\x6a\x1b\x58\xe6\x1b\x7f\x70\x4d\x7d\xbc\x6c\x68\xbf\xa8\xab\x0a\x64\x03\x61\xc4\xca\x03\xed\x62\xb6\x3f\x6c\xe8\xf0\xdb\x86\xe6\xeb\x0b\x3a\xf4\x5b\x1a\x00\x71\x46\x85\x78\x43\xb3\x0c\x2c\x4e\x4d\x33\xfc\xae\xa1\xfd\xa2\x19\x56\x20\x5b\x08\xe8\x3b\x28\xdf\x36\x75\x67\xaf\x90\x6e\xeb\x85\x9d\x39\x40\xcd\xb7\x53\x4c\xe8\xc0\xde\xf0\x5c\x94\xc5\x4c\x72\x27\x2c\x94\xdc\xd8\xef\xda\xf5\xdf\x2e\x1a\x45\x73\x87\x06\x6e\x9a\x8f\x59\x91\x96\xcd\x53\xaf\x37\x5d\xd4\xa3\x01\x67\xbe\x2a\x94\x0d\x3d\x08\xdc\x6f\xb5\x88\x5c\xa0\x81\xc5\x46\xc1\xa7\x47\xf3\x29\xd4\x86\x0a\x01\x7e\x52\x6f\xb9\x08\xb8\x69\x64\x3e\x1b\xc8\x23\xbf\x69\xd8\xcf\x9e\xbd\xac\x34\x5c\x04\x1c\x5b\x98\x0f\xca\x31\x9b\x30\x6d\x26\x68\xc2\xcb\xcb\xf5\x70\xfb\x45\xfd\x78\x0d\x1d\x2e\x43\x63\x30\x9a\x34\xce\xe5\xdb\x7a\xdb\x45\xdd\x98\x46\x1d\x37\x00\xb4\xa1\x35\x1f\xfc\xda\x21\x5f\xf4\x59\xc1\x07\xbf\x82\x4d\x62\xf0\x6b\x64\x99\x29\x79\x0d\xcf\xfb\xe4\x8b\xa9\x6e\x00\x0f\xae\x36\xc8\x95\x2d\xb4\xe3\x19\x10\x21\xcd\xb5\x3c\x7a\x3f\xc1\x9c\x3f\x19\x61\x18\x0a\xdd\xec\x6a\xf5\xa0\x14\x05\x74\x0b\x7a\x4e\xd3\x0c\x1c\xcf\xa0\xfc\xba\x55\x07\x43\x9d\xc3\x72\x4c\xf3\x33\xf0\x19\xc3\x87\x31\x66\x21\x89\x02\x5d\x2b\x5f\x09\x29\x2f\xb2\x02\xec\xfc\x03\x46\x20\xfe\x83\x96\xe4\xd1\x23\x23\x7e\xe8\x2a\x92\xce\xa0\x0b\xc6\x1e\x3d\x8a\xe0\x78\x96\xe8\x7e\x37\x4b\x8f\xe4\xe0\x0e\xd0\x28\xe0\xfb\x17\x9f\xc2\x40\x1e\x58\x4f\x24\x38\x71\xda\x4f\xba\xce\x36\x8c\x14\xbe\x3a\xed\x2a\xa8\x2e\xa9\x7d\x0f\x96\x6f\x03\xbf\xfa\x41\x5b\x65\x49\x89\xfd\xb4\xbe\xd0\x5f\x85\xc3\xda\x5e\xa5\x50\xd5\xad\x81\xd2\x8e\x03\xbd\x1e\xf9\x1b\xc3\x72\xf4\x7c\x56\xa2\x24\x37\x61\xd6\x97\x34\xd6\xa9\x74\x62\x9a\xeb\xca\xb9\xc6\xa6\x75\x0a\x02\xdb\x26\x0e\xa0\x99\xf5\x55\xc7\x52\x43\x44\x74\x7a\x0a\x6a\xf9\xd3\x53\x72\x79\x89\xd0\x2a\x27\x54\x33\x12\x3b\x1d\x54\xd7\x22\xe8\x0a\x82\xf4\x2c\x61\xa0\xd1\xa0\xe0\x34\x51\x0c\x03\x3a\x51\x5c\xc1\x02\x57\x2a\x78\x6c\x3e\xcb\xc5\x6c\x20\xe2\x22\x1d\xb0\xdd\xc4\x73\x5f\xc1\xf7\x80\x2f\x18\xcb\x75\x2f\x2b\xdc\x41\xf7\x17\xa5\x18\xf5\xd1\xd6\xc3\x35\xe1\x20\xda\x7c\x8a\xe6\x7d\x5c\x12\xc1\x49\x5a\xea\x65\x40\xaf\x60\x1d\xf1\x67\xe3\x31\x43\xb3\x8d\x04\x2b\x0f\x4b\x5a\xb2\x36\xbe\x98\xb0\x62\xc4\xf6\xe5\xf8\x7e\xe6\x31\xcd\x60\x90\xea\x15\xa6\xab\x85\xfe\x3a\x7e\x52\x55\x78\x6f\x62\xf6\x90\xe2\x9c\x33\x76\x11\x91\x1f\x23\x95\x9e\xb1\x79\x9f\xb4\x74\x39\x05\x95\x41\xa8\xd5\x55\xc4\x04\x32\x9a\x5b\xec\xc9\x6d\xd5\xf6\x0d\x5b\xa7\x05\x1b\x6e\x54\x5c\x12\xe4\x33\x28\x9b\xdd\xc5\xc1\x55\x44\x2a\x3b\x3e\xd9\xb0\x5b\x59\x91\xe8\xcd\x8f\x5b\x7b\x7b\x3b\x3f\x77\x89\x8f\xb9\xce\x72\xc0\x5a\x93\xca\x9c\xf7\xd1\x9c\xdb\xea\x3a\x36\x2f\x31\x66\xac\x14\xef\x68\x4e\x47\xac\xe8\x13\x07\xdd\xde\x9b\xae\xf9\x20\x49\x05\x64\x50\x93\xb7\x43\xf1\x37\x2c\xf1\x0a\x46\x55\xe7\xd3\x86\x36\xc6\xaf\xaa\xab\x70\x65\x3d\x35\x88\xbb\x18\x35\x8f\xef\x86\xe5\xa8\xb5\xab\x2e\x88\x1c\xd2\xba\x8a\x57\xd8\x70\x5c\xd7\x0e\xf5\x06\xd2\xd6\x23\x87\xc7\x74\x49\x3a\x24\xea\xe2\xa9\xbe\x08\x6e\xbb\xa6\xcd\x63\x5a\xc1\xd6\x8f\x0c\xa3\xb2\xdc\xd9\xee\x41\xd7\xf8\x88\x83\xf5\x37\xa8\xfd\x63\xc3\x75\xa7\x7a\xcb\x8b\x0b\x5a\x24\xae\x8f\x0d\xee\x45\x1d\xb4\xcc\xeb\x9b\xcf\xe9\xa2\x69\x07\xae\x2f\xd8\x82\xeb\xa1\x3d\x68\x5d\xe4\x16\x2d\xe2\xc7\x34\xcb\xde\xb3\x98\xa5\xe7\x40\xaa\xe2\xba\xc5\xac\xb6\x87\x9c\x70\x07\x7e\x4a\x12\x8f\x17\x69\x53\xa8\x8b\x03\xc7\x04\x5c\xe5\x20\x18\xc2\xa1\x61\xaa\x19\x39\x0b\xd1\xc4\xa5\x9a\x99\x54\x15\x58\x30\x7b\x47\x33\x72\x94\x23\xe5\x32\x78\x51\x4d\xdb\x95\x0c\x25\x75\xfa\x0c\x85\xa9\x34\x51\xac\xf3\x65\x85\x66\xeb\x80\x83\x51\x8a\xbd\x1e\xf9\xc8\x4c\x56\x48\xcc\xcc\x60\x65\x24\xf4\xf4\x72\xfd\xba\x28\xb8\xec\xce\xf2\x9c\xc9\xd3\x82\x42\xd0\xb6\x8a\x8e\x5f\xa9\xe3\x2a\x84\xf2\x16\xba\x76\xe1\x66\x86\xe8\x32\x02\xcd\x6c\x75\xee\x8a\xe0\x40\x73\xdc\x2e\x0e\xa5\x04\xb1\x1d\x5c\xdf\xcc\xfc\xf4\x28\xf0\x88\x13\x95\x67\x02\x17\x09\x75\x8e\xa8\x30\x62\x13\xe6\xba\x21\xa8\x08\x08\x0b\xa8\x31\xe4\xc1\x9c\x1c\xb6\x6d\xbb\x72\x72\xd7\xfd\xdf\xc0\x2b\xa5\xda\x6a\x11\xc8\x26\x0f\x3a\x38\x56\xb4\x6a\xc1\x9e\x27\xf2\xf8\xaa\x80\xef\x3a\xd0\x9a\x99\x00\xae\x6a\x03\x65\x9b\x70\xa4\x4a\x84\x89\xb3\x61\xfd\xaa\x09\xd0\xc1\x89\x5b\x20\xb0\x7a\xaa\x6f\xac\x5c\xa9\xcb\x9e\x25\x6f\x4f\x8a\xad\x89\x78\xaa\x95\x2e\x0b\x2b\x87\xd2\x78\xc2\xa1\x9f\xf1\x4a\xed\xd0\x04\xe1\xf3\x6a\x63\x25\x00\xde\xbd\x6a\x2a\x75\x51\xc4\xf2\xf3\x68\x6f\x7f\x7b\xe7\x74\x67\xef\x17\xd8\xa8\xf7\xa7\x05\x4f\x66\x80\x94\xfb\xe4\x35\x8c\x01\x6e\x2e\x84\x3c\x22\x7f\x07\xa7\xe3\x9c\x40\xac\xb8\xf5\x00\x92\x7b\x2c\x33\x45\x41\xd1\x74\x04\xf3\xfe\x8f\xb5\xe7\x5d\x42\xd1\x69\xd3\x7d\xfa\x02\xc8\xf1\x51\x6f\x85\x98\x73\xa1\xef\xde\x6f\x0d\xba\xc0\xfb\x36\x15\xea\x2a\x96\x74\x43\x83\x51\x18\x82\x1d\x35\x32\x08\x52\x94\x8f\xd6\x30\x4c\xce\x8e\xaa\x53\x74\x23\xc3\x01\xc8\x0b\x96\x12\x16\x67\x82\x0d\x67\x19\x56\x16\x2a\x0b\x0a\xde\x59\x1e\xe7\x80\xdb\x15\x9f\x95\x10\xcf\xa6\x80\xff\x78\xf4\xee\x67\x04\x64\x13\x3d\x88\x92\x4d\xf5\x49\x8e\xae\x30\xaa\xaf\x9f\x59\xd9\x12\x44\xd0\x39\xf8\x6e\x43\x70\x3e\x74\x81\xfe\x2f\x74\xca\xb3\x8c\x43\x5e\x97\xcf\x65\x01\xae\xb5\x78\x89\x78\x04\x90\x7e\x9b\xb1\x22\x65\x82\x4c\x68\xc2\xb4\x3c\x0b\xf7\xd4\x21\x8d\x4d\xec\xb6\x1c\x5a\xe4\x23\x47\xa4\xa3\x3c\x1d\xa6\x31\xcd\xcb\x6c\x4e\xc4\x94\xb1\x84\xcc\xa6\x28\x31\xe3\x2c\x69\xe6\x20\xc7\xb9\x7d\xaa\xf5\x69\xa4\xbf\xd0\x72\x0d\x38\xcf\xbc\x35\x3a\x92\x48\x70\xe9\x93\xa4\x02\xaf\x98\x25\x27\x09\x4b\x66\xd3\x2c\x8d\x21\x38\x1e\x8c\x96\xd0\x94\x98\x94\x4f\x5a\x09\x3e\xa5\x23\x66\x16\xac\x25\x9c\x0f\x25\xfe\x2c\x8b\x6f\x2b\x99\x09\xd7\xbc\x43\x62\x3e\x9b\x66\xfa\xcb\x7d\x77\x49\xc0\x09\xde\x5e\x80\x35\x21\xe7\xec\xc2\x64\x91\x43\xcd\x37\x8d\xc7\x10\x47\x08\x1e\x38\x1a\x27\x95\x1d\x17\xc2\x04\x96\xe2\xf0\x70\xb1\xa5\xb8\x3f\xbe\xb2\xd0\xe0\x69\x03\x94\x9c\xed\x0f\xe5\xb3\xf6\xf1\x82\x4e\x82\x9f\x4a\xc6\x76\xd2\x71\xf6\xce\xca\x15\xe9\x93\x2f\x57\x21\xb6\x13\x3b\xd7\x08\xcd\x1f\x16\x30\xdf\xa6\xa3\x3b\x76\x20\x20\xe7\x6d\x90\xf9\x17\xa1\x0c\xd5\xcf\xf5\x21\xfa\xa3\x5b\x66\x08\xe8\x9e\xb5\x95\x24\x84\x92\x8b\x82\x4e\xa7\xcc\x53\x61\x70\xcd\x2c\xb0\x48\x3d\x19\xb3\x4c\xb6\x98\x48\x21\x60\xc4\x84\xa6\x3d\xc7\x91\x4e\x82\x63\x8e\x4f\x25\xfc\x2d\xb2\x34\x2f\x57\xd5\x2e\x59\x95\xc2\xd7\x6a\x96\xe6\x4c\x55\xc1\xef\xe5\x7c\x75\x32\x03\xdf\xe9\x55\xa5\x7e\x0f\x2a\x4c\x3e\xaa\xf1\x6d\x06\x0e\x11\xf0\xbb\x6d\x64\xd7\x2d\xcb\xae\xd5\xc1\xdd\x0c\xbb\x51\x67\xa2\x9a\xb4\x43\xf5\x59\xaa\x27\x98\x5f\x8f\xab\x7e\x93\x75\xea\x36\x6d\x34\x8f\xc6\x3b\x8b\x14\xad\x69\x8d\x5d\xf3\x3d\xd9\x7e\xd5\x25\xad\xea\x4b\xe5\xf3\xa2\xd0\xac\x81\x04\x50\xaa\x86\xb0\xd0\xae\xf2\xb5\xfe\x6d\x6b\xcf\x6e\x65\xf7\x09\x9b\xd8\x9f\x77\x36\xea\xa6\xa7\x50\xd3\xf5\xa7\x9d\x48\xd9\x7e\xa8\x90\xac\x5f\x59\x34\xdd\x01\x3e\xbf\xd5\x00\x7b\x3d\xb2\xf6\x5d\xb4\x16\x3d\x8d\xd6\x88\xd7\x53\xbb\x84\x20\xb9\xae\x32\x4d\x76\x80\xcc\x1f\x28\xf7\xc7\x86\xd1\x82\xea\x59\xb5\x69\xab\x7f\xa3\x43\xf2\x58\x7f\x17\xbd\xed\x92\x16\xf6\xd2\xea\x92\x2f\x04\x7b\xea\x37\x38\x22\xbc\xe8\xc0\x0d\xb0\x36\xe1\x17\x77\x69\x1f\xd6\xf3\x5f\xbf\x66\xfe\x5d\x12\x45\x11\x22\x61\xc4\xca\x9f\xd8\xbc\x69\xc9\xbe\xfd\xae\x83\x55\xda\x47\xfb\x07\x87\x4d\x3a\xf4\x17\xcf\x54\xa3\xe9\xee\x4e\xa3\x7d\xe5\x85\x6a\x53\x72\x1c\x58\x93\x45\xed\xa9\x6a\xb7\xbb\xb0\xd9\xda\xf3\x97\xaa\xdd\x03\x9c\xa0\xf5\xa8\x35\xa4\xd5\xeb\xe9\x23\xd4\xfa\xae\x8a\xf9\x64\xc0\x33\x15\xb2\x8f\x2f\x21\x04\x27\x61\x25\x2b\x26\x69\x0e\xc9\xa4\xac\xcb\x07\x5e\xc3\xda\xbf\x7c\x4b\x06\xb3\x51\xa7\x4e\xe5\xf7\x74\xef\x97\x97\xc1\x61\xbe\x58\xeb\xd4\x22\xf7\xe4\xa0\xb7\x40\xcf\xb5\xa1\xfe\xfa\xc1\xfc\xb5\x88\x65\xe7\x7c\x15\x72\x98\xa8\x8f\xe4\x6a\x1c\xc2\x6c\x50\xe5\x29\x9f\xfd\x44\x36\x49\x8b\x0e\xe2\x84\x0d\x47\xe3\xf4\xd7\xb3\x6c\x92\xf3\xe9\x6f\x85\xc0\xda\xcb\x5b\xc7\x87\x27\x64\x93\xbc\x94\xbf\x7f\x8a\xc4\x34\x4b\xcb\x76\xab\xd5\x89\x86\xbc\xd8\xa1\xf1\xd8\x19\xe8\x59\x87\x7c\x21\x3f\x1c\x9f\xc9\xe6\x67\x1b\x4a\x73\xa1\x18\xae\x9a\x31\x1c\xb5\x5b\x1d\x09\xf2\xde\x26\x79\x29\x11\xe0\xc6\x74\xbb\xad\x7e\xe8\x74\xa2\x5f\x79\x9a\xcb\xce\x64\xe3\x9f\x36\x56\xae\x3a\xe4\xb5\xe5\xf7\xe1\x2d\x4a\xbe\x04\xd0\x61\x31\x21\xc5\xb4\xd5\x73\x5a\x08\x35\xf7\x23\xb2\x69\x68\x4b\x81\x32\x78\xa1\x3f\xb3\x3c\x90\x2b\x46\xbf\x06\x57\x7c\xb2\x49\xd6\xf4\x83\x11\x2b\x0f\x15\xa1\x6c\x02\xe5\x47\x43\xd3\x56\xec\xe4\xb3\x89\xbc\xa1\xec\xee\xe0\x53\x95\xea\x0b\xfa\xf8\x1e\x61\xb9\x41\x23\x72\x9d\x14\x2d\xb7\x6d\xde\x19\x68\xf6\xf8\xf1\x89\x93\x82\xf0\x0c\x77\xa1\xd3\xf7\x6b\xbd\x39\xdb\x87\x1d\x29\x3b\xc4\xb4\x6c\xdb\xd7\xed\xc3\x4e\x07\xcb\x5c\xab\x26\x16\x94\x4a\x85\xb3\x09\x30\x9d\xc9\xe2\xdb\x5f\xc9\xa6\x5b\x67\xfc\x8c\xcd\xf1\x0f\x35\x11\x93\x47\xe7\xd7\x0e\x66\x36\x80\x19\xe3\x81\x73\xd8\x55\x69\x77\x24\xe0\xe3\x5f\xe5\x04\x3a\xe4\xe8\xf8\x8c\xcd\x25\xa9\x1c\xc2\x0f\x4c\x2e\xa4\xa8\xe5\x68\x03\x04\xbb\x07\x8d\xfc\xfe\xe5\x6d\xf9\x3d\x5c\x34\xc9\xea\xf7\x64\xab\x28\xe8\xfc\xaf\x2a\xac\x42\xbe\x81\x64\xb4\xee\x9b\x38\x9b\x25\x4c\x28\x2e\xb4\x98\xbf\x80\x59\x10\x1b\xfe\xac\x91\x19\xe6\x6b\xcf\x4c\xc3\xad\x81\xe0\xd9\xac\x64\xbb\x8a\x9c\xc2\xe7\xc0\xb7\xa1\xd3\xd2\x6e\xbd\xdd\xc3\xd3\xdd\xbd\x37\x3f\x7f\xd8\xde\x39\xf4\x3c\x48\x6c\x8b\x07\x68\x26\x61\x59\x17\x4c\x3c\xbb\x55\x82\xdb\x87\x8d\xa0\x49\x0e\x5a\x87\x48\x43\x4f\xac\xbd\xaf\x08\xc4\x69\xa4\x37\x44\x65\x4e\x6d\xd3\x5f\x97\xd4\xbe\x01\x8d\x85\xb1\x7e\xf8\x28\x97\x77\x2a\x41\x0e\xe9\x04\xcb\x5f\xfd\x5f\x56\x70\xc2\x7e\x9b\xd1\x2c\x2d\xe7\x84\x66\x23\x5e\xa4\xe5\x78\xa2\xbf\x5d\xc4\x01\x05\xcb\x86\xab\x52\x4c\xa6\x05\x33\xa1\x3b\x0e\xce\xc8\xc3\x87\x84\x65\x92\xcb\xb0\xac\x53\xa3\x68\x6f\x73\x2a\x25\x8b\x3c\x38\xcc\x76\x74\x82\x69\x6e\x34\x0a\x1c\x07\xc2\xbb\xb7\x89\x80\x3b\xf5\x58\x64\x07\x31\x40\xa5\x24\x1d\xe5\xbc\x60\x82\x8c\x79\x26\x85\xc6\x0a\xd6\x56\x49\xce\x4b\x37\x88\x59\xde\xf9\xda\x1b\xfe\x74\x36\x88\x1a\x7c\xa7\x86\x0b\x28\x5d\x23\x57\x32\xcd\xc9\xbe\xaf\x06\x55\x53\x3e\x01\xdd\x9a\x44\x95\x1a\x6b\xf0\xf3\xcb\x4b\xcd\x2f\xcc\xbe\xbe\x57\xc1\xf9\xea\x9a\x8e\x5c\x0b\xec\xf1\x6f\x6f\xb5\xc7\xd5\x76\xcd\x4b\x36\x6a\x36\xe3\xbf\x78\xa2\xb6\xe1\x84\x4a\xc2\x7d\x47\xcb\x71\x34\xa1\x9f\xd5\xb3\x34\x37\xcf\xd2\x7c\xe1\xf6\x4b\x3d\xea\x06\x94\xd9\xcd\xa0\xc6\x80\x8d\xdc\x33\x11\x9b\xbc\x22\x4f\xc8\x6b\x39\x00\x6c\x40\x1e\x2b\x30\x5d\xf2\x44\x32\xea\x49\x9a\x57\xc0\x87\xb1\x75\xbb\x10\x94\x20\xd3\x59\xd7\xd8\x79\xb0\x90\xe9\x59\xf9\x7c\x11\x8e\x2a\x6e\x5b\x69\x09\x67\x42\x97\x24\x4c\xc4\x1e\xcb\x7a\x10\xf6\xf3\xf2\x3f\x08\xe2\x60\xfd\x76\x4e\xfe\x4b\xca\xf6\x56\x58\x7e\x46\x7a\x64\xed\x79\xb4\x1e\x3d\x8d\x5e\x90\xf0\xa8\xf7\xbb\xe4\xa0\x4b\x4c\x3e\x4d\xd1\x59\x7c\x33\x20\x8f\xc8\xbd\xe0\xa5\xec\x65\xc7\xbf\x34\xf8\xdd\x84\x2f\x0f\x4f\xd7\x3b\xd1\x30\x78\x7b\x58\xbf\x9d\x6f\x78\x98\x58\xd6\xbf\xe2\x3e\xe7\xdb\xfa\x03\x03\xbd\x9d\x1b\xac\x5d\xaa\xef\x48\xb0\xc7\xf6\x7e\xe7\x46\xb7\x8b\x07\x4b\x79\xdb\xad\x3f\x03\xf7\xa6\xf0\xab\xb5\x4e\xbb\xe5\x43\x69\xd5\xf3\x6a\x54\x4f\xef\xca\xa8\xd3\xb2\xa2\xce\xa8\x8c\xab\x6d\x24\xda\x54\x25\x45\x92\x2c\x36\x44\x08\xb7\x73\xe8\xac\x2d\xf7\x17\x72\x5f\x69\x28\xee\x37\x5c\x68\xd7\x9f\x75\x24\x3c\xed\x5c\x84\xde\x99\x72\x78\xd5\x91\xdd\xbd\xca\x61\xed\x85\xbc\x4c\x86\x57\xe5\xe9\xb2\xc4\xbb\xf6\xe2\xbb\x4e\x34\x6c\xb7\xd2\x92\x15\xb4\xe4\xa0\x9f\xa9\x8d\xfd\x76\xda\x88\x9b\x9d\x5c\x3a\x3d\x65\xd3\x85\xf7\x3b\x64\x59\x46\xaa\x3d\x04\x9f\xe2\xbf\xd2\xd2\x93\x82\xd5\xd3\x98\x27\xec\x80\xa7\x79\xb9\x55\x2e\x3a\xee\x8e\xf6\x4f\x0f\x8f\xde\xef\xee\xfd\xad\x41\xd6\x2c\xc7\xb4\xec\x92\x29\xf7\xc2\xe0\x25\x08\xec\xa6\xad\xc6\x0c\xed\x3a\xae\x00\xe9\x9d\x97\xf2\x7b\x47\x02\x25\x9b\xa4\x7e\x29\xa1\x5d\x32\x70\xb2\xa9\xc1\x61\x2a\x05\x10\xf2\xfd\x26\xb1\xe2\x89\x19\x2f\x79\x4d\x5a\x2d\xd2\xb7\x59\x3d\xf1\x5b\x0a\xb0\xe3\x31\x2d\xde\xf0\x84\x6d\x95\xed\xd4\x77\x81\xa1\x12\xee\xe7\xe4\xdb\x27\x00\x9c\x92\xef\xe5\x5f\x83\xe1\x10\xbb\x7a\x4c\xd6\x40\x1e\xca\xc0\x85\x69\x50\x83\x25\x1b\x74\x3a\x08\x22\x46\x10\x03\x04\x31\x1c\x0e\x95\x70\xf5\xda\x1b\x23\x7e\x0f\xe3\x20\x7d\x42\x55\x9b\x7e\xa5\x8d\xc8\xd2\x98\xb5\xd3\x2e\x0c\x61\x5d\xb6\x6c\x53\xb2\xaa\x07\xfa\xea\x15\x59\x7b\xd2\x21\x8f\xe5\x88\x56\x55\xd7\xf2\xcf\x27\x9f\xd7\x9e\x3c\x79\xf2\xa4\x59\xee\x5a\xbf\x53\xd5\x12\x44\xdb\x80\x72\xb5\xf1\x2a\xf4\xad\xa1\x64\x4c\x58\xce\x9b\x88\xfe\x5b\xdd\x52\xb0\xf2\x88\x23\x2d\x1d\xd1\x51\x23\x60\xad\x84\xda\x55\x7b\xd5\x70\x48\xa5\x38\x91\x3b\x60\xfd\x39\xea\xbd\xa2\x35\xf2\x4d\xad\xdd\x37\xc7\xff\xf1\x1f\x7a\xa3\x9f\xb4\x3b\x41\xde\xf1\xfc\x49\xa7\x5d\xfb\xb0\x41\xb5\xfa\xa4\xe3\x32\x8e\x0a\xdb\x77\x6d\xb3\xa8\x3c\x59\xb4\x05\x1d\x5f\xbb\x2e\xd9\xdb\x7a\xb7\xd3\x05\x87\x0b\xdc\x70\xce\x4b\x9b\x7f\xd4\x14\xe4\x0e\x0d\xf7\x0b\x7c\xdd\x77\xd6\xa0\xbd\xa6\x21\xa2\x1e\xc7\xc7\x79\xbd\x7f\xf2\x98\xb4\x0c\xa6\x5b\x0d\x02\xda\xed\xae\xed\x40\x24\x07\x0d\xcb\xfd\x54\x5f\xbd\x69\xbe\xf0\x2c\x37\x8c\x73\x09\x0d\xe6\x72\x47\xc2\xd3\x97\x1d\xf2\x3a\x28\xff\xa5\x4c\x90\x7e\x83\x08\x9c\x32\x01\xd2\xa1\xf9\x0b\x97\x4e\x8f\xbe\xbd\x6f\xd4\x50\x56\xc3\x03\x1a\x1b\xe7\x0b\xdd\xa2\x49\x71\xa3\x79\xea\x13\xfd\xc7\x81\xa3\x79\xb2\xf7\xc1\x0e\x49\x0e\xa2\x21\x8c\x46\xeb\x68\xd2\xc7\x8f\x4f\xdc\xc1\x1d\x1f\x78\x4e\x01\xfb\xe1\xe5\xbd\xfd\x8d\x4d\x97\x44\x68\x42\xf5\x8b\x4e\xa4\x9b\x04\x0e\x6c\xf3\xf5\xc3\x87\xb6\xb8\x82\xfe\x61\x52\x75\xd6\x86\x7d\x97\xd1\xfb\x48\x82\x49\x72\xc4\x3f\xe4\x22\xe6\x53\x3a\xc8\x1a\x9d\xe0\x9f\x3d\xd5\xb4\x08\xe6\xf5\x26\x61\xf2\x59\x85\x8d\x35\x81\xfb\xee\x89\xd1\x29\x2d\xa1\xa5\x02\xe6\xb7\x0e\x46\x8f\x67\xa8\x41\x70\x52\x15\xb3\xbc\x2c\x24\x81\x76\x9c\x56\x6b\x4f\x6b\xcd\x40\x67\xeb\xb6\x59\xff\xae\xd6\x06\x94\x1a\x7e\xab\xa7\x4f\xaa\xad\x2a\x7c\x76\x49\x49\xec\x65\xa7\x0d\x70\xba\xa4\x05\xff\x7a\x82\x34\xc2\x63\x49\x97\x9c\xa5\xb9\x2a\x98\x80\x49\x95\x4b\x4f\xd3\xa5\xdb\x75\x36\x88\x14\x93\x40\x03\x6c\x9a\xe2\xe6\x21\xf5\xff\xf5\x7a\x58\xf6\x14\x6e\xe6\xa6\xf9\x99\xdc\x3e\x69\x9e\xd4\xbe\xe8\xf5\xe0\xb9\xc1\xc1\x73\x30\xb5\x7c\x03\xa3\xae\x9f\x3a\x50\x45\xb5\xdd\x59\xb9\xaa\x5f\x0c\x8c\xa6\x0e\x67\x62\x58\x44\x9a\x27\xe6\xe9\x59\x55\x41\xad\xe6\xf2\xf8\xb1\x29\xa4\xb1\x6f\xb5\x34\xdf\x6f\x12\xa3\xca\x53\xd2\x9a\x45\x53\x45\x4e\x32\x61\x69\x6c\x0a\xa1\x21\xe8\x2f\x24\x21\xe2\x00\x36\x49\x4b\x92\x44\xab\xe3\xb5\x7c\xd2\x25\x56\xf5\xe1\x35\x46\xda\xa8\x37\xd7\x6a\x26\x97\xe5\xe8\x77\xc7\x4a\x19\xa2\xdb\xc8\x46\x57\x5d\x0b\x0b\x29\xdb\xa8\xcc\x7f\x4e\x45\xe9\x52\x17\x49\x85\xc2\x3b\xe0\xfb\x14\x3f\xfb\x86\xb4\xbf\x8b\x9e\x45\xcf\xa2\x17\x5d\x82\x3f\x5e\x76\x56\xcc\x7e\x8b\xb6\x34\x34\xb2\x49\xdc\xa7\x05\x9d\x6f\xac\xac\x54\x77\x7b\x5b\x21\x61\x23\xf0\xc6\x8e\xb2\xfe\x4e\x6d\xba\xd0\x8d\xe2\xe9\x32\x9a\x8d\xf0\x95\xcc\x97\x31\x7a\x8f\x54\x85\x25\x09\x3c\xd0\xcf\xed\x14\x03\x5f\x71\x1f\x7c\xba\xbe\xdc\x7d\xf0\xe9\xed\x34\x01\xe1\xbe\x9f\x36\xde\x07\xbf\x6d\x78\xf3\xec\x69\xd3\x1d\xf2\xd9\xd3\x97\x37\x51\x80\xa0\x35\x26\xb0\x02\x77\x19\x62\x29\x77\xc2\xce\x9b\x77\x5b\x87\x20\xd3\x91\x17\xc6\x8e\x29\xc6\xe9\x04\x85\xa0\x8c\x0f\x68\xd6\x7c\xda\xe2\x81\x32\xa6\x4d\x53\x79\xa1\xa5\xae\xed\x9d\xc3\x37\xef\x77\x0f\x8e\xf6\xdf\x37\xd9\x7b\x9f\x1a\xd3\xeb\xf5\x3a\x36\xcc\x0a\x84\xbc\xa7\xf1\x5c\xd4\x5d\xbf\xdb\x39\xda\x6a\x8c\xd3\x7a\xd2\x89\x7e\xda\xf9\xbb\xea\x78\x48\xd3\xac\x71\x26\x6b\xfa\x2c\x1e\xd3\xa2\xf9\x3e\x6d\x26\x7c\xc3\x3b\xc8\x2c\x6d\x04\x09\x9e\x10\x90\xe0\xfe\xac\x51\xc4\x7c\x62\x9b\xec\x7c\x6e\xb4\x6e\xbf\xf8\xce\x36\xdb\x5e\x84\xbc\xb5\x97\x7a\xb6\x2c\x9f\x4d\x16\x88\xc1\xcf\x9e\x6a\xe9\x23\x15\xc0\xef\x1a\x57\xe3\xf9\x0d\xc5\xef\x1b\x98\xd2\x0e\x8a\x74\x92\x96\xe9\x79\xe3\x6c\x9e\x6b\x42\xc5\x0b\xce\x36\x13\xf1\x75\x57\xc8\xd3\x25\x2f\xa5\xa3\xfd\x83\xbd\x66\x8c\x3f\x7b\xaa\xa7\xfd\xe0\x6f\xfb\x07\xdb\x8d\xc8\x31\xa4\xbf\x7d\xed\xf5\xe5\xc1\xd9\x72\x6e\x15\xb2\x33\xe8\x34\x1a\x6e\xd8\x9b\xd1\x83\xed\x03\xfd\xb7\x1c\x39\xda\xa1\xe5\x04\xf4\xd3\x07\xc8\x78\xe4\x0b\xd8\xfa\x86\x11\xc1\xcb\xff\x3c\xdc\xdf\xb3\xaf\xe4\x5f\x0a\x5b\x18\x89\x9e\x0e\xe5\xfa\x63\xab\x87\x0f\xf1\x47\x64\x5e\x61\xd3\x83\xf7\xfb\x47\xfb\x47\x7f\x3f\xd8\x21\xe8\xc6\x85\x32\x4d\x0b\x5f\xfe\xb8\xbb\xbd\xbd\x23\x7b\xb8\x38\x13\xed\xd6\xe9\x38\x4d\x12\x96\xb7\xd4\xa4\x8e\xf6\x4f\x0f\xde\xef\xbe\xdb\x3d\xda\xfd\x65\x47\x37\x71\x16\xbf\x65\x08\x51\x99\xd2\xbf\x5c\x45\xda\xe3\x62\x17\x9e\x41\xbc\x1f\xc3\x56\x38\x2d\x9d\xb1\x92\x6c\xaa\x6d\xdd\x6e\x21\x0b\x5c\x2d\xd4\x1b\x0d\x75\x2b\xcb\xac\xed\xde\x6f\x2b\x74\x9b\xfd\x83\x7a\x13\x3e\x5d\xad\xb6\x02\xaa\x06\xe9\xc2\x78\x97\x1c\x1b\xac\x9c\x60\xa3\x0f\x87\x3b\xa7\x7b\x5b\x6a\xa6\xca\x75\xdd\x2c\x8d\xeb\xb6\x8e\xcd\xff\xcb\x6c\x15\xb5\x34\xff\xa5\x0d\x2e\x26\x7f\x1f\x30\x7e\x48\x93\x07\x5e\x7e\xff\x55\x12\xe4\xfa\x5d\xa2\x13\xd3\x8d\xd2\x72\x3c\x1b\x40\xe6\x8d\x7f\x64\x3c\x2d\x78\x7c\xd6\x8b\x79\xc1\x56\x7f\x15\x3d\x2c\xef\xd6\x5b\x7b\xf9\x54\x33\xb7\x12\x74\x8f\xf7\x74\xcf\x97\x97\xe6\xb7\x33\x99\x86\xc7\x50\xb5\x00\xc2\xb8\x36\xb4\xb1\x1d\xb2\x9f\x83\x25\x92\x67\x09\xd9\xca\x93\x82\xa7\x89\x1d\x5b\xcc\x13\x16\x8d\x38\x1f\x65\x0c\x06\x38\xed\x9d\x7f\xab\x07\x95\xb0\x92\xa6\xd9\xeb\x34\xd9\x7c\xf1\xed\x4b\x3d\x3c\xc4\x95\xda\xe9\xee\xe1\x23\xe9\x12\xf8\x7c\xcd\x83\x46\xbb\xfe\x29\x2d\x48\x72\x00\x6e\x26\x2d\x6a\x82\xb5\x46\xac\xec\x87\x75\x32\xc9\x81\x8a\x32\xc4\xd6\xda\xcf\xfe\x25\xb9\xea\x44\x74\x03\xbd\xe6\x3b\x9d\x88\x82\x53\x4b\xd5\x4f\xc5\x9a\xae\xb6\xad\x10\x0f\x3b\x43\x0d\x5f\xee\xe6\xb6\x43\x36\xba\xf2\x0e\x4a\xcb\xa6\x65\x87\x24\x50\x31\xda\xa5\x30\xe3\x3a\x91\x1c\xb8\xdd\xd4\xbe\x85\x7c\xcd\x25\xf8\x56\x3a\x5f\xcb\x8b\x7f\xad\xe3\xae\x1d\x5b\x07\xdd\x30\x92\x03\x5d\x6e\xb6\xa0\x53\x4f\xa4\x2c\xe9\xc8\x4e\x49\xcc\xe5\xae\xb4\x1b\xe9\xb8\xa4\xa3\x13\xc9\xc9\x14\xc2\x15\x7d\x3b\x74\x82\x8a\xa5\xf9\x04\x6f\x4e\x25\x1d\xb9\xf2\xfe\x7c\x62\x0b\xd6\xa4\xc2\xb0\x2d\x67\xe7\x3c\x7c\x58\xd9\x3a\x91\x16\xf3\x61\x0f\xe1\xbe\x6c\x55\x96\xc2\xa3\x05\xf5\x79\x5a\xba\x1f\xe0\xa4\x1b\xbf\x49\x4b\xe3\x4d\x6d\x7b\xb6\x43\x7d\xe0\x9b\xe6\x96\x31\x81\x2a\xb2\x00\x0d\x76\x09\xaa\x64\x6f\x8d\x1e\x54\x6d\x8a\x9a\x0d\x79\xcb\x6d\x14\x47\x29\x3a\x30\xa1\xc3\x8d\xc3\x3f\xdb\xd0\x18\xca\x26\x7b\xed\x2d\xb5\x8c\xa9\x68\xdb\xe5\x43\x2a\xec\x38\x65\x77\xef\x6d\x47\xcc\xb0\x59\xdf\x31\xe0\x9e\xfc\x56\x4e\x08\x39\x7c\xa7\xa3\x09\x12\xff\xee\x3a\x27\x73\x7b\xad\x4b\xbe\x5c\xd9\x08\xae\xb4\x3c\xc6\x46\x27\xda\x21\xa8\x31\x0b\xbb\x1e\xa4\xd3\x11\x12\xb6\x07\xa1\x13\x00\xe9\x55\x61\xdc\x76\x88\x72\x5b\x6e\x67\x3b\xab\xbe\x3b\xd0\x27\x2a\xef\x7d\xc7\x06\xe1\x19\xea\x74\x39\x50\x75\xe7\x5d\x39\x6c\xc3\x7b\x75\xb5\x11\x20\x91\x94\x35\xdb\xc9\x53\x86\x93\x3d\xa8\x28\x07\xd3\xb2\xaa\x1d\xd4\x72\x5c\xfb\xc0\xd3\x6e\x1c\x74\x3a\x41\x45\x60\x16\x56\x16\x2a\xa7\x2e\xad\x21\x44\xe5\x60\x95\xfe\xd4\x94\x2a\xaa\x42\x44\xbd\xeb\xdd\x50\xda\x09\x1b\x61\xab\x92\x3d\xd9\x9d\x9c\xfa\xec\x00\x36\x80\x5b\x76\xed\xd4\xb4\xed\x90\x7e\x1d\x79\x6d\xe7\xbd\x04\x66\x7b\x0d\x49\x07\xee\x18\x42\xef\xe5\x2e\xb1\x2c\x4d\x9e\xce\xae\x23\x1b\x1e\x02\x8b\xb6\x96\xd9\x4c\x18\x20\xef\xef\x65\x5d\xc5\xa4\xba\xc9\x20\x47\xbe\x7c\xe1\x6f\xed\x4e\xa7\x96\x76\x5d\xfd\x8d\xe5\x6a\xe5\x17\x66\x44\x1d\xf3\xa8\x06\xfd\xf2\x92\xd8\xa6\xce\xbe\x91\x0f\xfc\x8d\xf2\x9a\xec\x90\xbe\xda\x7f\x57\xd6\xe4\xbd\x7f\x91\xeb\xd5\xdf\x76\x8d\x34\xae\x7d\x3a\xd8\x46\xd3\x8a\x62\x70\x55\xcd\xdb\x52\x8c\x2a\xcc\x16\xbf\x16\x95\x9a\xd2\xb7\xf5\xb9\xab\x47\xa8\xbb\xda\x5e\x08\x79\x19\xf6\xd3\x21\x2e\x9f\x74\xf8\x99\x2e\xef\xd4\x84\xdb\x3d\x3a\xf1\x79\x41\xe0\xb5\x39\x8d\xe4\xf7\xb9\xfa\x40\xca\xf8\x6d\x0f\xb1\x66\xd7\x17\x4c\x60\xbc\xc0\xf1\x49\x90\x11\xf8\x3b\x1e\x00\x46\xae\x65\xc0\xe1\xfe\x01\xa4\x90\x4d\x1c\x03\x30\x01\x40\x86\x7c\x78\x6f\x53\x0b\xfa\xf6\x81\xbc\xa4\x77\xd4\x68\xa2\xe9\x4c\x8c\xdb\x1a\xe9\x57\xb6\xdc\x8e\x7c\xd9\x84\x1c\x2b\x7a\x37\xa0\x47\xfb\xb7\xba\x08\xda\x3d\x3c\xdd\x97\x0c\xb1\x4e\x3f\x1b\x21\x14\x62\xf3\xd7\x8e\xa0\xdf\x27\xbf\x37\x5a\x97\xc2\xaa\x19\x19\x50\x76\x55\x52\x54\x5b\xb6\xe3\xe3\xd7\x11\xc4\x0c\x6b\x0e\xe1\x5a\x79\xc9\x3c\x03\x1b\xa8\x72\x0d\x3f\xd6\x76\xc0\x94\xe7\x27\x1d\x88\xd5\xb9\x67\x05\x2f\x1c\xbe\xbd\x49\x9a\x05\xd1\x8e\xe5\xce\xf4\x80\x0d\xd6\xe5\xa5\x8e\xaa\xad\x75\x34\x9f\xb2\x9d\xa2\xe0\x45\xbb\xa5\xc0\x99\xba\x1b\xb1\xb5\x30\xde\x6b\x39\x8e\x00\x25\x68\x5b\x66\x69\xd2\x0e\x14\xf1\x7c\xe2\x95\xe9\x7c\x72\xe2\xda\xfa\x1d\x18\x0f\x04\xf3\xeb\x30\x2a\xd7\xcb\x6a\xc8\x77\x40\x18\x13\xac\xc4\xb3\xc0\x61\x30\xf8\xf5\x46\x45\x4a\xa9\xf1\x5b\xfd\x50\xb3\x8b\xae\x9c\x4b\xa7\xe3\xf3\x61\x25\x34\x7b\x02\x8b\x2f\x6d\x20\xdc\x92\x8e\xaa\x52\x15\x0e\x43\x8b\x2a\xd6\x2d\xa2\x72\x3d\xc2\xcb\x5d\xa7\x02\xd5\xa3\x2a\x00\xfe\x45\x2e\xc1\x30\x1d\xcd\x94\x64\x84\x75\xca\x84\xbc\x24\x01\xfe\xae\x7c\x27\x09\x79\x39\x80\x0b\x81\x89\x92\xd2\x1a\xbc\x80\xe4\xdf\x25\xad\x52\x69\xcf\x5c\xab\x8d\x7e\xd6\xae\xf8\x37\x39\x86\x8d\x2b\xcc\xec\xa2\x54\x1f\x64\xb3\xf9\x80\x92\xad\x41\x1f\x22\x1b\xf9\x32\xcc\x06\xd4\xe7\x08\x69\x6a\x5e\x74\xa0\xbd\xd1\x9a\xd4\x3b\x00\x36\xdc\x04\x60\x6d\x4d\x01\x08\x0a\x1f\x8d\x5f\xbd\x78\xd6\x09\x75\xa5\x08\x0c\x26\x1c\x58\xc8\xa0\xab\xe0\xda\x8b\x6f\x3b\x16\x7b\x6a\x01\xbc\xc5\x6d\x85\x86\xd6\xea\x86\x87\xec\x1c\xc4\x10\xc9\x8e\x0a\x48\x18\xac\xdd\x3d\x92\x5b\x55\x56\x0c\xa8\xe1\xe2\x4c\xe0\x3b\xa7\x40\x45\xd5\xff\xf1\x6f\x8e\xff\xe3\xc7\xaa\x2f\xa4\xe5\x39\x92\x1c\x11\x1d\x7d\xc3\x79\x80\x14\xc0\xb9\x19\x34\x99\xe2\x85\x3d\x23\xda\x18\x15\x03\x7c\x6d\x3d\x5a\xef\xea\x5f\x4f\xcd\xaf\x67\xe6\xd7\x0b\xf3\xeb\x5b\xf3\xeb\x3b\xf3\x6b\xed\x89\xfd\xb9\x66\x7f\x5a\x90\x6b\x16\xe6\xda\xb3\x15\x42\x5a\x63\x2a\x74\xad\x8c\x2e\x94\x08\x8a\x69\x79\x38\x2d\x18\x4d\x00\xa1\xfa\x8e\xda\x9d\xd0\x32\x1e\x77\x55\x72\xc7\xae\x60\xb4\x88\xc7\x5d\x31\x65\x71\xca\x44\x17\xe2\x6c\xba\x8e\x54\xd4\x2d\xad\xb6\xb9\x3b\xb3\x76\xa3\xd6\x4a\x47\x07\xe5\x74\x5b\x9d\xae\x0a\xd3\x70\xb0\x61\x99\xe3\xaf\x1b\x1d\xb9\x22\xf6\x15\x86\x62\xb8\x48\xbc\x60\x59\xf6\x53\xce\x2f\x72\x8b\x4a\x50\x48\xca\xa5\x8c\x44\xc9\x0b\xd6\xe9\x92\x33\xec\xa2\xda\xd6\x76\x74\xb6\xd1\xb1\x2a\xe8\x76\xb5\xdd\xf1\x99\xea\xf5\x5a\x57\x58\x77\xf9\xd5\xf9\xa0\x94\x35\x76\x6d\xf5\x99\x15\x0d\x79\x01\x32\x85\x5c\x82\x21\x2f\x5a\xee\x15\xde\x88\xa0\x36\xeb\x38\x15\x6d\x5f\x47\x88\x47\xef\xe3\x4d\xd2\x6a\x75\x8c\x57\x96\xdf\x04\x0e\x52\xe3\x8d\x15\x78\x27\xd1\xa5\x0e\x41\x23\xde\x74\xbd\xe1\x3e\xd7\xc3\x3d\x63\xf3\xb7\xbc\x68\x8b\xf9\xa4\x83\x42\xf0\x5b\xee\xd6\x50\x74\x5e\xbb\x32\x98\x56\x84\xc0\x8b\xfa\x21\x2a\xe6\x13\xf0\xc3\x31\x87\x28\xaa\x34\xcc\xf9\x69\xd6\x59\x4e\x35\xcd\x2b\x53\xc0\x50\x80\xe0\xb4\x36\x37\x09\x0c\x45\x61\x4f\x89\x37\x58\xc8\x50\xb0\x43\x38\x51\xaa\xba\x33\xa3\x44\x04\xf9\xd7\x36\x86\x64\x22\x8d\x8d\xf1\xe0\x23\x57\xe8\xaf\x7a\x33\x12\xb1\x0e\xd2\x06\xe7\x6b\x72\xfb\x6b\xe7\x1c\x75\x51\xdc\x27\xc7\xae\x6f\xcb\x49\xc7\xd4\x40\xee\xeb\xab\x6a\xd7\x03\xf0\x6c\x69\xef\x6e\x52\xf3\xcc\xae\x9c\x3c\x3e\xe0\xa7\x4d\x6e\x43\x15\xd7\xa0\x2a\xdc\x94\x89\xc0\x4d\xd8\x87\xfd\xc2\x71\x79\x0e\x5f\xce\x64\x1f\x12\x74\x53\x83\x7e\xf3\xd9\xea\x77\xf5\x32\xdc\x15\x5e\x58\xf6\xeb\x5d\xc0\x8b\x1a\x74\x78\xea\x03\xfe\x36\x0c\x58\x8b\xfa\x01\xd0\xea\x55\x0d\xb8\x7a\x8e\x54\xd5\xeb\x91\xf5\x67\xd1\xd3\x68\x9d\xf8\x16\x0c\x15\x8a\x73\xdc\x25\x8a\x2b\x17\xf2\xb7\x98\xd2\x98\x9d\x9c\x74\x56\xac\xe1\xe3\x1a\xaa\x74\x85\x65\x79\xfb\x6e\x50\x48\xeb\x38\xbf\x07\x6e\x40\x66\xaf\x47\xde\x1d\x92\x9d\x64\xc4\x74\x9a\x6b\xa1\x76\x31\xca\x77\x90\x05\x11\x06\x42\x05\xf9\x72\xb5\xa2\x72\x03\x0d\x7e\x4a\xcb\x25\x3e\x50\x49\xfc\x7a\x3d\xf2\xcb\xb7\xc8\x3d\x04\xe1\x39\x19\xf0\xcf\x2c\xd1\xd6\x61\x47\x55\x6e\x31\x73\x7c\x78\x02\x51\x98\xad\x63\x09\xe2\xa4\x05\xa1\xab\xf6\xf5\x17\x42\xfb\xe4\x90\x5c\x61\x9b\x2f\x57\xd5\xf7\xea\x0a\x75\xd8\x31\x0d\x36\x56\xae\x3a\x9d\x2e\x69\xc9\x91\xa9\x1d\x6b\x9a\x3b\xcc\xc1\x82\xb0\x4e\xef\x8e\x46\xc0\xea\x89\x2e\x2f\x8d\x96\x18\x6e\x6a\xfa\xbe\x0f\x55\x9f\x76\xbe\x55\x7f\x0a\x05\x50\x4e\xda\x7c\x6b\xbd\x89\x8b\x91\x3c\xf1\x8e\xd3\xf2\xc4\x77\x4a\x5e\xb3\x7f\x6a\xca\xe8\x92\x07\xfa\xa7\x17\x07\x19\xb8\x94\xa4\x1d\x80\x8c\xd7\x32\x27\x98\xd3\x06\x72\x1a\x72\x83\x68\x53\x71\xbc\x76\x62\xa5\x77\xa5\xa3\xb6\x4d\xfc\xac\x46\x0f\x9c\x6f\xfd\x01\xc9\x8f\xed\xdb\xcb\x4b\x72\x4f\xd9\x70\xdb\xfa\x21\x60\xc9\x7c\xed\x1d\x97\xfa\x36\xe1\x5d\x89\x0c\xb4\x8e\x09\x82\x33\x8f\x2a\x0a\xb2\xd0\xa5\xc8\x9e\x5e\xea\xa6\xa2\xe9\xcc\x09\x02\x54\xd7\x16\x85\x85\xda\x9c\x6a\x84\x19\xd1\xe9\x34\x9b\xb7\x61\x6b\x76\xe1\x33\x25\xab\xea\x8d\x0e\xe7\xee\xd3\xe8\x99\x3e\x77\x5d\x9f\x33\x47\xbc\x3a\x69\x8f\xd3\xbc\xec\xac\xd4\xaf\x2a\xc7\xae\x5d\xf2\xa4\x29\x64\xfb\xf9\x93\x4e\xf0\x9a\xe3\x7e\xdc\x25\xf5\x16\xe8\x1f\x07\xf9\x95\xed\x60\x9f\x87\x07\x6b\xe4\xbf\x93\x95\x8a\x37\xae\x82\x6b\xa5\x24\x04\xb7\xfe\x04\x5c\x9b\xbf\x83\x20\xb6\x6b\x40\xc8\x26\x5d\xd2\x92\xff\xb4\x8c\xd0\xaf\x19\xe5\x53\x60\x20\xd7\x40\x70\xac\xc6\x76\x5f\x2b\x40\x35\x37\x97\xdb\x85\x77\xf4\x7a\x50\xc5\xc3\xd1\xb2\x61\x9e\x15\xd0\x48\xeb\x62\x1e\x4c\x18\x8e\xb6\xa4\xbf\xef\xf9\x5d\x65\x2c\x58\x14\x2a\xe8\xa8\xa7\x8c\x16\x49\xfb\xf6\x3a\x7a\xfd\x86\x60\x72\xb9\x8f\xec\x2b\x2f\xbe\xc2\xb6\xb6\xc1\xde\x69\xe9\x86\x57\xd4\x82\xd0\x2b\x9a\xab\x70\x64\xb7\xa8\x8a\xf7\x69\x3d\xc2\xdb\xda\x04\x54\x6b\xe4\x6e\xcb\x6b\xfc\x6a\x04\x72\xeb\x8c\x1e\x9e\xd1\x79\x77\x67\x6d\x8d\x0c\x66\xa3\xd1\x7c\x81\xa8\xa2\xea\x91\x0e\x0b\xaa\xd2\xd9\x61\xf1\xbc\x9b\xb9\xab\x28\xb7\x8b\x66\xed\x82\xf6\x6a\xc1\x8d\x83\x7e\x0c\xfa\x2f\x6d\x67\x85\x7e\xb5\x3a\x58\x1d\x00\xf8\x10\xd8\x3f\x12\x7b\xcb\x56\x3d\x94\xbf\x9a\xe7\xb5\x42\xac\x7f\x7a\x48\x42\x43\x18\x1d\xd2\x07\x6d\xa6\xde\x2c\x1f\xbd\x41\xd4\x09\xb8\x2c\xe6\xfe\x95\x0a\x54\xa8\x8a\xe0\xae\x48\x2c\x6f\xb7\xa4\x5d\xd3\x0b\x58\xa8\x2a\x80\x45\xf3\xeb\x9a\xbb\xbd\xaf\x64\x58\xa4\x0b\xaf\xc3\x06\xf3\x86\x42\xaa\xa6\xd0\x0e\xe0\xee\x58\x71\x0a\x9c\xde\x49\x0b\xd3\x25\x38\x93\x55\x76\xa6\xa0\x4e\x3d\x44\xa8\xb7\x0b\x97\x69\xf2\xce\x6a\xb7\xa8\x98\xe7\xf1\xee\x82\x30\xb3\xa7\xb7\x8b\xa6\x68\xee\x99\x0f\x04\x2b\xce\x41\x2b\x14\xea\xf6\x76\x5e\xfe\x5f\xe3\x23\xfa\xdd\x92\x3e\xa2\xbf\x43\x0c\x34\x84\x72\xde\x34\xac\x55\x5c\x13\xd6\xfa\xec\x76\x81\xca\x4e\xba\x22\x13\xd7\x2a\x2a\x71\xad\xca\x8b\x63\xe9\x8c\x45\xb5\x2b\x8d\x1f\x6f\xec\x83\x6f\x58\xa7\x67\x6b\x9d\x48\x2b\x86\x6b\x53\xbe\x9d\x67\xb1\xbc\xe3\x40\x35\x2f\x60\xd1\x36\x69\x38\xcf\xb3\x79\x44\xf6\xb3\x84\x9c\x7f\x4b\x62\x0a\x85\x4c\x4d\xd6\x1e\xa8\xb1\x0b\x2d\x95\x78\x20\x22\x39\x16\x3f\x45\x03\xc9\xf9\x2a\xb6\x51\x69\xdf\x53\xb1\x90\xd1\x3f\x5f\xbb\xa1\xa3\x23\x54\xaf\xf1\x38\xa8\x59\x9c\x50\xc4\x8f\x12\x94\xd5\x33\xd5\xee\xe1\x43\x35\x0f\x9b\x74\xb6\xaa\xfa\xc1\xf7\x8f\xc9\xfd\xbe\xc2\x83\x5c\x09\x2a\x88\x11\x21\xef\xdd\x47\x06\x56\xdf\x80\x18\xdd\xd5\x0f\x93\x12\x04\x35\xb6\x0c\xc6\x5b\x24\xcd\xc9\x97\x2b\xf2\xba\x21\xcb\x0e\xaa\x99\xac\x83\x10\x13\x65\x17\x0f\x5e\x30\x1d\xd8\xfb\x84\x3d\x3e\x94\x85\xa3\x09\xdf\xdf\x75\xda\x6f\x15\x3c\xe0\xe4\xe1\xd8\xba\xf5\x67\x2f\x3b\xd1\x50\xdd\x33\xad\xdc\xdc\x25\xce\xd0\x81\x3a\xbb\x64\xdd\x29\xc6\x2f\x58\xa9\xc6\x78\x7c\xe2\x3c\x46\x49\x61\x93\xdc\x83\x97\xae\xfd\x0a\x2e\x50\x36\x3d\xac\x7b\xcc\x99\xaf\x94\xbe\xcb\x4f\xb9\x6a\x6f\xb4\x0d\x3b\xd5\xad\x92\x2b\x49\xc6\xbe\xb1\xe3\x92\xc4\x01\xbd\x74\xc8\xbe\x93\x3a\x7f\x13\x1b\xda\x76\xe0\x35\x23\xe7\x16\x80\x61\x43\xb8\xd4\x1c\xd4\xc5\x0b\xbc\xe1\x94\xbf\x8b\x6b\x35\xeb\xae\xa8\x01\xf5\xf1\x9f\xd0\x21\xf8\xec\x76\xde\xf9\x5f\x71\x26\x3c\x7b\xba\xdc\x99\xf0\xec\x76\xfe\xf4\xe1\xbe\x9f\xdd\x61\x5e\x0c\xa5\x93\x3c\x30\x6e\x60\x95\x34\x18\xee\xfb\xa0\x00\xf2\xec\x76\x57\xa9\x1b\x67\xbd\x58\xb7\x59\x2f\x9e\x5f\xab\x58\xbd\xe6\x58\xd1\x5a\xd7\x26\x1f\xec\xf0\x51\x72\xbb\xab\xc1\xad\xaa\x50\xfd\x5b\x16\x52\x33\x65\x0f\x21\xf4\x47\x33\xd3\x26\x97\x76\x7d\x11\x4e\xf3\x73\x5a\xa4\xb4\x31\x16\xf3\x5b\xed\xd4\x7e\x41\x8b\x1c\x6f\x32\xe1\x65\x34\x81\xb9\x3a\xe3\x5e\x10\xda\x0b\xaf\x6a\xf5\x81\x4e\x89\x79\xc8\xe2\xa2\xf1\x6c\x58\x7b\xfe\xdc\x3d\x64\x0f\xae\x29\x3a\xb4\xf6\xfc\xd9\xc2\xa8\xea\x76\x2a\x7e\xa1\x59\x9a\xa8\x48\xd1\x2e\x9e\xb1\xfb\xf9\x36\x20\x78\x2b\xd6\x95\xc8\x08\xe9\x3d\xd2\x91\x33\xca\x14\x09\x39\x6f\xc1\xe3\xe4\x68\xe7\xfd\xd6\xd1\xfe\xfb\xd3\xc3\xbf\xbf\xfb\x61\xff\x67\x7b\x7d\x33\xce\xdd\xae\xfa\x4e\x1e\xec\x15\xd7\x55\x7d\xff\x7f\xbb\xf5\xe1\xff\x9c\xd6\xa1\xb5\x6c\x2c\x5b\x0b\x74\x9b\x3f\xb0\x21\x2f\x98\x06\x2f\xa6\x2c\x86\x0c\xef\x26\x41\xef\x7b\xa5\xf7\x84\xdc\xca\xda\x3d\x76\xc2\xca\x31\x4f\xdc\x0c\xf8\x79\x49\x41\x8d\xaa\x72\x3c\x43\x4b\xab\x57\xc1\xbc\xbe\x08\xf0\x07\x46\xc4\xac\x80\x12\x08\x69\x7e\xce\xcf\x30\x47\xb5\x01\xa5\xd2\x2e\x3b\x20\xa8\xd0\x55\x59\xfa\x0e\x18\xa3\x7c\x50\x63\x7a\x9b\xa3\xe6\x62\xd7\xfc\xdd\x9e\x60\x6c\xe4\x20\x53\x6a\xc4\x47\xc4\x6a\x7f\x75\x23\x75\x6c\x3e\x52\x87\x9b\x0b\x11\xfc\x7e\x74\x3b\xbc\x04\x86\x21\x12\x12\x45\x91\xfd\xf3\xca\x19\xa5\xae\xea\xf7\x1a\xf1\x70\x45\x26\x74\x3e\x60\x1a\x88\x6a\xa3\xeb\xfb\xbd\xd6\x48\xb8\x32\x69\x90\xdd\xeb\xab\x3b\x33\x17\x8a\xab\xc4\xf1\xb0\xe1\xb5\x42\x37\xa0\x0a\x3d\x3c\x7c\xe8\x37\x3a\xae\x34\x00\x75\xa5\xdf\x22\x44\x57\x5a\xf4\x71\xd4\xcd\xee\x40\x1a\xf2\xe8\x1b\x3f\x4f\xdd\x72\xc3\xa6\x90\xf7\x48\xf0\x0d\xcf\x32\x95\xfb\x9a\x0f\x15\xed\x49\x82\xa4\x90\x0e\x9c\x5f\x90\x84\xc5\x19\x55\x19\xce\x69\x9e\x90\x73\xb9\x0b\x4d\xc2\x73\xc8\xbd\xab\x9a\x17\x0a\xe7\x62\x36\x9d\x66\x29\x66\xdc\xd6\x25\xa1\x54\x12\x64\x11\x91\x1d\x2c\xed\x48\x66\x82\x8e\x98\x4f\x74\x10\xa2\xa2\x32\xd1\x2b\xce\xd0\x6e\xf9\x2c\xa7\x65\x69\x03\xc2\xcb\xe6\x5b\x45\x99\xc6\xe0\xc9\x07\x0d\x23\xa7\xfc\x4d\xdb\xa1\x3e\x93\xc6\xb7\xef\xd3\x64\xaf\x47\xb6\x72\x95\xa1\x9d\x66\xda\x00\x21\x5b\x83\x9b\x57\x22\x65\x1d\xe3\x6d\x75\x3f\x72\x3f\x75\x5e\xf4\x71\xd8\xca\x58\xd5\xad\xec\x24\xec\x45\xcf\x28\x01\xcd\xa8\xd7\x45\x4c\x4b\x36\xe2\xc5\xdc\x87\xaf\x9f\x6a\xe0\x90\x9a\xbb\x7d\xdc\xda\x63\x17\xa2\xd5\x6d\x1d\x8c\x79\xc9\x45\xcb\xcb\xb8\xdd\xd0\xb3\x37\x9d\x94\x66\x7c\x74\x1f\x97\x4c\x0d\x49\x10\x9a\xdb\x2c\xe4\x7c\x48\xb6\xa1\x91\x3f\x5b\x78\xa4\xc7\xa2\x1b\xef\x0f\xdb\xd8\xd6\xcb\xfb\x6d\x77\x6b\xd7\xfe\xc6\x7c\xf5\xd6\x7a\x04\x96\xe5\x28\x8a\xd4\x96\xb6\xd5\x54\x4c\xf2\xf2\x89\xe4\x9d\x43\x5e\x4c\x28\xf2\x4e\xc8\x2a\xaf\x09\x6f\xcc\x2f\x24\x27\x13\xcc\xd0\x2c\xe6\xb7\x67\x89\x4f\x53\x90\x5d\xa3\xbf\x49\xa8\xbc\x1b\x5c\x0e\x38\xcf\x2e\xe5\x08\x2e\x91\x67\x5c\xe6\xb3\xc9\x80\x15\x97\xb8\x70\x97\x0a\xc5\x51\x14\x9d\x74\x2e\x9d\x39\x42\x66\x5d\x05\x50\xee\x07\x09\xd0\xa7\xcb\xe8\x8b\xec\xe8\xaa\xed\xa0\xa1\xf3\xda\x19\xc8\x0e\x8d\xc7\xb0\x7d\xd8\x39\x2b\xe6\xde\xa6\xc2\x74\xda\x50\x92\xad\xce\xa8\x05\x9d\x30\x48\xa9\x4f\xcb\x59\xc1\x22\x90\x55\x10\x22\xec\x4e\x3c\x3a\x80\xe6\x15\x5e\xe2\x99\x28\xf9\xc4\xdd\xa5\x1a\xa8\x88\xa0\x60\xb7\x2d\xad\x6a\xb1\x84\x5b\xe9\xe7\x34\x3f\xbb\x66\x1f\x35\x6c\xa3\xf0\x2e\xe2\x05\xf9\xf0\x7e\xd7\xa3\xbe\x71\xc1\x86\x1e\x95\xcb\x07\x0e\x4d\xa8\x42\x61\xf2\x9f\x3d\x28\xcd\x6c\x38\xc7\x9e\x75\x63\xd2\x24\xa9\x63\x75\xa6\xbf\x28\x7b\x17\x7c\x7d\xac\x3f\x3e\xf1\x4e\x11\x1d\x72\xa3\x1a\xdf\xc3\xab\xba\x13\xa6\xe2\xbe\xdb\x24\x2d\x9c\x83\x14\x02\x3c\x28\xf2\x7f\xf7\x1c\x38\xce\xed\xf3\xc3\xfb\xdd\x4e\x75\x84\x86\x11\xe7\xec\x82\xa0\x2e\xa0\x06\xae\xb5\xf3\x79\xca\xe2\x92\x25\x84\x3a\x98\xa3\x39\x20\x6f\xc8\x0b\xd2\x22\x8f\x0d\x46\xd0\x83\x24\x97\xcf\x6a\x80\x3c\x5c\x55\xde\xfa\x47\xaa\xdd\x73\xde\x6f\x67\xbb\x86\x76\x6b\x14\x45\xba\xad\xbf\x55\xff\x03\xea\x42\xe4\x34\x53\x47\xab\xce\x88\xbc\xb7\xbf\xf7\xf7\x77\xfb\x1f\x0e\xa5\x68\xf4\xea\x15\xcd\x79\x3e\x9f\xf0\x99\xf8\xfe\xfb\x16\x78\xcd\xf5\x7a\x64\x17\x72\xd6\xd3\xbc\xbc\x87\x7f\xff\xc4\xd8\x14\xc5\xe4\x2c\x85\xbb\x3d\x11\xf3\x3c\xc6\xed\x60\xd3\xce\x13\xa8\x95\x81\xd5\x1a\x3e\x45\xbd\x21\x05\x09\xfb\x63\x5a\x8e\x8f\xa4\x50\x98\xe6\xa3\xc3\x71\x3a\x11\xd1\xaf\x50\x72\x9a\xd4\x05\x57\xa5\x58\x21\xc8\x15\x74\x5c\x89\xb1\x37\xca\x36\x50\xaf\x8f\x15\xed\x16\x34\x69\x75\xb0\x86\x8b\xe4\x1f\x8b\x9b\xcb\x16\x8c\xe6\xfa\x03\x89\xbf\xc5\x1f\xd8\xc3\x1b\xbf\x40\x8e\xb4\xf8\x1b\x6c\xa3\xbf\x40\x56\xb6\xf8\x0b\x65\x95\x50\x5f\x20\x99\x2d\xfe\x42\x6d\x00\xfd\x85\x72\xef\x5b\xf8\x85\x32\x6f\x76\xb1\xaa\x0e\xcd\x0d\x66\xb7\xf2\xb9\xdb\x52\xc1\x04\xcc\xee\x0f\x4d\x23\xfc\xd3\x69\x88\xcd\x54\x91\x17\xdd\x4c\x5d\x00\x02\xf0\x2c\xc3\xd6\x6d\xb5\xab\x5f\x0d\x66\xce\x13\x13\x4e\xb4\xc7\x93\x2a\x24\xc4\x96\x85\xb3\xaf\xfe\xae\xc1\x81\x03\xc3\x8c\x2c\x9f\x4d\xc2\x2d\xe4\x53\xdd\xea\x43\x9e\xf2\xbc\xd6\x4c\x8c\xa9\x6d\x72\x28\xff\xa8\xe3\xe1\x33\xb5\xab\x7c\x08\x77\xe4\x50\xc3\xab\x0d\x4f\xbe\x4b\xf3\x0c\xee\x0e\x4a\x19\x90\x0a\x32\xe5\xd9\x7c\x98\x66\x99\x2d\x45\x85\x62\x80\x64\x3c\x31\xcf\xc5\x6c\xc2\x0a\xc8\x42\x00\x45\x5b\xd2\x82\xf0\x8b\x1c\x61\xe9\x80\x50\x55\xa1\x82\x15\xd1\x84\xff\x23\xcd\x32\x1a\xf1\x62\xd4\x63\xf9\xea\x87\xc3\x5e\xc2\x63\xd1\xfb\xc8\x06\xbd\xff\xa4\xe7\x14\xa3\x5c\x7b\xef\xd9\x90\x15\x2c\x8f\x59\xef\x6f\x70\x31\x3b\xc5\xc1\x88\x1e\xfe\xdb\x53\x47\x5a\x0f\xc6\x5d\xd7\x00\xbb\xa9\x79\x7d\xc1\x3d\x15\xed\xcf\x5d\x62\xdc\x07\x7b\x3d\x9b\x90\xb8\x92\x83\x58\x72\xff\xcf\x20\x2d\xcf\xbd\x22\x56\x87\x25\x9b\x0a\xb2\xb6\xfa\xbc\x4b\x5e\xae\xae\x3d\xa9\xbe\x78\x11\x0d\x56\x5f\x44\xac\x4f\x1e\x3f\x91\x47\xc6\xea\x13\x5f\xbc\xfe\x0c\x67\x05\x64\x8d\x5b\x23\x3d\x82\x1d\xc8\x5f\xf3\x60\x88\x9c\x02\x4b\x5e\x44\xb4\x4f\xf6\xe8\x1e\xd9\xdc\x94\xff\x84\x60\x7e\x96\x27\xd3\x1c\x7e\xce\x5d\xd1\xdd\xc1\x10\xcb\x1b\x10\xe4\x2e\xff\x47\x90\x89\xe4\x69\x02\xa7\xcf\x6a\x96\x9e\x19\x7b\xbc\x3c\x5b\x06\x34\x3e\x83\x62\x7a\xf0\x79\x99\x0e\x52\x4c\xe0\x2c\xc8\x94\x71\xa8\x2b\x46\xe7\x24\x36\x85\x81\x2c\x07\x45\xc5\x46\x36\x07\xa1\x26\xcd\xa5\x7c\x56\x6a\x7a\x99\x95\xd3\x59\x19\x91\x1f\xf9\x05\x83\xca\x37\x17\x8c\x24\x26\x0e\xba\x60\xea\x9c\xc0\x11\x49\xd9\x73\x2e\x25\xbd\x48\x8e\x15\x9b\xf9\xe0\x44\x49\xe3\x33\xd9\xea\x82\xce\xbb\xd0\x1d\xca\x3b\x58\x82\x67\xa2\xc8\x1c\x94\xe9\xe3\x74\x00\x6c\x29\x9b\x13\xf6\x79\xca\x72\x91\x9e\x33\xb9\xf4\xe5\x98\xcd\x41\x3e\xc4\xcd\x23\x6f\x26\x9c\xf0\x61\xc9\xf2\x2e\x11\x33\x29\x99\x09\x72\x31\xa6\xa5\x22\x73\x3a\x95\xdf\x42\xcd\x36\x53\x0e\xa7\x03\xe8\xa2\xf9\x1c\x25\xca\x01\xde\xec\xa1\xce\x5a\xce\x50\x9a\x06\x9f\x61\x96\x44\xf5\x0b\xa6\x46\x1b\x4a\x00\xaa\xe0\x8b\x97\xd1\x47\x3d\x93\x17\x4b\xfc\xb5\x61\xdf\x21\x02\x36\x49\xab\xa5\xb3\xfa\xf4\x7a\xe4\x1d\x3d\x63\xe4\x93\x23\x7e\x00\xec\x4f\x44\x94\x72\x6b\x83\x9d\x45\x0e\x18\x89\x4a\x5e\x3a\x00\xd9\x72\x6c\xde\x60\xbc\x14\x74\x95\x27\x7e\xd5\x5b\x25\x10\x8e\x69\x0a\x74\xe7\xf2\x5f\x25\x6c\x32\xd7\x07\xec\x06\xe5\x63\xb4\x28\x37\xa1\xf9\x8c\x66\x7a\x78\x50\x34\x97\xc6\x63\x66\x2a\x29\x84\xdb\x7d\x44\x0d\xd7\x1b\x3e\x03\x6d\xd8\x13\xbb\x5b\xdc\xc1\xcb\x91\xc2\x3a\x3a\x97\x25\xb2\x58\xda\xc4\x12\x6f\xf2\x73\x6c\xf2\x76\x96\x65\xf8\x5c\x80\xde\xcb\x0e\xde\xfb\x8c\x6c\x56\xfe\xbe\xbc\xb4\x92\x90\x9e\x86\x0b\x4f\x09\xae\xe6\xcf\xcb\x4b\x33\xa2\x0d\xb7\xc2\x1d\xf6\x0a\x38\x0c\xa9\xe1\x5c\x1b\x05\x86\xc8\x34\xe8\xc7\xf4\xff\x7a\x3d\xb2\xc7\x2e\xc8\x80\x8d\xe9\x79\xca\x0b\x2c\xb1\x26\x69\x66\x26\xe4\x01\xc0\x87\xe4\x93\x1c\xc7\xaa\x24\x05\xf1\x89\x4c\x69\x7c\x46\x47\xcc\x01\x60\x94\x90\xed\x15\x57\x0c\x35\x65\xe2\x1c\x11\x57\x2e\xa6\xdc\xb0\x96\x7f\x28\x9a\x91\x0c\xc0\xb0\x12\xe5\x19\xad\xaa\x0a\xda\x32\xba\xa1\x71\x44\x5a\x04\xb6\x9d\x7c\x10\x8c\x7c\xb2\x37\x32\x5f\xed\xd8\xee\x7c\x92\x07\x9e\x64\x65\xc0\x36\x02\xdf\xbf\x67\x34\xc1\x4b\x27\x2d\xe1\xac\xeb\xf7\x7a\xc3\x41\x34\x61\xbd\x99\x60\xab\x00\x6e\xd5\x8e\xa4\xb5\x52\x95\xae\x89\xc3\xf2\x97\xde\x02\xce\x0d\x44\x1e\xbe\x3c\x53\xf7\x0f\x63\xe3\x69\xd5\x56\x6d\x3f\x4b\xec\xaa\xc9\x05\x53\xac\x1a\xcb\x92\xe1\xf5\xcd\xcc\xdb\xf9\x14\x74\xb1\x72\x47\xfd\x04\xce\x40\x3e\x95\x3e\x26\xad\xbe\x7b\xd1\xd8\x70\x17\x7a\x48\xfc\x25\xbe\xd7\xb0\x55\x8f\x35\xf8\x13\x75\x6f\x72\x87\xbd\x05\xb2\x86\x98\xd2\xc9\x44\x97\x4f\xd3\x33\x1e\xb0\x98\xca\xb3\xc1\xf0\x69\xe0\xcd\xe8\x26\x0f\x68\x82\x93\x8e\x7d\x8e\xd9\x14\x8f\xad\x2c\x1d\x10\x3a\x2b\xc7\xbc\x10\x5e\x37\x0b\x58\xc3\x2b\xf2\xd4\x5d\x31\x0f\xa9\x44\xeb\xc9\xfd\x69\x06\x69\x99\x90\xd6\xdf\x55\x35\x3d\xec\x2d\xc3\x03\x52\xce\x89\x56\xb1\xef\xde\xc3\xab\xf4\x46\xac\xe2\x0e\xe6\x04\x94\xfe\x8d\xc0\x82\xec\x84\xe7\xf0\x07\xde\xf8\xe5\xce\x48\xd8\xb4\x60\x31\x9c\x5e\x01\x48\xe8\x11\x05\xb4\x5d\xf0\x0b\x6d\x82\x90\x87\x43\x42\x33\x79\x42\x2d\xb7\x87\xd4\xe4\xe4\xa1\x3f\x60\x44\x30\x86\x2b\x95\x0a\x63\x48\x48\x66\xa0\x5d\xa6\xf2\x69\x91\xac\x4e\x69\x51\xce\x9d\x6d\x1d\x00\x98\xa5\x83\x82\x16\xf3\x88\x1c\x32\x66\x44\x48\xdc\x57\x58\x88\x50\x81\x5e\x4d\x78\x5e\xae\x4a\x54\xc2\x2e\x2b\x35\x3c\x88\x18\x21\x98\x68\x44\x44\xad\xea\x6a\x78\xac\xb9\xf2\xae\x76\x23\xb6\xeb\xbf\xb1\x80\x6e\x42\xf4\xec\x66\x3e\x08\x7f\xe5\x52\x1b\xa6\xf3\xd3\xff\xbb\x5a\xa9\xfe\xba\x72\xf8\x7a\x45\x6b\x41\x02\xa5\x6b\xd1\xa3\xcf\x28\x96\x3c\xda\x0d\x83\xa8\xc3\x20\xbe\x32\xc2\x17\x49\x5a\x47\x63\x06\xb8\xd6\x47\x1e\xe8\x19\x3e\x69\x86\x60\xce\xa6\xc7\xa4\xf5\x49\x12\xe3\x84\x16\x67\x2c\x91\x62\x93\xd1\x6a\xca\xb6\xed\x96\xbc\x91\xcb\x5f\x35\xe6\xf2\xa9\x4b\x06\xb3\x92\xa4\xa5\x50\xee\xc9\xa9\x20\x9f\xe4\x18\x3f\x45\xad\x4e\x27\x8c\xad\xdf\x77\xc0\xa8\x45\x21\xed\xd6\x0d\x06\x6c\xb8\x72\x65\xd4\x76\xcc\x7a\xc4\xa6\xf0\x7c\xed\x16\x40\x1c\xcf\x6a\x10\x9b\xae\xd1\x7a\x35\xc9\x21\xb5\x5a\xc4\xf0\x0f\x1a\xdc\xc0\x5e\xf4\x46\x0b\x3d\x92\xd9\xeb\xdf\xd1\x20\xcd\x93\xb6\x1c\x9e\x76\x28\x40\x30\xd5\x6f\x1c\x45\x66\xd3\xe7\xda\x7d\xd8\x99\x52\x15\x8a\x09\x4d\xac\x88\x91\x41\x05\x02\x53\x7a\x30\xf9\x4c\x53\xae\xf9\xee\x96\xc8\xaa\x0b\x6d\xcb\x28\x0f\x9d\x66\x0a\x8f\x98\xcb\x1f\xfe\xb2\x5a\x40\xcf\x91\xde\x34\x96\xc7\x78\x68\x4a\x04\x8f\xc3\x4f\xe6\xf3\x4f\x64\x00\x7c\xd6\xd1\xc0\x77\x89\x90\x97\x1d\x39\xe1\x5e\xc1\x46\xec\xf3\xb4\x4b\xa6\x54\xa0\xba\x57\x2b\x73\x5c\x68\xb0\x40\x48\xb1\x17\x0c\x2b\xe6\x0e\x87\xac\x20\x14\x05\x1a\x79\x74\xa4\x82\xe1\x2d\x40\x5f\x31\xc8\x98\x15\x8c\x14\xb4\x1c\x83\x85\x9b\xe6\x2e\xc0\x16\x1f\xe2\x4d\xe7\x13\xf6\xf6\xa9\x15\x99\xd7\x88\x13\x80\xe8\xa2\xc5\x3c\xf0\x30\x53\xdb\x19\xf5\xbd\xbc\x9b\xc3\xea\x2e\xbd\x9f\xf5\xd0\x9c\xed\xeb\x0e\x07\xda\xb8\x46\xa8\xc6\x0d\xae\x97\x87\xb4\x3a\x16\x94\xbb\x66\xd0\xce\xdd\xea\x15\xc7\x21\xbb\xcd\xaf\xbc\x6d\xb0\xc4\x5d\xa9\x69\x6b\x54\x75\x65\xbe\x8b\xee\x02\xc8\x9e\x03\x41\x24\x6f\xa4\xca\xbc\xbc\x27\x4f\x82\xc6\xee\x6a\x5a\x37\xb0\x32\xaa\xdf\x77\xbd\x0d\x2b\x51\xfc\x28\xf7\x3a\xfd\xa1\xec\xbb\xa8\x2e\x78\x80\x7c\x4c\x3a\xa7\x66\x72\xb1\x55\x58\x1b\x68\x01\xd2\x68\xa6\x8a\x0e\x35\x7c\x29\x80\x22\x31\xa6\x39\x14\x61\x56\x1a\xcb\xa8\x55\xa3\x87\x25\xb9\x09\x38\x10\x62\x7e\x65\x1d\xef\x63\xf7\x8a\x3b\xdb\x1b\xb1\x9d\xdf\x7d\x6f\xa9\x71\x7c\xc5\xc6\xa2\x39\x22\x2d\xb4\x87\x4c\xc0\xab\xca\xe4\x9c\x92\x57\x16\x87\x3a\xf9\x11\x49\x1f\x3f\xae\x22\x06\xb9\xd8\xa6\x4b\x38\x16\x2b\x5d\x92\x2e\x49\x8c\x72\xac\xc7\x72\x06\xa9\xfc\x75\xd2\xea\x86\xef\xd5\xbe\x87\x1f\xf6\x5d\xd5\xbb\xf8\x82\x96\x5a\x0d\x68\x5a\x97\x11\x7e\x7f\x16\x12\x52\x91\xff\x6e\x1b\xf9\x26\x94\xef\xfb\xf0\xfc\x4f\x27\x7d\x5d\xa5\x1e\xa8\x4a\xcd\xf9\x8f\x3d\x4b\x02\xf6\x0f\x23\x65\x81\x69\xf7\xf7\xe5\xef\xf7\x6a\x17\x13\x67\xdf\xf8\xe3\xa8\x6d\x71\xf7\xad\xd2\x92\x79\xcf\xa2\xbc\x49\xb7\xa6\xc2\x45\xe3\x72\x46\x33\xf7\xf3\x11\x2b\xcd\x9f\xd5\x81\xfd\x51\xf4\x54\x1d\xd5\xd7\x8b\x2a\xae\xbb\x86\x27\xb6\xf8\xc0\xff\x58\x7a\xab\x58\xc0\x0c\xad\xc1\x9e\x15\x5e\xb2\x04\xff\x10\xac\x34\xb4\xd4\xb0\x9c\x0e\xed\xb5\xd1\xdf\xa0\xc2\x86\x98\xb5\xd2\x11\xbd\x1e\x92\x41\xab\xef\x1f\x52\x2e\x3a\xf5\x81\x45\xfa\x04\x54\x56\x4f\x36\x7c\xc4\x2d\x14\xb4\x36\xdc\xcb\xd8\x3f\x8d\xdb\x86\x8e\x56\x1f\xc7\x4d\xe7\x2b\xaa\x1a\xdc\xe3\xd4\xff\xee\x38\x3d\xe9\x04\x4f\x3b\xf7\xc6\xeb\x1e\x76\xce\xc0\x31\xe4\xdd\xc4\xd6\x55\xe2\xfb\x2b\x34\x50\x41\xfa\xdd\xec\x47\xbc\xc9\x9b\xf7\x88\x45\x78\x89\x9b\xf4\x66\x5b\x91\xe7\x40\x2f\xb2\x9d\x37\xb5\xc7\xa4\x65\xf7\xdd\x9d\x6d\xae\x80\x11\xfa\x4f\x51\xbd\x51\x54\xd7\x26\xfc\xaf\x97\xd5\x6f\x77\xf3\x37\x1e\x17\x4b\xe1\xe5\x9f\x2d\xaa\xe4\xda\x97\x78\x91\x98\xae\xf2\xd2\xd8\xc9\x57\xd8\x86\x95\xdd\xc7\x54\x38\xf1\xa0\x6d\x37\x57\xad\x73\xc4\x2f\x96\xe2\x21\x4f\xc1\xd2\x72\x7c\x24\xe7\x08\x9f\x5c\x23\xc3\x2f\x2f\xc5\x37\xc9\xf1\x8b\xf4\xb9\xbf\xdf\xd1\x5a\x75\x1b\x69\xd3\xda\xc5\x7d\xd1\x01\x1b\x6a\xfd\x47\x9c\xb2\x47\x10\xe7\xf5\x07\x9c\xb4\x81\x03\x2f\x30\xe7\xf0\xa9\x67\x82\x14\x54\x92\x8f\xda\x67\xc7\xa9\x77\x8f\xd1\xf6\xba\x6b\x19\x61\xc0\xaa\x54\xb3\x28\x2d\x89\xc4\x88\xec\x54\xef\xd4\x44\x8f\xc1\xba\x78\xa2\x06\xd0\x37\xc2\xb4\x0a\x16\xb3\xf4\x9c\x25\xe4\x1b\x41\xa8\x2a\x8b\x44\xbe\xa9\x98\x52\x24\x7b\xe3\xa2\x1c\xa6\x9f\xdf\xf2\xc2\x31\x67\xb4\xd5\x2c\x3b\x6e\xe3\xd4\xfc\xae\x0b\xce\x4b\xac\x59\x45\x65\x7d\xf7\x27\xd6\xad\xa8\xe1\x66\xf4\x80\x14\x11\x3b\xfc\xeb\x6b\x94\xd3\x61\x83\x7e\xd0\x8a\xb3\x9c\xb8\x75\x77\x47\x8d\x4b\x8d\x0b\xed\x25\xbf\x83\xc8\xe3\xb9\xe6\xfd\xbe\x57\xd5\x54\xc8\xce\x6a\xf7\xc2\xdf\xe7\xf8\x5e\x1a\xa7\x9e\x3a\x01\x88\x44\x8e\xf2\x8f\xbd\xd4\x55\x9d\x0c\xdb\x42\x3f\xf8\x1d\xd5\x07\xff\x83\x64\xb4\x80\x74\xf6\x35\x97\x0d\x6d\x87\x59\x46\x44\xab\xaf\x50\x9d\xad\xd9\x36\xa6\x4e\x85\xb3\x1d\x62\xff\x52\x81\xff\x8b\x79\x5e\xa6\xb9\x6b\x05\xbf\x0a\xea\x65\xe3\x3f\x4c\x9a\x33\xb2\xdc\xbf\x96\x02\x36\xec\x9d\xfb\xe7\xc6\xf9\x97\xdb\x38\x90\x9e\x8f\xe4\x0c\x61\xa1\x30\x45\xb3\x0c\x0b\x37\xa4\x39\x89\xa9\x60\x44\xf0\x09\x03\x7f\x1f\xe3\x3a\x20\x85\xac\x49\x2a\xc0\xdf\x6a\x58\xf0\x89\x85\x06\xe8\x8e\x1c\x24\xd3\x2c\x53\x99\xad\x30\xc4\x16\x22\xf9\x2b\x8b\xd2\x75\x37\x6c\x4d\x85\xa3\xf6\xb4\x02\x74\xa7\x1b\xba\x71\xcd\xbc\x6b\xd0\x8d\x17\x50\x8e\xf8\x93\xda\xc2\x4b\x5f\x47\xa3\x9a\x3f\xde\x7f\xe7\x3f\xd0\xc4\x44\x37\xc8\xaf\x2a\x1a\xa3\x1a\x1a\xd1\x2f\xa1\x45\x40\x49\x5a\x05\x06\xa6\x07\x58\x59\x04\x56\x85\xa6\x3c\xe4\x21\xa3\xae\xb3\x1e\x1e\x54\x07\x66\xd0\xfb\xe3\x7f\x06\x17\xbc\x3d\x1b\x74\xa4\x29\x4f\x55\x20\x2e\x52\x48\xc9\x51\x8d\xb9\x72\x7c\x69\xe5\x8e\xd3\x01\x2e\x7d\xef\xa1\x8a\x48\xf1\x1f\x5a\x3f\xc9\x7e\x95\x15\xb9\x0e\x5b\xd8\x58\x07\xe7\xd4\x9a\xde\x33\x23\xf1\x3f\x50\x7c\xae\xef\xa1\x7a\x19\xfb\xad\x81\x6c\x95\x22\x10\xf9\xd7\x46\xcc\x04\x89\xc7\x8f\x50\xd3\x3e\x5c\x98\x3c\x73\x09\xbb\x59\x70\xde\xce\x95\xe0\xda\x90\xee\x90\x75\x2d\x18\xd0\x1d\x00\x17\x88\xe7\x0e\x81\x53\xd9\xf0\x4a\x36\xad\x6a\x64\x9c\x71\xc9\x13\xc6\x41\x1b\x56\x5e\xad\x39\x6c\x62\xfe\xbb\x7b\x6d\x55\x9e\x59\x7f\xaf\xea\xf3\x76\xa2\x84\xe7\xac\xfa\x91\x2f\xeb\xcb\x2f\xa3\xf3\x00\x1e\x3d\x6c\x7a\xc9\xfe\xeb\x8b\x56\xfd\xab\xe6\xec\x45\xf0\x60\xd0\x78\x46\x2f\xcd\x69\xc1\xcf\xd3\x84\x11\x39\xb9\x39\x39\x3e\xeb\x9e\x9f\x90\x72\x36\xcd\x98\x70\xfd\x71\x94\x56\x39\xba\x8b\x89\x03\x67\xca\x55\xb9\x3d\x33\xf1\xea\xbc\x80\x93\xe4\x90\x6e\xba\x8e\x10\x17\x77\xd0\xe8\x78\xad\x6a\x0b\x58\x06\x77\x55\xec\x2d\xc4\xe6\xca\x02\xbc\x86\x3b\xb9\xaa\x79\x1c\xb9\xfb\x41\x65\xae\xa9\x31\x00\x07\xc8\x55\x80\x9b\xa9\xd4\xa8\x5a\x18\xe9\xd6\x39\x57\xaf\x47\xf6\x28\xd4\xc1\x54\x39\x23\x8c\x26\xce\x8a\x59\x4e\x1d\xb3\x5a\xa4\xbe\x53\x57\x6b\x45\x03\x5c\x36\xe3\x28\x42\x56\xd9\x45\xbd\x7e\x61\x88\xc7\x2d\xaf\x79\xcb\x6f\xbf\xd4\x48\xde\xba\xf9\x1a\x73\x9e\xaf\x8a\x29\x8b\xe1\x24\xcb\x20\x0b\x89\xce\x86\x79\x31\x4e\xe3\x31\xc8\x4a\x3a\xca\x4c\xc5\xc3\xb8\x7a\xb3\xc6\x6c\x1b\xd3\x50\x58\xad\xae\x49\x72\xdd\x28\xab\x0b\x79\xa5\x42\x4c\x77\x7e\x9b\xa5\xe7\x34\x63\x79\x09\xa6\x52\x1c\xc3\x27\xf4\x94\x4b\xcb\x31\x46\x96\xd3\x8c\x8c\x69\x9e\x80\x13\x37\xc4\xf9\x80\x7e\x8d\xe6\x09\x41\xef\xbb\xa8\x92\x2e\x22\x20\x2c\x3b\x89\x22\x1c\xc1\xba\x7a\xd0\xd9\x5c\x0e\xd7\x9f\x22\x6a\x46\x2a\x02\xd5\xbd\xa2\xf8\x27\x85\x83\xac\xf7\x6c\xb4\xf3\x79\xea\x45\xb8\xed\x67\x09\xb9\x60\x83\xb3\xb4\x14\xa4\x4d\x4b\x92\x31\x2a\x4a\x32\xcb\xcb\x34\xd3\xa5\x1e\xc9\xb3\xe8\x89\xc9\xf7\xeb\x2c\x49\xdd\x35\x10\x1c\x03\x55\x82\x4b\xf0\x59\xc7\xe9\x51\xd5\x71\x44\x3e\xb2\x56\xf6\xff\xd9\xfb\xf7\xf7\x26\x72\xa4\x51\x1c\xff\x79\xf2\x57\x88\xec\x2c\xb6\xc1\x97\x38\x37\x20\xd9\x2c\xc3\x84\xb0\xcb\x3b\x03\xe1\x21\xcc\xcc\x77\x4e\x26\x07\xda\x6e\x39\x6e\xd2\xee\xf6\xdb\x6a\x27\x64\x20\xdf\xbf\xfd\xf3\xa8\x4a\x97\x92\x5a\x6d\x3b\x24\xb0\xec\x79\x66\xce\x7b\x96\xb8\x55\x92\x4a\xa5\x92\x54\x2a\xd5\x25\x65\x19\x38\xed\x27\x7f\x72\xb4\x1d\x07\x3b\x43\x91\xa3\x97\x54\x6f\x90\x46\x3d\x22\x30\x47\x42\x70\x61\x2d\xc8\xbb\x24\xa8\x09\xa1\x81\xea\xd4\x27\xc2\xdc\x95\x59\xa5\xa4\x49\x22\xc8\xfc\xdb\x9e\xae\x4f\x39\x07\x2c\xef\x81\x2d\xb8\x40\x33\x4a\xb4\x49\x87\xad\xf9\x1d\xe1\x82\x77\x5d\x76\x98\xa5\x97\x10\x7d\x00\xc8\xe2\x98\x59\xc2\xfe\xdd\xeb\x81\xf9\xfb\xbb\x7a\xf3\xd7\x77\x55\x1e\x0b\x19\x54\xd2\xf4\x3d\xbe\xe3\xfa\x9e\xeb\x38\xa2\x3d\x89\x5c\x79\xa2\x4a\x15\xe7\x35\x94\xd2\xe6\x1a\x97\xc4\xea\x46\x57\xb9\x22\xd6\x32\xed\x53\xe2\x3a\x46\xf1\x92\xb2\x65\xc3\x33\xa2\x5e\x9a\xf3\x6d\x33\xb8\x82\x1b\xbe\xea\x79\xc1\xe4\xeb\xd0\x3c\xc6\x27\x1f\x98\x17\xdc\x67\x41\x4b\x8e\x77\x99\xc8\xf8\x45\x44\x83\x7c\x56\xe2\xfb\x06\x5e\x96\xe4\xec\xa8\x99\x27\x61\x17\xda\x6c\xd5\x4c\xd0\x2a\xcb\x0b\xb6\xaa\x6f\xbb\xb0\xca\x57\x7d\x1e\x08\xaa\xe4\xcf\xfd\x0d\xa7\x0c\x5a\xe1\xd2\x20\xdf\x54\xf0\xf6\x85\x6d\xdc\x5f\x76\xe6\x0b\xbe\x66\x33\x42\xab\xf9\x52\x91\x8b\xd5\xca\xd6\xf8\x15\xe6\xd0\xfd\xa4\xe6\x23\xd0\x74\xa5\xe5\xba\xd3\xda\xc2\x5c\x05\xa6\x6c\x98\x46\x42\x40\xc4\x09\x0c\xba\xa5\x1f\x83\xdb\x92\x7b\xa2\xec\xd2\x5f\x68\xae\x55\x50\x65\x99\xd9\xbb\x41\x97\xa4\xbd\x82\x98\xed\xc1\x92\x6e\xe6\x28\x64\x14\xca\x9e\x99\x52\x85\xff\xc2\xcd\x18\x8e\xf4\xa2\x8d\x54\x42\x6a\xb9\x1f\x76\xab\x35\x28\xb0\x5b\x04\x26\xda\x0a\x13\xbf\x04\x63\xf6\xd5\x46\x61\xbb\x42\x49\x7f\x5e\x58\xb7\xe6\x46\xab\xd5\xaa\x44\x89\xbb\x59\x5c\x5e\x3f\x4a\xdc\x5f\x61\xdf\xfc\xb0\x6f\xd7\x8e\xd3\x36\x27\xf0\x1a\xb2\xb2\x0d\x91\x39\x4e\x26\xb7\xe4\x84\x41\xbc\x5a\xf7\x16\x7a\xb5\xc2\x1d\x4a\xce\x11\x7a\x38\x8b\x68\xc4\xd9\xc5\x98\x67\xe0\x7c\x27\xcf\xdd\x22\x9f\x28\xf7\x3b\x67\xe5\x39\x22\x83\xef\xb1\xea\xbc\xc6\x7e\x61\x2f\x55\xf0\x4f\xad\x77\x4f\xad\xf5\x4e\xfd\x2c\xbf\x54\x9b\xe8\x4d\xce\x97\xeb\xcc\x23\xbf\xec\x7a\x7b\xe0\x91\x9c\x55\xcf\xd7\x40\xc3\x41\x33\x5f\x22\x58\x0b\x7d\x8a\x5d\x3a\x56\x8b\xc4\x8a\x06\x63\xb1\xbf\x31\xd6\x8a\xfd\xad\x23\xa9\xd8\x2f\x5a\x97\x68\xbf\xe8\x48\x28\xe4\x8b\x8a\x74\x82\x5f\xb0\xe7\xcc\xe9\xd7\xc4\x2d\x51\x74\xf3\xc2\x94\x58\x40\x1a\x90\xc4\x81\xc5\xf0\x23\x3e\x5e\x15\x30\x15\x5d\xa4\xfa\xed\x0d\xc4\x13\x71\xbe\xab\x00\x22\x2e\x4a\x18\x31\x44\x7d\x33\xb1\x41\x16\x9d\x25\xce\x96\x74\xab\x47\x89\x7f\x0c\xcc\x0d\x92\x6e\x37\x2b\xb5\x29\xbd\x7d\xbb\xec\x91\x10\xce\x08\x15\x6c\x70\xd5\xc6\xa9\x5d\x25\xd9\xe3\x31\x62\x6d\x6b\x77\xc5\x7b\xd9\xf9\xb1\xc8\xa3\x78\x28\x6f\x50\xcd\x24\x4b\xca\x24\x4a\x8f\x4a\x23\xbe\x42\xf2\xe6\x44\x94\x3c\xe3\x85\x30\x61\x0b\x60\xe3\x8e\x75\xa2\x1a\xf9\xeb\xad\x28\x31\xe3\x32\x6d\xc2\x8d\xb6\x20\xe7\x0c\x80\xfc\x45\x89\x75\x2b\x2a\x0a\x61\xe0\x45\x49\xc4\x69\xd3\x93\xc0\x2e\x18\x73\x12\x53\x53\x95\xb7\x41\x9c\x26\xa5\x70\x93\x4f\xa4\x3c\xab\xa6\xa6\x56\x2f\x15\x68\x64\x91\xf2\xcc\xb3\xa6\xe8\xf5\x40\xea\x32\x74\x91\x23\x13\x6c\x96\x89\xd9\x40\x0c\x8b\x64\xc0\x63\x16\xcf\x40\xc0\x36\x43\xb8\xe0\xec\xfd\x4c\x94\x4c\x9c\x25\x53\x96\x94\xe4\xfa\x60\x70\x3c\xc6\xec\xd6\x27\x27\x2d\xf6\x91\x55\xbf\x2a\x22\xec\x12\x61\x5f\x0b\x89\xa6\x5f\x7c\xf0\x89\xb2\x53\x08\x7f\x17\xdb\x6c\x96\x5c\xc3\x40\x38\xb3\xe7\xb1\x43\x66\x53\xdb\xe0\x12\xb8\x91\x99\xb1\xd6\x59\x06\xa1\x93\xb6\x8d\x09\xd6\x30\x35\x26\x72\xe0\x03\x4e\x62\xc1\x75\xd5\xab\x83\xbd\x92\x0d\x67\x45\xc1\xb3\xf2\xb9\xe4\xa9\x24\xc6\x39\xb0\x34\x30\xa5\x27\x6c\xcf\x7c\x56\x97\xb4\x98\xdd\x37\xf9\x92\xb4\x7e\x5f\x83\x13\x1a\x15\x7c\x92\x9f\xbb\x64\x90\x87\x1c\x7c\xd6\xae\xfb\x06\x63\x8d\x27\x25\x13\x99\x5e\xd6\x4c\x8c\xc3\xb2\x45\x32\x01\xec\xcc\x4d\xc8\x88\xb9\x3a\x5a\xa7\xe1\xff\x1d\xf3\x57\xdb\x30\xc8\x8e\xf9\xab\x6d\x27\x64\xc7\xfe\xd9\xa6\xfd\xef\x38\xc8\x5c\xad\x5c\x81\x40\x3b\x8e\x8a\x49\x9e\x5d\xea\x0b\x86\x12\x39\xd9\xbd\x5e\x68\xd7\x39\x36\xf1\xae\x25\xd2\x4d\x6f\x23\x08\x05\x41\xbe\x59\x16\x06\x77\x2f\x5b\xa9\xd9\xcd\x4c\x33\xde\x0e\x06\x7b\x8c\xd9\xc3\x20\xd5\x92\xce\xd9\xa1\x54\x5d\xc6\x08\xd7\x99\x01\x90\x1b\xdf\xba\x9d\xac\xd7\x25\x54\x69\x85\xe1\x37\x24\x3c\x04\x83\xcb\xa7\x4a\xe0\x78\x8a\xa4\x6b\xfa\x2d\x9b\x16\xce\xea\xf3\xfe\x6c\x6c\x38\x50\xeb\x73\x5a\x97\xe5\x06\x98\x7f\x28\x79\x16\x8b\x8d\x3a\x71\xda\x07\xdc\x9c\xd3\xb0\x6e\x4b\xd6\xd1\x74\xd4\x5c\xb3\x87\x27\xac\x1c\xd3\xee\x8a\x3d\x29\x6a\x9a\xca\x07\xef\xe5\x6e\xa5\x58\x3c\x1f\xbc\x67\x77\xef\xca\x7f\xba\x76\xfe\xd8\x63\xf8\xbe\xc3\x3e\x9a\xab\x2f\x7c\xb8\x92\x3b\xd9\x8a\x56\x49\x21\x23\x49\x39\x74\x10\x09\x0c\x0b\xac\xc3\x2a\x9c\x26\xe5\x78\x36\xe8\x0e\xf3\x49\x2f\x4a\x8a\x41\x36\xe8\x59\xc1\xb0\x03\xc8\xb2\x82\x4f\x73\x91\x48\x19\xac\x2b\x5b\x34\x41\x9a\x92\x8c\xe5\x05\x5c\x7a\x72\x56\xf0\x78\x36\xc4\xe8\x46\x28\x44\xc9\x6b\x4c\xcc\xa7\x3c\x8b\x79\x36\x4c\xd4\x8e\x09\x80\xb8\x53\xe4\x13\xce\xf8\x87\xb2\x88\x50\x2e\x07\x91\x42\xc8\xe6\x65\x13\x0a\xdf\x8b\x48\xc8\xa3\xe2\x8c\xc7\x5d\x24\x7f\x95\x1d\xeb\x19\xb5\x01\xc8\x83\x98\xbb\xc3\xfe\x98\xad\xaf\xad\xfd\xd8\xa0\x34\x37\x13\x61\xb4\x50\xc2\xbb\x94\x3c\xcf\x88\x8d\xaf\x9a\x84\xe6\x5a\xdb\x32\x81\x9e\xd6\x96\x79\xa2\x57\xcd\x00\x94\xc7\xe8\x2e\xb0\x87\x2f\x49\x9a\x8c\x37\x25\xaa\xab\x99\x65\x67\x59\x8e\xc6\xd1\x90\x0c\x57\x36\x0e\xdc\x6d\x9b\xc4\x3a\xdd\x51\x92\x96\xbc\x68\xba\x6d\x55\x14\x0b\x77\x0c\xa6\xbe\xd9\x35\x80\xab\xeb\x0f\x51\xd3\x51\x04\x48\x72\xee\x4a\xc3\xf2\x78\xb2\x16\x01\x21\x5a\x42\xd0\x18\x3d\x20\x15\x0a\x18\xae\xc8\xf8\xc0\xee\x74\xf4\x3e\x4f\xb2\x66\xa3\x8d\xee\x4b\x8d\x2e\x7b\x95\xf2\x08\xa2\x81\x01\x03\x49\x36\xa1\xed\x60\x8c\x7a\x63\xbb\xef\x68\x4b\xf4\x4b\xf5\x15\x24\xfd\xa9\xec\xbd\x5f\x20\xcf\xcc\xd6\xe7\xe4\x99\x91\x73\x5a\x3d\x1a\xb6\x6e\x27\xbb\xcc\x7a\xb7\xbf\xe9\x48\x6f\x87\x2d\x95\xb9\x6a\x7e\x22\xac\x0d\x9d\x1c\x61\xce\xae\x0b\xd9\xd6\x82\x84\x58\xdf\xec\xb7\x9a\x0d\x59\x95\xe6\x05\x6f\x3a\x4b\x8a\x26\xc9\x15\x24\x2f\xa4\xce\x9c\x00\x9f\x35\x9a\x26\x6d\xff\xd5\xee\x4a\x28\x9b\xc0\xd6\xcd\x12\xd3\x7c\x46\xea\x8a\xad\xf5\xe5\x52\x57\x6c\xdd\x2c\xa9\x46\x98\xba\x0f\x5b\xbb\xe1\xcc\x4f\xdb\xdb\x35\x25\xeb\x9b\x1b\x35\x25\x9b\x5b\xb5\x25\x90\xfd\x26\x5c\x52\x5f\x67\xeb\x3a\x4b\xe0\x45\x34\x0d\x4c\xe6\xcd\xb2\x7d\x78\x52\x11\xda\x11\x14\x79\x6d\x6e\x83\xcd\x2d\x9d\x09\x44\xdb\xa9\xd4\x21\x6c\x12\x15\xbc\x78\xf2\x4a\x1e\x35\x2f\xa2\x69\x43\x25\xa2\xdd\xe8\xf6\xd9\x8b\x68\xaa\x96\x9a\x58\x8e\x02\x9b\x5b\xdb\xad\xe6\x8b\x27\xaf\xe8\x1a\x39\xe5\x65\x78\x99\xbc\x88\xa6\x4d\x22\x16\x9c\xf2\x52\xe5\xe9\x0c\xe4\x2a\x5d\x63\x8f\xed\xe7\xe3\xb5\x13\x27\x15\xcc\x2e\x2c\x22\x93\x5e\x59\xa2\xde\xdd\xe8\x6e\xcb\x0e\xec\xc3\x71\x57\xb6\xaf\x12\x71\x9f\xf2\x72\xc7\xb9\x70\xd2\x4c\xdc\xae\xb9\x80\x24\xb3\xac\x7a\x20\xbf\x18\xbb\x1f\x85\xe8\x8b\x27\xaf\x5a\x60\xda\xd4\x72\x2e\x16\x58\xfb\xee\x5d\xfc\xa3\x7b\xbe\x4b\xf2\x6d\x2b\xe4\x1e\x79\xc8\x09\xc4\x41\xa7\x27\xd5\xa9\x8f\xe8\x25\x37\x90\xfe\x54\x6b\xab\x10\xcb\x98\x8f\x6a\x11\x04\x2d\xa3\x24\xe2\x1a\xdb\xf1\xf3\xa0\x5e\x49\xda\x61\x1b\xb5\x89\x31\xb7\x6e\x96\xcd\x25\xc0\xc1\xf1\xab\x3a\xd1\x77\xdd\x64\x23\xc4\xfb\x46\x6d\x06\x8f\x87\x8a\x79\x0b\x8e\x9c\xf0\x24\x4d\x6b\x53\x1c\x6a\x3d\xf2\xb0\xfc\x50\x9f\xd1\x49\x67\xd0\xd2\xce\xe3\xb5\xcb\x46\x27\xd1\x1a\xe5\xc5\xe1\xa8\x0e\xbf\x75\x0d\xf5\x7d\x52\xf2\x02\xb3\xce\xd7\xa6\xf0\xd4\xea\x6b\x65\xda\x12\x1e\x84\x5e\xd6\xf2\x12\x88\x09\xf9\x6b\xd7\xa1\x5e\xd8\x4f\x0f\x8e\xf6\x5f\x3f\x7f\xf5\xe6\xf0\x75\x5d\xfa\xd0\x0d\xdd\xf5\x28\x12\x25\xc6\xc7\x0b\xe7\xe0\x5b\x6b\x75\x15\xc8\x35\x37\x97\xa3\xe7\xff\xe7\x80\xed\x39\xa8\x3c\x66\x8d\xb7\xa2\xc1\x76\x58\x43\x24\x7f\xf2\x86\x4d\xef\x78\xa0\x56\x1e\xc9\xd5\x35\x8e\x30\x8b\x67\x4b\x2f\x70\x89\x05\xbc\xa8\x69\x15\x13\xb8\xf5\xec\xe9\x01\x98\x84\x9e\x66\x25\xef\xaa\x04\x66\x08\x08\xaa\x89\x67\x8d\x96\xd5\x7b\x44\x65\xf7\x6d\x72\x0c\xa5\x27\x4a\xe3\x3b\x2a\xf2\x3f\xb9\xf6\x0d\xd4\x9d\x81\xba\x47\xef\x0d\x58\x6d\xb4\xab\xba\x30\x7b\x06\x2e\xfa\x8c\x2a\x47\xf0\xd3\x19\xdb\xdb\xc3\x71\xd0\x7d\x62\xb7\x26\xcd\xa4\x52\xfe\x9e\xf2\x72\xdf\xbe\x8c\xd1\xf4\xf4\x17\x45\x34\x9d\xca\xeb\xcb\xcb\x27\x2f\x0e\xda\xec\xf9\xd1\x5b\xd8\x78\x9f\x3c\x7d\x7a\xf0\x9a\xee\x65\xfb\x6c\x8f\x29\xd8\xa6\x4f\xd5\xc4\xcb\xf5\xc1\x08\xf3\x2b\x90\x7d\xdd\x41\xe3\x6d\x62\x1d\x4a\x71\xf0\x52\xd8\x92\x85\xbb\xfa\x91\x12\xe2\x31\xd9\xb4\x1a\x72\x6b\x73\x2a\x24\x6c\x4f\x67\x96\x82\x07\x79\x48\x15\x03\x74\x77\xc0\x46\xce\xfd\x5c\xb5\x3b\x4a\x0a\x51\x22\xcd\x1c\xe0\x34\x04\x9c\x46\x01\xd8\x63\xc9\x88\x27\xe8\x17\x45\x10\x96\x1c\x48\x34\x6d\x26\x41\xcc\x1d\xd2\x6e\x0b\x97\xba\x29\xb4\xf4\x86\x86\x81\xe8\x27\xf8\xc3\xbb\x77\x90\xcd\xa9\xb9\x4f\x33\xc0\x11\x35\xa1\x3a\x14\xfa\xde\xa1\x30\x4c\x79\x54\x34\x5b\x0e\xdc\x3a\xe4\x87\x3f\xe2\x65\x2d\x1c\xfc\x22\x8c\xa2\x4a\x89\x79\x80\xb1\xaf\x86\x87\xfd\x3d\xe6\x1d\x1a\x72\x46\x5b\x10\x81\x2b\x32\x6c\x9e\xb4\xd9\x35\xf9\x1e\xff\xc3\x8f\x45\x20\x86\xa0\x5d\x17\xd3\x96\x02\x9b\x9a\x56\xa6\xdd\xcc\x57\x92\xe9\xff\x62\x9e\xf2\x92\x03\x76\xc7\x08\x4c\x3d\xd2\xac\xd5\x9c\xe5\xa4\x10\x9b\x38\x60\x84\x2f\xb4\xa5\x44\xbb\x32\x39\x1b\xde\xe4\x20\x1e\x5a\xa2\x70\x27\x68\xd3\x9b\x20\x05\x6b\xce\x76\xf9\x5f\x03\x3f\x36\x76\xdc\x04\xe7\xbe\x91\xfb\x9c\x29\x72\xa3\x7e\xe8\x69\x30\xb2\x8a\xdd\x37\x3d\x73\xe9\xaa\x91\xa3\xac\x9f\xf1\x0f\xa5\x9d\x45\xdf\x6e\x75\x5a\xf0\x73\x3b\x3b\x81\xf9\xd0\x9b\x68\x75\x4a\x16\x31\x81\x6c\xba\x05\x1d\xc0\xa4\x4b\x3c\x7c\x10\xf9\xad\x05\x25\xc0\x23\x12\xd6\x07\x31\xd3\xad\x90\x6c\x11\x06\x08\x35\x69\x98\xc2\x83\x4f\x03\xed\x5b\x1e\xe9\x74\x08\xab\x19\x35\xc4\x1d\xb3\x91\x07\x78\x67\x1d\x44\x51\x97\x1f\x46\x79\x71\x10\x0d\xc7\xcd\xa1\xb2\x2d\x1c\x65\x6d\x78\x4d\x7c\x52\x9c\x52\x2e\x6d\x55\x98\x70\xcb\x63\xc2\x6b\x36\xa4\xc0\x09\xcb\x55\x1b\x60\xbd\x7b\xac\xad\xd9\xce\xb4\xc0\xee\xf5\x5c\xce\x5c\xc4\x8e\x92\xee\xc3\xf2\x83\x83\x59\x40\xae\xef\x3b\x72\x7d\xdf\x91\xeb\xdb\x6c\x23\xc4\xe3\xf6\x93\xb2\x07\x76\x36\x20\xf6\x58\xb3\x30\xdb\xc1\x18\xe2\x6f\x47\x2e\xb3\x8f\xd4\xb6\x73\xae\xb6\xb4\xee\x19\xd2\xcc\xb1\xd5\x86\xa7\x80\x73\x5e\x94\xac\xcc\x51\xe9\x0f\x07\xca\x87\x44\x40\xf4\x75\x7a\xb2\x54\x30\x31\x82\x7f\xd1\xf2\x36\xc7\x69\xc0\x17\xa1\xba\xd3\x3c\xf0\x26\x79\x1c\x89\xf0\x36\xf3\xc0\x63\x2b\x09\xe8\xec\x31\xe3\x48\x90\xb9\xd6\xed\x54\x0d\xc5\xee\xdc\xa9\xbb\xe1\xa8\xb3\x80\xee\x22\x57\x15\xb5\x1a\x11\xec\x5a\x2c\x7e\xe5\x1e\x73\x28\xe0\xd9\xe3\xce\xbd\x7b\x35\x03\xd8\x84\x50\xc0\xe5\x17\x46\x41\x55\xdb\x37\xd7\xac\x98\x26\xd6\x21\x02\xa4\x77\x7b\x5a\x6a\xd7\xd4\x9b\x5f\x1b\xc5\x14\xfc\x08\x51\x27\xa3\xec\x94\x87\x38\x22\xb0\xc7\x2a\x86\xc3\x7d\x5c\xef\x80\xb2\x11\xbc\xdf\x64\xfc\x82\xd4\xf7\xcc\xbd\xed\xb6\xa4\x71\x25\xa1\x27\x76\x42\xb2\xaf\xba\xc4\xb5\x65\x0f\xff\xe8\x38\xe2\x15\x63\x67\xea\xfa\x57\xf3\x1f\x56\x39\xe3\x96\xb9\xcf\x77\x10\xe9\x9a\x2a\x58\x01\x20\x4c\x95\xe9\x8e\x3e\x2f\x14\xf2\xed\x40\x15\x09\x91\xe4\x33\xe1\xad\xa5\xcc\xd9\x00\x6a\xba\x83\xb3\xca\xad\x27\x25\x9e\x48\xd2\x6d\x1e\x9a\xa8\x72\x8d\x35\x17\x51\x27\xbf\x3b\xea\xb8\xa0\xe7\x86\xb3\xdd\x04\x8e\x2a\xa7\xdc\x1e\x12\x36\x02\x72\xaf\xc7\xa2\x38\xc6\x94\x84\x76\x12\x02\x37\x11\xf7\x0a\xe2\x36\x7d\x45\xef\x29\x86\xc7\x35\xc3\xee\x98\xbf\xda\xa8\x34\x38\x82\x8b\x3c\xe5\xff\x7d\xf7\x8a\x40\xcc\xf6\x25\x72\xa0\x44\x6d\x33\x74\x8a\x90\x7f\x28\xaf\x93\x36\x3b\xb6\x39\x1d\x4f\x74\x0d\xb5\x45\x6d\xb6\xf5\x5f\x0f\xcd\x5f\xfd\xbe\xfd\x73\xbd\xad\xf7\xa8\x2d\xf3\xd7\x43\xf3\x57\x7f\xcd\xfe\xd9\x87\x96\xc9\x0d\xd9\xa2\x4b\x73\xfb\x4b\x34\x24\x43\x9c\x25\x59\x4c\x1f\x93\xe5\xfe\xee\xc8\x47\x16\x14\x0f\x25\x89\x74\x19\x15\xa7\xbc\x74\xea\x9c\xb1\x3d\x68\x6b\xb7\x8e\x5b\x64\xa1\x53\xa3\x7a\xcd\xf0\x6a\x68\x86\xc6\x49\xab\x6a\x89\x99\x2b\xd1\xc9\x56\xa9\x4b\xaa\xec\xd0\xac\x98\x33\x5a\xe2\x0a\xde\x29\x61\xae\x65\x8f\xa8\xeb\x1e\x4f\xbd\x9e\xe4\xaa\xea\x32\x23\x0b\xa5\x04\x2b\xd0\x66\x75\x77\x0a\x9d\xc2\x50\x41\x2e\x2e\x2f\x10\x70\x5e\xb0\x51\x92\x25\x82\x64\xe6\x54\xef\xe9\x76\x4d\xe1\xfc\x06\x24\x77\xa3\xfc\xe2\xd3\x66\x3f\xe4\xde\x4a\x00\xd8\xe0\x92\xce\xa8\x1c\x07\xd2\x7b\x8f\xa1\x52\xbf\xe5\x34\xb7\x66\x44\x03\xc7\x11\xd8\x54\xc1\xb5\x52\x57\xe9\xdc\x0f\xe0\xa5\x8b\x8f\x8d\xbc\xa1\x00\x75\xf0\xbd\x2b\xbd\x36\xd9\x63\xd6\x50\xeb\x0f\x94\x23\xaa\xa3\x36\xbb\x63\xae\x9b\x24\xf2\xb4\x5a\xc1\xc7\x3f\xfc\x20\x50\x1b\x74\xa2\x56\xe0\x7a\x57\x2f\xc0\xf5\xee\x3a\x80\x5a\x8d\x51\xd3\x08\x6b\x57\x21\xc3\xa4\xad\xdb\xcc\x62\x8c\x4a\x1d\xcc\x48\x5b\xa3\x7c\xda\xd6\x7a\xb9\xbc\xa8\x55\x24\xe9\xa7\x9b\x79\x2a\xc3\x6b\x6b\xbb\x8e\x5e\x1d\xec\x3f\x3f\xa8\x05\x5b\x6b\x35\x1b\x8a\xaa\x8d\xb9\x46\xa2\xac\xf9\xd3\xc1\xef\xd6\x08\x6a\xdf\x7a\xbe\xc8\x21\x1d\xff\x74\xf0\x3b\xc4\xb5\x27\xbe\x25\x8f\x49\xc9\x8e\x22\x0f\xfc\xd2\x6a\x2a\x3a\x8a\xbb\x77\xd9\xbe\xfc\x9f\x3b\xfb\xc7\x0a\xe3\x13\x29\x63\x75\x47\x72\x9f\x54\x5f\xb4\x70\x35\xcc\xb3\x51\x72\x3a\x03\x05\x05\x3e\xdf\xa0\x70\x59\x15\xb9\xec\x91\x92\x08\x34\x15\xba\x0a\x67\xf1\xde\xba\x4d\x73\xe5\x6b\xb0\xc3\x12\xa9\xbf\x21\x1f\x0e\x07\x1d\x45\x9d\xbe\x52\xeb\x35\x93\xb4\x4e\x51\xba\xdd\x57\x40\xe3\x24\xae\xe3\x3f\xa3\xed\xbd\x8e\x9e\x79\x39\xcd\xf0\x35\x54\xcd\x89\x98\xfb\xbe\xb9\xd5\xb7\xba\xe1\x37\xd6\xe3\xad\x56\x77\xfe\x68\x89\x35\xa5\xd5\xf0\x3c\x1a\x8e\x6b\x15\xcd\x0f\x5a\xcd\xb5\xeb\xad\xbe\x79\x6b\x09\x4f\x7e\xa3\xda\x54\x09\x4e\xc1\x9e\x61\x92\x67\x56\xeb\xf6\xfc\xe8\xed\x6f\x07\x4f\x7e\xb2\xeb\xee\xc7\x48\x80\x1f\x08\xae\x26\xd9\xcc\xc9\x2e\x59\x92\xb2\x58\xff\x06\x65\x1d\xdb\x23\x5b\xae\xe0\x25\x6c\xb7\x51\x1c\x37\x34\x14\x5c\x61\xd8\x1e\xae\xbe\x7d\x9a\x1a\x0a\xcb\x0f\x8d\x95\x23\x9c\x8a\x74\xec\x9f\x3e\xe9\x2d\x60\x9f\xdd\x71\x96\x3e\x9c\x99\x0a\x77\xe5\xa3\x54\xe6\xfa\x16\x0f\xcb\x1c\x98\xb5\x59\x95\x1d\xe4\x1d\x61\xbf\xd9\xd2\xd2\x59\xb3\xa5\x9c\x5e\x95\x39\x00\x11\xea\xd4\xa5\x82\xa8\x61\x89\x6b\x05\x00\xed\x63\x0a\x9c\x49\x9e\x75\x5d\xf5\xf2\x7c\x9d\xf2\x02\x7d\xa6\x9a\x2b\x05\x26\x57\x66\xf7\xe5\xc1\xc1\x53\xa2\xf5\x71\x6e\x36\x35\x6a\x69\x10\xd5\x16\x29\xa6\x15\x10\x51\x4d\x0f\x89\x6a\x1a\x4a\xbb\x6f\x87\xa0\xf9\xb9\x80\xa9\x6f\x3a\xe7\xf8\x75\x35\xbc\xd0\xa0\xd5\xf1\xc2\x4f\x4f\xcb\x2b\x97\x48\x53\xf2\x4f\x1b\xd4\xad\x6d\xd4\x8a\xb5\xd5\xcc\xb6\x25\xba\xe3\x48\xb4\x05\x2f\xdb\x20\x6f\x2b\x69\x5b\xcb\xda\x65\xfe\x3f\x47\x87\x2f\x1b\x5d\x31\x4d\x93\xb2\xd9\x68\x37\x5a\xed\xd0\x01\xa3\x25\xc2\xe7\x47\x6f\x35\x13\xff\x74\xf0\x3b\x1c\x2f\x92\x75\x25\x47\xe9\xdf\x92\xa5\xe9\x98\xe5\x77\x8c\x60\x58\xe6\xc0\x68\x86\x0d\xef\xde\x35\x95\x00\xf7\x46\xab\x05\xbb\xa1\x3b\xbb\x3f\x1d\xfc\x4e\x51\x8a\xda\x6c\x40\x85\x39\xe7\xd9\x40\xde\xda\xf7\xa1\x8a\xa7\x7a\xbc\x63\x10\xbf\x7b\x97\x91\xfe\xef\xe8\xcd\xad\x19\xb5\x8c\x50\xa5\x91\x3a\x95\x8b\xf3\x31\x51\x45\xed\xf8\x7e\xcf\xb8\x37\x0b\xb4\x4b\x43\x69\x7d\x08\x07\x6a\x33\x72\xde\x3d\x01\xe9\x8a\x00\x69\x70\x7a\x8c\x16\xfd\x3b\xaa\x2d\x23\x51\x7a\x53\x4d\x96\xef\xcd\x75\x1d\x0a\xdb\xae\xac\x18\xd2\x6e\x80\x69\xa8\xbb\xa5\xeb\x0b\x12\x4a\x81\x87\xb8\xd7\xc9\x8d\x4a\xc2\xab\x73\xb3\xa9\xfe\xed\xfe\x8b\xdd\xd7\xdf\xba\xbf\x91\xbf\x9f\xb5\xd9\x21\x36\xa0\xe7\x05\xb7\x53\xb5\x2d\x98\x7b\x64\xe5\xf2\x48\xed\xdc\xf7\xc3\x22\xc3\x5c\xd3\xf6\x65\xec\x7c\xd6\x58\xe7\x9f\x0c\x9c\x83\xff\xa6\x16\x10\x58\xff\xd8\xaf\x93\x68\x0a\x36\x0a\x04\x0e\x0c\xc6\xe4\xc7\x0d\xfb\x51\xe4\x13\x2e\x3f\x6d\xda\x4f\x10\x89\x42\x7e\xdb\xa2\x75\xb3\x58\x7e\xda\x76\x3f\x3d\x87\x2b\xfb\x92\x6f\xc6\xcf\xe7\x1e\xce\xfd\x2d\x2d\xb0\x2c\x6b\xa5\x54\xe6\x3f\xa3\x8a\xb4\xee\xfc\xd6\x4f\xc1\x91\x18\xd6\x1e\xcd\x0f\x43\x86\x2b\x96\x1d\xdf\xfc\xfe\xea\xa0\xcd\xbe\xc7\xf3\xc2\x9e\xa4\xea\x58\xdc\x63\xb2\x5c\xae\x40\x63\xbc\xff\xfc\xe8\xed\xb3\xe7\x3f\xbf\x81\x7d\x47\x17\xae\x93\xc2\xa3\xc3\x17\x07\xa4\x68\x83\x14\x1d\xfc\x7a\xf0\xfa\x77\x52\xb6\xe9\xb4\xf9\xf2\xe9\xdb\xe7\x2f\x9f\x1e\xfc\xff\x08\xc0\xb6\x06\x78\x79\xf8\xf6\xdf\x87\x3f\x83\xa0\xae\xcb\xb6\xe4\xda\x73\x2a\x6a\x60\x63\x30\xa0\x46\x25\x01\x23\x31\xdc\x0d\x58\x9f\x34\xbf\xc7\x8d\xca\x55\x9d\x47\x25\xd5\x0e\xca\x33\xde\x18\x6c\x7d\x4f\x94\xc4\x28\x68\xa5\x52\xc0\x53\x33\xdf\x3c\x24\x45\x21\xe5\x37\x2a\x16\x37\x5a\x8e\x4f\x01\xce\xb0\x9e\xec\xa6\x6c\x52\xe9\xc6\xa9\x2b\x82\x52\xf1\x11\x77\x04\xb3\xdb\x19\x19\x46\xbd\xaa\xaa\x41\xa9\x36\xd8\x0e\x99\x33\x1f\x66\xad\x45\x95\xed\xb6\xed\xf3\x28\x6d\xcb\x0e\xa8\x87\x83\xd1\xd7\xa3\x12\x14\xff\xb9\x7f\xbf\x05\xbb\x87\x99\xa1\x4f\x9f\x14\xae\x49\x06\xd4\xa1\x87\x96\x94\x98\xe5\x37\xf2\xca\x8e\xdb\x20\xf0\x64\x13\x3a\x85\x22\xdc\x98\xec\x99\x21\x27\xdd\x0f\xb7\xab\x15\x59\x48\x06\xab\x35\x93\x58\xa3\x10\x24\x77\x08\x5d\xc3\x78\x4f\x17\x5c\xb4\x8c\x3b\xb0\xdf\xae\xf2\xd1\xdd\xd8\x71\xc2\x2c\x30\xfa\x5f\xaf\x07\xe6\xbe\x7e\x95\xad\x1d\xa2\xb9\xf6\x34\x43\xf0\x6e\x6d\xf4\x0e\xa6\xca\xb6\xa9\xa2\x08\x5a\xad\xf2\xdc\x51\xdb\xaa\x7a\xeb\xfa\x70\xea\x4e\x67\x62\x2c\xa9\xd6\xda\x75\xea\xc1\x2e\xa8\xbf\x10\xc7\x71\xbd\x04\x5b\x6e\xb0\x08\x59\x09\xb7\x44\xe7\xe8\x59\x71\x8f\x47\xb2\x40\x1f\xb3\x4e\x1f\xb9\x0a\x16\x3b\xae\x43\x5c\xdc\x8f\xed\x9f\xf4\x08\xbd\x0a\x1f\x12\x37\xf3\x13\xe8\xf5\xd8\xa3\xee\x66\x77\xbd\xbb\x81\x1b\xb6\xd2\x6d\xec\x23\x83\xe7\x45\x72\x9a\x64\x51\x0a\x45\x66\x31\x58\xc3\x6b\x2e\x88\xcc\x5b\xbb\x7b\x3e\x5a\x70\x55\xd1\xbd\xd8\xd5\x46\x8c\xdc\xa4\xe0\xd9\xac\x76\x66\x2a\xb5\x5a\x4d\xb3\xce\x43\xe4\xb9\x99\x29\xef\x75\xee\x8b\x2a\x0c\x47\xed\x85\x76\xeb\xd6\xf5\x25\x86\x06\x56\x69\x62\x0c\x74\x54\x4c\x10\x4b\x26\x72\x5b\xd0\x1f\xa9\xab\x38\x79\x4a\xc9\x85\xe8\x14\x3c\x4a\x27\x92\xb7\x61\xdb\x35\xcf\x31\xe6\x36\x56\x89\xbb\xd2\xdc\x07\x09\x11\x49\x00\xe1\xa6\x10\x01\x22\xd6\xc9\xcb\xd5\x7e\x55\x05\x89\xe8\xaa\xcd\x7f\x9f\x68\x36\x25\xac\x55\xd6\xd0\xad\x6c\x9f\x44\xa2\x08\xb4\x08\x6a\x18\x23\x5b\x01\xac\x15\x7a\x1f\x2b\x1c\x77\x6a\xa4\xae\xed\x1b\x5b\x57\x07\x1c\x29\x9e\x46\xe7\x49\xfc\x63\x31\x8b\xb2\xb2\xf7\x22\x9a\x76\xdc\xe7\x46\xbc\xb4\x2c\xab\xae\x59\xf1\x45\xd3\x57\x44\x1c\x7d\xdd\x46\xdb\xd3\x36\xfb\xc8\xb0\xd9\x1a\x23\xe5\xed\x7e\xab\x09\x90\x2d\x16\xb2\x9a\xde\xbe\x99\xd5\xf4\x0d\xa9\x00\xd1\x17\xf2\x3a\xad\xcf\xba\xb1\xca\x05\x7f\xed\x9a\x6d\x67\x7b\x7d\xbe\xd0\x06\x92\x7f\xd0\x9c\x16\x11\x69\x52\xbb\x33\x85\x10\x5c\xc9\x5a\xf2\xb6\x8b\xb5\xd1\x07\xcf\x3a\x38\xc8\xaf\xec\x3e\x5b\xfd\x1b\x36\xc1\x12\x91\x35\x4a\x76\xca\x33\x5e\x24\xc3\x55\xf7\x95\x55\xe2\xde\x34\x92\x50\x78\x73\xdf\xbe\x99\x85\xf8\x72\xea\xb3\x79\x44\x92\x77\xf8\x36\x7b\xfe\xe6\xe0\xf5\x93\x37\x87\xaf\xed\x3e\x63\xc4\xa6\x63\x58\x97\xf6\xc2\xaf\x12\x42\xb6\xe9\xe9\xaa\x7f\x90\x86\x88\x1c\xa9\x0f\xb8\xd0\xf0\x6f\x66\xed\x4d\x98\xb0\x1c\x6e\x3c\xea\x2a\x4e\x4c\x72\x70\x68\xca\x45\x94\x76\x04\x2f\x27\xd1\xb4\x93\x8f\xe4\x6c\xf4\xfe\x26\xf8\xb0\x33\x89\xa6\xdd\x7c\x54\x63\xc1\xbe\xa9\x17\x4d\x00\xd9\x5b\x35\xec\xbd\x36\xee\x4b\xef\x1e\x73\x66\x7b\xff\xf0\xe7\x9f\x31\x2e\x07\xce\xb4\xbf\xd1\x1c\xb5\x99\x05\x91\x3b\x4c\x4e\xcd\x03\xf2\x51\x93\x8a\xfc\x46\x28\xf7\x8d\x55\xac\x80\xfc\x84\xa9\x03\xa3\xe9\x88\xea\xea\x91\x0d\xbf\x75\x3a\x2d\xf6\xe4\x18\xff\x3e\xa1\xad\xe9\x6f\xce\xa2\x92\xd2\x82\x5c\x53\xcd\x27\xb8\xaa\xea\xb4\xf1\xdb\x37\x7b\x9c\xf9\x7c\xce\x82\x48\xaf\x61\xde\xda\x9e\xc3\x5b\xb7\xfa\x78\xf0\xc5\x78\x0b\xae\xd1\x0b\xe2\x90\xac\xdb\x87\xaa\xc5\xca\x80\x9b\x6d\x5e\xd7\x66\x67\x39\x58\x6a\xd2\x25\x77\x68\x15\x73\x05\x6c\xb9\x26\xd1\xf4\x19\xb1\x0b\xb3\x96\x5c\xf0\x82\x22\x0b\x1d\x06\xed\x9f\xec\xd2\xd2\x69\x92\x9d\xb6\xd9\x93\x36\xcb\xda\x6c\x38\xc0\x22\x43\xad\x26\xb9\x13\x2b\x58\xb6\xa7\xda\xbc\xb3\x17\x94\x99\x14\x58\x8b\x34\x02\xf0\xc4\x9e\x48\x21\xbf\xe7\x68\x67\xfd\xa5\xa2\xe0\x9f\x98\xdd\xdc\x6b\x5e\x8b\x63\x19\xb5\xeb\x1c\x0e\xd4\xcd\x5c\xd1\xc4\x8e\x7a\xfd\xa4\xcd\xd6\x69\x04\xe2\xc3\x91\xc2\xc3\x9c\x0d\x76\x8a\x32\xfe\xa1\x7c\x5e\xf2\x09\xbd\x3f\x3e\xc1\x2b\xd9\x70\x60\x4a\xdb\x2c\xbb\x7f\x9f\x04\x5e\xd6\x7a\x44\xd7\xbe\x27\xd8\xd5\x13\x75\x02\x3d\x09\x7a\x01\x2e\xbb\x5b\xdc\x4c\x11\xf7\x19\x2e\x64\xdb\x0f\x97\x73\x21\xdb\xbe\xd9\xed\x2f\xdc\xf7\xa3\x90\xe0\xd4\x59\xfb\xd0\x1f\xd1\xff\x02\x64\xba\xd9\x5d\xab\xd7\x63\xeb\x6b\xe8\x97\xb8\xc6\x5e\x82\xcb\x70\xf7\xc5\xf3\x97\x6f\x8f\x9e\x3c\x3b\x78\xfb\xfc\xe5\x9b\x83\x7f\x1d\xbc\xfe\x6c\x19\xf9\xa8\xcd\x1a\xd8\x26\x88\xc6\x7e\xbb\x3b\xd5\xf1\x05\xc5\xe2\x07\x37\xbb\x1c\x2c\x08\x3a\xb5\xbe\xd6\xdf\x6a\xb3\xdf\xa3\x71\x9e\xdf\xd1\x51\xa6\x6c\x71\x30\xb2\xd4\x4b\x7e\xc1\x7e\x3c\x7a\xca\x7e\xc6\x22\x4c\x90\x2f\x0b\xa2\xe1\x30\x9f\x4c\xa3\xec\x52\xee\x24\x4e\x8c\x29\x88\xb9\xc8\x8b\x89\xd0\x31\xa4\x20\x5e\xce\xc1\x93\xfd\x37\x6f\x8f\xde\x3c\x79\xf3\x7c\xff\xc8\x98\xc6\x0d\xc7\x49\x1a\xef\xe7\x59\xc9\x3f\x40\x26\x50\x41\x1f\xc3\x87\x35\xdf\x15\x6b\x83\xcb\xae\xf3\x3d\x11\xd3\x34\xba\x7c\x19\x4d\xfc\x37\xf5\xa7\x35\x35\x26\xc9\x87\x24\x73\xbe\x18\x3f\x65\xfa\xb1\x84\x48\x36\x18\xa9\x40\xbd\x8d\xff\xf4\xf2\xf0\xb7\x97\xde\x70\x32\xa7\x63\x94\x1e\xec\x6f\x73\x0f\xb1\x9f\x20\x28\x54\xe1\xfd\x26\xe5\x66\xcf\xa3\x9f\x92\xf2\xd2\xc3\xc5\xf5\xfa\xb6\x11\x53\xdc\xef\xbb\xda\x6f\x87\x78\x5f\x4b\x52\x91\x10\x2b\x81\xc2\x50\x2d\x1d\x47\xb5\xa6\x9e\x2a\x0e\xd5\x7c\xca\x31\x56\x07\xe8\x72\x82\x95\x2d\x84\xa9\xff\x4a\x13\x0e\x4e\x6a\x5b\x8b\x7c\x47\x58\xf4\x00\x32\x9f\x4d\x30\x48\x53\xfb\xee\x5d\xef\x8b\x0a\xa7\x3e\xff\x98\x1f\xe7\x89\x28\x5f\xe6\x19\xc4\x0a\x3a\x2a\xa3\x32\x19\x0a\xf5\xb0\xb9\xaf\xfd\xcd\xdb\x2a\x74\x1a\xf9\x30\x48\xa3\xe1\x59\x9a\x88\x32\x10\x7b\xc5\x03\x46\xeb\x42\x15\x39\xbc\xc5\x3e\xb2\x5e\x8f\xc5\xb9\xbc\xd9\x41\xdf\x2c\x3f\xe7\x85\x8e\xf0\xd8\x1c\x97\x93\xb4\x65\xa3\x06\x88\x15\x47\xdf\xea\xd1\xc0\x0f\x7c\x8c\x4a\xea\x31\x2f\x92\x92\xc7\xb6\x7f\x9f\x52\x4d\x0f\x41\xc7\xe0\x5a\x9b\x45\x56\x5a\xb9\x7b\x37\xd4\xb6\x1c\xdb\x02\xac\xe4\x7f\xcb\x51\xb9\xda\x3e\x25\xb4\x8b\x25\x4d\x80\xe6\x3c\x40\x2a\xb7\xf2\x00\xb7\x07\xc6\xed\x50\x37\xc8\xe8\xfe\x68\x54\xf3\x10\x81\x68\x98\x67\xc3\xa8\x0c\xd7\xab\x74\xe6\xc4\x5b\x37\x7f\x86\xd2\x44\xd1\xe8\x46\xec\xfe\xfd\x24\x34\xcd\xe0\x4a\xca\x54\xb0\xa1\xea\xfc\xdd\x71\x36\x64\x48\xc6\x00\xef\xbb\xce\xc6\x66\x3e\x37\xef\x18\x2a\x83\x65\x84\xf9\x05\x10\xc1\xf8\xda\xb8\x33\x91\xf5\x5e\xb7\xd0\x7d\x3a\xf8\x9e\x30\xfa\xbf\xb2\xb8\xc4\xa5\xf1\x04\xd2\xb0\x8d\xa2\x24\x9d\x15\x5c\xa0\x8e\xa6\xe0\x51\xdc\xc9\xb3\xf4\x92\x44\x66\xa8\xb4\xc0\xf0\xf0\xa0\x01\x6a\x2a\x1c\x06\x26\xd7\x16\xef\x00\x1e\x57\x6c\x18\xc1\xbb\x84\xe4\xe3\xba\xa8\xe0\x81\x00\xdf\x6e\x4f\x5a\x5a\x5c\x99\x07\x12\x10\x15\x1f\xdc\x4c\x6f\x76\xeb\x61\x7b\x30\x46\x4d\x26\xbe\x7f\x2f\xc4\xf7\x99\xf8\x5e\x8c\x39\x2f\x0f\xa7\x65\x92\xeb\xb2\x29\x89\xc4\x16\x92\xa7\xd6\x48\x2b\xb5\x0a\x39\x13\xcc\x07\x61\xdc\xe0\x35\xbf\x25\x69\x3c\x8c\x8a\xb8\xf9\x36\xb3\xf1\x75\x4c\xb7\x75\xf1\x81\x36\x1f\xac\x57\x81\xe7\x05\x07\xb2\x2d\xb6\x6e\x3d\x92\x4e\x43\x09\x35\x0d\x1a\x4b\xa7\xae\x0b\x33\x5e\xd5\x87\xda\xf8\xab\x1d\xb8\x08\xec\x9a\x0b\x8d\x72\x23\xbb\x38\x1c\xbc\x47\xdb\x28\xd3\xc4\x1d\x13\x7f\xb9\x92\xdb\x85\x74\xa6\xb8\xc6\xf1\x67\x21\x6b\x1b\x03\xae\xe6\x83\xf7\xb8\x94\x5b\xaa\x2b\xdc\x4d\xe0\x34\xc0\xe4\x2f\xf2\x42\xa4\xcb\x0c\x01\x14\xc4\x2e\xb9\x43\x1d\x22\xee\x0e\x45\x3c\x8e\xd5\x9d\x59\xc7\x11\xb4\x03\x76\x50\x0f\x33\xbb\xad\x6a\x02\xeb\x29\x37\x0a\x9e\xcd\x26\x9c\xda\x68\x86\xec\x36\xd9\x45\x91\x94\xf6\xb7\x94\xea\x2d\x9d\x73\x3b\x6a\xf4\x27\xb1\xcf\x06\x38\x21\x26\x5e\x93\x4b\x80\x66\x70\x45\xc1\x5c\x55\xc2\xfc\x84\x61\xdb\x2c\x13\xdd\xf7\x42\x6e\x05\x96\xb9\x49\x27\xb2\xac\x75\x9d\xb6\xec\xcf\xcc\x69\x54\xc5\x42\xbf\x7e\x5b\xe2\x35\x3f\x4d\x44\x59\x5c\xd6\xa2\x58\x28\x80\x6b\xb5\x3d\x89\xb2\xe8\x94\x17\x75\x38\x86\xea\xb5\x2a\xd7\xde\x07\x37\xd3\x8b\x7f\xa1\x5d\x76\xa9\x9d\x34\xc8\x4f\xb2\xcd\xf7\x42\xec\x60\x24\x27\x4b\x17\x08\xc8\xd9\x6a\xe2\xe9\x9d\xe3\xe4\xce\x07\x62\xca\x36\xe1\x5f\x3c\x03\xf7\x0d\x13\x97\x7a\x87\x56\x91\x24\x23\xf1\x5c\x95\x99\x14\xf9\xa2\x6e\x78\x2a\x11\xd9\x65\xca\x8f\xe4\x6c\xcc\x6b\xa3\xad\x4e\xca\x49\x7e\xbe\x64\x0d\xb0\xb7\x6c\xc3\x43\x00\xf2\xd1\xfc\x91\x45\x71\xbc\xb8\x7f\x9d\xa2\x62\x61\xbf\x2b\x55\x5d\xca\x83\x5b\x8d\x2d\x73\x5b\x4c\xa5\xae\x24\xc6\x16\x9e\x24\xbe\x58\xd5\x48\xae\xca\xa3\xc5\x29\xef\xda\x9c\x3a\x12\x10\xe3\xd1\xae\xb2\xc7\xf4\xf1\xd8\x39\x00\x55\x6d\x75\x0c\xed\xd4\xc2\xa9\x73\x6c\x11\x32\xf2\x9c\xa3\x81\xce\x25\x84\x02\xc6\x52\xb8\x77\xf8\x29\x49\xd8\x63\x8b\xea\x8e\x8b\x12\xce\xd6\x0a\xbb\xc7\x0e\x3e\x94\x45\x34\x2c\x31\xaa\xfe\x65\xca\x85\x0e\x2d\x01\x31\x83\x8d\x8c\x29\xd0\x3d\x68\x98\x67\x65\x94\x64\x4e\x92\x3c\x4c\x87\x73\xaf\x17\x5e\x8b\x76\xe4\xd8\xbc\x09\x96\xc1\x45\x9a\x64\x65\x27\x4e\x84\x3c\x4e\x3a\x19\xff\x50\x76\xd2\x24\xe3\x2c\xcb\x3b\x62\x1c\xc5\xf9\x05\x0d\x5f\xc9\x11\x4d\xa7\x11\xe5\xb6\x24\x0f\x0a\x0c\x40\xb6\xc2\x42\x89\x17\x9d\x1a\x24\xeb\x3d\x84\xd1\x91\x65\x4e\x6e\xb6\x73\x1b\xbb\x5f\x51\xec\x3c\x98\xc8\xe1\xb1\xf3\x6b\x47\x73\x96\x89\xf0\x4f\x9e\xd7\x4b\x93\x80\x21\x98\x91\x18\x9d\x97\xf2\x16\x8e\xe4\xe3\x15\x89\x01\x90\xbb\xc7\xa9\x56\xd8\x5a\xf3\x99\xd2\xcf\xed\x20\xf9\x01\x11\xbe\xa3\x93\x55\xc9\x7b\x8e\x9b\xd9\xa4\x9a\x60\x09\xac\xe9\x91\xc4\x10\x8f\x5a\x93\xfb\x3c\x90\x7b\xca\xc0\xb9\xf7\xa0\xfa\x61\xd0\x81\x98\xca\x01\x8f\xe3\xd0\x1d\x21\xdf\xf5\xe2\x90\x7a\x8c\xb0\x1b\xda\x79\x6e\xf5\xe9\xf0\xb6\x76\x1e\x95\xb5\x0d\x12\x21\xec\x79\x5e\x2f\xe6\x97\xd3\x49\xc2\x85\x31\x29\xd7\x31\x0b\x83\x17\xe4\x29\x89\x1b\xa8\x63\xfd\x56\x6f\xa4\x98\x9a\x2f\x39\xd9\x25\x9f\xbb\x56\xe8\x63\x7b\x35\xdf\x3f\x7d\xd2\x46\x59\xa4\x9c\x8a\x86\xda\x92\x1e\x58\x60\x15\x46\xbf\x2a\x57\x1e\xb9\x57\xd2\xaa\x5a\x82\x34\xd5\xc2\x04\xd6\x23\x27\x35\x2b\xb7\x55\x10\xa9\x2b\x06\x94\xc4\xae\xa9\x8d\x8a\xc8\x57\x18\x1b\x5f\x80\xa2\xe5\x95\x26\xa5\x4a\x5c\xa2\x8a\x5b\x55\xe2\x93\x86\xa8\x35\x35\xa9\x83\x63\x76\xda\x9d\xd7\x8a\x8b\x82\x11\xfa\x09\xc4\x2e\x5c\x86\x9a\x86\x6b\x74\x2e\x93\x9a\x47\xbb\x4d\x1f\x70\x5e\x40\x56\x05\xf2\xd5\xaf\x73\x60\xed\xb1\x1f\xa5\x29\x44\x96\x6f\xea\x10\xec\x6d\x3a\x6e\x3d\x1f\x77\x4c\x31\xcd\x24\x43\x01\x25\xa4\x0d\xd6\x6c\x8d\x45\x56\xf7\xa3\x2c\xcb\x4b\x0c\xd8\x1f\xa9\x8c\x23\x91\x20\x61\x9b\x57\x5b\xea\x5e\xa5\x8e\x3e\x10\xa9\xc4\x0b\x94\xa0\x31\xd5\xc4\x19\x67\x11\xfb\x8d\x47\x67\x2f\xa2\xa9\xca\x9c\x95\x08\xc9\x72\xc9\x69\xa6\x12\x92\xe6\xb3\xac\x64\x56\x24\x93\x0d\x69\x4c\x31\x06\x6b\x54\x96\xd1\x70\xdc\x8b\xb9\xfc\x87\x45\xb3\x32\x9f\xc8\x39\x8f\xd2\xf4\x12\xcf\x49\xb0\x5a\x73\xfa\xde\xab\x18\xe3\x9b\xdf\x0e\xa0\xb1\x08\xf0\x69\x8a\x96\xb3\x0e\xac\x3e\x83\xc0\x92\x1f\xaf\x20\xe4\x49\x12\xbe\x16\x7c\x54\xf9\xa6\xf4\x79\xf8\x0d\x36\x5e\xba\x73\x35\x9d\x2e\xda\xec\x18\xd1\x39\xe3\x97\x3b\xe8\x10\xd1\x56\xe7\x32\xec\x80\x75\x91\xec\x5c\xf3\x61\xd3\x6d\x17\xbe\x1c\x8e\x9a\x54\x23\x46\xfd\x11\x70\x14\x8e\xa5\x2e\xd8\xa6\x69\xc7\x06\x44\x23\x8a\xe3\x1a\x34\xa2\x38\xc6\x38\x04\xd0\x90\x8b\x8d\xa1\x10\xe9\x89\xe6\xd7\x57\xb4\x32\x74\xa3\x65\x8a\x66\x66\x20\xe6\xf4\xa7\xc3\xc4\x26\xcd\x18\x11\x05\x47\x4e\xb0\xbe\xf7\x9d\x7e\xcb\xb5\xc3\xd5\x60\xaa\x11\x78\xd1\xd5\x2d\x58\xfc\xf0\xfb\x9a\xf9\x06\x44\x85\x6f\x48\x51\x97\xa4\xaa\x2d\x65\x58\xd2\xd1\x41\xc8\x03\x14\xc5\x4b\x66\x0d\x51\xb1\xf0\x73\xa7\xd7\x90\xde\xa5\xbc\x67\x8d\x8d\x81\x71\x14\xe5\x8d\x59\xf5\xde\x1e\x5b\x6b\x61\xed\x2e\x2e\xba\x26\x89\x03\xe6\x42\xdb\xd8\x07\xca\x57\x5c\x21\xa5\x8a\x5b\x04\x4d\x31\x4d\x93\x21\x6f\x2a\xa3\xef\x35\x57\x41\x4b\x69\x57\x4b\xaf\x59\x36\x97\x62\xba\xf8\x73\x69\x66\x79\x65\x4f\xf1\x8a\xe3\xbc\xae\x04\xeb\xe4\x34\xcb\x0b\x4f\xae\x96\x77\x88\x3c\xb5\x86\xe2\x70\x41\xd4\x27\x07\x91\xdb\x5b\x4d\xf5\xde\xdf\x70\xd6\xfb\x0e\x1b\x46\xd9\x1f\x8d\x12\xec\xc0\xd5\xb4\x95\xb9\x19\x4f\xa3\xe2\xc3\xe4\x3b\xbf\x07\xe7\xd1\x09\x74\x5c\x9d\x39\x1a\xda\x68\x1e\x1f\x54\xb9\xa7\x8b\x5b\x70\xd3\x8f\x10\x53\x9d\x30\x74\x8f\xd2\xef\xa7\xde\xc6\x55\xcd\x73\x68\x66\x87\x5a\x60\x41\xb3\x27\x8e\x1f\x92\x43\xbc\xdd\x15\x3c\xd6\x83\xb7\x24\x0f\xd2\x17\x68\x6f\xd5\xf7\xfd\xaf\xab\xf4\x6d\x5f\xa5\x83\x53\x3a\x4c\xf3\x0c\x55\x37\x9a\x60\x89\x38\x1c\x08\x5e\x9c\x2b\xe1\x37\xa8\xfa\x07\xbf\xef\x2a\xf8\x3c\xb1\x8e\xc2\x7d\x25\xd9\xce\xb5\xcf\x77\x2e\x97\x34\x3d\x8b\xa1\x00\xde\xd6\xcc\xd5\xff\x08\xf3\x34\x61\x56\x1b\xa5\x42\x30\xa9\xdd\x67\x82\x17\x8c\x67\xb1\x60\xb3\x29\x2a\x21\xca\x31\x9f\xb0\xc1\x25\x8b\x86\xc3\x24\xe6\x19\x24\x93\x42\xb1\xfb\x32\x05\x6b\x2c\xd4\xe1\x9b\xa0\x16\x48\x72\xa7\x27\xf5\x9c\x8c\x37\x63\x79\x85\x3a\x4a\x26\xd3\x94\xbf\x9e\xa5\x5c\xa7\x38\xc2\xb7\xe0\x23\x6c\x53\x4f\xb1\xee\x62\xb9\xbb\x3f\x8e\xd2\x78\x2f\x3a\x2d\x92\x37\x6f\xed\x87\xed\x94\xa9\xf4\xda\xc1\xb2\x8a\xda\xc0\x1d\xaa\xcd\x12\xa2\x87\x8b\xb9\x52\xe5\x38\x9f\xe5\x59\xf9\x2c\x1a\x9a\x91\x52\x67\x06\x44\xd7\x25\x5c\x77\x12\x4d\x9b\x76\xe2\x5a\x3e\x21\x09\x07\xe3\x0d\xbc\xcb\xc8\x37\x01\x79\x66\x93\xc9\x64\x56\xa2\xab\xb2\xc8\xd9\x05\x57\xaf\xfb\x19\x07\x09\x7a\x45\x05\xe3\x9c\x5e\x62\x5a\x2d\x85\x14\x1c\x45\x0e\xcb\x3b\xe7\x51\x08\x57\xc0\x4d\xbd\xed\xe8\x79\x43\xbd\x83\xb9\x24\x43\xc6\x41\xad\x04\xa2\x5a\x23\x47\x03\x74\x2c\xc1\x88\xad\x5e\xf3\x06\x9a\x9f\x56\x4d\xaa\x4d\x8d\x23\xf6\xe5\xec\x0f\x9e\x96\x65\x98\x67\x65\x92\xb9\x69\x3f\x2b\xb5\x8d\x42\x88\xea\x46\x34\x54\x20\x06\xff\x83\x9b\x99\xbc\x2e\x17\x64\xfb\xc1\x83\x90\x8d\xd7\xcd\xac\xfd\x7c\x1b\xaf\xda\xc4\x87\xb6\x6d\x8c\xb5\xd0\x56\x49\x2e\xa0\x95\xdb\x7a\x92\xc8\x33\xc8\xa0\x5c\x4b\x80\x87\x15\xd0\x79\x3b\xb7\x86\xf9\x8a\xbb\x76\x91\xe7\xe5\x2e\xeb\xdd\xd3\xe1\x4e\x2e\x92\x2c\xce\x2f\xd0\x70\x8d\x9a\xec\xf0\x74\x84\x76\x3a\x96\xd5\x95\x77\x47\x9e\x97\xca\x65\x72\x77\xc5\xd3\x44\xe6\x23\xdd\xde\xbc\xaa\x08\x12\xaa\xac\x70\x9a\x57\x19\x41\xdc\xca\x85\x0e\x9d\xa7\x60\x70\xde\x0d\x0c\x29\x31\x96\xbd\x0d\x22\xca\x35\x5a\x4d\xcc\x5a\xe1\x78\x62\xe0\xdb\x89\x9e\x44\x67\x2f\x92\x8d\xd9\x14\x3e\xee\xa9\xaf\xdd\x2f\x6e\x98\xa1\x73\xb3\xdf\x0a\x17\xf4\x1f\x6c\xb6\xd4\xe2\x09\x24\xf1\x7c\xf0\x1f\xcd\x72\xf4\x5d\x4d\x92\x23\x97\x42\x28\x46\xd9\x7d\xfe\x95\xa2\x31\x11\x1c\xea\x40\x90\xf2\xd8\x53\x61\x48\x0d\x3f\xde\x6a\x81\x0f\xa6\xba\x8b\xbf\x76\x57\x56\xbe\x23\xec\xf5\x36\x98\xe5\x1c\xda\x03\x30\x55\xde\xcd\xad\x38\x05\x65\xdf\x19\xa6\xa8\x42\xec\xae\x7c\xf7\x9d\xe1\xb3\x00\x68\xb3\x61\x61\xe5\xfd\xe8\xbb\xef\xbe\xab\x36\x42\xf8\xe6\xbb\xef\xae\x56\x68\x83\xa6\xbd\xc6\x0f\x3f\x90\x96\x76\x57\xbe\xbb\x5a\x59\xf9\x2e\xe0\xf3\xe3\x31\xc4\xcd\x6c\x88\x3f\x63\xf3\x9d\x16\xf9\x90\x0b\x71\x9b\xbb\xee\x17\xd2\x81\x42\x95\xb9\x51\x9f\xfa\x0f\xb6\x3c\xc0\x79\x4d\x23\xc4\x57\xdc\xcb\xf7\x8f\xc0\xeb\x55\x61\x46\x4d\x09\xf6\x8f\x8e\x14\xde\x3c\x3b\x47\xd5\xbf\x9c\x94\x2e\xcf\xce\xbb\x2f\x0f\x9f\x1e\xbc\x3d\x78\xf9\x6b\xdd\xbd\x85\x3e\xd8\x15\x46\x64\xff\xcd\x93\xe2\x18\x17\xc3\x68\xca\x59\x52\xaa\xe8\x2d\x2a\xb5\x68\x9b\x0d\xf8\x30\x92\x6c\x73\xc1\x41\x18\xcc\xf2\x92\xcd\x84\x9c\x3e\x29\xd8\x37\x04\x36\x97\x64\xd3\x59\x09\x62\x9a\xe0\x29\xa4\xe5\x15\x6d\x5d\xe3\x14\xdf\xda\x21\x83\xb7\x29\x06\x13\xd0\x94\x97\x1c\x94\xa8\x2a\x96\xe9\x39\x2e\x65\xdb\x3b\x8d\x7c\x57\xd8\x28\x22\x92\x50\x9f\x3e\x31\xf9\x6f\x17\xf1\xd6\x72\xd9\x62\x05\xc8\xf1\xff\x1c\x1d\x9d\x30\x5b\x93\x4d\xf3\x14\x65\x80\x24\x63\x4f\x0f\x7e\x95\xa7\x0d\x24\xfe\x52\x6c\xa3\x72\x11\x27\x82\x0d\x8a\xfc\x42\xf0\xa2\x0d\x89\x97\x1a\x90\x7f\x8b\xe5\xb3\x32\xe4\xc9\x39\x89\xca\x71\x12\x89\xc1\x65\xc6\x33\xd1\xb3\x9d\x35\x5c\x1f\x47\x18\x94\x2b\xf2\x59\x58\x98\x2e\xd8\x03\xbe\x40\x76\xe8\x87\xb7\x69\xa8\xff\xd7\x93\xda\x5f\x4f\x6a\x7f\x3d\xa9\xfd\xbf\xf5\xa4\x26\x09\xf6\x2a\x9d\x9d\x26\x99\x31\x74\x9b\xf7\xaa\xe5\x81\x2e\x78\xd7\xf2\xa0\x9d\x97\xad\x71\x9e\x9f\x09\x12\x7c\x3a\xcf\x30\xd8\xc6\x6b\xf0\xf3\x3a\x3e\x69\x9b\xef\xaf\xf0\x10\xac\x2d\x80\xab\x73\xb8\x04\x6d\xaf\x68\xc9\x3e\x84\xd9\xfe\x15\xb7\x25\x5a\xf0\xcb\x34\x86\x7c\xa8\xc7\x27\xfa\xb9\x05\x5e\x1b\xf1\xbf\x7b\x4c\x0e\x8d\xbd\xa3\x48\xbe\x63\x38\x04\x92\xf0\x36\x32\xf9\x5d\x92\x91\xfa\x86\x39\xcd\x23\x80\xed\x9a\xe6\x7a\xa8\x22\x08\x3f\xd5\x79\x54\xf3\x1e\xeb\x28\x0a\x35\xef\x14\x14\xa4\x99\x41\xb2\xf8\x98\x0f\xd3\xb6\x36\x9d\x6b\x51\x5f\xc1\xca\x0e\x6a\x67\xa7\x4b\x1b\xf2\xf6\x54\xc7\x02\xa5\x98\xe1\x16\x16\xae\x79\x9c\x9c\x04\xb1\x70\x9f\x07\x0a\xb8\xf2\x6b\xc1\x78\x96\x72\xff\x0d\xc2\x4b\x59\x68\x2c\x4e\xcc\x34\xd9\x49\x22\x1c\xa3\x66\x49\x91\x5e\x5e\x97\x2b\x8f\x08\x0e\x7c\x2d\x49\x09\x8c\xc2\xf5\xe3\x8a\x8b\x7d\x37\x11\x0a\xc8\xba\x97\x86\x9e\xcb\x00\x56\x11\xa1\xab\x1e\xa4\x96\x9d\x0f\x82\x45\xdd\x84\xd4\xc1\xcb\x69\x28\xe0\xd8\x77\x1f\x20\x8d\x0f\x40\xaf\xc7\xbe\x7f\x96\xe6\x17\xcf\x92\x0f\x2f\xb8\x3f\x36\xa5\x88\x83\xc6\xdd\x95\x47\xca\xdb\xcc\xed\x40\xcf\x9c\x47\x1c\x27\x6f\xc7\xc2\x59\x84\x4e\xae\x33\x8d\x50\x61\xd1\x3c\x12\xf5\xb6\x8b\xb5\xf3\xae\x97\xf1\x0f\xa5\xd6\x50\x5a\xd5\xe5\x75\x66\x0a\x6a\xd7\x4d\x15\x6d\xbe\xb6\x32\x2c\x1f\x0d\xe8\x53\x58\xb7\x14\x9a\x3b\x45\x78\xa5\x0a\xb7\x9d\xf9\xaf\x6a\x8b\xe8\x2f\xbb\xba\x16\xfd\x65\x85\x85\xf4\x97\x40\x4d\x8f\xe4\x4b\x13\x15\x9e\x8e\xaf\xc1\xff\x50\x41\x12\xd2\x67\xfd\xf9\x14\xc0\x33\x61\xa9\xb1\x23\x68\xed\xa8\xb1\xb8\x19\x47\x65\x54\xc3\x6e\x0b\xc7\x8e\x4d\x2c\x35\x6a\x04\x95\xe3\xad\x76\xb8\xec\xd8\xc9\x41\xb9\x14\x01\x08\x7c\xfd\xb1\x64\x61\x9a\xca\x79\x41\x4a\xe2\x88\xa0\xbb\xf2\xa6\x7a\xb3\xf8\x55\x29\xfc\x1d\x4b\xca\xc5\xe7\x96\xed\xa9\x8e\x62\x95\x1e\xea\x1a\x90\x74\x74\x81\x1d\xb4\x6b\xce\x29\xb7\x46\xdd\x5e\x87\x87\x3c\x2f\x58\xc4\xa6\x70\xec\x6b\x22\xb3\xe7\x23\x4b\xb9\x44\xb0\x69\x24\xdb\x6a\xc3\xbd\x1d\x6c\x7e\xc7\x79\x51\x0e\xd5\x5d\xfc\xdd\x47\x67\xa7\xbf\x7a\x37\x6f\xaa\x66\xa2\xd6\xbe\x41\xf0\x26\x62\x11\x60\x4b\xfd\x22\xe3\x03\x90\xc7\x7d\xa0\x1d\xbe\x74\xb4\x98\xff\x05\xed\x59\xb0\xb6\x82\xd9\x05\x6d\xd9\xb2\x57\xf9\x5f\x54\x4e\x63\xd9\x26\x5b\xfd\xbb\x58\xed\x36\xda\x80\x55\xc8\x4c\xc0\x7d\xcf\xf7\x24\xaa\xb9\x2f\xfa\x15\x58\xff\x46\xfd\x4d\x7a\xb6\xd9\x67\xd1\xda\x07\xea\xad\x00\xf0\xbc\x2b\x92\x85\x32\x15\x7f\xe2\x97\xa3\x22\x9a\x70\x31\xb7\xa3\xed\x30\xfc\xbc\xbe\x1c\x40\x53\x7d\x3f\xcf\xe2\x44\x92\x37\x4a\xe7\x76\xf8\xa0\xae\xc6\xbc\x2e\x3d\x50\xd3\x04\x7d\x78\xad\xed\xf1\x61\x10\x7c\x5e\x77\x14\xce\x54\xfe\x35\xe1\x17\x72\xa2\xe7\xf6\xf5\x28\x08\x3e\xaf\x2f\x0a\xf7\x15\xd5\x9a\x70\x05\xe4\xfa\x4e\xd7\xf8\x61\x38\x8e\x0a\xc1\x25\x1c\xe5\x38\xb2\xda\xda\x00\x96\x4c\x24\xae\x8b\xa0\xe4\x42\x17\xd3\x68\xc8\x17\x01\x9e\x69\x56\x92\x80\x2e\x03\x56\x60\x27\x3c\x4e\x22\x09\xe7\xf3\x4d\x05\x52\xe0\x33\xba\x58\x0a\x78\x94\x67\x65\x67\xa4\x70\x75\x18\xa4\x02\x7a\xae\xa6\x4a\x42\x3a\xd3\x5b\x81\xec\x4c\x44\x67\x19\x68\x78\xf7\xc7\x03\xe6\x1e\xd3\xee\x4f\x6a\xd7\x16\xca\x34\xf6\x22\x49\x53\xe5\x6e\x24\x8f\x1e\xf9\x63\x96\x72\x3c\xe0\xef\xf5\x56\xae\x6a\x5e\x80\x68\x92\x74\x35\xd9\x2d\xb0\x3b\x08\x24\x1c\x24\xc1\x95\xde\x8b\x29\x2f\x46\xa0\x2f\x05\xfb\xae\x7c\xd4\x39\x17\x1d\x31\x1b\x88\xb2\x90\x7f\x15\xfc\x94\x7f\xe8\x44\x65\xa7\x1c\xf3\xce\x80\x9f\x26\x99\x3c\x0a\x3a\x1b\x26\xc6\x9a\x8a\xbb\xfe\x9a\x9f\x1e\x7c\x98\x36\x1b\xff\xb7\xc1\xee\x33\x9a\x92\x95\x5e\x36\xa9\xf2\x62\xd9\x7b\xb0\x79\x8d\xe9\x96\x5c\x94\x00\xd9\x62\x8f\xa1\x4f\x35\x4c\xf0\x82\x08\x37\xb1\x63\x93\xe8\x93\x68\x6e\x1f\x3d\x7d\x86\x83\xa2\xce\xd0\xee\x1d\x2c\xdf\xa4\x33\x1f\xdc\x18\xe6\xec\x4f\x90\xe6\xdc\x03\x9d\x7b\xaa\x68\x20\x4f\x19\x3c\xa7\x8b\xfe\x7a\x3f\x00\x3c\xaf\x13\x0b\x15\x34\xca\xfa\xef\xb6\xe1\xaa\xf5\x9c\x74\x39\xee\xda\xab\x00\x55\x8e\xf3\xad\x79\x64\x45\x6b\xcc\x43\x9c\xb7\x7a\x3d\xb6\x1f\x89\x92\xbd\x93\x10\xef\x58\x99\xb3\x77\xb6\x8d\x77\x6d\x26\x12\x50\x63\x96\x4a\x8e\x85\xd0\x3c\x60\x9f\x77\x3a\x8b\x8a\xb8\x6b\xcc\x7b\xe0\xb2\xfa\x3d\xe8\xdf\x87\xba\x6d\xa2\x61\x02\xf4\x08\x0f\x38\xc8\xe1\xd8\x3e\x5e\x51\x0d\x93\x46\xee\xcd\xe1\xd3\x43\x8b\xa8\xbc\xe1\x88\xb2\xe0\xd1\xa4\x2b\xb7\xa1\x61\x91\x0c\x78\xb3\xf5\x4e\x8d\x0b\xc4\x6b\xfc\x3c\xc5\xa7\x31\xdc\x35\xc5\x38\x9f\xa5\x31\x1b\x70\xb9\x18\xd3\x64\x98\x94\xe9\xa5\x6e\x73\x96\x99\x86\x62\x0c\xf5\x70\x31\xe6\x19\xbb\xe0\x4c\x0a\xad\xf8\xae\x84\xfa\x9f\x44\xb0\x2c\x67\x69\x9e\x9d\xf2\x02\x1e\xe5\xb8\x1a\x3e\x0e\x9d\x20\xe4\x79\xe0\x05\x64\x72\x79\x0b\xa9\x58\x49\x99\x8b\xbf\x2c\x6d\xe2\x45\x05\xad\xa5\xe4\xdf\x27\x81\xb4\x8b\xce\x26\xa8\x34\x6f\x90\x13\xce\xd3\xbd\x2e\xa1\x0d\x43\x26\x82\xd9\x22\x3a\x6b\xb2\x35\xd0\x19\x73\x95\x64\x66\xfa\xd5\x56\x60\x75\x80\xa6\x44\x6b\x61\x5e\x1b\xbd\x06\x61\x91\xb7\x69\x9e\x4f\xe9\xf6\x0f\x1f\x80\x00\x73\x9c\x08\x91\x28\x8e\x8d\xf9\x82\x35\xa0\xcd\xc5\x14\xc1\x1a\xda\xec\xcb\x64\xc7\x50\x09\x6c\x03\xcd\x43\x55\x32\xc3\xae\x26\x88\x10\x18\x52\xb1\xc8\xff\xf9\x95\xe6\x97\xc4\xff\x2c\x05\xc8\x04\x5b\xd8\x80\x7f\x9e\x8e\xf9\xe6\x3b\x5a\xd6\xb0\x0f\x10\xb3\x00\x55\x25\x21\xa1\xe3\xf1\x80\xc5\x90\xe1\x43\x8f\xbe\x15\xb0\x7f\xbb\x0a\x58\x36\x3c\xfc\x26\xdd\x8b\x25\x3d\x7f\x4e\x44\x5d\x30\xb5\x47\xfd\x0a\xe4\xbc\x53\x41\xc3\x7c\xc5\x53\xf4\x8c\x0f\xa2\xc1\x3e\xe6\x2c\x0a\x1a\x26\x3d\xdc\xac\xc2\xce\xeb\xc2\x00\x7d\xbd\x83\xfa\x2b\x1c\x9e\xbd\x1e\x7b\xa2\xcc\x94\x58\xc1\xa7\x69\x34\xe4\x13\xb0\x4c\x06\x15\x47\x7e\xc1\xf6\xd8\xd3\xa8\xe4\xdd\x2c\xbf\x68\xea\xe0\x9b\x19\x2c\x2c\xf1\x52\xde\x6c\x1a\xfa\x97\x94\x41\xb3\xfc\x42\x83\xc0\x84\x68\x08\x54\x40\xb3\xfb\xec\xfe\x7d\x00\xf9\xa2\x47\xb6\xb2\x91\x92\xe5\x68\x80\x47\x0c\xa4\x2a\x4f\x26\x37\x39\x4a\xf5\xb9\x72\x6c\x46\x7b\x62\xce\xe9\x85\x07\x88\x7a\xa3\x5b\x42\x0f\x4f\x8d\x7d\x47\x19\xf1\x48\x5e\x66\xdb\x5a\xb0\xb5\x3b\xe6\xc1\x3e\xb1\xdc\xed\x6b\xde\x36\x3e\xca\x8e\x81\x7a\x76\x1d\x39\xc4\x83\xed\xd2\x73\xfe\xbe\x32\xe4\x73\x4e\x36\x45\x4f\xcd\x60\x60\xc6\x93\x79\xa6\x23\x97\x0e\x3d\xf5\x33\xe5\x3c\xdd\x32\xc9\xdd\xf5\x5c\xa9\x0b\xe1\x7e\xa7\xa3\x00\xf0\x02\x3d\x26\x25\x45\x79\xf7\xb4\xcb\xbc\x1b\x6d\xd7\x30\x17\xc8\x11\x58\x97\x1e\xe7\x66\x0f\xa4\xe3\xb6\xde\x36\xa6\x52\x77\x66\x51\xf3\x3c\xb1\x28\x59\x3e\x53\x68\xa8\x92\xd4\x8c\x7a\x24\x25\xaf\x71\x74\xce\x59\x24\x99\x48\x79\x2a\x4c\xa2\xa9\x55\xa0\x42\x45\x70\x53\xa8\xc6\x44\x20\xa3\xa7\xb3\x33\x47\x02\xab\x07\xad\x0a\x63\x3e\x2c\x32\x17\x12\x29\xac\x9e\xaf\x0e\x92\xec\x3a\xaa\x80\x2c\xcb\x1a\x42\xa0\x08\xa5\x47\xdb\x06\x19\x9c\x67\x65\x52\x70\xec\x20\x11\x2c\xbe\xcc\xa2\x49\x32\x84\x37\x6d\x04\xc7\xf7\x6c\xdd\x1e\x28\x0e\x06\xdc\xbe\x6d\x83\xa8\x0b\x11\x26\x74\xbb\x96\x7c\x0a\x21\xcf\x5d\x53\xa1\xac\x0a\x5d\xd6\x30\x64\x7d\xbb\x84\x64\xfb\x96\x8a\xb6\x6f\x83\xb2\x6d\x9d\x08\xf2\x8d\xc5\x19\x40\x2d\xc7\xe9\xc1\x07\x29\xbe\xf6\x9a\xc7\x4f\x3a\xff\xe7\xa4\xd5\x3b\xd5\x05\x70\x4a\x51\xc1\x56\x7d\xb2\x76\x7e\x6a\xaf\x58\xed\xac\xb2\xfb\x12\xb3\x6e\x99\xff\x9c\x5f\xf0\x62\x5f\x65\xaa\xa3\xbe\x4e\x26\xe4\x6e\x8d\xcd\xa0\x35\x59\xeb\xea\x7e\x10\xb7\xb6\xee\x37\x18\xbb\xe1\xe1\x37\xe9\xea\xf6\x97\xa1\xd9\x5f\x86\x66\xdf\x8c\xa1\x19\x54\x31\xee\xea\x61\xbb\xe5\x6d\x0f\x70\x5e\xd3\x08\xf1\x15\xef\x18\xff\xad\x36\xd7\xdf\xb0\xf9\x9d\x8a\x68\xf1\x2f\x5e\x9a\x03\x7a\xaa\xc3\x13\x42\xcc\x09\xea\xd1\x8c\x27\xe6\x10\xd5\x2e\xb8\x3d\xe1\x9e\x0d\x31\x47\xa9\xd4\xa8\x60\x50\x47\xa2\xa2\x10\x43\xa3\xf8\xf6\xae\x2e\xf4\x34\x48\x68\x51\x50\xa9\xf1\x80\x4d\xa2\x4b\x35\xb6\x64\x64\x50\x92\x22\xc2\x0c\x9f\x61\xbb\xb4\xbb\x46\x03\x2d\xd9\x48\x88\x8e\xc5\x03\x12\xc1\x01\xd9\xc8\x88\xce\xb8\xdc\x01\x09\x3b\xa0\x26\xad\x74\x8b\x43\x32\x19\x41\xaf\xec\x99\x88\x46\x4b\xd6\x88\x5f\x62\xa4\x03\xdd\xc9\x8e\x8e\xde\xfc\xfe\xf3\xc1\xdb\xd7\xbf\xfc\x7c\xb0\xc3\xfa\x52\x5c\xff\xe9\xe0\xf7\x67\xaf\x9f\xbc\x38\x38\x52\x1f\x1f\x78\x8f\x33\x25\xc8\x60\xfb\x47\x47\x0c\xd6\xed\x19\xbf\xd4\x4f\x30\x2b\x57\xbb\xe7\x18\x57\xfa\x27\x1e\x32\xc8\x24\x71\x9f\x3c\x00\xfb\x55\x12\xf6\x0d\xff\xe0\x24\x20\x54\x99\x82\xfc\x5c\x24\xec\x9f\xac\x2f\xd7\x15\x4d\xda\xe0\xe6\x5b\x60\x8f\xdd\xc2\x1d\x9d\x03\xc1\x72\x9c\xec\xab\x8b\xcf\x3a\x4d\xd9\x4f\xdb\x7c\xd4\xc1\x10\x1a\x1f\x1b\x2d\xd6\x61\x7d\x9d\xea\x27\x94\x45\x51\xcd\xb4\x93\x75\x48\x4d\xbe\x09\x9a\x45\x69\xdf\xb5\x54\x6f\x55\xd8\x5f\x39\x21\x48\x24\x76\x97\x6c\xce\x9d\x33\xcf\x1c\x2c\x9a\xc8\xdd\x55\x37\x20\x7f\x3a\x6a\x31\x7c\x39\xd2\x8b\xc2\x3e\x45\x82\x27\x81\x03\xdd\xeb\xb1\x37\x63\x5e\x70\xa5\x0e\x2e\x74\x73\xe8\x84\x20\xaf\x66\x69\x9a\x5f\xc8\x43\x48\x79\x23\x88\x1d\x5b\xb3\x23\xb9\xf9\x11\xfd\x7d\x14\x8d\xa2\x22\x61\x0f\xba\xfd\xee\x43\xfa\xfd\x45\x3e\x48\x52\xae\x8b\x1f\x75\xd7\xba\x6b\x64\x38\x6a\x7a\xc8\x88\xd4\x17\x3f\xe2\x48\xe3\x07\x39\x80\x2a\x67\x05\x66\xd8\x3e\xbf\xb6\x5a\xae\xd1\x4b\x8f\x5e\x33\x85\xb3\xd8\xdc\x96\x29\x26\x26\x29\x54\xb3\xb5\xeb\x6c\x2e\x92\x48\x7a\x7a\x03\x1b\x8b\x2a\xb1\x7b\x0b\x65\x05\x9c\xd4\x10\x93\xa0\x83\x24\xe1\x19\x7c\xc9\x7c\x4d\xf6\x04\x39\xd1\x82\x97\x25\x2f\xd8\x45\x24\xc0\x4d\x46\xcc\x86\x43\x2e\xc4\x68\x96\x76\x11\x7e\x7f\x56\x14\x3c\x2b\xd3\x4b\x76\x91\x17\x67\xe8\x22\x3f\x2e\xf2\x09\x87\xb8\x7c\xdd\x95\xea\x3e\xed\xe0\xb0\xe7\x63\xe1\x1c\x14\x02\xc6\xfe\x6e\xcc\xa3\xf8\x1d\xe3\x29\xe8\xaf\xd8\x6c\x9a\x2b\xc6\x49\x0a\xa1\x4f\x9e\x2c\x66\xc3\x68\x38\x96\x97\xf7\xd2\x46\x30\x3a\xe5\xe5\xbf\x79\x14\xd7\x6c\x2a\x63\x2c\x82\xd8\xd5\x6b\xbb\xa1\x05\xea\xa8\xfa\x25\x78\x4b\x57\x8a\xf3\x21\x6c\x10\x5d\xf8\xfd\xe9\x93\xfd\x70\xca\xcb\x03\xc4\x54\xfc\x78\xf9\x26\x3a\x7d\x19\x4d\x78\xb3\x21\xc1\x1a\xad\xe3\x35\x37\x77\x91\xfc\x1a\x9a\x75\x18\x7a\x24\x2f\xf1\x2c\x1f\xe1\x8d\x15\x32\x5f\xb3\x0b\x58\x48\x72\xf0\x74\x53\x8f\x32\x36\xcb\xd0\xc3\x26\x86\x90\x82\x92\x1c\x70\x4c\x40\xe4\x27\xd9\xd4\x34\x2f\xe5\xfd\x37\x4a\xd3\x4b\xa6\x21\xf3\x8c\x43\xba\x09\x54\x9c\xcc\x04\x3a\x4d\x41\xf8\x82\x64\x74\x09\x7b\x35\xea\x43\x64\x73\xb2\xcf\x61\x5e\x14\x5c\x4c\x25\x6b\x67\xa7\xec\x7f\x74\x79\x97\x3d\x01\x1c\x54\xcd\x84\x17\xb2\x55\x79\x91\xd8\x3f\x3a\xb2\xa2\xda\x05\x67\x59\x5e\x4c\x00\x05\x79\x05\x7a\x47\x27\xfe\x5d\x97\xbd\x19\xe7\xb3\xd3\xb1\xa4\xb5\x4e\x56\x68\x3d\xab\x4a\xfe\x01\xa2\x58\x29\xad\x8e\x30\x63\x18\xe6\x31\x67\xd3\x3c\xc9\x4a\x81\xfa\x9d\x77\x3b\x59\x5e\x36\xff\xf6\xc7\x1f\xeb\x6b\xad\x77\x6d\x89\xc1\xe1\x0b\xbc\xcb\x0f\xf3\xc9\x54\xee\x10\x09\x04\x84\x51\x70\xac\xf5\x4e\xb6\x0b\x4a\x80\xdc\x0c\xb9\x21\x3c\xec\xd8\x05\x38\x96\x4d\xe0\xb8\xd5\x03\x77\x16\xa5\x6c\x45\x5b\x01\x5c\x5c\x5c\x74\x2f\x36\xba\x79\x71\xda\x7b\x2e\x05\xbd\x2c\xc2\x9d\xa0\xf7\xbf\x33\x2e\x40\xc7\xd8\xfb\xdf\xa8\x83\x43\x10\x7f\x1b\x0a\xa1\xfe\xa4\x7c\xfb\x8b\x9e\xd0\x9f\xf8\xa5\x78\x11\x4d\x6b\x78\x58\xeb\x18\x2c\x13\xab\xb8\x17\x10\x6b\x08\xec\x8f\xd5\xf1\x1e\xe2\x6f\x98\x3e\x2f\xa3\x11\x51\x43\x86\x53\xfa\x8d\xa2\x21\x1f\xe4\xf9\x59\x6f\x94\xe6\x17\xbd\x44\x88\x19\x17\xbd\xf5\xed\x47\xdb\x76\xa9\x28\x55\x86\x46\xce\xac\x0d\xbc\xa3\xaa\xe5\xd1\x6c\x40\xb9\xf6\x1f\x0b\x5d\x3c\x91\xbd\x82\x46\x8d\x44\xbd\x0b\x50\x24\xa4\xfe\x35\x75\x6c\xbe\x32\xf4\x3c\xb2\x1e\x7f\xda\x84\x5d\xff\xde\xb5\x27\xce\x61\x26\xf9\x58\xcd\x92\xad\x00\x99\x21\x90\xeb\x92\x91\xe4\x35\xc3\xb2\x11\x1b\x44\xc3\x33\x26\xd2\x48\x8c\xbb\xf4\x28\x35\x75\xef\xde\xb5\x2c\x65\x4e\x99\x3f\xfe\x68\xb4\x4c\xc0\x2d\x27\x88\xd2\xcf\xd1\x9f\x89\x5c\x4c\x18\x57\x0a\x5f\x61\xe9\x2b\xab\xa1\x85\x65\x07\xf7\x79\x4d\x6d\x8f\xcd\x56\x37\x9a\x4e\x79\x16\xef\x8f\x93\x34\x36\x11\x42\x2c\x9c\xc3\x4e\xd6\x9c\x9d\x39\xf1\xf5\x51\x5c\x95\x0b\x15\xb2\xc7\x64\xf4\x80\x61\xf7\x59\x83\x7d\xbc\x6a\xd8\x7a\x78\xef\xa3\x0f\x9d\x34\x58\x19\x33\x0e\x04\x6f\x95\x14\xec\xb8\x0e\x28\xb2\xb9\x46\xc5\xe4\xa4\x7f\x0d\xbb\x96\x0a\x67\xd6\xd5\x1f\x48\x75\x47\x38\x12\x2d\xc9\xf6\xc7\xfa\xd7\xf1\xda\x89\x73\x46\x9d\x68\x1e\x38\xe3\x97\xf5\x01\x41\x99\xc9\x6a\x5a\x25\xb5\x25\x33\xc6\x4a\x0e\x91\x39\xb4\x62\x99\x9f\xbc\x6a\x12\x4d\x43\xa7\xc5\xb3\xc4\x44\xf4\xe3\x3a\xe4\x15\x68\x7b\x23\x15\x9a\x8d\x8d\x93\xd3\x31\x64\x0f\x8a\xf0\xe4\x54\x96\x09\xea\x00\x20\xf2\xc4\x28\xc9\xe2\x7f\x03\x30\x1a\xad\x17\xc6\x31\xc7\x79\x8e\x09\xae\x55\x05\x1a\x5a\xae\x8e\x4b\x88\x82\x33\x0b\xd6\xcc\x65\xd7\x8c\x41\x2e\x04\xf8\xa2\x5d\x47\x70\x18\xff\x64\xee\xef\x00\x98\xe0\x85\xfc\xf3\x95\x3c\x11\x40\xba\x08\x17\x55\xe2\x65\xf9\xc1\xd2\x56\x3c\x27\x9c\xab\xc5\xd4\x96\x84\x05\x42\x8b\x12\xc9\x5e\x47\x5b\x51\x2e\x4f\x5c\x8f\xaa\x10\x02\x8f\x25\xec\x9f\x48\xf6\x4e\xe7\x16\x29\xfc\xb5\x48\x27\x0f\x62\x10\xe4\x80\x6a\xab\xef\x85\x58\x95\xfb\x74\x12\x87\x98\x71\x1f\x61\x5f\xe6\x31\x6f\x96\x46\x9e\x25\xd2\x9b\x59\x5c\xbb\x35\x7c\x29\xe1\xba\x90\xd5\x4a\x36\x12\x3c\x4d\xf0\x41\x34\x96\x5b\x91\x07\xed\x90\x50\x82\x74\xe5\xff\xbc\xd1\xb7\xa9\x87\x92\x8e\xe6\x33\x9a\xe0\x97\x45\x32\x69\x62\x84\x9d\x92\xdc\x48\x2d\x51\xf2\x98\x5f\x87\x5a\x80\xd8\x80\x8f\xf2\x82\x6b\x93\x46\xce\x86\xb0\xb4\xe5\xb4\xe0\xed\x00\xa6\xb2\x4a\xbd\x57\x05\x3f\x07\xd2\x39\x0c\xa6\x74\xf0\xda\x01\x52\xab\xdf\x42\x71\xfe\x77\x57\xb4\x83\xba\xcf\x88\x24\x22\x9e\xbc\xe0\x15\x97\x20\x3b\x22\x4a\x0a\x5b\x89\x59\x26\xa5\x7c\xb5\xfd\x68\x2c\x3d\x76\x5d\xbc\xe7\x78\x5c\xdc\x72\x38\xaf\x5b\xf0\x2c\xe6\x05\x2f\xba\xea\x82\x60\x9f\x84\x0e\xcb\x31\x2f\x2e\x12\xc1\x35\x62\xd1\xa8\x54\x49\xd4\xd2\x48\x94\x66\x15\x2b\xa3\x24\x1f\x9f\xfa\x75\x7a\x3d\x84\xba\x92\x08\x4a\xe8\x39\x4a\x06\x69\x92\x9d\xd2\x80\x58\x8a\x76\x23\x77\x71\xc0\xf3\xc3\x38\x4f\x63\x5e\xa0\x87\xa5\x9a\xaf\x44\x60\x48\x32\x1d\x12\xcc\x5f\xb7\x35\xab\xd6\x04\x1a\xf0\xe0\x6d\x34\xba\xc0\x06\x40\x12\x60\x99\x59\xd3\xf8\xed\x55\x96\xa7\xb7\x4d\x10\x25\x04\x02\x59\x95\x05\xfe\x06\xb2\x10\x7a\xe8\x57\x3c\x08\xae\x06\xe9\xd0\x47\x09\xc7\x8b\x85\x6e\x19\x25\x7d\x90\xd6\xa5\x64\x15\x49\x99\x7c\xc0\xd9\x28\x9f\x65\xb1\x56\x27\x68\x61\x93\x75\x74\x9b\x83\x28\xd6\xed\x0d\x13\xb8\x31\x09\x7c\x22\xbd\x64\x52\xee\x89\x0a\x9c\xff\x7a\xe7\x8c\x10\x69\xde\x0b\xd1\x30\xfe\x1a\xcf\x3d\x04\x57\xff\x2e\x56\xe1\xba\x0c\x98\x75\x1b\x6d\x16\x20\x8e\x13\x15\xcb\x5b\xfb\xd8\xa0\x12\xa0\xf5\xc5\x37\xc9\xca\x1c\x86\xf8\xf4\xf0\x85\xb7\xd8\xb1\x79\xc7\xc0\xa0\xb2\xe4\xaf\xc3\x29\xf8\xde\x8b\x9b\x87\x9a\xea\xca\x5e\x62\x58\x4a\x03\x52\x36\x99\x46\x85\xe2\x0b\x78\x19\x42\x80\xae\xfd\xaa\x16\x29\x54\x37\x1f\x5b\xa4\x9a\xc2\xea\x47\xd8\x4a\xf4\x98\x4c\x4f\xf4\x16\x4d\xd7\xd2\x6f\xa0\x83\x80\x83\x25\x51\xfa\x28\x08\x77\x9c\x5d\xe2\x3e\x5a\x82\xde\xeb\x7a\x4b\xc1\xdd\xf2\x75\x10\x3c\xb2\xf9\xe9\x3b\x92\x28\xa3\xe1\x99\x94\xff\xe5\xc5\x08\xae\x4a\xf6\xbe\xb7\xd9\xdf\x58\x7f\xf8\x60\xfd\x61\x6f\x94\x17\x43\xde\x19\x46\xa2\x4c\xb2\xd3\x4e\x92\x75\x24\xb0\x21\x9b\xdb\xb3\xda\x33\xd8\x1e\xf3\xa7\xc8\x88\xd0\x0e\x9d\x83\xb5\xc3\x44\x7f\x4b\xa9\xfe\x76\x01\xd9\xc3\xed\x92\xe5\x7b\x4d\xf7\x26\x7f\xb9\x24\xa8\x5b\x52\x0b\x58\x72\x77\x23\x3c\xc3\x56\x92\x5e\xc0\x1d\x4a\x71\xfd\x34\x9f\xbc\x56\x9b\xf1\x3c\x4f\x7f\x02\xe6\xde\x2a\xc2\xae\xfe\x04\xdc\x71\xf3\xd7\xcf\x16\x28\x95\x10\xff\x53\x0c\xfb\x6a\x4b\x45\xb8\xd4\xde\x39\xc9\xaf\x5d\xa7\x7d\x54\x80\xe3\x1f\x6e\x49\x40\x5f\x10\xf8\x4a\xea\x8c\x23\x81\xf3\xc0\x63\x7d\x5f\xb2\x9a\x82\x8a\xd6\x56\xc9\xb9\xf2\x8a\x29\xe7\x48\x1f\x71\x46\x71\x04\xca\xf6\x88\xc9\xdb\x76\x1c\xa5\x79\xc6\x99\xb9\x6e\x77\xfd\xc3\x32\x24\x70\x44\x71\xec\x86\x9b\xb6\xa1\x72\xf5\x45\x8e\xda\xbf\x16\x7c\xe4\x04\x63\x66\x8f\xc9\x0f\x2d\xd3\xb2\x1d\xf6\xf1\xca\x5e\x2b\xc1\x03\x46\xca\x3b\x05\x1f\x75\xe1\x07\x2d\x2b\x49\x51\x49\x4a\xb8\x59\x83\x50\xe8\xca\x18\xd0\xa7\x85\xd0\x7f\x51\x75\xe0\x3c\x95\x07\xad\xae\x54\xf4\xac\x21\x85\xc6\xde\x50\x88\x46\x00\x46\xf0\xf2\x49\x59\x16\xc9\x60\x56\xf2\x66\x23\x8e\xca\xa8\xa3\xce\xa1\x06\x39\x6f\x61\x6c\xad\x79\x35\xd1\x19\xa8\x8d\x24\x71\x6a\x96\xf3\x2b\x42\x97\x12\x0a\x2a\x1b\x73\x96\x05\xa9\x52\x20\x77\xad\x18\xe6\x05\xef\xc4\x51\x76\xaa\x82\x3b\xa3\xd4\x9d\x81\xbd\x47\x28\x40\x94\x7d\x79\x05\xa8\xb7\x6f\xa9\x24\x9e\x0d\xf9\x5c\x44\x01\xa2\xd1\xc6\x0e\xec\x71\x6b\x1e\xa4\xea\x0f\x58\x64\x6d\x56\x16\x9c\x9b\x17\x2a\x3c\x5c\xfe\xfd\xe6\xc5\xcf\xc0\xd5\x7a\x5f\xce\x38\x8f\x05\x1b\x25\x1f\x92\xec\xf4\x7a\x9a\xb2\x4a\x20\x0c\xb2\xa7\x78\x41\x30\x50\x48\xad\x8b\x16\xaf\x42\x8a\x9b\x4b\x86\x14\xa1\x70\x89\x42\xa0\x5a\xb0\x7b\xd2\xd8\xaa\x20\x50\xfc\x03\xa8\x24\x53\x2d\x46\x25\x82\x45\x69\xc1\xa3\xf8\x92\xee\xc0\x44\x3f\xe5\x90\x99\x1c\x38\x9f\x3e\xb1\x3b\x76\xd5\x79\xc6\x6a\x78\x1c\xcb\xfd\x42\xe9\x90\x0b\x2d\x85\xf3\x58\x05\xdb\x7a\x87\xbf\x31\x74\xc5\x93\x57\xcf\xdb\x4a\x3e\x7f\x87\xab\x58\x47\xc6\x36\x71\xd3\xdf\xd9\x86\xf5\x4b\x91\xca\x3e\xc5\xca\x71\x2e\x38\xf1\xec\xb2\x9e\x10\x0c\xcc\x48\x38\x44\xb5\x02\x85\x1c\x28\xe2\x66\xa7\x38\xfa\x91\x22\x00\x79\x14\x35\x72\x44\x54\xa0\x58\x29\x18\x70\x45\xcc\xa7\x69\x7e\x69\xaf\x5b\xfa\x96\x83\xd8\x41\x24\x30\x4c\x50\x24\x45\xe6\x0a\xf9\xfc\xdd\xb6\xe2\xcf\x8e\xcd\x37\x89\xde\x6d\xc1\x2e\xad\xf5\x4f\xba\x27\x22\x01\xd2\x09\x6b\x07\x36\xc6\x56\xbd\x8b\x36\x50\xd3\x5d\x15\x2a\x9b\xa7\xbb\x2a\x6a\x1c\xae\x71\xce\x6a\x98\x55\x4f\xa8\x19\x7a\x0d\x63\x39\x6a\x32\x0a\x53\x8b\xf7\xf3\x0c\x22\xd1\xec\x1f\x1d\xe9\x28\xca\xb0\x94\x75\xd3\x73\x11\x96\x64\xaf\x45\x18\xe7\xc4\x09\x7f\x12\x64\xf9\xc0\x78\x5c\x4d\x68\xe3\x8f\xac\xc1\xee\xd3\xb9\xd0\x79\xcb\x9a\x2d\x76\x1f\x8a\xeb\x07\x87\x77\x57\x65\xb9\xb8\xe4\xc0\xec\xda\xaa\x19\x9c\x05\x50\xa1\x52\x40\x67\x15\x48\x38\xa1\x0f\x5a\xb3\xd1\x5a\x7d\xcf\xb2\x1a\x57\x7c\xa9\x30\xda\x74\x3b\x74\x47\x65\xaf\x10\xd0\x09\x06\x74\x2b\x26\x82\x3d\x85\x05\x1b\x3e\xd7\x7e\x41\x4f\x82\x31\xa4\x60\xfa\x52\xdf\x25\x63\x15\x65\xa1\x87\x6a\xd6\x50\xc0\x8c\x82\x5d\x27\xf0\x5e\x94\x29\xf9\x15\x27\x2a\x03\x17\x29\x70\xa2\xe5\x31\xce\xda\x1f\xd9\x1f\xc5\xdf\xe5\x41\xed\x84\x51\xa8\x5a\x60\x30\xa2\x5a\xae\x5b\xff\xa8\x80\x77\x95\x4a\x46\x79\xed\xe6\x1d\xf1\x59\xe9\x29\xda\x79\x23\x2b\xcd\x5f\x16\x12\x70\x0e\xf7\x58\x00\xdf\x8a\x61\x31\xe7\x10\x30\x27\x99\x84\x7e\xf2\xd0\x0d\xd6\xe7\x92\x08\x91\x4d\x1f\x1a\x06\x2f\x77\x92\x1d\xbb\x96\x30\x75\xfe\xc5\x95\xe2\x96\xe5\x23\x16\x19\x5b\x95\xf9\xab\x0c\x50\xae\x5d\x62\xee\x80\x1c\x0a\x91\x55\x53\x25\x52\x75\x09\x59\x7b\x61\x4d\xb3\xb5\x5d\xfd\xf7\x3f\x2a\x6b\x45\x95\xb8\x51\x40\xc8\x9b\x07\x50\xd2\x30\xcd\x5b\x9d\x60\x44\x11\xe9\xad\x4a\xe8\xe2\xf2\xa3\x2a\xec\xf4\xeb\xe9\xa7\x3c\xb0\x23\x30\x12\xd3\x8f\xa9\x2a\x6a\x18\x9a\xf6\x82\x40\xf2\x21\x81\xdb\xaf\x7a\x7f\xa8\x25\xae\xaa\x33\x87\x0b\x09\x84\x35\x7f\xa8\x06\x58\x59\x8a\xcb\x30\x06\xd2\xc5\xbe\x26\x90\x86\x0e\xee\x92\xc1\x1d\x7f\x39\x0e\xb4\x7d\xcc\xe3\x43\xe3\xa8\xae\xf7\xfa\xb9\x21\x69\x4e\x39\xa0\x28\xea\x53\x1b\x41\x71\x4d\x9a\x90\x3a\xce\x63\xe1\x08\x23\x44\x54\x9d\x1b\x5d\xc4\x81\xf3\x4d\xa8\x6f\x16\xea\xfd\x2f\x13\xea\xbf\x4c\xa8\xbf\x05\x13\xea\x6f\xda\xda\xd6\xbb\x92\x23\xb4\xbc\xbc\x8f\xf3\x58\x74\x66\x82\x77\xc0\x55\x5b\x6e\x28\x4a\xeb\x8c\xcb\x15\x2c\xf1\xa2\xe1\x19\xcf\xc0\x1e\x28\xce\xa5\x70\x33\x46\xa1\x1a\x2e\x91\xef\x85\xb5\xb0\xfa\x35\x29\xca\x59\x94\x2e\xa3\x65\xf3\x40\x17\xc4\xd3\xf4\xa0\x5b\xe1\xf8\x91\x1e\x94\x77\x75\xd6\x7a\xb6\x9a\x6d\xd1\x58\xe5\x56\xb7\xc5\xc2\x71\xed\xad\x6c\xb6\xf3\x5a\x3d\xad\x6d\xb5\xd1\xa8\x6d\x93\x28\xfc\xe6\x20\xab\x2d\xfd\xae\x8d\xef\x4f\xbc\xee\x8a\x83\x85\xd7\xc2\x75\x49\x85\x44\xa0\xe6\x92\xb7\xc3\x60\xcd\xa5\xae\x69\x81\x9a\xd7\xb9\x07\x55\xa8\xe0\x19\x62\xdc\x40\x48\xbe\xde\x94\x5d\x4f\xf2\xb9\x26\xda\xd7\x10\x16\x82\xf4\x5c\x46\xe2\xad\xa0\xd4\xe9\xd7\xca\x13\xde\x1a\x9e\x2b\x53\x54\x60\x7d\xb9\xe2\x36\x13\xb9\xdc\x9a\x5c\xf1\x5e\x88\x37\x7c\x32\x4d\xa5\x6c\x5c\xe7\xb2\xfe\x30\x04\x3d\xcf\xad\x84\x80\xd1\xaa\xff\x9a\xe7\xb8\xb2\xf9\x68\xad\x0a\xbb\xa0\x93\x7f\x19\xf7\x15\x5d\xed\xe0\x43\x29\xcf\x86\xba\x2e\xfa\x55\xd8\x05\x5d\x20\x10\xad\xf6\x92\x0b\x4c\xf2\x1c\xee\x62\xb3\x0a\xbb\xa0\x0b\x04\xa2\xd5\xf6\xf3\xc9\x34\xaf\x8f\x21\xf0\x68\x2b\x00\xbc\xa0\x13\x05\xe5\x54\x8c\x26\x3c\x9d\x17\xab\xe0\xd1\x76\x10\x7c\x51\x4f\x1a\x8e\x56\x56\x00\xbf\x64\x49\x5d\x6c\x87\xcd\x47\x0f\x6a\x2a\x2c\xe8\x8f\x40\xba\xb3\x3b\x8d\xe6\x70\xc2\xa3\x2a\xec\x42\x4e\x90\x40\xb4\xda\xaf\x3c\x8b\xf3\xe2\x55\xc1\x47\xc9\x07\x90\x2f\x42\x5d\x6d\xad\xf5\xeb\xeb\x2c\xe8\xd2\x05\xa6\xcd\x80\x08\x78\x94\x17\x75\xd4\xdc\x5a\xdb\x0e\x82\x2f\xe8\xd0\xc0\xdd\xbe\x4b\x98\xda\x2a\x03\x21\x94\xba\xaa\xa8\xc6\x8c\x58\xbf\x98\x05\xdd\x65\xd6\x5c\x77\x99\xb5\x79\xee\x32\x6b\x27\xf0\xea\x46\xc3\x83\xc1\xbe\xaf\x82\xb2\xed\x30\x0c\x27\x40\xf7\x38\x8d\x5a\x4b\x5b\x16\x74\x4b\xbd\xaf\xb5\x99\x86\x56\x5b\x55\x15\x56\x79\xd7\x59\x48\xb5\xe3\x54\x21\x39\xee\x32\x16\x52\x6d\x1c\x55\xc8\x0c\x37\x0b\x0b\xa9\x97\x7f\x15\x74\xa8\x96\x3c\x81\x35\x4b\x38\x00\x6d\x96\xad\x85\xa7\x8b\xb0\x5a\x23\x26\x0b\x8f\x8e\x11\xd6\x52\x68\x8c\xb0\x7e\x2c\xa4\xb7\x14\xaa\x35\xce\x5d\xf6\xb7\x35\x2d\x3b\x57\x2b\x4d\x0d\x0b\x9f\x28\x7b\xd4\xea\x49\xfc\x1f\x4d\xf3\x54\x9b\x1c\x2d\x2a\xe6\x84\x8d\x79\xe4\xc2\xcd\x4d\x8b\x26\x01\xbe\x62\xc0\x49\x27\x0c\x95\x1b\xf8\x2f\x1c\x9f\x8a\xc4\x00\xa1\xa1\xb1\x03\x56\x5d\x4e\xe4\x6c\x4c\x29\x06\xa3\x77\xf3\x89\xd9\xc0\xe8\xbb\x26\xd4\xc0\x82\xdc\x3c\x8e\x93\xfd\x47\x3f\xc2\x96\x3b\xa2\x30\x0f\xdd\x66\x66\xa8\x6f\x3d\xd5\xd3\x57\x62\x24\xc1\x27\xc9\x6f\x49\x39\x7e\x29\x65\xc4\xde\xee\x1f\x59\xcf\x1a\x92\xbf\x8c\x92\x73\xf4\xd1\x04\x0e\x00\xbf\x16\xd6\xd1\x79\x35\x05\x78\x74\xa1\x4a\x77\x90\xc7\x97\xac\x99\xe5\x36\x35\x52\x0b\x61\x15\xd2\x02\xfa\x19\xe6\xa9\xbc\x12\x66\x31\xa8\x31\xc0\x1a\xc0\x5a\x60\x62\x64\x9a\x26\xff\x30\xe4\xd3\x92\xe5\x23\x34\xc9\x94\x40\xaa\xa9\x97\x39\xc3\x8d\x58\x29\x42\xd5\x93\x0a\xa8\x1e\x16\xb1\x9e\xe3\x0e\x4a\xfd\x64\xf0\x68\x82\x2f\xd3\x34\x51\xfe\x80\xe8\xcd\x29\x7f\x37\x2d\x79\x6a\x0d\x8a\x01\xb0\xce\x8c\x18\x62\x13\xed\x21\x0c\x18\x0f\xaf\x68\xcd\xfb\x1d\x08\x28\xe8\x79\x9b\xa0\x45\x65\x9a\x67\xcf\x95\x8a\x5a\x02\x59\xdf\x8f\x9d\x86\x63\x46\x69\xe1\x3c\x77\x90\xc5\x2f\x55\x2f\xa2\x74\x94\x17\x13\x1e\xd3\x47\xd2\xd5\xbf\x8b\xd5\x06\xc6\x5b\x9a\x9b\xd9\xd3\x44\x7f\x51\xf8\x29\xc7\xd7\xb5\x36\xc1\xbd\xa5\x0c\x9f\xed\xb8\x74\x80\x22\x5a\x85\x8c\xe1\x3e\xeb\xbb\x75\x48\xf4\x21\x37\x79\xa8\x1f\x20\xa8\xba\x51\x3c\xfa\x26\x53\x3f\xa1\xc0\x21\x6c\x34\xd9\x48\x88\xe4\x34\x03\x6d\xad\xe1\x54\xd4\xa1\x56\xd4\xc6\x7d\xe4\x35\x5f\x1a\x73\x54\xc7\x22\x9f\x15\x60\x3d\x63\xc5\xaf\xe4\x64\xd7\xb6\x73\xc6\xc1\xa2\x03\xc1\xb4\xf2\x51\xa1\x62\x74\xa5\xdd\x71\x24\x0e\x2f\x32\x3d\x4a\xcc\xbd\x85\x55\x30\xab\x3c\xe8\x22\x01\x49\x88\x0c\x2b\x99\x1b\x4a\xe1\x17\xaa\x77\x8d\x82\x17\xe1\x30\xe1\xf4\x5f\x1a\xf5\xbf\x34\xea\xd7\xd7\xa8\x07\xf7\x75\x23\xff\x93\xdb\x56\x5d\x60\xdb\xad\x87\xdf\xb8\x62\x5e\x6f\xa6\x68\xca\xd9\xf8\x01\x2f\x30\x8d\x5d\x55\x20\xe5\x70\xb7\x88\x35\xd4\xb0\x91\x06\xfb\x3a\xb0\x99\x2f\x09\xfa\xfa\xf6\x00\x78\x13\x98\x09\x93\x62\x57\x22\xec\x85\xf5\xf0\x81\x56\x1c\x13\x4d\x6d\xb6\x68\x86\x61\x8b\xce\x60\x18\x67\x8e\xa5\xaa\xbd\x68\xaa\xbf\x48\x59\xa1\x9e\xc3\x25\x69\xe5\x14\x77\x75\xec\xb5\xa6\xde\x4a\x9b\x24\x4c\x5f\xdb\x9c\x7e\x68\x39\xb4\x03\x8d\xe0\xa9\xd5\x6a\xf9\xf1\x3f\x8d\x27\xa2\x0e\xb4\x25\x3c\x33\x24\xb4\x1d\x03\x33\x54\x05\xaa\x09\x75\xac\x3f\x9c\xb4\xd9\x47\xd3\xd0\x8e\x6d\xf2\xca\xb5\x4b\x22\xcd\xa9\xc4\x18\xcd\x80\x01\x22\x86\x41\x31\x76\x18\xca\xca\xd0\x79\xdc\x08\x90\xde\x7b\xe0\x50\xba\xda\xf9\x9a\x5c\x15\xaa\x21\xf4\xf2\x8b\x58\x9e\x72\x15\x08\xbc\xee\x41\x1a\x23\x34\xaa\x77\x7c\x15\x49\xbd\x50\x6f\xed\x3a\x4b\xc6\xdc\xf7\xe9\x28\x8e\xe7\xe0\xa9\x4a\x55\x24\xc6\x90\xfb\x02\x0b\x24\xdf\xb2\x13\x16\xac\xe7\xbc\xd0\xeb\x7b\xab\x64\x2a\x8d\x6e\xe0\xe2\xe4\xbd\xd4\x17\x0b\xde\xe8\x89\xad\xc8\x22\x7b\x9a\xe5\xb4\xe6\xae\xe5\x42\x75\xa2\x1c\xb8\x45\x56\x18\x42\x99\xb0\x38\x06\x89\x41\xe4\xb4\x39\x56\x0d\x76\xc4\x50\xad\x1e\x35\xdf\xa4\x2b\xa0\xe7\x0f\xb0\xb3\xd6\xf5\xdb\xdd\x4d\x29\x22\xe2\xe5\x36\x37\x0a\x3d\x97\x7d\xe6\xed\x6d\xb4\x11\x67\x6b\x53\x21\x50\x30\x98\xc9\xa2\x1d\xcc\xf3\x1a\x97\x95\xb4\xd0\x6b\x36\x75\x25\xad\xb4\xbc\x3d\x8f\xb8\xe2\x48\x06\xb5\x81\x4a\xfd\xad\xa8\xcd\x96\xdf\x08\xb5\x05\x7b\x75\xbf\xb2\x5b\x64\xe8\x45\xb5\x4a\x13\x6f\xcf\x59\x96\x5b\x2a\x0b\xd8\x67\x9a\x6e\x05\x74\x01\xeb\x50\xa4\x28\xe7\x08\x3e\x8d\x8a\xa8\xcc\x8b\xd7\x26\xb0\xe0\x1f\xe2\x5e\xfb\x0f\x71\xaf\x77\x4a\x65\x81\x28\x8e\x8f\x86\xf9\xd4\x21\xab\xfc\x6d\x6f\x89\xd3\xa8\x80\x80\x65\xc6\x0b\x5f\x5f\x0a\x9d\x0e\x4c\x32\x06\xa8\x1d\xcb\xd3\xaf\x51\x77\x59\x84\x16\x43\x97\x45\x55\xf7\xfe\x1e\xfe\x05\x1e\xf2\x0d\x76\x1f\x2b\x1c\x27\x27\xce\xd5\x48\xb9\x49\xc9\x02\x79\x6f\x3a\x69\x91\xea\x8d\x36\x6b\xf8\xf7\x24\x28\x04\x2f\x18\x33\xf8\x71\x94\xc5\x29\x47\x95\x67\x48\x32\xb0\x7b\x8f\xab\x0f\xa6\x19\xfc\x0c\x4f\x91\x58\x9c\x24\x36\xb9\xde\xa1\x85\x13\x95\xf6\x27\x79\x4d\x30\x69\x8e\x55\xc4\x09\x62\x2a\x5e\xc9\xba\xe4\x04\xa5\x70\x72\x07\x76\xdd\x93\x02\xe3\x3e\x40\x7e\xa5\x45\x2b\xc3\xae\x02\xc3\x04\xb6\x0d\xe3\xee\xdf\xaa\x2c\x8d\x4a\x60\x5c\x1c\x4d\x95\xb0\x9a\x37\x91\xb4\xb7\x45\xd1\xf9\x71\x80\x95\x28\x3f\x25\xf7\x71\x85\xa2\xde\x68\x40\x51\xaf\xbe\x51\xd5\x43\x68\xc7\x32\x84\xa1\x4d\x7a\xed\xf9\xf4\xda\x9d\x33\x47\xde\xde\x85\x17\xfb\xe5\xe7\x29\xb4\x5b\xd5\x05\x2a\xa6\xd1\xd8\xf6\xf3\xec\x9c\x17\xa5\xab\x3a\x2a\x73\xbd\x49\xc8\x29\xd7\x2e\x03\x7c\x82\xb6\xed\x36\xdc\x0c\xc8\x7b\x3a\x9a\xcb\x0f\xb2\xc2\x84\x7d\x94\xa3\xb9\x82\x86\xe0\x6b\x34\x4d\xd8\x74\x36\x48\x93\xa1\xeb\x82\x69\x2e\x29\xfe\x51\x15\x88\x70\x5d\x23\x81\xeb\xb8\x5a\xa0\xdf\x31\xd3\xe6\xfb\x8f\xf3\x8b\xa0\x68\x1f\x6e\xd9\x91\x12\x74\xfb\xc7\x6b\x27\xa8\x09\xfe\xa1\x01\x0e\xec\xe4\xac\x02\x1e\xf2\x8e\x2b\x85\x8e\xfa\x3a\x07\xa1\xba\xe3\xb8\x0e\x1f\xeb\x28\x4a\x8e\x40\xfc\x80\x8e\xe7\xd4\x41\xd4\xb5\xc2\xc7\x6f\x36\xae\x99\xbe\x7f\xc8\x8b\xbb\x2a\x73\x1b\xac\x82\x52\xd3\x58\xf7\x35\xc9\x8b\x72\x72\xe5\xd3\xd0\x7b\x7b\xb2\x0b\xc0\x3d\xff\xdd\x6c\x13\x26\x75\xce\x8a\xcb\x1c\xf3\xd2\x4b\x14\x26\x76\xdb\x1d\x54\xdc\x83\xf3\x98\xeb\x68\xb3\xd4\xc6\xbe\x4b\x40\xeb\xb6\x2a\xdf\x27\x79\x5e\x5e\x9f\xf6\x62\x6d\x7e\x45\x47\xf7\x4d\x26\x93\x53\x4f\x24\x7b\xda\xf5\xf7\x08\xe3\xe5\x4b\x3e\x59\x35\x57\x77\xe2\x1a\x8c\xe5\xdd\xa4\xe4\x20\x10\x20\x20\x06\xd9\x5f\x65\x8f\x89\xbc\xea\xaa\xeb\x55\xed\x7c\xf0\x7e\x97\x5d\xb1\x9d\x5a\x38\xa5\xd6\x5f\x84\x4c\x3e\x78\xdf\x1d\x5a\xb5\x04\x40\x28\x60\x2c\x05\x7e\x51\xb8\x1a\x25\x0e\x7b\x6c\x51\xdd\x71\x51\x9a\xa3\x79\xc1\xf7\xd4\xaf\x11\x2f\x76\x89\xbc\x45\xfd\x07\x0f\xfe\x1b\xf2\x16\x61\x0c\x2e\x64\x51\x7a\x8b\xd1\xdf\x54\x1f\x76\xad\xa9\x5e\x9a\x76\x52\x70\xab\x32\x8f\xec\x0d\xf6\xd8\xf9\xb5\xa3\x59\x17\x9a\xc2\x2d\xba\x81\x01\xcc\x61\x4f\xbf\xf3\xa4\x28\xa2\xcb\x6e\x22\xe0\x5f\xec\x4f\x7e\x5e\x90\xf0\x45\xc2\x19\x05\x3b\x9a\x84\x0e\x67\x85\x48\xce\x79\x7a\xc9\xf0\xe4\x26\xa7\x24\x39\xfd\xb0\xac\x36\xc9\xb0\x32\xae\xd7\x0e\xd0\x01\x23\x83\x0d\xd7\xc8\x60\x63\x9e\x91\xc1\x86\x36\x32\x70\xdf\x39\x31\x54\x94\xc2\x32\xf4\xd2\x19\x88\x1a\x85\xb1\x50\x46\xea\xba\x89\x12\x8c\xd6\x9b\xd0\xf6\x1c\x67\x14\x55\xc1\xf7\xad\x30\xed\xec\xed\x29\x27\x84\x65\x3d\x88\x9e\xa0\x66\xa3\x2c\x12\x14\x56\xd4\x18\x92\x52\xf0\x74\xc4\xfe\x28\xfe\xc8\x88\xf3\x10\x57\x91\x19\x75\x7f\xde\x41\x57\x8d\x88\xa5\xe5\x1b\x13\x42\x3f\x58\x4f\x5d\xe4\x8b\xe8\xe2\x98\x0e\xfc\x84\x06\x02\x53\xb3\xec\x34\xe8\xcc\x76\xdb\xcc\x72\x28\x39\x8f\xbd\xde\x31\x33\x08\x97\x4f\x1d\x92\xeb\x91\xd8\x7b\x95\xf5\x7c\xd1\x8e\x2f\xb4\x82\xbd\x66\xf9\xbe\x2f\x94\x3b\x15\xb0\xf2\x94\x9a\x8f\x3d\xc1\xd5\x43\xc5\x11\xc8\x35\xc2\xae\x84\x02\x0f\x66\x92\x0b\xb1\xd4\x91\x37\x02\x08\xa9\x7f\x16\x91\x93\x90\xce\xec\x26\xce\xb8\x30\x3b\x80\xcf\x9b\x77\x74\x43\xaa\x9c\xb9\xbf\x49\xd0\xbf\x3a\x7a\x29\xf9\x3d\x88\x9d\x9f\x6e\x8b\x92\x8c\x41\xca\x27\xaf\xb3\x6a\xcb\xbe\xb0\x85\xff\x1f\x22\xa9\x4e\x2f\xd9\x20\x12\x4a\xea\xef\xae\x2c\xcc\x9d\x80\xf1\x2d\xaa\xe4\x77\x9f\x36\x1d\x0a\x1a\x04\x55\x72\x05\xb9\x19\xb9\xe4\xd5\x25\x61\xa6\x52\xa5\x75\xe4\x71\x52\x36\xd4\xce\x60\xb5\x0b\xaf\x01\xb6\xb7\xb0\x53\xb7\x8f\xfa\x76\x68\x03\x34\x1a\xd5\x0a\x15\xeb\x55\x90\x0a\x7b\xb9\xfa\x37\x08\x90\xec\x1d\x62\xf1\xce\x09\x77\xfd\x79\x57\x26\x94\x2e\xaa\x57\xa6\x25\x53\xd7\xd3\x87\x61\xbd\xf3\x3f\x9e\x77\x18\xed\x90\x2c\x33\x2b\x41\xeb\x14\x95\xbe\xc7\xfd\x1d\x96\x68\x6f\x33\x8b\x65\xef\x1e\xfb\xed\xe0\xc7\x57\x4f\xf6\x7f\x62\xbf\x3e\x79\xcd\x9e\xbf\xfc\x9f\x83\xfd\x37\xcf\x0f\x5f\xb2\x7b\x3d\xdb\xb6\xbe\x70\x7c\xec\xdd\x63\xea\xaa\x72\x91\x64\x71\x7e\x81\xef\x07\xd8\x75\x57\xf5\x5c\x6b\x96\xb9\xd1\x52\x0d\xc9\xcb\x92\xaa\xff\xe9\x13\x28\xe6\x30\xaa\x60\x2d\x26\x57\xf8\x3c\x3c\x6f\x68\xcd\xcd\x7e\xab\xd5\xaa\x90\xea\x76\x33\xa1\x55\x06\x6a\xdd\x24\x40\xbe\xb5\xe2\xcd\xab\x3c\xbb\x1c\x25\x69\xda\x2c\xf2\x1c\xb8\xe6\x3b\x3c\xf1\xc5\x2c\x2d\x77\xf1\x87\x96\xb2\x99\x04\xe9\xe2\xaf\xdd\x95\x95\xef\x88\x64\x41\x04\x71\x9a\x46\xe9\xe3\xca\x77\x00\xa5\x04\xed\xdc\x8a\x99\x50\xf4\x1d\x76\xc3\x8c\x24\x6e\x01\x76\x57\xbe\xfb\xce\xac\xd1\x2a\x64\xb3\x61\x41\x1b\x2d\x09\xfc\x5d\xa5\x09\x38\xc8\xd5\x30\xbe\xbb\x5a\xa1\xcd\x99\xd6\x1a\x3f\xfc\x40\x1a\xda\x5d\xf9\xee\x6a\x65\xe5\x3b\x93\x02\x16\x2b\x4b\x31\xca\x9f\xad\x6f\x2c\x69\xcc\x5f\xe6\x14\x21\x3b\x5e\x63\xc1\xfa\x5f\x65\x98\x16\x30\x51\x5e\xac\xc3\xb7\x8a\x22\x5b\x7c\xd7\x66\x0d\x1a\x91\x4a\xdf\x37\x8f\xff\xb8\xe8\x9c\xdc\x87\xa4\x42\xdf\x82\x52\x10\xe7\x48\x9d\x70\xbd\x9e\x7a\xf8\x25\xef\x25\x6c\xc0\x55\x0c\xa5\xbc\x60\xdf\x17\x7c\xe4\x66\xeb\x63\xee\x83\xae\xf2\xfb\xe1\xa3\xa6\xc9\x70\xe6\x1d\x86\x76\x31\x40\xb8\x6a\x64\xbb\xd0\x33\xaa\x69\xc0\xdc\x78\x74\xa6\x69\xaa\x7f\x6a\xd1\xe7\xd0\x4a\x20\x64\xe7\x86\x63\x0d\x85\xbd\x00\x09\x90\x4c\x16\xe2\xe1\x25\x2a\x94\x78\xc1\x47\xbc\xe0\xd9\x50\x07\x48\xf8\x3b\x44\x8e\xff\xbb\xe8\x36\x00\xdf\x36\x41\x4e\x5f\x53\x20\x46\xd3\xa7\x4f\xb6\xc4\x7f\xaf\x35\x96\x06\x57\xe6\x78\x87\x40\xa1\x91\x78\x92\x39\x31\xe0\xf1\x8b\xcd\x03\xe5\x64\x82\x32\xc6\x77\x77\x4d\xdc\xe5\x5d\x93\xc2\xc1\xf7\xbf\x7a\xa5\x98\x72\x24\x9a\xc8\x5b\xaf\x20\x45\x07\xf2\xea\x2b\x92\x8e\xd5\x72\xb0\xf6\xe2\x93\x1b\x99\x85\x9b\xf3\xd2\xa4\x6f\xcf\xb2\x79\x5a\xd9\x76\x58\x5b\x79\xc5\x5e\x71\xf5\x89\xd0\xf0\x2d\x23\xdc\xc7\x2a\x8a\x60\x7d\xe0\x6d\xa3\xb4\xf5\x6a\x58\x8b\x47\xd2\xc1\x7b\xec\xe0\x3d\xfb\x87\x3f\x08\xd3\xc1\x7b\x37\x50\x81\x1d\xaf\x19\xa6\xed\xe2\x3d\xb9\x91\xe2\x2d\x58\x0e\xad\xa5\x87\x48\x5e\xc4\xf0\x3f\xc8\x69\x80\xc1\x07\xa2\x34\x65\x77\xd9\xe0\x52\xc5\x40\x86\x31\xe4\xda\xe8\x86\xdd\xb5\x61\x7c\xd5\x8d\xd8\xb4\x61\xdb\x56\xac\xa3\x3c\x04\x20\x73\xba\xfc\xcb\xe4\x0f\xa3\xbb\x94\xe6\x03\x29\x75\xaa\xde\xf4\x2b\x5f\xa6\x36\x6e\xf7\xce\x43\x59\x51\x1f\xcf\xbe\xc2\xf8\x94\x97\x87\xb8\x20\x54\x40\x02\xb3\x1c\x2a\xcf\x09\xbd\x1e\x53\xa0\x12\x6d\x36\xe0\x3c\x33\x91\x9e\xf0\xc9\x37\x6e\x43\x22\xd0\x0b\x4c\xd6\xc0\x92\x4c\x7e\x86\x70\xa9\x18\xbe\xd8\xd5\x77\xdb\xf8\x10\xe1\x37\x1c\xac\xb6\xe3\x05\x69\xbe\xcf\xfa\x36\xf3\xb2\x9e\xd9\x24\x3b\xfd\x99\x9f\xf3\xd4\x7b\x0e\xeb\xd2\x32\x55\xc5\x03\x77\x7f\x7a\x2a\xa2\x3e\xdb\x71\x01\xee\xb3\xbe\xab\x85\x77\x50\x77\x5e\xe2\xc8\x65\xc9\x36\xe0\x36\xa7\x5f\xeb\xd4\x38\xed\x16\xe5\x1a\x70\xdc\x67\x7d\xf5\x6a\x35\x47\xdf\x5f\x9b\x0c\x74\xa1\xde\xdf\xde\x60\xb4\xfd\xb0\xce\x74\xe9\x11\x53\xbf\xa4\x68\x40\xfb\x04\x69\xb3\x05\xe8\xed\x41\x9f\x2a\x5e\xe1\x32\x89\x48\x13\xeb\xad\xa7\x56\x87\xc9\xb9\xe4\x83\x90\xac\x28\xca\x36\x93\x3c\x45\xb9\x01\x7e\x4c\xab\x77\xef\xb2\x3b\x81\xfa\x95\xe7\x4c\x46\xc6\xb7\xcc\x22\x71\xba\xd3\x1d\xf8\xbb\x10\xcd\x03\x50\xd9\xf1\x6d\x8a\xcb\xae\xf3\x5a\xc9\x48\x78\x7e\xbd\xd2\xf4\xa1\xa7\x9b\x29\x2c\x4b\xbc\x9f\x89\x92\x41\x1c\xbc\x91\xdb\x80\xdc\xae\x1c\x89\x45\xee\x4f\x2a\x44\x1b\x89\xa5\x2c\xff\x6b\xed\xe2\xeb\xba\x99\xc7\x96\x3b\xa7\x35\x92\x43\xdd\x26\x29\xa5\x10\x41\x5b\x17\x34\x36\xa5\xb2\x8d\xb0\x29\x13\x47\xaf\xdd\xac\x89\xb2\x7f\x12\x6d\xdf\xae\x93\xcf\x7b\x1b\x0e\xdb\xdc\x85\x35\x62\x01\x3e\xf9\x58\x45\x84\x8e\xfb\x15\x8c\x7a\x48\x38\xb3\x48\x4e\xc7\x34\x56\xb4\xda\xbb\x51\x45\x9b\x33\x9e\x89\x59\xc1\x15\x54\x5e\x60\xc4\x04\x4b\x2c\x33\x48\x95\xad\x7c\x96\x92\x64\xc6\xa6\x50\x67\x14\xf0\x28\x40\xc7\xea\x30\x96\x31\x32\x24\x21\xdf\xea\xb2\xf6\xba\x07\xc9\x2d\xea\x3b\xbe\xb1\xbc\x97\xc1\x2b\x91\x72\xd5\xfb\x6f\xbf\x13\x91\xf4\x4f\x7e\x96\x19\x7d\x05\x41\xfa\x5d\xd9\x9b\x8a\xb9\x8d\x28\x00\xb4\xae\xba\x42\x6b\xe4\x97\xd1\x44\x85\x00\x51\x16\x81\x00\xa9\xd9\xe1\xc7\x3c\x4f\x79\x94\x5d\xb1\x51\x1a\x9d\x42\x90\xa3\x64\x18\x41\x8c\x26\x33\xd2\x8b\x48\x90\xec\x4f\xa9\x14\x9c\xb2\xbc\x74\xaf\x3b\xda\x3a\x14\x4d\xc9\xd4\xd6\xab\x7b\x37\x37\xa0\xa3\xb3\x64\x0a\xd6\xf5\x97\x2a\x0d\xb1\x36\x0e\x22\xa0\x4e\x94\x04\x55\x0d\xfd\x7f\x58\x54\x14\xd1\x25\xcb\x47\x6a\x34\x19\x44\x79\x7e\xf7\x51\x79\x62\x8a\x1d\x76\xdc\x18\xe5\xb9\x14\x02\x07\x51\xd1\x38\xb9\x7a\xa7\x9a\x77\x5f\x1a\x6c\x5f\xcb\x3c\x33\x18\xe8\xfa\x37\x06\x3c\xe7\x8e\x78\x89\x47\xe1\x5c\x52\xa8\xc7\x07\x2f\xfc\x9d\xaa\x1c\x0a\x6f\xe6\x2e\x69\x6d\x9c\x70\xe5\x51\x46\x4c\xe5\x56\xa6\x2f\xb5\x71\x2d\x81\x24\x7d\x98\x24\x8e\xa1\x8d\x1d\x9f\xb9\xfe\xb0\x46\x8b\xfd\x93\x78\x19\x19\xb9\x74\xce\xb8\xd4\x45\x44\xd6\x6d\x39\x77\x30\x73\x61\x08\x0a\x28\x2b\x6e\xfe\x6e\x3e\x92\xdb\x6c\xc4\xd2\x7c\xa8\xb8\xba\xbb\xe2\xe3\x69\xe4\x86\xef\x9d\xe8\xf4\xf6\x29\x4f\x89\xf0\xfa\x66\x4b\x50\x44\x43\x97\xbe\xb1\x11\x57\x27\xa7\xf7\xa4\xb7\xd4\xc5\xf6\xb5\x77\x8b\x55\x81\xac\x95\x40\xda\xf5\x5f\xee\xdc\xeb\x6a\x75\x7a\xc3\x8f\x88\xd7\xc2\x68\xff\x72\x98\x26\x43\x86\x73\x9d\x28\xf7\x9a\x92\x0f\xcb\xcf\x40\x47\x91\x10\x48\xc7\xc5\xb1\x3e\xb2\x4e\xe0\x8e\xa5\x8d\x15\x1d\x08\xf5\xb0\x78\xa6\x4d\xfe\xc2\x1c\x1b\xe0\x81\x79\x9d\x98\xa9\xa3\x16\xa1\x26\x3f\xa5\xa7\xe1\x51\x4c\x6e\xd3\xa3\x49\x4e\x8a\xcd\xd1\x0e\x6d\x19\x6d\x8f\x01\xba\x5d\x8d\x8f\x3a\x82\x96\x7f\xd4\x70\xd2\xcc\xe1\x5b\x86\x5e\xac\x21\xa1\x3f\xb4\x04\xbd\x5a\x26\x2c\xb3\x8a\xe8\xaa\x0b\x1c\xba\x4c\x0b\x7e\x8e\x61\x8f\x47\x49\x96\x94\x9c\xa5\x79\x3e\xed\x56\xec\xec\x4c\xab\xbb\x35\x62\xc5\x0d\xa5\x8a\x6f\x2c\x14\x5c\x30\x79\xb8\x71\xdc\x9f\x93\xc1\xdc\x9a\x4c\x28\x41\x5a\xbb\x59\xaa\x6c\x4b\xc0\x64\x78\x26\xff\x4d\x09\xca\xdd\xd0\x71\x2d\xca\xc2\x39\x9b\xd5\x77\xff\xa4\xbd\x6e\x5e\xf4\xea\x52\x91\x63\x82\x30\xd1\xb1\x65\x0b\x3c\x2c\xca\x9c\xc5\x91\x18\xdb\xa3\xa4\x4e\xf6\x00\x2e\x70\xb0\x55\x25\x2e\xb6\x43\xec\x12\x70\x21\x37\x48\x75\x7b\x3d\xc7\xa0\xd0\x7b\xda\xa4\x63\xfe\xa5\xd3\x54\x00\x91\xb7\x36\x71\xfb\x89\x63\x84\x7c\x62\x36\x1f\x74\x5d\x93\x6c\x3d\x8a\xd2\x74\x10\x0d\xcf\x1c\xf3\xcb\x90\x39\x82\x05\x6c\xd9\xde\xed\x57\xf3\x9c\x6d\xbe\x74\x27\xd1\xb4\x49\xc6\xac\x6c\x36\xc2\x75\x2b\xb4\x21\xfd\xf9\x62\xbb\x69\x81\xce\xe7\x93\x34\xcd\x2f\xe6\xcd\xe6\xe0\x52\x57\x94\xdc\x08\x2a\x6e\xc8\x44\xa7\x66\x99\x17\xc9\x9f\xd5\x19\x76\xb6\x3b\x3a\x95\x7a\x25\x2c\xb3\xbd\x2d\xa0\x6c\xcb\x89\x5b\xae\x1e\x97\xf1\xaa\x9b\x26\x67\x9c\xfd\x30\xca\xb3\xb2\x33\x8a\x86\xbc\xad\x52\x1f\x0d\xa3\x8c\x8d\xa3\x73\xce\x26\xb3\xb4\x4c\xa6\xa9\xda\xa2\x40\x79\x1c\x65\x28\x1a\xfa\xfa\xc7\x5a\xab\x91\x5a\x51\x4e\xfb\x22\xa3\x94\x16\x9a\x23\x5f\x80\xf3\x62\xa4\x92\xcd\xda\x95\xdc\xaa\x0b\xe1\x76\x6e\x66\xdf\x64\xd8\xab\xbf\x6c\x2b\xe7\xda\x56\x92\xd0\x2e\x5f\xd9\x02\x12\x2a\x93\xee\xeb\x4d\x05\x1e\x06\xc1\xe7\xf5\x45\xe1\xbe\x92\xb5\xa5\x3e\xd7\xd2\x3c\xe3\x98\x31\x18\x0d\x21\x31\xf5\x4f\x1c\xcb\x4b\x45\x70\x7b\x3c\xe7\x85\x48\xf2\xcc\x33\x65\x8c\xe2\xd8\xc4\xf0\x89\x7f\x45\x10\x6b\xb0\xe9\x1d\xff\x9d\xe3\xa8\xf3\x27\x9e\xff\x8e\x2a\x95\x3e\x37\x55\xce\x6a\xfa\xde\x74\xdc\x3f\xe9\x96\xf9\x2f\xd3\xa9\x3d\xaa\xd5\x03\x96\xb2\x99\x3c\x1c\xbc\x37\xd6\x59\xfe\x5b\xb4\xc1\x8a\x29\x48\xfd\xa6\x9c\xab\x3f\x77\xbd\xb2\xb9\xc7\x25\xad\x74\xe5\x18\x02\x1d\x0e\xde\x9b\x9c\x3a\x33\xc5\x30\x41\x32\xb9\x6c\x42\x2d\x1e\x03\x26\xa5\x2c\xe6\x7c\xaa\x13\xe7\x47\x42\x50\x75\x83\x77\x1a\x19\x55\x06\x66\x9b\x36\x53\x48\x61\xd4\x5b\xfc\x27\x38\x60\x3e\xbd\x84\x34\x4d\x9f\xb0\x62\xeb\x8a\x4c\xba\xce\x8b\x5c\xd1\xa3\xe0\x8d\xc4\x91\x66\xe6\xb7\x89\x6f\x34\x12\x6d\xdd\x28\x4d\xc9\x05\xdb\x18\xa7\x49\xfb\xbd\x17\x1a\x10\xf7\x31\x9b\xbf\xa6\xb5\x8a\x7a\xe1\xcb\x46\xbf\xaa\x50\x1a\x6e\xb1\x72\xbd\x56\x9b\x8d\x0a\xb7\xb1\xa4\xd5\x30\x76\xbb\x4b\x0c\x68\x1d\x13\xe2\xfa\x83\x1b\x2b\xb6\x74\xe7\x0d\x38\x72\x1b\xd6\xa4\x6e\x81\x81\xb1\x5f\xdd\x31\x4f\x51\x27\xa1\xb8\x48\x20\x1c\xbf\x84\x31\x52\x5f\x24\xb8\xc1\x6e\x27\x68\x66\x69\xc4\x26\xc7\xd2\x92\x88\x01\x19\x2f\x5e\x29\x89\x52\x51\xdd\xb5\x94\x4d\x67\xf2\x5c\x57\x50\x72\x41\xe8\x29\x34\x1f\xdb\x15\xa8\xaa\xc3\x31\xcd\x89\x3b\x28\x78\x74\xe6\xcb\x08\x34\x92\xfb\x3c\x94\xb0\xab\xb7\x41\x8c\x60\xd4\xf7\x59\xa3\x23\x2f\xc8\x6f\x2b\xf8\xbd\x9d\x87\xa0\xc6\x83\x20\x87\xd4\xc5\xa9\xdc\xa9\xc8\x4f\xf6\x81\x18\x5a\x0f\x3f\x0b\x1b\x02\xfa\x68\x1a\x9a\x5d\x07\x15\x95\x64\x8d\x4e\x34\xf2\xb7\x3c\x7b\xd7\x3c\x9d\x7e\x60\x8d\xb0\xfb\xe6\xd5\x52\xd9\x9c\x7e\xfa\x84\x3b\x97\xfd\x69\x72\x26\x05\xf1\xd0\x3a\x59\xbf\x24\x28\x8e\xff\x8a\xeb\x92\xc8\xe4\x71\x0c\xdd\x49\x19\x1b\x82\x8a\x24\x43\xa5\xeb\xf4\x0e\x1b\xb2\x5f\x7e\xd1\x70\x7c\x7a\x47\x31\x3b\xf6\xa1\xed\x22\x78\xde\xd1\x57\xb2\x2f\xf1\x7a\xb9\xd4\xf3\xa2\x1b\x12\xc8\xe5\x2a\xe7\xdd\xa4\x32\xae\xd6\xe2\xa7\x10\xea\xa0\x37\x8e\xb2\x53\xcc\xdf\xda\x54\x3b\xf5\x94\x18\x6f\xa8\xea\xc1\x1d\x3d\xdc\xf3\x75\x24\xfa\xb6\x8b\xc0\x8e\xfb\x33\x2c\xef\x7f\x63\xc1\xf5\x14\xd7\xeb\xd0\x03\x31\x7b\x2f\x44\x47\xb1\x76\x07\xd6\x01\x04\x15\xd3\x47\x30\x2c\x44\x7d\xc2\x03\xa3\xe0\xc6\x0e\x4b\x23\x28\x2b\xcb\x4e\x1b\x51\x96\x4c\x20\x93\x7e\x27\xe6\xa9\xdc\xa9\x58\x63\x82\x51\x8c\x69\xd1\xac\x80\x3f\x68\xa9\x3c\x15\x4e\x21\x9b\x53\x47\x6b\x45\x65\xf1\xf4\x43\x6d\x71\xe7\xc3\x22\x80\xcb\x1a\x00\x91\xfc\xc9\x49\xd1\x00\x1e\x08\x29\x28\x7c\xe8\x0c\xf2\xb2\xcc\x27\x8d\xba\x82\x4e\xca\x47\x65\xa7\x88\xe2\x64\x26\xea\x81\xe0\x09\x72\x21\xd4\x45\x12\x97\xe3\x40\xb1\xec\xa2\xe6\x73\x6d\x9d\xda\xbe\x00\x95\xba\xef\xb5\xcd\x89\x69\x34\x4c\xb2\xd3\x40\x49\x99\x4f\xc3\x5f\x17\x50\x46\x42\x2c\x20\x8b\x04\xa9\x43\xa8\xee\x3b\x3c\x06\xd7\x96\x62\x26\xb0\xda\x62\x9e\xc5\xb5\x65\xe3\xbc\x48\xfe\xcc\xb3\x32\x4a\xe7\x10\x43\x94\x51\x51\x4f\x44\x50\xec\x0c\x83\x0d\x20\x07\x38\x55\x3e\x74\xc4\x38\x8a\xf3\x0b\xda\xd0\x30\x4f\x67\x93\xac\x73\x1a\x4d\x03\x5f\xe5\x6e\x5e\xf3\xb9\x8a\x92\x2a\xac\x7c\x1f\xa5\xfc\x43\x67\x10\x89\xc4\x99\x10\x50\xef\x78\x0b\xc6\x7e\x94\xab\xbc\x8c\x48\xd1\x98\xcb\x89\xb5\xbf\x25\x27\x90\x8a\x29\x2f\xcb\x30\x4f\xa5\xf9\x29\x10\x08\x1b\x08\x95\xf8\x08\x4f\xa2\xe2\x34\xc9\x08\x20\x7e\x40\x3e\x68\x54\xbf\x23\x07\x84\x0a\x2a\xeb\x5c\x15\xf8\xab\x4f\x7d\xae\xac\x23\xf5\xdd\x5b\x0f\x93\xe8\x43\x60\x34\xf2\x6b\x85\xf4\xaa\x01\x9e\xc5\x81\xaf\xc0\x59\xee\x77\x71\x56\xb3\x0b\xba\x45\x97\x95\x22\x7f\x22\x25\x36\xf5\x94\xa7\xa5\x55\x9c\x93\x2c\x54\x25\x09\x70\x96\xfc\x38\xa7\x17\x52\x5a\x99\xe3\x5c\x0e\x84\x02\xc3\x87\x4e\x3e\x1a\x09\x4e\x5b\xc9\x67\x65\x9a\x64\x9c\x40\xaa\x2f\x55\x50\x53\xe2\x77\x36\x8d\xe2\x38\xc9\x4e\x09\xa4\xfa\x12\xe0\x10\x5d\xe2\xb3\x88\xfe\x5e\xe1\x11\x5d\xe0\x31\x89\xfe\x5c\x61\x5a\xd3\x75\x85\x6b\x75\x89\xc7\x2d\xfa\x73\x85\x5d\xa6\xbc\x10\x53\x3e\x2c\x93\x73\xde\xc1\xf7\x33\xe4\x99\xbf\xd7\x16\x5f\xda\x62\x52\x6a\x9b\x2c\xdc\x35\xde\x10\xe3\x68\xca\x3b\xc8\xae\xa4\x67\xc9\x6c\x04\xaa\xe4\x1f\xca\x4e\x92\xc5\x3c\x73\xd0\x83\xcf\xa2\x2c\xf2\x33\x5e\xf3\xb9\x32\x51\x65\x3e\xa5\x90\x45\x94\x89\x51\x5e\x4c\x14\xfa\x64\x6c\x7e\x91\x33\xf0\x4a\xe1\xe5\xbc\xc2\x3f\xfd\xc2\x24\x2c\xe5\xd0\xb2\x80\x98\x63\x0e\x82\x28\x4d\x4e\x29\xb1\x60\x8c\x64\x54\x17\x79\x11\x07\xf6\xc9\x5e\x8f\xbd\xcc\x4b\x9b\x9e\x6b\x6a\xc2\xf9\x75\xb1\xf4\x17\xc1\x21\x25\x4c\x04\x26\x82\x2a\x8d\x3a\x18\xcd\x4a\x79\x0f\x63\x4f\x33\x50\xf3\x9d\x22\x76\x5d\xf7\xcc\xf1\xa4\x2a\xfb\xfd\xb2\xe6\xfb\x20\x9d\x15\x35\x45\x62\x5a\xf0\x28\xae\x1c\x1c\xb0\xf8\xaa\xfb\x00\xce\x78\x00\x09\x5a\x70\x59\x57\x40\xd0\x08\x05\x1f\xfd\x26\xa3\x14\xff\xa5\x7c\xf7\x94\xef\xae\x99\x18\x46\x50\xff\x4f\xe8\xdd\x21\x22\x69\x6d\x46\x81\xb5\xaf\x62\x5d\x66\x3b\xf0\xd8\x2c\x1f\xbc\x57\xfe\x17\x5a\x1d\x05\x37\x7a\x47\xdd\x5c\x13\xba\xd4\x56\xfd\xa8\x59\x52\x5d\x91\x6d\x58\x55\xe4\x52\x30\xc7\x35\x81\x54\xf5\x37\x1d\x21\x15\x7f\xb3\x2b\x88\x97\x89\x2e\x6d\x46\x33\x6d\x54\xa0\xd6\x47\x0a\xa7\xd9\x28\x5e\x5e\x44\x53\xa5\x68\x61\x83\x4b\x76\x9a\x9c\xf3\x0c\xf6\x31\xff\x79\x13\x94\x99\x57\xd6\x96\x4c\x1b\xa2\x55\x55\xce\xc6\x2c\x24\xa4\x73\xae\x00\x19\xfb\x10\xef\xf5\x9e\x4d\xa2\xe9\x94\xc7\xb6\x1f\xa2\x03\x9a\x44\x53\xb8\xea\x8b\x1f\x2f\x25\x35\xa9\x06\x82\x2a\x57\xa8\x8a\x18\x5e\x98\xed\x5a\x4b\x4a\x3e\xf1\x94\x15\x78\xa3\x7e\xa3\x43\xac\x49\x08\xa7\x49\xd0\x52\x04\xed\x02\x90\x26\x65\x6e\x23\x07\x7e\x09\xca\x19\x0b\x82\x31\x9f\xf0\x36\x68\x82\xc8\x23\x35\xb4\x2e\x50\x23\x24\x1b\x13\xcb\x19\x3e\xfa\x44\xb7\xc6\x05\xc6\xe6\x91\x3e\xf4\xc8\x4e\x0c\x85\x1c\xaa\x8b\x21\xa2\xe5\xc6\xd3\xc7\xaf\x5a\x1f\xb5\x07\xb6\xbd\xae\xea\xbe\xfb\x3e\x4f\xb2\x66\xa3\xdd\x30\xaa\x75\xaa\x32\x85\xed\x6c\xad\xe5\xe6\xd8\xaa\x51\xb1\x1f\xaf\x9d\xb4\x0c\x64\x00\xd3\xe3\xb5\x13\x17\x59\xd3\xa3\xa3\xe2\x97\xcd\x54\x83\x83\x54\x95\xf4\xd6\x9e\x8c\xf4\xee\x30\xd4\x62\x2e\xf5\xde\x8d\x28\x41\x58\x23\xc8\x6a\xea\x9d\xae\x96\xd7\xcc\x4c\x23\xdc\xcd\xb9\xad\xd6\x56\xd6\x18\xc0\x26\x82\xe9\x87\x04\x68\xe9\x33\xf8\xca\x5b\x7a\x15\x42\xb5\x59\x22\x9e\xa9\x3e\xc8\x4b\x10\xc6\x2c\xc0\xe4\x1a\x87\x83\xf7\x56\x51\xad\xbe\x0f\x67\xa2\xcc\x27\xaf\x68\x69\xcb\xe1\xa5\x15\xcf\xd7\xeb\xf8\x44\x9b\x56\x42\xd0\x4b\xd9\x0b\xc8\x76\x82\x45\xd9\x25\xcb\x72\xb8\xfe\x65\x71\x54\xd0\xf7\x34\x1b\x3d\x21\xdc\xa3\x31\xb6\x44\x6d\xbb\x05\x11\x72\xc0\x97\xa9\x51\xa0\xe2\x48\xeb\x5b\x72\xa8\x40\xad\x59\x5f\x45\x42\x40\x90\xe5\x19\x98\xe1\xa7\x29\x73\xd0\xd4\xd6\xc2\xea\x14\x3a\xe3\x97\x42\xbd\x2a\x99\x78\x65\x9e\x3d\xef\x20\x12\x5c\xbf\xb2\x84\x68\xec\xc6\xed\x40\xfe\xd7\x75\x4e\xfc\x40\x1a\xa1\xa5\x6a\x81\xdd\x27\x25\x9c\x89\xee\x74\x26\xc6\xcd\xd0\x12\x36\xf5\xda\x06\xc7\x36\xc5\x10\xfa\x78\x9e\x1d\x0e\xde\xb7\xe8\xf3\x12\x9e\x8a\xb4\x71\x1f\x8d\x5d\xc7\xe5\xc1\xc6\xbc\x20\xce\x03\xbd\x1e\x3c\x52\x68\xa1\x08\xe7\x13\x4c\xd4\x50\x40\xc1\x23\x9a\xe6\xb1\x0f\x91\xce\xf6\xc9\xee\xe8\xfd\xf0\xe3\x4a\x68\xfc\xf3\x6b\xb7\x42\xe1\x3f\x56\x3c\x67\xb8\xf9\x7b\x09\xb2\x18\xb9\xb4\x68\x39\x00\x76\x17\x30\x12\xc2\x5b\x2c\x5a\x40\x95\x39\x9a\xec\xc6\x49\xc1\x87\x65\x7a\xf9\x19\x3b\xcf\xd2\x06\xf8\x7a\x75\xb5\x59\x39\x8e\x4a\xed\x86\x02\xa1\x3e\x93\x28\xad\x62\x7e\xfd\x8d\x49\xa3\x82\xd3\x28\xaf\x64\xf9\x2c\x40\x12\x85\xc0\x45\x24\x8c\x23\x60\x14\xc7\x78\xa9\x0b\x98\x7a\x2d\x58\xdb\xa4\xbc\xba\xa5\x55\x9e\x76\x08\xb4\xe3\x14\x5b\xe4\xd3\x97\x18\x68\x97\x40\x68\xa3\x3d\x6d\xc6\xfa\x7c\x54\x79\xfa\x67\x71\xce\x45\xd6\x50\xf7\x55\x33\x1e\x15\x40\x94\x75\xe4\xc8\x20\x36\x61\x9e\x71\xf3\x34\x45\xdf\xca\xd5\x06\x7b\xc7\x7b\x31\xbf\x7b\x97\x35\xed\x60\xe4\xfe\x0b\x41\x4b\x81\x73\x9b\x1a\xdb\x56\xcb\x35\xfc\x97\xc2\x5d\x16\xdb\x47\x48\x60\xb8\xa7\x60\x78\x9d\x17\x4d\x5f\xca\xfe\x78\xd5\x36\xe3\x6e\x53\x64\x54\x80\xcd\xd6\xb1\x2e\xb5\xee\xb4\x6a\xbd\xa2\xb5\x84\x66\x5a\x3d\x5a\xc7\x93\xcd\xce\x83\x8d\x26\x6a\x6d\x0a\x6d\xd3\x6c\xcf\x45\x1b\x8d\x14\x6d\x9d\x39\x90\x2b\x76\xa9\xf6\x7a\x3a\xab\xbc\x3d\x14\x1d\xe3\x6b\xd0\x15\xc4\xf9\x0c\x52\xd0\x1a\x09\x8f\x5a\x19\x13\x02\xf8\x6f\x67\xe7\xfe\xc3\x2a\xd2\x54\x8e\x34\x52\xb4\xc8\x38\x8f\x85\x72\xa3\xb7\x16\x96\x0b\xed\x55\xbd\x82\xcf\x93\x07\x74\x6d\xd3\xef\x91\x6a\x9f\xac\x22\x97\x15\x9c\x98\x34\x0b\xd7\x8c\xf3\x1c\x4a\x73\xaa\x38\x96\xad\x0b\x2c\x35\x88\x89\x25\xca\x01\x6a\x32\x94\x8c\x6d\xe6\xa8\x40\xbb\x1c\xd4\xda\xe8\x26\xef\xd4\x8a\xa6\xee\xb1\xb8\xc8\x0c\x63\x19\x7b\x4c\x6b\x3f\x3b\xc7\x32\xd3\x3c\x0b\x13\x96\x36\x76\x9a\x01\x5a\x57\xc0\x34\xf1\xe5\x2d\xb3\x45\x83\x9b\x5d\x91\xbf\xfd\x63\x93\x1c\x9c\xfe\xab\xf4\x9c\x5b\x84\x7f\x94\xb7\x1c\xaf\xf4\x27\x40\x75\x70\x0f\x75\xb5\x6d\xa8\x52\xe3\x93\x69\x49\x1c\xa4\xc8\x94\x08\x1a\xc7\xab\xce\x09\xd0\x1c\xa5\xd6\x3b\xb2\x79\x03\x4b\xa1\xcf\xb9\x44\xb4\xea\x02\xa2\x85\x59\xc4\x9b\xae\x45\xd3\x59\x33\x8f\xb5\x02\x8f\x3b\x6b\xd7\x92\xd1\x77\x57\x6e\x30\x69\xcb\x4f\xd9\x95\x39\xee\x5e\x44\x97\x03\xce\x22\x70\xdb\x98\x95\x5a\x6d\x40\xec\xcd\xd0\xdc\x19\x7b\xd3\x57\x10\xc6\xec\x54\x3b\x83\x95\x24\x6f\xd4\x75\x4b\x77\x5b\xe1\xc7\xfb\x7a\x12\xc7\x82\x4d\x73\x21\x92\x41\x92\x26\xb8\xa1\x5f\x14\x49\xc9\x19\x2a\x7b\x79\x7c\x63\x67\x19\x54\xc4\xdd\xc4\x57\x46\x1e\xd1\xcb\x9b\x9c\x2c\x65\x8a\x0e\x57\x10\x34\x44\xcf\x33\xce\x06\x97\xf0\x0f\xe6\xbf\x18\xe5\xc5\x24\x2a\x41\x88\xfc\x02\x96\xe6\x01\x96\x77\xf6\xad\x6b\x5b\x9c\xd7\x1e\x3f\xb7\x62\x79\xbe\xb5\xf6\x8d\x65\xde\xd2\x8c\xab\x94\x22\xbe\x5e\x89\xac\x57\xb8\xeb\x18\x5d\x57\xc1\x4f\x67\xa9\xce\x13\xd7\x55\x6e\x15\x14\x3c\x4d\xc0\x11\x7f\xc0\xd3\xfc\x82\x5d\x24\x69\x2a\xe5\x0d\xf3\x92\xa3\xde\x45\xb4\xc7\x8f\x75\xc1\x1c\x5c\xa2\x57\xa6\xcd\x98\x6f\x4e\x03\x88\xe6\x87\xaa\x69\xfa\xed\x63\xd8\xa0\x04\x94\xa4\xf5\xc6\x2c\xba\x58\xdb\x9b\x58\x70\xcf\xde\xc4\x2f\x50\x8f\x8c\xfe\x67\x7c\x4a\xf4\xbf\xea\x97\xc7\xca\x77\x6d\x6b\x41\x0a\x88\xa1\x81\xfe\x3a\x4a\xf9\x07\xfb\x4b\xbf\xb1\xeb\xdf\xe6\x89\x54\x7f\x30\xef\xae\xa6\xd5\xc0\x73\x9c\x2e\x33\x45\xde\xa7\x04\x1f\x79\x91\x41\xac\x11\x72\x1d\x83\x58\xa1\xc8\xe1\x08\xc1\x92\x4c\x24\x31\x67\xf8\xb0\xc0\x87\x25\x6c\x79\xec\x59\x5e\x30\xde\x3d\xed\xee\xb0\xd5\x8f\x7a\x36\x76\xd8\xf1\x5a\x9b\xad\x9d\x5c\xad\xb2\xbd\x7f\xb2\xd5\xc0\x7c\xed\xb0\x35\xb6\xb6\xbb\x1a\xe0\x09\xb8\xec\x87\x18\x43\x17\x48\xee\xb0\xcd\xa0\xe6\xbc\xd7\x63\x81\x4e\xcc\x23\x29\xa8\xd3\x5d\x18\x59\x50\x4b\x8d\x69\x54\x80\x29\xb6\xdc\xee\x06\xb3\x24\x85\x3b\xf3\x30\x2f\xe4\x95\x43\x53\x03\x15\x05\xe8\xd7\x46\xe8\x61\x47\x53\x1d\x06\xc1\x5f\x4f\x34\xee\x82\xf0\xe2\xba\x86\xb1\x55\xd4\xeb\xaf\xfa\xa5\xcd\x57\xd4\x4f\xb4\xf7\x58\x83\x04\x36\x84\x7f\x6e\xd6\x8a\xa5\x8a\x6e\x29\x2a\xcb\x68\x38\x9e\x40\x26\x15\x88\xde\xa0\xdc\xce\xd2\xbc\xa0\x1f\x92\x49\x74\xca\xe9\x07\x3b\x2d\xf6\x5b\xc1\xa7\x3c\x52\xed\x98\x1e\xd5\x12\xc5\xde\xd4\xdb\xac\xad\x22\x70\xef\x0d\xf6\xac\x9b\x70\x57\xe9\x2d\x34\xa4\x17\xf6\x2d\x34\x65\x76\x9a\x5b\x68\x4b\x6d\x4e\x37\x68\xc9\xec\x21\x37\xc1\x46\xee\xfd\x1d\x94\x29\x0c\xbb\x5d\x4e\x17\x4e\x3e\xe1\x10\xdd\x14\xdd\x92\xb0\x21\x7d\x57\xa6\x15\xf5\xe3\x3e\xfd\xd6\x28\x93\x49\x92\x9d\x76\x4c\xf8\x49\x5a\x88\x65\xcf\x54\x91\x2a\x81\xf7\x7c\xce\x63\x15\x59\x0e\x2e\x79\xb8\x94\x27\x49\x1a\xa9\x78\xe4\xee\x13\x3e\x18\xb3\x76\x86\x91\xe0\xfa\x7e\x1e\x5d\xba\x03\x30\x86\x96\x1a\xff\x2c\x9a\xf0\x2f\x8a\xbb\xb9\x9f\x4a\x61\xf8\xfa\x88\x2b\x0c\xf0\x5d\x3b\xc9\xb3\xce\x30\x9f\x81\x91\x08\x99\x27\x5d\xb6\x2f\x8b\x6e\x09\x03\xd0\xd0\xf8\x74\x18\x25\x69\xda\x99\xe4\x31\x77\xfa\x97\x5f\x5f\xe4\x31\xbf\x9d\x9e\x1b\xd3\x34\xba\xec\x88\x32\x2a\xdd\x5e\xe4\xe7\x23\xf9\x15\x3f\xde\xa8\x97\xab\xea\x19\x8f\xdc\xf0\xc1\x6c\xb3\x97\x76\xff\x4d\x67\x85\xf9\x81\x66\x1b\xe6\x67\x75\x57\xcd\x04\xf7\xf6\x4b\x6a\x8a\xb1\x44\x47\xb5\x4b\x79\x99\xe3\x3f\xf4\x28\x92\x90\xd3\x1f\xc5\x53\xf7\xe4\x4f\xb2\x61\x3a\x8b\xb9\x2f\x0c\x59\x2d\x98\xaa\xac\xca\x1b\xa4\x15\x3c\x2f\x9d\xc7\x11\x72\x6a\xfa\xdf\x3f\x56\x0e\x0f\xec\x6a\xc7\xef\xba\xfe\x6c\x53\x66\x53\xbe\x78\xe9\xec\x57\xb4\x14\x3e\x99\xf6\x46\xb9\x5c\x1e\x1f\xe9\xc6\xa9\xcc\x35\x61\x6f\x6c\x6b\x35\x55\x12\x49\x38\x2c\x52\x3f\x55\xe1\x85\x36\xe1\x84\x32\xfc\xd5\xd0\x3b\x71\xc1\xcb\xe1\xd8\x36\x09\x3f\x75\x21\xe2\x6d\x0d\x46\xd5\xca\x89\x26\x49\x7a\xa9\x0b\xf0\x97\x2a\x92\xbb\xfe\xbf\x75\x6f\xd4\x2a\xe8\xc6\xeb\xcb\x33\x31\xa2\x3f\x0d\xa1\x40\xd0\x45\x42\x9d\x16\xf9\xc5\x8e\xb2\x80\x95\x7f\x2b\xfc\xc0\x18\x76\xc7\xb1\x8c\x6d\xfb\x3b\x07\x16\x9a\x0f\x9a\x86\x45\x34\xd5\x65\xf2\x6f\x4d\x8b\xd4\xf6\x23\xff\xd6\x94\x1b\x17\x49\x76\xa6\x0b\xf0\x97\xc1\x13\x0c\xc5\xcc\x8c\xf2\x74\xb4\xc3\x1a\xf0\xad\x23\x7f\x34\xcc\xf6\x38\x11\xa6\x00\x7e\x35\xf4\x02\xcb\x4a\x10\x93\x54\x99\xfa\xdd\xa0\xab\x8d\xde\x15\xbf\xb1\x0c\x30\x75\x19\x4f\x7e\xe5\x59\x9c\x17\x2a\x4d\x4e\x61\x52\x19\xeb\x82\x5a\xdb\x9d\x75\x6d\xe3\x73\x6e\xe0\x5c\xfb\x9d\xdf\x92\x34\x1e\x46\x45\xdc\xb4\x8d\xcd\x33\xf7\x31\xe0\xca\xee\x06\x42\x31\x86\x8c\x7d\x5c\x63\x20\x62\x37\xe3\xbb\x90\x9a\x26\xec\x63\x5d\x8d\x4f\xe9\xf2\xc1\x8d\xb5\xdd\x4f\xab\x55\xe7\x83\x0a\x21\x8d\x55\x99\x43\x6b\x40\xd6\xf5\x32\xc5\x1c\xb9\xc4\x8b\x4a\xd1\x52\xc5\xe8\x84\x4b\xb6\x13\xde\x80\x5d\x8c\x79\x06\x8f\x00\x0b\x62\x18\xcc\xd5\x42\xb9\x53\x5e\xab\x8d\x5a\x90\xa4\x09\x34\x6d\x67\xfc\x72\x54\x44\x13\x4e\x95\x9b\x3a\xaa\x0d\xc3\x9c\x5b\xf7\xd5\xa8\xba\x38\xaa\xee\x50\x08\x76\xdf\x00\xd9\x08\x45\x5e\x60\xfe\xff\x98\x1b\xd6\xfc\x97\x07\xe5\x59\x06\x2e\x4b\xaf\x30\x4b\x3c\x89\x25\xa4\xe2\x28\x62\x84\x2a\x0c\x57\xcb\xf6\xf4\xf8\x9d\xcf\xb0\x7c\x9d\xd0\x91\xa0\xc9\x74\x6a\xde\xbd\xeb\x35\xa5\x13\xdc\xb5\x5c\x04\x4c\xdc\x30\x17\x3d\xfd\x3c\x57\x8f\x9f\xf1\x22\xf4\x10\x44\xdf\x30\xa7\x6f\x6d\x23\x17\xc4\x16\xdb\xa1\xe8\xfe\x6a\xfc\x17\x95\x69\x9d\x8b\x92\x83\x31\x84\xba\xb2\xe3\xf9\xf4\x89\x02\xfb\x4f\x2f\x16\x70\xde\x6b\x80\xd6\x34\xba\xe4\xfb\xf4\x89\x99\x8c\x10\x2e\xa2\x9f\x3e\xd9\x14\xfc\xac\x26\x46\xed\x0d\xfd\xe9\xc2\x34\x9e\x7a\xa4\xad\x51\x51\x06\xd2\x8e\xb5\x6f\xdd\xd1\x6e\x6b\xed\x36\x53\x3c\xdc\x62\xc8\xc3\x0a\xbf\x56\x0a\x74\xeb\x8e\x16\x06\xf6\x50\xe2\x2b\x6a\x6d\x52\x55\x49\xd8\xf2\xf5\x61\xcb\x05\x9c\x67\xf3\x8a\x10\xa6\x42\x08\x9f\xf0\xe9\xb9\x51\x5f\x67\x5e\x7f\x15\xe0\x6a\x33\x9a\x46\xe1\x7e\xb7\x6a\x2a\x2c\xd5\xe9\xaf\x8a\x4d\xbf\x46\x98\x8b\x5a\xc7\x48\x24\xf9\x8e\x99\x1d\x02\x01\xae\x12\x3e\x85\x76\x42\x24\xae\xab\xa4\x96\x8a\x4f\x1c\x02\xbe\x72\xb5\x6b\xf2\x4f\xdf\x03\x47\xcf\x5f\x9d\x33\x1b\xe3\xcf\x81\xc1\x65\x46\x6c\x03\x46\x3c\x2a\x67\x05\x67\x25\x06\x58\xc6\x47\x67\xdd\xca\x0f\xc3\x7c\x7a\x89\x11\x56\x0f\x53\x7e\xca\x8e\xd2\x7c\x90\xc7\xe2\x2c\x4f\xd8\xfa\x5a\x7f\x4b\x43\x5d\xf0\x81\x48\x4a\xce\xc6\x65\x39\x15\x3b\xbd\xde\x69\x52\x8e\x67\x83\xee\x30\x9f\xf4\xde\x0b\x54\x55\xf6\x86\x42\x74\x70\xa7\xd1\xb5\xd2\x64\xc8\x33\xc1\xd9\x8b\xe7\x6f\xf0\x53\xcf\x1a\x89\xdb\x95\x50\x25\x66\x60\xf9\x51\xae\x9e\x4b\xd3\x39\x4b\x77\x0e\x69\xab\x22\xf4\xed\xe6\x51\xf9\x32\x22\x74\x85\x10\xd6\x6e\xfe\x79\xf6\x63\x91\x5f\x08\x5e\x27\x44\xf7\xd7\x37\x5a\x01\xe8\xf9\x46\xf6\x06\xac\xf5\xe5\xf7\x33\xb8\x0c\x26\x7f\xd6\x6f\x27\x9b\x15\xd0\x79\xad\x6b\x98\xaf\x98\x97\x10\xa2\xa8\xeb\x18\xdf\x18\x13\x60\x38\xe6\x3a\xfa\x1a\x18\xfa\x51\xca\xd3\xe8\x1d\xc0\x02\x50\x3f\xce\x87\x10\x61\x40\x25\x2b\x3f\x48\x21\x59\x45\xb3\x31\x6d\x60\xc4\x00\xb5\x1f\xdc\x63\xbf\xe1\x02\x67\xfc\x9c\x17\x97\x76\xf1\xe7\x99\x27\xd8\x2b\x12\xea\x94\x17\xec\x1e\x3b\xcc\x86\x58\x97\xc7\x6d\x6d\xd3\x9a\x08\xc4\x36\xee\xb2\xe7\x25\x58\xf7\x0b\x36\x13\x6c\x36\x95\x17\x83\x07\x6b\x7f\x67\x53\x5e\x8c\xd8\x20\xcf\x85\x6e\x45\xee\x0c\x3b\xbd\xde\x7b\x21\x4b\x60\x63\xe0\x88\x2b\xea\x2c\x3a\xa8\x8b\xe9\x44\x10\xd7\xb6\x73\x2e\x3a\xd3\x34\x4a\xb2\x8e\xf6\x47\x57\x3b\xd2\x3d\x06\x57\x83\x34\x55\xc4\x02\xdd\xc0\x59\x96\x5f\x64\x4c\xca\xee\x44\x51\x04\x0f\x47\xf1\x6c\xc8\x59\x34\xc9\x67\x59\xc9\xf2\x11\x36\x40\x2d\x05\xd0\x68\x49\xc2\xd2\x4d\x90\x45\x25\x2b\x66\x59\x99\x4c\xb8\x8b\x7c\x1c\x9d\x27\xf1\x45\x94\x8a\x31\xa4\xa4\xef\x21\xe5\x3a\x48\xb9\x15\xdc\xc0\x74\xc0\x18\x65\x2f\xb0\xa7\xf2\x3a\x75\x4f\x79\xb9\xaf\x3e\xe2\x65\xc1\xcc\x9c\xfe\x43\xcd\x5d\x5b\xc7\xc3\xf0\xef\x83\xba\x4d\xe7\xe1\x3d\x11\x2f\xa3\x97\x4d\xbc\xf5\x01\x49\x8e\x35\x18\x5c\xf9\x30\x66\x1a\xf9\xe0\x67\x69\x7e\x23\xc7\x0b\x46\x5c\x56\x4b\x26\xec\xc6\xd1\x56\x5c\x4e\x3e\x59\x40\x20\xbe\xde\xd1\xef\x69\x06\x4a\x46\x9a\x87\xe2\x2e\x7b\xad\x6a\xbf\x03\x41\xff\x9d\x2c\xcc\xf2\xd2\x36\xe6\x5f\x14\xa9\xa1\xa6\x17\xf9\x30\x60\xff\xfd\x49\x1b\x87\xcd\xbd\x55\xd6\xdc\x6d\x74\x10\xe4\x67\x79\xc1\x04\x2f\xce\x79\xd1\x01\xed\x60\xc1\x33\x1b\x49\x1c\x68\xcc\xad\x6f\x81\xac\xa9\x6d\xb9\x7f\xe3\x18\x01\x4f\x0e\x08\x97\x07\x64\xee\x42\xdc\x2f\x79\xd9\x66\x29\x2f\x05\x8b\x73\x88\x84\x25\x21\x74\x8b\x38\x51\x53\xd7\x5a\x57\x87\x32\xb1\x65\xc6\x68\x1c\xf7\x26\xad\x14\x33\xe4\x65\x03\x3e\x8c\xe4\x41\x72\xc1\xd9\x30\xca\x1a\x88\x06\x9b\x09\xb4\x42\xe9\xf5\x60\x4d\x88\xcb\xac\x8c\x3e\x00\x37\xf1\xee\x69\x57\x72\xd2\xb3\x67\xca\x8f\x50\xcf\x7e\x70\xee\x59\x24\x58\x22\x97\xba\x46\x1b\xec\x8c\xcc\x66\xea\x44\x13\x42\x8a\x26\x19\xe3\x69\xd7\x0d\x12\x49\x86\xba\xa7\xc8\x67\x32\x0a\xce\xef\x9e\xb0\x97\xe2\xad\xee\x0a\xb1\xac\x09\xc8\x05\xdd\xf7\xf2\xfa\x3e\x07\x4d\x0c\xd3\x53\x8b\xac\x8f\x6e\xa8\x0b\x54\x11\xe8\x81\x54\x12\xfc\xb9\x0d\xf8\xa1\x7c\x43\x73\x5c\xbd\xea\x7c\x63\x49\xbf\x82\xa2\x85\xa6\xaf\x1f\x86\xf5\xb8\xf3\x87\x38\xb9\xdf\xec\xb6\x1e\x87\xd2\x3e\xb9\x2b\x5a\xbb\x14\xc9\xfd\x97\x84\x85\xab\xdb\x13\x96\x0a\xc7\xaa\xf1\xaa\xc4\x63\x15\x65\x51\x89\xb9\xa6\xc2\xbd\xa1\x15\x3b\x49\x04\x05\x5f\x75\xd2\xa6\xa1\xd3\xcc\x90\x3d\x66\x43\x37\x4e\x1c\xdb\x01\xa7\x8f\xea\x3c\x7e\x9b\x51\xfa\x6b\x44\x44\x65\x4f\xfc\xff\x82\x7c\xf8\x95\xe4\x37\x2a\xae\x55\xe4\xb9\x05\xf2\xdb\x12\xb2\x9b\x09\xd2\x87\x27\xe8\x54\x25\x8b\x57\xfa\x3f\x79\x90\xa2\xaa\x35\x74\xc6\x2a\x18\xb1\xfc\x61\x5b\xe7\x4f\x69\x83\xf4\xdd\xe8\xe8\xb5\x1a\x25\x74\xbf\x20\x31\xd6\xae\x7b\x04\xdb\xd0\x7b\x24\x54\xbd\x32\xf7\xca\x0b\x16\x31\x0c\x59\x26\x4f\x2f\xf3\x1d\x82\xd8\x36\xfa\x8d\xae\x39\xb9\x2f\x22\x29\x12\x66\xe9\xa5\x22\x2c\x38\x1c\x2b\x3f\x95\x31\x2f\x78\x77\xa5\xea\xa7\xa0\xd5\xb7\x90\xca\x1a\xfc\x11\x50\xfa\x9a\x46\x85\xe0\xcf\xb3\x52\x6b\xd8\xfa\x6b\xad\x56\x5d\x20\x41\xc9\x33\x3f\x81\xfe\xd9\x1c\x7a\xf7\x09\x8c\x95\x0e\x34\x64\x9d\x84\x60\xca\x0d\x29\x0e\x20\x28\x2f\x3f\xe7\x19\x38\x6d\x5d\x80\x61\x6a\x51\xe4\x05\x26\x4b\x9c\x70\xd8\x5e\x45\xdb\x8a\x02\x3a\xaa\x38\x3c\x16\xb1\x3d\xcc\xd3\x00\xc6\x11\x97\x36\x73\x15\x1c\xd2\x38\x7e\x2a\x10\x30\x73\x7a\x1e\xeb\x91\x58\xaf\x60\xc8\xd6\x3c\x8c\x20\x78\x20\x2f\x0a\x57\x18\xb0\x23\x73\x0e\x48\x3f\xfa\xbd\xf6\x42\xfb\x55\xf3\x72\xbd\x60\x12\xc0\xe4\x8e\xb2\xb5\xad\xeb\x98\xe0\x49\xce\x6f\x77\xb8\x61\x01\xc4\xba\xdc\xd5\x8b\x07\x76\x42\x55\x40\xe5\x22\x1e\xe6\xb1\xba\x5d\xc8\xd3\x4e\x9d\x87\xab\xa3\x94\x7f\x58\x95\x5f\x56\x3b\x13\xd1\x91\xbf\x06\xf9\x87\x55\x98\xa1\xe7\x07\xfd\x35\x9b\xf9\x8b\x98\x8a\x6b\xc8\x46\xcb\x60\xd2\x20\xb5\x75\xfa\xa6\x79\xd3\xa3\x11\x0b\xd0\xb6\x6e\xd0\x0b\xe8\x3c\x8f\xc2\x2b\x26\xad\x88\x0b\x14\xaa\xa5\xa6\x7f\x45\xc5\xcc\x17\x5c\x59\xba\x29\x27\xd6\x95\x9a\x71\x29\xaf\xcb\xba\x15\x52\x3d\x9b\xbf\xd1\x58\xf7\xfe\x0b\x28\xf8\x60\x1d\xe5\x45\x69\x0c\x6a\xe5\x0f\xe5\x19\x38\xb8\x64\x68\xcf\xdc\xad\x3c\xa3\x99\x7a\xfe\x0b\x9a\x90\xdf\x64\xf5\x35\x7c\x09\xf0\xb3\x8a\x40\x91\xf6\x92\xee\x20\x88\xb6\x9a\xfe\xe2\xcf\x5f\xea\x95\x54\xa7\xc7\xd7\x89\xd0\xf5\x83\x18\xc9\x38\x0b\xce\xa6\x28\xbb\x77\x61\x48\xf2\x7f\x5a\x35\xa9\xd2\xa6\xd4\xd5\xcd\xcb\x81\xae\x1c\xdc\xdc\x20\xf5\xfa\x23\x75\xaf\xaa\x24\xe3\xbe\x0d\x9b\xed\x6f\x32\x5a\x38\xaa\x5c\x7e\x43\xd7\xc5\x57\x46\x5b\xb2\x5e\xa7\x69\x5b\x54\x71\x63\x8e\xd0\x56\xd7\x57\x2b\x18\x2e\x04\xe5\xa4\x37\x97\xd3\xfc\xb4\x88\xa6\xe3\x4b\x1b\x12\x9b\x4f\x27\xbc\x38\xad\x0d\x19\xb2\xbe\xd9\xaa\xc0\xce\x8f\x9d\xad\x80\xbe\x4e\x8a\xa9\x1e\xfb\x07\xeb\x9f\x0d\xd8\x34\xba\x4c\xf3\x28\x66\xf9\x39\x2f\xc6\x3c\x8a\xf1\x49\x3d\xcd\xe5\xb5\xa9\x87\x03\x4c\x04\xfb\x27\xdb\x38\x1b\x74\x09\x5e\x60\x21\xd4\x24\x22\x95\x42\xe5\x45\x54\x8e\xbb\xa4\x90\xdd\x63\x7d\xbe\xd5\x62\x3d\xf9\x8f\x7b\xe7\xf1\x29\xdb\x9c\x46\x10\xc5\xad\xcd\x4a\xf3\xcd\x46\x45\x7d\x5b\x70\x12\xd0\xc6\x42\x78\x79\xb9\xd9\x63\x52\xa6\x5b\x6c\x61\x60\x18\xf5\xb5\xad\xd6\xa4\x6c\xf1\xfb\x51\x9e\x95\xcf\xc0\x74\x48\x4e\x4d\xc1\x47\x5d\xfb\x45\x03\x56\x60\x9c\x5a\x5e\xf8\xd5\xc6\xea\xeb\x7c\x90\x97\xf9\x6a\x9b\xad\xfe\x9b\xa7\xe7\xbc\x4c\x86\x91\xfc\xf1\xa4\x48\xa2\x74\xb5\xcd\x44\x94\x89\x8e\xe0\x45\x32\x02\x47\x2b\xb7\xb9\x0a\x6e\x47\x4a\xdd\xac\x31\x93\xbf\x29\x5e\xa4\x9c\xc0\xfb\x99\x31\x37\x69\x4f\xb4\x09\xf3\xf1\x37\xb0\x61\xfa\x19\x1e\x5d\x48\x77\xe4\x33\xed\xb5\x0a\x5d\x6d\xc4\xc3\x61\x63\x6d\x8d\x22\x11\x68\xd8\x2b\x7b\x0d\x26\xf8\x55\x64\xf0\x7b\x51\x45\x47\x15\x54\x11\xd2\x2d\x79\x18\x6d\x86\x30\x42\xd8\x1a\x94\x5e\xf0\x38\x99\x4d\xaa\x28\xe1\xf7\x2a\x46\x0e\x7c\xa0\x1d\x0f\xa1\xad\x10\x42\x6e\xdb\x50\x38\x2e\x27\xe9\x33\x8f\x37\xe8\x37\x0d\x1c\x80\xf3\xea\xfa\x7c\xb2\xad\xfb\x0f\x35\x97\x97\x63\xb8\x9a\x83\xae\xab\x6e\xdf\xb5\x5e\x80\xb2\x9d\x36\xa4\x63\xd3\xcc\xdd\x68\xa3\xad\xde\x11\xd8\xf0\xe1\xdf\x84\x0f\xdc\x4f\x6a\x36\xdd\x8f\x48\x0c\xf9\x8d\x22\x88\x01\xe6\x89\x8c\x30\xfd\xf0\x26\x7f\xcd\x27\x4d\x27\xaa\x36\xbd\x1b\xb1\x9e\x4b\x9c\xfb\xac\x51\xf0\x49\xc3\x3f\x60\x61\xa4\x76\xf3\xb6\x63\x53\xd6\xdb\xd8\xcd\x8e\xfe\x43\x99\xe2\x99\xf1\xee\x30\x7f\x61\xeb\xd1\xef\x30\x77\x21\x7a\x94\xd8\xf1\x3f\xf8\x50\x8a\x38\x3b\xd5\x4f\x3e\x24\x52\x6c\xa7\xf2\x45\x9b\x1b\x8a\x69\x1a\x5d\x6e\xee\x18\x41\xc5\x62\xa8\x89\xd8\xef\xaf\xb7\xaa\xac\x5d\x83\xe2\xfc\xe1\x33\x86\x61\x3a\x8f\x30\xfa\xdc\x0e\x6b\x74\xba\x6b\x9b\x7c\xd2\x30\xc5\xc4\x6e\x13\x0f\x91\xfe\xfa\x43\x79\x76\xf4\xd7\x5b\x72\x92\x08\x28\x3a\x80\xfc\x8c\x51\x40\x3b\xdd\xb5\x6d\x52\xa6\x6c\x7f\xd5\xee\xdf\x2d\xf9\x87\xb2\x2b\xf8\x30\xcf\xe2\xa8\xc0\x0c\x31\x57\xce\xf8\x37\xe6\x8d\x7f\x6b\x7b\xc1\xf0\x03\x1b\xd2\xb5\x08\xb0\x3e\x97\x00\x0f\x36\x58\x8f\x6d\x6d\x2f\x1a\xfe\xe6\x0d\x86\xbf\x3e\x6f\xf8\x9b\x5b\xb7\x3a\xfc\xca\xf8\x36\xe5\xfc\x6e\x6e\x7d\xc9\xf1\xf5\xe7\x8d\x6f\x63\xf3\x0b\x8f\xaf\xcf\x7a\x6c\x63\xf3\x8b\x8c\x4f\xca\x6b\xd4\xc1\x25\x34\xbe\xf5\x2f\x3c\xbe\x8d\xf5\xee\x16\xeb\xb1\xf5\xca\x08\x43\xa3\x98\x16\xc9\xc4\x1b\x43\x99\x94\xe9\xfc\x01\xf4\x17\x0c\xa0\x7a\xfa\x5e\x07\xff\xf5\x4d\xc4\xbf\xff\x99\xf8\x8b\xd9\x40\x4e\x03\x71\x69\x0b\x6e\xa2\xb7\xbb\x89\x04\x46\x21\x77\xc9\xca\x2e\xb1\xe4\x18\x06\x79\x3c\x7f\x13\xe8\x2f\x62\xa2\x9b\xce\x81\xc4\xfe\x73\x39\x48\x62\x3f\x77\x89\x2f\xc4\xfe\xa6\xc4\x5f\x03\x16\xfa\xec\x01\x0c\xa3\x29\x75\xaa\x0a\x0e\x61\xd1\x19\x7c\xc3\x21\xf4\xb7\x71\x08\x95\x63\x76\xe9\xbd\x68\x30\x2b\xcb\xf9\x63\xd0\x5f\xcc\x48\x64\x63\x6f\xac\xe7\x6e\x63\x36\x9d\xf2\x62\x18\x09\xde\xb8\x39\xb3\x19\x2d\xca\x55\x1b\x05\x57\x9d\xe2\x7f\x98\xe6\x72\xc3\x04\x9d\x1f\x06\xbd\x35\xf6\x18\x50\x04\x79\x89\x9c\xf0\x88\x54\x79\x72\x9b\xa9\x17\x7a\xf7\xd8\x6f\x07\x3f\xbe\x7a\xb2\xff\x13\xfb\xf5\xc9\x6b\xf6\xfc\xe5\xff\x1c\xec\xbf\x79\x7e\xf8\x92\xdd\xeb\xd9\xb6\xa7\xa8\xcf\x81\xea\xb7\x97\x33\x3b\x2a\xce\x88\x69\x68\xaa\xee\x71\x15\xcb\xd0\x33\x7e\x59\x17\xac\x74\xc3\x3e\xc5\x49\xa8\x79\x8a\x0d\x59\xfe\x5f\xa3\xe8\x79\x85\x8c\xfe\x85\x33\x88\x7f\x05\x0d\x92\xca\x31\x14\x27\xa7\x79\x4d\xfb\xeb\x0f\xd6\x3c\xc0\xb9\x2f\xa9\x00\x61\xdf\x46\x93\xec\xac\xb6\xdd\xbe\x03\x36\xf7\x01\x35\xc9\xce\x0c\xf0\x69\xc1\xeb\x2c\x84\xfb\x0f\xd7\x1c\xb0\x79\x6d\xca\x72\x03\x5c\x80\x3d\x54\x18\xcd\x75\x0a\x35\xaf\xc5\x82\xc7\xd6\xb0\x2f\x9f\x4c\xf2\xac\x16\xcd\xbe\x07\x38\xd7\xfe\x0f\x20\x48\x85\x34\x2f\x5e\x44\x59\x32\x9d\xa5\x18\x85\xb9\x86\x2d\xb6\xbe\x61\x0d\xa1\x1c\x89\xde\x4f\xfc\xfd\x45\x6e\x49\x72\xcf\xb7\xde\xcf\x70\x14\xee\xb0\x46\x71\x3a\x88\xe4\x65\x5b\xfd\x5f\xf7\xe1\x83\x96\xf6\x60\xd3\x67\x4d\x00\x6a\x6b\xb3\x65\xdc\xe6\x44\x34\x48\x79\x1c\x00\xda\x78\xa8\x81\xc6\x09\x78\xab\xd5\x03\x24\x43\xf0\xbb\xab\x07\x88\x93\xf3\x04\x13\xba\xf8\x30\xfd\xf5\x96\x71\x3d\x3c\x1d\x97\x4f\x6b\x01\xd7\x1e\x6c\xb5\x8c\x07\x5e\x92\x4d\x67\x86\x1a\xe8\x3a\xff\x33\xe6\x1a\xf0\xab\x6d\x9a\xf6\xc7\x3c\x9d\xf2\xe2\x0d\x90\x71\x0e\x45\xd2\x68\xc0\xd3\x85\x50\x80\x40\x0d\x94\x9d\x83\x39\xd4\x95\x78\x19\x7f\xc2\x21\x95\x62\x22\x1d\xda\xff\xb3\x66\x6d\x7d\xbb\x35\xc7\x91\xd5\x70\x2b\xee\x05\x7a\x13\x3f\xde\x5a\x3b\x51\xee\xce\xd1\x54\x52\x5f\xaf\x41\x0d\xd0\xbd\x18\x27\xa5\x52\xb9\x44\xd3\xe9\x8f\x51\x51\x69\xa2\xbf\xa6\xdb\x50\x4f\xd4\xcf\x0a\xf0\x71\xf7\xc0\xd6\xd7\xd6\x4e\x34\x7e\xf4\x06\x26\x4a\x3e\xc5\xae\x5d\xf8\x4d\x05\x0f\x8e\x91\x72\x8d\x78\x47\xb0\xfa\xb9\x60\x85\xac\x6f\x6d\xb5\x99\xfd\x9f\x7e\xed\x22\xf1\x00\xd7\xba\xb5\x73\x59\x81\xdc\x0a\x2d\x97\x7a\x28\xba\x66\xea\xa1\xbc\x85\x53\x01\x9c\xbf\x7c\x2a\xe0\xd7\x59\x44\xf5\xa4\xa8\xae\xa4\x7a\xd8\xca\x72\xaa\x07\xad\xac\xa9\xba\x59\x5b\x66\x2a\x96\x59\x5b\x9f\xdd\xfe\xc6\x52\x6b\xac\xf1\xb7\x8d\x35\xf9\xff\x1a\xee\xd2\x72\xf9\xfb\xa1\x59\x36\x35\xeb\xea\xd1\x72\xeb\xea\x51\xcd\xba\xea\xf5\xd8\x9b\xc3\xa7\x87\x3b\xec\xb7\x71\x54\x32\x31\xce\x67\x69\x0c\x26\xae\xb0\x70\x4a\xf0\xe6\x07\xc3\xd8\x51\x5e\xe8\x45\x08\x0d\x3c\x86\xac\x16\x10\x10\x21\x36\xce\x8d\xec\x74\x96\xc4\x7c\xf9\x05\x6b\xce\x5a\x30\xa8\xce\xca\x22\x12\x30\xc3\x4d\x38\xb2\x6d\x14\x67\xb4\x02\xf5\x8e\xf1\x2e\xa9\xf4\x3a\x2a\x93\xbc\x85\xd5\xda\xd5\xed\x69\x90\x42\x34\xc8\x7f\xb0\x07\x9e\xd2\x5a\x8e\xd2\xb9\x3e\x7a\xd1\xb6\x61\xd5\x78\x00\xd5\xa7\x36\x25\xdb\xda\x57\x31\xf3\xb6\xa6\xbe\x7c\xaf\x2a\xb3\x3d\x73\xe1\x53\x5f\xf4\x65\xcb\x02\x54\xeb\x78\x8f\x09\x5a\xa6\x34\x22\xf6\x4e\xa5\x8e\x79\xd5\xd0\xdf\xcd\x46\x46\x30\x30\xdf\x34\x34\x05\x0a\xd5\xf4\xf1\x00\x19\x34\x84\x45\xa5\x65\x53\x82\x26\x4c\x16\x07\xf8\xad\xa1\x74\xa1\x0f\xed\xf7\x2b\x85\xca\x50\xb7\x4e\x63\xe6\xab\xca\x89\x6a\x2e\xda\x97\x53\xf3\xf0\xa2\x8a\x3c\x50\xff\xdd\x11\x78\xa0\x41\x3b\xa2\x6d\x5c\xf3\xf1\xc6\x3c\xc5\x1e\x37\xd4\x5c\x35\xda\xac\x61\x08\x26\x7f\xc0\x30\xe4\x1f\xb2\x1b\xfd\x04\x03\xee\xb4\xe3\x28\xe6\xf2\xde\xf8\x11\xf8\x76\x07\xfe\xb7\x8d\x3c\xba\xa3\x84\x43\x4c\x4a\xa9\x2e\xb7\x5d\x9e\x9d\x77\x5f\x1e\x3e\x3d\x78\x7b\xf0\xf2\x57\x30\xd8\x58\x9d\x16\x79\x3c\x53\x99\x41\x1e\x23\xd2\xfa\x86\x65\x91\x54\xe6\x80\x4d\xec\xf0\x58\xe2\x71\xd2\x6a\xb3\xc6\x8b\xa8\xe4\x45\x12\xa5\x9d\x5f\x9e\xef\xc0\x26\xa1\x46\x83\x84\x7c\xd7\x60\xf7\xf1\xaf\xfb\xac\xf1\xae\x6a\xb0\xd8\x68\xb1\x1d\x6b\x52\xa9\x2c\x41\xb0\x81\xc3\x59\x39\x9d\x95\x9a\x8a\xf5\x0f\x43\xb8\xae\xab\xf2\x87\xd2\x78\x42\xf4\x20\x3b\x39\xe6\x90\x77\x56\x05\x39\xd3\x3d\x3e\x05\xc2\xef\x30\xc2\x46\x72\xeb\xf2\x77\x30\xd5\x0a\x90\x66\x47\xfd\xab\xfa\x87\xb3\x89\x12\x0d\x76\x0e\x72\x7a\x79\xa5\xf0\xad\x6d\x4e\x1e\x39\x32\xa7\x1c\x3f\x2a\x35\x10\x39\x48\x1c\x20\x5b\xa0\x0f\x7a\xb9\xbb\x3b\x20\xf2\x93\x1a\x90\xbb\xcf\xee\xf8\x1f\x6e\xa8\xd7\x59\x51\x91\x8b\xcf\x99\x62\x2a\x1d\x56\xbe\x96\x21\x1b\x96\x21\x1b\x34\x24\x6f\x9c\x8c\x46\xbc\xe0\x99\x9b\xf3\xdb\x7e\x6d\x0e\x22\x01\x29\x4f\x26\xd3\xa8\xe0\x6e\x48\xd4\x3b\x95\xaf\x4c\x03\x12\x43\x24\x12\xc4\x94\xbe\x4a\x82\xd2\xc5\xf2\x9d\xec\xa6\xd5\x1d\x25\x69\xc9\x0b\x92\x1a\x64\xec\x3a\x8c\xab\x06\x74\xc7\xc7\xe3\x19\xb7\x01\x63\x75\xc0\x01\x62\x17\xa5\xd8\x7e\x5f\x1e\x57\x07\x6a\xd7\xb3\x8f\xac\x7e\x61\x33\x83\x88\xd6\x35\x23\x96\xed\x4d\x12\xcc\xf3\xbd\x57\x4f\xa1\x5d\x73\xd0\xdc\x68\x6b\x50\x3d\x39\xa9\x37\xe4\x66\xe6\x6c\x0d\x72\x23\x80\x28\x12\xf7\x59\x03\x15\x9d\x72\x37\xd0\x48\xca\x8d\x63\x94\xa7\x69\x7e\x21\x7f\x8d\x67\x72\x19\xc9\x1a\xba\x69\x93\xec\xa3\xcd\x1a\x47\x9c\xa3\x34\xa2\x76\x7b\x68\x4c\xb4\x19\x1e\x81\x6d\x96\x17\x4c\x9e\x42\x6d\x16\x09\x25\xf2\xf3\x18\xc3\xe8\x4d\x34\x42\xb3\xa4\x87\xb5\xba\x8d\x13\xd5\xf6\x1f\x59\xa3\x45\x37\x23\x3a\x3d\x55\xea\x93\x8d\xda\x3f\x7a\xdb\xee\x06\xa6\x0f\x75\x45\xec\x40\x53\x74\xa3\x77\xcf\x4f\xbf\x29\x03\x59\xdf\x98\x3e\x28\x9c\x03\xd1\x6f\x07\x80\xea\xdb\x90\x5b\xdb\xa2\x26\x94\xde\xc7\x7d\xc2\x77\x40\xa4\x50\x34\x47\xeb\x7a\x85\x31\x4d\xe6\xa9\x71\x9b\x1b\xad\x56\xab\xa2\x15\xfe\x26\x73\x80\xb9\xf5\xeb\x14\xac\x0f\x6a\xe0\xe7\xe9\x55\xbd\x96\x4d\x0b\xfc\x43\xc9\xb3\xb8\x56\x97\xbb\xe9\x03\xce\xeb\x43\xb7\x35\x4f\x57\xfb\x22\xf9\x90\x64\xe2\xab\xa6\xcc\xa2\x1d\x37\x21\x2d\xf8\x34\x4f\x32\x39\x2d\x2a\xa3\x5e\x9b\x4d\xa0\x90\x08\xd7\x65\x9e\xa7\x83\xa8\xd8\xf5\x0d\x4b\x34\x15\x7c\xe9\xe1\x74\x56\x96\xbc\x10\x24\x9d\x9a\xfa\x82\xc6\xa7\xc2\xcb\x90\x2d\xba\x2a\xa4\xe6\xcf\x7c\x24\x69\xa3\x10\xe9\x42\xe6\xe5\x7b\x6c\x7d\x37\x08\xfc\x5a\xe9\xe4\xe6\x43\x1f\x93\x21\x76\x67\xd3\x66\x43\x4c\x1a\x2d\x1d\x79\x40\x6d\xd4\xb6\xf3\x1d\xbf\xb5\x8d\xb6\x0f\xf6\x1a\x85\x40\x1f\x4e\x9f\x41\xbb\xee\x49\x87\x48\xec\xd2\x67\x26\x45\xcc\x1d\xd6\xd4\x74\x25\xd8\x4c\x92\x4c\x3f\x6b\x6d\x6d\xab\x5a\x5a\x56\x73\x98\x9b\x58\x29\xa9\x56\xda\xcc\x1f\xea\x07\xd1\x80\xc7\x30\x08\x5c\xd0\xcc\x8b\x84\x67\xa5\x0a\x6e\x98\x46\x59\x2c\x86\xd1\x94\xb7\x1a\xed\x50\xe7\x9b\x0f\xb1\xf3\xd6\xe7\xf7\x2e\x09\x1d\x6c\x7b\x7b\xd3\xb4\xad\x6b\xb7\x50\x1c\x52\x8c\x17\x78\xb6\xea\x7f\x63\x71\x9a\xf5\x2d\x21\xbf\xf8\x89\x5f\xfe\x32\x19\x14\xd1\xa1\x64\x08\x88\xa4\xb0\xd6\x5d\xf7\x00\x5e\xf1\x6c\xe6\xc3\xf4\x37\x29\xd0\x93\xc9\x40\xce\xce\x11\xfc\x70\xc0\xd6\x77\x2b\x8b\x17\xa1\x9a\x8e\xd5\xea\x71\xb3\x92\x6a\xff\x1f\x7b\x6c\x8d\x3d\x26\x57\xac\x1d\x27\xb3\x3e\xb0\xc6\xf4\x03\x48\x04\xc1\xca\xfd\xda\xca\xfd\xc5\x95\xd7\x6b\x2b\xaf\x2f\xae\xbc\x51\x5b\x79\xc3\x54\x76\xf5\xad\xb2\xa9\xf0\x7c\xdc\x67\x0d\xc9\xe3\xc1\x7e\x36\x6b\xfb\xd9\x5c\x8c\xe4\x56\x6d\xe5\xad\xc5\x95\xb7\x6b\x2b\x6f\x2f\xae\xfc\xa0\xb6\xf2\x83\x65\xc8\xe3\x73\xe3\x3c\x0a\x3d\xac\xed\xea\xe1\x62\x3c\x1f\xd5\x56\x7e\xb4\x04\xf7\xd5\xf3\x6e\x7f\x19\xe6\x9d\xc3\xbd\xfd\x85\x54\x0a\x2e\x47\xa0\xd3\x09\x4d\x91\xa7\x5c\x1a\xb1\x8e\x60\x7b\xec\xb8\x91\xe5\x19\x6f\xb4\xdd\x85\xba\xd6\x66\xfd\x36\xdb\xd0\xdd\xf4\xe1\xff\xf0\xef\x75\xf8\xbb\xd3\x6f\x05\xab\x6c\x11\xb0\x75\xfd\xf7\x06\x56\x59\x0f\x57\x79\x48\xc0\x36\xc9\xdf\x1b\x35\x55\xd6\x01\xac\x83\x08\x6d\x92\x2e\x25\x96\xf2\xaf\x40\x9d\x0d\x00\x53\x75\xb6\x48\x9f\xb2\xce\xe6\x12\x75\xb6\x55\xdb\xa6\xd2\xc3\x70\x25\xc4\xa7\x83\x43\x7f\x80\x95\xfa\x86\x6e\xb2\x95\x40\xa5\x2d\xac\x84\xe4\x7e\x48\x2b\x6d\x20\x7a\x21\x32\x6c\x01\x52\xaa\xd2\xa3\x36\xeb\xaf\xd3\x4a\xdb\xe1\x4a\xdb\xb4\x12\x74\xb3\xa9\x6b\x6d\xe2\xa0\x36\xc2\xb5\x1e\xb4\x59\x07\x27\xa7\x2f\x47\xbf\x45\x6a\xad\xaf\x85\x6b\x3d\x80\xb1\xe8\x5a\x12\xbb\x07\x9a\x27\xb6\xda\x6c\x5d\x4e\xe3\xc2\x5a\x72\x28\x8f\x68\xad\xcd\xda\x5a\x8f\x6c\x2d\x89\x54\x9f\xd6\xda\x0e\xd7\x7a\x88\xb5\x90\x81\xfa\x0a\xa9\x75\x3d\xdf\xeb\x0f\xdb\x6c\x2b\x5c\x4b\x52\x4e\x57\xdb\x46\xac\x4c\xb5\x8d\xb5\xfa\x6a\x7d\x5b\xed\x01\xa2\x65\xab\xad\x87\xab\x3d\x72\xab\x3d\x44\xbc\x0c\x7f\x6d\x6c\xb6\xd9\x76\x4d\xb5\xf5\x36\xeb\x6c\x63\x35\x49\xc3\x47\xb4\xda\x76\xb8\x5a\x5f\x11\x5d\xd5\x83\xa9\x35\x1b\x81\xe4\x8e\x87\x6d\xf6\x60\x89\x7a\xb2\xce\x06\xa9\xb7\xb9\x36\xa7\xde\xa6\xad\xb7\xde\x66\x1b\x5b\xb4\xde\x7a\x4d\x3d\xb5\x6e\x3b\x0f\xb0\xde\x06\x0e\xc9\x2c\x86\xcd\xcd\x36\x7b\x58\x57\x6f\xcb\xd6\xdb\xc4\x21\xd9\x7a\xdb\xb2\xde\x49\xf0\xfe\xa3\xf6\xcc\x4a\x84\xa8\xfe\xcd\x82\xac\x06\x2d\x70\xfa\xf2\x0e\x86\x4d\x74\x55\x0b\x75\x16\x15\x1b\xad\xee\x4b\x70\x84\xee\x82\x93\xb2\x94\x15\x3d\xfc\x6e\x16\x51\xaf\xd7\x63\xeb\x6b\xdd\x7e\x77\xbd\xbb\xc9\x68\x47\x4d\x74\xbf\x6e\xc1\x79\xf2\x3d\x36\x53\x6b\xf5\x21\x6f\x94\x0a\xa6\xa9\xfe\xed\x1e\xb5\x59\x03\x1b\x54\x02\x3d\x34\x4b\x6e\x60\x4e\x37\xf6\x4d\x8a\x8b\x34\xc9\xca\x8e\x7a\x69\xeb\x64\xfc\x03\x26\x21\x67\x59\x0e\x41\x74\x3b\x4a\xad\x45\xdf\x72\x94\xab\x38\x78\x58\xcb\xbf\x54\x74\x9c\x56\x80\x5a\xdf\x58\xbc\x2f\x98\x00\x15\x3c\x39\x12\xa0\xf0\xfa\xf3\x39\xa4\xba\xb9\xc8\x8b\x33\x15\x34\x39\x1a\x88\x3c\x9d\xe9\xc4\x6e\x02\x2d\x42\x14\x18\xde\xd4\x26\xf9\x20\x49\xf9\x91\x7e\x78\x7b\xb4\x06\x11\xbc\x27\x3c\x9b\xed\xb0\xfe\x1a\xfe\xd2\xaf\x88\xfd\x3e\xfe\x8e\x8b\xe8\x82\x17\x87\xe7\xbc\x80\xd8\xee\xfd\x75\xfc\x9c\x45\xe7\x4f\xa1\x64\x87\xf5\x37\x14\x64\x12\xa5\xf9\xa9\x85\xdc\xa4\x9f\x77\x58\x7f\x0b\x7f\xa7\xd1\xa5\xac\xb5\xae\xfa\x9b\xe6\xd3\xfc\x1c\x3e\xa8\x0e\x45\x16\x0d\xcf\xe0\xa2\xb9\xae\x10\x94\x97\xad\x32\x99\xee\xb0\x8d\xb5\xb5\xb5\x95\x70\x6e\x71\x1c\x67\x75\x59\x7e\x9b\xd1\x55\x08\xe2\x2a\x28\xc2\x93\x34\x05\x4d\x6c\x9e\x49\x59\x0f\x23\x44\x43\xd8\xdd\x8c\x3d\x8c\xa7\x4c\xfc\xef\x2c\x2a\x38\x68\x78\x81\xcb\x4f\x8b\x04\xd3\x0b\xe0\x94\xb6\x19\xe4\xf0\x2e\xdb\x70\x65\x8e\xb9\x38\x2b\x21\xf7\xb6\x6c\x59\x07\xe9\xd3\xfa\xce\x6e\x92\xf7\xe0\x15\x56\x36\x24\x7a\x69\x74\x99\xcf\xca\xde\x84\xcb\x51\x8a\xce\x19\xbf\x84\xef\xe0\xd6\xf4\x37\xff\x6b\x47\x23\xd0\x91\x08\x88\x15\xc6\x66\x59\x52\xee\xb0\x87\x81\xb0\xd3\xfd\xdb\x0c\x88\xf2\x1f\xb4\xd8\xf4\x54\x5f\xff\xe2\x19\x2f\xa2\x92\xef\xa7\x91\x10\x2f\xa3\xc9\x97\x36\x58\xfc\xe2\x1a\x36\x4c\xd5\x3b\xe0\xe9\xab\x74\x76\x9a\x64\xcf\xd2\xfc\xe2\x35\x8f\x86\xf0\x3a\xf9\xe6\x72\xca\x05\xa4\xd3\x2b\x2f\xa7\xfc\x2d\xf8\x36\x1f\x8d\x39\xaf\xdb\xe3\xfb\xeb\xeb\xad\xee\xf5\x1b\xfb\xf4\x29\xd8\xda\x5a\xab\x1b\x65\xda\xed\x77\xc9\x56\x4f\xfd\xe9\xa9\x3d\x8d\x36\x97\xc6\xb4\xda\xe6\x2d\x22\xfc\x7a\x96\xde\x06\x8e\xd0\xcc\x32\x68\xa9\xc1\xe4\x05\x64\xdd\x80\x97\xe9\xb5\x5d\x38\x5f\x74\x64\x99\xc8\x1e\xbe\x17\xe3\x64\x38\xd6\x55\xb8\x90\xab\xfd\x7f\x67\x9c\x0d\x25\x21\xe0\x01\x47\xc0\x96\x14\xb3\x3c\x63\x43\x6c\x4f\x74\x65\x5b\xbf\x61\x74\xf0\x0b\xdb\x1d\x3d\xd1\xd5\x52\x8a\x31\x7a\x80\xae\x89\xc1\xce\x04\x2f\xb1\x05\x1b\xad\x0f\x3e\xc2\xa1\xe7\x80\xcb\xed\xef\xe8\xe8\x35\x06\x38\x89\x86\x63\x88\x94\x06\x71\xd7\x7a\xbd\x15\x88\x16\xd3\x10\x72\xff\x4c\x26\xd3\x22\x3f\xe7\x31\x3b\xe7\x90\x67\x93\xe5\xa3\x15\xb2\x2f\x92\xe0\xa5\x43\x21\x92\xec\xbd\xe8\xbd\x17\xa2\x37\x48\xf3\x41\x6f\x93\x6f\x47\x6b\x5b\x71\xbc\x31\x7a\x30\xd8\xde\x7a\xb0\x3e\x8a\xe3\x8d\x68\xb0\xde\xdf\x7e\xb8\xdd\x8f\x1f\xf1\xcd\xcd\xed\xe1\xfa\xda\xc6\x46\xbf\x27\x8a\x61\x6f\x56\x26\xa9\xe8\xd5\xec\x12\xdd\xf7\xc2\x57\x87\x55\x60\x9a\x56\x75\x2d\x07\xea\x4e\xd0\x9c\x67\xd2\x3d\xef\x99\x54\xee\x00\xca\x5b\x1b\xc3\x11\xfa\xc9\x76\xb5\x1c\x55\xe1\x85\xfb\x7b\xac\x4f\x12\xf6\x55\xca\xff\xc9\xd6\x9d\x84\x7d\xf3\xa4\xb0\x61\x9e\x89\xdc\xe4\xc8\x55\xbf\xf0\xb5\xa9\xe9\x3d\x07\x5e\x28\x13\x22\x0c\x59\xcb\x63\x36\xc9\x0b\xce\xca\x71\xa4\x23\xcc\xab\xcc\x8f\x30\x77\xc0\x08\x96\x03\xed\x20\xba\x8d\x36\x6b\xfc\x9e\xcf\xb4\x91\x12\xc4\xfb\x91\xa7\x48\x9e\x85\x2b\x48\xae\xc5\xc6\x12\x9e\x95\x4c\x24\x31\x87\x36\x9e\x8f\xd8\x65\x3e\x63\x71\x8e\xef\xdc\x17\x89\xe0\x6d\xf8\x52\x46\x67\xf8\xda\x58\x24\xe2\x4c\x72\x26\x60\x3d\xcc\xb3\x51\x9a\x0c\x21\x91\x09\x5d\x19\x18\x8b\x42\x4d\x8a\xf7\xb6\xe8\x85\x98\xd7\xd1\x70\xcc\xf3\x31\xe6\xc2\x14\x72\x77\x34\x06\x49\x84\x25\x70\x9e\x6e\xe1\xb5\x96\x36\xfa\x0f\xd6\xe7\xfd\xea\x5b\xad\x1c\xf8\x04\xde\x2c\x60\xb4\x11\x9b\xf0\x49\x5e\x5c\xb2\x94\x47\x67\x40\xae\x37\x6a\x61\xee\xdb\x65\x6c\xec\x3a\x04\xae\xe0\xd3\x22\xbf\xc0\x1c\xd8\x93\xd9\x70\x6c\x69\xe1\xbe\xb2\x1a\xbe\x5b\x8a\xcb\x49\x98\x7f\x95\x8b\x7f\xd8\x50\xe1\xfc\x15\x26\x4e\x5e\x46\x08\x13\x0f\xa7\xcd\xdd\xbb\x48\xd8\x6e\x0e\xce\x3f\xa2\x3b\xe1\x65\xe4\x3d\x97\xf3\x32\x82\xcb\x9e\x0f\x46\x52\x92\x1e\x45\x59\x52\x26\x7f\x22\x43\xa8\xc8\x53\x91\x30\x39\x0a\x67\x02\xcd\xde\x62\x7e\xce\xd3\x7c\x3a\x91\x1c\x56\xe6\x26\xa1\xc2\xd8\xf0\x21\x8f\x6d\x9b\x96\x7d\x74\x32\x60\x85\x89\xfc\xc7\x04\xb4\x93\xfb\xea\x6b\x08\x6a\xd7\xec\x1d\xdf\x59\xfd\xdb\xf7\x7f\xbf\xdb\x68\xb6\xee\xdd\x6f\x77\x7b\x3b\xbb\xec\x1f\x7b\xff\x7c\xfc\xc3\xf1\x1f\x7f\xfc\x71\xf2\x7f\xdf\x7d\xfc\x74\xf5\xff\x3f\xe9\x9d\xb6\xda\xac\xd1\x51\x21\x62\x09\xc1\xa0\xed\xfb\x0c\xc3\x24\x9a\x5c\x09\xf4\x43\x88\x90\x3a\x37\xfc\x02\xf8\xab\x2f\xf4\xe4\xdb\xbf\xcd\x58\x3e\x5f\x5f\xac\xfc\x62\xee\x3d\x5f\xea\x09\xf8\xbf\xdc\x19\xe7\x1b\x75\xd6\x70\x0c\x5b\x41\x12\x16\xfb\xf2\x88\xd3\xb9\x62\xc5\x61\xa1\x7e\x7b\x11\x9d\x50\x74\x68\x82\xdd\x6d\x1b\x76\x0a\x6a\x14\xa5\xd2\x44\x9a\x60\x2d\x5e\x5b\xd5\x88\x2d\x1e\x00\xb6\x2b\xf7\x64\xaf\x80\x6c\xce\x77\x00\xa6\x2b\x87\x59\x24\x31\x17\x10\x1a\x2f\x53\x52\xb1\x5f\x78\x2c\x0b\x4e\x2a\x5b\xb5\xf3\xbc\x6c\xad\x9e\x6c\x9b\x7b\x2c\xd8\xd0\xae\x37\xd2\xdf\x92\x72\x7c\x48\x2a\xd5\xbd\xee\x5f\xb5\x55\x05\xbd\x07\x86\x2c\xb9\x4c\x5f\xad\xee\x28\x2f\x0e\xa2\xe1\x98\xd8\x73\x9d\xf1\x4b\x3b\x8a\x1b\x1e\xba\x01\xdc\x21\x5a\x73\xf0\xe8\x95\xd7\xfe\xb2\xb8\x04\xbb\xa8\xdc\x50\xc8\xa4\xe1\x87\x43\x35\xce\x39\x9e\xb9\xfc\x43\x22\xca\xae\x71\xe2\xec\xf5\xd8\xf7\xf2\xd2\xf0\x2c\xf9\xf0\x82\xb3\x0e\xe4\xaa\x62\x89\xc8\x1a\x25\x13\x93\xa8\x28\x19\xcf\xf2\xd9\xe9\x58\x41\x37\x9e\xa9\x83\x09\xec\x34\xd5\xd6\xfe\x0e\xfe\xc8\x47\xec\x9d\x37\x21\x5d\x6a\xc3\xf5\x6e\xbe\xe9\x14\x0b\x4d\x97\xce\x57\x54\x6b\xd1\x59\x4f\xa6\xdc\xf9\xad\x85\x29\x3d\xb7\x0e\x8f\x39\xd5\x2b\x61\xbc\xd0\x7e\x11\x96\xd4\x8e\xfa\x17\x69\xa7\xce\x7c\xeb\x54\x0b\xc9\xa0\x77\xec\xcb\x9c\x63\x19\x31\xe6\x93\x24\x3b\x3d\xc8\x94\xd1\xff\x52\x8b\x4f\x1f\x91\x01\x45\x83\xbf\x25\xcc\x3d\xa7\x3e\xfb\x1c\xfd\x0f\x47\x23\xab\x3b\x1a\x71\x16\xe0\x4e\x44\x6d\x1e\x9b\x90\x33\xcb\x98\x79\xd2\x6e\x12\x2e\x9a\x65\x54\x9c\xf2\xb2\x6d\x82\xbf\x91\xe4\xe0\x2a\x31\x38\xfb\x07\x16\xda\xa4\xe0\x90\x10\x1c\x6d\x49\xb9\x18\x16\xc9\x14\x3d\xff\x30\x24\x5c\x72\xb2\x4b\x3e\x77\x79\x36\x9b\xf0\x02\xc2\x86\xee\xd5\x7c\xff\xf4\x49\x85\x33\xa4\xe5\xf2\x6e\x90\x9c\xce\x74\x4d\xc8\x36\x04\xbb\xe8\x2a\x8c\x7e\x15\x25\x44\x0d\xde\xa2\x55\x2f\x8a\xa4\x74\xaa\x85\x49\xac\x47\x4e\x6a\x9e\xf1\x4b\xfa\xbb\x85\x99\xc0\x2a\x77\x8c\xfd\x3c\x13\x65\x31\x1b\x96\x79\x01\x84\x2b\x73\x88\x23\xd8\x06\x9f\x8d\x64\xf8\x4a\x93\x52\x49\xe4\xaa\xb8\x55\x25\x3e\x69\xc8\x26\x2d\xa3\x4d\xb6\x76\x55\x76\x7c\xd2\xee\xbc\x56\x5c\x14\x4c\xae\x32\x02\xb1\x0b\xa7\x6f\x93\xb8\x91\x46\xc3\x5a\xa5\x94\x0b\x35\xdf\xdd\x34\x1a\x96\x24\x0a\xb1\x52\xb3\xd4\x34\xbc\x56\x85\x9c\x1f\xb2\x58\x01\xd9\xcc\x37\xfa\xb8\x0e\x3e\xff\xd8\x70\xc8\x47\x49\xcc\x7f\x8c\x6a\x33\xe0\xf5\x2b\x90\xf3\xd0\x50\x20\xa6\xca\xbf\x79\x14\xd7\x06\x7e\xde\x7e\xb0\xe9\x01\xce\x6b\x1a\x21\x4c\x85\x17\x51\x52\xe7\xae\xbb\xfd\x60\xdb\x01\x9b\xd7\xaa\x2c\x37\xc0\xfb\xf3\x9c\x80\x1f\x7d\x1d\xff\x5c\xdb\x41\x99\x4b\x9e\x9c\x4d\xe4\x3a\x85\x7c\xe1\xcd\x08\xe2\xdf\x02\xbb\xc3\x87\x6e\x22\x6c\x41\x75\x63\x6a\xb3\xa8\x00\x92\x1a\x20\xb5\x3f\xb5\x70\xcb\xb2\x1f\xcc\x86\x25\x2b\x1c\x27\xf2\xe4\x8c\x8a\x02\xf6\x29\xb3\xb6\x65\x11\x49\x43\xa8\xbe\x22\x1e\xa3\x22\x9f\x00\x12\x2a\xd7\x9f\x1d\x04\x5c\x3a\xf7\xa3\x34\xdd\x1f\xf3\xe1\x59\x33\xc9\x44\x19\x65\x43\xde\xa6\xeb\x4d\x8f\xe9\x8e\x29\x66\xfa\x8f\x7c\xe4\x00\x4a\x48\x0c\x48\x2c\xaf\xa9\x92\xdf\xd1\x90\x78\x75\x3f\xca\xa4\x88\x22\x4f\x2b\x16\xa9\x9b\x6e\x44\xb5\x8d\xab\x55\xd4\xa6\xb9\x10\xc9\x40\xde\x2b\x4d\x07\xa8\xa5\x6c\x0a\x9e\x8e\xda\xd0\x98\x41\x4d\x7e\x72\x7b\x7f\xcd\x95\xa9\xbb\x42\x01\x12\x36\x8c\x23\x10\x80\x06\x9c\x67\x2c\x91\x57\xf8\x28\x4d\xe4\x5d\xbd\xc3\xc4\x6c\x0a\x49\x08\x29\x84\xec\x81\xc7\x88\x9a\x89\x37\x9b\xa6\x92\x65\x74\xb4\x68\xf8\x2d\x0f\xf7\x55\xf4\xee\x59\x95\x47\x41\xa5\xcc\x8e\x92\x3d\xc6\xcf\x3b\x90\xfa\xd3\xe3\xa8\x24\x1b\xf3\x22\x29\x45\x53\xcc\x06\x70\x08\xb6\x11\x2d\xf8\x5b\x0f\x55\x0b\x18\xa6\x00\x85\x4f\xd3\x85\x4a\x80\x47\x0b\x75\xda\xc9\xe0\xd4\x1c\x49\x58\x79\xe6\x17\x5c\x80\x86\x74\x32\x13\x25\xe3\x09\x78\x2e\x0d\x38\x26\x2e\x86\x68\xdb\xba\x8b\x36\x88\x9b\xab\xca\x9f\xc7\xc1\x05\x48\xa5\xb1\xb7\xe7\x81\x8d\xe6\xaa\xae\x30\x04\x41\x07\x5d\x7a\x84\x7c\x04\xbd\xa1\x9a\xf9\x1d\x38\xad\x41\x66\xb0\xc4\xb1\x07\xb0\xf2\x40\x69\x33\x7d\x70\xea\x3c\xfd\xf4\x0c\x56\x69\xf9\xaf\xa4\xb4\xa8\x33\x07\x1a\xe2\x2a\xfc\x04\x2f\x5f\x69\x14\x0e\x47\xec\x71\xf8\x7b\xcd\x04\x59\xdc\xba\x6f\xdf\xc2\x48\xde\xbe\xc5\xc0\xfb\x0a\x44\x52\xa7\xd7\x63\xfb\x26\xd1\xd6\xfa\x5a\xff\x01\x7b\x33\xe6\xec\x34\xef\x70\x49\x71\x3e\x9b\xb0\x27\xb3\x72\x9c\x17\x42\xde\x2e\xdf\x48\xa6\x1d\x25\x29\x5c\x1f\xa7\x52\x6a\x57\x3a\x50\x0a\x9f\x26\x83\x22\x2a\x2e\xb5\xea\xdb\x6f\x4e\x15\xcb\x16\x46\x05\xe7\x4c\xe4\xa3\xf2\x22\x2a\x38\x5e\x31\x86\x51\xc6\x0a\x1e\x27\x52\x9c\x1b\xcc\x4a\xce\x92\x92\x45\x59\xdc\x83\xe7\xc5\x38\x19\x5d\xca\x26\x93\x12\x84\xdf\x42\xa5\x37\x29\x26\x42\xe3\xf1\xaf\x97\xbf\xb0\x9f\xb9\x10\xbc\x60\xa8\xd2\x4e\xd9\x2b\x88\x0e\xcf\x7e\x56\x19\xbf\x22\x81\xf1\xe2\xc5\x98\xc7\x6c\x00\xcd\xc9\x8a\xcf\x24\x2a\x47\x0a\x15\xf6\x2c\x9f\x65\x71\x84\xcc\xa5\x58\x4f\x2b\xec\x37\x74\x57\xaa\xc1\x36\xcb\x0b\xd9\x48\x33\x2a\xe5\x00\x0a\x25\xae\xb7\x58\x94\x5d\xb2\x54\xde\xa0\x74\xd5\x25\x08\x62\xc7\x0d\xfa\x3a\xd9\xcd\x38\x9f\xaa\x9b\x55\x52\x52\x85\xde\x68\x96\xb6\x65\x6b\x83\x59\xc9\x7e\x7b\xfe\xe6\xdf\x87\xbf\xbc\x61\x4f\x5e\xfe\xce\x7e\x7b\xf2\xfa\xf5\x93\x97\x6f\x7e\xdf\x85\x87\xf8\x7c\x56\xea\xb8\xec\x9c\xfd\x7f\xec\x7d\x79\x73\x1b\x37\xb2\xf8\xff\xfe\x14\x70\x7e\xfb\x4c\x32\xa6\x48\x49\xbe\xe9\xf5\x66\x1d\xd9\xde\xe8\xc5\x57\x59\xf2\xe6\xa5\xf4\x54\x34\xc8\x01\x49\xac\x86\x83\x79\x33\x43\x49\x8c\xa3\xef\xfe\x2b\x74\xe3\x9c\x8b\x97\xa8\xd8\x89\x5d\x5b\x1b\x11\xd3\x68\x1c\xdd\xb8\xfa\xe4\xd3\x38\xe4\x2c\x20\x17\x34\x49\x68\x94\xcd\x95\xf2\xe1\xcd\xcb\x0f\x07\x3f\x3d\x7f\x7b\xfc\xfc\xc7\xc3\xd7\x87\xc7\xbf\xca\xc5\xf5\xea\xf0\xf8\xed\xcb\xa3\x23\xf2\xea\xdd\x07\xf2\x9c\xbc\x7f\xfe\xe1\xf8\xf0\xe0\xe3\xeb\xe7\x1f\xc8\xfb\x8f\x1f\xde\xbf\x3b\x7a\xd9\x21\xca\xd7\x45\xd6\x5f\x3c\xe7\xa8\x1c\x4e\x40\xa8\x4e\x79\x98\xea\x99\x70\x04\xe4\x20\xcf\x4d\xd8\x90\xf1\x73\x16\xc8\x3d\x59\xc4\xf3\xa5\x89\x2a\x71\xd1\x50\x44\x63\x34\x3e\xa8\x62\x48\x72\x08\x39\x80\xda\x24\x65\x8c\xfc\x5d\x65\x56\xba\xb8\xb8\xe8\x8c\xa3\x59\x47\x24\xe3\xae\xca\x0a\x97\x76\xff\xd1\x01\x61\x0a\xbe\x7c\xa0\xfb\x12\xe7\x0b\x9a\x4e\x06\x82\x26\x81\xd5\x8e\xa3\x61\x83\xb9\x3b\xd9\x60\xd7\x50\xa2\x45\x18\x9e\x17\xaf\x35\x9a\xa7\x71\xac\xfc\x9f\x6d\x19\x3c\xe9\x45\xca\x55\xf6\xe7\x84\x85\x34\xe3\xe7\x36\x16\x12\xfe\x53\x21\xed\x54\x4a\xe7\xdc\xc7\x0b\x1e\x64\x93\x1e\x69\xec\xed\xee\xfe\x57\xee\xd3\x44\x67\xc3\x2e\xf9\xe6\xfa\xec\xe1\xfb\x5a\x7b\xa1\xda\x2f\xfa\x61\x68\x2a\x5e\x69\x77\xa4\x2b\xd4\xdb\xd9\x29\xe2\x68\x1a\x32\xa5\x2a\x7f\x14\x4c\x57\x5b\x69\xf1\x30\xcd\x02\x42\x5c\x4c\x44\xc8\x48\x4c\xc7\xac\x4d\xa6\xf4\x8c\xa5\x72\x93\x8c\x54\xba\x40\x43\x4f\x4c\xd2\x00\x26\x05\x21\x4f\x33\x16\x21\x59\xa6\x2c\x4d\xe9\x98\x39\x8a\x3e\x20\x3a\xa4\x66\x90\x47\xea\x50\xc8\xd7\xb0\x06\x6b\x93\x59\x1c\x80\xf2\x10\xfd\x41\xc7\xac\x91\x6a\x4f\x74\x32\x14\x49\xc2\xd2\x58\x44\x01\x8f\xc6\xe1\xbc\x83\x97\x3c\x3b\x20\xf7\x01\x28\xaf\x7e\x38\x22\x4d\x5c\x7b\x58\x9a\x1a\x6d\xe2\x80\xe9\x34\xbb\x1a\x85\x81\x6a\xe6\x62\x84\x93\xc2\x25\x48\xde\x14\xda\xb6\x82\x15\x9d\x6b\xcf\x12\xb9\x29\x3f\xab\xbb\xa0\x20\x06\xdb\x33\xe7\x38\xf8\xfd\x77\x7d\xa4\x8c\xfd\x23\xc5\xb6\xd7\xc2\x57\x3d\x22\xc1\xde\xba\x7d\x80\xf6\x3b\x09\x53\x54\xcb\x3f\x94\x3d\x1e\x83\xc5\x82\x94\x7c\x06\x07\xff\x2f\x6c\x70\x24\x86\x67\x2c\x6b\x36\x55\xb6\xb2\x50\x0c\x61\xe3\xc5\xa3\x77\x28\xd4\x95\x05\x35\xa4\xdf\x91\x1f\xc8\x77\x17\x69\xda\xeb\x76\xbf\x23\x3d\xf9\xa7\xfc\xab\x45\xee\x92\x7c\xed\x89\x48\x33\x72\x97\x7c\xd7\xa5\x31\xff\xce\xed\x2e\x48\x80\xa0\x0b\x1d\x11\x29\xbe\xf0\xfa\x2c\xb7\xcb\x2c\xdf\x71\xdd\xf9\x69\x3a\x26\xcf\xc8\x7f\x1f\xbd\x7b\xdb\x81\xdc\x1b\x08\xdd\x09\x68\x46\x5b\x4f\x0b\x35\x4c\x34\x00\x7c\x29\x74\x78\xfa\x76\x16\x86\xef\x92\x8f\x5a\x72\xd3\x6a\x4e\xd3\x71\xab\xac\x31\x62\x36\x8c\x22\xda\xab\x42\x09\xd2\x00\x99\x1b\x50\xfa\x95\xae\xaa\xc6\x3f\x0c\x45\xca\x6a\x29\x86\xe0\xd9\x31\x9f\x32\x31\xcb\x9a\x39\x62\xb7\xc1\x0c\xaa\xd8\x5a\x59\xc3\x6e\x1f\xbd\x26\x65\x7f\x73\xad\x6a\x0d\x6d\x28\xc6\x25\xc3\x41\x4c\x29\xcb\x8e\x32\x39\x5e\x8b\x29\x4e\xd8\x39\x94\x55\x91\x0f\x62\xe8\x63\xfb\x27\xa7\xc5\x89\xd5\x9f\x3b\x78\x28\x7d\xd4\x7d\xfd\x7c\x55\x84\x85\x67\x53\x94\xb2\xc4\xe3\x78\x2c\x69\x82\xd4\x03\x4d\xdf\xda\x24\xe4\x53\x5e\xca\x50\x6e\x93\x5a\x02\x79\x72\xda\x19\x8a\x68\x48\xe5\x54\x17\x1e\x74\x66\x7c\x28\x6b\x6c\x97\x3d\xfa\xb0\xd5\x56\x09\x37\xca\x7f\x17\x13\x79\x79\x6b\x7a\xad\x6a\x8b\xff\x7f\xd4\xf7\xb4\xd0\xdb\x4e\x3a\xe1\xa3\xac\x59\xd1\x52\x91\x49\x2b\x67\x58\x8f\x1d\xf3\x5f\x17\x10\x15\x8b\xe4\x75\xeb\x03\x6b\xe9\x17\x93\xd1\x7b\x4a\x6a\x99\x13\x23\xa6\x69\x46\xe4\xc2\xec\x94\xae\xcb\xdb\x8b\x17\x66\x67\xc2\xd3\x4c\x24\xf3\xca\x05\x8a\xea\x59\xd0\x40\x3f\x33\xb8\x5e\x3c\x3f\x7e\xde\xff\xf9\xe5\xaf\x47\x1d\xfc\x54\x3e\x3d\xb2\x6a\x96\xd0\xd1\x88\x0f\x4b\xeb\xaa\x6f\xe5\x95\x0d\x19\xb0\x85\xd3\x0a\x76\xf6\x40\x15\xc2\x3a\xd8\x15\xa7\x45\x8d\xef\x88\x4e\xe3\x50\x72\xdc\x32\x7c\x63\x3b\x5c\x89\xa8\x33\xa5\xb1\xb3\xa6\x59\xc8\xa6\x75\xa8\x49\xce\x25\xbe\xba\xeb\x12\x53\x47\x05\x03\xff\x81\xec\x92\x1e\xb1\x25\xe5\x13\x42\x1c\x8f\xf8\xb2\x7f\xf9\xd5\xa4\x46\x67\x17\x94\xee\xcd\xeb\xc3\x37\x87\xc7\x6a\x98\x8b\x06\x53\xc0\x56\xbb\xcc\x48\xe5\x52\x23\x95\xcb\xcd\x12\xa1\x7c\xc5\x55\xe3\x5c\x95\x43\x14\xd3\xad\xc4\x22\x0e\xa3\x56\xa3\xfa\x8a\x99\x44\x8f\xaf\x8a\x4b\xd4\xf7\xa5\xd9\xc4\xe0\xbb\x76\x3e\x71\x28\xb1\x0a\xa3\x14\x4b\xba\x5d\x72\x88\x47\xa5\xdc\x98\xe5\xbd\x4f\xee\xcb\x24\x55\xb4\x5c\x7b\x7f\x56\x0b\xaa\x6a\xaa\xd4\x61\x5c\xb5\x31\xb7\xc9\xc9\xd2\x6d\xf8\x2c\x91\x2f\x3f\x6d\x97\xaf\xf4\x65\xae\x6e\xcb\x8e\x55\xb3\xc5\xca\x83\x55\x15\x97\x1b\xad\x02\x2e\x0e\xd7\xfb\x50\x18\xaf\xee\xdc\x75\x0e\x38\x14\xd5\x37\xe3\xca\xc1\x86\x62\x9c\xb6\xc9\x89\xaa\x5f\xe8\xa7\xc4\x59\xd6\xc7\x42\x91\x9b\x73\x89\x66\x39\xd6\x77\x57\x7b\xf1\x86\x3b\x9c\xd0\x68\x2c\x1f\x61\x2a\xb5\x9d\xdd\xa5\x30\x60\x5b\x7e\x4c\xeb\xdd\x66\x4d\xd2\x2c\x05\xd3\x41\xe4\x20\x5f\x55\x7f\xfe\x40\x3e\x9b\x18\x71\xaa\xe8\x8a\xf4\x0a\x97\xd9\xfa\xd1\x88\x98\x45\x56\xe5\x53\xfd\x4e\xc8\x8d\xe2\x33\x58\x30\x82\xf3\x06\x0a\x39\xeb\xa7\x4c\x3e\x43\x36\x6b\x05\x23\xfe\xd4\x37\x93\xaa\xab\xbf\x8f\x53\x4f\x91\xe6\x94\xe3\xe7\xff\x3a\xea\x4c\xc4\x94\x75\x78\xd0\x96\x5b\x97\x9a\xbb\x29\x8b\x66\xfe\x2b\xca\x1d\x21\x40\xc2\x50\x39\x0a\xad\xe4\xd7\x01\x05\x0b\x44\x39\x87\xc6\xb2\x0e\xff\xe1\x06\xd1\x23\x27\xa7\xbe\x10\x46\x2d\xa4\xe2\x07\xc9\xd8\xc5\x52\x77\xbb\x96\x94\x75\x07\x9f\xe3\x14\x98\x02\xcf\xca\xa5\xdb\xb5\x82\x99\x17\x3c\x78\x03\xb9\xca\xf1\x4e\xad\x45\x24\x2c\xcd\x28\xc8\x4a\xc1\x64\x50\x89\xe3\x46\x3c\x49\x33\x72\xc1\x06\x29\xbc\xdc\x5d\x71\x0d\x1d\x65\x4a\x2a\x6b\x30\xa3\x25\x75\x14\xb0\x84\x05\x9d\x5b\xd8\xb2\xab\x58\x77\xe5\x25\x27\x96\x32\x67\x6c\xde\x23\x8d\x42\xff\x1c\x99\x95\x12\xbf\x5b\x6b\xa4\x3c\x6c\x81\x7b\xfc\xb7\xab\x7b\x52\x3a\x3b\x40\xb7\x4b\xac\x2c\xc3\x8c\x9f\xa5\x84\x96\x0f\x39\x27\xa1\x6a\x7b\xe2\xa9\xbc\x00\x2a\x75\x9b\xa1\x51\x40\xb2\xc4\x64\x8c\xd7\x6d\xc2\x50\x0c\xfa\x50\xa4\xa9\x9e\x36\x55\x4f\x3d\xa1\x69\x44\xc3\xf9\x6f\x8a\x50\x45\x49\x97\xc4\xee\x4a\xbb\x86\x13\x9a\x64\x69\xa3\x46\xdc\xe5\xb6\x71\x8c\x35\xa2\x31\xd3\x54\x57\xab\x00\x42\x60\x6a\x63\x65\xbd\x64\x2d\xb1\x41\x40\x9d\x25\x7c\x3c\x66\x90\x10\x95\x5d\x28\xe2\x6b\x71\xf6\x1b\x4f\x1e\xd8\xb9\xa5\x6c\x57\x48\x9e\xf2\x58\xab\x86\xdc\x08\x50\xa0\xb1\xee\xbb\x64\x2d\x96\x7a\xf9\xbd\x79\xf4\x1f\xb4\xe8\x1e\x60\x02\x79\x94\xee\x36\x5b\x9d\x82\x88\x4a\xd7\x7e\x86\x2c\x83\xb6\x1a\xaa\xf0\xe9\x2d\xff\xb4\xd0\xcb\x0b\xf5\xf9\x26\x88\xa3\x9f\x58\xb7\xb0\x7d\x37\x02\x7e\x9e\x93\xbf\xca\x7f\x9f\xb1\xe9\xb7\x20\x14\x56\x0d\x76\xb4\x98\x58\x9b\xf8\xb8\xff\xea\x9b\xd5\x6a\x72\x1b\x2b\xa9\xfc\x38\xc5\x0d\xaa\x47\xec\x2e\xd9\x51\x9b\x5b\xb1\x45\x0d\xaf\xa0\x9d\xf3\xa1\x78\xae\xb6\x56\xee\xb0\xb6\x19\xb8\xee\x1e\xc3\x09\xa3\xc0\xdd\xd3\xa6\x02\xda\x3d\xc2\x75\x2d\xb7\xec\x3a\x86\x0a\xa6\x06\xd7\x3d\x4e\x7d\x98\x39\xf0\x58\x54\x0e\xae\x8f\x21\x07\x5c\xdd\x8d\x4b\xc1\xcd\xe9\xe4\xc0\xeb\xeb\x65\x69\x05\x3c\xb5\x1c\x68\xb8\x9f\x95\x82\xfa\x47\x99\x3b\x5e\xe7\x43\xc9\xbc\x7b\x45\xde\x96\x0e\xff\x7f\x9a\xb3\xc4\x33\xa7\xcd\xd3\x5b\x57\xca\xc6\xa6\xe3\x49\xe9\xad\x90\xdc\x35\xb9\xd1\xd1\x05\x61\x45\xf6\x5c\x23\x1b\x43\x5e\x54\xb8\x77\x78\xaa\x4c\x3c\x82\x0a\xef\x50\xb8\xfa\xaa\x30\x4c\x76\x1b\xd2\x26\x86\xad\xa6\x27\xe8\xcf\xd9\xc9\x5d\x67\xe2\x89\x6f\x76\x72\xdf\xec\xe4\xfe\x50\x3b\x39\x65\x1b\x6d\x8d\x31\x68\x9a\xf2\x71\x04\x44\x31\x03\xc6\xa9\x2a\x70\xc7\x9e\x36\x49\xf2\xa3\xd6\x78\x1c\x92\x8a\x59\x02\x11\x39\x6d\xd8\x1a\xc9\x21\x06\xcf\x19\x9b\x63\x7e\x72\x09\xa6\x27\x4d\x75\xc5\x4c\x49\x67\x42\xd3\x77\x17\x91\x26\x1d\xaa\xc2\xb0\x4a\x5b\x62\x40\x1b\x23\xe8\xa4\x16\x63\xe3\x57\xf8\x85\x54\x34\x74\x44\x38\x98\x87\x6f\x66\x17\xdf\xcc\x2e\xbe\x99\x5d\x94\x98\x5d\xfc\x05\x4c\x68\x31\x58\x45\xa5\xa3\xf5\x83\x1c\x60\x5d\x27\x10\xc2\x54\xd0\x71\x15\x3e\xf2\xaa\x5e\xdc\xb3\x36\xb4\xaf\x79\x5a\x39\xc7\x8f\x1f\x79\x60\x75\x5d\x90\xdf\xad\x49\xec\x84\x9d\x27\x22\x52\x41\x28\xcb\xad\x6d\xef\x95\x41\xd7\xb5\xe0\x80\x7d\xa1\xb6\xb7\xdf\xcc\x56\xbf\x99\xad\x7e\x33\x5b\xbd\x41\xb3\xd5\x32\xf3\xbc\x82\x34\x6a\x23\xe3\x3c\x8c\x35\xf4\x1e\xf3\x9c\xac\x6a\x9f\x57\x67\x67\xa7\xcc\xf3\x8c\xee\xe2\xc3\xf3\x5f\x5e\x7e\xe8\xff\x72\xf8\xe2\xf8\x27\xfb\x78\x6d\xe7\xfa\x81\x82\x9c\x9e\xb9\x34\x37\xfd\x1e\xd5\xda\x03\x42\xfc\x9e\xc3\x8c\x4d\xd3\x1e\x69\x0c\x99\xdc\x0b\x73\x10\xff\x99\xa5\x19\x1f\xcd\x8d\xc0\x03\xb0\xec\xb0\x28\xc8\xc1\xa9\xf0\xbd\x3d\xd2\xd8\x25\x8f\xe3\xcb\x86\xd3\x5f\x65\x32\x88\xd1\x67\x3b\x26\xa0\xed\xe7\xbc\x74\x3b\xc2\xa9\x7b\x31\x4b\xa8\x9f\xed\xd2\xfe\x83\x1e\x6a\x1b\x44\x5b\x25\xed\x04\xaa\x52\x07\x20\x78\x34\x3e\x1a\x26\x8c\x45\x45\x79\x02\xbb\xe4\x59\x2d\x82\x90\xd1\x73\x53\xdf\xd7\x86\xd8\x31\xa1\x68\xc1\xda\x36\x6a\xfe\xd2\xc6\x8b\xd4\xc8\xf8\x5d\x79\xa6\x64\xb9\x32\x55\x46\x9d\xc9\xa0\x16\x46\xd5\x19\x0c\x2a\x98\x65\xcd\x05\x1d\xcf\x1a\x0d\x08\x3e\xfd\x7c\x78\xf6\x0e\x04\xcc\x19\xe5\x51\x4a\x44\x74\x20\x8b\xe0\xb2\x9a\x99\xc6\xec\x9a\x9a\xb2\x68\x46\xb8\xe4\x9d\x8e\x8b\xe7\x10\x0e\x2e\x50\x14\x60\x68\x0b\x01\xa7\x1d\x8d\x02\x92\xb0\x59\x8a\xf6\x38\xe0\x00\xca\xa3\xb1\x83\x16\x83\x0e\x40\x5b\x20\x93\xb6\x91\x34\x5c\xec\x72\x6b\x75\x2d\xaa\xe0\x8c\x4c\x65\x1f\x93\x39\xc9\xf8\x54\xc5\xbd\x40\xb9\xf2\x94\x65\x13\x81\xe6\xa6\x28\x76\x66\x41\xc7\x11\x1a\xaf\x62\x1f\xa9\xe6\x6c\x19\xeb\x48\x3d\xbd\x4b\xd9\x46\xea\x59\x47\x43\x32\xbf\x73\xa1\x10\xb1\xcb\x27\x50\xe0\x7b\xf8\x5a\x68\x1e\x38\xb6\x42\xc7\xcf\xff\x75\x84\x76\x58\x3c\x28\xb3\x8f\x53\xad\x9e\xf0\xe0\x74\x39\xfb\x46\x34\x65\x54\xf4\xd1\x97\xa4\x12\x75\xa9\x6b\x9c\x87\x75\xf0\x5d\xdb\x39\x63\x65\x2a\xef\xbe\x2b\x43\x77\x85\xa8\x4d\x1e\x2c\x67\x39\x98\x7f\xb1\xbb\x33\x50\xd0\x10\x9a\xf9\xcb\x8b\x02\x49\x9d\x2e\xcc\xd3\x48\x99\xe5\x58\xd0\x47\xad\xab\x95\x30\x7c\xb8\xaf\x74\x0a\x39\x83\xcc\xaf\x44\x6b\xa1\x1f\x24\x7e\x76\x19\xf7\x5f\xb9\x14\x1b\x73\xdd\x34\x62\xf9\x20\x4f\x25\xe9\x4b\x54\x1f\xc4\x95\xaf\x7e\xd6\x09\xc6\xb4\x0e\xc4\x39\x8d\xcb\xd4\x20\xc4\x57\x4a\xe0\xd0\x4b\xd4\xae\xc4\x3f\x5b\xcd\xb8\x56\x9b\x06\x52\xad\xc0\x91\xff\xe4\x55\xaf\xfc\xcb\x1a\xed\x2c\x68\x8b\x54\x29\x8d\xdc\x6b\x43\xd5\x8c\x6d\xd0\x25\xa8\x6a\x5f\x9b\x9d\xc3\xa1\x88\x7e\x84\xdc\xcf\xd5\x4d\x61\x5f\xd5\x89\xd3\xf3\x99\x54\xa4\xa5\xea\xad\xe5\x7b\xea\xbd\x25\xad\x56\x05\xee\xec\x95\x68\xcb\xbf\x94\xa8\x72\x16\xb7\x5f\x3d\xc1\xf0\x7e\xae\x5e\x31\xfa\x5f\x35\xd7\xc8\x7f\xea\x14\x42\xe3\xde\xa6\xb7\x01\xe6\x4c\xe1\x32\x5a\xb0\xa6\xce\xff\x5b\x6f\xf1\x97\x0e\xac\x23\xff\x4f\xde\x2d\xeb\x69\x47\x80\xf4\x3a\x39\x38\xbe\x29\x60\x47\xcd\xe8\x18\xcc\x2c\x0c\x57\xe0\x2e\x69\x0e\x2f\xfc\x7e\xba\x88\x37\xc8\x62\xfe\xf0\x7a\x7b\xcc\x2e\x33\xf9\x34\x32\x49\xb7\x64\x3b\x19\xcf\x42\x96\xd7\x28\xe5\xff\xd5\x99\xd7\x55\xb0\x53\xa1\x74\x55\x9d\x95\x3a\x8f\xaa\x34\x56\xfa\xda\xb2\xa9\xbe\x4a\x47\x9b\x40\x8d\x63\x59\x95\x81\x10\x61\xa1\x82\x52\xad\x96\xc1\x4b\xae\x2c\xc2\xfb\xca\xd5\x25\xea\xad\xa9\x48\x73\xae\xc0\x39\x35\xda\x17\x96\xa9\x47\x0f\xcd\xbc\x54\x0b\x29\xd8\xb7\x1a\x50\xe9\xe6\x53\x04\x7d\x29\xe9\xdf\x31\x91\xb8\x2f\xab\x28\xef\xc2\xe3\x0a\xf0\xda\x0c\xe4\x1e\xa4\x55\x96\x7a\xcf\xb5\xaa\x31\x3f\xa9\x80\xaf\x1b\x6a\x0e\x73\x99\x7a\xb6\xaa\xb9\xbd\xdd\x32\xe8\xda\xc6\x1c\xa4\x56\x70\x5e\xf5\xc4\xaa\x6c\x77\x6f\x71\xdd\xba\x5e\x54\x37\xe8\x24\xb5\xc7\x57\x76\x65\x17\x8a\xa0\x75\x2d\x1a\x74\xdb\x8d\xf7\x01\xb4\xc4\xd8\x8d\x15\x7a\x82\x12\xd0\xda\x34\xf3\x06\xca\x06\xbb\x10\x01\x0d\x2b\x67\xe5\x91\x0f\x57\x1b\x15\x43\x02\xd8\xb8\x6b\x66\x2f\xae\x52\x01\x94\x80\xd6\x46\x69\xb3\x9b\xbb\x89\x2d\x12\xf2\xa0\x32\x54\xad\x93\x7e\x1f\xe0\x6a\x23\x90\x48\x00\x03\x8e\x0f\x8c\x8a\x5d\xe8\xbe\x0f\x56\x87\x15\x00\x0c\x38\xa6\x98\xae\x24\xa4\xc5\xeb\xc8\xaa\xaa\xa6\xee\xfe\x97\x16\x87\xf9\xad\xa8\x24\xc4\xde\xd2\x11\x83\x01\xc9\x82\x88\xc1\xdd\x2e\xf9\xa7\x5a\x7c\x2c\x30\x17\x20\x02\xbc\xb7\x52\x8f\x8f\x0b\x52\xc8\x2a\xca\xec\x2e\x3d\x80\x12\x9c\x8b\x02\x20\x7b\x51\xf7\x24\x17\xbe\xe0\x09\x1a\x7d\x36\x69\x34\x9c\xb8\x19\xa5\xf1\x37\x06\xed\x0a\xd9\x28\x6b\xe4\xa4\xd6\x0d\x30\x23\x68\x40\x48\x31\x0c\xb8\x92\xaf\x85\x00\xf9\x6a\x80\xab\xa6\x56\x26\xe2\x42\x9d\x40\x5c\x44\x0d\x13\xbc\x0c\x34\xf0\x4e\x0d\xcc\xbc\xde\x68\xd9\xb8\x66\x8d\x59\xdc\xb0\x59\x7e\xf4\xb6\x50\xb8\xf2\xd4\x08\xe7\x3d\xd1\x7c\x20\x86\x67\x2c\xb0\x62\xe3\x51\xc8\x2e\x41\x1e\xbd\x4b\xe8\x2c\x13\x0d\x65\x4f\x0a\xff\x89\x7d\xe1\xbd\x38\x67\xc9\x28\x14\x17\xbf\xf6\x48\x03\x60\xf5\x9b\xa2\x42\x7a\x2e\x7f\x18\x9a\x80\x31\x72\x38\x9b\x46\xe6\xb3\x2b\xe3\x3f\x9f\x78\xb5\x64\xa1\xee\x90\x2e\xc7\xa4\x00\x5a\x2a\x8d\xbf\x3a\x26\x73\x81\x86\xfa\x85\x0d\xce\x78\xf6\x4e\xf5\xf4\x68\x98\x88\x30\x44\x89\x7b\x26\x66\xc3\x49\x03\xcc\xcc\x9f\x07\x01\xe1\xef\x8e\xc8\x54\xc8\xa7\xcd\x6c\x4a\x52\x0d\xa7\x85\x42\xdd\x2e\xc9\xd8\x34\x16\x60\xe0\x00\x33\xaa\x3e\x38\xaa\x8b\x11\xbf\x64\x56\xc0\x9f\x89\xb8\x47\x76\x0b\xb3\xf7\x1c\x68\x8b\x69\xfd\xf4\x3c\x86\xf0\x6b\x57\xd7\x4c\xd4\x34\x94\x4f\x3f\x22\x50\x09\xff\x7c\x0c\x3e\x11\x14\x9a\xaa\x2e\x1c\xcb\xfe\x7d\xf6\x3a\xdb\x2e\xef\x0f\xb2\x60\x15\xfa\x02\xf5\x3c\xa8\x29\xbd\xfc\xc9\x27\x6b\x45\x77\x7e\x54\x8d\x78\x3d\xf2\x71\x55\x74\x2b\x3f\x6f\xd7\xd5\xa3\x17\xb0\x30\x7c\x4a\x0d\x44\x12\x30\x3d\xf9\x8d\xbd\xf8\x92\xa4\x22\xe4\x01\x24\xe9\xf2\x43\x3c\x40\xd2\xf8\x80\x9f\xf3\x80\x25\xb5\x0d\x78\x74\x40\xfc\x7a\x2e\xae\xa7\x81\x1c\xab\x60\x13\x38\xac\xeb\x69\x20\x4f\x3a\x6c\x01\xc6\xb5\x56\x03\x53\x79\x00\xf5\xc8\x67\x08\xa5\xf3\xdf\xb3\x34\x23\x10\x81\x22\x15\x24\x66\x22\x0e\x19\xd8\x56\x99\x58\x99\xe8\xa8\x3c\x0f\x21\xa8\xb2\xd2\x2d\xad\x70\x76\x3d\x57\x7b\x6d\xd5\xd1\x22\x22\xf6\x6e\xd4\x3c\xc1\x9d\xbd\x8d\x3b\x78\x5b\x6f\xff\x6d\xb3\x3f\x9f\xb6\x56\x6b\xf6\x58\xe5\x9e\xaf\x6f\x34\x66\xc9\x94\x46\x20\xde\xf5\x85\xbd\xa4\x61\x76\xa3\x95\x9b\x06\x7b\x42\x9d\x9b\xe4\xfb\xef\xe5\x94\x7f\x0f\x12\x11\xcc\x9c\x8c\xf1\x44\x20\xeb\x32\x5a\xd5\x80\xad\x16\x8d\x63\x46\x13\xd8\x0d\xbf\xef\xde\x22\x04\x8f\xa8\xde\xc6\xb3\xd6\xbe\xe5\xf6\x02\x44\xf6\x28\xc7\x30\x96\x70\xd8\x0b\xdb\xf2\x70\xc2\xc3\x20\x01\xc9\x34\x6a\xf9\x57\xba\x56\xe5\x43\xe4\xae\x50\xd9\x91\x9f\xac\x5f\xb1\xb7\x52\x77\x2b\xe7\x37\x9d\xd0\x98\x35\x57\x40\xd5\xf2\xa4\x46\xee\x9c\x7f\x04\x13\x3c\x92\x09\x82\x72\x0c\xbb\xa0\x24\xd1\xc1\xce\x2e\x13\x4e\xf6\x1a\x87\x12\x46\x18\x56\xc1\x04\x20\x28\xf0\x5b\xfb\x27\x1f\x47\x02\x13\x37\x59\x1c\x28\x68\xaf\x1a\x2a\x04\x5f\x2f\xf2\x09\x0b\xd9\xb9\x97\x35\x20\xcf\x28\x06\xa0\x12\x35\x26\x8a\x2a\xa2\xd6\x5a\x6d\xa3\xb4\xb5\xcf\x88\x36\xe1\x11\x99\xf2\x30\xe4\x98\xa1\x5b\x4d\x07\x58\x00\x4e\xe9\x9c\xa4\x31\x1b\xf2\xd1\x1c\x54\xd9\xd1\x38\x64\xa0\x5d\x15\xb3\x0c\x50\x51\x70\xe5\x31\x2f\x12\xc8\x5f\xce\x23\xd8\x01\x67\x34\x0c\xe7\x2a\xd3\x13\x3c\x30\xd8\x30\xb3\x43\x29\x53\xf3\xaf\xc6\xfd\x65\x57\xf4\x35\xd7\x42\x09\xaa\xeb\xe1\xd3\x22\xe2\xdc\xf6\x60\x85\x4d\x2e\x6b\x42\x50\x63\x78\xb4\x7c\x02\xd7\x72\xb0\x1a\xd0\x33\x07\xe5\xb0\xe3\xad\xc4\xa6\x07\x34\x0c\x07\x74\x78\x46\x46\xb0\x6a\x2f\x54\x1c\x24\xc7\x2f\x4b\xa5\x23\x01\x0d\xfc\x80\xa1\xcc\x16\xf5\xe4\x9a\xd3\x63\x9a\xd0\x29\xf9\x8c\xe8\xaf\x94\x41\x00\x70\x2e\xfc\xa5\x8c\xa9\x75\xca\x0b\xd5\xa0\xe9\xb8\x88\x3e\x60\x0b\x07\x4a\x1a\x5c\xde\x79\x49\x3f\xbf\xeb\x87\x23\xf2\x29\x4b\x66\xec\x53\xdb\xdd\xc4\x95\xd3\xa4\x9d\x18\x54\xee\x55\x60\x1d\x08\x11\x16\xd6\xad\x88\x9c\x75\x0b\x27\xf9\x82\x29\xad\xdc\x72\x6a\xe8\x08\xef\xb6\x12\x3a\x42\xf9\xea\x74\x94\xd3\x0d\x86\x5e\x62\x54\xd8\x1f\x50\x87\x7a\x3d\x27\xb0\xb9\x75\x18\x4b\x54\xc7\x4e\x05\xf8\xfd\x6f\x39\x6b\x15\x90\xb5\x1b\xf1\x98\x8d\x8b\xad\x5e\x2f\xa4\x50\x0b\x34\x18\x36\xda\x15\x80\x35\xdd\xf0\xf0\xfd\x84\x8d\x9e\xda\x70\xeb\x7d\xd9\xbf\x36\xaa\x7f\x20\xc3\x7f\xe6\x46\x47\xcf\xc9\x40\x6d\xfb\x2a\x36\x96\xb1\x82\x25\xae\xb9\x40\x3f\x64\x91\x6b\xfe\xaf\x9c\x04\xda\xb2\x24\x35\x71\x4e\x25\x54\x0b\x23\xb0\xa3\xdb\x09\xfc\xf5\x77\xa8\x8d\x3f\xc0\xa5\x40\xdd\x16\x65\xd5\x93\xbe\xb2\xf4\xb7\x8e\x05\x50\x52\x96\x9a\x42\x8e\x84\x3c\x23\x4d\x18\x1f\xfe\x81\xe6\x28\x30\xae\x6a\x99\x67\x7e\x88\x4d\x39\x5f\xe4\x99\x1a\xaa\x6f\xa2\x02\xa8\x72\x72\xe9\x3c\x89\x94\xa5\x4a\x47\x72\xf0\x1c\x90\xb5\xc9\x89\x44\x6d\xe2\x0d\xc9\x91\xb5\x5a\x2d\x45\x03\xfd\xdf\x82\xd3\x74\xb7\x4b\x5e\x33\xc8\x66\x94\xa6\xb3\xa9\xb2\x91\x87\xe8\x78\xee\xfd\x2b\xbc\xa0\xf3\x54\xee\x34\xda\xf5\x97\x88\x88\xcc\x52\x96\x40\xd2\x77\xe6\xbc\x53\x7f\x01\xb3\x7a\x44\x83\x6d\xc9\xc5\x9f\x80\x9b\x81\x20\xe9\x19\x8f\xd1\xfd\x14\x6e\x74\xce\xd1\x22\x8f\x3d\x08\x44\x3f\x61\x16\x99\x32\x46\x25\x53\xf0\x65\xd6\x9b\x95\xb5\xce\x52\x4f\x74\x9e\xa4\x19\xb8\x08\x2b\x25\x0c\xde\xe6\x91\x07\x75\xb6\xf6\x65\x48\xe3\x70\x6b\xcb\x88\x44\x90\x61\x1d\x21\x7a\x71\xb5\x28\xbb\x92\x9c\x8f\xf3\x2f\x3c\x0c\x3f\xa0\x29\x3e\x6c\x1d\xea\x0d\x58\xe9\xe7\x9c\x87\x77\xac\x4e\x72\x6e\xf2\x46\xc1\xe8\x8e\x1c\x4c\x3d\xd5\x97\x2b\x37\x09\x90\xb6\xda\x2b\x31\x79\x59\x68\xee\x62\xcc\xe7\x7d\x33\x14\x57\x7b\x8b\x77\x71\xd9\x63\x30\xca\x02\x03\x00\x2c\x73\xa1\xf4\xbd\xd9\xc2\xe8\x12\x0f\xca\x98\xbc\xf4\x3d\x73\x97\x02\x8c\xce\xbe\xe6\x40\xc9\x22\x17\xce\xde\xd0\x0c\x9c\x29\x72\xe1\x8a\xb7\x1b\x5b\xa1\xf8\xcd\xad\x69\x4f\x77\x5b\xc3\x96\xb9\x90\xfe\x71\x6a\xa1\xfd\x72\xaf\x46\xec\xce\x95\xfc\xe5\x7e\xb5\xe7\x91\x85\xb1\x65\xde\xe8\xe4\x49\xe9\x0c\x08\x72\x7b\xb8\xdf\xd5\x4b\x50\x7d\x9e\xc7\x7e\x2f\xc0\xdc\x59\x6d\x6e\x55\xca\x3a\x67\xfd\x20\x73\x90\x93\x06\x32\x80\x3c\xa7\x34\x99\xe1\x6f\xa4\xa6\xf9\x53\x92\x4c\xfe\x30\x74\x81\x83\xad\x30\xe7\xb2\xd4\xce\xab\xfc\xe5\xcf\x1b\x94\xc4\xd8\x84\x9d\x05\xc0\x25\x87\x0b\x7f\xcc\x63\x86\x4f\x55\x87\xb1\x93\x2c\x34\xc9\x40\x02\x2d\x18\x54\xf2\xd5\x2c\x6c\x3c\x75\x40\xb5\x4c\xd4\xe1\x76\xfd\x99\x8f\x48\x53\x62\xba\x73\x87\xd8\x17\x27\x3e\x35\x4f\x3b\x3c\x1a\x86\xb3\x80\xa5\x5a\x04\xec\x9a\x72\xe4\x70\x3a\xe2\x60\xf2\x83\xc6\x40\x7a\x8e\x54\x97\xb8\x91\x0d\xc0\x67\xd2\x38\x9e\x2c\x67\xfa\xa1\x14\x1d\x45\xe3\x95\xcf\x65\xeb\xa6\xa7\x98\x03\x24\xc7\xe6\xb6\x41\x7e\x70\x56\x96\x23\xee\x92\xff\x30\x93\xa8\x32\x08\x29\x5b\xb2\x3d\xe7\xf8\x47\x0d\x97\x65\x1e\x6d\xe9\x04\x02\x9e\xb6\xde\x0a\x4e\x1a\x8e\xc0\x07\x32\xdb\x4b\x04\x4a\x03\xd3\x19\xd2\x98\x67\x10\x31\xee\x95\xdc\x09\x5f\xb3\x2c\x63\x49\x4b\x4f\xf6\x69\x5b\x27\x00\xf1\x14\xdc\x7e\xee\x96\xb2\x76\x50\xb0\xb4\x7a\x6b\x30\x5f\xb7\xfd\xf9\x6a\x59\xeb\x10\xc7\xe8\x45\xaf\x0a\x55\x60\x6d\x4c\xb5\x2f\x83\x4a\x49\x66\xee\x7f\x2e\xe3\xac\x6a\xef\x53\xb0\x37\xab\x4a\x65\xb3\x1a\xa1\x50\x74\xdf\xb6\x95\x5a\xf2\xac\x81\x2d\xc3\x33\xb9\x42\x2e\x35\x05\xad\x52\x56\x4e\x43\x1e\xf0\x68\xfc\x62\x55\x8e\x46\x85\x60\x91\xa3\xab\x86\xe8\x4e\x0b\x8f\x1a\x3d\x92\xdf\x5a\x03\xab\x21\xa8\x54\xe4\x78\x1b\x28\xbe\xb0\x7b\x25\xe7\x88\x77\x4a\xc2\x7d\xa7\x47\x6e\x3b\x9e\xf0\xf6\xf4\x76\x58\xc4\xd9\xdb\x5b\x79\xaf\x81\xc5\xdc\xa2\x1f\x08\x5f\x31\xbb\x78\x9c\x50\xc3\x35\xdd\xae\xdd\x9f\xcc\x72\xbb\xb5\xce\x90\x95\x42\x7c\x2d\x26\xfa\x91\x0e\xcf\x82\x44\xc4\x45\xe9\xc1\x22\x8e\x58\x69\xf2\x40\x28\xed\xce\x9d\x37\x63\x13\x71\x51\x64\xe4\xfc\x13\xde\xff\xed\x72\x1c\xd0\xa0\xed\x5c\x67\x1c\xec\x65\xd4\x70\x2f\x97\x98\x21\x49\x07\x63\x00\x28\x6b\xd7\x66\x67\xde\x0f\xc9\x80\x6f\x1e\xf5\xcd\x15\x08\x6b\xb9\xae\x3a\x47\x7d\x31\xda\xde\xc3\x76\x85\x30\x0a\x09\xa2\xfc\x4c\xfa\x4b\xbb\x98\xa0\x5b\x49\x39\x7c\xde\xa3\x04\xf6\x6e\x94\x5a\xa0\x4f\x95\x79\xc2\xbb\x67\x63\xb7\x4b\xde\x40\xd2\x6c\xbc\x99\x77\xe4\xc3\xbc\xc2\xd0\xcd\x31\x95\xc8\xa7\xa5\x6a\x93\xcf\x64\x14\xf2\xd8\xba\x6f\xf1\x6c\x72\x8c\x22\x0f\xb4\xb5\x8c\x80\x6d\x1a\x6f\x66\x1c\xe7\xb2\x41\xae\xcc\xc3\xb0\x60\x1e\xb7\xbf\xfb\x55\x67\x35\x5c\x6c\x4d\x77\xf3\x06\x6f\x5b\xc8\xb1\xf8\x45\xd9\xd0\x6d\xd5\x3e\xf1\x9b\x81\xde\x37\x03\xbd\x2f\xcf\x40\x0f\x7e\xbd\x10\xd3\x2a\xdb\xa1\x27\x05\xc8\x85\xb8\x5f\x88\xe9\x8d\xda\xff\x6d\x33\x93\xea\x19\x9b\x0f\xab\x2d\xc3\x9c\x18\x07\x0a\x70\xc1\xbe\x27\x41\x1c\x2e\x78\xf1\xee\x4d\x95\x81\xdc\x03\x1f\xac\x0e\x2f\x00\xd8\x69\xd4\x3e\x91\x55\x5c\xf8\xb8\x00\x5a\x3b\xdf\x0a\xc6\x54\xc2\x38\x5c\xea\x32\x59\x19\xfc\xe1\x61\x39\x7c\x5d\x4b\x1e\xa0\xdd\xe6\x2f\x22\x26\x1f\xa6\xb3\x9a\xe6\xf6\x1c\x2e\xf5\xe0\xeb\x9a\xf3\x00\x6d\x6f\x83\xe0\xe5\x39\x8b\xb2\xd7\xf0\xa0\xa8\x89\x6e\xf1\xa8\xb2\x4a\xed\x18\x73\xb0\xab\xdb\x56\xbe\xa2\xd5\x06\xa3\x8f\x1e\x7b\x60\x75\x1d\x91\xdf\x6f\xd4\xd2\x15\x6e\xf2\x6f\x68\x44\xc7\xd5\x96\xa9\xfb\xf7\x4a\xc1\xeb\x5a\x72\xe1\x4c\x65\xfd\x38\xa9\x6c\xe7\x61\x01\xb4\xae\x0d\x0d\x63\xed\x66\x45\x92\x55\x5a\x1c\x3f\x70\x2c\x8e\x11\xb0\xd6\xc2\x16\x20\xbe\x34\x63\x58\xb5\x08\x6b\xcc\x65\x96\xb7\x89\x75\x71\x2d\xb2\x25\x5d\xbd\x8b\xd7\xd5\xbd\x85\x5d\x83\x27\x4e\x40\xc3\x94\x04\x22\x6a\x64\x28\xa8\x56\xf1\x43\x55\x2a\x98\x54\x80\xaa\x80\x5c\x00\xc0\x20\x61\xf4\x8c\x0c\x45\x34\x9c\x25\x09\x8b\x86\x10\xd1\x8a\x1c\x40\xb8\x22\x1a\xa6\x82\xc4\xb3\x0c\xe1\x31\x52\x2a\xd8\x65\xad\x67\xff\x6b\xf4\xe6\xd7\x68\xff\x6b\x70\x5e\x23\xcd\xbe\x10\x8b\x65\xd9\xe3\xdc\x76\x04\x4f\x53\x6f\xcf\xb1\x8f\x53\xbd\x9a\x37\x37\xfa\x4d\x84\x70\x4c\x02\x2b\xcc\x75\x4b\xd3\x5e\x95\x07\xe2\xa8\xb4\x82\x2d\x35\xd2\x0d\x38\x0d\xc5\xd8\x37\x94\xcd\x19\x79\xba\xf6\x80\x13\x1e\x04\xcc\x09\x6c\x71\xce\x53\x3e\xe0\x21\xcf\x64\x8f\xf1\x63\xc3\xca\x43\x56\xb6\x00\x2c\xb5\x87\x3b\x9e\x30\x72\x70\x74\xa4\x42\x02\x41\x26\x6c\xa5\xfc\x1c\xe8\x2d\xbd\x60\xa3\xa0\x77\xe7\x83\xb5\x6c\x9a\xde\x43\xec\x21\xc7\xc2\x04\x9b\xce\x04\x68\x73\x69\xea\x35\x5e\xd2\xa8\xae\xb7\xaa\x65\x90\xb7\xc3\xae\x69\x12\xe4\xe2\xb8\x1e\x5b\x20\x07\x63\xab\xd6\xbe\xc5\x90\x03\x3c\xfb\x81\x35\xd0\x14\xd4\x9f\x9e\x43\xfd\x69\x05\x9b\x97\x52\x53\x30\xd3\xde\x1f\x6d\x13\x56\x2b\xf7\xfc\xeb\xd9\x86\x3d\xd7\x93\x0b\x8a\x1d\x13\x94\xbb\xb0\x48\xd7\x35\x1f\x35\xa7\xfc\x66\x4b\xe4\x7a\x97\x47\xeb\xeb\x37\xe5\x7c\x8e\x86\x2d\x67\x8c\xc5\x2a\xaa\xba\x32\x53\x50\x61\x23\x5f\xbc\x7b\xd3\xd1\xcb\x91\x3b\x81\x3c\x86\x34\xb2\x01\x24\x25\xf0\xd1\xcb\x77\x24\xe5\xd9\x4c\xd9\x84\x26\x58\x09\x2c\xf7\xe6\x62\x46\x2e\x68\x94\xc9\xd1\x4f\xe9\x25\x9f\xea\x04\x57\x18\xaf\x3d\xe5\xe7\x2c\x62\xa9\xb1\x38\x86\xdb\x95\x9d\x1b\xd9\x35\xd0\x11\x81\x13\xf7\xb2\x9b\x47\xcd\x36\x15\xf0\x94\x0e\x42\x6d\x2d\x28\x9b\x50\x25\x7a\x49\xaf\xd7\x0c\x78\xf8\x2b\x03\x1e\xdb\x1e\x58\x0f\x45\x22\x03\x4b\x46\xb4\xb1\xf3\xf5\x10\x9f\x8c\xed\xa1\xed\x0f\x52\xd6\x9e\x67\x18\x48\x60\x8d\x3e\x4d\x78\x06\x01\x8b\x58\x3a\xa4\x31\xdb\xa4\x33\x2f\x01\xc3\xcf\x6c\xfe\x71\x95\xe9\xc9\xf3\xa8\x7b\xb1\x5a\xdf\x20\x34\xb5\x06\xa1\x2e\x5d\x81\x00\x60\x98\xe5\x98\x59\x46\xcb\xcd\x62\xd1\x8e\x33\x67\x82\x3a\x60\x23\xa1\xe6\x0c\x06\x21\x1b\xd4\x2a\x15\xb7\xb9\x97\x2a\xd6\xd7\x9a\x27\x80\xbd\xc0\x6f\x7c\x02\x18\x54\xd7\x7d\x02\x68\xc4\xad\xe5\x6c\x76\x17\x4f\x17\xf8\x83\x7d\x9b\xb1\xdc\x8c\x4d\xa8\x9a\x32\x77\xa7\x52\x33\x06\x11\xf4\xff\xe2\x13\xe6\xec\x02\x6a\x7b\x83\x68\x5a\xf2\x8c\x62\x69\xca\x02\x4c\x47\xe2\x32\x20\x97\xd7\xc8\xe1\x2c\xf5\xa6\x73\x89\x7d\x6d\xbd\xcd\xe1\x92\x67\x79\x66\xc7\x28\x7e\x7f\x71\xba\x95\x6e\x0d\xe5\x93\xf5\x6d\x63\xa8\xdc\x18\x2e\x79\x96\xdb\x17\xa0\xe4\xdb\x74\x7d\xd5\xde\x22\x6f\xf4\x82\x28\x3c\xa4\xd1\xc4\xa5\xe6\xe2\x95\x0f\x2f\x04\x4d\xe0\x23\x1a\xd9\xc6\xce\x46\x9c\x88\x73\x1e\x40\x06\x28\xf4\x0d\x1d\x99\x30\xf5\xf0\x26\xc6\x28\x96\xd1\x98\xa0\xa0\x28\x6d\x4b\x44\xb1\x88\xc5\x39\x4b\xf0\x85\x7c\x31\xa1\x19\x3b\x67\x09\x78\xd9\x77\x6e\x19\xd7\x41\x3b\xdf\x18\x51\x94\x67\x29\xf9\xa4\x9f\x14\x9f\x48\x24\x02\x06\xbb\x70\x22\xd0\x9a\x9d\xda\x0b\x9c\x6b\xd4\x6e\x7a\xae\xfd\x8a\xc4\x68\x84\x01\x4a\x47\xec\x82\x4c\x58\x18\xcb\x47\xc7\x88\xd1\x6c\x26\xcf\x01\xd9\x2f\x32\x93\xef\x4f\x08\xfc\x4a\x28\xf9\x84\xd2\xf4\x4f\x4e\x97\xe4\x69\x90\x8a\xa9\x7a\x90\xa5\x3d\xd9\xc4\x0e\xc1\xbb\x68\xaa\x46\x4a\xd2\x8c\xe2\x1d\x1e\x78\x48\x44\x6c\x87\x66\x3b\x74\x07\x42\x74\x02\x6a\x0e\x51\xa0\x59\x24\x66\xe3\x49\x07\x51\x1c\x80\x5a\x3a\x75\xc6\xd2\x86\x59\xc4\x47\x85\x44\x06\x62\x7c\x8a\x82\xc1\x01\x0b\xc5\x85\x5d\xcc\x0a\xc7\x61\xa6\x5e\x56\xe1\x9c\x4c\x55\x97\xe0\xa8\x7a\x4a\xa6\xe2\x1c\x1e\x15\xc2\xd9\x01\xd4\xeb\x1a\xe8\x42\x60\x64\xf2\x91\x04\x4d\x65\x2a\x5f\xfc\x2c\xca\x78\xe8\x6f\xb2\x86\xeb\x55\x8b\xea\xd5\x93\x5a\x6f\x7b\xcd\xdf\x31\x1d\x1b\x47\x50\x95\xee\x53\x79\x2f\xc9\xaa\xcf\x83\x20\xd5\x2e\x0c\x89\x88\x13\x08\x9a\xfa\xfc\xc3\xe1\x73\x92\x08\x89\x8e\x26\x0c\x22\x05\x4c\x69\xc6\xe5\x4a\x99\x5b\x8a\xca\x5e\x18\x8a\xa4\x13\x2a\xa9\x37\xa5\xd1\x1c\xa4\xe3\x2c\xce\x52\x14\xb7\x9c\x80\xf6\x78\x47\xd2\x35\xa4\xf3\xf4\xb4\x89\xc9\xd2\xbb\x5d\x2c\x1f\x08\x91\xa5\x59\x42\xe3\xce\x98\x67\x93\xd9\xa0\xc3\x45\xd7\xaf\xd1\xfd\x7f\x30\xea\xb4\x25\x9b\xee\x82\x34\x52\xc7\x86\x59\xd7\x31\xe8\x0d\x1a\xa0\x2d\xf0\x0b\x02\xa8\xad\xb9\x05\x99\xb0\x34\xe4\xcf\xee\x15\x84\x32\x80\x15\x9c\x82\x70\x6a\xd6\xf0\x09\xb2\xe1\xde\xdf\xa3\x2b\x05\x0d\xc3\xa6\xf5\x18\xda\xb2\x03\x8d\xe2\xaa\x6a\xff\x19\x37\x49\x60\xad\xe3\x4c\x3e\x43\x20\x84\xbf\x77\x42\x52\xca\x03\xc4\x35\x8a\xcd\x27\x9e\x64\xfa\xfe\xe0\x67\xb7\xbc\xb2\x92\x7d\xdf\x8d\xa6\x2a\x93\xe1\x2a\x59\x0c\xa1\x0f\x53\x94\xed\xe4\x72\xf2\x82\x61\xef\x82\xde\x4f\x68\x14\x84\xec\x68\x22\x2e\x9a\x2b\xf4\x77\x63\xaf\xa4\x88\x5d\x66\xef\xfd\xa0\xd5\xb2\xb7\xa6\x18\x3a\x4b\xee\xdc\x71\x73\x7e\xe1\xec\x2e\x33\xff\xf9\xbc\x9f\xcb\x0d\x08\xb3\x89\x2d\x33\x14\x84\xac\x1a\x44\x9e\x63\xe4\x30\xfc\x81\x15\xc6\x30\x94\x5b\xd5\x2b\x91\xbc\x92\xe7\xd5\x2a\x84\x78\xc1\x83\xe5\xba\x6d\x00\x21\x83\x6c\x59\xaf\x4d\xb9\x3f\xf7\x6b\xf1\x8e\x76\xe2\x93\xc7\xd8\x05\xe5\x18\xf0\x5b\x69\x1f\xf4\x35\xdb\xdc\x00\x41\xa0\x4b\x43\x79\x29\x97\xf8\x7e\xe2\x81\x72\x05\x5c\x48\xb0\x68\xba\xec\xca\x56\xa0\xb9\xb5\x9d\x27\xd4\xef\xbf\x7b\xa6\xf5\x15\x0c\x67\xbb\x59\x1c\x76\x6e\x35\x62\x1e\xb1\xca\xc1\xb8\x54\xaf\x1a\x85\xcf\x19\x5e\xf7\x95\x31\x93\xd9\x09\xf3\x1d\x0d\x69\x9a\x41\x3d\x7d\x86\xf8\xd6\x43\x9e\x52\x76\x01\xc3\x25\x2c\xcd\x44\xc2\x5e\x6b\x8c\x95\xae\x7f\x3e\x58\xd9\x7c\xdb\x5e\x69\x16\x33\x25\x1d\xb8\xaf\x55\x8f\x03\xbf\xbb\xe1\xc7\x0b\xe3\x74\xec\x7a\x17\x0c\xc9\x72\x6f\xc5\x60\x5c\xf6\xf6\x7c\x19\x03\x31\x34\xee\x6c\x9e\x81\x94\x73\x86\x19\xfb\x3e\x1b\xbf\x94\x47\xc1\x8b\x77\x6f\xde\x8a\x80\xc1\x44\xb4\xcc\x30\x1c\x36\x74\x85\xbb\x1d\x1a\x04\x08\xe9\x01\x8a\x48\xb7\x07\x12\x17\xc7\xb6\x0a\x69\x9c\x37\xa0\xb2\x9d\x0a\xc4\xb0\x4d\x1a\x67\x6c\x3e\x8b\x1b\x6d\x97\x97\x3d\x84\xf9\xd6\x60\x66\x57\x6e\x65\x84\x5c\xe2\xb6\xe2\x21\x6a\xc3\x49\xe5\xb7\xe5\x51\xb7\x84\x62\xa3\x1a\xce\x1b\xe5\xd8\x0d\x62\x9f\x83\xad\xc8\x72\x4b\x60\x73\x6a\xb6\x5c\x57\x3f\xa0\xa3\x4d\xf7\xad\xb6\x05\x79\x7b\xd6\x4c\x8f\x4f\x17\xc9\xba\x07\xf2\x6d\xe7\x56\x86\xb1\x1c\x46\xfa\xb6\xed\x0d\xe3\xce\x1d\x75\x15\xd2\xd6\x86\xb6\x97\x6e\x9b\x6d\xaf\x96\xef\xeb\xe3\xf5\xed\xce\x1d\x72\xdb\x6d\xcf\x5d\x7c\x70\x2c\xb8\xd0\x9d\x09\x4d\x9f\x67\x2a\x2b\x5a\xb3\x91\xd1\x01\x18\x43\x34\x72\x29\xd9\xbd\x2a\x29\xcb\xca\xaa\xb4\xc9\xce\x9e\x17\x36\x59\x99\xfb\x77\x58\x74\xde\x79\xfb\xee\xc5\xcb\xfe\xcb\xb7\xff\xc6\xf4\x3b\x71\x22\x82\x99\x4a\xc0\xf3\x83\xf2\x7b\x50\xb6\xa7\x76\xf0\xca\xc9\xa1\xf1\x46\x85\x1f\xdf\xf9\x78\xd8\x2b\xbe\xf6\xf0\xf5\x1c\x08\x96\x82\x0a\x87\x0e\xe5\x83\x49\x09\x34\x21\xba\x53\xe3\x95\xd6\x91\xb3\x88\x8d\x38\x3e\xb0\xd3\x94\xa7\x90\xe7\x38\x63\xc3\x49\x24\x42\x31\xe6\x2c\x6d\x23\x3c\x84\x56\x51\x83\xd2\x4f\x3f\x7c\xa2\xa7\x64\xc0\xe4\xb9\x97\x32\x50\xda\x7d\xb7\xb3\xf7\x5d\xa7\xd1\x22\x3d\x72\x2e\x78\x40\x76\x4b\xf3\x4c\x7b\x33\x37\x5a\xf2\x32\x60\xcf\xa3\xda\x8d\x0c\x0f\x2c\xff\xde\x58\xb2\xe9\x24\x6c\x2a\xce\x99\xbf\xef\x98\xbd\xbb\x62\xef\x69\xd5\xee\x4c\x1a\x65\x19\x3a\x6f\x4f\x68\x95\x6e\x39\x85\xea\x2a\x63\x77\xfe\xa4\x59\xe0\xac\xae\x75\x58\xb5\x4e\xeb\x1a\x28\xb7\x91\x68\x0f\xe6\xfc\xf3\x90\xfc\x83\xec\xca\x15\x64\x1f\x77\xbb\xa7\xc0\xb3\xe6\x14\x22\x3f\xf8\x1f\xdd\x4c\xfb\x4b\xb8\xc5\x17\x2c\x63\xac\x97\x75\xe1\x53\x69\xbd\xa2\x9b\x7b\xe1\x53\x59\xbd\x72\xdb\x32\x1f\x41\x11\xa6\x0c\x93\x31\x5a\x29\x22\x30\x9f\xf2\x6e\x68\x16\x54\xfe\xb2\xee\xd6\x2b\x3a\xe4\x81\xd5\xee\xf2\xfe\x78\xc6\xbb\x12\xbd\xa3\xd0\xb1\x53\x76\xa0\x6d\xdd\x33\x6b\xe6\xa7\xc4\x0d\xb1\xbe\xa3\x45\x02\x7a\x9b\x28\xb7\xd6\x3e\xb5\x13\xe6\x98\x2c\xd4\x92\xd6\x4f\xb1\x80\x5b\x82\xa7\xd7\xb5\xfb\x91\x76\x36\xbe\xd6\xf8\x0f\xa5\x89\x4e\xec\x12\xd8\xaf\x5c\x03\x39\xc3\x02\xc3\x1c\xfb\x9d\xdc\x97\xe5\x16\xce\xfe\xba\x2b\x67\x7f\xe3\xa5\xb3\xbf\xf1\xda\xd9\xaf\x5f\x3c\x25\x36\x0f\x4e\xd5\x92\xaf\xc5\xca\x8e\x2e\xaf\x50\xd5\xf9\x56\x1b\x95\x63\x7f\xa9\xb0\x1c\xfb\xcb\xc5\xe5\xd8\x2f\x0f\xcc\xe1\x58\xb4\x38\xa0\x4e\x69\x3b\x7f\x21\x51\x07\xdc\x7b\x9f\x87\xdc\x4f\xfe\x72\xa9\x9a\xc6\xdc\x17\xbf\x52\xf9\xf4\x79\xe5\x4b\x84\xf4\xd8\xaf\x8b\xe9\x81\xda\x6b\x1f\xbb\x2c\x29\x01\x52\x7e\x3c\x3e\x1c\x98\x2f\x15\x40\xbd\x69\x34\x65\x39\xc0\x4b\x9e\xf9\x50\x97\x3c\x2b\x82\x14\x5a\xc5\xb2\x22\x60\xbe\x4d\x28\xaa\x3c\x0c\xf6\xe1\x34\xd8\x38\xb0\xc8\x7e\x9b\x9c\x34\x72\x3b\x47\xa3\x4d\x1a\x85\x5d\xc1\x2b\x74\x03\x8d\x54\x2f\x62\xf7\xab\x59\xa0\xb2\xb0\x64\xe9\xd9\x62\x87\x37\x96\x8d\x75\xe2\xf0\xb9\xfc\xe9\x32\x31\x46\x36\x29\x34\xe5\xb1\x60\x45\xf4\x13\xa4\xba\xf3\x27\x8f\xc6\xce\x2f\x6c\x0b\xe9\x64\xff\xb2\x30\x40\x3e\xf9\xb7\xa4\x93\x17\x27\x05\x1e\x12\xee\x8a\x95\xaf\x8e\xa5\x24\x7c\xea\xc8\x8f\x66\x61\x58\x1a\xf1\x21\x2b\xe8\x35\x53\x27\x2c\x95\x63\x4c\x54\x58\x24\xae\xdd\x4c\xd9\xca\x70\xac\x44\x4a\x96\x83\x36\x44\xc8\xaf\x01\x47\xe7\x5e\xc2\xf8\x8e\x86\xd9\x1e\xc2\x96\x8d\xf0\xa3\x1e\xa6\x77\x48\xe2\xc3\x00\xcc\x42\x8b\x61\x2d\x0e\x14\xc7\x74\x44\x14\xce\x9b\x9a\x7f\xbc\xf7\x68\xdf\x22\xf8\x9b\xbe\x72\xda\xa2\xe2\xa1\x9b\x08\x3c\x75\xf2\xd5\x3a\xf2\x83\x17\xb9\x42\xbf\x7d\xca\x80\xf5\x47\x6f\x28\xd0\x3f\x63\xb0\x7e\xe5\x3d\x4d\xb1\x59\xf7\x02\xed\x32\x83\xad\xd9\x51\xfd\x2b\xc2\x93\x1f\x48\x23\x50\xaf\x90\x06\xe9\x01\x44\x81\x73\xe0\x01\x62\x3a\xbe\x44\x73\xce\x28\x9d\x7a\x98\xbf\xf5\x07\xb2\xb3\x47\x7a\xc4\x8e\xb5\x84\x4d\xb5\x56\x53\x0f\x5b\x3f\x01\xad\xb0\xf4\x10\xa2\xa7\x11\xcb\x0c\x24\xe4\x67\x8e\x3a\xb8\xf0\x7e\xb7\x74\xcb\x65\xa3\x6f\xca\x9b\xab\xf7\x22\x87\xfd\x11\xfc\xc8\x1d\x55\x51\x71\xe1\xb4\x3a\x23\x91\xbc\xa4\xc3\x89\x93\x38\xaa\x90\x73\xd0\x4e\x8a\xce\x6c\xef\x47\xb7\x41\x0d\xcd\x84\xca\xc9\x7c\xa5\xd0\x94\xb6\x06\xd5\xdb\x05\x26\x84\x62\x37\xfb\x91\x7d\xff\x62\x38\x7a\xdb\x99\xfc\xa4\x96\x34\x52\x4a\xf9\xb2\xe9\xb0\xc3\x6a\xa9\xb7\x9d\x3b\xec\xda\xd5\x37\x0c\x45\x64\x2e\xf5\x16\xb2\xed\x4c\x55\x31\xee\xc8\x8a\x4f\x19\xe5\xfa\x56\x1f\x73\x49\xe5\xba\xcb\x85\x4d\x4a\xd8\xc8\xbb\x9b\x8f\x9a\x91\x08\x58\x21\x43\x22\x66\xd8\x02\xc9\xb5\x4a\xde\x00\x52\x8c\x1f\xe0\x3f\x9d\x31\xcb\x5e\xd3\x39\x5c\xea\x7b\xde\x66\x4c\xfc\xec\xa8\xcb\xbe\x7d\x9c\xda\x4b\x07\x8a\xf1\xfa\xbb\x52\xdc\x93\x44\x88\xcc\x09\x7b\xb2\x42\x40\xa7\x0e\xba\xe6\xb4\x4b\x0e\x29\x37\x5f\x97\x0d\x7f\xe2\xf7\x72\xb9\xb9\x77\x66\x1f\x05\x7e\x12\x28\x97\x03\xd3\x6d\xcc\x0b\xdb\x72\x3b\xff\x3c\xba\x73\x27\x77\xd6\xfe\xfe\x3b\xa9\x53\x6e\xe8\x13\x38\x27\x00\xf1\x16\x57\xab\x70\x99\x06\x16\x37\x85\x65\x0f\x46\x2f\xa6\x0b\x88\x16\x17\x86\x74\x41\x85\x75\x49\x44\x97\x12\x07\x21\xeb\x6b\xea\x2e\x8a\x3a\x87\x92\x7b\xbb\xbb\xed\x72\x6f\x1a\x13\x8b\xc5\x33\x93\x37\xa5\x05\xcb\x76\xf3\xa5\xd4\xc6\x3c\xf7\xd5\x33\x8e\x34\xdf\x7c\x23\x6e\xf7\x97\x71\xfd\xca\x6b\xd5\xbd\x84\xb0\xb9\x6f\xea\xb1\x6d\x1e\xda\xf7\xdc\x87\x76\x49\xc4\x4e\x4f\x51\x7a\x4b\xe5\x58\x5d\xa0\x5d\xd0\xcb\xbe\x42\x2d\xe0\x7d\x2e\xd1\x80\xd5\x6b\x6a\x1c\x01\x79\x19\x2a\xbd\x25\xc1\x87\x5b\xa4\x52\xab\xe0\xd9\xa6\xe8\x75\x06\xb7\x4f\x9c\x16\xd3\x31\xb9\x18\x54\x51\x89\x0c\x94\xa7\xc7\x22\x46\x33\x14\x04\x72\x8e\x53\xe4\x68\xcf\x7e\xe3\x26\x75\x0d\xba\x3f\x6a\xa9\x95\xe8\x1a\xcc\x48\x95\xb6\xc1\xfd\xed\xea\x1b\xcc\xdc\xe4\xf5\x01\xde\xef\xdb\xcf\x8a\x0a\x88\xdb\x6b\x68\x20\xec\x04\x56\xcb\xb8\x95\xef\xa3\x4f\x5f\x8f\x1d\xab\x73\x16\x6f\x9d\xc8\xee\xcd\x01\x62\x53\xd8\x61\xab\x8e\x40\xcc\x3e\x96\x0e\x1b\x0b\x99\x05\x5f\xa2\xf7\x2c\xb1\x72\xf7\xef\x72\x39\xc2\xbd\x2a\x39\x42\x85\x14\xe1\x5e\xa5\x14\xa1\x5a\xd4\x73\xaf\x28\xea\xd1\xcf\x38\x39\x01\x5e\x07\xec\x30\xbd\x62\x35\x1d\x85\xc9\xcb\xf5\x52\xf2\x51\xa1\x2d\x17\xa5\x0b\x9d\xc3\x59\xc2\x26\x79\x69\x4d\x0d\x9b\xb8\xe9\xa9\x81\x68\x58\xa0\xd8\xf5\x18\xca\x97\x24\xe1\xfd\x1a\x12\x96\xcb\x8f\xee\x57\xcb\x8f\x2a\xc8\x78\x7f\x01\x19\xab\xda\x29\xf9\xea\x93\xd2\xfb\xe4\xce\xbc\xf7\x61\x65\x72\x56\xa2\x5d\x8d\xa0\xf9\x67\x71\xe5\xd6\xee\xad\x70\x0d\x5d\x16\x7c\xf8\x81\x79\x6f\x29\x51\xd0\x83\x1c\xf5\x5a\xa6\xba\xb6\x7e\x43\xb0\xb6\xd5\xe1\xf8\xf3\xa0\x2a\x2f\xb2\x00\x53\x60\x79\xbb\x11\xe5\xe6\x7d\x0d\xa1\xdd\x6c\x24\x37\xd8\xcf\x20\x90\x9b\xb6\x73\xac\x89\xb5\x76\x85\x86\x7a\x75\xc1\xdb\x9a\xf2\xa8\x29\xc4\x82\xdb\xfb\xb2\x52\xa5\x6e\x29\x00\xd0\x8d\xc4\x10\x01\xf5\x80\x69\x49\x44\x92\xb5\xaf\x9e\xde\xaa\x34\xef\xf1\xe1\x61\x21\x98\x95\xa0\xe5\x1e\x9d\x42\x60\x1c\xdd\x49\x5b\x51\xbe\x31\xda\xb8\xf3\xe1\x9b\x08\xb9\x33\x69\x93\x21\x8d\xb3\x59\xc2\xf2\x3b\x20\x3e\x04\xf3\x98\x9b\x35\x18\xe4\xf9\x0b\x0c\xaa\x17\xcd\x53\x93\x4f\xce\xf6\x34\xcb\xe8\x70\xf2\x12\xb7\xe8\xa5\x3b\x59\xd1\x37\x8b\xab\xd9\x10\x51\x83\xdc\x75\xab\x3a\x07\x82\xfb\x00\x93\xfb\x2c\xf4\xf4\x82\x47\x81\xb8\xe8\x40\x0d\xfb\xf8\x62\xfa\x9c\x78\x66\xff\xfc\xfd\x77\xc2\x3a\x69\x32\x54\x17\x3b\x17\xd8\x3b\x43\x0a\x2f\x39\xd5\x7b\x5c\x75\x6a\x6c\x56\x34\x60\x66\x49\x6e\x0d\x72\x87\xb8\x2a\xdb\x1b\x44\xf4\xf4\x16\xae\xb4\x8e\xfa\x68\x63\x68\x9c\x34\x14\x5c\xe3\xb4\x18\xbf\x71\xff\xdb\x9a\xbd\xb6\x35\x3b\x1a\x79\x8b\x76\x34\x5a\xb8\x6a\xfd\x1a\xde\xf9\x75\x03\xab\x16\x2d\x28\xbe\xd8\x85\x1b\xb0\xba\x85\xab\xab\x2e\xb7\x3c\x46\xa3\x35\xd7\xc7\xbd\xaf\x3a\xbe\xe9\xf6\x63\xf7\xf1\xf4\x17\xd8\x21\x2b\x03\x75\xdd\x2f\x80\xd6\xae\x58\x05\xf3\x47\x85\xa6\xdb\x4e\xb8\x40\xf4\x02\x1a\xd0\xe4\x88\xff\x56\x9d\x89\x78\xb7\x1c\xbe\xae\x19\x0f\xd0\xc6\x75\x83\xa7\xec\xf3\x84\xd3\x9f\x40\x4e\x59\x49\x9b\x07\x37\xb2\x37\x76\xbb\xe4\x98\x9e\xb1\x08\x93\xf0\x69\x7f\x23\xe5\x5f\x34\x14\xd3\xbc\xeb\x51\xde\xe1\x68\x10\x8a\x41\x77\x4a\xd3\x8c\x25\xdd\x34\x19\x76\xdf\xb8\xcf\xf5\xff\xa4\x7e\x76\xdc\xf7\x34\x08\x78\x34\x86\xcc\x90\x8e\x58\x55\xf5\x3e\xa6\x49\xca\x0e\x23\xfc\x82\xb1\xa5\x3a\xb1\x53\x43\x6e\x71\xbb\x6d\x02\x01\x54\xb1\xe7\x2f\x04\xb9\x60\x64\x42\xcf\x19\xa1\xca\x9b\x8b\x0c\x68\xf2\x83\x6d\x74\x20\x82\xf9\x61\xaa\xd3\xb0\xf2\x68\xec\x34\xbb\xa4\x59\x70\x84\x11\x2b\x11\xfe\x82\x47\x1a\xde\xac\x18\xcf\x8c\x16\xcd\x36\xd5\xac\x82\xeb\x35\x1d\x0e\x21\x89\x4d\x2c\x32\x16\x41\x52\x9b\x48\x44\xe4\x37\x96\x08\x32\xa5\xc9\x98\x9b\x20\x6a\xb2\xaf\x1d\xd5\x0e\x46\x4f\x79\xa6\x6f\x38\x63\x96\x1d\x88\x69\x3c\xcb\x58\x00\xef\x0b\xd9\x52\x47\xc2\x9b\x8e\x21\xaa\xd7\x6c\x24\xd7\xa1\x99\x49\x9c\x44\x74\x1e\x82\xfd\xe9\xdf\x72\x0f\x6a\x36\x10\x7a\x07\x53\x10\xab\x29\x75\xf1\xe0\x7c\x2f\x8f\x48\x65\x25\x56\x98\x2c\x49\x9d\x5e\xdd\x25\xba\xcf\x9d\x61\xc8\xc1\xc4\x3f\xc8\x26\xe4\xae\xd7\xe2\xdf\xe5\x80\x3b\x3c\x8a\x58\x02\x9f\x35\xa1\x75\x82\x46\xca\x23\x96\x90\x74\x22\x66\x61\x00\x21\xe6\x20\x12\x4b\xe0\x87\xa1\xc3\x18\x72\x8a\x28\x07\xa6\xd6\x33\x92\x3b\xe6\xc9\x0f\x7a\x7a\xcd\x09\x29\xbb\xa7\xec\xfd\xb4\x23\x29\xbc\x12\x95\x73\x22\x6c\x73\xa8\x36\x03\xd7\x08\x74\xb6\xeb\x86\x74\xce\x92\x14\xbc\x04\x8f\xf8\x34\x0e\xf9\x88\xb3\xa0\x4d\x06\xb3\x8c\xf0\x28\x8d\xd1\x55\x7e\x4e\xbc\x95\xd3\x48\x89\xbb\x54\x50\x79\xa1\xfc\x05\xff\x09\x6b\x3d\xa2\x21\xf9\x98\x62\x55\xeb\x23\x9b\x09\xc2\xa2\x54\x1e\xf8\xe8\x38\x89\x86\xb0\x4e\xff\xd0\xf3\xcf\xfa\x22\x80\x0e\xc7\x6d\xca\x95\x3b\xa3\xd3\xd9\xf5\x98\x48\x6a\x19\x87\x44\xfa\xb7\xa1\x3b\xed\x09\x1b\x75\x4c\x81\x06\xcb\x43\xb8\x55\x72\x4d\x15\x48\xd9\xcb\xd5\xf0\x9a\x9e\xf0\x80\x1d\x71\xf0\x40\x7d\x2b\x02\x34\x5e\x92\x3d\xc8\x97\x9b\xc8\x72\xe5\xf0\x25\x78\x72\xdd\x02\x79\x41\xaf\x1c\x18\x16\xc1\x86\xe6\xd1\x76\x42\x6e\x2b\xbd\x75\x9b\x34\xfe\x37\xf2\xac\xa5\xe7\x62\x06\x0e\x3b\x53\x91\x66\xa0\x7d\x0e\xe7\x84\xc9\x8b\x06\x3a\x32\xa3\x37\x78\xc0\x9c\x48\x0d\xff\x1b\x0d\x12\x71\x91\xb2\x04\xfc\xe9\x29\x19\x4e\x68\x34\x64\x92\xaf\x24\x7f\x62\x06\xd6\xbf\xcb\x75\xf0\x8f\xce\xff\x46\xef\x43\x46\x53\x89\xfd\x1c\xa3\x3c\xf0\xa9\xbc\xdd\x10\x95\x28\x8c\x45\x81\x36\x9f\x36\x35\x08\xf1\xec\xa5\x6f\x39\xe2\x6e\x39\xb3\x27\xa7\xa6\x2c\x4e\xd8\xb9\xde\x98\x1d\xf5\xba\xfd\xa8\x4e\x0b\xa7\x9a\xe1\x6a\x1a\x04\x28\xb8\x76\x3d\x4e\xa1\xe0\x30\xb8\xd4\x66\x12\x69\x87\x47\x01\xbb\x7c\x37\x52\xa0\x79\xf1\xb9\x04\x95\x33\xbb\xb3\x57\xb8\xe2\xea\xef\x9e\xe4\xa8\x88\x1f\x97\xcb\x53\xfb\x35\xed\xc4\xb3\x74\x52\x6c\x2f\xcf\x1e\xb6\x41\x8c\xbb\x98\xbb\x13\xb8\xbc\x9a\x3a\x8c\xa0\x54\xef\x56\xbf\x52\x14\xf1\x79\x3d\x03\x96\x75\x46\xd7\xed\x92\x23\x79\x58\x8a\x99\x51\x7e\x98\x64\xea\x24\x85\xc3\x74\x48\x23\x92\xb0\x73\x96\x64\xb6\x8e\x76\xf8\xe2\x19\xfa\x87\xd3\x30\xd4\x14\x95\xbc\x87\xfe\xd5\xb7\x15\x7c\x8e\xac\xa6\xef\xea\x40\xd7\xcd\x79\x26\x24\xc5\x53\xda\x54\xf3\x8c\x22\xf2\x5c\x91\xbf\x52\xd8\x5a\xa7\xf6\x05\x0f\xc7\x69\xee\x8e\x07\xb3\xee\x5f\xe4\x4a\x3c\xab\x48\xa1\xf7\xde\x75\xe4\x99\xd7\x1f\xb9\x0d\xde\xcd\x35\x74\x97\x34\xe2\xcb\xc6\xd3\x5b\x5e\x5f\x20\x50\xa5\xde\x69\xcc\xc9\xf3\x7f\x33\x96\xcc\x8f\x58\xc8\x86\x99\x48\x9e\x87\x61\xb3\xd1\x99\xce\xf8\x0e\x46\xb5\x74\x7a\x64\xbc\x9f\x39\x7a\x33\x73\xf2\x77\x07\xa3\xe6\x48\xc2\xc9\x5d\x8f\xf2\xba\xf1\xdc\x00\xf2\x13\x68\x31\x9d\xf0\xd3\x9c\xab\x87\x1d\x2a\x32\xb9\x8b\xca\x03\xf5\x90\x54\x4c\x9c\xfb\xb3\x6a\xd6\x34\xbe\xab\xbc\x21\x46\x15\x4f\x91\x67\x26\x2e\x67\x99\xaf\xb6\xbb\xa8\xaf\xbc\xed\x44\x79\x2b\x5c\xcb\x8e\xf2\x6c\xd5\x1d\x25\xed\xa4\x71\xc8\x87\xcc\xa0\x68\x93\xbd\x02\x66\x6f\x45\xef\x5a\xec\x35\x53\xe1\x2e\xc4\xa7\x15\xe0\xf5\xfc\xec\x99\x80\x6d\xc2\xb6\x6b\x33\xed\x32\xac\xe4\xf6\x99\x93\xbb\x64\xef\x34\xc7\x41\x86\x6f\x72\x5b\x53\xc1\xed\xb0\xe4\xd0\xb1\x7b\x54\xf5\x16\x5e\xb5\x89\xa7\x13\x71\xb1\xc2\x26\x6e\xbc\x85\x88\x91\xdc\x54\xb7\xd9\xed\xa2\xf5\xca\x05\x97\xc7\x33\x3d\x63\x04\xee\x84\xe0\xc9\xc4\x2e\x33\x92\x89\xd8\x06\xc0\xd0\x16\xe9\x99\x20\x94\x1c\x7d\xa8\x3d\x79\xa8\xf9\xd3\xf8\x67\x21\x03\x9e\xf8\x7c\xb8\x43\xf6\x4e\xab\xce\xa1\x85\xeb\xcd\x51\xe3\x7a\x6b\x4e\x55\xbc\x7d\xdb\x6f\x4b\xeb\xb7\xcb\xfa\x00\x0b\x62\x8a\xa6\x2a\xaa\x99\x92\xe8\xc6\x9f\xe5\x8d\xa1\x27\xff\xaf\xad\x16\x7b\x4f\xfd\xb7\xed\x74\xa6\xe7\xfc\xad\x94\x5b\xee\x50\x14\xba\x0a\x29\x56\xf1\xa2\xbd\x1d\x3d\xce\xfd\x2f\x4b\x26\x5c\x9c\x88\x31\xcb\xf0\x61\xfc\xd4\x7b\xfb\x63\x59\xf1\xd5\x1f\xe9\xfc\xf8\xf0\xea\xc7\x07\x99\x32\x61\x23\x3d\x2c\x94\xff\x67\xe2\x04\x3f\xd1\xf6\x6d\xaa\xc5\x7f\x73\x06\x76\x52\x50\x16\xd3\x04\x5e\x96\x80\xa4\xa7\x0d\x59\xae\xaa\xa5\x8b\xdf\x29\x2c\xdf\x95\x48\x17\x1f\x7c\x99\x33\x4d\x5d\xd1\x91\xfd\x61\x01\xdc\xcb\x23\x79\xe6\xbe\x6f\x52\x27\xa9\x92\xb3\x39\x91\x67\xc4\xfd\xf9\x54\xbe\xb8\xc9\x05\xa3\x67\x28\xb2\xfa\xf1\xf5\xf3\x83\x9f\x5f\x1f\x1e\x1d\xcb\x3d\x11\x92\x5e\x85\x10\xbc\x80\x34\xd2\x61\xc2\x63\xb0\x2b\x87\xad\x19\x44\xb4\xb0\xcd\xa7\x3f\xf1\x80\xa2\x13\x8c\xb3\xe8\x55\x21\x04\x28\xb1\x8f\x50\x4b\x5d\x7c\xa7\xe9\xdf\x26\x4e\x37\x1d\x6b\xe7\x12\xf9\x59\xfd\x7c\xea\x73\x90\x61\x8f\x3d\xb9\x5b\x98\x1e\x9b\xf3\x5a\xd5\xea\x64\xe2\xb5\xb8\x60\xc9\x01\x4d\x59\xb3\xd5\x52\x87\xb5\x0d\xdd\x9d\xda\x19\xb1\x21\xcd\x55\x99\xbf\x83\xcf\xc0\x5a\x66\x80\xc3\xc0\x2c\xc5\xf2\xc4\xd0\xf1\x56\xa0\xa4\xf5\x54\xee\xd3\x2c\x0d\x79\x94\xed\x28\x8b\xb4\x9d\x90\x47\x8c\x44\x62\x07\x02\x6f\xed\x24\x8c\xa6\x29\x1f\x47\xb7\x88\xac\xac\x6c\x79\x71\x6b\xb0\x67\xb5\xf1\xcc\xc9\x49\xeb\x5d\x8d\x04\x34\x68\x86\x8b\x5f\x71\x74\x72\x42\xec\xdc\xc3\x17\xe7\xfe\x30\xb0\xf2\x2d\xa5\xd4\x6f\xe1\x74\xd8\xb7\x96\x61\xb1\x26\x7a\xd6\xd9\xa6\xc1\x80\xc7\xed\x89\x35\xbc\xb8\x52\x9f\xdd\x20\x14\x28\xd7\xf3\x7c\x8b\x25\xf2\x1d\x75\x67\x83\x14\xb0\x33\x86\xd7\x06\xcf\x72\xd8\x51\x88\x54\xd4\x55\x41\x67\xae\x9c\x7e\xbb\x7c\x5f\xa0\xdd\x5b\xd3\xe9\x4a\xf2\xbe\x05\x7d\x48\xf9\x8c\x2b\xce\x73\xa6\x46\xa5\x67\xd3\x73\x79\x85\x32\x4a\xcb\x44\xce\xfa\xda\x7e\x67\xb4\x89\x41\xae\x37\xb9\xfd\xed\xe1\x57\xad\x3d\x59\x9c\x1d\x6e\xab\xb9\xcc\x6e\x3e\xf5\xdc\x17\x95\x27\x0e\x83\x7b\x6d\x2f\x29\xd7\x8d\x64\xcd\xda\x6e\xd2\x9f\x2f\x29\x9d\xcd\xdb\xea\x0c\x5e\xcb\x27\x8a\x01\x24\xcb\xa4\x16\xb9\xee\x3c\x21\x3a\x99\xc7\xce\xde\x75\xa6\x08\x29\xcd\xff\xd1\xb6\xef\xab\x0f\x70\xde\x90\x71\xc2\xe6\x64\xc2\xc7\x93\x50\x62\x57\x9f\x7f\x61\x83\x33\x9e\x1d\xd3\xf8\x27\xfd\xe1\x40\x84\x22\xd1\xf9\x46\x62\x1a\xb2\x2c\x63\x9d\xa1\x98\x4e\x45\x84\xc9\xe4\xf1\x6a\xaa\xf1\x0f\xe8\xf0\x6c\x9c\x88\x59\x14\xd4\x55\x04\xcc\x3f\x86\xd4\x5a\x1c\x5a\x7f\x19\x5d\xc5\x4d\x62\x8a\x6f\x90\x66\x43\xc4\x74\xc8\xb3\x79\xa3\x65\xe7\x2b\x0c\x0f\x26\x34\x1a\xb3\x1e\x31\x5f\xf5\x47\xf5\x3b\x97\xfd\xc4\xf1\x65\xff\xbc\x52\xa7\x9d\xd1\xba\x96\x82\xd7\x91\x1d\xe5\xc0\x04\xdf\x0f\x30\xd6\x24\x8f\xd2\x8c\x46\x43\xd6\x46\xf9\x75\x14\xb0\x84\x50\x02\xdd\x81\x8f\x3c\xc0\x37\x31\x3d\xa7\x19\x4d\x36\xcf\xc6\xf0\x56\x3f\x56\xd6\x09\x14\xfb\x16\x9f\x34\xd7\x11\x1a\x16\x6e\x0c\x5f\x7f\x12\x86\xd5\x72\xaa\xf0\xa5\x72\xa9\x00\xa3\x69\xe5\x9d\xea\x26\xd9\x21\x46\xa5\xe6\xc5\x5b\x75\x14\x65\xc6\x8b\x26\xb6\x71\xd6\x8c\xeb\x23\x7a\xca\xa3\xb9\x6a\xde\x4f\xde\xfa\xc8\xab\xef\xbe\x87\xbc\xeb\x1d\xef\x00\xb8\xbe\xf1\xdc\x89\x19\x80\x20\x3c\x1f\x29\x60\x45\xb7\x69\x34\x6c\x26\x27\x4b\x39\x26\x9b\xc6\x8c\xff\xaf\xeb\xfe\x08\x6e\xd4\xba\xe5\x25\x5c\xb6\x96\xf7\xd3\xb2\x83\xb4\x33\xd0\x72\x53\x5d\xbb\x12\x98\x25\x7c\xd3\x1c\xaf\xb4\x65\x12\x97\x7b\x03\x6c\x13\xef\x39\xd1\x53\x4f\x91\x7c\x84\x10\x27\x7b\x3f\x5e\xa9\x35\xd7\x80\x31\x32\x2c\x52\xa4\xe1\x72\x7a\x3f\xa5\x7f\xfd\xbc\xf4\x22\x74\x82\x1d\xb7\xff\x2c\xdb\xd8\xad\xab\x45\x4c\x83\x01\x4d\x1d\xfe\xad\x9d\xa3\xd6\x2a\xe8\xd4\x1a\xa8\xdd\xb3\x96\x45\xc8\x9d\xe8\x01\x35\x1b\x54\x0b\xc2\xa4\x8e\x5a\xca\xce\xc0\x70\x50\x89\x0f\x1d\xcf\xf9\xbb\x6d\x60\x7b\x6e\xcd\xcd\x4d\x00\x05\x72\xd5\x6a\x3a\x99\x1d\xb7\x21\xac\x7c\xf4\x55\x3f\x31\xbf\x65\xad\xfe\x96\xb5\xfa\x2f\x9a\xb5\xfa\xeb\x34\xf2\xfe\x22\x5f\xc3\x9b\xa6\x83\xd4\x61\x10\x33\x41\x62\x4c\xbb\xcb\x23\x22\x12\xf9\xd4\x91\x97\x7d\x4c\x01\x83\xd1\xeb\xc1\xa0\x43\x12\x0e\x04\xa6\x7f\xe6\xd7\x8e\x79\x39\xf8\xc9\xdb\x20\xd1\xd7\x80\x11\xed\x4d\xca\x23\x95\x3f\xc0\xa4\x73\x83\xac\x15\x10\x74\x61\xd1\x1b\x62\xe9\x27\x84\x24\xb2\x49\x88\xbc\x6e\x98\x7d\x44\xb0\x30\xce\x3e\x82\x6d\x2d\xd0\xbe\x4d\xc6\x4c\xfe\xec\x91\xf6\x71\xa8\xab\x84\xda\x57\x93\xb3\x46\xac\x7d\xe5\x47\x3f\x37\x4e\xf7\x37\x10\x61\x5f\x33\x54\x79\x88\xfd\x0d\x82\xd7\x77\xbb\xe4\x68\x16\x83\x1d\x20\x1c\x1b\xff\xdc\x7b\xd0\xb9\x6c\x9b\xa5\x87\x6a\x9a\x80\xd0\x0c\xd3\x8e\xc4\x82\x7b\x91\x70\x6e\x97\x38\xcb\xe3\x08\xd4\xfc\xe6\x23\x49\xa3\x58\x47\x85\x32\xd9\x6a\x94\xf5\xaf\x6e\x8c\x1b\x07\x54\x87\xc6\x67\x51\x49\xf3\x25\xcd\xea\x80\x32\x15\x4d\x39\xf1\x66\x8a\x91\xf5\x81\xf9\x4b\x82\x84\xe3\x92\x30\xe6\x44\xfe\xab\x1e\x1e\xf4\xc5\xc0\xe1\x73\x96\xe4\xb4\x88\x01\xcd\xe8\xce\x74\xc6\x77\xf0\x80\xf4\x35\x89\xb6\x2b\xbe\x99\xb7\x8d\x64\x9e\xeb\x1a\x21\x1e\xa0\x5c\xe9\x2c\x0a\x20\x02\x43\xd3\xa9\x51\x63\xa0\xa6\xb6\x2c\x0b\x5c\x39\xa7\xde\xdc\x57\x4c\x6c\x8e\x3e\xcb\xcc\xae\xeb\x00\xef\xf4\xeb\x06\xd9\xba\x04\x74\x86\xec\x67\x8e\xb6\xe7\x99\x89\xc4\x9d\x9b\x52\x2f\xf4\x93\x47\x0c\xb7\x09\x9f\x4a\xd8\xf9\x4a\x2a\x79\xc1\xfe\xdd\xad\x78\x41\xbc\xd4\x3a\xc2\x94\x93\x65\x89\x10\xc1\x85\xe8\x9b\xa5\xc1\x37\x21\xc1\xbe\x81\x90\xbf\xfc\xe8\x7c\xb2\xc4\x9d\x8f\x6e\x97\xfc\x38\x87\xac\x0c\x68\xfa\xcd\x53\x32\x65\xd9\x44\xc8\x6b\x50\xe9\x8e\x4e\xa3\xc0\xad\x5c\xb6\x23\xb6\xc9\x5c\xcc\x1a\x09\x23\x6c\x34\x62\x10\x1a\x25\x9c\xdb\x3c\x59\x94\x7c\x77\x21\x92\xe9\x44\x84\xec\x3b\x92\x4d\x68\xe6\xa2\x1b\xcd\xa2\x88\x85\x29\x81\x0b\x4d\x23\x25\x13\xce\x12\x9a\x0c\x27\x7c\x48\x43\x32\x03\xfc\x29\xc9\x26\x89\x98\x8d\x27\x68\x9a\xa6\x6f\xae\x44\x44\x84\x46\x2e\x2e\x16\x65\x3c\x91\x4d\x07\x7c\x34\x62\x70\xcd\x8d\x69\x92\xb9\x79\x9b\x3a\x06\x5e\x12\x00\x28\x6c\x72\x27\xaf\x1a\x7d\xaf\x82\x7d\xd3\x8c\x0e\x42\xd6\x47\xb2\x1f\xcd\x06\x59\xc2\xd8\x61\x94\x09\xe3\x98\xa0\xae\x18\x6e\xe3\x2a\x0c\x95\xdd\x1c\xab\x63\xa3\x55\x6f\xc6\xb5\x49\x1e\x56\x8e\xea\xbb\x20\x76\xef\x92\xa1\x61\x3d\xee\xdc\xd7\xec\xb9\xc1\x3e\xb3\xe6\x46\x53\x17\x6d\xb2\xdb\x25\x07\x54\xf9\x09\xe1\x5c\xb0\x40\x39\x09\xed\xa4\x26\x65\xc9\xc2\xc4\x1c\x65\x8b\x2d\x27\x98\xae\xec\x6a\xd3\x1a\xef\x54\x31\x82\x17\x4d\xbe\x9e\x09\x6e\x55\x8c\xb9\x18\xbd\x0b\x5b\x5f\x18\xbe\x4b\xdd\x82\x4b\x64\x8f\xf8\x48\x32\x62\x47\x05\xb8\x8e\x98\xfb\xf3\x9f\xe7\x09\xba\xd4\xdb\x51\x09\x76\x8b\x72\x5a\x4d\x93\x6d\x48\x5a\x1f\x7f\x99\xc6\x8a\x31\x4d\x53\x7e\xce\xde\xc5\x2a\xa8\xb6\x9d\x14\xe3\x3e\xee\x94\x3a\x0e\xea\x4e\x69\x89\x27\xbc\x5b\x27\xe7\x81\xef\x7c\x1a\xd2\xe8\x63\xca\x50\x90\x55\xb0\x0e\xf2\xc7\x56\xe9\x85\xfb\xa4\xce\xe2\x67\x29\x0b\x9e\x9b\x72\xe3\x3d\x74\x5c\x0d\x4b\xfc\x78\x47\x74\xc8\x06\x42\x9c\x75\x47\x83\xff\xf8\x6e\xbb\x72\xcc\x74\xcc\x52\xfc\x92\x26\xc3\xee\x50\x24\xac\xfb\xf2\x92\x0d\x67\x10\xcb\x27\x3a\xe7\x89\x88\xe0\xaa\xf5\x9f\x14\x26\xc3\x9d\xd9\xb2\xd9\xbe\x7d\xbb\xa9\xd6\xb9\x32\xe8\x85\x38\x5b\x86\x06\x0d\x39\xbc\x9c\xef\x65\x49\x91\xff\x1c\xd0\x84\xa8\x21\x78\xc9\x27\xdb\xab\x3b\x77\x48\x23\x0f\xd0\x90\x57\xa3\x0b\x65\xad\x2c\x91\xd7\xf3\x5a\xf9\x57\xbf\x89\x12\x18\xaf\x15\x20\xd5\xcb\xc7\x77\xf5\x09\x89\x63\x2a\x65\x7c\xbf\x34\x37\x12\xfb\xad\x30\x88\xf2\xc5\xe5\x97\xfa\xd8\x9c\x6f\x85\xce\xbe\xc7\x25\x4c\x04\xac\xe1\x74\x09\x56\x7b\x23\x02\x96\x44\xfc\xb7\xc4\xf9\xcb\x65\x38\x95\xc0\x74\x27\x60\x19\x1b\x66\x69\x37\x10\xd3\xae\xda\x28\x20\x86\x44\xa8\xe6\x2d\xd5\xec\x56\xb5\x8b\xe4\xcb\xf3\xc1\x3a\x90\x55\x87\x13\x2f\x0e\x61\x21\xf0\x85\x6b\x46\x8b\xd0\xda\xdf\xb2\xe0\xc5\x03\x9f\x0b\x71\xc5\x52\xa4\x64\xfa\x3e\xdf\x1d\x34\x3f\x07\xb8\x2c\x99\x1b\x64\x8a\xcd\x0b\x71\x79\x1a\x19\x4b\xb3\x46\x5b\x49\x88\x4a\x74\x8e\xfb\xbe\x22\xbd\xa1\xc6\xdf\x70\x63\x98\x8e\x59\xe6\x3f\xca\x9b\xfe\xb5\xa5\xaa\xb3\x6e\x12\x42\xe7\x49\xab\xaf\x29\x57\x64\x48\xb3\xe1\x04\x23\xf1\x5c\xd5\xd8\x35\xb3\x69\x9c\xcd\x71\xcc\x7a\xea\x4b\x9b\x7c\xea\x49\xf7\x2a\x40\x74\xd8\x10\xf9\x7f\xf9\x13\xef\xc9\x97\x75\xe2\xad\x70\xaa\xec\x39\x1a\x94\x4d\x4e\x95\xe2\x0d\xc3\x87\xb9\xa1\x83\x47\xb9\x0a\x98\xa6\x72\x73\x28\xda\x24\x6e\xcb\x1d\x2e\xf1\x0c\xfd\xea\xd9\xdb\xa9\x54\x62\xba\x7c\x6f\x77\x23\xda\xc3\x46\x2f\x44\x95\x4e\xee\xde\x93\x96\x15\xff\xff\x8b\x65\x98\xf4\x37\xe3\x53\x96\x66\x74\x1a\x9b\x8c\x51\xb3\xe9\x80\x25\xf2\xd7\x94\x87\x21\x4f\xd9\x50\x44\x90\x20\x98\x66\x18\x92\x82\x85\x34\x4e\xe5\x83\x83\x47\x43\x26\x71\xc9\x5a\x1f\x23\x7e\x49\x58\x2c\xe4\x52\xda\x23\xff\x4d\xa3\x19\x4d\xe6\x64\xef\xc9\xa3\x5d\xb2\xbb\xdb\x83\xff\x91\x8f\xc7\x07\x2d\x9d\x3b\xf8\x9f\x69\x46\x33\x3e\x84\x3f\xa7\x4c\xb6\xf8\x6e\x44\xfa\xf8\x45\xe2\x25\xfb\x9d\xfb\x9d\x5d\xf8\x3d\xa4\x19\x1b\x8b\x64\x4e\x5e\xd0\x0c\xda\xfb\x27\x4e\x75\x4a\x3e\x63\x5f\xaf\xc8\x07\x55\xe0\x0d\x08\x02\x17\xfc\x93\x5d\xd2\x69\x1c\x32\xd5\x6c\x5f\x92\x82\x25\x76\x72\x01\x12\x08\xf8\x3d\xfa\x11\xa6\x22\x64\x9d\x50\x8c\x9b\xfd\x4e\x04\xd9\xf6\x76\x08\xc2\x3c\x95\x20\x57\x6d\xa2\xca\xf1\x77\xb7\x4b\x9e\xfd\x83\xbc\x16\xe3\xb4\x6e\xee\x78\x46\x32\x21\xce\x4c\xda\x49\xe8\x43\x02\x7a\x9c\x73\x31\x84\x98\xc0\x56\xe5\x12\x81\x13\x9f\xe9\xa0\xc7\x5c\x92\xba\x1d\x39\x0d\xd8\x07\xb4\x3e\x2c\x38\x01\x45\x98\xa8\x28\xc7\x5b\x9b\x05\xca\x93\x3d\x3b\x9a\x4f\x07\x22\xac\x52\xdc\xdf\x53\xdc\x85\xc1\x1d\xe4\x50\x07\x33\x1e\x66\x3b\x3c\xd2\xe2\x9a\x84\x81\x8c\x63\xc8\xd2\x8e\x1e\x2c\x9a\xb6\x80\x5e\x82\x3c\x23\x6a\xb3\x8a\xb5\x9a\xc2\x45\x98\x09\xcc\x3f\xa9\xaa\xa4\xd0\x82\xb8\x88\x54\xbc\x88\x8c\x3b\x58\xfd\x20\xf4\xe4\x99\xdb\x4c\x2e\x42\xbd\x5d\x11\xba\x95\x84\xa5\x22\xc4\xb8\x00\xb2\xf8\xe4\x53\x26\x8e\xc0\x5e\xe6\x98\x8e\x3f\x61\xea\xea\x5e\xb7\xcb\x86\x53\xba\xa3\x34\x67\x72\x26\x69\xd8\x11\xc9\x18\x8b\xf7\x1f\xee\x77\x1f\x75\x76\xbb\xff\x2f\x65\xc3\x1d\x91\x1b\x53\x27\x13\xca\xfc\x46\x62\x17\x23\xdc\x70\x53\x87\xfe\x34\x93\x27\x05\x54\x3b\x56\x4d\xe7\x86\xa0\x7b\xa4\xe6\xe7\x47\x3d\xcf\x80\xaa\x6c\x9a\xd3\xf9\xf4\xd8\x8e\x82\x3c\xd3\xa4\xfc\x41\xfd\xd1\x71\xc6\x48\x7a\xde\xa3\x42\xcd\xce\x73\x92\xc6\x6c\xc8\x69\xc8\x7f\x63\x01\x39\x67\x49\x8a\xe1\xc6\xc8\xa7\x01\x4d\xd9\xbf\x58\x26\x67\x87\x5c\x4c\xf8\x70\xa2\x62\x81\xa6\xe4\x53\x11\xf9\x27\x67\xb8\xb0\x3c\xe3\x84\x9f\xeb\x65\xad\x72\xf6\x7f\x7f\xa5\x06\x72\x3c\x61\xea\xaf\x4c\x10\xf0\xc8\xed\xf8\xcb\x1f\x27\xd2\x5f\xfe\x09\xbd\x20\x1e\xc9\x72\xf6\x90\x63\x96\x7d\xa0\x17\xc7\x74\xdc\x04\xd4\xf6\x42\xc5\x25\x5b\x90\x67\x39\xe6\xc1\x77\x2b\x80\xb6\x73\xd3\xd8\x72\x3c\xb9\xc8\x33\xec\xe9\x89\x0f\x82\xae\xc6\xf6\x8e\x54\x0a\x53\x74\xd9\x95\xdd\x99\x45\x53\x9a\x9e\x79\x79\x94\xfd\xbb\x8a\x36\x68\x4c\x58\x8a\x87\x64\x19\xe3\x38\xdd\x87\x0b\x8f\xbc\x0b\x6a\xcc\xee\xfd\x10\x06\xef\xca\xd3\xca\xfb\x99\xd1\xb1\xbe\x36\x79\x42\xbe\x80\x85\x2c\x63\x55\x53\x60\x24\x39\xce\x46\x06\x9d\x86\x23\xb0\xb0\x7d\x19\x0a\x95\x6c\x62\xcb\x44\x0e\x84\xfd\x6a\x1b\x1b\xd1\x57\xbd\x4b\x48\x3c\x07\x22\x3a\x67\x72\x92\x3f\x01\xba\x4f\x28\x9e\xc6\x86\xc8\x2c\x95\xff\xff\x29\x3f\x74\x83\xe6\xd3\xea\x6b\x76\x88\xed\x2d\xb1\x6a\x15\xa4\xbc\x55\x20\xdf\xfa\x8b\x56\x78\xe3\x74\x57\xae\x16\x19\x2e\xe4\xfd\x32\x4e\xf3\xd1\x96\xb0\xdb\xd7\x1d\x88\x6f\xb1\x2b\xd9\x5f\xdc\xdb\x6b\xab\x9e\x74\x7f\x0a\x57\xb2\x2d\x06\x71\xfc\x0b\xb9\xa9\x29\x49\x9f\xf6\x06\xdf\xc8\x3e\xcf\xc5\xb5\x35\xa7\x35\xa8\x38\xa1\x81\xb8\x70\x12\x63\xa1\x57\x94\x2a\x2e\xc9\xcf\x84\x5f\xda\x04\x9c\xb5\xf5\x5d\x42\x81\x9f\x34\xf0\x8f\x06\xb9\x8b\xdf\x4f\x9d\xd4\x68\x03\x71\x79\x04\x5f\x7b\x0a\x1c\x6f\x0c\xda\xc3\x37\xf7\xb6\xae\x4a\xc7\xe3\xfb\xd6\x2d\xf0\xe9\xb2\x9f\x3b\x31\x8d\x59\x82\x2d\xb6\x15\x22\xb9\x4f\x06\x0e\x2e\xb0\x4a\xfc\x40\x03\x3e\x4b\x7b\x64\xdf\x55\x59\xaa\xe1\xb5\xae\xc7\x0f\xec\x6b\xf4\x75\x42\x53\x4e\x9d\xd9\x74\xa6\xaf\x5c\x70\x15\x17\x22\x73\x4c\x36\xc9\x4b\x0e\xde\x3e\xe6\xc6\x91\x09\x09\xaf\x14\xe4\x4c\x29\xb5\x85\x04\x70\x2d\x11\x75\xef\x6c\xbe\x9d\xd5\x54\x6d\xde\xe2\x5b\x53\xe3\xe6\xe2\xb8\x1e\xc5\x9b\x83\x31\x67\x02\x8a\x4b\x81\x04\x2c\xce\x26\x6d\x32\x14\x49\xc2\xd2\x18\x45\x30\x82\x7c\x0a\xe2\x4f\x84\xab\xa8\x90\x31\x1b\xaa\x99\xc5\x8c\x6d\x90\x41\x5c\x4e\x2c\x5e\x16\xc9\x80\x65\x17\x8c\x45\x64\x97\xd0\x28\x20\xfb\xf7\x09\x8f\x86\xe1\x2c\xe5\xe7\x8e\x0d\x2d\x0b\xd9\xb9\x4a\x4a\x54\x31\x2c\x94\x69\x54\x3a\xb8\xa9\xd5\x22\x3b\x1a\xb1\x04\x23\xa7\x29\xd9\x69\x60\x9b\x49\xff\x6f\x46\x93\x65\x1c\xdc\xac\x45\xa8\x5c\x96\x05\xa7\xb5\x25\x7d\xd2\x54\x62\xd5\x0a\xbf\x34\xa3\x29\xf6\xc1\xf2\x29\x78\xb1\xcf\xe6\x3b\xfe\xd4\x1f\xcd\xbc\x99\xef\xa6\x64\x63\xdf\xb6\x0a\x7f\xb6\xa1\x9b\x0d\x14\x7b\x23\xff\x32\xed\x1a\x37\xb7\x0d\xe3\x33\xda\xa1\xfd\xe3\x19\x06\xcc\xb4\x25\x7f\x27\xfb\x0f\x8a\x99\xed\x79\xea\x80\x7c\x82\x98\xd9\xe6\xe7\x5d\xd2\xf8\x44\x38\xe6\xb8\xe7\xd3\x18\xd9\x9e\x05\x9d\xb2\x70\x8a\xae\x4f\xe1\x4a\xa9\xd4\x98\x77\xc0\xe4\x47\xf0\x83\xd3\x9d\x1e\xd9\x6d\x9d\xae\xe2\xcd\xa7\xf8\xbb\x4d\x6e\xe3\x94\xbb\x9e\x7c\xef\xd1\xc3\x68\x59\x6f\x3e\x8f\xef\xda\x4b\x39\xf3\xd9\x19\x31\x1e\x7b\xf8\x96\x81\xe5\xf1\x07\x79\xe7\x7d\x21\x3b\xb1\xd3\xad\x8d\xeb\xf7\xbe\x8c\x93\x20\x37\xd3\xcb\x6e\xce\xb9\x6a\x4b\x6c\xb6\x4e\x8d\x3f\x8d\x9f\xa2\xbb\x3f\xfe\xd9\xae\x08\xcb\xce\x81\x3d\x0c\x2a\x27\x15\x59\x66\x59\x84\xe6\x9c\x59\xde\xf3\x13\xb7\xa6\x12\xd3\x2b\x67\xe3\x30\x3e\xcd\x0e\x8b\xef\xbb\xbc\x7b\x7d\x7e\xa1\xd0\x1d\x70\x0a\x85\xbf\xb6\xe3\x11\x7a\xaf\x36\x7c\x9d\xc5\xa2\x10\xf7\xfb\xcb\x4a\x8d\xca\x85\x40\xa5\x08\x73\x02\x21\x57\x1c\x04\xef\xa8\xee\xf7\x64\x42\x93\xa9\x88\xe6\x3a\xde\xf1\xf7\x5d\xb4\x9c\xec\xab\xe9\xe8\x1f\xbe\x79\xff\xee\xc3\xf1\xcb\x17\xfd\x37\xef\x5e\x7c\x7c\xfd\xb2\xbf\xdb\xef\x3f\x8f\xe3\x1f\x69\xd2\xef\x57\x66\x10\xb8\xbf\x31\xea\xbe\x25\x6d\x49\x13\x9d\xa8\xb9\x14\x16\xbf\x1b\x09\xc3\x99\x21\x4d\x8d\x1c\x12\x01\x44\x22\xda\x99\xd0\xa9\x48\xe6\x2d\xd9\xc5\xb2\xe6\x82\x8a\xd9\xc5\x76\xbe\x6b\x7b\xaa\x39\x73\xf0\xaf\x32\xce\x0e\x7d\xba\x2e\x41\xf6\xfa\xfd\xe7\x10\xf3\xa3\x92\x20\x0f\xee\x3d\xdc\x18\xf5\x06\x04\x71\xb0\x6c\x9d\x20\xd0\xce\xca\x04\x29\x19\xe7\x06\x04\xd9\xef\xf7\x7f\xa4\xc1\x98\xd5\xd0\xe3\xd1\xa6\x98\x37\x20\x87\x45\xb2\x6d\x6a\x40\x33\x2b\x13\xa3\x38\xc8\x0d\x68\x71\xaf\xdf\xff\x51\x64\x99\x98\xbe\xa5\xe7\x7c\x0c\xa7\x4a\x0d\x59\x9e\x5c\x63\x23\x1b\x50\xa8\x14\xdf\xd6\x89\x95\x6b\x71\x65\xba\xd5\xce\x42\x09\x09\xed\x10\x06\x3c\x0a\xe4\xa5\x4e\x76\x99\x8f\x9a\x65\xbd\x16\xab\x4e\x57\xc9\x88\x7e\x9c\x65\x99\x88\xbe\x6b\xb5\x36\x9a\x17\x85\xe5\x5a\x66\xe7\xa4\x0a\xfb\xe9\xda\x0c\x7f\xbf\xdf\x47\x1c\x35\xc7\xf3\x9a\xbb\x8f\x83\x7a\x03\xe6\x76\xb0\x6c\x9d\xa5\xd7\x23\x55\xc9\x38\x37\xd8\x81\x1e\x68\x6c\x3f\xd2\xb4\xfa\x48\xb8\xff\xe0\x5a\xb0\x6f\x40\x97\x1c\xa6\x9b\xa1\x8d\x6c\x6b\x65\xfa\x54\x8c\x79\x03\x1a\x3d\xec\xf7\x0f\x68\x12\x54\x9f\x0c\x0f\xd6\x24\x8f\x41\xbc\x01\x61\x0c\x8e\x6d\x93\x44\xb6\xb2\x32\x31\x0a\x23\xdc\xe6\x4e\x6f\x1a\x53\xbd\x7d\x0e\x1d\x4d\x57\xdd\xd2\xdd\xaa\x6b\x8f\xf7\xc4\x43\x53\xdc\xb0\xb7\x36\x68\x95\x9b\x7c\x9d\x41\xeb\xaa\x1b\x0e\x5a\xa3\xb9\xc1\x41\xff\xc4\x68\xc0\x92\x75\xc6\xac\x6a\x6e\x38\x64\x85\xe5\x06\x47\xfc\x86\x05\x9c\xae\x33\x60\xac\xb8\xe1\x78\x11\xc9\xfa\xd7\x90\x47\xfd\x3e\x84\xdd\x18\x88\xcb\xea\x5d\xf5\xe1\xde\x35\x20\xdf\x60\x67\xf5\xf0\x6c\x7d\x77\x55\x2d\xad\x4c\x99\xd2\xd1\x6e\x70\xd8\x3d\x96\xf8\x78\x5c\x4d\x96\x47\x6b\x92\xc5\x20\xde\x80\x24\x06\xc7\xf6\xc9\xc1\xe3\x95\x49\x51\x18\xe1\x06\x64\x78\xd2\xef\xcf\x32\x1e\xa6\x7d\x48\x44\xff\xfc\x82\xce\xb5\x73\x4c\xf5\xcd\xfd\xc9\xee\xf5\xb7\xb5\x01\xb1\xea\xd0\x6e\x9d\x7e\xf9\x26\x57\x26\xe6\x32\x93\xb2\x89\x58\x6e\xb7\xdf\x7f\xc1\x69\x28\xc6\x35\x2b\x6d\x4d\x41\xa9\x8b\x7b\x13\xc1\x9c\x83\x66\xdb\xf4\xc2\x76\x56\x97\xcc\x95\x8c\x74\x9b\x37\x4c\xb7\x3d\xd3\xeb\x35\xaf\x99\x7e\xe5\x4d\x46\x7e\x92\xc3\xb5\xc5\x6b\x48\xe9\x04\xac\x79\xe5\xf4\x2b\x5f\xc7\x04\xdc\xc0\xcd\xb3\x6e\x02\x8e\xd9\xe5\x66\x93\x00\x08\xae\x71\x22\x00\xdf\x4d\x4f\xc6\x31\xcf\x42\xb6\xde\x34\x60\xd5\xeb\x98\x00\xc4\x74\x73\x43\xbf\xe0\xd9\xe4\x8d\x18\xf0\x90\xa9\x9d\x6c\xc5\xf1\x17\xea\x6f\x36\x09\x05\x74\xeb\x5f\xd5\xf7\xf6\x24\xe2\x73\x1e\xd4\xdc\x3c\x1e\x3c\x5e\xf3\x4e\xe8\x21\xdf\xe4\xa8\x72\xf1\x6c\xff\xac\x82\x86\x56\x27\x51\xd9\x60\x37\xb9\x42\xec\xf7\xfb\x2f\x12\x7a\x51\x77\x25\x7c\xb4\xa6\x64\xca\xc5\xbd\x09\x5d\x1c\x34\x5b\x27\x0b\xb4\xb3\x3a\x55\x4a\x46\xba\x09\x51\xee\xf5\xfb\xaf\x44\x32\xad\xb9\xa5\xaf\xbb\x56\x0c\xe6\x4d\x08\x62\x90\x6c\x6b\x5f\x34\x0d\xb4\xc9\x77\xf2\x0f\x79\x14\x25\x22\x5c\x75\x43\x74\xab\xae\x4c\x52\xd3\x87\x13\x0f\xcf\x36\x8f\x83\xfc\xb0\xff\x95\x88\x59\xbc\xce\xa0\xb1\xe2\xa6\x43\x46\x2c\x37\x39\xe0\xd7\x74\xc0\xd6\xa2\x32\x56\xdc\x74\xc0\x88\xe5\x26\x07\xfc\x13\x64\xbf\x5f\xe7\xce\x97\xab\xbd\xe9\xd0\x1d\x54\x37\x39\x7e\xb5\xaa\xd6\xa6\xbb\x57\xff\x9a\x96\x78\x15\x17\x2c\xbd\xc7\xde\xef\xf7\x31\x73\x5c\xcd\xfe\xbd\xee\x91\xea\xe0\xde\x64\x07\x77\xd0\x6c\xfb\x48\xc5\x76\x56\x27\x4e\xc9\x48\x37\x39\x52\x1f\xf4\xfb\x87\xc3\x1a\x95\xf5\x93\x75\xe5\x24\x06\xf1\x26\xf4\x30\x48\xb6\x4d\x0d\xd9\xca\xea\xb4\x28\x8c\x71\x13\x4a\x3c\x44\x64\x0b\x4c\x08\xf6\xee\xad\x29\x88\xcc\xe3\xdf\x84\x2c\x39\x54\x37\x41\x9c\x35\x0d\x0a\xaa\x46\xbd\x09\xa1\x1e\xf5\xfb\x87\x51\x3c\xcb\x6a\x68\xb4\xee\x35\xd4\xa2\xde\x84\x3c\x16\xcb\xd6\x29\x23\x9b\x59\x9d\x28\xc5\x61\x6e\x55\xb0\x68\x9b\xd3\x5d\x5e\xeb\x60\x75\x6a\x6e\x30\xe2\x13\x17\xcf\x36\xef\x14\xc5\x51\x3f\x0f\x44\x02\x01\xf6\xd6\x1a\xb9\xad\xbd\xf9\xe8\x2d\xae\x0d\xee\x13\x8f\xfb\xfd\x7f\x25\xbc\xda\x74\x64\xff\xc9\x9a\xd6\x56\x16\xf3\x26\xab\xd0\x20\xd9\xf6\x22\x94\xad\xac\x4e\x93\xc2\x18\x37\xd9\x12\x9f\xf4\xfb\xaf\x79\x5a\xb3\x23\xae\x6b\xf8\x66\x31\x6f\x42\x0a\x83\x64\xdb\xa4\x90\xad\xac\x4e\x8a\xc2\x18\xb7\xba\x1b\x9a\xd6\x54\x7f\x0f\x33\x36\x5d\x75\x43\x30\xf5\xd6\x1f\xeb\x89\x45\xb2\xcd\x5d\xb0\x6c\xb4\xca\x54\x7d\xcd\x31\xaf\x6b\xe8\x5e\x32\x72\x85\xea\xa6\xc7\x0f\x97\xdd\x35\x47\xbf\xde\x45\xb9\x64\xec\x80\xe8\xa6\x47\x7e\x04\x21\xe0\x68\x32\x47\x75\xde\xba\x93\x90\x47\x73\x1d\xf3\x91\xc7\x79\xd3\x53\xb3\x8e\xb0\xc5\xab\x7b\x1d\x93\xb0\x75\x41\x4b\x7e\xe4\x47\xb3\xc1\x64\x2d\xfb\x36\xbf\xf2\xa6\x63\xb7\x98\xd6\xbf\x0f\xed\xef\xf6\xfb\x6f\x58\x34\xab\xb9\x0f\xad\xe9\x64\x61\x31\x6f\xe2\xfb\x62\x90\x6c\xfb\x10\x96\xad\xac\xee\xfa\x52\x18\xe3\x36\x0f\x61\xdb\x9a\xea\xef\x3a\x87\xb0\xa9\xb7\xfe\x58\x4f\x2c\x92\x2d\xae\xba\xc2\x68\xe1\x9a\xb4\xc6\x68\xd7\xba\x5e\xe5\x47\x0b\x48\x36\x58\x66\x7b\xfd\xfe\x1b\x11\xd0\xb0\xfa\xb2\xbb\xbf\xae\x8f\x99\x45\xbd\xc9\x42\xb3\x58\xb6\xbe\xd2\x64\x33\xab\x13\xa4\x38\xcc\x4d\x5c\xfe\xf6\xfb\x7d\x70\x25\xae\xd6\xa0\xaf\x29\xc2\x74\x30\x6f\x42\x0e\x8b\x65\xdb\xe4\x80\x66\x56\x27\x47\x71\x98\x9b\x90\xe3\x5e\xbf\xff\x5e\xc4\xe2\xbc\x86\x20\xf7\x76\xd7\x94\x8f\x79\xc8\x37\xa1\x89\x8b\x67\xeb\x54\xc1\x86\x56\xa7\x4b\xd9\x60\x37\xa1\xcc\xfd\x7e\xff\x7d\x22\xc6\x09\x4b\xd3\x4a\xd2\x3c\xdc\x5d\x77\xef\xf2\xb0\x6f\x42\x1b\x0f\xd1\xb6\x4e\x24\xaf\x91\x36\xf9\xee\x80\x27\xc3\x59\x48\x13\x5d\xb8\xb2\xf5\x7f\xbe\xfe\xca\xd4\xf6\x7a\x74\x52\x44\xb8\xcd\xf3\x39\x3f\x1b\xaf\x79\xc4\xd6\x9f\x8b\x5c\xed\x4d\x67\x22\x87\x6e\x83\x93\xfb\x41\xbf\xff\x81\x06\x5c\x54\x73\xff\xde\x9a\xca\x15\x07\xf5\x26\xac\x6f\xb1\x6c\x7b\x53\x82\x66\x56\x27\x4d\x71\x98\x5b\xbd\x25\xdb\xe6\x74\x97\xd7\x32\xfd\x70\x6a\x6e\x30\xe2\x13\x17\xcf\x06\x5c\xf8\xb0\xdf\x3f\x62\x21\x1b\x56\x4b\x4b\xef\xed\xde\xdb\x1c\xf7\x26\x7c\xe8\xa0\xd9\x36\x23\x62\x3b\xab\xd3\xa5\x64\xa4\x9b\x9c\x8d\x8f\xfa\xfd\xa3\x88\x0e\xcf\x06\x35\xb1\x3c\x1e\xee\xad\x7b\x36\x7a\xd8\x37\x21\x8c\x87\x68\xeb\xa4\x51\x2d\xad\x4e\x9c\xd2\xf1\x6e\x75\xa7\xf0\x5a\x74\xfa\xbe\xa6\xf9\x7c\xbe\xfa\x66\x33\x70\x52\xc0\xb7\xc1\xf6\xf1\xb8\xdf\x3f\xca\x58\x5c\xf7\xe0\x79\xb8\xb7\xae\xa0\xc7\x45\xbe\x09\x9f\xba\x78\xb6\xce\xa6\xd8\xd0\xea\x34\x2a\x1b\xec\x56\x99\xd4\x6d\x50\x75\x7c\x65\xc6\x94\x75\x36\x1a\xe9\x09\xe2\xd8\xe6\x75\xb2\x64\x9c\xeb\x05\x00\x71\x6a\x5e\xc3\x98\x2b\x03\x7c\x6c\x75\xe4\xeb\xee\x40\x4e\xd5\x6b\x18\xfb\x0d\x78\xef\x94\x0d\x7e\x2d\x3b\x0b\x5b\xf1\x1a\x06\xbe\xa9\xd5\xe2\xfe\x93\x7e\x1f\xe3\xd8\xd5\x78\x68\x6c\x8e\x7a\x93\xcd\xd6\x41\xb3\x2d\xd2\x3a\x4d\xb4\xc9\x77\x6f\x66\xfc\x78\xc2\x20\xe0\x2a\x7a\x6b\xac\x2a\xca\xcd\xd7\x5f\x99\xce\x4e\x7f\x4e\x8a\xe8\xb6\xc9\xe4\xfe\x4c\xd8\xb0\x87\xeb\x38\x25\xa9\x9a\x9b\x8d\xde\x41\x74\xb3\xe3\x86\x39\x5f\x67\xd8\x58\x71\xf3\x51\x23\x9e\x9b\x1b\x34\x86\x0f\xd6\xdc\xb6\xea\xc8\x73\xb5\x37\x1b\x7e\x0e\xd9\xfa\xdb\xdb\xbd\xdd\x7e\x7f\x28\x42\x91\xd4\x88\x04\xf7\xd7\x34\xca\x76\x71\x6f\x12\x92\xcd\x41\x53\x45\x68\x0c\xed\xa9\x32\xc8\xac\x7c\x83\x44\xec\xab\xc7\x15\x73\x3a\xb6\x3e\x01\xf6\xfa\xfd\xa3\xf3\x71\xad\x0d\xf6\xda\x04\x70\x71\x6f\x42\x01\x17\xcf\xd6\xaf\xf3\xd8\xd0\xea\xd4\x28\x1b\xec\x26\xe1\x0b\xf7\xfb\xfd\xa3\x0b\x9e\x0d\x27\xd5\x2b\xe3\xfe\x9a\x7a\x0c\x17\xf7\x26\x74\x71\xd0\x6c\x9d\x2c\xd0\xce\xea\x54\x29\x19\xe9\x26\x44\xb9\xd7\xef\x1f\xd3\x41\x58\x1d\xcd\xed\xe1\xfd\x35\x65\x67\x0e\xea\x4d\x48\x62\xb1\x6c\x9b\x22\xd0\xcc\xea\x04\x29\x0e\x73\xab\x01\x22\x6d\x73\xba\xcb\x3f\x8a\x60\xbe\xea\xe1\x69\x2b\x6e\x30\xde\x13\x07\xcd\x16\x6f\x0d\x25\x43\x3e\x60\xe1\xca\xaf\x20\x5b\x71\xf3\x21\x03\x9a\x9b\x1d\xf2\x2b\x21\xb2\xd5\x5f\x06\x6e\xd5\xcd\x87\xad\x10\xdd\xec\xc0\x7f\x62\x34\x58\x6b\xd8\x50\x71\xf3\x41\x03\x9a\x9b\x1d\xf2\x7b\x3a\xe6\x98\x51\x71\xad\x81\x3b\xd5\x37\x1f\xbe\x83\xec\x66\x27\xe1\x83\xb8\x58\x6b\xf4\xb2\xde\xe6\xc3\x96\x58\x6e\x76\xbc\x47\x22\x59\xcf\x8d\x26\x57\x7b\xf3\xb1\x5b\x5c\x1b\xbc\x83\xee\x03\xd6\x9a\x57\xd0\x83\x75\xef\x15\x06\xf3\x26\xd7\x0a\x83\xe4\x06\x6e\x15\x6b\xbc\x84\x0a\x63\xdc\xea\x9d\xc2\xb4\x86\xfd\x5d\x83\x01\x37\x18\x21\x30\xdd\x26\x9c\xf6\xa0\xdf\x3f\x9e\xc7\x62\x9c\xd0\x78\x32\xaf\x8e\x4a\xbc\xa6\x25\x42\x1e\xfd\x26\x4c\x97\x43\xb5\x75\xd6\x33\x6d\xad\x4e\x9e\x8a\x51\x6f\xf2\xd4\x78\xd8\xef\x1f\xb3\xcb\xec\x15\x67\x61\xb5\x8f\xd9\xc3\x87\xeb\x6e\x0b\x3e\xfa\x4d\xc8\xe4\x63\xda\x3a\x95\x74\x53\xab\x13\xa9\x7c\xc8\x9b\xd0\xe8\x51\xbf\x7f\x2c\x44\x58\xa7\xb5\xdf\x7b\xbc\xa6\x78\xde\x43\xbe\x09\x7d\x5c\x3c\x5b\xa7\x0e\x36\xb4\x3a\x6d\xca\x06\xbb\x09\x65\x1e\x23\xbe\xac\x26\xda\xe9\xc3\x87\xeb\xca\xb5\x5c\xe4\x9b\x50\xc6\xc5\x73\x13\x94\xc9\xd6\x08\x7c\x5a\x3a\xd8\x4d\x28\x63\x82\x6f\x5e\xf0\x6c\xf2\x0b\x0f\xb2\x6a\x01\xd7\xde\xba\xe9\x84\x4a\x1b\xd9\x84\x52\x65\xf8\xb6\x4d\x31\xd3\xd4\xea\x34\xab\x1b\xbe\xa6\xdd\x82\x7f\xdd\x2e\x61\x69\xc8\xa3\x6c\x47\xe5\xef\xdc\x89\xd8\x65\xb6\x13\xf2\x88\x29\x32\x74\x47\x3c\x49\xb3\x62\x45\x3f\x15\xd6\x83\x3f\x79\xd2\xf4\xad\x66\x0d\xff\x8b\x67\x64\x87\xa4\xe9\xdd\x2e\xf9\x27\x8f\x26\x2c\xe1\x19\x0b\x4c\xd2\x4c\xcc\x08\xfb\xd5\x67\x54\xdf\x6e\xd6\x73\xa8\x38\x81\x10\x52\x95\x83\xb0\x0c\x0a\x33\x5a\xe7\xc3\xe2\x80\xd5\xf5\x41\x27\xd6\xfb\xa2\x92\xae\xbf\x15\xc1\xe6\xd9\xd6\x01\xc9\xd6\xd2\xac\xab\x79\x28\xcb\x5f\x1e\xf0\x34\x0e\xe9\xbc\x47\x1a\xa3\x90\x5d\x36\x74\x4e\x61\xf9\xe3\x05\x4f\xd8\x10\x53\x26\x36\x86\x22\x9c\x4d\x23\xf3\xf9\x42\x6e\xfc\x3d\xd2\xd8\xdb\xdd\xfd\x2f\x53\x38\x10\x97\x47\xfc\x37\x1e\x8d\x7b\xa4\x81\xa9\xcc\x77\x06\xe2\xb2\xd1\x26\xdd\x2e\x79\x9f\xb0\x73\xb9\xb6\x62\x1a\xc8\x07\x32\xe1\x69\x3a\x63\x44\xf2\x14\xa4\x98\x06\xa7\x29\xc8\x1e\x3d\xe2\x97\x2c\x20\xb1\x48\xb9\x6c\x99\x05\x04\x93\xda\x75\x54\x1b\xbf\x1d\x46\x01\xbb\xd4\x59\xd6\xf1\x57\x87\x02\x88\xdb\xf5\xa3\x49\xc2\xa3\xb3\x1e\xd9\x75\xf3\xad\x6b\xa4\xaf\x64\x13\x76\x06\x74\xb1\x9c\x02\xf9\xc5\x8c\x27\x13\x71\x8f\xec\xea\x5f\x21\x1b\x65\x3d\xd2\xa0\xb3\x4c\x18\x88\x84\x8f\x27\x59\x45\x2b\xcf\x07\xa9\x08\x67\x19\x2b\x6d\x88\xaa\x8f\xd7\xd4\xd6\x51\x46\x33\x3e\x2c\x6d\x29\x85\x4f\x8d\x85\x93\x03\xea\xde\x17\x7a\x21\xac\x9e\xdd\xde\xa7\xc1\xb0\x0c\x7a\xcc\x32\x08\xb8\x46\x53\x08\x31\xdc\x5c\x80\xab\x55\xe8\xde\xfb\x84\x4f\x69\x32\x5f\xba\x7b\x31\xc2\x9f\x3c\xd8\xdd\x3d\xdd\xa0\x67\x2e\x9a\x62\xa7\x9e\x0f\x87\x90\x69\x74\xc9\x3e\xa5\xda\x19\xbe\xf3\x7c\x7f\x77\x77\x83\x5e\xf9\x88\x54\xbf\x6e\x11\x72\xf5\x14\xb2\x99\xae\xb0\x81\x41\x3f\x2b\x76\xb0\xdd\x56\x47\x44\xec\xdd\xa8\x79\xd2\x50\x27\x65\xa3\x4d\x1a\x6a\x46\xe4\x9f\x14\x86\x2f\xff\x52\xbb\x28\x66\x07\x5f\xa1\xf9\xf7\x8a\x59\x17\xf7\x40\xf3\xb2\x59\xa8\xce\x42\x5a\xb9\x55\x27\x5f\xac\x49\x37\x7f\x3c\x61\x64\x88\xf6\x84\x44\x8c\x60\x67\x32\xb9\x64\x6d\x8e\xf9\xe1\x84\x87\x41\xc2\xa2\x55\xd3\x52\xe3\x41\xb1\x66\xda\x5f\xa8\x7c\x3d\xf9\x7e\x25\xaa\x96\x9f\x67\xff\x63\xca\x46\xb3\x90\x64\x82\xe0\x45\x11\xf3\xfe\xcb\x73\x84\xd0\x38\x0e\x39\x0b\xe4\x37\x33\x17\xa9\x33\x19\x4b\x65\xf6\xf6\x5b\xfb\x27\x1f\x47\x22\x61\x3e\x0e\xcc\x43\x5e\x35\x3e\x48\xd0\xec\x63\x41\x62\x49\xd6\x2d\x90\x8a\x1c\x66\x8d\x94\xcc\x52\x79\xd2\xc8\x2f\xb0\x72\x88\x5a\x39\xe4\x62\xc2\x22\x92\x4d\x68\x46\xa6\xf4\x8c\xa5\x24\x65\x51\xca\x9c\x11\xe1\x5a\xbc\xb6\xd5\x50\xec\xb5\xde\x9e\xa1\x7b\xf3\xd8\x69\xdb\x6e\xdc\x1b\x2d\x05\xd8\x01\xec\x25\x09\x8f\x50\x4c\xfc\xdf\x52\x8f\x11\x7d\xb7\x94\xd3\x9e\xda\xc4\xf8\x8a\xb5\x31\xcd\x7b\x9c\x76\x74\x81\xd9\xa8\x90\xdc\xf6\x3b\xfe\xf6\x3e\xeb\x8c\xf5\x3e\x90\x2c\xf5\xb6\x3b\xfb\x59\xfe\x6a\xe7\x8e\x2e\xf3\x55\x17\x68\x00\x48\x4e\xaf\x93\x33\x57\x3d\x0d\x6c\xa6\x66\x40\xd2\x26\x27\x0d\x3d\x92\x86\x97\x61\xdc\xcb\x0e\xde\x80\x9e\x00\x49\x55\xa3\xb8\xad\xe8\xc9\x31\x39\xf2\x55\xeb\xce\xe5\xdc\x36\x68\xf3\xf9\x8b\xcc\x64\xf7\x3f\xb1\x18\xc9\x5d\xac\xac\x2e\xcf\x9d\x21\x8d\x79\x46\x43\xfe\x1b\x7b\x25\x1f\xbd\xaf\x25\x8b\x26\xad\xa6\x86\x6f\x9d\xb6\x49\xd3\x21\x95\xdc\xb2\x16\x27\x52\xb7\xf0\x4e\x17\x70\x74\x4b\xb6\x0f\xc0\xb2\x71\xa4\xd5\x6d\xb9\x6d\x69\x9e\x5f\x9c\xd3\xdb\x6d\xbf\x31\x9d\xf1\x1d\xcd\xa5\x96\xbc\xb0\x0f\x42\x69\xab\xed\xf2\x62\xab\xed\x73\x51\x0b\x98\x53\x0b\x26\xf0\xa5\xa5\x5b\xea\xa0\xb5\xa0\x4a\x60\xde\x04\x0e\x51\xaf\x08\x0d\x82\x6c\x03\xdd\xd5\xcf\x64\xdb\xcf\xcf\x26\x0d\xb8\x7c\x96\xb7\xbd\xc4\xe1\x18\xb5\xa4\xd1\x76\x33\x87\xdf\x6f\xbb\x7b\x95\xe5\x87\xab\x36\xb2\x65\x4b\xdd\x0b\x14\xab\xdd\x22\xa4\xf5\xf4\xd6\xd5\xad\x5b\xea\x0e\x1b\xeb\xbd\x18\x99\x7b\xc8\xd2\xb4\xc3\xa2\xf3\xce\xdb\x77\x2f\x5e\xf6\x5f\xbe\xfd\x37\xcc\xf2\x77\x71\x22\x82\x19\x46\xca\x21\x3f\x10\xc8\x8f\xae\xf3\x9a\x2f\xb5\xd7\xe6\x92\xf4\x5f\xf7\x76\x96\x43\x7f\x4d\x3b\x56\xbe\xd3\x7f\x86\x23\xf6\xd6\xe2\x75\x8a\xb9\xef\xed\x76\x54\x4b\xd8\x65\x53\xe9\xbb\x5b\x5a\xed\x79\xba\x34\x42\xb5\x2d\x5e\x1b\x0f\x2d\xdb\xb0\xd9\x34\x17\xb6\x5d\xcf\x5d\x72\x87\x49\xd8\xa8\x25\x5f\xfb\x57\x4f\xf5\x72\x54\xad\xb9\x37\x41\xb5\x58\x6c\xff\x6f\x95\xbc\x0f\xe1\x74\xd5\xcf\x6f\x2b\xf9\x85\x11\x39\xb2\x14\x3b\x1a\x7c\x90\xb7\xc9\x67\x12\xc1\xc6\xd1\x78\x33\xe3\xd8\x87\x06\xb9\x6a\x35\xf1\xcf\x56\xad\x10\xf2\xaa\x33\xa4\x61\xd8\xac\x93\x6a\x36\xef\xb5\x5a\xad\x82\x90\xf4\xe1\x35\x0a\x49\xaf\x41\xea\x89\x82\x1e\x8c\x0e\x57\x99\x4a\x18\x44\x7f\x0b\x9a\x32\xdc\x84\xed\xb0\x68\x36\x65\x09\x1d\x84\x7a\x2f\xbf\x45\xc8\x98\x65\x3d\x2b\x15\x19\xb3\xac\xd9\xd2\x22\x10\x75\x9a\x54\x88\x99\xb0\x7b\x2d\x4d\xc0\xa7\xf2\x55\x85\xbd\xdf\xba\xdc\x29\x47\xbd\x47\x5f\x22\xf5\x20\x91\x7a\x65\xba\xf3\xc7\x7f\x30\xf1\xa0\x77\x5f\x02\xed\x1e\x7f\x53\x4f\x7c\x53\x4f\x6c\xa0\x9e\x20\xdd\x2e\x21\x17\x8c\x9e\x7d\x53\x45\x5c\x8f\x2a\xe2\xaf\xab\x34\xf8\xf0\xfc\xc5\xe1\xc7\x23\xf2\x8c\xec\xed\x6f\x49\x8d\xe0\x5c\x92\x12\x16\xd2\x8c\x9f\x5b\xd9\xb6\x55\x31\xf0\x28\xe4\x11\xdb\x01\x4d\x83\x2b\x48\x1d\xc8\x3d\x7b\x65\x9d\x44\x22\x2e\xbc\x6f\xbf\x24\x34\xee\x91\xc6\x45\x42\x63\x53\xfe\x9f\x59\x9a\xf1\xd1\x5c\x39\x09\xf7\x48\x43\x5e\x46\xe5\xb3\x4e\x7d\xa7\x21\x1f\x47\xf5\x5f\x0f\x33\x36\x4d\x8b\xdf\x16\x4a\xf3\x77\x70\xd6\x73\xf2\xfb\x5c\xe9\x48\x44\xd9\x2b\x3a\xe5\xe1\x5c\x4b\x7f\x33\x63\xec\xd5\xb1\x1f\x5d\xf0\x5f\x18\x62\x2a\x05\xc7\x8f\x2e\xf8\x11\xff\x8d\x95\x00\xc7\x97\xc7\xe2\x03\x9b\x36\xb1\x3b\xad\x9c\x62\x47\x31\xcc\xf7\x64\x5f\x7f\x98\xa8\x56\x8b\x5f\x50\xd5\xf3\x81\x06\x7c\x26\xa7\xe9\x81\xab\x11\xaa\x97\x85\x7b\x82\x9f\x52\x11\x78\xc6\x2e\xb3\x03\x17\x4a\xeb\x7f\xf6\xe4\xee\xf8\x81\x45\x01\x4b\x40\xc2\x07\x1c\x44\x44\x24\xa7\x9e\x88\x11\x89\x85\xa4\x28\xa7\x21\x49\x78\x1c\x87\x0c\x25\x96\xdf\xb4\x09\xdb\xd7\x26\x2c\x14\xac\x27\x40\x35\x16\x80\xf6\x8f\x47\x96\x7c\x56\x0c\x0a\x3f\xcd\xaa\xbc\x61\x11\x80\x23\x8a\x58\xbf\x62\xef\x8f\x12\x3a\x78\x82\x94\x3c\x09\x70\x95\x5c\xf0\x30\x24\x03\x46\x68\x10\xb0\x80\xe8\xed\x9a\x64\x82\x64\x13\x9e\x92\x48\x0e\xe5\x8f\x57\x76\xfc\x49\xc9\xf0\x4d\xd3\xb2\xaa\xa6\xc5\xbe\x15\x4b\xc4\x4a\x05\x5d\x07\x3c\xff\xf2\xaa\x0e\x77\x3f\x31\x8a\x05\xb7\xf0\xc6\xd4\x1b\x0b\x15\x2c\xeb\xaa\x37\xdc\xd1\x2c\xa5\xe2\x30\xfa\x90\xd3\xd6\xd3\x8d\x35\x1c\x8e\xb0\xde\x9d\xf1\x95\xd0\x41\x95\x45\x82\xc1\xcf\x57\xd7\xa9\xd0\xd0\xac\xd5\x5a\x55\xc9\xd0\x08\xf8\x79\x63\x81\x6a\x61\x15\x4d\x01\xfe\x5a\xa2\x61\x42\x1a\x69\x4c\xad\x21\x8e\xd7\x4c\x6e\xd2\xaf\xec\x35\xcc\xf2\x06\x14\xb5\x8c\x66\x02\x96\xcb\x1f\xa3\x98\xf8\x76\xc8\x5f\xcf\xe9\xf2\xed\x8c\xde\x7c\x16\xff\x6a\xaa\x9a\x05\x67\x6a\x4e\x5f\x82\x9b\x44\x8d\xba\x44\xa3\xbb\x16\xcd\x08\xb4\x06\x8a\x11\x14\xe5\x6e\x47\x2f\xf2\xe4\x8b\x94\xac\x8b\x2c\x13\xd3\xb7\xf4\x9c\x8f\x69\x8d\x49\xd4\x03\x70\xa1\xfb\x43\x85\xec\xb9\x8e\x96\xc9\xdb\x4b\x47\x84\x91\xea\x2a\xc7\xb5\xb7\xcc\xb8\xca\x71\xde\xc4\x30\xb1\xa5\x2f\x40\xb9\x70\x7f\xf7\x4f\xae\x5c\xb8\x79\xf9\xff\x56\xd5\x19\xdf\x94\x0b\x5f\xa9\x72\xe1\xaf\xab\x33\xb8\x21\x47\x83\x45\x02\x7a\x2d\x77\x7e\xf0\x70\x49\xa1\xb2\x63\x47\x1e\x83\x23\xcf\x16\x45\x99\x5f\xa0\x8d\xf0\x9f\xe6\x4a\xfe\xf5\x8b\xcd\x0e\x68\x18\x4a\x6e\x24\x23\x98\x54\x25\x0c\x63\x78\x1a\x92\xe1\x84\x46\x63\xa5\x97\xd0\xcd\xc6\x34\xa1\x53\xf2\x19\xbb\x74\x45\xd0\x65\x46\x32\x1c\xfe\x95\x8a\x59\x32\x64\x86\xeb\x14\x7a\xbf\x2e\x8d\xe6\x57\xaa\x85\x5f\x98\xde\x70\x50\xb6\xcb\x08\x8f\x02\x76\x69\xea\x4b\x16\x35\x43\x14\xd1\x01\x74\xa8\x72\x84\x92\x1f\xfd\xf1\x1d\x8e\xc8\x27\x79\xa4\x7f\x6a\x13\x1a\x86\xe4\x53\xf9\x6d\xe9\x53\x8a\x02\xe7\x74\x22\x2e\x64\xbb\x3c\x21\xa1\xe4\x08\x35\x72\xf2\xe3\xdc\xf4\x52\x44\xe1\x1c\x09\x0b\xf1\xef\x59\x50\x89\xd3\x41\xc9\xb3\x14\x11\x5a\x92\xcb\x72\x08\x9b\x52\x4d\xf5\x81\x10\x61\x51\xc8\x89\xf3\xa6\xe7\x67\x96\x24\x2c\xca\xc2\xf9\xe2\xee\xd8\xa6\xd5\x4d\xc7\x6c\x91\xf0\x5b\x4b\xe9\xe4\x7f\x40\x4e\x68\x19\x55\xfe\xd4\x97\x51\x3e\x22\xcd\xdb\xea\x6e\x15\x27\x22\x13\x60\x1b\x3e\xa1\xe9\xbb\x8b\x48\xdf\x57\xf0\xb9\x93\xc3\xd7\x6a\x99\x5d\x36\x9b\x24\xe2\x82\x44\xec\x82\xbc\x4c\x12\x91\x34\x1b\x20\xa9\xfc\xd4\x20\x77\x0d\x34\xb9\x4b\x1a\x9f\xc8\x84\xa6\xb0\x35\x91\xff\x6d\xd0\x68\xfe\xbf\x8d\x36\x19\xcc\x32\x72\x41\x53\x12\x89\x4c\xc2\x9e\xf3\x00\x17\x15\x54\xf6\x3a\x0c\x18\x3a\xe4\x3d\x4d\x53\x7b\x73\x23\x22\x21\x34\x9a\x2b\x01\x26\x8c\xbb\xd3\x00\x79\xa0\xda\x7e\xf3\x82\xda\xdc\x54\xe6\x65\xb6\x7a\x07\xf5\x45\xad\x5b\x31\x47\xd7\xbc\x6f\x20\x74\x81\x06\xb0\x0c\x65\x40\x6c\x91\x06\x42\xe6\xd1\xdf\xe1\xd7\x4d\xd8\xac\xeb\xbe\xca\xbf\x6d\xa7\xe4\x2f\xe8\xc2\xf5\x58\xb0\xfb\xc6\xd8\x39\x4f\x81\xbc\xd8\xf2\x40\x7d\xea\x4c\x69\xdc\x74\xc9\x68\x9d\xcd\x09\x96\xb7\x11\x0d\xe8\x74\xbd\x55\x90\x47\xc9\xd3\x7f\xd3\x90\x07\x5a\x14\x0a\xb5\x5a\x2d\x7d\xdd\x88\x66\x61\x88\x8c\x66\x7a\xf6\x6f\x45\x0c\xf8\xd1\x71\x48\x22\xef\x3e\xb6\xd1\xa7\xde\x2b\x30\x2f\x7e\x0d\x45\xc4\xbc\x26\xdb\x66\x9d\xe9\x2d\xa1\xe7\x35\xf7\xec\x19\xf1\xe8\x6e\xe8\xd1\xf3\x3a\x62\x8a\x41\xae\x6a\x57\xd0\x0f\x15\x50\x3d\x52\xc1\x6d\x6e\xeb\x79\x66\xee\x99\xbf\x70\x09\xc2\x52\xbc\xfa\xa3\x05\xdd\x56\xf0\x9c\x5b\xfe\x7f\x8c\x0c\x7a\xc9\x93\xe2\x9b\xbc\xf5\x9b\xbc\xb5\x1c\xa1\xb3\xfb\xd6\xdc\x9b\x96\xc5\xe6\xed\xdf\x35\xfc\xb8\x2c\x3e\x3c\x01\xda\xeb\x5c\x47\x36\xbf\x8c\x7c\x89\x57\x91\xab\x5b\x57\x79\xd9\x76\x7e\x1f\x2a\x11\x73\xbb\xbb\xc4\x88\x86\x29\xbb\x1e\x39\x77\xae\x65\x14\x79\xe7\x05\xab\x5b\x91\x7e\xdf\xdf\xfb\xb2\xa4\xdf\xdf\x8c\x8d\xff\x48\x79\xe0\x98\xc9\x62\x5c\xe1\xef\x46\x15\x5d\x78\x5c\x01\x5e\x27\x4a\xf3\x21\x7d\x59\x9f\x7c\x1c\x1f\x4c\xd8\xf0\xac\x6a\xcc\x4f\x2a\xe0\xeb\x86\x9a\xc3\x6c\x31\xc0\xc5\x06\x34\xe3\x55\xcd\x41\x7e\xc4\x02\x74\x6d\x63\x0e\x52\x53\x37\x16\x69\xca\x07\x21\x3b\x10\x51\x9a\x25\xb3\x61\x26\x92\x0f\x70\xd9\xaa\x6c\x77\x6f\x71\xdd\xba\x5e\x54\x37\x68\xf0\x2a\xbf\xac\xea\xa1\x17\x41\xeb\x5a\x34\xe8\x7c\xb1\xf0\x37\xe1\x71\xb9\x65\x3a\x8a\x08\x7e\xa4\x69\x95\xec\xf6\xfe\x83\x12\xd8\xba\x46\x2c\x94\xa9\x78\x38\xac\x54\xaa\x3d\xb9\xef\x41\xd5\x21\x96\xdf\xbf\x34\xa1\xb7\x7a\x8d\x6c\x2c\xf7\xd6\x78\x16\x88\xbe\x2b\x42\x42\xd9\x29\xff\x0b\x49\xec\xb3\x84\x46\xda\xc6\x5d\xd9\x8f\x9b\x92\x54\x3d\x16\x9b\x27\x8e\xd3\x3c\xc6\xf6\xd9\xc9\x44\xdc\x38\xb5\x4f\x65\x42\x82\x59\x42\xab\xd0\xe8\x6f\xf2\xb9\x9b\x64\xaa\xca\x95\xb1\x47\x57\x38\x8f\x45\xdc\x23\x8f\x73\x85\x78\x57\xea\x91\xbd\xdd\xdc\x87\xd7\x10\x3e\x67\x6f\x3f\x57\xfc\x01\x35\x09\xb6\x7c\xca\xa3\x5f\xd0\xde\xfd\xb1\x41\x31\xa5\x97\xaa\x6c\xef\xe1\xe3\x85\xb6\xe9\xd6\x6e\xda\x75\x44\xe8\x91\xc6\x9e\xe7\xdf\x60\xa5\x05\x9f\x4b\xc6\xf5\xb0\xb6\x19\xd7\x5e\xbc\x0c\xa7\x5c\xb4\xef\xa2\x70\x5e\x8e\x1b\x71\xa5\x31\x1d\xf2\x68\xdc\x99\x45\x3c\x23\xdf\x93\x7d\x17\xcf\x45\x42\xe3\x98\x25\x65\x8a\x1a\xd7\x5d\x63\x19\x97\x88\x45\xba\x9c\xd2\xa8\x51\x15\x91\xa6\xdc\x2e\x86\x28\x42\xf9\xbc\xbe\xcf\xc4\x02\x27\x88\x52\x2c\xb2\x0e\xd9\x21\xfb\x86\x17\x85\x9c\xc5\x6c\xde\x23\x7b\xed\x92\x15\xd2\x90\x75\x76\x52\x59\x69\xb7\xb3\x9f\xb6\x35\x38\xfc\x6a\x14\x6b\xbc\x60\x38\xc9\xbb\x9d\xbd\xb4\x94\x59\x5e\x17\x47\xbd\xee\x30\x3c\x3f\x83\x09\x0f\x02\x16\xe5\xb0\x9b\xb1\xed\xd6\xf4\xd4\xef\x27\x1f\xca\x61\x17\xb9\x66\x10\x8a\xe1\x59\xc3\xae\xa7\x64\xcc\x23\x1d\xcc\xea\xba\x95\x71\x5f\xa3\x5a\xe8\x78\xc2\x60\xee\x08\xc3\x23\xa9\x43\x0e\x47\x84\x12\x04\x25\x3c\x35\x2f\xde\x36\xe1\x99\x31\xd6\x9f\xa5\x2c\x20\x34\x25\x14\x18\x81\x84\xf2\x7d\x38\x4b\x1c\x63\x6a\x24\x47\x9d\xdd\x97\x9c\xd0\xe6\x49\x7d\x4f\x57\x94\x68\x99\xd3\x79\x4d\xa1\x96\xae\x7f\x3d\x52\x26\x85\xad\x55\x16\x73\x07\xf6\x10\x33\xe5\x66\xd6\xd4\xd6\xf2\x15\x47\x99\xa8\x67\xd1\x35\xd4\x7a\x25\x28\x42\x3e\x3c\xdb\x00\x83\x3d\xfe\x96\xd6\xc6\x39\xba\x45\xb9\xa4\x2b\xcc\xc8\x96\xd3\x02\xae\xd0\xec\xaf\x62\x46\x86\x34\xd2\x4b\x90\xcc\xc5\x2c\x21\xe2\x42\x09\xce\x3a\xe4\x5d\x36\x61\xc9\x05\x4f\x59\x9b\x5c\x30\x32\xd2\x0a\x5e\xa5\x5e\x05\xb9\xb0\x0d\x71\x03\xda\xd6\x6f\xaa\xc1\x65\x55\x83\xf2\x2c\xa8\x34\x17\xb4\x8a\xa3\x3e\xac\x86\xbf\x99\xbb\x39\x0e\x10\x44\x6f\xe6\xf5\x6a\x05\x6f\xe5\x08\xdb\xa4\x80\x05\xf4\x22\x95\xca\x49\xac\x66\xcc\x06\x6d\x08\x59\xfb\x33\x63\xd3\xb8\x4d\xfa\xd9\x84\xa7\x20\x61\xcc\xd4\x47\xab\x67\xb3\x22\x0c\xdb\x3f\x04\xaf\xb0\x33\x54\x18\x46\x22\x21\x4d\x68\x23\x04\x7d\x1b\x4d\xc6\xb3\x29\x9c\x66\x21\x8b\xc6\xd9\xa4\x2d\x4b\xe4\xd1\xf8\x3c\x49\xe8\xbc\x29\xa1\x5a\x6d\xd2\x3f\x63\x73\xf2\x8c\xec\x3e\xc5\xbf\xfe\x0e\xb5\xf1\xc7\xdd\xbb\x96\x2b\x64\xd5\x13\x59\x78\xea\x62\xc6\x12\x4d\xa1\x9c\x92\x0c\x44\x9d\x30\x5e\xfc\x63\xc2\x53\x2d\xfc\xac\x16\x61\xe4\x87\xac\x55\x37\xe5\x43\xef\xf4\xfb\xc0\xe6\xfd\xbe\x7c\xf9\x00\xea\x9c\xd8\x69\x11\x89\x5b\x2d\x58\x0f\x1d\x79\x0d\x98\x2b\x79\xf8\x89\x6c\xfa\xb4\x33\x14\xd1\x90\x66\x4d\x39\xf2\x16\x98\x3a\xcb\x62\xfd\xdf\xce\x84\x46\x41\xc8\x8c\x42\xd8\x32\x1e\xd8\x60\xd8\x89\x43\xa2\x4f\x78\xfa\xb7\x58\xdd\x4c\xb0\x3e\x2e\x40\xf3\xf6\xf1\xb4\xcb\x0e\x7c\x41\xc7\x4c\x1c\x15\xb2\x0b\xe7\x29\x14\x15\x3e\xb9\x1f\x17\xd1\xc9\x52\xd4\xf5\xea\x2d\x43\xb7\xd1\x72\x1e\x63\xba\x0c\xc7\xd3\xc6\x36\xd5\x62\x34\xc4\x36\xd5\x25\xce\x5c\x6d\x59\xa4\x26\xc3\xd6\xc2\x7b\x21\xae\x02\xad\x9d\x58\x86\x19\x9c\xf5\xa2\x04\xf4\x7a\x31\xbb\x52\xb8\xc5\xeb\xf9\x04\xbb\x78\xc6\xe6\xe0\x81\x1e\x05\xe6\xd9\x91\xdf\x76\xf1\x63\x33\x47\x48\x37\x60\x99\xf3\x63\xff\xe9\x2d\x17\x4a\x53\xba\x9c\xd0\x78\xc5\x78\xa6\xc0\x3a\xf0\xd3\xfd\x2e\x6f\x68\xca\x10\x41\x81\xc8\x12\x17\xc2\x18\x9a\x18\x08\x5d\xe2\x42\x59\xa3\x87\x7e\xa9\xd5\x03\x29\xb1\x7c\xe8\x57\x98\x3e\x10\x57\x4b\xed\xc3\x9a\xe2\x2a\x66\x5e\x82\x8f\xab\x58\x78\x35\x7b\x88\xbe\x31\x88\x80\x39\x6d\xb4\x49\x43\xce\x1c\x58\x3c\xa8\xf9\xa9\xb3\x90\x30\x03\xc9\x9b\x4b\xf8\x06\x12\x9a\xca\xeb\x18\x49\x5c\x4b\x84\x3e\x4b\x6c\xc3\x08\xab\x45\xda\xcb\xe3\xd1\xa2\x81\x36\xb9\xed\xd3\xf8\xce\x1d\x72\xdb\x69\x62\x61\xf4\x3d\x3d\x35\x1c\xc5\x8c\x68\x6f\xe1\x6c\x14\x9a\xb3\xdd\x9d\x42\x96\x2f\x30\xe3\xb0\xd5\xee\xdc\xd1\x57\x70\xb3\x48\xc0\x41\x0f\x5f\x25\x0d\x17\x2f\xd1\xbd\xa8\x35\xd7\xd0\x68\xda\x5e\x4d\xef\xc9\xb6\x98\xb6\xb0\x3c\x4d\x8f\x3a\xb9\x25\xd4\x72\x10\x5f\x99\xad\x90\x90\x2b\xc2\xc2\x94\x2d\xd5\xe3\x32\xff\x3e\xfc\x87\xb2\x5a\x3f\x88\xa1\xfe\x27\xa7\xdf\x2f\xd1\x5d\x74\x0a\xdd\x0e\xe5\xf7\x76\x49\x4a\x58\x49\xab\x39\x68\xe2\x86\xe6\xf1\xfa\xfe\xaa\xcc\xbe\x5f\xe4\x52\xdc\x63\xd6\x62\x79\x07\x9b\x23\xd5\x58\x81\xdd\xf7\x5b\x96\xc1\x97\x37\x8a\x01\x02\x39\xb2\xfa\x22\x99\x56\xb2\x95\x69\x93\x91\x18\xce\xd2\x0f\x10\xa8\x02\xb5\xa2\xc6\x7c\xa6\x4d\x3e\xdb\x07\x58\xf1\x7e\x62\x05\xa5\x4b\x7a\x8f\x92\x82\x07\x29\xc9\x7b\x91\xea\x19\x55\x82\x41\xeb\x46\xaa\x39\xcd\xfd\xbd\x02\x4b\x17\x9b\xcd\x35\x9c\x63\xc9\x2b\x1f\x14\xbe\xba\x0c\x7e\x2b\xff\x97\xfb\xa2\x38\x85\x1f\x8a\xa4\xe5\x97\x86\xa7\xb7\xae\x0a\x1b\x94\xf7\x1e\xb8\x6e\x05\xbf\xf2\x53\x2a\x53\xf3\xdb\x0b\x7f\x4e\x51\xbf\xff\x4d\x51\xff\x4d\x51\xff\x4d\x51\xff\x4d\x51\xff\xe5\x2a\xea\xe1\xd7\x0b\x31\xad\x52\xd3\x3f\xb9\x51\x95\xfe\x19\x9b\x0f\xab\xb5\xae\x8f\x1e\xe4\x01\xeb\xd0\x2b\x90\x1b\x35\x17\x38\x63\xf3\x81\xa0\x49\xf0\x4a\x5e\x09\x2a\xfd\x64\xef\x19\xf8\x63\x31\x1b\x4e\xf0\xea\x50\x09\x7d\xbf\x0c\xba\xae\x5f\x0e\x58\x6e\xb1\x61\xe1\x4f\x70\x07\xa9\xcc\xe8\xf3\x20\xbf\xa0\xbd\x5a\xb5\x04\x2d\x82\x7f\x69\x06\x09\x37\xa5\xd3\xcf\x79\x68\xae\xa6\x02\x91\xa5\xd7\x65\x32\x01\xb8\xfe\x58\x8f\xc1\xeb\x56\x44\xd7\x45\x2b\x84\xb8\x72\x53\x71\xce\xc8\x38\x61\x73\x32\xe1\xe3\x49\xc8\xc7\x13\x6d\x9a\xf0\x0b\x1b\x9c\xf1\xec\x98\xc6\x3f\xe9\x0f\x15\xa1\xed\xa6\x53\x11\xa1\xa5\x43\x4c\x13\x27\xc4\x50\xc1\x7d\xb1\xe1\x00\x61\xb2\xa4\x0f\x2c\x65\x99\xf1\x8a\x82\x3b\x98\x56\xd3\xce\x32\x39\x13\x3d\xd2\x88\x44\xc4\x1a\x7e\x08\x3e\x47\x79\xeb\xc7\xe4\xb3\x81\xe1\x66\x49\x8a\xf1\xad\x05\xf7\x26\x64\x96\xb2\xe4\x08\x5e\x48\x79\xd4\xf2\x0d\x40\x13\x1a\x0d\x0b\x8d\x66\xec\x32\x7b\xc1\x86\x42\xdb\x76\xf8\x5f\xbb\x5d\x72\x24\xc8\x05\x23\x19\x3d\x63\x24\x4e\xd8\x90\x05\xe0\x32\x79\xae\x22\xf6\xa1\x96\x56\x8c\x08\x25\x11\x06\x20\xfb\x3b\x25\xdd\x7f\x78\x2a\x3a\x6b\x13\x61\x83\x8b\xab\xf2\xc6\x9d\x5e\x6f\x67\x2a\x7e\xdb\x81\xb7\xd3\x0e\x8f\x22\x96\x34\x7a\xce\xab\x1b\xa7\x00\x76\x57\xdd\x37\x87\xb6\xaf\x78\xc2\x46\xe2\x92\x04\x22\xcb\x58\xa0\xe7\xb5\x93\x93\x67\xde\x52\x6c\x48\x07\xa1\x9f\x31\x0a\x66\xef\xe5\x39\x8b\xb2\xd4\x0c\x5c\x62\x7f\x81\xb0\x24\xe4\xd1\x19\x01\x20\x0a\x8c\x9f\xe6\x09\x60\x22\x66\x90\xeb\x55\x88\xe7\xf4\x66\x2a\xf8\xa1\xd1\x22\xe3\x3a\x60\x41\xc7\x28\x46\xe7\xe4\x42\x44\x8d\x8c\xa4\x19\x4d\x32\x42\x33\xed\xfa\x96\x8a\xc4\x1d\x80\x59\x32\x8e\x06\x1d\x70\xe9\x57\xeb\x4a\x7e\x76\x5f\xb0\xff\xec\xb7\x1c\x3b\x45\x62\x69\x2b\x38\xb0\x41\x18\x09\x5c\xbf\x72\xaf\x76\x62\x05\x92\x97\x1c\x84\xba\xc6\x90\x21\x13\x12\x9e\x50\xf2\xe2\xdd\x1b\xbd\xa8\x41\x11\x98\x27\x37\x34\xe2\x6d\x76\x84\xa7\x84\x92\x4f\x83\xbc\x73\xa5\x93\x9e\x63\x2d\x33\x05\x3c\x15\x37\x33\x55\x00\x1c\xd7\x6a\xae\x20\x4b\x5b\xb5\xda\xef\x01\x4d\x19\x19\x38\x2a\xef\x01\x33\xbb\x92\x9d\x1d\xbb\x4f\xad\xab\x65\xc7\xdd\x82\xb0\xd1\x88\x0d\xb3\xc5\x2d\xad\xbc\xf4\x17\x0d\x6b\x42\xcf\x25\xc3\xe8\x2b\x30\x8a\xc5\x54\xaf\x14\xaf\x7c\xf2\xda\xfe\x44\xa6\xb3\x34\x23\x34\x4c\x85\xec\xe9\x27\x70\xce\x70\x18\xc6\x93\xab\xad\xb4\x43\x1d\x1c\x1d\xe1\x92\x31\x6b\xf3\x62\xc2\x43\xe6\x6f\x57\x92\x4f\xfd\xce\xba\xb3\xe4\xdd\xe4\x59\x70\xb0\xd6\x02\x2c\x1a\x63\xfc\x18\xce\xaa\x63\x26\xde\x84\x35\x87\x88\x60\x44\x2b\x60\xa8\x72\x84\xf7\x26\x52\xcd\x1f\xe6\x84\xb4\x4c\xa0\xe8\xfe\x0b\x23\x59\xc2\xc7\x63\xd8\x61\x3e\xa9\x2e\x7c\x32\x3e\xf0\x24\x13\xa2\xe3\xf4\xf0\x67\x77\xee\x37\x1a\xeb\xcf\x6c\xfe\x42\x5c\x54\x5b\x56\x2d\x89\xe3\x63\xbc\x11\x86\x37\x62\x96\xb2\x8d\xfb\x01\x58\x5e\x33\x7a\xbe\x99\x39\x10\xa0\xd9\x70\x40\xf0\xc2\x7c\x19\x55\x6f\x56\x4b\x23\x79\x23\x36\x1c\x0e\x60\x39\x92\xd7\x9f\x0d\xd0\x24\xa2\x66\x8b\x29\x5b\xd8\x1f\x53\x86\x91\x51\x63\x25\x73\x94\x07\x66\x0c\x1b\x0e\x49\xd8\xc8\xe5\x6c\x7b\xdc\x96\x5c\x94\x64\xf9\x07\x36\xda\xa0\xeb\x19\x1d\xa8\xa0\xda\x6b\x1b\x0f\x46\xb3\xe9\x80\x25\x0b\x5c\x2a\xf3\x56\x79\x85\x7e\xcc\xe3\x45\x53\xe8\x79\x90\x6a\x93\x21\xd7\xbf\x62\x6d\x33\x21\x83\x64\xb1\x69\x90\x01\xdd\x9e\x39\x90\xe7\xe0\x41\xfe\xf4\x26\x40\x66\xb8\x2b\x99\xfd\xd8\x49\x5a\xd7\xd4\x27\xcd\x68\xc6\xd4\x0b\x8a\x90\xc2\x89\xad\x9d\x3d\x89\xb6\x6d\x91\x75\x72\x67\x8b\x95\x84\x55\x1a\x0a\x61\xbd\x33\x3c\x47\x24\xa0\x44\xfa\xd4\xfb\x98\xb2\xec\x48\xf6\xa5\xf9\xb9\xd8\x07\x54\x07\xb6\x3c\x7d\xbb\x63\x69\x94\xef\x90\xab\x2a\xaf\x01\xab\x36\xe0\x91\x55\x12\x2d\x4f\x04\x55\x73\xf9\x08\x74\xf1\x40\x9b\xe8\xe5\x60\x6d\x5b\xc7\x7c\xca\xc4\x2c\xab\x03\x81\x75\x20\xe1\xc8\x33\xf2\x60\xb7\x14\xe4\x0d\xbd\x34\x50\x92\xd9\x1e\xf8\x06\x5b\x3f\xdb\xde\x6d\x6c\xb1\x65\xef\x25\xbe\x8d\x95\x29\x77\x81\x9d\x3b\x66\x0e\xdc\xf9\xe2\x9b\xd0\xd8\xbe\xfa\x16\x5c\xaa\x7c\x15\x63\x2f\x3b\x32\x5c\xeb\xb0\x66\xb4\x68\xdb\x2e\x16\x4d\x6d\x2b\x9c\x81\xb9\x94\xcc\x24\xeb\xc9\xf7\x56\x98\x30\x1a\xcc\x49\x20\x3b\x96\x09\x42\xcf\x05\x0f\x48\xc2\x62\x46\xb3\x94\x0c\x98\x7c\xd2\x0d\xc5\x2c\xca\xd0\x0c\x7d\x3a\x0b\x33\x2e\x87\x4c\x87\x19\xc7\xf4\x88\xa9\xc3\xa0\xee\xa4\xdc\xb9\x43\x6e\xfb\x1c\x74\xe7\x8e\xbb\x00\x3b\x39\x96\x97\x9f\x61\x30\x60\x00\x12\xd3\x21\x6b\x14\x99\xda\x32\xa3\x5c\x1f\xd6\xd6\x01\x06\xda\x89\x59\x92\xf2\x34\x6b\x3a\x46\x10\x2e\x63\x77\xd2\x4c\xc4\xda\xfe\xcd\xb2\x8b\x6f\x65\x92\xab\x40\x93\x2c\xb7\x66\x5c\xab\x8f\x9c\xd9\x9c\x22\xa4\x6f\x38\xa7\x0a\x0b\x2b\xcf\xd2\x44\xaf\x50\x42\x87\x43\x26\x77\x51\x1e\xf2\x6c\x0e\x9b\x7f\x04\xf6\xc4\x4a\x1c\x73\xce\xf4\x83\xda\x9d\x73\x1c\x7a\x46\x93\x31\x43\x83\x7c\x6f\x7d\xde\xb9\x63\x78\xe9\xce\x1d\x87\xc3\xbd\x1f\x60\x73\x43\x1b\x25\x85\x03\xa5\xbb\xbe\x73\x87\x34\x73\xc4\x91\x5b\xb5\x29\x42\x39\x6b\xcb\x1d\xb9\x22\x09\x26\x80\xd7\x12\x7b\x67\x16\x17\x9a\x14\x7a\x8b\xfc\x63\x5c\xb7\xc4\xf3\x9b\x63\x8e\x0f\x6b\x57\x87\x37\xa6\x7a\x16\xad\xe3\x47\x6f\x7b\xbf\x4e\x86\xd4\xa7\xaf\x5b\x2f\x9e\x85\xa9\x3c\x37\xea\x38\xb3\x7c\x66\xd4\xab\xa4\xf6\xb8\xf8\x18\x2f\x43\x14\xf3\x36\x31\x46\x44\x25\x3a\x9f\x82\xc5\x67\xc3\x54\x03\x13\x3d\xb9\xbe\x1a\xe5\x63\x1f\x86\x8c\x26\xea\x0c\x69\x56\x1f\x2f\xa6\x93\x9a\xc8\x16\x02\xd9\xe0\x67\x36\x7f\x9f\xb0\x54\x92\xaf\x09\x44\x32\x35\xec\xdc\x2c\x49\xed\xba\xf3\x1a\x50\x17\x08\x70\xd5\x2a\x99\x34\xe0\xe5\x55\xa7\xec\x63\x8c\x13\x26\xe2\x46\x19\x4e\x78\xde\xad\x81\x16\xea\x19\xcc\xed\x65\x96\xd8\xc2\xc9\xaa\x5f\xf9\xe5\x13\x63\x5f\x63\xab\x0d\xc2\xd6\xb3\xfc\x54\x86\xfa\x65\x14\xac\x81\xf8\x65\x14\x54\xcd\xba\x79\x84\x5e\x2f\xda\x1f\xc3\x59\xb2\x1a\x46\x59\xa3\x94\x80\x37\xb9\x94\x56\x5d\x1f\x79\xf2\x6b\xb5\xf7\xd2\x3b\xbc\x96\x4e\xba\x7c\x87\x3b\x65\xd9\x09\xfb\x8a\x5f\xc2\x71\x3a\xc9\xb2\x38\xed\x75\xbb\x63\x9e\x4d\x66\x03\x79\xb1\xeb\x8e\xe8\x90\x0d\x84\x38\xeb\x82\x3d\x43\x97\xa7\xe9\x8c\xa5\xdd\x47\x8f\x1e\x3e\x71\x5a\xbe\xed\x9e\xa9\xc5\x7d\xc1\xdc\x85\x91\xf3\x55\x04\xc1\x63\x38\x92\x0b\xdd\xa9\x38\x19\xd4\x5d\xce\xb9\x1b\x6b\x49\xc0\xb3\xda\x27\x48\x67\xc0\xa3\x40\x33\x83\xbf\x6d\x97\x90\x31\x60\x19\x1b\x66\xfe\xcb\xc1\x18\xe3\x3b\x63\x69\x97\xf7\xa5\xee\x39\xb2\xe0\x19\xb2\xe0\xf9\xb1\x6d\xff\x01\xe7\xa1\xef\xf9\x0c\x98\xfb\xce\x0b\x1e\xbc\x91\xf7\xdc\x0a\xf7\x81\x02\x5c\xd3\xf5\xb0\x72\x79\x00\x7a\xa1\x8d\x63\x3a\x23\x1e\x05\x2f\xde\xbd\x01\xbd\x10\xbc\x7f\xeb\xa8\x13\xf2\x34\x63\xd1\x2b\x91\xbc\x52\xab\x2d\x6d\x35\x5d\xeb\x46\x6d\xd5\x9c\xeb\xfa\x2f\x3c\x0c\x3f\xc6\x01\x35\x99\xe8\x2a\x3b\x6f\x21\x9b\x11\xbb\xc4\x60\x47\x6d\x22\xff\x84\x75\xeb\x2f\xb7\xea\xfb\x94\xa9\x50\x76\x87\xbf\x5d\x7f\xc5\xbf\x5d\x5c\xc4\xca\xe2\xc4\x61\x9d\xb2\xbb\x4e\x9e\x6b\x16\x4d\x48\x34\x5d\x86\x9c\x0e\x68\x25\x45\x6d\x9c\xc1\xdc\x56\xba\x68\x27\xbd\x92\x7b\xcf\xc7\x14\x35\x7c\x13\x16\xc6\x24\x4b\xe4\x8a\x3e\xb3\x17\x7e\xfd\x8a\x22\xea\x26\x79\xab\x38\x2c\xf4\x5c\xc1\x49\xaa\x75\x6e\x41\x90\xbc\x8b\x8b\xec\xe4\xbe\x72\x5e\xf1\x96\x6f\x25\x25\x2a\xc8\x54\xb2\xd7\x2e\xb0\x03\xf6\xec\x8e\x8c\xb5\xb4\x6f\x22\x1f\x45\x2c\x01\x41\xa6\x19\x8c\x2e\x6a\x46\x72\xd1\xe4\x0c\xf9\x71\x38\x8e\xa4\x42\x04\xce\xad\x9b\xf8\xd6\xc3\xa8\xaa\xee\x39\x7e\x3b\x1d\x57\x7b\x5d\xf7\xa0\x2b\x84\x98\x2c\xe1\xb7\x8d\xfc\x8d\x56\xf1\x30\x72\x3b\xed\x38\xf5\x38\xa5\x1e\xb4\x13\xa2\xb3\x3c\x7c\x2a\xd9\x82\x37\x91\x27\x3c\xa9\x91\x9b\x68\x66\xb2\x60\xba\xa4\x04\x2a\x3f\x64\xaf\xb8\x46\x1a\x53\x2b\x88\xa9\x52\xd0\xd9\x8a\x55\x10\xbe\x84\x46\x5d\xd5\x8c\x3f\x94\xfc\xed\x43\x18\x63\x3e\xef\x10\x2c\x08\x85\x7c\xc3\xbf\x52\xb9\x5d\xa5\x20\xa9\x56\x86\xa4\xdf\xcd\x7d\xef\x71\xe7\xc3\xb8\xcf\x38\x03\x67\x0a\x4b\x60\xf5\x4b\xc3\x07\x86\xd2\x12\x68\xbf\x7d\x55\xe4\xc3\x39\xf7\x73\x03\xa8\xcb\x4a\x20\xd5\x9d\xdb\x07\x95\x85\x25\xb0\xfa\x41\xe1\x03\x43\xa9\x0b\xad\x94\x29\x16\x50\x15\xb8\x30\x5a\x5d\x62\x81\x74\x89\x07\xa5\x0c\xf0\x14\xc4\x3c\xbe\x1e\xff\x37\x77\xa9\x7b\x49\xdc\x6a\x33\xbe\xa9\xd5\x27\x7f\xe8\x35\xe6\xfc\x6d\xb1\x39\xeb\x44\xfe\xac\xe2\x7e\x74\xa3\xd3\xcf\x0d\xc5\xcc\xf8\xa7\xc7\xab\xa6\x48\xbf\xf2\x15\xdf\xe1\x9f\xde\xfb\xdf\x65\x1e\xe7\xb7\x86\x75\x1f\x4b\x0e\xa1\x9d\x9f\xe6\xe5\xa7\x28\x26\xff\xd4\x74\x81\xbf\xe7\xf1\x97\xe4\xe9\x67\xb6\x3a\xb3\x0d\xae\xe6\xe9\x57\xb9\x75\xfd\xfe\x3b\x69\x34\xda\xa4\xe6\x7d\xbe\x82\xbb\x1f\x5e\x7c\x8c\x9d\xd9\x95\xf7\xd1\xe8\xc7\xd4\x99\x60\xd8\xcc\xbf\x5b\x78\x60\x79\xff\x40\x58\x07\x9d\x09\x84\xe3\x74\x8f\xf7\x3c\xee\x06\x6d\xd4\xfa\xd7\x15\xe0\x95\xb8\xb2\xc6\x07\x4e\x36\x9f\xab\xe6\xc8\x39\xdd\xee\x38\xb3\xd0\x51\xcb\x3a\x53\x26\xb1\xf9\x76\x6a\xb0\x2b\xd1\x6a\x15\xe2\x44\xc0\x81\x55\x28\x2a\x69\xc4\xaf\xe8\x1c\xa3\xfa\xcf\xaa\x3b\xcc\x92\xbe\x5a\x5e\xbf\x17\xbb\xb4\x15\x8e\x42\xcf\x4f\xad\xe2\x2c\xf4\x60\xaa\x0f\x36\x0f\xac\xfa\x64\xcb\x83\x55\x1e\x6d\x1e\xe0\xc2\xb3\xad\x08\x5d\x7d\xb8\x15\x61\xab\x4e\x37\x0f\x72\xc1\xf1\x56\x84\xad\x3b\xdf\x8a\xd0\x85\x03\xce\xea\xfa\x0d\xdf\xfc\x40\x76\xf6\x48\x8f\x94\x1d\x62\x65\xce\x8a\x76\x45\xb5\x5d\x3e\xb4\xee\x8a\x9e\xc4\x7a\xd4\xd3\x67\xaa\x73\xc7\xb6\x4d\x14\xef\xa3\xf8\xe0\xf3\x5e\x31\xea\x5b\xb5\x77\x9f\x79\xd2\x2f\xf4\xe8\x73\x34\xcd\x65\xd9\xec\x3c\x83\x56\x54\x72\xe6\x8d\xc8\x4c\x69\xce\x06\xce\x94\xdb\x19\x06\xab\x6b\x34\x6a\xd0\x4b\xf8\xd6\xd5\xd3\xcd\xbd\x0a\xcd\x18\xd0\x93\xd0\xb3\x15\xc8\x79\x0f\xde\xfb\x53\x64\x09\xcb\x89\x1c\xc9\x33\x92\x2b\x71\x27\xb5\x20\xd6\x92\x1b\x63\xb1\xd4\x56\x29\xca\x5a\xc8\x33\x52\x2c\xbc\x11\xff\x22\x9a\x44\x3c\x1a\x57\x39\x6e\xdc\xcf\x03\xd6\xba\x16\x21\x88\x75\xc4\x11\x51\x46\x79\x54\xe5\x52\xb4\xb7\xff\xb8\x00\x5a\xeb\xa8\xa3\x60\x4c\x25\x1a\x04\x60\x0f\xff\x1a\x66\xae\xd2\x37\x68\xff\xd1\xa3\xca\x2a\x75\xed\xe5\x61\x6f\x26\xe7\x9e\xe7\x81\x03\x8d\x44\x34\x54\xbb\x05\xb2\x08\x8f\xc6\xf9\xad\xc2\xf2\xa5\x1b\x2d\xdc\x74\x36\x07\xd3\x8c\x95\x20\xdd\x44\x5d\x57\xa6\xcd\xaa\x1c\x2f\x0e\xc6\xcd\xd6\x5c\x20\x74\x6f\x4a\x56\xc7\x8f\x42\x84\x8c\x46\x06\xb3\x91\x8b\xaa\x99\xa8\xaa\x0a\x79\x19\x4c\x3f\x4b\x16\x4d\x93\x47\x69\x46\xa3\xa1\xdc\x3c\xf0\xd6\xd0\x36\x76\x6a\x36\x71\x0b\xcd\x32\x36\x8d\xb3\x12\x2b\x25\xf2\x0f\x72\x4f\xd2\xc0\xda\x18\xdd\x3b\x2d\xa4\xc0\xf0\x3e\xf6\xc8\x1e\x5c\x27\x97\x4e\x08\x01\x5b\xa9\x5a\x1d\x76\x1f\xd5\xfd\xae\x30\x3a\x69\x93\xc6\x1b\x9a\xb1\x84\xd3\x70\xe7\xe3\x61\x8f\x4c\x79\x0a\x09\xcd\x17\x54\x6b\xb4\x48\x8f\x80\x99\xc4\xee\xd3\x6d\xf5\xd1\xb3\x7a\x59\xad\x9f\x5e\x55\xaf\xaf\x92\xd1\x4a\xab\x58\x4b\x9d\x94\x65\x5a\xb8\x59\x54\x24\x19\x0b\x0f\x87\x8d\x21\x86\x47\x33\x10\x43\x20\x5e\x07\xcd\x14\xdc\xf0\x80\xcc\x06\xe0\xc5\xb7\x96\xde\x65\x1c\x3d\xbc\x66\xaa\x72\x34\x2d\xc7\xac\x40\xb3\x9d\x11\x8b\xe3\xa3\x40\xf6\x4c\xf3\xdf\xdf\x97\x99\x17\x8b\x71\x45\x7e\x6f\x1b\x3e\xbf\x4b\xf6\x7c\xd9\xfc\x02\xb6\xc1\xfc\x27\x72\xa5\xbc\x7a\x77\xf0\xf1\xa8\xff\xf3\xcb\x5f\x8f\xc8\x33\x72\x22\xdf\xab\xf2\xa9\xaa\x5c\xd5\xb4\x29\x82\x2c\x49\x87\xf2\x3f\x33\x78\x0d\x07\xea\xc9\x1c\xb2\x11\x3e\x78\xf9\x78\x92\x35\x4e\xdd\x2d\x86\xa7\xfa\xd8\x72\xb5\x67\x6a\xf5\xdb\x46\x3b\x10\xa0\xee\xdd\xa8\x59\x6b\x16\xd1\x02\x1e\xde\xd9\xf3\x77\x87\xe2\x01\xa9\xb8\xa3\xdb\x25\x87\x59\x23\x25\x94\x48\xd6\x0c\x19\xe8\x90\x2e\x18\xe6\xf6\x8a\x18\x8a\xc0\xb1\x36\x11\x72\x92\xb0\xce\xf3\x30\x15\xf8\x6c\x25\xa1\x18\xf3\x21\xe1\x29\x19\x86\x1c\xb2\x9e\xf1\x00\xab\x03\x9e\x00\xbc\x95\x00\x11\x25\x19\xa3\x89\x9c\x8f\x8e\x4e\x58\x61\xb6\x36\xb3\x3b\x6b\x02\xc3\x18\x0b\x27\x8e\x1d\xec\x05\x8f\x02\x71\x81\x52\x8f\xd9\x42\x05\x78\x61\x86\xbd\x97\x6d\xf5\xd6\xec\x1a\x2b\x69\xfd\xf7\x53\x7f\x3f\x37\x3d\x77\xc0\xaf\x6e\x5d\x6d\x25\x0d\xc4\xfd\x2f\x3c\xba\x84\x2e\x78\xf1\xf2\xf5\xf3\x5f\xfb\x1f\x0e\xdf\xbf\x7f\xfd\xf2\xc6\x83\x4e\x7c\x51\x21\x20\x32\x71\x20\xa2\x74\x36\x95\x6f\x0f\xb0\xf5\xad\x8c\x15\xf0\xb8\xa6\x52\x5d\x17\x8a\x2d\x7c\x8b\x3f\xf1\x2d\xfe\xc4\x9f\x22\xfe\x84\x86\x5c\x88\xfb\x85\x98\xda\x90\x09\x26\x0e\xf6\xbf\x12\x31\x8b\xab\x5a\x79\xfc\xb0\xaa\x46\x6d\xa0\x05\x1f\xf4\x4f\x97\xfc\xa2\x3e\x30\xc5\x83\xbd\x1c\x60\x1d\x76\x1b\x8e\xe2\x86\xdf\x7d\x2f\x3e\x7e\x78\x0e\x07\xed\x33\xf2\xe0\xc1\xee\x53\x2c\xf3\x0f\xa4\x8a\x73\xea\xf1\xee\xd6\x23\x23\xf8\xc1\xd6\x9d\xb8\x06\x74\x90\x8a\x70\x96\x59\x87\x7c\x71\xce\x92\x51\x28\x2e\x7a\xa4\x81\xb1\xd2\x1a\xe5\xc1\x02\x0a\x9e\xf6\xa5\x51\xfb\x75\x5a\x66\xbf\x34\x84\xc4\x0b\x36\x84\xbc\x88\x9d\x5f\xe5\x5e\xf3\xea\xe3\x6f\x5a\x68\xa6\x2c\x81\xe0\x3f\x85\xd4\x04\x36\x02\x7f\x09\xd8\x6b\x46\xcf\xe1\x39\x5e\x1d\xd3\x9e\x46\x7c\xaa\xa3\x15\x4c\x67\x7c\x07\xad\x07\x76\xd8\x25\xcf\x48\x83\xdc\xb5\xa4\xbe\x4b\x1a\xd3\x14\x8a\x8a\x19\x2b\x18\x95\x37\x5b\xf9\x1f\x76\x18\xbd\x9b\x65\x25\x5d\x79\x0f\xa6\x2a\x5e\x67\xea\x48\x53\x3b\x6d\x55\xb4\x5e\x81\x2c\x15\xc3\x56\x06\x35\x64\xef\xc1\xee\xee\xd2\xa3\x95\x53\x43\xf6\xa1\x02\x8f\x46\x3c\xe2\xce\x38\x10\xef\xbf\x39\x9c\x33\x6e\x2c\x06\x4b\x89\xce\xbe\x7f\xfb\xc5\xaa\x8d\x7f\x9e\xb1\xf9\x28\x81\xfd\xce\xa5\x0b\xbc\x84\x2c\xa2\xc6\xee\x7f\x79\x21\x1e\xa0\x9f\x23\x91\x4c\x7b\xa4\x91\x0e\x69\xc8\x9a\xbb\xad\x86\xc6\x6f\x02\x45\xc0\x54\xd4\x57\xdb\xb3\xd5\x96\xe9\xd6\x25\xcf\x6a\x7a\x95\x63\xd2\xda\xae\xd8\x89\x59\xa1\x7d\x45\xb7\x95\x26\x66\xaf\x64\x62\x1e\x2c\x9e\xce\xce\x93\x6b\x9d\xd0\x44\x49\xcb\x3f\xfb\x3c\xfc\x60\x37\xcf\xbf\xb6\xa4\x76\x6d\x14\x57\x78\xdd\x32\xcb\xed\x73\x0f\x9c\x15\x62\x83\xb2\xf4\x48\x43\x99\x6d\x42\x78\x96\x46\xb1\xfb\x05\xfe\x76\xb8\xfb\x9e\x97\x3d\x23\x3f\x25\x8b\xb6\x21\xc9\xee\xd7\xb3\x0f\x21\xc6\x57\x34\x75\x0e\x0d\xd3\xea\x0b\x93\x8e\xa7\x01\x0b\xf9\x66\x82\x90\x60\x84\x91\xd4\x84\x18\xc1\xd1\xe6\x23\x80\x20\x82\x84\x82\x81\x44\x36\xa1\x91\x86\x87\xd3\x43\x82\x3b\x41\x49\xf2\xb1\x48\x56\xf0\xf1\xff\x3a\x82\x71\x00\x35\x00\x8b\xc1\x41\x76\xac\x20\xda\x75\x07\xfe\xbe\x0b\x64\xf3\xc3\x81\xad\xeb\x0e\xeb\x60\x59\xe8\x0f\xeb\xc0\x6e\xcd\x21\x36\x17\x8f\x8c\xfc\xd9\x3d\x62\x9d\xf1\xae\xe2\x12\xeb\x4e\xd3\x75\xf9\xc4\x46\xec\x32\xfb\x99\xb9\x5b\xac\x8a\x29\xd4\x23\x27\x3a\x1f\x95\xaa\x0a\x0c\xca\xa3\xb1\x6b\x49\xe6\xb9\x8a\xc2\x0e\x70\xcc\xa7\xa0\x1d\x72\x7d\x41\xed\x87\x03\x31\x9d\xf2\xbc\xab\xa8\xbe\xa8\x3c\x2b\x75\x6a\x70\x50\x34\x3f\x5f\xb5\xc9\x67\xa2\xe0\x1d\xdf\x59\xaf\x9f\xa9\x32\x06\x2b\x43\x26\x39\x0a\x24\x7a\xe5\xea\x8b\x5d\x5f\x7d\xb1\x5b\xa7\xbe\xd8\x3d\x55\x29\x66\x2d\x66\x11\xc3\xd6\x5d\x8e\x7b\xcf\xc7\xbd\x57\x87\x7b\xaf\x88\x7b\x38\xf0\x78\x75\xff\xd4\xfd\xd8\x57\x2d\xff\xcd\x4e\xa5\x2a\xd1\x93\xeb\xea\xfd\x2d\x50\xb1\x5e\xae\x4b\xe8\xcd\xd1\x2b\x00\x7a\x31\x82\xf5\x37\xb5\xe7\xdb\xb6\xb1\xa0\x68\xe1\xea\xb6\xac\x4b\x72\x0d\xf7\x0b\xb6\xbc\x72\x7d\xe4\x06\xe5\x76\xac\xd8\x96\xf9\x34\xa2\x67\x56\x55\x61\x70\x38\xa5\x9e\x85\xa9\x07\x5c\x8e\x63\xd1\x24\x39\xc0\x7e\xc2\x06\xe5\xc3\x69\xe2\x14\x4d\xe5\x52\x02\x89\xbf\xf5\x48\x2c\x2c\xb3\xa2\xaf\x45\xe5\x4a\xb4\x36\x44\x15\x3e\x32\x65\x9d\xc8\xe4\xb6\xa2\x3c\xaa\x96\x6a\xca\x97\x72\xbb\x2b\xcb\xcc\x9b\x3b\x5d\x3f\xc0\x62\x97\xf3\x63\x04\x34\xc6\x7c\xc3\x71\x9b\xc0\x4d\xd5\xf3\x93\x49\x18\x88\x93\x98\x41\xd4\xed\x92\xbf\xc9\xeb\xca\x2b\x7e\xf9\x46\x9b\xaa\xe8\x80\x72\x63\x96\xfd\x28\x6f\x78\x3c\x1a\x1f\x80\x66\xe1\x03\x1b\x66\x4d\xc8\x03\x6d\xc6\xa4\x2e\xa4\xbb\x96\xe0\xfa\x46\xea\x14\xe5\xae\xa4\xfa\x52\xaa\x07\xec\x7a\x59\xff\x8b\xe1\xed\x05\xd2\xc2\xa9\xbb\x4e\xe2\xda\x9c\xc3\x28\xa0\xe0\x7f\xc8\x33\x47\x99\xe8\x7f\xfb\xb5\xe6\x1b\xa4\xa9\x7b\xe6\xea\xf6\x34\x1d\xed\xb2\x50\xee\x48\x30\xea\xff\x01\xa2\xc2\x46\xe6\x16\xff\xaa\x8a\x7f\xff\x9d\xdc\xf6\xc1\xef\xdc\xd1\x25\xc0\x08\xcc\xf3\xed\xb1\x7d\x7f\x43\xb3\x49\x07\xae\xd0\x4d\x49\x96\x0e\x4c\x25\xe9\x92\x7d\xc7\x2d\xd5\x8e\x26\x0f\x8d\xd3\xec\x81\x17\xec\xfc\xd0\x64\x53\x8d\x21\x37\xa6\x1f\x72\xbf\x7b\xc4\xeb\xf2\xc9\xee\xa9\xfe\xf4\xb4\x04\xdf\xaf\x39\x7c\xbf\xe6\xf0\xfd\x5a\x8d\xef\xd7\xfc\xe8\x72\x73\xa1\x3b\xb4\x03\xcc\xda\x91\xbc\xb3\x68\x42\x74\x9b\xaa\x4a\x06\x66\x99\x25\xeb\x14\xe9\x5b\xa4\x86\xe2\x08\xc0\x98\xfe\x5f\x92\x35\x9b\xfb\xe4\x7b\xfc\x19\x8b\x0b\x87\x3a\x6d\xb2\xdf\x22\x77\x73\x5f\x90\x12\xf2\x53\x8b\x74\xc9\x3d\x6b\x11\x8a\x0e\x74\x22\x21\xa9\x98\x32\x92\x30\x9a\x0a\x0c\xe3\x64\x1e\x16\x84\xa7\x64\x90\x88\x33\x50\xed\x91\x37\x62\xc0\x43\x46\x0e\x26\x89\x84\xe7\x23\xbb\x10\xf8\x08\x66\xb3\x63\x10\xcb\xd1\x38\x7d\xff\x2f\xb2\x8f\xdc\x98\x73\x80\xb6\x10\x77\x9f\x91\xbd\x12\xe3\xce\x32\x8e\x91\x2d\x1a\x9a\x4c\xe9\x65\xd3\x1d\x4e\x61\xb3\x20\x08\x47\x07\x69\xb3\x69\xb7\x15\xbd\x85\x20\x65\x20\x3f\x28\xe9\xc9\xee\xed\x68\xa2\xb7\xda\xe6\x2f\xf2\x3d\xd9\x27\x77\xc9\xfe\xd3\x42\x37\x7e\xbd\xd6\x6e\xfc\x84\x4b\xc6\xeb\xc7\xaf\xa6\x1f\xbf\x96\xf4\xa3\x82\x3d\x0c\xfd\x61\xaa\xf2\x4c\x01\x1d\x07\x76\x28\x73\xa8\x84\x2b\x27\x23\x01\x3b\xe7\x43\x56\x12\x8d\xa0\xb8\x63\x74\xbb\xe4\x7d\xc2\x62\x9a\xb0\x62\xcc\xb9\x4e\xee\x70\x29\xb9\x17\xd6\x87\x6b\x80\x0a\x08\xdb\x74\xee\x81\xfa\x52\xa2\x69\xd4\xd3\x7f\x98\xd9\xd2\x25\xbf\xb6\x9d\x59\xea\x39\x7f\xb7\xc9\x70\xd0\x93\x97\x2c\x2f\xd5\xc7\x53\x77\x58\x2f\x58\x1c\xd2\x39\x8c\x8a\x5d\xb2\xe1\x0c\xba\xe9\x6d\xfa\x0b\x87\xb9\xc8\xf2\xa2\x6e\x72\xdc\xe0\x02\x35\x13\xe8\x3a\xb1\xc1\xa5\xd8\x15\x5a\xb7\x20\xec\xf0\x2f\x0c\x43\xf1\x65\x82\x4c\xe9\x19\x23\x94\x64\x09\x0d\x98\x18\x8d\x30\x3a\x1b\x3c\x6e\x30\x8d\x5b\xd5\xca\xfb\x03\xc8\x71\x55\x72\xcb\x2f\x61\x9b\x98\x26\x74\x9a\xfa\x37\x7e\x7b\xe1\xc5\xaf\x65\x97\x62\xbb\xbb\x2b\x18\xdd\xe7\x02\xcc\xaf\x79\x98\x5f\x8b\x30\x6a\x11\x7a\x60\x30\x2e\xf7\x2e\x3c\xb0\x10\xc3\x81\x67\x7c\xaf\xe3\xba\x3e\xf3\xa2\x54\xa8\x52\xf7\x02\xf2\x3c\x08\x08\xd5\xdc\xa7\x43\x89\xa9\xca\x54\xbe\x8c\xfd\x47\x1d\x79\x46\x4e\xcc\x0b\x11\x1e\x9b\x45\xdd\xb1\x7d\x6f\xaa\x4a\xad\x36\x39\x59\xe0\xff\x57\xe3\xfa\x07\x2e\x74\xee\x28\xd4\x8b\xd3\xb1\x12\x36\x12\x17\xf7\xce\x9f\xf7\x52\xcb\x70\xd1\xf4\xbc\x95\xc2\x2e\x79\xd6\x33\xe2\x34\x77\x72\x95\xc0\x48\x7f\x72\x16\x84\xf9\xb3\xc0\xaf\xf9\x93\xde\xf2\x6d\xfe\x40\xb7\xfc\x5b\xb2\xf9\xba\x7c\xac\x79\xb7\x75\x6a\x0f\xda\xbc\x0f\xbd\x41\x61\xde\xe2\x25\xd3\x45\xee\xda\xb4\xc4\xce\x1b\x5d\xfd\x71\xcb\xac\xf6\xe1\xa0\xf8\x1c\x16\x25\x31\x55\x00\xb2\x2e\x70\x80\xdd\x5a\x5a\xc5\x4b\xe9\x12\x9c\x79\x3c\x91\x0c\x39\x1b\x4e\xbc\x30\xc3\x62\x38\x9c\x25\x2c\x95\xac\xfa\x7f\x33\x3e\x3c\x0b\xe7\x1d\x5b\xe5\x17\x46\xd2\x8c\x87\x21\xb9\xa0\x51\x26\x41\x20\xf5\x67\x6e\x6b\x5d\xf4\x90\x61\x51\xe0\x87\x77\xf1\x36\xc8\x92\xf0\x15\x55\xa1\x5b\xea\xf6\xdf\x25\x77\xdf\xcd\xb6\x7f\x1b\x32\xc6\x10\x55\x11\x76\xb7\xb5\xf0\xa1\xb7\xa0\x87\xce\x2c\x6a\x8a\xde\xb9\xa3\x89\xab\x64\x16\x75\x71\x51\x0a\x1b\x9e\xe5\xc5\x4e\x1a\xf2\x21\x6b\xee\xb5\xdc\x1e\x3b\x23\xb8\xb9\x60\x00\x9e\x98\xb3\x3c\x1a\xc0\xc6\x1e\xe4\x45\x3f\xf1\xc2\xc2\x51\x34\x71\x5c\xc4\x47\x3c\x04\xe1\xf8\x2c\x23\x20\x01\x20\x6c\x3a\x0b\x69\xc6\x02\xe4\xc9\x54\x5e\xaf\xa7\x70\xbd\xee\x98\xba\xbf\x30\x15\x6f\x39\x03\x4e\xe2\x11\x01\x75\x87\x44\x07\xb6\x77\xb0\x56\xdc\xed\x1f\x02\x39\xc3\x02\xfc\x6e\x18\xf2\xe1\xd9\x77\x24\xe4\x67\x4c\xb5\xd0\x71\xd0\xa2\xc9\x9d\x5e\x73\x4a\x1f\xe9\xde\x6a\x2c\xa6\x74\x98\x88\x30\x34\x38\x6e\x99\xb5\xce\x53\xf9\x38\x90\x75\x26\x42\x9c\x81\x15\x25\x0b\xc0\x00\x10\xa5\xfb\x09\x3b\xe7\x62\x96\xea\x5d\x5c\x02\x43\x3c\xb2\x4e\xa5\x1f\xfc\x4a\xee\xd6\xcb\xb8\x55\xe7\x1d\xaa\xd7\x76\x92\x5e\xe0\x20\xbd\xa1\xf3\x67\xa5\xab\xa7\xeb\xdd\xb8\x62\x2e\xb3\xbc\xc5\xca\xf2\x09\xcd\xdc\xf1\xdb\xe8\xdc\xc5\x54\x5f\xda\x01\x3f\xf1\x13\x41\xe2\xf9\x9c\x2f\x5d\x29\x49\x1f\xba\x65\x96\x64\xe5\xd3\x29\xd4\x5a\x39\xef\x22\xef\x44\x52\x9f\x2a\x9d\x8b\x9c\x2d\x62\xa1\x77\x91\x2b\xb5\xaf\x74\x2f\x72\x7c\x02\xd6\xf3\x04\x1a\x85\x3c\xd6\x2e\x07\x8e\x5b\x90\xd3\x38\xf8\x05\xe5\x54\x26\x39\xc3\xcf\x07\x1b\x19\x7e\x22\x60\x47\xc1\xc9\xe1\x91\xef\x54\x4f\xbf\x2b\xd7\x68\x3d\xb8\xff\xb0\x25\xf1\x69\xfb\x1b\x2d\x9a\x2f\xf6\xec\xe1\x46\x3d\x2b\x35\x2c\x7b\xf8\xb0\xf5\xb4\xf4\xcb\x83\xfb\x8f\x5a\x4f\x8b\xa3\x29\xb5\xb7\xba\xd7\xea\xc0\xf5\xb7\x33\x4a\xc4\x54\x2e\xb4\x5c\xbf\x1f\x5d\xa7\x29\x2d\x48\xa6\xb2\xcb\x2a\xbb\xa9\x27\x2d\xb4\x42\xfa\x1b\xe2\xad\x74\xb5\x51\x60\x99\x40\xcb\xdc\x2a\x9f\xa5\x7b\x0a\x4e\x6e\xca\x55\xb8\xc0\x54\x0b\xbc\x60\x52\x98\x86\xc3\xac\xda\xc5\x07\xd2\xff\x60\xc3\xaf\x51\xb9\x51\x65\xd1\x78\x5f\xb7\x0c\xfb\x92\x36\x19\xae\xcc\x63\xf4\x58\x81\x8f\x59\x26\xdb\x7f\x15\x55\xf6\x00\xc4\x56\x6a\x7a\x9a\xea\xbf\x9d\x23\x72\x57\x4f\x59\xe7\x15\xf9\x9e\xdc\x2e\x6f\xe5\x49\xcb\xb9\x79\x71\x94\xb0\x11\x4b\x7b\x2c\x7a\x0a\x91\xab\x1a\x50\xdc\x68\x6b\xcb\xf7\xfd\xfd\xce\x5e\x67\xbf\xb3\xe7\x82\xc3\x2b\xeb\x35\x3f\x63\x6d\x32\xa5\xf1\x28\x72\xed\x97\xd1\xe2\xfd\x79\x32\x76\x0b\xe5\x0e\x26\x6b\x3a\x87\x9a\x8f\x88\x74\xbf\x27\xcb\x22\x23\xdf\x77\x5d\xa5\xec\x3b\x79\x06\x2a\x76\xb0\x08\xd5\xee\x07\x5e\xdd\xca\xbb\x19\xc4\x16\x3c\x25\xf9\x64\x09\x50\xd8\xc3\xf1\xd9\x5a\xf4\x75\xa9\x0e\xd6\x02\xe8\xce\x02\xe0\x3f\xc8\x5e\x51\x99\xe5\xd8\x74\x3b\x95\x62\xb4\x83\xc7\xea\x9e\x3a\xcc\x82\x71\x15\x8d\x61\xd7\x29\xd2\xdc\x61\x38\xa5\xf9\xce\x19\xa4\xd6\x10\x27\x2c\x85\xc7\x68\x9a\xb1\xb8\x0d\x95\x68\x26\x12\x65\x8f\x3f\x22\x4d\xd5\x81\x96\xe9\xfe\x30\xbb\x6c\xc2\xdf\x6d\x3d\x92\x7d\x6f\x24\xfb\xde\x48\xda\x46\x98\xdd\xed\x4a\x7c\x78\xd6\x13\x9e\xca\xeb\x14\xb4\x36\x08\x19\x11\xb2\xbb\x0d\xf5\x1a\x47\xf9\x8a\x3e\x10\x74\x8f\xc8\x0e\x5c\xed\x52\x3e\x95\xb7\xad\x21\x55\x31\x89\xc1\x11\x01\x47\x7a\xdb\x25\xf9\x9d\x3b\xe4\x76\xf3\x40\x92\x0e\xc8\x24\x7f\x3b\xab\x56\x55\x71\x9d\x69\x40\x97\x6e\x1a\x7b\xa6\xa6\x0f\x9d\x0a\xde\xb5\xf4\x3c\xc9\xb7\x01\xbb\x20\x07\xcd\xd6\x53\x72\xbb\x29\xe7\x4c\x81\xca\x5a\xf0\x0c\x6d\xb6\x5a\x9d\x40\x44\xec\x29\xd2\xc4\xd5\xa8\x93\xdc\x1a\x6f\xea\xb9\x07\xc8\xb6\xa1\xf5\x0f\xb0\x0b\x99\xce\x28\x36\x6f\x93\x13\xd9\x9e\x4a\x24\x8d\x75\x4e\xdb\x70\x86\xb4\x48\x8f\xd8\x6f\xf9\x47\x84\x2f\x96\x0a\xf5\x6e\xa4\x37\xa6\xe6\x3b\xfd\x94\x79\xea\x4e\x45\x6e\xbc\x1a\x84\x18\x55\x2d\x74\x60\xa3\x51\xc2\xb0\x9a\xef\x4e\xf4\x50\xe0\xbf\x72\x2c\xba\xa8\x24\xca\x15\x51\x84\xe8\x98\x71\x60\x3f\x6e\x39\x37\x3e\x84\x50\x3e\x23\xad\x92\x73\xea\xf1\x75\x9f\x53\x7f\xf3\xfd\x3d\x2a\xb6\xe4\x7b\xfb\xde\x56\xff\x82\xa5\xc3\x2a\xff\x01\x70\x20\x28\x1c\xca\x76\x4b\x56\x06\x36\x7a\x4e\x91\xee\xc6\x7b\x12\x77\x03\x1e\xa9\xd5\xd6\xca\xf7\xaf\x33\xca\x23\xb0\x3d\x92\xd7\x2f\x44\x07\xb3\x0f\xbc\x83\xc0\x8a\x28\xe4\x19\x7e\x47\x33\xa9\xfc\xd4\x3e\xd9\x68\x6a\xe5\xe4\x1c\x1e\xbf\xfc\xf0\xfc\xf8\xdd\x87\xaa\x49\xdc\x6d\x35\x1b\x7a\x69\x34\xd4\x84\x1e\x3d\x7f\xf5\xb2\x7f\xf0\xfa\xdd\xd1\xe1\xdb\x7f\x59\x35\xef\xad\x2c\x99\x1b\x8f\xcc\x84\xe3\x69\x7d\xf2\xe8\xf4\x44\x37\x71\x8a\xe2\x0a\xf8\x74\xd2\x40\xee\x69\x9c\xe6\x05\xec\x79\xec\xa0\xd9\x45\xb1\x77\xb7\x4b\x58\x1a\xf2\x28\xdb\x51\xae\xf0\x3b\x72\x0b\xd8\x09\x79\xc4\x48\x24\x76\xb2\x49\x22\x2e\x76\x42\xe8\x6d\x78\x8b\xb8\x27\x22\xb4\x99\x0b\x50\x49\x00\x9e\xec\x3f\x05\x81\xee\x15\x19\xd2\x6c\x38\x21\x4d\x49\x58\x79\xdc\xb1\x69\x9c\xcd\x89\x9c\xec\x5a\xd6\x60\x97\x6c\xd8\x26\xe9\x19\x8f\x0f\x42\x91\x1a\xef\x2f\x70\x0d\x73\x4a\x61\x87\x74\x47\xd6\xd2\xcb\xc7\x28\xc9\x41\x65\x43\x47\xcc\x55\x9c\xeb\x29\x55\x67\x5e\xa2\xa6\xd4\x3f\x76\xe0\x18\x4c\xf2\xd3\x4c\xe0\x1b\x6c\x92\x85\x29\xd6\x76\xde\xf2\x9d\xcd\x7a\xba\x55\x75\x3f\xd6\x2a\x06\x0f\x67\x15\x0a\xd9\x86\xa9\x21\xe7\x42\x1e\xf1\x28\x09\xa9\x99\x50\xb3\x77\xc8\x96\x4b\x39\xfb\xc1\xee\xb5\xfa\x89\xe9\x77\x8f\x63\x8e\xaf\x6d\x06\xf4\xa7\x31\xcb\x0e\x26\x3c\x0c\xde\x98\x2b\x40\xae\xc4\x82\x4e\x59\x32\x66\xee\x27\xc9\x12\xc5\xc2\xa5\x5d\x50\x94\xb9\xdd\xbf\xf8\x39\x8b\xc8\x27\x57\xe2\xac\x82\x55\x7c\x6a\xeb\x09\xa3\x7a\x97\x31\x1b\xfb\x19\x83\x3c\x1e\x00\xda\xb9\x45\xd0\x70\x0f\x44\xf8\xe4\xf3\xf7\x57\x36\x22\x5b\x29\x5e\x00\xd6\xdc\x80\x88\xaf\x88\x9e\x01\x31\xf2\x90\x83\xc1\x9f\x61\x82\xdc\xe4\x34\x4d\x5c\x0d\xd9\xb1\x57\x91\xf5\xcd\x9e\x62\x4a\x6f\x87\x7f\xb0\x04\x6b\xe8\x83\x4c\xf5\x01\xea\x9a\xb0\xd9\x30\x71\xb9\x0c\xfe\x2d\x5d\xef\x07\x04\xd6\x3f\x7b\xd8\xc9\xa7\xb7\xb4\x39\x04\x1a\x6b\xa8\x53\x55\xf9\x09\xe2\xbe\xdb\x8c\x66\x61\x08\x3c\x0a\x2a\x6d\xd5\xf1\x96\x6e\xef\x40\x15\x74\xa6\x34\x76\x86\x65\xd9\x7f\x98\xeb\xf4\x10\x1a\x6d\x75\x46\x22\x79\x49\x87\x13\xe7\x2a\xef\x0d\xb1\xdb\x25\xc9\x0c\xd5\xd7\x53\x1a\x5b\x7c\x13\x96\x30\x70\xe0\x65\x34\x20\xa9\xc0\x14\x2d\x12\x4a\x85\xc9\xd7\xc6\xaa\x33\xc8\x1a\x18\x31\xe7\x58\x3e\x41\xaa\x2b\xab\x41\x6f\x5e\xb1\x4f\x8e\x58\x41\x1f\xd3\x57\x86\xdf\x7e\x99\xb0\x88\xcc\xc5\xac\x91\x30\x42\x83\x00\x48\x2e\xe7\x6c\x2a\xce\x21\xf4\xbe\xe6\x1c\x50\xbe\x4f\xe9\x9c\x0c\x00\x4e\xf6\x42\x81\xb1\x40\x1e\x7b\xd9\x84\x49\x74\x29\x05\x1d\x7d\x14\xb0\x04\xb2\xca\x74\xc8\x2f\xcc\x17\x9b\x7f\x3f\x10\xd9\xe4\x7b\x92\xf2\x68\xc8\xc8\x85\xf3\x91\x4f\x67\x61\x46\x23\x26\x66\x69\x38\x97\xb8\x50\xbf\x6f\x63\xce\xcb\x66\x68\x04\x49\x13\x3b\x28\xda\x33\xd3\x97\xd1\x33\x96\x12\x6a\xe5\x79\x29\xcb\x14\xeb\xa6\x88\x2a\x20\x14\xae\x55\xce\x07\x28\x85\x15\x0b\xf3\x3b\xc5\x4b\x30\x87\xb4\x03\x69\x46\xc6\x33\x96\xa6\xd6\x50\x38\x49\xd8\x30\x93\xb8\x40\xbc\xc9\xa3\x71\x87\x1c\x22\x21\x47\xb3\x6c\x96\xc0\x58\xe4\xfc\xc8\xfd\x41\xee\x3b\x72\xbe\x54\xe5\x59\xc6\x43\x9e\x71\x26\x47\x20\x31\x80\x61\xeb\x9b\x59\x98\x71\x60\x33\xa3\xef\x84\x47\x0e\xa3\xe9\x1c\x42\xdc\xa8\xf8\xfb\x17\x08\x2e\xfb\xc5\xc2\x11\x09\x04\x4b\x49\x24\xa0\x27\x01\x97\x7d\x0a\xe7\x4a\x6b\x2a\x6b\x0f\x45\x34\x64\xb1\xc9\x70\x38\x8b\x94\x2e\x58\x4e\x8c\xe6\x69\x18\xb7\x3c\x12\x74\x01\x10\x0e\x92\x66\xc2\x4d\x1f\xb4\xfe\x3c\x03\x9e\xcc\x6f\x26\x7a\x7b\x90\xf8\xf0\xff\x0c\x87\xd0\x54\x71\x19\x0b\xe0\xe1\x28\xab\x7d\x82\xbe\x5b\x31\x9f\xbb\x5b\xe4\x37\xdb\x66\xeb\x53\xa7\xac\x29\x38\xbc\xe0\xff\xae\xbf\xa9\xfc\xae\x07\xf9\xbf\x80\x47\x60\x01\x9a\xe0\x25\x34\x0c\x91\x65\x78\x44\x3e\xc9\x61\x7f\x42\x96\x52\xc5\x12\x97\xfc\x22\x7b\xf9\x09\xd8\x54\xd9\xa9\xa8\x97\x56\xc0\x92\x8e\xbf\x73\x16\x0f\x8a\xa6\x44\x8b\xb1\x70\x71\xb3\x80\xd9\x7d\x86\xff\xf9\xfd\x77\x65\x75\xa9\x4e\x72\xf8\x8f\x2a\x74\x8d\xa2\xc7\x2c\xfb\xb7\xbc\x28\xbe\x12\xc9\xcf\x6c\xde\x3c\x63\xf3\xdc\x36\x05\xdb\x49\x84\xf5\x7f\x80\xff\x9c\xc0\xc6\xd1\x83\x76\x4e\xb4\xa1\x31\xa8\x06\x94\xd9\x0d\xa3\xc3\x09\xd4\x13\x23\x35\x42\x34\xaf\x0f\x79\x6a\x97\x52\x26\xe4\xee\xc5\x92\x8c\x0c\xd8\x48\x24\x2a\xc7\x14\xb6\x86\xa8\xd4\x0e\x36\x80\xa7\xa2\xac\xab\xb6\x67\xa5\x47\x4c\xdf\x33\x30\x91\xab\xda\xa7\x15\x74\x8c\x50\x2a\x5c\xce\x09\x74\xd6\x98\x64\xcb\x21\xfc\x8c\x03\x94\x7f\xba\x61\x23\x9c\x4f\x76\x86\xcd\x47\x8b\xb4\x44\xc5\x94\xeb\xe0\x89\x42\x25\x37\x5b\xa7\xa2\x55\x7c\x95\x75\xb1\xf2\x69\xe8\x36\x1d\xcf\xd2\x89\xee\xa8\x2b\x18\xd6\x63\xe7\x9e\x35\x1e\x3c\x6a\xfc\xbb\x0a\xb2\x88\x99\x0e\xad\xa1\xcd\x8d\x59\x8e\x38\x3f\x26\xf5\xfb\x34\xff\x36\x47\x9b\x75\x4e\xfe\x5e\x98\x05\x5d\x43\x8b\x5c\x08\xf7\x1f\xa4\x0e\xb1\xde\xaa\x7e\x3c\xab\x44\x72\xc2\x4f\xed\xfc\xb9\x83\x3a\xa9\xa9\x71\x8a\xb7\x33\x97\xdf\xfd\x06\x4b\x9f\xb2\x65\xd8\x4b\x30\x45\x0e\x0a\xb3\x18\x78\x44\xc3\x70\xde\x96\xe7\x9f\x3e\x9b\x53\x72\x31\xe1\xc3\x09\x09\x78\x10\x35\x32\x95\xb5\x58\xaf\x01\x1a\xcd\xf5\x82\xc3\x85\x73\xab\x38\xaf\x45\xde\xf3\xa6\xd2\xeb\xae\x03\x5b\x3b\x7e\x05\x50\x08\xc0\x33\xf4\x2e\xb2\x57\x85\xeb\xf6\xde\x97\x15\x96\xe1\x06\x62\x2c\xf8\x9d\xab\x6a\xe3\x51\x05\x7c\x5d\x53\x39\xcc\x5f\x66\x54\x87\x6f\x81\x15\xbe\x05\x56\xf8\xf2\x02\x2b\xdc\x44\x10\x02\x7b\x4f\xac\x5a\xf3\x65\x71\x15\x96\x0b\xa9\x70\x23\xb1\x02\x36\xf5\x95\xfc\x3a\x1c\x11\x97\x49\x1b\xad\xac\xe4\xd2\x36\xc9\xe6\x31\x1f\xca\x23\x9a\xf0\x28\xe0\x43\xf0\x84\xd7\x07\xb5\x9b\xd9\x19\x7d\xcd\xc4\x88\xd0\xc8\x4b\xfb\x0f\x5d\x33\xd6\x77\x4b\xfb\x74\xbe\xe0\x74\xca\x1c\xa7\x52\x37\x71\x34\xa4\x4a\x75\x2c\xf0\x6a\x13\x99\x3a\x69\x46\xfd\x16\x7e\x12\x09\xff\x4d\xbe\x45\x42\xe3\x68\x9c\x33\xf0\x45\x25\x7f\xbe\xcd\xff\x59\xb7\xc1\x7f\xcb\x93\x62\xb8\x6a\x73\xbf\x2e\xdf\xdc\xad\x2b\xb0\xf8\x55\xe1\x2e\x56\x72\x35\xdd\xd8\xcb\x74\x49\x07\xd3\x2d\xfb\x96\xfe\x85\xdc\x4a\x57\xf7\x28\xbd\x66\x67\xd2\x9c\x03\xbd\x89\x9b\x69\xbf\x99\x20\x1e\x25\xa9\x57\xc7\x2c\xc3\xfe\x1c\x15\xa2\xa7\x34\x41\x94\xea\x1b\x7d\xf9\x86\xd6\x18\x52\xbb\xd4\xce\xda\xb1\xec\x76\xa0\xaa\x0c\xbb\x1d\x90\x5f\x0b\x06\x57\x05\x4f\xb2\xb2\x16\xb5\x4b\x59\xd9\x37\x70\x25\xdb\x71\x9d\x61\xba\xe8\x8f\x51\xb0\x27\x46\x2f\xb4\x6a\xd0\xff\xd1\x8f\xae\x9c\xb9\x2f\x86\x87\x7e\xa9\x2c\xde\x6a\x1c\x6a\x8b\xb6\x9c\x39\xf2\xc1\x03\x41\x35\x92\x37\x2a\x56\xad\x5c\x56\xfa\x6c\x2c\x68\xc4\xf0\x41\x55\x23\x5b\x36\x0d\x2d\xb5\x0a\xdd\x28\xcf\x8b\x17\x77\x7f\x7f\xa5\xac\x2f\xd7\x9c\xa1\xc5\x71\xef\x45\xa8\x5a\x6f\x87\xfe\x12\x8b\xc2\x83\xa9\xf6\x76\xe8\xd7\xad\xc2\xf5\xcd\x22\x2b\xf2\x5e\xe8\x30\x29\x10\x23\x13\x3a\x6f\xff\xfc\xd5\xfe\x29\xfb\xd1\x38\xf5\x6c\xd8\xfb\x7a\xdf\xb2\x9b\x58\x71\x4c\x6a\x19\xc8\x61\xb9\x16\x85\xaa\xb8\x08\xaf\x38\x3a\x0f\xaf\x8a\x37\x49\x4c\xa1\x82\x0e\x5d\x57\x6e\x0a\x3f\x9c\x52\xdb\xef\xfe\x6a\x69\x2a\x72\x28\x4d\x58\xa4\xb6\xe6\xc1\x55\xb2\x51\x60\x3f\x0e\x56\xcb\xd9\xa1\x96\xb1\xdb\xad\xfd\x55\xa7\x66\xdf\x0e\xc4\xa7\xb1\xcf\x09\xab\x4c\x4d\x01\xe5\x2b\x9a\x66\x15\xb3\x02\x9e\x77\x9b\xda\xf5\xae\x60\xd2\x4b\x44\xf4\xd2\x49\x97\xe5\x9c\x17\x6d\xf9\x09\x2d\x76\x73\x7b\x7c\x89\xad\xed\x92\x7d\x24\x25\xc6\xc2\x9f\x4b\x33\x0f\xf8\x29\xbd\xea\xd1\x2b\x9c\x3e\xa6\x1c\x03\xb5\xf1\x99\xa5\x06\x93\xbb\x5c\x38\x49\xef\x5a\xe4\xca\x1a\x15\x2f\xcc\x46\xb0\xa4\xad\x70\xb5\x99\xb0\x79\xf7\xd4\xd8\x09\xeb\x46\xf2\x82\xc3\xfd\x2f\x4b\x70\x68\x7d\x24\x8a\x09\x4c\xdd\xd8\xca\xe7\x2c\xca\x90\x22\xe8\x05\x64\x7d\x8f\xb4\x59\x86\x51\xcf\x22\xcb\xc9\x0a\x7e\x58\x5e\x50\x1e\xbb\x0e\x4b\x03\x34\x5f\xcb\xb5\xe2\x7b\x5c\x58\x1f\x21\x43\x07\xf8\xe9\x66\xb8\xcb\x1b\x86\x78\x95\x4d\xa4\x67\x64\x2d\x47\x9b\xe1\x7f\x38\xc1\x71\x9d\x36\x2b\x3a\x61\xc0\xf1\x22\x70\xe7\x8e\xb6\xc1\xf4\x3f\x9c\x34\x44\xd4\x20\x77\xed\x84\x9d\xa2\x5f\x93\x31\xd0\x2c\xe9\x40\x45\xc5\xb2\x9e\xa8\xa1\x9a\xa0\xc3\x20\x9a\x2e\x32\x5f\x09\x31\x8b\x9c\xf8\xe7\xc8\x3c\x61\xc2\x34\xde\x6c\xc4\xe1\xbf\xb8\x34\x1c\x1f\xf7\x5f\xb7\x5c\xf3\x26\x82\xab\x4e\x58\x18\xb3\xa4\x72\x10\xf7\xbf\x34\xf9\xe7\xdb\xea\xbc\x29\x7b\xad\xce\x2a\x48\x7e\xff\xbd\x4a\xc0\x45\xa3\xf9\x96\x62\xae\xce\x52\x96\x1c\xb1\x90\x0d\x33\x1d\xbb\x54\x3d\x46\x51\x3f\x28\x42\x91\x3c\x1f\x0e\xc1\xfd\xc9\x1c\x42\xb2\xb0\xa7\x42\xf7\xc5\x34\x64\x59\xc6\x3a\x29\x1b\x8a\x28\xa0\xc9\xbc\xf3\x7c\x7f\x77\xb7\x04\x07\x86\xe6\xab\xc5\xa1\xc2\xdf\x61\x76\x84\x02\x8a\x03\x11\x65\x89\x17\xfa\xaf\x14\xc9\x98\x65\x1a\xf2\x98\x5d\x66\x4d\xff\x6b\x9c\xf0\x29\x4d\xe6\x27\x0f\x76\x77\x4f\x5b\x85\x26\x5e\xa8\xec\x51\xcb\xf5\x53\xe7\x9a\x2a\xa0\x79\x99\x24\x22\x59\x80\x83\x49\x18\xe8\x46\xa1\xfa\x7b\xec\xe3\x02\x04\xee\x48\xec\xa5\x6d\xe5\x48\x87\x10\x0e\xb2\x82\x7d\x77\x5b\x1d\x11\xb1\x77\xa3\xe6\x89\x8d\x9e\x4b\x1a\x14\xd8\x01\xff\x82\xe3\x19\x92\x31\xe2\x8c\xe7\x73\x31\xc2\x28\xe1\xd5\x8a\xbd\x45\x6f\xbe\x4d\x95\x0b\xc7\x13\x06\x2e\x62\x5a\x6a\xcc\x87\x90\x80\x26\xca\x48\xc8\xc7\x34\x9b\x25\x8e\x74\x5c\x1b\xf5\xf4\xf4\xdd\x63\xa5\x55\x9d\xf7\x13\x59\xa5\x72\xb5\xee\x61\x42\x63\xd6\x5c\x01\x55\xeb\x6b\x0c\xf2\xe8\x63\x39\x06\xf3\x1c\xc9\x6a\xf9\xd0\x98\x1d\x4c\xac\x31\x4b\xb5\x36\x05\xd8\x9c\x28\x36\x27\x17\x13\x16\xa1\xb5\xcf\x14\x8c\xf0\x52\x16\xa5\x2e\x79\x71\x69\xdc\x18\xf7\xa2\x1d\xb1\xd9\x6a\x0f\x87\x78\x47\xd3\x42\x5a\x63\x35\x83\xf9\x89\xcb\xd3\x13\x5b\xc1\x57\xa9\xdc\x2b\x2f\xf3\xaa\x10\x79\x0d\xd5\xc2\xd5\xb9\x88\x43\x61\x5c\x7b\x57\x94\x39\x59\x91\xd3\x52\x69\x57\x43\x91\x18\xa7\xdc\xe5\xa5\x3a\x8d\xa9\x4e\xf1\x23\x57\xab\xc4\x9b\x4b\x40\x5a\x2b\x63\xf8\x7c\x65\xe0\x4f\x54\x17\xc8\x5d\xac\xa3\xae\x0b\x9d\x21\x8d\x79\x46\x43\xfe\x1b\x7b\xc5\x93\x34\x7b\x2d\xb9\x27\x69\x35\x01\xb8\x75\xda\x56\xf3\x05\x69\xa7\x34\x3b\x94\x0b\x66\x96\x17\x46\xb8\x4f\xfc\x4a\xb1\x43\xd9\x9b\x5f\x72\x5f\xc2\xe9\x8e\x8a\x58\xde\x23\x0d\x79\x47\x6f\xe4\xe5\x0d\x43\x63\x40\x49\x30\xbb\x8e\x64\x37\x78\xfa\xc0\x26\x81\xc4\x5f\x2e\x39\x93\x52\x95\x7c\x5e\x7a\x13\xf0\x74\x77\x37\xbf\xce\xf2\xcd\xff\x19\x76\xf1\x5b\x8b\xa5\x73\xa0\x83\x72\xd6\x5e\x2d\x89\x16\x4b\xe6\x1c\x74\x6a\xfd\xd6\x6e\xd9\x4b\x23\x84\x05\x58\xdd\xbb\x6b\xe7\x86\x16\xa8\x38\x46\x2d\x15\x1d\x14\x96\x41\x99\x2b\x3a\x32\xa9\x69\x18\x36\x6b\x00\x9e\xce\xb8\xda\xa1\x1a\xf2\x77\xe3\x69\x99\x04\x60\xb5\x84\x95\x80\x87\x5c\xb5\x9a\xf2\x8f\x56\xed\x73\x7e\xdd\x44\x46\x0f\xae\x33\x91\xd1\x97\x28\x6e\xf8\x8b\x4b\x04\xb6\x2a\x6d\x01\x71\x43\xb7\x4b\xfe\xa9\x56\x03\x0b\x8c\xa4\xd6\xc9\x2d\xfb\x4d\x20\xb1\x58\x20\x01\xdb\xca\x1b\x1a\xf1\x78\x16\x2a\x57\xe2\x72\x6b\x37\xcb\x2d\x76\x82\xab\x68\x5b\x06\x5b\xd7\x2f\x3f\x21\xee\x5f\x57\xfe\xb1\x24\x3e\x75\x4f\x3b\xc6\xc4\xe6\x9b\xf5\xcd\xc5\x75\x93\x22\x9a\xaa\x2b\xe5\x55\x5b\xa7\x4d\x98\xc7\x62\x9c\xd0\x78\x32\xef\x60\x26\x66\x1b\x80\x2e\xe4\x11\xfb\xc9\x64\x4d\xe9\xdc\x67\xd3\x46\x1b\x92\x18\x4e\xe3\x44\x9c\x43\x9c\xd3\x80\x0e\x78\xc8\xb3\x39\x18\x07\x4d\x67\x61\xc6\xc1\xc9\x15\x31\xe9\xf0\x64\x03\x71\x79\xc4\x7f\x03\x93\x85\x06\x26\x9a\xd8\x19\x88\x4b\xa3\xd6\x9a\xf2\xe8\x17\xb4\x08\x79\xfc\xd8\x29\xd3\x2d\xdf\x7b\x68\x12\x58\xa0\xf3\x97\x16\x62\xa4\x31\x1d\xf2\x68\xdc\x99\x45\x1c\x52\xaf\xc4\x97\x4e\x36\x08\xef\x23\x46\xfb\x6c\xc4\x97\x15\xf9\x2e\xf6\xdb\x75\x42\x92\x8c\x5d\x66\x5a\x52\xe2\xe5\xb0\x50\xd9\x34\x8a\xe9\x27\x94\x5b\xc8\x49\xc3\xe6\xce\xd8\xd1\xf7\x9d\xc6\x40\x5c\xee\xa4\x13\x1a\x88\x8b\xc6\xa9\x1b\xec\x2f\x30\xa9\x27\x8a\x08\xf5\xb7\x4e\x3a\x11\x49\x66\x6c\x3e\xfe\x3f\x7b\xef\xde\xdd\xc6\x8d\x24\x8a\xff\xef\x4f\x81\xcc\x66\x4d\x32\x26\x29\x52\x96\xfc\x90\xc7\x93\x75\xe4\x64\xe2\xbd\xf1\x38\xc7\x72\x26\x77\x7f\xbe\x3e\x16\xd8\x0d\x92\x88\x9a\x8d\xde\xee\xa6\x44\x25\xf6\x77\xff\x1d\x14\xde\xe8\x07\x9b\x14\x29\x4b\x32\x67\xf7\xc4\x22\x1a\x28\xbc\x0a\x85\x42\x3d\x75\xda\x91\xfb\x47\x53\x76\xee\xe4\x83\x41\x88\x0f\xfb\x25\x09\x98\x4e\x68\xe1\x24\x15\x02\x6f\x81\xb7\x04\x5c\xcd\x62\x19\x49\xcb\x8d\x54\x6a\x67\xfe\x38\x16\xeb\x22\x93\x93\xba\x94\xac\x3f\xc6\x21\xe9\xb4\x6b\xd6\x0c\x0d\xfa\xc3\x7d\x4b\xfd\xd9\xfa\xaf\x19\x09\x29\x46\x6d\x18\xf4\x11\xe2\x03\xeb\xb4\xdc\xe8\x84\x85\xbe\x5b\xb0\x1e\x09\x4e\x39\x0f\xa8\x2b\x5a\x7a\xcf\xd6\xfd\x6f\x35\x07\xb8\x1e\xac\x7b\xf6\xbf\x6a\x75\x43\x12\x67\x56\x42\x93\x3a\x1c\xec\xa1\x61\x3d\x1e\xba\x38\x68\xf0\xfe\xd1\x41\x19\xde\x6b\xac\x1c\xb3\x38\x17\xa6\x99\x85\x23\x9b\x2c\xde\xb1\xb7\x64\xd6\x2e\x7c\x50\x6d\xf8\xa0\x1c\x19\x65\xc4\xe9\x55\x21\xcd\x8c\x9b\x14\xc9\xe4\x55\xf2\x13\x5e\xe1\x88\x4e\xe2\x57\x39\x99\x95\x65\xc3\xfa\x63\x9e\xe5\x74\x7c\x79\xcc\xe2\x5c\x84\xba\xd2\x3c\xb4\xd5\xff\x38\xc2\xf9\xea\xc2\xc9\x5a\x4c\xbf\x02\x9e\x3a\x7d\xf8\x78\xba\xfc\x84\x6c\x12\x93\x5d\xec\x33\x8b\xb5\x86\xe4\x7c\x5b\xab\xe5\xf5\x72\x33\xd7\x6b\xf3\x22\xfe\x6d\x2d\xe7\x2a\x43\xb8\x79\x6b\x0d\x53\x7c\x25\x4e\x78\x61\xad\x4b\x8f\x7e\x8a\x69\xb6\x54\x2f\x52\xbf\x28\x93\x94\x5c\xbe\x7f\x68\x6f\x4a\x61\x0a\x15\x0d\xba\x16\x33\x02\xb7\xaf\x26\xe1\xf0\x2b\x7b\xbf\x6f\x11\x99\x6f\x9d\xf4\xd4\xde\x85\x52\x09\xe1\xd1\x07\xb5\x4e\x16\xc6\x08\x45\x54\x33\x00\x4f\x4a\x00\x94\x5f\x6a\x95\x20\xcc\x44\x97\x2e\x0d\xdc\xd1\x21\x3d\xa7\x21\x49\x4b\x06\xde\x00\xd5\x8b\x4b\xdd\x7f\x31\x1c\x0c\xb6\x8e\xa5\x15\x5b\x7c\x45\xae\xa0\x7a\x75\x6c\xe3\xaa\xe5\x53\x6a\x36\xa9\x35\xa6\x65\x0e\x62\xc5\x91\xf4\xb0\xf6\x08\xfd\xe5\x9c\xbc\x66\xd7\xee\x1a\x84\x71\xc9\x4c\xd6\xbf\xc8\xcb\xe1\x3c\x1e\xd8\x58\x7e\x2d\x38\x56\x50\x94\x56\xee\x81\x58\xea\x46\x97\x76\xfd\x4a\xbb\x97\x6d\xd3\xb5\xbe\x0a\x23\x50\x09\xe9\xe0\xda\xcf\x74\x89\x25\xc0\x92\x15\xdf\xae\x66\x3f\xbc\xb2\x52\x7f\x8c\x47\xa6\x71\x4d\xba\x45\xfd\xc0\x18\x14\xdf\x09\xba\x48\x25\x87\xd4\x4f\x63\x9d\x1c\xf2\xd1\xd2\x7b\xee\xd1\x87\x35\x6f\xa7\xe1\xfe\x07\x77\xf9\xb7\x69\x2b\x20\x25\x15\xfc\xc1\x6c\xa9\x00\x94\x34\xdf\xd1\x06\x68\x1d\xc0\xc6\xec\x02\x02\xf1\x82\x51\x6a\x66\x4b\x9a\xf1\x65\xcd\x01\x2c\x85\xd6\xfa\x0d\x8f\xbe\x94\xea\xaa\xd2\x93\x6f\x67\x8b\xb0\xaa\x2d\xc2\x7a\xa7\xa3\x6c\x06\x4a\x9a\xcf\xf9\x05\x11\xac\x7c\x4a\x40\x74\x88\x62\x8e\x37\xa2\xea\x8f\x14\x8c\x01\x30\x12\x2b\xc1\x77\x43\xc4\x53\x7f\xf9\xe6\xb5\xce\x30\xc6\x78\x05\xdb\x17\x52\x75\xa2\x94\x63\xa0\xda\x41\x34\x43\x18\x9d\x8a\x23\x75\x6a\xcf\x5b\x47\xc8\x5e\xed\x50\x39\x42\xda\x35\xcf\x96\x0d\x63\x33\x08\x6f\x41\x2c\x1a\xde\xf0\x15\xc8\x66\x38\x8a\x48\xaa\x89\x7b\x17\xd1\x90\xe0\x48\x6e\x01\x84\x6a\x83\x90\xf3\x01\x4e\x43\x69\xfa\x6d\xe1\xbd\x14\x4a\x35\x76\xff\xf5\xbc\x92\xc5\xea\xa3\x0b\x1a\x45\x68\x44\xf4\xe5\x66\xc1\xd7\xd7\xdd\xba\x5d\xf8\xfe\xcc\xd2\x29\xb7\xbc\x4b\x74\x2a\x7f\x0b\xcb\xe9\x53\x34\x9b\x67\x39\xc2\x51\xc6\x78\x5d\x0e\xb5\x30\x34\x60\x71\x45\xf5\xf5\x07\xe9\xa4\xc7\x58\xbe\x1c\x57\xe9\x0e\x80\xf3\x43\x33\x8e\x98\x70\xfa\x96\x59\x3d\xe4\x5e\x70\x72\x47\xe3\x89\xe9\x13\xf8\x85\xc6\x3d\xf1\x73\xf6\xdb\xdb\x5f\xf8\xc9\x8c\x68\x7c\xc6\xff\x95\x84\x46\xef\x36\xcd\x10\xe4\x32\xd0\x8b\xfe\x6a\x8c\x74\x34\x5e\x1c\xa3\x53\x7c\xaa\xcf\xb2\x5a\x0a\xa0\x0a\x38\x2b\x23\x0a\x7c\x8c\xd3\x94\x8c\xaf\xe2\x1d\x6f\xe3\x21\x5f\x1b\xc1\xc9\x15\xd7\x42\x09\x0e\x1a\x2f\x87\x4f\xe3\xf9\x99\x6c\x92\x4f\xd8\xe8\xc4\x84\xaa\xcc\x37\xcb\xb2\x5c\x8f\x74\xb8\xa7\x2f\x6f\xaa\x05\xd4\x40\x7f\x82\x5f\x96\x24\x17\x70\xd9\x7c\x95\x05\x5e\x05\xeb\x38\xf9\x55\xad\x4f\x5a\x20\x8d\x47\xba\xd6\x18\x8f\xb4\x9b\xb2\xd8\x3e\xed\x08\x0c\x3f\xaf\xcf\x9e\xac\x8b\x5a\x30\x77\xdf\x16\xa4\x38\x0f\x5e\x3a\xc6\x23\x70\x74\x84\x41\x3a\xb6\x68\xe3\x08\xe7\xe8\x39\xfa\x46\x4e\xe7\xfe\x7d\xf4\xcd\x18\x8f\x9e\xad\x64\xa9\xb6\x19\x77\x43\x61\xd5\x06\xa1\x9c\xd7\x6b\x2f\x76\x40\x6d\xcc\xa7\x4f\x7c\xe7\xd6\x03\xc5\xb7\x79\xfd\xd6\xb6\xac\x50\x59\xd1\x3d\xf7\xac\xe8\xd6\x19\x94\xd1\x25\x74\xc5\xb6\xdd\xbf\x6f\x43\x57\x0c\xd1\xfa\xd0\xc5\x3b\xbe\x14\xb8\x64\xb1\xd6\x87\xad\xde\xa1\xa5\xd0\x35\xdb\x76\x95\x9d\xd7\x6b\xf3\xcd\xc6\x17\xc7\x16\x73\x94\xc3\xbf\xd2\xfa\xb8\x6f\xfa\xf2\x0e\xae\xb8\x44\x82\x4e\x0a\xe2\xb9\x26\x04\x45\x4b\x35\x99\x6d\xe2\xb3\xdb\xdc\x34\xd4\xb6\xea\x70\x7d\x54\x97\xa4\x9c\x29\x35\x17\xf5\x6e\x84\x23\xe4\x5f\x05\x63\x9b\xa5\xfa\xa6\x9a\xfa\x7b\x52\xc6\x63\xaf\x33\x92\xf5\xbd\x1a\x52\x0c\xe2\x98\xa5\x36\x72\x81\x75\xdd\x5f\x8b\x66\xb0\x24\xeb\x83\x3a\xd3\x08\x7c\x2d\x6b\x57\xe1\x90\x2a\x6c\x5e\xc5\x42\xde\x64\xab\xd7\xf5\x5e\x74\x5e\x57\xcb\x9f\x05\x7e\x83\x26\x7c\xbe\xd7\x66\x19\x63\x5a\xde\x45\x53\x7e\xdd\x6b\xdd\x80\xf3\x2b\xef\x6f\xf5\xae\x1a\xf0\x88\x37\xc5\xa0\xf8\xce\xc8\x81\xbe\x36\x6b\xe6\xf5\x4e\x79\xf3\x41\x48\x19\x4a\xab\x7b\xe7\x84\x28\x4d\xd7\x40\xbd\x00\x6a\xce\x7d\x63\x50\xe6\x0d\xb1\x39\x68\xee\x2b\x64\x73\x70\x37\x09\x52\x3c\x8d\x36\x00\x68\x9a\x92\xf1\xa6\x4e\x98\x7c\xa8\x6d\x64\x5c\x1c\xbb\x1a\x8c\xcb\x76\x17\x90\x1c\x44\x8d\xc3\x80\x3e\xdb\xe6\x22\xd6\x41\xbc\xcc\x3d\xab\x8b\xe0\x1a\xf5\x2b\x38\xb7\xa4\xfe\xa8\x2e\x41\xbf\x76\xa1\xa2\xb8\xc2\x5a\x42\xac\x22\x3c\x17\xae\xea\xa1\x20\xe6\x0d\x3e\x0a\xe2\xcf\x2d\x79\x29\x5c\x2d\xeb\xde\x96\xe2\xfa\x1e\xe3\x34\xac\x32\xea\x3f\x04\xa3\xf0\x25\x1d\x59\x04\x9f\xf7\x42\xe2\xf9\x4c\xa4\xb6\x32\x89\x1d\x27\x24\x3f\x72\x82\xa3\xb7\xbd\x70\xe8\x55\xc6\xdc\x7c\x70\x1d\xb5\x79\x56\x56\x23\x3d\x72\x69\x87\x57\x65\x37\x2f\x92\x09\x2d\x9b\x80\x05\x68\x5b\x93\x90\xe0\x6b\xe7\x22\x5c\xbf\xab\xec\xf3\x0f\x0f\x1f\x37\x9d\x8b\x04\xb4\xad\xb9\x48\xf0\xb5\x73\x79\x0d\xca\xf1\xaa\x99\x34\xde\x15\x00\xb3\xad\x79\x00\xf0\xda\x59\xfc\x4c\x70\x58\x99\xe7\xf0\x10\xf2\x30\x36\x9a\x86\x80\xb3\xad\x79\x08\xe8\x65\x13\xd9\xba\xf7\x83\x47\xe0\xae\x96\xbc\xf3\x4b\xbb\x61\x7d\x29\x57\xab\xad\x7a\x37\xdd\x28\x3f\xae\xad\x78\x4f\xfd\x8a\x93\xea\x33\x7a\xe0\x56\xab\x83\x0a\x15\xae\xe7\xd4\x94\x3b\x9b\xc1\x00\xae\x6e\xdc\xb1\x95\x18\xcf\xa0\xa2\xdd\x84\x0e\xcb\x53\x41\x71\xfa\xe5\x2b\xa0\xb6\xa2\x62\xf1\x74\x20\x8d\x04\x94\x12\x67\xb4\x58\xb2\xda\x77\x9d\x44\xe4\x5c\xba\xa0\xc8\xd1\x7f\x8f\x9e\xa0\x23\xb4\x6f\x44\x82\x42\x48\xc7\xe7\xbb\x9e\x88\xae\xde\xed\x7f\x2d\x31\x52\x53\xcc\xb8\xf7\xb9\xe9\xdb\x44\x3e\x24\x60\x96\x25\xcf\x08\x87\xc9\xaf\x60\xdd\x79\xdb\xed\xb0\xdf\x9b\x4c\xd1\xbc\x73\x12\xfe\xda\x6e\xae\x5d\x4c\xb2\x26\x2e\xc0\x30\xab\x9f\x6b\x03\x93\x3d\x7e\xf2\x75\x3b\xe6\x56\x7b\xbd\x02\x89\xb4\x82\x8e\x69\x83\xd7\x7d\x6d\xa0\x2b\x5d\xd6\xc6\x11\x51\x3e\x76\x8e\xb7\x9a\xc8\x07\x20\xbf\x68\x2b\xdb\xd6\x7e\xb2\x40\x07\xc9\xa2\x75\x4f\x5a\xea\x0a\xb3\x9c\x13\xe1\xb6\xa7\x7a\x9b\xe1\x74\x42\xe3\x23\xd4\x1a\xe8\xba\xab\xda\xbd\x36\x35\x36\xf5\x2c\xe8\x76\xe1\xa7\x6e\x8c\xc9\x67\x19\xdb\x27\x2d\xf3\x50\xc8\x50\xcc\x72\x91\xe4\x90\xa3\x16\x2f\xc5\x91\xc4\x9b\x82\x21\xd9\x0b\x17\xc7\x56\x63\x09\xa5\x88\xc1\xe7\x0c\xcb\x40\xfb\xa6\x3c\xce\x47\x5f\x65\x7a\x65\xfb\xa5\x6a\xdb\xa5\x75\x19\xd3\xb2\x61\x83\x6e\x64\x99\x4d\xd0\x4a\xac\x2c\x0c\xb2\x15\xd2\xf3\x15\xa2\x30\x35\x08\xaf\x0d\xb6\x3b\xba\x49\xc7\x57\x80\x97\xee\xd7\xf7\x66\x37\x8e\xac\xd4\xb2\x3f\xab\xf0\x54\x11\x8b\x89\xca\x88\xc9\x57\x50\xeb\xde\x3b\x56\x02\x58\x35\x02\x87\x92\x19\x5d\xb8\x85\x43\x5f\x46\x21\xbe\xf2\x21\xb8\x29\x6a\xd7\x5d\x1c\xa7\x6a\xfd\x93\x7f\x46\xeb\xb5\x34\xb6\x66\xc5\xc6\xc7\x92\x77\x51\x39\xb6\xd4\xbd\x92\x56\x53\x70\xd8\x42\x61\xf4\xb9\xd3\xb6\xa5\xb8\xdb\x79\x6b\x3d\xd9\xbd\xb5\x76\x6f\xad\xaf\xf9\xad\x85\xd3\x58\x66\xfb\x28\x1b\xfa\x81\x5f\xb1\xf6\x99\x25\xaa\x5c\xd7\x3b\xee\x26\xbd\xcc\x6e\x66\x74\x22\xff\x9d\x66\xfc\x3c\x45\x04\x93\x56\x00\x7e\xa8\x5d\xef\xe3\x5b\x92\x10\x2c\xa2\x47\xf7\x52\xf8\xbb\x50\xe5\x57\xa6\x02\xee\xa8\xa7\x9c\x7a\xb2\xf1\xfe\x40\x61\xa5\x3a\x75\x82\x9a\x38\x8f\x35\x70\x4c\xd5\x62\x65\x48\x7e\xdc\x3a\xa7\x21\x61\x60\x7c\x33\x0f\x29\xfc\x91\xd0\x20\x9f\xa7\x60\x26\x4e\xc7\xa9\x34\x32\xa7\xb3\x49\xeb\xc3\x06\xde\x7c\xb7\xf2\xe9\x33\xc3\x13\xc2\x87\x25\xdc\x63\xf8\x4b\x5b\x38\x86\x60\x6b\x83\x10\xe5\xb5\x5c\x97\xb1\x53\x28\x3b\x45\x2c\x45\xa7\x59\x1a\x9c\xc2\x0b\x41\xb8\xf7\x8c\x08\xca\x12\x12\xd0\x31\xd5\x1e\x29\xff\x62\xb9\xcc\xca\x1d\x48\xef\x28\x5e\x51\xd4\xba\x94\x4f\x7e\xc1\x44\x5f\xd0\x8c\x88\xb0\xcd\x30\x32\x90\xbe\xf3\x07\xd8\x88\xa0\x73\x91\x72\xc6\x2c\x1b\x54\x59\x69\xba\x2f\x62\x84\x23\x8a\x33\xf0\xc6\x52\x53\x48\xe4\xb5\x23\xc7\xfa\xe2\x1c\xd3\x48\xe4\x4e\x8f\xa3\x4b\x91\x97\x5f\xb8\x3d\xfb\x5b\x87\x5e\x7b\xc5\x47\xe8\x14\x70\xee\xb4\x8b\x4e\x01\xe7\xf8\x1f\x12\xe7\xf8\x9f\x02\xe7\xe0\xaf\xd9\xc4\xf2\x91\xcb\xd2\x60\xa5\x69\xf8\x7b\x2f\x73\xba\xac\x80\x3d\x46\x01\xc3\x57\x42\xa4\xf1\xe2\xa4\xdb\xda\xe9\x3b\xee\xbc\x57\xf2\x00\x87\xed\x6c\xe4\x19\x74\xe5\x87\xb3\xc0\x6e\xf5\x19\x7e\xa9\x4f\x82\x62\xa8\x4f\xf0\x4b\x7f\x4a\x03\xf3\x21\x0d\x54\xb1\xde\x4c\xd7\xd1\x48\x95\x5e\xd9\x51\xa7\xc2\x39\x07\x46\xcd\xff\x80\x31\xc2\x1f\x69\xd0\x72\xcc\x15\xd5\x73\x7d\x25\x85\x8f\xe2\x0e\xcc\x50\x7e\x60\x2c\x22\x38\x6e\x8b\x55\xfb\xf4\x89\x2f\x44\xa7\x8b\x5a\xaf\x55\xd4\xe8\xdf\x5e\x1d\x21\x52\x43\x98\xf8\xf1\x2e\x21\x4e\x2d\xfe\x54\x51\x59\xed\x55\xa2\xfb\xec\xb5\x73\x95\xa0\xe7\xfe\xdd\xd2\xa7\x71\x48\x16\x6f\xc6\x6d\x67\xdd\x3b\x30\x9f\xde\x50\xbb\x13\xf1\x8f\x19\x09\x4f\xe4\x76\x7e\x53\x00\x7c\xff\xbe\x44\x83\xef\xab\x25\x13\x86\x08\xbf\x12\xc4\xae\x35\x4f\xa3\x76\x0b\x3d\x90\x4d\x1f\xa0\x56\x07\x22\x43\xc3\x1e\xf0\xe9\xc0\x1f\xfe\x20\x9a\x25\x10\xdb\xa4\x6f\x53\x61\xba\x6b\xba\x8b\x28\x0e\xa0\x5b\xd8\x98\x6a\x97\x8c\x15\xdc\x31\x9c\x2d\xac\xd6\x75\xde\xf3\x9d\x2f\xfc\x75\x15\x67\x4c\xd2\x61\x67\xeb\xe5\x17\x4e\xe1\x0b\x18\xf0\x3d\xb2\x31\x1a\x1d\x99\x27\xd7\x3d\x54\xa6\x44\x85\xe6\x5f\xca\xd9\xe1\x66\xdc\x04\x6b\x59\xc8\x57\xb4\x6f\x6c\x28\xbf\xdd\x9b\xe8\x2e\x9a\xcd\xab\xbb\x61\x23\xc0\xc4\xb5\xb2\x19\x50\xf2\xaa\xda\xcc\xaa\xdd\x6d\xb3\x7c\x5f\x96\x27\xa8\x4f\xa9\xa1\xb4\xa6\x0d\x20\x6d\xdf\x98\xf8\x4e\x58\x42\x2a\xe1\x9d\x30\x5d\xdc\x8e\xe8\xee\xe9\x4e\x74\xb7\x13\xdd\x5d\x45\x74\x57\x61\xde\x66\x99\x41\xdf\x7a\xe9\xde\x35\x58\x52\xbc\xd3\x71\x6e\xab\xd0\x66\x50\x52\xb7\xae\x13\x53\x6b\x75\x13\x7a\xbf\x76\x5d\x3f\xb6\xbd\xfb\x0d\x93\x27\xde\x14\x4b\x8f\xf5\x52\xd0\x95\xda\x7f\x94\x5b\x80\xd8\x51\xd9\xf0\x39\xce\xb1\x95\x66\x8d\x37\x06\x33\x8f\x01\xc2\xf3\x9c\x99\x58\xcd\xa0\xc8\x7f\x2b\x6c\x4e\xca\x23\x8c\xdb\x60\x03\x15\x02\xd9\x83\x3b\x44\x43\x01\xd7\xae\x9c\xd3\x9c\x3f\x07\x54\xac\xc6\x6c\x3e\x9a\x82\xd5\x3a\x2f\x5a\x2b\xc4\x5a\xa5\xa9\xc9\x0b\x98\xad\x0e\xf3\x04\xee\x2d\xc2\x42\xde\xc8\x72\xd4\x8a\xdc\x62\xdd\xea\xed\x37\x35\x69\x66\x17\x64\x61\xca\x9d\xd9\xad\x92\x99\x03\x9a\xbe\xe3\x87\xc4\x4c\x5d\x9e\x99\x5b\x3c\xed\x12\xc1\xa2\x38\x8a\xbe\x64\x51\x1c\x48\x2d\xaf\x13\x3f\x37\x1b\x5b\x48\x23\x92\x11\x1b\xaa\x12\x9d\xf0\x80\x2f\xb8\xfe\x0c\xbf\xae\x2a\x30\x14\x33\xa9\x8b\xeb\xa3\x47\xc1\x7f\x40\x9f\x6b\x24\x8d\xab\x30\xc8\x31\x01\x39\xf6\xf6\xd0\x8b\xf0\x8f\x79\x96\xcf\x40\x25\x04\xfa\x87\x90\x24\x9c\x54\x30\x11\x41\x2b\x49\x49\x46\xe2\x00\x72\x45\xe2\x58\xee\x88\x1c\x04\x0c\x4b\x2a\xe1\xe4\x56\x7d\x8f\x5a\x23\x16\x5e\xee\xb7\xd0\x11\x6a\xf1\x09\x44\x34\x26\x2d\x25\x6c\xd3\x93\xaa\x69\xc4\xff\x1a\xb6\x56\x0d\x17\x62\xf3\x20\xcd\xe2\x85\x54\x25\x93\x77\x2c\x95\xe4\x00\xef\xdf\x6f\x18\xb4\xc3\x58\x52\x55\xc4\xec\x90\x00\x75\xd0\x0e\xbd\x9e\x08\xad\x14\x1d\x64\x69\x47\x8a\x90\xe8\x9e\x1a\x26\xde\xb7\x99\x46\x77\x21\x45\x57\xc2\xcf\x56\xef\x7c\xd7\x79\xda\xca\xf4\xfa\x25\xc3\x11\x67\xc8\x0a\x4e\x0d\x05\xf2\x57\x67\xb3\x63\xd4\x7f\x29\xaf\x60\x07\xed\xec\x80\xd6\xc5\xb1\x3b\x1f\x85\x73\xb3\x8e\xc7\xeb\x7e\x2d\xce\x51\x77\xa3\xab\x59\xf3\xf5\x3f\x76\xbc\x30\x2d\x86\x08\x7e\x19\xe9\xe5\x1d\xe0\x7d\xee\x8c\x68\xd0\xa6\xfd\xb7\x78\x3f\x1a\x87\x24\x80\xdb\xed\xb6\x4f\xd5\x96\x05\x6e\x42\xb2\x27\x9d\x83\x95\x68\x4f\x7a\xf3\x6e\x45\xb6\xf7\x68\x70\xc7\x65\x7b\x5b\x95\xb4\x7d\xe5\x49\x18\xef\x84\x59\xde\x35\x08\xee\xa6\xb5\xde\x4f\xfb\x07\x5f\xb7\x4c\xec\x56\x1b\xfe\x5d\x55\x6c\x37\x8a\x58\x70\xe6\xc9\xdb\x8e\xd0\xc0\x16\x94\xc9\xca\x07\x25\x79\xd0\xd4\x27\xa7\xe2\xc3\xea\x8a\x0f\x9d\x8a\xfb\xd5\x15\x5d\xf7\xb2\x61\x75\xc5\x61\x57\xfa\xa5\x89\xe7\x5e\x49\x45\xf5\xc9\x91\xfa\x15\x6a\x59\x4f\x6b\xc9\x02\x59\xe9\xe6\xac\x7a\xe6\xa3\x34\x94\xe4\x8f\xc7\x92\x7a\x50\x6e\xaa\x94\xcd\x00\xca\xa5\xe0\x12\x27\x4e\x0e\x42\x53\x49\x7e\x91\x90\x20\x14\x50\x19\x28\x91\x42\xd2\x78\xdf\xfd\x42\xc6\xd6\x76\xe7\x64\x91\xbf\xe0\xc5\x47\xa8\x15\x91\xb1\x9b\x1e\x0a\xea\x1f\x83\x8c\xb6\xbc\x45\x99\xfc\x96\x7f\x92\x62\xd9\xb2\x26\x29\xff\x54\x6c\xf1\xdf\x22\x53\x5d\x79\x1b\x99\xc6\xce\x69\x15\xb3\xdf\x53\x9c\x98\xfa\xec\x9c\xa4\xe3\x88\x5d\xf0\x07\xbe\xc8\xbf\xde\xb5\x20\xbd\x31\x5f\x49\x14\xd1\x24\xa3\x99\xfe\x7e\x31\xa5\x39\x39\x49\x70\x40\xc0\xda\xf5\x22\xc5\x89\xd3\xd3\x64\x9e\xe7\x24\xfd\x81\xe5\x39\x9b\x99\xfe\xc4\x79\x50\xa5\xad\x41\xff\xe1\x21\x99\x39\xed\x12\x9c\x62\xd8\x84\xaa\x46\x4d\xa4\xd6\xab\x66\xf4\x82\x6f\xab\x67\xf3\x2b\x80\x38\x51\xcf\xcb\x25\x40\x20\x29\x93\x7e\x8b\x16\xc0\xac\x9a\x2a\xef\x60\x30\x28\xc0\xf8\x31\x4d\x59\xba\x04\x04\x64\x17\xb7\x9a\xaf\x25\xa5\xaf\xa1\xdf\x76\xc4\x40\x49\xd8\x64\x20\x6b\xa0\x5d\xd6\xdf\xfb\xd6\xdf\x43\xfe\xb7\x16\x37\x59\x6f\x8a\x96\xa1\x15\x22\x01\x69\x28\xda\x09\x29\x13\x7f\xbc\x89\xb3\x0d\x65\x22\xde\xd7\x55\x52\xa9\x60\x71\x8e\x96\x4c\xcc\x8a\x7f\x08\x94\xa0\x6b\x3c\x74\xd5\xb1\xed\x9a\xb3\x28\x72\x4d\xdd\x09\xcf\xaf\xbb\xa2\x9d\xd8\x72\xe6\x90\x1f\x2e\x75\xe2\x90\x0b\x82\x66\x38\x11\xb9\x54\xf8\xa1\xc9\x19\xc2\x68\xc2\x58\xa8\x6b\x28\xac\x2f\xf5\x9e\xbe\x21\x26\x69\x5b\xcf\x2c\xf2\x65\x53\xd2\x94\xc7\x33\xb5\xe4\x86\x76\x70\x53\x20\xa0\x2d\x2b\x3e\x9e\x9f\x9c\xc6\xf3\xb5\xe6\x74\x5f\x18\xf9\x0b\x0f\x6b\x34\x82\x4b\xad\xe0\x5f\xed\x5e\x9e\x35\x3e\x88\x6e\x6f\xbf\x13\x84\x53\x82\xc8\x2c\xa1\x29\x0d\x70\x14\x5d\x72\x84\x4b\xf4\x6a\xf1\xdd\xd3\xf6\xc1\x80\x7d\x29\x8e\x27\xa0\x0e\x08\xe9\x78\x4c\x52\x8e\xc5\x36\x46\xf3\x16\x12\x8f\x7f\x62\x29\xa2\x71\x96\xe3\x38\x20\x5d\x34\x1d\xf2\xf6\xd3\x47\x7d\x3e\xc3\x4b\x36\x47\x17\x34\x9b\xc2\x09\x9f\x02\x44\xb9\x0b\xd0\x77\x17\x2a\x04\x38\xe6\x7d\x9f\xd3\x90\xf0\xdf\x29\x62\x17\xb1\x72\x41\x88\x72\x92\xc6\x38\xa7\xe7\x24\xba\x34\xb5\xe7\xd2\x35\xe2\x54\xef\xbf\xef\xbc\x00\xb9\x3b\xe4\x91\x79\x2d\x3a\x5b\x82\x9c\x7f\x7d\x6e\xba\x41\x31\xcb\x11\x67\x6a\xba\x9c\x49\x84\x99\x13\x2c\xc3\x23\xe5\xe9\x3c\x0e\x30\x47\x38\x9a\x4f\x11\x8e\x91\x62\x8e\xcc\xa8\x14\x9f\xd5\x78\xeb\xd6\x44\x14\x8b\x5b\x6a\xdc\xd5\x0b\xa0\xc7\x99\x75\x80\x0c\xe3\x2b\x5f\x3d\x96\x82\xb2\x2e\x9a\xf4\x17\xbf\xdc\x3d\xe5\xa3\x51\x25\x34\x71\x6b\x80\xfb\xdd\xe8\x23\xf9\xaf\x4d\xa7\x3a\x69\xe4\xa8\x50\x93\x11\xc5\xa6\x03\xba\x86\x5d\x68\xf2\xe6\x39\xa7\x40\xd7\xf5\xca\x55\x75\x81\x9e\xba\x96\xf8\xa9\x3e\x6a\x9c\xd2\xdf\x75\x89\x7e\x1c\x08\x9e\x4f\x2a\x51\x2d\x45\xcc\xda\x3a\x54\xbe\xfa\xf5\xa9\x51\x8c\xf1\xa9\xc9\x93\x62\x2f\x85\x8d\x58\x72\xba\xbc\x48\xcc\x0d\xc8\xb9\x9a\x45\x4b\x85\xce\xdd\x88\x12\x96\x64\xef\x39\xb0\x0f\x5d\xb4\x11\x87\x82\xf7\x72\x76\xe8\x81\x68\x3c\x55\x31\x13\x70\x42\x73\x1c\xd1\x3f\xc9\x4f\x34\xcd\xf2\x5f\xf8\x8d\x97\x76\xda\x50\xb9\xf3\x41\x25\x23\xf9\x86\xdf\xef\xea\x32\x5a\xcf\x07\x41\x22\x83\xc4\x91\xf5\x60\x38\x28\xea\x60\xf1\x7a\xf0\x0c\x02\x1a\xec\x5c\x0b\x92\xc2\xb4\x86\xab\x0b\x95\xf9\xea\x0a\x5a\xf1\x8d\x97\xea\x65\x69\x8e\x0c\x8e\x58\xb6\x6b\x8d\x4b\x11\x3e\x7d\x42\x6d\x73\xd8\xbe\x47\xad\xa4\x85\x8e\xfc\xa3\x2c\x90\xab\xc3\x2b\x0b\xb5\xe6\x1a\xde\x1e\x35\x51\xed\xea\x15\xe7\x42\x9d\x69\xc8\xea\x97\x51\x67\xae\x7c\xc5\xaf\x92\x11\xe1\x8b\xdf\x61\xbe\xee\x76\xf7\xea\xfc\x2a\xf4\xc2\x77\xdc\x9b\x62\x93\xd9\x26\xae\xfa\x24\x6b\x3a\x1c\x8f\x9b\xd8\x44\xe2\x80\x02\x3f\xb2\x8c\x74\x35\x85\xac\xd9\x9a\x0d\x8c\xd2\x66\x8c\xb6\x9e\x95\xe0\x8b\xd3\x5b\x4f\xbd\x6f\x5d\x6e\x25\xbe\x3e\x92\x1a\x1b\x14\xac\x48\x94\xe0\x3e\xd8\x75\x22\x83\xc2\xcd\xf5\x97\xa7\x00\x6a\x4d\x87\x2d\x5f\xd7\x53\x28\xdb\x2f\x29\x1b\xda\x65\x46\x59\x63\xca\xa4\x5e\xa6\x35\xdd\x6f\x15\xb5\x30\xad\xe9\xc3\x96\xa3\x6e\x69\xe1\x8c\x86\xa4\xe5\xe8\x57\x5a\x89\x8e\x4c\xa1\x9e\xb3\x7a\x62\xd6\xbb\xb3\x90\xb5\x01\x16\x7f\x23\x4e\x51\x66\x6f\xc0\x74\xc2\x71\x6e\xd8\x86\xe9\xc4\xf0\x46\x26\x6f\x98\x92\xe0\x6c\xc4\x16\x55\x06\x01\x8f\xf6\xbf\x74\x02\x07\x39\xc0\x1b\x10\x9d\xfe\xd1\xfe\x1d\x37\x7e\xd9\x39\xb6\xdd\x5e\xe3\x97\xeb\x30\x4c\x39\xb9\xa0\x79\x30\xfd\x01\x67\x95\x26\x15\x4f\x1e\x96\x54\xae\xeb\xc5\xd4\xd2\x0d\x5f\xc5\x21\xc9\x49\x3a\xa3\x31\xce\x09\x1c\xff\x1f\xaa\xe9\xd3\xe3\x41\x7d\xbb\xba\xbe\x4b\x1b\x7c\xdd\xc6\x35\x57\xb7\x5c\xd1\xb3\x5d\x57\x45\xcd\xf7\x81\x84\x6b\xea\xc9\x4d\x0a\xa9\xda\xe6\x22\xe8\xa7\x4e\x4d\x5a\xa6\x9f\x76\x70\x1d\x18\x0b\x0b\xa1\x0d\x63\x71\x05\x0d\x70\x65\xc8\x5c\x2d\xd2\xa1\x99\x5a\x0e\x3b\xcc\xb1\x5c\x9f\x3a\x0e\x98\xf7\xda\x7e\x5f\x27\xb3\xaf\x7f\x66\xfa\x8a\xa6\x77\x53\x82\x68\xc0\x62\x94\x33\xc5\x22\x9a\xcc\xe9\xd5\xe3\xe5\x33\xd3\x4a\x4d\x9a\x29\x0d\x4d\xd8\x45\xb4\x98\x3d\x1d\xa3\x31\x8b\x73\x14\xd1\x09\xce\xe7\x29\x29\xcc\xf8\x55\xc0\x6e\xb7\x70\xe1\xf6\xab\xb4\x7d\x28\xf2\x14\x1c\x2f\x41\xc9\xa5\xfa\xa8\x0c\x4e\x96\xc6\x08\x75\x2c\x0b\x11\xa1\xaf\xd0\x45\x2a\xb2\xb6\x93\xf1\x98\x04\xf9\xf2\x9e\x1a\x24\x46\x5d\xf7\x84\xcc\xe3\x2d\x9c\x11\x7a\xb7\x0e\x47\x25\x45\xc4\x49\x42\x70\x9a\x21\x6a\x5f\xdd\xd6\x32\xd8\xc5\x5b\xd9\xbd\x92\x8e\x37\xb4\x83\x36\xe0\x3b\x46\xeb\x0c\x3f\x6c\xd3\x36\xd0\xbe\xd3\x38\x99\xe7\xa7\xca\x24\xc0\x5e\x8e\x44\xf0\xd1\xab\xd1\xb9\xdf\x32\x69\x1d\x60\x1b\x22\x24\x38\xe3\x0b\x9f\x92\x31\x44\x4c\x1c\xe1\xe0\x4c\xf5\x2f\xec\x02\x44\x6f\x65\x66\x31\xf0\xe1\x2d\x19\x57\x0e\x82\xaf\xb5\x1c\x42\x39\x8d\x8c\x57\x25\xb2\xc7\x6a\x88\x63\x88\xab\xa4\xd1\x30\xcb\x71\x4e\xc4\x15\x8b\xe3\x89\x22\x1f\xb2\xd3\x04\xa7\x78\x86\xfe\x12\x4b\xf2\x19\x91\x73\x8e\xae\x1c\xab\xc5\x5f\x19\x9b\xa7\xc2\x31\x53\xc4\xe4\x17\x3d\xb8\x6d\x47\x22\x2e\xdc\x67\x75\xdf\x42\xf3\x53\xf9\xe3\x54\xbc\x26\x15\x04\x41\xb0\xf5\x1c\x59\x7c\x0c\x63\x6a\xb2\x4a\x15\xcb\x94\xe3\x11\x67\xc7\x17\x57\xe0\x6b\xe2\xf9\x6c\x44\xd2\x35\x38\x1b\x67\x6a\x25\x48\x20\x1f\xd2\xb5\x70\x7d\x47\x65\x29\xb5\xf0\x2d\x05\x2c\x5e\xc6\xca\x24\xa0\xcb\x74\x44\x43\xfb\x3b\xb5\x3f\xd8\x54\xc2\xd4\xb0\x4b\x4b\xab\x3a\x1d\x16\xbe\x5c\x39\xa8\xa1\x99\x01\xc4\x32\x54\xff\xda\xfd\x14\x0a\xa0\xf6\x4a\x29\x08\x0c\x03\xbe\x2c\xb8\x9c\xcd\x31\xba\x4b\xf6\x7d\xc9\xba\x1c\xa1\xc2\x16\xd0\xc6\x4d\x79\xcd\x92\x00\x73\x72\xff\xbf\x50\x7c\xb9\xeb\x7a\x23\xdc\x1d\xe6\xfc\xce\x68\xfe\x5c\x9e\xfc\x06\xe7\xf8\xde\x64\x2e\x6e\x49\x71\x6e\x31\xfe\x35\x9e\xa9\x47\x53\x37\xb1\x78\x05\xaa\xfc\x95\xac\xa4\xe2\x30\x37\x75\x96\x15\xb3\x58\x0d\x8f\x2f\x4f\x63\x1d\xec\x06\x89\x82\x62\xd0\x36\x33\x32\xc5\xab\x2d\x51\xc3\x6e\x82\x59\x6b\x3a\x24\x60\xd1\x56\x4c\x56\xaf\xef\xe8\x12\xcd\xac\xf7\x90\xd4\x5a\xc8\x92\x57\xda\x92\x0c\xa0\xe5\x52\x69\x93\x11\x34\x9e\x47\x51\x67\x33\x41\x1e\xe5\x7c\x84\x23\xb8\x52\x9b\x6d\x47\x97\xf9\xf0\x8e\x6b\xc2\x76\x6e\xe0\xdb\xd5\x84\xa1\xbd\x3d\x84\x2e\x08\x3e\xab\x8a\xf5\xf8\x03\x18\x54\x70\x5e\x7f\xe7\x31\xbe\x5c\x31\x67\x56\xab\x0a\x61\x0f\x4b\xea\xd6\x75\x62\x6a\xad\xe4\x96\x2e\x14\x71\xe2\xb1\x59\x56\xeb\xa9\x5b\xab\x56\x3b\x17\xb0\x98\x57\x2e\xed\xec\x70\x97\x2f\xb4\x89\x52\x8f\x1f\xb3\x1f\xe3\x6c\x9e\x12\x74\x7c\x72\xa2\x82\xf5\x07\x34\xbf\xbc\xb7\x1d\x4f\xf5\x12\x47\x64\x25\x5c\xa8\x0a\x1a\x39\x66\x71\x2e\xb2\xde\x14\xfc\xa4\x93\xc5\x3b\xf6\x96\xcc\x38\x6e\x69\xc7\x60\x91\xb4\xa6\xd4\x4d\xf7\x91\xf1\x57\xa8\x09\x41\xf9\xc8\x78\x22\xc8\xec\xa6\x03\x55\x32\x62\x69\x48\xd2\xb7\x38\xa4\xf3\xec\x08\xb5\x0e\x07\xff\xd9\xea\x36\x50\x23\xf2\x7f\xce\xb5\xdc\x25\x4f\x71\xac\x72\xf0\xc8\x19\xe9\x92\x4c\x72\x07\xed\x96\xc9\x45\xd0\x53\x76\x8a\x26\x1a\x55\x38\x4f\x71\x15\x00\xf5\xad\x9f\x4d\x59\x9a\x93\x2c\x97\xad\x3e\x77\xae\xec\xe8\xbb\x5f\xe2\xe8\x7b\xcc\xe2\x3c\xc5\xd9\x32\x28\x13\x92\xab\x9a\xef\xc8\x22\x6f\x57\x6b\x6b\x8b\xc3\xdc\x80\x67\xf4\x4a\xee\xd8\x57\xd1\x11\x0b\x08\x11\x3f\xa0\xa6\xb9\x93\x48\x49\xa1\x41\x93\x50\xab\xb6\xdd\x1f\xff\x9f\xb4\xa8\x3e\x56\x71\x51\x4b\x87\x2f\x44\x53\x85\xbe\xc9\xac\xe5\xa3\x3f\x14\xda\x4d\xcf\xc8\xe5\x88\xe1\x34\xfc\x89\x05\xf3\xcc\x5e\x00\x83\x8d\xc7\x95\xda\xfa\x90\x9e\x53\x15\x94\x6c\x83\x11\x57\xd7\x94\xd8\x0b\x83\xcb\x32\x69\xad\xf8\xd2\x50\x66\xef\xeb\x7f\x1c\x3d\xc4\x6a\x8a\x9d\x58\x40\xa8\x54\x62\xdf\x01\xf3\xf8\xdb\xaf\xc1\xfe\xb2\xde\xbf\xc6\x4c\xb2\xc2\xea\x3c\x90\x34\xd4\x32\x3a\x5f\xe2\xf3\x2b\xcf\xc1\x35\xa8\xce\x37\xaf\x33\x5f\xf5\xe8\x83\xdb\x7c\xc9\x89\xe7\xe5\xcb\xce\xbb\xd0\xcf\x40\xd7\xdf\xa1\xb7\x64\x4c\x52\x05\xf5\x3d\x67\x34\xb3\x0f\xed\x3d\x40\xdd\x3d\x7e\x88\xb3\x0e\xca\x88\xe0\x7e\x24\x9a\x84\x2c\x98\x73\xc2\x00\x57\x2f\x07\x91\x92\x09\x4e\x43\x85\x2b\x58\xa7\x39\x03\x1a\xc0\x12\x71\x57\xdf\xe3\xe3\xd3\x8c\x14\xef\x47\xb0\xd5\x4d\xfc\x47\x35\x19\xd3\x6a\x1b\x5d\xa2\x79\x92\xed\xe7\xa4\xae\xf1\x1e\x55\x78\xe0\xa7\xcf\x0e\x55\x05\xb9\x2d\xfa\xbb\xfc\x7d\x55\x65\x93\x5e\x86\x46\x39\xae\x6d\x7f\x4e\x4b\x8c\xdd\x92\x83\x59\x23\x07\xb6\xfd\x80\x6a\x16\x3f\xd6\x5f\xee\xe6\x89\xb1\xef\x86\xcf\xa7\x46\x0c\x8d\x33\x35\xe9\xa6\x34\xe6\xc1\xeb\x41\xd1\x14\x65\x46\x5e\xc2\xc5\x1c\x17\xc3\xab\x7a\x35\x7c\x8c\x3d\x42\x1e\x53\x27\x70\xd1\x70\xe0\x9a\xa0\x14\x8e\x5c\xca\x4b\xe5\x67\xd1\x78\xa5\x58\xbc\x4e\xe4\xd8\xd2\x60\xbc\xc0\x5a\x9a\x68\xb0\x92\x59\x30\x27\x9d\xef\x86\xb8\xd8\x38\x1f\xd0\x34\x0a\x2e\xbc\xb5\xcb\x62\xf4\x96\x8c\x00\x28\x98\x15\x8e\x56\xf5\x2d\x0b\x3a\xa8\x28\xf2\x54\xc9\xd6\xfb\x33\x9c\x58\x29\xd6\x35\xe5\x13\x65\x1d\xeb\x85\x43\xc7\xa8\x5d\xcc\xdc\x4e\xb3\xd7\x73\x2a\x47\x2f\x73\xb5\xf3\x13\xaf\xf4\xca\x27\xe7\x13\xa9\x34\xee\x38\xa1\x7b\xab\xce\x6e\xc4\x62\xbd\x16\x12\x98\xdd\x6c\xc5\x13\x09\x6a\x78\xb1\x1a\x7d\x8f\x5a\x76\x2c\xa8\x9f\x3b\xcf\xf4\xaf\xcf\xf7\xee\x79\x63\x84\xe6\xcf\xdc\x27\x9b\x89\xec\x6b\x6e\x88\x2f\xa3\x37\x6e\xca\x3a\xdf\x11\x76\xf6\xce\xe8\x7c\x1b\x7a\x3a\xae\xc7\x7e\xde\x19\x25\xb1\xba\xf2\x97\xe9\xc0\x6c\x1d\x91\x75\x22\x4b\x73\x75\x15\x7d\xf5\xcc\x25\xa3\x95\x46\x1e\x7f\xbc\xb9\xac\xfc\x66\x74\xa0\xf3\x31\x3f\xb7\xa4\xf5\x39\xb8\xe3\x5a\x9f\x9d\xff\xd3\xed\xf5\x7f\xba\x03\xaa\x9c\xaf\x51\x43\xb1\xed\x80\xb9\x34\x8e\x68\x4c\x7a\x6e\xdc\xdc\x31\x8d\xa2\x23\xd4\x0a\xe6\x69\x4a\xe2\xfc\x58\xdc\x9e\x9e\xf0\x74\xff\xc0\x53\x39\x98\x82\x79\x46\xd2\x13\x12\x91\x40\xa4\xe2\x8f\x89\xa3\xe3\x38\x99\xa6\x34\x3e\xb3\xb4\x0a\xcd\x14\x02\x7c\x4c\xeb\x2a\x01\x52\x4f\x07\xb0\x39\xe9\xac\x64\x9f\x33\x10\xcb\x90\x10\xd1\x58\x4a\x4d\x4e\xfe\xfd\x4f\x10\x68\xdc\x00\x09\xe7\x5a\x59\x6c\xfd\x86\x8d\xd3\xd7\x6e\x9a\x09\x75\x58\xf0\xdb\x2e\x5e\xfd\x55\x48\xc8\x33\x84\xd1\x74\x3e\xc3\x71\x2f\x25\x38\x04\xb9\x98\xc8\xea\xa2\x02\x60\xea\x08\x80\x53\x9c\x43\x22\x2b\x4c\xe3\x0c\x51\x25\x77\x9f\xe6\x79\x92\x1d\xed\xed\x5d\x5c\x5c\xf4\x2f\x1e\xf6\x59\x3a\xd9\x7b\xf7\x76\xef\xe4\xdf\xff\xec\x71\xae\x34\xcb\xf6\xfe\xe3\xc7\xff\x9d\xd3\x73\x1c\x91\x38\xbf\xe7\x24\xbb\x7a\x01\xdf\x57\x1a\xf3\x8b\x28\x62\x17\x19\xc4\x05\xcc\x19\x4a\x89\xb8\xaa\xd1\x05\x1f\x9a\x90\x10\xb3\x34\x04\xeb\x9d\x0c\x42\xf2\xb1\x79\x8e\xe6\x31\xcd\x33\x34\x23\x38\x46\x34\xce\x68\x48\x10\x8e\x51\x76\x3e\xf1\xf4\x07\x3f\xb1\x14\x91\x05\x9e\x25\x9c\x3f\xa2\x63\x7d\x70\xd4\xf4\x69\x86\x0e\x07\x03\xd4\x06\x0a\xd3\x41\xa3\x4b\xb4\xcf\x7f\x0a\x12\x24\x04\x0b\xdf\x21\x1c\x87\x30\x38\x10\x8c\x9e\x53\x72\xf1\x03\x5b\x3c\xff\xdb\x00\x0d\xd0\xe1\x00\xed\x0f\xfe\x26\xab\xe5\x53\x2a\x46\x24\x73\x33\xf9\x43\x97\xe3\x04\x24\x3a\x9f\x08\x69\xee\x84\xa1\x71\xca\x66\x42\xdc\xcd\x12\x14\x91\x31\xdf\x8e\x34\x26\x29\xe7\x44\x07\x1d\x09\x9a\xa9\x00\x81\x10\xfb\x07\xb5\x0f\x07\xdd\xfd\x41\x07\x46\x46\x70\x30\x85\xe5\xd0\xf2\xe1\x0b\x96\xe6\x53\x34\x1c\x24\x0b\xcb\x82\x5e\x0c\x7b\x35\x1b\x7a\xf9\xdc\x2f\x9a\xd0\x6f\x5d\xea\x69\xa1\x92\x9b\xcc\x4b\x94\xa9\x6a\x72\x56\xba\x8a\xfc\x7d\x75\x6b\xfa\xe5\x32\x4d\x6b\x34\xfc\xa7\xec\x79\x0d\x69\x66\x2b\x3b\x9f\xb4\xb6\x25\xbe\x2c\x4a\xf5\xc6\x2c\x98\x67\x22\x32\x44\x0b\xde\x41\x2d\x6f\x31\x8f\x90\xb7\x8a\x2d\x9c\x52\xdc\x93\xe1\xc3\x8f\x9c\xad\xf9\x5e\xc1\x40\x47\xa8\xc5\xd9\xfc\x96\x23\xcf\xeb\x58\xa1\x4a\x74\x8b\x66\x72\x3a\x19\x02\x46\xfe\x8c\xe7\x51\x54\x82\x1a\xf7\x94\x38\xcc\x7c\xb7\x64\x65\x42\xa2\x23\x71\xf8\x4b\xb9\x01\xec\x6e\xe4\xab\xdd\xc8\x77\x46\x42\xe4\xd2\x8b\x8d\x80\x54\x34\x67\x35\xa3\x5b\x75\x20\x4a\xa4\x29\x9a\x02\x80\x8d\xd0\xfe\x01\xda\x3f\x10\x81\x7e\x54\x9b\xd9\x9c\x4a\xba\xad\x45\xc1\x1b\x10\xa2\x28\x50\xe8\x73\xa7\x2d\xff\xde\x92\xf8\xe4\xf0\x26\x06\x00\xda\xca\x63\x3c\x99\xa7\x55\xaf\xc7\xfd\x27\x4e\xad\x3a\x98\xfc\xbb\x09\x27\x22\xb6\xa6\x0a\xea\xa1\x5f\xb1\x36\xe8\x88\xde\xe6\x6b\x09\x21\x74\xcf\xf0\xd7\xa8\x87\xa0\x9f\x18\x47\x8e\x26\xfb\xbb\x3d\x2d\x25\xe1\xe3\xae\xbd\xa4\x5a\x09\xce\xa7\xfc\xa9\x88\x42\x8e\xc1\xc3\xa7\xe8\xf0\x7c\x78\xf0\xf3\xe1\xbf\x0f\xa7\xc3\x83\xd9\xa0\xb7\xff\xf3\x61\xd0\x1b\xf6\x87\x68\xd0\xdb\x47\xfd\xa7\xbd\x7d\xb4\x7f\x3e\x3c\x08\x06\x68\xd8\x1f\xf6\x9f\xa2\x7d\xfe\x7f\xd3\xe1\x41\x00\x55\xd0\x7e\x8f\x97\xf5\xf6\xff\x7d\x18\x0c\x78\xab\x1e\x6f\xc1\xff\xef\xcf\x16\xd2\x58\xa2\xec\xd6\xdf\xcc\x73\xfe\x9c\xfe\x21\xc2\xf1\x99\xfd\x38\x2f\xfb\x6e\xf3\x6d\x2b\x68\x57\xd5\xf6\xb9\xda\x2a\xc1\x1c\x29\x4d\xdb\x58\xde\xaf\xd2\x86\xbf\x38\x30\xa0\x00\x80\x5e\xe6\xec\x97\x55\xed\x94\x43\x68\x4c\x69\xca\x1a\x3f\x2b\x9c\xfb\x47\x5f\x52\x6c\xaa\x06\x6d\xe1\xeb\x73\xa0\x01\xab\x11\x80\x8c\xe4\x2f\x85\x50\x45\x2e\x4c\xf9\xd9\x7e\x5a\xd1\xa0\xee\x34\xba\x35\x8d\x04\x2d\xc5\xc9\xf2\x2e\x1f\x1f\x54\x35\xa8\x95\xbb\xb9\x55\xaf\x85\x10\x98\x0e\xe0\x76\x3f\xc6\x51\x04\xe8\xd3\x36\x71\xef\x8f\x59\x9c\xe5\xe9\x3c\xc8\x59\xca\xfb\xa2\x63\xd4\xfe\x46\x7f\xd6\xf1\xf1\xd9\xd8\xa9\xc8\x6b\xe6\xd3\x94\x5d\xa0\x98\x5c\x20\xce\xd0\x40\x72\x96\xf6\xdf\x8e\x71\x1c\xb3\x1c\xac\x68\x10\x16\x1c\xa4\x8c\x40\x20\x47\xf2\xb7\xce\x33\xf4\xd9\x1d\x5a\xc2\xb2\x8c\x8e\x22\x62\x75\xf0\x16\x66\xdc\xce\x48\x34\xee\x02\x30\x3d\x34\x5e\xe4\xf6\x0e\x86\x35\x24\x0e\xd4\x10\xe0\x51\x3a\xc5\x59\xdc\xca\xd1\x88\x10\xfe\x5a\xa6\x39\xc5\x11\xcd\x48\x88\x7a\x28\x9b\x27\x24\x6d\x77\x9c\x1a\xbc\x07\x12\x8a\xa1\x29\xa5\x29\x9f\xc1\xfd\xfb\xa8\xad\xb4\xe1\xfc\x37\xe7\x4f\xff\x26\xb8\xaa\xbf\xa1\x4f\x9f\x50\xe1\x9b\x99\x25\xfa\x5e\x14\x1f\x21\x3e\x62\x6f\x33\xa4\x26\x2c\x6b\x67\xf3\x11\x98\x12\x74\xc5\xb0\xe0\x6f\x35\x55\x09\xdc\x7c\x10\xfc\xba\xee\x82\x8f\xce\xfb\x08\x7e\x3d\x55\x5b\x73\xc2\xeb\xf2\xa3\x9f\x92\x2c\xe3\xc3\x98\xcd\xb3\x1c\x11\x91\x06\x64\x44\xa0\xb1\x48\xf8\xa1\xba\xe8\x42\xca\x80\xbf\xa1\x07\xa8\x30\x16\x58\x2a\x35\x7a\xfe\xd2\xc8\x99\x8c\xa0\x2e\x59\x04\x29\x62\xb4\x06\xe8\x0c\xd7\x34\xe1\x77\x4a\x60\x76\x9e\x23\xb2\x64\x1a\xcc\xe2\xd8\xc1\xfd\x84\x86\x0b\x5d\xa4\x34\xb7\xa2\xfd\x71\x10\x63\x3a\x99\x5b\x11\x00\x39\x9a\x75\x9e\xc1\x52\xda\x8b\x2b\xc7\x97\x11\xce\x07\x8a\x21\xbc\x19\xa3\xef\xcb\xcb\x2b\x36\xc8\x8c\xad\xff\xf1\x23\xcc\xe4\xe3\x47\xf4\xdc\xaa\xa2\x25\xdf\xd9\x94\xcd\xa3\xf0\xb7\x24\x14\xae\xf3\x46\xb2\x6c\x95\xb7\x73\x92\xe5\xce\x9d\x65\x8c\x18\x7e\xc0\x19\xd1\x0e\x2a\xca\x02\x81\x03\x1e\x63\xbe\x5a\x97\xea\xde\x01\x82\x2a\x17\xfd\x27\xf1\xa9\xe3\x35\x7e\x76\x4f\x37\x3e\xa9\x18\x55\xfb\x63\xa1\x2f\x64\x61\xab\xdd\xac\x8b\x3e\x16\x40\x23\x03\xc9\xae\xda\xb6\x2d\x27\x7c\x42\xc4\x4f\x6b\xd7\xa9\x6e\xa0\x99\x3b\xbc\x9a\x44\x88\xf6\x66\x2c\x7d\x9c\x24\xd1\xa5\x2c\xc6\xe9\x04\x2c\xe8\xb2\x8e\x36\x90\xd0\xe6\x11\x76\x97\x06\x1b\xfb\x62\x63\x34\xb8\xaa\x9d\xf3\x2a\xb4\x63\xb2\x10\xef\x0a\x7b\xae\x72\xf4\x7c\x7b\x61\x40\x7d\x29\x6e\x31\x95\xf5\xa8\x9e\x2d\x19\x56\x4a\x62\x91\x04\x5e\x8f\x43\x94\xb4\x4b\xfa\x93\xa8\x61\x75\x59\xd2\x8f\xac\x6b\x77\x27\x2a\x7d\x96\x7c\x75\xbf\xb0\xbd\xfc\x24\x55\xca\x11\x5a\x46\x8e\xd0\x32\x63\x92\xbd\x00\x8a\x7a\x97\xb3\x61\x92\xc4\xd3\xc9\xbb\x48\xcd\x67\x07\x8b\xbb\xa8\x65\x1f\x9d\x56\xa7\xd3\xf6\x70\x47\x29\x23\x2a\xa7\x28\xb5\x14\x45\xc6\x2a\x73\x2a\x6e\xe3\x31\xf6\x78\xa3\x8f\xb1\x1a\x2e\x0b\x48\x0f\xc9\x4f\x72\x9c\xd3\xc0\xc1\x5e\x55\xd8\x3e\x23\x97\x5d\x41\x69\x57\x21\x3d\x7b\xdf\x21\x92\x45\x34\xce\x7b\xd2\xc0\x00\xc5\xac\x07\xc1\x5c\x7a\x29\xc1\x59\x46\x27\xb1\x90\xbe\x22\xe4\xb4\x7f\x7f\x46\x2e\x3f\xa0\xe7\xa2\xc3\x67\x1e\x28\x12\xd7\x43\x92\x43\x73\x00\xd6\xef\xa4\x9a\x65\x91\x2f\x7e\x72\x5d\x5b\x20\x39\xd2\x29\x8e\x22\x76\xf1\xe3\xff\xce\x71\x54\xc5\xef\x0e\x4d\xfc\x4a\xbb\x7a\x2d\xfb\x6a\xd5\xbb\x16\x46\xb2\xb8\xc6\xee\x58\x4d\xa0\x5c\x7f\xc1\x9f\xee\x04\x10\x3b\x01\xc4\x36\x04\x10\x0f\xa5\xc8\xa1\x5c\xe6\xf0\xc4\x15\x3a\x94\x4b\x1d\x9e\x28\xb1\xc3\xac\xf7\x14\x0d\x0f\xa2\xde\x61\xef\x10\x0d\xfb\x07\xc3\x1e\xff\xcf\x2f\xc3\x01\x1a\x1e\xf4\x87\x8f\xa3\xc7\xfd\xc3\xa7\x3d\xfe\x9f\x5f\x86\x4f\xd1\x93\xa8\xf7\x14\x3d\x2d\x93\x54\x94\x49\x27\xae\x55\x22\xb1\x44\x0a\x61\x49\x1e\x56\x96\x36\x14\x0e\xf6\xe3\x4d\x66\x65\xdf\x1d\xec\xdd\xc1\x2e\x1c\xec\xab\xca\x12\x67\xbd\x7d\x34\x1c\xfc\xfc\xf8\xbc\xb7\x3f\x1d\x0e\xce\x1d\xe1\x62\x55\xbc\x67\xe3\x38\x53\x56\xe1\x5a\x0e\x73\xd5\xd0\xca\x4e\x76\x55\x34\xe9\xd2\xf2\xc6\x67\xbe\xb4\x75\x91\x00\xdc\xd0\xdc\x02\x34\xa9\x8c\xdb\xfd\xe5\xf3\x0a\xd0\xe4\x06\xe4\x14\x78\xbc\xc9\x9c\x02\xbb\xd0\x28\xb7\x3c\x34\xca\xc4\x95\x84\x95\x0f\xe1\x49\x45\xf5\xba\x7b\xc9\xad\xe9\x5a\xc2\x6a\x01\x50\xd5\x9c\x9f\x56\xd4\xaf\x9b\xaa\x07\xd9\x40\x00\x9a\x0c\x82\xb9\xaa\xee\x86\x83\xb2\xda\xb5\x9d\x59\x40\x0d\x0f\x50\x25\xa7\xaa\xec\x77\xb8\xbc\x6d\xdd\x28\xaa\x3b\xd4\x70\x95\xf8\xae\x72\x08\xc5\xaa\x75\x3d\x6a\x70\xdb\xe5\xb9\xae\xc3\xb4\xfa\x8c\x5c\x06\xd5\x26\xc7\x8f\x0f\xfd\x8a\x75\xe0\x65\x95\x6b\x8d\xc0\x73\x8c\xe3\x80\x54\x89\x15\x0e\x1f\x3f\xf4\x2a\xd6\x41\x17\x35\xcc\x92\xb2\x88\xa5\xaf\x71\x4c\x93\x79\x84\x73\xf0\xc6\x2d\x47\x1d\xb3\x46\x2f\xce\x71\x8e\xab\x2a\xee\x3f\xf1\x2b\xd6\x0d\x46\xd4\xf8\xba\xad\xd3\x57\xcb\x51\x77\xe5\x71\x29\x38\x5b\x33\x9c\xe7\x0d\x85\x8d\x29\x7a\x8e\x1e\xee\x3f\x53\x1e\xe7\x6e\x10\x10\x9d\xa9\xd6\xc3\xbf\x3e\x99\x25\x53\x9c\xd1\x3f\x49\xc7\x0b\xf3\x62\x00\x98\xf0\x76\x83\x3e\xd0\x34\xd1\x43\x48\x22\x22\xc2\xe6\xd5\xf7\x30\xc6\x61\x01\x38\xc4\x20\x91\xbe\x6a\x1c\xec\xfe\xa3\x8e\x9d\xab\xb4\xcc\x0b\x60\xcc\xe2\xfc\x27\x3c\xa3\xd1\x65\x49\x6c\x21\xf3\x71\x85\x40\x44\xc3\x87\x9d\x55\xe2\xbb\x78\x11\x90\x0a\xe1\x5d\xbc\xef\xca\xf5\x40\xfc\x5b\x1b\x79\xc8\x8f\xb7\xe3\xed\x9d\x1e\x65\x21\xb0\x8b\x57\x50\x1e\xf9\x48\x22\xc7\x1e\xda\xd7\x3e\x10\x53\x9a\x93\x93\x04\x07\x04\x5c\x1e\x2e\x20\x3b\xa0\xeb\x1f\xd1\x1a\xd3\xbc\x17\x88\xb9\xb5\x56\xf2\x7d\xd0\xa3\xdd\xdb\x13\xa1\x75\x84\x2d\xb1\xbc\xdd\x84\x65\x33\xd8\x29\x0b\xab\xd2\x7c\x4a\x62\x74\x1a\x44\x34\x38\xe3\x6f\x81\x53\xa9\xda\x66\xe7\x24\x4d\xc1\xf8\x5c\x34\x60\x29\x1a\xb1\x7c\xaa\x56\x71\x9e\x66\x05\x5f\x3d\xfe\x3f\x26\x4c\x37\xb4\x27\x07\x1f\xc4\xbf\x98\x2a\x46\x10\xd1\x05\xbc\xc8\x8d\xd5\x76\x8c\x8e\xa7\x29\x9b\x11\xd4\xc6\x19\xca\x53\x3a\x99\x90\x94\x84\x68\x74\xa9\xa3\x98\xc3\x83\xb2\xe3\xac\xad\xd3\xc1\x5b\x32\x63\xe7\x04\x9d\x0a\x87\xdb\x53\x59\x45\xd6\x37\x71\xa9\xca\xaa\xca\xaf\xd2\xd2\x55\x58\x9d\xaa\xa5\x30\xa8\x6f\x1a\x4e\x52\x72\x89\xa6\x74\x32\x8d\xf8\x9e\xca\xcf\xbf\x93\xd1\x19\xcd\xdf\xe1\xe4\x67\xf5\xa1\x34\xee\x4f\xc0\x66\x33\x16\x8b\x2d\x4b\x70\x6a\x67\x15\x57\xcb\x99\x30\xea\xe0\x70\xeb\xfe\xd1\x94\xef\x44\x17\xdd\x3f\x82\x85\x6b\x1d\x59\x5a\xb1\x02\x3a\x2e\xa5\x30\x3e\xbe\xa2\x41\x7f\xf0\x44\xad\xec\x67\xab\x57\x11\x84\xcb\xed\x8d\x2d\x4e\xa6\x38\x64\x17\x3a\x12\x18\xfc\xca\xde\x0f\x3f\x74\x37\x3b\xa4\xe1\xbe\x1e\x92\xbd\x31\x40\xef\xdc\x8d\x69\x5d\xc7\xb2\xd8\x63\xc0\x70\x81\x9b\xde\x44\x8e\xff\xb7\x82\xd2\xf4\x7c\x27\xa7\x87\xfb\x3e\x31\x32\x25\x4d\xe8\xe3\xa3\x4e\xb1\xef\x63\x6d\x86\xec\x05\xad\x1a\x3e\xf5\x3b\x1b\x3e\xb5\x9b\x7b\x61\xb6\xd6\xa0\xb8\xf2\xb0\xfc\x42\xc6\x1c\xf8\xbe\x57\x2c\x17\xc1\x94\x57\x3b\x76\xd5\xd1\x3f\x7d\x16\x4a\x83\x8d\xe9\x2b\xef\x1a\x0f\xa7\xa8\xee\xdd\xb6\x4b\x8f\xae\x0e\x1b\xe6\x84\xe7\x13\xf8\x02\x46\xb9\x07\xc9\x02\x0d\x50\xef\x49\xb2\x28\x1c\x77\x07\x9d\x83\x3a\x24\x16\x77\xbb\x3f\x36\x34\xe8\x1f\x78\xe8\xbb\x39\x27\x36\xc9\x0e\x17\x72\x8c\xa8\xa3\xb1\x56\x82\xe4\xab\x26\x47\xde\x6c\x62\xe4\x3b\x10\x9a\xeb\x78\x9e\xe5\x6c\x26\xb1\x16\xe2\x28\xf5\xd1\xef\xd2\xa7\x28\x9b\xb2\x8b\x18\xb1\x38\xba\x44\x74\x8c\x4e\x59\xcc\xdf\x1e\x24\xcb\x5f\x42\xe5\x53\x44\x33\x94\x11\x6b\x67\xed\x53\x77\xf7\x76\x57\x04\x31\x03\x46\x4b\xc5\xa7\x02\x52\x69\xe6\x2f\x29\xe7\x2d\x8e\xcd\x51\x8f\x61\x2c\x3e\xe6\x3c\xcf\x15\xf2\xcd\xb0\xf8\xff\x90\xcb\x97\xec\xa2\x3a\x19\x7e\x11\x86\xc9\xcc\xa3\xde\x56\x5e\x8a\x1e\x0b\x77\x21\x51\x0f\x1f\xa3\x9d\xe7\x2b\x23\x82\x7d\x75\x2a\x5e\xd8\x38\xde\xb7\x06\xe8\xe0\xf8\xad\x48\xad\x03\xd4\x5a\xaa\xa5\x8e\xa7\x34\xc9\x50\x4a\x92\x94\x64\x1c\x51\x39\xb1\x89\xc8\x02\x91\x38\xa7\x90\x09\x8a\xc6\x28\x9b\x61\x3e\xf7\x88\x05\x67\x60\xd5\x17\x4c\x85\x81\x2a\x78\x84\x06\x96\xf6\x4a\x6a\x12\x2c\xe3\x38\x40\x9e\x6f\x3d\x9b\x18\xb8\x71\xb4\xe0\xcc\x56\xba\xd2\xa4\x8b\x0a\x6d\xe0\xfd\x68\x69\x89\x69\xd2\xb6\xcd\xfa\x64\xc8\x02\xfd\x33\x27\x33\x0e\x45\x5a\xb9\xa5\x24\x97\x1f\x8d\x37\x9c\x91\x8c\x9a\xbe\x45\x75\xd0\x36\xc8\xfa\xfc\x65\xd2\x06\x88\x11\x78\x31\x6a\xcb\xb8\x7e\x44\xe2\x49\x3e\x05\x5b\x39\x7e\x89\xbd\x48\x53\x7c\xd9\xe6\xb5\x3a\x5d\x10\x7c\xa1\xe7\x68\xf0\x4c\xfc\xf5\x77\x68\x2d\x7e\x3c\x78\x60\xac\xbc\x78\xd3\xf7\x1f\xa5\x85\x8f\x86\x2c\x4a\x94\x41\x96\xa3\x1e\x49\x09\xb8\xcc\xc0\xec\xc4\x1f\xfc\xf5\xa4\x54\x5c\x95\x72\x50\x7f\x82\xca\x59\x8d\x4f\xd4\x32\xc4\xfc\xf4\x49\x00\xf2\x24\xd5\xee\xd6\x74\x3a\x60\xc4\x25\xcd\x05\x85\x7b\xd1\x7b\x0e\xf6\x43\x3f\x60\x71\x80\xf3\x36\x9f\x55\x07\x72\xab\xf3\x62\xf5\x6f\x3f\x98\xd2\x44\x44\x98\x03\x17\x3c\x59\x3a\xc5\x71\x18\x91\x97\x86\xc3\xe0\xc7\xd0\xc1\x1e\x48\x8a\xd5\xb1\xf9\xb1\x93\x9c\x25\xc2\x33\x19\xf2\x65\xc1\x6b\x73\x34\x1f\x8d\x22\x1a\x4f\xd0\x3c\xd1\xe9\xca\xf8\x70\x4f\x65\x33\xa8\xda\xcf\x72\x96\x70\x22\x86\x27\xe0\x91\xdf\xd6\xf6\x7d\x7c\x87\xbd\x43\x8c\x9e\xcb\x21\x0a\x7f\x51\xef\xab\xb6\x07\xa4\x63\xd4\xf6\xbe\xd9\xa6\x85\xde\x27\x39\x9b\x67\x1e\xf3\xef\x2c\x86\xa4\x75\x75\x8b\x20\x50\x7c\x4a\xb3\x6f\x13\xc9\x43\x59\x43\x35\xcf\x25\x4d\x7b\x55\x85\x6f\xd5\x5c\xa0\xd4\xad\x58\x3a\xf9\x6f\x4b\x27\xef\x36\x34\xe3\x75\x9b\xc8\x72\xbd\x52\x7c\xd0\xe2\x5c\x00\x96\x29\xd9\xb0\x41\x2f\xb5\x36\xce\xca\x8a\xf1\xdf\xbf\x8f\xda\xd0\x16\x42\xaa\x71\xd6\xbe\xc5\xd1\x55\x17\x89\x97\x84\x13\x6a\x4c\xec\x78\x92\xc2\xbf\x4a\xee\x69\xc5\xfb\x92\xa0\xfd\x1d\x41\x24\xca\x48\xd9\xae\xf2\x31\xe8\xfe\xf8\xcd\x22\x86\xb1\x5a\x97\xb5\xc8\x60\xba\x36\xf3\xca\x82\x95\x7a\xe0\x8d\x9d\xe3\xe6\x06\x5f\x73\x3e\xf5\x47\xd1\x3c\x6d\x3b\x11\xd0\xd4\xbf\xce\x0e\xc8\x7d\x74\xb1\x5a\x16\x56\xe3\x33\x99\x25\xca\x39\xb1\x09\x61\xb2\x28\x75\x47\x28\x78\xd5\x15\x61\xab\x95\xfc\x5b\xe2\xbd\x18\xd2\x19\xe1\x0f\x4d\x61\xd8\x2b\x5f\x3b\x52\x55\x5a\x6d\xf5\xab\x8f\xd0\x3e\x7a\x0e\x42\x28\x07\x4f\x3f\xaa\x73\x55\x7e\xac\xc4\x63\x84\x53\x12\x8e\xf5\x02\xe1\x45\x99\x5d\xcb\xf8\xb6\x7f\x2c\x75\x6e\x47\xb6\xa3\xb6\x0b\xac\xe0\xe5\x8e\xd4\x13\xdb\xd4\x81\x9f\x15\x87\xbd\xe6\x9c\x5b\xc7\xd5\x3b\xa9\x4b\xe8\xc1\x52\x52\x60\x18\x79\x77\x32\xa6\xdc\xae\xad\x38\x1d\xb7\xae\x2a\x75\xc6\xb2\x9a\x6f\xfe\x47\xed\x9c\x2f\xb6\xa4\xce\x35\x1f\xd6\xb0\x25\x92\xee\xf0\xa5\x12\x7f\xca\xf5\x10\x3f\x9c\xe9\x42\x64\x52\x3d\x9d\x96\x9d\x5f\x47\xb9\xf3\x2b\x14\xb2\x43\x17\x34\x0e\x21\x5a\xeb\xcb\xfb\xd7\x67\x13\xa6\x53\x8b\x11\xbb\x6a\xdb\x97\xba\x02\xdb\xcd\xb5\xb0\xab\xeb\xef\xb4\x1d\xdf\x93\x03\xe9\x38\xe7\xc2\xcc\x5d\xde\xe3\xcf\xaa\xaf\x41\x4e\x30\x3d\x94\xb8\x7f\xbf\x60\xf7\x43\xb3\x7f\xe3\x88\x86\xca\xf0\xc7\x6d\xe0\x10\x74\xa7\xef\xda\xf8\x91\x2e\x10\x37\x90\xa4\x7e\x8d\x54\xb3\x1f\xa5\xe7\xb3\x49\x20\x05\x0b\xd1\xbd\x99\x57\x07\xa1\xfc\xdc\xe0\xea\x69\xbe\x0a\x6e\x3a\x23\xa9\xbe\x34\x0a\x9e\xd2\x18\xa2\xf6\xa8\x1b\xac\x8e\x3d\x62\x1b\x35\xb0\xd2\x63\xfa\x68\x61\x11\xcb\xe5\xfb\x6f\x2a\x3b\x7b\xbf\xb7\x87\xbe\xe5\xcf\xd0\x9f\xe8\xe2\x35\x41\x3d\xa1\x35\x88\x18\x3b\xcb\xa4\x41\x4d\x74\x89\x02\x96\xa6\x24\xc8\x85\xf3\x15\xa4\xd1\xb8\x98\x5e\x22\x9a\x23\x92\xa6\x2c\x15\x62\x13\x8b\x7a\x2f\x43\x22\x33\x12\x17\x81\x56\xc2\x08\x79\x29\x58\x17\x46\x01\x13\x1c\x6c\x93\xd2\xd7\xe3\xd5\xfb\x38\xd6\x91\x5c\x8b\x7d\xf9\x50\x4b\xb1\xcf\xde\x4b\xad\x1a\x79\xee\x90\x69\x87\x35\xfb\x46\x7d\xb1\xf7\xc9\x6a\xa8\xd0\xe5\xd3\xa7\xc2\x65\xf2\x3d\x1a\xa0\x23\xd4\x1b\x16\xfa\x6e\x6e\x1b\xc8\xff\xd7\x0a\xe9\x79\xcb\x2c\xdf\x92\x90\x28\x00\x9f\x41\x30\x13\xa1\x9e\x69\x55\x9c\xf3\xd2\xbb\xd7\xbc\xcb\x4b\x6f\x28\x75\x6c\xea\x6e\x5c\xe7\x50\xc9\x32\xb3\x11\x85\xb8\xc6\x48\x45\x30\xb6\x78\x98\x71\x3b\x66\x21\xe9\x78\x91\x71\x05\x1b\x63\x3f\xb0\x58\x48\x9e\x59\x55\x3e\x5b\xfb\xdd\xf5\x8e\x81\xf9\xdd\x70\xd5\xfd\xc8\xc8\xa8\x61\x74\x64\xa4\x38\x18\xfd\xdb\x1a\x8b\xa1\x41\xb2\xc8\x72\x48\xfa\xfc\x01\x7e\x48\xdc\xe0\x8c\xdf\xb3\x7b\xca\xd9\xca\x0a\x6b\x6c\x4b\x0a\xae\x9e\x9d\x8d\x26\x32\x33\x9b\x10\x05\x78\x76\x80\x9b\xcc\xa8\xb6\x33\xe1\xde\x99\x70\x4b\x13\xee\x7d\xb4\x7f\xfc\xa8\x7f\xf0\x18\x4c\xb5\xe5\x1f\xc3\xfd\xec\x80\xff\x35\x1c\xe8\xff\xef\xc9\x82\xde\x70\x70\x32\x7c\xdc\x3f\x7c\x08\xd5\xd0\xfe\x9f\xb3\x43\x34\x7c\x08\xde\x16\x87\xfd\xc3\xa7\x68\xf8\x98\x17\x0f\x1f\xf6\x0f\x86\xe8\x09\xff\xcf\xf0\x31\x7a\x8c\xe4\xb7\x01\xfc\x77\x1f\x3d\x16\x9f\xe0\x3f\xa2\xbe\xf8\x02\xb5\x1e\xf3\x26\xa2\x29\x40\xe1\x9f\x25\x04\xc7\x8f\x43\xd9\x53\x19\xf9\x1c\x94\x5c\x8f\x0f\x87\xea\xbc\xd4\x83\x43\x99\x67\x89\x3f\x9a\x7b\x6f\x40\xf5\xe2\xc1\xdf\x64\x50\xdd\x8d\x1d\xfc\x97\x14\x47\x6c\x52\x69\xce\x76\xf8\x85\x8d\xb7\xc5\xf0\xca\xcc\xb7\xad\xd1\xbf\x00\xb0\x55\x36\x7f\x87\x8f\x1f\x35\x99\x84\x03\x6a\x7b\x53\x91\x1d\x2c\x99\xd1\x3b\x08\xa2\x58\x35\x9f\xc7\xcd\xe7\xf3\x4e\xc4\x37\xdb\xd6\x6c\x00\xfc\x92\xb9\x48\x2b\xa8\xca\xd9\x3c\x69\x3e\x9b\x63\x65\x74\xb4\xad\xf9\xc8\x0e\x9a\xcd\xe8\x1d\x59\x54\xcf\xea\xe9\xca\xb3\xe2\xe0\xb6\x3e\x33\xde\x49\xe5\xec\x38\x8b\xf3\x9a\x8d\x68\x44\xea\xa9\xc2\x93\x41\x93\xc9\xf9\xd0\xb6\x31\x37\xbf\x8f\x9b\xe0\xe7\xb1\xc9\xe0\x5f\x37\x31\x76\xfa\xce\x2d\x64\xcb\xb1\xd3\x2b\x12\xe5\xbe\x66\x21\x8e\x6e\xbb\xf5\xff\x75\x58\xe8\x37\x4e\x5f\x0b\x2b\x5a\x69\x65\xff\xd8\xad\x57\x37\x08\xa8\xa0\xab\xff\x84\x2b\x6d\xd6\xf7\x1f\x3f\x71\xaa\xd5\x01\xe5\xdf\x75\x65\xcb\x98\xb6\x6a\xe1\xcc\xbc\x7e\xc5\x09\xa9\x72\x0a\x38\xf4\xaa\xd5\x8d\x00\x2a\xec\x3c\x02\x1a\xc0\xd3\xa7\xf4\x9d\x88\xc7\x54\x63\xc2\xb1\x1a\xe0\x77\x7a\xdf\xb5\x4d\x4a\x05\x66\x0d\x1a\x4f\xbe\x04\xe6\x06\x97\xc2\x40\x7f\x29\x63\xd7\x6f\x72\xc4\x1a\xe6\x97\x48\x36\xb0\xcc\xac\xbf\xcc\x40\x55\x2a\x35\xc5\x2b\x94\x9f\xa7\xa5\x66\xae\xca\x0e\xb3\x34\xa7\xf1\x81\x9d\x80\xe0\x25\x4d\x45\xf2\xc2\x23\xc8\x0c\x34\x9f\xc5\xc5\x1c\xcc\x43\x37\x07\x73\xc2\x94\x91\x7e\x2b\x25\x11\x64\x58\xb5\x3a\x5e\xfc\xac\x2c\x43\x9f\x0e\xce\xa7\xc6\x72\xfe\x9c\xa4\xe3\x88\x5d\xfc\x8f\x36\x19\x45\x7b\x7b\xe8\x27\xba\x40\xaf\x7e\x1c\x0e\x11\xcd\xb2\x39\xe9\x8a\x98\xea\x60\xec\x8a\x73\x94\xb1\x19\x41\x60\x77\xaa\x44\xe7\xa5\xf6\xd0\x9e\x4d\xbe\xa7\x09\x36\x8b\xf6\x3b\x0d\xf3\xe9\xff\xcd\x6c\xe3\xe6\xc5\xef\x76\x82\xe8\x51\x4a\xf0\x19\xf4\x97\xf5\x81\xa5\xc9\xfa\x8b\xac\x1c\xcc\xc9\x6c\x25\x30\xd9\xac\x1c\xcc\xeb\x70\x25\x30\x33\x27\xaf\xf0\x78\x1e\x45\xb2\x45\x69\x6e\x61\xbf\xee\x49\x90\x12\xdb\xae\x5a\xe1\xc8\xc0\x77\xcd\x70\x32\x13\x9b\x61\xb9\xe5\x26\x6d\xb0\x57\xfb\xe7\xd2\x0f\xae\xcb\xc8\xc0\xc8\x56\x37\x63\xb4\x2b\xdf\x1a\x26\x9b\xdc\x3c\x9b\xe3\x28\xba\x04\x3b\x1c\x1a\x07\xd1\x3c\x24\x21\xca\xe6\xa3\x5e\xa9\x19\xeb\x5d\xc8\x4f\x76\xfb\x6d\x7a\xad\x4c\xb2\x56\x86\x00\x8e\xba\xbd\x0c\x70\x57\xc3\xb7\xd1\x79\x9d\x44\xb5\xa0\xbc\x56\xe9\x58\xf9\xe5\x15\xa6\x2c\x11\x3d\xc6\x2c\x07\x43\x4d\x61\xc1\xa5\x15\x47\xc7\x11\xcb\xc8\xa9\x4e\x32\x6b\x96\x4b\xcc\xfc\x07\x09\xa3\xde\xd0\xb4\x76\x4c\x53\x9a\xe7\x7c\x48\x24\x0b\x70\x42\xae\x32\x98\x1f\x01\xc2\xff\x21\x97\xbf\x25\x2b\x0c\xe5\xdd\x94\xe8\x2c\x32\x3a\xf5\x86\x61\x19\xbb\x88\xc6\x68\x46\xa3\x88\x8a\x1c\xf0\x12\x63\xd0\xff\xb0\x39\x9a\xe1\x4b\x94\x25\x24\xa0\xe3\x4b\x84\x51\x46\xe3\x09\xe4\xf0\x98\x11\x36\xcf\x01\x14\x8e\x22\x0b\x54\xd6\x45\x2c\x45\x34\x86\x1c\xe1\xe2\x98\x72\x0e\x1c\x61\x60\xfb\x48\x60\x99\x66\xe7\x85\x4b\x7b\xd5\x33\x5a\xc6\x4a\xac\x79\x62\x4b\x40\x6d\xe6\xfc\x16\x01\x7b\xa7\xf9\xa5\x8c\xea\x21\x10\x61\x86\x17\x82\x56\xeb\x7c\xc3\x40\xfd\xfa\xd6\x3e\x0a\x72\x28\x2a\x4d\x52\x76\x21\x92\x91\x08\x22\x40\xff\x24\xaa\xa1\x38\x56\x5d\xa1\xcd\xd6\x79\x95\x69\x86\xe6\x40\x3e\x04\x40\xa6\xcc\x95\xb3\xb3\x9c\x9f\x92\x29\x49\x09\xe4\x18\x99\x81\xdf\x5f\x4c\x38\x65\xe5\x57\x75\xc0\xf8\xa7\x38\x47\x21\x1d\x8f\xc5\x5f\x62\x04\xd0\x25\x0e\x52\x96\x41\xe6\x94\x54\xc0\x05\x3a\x14\x88\xcc\x44\x7a\xc3\xcd\x75\xb3\x24\x3d\xe1\x02\x6c\x69\xb2\x19\xff\xef\x2c\x2c\x4b\x7c\x2d\x30\x92\x92\xb0\x8b\xb2\x3c\x25\x79\x30\x25\x99\x5a\x99\x9c\x99\x55\xec\x3b\x64\xa5\xbe\xf7\xe2\xb1\x31\x66\xde\xae\x75\xb7\xa6\x2a\xbe\x69\xb7\x30\xd7\x6e\x46\x30\xea\xac\xca\xa1\xbb\x11\x19\x33\x49\x1e\xe4\xcc\x80\x63\xcc\xec\xae\x7e\xe4\x25\xeb\x1f\x1b\xf3\x66\xb8\xf2\xb1\xd1\xa0\x36\x7d\x6c\x14\xe0\x4e\xb3\xbd\x91\x4b\x45\x33\xb1\x5a\x9c\x35\xf6\xd7\x0b\x5c\x2a\x77\x4b\xe6\x2f\xd9\x14\xcb\x35\x73\xb1\xf9\x47\x51\xb4\x5b\xb1\xcc\xac\x98\xbc\xc7\xcf\x08\x10\xd4\x94\x44\x04\x67\x24\x84\x34\x48\x40\xc4\x41\x6e\x44\xc1\xb3\x01\xde\x34\xce\x7a\x36\xb8\xc1\xd7\xa1\x0d\x0b\x9a\xbb\xfd\x2c\x68\xbe\xdb\xb4\x72\xca\xb0\xa0\xb9\x4f\x18\x44\xd1\x6e\xc1\x2a\xe8\xc2\x82\xe6\x1e\x59\x80\x92\xdd\x7a\x59\xeb\xa5\x5f\x5c\x28\x15\xbc\x7c\x06\x09\xd3\x08\x0a\x38\x4f\x2f\x57\x4f\x3e\xaa\x20\xa6\x2e\xfa\x4b\xf0\xc4\x9f\xa5\xb3\xc9\x3b\xed\x76\x92\xb1\x79\x1a\x68\x56\x4e\x3d\x06\xee\x15\x5c\xc2\xe0\xb5\xb0\x02\x19\xb1\xde\x24\x1c\xf0\x4b\x7d\x24\x58\x42\x6c\x97\xb3\x64\xa5\xd7\x97\x59\x31\xc7\x5a\xa5\xc0\xe7\xaf\x8a\x2d\x9e\xd4\x74\x4d\x44\x71\xa1\x6c\x06\x47\x1c\x98\xc2\xdb\x4d\x99\xf0\x88\x35\xcd\x10\x4e\x09\x08\xc6\x22\x4c\x43\x79\x23\x80\x70\x08\x8d\xe0\xae\x30\xcf\x73\xf9\x40\xd2\x5c\xa5\xb0\xf3\xd1\x12\x48\x01\xcf\xcf\x7d\xf7\x51\x3f\xc3\x85\x6f\xc1\xf9\xf5\xe4\xc3\x33\x8f\x73\x5d\xc7\x14\xa9\x4a\x25\xcf\x66\x5d\xbb\xe4\x9b\xdb\xcc\xba\x1e\xbd\x46\xd6\x97\x62\x50\x11\x4b\x96\x2c\x6d\xfd\x0b\x9f\x7c\xa9\x97\xae\xaa\x0a\xec\x49\xba\x35\x74\x89\x96\x78\x26\xd6\x0a\xf0\x1f\xfa\x43\x5c\x3e\x6f\xaf\xdc\x54\x2f\x9b\xaf\x53\x6a\x55\xe5\x9c\x98\x5d\x89\xff\xf6\x3e\xd3\x78\xe2\xd7\x00\x59\x8c\x53\x89\x84\x7e\x1d\x91\x26\x4e\x56\x59\xd0\xdc\xfe\xbe\xa0\xb9\xfb\xd1\xeb\x43\x94\xb8\x55\xdc\x1e\xa0\xc0\x54\xb0\x69\x97\x55\xcd\x2e\x56\x95\x0d\x65\x91\x9e\x1c\xfe\xe6\x5e\x47\x8a\x45\x83\xe1\x90\x30\xbf\x88\xc1\xa6\xd8\xda\x37\xf0\xdf\x28\x20\x21\x3c\x69\x25\xbe\x29\xd8\xfa\x07\x47\x24\xe1\x17\x52\x00\xef\xa0\x84\x2c\x10\xba\x05\xfd\x27\x8d\x27\xd6\x2f\x48\xbf\xdf\x12\x8b\x6f\xfe\x32\x75\x60\x4f\x1c\x27\x14\x58\x78\x77\xd4\x6b\xa4\x91\x94\xca\x50\xd7\xbc\xee\x3a\x12\x4a\xaa\x25\x2b\x0a\x5c\x8e\x4a\xe8\x44\x0d\xad\x3a\x2a\x2b\xac\x24\x52\x47\xc5\xa2\x0a\x5a\x70\xe4\x17\x94\x12\x81\x23\x54\x71\xfa\xdd\x1b\xbf\xfc\xb8\x64\x53\x76\x71\x04\xc4\x49\x2a\x08\x9c\xfc\x97\x8d\x6c\xb0\xdd\x13\xa7\x00\x1b\x8d\x0c\x4e\x12\x02\xa1\x32\xa4\x69\x8e\xf8\x5f\x8b\xc6\x2d\xd1\xb1\x29\x93\x42\xc2\xba\xd5\xb7\x44\x18\x1e\x39\x73\x1f\xeb\x45\x4a\xe6\xbc\x4c\x0b\x44\xcc\xbc\x7f\x5c\xfa\xe5\x70\xfa\x05\xd2\x65\xb3\xb5\xea\x2f\xa5\x71\x52\x75\x1a\xda\xb1\x4b\xdd\xb9\x7b\x0a\xdc\x85\x44\x88\x44\xe4\x5c\x22\xa8\x49\x29\xbe\xf2\x79\x00\xa6\x42\x3b\x5f\xbd\x6f\x19\x0d\x54\x0b\x3d\x10\xed\xa5\xc1\x43\x3f\xc0\x09\xcd\x71\x44\xff\x24\x3f\xd1\x34\xcb\x7f\x21\x79\x4e\xd2\x4e\x5b\xd1\xa3\xce\x87\x2e\x6a\x5b\x8c\x05\x7a\x8e\xfe\x5a\x9e\xf6\xd2\xd4\x37\x1e\x60\x16\x4f\x60\xb1\x0c\xcb\xf3\x49\x56\xc1\x12\x77\xaf\xb9\x98\x3b\x5d\x9b\x01\xea\x58\x2e\x27\x66\x19\xad\x0c\xac\xfc\x7f\xa2\x4e\x47\xe7\x63\x15\x6c\xd5\x97\x49\xc7\x7a\xa3\x38\xe2\xb5\x52\xb4\x56\x42\x68\x9c\xab\x75\xfb\x5c\xf9\x4d\xc9\x81\xbb\x49\x45\xe0\x9d\x49\x43\xeb\xf0\x54\x35\x0f\xcd\xa6\xf0\xca\xb9\xb2\x8d\x01\x76\x99\xaf\x0d\x80\x2d\xe5\x0c\xbf\x0a\xed\x57\xd3\x15\xb2\xb8\xe4\x55\xd5\x45\xab\x20\xe1\x92\x3e\x56\xd9\xd3\x22\xdb\x5e\x23\x97\x69\x0e\x54\xf1\xf9\x5f\x85\xa4\x6d\xc5\x65\x11\xef\x99\xdd\xca\x14\x57\x06\x1e\x77\xbb\x85\x71\x17\xa6\x09\x15\x5f\xf1\x70\x8a\xe7\xf5\x6e\xa1\x0b\xab\xb2\x3b\x9a\x15\x0b\xb3\x3b\x99\xc5\x75\xf1\x44\x50\x9b\x38\x9a\xc9\xa6\x58\x4b\x4b\x1c\xb6\xea\xbe\xdd\x16\x05\x46\x07\x82\x23\x8d\x3b\xe8\x08\xfd\xf5\xf9\x99\x7a\x1b\xcb\x85\xb0\x8d\x32\x6d\xe3\x3c\x91\xf3\xb7\xca\x4c\xce\xfb\xea\x48\xb8\xf4\xb7\x32\x13\x30\x21\x21\x21\x42\x2a\x64\xfb\x35\xf4\x95\x05\x5b\x5f\x59\x76\xd8\x6a\x07\x02\xe2\x9e\xf2\xfa\x11\xc1\xe7\xba\xfa\x3d\x29\x25\xb0\x8c\x5f\x39\xeb\xe8\x9a\x08\xe9\x11\x0a\x4d\x58\xc9\x80\x8f\xa4\x83\x86\x5a\xa5\x8a\xa4\x97\xab\x85\x06\x90\x8e\x70\xe8\x73\xa7\x2d\xfd\xd5\xb6\x92\xf2\xf4\xf1\x17\xcd\x43\x7f\x0d\x2e\x68\xd7\xef\x25\xb6\x55\xa7\xb7\x9b\xe7\x82\xb6\xf3\x32\xab\xf3\x32\x2b\x0f\x68\xf1\xf8\xeb\xf5\x94\xda\xdb\x43\x27\x0c\x5d\x10\x14\xb2\xb8\x95\xa3\x29\x3e\x27\x08\xc7\x97\x3a\x53\x03\x4a\x52\xca\x52\x0a\xf6\xa9\xd9\x9c\xf4\xb7\xe3\x9e\x53\xe1\x4f\x53\xf0\xda\xe1\x5f\x7b\x24\x0e\x1b\x05\x96\xaf\xf1\xc6\x79\x80\x5a\xc9\x02\xb5\xd0\x83\xb2\x8f\x7b\x68\x5f\x54\x28\xba\xe4\x0c\x84\x4b\x8e\xed\xe3\x81\x03\xfb\x72\x74\x62\xb1\x2f\x85\x6f\xc3\x11\xc1\x89\x2c\x38\x34\x96\x37\xde\xa3\x83\x4d\xfb\x6d\x94\x04\xa7\x2e\xb1\x0e\xb9\x13\x62\xd9\xdb\xe8\x9f\x21\x8c\x56\x3c\x33\x13\x19\x7d\xc2\xb7\x36\xb9\x06\xcb\x92\xad\x29\xf0\x57\x57\x61\x5b\xa1\xbf\xaa\x14\xd7\x57\x53\x59\x2f\x53\xcc\xaa\x70\x6b\xfd\x19\x4e\xda\xc6\xef\xc9\x44\xec\x15\xc7\xb8\x90\xd1\x7f\x49\xf8\x3b\xd5\xaa\x24\x50\x5e\xb3\x20\x68\xa5\x91\xb8\x04\x69\xb2\x35\x6f\xb5\x91\xef\xc4\x20\xae\x10\xf5\x4e\x01\x10\xff\xd6\xc5\x3e\x54\x9a\x3f\x19\xed\xcb\xd7\xfd\x49\x5c\xff\x32\x2a\xc0\x3b\x41\xf6\x6e\x83\x36\xca\x7e\xd7\x6e\xe6\x79\xa6\x42\x00\x99\x57\x9a\x8a\xd9\xb3\x9d\xc7\xda\xe3\xdd\x63\x6d\xf7\x58\xdb\x3d\xd6\xb6\x1a\x12\xe4\x9d\xce\x60\x55\x85\x13\x83\x92\xba\x75\x9d\x98\x5a\x5f\xef\xb3\x6f\x1b\x8f\xb8\x82\x67\xbb\x4e\x92\x57\x1a\x0f\xe1\x61\xfd\x2b\xcc\x54\x10\xff\xdb\x1f\x34\xa8\xbb\xe4\xc5\xb6\x7b\x41\x7d\x25\x2f\xa8\x5a\xd7\x0a\xfd\x64\xba\x00\x91\xc7\x88\xa0\x8b\x14\x27\x89\xc8\x0e\x89\x91\x49\x99\xe7\x6f\x29\xfa\x09\x1c\xa8\xb3\x1c\xc7\x01\xe1\xb0\x70\x8e\x02\x1c\x73\x08\x73\xbd\x2c\xbc\x40\x64\x1d\x40\x38\x46\xd3\x03\x68\x40\x70\xc8\xd1\x04\xeb\x89\x84\x34\xc3\xa3\x88\x18\x52\x54\xeb\xd3\x51\xfa\x20\x84\x00\x7e\x5f\xe0\x39\x58\x18\xba\xae\x5a\xf8\x72\x1d\x26\xe0\x85\x4e\x6f\xc3\xb3\xb2\xb8\x86\xdf\x9b\xad\x3b\x6a\xf6\x06\xb4\x6f\x3b\xdf\x9a\xf5\x2f\x20\x38\x47\xa8\x95\x43\x10\x49\xf3\x04\x74\x4c\x2f\xfd\x67\x17\x60\xd4\xee\xd1\x75\xa7\x1f\x5d\x8d\x00\x16\xcf\xd4\x32\x75\x6d\x51\x47\x29\x90\xa9\x44\x51\x59\x42\xfa\x40\x89\xb7\x41\x35\xdd\x3b\x89\xf5\xea\x15\x28\x62\x9d\x6e\xe7\x0d\xf8\x64\xf7\x06\xdc\xbd\x01\x77\x6f\xc0\x6d\xbd\x01\x77\xcf\xb3\x95\x9e\x67\xd0\x50\x3c\x8d\x20\x8b\x55\xd9\x53\xe9\xd9\x92\x8c\xfc\xe2\xe9\x34\xf4\xe3\xcf\x15\x43\xc9\xf9\xcf\x3c\xa9\xf2\x52\xfd\x9b\xe7\xdd\x92\x12\x3b\x53\xf1\x98\xa6\x59\xde\x03\x76\xc0\x09\x37\x27\x3b\x79\xc7\x92\x23\xd5\x58\x39\x00\xed\xde\x76\x5f\xd5\xdb\xae\xf4\x31\x24\x55\xc4\x85\xe7\xd0\x92\xd7\x4e\xa3\xd7\xd2\x96\xb4\x63\xd6\x7b\xc6\x7f\xe6\xdc\x16\xed\x98\xf5\x9a\xb0\xdf\x11\x72\x33\x76\x2f\x89\x3b\xfd\x92\xd8\xbc\xfa\x46\xe5\x08\x30\x8c\xbb\x0a\xea\xbf\x1d\xd6\xfd\xe9\x8e\x75\xbf\xcb\x11\xd9\xb7\xfa\x8e\xd8\xb1\xee\x3b\xd6\x7d\xeb\x9a\x95\xaa\x5b\xfc\x73\x57\xb2\xf6\x46\x56\xdd\xcf\xe6\xa3\x29\xc1\x9c\x47\x36\x16\x1c\x01\x8b\x58\xaa\xd4\x2f\x09\x8e\x48\x9e\x93\x7e\x4e\x16\x79\x5f\x44\x13\xc5\xe9\xa5\x6f\x2c\x37\x30\x16\x19\x3b\x76\xfa\x6b\x67\xa7\xdf\x91\x45\x91\xa5\xfe\xba\x0c\xce\x92\x1b\xc4\x50\xf3\xed\xd8\x31\xd5\x3b\xa6\x7a\x1d\xa6\x1a\x52\x54\x15\x18\x6b\xc8\x29\xb5\x15\xe6\xfa\xc9\xe0\x56\x33\xd7\xd7\xc2\x41\x6e\x81\x6d\xbc\x48\x71\xf2\x52\x18\xd3\x4b\x1a\x5b\xca\xf2\x1f\x54\x35\xa8\xe5\xee\xdc\xaa\x0e\x6f\xa8\x82\xb2\x95\x4e\xe6\xc9\x41\xb1\xee\x32\x36\x52\x04\x93\xb9\x61\x5c\xe4\xcf\x74\x32\x25\xe9\x9b\x34\x24\xa9\x49\xee\x54\x95\x84\xe8\x51\x63\xbe\xb2\x14\xec\x06\xf3\xba\xfc\xa0\x73\x5a\x54\x21\xf2\x7e\xe3\xb1\x5a\xb0\x36\x38\xc2\x57\x31\x3f\xaf\x24\x2c\x65\x20\x5f\x8d\x11\xcd\x00\x1f\x5e\xb2\x8b\xb8\xcd\x12\x61\x1c\x6c\x32\x75\x74\xba\x6a\xfb\xf9\xf9\x75\x03\x8b\x37\xc8\x57\x60\xdd\x75\x25\xe1\x22\x45\x4a\x80\x94\x64\x09\x8b\x33\x7a\x4e\xa2\x4b\x95\x1e\x41\xc6\x71\x47\xdf\xe1\x1c\xb1\x14\x8d\x48\xc4\x2e\xbe\x03\x26\x6f\x42\xcf\x49\x8c\xcc\x00\x39\xb4\xb6\x44\x3d\x88\x3c\xda\xca\x66\x2d\x08\xd1\x3f\x83\x0c\x78\x28\x24\xe7\x34\x20\x59\xa7\xcf\x6b\xfe\x8b\xe5\x34\x20\xc2\xbc\x04\x42\xc4\x0b\xfc\xe8\x41\x2e\x0f\x64\x30\x04\xa2\x18\x73\xf6\x11\xe7\x74\x14\x11\x11\xac\x32\x23\xe9\x39\x49\x51\x46\x43\x22\xcd\x50\x44\x38\x5d\x99\x9f\xb6\x24\x4f\xa0\x3e\x60\xfe\xb7\xb6\x61\xfa\xe4\x9a\xa3\xe7\x08\xa7\x93\xf9\x0c\xb8\xd5\x88\xc4\x93\x7c\x8a\xfe\x81\x06\xfc\xc4\xe9\xf2\xf7\x83\x0f\xc0\x82\x68\x69\x04\xfa\xde\xfd\xc8\x8f\xa1\x59\x1a\xe1\xe3\xc9\xdf\x1a\x9a\x2d\x33\xc6\xf4\x26\xb9\xb3\x7c\xd2\x00\x4a\xd9\xd8\x5c\x44\x06\xc1\xe1\x21\x03\xe5\x77\x7f\x5a\x16\x43\x8b\x9a\x26\x1f\xd7\x23\xe9\x56\x73\x82\x36\xba\xe9\x9b\x1a\xf0\xb6\x6f\xe1\x6f\xa7\x6d\xc6\xda\x95\x1c\x30\x04\xc4\x07\x66\x50\x8c\x4d\x67\xc1\x86\x7f\xfc\x09\xac\xc5\x02\x7a\xb9\x6a\x6a\xf9\x10\xfb\x40\xc0\x38\x24\x43\x82\x64\x0a\xf8\xca\x3e\x5b\xa6\xcf\x96\x59\xe0\xc2\xf8\x43\xe7\x82\x12\x4b\xe5\x5d\x43\x56\x2a\x5f\xb3\xf2\xc5\xbc\x94\xee\x42\xc9\x9d\x74\xd7\xde\x02\xd5\x69\xfb\x43\x81\xf6\xf2\x9d\x5b\x64\xb7\xfc\xee\xb6\xc3\x28\x0d\x6f\x66\x6e\xe1\x73\x1a\x56\x67\xa2\x7b\xb2\xff\xc5\x93\x0b\xc3\xf8\x6e\x40\xd2\xd0\x27\xfb\xb7\x9a\xd1\xdd\x25\x0d\xdd\x19\x80\xec\xa4\xc8\x9b\x36\x85\x57\x69\xda\x86\x05\xf1\x2a\xe4\xdf\x7b\x4b\x32\x92\xa3\x51\xca\x2e\x32\x92\xaa\x31\x89\x1e\x54\xce\x3d\x91\xb9\x4d\x65\xd7\xb3\xcd\xda\x4f\xa6\x29\x8d\xcf\xb4\xa4\x56\x1a\x94\xaa\x79\xa9\x11\x8c\x70\x70\x36\x49\xd9\x3c\x0e\x8f\x2b\x85\xc0\xa1\x20\xa2\x36\x1c\x1a\x67\xa4\x60\xd2\xff\x0b\x19\xe7\x47\xe8\xf1\xbe\x5d\x31\x12\x13\x5c\xa5\x3b\x68\xf2\xb2\xd8\x27\x1e\x65\x2c\x9a\xe7\xc4\x40\xb3\x52\x1d\xaa\x8f\x56\x4a\xbb\x3c\x67\x33\xcb\xcb\x20\x82\xd1\x95\xa7\xd3\xdb\x90\x69\x88\x19\x61\xe3\xc0\xfb\xb7\x43\xf8\x5b\x6b\x27\x2f\xd1\x43\xa7\x84\xa3\x71\x48\x62\x27\xd7\x84\xc4\x96\xc6\x8b\x52\xd7\x81\x88\x3c\x20\xf0\x8a\xa4\x42\x75\x61\x7a\x92\xe8\xb6\x8a\x8d\x3c\xc0\x6e\x12\x9c\x5f\xed\xae\x16\x48\xab\x82\x55\x25\xda\xbf\xda\x81\xd0\x0b\x52\x6d\x58\x2c\x13\x38\x9f\xff\xd2\x28\x0c\x29\xbd\xd4\x27\xf8\x75\x55\x59\xb8\x39\x37\xd5\xa6\xf3\x30\x06\xfe\x07\xf4\xa8\xa5\xe3\xda\x70\xc6\x66\xd0\x1b\x88\xb5\x37\x13\xa0\x58\x2f\xbe\xde\x97\xf5\x82\x13\x8b\x05\x16\xab\xbe\x1a\x04\xb1\x1b\xdf\x6b\x48\xe2\xb7\x71\xab\x56\xb6\xf6\xc0\x44\x79\xf1\x8e\xbb\x2e\x36\x74\x9e\x35\x56\x37\xb4\xa6\x69\xab\xe6\x71\xe9\xbb\x77\xc3\xde\x68\xed\x81\x52\x16\x00\xce\x7f\x19\x15\x41\x23\x1a\x79\x1b\x44\xf0\xcd\x62\xcf\xca\xa3\xb3\x81\x20\x66\xe2\xf0\xad\x66\x60\x2f\xf6\xb9\xc4\xb8\xde\xec\x82\x89\xf2\x25\x88\xb4\xfe\x2d\x49\xe9\x26\x6d\xee\x61\x38\x52\xbb\x20\xde\x65\xdb\x79\x2a\x3f\xdc\x3d\xb5\x76\x4f\xad\x1b\xfa\xd4\xb2\x89\x6e\xf9\x51\x2e\xd4\xac\x03\xae\x2b\xed\xde\x72\x77\xc1\x22\xa8\x21\x3c\xc9\x0c\x88\x98\x94\x57\x1c\x9b\x0d\x6b\xab\xfe\x06\x90\x47\x11\x9e\x7d\xda\xe5\x40\xbd\xfb\x92\x94\xce\x70\x7a\xf9\xde\x7b\x0d\xea\x90\x9b\xe2\xee\x43\xdf\xa3\xd6\x8b\xc7\x83\x41\x0b\x1d\xa1\xd6\x8b\xfd\xc1\xa0\xf5\x61\x99\x8f\x02\x8b\xf3\x9f\xf0\x8c\x46\x97\x47\x45\x4b\x28\xf3\xb1\x5b\x67\x07\x45\xe3\x64\x9e\xf7\x23\xbe\x98\xef\xc8\x42\x33\xdc\xbc\xf5\x09\xfd\x93\x94\x00\x4e\x16\xef\xd8\x5b\x32\x6b\x0f\x1f\x75\x0c\xe7\x1e\x93\x9f\xfd\xc7\xbe\x76\x88\x70\x9e\xe8\xb0\x4c\xc4\x4a\x3d\x2f\x47\x65\x96\xcf\xae\x4d\xd2\x94\x7f\xac\xb5\xe4\x82\x3a\xfd\x17\x07\x03\x57\x14\x20\xfc\xeb\x8a\x1d\x95\x4d\x5f\x55\xde\xf9\x50\x7c\x55\x46\x5f\xc5\x1c\xe4\x26\x43\x22\x47\x52\x9d\x89\x9c\x1f\x3b\x14\xb3\x50\x6a\x55\xd1\x8f\x14\xde\xa3\x18\x09\x38\x7c\x2e\x9c\xab\xc2\xe8\xe5\x9b\xd7\x88\x08\x8a\x83\x18\xaf\x50\xb6\xdd\xaa\x68\xd5\xfd\x76\xc8\xe2\x9a\xdb\x6e\xc3\xd8\xcc\xee\x5b\x10\x8b\x69\xb0\x6d\x39\x07\xd0\x18\x94\x4d\xd9\x3c\x0a\xd1\x88\xa8\x68\x87\x24\x44\x34\x46\x58\x1f\x58\x94\xe5\x38\xb7\xd4\xd7\xe6\x20\xaf\x2b\x60\xa9\xef\x38\x16\x44\xc6\xef\x56\x52\x9e\x75\xfb\x04\xba\x22\xce\x3c\xcd\xe4\x08\x68\xa6\xa8\x1f\x6a\xc3\x7f\x47\x97\xe8\xf4\x27\x96\xce\xfe\x99\xb2\x79\x72\x6a\x1d\x87\x8e\xa5\xbd\x57\xf4\xf2\x6a\xb3\x07\xe1\x12\x8d\x43\x1a\xe0\x5c\x2b\xd5\xd5\x30\x21\x45\xb0\x78\xc3\x9a\x8e\x55\xc9\x2a\xe2\x26\x3e\x99\x5f\x78\x7f\x4a\x02\x03\xc4\x6f\x91\x5f\x53\x5a\xc8\x7a\xc9\x93\x6d\xab\x22\xab\x68\xa5\xaa\xac\xa2\x70\xcd\x01\xa4\x0a\x55\x25\xc0\x0c\xa7\x06\x94\x98\x9b\x13\x36\xcc\xa9\x20\xcb\xba\x5a\xd7\x2e\x96\xd6\xa9\x93\x5a\x52\x84\xab\x88\xbc\x9a\x44\x8b\xd0\x13\xb7\x42\x47\x40\xae\x3d\x98\x09\xa4\xfd\x13\x23\xe6\x7f\xaa\x81\x81\x64\x4c\xec\xd8\x6c\x4e\xf9\x56\x1f\xb3\x38\x4f\x59\x84\x9e\xab\x7d\xee\xbb\x1f\x8c\x20\x4d\xc1\x40\xcf\x9d\xc9\x3f\xb3\x79\x27\xf8\x6a\xad\x9e\xfa\xa8\x09\xc3\x73\x67\x7f\xd4\x67\x71\x7a\x9f\x9b\x6d\x01\xbc\xa2\x63\xd4\x76\x07\xa3\x54\xaa\xfc\x8b\xa4\xbb\x66\x54\x9c\x9a\xea\x77\x68\xcb\xb6\x8a\xd0\xe3\x76\xa1\xe9\xed\x7a\xa6\x79\x06\x07\xb4\x9e\x51\x15\x64\x33\x65\x0f\xb0\xfc\x50\x01\xd7\x2c\x46\x15\x60\x6b\xb9\x3c\xc8\xea\x4b\x05\x68\xb9\x90\x55\x70\xd5\x3a\x7b\x40\xa1\xd8\x40\xfc\xfc\xe5\x45\xa7\xea\xb0\xa9\x25\x5e\x4f\x70\xaa\x4f\xbd\x5e\xd0\xf5\xe0\x08\xda\x20\x56\xaf\x89\x94\x14\x44\xf1\x59\x4e\x52\x9a\x9d\x1d\x37\x5a\xc3\xfa\x41\xf1\x45\x2c\x1d\xcb\x0a\x42\xd9\x7b\x0e\xf9\x6c\x6e\x09\x5e\x22\xa2\x75\x0d\xbc\xbb\xf7\x9c\x43\xd6\x34\xee\x67\x2b\x4b\x70\xdc\x32\x51\x5e\xac\x2e\x8b\x4b\xa7\x83\xbe\xb4\xfe\xdf\x7c\x7f\x30\x78\xfa\x9d\x50\x87\x99\xa8\x2f\xfa\xd2\xfa\x42\x46\xe5\x37\x84\x1d\x5c\x2b\xcd\x5e\x45\xfb\xc6\x49\xf6\xb6\xcb\x8e\xee\xcc\xf7\x6f\xb0\xee\xc0\xe6\x41\xee\xda\x3b\x68\xc5\x08\x43\xe1\x66\x54\x28\x8a\x79\xdb\x00\x28\xc3\xfe\x6d\x00\x98\x66\x20\x57\xd1\xee\x18\xaa\x5c\xa2\xdf\xb1\x68\x66\x0b\xde\x37\x2d\x78\x88\x98\x36\x92\x1f\x55\xc4\x9c\xb7\x71\xf9\x96\x23\x5b\x00\xad\x6f\x1b\x71\x24\x36\xa2\x0e\xd2\x63\x01\x85\x90\xfe\xb5\x25\x95\xd0\xc1\xcd\xb2\x9e\xfc\xc2\x3a\x9e\x1b\xa5\x71\x99\x10\x5e\x9c\x33\x4e\x24\xde\x8c\x2b\x86\xf0\xa4\xa2\x7a\x9d\x52\xc1\xad\xe9\x6a\x3d\x8e\x71\x14\x1d\x4f\x49\x70\x56\x35\xe7\xa7\x15\xf5\xeb\xa6\xea\x41\x36\x10\x80\x47\x03\x8e\xab\xaa\xbb\xe1\xa0\xac\x76\x6d\x67\x16\x50\xa3\x33\x62\x59\x46\x47\x11\x39\x66\x71\x96\xa7\xf3\x20\x67\xe9\x5b\x60\x60\x2b\xfb\x1d\x2e\x6f\x5b\x37\x8a\xea\x0e\x35\x5c\x1a\x4f\x49\x4a\xf3\xea\xa9\x17\xab\xd6\xf5\xa8\xc1\x6d\xd7\x43\xea\x3a\xd4\x68\x21\x19\xb1\x79\x1c\x54\xe9\x70\x0e\xf7\x0b\x35\xeb\x3a\x50\x75\xdc\x19\xff\x78\x4e\xe2\xfc\x17\x9a\xe5\x24\xae\xb4\xd3\x3e\x78\x58\xd3\x66\xe9\x92\x39\xb5\xef\x94\x8a\x30\x65\x17\x99\xd0\xda\xa0\xe7\x68\xff\x60\xa9\x02\x0c\xac\x3d\x2d\x05\x94\x65\x9f\x98\x92\x08\xe7\xf4\x9c\x33\x87\x7b\x7b\x68\x44\x02\xcc\xaf\x14\x10\xfa\x4f\x71\xc8\x2e\xd0\x14\x67\x35\xf6\x8c\xbe\xb5\x22\xbc\xd9\xf8\x05\x8e\x53\x82\x55\x77\x4e\x25\xd1\x4e\x19\x98\xda\x65\x29\xc9\x40\x6f\x65\x9b\x8c\x8e\x19\xb0\x0a\xf2\x6c\xc9\x42\xa3\x9f\x92\x8f\xd2\x79\x9a\xb1\xb4\x50\x6d\xc4\x16\x27\xf4\x4f\x11\xd9\x4b\x98\xa3\xf6\x46\x4c\x05\xeb\xb2\x15\x5f\x85\x76\x45\xd3\x55\x36\xcf\x79\x0b\xb7\xd0\x18\x8d\x1e\xc9\x5c\x7e\x09\x4e\x39\x5f\xac\x16\x42\x2c\xe1\x91\x76\x09\x28\xce\x6f\x6f\x0f\xbd\x91\x71\xc9\x10\x8e\x32\x86\x62\x42\x42\xa1\x63\x99\x92\x94\xf0\x7f\x53\x32\x63\xe7\x62\x4b\xc8\x22\x4f\x31\xdf\x7d\xd5\x16\x87\xb2\xb2\x5a\xf2\x0c\xd1\x18\xfd\x44\x53\x32\x66\x0b\x61\x8a\xab\xc2\x9e\x1d\xa1\xd6\x94\x86\x21\x89\x4d\xcf\xff\xa6\x19\x1d\xd1\x88\xe6\x97\x76\xb7\x34\xb4\x3b\xe3\x80\x11\x87\x8c\x58\x8c\x68\x82\xc3\x4c\x38\x32\xe9\xa6\x3e\xdc\x6a\x5c\xd1\x7b\x6e\x45\x5f\xbb\x98\xd2\x9c\x9c\x24\x38\xe0\xeb\x92\xa4\xa4\x77\x91\xe2\xa4\x25\x9c\x21\x36\xa0\xc6\xbb\x8d\xda\x2c\x1f\x8a\xa4\x01\xff\x16\x9c\x5a\xd5\x70\x62\xf2\x66\xcc\x57\xa4\xfd\xbe\xbe\xab\x2a\x00\xf1\x7c\x36\x22\xe9\x87\xce\x92\xb1\xac\xae\xd2\xf1\x41\xb0\xf8\x78\x8a\xe3\x49\xf5\x54\x38\x05\x75\x41\xfc\x0b\xc6\x86\xd8\x18\x08\x1f\xdf\x31\xa9\x08\x42\x17\x53\x12\xa3\xd9\x3c\xca\x29\x3f\x9d\xd2\x9b\x0e\xd1\x0c\x65\x24\x87\x63\xe1\xf8\x53\xf2\xd6\xd7\xbd\x82\xaf\xf1\x82\xce\xe6\x33\x14\x6f\x70\x0e\xaf\xf1\xe2\xba\xa7\xf1\x5b\x26\x75\x4f\x89\x7c\x54\xf0\x91\x25\x38\xcb\x10\x46\x29\x19\xa3\x40\x65\x7c\xe5\x03\x9e\x12\x14\xc3\xa5\xa2\xc9\x92\x52\xad\x9a\x79\xa8\x2f\x6f\xc9\x78\x05\x4c\xf0\x91\xe9\xfc\x7a\x0e\x05\xd0\x22\xe9\x55\x2b\x87\x80\x7a\x08\x2e\xf8\x18\x47\x8e\xaa\x58\xfa\xa9\xbe\x53\x13\xb7\xac\x4f\xda\x1f\x81\x76\x7d\xeb\x79\x85\xc2\xeb\x54\x33\x98\xe6\x6d\xaa\x40\x74\x51\xa1\x1d\x08\x80\x35\x5c\x55\xb1\x6d\x7b\x99\x4a\x7b\x31\xfd\x33\x27\xb3\xa4\x8b\x3e\xe6\x53\x9a\xc1\x73\x3d\x97\x1f\x8d\x74\xda\xbc\x24\xcc\x18\x44\x75\xd5\x41\x47\xb6\x19\xb3\x14\xb5\x01\x6a\x04\xba\x3f\xdf\xa7\xb6\xcb\x4b\x38\x2d\x7e\x91\xa6\xf8\xb2\xcd\x6b\x75\xba\xe8\xe3\x19\xb9\x44\xcf\xd1\xe0\x99\xf8\xeb\xef\xd0\x5a\xfc\x78\xf0\xc0\x68\x2b\x78\xd3\xf7\xbc\xf0\x83\x0d\x59\x94\x94\x79\x4b\xf2\xb9\xf0\x37\x3e\xcc\x50\xfc\x31\xa5\x99\x7a\xf5\x57\xbf\x1d\xfc\x49\x2a\x71\xb0\x9a\x6c\xff\x23\xbf\x5b\x72\xf6\xf1\x23\xfa\xf4\x49\x00\xf3\x5e\x78\xc5\xad\xea\x74\x40\x0c\xd0\xe7\x77\xcb\xa5\x14\xa2\xbc\xe7\xe0\x3f\xf4\x03\x16\x07\x38\x6f\xf3\xd9\x75\x20\x29\x2e\x2f\x56\xff\xf6\x41\x85\x2d\x2f\x2f\xfb\xaa\x8c\xe7\x51\x24\x6d\x63\x64\xcd\x29\x8e\xc3\x88\xbc\x05\x56\x42\x4d\x52\x33\xe1\x66\x44\x06\xe9\xc8\xb9\xe5\x7f\x8c\x54\x7f\x97\x71\x20\xb8\x1f\xfe\xfe\x3d\x01\x36\x45\xd6\x7c\xa6\xfa\x1b\x3e\x7a\xd4\xf1\x7b\x1d\xbf\x02\xb5\xb3\x8d\xd4\x31\x0b\x89\x0f\x9e\xca\x5a\xfc\xdb\x33\xe5\x3e\x30\x96\x5b\x23\xf3\x6a\x59\x04\xa0\x63\xc5\x49\xad\xa8\x22\xba\x51\xb0\x3e\x97\xaf\xc9\xf8\x84\xc6\x93\x88\x70\x32\x2a\xa6\xb4\x74\xa0\x59\xb1\x81\x19\x73\x09\xfc\x86\x50\x97\xc2\x12\x57\xa0\x03\xa8\x74\x9f\x80\xbe\x71\x8e\x9e\x7f\xec\xe7\x38\x9d\x90\x5c\x14\xca\xa3\xe8\xe8\x01\xed\xb5\x93\x2d\x5d\x9d\x20\xe8\x69\xac\x21\xda\x0b\xbf\xb7\xe7\xd9\xd1\xd0\x0c\xc5\x2c\x07\x05\x71\xca\x22\x50\xa8\x5d\x10\x60\x14\xc1\x6a\x26\x09\x85\x3d\x02\x3c\x14\x22\xce\xbf\x42\x97\x7d\x6f\x27\x45\x47\x7a\x22\xd6\xb4\x9e\xf9\x35\x97\xe1\xa4\x3e\xf9\x45\x64\x52\x4c\x45\x15\x26\xa9\xef\x05\x78\x7a\x6f\xc8\x2c\x51\x52\xd1\x26\x34\xc3\x22\xa4\xc2\x07\xfb\x9e\xa2\xe4\xb6\x94\xa4\x8c\x98\xbf\x17\x23\x3c\x23\x9c\x73\xd6\xab\xfd\x3b\x8d\xa2\xd7\x6c\x1e\xab\x37\x88\xbc\xd8\x34\x7a\x14\x2b\xb6\xcd\x5c\xf7\xf6\xd0\xdf\xe1\x60\xfe\x83\x3f\xfd\x48\x90\x67\xae\xc1\x5a\x86\x68\x2e\x83\x29\x64\xe2\x45\x91\x25\x2c\x86\x6d\x6c\x41\x47\x2d\x03\x28\x63\xe2\x9e\xa7\x22\x35\x48\xc0\x2f\x04\xce\xa2\x80\x4d\x43\x3e\x25\x97\xfc\x31\x80\x42\x9a\xe6\x97\xb2\x91\x83\xa8\x05\x0c\xfc\xf4\xc9\x2e\xb3\x79\x59\xfe\xa9\xd5\x7a\x66\x43\xc9\x48\x7e\xc2\x29\x61\xdb\xec\xa2\xa2\x84\x82\x07\x6c\x5b\xb0\x38\x27\xd4\x41\xdf\x59\x8f\x61\xb5\xab\x1d\x4b\xab\xad\x82\xc9\x79\xeb\xfd\x92\x86\x8d\x96\x5b\xd5\xb3\x56\xbb\x1a\x59\x39\xb5\x6e\xd0\x37\xdf\xc2\xb7\x24\x20\xf4\x1c\x44\xb4\x59\x93\x2d\xb7\xeb\xb7\x63\xb2\x10\x42\x75\x33\x28\x7e\x20\x74\xb1\x5c\xfa\x6f\x9e\x97\xef\x87\x5c\x4a\x53\x5d\xf2\x94\x1d\x68\x51\xbe\xd0\xfc\xb3\x7d\xb8\xea\x17\xa1\x8b\xcc\x10\xbd\xb3\xb6\x64\x5d\x7e\x8b\x67\x4d\x4f\x81\xac\xea\xef\x8c\x7d\x41\xf6\x03\x1c\x07\x24\x6a\x57\x6f\x4a\xd9\x14\x2a\x3a\xaf\xa1\x4f\x7a\x04\x9c\x29\x4a\xe4\x43\xb4\x24\xd2\xc8\xd0\x8d\x34\x32\xac\x8b\x34\x32\xfc\x80\x8e\xac\xed\x73\xe9\xbd\x75\xcb\xdc\xbf\x8f\x4a\xaf\xb2\x65\xb4\x7d\x6d\xba\x6e\x5d\x38\x05\xec\xfa\xa6\xca\x06\xc5\xe0\x8c\x7b\x1f\xb8\x97\x15\xf0\x3b\xe8\x7b\xd4\x6a\xa1\x23\x74\x02\xbc\x79\xdb\xaa\xd1\x31\x57\x86\xbe\x09\xc4\x9a\x1b\x69\x8e\xa2\x41\xfe\x72\xf4\xb3\x80\xcf\x56\x54\x7a\xe6\x34\x8e\xc9\x85\xd7\xb6\xac\x85\xbd\x98\xff\x9c\xe3\x34\xa4\xf1\x04\x38\xe1\x3f\xb2\x90\xcd\xba\x9c\x46\xa6\x04\xd9\x6d\x10\xcd\xe2\x16\x7f\x31\x91\x4c\x3d\x7d\x14\x80\x13\x42\xd0\x34\xcf\x93\xec\x68\x6f\x6f\x42\xf3\xe9\x7c\xd4\x0f\xd8\x6c\x2f\x9f\x25\xe7\x38\xdd\x03\x88\x7b\x90\xaf\x3a\xdb\x1b\x0e\x86\x0f\x9d\xb5\xb7\x86\x6b\x23\x8f\xbb\xd6\x82\x39\x2e\x5d\x2f\x0e\x43\x1e\x72\xf7\x7c\xa3\x7f\xe8\xd3\x6f\x51\x58\x17\xae\xbd\x56\xaf\x71\x3e\xed\xcf\x68\x5c\x01\xed\x3b\x6b\x57\xba\xa6\x61\xf9\x26\x16\xe1\xe2\x85\x99\x69\xd7\x02\xd5\x79\xe6\x4e\xc5\xf0\xcf\x7d\x71\x57\x00\x12\x9a\xee\x4a\x50\xb0\x78\xcb\x20\x9b\xe7\x56\x4d\xad\xaf\x9f\x9d\x51\xdb\xff\x96\xd0\x14\x71\xd3\x56\x50\x11\xf1\xb1\xed\x92\x8c\x8f\x8a\x66\x98\x03\xd5\xb5\x7a\x37\x56\x94\x1f\x4b\xcd\x28\x91\x17\x96\xf2\x63\x85\x1d\x25\x42\xae\x34\xc9\x54\xb5\x4b\xed\xda\x8a\x6f\x32\x35\x55\x89\x5d\x0b\x24\x1a\xba\x06\xff\xe5\x7f\x7d\x8d\x17\x6e\x85\xd7\x78\x61\xd7\xb1\x38\x7d\x53\xcf\x2a\xb4\xeb\x9e\xbb\x43\x3f\x2f\x8c\x79\x35\xf3\xcb\x8f\xa5\x11\xed\x9d\x0c\x5d\xd6\xe2\xf0\xdf\x6a\x09\xc0\xc4\x92\x5d\x64\xea\xdf\xd7\x78\xc1\xff\xb4\x86\xcd\x7f\x0a\x06\x4b\xf9\x26\xa3\xa6\x01\x9b\xf4\x84\x9a\x24\x4a\x16\x46\x78\x20\xd7\x3c\x42\x7f\x69\x4c\x2e\x1e\x8d\xcf\xb5\xc9\x94\x9d\x01\x94\x69\x5c\x8c\xeb\xf0\x5f\x48\x3c\x46\x8e\x50\xeb\x82\xc6\x70\x69\x22\x16\xbf\x95\x12\xee\xe2\x4b\xf5\x73\xa7\x69\xbf\x7a\xfd\x5a\x5d\x8f\xa2\x8d\x3d\xc0\x85\xe7\x5e\xe9\x79\x68\x12\xd6\x54\x10\x7c\x63\x6e\xa7\x86\xd0\x71\x70\x14\x8f\x5e\xc5\x21\x59\x1c\xa1\xde\xd0\xc7\xef\x23\xd4\x1a\xb6\x9c\x42\x82\xc3\x37\x31\xb8\xf7\xa4\x2e\x7a\xb6\x70\x4a\x71\x4f\x8a\xcc\x41\x6f\x30\x27\xad\x02\x7e\x1f\xa1\x56\xcb\x50\x9c\xad\x2c\xde\x17\x5f\x32\x9f\x50\x2c\x5d\x99\xea\x45\x75\x65\xe4\x55\xd4\x4c\xae\x2c\xfc\x73\xc5\xc5\xad\x32\xa2\x5c\x3a\xc9\x95\x16\x39\xd7\xaf\x46\x13\x72\xf7\x6a\xd3\x2e\x23\xee\x0e\x66\x88\x22\xb3\x3a\xd2\xfc\x73\x29\x3a\xc1\xfb\xd3\x5a\x54\x3f\x45\x3a\xbf\x26\x85\x19\xba\x24\x7f\xea\x45\xfc\xec\xde\xe7\x76\x21\x4b\xbd\x2d\xe9\xd4\x02\xb9\x12\x73\x22\xb1\xc6\xc3\x7b\x1b\x88\x36\xab\xba\x01\xab\x1f\x5b\xe2\xe9\x19\xec\x1c\xee\x7c\xb8\x77\x3e\xdc\x57\xf1\xe1\xde\xfb\x0e\x91\x2c\xa2\x71\xde\x93\xda\x34\xf4\x47\xb6\xe8\xe1\xe1\xf0\x72\x0f\x2c\xe2\x7a\x53\x9c\xf5\xf8\xc3\xe2\xbb\xbd\x9d\xbf\xf7\x2e\x81\xf7\xb5\x3a\x95\xcb\xab\x6e\x53\xbe\xdb\x9b\x74\x2d\xbf\x9d\x19\x30\x2c\xdf\x9e\x24\xc2\x97\x60\x6b\xc2\x19\xd6\xde\x38\x22\x26\x6f\x1c\x8e\xe8\x24\x7e\x95\x93\x19\x67\x24\x03\xc2\xd1\x40\x7f\xd3\xc6\x2d\x10\x71\xd5\xfa\x00\x71\xd8\xc0\x34\x64\x92\x92\x4b\x34\xa5\x93\x69\x64\x3d\x5b\x7f\x27\xa3\x33\x9a\xbf\xc3\xc9\xcf\xea\x43\x69\x64\xb3\x80\xcd\x66\x2c\xee\x5b\xd6\x2b\x6e\xc8\x37\x11\x3b\xad\x37\x3c\x70\x8b\xdf\xaa\x17\x46\x49\x82\xbe\x7d\x3e\x34\xed\x85\x9b\xb2\x0b\x25\x02\xc1\xb0\x6e\x6c\x8c\x52\x1c\x52\xb6\x07\xb2\xe5\x11\x5b\x48\x21\xfc\x3d\xd4\xdc\xf9\x5b\x86\x7f\x73\xdd\xfb\xf4\x4a\xa9\xb8\x9d\x36\x60\x20\xad\x06\xea\x3c\x23\xe9\x09\x89\x48\x90\x2b\x7b\x1c\xc3\xa6\x6c\xc6\x83\xdc\x4f\xda\xad\x65\x6f\x38\x49\x08\x4e\x33\x94\x41\xf7\xb6\xe3\x26\x2c\x48\x8d\x71\xc5\x72\x7d\x36\x98\x5f\xd4\x1b\x9b\x94\x68\xf6\x6f\x9d\x89\xcc\x0b\x25\xbd\xd4\x76\x05\x5e\x6a\x73\xaa\x13\x9b\x8f\x08\xc2\xe8\xf4\x2d\x47\xb8\xd3\x2e\xff\xf3\xe4\x82\xe6\xc1\xf4\x54\x38\x79\x9f\x1e\x4b\x1c\x3c\xb5\xbd\xbc\xa5\x9d\xf9\x5a\xbe\x0d\x57\xf5\x6b\xb8\x8a\x33\xcf\x55\x1c\x79\x36\xeb\x4b\xe1\x3a\xf0\xd4\x1e\x0b\xb1\x8f\x2a\x46\x9f\x3a\xd3\x57\xf2\x22\x5f\xd3\x58\x45\x68\xad\x4b\xfc\xfe\xe1\xc3\x6a\x86\x2a\xef\xa6\xc2\xf8\x85\x77\x21\xd2\xeb\x6b\x9f\xf5\x38\x88\x58\x46\xe3\x89\xf4\xef\x2e\x58\xc6\x48\x4a\x75\xcd\x9e\x4e\x6b\xe1\x9d\xdf\xb0\x31\xd2\x6d\xda\xb7\xaa\x88\x6e\xe5\xe4\x26\x5e\x95\xd2\x1c\x2b\x54\x19\xc3\x04\xc1\x56\x4b\x10\x48\x9c\x13\x50\xa3\xc0\x7b\x59\xe2\xab\xec\x34\xc1\x29\x9e\xa1\xbf\x04\xfd\xfb\x2c\x94\xf7\x80\x11\xe2\xaf\x8c\xcd\xd3\x80\xe8\xb0\x22\xb2\x07\xb7\x2d\x47\x6a\x82\xe3\xcf\xea\x4e\x80\xe6\xa7\xf2\xc7\xa9\x94\x81\x4a\x08\x19\x50\xb4\x7b\x57\x30\xb0\xe3\xc0\x1d\x90\x25\x87\xa0\xde\xd4\xca\xce\xc5\xa4\xd2\x0f\xa4\x2c\xe1\x38\x9f\x92\x24\xc2\x81\x8c\xac\x21\xc0\x6b\x7a\xac\xa9\x31\x8e\x43\x8b\x18\xbb\x16\x55\xf2\x3c\x83\xce\x4a\x2b\xb0\xc6\xe8\x92\xcd\xd1\x05\x8e\x73\xdb\x96\x8e\x9f\x2f\x30\x5b\x85\x43\x24\xcc\xb1\x9c\x18\x07\xd2\x89\xa8\x3e\xd4\x81\x5a\x73\x13\xd5\x00\x7e\x6f\x36\xa8\x41\xa0\x5d\xf0\x55\x48\x03\xf8\xbd\x52\x40\x03\x45\x98\xac\xa8\x9c\xa2\x40\x87\xf7\x01\x12\xa3\x03\x73\xf2\x5f\xea\x53\x6c\xa7\xb0\x8a\xed\xec\x55\x46\xe6\x5f\x2e\xf2\x2f\xd1\xdd\x5d\x3d\xf4\x01\xac\x70\x7d\xe4\x03\x58\x1f\x3f\xee\x81\x9a\x31\x84\x01\x05\xaf\xad\x2e\x6a\xc5\xb2\x8d\x2d\xa9\x37\x72\xf8\x55\x23\x21\x2c\x09\x66\x70\xcf\x51\x89\xca\x61\xf6\xdd\x0d\xab\x52\x8c\xae\x1b\x1f\xa0\xbc\x17\xcf\x99\xbf\x51\x24\x85\xcd\x86\x25\xb8\x5a\x10\x81\xc6\xee\xf0\xa5\x2e\xfe\xeb\x06\x2e\x85\xc1\x2b\xdc\x81\x1f\x57\xf2\x90\x2f\x74\x16\xb1\x58\xf7\xa5\x0e\x79\x61\x71\x8f\x50\xe1\x35\xa3\x1e\x03\xa5\x88\xa5\x49\x94\x67\xe0\xf5\xbd\x26\x5e\x47\xe5\x2d\xec\xe3\xef\x57\x01\x92\xf0\xe9\x13\x2a\xa3\x06\x7e\x5d\x4d\x25\x3e\x7d\x42\xa5\x04\xc2\x6f\xa0\xcd\x4f\x1c\x82\x61\x58\x2b\xb7\xb6\xa6\x6c\x9f\x3e\xe9\x3a\x02\xcb\xaa\x96\xb9\x4c\x7b\x66\xcb\x63\xb4\xee\x4a\x7e\x2b\x55\xa4\x09\x7a\xf9\xd9\x21\x9f\xf0\xb7\x1b\x74\xc0\xbe\x45\xbe\x54\x42\xbb\x6b\x79\x2a\xde\x21\x9f\x75\x75\x7b\xec\x5e\x75\x1b\x79\xd5\x7d\x19\x47\x79\xeb\xb6\xaf\x61\x6e\x1b\x47\x2e\x96\xfc\xc2\xee\xa9\xb5\xde\x53\xab\xe9\x3a\xc7\x1b\x3c\xc8\x16\x4b\xb7\x01\x0c\x38\x97\x36\x1d\xcb\x86\xe6\xc7\x37\x70\x2e\x80\x9b\x11\xb2\xc0\x1e\x92\x8e\x5c\x60\x17\x6e\x29\x80\xc1\xa3\x5b\xad\x0f\xbd\x91\x4a\xc2\x2d\x68\xfb\x7e\x06\xab\x8a\xff\xae\x54\xc5\x3d\x7d\x54\xa8\x5a\x07\x5c\xd5\xf1\x1a\x1d\x67\x55\x1d\x1c\x3e\x79\x5a\xac\xbb\xbc\x87\xe3\x6c\x17\x77\xf9\x6e\x64\xc8\xbc\x8d\x51\x76\xef\xcc\x45\xbd\x0d\x1d\xcc\xcf\xca\x4f\xdc\x4f\x16\xda\xb6\x83\xa0\x32\x30\xd7\x5a\xfe\x48\x59\x6d\x67\x6d\x74\x5f\x73\x7f\x2d\x10\x9b\x59\xf3\x1f\xec\x74\xae\x55\xa7\x26\x4d\xf1\xe5\x9b\x71\xfb\x4e\xcd\xb6\xe3\x6b\x14\x5f\x8d\x85\x7d\x9e\xcc\x2f\x9b\x09\xd9\x2d\x98\x81\xe2\x38\x44\xf3\x44\x6b\x7b\x84\xad\x9f\xc1\x96\x45\xf6\x5b\xb2\x5a\xbc\xdc\x35\x3b\xca\x66\xd7\xd4\xd1\x2c\xbc\xa6\x8e\xa2\xc9\x35\x75\xb4\x88\x36\xd9\x51\xc8\x2e\xe2\x1a\x74\x78\xc9\x2e\xea\x73\x1f\x6f\xae\xb3\x6c\x76\x8d\x9d\xcd\xc2\x6b\xec\x2c\x9a\x5c\x63\x67\x8b\x68\xc5\xce\x4e\x12\x12\xd0\xf1\x25\xba\x98\xd2\x60\x8a\xe8\x2c\x11\xb2\x06\x61\x2b\x22\xc2\xb3\xf7\x11\x6a\xfd\x91\xb5\x10\x15\x7e\x8d\xda\x08\xbd\x15\x64\x59\x0b\x5d\xb0\xf4\x2c\x43\x23\x92\xe7\x24\x05\x8b\x13\x91\x42\x5a\x40\x2f\xe4\x91\x56\x2a\x5d\xa7\x9f\xfa\x1b\xaa\xfd\x9e\xf7\x2e\xbb\xf3\x89\xdd\xff\xb0\x39\x98\x1a\xcc\x95\x8e\x4a\xeb\x9c\x41\x57\x18\x4c\x99\x50\xf6\x82\xda\xeb\x8f\xec\xd4\x9f\x61\x6d\xd2\x6b\xad\x52\x7c\x91\xa1\x53\x61\x67\xdf\xa7\x71\x4c\x52\xc8\x0c\x7c\xca\x17\x64\x1e\xe3\x73\x4c\x23\xb0\x23\x64\x52\x37\x09\xd0\xba\xa2\xe5\x85\x5e\x2f\xe1\xf9\x29\x81\x83\xa6\x6c\x96\xe4\x97\x9a\xe1\xe2\x3c\x58\x38\x4f\xd5\x58\xc7\x34\xcd\x72\x04\x1e\x76\x32\x74\xfe\xab\x18\x65\x6c\x46\x50\x46\xf3\xb9\x18\xfb\x25\x9b\xa3\x19\xf8\x15\x28\x3d\x1c\xc4\xd2\x8f\xd1\x94\xa4\x34\xcb\x69\xc0\x8b\x70\x92\xa4\x6c\x41\x67\x38\x17\x1c\x87\x18\xa2\xc8\x3c\x0e\x81\x81\x34\xe7\x17\x51\x3e\x06\x95\x55\xd2\xae\x62\x2f\x85\x6b\xe8\xc1\x87\x10\xa8\xf0\xf0\x73\xbd\xd2\xf3\x8c\xa4\x3d\x3c\x91\xc1\xfc\x0d\xf4\xde\x94\x6a\x13\x16\x70\xc0\x3a\xda\xdb\x0b\x70\x4c\x39\x92\x05\x6c\xb6\xf7\x1f\x19\xc1\x69\x30\x7d\x2e\x6a\xff\xe7\xfe\x60\x0a\xd9\xcf\xb5\x1d\x00\xcd\x29\x8e\x7e\xaf\x4d\x41\x2d\x62\x46\x38\x9a\xd0\xb7\x76\xf2\xf5\x29\x0d\x49\x66\x22\xa7\x8f\x70\x46\x42\xb3\x73\xc2\x24\xc8\x43\x12\x4f\x8f\x29\x9e\x46\x7e\x66\x40\x0f\xaf\xb4\x46\xd0\x29\xbe\xaa\x9e\xce\x85\xa6\xbd\x5a\xe8\x18\xb5\xfd\xfe\x39\xa7\xf2\x47\xd6\xf2\xf3\x21\xd7\xfb\x9c\xe8\xb7\xa7\xf1\x34\x11\xba\x15\xed\x63\xbd\x0a\x1c\xfe\xc4\x2c\x02\xfa\x7c\xef\x9e\xf8\xbc\x96\xe4\x7e\xa5\xe7\x8e\x10\x18\xc9\xde\x4a\xcc\xd7\x7d\x2a\x04\x74\x46\xf3\x41\x3a\xe3\x99\xe0\x56\xf4\x4f\xc1\x53\x98\x7c\x68\x13\xe7\xa7\xb8\x9f\xcd\x4f\x79\x87\x5a\xc0\xbc\x02\x75\x17\x59\x00\xbd\x02\x45\xd3\xeb\x52\xae\x89\x49\x6e\x47\xc4\xf4\xf8\x4a\x22\x26\x51\xb1\x2f\xeb\xf1\x95\x47\x7f\x93\xe3\xfe\x5b\xf9\x29\x3e\x7c\xf2\x04\x78\x78\x25\x3b\x10\xf2\x22\xf4\xb9\xe8\x0c\xf0\xe4\x4a\x23\x03\x45\x29\x4b\xab\xc4\x09\xfb\x0f\x3b\xcf\xa0\xce\xb7\xff\x7d\xf2\xe6\x5f\xa0\xf5\x4d\x49\x1f\xfe\xfe\xf4\x09\xb5\xcd\x2f\x3e\x25\xf1\x44\xa3\xe3\xcb\x23\xc4\xcb\xfa\xfa\x37\xf8\x2e\x16\xd6\xc0\xb2\x62\x95\xf5\xda\x34\xef\xa0\xbf\xd0\xde\x9e\x67\x9d\xde\x83\xa8\x44\x31\xeb\xcd\xe3\x79\x46\xc2\xde\x39\x4e\x33\x73\x0e\xbf\x75\x3b\x93\x91\x4f\xa0\xb4\x6b\x9c\x99\x3b\xcf\x34\x3d\xb4\x57\xef\xe9\x1d\x10\x1d\x9e\x91\xcb\x2a\x99\xd7\xc3\x87\x4e\xad\x3a\x69\x17\xff\x7e\x33\xa5\x91\xd7\xef\xb1\xb1\x55\x07\x94\xad\x08\x57\x2f\x70\x1a\x73\xce\xa3\x02\xec\x81\x5f\xb1\xd6\x01\x41\x54\xf1\x82\xae\x9a\xe7\x76\x15\xb2\x1d\x98\x39\x4e\x49\x94\x90\xb4\x52\xd4\x7b\x70\xa7\x42\x61\xde\x30\xa9\x2d\x2a\x7a\xf7\x8c\x23\x76\xc1\x9b\xef\xc9\xca\xbd\x73\x1c\xd1\xb0\x37\xa6\x11\xe9\xe1\x38\x66\x92\x61\x52\xde\x3e\x0d\xc7\x22\xee\x5b\xc5\x4c\x94\xce\xeb\xc9\xa3\xc6\x33\xb3\xa1\x6d\x41\xe8\x5b\x65\x50\xf3\xb9\xbb\xd6\x74\x9f\x57\x79\x2c\xf1\x11\xa2\xef\xd1\x5f\x9f\x9b\x4b\x5d\x2d\xc0\xdd\x9d\x70\xfa\xcb\x0b\xa7\xb7\xed\x8e\x60\x75\x2c\x6e\x71\x43\xa6\x26\x24\x26\x29\xce\xc9\x49\x69\x96\x48\x21\xe8\xd0\x31\xda\x8c\x43\x8f\xf2\x1e\xf9\xec\x98\x9c\x15\xe8\x76\x9f\xdf\xf1\xfd\x94\x84\xf3\x80\x58\xe1\xd9\x94\x3a\xf7\x8c\x5c\xaa\xa7\x92\x28\x7a\xdf\x62\x71\x74\xd9\x42\x0f\xc4\xe9\x91\x44\xbd\x1f\xe0\x84\xe6\x38\xa2\x7f\x92\x9f\xf8\x0b\xfd\x17\x10\x7b\x74\xda\xbc\xf9\x07\x13\x0f\xae\xc6\x86\x4e\x38\xd2\x8c\xac\x81\xf1\x7e\x00\x40\x57\x4e\x52\xfa\xec\xca\x71\x9c\x91\x4b\xf4\x00\xb5\x7e\x4b\x5a\xeb\x76\x30\x4f\x96\x83\xe7\x2f\x8c\xb5\x3b\x08\xd9\x45\xec\x77\x61\xbf\x3a\x45\x57\xcf\x64\xa8\x8e\xcf\xe2\x11\xe8\xb8\x79\x2d\xf7\xea\x2a\xc5\x8e\x67\xab\x45\x86\xf4\x9e\xf0\xc7\x59\xe6\xbf\xe2\xaf\x9a\x51\x8d\xef\xa5\x65\xb8\x6b\x52\x88\xf2\x27\xa5\xfe\xc0\x7f\xa8\x0f\xfc\x71\xa9\x3f\xf0\x1f\xda\xd1\x2b\xb4\x3e\xf0\x1f\xda\x2a\x6e\x62\x7d\xe0\x3f\x74\x1f\x91\xdd\x47\x64\x7d\x80\x47\xa8\xd5\x3d\xff\x69\x06\xe0\x7c\x14\x3f\xcd\x20\x9c\x8f\xe2\xa7\x19\x88\xf3\x51\xfc\x34\x83\x71\xfb\x8c\xec\x8f\x1b\x4e\xd1\x06\x27\xb5\x8b\x5a\x7c\x5d\xf9\xbf\x7c\x19\xf9\xbf\x7c\xd5\xc0\x30\x79\x22\xfe\xe5\x6b\x22\xea\x01\xba\x43\x4d\xf5\x97\x98\x9a\xa8\xad\xfe\x12\x83\xd6\x62\x96\xc6\xd6\x85\x60\x3c\x22\x79\x4d\x2f\xdd\x14\xbc\x44\x4c\x99\x10\x8a\xa8\x08\x55\xfc\x3e\x1a\xe8\x70\x97\x4b\xab\x42\x38\x2b\x28\xee\x4f\x71\xf6\xe6\x22\xd6\xcf\xa8\x56\x4a\xc6\xad\x4e\x17\xb5\x5e\xe3\x9c\xa4\x14\x47\xbd\xdf\x5e\x1d\xa1\x79\x9c\xcd\x13\xfe\xbe\x22\xa1\x12\x93\x52\x92\xa1\x54\xc4\x36\x0b\x91\x26\x76\xe5\x3d\xff\xc1\x68\xdc\xe6\xcb\xd2\xe1\x04\x03\x72\x30\xfe\x5d\x1c\x24\xb4\xf7\x8f\xd3\x7e\xab\x83\x8e\xd0\x39\xa3\x21\x1a\x3c\x2b\x33\x43\x7e\xff\x41\x84\x4d\x55\xc1\x4b\xa9\x08\x46\x4a\xd1\xdf\x2b\xa9\xb5\x98\x2b\xaf\xf3\xe0\x39\x1a\xda\xe1\x55\x47\x8e\xc2\xbd\xbc\xf9\x7b\x2a\x03\x96\xba\x0d\xcc\x19\x79\x6f\x41\x91\x14\xb6\xac\x81\x8d\xc7\x5e\x13\x81\x1e\x92\xd8\xd1\x31\x6a\xdb\xdd\x18\x13\x6e\xbd\x0c\xfd\x64\x9e\x4d\x95\xd9\x75\x49\xf7\x1d\x3f\xc3\x9c\x3b\x8a\x15\x21\x6a\xe4\x2d\x98\xa5\xf3\x03\xa3\x80\x55\x80\x5a\xe9\xfa\x03\x78\x1f\x56\x94\x12\x0a\xc3\x6f\x2b\x23\x59\xa5\x81\xb7\x18\xa7\x3c\xfb\xda\x12\x58\x13\xf1\xeb\x12\x24\x5e\xd5\x4c\x4c\x0f\x18\xec\xc3\x6c\x0b\x9b\x2d\x48\xed\x9e\x0e\x6e\xb5\x74\x67\x17\x28\xe3\x8b\x07\xca\xb8\xe5\x49\x54\xb6\x1d\x37\xe2\x6b\x13\xe1\x38\xc9\xe3\x36\x13\x9f\x02\x60\xed\x62\x54\xc8\x3b\x5d\xd8\xc3\xa3\x07\x28\xa4\xe7\xe8\x1f\xe8\x7e\xeb\xc8\x0a\xfa\x24\xc2\x3e\xbc\x63\xc9\x11\xea\x95\x47\x7d\x90\x55\x55\x4c\x65\xf8\x47\x25\x03\x39\xc9\x71\x6a\xf5\xb4\x24\x86\x44\x19\x84\x1f\xe3\xd0\x6f\x2f\x42\x53\x54\x35\xdf\x5c\x24\x87\x3a\x41\x50\x17\xc5\x2c\x9d\xe1\x28\x02\xdf\xd3\xd3\x57\x01\x8b\x7f\x98\xe7\x39\x8b\x21\xc0\x80\xd0\x8b\xdc\x00\x61\xd1\x26\x45\x37\xb7\x3f\x7c\x84\x1b\x0b\x57\x47\x2a\xe1\x23\xe7\x27\x02\xc2\xb6\x4b\x1b\x81\x1f\x29\xbc\x14\xb1\xdc\x4a\x6d\xe3\x80\x5e\xbe\x79\xad\x5c\xf7\x45\x28\x89\x32\xd9\xe0\x0d\x49\x10\xbb\x85\x3c\x99\x05\x83\x21\x2d\xb8\xa0\x99\xb5\x5a\x53\x12\x2b\xc7\x46\x74\x91\xe2\x24\xe1\xa5\x34\x46\x18\x59\xb7\x63\xc9\xca\xc9\x36\xa6\xd2\x0a\x06\x45\x7c\x77\x15\xd5\x10\x26\x39\x38\x64\x69\x0c\x3b\x95\x4d\xc1\x56\x44\x84\x60\x41\x2a\xf7\x95\x8a\x03\x71\x0a\x41\xec\xac\x50\x20\x26\x97\xd1\x12\xfb\xa0\x8c\xd3\x37\x48\xc3\x1e\x87\xad\x0f\x1d\x47\xc8\xe8\xc8\x18\xa1\x87\x17\x6a\x3c\xbe\xf4\x67\xad\x1c\xfb\x0d\xb2\xe3\x37\xf5\x58\xaf\xf6\x56\x2f\x6c\x88\xef\x93\x6e\xbe\xa8\x26\x7a\x0f\x54\x4d\x55\xb0\x51\x21\x8c\x9d\x0f\xbf\x32\x80\xab\x3f\x44\x5e\xa8\x46\xa3\xa5\x2b\x1b\x4f\xa8\xed\xaf\x6e\x93\x88\x8f\x9b\x4c\xa7\xee\x5c\xbe\x5d\x6b\x3f\x38\x45\x11\x18\xbb\x5e\x66\x74\xeb\x4e\xf6\xc1\x72\xfc\xaf\x4e\x96\xde\x91\x37\xbb\xe3\x30\xad\xfc\x9b\x35\x9e\x8b\xe1\x71\x02\x02\x09\x2b\xbe\x29\xe2\xde\xf7\x1b\x71\xff\x15\x81\xa5\x5a\x19\x09\x58\x1c\xe2\xf4\xb2\x65\x1c\x7f\xad\xb7\x3e\x42\x1d\x74\x54\x7c\xfc\xbb\x07\x79\x97\x80\x7c\x5d\xef\xd6\xdb\x91\x80\x7c\xb5\xfb\x68\x97\xbd\xfc\x46\x7b\x82\xef\xb2\x97\x97\x5d\x88\x1b\xf0\xce\xd6\x57\x6a\xf5\xde\x2f\xe5\x97\x3c\x67\x5b\x8f\xcc\x2e\xc9\x28\xae\x42\xa5\x97\x1c\xd7\x3a\xdb\xc5\xd5\xa4\xa8\xee\x90\x40\x94\xea\x16\x6d\x49\x9e\x3a\xdc\xc9\x53\x77\xf2\xd4\x1b\x2a\x4f\x4d\x76\xc1\x84\x9b\x05\x13\xfe\x89\xa5\xb3\x4a\x1f\xec\xe1\x4d\x13\xb9\xde\x6e\x79\x26\xc4\xb4\x1d\xb3\x74\xf6\x26\xa5\x13\x1a\x1f\xa1\x56\xce\x12\x14\x91\xb1\x1b\x19\x76\x6c\x07\x6a\xf8\xcb\x7b\xbc\x16\xb3\x18\x23\x80\xa0\x73\x4f\x23\x94\xb3\xc4\xfa\xb5\xb7\x87\x32\x88\xb6\x8b\x70\x94\x93\x54\xbb\x31\x65\x09\x09\x90\x94\x52\xf2\xdf\x33\x9c\x07\x53\x74\x4e\xb3\x39\x8e\xc4\xc7\x94\x64\xf3\x28\xf7\xc7\xae\x32\x4b\x47\x38\x27\xfc\x9e\x02\x8d\x68\xa9\x00\xf6\x21\xea\xa1\x21\xa8\xc6\x93\x45\x07\x65\x01\x8e\x48\x7b\xd8\x29\x06\xc1\x7d\x49\xe2\x8c\x1c\xd9\xc9\xe3\xf8\x7b\x96\xc4\x99\x18\xab\x92\x84\x09\x61\x88\x08\xc4\x04\x4d\x4e\xc5\xea\xf7\xd7\x1f\xe1\x7e\xff\x10\x3d\x58\x36\xc6\x6c\x9a\xd2\xf8\xac\x64\x17\xfd\x7e\x86\xfd\x43\x03\x64\xd0\x7f\x7c\xd8\xd1\x3b\xd4\x70\xe7\x71\x0c\x6e\x49\xa1\xd7\x99\xdc\x78\x31\x05\x53\x92\xc9\x47\x66\xbb\xa5\xc1\x3b\x59\x36\xc2\x79\x8a\xab\x5a\xaa\x6f\xfd\x6c\xca\xd2\x5c\x3a\x67\xc1\xff\x08\xce\x20\x43\x79\xb1\x8d\xf8\xc2\xff\x21\x6f\xe6\x26\xb7\x9d\x3d\x81\x86\xd1\x92\x61\x0f\x75\xd0\xb4\x2d\x8a\xc7\x33\x1d\xe0\x11\x90\x07\xc2\x8e\x9c\xee\xc4\xdf\x37\x4c\xfc\xed\x85\xe0\x35\x38\x27\x0f\x84\x4c\x3f\x5d\x19\x8a\xf7\x85\xaa\xb5\x9a\x4b\xa9\xea\x13\x5c\x44\x4c\x54\x41\x98\xc3\x95\xc2\xfd\x7a\xf3\x11\x5a\x2c\x2b\xa0\x70\x12\xe1\x4b\x13\x7e\x37\x4d\x41\x31\x83\x73\x2b\xa9\x36\x14\xae\xd0\xe3\xa9\xdc\xbc\x53\xe3\xed\x69\xed\x36\x1c\x00\x2b\xfa\xce\x69\x31\xc6\xaf\xf5\xf5\x78\x0d\x3c\xf0\x66\x2c\x02\x17\xcb\x7c\x7c\x72\xfe\x34\x43\x63\x16\xcc\x33\x7b\xff\x64\xc1\x8a\x4b\x1b\x02\xf1\xef\x8a\x15\xc5\xe1\x1f\xf3\x2c\x47\xe7\x9c\xc1\x0c\xe0\xe6\x12\x14\x1e\xbd\xe3\x5d\x43\xca\x58\xa9\x0e\x63\xa3\x1c\x43\x52\xc3\x73\x8a\x55\x6c\x4d\x34\x4e\xd9\x4c\xbb\x71\xea\x38\x92\x7a\x80\x42\xaf\xb7\x54\xda\x0e\x23\x2a\x78\xe2\xd2\x4a\x34\xa0\x71\x48\x03\x91\xd5\x10\xe7\xd6\x8a\xd1\x0c\x49\xf8\xd6\x22\xa9\x92\xab\x22\x20\xcd\xf8\x55\x36\x8f\xcf\x2c\x17\x73\x79\xb5\xd5\x00\x2e\x53\x17\xd4\x07\xab\x2d\xd3\x19\x58\x21\x3b\xcb\x03\xc7\xfa\x27\xd9\xaf\xa8\x3f\xf8\x02\xd1\x75\xed\x52\x1b\x06\xc5\x2d\x9e\x0b\x5d\xb7\xf8\x49\x1b\x90\xc2\xb2\x3a\x80\x45\x91\x9b\xb2\xc0\xa9\x20\x8a\xae\xaa\x89\xb0\x03\xd1\xfa\x2b\x07\x5a\x88\x72\x73\x51\x47\x39\x51\x9c\x17\xd8\x85\xc2\x04\xc0\x2e\x14\x46\x7a\x85\xc0\xb5\x02\x14\x7a\x6e\xad\x93\x1f\xb4\x56\x55\x29\x66\x8b\x2e\x8f\x1f\xab\x41\x16\x02\xc2\x72\x52\xf8\xe9\x93\x5f\x2e\x09\x4f\xc9\x17\x50\xcd\x91\x10\x54\x14\xcf\xec\x00\xb2\x62\xda\xbc\x0b\xbd\x79\xcf\xdc\x41\xab\x1a\x4d\x07\x6d\x20\xba\x43\x10\xe5\xcf\xae\x1c\xbd\x76\x23\x3a\x1b\xeb\x31\xd2\xf5\xe7\xb1\x16\x40\xc5\xe3\x76\xb5\x1e\x45\x63\xe8\x7a\x00\xe5\xd1\x92\x38\xb0\x1e\x8c\xd2\xf8\xbd\x6b\xc0\x31\xef\x99\xae\x83\x0e\xe2\x82\xa8\xd6\x43\xfd\xba\x46\x84\x60\x78\xba\x03\x15\xfa\xc5\x84\xd1\xae\x8c\x14\xdc\x0a\x71\x8e\x7b\xf2\x14\x1f\x21\xb5\x68\x65\xf6\xa5\x5d\xc3\x0a\x96\x90\x3f\x4f\x59\x56\xae\x87\xfa\x82\x81\x68\x1b\xf1\x6b\xe5\x6d\x9a\xf1\x91\x3b\x65\xca\x0d\x56\xa6\x94\x5c\x7a\x1b\xd0\x23\x6c\x36\x66\x2c\x30\xf7\x9b\x01\x55\x7a\x57\x6f\x64\x67\xe4\x0d\xb9\x99\x61\x4a\x96\x61\xa9\x16\x46\xf1\xd1\x4d\xe1\x2a\xd6\x78\x33\xa3\xd4\x2c\x4e\x3d\xac\x82\x36\x48\x10\xbb\x12\x4d\x90\x21\x45\x3a\x72\x45\x91\xd2\x18\x3d\x90\x05\xec\xcb\x47\x70\x35\x83\x31\x0a\xa5\x2d\x46\x6d\x7d\xba\x7f\xc7\x95\x49\x37\x4a\xfb\x72\xc7\x34\x5b\x22\x8b\xe5\x1e\x7a\x81\x26\x29\x0d\x1d\x4b\x4a\x1d\x3d\x8a\x45\x11\xbb\x80\x24\x47\x74\x94\x21\x9c\x21\x1a\x67\x09\x95\x42\xd0\x7b\x7b\x7b\xbc\xfd\x4f\x52\xd2\xec\x45\xc1\xe1\x9f\x7a\x2a\x38\xd3\xf9\x41\x0f\x47\xc9\x14\xf7\x27\x24\x1f\x31\x96\x67\x79\x8a\x13\x08\xd5\x14\xe1\x4b\x36\xcf\xf7\xc6\x11\x59\x8c\xd8\xa2\xc7\x87\xb2\x67\x9a\x7a\x89\xf5\xcf\x52\x9a\xe5\x6c\x4c\xd2\x3f\x58\x46\x92\xa9\x6a\x05\x8d\x46\x11\x1b\xed\xcd\x70\x96\x93\x74\x2f\x4b\x83\xbd\x20\xcb\xec\xef\xfd\x20\xcb\x2a\xe1\xa6\xec\x32\x22\x64\xf0\x78\x70\xb0\x07\x1c\x64\xcf\x1e\x8e\xdb\x6a\x26\x3d\xe1\xfa\x38\x9e\xcc\x23\x9c\xfe\x91\xf5\x59\x3a\xd9\x8b\x70\x4e\xb2\x5c\xcd\x86\x72\x6a\x23\xd9\x33\xbd\x4a\x7c\x29\x85\x68\x47\x42\x47\xff\x9c\x43\xf0\x4d\xa6\xa2\x9e\x71\xf4\x4f\xb3\x1c\x4b\xf9\x23\xfc\x8c\x2e\xf9\xf2\xcf\x58\x48\xa2\x23\x77\x24\x41\x96\xf5\xf8\xd9\x3d\x03\x4b\xc1\xbd\x2c\xa6\x49\x42\xf2\x0c\x26\x8e\x7b\x13\x0e\xbb\x97\x33\x35\x95\xad\x26\x21\xbd\x2b\x6a\xbd\x35\xa2\x74\xc8\x42\x7e\xbc\x7e\xc2\x41\xce\xd2\x2a\x37\x91\xc3\xa7\x0f\x6b\x1a\xd5\xaf\xb5\x5f\xdb\x8b\xc1\x5c\xa9\x89\x3c\xf4\x2a\x2e\x8f\xd4\xfc\x75\xab\x2e\xef\x8e\x0b\xcb\x97\x8d\x2b\xf2\xcf\xdf\xde\xbd\xfb\xf1\xed\x09\x7a\x8e\xde\x0f\xba\xe8\x49\x17\x0d\x1f\x75\xd1\xfe\x41\x17\x1d\x0c\x3e\x88\x58\x58\xff\x7c\xfb\xea\xe5\xc7\x93\x57\xff\xdf\x8f\x50\x49\x84\xa9\x1c\x76\xd1\x7e\x17\x3d\xec\xa2\x83\x2e\x3a\xec\xa2\x47\x5d\xf4\x18\x1a\x3f\xed\xa2\xe1\xa0\x8b\x86\xc3\x2e\x1a\xee\x7f\x78\x56\x12\xea\xe1\x9f\x29\x0d\xdb\x93\x88\x8d\x70\x74\x22\xb9\x32\x50\x9d\x75\x2d\xf7\x5b\x21\x3f\xb2\xee\x2b\x3c\xcf\x19\x12\x04\x9b\xc6\x13\x25\x65\x53\x14\x66\x79\xfc\x82\x16\xbf\x1c\x7a\x2d\xf4\xc0\xea\x44\x29\x12\x39\xd1\xfd\x01\x67\x34\xd3\x2a\x65\x5e\xf2\xcf\x94\x5d\x1c\x21\x99\x42\x7f\x86\x17\x32\x02\x61\x6b\x38\x18\xfc\x27\x84\x9e\x10\xc2\x0c\xb3\x36\xfd\x31\x4b\x7f\xc4\xc1\xd4\x0e\x34\x41\xff\x24\x25\xf9\x9f\x20\xaa\x27\xbc\x8b\x65\xca\x39\x2b\xf3\xd3\xde\x1e\x3a\x39\xa3\x89\x15\x0f\x92\xc5\x84\x5f\xe6\x22\xeb\x3b\xc2\x23\x76\xae\xf5\xc1\xe2\x54\x2b\x5f\xdf\x7b\xb2\xfd\x9b\x38\xba\x44\x67\x84\x24\xe8\x11\xca\xe8\x24\xa6\x63\x1a\xe0\x38\x47\x22\x4a\xa2\xd0\xfb\xc0\xfa\x89\x50\x90\xcf\xd1\x6b\x9c\x4f\xfb\x29\x9b\xc7\x21\x8c\x18\xed\xa1\xe1\x3e\xfa\x4e\x14\x27\xec\xa2\xcd\x37\xf4\x51\xa7\x83\xf6\xdc\xa2\x03\x50\x2a\xff\x67\x4b\xba\x42\x17\xa3\xf0\xcc\xf0\xa2\x17\x91\x58\x08\xe2\x85\xd6\x3b\x62\x99\x36\xfd\xd7\xbc\x45\x81\x1b\x91\xb5\x4b\x2e\xff\xfc\x62\x94\xed\xe9\x86\x82\x8f\x18\x0d\x0e\x07\x4f\xf0\xd3\xc7\x87\xe1\xe3\xe1\x30\x7c\x34\xda\x3f\x08\x06\xc3\xf1\xe1\xe3\x30\x3c\x3c\x38\x38\x0c\xf6\xf7\x1f\x3d\x7d\x3a\xc6\xc1\xc1\x5e\xc6\x6f\xdb\x19\x5d\xd0\x38\xdb\xfb\x08\x7c\x06\x2f\xf9\x8f\x5f\x1e\x3d\xf5\x26\x40\xe2\xb2\xf1\xab\x18\x21\x25\xa8\xc4\x17\x02\x8a\xf8\xfa\x7d\xd0\x01\x4b\x1c\xdc\x82\xd5\x36\xe2\x71\x85\x50\x50\x2c\x76\xf0\x99\x41\xab\xbd\x3d\xf4\x2f\x86\x62\x22\xdd\x64\x30\x9a\x91\x90\x62\xf4\xbf\x73\x92\x5e\x6a\x73\x01\x81\x1f\xbc\xcb\xfe\x3d\xdf\x75\x5c\xe0\xd7\xc2\x04\x83\xac\x10\x9b\xb9\x07\x31\x53\x57\x2c\x42\x9f\x11\x89\x32\x22\x1b\xdb\xb5\xde\x97\x06\x1b\xb1\xce\x2e\x9f\xbf\x15\xfd\xe3\xde\xe7\x32\x22\x30\xe7\x4c\x54\xbb\xe2\xe0\x3b\x87\xfb\x2f\x11\xe4\x45\x92\xa9\xb2\x53\x26\xf4\x61\x5d\x44\xe3\x90\x2c\xec\xf3\x06\x05\x22\xc2\x42\xf9\x09\x53\x4f\x47\xc7\xca\xa2\xe4\x54\xa9\xad\x97\x5d\x55\xee\xbe\xf8\x6c\x23\x80\x52\xaf\xf5\x94\x1d\xca\x1e\xda\x57\x48\x70\x21\x49\x4a\x80\xa3\xa0\xcd\xe9\x0a\xc4\x58\xd0\x60\xa4\xc9\x86\xb6\xb0\x68\xdd\x47\xff\x40\xdf\x72\x1a\xf2\x2a\x27\x33\xc7\x53\x30\xc1\x61\x08\x26\x0d\x56\x2f\xae\x6f\xa0\x85\x5b\x5e\x80\x96\xcf\xf7\x38\xab\x2a\xf9\x05\x74\x7c\x72\x22\x9e\x7e\xc0\x80\x73\xf4\x3d\x42\xad\x01\x1a\x02\x05\x6e\x75\x55\xe1\x4b\x9a\x92\x40\x1a\xeb\xa4\xec\x42\x7c\x70\x52\x6a\xf3\x5a\x3d\x69\x73\xaa\x5a\xfd\x9e\xe2\x04\xa2\xf7\x5c\xa4\x38\x11\xc5\x7f\xcc\xb3\x9c\x8e\x2f\x8f\x85\x31\x83\xdf\xee\xaa\x26\x4a\xb5\x6e\x22\x7c\x25\x79\xbf\x98\xc6\x24\x35\xab\x39\x62\x8b\x13\xfa\x27\xac\x66\x6b\xc4\xd2\x90\xa4\xbd\x11\x33\x79\xc3\x4d\x10\x22\x27\x9d\xb8\x35\x3d\x39\x39\x77\x8f\xd5\xb5\xa1\xed\x48\xd4\x3e\x36\xee\x58\xef\xc5\x40\xed\x85\x8b\x61\xad\x41\x4b\xdd\x98\x76\x52\xe6\x56\x86\xe6\xc2\x60\x02\x82\x23\x83\x4e\x08\x02\x20\x63\x74\x3a\xa6\x93\x79\x4a\x5c\x5d\xb9\x1a\x5f\x2b\x54\x5b\xdc\x5b\x64\xbd\x80\x45\xf3\x59\x6c\xe1\x9c\x8f\x04\xb2\xc2\x32\x08\xbd\x94\x9c\x93\x34\x23\x4b\x21\xe9\x8a\xd5\x10\x53\x76\xd1\x00\x9c\x5d\xcb\x81\xc5\xb7\x89\x83\x91\xd8\xe8\x42\x70\x31\xb5\xb4\x1d\xfc\x5b\xde\xbf\x85\x08\xe5\x7d\xc3\x49\xe9\x51\x7e\x54\x60\x6d\x44\xfa\x79\x03\xa4\x2c\x39\x7d\x1d\x00\xeb\xd0\x54\x00\xb1\x6a\x2c\x05\x44\xe2\xb0\x16\x0c\xff\x5e\x07\x64\x84\x33\x12\xd1\x98\x54\x01\xd1\xdf\x4b\x80\x48\xab\xa6\xea\x55\x31\x94\xa2\x7a\x5d\x2c\x20\xd5\x2b\x53\x4a\x72\x1a\x00\x2b\x59\x1d\x0f\x54\xc5\xfa\x58\x80\x38\x99\x26\xbd\x11\xc9\x2f\x08\x89\xab\xa1\xb9\xd5\x9a\x80\xc4\xc0\xc6\x2d\x83\x28\x6b\x39\x00\x25\x21\x2e\x5d\xf8\x02\x91\x2e\x5b\x7a\x0b\x40\xc9\x3a\x95\xd3\xf9\xc2\x4a\x59\x40\xaa\xd6\xa8\x00\xa9\x66\x95\x0a\xe0\x0a\xeb\x53\x01\xcd\x59\x21\x11\xc3\xac\x9c\x75\x01\x16\xab\xdb\x3c\xf6\x1c\x0e\x82\xf9\x6c\x1e\xe1\x9c\xa5\x4e\x00\xba\xbd\x3d\x48\xb9\x0c\xe1\xe8\xc9\x78\x4c\x82\x1c\xb1\x73\x92\x22\x3a\x9b\xcd\x73\x3c\xa2\x11\xcd\x05\xe3\x27\xc5\x4f\x09\x49\xc7\x2c\x9d\x71\x2a\x2f\xc8\xb6\xf3\xbc\x72\x7a\x91\x23\xe5\x9d\x09\xa6\x46\x5e\x8e\x56\x25\x13\xa6\xad\xb3\xb2\x81\x22\xef\xf0\x84\xfe\x59\x63\x87\x7e\xd5\xcc\x98\x52\x77\x32\xfc\x50\x9d\xe5\x45\x56\xd9\x5f\x5e\xe5\xe1\xf2\x2a\x07\xcb\xab\x1c\x2e\xaf\xf2\x68\x79\x95\xc7\xcb\xab\x3c\x59\x5e\xe5\xe9\xf2\x2a\xc3\x41\x83\x3a\x0d\xd6\x77\xb8\xff\x01\x42\x3e\xdd\xf5\x2c\x54\x3b\xe3\xd5\x5d\xec\x86\xed\xc6\x6e\xb0\x8d\x17\xcd\xda\x82\xe9\xe4\x14\x9f\x8b\x2c\x5f\xfc\x8a\x44\xdf\x05\xea\x89\xf2\x1d\x1a\x91\x29\x3e\xa7\x2c\x95\x8b\xfd\x3f\x6c\xae\xa2\x2b\x8c\xac\x58\x0f\xdf\x01\x23\xf6\x9d\xe2\xf2\x2d\x00\xf6\x52\xeb\x77\xcf\xba\x26\x97\xf5\xa3\xe6\x63\xd8\xe4\x80\x29\x3c\x95\x1a\x8f\xf5\x25\x08\x03\x45\xee\x9a\x53\x87\x57\x92\x2e\x15\xda\x8a\x58\x65\x5a\xe1\x0f\x25\x75\x02\x41\xe4\x12\x45\x2a\x1f\x4a\xc6\x6f\x37\x33\x14\x97\xa5\x5a\xea\x75\x99\x92\x3c\x98\x82\x09\xa2\x60\x9a\xba\xee\x1b\xd7\xe2\x84\xba\x3e\x2f\xd3\xf5\xd8\x11\xdf\xfc\xb6\x64\x96\xb0\x94\x1b\x9a\xa3\xe4\xd7\x97\xcc\xd0\x9d\x8c\x37\x49\x35\x2d\xb3\x0a\x9a\xf9\xaf\x9d\x0c\x34\xd6\xaf\xbd\xca\xf9\x40\xe4\x93\x46\x13\x0a\xcd\x93\x70\xc9\x7c\x40\x9c\xe1\xbe\x1b\xbb\xfa\x7d\xdb\x2d\xbc\x4f\xeb\xa6\x01\x9b\x87\xe4\x6e\x0a\xc3\x7f\x4e\x5e\x4e\xf9\x26\x9d\xfa\x14\x90\x4f\x27\xc0\xb1\x08\x27\x0b\x99\x75\x44\x92\x1a\x2c\x1b\xe9\x53\x51\x68\x09\x76\xce\x42\xf0\xb3\x6c\x76\x05\x09\x7f\x91\x32\x25\x29\x3b\xa7\x21\x09\xa5\xf5\x39\x3f\xa5\xe2\x64\xbe\x17\x9a\x85\x0f\xed\x3d\x9c\xd0\x3d\x19\xf4\xd7\x22\x03\x38\x0e\x65\x62\x42\x13\x68\xd4\x0c\x50\xd4\x5f\x95\xb2\xfb\x31\xc8\xd7\xa1\xec\x36\x8c\xcd\x50\x76\x0b\x62\x1d\x12\xab\xd7\xc7\x32\xca\xd3\x1c\x8b\x25\xc4\xcd\x9c\xc9\xf5\x49\x0d\x80\xe1\x88\x71\x75\x42\x73\x01\xa2\x92\x25\xd3\x51\x02\x43\x25\x5b\xf3\x44\x2b\x75\x63\x15\x4a\x0f\xce\x63\x4e\x52\x1a\x66\xde\xcd\x45\x33\x34\x61\x86\x4f\xa9\x1b\xbe\x95\x42\x0b\xa6\x20\xce\x04\xf8\x1e\xb0\x0b\x92\xe5\x28\x49\x29\x4b\xa9\x5a\x03\x91\x4b\xaf\x49\x1a\xce\xdd\x8b\xe8\xf6\xbf\x88\xb6\x8c\x7f\x70\xe8\xb2\xd9\xa9\xad\x73\xe0\xd4\xf6\x82\x86\x3a\x6b\x5b\x86\xe8\x18\xc5\x4c\x88\x0d\xd2\x42\xa2\xc5\x1d\x26\xee\x30\x71\x53\x98\x38\x0b\xd7\xc7\xc4\x59\xb5\xd5\xfa\x0e\x13\x77\x98\xb8\x22\x26\x46\x93\xf5\x31\x31\x5a\xc2\x2c\xef\x30\x71\x87\x89\xcd\x31\x71\x11\xd5\x63\xa2\x9d\xad\x77\x87\x77\x5f\x07\xde\x79\x8e\xc5\xa0\x99\x69\x12\x7d\x74\x23\x6e\xbd\x3a\x60\xa6\x5b\xad\x10\xa6\x54\x49\x15\xac\x2a\xb2\x44\x55\xa1\x39\x99\x99\xdc\xb6\x39\x99\x75\x4b\x74\x8b\xba\x82\x5d\xd8\x2d\x68\x7f\xdd\x6a\x50\x64\x0c\x2b\xa4\x84\xc6\x72\x8c\x96\x25\xda\xeb\x58\x5a\xb7\x68\x97\x63\x69\xf9\x23\x3f\xeb\x74\x51\xe2\xab\xf8\xd9\x75\x15\x7d\xfa\xab\xfc\xad\xed\x34\x52\x6c\x56\x89\xff\x30\x79\x74\xac\x1c\x3a\x26\x7f\x8e\x95\x3b\xc7\xe4\xcd\xb1\x72\xe6\x98\x7c\x39\x56\xae\x1c\x93\x27\xc7\xca\x91\x73\xe5\xd0\xac\x15\x4e\xce\x6e\x98\x56\xb5\xa9\xfc\x07\xdf\x43\xfe\xaf\xbd\x55\xfa\x37\xec\x89\x70\xae\x96\xab\xaf\x64\x03\x34\x9e\xf0\x3f\xc5\xb2\xf2\xbf\xe4\x12\xda\xef\xf2\x85\xf0\xa4\x9e\x89\xec\x3a\x22\xb3\x8e\xc8\xaa\xa3\x63\xbe\x36\x77\xf6\xdd\x8c\x7b\xaf\x63\xe6\xd3\x35\x08\xbf\x9e\xfb\xab\x32\xdb\xe9\xc2\xb1\x58\x0b\x86\x31\x23\x5b\x64\x60\x36\x76\x02\xba\x12\x65\xc7\xd6\xf9\x60\x0d\x12\xdd\xbf\xaf\xb1\xfe\x1b\xb0\x63\x5b\xaf\x47\xc7\x70\xc6\xea\x53\x97\xf3\x5e\xcd\x09\xe4\x5d\x71\x72\xe5\xb8\x7c\x99\xf3\xb8\xe6\x20\x94\xe5\x8c\xd5\x3f\x2f\xe2\x5d\xc3\xf1\x2b\xef\x15\xaa\xac\xd7\xa1\x67\x97\x62\xf5\x6b\x50\x9d\xf7\x6e\xd1\xa7\xf2\x31\x58\xd5\xaf\x32\x12\xcb\x5c\xc3\x1f\x8b\x3c\x86\x7a\x34\x8a\xac\xd6\x8c\x47\x35\x59\x6f\x44\x96\x69\x84\x35\x16\x59\xca\x87\xa1\x08\x66\xf9\x08\x54\xc5\xf5\x3a\x07\x13\xda\x45\xd6\xfa\xd0\x05\xfa\xfa\xfc\x39\xf8\x99\x5d\x0d\x98\x3d\x8d\x05\x6c\xeb\x22\xe3\xc7\x67\x21\x36\xf5\xaa\x1d\x64\x33\x3e\x5a\x4e\xf8\x37\x02\xcc\x39\xf8\xb3\x8e\x00\xcd\x0f\xfb\x6c\x23\xa3\x9d\x85\x7c\xb4\xfc\x46\xda\x08\x30\x7b\xb4\xb3\xb0\x23\x40\xdf\xbf\xcf\xff\xbb\x89\xd1\x46\x13\x3e\x5a\x7e\x55\x6e\x04\x98\x3d\xda\x08\xe8\x69\x34\xe1\xa3\x8d\x26\x1b\x19\x2d\xbf\xcb\xba\x70\x87\x6f\x04\x98\x83\xb7\x51\x47\x80\xe6\x78\x1b\xd9\xa3\xad\x8f\xaa\x20\x6e\x55\x0e\xf0\xd7\x25\xe9\x5f\xab\xd2\x6d\xe9\x54\xfd\xd2\x92\x5c\xa9\x77\xfe\xb2\x2d\x86\x9a\x45\x00\x97\xee\x4b\x7e\xf4\x6f\x97\x1d\xab\x07\xe5\x30\xaf\x5d\x33\x31\x11\x89\x6d\xc5\x9c\x63\x95\xc0\xc0\xf6\x19\x48\xdb\x2e\x94\xb8\x18\xd6\x1d\x0d\x25\x7e\x27\xec\x88\xee\x4c\x00\x8b\x5d\x34\x70\xf7\x3d\xb6\x81\xb8\x0e\xf2\x45\xb7\x01\x48\xde\x9b\xf0\x7a\xad\x5b\x56\x1a\xa4\x7a\xa8\x6e\xcd\x3c\xa5\x79\xe8\x14\xf3\x50\xde\xb4\x6d\x49\xe3\xc0\x1e\xfa\x7d\xbe\xaa\xfd\x47\xd3\x1e\xf4\xb3\xff\xae\x19\x70\x34\x5d\x00\x23\xed\xb8\x06\xe3\x8b\xa6\x83\x92\x72\x97\xab\xda\x4f\x34\xed\x6e\xb1\xec\xc0\xed\x84\xd7\x77\x45\x78\xdd\x98\xf2\xd4\x5c\x3c\x3b\x94\xf8\x2a\x51\x62\x56\x13\xad\x6a\x87\x12\x5f\x25\x4a\x44\xcb\x58\x93\x1d\x4a\x7c\x6d\x28\xb1\x88\x76\x28\xf1\xf5\xa0\x84\x1d\x52\xb0\xa0\x4d\x90\x52\x34\xdf\x57\x55\xbd\xca\x3c\x7f\x04\xe7\x43\x59\x2a\x2a\xcb\xb9\xc5\x8a\x4a\xe8\x07\x2c\x30\x26\xe9\x3a\x92\x5d\x57\x3b\x9a\xe8\x76\xda\xe2\xda\x0d\x4c\x60\x19\xdc\x0f\x1f\x75\xb5\x1d\xb3\xe0\xaf\x41\xef\xbf\xb7\x87\x5e\x84\x21\xc2\xc2\xcd\x85\xa4\x96\x5d\x49\xce\xb4\xb7\x26\xca\xd8\x8c\xa0\x29\x89\x78\x8d\x19\xc9\x32\x3c\x21\x19\xa2\xb1\x8c\x4e\x71\x4e\x22\x96\xcc\x48\x9c\x73\x70\x24\x3e\xa7\x29\x13\x49\xb9\xe0\xb7\x13\x6d\xa5\x17\x93\x45\xde\xe3\x4f\x57\x44\x67\x09\x4b\xf3\xbd\x98\xf5\xc0\x77\x34\x22\x3d\x19\x3a\x41\x44\xf3\x49\x69\xf8\xbb\x1c\x93\xd0\xec\x3c\xbb\x77\x8f\x8e\x51\xbb\x52\xf0\xd9\x32\x82\xcf\x96\x31\x5d\x90\xdb\x2d\xcd\x0b\xe0\xc8\x5b\x45\x2a\x54\x96\x39\xf6\x2d\xde\x55\x4b\x46\xcd\x71\xc6\xe0\x58\x48\xc8\x62\xdb\x50\xa2\xa1\x9c\x97\xb7\xee\x0a\xb5\xba\x90\x10\xab\x48\x2a\xdf\xf2\xa7\xe0\x4f\x74\xf1\x9a\xa0\x1e\x0a\x70\x1c\xb3\x1c\xcd\xe8\x02\x45\x64\x82\x83\x4b\x64\x84\xbf\x60\xd2\x1d\xcc\xd3\x94\xef\xd2\xcf\x6f\x8e\x51\x82\xf3\x9c\xa4\x71\x79\x20\xba\x31\x0e\xc8\x88\xb1\xb3\xbd\x71\xc4\x2e\xf6\x68\x96\xcd\x49\xb6\x77\xf0\xe8\xe0\xe0\x3f\xe0\xef\x80\xcd\xf8\xb0\x7a\x0f\x1f\xee\x1f\x3e\x1c\x3c\x1d\x3c\x75\xe7\xed\xc8\x9c\xc5\x2c\x5d\xfc\xb7\x16\xb3\x6d\xc9\x8b\x64\x50\x62\xfb\x40\xd4\xd7\xb4\x30\xbf\xbe\xa2\x46\xf5\xfa\x6a\xd1\xc4\xab\x01\xc2\x27\xf9\x71\x16\xd6\x7c\xcc\x66\x75\x1f\xd5\x79\xaa\xef\x5d\x9c\xb3\xfa\x3a\x0b\x7f\x4d\x44\x3f\x32\xfd\xca\xd5\x03\x87\x02\x22\xa3\xcf\x9d\xb6\xb5\x9d\x5b\x8a\x19\xfa\x70\x83\x31\x43\x37\x10\x04\x74\x6f\x0f\xa1\x0b\x82\xcf\x84\x03\x70\xf1\xb8\xdb\x87\xb9\xf8\xb5\xad\x49\xe0\xbf\xf0\x8c\xbc\x8a\x7f\x4c\x53\x96\x56\x11\x94\x32\x38\x6d\xf9\x37\xe8\x6f\x3c\xda\x60\x5c\xec\xa5\x65\x0c\xff\x47\xc6\xfa\xb6\xbb\xed\xa2\x88\x05\x22\xcf\x02\x54\xf9\x69\x1e\x45\x90\x27\x57\x87\x04\xe0\x63\xb1\xbf\x9c\xe0\xb1\xca\xd2\xac\x8a\xd0\xa7\x4f\x1a\xbe\x0c\x7f\xe5\x44\xf8\x82\x21\xbc\x57\x35\x3e\x08\x2a\xea\x06\xcc\xff\x46\xd4\xb1\x67\xf4\xa1\x63\x85\xf4\x91\xd3\x8a\xc9\x05\x82\x75\x6a\xb7\x20\xc9\xb6\xca\x7d\x72\xda\x42\x0f\x8a\xa3\x7c\x80\x5a\xa7\x88\x8d\x45\x3e\xa8\x16\xd4\x29\x5b\x73\x51\x6f\x36\xcf\x72\xdb\xd1\x0c\xaa\xdb\xe3\x81\x6a\xfd\x56\x47\x86\x0d\xd0\xd1\x90\xcc\xe0\xe6\x51\x24\xe3\x24\x49\x82\xab\x3f\x59\xbb\xf6\xac\x22\x5a\x6f\x11\x41\x9e\x15\xf0\xff\xe0\x66\xe1\xff\x2e\xa3\xe2\x97\x8c\xe9\x3b\x21\xbc\x38\x67\xfc\x90\xbd\x19\x57\x0c\xe1\x49\x45\xf5\xba\x70\x9a\x6e\x4d\x37\xfc\xe9\x31\x8e\xa2\xe3\x29\x09\xce\xaa\xe6\xfc\xb4\xa2\x7e\xdd\x54\x3d\xc8\x5e\x4c\x53\x88\x73\x5e\xd5\xdd\x70\x50\x56\xbb\xb6\x33\x0b\xa8\xc9\x09\xc9\xb2\x8c\x8e\x22\x72\xcc\xe2\x2c\x4f\xe7\xfc\xf8\xbd\x85\x93\x5b\xd9\xef\x70\x79\xdb\xba\x51\x54\x77\xa8\xe1\xd2\x78\x4a\x52\x9a\x57\x4f\xbd\x58\xb5\xae\x47\x0d\xae\xb3\xcb\xc3\x59\xc4\xbe\x6b\x0d\xd8\xbb\x8b\x52\x7b\x83\xa3\xd4\x6e\x3a\x07\xa8\x0c\x54\x37\x34\x41\x03\xa5\x29\x34\xcd\x72\x40\x09\x08\xac\x16\x93\x42\x04\x3b\x9d\xd0\x53\x87\x33\x34\x25\x26\x37\x68\x4a\x22\x9c\xd3\x73\x37\x7a\x98\x6e\xf1\x97\x0b\xe2\x1d\x4b\x54\x66\x46\x3b\x31\xa6\xd7\xd1\x0f\x2c\xcf\xd9\xac\xac\xa2\xdd\x47\xe8\x26\xf1\xac\xef\xc1\x8e\xf3\xb8\xb4\x17\x1d\xae\x51\xe5\xe3\x9c\x8f\xa6\x04\x87\x76\x54\x42\xbb\xb7\x81\x09\x4b\xb5\xf1\x74\x92\xbb\x68\x3c\xbb\x68\x3c\x5f\x6f\x34\x1e\x3e\x67\xce\x22\xe8\x5c\x8b\xf2\xd8\xa1\x90\x64\x74\x12\xcb\xa5\x3e\x23\x97\x23\x86\xd3\x10\xbc\xbc\x66\x8c\x2f\xa9\x48\x6e\xa8\x12\x60\xaa\x4d\x11\xf0\x21\x46\x00\xcd\x84\x53\x18\xfc\x01\x16\xe9\x7d\xe4\x3c\xe8\x68\x86\xf0\x39\xa6\x11\x44\x1e\xce\x19\xef\x31\x20\x71\x88\xe3\xdc\xc2\x3f\x84\xc1\x47\x4d\xc0\x95\x59\x22\x75\x2e\x3a\x13\xeb\x44\x10\xaa\x3a\xc9\x79\xd5\x02\x14\x26\xae\xa6\x94\x92\x19\x3b\xe7\xb3\x4a\xd9\x4c\xcf\xa8\x90\x42\xf4\x57\x45\x86\x1b\xf7\xfd\x5b\x26\x53\x44\xea\x85\xc8\x19\x4a\x70\x96\x21\x8c\x52\x32\x46\x01\x8e\xa2\x11\x0e\xce\x54\xd0\x68\x40\xf1\x12\x6c\xe5\xe5\x6f\xc9\xb8\xb2\x67\x8e\x83\x65\xe7\xa8\x9c\xe8\x75\x4d\x4e\xcd\xd3\x5f\x68\x96\xbf\xca\xc9\xcc\x4a\xaa\x6b\xd1\xe7\x5b\x4c\x0a\xf5\xd5\xc1\x67\x68\xdf\xf6\xed\x8f\xd0\xee\x5b\x6d\x38\x2b\xae\x7c\x10\x92\x69\xc6\xdb\x88\xc8\x78\xf3\x2e\x2a\xb4\x01\xb9\x88\x86\xc9\x2b\xb5\x9d\x58\xd4\xde\x6b\xc9\xc0\xcb\xa7\x34\xeb\x42\x03\x37\x5e\x21\xb4\xaa\x7e\x7b\xf8\x00\x60\x5c\xfd\x8f\x7c\xd2\x39\xfb\xf8\x91\xb3\x42\x00\xc1\x7b\x16\xba\xf3\xe8\x74\xfa\x90\x2b\x57\xc2\xc0\xe9\x64\xce\xa9\x46\xd6\x31\x36\xc7\x62\xf0\xd6\xd3\xcb\x5f\x89\xf7\x62\x92\x67\xe4\xf2\x08\xb5\x26\x24\x3f\xe6\xf7\xe6\xb1\x38\xa4\x92\xe7\x91\x72\x05\x2b\x2c\xb6\x53\xab\x6d\x04\x41\x0e\x9f\x65\x71\x21\x7c\x7c\x7d\xe9\x26\xc7\x4b\x94\x84\xe6\x99\xe1\x0d\x54\x7c\x7b\x31\x90\x94\xc4\x21\x49\x2b\xfa\x17\x1f\xdb\xae\x0c\xcc\xf7\x4d\xd4\xe5\x89\xe4\x21\xcc\x18\x4c\x6e\x6d\x3b\x2b\xe9\xc7\x52\xff\x45\x54\xe2\xc3\xf8\xb1\xc2\x89\x11\x95\x38\x32\x7e\xac\xf0\x64\x44\xc8\x27\x43\xa6\xb2\x5b\xee\x8c\xc4\x24\x59\xfd\x58\x9e\x65\x55\x2f\xba\x05\x0e\xd2\x1f\x5a\xdf\x35\x41\x30\x75\x74\x91\x5d\x4f\x52\x29\x53\x4b\x16\xd8\x75\x56\xf4\x03\xfc\xb8\x9a\x23\xa0\xbb\x12\x7e\xc2\x54\x91\x9d\xac\x8b\x5a\x7a\xf4\xc2\x5c\x11\x06\x29\x3c\xf8\x0c\x1e\x7c\xb9\x8c\x9d\x62\xfd\xe5\xae\xdc\xbf\xaf\xd3\x6c\xca\x59\xad\xe7\xd9\x27\x6f\xbc\xee\x66\xa0\x99\xed\x37\xc8\xd1\x24\x39\x26\x5a\xd1\xdb\xc2\x3b\x1f\x06\x91\xd6\x73\x00\xe9\xc2\x2b\x7c\x7c\xa4\x31\xf5\x73\xc7\x80\x2c\x41\x69\x2b\x37\x26\x52\x9e\x19\x92\xfc\x88\xec\xb9\x72\x2e\x9c\x32\x3e\xbb\xf7\xb9\xed\xcf\xc9\xb9\x2e\x80\x60\x97\xe8\x85\x6d\x1d\xef\x3c\x02\x12\x26\xa9\xa0\x9f\x74\x4e\xf3\x1f\x26\xe5\x9c\x80\x1a\x58\xd4\xd5\x56\xba\x29\x56\xa9\x24\xd3\x9c\x4e\x0d\x7d\x55\x75\x11\x1f\x00\xa8\x8b\xe4\x95\xe6\xcb\xb8\x0f\xef\x78\x5e\xb8\xeb\x97\x5a\x6f\x55\x08\x7f\xa3\x44\xe2\x3b\x89\x66\xa5\x44\x13\xa7\xb1\xe4\x01\xca\xd6\xe6\xc0\xaf\x58\x2b\xcc\x14\x55\xbe\x46\x69\xa9\xbc\x6e\x36\x25\x94\xfc\x22\x02\x49\x99\x83\xe3\xe1\x23\xed\x8a\x48\xe8\x64\x9a\xdb\x25\x63\x16\xe7\x27\xf4\x4f\xa2\xa4\x73\xf9\x65\xc2\x26\x29\x4e\xa6\x97\xfd\x64\xf1\x8e\xbd\x25\xb3\xf6\xf0\x49\xc7\x15\x58\xbe\x15\x40\x0e\x6c\xc9\x1d\x0d\x58\x5c\xe8\x78\x7f\xe0\x77\x6c\x4a\x1a\x74\xbc\x3f\xe8\x5c\xa7\xc0\xcf\x7e\xfb\xbe\x38\xc7\x39\x4e\x4f\xaf\x2e\x03\xd4\x68\x74\x35\x79\xd0\x55\x5c\x15\xaf\xe2\xa6\xb8\x59\x19\x94\xeb\x9e\x78\xfb\xe4\x91\x82\xaf\x02\x30\x2a\x1c\x12\xca\x20\x87\x97\x36\x76\xcb\x19\x0c\xf8\x52\x04\x47\x92\x82\xaa\x19\x0b\x89\x3a\xdc\x39\xb3\xb1\xeb\xbb\xbd\x7b\x8e\xa4\xe0\x55\x4e\x66\xe2\xab\xb2\xe6\x90\x42\x2e\x71\xd6\xe9\x18\xb5\x95\xd4\x4b\x3e\xcd\x9e\x5b\x8c\x87\x7a\xc6\x36\xf6\xe4\x05\x76\x4e\x5e\x03\x86\x97\x13\xcc\x25\x6a\xbd\x96\x59\x44\x7b\xbf\xbd\x3a\x42\x7f\x77\x87\xf7\x0f\x90\xdb\xd5\xce\x5e\x0c\x50\x4c\xfb\xff\xc5\xe2\xd4\xe7\x0c\xfd\x5d\x02\xe8\x43\x54\xec\x90\x41\x9c\x32\x48\xf8\x45\x73\x34\x8f\x23\x92\x65\xe8\x92\xcd\x11\x4e\xc5\x51\x4d\x59\x14\xa9\x54\xaf\x30\x88\x7f\x48\xc8\x3a\xf6\x6a\xab\x83\x8e\xd0\x39\xa3\x21\x1a\x38\x72\x13\xf7\x59\xab\xe5\x18\xf0\x84\x33\xaf\xdf\xf2\xc7\xef\x66\x62\x11\xad\x1d\xda\xc6\x7a\x9a\x96\xbe\x6e\x55\x4c\x99\xaa\x17\x53\xc4\x62\xfd\x60\xd2\x53\xab\xcf\x0a\x65\x1d\x82\x9a\xc8\x34\x4b\x13\x0e\xba\xcf\x5e\x07\x59\xfd\x87\x5f\x57\x6f\x43\xdf\x5b\x3f\x79\xe1\xa8\xcf\xc7\x9b\x1d\x1a\xbf\xab\x4a\x86\xe6\x8d\xc5\xef\xbb\x23\x44\x4b\x22\x5c\x80\x70\xa1\x77\x8f\x44\x59\x66\xef\x26\xcf\x2c\x0f\xca\x6c\x4e\xa5\x6c\xa1\xe5\x7e\x69\x6d\xe8\x49\x66\x41\x54\x8f\x33\x53\xb4\x25\x73\xbe\x47\x77\xfc\xa9\xb7\xb3\x7e\xda\xe6\x53\x6f\xfc\x0c\xb9\x06\x98\xbb\xe7\xdf\x17\xcd\x40\xfd\x4e\xf3\xea\x55\xf8\x3e\x28\xa9\x5b\xd7\x89\xa9\x75\xd3\xde\x81\xd7\x6b\x35\x73\x5d\x26\x29\xda\x6c\xa4\x35\x40\xc3\x47\xc9\xc2\xca\xb5\x79\x04\xd9\x55\x7b\x70\xff\x95\xe5\xda\xfc\x85\x8c\x73\x65\x8a\xa1\xb3\x6c\xca\x47\x60\x9c\x11\xab\xf3\xa6\xb0\x4a\xec\x42\xbe\x43\x8f\xcb\x3a\xf0\x2c\x51\x9a\x3c\x5e\x1f\x76\x6c\x00\xfc\x7e\x3e\x02\xe9\xfb\xde\x1e\xfa\x35\x25\x99\x74\x4b\xc1\x90\xf7\x9e\x53\xde\x34\xc6\x11\x0a\xe6\x59\xce\x66\xf4\x4f\x30\x97\xd6\x0d\x5f\x56\xf5\xde\x92\xca\xc1\xd6\xa6\x9f\xab\xb7\xe3\x59\x54\x9f\x2d\x47\x71\xda\x17\x2c\x6e\xe5\x3a\xfd\x0d\x09\xd1\xe8\x52\xa4\xf8\x50\xa4\xc4\x4f\x0b\xe2\x26\xf4\x04\x5d\x79\x80\x63\x69\x66\x20\x97\x85\x17\x08\x1d\x1e\xc2\x31\x9a\x1e\x40\x03\x82\x43\xfe\xb8\xc7\xbe\x92\xde\x10\x99\x2b\x24\xff\xd1\xd3\x91\xf6\x01\x34\x0e\x49\x9c\x93\xb0\xaf\x04\x0c\x34\xb3\x52\xfd\x80\x41\x04\x05\x41\x43\x4a\xf8\x93\x29\x66\x28\x22\xe3\x1c\x61\xe0\xb6\x10\x4b\xc5\x4f\xce\x92\x5a\x39\x7f\xc4\x39\xaa\x1d\x23\x7f\xe5\xd1\x19\x4e\x2f\x6f\xb5\x2a\x1e\x1c\xca\x48\xc0\xe2\xf0\xb6\xcf\xc4\x8b\x79\xab\xb8\xea\x77\x64\x91\x97\x3e\xe5\xb7\x1b\x04\xb7\x80\xf1\x56\x6c\x59\xef\x8b\xbe\x12\x04\x3a\xe9\x8a\xf2\xb7\x8e\xfc\xaa\x76\xc9\x04\x80\x55\x25\x3a\x5e\x2e\x47\x5b\x13\x30\x97\xff\xda\x56\x8c\xd7\xc2\x2c\x78\xa1\x1c\x31\xa8\x71\xd5\xd8\x20\xec\x2b\x1f\x49\xeb\x83\x0e\x17\xa7\x94\xda\xce\x0b\xf0\xd9\x6a\x21\x5a\xb7\xad\xdd\x5d\x4f\xf9\x2a\xd6\x5c\x6c\x44\x13\xa5\x6b\x73\x85\xab\xf6\x31\x5d\x57\xc1\x2a\x9f\xf4\x0a\xcb\xee\xdf\x47\xed\x22\x92\x7e\xaf\xbf\x1f\x35\x8c\xb9\x67\xb1\x97\x7e\xdc\x3d\xc3\x6d\xf0\x53\x7a\xa4\x75\xfb\xa0\xfe\x37\x8a\xdc\x26\xb2\x05\x1d\x04\x97\x2c\xf2\x65\x1b\x63\x4b\x1a\x34\xd7\xa0\x76\xb5\xa3\xb8\x1a\xef\xd4\xc1\xaf\x8e\xf2\x08\xd4\x47\xad\x6a\x95\x4c\x8d\x8d\xae\x53\xc0\x22\x96\x1e\x39\xa7\xc7\x5f\xc3\x11\x0b\x2f\x87\x37\x67\xf9\xf4\x48\xe5\x02\xde\x03\x55\xbc\x25\x9a\xe1\xf4\xf7\xfa\xa3\x1c\xde\x99\x90\x75\x65\x74\xb6\x86\x2d\x69\x1c\xb6\x0d\x28\xf2\x46\x40\x19\xa2\x7f\x8b\x99\x87\xc6\x31\x87\xac\x6b\xed\x76\x4f\xd7\x0e\x8b\xe0\x9c\xd5\x12\x33\x98\x12\xf6\x5d\xdb\xbf\x68\x26\x58\x97\x58\xec\xa4\x2e\x93\x0c\xb5\x31\x8e\x71\xba\x5c\x53\x6e\xbb\x29\x59\x2c\x1f\x83\x23\x89\xe5\x05\x5b\x92\xc3\x3e\xde\xb9\x95\x7e\x55\x16\x2d\x77\x40\xe2\x78\x93\x84\x81\x77\xc1\x28\x44\x9b\x62\x1c\x94\x5a\x75\x94\x0a\xe3\xb4\x47\x97\x32\xec\x38\x30\x69\x54\x80\x65\x14\xad\x12\x1c\x91\x3c\x27\x7d\x0c\xc3\x82\x7f\xce\xf5\x93\x74\x1c\x91\xc5\xc9\x34\xa5\xf1\xd9\x35\x3b\x72\xd9\x76\x1d\xaf\x02\x16\x9f\x76\xd1\xe9\xc9\xf9\x44\xfc\x29\x9a\x83\x2b\xd0\xe9\x4c\xe9\xbb\xe7\xb4\x47\x03\x16\x67\xa7\xe8\xe4\xdf\xff\x04\xd9\xcc\x26\xdd\xc2\x76\x26\x21\x77\xd5\x24\xe4\x45\xa5\x3d\x04\x38\xd3\x9c\x5a\x36\x20\x38\x96\xc8\xc8\x71\x4f\xa3\x63\x85\x45\x08\xff\xe6\x27\x50\xda\x59\x30\xac\x67\xc1\xe0\xd9\x27\x34\xb4\x47\x28\xea\xfe\x37\xc5\xfd\xf1\xbd\x75\xb8\x3f\x5e\x50\x62\x2c\xfd\xe4\x8e\x6b\xd0\xaf\x5f\xc9\x7d\x6d\x7a\xe5\x1d\x13\xb6\xd3\xc8\x1a\x7f\x76\xe3\xd0\x8f\x47\x19\x8b\xe6\xb9\x89\x07\x90\x4a\xc3\x5a\xf5\x3b\x67\xc9\x11\x6a\x1d\x0e\xfe\xd3\x8b\x18\x00\xce\xf0\xbd\x52\x4e\xed\xe1\x17\xe2\xac\xd4\x7d\xf6\xc3\x3c\xcf\xe5\xad\x96\x91\x48\x66\xd5\x92\x66\x7c\x3b\x8f\xfa\x1b\xc2\xae\x14\x18\x8c\x13\x25\x33\x79\xa1\x69\xff\x56\x78\x8d\x22\x9f\x51\xcf\x04\xd4\xea\x21\xfe\xba\xd2\x85\xdf\x51\x42\x64\xcb\x93\xcb\x15\x1d\x7b\x8b\xf2\x85\x72\xe5\xdc\x85\x93\x72\x1b\xc4\xe1\x65\x02\x49\x1f\x03\x4a\x4c\x33\xbd\x2a\x9b\xb4\xd1\xf4\x41\xdb\x4c\xa2\xf7\x6d\x4b\xd2\xc2\xa7\x77\x9c\xe7\xdc\x59\x6d\xde\x01\xab\xcd\x3b\xc0\x5d\x43\x43\x11\x0b\xb9\x72\x12\x07\x37\x8d\x0d\xff\x92\x91\xbb\xbe\x8a\x97\xc2\x88\x2d\x4e\xe8\x9f\xc2\x4a\x73\xc4\xd2\x90\xa4\xbd\x11\x5b\x58\x51\xc5\x62\xf2\xb3\x94\xe5\xb6\x0e\x9e\x24\x8b\xe5\xf1\xc6\x96\x5b\x5d\xfa\xa1\xbb\x1a\x09\x85\x4b\x65\xc0\x60\x59\x53\x30\x11\x1a\xb3\x38\xff\x09\xcf\x68\x74\x59\x62\xb3\x69\x3e\xda\xd5\x7f\x27\xf6\x18\xbc\xea\xe2\xe3\x6b\x12\xd2\xf9\x6c\x05\xcf\xc2\x52\x58\xbc\x8d\x63\x2c\x0a\xf3\xfa\x55\x29\x18\xff\xaa\x9b\xad\x54\x43\xbe\x3f\x1c\x0c\x3e\x14\x40\xbc\x12\xd6\xa1\x05\x10\x9e\xd9\x68\xa9\x0d\xed\xf2\x2d\x7b\x6a\xb7\xce\x72\x1a\x9c\x5d\x96\xbe\x36\xc5\xa7\x96\xf3\xb6\xd4\xde\x98\x7f\xbe\x8a\x43\xb2\x38\x42\x43\x55\x30\xc2\xc1\xd9\x04\x92\x32\x1d\x97\x0e\x76\x17\x83\xed\x2b\x79\x31\x5e\x7f\x0c\x36\xe8\x44\x31\xcf\xc0\xd4\x09\x5f\xc3\xd3\x91\x90\x2d\x7c\x85\x91\xda\xc4\xb2\x47\x2c\x2d\x9e\x10\xe1\x87\x3a\xcf\x94\x8b\x24\xd0\x08\x24\xe9\x12\xba\x98\x92\x58\x98\x4e\xcf\xf0\x19\xc9\x50\x46\xe2\x8c\xd8\x0b\x08\x67\xbb\x3e\x95\x45\x4b\xee\x85\x67\x62\xa9\xe8\xc1\x87\xea\xa8\x72\x7c\x3c\x10\x63\xeb\x44\x87\x09\x02\xb3\xe9\x98\xe5\x82\x52\xa9\xe0\x66\x39\x4b\x50\x38\x07\x34\xc9\x82\x94\x45\x51\x21\xc0\xda\x89\x24\x6c\xeb\xda\x6d\x97\x0d\xa3\x60\xbd\xdd\xcc\xf6\xba\x44\x86\xa2\x01\xfb\x92\x93\x52\x0b\xdf\xeb\xd1\xdc\xf8\xe1\xa3\x2a\xa2\x47\x09\xb4\x32\x9f\x23\x96\x7a\x46\xc4\x62\xe9\x7d\x03\x62\x51\xba\x4d\xd3\xdf\x65\x1a\x24\x3f\xc2\x13\x8c\xdd\x32\x0e\x3e\x91\x17\x9e\x6d\x00\xfc\xa5\x6d\x7c\xdf\xcb\x51\xa2\x07\xa2\xb1\x64\xfa\xfb\x01\x4e\x68\x8e\x23\xfa\x27\xf9\x89\xa6\x59\xfe\x0b\x3f\xbc\x69\xa7\x0d\x95\x3b\x1f\xba\x72\x97\x20\x9a\xbe\x3a\x8d\x1b\xb1\x10\x5e\x27\xc0\x93\xd8\x78\x1d\x2d\x4a\x2c\xf3\x66\xad\x8d\x4b\x42\x3b\x5d\xc9\xea\xb8\x54\xc6\xa7\x0f\xed\x2e\x0b\xf6\xba\x76\x04\xbb\x2c\xd8\x3b\x19\xea\x2e\x0b\xf6\x3a\x59\xb0\xc5\x55\x75\x45\xc6\x6b\x45\x2b\x6e\x7d\x21\x5e\x9b\x05\xb7\x2f\x54\x37\x24\x77\x49\xb4\xbb\x88\xca\x84\x66\xe2\xed\xa9\x17\xa2\xc8\x10\xd6\xdb\xf8\x9a\x0e\x3d\xd9\xbd\xfe\xb0\x29\x89\xbd\x01\xa8\xe4\xf4\xba\x64\x2b\xd2\xf9\x47\x83\xc1\x4e\x3a\x7f\x47\x4c\x7f\x77\xf9\x5d\x76\xf9\x5d\x6e\x5e\x7e\x17\xf8\xf5\x92\xcd\xaa\x34\x12\x4f\x0b\x35\x97\xc2\x7e\xc9\x66\xd7\x12\xa7\x50\x66\xc6\xab\x52\xa6\x0c\xf7\x9f\x14\xaa\xd6\x6a\x84\x64\x1d\x4b\x57\x37\x62\xf3\x38\xa8\x52\x2e\x1c\xee\x17\x6a\xd6\x81\x57\x75\xdc\xf5\xfc\xf1\x9c\xc4\x39\xbf\x47\x48\x2c\xc2\x2b\x97\xd1\xc0\x87\x35\x6d\x96\xee\x86\x53\xfb\x5a\x75\x5d\xaf\x59\x88\xa3\xca\xcd\x79\xec\xd6\xab\x83\x0d\x15\x74\xf5\x7f\xa6\xec\xa2\x6a\xd0\x83\xa1\x53\xad\x0e\x28\xff\xae\x2b\xff\x8a\x93\xca\xe5\x3f\x3c\x70\xab\xd5\x01\x85\x0a\x37\x4d\x87\x77\x6d\x0a\xb2\xbd\x3d\xf4\x5f\x92\x6c\x91\x50\xbf\xee\x11\x6c\xdf\x4a\x23\x7e\x97\xe2\x58\xa8\x34\x8e\xb5\x94\xac\x94\x3a\x0d\x1a\x8f\xbf\x08\x72\x83\x2a\x48\x0b\xb8\x4a\xe8\xb0\xc9\x01\x2b\x98\xcb\x46\x6c\x07\xdc\x7f\x33\x1e\x67\x24\x7f\x07\x59\x25\x83\xdc\xa4\xbe\x30\x52\x4b\x06\x35\xd0\x73\x34\x00\xb9\x8d\x95\xdf\x51\xa7\xc9\x80\xf7\x57\x3c\x9f\x8d\x48\xda\x52\x61\x07\x75\x33\x55\x0b\x42\xee\x21\x12\x65\x04\x60\xb8\x8d\x03\xc2\xd1\xbf\xd8\x98\x0f\xaa\x2f\x9c\x54\xd0\x1e\xda\xaf\x85\x31\x82\xcc\x42\xb5\x30\x74\xd8\x3f\x75\xa0\xa0\x0e\x08\x81\x8a\x8b\xf2\x0b\x19\xe7\x72\x55\xa6\x2c\xa5\x7f\x72\xba\xdf\x68\x5d\x4c\xed\xfa\x95\x31\xf5\xbc\x79\xf9\x00\x6a\x57\x07\xbc\x70\x4a\x16\xc7\x07\x02\xf6\xa4\x75\x30\x1a\x2e\x0e\x20\xdc\x98\xa5\xb3\x37\x29\x9d\xd0\xf8\xdf\x9c\x95\x6f\xe7\x6e\xa1\xa3\xce\x7e\xef\x7d\xec\x9b\x91\x75\x91\xff\x4d\x6d\xe9\x87\xfe\x0c\x27\x6d\x93\x8c\x23\xf6\x12\x9d\xca\xa5\x8e\x9d\x15\x46\xdf\xa3\x18\x3d\x40\xad\x64\xd1\x42\x47\x48\x04\x79\xec\xf4\xff\x60\x34\x6e\xb7\x50\x4b\x08\xfb\xf6\xf6\xd0\xc9\x5c\x24\x6f\x11\xda\x85\x77\x2c\x41\x23\x92\x5f\x10\x12\xa3\xfc\x82\x29\x6d\x54\xd6\x77\x66\x7d\x02\x75\x7f\xc5\x29\x89\xf3\x76\x02\xff\x48\x0f\x01\x83\x11\x44\x3b\x84\xc1\x07\x15\x61\xc2\x74\xa3\x70\xe5\x62\x4a\x23\x82\xda\xaa\xfe\xfd\xfb\xba\xe9\x37\xcf\x9f\x23\x01\x5d\xcd\xd7\x00\x95\x7f\xf5\xc5\x77\x4e\x68\x45\x80\x4b\x03\xff\x81\xa9\xa4\x0b\xc5\xae\xea\x75\xb3\xca\x3f\x2f\xb3\x54\xe0\x03\x48\xf8\x4d\xa5\x54\xc8\xd5\xe6\xca\xec\x9c\xa4\xe3\x88\x5d\xfc\x0f\xff\x64\x62\x4b\xa9\xe2\xff\x7b\x84\x5a\x22\xcf\xb8\xfc\xc0\x77\x81\xa1\x0b\x82\x32\x02\x5a\x2a\x94\xb0\x84\x57\x16\x3a\x2a\x9a\xb7\x32\x44\x66\x49\x7e\xd9\x57\xb5\x41\xb1\x35\x63\x59\x8e\x22\x7a\x46\xa2\x4b\xc4\x62\x04\x09\xa6\xf9\x1f\xf3\x8c\xa4\x11\x8e\x85\xe2\x06\xcd\x68\xfc\xbb\xf0\x4c\x1b\xca\xc8\xc6\x33\x1a\x2b\xe3\x08\x5d\x84\x17\xb2\x52\x2b\xc0\x51\xd0\x1e\x0e\x06\xe7\x17\xa8\x87\x1e\xee\x27\x8b\x4e\x4b\xd7\xd1\x36\x15\xba\xd2\xd4\xab\xd4\xba\x7f\x34\x66\xc1\x3c\xb3\x22\x5a\xb1\x79\x1e\xd1\x58\x1b\x5c\x18\x1d\xf9\xaa\x2a\x72\x71\x26\xe4\x4e\x98\x53\x53\xaf\xa3\xe3\x30\xda\xef\x97\x08\x93\x22\x32\x06\x65\xdd\x32\xa1\x93\xa4\x3c\x0d\x6a\x0a\xf2\x52\x53\x51\x9c\xd1\x0f\xbe\x3c\x56\x1d\xf8\x0d\x4c\x2a\x67\xc9\x66\xe7\x24\x6f\x94\xd5\x26\xc5\x37\x79\x15\x33\x08\x79\xa6\xe4\x2e\x83\x25\x46\x6d\x67\xde\xfa\x45\x60\x0c\xd2\xb4\xc5\xaa\x83\x2b\xb7\xd1\xa0\x19\xa2\x90\x82\xcb\x51\xdf\x4b\xcd\xf2\xa5\x0a\x75\x25\x6a\xe7\x0c\xf1\x8b\x46\x9c\x71\x39\x55\xa9\xb7\x96\x67\xde\xa8\x5b\x71\x1c\x4c\x59\xfa\x63\xa4\x65\xf3\x3f\xbf\x7b\xfd\x4b\xa5\x87\x64\xc5\x9c\x55\x94\xb0\x37\xe3\xb6\xd5\xbc\x53\x2d\xe0\xc5\xf1\xa5\xaf\x60\x37\x13\xd4\x63\xbe\xda\xec\xa4\xd2\x9e\xa5\x21\x8d\x71\x4e\x32\x08\x68\xac\x72\x38\xa2\x9c\xdd\xd3\x39\xd2\xc0\xda\x43\xa4\xe6\x6e\x65\x28\x88\x28\x9f\x3b\x4e\x09\xf6\x97\xe9\x57\x4d\x8c\x6b\x05\xd7\x82\x28\xad\x8c\x56\x2b\x23\x16\x02\x59\x24\x2c\xa3\xb5\x8a\x21\xc9\x49\x3a\xa3\x31\xc9\xf8\xa5\x17\x4c\xe5\xd8\x41\x35\xcc\x17\x2f\x25\x63\xe1\x19\x29\x16\xd2\x2c\x43\x43\x5c\x79\xcb\xdb\x93\x38\xa8\x36\x5c\x51\x67\x59\xe1\x56\xab\x8b\x5a\xee\x02\x16\x8c\x16\xdc\xfd\xa7\x71\x8e\x60\xff\x89\x1a\xfc\x05\xc4\x6f\xb3\x46\xd5\xca\x44\xc3\x53\xd5\xc9\xa9\xb0\x29\xc0\x79\x8e\x83\x29\xca\x59\x5f\xc3\x8c\x99\xb4\x94\x91\xc6\x18\x32\x8b\x9d\x37\x1b\x5e\xd3\x1f\xa5\x98\xba\xa8\xfe\x26\xe1\x45\xd9\x91\xf8\x65\x48\xe8\xfb\x1c\x1c\x17\x81\xc0\x75\x91\x20\x5f\x1f\x9e\x89\x5a\xf6\xfd\xf1\x9e\x6f\xae\xa9\x08\xb4\xfb\x83\xbf\xb6\xe2\xf6\x69\x84\x5e\x77\xf4\x6e\xba\x8b\xb7\x93\x75\x4e\x6f\x87\xcd\xdd\x5a\x2a\x69\xbf\x61\x63\x5d\xf4\xa6\x35\xb5\x37\xc4\xa3\x9d\xef\x31\x89\xc8\x39\xae\xa5\xa9\xba\xc6\x12\xba\x5f\x42\x2e\xf5\x5b\x89\x66\x90\xad\x92\x84\x88\xc6\x08\x0c\x95\x05\x9d\xcf\x53\x4a\xce\x89\xc4\x2e\x81\x6c\x92\x9c\xaa\x27\x8b\x34\xd5\xe2\x8c\x3e\xaf\xc5\x12\xb8\x03\x88\x1a\xad\x45\x5c\x75\xb0\xff\x22\x02\xbb\x30\xad\xe0\x9b\x38\xd6\x85\x34\xce\x68\x48\x4a\x2e\x69\x69\x3d\xa7\x96\x3e\xe5\x6f\xe3\xe8\x52\xbe\x99\x20\x71\x69\xf3\xcb\x5e\xd5\x00\x33\xb6\x3c\xc5\x39\x99\x5c\x22\xbe\x08\xe0\xf1\x3f\xc3\x67\x75\x6b\x81\xfe\x98\x67\x39\xc2\x23\x26\x56\xcc\xbe\x23\xdc\xe5\xe2\xbb\x36\x21\xf9\xb1\x80\xf2\x42\xf3\x4f\x15\xdb\x57\xcc\xff\x79\x92\x90\x80\x8e\xf9\xa8\xa6\xec\x02\x05\x11\xcb\x88\xb2\xc3\x23\xe1\x44\x2f\xfe\x05\x8d\x43\x76\xe1\xbc\xd4\x02\x1c\x73\x4c\x25\xd8\x42\x20\xe9\x91\x3a\x4d\x49\x36\x65\x51\xb8\x12\x1a\x69\xf1\xd5\x18\x4e\xec\x88\x8c\x59\x4a\x5c\x6a\xc4\x91\x0b\xc8\x23\x8d\x27\xa6\x53\x16\xff\xc8\xcb\x56\x25\x4c\x65\xc2\xb8\x35\xc9\x54\x09\xa8\xcd\x90\x90\x22\xe0\x4e\xed\xa2\x29\xa6\xa2\xe1\x92\x81\x3b\xc1\x6e\xd5\x4a\x56\x6d\x8a\xe5\xb2\xd9\xd6\xa0\x72\xd5\x48\xb8\x5b\xb4\x9a\xf3\xb9\xa0\xb9\x8f\x6b\x0b\xba\xb2\x5d\xdb\x5d\x5c\xb2\x8a\xd3\x59\xbe\x60\xbb\xb3\x59\x7b\x36\x17\x34\xf7\x8e\x26\x94\xec\x96\xac\x74\xc9\x78\xe7\x24\xcb\x81\xf5\x18\x11\x71\xcd\x87\xf6\x83\xf2\xbf\x12\x9c\xe2\x19\xfa\x4b\xf0\x8e\x9f\x11\x39\xe7\xcd\x80\x6b\x84\xbf\x32\x36\x4f\x03\xcd\x0d\xa8\x74\xe4\xf6\xfa\xbf\x15\x5d\x1c\x73\xd0\x2b\xf0\x1f\x9e\x65\xbe\x62\x2e\x68\x86\xce\x29\x58\x52\x58\x7d\x24\xa4\x9a\x31\x1d\x31\x16\x55\xf2\xda\xc6\xcc\xc6\xe6\xad\x81\xa9\x04\x4d\xec\x69\x91\xa9\x82\x72\x10\x7f\x5d\xc9\xb1\x26\x65\xd1\xaa\x3e\x35\x15\xb2\x07\x23\x20\xa7\xc1\x54\xd4\x75\x65\x0c\x96\x84\xa2\x95\x21\x26\xd4\x29\x6b\xca\x0c\xba\x68\xd1\x4e\x16\x9d\xa6\xa2\x03\x55\xdd\x2c\x9f\xa7\xd6\xd9\x09\x11\xbe\x06\x21\x02\x8e\xe9\x4c\x3c\x30\x2d\xe7\x08\xef\xc0\x19\x9a\x84\x33\x44\x73\xc1\x64\x71\x74\x05\x92\x9e\xd9\x89\x13\xd4\x2b\x4f\x38\x7c\x85\x94\xbf\xc6\xd0\x88\xc6\xa1\x74\x20\x7b\x7f\x7a\x7c\x72\x62\x88\xa3\x71\x7a\xc9\x4e\x3f\xb4\xa7\x79\x9e\x64\x47\x7b\x7b\x60\xdb\x12\xb0\xd9\x6c\x1e\xd3\xfc\xb2\xcf\xd2\x89\x28\xea\xe5\xba\x61\x6f\x92\xb2\x79\xb2\xf7\x1f\x0e\xb4\x1e\xef\xbd\x67\x39\x31\x78\xb8\x6d\x9b\x08\x5c\xe1\xd2\x51\x66\x0b\x57\xbf\x73\x24\xa4\x8d\x5f\x39\x02\xae\xb7\xdb\x27\x04\x12\xa5\x08\x55\x1f\x44\xb0\x9b\xe7\x8c\xef\x7d\x00\xf1\x7f\x02\x1c\x05\xf3\x08\xe7\xc4\x5a\x2b\x94\xd3\x19\x41\x23\xcc\x5f\xd7\x2c\x96\x81\x27\xcb\x16\xf5\xe5\x3c\xad\x97\x41\x2c\x3f\x2d\xf2\x79\xd9\x84\xe8\x10\xf1\x74\x5c\xf2\x4e\x85\x9a\xc0\xc5\xd6\x56\x14\xe7\x62\xa9\x24\x9a\x2f\xda\x87\xce\x87\x8e\x56\x07\xfe\x2a\x69\xbb\xe5\x1c\xde\xfe\x08\x7b\xf3\xad\x49\x0d\x0e\x4a\x18\x30\x45\xd6\x66\x81\xc6\x10\x59\x42\xe8\xa2\x42\x33\x50\x38\x6b\xb0\xb2\x5e\x5b\x69\x97\x75\x74\x86\x7b\xe6\x67\x4e\x66\x49\x17\x7d\xcc\xa7\x34\x03\xa3\xed\x5c\x7e\x34\xbe\x51\xc6\xfa\xd3\x8c\x40\x54\x97\xf0\x55\x16\xf7\x31\x4b\x51\x1b\x80\x46\xe0\xe2\x86\xd3\xc9\x5c\x28\xd7\x23\x12\x4f\xf2\x69\x97\x97\x64\xe8\x39\x7a\x91\xa6\xf8\xb2\xcd\x6b\xf1\xf5\x3b\x23\x97\xa0\x2b\x17\x7f\xfd\x1d\x5a\x8b\x1f\x0f\x1e\x74\xb4\x9a\x95\x37\x7d\xcf\x0b\x3f\xd8\x90\x45\x89\xca\xc0\x6e\x9b\x0c\xf0\xa9\xa0\xe7\xa8\x0d\x13\x14\x7f\x70\x32\x23\xed\xbb\xab\xcd\x3d\xfd\x39\x2a\x67\x1f\x39\xd7\xfe\x47\x7e\x6e\x72\xf6\xf1\x23\xfa\xf4\x49\xc0\xf2\x6c\x72\x0b\xdb\xd4\xe9\x80\x99\x77\x1f\xc2\x41\x4a\x23\xfa\xf7\x1c\xf8\x87\x7e\xc0\xe2\x00\xe7\x6d\x3e\xb7\x0e\x84\xc6\xe6\xc5\xea\x5f\xe3\xb0\xf7\x3b\x8d\xa2\xdf\xe2\x19\x9b\x83\x65\x80\xc1\x1a\xb3\x3a\xa2\xc1\x14\xc7\x61\x44\xde\x92\x8c\xfe\x49\xfa\x01\x8e\x03\x12\xb5\x55\x7a\x7a\x05\x34\x23\xf9\xaf\x46\x58\x75\x52\x88\x53\xa0\xec\x14\x0c\x6c\x3a\x2e\x33\x5e\x10\x86\x03\x1d\x2b\x85\x00\xdf\x79\x5b\x0e\xf6\x5c\xf6\x38\x29\xf6\xa8\x3b\xd1\xf9\xff\x91\x0b\xb7\x9f\x0b\xc7\x45\xd3\x8e\x97\x3c\xab\xa8\x0c\x79\x74\xdc\xda\xbc\xa8\xaa\xba\xc7\xae\xf8\xfd\xb8\x5f\x15\x90\xcf\xee\x32\xfe\xff\xec\xbd\xfd\x7f\xdb\x36\xf2\x20\xfc\xbb\xff\x0a\xb4\xcf\x6e\x28\x35\x92\xac\x57\xbf\xc8\x75\x7b\x49\xda\xee\xe6\x73\xed\xa6\x4f\x92\xdd\xbd\x7b\xb2\xb9\x18\x22\x41\x9b\x1b\x8a\xd4\x91\x94\x5f\x9a\xf8\x7f\x7f\x3e\x18\xbc\x83\x20\x45\xc9\x52\xe2\x26\xee\x7d\x6f\x63\x81\x83\xc1\x00\x18\x00\x83\x99\xc1\x8c\xa3\x53\xf5\xa3\x48\x47\xc7\x52\x98\xc9\x11\x62\x4f\x27\xad\xaf\x72\x68\xf6\xf7\x11\x2c\x3f\x9e\x4c\x88\x7b\x8c\xc0\xc5\x88\x4b\xfa\x24\xe0\xa2\x20\x1d\xf6\x34\x41\x38\x41\x51\x92\x90\x4c\xea\x1b\x93\x34\x20\x7b\x1a\x21\xbe\xae\x41\x7c\x21\x9c\x83\x64\xcf\x9e\x95\x3f\x6b\x33\x26\xa9\xfa\x1b\x57\x8f\x72\xef\xa2\x34\x14\x37\x06\x45\x0c\xaf\xa5\x35\x8d\x2b\xda\x34\x1a\x73\xd0\xa7\x58\x45\x38\xdf\xbc\x24\xe0\xf8\xac\x18\x90\x47\x28\x16\x93\xcd\xac\xa9\xe0\xf7\xa1\x92\x56\x88\x10\xc8\x26\x10\x73\xfc\x10\x33\xed\xe8\xa2\x64\x0a\x2e\x6a\x9b\xd2\xba\x54\x35\x17\x39\x89\x43\x8d\xcc\x32\xa7\xc9\xfe\x5a\x8e\x55\x2d\xd1\xa3\x8e\x6b\x72\xda\x06\x33\xc8\xf3\x56\xb4\xab\xb1\xaf\xde\x38\x2c\x21\x7d\xbc\x61\x55\x75\x2b\xbd\xb0\x4e\xb4\xca\x7c\x49\x19\xb5\xa1\xac\x5c\xdd\x74\x6c\x13\x08\x98\xa8\x89\x4e\x81\x8c\xc7\x72\xc2\x34\xd7\x3c\x01\x09\xa2\x36\x3a\x65\x4d\x6a\x90\xdc\x4d\x4d\x75\xfc\xdf\x42\x2d\xcd\x57\x48\x8e\x0a\xfc\x9e\x72\x59\x26\x0c\x3f\x6c\x09\xa1\x28\xa1\x42\x8a\xef\xd3\x0d\x53\x6b\x88\x35\xad\x2f\x3f\xa6\xe8\xee\xc1\x62\x61\x3c\x80\xba\xf6\x2a\xd5\x49\x05\x92\xaa\x10\x00\xa7\xb9\xea\x57\xac\x63\xe9\xcf\x88\xaf\xa3\x1c\xd2\x20\xe7\x28\xbf\x88\xc2\x42\x4d\x23\xb8\x19\xa6\x0b\xf4\xbd\x8d\xd4\xde\x77\x83\x28\x0c\xf9\x58\x57\x76\x00\xb1\xcf\xa7\x00\xac\x15\x56\x70\x03\x7a\x6c\x42\x6a\xce\x86\x7c\x6e\x7f\xb0\x47\xd4\xa6\xea\x1d\x27\x8b\xc3\x77\x6d\xf8\x12\x65\xef\x9a\x93\x66\x80\xde\x8a\x31\xbe\x63\xfa\x6b\x8b\x4b\xd1\xf7\x25\x9e\xf9\xf8\x11\x7d\x63\x43\xd1\x32\x0b\xae\x83\xde\x98\x39\xb4\x0d\x5b\x8a\xae\x10\x2c\xd2\x14\x15\x54\x3c\xf0\x3a\xc8\x7b\x95\x42\x00\x87\x0c\x36\xd3\x88\x25\xbd\x4b\x52\x48\x9d\x97\x13\x92\x88\xfd\x26\xf7\x33\xfa\xab\x05\x6f\xc9\x6d\x6a\x4a\xa3\xdc\x66\x4e\x92\x6d\x68\xe1\xf7\x98\xe0\x1c\x0c\x51\x79\x04\xa9\xf3\x20\xc6\x0c\x0b\x81\x7e\xdd\x65\x35\xcf\xa8\x8c\x1f\xcd\x17\x19\x37\x48\x81\xc7\x5d\x97\x5c\x2f\x48\x16\x91\xc4\x27\x3d\xef\x2d\x77\xb3\xfc\x4f\xe2\xb5\xf5\x0c\xdc\x15\x9c\xae\x39\xa7\xd6\xf3\x3a\x6c\x01\x2b\x99\x1d\xa6\x7e\x28\x76\x8c\x1a\x7e\x67\xdf\x39\xaf\x0c\xab\xf9\x4a\xa3\xef\xb1\x0d\xad\xb1\x3d\xdb\xa8\x7e\xb0\x76\x01\x27\x75\x23\x74\xca\xf7\xb5\xae\x05\x5e\x41\xdd\x68\x2d\xea\x46\x25\xc6\x37\x82\x49\x21\xe1\x03\xc4\xf6\x5e\x4f\x0b\x10\x25\x3c\x7d\xf8\x66\x6b\x7e\x2a\xe9\x71\x9a\x3a\x00\x9b\x27\xa7\x14\x92\xd4\x35\xef\xe7\x58\x7f\xe6\xd7\x31\xe4\xd5\xbf\x69\x7e\xe9\xe8\xd4\x70\x53\xaf\x00\xfc\x95\x1d\x4e\x86\xef\xb6\x09\x0a\xa6\x9b\xd5\x62\xad\x2e\x7e\x71\x7b\x8f\x3e\x9d\x8e\xcf\x25\x39\x48\xce\x40\xb5\x78\x6d\xd5\xb9\xed\x38\xc4\x75\x71\x31\x91\x8f\x86\xb4\x9c\xfc\x0e\x79\xdf\x74\x40\x56\xaf\xb0\x64\x64\x85\x30\x4a\x82\x9f\x5e\xfc\xf6\x8f\x34\x20\xad\xf2\x64\x48\xea\xd7\x21\x7a\x70\x70\x00\x57\x13\x32\x5f\x88\xa7\xc2\x4d\xae\x51\xda\xd5\xb2\x2d\x9d\xce\xd9\xed\x52\x7b\xeb\xe7\xb8\xdc\xbe\x61\x9d\x7d\x4f\x6e\xa6\xc8\xb3\x24\x44\xaf\xb3\xc7\xc6\x7d\x7f\x1f\xb1\x16\x73\x11\x4d\x66\x1f\x58\x5b\xc9\xa4\xba\x01\x5f\x54\xa1\xe2\x81\xd4\xa4\x9a\xee\x5e\x62\x54\x5b\x29\x95\x61\x82\x1b\xca\x27\x49\x9a\x80\x93\x16\xdd\x11\xa3\x80\x04\x6d\x7e\x7d\x86\x67\xad\xba\xdf\xf8\x4a\x21\x56\x4e\xe0\xfe\x3e\xfa\xcb\x2f\x71\x7a\xf5\x4b\x74\xfd\x1b\xd1\x26\x15\xb4\x32\xf4\x42\xa6\x58\x4f\xad\x4f\xe5\x33\x49\x27\x9d\xf1\xa5\x28\x29\x43\x29\x99\x53\x87\x64\xa5\x65\x68\xe5\x8d\x66\x55\x90\x1f\xca\x75\x34\x6f\x56\xa3\x8a\x28\x3f\xd9\xdb\xd3\x16\x5b\xa9\x9d\xd3\xd3\x92\xdb\x9b\xbe\xfa\xf8\x96\x66\xa3\xb4\x96\x9d\xba\x53\xa8\x0c\x2d\x72\x94\x3e\x7e\x44\x41\xea\x83\xaa\xa0\x47\x27\xf3\xa4\x54\x89\x5f\x22\x0c\x0c\x54\x3c\x7f\x9a\x2e\x41\xf5\xf8\x0c\xee\x07\x14\xaa\xd5\x2e\xd7\xfe\x97\x7c\x92\xe2\xbe\x52\x9d\x9e\xa2\x3e\xfa\xd1\x98\x0f\x25\xc4\x4c\xe5\x53\x8f\x93\xfa\x5d\x5c\x51\xda\x63\x1b\x7a\xc5\xe6\xd9\x52\x80\x1d\x8b\xc0\xb6\xbd\xff\x6b\x38\xf9\x51\x50\xb5\xd1\x3a\xb0\x96\x0e\x26\xfb\x00\x70\xae\x4d\xd9\x71\xb5\x36\xcd\x5b\x2a\xe4\xc6\x80\x45\x68\x5d\xb9\x12\xca\x3f\x62\xf1\xed\xb1\x84\x0c\xd6\xe6\xe0\xb8\xb2\xf2\x83\xcd\xb1\x4c\xeb\xee\xb7\xc6\x16\xcb\xb8\x7a\x58\xb9\x1c\xcb\xce\x38\x72\x29\x0c\x4b\x17\x69\xd7\x1a\x2d\xaf\xba\xa1\xbd\xec\x4e\x56\x5f\xdc\x95\xe4\x45\xd7\x99\x83\xa8\x47\x8f\xca\xed\xa9\xd5\xf7\x73\xec\xd9\x42\x8c\x5f\xea\x55\x19\xab\x4b\x89\x43\xdb\xb7\xeb\x3e\x7a\xc4\xb7\x7b\xf1\xdc\xd6\x94\xb7\xd9\xdb\x1a\xb3\x4e\x5b\xa7\xa7\xfc\xae\xc6\x7e\xa1\x53\x89\xe6\x44\x43\xe2\x1e\x3a\xab\x46\x2f\x95\x92\xc8\xe3\xd2\x37\x5d\x57\x80\xf6\xd1\x10\x75\x35\xaa\x3e\x7e\xa4\xd3\x20\x1a\xbb\x55\x43\xb2\xbf\x8f\xbe\x39\x05\x8e\x36\x02\xdb\xc9\xef\x77\xbc\xb2\x68\x22\x8a\x7b\x9b\x81\x89\x2e\xd2\x85\x57\xba\x93\xdc\xa4\x4b\x79\xc3\xf0\x2f\x70\x72\x4e\x0c\x32\xcf\x9c\xf8\xce\x78\x5c\x3e\xb0\x3b\xe3\x38\x4f\x11\x8b\x51\x42\x17\xa7\x08\x44\x77\x56\x66\x16\xe5\xc6\x27\x6c\x43\xa5\xdb\x10\xdc\x4f\x5e\x24\xf1\x0d\x04\x0b\xa4\x47\x2e\x3f\xbd\x8b\xab\x54\xd4\x8e\x58\x24\xb0\x57\xa4\x70\x37\x52\xa4\x28\x59\xc6\xb1\x4c\xae\x5d\xd5\x87\x65\xc2\x3a\x1c\x88\xab\x8c\x71\x8d\xb1\xe6\x90\xef\xca\x0e\x06\x72\x6f\x77\x40\xf4\x8c\x5e\xb3\x4a\x6a\x23\x15\xac\x4f\xd7\x8c\xed\xef\x83\xbb\x21\xd7\x66\x38\x1c\x05\xf9\x8e\xa9\xeb\x35\xe8\x52\x03\x84\xc4\xbd\x21\x5a\x72\x7b\xf5\x66\x58\xa5\x88\x32\x77\x42\xf7\xea\xb1\x35\xfc\xe8\x07\x34\x80\xcd\x46\xea\xe7\x07\x6f\x81\x97\xa5\xe8\x4f\x4f\x43\xfd\xe3\x54\x8d\xb7\x5b\x61\xa6\xf1\x77\x49\x33\x5b\x75\x6a\x2a\x13\x6c\xd5\x49\xa9\xb4\x6d\x55\x3a\x86\xb6\xbd\x01\xb0\xca\x9a\x26\x51\x33\x60\x57\x9e\x9d\xd5\xed\xd4\x1c\x9e\xa5\xe9\x64\x69\xee\x2b\xa6\x90\x7d\xb4\xee\x06\x20\x74\x8b\x73\xcb\x38\x41\xd8\x29\x33\x6a\x2e\x61\x8e\x6a\x44\xcc\xf2\xf1\x35\xda\x40\x6a\x1c\x59\x62\xe3\x4a\x51\x76\x54\x29\xcb\x6a\x01\x16\x05\xa8\x1d\x62\x11\x19\x61\x16\x25\x94\x19\x68\x11\x21\xcd\x3f\x5a\x03\x93\x65\x0d\xa5\x80\xd1\x0a\x29\xc0\x61\x11\xe0\xf5\xac\x2f\x7a\x25\x7e\x15\xd5\x80\x79\x89\x03\x88\x1b\x62\x4c\x38\xf0\x43\x29\x81\x92\xa0\x0c\x49\xec\x86\xaf\xa3\xc2\x84\xba\x8e\x8a\x32\x48\xa9\x55\x56\x56\x06\xb4\xdb\x84\x22\x03\x6c\x61\x4c\x26\xfd\xa9\x7f\x56\x8e\x3b\x1a\x90\x2a\xd4\x41\xb3\x34\xd6\xd9\x94\xfe\xd4\x3f\x3b\x54\xf5\x1c\xd2\xfa\x52\xaa\x64\x87\x24\xd0\xab\xe9\xdf\xdc\x15\x85\x01\xdc\x59\x53\x7c\x34\x46\x64\xbd\xa0\x9a\x1c\x29\x3d\xfc\xcb\x8f\xa2\xe4\x2a\x75\xbc\x93\x92\x25\xe2\x00\x41\x55\x71\x39\xe5\xa2\xa0\x3f\xca\xfc\x4e\x4b\x2d\x6e\xa6\x45\x9c\xc3\xb4\x3f\x21\x3b\xbb\xfc\x45\x04\xd4\x75\x54\xa8\xbf\x14\x0c\xb0\x0a\xfc\xbd\x60\x14\xa9\x69\xa7\xbf\xe8\xfc\xd2\x7f\x0b\xfb\x1c\xe4\x45\xfa\xcc\x98\x85\x62\xd0\x65\x9e\x3a\x84\xd6\x09\x60\x49\xff\xe3\xd1\x4b\xec\x74\xeb\x35\xa1\x2c\xf3\x8b\xf4\x6a\x0a\xdc\xde\x41\x4f\xb1\xff\x3e\xc8\xd2\xc5\xf3\x84\x7b\xc5\xb1\xd8\x59\x76\x64\x4b\x68\xa8\x19\x3d\x88\x47\x3e\x29\x13\x84\x0c\x41\x1b\x71\x1f\x7f\xd6\x60\xc7\xf8\xe2\x45\x89\xc7\x29\x34\xca\x95\x43\xbe\xa5\x7e\x73\x82\x81\xa3\xab\x7b\x1b\x32\x5c\xae\x9d\xfb\x8f\x72\x2f\x2e\x6f\x3c\x86\x27\xad\x73\xc7\xd1\xfd\x46\x5d\x5b\x8d\xf0\xdf\xb3\x77\x06\xb7\x0f\x50\xdd\xea\x46\xe0\xfe\x92\x2e\x8b\xa9\x63\xa1\xdb\x4d\xa6\xc5\x4b\x12\xea\xe7\x39\x2b\x69\x25\x69\x40\xda\xd6\xec\x70\x85\xdd\xd0\xd6\xac\x26\x32\x3c\x80\xf8\xef\x56\xfb\x75\xab\x37\xd9\x98\x63\x90\x88\x6c\xe3\x62\x9a\x6a\x4e\xb6\xe8\xb5\x43\xb4\x92\xbc\x07\x41\x06\x3a\x16\x9c\xf6\x18\x49\xfe\x69\x76\xa8\xa3\x6d\xf6\x6d\xb3\x7a\x7d\x9f\x5c\xf1\x91\x64\x9f\xd0\x07\x54\xe0\xec\x9c\x14\x53\xe4\x31\x63\x9e\xd7\x01\xff\xd6\x9c\xa7\x11\xb0\xf5\xb4\xb7\x56\xdb\x5a\x7c\x59\xf1\x5f\x7b\xcf\xfe\xab\xad\x89\x76\x6f\xe1\x07\xdf\x4f\xb8\xb2\xf3\x64\xef\xb6\x65\x77\xc2\x70\xea\x11\xde\x27\x8e\xd8\x89\xa5\xa7\xb1\xda\x3e\x5f\x7a\xdd\xc9\xfd\x80\xa4\x7c\xcc\x2e\x86\x50\xa8\xcb\xb3\xcc\xa1\x72\x8f\xb3\x4e\xc9\x2c\xb0\x39\x16\xcb\xe7\x4b\x45\x8f\xd0\xe6\xff\xa8\xe3\x7a\x5b\x34\x38\xd8\xbb\x3d\xb9\x73\xb8\x46\x3e\x8e\x10\xa8\x51\x79\x2f\xed\x22\x44\xe3\xe0\x7e\xa5\x5b\x7f\x88\xab\xf8\x10\x57\xf1\x21\xae\x62\xb3\xb8\x8a\x62\x93\x01\x35\x23\x86\x5b\x83\xf8\x73\xa7\x51\x17\x0d\x97\xe4\xca\x60\x76\x43\x37\x7c\x5d\x33\x06\xa0\x11\xc2\xef\x35\xa4\x8c\xa8\x60\xd6\x61\x19\x74\x55\xb0\x3f\x00\xba\x6f\xa1\xee\x3e\x71\xea\xfe\x8a\x80\x77\xc6\x24\x40\x64\x2a\xd0\x75\x32\x66\x13\xc9\x54\x48\x5e\xe4\xbd\x87\xa0\x78\x9f\x34\x28\x1e\x2c\xec\x16\x1c\x98\x46\x24\x33\x2f\x87\x0f\x1e\x7a\xcc\x55\xde\x8f\x41\xd5\x8d\x1e\xa3\xdf\x70\x71\xd1\x5b\xa4\x57\xac\x52\x07\x0d\xc1\xc5\xa6\xed\xc9\x28\x5b\x6b\x13\xae\x6b\x01\x76\xee\x07\xdf\xd4\x0b\xbe\x89\x0f\xfc\x3a\x1e\xf0\x5b\xc8\x18\x65\xbf\xb8\x12\xd7\xd5\xc6\xb9\x61\x9e\xa0\x3c\x4a\xce\x63\xc2\xe4\x76\xa9\x67\x2f\xbd\x08\xdb\x34\x00\x46\x65\xfc\xa2\xf5\xea\xdf\x25\x33\xc3\x5d\xb2\x32\x6c\x37\x30\x7e\x75\x3c\x0c\xed\x21\x60\x7e\xc1\x43\x0d\x48\x43\xd0\x09\x2a\xb2\xe8\xfc\x9c\x64\xcc\x6e\x0c\xec\x2a\xde\x0c\xa9\x67\x47\x7a\xde\x9e\xcd\x1e\x0a\xda\xcc\xf4\x35\x87\x16\xa8\x18\x8b\xaf\xf5\x5d\x72\xc5\x70\x7c\xa5\x4f\x8e\x1d\xa3\xf1\xb5\x3e\xf2\x77\x0f\xc5\xc3\x32\x79\x78\x98\x8f\xfe\x99\x13\x16\x37\x50\xf7\x74\x58\xe0\x3c\x47\x18\x65\x24\x94\xef\xe8\x85\x03\x04\x64\x4d\x74\xc4\xde\x92\x2a\xe1\xc6\xcf\xea\xed\x69\xc8\x59\x06\xd8\x35\x23\x46\x3d\x3c\xe8\xfd\x5a\x1e\xf4\xda\xfc\x02\x89\x23\xd7\xe6\x97\x40\xdc\x59\x42\xdd\x63\x8f\x59\xf0\x51\x94\xa0\x79\x14\xc7\x11\x4b\x03\x2c\x18\xe3\x7f\xa7\x4b\x88\xaa\x99\x43\x1c\xaa\x1b\x84\x85\x34\xce\xed\x25\x80\x0a\xc7\xb1\x86\x2a\xef\x50\xee\xa2\x6c\x73\x19\x05\x4b\x78\x70\x7c\x15\x15\x17\x08\x83\xd6\x80\xf8\x85\x1e\xf5\x60\x07\x2f\x95\x85\x21\xe7\xab\x78\x9e\x0c\xf3\xcb\x66\x17\x12\x2a\x68\xc3\x14\xf1\x58\x69\xb3\x1b\x98\xeb\xdf\x4b\xde\x5b\x7b\x2a\xa4\x1a\x5d\xe1\x6f\xdc\xeb\x54\x2d\xed\xf3\xa8\xb8\x58\xce\x7a\x7e\x3a\x67\x4b\xfa\xbf\x79\xc5\xd2\x6e\x23\x50\x21\x25\x74\x0a\x69\x2b\xfb\x70\x8b\xe4\x09\x1f\x36\x7d\x42\x4d\xab\xaf\x7c\x3f\x4d\x81\x76\xf6\x78\x5a\xa4\x9a\x40\x5f\xfa\xcb\x69\xda\xd1\x75\x9e\x4d\xc3\xc0\x6c\xfa\x66\x9a\xf2\xf3\x6b\xbe\x99\x54\xbe\x38\x29\xbf\x0e\x31\x8d\xad\x90\xca\x98\xbd\x15\x4e\x17\xd8\x8f\x0a\x3a\xcc\x5e\xdf\x3b\x29\x7f\x57\x1e\x7e\x4a\x49\xdc\xea\xf7\x0e\x27\x6d\xc3\x27\x77\x83\x87\x26\x40\x52\xc5\xeb\x63\xad\x1b\xcc\xd5\xa6\xaa\x27\xd2\x17\xec\x2f\xe2\x5d\xc1\x3b\xb7\xdb\x57\x21\x14\xc1\x0a\xb8\x07\x65\x06\x90\x1c\x58\x03\x8c\x95\x1a\x5e\x66\x81\xd2\x67\x99\xce\xc9\x12\x05\xb8\x1f\xd3\xcd\x47\x1f\x07\xad\x1a\xcf\xd3\xae\xce\x01\x78\x24\xbc\x2c\x52\xe6\x7f\x2b\x14\x66\xd0\x5f\xc3\x33\x57\x73\xfa\x75\xb1\x84\x68\xc2\xf1\xbe\x8b\x8b\x01\x06\x89\x56\x36\x07\x9b\x48\xd1\xf5\x32\x2e\xf6\xa5\xbe\x5e\x0f\x36\x7c\xab\xb6\xaa\xb0\xbf\xcf\x62\x4b\xf2\x03\x9e\x45\x00\xba\xc2\x59\x42\x4f\x57\x58\x93\x3e\xe6\x29\x9d\x75\x77\x55\x9b\x3b\x85\x39\xe1\x4d\x79\x48\x99\xb9\xa7\xe5\x71\x2e\xf7\x3a\x0e\x72\xa7\xf2\x2f\xd1\x50\xbb\xe3\x98\x1d\x81\x4a\x2e\x88\x15\xc8\xd0\x77\xa8\xdf\x3b\x38\x38\x90\x48\xc5\x9b\xc2\x8e\xa7\x96\x8e\x7b\x21\x0e\x1a\x2f\xc4\xc1\xca\x55\x18\x25\xe7\x2b\x16\x62\x94\x9c\x37\x59\x8b\xcc\x31\xae\xe1\x3a\x1c\xae\xb5\x10\x87\x0d\x57\xe2\xf0\x61\x29\xde\x61\x29\x5e\x47\x76\xe5\xaf\x6c\x25\x2a\xfe\x0a\x48\x8c\x6f\x2c\x80\xd1\x68\xb4\xc1\x52\xdd\xe2\x99\x79\x1d\x15\x35\x2b\xf5\x3a\x2a\x6a\x57\x29\x0e\x82\x9f\x93\x40\xcb\xa9\x66\xae\xd4\x0e\x4a\xc8\xb5\xe5\xf2\xae\xd6\x98\xf5\xbc\xd9\x26\xae\x7e\x21\x59\x4b\xd5\x58\x03\xfa\xa3\x91\x12\xd3\xd9\x15\xad\xd3\xd6\xe2\xb5\x9c\x14\x1c\x6b\x8b\x76\xa5\x23\xaa\xeb\x8f\x4e\x77\xfc\x72\x93\xc9\xd4\x6f\xee\xe8\xb9\xbe\xe2\x01\x24\x18\x7c\xb4\x07\x87\xf0\xbb\xd6\x05\xdc\xe9\x01\x6e\xfb\x50\x37\x74\xa1\xae\xf6\xa0\xd6\x1d\xa3\x1d\x7e\xd1\x5c\xa9\xa3\x40\x78\x81\x0e\x03\xab\x83\xa7\xec\xe7\x50\x50\xd4\xcc\xe3\x78\x85\xc3\xb1\x62\x26\x83\x8f\x9c\x47\x4f\x85\xf8\xb7\x91\xe7\x31\x38\x1e\xc3\x24\xd9\x1e\xc4\x75\x0e\xc0\xdc\xe7\x97\x0f\x12\xfd\x13\x46\xa2\xda\x7b\x97\xf5\x06\xfe\xa4\x64\x1b\xbe\xbb\x32\xef\x91\xa0\xdd\xe1\xb6\x78\xdb\x91\x8c\xd3\xd3\x87\x5e\x4d\x8a\x11\x83\xe5\x97\x34\x43\x39\xc9\xe8\x0d\x18\xa2\x8b\x33\x56\x16\x81\x5d\xf9\x1e\xf1\x8d\xb6\x6c\xa3\x84\x2e\x76\x36\x10\xfa\xee\x50\xb3\x63\xda\xef\x8f\x9a\xfa\x1e\x9b\x6e\x21\xcd\x7d\x90\xf5\x35\x24\x15\x67\x2b\x3c\x5d\x1b\x39\xff\x1a\xb6\xa4\xf2\xf5\xa5\xbc\x90\x4c\x30\x6b\x25\x99\x3b\x39\x07\x35\x0b\xcb\x1b\xc6\x14\x95\x37\x0a\xae\x25\x85\x7f\x64\xb1\xf0\xb1\xee\x18\x9e\xb7\x19\x09\xa7\x62\x09\x2b\x50\xcd\x13\xd4\xf2\x02\xad\xf4\xf7\xa4\x5b\xe4\x4a\x67\x4f\xb8\x30\xbb\x3c\x3d\x2d\xdf\x6c\xa9\x9b\x52\x6e\x94\x0e\xe5\xe6\x87\xdb\x15\x8e\x93\xcc\xb1\x47\x31\x02\xbf\x81\x9f\x94\x5c\x1a\x87\x9f\x33\xeb\xb4\xe8\x80\xe6\x1f\x74\x0a\x23\x61\xb9\x2c\xa2\x53\xc4\x9d\x25\x71\x9e\x47\xe7\xb0\xec\xd4\x59\xcf\x7c\x7d\xdb\xe8\x83\x52\xb9\x44\xe8\x14\x0d\x4e\x50\x84\xbe\x2f\xa9\x5d\x4e\x50\x04\x8a\x14\xb6\x83\xb0\xa0\xb8\xba\x0a\x25\x7a\x7b\xa2\xf0\xbc\x27\x37\x54\x1a\x64\x60\xb4\x12\xdd\x02\x38\x29\x0b\xa1\xe8\xe8\x5d\xe0\xfc\xc5\x55\x22\x3c\x38\x99\x73\x29\xab\xd2\xa1\x18\xda\x6d\xe9\x90\xfc\x86\x6b\x6c\xd8\x57\xf8\x75\x82\x6e\xe1\xff\x89\xac\x78\x00\x77\x82\x6e\xa5\xb3\x9d\x50\x05\x57\xba\x91\x88\x10\x84\x3a\xa0\xe9\xa0\xf5\xef\x28\x0e\x7c\x9c\x05\x2d\x85\x4d\xba\x81\xe1\x20\x00\xb6\xaa\xf4\x4d\x1b\x95\x40\xeb\x1c\xc6\x04\x8c\xe6\x2f\x37\x4f\x2f\x49\x7d\x13\x13\x17\x74\xbd\x8f\x9d\x04\xdb\x6d\xd2\xe4\x95\xbe\x7b\x87\x07\x0e\xd8\x3a\xfc\x0e\xa7\xbd\xdf\x57\x4c\xf1\xf0\xf0\xf8\x93\xb8\xdf\x55\x35\x20\xd9\x87\xb7\x40\x17\x81\x13\xbd\xd9\xfc\x89\x14\x7f\x61\xad\x25\xe4\xea\xc5\xec\xbf\x74\xdb\xbb\x3d\x91\x28\xbe\x39\x85\xb7\xbd\xc6\xe2\xe5\x8b\x4e\x6b\xac\xd1\x8a\x4b\x67\xff\x15\xcb\x8d\x35\x25\x16\x5b\xca\xff\x64\x2b\x8d\x7d\xd3\xf6\x4c\xa0\x94\x53\xcd\x3e\x02\xa0\x3e\x1c\xa6\xd6\xb7\x25\xf2\x93\x75\x90\x26\x69\x0b\x5a\xbf\x91\x9f\x91\xf8\x23\x0d\x0d\x40\xd8\x0e\x2e\xb2\xf4\x8a\x36\x87\xe8\xc4\xff\x9c\x65\x69\xd6\xfa\xf6\x19\x4e\xe0\xd9\x36\x8e\x63\x84\xd9\x79\x8d\x70\x8e\xb0\xdc\xeb\xbe\x6d\x97\x48\xab\x94\xf9\x5b\x39\x89\xc3\x0e\x20\x93\xa4\xd1\x22\xb3\x75\xf9\xc4\x80\x93\x00\xf7\xde\x0b\x9c\x27\x5e\x81\x66\x84\xd0\xbb\x70\x54\x44\x38\x8e\x72\x12\xa0\x2e\xca\x97\x0b\x10\xee\x75\x08\x96\x2b\x86\x91\x26\x5e\x55\xd3\x1e\x3c\x7a\x24\xaf\xfc\xf0\x9b\xde\xa4\xbe\x65\x12\xe6\xb7\x74\x03\x2f\x7d\x53\xbd\x44\x3f\xb2\xe2\x29\xa2\x14\x97\x78\x93\x29\xfe\x5b\xf9\x72\x06\x3b\x40\x87\x91\xc5\x76\x03\xde\x55\x8e\x5c\x7d\x60\xaf\xef\x65\x13\x94\x3a\xeb\xa3\xe0\x43\xe7\xd4\xbc\xa2\xb0\xf4\x3c\xcc\x48\x9e\x53\x32\xe6\xcb\xbc\x40\x24\x02\xe9\x79\x46\xe4\x03\x75\x35\x57\x1d\x78\x82\xff\x2d\x7a\x8c\x4a\xb4\xc0\x50\x09\xea\x15\x57\xab\x53\x8e\xdf\xf6\x35\x02\x0d\x72\x55\x95\x0e\xfa\x00\x61\xbf\xf8\xcc\x4f\x61\xa9\xc1\x85\x4c\x0d\x0e\x49\x96\x73\x92\x61\x78\x72\x16\xe2\x38\x27\x1d\x74\x95\x45\x05\x96\x6f\xd0\x20\xc4\x42\x18\x9d\x2f\x33\xac\xbd\x4b\x43\xb7\x6d\xb6\x4c\xf5\xc1\xe5\xf4\xe5\xa6\x23\xfe\x8f\xee\xf2\x8a\x09\x52\xb4\x69\x06\x84\x53\x0d\x44\xba\x02\x6b\x47\x93\x9c\x7e\x51\xc6\x6f\xf8\xfc\xfd\x91\xe1\xe3\x29\x1e\x02\x3f\x7a\x24\x9f\x27\xe5\x8b\x38\x2a\x20\x83\x6c\x2f\x4c\xb3\x9f\xb1\x7f\xa1\x45\x60\xf2\xad\xc4\xb4\x20\x44\xc9\xb3\x4e\xc9\x50\xbc\x45\x76\x6d\x6e\x9f\x88\x44\x8c\xe6\x01\xa7\x5d\x84\x65\xf1\xae\x69\xd5\x0f\xcd\x5a\x72\x81\x5e\x43\xa0\xe0\x02\x16\xdc\x95\xde\x39\x6e\x18\x3d\x09\x4d\x85\xe7\xdd\x79\x17\x48\x17\xce\x04\xcf\x09\x04\xb0\x98\x11\x19\x1d\x06\x02\x29\x44\x05\xd3\xd0\xcd\x08\xca\x97\x61\x18\x5d\x73\xf7\x6a\x82\xfd\x0b\x94\x17\xf8\x9c\x4c\x11\xe9\x9d\xeb\x96\xe3\x33\x45\xd5\xe9\xb7\x21\x0e\xc8\xb7\x67\x9c\xba\x1c\x9d\xd1\xdf\x5d\x20\xe6\xac\xa3\xff\xea\x62\xbf\x88\x2e\xc9\x59\x87\xe3\x60\x5f\xae\xa3\x42\x81\x5d\x47\x85\x84\xe2\x65\x4c\x8c\x3f\xeb\x00\xa9\x7a\x91\x00\xe4\xfd\xa4\xd3\xa9\x19\xbe\xf5\x71\x83\x6c\x4c\x71\x0e\xe9\x1d\x72\x9e\xd3\x29\xa0\xb0\x64\x41\x2f\xa2\x49\x11\xdf\x40\xe6\xdc\xa9\xde\xc3\xb3\xb3\xff\xf2\xcc\x85\x5a\x5f\x3f\x7c\x60\x45\xf2\x72\xe1\xcd\x6f\xba\xe2\xbe\x6e\x7c\x7a\x02\xc4\x71\x00\xf8\xdb\x86\xe3\xe6\x6b\x0a\xc0\xe2\x1a\x19\x1f\x1c\xf5\x2d\x28\xb8\xf9\x41\x6d\xb8\xfe\x6b\xc5\xae\xba\x1a\xcc\xed\xad\xec\xa2\xd6\xe1\xff\x01\x1b\xe5\x07\x96\x77\x01\x7d\x44\x66\x4f\x7f\x9c\x22\x91\x91\xa1\xdc\xcb\xd2\x47\xa0\xd4\x5d\x5a\x55\xe3\x3a\x2a\x9c\x85\x6e\x78\xde\x05\x99\xf1\x8d\x5f\xbe\x95\xbc\xa7\xf9\xc7\xbc\xba\xc0\x0b\x62\xbb\x35\x9f\x7d\xaf\x96\xe4\x0f\x67\xca\xd9\x88\x65\x09\x89\xe6\x73\x12\x44\xb8\x20\xf1\x0d\xc2\x61\x41\x98\xc3\x86\xc7\x26\x80\x2e\x30\xa1\xa3\xe1\xa2\x44\xc4\x39\x85\x2f\xd0\x5e\x69\x58\x7f\x11\x77\x34\xba\x75\x4c\xd1\xdf\x8b\x79\xfc\xb3\x88\xc2\x13\xe5\x4f\x00\x19\x5c\xf8\x67\x69\xca\x22\x5c\x98\x2e\xb6\xaa\x5f\x65\x77\xa6\xbb\x74\x86\xb3\x07\xed\x13\x43\xe6\x19\x6b\x4b\xf5\x6f\x57\x5d\x83\x2f\xbb\xea\x5d\xa9\x5b\x9e\x3c\x15\x70\x46\xd0\x77\xdf\xb1\xed\x3d\xf8\xee\x3b\x14\x66\xe9\x5c\x26\xed\x05\xe5\xfb\x96\x3b\x4a\x82\xdd\xf4\x93\xae\xeb\xbb\x73\xa1\x41\x2e\x6c\x2c\x3b\xa2\x55\x32\xd6\x66\x2c\xb5\xe7\x70\x24\xdd\xed\xa8\x12\x31\xa8\xdb\x64\x18\x7b\xb8\xcb\xcc\xc1\x5e\xa1\x72\x07\xa3\x27\xe8\x4c\x75\xe2\x4c\x3b\xf7\x99\xef\xd0\xb3\x57\xaf\x74\x0f\x30\x38\x28\xa5\xfc\x90\x2b\x4f\xa3\x28\xc9\x17\x2c\x3d\x19\x73\x4a\x22\xd7\x3e\x89\x63\x8a\xe7\x4d\x72\xde\x65\x35\x08\xf3\x38\x9a\xee\xef\x5f\x5d\x5d\xf5\x92\x73\x5e\x0a\xae\x84\x6d\x14\x47\xb3\x0c\x67\xe0\x56\x44\xb1\x9a\x2e\x89\x4a\x02\xc0\x68\x81\xa3\x0c\xd1\x2b\x08\x30\x66\x02\xa7\x70\xb0\xcc\x64\xc4\x2b\x79\xa8\x9f\x71\x39\x61\x0f\x72\x38\x06\xe8\x0c\xe4\x01\x26\x75\xe4\x32\xa2\x95\x72\x7b\x04\xe1\x28\x8c\xb2\xbc\x28\x6d\x4d\x2c\x28\x14\xc4\xd9\xa2\xd8\x98\x2b\x1d\xfa\x96\x31\xdc\xb7\x02\x5c\xcb\xbb\x09\x5f\xc0\xbd\x8d\x0a\x53\xf4\x46\xa8\x3d\x96\x80\x0e\xfe\x5b\x64\x8b\x3a\x8b\x12\x16\x92\x8b\xc5\x20\x3e\x3f\x8f\x99\x18\xc6\x5e\x65\x00\x88\x7a\xba\x06\xc2\xd4\x39\x29\xf6\x78\xba\xe6\x33\x72\x8d\xe7\x8b\x58\xc8\x44\x30\x5f\xfc\x0a\xca\x53\x9b\x9a\x10\x42\xb0\x51\x80\x30\x3a\x41\xc0\xf2\x86\xd2\x0a\x09\xb9\x2e\x50\x11\xf9\xef\x55\xf2\x64\x4c\xef\x1a\x97\x24\x01\xa1\x51\x3a\xe8\x01\x76\xcd\x57\x14\x3a\x21\xe7\x8f\xc9\x38\xdf\xa1\x68\xbe\x48\x33\xeb\xcd\x1d\xe3\x70\xaf\xc2\x7f\xd4\x00\xf5\x4e\x38\x42\xb8\x30\xa1\x5f\x70\x00\xb6\x83\x0f\x52\xcf\xdb\x41\xbd\x1e\xd3\xec\xa3\xdb\x36\x3a\xfd\x01\xb5\x28\x34\xfa\xde\x7c\xe4\x47\x8b\x10\xfa\x20\x40\x6f\x79\x01\xd7\xdb\x9e\x7e\x98\xf4\xfb\xa2\xac\x24\x7e\x42\xf9\x0f\xec\xeb\x07\xd1\x2c\x83\xfe\xde\x24\x16\x80\xda\x92\x62\x98\x07\x4a\xf1\xf3\xe4\x49\x12\xbc\x58\x16\x48\x68\x46\xc1\xd9\x4d\xa9\x9a\xa9\x40\xf4\x1d\x0b\x8c\x27\x2e\x85\xad\x5e\xaf\x07\x8e\x55\xe2\x1b\xe2\xd7\x78\x51\x7e\x22\x8a\x59\xdc\xd8\x02\x17\xe4\x14\x89\xe8\x25\x70\x63\x44\xb7\x9c\x10\xc4\x8c\x92\xcf\x29\x03\x5c\xe2\xb8\xd5\x82\x71\x92\x78\x05\x0a\x52\xbc\xa2\x58\x64\x08\x94\x6f\x14\xe6\x1e\x3c\x0d\xba\x6d\x8b\x2a\xb7\x1d\x34\xe9\xf7\xfb\xfc\x37\x1f\x39\xdd\x88\xf8\x9d\x6e\x2e\x69\xa9\x96\xbe\x87\x09\x8c\x92\xd3\x0f\x16\xf2\xdb\x1f\x14\x10\x42\xdf\x07\xd1\xe5\x0f\x7f\x27\x71\x9c\xa2\xab\x34\x8b\x83\xef\xf7\x69\x81\x86\x66\x9f\xe2\x91\x05\x3a\x1d\xb7\x7b\x42\xfc\x64\xfb\x1b\x5f\x06\x7e\x9a\x66\x19\xc9\x17\x29\xf3\x7a\xa6\xec\x2f\x9c\x65\xcf\x80\xa8\x1f\xb4\xcd\x6f\xaa\x98\xd8\x67\x2b\xa4\xa7\xae\x1a\xa2\x7b\xdc\x52\x34\x45\xfd\x5e\x7f\x70\x22\x9a\xb6\x80\x7b\xa5\x2b\x4a\xa9\xfa\x80\xcf\xa4\x5a\x07\x53\xf1\x91\x0e\xf2\x3c\x47\x04\xe7\xa4\x0b\xf9\x2f\x4a\x6d\x5c\x47\x45\x05\xc2\x32\x60\xcf\xbe\x07\x55\xf7\xc4\x4d\xcd\xc8\x49\x0d\x1f\xec\x7d\x76\x4f\xb5\x5f\x4e\xaf\xf2\x0a\x55\x8a\x21\xa3\xe6\x4a\x87\x50\x03\xda\xf4\x0c\xad\x72\x05\xb5\x15\x82\x0c\xa0\xf4\x22\x1b\xfd\x69\xbc\x40\x6b\xd4\x88\xbc\xf3\xd6\x18\x1a\x9e\x9c\xd6\xb7\x86\x5e\x9d\xca\x5a\x6f\xbb\x6d\x60\x21\xa5\xba\x7c\xad\xce\x49\xf1\x4c\x5d\x9a\xf5\x04\x27\xb2\xb4\x25\x11\xa0\x1f\x95\x50\x3d\x15\xf2\x76\xbb\x14\x35\x8e\xd6\x92\x6e\x57\x06\x2a\x75\x43\x3b\x31\x63\x82\x6b\x3a\x17\x22\x14\x3c\x4c\x22\x93\xde\x2a\x2e\x55\x15\xc5\xb4\x53\x2f\x52\xc3\xbf\x61\xf3\x81\x1d\xde\x7d\x64\xd9\xce\xf0\xac\x7e\x7c\x87\x3d\x0b\xac\x34\xcc\x61\x9c\x5e\x3d\x49\x82\x27\xe6\x60\x5a\xb5\x3e\x81\x4b\xa0\x1e\x50\xaf\xc1\xb8\x56\x73\xc9\x8a\x21\x5c\xd5\x13\x12\xac\xe8\x08\x09\x56\xf5\xa3\xa9\x5b\xa3\x31\x53\xa3\x0a\x8e\xe0\x4c\xbf\xc6\x9a\x1a\xad\xb7\xa8\xf8\x10\x59\xe1\xed\xdd\xeb\x4f\x0c\xe1\x1d\x16\xe0\xdd\x5c\xd2\xf4\x50\x89\x6b\x0e\xf0\xb8\xf9\x00\x37\x5a\x5a\xe3\x4f\xb0\xb4\x58\x5f\xeb\xc7\xab\xc1\xc2\x12\x41\x23\xab\x46\xac\xc1\x96\x5b\x4b\x63\xed\x9a\x81\xef\xb5\x14\xda\x47\x8e\xe6\x7a\x70\xb3\xb0\x26\xd6\x2f\x9f\x4d\xdc\x61\x4d\x7e\x30\x9d\x98\xf4\xc5\x22\x4c\x62\x0a\xc7\x37\xa7\xa7\xc8\x63\x4a\x45\x0f\xfd\xa8\x7d\x79\x43\x61\xdf\xa2\xa9\x0e\xfc\x18\x79\x5d\x8f\x1b\x9c\x0c\x77\xe1\x32\xbf\xac\xdb\x12\xc5\xcd\x94\x9c\x9e\xd1\x28\xb4\xc9\xb5\x25\xa5\xd8\xbd\xa5\x40\x71\xf4\xcf\x12\x83\x4d\x4b\xe4\xdd\x96\xdc\x1b\x6b\xe4\x13\xa7\x43\xa3\xf9\x0a\x51\xd9\x8d\x0d\x16\xaa\xb0\xd6\x48\xde\xd2\x27\x57\x04\x94\x32\xf8\xc0\xb1\x58\xa1\x8e\xe6\x42\xa4\x2f\xd1\x0a\xc1\x42\x41\x3b\x96\xb5\x59\xc7\xbd\xa0\x55\x23\x8f\x1e\x55\x99\x9d\xf8\x4a\x76\xb5\xe2\xac\x54\xde\x04\x20\x96\x71\xed\xd0\x5a\xdb\x89\x39\xbc\xee\xbd\x46\xd1\xc6\xc7\x19\x9c\xb2\x99\xaa\x00\x2e\x55\x29\xfd\xc7\x27\xf0\xda\x76\x81\xa3\x84\x7b\x8d\xed\xef\xb3\x2c\xca\x08\x12\x0f\xf9\x24\xcf\x71\x76\x63\xa8\x4d\x34\xdf\x6c\x16\x33\x8e\x07\x37\x17\xa9\x91\x94\xce\x87\x79\xf7\xed\x7f\x87\x48\x1e\x47\x49\xd1\x0d\xa2\x1c\xcf\x62\x82\x92\xb4\xbb\x4c\x96\x39\x09\xba\xca\xec\x9b\x33\x7d\x98\xf0\x7c\x16\x81\xe2\x4f\x2c\x14\x24\x59\x8d\xa1\xe6\x70\x5a\x3d\xd4\xf4\x7a\x6c\x8e\xaf\xe1\x75\x2b\xcc\x7c\x25\x13\x9f\xda\x8f\xc4\x96\x19\x90\x98\x14\xcc\x0b\xde\xda\xa3\x50\x53\x2f\x45\x97\xdd\xb0\x63\xb6\xcb\xbd\x46\xc5\x46\x69\x7a\x18\x5a\x5e\xba\x7a\x58\x06\x43\xf0\xb2\x00\x94\xeb\x61\xd9\x7f\xd7\x70\x39\x34\x1d\x77\xf5\xc7\xfd\xc6\x89\x6d\x02\xe8\xcd\xc3\x4f\xb6\x25\xb5\xb5\xe9\xe1\x83\x63\xcc\xd2\x4a\x3f\xc0\xd2\x9c\x4a\x5b\x6c\xd3\x9c\x01\xaa\xce\x14\x7d\xb8\xd5\x42\x9b\x29\x97\x16\x8b\x24\xe6\xce\xd7\xe3\x70\xe8\x54\xf8\xf5\xbd\xf1\x78\x15\xef\xed\x6e\xe2\x25\x8e\xee\x57\xbc\xc4\xf2\x40\x89\x45\x28\x3c\xb1\x2e\x70\x5e\xef\xa9\xa6\xa2\x29\x0a\xd0\x3a\x5f\x2f\x01\xf3\x69\xbd\xb7\xe4\xce\xa2\x52\x68\x98\xdb\xac\x96\xfc\x95\x2d\xf9\x5f\xa3\xbc\x68\xa3\x52\x51\x0f\x07\x41\x4b\xdb\x98\xe4\xeb\x9b\x6f\xc0\xed\x40\x8e\x40\x29\xf7\x47\xdb\x42\xc6\x4f\xb3\x72\xd9\x63\xe4\x41\xf0\x2d\xed\x42\x70\xdb\x8c\x5d\x6d\x56\x1b\xdf\x77\x56\x13\xa3\x75\xa2\x26\x4a\x14\xad\x3b\x51\x9c\x47\xbe\xf9\xc6\x38\xf9\xcb\xd3\x27\x92\xb3\x94\xe6\x50\x68\x53\xbf\x05\xff\x24\xd7\xb4\x7c\x8b\xbe\x6d\xf7\xa2\x24\x20\xd7\x2f\x42\x0e\x66\x7f\x86\xbd\xa9\x3b\xa8\x9d\xb1\x6f\x79\xff\xbf\x75\xcc\xd8\x64\xab\x33\x56\x22\xc1\xe9\x88\x73\xe7\x15\xc1\x90\x95\x06\xb4\x11\xb7\xf7\x32\xb2\x88\xb1\x4f\x5a\xcc\xf1\xee\xfc\xe7\xeb\x45\xcb\x6b\xfd\x9f\x8f\xff\xf9\x4f\xde\xf6\xac\x01\xf6\x5a\x3f\x4e\xff\xf3\x9f\xfc\xe3\x5f\xda\x10\x7f\xdd\x6b\x77\x90\xf7\x97\x81\xd7\x96\x38\xf6\xff\x93\x3f\xde\x3f\xef\x20\xf0\x13\x92\x85\xff\xe7\x3f\xf9\x77\x1f\xff\x93\x7f\xf7\x17\xf8\xe4\x71\xaf\x1f\x6b\xe0\x0f\x3e\xa7\xcb\xf7\xd6\x56\x56\x2e\xb2\x5c\xcb\xf7\xe0\x62\x67\x36\x71\x57\x05\x13\x3d\x6c\xbb\xe1\xeb\x22\x8a\x5a\x98\xef\x67\x94\xdc\x9d\xc6\x03\x86\x58\x09\x15\xc1\x30\xe9\x02\x79\x5e\x90\xf9\x2e\xfd\xb1\x61\x8d\x24\xe2\x7a\xed\xf2\x95\x76\x80\xd6\xa1\x57\x50\x46\x60\x54\x99\x43\xdd\x29\x06\x38\x40\x57\x05\x51\x65\x50\xb2\xa2\x18\xab\xaa\x5e\x1c\x1f\x95\x40\xeb\x5a\x10\x30\xf7\x2d\x4a\xeb\x3f\xd2\xa0\x2a\x12\x6d\xf3\x10\xad\x80\x64\x8b\xe1\x4a\xf9\xbd\xe5\x35\x73\xb9\xdd\x4a\xf8\x58\xc0\xd5\x84\x44\xb9\x6b\x95\xb6\x31\x39\x6d\xac\xa4\x05\x4f\xde\x0c\x5f\x51\xee\xf8\x99\xa6\xc5\xb4\xee\xc9\x1b\x7f\x3c\x7c\xb3\x48\xcf\x33\xbc\xb8\xb8\xe9\xe5\xcb\xd9\x05\xc1\xf4\xde\xab\x6e\x60\x22\x65\xfa\x70\x2c\xae\x3d\xb3\xf4\xfa\x55\xf4\x07\xdc\x8b\x3c\x1e\x41\xb3\x3b\x4b\x55\x26\xd9\x19\xf6\xdf\x9f\x67\xe9\x32\x09\xa6\xc8\x4b\xd2\x84\xc8\x2f\xe9\x25\xc9\xe8\xf5\x7e\x8a\xbc\x8b\x28\x08\x48\x22\xbf\x14\xe4\xba\x78\xa1\xbe\x92\x38\x8e\x16\x79\x94\xcb\xef\x57\x17\x51\x41\x5e\x2d\x30\x44\xb8\x4f\xd2\xab\x0c\x2f\xe4\x37\xef\xd1\x34\x4c\xfd\x65\xee\x4d\x35\xd5\x9d\x4e\x04\xeb\xe7\x02\xc7\xa4\x28\x48\x8f\x36\xd5\x03\xb7\x4a\x88\x92\x83\xf4\x14\x09\xde\xa3\xe9\x05\x44\x88\x77\xa3\x7a\x96\xc6\x69\xd6\x04\x1f\xbf\x02\x32\xb4\x39\x89\x89\x0f\xd7\xc4\x0f\xa5\x11\x6a\x86\xf1\x96\xdd\x24\x6f\xb7\x10\x42\xf5\x37\x92\x2c\x51\x44\xf7\x13\x3e\x75\xf9\xdd\xa3\x9e\xb2\xb5\xbb\x61\x14\x2c\xa8\xbc\x9d\xc0\x57\x14\x55\x39\x2a\x5b\xb8\x8c\x51\x91\x72\x37\x08\x96\x40\x1b\x5e\x83\x6a\xde\xc7\xd2\x08\xaf\x0f\x46\xcc\x5f\xd0\xad\x11\x17\xcb\x8e\xac\xa5\x69\x35\xab\xfa\xc7\xbd\x40\x6d\x7f\x69\xdd\x27\x4a\x44\x87\x16\x41\xe3\x94\x77\x16\xfa\x99\x3d\x2b\xc0\xdc\x9b\x94\xf6\x85\x0a\x5d\x18\xbc\xb8\x44\x2e\x5b\x78\x6c\xe0\x88\x34\xa7\x5c\x0f\x36\x8b\x72\xcb\xb6\xc5\xbb\x45\xba\x05\x1c\x5b\x8d\x3a\xfb\x9a\xe9\x55\xeb\xa6\x85\x25\x7a\x59\x63\x46\x20\xb6\x5f\x0a\x1c\x73\x23\x97\x33\xb0\x91\x78\xf3\xcb\x02\xef\xc9\x85\x5e\x13\x8f\x16\x56\xb1\x3a\x7a\xe9\x7a\xa4\xe7\x71\x8b\xe9\xda\xb8\x20\x9b\x69\x39\xca\x34\x85\x9b\x7a\x7d\x2b\x39\x8b\x3f\x18\xb7\xb4\x72\x12\x4c\xb2\x91\x04\x91\xb6\x77\x0e\x22\xbb\x23\x20\x44\x81\x00\xe0\x99\xb3\xc4\xbb\x75\xf5\x20\x7d\xcd\x07\xe1\xf2\x3d\xb8\x96\x3b\x4a\x12\x0c\x3f\x04\x69\xf0\xe0\x9b\x53\x21\x93\x39\x89\x27\xdd\xb6\x25\x44\x05\xdb\x62\x12\x9c\x6a\x50\x3c\x93\xa0\x8b\xa6\x23\xf2\x6b\x1b\x02\xbc\xf5\x02\x9c\xc3\xcb\x01\x90\x63\xd3\xee\x98\x03\xde\xd6\xb5\x7a\x2b\x54\x9e\x52\x28\x53\x0a\xcf\xda\x27\xd8\xb3\x65\x51\xa4\x89\x9e\x82\xc9\xce\x4b\x54\xe0\xd9\x73\x7a\xdf\x9e\xa2\xee\xa0\x63\xea\xf5\x75\xeb\xc9\x9e\xc1\x00\x53\xf5\xe7\x9e\x7a\xe7\xdc\x6e\x43\xd0\x72\xc1\x84\x1b\x69\x19\x45\xa0\xaf\x0f\x8d\x37\x4d\x23\x24\x73\xa3\xe5\x68\xd5\x68\xb4\xd0\xac\x3a\x5f\xc4\xe1\xb6\x77\xbb\x8a\x91\x59\xb0\x34\x6d\x8d\xd5\xce\x44\x7b\x1d\x74\x7c\x9d\xd6\x4e\x54\x63\x84\xda\x5a\xff\xd2\x0e\x9f\xa6\x63\xc0\x73\xd4\x6d\x65\x3c\xb5\xed\xb2\x66\x49\xb4\xc1\xfa\x19\xb6\xb9\x3d\x40\x2e\x7b\x47\xb4\x01\xb6\x28\xbd\x39\x49\x96\x54\x5a\xf4\xcc\x65\x07\xbe\x9e\x7b\x6e\x93\xc2\x7a\x29\x99\x04\x0d\x90\x93\x49\xfc\xd8\x51\x52\xa6\xc3\xfb\xa5\xf9\xe5\x69\x5c\xa2\xcc\x5f\xc6\x38\xfb\x3d\x4b\xcf\x33\x52\x63\x50\x80\x7b\xfe\x8a\x46\x3d\x1b\x1b\x0f\xfe\xa4\xbf\xec\x14\x07\x0b\x64\x3d\xd3\x33\x61\xb4\xac\x17\x83\x95\xf9\x64\xac\x36\xda\x62\x86\x99\x51\xfd\x56\xd3\x47\x24\xa4\x41\xc7\x8e\x9b\x74\xcc\xc4\xb5\x8b\x6e\x99\x2d\xb8\x3a\xb5\x73\x7d\x89\xc5\xaf\x47\x0f\xea\xd7\x2d\xab\x5f\xbf\x9e\x0c\x68\x2c\x54\xed\x83\x7a\xb5\x46\xbd\xfa\x49\xd4\x9f\xaf\x9e\xff\x7f\x3f\xa3\x53\x34\xe9\x5b\x69\x87\x5e\x92\x18\x17\xd1\x25\xf9\x17\x5d\x35\x22\x93\xd0\x3c\x4a\x3a\x68\x8e\xaf\x8d\x6b\xe0\x7c\x41\x02\x80\x42\xa7\x2c\xf5\xd0\x3c\x4a\x5a\xec\x0f\x7c\xdd\x82\x2a\x2c\x7b\x11\xab\xaa\x85\x1b\x6a\x19\xb5\xbb\x14\x7d\x1b\xed\xa3\xd6\x1c\x5f\xf3\x5f\x32\x65\xd1\xb6\xb4\x8d\x42\xc3\x15\x44\xf9\x02\xa2\x08\x7a\x51\x12\x47\x09\xe9\xce\xe2\xd4\x7f\xef\xed\x69\xda\xb6\x45\x16\xcd\x71\x76\xc3\x35\x60\x1f\xe4\x8d\xd5\xa1\x10\xe3\xa0\x6f\x26\xfd\xfe\x5b\x1d\x05\xf6\x7d\x92\x14\x4d\x30\xb0\xd7\x53\x38\xbb\xe9\x3d\x19\xf6\xfb\x3a\x8e\xfc\xf2\x9c\xde\xa6\x0a\x92\xcd\xa3\x04\x17\x44\x21\x92\xcf\xa7\xa8\x1c\xb4\x8c\xba\x0b\x7e\x34\x74\x7d\x7e\x00\x76\xb3\xb4\xc0\x05\x41\x83\xde\x38\x47\x31\x1c\x1f\x28\x4a\xc2\x28\x89\x0a\xe2\x59\x6d\xfc\xe4\x6a\x41\x86\x42\x9c\x52\x69\x10\x1e\xc2\x74\x8f\xfb\x01\x39\x6f\x1b\xd5\x69\x7b\xb1\x56\x2d\x2f\xb2\xf4\x3d\x95\x9f\xfc\x65\x96\x89\x01\x90\xea\x50\xf6\x95\x9e\x66\x3e\x5e\x00\xe2\x65\x12\x38\xf0\x6d\xdc\xeb\x00\xe7\x17\xac\xcf\xfc\x59\x46\x37\x5d\x16\xaa\xe3\x82\x8e\xfd\x7d\xf4\x2a\x9d\x13\xb1\x30\x78\x16\x2d\x48\x91\x10\xa7\xe9\xfb\x1c\xd1\x2d\x1a\x5d\x61\xe6\x04\x2b\x34\x5c\x2a\x50\x40\x91\xa2\xf7\x91\xff\x3e\x47\x51\xd2\x33\xba\xf6\x13\xce\x2f\x70\x96\x01\x77\x1d\xf5\x3b\xc3\x7e\xdf\xea\x3b\x05\x48\x21\x0b\xff\x14\x19\x73\xed\xfd\x8f\xf7\xe4\x26\xcc\x60\xd7\xaa\x9b\x51\x4d\xfd\xeb\x0d\xfa\xfd\xbf\x1a\xea\x60\xc7\xa4\x8d\x0e\xb4\x49\x53\x4e\xa1\x0d\xdb\xa4\xe3\xa9\xb7\x68\xb5\x57\xee\xf4\xc0\xe8\x73\x75\xaf\x75\xc5\xf6\x64\x35\xd6\x7e\x7f\x25\xde\xee\x60\x52\xc2\x5c\x1a\xa0\x4d\x51\x0f\xfb\xe6\xf8\x6d\xa4\xf4\x86\xb5\xb0\x22\x8f\x5a\xeb\x8d\xc7\x77\x14\x48\x73\x0e\x9b\x08\xfd\x8b\x5b\x2a\xbd\x75\x73\x95\xfd\x56\x6d\xbb\xd2\x9a\xd4\x56\x1b\x6b\x4c\x2f\xd8\x4a\x7a\xb4\x3f\xaf\xb2\x9b\xce\x19\x7f\x1c\xab\x14\xd5\x7a\x3e\x01\x78\x36\x0b\x01\x2a\xf9\x8e\xce\x9c\x34\x61\x37\x99\xe3\xf7\x24\x47\x39\x49\x78\x0c\x5e\xae\xdc\x86\x53\xe0\x6e\x6c\x50\x26\x95\x1e\x9d\x6c\x23\x4b\x43\x24\x96\x32\x8a\x12\xa4\x4d\x26\x9a\x4b\x05\xfd\x3e\xe4\x32\xbe\x5e\x99\xd4\xa1\xd4\x4c\x94\xac\xdd\x4c\x4d\x1e\xb4\xca\x66\x28\xe3\xa6\x21\x4b\xc2\x76\x93\x2e\x33\xd9\x56\x0f\x19\xc7\x03\xab\x42\xf7\x68\x3e\xec\x24\x23\xe0\x51\x9b\x72\x32\xe9\x27\x59\x97\x41\x6b\x27\x1e\x7c\xf6\xd3\xa4\xc8\xd2\x38\x26\x81\xea\x11\x54\xd6\xfa\x00\x0f\xcb\xef\xb6\x8e\xca\xbd\x84\xc4\xdd\x82\xbb\xe0\xe8\xd3\x54\xf6\x90\xe7\x7b\x8d\x61\xdb\x4e\xb2\x9d\xe2\x22\xf2\xdf\x27\x74\x04\x2a\xe8\x92\x00\x6b\xcf\xe9\x9a\x6c\xc3\x6f\x6d\x2b\xd2\x3c\x1a\x26\x0b\xfb\xfe\x6f\x9b\x2e\xde\x59\xce\xc1\xeb\x98\x33\xea\x4c\x19\x6c\x63\x17\x66\x8c\x38\x95\x7e\xc0\x30\xc1\xd2\x7c\x11\xfd\x41\x94\x38\x70\xa3\xd9\x2e\x8c\x68\xba\x6a\x06\xc4\x67\x59\x22\x40\xe6\x6c\x5b\x67\x5f\xe9\x0f\xf1\xe1\x92\x4b\xe3\xec\x0b\x93\xdd\x45\x9d\x28\x51\x55\x22\x19\x73\x98\x6e\x1b\xb2\x18\x5f\xef\xce\x82\x02\x82\x20\xf2\xe8\x20\x98\x61\x73\x45\xe7\xe8\x0f\xda\x17\xfa\x2f\x50\x0e\x05\x11\x84\xe4\x9d\xe3\x6b\xc3\xcc\x42\x45\x7a\x79\xd0\xdc\xaa\xb9\x04\x5e\x7d\xc5\xc7\xf6\x03\xbc\xc1\x88\x42\xd4\x9a\x4b\x4d\xb9\xbe\x22\x75\x4f\xf3\x8c\xc4\xff\xc2\x31\x8b\xfb\xbd\xe2\x02\xf4\x1d\x1a\xf4\x79\x70\x6c\xd1\xe6\x72\xce\x23\xd0\xa1\x53\x34\x44\xdf\xb1\xcb\xd0\xef\xcf\xd1\x77\xa8\x05\xb7\xac\x7d\x34\x44\x5d\x24\xc3\x88\x6b\x64\xf6\x6c\x71\x43\x5c\xa5\x40\x36\x6e\xb5\x06\xfd\x3e\xea\x72\xea\xe8\x0d\x89\xfe\xfe\xce\x6a\x13\x08\xea\xf3\xaf\x7d\xf4\x18\x79\x8b\x6b\x1e\xac\xd7\xdd\x12\x08\x3f\x66\x43\x75\x18\x85\x1f\xbd\x18\xf3\x37\x1e\xce\x22\xdc\x85\x81\x49\xd2\x2b\xef\x2d\x3a\x65\x8c\x77\x52\x0d\x47\xe7\x91\xc2\xcd\xa3\xa4\x0e\x8a\x4e\x33\x85\xc2\xd7\xf2\x19\x4c\xf3\x20\xc3\x5e\x10\x5d\x72\x41\x6e\x45\x28\x61\x4d\x20\x68\x6a\xa4\x63\x8b\x1c\x1e\x18\x89\x53\x58\x0b\x78\xf6\x86\x7d\x7e\x8c\x3c\x76\xe3\x79\xab\x7b\x67\x1a\x6b\xbe\xda\xed\x05\x5d\x45\x41\x71\x31\x85\x3d\xa3\x23\x9d\x5b\x60\x07\xb9\xe5\xe1\x9e\xdb\xba\xe5\x73\x8a\x3c\xb1\x91\xce\x70\x26\xae\x51\x6a\x60\x85\x21\x8d\xd5\x69\x14\xa4\xd9\xcb\x2f\xcf\xa5\x28\xac\xc4\xe6\x46\xc3\xd5\x7a\x67\x3c\x1b\xfb\xb0\xda\x1e\xa4\xe0\x35\x0b\xa7\x75\xe7\xed\x20\xb5\x76\xcd\xf3\x74\xb5\xfd\xa1\x02\xff\x4f\x6e\xec\x16\x6e\xad\x76\x5b\x7b\x0c\x75\x19\x91\xab\xa7\xe9\xf5\x14\x79\x7d\xd4\x07\xb7\x6f\x58\xe0\xc2\x07\x9c\xfe\xb0\xaf\x21\xf5\x23\xef\xb1\x25\x6a\xa4\x42\x58\x8b\x3d\x59\xfd\x75\xac\xc8\x8e\x4b\x76\xcd\x30\xb7\xf5\xab\x11\x30\xb0\xb6\xa9\x68\xaf\xc4\xae\xa7\x48\xec\x75\x5a\xe9\x8d\xab\x34\x53\x85\x74\x5b\x54\x1f\xc2\x28\x8e\x6d\xcf\x2c\x71\x23\xfb\x37\x5b\x1d\xf2\xb8\x10\xc3\x0c\x11\x7e\x10\xfd\x5f\xa6\x33\xb2\x65\x80\xcf\x63\x39\xde\x8a\x90\x6f\xdb\x96\x57\x4b\x84\x56\x8d\x6d\x48\xad\x16\xca\x26\x52\x99\x4d\xc5\x4a\xf9\xdf\xae\xb0\xf2\x5e\xa2\x55\xf8\x82\x0c\xcf\x4c\x44\xba\x1b\xcf\x34\x6d\x8d\x1e\xb5\x95\x6d\xb1\x41\x6e\x8c\x0a\x64\xb4\xed\xa0\x62\xf2\xdf\xdd\x38\xb6\xb1\x65\x9a\x89\xa2\x5b\x21\x5c\x88\xb3\x5b\x61\x2d\x5d\x24\xde\x0a\x75\x42\x9c\x5e\x85\x4c\x37\xc1\x97\xf6\x51\x87\x29\x9e\xef\x72\x8a\x27\xe5\x2e\x35\xee\x77\xcc\xbb\xe2\xa8\x77\xa0\x76\x24\x6b\xca\xb4\x7d\xa5\x2f\x37\x8c\xbe\xdc\x09\x06\xfd\xfe\x56\x0c\xfa\x25\x0b\x34\xba\x6d\xb7\x4a\x26\xe3\xdd\x18\xf8\x8f\xbf\x70\x83\xe9\x4e\xcd\x97\x5f\xf9\x63\x98\x2f\xc2\x60\x8a\xb3\x84\xe7\x2b\x72\x91\x3e\xb6\x01\x6b\x6d\xa5\x0c\xe4\x8b\x32\xc6\xbe\x7e\xf9\xe4\x1f\xaf\x9e\xd3\x55\xfc\xee\xa7\x7f\xbe\x7c\x02\xcb\xf9\x14\x8d\x4f\xd0\xfe\x3e\x1a\xf7\xfb\xf3\x7c\x37\xc6\xd0\x45\x2a\xa2\x9a\x79\x19\xd7\x7a\x34\x78\x12\x21\xee\xa6\x93\xd5\x46\xd3\x15\xef\x09\x84\xf9\x74\x60\x99\x4f\x75\x64\x4f\xf1\xfa\xf8\x6c\x73\x2c\x2f\xff\x09\xe7\x17\xee\xd7\x0e\x74\x00\x70\x10\xe1\xb8\x7b\x4e\xff\x85\x9b\x19\x7a\x5c\x43\x2d\x5c\xf9\xfa\x7f\xed\xa0\x06\x60\x83\x83\xbf\x76\x98\x71\x6e\x81\x33\x92\x14\x68\x3c\xfc\x6b\xdb\xf1\x28\xe5\x15\x1c\x9d\xde\xa0\xbf\xb8\x46\xf4\x7f\x1c\x20\xbf\xab\x09\xa3\x50\xdd\xe1\x68\x71\xed\xad\x34\x3c\xaf\x18\x35\xcd\x04\x3d\x30\x4d\xd0\x1a\xb6\x75\xa6\x41\x43\x38\x76\x21\xbc\xe3\x3c\x98\xf4\xd6\xcc\x84\x03\xf0\x53\xce\xc5\x4c\x1f\x32\xae\xdd\x61\x46\xc9\x4e\x79\xfd\xe1\x59\x9e\xc6\x4b\xcd\x4a\x1d\x93\xb0\xe0\x62\x10\x20\x4b\x8b\x22\x9d\x6b\x05\x45\xba\xd0\x7f\x69\x11\x0a\x55\x86\x45\xd4\xef\x0d\x85\x03\x80\xd7\xb1\x6d\xfb\x2f\xb2\xe8\x9c\x8a\x5a\x1e\x6d\xca\xa0\x3c\xb0\x26\xa8\x8e\xce\x39\xce\xce\xa3\xe4\xb5\x41\x8d\xd8\x21\xcc\xde\x3a\x87\x40\xb7\xea\xcf\x96\x61\x48\x32\x34\xca\xa5\xcd\x5e\xd0\x6e\x0c\x2b\x40\x3d\xc5\xd9\xd0\xf2\x57\x28\x77\xbf\x47\x79\xc2\xb5\xb7\x3e\x46\x5e\xee\xc2\x4d\xb7\xc7\xa7\x80\xbf\x86\xd9\x3d\x8d\x7f\x4a\xb5\xff\xdf\x25\xc9\x6e\x6a\x1d\x29\x06\x47\x65\x47\x0a\x43\x20\x7e\x8a\xb3\x41\x99\x71\x64\x2e\x2d\x56\x18\xc7\xcf\x2e\x70\x72\x4e\xf8\xf4\x75\x50\x46\x87\xdc\x39\xac\xf3\x65\xd4\x35\x1a\x18\xa0\x61\x6f\x90\x23\x7f\x39\x8b\xfc\xee\x8c\xfc\x11\x91\xac\xd5\xef\x1d\x4c\x3a\xa8\xdf\x3b\x1a\xc0\x3f\x87\x23\xf8\x67\x74\x3c\x69\xbb\x3d\x47\x6c\x8a\x87\x3b\xa5\x78\xe8\xa4\x78\xc0\x49\x1e\xd3\xff\x1d\x8f\x3b\x68\xd0\x2e\x7b\x7b\x48\xbc\x3f\xb1\xec\xa1\xde\xa0\x37\x98\xe4\x26\xbb\x57\x8f\xbd\x46\xb4\x96\xb7\x74\xcb\x5c\x27\x39\x5a\x6b\xfa\x0f\xfe\x92\x62\xb0\xb3\xc6\x86\xbf\xb3\x83\x6a\x3b\xab\xa8\xbc\x3f\xae\x75\xe2\x2b\xaa\x9e\xc0\x11\xf1\x49\x89\xaa\x3e\x00\xf7\xf7\xd1\xaf\xe4\x9c\x5e\x47\xa6\xe2\xf7\xc7\x8f\x28\x23\x8b\x8c\xe4\x24\x29\x72\x30\x91\x5e\x46\xe4\x8a\x8a\x63\x02\xa2\x8b\x74\x08\x8c\x62\xca\xe7\x1a\x0d\x02\xee\xda\x82\x0b\x70\xf6\xde\x06\xb3\x9d\x74\xcc\x75\xac\x79\xb7\xec\xef\x23\xf4\xb1\x4b\xff\xa3\xff\x7b\xdd\xfd\xc8\x7f\xf0\x7f\x84\x86\xdf\xf2\x88\x61\x87\x8c\xd7\x1d\x4d\xfe\xaa\x69\x5c\x33\x7d\xf7\xb6\xf5\xd9\x66\x43\xaa\x85\x8f\xd7\xd7\xd7\xd7\xaa\xa1\x03\x77\x4b\xc6\xde\xaf\x5a\xea\x1e\x3b\x5a\x2a\x3b\xf0\xac\x81\x44\x9f\xc5\xda\x41\x1c\xda\x83\x48\xfb\x71\xcd\xff\x77\xad\x41\x1c\xba\xc9\x5a\x6f\x14\xbb\xd7\x46\x53\x95\xc3\x78\xe8\x1c\x81\xa3\xb5\x46\x71\x25\x8e\xaa\x41\x64\xab\xb5\xc6\x35\x4c\x85\x5f\x56\x0d\x34\x91\x9c\xea\x1c\xc3\x54\x60\xe6\xcd\x71\x96\xc6\xa2\x31\xa1\x74\x76\x4b\x78\xf7\xd0\x76\xdf\x40\x3f\xf8\x49\xdd\xdd\x4f\xca\xe9\x1c\x55\xe9\x4e\xd4\x31\x05\x99\xbd\xf5\xdd\x89\xb6\xe3\x1e\xd4\x11\xd2\x2f\xfd\xeb\xff\x52\x19\xd2\xd9\x91\x92\x0f\x4d\x07\xa5\x49\x7c\x83\xae\xd2\xec\x7d\xc9\x9f\x06\x27\x01\x5f\xa9\x9a\x6b\x0d\x62\x3e\xd7\x33\x52\x5c\x11\x92\xa0\x3e\x40\x0d\xfa\xfd\xf5\x1c\x6f\x6a\x28\x63\x2d\xda\x74\x6d\x4a\x87\x10\xc6\xd7\x71\x03\x32\xdf\xcb\xd4\x38\x01\x19\x66\xde\xa1\xf1\x6b\x64\xfc\x1a\x7f\x1a\x77\xa1\x4d\xfc\x7a\xb4\x51\x32\x01\x58\xd9\xce\x1d\x7a\x4a\x2e\x3b\x5a\xe3\x86\xcf\x0e\xbb\x53\x8a\xd0\x74\xab\x0d\xdb\x0c\xbe\x83\xb6\xe3\x58\x60\x68\x80\x84\x3b\x07\xd8\xbb\xc5\x0e\xb2\x99\x43\x81\xae\xd0\x30\xd0\xf2\xdd\xc8\x76\x25\x38\xd1\x5d\x98\x9e\x6d\xf2\x5a\x5c\x67\xd9\x75\xc7\x63\x58\x1a\x10\x90\x87\xef\x3c\x1e\x43\x7b\x40\xca\x68\xd5\x78\x6c\x82\x55\xdd\xcb\x75\x57\x05\xbe\x63\xde\x01\x27\xdc\xd6\x75\x94\x6c\xeb\x35\x67\x6d\xd8\xb6\x63\x9b\xb2\xe0\xa4\x6c\x00\xd7\x9a\xc3\x19\xce\xcc\x29\x1c\xad\x3b\x85\x23\xf7\x14\x3e\xc5\x77\x9f\xc5\x91\x73\x16\x6d\xcc\x1b\x4c\xa4\x86\xb8\xa4\xe8\xa8\x76\x3d\xa1\x37\x2d\xc7\xc4\x6c\xd2\x6a\x4d\x9b\x9b\xfa\x14\x69\xd8\xd5\xf5\xdd\xcd\x9c\x7a\xad\xb6\xe4\x1f\x79\xe9\xbc\x23\x07\x8d\xd7\xe5\xa0\xb1\x83\xf2\xe1\x1d\x97\xd5\x78\x3d\xae\x44\x8f\x1e\xb1\xf6\xbe\xd9\x6e\x7b\xf5\x8d\x6d\xa1\x73\xab\xd7\xc5\x36\xbb\xb6\x62\x2f\xdd\x66\xc7\x4a\xea\xbc\xb5\xd7\xa5\x8e\x57\x71\x39\x7b\x64\x27\xcd\x73\x1f\xc4\xb6\x39\x05\x9e\x95\x6b\x80\xfe\x64\x31\xd3\x2b\xdc\x7b\x57\xbb\xf1\x52\x08\x26\x27\xd1\x91\x97\x16\x6a\x15\xda\x5e\x27\x45\x70\x4d\x4f\x29\x94\x4e\x91\x97\xfb\x38\x26\xff\x0b\x2c\x0e\x0c\x13\x73\xb8\x7d\x8c\xbc\xb6\x27\xe2\xea\xd7\xba\xc1\x6a\x1e\xb5\xec\xe5\x23\x8f\x02\xcf\x73\x88\x0b\x6d\x7a\x53\x2f\x34\x70\x6f\xe0\x06\x51\x35\x81\x3c\x01\xb2\xf7\x1b\x2e\x48\x16\xe1\xb8\xfb\xcf\xe7\x53\x7a\xa9\x41\x09\x61\xf7\x43\x9e\x73\x16\x61\xde\x8b\x05\x67\x02\xb0\x90\x78\x70\xb1\xb1\x1e\xc0\x47\x6e\x5f\x7c\xaf\x8d\xa6\xe8\x32\x8d\x02\xd4\x3f\x51\x57\x5d\x24\x63\xe8\x96\x99\xef\xd3\xce\x85\x81\x45\x29\xf1\xaa\xf0\xb4\x74\x59\xf9\xe3\x47\x24\x3c\x9c\x75\xa4\xf7\x65\xaa\xaa\x67\x49\xbf\x49\xb9\x27\x68\xeb\x6e\xd3\xba\x66\xc0\x94\x5b\xab\x1d\x8e\x4b\xbc\x81\x7e\x5c\xe5\x0a\x0b\x84\x98\x29\x17\xf4\x4b\xc3\x2d\xed\x6c\xb2\x8c\xe3\x26\x1e\xcd\x2e\x64\xb6\xc4\xd6\x11\x1e\xad\x2e\x6e\x94\x41\xf2\xdc\xbb\x0e\xfa\x91\xe5\x4b\x9f\x6e\x40\x47\xf9\xe4\x77\x53\x22\xe1\x98\x97\x2b\xf3\x6f\x35\x79\xe2\xd3\x7b\xb7\x3e\xf8\x5b\xae\xe1\x64\x79\x77\x77\x46\xa7\x5e\x68\xdb\x7e\x7f\xcd\x91\x3d\x15\xb4\xac\xe3\x4a\x68\xb1\x6c\x43\x47\x42\xa7\xab\xe0\x56\x1c\x01\xad\x88\x2d\xe8\xb6\xdd\xb2\x42\xac\xec\xc4\x09\x70\xd0\xbf\x8f\x51\x7e\x5e\xe2\x20\x4a\xab\x1c\xa7\x06\x83\x26\x11\x70\x44\x48\xfb\x1d\x84\xbe\x01\xea\x2a\xc3\xf8\xc0\xd7\xbf\x65\xe9\x72\x51\xd9\x81\x71\x93\x0e\x28\x3c\x3b\xeb\x03\x60\xbf\x07\xa1\x7b\x06\x83\x2f\xc2\x13\x15\xc6\xf4\xa7\xd4\x77\xfa\xc2\xdd\x83\x70\x3e\x19\x09\x87\xe0\xbc\x87\xae\x08\x7e\xbf\x4b\xef\xcd\x4f\x11\xe9\xfb\xd5\x55\x54\xf8\x17\x4f\x71\x5e\x19\x6c\xfa\x68\xe4\x00\xae\x6b\x45\x41\x99\xab\xf9\x29\x04\x99\x84\x94\xa4\x10\xf9\xd3\xbd\xaa\x87\x35\x95\xea\x5a\x2d\x43\xbb\x10\xfd\x33\xf1\x57\xb4\x3f\xaa\xad\xd6\x90\x02\x09\xff\x75\x47\x3c\xbf\xbb\x4f\xab\xec\x6d\x6d\xa0\x1d\x88\x5d\x2d\x45\x6a\xdd\xb2\xcd\xa7\x61\xc3\x50\x3f\x3c\xd7\xd6\xaa\xea\x18\xba\xd2\x13\xd0\x2e\xcb\xb1\x38\x8a\xd7\x93\x66\xa0\x16\x08\x31\x50\x4f\x5b\x7e\xe6\xc3\xd7\x28\x59\x2c\x21\x0c\x24\xf7\xb1\x64\xae\x59\x1c\xe4\xb9\x9f\x26\xab\xae\x32\x6e\x5e\x57\xc1\x63\xe9\x7d\xa8\xad\xe1\xe4\x2b\x6c\x5d\xd4\xcf\xdc\x88\xf7\x20\x6f\xd5\x1e\x00\xf6\x78\x10\x27\xae\x34\x65\xe7\xb7\xe7\x94\x0c\xe1\xd3\xc9\x9d\x0d\xf3\xcf\x43\x9e\x81\xbe\x63\x9a\xb8\xe9\x9d\x9c\x8f\x84\x1e\xad\x9c\xf3\x53\x9d\xe0\x4f\x5b\x6d\xbd\xa9\x09\x89\xb9\xe2\x9a\xe3\xb2\x0e\x47\x3e\x8b\x4e\xc4\x87\x47\xda\xb0\x6b\xe8\xa5\x3d\x93\x41\xba\xa3\x5c\x28\x24\x82\x0e\x8a\x78\x7e\xfd\x19\x61\x91\xbe\x71\x8e\x30\x0a\xd3\xa4\x40\x71\x74\x8e\x8b\x65\x46\x4a\x3d\x66\x53\xfd\x27\x8e\x62\xfb\xe7\x0f\xd1\x6e\x63\x31\xd7\x62\x6d\x58\x62\x13\x91\xc5\xf1\x39\x6c\x2b\x92\x23\xc4\x36\xa6\xba\xac\xb6\xc1\x4d\x9b\xc8\xa2\xc5\x22\x26\x88\x84\x21\xf1\x8b\xd5\x2d\xbd\x04\xf0\x35\x9a\x6b\xbe\x42\x96\xc9\x0e\xd6\x48\xf4\x65\x2d\x0e\xe5\x36\xa0\x2f\x06\x3a\x94\x67\x70\xd2\x9c\xc9\xe4\x51\x6a\x04\x68\x39\x6c\xaf\x6b\x2d\x0c\x88\x71\x7f\x81\x0b\xa5\x1c\x2d\x52\xb4\xc0\x79\x0e\x19\x35\x43\x44\x6f\xe3\x33\xec\xbf\x17\xed\x27\xf0\x8e\x85\xb5\xe6\xca\x2e\x00\x1f\x5e\x92\xb0\x92\x08\x3a\xd6\x9c\x04\xf7\xa2\x4a\xd6\x5d\x95\xcf\x04\x89\x61\x94\x91\x40\x71\x5d\x0e\x51\xfa\x60\x4f\xc6\xc9\xb9\xe0\x37\xde\xe8\x02\x67\x78\x8e\x3e\xb0\x21\xb9\x45\xe4\x92\x72\x27\x65\x62\xf6\x57\x9e\x2e\x33\x5f\x85\x0f\xe2\x2d\x98\x75\xe9\x22\x20\x38\xb9\x15\x1b\x34\x54\x3f\xe3\x3f\xce\x94\xcf\x8e\x5a\xe1\xb2\x8f\xf4\x20\x66\x8e\xcf\xab\x47\xa9\x62\x98\x54\x38\xf8\x8d\x0f\x42\xee\x6d\xb4\xfe\x51\x68\x74\xcd\xc1\x04\xf5\x4e\x4e\x0c\xaf\x14\xcc\xb8\xbe\x74\x85\xa6\x37\x5f\xe0\xc4\xe3\xd2\xca\xc9\xde\x9e\x96\x06\x16\xbc\xc8\xf2\x34\x26\xf1\x0d\xcb\xeb\x1a\x9d\x9f\x93\x0c\xe1\x45\x84\x82\xd4\x47\xe7\x24\x21\x19\xb8\xa8\xd3\x4a\x66\x0a\xd7\x6e\x42\xae\x8b\x6e\x1c\x25\x7a\x2a\xd6\x4b\x9c\xe5\x4a\x62\xb4\xae\xc1\x7a\x99\x94\xa0\x65\xa1\xee\x0d\xa5\x6c\x04\x21\x08\xa1\x12\x68\x73\xad\xf2\xf0\x4e\x41\x13\x3e\x95\xdc\xf4\xe5\x08\x2c\xcd\xb4\xf1\xc3\x2d\xab\xe3\x87\x5b\xd7\xc7\x0f\x95\x1a\x91\x8b\x2a\x2b\xe3\xc5\x37\x44\xca\xc5\x87\xed\xa2\x63\xb2\xc7\x96\x70\x52\xc1\x60\xed\x64\x03\xf7\x8a\x0b\x9b\x77\x55\x4a\x00\x5b\xe3\x43\x71\x9a\x57\x23\xa4\x03\xd4\x18\x5d\xb2\x4d\x8e\x16\x67\xe8\x96\x68\x13\xe7\xe9\x0a\x93\xd2\x36\x0e\xd4\xc6\x34\xad\x30\x31\xc9\x01\x03\x78\x61\x10\xda\x85\x71\x65\x78\x1f\x8d\x2b\x3b\xd1\xf8\x2e\x96\x59\x95\x7a\x6e\x78\x64\x40\xd5\xe1\xa4\xdf\x95\xce\xf6\xf2\x9c\x1e\x85\x55\x58\x27\x36\x60\xad\x66\x97\x81\x7c\x2a\xdb\xc6\x9e\x12\x3c\x51\x17\x41\x3b\x09\x8e\x0d\x91\xef\xbb\xfd\x35\xa4\xb8\x05\x2e\x2e\xc0\x60\x1f\x4c\x91\xf7\xdb\x60\x88\x0e\xfd\xee\xb0\x77\x78\x80\xfa\xdd\x09\x1a\xf6\x86\xe3\xee\x04\x4d\x72\xfa\x07\x9a\xb0\xff\xd7\x65\x3f\xba\xec\x8f\x2e\xfd\x63\xf2\xc7\xbc\xdf\x9d\x3c\x3b\xe8\x8d\x8f\xd0\x10\x0d\x11\xff\x63\x30\xcc\xc7\xf4\xaf\x41\x5f\xfe\x5f\x97\x17\x74\x07\xfd\x57\x83\xc3\xde\x64\x08\x60\x68\xf8\xc7\xbc\x8f\x06\x47\x3e\xfd\x3c\x44\xfd\xee\x51\x77\xd4\x9b\x1c\x75\x8f\xba\x47\x39\xfb\x03\xc1\xff\x47\xf4\x07\xa2\x3f\xd8\x1f\xb4\xec\x0f\x0f\x49\x06\x74\xaa\xd4\x4d\xa1\xd0\xf8\xea\x96\x0e\x57\x79\x90\x48\xae\x90\x2a\xbb\x3d\xee\x3b\xb3\xc8\xa5\xaf\x46\xc8\x3d\x18\xb8\x98\x69\x13\x05\xbb\x0d\xf0\xac\xda\x63\x9c\xda\xfa\x72\x61\x6f\xbe\x8c\x84\x26\x90\x53\x52\xa3\x0b\x34\xaa\x96\x12\x0b\x0f\xee\x59\xba\xf7\x87\x6d\xe4\x4b\xd9\x46\x86\xf7\x6a\x37\xd0\x4d\x5c\xae\xfd\x40\x7e\xff\xd4\x3b\x82\x4e\xd8\x8a\x3d\x41\xb7\x9f\xb9\x8a\x37\xd9\x17\x64\xe5\xf2\xce\xb0\xcd\xec\xfc\x9f\xde\x70\xfe\xb5\x65\x99\x39\x27\xb4\xb8\x48\xe9\x25\xe5\x45\x58\x41\xc2\x51\x05\x78\xdd\xbe\x64\x42\x9a\x91\x91\x9e\xe1\x38\x86\x93\xa5\xaa\xcf\xc7\x15\xf0\x75\x5d\xb5\x30\x2b\x0c\xb0\xec\xc0\x85\xb0\xaa\xb9\x41\xdf\x05\x5d\xdb\x98\x86\x54\x9d\x01\x69\x9e\x47\xb3\x98\x3c\x4b\x93\xbc\xc8\x96\x7e\x91\x66\x2f\x61\x2b\xa8\x6c\x77\xb0\xba\x6e\x1d\x15\xd5\x0d\x4a\xbc\x3c\xe2\x61\x75\xd7\xcb\xa0\x75\x2d\x4a\x74\xbb\x3d\x73\x7f\x49\xb3\x79\x9d\xbf\xd2\xf0\x78\x58\x86\xad\x43\x2f\x81\x64\xb5\x0b\x12\x2f\x48\x56\x19\xca\x6b\xfc\xd5\x3a\x1b\x54\x64\xfc\x97\x23\x78\xf7\xd7\xdb\xec\x25\x34\xe4\xae\xae\xd1\x3c\x7f\x11\xe9\x3e\xcb\x0a\xf7\x84\x9e\xb4\x60\x04\x2b\x52\x94\x11\x11\x4a\xbc\x28\xeb\xe2\x21\xd9\x42\x6f\x73\x63\x8a\x6d\x66\x48\x93\xa7\xf1\xb2\xfa\x89\x70\xd9\x4e\xe1\xb2\xc6\x60\x04\x3e\x11\x3c\xc9\x2d\x8a\x72\x99\x53\x72\xdb\x36\x19\xd6\xa5\x5b\x3e\x2a\x60\x90\x81\x3f\xcf\xa4\x21\x46\xe4\x3d\xd6\x29\xda\xa6\x5d\x26\x4d\xfe\x27\xb9\xf9\x29\xbd\xaa\x0e\xcb\x5b\xc6\xf1\x2f\xc3\x54\xe4\xa2\x70\x43\xdb\x8a\xe1\xc3\x29\x37\xa6\xd6\x3b\x60\xbf\xbf\xc8\x75\xca\x24\x50\x90\x08\xe5\x7e\x6e\x49\x85\x80\xa4\x83\x4a\x35\xe1\xfd\x90\x29\xe4\x02\x68\x4b\x4f\x00\xc0\xa3\x2c\xca\x9f\x05\x99\x53\x5c\xc5\x45\x94\x83\xf2\xaa\xe0\x1f\xd5\x03\x3d\x75\x78\x2b\x3a\x18\xb8\xe6\xf0\xc9\x6b\x85\x69\x86\x5a\x80\x37\x26\xf4\x7a\x84\xb3\xf3\xe5\x1c\x5c\x06\x62\x92\x9c\x17\x17\x1d\x5a\x42\xf7\x93\x27\x59\x86\x6f\x5a\x14\xaa\xdd\x41\xef\xde\x93\x1b\x74\x8a\xfa\x27\xec\xaf\xef\xa1\x36\xfb\xf1\xf8\xb1\x7a\x4b\x43\xab\xbe\xa1\x85\x6f\x75\xcc\xac\x44\xbc\x0a\x31\xfc\x54\x33\x48\x33\xd0\x82\x3e\xb2\x3f\x2e\x22\xf9\x26\xbb\xfa\xc0\xb6\xbb\x29\x9e\x11\xa8\xee\xf6\xde\xd1\x6d\xa2\x48\xdf\xbd\xa3\x9b\x31\xa0\xb3\x04\x2b\xd7\x94\xb5\xdb\xa0\xf3\xeb\x41\x12\x73\xee\x6d\xfe\x86\x36\xf1\xb6\xe7\xa7\x89\x8f\x8b\x16\xed\x61\xbb\xdd\xe6\xf3\x21\xfe\xed\x01\xf7\x51\xc2\xdf\xbc\x15\x45\x61\xea\x2f\x0d\xc3\x57\x4b\x7b\x73\x14\xa2\xd6\x37\x46\xcd\x8f\x1f\x91\x51\xc0\x67\xa3\xad\xc5\x07\x61\x63\x76\x22\x03\x7e\xc8\x57\xf7\x19\x82\xb6\x5e\x0a\x1a\x0c\x3c\x61\x14\x17\x24\x6b\x29\x2a\x92\x32\x4e\xf4\x8d\xf2\x06\x93\xf8\x05\xc3\x70\x6a\xb5\x26\xd6\xa3\x4d\xac\x50\xc3\xa5\x8c\x8b\x06\xbd\x30\x4a\x82\x76\x4b\xc3\xdd\x41\xf5\x94\x26\x3d\x79\x2b\x72\xd2\x69\xb4\xa6\xd7\x37\x3e\xb0\xc9\x69\xb5\x4f\x56\x75\x40\xa3\xec\x4d\xff\xad\x59\xed\x56\xcc\xf4\x05\x4e\x82\x98\x00\x14\xdb\x10\x8d\x59\x87\xed\xb8\x23\xcc\x7c\x26\x0f\x88\x0b\xe6\xa3\x47\x1c\x15\x0b\x9a\x20\x36\x56\x9d\x7e\xd7\x77\x81\x1b\xfe\xe9\x15\x38\x3b\x27\x45\x4f\x7f\xed\xa7\xe2\xe6\xb0\x6d\x44\xe8\xd2\x9b\xac\x2c\x6d\xc3\x69\xcb\x14\x18\x6c\xcf\xd1\x04\x78\xf7\xc6\xf7\x86\xd1\xfd\x9e\xdc\x40\x38\xcf\x24\x20\x22\x00\x16\xdf\x90\xe5\xf0\xb0\x8f\xda\xd2\x60\x5b\xde\x45\x04\xe2\x34\xfd\xf7\x44\x67\x26\x38\xfb\x73\xfe\xa5\xa7\x5d\xe2\xb9\xbb\x23\x17\x68\xe8\x22\xe0\x41\x2d\x78\x89\x0e\x95\xb0\x9b\x38\x87\x48\xb4\x80\x18\x48\x0b\x70\xf1\xce\x11\xe1\x82\xfe\x27\x06\x5f\x81\x88\x12\x03\x6a\xbd\x20\x17\xef\x54\x94\x0b\x4e\xb0\xa7\x2c\x40\x2a\xa0\x85\xb4\xe2\x88\x68\x16\x88\x65\xe9\x31\x36\x20\x39\x60\xcd\x95\x24\xc0\x60\x4a\xca\x37\x55\x25\xa8\xee\x39\x1e\x4f\xff\x01\xcd\x9f\xc3\xb3\x05\x95\x37\x5f\x55\xb7\x49\x78\xc6\x3b\xd9\x9b\xe3\x45\x4b\x4e\x91\xb6\x68\xa0\x8c\x05\xc4\xb9\xd6\x57\x81\xd8\x3a\x2d\x7c\x51\xfe\x2f\x1c\x47\x81\xe8\x13\xd4\x6e\x9b\xf5\xd4\x0e\xb2\x8c\xe3\x13\xed\x83\x5c\xeb\x75\x43\x16\xa7\x09\x31\xb0\x77\x2c\xe4\xc0\xea\x40\x6e\xc7\x28\x67\x22\xa5\xcd\x63\xba\xe7\x8f\xec\xb4\x28\x6a\x25\x54\xac\xb5\xf0\xb3\x8e\xbb\xbf\xf0\xcd\x61\x28\xb6\xfc\xc5\x32\xbf\x60\xa0\x27\x16\xe4\xad\xf1\xfb\xd6\x24\x49\xfa\x3c\xf0\x15\x70\x7a\xca\xd6\x53\xaf\x62\x21\x18\x02\x20\x23\xa0\xb4\x13\xea\xe3\xac\x51\xc3\x53\x65\x80\xd2\x4d\xd0\x75\xfb\x56\x4f\xcb\xaa\x76\x93\x93\xbd\xdb\x56\x89\x7f\x74\x89\x4a\x3b\xf4\x37\x71\x16\xf9\xf0\xe5\x5c\x84\x1a\xde\x60\x1a\xde\x53\x1a\x0b\xf8\xcd\xc5\xf8\xa6\x02\x39\x37\xce\x56\xe8\x47\x39\x5b\xec\xc2\x74\x3b\xf9\x02\x34\xab\x5f\x79\x8c\xfa\x9d\x2a\x96\x8b\x94\x8a\x4c\xcb\x39\x15\x95\xe1\x82\x54\xa9\xf4\x3b\xaa\xa9\x54\xd7\x64\xb9\x85\x07\x45\xf2\x83\x22\xf9\x1e\x2b\x92\x3f\x45\xce\x86\xf7\xe4\xc6\xaf\x56\xce\x1e\x4e\x6c\xc0\x3a\xf4\x1c\xe4\x93\xe4\x83\xf8\x8d\x24\xcb\x0a\xc4\xa3\x7e\xdf\x00\xab\x43\x4b\xbf\x4b\xe0\xe7\xe0\x4c\x5e\xb5\xeb\xa8\xa1\x78\x92\x65\xe9\xd5\x4f\x59\xba\xa0\xe7\x72\xe5\xf3\xc1\x03\x37\x7c\x1d\x35\x06\xe0\x57\xab\xc3\x5f\x87\x28\x7e\x73\xb8\x33\x5d\x02\xcf\x16\x49\xab\x7a\x62\x06\x4f\xcd\x41\xc3\x0a\x21\xd4\x85\xba\x75\x91\x2e\xd2\x4b\x92\xb1\xa7\x26\x78\x59\xa4\x73\x5c\x44\x54\xd6\xba\x41\x33\x82\x72\x52\x20\xec\xfb\x69\x16\x40\x98\x55\xf6\x06\x22\x2a\xc8\x3c\x47\x51\x92\x47\x01\xe8\xe0\x59\x13\x73\x92\x2c\xf9\x3d\xf1\x2a\xca\x89\xfe\x7c\x05\x17\x28\x26\x38\x2f\xca\xad\x33\x1d\x0e\xbb\x28\x29\x1d\x2f\x25\x83\xa7\xe4\xab\xf1\x81\x35\x1c\xbc\x6d\x8b\x41\xba\x00\xfe\xe5\xcf\x44\x72\x78\xd5\x91\x2e\x96\x31\x2e\x88\xde\xf0\x55\x54\x5c\xf4\x84\xe2\x3e\x81\x1e\xa7\x73\x82\xce\xe8\xfa\x7c\x5e\x90\xf9\x19\x53\xe0\x9f\xb1\x67\x1f\x67\x28\xca\x11\x84\xdd\x81\x80\xa2\x67\xac\x11\x07\x0c\x1d\xeb\x7b\x60\x94\xd1\x46\x68\xf3\x8a\xd3\xcf\x75\xfb\xa9\x9c\xdf\x4f\xfb\x74\x8e\x72\xd3\xb3\x57\xaf\x58\x5d\xa6\x69\x32\x99\xb7\xf4\x14\x69\xb3\xc7\x75\xf6\x9b\x38\xc1\xa0\xbb\x7b\x13\x27\x2d\x2d\x74\x41\x53\xb6\xe5\x0f\xd7\x48\x00\xfa\x47\x14\x85\x28\x2a\x78\xb6\x72\xfa\x99\xcc\x17\xc5\x0d\x5f\x2d\xff\x3b\x5d\x22\x1f\x27\x2c\x10\xef\x92\x2f\x77\xf1\xf2\x48\x2e\x05\xf9\xa8\x2a\xca\xd1\x19\x2c\x9c\x33\xd4\x12\xba\x26\xa3\x2b\xb4\xdd\x9f\x29\xfe\xcd\x96\x7c\xe5\x13\x5a\xf5\x82\x8e\x6e\x60\x58\xbc\xdf\x3a\x63\x7d\x77\xbc\x23\x63\x00\x1b\x53\xc1\x76\x59\x61\x74\x9b\x2f\xf3\x02\x36\xc0\x04\xb1\xbc\xc8\x98\x73\x2b\xdd\x2c\x19\x6d\xf9\x72\x41\x6f\x83\x68\xbe\x8c\x8b\x68\x11\x8b\x59\x89\xd2\x24\xdf\xc5\x50\x8b\x66\x36\xeb\x60\xcd\xbb\x3c\xba\x63\x3a\x86\x93\x16\xaf\xff\x2a\x0f\x3c\xab\x70\x51\x64\xd1\x6c\x59\xc8\xf5\x26\x27\x2d\xcd\x10\xcb\x1a\x55\xfd\x1c\xf0\x73\x1a\x7e\x85\xf0\x64\x58\x80\x61\xc6\xc5\x42\xdb\x95\xf9\x57\xd4\x85\x13\x07\xea\xb2\x0b\x02\x1f\x1e\xf6\xd2\xf1\x0a\x2b\x02\xb6\x6b\xf9\xfd\x25\xf5\x97\xd5\x13\xbd\x1a\x43\x46\x70\xf0\x22\x89\xeb\xf7\x00\x13\xc5\x4b\xb0\x36\x98\xdb\x19\x2c\xbe\x5d\x2c\x1e\x66\xda\xf8\x57\xad\xc2\xab\xdc\xcb\x0d\x9f\x98\x56\x9d\x2e\xac\xbc\xe1\x13\xd3\x95\x8f\x16\x3b\x28\x13\x07\x7d\x98\x66\x08\x0b\x17\x8a\x98\x04\xeb\xbf\x6c\x5c\xfd\x42\x84\xaf\xbc\x15\xf1\xdf\x85\x9c\xf4\x97\x97\x9c\x21\x9e\xb0\xa4\xf2\xb6\x28\x54\x81\x25\x4a\xf2\x02\x27\x3e\x79\x11\xb6\x4c\x0c\xed\x6a\xf1\x04\x27\x37\x6f\xdb\xe0\x37\xb0\x96\xbf\xee\x2b\x98\x0c\x71\x81\xdb\xd4\xc3\x40\xc3\xb2\xd2\xc5\x40\x83\xdd\x99\x8f\x81\xd6\xc6\x57\xe1\x64\xa0\xf5\x77\x1d\x2f\x03\x7d\x98\x36\x75\x33\x60\x8f\xb4\x4f\xd5\x50\x24\xfe\x45\x9a\xfd\x1c\xeb\xc1\x28\x11\x4a\x17\xf4\xf6\x00\x1b\x93\x69\xa8\x66\x4c\xfa\x0f\x72\x5d\xd0\xd3\x8a\xb2\x20\x0b\x0a\xaa\x9b\xb1\x9f\xc5\x91\xff\xbe\x6c\xc0\x6e\xeb\x89\x69\x5e\x2c\x48\x22\x12\x69\xb0\x93\x2a\x47\xe7\x29\xbf\xf3\xcd\x28\xea\xe2\x82\xf4\xd0\x73\x25\x50\x81\xe1\x9c\x04\x90\xcf\x84\xed\xa8\x7e\x9c\xe6\xfc\x48\x93\xd6\xed\x12\x7d\x54\x3e\x3a\x31\x40\x72\x52\xbc\x82\xd4\x65\x7a\xde\x14\xb8\x2c\x65\xba\x75\x4a\x0d\x0c\xb3\x8d\xfb\xcb\x2c\x23\x49\xf1\x1a\x4c\xe4\x7b\xa6\x41\xca\xb6\xe3\x93\xff\xbb\x24\x79\xf1\x8c\xd2\x57\xe1\xbe\xb1\x82\x14\x35\xf2\x95\x8d\xd0\xdb\x62\x79\xa4\x99\xdd\x52\x36\xc3\xf9\xb7\x72\x26\x0c\x3f\x12\x9e\xa9\x81\x0b\x6c\xa6\x91\xb0\x92\x5e\x37\xcd\x25\x6b\xdd\x9e\xd1\xe0\x2a\x4f\x05\xbe\xa5\xe8\x76\x72\x47\x8d\x93\x3d\xbb\x82\x30\xbc\xeb\x41\x64\xb5\xcf\xcc\xbd\x41\xfb\x6e\x19\x85\x75\x27\x08\xdb\x46\xaa\x2a\xeb\x50\x95\x56\x60\xbb\x97\xee\x51\x45\x8a\x64\xd8\xc6\x7a\x51\xce\xb7\x33\xad\x2a\xf3\xc6\x40\x3f\xa2\x37\x72\x6d\xc3\x36\x51\xb6\x09\x58\x9e\x17\x46\x7d\x7a\x14\xbd\x79\x6b\x5a\x73\x21\xa4\x75\x41\xe6\xf0\x0e\x93\x0e\x32\x13\x64\xc0\x06\xfd\x22\x6c\x95\x4c\xb7\x96\x31\x98\xf6\x51\xab\x7e\x7a\x8a\xba\x83\xb2\x69\x99\x23\x05\x8b\xf2\x2a\x8c\x56\xbc\x62\x0b\x45\xbe\x88\x23\x9f\xa8\x26\x3b\x68\x60\xd7\xdf\x5b\x81\x4b\x0e\x77\x89\x92\xca\x99\x64\xd3\xbd\x20\x59\x1e\xe5\x45\xcb\x68\x50\xe7\x04\x71\x18\x38\x3c\x1c\x60\xe1\x02\x50\x07\x7d\x90\x12\x0d\xa3\x44\xf3\x3d\x02\xfa\x6c\xbf\x1c\xb6\x9e\xf5\x85\xc4\xff\x75\xee\x09\x62\x4f\xae\x5a\xee\x8a\x2b\xed\x7d\xf2\x94\xed\x94\xfa\xf4\x41\xc8\x07\x82\x78\x66\x51\xa5\xdd\x40\x38\xa3\x62\x7e\x7c\x43\x77\xeb\x94\x09\xb6\xb3\xe5\x6c\x16\xc3\x6f\x26\xee\xb1\x91\xd9\x33\x07\x2a\x2f\xd2\x05\xbd\x9a\xe1\x73\x08\x0f\xa1\x8f\x65\xdd\xe1\xb2\xd2\xc3\xaa\xbc\xa3\xd0\xea\xd5\x9e\x4f\xf4\x2b\x1f\x19\x87\x8f\x93\x1a\x4d\x6e\x90\x6e\x36\xa0\x0c\xb9\xb8\x50\x34\x70\x6c\xa3\x55\xdf\x78\xf9\x02\xfb\xe0\x97\x03\xd1\x3a\xbd\x20\xbd\x4a\xbc\xb7\xbd\x28\xf1\xe3\x65\x40\x72\xb6\xd0\x85\x45\x42\xb1\x14\xa3\xc2\x70\x4f\xe1\x6c\x9a\xc1\xbf\x42\x6d\xae\x8d\xf0\x4e\xce\xdc\x46\xa7\x6e\xed\xe1\xe1\x3a\x79\x9b\x9d\xbd\xfa\x01\xe3\x9c\xbe\x57\xe2\xde\x62\x4c\xa0\xe9\xff\x52\x3a\xfd\xe4\x65\xa7\xc1\x0c\x3a\xeb\x69\xbd\x4b\x20\xe6\x6f\xa2\x65\x3e\x82\x69\x78\x7a\xc3\x2e\x63\xa5\xe8\x3e\x38\x47\x57\x04\x5c\x04\x72\x42\xaf\x6a\x91\x7f\x81\xd8\x05\x1b\xb5\x40\x9b\xd3\x56\xe3\x2e\x76\x11\x7b\x9f\x77\xc9\x0c\x3b\xf6\xda\x33\x2e\x13\x9f\xcb\x6d\x4f\x6a\xf0\x95\x4f\x9d\x2c\x5a\xdf\xbd\x4f\x2a\x54\xe9\x76\xa5\x81\xda\xd9\xaf\x24\x2c\xb3\x5c\x3a\x93\x68\x21\x2d\xaa\xa2\x02\x12\x25\x16\x94\xd4\x4a\x1a\x90\xb2\xb4\xb9\x0b\x22\x67\x2c\xed\x3b\xfd\xad\x43\x48\xfd\x9f\x84\x11\x25\x3a\x14\xfb\xf4\x17\xa9\x55\x53\xd0\xb2\x48\x07\x2f\xc3\xe9\x55\xf5\xec\x09\xe8\x47\xf4\xe1\x96\x5e\x8f\x2d\x28\xd3\x4f\x92\x6f\x27\xef\xf4\xad\x7b\x03\x4f\x4a\xa6\x28\xd2\x81\xa0\x40\x87\x11\x3b\xb7\x02\x12\x25\x26\x94\x54\xc8\xe8\x80\xb2\x50\x87\xcd\xb5\xfd\xe7\x9d\xb5\x4b\xac\xe5\x2d\xba\xa9\x1f\xa8\x5c\x00\x90\xe2\x4c\x73\x0a\x35\x73\x9f\xa9\x9c\x68\x5a\x78\x19\x4f\x67\x3b\xdd\x91\x34\xe1\x79\xf5\x91\x27\xd8\x85\xfe\x2d\xa7\x8f\xb9\x98\xd2\x69\xf2\xcc\x90\x21\x1e\x1f\x73\xfa\xa7\x18\x59\xf6\xb7\x1c\x3c\xfa\x53\x8e\x90\x72\x5a\xd5\x1d\x55\xc1\x83\x11\x28\xd0\xf7\xe7\x3b\xe6\xb5\x50\x2b\xe1\x54\xde\x67\xcb\x49\x2e\x7c\x9c\xa0\x24\x2d\x40\xa7\x67\xe8\xf2\xc0\x32\x27\x70\x48\xd5\x5e\x44\x72\x96\xa1\x04\x33\x2b\x64\x4e\x97\x6b\x11\xcd\x09\x15\x99\x30\x3a\x7b\xc5\x55\xcb\x4a\xc7\x53\x4a\x7f\xb1\x85\xae\x7d\xa3\xf3\xa6\xd5\x29\xe8\x84\xf6\xdd\xd4\x4a\xf2\xae\x06\x68\x76\x63\x9c\x54\xf3\x05\xd3\x0f\x82\x08\xb7\x1b\x9a\x8d\x1d\xcf\x45\xb4\x0e\x70\x67\xaa\xad\x53\xbe\xa9\xaf\xb3\x91\x6a\x84\xfd\x67\xa4\xc5\xd0\xf3\xb2\x99\x6e\xb2\x8d\x1b\x40\x62\x39\x78\xa6\xcf\x6c\xd5\x3d\xc3\xba\x35\x69\xc4\xac\x4e\xc4\xc5\x1a\x5a\x15\x27\x87\x5e\x65\x64\x16\x32\x71\x82\xc9\xd3\x4d\x4f\x2c\x47\x2b\xb7\x3b\x16\x45\x55\x9e\xcc\xba\x6d\xd1\x75\x30\x22\xa4\xcc\x23\xe5\x33\x00\x19\x6e\xc4\xae\xfd\x1f\x21\xcd\x58\xe0\xd8\xfb\x91\x12\x4f\x1c\x2e\xca\xba\x99\x40\xfc\x65\xde\x3a\xb9\x17\x82\xed\xd0\x4d\x2b\x86\x53\x75\x0e\x98\x95\xda\xb6\xeb\x34\xdb\x9f\xb5\xc2\x76\x73\xae\xb1\x5c\x6f\x54\xb4\x61\x27\x4f\x42\xdc\x50\xe9\x40\x2d\x5d\xa8\xad\xcb\x89\xf2\xe1\x76\xa4\x3c\x42\xa8\xb8\xc8\xd2\x2b\x94\x90\x2b\xf4\x73\x96\xa5\x59\xcb\xb1\x4e\x2f\xcb\xdb\x8a\x54\xfe\xab\xec\x4d\x2a\xa3\x6e\x79\x53\x04\x7f\x09\xb1\xd5\x9e\x32\x43\x49\xcf\x2b\xd3\x0b\x29\x39\x79\x14\x54\x5b\xfd\xa3\x7d\x7b\x15\x25\xe7\x20\xf1\x78\x9e\xe3\xeb\x6f\x4a\x22\x52\x9a\x12\x48\x93\x9a\xce\x17\xcb\x82\xfc\x24\x1b\xe0\xf7\x52\x0e\xb2\xbf\x8f\xfe\x91\xca\x24\x48\x82\x0c\x9c\xdc\x08\x4b\x36\xbb\x13\x87\x11\x89\x03\xd3\xac\xcd\x47\x1a\x16\x1d\xd3\x06\x47\xf9\x4f\x51\x56\xdc\x30\x85\x71\x8f\x87\xab\xf8\xf8\xd1\x90\x0d\x6d\xf5\x9d\xb6\x87\x9b\xea\x17\x35\x22\x1a\x48\xcb\x56\xbc\x38\x14\x25\xa5\x0e\x9b\xf7\xb9\x5b\xd7\xf0\x33\x27\x9d\x72\x28\x91\x66\x0f\x35\xca\x2a\xc9\xf5\xdf\x67\x38\x5f\x67\xdc\x6a\x57\x26\xf5\x92\xcc\xa5\x03\x84\x1c\x60\x4e\x35\x1d\x10\x64\x2a\xe8\x84\x52\xcd\x5c\xf1\x1b\xac\x89\x92\xc5\x7e\xad\x85\x21\xc5\x0e\x6d\x51\x20\x5b\x83\xa5\x77\x7a\x85\x82\x0f\x8e\xe9\xee\xe0\xc4\xea\xbc\xc4\xf0\xe8\x91\xc5\x1b\xf6\x08\x58\x4b\xa9\xac\xf6\x13\x1c\x60\x91\x5b\xc3\x8c\x36\xf9\xee\x67\x25\x77\x26\x59\xee\x0d\x2e\x6a\x2b\x88\x5d\x2d\x3c\xac\x78\xf5\xc3\xdf\x3e\x31\xbf\x2e\xaf\x7c\x7b\xa0\x27\xa2\xf8\xcb\xba\xf7\xc4\x91\xff\xde\x7a\x35\x23\x4d\x02\x7c\x79\xb8\x34\x25\xe6\x5b\xc7\xea\x91\x51\x7b\x87\x14\x8f\x7f\x2c\xcd\xee\x7f\xd3\x28\x69\x51\x49\x9d\x0a\x54\xc6\x38\x3a\x77\xe8\x79\x94\x44\xf3\xe5\x9c\x5e\x16\xc4\x5d\x5d\xd9\xa4\x7a\x42\xe9\x83\xbe\x39\x65\xd9\xc8\x1e\x3d\x42\xdf\xa8\x7b\xfd\x8f\x2e\xd8\x9e\x1f\x47\x24\x29\x18\xc4\xd4\xc8\x95\x52\x3f\x2f\x6e\x99\xcb\x12\xe9\x1a\x09\x74\x77\x90\x17\x4d\x01\x60\x13\x71\xcd\xfc\xfd\x1b\x78\x44\x6e\x59\x84\x33\x05\x52\xc8\x12\xb9\xc8\x48\x9e\x93\xc0\x9b\xea\x53\x92\x2e\x48\x82\x7e\x44\x1e\x3d\x2a\x3c\x34\x45\x1e\x1c\x92\x96\xe8\xaa\x82\x28\x4b\x95\x88\x4c\x3d\xd7\x37\x41\xf9\xd2\x60\xcf\xf1\x2d\x34\x8c\x8c\xf4\x2a\xc9\xdd\x34\xcc\x49\xb2\xec\x42\x92\x44\xd0\x92\x7c\xfc\x88\x3c\xcf\xcc\xb7\x67\x62\xba\xc0\xf9\x22\x5d\x2c\x17\xde\x94\xd3\x6f\x3f\x52\x93\x6f\x93\xca\xea\x61\x1b\x94\x89\xa9\x96\x52\xbe\xf4\xe8\x8d\xad\x5e\x39\x08\x1f\x3f\x2a\x05\x84\x1c\x10\xdb\xa4\x6a\x23\x31\x05\x5a\x7d\x87\x72\x68\x95\x94\xb0\xd7\x94\x75\x59\x30\x52\xaf\xd3\xe4\xbe\xc1\xa5\x67\xd7\x19\x89\x7e\xe4\xa7\x0e\xdf\x2c\xd8\xe5\xcb\x16\xb3\xdd\x57\x83\x1a\xc1\xdb\x2d\x74\x83\xc0\xed\xd2\x01\xeb\x58\x0b\x96\x36\x84\x79\x74\x79\xda\x26\xd9\x78\x68\x36\x12\xb7\x37\xd8\x32\x98\x5b\x7f\xf9\x2d\x6d\xc3\x3b\x60\x14\x4c\x2b\xd6\x82\xc9\x4a\x4a\xdd\xee\xd8\x62\x2d\xae\x63\xfa\x7a\x73\xc9\xd9\x8c\xa9\xdb\xbf\x8d\xe9\xd0\x3f\x18\xfc\xaa\x14\x87\xf6\x25\x8a\x7e\xf8\x35\xca\x45\xa4\xfd\x1a\x1b\x9b\x44\xd1\x33\xea\x38\x6e\x65\x6c\x67\x89\xa3\xbc\x98\xa5\xd7\x5e\xed\xb5\xec\x77\xbc\x20\xd9\x3a\x6d\xab\x0a\xe5\x86\x79\x5a\xcc\x86\xf7\x77\x44\xcf\x4b\xee\x95\x6e\x9f\x9c\x16\x68\x05\x05\xf2\x24\xfd\xd1\xf9\x99\xe5\x26\xe2\xdb\x62\xdb\x1a\x86\xbd\xaa\x31\x01\x39\x5f\xed\x26\xfc\xaf\xca\x57\xb8\x9a\x75\x60\xe5\x33\x5c\xdd\x2d\x46\x0f\x77\xa7\x8a\x3d\xd7\x8b\x4e\xa3\x89\x5d\x3c\xe9\x3c\x78\x08\xa3\xf9\x10\x46\x73\xeb\x61\x34\x0f\xd1\xa0\x1f\xb3\x98\xbb\x13\x3d\xb0\xa5\xfd\xea\x4a\xf6\xd4\xf8\xf0\x49\x42\x59\xee\xd9\xb4\xb8\x82\x58\xda\x8f\xb9\x8c\xdf\x8d\xc3\x56\x1a\xb5\xca\xf1\x2a\x0f\xef\xe3\x12\x7c\x95\x60\xff\xfd\x0c\x67\x95\x4f\xe3\x8e\x3e\x73\xc2\x51\x41\x60\x65\xce\x51\x01\xf0\x8c\x07\x7a\xab\x7a\x68\x38\x69\xd2\x11\x0b\xd9\x2e\x3b\xc4\x9b\xb8\x0f\x29\x48\x8f\xee\x17\x67\xae\xce\x1f\xfa\x10\x36\xf5\xe1\xb5\xfb\xc3\x6b\xf7\x46\xaf\xdd\x3f\x47\xaa\xdd\x3f\xe9\xfb\x7a\x68\xf1\xe7\x4b\x92\x14\xf4\xe6\x45\x12\x52\x75\x2a\x8e\x47\x35\x75\x56\xf6\xc9\x80\xfe\xa4\x69\x83\x8b\x0c\x27\x79\x04\xef\xe4\xaa\x1a\x51\x5b\x27\xe8\x6b\x9e\x5c\xe1\x9b\x15\x83\x31\x3c\xee\x57\xd7\xa9\x23\xb0\x04\xbc\x56\xc8\x5c\x76\xf6\xc7\x51\xe5\x43\xf7\xe1\xd1\xc0\x84\xab\x95\xca\x29\xc0\x66\x22\x85\xab\x46\x6d\x53\xd6\xf9\xff\x10\x3a\xe0\x4f\x1d\x3a\x40\xde\xfe\x69\x79\x05\x81\xfc\x7d\xd9\x7a\x88\x5f\xcb\xc5\x2a\x5f\x49\x56\x30\x7a\xbf\x71\xff\x1d\x38\xb7\x38\x14\x0a\xfb\x4f\x4b\x96\x3e\x6f\x9b\x14\x4b\x9c\x3b\xcb\x61\x4d\x2b\x9e\x2f\x8b\x02\xb6\x3a\x96\x2c\x3a\x5f\x60\x3f\x4a\xce\x7b\xcb\x24\x2a\xd0\x77\x68\x74\xc2\xc1\x0a\xf0\xa9\xfc\x40\xff\x9d\xa2\x3e\x73\x65\x87\x91\x4a\x8b\x22\x9d\xc3\x27\xf6\xa7\xf1\x35\x8b\xce\x2f\x0a\xf8\xf8\xdf\x65\x5e\x44\xe1\x0d\xdf\x03\xa6\xc8\x0b\x63\x72\xdd\x25\x49\xe0\x29\xe8\x98\x84\x75\xc0\x79\x81\xb3\x42\x03\x2f\xd2\xc5\xab\x05\xf6\x89\xa2\x8b\xf7\xc5\x22\x4e\x01\x09\x0a\x6d\x38\x20\x53\x81\xc1\xcf\x32\x14\x25\x4f\x01\xd1\x5f\x65\x18\x9f\x24\x6c\x34\xd9\xcd\x88\x01\x79\x93\xfe\x5f\xb9\x75\x82\xa3\x06\x37\x3f\x5e\x04\x67\x54\x98\x66\x73\xb0\x63\xe0\x24\x8f\x71\x41\xfe\x57\xab\x3b\xe9\xff\xb5\xed\xb1\xf4\xdc\x76\xba\xf1\x2c\x4d\xb5\x5c\xe3\x7f\x70\xeb\x0c\x9b\x40\xf6\xab\x97\xf3\x4d\x57\x68\x01\x17\x29\x63\x2a\x3a\x98\xd1\x35\x09\xa4\xb5\x84\x9b\x1a\xf8\x20\xcb\x62\x46\xb9\x34\xef\x70\xba\xe5\xef\xd2\x0c\xb1\x8e\xcb\xea\x38\x8e\xce\x93\xe7\x05\x99\xe7\xea\x1b\x53\x36\x32\x08\xa6\xa8\x7e\x9d\x2e\x9e\xc1\xb7\xe9\x2a\x03\x18\x47\xcb\xae\x2e\x53\xf4\xa6\x48\x17\x22\x05\x3a\xef\xf7\x2c\x23\xf8\xfd\x22\x8d\x92\x22\xef\x2d\x17\x2d\x6f\x1e\x78\x6d\xa5\xcd\x95\x15\x19\x2d\xbc\x6e\x5b\x27\xe6\x29\x30\xc7\x86\xf4\x30\xce\xda\x36\x49\xaf\xd3\xc5\x4b\x36\xf0\xeb\x0f\x4f\x87\xcd\xd9\x5a\x24\x71\x76\xd5\x98\xd3\xc4\x09\xdc\xdf\xd1\x96\x4b\xf5\x38\x6e\x46\x37\x1b\xc6\xad\x93\xae\xed\x03\xab\xa8\x7f\x9d\x2e\x7e\x05\x54\x9b\x8c\x38\x25\x62\x2d\xaa\x1d\xdb\x81\x73\xc4\xe5\xd6\x53\x3d\xe0\x1b\x51\x2d\xc6\x7b\xcb\x84\x1b\xe3\x5d\xa2\x9d\xed\x69\xb7\xeb\x1d\xb5\x2f\xb2\xe8\x3c\x4a\xf8\xc6\x7a\x91\x66\xd1\x1f\x69\x52\xe0\xf8\x0e\xaf\xcc\x01\xa2\xf5\xc6\xa3\xf4\x79\x6f\xdb\xf5\x19\x0d\x5b\x6f\xc4\x2e\xd6\x00\x12\x06\xa7\x0e\x90\xbd\x60\x67\x79\x60\x2f\x49\x06\xa1\x94\xb6\xd0\x93\x22\x5d\x6c\xb7\x23\x6c\x1e\x9b\xf4\x84\x4e\xe7\x36\x92\x57\x60\x26\xaa\x28\x97\x3c\x2d\xde\x93\xcf\xce\xaf\x3f\x75\xa8\xd6\x52\x7f\x61\x05\xcb\xd8\x25\xe2\xaa\x74\xa6\x75\x1b\x20\x18\xfb\xaf\x20\x85\x2d\xce\x2f\x69\x71\x7c\x31\xcb\x83\xed\xd9\xa5\x8c\x25\xf0\x99\xce\xfe\x3c\x8a\xe3\x28\x27\x7e\x9a\x04\x10\x86\xec\x0a\x47\x05\x9a\x91\x30\xcd\x88\x15\x6f\x2d\x88\xf2\x79\x94\xe7\x54\x46\x17\x88\xa2\x1c\xcd\xc8\x05\xbe\x8c\xd2\x8c\x07\x68\x62\x0e\x2a\xb3\x1b\x71\x35\x66\x9e\x87\xec\x05\xc4\x32\x8e\xcf\xf4\xe8\x27\x22\x96\xda\xdf\xa3\x80\x88\x2b\x47\xe5\x68\xf3\xd8\x1b\x1b\xf6\x44\xd1\x8e\x70\x48\xe5\xe4\x65\x4e\x32\x66\xa3\x63\xab\x9b\x77\xe9\x79\x88\xce\x6c\x92\x0c\x97\xe4\xc4\x2b\x50\xbe\x20\x7e\x14\x46\x24\xe8\xa0\xa8\x40\x41\x4a\xe0\x25\xc1\x85\x1a\x98\x95\x58\x14\x0a\x34\x5b\x16\xe8\x2c\x23\xf9\x72\x4e\x4c\x70\x68\xab\xc3\x10\x5e\x11\x39\x9e\x45\x5a\xc6\x8d\xf6\xd1\xf0\x0c\xcd\x73\x3d\x14\x8c\x8d\x70\xad\x81\x7d\x1e\xc2\x23\x96\xab\x28\x67\x73\x57\xe0\xf7\x32\x7b\x0d\x82\x78\x7c\x10\xa5\x45\xbc\x8e\xb3\xa3\xb6\xc8\x17\x30\x4b\x3b\xb6\x0c\x1f\xa0\x7f\x2b\x87\xd5\xa8\xe8\xa0\x24\x55\x1b\x10\x17\xec\xcf\x1c\x41\xb2\x98\x5b\xb2\x1e\x64\x6c\xd3\xd0\x75\x52\xc9\xb1\xe1\xf6\x2c\xea\x6f\x67\x87\xe6\xd8\xda\x9f\x33\x8c\x9c\x1d\xeb\x68\xb3\x20\x71\x30\xaf\xfc\xfc\xa4\x93\x2b\x9d\x41\xfd\x34\xc9\x89\xbf\x84\xe7\x35\x62\xa6\x73\x14\x66\xe9\x1c\x61\xf1\x66\x9c\x4d\x2f\x8b\x83\x96\x83\x5b\x28\x43\xfa\xbd\xa8\xb0\xff\x43\x07\xe1\x80\x0d\xc4\x7b\x72\x63\x04\x2c\x22\x49\xbe\xcc\x08\x04\xc4\x5f\x50\x3c\x49\x81\x8a\x8c\xe0\x62\xce\x13\x52\x11\xec\x5f\xa0\x39\xc9\x73\x7c\x2e\x62\x2f\x91\xde\x79\x4f\x21\xa7\x18\x4f\x3f\x70\x88\x5b\x44\xdb\x92\xc1\x22\x3b\xfc\x11\x34\x7c\x43\x73\x7c\x83\x96\x8b\x00\x17\xa4\x1b\x25\xdd\x45\x4c\xef\xe5\x38\x61\xb1\xaa\x50\x48\x70\xb1\xcc\x48\x8e\xf2\xa5\x7f\x81\x70\x5e\xda\xe0\xa0\xfa\x8c\xd0\xe5\xe1\x13\x23\x62\x1e\xbc\x82\x95\x3a\x93\xf7\xe4\xa6\xc5\xdf\xe6\xd1\x7f\xe0\x1d\xa9\x9a\x6d\xfa\x53\x18\x41\xc1\xdf\x9c\x5b\x02\x17\xc2\xce\xd4\xbb\xc0\xf9\x8b\xab\x44\x88\xe2\xcc\x97\xc5\xc2\xa7\x39\xa4\x97\x5c\xd1\xe1\x29\xeb\x99\x87\x1e\x4b\x68\xf4\x18\x79\x67\xe8\x02\xe7\xb0\xd6\xd0\x7f\x3c\x9c\xdc\xfc\xc7\xeb\xc0\x06\x76\x85\xd9\x63\xaa\x45\x96\x5e\x46\x01\xe3\x4c\xa8\x6c\x10\x0c\x18\x7a\xe8\x77\x9c\xe7\xda\xcb\xce\x34\x83\xc7\x0f\xec\xdd\x22\x3b\x1d\x3c\xdd\x3f\xa8\xbc\xe5\x8b\x89\x70\xc9\x6a\xfc\xdb\x17\x24\xac\x59\x19\xbb\xf8\x81\x06\xbb\xb2\x54\xd8\xc1\x3b\x11\x7a\x98\xc9\x33\x88\x45\x3c\xfb\x99\xa9\x14\xd6\x1b\x0b\x97\x36\x74\xc3\x91\x71\xa0\xda\xce\x38\x95\x11\xd7\x8f\x9a\x8c\xa9\xd6\x70\xcc\xa2\xe4\xfc\x61\xd8\xdc\xc3\x46\x77\x00\x18\x37\x7d\xef\xe2\xc3\x46\x82\x87\x51\xab\x5b\xa2\xd7\x51\x61\x73\xdb\x75\x54\x3c\x8c\x59\xf5\x02\x75\x8f\xd8\xc3\xf2\xac\x5f\x9e\xd7\x51\x61\xad\x4e\x28\xf9\x2a\xc7\xac\x1c\x07\xf4\xb7\x74\x99\x13\x7e\x34\xde\x21\x9c\x28\xa0\xf9\x95\xe0\x9a\x70\xbc\xcd\xf2\x6f\x9a\x77\xa7\x8c\x79\xbd\xc3\x15\x96\xca\x89\x2a\x84\x8e\x10\x81\x6e\x16\xfc\x46\x7e\x66\x3a\xcf\x43\x6c\x6f\x91\x86\x34\x27\x05\x62\xd1\xfb\x22\xd6\x82\x1d\x99\x49\x5c\x2d\x2f\x22\xff\x42\xaf\x28\xae\x79\xa6\x5a\x08\x9d\xa5\x0b\xc2\x2f\xb1\x06\x31\x2c\x2c\x00\xce\xe1\x86\x8b\x33\x3c\x27\xf4\x7a\x0d\x31\x4d\xe1\x99\x9a\x08\xd5\xee\x42\x9f\x91\x7c\x41\x2f\x06\x20\x2e\x5a\x7d\xe1\xe4\x85\x69\x86\xc8\x35\x9e\xd3\x4b\x04\xcc\x00\xbd\x1f\x9c\xf9\x71\xe4\xbf\xc7\x57\xf8\xe6\x6c\x57\x19\x4a\x59\x97\x78\xd4\xf5\xe9\xd9\xb7\x45\x34\x27\xe9\xb2\xf8\xf6\x0c\xb5\x1c\x57\x7b\x72\xbd\xa0\xd3\xd9\x46\x69\x36\x45\x67\xdf\x4a\xf2\xbe\x3d\xd3\xf8\xc5\x7c\xe7\xd0\x98\x63\x54\xd4\x66\x35\x19\x51\x0e\x4f\x2b\xb4\x15\x0e\x0f\x2d\xb6\x1c\x33\xb9\x74\x25\x2f\x05\x7b\xb5\x20\xd6\x8f\xa4\xac\x56\xaf\x2b\x9c\xab\xda\xd6\xd6\xdd\xb9\x2c\x57\x81\x0d\x37\x2d\x13\xcb\x76\xf6\x2b\x03\xa7\x43\x33\x17\x88\x7b\x22\xe5\x7c\x73\x6f\xef\xd0\xa5\xac\x6b\xb9\xb4\x20\xc2\xf4\x56\xc9\x94\x4a\x37\xf2\xfa\x8c\x38\xd3\xb2\xd0\xb9\x71\xac\xa1\xca\x3b\xf4\xde\x15\x25\x41\x74\x19\x05\x4b\x58\xa3\xa0\xa8\xc3\x09\x8f\x21\xe5\x9a\x04\xa5\x4a\xda\xf4\x18\x51\xce\x0a\x77\x3e\x46\x24\xaa\x6d\x1f\x23\x02\x71\x5b\x1a\x8a\x34\xc7\xed\x8d\x43\xe8\x0a\xa3\xf8\xca\xf8\xb9\x1c\x70\x77\xc1\x73\x85\x93\xf7\x57\x11\x39\x97\x77\x76\xad\xb0\xb9\x62\x80\xb6\x15\x33\x77\x7f\x1f\xfd\x93\x1f\x7e\x10\xe6\x9b\xe9\xb9\xc0\xaa\x74\x49\x90\x70\x97\xc8\x7b\xd2\x96\xc9\x44\x35\x47\x38\x5d\xba\x9e\xb3\x27\xfc\xf4\x41\xec\xb5\x96\x19\xc5\x4e\x89\x36\xeb\xc4\x21\xd4\x45\xa2\xea\x40\x88\x0a\xc6\x19\x0e\x11\x19\x84\xfc\x8e\x97\x39\xa9\x48\x5c\xab\x04\xa7\x0d\x88\x84\x7a\x2b\x88\x04\x98\x06\x44\xbe\x04\x2d\x79\x05\x95\xd2\x67\x72\x3d\x22\xf5\x53\xbe\x9a\x4c\x1d\x4a\x04\xef\xf4\xa4\xd8\xe0\xd5\x87\x2a\x84\xb1\xad\x88\x14\xec\xc7\x04\x67\xaf\xd9\xbe\xdf\x72\x70\x4d\x55\x08\x62\x3a\x10\x35\xb9\xa3\x75\xea\x4b\x1a\x4d\xfe\x6e\xd0\x0e\xca\x61\x46\xba\xb4\xed\x11\x10\x3b\xc2\x19\x2a\x46\x8b\x00\x29\xa8\xa6\x1d\xca\x56\x20\x34\x42\x44\x98\x31\x18\xf5\x28\x0c\x15\xb8\xeb\x7b\xf8\xf1\x23\xea\xb7\xd1\x77\xa8\xdf\x9b\xd4\x4f\x8d\x3a\x46\xd8\x8d\xab\x61\x3c\x67\xb9\xe8\xa9\xa4\xf7\x69\xc3\x31\xca\x83\xc9\x88\xc5\x28\x85\xb1\x7f\x47\x71\xfc\x5b\xba\x4c\x8a\x8a\xb8\x8c\x65\x40\x3b\xeb\xb8\xce\xf7\x0b\x92\x98\x41\x81\x1a\x8c\x82\x1c\x69\x50\x06\x23\x27\x95\x3f\x45\x41\x23\x22\x05\x9c\x45\x63\x03\x12\x4d\x6e\x59\x83\x34\x3a\x2e\x2f\x89\x4f\xa2\x4b\xc2\x43\xde\xad\x1e\x47\x1d\xbe\x95\x90\x6b\x26\x58\x9b\x34\xcb\x62\x16\xc6\xe0\xd1\x23\xfd\x99\x35\x1b\xc8\x26\x43\xcd\xd2\x45\xad\x39\xd6\xff\x04\xeb\x47\x83\xc1\x66\x80\xad\x45\x46\x2e\x1d\x5d\x90\xc5\xac\x0b\x74\x43\xa8\x99\x89\x15\x13\xb5\x72\xaa\xdc\xa1\x8b\xf4\xed\xb2\x72\xb7\x44\x46\x14\xa3\x26\x33\xfe\xcf\x64\xde\x74\xd1\x70\xd0\xaa\x3d\xbc\x7a\x0b\x67\x92\xd3\xfe\x3e\x82\x8e\x32\x3b\x2b\xbf\x5d\xe7\x28\x20\x31\xd8\x99\x40\x13\x29\x64\x0c\x30\x46\xa1\x8b\x28\x20\xf9\x5e\xb9\x03\xf6\xd0\x55\x10\x5f\x1e\xe1\x86\x31\x59\x4b\xbb\x6a\x59\xd8\x44\x3f\xa0\x3e\x65\x65\x25\x2a\xf6\xdf\x9a\x07\x05\xfa\xd1\xfc\x38\xe5\x01\x9c\xaa\x76\x1c\xe3\xa4\xa5\xfb\x78\xdd\x36\x7f\x5a\x3e\xc8\x2a\x82\xf9\x36\xe5\x1b\xa7\xd8\x96\x93\x42\x54\x75\x1d\x0e\x7a\x9c\xe1\x61\x65\x3f\x8c\xcf\x4d\x7a\xe2\x3a\x14\xcd\x53\xd1\xdd\x58\x8b\x49\x99\x1e\xbf\x4c\x6a\xb2\x49\xa7\x3c\xa5\x2b\x06\x18\xce\x51\x9b\x7d\x99\x38\x03\x57\x5d\x60\x64\xa9\x13\x63\x3e\x1a\xb9\x72\xd3\x48\xce\x95\x3b\x89\x38\xb8\x04\x96\xd4\xae\x78\xc1\xd3\xff\xa1\xab\x28\x09\xd2\xab\xde\x9e\x6c\xf0\x25\x01\x87\xee\xba\x26\x93\x14\xc5\x69\x72\xae\xfb\x88\x34\x6d\x9c\x35\x07\x4e\x1e\x17\xe9\x55\x02\xd1\xb0\x7b\x8e\xe5\xb6\x41\xb8\xe3\x15\x41\x8d\x7d\xf1\x0e\x80\x8f\x3e\xfc\x76\x84\xe7\xd5\x1d\xbb\x34\x70\xad\xd4\x08\x38\xcb\xfd\xa0\x54\x8c\x5e\x1d\xb2\x27\x3e\xeb\x55\x94\x23\x58\x45\x25\x05\x60\x47\x65\xb6\x36\x88\x77\x6e\x46\x32\xa3\xbe\x94\x44\x4b\x2d\xd6\xae\xfd\x6d\xc3\xe8\xce\x2b\x22\x36\x4b\x6f\x89\x15\xd1\x9f\xcb\xba\x14\x55\xa1\xfc\xcd\x88\xbf\xcc\x6d\xde\x2a\xfc\x32\x2b\x30\xc3\x7c\x89\x9b\x9f\x0c\x5c\x0c\x05\x0e\x18\x9e\x7f\xd6\x00\xe3\xa9\xda\x2d\x48\x3d\x0c\xb5\x2c\xb2\xe0\xae\xa3\xc2\x00\xba\x8e\x8a\x32\x84\xdd\x24\x2b\x2a\xc3\x59\x0d\x42\x89\x09\x65\x5c\x72\xdf\x95\xaf\xa7\x0e\x68\x71\xdb\x7c\x57\xbe\x27\x9a\xd0\x56\x32\x96\x77\xae\x1d\xd1\xa8\xb1\xd0\xf9\xc7\x0e\x6f\xe3\xd2\x8f\x2a\x68\xd7\x57\xbd\xb6\xba\x4c\x98\x81\xc5\x35\x8d\xa0\x4e\xc9\xc6\x81\x9f\x99\x12\xae\x83\x3c\x7d\x8d\xc2\x6f\x6b\xd9\xb1\x08\xcc\xf6\x92\x72\xc6\x8b\x66\x21\xa2\x8d\xd0\xd1\x65\x06\x87\xb8\xd0\x8c\x8f\x59\xcc\xe7\x9f\xd9\x53\x0e\xf9\x67\x94\x9c\x6b\xbf\x58\xa8\x69\xc6\x13\xea\x2f\x05\x03\xac\xc2\xfe\x56\xcc\xa0\xfd\x86\xe9\x66\xbf\xf5\xe9\x84\x92\x05\xa3\xdd\x35\x25\x26\xed\xa5\x00\xd3\xdf\x34\x92\xbf\x1d\xd1\x26\x8d\x60\x77\x85\x31\xd7\xb9\xa6\x3e\x42\x28\x4a\xa6\xc8\xe4\x2c\xbc\x58\x10\x9c\xd9\x99\x10\xf8\x09\x3d\x75\x6c\x33\x0a\x48\x3a\x85\x94\x36\x07\xdd\xf5\xc1\xb5\x25\x68\x36\x7e\xc7\x46\x20\x4c\xd9\xf6\xf2\xd7\x0c\xb6\x8e\x45\xaf\x2c\x93\xc0\xb6\xfc\x35\x2a\x8f\x45\xf2\xec\x02\x53\x91\xef\x17\x7e\x28\xf2\x28\xa7\xee\x8b\x76\x47\xa2\x12\x31\x86\x6e\x4f\x9c\xc3\xab\x1e\x9a\xca\xed\x9f\x4a\x53\xf5\x01\xbc\xec\x37\xa7\x2a\x84\x57\x55\x74\x26\xe5\x88\x24\x36\x6a\xe9\x46\xce\xcf\xe9\xdb\x8e\x73\x7b\x68\xb7\x4f\xdc\x7c\x51\x8a\x54\x4b\x99\xcf\xdc\x22\x8c\x0b\x9f\x5e\xb1\x71\x08\x31\x13\x9f\xfb\xe8\x2a\xed\x53\xa5\xc1\x95\xdf\x94\xac\x68\x5f\xbd\x36\x23\x8f\xbf\x2e\x5e\x27\xc4\x19\x0a\xa2\x8c\xf0\x91\x57\xa2\xcc\xe9\x29\x02\xaf\x6c\xf4\x23\xcf\xa2\x82\xa6\x90\x54\x05\x5e\xa1\x98\x3d\x6d\xaf\xdb\xd5\xcd\x82\x49\xba\x9e\xb7\x97\xfb\xf9\x01\xb1\xd4\x40\x53\xe4\x31\x39\xd3\xeb\xa8\xd0\x7e\x25\x85\x5e\xc7\x15\x60\x90\x89\xdb\x9b\x84\xa4\x74\xbc\x39\x77\xcd\xc4\x07\x11\xb1\x90\x42\x96\xe3\x12\x82\x4a\x75\xe3\x10\xe7\x76\x54\xcc\xdd\xc4\x37\xcf\xd2\x54\x85\xcb\x7c\xc3\xcf\x45\x88\x8a\x67\xec\x52\x78\x11\x15\x38\x8e\xfe\x20\xbf\x44\x59\x5e\xfc\x4a\x8a\x82\x64\xed\x96\xe0\xb2\x76\x43\x78\x25\x0c\xb7\xdf\x6a\x01\x35\x4b\xf1\xd0\x4d\xc7\x05\xa7\xd2\xbf\xa2\x0a\x77\x52\x70\xaa\xe0\x8d\x1a\x22\x4c\xa2\xd5\xb6\xe2\x7a\xad\x58\x0b\x08\xbe\x67\x2c\x01\x47\x54\x37\xbe\xcf\xad\x0e\xe9\x26\xec\x35\xfc\xab\x7e\x16\x9a\xcf\x51\x3e\x68\xef\x33\xc4\x73\x88\x8e\xf1\x02\x45\x3c\xa7\x60\xbc\xe6\xb2\x62\x32\x16\xe1\xcf\x2e\xf5\x88\x0d\x3d\x61\x84\xed\x09\x07\xc1\x57\x7e\x46\xc4\x01\x4c\xe0\x9c\x73\xc3\xc7\x04\x5f\x4a\x70\x16\x65\xc8\x15\x83\x8e\xe5\x32\x50\xb1\x25\x14\x07\xb2\xa7\xd2\x1d\xf4\x01\x85\x71\xb4\x98\x8a\x04\x13\x2c\xe0\xa5\xf7\xdb\x32\x12\x43\xe4\xa1\x5b\xcd\x56\x55\x0e\x81\x75\x7c\xbf\x02\x0d\xf1\xd8\x0d\x05\x59\x2c\x2a\xc3\x5b\x1c\x1e\x7f\xee\x00\x58\x8c\xbc\xea\xf8\x57\x05\x59\x54\x46\xa8\x38\x68\x14\xf4\xaa\x20\x8b\x5d\x51\x5e\x4b\xf6\x53\x08\x8c\x5b\x15\xd5\x61\x34\x6c\x4a\xfc\x53\x1e\x60\x77\x37\x5d\x60\xd8\x6b\x3b\x52\x1f\x28\xe4\x80\x45\x2c\x69\xd2\x93\x5d\xc6\x1d\x53\xe8\x6b\xfb\xf2\x2b\x9e\x91\xb8\x92\xa1\x0e\x9b\xf6\x04\xd0\xec\xaa\x1f\x80\xfc\x1e\x44\x4e\x1b\xf6\xb7\xb8\xa1\xd5\x84\xfd\x54\xb8\x79\x62\x1a\xa8\xfe\x67\x0f\xb4\xf6\xe9\x43\x53\xdd\xab\xd0\x6e\xcc\x7f\xe6\xcf\x1d\x32\x6b\xc7\x51\xab\xee\x53\x60\xa4\x17\x59\x24\xb2\x2f\x55\x8b\x0a\x4d\xc3\xda\xe8\xc8\x76\x16\xcf\xa6\x26\x48\x4a\x18\x93\xeb\x29\xf2\x06\x68\x00\x0a\x6e\x23\x18\x49\x1c\x25\x44\x41\xaa\x80\x28\xb3\x38\xf5\xdf\xcb\x7b\xce\x2c\xcd\x02\x92\x3d\x4b\xe3\x34\x13\xb1\x56\x16\x38\xa6\xb7\x87\x1e\x45\xd0\xcb\x99\xd8\xa2\x23\xa6\x24\xfc\x4b\x0a\xc8\xa2\x81\x39\xce\xce\xa3\x84\xc5\x6b\x18\x0c\x3b\x68\x7f\x1f\x5d\xe0\x38\x44\x91\x2f\x25\xfb\x05\x0e\x02\x50\xd6\x78\x7d\xd4\x87\xec\x22\x8e\xe8\x3c\x8f\x91\xb7\xb8\x2e\x75\xe4\xef\x9a\xf0\xfd\xc1\x20\xfd\x75\xba\x78\xc5\x82\x59\x7b\x79\x1a\x47\x81\xd5\xb3\xd7\xe9\x82\x07\xae\x1e\xd8\x38\xcb\x7d\x60\x55\x68\x1f\xea\x50\xd2\xef\x02\xa7\xf8\x32\x8f\x92\xbf\x13\x16\x3d\x62\x38\xd6\x1b\xc2\x31\x84\xea\x2d\xa2\x4b\x02\xa7\xdd\x4b\x63\xfe\xb4\xf8\x35\x78\x96\xa7\xf1\xb2\x50\x01\xff\x21\xf6\x8f\x73\x80\xc6\x66\x38\x1b\xcf\xc7\xb1\xdf\x9a\xf4\xff\x8a\x1e\xa3\x61\x7f\x71\xdd\xf6\xac\xf8\x36\x0c\xa0\xab\x43\xd4\x91\xf8\xab\xc1\x38\xfa\xbc\xf6\xd5\x1d\x6c\xed\x50\x17\xce\xe0\x08\xba\xe3\x3b\x7a\x45\x0a\x19\xd9\x38\xbe\x41\xb3\x1b\x04\x32\x31\x18\xbf\xa2\xc2\xcb\x51\xbe\xe4\x4e\xc4\xd2\x56\x66\x93\x6e\xbd\x05\x86\x47\xe0\x16\x48\xad\x27\xf3\x26\xaf\x64\x0d\x0f\xfb\xfb\xf0\x50\xb6\xf4\x9a\x40\x6d\x52\xeb\x7a\xd7\x1a\x9b\xe5\x86\x6e\xb5\x3a\x8e\xed\xf8\xd3\x6a\x18\x99\x23\x6d\xf3\x08\xd9\xca\x17\x96\x89\xd1\x09\xf1\x8b\x34\xd3\x23\x58\xab\x83\x94\x0e\x7c\xde\xd1\x7f\x0c\x41\x7d\x0a\xfe\x06\x36\xe3\x9d\x22\x6e\x4d\xb4\x3e\x88\xa5\x68\xe7\x71\xad\x30\xe4\x29\x83\xa0\xd3\x1e\x98\x1a\x87\x17\xb7\x0b\xa9\x32\x09\xb6\x9e\xb9\x46\x59\x6b\x2c\xe2\xeb\x32\x74\x6a\xcd\x4a\xb3\x05\xc4\x0a\xd3\xcc\x95\xd5\xca\xb0\x96\x36\xaa\x74\x53\xb8\x5d\x95\x2c\xc6\x98\x12\x53\x95\xf6\x8d\x4d\x76\x7b\x63\x64\xe2\x48\xe8\x98\x23\x4d\x39\x5f\xa8\x84\xbc\xcd\xb0\xbb\xce\x81\x4e\x89\x8d\xda\x06\xbb\x95\x52\xe0\xc8\x98\x6d\x51\xc2\x9c\xed\x56\x8e\xb3\x68\x9e\xd6\xe8\x20\x9d\xb4\xe1\xba\xc3\x3e\x54\x9d\x31\x4f\x64\xc7\x60\x29\x5d\xd9\x5a\xc3\x65\x35\xb1\xed\xd9\x18\x56\x4f\xc7\xaf\x30\x3e\xf5\xd3\x31\xe4\xe6\x93\xe6\xba\x77\x4d\xa3\x5c\x69\x42\xb0\xb3\xb4\xc0\x94\x5a\xba\xd2\x15\xc1\xfc\xf3\x05\x06\xad\x89\x8e\xcb\x64\x11\x08\x4f\xd5\x3e\xd9\xbb\xdd\xdb\x33\x36\x3e\x70\xf4\x80\xdd\x95\x6d\x27\xcd\x92\xa5\x72\x07\xf8\x0f\xeb\x9e\xae\xc6\x3b\xa1\xa6\x27\xa4\x55\xe9\xfe\x1c\x66\x1a\x61\x77\xae\x3f\xbd\x1f\x87\xa9\x46\xd2\xde\xea\xad\x01\x5e\x2d\xb8\xce\x8c\x1a\x16\x58\xbd\x5c\x19\x56\x75\xd0\xd4\x32\xc7\x5a\xe8\xf8\x21\x56\x2b\x49\x35\x45\xa8\x9f\x7e\x9d\x2f\x4e\xa8\x6a\x83\x93\x77\xd8\xa6\xd7\xed\xdb\x13\x6b\xcb\x70\x99\x4f\x4a\xbb\x00\x33\x2d\xd8\xeb\x55\x3f\x17\x40\x70\x5b\xdf\x7a\xd1\x6e\x19\xd4\xb4\x77\x92\x66\x67\x38\xf8\xc2\xf5\x81\x9f\x23\x9a\xfc\x9f\x5f\x4b\x06\x8f\xde\x9e\x45\x99\x1f\x57\x45\x88\x3e\x18\x0e\x5d\xd0\xb5\xe1\xd3\x15\xd8\x27\x0d\x22\x4f\x97\xd1\xef\x5c\xfd\x50\x93\x15\xe9\x60\x38\xaa\xac\x52\x1b\x1e\xdd\x82\xbd\x6f\x6a\xc0\x9a\x2e\x0f\x46\xc3\xc6\x0a\x40\x40\xf3\x39\x34\x7f\xb6\x3e\x4f\x57\xe8\xd0\x3b\x6f\x4c\xc0\xf3\x49\x2a\x0a\xa3\x38\xb6\xf5\x7b\x8b\x2c\x9a\xe3\xec\xe6\xcd\xa4\xdf\x7f\xbb\x6d\xc5\xce\xbf\x2f\x08\xdc\x41\xe1\x89\x65\x5e\x90\x05\x8a\x72\xfe\x2a\xd1\x8c\x7d\x59\x13\xe0\xa0\xac\x90\x01\x81\x96\x5e\x8f\xc3\x34\xd3\xa2\x1a\x30\x95\x8c\xbf\xcc\x8b\x74\x1e\xfd\x81\x99\xd9\xfc\x4e\x8a\x98\xdf\x70\xf6\x9e\x6b\x7b\xc8\x02\xe1\x5c\x0d\x69\x0f\x3d\xcf\xd1\x82\x62\x64\x11\x07\x2e\xa2\x38\x70\x07\x4a\x53\x93\xd0\xb8\x7f\xaf\x2f\x08\xe8\x4b\xc5\xec\xb2\x68\x87\x92\x8e\x98\x4e\x88\x6a\x81\x42\xae\x2b\x03\x33\xb6\xdf\x50\xe8\x80\xca\xdb\x91\x36\x60\x4b\xb8\x8b\xee\x86\x22\xb0\xd5\x36\x72\xc8\x95\xfa\x44\x94\x08\xcd\x48\xe4\x6b\x9a\x13\xfa\x43\x86\xf6\x66\x2f\x66\xa5\x1a\x07\x7e\xae\xd0\xca\x30\xa5\x07\xbc\x1d\x62\x93\x10\xc9\xd1\x65\x81\x0f\x3d\x78\xb3\x60\x7f\x63\x92\xa6\xa7\x87\x58\x93\x74\x2a\x2f\xbb\x46\xb7\x4c\xe3\x90\xa9\xc8\xfd\xb9\xa6\x47\x52\x4f\xa3\xe5\x56\xf3\xba\x69\x4a\x51\xe9\x90\x58\x91\x92\x94\x35\xae\x14\xe1\x30\x29\x72\x6b\xe0\xd3\x72\xab\xde\x1b\x72\x2a\x28\x98\xbc\xcf\xd2\x76\xee\x7c\x95\xdd\xe8\x3a\xda\x60\x0b\x6b\x7c\x93\xda\xf6\x9d\x47\xcc\xe3\x76\x6e\x64\x74\xc0\xd7\xbe\xea\xdc\xab\xed\xc6\xba\xd5\x6c\x7a\xf7\xe0\xd2\xcc\x2e\xae\x1d\xc3\xfb\xe8\x57\xf5\x90\xdd\xf3\x4f\x9e\xdd\x73\x30\x44\xc3\x67\x07\xbd\xf1\x11\x1a\xa2\x21\xe2\x7f\x0c\x86\xf9\x98\xfe\x35\xe8\xcb\xff\xeb\xf2\x82\xee\xa0\xff\x6a\x70\xd8\x9b\x0c\x01\x0c\x0d\xff\x98\x77\x87\x68\x30\x89\xbb\x93\xee\x04\x0d\x7a\xe3\x41\x97\xfe\xcf\xaf\xb4\xce\xb8\x37\x38\x8c\x0f\x7b\x93\xe3\x2e\xfd\x9f\x5f\x07\xc7\xe8\x28\xee\x1e\xa3\x63\x3d\x89\xa8\x79\x6b\x92\xc3\xa9\x15\x7f\x92\x04\xa2\x26\x19\xae\xec\xa1\xe6\x4d\x4c\xfb\xd5\x38\x73\xa8\x56\xa7\xe4\x34\x39\x1c\x3d\xe8\x14\xb6\xaf\x53\x18\xfe\xe9\x95\x0a\x9f\xe4\xae\xff\x27\xdd\x1a\xbf\xa2\xfb\xbc\xeb\x82\xce\xa3\xc7\x8b\xc8\xf7\x86\xcf\x06\x97\x3b\xd7\xbb\xdf\xf3\xd4\x4c\xe4\x7a\x45\xc3\xe7\xa4\x78\x96\x26\x45\x86\xf3\xe2\x35\xb9\x2e\x5a\xd5\x78\xa5\x33\x7f\x98\x26\xc5\xab\xe8\x0f\x22\x50\x15\x37\x8b\xf4\x3c\xc3\x8b\x8b\x9b\x9e\x8f\x21\x58\x5f\x4f\x80\xe8\x55\x7e\xc1\xf3\x28\xbe\x71\x54\x52\x1f\x1f\x54\x13\x3b\xf0\x11\x79\x2d\x74\x0a\xe2\xe2\x05\xe1\xc4\x79\xc2\x03\x45\xa0\xba\x96\xfd\x89\xe5\x7e\xc9\x35\xcd\x84\x27\x1f\xce\x6f\x66\x4f\x05\xe7\xba\xa1\xd7\x41\xfe\x8d\xf8\x2b\xa3\x7f\xf4\xb9\x7c\xb3\x99\xee\x42\xbf\x1e\xdb\x3a\x0c\x39\x1f\x42\xd7\x20\x0a\x1a\x7a\x88\x34\xf4\x33\x71\xaa\x3b\x4e\xd6\xf3\xe1\x30\x6f\xf0\x2b\x72\x34\xdd\x6a\xb6\x77\xa6\x5b\xe1\x34\x38\x9c\x1c\xb6\x21\x06\x56\x1a\xd6\xa5\x64\xd8\xc4\xb4\xce\x47\xcb\xa3\x5b\xa6\xf4\xaa\x73\xaa\x31\x28\x44\x07\x49\x7e\x01\x76\x39\xa0\xf7\x65\x72\x5d\x3c\x81\xd7\x45\x53\xe4\xcd\xa3\x20\x88\x89\xa7\x5e\xa8\x89\xc9\x85\x9f\xa6\x8d\x5e\x67\x92\xcd\x75\x1b\xc3\x7b\xa1\xdc\x18\x6e\x59\xbb\x31\xdc\xba\x49\x97\x62\x14\x93\xf1\x45\x68\x39\x86\x77\x55\x73\x58\xc6\x9b\x5d\xa8\x3b\xc6\x5f\xf8\x8d\xe8\xe1\xd5\xc5\x9f\xf7\xd5\xc5\x15\xce\x12\x1e\x55\xc4\x85\x76\x6c\x03\xd6\xde\xc8\x18\xc8\xa7\xb5\x55\xa7\x71\x8c\x17\x79\x95\x92\x6d\xd4\x3f\x2a\x81\xd6\x5a\xa9\x39\xcc\xd7\xf8\x62\xe4\x5e\xa6\xd2\x6e\x9c\xa4\x99\xce\xf4\x8e\xb3\x34\x7f\x8d\x2f\x6f\xd8\xb3\x88\xd7\xee\x37\x1a\x9d\xb5\xdf\xc4\x30\x18\xe7\x6b\x0f\x5e\x91\xe1\x42\x8f\xab\x30\xf0\xd4\xb4\xd5\xc4\xa8\xc7\x2b\x54\x36\x5d\x5c\x23\x78\xdb\xa2\x3d\xc3\x59\xf5\xee\x27\xc6\x79\xe1\x7a\x2b\x33\x45\x5e\x92\x26\xc4\x70\x41\xd0\xa3\xab\x7f\xd8\xd5\x83\x91\x9f\xaf\x17\x18\xf2\xf1\x5d\xb0\x04\x72\xc6\xfb\x8b\xb5\x6f\xf0\xf7\xfb\x2d\x0a\x34\x5f\xea\xe4\xa6\x39\xea\xee\x9c\x92\x6a\x23\xe7\x57\xbb\x62\x63\xaf\xd7\x6d\x27\xc1\xaa\x4c\x58\xe0\x54\xae\xdc\x8b\x47\x3c\x9b\xb8\x93\xd8\x38\xd8\x02\xfe\x64\x0b\x42\xe4\xe8\x70\x2c\x04\xf1\xe9\x0e\x9d\xb9\x3f\x8e\xe0\x3b\x70\xc0\xb5\x74\x8b\x42\x96\x5b\x91\xc6\xa2\x71\xda\x8f\x27\xc1\x7f\x97\x39\x8b\x51\x29\x53\x42\xc8\x3c\x9b\x2c\x04\x02\x81\xbd\x55\x43\xcf\xf3\x41\xfc\xce\x5c\x9f\x40\x5b\xb8\xd0\x72\x24\x5a\x99\x82\x6a\x29\xbd\x97\xb9\x1e\x36\xda\xd1\xea\xd1\x34\xde\xdf\x3e\x65\xe6\x09\xc3\xc7\xff\x64\x6f\xaf\xf4\x24\x8e\x4e\xbf\xad\x95\xac\xf5\x8e\x5a\xff\x2d\x9c\x8a\x8d\xe9\x0e\x8d\xb9\x9d\xc7\x72\x0d\xdc\xc1\xe8\x8e\x28\xbf\xd2\x1f\xe2\xc3\x6b\x3d\x84\x58\x55\x64\x44\x67\xc4\xcd\x55\x01\x37\x9b\x3e\xe1\x13\x9b\xa7\x84\xe1\x05\x77\x7e\xe3\x07\x73\xe7\xb9\x5f\x6e\x94\x63\x2d\x3a\x5e\xfe\xe9\x8e\x45\x1e\x1d\x34\x2b\x88\x61\x65\x38\x46\xf3\xd1\x84\x27\x7a\x24\x9f\x0f\x36\xd6\x6c\x82\x02\x8b\xdf\xbb\x55\x17\xab\x1f\x89\x75\x90\xf7\x1b\x2e\x48\x16\xe1\xb8\xfb\xcf\xe7\x53\xf4\xbd\x1e\xec\x65\xff\x07\x48\x79\x94\xc4\x37\x28\x20\x79\x74\x9e\x90\x00\x8c\x38\xcb\x9c\xa8\xb3\x4c\x46\x77\xe3\x72\x71\xcf\x6b\xa3\xa9\x8c\x99\xf7\x49\xd4\xe6\xc0\x9e\xc0\xb1\x77\x55\x99\x7f\x9a\x67\x69\xa5\x95\x24\xf5\xe7\xfc\x5f\x84\xbc\x28\xf1\x84\x8f\x9f\x8a\x0a\xe6\xd2\xae\x3b\xa2\x92\x3a\xcf\x93\x9a\xe0\x94\x4b\x16\x0b\xfd\x85\x48\x8b\x98\x2d\x45\x7c\xb2\x5b\x7b\x63\x72\xa8\xe3\x39\xb7\x7c\x1e\x2f\xc3\x86\x87\x7c\x65\xad\x87\x03\xf7\x7e\x1c\xb8\x0d\x8d\x2a\x9d\xf5\xaf\x8a\x0f\x57\xc1\xbb\x5f\x05\x3f\x9b\xa3\xee\xb6\x1f\x27\x6e\xd9\xf3\x97\x1f\xf1\x5b\xc0\x24\x4f\xfc\xed\x60\xfb\xd2\xdf\x60\x36\x1a\x05\x43\xf0\xaa\x39\x1c\xd6\xc7\xa7\x89\x6e\x0f\xc7\xc6\xe7\x3c\x36\xdc\xcf\x71\x41\x1c\x71\x3c\xc6\x35\x84\x05\x69\xdb\xd1\xbd\x23\x5c\x82\x81\xc7\xe2\x47\xdd\xf1\x51\x6e\xc1\x62\xad\xee\xc2\x58\x3c\xb9\x8f\xbe\xf1\x7e\x3a\x9f\x57\xfb\x1d\x1e\x0d\x9a\x44\x59\x64\x38\x76\x11\x62\x91\x61\xae\x8c\x12\xc9\xd3\x2f\xb8\xec\x8f\x87\x8d\x62\x76\xb2\xa0\xf9\x5b\x27\x9b\x72\x7c\x15\xcd\x8b\x28\x79\x5f\x49\x74\xa3\xe1\xa6\x18\x76\x41\x35\xc5\x5b\x4d\xf6\x32\x5b\xd4\x3c\x1a\x6e\x14\xde\x95\xe1\xd8\x09\xe9\x80\xb9\x92\xf8\x80\x90\xc5\xef\xf5\x1d\x68\x14\x4e\x54\xe1\xd9\x45\x27\x14\xf6\xca\x8e\x44\x49\x10\x9d\xa7\x95\xec\xd3\x6f\xd2\x09\x86\x63\x17\x1d\x60\x98\x2b\x89\x9f\xc5\xcb\xea\xf1\x3f\x6a\x42\x3a\xc5\xb0\x0b\xc2\x29\xde\x4a\xb2\xe3\xe8\xfc\xa2\x78\x5a\x47\x7b\xa3\xc0\xcc\x12\xcd\x2e\x3a\x20\x91\x57\xf6\xc2\xbf\xc1\x95\x0f\xe4\x47\x8d\xf8\x86\x62\xd8\xc9\x1e\x7f\x83\xab\x77\xf8\x82\xe0\xaa\x10\xc0\x07\xa3\x46\xbb\x25\xc5\xb0\x0b\xb2\x29\xde\x4a\xb2\xcf\x33\x42\xaa\x87\xbb\xd1\xd1\x04\x28\x76\x41\x38\x20\xae\xe7\xf6\xbf\xd5\x92\x3f\x6a\xcc\xee\x7f\xdb\x55\x1f\x14\xf6\x9a\x8e\xcc\x2b\x57\xec\xa8\x51\x18\x6c\x8a\x61\x37\xc4\xcf\xab\xd7\xe9\x0d\x89\xe3\xf4\xaa\x92\xf0\x49\x13\xc2\x19\x8e\x5d\x90\xce\x30\x57\x12\x8f\xe7\xb3\xca\xf0\xf5\x07\xa3\x46\x32\x02\xa0\xd8\x05\xe9\x80\xb8\x92\xf2\x34\xc3\xc9\x79\x35\xbf\x34\x92\x0e\x18\x8e\x5d\xd0\xce\x30\xd7\x8a\x37\x2f\xea\x3b\xd0\xe8\x78\x55\x78\x76\x25\xde\xbc\xa8\xef\xc8\x2c\x4b\xaf\xaa\xf7\x9d\x46\xc7\x2c\xa0\xd8\x89\x8c\x40\x11\xd7\x6d\xf8\x37\x95\x97\xa8\x46\xc7\x2b\xc5\xb0\xa3\xed\xfe\xa6\x56\x24\xfb\x5b\x35\xe9\x07\xe3\x46\xa4\x0b\x2c\xbb\x12\xcd\xfe\x56\xd1\x85\x4f\x1d\x63\xff\xe0\x7e\x5d\xe0\xf7\xf7\xd1\xbf\x71\x54\xa0\x8b\xa2\x58\xe4\xd3\xfd\xfd\xf3\xa8\xb8\x58\xce\x7a\x7e\x3a\xdf\x0f\xb1\x4f\x66\x69\xfa\x7e\x3f\x8c\xd3\xab\xfd\x28\xcf\x97\x24\xdf\x1f\x1d\xf5\x51\x91\xa2\x19\x41\x61\x74\x4d\x02\xda\x27\x92\xc7\x51\x52\x74\xf9\xfb\x3c\x44\xa1\x8b\x9b\x05\xd9\xe7\x94\x77\x2f\x71\x1c\x05\xdd\x30\x8a\x49\x17\x27\x49\xca\x55\x85\xdf\xed\x33\xf6\x91\x77\x42\x4a\xdd\xa4\x3f\x45\xde\xff\x13\x8e\xc8\x24\x9c\x80\x69\x6e\xd0\x87\x12\x32\x98\x11\x72\x08\x25\x43\x56\xe2\x93\xe3\x51\x70\x04\x25\x23\x56\x32\xc3\x07\x47\x3e\x2b\x19\xb3\x12\x3c\x1b\x1f\xce\x7c\x28\x99\xb0\x92\x63\x7f\x78\x38\xeb\x43\xc9\x01\x2b\x39\x22\xc3\x31\xc6\x50\x72\xc8\x4a\x0e\x67\x83\x10\x0f\xa1\xe4\x88\x95\x1c\xe0\xc1\xec\x98\xc1\x1c\xb3\x92\x31\x1e\x8c\x8f\x18\xe6\x27\x82\x44\x7c\xd4\x0f\x79\x11\xa7\x91\xf4\xc7\xfd\x70\xc6\x8a\x38\x49\xc1\xa4\xdf\x0f\x8f\x59\x11\x6f\x0f\xe3\x7e\x3f\x0c\xa1\xc8\xe7\xaf\x0d\x39\xef\xf1\x70\xe4\x4c\x0c\xaa\x52\x4a\xb1\xf1\x2b\xbf\xb3\x3e\x7c\xe0\x33\x83\xcf\x8c\xeb\xbb\xe2\x35\x12\x90\xc3\xf0\x40\xe7\xb5\x60\xe0\x8f\xc9\xb1\xce\x6b\xb3\xd1\x71\x10\xcc\x74\x5e\x3b\x9e\x1c\x4e\xfc\x40\xe7\xb5\x43\x32\x39\xf4\x87\x3a\xaf\x1d\x1c\x8e\xf0\xec\x50\xe7\xb5\x09\x19\x4d\x66\x03\x9d\xd7\x26\x83\x61\x80\x8f\x74\x5e\x1b\x4f\x86\x87\xb8\xaf\xf3\xda\x68\x30\x98\x1d\x0f\x0d\x5e\x9b\x8d\x8e\x8e\x38\xcb\x08\x5e\x3b\xf4\xc7\x81\x28\xe2\x24\x1d\x4c\x06\xa1\x28\xe2\xed\x1d\x0c\xfb\x7d\x82\x37\xe6\x35\x35\x86\x65\x7e\x3b\x7a\xe0\x37\x83\xdf\xb8\xa2\x42\xe3\xb4\x51\x38\x0c\x03\x9d\xd3\x66\xb3\x80\xf0\xfd\x81\xcf\xe2\x71\xdf\xc7\x7c\x7b\xe0\x9c\x76\x30\x9e\x4d\x38\x7f\xf2\x69\x1d\x0f\xb1\xd8\x1d\x39\xa7\x0d\x07\xc7\x07\xe1\x48\xe7\xb4\x01\x39\x3a\x22\x13\x9d\xd3\x06\xc7\x87\x07\x81\xb1\xab\x0d\x26\x07\x13\xdf\xe0\xb4\x7e\x30\x3e\xc4\x03\x83\xd3\x8e\x86\xb3\x81\xc5\x69\xe3\xf1\x11\xb6\x38\x6d\x78\x7c\x78\x6c\x71\xda\xf0\xf8\x60\x78\x87\x5d\x8d\x8e\x5e\x99\xc7\xee\x59\xc2\xad\xcf\xce\x63\xba\x56\x49\x63\xb4\x41\x38\x09\x89\xc1\x68\xf4\x40\xf5\x75\x46\x3b\x1a\x04\xe3\x10\xeb\x8c\x36\x0e\xfd\x51\x78\xa8\x33\xda\xf0\x78\x76\xc0\x59\x8f\x33\x5a\x7f\x84\x8f\xc3\xb1\xce\x68\xfd\xd1\xf1\xcc\x64\xb4\xfe\xf0\xe8\x28\x18\xe8\x8c\xd6\x1f\x1e\x1e\xce\x02\x83\xd1\x06\x93\xc3\xe3\x99\xc9\x68\xfd\xc0\xde\xd2\xc6\x7d\x7f\x6c\x31\x5a\xbf\x3f\xeb\x5b\x8c\xd6\xef\x1f\x0f\xea\xb7\xb4\x00\x67\xef\xab\xf8\x4c\x8e\x60\x89\xd9\x46\xdb\x4c\x86\xf4\x25\x30\x1b\x57\xfe\x69\x7c\xd6\x0f\x0f\x39\x0f\x09\x3e\x1b\x92\x59\x38\x34\xf8\xac\x1f\x10\x62\xf2\x59\x10\xf4\xc9\xc0\xe0\xb3\x03\xff\x20\xc0\x06\x9f\xf5\x67\x7e\x60\xf2\x59\x1f\xfb\xbe\x71\x74\xf6\xfb\xc7\x87\xf8\xd0\xe0\xb3\xfe\xd1\xe8\x28\x34\xf8\xac\x7f\xd0\x3f\x18\x9b\x7c\x36\x0e\x43\x8b\xcf\x06\x47\xaa\x48\xf2\x19\x99\x94\xf8\x6c\x76\xc4\x69\xda\x80\xcf\xe8\xe0\x95\x59\x6c\x9b\xf1\x75\xbf\x04\x16\xe3\x8a\x5a\x83\xc5\x86\xe1\xc0\x64\xb1\x20\x0c\x66\x26\x8b\xf9\x33\x7f\x6c\xb2\xd8\xec\x00\xfb\x26\x8b\xe1\x83\x63\x8b\xc5\x8e\x0f\x8e\x8e\x4c\x16\x3b\x3a\x3e\x9c\x99\x2c\x76\x78\x7c\x30\x33\x59\xec\xe0\x78\xe2\x9b\x2c\x36\x0e\xc6\x7d\x83\xc5\xf0\x61\x18\x92\x99\xc1\x62\x07\xe3\x30\xe4\x2c\x2e\x58\x6c\x10\x90\xe3\xd9\x81\xcd\x62\x21\x9e\x6c\xca\x62\x74\xf0\xca\x2c\x76\xcf\x62\xa9\x7d\x76\x16\x13\x4a\x75\x8d\xc7\x8e\xc2\x09\x97\xf7\xf9\x04\xfa\x47\xe4\xc0\x37\x6e\x00\x78\x12\x1c\xf0\xcd\x66\x24\x0e\x50\xff\xf0\x68\xac\xf3\xd8\xc1\xc1\x6c\x76\x60\xf0\xd8\xd8\xc7\xe1\xc4\xb8\x6d\x8e\x47\xb8\x3f\x3e\xd4\x79\x6c\x74\x74\x44\x46\xbe\xce\x63\x43\x72\x18\x8c\x86\x3a\x8f\x0d\x66\x13\x32\x34\x79\x6c\x76\x1c\x1e\xf8\xd8\xe4\xb1\xe3\xb0\x8f\x89\xbd\x8d\x1d\x1c\xda\x3c\xe6\x1f\x4d\x46\x9b\xf2\x18\x8c\x5e\x99\xc9\xb6\x19\xd3\xeb\x4b\x60\x32\xc3\xfe\xa1\xe9\x35\x06\xe1\x91\xc9\x69\x81\x4f\x02\xae\xb3\x10\x7a\x8d\x09\x19\xf0\x3d\x80\x73\x1a\x26\xc1\xe4\xc8\x38\x30\x8f\x7d\xdf\x3f\x30\x6e\x00\x47\x33\x7f\x34\xc6\x3a\xa7\x1d\xfa\xb3\xd1\x78\xa8\x73\xda\xc1\xd1\x71\x38\x32\xee\x9a\x93\xc9\xd1\x6c\x68\x1c\x98\xa3\xd1\xc1\xf1\x80\x18\x9c\xe6\xfb\x61\x78\xdc\x37\x38\x6d\x36\x0c\xc3\xc9\xb1\xc1\x69\x87\x07\x61\xd8\x1f\x99\x77\xcd\x71\x10\x0c\x0e\xef\x24\x98\xfd\xcd\xcd\x6e\xdb\x0c\x98\xf0\x65\xb0\xdb\xdc\x52\xa0\x1d\x87\x33\xae\x2e\xe3\xb3\x18\xf6\xc3\xb1\x3f\xd2\x19\x8d\x1c\x10\x72\xec\xeb\x8c\x16\xf8\xe4\xf0\x70\xa2\x33\x5a\x30\x26\x83\xc9\xa1\xce\x68\x7e\x10\xf8\xa3\x63\x9d\xd1\xfc\xbe\x8f\x47\x23\x9d\xd1\x70\x38\x1b\x0f\x8d\x63\xf3\x98\x1c\x07\xc3\xb1\xce\x68\x47\xc3\xc3\x43\xce\x1c\x82\xd1\xc2\x71\x18\x72\x3e\x97\x0a\x34\x12\x86\xe3\x81\xc1\x68\x3e\x65\xb4\xbe\xa9\x40\x23\x04\xf3\xa2\x8d\x18\x6d\xee\x10\xfe\xef\x99\x9b\xd5\x67\x67\x31\x69\x51\xd4\x98\x2c\x0c\x03\x8b\xc9\xc2\xf0\x98\x4b\x62\x43\x59\x32\x39\x0e\x74\x26\x0b\xc3\x70\x70\x68\xe8\x33\xc2\x90\x90\xc9\x91\xce\x64\x54\x7c\x1a\xcd\x74\x26\x0b\x83\xe0\x68\x64\x5c\x33\xc3\x99\xdf\x1f\x06\x3a\x93\x85\xc7\xf8\x68\x38\xd1\x99\x2c\x9c\x1c\x86\x36\x93\x85\x61\x78\x14\x18\x4c\x46\x8b\x04\x47\x29\x92\xb0\xc5\x64\x61\x18\x1c\x6c\xce\x64\x6c\xf8\xca\x6c\xf6\x60\x0c\x30\xd9\x4c\xd8\x7e\x0d\x2e\x3b\x22\x03\x93\xcb\x88\x3f\x1b\x99\x5c\x46\xfa\x47\x43\x93\xcb\x82\xc9\x38\x34\xb9\xcc\xc7\x43\x8b\xcb\xfc\x41\xdf\xd0\xcf\x86\xe1\x6c\xc4\xe7\x58\xce\x3a\xee\xf3\x12\xc1\x65\xe1\x91\xe0\x16\xc1\x65\xe1\x81\xe4\x1f\x45\xe2\xe4\x30\xb4\xb8\x2c\x38\x1c\xdb\x5c\xe6\x8f\x4b\x5c\x86\x67\x9b\x73\x19\x8c\x5e\x99\xc9\x1e\x2c\x01\x26\x93\x49\x33\xbd\xc1\x65\x23\xd2\xb7\xb8\xac\x3f\x1b\x9a\x5c\xe6\xfb\x47\x7d\x93\xcb\x66\x87\xe3\xc0\xe4\x32\x7c\x38\x3c\x30\xb9\xec\xf8\xa8\x6f\xdc\x01\xc2\xd9\x91\x6f\x71\xd9\xe4\xd0\x37\xb9\x8c\x84\x07\xbe\xc9\x65\xe4\x60\x32\x28\x71\x59\x30\x38\xea\x5b\x5c\x86\x67\x25\x2e\x3b\x1e\x94\xb8\xec\x20\xd8\x9c\xcb\xd8\xf0\x95\xd9\xec\xc1\x00\x50\x36\x38\xbd\x70\xb0\xda\x8c\x1c\xdb\xc7\xa6\xef\xcf\x7c\x93\xd5\xf0\xec\x78\x60\xb2\xda\x11\x3e\x98\x98\xac\x76\xd8\x1f\x8f\x4c\x56\x9b\x1c\x0e\x87\x06\xab\x8d\x27\x03\x2e\xce\x1f\x0a\x36\x1a\xe3\xc1\xb1\xce\x6a\xc1\xd1\x78\x34\x30\x8e\xcd\x59\x38\x3a\xe8\xfb\x16\xab\x1d\x93\x12\xab\x1d\x90\x12\xab\x8d\x02\x8b\xd5\x82\x60\xe8\xd7\xb3\xda\x4a\x83\xd3\x8b\x0a\x7e\x7b\x30\x06\x58\x06\x27\xee\xf7\xa2\x69\x36\x42\x32\xb3\xee\x9b\x87\xbe\x6f\xde\x37\x67\x3e\xc6\xd8\xd0\x9e\xe1\xc1\xd1\xd1\xa1\x71\x76\x1e\x05\x07\xe4\xc0\x60\xb5\xc3\xe3\xc9\x64\x6c\x68\xcf\x0e\x82\xb1\x3f\x36\x6d\x9b\xc1\xb8\x3f\x32\x14\xb4\x63\x32\x1a\x0f\x89\x71\xdf\x24\xc3\xc3\xe1\xc8\x60\x35\x8d\xc4\x27\x65\x1a\x9f\x94\x49\x7a\x52\x6e\x6f\x23\x8b\x13\x1d\xbe\x12\x97\x8d\x1f\xac\x00\x65\xb3\x26\x77\xf6\xd1\x18\xcd\x27\xa1\xa9\xa6\xf5\xc3\xe0\x28\x30\xf6\xb4\x59\x7f\x46\x7c\x43\xb1\x71\xdc\xc7\x63\xae\xb0\x12\x5a\x84\xa3\xe3\xfe\xb1\xe1\xb0\x71\xd0\x3f\x0c\x8e\x8c\xab\xc0\x64\x7c\x40\x0e\x0d\x87\x8d\xf1\x64\x82\xb9\x96\x9f\x33\xda\xe8\x70\x7c\x38\x36\x14\x1b\xc3\x83\xd1\x90\x2b\x3f\x9e\x94\x49\x7c\x52\xa6\xf1\x49\x99\xa4\x27\xe5\xf6\x36\x35\x6d\xd2\x11\x2c\xf3\xda\x3d\x33\x07\xf0\x58\xe8\x57\x51\xe1\x5f\x54\xfa\x76\x35\x72\x43\xe6\x9d\xdf\x85\x6b\x17\x23\xef\x1e\x38\x76\x8d\xb7\xa9\x69\xbf\x8f\x61\x3c\x3f\x7d\xa4\xcd\x9d\x06\x0e\xbd\x77\x61\x3c\xd1\xfe\x3e\x42\x57\x04\xbf\x7f\x48\xe5\x60\xb5\xe1\x4a\xe5\x00\xcb\xfe\x29\xae\x8c\xec\x39\x38\x1a\x39\x80\x6b\x33\x3a\x48\xa8\xaf\x3b\xf2\xe6\xee\x52\x34\x46\x49\x1c\x25\xa4\x1b\xc6\xe4\x1a\x4e\x4f\xfa\xdf\x55\x14\x14\x17\x53\x74\x30\xec\x58\xb1\xc0\xa7\xc8\xcb\x48\x8c\x59\x94\x1e\x91\x2a\x21\x26\xd7\xaf\x2e\xb2\x28\x79\x3f\x45\x7d\x3d\xce\xe2\x0c\x67\x76\x48\xc6\x97\x38\x88\x96\xf9\x14\x1d\x76\x4a\x74\xb0\x54\x91\x8e\x06\xf1\x2c\x4f\xe3\x65\x41\x6c\xea\x46\x63\x51\x70\x41\x58\x7c\xc9\x81\x2c\x29\xd2\xc5\x14\x79\x93\xfe\x5f\x65\x25\x2d\x26\x66\x57\xb6\x1e\xb3\x08\x91\x65\x38\x16\x3a\xb2\x3b\x90\x90\xfa\xc3\x65\x9e\x0f\x42\x96\xe4\x3c\xb8\x4c\xeb\x8d\x97\x2e\xb0\x1f\x15\x37\x5e\x07\x79\x33\xec\xbf\x3f\xcf\xd2\x65\x12\x74\x7d\x2a\x81\x78\x6f\x3b\x5a\x74\x99\x40\x45\x3d\x29\x61\x13\xdf\x7a\xf9\x45\x9a\x15\x24\x2f\x44\x28\x18\x99\xd0\x42\xe1\xe6\xc2\x8d\x19\x24\x93\xb2\x16\x7b\xd5\xce\x64\x1e\xf4\x23\xd8\x18\xfb\x1e\xe2\x6a\x15\xd9\x5b\x4e\x6f\x03\x04\xfd\xde\xe8\x08\x4d\xe9\x3f\xfa\x14\xb3\x34\x8f\x6a\x8e\xaf\x5f\x5d\xe0\x20\xbd\x92\xa1\x3e\xe1\x57\xfe\x66\xf0\xb6\x92\x72\xcf\x5f\x66\x19\x49\x98\x94\x66\x4f\xf1\xb0\x6f\x4f\xb1\x2a\x31\x19\x0a\xe6\x50\xa7\x6c\x7f\x1f\xfd\x92\x66\x48\xed\x1f\x50\x2a\x97\xbc\x20\xf9\x8f\xe7\x49\x40\xae\xa7\x68\xd0\x91\x81\xb9\x9a\x0d\xa8\x95\x94\x24\x23\x37\x6f\x26\xfd\xb7\xa8\x94\xad\x84\x7e\x18\xf7\xfb\x6f\xd7\x62\x24\x16\xe8\x20\x4c\xb3\xb9\x77\x77\xa6\xd1\x47\xc5\xbf\x20\xfe\x7b\x3d\xf7\xaa\xb3\xbb\x7a\x12\x15\x83\x6e\x4a\xd1\x94\x87\x61\x88\x71\x41\xfe\x57\x6b\x30\x5e\x5c\xb7\xe5\xb4\x79\x8f\xd0\x63\xf4\x97\x19\xce\xbc\xa9\x46\xf6\x0a\x6e\x75\xb5\xa6\x71\x66\xbf\x37\x11\x5d\xd1\x7b\x22\x12\xcf\xac\xe8\x4a\xb3\x99\xa3\x13\xe4\x9e\xba\x23\x8d\xa8\x8d\x7a\xd7\x7c\x2d\xae\xb7\x1a\x07\x43\x58\x8d\x03\x73\x6c\xcc\x60\xb6\xc6\x79\x0c\x71\x12\xb4\x43\x57\xc5\x49\x68\x6f\x21\xf6\xed\xf3\x10\x9d\x51\xb1\xf5\xac\xc3\x23\x35\x8a\x24\x33\x51\x2e\x98\x4e\x8f\x0c\xcb\xb9\xb0\x2a\x44\x4d\x42\x5e\x84\xb4\xd5\xd6\x9b\xba\xc0\x42\xf5\x01\x69\xde\xb6\x2b\xf2\xd7\x16\xa9\x38\x75\x58\x84\xd0\x7a\x7a\x69\xcf\x30\x62\x28\xe9\xc7\x45\x96\x5e\x46\x01\x09\x3a\x28\x2a\xd0\x55\x14\xc7\xf4\x1a\xbf\x94\x61\x27\xc3\x34\x29\x50\x1c\x9d\xe3\x62\x99\x91\x52\x8f\x9f\x6f\x90\x15\xf7\xce\x31\x90\xb6\x19\x91\xc8\x1c\xd2\x7f\xe6\x24\x5c\xc6\x74\x40\x99\x20\xcf\xb3\x01\xdf\xc4\x04\x61\x1e\x70\xb5\x48\xdd\x09\x88\xef\x4d\xec\x5a\xbe\x0a\x9e\xad\x60\xc9\x72\xcc\x57\x8b\xe3\x73\x76\x23\x17\x1c\x21\xb6\x27\xd5\x65\xb5\x61\x6d\xda\x44\x16\x2d\x16\x31\x41\x24\x0c\x89\x5f\xac\x6e\xe9\x25\x80\x6f\x92\xe1\x79\xe5\x0a\x59\x26\x3b\x58\x23\x9b\xa4\x8c\xbe\xc7\x8b\x43\xdd\x28\xf5\xc5\x40\x87\xf2\x2c\x4a\x16\xcb\xe2\x0c\x11\x16\x8c\x50\x1b\x01\x5a\x0e\xdb\xeb\x5a\x0b\xe3\x9f\x39\x41\xc5\x05\x2e\x8c\x98\xb7\x0b\x9c\xd3\xb1\xce\x48\x88\x7c\x1c\xc7\xf4\x94\x12\xed\xb3\xc8\x6d\xac\x35\x57\x30\x5c\xf8\xf0\x92\x84\x4d\x82\xf6\xba\x17\x55\xb2\xee\xaa\x7c\x26\x48\x0c\x21\xe8\x91\xe4\xba\xbc\xc0\x05\x61\x7b\x32\x4e\xce\x05\xbf\xf1\x46\x17\x38\xc3\x73\xf4\x81\x0d\xc9\x2d\x22\x97\x94\x3b\x29\x13\xb3\xbf\xf2\x74\x99\xf9\x44\xc6\x0e\xe6\x2d\x98\x75\xe9\x22\x20\x38\xb9\x15\x1b\x34\x54\x3f\xe3\x3f\xce\x98\x3e\x46\x60\x60\x2b\x5c\xf6\x31\x4d\x9e\x01\x4d\x6b\x84\x36\xb6\x87\xa9\xc0\x33\x2e\x7e\x6e\x7c\x10\xb2\xa4\x68\x1b\x1c\x85\x46\xd7\x1c\x4c\xc0\x55\x51\xb5\x78\xed\x18\xbd\x30\x40\xa5\xc4\xe7\x0d\x73\x82\x55\x87\xd2\xdd\x34\x9a\xac\x1e\x16\x56\x86\xb1\x7b\xdb\x96\x21\x51\x79\xbe\xf5\x15\x29\xd7\x20\x1e\xa9\x3b\xaf\x16\x20\xb8\xbd\x43\x84\xd3\xcd\x73\xa1\xd3\x2a\x6d\x2d\x63\x58\x4d\xa3\x4a\xe6\xeb\x54\x86\x54\xe5\x23\xcd\xb6\x60\x3d\xf5\xbc\x3c\xa8\xb5\x5b\x88\xb8\x43\x09\xb2\x8c\xdc\x66\xc6\x2d\x43\xa6\x6d\x67\x05\x0a\x42\x1d\x86\x12\x89\x9e\x48\xd2\x08\x7b\xaa\x49\x4e\x32\xb3\x84\x0c\xf6\xda\x28\xda\x6b\xdd\x1c\xce\x70\xc6\xee\x48\x3c\x9c\x2a\x0c\xd6\xe7\x89\xa4\xfa\xc9\xc4\xe2\x2f\x47\x1e\xfd\x62\xc2\x62\x9a\x62\xe8\x76\x62\x50\x8a\x25\xb5\x55\x6c\x4c\xaa\xfc\x8c\x69\xfb\xef\x15\xff\x35\xee\xa9\x94\xec\xb6\xc5\x81\x42\x48\xdb\x4e\x60\xcd\x64\x8b\xac\x2c\x04\xa3\x2d\x85\xfc\xe4\x32\x52\xcd\xb8\x6d\x4b\x48\x6a\x4a\x12\x88\x46\x0d\x46\x4b\x8f\x8b\xb9\x7e\xdc\x4a\x7a\x5e\x31\x39\xda\xfb\x6d\x19\xb1\x73\xc9\x43\xb7\x6d\x7e\x9e\xef\x26\x92\xe5\xf8\x9e\x3d\x1a\x61\xa6\xa2\xd7\xe0\x13\x51\x65\xec\x6e\x14\xf1\x69\x87\xc6\x6e\xa0\xae\x32\x0e\x0b\x7c\x7d\x9a\x06\xd5\x81\x58\x1a\x05\x7e\x92\x68\x76\xd6\x03\x8a\xbc\xbe\x17\xcf\x48\x5c\x15\xb1\x6d\xd4\x6f\x14\xc2\x47\xa2\xd9\x59\x2f\x28\xf2\xfa\x5e\xfc\x92\xa6\x45\x75\x28\xab\x71\xa3\x50\x56\x1a\xa2\x9d\xf5\x84\xa1\xaf\xef\xcb\xdf\x09\xae\x0a\x93\x7a\x30\x6e\x14\xd9\x4a\xa2\xd9\x59\x3f\x28\xf2\xfa\x5e\xfc\x8e\xcf\xa3\xa4\x2e\xf5\xde\xc1\xb8\x51\x90\x2b\x0b\xd9\xce\x7a\xa4\x9a\xa8\xef\xd7\xcb\xea\x68\x6f\x93\x46\xd1\x97\x04\x96\x9d\xf5\xe4\x65\x4d\xc4\x37\x00\x78\x95\x66\x85\xc8\x9b\xe3\xee\x48\xa3\x48\x8d\x26\xae\x9d\x75\x47\xb6\x70\x1f\x3c\x8f\xee\xd9\x7b\xb8\xcf\x9c\x11\xf8\x5e\x39\xf6\x9c\x13\x5a\x5c\xa4\x54\x8e\x7f\x11\x56\x90\x70\x54\x01\x5e\xe7\xad\x62\x42\x9a\x4e\x3b\xcf\x70\x1c\xc3\xf5\xae\xaa\xcf\xc7\x15\xf0\x75\x5d\xb5\x30\x2b\x0c\xa0\xff\x78\x46\xbf\x56\x35\x37\xe8\xbb\xa0\x6b\x1b\xd3\x90\xaa\xe8\xd1\x69\x9e\x47\xf4\xe0\x4d\x93\xbc\xc8\x96\x7e\x91\x66\x2f\x61\x09\x55\xb6\x3b\x58\x5d\xb7\x8e\x8a\xea\x06\xb5\x58\xca\x17\x24\x8b\x8a\xea\xae\x97\x41\xeb\x5a\x94\xe8\xda\x3b\xcd\xea\xac\xeb\x9c\xdc\x57\x8b\x12\x64\x1d\x72\x09\xf4\x25\xb9\x99\x7d\xbd\x0e\x60\x0d\xf1\x71\x95\xe7\x6b\x70\x19\xb8\x23\x6d\x3a\xae\xcf\xe1\xa3\x16\xa6\x49\xf1\x0b\x9e\x47\xb1\xf4\x88\x28\x6e\x16\xe9\x79\x86\x17\x17\x37\x3d\xf5\xd1\xf2\x19\xf2\x06\x7d\xcd\x9d\x8b\x79\x09\x89\x4c\x13\x53\xe4\xf9\xfc\x4f\x0b\xe2\x15\x4b\x4a\x3c\x45\xd2\xbf\x28\xbd\x24\x59\x18\xa7\x57\x53\xe4\x5d\x44\x41\x40\x12\xcf\xe5\x62\x71\x17\x9f\x89\xd7\x5a\x4a\x4b\x6e\x88\x29\xa8\x18\xd3\x41\x49\x9a\xcd\x21\x95\xe9\x99\x14\xa1\x49\x76\x86\x70\x12\xf0\x12\x7a\x59\x3b\xbb\x07\xa9\x76\x1f\x7c\x0b\xca\x13\x2a\xec\xe4\x60\xf0\x0e\xd3\x8c\xd9\xee\xd3\xb4\x40\x49\x1a\x70\x7b\x37\xfa\x39\x02\xa3\x96\xb4\x9a\x17\x29\xe4\xf4\xc3\xe8\xa7\x17\xbf\x09\xc3\x30\x4a\x29\x80\xc3\x36\x27\x8b\xd6\x9d\x6f\x63\x77\xd8\x70\xda\x75\x1c\xdb\x99\x7d\x0d\x63\x5b\x2e\x2c\xa1\xf3\x91\x5b\x47\xeb\x1d\xd4\xff\xcb\x33\xd1\x79\xb6\x7f\x80\x1a\x4d\x9e\xe2\x4a\x89\xf6\x9a\xad\xa4\x52\x25\x30\xd6\x49\xa4\x00\x25\xef\x18\xca\x02\xa7\x84\x2f\x85\xb1\xb8\x88\xf2\x0e\xab\xd1\x3e\xd1\xef\x24\x50\xad\x5a\x96\xb1\x31\x30\xd2\x7a\xef\xe8\x00\x14\xe9\xbb\x77\x74\x6f\x05\x14\x96\x9c\x69\xf5\xa5\xdd\xee\x51\xc6\xbf\xe1\x58\x70\x76\xbe\xa4\xa3\x96\xb7\xdb\xec\x92\x23\xc6\x42\x17\xe6\x4a\xc3\xf1\x86\x75\xf4\x3d\xb9\x99\x22\xef\x9c\x14\xcf\xe8\xc6\x01\xb9\x71\xae\x0b\xbe\x23\xf2\x8b\x83\x7e\x09\xd3\xa1\xe4\x60\x81\x8b\xa5\xf9\x6c\xa9\x1b\x47\x09\x61\x6b\xa7\x3b\x27\xc5\x45\x1a\xe4\xdd\x65\x4e\xba\x94\x62\x5e\xc7\xd8\xee\xc1\xaf\x90\x5d\x00\x3f\xdc\x0a\xc3\xdf\x89\xda\x66\x85\xef\x23\x23\x37\x23\x49\x40\xb2\x0a\x2a\xd9\x47\x8d\x38\x29\x28\xd1\x6d\x97\x12\xd0\x63\x76\x61\xd9\xb0\x9e\xa2\xf5\x9d\xd3\x34\x8d\x1c\xd9\x5e\xdf\x55\xd8\xa8\x91\x99\x3a\xf6\x9d\x3b\x77\x2c\xfd\x4f\xb2\xa2\x85\x51\x14\xeb\xb0\x6b\x5a\xbe\xdf\xd5\x9b\xbe\xed\x14\xaa\xa2\x45\x61\x13\x17\xc3\xb6\x49\xaa\x50\x47\xce\x4f\xfd\xd6\xde\x24\x19\xa7\x35\x34\x6a\x1c\xee\x94\x07\x14\xd9\xa9\x33\xc1\xd2\x2b\x59\xec\x2d\xfc\xe0\x64\xc2\x22\x39\xd9\xbb\x6d\xd9\xf4\x1a\xdb\x07\x5b\xbe\x8e\xe4\x56\xda\xb6\xec\x01\x5b\xb3\xc7\x66\xbc\x82\xaf\x2d\x22\x21\xe6\x7f\xd8\x93\x0b\x40\x13\xea\x65\xb3\x6c\xc6\x37\xcc\x7b\x65\xda\x0f\x80\x06\x30\x1f\x88\x0d\xcc\xd6\x57\xdc\xb3\xe0\x2a\x0f\xfa\x8a\x07\x7d\xc5\x83\xbe\xe2\x41\x5f\xf1\xa0\xaf\x78\xd0\x57\xfc\x89\xf4\x15\xaf\xa2\x3f\x88\x43\x5b\xb1\xb8\x7e\x9d\xbe\x24\xf3\xd6\x60\xd4\xae\x7f\x68\x44\xae\x0b\xf1\x20\xe6\x13\xa8\x1b\x94\xd0\x69\xab\x1c\x5e\xa6\x57\x0f\xfa\x85\x07\xfd\xc2\x17\xae\x5f\xe0\x7e\x19\x77\xd2\x31\x50\x1c\xcd\xf4\x0c\x14\x72\x7d\x5d\x03\xf8\x65\xdc\x5d\xdf\x40\xd1\xac\xad\x73\x80\xb6\xef\xae\x77\x60\x43\x74\x7f\x75\x0f\xda\x8d\x7b\x96\x06\x37\xfc\x16\x22\x8a\x1e\x34\x13\x0f\x9a\x89\x7b\xa1\x99\xa0\xcb\xa8\x99\x76\x02\x16\xfb\x2a\x0d\x05\x65\x75\x5d\x43\x01\x95\xee\x81\x96\x02\xbc\xdc\xa4\xa6\x82\x6f\x7f\xb6\xb6\xe2\x9e\xc5\xe8\x7c\xd0\x56\x3c\x68\x2b\x1e\xb4\x15\x0f\xda\x8a\x07\x6d\xc5\x83\xb6\xe2\x0b\xd2\x56\x0c\x1b\x68\x2b\x72\xe2\xa7\x49\xf0\xa0\xaf\x78\xd0\x57\x3c\xe8\x2b\x76\xad\xaf\x90\x6f\x17\xee\xa4\xb1\x60\x58\x9a\xe9\x2c\x18\xec\xfa\x5a\x0b\xfe\x7a\xe1\xee\x7a\x0b\x86\x68\x6d\xcd\x05\x6f\xff\xee\xba\x0b\x31\x58\x7f\x0a\xed\x45\x08\xc4\x3e\xe8\x2f\xee\x97\xfe\xe2\x53\x6b\x1c\x36\xd3\x8c\xdc\x59\x3d\xc1\x56\x4a\x33\x05\x05\x5f\xd5\xab\x54\x14\x94\x9f\x75\x15\x05\xaf\x76\x0f\x94\x14\xfc\xf1\x97\x54\x53\xc8\xfd\xce\x56\x54\xdc\xb3\x3c\x0f\x0f\x8a\x8a\x07\x45\xc5\x83\xa2\xe2\x41\x51\xf1\xa0\xa8\x78\x50\x54\x7c\x91\x8a\x0a\x0a\xfd\x6f\x1e\x2c\xd6\xf9\x68\x84\x7d\xfc\x8d\x04\xd1\x72\xfe\xa0\xdd\x78\xd0\x6e\x3c\x68\x37\xee\x8b\x76\x83\x47\x33\xb8\x93\x6e\x83\xe2\x68\xa6\xd9\xa0\x90\xeb\xeb\x35\x20\x9a\xc1\xdd\xb5\x1a\x14\xcd\xda\x3a\x0d\x68\xfb\xee\x1a\x0d\x36\x44\x7f\x0a\x7d\xc6\x05\xc1\xc1\x83\x36\xe3\x7e\x69\x33\xd4\xb0\x7d\xdd\xde\x18\x74\x19\x35\x53\x76\xc0\x62\x5f\xa5\xea\xa0\xac\xae\xab\x3a\xa0\xd2\x3d\x50\x74\x40\x6c\x18\xa9\xe6\xe0\xdb\x9f\xad\xe4\xb8\x67\x59\x06\x1f\x94\x1c\x0f\x4a\x8e\x07\x25\xc7\x7d\x56\x72\x7c\x8a\x6c\x44\xcf\xfd\x34\x79\xba\x2c\x8a\xca\xb0\x52\x83\x51\xdf\x01\x5c\xd7\x8a\x82\x52\x15\x21\x8a\x76\x55\x03\x03\x13\xae\x16\x37\x05\x90\xe0\xbf\x91\x64\x59\xa5\x9e\x39\x56\xab\xe7\x15\x89\x49\xe5\xec\x8c\xfa\x23\x0b\xb0\x36\xd3\x12\x40\xc8\x0a\x0d\x23\xbe\x99\xb0\x75\xf8\x55\x78\x36\x59\x2d\x4d\xe3\x19\xae\x0a\xc5\x36\x38\x3a\xb2\x21\x6b\xd1\x33\x10\x55\x45\xde\xfa\xab\xf6\xf8\xbe\x03\xb6\xb6\x05\x09\x25\x2b\xfe\x4f\x72\x33\x4b\x71\x16\x3c\xc9\xb2\xf4\xea\x57\x12\x56\xce\x84\xb6\x01\x95\xea\xd4\xb5\x59\x02\x76\xa3\x79\x19\x9d\x5f\x54\xb7\x3d\xa8\xa9\xd4\xb8\x71\x80\xfe\x6a\x75\x6f\xfb\xfb\xe8\x7f\xf0\xad\x91\x04\x52\xc2\x43\x92\xa7\xbf\x5a\xe5\xdc\xfe\x3e\x7a\x9e\xd0\xc3\x12\x72\x10\x10\x94\x2f\x88\x1f\x85\x91\x1f\xb1\x2c\x04\xe9\x25\xc9\xb2\x28\x20\x6a\xa4\x7a\xbc\xa2\xf7\x68\x1a\xe3\xbc\xe8\x82\x88\x6b\x24\xd4\x59\xe0\x20\x60\xa1\x58\xf6\xf4\x2b\x1f\x8f\x08\x5e\xb0\x75\xae\x2a\x88\xcc\x50\x93\x03\x99\xc2\x2b\x4a\xfe\x5e\x2a\xe4\x58\x5f\xf2\x34\x52\x3a\xca\x7c\x81\x7d\xa2\x61\x0c\x63\x72\x3d\x45\xde\x00\x0d\x10\xc4\x92\xd1\x61\x7d\xbc\x60\x19\x98\x74\x60\x67\xf6\x33\x08\xd0\xeb\xd2\x62\x7a\x9c\x91\x0c\xbc\x39\xec\xbe\x2f\x8d\xb1\x65\xa9\xc8\x5e\xea\xba\xcc\x9c\x85\xa9\xe9\x2d\x93\xa8\x40\xdf\xa1\x71\x19\x85\x5d\x9d\x65\x32\x2b\xd7\xae\x4c\xa6\x46\xef\x1a\x4f\xe2\xe8\x1c\x72\xbd\x41\xbe\xa1\x8a\x21\x1c\xae\xa1\x3d\xb5\xd3\x78\x8d\x64\xe5\x38\x4a\x88\x98\x2d\x6f\x34\x5c\x5c\x1b\xc3\x82\x81\x25\xf3\x8a\xe1\xde\x80\x80\xfa\x41\x41\xdf\xa1\x21\x4f\x37\xb5\x99\xaa\x17\xa2\x0f\xfe\xc4\x72\xa7\x90\xe0\x65\x7a\x95\x3f\xc9\xce\xc5\xad\x2d\xcc\xd2\x79\xa5\x0e\x8d\xc5\x28\xb6\x22\xc2\x17\xe9\x7a\xf0\x7e\xba\xa4\xb7\xc9\x75\xaa\x2c\x70\x4d\x0a\x8b\x52\x0d\x3a\x1e\x77\xd5\x7c\x7f\x5a\x5d\xef\x83\x96\xf6\xce\x5a\xda\x15\xca\xf3\x34\x7e\xb5\xc0\xc9\x0a\x1e\x2a\x4f\x4a\x91\x16\x38\x46\xec\x2b\x4a\x43\x94\xa5\x57\xfa\x54\xaf\xcb\xc9\x6e\x0e\xf3\x97\x79\x91\xce\xa3\x3f\xd8\xe1\x14\x88\x85\x09\x8d\xa1\x98\x0e\x85\x6a\x32\x2e\xad\xdd\x35\x52\xbb\x54\x35\x09\x0d\x2d\x48\x06\xeb\x8c\xb7\x88\x9e\x27\x97\xe9\x7b\x12\x20\x7a\x69\x41\x18\x9d\x7d\x80\xad\xa1\x83\x8a\xb4\xc3\x3a\xde\x61\xe0\xb7\x67\x0c\x39\xcf\x16\x61\x52\x4a\x09\xfc\x9d\x64\xbf\xc3\xfa\xfd\x62\x0c\x41\x55\x89\x80\x60\x3c\xb4\x3c\x40\xe6\x18\x16\x57\xa9\x52\x85\xc3\xc6\xce\x73\x00\x61\xb6\xbd\x30\xdc\x80\xa3\x48\x51\x7e\x91\x5e\xa9\xc1\x14\xe1\xea\x7f\xaf\xdb\x08\xe9\x38\x55\xb2\x5b\x15\xcd\x26\x6f\x2b\x2e\x58\xa3\x1b\xac\x01\xe8\x4b\x99\x62\x83\x03\x36\x21\x9c\x2e\xc3\x3f\x48\x96\x76\x67\x98\xee\x8b\x51\x12\x90\x6b\x69\x8c\x64\x69\x39\x81\x62\xd5\xf4\x7a\xa7\x45\xb9\xb5\x8a\x21\x51\x0d\x64\x0d\xfa\xb4\xa2\x9d\x67\x62\x01\xe6\xd0\x91\x14\x04\xb6\x5c\xf4\xcb\x9c\x0a\x26\x33\xa1\x30\x22\x71\xe0\x24\xe2\xc5\x82\x0b\x20\x55\x92\x75\x96\xe1\x9b\x17\x61\xab\x96\xd4\x15\x3b\x28\xc8\x21\x2b\x0e\x35\x29\x88\xbc\xcb\x48\x08\x0a\x9c\x5a\x55\x39\x57\x37\xc8\xd4\x3c\xf4\xa6\xc5\x2c\x33\xff\x4c\x02\x92\x51\xa1\x8b\xe9\x4b\xd1\xad\xa6\xc2\x09\xc7\xab\x11\x3b\xae\x90\xaa\x95\x64\xa9\x5d\xef\x33\x12\x4e\xd6\xc4\x07\xd7\xe1\x6a\x74\x07\xdb\x45\x77\xb8\xa5\xde\xc2\xc4\x7e\x87\x9e\x68\xc6\x7a\xc4\x56\x94\x12\x3c\xa8\xcc\xb1\x88\x41\xd2\x44\x51\x92\xd3\x2b\xd1\x99\xe6\x38\x78\xc6\x00\x64\x60\xf1\xde\x1e\x65\x0d\x69\x19\x35\x22\xa4\xdf\xc9\x3e\xaa\x30\x35\xb3\x92\x2a\x78\x69\x33\x13\xc3\xc7\x8d\x37\xf0\xb3\x20\xf3\x45\x07\xbd\x63\x46\xc9\x77\x19\x29\xf8\xc7\xc6\x76\x55\x2d\xa6\x3a\xaf\x4a\x07\xa4\x05\xc8\x63\x30\x95\xc9\x8d\xb1\x17\x93\xe4\xbc\xb8\x00\xe3\x27\x15\x2e\x9f\xd0\x25\xd8\xa2\x50\xed\x0e\x7a\xf7\x9e\xdc\xa0\x53\xd4\x3f\x61\x7f\x7d\x0f\xb5\xd9\x8f\xc7\x8f\x95\xd5\x8f\x56\x7d\x43\x0b\xdf\xea\x98\x59\x89\xb0\xfa\xec\x99\x86\x29\xb0\x9f\x40\x47\xd9\x1f\x17\x51\x2e\x2c\x2a\x6b\x58\x7f\x79\x8e\x28\xab\xcf\x6b\x9b\x82\xb5\xe1\x6a\x43\xaa\x0f\x6e\x15\x66\x19\x4a\xde\xd0\xc6\xde\xf6\xfc\x34\xf1\x71\xd1\xa2\x7d\x6d\xb7\xdb\x7c\x7a\xc4\xbf\xbd\x0b\x9c\x04\x31\x79\x8a\xfd\xf7\x4c\xa3\xf9\x2c\x8e\xfc\xf7\x06\x7b\xc1\xb1\xa3\xc6\xec\x9d\xb2\x8e\xf6\xf4\x43\x93\xc1\x75\x8c\xef\xb0\xb9\x76\xd1\x40\x98\xd0\xcc\x46\xff\x41\xae\x8b\x5d\x35\xfa\xd8\x6c\x94\xcc\x17\x22\xad\x4b\x93\x59\xd2\x38\xb8\xb9\x41\x5d\x5f\x53\x86\x59\x5d\x2e\xff\x7f\x47\x71\xfc\x92\xf8\x24\xba\x24\x3c\x09\x90\xd3\x38\x5d\x09\x0f\xf3\x3a\x34\x8d\xd6\x20\x28\xb2\x1d\x2c\x1c\xf6\x98\xd8\xa8\x9b\x84\xb5\xc1\x92\x50\x7a\xa1\x0e\xac\x1d\x78\x12\x56\x2b\x33\xac\xbe\x09\xb9\xfa\x15\xe7\x05\x87\xfd\x0d\x17\x17\xbd\x39\xbe\xa6\x63\x04\x7f\xfb\x24\x8a\x5b\x8c\xb6\x7d\x1d\x6f\x5b\x63\x07\x84\xa2\x10\xb5\xec\x99\xfb\x41\x47\xdd\xd6\x14\x42\xc6\xbc\xd3\x4d\xb7\x63\x40\x9e\x98\x6a\xa2\x7b\xe2\x10\xa0\x94\x84\xf5\xa6\x7b\x7e\x7d\xb2\x8d\xfc\x50\x68\xc2\x2d\x4d\x5c\xd6\x7c\x97\x6f\x2f\x0a\xb8\xfc\xad\x54\xf3\xa5\xc9\x01\x5a\x3d\xed\x4b\x1d\x7f\x95\x97\xa8\x0b\xda\xd9\x8c\xe3\xa3\x5e\x77\x61\x00\x2f\xea\x59\x97\x01\x65\x6e\x4c\x65\xb9\xce\x59\x85\x7f\xd3\x6b\x82\x88\xa6\x80\xe1\xe7\xd6\x1d\x30\xa4\x9f\x05\xfc\x00\x0e\x60\x7f\x2e\x59\x59\x79\x1a\x65\xa9\x36\x74\x9e\x96\x82\xcb\xfe\x6d\x81\x2d\xf8\xbf\x99\x59\x5c\x1e\x0a\x5a\x0a\x7d\x36\x1e\xb4\xb0\x5d\x08\xe8\x44\xa7\xe8\x32\x8d\x02\xd4\x97\x5b\x05\x5d\xe1\xda\x1a\x38\x3d\xd5\xcd\x44\xd2\x25\xe1\xe3\x47\x64\x02\x79\x45\xe0\xe9\x6b\x5f\xe1\xd7\x17\xca\xc7\x8f\x68\xd0\xef\xf7\x4f\xd0\xfe\x3e\x2d\xef\xe6\x14\x24\xbd\x24\x19\xbd\x2a\x65\x37\xc5\x45\x94\x9c\xcb\x5d\xe1\x6e\x2e\x26\x1b\xb8\x97\x28\x67\x17\xa1\x1a\x11\xbd\x70\xf8\x9c\x34\xa4\x07\x29\x23\x58\x39\xdf\x26\x72\xa7\xb6\xe4\xaa\x72\x95\x4b\x73\x75\x7b\x75\x99\x32\x99\x9a\x1c\x9c\x3e\x9a\xa2\xd3\x00\x91\x61\x66\x73\xf5\x81\xf6\x82\x4a\x3b\xf4\xe0\x64\x5a\x76\xaf\xe3\xa2\x83\x7f\x34\xbb\x55\xde\xc6\xb4\x8f\x1b\x53\xcc\xad\xa6\x15\xd4\x1a\xbf\xf4\x54\xa9\xdc\x46\x22\x07\x4e\xea\xf6\x3b\x52\x49\x6f\x7e\xb3\xfb\x82\x10\xdc\xdf\x9e\xc5\xa5\xe4\xab\xe2\x3f\xb3\x05\xb0\x35\x58\x30\x25\x94\xdc\x20\x01\x17\x48\xfb\x1b\x3f\x15\x2b\xf6\x4d\x84\xf4\x74\xc7\x8e\xcd\x64\xaf\xa6\xe1\xf2\x6e\xd2\x9b\xe3\x45\x4b\x49\x7c\x25\x80\x76\xa9\xbf\xeb\xad\x5d\xf1\x1f\x18\xd1\x7b\xf4\x7f\x9e\x17\x64\x6e\x77\x88\xb2\x1b\xc8\x07\xa5\xf6\x3b\x8e\xe1\x78\xe1\xe4\x39\x67\xff\x2c\x08\x29\x9f\xf0\xd1\x69\x6f\x83\x31\x3f\xc1\x52\x32\x0e\x9a\x96\x3d\x23\xcc\x96\xc1\x85\x92\xd3\x53\xd4\x47\x3f\xa2\x3e\x9a\xb2\xc3\xfa\x3b\xe3\x54\x7e\x8c\x06\xf6\xa8\x15\xe9\x94\x4b\x8e\x51\xd2\xe2\x1a\xcf\x96\x14\xdf\xcd\xfa\x6d\xbb\x32\x57\x0d\x97\x24\x20\x84\x84\x7e\x6a\x51\x62\xc9\x6d\x0c\xba\x96\xb7\x59\x8d\xb2\x63\x50\xb9\xcd\xca\x1e\xd4\xb5\x98\x57\xf7\x47\x71\x4f\x30\x6d\x9c\xdf\x9f\xa6\xa8\xfa\x42\xd7\xd1\x52\x2d\x33\x41\x0a\x26\xab\xc4\xc7\xcc\x16\x16\x44\x19\x61\xab\x12\xce\xe2\xac\x88\x3d\xf4\x23\xd7\x0c\xb1\x9d\x63\x62\xd4\x6b\xef\xba\x8b\xa5\xd5\xe6\xea\xb2\x75\x9d\x2c\x2f\x51\x6b\x08\x7e\x38\x6d\x70\x55\x59\xb5\x9b\xae\x1a\xb0\x03\x3e\x60\x87\xe6\x80\xed\xb9\xfe\x16\x7f\xd5\x3b\x9c\xaa\x6b\x66\x33\xb7\x53\x4d\xbd\x50\xef\x7c\xea\x10\xcc\x3a\x4e\x2b\x83\xf7\x52\x57\x9e\x4e\xbd\x4e\x85\xd5\x44\xee\xed\x8e\x8d\x84\x8e\xc9\x91\xae\x4a\xa2\x3b\x09\xbf\x74\x1e\xf5\xc0\x0e\x22\xc7\xa5\x48\xe5\x87\x22\xd5\xdc\x74\xb5\x9b\xef\x11\xbb\x09\x19\x1e\xf9\x80\xf1\x31\xf2\xba\x1e\x7a\x4c\x71\x3c\x46\x1e\x4a\x43\x44\x7f\x49\x60\x98\x4f\x97\x9e\xf7\xcd\xa4\x83\x06\xfd\x0e\x1a\x4e\xde\xee\x6d\x9c\xb7\x95\x7e\x7e\xcd\xb4\xba\x90\xd9\xce\x76\xaa\xd5\x92\x14\x4a\xd7\x5a\x53\x03\x66\x39\xd8\x1e\x6f\xd1\xc1\xb6\x26\x6d\xac\xc2\xcd\x93\x9e\x43\xf5\x4f\xe0\x8f\x6b\xe2\xae\xf2\x65\x3c\x6c\xbb\xe1\xeb\x1c\x1a\x2d\xcc\xf7\xd3\x49\x77\xa7\xee\xc8\x19\x09\xe1\xa2\x84\xae\x08\x7e\xbf\x4b\xa7\xce\x87\x87\xa5\x7f\x4e\xe7\xb6\xad\x3a\x86\x55\xdd\x92\xf9\xee\xbd\x48\xf3\x88\x39\x50\x79\x19\x89\x71\x11\x5d\xaa\x4c\x5c\xdc\x3c\x3f\x45\x5e\x18\x93\x6b\x59\x8c\xe3\xe8\x3c\xa1\x12\x7c\x4e\xc5\x59\x42\xe7\x45\xf8\x08\xf1\x53\x78\x1e\x5d\x47\x89\xbc\xef\x72\xa1\xe4\x7c\x59\x14\x24\xcb\xa7\x26\x0c\x2f\x6d\x7d\x00\x91\x70\x4b\x6f\x39\x3f\xb1\x47\x0b\xbf\xd6\xcb\x47\x43\x68\x99\x2f\xe1\xb1\x28\x46\xf3\xe8\xba\x58\x66\x84\x1e\x77\x67\x4a\xbe\x3a\xeb\xa0\x33\xfe\x17\xcf\x21\x26\xaf\x0f\x5f\xf6\xb3\xd2\xed\x3c\xf4\x7c\x1e\xa2\x33\x7a\x96\x9d\x49\x61\x3a\xe7\xdc\x25\x5c\xe2\xd4\x20\x72\x80\xbf\x09\xe6\xab\x68\x66\x96\xa6\x31\x7b\xec\xa3\xcc\x6d\x6c\x5a\x5b\xa0\x1a\x6c\xf3\x73\x34\xd3\x1f\x8b\xb9\xdf\x8a\x29\x65\xb4\x53\x17\x6d\x3f\x4c\xab\x78\x97\x66\xd2\x2d\xe1\xcc\x62\x99\x1a\x6f\x3d\x6d\xa7\x52\x76\xea\xaf\xca\x2a\x5e\x9e\x99\x2d\x4a\x7d\xe3\xa6\xef\xcd\xea\x13\xfa\x7f\xb8\xed\xc8\x6b\x1b\xdf\x19\x3a\xe8\x1b\x93\x84\xb6\xf3\xd1\x5a\x73\x8d\x84\x76\x6d\xbc\xd3\x03\x35\xed\x71\x5a\xfb\x64\xef\x76\x6f\x8f\x33\x4c\x4f\x0f\x18\xc1\xc5\xb6\x1e\x49\x2e\x7b\xff\x78\xf1\xd3\xcf\xef\x7e\xfe\xc7\xbf\xd0\x37\xa7\xa7\xe8\xdb\x45\x96\x06\x4b\xe0\xb4\x6f\xd1\x8f\xd2\x0e\xf9\xa1\xf1\x1e\x64\x38\x01\xae\x1a\x57\x66\x86\xd4\xe6\xb8\x16\x75\xbb\x29\x3a\xc5\x3e\x7f\xe2\x1d\xaa\x71\x6f\xb5\x55\x51\xbb\x59\x35\x45\x68\xad\xac\x4a\xac\x74\x6f\x6a\x83\x0d\x34\x6c\x53\x31\xe6\xf6\x44\xb2\x9a\xe3\x1e\x69\x6f\x78\x21\x8e\x73\xb2\x9d\xe7\x87\xac\x51\x76\x43\x92\xaf\x3b\x6a\x6e\x2f\xb7\x60\x09\x6f\xd5\x5d\x87\x5a\xa3\x76\xbb\x6d\xdf\xae\x26\xfd\x2f\xfc\x76\xb5\xd3\xeb\xc5\x57\x7e\x75\x63\x8e\x30\x0f\xe1\x80\x1e\x6e\x6d\x9f\xff\x71\xcf\x17\x7d\xb1\x14\x37\x48\xfe\xd8\x43\xbe\xa2\x29\xdf\x1e\xe1\x75\x7c\x37\x4b\xaf\x3c\xfb\xd9\xc9\xf8\x48\x94\x78\x8f\xa6\x61\xea\x2f\x73\xe3\xe5\x51\xba\x2c\x98\x67\xa4\x97\xa4\x09\xf1\xf6\x2c\xd5\xef\x25\x5d\xfb\x3e\x8e\xc5\xeb\x98\x79\x14\x04\x31\x31\xde\xab\xb0\x80\x15\xe5\xa7\x49\x3a\x8c\x08\xd2\x59\x0f\x75\x91\x5e\xea\x40\xde\xa3\x29\x94\x18\xf4\xce\xb0\xff\xfe\x3c\x4b\x97\x49\x60\x3f\x7e\x51\x5f\x7a\x3c\xc8\xd0\x2f\x19\x9e\x13\xd3\x53\x46\x7f\x36\x44\x34\xb2\x1b\xa1\xc5\x8b\xc5\x53\x9c\x29\x7d\xf5\xda\x37\x69\x1e\xd6\xc0\x8a\x68\xd0\x58\x04\xbd\xfb\x3b\x94\x57\x17\xe9\x32\x0e\xd0\x8c\xd0\x13\x35\x0a\xd0\xd9\xf7\x45\xf6\xc3\x99\xba\x70\xe5\x4b\xff\x02\xe1\x9c\xfb\x69\x3e\x23\x71\xfc\x65\x5f\x96\x1f\x62\x30\x3d\xbc\xee\xd1\x75\x1d\x32\x1f\x3d\xca\xd2\x2b\x74\x15\xc5\x31\xca\x2f\x70\x40\x50\x9a\xb0\xdd\x49\x0d\x0f\xdf\xac\x6a\x2e\x14\xeb\xb4\x72\x81\x2f\xf9\x63\x52\xbe\x35\x41\xbb\x86\x9a\x45\x6d\x5a\x2b\x15\x2c\xdc\x3b\xfb\xdf\x14\x33\x5e\x16\xe9\x1c\xc3\x26\x1e\xdf\xa0\x9c\x14\x28\xb8\x49\xf0\x3c\xf2\xa1\x71\xb6\x11\x53\x60\xe6\xbd\x9d\xb2\x67\x1c\x73\x5c\x90\x2c\xc2\x31\x27\x53\xb0\xca\x02\xc3\xfb\x88\xd6\x05\x84\x53\x9a\x41\x8a\x2b\x52\xf8\x6d\xe6\xba\x6d\x7a\x51\xbf\x4c\xaf\x84\x16\xc4\x67\xdb\x9e\x52\xf0\xbc\x93\x9c\x9f\x9f\x18\x9a\x8e\x3b\xeb\x74\x56\xaa\x8e\x74\x1f\xc5\x0a\x17\x45\x98\x59\xf9\x19\x7e\x89\x4f\x72\x76\xc4\x57\x51\x70\x67\x35\xd1\x5a\x41\x89\x3a\xc8\x63\x27\x63\x07\x79\x82\x02\x8f\x59\x4f\xe9\x50\x16\x3c\x8f\x3c\x1f\xf7\x5e\xc1\x72\x3c\xdf\x49\xa7\xa4\x4d\x19\x3d\x54\x56\xab\x43\x14\xbc\xd2\x37\x31\xbe\x61\xe4\x3d\x7a\xc4\xfe\x80\xc2\xd5\xf7\x79\x17\xba\x90\xc7\x29\xb7\x10\xb2\xe2\xcd\x50\xb2\xd9\x56\x18\xe1\xf7\x66\xa8\x24\x6b\x28\x6c\xa2\xa8\xdd\xd1\x97\xc0\x5d\xb5\x6d\x96\xdf\xde\x96\x35\x6e\x7c\x2d\x7f\x7a\x95\x5b\xe7\x1e\x9d\x41\x1a\x59\x77\xae\x3f\xbd\x1f\x67\xa0\x35\xd2\xab\x8f\x33\xab\x42\xa3\xe3\xc8\x9e\xce\x2f\x41\x82\xfc\x6c\xaa\xe0\x6d\x2b\x47\xf5\xf3\xe4\x4b\x93\xf0\x9a\x8e\x81\x38\x46\xeb\xf5\xc2\x8d\x50\xc9\x83\x78\x2d\x2d\xb3\xd8\x5e\x1d\x6a\x66\xbe\x24\x41\xbb\x6c\xae\x38\x59\x64\x84\xd3\xcb\x58\x2c\x3d\x89\xd2\xff\xac\x41\xf4\x5e\xa6\x57\xca\xd1\xe7\x65\x7a\xb5\x23\x3d\xf6\xe0\x41\x8f\xfd\xa0\xc7\xbe\x8b\x1e\xbb\x22\xcc\x11\xf3\x1d\x78\x8a\x73\xf2\xe0\x3e\x54\xab\x88\x86\x8a\x6a\xb4\xaa\xf8\x74\xe2\x80\xad\x6b\x44\x41\xc9\x8a\xf0\x20\xf9\xa7\xf4\x2a\xb9\xc2\x59\x50\xd5\x97\xc9\xd0\x0d\x5f\xd7\x96\x01\x78\xdf\x94\xeb\x7f\x72\xcd\xf5\x32\xcb\x41\x75\xbd\x48\x61\x28\x1d\xaa\xeb\x28\x89\xa3\x84\x74\x0d\xff\xa7\xff\x2e\xf3\x22\x0a\x6f\x9e\x31\x3d\x2e\xf7\x8e\xea\xe6\x05\xce\x94\xf2\x9b\x16\xfd\x24\x7c\x91\x1d\xca\x71\x97\x0f\x55\xa7\x4e\xb5\x5c\x1d\x52\x69\x91\x45\x73\x11\x0f\x5f\x53\x8e\x3b\x15\xea\x8d\xb1\xe8\x0a\x69\xec\x17\xd1\x25\x29\x29\xfc\xab\x91\x28\x12\xd0\x5f\x22\x3f\x4d\x4c\x9d\xfe\x02\xfb\x51\x71\x33\x95\x1e\xdd\x46\x5b\x14\xbc\xac\x89\x1f\x1c\x98\xe1\xa2\x78\xc4\xab\xb1\x2b\x88\x94\x2c\x94\x0d\xc9\xb0\x54\x45\x86\x13\xe1\xed\xc6\x53\x11\xc8\x92\x9c\x5f\x5e\x5b\x6f\x3c\x5e\x11\xde\xd8\xd1\xef\x61\x9a\xcd\xbd\xb7\x1d\xad\x0f\xc1\x32\xc3\x55\x68\xc4\xb7\x5e\x7e\x91\x66\x05\xc9\x44\x2f\xa5\x6b\xfe\x32\x27\xd9\x2b\xfe\xea\x88\xd9\x35\xac\xd0\x5f\x03\xc3\xee\x10\x90\xdc\x57\x23\x22\x09\x9a\x22\x2f\x4b\x0b\x4a\x70\x3f\x20\xe7\x6d\x33\x48\xd7\x8a\x1a\x83\x23\xbd\xce\x46\xc6\x82\x9f\x94\x9f\x7d\xe5\x05\x22\x21\x2f\xc2\xd6\x1b\x0f\xe7\x3e\xf8\x11\x91\xdc\x67\xde\x43\x77\xb5\x13\x58\xca\x4a\xf0\x69\xb7\x14\x95\x8c\x65\x61\x37\x88\x92\x73\xd4\xca\xa5\x69\x01\x62\x6c\x08\x95\x74\x4e\x67\x28\xa0\x0c\xbd\x9c\x27\x6d\xa5\xcd\x14\x1c\xdf\x58\x7f\x0a\x61\xc6\x44\xfa\x88\x9c\xd1\x85\x33\xa9\x40\x9d\x81\xc6\x9e\x24\x01\x09\x4c\x95\xe7\x83\xfd\xe2\x3e\xda\x2f\x78\xa4\x1d\xca\x1d\x48\x3e\x28\xd1\x5d\x0a\xe5\xbe\xbe\x16\xeb\x1b\xea\xef\x27\x68\xc6\x42\xe1\x32\xd5\x36\x63\xe2\xca\xa0\x24\x60\xec\x82\xcf\x8c\x57\x81\x36\xa6\x80\x2f\xe9\xb6\x5f\xa5\x59\x01\xfc\x68\x7b\x2e\xf2\x45\x21\xb4\xc3\xec\xe7\x76\xbd\x16\x57\x6a\xb8\xb5\xf7\x39\xd2\xa3\x91\x97\xdc\x55\x4b\xcd\xfa\x53\xe7\xca\xa8\xeb\xab\x65\xb3\x22\x88\xfe\xee\x1d\x1a\xf9\x80\xf3\x79\x70\x2b\x56\x29\x15\xf4\x0c\x7c\xb6\x16\x25\xb4\xc6\x1a\x94\xbc\x91\x9d\x7f\xdb\x41\xdf\x7c\x23\x7f\xb5\xd7\x55\xee\xea\xe2\xb2\xf9\x64\x6c\x2d\x3d\x6f\xc7\x50\x15\xe4\xec\x99\x3d\xf7\x63\x7b\x19\x2d\x16\xb1\x8c\x8d\xe4\xd6\x07\xb3\x5f\x2b\x22\x07\xfd\xff\xec\xfd\x7b\x73\x1b\x37\xb2\x00\x8a\xff\x6d\x55\xed\x77\x80\xf3\xdb\x9f\x49\xc6\x24\xf5\x70\xec\x64\xa5\xd5\xfa\xc8\xb6\xbc\xd6\x3d\xb6\xe5\x92\x94\x64\xf7\xfa\xa8\x22\x90\x04\xc5\x59\x0f\x07\x3c\x33\x43\x51\x8a\xad\xef\x7e\x0b\xdd\x78\x34\x30\x18\x3e\x24\xd9\x71\x4e\x92\xaa\x5d\x8b\x03\xa0\xf1\x6a\x34\x1a\xfd\xf4\x19\x6e\x1a\x88\x89\x0c\xc9\x5f\x7a\x30\x49\x27\x92\x66\x7b\xb2\x6e\x2d\x6f\x5e\xe2\x82\x09\xa5\x93\x37\x91\x50\xdf\x94\x52\xdd\xc4\xb6\xd4\x1e\xbf\x3b\x90\x56\xfd\x01\x0d\x4b\xbf\x62\x51\xac\x23\x95\xf5\x23\x8c\xa2\x51\x4c\x9c\xe8\xce\x50\x44\xa8\x68\x8e\x85\x15\x21\x12\x04\x46\xa0\x77\x27\x02\xb4\x03\x71\x82\x40\xfb\xe9\x33\x89\x03\xb7\xbe\xae\xac\x1c\x9f\xd3\x48\x72\x9a\xd7\xc9\x05\xb6\x7e\xf0\x6a\xcd\xb5\x8d\x9c\xe6\x4e\xc0\x72\x7c\x71\x7e\xd0\xaf\x7d\x6f\x6c\x3d\x0e\x2b\xce\x0d\xad\x8f\x55\xbe\x88\x34\x45\xf3\x7b\x9a\x3d\x65\x1d\x06\xfd\x64\x3c\xf5\xcc\x5a\x74\x70\x39\x7d\x45\x2c\x88\x09\x32\xe1\xe5\x08\x82\x82\x0c\x14\x3e\x6f\x6d\xb0\xcd\xad\xb4\xb3\xd9\xfd\x6e\x13\xfe\xef\xf5\xe6\x23\xb6\xf9\xa4\xbb\xf9\xfd\x4f\xdf\x8d\x3a\x5b\x17\x9b\x5b\xdd\xcd\xef\xd3\xce\xe3\xee\xe3\x1f\xd4\xff\xfd\xed\xf5\x77\xaa\xfa\x0f\xec\x07\xf6\x43\xe7\x87\x5f\x1b\x2e\xde\x60\x28\xc1\xb2\x2b\xe3\x15\x50\xa6\x72\x05\x46\xc1\x6c\x8a\xcf\x25\x90\x40\x4e\x6a\xe6\xfa\xb6\xdd\x59\x5b\x0b\xc7\x82\xf1\xc2\x14\xba\xb8\x93\x1d\x0a\xc6\xbc\xdf\xdd\xf1\x34\xd1\xec\x53\x43\xf7\xdd\x88\x52\x0e\xaf\x55\xc5\xcf\xf7\xf1\xa3\xaf\xf1\xc8\x9e\xf0\x5e\xad\xb8\xf4\x31\x08\xdd\x17\x74\xd4\xd0\xf3\x6f\x60\x2f\x22\x9b\x8e\x45\x8e\xda\x17\x70\x8f\x5e\x63\xec\x5c\x94\x7e\xa6\x31\x1b\x91\xcb\xec\x7a\x7d\x5a\x89\xa2\x65\x16\x18\x43\xb6\x79\x23\xaf\x1b\xf8\x93\xad\x65\x06\x7e\xc2\x7b\x9f\x69\xd0\xb1\x31\x7f\x09\xe2\x40\xb1\xed\xbb\x3f\xf5\x45\xff\x47\xb2\x3c\x25\xc5\x5b\x5e\x7b\x57\x7d\xff\xc8\xaf\x37\xef\xaa\x82\x0a\x7f\x26\x8f\xfa\x33\x79\xd4\xdd\x24\x8f\xfa\xf2\x4a\xd5\xcf\x93\xae\x8a\xe7\x59\x92\x9d\xd7\x81\xfd\x2e\xac\x38\x57\x63\x88\x55\xbe\xa8\xda\x13\x66\xb3\x7f\x21\xb2\xf2\x75\x52\x94\x22\x13\x75\x49\x97\xbe\x7b\x34\xa7\xcd\xc2\xf5\xf2\x6a\x93\x3d\xed\xc9\x69\xd6\xaf\x63\xd0\x1f\x6f\x55\x6a\xce\xeb\xc8\xd4\xf1\xc7\x79\xdc\xcf\x65\x9a\xf6\x78\x7e\x9c\xfc\x5a\xd7\xd1\x93\xc7\x8f\xe7\x34\x5a\x38\x39\xaf\xb6\x05\x84\x89\x9a\x93\x5f\x05\x16\xcf\xc9\x01\xf5\xe4\xb1\x43\xf3\x02\x2a\xd7\x56\xfc\x21\xa8\x38\x6f\x6c\x58\xe3\x8b\x2a\xb8\x4f\x78\xef\x20\x1b\x24\x7d\x5e\xca\x3a\x3c\x7a\xb4\xf9\x28\x5a\x7d\x41\x82\x30\x5b\x8f\x36\xc6\x95\x9d\x9b\xc9\xed\xc9\x93\xcd\xba\x16\x0b\x7a\xa4\x55\xbf\x36\x6d\xb7\x35\xc0\x98\xe3\x4c\xa6\x43\xfc\x7f\xcd\x0e\x60\x4b\xc2\xb3\x7b\x0f\xd8\x36\x07\xaf\x96\x1d\x60\x00\xf0\xb7\xd0\xf8\xcb\x0b\x91\x0f\x53\x39\xdb\x66\x8d\x51\x32\x18\x88\xcc\xea\x5e\x49\x8e\x2a\xe7\x94\xf6\xb3\xe8\x7d\x48\xca\x43\xdd\x08\x51\x13\x32\x61\x35\x4a\x39\xed\x8f\x1a\x6c\x7d\x9d\xed\x0d\x06\x2c\x39\x3c\x66\x63\xa9\x9e\xbb\xd3\x31\x2b\x4c\xb5\xae\xe7\x64\x96\x8a\xcb\xe7\x32\x2b\x79\x92\x51\x37\xb2\x20\xc4\x8a\xe7\x07\x66\xe0\x44\x9a\x2d\x17\xb5\x45\x1b\x2f\xf4\x52\xd9\xff\xe0\x59\x26\xe8\x64\x5a\x7c\x5a\x4a\xa7\x7c\x1e\x25\xa5\x38\x9e\xf0\x3e\xba\xdb\xcd\x72\x3e\xf1\x86\x33\x4c\x2e\xa9\x4f\x9a\x59\xc9\x7f\x55\x97\x52\xab\xb1\x1b\x95\x5c\x5d\x38\x23\x3f\xab\x34\x85\x83\xe5\x7e\x7a\x2f\x30\x8d\xa0\x1d\x57\xac\x2f\xfc\x08\x34\xf0\x0f\xaa\xd6\xf6\xa6\xa5\xdc\x5e\x42\x2b\x82\x3a\xfc\x5e\x2e\xf8\x07\x30\x04\x29\xba\x03\x39\xcb\x9a\x8d\x62\xdc\x68\xb5\x23\x3b\xe5\x7c\x11\xef\x32\x66\xcd\xc9\x48\xb0\xe7\xc7\xc7\x28\xe8\x07\x61\xa5\xc9\x90\xa1\x2f\x27\xad\x2f\xd4\xee\x2e\x44\x5b\xda\xd3\xa1\xf6\x6e\x19\x4a\x45\x3b\xfe\x14\x56\x65\x6d\xd6\xbe\x6b\x06\x98\x14\x20\xb1\x51\x4b\xc8\x92\x02\x04\x59\xa0\xd2\x1e\xca\x9c\xa5\x3c\x3f\x17\xec\x22\x11\x5e\xd2\x20\xbb\x7b\x4b\x6b\xd2\xd1\x81\x0c\xf6\xd6\x66\x3e\x89\xb8\x7f\xfd\xa9\x2d\xff\x1a\xb4\xe5\xb5\xd8\x73\x9e\xcb\x99\x75\xe8\x4b\x53\xb4\x87\xb8\xe0\x09\x1c\x7e\xcc\xef\xb7\x14\x56\x15\x63\xd5\x1a\xb0\xaa\xcd\xd2\xe4\x03\xf8\xba\x8d\x65\x2f\x49\x49\x8a\x9a\xe1\x34\x4d\x7f\x46\x9a\xb3\x12\x9a\xc5\x4f\x5b\x62\x39\x29\x7d\xd2\x5c\x47\xb6\xe8\x66\x67\xed\x85\x28\x45\x3e\x4e\x32\x9d\x07\x07\xcc\xa8\x2a\xbd\xc6\x7a\x43\x7b\xab\x79\xaa\x17\x85\x5e\xcd\xf7\x8b\x94\x33\xfd\x3e\x26\x8d\x5f\xa8\xc6\xd1\x76\x5c\xf3\xaa\xe2\x04\x4f\x97\xcc\x16\x05\xa2\x22\x9d\x64\x49\x63\xae\xc6\xc3\x09\xcf\xf9\x98\x7d\x44\x1c\xbd\xd6\x59\xa2\x4e\x6c\xbe\xa8\x42\x4e\xf3\xbe\xdd\x9b\xbe\x06\xef\xb7\xc5\x9c\x3e\xd7\xba\x93\x9f\x85\xe1\xf2\x14\x02\xea\xb5\x25\x69\x94\x14\xe5\x58\x0b\x33\x37\xdd\x30\x5d\x53\x3e\x55\xd0\x2f\xe4\x07\x51\xb8\xeb\xda\x60\x73\x22\x0a\x08\xee\xc5\xd3\x54\xce\x00\x9b\x47\x32\x4f\x7e\x55\x97\x39\x38\x3b\x9a\xfa\x08\xab\xa9\xb0\x7d\x96\x4c\xd4\x4b\xd4\x1c\x26\xd6\xe3\x04\x1f\xe8\xed\xb9\x34\x9e\x5b\x9c\x63\x3d\x31\xe2\x17\x09\x62\x9c\x77\xa3\x14\x7a\x9b\xd4\xe1\xe5\xb9\x00\x2f\xcc\x52\xea\x3a\x08\xe5\x4c\x71\x0a\x67\x78\xb4\x65\x96\x5e\xb1\x49\x2e\x0a\xb5\x3d\xea\xea\x84\x23\x29\x06\xc9\x74\x0c\xd3\x85\x8b\x20\x87\x33\x0b\x2c\x9b\x86\x20\x33\xdd\x9e\xa7\x33\x7e\x55\x78\x10\x4c\x95\xe1\x50\xd7\xc9\xc4\x85\xc8\xab\x55\xdc\x2a\xe0\xfb\x60\x0e\xc9\x33\x28\x0f\x1c\x0e\x6b\x80\xee\xb2\x21\x87\xc3\x46\x88\xb1\x11\x87\xe5\x52\xea\x24\x14\xd5\xdb\x97\x50\xdd\xe0\xad\xb2\xea\x4d\x14\xbc\x25\x6e\x78\x25\xf9\x50\xee\xe6\x6e\xf2\x60\xb6\x96\x27\x61\x67\x27\xbc\x47\x1c\xf2\x4b\x71\x59\x2e\x41\xb9\x1c\x5d\x6a\x33\x4b\x77\xda\xce\x60\x36\xdc\xaf\x9b\xe4\xea\xaa\xee\x38\x92\x0a\x3f\xb3\x1a\x38\x20\x6b\x0f\x5a\x32\x17\x75\xc9\x5d\xc9\x29\x1b\xc8\xac\x51\xb2\x19\x87\x24\x76\x61\xd5\x36\x54\xe9\xf3\x0c\x4f\x8f\x77\xa7\x95\x92\x9d\x81\x42\x9b\x2c\x4e\x98\xf4\x04\x7e\x1b\x53\x26\xf5\x4f\x60\x16\xa3\x7e\x1a\x55\x46\x32\x64\xcd\xfb\x5a\x58\x3f\x31\x32\xdb\xee\x88\x17\x87\xb3\xcc\x70\xb8\xa8\xa1\x0e\xe0\xb5\x5c\x1c\xf7\x72\xa4\x2e\xe8\x4c\xcc\xd8\x7e\x9e\xcb\xbc\xd9\x00\xb3\xae\xb3\x06\x7b\x68\x6b\xb3\x87\xac\x71\xc6\x46\xbc\x00\xc4\x66\xff\xd3\xe0\xd9\xd5\xff\x34\xda\xea\x20\xb0\x19\x2f\x58\x26\x4b\x55\xf7\x22\x19\xe0\x91\x39\xc3\x70\xbe\x64\xc0\x00\xa1\xcb\xde\xa9\x1b\xd6\xaa\x02\xc0\xa3\x3f\xbb\xd2\x56\x5e\x30\xef\x6e\x83\xc6\x59\x5e\x31\x92\xc4\x09\xef\x15\x6f\x44\xc9\xad\x23\x67\x02\xe9\x7a\xe6\x71\x03\xd1\xb4\xab\x85\x15\x17\xdd\xb4\xdd\x5b\x23\x79\xaa\x67\x77\xe7\x40\x58\x79\xc8\x6b\x90\xeb\xf9\x39\xcc\xf7\x48\xf4\xcb\x35\xc6\xd2\x95\x47\x9f\xe3\x8b\x77\xd9\x26\xf6\xa1\xa3\x35\x90\xb7\xc8\x7c\x56\x2c\x93\xee\xac\xf8\x9c\x39\xce\x8a\x3f\x4a\x62\xb3\x62\xc5\x6c\x66\xc5\x8d\x53\x98\x15\x25\x2f\x85\x3e\x89\x40\xaa\x3c\x89\x0f\xf5\x02\x40\x54\xdd\x70\x31\xc4\xb5\xd0\xc0\xa6\x18\xb7\x41\x0d\xe0\x74\x88\x2a\x04\xb4\xf9\x7f\x26\xcb\x52\x8e\x63\xed\x46\x98\x6e\x10\xef\x68\x62\x52\x64\x0a\xc1\x87\x20\x5a\x3a\x96\xd3\xcc\x79\x32\x6a\xb9\x82\x9e\xe1\xb9\x28\x9f\xcb\x6c\x00\xc2\x17\x9e\x6a\x1b\x07\xff\x28\x04\x99\xab\x54\xb3\xbf\x9a\xf4\x55\xbf\x2c\xcc\x5f\xe5\xaa\xc7\x92\x58\x05\x4f\xfd\xa0\x41\x50\x4a\x1b\x3a\xe6\x31\x68\xe3\x0a\xaa\xd5\x35\x97\x15\x6d\xa1\xcb\x68\xa3\x80\x23\xd2\x96\xc2\xb4\x69\x50\x23\x9a\xd0\x89\x54\x87\x6f\x3b\x7e\x76\xa3\xd8\xda\x7f\xbc\x36\x29\x3d\x22\xe5\x7a\xbc\x5a\x4f\x40\xd4\x2d\x64\x49\x9e\x2e\x32\x1e\x8d\xa8\x27\x88\x05\xa9\x9d\x86\xcc\x5e\x4b\xae\xc8\x3f\x49\x86\xe0\xb5\xc2\xd7\x46\x9b\x34\xb0\xef\x8f\xf9\x4d\x0c\x7a\xb7\xd8\x36\xa4\xb9\xf4\x56\x45\xa1\xf3\x71\xb0\x63\x64\x76\x0f\x1e\xb0\x66\xb0\xa1\x8a\xdd\x04\xde\x58\x11\x84\x48\x99\xcc\x1a\x2d\xdb\x45\xfd\xa2\x62\x1b\xad\x63\xa9\x8e\x62\xd1\xb2\x46\x10\xc6\xf3\xb2\x71\xc6\x7f\xf3\x92\x3b\xe8\xa4\xf8\x6c\x9b\x35\x14\x55\x69\x78\xab\x8b\xb9\x29\xe8\xe2\x3a\xa2\x10\x24\xa7\xb8\x48\x80\xb4\x6e\x53\x5a\xd6\xf5\xc9\x08\x49\x79\xe0\x24\x00\xf5\xe6\xd9\xcb\x9b\x86\x3b\x81\x65\x3b\xb6\x1d\xb0\x55\xad\x76\x78\xfc\x5b\xb5\x58\xb1\x68\xcb\x80\xf8\xfd\x96\x7b\x06\x3b\xa5\xb6\x0c\x37\x6f\xc1\x9e\x11\x5a\xbd\xec\xa6\x91\x26\xbf\x9b\x5d\xd3\x2c\x40\x64\xf3\x76\x2a\xb7\x10\xe1\x7b\xdd\xd5\x03\xec\x74\xdb\x6d\x82\x7f\x15\x95\xae\x89\xc9\x0d\x87\x85\xea\x45\x81\x80\x55\x15\x9a\xed\x49\x35\x53\xb0\xec\xd5\xa5\x2a\xa8\xee\x9f\xc9\x69\x36\x48\xb2\x73\xc7\x7f\x36\x49\x5e\xa5\xf5\x75\x86\x58\xc3\x38\x3c\x32\xf0\x19\x86\x39\xb5\x5d\x0b\x2d\x7c\xc3\xbb\xf1\x21\xe1\xa4\x2d\x9c\xd2\x67\xee\xdd\x36\x52\x26\xdf\x8e\x4b\xe1\xae\x1b\x24\xa9\xc4\x3c\x4e\x23\xe0\xf5\x6b\x9a\xbb\x3a\xf5\xad\x3d\x8e\x9f\xc2\x01\x14\x8a\x68\xa2\xd5\xca\xb9\x46\xee\x7b\x8b\x2c\xbf\xb7\x7d\xd1\xae\x17\x4c\x9c\x54\x0a\xdb\x23\xd7\xa5\xa0\x77\xd5\x9f\xb4\x48\xbf\x04\xa0\x2c\xc7\xb0\x5b\xfa\xbf\x6b\x97\xcf\xd3\x47\xa6\x25\x70\x49\xdd\x3d\xf8\xd6\xbe\xbf\xbb\x8b\xfc\x54\x88\x5e\xbf\x10\x9f\x21\xba\x7d\xfa\xeb\xfb\x8d\x53\xfb\xb7\x3d\x28\xba\x1b\xf3\x5d\xf3\xe9\xec\x1f\x6c\xc3\x4f\x55\xa6\x07\xaa\x20\x5b\x78\xd8\x07\x0c\xea\x44\x1e\x64\x03\x71\xf9\x1e\x7e\x9c\x9e\xd2\xbc\x60\x4b\x3b\x75\x80\xe1\xb9\x36\x32\x71\x54\xe2\x99\x94\xa9\xe0\x59\xb3\xe4\xbd\x56\x9b\x35\xde\xe8\x88\x65\x9d\x1f\x0f\xb6\x89\x3c\xd4\x3e\x9f\xe1\xed\x8c\xdf\xe0\xd5\x0d\x62\x70\x08\x82\xd8\x50\x38\xe0\xaf\xb0\x3e\x18\x7a\xf5\xd5\xf4\x9e\xaa\xff\xaf\x3b\x95\x96\xc8\xd8\xfd\x5c\xf3\xff\x35\xea\x52\x7b\xda\xb6\xed\x5f\x6d\xd3\xd1\xb6\xed\xf1\x3a\x20\x45\x25\xbe\x04\xed\xfb\xde\x7c\xa7\x0b\xac\x63\x72\x79\x14\x5d\x14\x68\x18\xa2\xa9\xad\xb6\x33\x71\x2b\x18\xe3\xa7\x11\xc0\x74\x32\xe0\xa5\x20\xca\x64\x5e\x8a\x26\x61\xac\x2d\x1d\xa2\xd5\xe9\x9d\x85\x2d\x5c\x52\xe2\xcd\x27\x4f\x82\x24\xcc\x01\x8f\x50\xc3\xde\xd7\x93\x4d\xfc\x3a\x96\x17\x42\x91\x69\x84\xd4\xec\xc4\x89\x53\x98\x2e\xb7\x3d\xf7\xe6\xbb\x9b\xa1\xdc\x64\x24\x11\xa6\xd4\x97\x00\x54\x33\x22\x5b\xce\x1b\x35\xeb\x36\x93\x71\xf0\xdd\x1e\x6b\x7d\x87\x8b\x12\x77\xc8\x4d\xa2\xf6\x11\x18\x3e\x03\x3b\x01\xe8\x2a\xd2\xc7\x13\x60\xbb\xb5\xb9\x05\x4a\x2e\x8b\x63\xfe\x66\x78\x8b\x38\x10\x69\xc9\x83\x5b\x9b\x3e\x8c\xba\xfe\xc3\x68\xa9\xfb\x7b\x3c\x4d\xcb\x64\x92\x26\xf0\xe8\x99\xc7\x94\x75\x36\xd9\x36\xdb\xdc\xf1\x1a\x67\xe2\xb2\xf4\x2d\xa9\xa2\x57\xe4\x43\x06\x23\x67\xdf\x92\xde\x3c\x76\xe0\x65\x72\x09\x72\x96\xfd\x01\xc9\x04\x08\xce\x8e\xd9\x85\xc8\xcb\xb9\x23\x53\xef\x97\xba\x0b\x75\x20\x4a\x61\x5e\x66\x20\xaf\x6e\xb6\x74\x4b\x71\x21\xf2\x42\xc4\xe6\x65\x8c\xb8\x2c\x87\xab\xee\x42\xef\x06\xd6\x83\xfa\x36\x98\x7e\xdd\x01\x41\x78\xc7\x5a\x22\x7c\x90\x95\xf2\xa7\x44\xcc\x96\x13\x0a\x6c\xd5\x4b\x05\x22\x4f\xe2\xad\x6a\xa6\x63\xbc\x36\x82\x5a\xf0\xd1\x7b\x23\x62\xb1\xcf\x38\x56\x98\x49\xc3\x40\x06\x7b\xe1\x65\x15\x2c\x83\xf6\x14\x66\xd7\x5e\x1c\xd1\xbb\x2a\x5a\x5f\xfd\xeb\x25\x29\xbe\x6f\x1a\x7c\xfa\xc4\xee\x1b\x80\x14\xa9\xf1\xc2\xaa\x70\x25\x90\xc2\x1c\x9b\xc2\x8e\xb2\xbf\xdb\xb1\xc2\x6f\x0a\x62\x7d\x1d\x78\x21\x06\x2e\xd6\x72\x68\x6c\x2b\x92\x82\xc9\x29\xd8\x1d\x5c\x24\x62\x36\xff\x20\x58\xd8\xde\x31\xf0\x47\xd0\x09\x46\xb0\x0a\x0e\xd6\xa1\x1e\x13\x69\x21\xbc\xc9\x02\xbb\xc6\xfe\xe1\xfa\x82\x0f\xc1\x74\xb1\xd2\xf2\xf3\xfd\x65\xd5\x09\x63\x07\x9d\x70\x14\xab\x4c\xf9\x97\xe5\x8e\x5b\x0d\xb5\x5d\xee\xbc\x3d\xaa\x3f\x6f\x75\x32\xb2\x47\xab\x0b\xc9\x1e\xd5\x4b\xc9\x22\xa7\xfa\xd1\x7c\x82\x0e\xc1\x39\x3d\x71\x8e\xdf\xf3\x7d\x90\xd8\x0c\x87\x8d\x0a\x6b\x0d\x5d\x68\x0e\x8d\x2c\x34\x19\x8d\xdd\x16\x7c\x2f\xec\x92\x36\xf4\x21\x11\x34\xa1\x6f\x2b\xaf\x09\x29\x20\xcc\x3a\xb1\x9c\xd5\xb8\x74\xbb\x07\x52\x48\x9e\x2a\x5d\x79\x42\x9b\x05\xb7\x9e\x37\xff\x7f\xf8\x73\x7b\xe8\x0d\x7b\xdb\xfb\xf5\x0f\x92\x5b\x9d\xf4\x4b\x18\xb6\xe5\x3a\x36\xc0\x1c\xf8\xc5\x43\x09\x1f\x42\xc1\x84\x15\x42\xd4\x0b\xb1\xc0\xf0\x32\x1c\x6a\xac\x09\x29\xf7\x9f\x55\x21\x9f\x56\x11\xb6\x07\x03\x6a\x57\x05\xee\x95\x01\x5c\xb7\xea\x5e\x28\x70\xee\xc5\x78\x62\xdc\x95\x97\xd1\x81\x10\xa5\x50\x0b\xfd\xb9\x8c\x36\x8a\x7a\x8c\x84\x0a\xa9\xf7\x38\x49\x48\x42\xed\x02\x50\xbe\x48\x06\x6f\x30\xe3\xff\x1a\x63\x55\xd5\x6d\xa5\x1e\xa1\x3d\xeb\xeb\x4c\x14\x69\x92\x95\x1d\x1d\xcd\xa0\xa3\x28\x5c\x27\x4d\x32\xc1\x40\xca\xb6\x9e\xc9\xce\x20\x19\x74\x40\xe5\xd0\x29\x44\xd9\x81\xe5\x5f\x33\xa4\xc2\x5f\x66\xab\x98\xc0\x60\x08\x76\xc5\xea\x9f\x45\x91\x57\xd1\x52\x0c\x2b\x24\x64\x65\x75\xcb\xf1\x23\xb4\x5e\x62\x3d\xb0\x62\x73\x92\x8b\x8b\x77\x46\x17\x2d\x2e\xa0\x2b\xaa\x8b\x9e\x3f\x20\xb7\x96\x27\xd6\x98\x67\x0c\x97\x0d\x84\xfb\x41\xa3\xa2\x01\xe3\x25\x9a\x6b\xf0\xb1\x60\x65\x32\x46\xfb\x30\x6c\xf7\xb3\x60\x99\xd0\xf6\x73\x23\xd1\xff\xc0\xf8\x39\x4f\xd0\x30\x09\x6f\x2d\x67\xf3\x65\x0c\x6b\xbb\xab\x2d\x2d\x65\x41\xdc\x21\xf2\xd5\x5f\x70\xc6\xec\xfc\x83\x42\x7a\xc0\xe6\xf0\x94\xcd\xf0\x4e\x9c\xb3\x51\x3f\x27\x69\xfa\x63\x36\x5e\x06\x75\x49\xd5\x66\xb0\x31\xf4\xb9\xde\xed\xf3\xac\x2f\xd2\xa6\x8f\x4b\xe1\x0b\x2a\xa8\x15\x19\x62\x6c\x3d\x6b\x86\x18\x5d\x7a\xe2\x82\xcc\x82\x57\x12\x79\x1f\xc5\x98\x64\x2c\x8e\x70\xc7\x3e\x63\x7c\x5b\xbe\x78\x05\x96\x78\x1e\x37\xac\x46\x96\xe2\x85\xb9\xb1\x13\x61\x73\x75\x54\xf1\x0a\x83\x8c\x9a\xb2\xdc\x45\xda\x99\x77\x0d\x45\xd8\x3a\x77\x03\xb3\x87\xae\x9c\xde\x46\x9d\xb0\x99\x11\x37\x46\xa0\x39\xba\x9e\x5a\x46\xb2\x96\x45\x06\x1b\x12\x33\xf2\xa8\xe0\x31\x09\xdd\x12\x42\xa5\xb2\x2f\xd9\x5c\x5f\x67\x6f\xf8\x15\xeb\x09\x36\xcb\x65\x76\xce\xa6\x59\x99\xa0\x3d\xea\x50\x66\xa5\xe2\x80\x53\xc9\x07\xda\xc8\x19\xfe\xd3\x9a\x68\xb3\xc6\x4f\xed\x78\x67\x46\xa4\x6a\x86\xe5\xed\x49\xd3\x1f\x18\xce\x46\x1d\xf9\x5a\x82\x80\x55\x3e\x7d\x0a\xa6\xa4\xfb\x99\xdf\x14\xea\xb4\x14\x02\xdc\x47\x23\x0b\xf0\x23\x75\x17\x5a\xa4\xa7\xe5\x6b\x23\xf0\x2a\x49\x72\x37\x51\xa8\xd8\x0f\x36\xe5\x7a\x31\x99\x42\x0b\xbb\x9a\x53\x8f\x85\x21\x13\xef\x82\xd2\x3f\x6a\x87\xdc\xc8\x96\x3e\xb5\xfe\xa9\x36\x6a\xf7\x38\xbf\x1f\x51\xa6\x2f\xd4\xa3\x1b\x8b\x76\x57\xd9\x7c\xa9\xd1\xe7\xd7\xaa\xf2\x8d\x40\xda\xa8\xc9\xe3\xf1\xb2\x58\x24\xf6\xd6\x2f\x35\xc1\xb7\xd4\x7f\xd6\x16\xda\xd5\xb3\x9f\x68\xbd\xaa\x29\xb3\x6b\x50\x2d\x8b\xb7\x04\xe3\xbf\x48\x2b\xf5\x9d\xb6\x30\x4a\x6e\x57\xd7\x7c\xa9\x7f\x7d\xad\x64\x9c\x70\x33\xbb\x84\xc5\x26\x09\xc6\x82\xd1\xd5\xb6\x9f\xa2\x2f\xba\x05\x97\xcf\x2f\xe4\xf6\xf1\xd6\x67\xb5\x80\x67\xbf\xd8\x88\x67\x01\x9e\x42\x88\x33\x8d\x8d\x61\x18\xb4\x30\xd1\xab\xa9\x6f\x91\x03\x6d\x2e\xc3\x8d\xf7\xbf\xaa\x89\xa3\x35\x2d\x6e\x1f\x64\xf8\xb0\x5b\xe4\x7e\xe9\x3d\x68\x60\xbc\x06\xba\xbc\x10\x53\xd3\xac\x21\xfc\x50\x8b\xa5\xfe\x80\x55\xb1\xd9\x65\xcd\x09\xbe\x49\x40\xb6\x30\xaa\x9a\x83\x66\xc4\xc8\xab\x05\x57\xab\xfa\x61\xf9\x19\x47\x1e\xad\x9a\x72\xe4\x11\x49\x12\x92\x5c\x8a\x41\x9b\xdd\x77\xab\xb8\x4a\x3a\x0f\x02\x88\x9c\x14\xe6\x01\xa3\xd5\x5b\xde\x6a\x94\xbc\x77\x50\x8a\xb1\x9d\xd5\x6a\xab\xe2\xf9\xb3\xad\x12\x05\xcf\xd2\x4b\x47\x4b\xd5\xbd\x44\x06\xdd\xda\x89\xde\xf7\x0b\xe3\xe2\xf8\x8e\xad\x31\xfb\x9c\x02\x6f\xab\xda\x6b\x35\x6a\x29\x30\x8f\x1c\xea\x50\xb8\xfe\x11\x21\xaa\x06\xca\x27\x57\x34\x62\x74\x33\xe0\x80\x9a\xa2\x8d\x4a\x89\x56\x8f\x06\xd3\x7f\x6e\xf4\x9f\x63\x3e\x69\xd2\xfb\xa4\x4d\x24\x61\xf0\x9d\xde\xe5\x20\x63\x0d\x41\x25\xc5\x4f\x3c\x4d\x06\x66\x29\xb1\x91\xff\xea\xd7\x7a\xc2\x50\x99\xe8\x73\x9d\xaa\xdd\x4f\x9a\xde\xc1\x8f\x2e\x21\x7a\x8a\xd7\x71\x13\x25\x92\x41\xb8\xc1\x7d\x9d\xac\x83\x74\x6a\x40\x05\xad\xe0\x44\xbb\x94\x47\xb4\xeb\xdd\x5d\xe6\xf3\xf8\x8c\x2e\xf0\xc3\x5d\xaa\x0d\xa8\x0b\x62\x94\xca\x4c\x78\xcb\xd1\xf6\x56\x83\x38\x1d\xcd\xbf\x60\xb7\xdd\x20\x15\x9e\xeb\xb9\x22\xf6\xe9\x07\xbd\x2a\xb0\xf5\xbd\x9b\xce\x26\x55\x08\x53\x39\x31\xcf\x78\x2c\x76\x9f\x12\xfb\xfb\xe8\xad\xa5\x79\x2e\xb7\x6c\x6e\x4f\x1d\xf7\xd6\x5a\xc2\xfa\x6e\x8e\x5d\x24\x79\xbe\x2f\x1f\x2b\x8a\xf9\x39\xba\xd9\x6d\xb3\x06\xb1\xc5\xb1\x21\x23\xa1\x15\x68\x80\xc8\x92\xe7\x10\x59\xa8\x31\x4b\xb2\x81\x9c\x35\xda\x4c\x66\xf8\x22\xde\xae\x3e\x92\x49\xa4\xe7\x15\xec\x11\x97\x1d\x2a\xd9\xc0\x60\x8d\x18\xab\x2e\x47\x48\xa7\x9d\x79\xec\xfc\xc1\x39\xbb\x3e\x8f\xd1\x5e\x76\x64\x91\xb1\x31\xef\xf0\x30\x9f\xc2\x56\xee\xe5\x76\x50\xb7\x4a\xb7\x3d\x8d\x70\x58\x3d\x17\x43\xef\x31\x31\x6c\x66\x72\x20\x5a\x95\x21\x58\xca\xa3\x45\xe4\xaa\xd6\x4e\x50\xe7\xba\x02\x5c\xaa\xa1\x40\x4e\xd3\xa4\x28\x1b\x61\xb1\xcc\x8c\x88\x33\x2a\x1c\x59\x9b\x03\x7b\x85\xf5\x8d\xae\x70\x80\x01\xf5\xf7\x7b\x65\x4e\x24\xb1\x96\xfb\xaf\xe5\xd7\x22\x8b\x1f\x23\x5b\x6b\x35\x0d\x97\xb2\x44\xb4\xf5\x8d\x6d\x1c\x95\x1d\x61\xea\x38\x4d\x3f\xd4\x4a\xee\xac\x5d\x37\x2b\x57\x21\x75\x22\x00\x9b\xf7\x48\x78\x49\xe7\x8e\x6c\xed\xbd\x29\x19\x37\xdf\x42\xc7\x4b\xeb\xa0\x14\x38\xe1\xb9\xdc\x37\x94\xeb\xdd\xd6\x86\x7f\xed\x98\x8f\x58\x25\x18\x06\x8d\x87\x47\x28\xb6\x75\x7f\x5a\xbb\xde\xb9\x61\xb8\x4b\x55\x7c\x82\xce\x51\x10\x1e\xcd\x8f\x7f\x59\x98\xa8\x97\xc5\x67\x8a\x75\xf9\xf8\x6b\x0c\x9c\xb7\x5c\x54\x9a\x27\xf1\xfa\x73\x03\x4a\xd2\x8a\x5f\x24\x6c\x49\x15\x29\x7e\x89\xdb\xa7\x57\x63\x1a\x3e\xf9\x2d\xb7\xe6\x5e\x7c\x67\xfe\x0c\x6c\xf6\x67\x60\xb3\x5b\x05\x36\xfb\x7d\xe6\xfa\xff\x4d\xe3\x80\x95\xa3\x5c\x96\xe5\x9c\xd0\x3e\x5b\x95\xaa\xf3\x7a\x32\x75\xbe\x58\xd4\x26\x1b\x0b\xe8\xe3\xda\x3d\x12\x73\x66\x72\xd9\x68\xaf\xdd\x33\xa9\x63\xdc\x17\x12\x33\x87\xf7\x0a\x99\x4e\x41\xe9\x74\xaf\x94\x93\x6d\xd6\xe8\x6c\x6e\xa8\xff\xb0\x26\x89\x12\xa4\x43\xd2\xb4\xd7\xee\x8d\x0b\x1b\x07\x08\xb9\xd1\x86\x65\xe4\x1b\xd6\x2f\x32\xbc\x60\x88\x79\xa4\xe7\x1a\x79\xaf\xce\x33\xd2\x03\xd0\x66\xbf\x78\x7c\xcd\x3d\x0b\xce\xab\x06\x72\xf2\x7b\xf7\x88\x8b\xa4\xfe\x11\x73\x90\xbc\x77\x6f\x19\xf7\xc8\xca\x7d\x76\xef\xde\x67\xf2\x92\xbc\x77\xef\xde\x7c\x17\xc9\x7b\xf7\xae\x55\xf7\x9f\xc9\x3d\xd2\x9b\xe8\x2a\x7e\x92\xfe\x0a\xdd\xd8\x61\x52\x94\x6f\x04\x2f\xa6\x79\x8d\x1f\xe1\xbd\x7b\xf7\xa8\x89\xa1\x67\x4a\x0b\xdf\x21\x9f\xba\x1c\x0e\x0b\x51\xea\x92\x0e\x2d\x41\x9d\x9d\x31\xb3\xad\x42\xf3\x4c\x78\x28\x30\xa3\xe6\xab\xc0\xd2\xb6\x3d\xf7\xee\xcd\x35\xe8\xb6\xf4\xa2\xce\x7a\xf6\x1e\xa2\x28\x55\x0d\x10\xfb\x56\xf3\x59\xf1\x17\xba\xe6\x24\x17\x17\xc1\xdc\x2b\x66\xc4\xa4\xaa\x3f\x31\x7f\xbe\x74\x21\xfc\xf5\x6f\xb6\xa0\x2c\x19\xb2\x26\xe9\x8f\xd8\xc6\x04\xbb\xf0\xe9\x13\xe9\x2c\x52\x0d\xcd\xaa\x71\xba\xf7\xcc\xa4\x9a\x1f\x43\xc3\xe8\xed\x38\xf8\x36\xf3\x01\x55\xaa\x61\xbf\xd7\x38\xe8\x6b\xdc\x13\x63\x68\x7c\x2b\x83\x19\x38\x72\x73\xcc\x65\x02\x2a\xf5\x5e\x4d\xb0\xde\x6a\xe6\xde\xbd\xe5\x6c\x66\x2c\x4e\xbc\x96\x7c\xe0\x69\xed\xba\xf8\x4d\xa3\x83\xda\x1e\xfc\x60\x96\x76\xce\x5e\xde\xc3\x9a\xb1\x45\x5f\x6e\xcd\x17\x2d\xf9\xda\x3d\xd0\x6c\x56\x16\xc0\x37\xbf\x98\xb3\x06\xa1\xf1\x85\x99\x4f\x8d\xe5\x45\xb5\x4b\xab\x4a\xbd\x77\x6f\x7d\x9d\x3d\x97\x79\x2e\x8a\x89\xcc\x06\x05\x2b\x25\xdb\xdc\x60\xc3\x1c\x82\x99\xf2\x92\x3d\xd9\x60\xaf\x7e\xed\xae\x45\x46\x43\x34\xae\xf7\xcc\xed\xe1\xab\x55\xab\x27\xb6\xfe\xc0\x2e\x27\xec\x53\xbb\xa3\xc5\x18\xea\xcf\x6c\x9a\xa6\x6d\xef\xa4\x2c\xe9\x97\x7b\x77\x82\x3b\xed\x2b\x83\xa3\x58\x10\x84\x1f\x06\xae\xf1\xef\x9e\x16\x50\xe9\xd7\x37\x7e\xab\x97\x42\x41\xf1\x3d\x2d\x7b\xca\x30\xf6\x23\xca\x9e\xa0\xe0\x1a\xfe\xb9\x6e\xa9\x7f\xec\x86\x9f\xaa\xbf\xf4\xba\x7a\xc7\xcf\x49\x43\x7c\x21\x88\x7f\xb3\x55\xa4\x21\xf7\x8c\xaf\xb2\x9e\xb0\x13\x26\xab\x0f\x71\xb1\x43\xd0\x6f\xf8\xae\xfc\xfe\x0e\xdf\x95\x7f\x59\xf1\x5d\x49\x1f\xfc\xea\x78\xfe\x65\x6d\x7d\x9d\x3d\x83\xd4\x5a\x32\x63\xa3\xb2\x9c\x14\xdb\xeb\xeb\xe7\x49\x39\x9a\xf6\xba\x7d\x39\x5e\x87\x15\xeb\xf4\xa4\x2c\x8b\x32\xe7\x93\xf5\x81\x1c\x77\x46\x22\x9d\x88\xbc\x58\xef\xa5\xb2\xb7\x3e\xe6\x45\x29\xf2\xf5\x22\xef\xaf\x4f\xcb\x24\x5d\x4f\xb2\x17\x87\x6f\xba\xff\x29\xfe\xb2\x86\x5a\xa9\x17\x87\x6f\xd8\x2e\xbb\x7f\xbf\xa9\xe3\xfe\x20\x8a\xa1\x31\xae\xf5\x86\x02\xe7\x05\x2c\xe9\x0e\x64\x1f\x38\x9b\xc8\x27\x1f\xb7\xd4\xe8\x41\xdc\xce\xfb\x23\x31\x50\x0f\x86\x9d\xbf\x10\x8e\xba\x10\xc4\xdf\x01\x7a\x6f\xb1\x8f\x7f\x01\x79\x99\x6b\xa1\x8e\x27\x36\xbc\xfe\x8b\xdd\x49\xbf\xa9\xba\x1d\xbd\x0f\xc1\xa2\x95\x23\xc1\xfe\xf3\xbf\x53\x91\x5f\xb1\x09\x84\x61\x89\x2d\xa3\x2c\x47\xb9\x10\xeb\x58\xaf\x9b\x97\xa9\xf6\xc0\xe9\xa8\xde\xc9\xa8\x43\x3f\x8d\xa6\x1d\xb3\xa2\xe6\x6e\xdc\xf6\x33\x23\xfe\xb0\x74\x1d\x40\x2c\xe8\x5a\xde\xc7\x8d\xf8\xf4\x89\xdd\x0f\xd7\xb4\x27\x07\x57\x31\x70\x8d\x24\x1b\xe8\x30\x46\xbc\x14\x0d\x1f\xa6\x5a\xf7\xc1\x74\x3c\x56\x4c\xeb\xdc\x4d\x42\x02\xd0\xd2\xad\xa1\x49\x17\x73\xfc\x81\x56\xae\x19\xb4\x3a\x11\x97\xe5\x5b\x39\x10\xcd\xc6\xde\xb3\xe7\x2f\x1a\x2d\xbf\xe1\x20\x51\xef\x3e\xb0\xc8\xf2\xbe\x03\x3d\xe9\x0e\x65\x56\xea\xf7\x44\x63\xf3\xbb\xc9\x65\xac\xce\x4c\xf3\x3b\x8d\x9a\xf2\x91\x61\x9d\x1a\x9b\xf1\x0a\xe6\x75\xa4\xaa\xd8\xe7\x51\xa4\x5e\x09\xc6\x13\xf8\x5e\x8a\x43\x32\xaf\x27\x55\x4d\x3f\x9f\x4c\x2d\xba\x35\xfe\x6a\xa9\xf6\x66\x4d\x3c\x2c\xb6\x8e\x3c\x3b\x6e\xd3\x75\x6f\x9e\xf9\xb4\xb7\xd3\x3e\x04\x93\xec\xc2\xdf\x69\x70\xa3\x20\x6d\x2a\x40\x77\xd9\xe6\xce\x5f\x3c\xad\x69\xb5\xca\xee\x6e\xd0\x73\xb5\xf7\x4c\x9c\x63\x7c\x56\x02\xec\xda\x1b\x89\xbf\x2c\xb9\x18\xcb\x0b\x11\x59\x96\xd8\x69\x20\x87\x3b\x3c\x61\x6c\xb7\x72\xe8\x6a\xa8\x62\x51\xf2\xfe\x07\xb3\x6b\x70\xaa\xf9\xfa\xd6\x77\x8f\xfe\xf6\xdd\xa3\xef\x9f\x90\x23\x5c\x63\x9a\xdf\xd4\x61\x12\x7d\xb7\x73\x77\x9a\xbc\x15\x35\x21\x15\x89\x75\x20\xd6\x5c\x5f\x67\xef\x44\x3e\x94\xf9\xd8\x04\xfa\xeb\x4f\x53\xc8\xa3\x5a\x60\xc4\x39\x88\x51\xe7\x2c\x18\x93\x82\xe5\x25\x44\xcb\xe4\xe0\x1d\x3b\x16\x45\x91\x64\xe7\x6c\x3a\xc1\x9c\xa0\x65\xce\x7a\x1c\x03\xde\x11\xbc\xb1\xcd\xef\x1b\x03\xc8\x18\x81\xa8\x0c\x8e\xd0\x86\x32\xbe\xb2\xcd\x16\x41\xcf\xd2\x46\x74\xf3\x29\x4d\xac\xaf\xb7\x18\x62\xe9\x2d\x7f\xeb\xf7\x55\xcc\x92\xb2\x3f\x62\x3e\x79\x47\xe4\x2a\x04\x41\xaa\x6d\x1f\xf5\x34\x54\x7f\x99\xcd\x5b\xce\x7c\xf5\xdd\x0a\x2a\xb3\x75\xbd\x98\xa3\x77\xdb\x4e\x3a\xb5\x4b\x1a\x5b\x71\x82\xd3\x35\x28\xc7\x76\xeb\x90\x91\x5e\x94\xc5\x22\x7c\x75\xbd\xc6\x70\xf7\xab\xc0\xc8\xea\x79\xb1\xa1\x5d\x82\x1d\xd3\x4e\x71\x9f\x1b\x61\xef\x04\x4b\xa3\xb3\x8a\x23\x4e\x0c\xc9\x6a\x70\x56\xfd\x07\x41\x9c\x97\xc5\xe3\xb9\xc3\xb8\x11\x56\xd7\x0d\xc3\x08\x30\x97\xe8\x7f\x29\x98\xd7\xde\x29\xa9\x41\x74\x05\xac\xf6\x94\x54\x98\xf7\x1f\x6e\xc5\xbc\x43\x9c\x10\x5e\xa7\xb7\x79\xf2\xf8\x6f\x2d\x22\x13\xd6\x11\x35\xc1\x8c\xbf\xcd\xec\x71\x2c\x65\x9b\xc9\x09\x1c\xb0\xb6\x8d\xf4\xea\xb2\xd7\x42\x7e\x75\xb6\xcb\x1e\x66\x62\xc6\x5e\xa0\x93\x8c\xfa\x3e\xcc\xe5\xd8\xed\xdb\x7b\x05\xf4\xd4\xa4\x73\x85\x47\x73\x0a\xe6\x41\x18\xcb\x4b\x17\x08\x85\x16\xbb\x2c\xc9\x0e\xa7\xe5\x71\x92\x19\x50\x26\x75\x37\xdb\x65\x8f\x1e\x6f\xa8\xca\xe6\x74\xc8\xa1\x19\x5a\x10\xaa\xd3\x18\x15\x98\xf1\xb2\x5d\x53\x71\x0d\xd5\xd7\xc8\x66\x40\x1d\x0b\xc1\xfe\xf5\xe9\x13\xfb\x88\x16\xd2\x7a\x44\xba\xa0\x0b\x3f\x3f\x7d\x82\xcf\x9a\xc1\xb2\x43\x33\x75\xec\xa7\x4f\x9f\x6c\x71\x38\x16\xfb\xe7\xa7\x4f\xbe\x64\xf1\xda\x38\x45\xa9\x19\xe2\x12\xee\xee\xb2\x52\x06\xf9\xb2\x4c\x7b\x63\x7d\x40\x22\x46\x6a\x3e\x98\xf1\x34\x17\x7c\x70\x05\xfe\x37\xf0\xdc\x36\xfb\x6b\x38\xca\x86\xb5\x07\x08\xf7\x08\xf5\xfd\xd7\x5e\xd4\x3f\xdc\x33\xe7\xc0\x49\xf7\x10\x74\x86\x61\x03\x9e\x25\x63\x5e\x0a\xd6\x2c\x93\xb1\x28\x4a\x3e\x9e\xd0\x40\x99\xb6\xb9\xb3\xfe\xa8\x99\x9a\x37\x39\xed\x94\x66\x5b\x37\x88\x4d\x43\x75\x16\xc6\x6e\xe1\xda\x05\x27\xcc\x80\xff\xa5\xb8\xaa\xc9\x71\x02\xf6\x95\x6f\x78\x39\xea\x8e\x93\xac\xb9\xd9\x66\xcd\xa6\xaa\xdc\x41\x04\x6f\xb1\x75\xbb\x99\xad\x96\x6d\x26\x80\x67\xdb\x85\x7f\x61\xa2\xad\xb5\xb5\xca\x58\xd8\x2e\x6b\x62\xc5\x6f\x59\xb3\x94\xac\x03\x67\xa3\xd5\x62\x0f\xe1\x0f\x6c\x01\x03\xf8\x3b\xdb\x64\x4f\xd5\x81\x6d\xea\xd5\x6b\xb1\x6d\xf8\x19\x73\xa0\xb5\x0b\x05\x92\x02\xbf\x4b\x3d\x6f\xbb\x8d\x14\x24\x49\x25\x8c\xeb\xb8\x76\x4d\x88\x80\x3d\x7b\xac\x99\x79\x69\x1b\xba\x8f\xd5\xf0\x37\x59\x07\x17\xa9\x2f\x8b\x26\xfc\xf1\xee\x80\x7d\xcb\xd4\x9a\x5c\xaf\xad\x21\x5d\xea\x6a\xb2\xa4\xad\x3b\x40\x91\xe3\x26\xb0\x0c\x5d\x09\x18\x90\xa6\x7e\xaf\x9c\xc8\x49\x63\x21\x61\x5a\xd3\xf6\x3b\xe8\x74\x72\x27\xfd\xbe\x86\xf0\x65\xcb\x74\xac\x16\x21\xa4\xe0\x7f\xbb\x35\x05\x3f\x4f\x65\x8f\xd7\x66\xc1\x79\xb2\xd1\xb2\xd9\x2c\xcf\xd4\x77\x51\x94\x7b\xb0\xd7\x89\xcc\x5e\xe6\x7c\x2c\x9a\xad\x33\xc8\x64\x89\xd7\x01\xd6\x50\xbc\x1a\x80\xed\x46\x9b\xac\x31\x45\x9a\x74\x8d\x19\xa4\xdb\x38\x5a\x58\x6f\x2c\x7f\x9d\x53\x69\x68\x82\x84\xaf\x19\x65\x80\x77\x12\xed\x4e\x99\x7a\xac\x39\xcc\xdc\x35\xd3\x9f\xe6\x79\xe4\x96\x19\x17\xf6\xd4\xf2\xcb\xe6\x46\x9b\x6d\x3e\x61\x1d\xd6\x84\xda\x1d\xe8\x04\x4e\xab\x9e\x38\x5e\xbd\x27\xc9\x58\xc8\x69\xd9\x1c\x66\x6d\x36\x2e\x5a\x0e\xc5\xf5\x98\x54\xe3\xb6\xaa\xbe\xe6\xd2\x84\x9e\xe1\x51\x99\xb3\xae\x9a\x40\xda\x65\x8d\x35\x88\xac\xea\xf3\x45\xd5\xc6\xf2\xd7\xfa\x3a\xfd\x54\xf0\x5c\xcf\x67\x6d\x4d\x11\xd6\x97\x7a\x19\x49\x08\xe2\x5e\x92\x0d\xcc\x51\x36\x7b\xaf\xff\x82\xb2\x26\xf6\xa4\x16\xc2\x4e\x02\xff\xf0\x8b\x9d\x75\x0b\xdb\x65\x95\xa3\xae\x21\x5a\xee\x27\x00\x55\x39\x17\x4f\x36\x6e\x75\x2e\x96\x4a\xa3\xa8\x47\xce\x3e\xaa\x0d\x9a\x25\xd9\x0e\xae\x51\x55\x32\xf8\x8d\x95\x0c\x7e\x63\x28\xc1\x2c\xc9\xac\xac\x69\x67\x8d\x86\x77\xc0\xd6\xfa\x50\xce\x6d\x8d\x75\x62\xad\x0b\x91\x0e\x2b\x6d\x69\x53\x55\xc1\x36\xa4\x05\x1f\xaf\x77\xa2\xa4\x16\xa7\x77\x4b\x93\xb1\xef\x36\x23\x36\x63\x4f\x36\xff\x8f\xa7\xbf\xfc\xf2\xc9\xf7\xfe\x38\x09\x37\x73\x31\x7c\xb4\xa3\x1e\xed\x6c\x26\xf8\x87\xcf\x69\x14\xf4\x25\xf2\x03\x7e\x89\xac\x71\x68\x81\xfa\x0c\x1f\x1e\x51\xec\x78\x1c\xa9\x3b\xaf\x13\x57\xcb\x36\xfc\x6f\x71\xd5\x93\x3c\x1f\x40\x9a\xe5\x39\xc9\xf8\x1e\x11\xdb\xb7\x4a\x9b\x79\x7d\x56\x2a\xc7\xc1\x98\x80\xa7\xf1\xbe\x37\xe7\x34\x5a\xba\xf3\x23\x1d\xef\xe6\x0b\x1b\x3f\xdd\x51\x66\xb4\x7e\x60\x78\x1c\xa4\x0b\xdb\x60\x1b\xac\xc1\x1e\x6a\x4f\xf2\x62\xc2\xfb\x49\x76\xde\x9d\x66\x49\xc9\xbe\x65\xdf\xb3\x87\xac\x31\x31\xd9\xcb\xee\x2e\x25\xd6\xef\x31\x25\xd2\xcf\xa3\xa4\x3f\x22\x62\xc1\x62\x24\xa7\x29\x8e\xdc\x04\x5d\x42\xf3\x72\xf1\xd4\xf6\x44\x82\xe6\x2e\x48\x95\x81\x01\x8e\x4d\xd4\xdc\xd3\x56\x6d\x6a\x1a\x9b\x88\x07\x16\x4f\xf4\xa7\xa5\x80\xf8\x6b\x7a\x0c\x93\x5c\x14\x64\xb9\x5c\xd0\xdd\xfa\x2c\x38\x3e\xfc\xe3\xca\xb4\x7a\xc2\x26\x6c\x91\x39\x64\x69\x63\x7d\x99\x15\xd3\xb1\x97\xef\x09\x92\x5f\xd8\x98\xbd\xf5\x59\x6c\x2c\xfe\x2c\x95\x11\x3f\x42\x32\x9c\x19\x80\x7a\xb6\xd2\x6b\x62\x6b\x45\x70\x48\x05\xaa\xf0\x96\x4e\xec\x4f\x33\x1a\x50\xe3\x7f\x1a\xc7\xc2\x3a\xbb\xc2\x11\x8e\x3a\x8d\x87\x6e\xe0\x35\x5e\xe0\x24\xca\x83\xae\x62\xbf\x98\x2a\x7a\xbb\x6d\x05\xfd\xdb\x14\xeb\xfd\x71\xe1\x32\xf0\xb7\x6d\xbd\x9a\xbb\xb2\xf5\x56\xa6\xee\xc8\xd4\xbf\xd8\x0e\x4f\xbb\x16\xab\xa1\x80\x47\x30\x76\x6b\x7d\x82\xef\xca\x1f\x58\x0b\xbd\xee\x6b\xf8\x61\x86\xf8\xa5\xac\x3e\x6a\x1c\xcf\x5c\xac\xa1\xe5\xdd\xdd\xe8\xdd\x4a\xbd\x41\x56\xf4\x7a\x6b\xbb\x43\x6c\xb6\x13\x3c\x80\xb2\x81\xa2\xdf\x9d\xcd\xd0\x2b\x2e\x08\x06\x82\xf1\xb8\x9f\xe2\x71\xdb\xc6\x73\xb2\x06\x7e\x38\xd7\xe0\x4f\x43\xf1\xb6\x4b\xcd\xa2\x97\x0e\x94\x0b\x1c\x9a\xcd\xd2\xb2\x0c\x79\xf6\x12\x8f\x2c\x74\x8b\x56\xe0\x3d\xa7\xf7\xb9\xb0\x17\xbb\x59\x53\x78\x1a\x55\xe7\x5e\x03\x4b\x43\xa4\xf8\x7e\x73\x72\xbf\x74\x77\xee\x44\xcd\x21\xee\x4b\x43\x33\x87\xb2\x16\x9a\x22\xde\xad\x36\xf2\xe3\x2d\xc5\xc0\x5c\xef\x54\xf0\x27\xe2\x9a\x65\xef\x04\x7c\x4e\xed\xc4\x1c\x5c\x96\xf1\x7a\xf2\x9c\x9c\xbc\xc8\x03\xda\xdf\x29\xc8\x2f\xfc\x19\x5c\x9f\x9e\x6c\x7d\x5d\xae\x4f\x8b\xdf\xa5\x1f\xc4\x55\xdd\x3b\xe3\x91\xf3\x3b\x50\xb5\xe6\x31\xc3\xaa\xfc\xeb\x7c\x1b\xfe\xe9\x5c\xf4\xa7\x73\xd1\xad\x9c\x8b\x7e\x33\xc1\xcd\xa3\x65\x05\x37\xdf\x2d\x16\xdc\x3c\xfa\xbc\xbe\x52\x7f\x8a\x45\x56\x10\x8b\x68\x4b\xd3\xba\x95\x72\xdb\x7b\xd0\xaf\xcd\xb1\xff\x37\xbf\xd6\xbc\x11\xa8\xf2\xaf\x2d\x99\xbe\xd1\x1f\xdf\x36\xed\xbd\x81\xb3\x20\x9d\xfc\xfa\x3a\xfb\x2f\x7d\xb0\xc5\xc0\x1a\x4a\x33\xb7\x37\x77\x2b\x56\xa1\xbc\xfb\x77\xb1\x74\xe3\xe5\xd5\x44\x9e\xe7\x7c\x32\xba\xd2\xe1\xc6\x16\xc6\xd0\xd1\xcf\xaf\x31\xbf\xd4\x9e\x09\x5b\x4f\xbe\x33\x6f\xb2\x79\xf9\xe0\xc7\x49\xa6\x1b\x7c\xbf\x65\xeb\xf3\xc1\x00\x12\xd9\xdb\xf4\x20\xa3\x4a\xf2\x7b\x2d\xf9\x81\x6c\xe7\xf6\xed\x57\xc9\x9f\x8f\x32\x9f\x58\x12\xf5\xe9\xa4\xd9\x18\x0f\x68\x0a\x75\x37\x92\xcd\x27\x1b\x5a\x73\xac\x9f\x23\x6a\xd5\x5e\xab\x0d\x57\xa8\xea\xa4\x52\x66\x54\xdf\x6f\xe9\x7e\x6c\xe5\x3d\xf0\xc9\xaf\xc8\xaf\x70\x18\x13\x9e\x8a\xb2\x14\x10\xae\xab\x5b\x88\xbe\xcc\x06\x3c\xbf\x8a\x83\x38\xb6\x31\x56\xe6\x82\xb2\x50\xba\x7b\x5b\x1b\x1b\x71\x50\x2f\x30\xc8\xeb\x22\x50\x30\x2a\x1d\x10\x76\x10\x42\x7a\x87\x29\x50\x6f\x35\x31\x0d\x63\xc9\x99\xe9\xa4\xab\xef\x1f\x6f\x6c\x9c\xd6\x40\xba\x8b\x89\x1d\xe0\xe1\x5b\x2c\x71\x94\x13\xde\x4f\xca\xab\x6d\xb6\xd1\xfd\xbe\x06\x48\x75\x66\xb6\xd1\x66\x4d\x93\xea\x14\x48\x3f\xdf\xd1\x46\x24\x24\xc4\x47\x72\x14\xfe\x99\x2b\xb4\xf7\xc0\xcf\x72\x3e\x99\x88\xdc\xd5\x1b\x24\xc5\x24\xe5\x57\x30\xa9\x34\xc9\x44\x47\x35\xb4\x13\xe3\x69\x72\x9e\x1d\x94\x62\x5c\x6c\x9b\x40\x6d\xb6\xec\x3f\xd3\xa2\x4c\x86\x57\xcf\x31\xf3\x7d\xb5\x9c\xf8\xb7\xfe\xff\x3d\xd9\xec\x0b\x27\x3b\x6c\xf4\x65\x3a\x1d\xdb\x23\x09\xff\xa4\xea\x4c\xd9\x10\x20\xdb\x4b\xd2\x18\x4d\x1e\x4e\xe4\x64\x9b\x3d\x09\x68\x86\x49\xb5\x11\x7e\xc7\x74\x4a\x9b\x21\x89\x39\xc2\x03\xbc\xb9\xb5\x0a\xa1\xf0\x40\x46\x45\xce\x8f\xe2\xdd\xc4\xeb\x6a\x52\x43\x56\x64\xd9\x85\x30\xa6\xf7\xdb\x55\xaa\x3d\xb9\x3c\x91\x47\x62\xdc\xac\x14\x98\x36\xd6\x64\x68\x36\x4a\x4a\x71\x3c\xe1\x7d\x01\xe4\x34\x1f\xf3\x74\x25\xb2\x79\x9b\x41\xb0\x0e\xdb\x6c\x55\xe7\xff\x33\x60\xee\x60\xe1\x32\x44\x47\x38\x90\xb3\xec\x8e\xc7\xb8\x45\x0d\x89\xfe\xb8\xca\x83\x83\x21\x3b\x53\xef\xf6\xb3\xb6\x4d\x01\x0f\xf9\xd0\x7b\x82\x19\xb2\xda\x25\x5a\x03\x43\xd1\x96\xce\x06\x1f\x8e\x92\x90\xba\xa5\x61\x40\x10\x6e\xc5\x95\x1a\xf3\x55\x35\x6a\xce\x70\x3a\x0c\x13\x5f\x43\x56\xab\x36\x4b\x4a\x3b\x7c\x48\xac\xce\x0b\xc6\x31\xec\x6e\x9a\x9c\xf3\x72\x9a\x13\xa5\x40\xd2\x5f\xa4\xfe\x00\xb3\xe5\xf7\xf3\x57\x73\xc5\x24\xec\x96\x07\xbd\x61\xfa\x75\xd3\xfe\x6e\x12\xaf\x1b\xf7\xaf\x79\x29\xcf\xd9\x4b\x99\xb3\x42\xe4\x17\x22\xc7\x64\x1e\xe8\xb8\xa9\x96\xbe\x2f\x33\xf5\x05\x6d\x07\xdb\x6c\x26\x58\x2a\x74\x4c\x74\x13\x80\xae\xe4\x3d\x84\x42\xf2\xdb\xdb\x68\x47\x64\x2f\x5c\xec\xba\x3f\x37\x24\xb2\x21\xea\x08\x00\x19\xb5\x67\xc0\x2e\x9d\xbe\x5d\xfe\x5c\xb6\x05\x78\xac\xb5\x8e\x26\xf9\xed\xb2\x6a\xc7\x08\x88\x15\x15\x97\x21\x04\x17\x62\xf1\xc6\x54\x54\x3b\xff\xde\xe2\xb6\x20\x91\xbf\x6e\x8c\x39\x46\x67\xa0\x83\x95\x9d\xb6\x16\x6a\x17\x34\xe3\xbf\x4c\x55\xc3\xa3\xcf\xa9\x8a\x98\x1b\xee\xf9\xbf\xe5\x94\xf5\x79\x66\x2e\x05\x76\x25\xa7\x39\x93\xb3\x4c\x67\xfe\x67\x87\xe5\x48\xe4\xb3\xa4\x10\x40\xb0\x86\x44\x6b\x0d\x4e\x37\xa3\x24\x1d\xd8\xc7\x2d\xe6\x7e\x20\x7a\xe4\xc0\x87\x1d\x7e\x1b\x7d\xa3\xfa\x07\xf5\x62\xf6\x8a\x87\xe4\xab\xc4\x36\xfc\xbe\x16\xad\x3b\x0b\xc6\x11\x2f\x0e\x67\x99\x61\x84\x50\xfe\x1f\xc0\x6b\xd1\xfc\x08\xb9\x9c\x51\xab\x71\x50\xcc\x42\x2e\x47\x53\x1b\xd3\x39\x8e\x78\x81\x7e\x38\xff\xd3\xe0\xd9\xd5\xff\x34\x20\x25\x2c\x9b\xf1\x82\x65\xb2\x74\x59\x20\x4b\x89\x8d\xbd\x01\x03\x84\x2e\x7b\xc7\x8b\xc2\x09\xee\x99\xcc\x19\xcf\xae\xb4\x2a\x16\x97\xb2\x41\x63\xe6\xd1\x44\xfd\xb7\xcb\xd3\xbf\x4c\x9a\xfe\xcf\x99\xa5\xff\x8f\x92\xa4\x7f\xc5\x1c\xfd\x77\x96\xa2\x1f\xdf\xb0\x83\x13\x71\x59\x46\x13\xde\x63\x84\x84\x48\xbe\x47\x71\x61\xd1\x87\xad\x92\xeb\x3e\x0c\xf9\xf2\xd7\xfa\x90\xf0\x91\xd4\x76\x91\xe8\xe9\xd6\x98\x21\x00\xa7\xbe\xfa\x29\xb5\x4c\x1f\x2d\x2f\x65\xbb\x8e\xca\x02\xf3\x69\x63\x9f\xad\x68\x72\x39\x0d\x33\x68\xad\x3e\xe9\xc5\xa8\xc9\x57\x86\xac\x42\x24\x47\x2a\x24\xa3\x51\x2b\xaf\x9e\x63\x0b\x33\x7b\x02\x98\x4a\x8a\x2f\xb2\x7f\x76\xcd\xa1\x26\x84\xe4\xb5\x79\x60\x8b\x66\xcb\x65\xc9\x25\xd1\x8f\x1d\x78\x0c\xed\x49\xc1\x41\x40\x1b\xf2\x61\x41\x12\x28\x0f\x93\xbc\x71\xfd\xe6\xb9\x9d\x3e\x43\x6a\xa7\xea\x06\xfe\x26\xc9\x93\x82\x8c\x43\x1e\x36\x78\xe9\x86\x6a\xf6\x51\x5f\xd4\xf8\xdf\xb7\x6c\xaf\x64\x7d\x91\x97\x90\x1d\x49\xc1\xe0\x19\x3c\x1a\x18\xa2\x4e\xd1\x66\x9c\xa5\x3c\x3f\x17\x39\x3e\xe3\x20\x6c\xca\x98\x5f\xc1\xde\xc3\xa5\x3d\x93\x2c\x4d\x32\x51\xb0\xd9\x28\x49\x05\xbe\x3e\xc6\x3c\x4d\x45\x4e\xbb\x71\x8d\x8b\x52\x3d\x10\xc1\x9f\x56\x73\x13\x05\x93\x99\x00\x20\x5d\xc6\x4e\x14\x59\xc5\x9c\x4d\xf0\x92\x54\xf3\x01\xa7\x33\xc5\x0c\x0c\x93\x2c\x29\xcd\x0b\x88\xa5\x52\x4e\xbc\x3e\x72\x99\x31\xd9\xef\x4f\x73\x7c\x98\x66\xac\x1c\xf1\x92\x15\x7d\x91\xf1\x3c\x91\x5d\x52\x77\xdd\xfe\x5d\xbf\xab\x77\x9b\xca\x84\xc6\xd6\xf1\x42\x2c\xbb\x68\xfd\x5b\xab\xa4\x32\x59\x2a\xe1\xc8\x0a\x69\x44\x8c\x6c\xc1\x55\x33\x5f\x6e\x94\x6c\xa4\x1f\x66\xdd\x50\x5f\xa2\xd1\xd2\x23\xf9\x44\xbc\x04\xe6\xf0\x02\xf1\x40\xc1\xa7\x1b\xa4\x1b\x71\x91\xe3\x4d\xfe\x90\x48\x88\x75\x60\xed\xfd\xfe\x8a\x30\xe2\xf4\xb2\x69\x42\x3e\x5b\x1a\x90\x7a\xc3\x3a\xdc\xb2\x6a\x9e\x8f\x3e\x1a\xdb\xd9\x25\x56\x3f\x60\x1d\x2b\xd9\x3d\xf4\x9a\xc0\xdf\x6a\xe2\x95\x04\x1e\xf1\xbc\x1d\x09\xaa\x2d\x4d\xe2\x72\x42\xac\x2c\x2e\xa8\xdb\xc5\xde\x88\x5e\x7e\x02\xad\xf2\x9c\x9f\xa1\xc0\xc0\x69\xb1\xa7\x0e\xbf\xb6\x97\x8f\xa1\x8d\x3a\x53\xdf\xe0\x0e\xff\xc3\x80\x48\x55\xec\xb5\x9f\xaa\xdc\x81\x9a\xb2\xb9\xe5\x23\x73\x76\x58\x5b\x3b\x69\xd3\xfa\x8e\xa3\xbf\xfb\xe2\x7f\x3f\xf0\xf7\x2a\xe1\xdc\x8b\x09\xcf\x96\x8f\xe7\xbe\xd8\x32\x13\x0f\xed\x0a\x59\x43\xa8\xd4\xba\xcd\xe2\x37\x5e\xab\x75\xeb\x40\xf0\x66\x1b\xa2\x91\xe0\xbd\xdf\x41\x0c\x75\xbb\xc5\xe4\x6b\x6b\x01\xc6\xdc\xc4\x98\x95\xa6\x7f\xd9\x5a\x35\xf1\xcc\x96\x5d\xcf\xf7\x0d\x05\x4e\x3d\x36\xa1\xb1\x36\x47\xe8\xf6\xf9\x24\x29\x21\x5a\xc0\xcb\x24\x2f\xca\xd7\xa2\x2c\x45\xde\x6a\xda\x03\xdf\x3a\x6d\x83\x5d\xd9\x2a\x49\x6a\x6e\xdf\xa9\x7a\x02\x1b\xf5\x5d\xe3\xb4\x6d\x2f\xa7\x2f\x3f\x0a\xa3\x77\x54\xa3\x30\xa4\xf1\x66\xa3\xe8\x7a\x0a\xef\x36\x12\xbd\x07\x0f\x10\x8f\x6e\x08\xd2\xdd\xbd\xee\x66\xf6\x33\x00\x6d\xb5\xa2\xe6\xd0\x06\x21\x0b\x93\x51\xcf\xcf\x6c\xe7\x2e\x38\x08\x52\xa2\x05\x4c\x90\x7c\xd0\x2f\x31\x52\xa2\x56\x98\x72\xa7\xdb\xd7\xf7\xa3\x6d\x50\x39\x10\xa6\x6f\x98\x38\x98\x1a\x06\xe6\x9d\xe4\xfd\xb2\xc1\x9e\xce\x33\xb0\xc0\x1b\xda\xdd\xdd\x2d\xb6\xed\x7e\xdc\x30\x21\x49\xbd\x95\x36\x0b\x2c\xb5\xbf\xab\x6a\x11\x19\xc8\x2f\xfa\xd3\xe2\x28\x99\x4c\x8c\x91\x6b\x94\x35\xa3\x06\xdd\x21\x1b\xa2\x27\x41\xbf\xbb\x5c\x14\x1e\x71\x6e\xf0\x3c\xe1\x1d\x7b\x77\xc7\xb3\xc7\x38\xf5\x91\xa7\xb1\x47\xda\x86\xcc\x88\x9f\xf1\xc6\xca\x5a\x2b\x72\x01\xd7\x70\xe9\x94\x2b\x74\xb4\x95\xcb\x25\x7a\x95\x69\x65\xbb\x4f\x78\x43\x3e\x12\x8e\x8f\x23\xbb\xae\x28\xcc\x53\x31\x2f\xc1\xc4\x32\xf9\x25\x62\x36\xcc\x6e\x45\x51\x8e\x72\xe3\xd4\x0d\x9e\x11\xb3\x31\x5c\x6e\x55\x02\x2e\x3e\x79\xf4\x75\x19\x1a\xa3\x2d\x9a\xba\x89\x5f\x26\x22\x1d\xd4\xc6\x11\x00\xbb\xb5\x05\xbd\xd9\xa0\x6d\xd8\x95\xc8\xa6\x63\x91\xf3\x1e\x3d\x3c\x10\xd9\x93\x46\x27\x6b\x86\xae\x1c\x35\xd6\x70\x76\x84\x2d\x97\x23\x01\x64\xa6\x5f\xc4\x44\x2e\xd8\xc3\xef\x7e\xd7\x3e\xcf\x7f\x3c\x2f\xe3\xcf\x60\x39\x3b\xe3\x79\x96\x64\xe7\x75\x60\xbf\x0b\x2b\xce\x35\x68\xc5\x2a\xce\x32\x34\x9b\x4c\x6b\x07\xfc\x68\xd3\xaf\x37\xd7\x84\x54\x55\xb0\xd5\x5f\xca\x1c\x12\x0b\xe5\xb2\x2e\x5c\xc8\xd6\xdf\x1e\xc5\x6a\xcf\xeb\x82\x54\xf3\x9a\xbe\x02\x16\xcd\x48\x38\xa3\x7d\x7d\x57\xd3\x60\x51\x77\xae\xa6\xcb\xf9\x02\x77\x65\x9d\x3b\xc4\xc6\x77\x41\xc5\xb9\x59\x61\xa0\xc6\x97\xa1\x2a\x71\xf3\x56\xb2\xa4\x2b\x59\xd4\xbc\xc5\xa0\xc4\xb7\xb3\xcc\x05\x20\x0b\xcc\x72\x57\x19\x94\x49\x77\x08\x1a\x9e\x5b\x8f\xce\x87\x76\x87\xc3\x8c\x5a\x23\x81\x20\x73\xa2\x29\x2c\x53\x8f\x8e\x82\x4d\x0b\x91\x43\x8c\xee\x61\x92\xa6\x6c\x28\xf3\x71\xc1\x86\x10\x75\xb8\xcd\x44\x31\x11\xfd\x84\xa7\xe9\x15\x93\x19\x1b\xcb\x5e\x92\x0a\x36\x10\x17\x49\x5f\x68\x4b\x25\xb0\x42\x50\x9c\x02\xe8\x57\x7b\x82\xf5\x65\x36\x9c\x16\x60\xfb\x91\x94\x8d\x82\x8d\x65\x2e\x58\x9a\x7c\x10\x8c\x67\x8c\x4f\x4b\xa9\xba\xe9\xfa\x6a\xd9\x54\xf0\x3c\x63\xbc\x27\xa7\x25\x5a\xeb\x94\x23\x14\x93\xf2\xbc\x4c\xfa\xa9\xb6\x39\x31\x81\x42\x07\xe2\x42\xa4\x12\x9e\x4b\xe7\x52\x9e\x03\x5f\x3f\x5e\x9f\x89\xde\x3a\xa6\x69\x2f\xd6\xb7\x36\x36\x1f\xaf\x6f\x3c\x59\x07\x11\xaa\x9c\x96\x1d\x9c\x4f\x47\x01\xee\x98\x31\x58\x05\xae\xfa\xa0\x70\x35\x15\xe5\xad\xec\xa4\x12\x20\x72\xc6\xd4\x08\x38\x6d\x31\x60\x83\x29\x08\x7e\x21\xd5\xb7\x7a\xd2\x31\x08\xb1\xde\xf5\x7a\x7f\xa9\xea\xde\x42\xf5\x6f\x12\xa7\x6d\xaf\x68\xb0\x11\xa0\xf2\x0d\xcd\x36\x7c\x28\x77\x63\xbc\xe1\xc1\x5c\x60\xc0\x71\x33\x23\x37\x85\xb7\x86\x1f\x46\x99\xa8\x1c\xc2\x2e\x9d\xc1\x1d\x73\x56\x35\xaa\xd1\xb5\x7f\x42\xe6\xe3\xae\xf0\xe4\x4e\x2c\xea\x82\x1e\x50\x7e\x44\x7a\x98\xa4\xfc\x4a\x0c\x58\x92\xa9\x43\x28\xf2\x5c\x42\x20\xc3\x92\x18\xbe\xc1\xc7\x15\x7a\x74\x6c\x09\xb5\x63\x84\xf5\xf3\x6f\xb4\xc8\x42\xfa\x15\x80\x50\xad\x64\xb7\x52\xbf\x9e\x25\xff\x20\x4c\xa8\xd3\xe1\x34\x4d\xd1\x60\x59\xed\x6c\x52\x16\x8a\x34\xa1\x04\xd2\x0d\xe5\xa6\xa6\x87\x28\xaf\x41\xed\x54\x1f\xad\xa5\x1d\xd0\x91\x9d\xdb\xaa\x07\x12\x2f\xbc\x1b\x9e\x43\x68\x7c\x37\xc7\x4f\x81\x8a\x58\x9b\x3d\x3f\x3e\xc6\xd3\x86\x14\x5f\x1f\x18\xba\x16\x95\xbd\x76\x6b\xf1\xfc\xc6\xc7\x34\x19\xd8\xb3\x99\xd4\x9c\xcd\xa4\xfe\xb4\xd4\x41\x8d\x4f\xa6\xbe\x07\xf5\xfd\xe6\x73\xa8\xe9\xad\x8e\xd6\x1c\xdc\xbc\xb7\x39\x27\x13\xa0\x82\xb8\xaf\xae\xcb\xd7\x46\x80\xbc\xda\x89\x9c\xd3\xe7\xdc\xf5\xbc\xd3\x9e\xe6\xae\xe5\xea\x3d\xfd\x58\x08\x64\x42\x2c\xbf\x54\x4a\x36\x51\x3b\xc8\x59\x2e\x86\x2e\xa8\xa9\xee\x3f\x03\x7f\x27\x4d\x8d\x68\xec\x0d\x3a\xe1\x23\x31\x5c\xc1\x4a\xd0\x59\x78\x56\x68\x8c\xb6\xf0\xfc\x03\x90\x97\x79\x26\xae\x37\x3b\x21\xe4\xfe\xe0\x40\xb6\x78\x2e\xb8\xe9\xc1\x5e\x9b\xa8\x32\x87\x5b\xb3\x28\x05\x07\x1a\x04\x0a\xff\xc9\x94\x0c\x63\x3c\x4d\xcb\x24\x4d\xb2\xf9\x71\x64\xfc\xfe\x41\xd9\xc2\xcb\x32\x4f\x7a\xd3\x72\x31\xe5\xc9\x56\x9d\x9f\x8d\xba\x33\x4c\xd4\xf8\x21\x42\xb8\xea\x01\xd9\x1c\x30\x65\xe0\xd9\xb9\x61\x39\x34\x53\x35\xe1\x39\x1f\xb3\x8f\x78\x12\xae\x19\x1a\x38\xa8\x5d\xc1\xbf\x0a\x39\xcd\xfb\x76\xac\x06\xf7\xd7\x6e\x61\x44\xab\x60\x17\x23\x99\x97\x6c\x94\x64\xa5\xcf\xa5\xb8\x6b\xbd\x27\x86\xea\x01\xa1\x3e\xa8\x87\x0a\x03\x7f\x24\x75\x04\xd1\xdc\xd0\x0e\x60\x92\xf2\xbe\x18\xc9\x74\x20\xea\xb9\x98\x25\x78\x33\x44\xb6\xa4\x20\xc3\xe1\x85\xb1\x09\x21\x3c\x9a\xf9\xb2\xc2\xae\xaf\x4a\x4f\x72\x29\xa3\x74\x44\x7d\x5f\x8d\x8c\x60\x74\x7f\xb5\x77\xb9\x9c\xc1\x53\x4f\xcf\x0e\x51\xc3\xa2\xb0\x8e\xf2\xaa\xa6\x5f\x88\x12\xc6\x91\xd3\x35\x56\xad\xef\xc0\xa8\xbc\xa6\x38\x83\x51\x86\x96\xbb\x6f\xf8\x65\x32\x9e\x8e\x59\x76\x87\x73\x78\xc3\x2f\xbf\xf4\x34\x8e\xd0\x3a\x88\xb3\x33\x94\xc6\x9c\x39\x72\x03\x16\x4a\x0a\x0f\xcc\x33\x31\xb8\xc8\xc0\x20\xd7\xb4\xe2\x85\xa5\x13\x70\x60\x45\x69\xb8\x59\x85\xc9\x60\xfe\xe9\x2f\xc0\x95\x9c\xb2\xf1\xb4\x28\x11\xd3\x14\x78\x13\xf5\x5b\x1f\x65\x54\xca\x28\xc0\xe6\x15\xe9\x16\x0b\xcb\xee\xe6\x55\x10\xcc\xdb\x75\x82\x05\xab\xdf\xcf\x90\x5d\xa4\x4a\x45\x03\x2e\x80\x1d\x94\x26\xf8\x59\x4f\x20\xd9\x48\x06\xec\xd5\xc9\x9b\xd7\x8f\x35\x85\x01\x93\x6b\x3b\x1a\xf5\x6b\x65\xe6\x6e\xde\xfb\xb1\x6d\x69\x05\x18\x0f\x73\xb8\xca\x21\x6b\xfc\x20\x76\xba\x2f\xe6\xbe\x2e\x3f\x13\x76\x2a\x22\x38\x10\x59\x21\xce\x98\xcc\xd9\x19\x3a\x07\x9e\xb5\xf1\x2a\xe4\x03\x88\xa2\x76\xa1\xf6\xb5\xcf\x53\xa6\xdd\x1a\x71\xba\x49\x01\xc6\x79\xe6\x65\x35\x88\x7a\xb2\x8d\x79\x7e\x9e\x2c\x8e\x2a\x87\x2e\xde\xac\x01\x23\x51\x7f\x68\x27\xc5\xd3\x16\xd8\x91\x93\x00\x66\x46\x73\x12\x86\x2e\xa3\x92\x1c\x1b\x37\x8c\x7e\xb4\x3e\xb0\x46\xe8\xe2\xd5\x82\x2f\x36\xce\x99\x3e\x0d\x2e\xc4\x99\xfe\x50\x09\x84\x36\x27\x08\x1a\x91\x18\xb8\x38\x68\xe4\xa3\x8b\x96\x66\x0d\xdd\xe2\x76\x6e\xf8\x66\x37\xa5\xf0\xcb\x14\x25\xae\x55\x62\xeb\xfb\xaf\x15\x57\xc1\xfb\x6c\x2a\x1f\xc4\x2b\x1f\x44\x2b\x3b\xbe\xdd\x0b\x00\xe7\x3e\x7b\x50\x8d\x14\x92\x40\xf4\x2a\x19\xa6\xd8\x87\x73\x24\x86\xa6\x82\x31\x85\x89\x58\xd9\xf9\x1c\xa0\x5f\x27\x3e\x47\xf7\xba\xf1\x87\xe4\xbe\xbb\x38\x04\x44\xd8\x8f\x35\xdd\xa7\x6a\xa5\xea\x28\x22\x65\xa6\x59\x44\xfc\x61\x9b\x45\xca\xac\x9b\x35\x31\x73\xac\xb1\x72\xb4\x94\xc6\xd4\x30\x1f\x4c\x05\x9d\x86\x45\x9b\x07\x5e\x4d\xec\x98\xdc\xfd\x69\x4a\xed\x17\x53\x25\xa3\xd3\xcb\xc8\x7c\x88\xa5\x63\xdc\xd0\x91\xf0\x66\xb6\x0e\xf9\x66\x47\x8f\x8c\x8d\x1b\x3c\xfe\x76\xc5\xb3\x82\x94\xcd\x0a\x5a\xf0\x86\x5f\x7a\x65\x6f\xf8\xa5\x29\x2e\x8c\x26\x85\xda\x57\x9a\x42\x72\xf9\xd8\x1a\xe4\x9b\x8d\x45\xe8\x9d\x60\xcf\x66\xf2\xa6\x71\x08\x29\x59\x52\xc4\xce\x12\x20\x30\xa0\xd4\xb4\xa6\x6a\x4c\x49\x88\x47\x68\x5c\x09\x54\x01\x0c\x2a\x07\x68\x56\x49\x8f\xaf\xfa\x72\x50\xf9\xe2\x4e\xad\x2d\xb7\xbf\xcc\x49\xf4\xac\x32\xfd\xc3\x65\x1b\xb9\x03\xa4\x3e\x39\xdc\xf7\x7f\x79\xed\x22\x98\x5e\xb1\x10\x35\xe8\x0b\xe6\x9e\x57\x13\x68\x67\xf1\x12\x6e\x08\x0d\x8c\x1a\x8b\x12\xcc\x02\x18\x88\x45\xf8\xe7\xac\x30\xff\xbe\xe1\x97\xce\xb2\x54\xfd\x45\x76\xbd\x6a\x50\x8a\xb9\x16\x09\x3d\xf3\xa9\xa0\x8d\xe6\xe8\xaf\xb9\xf5\xf2\xa2\x2d\xeb\xc2\x29\x86\xb7\xca\x76\x40\xc3\xd1\x50\xa4\x4d\x80\x39\xb7\x83\xa5\xa3\x1f\x82\xd5\x87\x56\xdf\xba\xbe\xef\xeb\x23\xf2\xe9\x13\x7b\x26\x65\x2a\x78\xd6\x34\x08\xd8\x6a\xb3\xc6\x1b\x5e\x8a\x3c\xe1\x69\xe7\xc7\x83\x6d\x76\x66\x4a\xce\x90\xad\xec\x21\xef\x6a\x9e\x99\x53\xc7\xc5\xda\x5b\xfa\xcc\x31\x05\xa8\xda\x39\xc3\xfe\xce\xba\x8d\x16\xdb\xa6\x96\xaa\x6a\x99\x11\x49\x6d\x83\x85\x41\x52\x51\x65\xec\xe2\xa2\xce\x5d\x5f\x5f\xd5\x53\xe5\x0c\x88\x32\x26\x60\x08\xc8\xbe\xc4\xee\x45\x5f\x37\x50\xbd\xe2\xab\x66\x4e\xf8\x9d\x88\x0f\x02\x82\x8b\xaf\x7e\x47\x67\xf1\xf1\xe5\xe8\x9e\x7d\xc8\x78\xe4\x0e\xd9\x57\x47\xd9\x35\x3b\x49\x28\x56\x32\xd8\x66\x86\x4f\xa0\x32\xb8\xf0\x02\x77\xe2\x2a\xff\x4a\x76\x2f\x7d\x9f\xcc\x7b\x0f\x70\xf2\x03\x1d\x15\x1c\x69\x69\xa1\xb1\xdf\x0a\x91\x49\xa9\xde\x7e\xb9\xd0\xa4\xe1\x8d\xb9\xcd\x2a\x57\xe5\x3c\x5b\x37\xad\x0b\xf1\xb8\x2c\xf7\xe0\x37\x7f\x99\x03\x19\xd8\xa8\x81\xb1\xaf\x26\x3a\x58\x85\x46\xbc\x60\x0f\x1e\x2c\x67\x92\x86\x78\x4d\xd8\x13\x33\x90\xda\x70\xac\xa3\x72\x9c\xbe\x54\xe3\x4e\x06\x6d\x3a\xbd\x80\x4d\x32\x9b\xe1\x48\x76\xcb\x63\xa8\xe0\x6f\xfd\x49\xd3\x85\x45\xf9\x8f\xcd\x90\xb5\x29\x42\x68\x98\x58\x3b\x62\x40\xac\xed\xf0\xc4\x5f\xb7\xe9\xad\xdc\x0a\xf9\x71\x1c\x1f\x0b\x9b\x61\x35\xc2\xb6\x2d\xbd\xd0\x81\xa9\xc6\xd2\xa3\x27\x4b\x1c\x63\x04\xaf\xdb\x31\x46\xaf\x55\xe5\x1d\x71\x42\x2e\xca\xad\x21\x9b\x37\x8a\x6f\xbb\x92\x71\x80\x0e\x8b\x6a\x3b\x8c\x18\x13\x3a\xb4\x07\x63\xc2\x36\x11\x0a\x58\xeb\xc2\x88\x79\xa1\x85\xf9\x79\x42\x9b\x3e\xfe\x2a\x2d\x0e\xa5\x4c\xcb\x64\x52\x6b\x6f\xf8\xe4\xb7\xb6\x37\xc4\xf1\x7d\x0d\xd6\x86\x4f\x7e\xd7\xd6\x86\x8b\x23\xd9\xfe\x71\x2c\x11\xbf\x7c\x48\xd2\x3f\xa3\xe8\xfe\x19\x45\xf7\x56\x51\x74\x3f\x8b\xf1\x2c\xfc\x7a\x01\x29\x40\xe3\xa6\xa1\x7e\xcd\xfd\x0b\x91\x95\xaf\x93\xa2\x14\x19\x08\x0f\xa2\x54\xe2\xd1\x9c\x36\x0b\x47\xe6\xd5\x26\xc7\xaf\x27\xa7\x59\xbf\xce\xa8\xf2\xf1\x56\xa5\xe6\xbc\x8e\x4c\x9d\x2f\x62\x42\xfc\x25\x02\xfb\xc2\xca\xbd\x93\xe0\xe0\x51\x77\x8d\x7f\xbf\x7a\xf4\xdc\xbe\x1c\x8f\x6b\xe3\xe7\x6e\xfe\xb0\x19\x54\x9c\x3b\x68\xa8\xe1\xa8\x5b\x2e\x6a\x4d\x50\x7f\xd8\xf0\xaa\xcd\x25\x7d\xb9\xb8\xfa\x52\xd1\x8d\xbf\xa6\xe0\xbf\x5f\xca\xbe\x98\xad\x7f\xcb\x44\x91\x26\x59\xd9\xd1\xcf\x7f\x06\xa8\xb6\x9e\xc9\x0e\x3c\xfb\x3b\x7d\x39\x9e\xb4\x59\x26\x3b\x8a\x97\xc8\x8b\xbe\xcc\x45\x67\xc0\xb3\xf3\x54\x40\xc6\xc5\xaf\x38\xa2\xf1\xda\xfa\x3a\xa8\xb6\xb9\x36\xdd\x70\xb2\x9e\x42\xb2\x19\x9a\x05\x9f\x8b\x12\x95\xdc\x22\x17\x59\x5f\x74\x75\x4c\xa0\xfc\x5c\x94\xcf\x9d\x9a\xe5\xe6\xe1\x81\x28\xa0\x25\x22\x05\xd1\xea\x96\x7b\x5e\x2e\x10\x10\x6d\xaa\x9d\xb7\x34\xa6\xae\x1a\x73\xc7\x87\xb5\x5a\xdc\x1d\x6f\x14\x2d\x1d\x7d\x07\xe1\xda\xb0\x41\xad\x25\xa3\x92\xf8\x6b\xf7\xfe\xe6\x11\x25\xf4\x3a\xb8\xc8\x10\x5d\xad\x01\xad\xf7\x71\xa3\x7d\x2f\x74\x77\xfb\x1c\xe9\xc6\xc2\x48\xb9\xb5\x31\x6d\x8d\x4f\x29\x5b\x5f\x67\x6f\xf8\x07\x81\xaa\x74\xe3\x0c\x08\x36\xee\x65\xce\xb3\x62\xc2\x73\xa3\xce\x35\x2e\x82\x13\xe9\x47\xe7\xfd\x55\x27\xc3\xc1\x40\xa4\xf8\xab\x5b\xe2\xe3\xac\xda\xee\x79\x2a\x0b\xe1\x1a\x43\xec\x53\x91\xc3\xed\x5e\x98\xb0\xd8\xb4\x95\x06\xb4\x6c\x64\xd9\x1e\xef\x7f\x38\xcf\xe5\x34\x1b\x6c\xeb\x6b\xc2\xd4\x79\xff\xfd\xc6\xc6\xa9\x59\x8e\x9e\xcc\x07\x22\x3f\xe2\x83\x64\x5a\x6c\x33\x1b\x5c\x57\xc7\x4e\x36\xf7\x96\xdd\x37\x90\xb6\x8d\x12\xa7\x6f\x1d\xca\xac\x7c\xc9\xc7\x49\x7a\x15\x89\xcc\xea\x0a\x69\xf5\x05\x61\x5c\x37\xbf\xb3\xa2\x94\x71\x92\xbd\x12\x73\x02\xef\xda\xf0\xe4\x6a\x87\x4d\xcd\xc6\xa3\xad\xc9\x65\x24\xd8\x73\x10\xd0\x17\x72\xce\xd5\x64\x9c\xc3\x6c\x73\x56\xb5\xa6\xb6\x7f\x28\xf3\xf1\x36\x6b\x14\x7d\x9e\x8a\xe6\x46\xcb\x2f\xd4\xa1\xd1\xf5\x94\xec\x97\x42\xcb\xa5\x9a\xef\x1b\x7a\x18\xa0\xee\x30\xe0\x1a\xa7\xd4\xff\xd5\x24\xe5\x8e\x81\x31\x65\x5d\xb0\xaa\x12\x45\xa9\x5b\x5d\xb7\x8c\xa8\x32\x1e\xe6\xb7\x18\x07\xd1\xd1\xcd\x1a\x6d\x6d\x45\x57\x6e\x8b\xae\xdc\xca\xeb\xb4\xcc\xde\x6e\xf8\xb1\x82\x35\x4e\x63\x1c\xe6\xe5\xf0\xda\x2e\xdf\x61\x9e\x80\xed\x01\x26\x2f\x62\x41\x3c\x6b\x63\x99\x50\x3f\xf8\x6f\xd9\x23\x2f\xad\xe0\x92\x8b\xe8\xe0\x6e\x7e\x67\xdb\xfa\xd3\xd1\xb1\xa2\x6f\x3a\x9f\x54\x0c\xbf\xaa\xe9\x40\x94\xee\x9b\x4e\x06\xe7\xc1\x7a\x10\xd4\xbb\x32\x9d\x79\xf3\x60\x1b\x37\x9b\x89\x9a\x87\x6d\xeb\xcf\xc4\x84\x16\xbf\xe5\x64\x4a\x39\xf9\xad\x67\x72\x38\x11\x59\x34\xd2\xfc\xdf\xea\xa9\xd6\x66\xeb\x56\x09\x34\x53\xde\x9f\xc7\x7e\x12\x73\x1f\xdc\xec\x8e\xc8\x40\xbd\xab\x7f\x15\x25\xcf\x4b\xf7\x1b\x54\xce\x62\x58\x9a\x5a\xf0\xb7\xad\xe3\xe5\x25\x33\x55\xf0\x87\xad\x83\x39\xcb\x14\x41\x95\x13\x53\x45\xfd\x69\x2b\xa8\x6d\x3a\xf5\x1e\x26\xc3\x34\x99\xd8\x79\x34\x27\xe6\x2f\x64\x26\x8a\x59\x52\xf6\x47\x2c\xfc\xcc\x58\x9f\x17\x82\xd1\x49\x6d\xfb\x7c\x91\x3f\xc3\x9d\x6a\x1b\x2c\xa8\x69\xa5\x00\xd2\x36\x66\x36\x61\x75\x37\xb5\xb0\x76\x1c\xbc\x81\xb3\x43\xb5\x98\x41\x25\x3b\xd5\x1d\x93\xf3\xff\xd6\x6e\x88\x5a\x54\x6e\x5f\x04\x31\x4b\xb8\x9b\x3a\xb5\xdd\x51\x14\x62\x92\xe4\xee\x56\x6d\xb7\x7f\xdb\xe8\xc7\xb5\xa9\x59\x7f\x8f\x81\xe9\x5f\x48\x08\x55\x9b\x8b\x62\x22\x33\x18\x1f\x78\x59\xa2\x89\x7a\x51\xf1\xa0\x3b\xc9\x93\xf3\x73\x91\xaf\xea\x5d\x59\xed\x65\x24\x2f\x44\xbe\xa0\x97\x57\xaa\xce\xad\x7a\x49\x65\x76\x8e\x29\x71\x59\x29\xa7\xfd\xd1\x82\x0e\x4f\x54\x9d\x15\xdd\xd6\x30\x2b\x8f\xcc\x8a\x51\x32\x61\x3d\x51\xce\x84\x76\x0d\xd0\x17\x06\x46\x5a\x24\x2f\x1b\xdc\xff\x4c\x94\x2c\xc1\x30\xc1\xfd\x54\xf0\x9c\x0d\x73\x39\x86\x7a\x2f\x0e\xdf\x68\xf3\xe3\x67\x57\x3a\x84\x70\x02\x20\x88\x9f\x71\xdb\x88\x01\xa6\x85\x60\x10\x13\x66\x20\x8a\x7e\x9e\xf4\xc4\xa0\x07\x46\xf0\x85\x4c\x2f\xd0\xc4\x9f\xf7\xfb\x42\xbd\xa0\x93\x34\x29\xaf\x58\x52\x14\xd4\x74\x7b\x45\x1f\xaf\x3a\x2f\x88\xd2\x12\x9f\xff\x9d\x8a\xa2\x04\x5b\xf2\x9e\x60\x7d\xf5\xd0\xba\x5b\x97\x88\x23\xec\x41\x3f\xe1\x96\x36\xd7\x5f\x71\xe0\x72\x62\x4c\xb6\xef\x76\xd8\xc8\x3c\x2c\x3d\xea\x30\x69\x84\x1e\x6c\x52\xb0\x62\x24\x67\xc4\xa8\x5c\xce\x83\x1b\x41\x5b\x0d\xa8\x4c\xca\x94\xda\x69\xab\x9f\x5f\xdc\xff\xe9\x46\x97\x42\xd8\x70\xe9\x1b\xe1\xae\x3d\xae\x6a\xef\x02\xf0\xe1\xb7\x0e\x16\xe3\x24\x4d\x13\xcc\xea\x04\x38\x36\xe3\x89\xf5\xc3\x51\x7b\x69\x2c\xbc\xf4\x16\x13\x1f\x62\xc5\xf7\xbe\x10\x20\x50\x99\x6b\x7f\x7e\xd3\xde\x47\x09\x3c\x36\xe3\xbd\xa7\x82\x5f\x88\x1b\xf4\xae\xf1\xcb\x72\x39\x6b\x9e\x4b\xd1\x18\xf2\x20\xfd\x9e\x58\xd9\xa5\x3d\x32\x50\xd1\x11\xf1\xc8\xc0\x82\xd5\x3d\x32\x2a\xf9\x04\xd4\x33\x66\x01\x04\x17\x22\xde\x9a\x4f\xd4\xcb\x81\xb7\x16\x08\x82\x11\x44\x55\x02\xbc\x15\x8a\x80\xb1\xe2\xb2\x01\xe3\xb7\x56\x8f\x18\xaf\x6d\x2d\x7e\x3f\x51\xe3\xb7\x6e\x11\x36\x5e\x9f\xc4\x55\x44\xd8\x7a\x7d\x56\x0c\x1f\xbf\x65\xff\x70\x01\xe4\xaf\xed\x27\x20\x3f\x27\xc9\x18\x94\x77\x10\x3e\xd5\xc6\xd3\x54\xa4\x21\x5a\x02\x8c\x56\xb4\x24\x29\x9e\x3b\x47\x9d\xa0\x6c\x62\x54\x84\xde\x57\xe2\x31\xe2\x43\x82\x53\xf1\x56\x66\xc0\xb1\xa1\xe8\x56\xa1\x39\x18\x54\x99\x4a\x18\xc8\xee\x48\x40\x38\xea\x5d\x23\x7b\xd0\x3a\x58\xb7\x70\x73\x63\xb3\x9b\x81\xd1\xc0\x87\x5e\x41\xf7\x17\xfd\x6f\xd1\x1f\x89\xc1\x34\x15\x3a\xb8\x77\x35\x64\xfc\xe6\x93\x27\xad\xca\xd8\x2c\x5b\xb0\x28\x02\x3f\x59\x09\xd3\xbf\xe7\x42\xe3\xc7\x75\xc4\x2b\xdc\xb6\x81\x18\x8e\xc8\xd0\x35\xc2\x38\xf3\xa6\x92\x79\x55\xa2\xc2\xa0\x6b\xb5\x28\x32\x4b\xaf\x9c\xed\x32\xf6\x6a\x3b\xc3\xee\x60\xb8\x5d\x74\x84\x00\x4e\x00\x6c\xee\xd9\x83\x07\x3e\xf0\xae\xcc\xe0\xdd\xe0\x47\x69\x8d\x56\x09\xc2\xee\x93\x68\x92\xf1\x1e\xc7\x72\x5a\x08\xf5\x5a\x88\xf6\xfa\x46\x95\x1e\x5e\xf8\xbb\x58\xed\xd9\x56\x8b\xf4\x1e\x8c\x82\xe0\x47\x14\x15\x1f\x3c\x60\x64\x88\xb0\xfc\x70\x2c\xf0\x5e\xa1\xc3\x40\x0a\x52\x09\x9a\x09\x6f\x02\x75\x88\xe4\xb4\x6c\x56\x8e\x9c\x1d\x1a\xc5\x53\xd4\x0f\x59\x7e\x81\xfd\x83\x6d\x44\xb0\xd6\x3b\xb7\x85\x28\x4d\x1f\xb1\x53\x40\x9a\xe5\x0e\x53\xab\xab\xd3\x66\x35\x63\x70\x87\x80\x89\xb4\x10\xd5\xd1\xd4\x83\xf5\x33\x2d\x78\x35\xe7\x1d\x15\xc8\xfe\x12\x21\x37\x91\x95\x20\x09\x0e\x90\x7f\x56\xac\x36\xc9\x68\x10\xdb\x6c\xe3\x8c\x43\x0e\x6e\x8c\x32\x54\x6b\x99\x24\x14\x10\x63\xb7\x6e\x8e\x1e\x51\x80\x27\xce\xff\x25\xaa\xd0\x4b\xa7\xf1\xe3\xf9\x2c\x9d\x2e\x38\x99\xaa\xc6\x8d\x48\x02\x60\x7b\x3d\x4d\x78\xad\x8a\x97\x20\x0a\x50\x6f\x31\x55\xb8\xe9\xa1\x75\x6c\xf6\x9d\x1f\x58\xc0\xa2\x85\x27\x96\x0c\x60\xc9\x13\x1b\x83\x5b\x73\x64\x17\x22\xf2\x12\x77\xba\x87\xc7\x37\x3d\xdf\x00\x69\xb5\x03\x0e\x63\x5f\x7c\xc2\xc9\x6a\xb4\xb1\x9b\x05\x67\x1c\xa6\x78\xac\x2e\x83\x9b\x2f\x8c\x22\x25\x3b\xbf\x13\x5a\x10\x9e\x2a\x37\xff\xf9\xa7\xcf\xd5\xbb\xd9\xe9\x73\xbc\xa8\x6d\x89\x74\x62\x22\xf2\x22\x29\x4a\xc7\xa6\xc5\x98\xd7\x85\xa7\xad\x8e\x99\x0b\x0f\x46\x9b\x6d\x8a\x47\x26\x30\x71\x0c\x15\xf6\xb3\xc1\xef\x99\xd4\x47\xb7\x6d\x3f\x1b\x2c\xb1\xb9\xfb\xd9\xe0\xce\xb6\x76\x49\xfa\x3b\x1f\x03\x56\xa3\xb7\x4b\x50\xc5\x36\xdb\x7c\xbc\xb1\xc1\x1e\x2e\x20\xb9\x37\x4e\x98\xb4\xb5\x4a\xc6\x24\xf3\x9c\x8f\x67\x4d\xfa\x39\x49\xd3\xa5\xd2\x26\xd9\x8a\x41\xfa\x9b\x6a\x2e\x1b\x97\x3d\x04\xbe\x05\x4f\x40\x4d\x47\x27\x1a\x45\xa9\xd5\xbf\xc3\xae\xfb\x95\x96\x5e\x9e\xa3\x75\x14\xa2\xdb\xc2\x36\x08\xc5\xc1\xa6\x27\xe3\x29\x06\xe5\xb3\xb5\x83\xd4\x56\x04\x3b\xc9\x1d\xe1\x10\x71\x71\x8a\xa0\xbb\xc8\x38\x75\x5b\x5f\x53\x9d\xdb\x48\x9f\xf5\x4f\x9f\x98\xff\xc5\x46\x3e\x60\x9f\x3e\xad\xd9\x45\xfb\xeb\xcb\x54\xce\x5e\x26\x97\x6f\xcc\x74\x83\x46\x25\x3f\x7f\xcb\xc7\xa2\x5b\xca\xd7\x72\x26\xf2\xe7\xbc\x10\xcd\x96\xe6\xe4\x20\x62\x7e\xa3\xcd\xde\xfb\x8e\xac\x57\x72\xca\x78\x2e\xac\xd2\xe2\x9c\x71\x17\x86\x01\x1b\x39\x92\xa4\x45\x66\x46\x46\xe5\xb4\x95\x8d\x36\x6b\xec\xb9\x76\x26\x64\xcb\x00\x95\x3b\xc3\x24\x17\x46\x8b\xa3\x6a\x3e\x9b\x96\x1e\x9c\x4c\x08\x14\x72\xa6\x60\xa8\xed\xe5\x9b\x54\xdd\x1a\x70\x08\x82\x06\xbd\x01\x09\x28\x48\xc4\x15\x5c\xf5\x3f\xd0\x58\x33\xce\xce\x06\xc9\xc5\x19\x03\x85\x55\x29\x27\x46\xcc\x6f\x64\x7c\x8d\xd3\xee\x7f\x64\x92\x35\x1b\xff\x93\x35\x5a\xd4\xfb\x76\x11\xc6\xa8\x43\xf4\x63\x36\x5e\xf6\xbc\xe9\xaa\x04\x6f\x3c\x7a\x07\xbb\xe7\xe4\x35\x71\xa2\x88\x49\xe4\xaa\x24\x91\x04\xfe\x47\x79\x49\xb7\xcf\xb3\xbe\x48\xe7\x64\x3e\xbb\x61\x6e\xac\x47\x9a\x3a\xac\x94\x03\x8b\x5c\x1c\x24\xbd\x55\x10\x3c\x84\xad\x9a\x2d\x6b\xb9\x4c\x59\x54\xe3\x59\x49\x9a\x45\x0b\xeb\xdb\x82\x1e\xb3\xae\x2d\x14\xd6\xb7\x85\x4b\xb2\xae\x2d\x14\xd2\xb6\xe4\xf9\x6f\x9b\xb8\x6f\x5e\x7e\x05\x92\x1f\x2b\xf1\xd2\x47\xb8\x9b\x89\xa4\xe2\xb2\xdf\xda\x01\xc9\xf4\xf7\x44\x7d\xf1\x6a\x64\xc1\x6b\xf6\x97\x18\xe7\x1c\x6d\xa1\x5f\xfa\x61\x83\xc3\xa0\x07\x10\x88\x93\xfc\x5c\xea\xa7\x57\xae\x4e\x34\x29\x57\x3f\xbd\x44\x1b\x7c\xe6\x19\xd8\x90\x50\x1a\x63\xeb\x03\x8b\xff\x61\xd9\x5f\x89\x28\xdf\x35\x20\x1f\x2d\x3f\x51\x5f\xdd\xff\x48\x2f\x3e\xf6\x94\x7d\xbc\x66\xdb\x91\x7a\x94\xd5\x7f\xa7\xed\x58\x43\x44\xa6\xf5\xbb\x41\x25\x3a\x13\x2c\x3a\xbc\x49\x5a\x32\xda\x85\xba\x00\x82\x5e\x40\x59\x42\x76\xf3\xc6\x99\xcf\xc2\x68\x1d\xf5\x59\xd0\xe8\x19\xac\x7e\x86\xe3\x55\xfd\x0c\x27\x07\x22\x7c\xd8\xd3\xe1\xc2\x7c\x38\x6c\x87\x40\x18\x13\x1c\x86\x8f\xb3\xde\x97\x43\x5d\x05\xb0\x0f\xfe\x50\x68\x66\x23\x67\x28\x44\x82\xfb\xc4\x2d\x5d\x25\xaf\xda\x84\x20\x21\xda\xaa\x0d\x8c\xad\x34\x5e\xba\x79\x99\x36\xd8\xd3\xc0\x92\x8a\x62\xaf\xba\x7a\xe8\x6f\x8a\x30\x12\x0f\x53\x95\x05\x7b\xea\x0e\xf1\x36\x4d\xbe\xa5\xbe\xc6\x1e\x97\xd6\xf6\xc8\x25\x12\xf2\x8a\xde\x37\x42\x6b\x84\xc6\x29\xdb\x65\x49\xc0\xd1\x45\x36\x83\xf2\x74\xf5\xcf\x40\x33\x89\xf0\x19\xbd\x33\xbf\x2d\xbe\xaf\xc2\x96\xfb\xd9\x20\x2a\x0b\xb8\x1f\x41\xa1\x79\xc3\xb3\x82\x63\xbf\x0f\x82\x1c\xf5\xc3\x73\xf2\xa5\x68\x63\xc0\xb5\x65\x06\x59\x91\xac\x47\xe5\xea\x37\x18\xe0\xb3\x74\x1a\x9f\x57\xfd\xd0\x82\xd7\xe7\x3b\x93\x1f\xcf\xbc\x40\x43\x79\x5c\x97\xc4\x1c\xc3\xff\x6e\xcb\x11\x57\xa1\x6b\xca\x1f\x63\x59\x47\x6a\xf1\x7b\x42\x64\x1e\xe3\x7a\x06\x0d\xce\xbc\xd0\x92\x2e\x73\xb9\x1c\xb2\xbf\x1b\x96\x73\xfd\x1f\xc0\x31\x1e\x89\xb1\x04\x9b\x9b\xa4\xd0\xb7\x8e\x6d\x8a\xc9\xbf\x6b\xc6\x84\x99\xc4\x65\x5e\xc7\x0e\xcf\x63\x2f\xc9\xc2\xaf\x98\xf5\x2a\xe2\xff\x58\xcd\x7e\xf5\x91\x95\xe0\x50\xb2\xcd\x1a\xb3\x24\x1b\xc8\x59\xa3\x0d\x17\x74\xa1\x8d\xcd\x03\xa6\x91\x66\x70\x5a\x3e\x5d\x23\xf1\x10\xec\xbe\xe1\x19\x3f\xf7\xd9\xa1\x65\x82\x45\x2c\x9b\x63\xaf\xef\xc2\x08\x99\x28\x23\xde\x75\xb5\x42\xe2\x44\x6f\xd8\xe8\x76\xd3\xf6\x2a\x84\xc9\x26\x19\x55\xc2\xe7\x62\xb8\x55\x4d\x56\xa8\x08\x2d\x2e\x38\x91\xc5\x0c\xb7\xba\xe4\x5b\x98\xba\x70\xa9\x5d\x0f\x3d\x92\xaa\x49\x12\xf5\x5b\xc6\x1a\xff\xd4\x1f\xdd\x48\xe0\x92\x54\x66\xb6\x2b\xda\xb0\xed\xd3\x12\x85\xbb\x5e\x71\x65\x14\xcb\x27\x75\xd4\x82\x97\x47\x54\x41\x0c\x48\x60\x9c\x86\xbb\xc3\x24\x1b\xbc\x38\x7c\x03\x46\x3a\x08\x26\x5c\x3a\xf5\x1f\x59\xd9\xae\xea\x2f\x80\x1a\x69\x73\x1d\x7c\xb9\x0e\xea\xd0\xf2\x3b\xc1\x2d\xfc\xc7\x5f\xac\x05\x41\x7a\xcc\x7f\xc4\xda\x26\xca\xd0\x32\x23\x0c\x2b\xf6\x33\x1d\x4a\x29\x64\xe0\xd9\xaa\xf9\x3f\x51\x1b\xbe\x4a\x02\x50\xe2\x94\xd5\x66\xf7\xd5\x00\x5a\xed\x90\xc3\x6d\xf9\x6b\xdc\xa6\x1c\x6c\x15\x9f\x57\x4c\x0e\xfa\x88\x18\x1f\x2c\xce\x0e\x1a\xa4\x22\x5d\x61\x5b\x23\xa9\x5d\x59\x24\xdd\xaa\x1f\x4f\xca\x9b\x97\x4e\x0a\x88\x77\x44\x05\x90\x49\x0f\x38\x4a\x06\x03\x91\x35\xb6\x71\x31\xab\xb5\x56\xda\xcf\xd2\x48\x0c\x97\xdf\x50\xe2\x29\xd1\x66\x7a\x3f\x6d\x8a\x4e\x33\xf8\x25\xb3\x74\x5a\xbc\xed\x16\x93\x34\x29\x9b\x8d\x4e\xa3\xf5\x7e\xe3\xb4\x75\xda\x0a\x77\x29\x9c\x27\xdc\xad\xde\x37\xda\x84\x64\x70\xd5\x7f\xd5\xe7\x0d\xc4\x11\x2f\xce\x1d\xa8\x6d\x76\xea\xf3\x07\xfa\xc6\xd3\x36\xfa\x4f\xd4\xe8\xb9\xa6\x54\x5b\x28\xdb\x52\x6a\x1f\x08\x8e\x76\xd4\x64\x0f\x3e\x10\x22\x60\xcc\xe6\xee\x24\x7f\xa1\x41\x42\x88\x3f\x77\x82\x66\x69\x5a\x83\xde\x74\xb6\x5a\x9f\x23\x54\xd1\xf7\x5f\x57\xa8\x22\xb3\x92\x7b\x79\x2e\x67\xc4\x8f\xd6\x06\x3d\x30\x1f\xf0\x1a\x26\x1f\x34\xb7\x13\x0b\x77\xa3\x8b\xea\x22\x76\x3c\x79\xe2\xc2\xb1\xe8\xaa\xf3\x22\x76\x18\x68\x2e\xb0\x12\x0c\xa5\x1e\xfa\xdf\x82\x9a\xf3\x80\x6b\x58\xb6\x05\xce\xbb\x16\xf6\xf7\x1b\x41\xcd\x79\xb0\x35\x2c\xdb\x02\xd6\xb8\x1e\x74\x50\x71\x1e\x64\x84\xf4\x45\xa2\x27\x54\xb7\xdb\xee\x99\x0b\x1c\x55\x41\x12\xb3\xf2\xd5\x2a\x2e\x9a\x86\x5e\xc0\x6a\x15\x83\x8b\x7a\x1d\x5c\x85\xf0\x2c\xfd\xf0\x75\x9d\xa5\x4a\xfc\x1d\x4f\x2b\xaa\xb6\xc1\xfe\xf2\x3a\x49\x44\xd1\x44\x5e\xae\xcd\xcc\x63\xd2\x99\x88\x26\x68\xf2\x99\xb0\xbf\x9b\x78\xc6\x60\x22\xba\xc3\x12\x30\xfa\x04\xbe\x1b\x25\x16\x93\xd2\x85\x84\x7e\x9f\x9c\xee\x90\xcf\x5d\x17\x39\x8c\xed\xd6\x7c\xff\xf4\x49\x9b\x2b\xd0\xf2\xbe\xcc\x86\xc9\xf9\xd4\xb4\x04\xb5\x3d\x3c\x93\xbf\x81\xd9\x7f\xc3\x92\x8c\x54\x6f\xd1\xa6\xb3\x3c\x29\xbd\x66\xf1\x05\x36\x33\x27\x2d\x3f\x88\x2b\xfa\xbb\xb5\xc3\xae\xd9\xb5\xc1\x61\xb7\xa2\x44\xb9\x08\x0b\x57\x4a\x2d\xd8\x2b\x4a\x5e\x26\xfd\x77\x66\x29\xd5\x70\x5d\x71\xab\xba\xf8\x04\x50\x77\x62\xec\x53\x29\xc8\x16\xce\xd9\x83\x3b\x0f\x8a\x3f\x84\x1d\x33\x74\x52\x63\x07\x8e\x57\xf3\xf3\x06\x21\xa2\x01\x03\xe3\x46\xd7\x95\x9a\xf3\x80\xdb\x4a\x5f\x84\xf0\xb8\x0e\x6a\x44\xaf\xaa\x8b\x36\xfb\x20\xae\x0a\x73\x0c\x4a\x43\x7e\x3e\x5e\xef\xd0\x03\x94\xc0\x00\x0c\x2a\xa8\x16\xdd\x24\x1b\x88\xcb\xc3\x61\x33\x69\xb1\x7f\xec\xb2\x8d\x16\xa8\x60\x93\xcc\x60\xf7\x7d\x8d\xab\x16\x1b\xba\x23\x5e\x1c\xce\x32\x83\xb5\x78\xfb\xc3\x00\x92\x16\x6d\x8c\x43\x78\x9f\x9c\xb2\x5d\xd5\x27\x1c\x43\x8b\xba\x58\x18\xcc\xce\xb7\x1c\x6f\x26\x59\x51\xf2\xac\x2f\xda\x14\x5b\xcc\xd0\xef\xdb\x62\x66\xfe\x90\x43\xaf\xa2\xaa\x59\x8e\x14\xfd\xcc\xc4\x0c\x52\x22\xec\xe7\xb9\xcc\x9b\xdf\x3c\xe7\x19\x68\x9a\x79\x9a\xda\xd0\x2c\xbc\x60\xdc\x9e\xa7\x6f\xf0\x98\xd1\xa1\xd5\x6a\xf1\x9b\x85\x48\x87\x6d\x00\x66\x87\xa6\x3e\xf9\xbd\x1f\x19\x6f\x4e\x3d\x04\x10\x2e\x8d\x78\x91\x35\x4a\x94\x58\x25\x59\x52\x26\x3c\x4d\x0a\x31\x60\x1d\x56\x4c\x27\xa0\x75\xa3\x35\x54\x0f\x62\x80\x43\xd3\x8b\x08\x33\x78\xf0\xc0\x09\xea\xd4\xef\xdd\xdd\x5d\xf6\x0d\xe2\xc9\x37\x8a\x90\x55\xca\xdc\x2c\xd9\x53\xfc\x0c\xe9\xc7\x87\xc1\x66\x18\x27\x82\x66\x31\xed\x01\x09\x6f\xe3\xb0\xe0\x6f\x33\x55\x0d\xdc\x15\xa0\x70\xcf\x76\xa1\x46\x17\x14\x66\x53\x5c\xa9\xe8\xd6\x1c\xab\xba\xea\xbe\xca\x45\x51\xa8\x61\x40\x20\x65\x91\x80\xfa\xa1\x27\xa0\x31\x83\x54\x11\xa6\x8b\x36\x68\x93\xbf\x61\x0f\x59\x65\x2c\xb0\x54\x66\xf4\x0e\x7f\xd9\xae\x21\xbf\x3a\xb8\x04\x19\xa0\x37\x5c\x4a\x00\x3f\x2a\xc4\x36\x3b\xbf\x0d\x87\x0c\x6e\x3c\xb7\x38\x34\x20\xa5\xb6\x5f\x37\x64\x5f\x47\xa8\x64\xf4\x06\x31\x4c\x36\xbb\x36\x14\x95\x2c\xae\x1e\x5f\xe1\xc7\xf3\x7b\x1a\xff\x5e\xb3\x41\x6e\x6c\xc4\xfb\x60\x97\x54\xb1\x11\xa1\x1c\x3f\x43\x24\x5b\x41\x80\x21\x87\x0e\x46\xb4\xc7\x7e\xa9\x8b\x22\xa4\x6b\x2c\xeb\x42\xe2\x79\x90\x84\x34\x00\x2b\x68\x88\xbf\x23\x9f\x11\x50\xe5\xd5\xd2\x0c\xdf\x49\x44\xcf\xce\x77\x12\xd1\x5b\xed\xbb\x89\x98\xc5\x5f\xd5\x39\xc4\xfc\xdb\xfd\xa5\x10\x25\xf2\xa3\x3a\xbe\x97\xdb\x71\x5f\xb4\xa2\xab\x97\xb4\xae\x13\xaa\x5c\x5b\x78\xe7\xb5\xf0\x2a\xd1\x8f\x2a\x20\x2b\xf6\x52\x73\x56\x8c\x60\x8a\x33\x90\xa2\x0c\xa6\xc3\x4b\xcf\x24\xca\xc8\x4b\x9f\xcb\xac\x84\xa0\xfb\x51\x33\x87\xa0\x56\x75\xec\x44\xa3\x01\xac\xba\xee\x6c\xdb\x13\xfa\x78\x6b\xab\xc5\xea\xfe\x82\x53\xd9\xc6\x79\xac\xb6\xf7\xd1\x99\x2f\x19\x1d\xc1\x5d\x1a\x71\xcc\x37\xd5\x28\xf9\x39\x51\xb6\xf3\xf3\x98\x19\xc7\x7c\x13\x8e\x5c\x14\x4e\xfc\x5d\xc7\xb7\x38\x45\x71\xc9\xcf\xbd\xec\x0e\xa7\x2d\xdf\x10\x92\x9f\xc3\xed\x81\x46\xb9\x15\xbf\x0b\x22\x34\xf6\x25\x77\x2d\xd5\xb2\xed\x06\xe3\x64\xd9\xf5\x16\xd2\xe6\x76\xb5\x06\x99\x74\x17\xac\x5c\xc9\x09\x96\x34\x32\x38\xc1\x92\x2f\x4f\x32\xc7\xbb\x4f\x30\xcc\xb0\xa2\xaa\xd3\x00\xa3\x08\x03\x6a\xe5\x53\xb8\x7c\xc4\x47\x75\xed\x7a\xc7\xc2\xa5\xac\xad\x82\x57\xf2\xf3\x1a\x28\x24\x43\x52\xa4\xd8\xa6\x47\x8a\x94\xf5\xa4\x4c\x31\xd7\x90\xe9\x35\x22\x1d\x83\x8e\x41\x34\x1a\x17\x4c\xd9\x75\x0a\x1f\xaf\x7f\xfb\x1a\x1f\xaf\x5a\x2c\xef\xb8\x05\x5e\x14\xc9\x39\x98\xe5\x39\x22\x87\xc4\xac\xf2\x48\xdd\xc4\x47\x6a\x78\x2f\x79\x0f\x55\xed\x6b\x4e\xef\x18\xc5\x21\x5b\x38\xea\x8e\x4a\x32\x5d\xcd\xf0\x5b\x4b\xf1\xe2\xd8\x04\xde\x03\xc8\x04\x23\x23\xae\xaf\x34\x2c\x85\x5f\xf8\x98\xac\xf2\xe4\x7f\xbe\xc4\xfe\x98\x2f\x31\x17\x7a\x92\xde\xe4\xf8\xc5\x64\xe7\xe9\x23\x01\x73\x89\xc5\xb4\x39\x51\x9f\xa4\x25\xd1\x97\x82\x9f\x7f\x80\x31\x5a\xa5\xda\x2a\xb0\x9e\x02\x3a\xe2\x0c\xa8\x2a\xc0\x92\x2c\x13\xb9\x9f\x1d\x0b\x3f\x84\x49\x11\x6a\x93\x94\x2d\x75\x41\x39\x43\x26\x33\x00\xcc\xff\x83\x7d\xc5\x6e\x2c\x30\x02\xa2\x24\x9d\xed\x9a\x45\xeb\x7a\xdf\x6d\x6d\xdc\x01\x9c\x8b\x5d\x75\xfb\xd1\x63\xcc\x3c\x00\x5d\x8f\xb7\xa0\xca\x51\xf2\x34\x73\xeb\xe4\xc5\x76\x20\x9e\x76\xba\x02\x6d\xaf\x03\x5c\xad\xc5\x9d\x10\xe2\x90\xaa\x4a\xef\x8f\xa8\xc0\x73\xd3\xbb\xf6\xa2\x82\x1a\x78\xcd\x8f\xb4\xdd\x36\xfd\x41\x2e\xee\x6d\xb2\x5f\xd7\x8e\x05\x04\x9b\x26\xb3\x35\x76\x37\x35\xed\x06\x6d\x96\x6d\xd6\xaa\x4c\xc8\x43\xbe\xd0\xad\xc2\x87\xda\x45\x56\xdd\xce\x05\x06\x40\x19\x87\xa0\x3a\x41\x4f\xbf\x0d\xe1\x1b\xea\x79\x16\x87\xed\x01\x5c\x8f\x7d\x51\x3b\x84\xfb\xdf\xed\xdf\x1d\x5b\x61\x40\x86\x6c\x85\x1d\xc8\x8d\x98\x0b\x85\x5c\x71\xd6\x42\x21\x12\x1a\x1b\x9a\x35\x8b\x77\x80\x61\x55\x68\xec\xab\xcf\x30\x8c\xba\x9c\x1d\x48\x23\x43\xc6\xe5\xfb\x8d\x3f\x19\x97\xaf\x92\x71\xf9\x53\xf1\xf0\xa7\xe2\xe1\x0f\xa0\x78\xd0\xc9\x26\xe6\xc5\xe4\xff\x7e\x33\xa8\x38\x17\x38\x86\xc8\xf8\xb2\x8c\x74\x80\x8a\x86\x7f\x6e\x23\x75\x23\xfc\x31\xe1\x98\xe3\x58\xec\x9a\x7e\xf4\x93\xbb\x55\x93\x05\x45\x44\xb1\xa1\xb8\x16\x04\xb3\xe6\x8a\x07\xb6\x59\xd3\x21\x80\x49\x18\x68\xd9\xfb\xcf\x1f\xe0\x6d\xf0\xa7\x96\xe6\x4f\x2d\xcd\x9f\x5a\x9a\xdf\x50\x4b\x93\x49\xe9\x45\x00\x53\xbf\x9b\x5e\x14\x7f\xb5\xec\x2e\x2a\xb1\xb5\x2e\x59\x46\xa9\xa3\x8d\x53\xeb\x75\x3a\x58\xe1\x0e\x55\x3a\xef\xec\x5d\xf3\x7f\x50\xa3\xa3\x4d\x7e\x97\x50\xe8\xe8\x65\xb8\xa9\x3e\xa7\x12\xea\x0b\x14\x0e\x60\x2c\xb4\x9c\x82\x87\x93\xaa\x77\xa2\xdf\x89\x8a\x3a\xba\x1e\x98\x66\x2b\xd2\xcb\xe1\x70\x58\x88\xd2\x67\xd7\x07\xbc\xe4\x95\x6e\xf4\x3a\xaa\x4b\x11\x2a\x74\x25\xb6\x6c\x75\xc7\x7c\x42\xbc\xfb\xd5\x23\xa2\x2a\xd4\xa7\x2d\xde\x3b\x04\x70\xf6\xdf\x6e\x50\x49\xf1\x82\x97\xfc\x45\x92\x97\x57\x73\x46\x65\x63\x8e\x68\x87\x2b\xbf\xd4\xf6\xfb\xff\x1c\x1f\xbe\xd5\x12\xf6\x64\x78\xd5\xac\xcc\xbb\x0a\xa3\x05\x74\x78\x61\x3b\xac\xbb\x48\x97\x41\x63\x8c\x5c\x07\xf3\x9c\x42\xa0\x33\x70\xa4\x7f\x23\x07\xc9\x30\x01\xaa\x61\x40\x08\x63\x51\x6e\x92\x2c\xaa\xff\x20\xe5\xc5\x36\xfb\xdb\x86\xcd\x09\x31\xcc\x88\xc2\x69\x98\x35\xc3\x65\x70\xcb\x44\xd7\x55\x8f\xbe\x1a\xf7\x86\x06\x7d\x51\x75\xb6\xe1\xff\x3d\x23\xfd\xeb\xd8\xd6\xd6\xcd\x51\x9d\x3a\x40\x48\xb0\x89\xad\xc1\x63\x78\xc5\xa9\x6e\x76\x59\xb8\x1b\x56\x17\xb5\xbe\xce\x0e\x86\x86\xb6\x26\x70\xef\x23\x63\x53\x26\xbc\x14\x83\x36\x1b\x25\x03\x8c\xd7\x8b\x07\x40\x8b\x74\x5c\xeb\x52\x32\x0e\x9e\x3f\xc3\x94\x17\x23\x26\x87\x6c\x9a\x81\x5d\xee\x00\xa5\x84\x59\x59\x0d\x91\x63\x62\xd3\x41\x48\x80\x1a\x04\xa3\x4b\x38\x91\x26\xa1\x46\x83\xf7\x0a\x99\x4e\x4b\xe1\x19\x99\x47\x33\xa5\xf8\x0e\xc1\x26\x1c\xbe\x5b\xee\x8a\xa3\x12\xe6\x42\xe3\x25\xff\xab\x3e\x4f\x7f\xb5\x4f\x11\x7a\xca\x8c\x27\x01\x55\x2e\xa2\xab\x71\xa4\x6d\xb7\xf4\xfd\x49\x20\x93\x43\x4d\x55\x55\xd6\x8e\xcc\xba\xae\xbe\x29\x77\xfe\x9a\x86\x70\x59\x71\xe1\x5a\x75\x05\xcd\x5f\x66\xf6\x6d\x9c\x5c\x61\x92\x76\xd5\xe0\x19\xf5\x45\x9e\x43\x33\xef\xdf\x0f\x31\x8d\x3d\xad\x20\x9f\xf3\x62\x66\xdb\xd4\xc2\xb8\xa6\xeb\x57\xc9\x22\x4a\x1d\xe9\xf5\xc1\x83\x6a\xb7\x80\xca\x4f\x59\xa3\xb1\xa0\x5b\xb8\x6e\xe6\x1d\x2c\x82\xc9\xa4\x4b\x85\xcc\x95\x3e\x0d\xd2\xc0\xbd\x14\x43\xf3\xeb\x5a\x52\x67\x43\x13\xfc\x15\xe0\xfd\xd5\xe2\x40\xe4\x3c\xfb\xfd\xf8\x2e\x07\x1a\x3b\x63\x90\x42\xf4\x74\x08\x1a\xad\xad\x0a\x49\x84\x1d\x33\x05\xd5\xc3\xb6\xfa\xbf\x36\x34\xdf\x46\x20\xd7\x11\xda\x75\x07\x66\x11\x86\xb3\xfb\x12\x56\x11\x15\x73\x08\xcb\x88\x10\x6b\x08\xfb\x2d\x30\x86\x70\x58\x44\x8c\x21\xdc\xc7\x15\x8c\x21\xee\x22\x94\x0b\xbd\x1a\x0d\xef\xbb\x54\x87\x18\x36\x74\x89\x1e\x75\x7c\xd1\x94\x1b\xf5\x84\x77\x5c\xec\x67\x72\xf8\x15\x3f\xe0\xac\x35\x48\xc1\xa7\x4f\xcc\xd5\xf7\x1c\xc1\xc2\x36\x5e\x21\x3d\x5e\xf5\xf3\x0d\x7d\x82\xe9\x7d\xf4\xe0\x01\xe9\xd8\x0b\x52\x45\xfa\xb4\x1a\x8b\x4a\x77\xcb\x45\x5c\xfd\x9c\x91\x57\x70\x1c\x03\x51\x94\xb9\xbc\x5a\xb8\xcf\xde\xfa\xd4\x74\x18\xac\xe1\x32\x3d\xd1\x85\x0d\x1d\xdc\xf0\x2b\x1e\xe8\xea\xbe\xd4\x8d\x93\xd6\xaf\x1b\xa7\x0f\x73\x15\xdb\xa0\xc9\x92\x71\x36\x7c\x4c\x74\x71\x4c\xe8\x67\x2f\x7c\xcc\x58\xb3\x9f\x15\x1d\x1e\xc1\x26\x5b\x87\xba\x0b\xc2\xbb\x49\xd3\x8e\x8f\x8e\x65\xd5\x81\x02\xdd\x98\x08\xab\xbb\xcd\x6a\xb9\x5f\xf2\x22\xa8\xec\x8f\x7d\x2f\xd1\x4d\xb2\x63\xc2\xeb\x84\x70\xcf\xcc\xf3\xc9\xf5\x21\xcc\x61\xad\xbc\x43\xb6\x0b\xe2\x17\x23\xbe\x35\x5a\xa9\x66\xe4\x7d\xd6\x6c\xe9\xa5\xfa\x05\xf5\x5c\x84\x3e\xcf\xf5\x20\x0d\x7c\x47\xbd\x9f\xed\xea\x2c\xb7\xdd\x9f\xd5\xa5\x5a\x5f\x67\xe6\x3c\x33\x9e\xe9\x15\x57\x5c\xef\x98\x7f\x10\xac\x98\x62\xd4\xa7\xfc\xaa\x1c\x25\xd9\xb9\xa2\xfb\x85\x65\xb1\x80\x05\xce\x73\xd1\x27\xec\x32\x1f\x42\xf2\x2b\xa1\x2a\x53\x46\x3b\xb2\x50\x35\x74\x24\x76\x3e\xbc\x63\x58\x77\x40\x82\xb3\xea\x91\x67\xda\x6f\x2d\x5d\xd3\x00\x96\x38\xb0\x37\x8c\xc1\xb4\x55\x1f\x83\x69\xab\x3e\x08\x53\xc5\x0a\x63\xab\x6a\xaa\xc1\x7c\x0b\x0b\x53\x2f\xb4\xb1\x88\x53\x83\xad\x55\xc8\xc1\x56\xb7\x06\xdd\x98\x4f\x0e\x74\x65\x77\xfc\xe9\x94\x42\x83\xc4\xad\xdb\x5a\x24\x6e\xcd\x35\xf9\xf0\x82\xc1\x78\xc3\x57\x1f\xec\x10\xeb\xec\x19\x9d\x85\x48\x60\xf3\x61\x3f\x56\xfc\x9c\x75\xc8\x41\x38\xd7\x15\xf7\xe6\x55\xac\x3d\x58\x8d\xc5\x07\xab\x72\x56\x74\xa0\x86\xbb\x8f\xbd\xa6\x1d\x7e\xbb\xfa\xef\xbc\x28\x38\xf1\x97\x51\xac\x9d\x7e\xbb\x44\x5e\x34\xcd\xd6\xdc\xc0\x98\xf5\xf3\x25\xba\xaf\x77\x41\xc8\x4b\x32\x5e\x8d\x16\xcd\x5f\xfc\xdf\x1f\x3d\xf4\x19\x6e\xbb\x2d\xa2\x88\x55\xe0\xcd\x43\x96\xca\xad\x69\xc5\xd9\xda\xeb\xa2\xcd\x1a\xea\xb9\xd0\xa1\x18\x15\xac\x60\x6b\x39\x08\x97\x1d\x39\x2d\x3b\x72\xd8\xe9\xc9\x69\x36\xe0\x79\x02\x81\x96\xdc\xaa\xe2\x3b\xc2\x36\x23\xdb\x5e\x31\xc7\xf1\xde\xd4\x24\xdd\x05\xed\x35\x76\xac\x88\x89\x8e\xb7\x3a\x1e\x59\xde\x66\x21\x07\x39\x87\x86\xbb\x65\xac\x32\xa3\x2b\x58\xfe\xd0\x9b\x50\xef\x55\xbc\x22\x3e\xeb\xdb\x74\x27\x49\x98\x80\x70\xab\xb6\xc3\xad\x0a\xab\xc6\xf6\x64\x9b\xec\x49\x0d\xa3\xb1\x8c\x75\x12\xab\xb3\x50\xb2\x08\x5a\xfb\x4e\xae\xb7\x54\xaa\xb6\x0d\x24\x25\xb7\xb5\x58\x62\x71\x03\x6a\x3c\xe5\x75\xf6\xd3\x5a\x98\x7e\x87\x26\x4e\x06\xe2\x5c\x83\xec\xd5\xe1\x7d\xad\x16\x53\x34\x59\x4f\xdd\x38\x9a\x21\x7f\xe9\xee\xf0\x02\xba\x0a\x78\xc4\x3a\x23\x71\x55\x95\x30\x8a\xf5\x4b\xf8\x45\x4c\xb9\xde\x19\x46\xac\x62\xab\x4e\xf6\xc6\x06\xf3\x88\x44\x58\x88\xcc\xdc\xc8\xc1\xc9\x2c\x3f\x5e\xc7\x0d\xde\x0d\x5e\x87\x66\x63\x9b\xf3\xcc\xc6\x9c\x19\x87\x06\xf8\xcb\x2f\xcb\x9a\x90\xc5\xcd\x22\xa2\x00\x03\x63\x32\x6a\x4a\x06\xf4\x68\x4e\xbc\x07\x37\xe4\xf3\x54\xf6\x78\xda\x62\x1f\xd7\xbf\xfd\xf6\xfe\x1a\xfb\x96\xfd\xd7\x30\x49\x21\x80\xda\x45\x22\x66\xec\xbf\x93\xfe\x07\x5e\x14\x2c\x4d\x7a\x39\xcf\x21\xf0\x16\x52\x0d\x48\xa5\x07\xab\xad\xcf\x5a\xc1\x32\xc1\x21\x70\x56\x92\x93\xcc\x97\xfa\xe5\x54\x74\x01\xf6\x85\xc8\x41\xd9\xbc\xd9\xdd\xdc\xea\xfe\x00\x9f\xd2\xa4\x2f\xb2\x42\xa8\xbf\x9f\xcb\xc9\x15\xe6\x31\x6e\xf6\x5b\x6c\x6b\x63\xf3\x09\x7b\x29\x06\x22\x4f\xfa\x92\xfd\xbf\xc9\x85\x4c\x25\xf4\x0a\xe1\x85\x93\xde\xb4\x94\xea\xf1\xf2\xad\x6a\xf9\x4e\xe4\xe3\x04\xf5\xd8\x49\xc1\x46\x22\x17\xbd\x2b\x76\x9e\xf3\x0c\xe4\xf9\xc3\x5c\x40\x42\xb8\xfe\x48\x3d\xb3\xda\x20\xbf\xcf\xae\x98\x1a\xb4\xcc\x98\xec\x95\x3c\xc9\x30\xd0\x58\x5f\x4e\xae\x14\x3c\x08\x2b\x9b\x14\xac\x90\xc3\x72\xc6\x73\x9c\x2d\x2f\x0a\xd9\x87\x97\x0b\x1b\xc8\x3e\x68\x20\x39\xea\x4a\x92\x54\x14\xea\x41\x21\xd8\x37\xc7\xba\xc5\x37\x2d\xe8\x67\x20\x78\xaa\x00\x26\x98\xe3\xce\x94\x42\xa0\x0e\x39\x85\xfc\x88\xb0\xf3\xa0\x5f\x4f\xb2\x7e\x3a\x85\x90\x67\xa6\x38\x4d\xc6\x89\xee\x44\x35\x87\xc5\x51\x73\x56\xa0\xa7\x05\x28\xba\x27\x57\x6d\xc4\x63\xf5\xaf\x80\xf9\x4d\xa6\xbd\x34\x29\x46\x6d\x36\x48\x0a\x5c\x29\xd1\x66\x85\xfa\x08\x4b\xdd\x56\xb3\x59\x97\x39\x2b\x44\x0a\x83\xeb\xcb\x49\x22\x0a\x13\x4b\xd7\x8c\xb1\x8d\xd9\x12\xa5\x5a\xa7\x71\x52\xea\xe5\xc2\xa4\x65\x23\x9d\x1f\xd1\xce\x27\x81\x51\x0d\xa7\x79\x96\x14\x23\x4c\xc2\x35\x90\xac\x90\xd0\xaf\xc2\x68\x13\xb2\x6d\x28\xd3\x14\x73\xac\xf5\x65\x36\xc0\xd4\xde\xdb\x7a\x17\x4f\x46\x82\xf1\x9e\xbc\x10\x30\x2d\xc4\x84\x4c\x96\x49\x5f\xe8\xc4\x8d\x49\x81\x83\xc1\x9d\xd6\x45\xc5\x88\xa7\x29\xeb\x09\xbd\x7c\x62\xa0\x16\x9b\xfb\x33\xcb\xd5\x30\xf4\xcb\x33\x65\xea\x04\xa9\x7e\xc3\x19\x77\xcd\x38\x5e\xed\xb3\xe3\xc3\x97\x27\x3f\xef\x1d\xed\xb3\x83\x63\xf6\xee\xe8\xf0\xa7\x83\x17\xfb\x2f\xd8\x37\x7b\xc7\xec\xe0\xf8\x9b\x36\xfb\xf9\xe0\xe4\xd5\xe1\x8f\x27\xec\xe7\xbd\xa3\xa3\xbd\xb7\x27\xff\x66\x87\x2f\xd9\xde\xdb\x7f\xb3\xff\x3e\x78\xfb\xa2\xcd\xf6\xff\xf5\xee\x68\xff\xf8\x98\x1d\x1e\x29\x68\x07\x6f\xde\xbd\x3e\xd8\x7f\xd1\x66\x07\x6f\x9f\xbf\xfe\xf1\xc5\xc1\xdb\x7f\xb2\x67\x3f\x9e\xb0\xb7\x87\x27\xec\xf5\xc1\x9b\x83\x93\xfd\x17\xec\xe4\x10\xfa\xd4\xd0\x0e\xf6\x8f\x15\xbc\x37\xfb\x47\xcf\x5f\xed\xbd\x3d\xd9\x7b\x76\xf0\xfa\xe0\xe4\xdf\x6d\x05\xeb\xe5\xc1\xc9\x5b\x05\xf9\xe5\xe1\x11\xdb\x63\xef\xf6\x8e\x4e\x0e\x9e\xff\xf8\x7a\xef\x88\xbd\xfb\xf1\xe8\xdd\xe1\xf1\x3e\xdb\x7b\xfb\x82\xbd\x3d\x7c\x7b\xf0\xf6\xe5\xd1\xc1\xdb\x7f\xee\xbf\xd9\x7f\x7b\xd2\x65\x07\x6f\xd9\xdb\x43\xb6\xff\xd3\xfe\xdb\x13\x76\xfc\x6a\xef\xf5\x6b\xd5\x9b\x02\xb7\xf7\xe3\xc9\xab\xc3\x23\x35\x50\xf6\xfc\xf0\xdd\xbf\x8f\x0e\xfe\xf9\xea\x84\xbd\x3a\x7c\xfd\x62\xff\xe8\x98\x3d\xdb\x67\xaf\x0f\xf6\x9e\xbd\xde\xc7\xde\xde\xfe\x9b\x3d\x7f\xbd\x77\xf0\xa6\xcd\x5e\xec\xbd\xd9\xfb\xe7\x3e\xb4\x3a\x3c\x79\xb5\x0f\x93\x54\x35\x71\x98\xec\xe7\x57\xfb\xea\xab\xea\x75\xef\x2d\xdb\x43\x92\x73\xf8\x92\x3d\x3f\x7c\x7b\x72\xb4\xf7\xfc\xa4\xcd\x4e\x0e\x8f\x4e\x6c\xeb\x9f\x0f\x8e\xf7\xdb\x6c\xef\xe8\xe0\x58\xad\xcc\xcb\xa3\xc3\x37\x30\x53\xb5\xba\x87\x2f\x55\xad\x83\xb7\xaa\xe9\x5b\x4d\xbb\xd4\xca\xfb\x1b\x74\x78\x04\xbf\x7f\x3c\xde\xb7\x30\xd9\x8b\xfd\xbd\xd7\x07\x6f\xff\x79\xac\x1a\xeb\xb9\x9a\xfa\x6a\x93\xd7\xc1\xba\x22\x29\x9e\xe5\x72\x56\x60\xa8\x48\x64\xd8\x30\xb2\x1e\x46\x59\xb3\xea\x12\x88\x91\xa8\x2b\x98\x83\x1f\x56\xd9\x01\x88\xa9\xcc\xce\x85\x09\xf0\xac\x81\xab\xdb\xea\x7d\x63\x7f\x70\x0e\x31\x48\x4f\xf2\x64\xa0\x1f\x9d\x2f\x93\x5c\x0c\xe5\x65\xe3\x14\xdb\x96\xd8\xea\x85\xce\x72\x0f\x36\x11\x6b\x31\xeb\xd5\x68\x27\xce\x9a\x95\x3d\xdc\x65\x9b\xc8\x62\x2a\x4e\xd4\x4d\xf2\xc1\x03\x96\xf1\x8b\xe4\x9c\x97\x32\xef\x4e\x0b\x91\xef\x9d\x43\x2e\x5f\x6d\x94\x16\x05\xfb\x3e\x39\x35\xb6\x6a\xc8\x7c\x56\x47\xb9\x89\x2c\x21\x64\xf3\xb6\x19\x94\xed\x73\x78\x9c\xf4\x73\x59\xf2\xe2\xc3\x0b\x9d\xec\xab\x39\xcc\x9c\xdf\x09\x5a\x5a\xb9\xc4\x22\xac\x6a\x9c\x6a\x3a\x86\xd4\x06\xdc\x0f\x38\x4f\xf3\x35\xe1\xc3\xd7\x02\x74\xca\x72\xdc\xd2\xee\xbb\x5c\x8e\x93\x42\x74\x73\x01\xe9\x58\x9b\xad\x6e\x39\x12\x59\x34\x93\x40\x75\x54\x0c\xb4\xe3\x56\x1a\x85\x6a\x9a\x1d\x6f\xa2\xb5\x73\x34\xaf\xa1\xe5\xa7\x79\xdf\x36\x71\x63\xa2\x50\xa8\x21\xc0\xc2\xa4\x08\xd1\xee\xc3\x19\x61\x56\x76\x7f\x6b\x7d\x37\x12\x6d\xc0\x54\x4c\x27\xc0\x7e\xbc\x51\xdb\x7a\xc2\x8b\x0f\x0a\xbb\x3d\x14\xf3\x97\x1b\xf9\xa6\xb5\x6f\xd9\x73\xcd\x34\x30\x93\xf4\x6d\xc0\x0c\x2f\x20\x87\x8c\xb3\xb1\x28\x47\x72\xd0\x66\xe5\x88\x97\x8d\x82\xf1\xe2\x2a\xeb\x8f\x72\x99\xc9\x69\x91\x5e\xb1\x81\x62\x27\x14\xa3\xfe\x2d\xeb\x4d\x4b\xb3\x41\xfa\x4e\x1d\x27\x59\x32\x9e\x8e\x61\xfc\xcc\xa8\xd9\xba\x6b\xaa\xd7\xff\x42\xb0\xf8\xd7\xb8\x27\x72\x69\xf4\xfe\xdd\x1f\xcb\x24\x2d\x54\x81\x31\x26\x62\x1f\x5f\xea\x05\xbc\x66\xc3\x4c\x95\xe0\x26\x15\xa4\x60\x4d\x53\x0e\x33\x09\xb4\xf2\x0a\x57\xe4\x69\x15\xeb\xd9\xb6\x87\x20\x7a\x59\x14\xcb\x33\x12\xfd\x0f\x6a\xd7\xd5\x4c\xce\x93\x0b\x91\x29\xa4\x49\xc0\xde\x3b\xa1\x96\x92\xc0\x2b\xe9\xe9\xb0\xda\xf9\x30\x6f\x42\x7b\xd9\xd5\xb5\x05\x70\x22\xb1\xaf\x8e\xeb\x40\x31\x73\xea\x1b\x34\xb3\xb3\x7d\x26\x65\x2a\x78\x76\xcd\x78\x56\xcc\x20\xcc\xfe\xb6\x3f\x94\xa7\x40\x41\x2d\xba\x25\x85\x59\x9f\x66\xd0\x97\x3b\x04\xe7\x02\x5e\x67\x3a\x58\x71\x05\xff\xcd\xd8\x1e\x3c\x30\x35\xbb\xa5\x3c\x86\xd7\x32\x1a\xbd\x56\x00\xc3\x7b\xfa\x3d\x3e\x43\x98\xe9\xff\xb4\x01\x88\xaa\x97\xf6\x9f\xa2\x64\xcf\x8f\x8f\xe1\x99\x30\x55\x4c\x9b\x0d\x01\x2b\xe9\x72\x0b\x63\xdd\xb1\xfa\xfa\xee\x43\xcb\x6b\x0f\x84\x2b\xc5\xf1\x5f\xdb\x6e\xfd\x55\x3b\x17\x25\xc8\x26\x9e\xeb\xd1\x39\x5f\x11\x04\xd6\xb6\xed\x1c\x2d\x37\x59\x0e\xd4\xb3\xe9\xc4\x24\xb3\xdb\x34\xa7\x5d\xaf\xe9\xfb\x53\xa4\xc2\x20\x7a\x7f\x7b\x78\xb2\xbf\xcd\x36\xd9\x8b\xc3\x37\x3a\xf9\x34\x30\xc7\x86\xfc\x82\x6b\xc5\xb9\x28\xcd\x20\x50\x16\x68\x47\x00\x06\xa4\x64\xbb\xec\x02\x3e\x55\x4d\xdf\x9b\x9f\xa7\x6c\x5b\xfd\xa6\x6b\x7f\xa4\x91\x09\x8c\x68\x78\x2e\x32\xb4\x3d\xd3\x81\x75\x47\xb2\x28\x83\xcc\x0d\x37\x5a\xfe\x34\xb2\xfe\x16\x8d\x6d\x29\xf6\x5f\x59\xfd\x77\x76\x58\x66\xc2\xf1\x85\xc6\xa0\xee\x0a\xdd\x5e\x9d\xbc\x79\xdd\x08\x56\x5b\xd7\x34\x4b\xee\x7f\xed\x92\xa9\x7f\xfa\x64\xbf\xaa\xe9\xd7\x2d\x56\xd1\xcf\x65\x9a\x2a\xf6\x18\xdb\xde\x1d\xae\x2e\xb7\x58\xd8\x7f\xdd\x9a\x1d\x43\x29\xae\x9c\xbf\x6a\xeb\xeb\x7a\x1a\xac\x27\x07\x57\x6d\x76\x66\x6b\x9f\xb1\x59\x92\xa6\xac\xe4\x1f\x04\xeb\xab\xa7\x42\x29\x15\x28\x8c\xdf\x8c\xaa\x22\x76\x86\xdd\x9e\xc8\xc9\x19\xe6\x5e\x4f\x4a\xbd\x13\xf7\xbd\x5e\x9c\x9d\x98\x66\xc3\xba\xaa\x37\x6b\x34\x51\xcc\x92\xb2\x3f\xaa\x6e\x9f\x75\x07\xe4\x85\xd0\xdb\xb8\x4d\x3e\x3c\x3b\x7c\xf1\x6f\xfd\xa1\xb2\x83\x72\x96\x89\xfc\x45\xd8\x9b\x69\xf9\xff\x33\xe3\xa8\x6b\xee\x0d\x6f\x7d\x9d\x69\x9e\x8f\xcd\x78\x56\xb2\x69\x61\x29\x30\x3b\xeb\x5c\x9e\xc1\x23\xe7\xac\x73\x75\x86\x14\x1a\x9f\x28\xbc\x60\x33\xf5\x4c\x33\x9e\xba\x31\xba\x81\x87\x78\x2e\x39\xb1\x22\x50\x79\x21\xf2\x61\x8a\x01\xe9\x62\x8d\xba\xa6\x42\xd8\xe0\x5f\x0b\x5b\xfc\x2b\x6c\xf2\xef\x85\x4d\xfe\x6d\xfd\x39\xd7\x9b\x7c\x5a\xca\x4f\x88\x08\xad\xf5\x6e\x29\x8a\xb2\x69\x07\xfb\x90\xc0\x74\x7f\xff\xab\x35\xef\x34\xba\xe3\x18\x62\x6e\xfc\xf4\xb7\xea\xce\x24\xda\x19\xfd\x46\x07\xd2\xeb\xbc\x72\x20\xd1\x82\xb4\xe6\x40\xce\x27\xfe\x92\x34\x65\xbb\x36\x17\xcf\x83\x07\x0e\xf7\x49\x8d\x1d\xdd\xca\x51\x44\x1f\xc0\x83\x07\xde\x6f\x7b\xf4\xec\xfe\xde\xb7\x2d\x3f\x7d\x62\x3e\x5d\x85\xf3\x57\xfd\xec\x91\x5b\x42\x95\x2b\x26\x4c\xf1\xb3\x6a\x8e\xe6\x7e\x4a\x32\x30\xf8\x46\xe2\x83\x39\x75\xcd\x89\xf5\x56\x01\x49\x99\xb1\xc7\x55\x04\x2c\x95\x85\x28\x4a\x76\xf2\x42\xdd\x6d\x27\xf0\x5a\x4e\x32\xa0\x0e\x6b\x3a\x1d\x96\xbf\x4e\x49\xc1\x26\xb9\x28\xe0\x7a\x3d\x60\x23\xd0\xab\x8f\x92\x82\xfd\x47\xf6\xba\xdd\xae\x5e\xab\xf7\x8d\x93\x17\xf0\x58\x54\xf0\x1a\xa7\xf6\x89\x16\x5d\x61\xb4\x31\xee\x6c\x6a\xe6\x29\x4e\x05\x68\xcb\x36\x6b\x18\x6d\x7d\xa3\x65\x14\x13\xbc\x4c\xfa\xe1\xdd\x16\xe2\x17\x05\xd2\x0a\xcf\x98\x8f\x2c\xf4\x65\x94\x14\x08\xe5\xb9\xcc\x4a\x9e\x64\x22\xf7\x37\x32\xc0\xaa\x90\x76\x5b\x04\x8a\xe0\x4c\x30\x5e\xfb\xbc\x21\x37\x71\x04\xa5\x14\xa6\xd5\x1c\x9d\xee\x30\xc9\x0b\x83\x05\x60\x37\x87\x0b\x64\xe9\x8a\x23\x10\x2f\x13\x48\xe0\x3f\x12\x2c\x97\xb2\x84\x7e\x58\xd3\xe0\x51\x9b\x15\x23\x3e\x90\x33\x75\xf2\x54\x71\xeb\xee\xa9\x46\x06\xd6\x27\x51\x92\x61\x07\x54\x21\x17\x47\x52\x96\x44\x2f\x6d\x96\x95\xf2\x29\xc4\x71\x28\xc0\x05\xdb\x98\x54\xaf\xa0\x01\x6a\xb5\x63\xcb\xe4\x53\xd1\xbe\x1c\x8f\xa5\xcd\x08\x56\xce\xa4\xce\xf7\x20\x06\x00\xa2\xb8\x0b\x8a\xba\xb9\xa0\x7c\xab\x66\xfd\xf4\xd8\xe6\x50\xde\x61\x92\x0d\x9e\x43\xad\x18\x16\x6d\xb6\x6d\x0f\x96\x16\x9f\xa8\x43\x8e\x57\x7d\x52\x40\x62\x34\x14\x92\xa2\x1d\xb9\xc8\x73\x99\x17\x86\x72\x30\x99\x89\x80\x3d\x2e\xb4\x9d\xba\x89\xad\x31\x94\x39\x88\xb0\x73\xc1\x0b\xb0\x6b\xa6\xbc\xd2\x26\x98\xe5\x9a\x1f\xee\xb5\x40\xbe\x6e\x79\x3f\x6c\x95\x3a\x2e\x6b\x0e\x7d\x7c\x25\x72\xc1\x66\x82\x98\x06\x29\xfe\x2e\xb9\x10\x8a\x73\xf9\x06\x72\x6c\x7f\x43\x67\x02\x2f\x7c\xb5\xc4\xa2\x60\x70\xda\xcc\x33\xfe\xc5\xe1\x1b\x73\x33\xe5\x03\x8c\xd5\x6c\x66\xa0\x5e\x70\x3c\x17\x86\xb4\xbf\xd3\xd4\xab\xe9\x56\xf9\x01\x53\xd8\xd8\x7d\x71\xf8\xfc\xc7\x37\xfb\x6f\x4f\x7e\x79\x77\x78\x7c\x70\x72\x70\xf8\xf6\x97\x97\x87\xaf\x5f\x1f\xfe\x7c\xf0\xf6\x9f\xe6\x02\x2b\x74\xe6\x1a\xec\xe4\xa9\xed\x84\x6d\xdb\x4d\x33\x55\x05\x24\xaa\x09\x2a\x6e\xb9\x8a\x9b\x3b\x7a\x0d\xd4\x4b\x53\x23\x0d\xcf\xfa\xa2\x28\x65\x0e\x4a\x0a\xa0\x76\x1a\x58\xce\xb3\x73\xf0\x19\x37\x6b\x8a\x6a\x94\x23\xf5\x19\xc5\x30\x50\x43\x3b\x4d\xe4\x65\x13\x06\xda\x66\x1b\x7e\x19\xa4\xe8\xcc\x06\xe6\xbb\x56\xa0\x8f\x65\xb6\xa7\x3b\xb6\x54\x96\xed\xea\x56\x35\xe5\x66\xf0\xcf\x64\x39\xc2\x33\x07\xf9\x02\x93\xac\x48\x06\x82\x59\xce\x76\xcd\x7f\x12\x6d\x02\x81\xa8\xeb\xd2\x31\x0f\x5b\x73\xeb\x7d\xfa\x84\xfb\xd0\xd5\xab\x54\xa8\x39\xb5\xe8\x5d\x5f\xbd\x34\x6a\x60\xb5\x2a\xec\x40\xed\x7c\xab\x0c\x40\x78\x0d\xd4\xf5\x41\x11\x9e\x1c\x4e\x5c\xb5\xa4\x30\x8b\x66\x89\x7e\x1b\x28\x04\x9b\x8d\x92\xfe\x48\x35\x30\x08\xa5\xd7\x10\x08\xf4\xae\xa5\xa9\xe6\x33\x74\x43\xd7\x5a\xd5\x83\xd7\x62\x78\xd1\xcd\x27\x3f\xb6\x19\xa1\x43\x95\x58\x27\xcb\x81\x6a\x87\x83\xdc\x6a\xe1\x80\xac\xa4\xd7\x09\x5b\xe8\x03\x16\x75\x91\xd1\x5b\xcf\x9c\x77\xfc\x08\xeb\xd6\x2c\xe5\x04\x1e\x3f\xa9\x18\x96\xad\x3b\x63\xa6\xab\xa2\x18\xe8\xed\xac\x54\xcf\x4c\x99\xb3\x33\xd5\xdd\x99\x7f\x09\x64\x53\xd5\xd9\x35\xe3\x60\x65\xac\x26\x80\x13\x12\x03\x36\x49\x2e\x05\x74\x1c\x7b\x13\x57\x79\x9a\x02\xcd\xa0\x42\x2f\x48\xf6\x0f\x06\xac\x9a\xf3\x61\xdc\x3c\xf5\xf3\xad\xb2\xa7\x7e\x21\x64\x99\x98\x34\x6c\xa8\xa1\x29\xd8\xb5\x20\x74\xec\x44\xb1\x36\xaa\x0a\x7b\xca\x1a\xf6\x25\xdd\x50\x0d\xf1\xd7\x6b\x31\x2c\x1b\x11\x0e\x7e\x15\x5e\x6b\x01\x7f\xae\x20\x8f\xca\x71\x4a\xa0\x2e\xc1\x8e\xa3\x7c\x5c\x4b\x3c\x74\x49\x2d\x84\x4a\xc5\x4f\x9f\xa0\x4b\x2f\x20\x51\x58\xe9\xbd\x5d\xad\xd3\x90\x55\x11\x91\x1a\x80\xd0\xa0\x2d\x9a\x8e\xb5\xd6\xb0\xcc\x79\xbf\xf4\x6e\x30\x8a\xe2\x05\x6b\x82\xe7\x07\xaa\x4a\x27\x2d\x14\x5f\x70\x8d\xdd\x20\xdc\x40\x21\xe5\xf2\x58\x3d\xe1\x39\x1f\xb3\x8f\x68\x08\x70\x8d\x30\x3a\xec\xc8\x81\x82\x44\x59\x20\x41\x00\xf1\x81\x22\xf2\xb4\xa1\xda\x97\xf0\x3c\xb0\x0e\x28\x57\xcd\x2f\x18\x24\x68\x63\x9d\x81\x2a\x1f\x54\x0f\xb0\x37\x20\x2b\x17\xb6\x8b\xd2\x61\x8a\x41\x52\x3c\x5c\x3e\x15\x0a\x71\xe8\xc0\xbc\xa5\xab\x02\x35\xee\x27\xc1\x34\xd5\x28\x8d\x55\x46\xb0\x7c\x54\xe4\x8c\x9a\x5e\x7d\xf4\x54\x35\x4b\xea\xc8\x01\x34\x03\x88\x1e\xc2\x2d\xff\x10\x6e\xcd\x3b\x84\x5b\xea\x10\xba\xdc\xf7\x0e\x6b\x4f\xac\xec\xc5\x23\x02\x6d\x3c\x8e\xf6\x86\x76\xa7\xb0\xa6\xb6\x42\x21\x57\x7d\xec\x3c\x38\xed\x1c\x9e\xaa\x17\xde\x36\x2a\xdb\xd4\x7c\xbb\x8a\x64\x3e\xdc\x25\xe3\xf8\xd6\xb6\xb3\x75\xd0\x00\x66\x61\x35\x40\x60\x5b\x09\x86\x19\xa9\x85\xea\xf8\xf9\xd5\x60\x4b\x55\x6d\x72\x92\x5e\x41\x52\x19\xb4\x85\x28\xd5\x86\xf6\x80\xa3\x2a\x50\xef\x73\xc3\x07\x91\x46\xc9\xe7\xc7\xc7\xf0\xde\x7d\x21\xfa\x29\x47\xb5\xd5\x35\x5a\x07\x16\x28\xc4\x29\xa6\x29\x10\xf1\xb3\xba\x97\xf1\x19\x93\x59\xcd\xcb\x4c\xf7\x61\xee\x0e\x7e\x99\x14\xac\xc3\xce\x2e\xf1\xee\xb8\x3a\xf3\xd0\xd8\xdc\x1b\x66\x72\x88\xc9\xe6\x17\x24\x64\xf3\x2e\x43\x05\x0d\x70\xda\xbb\x4b\x9e\x61\xfd\xe3\xe4\x57\x61\x13\xbd\xa8\x9a\xfe\xad\xb2\xa7\x30\x5a\x8d\x06\xc8\xf0\x25\x90\x7d\x20\xf1\x8a\xe2\x9f\xc0\x55\xe1\x2a\x3f\xd3\xb7\xc4\x1e\xd6\xc6\x7a\x4f\x59\xe3\x48\x6d\x27\xb4\x78\x86\x66\x52\xd4\x98\x6f\xc2\xf3\x42\xbc\x4c\x25\x2f\xf5\x30\xde\x37\x70\x2a\x0d\xf6\x50\x43\x7b\xc8\x1a\x3f\x27\x83\x72\xd4\x38\x6d\xb3\xcd\x8d\x16\x7b\xb8\xb8\xd1\xb3\xb0\x11\x7d\x28\x9e\x88\x34\x2d\x0c\x0d\x51\x8c\x68\x3e\xcd\xc0\x28\xe7\x00\x92\x87\x8b\x92\xed\x5f\x4e\x52\x99\x8b\x9c\x6d\x6e\x2c\x8f\x28\x55\xad\x56\x52\x1c\xec\x03\x04\x63\x04\xa0\x7e\x46\xd2\xbe\x60\xc1\x5f\x37\x23\xfe\x90\xc8\xa0\x62\x3b\x4a\x34\x2c\x03\x6b\x60\x3a\x7d\x3b\x9f\x4c\x7e\x42\x7d\xa7\x95\xe6\x34\xde\x1c\x1f\xec\xb3\xcd\x8d\x86\x91\xe0\x04\xa2\x0b\x84\x82\xc1\x20\x3c\x86\x43\x61\x87\xda\xff\xb6\x96\xb5\xab\x4b\xb0\x6d\xd5\x5c\x68\xf1\x4a\x63\x4a\xbc\xe1\xe5\xa8\x3b\xe6\x97\x4d\x55\xfd\x7d\x03\xdf\xb5\x6a\x53\x14\x90\x53\x84\xf2\x5e\xb3\x0a\xe4\xb3\x02\xfb\xbe\xd1\x4f\x13\x91\x95\x95\xcf\x15\x20\xf8\xb9\x02\xc4\xac\x62\xb3\xc5\x9e\xc6\x9b\xb2\x87\xfe\xd0\xdf\x37\xc6\x3c\x3f\x4f\x32\xc8\x4a\xe5\xd0\xfc\x95\x40\x84\x7d\x8a\x28\xae\x10\x17\x70\xb9\x75\x03\x00\x1a\xe3\x15\x0c\x3c\x06\x2d\x45\xe0\x35\x3e\xd2\xa5\xfe\x19\x94\xd9\x6a\xc1\x8b\xa6\x3b\x83\x6a\xbd\xe8\x4b\xce\x08\xf9\x09\x0f\x34\xef\xe5\x6c\x8c\x9e\xed\x80\x41\x85\x6e\x97\x09\xc5\x78\xbe\x46\x4e\x41\xf5\xac\x6d\x11\xcf\x46\x30\xa5\x6d\x8b\x14\x66\x8e\xf3\x10\xa3\xad\x8d\x22\x06\xe5\x88\x34\xc4\x53\x39\xaf\x9d\x67\x06\xe0\x47\x03\xf1\x4e\x48\x5d\x28\x21\x23\xa3\x58\x26\x98\x10\x5a\x9a\xdc\x34\xa0\x10\xbe\x4c\xf4\x29\x9e\x13\x45\x8e\x86\x46\x59\x18\x47\x0e\x86\xb4\x6c\x2c\x39\x62\xdd\x1e\x8f\x28\xa7\x2b\xdc\x30\xae\x5c\xb5\x75\x2c\xba\x1c\xb1\x46\x5f\x3d\xc6\x9c\x6e\x7c\xf3\x48\x73\xce\x76\x64\x2d\x66\xee\xb2\x64\xc8\x39\x2b\x0e\xb8\x6d\xd8\x39\x0b\xe8\xa6\xa1\xe7\xe8\x1b\x83\x86\x9f\xd3\xc7\x02\x3c\x5b\xd4\x7f\xb8\xe7\x74\xb9\x3c\xb4\xab\x46\x46\xd3\xe7\xc2\x8b\x8d\xb6\x56\xbf\xf6\x24\x3e\x9a\xc5\x32\x12\x25\x4d\x7f\xab\xc4\x4a\x33\x96\x4d\xd5\x88\x69\xba\xc4\x0f\xa0\x44\xcd\x9c\xa8\xd0\xa0\x12\x41\x2d\x54\x02\xf4\xfe\xe3\x82\x17\xad\x18\xc4\x72\x8d\xad\x14\xc6\xd2\xbd\x1f\xa3\xa1\x2c\x83\x90\x44\x61\x3c\x4b\x72\x38\x6e\x12\xd5\xd2\xf9\x0a\xd6\x46\xb7\xac\xba\x0b\x92\x75\xd2\x31\xd9\x60\xa9\x8c\x00\xc5\x93\x91\xe8\xd0\x06\x6d\x76\x2e\x32\x91\xa3\xb9\x35\x93\xd3\x72\x32\x2d\x59\x91\x8c\x93\x94\xe7\x5a\x8f\xfe\x4c\x4e\xb3\x41\x92\x9d\x3f\x87\x7b\xfa\x68\xa5\x97\xa6\x13\x90\x98\x57\x98\xee\xd7\x67\x9d\x4c\xa1\xeb\x82\xa5\xc9\x07\xa1\xc7\x53\x11\x88\xb8\x6a\x4d\x13\xd6\x87\x72\x23\x9e\xd7\x8e\x9d\xa7\x16\x4a\xe1\x7d\x66\x02\x3b\xe0\xc3\xc4\xfe\x84\x4b\x0b\x11\x16\x5f\x36\xae\x26\xbc\x86\xec\x2f\xbc\x17\xd7\x10\x85\x7d\x83\xa0\x9e\x5e\x2e\x86\x7c\x8d\x7e\x62\x0e\x6f\xf9\x0e\x89\x3d\xb9\xa3\xaf\x5c\xd2\x6b\x65\xdd\xaa\x3b\x59\x15\x2a\xc1\x70\x6d\xc6\xf7\xf5\x75\x06\x8c\xe6\xe6\x06\x7b\x79\xf0\xaf\x6d\xf6\x2e\x15\xbc\x10\x6d\x36\x90\x59\xa3\x64\xbc\xf8\xd0\xf6\xe4\x16\xa0\x42\xc0\x66\x7d\x09\x12\xcb\x1c\xad\xe8\x5e\x1c\xbe\xc1\xd3\x31\x16\xac\x9f\xe4\xfd\xe9\x18\x6f\xe6\x02\x55\x92\x46\x7d\x81\x2a\x88\x5c\x60\xda\xef\x04\x4c\xd4\x32\x1c\x01\x48\xe8\xcb\xa4\x97\xa4\x49\x79\xa5\x1e\x85\xf0\xdc\x39\xd8\xdf\xdc\xf4\xd8\x65\xc5\xe0\xd8\xfb\x3d\xbf\x22\x92\xdb\x3e\x95\xfb\xc4\x17\xc3\x73\x35\x5c\xfa\xfd\xed\x37\x58\xea\x0d\x6e\x46\x54\x79\x63\x7b\x85\xd5\x57\xb3\x57\x1c\x79\x7b\x7b\xe5\x91\xe7\xb4\xbe\x34\x59\x9f\xa3\x15\x4b\xae\xf8\xa6\xeb\xaa\xe0\x76\xd9\xb5\xb2\xc1\xb5\x73\x7c\x07\x1b\x57\x48\x0c\x58\x62\x27\x81\x27\x0a\xe2\x99\x98\x59\x7b\x4c\x22\x19\x6e\x27\x6c\x65\x38\x50\x3a\xe5\x8e\x05\x63\x23\x90\xaf\xaf\x3b\x49\x06\xce\xb7\x07\xcf\xd3\x5f\x05\x8a\xa2\xd4\x5f\x85\x7d\xb4\xfe\x0a\xde\x57\x73\x6c\xb0\xd8\xd3\x2a\x73\xbe\xad\x2d\x0b\x15\x08\x18\x38\xbc\x7b\x7f\x15\x9a\x6c\x50\xfb\x2b\x3c\x84\x3f\x9b\xcf\xb8\x3a\x64\x86\xf0\x33\xd5\x1b\x02\x4c\x3d\xcc\xd2\x02\xd4\x3f\x2b\x10\x5f\xd9\xef\x1a\x06\x59\x10\xf8\x5d\x2a\x1c\x30\x30\x65\x9e\xfc\x7a\x6c\xd7\x62\x37\xb0\xba\xc0\xd1\x75\x70\x2a\x66\x1c\x17\x22\x2f\xeb\x9b\xe8\xee\x3b\x7a\xb8\x66\xe1\x93\xa1\xba\x3b\x46\x57\x13\x59\x8e\x44\x99\xf4\x79\x4a\xb6\x20\x29\xb4\x54\x46\x0c\xda\xa0\xc5\x9b\x16\x25\xeb\x69\x45\x5e\x52\x36\x0a\x88\xf9\xc8\xd9\x19\xbe\xe4\xcf\x10\xa4\x51\xf7\x95\x4e\xa9\x69\x9d\x39\x78\x0a\xb7\xee\x44\xe4\x43\x99\x8f\x81\xd1\x47\x25\x65\xa1\x29\x41\x30\xf1\x4f\x9f\xfc\x69\x79\x57\x3b\x88\x11\x96\xb1\x6e\xc2\xa3\x13\x80\xee\xec\xd6\xc9\x54\x1a\x97\xe6\xa4\xfb\x4b\x3a\xa7\xc5\x55\xc3\x78\x78\xea\xcd\x44\xb4\xea\xec\x06\xbd\xee\xd0\x3a\x1a\x53\x3a\xbb\x7e\x3f\x11\xfb\x24\x72\x76\xb1\x6d\xf5\x31\x8a\x0a\x1a\x55\xe5\x48\xa4\xbc\x4c\x2e\xc4\x89\xdc\xcb\x7b\x49\x99\xf3\xfc\x0a\x2c\x99\xac\xc3\xbc\x56\x5a\xbb\x7b\xc3\x4a\x24\x1c\x1d\xde\xb1\x45\xea\x4c\xa9\xd7\x89\x6f\x57\x42\xce\x9b\x7d\xb5\x6a\xf8\x47\x48\x82\xe2\xa4\xc7\x73\x15\x05\xef\x6c\x80\x3b\xb7\xcd\xc4\xd9\x94\x38\x5a\x6d\x4d\x93\x42\xf3\x2d\xd2\xc3\xda\xb2\x88\x12\xf4\x80\xe8\x7c\x22\x27\x3f\x6b\x52\x51\x11\x5e\x75\xfd\x2a\x5a\x5e\x45\x5b\x2b\x92\xbd\xa8\xb9\xad\xa3\xdb\x7b\xb6\x57\xc6\xf8\xd6\xad\xc3\x47\x47\x8a\xe9\x5a\xc3\x45\xd4\x21\x0b\xa9\x3f\x04\x43\x24\xc4\xdd\x6b\x0d\x37\x95\xd7\x5c\x7f\x09\xc7\x48\xa9\xbe\x07\x81\x70\x5e\x86\xe2\x7b\xe5\x1e\xc3\xc5\x2c\x1f\x86\x72\x18\xbc\xa4\x37\xaa\x05\xfa\x32\xde\x30\x94\xea\xd8\x5c\x11\x58\x0c\x12\xe2\x40\x7e\x62\x4d\x24\x80\x36\x61\x48\x91\x69\x21\x06\x8c\x17\xd6\x50\x43\x53\xa8\x81\x44\xfa\x24\xb3\xf4\x8a\xc9\x8c\x01\x96\xf7\x44\x9f\x4f\x4d\x73\xb0\x4a\x51\xa5\x9e\x69\x42\x4f\x8c\xf8\x05\xdc\x46\xeb\xeb\x6c\x90\x0c\xc1\x91\xb1\x4c\xaf\xd8\x6c\x24\x32\x3b\x34\xf0\x09\x9c\x4c\xd2\x04\xcd\x38\x92\xb2\x8b\xaa\x0b\x52\x4c\xdc\xd1\x10\x58\x09\x12\xe1\x4b\x23\x08\x0e\xa6\xd6\x36\x8a\x51\x09\x21\x78\xd5\x2c\x81\xfa\x1a\xa3\xb0\xfb\xfa\x0c\x3f\x78\xa0\x8f\x2c\xa5\x94\x74\xa5\xab\xb8\x68\x4b\x2d\x16\xd3\x56\x7a\x1b\xea\x9a\xa9\x62\x87\xbd\xcc\x63\xb9\x3b\xbb\xe1\x49\xea\xb8\xa1\xec\x78\xd5\xcd\x5d\xb8\x7c\x0b\x44\xd2\xdd\xca\x69\xeb\x90\x71\xfb\x2d\x72\x43\x6d\xe7\x37\x81\x36\xeb\xeb\x6c\xaf\x2c\x79\x7f\x44\xd6\x8e\x67\x03\xba\x26\x16\x59\x62\xac\x31\x5e\x82\x57\x60\xca\xa3\xb6\x6d\xec\x8d\x84\xee\x47\xcd\xf4\xbc\xc5\xf7\x67\x74\xbd\xe6\x0b\x99\x9f\x1a\xda\x6c\xcd\x25\x28\x85\x54\xbc\x8f\xb6\xaa\x52\x24\xdb\x23\x9e\x0f\x1e\x78\xbf\x1d\x71\xbf\x5f\x31\xa2\x73\x34\xc9\xd7\xae\xd9\x27\xda\x64\x9e\xe1\x5f\x51\xb9\xae\x7e\x4a\xc4\x6c\x22\xf3\x9a\x6b\xab\xa4\xf7\x56\xe5\x99\xb3\xaa\x26\x19\x99\x5c\x84\x8e\xfd\x21\x69\x5d\x7c\x65\x5a\xfe\x5f\x8b\x58\x7d\x06\xd2\x4a\xce\x55\x29\xe5\x1b\xdb\xc6\xcf\x09\xbc\xf7\x2d\x2b\xe9\xae\x08\xcb\x32\xc6\x40\x20\xa7\xe6\xc3\x70\xcc\x23\xb9\x27\xe2\xaf\x1c\x6f\xa8\x35\xef\x1a\x14\xe1\xda\x47\x8d\x77\xef\xd8\x87\x00\x5c\x34\xae\x8f\x4e\xb0\x86\xfa\x55\x1d\x7c\x74\xc4\x84\xdc\x37\x64\x14\x15\x28\xfa\x15\x1f\x05\xf3\xda\xbe\x24\xf4\xb5\x13\xb9\x69\xdc\xe5\xb2\x53\xcb\x33\xe1\xc4\xbc\xd7\x7e\xc4\xb3\xca\x3d\x84\xd9\x30\xb9\x14\x03\x26\x73\x62\xbd\xc3\xf5\x47\x6b\xf0\x77\xd7\x56\x28\xce\xc0\x70\x5a\x94\x72\xfc\xdc\x59\x88\xcd\x77\xbf\x62\xdf\x24\xc5\x4b\x35\xb4\xa7\xdf\x54\x3c\xaf\xd4\xe7\x15\xed\x69\x6f\x6a\xe2\x11\xb3\xb2\x55\x90\x16\x7b\x32\x55\xec\x8d\x61\xa1\x43\xc0\x46\xf0\xec\xa9\xc0\x70\x82\x4b\x18\xec\x9b\xde\xf5\x2d\x6b\x62\xb5\xa0\x07\x7d\x01\xa4\xdd\xd9\x6d\x8f\x6f\x27\xe1\xc1\x80\x07\xb5\xc5\x36\xf8\x01\xad\x61\x14\xc4\x13\x3e\x50\xcc\x6f\x6d\x63\x37\xf4\x7d\x6b\xba\x61\xfe\x02\x4e\x07\x14\xe9\xc3\x24\x13\xc1\x4c\x6b\x64\x76\x52\xe6\x83\x24\xe3\xa5\xf3\xef\xf7\x9a\x44\x44\x50\x50\xd4\xd4\x11\x7f\xdd\x64\xda\x66\xe8\xed\xea\x18\x97\x74\x39\x20\xdb\xb2\x6b\x42\xa8\x6e\x98\x00\xaa\x1b\xcc\xbe\xdf\x03\xd7\x84\x1a\x1b\xb5\xca\x08\x5b\x86\x91\x7c\xc5\xb3\x41\x2a\xd8\x85\xbe\x81\x8c\x39\xbe\x42\xd6\xea\xf2\x02\x42\x9a\xaa\x16\x27\xbd\xa1\xae\x76\x9b\x55\xcd\xe4\xa9\xf8\xc6\x0d\x8f\xf2\x79\x3d\xae\xb6\x56\xa2\x28\x4e\xd0\xed\xe6\x85\xb7\x61\x2c\x5c\x49\x1d\xd3\x1d\xcc\x88\x37\x9c\x9e\xa3\x66\x9e\x94\x19\x20\x71\x88\x2a\xe0\xe6\x7b\xcc\xb8\x15\xf7\xa2\x5f\xfa\x50\xba\x73\x0c\xf6\xa3\x7d\xea\xe8\x51\x4b\x98\x8d\x59\xb1\x3a\x2e\xec\x9c\xf9\xe2\x0d\x3b\x6f\xa6\xcb\xf7\x1a\x04\x61\xaa\x40\xaa\x0c\xc1\xb3\x38\xad\x3c\xfb\x16\xf3\x26\x7e\x0f\x6d\x16\x20\x96\x41\xa7\x03\x63\x35\x3e\x84\x37\x0e\xc8\x71\x80\x2b\xe5\xee\xf9\xa2\x95\xb9\xdc\x46\xc1\x5e\xb8\x5f\x28\x68\x7b\xf0\x80\xdd\x37\x44\xd8\xeb\x3e\x88\x64\xe8\x8b\xe3\x70\x82\x9e\x7c\x8e\x06\x13\xb3\xbc\x51\xd0\x4c\x3f\x23\x69\x55\xc3\x88\x85\x35\xb5\x58\xac\xb2\x15\x46\x64\xeb\x3d\x52\xaa\x5c\xf9\x4e\xb5\xa1\x7e\x9f\xec\x9a\xd1\x3d\xa4\x30\x22\xf5\x8d\xf8\xd7\x7f\xad\x44\xb8\xfb\x48\xdb\x5c\xcf\x1f\x67\xf7\xd0\x83\x11\xc5\xb5\xf5\x75\xb4\xf8\x4f\x53\xf2\x42\x24\xa4\xa2\x68\x9b\xb7\x2e\x78\x8d\x9f\x4b\x39\xa8\xf4\x6a\x3d\xb6\x8a\x40\x39\xab\x5e\x42\x83\x81\xa1\xee\x8a\xc6\x44\xa6\xa9\x4b\x77\xd6\x62\xab\x1d\x2f\xb4\xaf\xb1\x78\xb1\x7b\x10\xda\x72\x77\xf1\xbb\x7a\x95\x77\xc5\x5e\x2e\x38\xa4\xd7\x70\xec\x8e\xc5\x92\x5c\x0c\xa9\xac\x82\xa2\x9a\x2a\x22\x82\x51\xdd\x0f\xb6\xfc\xd6\x8a\x4c\x1d\x3f\xa1\x38\x80\xa4\xbc\xb2\x77\x6e\x99\xf3\xac\x18\xca\x1c\xed\x26\xcf\xf8\xb4\x94\x67\x24\x6e\xa6\x76\x64\x71\x1f\x66\x49\x39\x62\x63\x99\x03\x13\xc0\x2f\x78\x92\x82\x7e\xbd\x98\xf0\xbe\xe8\xde\x46\x45\x07\x71\xd7\xd1\xbc\x0c\xfe\xd4\x36\xa1\x46\x51\x38\x60\xbd\x2b\x13\xb1\x95\xf4\x10\x51\xf5\x4d\xd0\xc1\xb4\xc3\xde\xd8\x18\x9d\x56\x3f\x0c\x8b\xad\x78\x26\x5d\x2b\xce\x5c\x04\x63\x30\x2e\xeb\xe9\x95\x31\x0b\x1c\xf8\x1c\x86\xb6\x28\xd9\x9b\x96\xd2\x45\x90\x74\x71\x46\xd5\x4d\x7e\x84\x70\xaa\xcc\x47\x0d\xcf\x81\x02\x46\xc0\x9f\xb8\x9d\xe7\x63\xdf\xce\xf3\xf1\x3c\x3b\xcf\xc7\x60\x06\x64\xad\xa0\xed\xc8\x9c\xc9\x96\xda\x76\xcd\xc4\x76\x42\xc7\x7b\x5b\xdd\xd3\xbd\x84\x8c\xc4\x8d\x59\xac\x9d\x35\xa2\x03\x2c\xfc\x37\x9c\xa1\x13\xfa\x11\x45\x4e\x59\xe4\x34\x6c\x9b\x75\xb6\x52\x44\x7a\x9e\x91\x36\xb4\xa9\x3a\xb6\x1e\xba\xd3\x99\x20\xc0\x9c\xd2\x6f\xd3\x1b\xa9\x6f\x9f\x72\xb6\x0b\xa3\xc8\x5d\x71\x06\x11\x3a\x62\x07\x81\x1f\x68\x27\xc8\x60\x06\x5d\x98\xea\x56\x16\xea\xd1\xbc\x25\x27\x61\x5f\xa5\x68\x89\x90\x97\x62\xa0\xe8\x13\xb1\x79\x80\x1c\x37\xb0\x65\x73\x92\xdb\xd4\x25\xb1\x80\xc8\xc2\x1f\xc4\x95\x9e\x0c\x6e\x3d\xd8\x17\x38\xfb\x0f\x9e\x0b\xbe\x6d\x09\xa3\xab\xd1\xa2\x46\x1c\xad\xae\x1a\x1c\xe9\x9c\xb7\x59\x2f\xe8\xbd\xd7\x55\xa0\x58\x87\x71\xf8\x63\x67\xcd\x46\xb5\x54\x93\x1b\x26\x69\x29\x72\x37\x3d\x32\xd9\x2e\x96\x11\xe8\x8a\xda\x6e\x51\xf9\x24\xa5\xd0\x5b\xfe\x96\x06\x44\x7a\xcb\x52\x69\x32\x34\x6c\xfe\x0f\xcb\xad\x51\x0d\xde\x83\x07\x06\x40\x58\xfe\xca\x02\x22\xf3\x30\x56\x6d\x5e\x72\x0f\x3a\x37\x47\x3a\x36\xd8\x53\xbf\xe8\xfd\xc6\xa9\xda\x4f\xb6\x4d\x67\xaf\x3f\xda\x0e\xac\xef\xbe\x62\x2e\x2d\x05\x29\x26\x69\x52\x36\x1b\x9d\x46\xeb\xfd\xe6\x29\xbd\x81\xaa\xe3\x79\x08\x26\x2b\x1a\xc6\x53\xd6\xe8\x34\xd8\x43\x02\x75\x9b\x35\x1a\x15\xb3\x06\xc3\x59\xea\x6b\xa8\x12\x7e\xef\xc6\xde\x07\x90\x0e\x83\x16\x04\x8f\x60\xd6\x21\x89\x72\x62\xe6\xd3\xd5\x57\xb1\x6e\x52\x19\x23\x06\xd0\xd3\x90\xc0\xd1\xba\x27\xac\xd4\x08\x67\x96\x14\xad\xf8\x4d\xb4\x97\x99\x7b\x50\x8b\x48\xd5\x7d\xe0\xbc\x4e\x0b\xed\x8a\x65\xa0\x12\xc9\xbd\xeb\xb3\xea\x2d\x6b\x46\x68\xf2\x34\xc1\x62\x44\x6e\x27\x12\xd0\xaa\xf2\x4c\x5d\xed\xfd\x5a\xf5\x4c\x9b\xf7\x40\x20\x17\x47\xb5\xe3\x0a\x8e\xc0\x72\x4c\x4b\x61\x54\xec\x51\xe7\x2c\xcd\xe5\xa3\x6e\xfe\xa1\xd1\x67\xdc\x9d\x4f\x56\x65\xe7\xaa\xdb\x86\x87\x5d\x31\x1f\xfa\x5c\x4f\xac\x81\x5e\x35\xfe\x81\x9a\x0f\x3e\x31\xaa\xfe\x1f\x44\x29\x18\x0d\x70\x63\x65\xa8\x97\xf3\xb5\x26\x51\xe3\x76\x5d\x8c\xa6\xc4\x16\xd2\xd5\x02\x45\xca\x3c\x50\x60\x8a\xdc\xda\x89\xdb\x6c\xe8\x4b\x2b\x66\x24\xf0\x90\x5d\xf9\x02\xd3\xa8\x59\xc0\x43\x76\xb9\xa6\xc3\x82\x5b\x3f\x0d\xd5\x43\x14\x4b\x26\x20\xb0\xa3\xec\xac\x87\x2c\xe0\xd1\xb8\x3a\x42\xd8\x80\x48\x06\xaa\x8f\x11\xa6\x78\x98\x26\x93\x89\x18\x78\xd5\x82\x5d\xd7\xe3\x8b\x30\x91\x44\x87\xc0\x8b\x11\x88\x99\xf0\xf6\x6f\xe4\xda\x34\x5a\x33\x35\x28\x1a\x6f\x5b\x06\x04\x2c\x86\xda\xc8\x4e\x99\xc8\xb1\xde\x72\x39\x5a\x9e\x0b\xf8\xbb\xb9\xae\x40\x7c\x02\x78\x9f\xb0\xc5\xa7\x52\x4e\xd6\xcf\xdb\xc4\xbc\x71\xcc\xcb\xfe\xc8\x79\x06\x68\x58\x6a\x6c\xef\x75\xd1\xe9\x4e\xd4\x50\x2d\xa0\xe8\x44\xe4\x78\x13\x32\x6e\xf3\x6a\x75\x20\x24\x96\xfd\xa9\x40\xbf\x23\x14\xf7\x5c\x94\x86\x38\x2e\x90\x7e\x2e\x24\xfc\xce\xb1\xcb\xa7\xa2\x15\xf2\x6f\x66\xba\x3c\xf9\x0f\x3c\x73\x1c\x96\x76\xa8\x77\xee\x05\x4f\x93\x01\x45\xe1\x79\x4f\x19\xec\xd7\x0d\xf1\xb3\x5c\x28\xef\x68\x27\x55\xfa\x7f\x68\x35\x6d\x3e\x36\xd3\xec\x0c\x51\x8e\x62\xe3\x94\x7a\xa2\xeb\x25\x84\x88\x14\xd4\xb0\xca\x44\x06\x37\x76\x18\x84\x76\x4e\x48\x22\x4f\x23\x0e\xd0\x28\xd2\xae\xd2\xe3\x52\x32\x39\x75\xd2\x2c\xe3\xa0\x47\x3a\x71\x89\x20\x3d\xea\xe5\x46\x10\xb3\x28\x20\xa5\x81\xca\x67\x7d\x9d\x0d\xc4\x44\xa0\xe1\x66\xef\x8a\x22\x1e\x79\x70\x0b\x36\xe2\x88\x29\x9a\xa7\x62\x89\x1a\x9d\x1e\x4a\x91\x2a\x90\xe9\x15\x55\xe9\x3b\x0b\x18\x99\x27\xbf\x42\x9c\x4e\x43\x25\x90\x3c\xb8\xd0\x2b\x64\x4b\x9c\xb3\x0e\xea\xd0\x93\x4c\x3b\xe3\x1a\x38\x4f\xb5\x37\xae\x21\x32\x56\x55\x27\xfa\x52\x3d\x22\xae\xaa\xf5\x53\xe3\xbe\x55\x12\xf7\xad\xb1\xe0\xc5\x34\x37\x3b\x4f\x6a\x8f\x84\x75\xde\x82\x75\xac\xf6\xf0\xc6\x6b\x7a\x7f\x7e\x5b\x1b\x2e\x5d\x6f\xdb\x7b\x33\xa7\x53\xb6\x5b\xc1\x4e\x52\xf8\x30\x52\xe8\xfa\x3d\x65\xeb\x6c\x8b\x75\xc8\xb6\x56\x4a\x77\xc2\x87\x36\x2a\xb0\xe9\x32\x19\xc2\xe9\x0f\xd0\xab\x12\x1d\x65\x50\xc3\x1b\x46\x6c\x95\x4e\x2b\x82\xfa\x55\x7b\x8c\xde\x4b\xfe\x5c\x2a\x2e\xc8\x5e\x1f\xf4\x06\x78\x93\x8c\x93\x3e\x5a\xa8\x9c\x29\xf6\xf1\x4c\xcb\x72\x14\x6d\x83\xf4\xb9\x37\x0a\x07\xa9\x1a\x5e\x33\x9e\xe7\x7e\x81\xe2\xaf\xfc\x2f\x60\xdc\xef\x11\x4a\x38\x07\x4c\xe6\xac\xb3\x59\x0d\x85\xd2\xe4\x79\xde\x46\x43\x40\xab\x09\x9a\x16\x82\x65\x48\xbb\x21\x16\x42\x32\x34\xa1\x32\x21\xf1\x8f\xda\x76\x18\x0f\x31\xbc\x57\xf5\x82\x8b\x92\xe7\x39\x7c\x6e\x22\x70\x1a\x87\x41\x75\x70\x86\xcf\xb3\x33\x20\x49\x10\xc6\x1b\xbd\x8d\xf9\x58\xa0\x1d\x4f\x22\x73\x70\xff\x84\x35\x5c\x0b\xc0\xc2\xa3\x15\x01\x03\x09\x0d\xa3\x7f\x01\x2c\x3d\x71\xbc\x52\xe0\xca\x56\x44\x68\x55\x9f\xee\x2f\xb0\x09\x07\xaa\x10\x77\x42\xc1\xf2\x3c\x4c\xaa\xfb\x01\xb5\x97\xdd\x14\xa8\x5c\xb3\x33\xd8\xad\x63\x78\xfa\xd3\xbc\x1a\x91\x63\x9a\x43\xb0\xc8\x53\x38\xdf\xd6\x73\xc4\x4a\x27\xfc\x1d\x55\xd8\xfe\x90\x9d\x69\xca\x7b\xa6\x46\x75\x66\x7b\x3a\xd3\x56\xe8\x74\xd8\x48\x86\xcb\xfe\x48\xbf\xb5\x70\x11\x3c\xa7\x9b\x60\xf0\xb2\xf7\x9f\xd8\x80\xae\xe9\x0b\x4c\x4d\xd0\x50\x7f\x80\xee\xb1\x68\xaf\xa5\x9c\xb0\x32\x97\xd3\xf3\x11\x60\x46\x9a\x60\x48\x4b\x97\xef\x08\x34\xce\x53\x54\x37\x83\x6b\x4f\x3e\x80\x0c\xaa\xdf\x32\xc1\xfb\x23\x8d\x51\x63\x1d\x1c\x71\xa4\x9e\x60\x83\x04\xd9\x6f\x22\x52\x5d\x41\x52\xac\x99\x22\xd5\x98\x8a\x8a\x69\x99\xc6\x3d\x92\xf9\xab\xca\x4c\x81\xc7\x4e\x87\x1d\x4e\xb4\x31\xaf\x75\x46\xcf\xd4\xa1\x32\x2a\xc9\xa2\x74\xfc\xa8\xe5\xa5\x48\xd7\x3e\x7a\xe6\xd3\xcc\xca\x98\x9b\x24\xf9\x9b\x6a\xd0\x86\x1e\x1d\xdb\x6e\x8b\x4f\xe4\xd1\x34\x63\xbb\x38\xa0\xdd\x40\x66\xeb\x96\x99\x24\x32\xeb\x16\x69\xd2\x17\xcd\x8d\x36\x39\x0f\xa4\xb7\x86\x9a\x41\x43\xf7\x87\xbc\x8e\xdf\x59\x77\x28\xf3\x7d\xde\x1f\x11\x6c\x36\x15\xa8\x2f\x9a\xf9\xf6\xde\xe5\x2a\x3a\x6d\x51\x55\x8d\x28\xd2\x24\x2b\x3b\x83\xa4\xe0\xbd\x54\x74\xd2\x24\x13\x6c\x20\xcb\x4e\x26\x89\x02\x0e\x9c\xb1\x0a\x99\x8a\xee\x8c\xe7\x59\xb3\x71\x66\xc0\x76\x0d\xd4\x33\xb4\xce\x9e\xe4\xa2\x8f\x69\x89\xe1\x7c\xb8\x6a\xd9\xd9\xfd\x06\x71\xb4\xd3\x62\x3a\xb5\x64\xb1\x11\xb2\x4f\x9f\x18\x69\xbb\xb3\xf4\x40\xe9\x94\xbb\x3a\x2d\x1f\x1a\x21\xba\xb0\xbf\x59\xcb\x5b\x00\xe0\x1f\xed\xa3\x1d\x88\xb3\x7b\xcd\x68\xcb\x71\x31\x86\x74\x0b\xe3\x49\x2a\x4a\xa1\xfd\x62\x8e\x68\xbc\x07\x03\x8c\x98\x72\xf6\xc4\x50\xe6\x02\xcf\x8f\xc5\x4b\x2f\x2d\x1d\x70\x86\xb9\xb8\x48\xe4\x14\xb5\x61\x03\x29\xb4\xd7\x8b\x06\x37\x16\x45\x81\xca\x99\x72\x24\x0a\x61\x43\x52\xc0\x7f\x91\x9c\xc7\x15\x1b\xdd\x48\x1d\xab\x05\xf7\xca\xdc\x0b\x67\x2e\x88\xc0\x7c\xc1\x80\x51\xb4\x0c\x53\x70\xb7\xed\x5c\xa9\x5b\xa5\xe7\x0e\x8c\xe9\xad\x89\xf2\x0a\xf4\x3f\x3a\xfc\xae\x79\xeb\xe9\x3b\xcc\x3c\x3b\x90\x49\x36\xcf\x9a\x4c\xcc\xec\x26\x41\xae\x8b\xc9\x24\xbd\xd2\x76\x2a\xa6\x1c\xa4\x15\xdd\xbf\xf7\x72\xb6\xfe\x0f\xf5\xfd\x1d\x0c\x9d\x9d\xf9\xf9\x9e\xce\x20\x3c\x27\x3b\x9b\xea\x5f\xc6\x8a\x52\x0e\x63\x4e\x01\x8b\x08\x9c\x4f\x48\xa6\x3a\x2b\xa0\xb9\xd4\x92\xa1\x79\x07\xc0\x51\x81\x54\x7d\xea\xa4\xa0\x03\x94\xee\x0e\x02\xa5\x0d\xa7\x39\x28\x4d\xa7\x26\x27\x95\xcd\x00\x88\x09\x85\x93\xe2\x85\x69\xee\xdf\x15\x9e\x32\x47\x6f\x8c\xa6\x05\xda\x7f\x19\xb3\x61\xe1\x5b\x06\x05\x3a\xdb\xec\xa3\xd6\x3c\x70\x9b\xfb\x96\x7e\x2c\x75\x52\x0e\xf2\x4d\x0b\x3d\x74\x98\x91\x36\xb5\xc8\xdc\xd6\x4e\x40\xe6\x29\x64\x5e\x37\x55\x01\xaa\xf5\xde\x9b\x8b\x88\x15\xb1\xa6\x5b\x06\x93\xa5\x53\xa3\x08\xfc\xa8\x9a\xd7\x98\x01\xf0\x69\x29\x49\x2a\x4a\x75\x29\xe4\x54\x66\xa4\xed\xea\x82\x2b\xad\x8d\x40\x1c\x05\xb7\x6f\x68\x1d\x92\x1c\xee\xc1\x33\x0b\x06\x18\x00\x0c\x98\x87\x2d\xd1\x94\x6b\x88\x47\x5f\xe6\xc9\x79\x92\xf1\xf4\x1d\xd5\xc4\x7e\xc8\xe4\x0c\x1f\xeb\xba\xd4\xf0\x52\x2c\x48\xc5\xbd\x1b\x57\x49\xc2\xbc\xb5\xb8\x80\xe4\x41\xac\x59\xd5\xb9\x8b\xa6\x7f\x1b\x60\xee\xae\x52\x1b\xde\xad\x68\xf9\xe6\x57\xd7\xda\x41\xbb\x11\xb8\xe0\x18\x48\xd9\xc4\x38\x0f\x57\xff\xac\xb2\x42\x67\x16\x3f\x2a\x6b\xb7\x1b\x2c\x50\xb8\xe3\xe4\xe1\x5d\x83\x6b\x94\x68\xfa\xe2\x0e\x6f\x91\xea\x56\xd2\xef\x1e\xe8\x5d\x04\x7c\x97\xa4\x89\x77\xd9\xf1\xcd\x60\x35\xd3\xe5\x25\x38\xd5\x07\xd7\x63\x44\x60\x40\x01\x37\x62\x97\x16\x82\x23\x41\x78\x42\x4b\xc8\x00\x4f\x21\xf2\xc0\x99\xcc\x30\x9f\xc1\x19\xfc\xee\xf1\xfe\x07\xd7\x0a\x8d\x33\x64\x26\x0a\xbf\x85\xa1\x8e\xa4\x05\x98\xf5\x7b\x44\x08\xc1\x0e\x5c\x0c\x84\x6a\x99\xe7\xa2\xef\x61\x8b\x19\x55\x53\xcf\x24\x78\xd0\x06\x75\x75\x86\x55\x57\x97\xdc\x1f\x3a\x66\x8f\xb1\x7d\x80\xf3\xe4\x59\xd2\xda\xdb\x37\x29\x4c\xaa\xde\x15\x58\xd5\x8a\xad\x6b\x68\xd6\x6a\x36\x49\x27\xec\xa2\x5c\x9c\xf9\xd3\xc5\xf5\xd6\x77\x20\x61\x03\xe5\x58\x04\xca\x48\xaa\x8b\xcc\xd0\x30\x16\x2c\x42\xd4\xdf\x24\x87\xae\xcb\x6b\xaa\x0a\x85\x49\x6f\x4c\x5e\x0e\x84\x01\xca\x8c\xad\x14\x1d\x52\x5c\x98\xab\xd9\x12\xb4\x2f\xb6\x4f\x17\x17\x4f\x5f\x81\xba\x95\x44\xdd\x00\x6a\xf6\xf9\x58\xa4\xcf\x79\x21\x5a\x71\xe1\xba\x1d\x45\xa4\x89\x7a\x59\xbe\xe3\x45\x9f\xc3\xaf\x36\x91\xb9\x69\x49\xf1\x85\xc8\x06\x32\xd7\x30\x5a\xd5\x48\x78\x66\x62\xc6\x02\x58\x2d\x48\xd3\x4f\x63\x00\x32\x42\x1c\x03\x24\xc6\xc1\xeb\x8e\x35\xc6\x90\x69\xf5\x67\xd1\xfb\x90\x80\xf8\xed\x8d\xfc\x55\xfd\x73\xd8\x38\xdd\xa1\x61\xef\x74\xb4\xf3\x89\x75\xce\x1f\xf1\x7c\xaf\x6c\x6e\xb4\xba\xa5\xfc\x51\x55\x50\x23\x6f\x82\x96\xc5\x54\xc1\x47\xc1\x26\x9e\xec\x78\x04\x0f\x1c\x8e\x51\xfc\x76\x20\xf4\x80\x1f\x64\x00\xeb\x40\xcf\x58\xd9\x46\xf1\x80\xd4\x3d\xd2\xc4\x41\xd1\xf5\x9e\xb2\x46\x03\xc6\x00\xbf\x1e\x92\xb1\x6f\xdb\x81\x39\x5b\xcd\x20\xb5\x10\xc4\x93\xc1\x2c\x96\xef\x35\xe4\xd3\x30\xdd\x50\xe5\x89\xad\x2b\x52\xd3\x2e\x17\x93\x77\x9a\xa6\x14\x23\x35\xa7\xb3\xbc\x5e\xc1\xdf\x69\x9b\x12\x19\xc6\x10\xe7\xa1\x2c\x91\xd2\x74\x51\x4e\xfb\x23\x30\x58\x03\x7f\x2b\xf5\xa2\x77\xe9\xbe\xcf\x62\xd4\xc4\x3a\xc0\x84\xa4\x20\xa4\xda\x0d\x07\xa8\xd1\xf2\xe8\xa6\xbe\x2b\x72\x31\x96\x17\x62\xcf\xf0\x5c\xcd\xc6\x25\x49\xff\xd9\xda\xa9\xd4\x47\x2e\x37\x45\x87\x8a\x46\xa3\xae\x02\xbd\x82\x6a\x2b\x95\x80\xad\xb5\xe5\xef\x6b\x0f\x4d\xc3\x9a\x9b\x35\x5a\xa7\x16\x04\xf0\xa1\x00\x45\x3f\xd9\xf6\x2f\x44\x56\xbe\x4e\x8a\x52\x64\xea\x46\xb3\xb7\x17\xce\x99\x5e\xd7\xc9\x50\x51\xf3\x9c\x89\xcb\x49\x9a\xf4\x93\xf2\x8a\xf1\xe2\x83\x0e\x24\x0c\x0c\x9a\x48\x05\xbe\x12\xec\x06\x6b\xc1\xbb\x04\x17\x60\x78\x7b\x22\x58\xc7\xd2\x1f\xec\x6f\x6e\x9a\x17\x96\x21\x6b\x2e\x75\x83\x77\xdf\x60\xd3\xc3\x4c\x63\x48\x6c\xa3\x5c\x54\x69\x5d\x1b\x02\x70\x53\xbe\xa1\x15\xb8\x07\x60\xde\xec\x2a\xa9\xd5\x59\xbc\x48\xbe\x3e\xf3\xe0\x5b\xe4\x99\x11\x55\x55\xa3\xe1\xe9\x75\x85\xde\xe1\xf7\xaa\xe2\xd9\xb3\x25\xae\x73\x63\x22\x92\x26\xbf\xfe\x53\x16\xd8\x22\x63\x2a\xca\x9f\x12\x31\x63\xdb\x7a\x6a\xbe\x51\x24\x07\x3f\xb6\x13\x49\x2d\xb6\x7d\x17\xb1\x36\x26\xc0\x6c\x5b\xe6\xa3\xed\xb9\x85\x15\xd4\x51\xf8\x19\x46\xb7\x8a\xbb\x8d\x39\x53\x6e\x43\x96\x31\x94\x09\x66\x81\x52\x2d\x9f\xfa\x2d\xe7\xcd\x85\x56\x54\xe0\x10\x54\x97\x0f\x06\x1e\x5e\x37\x2b\x63\xff\xc8\x26\xbc\x28\x92\x0b\x9a\xec\xd2\x79\x49\xaa\x61\x18\xfc\x8a\x2f\x4d\x68\xdd\xae\x3b\x26\x61\xcd\x17\x2e\x98\xc1\x44\xef\x6b\x77\x32\x2d\x46\x26\xa2\x0d\x45\xcc\x63\x51\x4e\x27\x26\xea\x37\x40\x06\x81\x21\x9c\x5a\xcb\x65\x99\x34\xfb\x44\xb9\xa5\x69\xcc\x0a\x42\xc0\x3c\xb9\x40\x83\x1d\x82\xaa\x85\xea\x3d\x20\x15\x84\xe7\xd6\x47\x14\x03\x1e\x89\xb6\x1e\x07\xd8\x29\x92\xdc\x2e\x60\x10\xe2\x0f\x5d\xd1\x0a\xc4\x47\xb5\x10\x70\x05\x90\xb6\x6c\x97\x42\x52\xeb\xe5\x8e\x8c\x7b\x53\x56\x77\xbb\x91\x43\x5f\x8d\x76\x15\x64\xed\xce\xaf\xaf\x33\xdc\xd0\xc8\x08\xbd\x8c\x36\x85\xe7\x35\xe7\x22\xce\x86\x18\xe1\xdb\xe4\xcc\x3b\x60\xf6\xe1\x66\x62\xdf\x45\xc7\x8d\x9f\xaa\x28\x44\xbf\xbb\xd1\x78\xbf\x5d\xb5\x30\xf9\xbe\xbd\x61\x4d\xec\x5b\x55\x8b\xa2\xdd\x81\x4e\x58\xc1\x07\xea\xc5\xac\x56\x75\xbd\x20\xcb\x84\x92\x1e\x0c\x88\x9e\x8b\x3e\x4f\xfb\xd3\x94\x97\x5a\xe8\x13\x17\x1b\x59\x51\x03\x38\x43\x97\x23\x71\x05\xae\xce\x65\x9e\x9c\x9f\x8b\x7c\xf1\x23\xc0\x47\x4c\xbc\xeb\xc3\x4b\xcc\xc5\x8a\x23\xbc\x85\x37\xf7\xea\xf3\x48\x2d\x5a\x04\xcb\xe7\xbd\xc5\xdb\xac\x22\xf7\xf0\x05\x59\x95\x57\xd1\x11\xde\xaa\x5f\xfc\xfc\xe2\x6d\x58\x7f\x80\x61\x0a\xe4\xa8\xc2\x28\xf3\x85\x27\x36\x7a\x1c\x23\x7d\xcd\x3b\x91\xf6\xf8\xe9\x5e\x8b\xa5\x4f\x61\xe4\x44\x44\xe4\xef\x34\x3a\x98\xbd\x20\xa2\x63\xac\x3f\x7d\x2d\x62\x01\x8a\xa4\x4c\x94\xc6\xae\x31\x4a\xb6\x90\x5f\x8e\x0e\x51\x3d\x59\x4e\xeb\x0f\xae\xdf\x32\x3c\xaf\x61\xf6\xc7\xda\xf3\x9a\xd3\x2d\x8c\x1c\xd9\x99\xc4\x40\x4c\xe6\xc8\x46\x11\xae\xee\x84\xaa\x5e\x78\x5a\x48\x0d\x45\x17\x30\x23\x10\xb0\x37\x1e\xe3\xd9\xd5\x58\xe6\x02\x54\x56\xd3\x2c\x15\x45\x01\xb1\x59\x51\x9e\x61\x84\x22\x5a\x2d\x3d\xe6\xd9\x94\xa7\xe9\xd5\x6a\xe7\xbf\x86\x8b\xb5\x04\x60\xd1\xf9\xef\xf3\xac\x2f\xd2\xbd\x2c\x19\x83\xba\xe2\x65\xae\x58\xe7\xba\x93\x1c\x90\x8b\xe8\xa1\x8a\xd2\x0b\x3c\x5e\x21\x31\xb0\xf1\x6a\x4d\x0c\xe3\x24\x9b\x4c\x4b\x4c\x94\x88\xbe\x9e\x2b\xab\xee\xbe\xbd\xd6\x40\x22\x79\x19\xeb\x65\x25\x6f\xa7\x63\x91\x27\xfd\x66\xe6\x49\x43\x32\x7c\x31\x1a\x0f\xae\xb7\xfc\x6d\x93\xd8\x1d\x66\xad\x96\x56\xe1\x24\x59\x52\x8a\x66\x16\x72\x2b\xa8\x46\x87\xe0\xa4\xda\xa4\x09\x27\xb9\xaa\x19\x5a\x3d\x8b\x4d\xdc\x5a\x4b\x89\xea\x06\xaf\xd3\x1a\xaf\x15\x17\xdc\x19\xbf\x20\x67\xcf\xad\xfe\x95\xa8\x9d\xd4\x49\xd1\x31\xda\xe7\x1a\x6b\x39\x9e\xdf\xe7\x99\x50\x6c\xef\xbc\x98\xb1\x6b\x5c\x65\x6a\xdc\xaf\xbf\x47\xa8\x97\x1a\x0c\x95\x22\x4c\xb3\x84\x3e\x2a\xd7\xd7\xe1\x66\x86\xaf\x89\xb5\x59\x9b\x82\x0b\x57\x86\xbb\x0a\x93\xd0\x8e\x5d\xfa\x22\xb6\x09\xb4\xad\xfc\xe0\xbd\xb6\xe4\x69\x5b\xeb\x9e\xb6\x31\x67\x74\xf6\x4c\x26\x19\x7e\xd5\xb2\x09\x06\xe9\x72\x48\x39\x8c\xd2\x51\x9c\x41\x51\x4e\x14\x7c\x66\x16\x93\xcb\x06\xd5\x3e\x9a\x57\x0e\xbe\x6c\xb5\x76\x9d\x51\x18\xec\x21\xb4\xad\x8a\xc8\x0c\xc2\x39\xc5\xc8\x97\xc6\x3a\xaf\xe7\xdf\x1e\xf5\xac\xb4\x82\xa0\x9f\x1b\x62\x15\x05\x49\xd9\x12\x68\x88\x48\xb6\x4b\x20\xe2\xfe\x38\x89\x14\xd6\x50\x38\x01\x77\x96\xdb\x7b\xbb\xc9\x64\x8c\x4d\x34\x37\x09\xa1\xb5\xa2\x9e\x8c\x06\x40\x28\x95\x81\x31\xfa\xea\x4d\x87\x1f\xff\x15\x24\xc1\xd5\xfb\xfe\xc6\xb3\x63\xb8\x99\xa7\x5c\x70\x91\xcd\x81\xd4\xd5\xf6\xe4\x1d\xf6\x5a\x6f\x38\x92\x2a\xb2\xed\x1d\xb3\xe9\x0e\xb7\x64\xcc\x42\xb6\xa6\x03\x82\x84\xae\x13\xfb\xf1\x6e\x3a\xba\x23\xaf\x3f\xb0\xb0\x22\x8b\xea\x63\xb0\x13\xc9\xa1\x7a\xc1\xb0\xa6\x3c\xbb\x72\x72\x67\x9d\x06\x8f\x25\x19\x3b\x23\xeb\x7b\x36\xdf\xa6\x56\x6b\x0f\x13\x14\xfe\xb0\x19\xbf\x62\x33\xc5\xb3\x64\xd6\xae\x80\x3d\xca\x21\x86\x47\x79\x45\x8d\x71\x06\x03\x1d\x75\xc3\xb8\x05\x40\xd0\x26\x9d\x01\x49\x30\x3e\xe3\xb9\x68\x93\x06\x7d\x39\x4d\x07\xa0\xc9\xce\x8d\x0e\x93\xac\xbf\x31\x44\xd1\xf6\x66\xc6\xe2\x00\xc1\xa5\x49\x66\xbc\x2b\x92\xc2\x82\xbc\xbf\xc6\xc8\xa5\x02\x13\x36\x0a\x64\x5f\x2b\xa6\xaf\x13\xc3\xae\xce\x5f\x33\x87\x32\xcb\xad\x1b\xf0\x83\xa6\xa2\xe2\x83\x79\x81\x81\xb1\x08\xee\x85\x89\x79\x03\x82\x34\x67\xe8\x84\x0c\xd1\xe8\x83\x79\x2e\x67\xfb\x2e\xf4\x8a\x59\x3c\x30\x33\x70\xfa\x71\x36\xe2\x05\xc6\x59\xa2\xfe\x1e\x40\x8e\x10\x38\x05\xf3\xe0\x81\x47\xff\x5c\x85\x63\x7d\x19\xa3\x2c\xdf\x10\xae\x60\xe1\x29\x28\x33\x74\xd2\x38\xb4\xd2\x0c\xad\x2b\xcc\x75\x45\x04\xc9\xe4\x98\x1a\x23\x95\x0b\x91\x5f\x95\x60\x2c\x08\x04\xd0\x45\x1e\xd3\xb8\xd5\x43\x6b\x2a\x30\xb0\x90\x80\xa0\x26\x78\x98\xb7\x71\xf6\x6b\x26\xc4\x00\xca\x7a\xc0\xa3\x23\xe3\x3f\x20\xd9\x74\x15\x24\x93\x50\xd7\x57\xd2\x2e\x54\xcd\x45\x2d\xc2\xe2\x31\x4d\x34\x41\xad\x1a\x1f\x98\x67\xb0\xe7\x5b\xb0\x20\x52\x8a\x75\x25\x50\x20\x01\x0f\xc3\xd8\x17\x5a\x36\x1c\x73\x2c\x70\xa4\x4c\xcf\xe2\x3f\x05\x21\x5c\x51\x72\x74\x98\xbd\x96\x7c\x40\xdf\xce\x06\x7f\xad\x50\xc0\x2c\xc5\xa1\x27\x15\xb3\x24\x6c\x19\xe3\x0b\x74\xdf\x09\xbc\x1e\xe2\xa6\x17\xb5\x1e\x65\xff\x07\x6c\x2d\x40\x6f\xb6\xc8\xd4\x22\x62\x65\x11\xf1\x87\xa8\x3a\x4a\x2f\x6f\x50\xb1\x8c\x2d\x85\x51\xca\x50\xae\xc6\xd3\x13\x51\x9f\x0c\xeb\x25\x01\x17\xef\x99\xc1\xf7\x33\x72\x07\x6b\x1a\xc0\xb3\x08\x05\xd0\x01\x0a\x93\x72\x24\xa7\xa5\x6f\xa1\x65\x28\x37\xde\x68\x8d\x92\x9d\x4f\x79\xce\xb3\x52\xb8\x4c\xd9\x24\x8e\x47\xe1\xdd\x28\x66\x8d\x3e\x5a\x70\xdb\xc4\x36\x22\xb0\x17\xd3\x6b\xf2\x55\xf1\x58\xbf\x5d\x3c\x02\xc7\xa9\x58\x6c\x71\x0a\x91\x4b\xb6\x6b\x51\xe8\xd2\x98\x0a\x5c\x91\x8f\x36\xf5\x87\x35\x7d\x89\x58\xac\x04\x62\x32\xe0\x0c\x52\x71\xce\xfb\x57\x4e\x6f\x96\x11\x3a\x76\xb1\x65\x4c\xce\xb0\xd6\x3f\x27\xd3\xbd\x7e\x5f\xa4\x02\x97\x02\x89\x93\x31\x77\xf6\x6f\x64\xa2\x1b\xad\xb7\x63\x0d\x6c\x26\xba\xd6\x96\x81\xaa\x53\xb5\xe7\xf8\xb9\xdf\xb7\x71\xda\x98\x37\xb0\xfb\xb1\xac\x38\xbe\xbd\xeb\xcf\x7b\x47\x6f\x0f\xde\xfe\x73\x9b\x9d\x05\xf0\xcf\xf4\xca\x32\xb5\x52\x70\xa3\x9c\xd1\x7d\x22\xda\x62\x10\x85\x29\x82\x96\x49\x1d\xb4\xd8\x18\x56\x24\x19\x1b\x4e\xcb\x69\x2e\xd8\x05\x26\xdd\x01\xae\xc6\x2e\xaf\xb6\x9b\xbd\xd6\x4b\x1c\x0c\x80\xed\xce\x5d\xf4\x30\x7c\xc4\xbc\xba\xdb\x16\x4b\x2a\x8b\x18\x0f\x75\x15\x26\xa4\x8c\x31\x5b\xad\x58\x98\xac\xb9\xe1\x75\xab\x81\x83\xd6\xd7\xd9\xb1\x7e\xce\xfa\xbe\xb2\xc6\xf7\xc5\x90\x90\xc0\xe0\x8a\xda\x21\x0e\x53\x29\x31\xc7\x54\xe1\x32\xd9\xf6\xd2\x69\x9e\x5f\xb1\x52\x5c\x96\x95\x58\xb7\x34\xfa\x38\x84\x45\x04\x08\x9a\x72\x81\xc6\xbd\x45\x62\x91\x57\x6b\x94\x72\xd2\xf2\xa3\x46\x54\xeb\x60\x49\xcb\x8b\x5f\x51\xad\x05\x05\x2d\x3f\x78\x83\x4e\xac\x75\x89\xc7\xc0\x78\x80\x12\x5f\xae\x9e\xc9\x93\xe5\x27\xd7\xba\xc2\x06\xb9\xcd\x2e\x64\x7d\xb9\xf0\x13\xe1\x84\x43\x44\x4b\x0a\x93\x40\xef\xac\xcc\xa7\xe2\x0c\xb3\x08\xda\x40\x33\xaa\xd8\xa0\xb4\xbe\xc9\xd5\xd5\x00\xaa\x78\xa8\xa5\x38\xc0\x47\x83\x33\x5f\x94\xe1\xf8\x2f\x8f\x8d\x9c\xe9\x8b\x47\x31\x12\x63\x0e\x71\xc0\x53\x88\x6e\x83\x52\x37\x62\x93\xa4\x0d\x84\xf4\xc9\xf1\x38\x02\x62\xbd\x33\x20\xf9\x4d\x96\x32\x63\x30\xeb\x90\xc9\x59\x9b\xa5\xa2\x6c\x14\xf8\x64\xe3\xac\x28\xc5\x84\x69\x91\xf3\x80\xa5\x52\x7e\x60\xbc\xd4\xc1\xc5\xe5\x40\x27\x59\x4f\xaf\x58\x73\x56\x0e\x9f\xb6\x74\xde\x83\xa1\xb6\x7b\xcc\x4a\xe2\x9e\xac\xe7\x7a\x9e\xcb\x59\xc1\x24\x24\x19\xc2\x38\xc1\x20\x44\xc2\x75\x11\x83\xb6\x7d\xf9\x8d\xf9\x15\x1b\xf1\xc9\x04\x24\xe5\xbc\xf4\x60\x28\x9c\x1d\x27\x05\xdc\xfb\x03\x6a\xc5\x6c\xcc\xa1\x75\xdf\x3a\x2b\xec\x85\xc8\x87\x28\x97\x03\xb7\xc3\x48\x04\x06\xc8\xa3\x60\xce\x09\xcc\x6e\x92\xcb\x5e\x2a\xc6\x10\xb1\x4b\xa7\xbf\x86\x54\xd8\xe6\x2a\x6c\x5e\xc2\x8a\x5c\xb5\xda\x5a\x8c\xc4\xd3\x14\x54\x37\xda\xd4\x50\x51\xd4\xe9\xd8\x24\xd7\xb3\x31\x01\xb5\x0b\x3f\x32\x64\x5d\xbb\x5e\x33\xca\x69\xd8\x17\x82\xc2\x93\x09\xe6\xe2\xab\x8c\xb9\x6d\xde\xd6\x85\xd0\xe3\x3f\xbb\x3c\x43\x74\x95\x93\x33\x6a\xcc\x4f\x57\x9e\x95\x72\xc6\xf3\x41\x01\xeb\xa0\x80\x2b\xfa\x25\xf8\x80\xc9\xa1\x3e\x09\x65\xa1\x4f\x70\xd7\x5e\x72\x60\x6d\x83\x41\xec\xcc\x25\x8b\xc6\x33\x2e\xb0\x1d\xa4\xef\x71\x99\xec\xf4\x71\x6c\xb9\x38\x38\x6c\x97\x75\x42\x9a\xd8\xad\x84\xf3\xc2\x76\x55\xeb\x48\x68\x1f\xc4\xfc\xba\x26\xdd\x3e\xa3\xe7\xbc\x45\x88\x59\xb4\xdb\x30\xb4\x57\x6e\x43\x91\xd0\x4e\x75\xf3\x30\xfe\x97\x8d\xac\x19\xd0\x8b\x07\x0f\x2a\xa7\xcf\xbe\x70\x8d\x9c\xd5\x2f\x06\xdb\x21\x42\x2b\x9a\x0d\xf6\x90\xe9\x80\xac\x8d\xc9\x65\x9b\xa9\xdf\x18\xe6\x15\x7e\x6e\xb4\xb4\x4c\x57\xc3\x83\xf5\x3e\x35\xe1\xbb\xbd\xcf\xcf\x2a\x9f\xbb\xea\x32\x7e\x3e\xd2\x89\xae\xc9\xd9\x8f\x05\x41\x94\xe5\x68\x26\xf2\xa4\x10\x6d\x43\xd3\x50\xfa\xcf\x15\xff\x3e\x40\x0c\x6b\xeb\x14\xbd\x6d\x76\x86\xbb\x86\x14\xf2\x0c\x16\xf3\xcc\x97\x13\x68\xf3\x95\xec\x42\xe4\x25\x06\xcc\xad\xe2\x8a\x97\x45\x93\x36\xd0\xe1\x73\x2b\xdb\x1c\x34\x08\x17\xa5\x84\x7c\x9a\xb6\xcf\xf8\x12\xa5\x98\x28\xd3\x75\x54\xbf\x64\x36\xb3\x22\xee\x0b\x80\xa0\x0e\x72\x4e\x0a\xa3\xcf\x0d\x91\xda\x98\xeb\xd5\x7b\xb6\x6c\x07\x06\xd5\xf4\xfa\xd6\xea\x3e\x90\x23\x9d\x11\x48\x46\xd1\x11\xca\x67\x8c\x29\xb6\xd7\xa7\x97\xcc\x87\xc2\xa8\xca\x83\x98\x27\x45\x0d\x9a\x9a\x34\x0b\xbe\x04\x8c\x55\x64\x33\x61\x3b\x8f\xd5\x86\x7a\x51\x79\x4e\xbd\x2c\x67\x79\x4b\x67\xb4\x86\x2d\x74\x82\xdf\xcc\x9a\x79\x13\x87\x98\x83\x12\xf5\x76\x85\x01\xa1\x2d\x7e\xa8\x7d\x23\x28\xc5\x51\xf8\xb5\xba\xe1\x74\x8d\x1f\x1f\xeb\x54\xfd\x0f\x63\xbe\x7d\xb9\xf8\xdf\xa9\x28\xca\x24\x3b\x07\x63\xae\x0e\x9a\x30\xcb\x21\x29\xb0\x00\xe6\xb4\x17\x83\x78\x73\x32\xd3\xd5\xcc\xbc\x8f\xc4\xff\x4e\x93\xdc\xb7\xf3\xf6\xc7\xda\xf6\xfb\xa6\x09\x91\xec\xc8\xf5\x6b\x28\xfa\xfe\x59\x64\x03\xee\xd9\x78\xdb\xc7\x90\x3f\x86\x20\x90\x54\x52\x98\x61\xb3\x5d\x76\xff\x3e\x19\xc8\x83\x07\xf5\xc6\xe8\x4b\x3f\xc4\xfc\xb5\x26\x20\xa9\x0f\x9e\xfd\x06\xce\xa5\xec\xef\x64\xc4\xf8\x89\x8c\x59\x5b\xc7\x99\x41\xd3\xd5\xf8\xc5\x5b\xc5\xc6\x59\x03\x5c\xfb\x3d\x5c\x79\xa8\x3e\x3b\xb2\xe9\x76\x3c\xa8\xaf\xc7\x4b\xaa\x7b\xcf\x3e\xd7\xee\x21\x6b\x78\xe7\x22\x37\x8b\xd9\xbb\x02\xe2\x47\xc7\xe4\xd7\xd5\xae\xb4\xea\xb8\xce\x64\xfe\xa1\x6d\xf3\xd5\x94\xd2\x84\xae\x67\x49\x69\x64\x30\x11\x58\xe4\xf9\x67\xe3\x4c\x9b\x65\xf9\x42\x22\x91\xaf\x34\x40\x23\x50\xcd\x3a\x49\xc8\x2f\xea\xfb\x5f\x35\xb1\xfd\x2b\x54\xb5\x4a\x0a\xf5\xc3\x52\x48\x99\xb1\x0f\x42\x4c\x4e\xe4\xb9\x00\x22\x19\xee\x98\x43\xc6\x0a\x01\xa8\x15\x65\x34\xa0\x0b\x75\x31\x52\xd0\xce\xe2\xdb\x23\xef\xc4\x63\xcf\xd3\x1a\x38\xa1\x8d\x48\x3d\xff\xa6\x88\x96\x42\x3d\x4b\x72\x08\xc5\x08\x6f\x23\x93\x33\x84\x43\xfc\x9c\x42\xa4\xa2\x5f\xca\x7c\xcd\x33\xe0\xf7\xfb\x82\x70\xcb\x00\xc2\x72\x8b\xc1\x60\x62\x8f\xfb\xee\xff\x4e\x45\x7e\x75\xac\xe1\x37\x69\x0b\x12\xf2\x37\x32\xde\x4c\x96\x6c\x88\xc6\x86\xe8\xfd\x18\xba\x41\x59\xe5\xee\x7d\x0f\x68\xe8\x48\x60\x56\x50\xeb\x61\x03\xae\x4d\xdf\x6b\x41\xe7\x90\x6d\x8e\xc1\xc8\xed\xd2\xd8\x6c\x52\x98\x1f\xca\x3c\xaf\x0c\x20\xfd\xdc\x19\x80\x53\x00\x84\xaa\x81\x54\x52\x49\x0a\x21\x2e\xd4\x0b\x81\x84\xb1\x71\x43\x8f\x2e\x99\xcd\x8a\xe1\x4d\xcc\xcd\xac\x4e\xf0\x04\xd5\x0d\x2a\x9c\xd9\xdc\x57\xb1\x51\xe8\x4a\xf7\x69\x82\xb8\xd8\x72\xad\x45\xe4\xde\x3e\x0b\x16\xc6\xed\x89\x9c\xad\x40\x84\x68\xde\x43\x56\xbe\xe8\x55\xee\x3a\xfd\x1e\x0e\xcb\xf9\x7a\xfa\xf5\x6c\x09\xb9\xc1\x7e\x52\xec\x73\x9f\xa7\x10\xfa\x46\x07\xc4\xd2\xac\xef\xdc\xd0\x37\xf6\xd9\x96\x81\xe1\xb7\x05\x33\x37\x36\x4d\x32\x10\xcf\xf9\x24\x29\x79\x9a\xfc\x0a\x17\x87\xdf\xd0\xcb\xea\x4c\x1b\x69\xc6\x98\xb4\xed\x96\xf2\xb5\x9c\x19\x67\x1f\x53\x97\xa7\xa5\x0d\xac\x43\x01\x47\x63\xeb\xc8\x49\xb4\x6e\xcf\x65\x86\x36\xd2\x9b\x2a\x1d\x39\x4e\x7e\x15\x95\x10\x4a\x1e\xee\xbd\x4f\x45\x66\x62\x32\x21\x85\x31\xb9\x50\x3d\xc2\x68\x43\x94\x8c\xf9\x07\x75\x37\x39\x17\x76\xdc\x6a\x30\xfe\x29\x0b\xe3\xd3\x61\x76\x16\xc2\x1c\x89\x0c\x62\x4f\x4c\x92\x4b\x91\x16\x90\x16\x49\x66\xff\x99\xea\xeb\x4a\x75\x6b\x3c\x6f\x26\x10\xa6\x0c\x96\x50\x93\x2b\x0b\xe9\x3d\xae\xc2\x29\xeb\x54\xe7\xf7\x77\x3d\x08\x78\xc8\xd8\xf8\x06\x11\xd1\x36\x56\x80\x38\xce\xde\xef\xe5\xfa\xb1\x37\xf1\xfa\xba\x96\x09\xac\x63\x50\xd9\xe8\x78\x0b\x1d\x77\xa8\x32\xda\x7f\x98\xce\x75\x4f\x8b\xc7\xfb\x90\x84\xf0\xa9\x87\xdb\x09\xe0\x9a\xd1\xde\x3c\x50\x80\xaf\xd6\xeb\x8b\xac\x04\x3d\xad\xa7\x2d\xc5\x50\x92\x58\x14\x1b\xa6\xfb\xa2\xf0\x4c\xc7\x59\xaa\x8c\x1d\x02\x2c\x61\x77\xcf\x89\xff\xae\x02\xf2\x13\xd8\xf7\x4c\x0b\xe3\xfd\x8f\xec\xc8\xa0\xea\xdb\xab\x30\x88\x7f\x08\x74\xd1\x0a\xdb\x78\xbf\x2f\xa7\x99\xcb\x91\x04\x51\x1a\xd4\x3d\x80\x31\xb8\x20\x5d\x68\x36\x94\x2e\xf2\xb5\x99\x55\x31\x37\x4d\xdb\x5c\x79\x37\xfe\x7c\x03\x63\xd0\xa7\x97\xd8\x34\xf6\x8b\x82\x66\x7e\x0f\x48\xc6\xa9\x97\xc0\x0d\x21\x61\x9e\xbf\x1a\x48\x98\x42\x2a\x02\x49\x71\x90\x98\x2e\xdd\x87\xe9\xd6\x75\xd7\xec\x5d\x67\xde\x79\xa9\x4e\xa7\x53\x19\x97\xd9\xbf\x49\x8e\x16\xd5\xde\xbd\x0b\x0f\x51\x4c\x81\xa6\x85\x94\x90\x1a\x5d\x66\x65\x72\x3e\x95\xd3\x02\xad\x82\xdc\x25\xb6\xc6\xbc\x31\xda\xc4\x44\xf8\x47\x92\x69\xe1\x38\xe2\x54\x15\x9f\xda\xae\x75\xab\x6d\x92\x14\x55\x2d\x33\x76\xbd\x86\x15\x07\x6e\xe4\x14\x77\x59\x33\xc2\x4d\x42\x62\xdb\x76\x90\x3e\x3b\x56\x11\x87\xd2\xc6\x29\xe4\x8a\xe9\x69\xba\xb1\xb5\x96\x83\xa0\x6f\x8b\x36\x6b\x34\x5a\xed\x18\x6f\x3b\x57\x6c\x30\x27\x52\xa6\x8b\xd4\xfb\x59\x62\x66\x3a\xf8\x4b\x46\xcf\xf4\x1a\xc4\xe3\x68\xfe\x64\x6a\xb8\xc0\xc3\xce\x08\x9b\xc4\x33\x56\x2c\xad\xc8\x2a\x89\x7b\x1a\xe0\x42\x42\xa5\x7c\x91\x76\xff\x1f\x7b\x6f\xbb\xde\xc6\xad\x24\x0c\xfe\xd7\x55\x94\x3d\xe7\x98\xa4\xd4\xfc\x94\x3f\xa9\xc8\x1e\xc5\x56\x12\xcf\xd8\x96\x5f\xdb\x49\x4e\x46\xd1\x4a\x50\x13\x14\x3b\x6e\x76\xf3\x74\x37\x25\x32\xb6\xf6\x99\xbf\xfb\x7f\xff\xbc\x17\xb0\x7b\x61\x73\x25\xfb\xa0\x0a\x9f\xfd\x41\x91\x22\x9d\x78\x76\xe2\x79\x26\x47\x44\x03\x85\x42\xa1\x50\x28\x14\x0a\x55\x54\x27\xdf\x52\x40\xcb\x9d\xc5\x74\x3b\x27\xdc\x92\xf2\x86\xf3\x7d\x3e\x71\xe2\x1c\xe0\xdd\x93\x90\x40\x2c\x55\x4e\x71\x92\xee\xb6\x5b\x03\xe9\xfd\x96\xa9\xe6\x27\x37\x38\x24\x66\xec\xeb\x8b\x0f\x4d\x19\xdb\x5f\xfe\x9d\xc5\x13\xf5\x27\x59\x1d\xe5\x0f\x69\x8f\x94\xbf\xd0\x4a\xb9\x05\x88\xea\x21\xf3\x47\x16\xf5\x7d\x16\x91\x4c\x64\x16\x67\xe0\xd2\xa5\x4b\xe0\x20\xcd\x54\xbf\x4d\xa4\x91\x82\xd9\xe4\x18\xb2\x6c\x9b\xb0\x95\x2d\x55\x66\xc1\x8c\x27\x93\x84\x0b\x42\x70\x96\x06\xf4\xa4\x76\x1e\x4f\x05\xcc\xe8\xa3\x8e\x2d\xc5\x28\x02\x0c\xee\xff\x59\x4c\xd7\x61\xf8\x34\x20\x09\xb2\x8c\x47\x10\xb2\xe8\x62\xca\x2e\x78\xda\x02\x8c\x0f\x28\xf4\xe8\x30\x9c\x43\x9d\xec\xfb\x68\x6b\x95\x03\x6d\x78\x70\x46\xe8\xa1\x11\x4b\x40\xc4\xcf\x12\x49\x3c\xc1\x0b\xf0\x36\x89\xa5\x5e\x85\x00\x91\x42\xb6\xf5\xd6\x05\x98\xc9\xec\x7b\x08\x4f\x14\xe8\xfb\x01\xf2\xb8\x8a\xc7\x2a\x9e\x27\x9f\xb1\xf1\x04\xcd\x93\x66\xc2\xb2\x78\x82\xd4\x82\xba\xb9\xce\xb0\x7c\x45\x48\xa1\x60\x61\x70\x11\xf1\x41\xc3\x9e\x4d\x49\x71\x6c\x47\xb5\xdc\x96\x88\x96\xdb\x4e\x19\xa2\x45\x13\xfa\xdb\x93\xe2\xde\xd4\x11\x0c\xd4\x94\x46\xea\xba\xf4\x84\x42\x4d\x56\x27\x85\xa0\x3c\x10\x66\x77\xf4\xa8\x1b\xe4\x18\x75\x8c\x3e\x9f\x5b\x4e\x27\x92\x10\xff\x9a\x66\x2c\x0b\x7c\xfc\x53\x9c\x3a\x95\x2d\x10\x0b\x78\x34\x35\xc6\x3a\x29\x1d\xd8\x20\x8e\x42\x3b\x5a\xa0\xc5\xf3\x95\x0f\x34\x9c\x13\x0c\xbe\x79\xc1\xc4\x07\x44\x2d\x71\x44\xc0\x34\x08\xf2\x7f\x05\xe5\xa5\xc3\xb9\xa9\x20\xbd\xcf\xe5\xc4\xe8\x53\x85\xa9\xa0\xfd\xd2\xa9\x5c\x56\x22\x82\xba\xbf\xac\x72\xdd\x5a\x70\x93\xaa\xa5\x8e\x2d\x58\x46\x35\x84\xea\x2d\x83\xa1\x26\x01\x1e\xe5\x64\xbe\x8e\x33\x33\x0c\xc9\x8c\x6a\x04\x67\x5b\xd2\x33\x3a\x30\x91\xd8\x53\x3b\xde\xaa\x8a\x2e\xb6\xdb\xc8\xe7\xec\x67\x42\x21\x0a\xb2\x80\x85\xe0\x78\x31\x91\x60\x56\x39\x5b\xd2\xe9\x79\xca\xff\x39\xc5\x50\x7f\xce\x0c\xf8\x61\xec\x7f\xbc\x0a\x52\x0e\xf5\x38\x01\xd4\xaa\x78\xd2\xd4\xa5\x0d\xb5\x06\xd6\xdf\x39\x9a\x70\x50\x08\x8a\x5b\x0f\x32\x29\x54\x53\x23\x9f\x64\x98\x5d\x03\x4b\xe7\xa4\x93\xe8\x41\x93\x9c\x20\x63\x7a\x85\x99\xc5\x70\xc5\xc2\x8f\x6e\x06\x94\x54\x55\xd6\x43\x71\x37\x2c\x69\xc4\xb6\xea\x93\xf1\x4e\xea\xa4\x81\x15\x49\x3f\xe7\xcf\xa7\x01\x96\x85\x7d\x56\x18\x96\x26\x03\xe9\xba\xc9\x40\xba\x8b\x92\x81\x74\x4f\xa0\xaf\x9e\x6c\xa9\x03\x33\x06\x4d\xdc\xcf\xb3\x49\xc9\x49\xd9\x3a\x36\x96\xd4\x27\x4e\x22\x68\x3b\xd0\x6d\xb4\xfc\x38\xf2\x59\x56\x2f\xaf\xd7\xf1\xa8\xe3\x86\x1d\x9d\x50\x0d\xf3\x19\xc6\x29\x14\xea\x61\x82\x81\x2f\xfa\xe2\x37\xee\x9c\xa2\xfb\x6f\x0f\x7f\x38\xf8\xe9\xe5\xd1\xbb\xf7\xf2\x7a\xe8\xbb\x57\x2f\xdf\xf6\xa1\x26\x74\x84\x9a\xb7\x05\xf0\xfc\xd5\xd1\xf3\x7f\xff\xf9\xe5\xfb\xc3\x3e\xd4\x34\x55\xe9\xcb\xd1\x8f\x6f\x3e\x1c\xbe\x73\x2a\xe4\xa6\xb3\xb6\x75\xbd\xf7\x3f\xd8\x56\x2a\x88\x58\x66\x2a\x25\x2b\xd9\x19\x26\xf5\x2c\x0d\x6d\xe1\x19\xff\x3e\x75\xed\x79\x26\x80\x9d\xd9\xa6\xba\xf2\xe0\x17\xd5\xe6\x51\xec\x6e\xb1\x39\x54\x7b\x52\x2b\x15\xf1\xde\xbd\x42\x3c\xac\xfd\xfd\x8a\xd0\x50\x0d\x63\x03\x4c\x39\x1f\x0b\xc5\xe5\x23\x47\x1a\xe0\xf6\x9d\xcc\x71\xd9\xc6\x10\xc6\xf1\x04\x49\x77\xce\xce\xc9\x21\x25\xe1\x32\x8b\xbc\xb4\x58\xd0\xce\x87\x33\x32\xd7\x6f\x9a\x04\x46\x94\x1f\x29\x18\xc8\xeb\xdc\x2a\x8b\xee\x82\x84\x3a\x0b\x5c\xd3\x75\x69\x89\x0f\xa9\x4e\xba\xa3\x0a\x16\x24\xdf\x59\xd5\xb0\xa7\x3f\x2b\x5d\x5b\x1a\x8e\x16\x44\xb0\xdf\x2b\x49\x24\x52\xdd\x55\x17\x23\x3b\xd6\x6a\x26\x51\x4b\x18\x4c\x8e\xd0\xdc\x4e\x6f\x55\xc5\xb1\xef\x2a\xc8\xfc\x11\x68\x67\x5b\x65\x77\x32\xef\x28\x53\x6e\x64\x45\x0b\xa5\x84\xb4\x27\x3a\xd0\xac\xed\xad\x30\xae\x13\x9d\xe7\x2c\xe1\x4c\xc6\xa1\xc9\xc1\x35\xc2\xa4\x04\x78\x99\x50\x5f\x02\x64\x5e\x4c\x2d\x07\xd9\xc3\x7d\xab\x0c\xbe\x8c\x50\x51\x06\x27\x4f\x3d\xcd\x95\xba\x52\xc9\xdb\xab\x34\xe3\x13\x25\xbf\xad\x18\xa2\x86\x8d\xc4\x06\x84\x0e\x50\x9f\x3f\x5b\x80\xe4\x8e\x25\xd6\xa3\xd9\x26\x16\x99\xea\xc9\x6d\x6f\x05\xe6\x84\xdb\xb1\xa6\x89\x88\x94\x0b\xf4\x5e\xea\xf4\x6a\xae\x0b\x87\x15\x35\x5d\xab\xb4\x0c\x03\x2c\x64\x09\x79\x17\x2a\xf3\x52\x79\xc6\x80\x31\x9b\xab\xf0\xfc\x30\xe0\x7e\x30\x66\x21\xe6\xe5\x16\x67\x24\x21\x71\x2e\x62\x29\x95\xfc\x18\xdd\xe3\x13\x95\x8c\x54\xad\x14\xd1\xc5\xbe\xe5\x1f\x68\x30\x8e\x2f\x79\x12\xb2\x49\xfa\x8e\x0f\x6d\x2d\x90\xce\xb2\x64\x51\xbe\x77\x0f\x6c\xa7\xc2\x23\xdb\xd3\xa7\x01\x4f\xe5\x47\x33\x74\xf2\x70\x14\xf3\x9c\x03\x27\x7d\x4d\x2a\xe0\x51\xab\x6f\x8a\xe0\x64\x47\x45\x78\xe8\xb0\x58\x01\x4d\xfa\x47\x96\xa1\x97\xc5\x93\x32\x68\xca\x24\x5e\x01\x10\x5b\x95\x60\x77\xae\x12\xa3\x38\x24\x1d\x86\xf1\x55\x2a\xbd\x6d\x6e\x1e\x6c\x2e\x27\x57\x63\xaf\x08\xeb\x9d\x4c\x1d\xb5\xc4\x4c\xe4\xf3\x96\x95\x81\x23\xcf\xa1\x1b\xc7\xe9\xa6\x4c\x2b\x03\xf4\xad\x4a\x27\xb9\xcc\x24\x14\xb2\x99\x95\x92\xed\x5b\x7b\xe3\xab\xe2\x48\x97\xc8\x8b\x78\x2d\x47\xc2\x6a\x36\x72\x88\xb3\x90\x3f\x72\xa3\x37\x4b\x1a\xf5\x04\x7a\xdf\xac\xf6\xb4\x60\xa8\xaf\xfc\x8d\x33\x96\x7b\x21\x25\x0f\x91\xb2\x83\x1b\x72\x31\x98\xcd\x6f\xc2\x07\x3f\x59\x5b\xe7\x9d\x3b\x4a\x70\x8b\x8f\x96\x25\xe5\xde\x3d\xa1\x62\xe9\x1e\xef\xdd\x83\x52\x93\x55\x29\x55\x17\xb6\x13\x07\xd3\x72\x0a\xdf\x59\xb5\x3f\x49\xf2\xc5\xed\x0a\xfd\x7d\xeb\x30\x91\xd8\x6f\x6c\x71\xf6\xf9\x73\x29\x4f\xc9\xfd\xc7\xa6\x9e\x13\xd4\x99\x22\x30\xd3\x41\x90\x1c\x4e\x33\xa1\xaa\x63\x70\x5d\x31\xbd\x42\xf3\xb3\xc3\x20\x2b\x2d\xd3\x8a\x53\xb3\x3c\x36\x76\xa2\x60\x7b\x57\xd3\x3b\xe4\xb1\xde\x16\xb5\xe2\x71\x6d\x77\x51\x3d\x14\x70\x14\xab\x1b\xac\xa0\x05\xd8\x85\x00\xb2\x93\x15\xf3\xb6\xe5\x08\xea\x26\x99\x49\xad\xe7\x44\x78\x4c\xb8\x62\xf4\xca\x0a\x1f\x7e\x26\x97\xe8\xd8\xc2\xc2\x18\xb3\x64\x65\x23\x03\x4b\xcc\x82\xd0\x62\x33\x0a\xda\xae\x1f\x8c\x5e\x71\xdc\x24\xd9\x40\xbf\x55\xa5\x77\x11\xf6\x68\x0a\xd7\x58\xd5\x1e\x76\x4a\xa5\x2e\x04\x77\x5d\xa0\x79\xdf\x1c\xe5\xb5\x10\xf8\xda\x09\xd3\x5a\x79\xe6\xa1\xb3\x17\x1d\x66\x73\x4f\xc7\x2b\xed\xf6\xff\xf3\x8e\xa9\xf6\x85\xb3\xf5\x1a\xfb\x4f\x73\x3a\x58\xf5\x00\x55\xae\xa4\xad\xbb\x5b\x58\xbe\x05\xae\x03\x40\xa2\xbd\x17\x72\xcf\x3d\x2a\x1c\x06\x96\x4a\xdc\x63\x37\x20\xa7\x08\xd1\x42\x7a\x4a\x98\x74\xb3\xf6\xf5\xa0\xa5\x51\xb9\x77\xe8\x8d\x45\x57\xdb\xea\x9e\x7d\xbf\xb2\xb5\xb9\xd1\x1e\xe7\x93\xdf\xb8\x68\x28\x50\x4f\x0b\xa0\xd2\x35\xd0\xa0\xb6\x37\x3d\xb0\x7e\x1e\xa3\xb3\xb4\x71\xc2\xb2\x93\x70\x51\x6c\x8a\x1d\x19\x36\x25\xca\x62\x60\x30\x99\xc9\x62\x2b\xf2\x4e\xf9\x4a\xff\xa4\x05\xc8\xff\x49\x48\x5f\xe7\xe2\x6e\x95\x99\x50\xd3\x2c\x81\x26\xfc\x64\x77\x4c\x78\x55\xd4\xb7\xe7\xbf\x09\x67\x34\xd1\x67\x10\x27\x70\x86\xd3\x7f\x56\x21\x1e\x1c\x2d\xb1\xa2\x4e\xfe\x75\xac\x2b\x25\xde\xe0\xf8\x3f\x5b\x77\x00\x84\x75\x10\x49\x4f\x11\x4f\x60\xa1\x9f\xea\x4a\xea\x06\x43\x88\x62\x1d\xb0\x84\x27\x1c\xf8\x2c\x4b\x98\x9f\xe5\x85\x49\x16\x23\xb8\x7a\x9a\x25\x9e\x3d\x4a\xcf\x45\xbd\xf8\x86\x57\x9b\xc6\x52\x3e\x61\x42\x64\xca\xf9\xc2\x8b\x30\x41\x50\xb5\x26\x85\x08\xc0\xb0\x31\x49\x0b\x93\xae\xd4\xdb\xf5\xfa\xb3\xfe\xaf\xcd\xcf\xbf\xee\x34\x9e\xfd\x3a\xd8\xfe\xb5\x25\xfe\xdb\xa8\xb7\xb6\x1b\x6d\xcb\x52\x42\x57\xda\x3b\xd8\xfc\xb8\x6b\x62\x06\x53\xa8\x1a\x2a\xee\xe9\x2c\x69\x2f\x87\xe4\xcc\x27\xce\x88\x2a\x5a\x93\x74\xef\x8b\x40\x48\x53\x96\xc5\x89\x07\x2f\xe1\x62\xca\x53\x15\x84\xe0\x8e\x95\x4f\xc7\x0a\xe1\x95\x38\xf6\x35\xd1\xa1\xc9\x16\xfd\x77\x99\x2a\xba\x63\x3b\xdb\x72\x7d\x51\x6e\x9e\xb6\x18\x13\x8d\x00\x60\x79\xae\xb1\x94\x43\xed\xef\x93\x5a\x5f\x2b\x2f\xa6\x79\x2e\x79\x94\xaa\x60\x19\x33\x34\x00\xdd\x5e\xfe\x4e\x74\x41\xce\xde\x61\xc3\xcf\xcf\xa1\x63\x6a\x50\x89\xa8\x0b\x5e\x2f\x76\x6e\x4d\x2b\xd5\x64\x31\xfb\x57\xb7\xd3\x81\x6d\x2b\xf7\x8e\xb9\x39\xa6\x59\x13\x9a\xed\xe5\xa8\x26\x14\x44\xab\xe0\xaa\xd6\x70\xbc\x11\xd1\x53\xf3\x72\x24\xb8\xfa\xf2\x4a\x5a\x56\x55\x50\x34\xba\x76\xfb\x9d\xc3\x39\x4b\xf9\x40\x07\xb1\x0e\xf8\xd5\x24\x4e\x32\x3d\x8c\x94\xdc\xb9\xec\xd9\x28\x60\x61\xa6\x44\xd6\xd6\xde\x13\x3a\x6a\xb3\xfa\x43\x9a\x0c\x9d\x1c\xc4\x9e\x8c\xba\xd7\x42\x33\xad\xcc\xc8\xf9\xf9\x33\x74\xca\x83\xe4\xac\xd8\x07\x7a\xa3\xb8\x5d\x50\x66\x50\xbb\x07\x87\x6b\xc9\x3d\xa8\x7c\x06\xf2\xd4\x8d\x74\xcc\x60\x12\x21\x38\x1b\x48\xe9\x0b\x73\xbf\x86\x4e\x44\x82\x60\x42\x7f\x11\x2a\x87\x89\x66\x55\x00\x17\x8c\x25\x38\x02\x84\xeb\x6e\x32\xf3\xe8\x39\x2f\x57\x38\xfe\x36\x4d\xb3\x1c\x10\xed\x20\xa0\x10\xb6\xb6\x8c\xb7\x2c\x49\xb9\x80\x7e\x46\x62\xfd\x4c\xc9\xb6\x2c\x26\x61\x36\x89\x91\x27\xce\x66\xf2\xe2\x6f\x7e\xa6\x63\x6c\x39\x51\x32\x36\xb8\x6d\x50\xcd\x4d\xcb\xfa\x62\x3f\x82\xbd\xdf\x96\xe7\x54\x55\xd9\xc6\xf0\x59\xa1\x8f\x21\xeb\x98\x28\xa2\x9b\x68\xf9\xbc\x50\xdb\xd3\x82\x48\x0a\xc3\xdc\x85\x1b\xfa\x46\x11\x0e\xf2\x2d\xf1\x8d\x02\xdf\x73\xb1\xb2\x82\x23\x6b\x75\xf3\xb8\xe3\x81\xc9\x5c\xf9\x63\xca\x55\x7e\xc9\x60\x68\x07\xb6\x90\xde\x06\x71\xa2\xee\xf1\xa3\x81\xb4\x89\x06\x29\x74\x28\xdd\x02\x5e\x9f\xa2\x1b\x9a\xe0\xfb\x62\x88\x20\x93\xcd\x41\xbe\x8d\xc4\x67\xe3\x53\xe2\x18\x36\x0b\xe8\xb1\x13\xca\x0b\x4c\xd8\x47\xde\x3a\x14\xa7\x41\x56\x74\x52\x3b\xa8\xed\x25\xe5\x3f\xa8\xdc\xe5\xd5\xa9\x23\x73\x84\xb0\x7c\x68\xdb\x6d\x78\x8f\x1b\x9e\xf5\x6a\xd3\xb0\xad\x4c\x68\x67\x02\x8c\xc9\x0d\x9a\x8e\x08\x3c\x61\xd1\x40\xba\xe8\x51\x40\x96\x0b\x3e\x13\x07\xbd\x84\xa7\x29\xd7\xbe\x30\x3a\xf0\xf5\x24\x9c\xa6\x82\x88\xe3\x20\x9a\xa6\x90\x06\x17\xe8\xc6\x37\x4c\xe2\x28\x83\xfa\x4e\xb7\xe3\x41\xb3\xd7\xf1\x80\x67\x7e\x43\x69\xde\x09\xbb\x50\xd7\xe0\x84\x9c\xd4\xd0\xdb\xf5\x5f\x77\x3e\xff\xda\x6c\xb4\xf3\x19\xed\x45\x8b\xdc\x06\x29\x8a\x5a\x59\x12\x8c\xeb\xb9\x30\x9c\x2f\xc8\x7c\x20\x1d\xca\xdd\xc1\xeb\xd3\x30\x83\x09\x0b\x12\x6b\xec\x71\x22\x74\xc2\x20\xba\x08\xb9\x99\x23\x0c\x6a\xa4\x83\xea\x28\x0d\x03\x0f\x65\x7e\x3c\x1e\x33\xd1\x0a\x6f\x9d\x54\x16\x9f\xe0\x32\x20\x93\xbe\x1e\xa2\x9e\x2c\x7c\x42\xa4\x8b\xed\x27\x44\x55\x83\x4b\x39\x4b\x84\x9e\xe2\x7d\xfe\x35\x6d\xdb\x67\x8c\xeb\x86\x79\x78\xa3\x21\x1e\xcb\xce\x4f\xd0\x9e\x5a\x28\x35\xba\x83\x27\x75\x87\x66\xb7\x3c\x7e\x82\xb2\xa7\x3b\xc3\xbd\x1a\x05\x99\xf4\x2d\xa9\xa7\x0d\xb4\x83\xe7\x13\x88\x31\x49\x93\xba\xd7\x50\x0f\x73\x5b\x35\x27\x0d\xdf\xcb\xa1\xa6\x50\x90\xaa\x37\x05\x57\x5c\x16\x3a\xd9\xee\x4a\x38\x12\x4d\x43\x58\x53\x4f\xce\x58\xa0\x16\xe3\x04\xff\x03\xeb\xfe\xd2\xb2\xd5\xbd\x77\xc8\xb9\xfb\xd0\xfe\x35\xdd\xf6\x7e\x4d\xb7\x3f\xff\x9a\xee\xb4\xcd\xb1\x0b\x4f\xa6\x12\x1f\x19\xa5\xf0\x19\x1c\x9b\x99\xd3\x97\xe4\xb2\x92\xbe\x4d\x3f\x2e\x21\x2f\x31\xb0\xe9\x56\x9c\x34\x4f\x1a\x1e\x2c\x57\xb7\x7b\x72\xa2\x80\xe7\xfb\x57\x18\xee\x40\xb7\xd1\x38\x81\xbe\x05\xf1\xc4\x78\xe1\xe2\xb1\xc6\xec\x6a\x72\x79\x8a\x7d\x90\x42\x28\xc8\x70\x2d\xca\xab\x5b\x14\x85\x61\x7c\x85\xe9\x76\x73\x91\x5f\x88\x30\xf1\x24\xcd\xad\xc1\x38\x7f\xdd\xd4\x6e\xc3\xeb\x38\xcd\xec\x5d\x3a\x85\x84\x87\x73\xa5\x10\xc5\x89\x50\x22\x1c\x97\x45\xed\x30\x5a\x76\x9e\x95\x8e\x0b\x82\x39\xc5\x54\xdc\x31\x52\xb0\x6f\x24\x62\xa3\xf2\x2d\x80\x02\x99\x5c\xf0\x9f\x83\x6c\xf4\x56\x65\x6b\xb3\xe2\xe3\x5a\x71\x6a\xd4\x10\x3e\x08\x51\xce\x2e\x2e\x12\x7e\x81\x99\xcd\x58\x34\x87\xb3\x1d\x3a\x53\x35\xcf\x48\x9e\xe1\x1b\x13\x96\xf0\xa8\x96\xe9\x1b\x1f\x3e\xd0\x0a\x7d\xaa\x60\xf1\xd6\x45\xab\x0f\xdd\x0e\xec\xc0\xce\x03\xd8\x7f\x0a\xc7\x42\xfc\xed\x78\xb0\xf3\xe0\x04\xeb\xb4\x12\x3e\x98\xfa\xf6\xb3\x3d\xe6\xc1\xb9\xd1\x01\xc5\x8a\x66\xc7\xcc\x4a\x18\x42\x89\x24\x29\xdc\xea\x71\x6d\x47\xec\x02\x4d\x7b\x0b\x50\x72\xc1\x36\x43\x16\x20\xc0\xb9\xd1\xe2\xcb\xe8\x63\xd2\xfe\x58\x24\x62\xda\x44\x69\x14\xe8\x42\xe3\x45\xdd\xee\xdc\xd8\xaf\x35\x2f\x0b\x3a\xfe\x54\xa8\xa0\xd6\xca\xb9\x65\x46\xc5\xff\x7a\x70\x7c\xd2\x50\xb3\xf1\x83\x38\x6f\x5e\x61\x30\x03\xbd\x3a\xe4\x3e\x20\x17\x09\x1e\xf2\xe5\x29\x4d\x16\xd5\xc5\x81\x76\x46\x30\x72\x0b\x20\xcd\x8a\x09\x48\x6f\x7f\x6e\x95\xda\x73\x6e\xf3\xca\x67\xff\xd4\x99\xf3\x84\x6e\x45\xf2\x90\xcf\xb8\xaf\x5c\xee\x89\x03\xcd\xc2\x2d\xb9\x27\x2e\x2c\xdb\x78\x52\x52\x4b\xc8\x14\x59\xaf\xe7\xb2\xa3\x89\xda\x8a\xfb\x94\x3d\xe1\x12\x39\xb2\x98\xe3\x7c\x8b\x2a\xb0\x2d\x3a\xa5\xc2\x9e\xc5\xc2\x4d\xf3\xe8\x3d\x3f\x6d\x9a\x08\x66\x7d\x16\x33\x17\xff\xb7\xb3\xb0\x1a\x18\xae\xf1\x44\xdf\xf7\xd3\x20\xf7\x3b\x18\xf5\xd9\xe8\x2a\x64\x74\x60\x98\x77\xd0\x4f\x82\x73\x13\x0e\xd2\x7a\x32\x2e\xbe\x4c\x8a\xce\xda\xb7\x35\xe6\x52\xd7\xd2\xeb\xc8\xbc\x69\x36\x7a\xb5\x7a\xd3\x4c\xbf\x0a\x4e\x28\x05\x9b\xab\xb2\xe0\xfe\x29\xa6\x60\x47\x31\xbe\x21\xb7\xbd\x7b\x74\x70\x83\x82\x18\xde\xdf\xa1\x2a\x9a\xfd\xad\xc3\xc6\x8e\x3a\xb8\x74\x8a\xa9\xbe\x4d\xb5\xea\x93\x8e\x13\x7d\xce\x55\xe9\x1d\x0b\x50\x6e\x50\xfa\x72\xd6\x4d\x64\x8e\x99\x81\x76\x74\xe4\x0f\xe3\x93\x61\x62\x21\x41\xd3\x7c\xee\x9e\xe4\x4c\x24\x25\xbd\xb8\x81\x49\x96\xef\x66\x67\xb5\x6e\xb2\x78\x92\xef\x24\x0f\x26\xd7\x8b\xc0\x61\xc5\xb1\xe4\x62\xbb\x2c\xdf\x4f\x71\x30\xfa\x95\x8a\x66\x5f\xe3\x9c\xf2\xc7\x5f\x12\x7d\xb5\xa1\xf0\xe4\x0b\xa3\x23\x79\x15\x5b\xf5\x06\xbc\xe0\x19\x67\xfb\x45\x15\xbe\x7d\xfe\xbc\x6c\x40\x33\x7d\xf2\x70\xe2\xa1\x05\x69\xce\xf1\xc7\x8e\x4b\x94\x70\x7c\x5a\x20\x6f\x48\x09\xc0\x45\x8c\x91\xd2\xd1\x9f\x6a\x4a\x2f\x0a\xd4\xd9\x3d\xe2\xb3\xcc\x85\xce\xec\x28\x4d\x0a\x82\x8c\xce\xa4\x23\x1b\x59\x11\x7c\x75\xb6\x62\x8a\x9b\x85\x09\x11\x74\xc0\x2a\x74\x87\x3c\x4f\xe2\x8f\x3c\xb2\x5d\x2d\x8b\x6e\x87\xc8\xe0\x45\x07\x43\xc9\xe9\x65\xf4\xcd\x93\xb0\xcc\x3b\xf1\x8f\xf1\x8f\x2c\xef\xb9\x38\xff\x60\x8f\xd0\x88\xef\x9c\x1f\xdd\x24\x09\xe2\x24\xc8\x96\x8f\x9f\x88\xee\xdd\x32\xd1\x9e\x14\x0c\x49\x30\x66\xc9\xbc\x0f\x16\x1f\x63\x49\xde\x33\x1c\x72\xa1\xcf\xe5\x45\x95\xae\xa5\x9d\x08\xac\x1b\x30\xf3\x11\xbe\xb1\xc6\x63\x97\xdf\xbb\x07\xda\xbb\x84\xa7\x3e\x9b\xa0\xea\xac\xa3\xbc\xba\x4e\x07\xb9\x67\x77\x85\x5e\xbc\xf2\x4e\x72\x5a\x98\x91\x5a\xee\x23\xb7\x4f\xd7\x9e\xfd\xfc\x80\x2e\x2b\xa4\xf6\x2a\x73\x13\xa3\x69\xcb\x25\x97\x2e\xab\x22\xd8\x98\x99\xb7\x96\xa5\x9e\x44\x65\x77\xa0\x15\xd4\x56\xb0\x6e\x20\xf6\xd3\x4d\x13\xdb\x3c\x6d\xd4\x18\x54\xd0\x1a\x9a\xb6\x6b\xa6\x3b\x4c\xb9\xcb\x50\x60\x2f\x1d\x18\x91\x8e\xb8\x8d\x15\x26\x49\xe1\x90\x9b\x23\x1d\x9a\x29\xae\xf0\x24\x2d\x4c\x90\x75\x87\x6d\x1e\xef\x8b\x29\x58\x70\xf7\x2d\xa6\x4b\x2e\x11\x9c\x31\x3d\xff\x35\x7b\x2b\xcd\xfb\x80\x28\x49\x81\x8b\x8f\xee\x70\xeb\x8e\xfb\x86\x3e\x1b\x95\x3b\x94\x58\x6b\xf8\xaf\x2d\xd7\xac\xbd\x51\x30\xcc\x72\x2e\x19\xd5\x9a\xfa\xde\xaa\x4a\xb3\x64\x10\xd1\x89\xed\xf0\x54\xe1\x44\x6e\x45\x42\xc1\x26\xf9\x86\x41\x0a\xe9\x84\xfb\x38\x0c\xaf\x2c\xb6\x08\x86\xc9\x73\xda\x38\x11\x86\x96\x38\x5f\x2c\x75\x78\x30\x95\x17\x1e\x47\x2c\xff\xc9\x9c\x9b\x88\x79\x54\xe6\x2e\x95\x0a\x2b\x7d\x6e\xa1\xdd\xe0\xfc\x71\x5b\xf7\x0f\x6b\xae\x8e\x72\xe1\x52\x81\x12\xb4\xf5\xcb\x44\x09\xbd\x82\xce\x7b\x57\x28\x12\xf1\x68\xb0\x7c\x2b\x27\xaa\x80\x73\x53\x5b\xea\x30\x42\x96\x97\x6b\x89\xfc\x12\x6e\x64\x4a\x84\xd8\x63\x3c\x76\xf9\xe5\x66\xbf\x90\xff\x76\xb6\x85\xb5\x65\xc4\x28\x18\xd8\x39\x34\x56\x0f\x9b\x24\x00\x08\x66\xcf\xe9\xf7\x37\x07\x4e\x4a\xf8\x50\xc6\x14\xae\xf2\xd7\xb7\xd4\xcd\x2f\x12\x89\x3a\x8f\x32\x6d\x33\xad\x9c\x66\x29\x03\x84\x60\xd0\x4d\x5a\xdb\x4a\x5b\xc3\x03\xe1\xe7\xcf\x6a\x24\x74\x7c\x94\xca\x05\x79\x80\xdb\x5f\x45\x65\xf5\x51\xc2\xb1\xbe\x52\x75\x05\x98\xbc\xd4\xb5\x79\xfd\x00\xcf\x0c\xd3\x28\xe2\x3e\x4f\x53\x96\xcc\x31\xa8\x11\xf3\xc5\x2f\x81\xdf\x65\x90\x06\xe7\x41\x18\x64\x73\x18\x31\x0c\x96\xe4\x63\xc4\xc7\x81\xf6\x35\x40\xba\x8d\x50\xc4\xec\x93\x9d\xf7\xe6\xc7\x1e\x56\x1b\xcb\x32\x9c\x8b\xbb\x78\x5c\x9b\x35\xe3\x69\xd6\x8c\x87\x4d\x43\xb7\x9a\x95\x51\x38\x77\xe7\xbf\xe9\xa1\xe4\xd2\x07\x2d\x33\x16\xcb\xda\xbc\xf4\x60\x74\x9b\x3f\x49\x7a\x7c\xb5\x3a\x06\x3a\x83\x7c\x69\x1d\xe3\x4f\x0a\x5e\x85\x21\x0b\x16\x46\xae\xaa\xbe\x79\xc7\xed\x76\x7a\x8e\x4e\x6e\xaf\xe4\x5b\x2b\xe3\x43\xba\xf8\x02\x7f\xdf\x80\x91\x3b\xa3\xc2\x25\xaf\x12\x9c\x38\xd1\x7b\x1c\x30\x78\xd4\xc8\x61\xf0\xac\x04\x5e\x41\x5f\x38\x81\xbe\x13\x7c\xc5\x9e\xcd\x25\x1e\x16\x2e\x13\xb8\xc8\xb6\xca\x54\xac\x25\xc5\xc0\x5a\xb0\x7b\xc0\x99\x3f\xb2\x6c\x25\x26\xec\x85\x65\xbd\x26\x83\x0a\x06\x2e\x60\x69\x8a\x71\x15\x64\xfe\x9b\x20\x4b\xe1\x6c\x18\x9d\x99\xbc\xfd\x26\x90\xc4\x87\x11\x4f\xb9\x06\x63\x92\x98\xf8\x2c\x0c\xc9\xaf\x0b\xfb\xa6\x35\xe8\x49\xa3\x0d\x67\x51\x4a\x37\x82\xf3\x78\x8a\xb1\xdd\x04\x28\xb4\xea\xa8\x30\x5b\x94\x19\x73\xc2\x93\x61\x9c\x8c\x59\xa4\x5f\xa8\xea\x60\xf6\xfa\x93\xcf\x31\xd6\x43\xc8\x23\xee\x7f\x4c\xf5\x8b\x7c\x3d\x32\x45\x8e\xef\xa2\xdc\xd2\x17\x74\xfb\xaa\x04\x89\x8d\xd0\x92\xc2\x24\x3f\xe7\x14\x83\x64\x12\x4e\x31\x2d\x91\x8a\x9c\xcb\xc2\x8c\x53\x2a\x79\x1d\xd5\x2c\xc6\x98\x24\xca\xb0\x93\x5a\x33\x6a\x12\x5d\x4c\x53\x8e\x6e\xbe\x1c\x2f\xa8\x9f\x58\x31\x6d\xf1\xd5\x03\xc5\x44\x57\x31\x14\xce\x59\x1a\xf8\x9a\x11\x58\x18\x50\xec\xe7\x6d\x15\x67\xf7\x7c\x2e\xbd\x13\xce\x13\x96\xcc\xd5\x34\xfd\x98\x62\x6a\x52\xe4\x03\x8a\x51\xa5\x5e\x55\x38\xe9\xbd\xce\xf0\xe0\x7d\xe6\x11\x1b\xa2\x8f\x58\x8c\xe9\x82\x88\x27\xc9\x3d\xec\x40\x62\x42\x9e\x40\x76\xc6\xbf\x84\xbb\x53\x20\x99\x4f\xbb\xa5\x64\x57\x9c\x7d\x54\xc1\x7e\x85\x92\x43\xef\xa0\xed\x78\xbd\x14\x78\xc3\x50\x80\x8e\x00\x48\x7d\xb0\xd7\x9c\x22\x39\x1d\xd4\xac\x78\x71\x2a\xd4\x08\x66\x74\x8e\x13\x71\x02\x50\x71\x0c\xb5\x18\x22\x58\x2a\x0d\x9f\x9a\x12\x70\xb2\xcf\xb2\x41\xee\xb1\x56\x49\x44\x9d\xc2\x3a\x95\x20\xc4\xc2\x3f\x47\xe7\x1c\xe0\x01\x52\x89\x22\xd9\xd0\x4d\x3d\x85\xde\x68\x51\x6d\xb3\x07\x5b\x54\xc0\x0f\xb8\x6d\xe1\xdf\xed\x2d\xa0\x71\xf6\x95\x92\xb2\x8d\x7e\x77\xf1\x04\x3e\xd1\x95\xf0\x35\x59\x4c\xf6\xbb\x9d\x0e\x34\xe1\x25\xfa\x26\x28\x0a\xd9\x41\xf1\xd1\xfa\x18\x0f\xe5\xc5\xac\x18\x15\x02\x97\x06\x97\x3e\x74\x3b\x32\xf2\xbc\xd5\x83\x8e\x7b\x21\x9f\xee\xef\x63\xb8\x8b\x26\xfc\x3c\xa2\x00\x7e\xce\x6d\x9f\x79\xe1\x2f\xc6\x1a\xc5\x99\xea\x40\x96\x52\xca\xf2\x42\x1f\x46\x76\x5c\xab\x06\xc3\xa8\x4f\x83\xde\x42\xe3\x9d\xcd\x04\x1f\x90\x53\xa5\x8b\xa3\x23\x6d\x89\x1b\xac\x05\x07\x14\xa1\x66\x84\xf3\xcf\x66\x41\x4a\x64\xd7\x33\xa5\xc2\x7e\x38\x49\x45\xc9\x3f\xa4\x4f\x95\x9a\x70\x36\x99\xe1\xcc\x89\xd2\x90\xa7\xa9\xe7\xc4\x1e\x62\xa9\xf4\x54\xd1\xd5\xff\x4e\xf3\xfc\x77\xb1\x8e\x26\x3c\xf1\x79\x94\xb1\x0b\x0e\x09\x0f\x59\x16\x5c\xea\x64\xb2\xd2\xff\x40\xb2\x55\x59\xae\x04\x09\x6e\xb2\x0a\x9c\x7c\x02\x44\x09\xe4\xf2\xea\xcc\xc3\xa8\xad\xca\xf3\x97\xbc\x04\x95\xdb\xb9\xac\x34\xca\x57\x92\xce\x88\xba\x16\x55\xfd\x2e\x4e\x54\xaf\x18\xe2\x4e\x9c\x70\x39\x2d\x97\x31\x7a\xeb\xcd\x30\x96\xb1\x8b\xa6\xd9\xa3\x1d\x4c\x9d\xa5\xf3\x21\xb7\x6b\x49\xc7\x38\xc7\x11\x92\xc2\x32\x09\x02\xcb\x28\x44\x9e\x4d\x05\xb5\x2d\xca\x28\xab\xdb\xea\xb1\x41\x0b\x5e\x46\xe4\xf8\x1d\x0f\x65\xa8\x2a\x84\x41\x01\x8a\x3c\x08\x32\xbb\xa9\x1c\xb7\xcd\x2b\xbf\x60\xd6\xe7\xc8\x88\x63\xe5\x81\x47\x66\xd6\x3a\x4b\xe1\x8c\xee\xce\x09\x30\x5d\xa0\x9f\x35\x3c\x72\xd7\x73\x5d\xf8\x08\xa4\x68\x22\xab\x49\xbf\x2d\x94\xde\xcc\x38\xec\x09\x01\x52\x8f\x13\x8c\x96\xd4\xb0\x1d\xdb\xd2\x1c\xd9\x38\x84\x2c\xcb\x68\xfd\x31\xcb\xdd\x4d\xa5\xa6\xb6\x12\xef\x85\x9c\x91\x83\x9a\x90\xd4\xd3\x54\x6d\x94\x72\xf4\x04\x90\x12\x93\xe2\x5d\xfe\x65\xcf\xe9\xea\x40\xbf\xaf\x0b\xe7\x48\x35\xb5\x80\xd4\xc3\x3b\x99\x4f\x5f\x2a\x75\x58\x70\xce\xb3\x2b\xce\x23\x18\x04\x43\xe4\x71\xe2\x27\xb9\x12\xe1\x4d\x8c\x0e\x22\x2c\x83\xf1\x34\xcc\x82\x49\x18\xf8\xcc\x00\x12\x74\x49\x55\xcc\x2f\xb1\x6d\xe9\x24\x2d\xf6\xe4\xfc\x54\x16\x15\x0b\x67\xff\xec\x8c\xfe\xe8\x76\xe8\x7f\x6b\xdd\xce\xdf\x6b\xfa\x4f\x0f\xba\x1d\xf3\xeb\xef\xee\x4f\xd8\x01\xa7\x32\x34\xe1\xc1\xe5\x08\x76\x60\x57\x17\x36\xbb\x9d\xc9\x0c\x76\x44\xb9\x07\x0f\x26\x33\x68\xc2\x43\xf5\x51\x77\xfd\x14\xb6\xb7\xdf\x7c\xbb\xbd\xdd\x87\x97\x14\x9f\x6c\xc0\xd3\x80\x22\x75\x53\xc2\x1a\x75\x68\xc8\x62\x47\x55\xc0\x08\x93\xd2\x73\x57\x50\x87\xcd\x75\xa6\x91\xb1\x7a\x9a\xaf\x7a\x50\x1e\xae\x41\x52\x76\x51\x38\x8d\x86\x71\x92\x4d\x23\x96\x71\x31\x6b\x02\x07\x9c\x6e\x0a\x53\x19\xab\x14\xe4\x65\x51\x58\x5a\xaa\x87\xd7\x71\xc2\x69\x6f\x0d\x52\x38\x16\xdb\x23\xc5\x28\x12\x02\x20\x4d\xa7\xfc\xa4\x3e\xca\xb2\x49\xda\x6f\xb7\x2f\x82\x6c\x34\x3d\x6f\xf9\xf1\xb8\xfd\x1d\xff\xfd\xa7\x84\xa5\x19\x6b\x4f\x94\xb2\xd3\xc6\xda\x69\x7b\xf7\xd1\x6e\xc3\x9a\xc1\x65\xb7\x41\xa2\xd5\x8d\xfb\x60\x6f\xcd\x7d\xb0\xf7\x75\xed\x83\xd2\x0b\x23\x5f\x3b\xef\xab\xa3\x7d\x74\x40\x8b\x85\x5b\xfa\xe9\x80\xa2\xb7\xa1\x78\xa7\xb8\x0f\x17\x94\x31\x15\xa2\xd3\xda\x88\xec\x00\x9d\x3a\xf9\x10\xc4\xd3\x4c\xa7\x6a\x94\x66\x8c\xb9\xbd\xa0\x0f\x22\x48\x7d\x1e\xb1\x24\x88\x81\xcf\x82\x34\x4b\xe1\x6a\xc4\x93\x7c\x0c\x8c\x20\x4b\x79\x38\x54\x91\xbf\xc5\x22\x90\xa3\xb2\x82\x09\xd8\xd2\xeb\x67\x99\xc9\x87\xcd\x85\xe8\x1a\xb1\x14\xee\xd2\x25\xda\x20\xd7\xea\x2e\xfc\xd7\x7f\xfe\xdf\x62\xe6\xf0\x05\x86\xaa\x74\xd7\xd5\xf3\xe4\x62\xc0\x5d\xe5\x8a\xf2\x5c\x10\x9f\xf9\x18\xe6\xce\x62\x0b\x49\x8b\x74\x84\x8a\x30\xa9\x84\x7d\x6b\xb8\x4d\x18\xf0\x4c\x1c\xdf\x64\x4c\x44\x7b\x8c\x94\x7d\x12\xf7\xd5\xbb\x59\xc2\x26\x02\x0f\x28\x0c\x53\x6c\x33\x0a\x56\x20\xb4\x5d\xd5\x59\x70\x11\xc5\x89\x4b\x68\x04\x29\xc7\x44\x92\xc3\x51\x8e\xef\x5a\x88\xfd\x3c\xe2\x11\x9c\x95\x5c\x34\x9e\x99\xbc\x5d\x56\xda\x2e\x6b\x66\x52\xcb\x53\x80\x60\xa9\x39\xa7\xcc\x47\x06\x71\x3b\x3f\x97\x90\x4a\xea\x25\xbc\x0c\x05\xa7\xdd\x0d\x42\xce\x2e\x39\xc9\x8c\xdc\xe0\x9d\xe0\xfa\x92\x56\x2c\x13\x04\xb5\xb2\x8c\x0f\x2e\x78\x41\xd7\x6a\xdd\x42\x02\xe5\x2c\xb2\x37\x8a\xa2\xdd\x35\x45\xd1\xee\xd7\x25\x8a\x72\xc3\xd7\xcd\x94\xd0\x91\xad\xe5\x9b\x9b\x63\xe5\xdf\xb0\xaf\x0c\x54\xea\x85\x08\x99\x99\xf4\x4b\xe5\x13\xd5\xfe\xad\xc5\x09\x59\x32\xb7\xa5\x8a\x66\x0c\xa3\xa8\x67\x68\x15\x91\x9d\x08\x4e\x38\x9f\xab\xd7\x7c\x9e\x82\x98\x8d\x78\xe4\x99\x94\xc3\x1a\x8a\x3c\x28\xea\x30\x9e\x26\x6c\x26\xee\x83\x05\x3f\x8f\x33\x47\x2c\xaa\x81\xf5\x0b\xa6\x37\x13\xf9\x51\x0d\xae\x8a\x48\x8a\x51\xa4\x6f\xc9\xfe\x03\xf5\xfd\x60\x8c\x71\xa5\xe3\xa1\x7a\x6d\xe6\xf2\x0d\x83\x71\x10\x05\xe3\xe9\x58\xec\xdc\x19\x59\x66\xa4\x8e\xe5\x2e\x0c\x05\x4f\x3d\xec\x91\xcb\x8c\x8c\x43\xec\x23\x4f\x0b\xd1\xd6\x85\x4c\x64\xe1\x15\x3a\xf0\x42\x18\x64\x59\xc8\x15\x7a\x0a\x98\xdd\x95\x58\x55\xa9\x3a\x5e\xcb\x17\x2b\xd2\x67\x5e\x13\x8a\x5a\xf7\xe1\x41\x15\x19\x68\xff\xfa\xec\x24\x45\x2e\x50\x7f\xbf\x96\xfa\x49\x1c\x86\xe4\xff\x53\x53\x20\xac\xd8\x1d\x48\x24\x69\xfd\x50\xcc\xef\xa9\xa3\xf8\x99\xdd\xfa\xcc\x13\xc7\x82\x68\x10\x5f\x9d\x69\x2e\x39\x53\x67\x1e\x54\xdf\x59\x44\x46\x7f\x65\x22\x70\x46\x54\xc0\xad\x0f\x05\xe4\x6e\xda\x29\x1d\x1b\x5c\x4e\xda\x5b\x29\x17\xd2\x8c\xcd\x21\xe2\x2c\x41\xeb\x1e\x1a\x5c\xa4\x54\x52\xb9\x73\x85\x54\x14\x2b\x41\x60\x7c\xc1\x26\xce\xec\x64\x57\x71\x0b\x0e\x67\x13\xee\x07\x2a\xd1\xe1\x70\x1a\x8a\x9d\x29\x32\x19\x2c\x20\x90\x10\x95\x90\xc0\xe7\x70\x42\x45\x94\x06\x22\x96\x22\x9e\x01\xc5\xe0\x88\x03\x2a\x2d\xcd\xef\xd7\xb2\x2c\x20\x89\x60\x8c\x28\x9c\x03\x3b\x57\x39\x7e\xe9\xf5\x99\x38\x1d\x92\x12\x8a\x7b\x71\xa6\x35\x51\xa5\xf7\x52\x80\x58\x0c\x09\xbe\x55\xe0\x38\x37\x2b\x40\x25\x0a\xcb\x4a\x73\x3b\x32\xc4\x8d\xa2\xfc\xfe\x9a\xa2\xfc\xfe\xd7\x25\xca\xed\xb1\x97\x19\x59\x6c\xb7\xbf\xc0\x18\x39\x65\xf2\x5e\x2e\x73\x87\x28\xe9\x98\x33\x40\x48\x1e\x27\x58\x8a\x81\x82\xd4\x56\x02\xed\x69\x2d\xa6\x12\xcf\xad\x84\x02\x87\xb9\x66\xba\x78\x2a\x4e\xbf\xf8\xa6\x57\x09\x70\x17\x3b\x4c\xaf\x62\x22\xf6\x8c\xe2\x2b\x18\xb3\x48\xaa\x26\xf2\xa9\x51\x3c\xb4\x12\x48\x50\x00\x35\xb4\xa9\xe6\x6c\x46\x42\x46\x46\x31\xf0\xe1\x50\x3e\xde\x8b\xe2\x7c\x6f\x94\xd7\x12\x8f\xf4\x2b\x32\x24\xc2\xb9\x91\x13\x1f\xac\xc9\x89\x0f\xbe\x2e\x4e\xa4\x70\xf4\xf9\xca\x65\xfb\x02\x57\xbb\xc1\xf1\xac\x89\xad\x4e\x6a\x18\x87\x57\xe6\xdb\x89\x29\x57\x8e\xce\x9c\x4f\x12\x4e\xa1\xa6\xa5\xb5\x69\xbc\x84\xa8\xd6\x71\xbb\x88\x13\x6b\xa9\x65\x8f\x42\x51\x8a\x91\x30\x58\x42\x27\x78\x79\x30\x97\x29\x4b\xd0\x96\x52\x2a\xa1\xe8\xa3\x74\x5e\x48\xa5\x65\xd9\xd5\xad\x2c\xdb\xa6\xcc\xe3\x85\xc1\x3e\xdc\x3c\x52\x36\xb4\xed\xed\x37\x47\x1f\x0e\xfb\xdb\xdb\x39\x9f\x5d\x5c\x2a\x68\xb3\x4c\xa6\x13\x12\xc5\xfe\x34\x21\x4b\x0c\xb9\x7c\xf8\x73\x3f\xe4\xda\x0e\xa4\x10\x27\x1b\x7a\x90\xc9\x13\x05\x2d\x9d\x54\x27\xf5\x73\x89\xa3\xaf\x47\x57\xe3\x77\x01\xe0\x46\x76\x7f\xb8\x26\xbb\x3f\xfc\xba\xd8\x5d\x8c\xf9\x06\x65\x48\xea\xcf\xea\x1a\x69\x9f\x22\x3c\xd9\x27\x7b\x7d\xc3\xa4\x08\x42\x4e\x08\x15\x9c\xda\xca\x5d\x4b\x60\x1a\x5a\x52\x7c\xd0\xe0\xe3\xc1\x99\x0e\x11\x8a\x3f\x72\x71\x8e\xa5\x56\x64\x3f\x9c\x77\xde\x64\x07\x03\x05\xcf\x8a\x65\x5d\xc7\x7a\x74\x05\xc7\x42\x3b\xb4\x76\x4e\xa1\x92\x43\xb1\xa3\x32\xaf\xa4\x2f\x7f\xc8\x1d\x21\x29\x24\x2f\x32\xed\x28\x90\x1c\xab\x55\xd5\xa5\xb4\xfb\x4d\x29\xad\x4a\xab\x74\xa6\x4e\x6d\x71\x94\xcf\x18\x31\xb6\xb8\xd9\x3a\xd7\xba\x5b\xaa\xda\x3a\xed\x93\x8d\x33\xec\x88\x5f\xa2\xac\x50\xa9\x50\xd4\x89\x5b\x82\x51\x01\xbe\x8b\xe7\x83\x3a\x9f\xf9\x7c\x82\xeb\xdc\x4d\x5a\xa7\xd9\xbe\x71\xa3\x06\x6c\x8f\x74\x29\xed\xd7\x36\x12\x85\x3a\x63\x32\x16\xa3\x88\xa8\xbc\x19\x91\x12\xe6\x5b\x73\xd4\x53\x2a\x6d\x4e\x63\x91\x76\xcd\x41\xd1\xc6\x50\xa0\x91\x31\x2b\xac\xab\x51\xe2\xaf\x1b\x25\xda\xa3\x35\x25\xda\xa3\x65\x24\x1a\x7a\x04\xdd\x5e\xa4\x61\xf3\x65\x65\x9a\x22\xc2\x4d\x53\x3f\x52\x66\x3f\x35\x1d\xb4\x83\x96\x68\xf2\x02\x43\x97\x83\xa5\xb2\x46\x0d\x2d\x13\x9f\x56\x07\x53\x9e\x01\x83\xb3\x12\x0f\x29\x2b\xb9\xaf\x5c\x76\x3e\xd3\xa7\x0b\x17\x39\x29\xdc\xec\x14\x87\x37\x20\xac\x4e\x50\xe2\x9c\x13\x0f\x6d\xcc\xbe\xc0\x56\xbf\x34\x23\x8a\xc1\xdc\xc8\x87\x8f\xd7\xe4\xc3\xc7\x5f\xd7\xce\x3a\xa2\xa5\x9c\x63\x42\x99\x61\x2b\x95\x8e\x01\xf3\x50\x5e\x38\x29\x51\xc0\x26\x93\x30\x30\xa6\x42\xf7\xc4\x21\x4a\x2f\xb8\xd2\xe6\xb4\x77\x88\x39\xc7\xd8\x93\x6c\x2e\xb3\x4a\x34\x30\x31\xb8\x2c\x9e\xfa\xf4\x5c\xfa\xc5\xd1\x6b\xb4\x4a\xa1\x85\x79\x92\xf0\x09\x4b\x6c\x0c\x65\x7f\x69\x4c\xe0\xce\xf0\xaa\x08\xf3\x85\xe5\xae\xbc\xe9\x0e\x29\xc8\x5a\x74\x62\x93\xa1\x30\xa4\xbb\x3a\x9d\xf8\x09\x54\x20\x2f\x40\xc5\xc9\x5b\xa9\x6f\x09\x47\x31\xe8\x82\x97\x0b\xc0\x9f\xa6\x59\x3c\xc6\x48\x45\x48\x08\x04\x6a\x0f\xd6\x3d\x21\x8a\x53\xd1\xd9\xe3\x07\x9d\x33\xbc\xd7\x24\x3f\x12\x79\xef\x80\x12\x3f\xa0\x10\xd5\xe7\xcc\xff\x88\x72\xde\x8f\xc7\x13\x96\x49\x47\x4a\x63\xd3\x40\x6b\x1f\xbe\xb9\xbf\xe4\x09\xdd\xfc\x99\x14\x1f\xbf\xa5\xd2\x9e\x91\x39\x4c\x94\x12\x37\x62\xe6\x66\xe9\x32\x04\xe4\x51\x25\x75\xa2\x20\x92\x21\x3f\x61\xcc\x7e\x8b\x13\x07\xb4\xeb\x2c\xb3\xb2\x39\x58\x26\xb1\x43\xd2\xdd\xbc\xda\x1e\xac\xb9\xda\x1e\x7c\x55\xab\xcd\x1e\x7b\x95\x9e\xa4\xd1\xcb\xe5\xf1\x47\x34\x55\xdd\x97\x43\xea\x57\xac\x07\x74\x86\x12\x48\x0b\x01\xbc\x3b\x00\x9d\x41\x9f\xc9\xe8\x7b\x7a\xe9\xd9\x5e\x04\x0a\xd2\x91\x8a\x84\x64\xae\xf4\x75\x7e\x09\x93\xcf\x89\xee\xff\x8d\xe7\x92\xab\x8e\xe6\x30\xcd\xd1\x24\x37\xbe\x54\x5e\xbe\x1d\xcf\xf6\xb5\xbd\x57\x55\xf9\x99\xae\xac\x62\x60\x91\x3f\x92\xbb\xc8\x3f\xc8\x3b\xa2\xae\x73\x28\xc5\x09\x61\xd6\x68\xc1\xc1\xbf\x1f\xc0\x3f\xd4\x95\x1d\xc5\x27\xd4\x03\x7b\xae\xb4\xfb\x20\x95\x79\xae\x92\xdc\xb5\xd2\x05\x1a\xf3\x22\x60\x30\x08\x12\x4e\x36\x0c\x73\xe5\x8e\x37\x4b\x26\x63\x97\x35\xdc\x99\x89\xf3\xb9\xcc\x20\xc9\x2f\x74\xd1\x10\x7f\x51\x43\xcc\xbb\x59\xc8\x21\xfe\xf2\x45\x87\xa8\x32\x94\x59\x23\x9c\xeb\x4c\xa6\xc5\xbd\xe1\x00\x65\x3f\x71\x9c\xe4\xe7\x81\x4a\xfe\x5f\xba\x1f\x38\xd7\x94\xd2\x13\xee\xc5\xd1\x6b\x18\xb3\x28\x98\x4c\x43\x2b\x43\x59\x18\x8c\x83\x4c\x6d\x2b\x96\xa8\x94\x92\x5a\x8b\x67\x25\x99\x09\xa6\x6d\x7a\x15\x67\xf6\x0b\x8c\x14\x69\x9c\x05\x03\x8c\xe9\x02\x0c\x86\x09\x1b\x73\xa1\x17\x60\xdc\xbf\x80\x5f\x29\x31\xa6\x2c\xb8\x52\xa8\x4a\x58\x03\x1e\x62\xd8\x18\xed\x48\x58\x44\x1a\xcd\xba\xe5\xdb\x99\x4c\xad\x66\x3c\x05\xac\xf1\x78\xda\xbb\x34\x67\xd6\x2e\xf3\x45\x12\xdb\x04\x99\xf5\xe4\x22\xa6\x4b\x44\x38\x53\x71\x7f\xce\x94\x06\x64\x86\x2c\xb6\xb9\x01\x99\x9c\xc5\x78\xef\x58\x18\xfe\x9b\xe8\xb5\x14\x2b\x72\x1f\x21\xe1\x2a\xf0\x8b\xaf\x50\x78\x30\x7f\x14\x70\x69\xc0\x24\x47\x8c\x81\xb4\xe4\xdd\x46\xfa\x9b\x6d\xf3\x46\xd9\xff\x64\x4d\x4d\xeb\xc9\xd7\xa5\x69\x99\x91\x17\x5a\x7c\x27\x7d\x53\x75\x7d\x72\x21\xb5\xdb\x1c\x61\x49\x51\xdc\x58\x9e\x4b\x69\x20\x54\x6b\xb9\x53\x43\xb7\xd5\xed\xb4\x3a\xf2\x20\xa7\x02\x7b\x93\x93\x92\x60\x1e\x7b\x27\x3a\x73\xb3\x7d\xff\xff\x6b\x2b\xd2\x69\xba\x28\xf4\xa3\xc9\x3d\x85\x3e\x91\xc6\xb1\xf9\x4c\xc6\x99\x74\x43\xab\xe3\x45\x91\x5c\xfe\x41\xa4\x47\x62\xee\xce\xf4\x9a\x43\x8f\x74\x2b\x36\xfb\x05\xcf\x60\xc2\x52\x7d\x05\xa0\xbd\xa0\x23\xad\x36\x9f\xc5\xd1\xf3\x84\xa3\xe3\xb6\x74\x1c\xfe\x51\xfa\x71\xfb\x2c\x0c\x85\xde\x97\x1a\xc7\x5f\x30\xa8\x6e\xa9\x19\xc2\x39\x75\x9e\x9c\xe8\x67\x54\x38\x3c\x47\x06\x62\x71\xae\xa9\x72\x84\xc9\xbd\x09\x30\xaf\x38\x2c\x45\x5f\x45\xf7\xaa\x06\x50\x48\xff\x64\x01\x52\xdf\xc2\xb9\xb6\xaa\xc4\x94\x01\x2f\x07\x51\xf3\x9c\x93\x0e\xe0\x83\x58\xa6\xc1\xd0\xbe\x74\x3d\xe7\x3c\xd2\x79\x4b\xcf\x65\x3a\x01\xc3\xc8\x0b\x80\xe2\xa1\x55\x41\x2c\xbf\x4b\xa1\x93\xb4\x7b\x36\xf5\xd4\xee\x93\xc5\xf0\x31\x8a\xaf\xa4\x0d\xa5\x70\x42\x6f\xe5\x3a\x77\x2c\x5e\xc5\xd4\xb7\x6f\x8a\xe6\xf7\xf3\xb9\xfc\xa3\x62\x38\xce\x8c\xcb\xad\xf7\x20\x9a\xe3\xaa\xd3\xb5\x14\x99\x51\xdf\x58\x78\x70\xc3\xe5\xc6\xf1\x94\x40\xab\xf7\xdf\xd8\x25\x7b\x8f\xbe\x4d\x10\xc5\x63\x1e\xf9\x21\xc3\xb3\x40\x9d\x5f\xb4\xe0\x8c\x2e\x1a\xbf\x95\x19\x3e\x17\xa1\x86\x83\x78\xbf\x36\x7e\xf2\xb6\xe3\x4b\x61\x69\x99\x0f\xd5\x33\x5a\xd7\x8c\x68\x9b\xff\xaa\xc1\x28\xa7\x44\xb1\xf0\xac\x47\xaf\x08\xac\x10\x0c\x08\x17\x3c\xcd\xb1\x64\xb9\x34\xcf\x36\x65\xc0\xd5\xdb\x1b\x14\x87\x9e\x94\x85\x9e\x72\xd9\xf5\x4c\xd0\x70\xe5\x35\x7b\x33\x44\x83\xd2\x06\x81\xd2\x5d\x51\x51\x6a\xab\xe7\x5d\x74\xcf\x4d\x66\x75\x72\xcf\x54\x0c\x90\x53\x4e\x3b\xce\x5b\x92\x17\x64\xbd\xd4\x2f\x59\xd4\x8d\xa1\x60\x17\x4b\xf9\x89\xa3\x34\x4b\xa6\x7e\x16\x27\x85\xe7\x40\xca\xa0\x2f\x9f\x70\x44\x56\x36\xf3\x33\x09\xf5\x4c\x67\x73\x74\xcf\xd1\x16\x28\xeb\x0d\x08\x86\xfe\xa6\xa7\x4c\xa9\x38\xf8\xcf\x51\xe8\x8b\xa5\xbc\x9b\x0c\x0c\x24\xb3\xb1\xe8\xd0\xaa\x29\x1b\xa3\x38\x26\x5c\x05\xe3\xaa\x97\x4e\xea\x61\x8d\x74\xcf\xc5\x7c\xb5\xe8\x1c\xbb\x0d\x11\xbf\x92\x28\xd5\x13\x3e\xc4\x07\xd2\x9e\xd0\xa3\xb6\x01\xcc\x1e\xd3\x57\x25\x65\xbe\x57\x39\x6b\x25\x5c\x53\x55\xfc\x9f\xeb\x86\xd5\x95\xcc\x14\x2b\xe7\x37\x9f\x46\xb6\x2a\x01\xac\x9c\xa2\xc2\x33\x94\xb7\x85\x0b\x96\x2d\x5b\xd3\x90\x64\x36\x57\x21\x56\x8a\x4f\x7d\x4c\xd4\x4a\xa4\xfe\x64\x1f\xc4\xec\xde\x94\x3a\x87\x83\x4f\xa1\x9e\xf0\x94\x72\x91\xa3\xd3\x49\x43\xa6\x43\xc6\xec\xab\xe1\x5c\x51\x64\xab\x54\xf5\x21\x10\x87\x96\xba\xa8\xd1\x70\x3e\x29\x65\xd0\x46\xc3\xce\x76\x2a\xcf\x03\xda\x47\x64\x9a\xc5\x42\x97\xa0\x4c\xc7\xe4\x3e\x9e\x37\x9a\x9a\xe3\x8d\xaf\x74\x90\xb3\x01\x4f\xb3\x24\x9e\xab\xa7\x5e\xad\x72\xa4\x09\xde\x51\xf4\x82\x6a\x93\x5d\x5b\xe3\x9d\xfb\xaa\xed\xd6\x8e\x05\x50\x6a\x20\xea\xb9\x9c\x76\x81\x91\xf8\x05\x29\xf8\xa8\xbb\x0c\x1c\x17\x4f\xfb\x8a\x41\xfb\x3b\x42\x14\x37\xe3\x89\xeb\x15\x4f\x6f\x83\x8b\x0a\x0a\xad\x8f\x33\x47\x97\x39\x73\x47\xa9\xb4\xa6\x6b\x3d\x20\x55\x62\x85\xa8\x51\x45\xf5\x06\x7c\xca\x1b\x37\x6f\x1e\x1a\x5d\xf2\x0e\x3c\xe5\xaf\x2a\x1b\x48\xb7\x59\x6a\x27\x2d\xd8\x91\xd4\x0d\x91\x99\x82\xdf\x51\x3d\x6c\x23\x69\x0a\x91\x51\x3d\x38\x17\x3a\x05\x89\x3e\x2b\xb5\x2f\x41\xa2\x3e\xd3\x3f\x81\x9c\xa4\x75\xda\xe4\xa4\x12\x87\x9c\x54\x54\x42\x4e\x95\x64\xdd\xa8\xb8\x53\x5b\xe9\x25\xf7\x32\xb5\x39\xca\x93\xaa\x7e\x46\x59\xba\xdf\xb7\x94\xb5\x94\xcf\xf5\xeb\x91\xb1\x15\x8c\x36\xf7\x94\xcf\x11\xd3\xce\xd0\x34\x4a\x66\x6c\x96\x90\x34\x07\x55\x3b\x23\xad\x9e\x6c\xc5\x41\xb4\xdf\xb1\x84\x8d\x8b\x0f\x33\x9d\xdd\xc9\x6e\x4a\xd4\x5a\xa2\x69\x1b\x28\x0b\x73\xbb\x0d\xaf\x71\x45\xa7\x28\x46\xdf\xaa\x37\xb6\x26\x04\x42\xc3\x15\xa8\x84\x1c\x30\x6b\x4b\x70\x15\x7d\xa4\x83\x1f\x32\xcd\x17\x8a\x34\x84\x8f\xa5\x95\x7e\x36\xf1\x4b\xf3\x21\xe4\xe5\xcb\xd3\xa2\x82\xac\x1d\xd8\x8b\xe7\xb9\xca\x7e\x54\xf8\x7a\x09\x54\x7c\x71\xe1\xb1\xd4\xe5\x00\x05\xa3\xf8\x82\xf5\x17\x8c\x6d\x4c\xf6\x76\x55\x9a\x7f\x9a\x19\x47\x3c\xd5\x5a\x66\x10\xc1\xb1\xda\x9b\x4e\xea\xff\x22\x57\x55\x2a\xbd\xa3\xe5\x4b\x57\xd3\x93\x5e\x3f\x84\xaa\x79\x6d\x5b\x41\x69\x74\xcc\x50\x53\x65\x36\x68\x15\x13\x4d\xbe\x8d\xb6\x43\xdb\xa0\x64\xd9\x47\x01\x63\xa7\xed\x93\x63\x29\xcd\x43\xdd\x73\xf3\x50\xf7\x16\xe5\xa1\xee\x9d\x40\x1f\x3e\x5d\xcb\xf4\xa7\x82\x0b\x84\xd8\x7b\x3e\xe2\xfe\xc7\xba\xe8\xd3\x93\x58\xaa\x2c\x5a\xa2\xac\x95\xfa\x23\x3e\x98\x86\x9c\xb8\xb7\x84\xfb\xc0\x4e\xce\xf1\xcf\x29\x4f\xb3\x83\x28\xa0\x23\xf1\x77\x09\x1b\xf3\x3a\x0e\xab\x45\xa2\x4c\xc5\xa8\x32\x09\xfd\xd0\xd8\x35\x55\x82\x64\xc0\x85\x62\xed\x0b\x31\xab\x2e\x6d\x02\x29\x1e\x93\x69\x94\x02\xcb\xe4\xaa\x8f\x7c\xde\x9c\xf0\xa4\x99\x05\xfe\x47\x83\xec\x54\x21\xa9\xe0\xd4\xad\xe2\xd6\x79\x10\x0d\xb0\x40\xe7\x09\xc3\xb0\xfc\xd9\x08\x3e\x5d\x63\xdc\x60\x7b\xf9\xe4\x55\x33\x35\x0b\xd2\x72\x48\x4f\xf9\xa8\x57\x33\x41\x4e\xa0\x1a\xc9\x16\x8a\xc3\x4c\x0c\x44\xd3\x79\x40\x09\x80\x50\x2c\x68\x82\x67\x34\x04\x1d\x93\x37\x95\x7b\x72\xee\x36\x59\x7c\xa1\x05\x9f\x2f\xb7\xdd\x68\xd3\x3e\x1c\x9f\xe4\x69\x8e\xe9\x36\x9c\x63\x87\x6b\x64\x4c\xa1\x4e\xd1\xc2\x7f\xfb\x5f\x53\x9e\xcc\xe1\x0a\x5f\x4c\x24\xb4\x32\x08\x4b\x3b\xc0\x82\xf9\xfb\xde\x3d\xeb\x59\xc0\x6f\xff\xc4\xc6\xcf\xac\xc0\x05\x1d\xc1\x81\x4e\xe0\x17\x09\x2e\x17\xe0\x4b\x00\x52\x8f\x9d\x14\x14\x19\xd1\x00\x41\x38\xa1\x99\x30\x05\x00\x9f\x50\xc0\x69\xfb\x3a\x4b\xbd\x5a\xcf\xcd\x53\xcb\x79\x17\x2d\x97\x03\x2d\xf2\xd6\x47\x3e\x4f\xeb\x8b\x66\xd1\x0e\x45\x53\x80\xd7\x68\x94\x44\x5b\x8b\xd8\xd8\x8a\x5b\x72\x5a\x8e\xc9\xb1\xa8\x75\x72\x03\x07\x15\xaa\x7f\xfe\x2c\x76\xde\x22\x1e\xf0\xac\x58\x26\x9b\x08\x01\x60\x85\xa2\x56\x04\x7c\xc7\x87\x4c\x1c\x8e\xf0\xf6\x4f\x35\xa9\x91\x6f\x52\x9d\x68\x03\xfb\x4f\x01\x1d\xaa\x2c\x2e\xb0\x29\x69\x53\xb0\x7c\x90\xf9\x24\x0f\x2e\x65\xa4\x0c\x31\x04\x90\xe5\x00\xa2\x5e\x1f\xff\x2b\x8b\xae\xbd\xc5\x74\xd4\x03\x54\xc3\x4b\xe3\x24\x7f\xd9\x79\x3e\x27\x9b\x30\x56\x69\x89\x0a\x95\x41\xda\x75\x14\x72\x32\x2f\x37\xe1\x9c\xfe\x2a\x92\xd1\x80\xa7\x57\x81\x23\x0e\x4c\x06\xb9\xc1\xec\x31\x14\xc8\x9b\x25\xe7\x41\x86\x77\x0c\x7e\x4c\x6f\x9c\x22\x6b\x0f\x11\x8b\x53\xc8\x05\x19\x09\x47\x60\x3f\xf5\x47\x54\x35\x48\x15\x10\xfd\xf4\x4c\x1c\x19\x8d\xdd\x3b\xc8\x52\xd7\x70\xeb\x26\xb5\x60\x83\x01\x0a\x37\x2b\xdc\x00\x69\x59\x81\xd9\x66\x9c\xd8\x03\x0a\xc6\xb7\x87\x70\xf0\xf3\xc1\xbb\xc3\xbe\x8c\x7b\x20\x00\x59\x7b\xec\x59\x61\x22\x30\xfa\xd2\x19\x2a\xb7\xe2\xbb\x2a\x3f\x92\xe7\xe9\x3b\x25\x3c\x54\xb2\x76\x72\xcd\xdc\x40\xe5\xb9\x8f\x2d\x65\x97\xbf\x77\x0f\x82\x54\x99\xcf\x0b\xb5\xc8\x8c\xee\x84\x35\x2f\xaf\x22\xf7\x2d\x6b\xc7\x3e\xb5\x44\x55\x8e\x03\xbd\x3c\x10\xf5\x1d\xa5\x79\x49\xf8\x73\x45\xd8\x61\x20\xaf\x79\xc8\xad\x5f\x6e\x60\xe5\x4a\x94\x9a\x72\x0a\x21\x85\x07\xde\xfc\xd6\x57\xb7\xf3\xfd\x3a\x67\x51\xa9\x57\xe8\x25\xe3\x7c\x34\xb9\xaa\x9c\x62\x27\x6b\x6b\xca\xb3\xe9\x84\x60\xa2\x5c\x10\xea\x0f\x3d\x3c\x9b\xcb\x87\x46\x62\x27\xf7\x19\x19\x2d\xd4\x40\x10\x79\x39\x92\x20\x52\x91\xff\x7c\x48\x83\x6c\xca\x8c\x7c\x96\x83\xa0\x29\x3c\x14\x7d\xbc\x52\x5d\xd4\x1b\x4e\x80\x27\x43\xd5\x56\x7e\x7c\x85\x21\xa9\x3c\x24\xf4\x62\xb1\x86\x1a\x25\x29\x3e\xf6\x0a\xb0\x32\x83\xcf\x25\x7b\x8b\x35\x88\x63\x54\xcb\x8c\xe0\xe8\xa6\x59\x4c\x91\x67\xa2\x01\x25\x49\x83\x34\x9b\x0e\x87\x14\xba\xf7\x7d\x10\x89\x93\x5c\x36\x3d\x4f\xb7\x44\xff\xa4\x55\x3c\x17\x4d\xeb\x6f\x25\xef\x1c\x13\x5d\x3f\xf2\x79\x1f\x6a\x44\x2a\x79\x6d\x8c\xf6\x34\xeb\x90\x45\x1f\xff\xf6\xb7\x6e\x51\xdb\x92\x5a\x8d\x38\x61\x90\x56\x63\xc5\xff\xf4\xc0\xee\x41\x1a\x08\x2a\xba\x90\x5f\x4b\xfb\x90\xdf\x96\xe9\xa4\x6c\xee\x2a\x7a\x2c\xab\x5a\xda\x7d\x59\xc5\xa5\x06\x4c\x77\x99\x4b\x21\x53\x5a\xb7\x9c\x18\x65\x35\x4b\xd0\xc9\x5f\xc8\xbd\x97\x2a\x34\xb0\x48\x87\x16\x52\x97\x59\xc9\x34\x52\xf6\x02\x8c\x2b\xfd\xe3\x4b\xb5\x74\xd8\x25\x0b\x42\xd1\x9f\xbe\x80\x93\x61\x08\x5c\x8d\xdc\xfa\x9a\xb3\xbe\xc9\x1b\xb0\x02\x3a\xcf\xe3\x30\xe4\x3a\x8e\xd2\x34\x0b\xe4\x91\xd9\x7e\xd8\x74\x95\x04\x19\xe6\x4f\xa2\xe3\x94\x91\xd1\x7a\x4c\x19\x4b\xb0\x06\x9a\x64\xcd\x05\xe3\x23\x1d\x35\x09\x71\x0d\x52\x33\x0e\x52\xe3\xc9\xe6\xa5\xc0\x04\x91\x1f\x4e\x07\x1c\xce\x48\xc2\x35\x05\x36\x69\xeb\xb7\x54\xdf\x5f\x9f\xe9\x37\xef\x67\xaa\x6f\xd5\x76\x7b\xfb\xc5\xe1\xdb\x77\x87\xcf\x0f\x3e\xbc\x3c\x7a\xb3\xbd\xdd\x27\x87\x00\x7c\xea\x1f\xab\x40\x73\x44\x0b\x3c\x4e\xa3\x2f\xab\xbe\x19\x55\x40\xac\xa8\x0d\x6e\xc0\x86\x3b\x98\x47\x2c\xd3\x37\x66\x04\x63\x1c\xe3\x44\x92\xe3\x84\x18\x8d\xcc\x7b\xa4\xc0\xbd\x98\xea\x50\x1d\xa3\xe0\x62\x44\x07\x42\xa9\x01\x48\x4b\x05\x51\xc6\x3c\xf4\xc3\xfe\x10\xba\x4c\x3a\x18\xd5\x32\x05\xee\x62\xca\x12\x16\x65\x5c\xc6\x2b\xc8\x62\xf9\x6a\x13\x52\x3e\xbe\xe4\x49\x4b\xe1\x38\x06\x26\x03\xb6\xc4\x57\x11\x24\x41\x4a\xd7\xfb\x60\x1b\x68\x41\x59\x41\x64\xa2\x39\xf9\x3b\x67\xd1\x85\x1b\xaf\x90\x1f\xe7\x38\x4e\x1a\x2b\x6e\x64\x43\x80\xeb\x13\x3b\xe3\xc7\x5b\xa9\xc3\x5f\xe3\x9e\x65\x5f\xc0\xe6\x4c\x0f\xb9\x5b\x58\x3c\x14\x4a\x13\x10\x65\x01\x8c\x32\x9e\x0c\x99\xcf\xb5\x37\x5c\x28\x6d\x5c\xce\x45\x2c\x06\x58\xe7\x59\x8a\xc6\x53\x19\xc6\x03\x03\xb7\x3b\x31\x55\x18\x46\x83\x47\xb7\x8e\x28\x1e\x70\xcb\xc2\xaf\x62\x97\xd0\x56\x61\x58\xdc\xde\xab\x99\xda\xa9\x55\xdc\x96\x90\x98\x51\x45\xa5\xf2\xe3\x38\x19\x04\x11\xcb\xe8\xca\xc4\x76\x26\xa4\x8d\x47\x06\x3a\x53\xdd\x8b\xc6\x98\x6a\x2b\x75\x9e\x5b\x6f\x57\x5a\xff\x6d\xba\x29\x13\xc3\x9b\x78\x80\x1a\x88\x6a\x22\xfe\x7a\xf3\xad\x5c\x2e\x43\x4e\x17\x64\x41\xea\xc4\x05\x11\xa8\xbd\x14\x74\x8d\x78\x06\x87\xb3\x49\x18\x27\x3c\xc1\xf8\x1f\xea\xea\x39\xd7\x59\xee\x06\xc8\x78\x2f\xa0\x99\x51\x05\x8f\x0f\xa2\x0b\x13\x1d\x0e\xa3\x60\x19\x39\x8c\xf3\xaa\xa2\x8b\x95\x51\xac\x30\xbd\x28\x34\x29\x3c\xce\x59\x69\x0f\x96\x45\xdc\xc1\x4e\xf9\x94\x20\x6e\x56\xe6\xcb\x2d\x0a\x9a\x70\xf8\xfe\xa1\xd0\x00\x28\x0a\x19\xd3\x8f\xe4\x28\xff\xcf\x48\xa6\x06\x54\xcb\xf9\x32\x48\xb2\x29\x0b\x4b\x3d\xde\x6f\xea\x94\x12\x5c\x2d\xd9\xab\x8c\x22\xb4\x4c\xb7\x42\xe8\x4b\xde\x27\xb1\xb5\x0f\x75\xb1\xce\xe3\xa1\x4c\xed\x89\x46\xa2\x9a\xb6\x12\xd5\xe0\x99\xfa\xd0\x87\x8b\x30\x3e\x67\x61\xa3\x65\x89\xbd\xbd\xad\xc2\x5d\x8c\x1d\xcb\xd1\x7c\xb7\x6e\x7a\xd4\x9f\xb8\xb6\x61\xc4\x92\x71\x1c\x69\xcb\x35\xf0\x19\x46\x46\xda\x6e\xc3\xe9\xe9\x15\x3f\x9f\x30\xff\xe3\x29\x95\xa5\xa7\xa7\xc7\x77\x65\xb5\xbb\xe2\x44\x5c\xd7\x46\xa9\x76\xfb\x5f\x20\x8d\xa7\x89\xcf\x5f\xb3\xc9\x24\x88\x2e\x7e\x7c\xf7\x6a\x5f\xef\x0f\xe2\x70\x89\x7d\xfd\x7c\xf8\xed\xdb\x83\xe7\xff\x0e\x3f\x1d\xbc\x83\x97\x6f\xfe\xed\xf0\xb9\xd8\x1f\x60\xbb\x7d\x4d\x5b\x75\x49\x87\x9e\x85\x45\x42\x1e\xe6\xa7\xa7\xf5\xfb\xdd\x46\xa3\x81\x92\x69\xbb\x0d\xd7\x0d\x4f\xc0\x7e\xf8\xa8\x27\xc8\x4b\x65\xfa\xa0\x52\xa7\x6d\xc1\x93\xc3\x4a\x4b\xe1\x09\x75\x62\xeb\xae\x58\xcd\x69\x96\x04\x7e\x76\x77\x6f\x6b\x6b\x4b\x1e\x9a\x73\xb1\x95\x35\x98\xbb\xa7\xa7\x3c\x7d\x8d\xc0\xef\x7a\x32\xec\x26\x6a\x2f\x78\xe7\x84\xe7\x08\x34\x1c\xca\x33\xb3\x39\x85\x53\x4c\x44\xf8\xfc\xd9\x32\xd7\x65\x2c\xb9\xe0\x59\x03\x3e\xc1\x30\x4e\xa0\x8e\xa1\x2f\x61\x1f\xba\x7b\x10\xc0\x37\x05\xdb\xe2\x1e\x04\x3b\x3b\xa2\x32\x06\xb8\x44\xaa\xdb\x16\xc8\xe3\xe0\x64\xcf\xc0\xf9\xc8\xe7\xa8\xdd\x63\x35\xd1\x48\x1c\x25\x24\x2a\x5a\x5d\x6e\x8d\x58\x7a\x74\x15\xa9\x51\xd2\x6c\x50\x13\x4f\x40\x10\x67\x32\x20\x24\x8f\x3f\xf2\xb9\x98\x7b\xfa\x8a\xbf\xf6\xe0\x1a\xff\x4f\xad\x08\xac\xb7\x87\x56\x2d\x24\x41\xc2\x19\xc6\x18\x2e\x9b\xc9\x6e\xc3\xa9\xd5\x13\xd5\x70\xd7\x88\x27\xf2\x41\x81\xe4\xd6\x3a\x55\xd0\xd5\xc5\xea\xfd\x30\x9f\x60\x1e\x8a\x32\xc0\x9d\x62\xcd\x45\xc0\x75\x25\xd1\x4c\x4f\x4c\x45\xed\xf8\xfc\x37\x41\x10\x95\x1f\xeb\xfc\x37\x71\xb0\x8d\xcf\x7f\x6b\x19\x9e\x80\x67\x58\xde\x87\x4f\x3a\xfb\x32\x16\x5c\xef\x09\x2d\xd4\x74\x40\x3b\xe7\xcf\xf4\xd8\xfd\xad\x3e\xf9\x88\x2e\x90\xf2\xa9\x9a\x67\xa2\x2a\x99\xc5\x6c\x2e\x09\x10\x01\x35\xb1\xa2\x85\x0e\x69\x1a\x34\xe0\x29\xe6\xa5\x16\xfa\x4c\x10\x4d\xf9\x1e\xc5\x96\x5e\x6a\xf6\x11\x81\xa0\x61\x37\x96\x0c\x10\x88\xe9\x8f\xcf\x7f\x43\x3e\x2b\xce\x3a\x51\xfd\x00\x9d\x25\x2c\x93\x34\x16\xd4\x31\xc8\xa2\x87\x30\xf9\xcc\x4a\x18\x8b\xf4\x4f\xff\x26\xb6\x91\x38\x92\xf1\x68\x31\x1e\xa3\x2e\x51\x16\x54\xbb\x4a\xb1\x55\xce\xc0\x5e\x4b\x27\x2c\xaa\x41\xbf\x50\x53\xdb\x69\xa3\x88\x27\xef\xf8\x50\xf7\xa7\x0a\x74\x77\xa3\x20\x1c\x24\x3c\x32\x08\xc9\x02\x13\xce\x36\xc5\x79\x43\x3e\xac\x9a\x4d\x39\xec\xe3\x9a\x46\xa0\xe6\x41\x4d\xf5\x25\xfe\x56\x60\x6b\x27\x0d\x1d\xbb\x56\x5b\x5e\x25\xb9\xf2\x69\x52\xd0\x6d\x83\x90\xd7\x64\x56\x65\x75\xa1\xa3\xe4\x52\x2b\xa5\x3c\xc3\x59\x10\x5a\x07\x7d\x37\xc6\x05\xb9\x07\x19\x7a\x88\x5d\x48\x41\xb5\x32\x63\xab\x0a\x76\x7b\x99\xd6\xc2\x42\x0a\x9d\x88\xb4\xc9\x58\xe8\x18\x07\xba\xb8\x6e\x12\xa6\xca\x4e\x0d\x8d\x4b\x3b\xd5\x50\x15\x99\xcd\xd9\x6f\xd8\xd7\x03\xd6\x16\x76\x72\x56\x35\x68\x28\x0b\xbb\x75\x5a\x54\x1d\xd6\x3f\x59\x80\xfb\xd6\xdf\x9e\x99\xd6\xbe\x35\xc3\xd7\x6e\x12\x1e\x3d\x99\x7a\xfe\x6d\x0b\xb1\x6e\xa6\xce\xbf\x12\x33\xa7\x92\x41\xd3\x6a\x40\x3e\x62\x0d\x93\x70\xc3\xa6\x95\xc3\xeb\x35\x72\x5c\xaf\x99\xec\xb1\x36\x46\xad\x04\x79\x43\x51\xa8\x10\x0a\x3c\x57\xdb\x5a\x0b\x4e\x13\x2b\x42\x70\xbd\xe3\x49\x41\xdd\x22\xdb\x89\x4a\x11\x54\x37\x2b\x2b\x07\xd6\xd3\xd4\x6e\xec\xe1\xcd\x2d\x72\x42\x4b\xb2\xb4\x92\xe0\x9f\x74\x9c\xe5\xbe\x2d\xb0\x5b\x52\x76\xb6\x68\x61\xb5\x82\x54\x45\xc3\xb7\x40\xd9\x3b\xc1\xa7\x2d\x6b\x58\x15\xa0\x22\x7e\x34\x14\x65\xf5\xe3\xb2\xcf\x82\xaf\xbd\xd2\x86\x82\x31\x29\xf1\x82\xa2\x54\x79\x07\xa2\x9e\xa8\xa5\xc6\xfd\x45\xd0\xc0\xf1\x4b\x65\x44\x7d\x82\x7d\x92\xb2\x7b\x05\xcd\x68\x77\x83\x9a\xd1\x02\x35\xce\xc0\x96\x9a\xaa\x68\xbd\x21\x3d\xea\xcb\x28\x11\xe2\x7c\x55\x0e\xb3\xf7\xd8\xa9\xb5\x50\x77\x98\x26\x5c\x57\x7e\x7f\x79\xf1\xd2\xc7\x24\x2c\xa5\x50\x1f\xe4\x2b\x2e\x02\x2c\xab\xfc\x21\x2a\x89\xc0\x49\xf6\xf7\x9c\x2c\x4b\xfb\xf2\xbc\xd1\x3a\x3d\x7d\xfd\xe3\x4b\x85\xcc\xe9\xa9\x50\x5d\x35\xf6\x8a\xf7\xcc\x04\x0c\x29\x3d\xa5\x98\x07\xcd\xb3\x8e\xb0\xa8\xd7\x26\x2c\x1b\xd5\x3c\x81\x47\x1f\x6a\xaf\xbb\x0f\x5a\xf7\xbb\xf0\xa8\x75\xbf\xfb\xaa\x7b\x1f\x1e\x86\xcd\x87\x40\xff\xd7\x6d\xdd\xef\x36\xbb\x58\xde\x69\x3d\xde\x85\x6e\xef\xf7\x1a\x68\x8e\x78\x3e\xe2\x97\x49\x1c\xbd\xe2\xc3\xcc\xde\x00\xad\x62\xda\x76\x49\x36\xaa\x2b\xac\x85\x88\xa1\x54\x74\x88\x40\xbb\x0a\x6d\xdf\xf8\xa7\x18\xe0\x16\x80\x94\x65\x2e\x0e\x28\x1d\x91\x59\x14\xfc\x46\xdd\xaa\xd1\xd8\xb3\xeb\xb7\xc6\xd3\xe0\x0d\xa6\xc1\x80\x9a\xec\xb2\x56\xba\xa4\xad\x36\x0b\x17\x9f\x3c\x43\x2d\x5a\xcd\x15\xe7\xa6\xfb\x7f\xee\xb9\xa9\x6a\xc5\x5b\xd6\xf9\xbc\x6f\x83\x6d\x21\xb7\xba\x11\xaa\x16\xe9\xa1\x14\xe6\x3c\x2d\x9c\xa8\x3a\x74\xa2\x22\x55\xae\xe4\x34\xa5\x82\x44\xc6\x89\x52\xf8\x50\xcb\x35\xc5\x2d\x1e\x4d\xc7\x3c\x41\xa3\xe9\x7e\x45\xb9\x38\xda\x61\xae\x0a\xfb\xbb\xbe\xbb\xa3\x96\x98\xcc\x03\x37\xf6\xbb\x38\x7a\x0c\x79\x68\xaa\x37\xec\xa6\x57\x49\x90\x39\xcd\xca\x49\xac\x46\x6e\xb5\xfc\xc8\xe7\xf6\xef\xc6\x9e\x7d\x4e\x33\x14\x7d\x6e\x5c\x70\x3d\xba\x43\x91\x5b\x37\x19\x28\xdf\x2a\x52\x62\x2a\x37\xfd\xb9\x51\x24\xbe\x05\xc8\x1c\x2f\x6c\x90\x0d\x1a\xb3\x03\x77\x11\x14\x17\x85\x3d\x85\xba\x55\x63\x0f\xe5\x57\xfd\x0b\xef\x13\x5f\xf0\xb0\x49\xbc\x2e\xb8\x1c\x03\xc6\x57\x6d\x1c\x25\x55\x17\x75\x61\x6a\xe9\x86\xf2\xe5\x41\x39\xfc\x07\x66\xbb\x3b\x98\x4c\xbe\x65\x49\xe5\xb6\x78\x3f\x57\x71\x11\x16\x54\x43\x37\xf8\x10\xc7\xe1\x79\x25\xe8\xee\xe3\xc7\xf9\x9a\x8b\x60\xcb\x2a\xa6\xc9\x7c\x12\x5f\x24\x6c\x32\x9a\x57\xc0\xbf\xdf\x29\xa9\xbb\xb0\x07\x5d\x4b\x37\x14\x62\xfa\xdb\x69\x96\x55\x6e\xf0\xdd\xdd\x4e\x49\xe5\x45\xbd\x98\x5a\xba\xe1\x6b\x1e\x4d\x2b\xe0\x3f\x7c\xf4\xc0\xa9\xb6\x08\xb2\xf8\xae\x2b\x3f\x8f\xc7\xe3\x4a\xac\x9f\x3c\xf8\x83\xcd\x1e\x39\x17\x37\xe5\x9c\xe7\xd9\x2b\x5b\x49\x9c\x3b\xfa\xb3\x76\xe2\x8b\x87\x4e\x45\xb4\x4e\x8d\x92\xf8\x0a\x4d\xee\x62\x65\x1d\x26\x49\x9c\xd4\xef\x3e\x67\x91\xf2\x00\x06\x26\xef\x88\x59\x6a\xa5\x2b\xb9\x4b\x22\xd1\x46\x6d\x12\xa7\x69\x70\x1e\x72\xab\x83\x77\x38\xe2\x7a\xca\xc3\xa1\x87\xc0\x34\x6a\xa2\xc8\xed\x5d\x47\x90\x95\x28\xe0\x7d\x84\x4c\xa3\x84\x6f\xa0\x94\xef\x71\xca\x07\xd0\x84\x74\x3a\xe1\x49\xbd\xe1\xd4\x20\x87\x65\x42\x4d\x9d\x58\xc5\x08\xee\xdd\x33\xc7\x40\xf1\x5b\x9c\x00\xef\xd2\xc9\xe8\xae\xd8\x74\x0a\xdf\xcc\x28\xe1\x19\x15\xf7\x41\x60\x9c\x9b\x8c\x20\x1a\xf1\x24\xc8\xd2\x7a\x3a\x3d\xc7\xed\xd6\x23\xb4\xf0\x6f\x35\x54\x09\xdc\x7c\x40\x43\xb5\xe9\x42\x60\x97\xfb\x18\x4d\x89\x52\xa5\x53\xf3\x7e\x8a\x5e\x6d\xb3\x49\xc2\x53\xbc\xbe\xc2\xf7\xb5\x32\x9b\xc4\x39\xc7\xc6\x14\x5a\xde\x64\x9f\x11\x73\x79\x17\x76\xa0\x80\x0b\x92\x4a\x61\x6f\x76\x1e\x63\x74\x25\x5d\xa2\x6e\x21\xe8\xa0\x6b\x6f\x56\x9f\xec\x17\x29\x7d\xd4\x0b\x50\x3b\x31\xc4\x31\x5b\xbd\xf2\xee\x03\xb5\x45\xcb\x67\x05\x60\xef\xf6\x54\x26\xd8\x4c\xed\x7e\x16\x71\x25\x7e\x29\x17\xa7\x65\x42\xe1\x68\x08\xcf\xca\xcb\x2b\x26\xc8\xe0\xd6\x3a\x3d\xc5\x91\x9c\x9e\xc2\xbe\x55\x45\x50\xa7\xdd\x86\xe7\xf1\x64\x4e\x0e\x2a\xbd\x4e\xf7\x11\x79\xca\xc6\x4d\x7c\x7a\xc1\xa7\x63\x38\x98\x66\xa3\x38\x41\xdf\x66\xba\x7f\x0a\x42\x74\x6b\x9a\x60\xa2\x11\xba\xdb\xb0\xeb\xeb\xa0\x12\xed\x36\xb5\x29\xfd\x2c\x20\x0c\x13\xce\x21\x8d\x87\xd9\x15\x4b\x78\x5f\x87\xc6\x4c\xf8\x20\x48\x55\xd0\x9a\x00\x23\x22\xb6\x63\x99\x1b\x65\x2e\x40\x06\x19\x5a\xf3\xe8\x9d\x6f\xc6\x93\xb1\x7e\xea\xf5\xfd\x9b\x1f\xe1\x15\x4f\x53\x9e\xc0\xf7\xe8\xec\x1b\xc2\xdb\xe9\x79\x18\xf8\xf0\x2a\xf0\x79\x44\xf7\x72\x13\x51\x92\x8e\xf0\xbd\xe1\x16\x79\x5b\xc1\x77\x02\x95\xf7\x12\x15\xf8\x0e\x9f\x8a\xc9\xd4\x46\xc4\x7a\xea\x36\x75\x57\x75\x25\x01\x62\x00\xea\x76\x1b\xea\xfa\x3a\x17\xbd\x75\x1a\x18\x98\x34\x64\x99\x69\xba\x04\x41\xcc\xb8\xb5\xb3\xd8\x28\x9e\x70\xed\x55\xab\xae\xbd\xe9\xde\xdf\x13\xd0\xce\xa7\x19\xfc\xfc\xf2\xc3\x0f\x47\x3f\x7e\x80\x83\x37\xbf\xc0\xcf\x07\xef\xde\x1d\xbc\xf9\xf0\xcb\x9e\x8e\x94\xca\x2f\xe5\xc3\x88\x60\x4c\x5e\xfa\x57\x2c\x49\x58\x84\xd7\xdb\xe8\xb0\x7e\xf8\xee\xf9\x0f\x07\x6f\x3e\x1c\x7c\xfb\xf2\xd5\xcb\x0f\xbf\x88\xc5\xf5\xdd\xcb\x0f\x6f\x0e\xdf\xbf\x87\xef\x8e\xde\xc1\x01\xbc\x3d\x78\xf7\xe1\xe5\xf3\x1f\x5f\x1d\xbc\x83\xb7\x3f\xbe\x7b\x7b\xf4\xfe\xb0\x05\xef\xe9\x82\x5b\xb4\xbf\x99\xe6\x43\x99\xca\x01\xa3\x7d\x07\x61\xaa\x28\xf1\x4b\x3c\x55\x11\x0e\xf0\x16\x35\xe1\x3e\x0f\x2e\xf9\x00\x53\x41\x4c\xe6\x4b\x4f\xaa\x80\xc5\xc2\x38\xba\x30\x97\x8c\x65\x0c\x09\x2f\x87\x42\x54\x78\x90\x72\x0e\xdf\x8c\xb2\x6c\xd2\x6f\xb7\xaf\xae\xae\x5a\x17\xd1\xb4\x15\x27\x17\xed\x90\xc0\xa5\xed\xa7\x2d\xf4\xe9\x97\x6f\x1e\x87\x32\xbe\xc3\x0f\x9c\x0d\xb8\x65\xde\x6b\xe1\x0e\xaa\xd5\x27\x93\xdb\x15\x4b\xea\xd9\x88\x1b\x67\x49\xe5\x99\xae\x3d\xd8\x18\xaa\x40\x7d\xab\x84\x2c\xb2\x74\x2d\xdd\x87\x9a\x8a\x0b\x50\xf3\x9c\x1a\xf8\x16\x5b\xd6\xc1\x1e\x5a\xa6\x24\x55\xf2\xec\xb8\x46\xef\x26\x6b\x9e\x4a\x22\x76\xe2\xe5\x7a\x12\xff\x38\x4b\x31\xd8\x5b\x11\x0e\x7d\x69\xa5\x23\x96\x4c\xbc\x42\xbb\xc1\x54\x47\x08\x29\xb4\x54\xdf\x5a\x32\x40\xef\x7b\x3f\xe1\x3c\x72\x40\x48\x27\x4f\x30\xd9\xa9\x0d\x41\xde\xdb\xe9\x7e\xd4\x3f\x1a\x8c\x38\xe9\xf6\x95\xc2\xd2\x7a\xf1\xee\xe0\xe7\xc3\x77\xa7\x3f\xbf\x7c\xf1\xe1\x07\x17\x43\x1c\x70\x1f\x6a\x3e\x0b\xfd\x7a\xb7\xd3\xf9\x3b\x34\xa1\x06\x3b\xa5\x2d\x61\x07\x6a\x93\x59\xe3\xcf\xa4\x31\x67\x29\x3f\x9a\x66\xb7\xa4\x32\x17\x1a\xd9\x2a\x64\x1e\xf3\x68\x4a\x6a\xe5\x22\x2a\x77\x7b\x5e\xc9\xb7\x77\x62\x93\xe8\x43\xaf\x53\x06\xd8\x0e\xbb\xa5\x87\x10\xa4\x93\x90\xcd\xfb\x50\x8b\xe2\x88\xd7\x4c\x33\x65\x7c\xc7\x27\x3b\x6d\xb5\xb2\x12\x2e\xa4\xba\xd0\xc3\x46\x58\xe0\xa9\x90\x65\xe4\x77\x83\x3e\x06\xc1\x80\x9f\xe3\x0b\x0b\x21\x09\x20\xf0\xe3\x48\xbd\xfc\x62\xf8\xde\xdb\x0f\xe3\x94\x0f\x5a\xa4\xdd\x4a\xb8\xb6\x95\x40\x70\x01\x2d\x5f\xb5\x34\x8d\x9e\xf3\x83\xec\xd5\xaa\x23\x7d\x33\x75\x7b\xaa\x52\xb7\x7d\x51\xf3\x4a\x2b\xbd\xcb\xa0\x8a\xaa\x3d\x58\xde\xd2\xd5\x8a\x24\xb5\x94\x68\x58\x7b\xf6\xe7\xcf\x6a\xdf\xbf\x70\xf7\x7d\xd9\x49\xa3\x85\x11\x26\x64\x7b\x7d\xe1\xdb\x70\xdd\xdb\x6c\xc3\x89\x1e\xea\xb1\x19\x07\xf9\xe1\xd1\x1c\x58\x0b\x22\xef\x7c\x47\x15\x1c\x0a\x00\xb9\x9b\x8a\x8d\x0d\x69\xc1\x53\xf3\x3e\x1c\x13\x25\x09\xdc\xe9\x79\xbf\x10\xd0\x24\x56\xeb\x2a\x18\xa6\xee\x27\xd1\xad\xa5\xe3\xab\xbc\x59\xa3\xc2\xbd\xad\x2d\xa7\xfe\xf2\x96\x3b\xfb\x9f\x3a\x9c\xb6\xdc\x68\xf9\xd6\xbf\x4f\x84\xc5\x1b\xf4\x60\x47\xd3\x9d\x75\xb2\x36\x06\x3c\x89\x55\x8b\xc4\x96\x67\x23\x8c\xbc\x89\x4e\xcd\x6e\x25\x94\x6d\x0d\x7b\xcd\x68\xac\x56\x1b\x04\x36\x51\x47\xe1\xea\x91\xd0\x68\xa4\x0b\xe4\xf7\xd3\x2c\xc3\xf7\x72\x77\x8a\x98\x96\x60\x74\x4b\xac\xb0\x99\x75\xbe\x5d\x8c\x1c\x22\x58\xf9\x05\xf0\x2a\x2a\xc4\xf0\xa8\x42\x02\x24\x2c\xcd\x6a\xd5\x80\xc4\xbf\x1a\x4b\x02\xd6\x0c\xd9\x39\x0f\x6b\x7d\xa8\x89\xe1\xc1\x20\x61\x57\x0e\x43\x97\xfd\x8b\xa3\xe7\x61\xe0\x7f\xec\xe7\xa7\x71\x71\xab\x95\x18\xc5\x08\xde\x1b\x98\x45\x08\xd2\x46\x65\xbf\x15\x73\x05\x37\xce\x17\x99\x05\xf4\x84\xd0\x29\xac\x14\x56\x63\xb3\xec\x60\x19\x55\x96\x60\x07\x3c\xc4\xf5\xa1\x96\x05\x59\xc8\x6b\x9e\xe6\x00\x29\xa4\x6b\xe2\xb4\xf7\x73\xc2\x26\xea\xf4\x54\x0d\xaa\xf6\x7d\x0c\x87\x4a\x07\x7c\xc1\xd2\xd1\x79\xcc\x92\x41\xad\x7c\xc8\x85\x52\xb7\x44\x3f\x07\xd0\x7b\xd7\x89\x12\xed\x52\x0e\x91\x40\xdd\xdb\xba\x96\x36\xc2\x96\xb3\x87\x48\x91\x9e\xbf\x92\x04\x35\xe9\x4b\xde\x6e\xd2\x60\x89\x65\xca\x9b\x9c\xc7\x71\x58\xda\xa0\xfa\x4e\x32\x7f\x7b\x5a\xbc\x6a\x40\xe6\x26\xad\xb6\x65\x04\x78\xa3\x9e\xca\xff\x35\x7b\x5d\xee\x06\xe1\xc1\x5f\xf7\x8b\x7f\xdd\x2f\x7e\xad\xf7\x8b\xbb\xd0\x7d\x3c\xea\x3e\xbe\x6c\xf6\x7e\xd8\xbd\xec\xfd\x3e\xee\x34\x1f\xb8\x3f\x1f\x5d\xf6\x46\xdd\xc7\x3f\x3d\xfc\x61\xd7\xbe\x5f\x94\x46\x58\x93\xfe\x97\x47\xd3\x2f\x7f\xa3\x28\x7b\x2d\xbb\x4a\x94\xe6\x5c\xf1\x3f\x4b\x5f\x1e\x8a\xca\x5f\xe8\xd6\xf0\xe1\x5f\xb7\x86\x7f\xdd\x1a\xfe\x75\x6b\xf8\xd7\xad\xe1\xd2\xf7\x4b\x58\xef\x87\x78\x5c\xb5\x25\x3e\x7c\xf4\xc8\xa9\xb6\x08\x53\xf1\xfd\x0f\xbe\xb3\xca\x2d\x1c\xe5\xa1\xeb\x91\x20\xb2\x3c\x70\x2d\x9f\xdc\xf2\x35\x67\x9a\xea\xdb\x05\xfc\x1f\xf7\x6a\xa1\xea\x26\x21\x7f\xdb\x80\xf7\x0a\xca\xb1\x0f\x1d\x73\xa5\x8b\x36\xc2\xb4\x2e\x91\xe2\xf3\xdf\xfe\xba\x86\xfb\xeb\x1a\xee\xaf\x6b\xb8\xbf\xae\xe1\xfe\xba\x86\xfb\xeb\x1a\xee\xab\xbb\x86\x7b\x1e\x47\x19\x8f\xb2\xf7\x57\x41\xe6\x8f\xc0\x1f\xc5\x71\xca\x53\x99\x77\x97\x2e\x0c\x4c\x74\x64\x98\xb0\x0b\x4e\x0f\x23\xd4\x05\x9d\xdb\x7c\xd9\xbb\x00\xa7\xd5\xc2\x2b\x01\xa7\xe6\x12\x37\x03\x4e\xfd\x5b\x5d\x10\x38\x10\x96\xb9\x27\x70\xbb\xbc\xc5\x75\x41\x8e\x1a\x1b\xbb\x35\x48\x69\x52\xea\x96\x41\x94\xf9\x59\x70\xc9\xf3\x15\xd1\x56\xc6\x52\xae\x6f\xf1\x3e\x1c\x7c\xff\xbe\x35\x8a\xc7\xbc\x15\x0c\xfa\xa5\x36\xbd\xa5\x0e\xe2\xa4\x50\x1a\xab\xe8\x27\x18\xf3\x71\x9c\xcc\x1d\x4b\x30\x15\x79\x90\x25\x6c\x38\x0c\x7c\xe7\x9b\x2c\xf3\xe4\x0a\x52\x21\xf7\xac\x1a\xf6\x07\xb8\xb6\x2c\x89\xd5\xe3\xf2\x47\x2c\x88\x6e\x1a\x98\xd8\x82\x97\x01\x86\xf7\x86\xcc\xa7\x8b\xc3\x0d\xc1\x8c\x78\x86\x99\x79\xaa\xc0\xb5\xdb\x70\x14\x85\x73\xba\x3a\xe7\x69\x16\x44\x17\xad\x4d\xf4\x9b\xce\xd3\x8c\x8f\x37\x35\x8a\x30\xbe\xb8\x91\x22\xb7\xb4\x7a\xd7\x06\xc1\xe5\x82\x3b\x07\x81\x61\xf5\x57\x8b\x79\x10\x45\x37\x06\x53\x18\x5f\x78\x80\x6f\xf9\xca\x16\xc9\xe6\x86\xb0\xe4\x50\xd4\xbf\x4f\x24\x0a\x10\xb1\x45\x66\x79\xf5\x2f\x8c\x2f\x16\xd6\x29\x59\x28\xea\xdf\x75\xc5\xbd\x85\xdb\xe2\xba\xec\xba\xd0\x65\x8d\x0a\x5b\xbe\x23\xed\xaa\x4c\xfa\xae\x10\x2e\x5a\xf6\x49\x8e\x95\x9b\xdd\xe9\x79\x56\xc1\x4e\xef\x8a\x90\xe5\xdf\x3b\xb5\xdb\xca\x0b\x45\xdf\x94\x9b\x7c\x4a\xda\x7d\xe5\x35\x0b\xa2\x0d\x39\xaf\xc8\xfd\xb5\x5f\x38\xfc\x7e\x2a\xf5\xc4\xe8\x76\x3a\x7f\xaf\x95\x39\x14\x90\xb3\x41\xf3\x66\x9f\x8e\x61\xc8\x67\xdf\x63\x82\xd8\xae\xfb\xe1\x9c\xf9\x1f\x2f\x12\xa1\x27\x3e\xa7\x8b\x22\xf2\x95\x98\xb0\x90\x67\x19\x6f\x99\xcf\xe5\x57\x4f\x3a\xdf\x21\x35\x4b\x27\xcc\x17\x13\x33\x8d\x82\x0c\xb6\x61\xf7\x16\x6e\x21\xc6\x2b\xe4\x2b\xf2\xb7\x29\xa3\xfd\x87\x78\xd2\x87\x07\x0f\xdd\x4f\xb1\x8e\x30\x5d\x63\xd3\x2c\xb6\x3c\x36\x3c\xd9\x37\x06\x4f\xc2\x6c\xd8\x69\x6b\x3a\xa9\xd7\xd2\x71\xad\x91\x1f\xab\x66\x8f\x22\x09\x28\x24\x42\xce\x3b\xe7\xe1\xfd\xa2\x0f\x4e\x0e\xd1\x87\xf7\x2b\xd6\xb6\x3d\x38\xd9\xef\x8d\x3e\x44\x9d\x3f\x7a\x5e\xff\x10\x1f\x9f\x9c\x4f\x0d\x2e\x77\xe3\x51\x63\x1e\x88\x2a\x79\xe0\x6a\xca\x74\xb7\x21\xda\x94\x6b\xc8\xbd\xa2\x8a\x2c\x6a\xdb\x9a\x71\xaf\xa0\x1a\x8b\x1a\x4b\x68\xc4\xa2\xda\xad\x14\x61\xd1\x70\x19\xfd\x17\x3b\xb8\x85\xda\x4b\x23\xfc\x9f\xe6\x23\x53\x1b\x33\xc1\xe8\xeb\x7a\xc6\x48\xd6\xba\xc1\xdb\xc1\x5e\xb3\xb7\xf0\x8d\xc9\x1d\x4c\xca\xf5\x21\xb5\x15\x17\x4e\x19\xe5\x5a\x4a\xf5\x09\xa0\xb4\xfa\xa2\x53\x41\x69\x03\xa1\xd3\xf5\xf3\x4a\x5e\x79\xd5\xa5\x0e\x15\x85\x96\xd7\xab\x3a\x2f\x08\x3e\xaf\xd2\x73\x70\x8d\xfd\x49\x8e\x0b\x7f\xa0\x0e\xb5\xba\xd7\x83\x92\x5a\xb9\xfb\xcf\x47\x7f\xdd\x7f\xfe\x75\xff\xf9\xd7\xfd\xe7\x9f\x79\xff\xf9\x7d\x12\x0c\xaa\x6e\x3e\x9f\x3c\x72\xaa\x2d\x02\x2c\xbe\x5b\x63\xf4\x47\x2c\xc9\xaa\x70\x7e\xf8\xe8\xf1\x97\xb8\x1a\xfd\xeb\xe9\xdd\x5f\x77\x7e\x7f\xdd\xf9\xfd\x75\xe7\xf7\xd7\x9d\xdf\x5f\x77\x7e\xff\xb3\xee\xfc\xc4\x66\x8b\xfb\xb8\x31\x61\x5c\x88\x9f\x2a\x06\x6f\x82\x43\x4b\x78\x3a\x89\xa3\x34\xb8\xe4\x40\xdb\x73\x4b\x4d\xb3\x0e\x1e\x26\x98\xea\x9d\xda\xbc\xb5\x15\x24\x05\x0a\xb7\x25\xe6\x44\x21\xfe\x5a\xb0\x4c\xc0\xc2\xe6\x8f\x2f\x6b\x29\xcc\xcc\x01\x5d\xde\x23\x6a\x94\x96\xbe\x43\x54\x2d\x16\xdf\x1f\xaa\x5a\xcb\xdc\x1d\xaa\xba\xb7\xbb\x37\x54\xad\x97\xba\x33\xd4\x5d\xdd\xe6\xbe\xd0\x8c\x7c\x63\xd6\x93\x5b\x3e\xf8\x41\x2d\x6f\xe1\x73\x1f\xc5\x51\x6a\xa7\x90\x56\x60\xf7\xbc\x4d\x65\xcb\x18\x28\x9e\x4b\xce\xc3\x6b\x1b\xdb\x46\xa3\x22\x04\x5a\xdc\x83\x65\x55\xd7\x38\xeb\x5d\xdf\xdc\x34\x70\x43\x80\x20\xe3\x63\x35\xf6\x59\xda\xa7\xa5\x23\x91\x9e\xa5\xb7\x7f\x71\xb2\xf0\x7a\x47\x2b\xd4\xad\x77\x7a\x0d\x3f\x57\x33\xb1\xf8\xf6\xe8\x53\xee\x62\x41\x1b\x95\x6d\xc4\x65\xec\xdd\x1b\x2e\xa2\x0a\x03\x08\xe3\x48\xe3\x8f\xe0\xd0\x5d\x9c\x65\xcc\x85\x4e\x39\x34\x73\x17\x73\xca\xdf\xef\xc6\xab\x2f\xb0\xee\x54\x1c\x47\x3f\x15\x8f\x70\xd1\xbf\xeb\x46\xd5\xfd\x17\x94\x3e\x64\x81\xf2\xbb\xb4\x95\x6d\x44\x7a\x49\x57\x5e\x88\x69\xe9\x52\xb4\x16\xe9\x25\x55\x1a\xd3\x0e\xc3\x2c\x97\x5c\x6a\xa1\x4f\xa8\xed\xe3\x31\x12\x05\xd6\x15\x16\x3d\xf2\x24\xcf\xd1\x25\x8d\xd6\xa2\xf6\x62\xa3\xb5\xa8\xb1\xcc\x03\x4f\xe9\x69\x9a\x9b\xd0\x25\x9e\x77\xc6\x63\xbe\xd4\xe3\x4e\xd1\xc1\x6d\x9e\x76\xe2\x08\x0b\x62\x97\x76\x7b\x3d\xee\x1f\xed\x14\x16\x50\x22\x85\x4b\xeb\xd7\x23\x3e\xcb\xde\x9a\xc7\x0e\xe6\x9f\x1c\xfe\x1d\xb4\x9a\xc9\xfb\xbc\x20\x7d\x33\x0d\xc3\xa3\xe4\x47\x15\x7a\xb5\x61\xda\x3b\x16\xcc\x63\x7d\x03\x78\xf0\xe1\xe0\xf4\xdf\x0f\x7f\x79\x2f\x2d\xae\x27\x0d\x41\x9f\x8d\x01\x95\x66\xd9\x93\x22\xb7\xdb\xa6\xe3\xf5\xb6\x29\x0c\xca\x3b\xe2\xc8\x93\xb6\x45\x58\x14\xed\x6d\x15\xaa\xd2\x38\xf1\xf2\x12\x1b\xd8\xb7\x97\x93\x24\x18\xb3\x64\x7e\xbc\xdb\xe9\x9c\xec\x15\x3b\xa1\xc1\x94\x37\x4d\xb9\x1f\x47\x03\xd3\x78\x03\x3b\xa9\xd9\xd3\x4b\x36\x51\xbd\xc0\x7b\xf7\x37\xf5\xc0\x55\x6f\x10\x07\x09\x67\xd8\x79\xd5\x13\x57\xb1\x69\x3d\x34\xdb\xc0\x6e\xa7\x23\x9d\xaf\xd3\x12\x23\xfe\xed\x5e\xbb\x1a\x6c\x7e\x39\x98\x89\xa5\x88\x27\xe9\xf5\x20\x89\x71\x79\xe6\xc5\xe3\x38\x8e\xe2\x2c\x8e\x78\xcd\xc3\x0d\xe7\xdf\x91\x0b\x71\x18\x35\x0f\xd2\x2c\x89\x3f\xf2\xbe\xcd\x2e\x9e\x38\x0e\x86\x4e\x51\xd9\xce\x50\x82\xe4\x5a\xb3\xf1\x2a\x88\xf8\x26\x66\x43\xb2\xef\xba\xd3\x21\xd0\x59\x95\x88\xf6\xca\xf1\x60\x10\x67\x3a\x8b\xf2\x7f\x1f\xf2\x7d\x6d\xcc\xfc\x9c\x25\x19\x4f\x03\x16\x91\xd6\xff\x49\x13\xbb\xf6\x2f\x9c\x1b\xe2\xbf\x60\xe9\x48\x9c\x81\xc5\xb4\x3c\x80\x07\xb5\x82\x73\xc2\x1f\x31\xff\xce\x22\xfa\x63\xa7\x7f\x53\xb2\x6c\x43\xab\xe7\x96\xb3\xe6\xc1\x25\x4f\x30\xeb\xb5\x21\xdd\x1f\x2f\x0b\xdd\x65\x4c\xc2\xd0\xd9\x14\xcb\xe6\x73\x45\xad\x57\x28\x53\x95\x8f\xba\x85\x22\x57\xd4\x75\x71\x23\x5e\xe9\x5e\xf4\xcb\xdd\x59\x7e\x40\x37\xae\x7a\xa3\xae\xb4\xd5\xdc\x65\xe5\xe3\x45\x97\x95\xcb\xa6\xdd\x28\xb9\xb8\x2c\xbf\x53\x2b\x05\x98\xbb\xc2\xb4\xaf\x2f\xd1\x5b\xd6\x4a\x45\x12\x8c\x55\x0a\x12\xbc\x3f\x39\x95\x8f\x57\x4f\x5f\xbe\x7e\x7b\xf4\xee\xc3\xe1\x8b\xd3\xd7\x47\x2f\x7e\x7c\x75\x78\xda\x39\x3d\x9d\xc4\xe1\x5c\x70\x04\x9a\x5d\xcb\x2f\x6c\x9e\xdc\x0e\x78\xf7\xf4\x54\x5b\x0c\x4e\xdf\x4f\x31\x8d\x51\x65\x2f\x4f\x1e\xba\x9d\x24\x5c\xa6\x51\xa9\x9f\x07\x98\xf9\xa6\xe1\x26\x54\xd1\x2d\x5b\x83\x0a\x6a\xc9\x1e\xef\x1a\x2b\x42\xdd\xba\x01\x5a\x15\xed\xe3\xbb\xec\xee\xc9\xde\x6d\xe9\xdc\xb3\x61\xbe\x62\x73\x9e\x54\x12\xa2\xfb\x64\xd3\x84\xc0\xfe\x56\x26\x43\x19\xca\xeb\x11\x61\x57\x40\x94\x52\xe1\xf4\x15\xbf\xe0\xd1\x60\x01\x15\x1e\x6d\x9c\x0c\xd8\xe3\xca\x74\x28\xc5\x7a\x3d\x42\xdc\xb7\x41\x7e\x88\xe3\x30\x0b\x26\xd5\x94\xd8\x7d\xbc\x69\x4a\xc8\x2e\x57\x26\x45\x39\xde\xeb\xd1\xe2\x81\x0d\xb3\xc4\xc0\x55\x49\x97\xc7\xbb\x1b\xe7\x90\x92\xee\x57\xa6\xd1\xcd\xe3\x59\x8f\x5e\x0f\x6d\xf8\xcf\xf9\x02\xb9\xdd\xed\xec\x6e\x9a\x40\xa2\xbf\x95\x29\x52\x82\xf1\x7a\x24\x78\xe4\xb0\x21\x9f\x65\xd5\x5b\xd7\xe6\x97\x0e\x9f\x65\x2b\x53\xa0\x04\xe1\xf5\x28\xf0\xd8\x91\x49\xec\x9c\x57\x73\xc1\x83\x07\x9b\xdf\x4e\xce\xf9\xea\x5c\x50\x86\xf2\x7a\x44\x78\x52\x80\xf8\x2a\x48\xab\x79\xe1\x51\xf7\x8b\x10\x42\xf4\xb9\x32\x31\xaa\x50\x5f\x8f\x20\xdd\xce\xe9\x69\x3a\x62\x13\x7e\xfa\x9e\xfb\x59\xbc\x40\xc5\x78\xd0\xd9\xb8\xb2\x85\x3d\xae\xae\x6b\x15\x50\x5e\x93\x04\x5d\x05\xef\xf9\x34\xb9\xac\xd6\x36\x1f\x6f\x5e\x34\x8a\xfe\x56\x1f\x7f\x1e\xdf\x35\x87\xdf\x53\xe0\xde\x71\x3f\x63\xd1\x45\xb8\x80\x04\xbd\xcd\x6f\x9f\xb2\xcf\xd5\xc9\x50\x86\xf7\x9a\xa4\xd8\x55\x20\xdf\xc6\xe1\xfc\x02\xc3\x22\x55\x38\xba\xf5\x36\x2e\x22\x65\x97\xab\xd3\xa1\x88\xf4\x9a\x54\xb8\xaf\x00\xbe\x88\x17\x88\xc6\x8d\x8b\x83\x17\xf1\xea\x42\x31\x87\xeb\x9a\x03\x7f\xa0\x17\x56\x12\xa7\x69\xe5\xd0\x77\x9f\xdc\xdf\xb8\x24\x10\x1d\xae\x3e\xfa\x3c\xc2\x6b\x8e\xff\xa1\x16\xac\xf3\xf1\x79\x1c\x56\x53\xa0\xfb\x64\xe3\x4a\x92\xec\x72\x75\x1a\x14\x91\x5e\x93\x0a\x8f\xd0\xbe\xc1\x12\xb1\x9e\x58\xf2\x7d\x12\x54\x9f\x38\x9f\x6c\xfe\x3c\xa1\x3b\x5d\x9d\x12\x65\x88\xaf\x49\x8b\xc7\x0e\xc8\x77\x6c\x10\x4c\xd3\x83\x59\xb0\x80\x33\x1e\x6c\x5c\x65\xca\x75\xbd\x3a\x5d\xaa\x07\xb1\x26\x75\x9e\x38\x80\x0f\xc4\x16\x74\x03\x71\x36\xbe\x7f\xba\x3d\xaf\x4e\x9b\xca\x21\xac\x69\xbb\xea\x68\xb8\x41\xb5\x3a\xb1\xbb\x79\x03\xde\xdb\x60\x75\x4d\x22\x87\xec\x9a\x23\xef\x2a\x60\xef\xd8\x80\x55\xeb\xd3\xbb\x9b\x37\x56\x61\x87\xab\x8f\x3e\x8f\xf0\x9a\xe3\xef\x59\xe0\x02\x16\x7e\xbb\x90\x06\x1b\xdf\x46\x74\xa7\xab\xd3\xa1\x0c\xf1\x35\x69\xb1\x7b\x7a\xea\xab\x3b\xa0\xd3\x6f\x93\x69\x3a\x5a\x40\x8b\x8d\xdb\x70\xb1\xc3\xd5\xe9\x50\x86\xf4\x9a\x74\xb8\x6f\x83\xd4\x0f\x06\x5e\x05\xd1\x22\xd9\xf0\x05\xce\x1a\x56\xc7\xab\xd3\x65\xd1\x20\xd6\xa4\xcf\x83\x52\xd0\x8b\xd4\xef\xdd\x27\x1b\xdf\x67\xed\x7e\x57\xa7\xce\x82\x21\xac\x49\x9c\x87\xa5\x90\x0f\x12\xce\x16\x50\x67\xe3\x67\x75\xa7\xe3\xd5\xc9\xb3\x68\x10\x6b\xd2\xe7\x91\x0d\x5a\x5f\x39\x2f\x54\x44\xee\x77\x36\xce\x3d\x4e\xc7\xab\xd3\x67\xd1\x20\xd6\xa4\xcf\xe3\x52\xd0\x8b\xf5\xfa\xfb\x1b\x17\x3e\x4e\xc7\xab\xd3\x67\xd1\x20\xd6\xa4\xcf\x13\x1b\xf4\x42\x99\xdc\xeb\x6d\x5c\x5f\xbb\x9d\x28\x2e\x41\x79\xcd\x6b\xc6\x8e\x0d\x71\xa1\x6c\xe9\xf5\x36\xae\xb8\xdd\x4a\xa4\x94\xa1\xbc\x26\x11\xba\xce\xce\xbf\x40\x71\xeb\xf5\x36\xae\xb8\xdd\x46\x65\x2b\x41\x78\x4d\x0a\xf4\x6c\x80\xef\x7d\x96\x65\x0b\x6e\x13\x7b\xbd\x8d\xab\x6c\xb2\xcb\xd5\x29\x51\x8e\xf8\x9a\xd4\x70\x34\xc1\x7f\x2c\xdc\x51\x1e\x6f\xdc\x24\xf6\x8f\x5b\x6d\x24\xa5\x38\xaf\x49\x06\x47\xf1\xfb\x65\x31\x19\x36\x6e\x16\xfe\xe5\x76\x64\x28\xc3\x79\x4d\x32\x38\x1a\xde\x7f\xdc\x60\xe8\xd8\xb8\xfe\xf5\x1f\xb7\xa3\x43\x19\xd2\x6b\xd2\xc1\x51\xe5\xf0\x71\xef\x22\x51\xd9\xed\x6c\x5c\x48\xa8\x3e\x57\xa7\x46\x05\xea\x6b\x12\x44\xe8\x6e\x23\x96\x64\xa7\xda\xfb\x76\x81\x62\xb5\x71\xc6\xd0\x9d\xae\x4e\x8e\x32\xc4\xd7\xa4\xc5\x63\x05\xf2\x5b\x96\xdc\x44\x8a\x8d\x2b\x53\xaa\xcf\xd5\x29\x51\x82\xf6\x9a\x84\x78\xa2\x20\xbe\x0d\x6e\xe4\x89\xcd\x1b\xd1\x83\xdb\xb2\x44\x09\xda\x6b\xfa\x6d\x75\x14\xc4\x0f\x09\xe7\x63\x56\xed\xb4\xf5\xe4\xfe\xe6\x3d\x4f\xa8\xcb\xd5\x9d\xb6\x8a\x48\xaf\x49\x85\xae\x02\xf8\x9e\x45\x1f\xf9\x7c\x01\x11\x36\xaf\x53\x61\x8f\xab\xd3\xa0\x80\xf2\x9a\x24\xe8\x29\x78\x68\x67\xbd\x61\x4d\x6c\xfe\xa6\xc0\xf4\xba\x3a\x29\x4a\x51\x5f\x93\x1c\xbb\x9a\xbc\xa4\xad\xde\x44\x90\x8d\x6f\x1c\x76\xbf\xab\x93\xa4\x02\xfd\x35\x89\x72\x5f\x41\xd5\x2f\x19\x16\x50\x64\xe3\x2a\xb7\xee\x74\x75\x72\x94\x21\xbe\x26\x2d\x1e\x58\x4c\x47\xf6\xf8\x9b\x08\xb2\x71\xe5\xdb\xed\x79\x75\xaa\x54\x0e\x61\x4d\xd2\x3c\x54\x70\xf1\xc5\x44\xca\x07\x37\x51\x66\xe3\xaa\x86\xd3\xf1\xea\x84\xa9\x1a\x80\x45\x97\x2f\xfc\x2f\xf7\x54\xe3\xc9\x17\x7a\xaa\x71\xab\xf7\x15\x7e\x9c\xf0\xd3\xdf\xd2\x53\x9e\x3e\x3c\x1d\xb3\xac\xfa\xd2\xe8\xe1\xe3\xce\x6d\xdf\x70\x14\xfb\x38\x35\x0f\x5d\xca\x38\x21\xaa\xaf\x06\x8e\xde\xc3\x00\x4f\xc3\x20\xca\x20\x8a\x9b\xf8\x24\xbb\x0f\x1d\x41\x69\x7c\x61\xcb\xd3\x8c\x5e\xb2\xc0\x3e\x7c\xba\xde\xdb\xda\xa2\xe0\x57\xe5\x11\x82\x3e\x7f\xb6\x1a\x98\x07\xde\x8d\x86\xcc\x2e\x98\x40\xc4\xb2\xe0\x92\x7f\xef\x36\xdb\x2f\x7f\xfe\x8d\xcf\x90\x4a\xbf\x38\x6f\xdd\xe9\x61\x90\x7a\x83\x2c\xd0\x8b\xf3\xfd\xeb\xf7\xc9\x26\x4a\x98\x53\xc1\x79\x49\xae\xc2\x64\x97\x60\x4a\x19\xe1\x08\x25\x4f\x42\xc1\x07\x54\xd7\x7b\x5b\xd7\x79\x76\x7d\xdc\x59\x2b\x0c\x62\x39\x2b\x75\x1b\x7b\xe5\x5f\xf0\x32\xa5\xfc\xcb\xfd\xca\x2f\x0f\x2a\xbf\x3c\xac\xfc\xf2\xa8\xf2\xcb\xe3\xca\x2f\x4f\x2a\xbe\x3c\xea\x54\x8d\xe7\x51\xa7\x57\xf9\xa5\x6a\xa4\x8f\x3a\x55\x23\x7d\xd4\xa9\x1a\xe9\xa3\x4e\xd5\x48\x1f\x75\xaa\x46\xfa\xa8\x53\x35\xd2\x47\x68\x47\xa0\x29\x6e\xc9\x19\xae\xf4\xce\xea\x34\x5a\xaf\x59\x36\xda\x2b\xc8\xb9\xc7\xdd\xb5\x18\xa7\xdd\x86\x5e\xa7\xd5\x6b\xf5\x5a\xbb\x20\x3a\x68\x31\x3f\x4e\x47\xf5\x59\x03\x17\xf4\xdf\xe4\xa6\x52\x61\x2d\x15\xf3\x21\xaa\x85\xf1\x45\x77\x52\x75\x71\xd7\x7d\x20\x6b\xa5\xff\x44\x48\xd8\x8b\xf8\x9b\x4a\xff\x86\x1d\xaa\x72\xfc\xb1\xb7\xb5\x25\x3b\xae\xcb\xff\x6d\xbd\x87\x1d\x85\x4c\xeb\x3b\xd8\x86\x3b\x75\x6a\xb7\x85\x41\x82\x7f\x7a\x0c\xe7\xd3\x8b\x3e\x8c\xb2\x6c\x92\xf6\xdb\x6d\x3f\x1e\xf0\xd6\x45\x1c\x5f\x84\xbc\xe5\xc7\xe3\xf6\xa4\x7d\xf9\xb8\x1d\xa4\xe9\x94\xa7\x6d\x8a\xeb\xf4\x2c\x18\xec\xef\x3e\xe8\x3c\xd9\x02\xb8\x77\x8f\xba\x1e\x86\x71\x9c\x48\xb0\xf5\x37\x14\x62\xe3\xf5\xc1\x3f\x4e\x7f\x3a\x78\xf5\xe3\x61\xa3\x01\xfb\xfb\xf0\xa8\xdb\xa1\x0e\x3f\xc4\x09\x7c\x9b\xc4\x57\x29\x4f\xa8\x67\x8b\x74\x2f\xa3\x61\x10\x05\xd9\xbc\x01\xcd\xa7\xf0\x86\xbd\xa1\x2e\xfe\x96\xff\xb8\xbf\x0f\xea\xc7\x56\xc3\x83\xda\x6b\x99\x6b\x73\x0b\x00\xab\x5a\x81\x13\xd4\x94\xb8\xd1\xe5\xeb\x33\xd8\x87\x9d\x59\x03\xbe\x81\x2e\x3c\x13\x3d\x41\x1f\x66\xf0\x14\x9e\xdc\x7f\xd2\x79\xd8\x7b\xf8\xa0\xf5\xb0\x77\xbf\xf7\xa0\xfb\xe0\xa1\x14\x67\xcf\x08\xcb\x30\xbe\x10\xb0\x76\xe8\xd7\xab\x37\x3d\xf9\xb9\x4f\xd3\x58\x9f\x41\x13\xba\xb0\x83\xd3\x45\x3f\x1a\xb0\xad\x7e\xed\x40\x97\x42\x69\x5c\x53\xa8\xd4\x3c\x33\xf6\xd6\x62\x46\xc1\x0f\x2c\xd2\x3b\x48\xb9\x50\xdb\x95\xec\xf4\xf2\xf0\xf1\xe9\x8b\xa3\xd7\xa7\x2f\x0e\xbf\x7b\xf9\xe6\xb0\xb2\xfa\x7d\x59\x3d\x8b\xdf\x26\xc1\x38\x10\x62\xba\xb2\xee\x43\x59\x77\xf0\xd6\xec\x32\xee\x93\x4c\xeb\x11\xe9\xb0\x72\xad\xf6\x1a\x26\xfa\x9d\xdb\x1c\xfa\x15\xb1\x63\xe7\xf5\x23\x0f\xde\x7a\x70\x90\xc9\xa0\x6a\x32\x5e\x88\xa2\x46\xfd\x08\xa9\x2e\xf0\xb2\x06\x52\x7f\xeb\xe1\xbb\x4f\xfc\xa6\xab\x5a\x30\x44\xb9\xd8\xe3\x5c\x5a\x35\x20\x4b\xe6\x2e\x33\x0d\xde\x16\x11\xc0\x69\x06\x9f\x61\xc2\x19\xcc\xcb\x27\x36\xff\xf1\x24\x9b\x0b\x6d\xe4\x5a\x82\xae\x5d\xf0\xac\x06\x41\x64\xb5\x14\x3b\x7b\x2d\x2d\x14\x37\x64\x14\x45\x13\x41\xb1\x76\xe0\xfb\x3c\x4d\xe3\x24\xc5\xb8\x88\xe9\x74\x22\x48\xcb\x07\x77\x6a\x1a\x73\xf9\x88\x39\x0f\xe9\xe8\xf8\xed\x09\xec\x5b\x45\x14\x61\x68\xcf\xe4\x93\x3d\xa2\xc0\xee\x79\x06\xdd\x5d\x9b\x41\x83\x74\x21\x83\x76\xd1\x8d\xa3\x20\xd5\x8d\x06\x12\x48\xed\x03\x55\x23\x05\x4c\x94\x16\xe9\x13\x64\xb0\x03\x35\x08\x88\x3c\x4c\xa9\x22\x92\x3c\x72\xa0\x41\x56\x3e\xd2\xfb\x6b\x8d\xb4\x30\x80\x3b\x95\xbc\x7e\xef\x5e\xc5\xc7\xdd\xdd\x46\xdd\x09\x9c\x6c\xcd\xce\x0d\xef\x9d\xed\x55\xf9\xa0\x51\xc7\x94\x2a\x42\x4a\x32\x4c\x47\x7c\xc1\xb3\x7e\x2e\x24\xb3\x84\xfb\x08\x63\xa1\x36\x5a\x0c\xee\xec\xc3\xa3\xbd\x72\x21\xb5\x5e\x96\xed\xa5\x79\x00\x25\x49\xec\x63\x00\xa2\xaa\x8a\x8f\x9f\x34\x5a\xaa\xce\x1e\x06\x78\xa4\xb8\xa0\xaa\xcc\x7d\xff\x2f\x38\xa1\x46\x3c\x80\x2b\x22\x0e\x07\xf0\xf2\x50\x62\x04\xfb\x1a\xad\xba\x6a\x8e\x93\x53\x28\x75\x81\x2e\xc7\xad\x8a\xd9\x52\x78\x56\x81\x1c\x56\xed\xa3\xda\x5f\xc6\x8e\xeb\xa5\x39\x6e\xb7\xe1\x51\xab\xdb\xea\xc2\x07\x4b\xfa\x05\xd1\x64\x9a\xc1\xb1\x07\x6f\x13\x3e\xe4\x49\xc2\x07\x62\xe9\x9c\x34\x96\x9f\xa2\x76\x1b\xe3\xf1\x72\x36\x50\x01\x1c\x0f\xdf\x3f\x84\x74\xc2\x7d\x15\x09\xd3\x83\x2b\x0e\x83\x60\x10\xd5\x32\x0c\x4a\x49\xf3\xf0\xaf\xff\x6a\x6f\x27\x3e\x93\x71\x1d\xa3\x01\xe5\x91\xc1\x58\x42\x3a\xf8\x14\x34\x61\x18\xb2\x0b\x68\xc2\x44\xe1\x89\xd3\x2c\x88\xc9\x80\xc2\xb2\x2f\x9e\x02\x0f\xde\x57\xca\x0c\x4b\x0a\xd0\xa1\x69\x18\x61\x00\x0c\x25\x40\xdf\x0b\x16\x90\x5c\x55\x1f\x46\x82\x4b\xb2\x56\x16\xbf\xc7\x6e\x51\x0d\xa9\xa9\xae\x6a\xb8\x94\x35\xf8\x4b\x16\x0a\x3c\x22\x3a\xc7\x88\xce\x74\x6f\x16\xfc\x3c\x68\x94\xc3\x47\xc3\x0d\x40\xbe\xf3\x25\x51\xcf\x8b\xda\xbb\xcf\x99\x98\x62\x3f\x8e\x2e\x79\x92\x49\x41\x0b\x59\x0c\x13\x3d\xcd\x14\x29\xbd\x51\xce\xde\xcb\x44\xb1\x2f\x17\xac\x66\xa2\xcf\x83\x6c\xcc\x26\x26\x0f\xee\x56\x2e\x93\x90\x1d\xb4\xf7\x8e\xac\x0d\xf7\xa0\x2b\x43\x89\xb8\x01\x7b\xad\x0a\x3d\x59\xc1\x44\xf8\xb5\x3e\xde\x97\x1f\xed\xb0\x7a\x5b\x3a\x2f\x4a\x7e\x98\x0b\xe3\x5f\x2c\x25\x3a\x29\x57\xfd\x02\x79\x48\x82\x73\x14\x0c\xaa\xf4\xb4\xdd\xae\xd2\xe9\x46\xac\x32\xbc\xb8\x06\xf4\xfe\xdd\xf3\xaa\x3a\x4f\x3a\x8d\x7a\x2d\x4d\xfc\x9a\xac\xfa\xe1\xe8\xf4\xfd\x87\x77\x2f\xdf\x7c\x0f\xfb\x50\x53\x7c\x56\x93\xc7\x14\xf5\x1b\xf6\xe1\x3b\x39\xf0\x63\xdd\xe0\x44\x02\x78\xfb\x0a\xf6\xa1\x5e\xab\x89\xd3\x8a\x66\xd4\x56\x3a\x09\x83\xac\xae\x2b\x8b\x2d\xa9\xf2\x90\x17\x44\x42\xfa\x64\xef\xe3\x69\xe2\xf3\x45\x92\x58\xc3\xd7\x3c\x4e\x33\x56\x5f\xc0\x60\x47\x26\xd1\xb2\x07\x29\x1b\x72\x63\x6a\x09\x52\x35\x2a\xa1\x62\xd2\x9a\xc3\x55\x64\x2f\x32\xb5\x32\x4d\x65\x8c\xfa\x5d\x47\x78\xb5\x88\x8d\x79\x0d\xe3\xcf\x89\xc9\xb3\x0b\xb1\x5b\xad\xd2\x1d\xc9\xbc\xca\xfb\x98\x59\x59\x2d\xcc\x85\xb0\xdf\xbf\x7b\x9e\x03\xfc\xfe\xdd\x73\x0f\x24\xa4\x67\x80\x14\x97\xbf\xfa\x62\x1a\x5a\xbf\xc5\x41\x54\x27\x02\xd5\x45\xe7\x0d\xd3\x3d\xf6\x4c\x6c\xa8\x8e\x54\x47\x56\xaa\x67\x52\x7b\x31\x0b\x34\xc5\x47\xd7\x74\x02\x18\xf0\x90\x67\x5c\x56\x27\x3b\x10\xa2\x64\x11\xb6\x91\x6b\x4f\x75\x6f\xe8\xe8\xd3\x02\x50\xb8\xb3\x0c\x06\x30\x64\x1f\xb9\x66\xbd\x7f\xd1\xec\x38\x8c\x13\xf0\xe3\x24\x11\xe2\xea\x2a\x4e\x3e\xc2\x55\xc2\x26\x13\x3e\x80\x31\xcf\x46\xf1\x20\x85\xb6\x1d\x0c\x3c\xa5\xe8\xbd\xea\x5b\x18\x7c\xe4\xf0\x2a\x7e\xc1\xd2\x11\x04\xe9\x1b\x34\x62\x6d\x5d\x37\xea\xaa\x1b\x3b\xa8\xb8\xe6\x5f\x2b\x1e\xab\xc2\xc2\x55\xee\x24\xfb\x60\xd8\xf8\x82\x90\x16\xa5\xc7\xef\xdf\x3d\x3f\x11\xf3\x99\x63\x62\xf1\xad\x51\xa1\xb4\x2d\x34\xe7\xda\x02\x56\x0a\x86\xa3\xab\x48\x9f\xba\xf6\xe1\xd3\x75\xcb\x2d\xbb\x41\xe9\x21\x8e\xb5\x07\xe5\x36\x57\x8b\x4e\x71\x76\x89\xac\x7c\xb2\x8c\x45\xcf\x68\x94\x03\xcc\x0f\x82\x7f\x4f\x66\xca\x1c\x92\xb0\x68\x10\x8f\xeb\x8b\x55\xb4\x3c\xa6\x35\x7a\x36\x57\xaf\xb5\xfc\x38\xf2\x59\x86\xa9\xd4\x05\xcf\x4f\x55\x04\x48\x5a\x31\x7d\x62\xb4\x5a\xe3\xb4\xe6\x41\x7d\x67\x27\x18\xc0\x0e\x4c\x66\x0d\xbd\xc5\xd6\x77\x1f\x36\x2a\xc6\xb6\xb6\xd1\x89\x42\x8f\xb3\x10\xda\x90\xa2\x5e\x45\x99\xb5\x66\x19\xc8\xfb\x0b\x32\x06\x58\x42\xa9\x5c\x84\xf7\x16\xd3\x46\x28\x43\xd9\x88\x65\x1e\x50\xba\x15\x79\xaa\x56\x60\xeb\xc3\x48\xcb\x05\x0c\x5c\xee\x90\x49\xeb\x0c\x43\x94\x4e\x2a\xf7\xaa\x0d\x49\x66\xc9\xec\xf6\x8b\x69\x4d\x58\xc1\x90\xac\xf4\x11\x42\x88\xa9\x90\xa4\x7b\x06\x4e\xaf\x0c\x8e\x07\xe7\x37\x81\x12\x55\x8a\xd0\x76\x2b\xa0\x79\xe0\x2f\x01\x50\xd4\xb2\x60\x5e\x1b\x06\x33\xd0\xda\xdb\xd0\x6a\xb5\x58\x72\x91\xc2\x76\x3b\x67\x9f\x1a\x46\x3a\x14\x2b\x82\xd4\xa1\x58\xf7\x2a\xd5\x8b\x27\xcb\x98\x8f\x6e\xd2\xa2\xec\xf3\xb5\x94\x44\x41\x26\x8e\x83\x46\x0e\xdd\x78\xd2\xd6\xe0\x96\x3a\x6a\x3f\x59\xcf\xa8\x60\x4c\xb0\x0f\xa4\x1d\x31\x0d\xa2\x55\x4d\xb0\x7f\xc3\x46\xda\x8c\x2a\x7e\xd8\xe9\x50\x14\x48\x5b\x4e\xdc\x09\xd2\xef\x82\x28\xc8\xb8\xb6\x24\x7e\xfe\x0c\x33\x21\xb1\x3b\xf0\x0c\x66\x68\x4d\xfc\x06\xff\x6e\x52\xf3\xe6\x4c\x1c\xf0\x8c\x11\x51\xd9\x10\xa5\x6d\x70\x1b\xb4\x7d\xf0\x1a\x47\x55\x61\x25\x45\x58\x1d\x34\x8f\x36\x3b\x4b\x59\x7a\x71\x68\xf7\xee\x41\x17\xda\x72\xa0\xa2\xfd\x53\xe8\xd8\x86\x53\x1a\x63\x9f\xfe\x07\xca\xf6\x90\x27\xeb\x99\x44\xcc\x3c\x3d\x92\x23\xc9\xd8\x2d\xe6\x49\x34\xd2\xf3\x24\x7e\xec\x2d\x22\x16\x76\xd1\x24\x6a\x2d\x47\x2c\x84\xaf\x89\xa5\xdb\x7f\xe3\x52\x4b\x48\x41\xf1\xcd\x36\x33\xcb\xe1\x54\x98\x99\x2d\xbe\xd0\x2c\x50\xef\xc2\x0e\xcc\x1a\xd0\x86\x7a\x17\x9a\x30\x6b\x88\x3f\x7b\xd5\xf6\xe1\x27\xeb\x99\x5e\xcc\x0c\x3c\x21\x1c\xfc\x73\xc1\x79\x2b\x4d\x40\x1a\x5c\x54\xed\x26\x5d\xbc\x16\x2b\x12\xd9\x25\x9b\xe8\xd3\xa2\x9a\x44\xc1\x25\x9a\xe8\x44\x13\x6e\x9b\x70\x9d\xc4\x57\x75\x9a\xd3\xf3\xb4\x3e\x6b\x78\x38\x41\xbb\x0b\x8c\xe9\x4f\xd6\x36\x99\x48\x62\x75\xbb\x92\x5a\xe1\xef\xbb\xbd\x15\xc8\x75\x23\x25\x04\x3c\x9b\x14\x12\x7e\x81\x81\x9e\x3e\x7d\xba\x0f\x9d\x06\x3c\x83\x5d\xc1\x26\xd6\x75\x8b\x23\x4c\x3a\xad\x07\x9a\x5a\xaf\x8e\xbe\xef\x1d\x0a\x71\xb3\xbb\x88\x9d\xd6\xcb\x1d\x67\x51\xa8\x27\x29\xb4\xfa\xdd\x17\x9f\x4d\xd4\x6a\xe6\xb3\xc9\x12\x44\x73\xef\x76\xca\xaf\x76\xf8\x6c\xa2\xd9\x67\x47\x74\x21\x64\xef\x4d\x6b\x6b\xbd\xb3\xb9\x45\x8c\xfb\x7a\x38\xe3\xee\xaa\xe2\x0d\x1b\x55\xae\xaf\xfb\xa5\x5c\x95\x13\x62\x75\x09\xe4\xce\xbe\x85\x87\x23\xe9\xb1\xa4\xaf\x3a\x2b\x25\xc6\x32\xc7\x85\xa5\x88\xf1\x50\xb2\x2b\x26\x45\xde\xd4\xe2\x01\x02\xd7\xaf\x88\xc3\xd2\x69\x94\x0d\xea\x51\x67\x3d\x1f\x81\x9b\x06\x75\xa3\x64\xc4\xb3\x49\x7c\xa5\xd8\x7d\x12\x5f\x51\xd9\xe1\xdb\xf7\x2f\x5f\x1d\xbd\x81\x7d\xf1\xb5\xde\xf3\xa0\x89\xbe\x8e\xd6\xa7\xdd\x9e\xf5\xb1\xa7\x60\xbd\x3e\xf8\x87\xfd\xa1\xdb\x7b\x24\x96\x7f\xbd\x07\x4d\xd3\x4e\x55\x7d\xe9\xc2\xe8\xe2\xbb\x35\xfc\x84\x63\xf8\x10\xf0\xf4\x43\x7c\x78\xc9\xdd\x74\xbc\x91\xa3\xf0\x44\x42\x3d\x81\xb6\xc6\xb7\x69\xff\x22\xcd\xae\xa0\x57\x5a\x74\xc2\xcc\x8a\x0a\xb4\x26\x9d\xb6\xa0\xfc\x8d\x9d\xeb\x06\x24\xe2\x95\x45\xf6\x6f\x92\xb2\xb4\x2b\xe8\x62\xe6\x41\xc2\xd3\x69\x98\xa9\x13\x08\x42\xf8\x86\xc6\xaa\xcf\x1e\xd4\x78\x3b\x3f\x4c\xaa\xdc\x96\x84\x69\x5b\x04\x13\x12\x14\x0b\xb7\x4d\x21\xde\x0f\xc2\x3e\xe0\x7e\x6d\xe6\x44\x37\x13\x8d\x04\x40\xd2\x75\x53\x72\x19\x62\xd0\x84\xba\xf8\x8f\xf8\x82\x58\xb7\xdb\xd2\xf9\xa7\x39\x08\x52\x76\x1e\xf2\x66\xc4\x67\x59\x33\x0c\x22\x0e\x51\xdc\x4c\x79\x38\x6c\xfa\xf1\x78\xc2\x12\x2e\x87\x24\x81\x3d\x95\x73\xfd\xf9\xb3\x02\x7f\x67\x5f\xfe\x55\x18\xa8\xba\x15\xb7\xf4\x6e\x4d\x03\x49\xae\xa2\x0e\xfe\xa8\xb3\x29\x37\x88\xae\x54\xee\x46\xf3\x49\x9c\xd5\x8f\xd1\x1e\xda\x3d\x96\x46\xd9\xde\xb1\x07\xff\xf5\x9f\xff\x2f\x9c\x9c\x9c\xac\x24\x16\x5d\xd6\xb8\x79\x93\xc0\xce\xad\x5d\x82\x90\x21\x5c\x14\x2a\x78\x21\x5b\x98\x10\x35\x17\xd3\x68\x9a\xf2\x41\xf3\x92\x25\xa9\x34\xef\x26\x90\x4e\xc7\x64\x64\x50\x05\x81\xfb\x93\xbd\xc2\xe5\xa3\x4f\x6a\x2a\x45\xa9\xae\x10\xb2\xe4\x22\xd7\x24\xb9\xf0\x60\x10\x5c\x52\xc9\xd5\x28\x08\x39\xd4\x03\xf8\x06\x61\x99\x43\x26\xb5\x13\xab\x42\x03\x3f\x0e\x76\x76\x4c\x5e\x09\xc1\x2b\x08\xfd\x1b\x51\xd7\x4e\x11\x31\x08\x2e\x61\x9f\x7a\x6e\x8b\x6f\x26\x02\x35\x0d\x47\xfc\x77\x1b\x6b\xd1\x7f\x77\xa0\x6b\xaa\x48\x84\xad\x66\x96\x65\x4e\x7c\x13\x67\x88\x42\x67\xd4\x57\x58\xe8\x6c\x67\xdf\xf4\x93\x83\x27\x3f\xeb\x26\xd7\xf6\x76\x4e\x58\x58\x0e\x1f\xf0\xcc\xfc\xd9\xa7\xcf\xdb\xd6\x51\x2a\x9d\x8e\xab\xd5\xc2\x47\x9d\xf5\x7c\x2c\x2c\x4e\x7f\x4c\x7d\x06\xe3\x69\x58\x9f\x79\x30\x5f\x6d\xa7\x17\xcd\x14\x53\x8b\xbf\xe9\x18\x93\xc6\x63\x0e\x3f\xf3\xf3\x7f\x0f\x32\x75\x85\x96\xc2\x90\x05\xa1\xb4\x3c\x9e\x07\x17\x40\xf9\x6b\x52\x8f\x2a\x8f\x58\x0a\x57\x49\x1c\x5d\x00\x4b\x82\x6c\x7e\xa3\x7a\xb0\xea\x55\x33\x22\x5a\xef\xcc\x86\xf2\x9f\x07\x0f\x1a\x42\xfc\x34\x1f\xa0\x05\x52\x7c\x95\x8c\x2e\x4a\x7b\x7b\x5b\xd7\xb9\x73\x92\xa8\x61\xad\x45\x43\x2e\x9d\x3f\x38\x81\x1f\x5f\xbe\xf9\xd0\x7d\x28\xd6\x06\xf6\x63\x16\xc8\x2c\x42\x35\xce\x14\xcc\xb1\x60\x6e\xd5\x10\x54\x94\xed\xef\xc1\x2c\xb2\xaa\x3a\x5f\xe6\xf2\x8b\x1c\x56\x07\x3e\x8b\xa6\xdb\xa2\xd6\x0e\xd4\xeb\x16\x04\xa1\x6f\x43\xf7\x61\x43\x7d\xc4\x6a\x75\x0b\x90\xae\xf0\xcd\x37\xd0\x7d\x88\xbf\x3a\x8b\x38\x6e\x53\xf6\x8d\x5e\x57\x1f\x1d\xbb\x9d\x0d\x1e\x44\x10\x9e\x35\x45\x0a\xbe\xab\x55\xdb\xde\x4f\xe6\x94\xd1\xed\x1c\x2e\x18\xf9\xa6\x2c\x06\xbd\x8e\x19\xf9\x64\x63\x5a\x24\x42\x2b\x57\x22\x77\xbb\x0f\x2a\x94\xc8\x4d\x1d\xc1\x7b\x3d\x3d\xa4\x4d\x1e\x2a\x05\x38\x77\x2a\x8b\x47\x4a\x7b\x26\xdb\xda\x8f\x6d\xc1\x34\x6e\xea\x24\xdd\x93\x22\x53\x6a\x72\x9b\x99\x45\x01\xac\x7c\x12\x85\xda\x5d\x3e\x89\x9b\x3a\xf8\xee\x76\xd4\x80\x56\xb6\x64\xdd\x7c\xd2\x2b\x3d\x1e\x93\xbb\x66\xc4\x31\x41\x64\x12\x8f\x83\xe9\x18\x76\x1f\xe3\x2e\xc0\x60\x92\xc4\xe7\x21\x1f\xd3\x56\x71\xc9\x93\x39\xa4\x63\x16\x86\x6a\xc7\xd8\xf8\xde\x70\xc7\x0c\xbe\xd9\xe3\xcd\xee\x23\xda\x19\xf0\xcf\xe2\x46\x40\xf6\x45\x93\xf0\x2b\x28\x31\x97\x19\xf5\xdf\x78\x67\x6a\xff\xcb\xba\x3a\x52\x43\x93\xc8\xa7\x8f\xf5\xda\x07\x53\x1e\xfd\xd1\xeb\xb2\x29\x4f\xfe\xf8\x0b\x8f\x46\x08\xfd\x50\x34\x58\x24\xae\x37\x65\x08\xd8\x95\x2e\xc1\xb7\x30\x73\xde\x92\x39\x6e\x90\x0d\x39\x83\xa5\x6b\xaf\x44\x75\x14\xf6\x25\x61\x25\xf9\xcd\x66\x7a\xae\x3f\x35\x55\xb1\x9c\x32\x06\xae\x6a\xd6\x85\xbe\xa8\xed\x94\x35\x45\x21\x1e\x86\xce\xd1\xda\x89\xb3\x64\xdb\x66\x16\x4c\xc7\xa6\x4c\x11\xbb\xd2\x2e\x93\x25\xd3\xc8\xdf\xa0\xc4\x45\x78\x36\x59\x11\x7e\x90\xe5\x8d\x52\x81\x38\xc7\x75\x94\x1b\x31\xda\xef\x94\x2d\xd8\xe7\x41\xd8\x20\x1f\x84\x2a\x32\x74\xd7\x33\x5e\x90\x8f\x02\xb9\x65\x57\xf2\xd5\x43\x99\xb1\x65\x0b\xb6\x01\x53\x0f\xa6\x42\xd1\x3f\xc3\xf3\xd2\x19\x04\x29\x9c\xbd\x61\x6f\xce\x5a\x5b\x80\x35\xb6\xb7\xdf\xc4\x19\xef\x6f\x6f\x53\xae\x68\xba\x13\x17\xb5\xce\x59\xca\x07\x10\x47\xa2\xd2\xf1\xd9\x1b\x95\x6d\x51\xb4\x3d\xa9\x2b\x1f\xf3\xf1\x20\x6a\x05\x71\x9b\xbe\xb6\xf1\x6b\x03\x3d\xc0\xe4\x1d\x12\x3a\x82\xb1\x31\x07\x96\x0a\x38\xd2\xed\xe5\xf8\xac\x02\x8e\x04\x70\x35\x0a\xfc\x91\xa4\x78\x0a\x67\x59\x22\x10\x1f\xc6\x89\x00\x71\xa6\x2f\x26\xcf\xb0\xa3\x18\x93\x3d\x47\x71\xd4\x24\xf1\x28\xd3\x1e\xa9\xe1\xfd\x6b\x9a\xb1\x2c\xf0\xf1\xcf\x31\x17\x15\x8e\x86\x70\x4a\x5f\x82\xc8\xe7\xd0\x69\x75\x5b\x1d\xfc\xed\xb3\x8c\x5f\xc4\xc9\x1c\x5e\xb1\xe8\x02\x4b\x26\x2c\x61\x63\xf8\xb4\x7d\x2d\xf3\x6c\x7e\x18\x49\xff\x27\xc8\x62\xf0\x05\x69\x5b\x58\x4f\x61\xfa\xe9\x3c\x8e\x43\xce\xa2\x6b\x78\xe7\xe2\x5e\x42\x7f\x8f\x8e\x4c\x67\x98\x08\xe9\x8c\xe0\xf0\x19\x1b\x4f\x42\x2e\x51\x3f\x25\x6a\xd7\x05\x49\xf6\x44\x41\xbb\x0d\xfb\x4f\xd1\xd5\x39\x57\x23\xe2\x57\x40\x53\x80\x95\x2b\x6a\x53\x5d\x73\xaf\xbb\x18\x66\x69\x3d\x44\x76\x4b\xb0\xb0\x39\x08\x60\x6d\xcb\x59\xab\xdd\x86\x83\x88\xc6\x68\xb9\x8d\x05\x94\x8a\x33\x8e\xc2\xb9\x22\x21\xa6\xc8\x26\x36\xe1\xff\x9c\xb2\x50\x10\x35\xc8\x52\x1e\x0e\x5b\x04\xe6\x2d\x4f\x86\x71\x32\xc6\x86\x67\xea\x3a\xfe\x03\xbb\x38\x23\xda\xc3\x30\x48\x52\xf4\x4e\x63\x97\x71\x30\x00\x9e\x24\xda\xb5\x43\x9c\xa9\x24\x2e\xbe\xe8\xff\x1f\xd2\x97\x2d\x85\x20\x82\x97\x87\x2d\xdb\x97\x53\x52\x4e\x0e\xe1\xde\x3d\x89\xdf\x9d\x7d\xd8\x91\xee\xd4\xd7\x25\x26\x31\x1c\x77\xc9\x02\x5f\x68\x81\xf9\xa3\x1f\xdc\x61\xfa\xa9\xea\x10\x1e\xb7\x7d\x63\x27\xc1\xae\xf5\xb0\x4e\xc2\xb8\x6d\x36\xa5\x49\x12\x4f\x4e\xb3\xf9\x84\x57\x07\x6b\xb9\xe5\x13\x42\x17\xf6\x1a\x63\x74\x01\xdd\x36\x57\x12\x66\x91\x8d\xd8\x78\xc1\x40\x7b\x9b\x80\xbd\xc6\x40\x5d\x40\xb7\xce\x87\x34\xcd\x82\xf0\xf4\xed\x34\xe1\xef\x30\x45\xea\x82\x20\x3c\x6b\x64\x1a\xba\x6d\x0a\xae\x15\x52\xf8\xdc\x32\xd4\xf8\x0a\x49\x6f\x90\x52\xef\xc4\x02\xfa\x31\x0b\x16\xf5\xa1\xee\x18\x4e\x29\x6d\x7d\x6a\x1e\xf4\xb0\x14\xad\xc9\xb6\x31\xbf\x9e\xb1\xe4\x82\x0b\x85\x07\xdd\xe9\xea\xca\x36\xda\xdd\x83\x80\x2c\x92\xae\x41\x14\x82\x9d\x9d\x06\xa6\x5e\x4b\x20\x55\x9e\x9a\x96\x65\xf3\x64\xcf\xc0\xf9\xc8\xe7\x42\xf2\x52\x35\xd1\x08\x9d\x02\x09\x15\xed\x5d\xd7\x2a\xf3\x2e\xa3\x26\xe4\x61\x26\x1a\x12\x92\xca\x81\x90\xbe\x92\x23\x22\x5c\xe3\xff\x29\xf7\x3b\xac\xb7\x07\xd7\xf2\x82\xc4\x4e\x76\xec\xdc\x8e\xe0\x78\x4b\x9f\x23\x05\x3c\x95\x34\xf1\x30\xa9\x7f\x5a\x20\x4d\x87\x48\x43\xc9\x15\x4b\xc8\x32\xe0\xa9\x9f\x04\x93\x0c\x53\xed\x62\x2d\x24\x8b\x29\x6e\x19\x6f\x66\xd8\xaf\x28\x17\x73\x24\xf6\x5d\xa7\x9d\xed\xe6\x0c\xfb\xb8\x81\xef\x21\x51\xef\x92\x83\xb6\xa0\xb6\xa9\xde\xb0\x9b\x2a\x07\x68\xdd\xac\xfc\x19\x8a\x1a\xb9\xd5\x12\x3d\xe5\x2c\xa8\x7b\x36\xc1\x0d\x45\xad\x1c\xd6\x48\xb8\x2c\xc6\x34\xcb\x1e\x90\x2e\xa6\x12\x41\x23\xba\xe6\x73\xa3\x48\x7c\x0b\x90\xed\x83\x69\xb5\xa1\x31\x3b\x70\x17\x41\x71\x51\xd8\xd3\x49\xca\x4d\x0d\xc1\x30\x70\x5d\x6f\x68\xae\x11\xfc\xe2\xc9\xff\xed\x79\x70\x9a\xf1\xf1\xc4\xf6\x29\x3a\xcd\x91\x2d\x3e\xff\xcd\xf8\xae\x4e\x35\xaf\xcb\x05\x10\x9f\xff\x26\x4a\xca\x29\x6e\x9a\xba\xf9\xdd\x3d\xc7\xe7\x9d\x32\xee\xbb\x6e\xee\x54\x66\x3c\xdb\x55\x1a\x44\xed\x59\x2b\x3a\xb6\x9c\x6e\xc5\xac\x5f\x5b\x2f\xbb\xf7\xe0\xda\x1e\x52\x2e\x73\x79\x10\xa5\x19\x8b\xc4\x22\xb4\x08\xa5\x06\x76\x47\x7f\x06\xf5\x47\x3c\x74\x2a\xe2\xaa\x45\x4f\x33\xa1\xa7\xba\x8f\x0d\x84\xf2\x27\x96\x39\x30\xc0\x4e\x01\x0d\x20\x0a\x93\xbb\xc4\x61\x36\x6a\xd5\x79\xd2\x85\xe2\xe8\x21\x30\x8d\x9a\x28\x72\x7b\xd7\x11\x6a\x25\x0a\xe8\x9d\x3b\x62\x69\x54\xcb\xe0\x9c\xf3\x08\xc4\x51\x37\x60\x61\x20\xce\x3e\x4d\x48\xa7\x13\xcc\xd5\x6d\xd7\x10\x3d\xf0\x01\xa1\x26\x29\x88\x23\xb8\x77\x4f\x7b\xda\xe1\xef\xfd\xfd\x7d\xb8\x4b\x5a\xe7\x5d\x7c\xe5\x9f\xff\x66\x46\x09\xcf\xa8\xb8\x0f\x02\xe3\xdc\x64\xe8\x1c\xf4\xe9\xf4\xfc\x39\x71\x23\xa2\x85\x7f\xab\xa1\x4a\xe0\xe6\x03\xdc\x71\xba\x10\xd8\xe5\x3e\x62\xf6\xde\xaa\xa9\x79\x2f\xea\x8a\xf3\x68\xc2\xd3\x54\xa0\x31\x9e\xa6\x19\xf0\x00\x0f\x5b\xe7\x1c\x1b\x43\x9c\x58\x73\xe5\xa1\x22\x7f\x17\x76\xa0\x80\x0b\x92\x4a\x61\x6f\x16\xb2\xd9\x8c\x48\x34\xd7\x2d\x04\x1d\x74\xed\xb5\xff\xc9\xf6\xe3\xee\x9b\x85\x62\x88\x63\xaf\x15\x94\x9b\xf9\x85\x51\xb6\x78\xf0\xbd\x9c\x14\x26\x16\x71\xcb\x43\x36\x3c\x2b\x2f\xaf\x98\x20\x83\x9b\x95\xbe\x7f\xdf\xaa\x82\xf3\x2d\xcf\xeb\xff\x3a\x0c\x42\x7e\x74\xc9\x93\xcb\x80\x5f\xc1\x0b\xa9\x92\x51\xa6\x45\xb1\xa8\x32\x1e\x65\x78\xfe\x52\xff\xf0\x71\xc7\xcb\xff\x38\x84\x7d\xf4\x11\xc2\x27\xc1\xcf\x8f\xde\x9c\x7e\xf8\xe5\xed\xe1\x7b\x54\x0b\x56\xd1\x23\x8e\xef\x9e\xdf\x85\xf6\x36\xbc\x3a\xfc\xfe\xf0\xcd\x0b\x09\x64\xbb\x7d\xd2\x1a\x06\x61\xc6\x13\xcb\x80\x28\x86\x5c\x70\x77\x47\xbe\xaa\x45\x71\xc4\x6b\xd2\x7f\x5d\xe0\x23\x47\x41\x83\x90\x63\xd0\x73\xbf\x40\xad\x2c\x53\x09\x8f\xef\x32\x44\x50\x29\xab\xdb\xed\x93\x46\x9d\xe4\x15\xec\x43\x1d\xa5\xb3\x18\x35\x89\x6b\x67\x9f\x3f\x35\x59\x78\x11\x6f\xb3\xb0\xca\x10\xf4\xe0\xd4\xc9\xda\x0b\x06\x52\x59\x75\x9d\xcf\x3f\x2f\x3b\x85\x80\xf1\x4a\x9b\xe4\x52\x06\x2f\x90\x6c\x04\xa3\x14\x4d\x8b\xa5\x3e\x7f\x2e\x0f\xfc\x51\xda\xae\xd1\xd0\x6e\xc9\x02\xb6\x71\x4b\x96\xb6\x2b\x41\x1f\x4b\x61\xaa\x20\xd1\x31\x8d\xf9\x23\xe6\x59\x4e\x70\x8a\x5e\xfa\x71\x54\xf3\xb6\x68\x68\xc8\xd4\xe2\xdf\x36\xd0\x04\xe2\x51\x7e\xc2\xb2\x11\xc4\x43\x08\xfc\x38\x52\x9f\x95\xa9\x85\x46\x70\x8d\xe9\x9b\xe1\x85\xf8\x4f\x3c\x04\xce\xfc\x11\x84\xb4\x06\x82\x8c\x8f\x75\x23\xf5\x2e\x8c\x2c\x03\xd7\xf0\x56\x40\xe6\xf4\x3a\x51\x56\x6a\xdb\xcf\xba\xf4\x14\x1a\x5c\xeb\xa2\x27\x73\xf9\x8d\x8a\x5d\xc4\xd0\x66\x40\xd9\xa0\xf7\xed\xfc\xd9\xce\x27\x39\x7f\xd4\x68\xc4\xc2\xe1\xfb\xe0\x77\x21\xd4\x70\x39\x4a\x27\x35\xed\x74\x10\xcc\xb2\x91\xfb\xfd\xa1\xfd\x3d\x1b\x05\xc9\xc0\xfd\xbe\x6b\x7f\xf7\x25\x2e\x02\x5b\x8d\x05\x3c\xcb\xe1\xda\xa7\xef\xbe\x83\x9d\x90\x69\x58\x4c\x32\x57\xac\xd0\x30\x88\x78\xcd\xbe\xf1\xbf\x31\xb0\x51\xe1\xcc\xdf\x62\xb9\x77\xaf\xb5\x89\xb1\xa5\x6a\x77\x01\x4c\xb9\xfd\x73\x30\xc8\x46\x7d\xb8\x6f\xa7\xfa\xa6\xb4\xdb\x24\x2a\xbc\x42\x8b\x3e\x8d\xd7\xfe\x30\xe8\x43\xed\x75\xc7\xab\xc1\x8e\x21\xf5\x0e\xd4\x46\xa2\xc0\x10\x6f\x07\x6a\xbf\x46\x60\xfd\x3b\x10\xdf\x0d\xf1\x77\xa0\xe6\x15\x4b\x3a\x5e\xd7\xeb\x62\x79\x0f\xb6\x5d\x68\x85\x0e\x5d\xf0\x3f\x88\xcf\x38\x5f\x3b\x50\x7b\x7d\x1b\x08\x2b\x22\x58\x0d\xda\x26\x16\xca\xa0\x37\x6c\xcc\x71\x59\x52\xae\xf4\x26\x2d\xa0\xa6\x58\x75\x35\x93\xbf\xbc\x51\xe2\x12\x92\xe3\x96\x84\xfb\xd9\x1f\xc7\x2d\x65\x5c\x41\xdc\xb2\x88\x27\xe4\x9a\x79\xac\x79\x42\x4d\xca\xa5\xfe\xb1\x0d\xbb\xd0\x86\xfb\xba\x46\x53\x55\xf9\xbd\xb6\x36\xed\xb6\xb6\x36\x46\x99\x55\x4c\x0b\x25\xbb\xa1\x4d\xd2\x52\xb2\xf9\xb3\x7e\x09\xcf\xf8\xf3\xb2\xd2\x34\xf8\x9d\xf7\x91\x7a\x6e\xd9\x07\x4a\xb7\x3f\x08\xd8\x98\x67\x3c\xb1\xe8\x47\x89\xf8\x35\x03\x6d\xb9\x94\xba\x2e\x6c\x0b\x2f\x12\x76\x85\x32\x3d\x15\x82\x9e\xc8\x5c\x10\xef\xa8\xa1\x48\xfa\x5c\xc3\x4b\x51\x5b\x4b\x77\xb1\x5b\xa9\x31\x3b\xfb\x90\xa8\x55\xf3\x16\x49\x7f\x51\xa3\xee\x8a\xfe\x53\x21\xeb\x7b\x52\xe6\x3b\xf2\x1d\x6d\x79\xa9\xb3\x1b\xd8\x5c\x33\x61\xf3\x30\x66\x03\xa1\x7a\xd0\x4e\x21\x0b\xec\x3a\x82\x7b\xa4\x88\x97\x95\x54\x89\x5d\x2b\x64\xf3\x78\x9a\x99\x3a\xf4\xdb\x59\x0d\x71\x32\xc6\xd0\x8c\xa6\x92\x2e\x72\x70\x16\x3a\xe4\xb7\xf1\x0c\xf6\xe1\x13\xcc\xfa\xd0\xf1\x60\x8e\xff\xbd\x22\x81\x8c\xf3\x0a\x23\x1e\x5c\x8c\x32\xfa\xa5\xde\x4d\xc9\x7d\x30\xe3\xe3\xf7\xd9\x1c\x0d\x05\xb6\x73\x58\x3a\x09\xd9\xbc\xaf\x11\x15\x22\x62\x14\x27\xc1\xef\x71\x94\xb1\xb0\x06\xcf\xa0\x16\x44\x62\x87\x69\x9e\x87\xb1\xff\xb1\x06\x7d\xa8\xd1\x5f\x66\x10\x63\x96\x5c\x04\xd1\x3b\xea\x19\xc3\x09\x81\x79\xb5\x25\x77\xcc\xcb\x0b\xdd\xb9\xe9\xd4\x05\xed\xc1\xa5\x38\xe3\xfb\x2c\x3c\x08\xd1\x7d\xa0\x36\x0e\x06\x83\x90\xd7\x3c\xb7\x87\xfb\x68\x05\x72\x96\xa8\x9c\x9f\xd6\x98\x4d\x2c\xad\x96\x47\x59\x32\xf7\x20\xb0\xa5\x9d\x31\x03\x08\xa9\x60\xb8\x42\xc6\x19\x08\x22\x16\x7e\x67\xcd\x08\x82\x30\x13\x82\xd6\x1b\x33\x3b\x76\x53\x0d\x73\xa1\x9a\x5e\x6e\xa5\xad\x37\xea\x75\x0b\x29\x67\x86\xa0\x44\x70\x65\x7c\x5c\xeb\xcb\x6b\x1e\xf9\xef\xda\x2b\xd8\x2e\x2c\x88\x1e\xd4\xac\xb6\x4d\x21\x30\x03\x19\x66\xe7\xa6\x76\x4a\x27\xa9\x79\x92\x18\xaa\xa0\xe1\xd9\x84\x6c\x34\x2c\x52\x8a\x6d\x87\x2a\x9b\x7d\x07\xb7\x81\x86\x33\x30\xe5\xc2\x3c\x0d\x43\x43\xcb\xeb\xad\x4d\xee\x4c\x36\x19\xc3\xc0\xd9\x1a\x94\x15\xb5\x6e\xa3\xe4\xec\x18\xfa\x4f\xcf\xa9\x91\x0a\x46\xee\x9b\x05\xe5\x7e\x25\xb1\x55\xa0\xb6\x55\xe7\xda\xbb\xf9\xb4\x54\x7e\x9c\x1b\xe2\xfe\x40\xa7\xb7\xc3\x4b\xa1\xe1\x1f\x0d\x9f\x8f\x82\x70\x20\x4f\x4e\x28\xef\xa4\x38\x03\xcd\xfd\x0d\x67\xd4\x9b\x21\xe6\x22\x40\xe5\x96\xf9\xb2\xdd\xcd\x01\xf8\x49\x49\x32\x2d\x47\xb5\x34\x33\x25\x52\x08\xf6\xd5\x1f\x9e\x9a\x0d\x2d\x60\xae\x5d\xa8\x92\x26\xd6\x11\x01\xe9\xd2\xb0\x2a\x7d\x19\xfa\xd4\xd2\x09\x8b\x6a\xf9\x21\x2e\xd4\x47\x04\xb3\x64\x7c\x96\xd5\xf2\x83\xc8\x89\xa5\x67\xb9\x02\xb9\xd6\xb4\x75\x51\x49\xbd\x3e\x58\x1f\xec\x01\xeb\xbf\x8d\xce\xd3\x30\x3e\xbe\xa5\x3b\xf0\xc2\xcd\x37\xbf\xef\x22\x07\xf6\x96\xde\x5e\x7b\x65\xfb\x6b\x6e\xe7\xec\x95\x6c\x9d\x2c\x94\xaf\x3b\x64\x0d\xfc\xbd\xb7\x65\x1f\x95\xee\xa8\xbe\x3e\x7f\x06\xf5\x77\xcb\x7d\xec\x0c\xe5\x92\xe8\xda\xde\x7b\x91\xde\xc5\xdd\x73\xc2\x06\x83\x20\xba\x10\xdb\x70\x6e\x33\x74\x8a\xc4\x9c\xca\x2d\xad\x7a\x9b\xa5\xc1\xa0\xe8\x18\x66\x35\xb3\x87\x6e\x4e\x17\xd5\xf8\xd4\xa6\xa1\xc5\x98\x15\x4c\x29\xa1\x48\xe6\xac\xe9\x85\x66\x91\xc2\xe2\x52\x9c\x68\x47\x13\xdb\x72\x38\x0c\xf9\xea\x84\xf6\x08\x39\x94\x32\x23\xc4\xde\xd6\xf5\x32\xd7\xcc\xc7\x77\xb5\x35\xe7\xee\x89\xde\x87\x7a\x2d\xa9\x58\xc8\x5d\xb8\xf6\x4a\xa1\xae\xbe\x0b\x3e\x11\xda\xae\xda\x61\x7d\xea\xb5\xbf\xf2\xfd\x71\x8b\xb5\xa4\x61\x42\x90\x40\x89\xa7\x5b\xc1\x21\x3f\x17\x05\x86\x74\xf1\x5b\x80\x89\x23\x7e\x34\xac\x1b\x63\x21\x0a\x35\xe2\xb6\x35\xe0\x1d\xdb\x4c\xea\x41\x4d\x29\x68\xb5\x13\x84\xcf\x42\xe9\xe6\x79\x6b\xf0\x3e\x8f\xf0\xc8\x21\xd9\xde\x83\x5a\x22\x44\xbe\x84\x9f\xd3\x07\xd7\xe8\x27\x8b\x27\x02\xf8\x79\x9c\x65\xf1\x58\xfc\x25\x55\x4b\xea\x47\x0a\x86\x5b\xf5\xc0\x92\x84\xcd\x8f\x86\x4b\x7b\x0e\x58\x4d\xf1\xfc\x57\xff\x64\x0b\xd6\xdb\x20\x10\xcd\x69\x1d\x06\xb7\x1c\x80\x6a\x9f\xad\xc7\x7b\x9b\xb1\x4d\x0b\xb9\x71\x4d\x2a\x8b\x63\x0d\xbb\x15\x62\x14\x87\x4c\xc0\xd2\x4a\xfb\xad\xe0\x88\xed\x4e\x40\x89\xa3\xd7\xf1\x34\xe5\x87\xd1\x86\x00\xbd\xe2\xec\xf2\x76\x24\x37\x80\x9e\x87\x81\xff\xf1\xd6\x30\xb6\xae\x2d\xe9\x49\x5f\xde\xca\xa3\xf1\x27\x47\xb2\x75\xef\xdb\x02\xc5\x11\x0b\x46\x10\xe8\xe5\x5c\x5c\xbb\xfa\x2c\x57\x9c\xd8\xda\xbf\xf8\xbe\x5f\x43\x4c\x32\x3e\x9e\x34\x30\x66\x03\x21\x45\xc1\xb9\x95\x4f\x85\x52\x1d\xa5\x7b\xa8\x13\x0b\x5e\x7b\x60\x61\x6c\x76\xd8\x2f\x37\xb0\x4b\x5f\x4a\xdb\xc3\x6b\xe1\xcb\xa3\x3f\xda\xc3\x6b\xb0\x7b\x3a\x59\x14\x49\x3d\x9f\x8d\x79\x79\x2f\xa8\x53\xbc\x68\x63\x51\xb5\xff\xd8\xc3\x5b\xfa\xc8\xf4\x4e\x17\x47\x7f\x47\xcf\x18\xf1\xcf\x04\x65\x48\xfc\x97\x51\xc4\x65\x8e\xf3\xfa\xc0\xb9\x79\x1a\xb4\x02\xf3\x0d\x9d\xf5\xec\x76\x47\xd3\xac\xb2\x5d\x6c\xbe\x15\xda\xbd\xcf\x58\x92\x61\xde\xf0\x42\xb3\x54\x7f\x2a\xb4\x3a\x8c\x06\xe5\x6d\xb8\xfc\x50\x68\xf1\x96\x95\xb7\x80\x7b\xf7\x60\xd0\x9a\xc8\xaf\x7b\xd0\x6e\x03\x3a\xea\xea\x98\x41\x77\x1c\x48\x81\x58\x46\xa9\x38\x22\xce\x3a\x1e\xcc\x3b\x1e\xcc\xba\x1e\xcc\xbb\x1e\xcc\x7a\x1e\xcc\x7b\x1e\xcc\x76\x3d\x98\xef\x9a\x97\xba\xb3\x6e\x07\xf6\x61\x86\x11\x2b\x44\x13\xfc\x39\x17\x3f\xe7\x5a\x13\x9d\xe1\x73\xe3\xd9\xae\xa8\x23\xc0\xe0\xcf\xb9\xf8\x39\xef\xa9\x3a\x42\xe3\xae\xcf\xf0\xa5\x6d\x7d\xde\xc1\x4f\x0d\xf1\x5f\x2a\x99\x75\xb0\x2d\xfa\xf7\xd7\xa9\x4c\x74\xdc\x04\x6a\x31\xef\x76\xec\xd0\x32\xc7\xb3\x0e\xec\x40\x46\x95\xc4\x30\xe4\xaf\x79\xb7\x73\xa2\xe2\xa9\x08\x45\x6e\x9a\x71\x98\xf0\x64\xc2\xa3\x41\xe0\x4f\x43\x96\x40\x3c\x1c\xa6\x3c\x03\x7c\xf8\x89\x96\x44\x7c\xca\x96\xf8\x2d\xd1\x64\x94\x65\x93\x7e\xbb\x2d\x98\xee\x2a\x4e\xc2\x41\xeb\x2a\x0e\x87\x09\x1b\x63\x58\xec\xe7\x41\xe2\x87\xbc\xf9\x2a\x88\xf8\x4b\x45\xc4\x20\x8e\x5a\xa3\x6c\x1c\x6e\x59\x11\x0a\x92\x88\x27\x1f\x58\x74\x21\x0e\xd1\x05\x22\x27\xe2\xff\x7d\x0f\xfc\x2b\x8b\xc0\x9d\xae\x20\x1e\x0e\xb6\xab\xa8\x35\xc7\x42\xa2\x93\x2e\x0c\x63\x41\x43\xff\x0a\x9e\x41\xe2\x43\x1f\x9a\x89\x2f\xe8\x75\xe3\x99\x5f\x2f\xa4\xe3\xbb\x21\xee\x8d\x18\x5c\x1c\x4f\xf6\xa2\xf3\x6d\x44\x61\x07\xfb\xdc\x16\xff\xd5\xe7\x56\x34\x0a\x86\x31\x95\xea\xc2\x39\xec\x43\x13\x4b\x67\xa6\x74\xd6\x95\xa3\xd8\x81\x78\xa6\x47\xd1\x95\xa3\xd8\x81\x78\x6e\x6a\x4a\x86\x72\x6b\x4a\xb6\x72\x6a\x76\x3a\xc8\x34\x5d\x0c\x9c\xd2\xed\xe0\xe3\x0f\x43\x21\xfc\x38\xc7\x8f\xf3\xdc\xc7\xc1\x0c\xbb\x20\x9a\x6a\x1c\x07\x73\xec\x83\x88\x6a\x4a\x05\xb3\x0e\x66\xb0\x2d\xfe\xb3\x23\x2a\x6d\xc3\x40\xe3\x90\xc0\x3e\x24\x82\xdb\x13\x5f\x15\xbd\x40\xd8\x5d\xe2\x37\xec\xa1\x83\x7f\x1b\x88\x02\xb1\xc1\x5c\xc5\x03\xea\x42\x9f\xc2\x82\xaf\x33\x51\xab\xb4\x1d\x61\xdb\x31\x9b\x51\xd3\x8e\x07\x09\x6c\xe3\xff\x0f\x7a\xd0\x84\x17\xb0\x0d\x2f\x8c\xf1\xc6\x9f\x21\x21\x5f\xe0\xb0\xa1\x29\x49\x21\xc8\x39\xd0\xf4\xf4\xe7\x58\xa7\xf9\x82\xa8\xd4\x94\x54\xca\x55\x9a\x75\x2d\x40\x3b\x15\x80\xba\x36\xa0\x9d\x52\x40\x03\xc4\xc8\xa7\x25\xd1\xe9\x98\xe9\xc3\x62\x5a\x14\x56\x31\x76\xeb\x4b\x09\x65\xd5\xc6\x62\x29\xa9\x3a\x78\x40\x6c\xb7\xe1\x6d\xe0\x7f\xc4\xeb\x65\x3f\x8c\x53\x9e\xa8\x48\xb6\xd9\x55\x6c\x64\xa3\x58\xc8\x93\x38\x88\xb2\x54\x7a\x98\x7f\x38\x7a\x71\x04\x2f\xd1\x35\x3d\xe1\xc0\x60\xc8\xd2\x8c\x27\x70\xc5\xe6\x90\xc5\x30\xe0\x19\x4f\xc6\x42\xa2\xd0\x83\x04\x07\x4e\x16\xc3\x34\xe5\xcf\xe4\x0b\x7f\x31\xb2\x6d\x1c\xdf\x0e\x0e\x67\x1b\xff\xfb\x14\xc7\xb0\x8d\xff\xdd\x41\xc4\x45\x79\xb7\x21\xa7\xc6\x17\xd2\xc3\x97\x83\xef\xda\x27\x5d\x19\x54\x6d\xd6\x17\x35\x65\x5c\xd3\x79\x5f\xd4\xa5\x1f\xb3\x4e\xb7\x0f\x4d\xb5\xca\xe6\xf4\x4b\xb2\xf6\xac\xdb\xc5\x66\x42\xfa\x26\x5d\x68\x43\x82\x2f\xa7\x64\x55\xfc\x38\xcf\x7f\xb4\xd2\x71\x00\xbd\x99\x5f\xa0\x42\xe1\xe6\x4e\xb5\xf4\xe6\x2d\x6b\x9d\xea\x77\x38\x75\x3b\x71\x8e\x8a\xae\x69\xb6\x69\xf4\x14\xb5\xf7\x74\x2d\x84\xcc\x96\x4c\x75\xac\xfd\x5b\xf3\x1a\xca\x62\x5d\xe9\xc6\x15\xe4\xe8\x32\xa5\x1e\x24\x1d\xbd\x68\x26\x6c\xa0\x01\x47\xd3\x30\x54\xe5\x66\xcf\x27\xb4\x8c\x7a\xa0\x6a\xa8\x1d\x9e\xbe\x2b\x45\xc0\x82\x6b\x7d\x55\x9b\xbe\x19\x11\x45\xfd\xdb\x97\x06\x25\xdb\xdd\x84\x25\x7e\xdd\x7e\xdd\x75\x3e\x1d\x0e\xb9\x75\xa1\x67\xff\x29\x58\x69\xc7\x22\x73\x85\x93\x87\xd5\x42\xac\xa5\x1d\x8b\xe8\x37\xb6\x60\xa2\x0f\x43\x8d\x8a\xfa\xd0\x5c\x46\xff\x3b\xbe\x7b\x81\x73\x31\x62\xe1\xf0\x6d\xe0\x1a\x78\x59\x17\x2f\x53\x06\x5f\xb6\x97\x01\x5b\x86\x81\x2c\x50\xc4\x3c\xec\x3c\x25\xc6\x61\x42\x0a\xb1\x8e\x45\x1f\xff\x4a\x4c\x71\x17\x9e\x02\xeb\x48\x5b\x1c\x9a\x15\xe5\x14\x37\xac\xb9\xa6\x99\x5c\x06\x01\x4b\xcf\x57\x28\xa0\x17\x0d\xe2\xa0\xee\x51\xda\x6d\x38\x8c\xd2\x69\x22\x9f\xd6\xe0\x73\x1b\x31\xb1\x90\x10\x43\x07\x29\xb0\xf0\x8a\xcd\x53\x8c\xb5\x80\xce\x38\x2c\xc2\x6a\xc8\x31\xb2\x5a\x4b\xa3\x9c\x74\xe1\x1b\x48\x3a\x0d\xb9\x55\x7a\xc4\x2c\x89\xd8\x75\x04\x0f\x24\xa6\xdb\x97\x29\x04\x19\x30\x92\xad\xcf\xcc\x98\x05\x88\xa7\xcb\x4d\x11\x5d\x54\xf0\x49\x1a\x84\x71\x84\xe3\xd2\x94\x6a\x8d\xe3\x4b\xfe\x21\x16\xdb\x5d\xc7\x1a\xeb\x11\x86\x7b\xc7\x7e\x7d\x54\xe1\xd0\x1f\x31\x8a\xa6\xe1\x34\x25\x1c\x2c\x87\x86\x65\xd1\x18\x23\x1a\x19\x9b\x0a\x14\x96\x65\xaf\x22\xee\xda\xe2\x9b\x1b\x42\xd2\x5d\x51\x5b\xe0\x08\xda\x8f\x15\xbb\x75\x1a\x38\x0d\xab\x01\xf9\x48\x2a\x47\x10\x69\x20\xda\x8a\xaf\xf0\x13\x42\x46\xd0\x97\x34\x59\xd6\xf1\x80\x75\x3d\xb8\xe3\x5f\x39\xb1\x49\x92\xce\xed\xa7\xd3\x32\x82\xe7\x89\xd2\x59\x93\x28\xdd\x06\xb2\xe4\x7a\x44\xe9\x1a\xa2\x94\x92\x45\x92\x44\x90\xc6\xa2\xca\xb5\xb4\x55\x57\x30\x25\x1d\x4d\x24\x5b\xb2\x04\x84\xf2\x10\x27\x16\x77\xda\x97\x20\x0c\x8f\x06\xac\xe3\x5c\x58\xa0\xa2\xcd\xba\x4e\x19\x2a\xc8\xf9\x7a\x9d\x42\xbd\x01\x8a\xea\x01\x73\xcb\xba\x85\x32\x36\x81\x7d\xbd\x3f\x55\x49\x5a\x4b\x07\xc7\x7d\x43\xb4\xa9\xb3\xc9\x1a\xfc\x70\xef\x1e\xd4\xcd\x6e\xfb\x0c\x76\xf4\x8f\x2a\x1c\xfa\x6b\x29\xda\xc8\x21\x89\x50\xd0\x70\x01\x25\x5d\xf7\x9a\x33\xf1\x57\xdc\x09\x02\x52\xc6\x15\x03\xad\xb1\x89\xd0\x31\x44\x1e\x74\x60\xc7\x56\x6f\xaa\xbc\x34\x5d\xcc\x51\x1c\xfb\x6e\x59\xb7\x50\x96\x39\x1c\x93\x75\xf5\x4d\x51\xbb\x0d\x07\xa2\x1b\x75\x3b\xf5\x0c\x2d\x0d\xb4\x8b\xd0\x23\xd9\xa4\x0b\xff\xf5\x7f\xfd\x3f\xb8\x08\x04\x07\x89\xbf\x07\xac\xd3\xb2\x45\xc3\x3a\xac\xe0\x3a\x5b\x4c\x3a\x2b\xce\x84\x4f\xe4\xd4\x6b\x39\x99\x08\xc5\x76\x5d\x81\x30\x71\xa9\x0c\x30\xe9\x6e\x04\xaf\x75\xa5\xf7\xc4\x16\x54\x82\xf4\x75\xb1\xd0\x9b\xfb\x82\x6e\xdb\xd0\x6b\xac\x31\x0f\x02\x82\x32\x44\x88\xc3\x6d\x53\x48\x56\x21\x6e\x76\x04\x74\x0f\xa5\x0c\x76\x64\x10\x40\x29\x46\x92\xa6\xe3\x29\xd1\x84\xc2\xa8\xce\xc4\x5a\x63\xdd\x86\xed\x0b\xab\x31\xee\x22\xa0\xee\xda\x18\x77\x4b\x31\xee\x22\xc6\x42\x5c\x77\x65\x47\x05\x8c\xbb\x0a\x63\x12\xb0\xdd\x2a\x8c\x9d\x5b\x5d\x32\xe9\xac\xbf\x8b\x77\x1d\xd6\x9a\xdf\x0e\x6a\x61\x5b\x77\xa1\x92\x39\x66\xfd\xcd\xb5\xe3\xe2\x7a\x3b\xa8\x85\xdd\xb6\xd3\x28\x8a\x1f\x0c\xee\xc7\x07\xf2\x7c\x27\x95\x38\x29\x5e\xfc\x8d\x89\x17\x32\x68\xad\x3d\x87\xdd\x6e\x4e\x3c\xcc\x6f\x07\xb7\x40\x99\x3c\x5c\x32\x96\xad\x3d\x8f\x9d\x4e\x1e\xdf\xdb\xc1\x2d\x70\x5d\xc7\xf6\xe3\x6a\xb7\xe1\x1d\xa7\x1b\x0d\x32\xc6\xe0\x54\xaa\x13\x08\xf3\xfd\x38\x11\x3b\x0c\x64\xb1\xca\x11\x94\xa1\x7a\x24\x34\x0f\x47\x44\x0c\x18\x7c\xb3\xdc\x84\xff\x46\xc7\xa1\x20\x3f\xd7\x34\xdb\xb1\x8f\xfa\xce\xed\x15\x57\x74\xb2\x37\xb6\xf5\xae\x87\x26\x53\x34\x48\xa1\xb1\x0a\xed\x90\x68\x24\x94\x36\xeb\x6e\x47\x68\x2a\xc7\xea\x47\xce\x67\x09\x80\xa1\x09\xb3\x23\xf6\xfc\xd8\x3f\x2e\xf9\x8e\xc6\x4c\xf5\xbd\x5b\xf8\x7e\x3e\x93\x66\xca\x8a\xf6\xe7\x64\x0c\xad\x6c\xff\x51\x50\xa4\xbb\xa2\x79\x39\x37\xeb\xab\x34\xa5\x5b\x5b\xa6\x39\xb1\xce\x66\xb0\x2d\x46\xb1\x23\x86\xba\x0d\xe7\x73\xbc\x1b\x58\x47\xb5\x43\x88\x4c\x43\x64\xf3\x75\x8d\xb2\xe7\x1a\xc5\x73\x89\x22\x05\x28\x6a\xe4\x89\x19\xae\xaa\x35\xe6\x7b\xc2\x29\x84\x6d\x9a\x4a\xd8\xa1\x29\xa3\xdf\xdd\x13\x6b\xa3\x57\x6a\xde\x1a\x1a\x6a\xe2\x7b\x78\x84\x6b\x42\x88\xd7\x0b\xf5\x8f\x3e\xc5\x54\xda\x2b\x28\x8e\x6b\xf7\xd2\x75\x7a\xd9\x71\x7b\xb9\xce\x6f\xad\x64\x42\xb0\x04\x82\x1f\x87\x21\x9b\xa4\x7c\x80\xd1\x3d\xf0\x56\xc7\xde\x0d\xee\xa0\x02\xb1\x39\xcb\x82\x5a\xd6\xce\x9e\xf4\x22\xe6\x36\x4e\xff\xf5\x9f\xff\x3b\x55\xf6\x14\x21\xc1\x46\xec\x92\x57\xed\x58\xda\xf0\x20\xa8\xb9\x89\x7d\x2b\x43\x1b\x71\xfe\x0a\x4a\x4b\x20\x2d\x95\xe8\x1a\xaa\xeb\x1c\x51\x85\xaa\x5f\xd2\xba\x20\xb5\xf2\xad\xab\x8e\xeb\x59\xa7\xe5\x8b\x95\x91\x75\x5a\xd8\xb1\xf8\x3d\xa7\xdf\x0e\x09\x91\x88\x3f\x08\x2a\x99\x8d\x20\x85\x31\x4f\x2e\xf8\xe0\x99\x23\xeb\x05\x95\xbe\x81\xc4\x6f\x38\xe7\x6e\xec\x47\x82\x97\x78\xad\xc2\x96\x03\x12\x3b\x19\x8b\x7a\xc4\x98\x84\x9f\x27\xf1\x6e\xac\x0b\xad\x2b\xa1\x75\x25\xb4\x3b\x2e\xd1\xda\x6d\x38\xca\x46\x3c\xb9\x0a\x52\xee\xc1\x20\x61\x57\xfa\x3a\x42\x91\x42\x25\xca\xc3\xcc\x3f\xae\x7a\x6a\xef\x62\xff\x8d\x68\xd2\x69\x21\x47\x09\x68\x5d\x43\x93\xf2\xa1\x18\x6b\xd3\xba\x7d\x6a\xee\x93\x7d\x6b\xee\xec\x6e\x62\x96\x09\x7a\x57\x42\xef\x4a\xe8\xdd\x25\x46\x88\x95\xa9\xcd\x66\x26\xcb\x20\xb1\x99\xa1\x95\x31\xf0\x22\x19\x4d\xc6\x2d\xcb\xae\x2c\xe4\xe0\x6f\xd3\xd4\xb1\x76\xb1\xc4\x77\xc4\x60\x95\xa8\xf5\x2a\x6d\x8f\x74\x6c\xcb\xad\x28\xbd\x45\x24\x1c\xa2\x58\x59\xac\x83\xe8\xc2\xa3\x70\x63\x19\xca\x67\x0b\x0f\xdb\xd4\xa6\xb0\x9f\xf0\x64\xc4\x26\xa9\xae\x1d\xe5\x0c\x73\xd6\xbe\x33\xa0\x20\x5f\xca\x22\xe2\x6c\x3e\x6b\x99\x41\x3f\x7f\x86\x3b\xf5\x75\x14\x52\x6b\xfb\x12\xfb\xa2\xa0\xa9\xd2\x3b\x6f\xda\xbe\x0c\xd5\xa0\x1e\x27\x64\xae\x6f\x2c\xbb\x93\x6d\xc6\xf6\x5b\xba\x93\xe9\x1d\xc8\xec\x4a\x49\xc7\x83\x66\xe2\x77\x96\xd9\xca\x4a\x94\xf2\x5c\xf3\xc2\x5e\x26\x29\xf7\x25\xf6\xb2\xce\x12\x7b\x59\xe7\xeb\x92\xdb\x5f\xc5\x5e\xf6\x95\xd1\xe4\x16\x7b\xd9\x06\x46\xf0\x67\xee\x65\x2b\x6c\x65\x6b\x8f\xf4\xeb\xd9\xca\x2c\x99\xb8\xec\x56\x96\xbf\x15\x22\xc3\xa7\x45\x40\xd9\x93\xaa\x8f\x1e\x29\x6f\x59\x36\xd2\x57\xb5\x42\x52\xd0\xed\xaf\x4e\xfc\xe0\xba\x00\x78\xea\x72\x78\x07\xee\x62\xf4\x18\xf5\xd0\x04\x41\xb3\xc4\x6f\xf9\x3c\xca\x92\x18\x13\x26\xe6\x5c\x2d\xc8\xf0\x91\xc0\x3e\xd4\x97\xf0\x05\x80\x9d\x65\xee\xff\x73\x17\x40\x98\x45\x63\xe7\x66\x2f\x80\x1d\xd8\xb9\xe1\x0a\x1f\x01\x2f\x7b\xd1\x6a\x9b\x7a\x8c\x8d\x56\xf9\x0e\xae\x63\x1d\x6b\xc0\x36\x24\xab\xb1\x61\xde\x10\x86\x20\x4e\x64\x5a\x3f\x39\x49\xae\xc7\x8b\x9e\xa7\xd3\x5c\x50\xd9\x7c\x68\x35\x78\x06\x75\xb7\xa9\x8c\xa9\x73\x9a\x8b\x1c\x04\xcf\xe0\x74\x99\x6b\xb1\x9b\x3d\x60\x76\x4e\x1b\x62\x5a\xfc\x06\xf4\xc1\x71\xa7\xb5\x87\xe3\x3a\xe7\xac\x34\x1c\xb7\xe9\x1f\x3a\x1c\xc7\xcb\xd7\x1e\x4e\xce\x8f\x68\xa5\xf1\xe4\xda\xfe\xa1\x03\xb2\xfb\x76\x47\x64\x7b\x2f\xad\x34\x1c\xbb\xa1\x18\x04\x05\x78\x7a\x46\xff\xd3\xff\x63\x87\xa7\x71\x71\xc7\xe6\x78\x60\xad\x34\x38\xa7\xe5\x1f\x3a\x14\xdb\x53\xdc\x1e\x8b\xe5\x2b\xb6\xd2\x48\xac\x76\x7f\xe8\x38\x8c\xf7\x7a\x8e\xdb\x6e\x35\x0a\xab\xdd\x1f\xcd\x58\x25\xa3\x30\x1b\xef\x4a\x83\xa8\x9b\x76\x25\x0b\xc6\x59\xad\x58\xcf\x74\xaa\x81\xfa\xa5\x49\x9e\x1f\x75\x17\x26\x1a\x59\xe3\x81\x09\x5e\xae\x07\x2a\xd6\xfc\xdb\x97\xf2\x11\x17\x9b\xc2\x3e\xc6\xad\x99\x04\x54\xa2\x8e\x6e\xfb\xd0\xe5\xcd\x87\xba\xd6\xa1\x2e\x16\x4d\x9a\xaa\x9a\x1d\x0c\x91\x94\x1c\x8a\xa7\x3e\x0a\xd2\xd6\x29\xfa\xb9\xd2\x9f\xe8\xe7\xda\x6e\xd3\x9a\x80\x78\x08\xfe\x34\x49\x78\x94\x41\x3a\x3d\x9f\xb0\x6c\x64\xda\x74\x4d\x9b\xae\x72\x89\xc4\x24\x4f\xd1\x60\x51\x3b\xd8\x87\xbb\x77\xdd\xf7\x15\x13\x83\x8f\x7a\xb0\xcb\xaf\x10\x4b\xac\xf7\x16\x13\xb8\x59\xf1\xe8\x26\xf9\x02\xf9\xe6\xd3\x04\x9c\x13\x4d\x04\x45\xc8\x9c\x61\xde\x35\x3b\xb9\x70\x24\x3e\x3b\xfb\x70\xf7\xf5\x5d\xd8\x81\x7a\x81\x18\x38\x46\xca\x6b\x78\xd7\xb3\xaa\xcc\x3b\xee\xd8\x77\x28\x61\x3c\xbe\x9b\xd5\x6a\x64\xbf\xa8\xf1\x51\xea\x66\x09\xd9\x8a\xee\x27\x35\xb6\x02\x61\x67\x1d\xcf\xee\x46\x75\xbe\xe7\xd4\xc7\x01\xfc\xc7\x5d\xfb\x9d\xf7\x16\x00\x1d\x9d\x6f\x1e\xf9\x2b\x7b\xe4\x55\xc3\xcd\x8f\xf1\x9f\x53\x36\x48\x58\x16\xf8\xcf\xa7\x49\x9e\xc0\xea\x3d\x4b\x79\x77\xff\x0b\xc1\xee\xcc\xba\x56\x27\x3b\xf3\x6e\xa1\xcb\xa5\x51\x39\xe7\xbf\x07\x3c\x59\x80\x87\x7a\x57\x53\x8e\xcf\xf3\x1b\xf1\xd9\x99\xf5\x9c\x6f\xbd\xdb\xe3\xca\x12\x7f\x21\x8e\x89\x42\x50\x42\xc4\xcf\x08\x03\x2b\x61\x19\x56\xc5\x32\xd1\x40\xfc\x91\x58\xe9\x99\x6c\xd6\x35\xe7\x00\x87\x5d\x4d\xf1\xac\x87\x6f\x46\x7a\xce\xcb\x17\x80\x39\x16\xcf\x7b\xce\xdb\x17\x28\x7f\x27\x53\xf1\x52\x06\x20\xec\x74\x4f\x7b\xf2\x06\xb5\xf0\xc0\xc5\x71\x49\x45\x7b\x04\x29\x35\x11\xbf\xc0\xac\xfe\xcf\x00\xe3\x5b\x5a\x3e\xae\x98\x11\xd8\x8a\x81\x29\xe3\x5f\xaa\x06\x12\x40\x1f\x03\x5b\x26\x8d\x1c\xfc\x20\x25\x37\x5c\x3e\x9e\x64\xf3\x67\xf0\x3a\xbe\x44\xa3\xa1\x20\xff\xbc\xdb\x68\x15\x57\xe6\x7e\xc5\xca\x2c\x8a\x0a\x24\x49\x91\x7b\x71\xd6\xe6\xdd\x5c\x3c\x25\x71\x9e\xf5\xc4\x81\x56\xf6\x0c\x7e\x1c\x44\x7e\x30\x10\x52\x12\xc3\xe1\xd7\x67\x1d\x6f\xde\x69\x3c\x83\x17\x31\x44\x71\x36\xd2\x56\x1a\x6d\xdf\xbb\x53\x27\xc2\x3e\x55\x62\xbd\xd1\x80\x4f\x2e\x7c\x96\x70\x05\xc8\xd3\x3d\xb1\x68\x00\xf5\x59\xcf\x13\xdc\xeb\xc7\xa1\x10\x0e\x4c\x5a\x5d\xdb\x6d\x38\xfc\xe7\x34\xb8\x64\x21\x8f\xb2\x70\x7e\x03\x82\x08\xe2\x59\x6e\x3c\xd6\x14\xfe\xce\x93\xf8\x19\xbc\x0a\xa2\x22\x89\xad\x41\xe8\xc4\x33\xc4\x12\x82\x11\x9b\xc8\x77\xc8\x2a\x0d\x6b\x78\x68\x88\x4d\x4a\x27\xa2\x20\xb9\x56\x99\x88\x9c\xa1\x8c\xe1\x46\x7f\x67\xab\x60\x0e\xc3\x55\xd5\xeb\xe8\x75\xe2\x38\xe7\xcd\xf1\x03\xad\x14\xe7\x43\xd8\x93\xdc\xdf\x53\xc3\xdb\x91\xc3\x9b\xf7\xba\x6e\xc5\x8e\xac\xd8\xc1\x8a\x1d\xac\x88\xef\x99\x7a\x79\x88\x4a\x23\xc0\xb4\x7b\xd8\x83\x73\xcf\x1d\x76\x72\x35\x3a\x85\x1a\xb0\x8f\xaf\x90\x54\x9e\x9c\x7a\x7d\x12\xa8\x0c\xc7\xcc\x8f\xd3\x3a\x41\x85\x1d\xb9\x7a\x9b\x84\x1e\x5e\x0f\x0b\xc5\x23\xc4\x11\x84\x9d\x6e\xd9\x35\x7b\x86\xdd\x87\xd0\x16\x15\x9c\x0f\x3d\xfd\xa1\xe7\x38\x33\xbe\xa4\xa7\x3f\xa4\x68\x64\x64\x26\x56\x99\x26\x2a\x56\x86\x47\x2f\x07\xb3\xd8\xf6\x69\xd4\xcc\x94\xa1\x37\x86\xcb\x3e\x96\x49\x3b\xcf\x39\xf8\xda\x27\xeb\x68\xa6\xd3\xac\x33\x37\x1f\xc8\xbc\x4c\x00\xb4\x61\xca\x82\x74\x80\x02\x47\x37\xa5\xbf\x3a\x5e\x47\x6e\x16\x9a\xbf\x3b\xf0\x54\x8a\xc2\x79\xaf\xd3\x28\xdf\x41\x08\x1f\xc5\x31\x55\xac\xac\xeb\xcc\x7b\xdd\x46\x6e\xcf\x67\x89\x9f\xdb\xf0\x3d\x48\x8c\x9f\xb8\xaf\x9e\x3d\x02\x50\xc6\x21\x0f\xe6\xb8\x93\x14\x37\x12\x7c\xc0\xa7\x79\x45\xf0\x86\xf3\x7a\x02\x5f\xf2\xe9\xcf\x69\x10\xb9\x9f\x71\x1b\xc2\xd7\x65\xb3\xdc\x26\x84\xef\xd2\xe6\xb9\x67\x18\x5d\xf8\x3f\x04\x6e\xb9\xe7\x1e\x3e\x7a\x0b\x32\xb1\xb1\xb0\x2e\xf4\x41\xbe\xe1\xf8\x5a\xf6\x0e\xe4\xc7\x5b\xed\x1d\xf8\xfa\x8c\xa6\x56\xa9\x72\x25\x3b\x04\xc2\x2f\x5d\x0b\x18\x9c\x35\xe1\x97\x41\x3c\x4d\xe5\x5b\x0e\x4b\xe0\x5a\x78\x69\x81\x6b\x56\x88\xc2\x52\x48\x32\x6b\x9d\x08\x29\x9b\xab\x24\x1f\xee\x95\x2e\xa6\xfc\x52\x5a\x38\x22\x45\x46\x96\xf8\x8a\x8a\x3f\xf3\xff\xfa\xcf\xff\x9d\x70\x18\xc4\x11\x37\x24\xbc\xa3\xad\xac\x66\x0e\xf4\xf5\x18\xfa\x9e\xc1\x05\xf9\xa3\x51\x06\xce\x2b\x36\x7f\x06\xdf\x85\xc1\x04\xcb\x06\x41\x22\x5f\x04\x6b\x80\xe8\x9c\xd6\x69\x10\x3b\x0d\x18\xfc\x1d\x4f\x44\x3b\xe2\xbf\xc5\x59\x66\xe0\xc7\xe3\x49\xc8\x33\x2e\xdf\xa9\x3c\xa3\xa8\x87\xd9\x55\x2c\x50\x4f\x31\x97\x90\xaa\x81\xd7\x4b\x58\xcb\xe9\xed\xa9\x75\xfe\x2a\xa5\x56\x85\xb8\xe8\xe2\x2f\xff\xca\x2c\x79\x7c\xe3\x69\x6b\x94\xf8\x32\x74\x8e\x05\x4b\x03\xb1\x65\x4b\xa7\x42\x9e\x74\x0a\x5b\xa3\x3d\x5f\x51\x1c\x35\xe5\x9c\xbd\x28\xdd\x26\xf5\xc0\x17\xf1\x48\x05\xc2\x52\x44\x8a\xe6\xfb\x30\x09\x2c\xa9\x58\x35\x08\x6c\x6c\xcb\xa4\x6e\x51\x94\xd2\xb0\xec\x9a\x28\x9e\xb4\x67\x93\x16\x96\x82\x5d\x0a\xd2\xf2\xca\x83\xd1\x17\x39\x1e\x8a\x2a\x23\x1a\xf1\x15\xfe\xb8\xa4\x1f\x23\xeb\x4b\x93\xbe\xd0\x51\x0e\x71\x54\xd9\x94\x4a\x8e\x92\x2a\x9e\x37\xf6\x22\x33\x99\xad\x13\x55\x43\x48\xb9\x32\x2b\xc7\xc2\xa4\xa2\x7f\x74\x18\x8d\x2f\x17\xec\xa2\x7b\x7a\x3a\xe0\xa9\xcf\xa3\x41\x10\x5d\x54\x42\x7f\x74\xdb\xa4\x36\xbd\xd3\x53\x94\xe0\x41\x36\x5f\x00\xfc\x96\xb8\xef\x2e\x1b\xa8\xe3\xcb\xbe\x1b\xa6\x7c\x5c\x8b\x83\x64\x5a\x54\x58\x10\x37\x30\x8d\x93\xec\x27\xcc\x0f\xb7\x10\x5c\x6e\xce\x6e\x00\xb8\xe8\xa5\xf0\x12\x2f\x3b\x97\x7f\x9b\x6c\x59\x7f\x37\x00\x77\x89\x69\xcf\xbd\x87\x6c\x94\x3c\x66\xde\xc8\x00\xdd\x07\xcf\x93\x80\x3b\x51\xd9\xf1\xe9\xb8\xd1\xe1\x22\x15\x06\x9d\x6c\xb1\xe6\xc3\x6f\xe6\xcf\x8f\xe6\x4f\x99\xee\xdd\x14\x04\xd1\x80\x0b\x25\x54\x68\x6c\x07\x49\xc2\xe6\xf5\xc8\x7e\xde\x2c\x76\xe4\xca\x8f\xf8\xbe\xfa\xc6\x6b\xcf\x9c\xbe\x89\x7b\xc5\x38\x58\x94\x41\xab\x8a\xe2\x9e\x6c\xcc\x66\xf5\xe6\x6d\x5a\xdf\xfc\x7e\x9a\x75\xec\x67\x4e\xf6\x03\xc2\x89\x8d\xba\xd6\xe1\x06\x4c\x9c\xd0\x22\xef\xa6\x07\x83\x16\xd0\x89\x20\xc2\x04\xb6\x95\xde\x64\x42\x67\x98\x3a\x97\x52\x6f\xc2\xec\x4a\x56\x66\xa5\x68\x0f\x76\x76\xac\x70\xbc\xf8\x7a\x88\xb2\xd3\xfb\xe9\x31\x4e\xe5\x71\x20\xb6\x19\xfc\x0f\xe5\xeb\x43\xe6\x39\x0e\x4e\x3c\x08\x3c\xe4\x94\x46\x23\x9f\xe1\x5e\x26\xaa\xbf\xac\x7c\xc6\x29\x63\xec\x84\x73\x5a\xe1\xa8\x28\x0a\xce\x38\x9f\x6b\x0d\x39\x9c\x37\x7d\x0a\x45\x33\x90\x39\x27\x21\x4e\x44\x05\x64\x4e\xad\xbd\x59\x22\xe7\x8e\x52\xe0\x11\xef\x96\xf8\x62\xc4\x5d\xe0\x01\xa6\x06\x92\xdb\xaf\x69\x56\xa7\xa1\x9e\x78\x34\xe6\xdf\x4e\x1a\x7b\x3a\xf8\xa6\x56\x95\x10\xcb\x55\xe1\x1b\x42\xe1\x1f\x1a\xb2\xa2\x82\x8a\xb4\xa3\x46\x7f\x07\x3e\x8c\xf8\x1c\xed\x40\x69\x16\x27\x7c\x00\x01\xbd\x1f\x8f\x93\xe0\x22\x88\x58\x88\x70\x6a\x82\x0e\x03\x2e\x0f\x4a\x66\x42\x3d\xf8\x88\x69\x4f\xc6\xf0\x0c\x39\xa1\x09\x11\x6c\xc3\x04\xf9\x49\x94\xf6\xdd\x39\xf7\x68\xb5\xb1\xae\x99\xb7\xdf\xc4\x3c\xcb\x29\xf7\x40\x73\xc1\x6f\x82\x34\xf4\x74\x56\x28\x3b\x97\x32\x3f\xeb\x25\x6c\xc3\x47\x01\x55\xe8\x3e\x13\xa6\xc9\xe7\x46\xb3\x66\x19\xeb\xab\xe1\xe7\x64\x44\xdf\x96\x3a\x2a\x1f\x93\x25\x58\xb4\x18\xe8\x3b\x8f\x71\xd5\x9a\xeb\xbb\xab\x89\xa9\xd2\x89\xe2\x39\x47\x3f\x36\x97\x42\xa9\x76\xf3\x98\x04\xbc\xa5\xf6\xbe\x95\xee\xa6\x54\xa3\x35\x6f\xd7\x6e\x16\xdd\x78\xbb\x36\x09\x78\x03\x64\xaa\x2a\x73\xcb\x25\x90\x77\xb6\xdb\xd5\xae\x6c\x9d\x8d\xda\x73\xf6\x59\xd5\xa1\xa9\x53\xec\xf5\x36\xfd\x99\x9e\x74\xcf\x85\xfe\x72\x3d\x7d\x15\x57\xd2\xab\x4d\x53\xd9\x95\xb4\x18\xcb\x9f\x7f\x25\xbd\xda\x38\x8a\x57\xd2\x62\x14\x7f\xfe\x95\xf4\x6a\xa3\x28\x5e\x49\xab\xf8\xf4\x01\xaf\xb8\x1d\x7e\xf0\xe5\xcf\x4d\xab\x1d\xf0\x34\x12\xcc\x83\x73\xe7\xb2\xf5\x1c\xbe\x01\xa6\xb6\xfb\x73\x78\x8a\x3f\xe4\xdf\xfb\xf8\xa3\x03\x7d\xc0\x3c\xba\xa5\x43\x7d\xf8\xd5\x0e\x35\x17\xac\xaf\x02\xff\x47\x5f\xd7\x11\x77\x9a\x5c\xf2\xd3\x84\x0d\x02\x16\x56\x1e\xe9\x76\xbb\xb7\x0f\x18\xc9\x12\xce\x16\x00\xbe\x7d\xb4\xc8\x30\x88\xf8\xbb\x9b\xf0\x56\x67\xd1\x2f\x7a\x14\x5d\x2a\x5c\x90\x26\x45\xe9\xf2\x6f\xb4\x70\x22\x6e\x10\x21\xce\x5c\x29\x38\x58\x4a\x84\x78\x85\x17\x6d\xce\xa9\xcc\x17\x2a\x10\x01\x37\x81\xf6\xb0\x4c\xd0\xef\x1f\x26\xa8\x63\xd7\x14\x5a\x71\x09\x75\xe1\x2f\x1d\x13\xbc\xcf\x14\xd2\x0d\x0b\x6b\x31\x15\xc5\xaa\x35\xf3\x60\xc0\xd1\x6a\xc9\x5a\xb3\x3d\xfc\xe8\x46\xc9\x6a\xcd\x3a\x76\x95\x0e\xd5\xb1\xe3\x64\xb5\x66\x5d\xbb\x46\x97\x6a\x24\x3a\xfc\x57\x6b\x6e\x7d\x9e\xd3\xd7\x5c\x14\xb1\xd6\xdc\xee\x64\x2e\x3b\xc9\x85\x11\x6b\xcd\xed\x7e\xe6\xb2\x1f\x31\xae\xf7\xa5\x5b\xb8\xa5\x28\x2f\xe3\x12\x6a\xf3\xa7\x9a\x2b\x53\xa6\x02\x32\xd6\x1b\x42\xbf\xb6\xf0\xa0\x69\x31\xb8\x1c\x96\x6c\xc1\x5f\x02\x93\x6e\x39\x26\x16\x55\x5e\x96\xfb\xad\x7e\x01\x64\xe6\xe5\x64\xf9\xc5\x22\xcb\x51\xb9\xd7\xe9\x97\x40\xa6\x9c\x32\x9a\xf7\x71\x6d\xad\xa8\x5a\xf8\x37\xbf\x6c\x2e\x59\xef\xe7\x25\xf6\x9a\x06\x7a\x93\xd5\x1b\x2d\xaa\x5d\x74\x28\xab\xd8\x85\x1e\x7f\xb9\x5d\x28\x27\x68\xa5\xe8\x0c\x83\xe8\xe3\x0f\x3a\xdc\x33\xf5\xbe\xa0\xea\x4f\x32\xee\xf3\x8d\x15\xf5\x54\x7d\x75\xa1\x92\x31\xa4\x7b\xf5\xde\xd4\xbb\x65\x2a\xfa\xde\x17\xb4\x4b\xef\x9e\x9e\xe2\x15\x5f\x75\x56\x79\xbc\xa1\xbe\x5d\x9e\x75\x84\x7c\xe3\x8e\xfd\x44\x59\x8f\x8d\xc3\x9e\x98\xe6\xf7\x98\xd3\xbb\x18\x75\x19\x8b\x5d\xff\x3e\x51\xfd\x03\xe6\xa9\x2e\x54\x97\xf9\xbf\x0b\xd5\xeb\xb8\x78\xcc\x8e\xae\x33\x97\x9b\xae\x75\x64\x63\x04\x21\x3f\x51\x37\x7a\x0f\x5d\x68\x3f\x36\xb4\x55\x92\x66\x66\x1b\x8d\xe7\x4b\x37\x26\x31\x30\xb7\x1b\x2f\x0a\x15\x89\xe3\x2b\x89\x15\x29\xe4\xd2\xe5\x4d\x16\x6f\xc9\xc3\x0a\xe3\x34\x0c\x7c\x8e\xb9\x5f\x31\x0d\xbb\x65\xdd\x84\x54\x27\x5e\xcf\x1b\xff\x2e\x1b\x1e\xc6\x83\x26\xca\x15\xbf\xee\x99\x3b\xd9\x2f\x1a\x0f\x11\x09\x85\x5a\x96\x84\xee\xc1\xce\xcc\x41\x47\x0c\xe8\xf2\xb8\x83\x39\xe4\x25\x72\x0d\x0f\x76\xe6\x65\x23\xaa\x6e\x9a\x2d\x6e\x6a\x8d\x77\x8d\xd7\x3e\x62\x56\x5b\x9a\x4d\x57\x34\x6b\xc8\x56\xa7\xe8\xe0\xf2\x91\xcc\x18\xb4\x8e\xd4\xee\x81\xe0\x35\xab\xaf\x04\x5e\xb7\xb2\xc0\xab\x75\xe7\x80\x9f\xad\x0a\x79\xb6\xfe\x41\xbc\xb7\xdc\x41\x5c\xe1\x3d\xcb\xa1\x3c\x5f\x15\xe5\xf9\x1f\x8e\xf2\x3c\x87\xf2\x17\xf3\x64\x57\x1d\x56\xb9\xb2\x8b\xef\xae\xa4\xc5\xc5\x67\x74\x00\xb3\x0c\xdd\xc0\xe9\x0d\x93\x54\xc7\x7e\x22\xee\x29\xf7\x01\xf5\xc5\xf1\xc5\xad\x53\x5c\x6b\xf4\x0d\x99\x75\x65\xd4\x3c\x84\xd9\x91\x5e\xaf\x04\xbb\x04\x23\xa5\x6a\x6c\x1a\x1f\x8f\xce\x4f\x75\x8c\x88\x3e\x57\x38\x21\xcc\xce\x22\x7c\x68\x8b\x5c\x8c\xcd\xf2\x21\xf1\xf2\x1b\x6f\x29\x07\xc9\xd1\xe8\xab\xbc\xa5\xc2\xbd\xac\x00\x39\x4f\x06\xd3\x53\x6f\x73\x3d\x75\xdd\x31\xec\x6e\x16\x72\xd7\x99\x6b\xc9\x05\x93\xce\x71\xe7\xc4\x83\x49\x47\xc5\xe5\x29\xe7\x85\x49\x97\xaa\x75\x8f\xbb\xe2\x7f\x7a\xf4\xab\x47\xbf\x76\xe9\xd7\x2e\x81\xc8\x6b\x26\xd6\x72\x71\x74\x19\xa3\xb5\x98\x1a\x25\xcd\x35\x6f\x57\x34\x56\xdf\x4b\x9a\x4a\x36\x34\xfc\x16\x4a\xa5\xa7\x6e\x71\x29\x0e\x3a\xd4\xe7\xff\xd0\x3a\xff\x87\x74\xfe\x0f\xcd\xc9\x3d\xb4\x4e\xee\xff\x1f\x7b\x6f\xbf\xde\x44\xae\x24\x0e\xff\xcf\x55\x08\xce\xf9\xc5\x6d\x70\x1c\xdb\x01\x86\x49\xc6\x93\x65\x02\x33\xc3\xee\xf0\xf1\x10\xe6\xcc\xee\x06\x1f\xa7\x63\x2b\x71\x13\xbb\xdb\xdb\xdd\x06\x3c\x24\xef\xfd\xbc\xd7\xf1\xde\xd8\xfb\xa8\x4a\x1f\x25\xb5\xba\xdd\x8e\x03\x87\xf9\x2d\xb3\xcf\x1e\xe2\x96\x54\x2a\x95\x4a\xa5\x52\xa9\x54\x35\xc5\x93\xbb\x42\x08\xba\x77\xcf\x28\xdf\x7f\xe9\x33\x4a\x86\x39\x74\xbf\xc6\xc3\x04\xa2\x36\x44\x37\xb0\x8a\x43\xc5\x35\xd5\xf3\x9e\xe9\x21\x4d\xb2\xac\xa2\x83\xde\xb5\x4f\x16\xb2\x83\x71\x14\xce\x92\x78\x5c\xd1\xc5\xee\xb5\x8f\x18\xb2\x8b\x2c\x0f\xd3\x0a\xf8\xf7\xaf\x07\xff\x81\x81\xff\x3f\x8b\x30\xad\x9a\x85\x6b\xfa\xed\x3c\xd4\x3d\xe4\x69\x04\x6b\xaa\xa2\x8f\x6b\x1e\xf1\xbe\xd3\x7d\x7c\x58\x56\x81\xbf\x26\xab\x3e\xaa\x7b\x3a\x35\xff\xc1\x81\x4b\xae\xbc\x3e\x3b\xbe\x55\x95\x3d\xb3\xb8\x12\x4a\xfc\x70\xd6\x60\xf5\xb5\x21\x78\x78\x79\x6d\x18\x45\x66\x5a\x1b\x84\xcb\xef\x6b\x03\xf0\xb1\xdb\xda\x40\x1c\x7e\xf2\xb4\xbf\x35\xd8\xc4\x53\xd0\x63\x6f\x97\xcf\xf0\x56\x6e\xee\x8f\x36\x70\x77\xaa\xc5\x68\x5a\xd9\xc8\x30\x83\xf7\x0d\x60\xf4\xf0\x7e\xb3\xce\xa1\x1e\x71\xf3\x1c\xeb\xbf\xe4\x61\x5a\xcc\x43\x89\xa7\x4f\x7b\x9c\x86\x1f\xc8\x39\x5b\x10\xa8\xcc\x29\xe8\x46\xce\xc3\x48\x10\x99\x28\x7a\xcd\x03\x2b\xb6\xd9\xf0\x98\x56\x83\xd9\x9a\x2d\x89\x66\x53\xbe\x9e\x37\x67\x26\x89\xbe\xe4\xa3\xf5\x8e\xf3\xd8\xe6\xb3\xa3\x7f\xcf\xc6\x5f\x74\x5b\xc0\xff\x9a\x87\xcd\xea\xb3\x26\xed\xb5\xec\xb0\x89\x35\xfc\xb6\xee\x5e\xe7\xab\xba\x71\x8d\x93\x64\x5e\xba\x35\x76\x77\xaf\xa9\x3a\x74\x87\xc3\xd3\x30\x8b\xca\x35\xb7\xee\xae\xdc\x75\xb5\x0c\xf9\x49\xd4\x3f\x9c\x26\x19\x1f\x07\x5a\x56\x98\x57\xda\x66\x52\x34\xd1\xaf\x6e\xdd\x22\x8d\x0a\x6f\xa2\xc3\x94\x87\x70\x75\x56\x95\x47\x52\x53\xa0\x64\xa7\x11\x40\x9e\xc6\x95\x39\x48\x57\x81\xd0\x57\x78\x1e\x47\x76\xbf\x57\xbd\xfc\xb3\x67\xfe\xdc\x35\x7f\xde\x67\x7d\xd2\xd4\xf5\xb6\x97\x7f\x9a\xa6\x4b\xd3\x74\x79\x9f\xf5\xd1\x93\xc1\xb4\x87\xe3\x26\xf8\x32\xd2\xb7\xd3\x30\xe2\x02\xb2\xd9\x87\x28\x1f\x4d\x94\x9f\xbf\x8c\xcc\xa6\xb3\x88\x84\x19\x67\xdd\xbd\xc2\x9b\x33\x37\x32\xa7\x1c\x9a\x7e\xda\xdd\xa3\x91\xd3\xac\x16\x56\x48\x22\x55\xe5\x34\xe5\xe1\x85\xed\x12\x29\xfb\xee\xad\xec\x5b\x77\xce\xee\x41\x2c\x01\x45\xdb\x26\xdb\x61\xbb\x2d\xfd\x7e\xc1\x2e\x5e\x62\x71\x29\x96\x32\x4a\x5b\xa0\x27\xca\x82\xdd\x73\x60\xdb\xc5\xcb\x5e\x35\xec\x35\x29\xb0\x5b\xa0\x00\xcc\x51\x0d\x9a\x5b\xf5\x76\x5b\x66\xe8\x55\xf5\xee\xeb\x7a\xf7\xab\xd1\xd3\xaf\x4e\xa0\x79\xc9\xab\x7c\xfb\x51\xde\x7e\x4d\x86\xeb\xec\x39\x7c\xdc\xdd\xa7\xab\xe7\x63\x8b\x2e\x88\xe5\xbe\x8d\x9d\x62\x59\x1b\x42\x6f\x9f\x2e\x3a\x03\x61\xb7\x0c\x42\xcf\x85\xb0\xbb\x4f\xd6\x2a\x81\x70\x1f\x21\x54\xf2\x66\x87\xdd\x63\xf7\x0d\xff\x40\xf2\x41\xc1\x24\x0f\x5b\xe4\x7d\x0d\xad\x02\x8f\x22\x21\x3c\xf5\xc3\xa6\x83\x9d\x94\x43\xf5\x62\x94\x48\x71\xad\x32\x42\xe0\x58\x30\x74\x19\x68\x48\x30\x57\x56\x07\x57\x65\x12\xac\x45\x65\xd9\xc7\xfd\x32\x69\x65\x45\x77\x58\xde\xc0\x2b\x1e\xcd\x57\xd6\xf6\x41\x82\x6a\xf8\xb6\x98\x92\x4d\xba\xfb\x55\x6d\xd2\xf5\xf6\x52\x7b\x2b\x7d\x39\xe7\xf1\x9a\x1b\xa9\x68\x52\xb5\x8d\x96\x6c\x5f\xf0\x2c\x99\x6e\x21\x7a\xd3\xac\x6e\x20\xb7\xa2\xab\x6b\x6d\x92\x15\x7b\xe0\x06\x5b\x9c\x79\xcd\x0a\x38\x5e\x5e\x5a\x3f\x6f\xf7\xfb\xac\xc3\xb6\xb6\x6c\xc0\xfd\x3e\xdb\x6d\x36\x57\x89\x6e\x6b\xe4\x5d\xb6\x4d\x3e\xec\x7f\x59\xf9\x58\x4f\x06\xd6\x93\x73\x3a\xee\x46\x0d\xf9\xb5\x24\xf5\xca\x85\xd8\x3e\xa5\xd4\x81\x7f\xb3\x95\xf7\x03\x6c\xcf\x2f\x4b\xd5\x65\x88\x67\x0c\xbb\xee\x18\xee\x43\xd4\x9e\x79\x9a\x8c\x38\x1f\xaf\x2d\x37\x3b\xff\x8b\xe4\xa6\x25\x4f\x4a\xa4\xe6\x57\x95\x76\x7c\x6d\xa9\xb9\x88\xc7\x53\x72\x1b\x7f\xca\xd5\xfb\x2e\xa4\x37\x80\x93\xef\xae\xea\xb1\x04\x1e\x07\x80\x7a\x82\x25\x08\xf5\x34\x4c\x9e\x87\xac\x0f\x5d\xa1\x18\x06\x1c\x0a\x32\xb8\x86\x74\x64\x7d\x76\x3c\xb0\x78\xa6\xf0\x05\xf0\x32\x1e\x85\x41\xb3\x86\x40\x84\x05\x6e\x78\x94\x44\x34\x30\x1c\x49\x9e\xb7\x09\xc6\x55\x27\xe9\x6d\xd6\x25\xa1\x44\xdf\xd9\xef\x9b\xb4\xe0\xf8\xe8\xa4\x07\xc1\x48\x09\xce\x47\x4c\xa9\x7c\xfc\x6e\x50\x88\x42\x82\x69\x95\xb1\xc4\x0e\x43\x12\xb1\x3e\xdb\xb6\x83\x71\xe8\x00\x1c\x1f\x26\xd1\x94\xb3\xe0\xde\xbd\x88\xfd\xd0\x87\x37\x47\x46\xcf\x65\x7d\x16\xb1\x1d\xf6\xce\x55\xca\x91\x7a\xa8\x01\x53\xa0\x66\x1e\xef\x32\x78\xe8\x75\x8f\x05\x46\xbe\x23\x13\xdd\x95\x57\xc1\x39\x24\xda\xb5\x43\x87\xd0\xf6\xcb\xf2\xf6\x3a\xcf\xf8\x78\xd9\xd4\xcd\xfd\x39\xfe\x0c\x47\x18\x4e\x50\xd6\xa9\x22\x2f\x3c\x8d\xc7\x84\x13\xaa\xb6\x20\x09\xb7\x3d\x5f\x64\x93\xe0\xde\x47\x6b\x63\x5b\xca\xaf\x32\xe0\x93\x12\x48\x37\xe4\xe5\x1c\x90\x2b\xe9\x2c\x4f\x66\x81\x5a\x9b\xd4\x08\x79\x6a\xad\x5f\xc7\xce\x83\x0b\xad\x2f\xb6\xde\x83\x1b\x58\xc1\x6c\x0f\x05\xa3\x4f\x64\x68\x23\x20\x22\xd4\x96\x6b\x5c\x93\xd4\xc8\x15\x8d\x9d\x1c\xd5\x3d\xd3\x9e\x5a\x93\x10\x8e\x10\xb9\x41\xa7\xfd\xe8\x41\xd3\x27\x79\x3f\x57\x3c\xbe\x6b\xba\xf1\x87\xe9\x38\x8a\xc3\x29\xea\xda\x15\xd7\x3a\x8f\xae\x6d\x5e\xfa\x3c\x76\xab\x9e\xc0\x3d\x9f\x2d\xa6\xd3\xd7\xc9\xac\xc2\xed\xb0\x27\xaf\x8c\x34\xf3\x1d\xea\x56\xf6\xf9\xa2\xc5\xc2\xe9\x7c\x12\xae\x50\xc0\x55\x11\xd4\x65\x7d\x6c\x03\x1b\x82\x0b\xf7\x7a\x56\xae\xee\xe6\x56\xae\x55\x20\x6e\xde\xca\xa5\xfe\x7c\xb0\x99\xc1\x4b\xfe\xf9\xa0\x78\x30\x98\x76\xba\xc3\x50\xd7\x98\x76\x7b\xf4\x57\x6f\x57\xfc\x72\x6a\xf7\xec\xea\x3d\xbb\x7e\xcf\x6e\xf0\x2f\x32\xad\x55\x98\x6f\x3e\x83\x69\x4d\x25\x29\xf8\x6c\x7d\xaf\x30\x6a\x6d\x66\xac\x2a\xd6\x7b\xa0\xeb\x3d\xf8\x0c\x46\x2d\xe7\x8c\xe9\xcc\x33\x86\x5b\xdb\xa5\x4b\x63\x9b\x7d\xb4\x63\xae\xed\x52\x96\xdf\x66\x4b\x3b\x1a\xa6\xe4\x5a\x12\x08\xcd\xe6\x4e\x2c\x98\x27\x1f\x02\xd1\xcf\x5d\xe8\xed\x1e\x40\xbd\x2b\xfe\xb7\x45\xc5\x50\xd3\x0e\x8e\xb3\x91\x2d\xae\xa6\x25\xad\xdc\x16\xe7\x67\x75\x8f\x79\xcd\x7b\xea\xab\xb0\xd0\x3d\xb0\x40\x3c\xf0\x60\x56\xff\x34\xe8\x6c\x1e\xfa\xa2\xb2\xce\x91\xb0\x5a\x2c\xb5\xca\x65\x94\x2b\xd0\x0a\x22\xaa\x55\x25\xb0\xf6\x6b\x9d\x45\x15\x3b\xb6\x2c\xdb\x6a\xbd\x03\xaa\x62\x56\xc7\x12\xfb\x25\x94\x44\xbd\xf3\x52\x2d\xd1\xcc\x50\x89\xa6\x88\x7b\x30\x2a\x89\x2b\x77\xf5\xbd\xd5\xba\xa4\xab\x0b\x29\xb6\x38\xb4\xbe\x53\xed\x12\x73\xc8\x4b\xae\x30\xf8\xb6\x95\x76\x60\x1e\xb3\x1a\xd5\xa2\xa0\x4a\x62\x59\x41\x97\x34\xe0\xa4\x3e\xe9\x57\x27\xbf\xb2\xc0\x47\x92\x54\x2f\xe7\x3c\xae\x50\x26\xbf\xbf\xb6\x32\xb9\x8e\xce\xe7\x51\xf9\xa8\x69\xe4\xe6\x14\xbe\xbf\x92\x35\x96\x08\x86\x7a\xba\xda\xd7\xab\x8a\xfd\x75\x4c\xc0\xff\xeb\xb4\x89\x9b\xb4\x5c\x93\xc9\x28\xb1\x32\xbb\xbb\xde\xb2\x57\x6a\x71\xf6\x54\xfd\x02\xd6\xe7\xee\x37\x7d\xe3\xff\x5a\x7d\xc3\xbb\xa5\xac\xa1\x6d\xe0\x56\xe9\xea\x1a\xe2\xeb\x57\xa6\x69\x7c\x81\x50\x21\x37\xeb\x0d\x45\x34\x00\x0c\x70\xb0\xae\xcf\x12\x6d\xf5\x17\x76\x5a\xba\xde\x9e\x2a\x45\x7d\xe5\x4e\x79\xad\xbb\xd0\x15\x5d\xa8\x9b\x43\x10\x85\xd0\x00\xe2\x92\x39\x5b\x4c\xcb\x2f\xde\x75\xab\xcf\x7d\xd1\xe6\x65\xa8\x92\xbb\xb6\x2f\x10\x78\x46\x8e\x2a\x88\x66\xb3\x45\x1e\x9e\x4e\x79\x73\xc5\x08\x67\x49\x9c\xe4\x49\xcc\xff\xf3\xba\x60\x4e\x2d\x30\xff\xb5\x6f\xd6\x5a\x16\x9d\xc7\xc1\x47\x8b\x62\x1f\xad\x48\x7d\xb0\xb6\x76\x76\xd8\x61\x38\x1d\x2d\xa6\xa1\x8c\x09\x97\x4d\x93\x39\xcf\x58\x82\xe1\xd6\x65\xa0\xf5\x8c\x05\xbf\xf2\x74\x16\xe5\x7c\x1b\x96\x1e\x24\xcf\x9f\x27\xd3\x50\xf4\xd4\x64\xa7\xa1\xd8\x1e\x92\x58\x40\x13\xad\xce\x92\xe9\x34\xf9\x10\xc5\xe7\x6c\x1e\xce\x79\xba\xc7\x8e\x72\x7e\x76\xc6\xe3\x16\x7b\xde\x66\xdd\xef\xbf\xef\xb4\xd9\x63\x76\x14\xcd\xe6\x53\xce\x9e\xf3\x7c\x92\x8c\x21\xa4\xdc\x73\x1c\x45\x34\x12\x70\x9e\xd1\x2e\x58\x14\xb3\x97\x31\x67\x4f\xa2\x19\x8f\xb3\x28\x89\xdb\xec\x71\x96\xa7\x49\x9c\xcc\x96\x90\xad\x00\x7e\xcd\x27\xcb\x2c\x1a\x65\x2d\xf6\x8f\x64\xda\x66\xbd\xdd\xef\x5b\xec\xc5\xcb\xb6\x00\xf6\xe2\xe5\x3f\x82\x67\xcf\x9a\x2d\xf6\xaa\xcd\xee\xdf\xdf\x6d\x21\x12\x84\x56\x62\xd0\xbb\x41\x3e\x09\x73\x95\x5f\xc3\xb8\xab\x4f\x70\xeb\x0c\x73\x19\x0b\x5b\xfe\xa9\xef\xce\x26\x3a\x2f\x86\xaa\xa4\xdd\xca\xe5\x05\xbe\xf8\xba\x34\x4d\x97\x1d\x08\x92\x3f\xe9\x08\x5d\x79\xd2\x85\x49\xd9\xda\x62\xdb\xe6\xf1\x5b\xd6\x85\x17\x77\x06\x26\xbe\xbb\x0b\x26\x5d\x68\xd2\xf1\x34\x99\x8b\x16\x59\x87\xdd\x15\x10\xef\x09\x08\x77\xd9\x44\x77\x74\x8f\x4d\xf0\x01\x9c\xe4\x84\x00\xb8\x23\x83\x30\x7a\xf8\x67\xb7\xd9\x54\x21\x90\xad\xd8\x90\x59\xa7\xd9\x32\xd1\xbe\xb3\x6e\xb3\xc5\x3a\xed\x07\xaa\xaa\xf8\x36\x6f\x42\xde\x85\x4e\x91\x9f\x42\x96\xc4\x7c\x3b\x8b\xc6\x7c\x8c\x24\x76\x49\xde\x93\x24\xcf\x09\xb5\xfd\xc4\x26\xb8\x83\xcb\xb1\x50\x99\xcb\x28\x3b\x11\xbf\x31\x07\xe1\x1e\xcb\x15\x5a\x8f\x47\xa3\x44\x6c\xea\xe7\x2c\x4f\xd8\x24\xcf\xe7\xd9\xde\xce\x0e\x8f\xdb\x1f\xa2\x8b\x68\xce\xc7\x51\xd8\x4e\xd2\xf3\x1d\xf1\x6b\xe7\x70\x71\x1a\x8d\x86\x92\xe3\x87\xd9\x5c\xc8\xc2\xbf\xbd\xe6\xf3\x94\x67\x3c\xce\x81\x23\x33\x01\xf2\xce\x32\x59\xb0\x51\x18\x8b\x05\x9b\xf2\x2c\x63\x23\xd1\x90\xc9\x86\xf6\x2a\x81\xb0\x8a\x3c\x9d\x65\x98\xed\x48\xd4\xfb\xe9\xff\xfb\x7f\xff\x8c\x78\x8a\xaf\x46\x01\x20\x44\x6c\x4f\x79\x36\xe7\xa3\x5c\xa0\x89\x8b\x69\x91\xaa\x58\x94\xf3\x4e\x8b\xcd\xc5\x6c\xce\x3a\xe8\x26\x39\x17\x63\x9f\x75\xd5\x8f\x3b\x84\xc0\xca\x4a\x0b\xf4\xed\xb4\x58\x4e\x9e\x9e\x7e\x24\x2c\xdd\xb1\xa2\x05\x29\x3a\x5a\x71\x85\x5c\xbe\x5e\x9a\x8f\x26\x8b\x0b\x5c\x39\x07\x3a\x5a\xfc\x0e\xdb\xc5\x53\xbb\xa8\x55\xfa\xe4\x17\x82\xfe\xb3\x25\xfe\xc1\xee\x02\xa2\x00\x02\x3e\xe3\x1f\xe2\x73\xd9\x03\xe0\xe7\x4a\x7e\xd6\xd7\x26\x74\x93\xbf\x8a\xa9\xa0\xdc\x3e\x40\x4a\x20\x05\xf3\x67\x75\x55\xee\xb9\x47\x39\xfb\xd4\x47\x0e\x15\x65\x47\x39\x73\x6f\xd0\xd2\x58\xb7\x8c\x20\xa0\x9f\x9b\x3e\x0f\xa0\x6b\x1a\x1a\xba\x9f\xdf\xd0\x00\xaf\x9a\xb4\x27\x5d\xa5\xca\xf5\x11\x70\xd2\xb3\xbb\xb5\x25\x6a\xf4\xcd\xac\xea\xac\x06\x10\x5d\xff\x3c\x4e\x52\x4e\x73\x3a\x00\x16\x59\x7b\xe3\x1b\x86\x4a\x6f\x31\x18\x59\x99\xaf\x58\xe1\x6c\xbc\xb1\x65\x81\xf2\x85\xcd\x0d\x82\xa4\x7a\x6f\xd6\x27\xf3\x26\x08\xb3\xb2\x5b\x07\x3f\x97\x95\x81\x2a\x3f\xe5\xdf\x8c\xa7\x99\xb5\x3e\xf3\xae\xd4\x89\x3d\x12\xec\xbf\xaa\x25\x98\x50\x76\x5f\xf3\xb3\x29\x1f\xe5\x87\xf8\x91\xaa\xbb\xb7\x6e\x05\x1a\x8e\x25\xd6\xd0\x24\xd2\x1e\xa5\x3c\xcc\x79\xe0\x11\x7d\xcd\x66\x5b\xcd\x84\x87\xb3\x3d\x0d\xb0\x3a\xc6\x8f\x41\x42\x2e\x5b\xec\xa3\x40\x82\xe6\x0c\x2c\x41\x75\xa5\x70\xb6\xdb\x15\x24\x74\x59\x82\x3e\x3f\xab\x22\x62\x95\x79\xf6\x2a\x04\x43\x75\x62\x3c\xff\xca\xa1\x3d\xae\x99\x6a\xce\x01\x68\xef\x94\x3a\x00\x46\x4f\xb6\x93\xfd\xd8\x44\x9f\xf9\x37\x43\x72\x5c\x2a\x6e\x97\xf6\x76\x3a\xf3\x33\xa3\x07\xc2\x7f\xd9\x10\xdc\xb3\xd6\xe7\x0a\x92\xa9\x31\x7d\x11\xe6\x8b\xd4\x44\xd9\x58\xcd\x59\xb2\xc1\xd7\xbb\xe9\x57\xf8\x23\xde\xa8\xcb\x61\x4c\x5c\x0e\x89\x49\xbc\x90\x8c\xa5\x72\x87\x80\x98\x17\xcb\xe3\xce\xa0\x7c\x9f\x30\x55\x94\x88\x86\x6e\x60\xb3\xeb\x35\x57\xf9\x47\x7c\x84\xe0\x1a\x4b\x15\x97\x03\xa4\xb3\x9d\x6b\x4d\x06\x51\xf9\x28\xe7\x39\x4d\xa6\xaf\x60\x6f\x0c\x6c\x77\x41\xc6\xe6\xcb\x42\x95\x25\x71\x55\x80\x60\xe6\x90\x8e\xa0\x83\x11\xcd\xa3\x2e\x6e\x94\x51\x57\xc7\x2d\xef\xb4\xc4\xff\x76\x29\xd6\x2e\xde\x4e\xc4\x10\x31\xfc\xe3\x08\x22\x83\x2c\xcd\x9f\x62\x54\xfa\xab\xfa\xf3\xe3\x71\x84\x63\x8d\xc8\x60\x69\x86\x7b\xb2\x35\xd5\x54\x81\xe2\x1b\x52\x7c\xaa\x5d\x23\x6f\xde\xff\x71\x87\x1d\x71\xae\x0f\x67\x1f\x3e\x7c\x68\xcf\xc3\x34\x8f\x46\x53\x1e\xc5\x23\x3e\x9d\xb6\x47\xc9\x6c\xa7\xd7\xe9\xf6\x76\x90\xdc\xdb\x78\x36\xcb\x76\x60\x16\xc7\x3c\x8d\xde\xc3\x61\x8b\x1c\x83\x5c\xde\xd0\x67\x20\x1d\x07\x3e\x76\x7c\x70\xd5\xf7\x99\xfa\x23\x2c\xc9\x1d\x71\x5a\xf2\x3d\x75\xbe\x8b\x01\x86\x18\x5b\xac\xd3\x62\xa7\xf8\x57\xaf\xc5\x52\xfc\x4b\xb0\x8a\x7c\xe5\x26\xf8\x43\xd4\xd6\x01\xf6\xbb\x32\x7a\x3e\xf8\x06\x63\xd6\x84\x10\x73\x23\x74\x05\x24\xf8\xeb\xbe\x80\x84\x7f\x19\x8f\x5a\x84\x16\xb1\x7b\x0c\x21\x86\xc7\x00\x43\xf6\x7c\x6a\x7e\x7d\x27\x5a\xeb\x5f\x8f\xa0\x99\xfc\x79\x4f\xfc\xe9\xc7\x47\xe2\x32\x63\x7d\xc4\x67\x47\x20\x03\xad\x24\x5a\xdb\x7d\x36\x93\x78\x89\x3f\xd9\x5d\xf1\x37\x54\x70\xb0\xd1\x9d\xef\x68\xac\xac\x1e\xc5\xa7\x9e\xe8\xf5\x47\xc8\x1f\xb1\xbd\x6d\x48\x10\x20\x78\xf1\x13\xc6\xd9\x44\x34\xa0\x3d\x19\x61\x20\x46\xc1\xee\xe9\x4e\xc1\x32\x60\xf5\xd1\x29\x52\x59\xd2\x96\x92\x91\xf4\x44\xac\x11\xc7\x61\x8b\x9d\x0e\xd0\xc8\xf0\xd9\xcc\x9c\xee\x6e\x57\x62\xe1\xfc\x8c\x41\x41\xaf\x61\x9a\x1c\xc1\xe0\xb2\x9c\xcf\x7f\xe2\x67\x49\xca\x37\x33\x71\x0a\x38\x8f\xcf\x72\x9e\x12\x25\xe0\x28\xe7\x73\x73\x33\xb3\x4a\x09\xd0\xaa\xb8\x10\x66\x30\x61\xa2\xfd\x57\xad\x10\x18\x99\xbb\xe1\x13\xad\x0e\xfb\x41\x8f\x5e\x1f\x91\x73\xf6\x03\xeb\xfa\x4e\xcc\xbd\x92\xcb\x00\xa5\x60\x28\xbc\x9a\xee\x4d\xc2\x4d\x9f\xcb\x1d\xc8\x42\x04\x34\xc9\x2c\x9a\x0d\x2b\x6f\xdd\xb8\xb3\xc0\x5f\xe3\x84\x5d\x7e\x1b\x6e\x54\x15\x43\xc5\x9c\xfd\xd0\xb7\x93\xe6\x54\xbb\xa7\x9a\xcb\x9f\x2a\x55\xcd\xae\x55\x50\xd3\xa4\x82\x4a\xee\xa9\xd9\x5d\xfa\x62\x23\x6f\x8a\x9d\x46\x3f\x6d\xcb\x57\x77\xd8\x75\x39\x70\x45\xe5\xa5\x47\xad\x2a\xf5\x51\xa5\xeb\xcf\xb0\xfa\x97\x7a\x39\x66\x8b\xb4\x4e\xfb\x81\x92\xf5\xc6\x70\xae\x05\x6a\x5d\x20\xce\x21\x4f\x4b\xd2\x9a\xed\xbb\xfe\x23\xde\x67\x8c\xee\x76\x8d\x7b\xe8\xcf\x14\xac\xb9\xfb\x19\x83\x35\xf7\x86\xc3\xe4\xec\x2c\xe3\xf9\x30\x4e\xe2\xf2\x50\x5e\xdf\x5f\xd3\x4b\x6f\x77\x38\x84\x94\x4d\xd5\xd0\xbb\x9d\x8e\x0a\xe6\x45\x18\x24\x1c\x5d\xfc\x03\xb3\x6e\xb5\xd8\x05\x5f\xda\x51\x98\x8f\x2f\xf8\xf2\xa6\x14\x1e\xa3\x8e\x5f\xf0\x65\x56\x33\x0f\xc3\x8a\x40\x37\xc7\x26\xae\x13\x10\x60\x55\x60\x66\x4a\xa5\x8a\xac\x80\x38\x57\xab\x32\x16\x5a\x33\x5a\x01\x4d\x65\x73\x32\xb4\x76\x02\x44\x89\xef\x85\x8c\x79\x17\x7f\xb2\x3e\x50\x6a\x65\x92\x3a\x92\xe5\x6a\x56\x96\x5b\x4f\x1c\x7c\x2e\xfe\x2c\x7c\xce\xfe\x2c\xcd\x95\x97\xfc\x59\x33\xa5\x9b\x3e\x54\x5f\x44\xd0\x09\x24\xf7\xca\xc4\xdf\xd9\x9f\xa8\x59\x9b\x0e\x66\xcd\x16\xbc\x83\xec\x88\x1a\xef\xf6\xd9\x3b\xf6\x03\x9b\x09\x78\xd6\x33\xc3\x2c\xc2\x34\x5f\x59\x24\xea\x1e\x8b\x13\x39\x49\x0c\xf7\x6e\xd0\x62\x17\x51\x8b\xbd\x93\xc9\xe1\x06\xfb\xa4\xe1\xbb\xb6\xf8\x26\xa9\x70\xfc\x6e\xe0\x3e\x9b\xc8\xa2\xf6\x05\x17\x12\xfe\x22\xb2\xec\xc0\x34\xcd\x59\x22\x88\x02\x9c\x12\x64\x7f\x36\xfd\x83\xce\xfe\x3c\x4e\xc4\xe8\x06\x6d\x95\x8e\xd0\x86\x87\xbc\x11\x64\x7f\x0a\x70\x72\x4b\x52\xf1\x8f\xfe\xd4\x5e\x45\x30\xf3\x6d\xb9\x1c\xd6\x0a\xc3\x24\xdb\x6c\x18\x49\x6a\xf5\x02\xab\x23\x88\x4b\x22\x8e\x0f\x9b\xcd\x16\x8e\x50\xa8\x3f\x02\x61\xe3\x06\x85\x03\xff\x57\xe6\x46\x5b\x3d\x74\x0c\xa2\xa5\xf0\x77\xb2\xa3\xe1\x00\x94\xcc\x59\x6b\x00\x5a\x50\x91\xf8\x59\x9b\x08\x2d\x19\xa0\xec\xaf\xc1\x06\x30\x96\x02\x19\x95\xb8\x5d\x8f\x8e\x5a\x48\xd7\x22\x64\x0d\x81\x2d\x23\x98\x69\x5c\xa1\x7a\xc1\x77\x0f\xca\xfd\xa7\xf2\xdd\xaf\x2d\x7c\xd9\x2a\x5d\xe3\x26\xf6\xf5\x8c\xa7\x11\xcf\x5a\x38\xb5\x38\x6f\x10\xd3\x30\x08\xc4\xa6\x83\xa5\x72\xda\x30\x8f\xa7\x49\xe6\x4e\x2d\xb2\x2d\x16\xeb\xbd\x61\xa6\x1b\x1e\x77\x06\x6a\xd3\x62\x4b\xdf\x7e\x01\x00\x96\xf0\x2e\xbd\xb0\x43\x2d\xd9\x3d\x0d\x27\x1a\x1c\xbf\x1b\x1c\x77\x07\xd2\x7d\x45\x9d\x95\x96\xcd\xd2\xfd\xcd\x6d\xb8\xa3\x8f\x05\xac\x56\xf0\x8b\x52\x36\x6b\x3a\x24\x2b\xe1\xa5\xcf\x18\x65\xe7\xa6\xf3\x6b\xad\xc9\x02\xdd\x52\x16\x90\xf3\x3f\x6e\xb1\xf1\xb2\xc5\x96\xf3\x16\x5b\xc6\xc0\x18\x84\x23\xa0\x93\xe3\xce\x40\x31\x46\x39\x57\xcc\xc5\x49\x2e\x96\x96\xfe\x15\x39\x69\x21\x56\x42\x30\x76\xbb\x89\x06\x62\xfa\x9b\xc7\x60\x12\x1c\xc3\x25\xc8\x8f\xce\xb1\x7a\x8c\xa6\x5d\x81\xec\xf8\xb8\x8b\x7f\x0a\xc6\x1b\x2f\x9d\xdb\x0c\x48\x89\xbf\x64\x3f\xb8\xcd\xb1\x4d\xdc\xd2\x90\x62\x6f\x73\x4f\x8f\x9e\x57\x97\x7e\x5e\xfa\xba\x62\x8f\xfc\x95\xe4\x92\xd2\x56\x3b\x1e\x06\x34\x9c\xd9\x59\xc5\x8b\xc0\xdf\x08\x6a\xb9\xb6\xa0\xca\x3a\xf2\x93\xa8\x05\x7f\xc3\xfc\x6f\x2f\x95\x75\xfb\x4b\x89\xa4\xaf\x2b\x90\xc2\x57\xca\x46\x62\xe2\x6e\x07\xc1\x4c\x3a\x69\x16\xd9\xa6\xb9\x9a\xeb\x96\xc8\x2a\xef\xf0\xf2\x27\x13\x5b\x62\x4b\x70\xcb\x6a\xee\x02\x77\x52\xf1\x6f\xaf\x5c\xe0\x41\x14\xef\xc8\x23\xea\xe8\x65\x6a\x16\xbd\x03\xe4\x23\xc2\x8e\x4e\x79\x57\x96\xc3\x55\x8b\xb7\xce\x2e\x10\x41\x40\xda\x86\x06\xfa\x3e\xc6\x3e\x38\x22\xaa\x17\xec\x07\x16\x09\x54\x2f\x9a\xce\xcd\x6f\x76\xe1\x22\x7b\x61\x23\xcb\x58\x76\x81\xe8\x5e\x94\xa0\x0b\x35\xba\xb2\x86\x85\x30\x39\x3e\xee\xc2\x0a\xbb\x40\x74\x2f\xde\x75\x0b\xa7\xc7\x2e\x54\x88\xde\x21\x81\xc5\xdf\xbb\xec\x2e\x7c\xa0\xce\x6b\x62\x8d\xea\x2e\xe4\x9a\xc5\xdf\x28\xb7\x8d\xfa\x91\x75\xc5\xe2\xdf\xee\x0b\x68\x3b\x2c\xeb\xaa\xc5\x5c\x07\xc2\x97\x58\xf0\x5f\xd7\x53\xd7\x30\x1b\xf1\x78\x1c\xc5\xe7\x15\x0f\x51\x77\xd5\xb2\xff\x3c\x3a\x8e\x65\x1e\xab\x33\x03\x04\xe7\x8a\x69\x68\xb6\x53\xfe\x9e\xa7\x19\x0f\xca\x66\xe2\x6b\x7b\x0a\xb4\xd2\xce\x78\xcd\x44\x7c\xb5\xa7\xf8\x73\xcf\xb1\x68\x5a\x90\xf0\x4a\xa2\x68\x93\xdb\x3b\xed\xc6\xbf\x98\x65\xa6\xf6\x2c\x9c\xaf\xc8\x2f\x4b\xd9\x02\xb3\xc4\x65\x8b\x99\x15\xa8\x5e\xd9\x09\x6e\x64\x9d\x37\x21\xab\x7a\x21\xd5\xb3\x3e\xd3\x2e\x66\xd9\xf1\xa9\xd0\x71\xe1\xaf\x70\xb0\x0f\x9c\x87\x88\xe4\xc9\x1c\xf6\x14\xe5\x0a\x91\xe4\x79\x32\xa3\x5f\xf2\x64\x0e\xe9\x20\x06\x76\x95\x4c\x3a\x35\xf9\xae\xdf\xad\x1d\xe9\x9d\xb2\xb7\xc9\x0b\x7d\x79\x8d\x95\xcc\xd9\x0f\x12\x14\x71\x58\x4a\x40\xb9\x06\x34\x8d\x79\x4f\x60\x80\x4e\x26\xef\xd4\x5b\x5a\x5b\x69\x96\x48\x17\x5b\x4a\x54\x9d\xc6\xca\x40\xa7\x82\x4c\xc9\x4a\x7a\x91\xb6\x47\x49\x3c\x0a\x73\x81\x63\x56\xb6\x62\xbf\xc0\x1b\xa4\x9b\x5d\xb1\x5f\x93\xd8\xac\xc1\xd0\xab\x24\x66\xa5\x5f\xa2\xa4\x7a\x39\xcd\xc5\x30\x8f\xf2\x70\x74\x51\x76\xcd\xb4\xdb\x95\x0b\x84\xff\xcf\x22\x9c\x82\x79\x3b\x2b\xad\xbb\x4b\xeb\xfe\xb4\x7c\x13\x9e\x97\x54\xfd\xee\xe1\x77\xb4\x2a\x92\xaa\x0c\xee\x77\xdf\x29\x1c\xce\x79\x5e\x01\xf3\xd1\x03\x59\x2d\xca\x00\xcf\x32\x2e\x78\xa4\xab\xfd\xa4\x92\x4f\xf8\x87\x63\x2a\xbe\x59\xce\xf9\xb8\x0a\xe8\xee\x2e\x28\xe2\x3b\x77\xef\xb2\xdf\x05\x63\xe5\x09\x1b\x25\xb3\x79\x92\x71\x76\x1a\xe5\xb3\x30\xbb\xc8\x40\x3a\xa0\x59\x57\x14\x85\x69\x94\x25\x71\xd6\x16\xd3\x27\x66\xe1\xf0\xe5\xf3\x57\x8f\x5f\x3f\x1d\xbe\x7a\xfc\xfa\xcd\xb3\xc7\xbf\x0d\x7f\xfe\xed\xf1\x2f\x70\xf9\x8e\x50\x4f\x90\x46\x7f\xcb\x93\xa3\x3c\x8d\xe2\xf3\x13\x96\xf2\x4c\x30\x4b\xca\xcf\x78\xca\xe3\x11\x37\xa0\xc2\xf4\x3c\x43\x3a\x35\x8e\x13\x68\xc6\x1e\x2b\xcb\xe2\xa0\x81\x63\x02\x6b\x66\xa1\x52\x1a\x2e\x55\x05\xfc\xe6\xd4\x40\x24\x06\x0d\x3a\x54\x31\xac\xd3\x45\x34\xcd\xb7\xa3\x98\xcd\xf0\xed\x9b\x07\x29\x84\xf0\x2a\x4d\xf2\xc4\x78\x71\x6b\x4f\x15\x97\x76\x13\x3e\xba\x90\x4d\x90\x70\xc9\x87\x98\xcd\xd3\x64\xce\xd3\x3c\x22\x50\x27\x61\xf6\xf2\x43\xfc\x0a\x0b\xc4\xe4\x90\x6e\xda\x76\x21\x76\x71\x8b\xdd\x65\x8f\x59\x36\xe7\xa3\x28\x9c\x46\x7f\xf2\x31\x13\xcb\x2b\x4a\x62\x96\x9c\xb1\x93\xd3\x30\xe3\xcf\xb2\xa7\x82\x27\x4f\xa0\xdb\x10\x19\x3e\x8c\xc7\x1a\x9b\x0f\x93\x68\x34\x61\x73\x9e\x9e\x25\xe9\x2c\x13\xf0\xc6\x9c\xcf\xe9\x9c\x42\xf5\x3c\x0d\x47\x17\x99\xf8\x07\xd6\xaf\x69\xcf\xe3\xf0\x74\x1a\xc5\xe7\x06\x60\x94\x4f\xd8\x28\x4a\x47\x8b\x69\x98\x0a\x78\x86\x7a\x82\x16\xa7\x8a\x5f\xf8\xb8\x7d\x8b\xc1\x00\xfe\x6d\x0e\x6e\x81\x1c\xff\x0e\xd3\x70\xc6\x3e\x21\x45\xaf\x24\x54\xf6\x66\xc2\xd5\x9f\x92\x17\xc3\x94\xb7\xbd\x0d\xf2\x09\x4f\xb1\x3e\xfc\x55\xdd\x2a\x5e\xcc\x4e\x79\x7a\xa5\xb8\x1a\xda\xa9\xbf\xcf\xa6\xe1\x79\xd6\x06\x87\xc7\x22\x25\x67\x49\xca\xd9\x98\xe7\x61\x34\xcd\x2c\x88\x3f\x4b\xa1\x75\x25\x5f\x93\x47\x7f\x4a\x74\xf4\xcd\xa1\x40\x45\x15\x59\x6b\xc7\x0f\x06\x44\x8a\xf8\x59\x80\x32\xe6\x39\x4f\x67\x51\xcc\x45\x9d\xe8\x7d\x38\x85\x87\xa0\xc9\x99\x7c\x8c\xe6\x25\xcf\x31\x18\xc2\x07\xec\x8d\x3b\x9f\x27\x48\xa8\x13\x98\xed\x13\xa0\xdd\x89\x9a\x53\x84\x84\x1b\x41\xc6\x3e\x9d\x26\xc9\x94\x87\xf1\x15\x7b\x2d\xbf\x9c\xe4\xe9\x82\x9f\x88\xfd\x3f\xd7\xf3\x94\xb1\x30\xa5\x88\xb5\x70\x6b\x3f\x39\x0b\xa7\x19\x3f\x11\x10\x77\xcc\x85\x36\x21\xef\x13\xce\xe7\x01\x82\x68\xe1\x14\xb6\xd4\x8c\xb4\x08\x49\x5b\x86\x2e\xda\xf8\xaf\x14\xc0\xe4\xf4\xdd\x33\x21\x33\x59\x5f\xc9\x4e\x09\xd0\x68\x69\xf9\xa4\x50\x43\x74\x65\x2a\x9c\xbe\x43\x59\xa1\x61\x1d\x18\x19\xb3\x27\x25\xb7\x07\xaa\x6c\xa4\xc0\x7b\x1b\x41\x47\xa0\x60\xd1\x5e\xe0\x8f\xbe\x16\x76\x07\x44\x62\xed\xc9\x72\xa1\xe6\xd0\x3e\xaa\x9b\x40\x39\x74\xa3\x69\xf2\xf2\xf4\x9d\xd5\x99\xae\x6f\xd1\x45\xd6\xd2\xf0\x0b\xb5\xa2\xec\x28\x9c\x71\x17\x73\xd2\xa1\x50\x04\x4d\xa5\xad\x2d\xbd\x37\x29\x8a\x51\xcf\xb7\xdb\xa6\x10\x28\x63\xb4\x46\xa9\x79\x00\xc7\xd0\x93\x3a\x99\x5f\xc1\x78\xfb\xe6\x23\xa2\xae\x1b\x5c\xf9\x70\xb9\xad\x6a\xea\x97\x75\xa0\x30\x5c\x5e\xb2\x20\x93\xaa\x03\xba\xd8\x08\x9e\xb2\xee\x80\x03\xdd\xf1\xe5\xa5\xb5\x8b\xea\x61\x49\xc4\x0f\xa8\x7a\x71\x3d\x66\x96\x90\xf6\x88\xf2\xe1\x02\x42\xd2\xd7\x05\x48\xe9\x71\x3b\x50\x32\x6e\xcb\xbb\x51\x37\xa9\x4b\x03\x0c\xfa\x8f\x34\x9c\xcf\xf9\x58\x2d\x08\x41\xe7\xad\x2d\x67\xbb\xc2\x9b\x43\x85\x64\x63\x38\xfc\x80\x8d\x86\xc3\x06\xf5\x50\x10\x2c\x46\xc0\x29\x8e\x2b\x03\x87\x63\xb5\xa1\x91\x57\x11\x16\x76\x97\x97\x16\x78\xdb\x76\x96\x9c\xbe\xfb\x3d\xfe\x60\x8f\x43\x35\x54\x4b\x07\x2f\xb7\x83\x26\x2e\x39\x31\x0e\x62\x8c\x4a\xf2\x89\x05\x80\x0e\xe4\x00\x27\x85\xb6\x17\xbf\x75\x78\xe6\xd5\x3c\xa6\xb9\x4c\xcf\x5c\x40\x31\x6e\x59\xdd\x97\x4c\x7a\x46\xe0\x5d\xd1\xf9\xd6\x0b\xc0\xb9\xa1\xb5\x56\xca\x2a\x1c\x29\x7e\x52\xc5\xbd\x1e\x6f\x83\x6b\x12\xea\xf4\x6d\xa9\xd2\xb3\xbe\xbb\x07\x78\xce\x06\x95\xde\xd3\x12\x10\x1c\x03\xa4\x62\xf4\x9a\xcf\x92\xf7\x3c\x63\xe1\x74\xca\x2e\xf8\x72\x1b\xb5\x55\x1e\xe7\xe2\x28\xc2\xce\xd2\x64\x06\xfb\xd5\x34\xca\x72\x36\x0a\x47\x13\xee\x55\x48\xe2\x70\xc6\xd9\x68\xca\x51\x99\xf9\xb7\x19\x17\x1a\xc3\xcb\x33\xf6\x5b\x94\xe5\x87\xa2\x95\xbd\x95\x4d\xd5\xe7\x43\xd1\x24\xa0\x2e\xcf\xc3\x71\x98\x87\x70\x9c\xc3\x57\x43\xf0\x55\x66\x17\xeb\xf8\x89\x62\x43\xf3\xd0\xa4\xd2\xc9\xaf\xd6\x79\x29\xcc\xb2\x64\xf4\x2c\x1e\xf3\x8f\x2f\xcf\xca\xce\x18\xf7\x3b\xcd\x6b\xe8\xc8\xb0\xf7\x29\x15\x19\x84\x61\x41\x43\xfe\x49\x41\xc1\xb9\xf1\x00\xc9\xe6\xe0\x99\xd0\x27\xd0\xda\xf8\x6d\xbf\x30\xd1\x27\x17\x7c\x89\x0a\x4c\x94\x67\x12\xe4\x5a\xd3\x8c\xb9\x73\xcb\xe7\x59\xab\x53\x19\x9c\x5a\xae\x04\x5b\x81\x5a\x26\xfe\x95\x11\x39\xb0\xdb\x3c\x61\x29\x60\xb5\x9e\xee\x24\x98\x73\xc9\x3e\x84\x99\x6c\x3d\xae\x54\x9b\x34\x77\x3c\x01\xbc\x03\xed\x09\x28\x08\x27\x5d\xaa\x2c\xd6\xd3\x3b\xb8\x74\x7f\xa2\x73\x0f\x7e\x5a\xe8\x4d\x68\x36\x71\xa8\x47\xee\x3e\x7d\x72\x03\x52\x17\x87\x59\xfe\x4c\x02\x25\xae\x6c\x18\x31\x9f\xc2\xea\xf7\x4d\x5d\x05\x14\x1a\xcc\x93\xb9\x8c\x95\x43\x6d\x40\x38\xd3\xb8\x15\x20\x7e\x00\x06\x7d\x5e\xb1\xfb\xed\x6d\xbd\x8e\x88\x94\x42\xc5\xa0\x72\x49\x21\xd1\x8a\x6b\xea\x7e\xa5\x3f\xc8\xcd\xaf\x29\xc1\x20\xbf\xf0\x3c\x73\xb8\x54\xf1\x6f\x92\x22\x5f\x97\x73\xed\x39\xcf\x6f\x88\x65\xcf\x79\xee\xf0\xeb\x5d\xc3\xa9\x86\x3f\xa1\x7e\x19\x2f\xfe\xc2\xf3\x9b\x65\x44\x39\xa3\x9a\x17\xd9\x01\x5b\xc4\x63\x7e\x16\xc5\x7c\xcc\xf6\xd0\x67\x10\x0a\x07\xf0\x38\xab\x72\xce\x7f\xe1\xb9\x67\xc2\x2b\x9d\x36\x3e\xcf\x84\x1f\x4e\xb8\x38\x7f\x45\x67\x2c\xac\x98\x73\xc6\x3f\x46\x19\x9e\xbf\xfc\x53\x3f\x09\xb3\xcd\xa6\x1e\x27\x54\xd9\x28\xea\x0b\xab\x30\x96\x4d\x5d\x5c\xeb\x09\xac\x5f\xc3\x2c\x70\xfd\x96\x2d\x1e\xb0\xb9\x05\x7d\x9c\x7f\x64\xdb\xdd\x15\xf3\xfb\x6b\x98\x79\xe6\xb7\xd2\x91\xe2\xf3\xcc\xef\x91\x67\x41\x23\x99\xf2\x84\x9d\xc0\x34\x57\xac\xe8\xec\xc6\x56\x74\xa6\x56\xb4\x6c\x73\xf7\x4a\x96\xbd\xf1\xd6\xd2\x53\xaf\xec\x05\x74\xf1\x93\xa1\x44\xe0\x78\x38\x2a\x15\x02\x47\x28\x04\x5a\xd8\xc5\x67\xde\x94\xee\xdd\xb3\x76\x00\xb5\xa1\x2c\xb2\x49\x70\x6c\x90\x18\x14\x77\x17\x5b\x74\xb0\x3e\xf1\x17\x25\x3b\xc9\x24\xca\x56\x70\xdd\x91\x57\xaa\x54\xfa\x5d\xd4\xe2\x3a\x3d\xeb\xa5\xe1\xfb\xbe\x6f\x16\xb5\xa0\x15\xea\x2e\x7a\x6f\xae\xa3\xe9\xc2\x11\xc0\x9e\x68\x00\x52\xa5\xe1\x62\xec\x37\x89\x7e\x4d\x65\xd7\x00\xf5\x50\xb3\xf2\x52\xbb\x42\xf9\xaf\xd4\x09\x57\xd0\xc2\xa7\x0e\x2a\x62\x7c\x65\xaa\x20\x8c\x64\x5d\x35\x50\xda\xdc\xa5\xdf\x7d\x03\x87\xdb\x18\x04\x7a\xb9\xd1\x49\x83\x45\xe5\x68\x59\x08\xa0\x62\x36\x4b\x75\xac\xca\x9b\x71\xcf\x74\x6a\x05\x09\xcf\xa6\xd7\xd7\x8d\xae\x35\x7f\x1b\xe8\x45\x80\xaf\xa5\x13\x11\xb9\xa2\x67\xa4\x7d\x2e\x6b\x54\xd0\xd2\xaf\xbb\x54\x5e\x58\x7a\x08\x49\x15\x0f\x2f\x2d\xd7\xd7\x39\xd6\x21\xe9\x97\xd5\x37\x60\x80\x3e\x5d\xc3\x26\xfe\x44\xd6\xa8\x20\xbe\x5f\xb1\xd8\xfc\xb6\xb2\x8e\x88\xc7\xe5\xfa\x3c\x9c\x97\x3a\x57\x3c\x34\x75\xaa\x80\xf5\x3a\xdf\x59\xe7\xf8\x50\x2e\x29\xb1\xc0\xf3\x04\xaf\x72\x38\x9b\x86\xe9\x39\xc7\xe3\x36\x4b\xe6\x79\x34\x8b\xfe\xc4\x88\x7a\xfa\x4c\xfe\xdb\xe3\xd7\xbf\x3c\x1d\x3e\x7e\xfd\xfa\xf1\x7f\x0d\x8f\x9e\xfd\xf7\x53\xd6\x67\xbd\x4e\xc7\xa3\xfc\x20\x83\x6d\xa0\xf7\x5c\x6b\xb5\xde\xa4\xce\x83\x23\xa8\x54\x7a\xa0\xca\x3a\x0a\x8f\x3a\x11\x43\x99\x02\x9a\x10\x25\x8f\x9a\x5f\xe7\x61\x94\x66\x4a\xfc\x52\x08\xd2\xb4\x27\xd8\xe2\xf2\x92\x05\x50\x4f\x1d\xbb\x7f\x28\x4e\xd1\x36\x38\x70\x2b\x83\x28\xd6\xf6\xab\x48\x8c\xd9\x82\xff\xde\x3d\x4b\xf4\x13\x33\x00\xaa\x46\xc6\x30\xef\x1b\xac\xd4\x05\x14\x67\x22\x9e\xfa\xf0\x8e\x90\x6d\xda\xb9\xda\x82\x6f\xe3\x29\x57\xca\xd4\x6c\x78\x56\x6b\x1d\xfb\x61\xf5\x6a\x8d\x32\x75\x2f\x57\xb6\x5c\x1f\xea\x4b\xf6\xe7\x61\x76\x01\x86\x62\xef\xed\xfe\xfd\xef\x75\x45\x64\xbb\xb2\x9b\x78\x75\x6b\x9f\x27\x47\xc9\x22\x1d\x95\x2d\xed\xdd\xdd\x1e\x51\x05\xd5\xc5\xf3\x2c\xcc\x47\x13\x76\xf2\x9a\x9f\x3f\xfd\x38\x3f\x11\x25\xc7\xd9\x32\xce\xc3\x8f\x6c\x34\x09\xd3\x70\x94\xf3\x34\x1b\x04\x93\x3c\x9f\xef\xed\xec\xf0\xd1\x2c\xdc\x86\x90\x98\x31\xac\xf7\x70\x0a\x01\x37\xe1\x73\xef\x61\x6f\xe7\xbb\x76\x67\xe7\x6f\x19\x1f\x6d\xcf\xc3\x5c\x54\xca\x9a\xb8\x10\x04\x61\x52\x8e\x7d\x1c\x4e\xc2\x94\xf5\xd9\xce\xf1\xdb\xb7\xff\xfc\x7b\xfb\xee\xbd\x83\xa0\x79\xfc\x76\xf0\xe9\xea\x72\xb0\x73\xee\x5c\x8a\x8f\x79\x2e\x86\x3d\x49\xc4\xa1\x22\x89\xb3\x3c\x5d\x8c\xf2\x24\xcd\x58\x70\x14\x9e\x85\x69\xd4\x6c\x1b\xe0\xcf\xb2\x5f\x93\x2c\x3f\xcc\x13\x00\xfe\xcf\xb7\xea\x02\xbf\x7d\xef\xe0\xd0\x34\x7d\x3b\xf8\xfb\xce\x35\xcc\x94\x82\x15\x94\x95\x52\x4d\xaf\x31\x54\x52\xf7\x81\x9a\xd7\xfd\x29\xcf\x92\xe9\x7b\x8c\xd6\x3b\xe6\xa3\x64\x36\x8f\xa6\x7c\xcc\x32\x9c\xbf\xe4\x4c\x5f\xe2\xda\x38\xbc\x91\xbe\x10\xf2\x49\x15\x9a\x3a\x95\x83\xc4\x17\xf3\x28\x70\xe7\x07\x14\x05\x49\xbc\x28\x63\x82\x35\xde\x73\x6b\x6a\x5e\xc0\x27\xd6\x67\xc8\x02\x41\xe3\x9f\x0d\x76\x4f\x3e\x95\x55\x63\x42\x0b\x9e\xdd\x5f\xb3\x9d\xf2\xf9\x34\x1c\xf1\x80\x72\x4f\x8b\x35\xde\xbe\xfd\xfb\x56\xa3\x79\x8b\x31\x5d\x61\xc7\x6e\x79\xa9\x97\x6f\xb3\x7d\xf7\x20\x38\xe8\xbf\x7d\xfb\x36\x68\x5e\x02\x1d\xda\xf7\xe4\x87\x41\x73\xe7\xbc\xc5\x1a\x7f\xef\xb6\xef\x1e\x34\x9a\xec\x1e\x6b\xfc\xbd\x71\x8b\xac\x11\xb8\xea\x0f\x33\xce\x20\xcc\xf1\x4c\xc5\x8d\x05\xc7\x89\x61\x3b\x92\xc3\x3a\x01\x7f\x86\x64\x91\xb3\xd3\x70\xcc\xb2\x49\x34\x43\xda\xfb\xf5\xa3\xca\x0d\x67\x4d\x8d\x47\x6e\x96\x82\xe8\xa1\x24\xbb\x66\x9c\x96\x80\xb2\xfa\x42\x1d\x87\x10\x90\x2d\x49\xde\x06\x49\x67\x2e\x59\x00\xb7\x99\x28\xae\xe4\xa7\x55\xe6\x5e\x29\x01\xe0\xfa\x5c\x2d\x19\x05\xed\x80\x32\xc5\x9e\xb5\x78\x89\x00\x97\x10\xda\x39\xcf\xf2\x40\xc9\x36\xd5\x7b\xd5\x05\x11\x02\xf6\x48\xf7\xcd\x6f\x42\x46\x49\xca\xff\x3d\x7b\x82\x9b\x98\x57\x6a\x3f\xe8\xb8\x6e\x51\x72\x95\xe0\x02\xc9\xd8\x2c\xcc\xfe\x67\xc1\xd3\x10\xc2\x18\x87\x85\xe5\x32\x0b\xb3\x8b\xa3\x74\xf4\x1f\xf0\x98\xd9\xf7\xc8\x7e\x11\x8d\x41\x7c\xfe\xb3\x3d\xb8\xf7\xf7\x9d\x36\xff\xc8\x47\x01\x41\x6b\x6b\x8b\x20\x89\x4f\x90\x8b\x9f\xda\xcf\x9e\x0e\x5f\xbd\x7e\xf9\xe6\xa5\x98\xd8\x46\x83\xde\xdd\x09\xf0\x07\x2c\x68\x1c\x2d\x67\xa7\xc9\x34\xc8\xd2\x51\x73\xd8\x6d\x37\xd8\x3d\x51\xd2\x64\x7b\xac\xd1\xd8\xbf\x75\x15\x34\xbd\x86\xca\x13\x81\xef\x89\x90\x28\x70\x94\x96\xe2\x6c\x06\x7c\x53\xb5\x1a\x8c\x2b\xcb\x99\xcf\x8b\x65\xdd\x65\x81\x58\x44\x99\xec\xb9\x52\xff\xd7\x6c\x2d\xbe\x58\x07\x80\xdb\xb7\xc9\x5c\x6c\x6d\xb1\x80\xfc\x8c\x62\x40\xb0\x84\x0d\x15\xcc\x22\x0b\x3e\xd8\xfc\xe2\x20\x4d\x92\x52\x4d\xa0\xe0\x92\x27\x79\x2f\x79\xcf\xd3\x94\x87\xa3\x89\xe0\x39\xc1\x0b\xdb\xef\x32\x90\x54\x66\x17\xb0\x38\x5b\xf4\x71\xdc\x18\x0e\x65\xd5\x61\x36\x09\x53\xb8\x57\x1f\xec\x7b\x86\x6b\x9a\x7a\x06\x5c\xc7\x70\xee\x3d\xc5\xa3\x50\x0c\x73\x79\x36\x10\x32\x57\xfa\x1f\xd5\x71\x0a\x93\xdb\xff\xc0\x71\x0b\x13\x2b\x6f\xd9\xae\x79\x5a\x98\xab\x2d\xb1\xce\xf1\x5e\x57\xf6\x9d\xf0\xcf\x79\x8e\xb1\x38\xd4\x65\xb8\x7b\xd8\x94\x18\x9a\xf7\xce\xf4\xfa\x02\x0b\x4d\xc8\x8e\xc2\x04\x28\xf0\x1e\xf2\x6f\x6e\xd7\xfe\x35\xcc\x26\xa5\xc2\x4e\xf9\xbf\xde\xd4\x19\x75\x6d\x53\xe5\x2c\x9c\xaf\x65\xa8\x54\x87\x0c\x7b\x7e\x66\xf2\x6b\xc1\x5c\x69\xac\x91\x45\xfb\x25\xee\x7f\x8d\x49\x98\x4d\x1a\x98\xa4\x46\x90\x0a\x47\xd9\x98\x85\x73\xf9\x31\x90\xc7\x2f\x73\x74\x93\x55\x90\xf3\x48\x53\x7c\x90\xee\x9b\x60\x0b\x3f\xcf\x2c\x6f\x6e\x47\x16\xa3\x00\xe8\xa5\x53\x7d\x5f\xe2\x2d\x6a\xa2\xcd\xae\xb4\xea\x03\x52\xf5\x17\x5e\x26\xad\xbe\x7b\xf0\x90\xd4\xfb\x35\x2c\xf5\x86\x7e\xf0\x1d\xa9\x77\x54\x01\xef\x11\xdd\x94\x20\x5c\xb2\x50\x8c\x44\x2b\xe5\xbc\xe3\x63\x15\x72\xb2\xa0\x82\x01\xbc\x11\xae\xd8\xb1\x64\xb9\x81\x92\x0e\x92\x13\xf1\xd0\x2d\x36\x27\xe5\x2f\x40\xf8\x49\xcc\x66\x20\x1b\x92\x68\x95\xf2\xf6\xc2\x24\x68\x97\x67\xf1\xbe\xe6\x6b\x23\x00\x3a\x6c\x4f\x7d\xa5\x81\x5e\x81\x09\x47\xc8\xa6\x82\x29\x4d\x52\x77\x79\xe5\xa1\x9e\x20\x1a\xf3\x00\x1a\xc5\x74\x1f\xf2\x36\x83\x44\xa2\x13\x87\x6b\xa8\x04\xe1\x5e\xf1\x2f\x19\xc6\xf4\x4a\x25\x5e\x18\x8f\xb5\x02\x93\x27\xec\x44\x0c\xf0\xa4\x7d\x4b\xfc\x43\xc2\x4a\x8f\x24\x03\x69\x66\xda\x77\x6a\x18\x03\xb2\xac\xa5\x8c\xbf\x0e\xa0\x73\x98\x64\xc9\x3e\x85\xd2\x09\xb0\x8a\x64\x9a\x42\x69\xa6\xdb\xe2\x11\xbf\xb0\x98\x44\x7d\xcf\x1a\xaa\x73\x7b\x50\xbd\x86\x50\x93\x43\xc6\x2b\xbd\x01\xec\xae\x2f\xe3\xc4\x58\xd6\x12\x72\x28\x4c\x28\x43\xea\x19\x29\xbb\x8b\xa1\xa8\x1f\x58\x3f\x03\xc1\x90\x42\xf1\xfb\x74\x55\xf3\x92\x86\x4c\x7f\x81\xca\xeb\x1a\xf5\x6b\xdd\xd1\x54\x13\xc8\x77\x45\x23\x29\x54\x50\x1b\x40\x56\xbc\x91\x20\xc1\x3c\x92\x8c\xa3\xb3\xda\x1a\xc3\x17\xbc\xcd\x31\xab\xc7\xbe\xcc\xd1\x17\x36\x30\x51\xca\x6c\x2d\xf4\x57\xa4\x83\x3d\xf5\x52\xa9\xa0\xd3\xba\xdd\x57\x30\x0e\x58\x97\xed\xb1\x4e\xcd\xcb\x1c\xba\x9c\x0b\xd3\x5e\xe7\x0a\xe2\x06\x17\x97\xd6\x7f\xb3\x3c\x8c\xc7\xdb\x42\x5b\x4f\x52\x76\xa2\x95\xaa\x13\x9c\x5f\xe9\x04\xaf\x54\xe0\x5f\x1f\x1f\xfd\x3a\xfc\xfd\xc5\x93\xa7\x3f\x3f\x7b\xf1\xf4\x09\xeb\xb3\xc6\x70\x38\x4d\xc6\x61\x36\x19\x8a\xea\x43\xdd\x7c\x38\xfc\x8b\xbf\x07\xd1\x4a\xb6\x21\xc3\xb5\x6e\xca\xdc\x65\xf4\x99\x2f\xca\xe4\x86\xb0\xfa\xf6\x52\x99\xcf\x29\xd3\xd0\x2d\xd1\xbe\xd5\x54\x6b\xc0\x61\x73\x08\xba\xe4\xf0\x84\xad\x98\xab\xe5\x60\x39\x03\xf8\x5c\x94\x8d\x8b\x02\x3b\x30\x7d\xb2\x3d\x03\xad\x7c\x4d\x79\xef\xf4\x1e\x6c\x7e\xad\x74\x8d\x05\xf5\xd7\x63\x74\x7a\x95\xe9\xe3\xf5\xf5\x6f\x32\xd7\x60\xf9\x2f\x7b\x91\x29\xf5\xa1\x7a\x8b\x43\x05\x0a\xb5\xb7\xfd\xc0\xb0\xe6\xed\x7e\xdf\x30\xa7\xd8\xfd\xab\xd9\xba\x9c\x7d\xbd\xb7\xa2\x0f\x36\xbf\x67\xf9\x2a\xf7\x03\xeb\x66\x13\x40\x6e\x70\xb1\x79\x1d\xe1\x7a\x93\xf7\x9a\x80\x7f\xc9\x85\xa6\x54\xaf\xd7\xba\xcf\x34\x2a\xc6\x3d\x57\x3b\xc1\xe3\x0e\xf8\x01\x1b\x16\xec\xdb\xf2\x5b\xa8\x30\x32\x46\xa0\xcd\x9b\x07\xee\x44\x91\xa0\x7e\x2b\xef\x02\xcd\x39\xc1\x65\xd1\xcd\x8d\xc5\xe7\x3c\x7f\x1e\xce\x2b\x8c\xc5\xdd\xfb\x3d\xcf\x69\xa0\x52\xd5\xad\xb4\x77\xf8\x34\x5d\x62\xf0\xf8\xca\x34\x58\x65\xd4\xa8\xd4\x62\x0d\x0d\x65\xa0\x54\x51\xad\xe0\x87\x74\x13\xfa\xab\x8d\x4e\x91\x21\x1e\xd6\x31\xdd\xfa\xdd\x68\xc8\x3d\x4d\xb6\x88\x20\x54\x3e\x08\xa0\x45\xc6\x59\x98\xb1\x45\x1c\xfd\xcf\x42\x5b\x29\x2f\xf8\xf2\x4b\x5e\x1c\x29\x84\x56\x18\xc9\xff\x83\x2f\x45\xad\xc0\x59\xeb\x32\xe6\xbe\x8c\x53\xe9\x2e\xbb\x00\x8b\xfb\xda\xd6\xc5\x2e\x2f\x99\xfe\x86\x0f\x6b\xed\x6f\x19\xdc\x3a\xd8\xdf\xe4\x38\x1a\xf8\xe0\x4d\x47\x0a\x15\x3b\x54\x63\x38\x04\xbd\x62\x38\x94\xa5\x7b\x3a\x8e\xa8\xb4\xa4\x94\x5a\xe8\xe5\x80\x3c\xf3\xbc\xb9\xab\xf7\x9a\x0b\x5f\x6b\xe3\xb3\x70\xbe\x81\x32\x7e\xdd\x95\xbe\x81\x42\xae\xd6\x8c\xcf\x79\xcd\xbb\x72\x57\x38\xb1\x11\x78\x9e\x89\xd9\xdc\x96\xbd\xe6\xc4\x50\xed\xd1\x33\x37\xeb\x2b\x8f\x6b\x4e\xd1\x97\x55\x20\x15\xf1\x7d\xce\x70\xfe\xc9\xac\x76\x8a\x23\xf0\x3c\x93\xb9\xb9\xc9\x7a\xcd\xc9\x3c\xa2\xab\x6c\x03\xb5\xec\xba\xcb\xec\x26\x55\x33\x31\x84\x4a\x87\x33\x45\xfb\x15\x3a\x9a\x77\x5a\x75\xe4\xa3\x82\x6f\x55\x2d\x6f\xac\x7b\xa4\x89\x90\xdf\xf0\x2f\x51\xf0\x56\xaa\x64\x04\x77\x0f\xdf\xac\xe3\xe4\xfd\x25\xd5\xfe\xc7\xe3\x71\xa6\xf7\x55\x99\xf6\x17\x1d\x24\x57\x3c\x28\x0c\xc7\x63\xc7\xa1\x91\x93\x77\x1c\xe1\x34\x0a\x33\x36\x5f\xd8\x47\x81\x12\x25\x40\x75\xb4\x82\x7b\xaa\x5d\x15\x65\xef\x8f\xc7\x63\xba\xd9\xdb\xde\xb0\x82\x01\xa0\xb0\xe5\x50\xab\x59\xcf\x01\xcf\xf4\xe1\x99\xe1\x75\x4d\xc4\x5e\x3d\x2b\x8a\xeb\xcf\x40\xd1\x5b\x99\x17\x5f\xd2\x94\x2d\xd7\x30\x1d\x4d\x04\x5b\x39\x74\x57\x51\x43\x2a\x75\xaf\xb3\x64\x11\xaf\xf0\xd9\xe7\xe6\x31\x14\x99\x8d\x52\x17\x65\xb5\x20\xab\xa8\xee\x97\xc7\xeb\x3a\x89\x97\x87\x94\x19\xb6\xb3\x64\xc6\xad\x68\x32\xca\x41\x2a\x5b\xcc\x21\x90\x94\x28\x8a\x72\x9e\x86\x39\x07\x22\x67\x93\x24\xcd\x27\x61\x3c\xae\xf4\x99\x52\x37\x72\x00\x14\xef\xe3\x70\x7e\xf3\x44\x41\x03\x4f\x87\x92\x28\x29\xf3\x94\x8f\xa3\x91\xa8\x64\xf9\x97\x44\xf1\xfb\xe4\x82\x8f\xd9\x9c\x2b\x9c\x20\xf9\x5c\xfd\xbd\x76\xc9\x38\x3a\x87\xb1\x79\x98\x65\x5c\xb9\x03\xa8\xce\x60\xef\x5e\xe9\x8d\x05\x03\x39\x4a\x66\x3c\x80\xbf\x5a\x06\x40\xad\xfb\x43\xa4\x83\x7d\x7b\x08\xdf\xe8\xdd\xe1\x8a\xbb\xc2\xe8\x8c\x05\xba\x57\x44\x43\xde\x15\xea\x27\xb5\xf0\xb1\x18\x7e\xc3\x84\xd8\xb8\xb2\x6d\xa1\xd2\x2b\xcc\xc7\x8d\x7a\xc0\x1e\x5e\xbc\x81\x08\x5f\x70\x8e\x28\x0b\x21\xab\xbc\x16\x7e\x8f\xe2\xfc\x51\x55\x90\xab\xef\x1e\x3e\xd2\x51\xbb\x4a\xbd\x16\x1e\x5c\x23\x5e\xd8\x2c\x9c\xbf\x49\xaa\x7b\x56\x0e\x13\x19\xcf\x57\x54\xfd\xae\xe0\x72\x76\x43\x91\xb8\x10\x01\x55\xfa\xfb\x8b\x97\xaf\x9f\x3c\x7d\xfd\xf4\x89\x2a\xef\x5d\x23\x52\x97\x58\x49\x4e\x88\xad\x9f\x70\x71\xa9\x30\x5c\xe3\x30\xe7\x4e\x8d\x27\x61\xce\x55\x31\x4f\xd3\x24\x75\xca\x9f\x8a\x6f\xaa\x82\x20\xad\x5d\xfc\x3c\x9c\xab\x42\x14\xcb\x4e\xf9\x0b\xf8\xa8\xaa\xa4\xfc\x9c\x7f\x74\x41\xa0\xf3\xa9\xaa\x92\x71\x37\x4c\xd8\x11\xcf\x75\x21\xd0\xc0\x2d\x87\x8f\xba\x0a\x70\xa7\x5b\x05\x3e\x42\xa4\x31\x1d\x19\x01\xa3\xde\xf8\x82\x96\x61\x09\xa1\x59\xf8\x8f\x88\x7f\x28\xd2\x0d\x3e\xdb\xe1\xcb\x80\x3f\xe2\xf7\x3c\xcd\x25\x22\x70\xa5\x3f\x4f\xa3\x59\x94\x47\x70\x1d\x1d\x8f\xe5\x28\x48\x8c\x05\xa8\xa9\x6c\xfa\x72\x79\x1d\xc8\x3f\x48\xfe\x3d\x72\xa5\x41\xc7\x0a\xee\x49\xf0\x2e\x96\x02\x3a\xa0\xbf\x30\x30\xca\xcb\x33\xfb\x56\x64\xad\x08\x66\x4f\x38\x9f\xe3\xbe\x23\xb9\x9c\xc4\x1c\x4b\xce\x6e\x41\x7a\x32\xce\x32\xb1\xe7\x9f\x28\x66\x7d\x13\x9e\x6b\xed\xff\xee\xdd\x17\x49\xce\xf7\xee\xde\x65\x6f\x26\x62\x7b\x56\xc2\x39\x89\xa7\x4b\xb5\x77\x65\x04\x36\x2a\x8e\x18\xce\x2c\x0f\xcf\x55\x27\x27\x92\xa3\x4f\x5a\xec\x44\xb0\xae\xf8\x17\x58\x54\xfc\x81\xcc\x26\xfe\x92\x2e\xf7\x2d\x26\x74\x52\xb9\x72\xbe\x82\x78\x67\xea\x2c\x93\x87\xe7\xd0\xc6\xa2\x94\x3a\xd5\x28\xaa\x7e\x8b\x99\x86\x24\xc6\x37\x40\x5f\x57\xc4\xb4\xf2\xb0\x50\x79\xfd\x98\x50\xb0\xd5\xeb\x14\x8a\x26\x3a\x10\x24\x33\x24\x62\x67\x4f\xbd\xd0\x3e\x63\x81\xec\xae\x7d\xba\xcc\xf9\x6f\xa8\xa1\xdc\xee\xcb\xe8\x47\xe6\x5b\x93\x5d\x5e\x92\xd0\x49\xb4\xd1\x4b\xcc\x00\x63\x35\xc2\x6f\x4d\x1a\x41\xbc\x18\xfc\xcb\x44\xf4\x56\x0e\x95\xca\xf1\xeb\x14\xe4\xe5\xbe\x09\x62\x06\x51\x30\x25\x78\x59\x66\x06\x66\x0b\xdf\x8d\xc7\x76\xdb\x04\x6c\x8a\xf9\x07\xa2\x76\xe8\xf0\x70\xcc\xfd\x8e\x71\xce\xea\x8e\xd6\xd2\xc3\xcc\x30\xe4\x66\xbb\x67\xcd\x18\xb7\xbf\xe8\x1d\x51\x8d\x72\x67\x87\x1d\x26\x3c\x1d\x61\x73\x1e\xc6\xe8\xf1\xd5\x3d\x01\x39\xd5\x41\x5e\x1e\x83\x6f\x5d\x9e\xb0\x59\x34\x9d\x46\x19\x1f\x25\xa8\xbb\x2b\x08\xcf\xe2\xf7\xe1\x34\x52\xf5\x04\xd3\x8e\x00\x26\xec\x3e\x27\x2f\xc2\x17\x27\x6d\x37\xa4\x55\x70\x4f\x71\xe9\x3d\x12\xff\x4e\x62\xa9\x76\xfd\x3d\xbb\x95\x9c\x0c\x38\xc5\xf5\xd5\x34\xc0\xaf\xad\x2d\x55\x38\xe3\x59\x16\x9e\x93\x72\xf9\x81\x82\xd7\x7b\x3e\x21\x8c\xde\xc7\x8b\x84\x81\xea\x38\x7e\xb9\x4f\xca\x00\x98\x3c\xcc\xd5\x97\x96\xbb\xa3\xca\x15\xdc\x32\xd0\xc2\x0c\xd7\x5b\x5b\x67\xcc\x96\x09\xb3\x6b\x3f\xb3\x42\xbc\x89\xf3\x5b\x9e\x60\xf7\xa6\x13\x8f\x54\x2d\x52\x50\x10\x07\x79\x8e\xdd\xc3\xf7\x00\x86\x0e\xa8\x4f\xed\x91\x30\x69\x4a\x7b\xe8\x13\x35\x96\xb6\x40\xf5\x88\xb6\x88\xb2\x57\x61\x9a\x47\xa1\xd0\xc8\xab\xe3\xca\xe9\x64\xa9\xb2\x8f\xcb\x4b\x16\x98\xfe\x8c\x2e\xdc\xd4\x71\xd3\x64\x88\x37\x31\xd5\x60\x6a\xd2\xcb\x11\x7e\x6d\x6d\xb1\xdb\xba\xf7\xba\xcb\x69\x67\x87\x3d\xce\xb2\xc5\x8c\xb3\xd1\x72\x34\x8d\x46\x6a\xa3\x97\xc2\x37\x9c\xb6\xc9\xd8\x40\x4e\xc2\x2b\x3e\x0c\x15\x70\xce\x73\xb5\xac\x69\xd2\x7c\x59\xcd\x83\x82\x06\xd0\x57\x11\xe1\x6c\x6c\x14\xc1\x2e\xfb\x25\xaa\xb8\x26\xc5\xce\x0e\x7b\xcd\x47\x8b\x34\x8b\xde\xf3\xe9\x52\xed\xcc\x7a\xef\x08\xb2\x45\x36\xe2\xf3\x3c\x3a\x9d\x4a\x7b\xd1\x74\x2a\x77\xae\xa9\x60\x55\x78\xad\xc7\x98\x8a\x45\x07\x56\x1e\x6b\xe7\xd0\x03\xb2\xae\xe8\x68\x20\x43\x39\x55\x46\xae\xe9\x0f\x18\x3b\x73\x8d\x48\x84\x1a\x0f\x72\xdb\xe7\xd0\xd5\xb9\xd5\x23\x1c\xa8\x14\x6c\x2a\xba\x2d\x4d\xd4\x37\x0f\xb4\x9c\x46\x2a\x6c\x82\x19\xd3\x53\x6a\xd1\xa4\xfe\xd1\xd7\x6c\xcc\x9e\xb3\xef\xe6\x9e\x11\xb5\x1e\x88\xac\x8e\xaa\x66\x1d\x8e\x05\xcc\xb6\xf9\xe2\x73\xab\xb5\x4a\xdd\x51\xd5\xb9\x4c\xb7\x6c\x7a\xc8\x36\x19\x3b\x99\x85\xf3\x13\x34\xf0\x64\xae\xf7\x75\x1d\x65\x79\x16\xce\x41\xc1\x13\xff\x9a\x83\x8f\xa3\x7b\x49\xc3\x12\xb5\x91\x7a\xba\xb2\xcd\xeb\x52\x0e\x05\xb3\x70\x5e\x65\xa1\xd1\xab\x44\xd7\x06\xb9\x84\xe2\x4b\xfc\x3a\x4b\xd2\xa7\xe1\x68\x62\xa8\x22\xed\xaa\xfa\x06\x46\xc1\x38\x96\x76\x9b\x01\xeb\x33\xfa\x20\x1b\xdc\xcf\x9a\xf5\x2f\xb9\x8d\xc0\x76\x26\xe9\xbb\xb5\x2f\xb8\xf5\x24\x65\x3c\x87\x49\x0a\x63\x15\x14\xe0\xcc\x38\x2f\xd4\x9a\x27\xa1\xef\x89\x79\x12\xff\xae\x33\x4f\xa6\x07\xdb\x6a\xaa\xa6\x47\xe8\x8c\xf5\xa7\x27\xe3\x39\x99\x1e\xf1\xcb\x3f\x3d\xe5\x33\x63\xc2\x03\xd5\x9d\x12\x83\xac\x67\x4a\x6e\xe4\x2e\xfa\xf1\x74\xfa\x1f\xbc\xd4\x28\xf5\xdd\x77\xbd\xcf\x1b\xc8\xfd\x2f\xea\x3a\xb8\xa6\xc5\xc1\x8a\x6d\x4e\xec\xdc\x02\xd4\x5c\x2a\x3f\x6e\xd8\xf4\xaf\xe0\xb4\xff\xed\xa4\xfe\xb5\x9c\xd4\x37\x8a\x97\x6b\x44\x5c\x6d\x4d\x9b\xc4\x31\x17\xcc\x2f\xdf\x11\x4a\x59\x51\x88\x5b\x7e\xfa\xee\x37\x75\xd7\xa0\x1a\x38\xa9\x73\x92\x7c\xe2\x83\x63\xc7\x4c\xcf\x27\x06\x8c\xac\x4f\x6f\x28\xa4\x2e\x6f\x1d\xac\xe5\x0f\xaf\x22\x5f\xf6\xf8\x5c\x09\x7a\x0d\x8b\x3c\x95\x82\xb2\xed\x6d\x2b\x25\x37\x5f\x92\x71\x59\x0f\xa4\x30\x16\xb6\xa1\xea\x01\x54\x8e\x62\xb9\xb8\xfc\x7e\xb1\x72\xea\xc4\x16\xbe\x32\x56\xb9\xf8\xff\x5a\xe7\x8d\x1a\x67\x0d\x72\xce\x10\xf4\x22\x75\xac\xb0\xe9\x15\xe7\x8e\xab\xc2\x2b\x12\x79\xb5\x53\x75\x22\x20\x65\x3a\xec\x38\xa2\xa4\xd0\xbe\x88\xe6\x32\x32\x87\xa6\xa4\xf7\xf1\x9a\x9e\x2f\x85\x6a\xc5\xcc\xc8\xed\xe2\x1f\x32\x6d\x34\x79\x24\x6b\x45\x12\xd7\xe5\x02\x35\xe9\xea\xaf\x67\xd6\xac\x29\x3b\x10\xb8\x4a\x3f\x41\x11\xd6\x40\x0f\xc8\x52\x0c\x54\x0f\x2d\x8d\x0b\xcc\x3b\x8d\xc0\x0e\xd4\xb2\x42\xb6\x33\xb6\x67\xc1\xd0\x2d\x0d\x34\x84\x61\x8b\x02\x37\x76\xf7\x8d\x1d\xf8\x90\xc9\xcd\xa0\xa9\x7f\x2d\x31\x63\x1d\xb0\xc0\x10\x1c\xb9\x06\x7f\x5c\x5e\xda\x21\xc9\x0b\xa3\xa9\x08\x45\xde\x24\x1d\xec\x69\xc2\xeb\x8f\xd6\xfa\x91\x3c\x69\x9d\xd9\x4f\x53\x1e\x5e\x58\x49\xfa\x14\xb3\x41\x98\x72\xc3\x79\xc0\x4a\x7d\xd6\x20\xcf\x3d\x1b\x56\xc8\x7b\x09\x5f\x08\x1a\xd5\xcc\x09\x72\x2f\x21\x49\x6b\x03\x01\x64\x71\x9c\xaa\x05\x46\x08\x52\x49\xf2\xdd\xce\x0e\x7b\x91\xc4\xea\xd2\x4c\x6d\x32\xda\x1d\x43\x6a\x10\xe3\xe8\x0c\x94\x23\x27\xf0\x8d\x98\xdd\x38\xc9\xa9\x15\x42\xca\x4c\xe8\x15\x25\x26\xfc\xb9\xb5\xa5\x71\x0a\xac\x31\x83\xf0\xc2\x3e\xb7\xb6\x58\xb1\x08\x96\x35\x6d\x7e\x3b\x90\xee\x9d\x9a\x02\x7d\xd6\x50\x7b\x57\x43\x5a\xda\xa0\x80\x04\xaa\x52\x9f\x08\x1c\xa6\xdc\x44\x35\x8d\x0a\x70\x64\x01\x85\x83\x9f\x56\xb0\xc1\x15\x8d\x4f\xef\xb7\x17\x14\x8a\xb4\xf8\xaa\xa1\xa3\xd3\x0d\xda\xa3\xa5\x6f\xee\x98\x28\xd4\xab\x5f\x56\x6b\xea\xbb\x26\x2d\xd4\x91\xbc\xba\x2b\xab\xaa\x9e\x6b\x5f\x94\xc3\xeb\x75\xbc\x0f\xa6\xc9\x19\x4e\xe8\xd3\x3c\x5e\xcc\x78\x0a\x3e\xcb\x3a\xc6\x41\x1c\xce\xd4\x3d\xa1\x44\x63\xcd\xf0\x0c\x5e\xad\x96\x04\x67\xa8\x3a\xf2\x69\xec\xca\xd1\x29\x86\x5f\x70\xf4\x1a\xea\x45\x63\xd3\x9e\x86\x68\xc8\x5a\x84\xd2\x25\x5e\x35\x06\xb6\x87\x31\x36\x77\x72\xc4\x90\xf6\x8b\xd2\x10\x0c\xbb\xbb\x0f\xeb\xe6\x00\xab\x17\xd7\xc8\x8c\x47\xea\xc2\xe6\xc3\xb3\xf8\x44\xe6\x82\x5a\x64\x1c\x5c\xa6\x4e\x04\x91\x7e\x86\x68\x2b\x50\x57\x92\x1f\xbf\xa0\x6b\xb1\x74\x64\xad\xe0\x21\x70\x00\xfa\x3c\x6c\x54\x38\x4b\x28\x7c\x0b\x47\x09\x85\x29\x2c\x17\x07\x0b\x0f\x1c\x32\xd0\x52\x50\x25\x63\xba\x69\xe6\xae\x60\x5f\x79\x42\x30\xb8\x7a\x1e\x58\xa8\x7a\x54\x56\xaa\x70\xea\x76\x66\x24\x08\xdb\x04\xad\xf6\x0c\x5b\xca\x5d\xd3\xea\x45\xe7\xba\x29\x0f\xd2\xf4\x4b\xd5\xaa\xd9\xfc\x25\x3e\xa0\xf7\x73\x34\xcd\x2b\x72\xdd\xa9\xa0\x12\x59\xbe\x38\xad\x76\xaf\x79\xf0\xd9\x1e\x41\xae\xb6\xc2\x2a\x36\x78\x96\x3d\x35\x6b\xc8\x36\x60\xf8\xaa\x00\x7c\x03\xbe\x80\x26\x8c\x22\x9f\x24\x19\x97\xde\x0b\xca\x2f\x02\x5d\x52\x33\x79\xbc\x39\x41\xbf\xd7\x13\x15\xfb\x41\xa3\x85\x0f\xb3\x7e\xa1\xdb\x90\x1c\xe2\x39\xcf\xc9\x79\x48\x16\x57\xef\x32\x70\x6a\xb6\x77\x9a\x7f\xe5\xb6\x62\x2d\x33\x69\x42\x33\xc3\xbc\x5d\x18\xfa\x01\x61\xa1\x3d\x2d\x09\xac\x9d\xc6\xdc\x51\x29\x1f\x3d\xe7\x2c\x86\xd9\x5e\xae\x6e\x91\x8b\x6b\x19\x80\xad\xb8\x2c\x09\x73\x07\x2e\x32\xe6\xe2\xc5\x24\xea\x84\x12\xa7\x3f\x1f\xcf\xd8\xc9\x99\x64\x33\x65\xca\xbc\xf2\x99\xfc\x0d\x61\x3c\xab\x78\x5d\x37\x5e\x70\xb9\xd1\x8c\x8a\xf3\x12\xc2\xbd\x38\x9f\xcd\xf3\xa5\x74\x67\x54\x4c\x90\x89\x2d\x6b\x64\xbb\xed\x0e\xb1\x24\x8a\x47\x9c\xdd\x6f\x77\x77\xdb\x1d\xf8\x30\x0a\x73\x7e\x9e\xa4\x4b\xf6\x7b\x1e\x4d\x57\xb2\x81\xa7\x43\xf6\x6f\xfc\x63\x28\x76\x4a\xd9\xb9\x96\x30\xa0\x58\xb5\xf3\x68\xc6\xb3\xa0\xd7\x62\xc3\xb6\x66\x04\x41\x37\xa8\x2b\xd4\xeb\x64\xca\xdb\xd3\xe4\x1c\x5d\x2a\x21\xb0\xe9\x5d\x71\x0a\xe8\xff\xc8\x8e\x8f\x07\x2d\x76\x3c\x18\x94\x56\x86\xb4\xe0\x7d\xe9\x2d\x99\xc9\xa8\x2c\xaa\x35\x28\xc0\x6e\xa0\x59\x89\x40\x60\xa9\x38\xc7\x25\x81\xa3\x74\x75\xcf\xfc\x6d\x1e\xb2\x41\x08\xfa\x37\x82\x38\xa5\x92\xf5\x3b\xa2\xbb\xc8\x74\x9d\xa5\xba\xea\xf7\x9f\x2d\xd7\xa9\xca\x4a\xe3\xed\xb7\xdb\xb9\x7e\x4e\xd4\xbf\x9e\xd1\xbb\x4c\x3c\x97\x2b\x70\xb2\x02\xd4\xde\x9e\x46\x17\xbc\xf2\x49\x4d\xa5\x33\x7d\x51\x71\xd3\xa6\xd6\x28\x9e\xf0\x34\xca\xf9\x98\x1d\xcd\xf9\x28\x3a\x5b\x4a\xce\x8e\xe2\x73\x52\x66\xa3\x76\x6d\x65\xcb\xe7\x9a\xfd\x5b\x74\xc1\x41\xbf\x92\xd7\x73\xba\x53\x6a\x7a\xb5\xd3\x45\xe2\x4d\x91\xc9\x88\xf8\x38\x3d\x17\xfb\x07\x56\x83\x8c\x87\x9a\xe9\x0b\x75\x05\xef\x5a\x95\x6f\x63\x7b\x9a\x28\xd1\x6d\xf3\x06\xdf\x62\xfa\xda\xc8\x04\x8a\xd8\x9c\x24\x25\xb4\x41\x64\x17\xd1\x1c\xd6\x02\xcf\xd4\x30\x30\xf0\xa7\x80\x02\x7f\x00\x10\x9d\xd9\xb0\x70\x89\x46\x01\x1c\x98\xe5\x8f\xdd\x28\x73\xb1\xf4\x85\x6d\xb2\x3d\x92\x58\x5c\x3b\xb2\x23\x2c\x6a\x13\x86\x14\xe3\xca\x4a\xab\x54\x25\xea\xb3\x1e\x18\x06\xb8\xbc\xf4\xda\x63\xc9\x95\xaa\x63\xd9\xa0\x18\x6f\x6d\xb1\x80\x18\x2b\x84\x90\xc5\x30\xc3\xec\x7b\x88\x68\x49\xd6\xc0\x49\xa8\x66\x4e\x62\x7a\x22\x30\xc3\x4c\xde\x6c\x96\x8c\x79\x9b\x02\x52\x96\x27\xac\xda\xb0\x7d\xc3\xd0\x1e\x34\xe6\xed\x77\x19\xeb\xb4\xbb\x1d\xb7\xab\x38\x89\xb7\xd1\x3c\x6a\xd6\x38\x13\x6a\x3f\x30\x41\x66\x75\x14\x98\x69\x0e\x54\xa7\x09\xf8\xcd\xc1\x8b\x5a\xf5\x69\x1e\xa6\x3c\xce\x1b\xcd\x66\x11\x93\x57\x93\x30\xce\x93\xd9\xbf\x1f\xb1\x5e\x5d\x44\x84\x8c\x1a\xcb\x0d\xca\xc5\x06\x58\x92\x62\x83\x58\x5b\xd8\x18\xaf\xb9\xc2\x67\xf4\xf9\xf3\x22\x7a\x74\x11\xcd\x99\x8b\x8e\xd5\xbd\x94\xeb\xf8\x50\x4d\xbe\x74\x20\x66\x45\xd7\xa0\x84\x91\xce\xd5\x73\xf2\x82\x3b\x47\x95\x75\xc8\x12\x10\x9e\x9d\xb4\xce\x73\x06\x5b\x13\xaa\x0a\x3b\x0c\xea\xc6\x49\xe5\x93\x1a\xf2\x9e\x46\xc0\x4b\x52\x36\x0b\x3f\x4a\x69\x27\x57\xda\xea\x08\xc5\xea\x66\x30\x06\x7c\xf0\x17\x48\x7b\xd8\xd1\xf3\x44\x3e\x9c\x61\x27\xaa\xd7\xb2\xb3\xb2\xc6\x6a\xed\x67\x37\x55\x22\x1b\x27\xc4\x77\x18\x46\x99\x13\xb7\x74\xc7\x6b\x38\x00\xc4\x4d\xff\x4b\x99\xd8\xb9\xf1\xd7\xf7\xfd\xaa\x0f\xbc\x56\x6a\xee\xd7\xe7\x1a\x8d\xaa\x87\x63\x36\x77\x02\x92\x87\xec\xf2\xe4\xf1\x3a\x74\xa7\x0a\xf5\x2c\x18\xb8\xa4\xee\xfd\xfb\xcd\x1b\x4f\xca\x5e\x3f\xca\xb6\x6e\x74\x0d\x95\x62\x83\x80\xda\x31\x91\xf2\x27\x26\xd7\x6b\x31\x84\xb6\xbb\x8b\x53\xc5\x9b\x12\x57\x15\x6f\x6d\x91\xd9\x51\x1f\x4d\x92\xe6\xaa\xc8\xd6\xba\x2b\x0f\xcf\xac\xeb\x62\xe5\x3b\x6f\x91\xeb\xe9\x1b\x3c\x65\x15\x09\x6e\xba\x71\xcf\x56\x85\xe3\xd4\xcf\xa2\xaa\x75\x66\x82\xc6\x2d\x3c\xfd\x0c\x8a\xc7\x1f\x68\x60\x1f\x7f\x2a\x7c\xf1\x74\x8b\x22\x45\x1f\x6d\x1e\xab\x79\x9d\x55\xa8\x2f\xc6\xfd\xc7\x90\xee\xbf\x76\xb9\x62\xe7\x3a\x55\xb9\xfb\x1c\x49\x55\xf8\xfc\xcf\xbb\x20\x65\x80\x5d\xae\xb6\x9a\x9b\x7a\x01\x66\x72\xa4\x93\x2a\x48\xc9\x2f\xf8\x48\xec\x03\x0f\x2f\x9e\x17\x46\xf2\x07\x7e\xfd\x4c\xcf\xc4\x24\x89\xa7\x49\x98\xef\xf6\x5c\x2a\xe3\x57\x6b\xba\xa1\xe6\xc3\xfb\xbe\x9a\x0f\xef\x5b\x35\xa3\x38\x7f\xe4\x54\x7b\xa6\xfc\x45\x49\x9d\xee\xc3\x62\xa5\xee\x43\xb7\x56\x01\xb7\x67\xb1\x8b\xd9\xc2\xd3\xa1\xf1\x50\xb5\x6a\x1d\x4e\xc3\xd9\x9c\x8f\x7d\x95\x65\x51\xa1\x4d\x01\xcd\xdf\xa3\x02\x9e\x0b\x1f\xa2\xbf\x47\x04\x53\xe7\x64\x1f\x8d\x79\x9c\x8b\xa3\xad\xfd\xe2\x4a\xfa\x82\x08\xcd\x8b\x6a\xda\x6a\xd9\xe6\xfa\x34\xf7\x26\x3c\x17\x12\xed\xd3\xd5\xfe\x2d\xfb\xe3\xb1\x99\xd0\x81\x0c\xd6\xe3\x16\xc2\x1c\x0e\x58\xdf\x6d\x29\xa9\xe8\x69\xa6\xa8\xe0\x6f\x54\xd6\xd9\xc2\x00\x74\x5b\x39\x73\x51\xd2\xb8\xac\xcf\x85\xd5\x29\x38\xad\x38\x35\xa4\x7c\xf3\xc0\x55\x52\xcd\x03\xd6\x5e\x5e\x9e\xb6\x52\xe0\x79\x9a\x92\xc5\xe6\x69\x27\xc5\xa0\xa7\x9d\x92\x80\xbe\xa9\x42\xd9\xe7\x69\x84\x22\xcf\xd3\x44\x8b\x3b\x4f\x23\x2d\xe7\x3c\xed\xb4\x80\xf3\xb4\x43\xc9\xe6\x69\xa4\xa5\x9a\xa7\x91\x11\x67\x03\x73\x77\x5f\x57\x05\x34\x26\x0b\x73\xf0\x51\x87\x66\x3b\xff\xd8\x17\x4d\xb9\x42\x16\x64\xa5\x7f\x1f\x2a\x6f\x05\xbb\xcb\x6a\x45\xd1\x52\x0d\x2c\x33\x0a\xa8\x91\xb7\x6f\xbb\xdc\xe8\xea\x95\x25\x76\x5f\x17\x21\x8f\xf2\xb3\x99\xe7\xf1\xce\x5d\xf6\xc7\xd3\x9f\x5e\x3d\x3e\xfc\x0f\xf6\x8f\xc7\xaf\xd9\xb3\x17\xff\xfe\xf4\xf0\xcd\xb3\x97\x2f\xd8\xdd\x1d\x17\x5a\x93\x7d\x82\xf4\x46\x29\xe7\xbf\x4c\x93\xd3\xb0\xec\xd5\x7e\xef\x91\xf6\x53\x7e\x82\x59\x2d\x44\x13\x71\xac\x8b\xd0\x26\x23\x91\x3a\x31\x19\x93\x52\xce\x9f\xea\x31\x4b\xe7\x13\x4d\x84\x3e\x6b\xe0\x02\x00\xd7\x13\xf5\x59\x50\x55\xfe\xdd\x8e\x93\x31\x57\x16\x0c\xf9\xad\x12\x01\x1c\x8f\xdd\xff\x73\xf8\x26\x38\x9e\x20\xb3\xb5\xa5\xb0\x99\xc9\x62\x1b\x19\xf9\x55\xe0\x22\xa7\x8e\xa2\x82\x9f\x6c\x4c\x20\xe4\x44\x32\x5f\x4c\xc3\x94\x1d\x26\xb3\x59\x12\xff\xfb\x11\xe3\x1f\x73\x1e\x83\xd7\xf2\x89\xcd\x01\x06\x45\xfc\x6e\x88\x44\x50\xde\xda\x22\xbf\x0c\xef\xf4\xad\xa1\x54\xd2\x63\x9e\x26\x23\x9e\x65\x27\x18\xbd\x50\xae\x57\x8b\x3a\xaf\xb0\x06\xeb\x3b\x88\xc8\xbe\x91\x1f\xda\x12\x8e\xb3\x5d\x86\x23\x68\x7a\x16\x66\x39\x4f\xb5\x34\x98\xf0\xe9\x9c\xa7\xe4\xa2\x32\x19\x73\x71\x22\xf1\x24\xd3\xc9\xd3\xa5\xe3\x46\x4a\x30\x92\x18\xc8\x9f\xed\xd3\x28\x86\x7c\x3d\xfe\xcf\x41\x63\x91\x47\x53\xe9\x4d\xc6\x46\x90\x51\x2d\x10\x8c\x7d\xa5\x32\xe5\x14\x56\xa0\xc2\x6b\xbf\x72\xad\x5c\xa1\xfd\xb2\x6a\xb9\x05\xdd\xef\xee\x37\xd5\x52\x6a\x36\x0b\xeb\x78\x73\xdf\xa4\x28\x7b\xa5\x9f\xf7\x97\x5c\xe4\x3c\x52\xc7\x18\xbc\x8f\xac\xf2\x61\x7a\x74\xff\x2f\x7e\x45\x52\xbd\x57\x5d\x80\xe3\x0c\x7a\xc9\x8c\x13\x9e\xc5\x8d\x5c\xbd\x0b\x9d\x87\xa9\x7a\x5a\x9c\xb1\x30\x63\x63\x1e\x67\xfe\xa8\x44\x9f\xdf\x59\xca\xb3\x41\x15\xdc\xa3\x64\x22\x30\x3d\xf9\xda\xad\xc3\x5e\x35\x66\xca\xe9\x5d\x75\xc1\x91\x18\x6f\xb8\x5d\x63\xbe\x7d\xc9\x4d\xad\xfa\x5e\xbf\x6a\xe3\xdb\x02\xfb\x9f\x00\x72\xdb\x75\xe9\xbc\x39\xbb\xae\xa2\x8a\x67\x77\xac\xe3\xd8\x65\x47\x21\xbb\x41\x46\x2f\x0d\x7a\x35\x8d\x2e\xf8\x74\xc9\x42\x66\xe2\x71\x48\x5f\xd5\x2f\xaa\x16\x99\xc4\x88\xd5\x31\x45\x0d\x67\x39\xd1\xe9\xa4\x07\x2d\x22\xa3\xc2\xfe\xfa\xfc\x6d\xe7\x92\x4e\xca\x43\xd5\xef\x56\x2a\xbe\x1a\x1a\x42\x32\x3b\x42\x66\x30\xf8\x4a\x6e\x30\xb1\x43\xe7\x58\xe4\x8f\x1d\xfa\x8a\xcc\x87\xcb\x19\x9b\x3b\x2f\x25\xef\x79\x8a\x77\x85\xde\x3b\xe6\xfb\x32\xda\xcf\x67\xf7\xee\x91\x52\x5c\xa2\x13\x48\x5e\x44\xb7\xc8\x97\xda\xc3\xbf\xb8\xb3\xe9\xc6\x1e\xea\xd4\x71\x0a\xa9\xa6\x8e\x32\x56\x94\xee\x2f\x0f\xd7\x48\x86\xfc\x2a\x4d\x66\x51\x56\xbe\xad\x29\xff\x84\x8a\xa4\x43\x8f\x94\x1f\x81\xb4\xcc\x94\xd6\x53\xfe\x0b\xf5\x6d\x82\xb5\xf3\xb9\xae\x65\xe7\xab\xb4\x8e\xd5\x30\x7d\xcd\x91\x66\x4e\x1d\x49\xc9\x5a\xc6\xaf\x7a\x96\xad\x75\x63\x1a\xa9\x34\x8b\xe1\x3c\x6b\x89\xfe\xb3\x16\x38\x4d\x8a\xce\xc4\x37\x3d\x7e\x05\x57\x48\x05\x9d\x4d\x55\xa7\x97\x54\xe0\x4d\x9c\x2e\x7f\xbd\xe7\xe1\xbc\x69\xd1\xc3\x5f\x4d\x92\xc5\x84\xf2\xf2\x57\x3b\xe2\xea\xa9\x95\xa4\x8d\xbf\x9a\x24\x91\x2f\x74\x70\x21\x4a\xcf\x4d\x78\x61\x68\xc9\xaf\x62\x02\x51\xcd\xa2\x10\x41\x49\x3b\xcb\xe1\x8c\x19\x3e\xdf\x87\x14\x52\x3f\x87\xd3\xe9\x69\x38\xba\x00\xe1\x04\xf1\x47\xdf\x47\xfc\x43\xd6\xf2\xce\x18\x7c\x14\x0a\xc2\xb3\xa7\xac\xdb\x85\xcf\x92\xce\xf0\x55\x69\xfb\x3f\xb0\x87\xed\x5b\xe0\x03\xa0\xc5\xc2\xd6\x96\x44\x01\x42\xad\xa8\xcf\xf0\x83\x58\x44\x83\x6e\xb3\xd9\x14\xba\x03\xe1\x32\x7d\xcb\x0c\x19\xdb\x6c\x38\x82\xea\xa2\x3a\x2e\x1e\x53\x53\x09\x10\x53\x5b\x7e\x69\xcb\x0c\xbf\x01\x76\x63\x16\x8d\x69\x2b\x84\x8a\xdd\x8b\x60\x03\x51\x1b\x57\x8f\xa9\xa9\x44\x8b\x5d\x5b\x71\x83\x68\x61\x96\x94\x54\xa2\xf4\x34\xf8\x1f\x2e\x5b\xaa\x59\xc1\x6a\x60\x9e\xb3\xc8\x9d\x58\x27\x44\x21\x02\xe2\xa0\xb8\x2d\x17\xa3\x7f\x89\xff\x46\x94\x97\x01\xe0\x81\x61\x69\x7c\x65\x83\x59\x45\xcd\xb3\x2c\xdd\xc2\x68\x73\x2a\x06\x91\xaf\xcc\x09\x47\x64\x16\xcf\x9e\xda\xd8\xc9\x34\xef\xdb\x8d\xac\x15\xae\xeb\xe3\x3c\x3b\x55\x0b\x2b\x7d\x8f\xb8\x53\xca\xe9\x75\x9a\x58\x2b\x5e\x57\xcf\xe4\xb2\xb0\xaa\x16\x56\xbe\xae\x6e\x26\xd7\x0e\x0d\x72\x45\xd5\x70\x92\x8b\xa6\xf4\xa1\x82\x37\xe2\xc4\xa3\xcd\x1d\xfd\xce\x79\xae\x33\x3c\xfb\x76\xaa\x87\x6a\x1f\xad\x11\x9a\xa2\x4a\xad\xc9\x27\x61\x0e\x4f\xa0\xde\xf3\x34\x3a\x8b\x50\xee\x9f\x72\x37\x85\x2e\x51\x11\x34\x66\x81\xe8\xba\xc5\x1a\xaa\xac\xe1\xd5\x5d\x54\xa9\x87\x4a\x9b\xc7\xa4\xfc\xca\xa8\x64\x74\x9f\x02\x91\x64\x91\x9f\x46\xb2\xd0\x43\xa2\xcd\xbd\x16\xbe\x32\x12\xa1\xda\x57\x20\xcf\x11\xcf\xfd\xa4\xf1\x46\xac\x7e\x74\x23\x89\x44\xbe\x26\xb2\x18\x4d\xb7\x40\x1a\x59\xe4\x27\x8f\x2c\x2c\x92\xe8\xfb\xcd\x6e\xda\xef\x2c\x64\xb8\xae\x51\x7e\x47\x00\x97\x27\x15\xdc\x88\x94\x05\xc1\x18\xd1\xee\x0c\x87\x3c\x43\xb3\xe6\x9d\x96\x3c\x73\x4e\x17\x7c\x0f\xae\x8d\x6e\x5d\x35\xa5\xfe\x39\x94\x67\x4a\x6d\x39\x56\x31\x65\xfb\x7d\x76\x47\x21\x79\x87\xd8\x72\x65\x2c\x4c\xf4\x08\x82\x73\x68\x9f\xdd\x41\x37\xfa\x3b\xec\xc0\x78\x3e\x05\xc9\xe9\xbb\x26\xfb\xa4\x83\xb6\xe9\xc7\x95\xfb\xec\x8a\x3c\x20\x70\xeb\x25\xa7\xef\x0a\x9d\x79\x90\x49\x4e\xdf\x59\x5b\xb2\xa8\x21\x2b\x63\x29\x24\xce\x28\xc4\xed\x3c\x30\xa8\xee\xd9\x28\xed\xdf\xba\xa5\x0c\xe2\x63\x7e\x16\xa2\xca\x30\x02\x3f\xe1\xc7\x71\x34\x0b\x73\xfe\x3c\x8c\xc3\x73\x08\xa0\x07\x74\xcb\x78\xfe\x3a\x3c\x7b\x13\xcd\x78\xb2\x28\x3d\x36\x7d\xdf\x6d\x7a\xeb\xf7\x44\x03\x08\x7d\x96\xcc\x5f\x63\xf5\x27\xd8\x6b\x60\x57\x14\xcd\x35\xa9\x4a\x5a\x78\x09\x28\x08\x64\x38\x80\x1d\xc0\xf7\x3d\xf6\x89\xc9\xd1\x41\xbe\x65\x76\xb5\xcf\xae\x68\x07\xb9\x8c\x27\x13\xa6\x29\x01\x09\xdf\xda\xca\xe1\x17\xca\x0e\x58\x98\x0a\x45\x08\x8b\xce\xd2\x64\x06\xdf\x6d\x70\x3e\xf2\x91\x14\xef\xa3\x45\x9a\x1e\xe5\x4b\xb8\x37\xc0\xac\x9b\x68\xad\x8c\xc7\x53\x7e\x38\x09\xe3\x73\x4e\x14\x3b\xeb\x7b\xe0\x1a\xe7\x16\xd3\xa9\xd4\x09\xe4\x53\xfc\x49\xb2\x98\x8e\x8f\xf2\x64\x4e\x6e\xe1\x64\x11\xcf\x55\xa7\x34\x92\x0e\x7c\x0b\x86\x99\xf8\x87\x1a\xe8\x0c\x24\x37\xc4\x81\x32\xb4\xe9\xaa\x36\x99\x24\x28\xd3\x0a\x0c\x8d\xf8\xb5\x6d\x87\xa4\x76\x61\x6a\xa8\x2a\x1c\xc2\x72\x8a\xaf\x0b\xe0\xaf\x7d\x5a\x36\x34\x85\x6a\xee\xf0\x0b\xd1\x6e\x19\x50\x5a\xb7\xcf\x8e\x3b\x03\x5a\x98\xf2\x0c\x47\x6f\xba\xc8\xda\xd9\x34\x1a\xf1\xa0\x6b\xc7\x9f\x93\x0b\x06\xa1\x91\xdc\x36\x74\x1c\x41\xa7\xe5\xf2\xba\x5a\x50\xcd\x40\xd1\x19\x6e\x14\x20\xe3\x6a\x8b\x74\xdf\x6c\x01\x68\xd3\x67\x29\x55\xf4\x7c\xc9\xfa\x9b\x77\xed\x04\x5b\x2b\xcc\xad\x1a\x3b\xd2\x07\x47\xaf\x0f\x01\x0d\x76\x60\xfd\xda\x53\x52\xd5\x30\x41\x9f\xdc\x7d\x19\x72\xd1\x15\xa0\x26\x17\x4b\x2c\x6e\xd7\xd5\x9a\x05\xbc\x3c\x68\x69\xa3\xa0\xe9\x07\x8b\x03\x6a\x1b\xa6\xf6\xc0\x4f\xd2\x59\x27\x99\x13\xb9\x2c\x7e\x06\xe4\x60\x42\x57\x14\x89\x84\xae\x1c\x7d\xc2\x34\xb7\x1a\x87\x69\x1e\x58\x8b\x89\x79\x17\xa5\x33\x9f\x19\x1d\xa5\x04\xbd\x38\xcd\x46\x69\x74\xca\x29\x78\xf5\x2d\x18\x52\x42\x99\xae\x1c\x21\x62\xd5\xd2\xec\xa5\xee\xc3\xf4\x4e\x44\xf9\x78\x2d\x31\x64\xc1\x53\xc2\x48\xf2\xac\x66\x5e\x8b\xf8\x57\x05\xe5\x60\xb3\x9b\xe8\x1b\x57\x0e\x8a\x9b\xa1\xb5\xb2\xd4\xae\x96\x86\x67\xa5\x16\x5c\xb3\xf7\xa5\xe1\x59\xd5\x8e\x97\x86\x67\x5f\x76\x9f\xb3\x86\x12\x8c\xa4\xc9\x86\xe4\xfb\xd2\xbb\xba\xfb\x02\x82\xfd\xc8\xba\xa2\x5b\xfd\xfd\xb8\xeb\x64\x91\x84\xad\x91\x14\x42\x6a\x36\xb2\xe3\x89\x5e\xc1\x37\xdb\xec\x48\xb0\x2e\x7e\x9f\x8f\x31\xc7\xa3\xc1\x92\x7c\x0f\xe2\xe4\x03\xdd\x96\x34\xa4\x1f\x58\xc7\x96\x27\x12\x7e\x9c\x7c\x28\x08\x8b\x38\xf9\xc0\xb6\x4d\xa5\x1f\xd5\x38\x09\x00\x49\x0a\xe8\x6e\xbf\x08\x75\xbb\x2b\x81\xe2\x95\xc7\x27\x2a\x79\xc5\x24\x13\x79\x4b\x90\x2f\xc8\x9d\xd5\xf5\x8b\xeb\x63\xb3\x1b\xde\x5a\x9e\x1a\xf2\x06\xbe\xc9\x3e\xed\xec\xb0\x5f\x78\x0c\x3e\xef\x63\x76\xba\x64\x87\xc9\xd9\x19\xe7\x47\xa3\x34\x9a\xe7\xac\xdb\xee\xf6\xda\xbd\x5b\xee\x45\xbb\x3e\xc2\xc4\xc9\x11\x46\x0a\x6e\xb1\x49\x2a\x48\xdc\x62\xd3\x24\x1c\xbf\x81\xbf\x10\xe3\xdf\xf4\xef\x38\x19\x93\x5f\x8b\xb9\xf8\x57\x07\x89\x52\xe2\x7d\xce\xd3\xb3\x24\x9d\x85\xf1\x08\x13\xc2\xdd\xd1\xdc\x06\xca\xb0\x5b\x8c\x2f\x6f\xed\x82\x36\x61\xa0\xc2\x91\xc5\x19\x09\x11\x66\x0e\x04\xbd\x85\xa0\x0f\x00\x30\x81\x85\xa8\xf4\x2b\xf0\x21\x49\x8a\x0c\x82\xd2\xc3\x00\xe9\x74\x0d\xfc\x02\x9b\xe2\x41\x93\x6d\x5b\x24\x6d\xb2\x1d\xd6\xe5\x0f\x09\xd6\x4c\x4e\x0a\xeb\x3b\xbd\x63\xa1\x0d\xcf\xdf\x37\xa8\xa9\x3a\x80\xed\x44\xa8\x56\x08\x22\x70\x63\xb6\x4e\xd2\xe3\xce\x80\xdd\x65\x5d\xfe\x3d\xbb\x27\x7e\x75\x07\x16\x2a\x36\x37\xa8\xa3\x26\x19\x0e\x56\x43\xb6\x20\x18\x2f\xe6\xd8\x1d\x82\xc6\x4a\x74\xd8\xda\xd5\x44\x7f\xd8\xd6\xbc\x65\x4d\xdc\x93\x30\xbf\x2e\x6b\xa8\xa6\x40\x73\xc5\xe0\xd6\xe8\xa6\x06\x1b\x53\x99\x20\xb0\x76\x97\xd2\xd6\xcd\x03\xc8\xb0\xf7\x06\x49\xb0\xba\x73\x5f\x33\xbc\xbd\xbf\x75\xd5\xc4\x3b\xf7\x7c\x12\x65\x60\x39\xd8\xf9\x1b\xcb\xc0\x66\xfb\x3c\x9c\xcf\xa3\xf8\xfc\xf7\xd7\xbf\xf5\xc9\x22\xd8\x8e\x93\x0f\xed\x77\x59\x7b\x16\xce\x37\x76\x69\xd9\xf5\x38\xb2\x7c\xbf\x59\x2c\x95\xcf\xa6\x06\x64\x93\x70\x3a\x4d\x3e\x40\x64\x44\xd6\xb7\x52\x57\xc0\x0e\x1f\x65\xaf\xa6\x61\x14\x63\x7f\xbd\x52\x95\xa0\xd7\xf4\x36\xd8\xad\x50\x0e\x6c\xc8\xa4\x3d\xe0\x52\xd6\xd5\xfd\x87\x6e\xcd\xea\x3e\x10\x18\x69\x03\x67\xa9\x32\xe8\x18\x66\x86\xd6\xac\x86\x8e\xc0\xbe\x99\x5c\x0a\x26\x97\x2f\xa8\xf2\x11\x06\x16\x60\x1f\x43\xdc\xb9\x9f\xac\xc0\x15\x8f\x31\xde\x9b\xfe\x5c\xc8\xfc\x74\xe5\x6e\xcc\xba\x51\x9d\xc3\xa0\xa8\x0c\xf7\x64\xc4\x0d\x12\x9d\x34\x1e\xeb\x44\xae\x10\xce\xcd\x00\xff\x69\x1d\xe0\x3f\xf9\x81\xff\x64\xb2\xc4\x96\xc6\x93\xbc\xa5\x23\x44\x66\x8f\x8d\x43\xce\x85\xf4\x76\x7a\xdc\xdc\x27\x15\x7e\x2a\x56\xf8\xa9\xa9\x55\x16\x00\xa1\x94\x65\x81\x0d\x34\x71\x0c\x1e\xa5\x08\x9c\xfe\xea\xfa\xaa\x39\x0e\x52\x70\x7a\x97\x3d\x12\x3f\xab\x88\xf5\x59\x67\x9f\x45\xec\x07\x46\x11\xd8\x67\xd1\xbd\x7b\x4e\x08\xcc\xc7\x32\x1a\xd0\xe3\xe3\x88\xc6\x48\x14\xc3\x3c\x16\xc5\x03\xcd\x04\xf8\x93\x28\xc7\x49\x9c\x47\xb1\xc9\x01\x06\xff\xec\xec\xa8\x00\xba\x10\xcc\x0e\x3d\x51\x30\x7a\x42\x92\x4a\x3a\x19\x2b\x82\xd0\x7b\x95\xc4\x30\xba\xaf\xe9\xdb\x35\x17\x95\x37\xd0\xd8\x49\x0e\xc2\x9f\x94\xf0\xa6\x52\xa9\xb9\xc9\xc9\x0b\x60\xd4\x02\xd5\x31\x4a\x4e\x1f\xa6\x2d\x4a\xa2\x7a\x19\x07\xa8\xbe\x88\xe0\xe9\x16\xb0\x06\x39\x4a\x9b\x51\xa2\x7c\xee\x21\xdc\x76\x78\x35\x50\x4c\x65\x4d\x09\x7c\x19\x58\xf3\x81\x9f\x56\x07\x4c\xbd\xe5\x88\x1f\x8f\x34\x3b\xc4\x38\x92\x81\x8a\x24\xd8\x62\x31\xff\x98\x43\x10\x51\xfc\xf3\x28\xd7\xa9\xf5\x24\xac\xdb\x96\x20\xd4\xd9\x31\xe7\xa6\x0d\x34\x47\x12\xfa\xeb\x66\x02\x28\x85\xef\xe2\x26\x4e\x72\x02\xb5\x24\xe6\x71\xae\xce\xaf\xab\x10\x73\x86\x84\x89\x5a\xbd\xad\x44\x77\x3b\x77\x19\xcf\xa6\x51\x9c\x6f\x8f\xa3\x4c\x3e\xdc\xdf\x06\x87\x8f\xed\x94\x87\x59\x16\x9d\xc7\x96\x1b\xde\x7c\x91\xf2\xd7\x3c\x1e\xf3\xf4\x09\x1f\x25\xb0\x8d\x42\x24\x50\x40\x11\xf1\xd0\x3f\x49\xa2\x11\xef\x58\x58\xdf\x3f\x46\x81\x57\x89\xbe\x44\x7f\xfa\x6c\x2b\x1e\xf4\xf6\x0b\xaa\xe1\x17\xf3\xb9\xab\x13\xb1\xeb\x9c\xe7\xd4\x5f\xda\x71\x9f\xa3\xa5\x2f\xcf\x2a\x1d\xe9\x68\x55\xcf\x9d\xd9\xe6\xae\x74\xe0\x1b\x5c\xee\xb2\xd6\xbd\x7f\x9f\xb8\xac\x3d\x13\x6a\x48\xc6\x91\x69\xca\x2e\x75\x1e\x92\x06\xaf\x79\x56\x7a\x17\xa9\x21\x8f\xc2\x2c\x7f\xac\xc2\x27\xbc\x54\xa1\xaf\x7c\x6d\x1e\x75\x3b\x2b\x82\x55\xca\x34\xfa\xf2\xbd\x9c\xbe\xcb\x8c\xe2\xd1\x74\x31\xe6\x63\x16\xc5\x2c\x9c\x4e\xd9\x79\xf4\x9e\xcb\x56\x10\x1d\x61\x91\x45\xf1\x39\x3b\x3e\x39\x0a\x67\x1c\xc2\xd5\xfe\x37\x4f\x93\x93\x41\x20\xf3\xf1\xd4\xce\xc5\x93\x85\x33\x0e\x7d\xff\xc9\xd3\xa4\x29\x20\x8b\x4d\x18\x22\x87\x46\xf9\xd2\x0e\x9c\x0f\xae\xdc\xe9\x98\xa7\xe0\xd9\x44\x6e\x60\x75\x60\x03\x12\x02\x5a\x80\xd2\x91\xce\xc1\xe8\x92\x4f\x38\x3b\x8b\xd2\x2c\x5f\x33\x28\x56\xa7\xdd\x75\x5f\x6b\x03\xf1\xa9\x53\x58\xbb\xdd\xb6\xf2\xac\x66\x24\xd1\xaa\x0c\xfb\x20\xb6\xf5\x1a\xa9\x19\xc4\xe1\xd2\x64\x83\xd0\xec\xa3\xf3\xe6\xf9\x9f\x7f\x47\x84\xcf\x82\xe3\x5e\x8b\x75\x07\x2d\x26\xfe\xdd\xb5\x62\x5f\x1d\xf7\x06\xda\xe5\x2c\xb2\x59\x53\x31\x9f\x59\x15\x32\xf0\x96\x36\x46\xcd\xc2\xf9\x1c\x82\x3b\xab\x15\x20\x6b\xb4\x7c\xfc\x48\x43\xaf\x05\xd8\x52\x29\x13\x5b\x5b\x12\x94\x13\xa6\xab\x33\xc0\x48\x23\x07\x85\x95\x23\x01\x60\xf1\x1e\xc6\xe5\xf2\x2e\x7e\x3a\x26\xcf\xe2\xdf\xdc\x67\x47\xe5\x38\x2e\x75\x2e\x55\x4b\x14\xc6\xf4\x0c\x17\x51\xe9\xab\x8e\xef\xbf\xf3\xd5\xfe\x23\x2a\x7d\xd0\xfe\xa8\xd3\xa3\x2d\xea\x4a\xa1\xdf\xe3\x30\x2d\x8b\xbe\xd5\xeb\xf6\xb4\x54\xc1\x34\xc7\xa5\x63\x7b\xf0\x85\x5c\xa8\x9f\x47\x82\x21\x9f\x87\xf9\xa4\x3d\x8b\xe2\x5a\x6f\x48\x24\x20\x86\xa1\xb4\xec\xf5\x70\xd2\x72\xc3\xbe\x28\x31\xe3\x89\xfc\xd2\x92\x22\x70\x34\xe2\xf3\xdc\x96\x94\xde\xc5\xbc\x22\xeb\xb2\x6c\x53\x21\x0b\x0a\x81\x5f\x8e\x15\x56\x28\x42\x34\x8e\x34\xf4\x8b\x4c\x9d\x5c\x06\x01\xa5\xa6\xd8\xf5\x11\x86\xf9\x5d\x0e\xa5\xb6\x4c\xca\x26\x10\xee\xdc\x9b\x42\xa6\xb0\x70\x95\x84\x50\xa3\x68\x11\x5c\x68\x80\x19\xbd\x4e\x08\xaa\x07\x9e\x65\xb1\x67\x7f\xf3\x67\x74\x16\xa2\xa4\x98\x66\xe1\x37\xbb\x4e\xb1\x82\x0a\x68\xa7\xeb\xb6\xf4\x2d\xc6\x68\x02\xc8\xe9\x2c\x83\x32\xdc\xbe\xaa\x30\x0b\x3f\x6a\xe8\xcf\xe2\xb3\x28\x8e\xf2\x65\x21\x54\xce\xf1\x80\x06\xc9\x51\xfd\xd9\x29\x15\x64\x42\x6a\x35\x0c\x55\x89\x64\x55\xd0\x78\x6e\x6d\x39\x91\x7a\xb4\x54\x28\x48\xe8\x96\x11\x02\x81\x6e\x63\x45\xc4\xa7\x03\xd0\x6b\x30\xa0\xa9\xb0\x5b\xa6\x8e\x6c\x89\x54\x31\x38\xb2\x3e\xbb\x4d\x66\x6f\x6b\x8b\xe9\xce\xc0\x0a\xa1\x2e\xbc\xfa\xac\xdb\xeb\xe0\x9d\x97\x01\x2f\x3f\xeb\xb8\xf6\x07\x4c\x7a\xf6\x82\xb4\xb5\x46\x8d\xd9\xb4\x65\x3d\x2b\xeb\x2d\x8e\xc6\xa1\x61\x67\xa0\x2f\xc6\x8a\x71\x8c\x32\xce\x85\xa8\x91\x43\x91\x55\x93\x45\xce\xd3\xbd\xf2\xcc\xdf\x02\x09\x2b\xe0\x1a\xfb\x81\x10\x87\xcc\xa6\x7c\x17\xc3\xac\xa4\xe0\xfa\x54\x28\x68\xb5\xc8\x31\x5b\x82\xa2\xd3\x81\x89\x8c\x24\x1d\x8f\xf7\x54\x6e\x24\x09\x15\x21\x06\x84\xd0\x97\x97\xf2\xb3\x38\x14\x76\x9a\xca\xc3\x18\x2f\x0a\xcd\x51\x57\x0c\x95\x5c\x2e\x1f\x68\x71\x0f\x25\x2d\x8d\x8e\x9d\x59\x40\xad\x4c\x1d\xb0\x58\x55\xb3\x16\xb2\x6e\x42\x8e\xbd\xbe\x05\xa5\x0e\xbf\x92\xb0\xdb\xdb\xaa\x12\x3d\x2d\xc3\xc5\xa6\xdc\x63\x5d\x1e\x33\xf7\xe0\x32\xf9\x82\x28\x27\x08\x3b\x23\x83\x3f\xfc\x43\x73\x86\xe7\x2e\xb8\x92\x81\xda\x10\xec\xeb\x7a\x65\xce\x41\xfe\x21\x37\xf6\xb7\xec\x7f\xc1\x0b\x88\xf3\x98\xb6\x16\xbf\xf1\xc9\x9d\xc6\xb5\x98\xac\xd4\xbc\xcb\x43\xde\xb8\xd6\xcb\xbc\x67\xd5\x1a\xd2\xe6\xfe\xba\xd8\xc9\x98\x7f\x7c\x59\x76\x93\xff\xdd\xf7\x34\xaa\x7a\x79\xc2\x28\xb1\x8b\xe3\xf4\x60\xee\x24\xb9\x81\x7a\x42\xb8\x41\x2c\x74\x8c\x70\x29\x14\xe5\x30\x96\x4b\x3d\x4f\x58\xc6\xc3\x74\x34\x81\xb7\xd4\x35\xb6\x6b\x54\xde\x89\xee\x5e\xb6\x5d\xdf\xbd\x62\x79\x98\x9e\xcb\xf4\x6b\xfa\x15\x88\xea\x2d\x49\xd7\x78\x04\x88\x80\xe0\x15\xe0\x59\xb2\x88\xc7\x95\xef\xff\xac\xed\x4f\x89\x77\xe7\x21\xa0\xbd\x1b\xaa\xd8\xc9\xec\x80\x75\xd4\xfe\xa9\x23\x45\x1a\x3b\xce\x6d\x23\xdc\xc8\x14\x5a\x3d\xb4\x84\x78\xf9\x11\x2e\xed\x4b\x03\xfa\x29\xd4\x3c\xbc\x75\x33\xe1\xd9\x7e\x8e\xe2\x71\x55\xe8\xd9\xef\xbe\xa7\x4f\xc6\x9e\x65\x2f\xc2\x17\xa5\xca\x74\xa7\x69\xe2\x0a\x8d\xf2\x6a\xae\x7d\xd4\xe9\xd6\xcc\x05\x20\xf8\x16\x20\x99\xa8\x1b\x27\x82\xff\x00\xfe\x09\x3b\x15\x73\x9c\xd5\x08\x25\x48\x55\xc8\x5a\x1c\xe9\x79\x96\xe4\x32\xa4\x13\xa5\x50\xa3\x85\xaa\x66\xc9\xa2\x21\x7c\xac\x1a\x52\xed\x10\x9b\xc9\x88\xb6\xb3\x30\x1f\x4d\x94\x7a\xa8\x38\x79\xbb\xeb\x8d\xed\xe1\x65\x31\x8d\x92\x65\xcd\x33\x4f\x4c\xe1\x2f\x79\x4e\xb4\xe6\xad\x14\x8e\x3c\x35\x5a\xcc\x43\x15\x23\xe0\x11\xda\xa0\x4a\x7a\x42\x57\x1e\xe6\x5e\x3f\x8e\x5c\x15\x03\x9d\x29\x3c\x65\x86\x08\xfc\xf2\x5b\x98\xe5\xf2\xab\x64\x2c\x10\x7c\xd5\xa1\x2c\x6f\x8e\xc3\xcc\x01\x63\x9e\xf2\x71\x34\x0a\xf3\xfa\xc1\x29\xaf\xc9\x77\x6e\x40\xe3\x63\x51\xf4\x3a\x3a\x9f\xe4\x03\x1d\xd2\x58\xf6\x14\x9f\x63\xc0\x8c\x54\x94\x0a\x60\x53\x7e\xe6\x1e\x6d\x6e\x92\x7b\x0b\xac\xa4\x89\x42\x58\x09\xff\x04\x84\xcb\xc4\xb3\x73\x0e\x51\x3a\xaa\xa1\xd0\x3d\x16\x68\x20\xec\x80\x75\xd9\x1e\xdb\xee\x5a\x01\x37\xad\x72\x99\xa8\x8d\xed\x31\x57\x6f\xb5\x02\x05\x68\x6c\x03\x4b\x3b\xc5\xe6\x2d\xa9\x64\x17\x2e\x15\xa0\xd4\xab\x77\x94\x6d\x0a\x16\xa9\x0a\xeb\xe6\x51\x67\xdd\xec\xa9\xab\x62\x1e\xbd\x08\x5f\xf8\xa3\xbc\xaa\x50\xac\x18\xdf\xe2\x4b\x3e\xed\x87\xc4\xed\x35\x22\x1d\xbd\x08\x5f\x78\x42\x1c\x19\xdd\x5e\x1e\x04\xca\x23\x13\xbd\x08\x5f\x78\x28\x5c\xc7\x11\x94\x52\xb8\x5a\x21\x53\x1b\x1b\x84\xea\x90\x8e\x2c\x99\x8a\xe1\xac\xcc\xb6\x18\x95\x5f\x5b\x6e\x4d\x6e\xc9\x16\x8b\xda\xbc\xcd\x4e\xfa\xfd\x7e\xe5\x1b\xdb\xff\x9b\xb7\xbe\x7a\x9b\x56\x21\xf8\xae\xc1\x77\x9b\x75\xfd\x76\x0f\x1a\xff\xbb\xe4\xec\x4a\x45\x00\x5d\xf8\x66\x6b\xbd\x81\x35\x6f\x8d\xd0\xc3\x91\x75\x5c\x2f\x0b\x31\x57\x49\x04\x0c\x69\xe5\xb3\xf4\xcd\x13\xc6\x3f\x8e\xf8\x3c\x47\xf3\x5d\x44\x2c\x78\xe4\xfc\xf6\x2f\x38\x01\x14\xd3\xbb\x9a\x93\xfb\xda\xa6\xb9\xcf\x73\x8a\xf8\x23\xca\x27\x0e\x1f\xfa\x8d\x74\xae\xf5\x64\x8d\x73\x46\x3d\x8e\x34\xdd\xaa\xe0\xf3\x94\x47\x8b\xdb\x11\x79\x37\x50\x3b\x8d\x7c\x61\xe8\x1e\x06\xbd\x81\x04\x64\xf3\xf9\xb4\xcc\xe2\xfe\xa8\x73\xff\x4b\x19\xd2\xc3\x8f\xda\x90\x1e\x7e\xac\x9b\xa4\xf9\x35\xcf\x72\x25\xe1\xf3\x34\x8c\x33\x94\xf1\x02\x85\x94\x17\x6e\xcf\x3c\x4b\xc9\x30\xfb\x99\x2f\xd3\x17\xd2\x26\x44\x60\xd0\x84\xe7\x3c\x65\x79\xe2\x95\xd3\xc7\xf0\xf6\xa3\x2f\x00\x48\x6e\xda\xee\xe2\xf2\x84\x02\x36\x4f\xb2\x48\x69\x00\x1a\x45\x0d\xb5\x64\x11\xea\x61\x01\x20\x33\x2a\x53\xe0\xac\x3c\xd3\xd4\xb5\x8b\xab\x91\x39\x2b\x2c\x79\xcf\x53\x7d\x9d\xd6\x42\x5c\x5b\x06\x3c\xb2\x32\x8e\xa0\x6f\x66\x2b\x90\x5f\x9c\x07\x00\x01\x19\xbd\x10\xff\x4d\xb6\xa7\x20\x76\xe8\x45\x5b\xc1\xd3\x55\x45\x28\xa6\x2f\x0f\x8c\x05\xb2\xb8\xa2\xc9\x9a\x36\x38\x09\x00\xa6\x73\xdd\xaf\x69\xa3\x2c\xae\x68\x1e\x9f\x2a\x23\xf1\x2d\x62\xea\x2b\x5b\xf5\x8c\xd9\xbb\x10\x60\x8b\x53\xce\xee\x31\x9a\xb8\x16\xed\x60\x06\x65\x92\xce\x56\x2c\x85\xc7\x38\x4a\xf5\x64\x0d\xdb\x77\xa5\x8d\xac\x80\x04\x54\xb0\x6c\x95\x08\xc1\xc1\xa3\xd8\xbf\xa9\x09\x20\x30\x6c\xaa\x9c\x53\x94\xa1\xb2\x4b\x95\x75\x4a\xf0\xba\xe4\x01\x74\x41\xd1\x10\x9a\x15\x51\x07\x14\xf7\x78\x64\x53\x1d\xaf\x0d\x5b\x9d\x93\xb1\xfe\xc2\xa9\xbc\x8d\x7f\x0f\x1b\xd5\x89\x62\xe9\xbf\x01\x8e\x27\x88\x9f\x7b\x98\xcb\xd8\x89\xf8\x72\x22\x20\x69\x41\x74\x22\x6a\x9e\x30\x15\xdd\x4f\xc8\x0d\xf1\xe5\x71\x7a\x8e\xc7\x55\x8c\xa0\xa6\x32\x13\x89\x62\x41\xcd\x4a\x85\x6f\x85\xc8\x40\x64\x0a\xfb\x2f\x76\x0a\xb5\x3d\x38\x01\xe2\x6d\xaf\x5a\x79\xae\xae\xe4\x14\x92\x24\x31\x03\x34\x83\xc1\x3a\x32\xe0\xae\xbd\xf8\xe5\xc5\x8e\xd5\x13\xdd\x62\x9d\x99\x7f\x9c\x9e\xb7\xa0\x67\xb9\xf4\x65\x60\x0e\xb2\xb8\x14\x3f\x42\x5c\x8b\xce\x1e\x5d\xd4\xc6\xa9\xfc\x71\x7a\xae\xef\x5f\x32\xce\xba\xe5\xd5\xb0\xb7\xe3\xce\x80\xd6\xef\xd5\xa8\x2f\xff\xe8\x5a\x0d\x77\xd7\x69\x28\xff\xe8\x0d\xdc\xcc\x0e\xd0\x16\x29\x63\xd3\xa4\x64\xaf\x16\x35\x3d\x6b\x60\x73\x27\x1e\xb1\xcf\x1d\xf1\xfc\x4d\xa2\x43\xac\xf8\x77\x6a\xe5\x9a\x03\xf6\x94\x97\xa5\x0f\xb3\x1f\x75\xbe\x27\xc6\xc1\xa3\x42\x78\x21\xb5\x41\x1b\x6e\x11\x1c\x27\x89\x72\x82\x71\x82\x36\x59\x1f\xb3\x64\x1c\x9d\x95\x65\xef\x44\xf0\x72\x95\x38\xa1\xae\x56\x6e\x73\x94\xb7\xe5\x73\x67\x42\x34\x45\x96\xc0\xa1\xa7\xd7\x39\x83\x34\xf5\xcc\xe9\xe6\xbe\x19\xe0\x4c\x1e\xc6\xe5\x73\xa4\xbc\x2d\xec\xe7\x0b\xa5\xd5\x75\xaa\x33\x88\x30\x5e\x51\xb1\xa6\x5d\x98\x8c\xdf\x6f\xa2\x98\x24\x39\x9b\x26\xc9\x1c\xc9\x1a\xc5\xe7\x7f\x09\x8e\x28\x2e\xa5\xdb\x0e\x81\x0f\x0c\x09\x49\xa6\x47\xa5\x18\x99\xa0\x44\x2a\xea\x90\xfd\xba\x04\xeb\x35\x14\x9e\x8d\x96\x14\x93\x8d\x51\x12\x9f\x45\xe7\x0b\xc8\xb3\xd4\xc0\x37\x26\x38\x61\x0d\x93\x7f\xa9\xb1\x87\x67\x01\x59\x00\xa7\x8a\xc6\x9e\x66\x95\x40\x76\x2f\x8b\x3f\xa4\x51\x4e\xa0\x55\x25\x71\x74\x46\xed\x61\xe8\x75\xf3\x17\x69\xe7\x3c\x32\x8f\xe2\x2c\xab\xb3\x8c\x38\xa1\xc9\x56\xb9\xad\xf5\xda\xf7\x4b\x93\x8c\x54\x1a\x4e\x74\x5c\xdf\x64\xe6\xd5\x72\x6b\xa9\xc5\x7a\x31\xda\x2d\x8b\x29\x21\x55\xc0\x59\x27\x27\xa4\x9e\xa1\x4f\xac\x11\x36\xf6\x58\x97\x5d\x35\xbd\xe9\x21\x65\x7b\xcb\xcb\xcd\xb4\x69\x31\xf3\xb7\x2f\x5f\xa4\x6c\xad\x3c\xd1\xd4\x4f\x3b\x63\x24\xf2\x02\xdd\xdc\x35\x76\x45\x7b\x5d\x41\x07\xa7\x76\xbc\x0a\x95\x4f\x81\xf4\x70\xd2\x17\x89\x10\xa4\xe2\x07\xba\xb2\xb1\x3c\xfe\x33\x84\xa3\x16\xb2\x87\x46\xb4\x79\x29\x83\xcd\x36\x6c\x40\x0d\xa9\x4b\x88\xfa\xc1\xa7\xab\x16\x6b\x88\x75\x7c\x65\x2b\xcb\xa2\x70\x8d\x60\xd0\x76\x0f\x1e\xba\xad\x73\x27\xe3\x06\x44\x14\xb2\x58\xb5\xc9\xd8\xe9\x92\xa4\xf2\x12\xba\x0f\x5e\x43\x47\x31\x0b\x59\x36\x0f\xd1\x05\x2d\x9a\x4e\xa3\x0c\x1f\x5a\xea\x73\xf8\xaf\x2f\xdf\x0c\x0f\x5f\xfe\xfe\xe2\x0d\xeb\xb3\x47\x9d\x0e\xca\x19\xf1\xf1\xe8\xd5\xe3\x17\xac\xcf\xba\x0f\xbf\x8c\x25\xe0\x45\xf2\x81\xbc\x9a\xf4\x78\x04\xdb\x42\xa7\x31\x9d\xe2\x26\xc4\xc4\x1e\x25\x74\x7a\x9d\xb6\x4c\x4a\xf2\x13\x16\xc5\x59\xce\x43\xc8\x43\x6e\xb4\x9a\x0f\x13\x1e\xb3\x28\x6f\x64\x40\x25\x3e\x66\x27\x9a\x02\x27\x90\x51\x2d\x49\xb9\xcc\x85\x16\xc5\x58\x28\x28\x01\xe7\x0b\x8b\x80\xd7\xdf\xf9\xc4\x69\x3e\x8d\x0a\xae\xb6\xe5\xa2\x0a\x06\x0a\x3e\xff\x25\x67\x79\xad\xe5\x9c\x59\xc9\xc0\x47\xc9\x02\x94\x8d\x8e\xb6\x87\x85\x59\x7e\x88\xc3\xee\xcb\x57\xfa\x55\x07\xf3\x2c\x0f\x67\x73\x7d\xd2\x7e\x91\x7c\x08\xc8\x99\x3a\xe5\xb3\x30\x8a\x71\x3f\xd5\xfc\xb2\xcd\x02\x6c\xb4\x4d\xfa\x52\x27\x6d\xab\x77\xa8\x66\xdc\x7f\x0c\xb4\x1f\xe9\xfb\x7e\x51\x74\xef\x1e\x8e\xe3\xc7\xbe\x61\x56\xcf\xe3\x15\x13\x83\xa0\x33\xf0\xbe\x61\x31\xaf\x9a\x24\x55\xe8\xb1\xb9\xa8\xfe\x9b\x88\x87\x06\x74\xd5\x89\x58\xcd\x41\x71\x99\x77\x37\x4f\x38\x25\x5f\x44\xd5\xf0\xa6\xa7\x3e\x00\x87\x61\x96\xeb\x6d\x19\x0c\x5b\x31\xcd\x81\x2c\xa8\x0b\x2b\x21\x4e\x72\xe3\x47\x0a\xa6\xeb\xeb\x86\x97\xae\x70\x22\xbf\x54\x61\xcf\x29\x77\x8f\x42\x65\xd8\xda\x76\xfa\xa5\x7b\x59\xd1\x79\xdb\x9b\x69\xa3\xa4\x8e\x71\x37\x2b\x4b\x97\xec\xe9\xc0\x33\x8b\x9b\xc5\x2b\x71\x66\xb1\xcc\x2b\xba\x73\x9d\x7c\x60\x6e\xda\xb7\x88\xb8\x19\x9b\x2e\x8b\x17\x10\xd3\x4c\xde\x1a\xd2\x80\xe3\x02\x18\xe6\xc9\x73\x98\x60\x75\xd2\xb8\x8e\xab\xce\xfd\x16\xc6\xe7\x9f\x35\x26\x79\x5c\x64\x9e\x96\x00\x54\xb8\x5a\xf0\x3c\x48\x28\xf0\xcb\x71\xb7\xc5\x0a\x0f\x12\xa4\x6a\x55\xd6\x66\x9c\x8c\x40\x34\xb4\x4f\x93\xf1\xb2\x3d\x9a\x44\xd3\x71\xca\xe3\x35\x00\x34\xc2\xd3\x51\xc3\x97\xfd\xbb\xac\xc1\xb0\x1d\x27\xc9\x7c\x45\xbe\xf0\xd2\xc5\xb0\x3a\x87\x21\x69\xaa\xdd\xf8\xfc\xe1\xd2\x57\x2f\x99\xcd\x42\x98\x7c\xa6\xf8\x7f\x67\x90\x62\xbf\xec\xa5\xfb\xa3\xee\xae\x53\xb3\xea\xa5\xbb\x84\xa5\x5b\x40\x6a\x16\x88\xa2\x21\x91\x95\x2f\xf3\x2e\x2f\xc9\x63\x74\xbc\x08\x6b\xb2\x4f\xf6\x73\xde\x2e\x3e\xe7\x75\x03\xf0\xa8\x27\xbd\xb8\x23\xab\xc0\xe1\x66\xb7\x8b\x06\xfb\x85\xf4\x0b\x58\x4d\x34\x12\x1b\xa8\x9b\x6d\xa0\xed\xcb\xc1\x80\x4d\x54\x32\xe5\x4f\xf2\xea\xf0\xf8\x82\x2f\x07\x62\x73\x83\x52\xf8\xb5\xcf\xae\xe0\xff\xd4\x0d\x17\xd4\xc3\xc7\xed\x18\x9f\x6d\x1a\x8d\xf8\xf8\x4d\xa2\x12\xaa\x5b\xd1\xa6\x48\xac\x1f\x51\xed\x99\x7c\xe0\x1f\x84\x69\xda\x62\x91\x1a\xe5\x30\x84\xe8\x6d\xc7\x83\x7d\xfc\x19\xab\x08\x5c\xf8\x73\xac\xa3\x69\xe1\x6f\x6e\xc5\x67\x40\xfd\xdf\x90\x64\x18\xe1\x9d\xda\xb1\x13\x54\x60\x10\x34\x5b\x6c\x98\xed\xb3\xdb\x01\x74\x10\x0c\xe1\x88\x17\xb5\x63\xfe\x31\x0f\x9a\xcd\xf6\x38\x89\x79\x73\xdf\xf4\x2e\xb0\x13\x98\xa1\x87\xeb\x30\x6b\xcb\xd5\x01\x34\x8e\xc4\xd2\x81\x52\x75\x3f\xd1\xef\x8b\x01\x9d\xa6\x3c\xbc\x40\x92\xa9\x23\x03\x46\x1a\x84\x51\xe0\xa0\x60\x00\x3c\x4d\x45\xb5\xb3\x28\x0e\xa7\x53\x31\x00\x1c\x06\xc6\xd0\x8b\x01\x7a\x74\x7c\x07\x89\x7e\x67\xd0\xb4\x7e\x05\x4d\xbb\xa9\x68\x34\x1c\x37\x59\x3e\x49\x93\x0f\x6c\xc8\xf7\xe9\x84\x09\x24\xf7\xcd\x4f\x33\x3d\x66\x0e\x8a\xb1\xfd\xc2\x34\x6d\x92\xb8\x04\x12\x84\x7e\x1a\xec\xc6\x6b\x30\x19\x40\x9c\x86\xde\x59\xd7\xa0\x3e\x49\x8c\x85\xce\xfb\x66\x39\xe7\x90\x20\x32\xb8\xf3\x2c\x7e\x1f\x4e\xa3\x31\x0b\xf3\x5c\x68\x2f\x78\x06\xc2\xa8\x0c\x8b\x54\x26\xb0\xce\x65\x36\x6b\xf5\x66\xf7\x0e\x40\xbd\xda\x67\x57\x41\xf3\x73\x84\xee\x82\xaa\x0b\x4c\x40\xe4\x7f\xde\xb4\xfb\xc5\x23\x59\x1e\x26\x71\xb6\x98\x09\x32\x58\x31\x2d\xcb\x67\xd3\x8e\x26\x00\x77\xd9\x3d\x7d\x45\x65\x78\xb9\xa9\x04\x53\xea\x8a\x24\xd1\xe0\x38\x1a\xc8\x05\x16\x0d\x08\x5f\x89\x22\x32\xb1\x56\x60\x4d\x1a\x3d\xd3\x1e\x84\x23\xdb\x93\xd3\x77\x20\x91\x8c\x03\xb1\x0a\xb9\x20\x58\x4c\x12\xcf\xbf\x2d\x98\xa6\x9f\xd4\x3e\xa0\xdc\x5e\xb4\xed\x4d\x9a\xe4\x18\xb5\xd3\xa9\x6f\xca\xd2\x86\xbf\xd9\x15\xe5\xd2\xe4\xf4\x9d\x12\x8c\x68\x34\x31\xc3\xc6\x40\x1f\xf2\x8a\x7d\x3a\x9f\x84\x54\x02\xc2\x87\xe0\x94\x9f\x47\xb1\x40\x63\xdc\x62\x17\xd6\x8e\x0c\x25\xec\x1e\x0b\x78\x3c\x66\xdb\xf8\xb3\xc9\xee\xb2\x0b\x30\xf1\xc1\x59\x99\xf3\xf1\xa1\x72\xe3\x27\x90\xe9\xf7\x60\x98\xf2\x33\x73\x08\x04\x2b\x59\x9f\x89\x8f\x40\x78\x75\x82\x83\x04\x2b\xf0\x35\x4f\xe8\x0d\xad\xa8\x7e\xbb\xdf\x67\x90\x26\x05\xf4\x4b\x50\x9f\xc6\x3c\x83\x60\x60\x51\x12\xef\x89\xa3\x33\x1a\xdd\x44\x65\xd4\xe3\xc4\x11\xfc\x3d\x9f\x26\xa3\x28\x87\xc9\xe1\xe1\x68\xc2\xb2\x9c\xcf\xe7\x3c\x25\xaa\x9d\x60\xe3\x63\x08\x7a\xa8\x66\x6a\x20\x3e\x01\x62\x2c\x4f\x5a\x06\x86\xe0\x0c\x65\x22\x18\x85\xd3\x23\x04\xf5\x8f\x70\x4a\x23\x26\x39\x25\x01\x0f\xb3\x28\x3e\x07\x57\x47\xf1\xbb\x05\x18\x90\x17\xa2\xf8\xa6\x9e\xcf\x25\x18\x88\x98\x20\x56\x71\x7b\x16\xce\xe5\xb3\xd0\xc0\x48\x44\xc5\x79\xd4\x03\xc4\xa2\xb4\x28\xb3\xa3\x64\x0d\x11\x03\x21\xd0\xe1\x0f\x51\x05\xc9\x2e\x00\xb5\x61\x84\xe1\xb4\xad\x46\x69\x05\x2d\x95\x6d\x41\xfa\x58\xbb\x68\x30\x54\xe3\xea\x59\x0d\x62\xfe\xe1\x3f\x45\x65\xd9\xce\x09\x73\x1a\xf3\x0f\xff\xa0\xa5\xdd\x81\x1b\x08\x52\xa9\x2b\x60\xef\x7a\x1f\x4e\x5b\xe4\x54\x2d\x70\xde\x83\x1e\x0c\x4c\x85\x35\x7c\xff\x87\x3a\x63\xdb\x31\x3a\x8d\x31\x11\xce\xca\x7a\x2a\x4c\xc0\x14\x98\x12\xf6\x03\xeb\x3a\xf6\xc7\x35\x27\x63\xe5\x74\xd4\x1a\x26\x1d\x14\x2e\x4f\x3a\x3d\x2d\x8b\x61\x60\xcd\x93\x32\xe4\x2d\x4a\x72\x24\x9a\x81\x83\x13\x5f\x84\x81\xdf\xb1\xbd\x79\x86\xd3\x2c\x84\x7d\xb5\x89\xe9\x90\xd3\x0e\x99\x51\xb2\x10\x68\xdf\xb2\x47\xf0\xcf\x90\x6b\x7b\x47\xcb\x3e\xce\x16\x18\xeb\x41\x51\xdc\x17\x1e\xda\xcc\x86\x59\xb0\xaa\xa7\xf1\x02\xdd\xa9\x5b\x2c\x85\xb8\x0e\xd4\x2f\x2b\xe7\xa9\xcc\x3a\x64\x26\xf9\x9c\xe7\xf4\xa9\x8f\x28\x6f\x6a\xb0\x3a\xfe\x4e\x1e\xcd\xa2\xf8\x5c\x85\x8c\xd5\x90\xda\x29\x1f\x2f\x46\x9c\xb0\x47\xca\x33\x99\x40\xcc\x62\x2a\x6b\xee\xa1\x8e\xbb\xc7\x88\x02\xe0\x2d\x70\xdd\x86\xf9\x11\x18\xc0\x1f\x03\x7c\x84\x78\x25\x2d\xc1\x2a\x7c\x25\xd2\xf9\x8b\x20\xa5\x38\x15\x39\xcb\x60\x78\xcb\x65\xde\x8e\x91\xeb\x7b\x0a\x7d\xe4\x19\x7b\x0c\xea\xf9\xda\xd9\xb3\xb1\xf6\x52\x11\x5f\xe6\x29\x97\xc1\xe3\xde\x27\xd1\x18\x8d\x63\x70\x79\x26\x36\x21\x6f\xc9\xa2\x10\xbf\x13\xbf\x54\xc4\xaa\x36\x41\x23\x0f\x49\x20\x60\xdd\x9e\x7e\x77\xa1\xac\x2d\x1d\xcc\xda\x81\xe5\xa6\x17\x10\x9d\xbd\x66\x49\x0c\x6d\x8c\xe0\x8d\x61\x07\x9c\x30\x2f\x56\xb1\x8b\x24\x86\xe0\x91\xc7\x46\x12\xea\x93\x74\xd9\xb2\xf6\xea\x26\x79\xe7\x84\xf4\xd9\xd9\x51\x18\x4a\xde\x37\x08\x80\x91\x23\x9b\xa7\x51\x7c\x6e\x73\xa2\x27\x92\x2a\x2d\x70\x43\xa9\xde\x96\x73\x6d\x68\x65\x26\x9f\x44\x51\x55\x5b\xda\x98\x4f\xf3\xd0\x14\xb3\x6d\x55\x7d\x9f\x18\x8a\x85\x5c\xe9\x93\xaa\x3b\x52\x2e\xb4\xc7\xb9\xdc\x75\x9c\x55\x53\x22\xaf\x6c\x52\xa1\x84\xc4\x7e\x76\x76\x04\x7f\xb0\x45\x2c\xe3\xd9\x82\xc6\x11\x8e\xc7\xe8\x0a\x9a\x47\x42\xfb\x9f\xa7\xfc\x2c\xfa\x28\x67\x44\x08\xa1\xc0\x5a\x6a\x46\x68\x59\x9c\x66\x71\x44\x53\x59\xab\x1d\x9a\x18\xea\x79\xf9\x80\x46\x94\xc5\xa5\xe5\x09\xf9\xba\xf0\x07\x87\xdd\xd9\x61\x39\xeb\xff\x28\x58\xd5\x3f\xe7\xa3\xc5\x69\x34\xda\x3e\xe5\x7f\x46\x42\x97\x22\x72\xb1\x38\xf1\xf4\x7b\x61\xde\xf5\x5a\x36\xd8\xd2\xe5\xed\x46\xd0\x85\x7e\xc4\x48\x70\xd6\x49\xeb\x1d\x2d\xed\x0d\x0f\xd0\xd0\xde\xd7\x5d\xac\xb0\x73\x16\xed\xef\x9e\xb3\x8d\x68\xdd\x1e\x25\xf1\x28\xcc\x83\x63\xa9\x6a\xe5\xcd\x81\x7e\x34\xde\xa2\x3b\x87\x9a\xd2\x1b\x65\x21\x13\xa3\xbc\x49\xb8\x23\xa7\x8a\xcd\x1a\xcc\x60\x5f\x51\x80\xde\x2e\x8e\xf3\xd7\x26\xe8\x0d\x91\xb4\x6b\x48\x5a\x46\xd4\x55\x74\x32\xe3\x68\x16\x38\x5f\x6f\x21\x52\x58\x44\x99\x94\x09\xf0\x74\x8e\xca\xb6\x3d\x8b\xb3\xd5\xb2\x51\x56\x05\xf0\xa6\x0c\xb5\xd0\x46\x33\x78\xf1\x72\xcb\x04\x3c\xaf\x9a\x0f\xc5\x2a\x1a\x78\x32\xf7\xc1\xae\x0c\xa7\xae\xe0\xb7\x47\x61\x3c\xe2\xd3\x66\x00\x8c\x60\xc5\x12\x56\xa7\x2b\xcb\x60\x7a\x03\x7e\xdd\x62\x2e\x7f\x86\x1d\xa8\x34\x4c\xca\x77\xe4\xfd\x69\x65\xd5\x47\x5d\x2b\x54\x94\x7a\xbb\x57\x76\x77\xd1\xd3\x77\x17\xca\xf8\x57\x1e\x4b\x54\x5e\x5b\x48\x98\x19\x38\x94\xaa\x47\x05\xe8\x92\x39\x4a\xa6\x53\x1d\x1f\x05\x69\x2d\xdf\x4e\x9b\x80\x27\xd3\xa9\x6e\x23\xa0\x9d\xe8\x47\x63\x27\xda\x2b\x25\x4f\x17\xf9\x64\x09\xef\x1d\xe0\xda\xc1\x3c\x0d\x8c\x32\xfd\xa2\x41\x5e\x5c\xa7\x1c\xee\xb8\xb4\x71\x75\x8f\x29\x37\x7f\x70\xb4\xbd\x84\x75\x66\xf0\x6a\xaa\xbb\x91\xbb\x77\x5f\x24\x39\xdf\xbb\x7b\x97\xfd\x1e\xab\x9b\x97\x94\xcf\x92\xf7\x5c\x79\xad\xea\x5b\x73\x44\x2a\x34\x11\x4b\x36\x89\xf2\x74\xa8\x51\x29\x38\x91\xea\xeb\x36\x83\xae\x7c\xce\xa1\x7f\xe6\x89\x7a\x8e\x09\xd4\x2f\x8b\xd5\xa2\x09\xd6\x1f\xb6\xd5\xe5\xfa\xa0\xf6\xbb\xca\x55\x51\x5b\x50\x59\x52\xe9\xf6\xb1\x4d\xc6\x39\x13\x04\xc4\x50\x92\x5e\xa7\x9c\x45\xc6\x53\xa1\x71\x1c\xc3\x6d\x0f\xfb\xc4\x1a\xe2\x4b\x63\x8f\x35\x4e\xc3\x34\xe6\xcb\x46\x8b\x35\xc2\x73\xde\xd8\x63\xbb\x0f\xc5\x9f\xa3\x3c\x7a\xaf\xbc\xa6\x20\xd1\x82\xd3\xea\x2c\xe5\xe3\x46\x8b\x31\xd5\xea\x7e\x87\xb6\x02\x6b\x33\xd8\x23\xd8\x60\x5f\xdf\xcd\x20\xea\x01\xa0\xd2\x32\x37\xe8\x09\xb1\xe8\xdd\x4e\xda\x08\x64\x1f\x8f\x77\xea\xca\x86\x26\xb1\x3e\xc6\xce\x95\xf3\xcf\xce\x0e\xba\xbd\x0d\xdb\xf8\x5c\x2b\x3b\xf1\x3c\x9a\x6d\xfb\x30\xf8\x54\x35\xe4\xf2\xde\x25\xc1\x4a\xfb\x57\x87\x92\xda\x78\x1c\xab\xbe\x5b\x48\xb8\xc1\xda\x23\x9f\xaf\xdb\xa5\xea\xb1\xd6\x28\xc9\x3d\x99\x84\x62\x16\x05\x79\x25\x4b\x4c\x68\xe8\x43\xa4\xcc\xa7\x44\x00\xa8\x10\x40\x52\x8a\xee\x11\x91\xea\xbc\x7a\xb0\xfa\xa0\xd2\x34\x20\xcf\x72\x77\x9b\x25\x97\x6d\x67\x12\x64\x61\xc3\xd8\x3c\x44\xa2\xc0\xe5\x69\x38\x2a\x0b\xe8\xb5\x7b\xff\x41\xed\xa8\x02\x88\xa5\xdf\x75\xf4\x3a\x0f\xbf\x6f\x4c\x86\xad\xff\x1c\x7c\x7d\xb1\x55\x78\x7d\x5d\x87\xb3\x9c\x34\xea\x6a\x2e\xac\x66\x7a\x5a\xe9\x56\x64\x6d\x43\xde\x57\xd3\xa5\xb5\x9b\xde\x4c\xea\x85\x88\x2d\xf4\xd9\xce\xaa\x98\x2d\x3f\x97\xb1\xe7\xcd\xf8\xc1\xff\x9c\x94\x2b\x28\xca\xff\xfd\x02\xed\x4b\xfe\xbc\xd0\x8f\xea\xb3\x70\x92\xbe\xfc\x10\xdf\x08\x0b\x57\xa6\xf9\xaf\xc1\xb4\xba\xbb\xb5\x79\xd6\xf5\xb4\x39\xc1\x7e\xbd\x41\x02\x60\xbc\x3a\x03\xbf\x1d\xb0\xcb\xdc\x69\x08\xac\x65\xdc\x95\x9f\x93\xb4\x50\x1d\x8c\x55\x65\x6f\x24\x4c\x37\x1e\x06\xb9\x01\xa7\x7a\x70\x10\xfc\x69\x05\x9b\x7c\x57\x93\x03\x0c\xb2\xea\x81\x61\x64\x69\xa8\x8a\x94\x02\x8e\xdc\xa5\x22\x9e\x49\x4a\x61\x14\xcf\x13\x41\x8b\x9f\xc1\xd9\xd0\xf8\x25\x66\xec\x44\x11\x0b\x63\x05\xc1\xfd\x88\xda\xe7\xda\x44\x15\xe6\xc4\xab\x73\x16\x2e\x19\xff\x18\xe5\x66\xa6\x19\x0f\xd3\xe9\x52\x74\xc3\x3f\xce\xa7\xd1\x28\xca\xa7\x4b\xa2\x1c\x13\x8f\x97\xaf\x86\x2d\x0b\x10\x14\x7d\x0a\x8e\x91\xe2\x70\x2e\x04\x2c\xac\x65\x31\x1b\x84\x6f\x6b\xb3\xb7\x2d\x34\x2c\xee\x08\xbc\x5e\xba\xb2\xb2\x87\x39\xaf\xef\x20\x0f\xec\x65\xb4\x8c\x24\x2d\xc4\x7f\x3c\x4b\xd2\x67\xb1\x09\x9e\x82\x2c\x57\x35\x6f\x37\x15\x62\xa4\xdc\xcd\xd4\x42\xda\xf5\xc1\xb3\xe8\xe8\xc4\x0c\x71\x7d\x48\xfd\xe2\xe1\x67\xed\x9b\x5a\xf6\x5c\x9b\x31\x7d\x8f\xaf\x1c\x68\x24\x2c\x72\xcb\x02\x81\xbb\x65\x48\x7b\x01\xb2\x58\x43\xbf\x10\x85\xaa\xf4\x85\xb7\x7e\x68\x29\xdf\xe9\x6e\xdb\x97\x77\x17\x7c\xa9\x5a\x1d\xd3\x88\x25\x12\xa0\x0e\x58\xa2\xfd\x4b\xc1\xf3\x43\xe9\x71\x0a\x77\x79\x85\x00\x67\x45\xf5\x0d\xf3\xe1\xc1\xe2\xa4\x36\x1a\xf4\x0e\xb1\x9d\x55\xa9\x69\x21\x91\x8e\x55\xe5\x3e\xf9\x74\x5a\x3c\x1c\xbc\xb9\x63\x7e\x3d\x9f\x45\x9f\xbf\xf6\x89\xd2\x66\xc0\xaf\x5a\xff\x02\xa2\x9e\x58\x7c\xb6\xda\x8f\x5a\x48\x4b\xaf\xc8\xa0\x02\x0b\x22\x29\x28\x35\xe7\xb3\x84\xe7\xd9\x74\xed\x80\x6e\xa7\xc6\x52\x08\xbd\xe3\x2e\x23\xaa\x04\xba\x91\x34\x31\x18\x81\x56\x83\x9d\x7c\x17\xe6\x56\x50\x57\xb1\xde\x28\x9f\xb1\xe0\x36\xf5\xf3\x2b\xd1\x0e\x01\x84\x42\xd7\x8f\x8e\x7b\x59\xa0\xd7\x1e\x99\x09\x3b\x7e\x90\x1d\x41\xa8\xb0\xc4\xaa\xa5\x01\x41\xd4\x5e\xd0\xeb\x46\x18\x2a\x5b\xbb\x4e\x94\xa1\x0d\xd7\xaf\x4d\xfe\x95\x6b\x58\xb0\x87\x67\x11\x6f\x9e\x68\x1a\xa3\xef\x3c\x07\x07\xb4\x12\x0d\xa9\xa7\xde\xcb\x9f\xf3\x1c\x2a\x3e\x09\xf3\xb0\xb4\xb2\xf2\x52\x96\x26\x82\x23\x70\xd2\xc4\x4c\x06\x72\xc2\xfc\x67\xc9\xba\x6a\x18\x31\x7e\xa0\x16\x36\x4e\x78\x16\x37\x72\x36\x9a\x26\x31\x67\x27\xe8\x8f\x58\x4b\xcf\x91\x2e\x93\x44\xcf\xc1\xb4\x6d\xf8\x7c\x48\x45\x95\x4f\x70\x28\xf5\x9f\x64\xcc\xf9\xa8\x6c\xbd\x8b\x41\x3d\x47\xf4\x03\xed\x89\xa9\x43\x94\x1b\xd2\x52\x4a\xab\x8a\xfb\xd2\x49\x42\xd7\x33\xfe\x84\x98\x87\x51\x17\x1c\x77\x06\xc7\xbd\x81\x73\x01\x59\x32\x1f\x81\xd5\xaa\x33\x68\xd9\x60\xba\xde\x67\xd0\x64\x2b\x77\x7a\x91\x74\x14\x4b\x42\x52\xf7\xf2\x92\xf2\x98\x56\x00\x94\x53\xa9\xee\xad\xea\x01\x05\x21\x5b\x71\x11\xf4\x36\x7f\x43\x71\x94\x87\xa3\x8b\x52\x9b\x78\xd7\x8a\xc9\xa8\xd2\x58\xf8\x8f\x93\xca\xef\x5e\x3f\xc9\x82\x4c\x1a\x19\x67\xa7\x51\x3e\x0b\xb3\x0b\xb4\x39\xa1\x5f\x94\x95\x1f\x40\xaa\xa7\x87\x2f\x9f\xbf\x7a\xfc\xfa\xe9\xf0\xd5\xe3\xd7\x6f\x9e\x3d\xfe\x6d\xf8\xf3\x6f\x8f\x7f\x61\x7d\x15\x34\x49\x95\xfe\xfe\xe2\xe5\xeb\x27\x4f\x5f\x3f\x7d\xa2\xca\x7b\xb5\xa3\x3b\xe2\x34\x7c\x81\x53\xac\x27\xec\xd0\x06\xeb\xce\x0e\x82\x60\x96\x0a\x9a\xed\x65\xcb\x38\x9c\xf1\xac\xa5\xc3\x75\x09\x05\x1a\x69\xcc\xd9\xd9\x34\x3c\x2f\x81\x49\x63\x8f\x2f\xb2\x3c\x99\x45\x7f\xf2\x74\x50\x50\x27\x74\x99\x35\x6f\xf5\x9f\x26\xc8\x93\x08\xbc\x4d\x40\x2c\x6a\x84\x55\x5b\xb1\x66\x5a\x06\x2b\x4f\xb0\x23\x57\x50\x14\x42\x1f\xe1\x4e\x26\xbf\xc6\xc9\xa1\x86\x05\xe1\xb0\xf5\x2f\xed\x9e\xa5\x17\xb7\x2f\x83\xd6\x6d\xe2\xae\x70\x8b\x69\x41\xe0\x28\xeb\xfb\x26\x98\x52\x54\x0c\x21\x3e\x46\xe9\x67\x24\x50\xe4\x44\x10\x0f\x2c\x2c\xb7\xb6\xa0\x85\x90\x75\xc4\xd3\xea\x00\x3f\x76\x75\xa6\x21\x3e\xca\x8f\xc7\x28\xcf\x06\xa4\xde\x1e\xbb\x1d\xc8\xcf\xd2\x65\x54\x20\xa8\x2b\xac\x4e\x4a\xb4\x32\x40\x4c\xe5\x70\xcc\xa9\x42\x22\x61\x94\x9b\xe4\xf4\xdd\x3f\x64\xb0\x6c\x89\x3e\x75\xec\x61\x2c\x4b\x47\xaa\x5c\x0e\x75\x9f\x26\xb6\xf5\x53\xc8\xd2\x6e\x4c\x0f\x56\xb4\x9e\xad\x2d\x76\x9b\xb8\xd0\x0a\x7a\xac\x95\x0b\x8a\x9e\x98\x32\x29\x53\x21\x16\xba\xf8\x9b\x9e\x8c\x5c\xb6\x35\xcd\xb4\xd9\xd3\x54\xd1\xd8\xb6\xf4\xc8\xe5\x19\xca\x5d\x18\xd0\x67\x21\xfa\x34\x86\xdb\x56\x80\xe9\x80\x09\x37\xe8\xd4\x1d\x28\xe0\x03\xd3\x93\xe9\xdd\x2b\x9c\x2f\x4b\xa4\x32\x5d\x9b\x0a\x33\xab\xbf\x3d\x39\x56\xf2\xb1\x2e\xb5\xed\x1d\x59\xa7\xc4\x2a\x09\xad\x08\x42\xc4\xb3\x6f\xde\xc4\xab\xb5\xda\xea\xdd\xda\xc6\xd8\x5f\x54\x20\x92\xfa\xe2\xdd\xb1\x0b\x5d\x6b\xdf\xfa\x9f\x05\x4f\x97\xab\x0d\xfd\xb0\xa6\x71\x81\x3b\xbd\x12\x19\x6e\x69\x71\x54\x5d\xb2\x18\x5d\x25\x0e\xa4\x96\x0a\x2d\xa2\xad\x58\xfd\x34\x14\x9d\x6b\xa6\x30\xe2\x04\x9b\x1c\x63\x05\x22\x35\xde\x17\x45\xca\xbe\x72\xcc\xa5\x2d\x58\x9f\x1d\x1b\xc7\xfa\x96\x67\x92\xe5\x8d\xc0\x60\xbf\x7e\xf8\x76\x4a\x0a\x0f\x2b\x6e\xf6\x1a\xcc\x9c\x63\x56\x29\x67\xfa\x1c\x53\xca\xa7\x2a\x70\xca\x24\xcc\x9e\x95\x65\xbd\x7a\xd4\xd3\xe1\x55\xb2\xff\xe0\xe5\xc9\x69\x76\x75\xad\xb5\x97\xc9\xfa\xa7\x27\x6c\x97\x27\xe5\x08\x75\xf5\x7d\xdd\xd7\xaa\x9d\x16\xae\x95\xfd\x27\x3c\x29\x9a\x2b\x17\x39\x06\x47\xb9\x62\xf3\x30\x9f\xa0\x96\x28\xfe\x90\x71\xf6\xb4\x48\x41\xcb\xb2\x1b\x9b\x4b\xef\xaf\xd6\x5b\xd4\xcf\x72\x0a\xd4\x6e\xbd\x02\x3d\xb3\xbf\x35\x75\x2a\x56\xe0\x30\x28\x95\x4f\x30\x0b\x8b\x51\xb7\xa9\x79\xe0\x03\x16\x41\x88\xa4\xc3\x7a\xa7\x3c\x19\xf4\x44\x69\x1f\xe7\x3c\xd7\xca\x29\x00\xb4\x42\x62\x54\x68\x19\x56\x89\xc6\xe1\x96\xda\x88\x61\xf1\xd9\x90\x6f\xa9\x4d\xf3\x46\x37\xe9\x9a\x87\xce\xf2\x38\x1d\xbd\xcd\xdd\xb2\x66\x7c\x96\x44\x7f\xf2\x43\x95\xa1\xcc\x2f\x71\x0a\x07\x4b\xdc\x81\xec\xcd\x51\x05\xf6\xd0\x5f\x05\xe9\xcc\xf2\x4d\xf9\x6f\x3c\x1c\x47\xf1\xf9\x93\x44\x08\xc0\x9d\x7f\xbe\x6d\xef\xb4\xe4\x8c\x89\x21\xbe\x08\xc1\xd9\x73\xe7\xf8\x9f\xed\xe3\xb7\x83\xc1\xbd\xcb\xb7\xc7\xc1\xc1\x5e\xb0\x7d\xf0\x76\x7c\x2f\x38\xd8\x7b\xdb\x7e\x3b\xbe\xd7\x3c\x68\x5e\x06\xc7\x77\x1a\x83\x66\x20\xca\x0e\x6e\xbf\xed\x35\x8f\xff\xf9\xf6\xed\xe0\xf2\xed\xdb\x76\xf3\xee\x41\xf3\x6d\xaf\xf9\x76\x70\x19\x1c\xf4\xa1\xc5\xe5\xdb\xe3\xb7\x83\xa6\xf9\xf3\xf2\xef\xcd\xe6\xce\xb9\x77\x28\xa7\xe1\xe8\x22\x9b\x86\xd9\x04\xe3\x6b\x94\x8e\xe1\x69\x36\x0a\xe7\xfc\x70\x12\x8a\x63\xca\xce\xdb\xb7\xc1\xdb\xb7\xcd\x03\x05\x13\xec\xcc\x49\xfc\x9e\x8b\x39\x54\xc1\xc9\x20\xbe\x81\x0d\x70\x75\x20\x50\x25\x40\x48\xbc\x29\xf9\x27\xc8\x4d\xe8\x62\xb5\x9e\x50\xd2\xa9\x8c\x47\x06\xf0\xde\x24\xaf\x42\xd8\xeb\x2d\x46\x30\xcc\x44\xa3\x4c\x79\x1c\x03\x30\x44\x86\x99\xd8\x76\xce\x33\x1d\x1b\xca\x88\x04\x73\x9d\xdf\x68\xe8\xc5\x8e\xb5\xda\x29\x9f\x4f\xc3\x11\x0f\x0c\x17\x10\xd7\x02\x79\x54\xc5\x10\x32\x2d\xf6\x3f\x8b\x24\xe7\x76\xe8\x2b\x1b\x3c\x54\x90\xf9\x0d\x2c\xd8\x66\xde\x5a\xac\xf1\xf7\x6e\xa3\xc9\xf6\x58\x20\x23\xd3\x5c\x5e\x22\x13\xc8\x07\x09\x5e\x07\x03\x7f\x5c\x36\x42\x42\xcf\xea\xdc\xdc\x07\x46\x4e\x4a\xe9\xba\xb4\xb7\xd4\x50\x69\x87\x1f\xa3\xd9\x62\xa6\x1b\x63\x4a\xa0\x2c\xfa\x93\x6b\x3e\x7e\xfe\xf8\x3f\x87\xcf\x9f\x3e\x7f\xf9\xec\xbf\x9f\x0e\x8f\x9e\xfd\xf7\x53\xd6\x67\x0f\x3a\x9d\x7a\xa9\x65\x24\x58\xb5\x3d\x8e\xa6\x3c\x4c\x65\xc7\x58\x32\xd6\xd3\xd7\x00\xe7\x47\xec\x5f\xc6\xb7\x81\x58\x0f\x7c\x9c\xb1\x13\x17\x87\x4d\xa2\xf8\x4d\xc2\xf7\x9c\x45\x79\xc6\x92\x45\x3e\x5f\xe4\x1a\x93\xda\x1b\x66\x01\x75\x67\xd3\x2c\xae\x0e\xcf\x92\x90\x95\x64\xdc\x35\x3d\xe3\xe4\x9d\x0d\x9c\x3e\x05\x39\xda\x19\x4c\x6b\xbf\x5f\x98\x0a\xea\xa3\x2d\x2a\x02\x7d\x83\xa6\x27\x26\xcc\x05\x5f\x2a\x7e\xbd\x65\x27\x7f\x92\x2b\x02\x7e\xd6\xf4\x96\xb1\x06\xe8\xe1\xe5\xcd\x1d\x66\x9e\x87\xf3\xaa\x04\x90\xbd\x8e\xb2\xc1\x33\x78\x5e\xcd\x66\x3c\xcb\xc2\x73\xae\xc3\x7b\x19\x29\xfc\xf3\xef\x2f\x0e\x87\x4f\x5f\xbf\x7e\xf9\x7a\xf8\xe6\xe9\x7f\xbe\x61\x7d\xd6\x78\xfa\x71\xce\x47\xb9\x58\x03\x86\xf9\x56\xc6\x6a\x52\x83\x2e\x89\x4a\xca\x9e\x9d\xb1\x93\x94\x67\xc9\xf4\x3d\x4f\x4f\x58\x94\x49\xdf\x8a\xf7\xd1\x98\x8f\x5b\x82\x97\x75\x96\x54\x15\x34\x66\x84\x4e\x02\xa0\xc8\x66\x79\x82\x02\xdb\xc0\x16\x9b\xfa\x98\x41\xef\xb6\x3f\xaf\x06\x2b\x98\xd9\xbb\x94\xda\xec\xa7\xa5\x7a\x67\xdd\xb2\x12\xb2\x22\x08\x8a\x5b\x29\x10\x16\x65\x6c\x61\x49\x8a\xb9\x41\x1a\xbd\x90\x4d\xd0\xda\xa2\x17\xb2\x2f\x56\xac\x1f\xd9\x82\xfb\xf1\x1b\x4d\x9e\x28\x03\x76\x21\x58\x9c\x40\xc1\x89\xd9\xad\x90\x40\x1a\xac\x80\x64\xc8\xf0\x2c\xcf\xf0\x66\x0a\x96\x65\xb8\x64\xa7\xdc\xd8\x3a\xc0\xcf\x05\x85\xbe\x22\xbd\x91\x58\x6d\x60\xbf\x13\x15\xc8\x0e\xde\xe9\x27\x29\x0e\x4e\xa8\xf6\x1f\x20\x54\x98\x7a\xa8\x9f\x99\x43\x82\x9a\xae\xe3\x93\xe7\xe1\xfc\x1a\x99\x7a\x8d\x3f\xce\x76\x72\xb6\x9d\x4f\xf8\xf6\x2c\x9c\x6f\xeb\xb0\x17\xdb\xda\xf8\x77\x57\x07\xca\x11\x50\xcf\xc2\x11\x47\x87\x73\x21\x02\x4e\x5a\xec\x64\xcc\xa7\x3c\xe7\xe2\xaf\x73\x9e\x8b\x7f\x26\x61\x76\x82\xb6\x88\x93\x8c\xe7\xf5\x23\x1c\x7a\x5c\xb6\x95\x6c\xbc\x31\xa9\x5b\x34\x70\xab\xb5\x54\x34\x6f\xcb\x12\x7b\x15\x6d\x26\xbc\xcb\x23\x26\xb2\xbe\x0e\x6d\xd8\x62\x8d\xd3\xc6\x1e\xeb\xc1\xd3\x87\xbb\x26\x26\x36\x56\x19\x35\xf6\xd8\x6e\x8b\x35\xc6\x8d\x3d\x76\x1f\xab\xa8\x5a\xf2\x9a\xa0\xcf\x34\x77\x05\x43\x8c\xbb\x21\xe3\x29\xe2\xdf\xc4\xf0\xac\x43\x2c\x76\x5b\xac\x37\xd0\xa0\xb0\x96\xe8\xd3\xaa\xb4\xdb\x62\xf7\x55\x25\x19\xee\x28\xc4\xb3\x6c\x6d\xd8\x3b\x3b\xec\x39\x84\x32\xa5\x12\x08\xf7\x14\x03\xa4\x2d\x77\x23\x72\x94\x3a\x6e\x84\x0d\xa0\xcb\x60\xd5\x48\x74\x45\xd3\xe3\x6b\x54\xb8\x8a\xab\x4e\x7a\x47\x5b\x1f\x59\x9f\xfd\xc1\xc3\x8b\xe7\xe1\x7c\xdf\xbb\xdb\xca\x8d\x54\xb1\x8d\x39\x96\x8a\x55\x93\x9c\x21\x53\xde\xee\xb3\x86\x16\xf9\x90\x2e\x53\xd5\x17\x45\x90\x56\x61\x6b\x8b\xc9\x16\xb4\xc8\xb4\xd2\x8a\xaa\x2f\xca\x87\xb3\xd9\x68\xed\x95\xa8\x67\x63\xf2\xd0\xad\x66\x00\x79\x6d\x2c\x43\x74\x0e\xf4\x9f\x24\xc6\xb3\x0a\x7a\xbd\xa7\xa3\x44\xeb\xe6\x6a\xa3\xd7\x2b\x4e\x6e\xf5\x8e\x92\x31\x09\xb3\x40\xc6\xcd\x71\xdc\x2f\xa0\x58\x1c\xa0\x45\xb1\xeb\x2b\xa1\x15\x9a\x33\x3b\xe8\xb4\x8e\x38\x0d\x36\x22\xab\x6b\x95\x71\x12\x38\x09\xec\x77\x08\xa4\x29\x66\x44\xeb\x21\x05\x4d\x44\xbe\x39\x2a\xc0\x12\x53\x10\xd8\xbc\x72\x79\xa9\x35\x08\xaa\xa0\xab\xa6\xa0\xd5\xec\xec\xb0\xa7\xb0\xb7\xb0\x13\x55\xf7\xa4\x7d\xcb\xe5\x39\x55\xe4\xd3\xe8\x65\x5d\x8f\x02\xb4\xb9\x43\xa8\xd8\xfd\x57\x85\xcd\xee\x51\x47\x04\x73\x94\x24\x91\xf2\xd4\xd1\x86\x3d\x56\x31\xf3\xe4\xc1\x30\x22\xde\x9e\x42\xff\x38\x11\xbc\x0f\xbb\x1d\xec\x0f\xda\x02\x72\xa2\x96\x3e\x9e\x2a\xa3\x73\x54\xec\xb7\x3b\x70\x3b\x38\x4f\x79\xc6\xd3\xf7\x28\xc4\x6b\xed\x25\xd7\x0f\xaf\xe6\x3d\xc6\xaa\x93\xaf\x15\x8d\x0f\x6b\xf2\xb1\x1a\xbc\x47\xbe\x0f\xdb\x2a\xce\x71\x00\xf7\x83\x44\x50\x35\x1a\xc5\x3a\xdb\x1d\xab\xc6\x76\xc7\x53\xc7\x1b\x77\xad\xd1\x6d\xf5\x5a\xbb\x0d\x5b\x60\xe9\x26\x65\x59\xa8\x4c\x86\x97\x46\x43\x9a\x91\xde\xd8\x6d\xfc\x6a\x79\x5e\x1a\x25\xb9\xb7\x79\xc2\x51\x8c\x8e\x54\xc2\x8a\xdf\xef\xae\x9b\x2f\x7d\xe5\xeb\x3a\x6d\x8f\xae\xea\xf7\xbb\xef\xdc\x33\xad\x13\xd1\xf5\x7d\x98\x46\xc9\x22\x63\x27\x2f\xe0\xf4\x7e\xe2\x39\x20\x3c\x7b\xf1\xf3\xb3\x17\xcf\xde\xfc\x17\xeb\xb3\x2e\xdb\x61\x9d\x82\xdd\x19\xd8\x89\x65\x80\x07\x5c\xcc\xcf\xd3\x68\x16\xe5\xd1\x7b\x71\x48\x88\x15\x9b\x19\x80\x58\xf3\x95\xd0\xd8\x58\x5f\xd1\xed\x40\xfe\x61\x02\x98\xd1\xa4\xca\x32\xfa\x3d\xd4\xa0\x71\xdf\x09\xa4\x03\xfa\x4b\xb3\x9d\x9d\x99\xb9\x9e\xe9\xda\x84\x22\x77\x6c\xd6\x72\xa4\x82\xf7\xa2\x6c\x62\xb6\x73\x31\x66\x2a\x3d\xae\x91\xd6\x6d\x9e\x26\x23\x9e\xb9\x4e\x08\xbe\xe5\x6b\x16\xad\x63\x86\x7e\xe3\x59\x36\x20\xc3\xa3\x5c\xfa\x93\xe3\x41\x0a\x30\x04\xe9\x07\x91\x1e\x42\x95\x3e\x4d\xe8\xe9\x6c\x12\xe5\x18\x5a\x6e\xc6\x19\x8f\xdf\x47\x69\x12\x63\x98\x3a\x5b\x59\xd0\xeb\xb0\x81\xf0\x1a\xa5\x51\xa6\xb5\xed\x5b\x3f\x3f\x26\xe6\x6d\xd0\x71\x46\x8b\x34\x8b\xde\xf3\xe9\x52\x13\x58\x52\x35\xc8\x16\xd9\x88\xcf\xf1\xc5\xb6\xe0\xb4\x70\x3a\x95\x77\xd1\x53\xc1\x60\x59\xb3\x4d\xfb\xd4\xc9\xc6\xe5\x65\x17\xa5\x49\x93\xdd\x63\x8d\x86\x8d\x10\xf2\x9b\x83\x91\x7a\x0e\x6c\x73\xda\x81\xf3\x01\x83\xe9\xe9\xd4\xd8\x06\xb2\xb5\xe1\x63\x05\xe8\x99\x6e\xb2\xe6\xfa\x9a\x35\x3a\x0d\x48\x50\x2e\xd6\x95\x84\xd6\xef\xb3\x6d\xb5\xe2\x9a\x42\xc2\x6d\x77\x1a\xfa\x7e\xb9\xdc\xba\x5d\x1e\x00\xbe\x77\x33\xf9\x6e\x7f\xad\xbc\x44\xfb\xde\x5c\xb5\x49\x0b\xa8\xb7\xde\x2e\xcd\x51\x70\x68\x62\x92\xce\xc3\x7c\x22\xdd\x69\xc6\x51\x0a\x5e\x44\x29\x8b\xe2\x09\x4f\x23\xb1\x4f\x99\xb3\xac\xe7\x56\xf8\x1a\x3b\x2a\xde\x1a\x5f\xe7\x1e\xd9\x7a\xb7\xe6\xbf\x97\xba\x46\xa8\x53\x1c\x3e\xff\x18\x65\x62\x26\x56\x05\x35\xb5\xce\x5e\xc3\x36\x3a\x96\xaa\xf8\xf4\xf4\xb7\x3c\x8c\x35\xe5\xb3\x50\xdc\x8f\xed\xfb\x98\x46\xd8\x28\x8d\x62\xea\xd6\x6c\x9f\xd6\xad\xeb\x1e\x7a\x56\x03\x3f\xf5\x06\x47\x25\x02\xce\x73\x8d\xe4\x79\xbc\x44\xce\x28\x92\x13\xad\x26\x2d\xc3\xc9\x25\x1a\x02\x74\xe3\x59\x43\x37\x9b\x56\x17\x7a\xf1\xfb\xed\x8d\x39\x9f\xcb\x6b\x92\x1a\x6e\x0f\xc7\x38\xba\xc1\x9a\x0c\x2b\xce\x4b\x6f\xa4\x71\xed\x1a\xec\x7a\xc1\x97\xe5\xdc\xea\x6c\x4a\xbf\x5a\xf3\xa6\x8d\xb7\xa5\xd3\x26\x3d\x96\x5c\x4f\xb3\x32\xb1\xf7\xab\x7f\xbe\x76\x37\xf7\x23\x1d\x85\x59\x5e\x21\xca\x76\x1f\x74\x88\xa2\xa6\x0c\x8f\x65\xc6\xd8\xef\xd7\x55\xea\xaa\x32\x8b\xf7\xba\xa6\xeb\xdf\x94\x73\x89\xbf\x62\x77\x2d\x57\x02\xaf\x50\xc6\x79\x66\x49\x7c\xa3\xfe\x38\x6b\xcb\xd1\x82\xfd\x6b\x12\xfa\x5f\x97\x41\x1b\xf2\x68\xef\xc6\xc4\xb0\x2d\x8c\x3c\xb2\x45\x62\x84\x0c\x3e\x47\xd6\x51\x5c\x24\x7d\x02\x34\x3f\xaf\xce\x65\x29\x1a\x38\xce\x9e\xc6\x92\x80\x7e\x64\xab\xbd\x16\x8d\x27\x91\xf1\x14\x50\x59\x2c\x8d\x27\xa6\x71\xa8\xf3\xcb\x51\xf2\xfe\x4a\x46\x0e\x26\x91\x85\xcc\xdb\x08\x99\x99\x4e\xed\x4c\x96\x6f\x92\xd1\xbb\x64\x57\x97\x97\xfa\xd5\xc6\xed\xbe\x83\x75\xd1\xac\x71\x8b\x10\xc6\xf6\x5c\x95\x59\x3e\xa5\x55\xcf\xf8\xad\x2a\x4f\x56\xe9\xca\x8a\xfe\x16\xb8\x5a\x54\x66\x40\xfc\x86\xb9\xb3\xc1\xc8\x62\xbe\x03\x1a\x5a\x67\x55\x7e\x13\x97\x97\x74\xb1\xab\xcf\xe5\x3b\x89\xff\x22\x73\x77\x73\x5f\x3d\x21\xf9\x56\xa5\x8d\xda\xed\x11\x57\x77\x55\xf9\x89\xd8\x5d\xca\x1a\xec\xae\xe5\x08\xb5\x86\x48\x59\x91\x50\x28\xd7\xe7\xa0\x30\x57\x8b\x30\x39\x63\x21\x3b\x8f\xde\xf3\xb5\xe3\xd3\xd7\x48\x37\x54\x25\x75\xaa\xbc\x8a\x6a\x18\xcf\xc3\x91\x38\xc5\x25\xe9\x1a\xe9\x86\x4c\x6c\x13\xa1\xbf\x19\xb5\x8d\xc6\x2f\x21\x25\x5d\x19\x32\x95\x86\x28\x99\x85\x73\x95\x41\xa8\xc5\x4c\x5c\x8d\x00\x75\x36\xcb\xca\xdc\x6b\xb1\xee\xc0\x6a\x38\x6c\x67\x49\x9a\xff\xb4\xf4\x42\x20\x9a\x5c\xd3\xa3\x03\x6a\x13\x39\x11\x8e\x73\xea\x06\xe5\x84\xa2\x37\xfe\x4f\x07\x16\x5f\x52\x47\xa6\xa6\xb4\xe8\x50\x9e\x0d\xa4\x47\x92\x6f\xa1\xcd\x4b\x1d\x7a\x76\xd7\x4f\xf0\x5c\xa5\xb5\x99\x70\x25\xd7\x57\xdc\x7c\x1a\xd8\xe7\x60\x39\x47\x0b\xd3\x74\x76\x15\xb0\x9a\x2f\x80\x94\xa8\x35\x8e\x5f\x7b\x05\xf9\x5e\xae\xa4\x95\xbb\x5c\xed\x6e\xee\x72\x25\x3a\xf8\xa5\xc2\x09\x94\x26\x44\xac\xce\x37\xec\xba\x2a\xca\xd9\xcd\x6a\x4e\xed\x97\x96\x2a\x25\x53\x6c\x96\x4b\xfd\x79\x96\x34\x2c\xfa\xff\xd5\x98\x54\xd1\x9f\x67\x62\x37\xf3\xd6\xf9\x4c\x39\x21\xf0\x68\x7c\x38\x0d\xb3\xac\x3c\x65\x81\xd5\x49\xc4\x33\x99\xc8\xa1\x85\x2f\xc6\x8b\x01\xd5\x31\x6c\xba\xf5\x08\x9d\xe6\x72\x50\x11\xb5\x21\x4e\x01\x3e\x3a\x8f\x06\xfb\xe4\x73\xdb\x44\x2a\x87\xd8\x9a\xbe\xef\x97\x97\x2a\x15\x02\x29\xa7\xf1\xcc\x75\x96\x01\xa1\x62\xdd\x81\xd1\xdf\x11\xe7\x28\x53\xbd\x49\x9b\xaa\xb0\xe7\xba\x99\x9f\xc0\x6a\xe4\xa4\x25\x28\x4a\x04\xaa\x95\x74\xc0\x50\xf4\xd0\xb8\x04\x00\xe1\xf2\x44\x00\x85\xd8\xc4\x62\xfb\x7e\xa5\x48\x89\xc1\x6c\x54\x71\xb3\x48\x7c\x02\xc8\x58\x86\x29\x48\x99\x99\xc1\x82\x5b\x05\xc5\x46\x61\x5f\xa1\x4e\x6a\xec\x3b\x09\x05\x46\x82\x5f\x5a\x6c\x98\xf3\xd9\x5c\xa7\x0f\xe0\x61\x69\x76\x26\x92\x64\x40\xd4\xaa\x4c\x33\x20\x2a\xe8\xea\x6f\xd2\x30\xc6\x24\xe2\xbf\xa4\xc9\xa2\x4c\x51\xeb\x3d\x7a\x58\xd6\xa2\xaa\x2b\xa7\xaa\x06\x21\x58\xf2\xcd\x72\xce\xcb\x0e\xaf\x9d\x62\xcd\xaa\x6e\x74\x25\xdd\x0c\xc3\xa7\x72\xe8\xf5\x70\x12\x4d\x4b\xfd\x62\x77\x1f\x94\xb7\xa9\xea\xb2\x50\xf9\x0b\xa7\x64\x00\xfe\x38\x0c\xa7\x53\x38\x3b\x07\xca\xe5\xa5\x45\x79\x4a\xf1\xfa\x6d\x5d\xac\x5d\x63\x92\x33\xab\x62\xb3\x2c\x3f\xc6\x61\x18\xc7\x49\x8e\x46\xf0\x90\x41\xa7\x2c\xa4\x5a\xf5\x9d\x62\xa2\x85\x79\x92\x65\xd1\xe9\x94\x93\x0e\x70\x6f\x09\x32\x3e\x3d\x6b\x01\x30\x8d\x9a\xf8\x64\xf7\xfe\x5a\xdd\x15\x49\x14\x20\xc6\xe1\x24\x84\xcb\x90\x53\xce\x63\x16\xc5\x51\x2e\xb6\xd3\x8c\x8f\xd9\xb6\xd8\x30\x79\x1a\x34\xad\x1a\x98\x7e\x0f\x51\x33\x31\xcc\xe1\x64\xa9\xee\x12\xe0\x77\xbf\xdf\x67\x77\x70\xff\xb9\x23\xc4\x5d\xa1\xcc\x8c\x92\x1d\xe0\xe7\x3d\x26\x30\x76\x26\x43\x1a\x8d\xb3\x20\x5b\x9c\x1e\xe2\xc2\x05\xb4\xe0\x6f\x35\x54\x09\xdc\x14\xc0\xf3\x42\xd3\x85\xc0\xce\x29\x94\xaf\x24\xfd\x53\x73\x24\xea\x8a\x5d\x2d\xe5\x19\xa8\x14\xb3\x45\x96\x33\x1e\x81\xf3\xcb\x29\x47\xed\x29\x49\xc9\x5c\xb5\x20\x1b\xdb\x1d\x76\x8f\x15\x70\x01\x52\x29\xec\xc9\x6d\x98\x4e\x36\x24\x0d\xbc\x04\x41\x0b\x5d\x2a\x26\x3f\x51\xdf\xac\x3d\x93\x23\xc3\x10\x87\xa6\xc9\xc0\x0c\xb5\x4e\x4e\x0c\x5f\xde\x0c\xc1\x66\x4a\xee\x12\xe2\x4a\xfc\x32\x9e\xbf\x52\x28\xbc\x3c\x63\x07\xfe\xef\x25\x13\x64\x70\x6b\x0f\x87\x30\x92\xe1\x90\xf5\x49\x15\x9d\x77\x83\x2e\x7b\x48\xec\x23\xe4\xb3\x10\x13\xa3\xc2\xfe\x3e\x3c\x4c\x66\xf3\x24\xe6\xb1\x54\x7c\x0c\x97\x50\x20\x2d\x46\xea\x81\x75\x45\x43\xa0\xd5\xb4\x4f\x8a\xbb\xf0\xd1\xa9\x83\x56\x6d\xee\x5b\xd9\x12\x2a\x96\x23\xb6\xb5\xd0\x21\xe3\xbf\xbc\x54\x34\x3c\xb7\x69\x68\x75\xd6\x74\x9d\x4b\x64\x36\x43\x93\x44\x80\x2a\x40\xce\xd0\x8f\x3f\xa9\x27\x7d\x7b\xac\x81\xa1\x7e\x1b\xad\x5b\xfa\xad\x99\xc9\x97\xac\xe2\x00\x3b\x09\x31\x54\xbc\x1e\xd1\x39\x9c\x94\x32\x9a\x31\x61\xa4\xe8\x2a\xe6\x07\x55\x25\xfd\xc9\xaa\x27\x33\xab\x91\x6a\xf2\x0b\xad\x15\xce\xe7\x1c\x5e\x0c\xc8\x3a\xf8\x9b\xd6\xe0\xb1\x8c\x76\x8b\x15\xe0\x27\x2d\x9f\xf2\x10\x73\xd0\x2a\xb5\x2d\x7c\x0f\x5e\x2a\x96\x5b\x8f\xdc\xbe\x55\xec\x60\xb9\xee\x9e\xe2\xc1\x30\xd0\xd0\x0a\x9b\xb0\x6a\x60\x3a\xfc\x64\x08\xb0\x47\x68\x71\x65\x6a\x60\x5f\xed\x43\x39\x5a\x38\x98\xeb\xa1\x13\x4e\x86\x6f\x32\x6e\x49\xd3\x4a\x70\xb1\x1e\xd2\xd0\x67\x71\x97\x2d\xa2\x0e\xe8\x5b\xbf\x14\xfd\x5f\x42\x96\x98\x6c\x8f\x15\xc9\xaf\xa7\x40\xd7\x29\xcc\x80\x9e\x05\x5d\x05\x7e\xb9\x55\x90\x1f\x61\xd4\xdb\x0d\x76\x0f\x07\x6e\xd5\xb9\xb2\x9b\x40\x55\xfa\x0c\x77\x5f\xff\xb8\x52\x0f\x8f\x68\xfc\xc3\x41\x93\xe6\x47\xa5\x14\xd9\xbf\x75\x15\xa8\x69\xd1\x62\xa1\x25\x57\x7d\x9b\xaa\x4d\x82\x3e\x48\x84\x3d\xaa\x25\xe9\x39\xd0\x19\x0b\x91\x0c\xab\x2a\x01\x21\xaa\x2b\xdd\x32\x4b\xa5\xa4\x62\xcc\x5f\x9e\x89\x6f\xc1\xb1\xaf\x18\xae\xca\x5b\xde\x96\x32\xd0\xf2\x00\xcc\x7c\x84\x6d\xbd\x60\xe2\xe5\xad\x2b\x4d\x12\xf9\xf5\x95\x94\x04\x9f\xec\xf6\x8d\x6c\x1e\xc6\x0d\xa8\x2e\x04\x75\x73\xdf\x93\x78\xc4\x26\xbf\x7b\xa4\xdc\xcc\x69\xfe\x33\x1d\x29\xa3\x0c\x1d\x67\xca\x12\x0d\x76\xbf\x7f\x58\xa8\x5b\x95\x6a\x50\xc3\xfb\x96\x6c\xd0\x24\x1b\xfc\x76\x6e\xff\x76\x6e\xdf\xec\xdc\xde\xfb\x42\x07\xf7\x32\x37\x3c\xdf\x91\xbd\xde\x69\xfd\x8b\x1f\xd4\x4b\x63\x27\x75\xdc\x9a\x35\x0e\xe5\x5f\xf8\x28\x8e\xfb\xe3\x1f\x68\x9e\x27\x7c\xa4\xd2\x04\x66\x6a\x75\xe3\x0a\x11\xbb\xd4\xd5\x3e\x95\x0b\x26\xdf\xa0\xcc\x40\x98\xb5\x41\xe5\x78\x79\x16\x44\x4d\xf6\x63\x9f\x75\x9a\xe2\x3c\x04\x59\x7d\x90\x81\x6f\xd7\x12\x85\x80\x40\xd4\xa4\x8d\xa5\x34\x84\xbc\x8a\xc9\xe9\x3b\x3b\xaf\xa2\x16\x81\xdf\x0c\x0d\xdf\x0c\x0d\xdf\x0c\x0d\xff\x52\x43\xc3\x3c\x4c\x33\xfe\x44\x66\x42\x7a\x79\x76\x14\xc5\xe7\x53\x6e\x89\x7c\x73\xf7\x59\x5d\x35\x30\xcf\x5c\x13\x3c\xf6\x50\xb5\x4b\xc5\x00\xfc\x91\x75\x04\xa1\x8d\x3a\xd6\xc1\xf0\x57\xe6\xf2\xed\xc0\x2e\xdc\x13\x52\xec\x96\x9d\xa3\x4b\xc2\x6f\xc3\x6f\x75\x44\x52\xe9\x9c\x48\xb9\xc9\xf0\x64\x27\x6e\x14\x33\x2d\xfe\x68\x7b\x5d\x33\xb0\xc8\x97\x08\x0f\x1e\x54\xf2\x38\x4f\x97\x85\x67\x32\xd2\xf3\xe3\x1e\x0b\x20\x6f\x8e\xd6\x86\x4d\x72\x1e\x68\xa7\x51\x02\x07\x0d\xfb\x13\xd0\xe6\xc0\xfd\xb8\xc7\x3a\x26\x21\x54\xc7\x98\x3b\x20\xca\x58\x49\x57\xba\x13\x67\x64\x34\xe3\x15\x4d\xbc\xd8\xc1\x44\x3e\xae\xe1\x49\x19\xb4\xd1\xfa\xd4\xdb\xc4\xfc\x74\x88\x47\xfb\x5a\x36\x28\xa8\x6b\x3d\x8e\x1a\xa6\xfc\x6c\xdf\x24\xf4\x02\x74\x84\xee\x03\xb6\xa0\x61\xca\x55\x7e\xb6\xd5\x46\x2b\x6d\x42\x17\xd5\x4d\x7e\xed\x29\x58\x65\x5c\x66\x6d\xa9\x57\x59\x32\x83\xe9\x94\xc7\xe2\x8c\x8c\x3e\x47\x9d\x7d\xfc\xeb\x07\x68\x8d\x3f\x40\xc1\x96\x7c\x01\x0f\xb1\x86\xf2\x38\x60\x38\x7a\xa8\xae\x94\xdd\x6c\xa3\x62\x18\xd4\xd2\x17\xc0\xf0\xc0\x8c\xb3\xca\xb0\x26\xc8\xe3\x1c\x30\x61\x9c\xeb\x1a\xd9\x90\x38\x4d\xd8\xd4\xa5\xb9\x4d\x80\x6e\xb1\x63\xd1\xd1\x40\x25\xd6\x82\x97\x5d\xcd\xa6\x9c\x00\xf5\x6f\x5b\x68\xb0\x5c\x1e\x8d\x19\xba\x03\x42\x42\x93\x3d\xe5\xf1\x8a\x2c\x8c\x95\x27\x61\x3c\x9e\xf2\xa7\xd2\x92\x65\xb8\x29\x4e\xc6\x10\xc9\xe9\x31\x58\x1c\x48\xe4\x06\x35\xf3\x93\x28\xfb\xbb\x32\xc7\x0d\xfd\xf6\x38\xcb\x82\xa3\xaa\xfd\x9d\x5a\xd3\x64\x59\xc1\xa8\xe6\x6f\x43\x8b\x8c\x1d\x8d\x8e\x03\x52\x83\xe1\x68\x03\x82\xbb\x10\x65\x16\x2e\x7b\x56\x37\x66\x59\x5b\x34\xf9\x18\xe5\xee\x39\x70\x45\x97\x84\x0e\x6d\x6a\x76\xa2\x1d\xf0\xd9\x5c\xcc\x54\x39\x2f\x91\xd5\x54\xc3\xa6\x2a\xd7\xb3\x65\x58\x2d\x20\x56\x62\x63\x2d\x0e\x00\x92\x29\xdb\x81\xff\x9c\x4f\x72\x5f\x89\x75\xba\xc2\xa7\xf1\x18\xa2\x6a\x2c\xa7\xbc\xed\x7c\x3e\xf0\x12\x8f\x41\xfe\xc6\x62\xf5\x80\x1a\xd1\xd8\x9e\x4c\xf5\xa9\x3f\x21\x6b\xf3\xfc\x48\x70\xb7\x9d\x1f\x2e\xc3\x04\x8f\xb4\x03\x1b\xf4\x9e\xf3\x9b\xf2\x9b\x59\x1d\xe8\x39\xae\xcd\x78\x4d\x4f\x08\x3d\xd5\x09\xd2\x19\xf6\xe1\x37\xd1\x8c\x27\x8b\xbc\x84\xc4\xb4\xca\x7a\xc6\xec\xc2\xe2\x59\x73\xdd\x14\x97\x4c\xc1\x34\x5d\xa8\x4d\xbf\x16\x0c\xd5\xab\xb4\x0e\x0b\xb3\x26\xbb\xb7\xb2\x81\xb5\x04\x6b\xd4\xf7\xad\xa8\xe2\xa4\x5c\xe3\x56\x41\x4c\x40\x4f\x4e\x84\xe6\x38\x33\x45\xbd\xf2\x0b\x07\xf7\x22\xa1\x57\x71\x93\xe0\x52\xbb\xb7\xe6\x5c\xf6\xd6\x9b\xcc\x9e\x35\x9b\xb4\xba\x96\xda\x65\xe7\x58\x09\xa0\xc5\x8e\x1b\x6a\x38\x90\x02\x8d\xa2\x2b\x3e\x50\x7c\xc4\x6f\xda\x61\x63\xd0\x2c\x64\x08\x5f\xfb\xa6\xc3\x73\x53\x60\x2d\x7c\x9c\x10\x67\xe1\x3f\x45\xeb\xb7\xbb\xbb\xb5\xec\x4a\x1f\xa3\xdc\xae\xf3\x31\xb2\xee\x23\x72\x5c\xb3\xb2\x8e\xbd\x8c\x89\x90\x30\x4d\x88\x95\x54\xe3\x0f\xb2\xea\xa6\x2e\x50\x4a\xae\x4d\x90\x7b\x71\xd3\x77\x4a\x9c\xdb\x9e\x24\x9e\x2e\xf5\x75\x4f\xb3\xe4\xf6\x62\xad\xcb\x0b\x00\x7d\x9d\x1b\x0c\x7d\x1d\x53\xe3\x22\xa3\x66\x5d\xfb\x9a\xa7\xba\x6e\xf5\xad\x86\xbc\x9b\xd0\x97\x08\xbd\x95\xb7\x08\x92\x0e\xee\x55\x42\xe5\xf3\x73\x63\xfd\x92\xb0\x87\xc3\xba\xd7\x0a\x3b\x77\xd9\x24\x4c\x67\x49\xbc\x64\xd1\x0c\x5c\x43\xef\xee\xa0\xbc\x1a\xfe\xf1\xf4\xa7\x57\x8f\x0f\xff\x63\xf8\xec\xf9\xab\x97\xaf\xdf\x3c\x7d\x32\x7c\xfe\xf2\xc9\xef\xbf\x3d\x1d\x76\x86\xd3\x64\x1c\x66\x93\xa1\xf4\x36\x87\x53\x68\x69\x42\xcd\x1b\xe9\x60\x68\x68\xe5\xe9\xa8\x1d\x07\xeb\x00\xbb\x1e\x52\x5d\xe4\xcb\xf2\xc1\x6e\x08\x76\x83\x21\x6a\x18\xd7\x43\xa1\x07\x8c\x3b\x14\x67\x87\xac\x74\x78\x9d\x9b\x80\xbd\xc1\x18\x6d\x40\xd7\x43\x66\x77\x08\xa9\x8a\x87\xaf\x16\x29\x7f\x0d\xbb\x77\xf9\x6c\x3e\xb8\x5e\x17\xf7\x65\x17\x4f\xc2\x3c\xfc\x3d\x8f\xa6\xe5\x04\x85\xcc\x5f\x0c\xdc\x7c\x6b\xfe\x77\x97\xfd\xdb\x59\x34\xe5\x2f\xdf\xf3\xf4\x7d\xc4\x3f\x30\x69\x8d\x66\x6f\x92\x64\x9a\x47\x73\x76\x98\xc4\x39\x44\x82\xaa\x0b\x6f\xe7\xdb\x7d\xdd\xb7\xfb\xba\x6f\xf7\x75\x9b\xdf\xd7\xc1\xbf\x3d\xe3\x70\xfb\xed\x02\xe4\xdb\x05\xc8\xb7\x0b\x90\x7f\xd1\x05\x08\xfc\x87\xf2\x15\xf6\xc7\x9f\x93\x74\x16\xe6\x8e\x4d\xd2\x2d\xf3\x04\xee\xb9\x8e\x7e\x1a\x34\x15\xa0\xad\x2d\xf5\x22\x7c\x2d\x65\xe1\xf8\x0e\xbf\xc3\x76\xee\x32\xb0\xff\xbf\x4c\x8f\xf2\x94\xdd\xdd\x19\x48\xa8\xc7\x9d\xc1\x67\x02\xdc\x1d\x88\x95\x03\x7f\xb7\xdf\x25\x51\x1c\x34\xd8\xff\xc3\x20\x46\xae\x0c\x8b\xa2\x36\x4a\xa9\x73\x48\x95\x43\x6a\x1c\x26\xcf\xca\x7a\xba\xd7\xf1\x9d\x10\x70\x52\x5a\x21\x20\xa4\x6f\x23\x1c\xf7\xd8\x5e\xcd\x0b\x0a\x2f\x86\x15\x97\x14\xde\xfa\x2b\x3c\x66\xbd\x6d\xd6\x76\x9d\xf5\x42\xa9\x63\xde\xf7\x77\xbf\xa6\x33\x6d\x09\x9d\x3c\x5e\xb5\xb2\xac\xd2\x0c\xe6\xd2\xad\x96\x59\x72\x1e\x2e\xa7\x49\x38\x36\x36\x43\xf9\x81\xd6\xc9\xf8\x3c\x4c\x43\xd4\x91\x64\x2d\xfd\x89\xd6\x3b\x23\xab\x5c\xd6\xd3\x9f\x2c\x13\x6d\xce\x67\x60\xa5\x36\xf5\xf4\xa7\x42\xbd\x24\xb5\x00\x9a\x6f\xc6\xa0\x09\x6a\x8a\x1c\xc7\xd6\x96\x1a\x92\x73\x07\xa9\xe8\x31\x8d\xb2\x5c\x75\xfe\x89\xcd\xc3\xf1\x38\x8a\xcf\xf7\x58\xa7\xc5\x66\x61\x7a\x1e\xc5\x7b\xac\x03\x2a\x29\x6d\x23\x3a\x85\x47\xa3\x12\x72\x96\xa4\x79\x60\x30\x69\x82\xe3\xad\x59\x18\x70\xd1\xd8\x62\x91\x6d\x29\x82\x64\xf1\x51\x1c\x4e\x9f\xd1\xe1\x6b\xf3\x97\x75\x64\x18\x47\xd9\x7c\x1a\x8a\xe9\x3f\x9d\x26\xa3\x8b\x86\x6d\x08\x92\x48\xbf\x49\xe6\x7b\xec\xbe\xb7\xe8\xa7\x24\xcf\x93\x59\xa1\x74\x94\x4c\xc5\x36\x83\x17\xa1\xf0\x43\x30\x78\xe3\x6f\x9d\x4e\xa7\x41\x2a\x5e\xb5\xcc\x14\x11\x5b\x12\x0e\x61\x12\x66\x32\x4a\xfc\x4d\x8a\x40\x44\x29\x0e\x67\xc5\x0e\x81\x66\x74\x03\xc1\xba\x86\xd9\x84\xfa\x4d\x7f\xb8\xfb\x0a\x99\xcc\x1a\x1b\x4b\xc1\x18\xd0\x0e\xab\xac\x79\x8d\x69\xe4\xcc\xce\x27\xd4\xfd\x04\x91\x60\xf9\x8e\x26\x61\x9a\x67\xdb\x39\x2e\xf2\x6d\x41\xd9\x46\x4b\x2e\x6e\xfa\x11\x3d\x95\xe5\xed\xc7\x9e\xcb\x2a\x8e\xc3\xb2\x9a\x85\x83\x9b\x1b\x09\x93\xce\xb6\xae\x33\x75\x8d\xf1\x6c\x8b\x89\x6b\xb8\x38\x32\x66\x66\xd5\x2a\x68\xca\xdb\xa0\xaf\x7a\x48\x5a\xc2\x79\xc6\xa5\xcb\x6a\x0c\xeb\xab\x18\x0c\x6c\x18\x9e\x81\x38\x6b\xeb\xc0\xf9\x20\x97\xa5\x8c\x8c\x66\x66\x53\xfe\x0d\x22\x4e\x89\x13\xa8\x64\xd3\xe3\x2b\x24\xc4\x22\x8e\xf2\x52\x46\x15\x85\x20\x10\x1b\xf6\x38\xca\x1e\x06\x10\xc1\x72\xb3\x62\xa5\xb1\x98\x5a\xa3\xab\x33\x32\xb1\xaf\x35\xb4\xf4\x30\xbb\xdc\x95\xbb\xa3\x66\xb7\x0a\x83\xb9\x72\x6e\x76\xf0\xaa\x96\xdd\xd8\x85\xdc\x8a\x6b\xb7\x69\x78\xca\xa7\xb6\x42\xd0\x6b\x9b\x8f\x85\xaa\x6e\xad\x42\x85\x9f\x0b\x8a\x88\xac\xf9\xb3\x4f\x1d\xf9\x90\x86\xf3\x39\x4f\x5d\x04\xe8\x67\xeb\x16\x11\xd6\x48\xc5\x06\xae\xf5\x08\x92\x97\x5c\xa9\x19\x5d\xf2\xf1\x34\x1c\x5d\x9c\xa7\xc9\x22\x1e\x1f\xe2\xbe\xdc\xf8\xdb\xd9\xd9\x19\x99\xf8\xd3\x24\x1d\x73\xf1\xbd\x3b\xff\xc8\xb2\x64\x1a\x8d\xd9\xdf\x46\xa3\x11\xa9\xf1\x61\x12\xe5\xfc\x68\x1e\x8e\x04\x5f\xc4\x89\x40\x59\xf1\xee\x55\xcb\x1a\x98\x9e\x6b\x3d\x82\xdf\x2c\xaa\x57\x0c\xc3\x00\x34\x73\x62\x81\x9b\x84\xd9\x6f\x72\x5e\x6e\x52\x27\x80\xde\x4a\xf0\xc6\x50\x39\xf8\xe7\x81\xe4\x0a\x8c\xa8\x48\x74\x42\x5d\x63\x6b\xcb\xe1\x0b\xaa\x99\x59\x40\xed\x6a\x0e\x0a\xee\x32\xb9\x91\xd5\xde\x18\x47\xef\x1b\xd6\xa3\x2f\xdf\x52\x97\x60\xd4\x92\x6f\xd8\x6a\x42\x61\xa5\xdf\x94\x1c\x9a\xaf\x23\x86\x80\x58\x0e\x66\x84\xc9\x2c\x41\x64\x0a\x8d\x34\x6a\xd9\xbe\x21\xce\xa1\x66\xe5\x45\xa6\xf7\x30\x05\x97\x99\xab\x89\x71\x7c\x47\x1f\x4d\xef\x0c\xf4\x65\x67\xaf\x2d\xf5\x70\xa9\xf0\x36\xbc\x5d\x34\x4c\x75\xf7\x72\x54\xeb\x09\x7b\x6b\x5f\xcf\xb4\xc3\x36\x06\x05\x11\x54\xd1\xea\xed\xb5\xe0\x40\x04\xf7\x5b\xb6\x9c\xbb\x16\x20\x73\xe1\xaa\x8f\x07\x1b\xc2\x31\x02\xe5\x26\x00\xfd\x7c\x23\x64\x02\x50\xd7\x82\x10\xc6\xcb\xd6\x2d\x7d\xa4\xbe\x1e\x88\x34\x0d\x97\x2f\xcf\x6a\x5f\xc2\x51\x76\x99\x84\x73\x2e\xe5\x77\x0c\x4b\xf4\xfa\x43\xd0\x1b\xfb\x75\x26\x85\x3c\x22\x5c\xbf\xb5\xca\x32\x75\xfd\xf5\x72\x6d\xb2\x0f\xa4\x04\x12\x6a\xe0\x75\x89\x07\xb9\x80\x9a\x7a\x89\x80\x79\xe0\xda\xdc\x68\x5e\x49\xf6\x7c\xcf\x24\x89\x74\x69\x88\xcd\xcf\x59\x98\x9f\xae\xdc\x15\xf6\xe9\xca\x3c\xa4\x84\xb8\x74\x08\x1c\x1c\x1d\xf4\x2d\xab\x32\x04\xa2\x17\x03\xbb\xbb\xe3\xf3\x6c\x38\xbe\x13\xde\x19\xb0\x7e\x89\xfd\xac\x59\x74\x9d\xa8\x0c\x94\xfe\x2f\x72\x9d\x18\xf3\xd3\x64\x11\x8f\x78\xe9\xf5\xf0\x83\xde\x86\xbe\x13\xa6\x87\x9b\x70\x9e\x30\xd0\xbe\x79\x4f\xfc\xaf\xf5\x9e\x80\x15\x0b\xa9\x1e\x4b\x07\x7a\x4d\xae\xb5\x61\x6f\x30\x50\x1b\xd0\x75\x7d\x38\x90\x21\x52\x9e\x45\x7f\xf2\xe1\x98\xe7\x7c\x94\x27\xe5\xbe\x22\x8f\x76\xaf\xe9\xe7\x54\xda\xd1\x06\x04\x28\x85\x79\x3d\x14\x1f\xac\xe7\xcf\x72\x8d\x1e\x1e\xca\x1e\x7e\x4b\xce\xab\x3b\xd8\x7d\x00\xaf\x5d\xbf\xf9\x6b\x7c\xf3\xd7\xb8\xa1\xb8\x68\xdf\xdc\x34\xbe\xb9\x69\x7c\x73\xd3\xf8\x17\xb9\x69\xc8\x00\xa7\xb6\x4b\xe3\x1f\x68\x26\x20\x11\x87\x20\x41\xf3\x05\x67\x68\xef\x61\xe1\x38\x9c\xe7\x2a\xbf\x25\xe4\x50\x4d\xce\xd8\x3c\x4c\x45\xd5\xbb\xec\xc9\xcb\xe7\x10\x66\xf4\x16\xf1\x02\x79\xcd\xb3\x79\x12\x67\xd1\x7b\xb1\x82\xf2\x30\x8a\xc1\x32\x7b\xbd\xd8\x5b\x1e\x58\x15\x9e\x05\x9e\xda\x81\xda\x79\x2a\x9c\x0b\x3c\xcd\x9a\xd6\x3b\xc9\xba\x2f\x08\x3d\x80\xea\x78\x17\xf8\xfa\xc7\xe7\x83\x12\x30\x8e\x41\xe1\x84\xef\xd4\x16\xf3\x71\x98\xf3\x27\xd1\x8c\xc7\x62\xf5\x64\xcf\x66\x33\x3e\x8e\xf0\xed\xa0\xef\xe1\x16\x48\x2b\x6c\x3a\x4b\x16\x71\xce\xc7\xd4\x2c\x8a\x52\xa6\x60\xfa\x14\xc3\x8f\xf9\x87\x23\x99\x11\x19\x5a\x9f\xf3\x5c\xa3\x29\x0a\x82\xa6\x65\x86\x95\xd5\xdd\x8b\x78\x7c\x09\xa8\x1e\x37\x92\xa7\x8e\xf6\xe5\x4c\x32\x1d\xff\x11\x8d\x31\x5b\x81\x69\x21\xb6\x6b\xec\x10\x0a\x0b\x4d\x7e\xe5\xd1\xf9\x24\x2f\x6b\x83\xa5\xfb\x16\x3a\x36\x40\xcc\x7f\x27\xd0\xae\xec\xc9\x81\xe8\x6b\xa5\xfa\x32\x77\x45\x90\x1b\xd0\xee\x4d\x88\x46\x3d\xd0\xcb\xcb\x02\x5c\x59\x8e\xbf\x6c\xb7\x82\xa1\xfd\x90\xee\x93\x33\x90\x3d\xe7\x77\xcb\x85\xbd\x57\xe8\xec\xca\xf3\x7e\x44\xbe\x99\xb3\xf8\xcd\x7d\x97\xea\x76\x6c\xd2\x13\x14\xba\xdc\xee\x7a\xe0\xe1\xc3\x9d\xd7\x1c\xd3\x32\x4b\x1d\x50\x1d\x7a\xe5\x1b\xee\x6b\x1d\xba\x83\x66\xb0\x62\x85\xb4\x9c\xde\x84\x00\x5d\xd1\xc4\xca\xa5\x38\xc4\xa7\x66\x72\x9d\xec\xdc\x65\x3c\x9b\x46\x71\xbe\x3d\x8e\x32\x50\x0c\x19\x1c\x08\x76\xe2\x64\x7b\x1c\x8d\xb7\x61\xb5\x6d\x67\x3c\xdf\x46\x12\x82\xb4\x74\x5c\x83\xbc\x62\xce\x72\x0c\xd2\xf2\xf9\x49\x34\x7e\x2e\x20\x96\x5c\xc9\x15\xea\x11\x11\x40\x17\xbf\xd2\x5e\xe9\x4a\x97\x53\x51\x67\x95\x67\xce\x12\xb7\xd9\x12\x4a\x57\x3e\xc0\xd4\xa8\xfe\x11\x4d\xa7\xbf\xc7\xb3\x3a\xa3\x22\x55\xcb\x07\x26\x53\x5f\x94\x74\xeb\x8e\xac\xa4\xcb\x22\x01\x6c\x51\x0a\x7d\x6a\x56\x2f\xca\x52\x72\xad\x5a\xbc\x4b\x32\x95\xdd\x65\x64\x83\x6d\x8f\xa6\x11\x8c\xda\x92\x45\x85\x05\xe6\x6d\x84\x85\x0a\x81\x15\x17\xbc\x87\x62\xb3\xaf\xf6\x37\x13\x35\xdc\xab\x5e\x25\x14\xfc\xe2\xbc\x20\x64\x87\xab\xa4\x79\x51\xc2\xba\x4d\x5c\x01\xeb\x11\xaf\x3f\xb0\x8e\x4f\xaa\xfe\xc0\x3a\x75\x67\xa9\xce\x03\xdf\x6c\x2e\x93\x6b\xc9\x97\xbd\xf0\xdb\xba\x68\x56\x83\xc6\x0a\x1f\xdc\xb1\x4e\xf4\x10\xb1\x02\xfe\xa6\x35\x66\x51\xfc\x87\x0d\x44\x7d\x71\x6a\xfd\xea\x80\xd2\x9f\xac\x7a\xe1\xc7\x42\x3d\xf5\xa9\x5e\x7c\x4d\x43\xf5\x95\x17\xbf\x45\x1b\x83\x72\x3d\xfd\x10\xa6\x31\xde\xf8\xae\x04\xe2\x31\x85\x1c\xdf\x39\x97\xb7\xc7\xaf\x78\x3a\x02\x1d\x54\x80\x02\xe2\x36\x8d\x86\x75\x23\x40\x71\x42\x9a\x2d\xd6\x78\x33\xe1\x38\x9d\xc1\xff\xc9\x9a\x90\xae\x12\xcb\xf0\x67\xca\xd9\x69\x92\x4f\xd8\x59\xf4\x91\x8f\x19\x5e\x69\x64\xad\xb7\xb1\xa6\xfb\xf2\x94\xb3\x65\xb2\x60\xe3\x24\x7e\xdb\xc8\x59\xcc\x31\x29\xe6\x22\xe3\x2c\xf4\x29\x9f\xed\x46\x0b\xbb\x6b\xc9\x7e\x8c\xec\xbd\x11\xc2\xdf\x96\xcc\x7b\x79\xa9\xd8\xf8\x47\xd6\x91\xc3\xc4\x0f\x30\x30\x38\x8f\x9d\x72\x76\x0e\x1b\x55\xca\xf2\x49\x18\xb3\x3f\x79\x9a\x08\xfc\xb0\x5e\xd3\xda\x3f\x46\xe1\x74\xb4\x98\x86\x39\xd7\x3a\xdc\xcd\x4f\xf1\x81\x2b\x55\xf6\x90\x54\xfb\x5e\x3c\x34\xc3\xdf\x3c\x5b\x50\x4c\x64\x37\x7b\x72\xba\xac\x9d\x52\x52\x78\x6b\x8b\xd0\x9a\xca\xa1\x9d\x1d\xf6\x4a\x66\x00\x86\x23\xd6\x98\x67\x51\x0a\x69\x58\xa1\x36\xbc\xa7\x37\x92\xbf\x38\x32\x97\xe8\x3b\xb2\xe5\x3e\xed\x21\x3a\x23\xcb\x3f\xca\x58\xc6\xf3\x16\x4b\xde\xf3\x54\x1c\x5b\xb9\x28\x2e\x40\x8e\x32\x7b\xe2\x75\x7b\x4b\xb3\x35\x50\xb7\xb6\x8a\x30\x7e\x34\xad\x6c\x35\xd6\x33\x0e\x5d\xd3\xa7\x8e\xde\x24\xf7\xbb\x04\xfb\x51\x6e\x17\x45\xe4\x3b\xab\x96\x7e\x72\x86\xa7\x64\x96\x4d\x92\xc5\x74\x5c\x58\x2c\x1d\x23\x05\xe6\x53\x1e\x66\x5c\x66\x1e\xc3\x14\xad\xcb\x29\x9c\xa5\x47\x46\xe3\x4b\x52\x9d\x02\x24\x2b\xed\xd5\xc0\x4c\x52\x16\x8e\xc7\x2c\xd4\x1b\x05\x22\x95\x9a\x2d\x41\x7d\x00\x51\x63\x56\x36\x66\xe4\xcd\xd3\x64\x2a\xfa\xd3\xf0\xe4\x8e\x24\xba\x83\xce\xc5\x3a\x77\xa8\xd5\x2a\xd0\xc9\x11\x55\x2d\x8d\x4c\xcb\xa0\x51\x14\x17\xd7\xf3\xa9\x99\x26\xb1\x76\x5c\x31\x91\x8f\x0d\x63\x7d\x90\x67\x20\x07\xe7\x5b\xf6\x96\xbb\x57\x18\x83\xe2\xb3\xaf\x23\x2e\x45\x61\xdb\xef\xd5\xdc\xf7\x7b\xfe\x8d\xff\x83\x03\x6c\x95\x26\xd2\xf3\xa9\x22\x05\xe5\xa1\xe7\xd7\x1e\xa2\x31\xa9\x11\x59\x0f\x0b\xb4\x3b\x11\x0d\xb8\xa1\xbe\xd9\x07\x11\xed\xb1\x2f\x67\xd4\x62\xb1\xbd\x02\xab\xed\xf9\x98\x6e\x8f\xf2\x9f\xc6\x75\x8f\x0c\xe5\x6a\x43\x76\xac\xe7\xe2\x65\x11\x67\x8f\x95\xd0\xa4\xca\x6d\xc0\x7f\x57\x17\x34\x03\xe3\x95\x95\x6a\x2d\x62\x5b\xcb\x13\xb1\x7a\x15\x78\xcb\x3b\x57\xba\x6c\x65\xae\xbb\x65\xca\xcf\x2c\xae\x3e\x83\x38\x52\x4d\x27\xb6\xb7\x0c\x59\x31\x22\xb6\x3d\x51\x8d\x3a\xf2\x5f\x19\x11\xee\x77\xf3\xc2\xb3\xc4\xcd\x78\xb0\x6d\x70\xdb\xd7\x0e\x5b\xec\x93\x0c\xa4\xa4\xce\x5f\x60\xbd\xc5\x4f\xfa\x78\x05\xdf\x92\x18\x8d\x15\x56\xe0\x11\x69\xbf\xa8\x11\x36\xdc\xa3\xe7\x6d\xe4\xae\xe6\x7a\xab\x79\xe0\x37\xca\xe3\x78\x80\x38\xbe\x96\xab\x8a\x74\xd9\xb9\xa5\xa5\xed\x17\x77\x1a\xda\xc0\xf3\x07\x91\x47\xd7\x1f\x25\x4c\xfe\xaa\xf8\x13\x41\xf7\x17\x1e\xc2\x1f\x7f\x6d\x26\x22\xfb\xca\x5f\x75\x08\x24\x9c\xce\x35\x00\x25\x63\xde\x8e\x32\x19\xad\x19\xb6\x36\x65\x55\xdd\x50\xba\x44\xd7\x73\xa9\xfc\x3a\x48\x5a\x67\x57\xff\x7a\x87\x50\x9d\xaf\x41\x8a\xfd\x46\xb7\xd3\xf9\x3f\x0d\x2a\x48\xcd\x17\xc3\x02\x1d\x9a\xcc\x61\x03\xcf\xc3\x92\x2b\x3a\xc7\xef\xf0\xd1\xd7\x98\xfd\x01\x55\x84\x27\x52\xf9\x28\xf5\x68\xfa\xbe\xa4\x41\x55\x00\x75\xbb\xe6\x17\x89\xa3\x5e\x0c\xa5\xe5\xe2\xab\x8a\x8a\xd3\x53\x27\x41\xfe\x17\x9f\x9e\x6f\xa1\x78\x86\xd9\x34\x1a\xf1\xf1\x9b\x44\xe5\x9d\x2f\x71\xee\x82\x6a\xcf\x72\x0e\x5e\xc8\x41\x98\xa6\xf8\xe8\x19\xcf\xb4\x61\x2a\x58\xfb\x78\xb0\x8f\x3f\x63\xed\x1d\x05\x3f\xcd\xad\x0c\xfe\x16\xf4\xd0\xa1\xaa\xf7\x59\x9e\x2e\x29\x69\x87\x11\x90\x2b\x3d\x3e\x5a\xce\x4e\x93\x69\x3b\x92\x7d\x0e\x02\xa1\xfd\x66\xfb\xec\x76\x00\x1d\x04\x43\xb8\x96\x8f\xda\x31\xff\x98\x07\xcd\x66\x7b\x9c\xc4\xbc\xb9\x6f\x7a\x17\xd8\x09\xcc\xda\xf3\x45\x36\x09\x86\x19\x3e\x5b\x94\x4e\x18\x91\x60\x7d\x28\x55\x69\xc3\xfb\x7d\x31\x20\xcc\x56\x0e\x04\x1b\x85\xf9\x68\xc2\x02\x9e\x82\x2b\xd2\x50\x5f\x9a\xe1\x00\x78\x9a\x8a\x6a\xf0\xb8\x65\x2a\x06\x80\xc3\xc0\x8b\xf6\x18\xa0\x47\xc7\x77\x90\xe8\x77\x06\x4d\xeb\x57\xd0\xb4\x9b\x8a\x46\xc3\x71\x53\x7a\xca\x0c\xb9\xe5\x1a\x26\x90\xdc\xf7\x79\x8a\x99\x39\x10\xed\x61\xfa\xda\x2a\x21\x79\x98\xa2\x5b\x94\x6c\x24\x41\x40\xc2\x7a\x51\xd9\x21\xad\x60\x41\x69\x5d\x73\x1a\x7a\x67\x5d\x83\x2a\xf1\xed\x79\x16\xbf\x0f\xa7\xd1\x98\x85\xb9\x10\xfd\xe0\x3e\x32\xe6\xe8\x33\xb1\x48\x39\x8b\x93\x78\x1b\x7a\x3e\x9d\x1a\x97\x2e\xe9\x89\x65\xbb\x8f\x7d\x73\x3a\xfc\xe6\x74\xb8\xb6\xd3\xe1\x67\xc9\xdf\xf2\xd9\x53\xab\xa4\xd6\x36\x0a\x8f\x38\xca\xfa\x7a\x74\xbf\xf3\x2d\x7f\xe9\x37\x77\xcd\x6f\xee\x9a\xff\x37\xbb\x6b\x4a\x57\x4a\xfb\xec\x50\xd3\x67\x92\x34\xaa\x76\x97\x24\x15\x57\x44\x60\x2a\x9e\x35\xd8\x75\xfc\x23\x09\x8c\x9a\xae\x91\xb4\x57\xe2\x15\xe9\xb8\x43\xba\xee\x69\xfc\xe3\x3c\x8c\xc7\x10\xda\x57\x19\x68\xf4\x63\x7c\x52\x26\xcd\x4f\x4e\xd1\xd1\x28\x4d\xa6\xd3\xdf\xf8\x59\xb1\x15\x16\x41\x30\x1e\x5d\x92\x4d\xd2\x28\xbe\x58\x55\xe2\x80\x9b\x86\x59\xee\xf6\x2e\xbe\x69\x6c\x3d\x3e\x73\x29\xcf\xb8\x76\x73\xc4\x5f\xed\xd3\x28\x1e\xff\xff\xec\xfd\x7b\x97\x1b\xc9\x71\x20\x8a\xff\xcd\x3e\x67\xbe\x43\x10\xbf\x15\x51\xd5\x28\x00\x55\xe8\x37\x9a\x20\x3d\xe2\x70\x24\xfe\xa4\x99\xe1\x1d\x8e\x5e\x8b\x69\x37\x0b\x40\x02\x28\x36\x50\x85\xa9\x2a\x74\xa3\x39\xec\x7b\xb4\x5e\xc9\x6b\xef\xca\x2b\x9d\xb5\xe5\x87\xec\x6b\xdf\xdd\xb5\xd7\x7b\xbc\x6b\x49\xbb\xf6\xda\x1a\x59\xb2\xbe\xcb\x9e\x21\x67\xf4\x97\xbf\xc2\x3d\x19\xf9\xae\x07\x1a\xdd\x6c\xf2\x52\xbe\xd3\x73\x86\xa8\xca\xca\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x8c\x64\x0e\x6f\xdc\xf6\x6c\x5c\x6f\x80\x35\xcb\x12\x7a\x62\xbe\x60\xa1\x77\x5b\xd6\x4d\xcd\xe0\xac\x62\x0f\xb5\xaf\x05\x93\xc9\x4a\x2e\x6a\x32\x63\xd6\x95\x6b\x18\xc5\x7d\xf2\x15\xf4\xc5\xb3\xca\xf7\xe4\xae\xc2\x25\x8e\x69\x99\xba\x9f\x97\xd8\x96\xeb\x9b\xce\x5f\xfa\x3e\x89\x59\x00\x67\x79\x63\x09\x65\x99\x19\x1c\x68\xd9\x85\xfb\x71\x26\x98\xae\x7b\x50\xbc\x29\x97\xc9\xe6\x1d\xc8\x6d\x2b\xc5\x06\x56\xd6\x5f\x44\xcb\xc0\x34\x5d\xb1\x7d\x51\x98\xb3\x80\xba\x6c\x4b\x5b\x8a\x0e\xd6\x1b\x25\x14\x2e\xcc\x6b\xd1\x55\x19\x57\x22\xe9\x63\x26\x9c\xba\x58\x8c\x4a\x0c\xd9\x14\x24\xca\xe0\xfc\xa8\x06\xb6\xf8\x86\x40\x56\xe2\x88\xa5\x08\xe7\x33\x66\x59\x90\x8d\xf6\x46\x22\x87\xae\xe0\x0b\xe3\xc3\xd7\x74\xd7\x93\xfc\xe7\xf7\xa2\x59\x61\xb1\x2f\x9a\x6e\x22\xac\x9d\x28\x2a\x0a\x2a\x34\x3e\xe4\x2b\x34\x3e\x6b\x15\x1a\xe9\xba\x67\x45\x21\xdd\xce\xf7\x87\xec\x97\x38\x43\xf2\x7e\xec\x6a\xac\xa6\x6d\xa8\xd1\x69\x3b\xe3\x9d\xc8\xce\x0e\xf0\xdd\xbb\x46\x34\x1c\x26\x84\x3b\x38\x42\x0e\x86\xf2\x2d\x59\x01\x08\xcb\x7c\xb0\x64\x0f\x3f\x21\xe5\x3e\x8e\x74\x10\x9d\xe3\x3c\x6d\x7a\x80\x72\xa5\xe6\x24\x08\x07\xd1\x09\xea\x6f\x55\x69\xd2\xa8\xae\xe8\x5b\xcf\xcf\x51\x64\x45\x8e\xd9\x3c\x63\x6b\x7c\x16\xc9\x1b\xc5\xaa\x6c\x5d\x54\xdd\xd7\x90\x62\x05\x1b\xfd\x79\x4c\x7f\x1f\x64\x6f\x7f\xd1\x4a\x17\xe4\x6c\x88\xcf\x12\x57\x65\x2f\x60\xcd\x64\x6e\xc1\xd3\xd9\x3c\x25\x83\x65\xc0\x4b\x72\x73\xf4\xec\x7c\x45\x7a\x13\x24\x98\x8e\x6a\xa3\x51\x0f\xc3\x3c\x31\x50\xa6\xf4\x88\xc9\xc4\xc7\x0b\x73\x72\xb4\xce\x78\xcd\x4b\x50\x05\x5a\x82\x3e\x5a\x75\xbe\x82\x9a\x11\xce\x27\xaf\x43\xe4\x0b\xb2\x11\x60\x96\xd3\xa6\xfd\x32\x37\x58\x5d\x0b\xc8\x70\xe0\xf9\x8e\x2a\xfa\x14\xbf\xfc\xe2\x20\xcc\x62\x91\xab\x65\x6a\xd2\x98\xc5\xe4\x98\x0a\x56\xe1\xa4\xb0\x2f\xbf\x24\x69\x34\xa3\xb2\xdd\x1f\xe1\x1d\x31\x96\x9d\xf1\xf9\xc8\xba\x12\x9b\x4e\x33\x86\xfc\xd9\xb8\xf0\x2c\xbd\x79\xde\x2c\xbd\xb1\xda\x34\xbd\xb9\xda\x34\xbd\xa9\x4f\xd3\x6c\xfc\x88\x93\x1f\xcc\xa1\x59\xf2\x01\x9d\xe8\xc6\xea\xdc\x87\xfa\x9a\xf7\x9b\x5b\x75\x36\xcf\x32\x7e\xb9\x86\xf0\x82\x3d\x9d\x0a\xfb\x54\xfb\xce\x55\xea\x5c\x54\xaa\x33\xa7\xd8\x1c\xd2\xd0\x46\xdd\x83\xec\xb5\x51\x7c\x5f\x8a\x11\x30\x3b\x3c\xf3\x3e\x60\xb9\x7c\xb9\x11\x96\xf1\x0d\x5a\xed\xce\x97\x5c\x80\x27\xee\x6c\x53\xdc\x1e\x26\xca\x78\x53\xf2\xee\x37\xab\xf8\xde\x98\x8e\x37\x46\x58\xa8\x55\x6f\xa9\xc9\xe0\x7c\x31\xac\xa3\x90\x49\x12\xc3\x2d\x86\x25\xad\xd4\x24\xd9\x28\xd6\x15\xd9\x16\x65\xda\x74\x5e\xab\x58\x53\x54\x03\x74\x0e\x3b\x53\xa1\xfd\xec\x5f\x59\x2a\x31\xb5\xee\x8a\xa9\x54\xdc\x00\x56\x95\x1a\x6c\x06\x01\x57\xf1\x77\xd2\x40\x16\x5e\x33\xb4\x5f\xb4\x9d\x98\x2d\xb7\xb6\x96\xb1\x1a\x64\x7d\x99\x0c\xf7\xad\xa2\x1b\x81\x7a\x51\x84\x41\x03\x4d\xa7\xae\x65\x39\x95\xab\x57\x51\x2e\x16\xac\x67\x3f\x87\x58\xc1\x5e\xb9\x81\x1b\x33\x3d\xe5\x10\x91\xc9\xaa\x56\xc9\x0b\x52\xcc\x93\xcc\x15\xa4\x84\x2d\xd0\xcf\x72\x9b\xac\x9b\xee\xab\xb5\xc9\xaa\xb4\x5c\x21\xe6\x45\x97\x9b\xa9\xb4\xac\xd0\xe5\xda\x50\xf5\x7b\x49\x34\x99\xf3\xf5\xdb\x44\x59\x4e\x52\x69\x5e\x89\x35\xa3\x4e\x8f\x07\x40\xc6\x97\xe8\x98\xc4\xc3\x49\x74\x42\x95\xa1\x60\x30\x20\x2c\x74\xe8\xe3\x7b\xe1\x80\x2c\xc4\x31\xc5\xe3\x20\x09\x7a\xc1\x24\x48\x4f\x55\x2e\x19\x71\x3d\xc7\xf7\x0a\xe7\x82\x4f\x17\x46\x5c\xf8\x4f\xb4\x72\xfe\x13\x98\x22\xd1\xc8\xce\x75\x1a\x1a\x05\x9f\x2e\x8d\x46\x89\x1b\x47\x11\x6b\x79\xcf\xc5\x5a\xfc\xf8\x39\xdf\x77\x18\x90\x19\xd5\x25\xc2\x7e\x40\x12\x3c\x41\x4e\x9b\xdc\xf3\x27\x7e\xd8\xc7\x33\x7c\xc5\xdb\x1e\x2d\x1b\xf3\xb1\x4b\x85\xdf\xe4\x28\xdc\xf1\x99\x89\xab\xb0\xc4\x06\x2b\x31\x25\x8b\x59\x69\x9e\x2d\x5b\x62\x87\xa6\x4b\x3f\x4c\x35\xa4\xde\x7a\xfd\xeb\x87\x0f\xde\x7b\xfd\xce\x97\xa0\x03\x9e\xeb\x42\xb3\xa9\xb9\xfb\x93\x30\x9a\x8f\xc6\xb8\xc1\xe8\x43\x82\x77\x1e\xa2\x77\xb9\x65\x37\x1a\x0d\x2c\xfe\xf6\xdd\x07\xef\xdd\x7d\xe3\xf0\xce\xeb\x5f\xbe\x73\xf8\xee\x5d\xe8\x40\xd3\x7a\xbf\xf6\xe4\xfd\xfa\x93\xf7\xd7\x9f\xbc\xff\xfe\x93\xee\xaf\xfb\xf5\xc7\x07\x4f\x6c\xeb\xfd\x64\xdd\xb6\xde\xb7\xec\xe6\x48\x22\xf3\x85\x49\xd4\xf3\x27\x54\x53\x0a\xfc\xde\x44\x43\x29\x49\xfd\xfe\x91\xcc\x76\x77\x31\x8b\x12\xc2\x89\x72\xe7\xc1\x83\x3b\xfe\xa4\x0f\xb3\xc9\x7c\x14\x84\x6b\xc0\x8e\xfc\xa3\x71\xfd\x43\x41\xb0\x33\x04\xc4\x3a\xae\xc1\xfb\x0d\x3a\x26\x00\x09\xfd\x5d\x4c\x85\x3b\x0f\x1e\xf0\x86\x41\x10\xd2\xb6\x72\x37\xa3\x93\x31\x09\xc9\x31\x89\x21\x48\xab\x09\x08\x0b\xb0\xa8\x77\xe6\xc7\xfe\x14\x3e\x7c\x80\x99\xcf\x98\x70\x80\x7e\x92\x40\x10\xce\xe6\x29\xa2\xa1\xcd\x7b\x5a\xf5\x16\x8f\x42\x3c\x20\xfd\x60\xea\x4f\xee\xc7\xa4\x1f\x24\x78\xdf\x33\xc6\x42\xa3\xed\x87\x0e\xda\x48\xb3\x39\xa0\x03\x6f\xf9\xe9\xb8\x31\x8b\x4e\x2c\xcf\xcd\x43\xc0\x45\x8d\x7e\x4d\xf6\x16\xb4\xf3\xd5\xe0\xc1\xde\x26\xbc\x3e\x99\x44\x27\xa2\xdd\xb8\xe7\x31\x49\x83\xd9\x84\xc0\x24\x08\x69\x7f\xf0\x16\x75\xf8\x45\x0e\x31\x99\x4d\xfc\x3e\xb1\x9a\xef\x87\xb5\xe6\xc8\x81\x0a\x54\x18\x24\x76\xe7\xd4\x3a\xdc\xa5\xf9\xfc\x94\x24\xe0\x87\xda\x5e\x0a\x7e\x64\x39\xb2\x24\xcb\x64\x82\x5f\x63\x13\x40\x22\x73\xac\xb1\x7b\xa5\x34\xb3\x3e\xe1\x95\xdc\x55\x7b\x35\x96\x02\xe3\xc8\x8c\xf7\x06\x24\x4c\x83\x61\x40\x62\xb9\x49\x86\x53\x0c\xdf\x9d\xed\x1f\xd5\x6a\x70\x4b\xb1\xbf\x52\x49\x74\xf2\x03\x2e\x32\xc4\x7e\x91\xdc\xc6\x9b\x4c\x78\x2e\x21\x8d\x71\x88\x54\xa0\xc6\x6a\xe2\x4a\x83\xac\x4e\xdb\x56\xc2\x8d\xb0\x8a\x6e\x8d\x33\x81\xe7\xb1\x87\x1a\x54\x2c\xbb\x0d\x55\x01\x9e\x26\x54\xd9\xfe\x14\xd7\x94\xc1\x47\x9f\x03\x0c\xa0\x9b\xcc\xfc\x3e\xe1\xfc\x5b\x31\x30\xd1\xb1\x90\x54\x7c\x9b\x24\x29\x19\x28\x5a\x1a\xa4\x64\x8d\x91\x3b\x21\xf3\x30\xc0\x91\x34\x22\xe9\x57\xe8\xe3\xbd\xb0\xb0\x1c\x2f\xd1\x6c\xc2\xbd\x21\x1e\xf8\xd1\x2a\xe6\x08\x27\x8a\xd5\x18\xd0\x28\xc6\x21\x28\x65\x81\x23\x40\xa4\x63\x12\xc2\x84\xa4\x59\x40\x3d\x02\x56\xd0\x20\x0d\xe8\xc5\xd1\x49\x42\x62\xce\xc5\xb6\xa4\x39\xc2\x55\xf7\xc9\x7b\x74\x21\xaa\xca\x37\x02\x3a\x5f\xbe\x33\xb4\x2a\xc7\x7e\x6c\x55\x6c\xb8\x05\x75\x2f\x67\xf5\x2b\xe9\x0c\xda\x11\x1a\x2a\x35\xa8\xd8\x15\x9d\xd0\x82\x56\xe8\x05\x14\xb0\x0b\xea\x9f\x3c\x81\x4a\x65\xcd\xc0\x8e\xf1\xc2\xe7\x34\x66\x68\x36\xa9\x84\x3e\x26\x71\x0a\x33\x76\x26\xcf\x1f\x91\x04\xd2\x48\x1e\xbb\xa4\xcf\x4c\xbf\xd2\x30\x48\x60\x12\x1c\x91\x36\x6c\xb9\x9f\x83\x75\xfc\xd7\x3a\x09\x26\x13\xe8\x91\x7e\x34\x25\x6d\x68\x6d\x7d\xce\x6e\xab\x2a\xfa\x51\x98\x44\x13\xd2\x98\x44\x23\xa3\xd7\x58\x06\x93\x4b\x14\xc1\xd4\xe0\xef\x75\xdd\xfa\xde\xfb\x8d\x83\xda\xe7\xa8\x10\x90\x33\x25\xc7\xb8\xe0\x10\x32\x5e\x50\xfa\xe6\x24\xf2\x53\x91\xa9\x81\xa6\x0a\xcb\x75\x28\xd5\x6d\x58\x07\xb7\xe1\x7a\x72\x6d\xaa\xd3\xb2\xd9\x84\x77\xc9\x34\x3a\x16\x8c\x12\xe8\x82\xa5\x2d\xc9\x9d\x46\x42\xf6\x14\x63\xcd\xb6\xc2\x47\x77\x17\x33\x24\xbd\x03\x95\x51\x50\xb1\x1d\x3a\x14\x25\x0c\x76\x39\x3f\xab\x16\x7d\x9d\x24\x33\x24\x4c\x77\xa7\xb3\x6c\x83\x0e\x1c\x4b\x55\x67\xcb\x05\x02\x48\x7f\xaa\xab\xe2\xa3\x66\x13\xf0\xba\xd9\x61\x14\x4f\x31\xc0\x36\xed\x7d\x5f\x63\x0d\x8e\x5a\xfb\x1c\xb6\xe2\x0d\x58\xc7\x09\x3e\x53\x81\x3f\x78\x44\x05\x09\x46\xee\x0e\xc2\x11\x24\xe3\x20\x15\xdf\x2c\xb7\xe1\x61\xdf\xb4\x10\xa6\xdb\x70\x5b\xae\xf9\xb7\xa9\xc6\x5b\xbe\x8d\x62\xf0\x3d\x79\x02\x4b\xf1\xe2\x33\x1a\xa2\x60\x09\x5c\x0b\xa6\xc6\x66\x2e\x2d\xd3\x96\xd7\x07\x03\xac\x69\x4d\x03\x5e\x63\x63\xd0\xb8\x49\x87\x77\xb4\x0c\x70\x91\x9b\xbd\x42\x14\x8a\xfa\x08\x7b\x31\x53\xd8\xf9\xc2\x97\xd3\x4a\x8d\x02\x2a\x06\xfb\xa8\x01\xf9\x71\x0a\xc3\x38\x9a\x16\x60\x4b\xf9\x84\x84\xc9\x3c\x26\xa2\x74\x8f\x60\x04\x79\x29\x2c\xa3\xe9\xcc\x4f\xf9\x1a\xa1\x60\x72\x28\x18\xf6\x96\x75\xbb\xfd\x7e\xbd\x4b\xd5\xb9\xda\xfb\x75\xfb\x36\x45\xc2\x46\x2d\x40\x1b\x42\xa2\x61\x83\xfb\x14\x3b\x3a\xd3\xc9\x4f\x61\x14\xde\xcd\x7c\x35\x29\x87\xb9\xa6\x74\x08\x11\x16\xd5\xff\x64\x1c\x4c\x08\x58\x16\x4f\x83\x4e\x46\xd9\x6c\x90\x05\xe9\x5b\x59\xb8\xb6\x6d\x9a\x7c\x79\xe9\xae\x7b\xc0\x64\x7e\xf6\x80\xb2\x89\x72\xad\x93\x43\xb4\x91\xcc\x7b\x6c\x3a\xb5\xf0\x5e\x1d\x13\x9c\x5d\xb4\xef\x21\x14\x7d\xda\xb3\xd0\x91\xaf\x56\xc5\xaa\x38\x74\x90\x3b\xcb\x2a\x51\xa0\x6d\xad\x19\x3a\xc8\x46\x2f\x1a\x9c\xe6\x34\x89\x02\x45\xa5\x9a\x97\x30\x17\x52\x1c\x32\xcd\x92\xa4\xd2\xf4\x07\x8d\x79\x73\x28\x52\xde\x30\x94\x88\x02\x6a\x1b\x85\x66\x31\xa1\x08\x8b\x3c\xbc\x4c\x01\xe7\x98\xa5\xa2\x24\xd5\x25\x81\xb0\x21\x98\x55\xe5\xc0\x88\xf1\x2f\x85\x42\x76\xd1\x25\x94\xf4\x62\xd6\x7f\xdf\x6a\x3a\x05\x54\xb0\xd7\x54\x28\x32\xf4\x2f\x49\xe0\x64\xec\xa7\x7c\xf6\xf2\x63\x02\xf3\x84\x0c\x70\x91\x61\xaa\xc8\x85\x2b\x0a\x23\x83\x26\x59\xd0\xc2\xcf\xd6\x39\x6b\x7a\x48\x97\xa5\x6a\x19\x37\x60\xa0\x6e\xf2\xc1\x9c\x7c\x85\x6b\x73\xdd\x03\x23\xf9\xcb\xd1\x09\x89\xef\xf8\x49\xe1\xf7\x14\xe7\x50\xba\xca\xeb\xbe\xdf\x70\xeb\x7b\x07\x56\xf7\x73\x48\x16\xbb\x39\x0a\xd6\x8c\x21\xcc\x95\x1f\x2c\xc0\x46\x6a\x46\x43\xe4\xc3\x9b\x67\xd7\xb5\xf3\xeb\x02\xc4\x93\x27\x20\x9e\xf1\x46\x39\x3d\x38\x53\x10\xf2\x1b\x5a\xce\x0c\xad\x2a\xd7\x02\xa9\xe9\x29\x40\x8d\x34\x92\x79\x2c\xdb\xc6\x91\xa4\x6b\x7f\x1a\x7d\x98\x6b\xb5\x86\x83\x91\x25\x53\x53\x26\x6f\xa6\x1a\x1d\xd9\x95\x68\x64\xf2\xa7\x86\x14\x65\xb1\xac\xf1\xa2\xb5\x82\xf1\x02\xed\x14\xb9\x75\xb1\x18\x4b\xfb\x8a\x93\xa4\xc0\xf2\x1d\xe8\x39\x54\x26\x30\xe2\x60\xc0\x07\xdd\xeb\x91\xa9\x54\x36\xf8\x18\xe1\xe0\xb4\x47\xde\xa2\x0d\xa3\xc5\x68\x99\x7d\x5e\xa4\x57\x54\xa4\x67\x16\xe9\x89\x22\x9c\x8b\xa8\xdc\x8c\xfd\x70\x44\x34\x1c\x74\xfb\x6b\x0c\x37\x6e\xf0\x0e\x4b\x52\x3f\x4e\xdb\x10\xcb\xad\x2b\x12\x0e\xe8\xab\xc7\x5f\x67\x31\x9e\x06\x8e\x95\xd2\x49\xb3\x72\x1b\x39\x95\x53\xfa\x57\xfa\x09\x6a\xe0\x73\xe5\xc5\x41\x38\x3c\x2f\x15\x34\x66\x5e\x8f\xe6\xed\x89\xcb\xd9\xd6\xd0\xa1\x49\xf7\x65\xd4\x1a\x18\x93\x91\x46\x49\x1c\x28\xd0\x41\x60\x53\xf1\x1d\x09\xc6\xdb\x37\x85\xdb\x30\xa5\xb8\xb4\x79\x0c\x9f\xb3\xb5\x35\xd1\x2d\x0d\x24\x8c\x20\x90\xd6\x6f\x59\x82\xc9\xaa\x7a\x64\x94\x38\xf4\x5f\x07\xad\x65\x0e\x33\x2f\x3a\x5c\x13\xda\xe7\xb9\xfc\x80\x63\x24\x86\x8c\x6f\x8b\x4f\xbd\xec\xa7\x9e\x43\xb3\xd7\xc0\x93\x59\xf0\x54\x43\x80\x7d\x84\x7c\x12\xc0\xad\x0e\xb8\xb4\x9b\x7a\x81\x3e\xe9\x52\x5c\xd8\x59\x0a\x7c\x9d\x30\x5f\x10\x0a\x9b\x7b\xab\xaf\xe9\xb3\xbf\x82\x72\x9d\x21\x6b\xce\xee\x01\x74\x68\xad\xfa\x2c\x48\xe1\xb3\xa1\x18\x68\xb1\xdf\xf2\x6d\x73\x40\xe1\x0f\xa6\x37\x00\x82\x90\xc7\x26\xc0\x33\xd7\x34\x5c\x69\xed\xf2\x9a\xa2\x99\x65\x3b\xb4\x8d\x07\x19\x48\x06\x4a\x74\xa0\xc9\xec\x0a\x2d\x5e\x1b\xdc\x44\x3a\x98\xdb\x22\x9c\x32\x3d\x32\xd2\xf7\x42\x62\xbe\x21\xdb\x0b\xf4\x48\x22\xaa\xaa\x82\x8e\xca\xb4\x53\xee\xdb\x62\x87\xc1\x4d\x5a\xe6\xc6\x0d\x10\x1d\x76\x9b\x3e\xb5\x25\x7c\x4d\xbc\x6a\x64\x29\x50\xe2\xbb\x3a\x6b\x81\xee\xa7\x62\xcc\xb2\x8c\xe1\x0a\x24\xd8\xc6\x73\x9a\x5f\x9f\xdb\xfa\xba\x69\x67\x6d\x8e\x0f\xf3\x4a\xc1\xc3\x4b\xd8\x1c\xf5\xf2\xb2\x8a\xaf\xf9\x93\x23\xaa\xb0\xcd\x47\x63\xf0\x27\x13\x5d\x7d\x57\x7a\x05\x55\xf7\xa7\x18\xb1\x24\x08\x13\x12\xa7\xec\x3d\x08\x79\xbc\xd2\x01\xe9\x4f\x7c\x0c\xa1\x93\x55\x20\x98\x82\x60\xae\x60\xd4\x57\xb6\xed\x71\x96\x29\xaf\xeb\x12\x05\xda\x90\x30\x89\x8a\x3c\xef\xde\x65\xba\x1d\x5d\x98\x2a\x49\xc3\xbc\xbd\xb9\x1a\xa9\xfa\x7d\x44\x52\x1d\x58\x52\x00\xcd\x6e\xb0\x4a\x55\xe7\x8b\x3c\xcc\xd1\x5f\xd7\xed\xd8\x17\xb9\x38\x89\x7a\x8f\x1a\x4b\xd6\xd8\xf4\x33\x9f\x71\x99\xea\x5c\x63\x4a\x38\xa5\xb2\xd1\xc4\x6c\x46\xac\xba\x00\xb2\x6a\x38\x7b\x32\x9a\x61\x33\xa7\x03\x86\xa2\xae\x0e\xde\xf7\xe3\x84\x24\xc6\x3a\x0d\x35\x70\x7e\xd9\x5c\xb9\x49\xb9\x44\xf7\x83\x5f\xf3\x67\x01\xcc\xe2\xe0\xd8\x4f\x49\x5e\x17\x34\xe9\x9d\x43\x53\xf6\x98\x8e\x0f\x6a\x7b\x3c\x7d\x18\xa2\x3d\x9f\xbb\xcc\xa8\x92\x6c\xe1\xc1\xd7\x09\x70\x1b\x34\xd3\x4a\xe5\xfd\xf7\x7b\x48\x71\x2d\x37\xa5\xf5\xfb\xef\x5b\x15\x1b\xda\x5a\xf2\x1a\xc0\x20\xe2\x7d\x8a\x26\x7f\xe2\xc7\xfd\x31\xce\x94\xd0\xc1\xaa\x99\x3e\xa4\xcc\xa9\xfc\x7c\x83\xcc\x96\x33\xb2\x64\x56\xeb\xdc\x26\x83\xd6\x5e\x55\x8a\xce\xd8\x86\x85\xbc\xdc\x12\x5b\x79\x2b\x48\x92\x20\x1c\xe1\x48\x1b\x06\x31\xae\x9a\xe6\xb3\x89\x16\x21\x78\x4c\x92\x00\x17\xdb\x23\x6e\xa0\x94\xf4\x0f\x14\x17\x06\x21\x98\x24\xd1\x4d\x46\x8c\xd0\x74\xc0\x18\x38\x2a\xba\x50\xdd\x06\xf7\xf6\xcc\x3c\x4c\xbc\x67\x97\xcd\xc5\x6b\x4d\x4a\x43\x6d\x7d\xa9\x40\xda\xf6\x5a\xa1\xce\x2d\x86\x00\xe6\x64\x6e\x3b\x1a\x76\xee\x81\x98\x1a\xeb\xfa\xcc\xa8\xc8\xf7\xe0\x34\x4c\xfd\x05\x37\x67\x87\xc2\x7c\x3d\xe5\xd4\xec\x4f\x22\xfc\xad\xda\x55\x4a\x1a\x4a\x35\xb6\xcb\x60\xda\xb7\xcb\x4c\xd7\x7c\x6a\xff\x90\xe3\xd8\x16\xc8\x16\xd9\xfd\xdb\x30\x0c\xb9\x35\x91\x8b\x25\xd1\x32\xbe\x64\x3c\x53\xcb\x10\x64\xb9\x94\x24\x29\x63\x39\x5b\x9b\xb3\x74\xc6\x52\xa3\xb9\x74\xaf\xe3\x42\x0b\x39\x69\x22\x5a\x3a\x9a\xb3\x82\x0a\x72\xe2\x73\x45\xd9\x84\xbd\xd5\x6c\xd2\x09\x27\x3a\x81\x98\xf4\xe7\x71\x12\x1c\x33\x1b\x90\x76\xb4\x87\x96\xb6\x2e\x3a\x05\x2c\xd9\x79\x29\x9a\xee\x37\x3f\x5b\xb0\x7c\xb6\x60\xf9\x6c\xc1\xf2\xd9\x82\xe5\x57\x76\xc1\xb2\xf5\x5c\x0b\x16\xf4\xbd\x20\x8b\x59\xa7\x78\x31\xb2\x6d\xef\xbf\xb6\x46\xbf\x6b\x51\x12\x86\x51\x3c\x9d\x4f\x7c\x3a\xf3\x64\x8f\x8b\xbf\xb6\x76\xcd\xf0\x6d\x7a\x6d\xed\x9a\xf4\xa4\xe8\x74\x0f\x9c\x59\x34\xf3\xe8\x3f\x2d\xfa\xcf\x86\xf8\x3c\x08\x92\x59\xa7\x7b\x20\x5e\x53\x32\x9d\x75\xaa\x55\xf1\xea\xc7\x71\x07\xdd\xf9\x70\x7e\xa6\xa9\xc3\x28\x66\xe7\xcc\x3b\xee\x7e\x70\x53\xc5\x16\xd8\x0f\x6a\x35\x9b\xe2\x70\x2d\x18\x5a\x7e\x1c\x77\x83\x83\x06\xc5\xb8\xd3\xe9\x78\x4f\x9e\x98\x09\x1b\x2c\xe3\x35\x5a\x37\x9f\xcb\x99\x53\x55\x26\xdb\x6d\xfe\x9e\x8c\xa3\x13\xf1\x8d\x19\x64\x69\x8e\xb6\x77\x46\x09\x74\xed\xda\x19\xfd\x87\x8f\x83\x6c\xd5\xe7\x55\x45\x41\xaf\x0c\xcd\xd5\x80\x75\x11\x22\x6b\x7b\xdd\x3b\xe8\xe4\xc1\xd6\x2c\xed\xe5\x7a\xa7\x52\xaf\xdc\xae\x58\x95\x76\xa5\x62\xd7\x0a\x00\xb0\x86\x15\x95\xb1\xb1\x0c\x43\xd2\x3d\x3b\x0f\xc7\x9d\xf3\x71\xb4\x8a\xaa\xa7\xc5\xaf\x77\xbc\x55\x50\x5c\x5a\x9c\x61\x5b\xcb\x91\x77\xe7\x5c\xcc\x3d\x41\x5e\xca\xa8\x1d\xd6\x61\x28\x78\x44\x62\x2b\x97\xa8\x60\xd0\x8a\x3a\x9d\x4e\xf5\x7e\x55\x32\x9b\x48\xba\x53\xb5\x73\xbd\x5f\xb9\x99\xcc\x67\xb7\x2a\x35\x0a\x95\x37\xab\x72\xb3\xc9\xd2\xf4\x2e\xa4\xf9\x7a\x2c\x9f\xa7\xe7\xeb\xdd\xaa\x70\xae\x71\x39\xdb\xb0\x46\xe5\x2a\xb2\xb0\x86\x2c\x71\xb5\x6a\x33\x19\x38\xf9\x34\xfc\xbc\x0c\x7e\x2b\x73\x6b\x2b\x3b\xec\xf6\x2e\x4c\xdf\xab\x6a\x8e\x31\x2a\xb0\x4d\x05\x20\x3c\x0d\x84\x97\x05\xc1\x5a\xad\xb5\x67\x85\xb1\xdf\xba\x70\x7b\xa9\x60\x3c\x9f\x08\x06\x83\x58\xd8\x49\x1b\xa2\x93\x1c\x93\xa7\x1c\xb3\x0b\x6d\xd1\x7b\x2d\x0d\x7d\xfa\x3f\x9f\x69\x70\x64\xb9\x07\x52\xda\xd2\x31\x63\xea\xbe\x1d\x3a\x1f\xe4\xfd\x16\xb7\x5f\xe4\x3c\xb4\x53\x30\x0f\x51\xb5\x72\x18\x2c\x72\xf3\xd0\x57\x12\x12\xbf\x21\x97\xd5\xaf\xad\x5d\xab\xaa\x29\x09\x67\x15\x2d\x43\x47\x7b\x7e\xf2\xe4\xc3\xb3\xcc\xe7\xc6\xfd\x7b\x1d\xf4\x0a\xb8\x7f\x2f\xfb\xe5\x2e\xfb\x70\xf7\x05\xcd\x71\xa8\x3c\x46\xd1\xa4\x23\x0e\x0b\xe9\x75\x87\xd7\x3b\x9d\x8a\xb4\x1d\x54\xec\xcb\x4e\x8a\x9c\x39\x11\xf5\x22\xf6\xba\xd8\x44\xb7\x51\x0a\x4e\xc3\xbd\xab\x83\x3e\xb8\xf0\xb4\x17\x0c\x65\xc8\x05\x5a\x4b\x97\xd5\x65\xce\x01\x1d\x93\x38\xac\xe0\xb5\xe2\xfc\xcc\xa3\x10\x71\x65\x15\xf2\x01\x77\xa6\xe4\xe9\x92\x82\x1d\xbd\x31\xd6\x92\x8c\xe7\xb6\x6f\xe7\x9f\x79\xfb\x76\x75\x39\xc8\x19\x24\x23\x08\x73\xa9\x3a\x1f\x31\x3e\x71\xf2\xdc\x69\x29\x51\xe7\x28\x31\x67\xaf\x20\x9a\xdd\x4b\xa0\xa4\xba\x47\xce\x31\xc5\xbd\xa1\xb0\xea\xe0\x63\x3f\x0a\xfb\x7e\x8a\xd3\x0a\x07\xa5\x65\x29\xe8\x1f\xbd\xf1\x34\x63\xbe\xdb\xb4\x73\x84\x72\xb2\xca\xe0\x02\x0a\x19\xaf\x31\x0f\x93\x71\x30\x4c\x75\x68\xec\xc3\xb9\x95\x7b\xb9\xca\x3f\xcc\x65\xbb\x5c\x07\x81\xf6\x77\xf6\x5c\xaa\xc4\x55\xf6\x1f\x64\xfe\x74\x47\xc5\x0c\xf5\x5a\xcb\x7b\xf7\xff\xab\xfd\x2a\x80\xae\xac\x19\x15\x74\x54\x9e\x0a\xd7\xcb\xa9\xd0\xe9\xd2\x7f\x0f\xf4\xf6\x14\x33\x00\x6a\x57\x97\x97\x34\x1b\xaa\xc1\xa2\xed\x21\x39\x41\xc5\x85\x51\x74\x15\xc1\xb3\xa1\x64\x3d\x9d\xe1\xed\x02\xaa\xaf\x34\x6d\x6e\x9c\x95\x08\x73\x06\x84\x17\x39\x30\xb5\x3c\xe9\x76\xce\x45\xf8\x2d\x8f\x13\x12\x0d\xe7\x96\x68\x4d\x83\x2c\xfa\x64\x86\x2a\x5c\xe5\x2b\x61\xdf\x9f\x8f\xc6\x29\xb7\xa8\x03\x89\xe3\x28\xae\xd8\x08\x57\x53\x1c\xd9\xf4\x20\x34\xc7\x5b\x5e\xc6\x47\xf3\x76\xe5\x5e\x38\x0c\xc2\x20\x3d\xad\xb4\x35\x4f\x5c\xb3\x54\x23\x8d\xde\x0c\x16\x64\x60\x79\x5b\x08\xff\x4c\x68\x7d\xe4\xd8\x9f\x74\xf4\x1d\x39\x27\x8d\x8e\x48\x98\x38\x51\xef\x11\x12\x50\x63\x18\xf6\xa5\x70\xcc\xe8\xe1\x30\x26\x64\x41\x01\xd9\x8d\x34\xba\xcf\x34\x49\xcb\xd6\x75\x4a\x4b\x36\x30\x3b\x2e\xa3\xde\xa3\x42\xe8\x39\x1c\x38\x8d\xb3\x8c\x8b\xdd\x55\x80\x0a\x6f\xd3\x39\x18\x21\x3a\x65\x20\xca\xcb\x72\xd8\x7a\x9b\x4a\x28\x72\x2e\x1a\x94\xe6\x17\x59\x19\x2c\xbd\xa8\xfe\xdc\x95\xc1\x6b\x72\x7b\x69\xc9\xfa\x60\x97\x22\xf4\xda\xda\xb5\xcc\x12\x41\xb6\xa0\xc0\x50\x95\x5b\x16\x5c\xe3\x91\x1f\x52\xaa\xc5\x93\x09\x99\xd2\x61\x3e\x23\x03\x67\x16\x93\x19\xfd\x87\x26\xf2\x59\x4b\x57\xf9\xc5\x7a\xde\xe2\x2b\xab\x4d\x9a\xb7\xed\x9e\x1d\x48\xa0\x79\xf5\xfe\x9a\x0a\x96\xd8\x91\xf1\x4d\xe3\x4c\xa0\xc4\x8c\x7d\xa1\xd4\x94\x95\x4d\xa0\x12\xe6\x5a\xb3\x19\x70\x36\x84\x20\xe1\x8e\xfb\x4e\x9f\x1f\xbc\x72\xa2\x18\x42\xeb\x64\x1c\xf4\xc7\xf4\xab\x3f\x49\x22\xf0\x21\x99\x91\x7e\xe0\x4f\x40\xe4\x82\x20\x84\x68\x1e\x43\xdf\x4f\x88\xcd\x84\x54\xc1\x1a\x82\x7d\xb8\xa6\x0b\xa8\xce\xdb\x58\x9d\xa5\xa7\xa9\xb9\x29\x49\x97\x2b\xa4\xb9\x3a\x36\x0b\x44\xe4\xca\x85\xb7\x44\x61\x34\x8c\x5b\x16\xeb\x53\x7d\x0e\xb0\xc5\xec\x22\xeb\xd1\x90\x64\xd9\x05\xf2\x67\xe7\x56\xe7\x79\x57\x5f\x5f\x66\xde\x56\xdf\x35\x44\x38\x24\xca\xb6\x5c\x6b\x17\xf4\x8e\x49\x87\xa6\x36\x66\x31\xd9\x97\x99\x3a\x85\xca\xbc\x2a\x32\xa3\x65\xb4\x22\xb8\x41\x3c\xf1\x47\x98\xcc\xfa\xb8\x53\x15\x27\xc0\xaa\x37\x6e\x60\x0d\xb9\xf4\x7d\xc9\x34\xb3\x98\xdc\xa2\x60\x6d\xad\x29\xb4\x8c\x2d\x51\x52\x6d\xe0\x94\xa3\xd9\x6f\x75\x66\x31\xb9\x71\xe3\x3a\xad\xfa\xc9\x13\xfa\xef\x8d\x1b\xb3\x98\xdc\x44\x50\x22\xfb\xb5\x3c\x89\xf7\xc5\xa7\xf3\x9a\x5a\x4e\xfa\x42\x32\x5c\xbb\x26\x88\x50\xd0\x5a\xa4\x42\x29\x11\x44\x5f\x5e\x2b\xa1\xc0\x59\x46\x6d\x12\x37\xe7\x29\xf5\x22\x49\x99\xf4\xe6\x22\x68\x25\xd1\xfb\x7c\xb1\xba\xcf\x11\xba\x7b\xcc\xf0\x20\x9d\x0d\xc2\x3e\x46\xae\x3d\xf6\xb9\x4e\xb3\xd4\x24\x81\xcd\x65\x9c\x5a\xeb\x1c\xfb\x93\x7d\xad\xd1\x7e\x1c\x8b\x79\x8a\x9d\xaa\x39\x22\x61\xa7\x5b\x4d\x82\xb0\xea\x54\xfb\x51\x52\x75\xaa\xa9\x4f\x9f\x67\x41\xd5\xa9\x5a\x55\xa7\x6a\x57\x9d\xea\xfd\xaa\x53\xbd\x53\x75\x28\x1c\x80\xaa\xcf\x72\xfb\x2c\xbb\xcf\xf2\xef\x54\x9d\xea\x6e\xd5\xa9\xee\x55\x9d\x6a\x10\xa6\x32\x73\x3f\x4a\xc6\x3c\x33\xfd\x9d\xd0\xbc\xbf\x5e\x75\xaa\x71\x14\xa5\x55\xa7\xba\x59\x75\xaa\x5b\x55\xa7\xba\x5d\x75\xaa\xcd\xaa\x53\xbd\x2e\x0b\xa6\x7e\x38\xe6\xe0\xe9\xef\x5b\xd1\xa0\xea\x54\xbd\xaa\x53\x6d\x55\x9d\xea\x46\xd5\xa9\xae\xcb\xac\x49\xc0\xb2\xf2\x5f\x42\xeb\x89\x46\x55\xa7\xea\x56\x9d\x6a\xa3\xea\x54\x6b\x55\xa7\x5a\xaf\x3a\xf8\xdf\x83\x60\x34\xf5\xab\x4e\x95\x22\x72\x9f\x36\x92\x72\x92\xb4\x1e\xa1\x59\xb9\x88\x1e\x37\x66\xc1\x7e\x31\x45\xce\xa7\xc7\x3d\x41\x8f\x2c\x35\x60\x19\x39\x6e\x0c\x82\xe3\x60\x40\xf6\x15\x55\xb2\x34\x81\xb7\xa2\x01\x64\xa8\x72\x23\x0d\xa6\x24\xd9\xe7\x05\x0a\x28\x03\xe5\xa4\xb9\x81\xb4\xd9\xe7\xc4\xb9\x71\x1f\x5b\x6c\x90\x87\x1c\xfb\x9d\x2e\x6a\x02\x53\x3a\x08\x93\x20\x74\xd4\x5b\x3f\x4a\xb4\xb7\xd4\x0f\x9d\xea\xfd\x7b\x8a\x66\xea\xd3\x7d\xed\xf9\x0e\x22\xaa\xde\x7d\x13\xa6\x6f\x02\xf5\x11\xaa\x46\x5b\x94\x05\xc3\x49\x14\xc5\x19\x38\x94\xc2\x19\x38\x63\x96\x7b\x12\x8d\x1c\x21\x42\xd8\x43\xf2\x41\x9c\x1a\xb4\x57\xe5\x06\xc1\xb1\xf6\x36\xf4\xfb\x69\xa6\x1e\xda\x15\x19\x04\xf5\xf7\x69\x34\x30\xfa\x47\xfb\x32\x9f\x64\x40\xd1\x4e\x72\x4c\x4a\x8c\x9d\xea\x5d\xbd\x10\xc5\x5d\x74\x9d\x96\x73\x30\xd0\xde\x92\x79\x0f\xbb\x53\x07\x3c\x9a\xfa\xd8\xa9\x5a\x1f\x04\x92\x08\xb2\x77\x67\x31\xe9\x93\x41\xe7\x43\xb7\xed\x79\x8e\xd7\x76\x9d\x56\x7b\xc3\xd9\x68\xbb\xce\x66\xdb\x75\xb6\xda\xae\xb3\xdd\x76\x9d\x1d\xfa\x71\x97\xfe\xb3\xd7\xf6\x1c\xcf\x6d\x7b\xae\xe3\xd1\xcc\x5e\x0b\x8b\x6d\xf0\x6d\x2c\x14\x2f\x74\xe6\xee\xba\x0e\xfd\x6f\xc3\xd9\x74\xb6\x1c\x9a\xd9\xc5\x76\xb3\x54\x0f\xff\x33\x52\x54\x72\xcb\xd9\x91\x1f\x5a\x32\x4d\xa4\x6c\x60\xbe\x6d\x67\xcf\xd9\x73\x68\xc5\x2d\xc7\xdb\xa0\xff\xee\x62\x7b\xa0\xb9\xfe\xda\xda\x35\x57\xf3\x49\x83\x93\x20\x1d\x43\xc2\x56\x5a\x22\xf1\x30\xf4\xa7\xc4\xa2\x94\x48\x0e\xc9\x62\x46\x65\xa7\x87\x0e\x0e\x78\x1a\xf3\xb5\xb5\x6b\x2d\xdc\x78\x0e\xfd\xf8\x14\xa2\x19\x0b\x22\xce\x4e\x63\xc2\x3a\x34\x71\x00\xe2\xa6\xb8\x9f\x24\x51\x1f\x6f\x2f\xf7\xc3\x01\x24\xfe\x94\x70\x6a\x92\xb0\x4f\x57\x03\x1b\xd0\xc6\x43\x70\x4a\x03\xc4\xd9\x8c\x83\x22\xce\x2c\x70\xee\xc4\xf3\xb0\x3f\x26\x31\xf8\x21\xad\x78\x13\xda\xb4\xc6\x30\x08\x47\xd0\x8b\xfd\xfe\x11\x49\x5f\x5b\xbb\xb6\x05\x6d\xe9\x60\xa5\x52\xb7\xd5\x11\xf0\xd7\xd6\xae\xed\x94\x35\x1a\xdb\x89\xcd\x34\x9a\xff\xda\xda\xb5\xdd\x95\xc9\x44\x8b\x7b\x8e\x78\x6a\x51\x82\xed\xe5\x49\xc4\x9a\x55\x73\xea\x94\x9e\x6e\xc9\xe7\xfb\x70\x07\xa2\x18\x7e\x9d\xe6\xf1\xda\x40\x3b\xd6\x6b\x65\x11\x71\x20\x21\x58\x8a\x0c\x20\x1d\xc7\x84\x00\x3a\x5e\x91\x94\x75\x8f\xb7\xd1\x96\x67\x8a\x21\x1a\x02\x4a\x30\x09\x82\xf2\xc1\x7a\x53\x63\x46\x97\x32\x37\x46\xcc\xf5\xd8\xcf\x06\xfb\xd9\x64\x3f\xdb\xec\x67\x97\xfd\xec\xf1\x9c\x2d\xfe\xcb\xf2\x9e\x39\xcd\x26\x05\xc5\x53\xe9\xe3\xa6\x7a\xdc\x53\x8f\x9e\xa7\x9e\x5b\xfa\x73\xeb\xb5\xb5\x6b\x98\x21\x8b\x4c\xab\x08\xa7\x2d\x03\xb5\x9d\x42\x0c\x05\x18\x6f\x29\xc6\x1b\x0a\x87\x2d\xf5\xb8\xa3\x61\xb6\xc1\x31\x3b\x54\xa8\x99\xc8\xec\x96\x54\x40\x97\xbd\xd3\x59\x7a\xda\xf9\x10\x9f\x11\xc6\xc6\x45\x68\x5d\x82\xf2\xa1\x86\xe8\xa1\x86\xe9\xa1\x44\x75\xbb\xf3\xa1\xa7\x90\x08\xc9\xc9\xeb\x71\xa7\xdb\x3d\x40\x29\x71\xad\x5b\xf1\x2a\x4e\xa5\x55\x71\x2a\x1b\x15\xa7\xb2\x53\x71\x2a\xbb\x15\xa7\xb2\x57\x71\x2a\x9b\x15\xa7\xb2\x55\x71\x2a\xdb\x15\xa7\x52\xab\x38\x95\x7a\xc5\xa9\xac\x57\x9c\x4a\xb3\xe2\xd0\xd5\x66\xc5\xae\x38\x95\x5f\xaf\x38\x95\xeb\x15\xa7\x72\xbf\xe2\x54\xee\x54\x9c\x0a\xa9\x38\x15\xb7\xe2\x54\x1a\x15\x07\xff\x0b\x2b\xb2\x9a\x59\x50\x71\x2a\x93\x90\x66\x0e\x54\x6a\x12\xd0\x94\x7e\x94\x54\x9c\x4a\xea\xd3\xe7\x37\xc8\xa4\xe2\x54\x82\x30\xad\x38\x95\xb7\xa2\x01\x2d\x14\x8d\x2a\x4e\x65\x16\x9d\xa8\x62\x3e\x2b\xe7\xb3\x82\x3e\x2b\x49\xe7\xaf\x8a\x53\xa1\x7a\x02\x83\x46\xdf\xe8\x0c\xa1\x95\xe3\x79\x7c\xfe\x15\x27\x90\x8a\x53\xc1\x31\x51\x39\x38\x30\x54\x4a\xe6\xe2\x95\xa4\xb1\xe7\x24\x69\xdc\x72\x02\x67\x61\xaa\x96\xc3\x8e\xbb\x3f\xbc\xb9\xd8\x1f\x8a\x4d\x2e\x6e\xe0\x8a\xbd\x6e\x50\x1b\x1e\x5c\xef\x74\x68\xb9\xee\xf0\x80\x2f\x53\xc5\x49\x68\xbc\x35\x20\xab\x6b\x63\xcc\x7f\xae\x77\xe2\x1c\xe4\x0f\x06\xef\xa1\xee\x29\x55\x67\x6e\x1a\x91\x38\x30\xd5\xd6\xb0\xf6\xa8\x0d\xb7\x6b\x8b\x0e\xfb\x82\xeb\x43\xfa\x24\xb2\xe0\x57\xb9\x0f\x58\xf7\x98\xf1\xe2\xda\xb5\x66\x13\x79\x03\xd7\xe4\x62\x39\x3e\x39\xc5\xdb\x6a\x47\x21\x19\xc0\xc0\x4f\x31\x28\x08\xbf\xe1\x21\x08\x81\xad\xe1\xbd\x37\xa8\xce\xec\x9f\x82\x9f\xc2\x24\xea\xfb\x3c\xac\x11\x0a\x9b\xd6\x80\x7f\x1b\xfb\x09\xb0\x90\x11\x31\x15\xcc\x28\xb8\xb8\xb3\x96\x07\x2d\xf6\xde\x62\x33\x43\x04\x54\x2c\x49\x7a\x2e\x6e\x22\x5a\xc2\x87\xe9\x5a\xb3\x89\x1d\x83\x37\x9c\xe2\x55\xab\xba\xa9\x21\x26\x88\xf3\x78\x3e\x62\xd3\x4c\x18\xa5\x40\x16\x41\x92\x06\xe1\x48\xac\xa2\xae\x31\xf3\x04\x46\xa1\xa7\x00\xc8\x00\x82\x14\x58\xb4\x80\x98\xf8\x47\xb4\x65\x21\x59\xa4\x18\x01\x04\xfc\x44\x0b\x25\x82\xfe\x59\x0c\x0e\xed\x80\xd3\x8e\xbb\x7f\xca\xd0\xeb\x2e\x84\x4b\xf0\xfe\xa9\xec\x02\x6e\x95\x33\xbb\xa1\xd3\xe9\x88\x12\xdd\xd3\x03\xb5\x90\xc4\xde\x60\x1d\x25\xdc\xc0\xf4\x7c\x72\x11\xc8\x2e\x2f\x31\xd7\x75\x67\xca\x6e\x4d\xa1\x74\x3a\x75\x4f\x9a\xa8\x19\x48\x5c\xf2\x65\x30\x11\x30\xd9\x86\x76\x26\xc3\xe9\x4c\x5a\x4d\x02\x8e\x09\x6f\xe0\xcd\x12\xc6\x12\xc6\x18\x86\x75\x71\x9e\x03\xbe\x0d\x7d\x5e\xb6\xa5\xf8\x92\x63\x3f\xfb\xdd\xb0\xf2\xd0\x15\x4a\x36\x03\x4d\x2b\x35\x5c\x60\xb6\x2e\x25\xdd\x41\xb6\x6d\x1a\x89\xf2\x19\x4e\x67\x44\xa1\x94\xfb\xac\xec\x6d\x0c\xa5\x5c\x06\x9a\x98\xd9\xb0\x40\xbd\x10\x87\xff\x84\x2c\xd4\xc8\x0f\xc2\x99\xa3\x8f\xfe\x42\xeb\x61\x92\xc6\x9d\xee\x87\xdc\x0a\xa8\xcc\x82\xe8\x3c\x46\x1f\xb2\x86\xc1\x59\xda\xa7\xbd\x71\xad\xd9\xbc\x6f\x7a\xf2\x53\xed\x89\xd0\xd1\x9c\x8e\x09\xf4\xc8\x28\x08\x51\xc5\xa2\x72\x61\x98\x92\x18\xc7\x36\x62\x23\x20\x05\xe1\xec\x41\x1a\x77\x82\x70\x26\x81\x1f\x91\x53\x6d\x8f\x0d\xab\xeb\x47\xf3\x30\x25\x71\xc7\x55\xa6\xc9\xc9\x24\x3a\x21\x83\x0e\xea\x1d\x32\x95\x2a\x6d\xef\x45\x77\x28\x12\x7a\xde\x24\x25\x71\xd0\x3f\xea\xe0\x2c\xaa\x1a\x11\x93\xe3\x2f\x91\x53\xee\xce\xc0\xb0\x71\x16\x0e\xcb\xa0\x76\xdc\x18\xf1\x32\xb6\x70\x24\xbd\x21\x6b\x75\x43\x35\xc2\x8a\x7a\x8f\x3a\xcc\x31\x43\x93\xb8\xac\xb9\x79\x89\x8b\xbe\xad\xf8\xad\x1b\x1c\x74\x3a\x55\xa8\xca\x41\x28\x4e\xeb\xea\x1c\x78\xa4\xd0\xbe\x96\x90\x7e\x9b\x56\xb0\xe8\x58\x06\xf4\x7a\x70\xcb\x18\x7b\xf5\x96\x7d\xdb\x78\xf7\xda\x99\xfc\xf6\xfe\xe2\x96\xbb\xbf\xa8\xd7\x85\x64\x59\x5d\x50\xb1\x09\x8f\xc1\x73\x34\xd9\x83\x33\x9f\x12\x54\x14\x6f\xed\xab\x29\x98\x20\x21\xfd\x42\xe1\xc4\x45\x54\xad\x73\x44\x4e\x25\xf2\x72\x63\x94\xc2\xec\x74\xaa\x55\x51\x4b\xf9\x86\xd0\x1d\x3f\xac\xa6\x28\x92\x63\xba\x4a\x18\x70\x9e\xac\xd4\x38\x1d\x98\x97\x77\x60\xdb\xc6\x68\x67\x5c\x3a\x20\x8b\x8c\x84\x3d\x22\xa7\xb6\x9a\x10\xfb\x6c\xc2\x65\xbc\x2b\xd3\xe8\x0a\x0d\xc7\x3f\x16\x3a\xd0\x3e\xdd\x3d\xee\xd0\x81\x9f\x4b\xbf\x1f\x93\x0e\x5b\xdb\x74\xb1\xb8\xfa\x76\xad\xff\x60\x1c\x9d\x74\x50\x1c\x64\x8b\xcd\x62\x42\x15\x86\xae\xf2\xaa\x96\xa6\x42\xda\x87\x8f\x3a\xb3\xb4\x2f\xba\xee\x51\xbd\xbe\x8f\x76\xf6\x49\x14\xcd\x30\x02\x13\x1d\xce\xca\xe2\x99\xf6\xbb\x8f\x0e\x34\xd7\x15\x4c\xed\xd2\x35\xe2\x86\xb3\xa5\xad\x06\x0f\x24\x25\x10\x51\xfb\x3a\x4e\x1d\xb2\xab\x83\xa1\xc5\xc7\x28\x6f\xc8\xf5\x4e\x07\x6f\xdd\x92\x39\xca\x7b\xea\x88\x9c\xd6\x2a\x68\xfe\x8f\x52\x31\xd2\x65\x67\xf1\x61\x6b\xab\x69\x4d\x58\x28\xaf\xd1\xe6\x1b\xae\x8a\xc2\x69\x6c\x8b\x49\x30\x2e\xd0\xec\xca\x99\x2a\xac\x0b\x12\x4f\xa5\x0a\x91\xc1\x94\x6d\x99\x1e\x84\x7d\x4a\x21\xa7\xee\xd9\xa6\xc5\xb6\x88\x61\xcf\xa1\xc0\x95\x34\x5f\x55\xc5\x31\xe6\x75\x75\xcc\xba\x18\x2b\xb6\x38\xb6\x94\xfb\x0c\x5b\x89\x48\x47\x0e\xab\x70\x2b\x57\x45\xa4\x52\x9e\x14\x24\x08\x3a\x41\x5d\x0d\x43\x4c\x04\x8e\x04\x0a\x3c\x46\xf8\xfe\xdd\x63\x46\x78\xac\x17\x89\x4f\xa1\x30\xfa\x63\x2d\x67\x72\xfc\x32\xd4\x34\x7e\xcb\x8b\x76\xad\x3f\x94\x08\x57\x9d\xd1\xb2\x59\xaf\xb7\x94\xbf\x00\xe7\x03\xbe\xe3\x57\xc8\x1b\x99\x6d\x2f\x39\xd9\x15\xec\x4e\x6b\x58\x4a\x0e\x67\x9b\x03\x59\x97\x34\xb4\xbe\x73\x97\xc5\x4e\xff\xee\xb1\x60\x0f\x81\xaa\x97\xd9\x21\x31\xf6\x0f\x8a\xd0\x3e\xcb\xd3\xc4\xcb\xd2\x84\x2d\x2a\x97\x61\xdd\x7a\x0e\xda\x96\xd3\xb4\xb8\xae\x0d\xfb\xc3\x66\x53\x18\x62\xca\xfb\xe3\xfc\x16\x6d\x2c\xab\x65\xb3\xc8\xe3\x45\xe8\x09\x35\x5d\xde\x15\x64\x63\xda\x0b\xab\x53\x53\x19\x6a\xb5\x02\xdc\x96\x52\x69\x65\xa2\x6c\x69\x6c\x73\x5d\xab\x52\xb2\xcd\x92\x59\x8b\x1b\xa4\xf4\x33\x93\x7e\x4c\x60\x1a\xc5\x04\xd2\xb1\x1f\x4a\x43\x56\x14\x12\x07\x4e\xfc\x20\x85\xaf\x8d\xfd\xf4\xfa\xf5\xeb\x15\x5b\x63\xa3\x2c\x15\xf8\x6e\x15\x27\x19\x9d\xf4\xf3\x73\x02\x6e\x19\x5f\x42\xb4\xf2\x72\x05\xb5\x66\x54\x39\x83\xfe\xf5\xfa\x45\x79\x63\xf5\x0e\xd8\xce\x8c\xdb\xb1\x9f\xbc\x41\xfa\x2b\x90\xff\xbd\x93\x48\x58\xff\x18\xdd\x75\xa1\x1c\xb0\xd5\x2a\x33\x68\x1a\xd4\xce\x88\x88\xeb\x19\x11\x21\x04\xa5\xcb\x3d\x49\xb9\x86\x4d\x35\xea\x19\xad\x83\x90\x01\xea\xd3\x3d\x02\xfd\xb1\x1f\x8e\xe8\x04\x90\xc8\xb5\x26\x55\xae\x27\x7e\xc2\xcd\x9c\x10\x46\x27\x3c\x6f\xe2\x0f\x71\x75\x3d\xf1\x53\x0c\x53\x35\x20\x59\xd1\x32\x8b\xe5\x5a\x47\x9f\xcc\xca\xa5\xcd\x76\x46\x20\xc8\xbc\x85\x03\xa2\x50\xfa\x29\x7a\x77\x84\xa9\xa2\xac\x9b\x76\x8a\x04\xd5\x72\x16\xc8\x21\x56\xca\x13\x5a\x3d\xbb\x97\x16\x88\x9b\x7c\xb2\xd9\x7c\x09\x93\xcd\x5e\xf1\x64\xb3\xa7\x6b\x66\x92\xe2\x9d\x4e\xc7\xd8\xb4\xd0\xf6\x99\x65\x16\x6d\x46\xc2\x54\xdc\x90\xc3\xf9\x38\xa7\xe1\x78\x59\xd5\x46\x62\x57\x5c\x63\x32\xef\xdd\xb8\xc1\x14\x88\x4e\xa7\x5a\xaf\x16\x55\x6f\xe0\x97\x47\xa4\x5a\xab\x9e\x8f\x86\x3e\x71\x9a\x03\x6c\x0b\xf7\xd8\xc5\xdb\x8e\xf1\xe6\x19\x6f\x1b\xe6\x37\x36\x63\xe1\x30\xc3\xcb\x7d\xa3\x70\x72\x8a\xa1\x6b\x21\x24\x23\xbc\x33\x84\x2a\x63\xc3\x68\x1e\x0e\x14\xdd\xb9\xc2\xcf\xdb\xda\x6c\x0e\x22\x2a\x19\xc6\x54\x0e\x0f\xa3\x18\x6a\x6a\x99\xcb\xff\x68\x16\xba\xfe\xf0\x07\x03\x66\xb3\xa2\xa3\xd8\xef\x45\xc7\xe8\xa3\x85\x17\x0e\x4c\x49\x98\xd2\x71\x9e\x8e\x7d\x3e\xd2\xe3\x39\x3b\xe3\x2d\x9c\xe4\x78\x1e\x79\x84\x9e\x16\x8d\x42\xb8\xc3\xac\x58\xb5\x22\xa5\xd6\xcd\x2b\xb5\x3a\x5f\x2f\x51\xa3\xf2\x7c\xac\xed\x00\x22\xb9\x1e\x04\xa3\x90\x9f\xae\x42\xc6\x6e\x79\x9c\xb3\xeb\xba\x8a\x7d\xe1\xd1\x50\xd4\xd9\xcb\x94\xa4\xbc\xb6\x52\x20\xc8\x96\x8d\xee\x12\x5d\xef\x79\x54\xd2\x8b\x4e\x50\xca\x01\xe7\xea\xb5\x0f\xef\xf2\xfa\xdf\x36\x67\x8a\xed\xe7\x11\x77\xe7\xa8\xd4\x1b\x17\x17\xfa\xe5\x32\x3e\x3b\xa7\x09\x2b\x8f\x58\x99\x63\x36\x61\x86\x5f\x75\x61\x9c\x5b\x17\x97\xb4\xdb\xae\x48\x3d\x48\xd7\x8e\xa4\xc7\x6b\xd9\xfa\x51\xb9\xcf\xe0\x51\x6a\xbe\x6a\xdc\x92\x2b\x46\xbe\x44\x28\xd7\x52\xfa\xd1\x74\x36\x21\x2c\xe2\x8d\x16\x2d\x41\xa8\x24\x08\x9a\x29\x7c\x86\xbe\xc5\xec\x58\x17\x6b\x06\x2d\xa2\x4a\xf0\xcf\x05\x05\x55\xcf\x37\x9b\x45\x2e\xe9\x78\xc2\xff\xb5\x02\x8f\x21\xf1\x61\x99\xc3\xd0\x6b\xf9\xf3\xc4\xab\xdc\x1f\x8f\xde\x41\xd7\xa4\x7b\x90\x0a\xbe\xeb\xc7\x09\xe1\x33\xa6\x72\x78\xec\xb0\x64\xd6\xe6\x33\xcd\x51\x93\x4a\xc0\x0e\x73\x9d\x4d\xde\x20\xa3\x98\x10\xb6\x79\x06\xcd\xe6\x34\x1a\xe0\xee\x45\xdf\x9f\xf4\xe7\x13\x3f\x8d\x62\x9a\xcd\xef\x47\x49\x5b\xd6\xc6\xf7\x82\x44\xc3\x2d\x25\x55\x05\xb8\xdb\xde\xae\xdb\xe4\x07\xb8\xd6\xdf\x12\x2e\x16\xd6\xc2\x6e\xeb\x2f\xbc\x6f\x71\x87\xca\x1f\x0c\x54\x05\xbe\xd3\x33\xab\xf0\x6b\x3d\x3d\x6f\x12\x84\xcf\x89\x4d\x12\x84\x0a\x1b\xf6\x62\x60\x93\xfa\xcf\x5b\x43\xea\x6b\x35\xb0\x17\xa3\x86\x7e\x94\x8c\x4b\xab\x10\xae\x28\xd6\xa2\x26\x7d\x50\xac\xc5\xfa\xa2\xee\x99\x40\x92\x20\xbc\x38\x90\x9a\x97\x6b\xeb\x0a\x40\x2c\xaf\xb6\xb0\x9b\x96\x57\x37\xdb\x71\x47\x95\x0c\x9d\x98\x97\x65\x26\xbd\xa8\xe3\x39\x51\x3a\x26\x71\x27\xac\xc7\x4e\x7f\x1c\x05\x7d\xd2\x89\x95\xdd\x04\x13\x6e\x62\x0e\x5e\x8e\xe7\xc1\x24\x96\x8f\x95\x8f\x75\x09\xa9\xbc\xdb\x58\xf6\x9a\xb7\x1f\xdc\xec\x84\xca\xb9\xed\xda\x2c\x8e\xd6\x3b\xc1\xbe\xde\x8c\x59\x1c\x35\x4d\x4f\x1d\x8b\x55\xac\x35\x45\xa9\x04\xa5\xd4\xa8\x2f\xf4\xfc\x45\x63\x22\x18\x16\xb0\x87\xbd\xd0\x54\xc7\x34\x7a\xd7\x1f\x04\xc8\x10\xfb\x39\x4a\xb3\x81\x61\x56\x52\xde\x39\x96\xbc\x0b\x80\x9d\x89\x74\x16\x76\x2d\x9b\x54\xf7\xd6\x17\xb6\xdd\x6c\x69\x30\x07\xc1\x71\xc1\x58\x13\x43\xad\xa9\x0f\x35\x4a\x29\xad\x87\xa5\xc3\xbd\x15\x7e\xce\xbb\x4e\xe7\x12\x5e\xaa\xf2\xf6\xeb\x6f\x57\xf6\xcd\xce\xdf\xcf\x74\x57\x6b\xb5\x7e\xd2\x6a\x0f\xc2\x63\x12\x27\xa4\xb4\xfd\x5e\x53\xef\x8f\x49\x34\x52\x39\x83\x12\x36\x0e\xec\xa6\x7c\xf6\x5c\x9d\xd2\xd3\xa8\x48\x02\x09\xaa\x7c\x4e\xa7\xca\x74\x3e\x59\x92\x75\x5d\xcf\x7a\x3f\x33\x3e\x32\xd4\x01\x45\x1e\xe5\xac\x66\x85\x76\x5d\x7b\x8b\x6d\xc6\xe2\x46\x06\x8d\x8c\x06\x1d\x33\x94\xd4\x10\x09\x14\x26\x93\xe8\xc4\x19\x07\xa3\xb1\x43\x16\xd9\x11\x9b\xed\xb4\x49\x74\x42\xeb\xa6\xb9\xb5\xed\x1e\x56\x25\xf7\x36\x27\x0b\xe3\x94\xc2\x87\x61\x3b\x38\x33\xcd\xbb\x85\x9d\x3b\x8b\x4e\x3c\x77\xa1\x90\x22\x1a\x2a\x0b\x81\x08\x9b\xf3\xe9\x4c\xff\xe1\x62\xbd\xe3\xb9\xfb\x06\x40\xbd\xf7\xd1\x8d\xed\xbc\x26\x26\xf3\xa9\x30\xdc\x9c\xdb\xc4\x64\x3e\xad\x5d\xb8\x89\xc9\x7c\x6a\xe0\x54\x20\x4a\x9e\x53\x42\xb0\xc9\xca\xac\xe4\x42\x12\xa2\xbe\x82\x84\x48\xe6\xbd\x25\x0c\x5e\xd7\x19\xbc\x70\xa6\x7c\xce\x36\xa6\x7e\xa6\x8d\xcb\xa7\x28\x0a\x94\x52\xc1\xb7\x16\x36\x93\xf2\x54\x6a\xfa\x19\x10\xbc\xc2\x52\x30\x8b\x75\x3e\x81\x37\xbd\x5d\x57\x6a\x9d\x6a\x57\x5a\x6a\xab\x4a\xed\x9a\x92\x24\xf1\x47\x44\xd3\xbb\x78\x4a\x87\xff\x9e\xa7\x06\x66\x95\xc0\xad\xe7\xbb\xdf\x8a\x9f\x79\xf1\x4f\xef\xcf\x93\x71\x49\xa0\xcb\x8d\x8d\x6d\x1e\x1e\x2a\x48\xde\x9c\xf8\x69\x4a\x42\x74\x8f\x2b\x09\x8b\xb9\xe5\xd9\xfb\x32\xe8\xd9\x7b\x63\x02\x3d\x9f\xae\x7e\xa8\xb6\x4e\x57\xf2\xdc\xe3\x65\x08\x0f\x0f\x1b\x43\x06\xed\x21\xf7\x11\x9c\xcf\x28\xb6\x68\x4c\x88\x09\xdb\xb0\x47\xe3\x02\xcb\x15\x84\xa3\x86\x0c\x96\x26\xa3\x9e\x65\x03\x58\x32\x07\x1a\x5a\x2d\x7b\x4a\x23\x51\xbe\xa1\xe7\x66\xf6\xcb\x33\x18\x90\x59\x3a\xc6\xec\x53\x7f\x11\x4c\xe7\x53\x11\xe3\x2c\x0a\xd9\x37\xa3\x54\x2f\x8a\x26\xc4\x0f\xcf\xa0\x3b\x8b\xc9\x20\xe8\xfb\x29\xe9\x18\x34\x39\x40\x50\x9a\x9f\xfd\x71\x74\x44\x06\x30\xc3\xfb\x80\x08\x0b\x9c\x59\x02\x31\x48\x1e\x60\x8b\x0f\xe0\x5d\xde\x76\x8a\x3b\xf7\xea\x44\xf3\xc8\xcc\x4f\x12\x78\x28\x6b\x7e\xc8\x1c\x72\x92\x46\x01\x15\xba\x2c\x0a\x51\xa7\x7b\xc0\x30\x0a\xc2\x20\x0d\xfc\x89\x08\x65\xc4\x4e\xf0\x15\x45\x89\x84\x77\xf9\x3b\x5d\x55\xd1\xf5\x09\x27\x1e\xe1\xae\x49\x0d\xf3\x8e\x22\xda\xb5\xbc\xf9\x16\x7e\x77\x18\xd5\x1c\x90\x68\x3a\x20\x5a\x26\x82\x71\xa9\xa0\x5d\x01\x8f\x53\xc8\x2e\x21\x63\x11\xa1\x58\x48\x2a\x5e\x9b\x16\x2f\x4b\x02\x84\x27\x4f\xc0\x52\x6f\x1d\x93\x2b\x79\x84\x31\x6c\x26\xcd\xa8\x82\x37\xf1\xeb\xf8\x78\xd4\xad\x5a\x8d\x55\x7e\x13\xcc\x70\x4f\x14\x2d\x71\x89\x11\xe2\x20\x76\x9e\x65\x8c\x28\xc6\x32\xb7\x58\xc8\x2e\x89\x07\x8b\xfd\x9e\xb9\x4a\x40\x64\x35\xc2\x6b\xe1\xd5\x0c\x2c\x8e\x1e\x99\x9c\x0a\x02\xb3\xca\x12\xb0\x92\x79\x82\x52\x83\x8e\xb0\x34\x62\x71\x08\xd9\xd5\x41\x93\x60\x1a\xa4\x89\xdd\x50\x91\xb0\x34\xea\xcb\xfb\xa1\x66\x2c\xce\xe2\xf2\x1e\x28\x8d\xe3\x25\x65\x01\x27\x9c\x03\xdc\x59\x48\x86\xd6\x02\x33\x90\xd8\x75\x01\x3b\x1b\x2f\x8b\xb3\xa0\xf0\x51\x12\x77\x42\xe9\x41\xb3\x8a\x62\x66\x15\x04\xef\x93\x8d\xdc\xcf\x2d\x81\xb7\x9e\xef\x0a\x36\xda\xd9\x0f\x4e\xa7\xbd\xa8\xec\xbe\xb4\xbd\x0d\x29\xf9\x5e\x8f\x47\x73\x2a\xbf\x92\x92\xac\x2d\x77\x4f\xcb\x4b\x45\x4f\x71\x3e\x6f\x97\x8b\x47\xf8\xfc\x3c\x98\xa4\xf5\x20\xe4\xfc\x16\x93\x21\x89\x49\xd8\x27\x49\x43\xde\x6b\x36\x8b\x89\x3f\xa0\x6c\x2d\xb1\xe4\x0f\xb7\xf9\x43\x23\x48\xee\xe0\x91\xf6\x07\x32\x2b\xb4\x95\x0f\xde\x7e\xf6\x6a\x81\x60\x08\x0f\xb1\xba\x87\xcc\x73\x71\xa8\xc9\xf3\x87\xbe\x68\xe2\x43\x88\x30\xe0\x2f\x44\xb1\x1a\xf6\x65\x82\x77\x5d\xdc\x63\xf6\x9e\x8c\xcc\x29\xbc\x0d\x33\x22\x46\x0a\x3b\x21\x64\x1e\xa6\x31\x62\x62\x20\xa5\xa1\xe4\x30\x3e\x7b\x88\x4e\xa0\x0f\x33\xb2\xc7\x18\xf6\x7c\xf8\x21\x0f\x72\xa6\xe2\xdd\x20\xbe\x3c\x79\xa2\x77\xa2\x4a\xc5\x2e\xbb\x7e\xdd\xca\xd1\xfa\xc6\x0d\xde\x1a\xf1\xd0\xcd\x66\xa1\x12\xa5\x88\x65\x0d\xcc\x0a\x98\x76\x95\xd0\xfb\x2b\x4c\xd9\x6f\xf9\x65\x57\xf8\x79\x9b\x9b\x22\xf8\xa3\x9f\x90\x7b\x38\xf3\x90\xb2\x09\xdb\x73\x5b\x5a\xe6\x72\xa0\xbb\x5b\x1b\x5a\xbe\x07\x51\x9c\x7e\xbe\x8c\xc7\x77\xb7\xf4\xfa\xbf\x82\xbe\xfa\x25\xa3\xc6\x13\x95\xe3\x0d\x33\x31\x79\x4b\x5c\xf3\x55\x06\x79\x4b\x8c\x32\x8c\x19\x9a\x96\xa2\xe0\xae\xac\x85\x44\xf1\x80\xc4\x9f\x3f\x65\x5a\x48\x34\x4f\xd9\x89\x00\x18\xcd\xfd\x78\x90\x9c\xab\x72\x3c\x11\xb1\xb1\xfb\xd1\x64\x42\x18\x6b\xd2\xfa\xb4\xd7\x34\xe2\xb3\x3f\x41\x1b\xab\x31\x61\x8b\x70\xa9\xdd\x03\x0e\xa8\x7b\xf0\x84\xb9\xfd\x76\x0f\xce\x44\x31\x92\xb0\x59\x5c\xbe\xa5\x11\x24\x54\x55\xea\x9d\x1a\xc0\x54\x41\x6c\x13\x2b\x85\x19\xf9\x3b\x6d\xb0\x84\xf2\x70\x35\x0d\x80\x96\x5f\x32\xfd\xbf\xc3\xa8\x67\xa9\xf6\x3a\x0a\x51\x87\x57\x5c\x34\xe5\x63\xec\x54\xd9\xa2\x8e\xe4\x69\x4b\x26\x8a\x00\x95\xb7\xb5\x7c\x6d\xe8\x8a\x9e\x3f\x70\x14\x7b\x59\x3a\xa3\xdb\x5a\x90\x55\x31\xfd\x73\xde\x36\xd0\x94\x63\x8f\x4f\x9e\x47\xe4\xd4\xd1\xfa\x4d\x57\x09\xfa\x31\x45\x21\xf0\x0b\xf1\xd4\x20\x89\xb4\x5c\xb0\x69\xf1\xc1\xd2\xe7\x53\x71\x6f\x3d\xcf\xf3\x21\x54\x45\x3d\xd5\xb6\xac\xd2\x81\x2a\x12\xad\xda\x06\xae\xb4\x38\x50\x45\x28\xd5\x36\x97\x50\x67\x78\xfb\xad\x11\x3d\x56\x8d\x51\x39\x93\x4b\x24\x99\x70\x77\x80\xd9\xb3\xcc\x40\xe9\x99\x61\x68\xe6\x95\xdd\x29\xea\x2b\x9b\xb0\x39\x53\x14\xc8\xbe\xe7\x0b\xda\xcf\xc2\xf2\x27\xe4\xae\xdf\x2f\x5d\xad\x6c\x6e\x99\xf3\xf0\x97\x83\xa3\x72\xd1\xb7\xfa\x5a\x65\xea\xcf\x94\x84\xd0\x97\x2a\xa2\x67\x21\x19\x47\x71\x3a\xf6\xc3\x97\x27\x34\x94\x80\x58\x79\xdd\x71\xde\x68\x9f\xfa\xb3\xd9\x92\xd1\x9e\x1d\x42\x26\xbf\x17\xeb\xf4\x72\x0c\x6a\x1d\x62\xe9\xc3\xec\x36\xb0\x99\x5a\xa5\xc9\x18\xac\x6d\x8c\xa2\xbb\x06\xb2\xd7\x2f\x33\x80\xb9\x42\xca\x47\x0f\x55\x45\xcd\xd1\x98\x2f\x28\xf8\x7b\x65\x0d\xf5\x2d\x7f\x56\xc0\xec\x2b\x87\xac\x5e\x89\x03\x13\x1c\xce\x0f\xf9\x41\x92\x79\x42\x12\x78\xc8\x87\x6b\xfc\x90\xf2\x0b\x53\xfa\x68\x57\x52\x60\x4a\xee\x63\x79\xec\xd1\x87\x78\xce\x83\xdf\x82\x90\x28\xa9\xc6\x46\x79\x22\x77\xe9\x83\x18\xfa\x51\x1c\x93\x64\x16\xe1\x2d\x7f\x14\x1e\x5b\x8a\x5e\x6e\x09\x4e\x71\x29\xe1\x60\xd1\x02\x93\x83\x55\x6b\x54\x33\x96\x33\x30\x6f\x60\x01\xcf\x72\x31\xc8\xd7\xa7\xa2\x3e\xc5\xb1\xe5\x6b\x4e\x96\x40\x31\xb0\x64\xb1\x7d\xb5\x86\xe4\x7e\xc7\x75\xc1\x67\x6c\xbd\xa8\x16\x3c\xc6\x7b\x43\x2e\x7f\xb4\x85\x0f\xe6\x28\xe7\x2a\x86\x79\x01\x63\x3d\x7f\x24\x61\xde\x9e\xd7\x93\x3e\x61\xf7\x38\x96\xe9\x5b\xdb\x9a\x84\xfc\x4a\x42\x06\xd0\x3b\x35\x94\x26\xaa\xeb\x33\x58\xea\x8a\xd6\x19\xbb\x18\x3d\x20\xa8\x71\xf8\x6a\x55\xe0\x87\x38\x8f\x50\x58\x78\x7a\x29\xc5\x85\x07\x76\x71\x3a\x26\x53\xc1\x5c\xf7\x86\xf0\x90\xcd\x34\xb8\x22\x98\x87\x78\xc0\x6a\x18\x90\x81\x83\xe7\xa2\xb8\x55\x84\xd6\xc9\xb5\x93\x20\x04\x5f\x36\x85\x71\x0b\xbc\x43\xab\x3a\x09\xf0\x32\xf9\x75\x76\x46\x6b\x78\x0a\x7e\xa8\x06\x45\x65\x40\x92\x7e\x05\xa5\x38\x7d\x92\xc5\xa1\xe2\x8b\x74\x05\x55\x31\x22\x05\x17\x0d\xcd\x11\xb2\xc2\xf0\x10\x32\x9f\xaf\xad\x28\xbf\xf3\x47\x45\xc3\x46\x61\x01\xda\x10\x96\x1f\x9f\x96\x97\xe2\xab\x2c\x43\x8f\xd4\xd4\x41\xd6\x78\xa5\x40\x62\x2b\x09\x9d\x4f\x79\xaf\x9d\x66\xc6\x99\x30\x95\xe9\x33\x85\x26\x5b\x82\x10\xad\x0c\x51\x8c\x80\x1e\x32\xdc\xb2\xc3\x70\x35\xad\x62\xc9\x1c\x12\xf5\x1e\xdd\x51\x2a\x18\x2b\xde\x90\x1a\x92\xc8\x94\x8e\xf5\x4c\x14\x76\x2e\x8f\x1c\xec\x1a\x44\x11\x09\x5f\x80\x41\x6c\xbe\x2c\x33\xe2\xab\x2e\x16\x56\x30\x21\xc9\x39\x2f\x3b\xce\x2c\xad\x5e\x6e\x5a\x72\x74\xc4\x79\x9a\xad\xec\x4d\x85\x41\xe1\xd9\xc5\x94\x1d\x03\xd7\x82\x8b\x74\x55\xf4\x7b\x65\xbc\x61\x08\xb2\xce\x13\x00\x0c\x23\x57\xa6\x34\xac\x83\xc5\x73\x77\xa0\x4a\xc7\x49\x15\x6e\x43\xdd\x83\xb6\x0c\xb9\x2e\xcc\x39\xcd\x26\xbc\x19\x2c\xd8\x0d\x17\x0f\x51\x3e\xff\xff\x28\xa7\x3c\x84\xde\x7c\x24\xee\xee\xf8\xff\x3f\x00\x12\x8e\xa8\x64\x27\xd3\x1e\x19\x0c\xd8\xe0\x7d\x7d\x10\xf5\x08\xf8\xb3\xd9\x24\x60\x67\x22\x93\x35\x7e\x9b\xb3\x9f\x42\xdf\xc7\xc9\x2e\x48\x1d\x76\x94\x05\xfa\x24\xc6\xcb\x28\xfb\x41\xdc\x9f\x4f\xd9\xc5\x0b\xec\xaa\xe3\x59\x1c\x1d\x07\x03\xe6\x14\x82\xa7\xe6\x99\xe8\x19\x46\x31\x83\x27\xf8\x13\xc5\xcf\x43\x64\x91\x87\x0d\x78\x40\x08\x8c\xd3\x74\x96\xb4\x9b\xcd\x51\x90\x8e\xe7\xbd\x46\x3f\x9a\x36\x1f\xf9\xc9\xf8\x88\x84\x7e\xd2\x64\x27\x68\xfa\x51\x4c\x9a\xb3\xf9\x64\xd2\xf4\x5a\x9b\x3b\x0c\x20\x65\x7a\xf4\x4b\x1e\x90\xd4\x0f\x26\x54\x00\x40\xb3\xc9\xbe\xbd\x37\x16\x11\x9b\xd8\xdd\xaa\x78\x54\x54\x13\x79\x41\x08\x5f\xdd\x45\x4c\xd8\xb8\x66\x74\xe1\x20\x0c\xa4\x7a\xf3\x51\xd2\xe8\x8f\xe3\x68\x1a\xcc\xa7\x8d\x28\x1e\x35\x67\xcd\xe3\xdd\x66\x90\x24\x73\x92\x34\x59\xd5\xb7\x83\x41\x67\xcf\x2d\x44\x88\xf7\x27\x1f\x36\x8c\x79\xea\x7c\x80\xe0\x5b\xf1\x14\x94\x19\xb5\x05\xf3\xd0\xf3\x47\x12\x0e\x92\xa5\x06\xb8\x9d\x1d\x6d\xfa\xb9\xc3\xf0\x49\xa4\x55\x3c\x52\x53\x47\xd1\x0c\x70\x71\xa3\x55\x81\x38\x5d\xcf\xcb\xdf\xe2\xfc\x97\x14\x98\xcc\xf0\x55\x2c\x2f\x95\xd4\xe0\x7a\xaa\xb6\x62\xa3\x62\x80\x21\x72\xbd\xd3\x31\x97\x72\xdc\x86\x7d\x2f\xe1\x21\x09\x85\xed\x15\x73\x4a\xdb\xa0\xa3\x1d\x38\x9c\xdc\x4b\xde\x9e\xe3\x85\x37\xdc\xf6\xdd\xe9\xe0\xa5\x1c\x99\x3c\xef\x92\xe1\x84\x2c\x82\x63\x62\x64\x64\xb8\x99\x39\x65\xa7\x8a\xfe\x95\xeb\x5e\x89\x61\x94\x8e\x75\x0c\x19\x69\x4b\x30\xc4\xbc\x1c\x43\x96\x31\x8f\x21\xe6\xd1\x31\x54\x19\xd9\x34\x63\xe6\xcc\x63\xc8\xdd\x3b\xd4\x6d\x10\xd6\x75\x55\xef\x8d\x1b\x70\x5d\x2f\x47\xdf\xf5\x96\x4a\x6b\xe1\x2d\xd1\x17\xdc\xb4\x48\xff\xac\x4c\x4e\xa3\xe9\xe2\x5d\xa1\x2e\xeb\x2a\xaa\xb9\x00\xb0\xc8\xb6\x1c\xac\x59\xf0\xba\xc1\x20\xcb\x33\x5f\x37\x3b\x3f\x67\xdb\xf0\xf6\x33\xf7\x67\x71\xe8\x12\xfd\x4c\xf3\xb3\x84\x64\x84\xbb\x59\x44\xb8\x7c\x4e\x03\xe9\x0c\x57\xca\xba\x8a\x6a\x2e\x00\x2c\xb2\x2d\x07\x9b\x21\x5c\x96\xca\x4b\x32\x5f\xcf\x12\x35\x43\xb8\xba\x57\xb8\x1d\xe2\x2e\x15\xc7\x52\x28\x14\xc8\xe3\xe7\x8b\xdf\x28\xad\x2b\x8b\x34\x26\xd3\xf9\xb4\xd4\xba\xbc\xad\x59\x77\xbf\x90\x96\x19\x62\xa4\x11\xf8\x22\xa6\x5a\x2a\xe3\xe7\x29\x61\x52\x53\xec\xc9\x32\x06\x51\xab\xd8\x06\xae\x10\xf8\x8a\x36\x48\x00\xdd\x78\xa9\xde\x8e\x1b\x05\xa7\xa8\xef\x3f\x94\x62\xe4\x21\x8b\x75\x40\x49\x4b\x06\x72\x52\x48\xe8\xda\xba\xcf\x1e\x83\xb0\x4f\xc0\x6d\x78\x0d\x17\xdf\xa7\x54\x33\x89\xdf\x19\xc2\x21\xbe\xf6\xfd\x94\x8c\xa2\xf8\x14\x3d\x0d\x56\x5b\xef\xe6\x2d\x37\x72\x76\x58\x37\x27\x06\xa3\x89\x2c\x2b\x59\xf8\x74\xf9\xcf\x11\x3d\x6c\x4c\xfd\x85\xd5\xdd\x74\xa0\xe5\xc0\xae\x03\xdb\xa8\x1b\xae\x53\x0d\xa1\x73\x0b\x76\xcd\x5c\xc6\x37\x49\x00\x73\x6e\xa1\x19\x11\x51\x63\xb7\x84\x25\xe1\x2d\x39\xda\x2a\x98\xdd\x85\x76\xdb\xe0\x0a\xb1\x90\x16\xbd\xea\x70\x36\x60\x79\x8d\xcd\xa7\x22\x2e\x9e\xfa\x8b\x02\xc6\x7d\xbe\xe8\x77\xc6\x4d\x36\x6b\x6b\x6b\x6c\xe1\xd4\x60\x78\xdc\xe7\xcb\x1a\x4b\x82\xa9\x1c\x1e\x92\x84\xdd\xfc\x59\x71\xf8\xa2\x63\x32\x27\x6d\x0c\x2b\xb2\x86\x76\x54\x3a\x14\x0e\x47\x24\x7d\x3b\xe8\x93\xf7\x82\xfe\xd1\x57\x99\xc6\x51\xb6\x48\xde\xa3\x65\xce\xa9\xb5\x3a\x22\xa9\x02\x55\x65\x15\x93\x70\x3e\x25\x31\x55\x09\x59\xed\x74\xc0\x8c\x48\xaa\x45\x2d\x1a\x91\xd4\xca\xd8\x68\xf3\x88\x35\x0c\xd8\xcc\xc8\x40\xdb\xb1\x02\x4a\x26\xa0\xab\x47\xcb\x4c\xb9\x10\x6a\xaa\x18\x86\x1a\x7e\x23\x9a\xfa\x41\xf8\x22\x09\xa7\x55\xa3\x10\xcd\xb2\xea\x2a\x5e\xd7\x2f\x91\x55\x79\xd6\xd2\x86\x40\x07\x0a\xb3\x98\xe9\x39\x3e\xd7\xb7\x90\x71\x30\x60\xa8\x80\xc1\x7b\x91\xd8\xdb\x36\x82\xf4\xaa\x37\xcc\xc6\x36\x62\x22\x0c\x2b\xeb\x40\x40\x33\x20\x0c\x3f\x8e\xd9\xbd\x68\xec\x95\xe2\x86\xc7\xe3\xd8\x2b\xd5\x02\x59\xb8\x1f\xf6\x4e\x0c\x34\x20\x8d\x4f\x69\x45\x22\x1a\xef\x61\xc0\x2c\x6c\x5d\xb1\x11\xce\xeb\x3c\xb0\x6c\x07\x0e\x93\x7d\xb8\x6e\x61\x05\xd6\x21\x0e\xdb\xa0\x11\x92\x45\x6a\xd9\x76\x63\x10\x85\xc4\xde\x57\xb5\x53\xec\x28\x66\xcc\xbd\xff\x30\x11\xe1\x51\xf8\xed\x6b\x37\x6e\xb0\xaf\xf2\xb2\xb4\x0e\x6d\x10\x8b\x2b\x03\x67\x70\x06\x7d\x0c\xb0\x63\x91\x38\x46\x48\x03\xd9\x28\x6c\x00\x89\x63\x9a\x6d\x18\x84\x18\x6b\xe7\x43\xde\x0c\x74\x9d\x38\x0c\x11\x7a\xd0\xad\x30\xfe\xac\x1c\xd8\xc6\x9b\x65\x9b\x45\x69\xa1\xc3\x81\xcd\x6f\xce\x3c\x24\xac\x7e\xc1\xdb\x3e\xab\x49\xc4\x4d\x92\xdd\xa3\xfa\x80\x96\xc7\xee\x6b\x88\xbd\x71\x3f\x8e\x6d\xfa\x45\x8b\xe6\xa9\x3b\x77\x64\x48\x4b\xd7\x58\x8c\x5f\xb3\x05\x0b\x7b\x5d\x82\xfa\x50\xbb\xeb\xf3\xbd\xd3\x19\xe1\xd7\xa5\xde\x0b\x8f\xfd\x49\x30\x00\x3f\x4d\xe9\x04\xce\x6c\xbe\x2a\x64\x52\x18\x85\x75\xac\x99\xae\x97\xc5\xf5\x8a\x15\x84\x7a\xb6\x0f\x67\x94\x38\xa8\x33\x7c\xf6\xf7\xd9\xdf\x2b\xf9\xb7\x0e\xbf\x36\x0c\x26\xe4\x9d\x63\x12\x1f\x07\xe4\x44\x1e\x90\x21\x90\x06\xfd\x23\x61\xc4\x88\x86\x90\xf4\x7d\xaa\xee\x7d\xf6\xf7\xd9\xdf\x2b\xf9\xb7\x0e\xbf\xe6\xcf\xd3\x71\x14\xc3\x22\x98\x90\x6d\xcf\x73\xc0\x8f\xfb\xe9\x78\x1e\x7f\xc6\xb4\x9f\xfd\xbd\xa2\x7f\xeb\xf0\x6b\x03\x2a\x6b\x5b\xae\xb7\x55\x77\xf7\xea\xde\xce\x67\xcc\xfa\xd9\xdf\x2b\xfa\xb7\xde\xe4\xab\xac\x79\x1a\x4c\xca\xcc\x0c\x1b\x5b\x3b\xd2\x34\xe1\xc7\x41\x3a\x9e\x92\x34\xe8\x97\xd9\x24\xb6\xdd\x82\xcc\x2d\x5c\x0a\x85\x29\x89\xa3\xd9\xbb\x2c\xef\x1b\x64\xe8\xcf\x27\xa9\xa5\xe5\xa2\x05\xe5\xfa\xa1\x24\x7b\xd4\x7b\xa4\xe9\xff\x51\xef\x11\xda\x90\x7b\x8f\x1a\x6a\xc1\x0a\xb7\x31\xbd\x0d\x1f\xc2\x80\x95\x6a\x63\x02\xd5\xde\xf5\x0a\xd2\xe8\x4e\x14\x26\xf3\x29\x55\xf4\xd5\xb2\x64\xe9\x7a\x45\xdd\xc9\x02\x1d\x70\xe9\x74\x14\xd3\xa6\xc9\x4c\xc2\x7c\x55\x76\x5f\x0b\x16\xe8\x06\xdc\x49\xa3\x1b\x1c\x68\x2b\x27\xfa\x49\x5b\xba\xf0\x54\x86\xc7\x30\x8e\xd0\xfe\xc5\x56\x21\xca\x68\x29\x35\x3b\x1f\x90\x5c\xc7\xfe\x84\x79\x3e\x4c\x83\x50\xb3\x60\x62\x04\x3e\xd3\xe4\x67\x5e\xff\x0f\x1f\xbe\xcd\x37\x8f\xa6\x41\xc8\x79\x03\x0f\xa7\xe8\x60\x8a\xf3\xfb\x0b\x3d\x7f\xa6\x0a\x61\x7f\x94\x36\xcb\xd7\x43\x89\xa8\x69\x1d\x1c\x91\xf4\xab\x74\x55\x76\x8f\x7f\xb5\x0e\x63\x32\x54\x3b\xf3\xf4\x0d\x99\xc8\x30\x07\x60\x26\x07\x84\x2b\x2f\x20\xf6\x1d\x96\x59\xde\x59\x0f\x88\xa3\x48\xf5\x0e\xa4\x8f\x26\xae\x02\xdf\xc2\x12\xd3\x20\x74\xe4\x26\x35\x4d\xc5\x12\xcc\x64\x88\x9b\xa2\x64\xc1\xce\xdc\x8a\x3b\xd8\x69\x45\xb7\x68\x06\xb5\xf7\xa5\x80\xd1\x62\x59\x50\xc2\xb2\xa3\x2c\x9f\x5d\x51\xc4\x91\x19\x0f\xd0\x74\x99\xeb\x5c\xdc\xc8\x4b\xc9\x0c\xe4\x75\x3c\xc4\x4f\xd0\xde\xab\x45\x58\xec\x91\xf4\x84\x90\x10\x75\xfc\xc4\x61\x91\xc9\x3d\xd7\x81\x16\xfd\x7f\xab\xac\xbb\x21\x8e\xe6\xa3\xf1\x03\x0a\x5c\xeb\x46\x4c\x64\x55\xca\xc5\x03\x3a\xe0\x0c\xc8\x71\x80\x1b\x9d\xdc\xd7\x6b\x10\x0c\xf9\xe1\x01\xfa\x95\xe2\x49\xab\xbf\x13\xcd\xc3\xd4\xa8\xee\xf3\xc2\x03\x1f\x03\x2e\xbc\x21\x82\x3c\x01\xc0\xeb\x34\x41\x96\x14\x91\x98\x64\x18\xa8\x28\x86\x30\x32\x61\x51\x0e\x19\x51\xdc\xd1\x0f\x06\xb9\xe7\x4d\xbf\x9f\x46\x31\xbc\xae\x25\xc1\x10\xd3\x0c\x1e\x94\x8d\x7e\xef\x42\x04\x3d\x89\x18\x6e\x39\x86\x7d\x33\x8a\xa7\x7e\x4a\x89\x67\x49\x32\x3a\x66\x13\x9d\x1c\x96\x6a\x17\x55\x91\xfe\x66\x47\x5d\xe2\xaf\xf6\x62\x38\xbb\xb0\xbb\x61\x47\x41\x8a\x64\xa5\x8c\xac\xc9\xd5\x06\x97\x70\x8d\x11\x49\xdf\x90\x99\x14\x68\x74\x94\x40\x97\x00\x02\xe8\x8e\xa9\x9a\x65\xf6\x33\x6d\x31\xf2\xd9\xd4\x9f\x4c\x48\x92\xf2\x48\x5b\x9c\x42\x18\x18\x1a\x7a\xc1\x68\x44\xb8\x43\x83\xf4\x65\x9a\xfa\xa3\x30\x48\xe7\x03\x76\x5a\x2c\x0b\x97\xe3\x4f\x1f\xdf\xc5\xea\x3b\x1a\xc7\x35\x41\x1e\xf0\xa4\x9c\xaa\x1a\x29\xb0\xfe\xda\x98\x84\xe0\x33\x91\x31\xc2\x1b\x05\x06\x78\x76\x24\xf2\x53\xe1\xf4\x85\xbe\x59\x18\xdf\xa7\xdf\x9f\xc7\x7e\xff\x94\xe2\xc4\x1d\x48\xa6\xfe\x29\x65\xa6\x93\x38\x0a\x47\x1c\x11\x7f\x4a\xc2\xc1\x03\x0d\x1b\x8d\xb2\xd7\x3b\x1d\xf0\xe0\x76\x31\x7d\x79\x75\xa7\xec\x28\x6a\x9f\x04\x13\x4b\x35\xaa\x09\x6e\xc3\xdd\xb2\xa1\x96\xeb\x6d\x87\x7f\x69\x5f\x12\xaa\x57\x06\xd4\x53\xbe\xe6\x43\xc9\x86\x65\xcc\x21\xab\x31\x9b\xef\x94\xd2\xdf\x70\xe9\x36\xc7\xec\x6d\xbd\xbe\x36\x28\xc4\x55\xb2\xad\x8b\xb1\xbe\x21\xc6\xd8\x20\xc7\x88\x4f\x69\x76\x7e\x01\xf2\xc1\x9c\xd6\x90\x46\xf9\x1d\xaa\x52\xf9\xc5\x4a\x42\xc9\x9c\x35\x27\x60\x5e\x61\x56\x04\xb8\x40\xb4\x48\x29\x26\xa1\x62\x30\x3d\xca\x5b\x42\x14\x9c\x2b\xdc\x56\x97\x6c\x99\x39\x32\xfb\x57\x2c\x7c\xde\x0b\xfa\x47\xef\x0c\x1f\x04\xe1\x68\x42\xd0\x7a\x2e\x7c\x35\x24\xee\x19\x51\xa4\xb9\xb9\x25\x6f\x4e\x4a\x05\x09\xfd\x18\xf9\xa9\x76\x5e\x40\x0c\x60\xe8\xb0\x1d\xf7\x66\x33\xd3\xa9\xd3\x60\x30\x98\x10\xb5\x5b\xca\x11\xc6\x82\xfc\x9b\x3c\x85\xc7\x65\x1f\x43\xe1\xc6\x8d\x22\x14\xf9\x48\xed\x25\x5f\xc5\x6b\xbb\x59\x5c\x92\x5e\x62\x7a\x72\x60\xf4\x1e\x96\xe5\xa6\x7e\xce\x91\xcb\x3a\xc4\x37\x19\x47\xf3\x09\x15\xe4\x52\x68\x48\xa1\xc6\xf9\x4f\x9b\xbf\x82\x84\xcb\xbe\x98\xc9\x31\x8f\x03\xe4\x2d\x37\x46\xca\x0a\x12\x98\x9f\xf3\xaa\x83\x27\x30\x06\x45\x8b\x15\x64\x01\x8b\x9e\xc0\x48\xda\x44\x24\x6c\x87\xfd\xec\x67\x8f\x42\x72\x32\xdc\xca\x90\xe1\x5d\x71\x6f\xa3\xe2\x78\x21\x47\xe5\x98\x30\x5a\xcc\x0f\x77\x30\xea\x88\x97\x20\x81\x51\x4c\x30\xc8\xa1\x41\x16\xd9\x96\x2c\xb6\xba\x6b\x9e\xc2\x51\x79\xed\xc8\x89\xae\x08\x82\xa5\x06\x1e\xa5\x1c\x34\xa1\xc5\x7c\xe2\xb5\x83\x9f\x85\x1c\xb3\x1c\x1d\x39\x8f\xb2\x6c\xf7\xb8\x9b\xe7\xb9\x15\x0b\x01\x8b\xfb\x39\xb4\xdf\x71\x99\xd4\xe8\x47\xd3\x59\x94\x10\xdb\xd2\xd2\xa6\xfe\xcc\xb6\xd4\xe6\x47\x98\xdd\x01\x2c\xea\xf1\x64\x3e\xb5\x18\x46\x25\x2c\x25\x59\x22\x84\xba\x8e\x3b\xe7\x04\x7e\x5c\x40\xe2\x10\x53\x0d\xd5\x10\xdd\xc3\x90\xa2\x28\xdb\x66\x2f\xd7\x2f\x4b\x85\xac\x5a\x14\x94\xad\x0d\x70\xd5\x61\xe8\xf6\x45\x60\xe4\x5a\xa1\x6c\xc9\xb0\x0c\x4c\x89\x70\xbe\xb4\x7c\xbe\x94\xf2\x29\xdb\x72\x61\xe5\x53\x38\x55\x4b\xf1\xe4\xe4\x29\xc8\x75\xf7\x1c\x49\x0a\x66\x00\x29\x81\x51\xfd\xa4\xeb\x17\x5a\x6c\x15\xe9\x9f\xc3\x9c\xae\x45\xf9\xf1\x54\xb1\xdb\x78\x0b\x36\x99\x4b\x06\x4f\xef\x6e\x1e\x98\x2e\x72\x70\xdb\xfc\xd8\xa6\x0a\xeb\x9a\x29\x7e\x2f\xa8\x5c\xeb\xf3\x8c\xa9\x5c\x5b\x94\x71\xe8\x00\x08\xe9\xc0\xcc\x0c\xd5\xf3\x15\x6e\x81\xd8\xeb\x30\x25\x83\xc0\x9f\x9c\x37\x51\x45\xc1\x40\xb5\x06\x55\x50\x97\xb6\x22\x08\x13\xe1\xe1\x2b\xf8\xd3\x01\xd7\x98\x64\x28\x3c\x6d\x81\x48\xd5\x7a\x4a\x46\x8a\xfe\xad\x22\xc9\xe7\x6a\xb2\x8d\x7d\x5a\x3a\xb7\xae\x9d\x3f\x89\xb0\xbb\xf6\xac\x25\xe2\x86\x31\x8a\xed\x70\xc9\x8a\x55\x4e\x83\x70\x9e\xb0\xb0\x1f\xd1\xca\x55\x61\xa1\x73\xe4\x17\x42\x94\x79\x94\xd0\xc2\x5a\x93\x34\x0e\x66\x2b\x54\x84\xf9\x24\x10\x6f\xdb\x14\xe9\x3d\x32\x89\x4e\xc4\xd2\x48\x69\xa3\x3c\xbf\x62\x1b\x39\x77\xd2\x42\xf3\x59\x51\x09\xce\x65\xb4\x5c\xae\x04\xee\x95\x89\x42\x5a\x9d\x35\x09\xab\x46\xb5\x23\xde\xfb\x5a\xee\x5b\x9a\xf8\x55\x9d\x8c\x6c\xc5\xe2\x4a\xa3\xe4\x09\x09\x19\x30\xcf\xde\x63\x9c\x69\x75\x1e\xcb\xe8\x32\x6c\x15\xd6\x30\x0e\x4f\x5e\x50\x18\xe4\x07\x09\xc5\x3e\x3b\xd3\x6a\x8d\xb8\x59\xde\x88\x09\x49\x12\xde\x88\xbe\x1f\x16\x36\xe0\x84\x08\xf4\xfd\xc1\x00\x92\x68\x4a\xe8\x43\x40\x6b\xf7\x27\x72\x10\x82\xd6\x2b\x38\x62\xc0\x85\xdb\x1a\x75\x8d\x71\xaf\x70\xa3\x6b\x2b\x9e\x89\x71\x96\xc1\x10\x0a\x90\x96\xdc\x36\x3b\xb0\x0c\x70\xd6\x60\xc3\xda\x4d\x7b\xa3\xcd\x04\xf8\x9a\xd0\xce\xdf\x0a\xc2\xb2\x05\xde\x0a\x83\x44\x4c\xf2\x0a\x29\x31\x54\xb4\x1a\xfc\x45\x49\x0d\xab\x2b\x11\x9c\x4a\x02\x38\x6d\x1d\xd5\x07\x0a\xd5\x01\xd6\xa1\xb9\xd9\xb8\x54\x3d\x70\xd4\xe4\x3e\xa5\xc4\xc8\x29\x08\x98\xa1\x5d\x62\x24\x7c\xd5\xd6\x5f\xc5\x2b\x2e\xd3\x57\xe9\xcd\x10\xad\x8f\x1b\xa6\x8d\x72\xb3\xd8\x46\xb9\x51\x6c\xa4\xdc\x2c\x34\x52\x6e\xea\x46\x4a\x45\x89\xc2\x69\xda\x33\xa7\x69\x6f\xd9\x34\xed\xd1\x69\x7a\x5b\x08\x34\x93\x58\x85\xc0\x5b\x26\xf0\xd6\x32\xe0\x2d\x0a\x1c\xfd\x8f\xf8\xc4\xf9\x96\x0c\x9a\x2f\xe7\x78\x4d\x88\x31\x92\x4b\x8d\x44\x93\xc5\x53\x7f\x61\x69\x72\x4b\x53\xc3\x0f\xb3\x36\x62\xa6\x28\x98\x66\xe3\xae\x60\xc6\x03\x49\xef\x5c\xb9\x22\x43\x72\x36\x8f\xde\x61\xfd\x28\xe6\x7d\x96\x83\xa4\x75\x20\xcd\xc5\xfa\x30\x9f\x8b\x77\x28\x95\xaa\x02\x58\xa7\xc3\x4b\x64\x56\x0a\x85\x4b\x7b\x56\x68\x89\x76\x27\x65\x55\xb3\x09\x5f\x20\xa9\x32\x19\xe7\x15\x2d\x41\x4d\x63\xd2\x80\x4e\x66\x12\x11\x35\x32\x1c\x1d\xd6\x47\xd9\x5a\x1d\x73\x8d\x6c\x82\x6c\x28\x19\x29\xa5\x64\x3e\x13\xff\x60\xe4\x63\x54\x2c\xc8\xc7\xed\xf1\x32\x56\x52\x52\xa6\x32\xe0\x4a\x08\xdb\x21\xe0\x4b\xc8\x35\x70\x1b\x1e\xac\x73\x15\x9c\xcf\xf1\x4a\xc8\x4b\xc3\x3e\xdc\xd6\x97\x7c\x31\xc1\xf8\x8e\x36\x5b\x54\x26\x74\xd2\x39\xe6\x8e\xa5\xfa\x9e\x92\xe9\x0c\xc9\x24\xc4\x96\x29\x21\xb6\x8b\x25\xc4\x56\xb1\x84\xd8\x2e\x94\x10\xdb\x9f\x49\x88\xd5\x24\xc4\xc6\x65\x45\x44\x91\x1c\xcf\x01\x5f\x4d\x46\x6c\xae\x24\x23\x36\x5f\xa2\x8c\x28\x5f\x68\x71\xfc\xea\xbc\x39\xb8\xdc\xea\x97\x2f\xb5\xdc\x2b\xb5\x91\xf0\x56\xd7\x20\xe4\xc3\xb3\xdc\xbc\x61\x48\x00\x66\xe4\x40\x34\xed\xc6\x30\x98\xa4\x24\xd6\x6a\x21\x61\x1a\x9f\x66\x6a\xc2\x34\xba\x24\xe3\x55\xde\xb8\xc1\x93\x6e\x0a\x82\xe7\x03\x9b\x5c\xa5\x60\x50\x5e\xd2\x5c\x46\xec\x38\x59\x05\x5b\x88\x8b\xdd\x62\x71\xb1\x53\x2c\x2e\x76\x0b\xc5\xc5\xae\x2e\x2e\x5e\xa1\x51\x9d\x1b\x04\x5b\x97\x1d\xae\x45\x42\x35\x07\x7c\xb5\xe1\xba\xbd\xd2\x70\xdd\xbe\xc8\x70\xed\xb2\x0c\x07\xc6\x00\x3c\x4f\xa4\x5d\xf1\x30\xcd\x8c\x99\xee\x41\xa3\x8f\xf1\xdb\xac\x02\x37\x88\x73\xa6\x54\x53\x35\x80\x3a\xb8\x8d\xbd\x3d\x73\x46\xb5\x1d\xd6\x68\x7f\x71\xf0\xfc\x83\x88\x22\x5e\x74\x54\x60\xd9\x31\x02\x5d\xea\x90\x69\x14\x3c\x26\xb6\x55\xa0\xc2\xdb\xfb\x02\x7a\x19\xe4\x55\xa0\x9e\x07\x71\x85\x53\x11\x66\x96\xf3\xeb\xd1\x25\x48\xfe\xac\xc8\xf6\xf3\x05\x67\x7d\x41\xc7\x9a\x56\xf0\x31\xe2\x6b\xd1\x67\xff\xf6\xdf\xfe\xf2\xf7\xfe\xe8\xd3\x1f\xfd\xe8\x93\x1f\x7c\xeb\xd9\xf7\x7f\xfc\xec\x77\x7e\xf8\xe9\xcf\xff\xfb\xb3\xbf\xfe\xcf\x18\x4f\x03\xad\x41\x6e\xc3\xdd\x33\xff\x76\xed\x8e\xdb\xf0\xf4\x63\x72\x62\x7d\x1a\xce\xa7\xdc\x50\xfc\xe9\x3f\xfe\xee\xd3\x6f\xff\xc5\xd3\x6f\xfe\xac\x28\xdb\x2c\x26\xfd\x00\x03\xb0\x7e\xf2\x3f\xff\xf1\xe9\x4f\xff\x4b\xa1\xeb\xc0\xb3\xef\xff\x98\x15\xd7\x96\x86\x0c\xa3\x70\x3e\x55\x92\x5b\xc1\xba\x1a\x9d\xcc\x6b\xe9\xa3\xa8\x86\xb7\x25\xb0\x6d\xba\x70\x3e\x6d\xa4\xd1\x7d\x51\x9f\x25\x6b\xb6\x0d\x63\xff\xd3\xdf\xfa\xf3\x67\xbf\xff\xd7\x8c\x96\xcf\xfe\xf0\x47\x4f\xbf\xf7\x5f\x3e\xfe\xc9\x4f\x9f\xfd\xaf\x1f\x7e\xf2\x1b\x1f\x7d\xf2\x3f\xfe\xe1\xe9\x9f\xfe\x3b\x73\x71\x6f\xd0\xce\xa4\x9a\xa0\x88\x5c\x75\x33\x70\xcf\xfe\xf0\x47\x19\x70\x4d\x51\xb7\xe9\x8d\xfe\xf1\x4f\xbe\xf9\xf1\x4f\xff\xf8\xe9\xb7\xff\xfb\x27\xbf\xf7\x5f\x3f\xf9\xc1\xb7\x3e\xfd\xc5\xf7\x3e\xf9\xe1\x1f\x3c\xfb\xfd\x8f\x9e\xfd\xcd\xf7\xd7\xf2\x1e\xbf\x6b\x85\xfe\x94\xd9\x70\x8c\x9c\x10\xe6\xc1\xc2\xe6\xaf\x5b\xdd\x5a\xfd\xe0\xb6\xfd\xfe\x60\xfd\xfd\xc6\xfb\x83\xda\xbf\x68\x36\x52\x92\xb0\x9c\x6b\x00\x06\x7d\x3e\xfd\xf7\x7f\xff\xf4\xbb\xbf\xcf\x7a\xf7\x93\x1f\x7c\xeb\xe3\x9f\xff\xce\xb3\xef\xff\x18\x09\xf7\xed\xbf\xfb\xf8\x27\x7f\xfd\xc9\x3f\xfc\x5f\x4f\x7f\xf4\xd1\xd3\x6f\xfe\xec\xe9\xff\xf8\xd3\x8f\x7f\xfa\xef\x9f\x7e\xe7\xa7\xbf\xfc\x83\xbf\xed\xba\x0d\xcf\x01\xcf\xfe\xa7\x9f\x7d\x07\x9e\xfe\xe3\x1f\x3c\xfd\xad\x1f\x7f\xf2\x83\x6f\x3d\xfd\xe6\xcf\x3e\xfe\xc9\x4f\xf1\x3c\x67\x59\x21\xd7\x63\x1b\xf8\xff\xf4\xb3\xef\xc8\x62\xac\xc2\x8f\x7f\xf2\x53\xa8\x7b\x4b\xcb\xb2\xc2\x6e\x69\xe9\x56\x99\x95\x86\x19\xbd\x25\xff\xaa\x8e\x94\x46\x17\xd9\x68\xd3\xec\x91\xdf\xd4\x14\x5c\xee\xf7\x92\xa2\xfd\xd9\x4c\x24\x12\xcd\x9e\x5e\xb2\x13\x28\xb3\x7a\x39\x7b\xb8\xfc\xa4\xed\xd5\xc9\xa8\xf8\x7e\x2f\xb1\x85\x13\x09\x8f\x92\x6f\x33\x33\xac\x69\xb8\x53\x41\xb4\x44\x6f\xff\xf0\x3f\x52\xa6\x13\xbd\xfd\xf4\xc7\xdf\x7d\xf6\xfd\x1f\x7f\xf2\x1b\x1f\x3d\xfd\xde\xbf\x37\x3a\x3f\x47\x44\x9f\x13\x90\x12\xff\xbb\x3f\xfa\xf4\x5f\xff\x9c\x8e\xa2\xef\xff\xed\xb3\xef\xff\xf8\x9f\x7e\xf6\x9d\x8f\x3f\xfa\x33\x95\x88\x63\x41\x80\xc9\x91\x1a\x4a\x89\xcd\x26\x6d\x8d\xe6\xbe\xa2\x77\x92\xe2\x66\x0d\xdc\x86\x6a\x15\x6a\xe0\x43\x1b\xaa\x55\xa1\x77\x25\xfd\x80\x84\x69\x30\x0c\xfa\x10\x46\x2c\x7e\x97\x30\x46\xa7\xb1\xbc\x40\xb6\x4a\xaa\xb6\xb1\x17\xa1\x07\x33\xa7\x9d\x88\xa2\xe5\x5e\x98\x62\x29\x76\x4d\x6f\xae\x7c\x0d\x95\x0c\x4a\x6d\x11\x56\x8a\xc5\x06\x3d\x85\x0e\x60\xb1\xd9\x24\x48\xad\x6a\xa3\x6a\xba\x91\xc4\xa7\xba\x04\xa4\x32\xee\xb4\xeb\x89\x7b\x8e\xd9\x0e\x92\xec\xa1\x8f\x3f\xfa\xc3\x67\x7f\xf3\x7d\x26\x1c\xfe\xe9\x67\xdf\xf9\xf4\x2f\xff\xf3\xd3\xdf\xfc\x9b\x8f\x7f\xfa\x9b\x8f\x12\x96\xf6\xc9\x0f\xbe\xc5\xa4\xf4\x2f\xff\xe0\x87\xbf\xfc\x4f\x7f\x58\xd2\x59\x9f\xfe\xa7\xff\x46\x01\x95\x74\x66\x0f\xb4\x8f\x39\x1f\x31\xf8\xe4\x2f\x7f\x94\x39\xc0\x2c\xbd\x68\x1c\xe8\xe9\x41\x83\xd2\xd7\xa1\x03\x92\x70\x16\xeb\x1c\xbb\xc1\xc3\x9d\x51\x42\x38\x50\xad\x32\x92\xed\xab\x52\x9f\xcf\x97\xea\x9d\x53\x4a\x28\x8d\x65\x9c\x52\x2b\xfe\xd2\x33\x3a\x02\x11\x5e\x67\x18\x64\x5c\xb0\xfa\x72\x97\x58\xcc\x1b\xff\xf6\xff\xbe\x9a\x7e\xa0\x80\x4a\xfb\x41\xfb\x98\xef\x87\xa7\xff\xe1\x3b\x99\xf9\x76\x3e\xcd\x74\x41\x4e\x97\x2e\xa1\x8f\x53\x46\x1e\x46\x1f\x03\x4c\x96\x24\x6a\x62\xd1\xf9\x80\x7d\x85\x9a\x62\x8e\x9e\x48\xa4\xa2\xa9\xcf\xb6\x25\x14\x39\xff\xcd\x77\xaf\x88\x9c\xff\xe6\xbb\x4b\xc8\xa9\x3e\x16\x90\xf3\xef\x7f\x98\x61\x6b\xdc\xa2\x50\x04\x55\xf7\x43\xd0\xc4\x7a\x4f\x67\x87\x5f\xfe\xd1\x9f\x5f\x0d\xfe\x14\x50\x29\xfe\xda\xc7\x82\x61\xf9\x0f\xbf\xfb\xec\x4f\xff\xc4\x6c\x02\xdf\xf5\xcc\x30\x85\x5f\x3e\x50\xe4\x78\xea\x95\xe5\xe9\xe9\x23\xf5\x25\x8c\xef\xcc\xf0\x6c\x32\x00\xeb\x19\x5e\xec\xd1\x35\x9f\x6f\x9b\xb6\x05\xbe\xcb\x6a\xb6\x7e\x1a\x0d\xf4\xb9\x99\x4b\x00\x3a\x1d\xf4\x8a\xdc\x4d\x7d\x73\x6d\x1a\x66\xa6\x5c\x1f\x9a\x14\x62\x76\x2d\xc7\xf8\x46\xb2\xfe\x34\x1a\x38\xb4\xac\xa9\x7a\x3e\xfb\xce\x6f\x7f\xf2\xed\xbf\x7c\xfa\xc7\x3f\x7d\xfa\xc3\x1f\x50\x7d\xfe\xaf\xff\xe2\x97\xdf\xff\x05\xd3\xb7\xba\x49\xea\xc7\xa9\x03\x24\x1c\xd8\x9f\xfe\xe2\x8f\x3e\xfe\xc9\x5f\x31\x45\x47\xaa\xfd\x38\x66\x3e\xfa\xbb\x8f\x7f\xf2\x7b\xbf\xfc\x93\x6f\x7e\xfa\x5f\xfe\xd5\xd3\x3f\xff\xd6\x27\xdf\xa3\xdc\x86\x13\x38\x63\xb5\x4f\x7e\xf0\x2d\xc9\x6d\x85\x0c\x85\x95\xc0\xa7\xff\xeb\xef\x3f\xf9\x8d\x8f\x0a\x33\x90\x70\x80\x8c\xf5\x5b\x9f\xfc\xc6\x47\x74\x1e\xff\xc9\xef\x3c\xfd\xce\xb7\x9f\x7e\xef\xbf\x7d\xfa\xa3\xcc\x5a\x41\x87\x49\x66\x00\xac\x2d\x4b\x7c\xf8\x3e\xfd\x77\x7f\xf1\xf4\xa3\xff\x59\xb4\x68\x50\xcb\x69\x45\x03\xbe\x78\x96\x7d\x18\x62\x28\x14\xfc\x9e\xd3\xaa\x78\x78\x52\x1e\x12\x8e\xe6\xbc\x89\x64\x34\xf4\x26\x76\xb4\x9c\xea\xbb\xdc\x07\x8d\x43\x9c\x4f\x69\xa2\xe6\x4f\xb6\x54\x5b\x7a\xfa\xa3\x8f\x58\x0b\x3e\xfd\xc5\x1f\x7f\xfa\x1f\xbf\xf3\xc9\x4f\x7f\xf1\xec\x9b\x7f\xf9\xec\xbb\xff\x81\xb5\xa9\x64\x8c\xc3\xd3\x1f\xfe\xe0\xe3\x8f\x7e\xfb\xe9\x9f\xfd\x19\xed\xcc\x3f\xfd\x57\x65\xb4\xef\xad\x9c\x33\x05\xe8\xba\x0e\x78\x07\x4f\x7f\xf3\xdb\x34\xe7\x9f\x7d\x8f\xf2\x4b\x46\x99\x55\x72\x42\x81\xcd\xe7\x67\x51\xee\x71\x5f\x73\x16\x4d\xfc\x94\xb0\x62\x19\x0b\xe6\x3c\x8e\x4f\x75\x7b\x25\x1d\x60\x0e\x68\xf6\xb9\x90\x9c\x50\xc9\x50\xf3\xf7\x55\x02\x1d\xf4\xb5\x9e\x3e\x4e\x30\x57\x0d\x30\x9e\x1d\x66\xa8\x63\x12\x1d\x23\xf6\xbe\xa0\xb1\x4e\x54\xca\xd0\xdf\xfc\x4d\x26\x50\xcb\x09\xbc\x32\x7d\x57\xcc\xb8\x80\xa7\xdf\xfd\xd1\xc7\xff\xf0\x17\x9f\xfe\xf0\xcf\xa9\xfe\xfa\x87\x3f\x62\xc8\x70\x95\xf8\x27\xdf\xfc\xf8\x27\x7f\x45\x17\x82\xff\xe6\xa7\xe5\x24\x7f\xfa\xf3\xdf\x5d\x3c\xfd\x93\xff\x0a\x3e\xfc\x9f\xd0\x63\xe3\xf9\xd3\xef\xfc\xeb\xa7\x7f\xfc\xb7\x4f\x7f\xf3\xdb\xcf\xfe\xe0\xef\xe8\x84\xf1\x8b\xdf\x7b\xfa\xc7\x7f\x2a\x97\x35\xac\x3f\x65\x87\xcc\xc3\xcb\x75\xc9\x42\x75\xc9\x20\x18\x0e\xa1\x03\x54\x4e\xd2\x6e\x59\x03\x91\x82\x3f\x4f\x9e\xc0\xbd\x70\x18\x84\x41\x7a\xaa\xf7\x90\xb5\x80\x3a\xf8\x74\xbe\xa6\xb9\x56\xea\x17\xba\x00\x40\xb9\xf4\xec\x4f\x7e\xfb\xd9\x6f\xfd\xd5\xb3\xdf\xff\x6b\x4a\xdd\xdf\xfd\x9d\x8f\x7f\xfe\x27\xbf\xea\x5d\xc6\x44\xf0\xf2\x2e\xfb\xa7\x9f\x7d\x07\x25\xc3\xcf\x7f\x77\x41\xa5\x65\x11\x00\x56\xfa\xe3\x9f\xfd\x80\x91\xe7\xe9\x6f\xfd\x98\xe5\x01\x3d\x53\x71\xd7\xbf\x17\xcf\x43\x16\x8d\xf1\xa5\x74\xbf\xd4\x1a\x5d\xee\x10\x3f\x0d\x42\xcb\x73\x32\x6c\x61\xf3\x01\x2b\x03\x9f\x70\xc3\x28\x74\x98\xd6\x24\xe4\x79\x5b\x3d\x3a\x6b\x20\xcc\x13\x6d\xf1\xc0\xe3\xc5\x28\x4d\xa3\x6d\xbe\x8a\xef\x59\x85\xa4\x5d\x98\xea\xd0\x66\x24\xf3\x69\x9b\xfe\x43\x8b\xe2\xa4\xdc\x66\x3f\xf8\xce\xe7\xe6\xb6\x7c\x72\x90\x28\x54\x5f\x6a\xf3\x5f\xcc\x87\x3a\x44\x9b\xff\xd2\x14\xb4\x6a\xb5\xd9\x0f\x56\x93\x1b\x9b\xed\x7c\x12\x2d\x58\x30\x8a\xdb\x45\x89\xb9\xbc\xaa\xdb\xdb\x65\x1f\xd6\xce\xf2\xb6\xce\xa5\x57\xb1\x28\x5b\x23\xef\xb6\xc3\xc3\x55\xed\x9e\xcd\x75\x18\xfb\xf1\x34\x0a\x4f\xb9\xc5\x14\xac\x60\x3a\x9d\x63\x1c\x4d\x1b\xd6\x9b\x45\xb0\xbb\x15\xbf\x72\x80\x41\x94\xc3\xc1\x65\x21\xf4\x10\xc2\x2c\x0a\xe8\xca\x41\x03\x11\x4c\x11\xc4\x7a\x93\xed\x9d\x1c\x7e\xed\xee\xe7\xef\xbf\x7e\xe7\x4b\x87\xf7\xde\xba\xff\xce\xbb\xef\xdd\x7d\xe3\xf0\xad\x77\xde\xf8\xca\x97\xef\x1e\xba\x87\x83\x8d\x43\x8c\x95\x75\x78\x58\x62\x6d\xdd\xdc\xb1\x2f\x05\xda\x3b\x3c\x8c\xe2\x41\x10\xfa\x93\x52\xd0\x1b\x3b\xe8\xf0\xbe\xa6\x87\xc2\x0e\x07\x96\x66\xc4\xe8\xfb\xe8\xea\xc7\x03\xba\xac\x56\x19\xa5\x2b\x34\xd7\xc5\x79\x4e\x58\x6f\x1e\xd8\x96\xdd\x98\x87\x47\x61\x74\x12\x5a\xd2\x72\x2a\xf7\x77\x06\xc2\x94\x8e\xd5\x35\xd8\xab\x16\x68\x97\x82\x7d\x97\x8e\x53\x99\x05\x47\xad\x0c\x1d\xcf\x3f\x31\x69\xa7\xbb\x39\x88\x67\xda\xaa\x93\x60\xa0\xa2\xf7\xc6\xd1\x3c\x94\x91\x84\x44\xe2\xcc\x1f\x0c\x82\x70\x74\x2f\x0c\x71\x2a\x73\x33\xe9\xef\xcc\x53\x33\xdd\x9f\x04\x23\x8a\xb5\xdb\xd8\x62\xd2\x8b\xe0\x55\xc3\x0c\x43\xde\x5a\xfc\xa0\xf4\x48\x82\x1f\x2d\xfd\xe8\x04\x85\xc0\x5a\x6c\xd9\x99\x18\xc3\x54\xe8\xe1\x5e\x0b\x74\x58\x23\xbb\xde\x01\xdc\xe4\x8f\x6a\xe3\x0b\xb8\xd2\x2c\x32\x89\x42\x75\x30\xf3\x44\x33\x05\x07\xea\x02\x36\x8f\xe7\xcb\xf7\xae\x2c\xcc\x56\x67\x10\xa5\xbd\x8e\xca\x5b\xcf\x81\x10\xea\x26\x91\x6a\x26\x6d\xd6\xa5\x9b\x2a\x3f\x31\x47\x55\x5c\xfd\x48\x06\x5b\x9f\x68\x07\x23\x18\xe2\xb5\x4c\xbd\xf8\x4b\x66\xa8\x83\x65\xaa\xb4\x6d\x58\x67\x84\xe7\xfe\x83\xa2\x67\x51\xf7\x66\x65\xbc\x6c\x99\x02\x9c\x18\xbd\x10\x29\x4c\x63\x8a\xbd\xed\x18\x00\xb5\xcf\x32\xd9\xde\xd7\xa3\xa7\xb2\x9d\xa6\x73\x47\x87\x3e\xca\xbb\x15\x82\xa3\x83\x71\x2d\x8e\x8d\xd0\x6e\x4c\xfd\x99\xa5\x5d\x32\xaa\x05\x4d\x62\x14\x12\x8d\x0b\xf6\xb3\xf7\x81\xe8\xe3\xc3\x12\x5d\x7f\x5b\x44\x1a\xe7\x09\x96\xda\xa5\x53\x4b\x08\x7d\xb4\x69\xb1\xba\xac\xc3\xec\x72\x33\xbb\x27\x72\x1b\x2c\xce\xb1\x87\xb6\xa3\x98\x9a\xd6\x21\x38\x79\x9f\x39\x2c\xca\x5a\xc4\x18\xbd\x50\x25\x72\x60\xd7\x0e\x29\xbb\x43\xed\xb0\xeb\x1d\x1c\x64\x6a\xc4\x4c\xdc\xf8\x59\x5c\xed\xbb\x62\xb0\x97\xd5\x5d\x5a\x0f\x2f\xc8\x2e\xb1\x96\xb5\x66\x2b\xd1\x59\x46\xd6\x91\xa9\x42\xe6\xc9\x16\xe6\xc3\xa3\xac\x9c\xf4\xac\xd0\x1b\x75\x5e\x7b\x0a\x69\xc9\x0b\x5d\xbf\x7e\x98\x25\x20\xfd\x92\xad\x83\x8f\x9f\x8b\xd6\x92\x11\xa1\x19\xc9\x59\xa6\xbb\x1d\xda\x59\x36\xd2\xe1\x94\xa0\x26\xea\x78\x1e\xfc\xae\x14\x21\xd1\xca\xcb\x20\x74\x69\x0a\x61\xc1\x2c\x42\x62\x62\xba\x10\x26\xa2\xd0\xea\x28\x48\x31\xac\xd7\xdd\x8f\x66\xa7\xe7\x8c\x03\xcb\x96\x93\x12\x97\x3e\x42\x9c\xd8\xda\x97\x98\x09\x34\x74\x23\xd2\x52\x51\x1a\x33\x31\xae\x52\xf5\xde\x31\xfa\x38\x9f\x07\x09\x66\x90\x5d\xcb\x83\x2d\x62\x94\xd0\x46\xb9\x32\xb5\x88\xf1\xaf\x1b\xf4\x50\xf7\x0b\x92\x31\xf3\xc0\xd7\xcd\xdc\x48\x08\x45\x95\xc2\xd1\x95\xe7\xa0\xfd\xac\x26\x91\x65\xbd\xa2\x8f\xbc\xe4\xaa\xbd\x20\x71\xa6\xf9\x2c\x3b\xdf\x56\x84\x52\xd0\x4e\xcb\xb0\x3a\x4b\x30\xac\x57\xcd\x6e\xf0\xb8\x61\x31\xbb\x02\x58\x7a\xaf\xdd\xd5\xac\x00\x56\x57\xbe\x0f\x67\x7e\x10\x27\xe5\xfa\xf1\x36\xd3\x8f\x9b\xeb\x30\x0f\xe7\x09\x19\xc8\x2a\x84\x6e\xcb\x97\x0a\xa2\x2a\x96\x4b\x42\xe2\xb9\x78\x63\xa8\x7a\x65\x5e\x46\x94\xb8\xfc\xea\xcc\xc4\xa3\x63\x6b\x30\xef\x6b\x0c\x14\xba\xe2\x20\x6e\xe2\x66\x14\xc3\xd0\x93\x9f\xbc\xcc\x27\xa9\x94\x84\xe4\x84\x87\x3a\x09\x5d\x58\x87\xd0\x93\xea\x76\x20\x35\xd8\x40\x5e\x9d\x11\x18\xe5\xd5\x06\x30\x43\x0a\x78\x1c\x75\x1b\xc4\xfb\x4a\x54\x15\x0b\x01\xfa\x4a\x35\x1d\xa6\x0c\x47\x31\x58\x01\x6d\x1b\x86\x65\xd9\x87\xc0\x85\x9b\x10\xba\xfb\x50\xab\x05\xd2\xd2\xcd\x63\xb7\x50\x5c\x14\x15\xba\x01\x9d\x9d\x03\x8f\x97\xf3\x68\x39\x0f\xcb\x79\x0e\xfd\x57\x9d\xa8\x65\x05\x58\xec\x16\x86\x32\x07\x26\xe9\xdd\x0d\xbc\x03\xe3\x62\x0a\xc5\xd6\xd2\x9b\xc9\xce\xc7\x20\xde\x5e\x7a\x35\xd9\xf3\xb1\xef\x55\xb3\x58\x6e\x97\xa8\x07\x37\x71\x43\x1a\xaf\xe5\xe8\xc1\x2d\x7c\xe1\xcf\x6c\xab\xda\x85\x36\xbc\xed\xbf\x5d\xd2\xf6\xa5\x37\x55\xbd\xf4\xa1\xbb\x7c\xd5\xbc\xb1\xbd\x75\xe9\x65\x73\x2f\x48\x48\x3f\x2d\x07\x8d\x91\x9c\x2f\x01\xba\x75\x78\xd8\x8f\x30\x46\x69\x39\xf0\xdd\xcb\xe2\xbd\x71\x78\x48\x16\x29\x59\x02\x7a\x63\x7b\xf3\x72\xa0\x37\x0f\x0f\x45\x1c\xef\x25\x78\x6f\x5f\x0e\xf8\xd6\xe1\x21\x4e\xf2\x4b\xd0\xbe\x24\xe4\xed\xc3\x43\xf4\x68\x5d\x02\xf9\x92\xa6\x95\x9d\xc3\xc3\x74\x1c\x93\x64\x1c\x4d\x06\x87\x49\x3a\x8f\x47\x64\x59\x2d\xbb\xcc\xc8\xc2\xfe\x5e\xc0\x40\x57\x73\x86\xb8\x94\x7a\xc5\xbe\x2c\xb0\xd4\xe4\x6c\x32\x2b\x71\xdc\x12\x40\x92\x50\x4b\x61\x15\x53\xb4\x00\xac\x69\x50\x19\x07\x49\x1a\x8d\x62\x7f\x6a\x0d\xfc\xd4\xd7\xcd\x2a\x81\xb2\x7c\xa0\x85\xc5\x4f\xb3\x37\x38\x01\x2c\x8c\xfb\x48\x72\xd3\xa6\xd8\x87\x63\x33\x16\x9f\x74\xe8\x9c\xb3\x5f\x3e\xd9\xe0\x33\x22\xd3\x0d\xe8\x5c\xe5\x60\xcd\x72\xa2\x91\xe8\x2d\x1e\x2b\xb3\x0f\x5f\x97\x6b\x78\xd1\x39\x6f\xf1\xd8\x30\xf1\x2c\x3c\x96\xe6\x69\x69\x29\x05\x22\xc9\xc6\xe1\x38\xb0\x70\x1d\x58\xc8\x48\x16\xcd\x26\xdc\x89\xc2\x63\x12\xcb\x80\x1a\xd1\x50\x15\x4a\x20\x08\xf1\xb0\x77\x30\x8c\xe2\xa9\x96\xde\x90\x36\x93\xeb\x66\x74\xb5\xf4\xb1\x76\x7f\x39\x62\x70\xae\xf9\x43\x0d\xc4\x6e\xa5\x8f\x1d\x4a\x5f\xf1\x24\x13\xda\x3f\x18\xc2\x0e\xa4\x8f\xe5\x15\xe2\xab\x01\x56\xb2\xa3\xd0\xe6\xa8\x8e\x0b\x2f\x5c\x68\x52\xf0\xb0\x0e\xe9\x63\x47\x37\x46\x2d\x3c\xe3\x0b\x45\x81\x87\x10\x9b\xcc\x93\xe0\x98\xe8\x1d\x87\x71\x3a\xa6\xd1\x31\x01\x3f\x3c\xd5\x69\x18\xcd\x53\x79\xdc\x9c\x75\x6a\x43\xf6\xf4\x94\xf6\xd1\x63\x79\x33\x18\x4d\xe6\xfb\xc0\x29\xed\x61\xb8\xd9\x81\x85\x6b\xd3\x2c\xc9\x38\x18\xa6\x96\xed\x40\xbd\x3e\xcd\x66\x9c\x42\x1d\xbc\x03\xb8\x45\x3b\x96\xe6\x9d\x45\x33\x99\x53\x56\xd5\x0b\x42\x93\x85\xa7\xcc\xfb\x4b\x32\x4c\x2f\x08\x15\x57\xdc\x63\xd7\xfd\x07\x8f\x09\x16\x6c\x14\xf1\x7a\x07\xa6\x19\x66\xef\xa1\x50\xa0\x05\x18\xc3\x77\xe5\x7d\x60\xbd\x20\x6c\x2c\x98\x5e\xc7\x0e\xf1\xa6\x8f\xbb\x01\x43\xbb\x0d\x0b\xd7\xc8\xe6\x61\xb6\x9b\x30\xe5\xd9\x30\x8b\xb7\x9f\x21\xf6\xeb\x49\x42\xd7\xa4\x74\x04\xe1\x81\x50\xda\xbc\xde\xa9\x38\xa2\x1a\x8c\xc2\x28\xa6\xab\x28\xda\x19\x65\x3d\x70\xde\xd8\x5d\x48\xed\xb2\x1b\xc8\x96\x50\xae\x5f\xb8\xd8\x33\x70\xe3\x06\x2c\xf0\xc9\xb8\x9e\x1f\xdb\xbf\x8a\x51\x5c\xa8\x12\x85\xfc\x49\x19\x6e\xe1\x80\xeb\xc0\xd4\x3e\x60\xdb\xff\x5c\x72\x64\xaf\xd2\x5f\x33\xd6\xd0\x41\x98\x48\x23\x9e\x94\x80\x0d\x21\xfb\x2f\xb4\xea\x17\x85\xd2\xd3\x19\x89\x86\x70\x88\xbe\x9e\x15\x01\xa2\x02\xb7\xe1\x10\xda\xe7\x0f\x44\x43\xb3\x29\x6c\xeb\xa1\xed\x28\x5c\xa5\x35\x52\x2d\x3c\x55\x3b\x9e\xc7\x20\xf9\x32\x5a\xd2\x65\x46\x42\xb4\x11\x66\x1b\x35\x50\xd7\x42\x64\x5a\xa5\x49\x8b\x0b\xb6\x4c\x9f\x40\x97\x37\xce\x14\xd4\x87\x36\xdc\xbe\x92\x9e\x5b\x41\x09\xef\x56\x7a\x58\x10\xcd\xb0\xb4\x58\xa3\xef\x4f\x26\xd6\x21\xda\x89\x5e\x04\xf7\x48\xa2\xe4\x4c\x17\x32\x5b\xc9\x22\x66\xe9\xad\xa8\x57\xb3\x88\xc9\x2b\x74\x4b\x76\x1f\x15\x12\x0b\x63\xb1\x56\x66\xbb\x59\xf0\x16\x17\x36\x6e\xe9\x55\x7b\xaf\x50\xe3\x16\x25\xf8\x2f\xbd\x9a\xea\x9f\xd1\x0a\x53\x5e\x42\x58\xbe\x9e\xf2\x2e\xbd\xc6\x64\x6a\x5e\x29\x64\xcf\xbd\xe4\x32\x70\xe3\xf0\xf0\x83\xb9\x1f\xa6\xc1\xa4\x7c\xb1\xd6\xf2\xb6\xc4\x62\xe7\x85\x19\xcd\x1c\x19\xc3\xc2\x56\x07\x98\x92\xf3\x6c\x52\x52\x52\x31\xf1\x32\xf5\x67\x4a\x4e\x09\xb8\x2b\x91\xb5\x48\x40\xb1\xeb\x9f\x57\xed\xf2\x22\x08\xfb\x19\x17\x17\x33\xca\x0d\x3b\x35\xd8\x82\x75\xb0\xce\x95\xa6\x46\x37\x15\x4a\x53\xd1\x5c\xb7\xb1\xb3\x65\x43\xfd\x7c\x01\x7d\x11\x90\xad\x2d\xdc\xa3\x95\xae\xb0\x7c\x23\x92\xaf\xbd\xa0\x4e\xf5\xed\x0d\x5b\x3a\xe8\x64\x25\xc0\xd2\x3b\xbe\x5e\xba\x04\x18\x90\xe3\x00\x7d\x59\x96\x48\x81\xd6\x8b\x35\x11\x67\xb9\xfd\x3c\x26\xd9\x68\x6c\xc1\xfa\x2a\x5b\xd2\x7a\xe3\x96\xf4\xe9\xf3\x74\xe6\xd2\x5b\xb0\x5e\x2d\x63\xa9\x20\x36\xfe\x46\x5a\x30\xeb\x50\xae\x10\x32\xf6\x83\xc0\xb8\x7b\xda\xb8\xdf\x54\xc4\xa2\x96\x47\xa8\xa2\xa1\x32\xa1\x7f\xa8\x2f\xed\x6a\x35\x5c\x95\xd8\xf0\x21\xbb\x17\x99\x07\xf6\x1d\x06\x71\x92\xf2\xbb\x1c\xf1\x6a\x23\x71\xf3\x9f\x5c\x9f\x48\xcd\x5d\xae\x5e\x6c\xb8\xce\xaa\xd0\xae\x19\xe5\x9f\xf5\xa5\x0b\x3b\x23\x2d\xb5\x6f\xf6\x57\x88\x0d\xbf\x49\x97\x05\x09\x26\x54\xb1\x35\xae\x30\x97\x7f\xab\xa3\xa3\xc7\xe0\x5e\x8a\x8f\xba\x86\x5a\x3d\x9d\x99\xc6\x7a\xed\xdc\xd9\xd5\xd2\x32\x1a\x5a\xb2\x11\x68\xc1\xe1\xe3\xe0\x15\xa2\xef\x45\x50\xbc\x4a\x9a\x8b\xc3\x04\x7e\x89\xfe\xb6\xb3\xf4\x28\xf3\x4b\x97\xde\x2b\x29\x42\x2f\x54\x74\xaf\x2e\x4d\xa6\xd0\x81\x70\x05\xd1\x92\xe0\xa1\x00\xf7\xc2\xe2\x45\x63\xf7\xeb\x41\xf2\xb6\xff\xb6\xe4\xa8\x55\xa6\x8a\x65\xba\x8f\x62\x45\xdb\xb6\x11\xbf\x5a\x86\xb7\x70\xa8\x4a\xa3\xd6\x4a\x23\xf8\x45\xa3\x5b\x3a\x82\x2e\xd6\x04\x0c\x1e\x69\x6b\xa7\xb0\xa0\x09\x25\x0b\xcf\x9d\x97\xe0\xfa\x7a\x91\xb5\xcd\x0b\x5b\x81\x78\x2f\x6e\x05\xd2\xba\xd0\x0a\xe4\x95\x18\xd7\x4b\x86\x32\xa3\x52\xa2\xce\x07\xbd\xa4\xf1\xec\x5d\x64\x3c\xab\x89\x83\xa3\xcb\xec\x94\x7a\xf4\xe8\x0b\x4d\xcd\x2f\x1a\xef\x65\x03\xfb\x32\x6d\xe1\x43\x7b\x15\x1b\xd6\x39\x4b\x24\x51\xe7\x39\x4b\x45\xf7\xdc\xa5\x22\x5d\x65\x6d\x95\xa8\xdc\x3b\x2f\xd0\xbd\xe6\xca\xfd\x13\xe8\x8a\x3c\x31\xc7\x10\x4b\xcb\xce\x8d\xc5\x83\xe9\x91\xee\x8c\x3d\x25\xf1\x88\x0c\xa4\x6b\x36\x05\xa3\x9f\xb9\x93\x0c\xf8\x88\x8a\x76\x56\x4b\x37\x38\xd0\xb6\x65\x18\x00\x63\xfb\xe4\x91\xad\x83\xa8\xd7\x43\xe3\x30\xbe\xcf\xef\xb8\xe5\xc0\x42\xbe\x7d\x30\x15\x49\x45\x5b\x3e\xf5\xfa\xd4\x80\x21\xaa\xed\xd6\xeb\x8f\x0e\x44\xc1\xee\xf4\xa0\xd8\x31\x85\xe5\x2d\xe9\xf8\x5f\x25\xc7\x14\x7e\x37\x78\x38\x20\x0b\xa2\x5f\x75\x00\x1d\x91\x28\x97\x98\x33\x12\x4f\xf1\xaa\x77\xbd\x63\x02\x1c\xad\x9c\xa6\x41\xbd\x6e\xcb\x6c\xf2\xba\x26\xff\xb4\xcb\x41\x75\x83\x83\x03\xcd\xba\x22\x72\x96\x90\xf1\x15\xf3\x71\x59\x6d\x96\x7e\xa1\x73\x1d\x5b\x39\x11\x75\x15\xce\x75\x2b\x37\xdb\xd9\x42\x07\x92\x87\x2b\xf5\x21\xeb\x16\x8e\xd8\x85\xdc\xa2\x5f\x3c\x52\x0b\xc7\x47\x7a\xa4\x2e\xb6\x3e\x92\x53\xa1\x4c\x58\x99\x68\x65\x0e\x04\xc5\xd3\x92\x56\xa9\xb5\x08\xf4\xc5\xac\x03\x8b\x47\x36\xdc\x04\x17\x9e\x3c\x01\x99\xe5\x11\x4b\xbe\xde\x31\x46\x34\xb6\x66\x11\x38\xd8\xda\xa0\x40\x61\xcc\x96\xe7\xe1\x55\x38\x7f\x3e\x2a\x61\xcc\x17\xb8\x6f\xf1\xa2\xc6\xb7\xeb\x40\xe0\x69\xa7\xdc\x69\xa6\xc0\x13\xfd\x89\x41\x45\x94\x9c\x84\x36\x66\xae\x0b\xe7\x40\x57\xcb\xe7\x42\x1b\x6a\x81\x2b\x77\xb2\x53\xc9\x5d\x7a\x6f\x4e\x65\x3f\xca\xb3\x1b\x7e\x38\x88\xa6\x96\x0d\xeb\x30\xad\xd7\xe1\x09\xf0\x5d\xe8\x54\x89\x5a\xa8\x41\xe0\x72\x79\x6b\x24\x29\x31\x92\xcf\x12\xc8\x2c\x69\xf6\x40\x36\x9f\x79\x0a\xbb\xf0\x05\xee\xce\xbc\xd2\x8a\xee\x15\xac\x59\x85\x92\x58\xd3\xec\x4b\xc6\x3a\x0d\x9a\x4d\x78\x3b\x4a\x49\x1b\x1e\x93\x38\xc2\xcb\xa7\x90\x79\xa8\xbc\xa0\xa4\x3b\xf6\x27\x24\x4c\x1b\x97\x52\x54\xcd\xca\xcb\x8d\x2f\xf9\x85\x63\x76\x06\x4f\xe6\x65\xab\xc3\x57\x6b\xe7\x2b\x8d\xfd\x30\x99\x45\xc9\x12\xaf\xbc\x1d\xf7\x45\x4d\x3c\x86\x9d\x7b\x95\xe5\xbe\x86\x6d\xa1\xe6\x2d\x77\xd5\xcb\x94\xe6\x57\x6b\xd3\x21\x89\xfb\x87\x21\x49\x96\xf8\x88\xee\x70\x07\xd4\x0c\xe5\x63\xc2\xa9\x49\x4b\xb3\x26\x5d\x66\xf5\x4e\xeb\x4f\xc8\x92\xea\x77\xdd\xe5\xd5\x27\xe4\xb2\xb5\xb7\x58\xed\x53\x7f\xb6\x64\x7d\x9f\x71\x07\x95\xd5\x5a\xbd\x00\xa7\xfd\xcc\x69\x5d\x59\xb4\x31\xb0\x0a\xfb\xb2\xe2\x57\x1c\x63\xbb\x5d\xde\x03\xb4\x12\x9e\xb8\xd7\xcd\x8e\xe5\x5d\x6e\x53\x95\x42\x3a\x22\xa7\xe5\x1e\xa4\xbb\xc2\x14\x53\x46\x70\x5a\xfa\x92\x14\xdf\x64\xf5\x33\x19\xb6\x04\x83\xd6\x72\x0c\xf8\x1e\xec\xe5\x70\xd8\x62\x38\x90\x30\x8d\x83\xa5\x48\x6c\x2c\x47\x82\x03\xc0\x8b\x72\xa5\xb7\xad\x31\xd0\x5f\xe0\x86\xd4\x25\x06\xfa\xf9\x6c\xfe\x82\xdd\x85\x91\x6f\x3a\xd0\x55\x87\xa6\xa3\x38\xfd\x52\x51\x22\x8b\x64\xaa\x8e\x4f\x4f\x26\x73\x79\xba\x9a\x4a\x1b\xd3\x2d\xd7\x9f\x61\xc4\x2d\xa6\x06\x0e\xc8\x8c\x2e\xe4\xfa\x78\x31\xd9\xbb\x18\xaf\xc6\xa1\x22\x82\x3d\xea\xba\x37\xe6\xa4\xeb\x63\x8a\x97\x58\x59\x18\x33\xb1\x42\x45\xec\x74\xd8\x5c\x89\x44\xab\x8a\xfa\x2c\xcd\x39\xe2\xf0\x16\x62\x2c\xb7\x47\x6e\xf3\x04\x86\x23\x1e\x66\x63\x7a\x1b\x98\x6e\xba\xa6\x52\x03\xca\x44\x91\xf3\x25\x3e\x22\xa7\xc0\x10\xef\x62\x33\x6a\xb5\x03\xe3\xe3\x57\x75\x85\x28\xa3\x1f\x09\x17\x86\xcf\x9f\x7e\x09\xa1\xac\x32\xe7\x49\xd1\x93\x3f\x69\x9f\x05\xab\x1f\x27\xe7\x01\x89\xf4\xce\xb0\x84\xa7\xf0\xb9\x2a\x50\x22\x75\x3f\xc4\xb4\x31\x22\xa9\x25\x9a\xc6\x1a\x2f\x55\x25\xae\x27\x1f\xd8\x50\x83\x4a\xc5\xb0\xbd\x71\xed\xb1\xc8\xf4\xa6\x2b\x64\x19\xb2\x34\x12\xad\x32\x07\xef\xe3\x9d\x93\x12\x3f\x49\xbd\x18\xf1\xfb\xe3\xbc\x5a\x7b\x44\x4e\x15\x4a\x92\x17\xad\x98\x73\xe7\x11\x39\x75\x38\x13\x8b\x12\xe7\x70\xb1\xf0\xf0\x16\xb4\xcc\x84\x67\xe2\xa8\xc9\x01\xc2\x25\x95\x35\xf5\x67\x1c\xb4\x3e\x0e\x6a\x35\x3e\x12\xcc\x81\x20\x77\xdf\x66\xea\x0c\x3a\x1f\x63\x7c\xdc\x42\x47\x8e\x60\xc6\x85\xe8\x7e\xab\x1f\x7f\x37\x46\xc1\x8d\x1b\x50\x3c\xe4\x84\x69\x6b\xea\xcf\x1a\x02\x55\xde\x42\xec\x21\xf1\xbd\x7b\xe0\xb0\x3c\x26\x91\x1d\x38\xe2\xd7\x67\xfb\xa7\xac\x9f\x3f\x3c\x22\xa7\x6d\x38\x12\xba\x72\x5b\x12\xe0\x58\x34\xff\xcc\xce\x9d\x6c\x17\x8d\xba\x9e\x59\x2f\xe2\x50\xcf\x9e\x72\xca\x14\xb2\xfc\x06\x76\x62\x8f\xfe\x20\x68\x7d\x8c\x9f\x19\x11\x9f\x12\x11\x16\x06\x20\xc2\x91\xd7\x06\x73\x29\xab\x81\x37\x24\x9b\x2b\xf8\x81\x0d\x58\xe4\x07\xf6\x48\x6b\x64\xc3\x6e\xea\xcf\x2e\x0c\xee\x2d\xca\x15\x09\x49\xdf\xf2\x67\x0a\x10\xa7\xd8\x12\x60\x82\xa6\xe7\x03\xc5\x28\xe3\x02\x30\x76\x8d\x04\x3a\xa0\x00\x91\x19\x98\x3f\xb2\xbd\xaf\x13\x4a\x16\x12\x6c\xa6\x95\xc4\x4b\x86\x69\x69\xc9\x82\x1a\x4f\x31\x3f\xf0\x0e\xbb\x89\xb8\x1c\xe4\x57\x39\x7b\x14\x03\x95\xa1\xbd\x97\x40\x61\x2c\xae\x41\x18\x22\x85\x18\xe3\x77\x60\x98\x2d\xa5\x39\x53\xaa\xeb\xfa\xb4\x4e\x35\x57\x23\x1f\x9e\x99\x87\x62\x65\x87\x5b\x11\x67\x01\xe4\x3a\xcd\x29\x80\xa5\x53\x52\x1c\xa8\x2d\xf7\xb3\x5c\x65\x6f\xf9\xb3\x8b\xaf\x7b\x96\xcc\x01\x39\x34\x69\x05\x28\x6d\xb2\x08\xd2\xf1\xcb\x65\xab\x48\x2f\x3a\xb7\xbb\xfb\x6a\x6d\xed\xaf\xa2\x3a\xc9\xe6\x3f\x20\xd8\x8d\x3c\x3a\xfd\x2c\x8e\xd2\xe8\x3c\x1b\x62\x19\x69\x1b\x58\x3a\x3d\x9d\x91\xfd\xb5\xb5\x07\x24\x55\xef\x54\xf6\x66\xde\x3f\xc4\x30\xa5\x61\x92\xc6\xf3\x7e\x1a\xc5\x6d\x8a\x08\xe5\xd2\xb1\x9f\xb4\x19\x1a\x8d\xb1\x8f\xd3\xb3\x3f\x18\x68\x2c\x6b\xf8\x94\xb0\x19\xb5\xd6\x81\x4a\x85\x1b\xaf\xc6\x41\xd2\x5d\x05\x79\xe6\x92\x3d\x8b\xc9\x30\x58\x50\xdc\xa1\xc6\x80\x1d\x98\xbe\x1f\xb1\xb8\x7a\x36\x60\xa7\x0a\x1c\x64\xc2\x69\x74\x4c\x04\x92\xec\x8d\xa6\xf7\x27\xc4\x8f\x45\x32\xbe\x38\xd2\x01\x53\x24\xd3\x51\x8f\x31\xa9\x82\xc7\x12\x02\x7d\xa6\x69\x64\x3a\x4b\x4f\x45\x22\xbe\x60\xaa\xdf\x1f\xcb\x44\xbf\x3f\xc6\xc0\x51\x3a\xf3\xca\xd1\xa5\x19\xa2\xe8\x22\x93\xed\x09\x3c\x20\xa9\x88\xab\x7c\x27\x9a\x9d\xea\x24\x6f\x70\x8b\x13\x2b\x0f\x01\x3a\x99\xf7\x49\x34\xa4\x85\x6c\x3e\x38\x8b\x74\x04\x14\x39\x24\x6d\xf8\x83\x81\x50\x52\xc4\xe4\xde\x6c\xc2\x3b\xe9\x98\xc4\x27\x41\x42\x1c\xf0\x93\x64\x3e\x25\x10\xa4\xff\xfb\x9b\x7f\x94\x80\xcf\x0d\x80\x0d\x61\x5c\x52\x95\x1b\x87\xd3\x98\x5a\x89\xea\x24\xc7\x41\xdf\x2c\xa2\x85\x34\xeb\x58\x56\x2f\x13\x78\x71\xd1\x22\x4f\x8b\x60\x85\x65\x99\x87\x2a\x3b\x1a\xad\x38\x52\xb9\x80\x92\x09\x49\x79\x3c\xd0\xab\x5a\x77\x24\x24\x2d\xb0\xb9\xec\xbe\x40\x77\x88\xab\x5e\x30\x4d\xfd\x59\xc1\x9a\x69\x7f\x4d\x1e\x53\xc7\x54\x08\x50\x37\xb3\xb5\xd9\x13\x75\x0f\x45\x5b\xfa\xa1\xd8\x02\xb5\xfb\x2b\xb4\x6d\x6b\x50\x43\xae\x0b\x96\xd0\x43\x57\xf8\xa7\xfe\x0c\xe7\x42\x9d\x2c\xcb\xce\xdb\xef\xfe\x0a\x6d\x6b\x1a\x84\x11\xb6\x88\xa5\x94\xe1\x99\x0c\x1d\x59\x4e\xc3\x6d\x10\xc4\x3a\xd3\xa9\xc5\xcb\x94\x90\xeb\x25\x6c\x5f\x5e\x38\xbe\x9e\x38\x6f\xfc\x62\x8e\x61\x6c\x5f\xf2\x30\xbe\x77\x78\x38\x09\x42\xe2\x2f\x73\x53\xba\xe4\x01\x8f\xf3\xcf\x60\x6c\xec\xba\xdc\x49\x49\x5d\x8d\xc1\xa9\xa4\x99\x67\xe4\x99\x36\x16\xd9\xce\xb4\xb1\xb0\x60\x34\xd9\xdb\x8b\x6a\x8b\x4c\x78\xaf\x80\x1d\xfd\xed\x88\x90\x2e\xf9\xb8\x5f\xcf\x11\xa0\x6b\x85\x43\xe2\xe7\x9c\xbc\x38\x7c\x8e\x43\x17\x0e\xf0\x90\x3b\xe2\xdc\x5d\x59\x14\xb0\x73\xa2\xe1\x28\xca\x9b\xe1\x88\xf2\x61\x71\x56\x71\x51\x12\x4c\x25\xf4\x2f\xf6\x1e\x24\x63\xa6\x99\x33\x94\x0b\x35\xec\x97\x70\x32\xed\xc2\x63\x77\xe2\xf7\x8a\x64\x25\x87\xf3\x65\xbf\x97\x31\xf9\x5e\x38\x74\xe6\xb8\x3f\x59\x52\xc1\x17\xfb\x93\x4b\xda\x94\xf1\x7c\xc3\x30\x08\x97\x39\x0a\x5e\x5e\x72\xf4\xa3\x49\x54\x3e\xba\x5b\xde\xee\xa5\x05\xc7\xd4\x4f\xc7\x4b\x36\xdd\x5a\x5c\x6c\x50\x38\x5f\xa2\x23\xcf\xdb\x65\xeb\xde\xaf\xb3\x48\x94\x7b\x5b\xee\xe6\x8e\xeb\x50\x25\xf5\x8d\xed\x2d\xc0\xfb\xdb\xfd\x78\x00\x31\x19\x92\x98\x84\x29\xe6\xfd\x06\x16\x64\xe5\xfe\x25\x3e\x37\xdc\xdd\xdd\xdd\x0d\xee\x9a\x91\xba\xd0\x81\x4d\x68\x42\x6b\x8f\x27\x78\xd0\x81\x6d\x3d\xa1\x05\x1d\xd8\x80\x75\xfa\x85\xfe\xc3\x53\x37\xa0\x23\x52\xf0\x1f\x5d\x8b\x9f\xf8\x3d\x1e\x86\xc0\x8a\x94\x2b\x49\xa4\xab\xe4\x5f\xf6\x7b\xb6\x16\x87\x9b\xbe\x5b\x51\x63\xe2\x40\xd4\xf0\xe9\x3f\x3d\xfa\x4f\x34\xf3\xfb\x41\xca\xd4\xaa\x1c\x84\x2f\xf6\x27\xba\x9a\x3d\xa6\xea\x75\x63\x0c\xeb\xab\x90\x5c\x49\x98\x51\x2b\xf6\x07\xcc\x55\x44\x93\x12\x06\x46\xec\xf4\x4d\x94\x58\x63\x1b\xd6\x21\x6a\xf4\x79\x52\x12\x84\x5a\x92\x89\xed\x99\x74\x9f\x31\x70\x5e\x85\xcf\x84\x2c\x79\x77\xd4\x43\x29\x62\x43\xb4\xa2\xc3\xa4\x04\x30\x66\x41\x27\x47\xa2\x17\x98\x34\x8a\xe4\x15\x08\x3d\xe8\xd0\xaf\xad\xc5\xe9\x63\x2b\x6a\xc4\xd2\x88\xec\x1b\xe9\x23\x99\x3e\x31\xd2\x7b\x32\x7d\x01\x1d\x58\x9c\x3e\x6e\x4d\xfc\x9e\x65\xb9\x8d\x4d\xaf\xb5\xb9\xb5\xbd\x09\xeb\xd0\xc3\xcb\x5c\x37\xb6\x76\xb6\x76\xb6\x29\x7b\xf8\xec\x72\xd7\x5d\x77\x73\x63\x67\x0b\xd6\x61\x62\x43\x13\xbe\x1e\x4a\x40\xa7\x26\xa0\x96\xd7\xda\xde\x69\xed\x49\x40\x3b\xde\x96\xb7\xd5\x6a\x49\x40\xee\x4e\xcb\xdb\xd9\x72\x05\xa0\x6f\x28\x40\x8f\x4d\x40\xae\xb7\xb7\xb1\xb1\xa1\x00\x79\xde\x9e\xb7\xd7\x72\x25\xa0\xbd\x2d\x77\xc3\xdd\xf4\x04\xa0\x7f\x19\xea\xca\x97\x60\x02\xcf\xdb\x86\x75\x38\x85\x3a\x78\xdb\x0e\x6c\xb9\xb4\x38\x46\xa0\x3e\xb5\x1d\x68\xb1\x57\xfa\xf5\xb1\x6d\x72\xc1\x99\x39\x22\xac\x89\x03\x2c\x2c\xb6\xc8\xa2\x9b\x80\x72\x33\x6e\xa7\xd3\xc1\xbb\x78\xb4\xb1\x34\xa1\xb3\x9f\xc0\x2a\x0b\x4d\xf3\xa0\xf1\xa0\x0d\xc5\x68\x14\x15\x64\x68\xa4\xe3\x20\x69\xd0\x7e\xae\x4d\xf6\xc5\xab\x2f\x43\xe8\xe3\x6b\x8f\x07\xd0\xe7\xaf\xb2\x5e\xa8\xf1\x47\xac\x6b\xb5\xc3\x68\x4c\x58\x17\x9a\xb3\xbe\xec\xf7\x1c\xda\x6a\x67\xc5\x73\x6d\x02\x14\x1b\x35\x18\xa4\x66\x70\xde\x61\x76\x7d\xb0\x30\x14\xee\xd0\x57\x0c\x65\x83\xe4\xe8\xc5\xc1\x68\x9c\x92\x58\x33\xd4\x1c\x65\x34\x09\xd1\x11\x9c\x72\x35\x2a\xa2\xd7\xc1\x3a\xca\x74\xc4\x91\xed\x70\x6a\xf2\xdf\x9e\x63\xd0\xcf\x96\x76\x98\x81\x1f\x1f\x5d\xa4\xc6\xfa\x73\xd7\x18\x8f\x7a\xed\xbc\xa6\x44\x25\x04\xed\x56\xd5\x32\x6f\x9b\x8e\x0e\xcf\xdb\xd6\x42\xd4\x50\x5d\x1f\x5d\xba\x59\x55\x36\xdc\x86\x53\x68\xc3\x29\xd4\x04\xf3\x34\xe9\x58\x51\x25\x1e\x9b\x25\x7a\xaa\x44\x5d\xf0\x57\x93\x0e\x27\x26\x88\x29\x02\xdf\xa0\xcd\x9b\xf8\x4c\xee\x9c\x72\xc3\x07\xad\xf8\xeb\xfa\x87\x05\xff\x40\xe1\xff\x4b\xfd\xc3\x63\x3b\x27\xd3\x2f\x21\x7f\x2d\x21\xeb\x4e\x1f\xb7\xe2\x51\xcf\x82\x8d\x46\x6b\xd3\xdd\xdc\xda\xa4\xe2\x88\x4a\x01\xaf\xb1\xb5\xb1\xe3\x6d\x50\x8d\x0e\xdb\xe2\x36\x36\xf7\x76\xb7\x36\x3c\x2a\x07\xa9\x48\xe0\xb3\x73\xfd\x16\x24\xef\x7e\xe1\xf3\x19\x68\x75\xb7\xb1\xb7\xbd\xd7\xda\xde\x76\x11\x5a\x0d\xbc\xc6\xee\xce\xb6\xeb\xb9\xbb\x08\x0d\x85\xdd\xa6\xb7\xb5\x85\xdf\x1f\x2b\xc1\x2b\x90\x71\x1b\xee\xd6\xd6\xf6\xe6\xc6\x26\x47\xc6\x6d\xb4\xdc\x4d\xb7\xb5\xb5\xc7\x8b\x7b\x0d\x77\x6b\xa7\xd5\xda\x6a\x19\xc5\x75\x6e\xc0\x24\x3e\x67\x9d\xd9\x86\x69\x5c\x08\xd2\xd4\x90\x54\x29\xdc\xa2\xb3\xff\x6d\x75\x50\x34\x75\x80\x9d\x0d\x85\x36\xa4\xd0\xa4\x1a\x43\x0d\x52\x37\x27\x01\xb1\x57\x0a\x80\x51\x31\x97\x52\x25\x02\xff\x6f\xd3\xf2\xeb\x60\xa5\x94\x2f\xdc\x8c\x00\x13\x0d\x37\xcf\xc7\xb6\xb6\xb6\x98\x4c\xbe\x49\xd5\x22\xd7\xdd\xf0\x36\xdc\x5d\x3a\x1a\x5a\x8d\x3d\xd6\x4d\x6d\xa4\xc4\x96\x7e\xbc\x75\xc1\xb0\x6e\x35\x36\x6d\x24\x9c\xbb\xb5\x95\xa9\x4c\x4c\x79\x66\x65\xd6\x02\x9a\x1d\x5a\xa5\xcd\xab\xa3\xdc\x00\xb7\x61\x41\x87\x08\x56\xd8\x56\x95\x58\xec\x5a\x73\x0a\x9b\x7e\xa6\x0f\x0e\x56\x69\xd6\x34\xee\x4f\xce\x53\x98\x50\xdd\xd1\x58\xf9\x8b\xfd\x89\x15\x35\xc6\x8e\xd0\x3e\x26\x45\x0a\xd3\xf5\xbc\xd2\xc5\xd4\x09\x43\x43\x13\x6a\x81\x0c\x83\xed\xa7\x7e\xd8\xb2\xb8\x12\xe6\xdb\xab\xea\x54\x3d\x1e\xeb\x7a\xd0\x1a\x90\x91\xd0\xa9\x32\x28\x8f\xd1\xb1\xf6\x36\x8c\xa1\x06\x1b\xdb\x2e\xb4\x61\x2c\xd4\xa9\x0f\x28\x32\x0d\x1f\x15\x2a\x3a\x3d\x47\x8d\x1e\x3e\xf7\xec\x82\xf6\x65\xa8\x67\x8d\x1d\xe8\x3b\x30\xb9\xe0\xe4\xaa\xd1\x7d\x2c\x26\xd7\x2f\x16\x40\x5b\x69\x72\x2d\x2a\xa8\x4d\xae\x94\xba\xb5\xb1\x9c\x3e\xfb\xf4\xb5\xbf\x5f\x32\xf5\xbe\xa8\xc9\xf5\x8b\xfd\x89\x43\x5b\xfd\xab\x30\xb9\x52\x7a\x32\xca\xf1\xf9\xab\xef\xc0\xaa\x93\xed\xe5\x26\xd7\x25\x35\x9e\x3b\xd9\xae\x38\xb9\xf2\xda\xb4\xf1\x47\x4b\xdb\x0d\x2a\xd4\x0c\x29\x9c\x35\x18\xbc\x84\x68\x2f\x17\x36\x18\xf4\xe7\x3d\x32\x26\x93\x60\xb1\x64\x55\x7f\x47\xe4\xf9\x6c\x6d\x5f\xb6\xb6\x7f\x1d\x3a\x50\x77\x1b\xde\xe6\xee\x36\x5f\x5d\xe3\x5d\x55\x5e\x63\x67\xb7\xb5\xb3\xc3\x52\xee\xb0\x3c\xad\xbd\x56\x8b\xa7\xbc\xc1\x52\xf6\xdc\xed\x4d\xbe\x52\xbf\xcb\x4a\xed\xed\xb4\xf6\x36\x79\x0a\xcd\x74\x17\xd6\xe1\x0d\xfe\xfe\x79\xfe\xfe\x79\x5e\xcf\x9d\xc3\x37\x68\xed\x9f\x87\x75\xb8\x03\x75\x78\x03\xd6\xe1\x75\x63\x77\x5c\xf4\xde\x79\xd3\x93\xec\x66\x63\x92\x92\xa9\x62\xaa\x4a\x56\x9d\xaa\x5e\x91\x95\x72\x8c\x56\x85\x98\xea\x09\x5b\x5b\x42\x7d\x1a\x61\xe2\xc8\x4c\xec\x61\x62\xcf\x4c\xa4\x52\xdd\x62\x44\x66\x4b\xd0\xbb\x94\xc2\x31\xd4\x69\x4f\xac\xc3\x08\x83\x78\xb0\xef\xf8\x8d\xa6\x4b\x2d\xad\x37\xe1\x17\x26\x4d\x44\xca\x11\x05\x47\xbb\xcf\x1a\xd1\x64\xaa\xb7\xdc\xa1\x80\x71\xf1\xfa\x86\x74\xe1\x13\xd3\x38\xce\xa8\x47\xb0\x0e\x47\x50\xa3\xd0\x44\x4e\x04\x31\x11\xb7\x67\x4c\x6c\xa6\xa4\xbe\xed\xbf\x4d\x3b\x62\xd2\x71\x21\x8a\x61\xd2\xf1\x38\x38\xbc\x6d\x43\xa8\x7b\x4c\x33\x38\x72\x10\xd2\x65\xd5\x02\xaa\x34\xb7\x64\xf4\x61\x28\x66\x98\x42\x45\x21\x61\x73\x6b\x89\x1e\xd0\x57\x85\x65\xd6\x8b\x68\x03\x39\x66\x97\x3a\xc1\x9d\x52\xc8\x2b\x69\x06\xe5\xc5\xcb\xf5\x03\xda\x8b\xb5\xe4\x65\xeb\x07\x12\x53\x47\x51\xe3\x95\xd5\x15\xe8\x70\xd0\xe7\xe3\xd5\xaa\x61\x41\x49\x05\x5c\xe4\x47\x4d\x61\xbf\x2c\x0c\x07\x8e\xf2\xcb\x4d\xd5\xef\x86\x56\x91\x48\xad\x62\x1d\x8e\x2e\xae\xb0\x5c\xae\xd9\x03\xd6\xd9\x08\xf5\x72\x8d\xce\x42\xb8\xf2\x26\x97\x9b\x23\xc6\xa6\xed\x60\x6c\xf3\x73\x62\xfc\x95\x2e\x74\x5b\xee\xca\x02\x29\x67\xfb\x55\x46\x0a\x1c\x66\x0c\x53\x95\xe8\x9b\xb5\x27\xa2\x76\x3e\x4e\x0d\x59\xaa\x4a\xf5\xa3\x44\x2e\xa8\x98\xf5\x58\xbb\x9f\x29\x08\xe5\x37\x66\x46\xbe\x4a\x53\x05\x5f\x0e\x4f\xf0\x26\xf2\x75\xb0\xe8\xe4\x83\xd8\xd4\x70\xa2\xa7\x95\xdb\x12\x99\x6c\xe6\x3b\x2a\xf3\x1b\xe7\x66\xbe\xcb\x33\xdb\x2b\x9a\x16\xb2\x4a\xed\x4b\x38\x08\x75\xc9\x10\x86\xb9\x78\xfa\xcc\x18\xea\xd0\x09\xb9\x03\xbe\x76\x86\x24\xcd\xa8\xf6\xda\x45\x52\x74\x15\x4b\xd7\xb0\xa9\xbd\x24\x8e\xe3\xee\x0b\x3c\x90\x54\xac\x92\x1b\x17\xf8\xf9\x61\x32\x8c\xe2\xe9\x9d\x44\x1c\xe8\x58\xbd\xcc\x83\xe3\xd1\xe5\x95\xfa\xf3\xc2\x86\x3c\xc7\x4d\x78\x78\xb5\xf3\x92\x93\x25\x7b\x99\x7b\xf0\x8a\xda\xc6\xae\xdb\x77\x60\xb6\xb8\x13\x4d\xa7\x3e\x7d\xb8\xef\xc7\x24\x74\xa8\xdc\xc0\x27\xa4\xb8\xb6\x47\x3f\x8b\x66\x56\x92\xe1\x05\x6d\xff\x3c\x61\x61\x9c\xa1\x06\x15\xa8\x40\x9b\x7b\xf8\x99\x9e\xe2\x78\xb6\x8d\xa2\x61\x2d\x7c\x07\x4e\x7d\x07\x16\x3d\x07\x4e\x7b\xa8\x34\x7c\xa0\x7b\x8d\x2f\x7c\x3c\x89\xbc\xe8\xc1\x93\x27\x70\xca\x5e\x4e\x7b\x7a\x98\x72\xe6\x78\xc6\xdd\x4d\x2a\x0a\x72\xc5\xc1\x79\x43\x6b\x99\x78\x65\xad\x12\x4e\xf6\x1f\x70\x47\x95\xa0\x0d\x01\xd4\x61\xd3\x81\xc5\x0a\xd1\x5d\xcf\x8b\xc7\xb3\xc0\x36\xd9\x67\x0e\x08\xc0\xad\xab\x01\x4c\x89\x75\xda\xb3\x85\x57\xf9\x99\xf2\xc8\xe3\x34\xd2\x88\x53\x40\x14\xa8\x51\x5a\xd6\x04\x51\xa0\x06\xa7\xec\x55\x27\xca\x59\xae\xc3\xe2\x28\xa5\xc5\xd9\x7e\x4a\xb6\x8f\x58\xaf\xf4\xcc\xb3\x15\x3e\xd4\xf1\x36\x0e\x6f\xd7\xb5\xe9\x8a\xa0\x43\x95\xdb\x7d\x85\x2d\xd5\xf7\x7d\xf1\xdd\x97\xdf\x9b\x4d\x48\xc6\x51\x9c\x92\x24\x85\x99\x9f\x8e\xf3\x9d\xc4\x1b\xc5\xb9\xb0\x06\x15\x8e\x9b\xec\x6f\xc5\xb7\x57\x46\x74\x14\x92\x05\x24\xcf\xd3\x3a\x8f\x16\x8a\xc6\x9a\xc2\xaa\x8c\xc4\xc9\x11\x39\xf9\xfa\xaa\x14\x5e\x46\x0f\x06\xe8\x55\x23\x07\xc7\x6a\x65\x6a\x30\x47\xa0\xab\x95\x0e\x1a\x36\x08\x5e\xd2\xa8\xe2\xa8\x47\xbb\xf2\xcf\x52\x34\x5c\xc7\xb5\x1f\x0a\x08\xf6\xbc\xac\xaf\x18\x75\x84\xac\xa8\x38\x15\x21\x27\x14\x75\xb2\x87\xc0\x0b\x14\x0a\xee\xd2\xcc\x8f\xd4\xd0\x91\x9d\x62\x68\x7b\x11\x16\x3b\xc1\x03\xed\xb3\x89\xdf\x27\xe3\x68\x32\x20\x71\x22\xf5\xc6\x0f\x98\x8b\x21\x2d\xc4\xef\x77\x50\x73\x57\xc4\xf3\xf9\x78\x17\x5f\x9c\x10\xcb\xb7\x1d\x34\x4b\xb0\xb7\x1e\xc7\x50\x49\x3d\xbf\x21\x9f\xbf\xee\x80\xf6\xf6\x0d\x07\x7a\xc6\xb7\x9e\xf1\x0d\xd9\x8d\x2b\xac\x5c\x00\x36\xd8\x03\xcd\x29\x9e\xb4\x5c\x7c\x0c\x37\xf0\x97\xe6\xe1\x0f\x7a\x16\xa4\xad\xdf\xc0\x5f\xc4\x06\x9f\x10\x13\x91\xd6\x93\x69\x5a\x41\x1f\x8d\x24\x6c\x31\x84\x84\x19\xf5\xf5\x19\x38\xaf\xa6\xe5\xbd\xb2\x3f\x90\x01\x68\x22\xc1\xe2\x39\xcf\xea\xae\x15\xd1\x9c\xdd\xe0\xc0\x6e\x60\xd8\x99\xa8\xb1\xb0\xd2\xec\xc9\xc3\xa4\xf1\x28\x0a\x42\xab\x22\xb9\x41\xe8\x7d\x6b\xd9\x7b\xed\x0d\xc5\xab\x53\xac\x82\xac\xa2\xe4\xa8\x6b\xb7\xe2\x84\x30\x25\xee\xc0\x81\xca\x6c\x41\x47\x2f\xfd\xb5\xe9\xcf\x80\x8c\x90\x43\xcb\x90\xa0\x9a\xdc\x73\x21\xd1\x53\x48\x30\xad\xf0\x80\xd5\x8f\x82\x43\x48\x8f\x9c\xe6\xfb\x12\x4e\xe8\x5e\xd8\xa6\x2d\x08\xf9\x9c\x97\x44\x73\x4a\x5c\x3e\x16\x71\x3f\x9a\x2e\x8d\xc9\xb0\xbb\xc7\xbc\x4a\xf1\xfa\xc1\x24\x79\x3b\x1a\xf0\x23\xa6\xfd\x24\x79\x37\x8a\x52\xf9\xf2\xd5\x80\x9c\xf0\x43\x57\xc7\x23\x9a\x4d\xb7\xef\x8a\xd6\xea\xc7\x50\xb4\x28\x18\x9d\x0e\x54\xc2\x28\x24\x15\xfb\xfc\x63\xf2\x26\xd6\x82\x25\x84\xbf\xa5\xd8\x0e\x44\x53\x2f\xc7\xd7\x16\x88\xe3\xf5\x38\x7d\x34\xca\x35\xd8\x11\xa9\xbb\x13\x42\xdf\xac\xca\x1b\xf7\xbe\x5a\xb1\x1d\xd1\x28\x3d\xa3\x78\xe0\x59\x1d\xd1\x56\x23\x0f\x9b\x07\x68\x32\xad\x9c\x57\xd7\x48\xd2\xd3\x09\x61\x22\x0d\x6f\xc2\xd1\x8e\xc8\x88\x33\xad\x1c\x58\x63\x44\xd2\x3b\xd1\x74\x36\x4f\xc9\xe0\x01\x2d\x65\x71\x4c\x1a\xfe\x6c\x46\xc2\xc1\x9d\x71\x30\x19\x58\xa2\x3d\x6c\xb2\xb4\x69\xa1\xfb\x71\x34\x23\x71\xca\x8e\xb0\x72\x55\x93\xd6\xc5\x24\x83\x00\xc2\x0e\xdb\x98\x40\x74\x2c\x58\xf4\x5a\xe6\xe9\xba\xe3\x40\xdd\xb3\x1b\xc9\x6c\x12\xa4\x56\xc5\xa9\xe8\xae\x4a\xab\x19\xe8\xb4\xce\x29\x98\x26\x59\xc0\x13\x76\x27\x2e\x7b\xf4\xd4\x63\x4b\x3d\x6e\xa8\xc7\x4d\xf5\xb8\x75\x90\xbd\x2a\x93\x8f\x80\x32\xce\x92\x77\x0c\x5e\x1d\x5b\x71\xfe\xb6\x05\xa3\x97\xb2\xd5\xdb\x0f\xac\xca\x38\x4d\x67\xed\x66\xf3\xe4\xe4\xa4\x71\xb2\xd1\x88\xe2\x51\xb3\xe5\xba\x6e\x33\x39\x1e\x51\x79\x35\x62\xe4\xe5\x80\x1a\x09\x49\x5f\x4f\xd3\x38\xe8\xcd\x53\xa3\x33\xd5\x21\x3a\xb1\x89\x21\x7a\x4e\x94\x94\x79\x1b\x3d\x3f\x21\x5f\xf5\x27\x0d\x3a\xcd\x47\x93\x60\x40\xe7\x4d\xdb\xbe\x32\x0a\x98\x2c\x33\xf5\xd3\x38\x58\x5c\x31\x87\x30\xd0\x3e\x6f\x74\xa3\x27\x1e\xfa\xe2\x61\x20\x1e\x88\x78\x18\x16\x7a\x3f\xef\xbd\x84\xf3\x85\xcf\x1b\x27\xa4\x57\x12\x27\x44\x1e\x70\xc0\x23\x62\xe8\xb9\x4f\x46\x31\xc1\xd3\x1f\xde\xae\x2b\x6e\x51\xbf\x7f\x6f\x9f\xcf\xf9\xa2\x9f\xd8\x11\x41\xa5\x55\xb5\x59\x74\x34\xa5\x58\xf1\x04\xa6\x3f\xf1\x17\x54\x94\xc4\x33\xaa\x41\x6d\xe6\xcc\xcb\x34\xa1\x36\x78\x78\x7e\xee\x6a\xec\x5d\xe8\xbb\x30\x70\x80\x98\x67\xef\xb8\xf6\x25\x75\x2f\x8a\x92\x60\x78\xf6\xd1\xd8\x70\xf2\xb9\x77\x65\x0f\xd6\xa1\x67\xd3\x45\x6c\xb3\x23\x81\xf4\xd4\x8b\x04\x41\xe1\x41\x07\x0d\x8a\x7d\x5e\x6e\x60\x43\x1f\xed\x6c\xb0\x0e\x5c\x57\x1c\xd0\xf7\x9e\x78\x37\xea\xff\x86\x51\x7f\x9f\xc3\x19\x20\x1c\x0a\x48\x54\xf9\x0d\x0a\x45\x7b\x61\x35\xcb\x04\x01\x93\x56\x3a\x80\x9b\x58\x59\xdf\x46\x05\xb3\xee\x33\x4d\xba\xde\x13\xa5\x3a\x50\x17\x4a\xac\x20\x41\x5d\xb5\x4b\x9c\x20\x36\x15\xee\xaf\xb7\x81\xcf\xd1\x7a\xa7\x0f\x1d\x4d\x93\x6e\xeb\xdb\x6c\x3d\x07\xd0\xf9\x86\x33\x98\xa3\x74\x69\x2d\x1b\xa3\x5f\x3e\x1b\x67\x16\x4e\x78\x95\xf6\x0d\x9e\xf6\x8d\x72\x8b\xe4\xde\x8b\x3a\xae\x87\x3b\xaa\xe3\x48\x74\xd7\x83\xff\xe3\xdd\xf7\x5a\xbc\xf5\xe3\xa8\x05\x1d\x50\x6f\x9b\xd0\x01\xbe\x89\x4d\x66\x49\x30\x89\x42\xfa\xdd\x23\x75\xaf\x65\xec\x4f\x47\xc9\x38\xeb\x9f\x65\x2d\x44\x05\x64\x31\xb3\x16\x36\x5d\xbb\x79\xd0\x84\x85\x0d\x4d\x68\x65\x0e\x4b\x07\xe1\x0a\xe5\xeb\xa5\xe5\x53\xff\xbc\xf2\xe8\x7f\xc6\x60\xe0\xde\x2b\x3a\xf9\x31\xa9\xd8\x6c\xc2\xcc\xa5\x2b\xba\xf9\xc2\x75\x60\x7e\xea\x3a\x70\xe2\x1e\x60\xb2\xc7\x92\x3d\x9a\xec\x39\x70\xe2\x1d\xbc\x88\x43\x6c\x33\xd7\x81\x99\x16\xb4\x6f\x8e\x57\xba\xcd\x5c\x54\x02\xe6\xa7\xfc\x85\xaa\x01\x27\xfc\xb9\x25\xf7\x4a\xe6\x78\xaf\xdb\xcc\xe3\x79\xf9\x0b\xe6\xe5\xcf\x2a\xef\x80\x52\x84\x16\xa8\xd3\x2a\x64\x2a\x95\x89\xb4\x64\x1d\xdb\x2e\x52\x69\x3f\x0f\x16\x94\x9f\x29\xa9\x06\xa7\xf4\xe9\x34\x77\x75\xf1\x03\x71\x3c\xf7\xc1\x8c\xf4\x03\x7f\x02\x7d\x3f\x21\x78\xf0\x6e\xee\xc2\xff\xfe\xed\x6f\xc3\xdc\x13\xe7\x81\x07\x2d\xb8\x29\x99\x48\xac\x02\x1f\x88\x3e\x9a\x44\x23\xeb\x84\x76\xef\x89\x4b\xfb\x27\x1e\xf3\x35\x60\xa0\x1f\x22\xd2\x16\x8f\xbc\x97\xbb\x72\x4d\x4e\x89\x56\x43\xdf\xc5\x81\x76\xc7\x24\xa5\x1e\x4f\x3d\x55\xa9\x27\xae\xf0\x40\xa4\xac\x41\x87\x02\xf3\x7a\x7c\x20\xee\x25\xcf\x06\x83\x6d\x36\xe1\x0b\x24\x24\x31\x6f\x60\xc3\x8c\x63\x87\xb3\x8f\x67\x48\xbf\x41\x4b\xbf\x02\x90\xf6\x1a\x6d\xdd\x3a\xed\x94\x3a\xab\xfe\x84\x22\x86\x23\x6c\x1d\x06\x2d\x79\xd7\x0c\x7e\xc3\x61\xb8\x0e\x03\xe3\x1e\x41\xaf\x18\x48\xbd\x08\x88\x57\x02\x24\x76\x75\x7a\x2b\x74\x7b\x14\x58\xcf\xc5\x31\x01\x75\xe8\xb9\x7a\x19\xaf\xa4\x0c\xad\xa4\xe7\xc9\x32\x1e\x5f\x6c\xd3\x2e\xb5\x62\x8a\x62\xbc\x5a\x57\x0a\x33\x0c\xf6\x80\xaa\x97\x6d\xdd\x21\xc6\x28\x5e\x62\x1d\x29\x80\x39\x74\x68\xf3\x9b\x60\xa9\x86\xc2\x3a\x58\xbc\xd0\x3a\x93\x09\xac\x6f\x13\x4a\x6a\x97\x62\x89\x82\x26\x76\xed\xac\xc5\x20\xcb\x47\xf3\x42\x3e\x9a\x17\xf1\x11\xaf\xb0\xc9\xb1\xd4\x2b\x2c\xe1\xa6\xa0\x31\x98\xc7\x78\x0b\x0c\x74\xe0\x01\xac\x83\xe7\xba\xae\x7e\xe6\x2d\x28\x99\x10\x5e\xde\x89\x65\x2e\xa5\xc6\xc9\xe4\xcb\x51\x78\xf9\xed\xa5\xc1\xc6\x39\xae\x5d\x5b\x97\xbc\x67\xf8\x5c\x9f\x31\xcf\xdd\xc9\x6c\x2f\x8d\x93\x89\x35\x16\x4b\xa0\xac\x59\x2a\x49\xfd\x38\x75\x80\x84\x83\xec\x7e\xf7\x78\x4e\x2c\xf6\x79\xb5\x28\x51\xaa\xc9\x62\xab\x7e\x9c\x4c\xf8\x39\x44\x0a\xc5\xb6\x1b\x63\x07\x2c\x12\x0e\x9e\x1b\x1e\xc5\xd6\x6e\x18\x1b\xda\x17\x75\xbc\x2a\x58\x5e\x20\x96\x8d\x04\x89\xd1\xd0\xaf\xc8\x9d\x5c\x19\xf0\x09\x03\xae\x6f\xd3\x2b\x4f\x9a\xab\xa9\x82\xc3\x63\x15\xe9\x2e\x0e\x4b\x4d\x92\xac\x2c\x76\xbb\x66\x55\xe4\x14\xa1\xcb\xc9\x5c\x2a\x25\xca\x24\x97\xaa\x5a\xc3\x9f\x0a\x6c\x94\xc8\x52\x35\x19\x62\xe4\x8c\x6f\xd0\x5f\x65\x18\x08\xca\xf2\x17\xf1\xa4\x19\xcf\x09\xf3\xe0\x63\x3a\xa2\x18\xfd\x1d\x58\x1d\x50\xd1\x2d\x6b\x39\x39\xf6\xf2\x02\x0c\x70\x5a\x28\x7c\x7e\xf5\xe5\xd8\xc4\xef\xe5\xc4\x15\xad\xe4\x2a\x86\xe7\x65\x05\x1d\x61\xc7\xae\xfd\x9e\x29\xe8\x26\x97\x15\x74\x19\x78\x4c\xd0\x4d\x8c\x03\x92\x57\x23\x26\x7c\x26\x20\x7c\x5b\xf7\x1f\xbd\x1a\xd0\x3d\x06\x5a\x1d\xd3\x7c\x69\x22\xae\x54\xc0\x15\x89\x2c\x4e\x07\xba\xf2\xcf\xa4\x51\x52\xf4\x32\x69\xe5\x82\xad\x50\xac\x9d\x15\x9a\x9d\x5e\x60\xc0\x8c\x12\x35\xa6\xff\xcf\x48\x8d\xe9\xbf\x74\x35\x86\x4f\x0e\xfd\xab\x52\x63\x32\xf0\xf2\x6a\x4c\xff\xca\xc6\x48\x9f\x8d\x8e\xfe\x67\x6a\x8c\x48\xa5\xb4\xed\xff\x8a\xa9\x31\xfd\xe7\x53\x63\xfa\x52\x8d\x59\x19\xd0\x4a\x6a\xcc\x4b\x0c\x1e\x72\xd5\x61\xb6\xa5\x57\x39\xa5\xcc\xa5\x03\x69\xbf\x5a\x92\x51\x3b\x77\x90\x91\x8f\x56\x3e\xcf\x17\xfc\xe9\xd4\xb7\x64\x44\x5a\x74\xe1\x3f\xe5\x81\x64\x0b\x20\xe6\x05\xeb\xd5\x88\x56\xb6\x89\xd4\xd7\x0e\x67\x5d\x85\x80\x2d\x84\x9a\x17\xb3\x2f\x78\xbd\xf8\x82\x45\xed\x4b\x15\xb6\x4b\xc5\x6d\x99\xc0\x2d\x5b\x39\x9a\x42\x57\x3f\xbf\x7d\x6a\xe7\x32\x2d\x93\xc1\xa5\x52\x98\xcb\x61\x19\x9d\x59\xb2\x42\x63\x44\xf9\x5e\x3f\x33\x88\x03\xc1\x8c\xa0\xac\x9d\x27\x04\x38\xb3\x2d\x61\x27\xbf\x32\x81\xae\xc6\xd5\x73\x88\x75\x43\x84\xe9\x2d\xba\x4a\x11\xff\x2b\x74\x7d\x8c\xee\x82\xe6\x88\x58\xe2\x68\x5b\xf5\xa7\xb3\x49\xe6\x36\x2f\xe6\xda\x28\x03\xe4\xe1\x8d\x51\xfb\x80\x5e\x56\xfb\x50\xab\x05\xb6\x28\xc5\x2e\xf7\xd2\x61\x5b\x01\x34\xc1\x0a\x71\x27\x45\x5f\x6e\xf0\x02\x25\xa6\xcb\x57\xea\xae\x95\xc1\xc6\x39\x01\xee\x2e\xef\xf5\x3e\xd8\x38\x1c\x46\xf1\xd4\x2f\xbf\xca\x63\x83\x5f\x1f\x76\x05\xbb\xc5\x2c\x66\x9a\x03\xfd\x68\x1e\xa6\x0e\x24\x33\xd2\x0f\x86\x01\x06\x6f\x16\x7d\xcf\xa7\x25\x96\xb3\xeb\xaa\x0b\x06\xd2\x68\xa6\xd2\x79\x2c\x37\x2d\x6e\xb4\xca\x47\x66\x2b\x4f\x40\x32\xea\xdc\x08\xc7\x56\x1a\xf4\x8f\x1e\xd0\xf2\x4a\xc6\x3a\x58\x31\xc7\x58\x3f\xb4\xe7\x42\x9b\x25\x4a\x09\x3f\x8b\x49\x3f\x48\x82\x08\xef\x37\x93\x4d\x5b\x4d\xd8\x6b\xbd\x20\xa4\x07\x7b\x7f\x20\xe1\x30\x9c\x14\x58\x89\x4a\xc5\x19\x56\xa0\xad\x11\x13\xeb\x3f\x09\xd2\xfe\x18\x54\x81\x46\x7a\x3a\x93\xf1\x82\x71\xd3\xab\x92\x54\xda\x86\x6e\x20\x5c\x41\x50\xc0\x4f\xfd\x05\x93\xf4\x7e\x2f\xe1\x13\x3c\x0f\xb8\xc0\x12\xa2\x99\x12\xfd\xb8\xa3\x2e\x2b\x92\x74\x90\x38\xde\xb8\x01\xfc\x1e\x4f\xed\xdb\x85\xc9\x42\x44\xa8\x62\x06\xe1\xbe\x8c\x59\x4c\xbb\x8a\xcc\x84\x4f\x8d\x6d\x43\x21\x2e\x66\xff\x68\xb3\xc7\x45\xf1\xe8\x69\xdd\x63\x20\x21\x6a\xd5\xbd\x7b\xc4\xad\x03\x8c\xe2\x95\xb6\xf6\x42\x8c\xb7\x91\xf1\x36\x33\xde\x62\xad\xa3\x5e\x0e\xad\x87\x26\xad\xdf\x8d\xe6\xe2\x4c\x26\x23\xf5\xca\x2c\xb2\x42\x77\x40\x3d\xcb\xa6\xcc\x81\x90\x28\xcf\xf1\x5e\x4c\xfc\xa3\x3c\x39\x87\x06\x95\x3e\xf7\xd2\xa9\x34\x30\xa9\xf4\x66\xb0\x20\x1a\x95\x9e\xa3\xe9\x9f\xab\xd8\xb0\x0e\xad\x92\xe6\x9f\x5d\x28\xd8\xa4\x81\xb1\xaf\xf1\x6e\x86\x6b\x4b\xee\xbd\xda\x7b\x09\xf7\x5e\xbd\xa8\x45\x23\x6b\x67\x6e\xb5\xf8\xa2\x5c\xbc\x74\x91\x20\x2b\x7d\x31\xf6\xfd\xc3\x49\xd4\xf7\x97\x5c\x70\xbd\xb1\xdb\x92\x5e\xbe\x2c\x2b\xd3\x41\x39\x45\xb4\x67\x8e\xee\xda\x1a\x47\xe9\xcb\x98\xdb\xa2\x03\x69\x40\xfa\xc1\xd4\x9f\xb4\xa1\xd2\xa8\xa0\xcb\xd9\x38\x9a\x27\x7e\x38\x48\xda\x78\xc2\x63\x0d\x60\x14\x47\xf3\x59\x10\x8e\xda\xd0\xdd\xc0\x19\xb8\x3f\x8f\x63\x12\xf6\x4f\xdb\xd0\xad\xfc\x8b\x8a\x03\x95\xca\x41\xe6\xde\x04\xb3\x1a\x3c\xfd\x1d\xd0\x0f\x6c\x6a\x62\xb8\xae\x78\xbd\x8d\xa0\x41\xe1\x0a\x49\x83\xcc\x35\x47\xca\xf2\x1d\x5e\x43\x43\x10\x02\x4c\x41\x9e\xf9\x2e\x88\xa3\xe2\xaf\x70\x5a\x16\x18\x89\x5f\x82\x53\xfa\x25\xb5\x2e\xd1\x4b\x8e\xea\xc1\x62\x6b\x2c\xbb\x70\x08\x4e\x82\x81\xba\x6b\x46\x68\xdb\xcc\x2f\x33\x7b\xa3\x51\x6a\x5c\x02\x95\xb9\xbc\x95\x45\xbc\x10\xb5\x6b\xba\x1c\x80\x88\xa0\xc0\x2f\x7c\x54\xf7\xf4\xc2\x2d\x70\xa9\x74\x1e\xd1\x07\xf3\x08\x1c\x2f\x53\x83\x11\x3a\x66\xdd\x12\x78\x8e\x74\x95\xc5\xe3\xe8\x43\x9d\xd7\x21\xe7\x90\x54\xbb\x4d\xa8\x91\xcc\x7b\xec\xf4\x8c\x15\x40\xbd\x03\x23\x07\x02\x0a\xd8\x54\x69\x64\x8d\x1d\x56\xa5\xad\xea\xd4\x24\x72\xa6\x95\x94\x02\xd6\x23\x96\xfd\x73\x32\x99\x13\xee\xc0\x58\xe4\x8a\x58\x66\x8d\x98\x1c\x93\x38\x21\x96\xcd\x8e\x81\xa8\x5e\x2a\x3f\xfe\xbb\xe7\xbe\x04\x5f\xd8\x4b\xf2\x5b\x38\x9f\x92\xd8\x9f\x2c\x63\xb2\xcc\x79\x57\xd6\x29\x31\xc1\xc3\x4b\x56\xb3\xeb\xd6\xf7\x0e\x9a\x23\x4d\xca\x06\x39\x47\x2a\x51\x49\xb7\x16\x08\xaa\x2e\x25\xd7\x0b\xbc\x4a\xe0\x39\xc9\xb5\x70\x80\xc7\x84\xc7\xb8\xa8\x8d\x34\xba\x2f\xf4\x03\x6b\xc6\xae\x93\x88\xe6\x69\x5b\x2d\x7e\x43\xcc\x26\xce\x1e\x05\x18\xa7\x17\xef\xc2\xc5\x93\x49\x81\x67\xae\x8b\xf9\x4e\x1a\x5f\x0f\x2c\xf0\xbe\x2d\x41\x4b\xa6\x38\x35\x2a\x6d\x56\x3c\xf0\xf0\x36\x62\x93\xbb\x59\x1e\x97\xe6\x19\xb2\x7b\x77\xd9\x55\xc4\xac\xc4\xfe\xb2\x42\xa4\xd2\x66\xc9\xb4\x01\xe2\x13\xa7\x92\x04\x77\x4b\x02\x73\xf7\xf3\x9a\x8e\xe6\x63\x84\x59\xe1\x36\x2c\xf8\xc1\x06\x97\x36\xda\x86\x9a\x4c\x08\xb8\x6f\x57\x1b\x16\x25\x4c\xf0\x02\xfd\x91\x2e\x31\x87\xb3\x39\xe6\x0d\x36\xcb\x96\x07\x93\x6a\xb5\xc4\x25\x7f\x57\xc6\x68\xe8\x00\xb8\xe2\x2c\x9b\xc1\xb2\xf8\x0c\x26\x85\x2c\x0f\x33\x0c\xe4\xe1\x84\x85\x34\xf1\xa1\x01\x2c\x22\xc3\x61\xd0\x0f\x48\x88\x2b\x7c\x6d\x42\xa0\x48\x87\x22\xd9\xd3\xe3\xff\xc9\x2f\x2c\xaa\x4f\xc5\x6d\x54\xa0\xa6\xd9\x85\xea\x22\x03\x97\x9d\x15\xb7\x42\x59\x42\xab\x8a\x57\xd1\xd6\xd3\x84\xe1\xe0\x96\x82\x5f\x63\xa1\x7c\xb4\x3c\x92\xcb\xf4\x3c\x78\xa0\x13\x71\xc8\x67\x35\xf2\x15\x55\x6b\x60\x2e\x73\xd7\x8b\x30\xab\x41\x4b\x6b\x51\x09\x3b\xbf\x40\xb7\x94\xe7\x65\x35\x43\xf6\x97\x0d\xc7\x57\xeb\x1e\x7d\xd1\x21\x4b\x62\x4b\xec\x5d\xd1\x48\xc4\xe5\xa1\x4e\x21\xa9\xbf\xb8\x0e\xd4\x57\x19\x95\x0a\xd9\xc2\x01\xa9\xad\xc2\x71\x21\x5a\xd2\x01\x2f\x61\x43\xf0\xd5\xed\x00\xe3\x86\xb3\x82\x7e\x90\xcf\xf5\x5d\xf1\x12\x84\x96\x78\x1e\x4e\xa2\x28\xb6\xae\xa0\xab\x38\x12\x4d\xd8\xb0\x6d\xba\xea\xdf\x80\xfa\x4a\x72\xf9\x6a\x38\xe0\x25\x84\x87\x7c\x95\x39\x60\xea\x73\x49\xc5\xcd\xc6\x26\xd5\xf0\xbb\x9e\x8a\xd9\xeb\x98\x79\xbf\x98\x69\xae\xa0\xe7\x78\x25\x57\x00\x89\x75\x3d\x9d\x8e\x4a\x7a\xff\x25\x6c\x72\x5c\xfc\x36\x91\xe8\xb2\xa7\x9f\x5f\x81\x5d\x92\xcb\xc5\xfc\x14\x11\x1c\x96\xe8\x80\x97\x04\xbe\x71\x78\x18\x06\xfd\x65\x76\xa2\x4b\xba\x3b\x6c\x22\xd6\x69\x10\xce\xa3\x79\xf9\x6d\xdc\xde\xe6\x2e\x8f\x57\x6a\x58\x80\xb4\x80\x01\xf9\x80\x59\x56\x4f\x3f\xbe\xd1\x83\x26\xf8\xb6\xd0\xa6\x6e\x83\xa1\x61\x18\x03\x90\xe6\x5e\x60\x6e\x68\x42\x6f\x9f\x1b\x8a\xa9\x06\x76\xee\x48\x32\xba\xa0\x70\x24\xf5\xb2\x21\xbe\x97\xb7\xc1\xa7\xea\x6a\x1e\xe7\x54\xc3\xb9\x2e\xb7\xd1\xeb\x3d\x07\x52\x5b\x0f\x31\x5e\xf7\x1d\xf0\xa0\x0e\x78\x45\xac\x6c\x46\x21\x18\x59\x26\x07\x44\x87\x91\x39\x62\x1d\x9d\x78\x6e\x46\x45\x0b\x92\x37\x83\x30\x48\xf1\xb2\xa8\xdb\x50\xb3\x2a\x1e\xc1\x80\x25\xb8\x9a\xe2\xca\xb7\xcb\x57\x56\x26\xa8\x99\xd5\xf3\x13\x73\x16\xa5\x09\x2c\x3a\x26\x2d\x86\xd5\xc9\x56\xc8\x6f\x88\xe8\x5d\x11\x20\x94\x2c\x66\xf9\x86\xe6\xfa\x18\x1b\xea\x27\xc4\x81\x45\xbe\x59\x93\x68\xb4\x0c\x17\xb3\xbe\x49\x34\xca\xa3\xe4\xa1\xe9\x49\x7c\x97\x48\x3f\x79\xa2\xb2\xb4\xf4\x1c\x2d\x95\xc1\x62\x39\x34\xc6\xa5\x88\x38\xe7\xf1\x2b\xf2\xaa\x9f\x10\x66\x2e\x36\x39\x6c\x38\xa1\x5c\x3b\x2c\xb6\xa2\x64\xef\xf4\xaa\x0f\xad\xfa\xc2\x56\x2e\xac\x3a\x55\xac\xcc\xa1\xdc\x55\x16\x7e\x99\xf1\x2d\x76\xbd\x32\x26\x56\x6d\x10\x38\xe6\x98\x90\xd7\x64\x75\x3d\x07\x3c\xf7\x40\xee\x92\x66\xae\x14\xe3\x3b\xc2\x62\xa3\x83\x11\xd1\x93\x26\xc4\x49\x34\x4a\xd8\x9c\x30\xb3\x3c\x75\x9e\x6a\x16\x9d\xd0\x64\xe4\x3e\xcf\xb5\xcd\x4b\xcf\x62\xc2\x82\xc2\x08\x0a\xe9\x30\x78\xaf\xe8\xe5\x31\x89\x1f\xf8\x1a\x8a\xeb\xca\x2c\xbb\xeb\x1e\x50\xb6\xb7\x45\x71\xd1\x1f\xf4\x55\x41\x10\xa9\xf4\x35\xe3\x57\xcc\x0c\xc5\xc6\x3d\x6b\xbc\x79\x17\xba\x3e\x8d\x97\xa9\x1d\x3a\xaa\x61\x36\x67\xda\xfd\xcc\x1d\x66\x92\xb6\x97\xb8\xa0\xcd\x3a\xb4\x33\x35\x08\x4a\x64\x6b\x49\x83\xfe\x51\xa2\x57\xc2\xb6\xc1\xf5\xb3\x85\x72\xa3\x5e\xbf\x68\x7e\x9e\x59\xf4\x03\x1c\x63\xca\xa0\x68\x1b\x1f\x20\xe6\x96\x61\xbc\x93\x1c\x3a\x70\x0c\x37\x61\x6e\xa3\xb9\x6b\xee\x20\xb0\x63\x07\x21\x04\xfb\xe6\x5d\xfc\xb4\x87\xac\xb9\x6d\x1a\xa5\x31\xf1\x58\x4b\x9c\x69\x37\xef\x6b\xf6\x6c\xf3\x1a\xff\xc2\x5d\xff\x1a\xf3\x5e\x90\x19\x1f\xf3\xfb\x1b\x25\xb6\xd7\x59\xa7\x7d\x0e\x3c\x9b\x4a\x8b\x47\x50\x87\xec\x6d\xf9\x42\x52\xb0\x78\x8f\x01\x1e\xf3\x75\x10\x51\x2d\xf9\x11\x57\xdd\x78\x99\x21\x58\x73\x66\x2d\x43\x4b\x20\xb3\xf2\x3d\x32\xac\x7c\xf4\x0f\x3f\x1e\x31\xa3\xe0\x8c\x31\x79\x62\x05\xf6\x3e\x1c\xc1\x4d\x2e\x6b\x6a\xb5\x23\xbd\x04\x33\xe3\xcf\x60\x1d\x8e\xf6\xb5\x44\x5a\x61\xca\x88\xce\x45\x01\xc9\x7f\xbe\x05\xc7\x19\x6b\x38\x92\x84\xd9\xda\x75\xc7\x2f\x31\x8f\xf1\x30\x5a\xab\x35\x01\xe9\x58\x2f\x68\xc9\xad\x0e\x78\xfb\x50\xaf\xff\xbf\xd8\x8e\x35\xad\x35\x02\x87\xc7\x17\xf7\x3c\x19\x4b\xcf\x93\x84\x49\xd5\xc0\x81\x47\xda\x7a\x13\xb9\xc7\x81\xd0\xb6\x1b\x53\x7f\xa6\x0b\x1a\x73\x17\x21\x86\xdb\xf0\x58\xed\x24\x40\x1b\x1e\x17\x0d\xdc\x37\xc5\x3e\x98\x39\x7a\x73\xbe\x38\x99\x2d\x74\x15\x78\x45\x77\x6c\x31\xe7\xf9\x4a\xc3\x25\x18\xa1\xd2\xa9\x28\x71\x9a\x9e\xce\x48\x34\xd4\x4a\x5d\xef\x74\xa0\x22\x2a\xaf\xd8\xcf\xe5\x28\xb3\x7c\x37\x5b\xa0\x20\x06\x71\x07\xee\x85\xb8\x27\x78\x2a\xed\x93\x32\x7b\x3e\x37\x6f\x2e\x7f\x05\x8f\xdf\x2f\x84\xb7\xb3\x66\x36\x9c\x90\x0c\xeb\x3c\x6b\x53\x97\x92\x96\xdd\x10\xbb\x50\xd0\x6c\xc2\x7b\xef\xbc\xf1\x0e\x0c\xfd\x24\x05\x92\xa4\xc1\xd4\x4f\xc9\xed\x42\xcf\xf8\x41\x3e\xe6\xd8\x00\x9a\x8c\xff\x35\xf9\x80\x32\x6d\x60\x9b\x9b\x56\x01\xac\x33\x84\x6e\x8a\xd1\xe3\x36\xb6\xa8\xd8\x5c\xef\xc8\x39\x43\xab\x33\x80\x9b\x1d\x38\x82\xdb\x8a\x14\xb4\xf6\x76\xc6\x3d\x5e\x63\x22\xba\x9c\x58\x72\x4f\x26\x17\xfb\xe7\xf6\xa4\x5c\x98\x14\x6f\xde\x8a\xc9\x43\xd2\x01\xcd\x2d\x25\xaa\xa1\xa2\x0b\x33\xca\x20\x5d\x16\x94\x2e\xe2\xc2\x7f\x80\x3e\x09\x26\xe7\x16\xa7\x99\x8c\xd2\x7c\x5f\xe9\xa2\x97\x85\x5e\x5c\xbb\x62\x34\x40\xb0\xea\x06\x50\x87\x29\x6f\xa8\x36\x30\x35\x25\x7f\xdb\x68\x52\xb2\x1f\xbd\xe7\xbe\x44\xbf\x8d\xd5\x83\xa4\x45\x27\xcf\x17\x1f\x2d\xf9\x20\x4e\x2f\x6b\x5c\x7a\x71\xab\xec\x17\x7b\x4d\xf0\x85\xd6\xd9\x4a\x0b\xf6\x83\x84\x58\x0b\xb5\x7b\x61\x5a\xe4\xf9\x92\x4e\x5b\x85\x1a\x59\xdb\xc6\x7d\x57\x32\x3d\xb7\xf8\xd3\x96\x16\xda\x1e\x8e\x27\x9d\x31\x57\x5d\x6e\xb4\x9e\x77\xb9\xb1\x74\x79\x61\xae\x0f\xca\xec\x0f\xa6\x05\x82\xd1\xaf\xa7\x13\xa5\x0e\x96\x2f\xbf\xf8\xda\x17\x69\x9f\x28\xb5\x50\x58\x05\xdd\x51\xcf\x99\x2a\x56\x32\x56\xb8\x2b\x19\x2b\x72\x11\x87\x4b\x1b\x7d\xe1\xc6\x96\x9f\xe6\x92\xba\x08\x2b\x24\xa2\x98\xb3\x0b\xd3\x14\x13\x89\x33\x57\x52\x9c\x6a\xac\x73\xa1\x95\x8b\x56\x8e\xae\x8f\x8c\x8b\x99\x31\x46\x5a\x5b\xd6\x7a\xd5\x12\x3c\xc7\xb0\x25\x12\x1c\xc7\x88\x6c\xa0\x65\x52\xf1\x05\xde\x1b\xad\x22\x15\x7d\x10\xa7\x96\x31\xf6\x33\x28\x51\xf5\xa0\x70\x02\x79\x15\xa3\x6c\x7e\x30\xf7\xc3\x34\xa0\x33\xde\xab\x66\x21\x5e\xe5\x06\x7a\x5d\x3e\x8b\x96\x14\x5e\xe5\x2e\x97\xc1\xe2\xc6\x75\x95\x92\x8e\x63\x92\x8c\xa3\xc9\x20\x51\xcb\xce\x52\xd3\x87\x3c\x2a\xc1\x02\xd6\xea\x4a\x2b\x42\x6e\x18\x3e\x52\x06\x68\xed\xe8\x05\x9e\x9c\xd8\xd7\xdd\xb4\x64\x7c\x5b\x55\xa4\x1b\xe0\xfa\xfd\xe2\x0b\x20\xe6\x44\x2b\xc8\xa1\xeb\x7f\x0e\x04\xd0\x84\x70\x99\x5d\x25\x1b\xe0\x5a\x5f\xbc\x70\x07\xdf\x05\x95\x0e\x0b\x15\x30\x11\x1b\xde\xbd\x20\x92\x6c\xb8\xf5\x82\x84\xf4\xb9\x90\x55\x2d\x77\x60\x61\x1f\xec\x17\xdd\xa8\x7f\x77\x91\x66\xa4\xda\x69\xb6\x67\x58\x37\x04\xe1\x80\x2c\xde\x19\x5a\x99\xa3\xb2\x01\x9f\xa5\xbb\x6f\xfb\x6f\x3b\xf0\xb6\xff\xf6\x01\xb4\x65\xe4\x9f\x80\xbb\xc3\xe4\xbb\xa0\x9d\x3f\x3d\x41\x21\xa9\x8c\x4a\x84\xea\x85\xb5\x82\xf9\xe3\x15\x08\xe7\xe0\x02\x06\x27\xec\x81\xac\xd0\xb6\xcd\x65\x82\x7e\x17\x3f\xe8\xec\xcf\x12\xcc\xd3\x3e\x8c\x85\x0f\xa5\xdf\xd3\xc0\x74\x73\x42\xdb\x1d\xcd\xd0\x0d\x0e\x1c\x18\xc0\xf5\x9c\xa7\x37\xfd\x5a\x1b\xfc\x3f\xec\xbd\x79\x77\xdc\x36\xb2\x38\xfa\xbf\x3f\x05\xe2\xdf\xbb\x51\xb7\xdd\x6e\x03\xe0\x2e\x8d\x26\xd7\x71\x9c\xc4\xef\x3a\x76\x8e\xad\x4c\xc6\x3f\x3f\x1f\x05\xc4\x62\x71\xdc\x22\x35\x24\x65\xab\x27\xd6\x77\x7f\x07\x1b\x09\xb2\xc9\xee\x56\x4b\x56\x32\x73\x1d\xe7\x40\x4d\x2c\x05\xa0\x50\x55\x28\x6c\x55\xd3\xa9\xad\x5c\x2d\xed\x59\xa7\xf2\x79\x55\x94\xdb\x13\x85\x16\xf9\xa4\xa2\x5c\xdd\x23\x36\x4f\xb2\xdc\x35\xb9\x65\xc7\x3e\xde\x2c\x5b\x5f\x69\xb6\xb3\x85\xb6\x91\x42\x96\x62\x15\x82\x65\xc3\xe6\x94\x2c\x16\xab\x7b\x7c\x9a\xfc\x9c\x61\x70\x5b\x69\x79\xb2\x5a\x33\x51\x3a\x44\x35\x02\x65\xc3\x4c\xdb\xca\xc1\x46\x09\x9a\x77\x26\x72\x27\x5e\xb5\x56\xe3\xe1\x0a\x2b\x21\x74\x8b\x56\x43\xaf\x38\x91\xfd\xeb\xdf\x74\x22\xdb\x6d\x21\xb3\xd5\x1a\x69\x60\x92\xfc\x97\x3b\x49\x2a\x53\x83\xcd\xf9\x80\x32\x26\xd8\x2c\x37\x72\xf7\xa3\x15\x27\x70\x1e\xac\x4e\xa8\x70\x06\x50\x6f\xf6\x1c\x98\x43\x94\x6b\xe0\x8b\x9b\x9e\x3b\xec\xf4\x76\x31\x53\x62\xcd\x99\x3d\x36\xce\xe4\x0f\x50\x4f\x58\xf6\x9f\x48\xae\xce\xd1\x46\xa6\xab\x77\x91\x93\x49\xa6\x6f\xb1\xdd\x03\xca\xac\xe2\x44\x4e\x19\xb9\xfa\x54\xb6\xef\x26\xb9\x31\x33\x39\x3a\xe3\x5e\xe7\xa4\x41\x8d\xdd\xfd\x63\x65\xfa\x51\x8d\xdc\xfd\x63\x65\xf9\xb1\x23\x92\xde\x5c\x40\x99\xba\x32\xd7\xec\x24\x33\x73\x65\xdb\xef\x26\x04\xe7\xd4\x99\x0d\xaf\x22\x44\x3f\x97\x26\xe0\x2c\x19\x65\x22\x92\x89\x12\x73\xcd\xd4\xdf\xcd\xf1\xd7\x43\x90\xcb\x2c\x26\x39\xd7\x87\x2d\x12\xcf\x4e\x36\x9b\x9a\x99\xd4\x86\x72\x56\x06\x63\x2b\xa1\xfe\xaf\x21\xa1\x6e\x87\x77\x5b\xb1\xbe\xcd\x4a\x6c\xfb\x65\x51\x7f\x6a\xb8\x85\x5b\xe1\x57\x9e\x1a\x9a\x29\xf5\xdf\x73\x6e\x70\xe5\x77\xd3\x95\xc1\x55\xce\xb8\x5c\xee\x08\xf4\x3f\x9d\x90\xbe\xfe\x61\xeb\xf5\xb5\xb8\x76\x39\xd7\x28\x4a\x8d\x66\xec\x2e\xed\xd4\xda\xcd\x18\x9b\x6e\x0f\x75\xc7\x84\xd5\x1f\xa9\x97\xee\xda\xa3\x5b\x90\xbe\x37\x26\x17\x1d\x7e\xf8\x6c\xda\xee\xad\xdb\x5c\x3d\xcd\x16\x0b\xc9\x37\x45\xce\xaa\xdd\x1f\x34\xaa\xed\xc9\x0f\xeb\xde\x41\x84\xcd\x8b\x46\xa7\xc6\x2d\x1f\x31\xb4\xd0\x07\x77\x4c\x7b\xe3\xf5\xf0\x21\xc8\x8b\xe2\xec\xce\xa5\x73\x7f\x87\x69\xe7\x44\xcd\xc5\x6d\xf9\x3d\xaf\x78\x7d\x94\x9d\xf2\xc9\x7d\xf9\x05\xee\xeb\xe4\x83\x4e\xb9\xbe\x21\x1e\xfb\xae\x21\x67\xea\x22\x29\x29\x6b\x73\x37\xf3\xe1\x43\xf0\x28\x07\xc5\x59\x9d\x9d\x66\xff\xe2\x4c\xe2\x4e\x7b\x9d\xd0\x86\x77\xe5\x62\xb8\x3e\xc9\x2a\x50\xa9\x04\x63\xd6\xd9\xc1\xc4\x9c\x7f\xe0\x65\x87\xf8\xcc\xe1\x78\x73\x5c\xa9\x4f\xc7\xde\xb7\x0f\x35\x9a\x4b\x5f\xef\xa7\xe0\xd3\x27\xf0\xd5\xe4\xbd\xba\x5f\xd0\xba\xe2\x3e\x5f\x2c\x9a\xcc\x2a\x11\xb5\x89\x4e\xd5\x07\x57\xf3\x17\xb1\xed\x60\x48\xa4\x5a\x06\xea\xa0\xdb\xe9\x8d\x42\xfc\x43\xf0\x5e\xaa\xb0\xef\x8d\x4b\xd8\xf1\x41\x5b\x33\x6c\x83\xe5\x57\xad\x28\xd9\xfd\x7c\x67\xfc\xa4\xde\xfc\x5e\x5b\x9e\x39\xb8\x9e\x57\x05\x07\xa5\xc6\x66\x4c\x87\xb7\x0e\xdd\x4f\x2d\x1e\x56\xef\xf4\xa2\x5b\xb7\x55\x7a\x4b\xac\xbf\x9b\xc2\x62\x0d\x57\x8f\x2b\x43\xe6\xe4\x4c\xdd\x8e\xfb\x1c\x22\xa5\xa5\xe2\x0d\x34\xbc\x65\x3f\x1a\x87\xca\x26\xe6\x95\x6e\xb4\xac\x74\xad\x23\xe3\x6d\x81\x1c\xec\x26\xf6\x3e\x43\xdd\x23\xa2\xb3\xcf\x7b\xd7\xae\x76\xb5\xc7\x9d\xfa\x54\x97\xdf\xf1\xfa\x97\xa3\xc7\xba\x4c\x35\xb1\xaf\x29\x76\xe6\xf4\x0e\x93\xb7\xfc\xbd\x81\xb5\x6f\xdd\x0e\xe9\x69\x96\x9f\xd7\xfc\x3f\x81\xb5\x75\x4f\xfe\xf4\xac\x4d\x3b\x24\xfa\x93\x6e\xf4\x55\x59\x7b\x14\xc8\x2d\xb0\xf6\x96\x75\xdf\x34\x6b\x8f\x55\xbb\x25\x6b\xeb\x02\x37\xc0\xd7\x9a\xcc\x9a\xc9\x5b\x73\xcf\xa1\xf9\x35\xca\xd7\x9f\xf1\x19\xde\x88\x7d\xe1\xe2\xbc\xfc\x4f\xe0\x6a\xd9\x8f\xcf\xc6\xd3\xb2\x82\x42\x88\x8a\xab\x67\xc9\x86\x52\x24\x73\xfc\xab\xc8\xf9\x0b\x95\x30\xb9\x11\xbe\x04\xff\xb5\x3d\x8c\xb4\x03\xe3\x47\xd9\x7f\xc7\x95\x9d\x69\xae\xba\xb7\x6e\x7e\xdf\xdf\xb0\x30\xdf\x0e\xf8\x98\x7c\x33\x72\xe2\x81\xa9\xed\x4a\x3c\x3b\x5c\xdb\x95\x30\x3a\x0c\x02\xdc\xb7\xcd\xb9\x05\x81\x37\xd2\x8b\xcf\x2b\xee\xc6\x06\x6a\x2b\x61\x27\xb3\xdf\x80\xa8\x93\xbc\x67\x0d\x16\x2b\x71\x72\xa8\xfe\x8e\x0a\xb9\xdb\xb3\x4c\x69\x6d\x2c\x91\xe5\x7f\x82\x8c\x63\x64\x2b\x83\xb1\xd7\x52\x5b\x34\x49\x40\xb5\xd3\x29\xff\xdf\x92\x71\xbe\x23\x35\x9f\x58\xb2\x52\x1f\xd3\x2b\x6d\x82\xb8\xf4\x0f\x1e\xa8\xcf\x41\x19\x6b\xb2\x0c\xa5\xdd\x8c\x62\x74\x15\xde\x23\x1d\x20\xdf\x91\xe5\x15\x58\xcf\xe0\xe8\x41\xf3\x20\x77\x67\xee\x63\x64\x69\xdd\x48\x4a\x32\x97\x13\xd4\x72\x94\xf5\x6e\xf1\x99\xef\x4d\xdb\x54\xab\xce\x73\x46\x96\x37\x6e\xc2\x6d\xcc\x62\xdc\x69\xd1\xa9\x6e\x58\xb0\xd4\xe7\xbc\x62\x6a\xdc\xc7\xf3\x7c\xe4\x2c\x77\x73\xdd\x54\xc3\xe9\x48\xc3\xeb\x93\xf3\xb2\xda\xdc\x74\x51\x66\x9b\x5a\x5e\x91\xfa\xbc\xdc\x98\x49\x0d\x4b\xb5\x36\x8f\xc6\xe5\xfa\x3c\x06\x95\xeb\x33\x35\xb8\xdc\x00\xcb\xa0\x60\x7d\x2e\x8d\x81\xf5\x79\x2c\x0a\xfe\xdd\xa7\x8f\xe6\xd0\xec\x23\xe7\xef\x19\x59\x5a\x33\x5a\xb7\xb4\x57\x3b\x34\x3d\x3c\x00\x4e\xcc\x52\xcd\x17\x11\x78\x00\xb2\x29\xf8\x2f\x10\xd9\xbb\x58\xe3\xb3\xd2\xb6\xdb\xbb\xe3\x33\x13\xb8\x67\xea\xb9\xf2\x3e\xef\xbf\xcd\x0c\xc5\x3b\x40\x7e\xe5\xfc\xbd\x55\xe3\xcd\x23\x63\xb5\xe9\xa4\x38\x18\x1c\x36\xb4\x01\xed\xaa\xb5\xe8\x25\x20\x93\x60\xc5\x5e\x9b\x82\x4d\x4a\x2b\xec\xda\x34\xcf\x96\x32\x5c\xe9\x24\xf9\x26\xc9\x08\xa3\x36\x21\xb0\x1b\x62\x56\x04\xb5\x49\xea\xf0\xa7\x6d\xb7\xda\x2c\x53\xbf\xec\xa4\xd7\x36\x5d\x2d\xb8\x8b\x7e\x5a\x23\x69\x0e\xed\x4f\x37\xd5\x11\x31\x87\xed\x47\xa7\x7c\x23\x5d\x0e\x9b\xdf\x6e\xba\x95\x2b\x87\xe6\x97\x9b\xd6\xca\x93\xc3\xe6\xf7\xe8\x64\xfd\x19\xdf\xed\x8c\xca\xe9\xfa\xe4\xb6\x4e\xee\x64\x5d\x9f\x5d\x9d\x55\x0c\xaf\x6f\x31\x5d\x53\xc3\xfd\x49\xb6\xb7\x11\x24\xfa\xeb\x6a\x3a\xae\x91\x18\xb6\xa8\x23\x28\x5a\x68\x56\xac\x7c\x7f\xbe\x58\xbc\xe6\xa4\xec\xe6\x6b\x63\xa5\x28\x41\x78\xdb\x3d\x2d\x0d\xfe\xda\x3b\x5a\x12\x4c\x2b\x1a\x24\xa5\x1c\xea\x1f\xa3\x14\xfc\x19\x1f\x0e\x0c\x53\xf0\x92\x93\xcf\xbf\x9d\xa5\x09\x58\x56\xf5\xd9\xe9\x57\x0f\x1d\x9c\x81\x1b\xa1\xe1\x86\x7e\x2c\x65\x38\x64\xb6\x03\x25\x6f\x22\xd2\x2d\xc9\xb3\x53\x60\xe7\xf3\x6f\x39\x1c\xa3\x07\xdf\xa6\x46\xe7\x98\xbb\x7f\x12\xde\x39\xf6\x06\xdf\xe8\x1b\xe3\xdb\xbd\xc1\xba\x8e\x62\xd4\xf4\xbd\x77\x52\xd0\x43\x6f\xe7\x58\x7b\x94\x3a\x6e\x44\x5f\xda\x4c\x23\xed\xf9\xf8\x75\x4f\xb9\xe5\x98\x19\x81\xa2\x19\xf7\x50\xfd\x1d\x13\x27\xf8\x33\x5e\xdf\x1e\x16\x27\xe7\x35\xfd\xe9\x3f\xe6\xe0\xab\xe9\xcc\x67\x97\x5a\xce\xf9\xe8\x15\xa4\xd3\xff\xc2\xd3\xa6\x5f\x8e\x1e\xdf\xd8\x81\x53\x33\xbc\x86\xa3\x1c\xda\x3d\x6c\x3f\x46\x79\xeb\x33\xde\x7f\x1d\xe5\xad\x1f\xff\x43\x0e\x9f\x4c\x57\x6e\x83\xaf\x2c\xb9\x5c\x6d\xe2\xff\x5f\x76\xae\xf1\xcb\xd1\xe3\x1b\x3a\xda\x30\x23\xdb\xb2\xd4\x8f\xe6\x80\xc3\xfc\x1c\x65\xa7\x5b\xbf\x7b\x79\x5e\xd3\xef\xfe\xfd\xf7\xa9\x0c\x96\xbf\xbb\x85\x93\x8e\x86\x48\xae\xac\x46\xff\x72\xf4\xb8\xb3\xab\x64\xbf\x77\x3f\xf2\xb8\xb5\x63\x87\xb6\xa9\x37\x70\xf2\xa0\x07\xaa\xe5\x8d\xef\xf4\xbe\x86\xfe\x35\xca\x19\xb7\x60\xaa\xfa\x73\x1d\x41\x9c\xd7\xf4\xd5\xed\x9e\x42\xc8\x79\x7b\x9b\x83\x88\xf3\x9a\x1e\x6d\x71\x16\x71\x5e\xd3\x5f\x6f\xf9\x38\x42\xb6\x6c\xbb\x13\x89\xf3\x9a\x7e\xbf\xf9\x50\x42\x8e\xc1\x36\xe7\x12\xcd\x58\xad\xdf\xe0\x6f\x10\xbc\x31\xdb\xd1\x36\x07\x14\x2e\x82\x37\x43\xdc\xea\x98\xa2\x41\xcb\xc6\x6c\xaf\xfe\xd3\x0e\x2b\x14\x36\xff\x88\xf3\x8a\x71\x09\xef\x9c\x5a\xa8\xc8\x0d\x07\x17\xc3\x93\xcc\xb6\x6b\xf1\x4d\x13\xcd\xee\x27\x18\x37\x7f\x8a\xd0\xf0\x9b\x9e\x01\x7e\xed\x9d\x25\x34\x7c\xd6\x4d\x46\x6d\xf2\x51\x73\xa8\xe0\xa4\xe3\x36\xfd\x57\xe7\x68\xc1\xc9\xe1\x39\x10\xda\x03\x06\x27\x83\xdf\x66\xf8\xde\x1e\x33\x38\xc9\x41\x9b\xfc\xaa\x3d\x6c\x70\x32\x34\xe7\x0d\x8e\x44\x39\x6c\x3f\xdc\xdd\x7d\x47\x98\x1c\xb6\x1f\xbd\x1c\x47\xed\xf1\x43\xfb\xd5\xcb\xf3\xab\x7b\x08\xe1\x7e\xf7\x61\x39\x47\x11\xce\x67\x2f\xd7\xf7\xcd\x81\x44\xf3\xd1\xcb\xf1\xca\x39\x96\x70\x3e\x47\xe7\xf0\x5b\xbf\x7e\xac\x91\x79\x6b\x87\x13\xb6\xba\xdb\x50\x42\x07\x8e\x28\xae\xa5\x9a\x76\x0f\x2a\x9a\x88\x9d\x76\x78\x9d\xd2\xce\x0e\x6f\x07\xe6\xa4\xcd\x3a\xbc\x1f\xdc\x49\xb8\xd2\xb9\x45\x5b\xcf\x4d\xec\x8d\x38\xa7\x17\x2d\x35\x1d\x36\xbf\x47\x69\xfd\xd6\xaf\xe4\x9e\xd7\xf4\xf5\xed\x1d\x63\x98\xda\x6e\x65\xef\x62\xf8\x30\xe3\x5a\xd4\xbe\xb2\x5d\xdd\xa5\xc3\xdd\x68\x7e\x0b\x42\xde\x9e\x84\x6f\xe6\x78\xc3\x0c\xd3\xbf\xdf\x09\x87\x8b\x81\x81\x43\x8e\x2e\xb6\x47\xce\x39\x56\x69\xe7\x06\x35\xac\xad\x28\xe8\xe6\xce\x3c\xcc\x40\xb6\x92\xe8\xb5\x39\xf9\xb0\x23\x3c\x26\x87\xfe\x5c\xfe\x59\xb2\xaa\xf8\x7e\x83\x1b\x8c\x04\xee\xbe\x54\xe0\x8e\x6b\xd0\x35\x56\x3a\xfd\xde\x82\xe1\x8c\x94\x15\x7f\x5a\x15\xcf\x49\x9d\x7d\xe0\x13\xed\xd8\xd1\x31\x38\x40\xd4\xe1\x47\xce\x3f\x02\x35\xeb\x9a\xf4\x03\xd7\xf9\x81\xb2\x0f\xa5\xe8\xb8\x61\x11\xf9\xd9\xe8\xb9\xb6\x0a\x70\x08\xee\x37\x80\xee\x62\x08\xe1\x03\x88\x1e\x40\x74\x04\xe1\xbe\xfa\x7f\x0e\x21\xfc\xbf\x77\xf5\x2b\xee\x6f\x7a\x2d\xbb\x03\xb6\xb3\xf0\xb8\x8a\x0a\x7b\xe4\x70\x5e\xd3\x9f\x25\x48\xcd\x81\xdb\x0e\x95\x65\xdf\xac\x2a\xba\xee\xc4\x35\x45\xdf\x90\x5f\x7f\xdb\xd7\x01\x3f\x33\xf8\x4f\xe5\x4c\xff\xb8\xce\x4e\xd7\x79\x44\xb9\x8e\x93\x18\x05\x7a\xa3\xa7\x98\x78\x57\x13\x4a\xb6\x86\x71\xde\xf0\x8c\x09\xa5\xeb\x3b\x48\xba\xf2\xd2\x5b\xb7\xac\xb1\x84\x49\x16\x3c\x67\xa4\xdc\x44\xaa\x4e\xa7\xde\xdc\xfd\x60\xa9\x5c\x29\x27\xf7\x1e\xbe\x9d\x6d\x87\x8e\x37\x77\xff\x69\x4b\x6a\x0d\xfe\x2a\x45\xcf\x6d\x51\xbb\xc6\xdd\xba\xe4\xc2\x96\x34\xdb\xb1\x5b\x17\x3c\xb5\x05\xed\x11\xc7\xd6\x25\x8b\xa6\x9f\xcd\xa9\xe3\xd6\x65\x4b\x5b\xb6\x7d\xfa\xba\x75\xd9\xbc\xad\xb7\xb5\xbd\xb0\x01\xc0\x2a\x47\xd8\x13\x1e\xb9\x22\x6d\xad\xb6\x37\xa6\x81\xa4\x54\x9d\xff\x72\xf4\x78\x22\x05\xab\x9a\xd5\xd1\x74\x06\x56\x63\xf1\xf4\xed\x88\x3f\x33\x7c\x0b\x56\xaf\xaf\x64\x72\x7a\x51\x94\x6b\xcc\x36\xc3\xf8\x7a\xde\xcc\xb6\x33\x16\xac\xdb\x30\xa8\xc4\xdd\x45\x22\x8a\x52\x5f\x88\x48\x40\x8e\x29\x81\x98\xb2\x10\x47\x38\x4e\xfc\x30\x4a\x59\x4c\x83\xd0\x4f\xb9\x17\x45\x14\x47\x42\xfe\x4b\x69\xca\x30\x46\x51\xca\xa9\xb8\x3b\x1d\x1a\x81\x5b\x30\x1b\xfb\x1f\x35\x02\x5e\xe2\xa5\x51\x12\xe0\xc0\x27\x5e\x98\x86\x9c\x8a\x84\x26\x9c\xf1\xd0\x8b\x12\x2f\x89\x29\xc1\x01\x4e\x03\x2a\xc2\x94\x72\x96\x26\x34\xa6\x21\xf3\x50\xca\x12\xee\x25\x3c\x4a\x49\x80\x79\x44\xd3\xc4\x8f\x7d\x8f\x7a\x09\x61\x7e\xe2\x13\x16\x86\x28\x4c\x79\x94\x84\x09\x8d\x52\x1f\x45\x1e\x09\x02\x94\xf8\x94\x87\x2c\x65\x8c\x27\x9c\x85\x83\xa3\xe7\xdd\x82\xad\xc4\xff\xac\xd1\x43\x31\x4e\x59\x98\x12\xce\xc2\x84\x53\xc2\x11\x0d\x59\xca\x05\x0f\x83\x00\x32\xc1\x62\xe6\x51\xc1\x08\x0f\x53\xc1\x18\x24\xd8\x43\xc4\x0b\xfc\xc8\xa7\x7e\x14\x12\xc4\x92\x24\xa5\x11\x4f\x28\x8c\x82\x30\x4d\x51\xc2\x13\x42\x63\xc9\x63\x8c\x32\xc2\x08\x4f\x43\x4f\xfe\x4b\x42\xf9\x2f\x65\xf2\x1f\x4b\xe4\xbf\xe1\xd1\xbb\x05\x73\x66\xff\x51\xa3\xa7\xa5\x1f\xe1\x34\xe2\xb1\x96\x81\x42\xa4\x69\x14\x6b\x49\x98\xc4\x4c\xc4\x44\xcb\x43\x21\x92\x38\x09\xb5\x54\xa4\x41\x0a\x59\xa0\x65\x23\xf5\x13\x9a\xf8\x5a\x42\x8a\x28\x0d\x99\x91\x93\x34\x92\xff\xb4\xb4\x94\xc3\x16\x33\x2d\x33\x13\xce\x08\x0f\x86\x47\xef\x4f\xe5\x9d\x9a\x79\x1a\x77\xa3\xc3\x17\xec\x7c\x26\xc4\xbc\x63\xc7\x18\xfd\x1a\xfa\xd0\xfb\x55\x9f\x91\x40\x56\xdb\x62\x35\x14\x27\xf2\xf1\x79\xca\x4f\xf8\x22\xbb\x78\x56\x18\x23\xbf\xdb\x50\x5e\x8b\x3f\x0b\x92\x5a\x38\x1a\x86\xa7\x94\x99\x79\x20\x03\x38\xdd\xca\x73\xe8\x46\x98\x0f\xb0\x6f\x81\xa2\x39\x9c\x0e\x52\xd9\xbf\xc1\x49\xfc\xd8\xa9\xf2\x47\x52\x9e\xde\xda\x21\x3c\x2d\x8a\xc5\x4a\x65\xff\x96\xfc\xa3\x1e\xb8\x90\xf2\x74\x6b\x0f\x4b\x7f\x10\x47\x3c\x40\x9a\x25\x22\xc5\x13\x5e\x70\x43\x4c\x11\xcb\x75\xc4\x3c\x50\xa0\xe3\xa9\x3d\xd7\x93\xc3\xfb\x67\x47\x08\x0e\x6f\x0f\x1f\x25\xc9\xf2\xb4\xf8\xb8\xb5\xfd\xfe\xf5\x75\xec\x76\x6e\x93\xf6\xb6\x20\x8c\xcf\x1a\xeb\xc0\x0d\x82\x4f\x9f\x40\xad\xac\xd0\x81\x1a\x3c\xe8\xec\x74\x6b\x17\x6d\xea\xa1\x56\xe5\x7a\x6c\xae\x8d\x03\x2c\xb5\xdb\xa7\xbb\x38\x3f\x01\x87\xc0\x0b\x21\xb8\x27\xa1\x00\x04\xa1\x9b\x28\x4b\xa3\x79\x20\x13\xe6\x81\xcc\x52\xb9\xa9\x92\x64\xe0\x3c\x56\x40\x93\x36\xb5\x71\x7b\xa2\x50\x78\x5f\x79\xcf\x1a\x5a\x9e\x7a\xb7\xe0\xf1\xfe\x73\x09\xdf\x53\xf2\xee\x94\xdc\xb8\xf4\x1d\xbb\x74\x95\xe5\x82\x97\x79\x71\xe3\xf5\xb1\x91\xfa\xce\x16\xa4\x1a\xe8\xde\xcd\x6b\xbb\xad\x85\x6f\x72\x7a\x66\xac\x7b\x36\x5b\xd5\x79\x63\x89\x54\xdb\x3a\x3d\x18\xf0\xfc\x5a\xf7\x2e\x78\x68\x73\xb7\xab\x8e\xeb\xb3\x5c\x7b\xee\xe8\xf8\xab\xaf\xc1\x3d\x90\x4f\xa7\xd3\xb7\xad\xa7\xd8\x9d\xb5\x2b\xd5\x81\xeb\xeb\xe0\xbe\x0f\x51\xe0\xfb\x3e\xc4\x41\xe8\x07\xd0\x0f\x22\x3f\x80\x41\x90\xf8\x21\x8c\x02\xe2\x87\x30\x0e\xa8\x1f\x42\x12\x30\x3f\x84\x69\xc0\xfd\x08\xb2\x10\xfa\x11\xe4\x21\xf2\x23\x04\x43\xcf\x8f\x10\x0a\x7d\x3f\x42\x5e\x18\xf8\x31\xf2\xc3\xc8\x8f\x51\x18\xc6\x7e\x8c\xa2\x30\xf1\x63\x14\x87\xc4\x8f\x11\x09\xa9\x1f\xa3\x34\x64\x7e\x8c\x68\xc8\xfd\x18\xb1\x50\xf8\x31\x12\x11\xf4\x63\x0c\x23\xe4\xc7\x18\x45\x9e\x1f\x63\x2f\xf2\xfd\x18\xfb\x51\xe0\xc7\x38\x88\x42\x3f\xc6\x61\x14\xf9\x31\x8e\xa3\xd8\x8f\x71\x12\x25\x7e\x84\x49\x44\xfc\x08\x53\x15\xb2\x28\xf5\x23\xb9\x0c\xf7\x23\x2c\x22\xe6\x87\x1e\x8c\xb8\x1f\x7a\x58\x85\x5e\x24\xfc\xd0\xf3\x63\xe8\x07\x5e\x10\x23\x3f\xf0\x22\x15\xc6\x31\xf6\x7d\x2f\x89\x3d\xdf\xf7\x88\x0a\xd3\xd8\xf7\x3d\x8f\xa9\x90\xc7\x81\x8f\x3d\x21\x43\x1f\xc6\xa1\x8f\x7d\x14\x87\x3e\xf2\x71\x1c\xf9\xc8\xf7\xe3\xc8\x87\x7e\x10\xc7\x3e\xf4\xc3\x38\xf6\x84\x1f\xa9\x30\x8e\x13\x8f\xfb\x89\x0a\x89\x0a\x69\x4c\x3c\xe6\x33\x15\xf2\x98\x78\xd4\x17\x32\x0c\x60\x9c\x7a\x69\x80\x54\x88\xe3\xd4\x23\x81\xa7\x42\x3f\xa6\x5e\x12\x04\x2a\x0c\x63\xea\xc5\x41\xac\xc2\x24\xa6\x5e\x14\x10\x15\xa6\x31\xf3\xc2\x80\xaa\x50\xae\x70\x83\x80\xab\x50\xc4\xcc\x93\x03\x26\x43\x14\x33\xcf\x0b\xb1\x0a\xbd\x98\x79\x38\xf4\x63\xee\xe1\x30\x88\xb9\x27\x07\x47\x86\x91\x0a\xe3\x98\x7b\x30\x4c\x54\x48\x62\x8e\x45\x98\xaa\x90\xc6\x1c\xf3\x90\xa9\x90\xab\x50\xc4\x1c\xb3\x08\xaa\x10\xc5\x1c\x53\x13\x62\x15\x7a\x31\xc7\x69\xe4\xab\x30\x88\x39\x26\x51\xa8\xc2\x48\x85\x71\xcc\xe5\xc8\xa9\x90\xa8\x50\xd6\x12\x47\x54\x85\xb2\x96\x28\xe2\x2a\x94\xb5\x44\xb1\xac\x25\x8c\x91\x0a\x71\x13\x06\xb1\xa7\x42\x5f\x85\xb2\x16\x3f\x0e\x55\x28\x6b\xf1\xe2\x58\x85\x89\x0a\x49\xcc\x30\x8e\x53\x15\x52\x15\xb2\x98\x61\x14\x73\x15\x0a\x19\x26\x50\x85\x28\xa6\x18\x26\xd8\x09\xbd\x98\x22\x91\xf8\x2a\x0c\xe2\x14\x89\x24\x54\x61\xa4\xc2\x58\x85\x49\x4c\x90\x48\x48\x4c\x10\x4f\x52\x15\xd2\x38\x41\x3c\x61\x71\x82\x44\xc2\x55\x28\xe2\x18\x09\x02\x55\x88\x4c\x18\x21\x41\x70\x1c\x61\x48\xbc\x38\xc4\x90\xf8\x71\x88\x11\x09\xe2\x00\x23\x12\xc6\x01\x96\xc8\x92\x61\x1c\xfb\xd8\x23\x49\xec\x61\x9f\x90\xd8\xc3\x01\x49\x63\x8c\x03\x42\x63\x8c\x43\xc2\x62\x84\x23\x15\xc6\x84\xc7\x10\x27\x44\x44\x02\x93\x14\x46\x02\xd3\x14\x45\x1c\xb3\x14\x47\x0c\xf3\xd4\x93\x4b\xe3\xd4\x8f\xa8\x87\xd2\x20\x4a\x3d\x9c\x86\x11\xf1\xfc\x34\x8c\x12\x2f\x48\xa3\x28\xf1\xa2\x34\x8e\x62\x2f\x4e\x93\x28\xf2\x48\x4a\xa2\xd0\x4b\xd3\x34\x0a\x3c\x96\xd2\xc8\xf7\x44\x4a\x23\xcf\x87\x29\x8b\xb0\x8f\x53\x1e\x21\xdf\x4f\x25\xcf\x86\x14\x4a\xfe\xa5\x28\xe4\x3e\xa1\x28\x64\x3e\xa5\x38\xa4\x3e\xa7\x5e\x98\x06\x90\xfa\x21\x09\x30\x0d\xc2\x24\xf0\x69\x10\xc6\x41\x48\xc3\x30\x0a\x62\x1a\x85\x81\xec\x44\xe8\x07\x94\xc6\xa1\x17\x70\x9a\x84\x38\x84\x94\x84\x30\xf4\x68\x1a\x88\x30\xa0\x69\xc0\xc3\x88\xd2\x80\x86\x09\x65\x41\x1a\x52\xca\x02\x12\x72\xca\x83\x38\x82\x54\x04\x51\xe4\x31\x18\x84\x51\xc0\x60\xe0\x47\x11\x43\x81\x17\x11\x86\x02\x14\x51\x86\x03\x18\x09\xe6\xf9\x3c\x46\xcc\xf3\x59\xec\x33\xdf\x4f\xe3\x90\x05\x92\x2f\x59\xe0\xc7\x71\xca\x42\x3f\x8c\x39\x0b\xfd\x20\x81\x2c\xf2\xbd\xc4\x63\x91\x8f\x92\x80\xc5\x3e\x4c\x62\x16\x7b\x3c\x49\x59\xe2\xd1\x84\xb1\xc4\x4b\x09\x64\xc4\x4b\x08\x66\xc4\x8b\x48\xc0\x52\x2f\x24\x31\x4b\x3d\x9f\x10\x46\x3d\x4c\x18\xa3\x1e\x4c\x21\x63\x58\xa4\x98\x31\xcc\xd2\x80\x71\x9c\xa6\x31\xe3\x38\x49\x09\xe3\x38\x4e\x19\x13\x38\xa4\x90\x09\x1c\x50\xcc\x04\xf6\x68\xc0\x21\x46\x34\xe6\x10\x43\x4a\x38\x42\x82\x32\x8e\x10\x63\x90\x23\x44\x19\xe6\x18\xa5\x2c\xe0\x18\x11\xc9\x1a\x28\x61\x84\x7b\x28\x61\x8c\x7b\x28\x66\x42\x86\x1c\x73\x1f\xc5\x3c\xe0\x3e\x4a\x78\xa4\x42\xc2\x03\x44\x24\x92\x50\xca\x05\x0f\x10\x15\x88\x07\x88\x09\x9f\x87\x88\x8b\x90\x87\x18\x8a\x98\x87\x18\x89\x94\x47\xd8\x13\x8c\x47\x38\xb8\x3b\x6d\x74\x50\xa5\x62\xa8\x29\xf0\x46\x66\x16\x28\xff\xf3\x21\x82\x10\x06\x10\x41\x04\x43\x15\xc6\x10\x43\x04\x13\x88\x21\x86\xa9\x0a\x19\xf4\xa0\x07\x85\x0c\x11\x86\x3e\xf4\x91\x0f\x03\xe8\xa3\x10\x86\x30\x40\xb1\x0a\x09\x8c\x60\x88\x28\x8c\x61\x84\x38\x4c\x60\x84\x21\x24\x30\xc6\x12\x46\x82\x7d\x48\x61\x82\x43\xc8\x20\xc1\x09\xe4\x30\xc5\x29\x82\x30\xc5\x0c\x21\x48\xb1\x40\x18\x32\x0f\x21\x0f\x32\x4f\xc2\xe6\x5e\x88\x02\xc8\xbd\x18\x85\x50\x78\x29\x8a\xa1\xf0\x18\x4a\x10\xf4\x04\x22\x08\xfa\x18\x51\x04\x7d\x1f\x31\x24\x67\x38\x8e\x90\x9f\x60\x88\x90\x9f\x62\x84\x90\xcf\x31\x46\x28\x80\xd8\x47\x38\xf0\x70\x80\x70\x10\xe0\x08\xe1\x20\xc6\x09\x42\x01\xc1\x04\xa1\x80\x62\x8a\x50\x20\x64\xfd\x21\xc2\x02\xa1\xd0\xf3\x10\x42\x61\xe0\x79\x08\x86\x91\xe7\x23\x18\x26\x5e\x88\x60\x98\x7a\x31\x82\x21\xf5\x12\x28\x42\xee\xa5\x50\x44\xd0\x63\x50\x44\xc8\x13\x50\x44\xd8\x87\x50\x44\xbe\x8f\xa1\x88\x02\xdf\x87\x22\x0a\xfd\x00\xc1\x28\x92\x33\x6f\x14\xfb\x89\x0a\x09\x82\x51\xe2\x53\x84\x22\xe2\x73\x84\xa2\xd4\x17\x08\x47\x69\x80\x10\x8e\x68\x80\x91\x17\xd1\xc0\x47\x5e\xc4\x02\x39\x65\xb3\x20\x42\x41\xc4\x83\x44\x85\x04\x85\x11\x0f\x28\x0a\x23\x11\x30\x14\x45\x22\x10\x28\x8e\x44\x08\x51\x1c\xc3\x10\xa3\x24\x86\xa1\x8f\x48\x0c\xc3\x40\x85\x11\x4a\x63\x18\xc6\x88\xc6\x28\x24\x2a\x4c\x11\x8b\x51\xc8\x54\xc8\x11\x8f\x51\x04\x91\x88\x51\x84\x55\xe8\x61\x18\xa3\x28\xc0\x48\x2a\x03\x2a\x8c\x31\x8e\x51\x94\x60\x1c\xe3\x28\xc5\x5e\x8c\x23\xaa\x42\x29\xc5\x71\x0c\x25\x22\x63\x89\x4e\x14\x7b\x6a\x06\xf0\x55\x18\xe2\x28\x46\x71\xac\xc2\x04\xc7\x31\x8a\x53\x9c\xc4\x52\x72\x27\x6a\x96\x20\x31\x4a\xa0\x0a\x11\x4e\x63\x94\x78\x38\x8d\x61\xe2\x63\x1a\xc3\x24\x54\x61\x8c\x59\x0c\x93\x44\x85\x29\xe6\x91\x48\xa8\x0a\x39\x16\x91\x20\x50\x85\x48\x6a\x0e\xc4\x53\x61\xe0\xa1\x88\x93\xd0\x43\x11\x93\xe2\x37\x62\x84\x78\x5e\xc4\x48\xea\x79\x11\x25\xcc\xf3\x23\x4a\xb8\xe7\x47\x69\x0a\xbd\x20\x4a\x53\xac\x42\xcf\x0b\x23\x92\x06\x2a\x8c\xbc\x28\x4a\xd2\x58\x85\xc4\x8b\xa3\x38\xa5\x9e\x9c\x42\x98\x97\x44\x51\x2a\x3c\x12\x45\x14\x7a\x24\x0a\x29\xf6\xd2\x28\xa0\xbe\x47\xa3\x80\x06\x1e\x8d\x7c\x1a\x79\x2c\xf2\x68\xec\xf1\xc8\xa3\xc4\xe3\x11\xa6\xd4\x13\x11\xa2\xcc\x87\x11\xa2\xc2\x87\x11\x64\x92\x45\x04\xc3\x3e\x0e\xa5\xbc\xf3\x42\xce\x02\xdf\x0f\x99\x94\x6b\x21\x65\xb1\x0a\x13\x3f\x0c\x53\x96\xfa\x51\x48\x18\xf5\xe3\x30\x61\xdc\x4f\xc2\x98\x09\x9f\x84\x31\x87\x3e\x0d\x25\xe2\x59\x18\x72\xcf\xe7\x61\xc0\x7d\x5f\x84\x3e\x0f\x02\x18\xfa\x3c\x0a\x70\x28\x15\x21\x2f\xc4\x3c\x09\xfc\x10\x73\x12\x84\x21\xe2\x69\x10\x85\x90\xd3\x20\x0e\x21\x67\x01\x09\x04\xe7\x41\x1a\x70\x2e\x02\x16\x70\x01\x03\x11\x70\x81\x42\x18\x48\xa1\x87\x55\xe8\x07\x54\x78\x61\x10\x50\xe1\x87\x91\x0a\x93\x80\x8a\x20\x54\x07\x2b\x21\x55\x21\x0f\xa8\x88\x22\xa8\x42\x1c\x50\x11\x47\xbe\x0a\xc3\x80\xca\x89\x37\x60\x22\x89\x12\x15\xa6\x01\x13\x24\x92\x75\x91\x48\xd6\x45\x62\x14\x08\x91\xc6\x9e\x0a\x83\x10\x8a\x34\x8e\x42\x24\x68\x9c\xa8\x90\x84\x58\xd0\x98\x86\x9e\xa0\x31\x0f\x7d\x41\x13\x18\x06\x82\x25\x38\x0c\x85\x44\x50\x24\x58\x12\x86\xb1\x60\x49\x1c\x26\x82\x25\x24\x24\x82\x25\x69\x98\x0a\x9e\xb0\x90\x0a\x9e\x88\x90\x09\x4e\x50\xc8\x05\x27\x5e\x28\x04\x27\x41\x84\x04\x27\x51\x84\x05\x27\x49\xe4\x09\x4e\x48\xe4\x0b\x4e\x68\x14\x0a\x4e\x78\x14\x09\x9e\xc2\x28\x16\x3c\xc5\x11\x11\x3c\xf5\xa3\x54\xf0\x34\x8c\xa8\xe0\x69\x14\x71\xc1\xd3\x24\x12\x82\xa7\x69\x8c\x04\x4f\x59\x8c\x05\x4f\x45\xec\x0b\x4e\x51\x1c\x08\x4e\x71\x1c\x09\x4e\xfd\x38\x16\x9c\x86\x31\x11\x9c\xc6\x31\x15\x9c\x12\x29\xfe\x29\x8d\x85\xe0\x94\x25\x50\x70\x2a\x12\x2c\x38\x43\x89\x2f\x38\xf3\x92\x40\x70\x16\x24\x91\xe0\x2c\x4a\x12\xc1\x59\x9c\x10\xc1\x18\x49\xa8\x60\x8c\x26\x5c\x30\xc6\x09\x14\x8c\x43\x82\x04\xe3\x98\xc8\x59\xc0\x23\x81\x60\x3c\x20\x91\x9c\x11\x48\x22\x18\x4f\x08\x11\x8c\xa7\x84\x0a\xca\x29\xe1\x82\x72\x9e\x42\x41\x05\x4c\xb1\xa0\x02\xa7\xbe\xa0\xc2\x4f\x43\x41\xa5\xb2\x28\xa8\x88\xd2\x44\x50\x91\xa4\xa9\xa0\x22\x4d\x99\xa0\x82\xa5\xe6\x7c\x52\x79\x78\xd0\xab\xc9\x5b\x9a\x5a\x88\x9a\x54\xa8\x0a\x39\xf4\x20\x46\x32\xaf\x9e\x5a\x3c\x33\xb5\x44\x30\x84\x3e\x4a\x60\x04\x03\x94\xc2\x18\x06\x88\xc1\x04\x86\x48\x40\x02\x23\x35\xa9\x44\x6a\x52\x89\xd5\xa4\x12\xab\x49\x25\x51\x93\x4a\xa2\x26\x15\xe2\x41\x24\x35\x38\x8c\x7c\x98\x7a\x3e\x0a\x60\xea\x45\x28\x84\xa9\x97\xa0\x18\x52\x8f\xa2\x04\x52\x8f\xa3\x14\x52\x1f\x21\x0a\xa9\xef\x21\x0e\xa9\x1f\x20\x01\xa9\x5c\xe8\x40\xea\x13\xec\x41\xea\x53\x59\x8f\x2f\xa4\x06\x14\x20\x1c\xc3\x34\xf0\x70\x02\xd3\x20\xc0\x29\x4c\x83\x08\x33\x98\x06\x09\x16\x90\x04\xa9\x87\x20\x09\xa8\x87\x21\x09\xb8\xe7\x43\x12\x08\x2f\x84\x49\x88\x3c\x25\xe3\xbc\x04\x26\xa1\xe7\xa5\x30\x09\x7d\x8f\xc1\x24\x0c\x3c\x0e\x93\x30\xf4\x21\x24\x61\xe4\x63\x48\xc2\xd8\xf7\x55\x18\x40\x12\x26\x7e\x04\xd3\x90\xf8\x89\x0a\x09\xa4\x61\xea\x53\x15\x32\xc8\x42\xea\x0b\x19\x06\x08\xf2\x90\x06\x18\x72\xa9\x3f\x41\x11\xb2\x20\x50\xa1\x5c\xf8\xc9\x29\x44\x86\x04\x21\xc9\xbc\x08\x87\x3c\x60\x2a\x14\xc8\x0b\x79\x88\x54\x88\x91\x1f\xf2\xd0\x47\x41\xc8\xc3\x40\x85\x11\x0a\x43\x1e\x26\x2a\x24\x28\x0a\x79\x48\x51\x1c\xf2\x90\xa9\x50\xa0\x24\xe4\x11\x52\xa1\xd4\x88\x79\xe4\xab\x30\x40\x69\xc8\xa3\x08\xd1\x90\x45\xb1\x0a\x09\x62\x21\x8b\xa8\x0a\x19\xe2\x21\x8b\x04\xe2\x21\x8d\x21\x92\x8b\x17\x8c\x61\x48\x63\x1f\xc3\x30\x95\xaa\x75\x98\xc6\x91\x0a\x95\xf6\x1c\x13\x15\x52\xec\x85\x49\xcc\x54\x28\xb0\x1f\x26\x89\x5c\x05\xc7\x09\x56\xa1\x87\xc3\x30\x4a\x02\x15\x46\x38\x0a\xc3\x24\x56\x21\xc1\x71\x18\x24\x29\x4e\x42\x3f\x61\x2a\x14\x98\x84\x1e\x81\x2a\xc4\x38\x0d\x31\xf1\x30\x0d\x91\xd4\x7f\x43\x48\x42\xcc\x42\x48\x62\xcc\x03\x41\x12\xcc\x03\x4e\x52\x2c\x02\x4e\x98\x07\x03\xa9\xd7\xc1\x80\xa6\xd0\x43\x41\x9a\x22\xa5\xe5\x7b\x2a\xf4\x3d\x2f\x48\xd2\xd0\xf3\x83\x38\x8d\xbc\x20\x88\xd2\xc4\x0b\x82\x30\x25\x52\x8e\xa6\x72\x19\xe8\xa7\xcc\x8b\x03\x2f\x15\x5e\x12\x60\x39\x91\x04\x88\x22\x8f\x04\x90\x7a\x9e\xe4\x50\xdf\x93\xca\x78\x28\x97\x9f\x34\x92\x4b\x51\x2a\x97\xa8\x29\x25\x3e\xf4\x09\x4d\x7d\xe4\x27\x94\xfa\xd8\x8f\x29\xf7\xe5\x6c\x26\x7c\x39\x7b\x40\x3f\xf0\x03\x86\xfd\xd0\xf7\xe5\x1c\xe7\x7b\xcc\xf7\x63\x1f\xb3\xc0\x27\x3e\x62\x91\x9f\x7a\x82\xc5\x3e\xf5\x38\x4b\x7c\xe6\x31\x46\x7c\xee\x51\x96\x06\xd0\x4b\x19\x0b\x90\x47\x18\x0f\xb0\x17\x33\x11\x78\x5e\xc4\x61\x10\x78\x21\x47\x81\xd4\xf3\x71\x10\x79\x3e\xf7\x82\xc4\xf3\xb8\x1f\x10\x0f\xf1\x20\xa0\x1e\xe4\x61\xc0\xb0\xe0\x51\xc0\x31\xe7\x71\x08\x31\xe3\x49\x88\x70\x2a\xe7\x5e\x4c\x78\x1a\xfa\x38\xe1\x69\x18\xe2\x98\xd3\x30\xc2\x21\x67\x61\x82\x03\xce\x43\x82\x7d\x2e\xe4\xdc\x29\x75\x5b\x8c\x04\x0c\x05\x86\x02\x45\x08\x09\x81\x22\x0f\x31\x81\x23\x1f\x51\xe1\x45\x21\x4a\x85\x5c\xf5\x27\xc2\x8f\x12\x14\x8b\x20\x4a\x51\x24\x02\xb9\x6e\x10\x61\xc4\x91\x2f\xc2\x18\x22\x4f\x44\x31\x46\x58\x44\xb1\x8f\xa0\x88\xe3\x00\x0a\x11\xc7\x11\xe4\x22\x8e\x13\x48\x45\x12\xa7\x30\x15\x49\x4c\x21\x11\x49\xcc\x61\x22\x48\x02\x61\x2c\x07\x15\x46\x82\x24\x3e\x8c\x44\x9a\x84\x30\x14\x69\x12\xa9\x30\x51\x61\xaa\x42\x06\x23\x41\x13\x21\x43\x82\x60\x2c\x28\xf1\x60\x22\x28\x09\x20\x11\x72\xed\x43\x05\x25\x31\x64\x82\x12\x02\x85\xa0\x84\xca\x35\x01\xe1\x08\x0b\x9a\x42\xe4\x0b\x9a\x62\x14\x0a\x39\x6c\xb1\x48\xd3\x10\x11\x21\xe7\x0e\x26\xd2\x94\x20\x21\xd2\x94\x4a\xb5\x3e\xe5\xd8\x13\x84\x42\x1c\x0a\x42\x31\x8e\x05\xa1\x3e\x26\x82\xd0\x10\x33\x91\xd0\x08\x0b\x91\xd0\xc4\xc3\x22\xa1\xa9\x17\x88\x98\x32\x2f\x12\x31\x15\x1e\x11\x11\x43\x1e\x13\x11\xf3\x34\x9b\xfb\x9e\x08\x59\xe4\x87\x22\x60\x89\x9f\x88\x80\xa5\x3e\x15\x3e\x63\xbe\x10\xbe\x1c\x5b\xe1\xcb\x51\x15\x1e\xf7\x02\x22\x3c\x1e\xc8\x69\x9e\x87\x21\x12\x98\xc7\x61\x20\x30\x27\x61\x22\x10\xa7\x21\x13\x88\xb3\x08\x09\xc4\x45\x14\x08\x24\x50\x94\x08\x2c\x70\xc4\x04\x16\x7e\x8c\x85\x27\x82\x38\x14\x9e\x90\x93\x9c\x2f\xe2\x98\x8b\x40\x24\x09\x16\xa1\x20\x49\x28\x62\x91\x26\x44\x24\x82\x26\x4c\x10\xc1\x08\x12\x54\x08\xe2\xb7\x53\x8b\xde\x38\xbc\xc1\x99\x85\xc1\x38\x8e\x10\x84\x51\x1c\x4b\x6d\x30\x4e\x50\x08\xa3\x98\xa0\x04\x86\x31\x45\x29\x0c\x63\x86\x18\x0c\x63\x8e\x21\x0c\x63\x21\xc5\x4c\x02\xb1\x0f\xc3\x04\xe1\x10\x06\x89\x94\xe1\x41\x82\x31\x81\x41\xe2\x61\x0a\x83\xc4\xc7\x1c\x06\x49\x80\x05\x0c\x92\xd0\x43\x30\x48\x22\xcf\x53\x61\x00\xfd\x24\xf6\x22\xe8\x27\x89\x17\x43\x3f\x21\x1e\x51\x21\x85\x7e\x92\x7a\x1c\xfa\x09\xf5\x84\x0c\x7d\x04\xfd\x84\xf9\x1e\xf4\x12\xee\xfb\x2a\x0c\xa1\x97\x08\x3f\x56\x61\x02\x65\xc1\x14\x7a\x04\xf9\x14\x62\x82\x7c\x0e\x31\xc1\x01\x54\x21\x82\x98\x78\x81\xa7\xc2\x00\x62\xe2\x07\x21\x44\xc4\x0f\x62\x15\x26\x10\x91\x20\x48\x55\x48\x21\x22\x61\xc0\x65\x18\x42\x15\x22\x08\x49\x14\x7a\x2a\xf4\x55\x18\xaa\x30\x82\x90\xc4\x61\xa2\x42\xa2\x42\xaa\x42\xae\x42\x21\x43\x89\x44\x12\x47\x18\x22\x12\x47\xbe\x0a\x03\x15\x46\x2a\x8c\x55\x28\x85\x66\x1c\xa5\x2a\x64\xd0\x23\x71\xc4\x65\x18\x43\xe8\x93\x38\x46\xd0\x27\x51\xec\xc1\x80\x44\xb1\xaf\xc2\x10\x86\x24\x8c\x23\x18\x91\x30\x8e\x61\x4c\xc2\x98\xc0\x84\x04\x71\x0a\x09\x09\x62\x06\x53\x12\xc4\x1c\x52\xe2\xc7\x02\x32\x22\xd7\x47\x9c\x78\x09\x86\x82\x78\x89\x8f\xe4\xea\x30\x40\x88\x20\x39\x69\x12\x94\xc4\xc8\x27\x30\x49\x50\x90\x88\x84\xa0\x30\x11\x09\x45\x51\xc2\x13\x86\xe2\x84\x25\x1c\x25\x09\x23\x10\x91\x84\x12\x84\xd2\x24\x25\x18\xb1\x84\x48\xc1\x95\x10\x12\x20\x91\x24\x24\xc4\x30\x89\x49\x84\x51\x12\x91\x18\xe3\x24\x24\x04\x7b\x49\x40\x52\xec\x27\x3e\xa1\x38\x4c\x7c\xc2\x70\x94\x78\x84\xe3\x38\xc1\x29\xc4\x49\x82\x52\x84\x49\x02\x53\x8c\xd3\x58\xa4\x1e\xa6\x31\x4f\x7d\xcc\x63\x96\x06\x58\xc4\x34\x0d\x3d\x18\xa7\x69\xe4\xa1\x98\xa4\xb1\x87\x63\xb9\x78\xf0\xe2\x38\x4d\x3d\x3f\x96\x4b\x88\x20\x8e\x52\xe6\x45\x71\x98\x72\x2f\x8e\x03\x29\xff\x63\x5f\xca\xff\xd8\xa3\xc8\x4b\x63\x4c\xb1\x47\x63\x44\x3d\x8f\xc5\x52\xf1\xe0\x91\xa0\x81\x0f\x23\x4e\x43\x1f\x45\x8c\x46\x3e\x8e\x28\x8d\x7d\x2f\x4a\x69\xe2\xfb\x11\xa1\xc4\x0f\x22\x39\x23\x84\x91\x9c\x11\xa2\x28\xa6\xd4\x4f\xa2\x88\x32\x5f\x2e\x4e\xb8\x9f\x2a\x9d\x9d\x46\x3e\x83\x3e\x8b\x3c\x86\x7c\x1e\x61\x86\x7d\x11\x21\xe6\x05\x28\x42\xcc\x0f\x70\x04\x99\x14\xf6\x82\x05\x81\x2f\x85\x74\x10\x84\x8c\x45\x41\x28\x97\x22\x41\x14\xa6\x2c\x09\xe2\x90\x30\x12\x10\x15\xa6\x61\xc2\xd2\x80\x86\x31\xa3\x01\x0b\x23\xc6\x02\x1e\x86\x8c\x07\x22\x0c\x18\x0f\x51\xe8\x33\x11\xca\xe5\x07\x0c\xbd\xd0\xe3\x28\x94\xcb\x0f\x1c\x06\x21\xe2\x38\x0c\x43\xb9\x86\x97\x7a\xb2\x5c\x48\x70\x1e\x84\x24\x60\x5c\x2e\x27\x18\x57\xcb\x09\x1e\x85\x3c\x48\x79\x14\x8a\x80\xf0\x38\x82\x41\xc2\x93\x08\x05\x31\x4f\x22\x1c\x44\x9c\x44\x7e\x10\xf1\x34\x0a\x82\x90\xa7\x51\x18\x04\x9c\x46\x51\xe0\x4b\x9d\x39\xf0\x38\x8b\x48\x80\x39\x97\x0b\x68\x2e\x22\xaa\x42\x1e\x40\x29\xba\x7d\x21\x60\x0c\x7d\x2e\x50\x8c\x7c\x26\x50\xec\xf9\x54\xe0\xd8\xf7\x53\xe1\xc5\x81\x0a\x23\x9f\x08\x3f\x8e\x7d\xc9\x9c\x89\x1f\x8b\x20\x4e\xfd\x48\x04\x31\xf5\x43\x11\xc6\xcc\x0f\x44\x18\x0b\xdf\x17\x51\x02\x55\x88\x7c\x4f\x44\x89\xe7\x63\x11\x27\xbe\x8f\x44\x9c\x48\x45\x2b\x91\x6b\x0a\x91\x24\xb1\xc7\x25\x99\x79\x5c\x90\x24\xf5\x98\x20\x09\xf5\xa8\x20\x09\xf7\x52\x91\x26\x52\x6e\xa7\x04\x79\x89\x48\x09\xf6\xd4\x9c\xa2\xc2\xc0\x93\xb3\x4c\xe8\x85\x72\x4e\xf1\x02\x41\x49\xe2\xf9\x42\x2d\x5d\x05\x23\x54\x85\xdc\xc3\x82\x11\xe1\x21\xc1\x52\xe4\x41\xc1\x52\x8c\x85\x60\xa9\xaf\xc2\x00\xcb\x25\x4a\x84\x99\xe0\x92\xa0\x04\x4f\x89\x0a\x53\x2c\x97\x31\x0c\xcb\x25\x0d\x97\x21\x85\x38\x11\x8c\x62\x15\x7a\x38\x16\x8c\x06\x38\x12\x8c\x86\x2a\x8c\x55\x48\xe4\x0a\x95\xa6\x38\x14\x94\x32\x1c\x08\x4a\xb9\x0c\x19\x54\x21\xc6\x81\x48\x99\x87\x7d\x91\xb2\x40\x85\x11\xf6\x05\x61\xb1\x0a\x09\xf6\x45\xc2\xa8\x0a\x65\xd9\x98\x09\x19\x72\x84\x03\x11\x71\xac\x42\x1f\x07\x6a\x7b\x2b\x14\x21\x8f\x71\x28\x02\x9e\xa8\x30\xc5\x91\xf0\x39\xc3\x91\xf0\x38\x97\xa1\x80\x38\x92\xb3\x0f\x8e\x04\x12\x72\xdd\x8c\x44\x80\x03\xbd\xd3\x22\xa0\x48\x30\x1a\xbe\x1a\xf4\x19\x9f\xa3\xed\xec\xa7\xb2\xe2\xff\x3c\xe7\x79\x9d\x91\xc5\xae\x47\x66\x5b\x3a\x04\x6e\x7d\x3f\x36\x35\x4e\xda\xc3\xf7\xa2\xdc\xce\x39\x30\x5d\x90\xd3\x33\x70\x08\x04\x59\x54\x7c\xad\x4f\x49\x75\x8a\x0c\x0e\xc1\xe4\x02\x3c\xb0\x7e\x71\x95\xb7\xdc\x0b\xd8\xf3\xca\xea\x34\x62\xa2\xe1\x7f\x03\x06\x4f\xe2\xd0\x0c\xd4\xca\x57\xac\x3e\xa7\xfe\x6c\x9e\x74\x1b\xaf\x88\x63\x5e\x74\x1b\x2c\x5c\xa5\x36\x5b\xe8\xab\xaf\x8e\x9d\x2a\x54\xec\xaa\xc3\xc5\x16\x25\x57\xad\xa6\x57\xd6\xad\xcb\x4d\xba\xa2\xcf\xc5\x31\xa2\x59\x71\x48\xab\x71\xa3\x3b\xbb\x83\x1f\x5a\x78\x0d\x3f\xb4\xde\xda\x67\x5e\x86\xf3\x14\xfb\x3e\xbc\x77\xef\x0e\xb8\x07\x7e\xe0\x75\x05\xea\x13\x0e\x16\xa4\xaa\x01\xd7\x2f\x09\x41\x21\xc0\x6f\xca\xd1\xe6\x6f\xf3\x3b\x40\xe5\xfb\xef\xaa\x26\x75\x46\xd5\xcf\x53\x7e\x9a\xf2\xf2\x85\x00\xc7\x3a\x25\xcb\x29\x07\x70\x8e\xe6\x50\x7d\x53\x52\xf3\x77\x45\xb9\xd4\xde\xa4\x55\xd4\x19\x29\xc9\x29\xf8\x5d\x45\x5c\x02\x05\x19\x1c\x9d\x70\xf3\xab\x2e\xc0\x3f\xcf\x79\xb9\x9c\xab\xbc\x1a\x4d\x15\xf8\xfd\xde\x25\x78\x69\x7e\x6f\x68\x20\xf8\x6f\x7e\x41\x4e\xcf\x16\xdc\x34\xf6\x78\x2e\x33\x4f\xde\xa0\x19\xc0\x33\xe0\x29\x67\xfa\xf7\xc0\xc3\x87\xe0\xf0\xaf\xc0\xbb\x23\x31\xd4\x70\xac\xca\xa8\x20\xb5\xcc\x6f\x08\xe9\xd0\x34\xef\xf0\x50\xbf\xe4\xfa\x06\x40\xb0\xaf\xe3\x56\x4f\xd5\x1b\xe2\x53\xe9\x6f\x5a\x0f\xa3\x6f\xc1\x3e\x38\xcf\x19\x17\x59\xce\x99\x1a\x32\x3d\x1a\x73\x33\x18\xe0\x50\xb5\x61\x40\x54\xff\xa9\xde\x3a\x95\x9c\xd0\xf1\x97\x48\x68\xd7\xcb\x0e\x06\xac\x7d\x05\x36\x0c\x7e\x9e\xaf\xe5\x16\x03\x63\xd7\x4b\x70\x67\x65\x71\x76\x5c\x2f\xcf\xf8\xf8\x95\x8b\x9d\x5f\x22\xba\xb0\xaf\xd1\xc7\x2e\xa0\x9d\xdd\xe6\x9f\xd7\xd9\xe2\xf8\xe7\xf3\x92\xbf\xe4\x39\xe3\x6b\xa6\xcb\x60\xb7\x2a\x3c\x5b\x45\xb1\x20\xe5\x2f\x75\xb6\x18\xc7\xa8\xb7\x63\x15\xbe\xa9\xe2\xa5\x1c\xf3\xf5\x55\x20\x6b\xda\xe3\x98\x5f\xd4\x5c\xbb\xc5\xd3\xb2\x77\x4e\xaa\x2a\x7b\x97\x83\x4f\x9f\xda\x99\x7b\x52\x93\xf2\x1d\xaf\xa7\xe0\x77\xf5\x82\x7a\x62\xdd\xf9\xa2\x03\xe5\x15\xbd\x3f\xcb\x1c\x80\xec\xfe\x7d\x99\x59\x59\xe5\x2e\xce\x4b\xca\x95\xbc\x30\xb9\xde\x64\x6f\x0f\x5a\x38\xef\xf9\x12\x64\xb9\xc9\x26\x0b\x65\xc2\x5e\x29\x9e\x9f\x95\x45\x5d\xc8\x81\x9d\x9f\x90\xea\xc5\xc7\xfc\xe7\xb2\x38\xe3\x65\xbd\xd4\xee\x8c\x75\x91\x99\x84\x30\x95\x05\x75\x23\xdf\xbc\xe7\x4b\xa5\x37\xa9\x54\xf5\x75\x00\x2e\xd5\x3f\xeb\xc4\x41\xe5\x3b\x50\x13\x8f\x42\x01\x2d\x39\xa9\xf9\xe3\x05\xa9\x2a\x67\x86\x03\xea\xe2\x52\xf3\xa5\x85\x94\x69\x41\xc6\x2b\x83\x93\x19\x90\xd4\x57\xad\xa0\x06\x6a\xd4\xa8\xc4\x21\xb4\x30\x5e\xd1\x32\x3b\xd3\x73\xb0\xca\xa5\xd0\xd2\x46\xcf\x79\x7e\x7e\xca\x4b\xa9\x22\x82\xc3\x91\x78\x39\x46\x4a\xcf\x72\xd3\x69\x91\x8b\xec\xdd\xb9\x2d\x59\x97\xe7\xfc\x40\x21\xf5\xee\x07\xb2\x38\xe7\x77\x25\xb6\xdb\xec\x53\xb7\xe8\xc7\x32\xab\x3b\xc5\xcc\x38\x74\xfa\xbe\x6c\x7a\xee\x94\x7c\xcf\x97\xee\xf7\xf4\xc0\x45\x78\x8b\xd1\xc7\x45\x5e\xd5\xe5\x39\xad\x8b\x52\x21\xae\x2e\x24\xd0\x6a\x06\xf4\x04\xfa\xb3\x45\xa5\x6c\x6e\x9b\x3c\x5d\x45\xbe\x03\xa8\xa5\x12\x17\xe4\x54\xf7\xb9\x03\x77\x1d\x94\x6e\x13\x0e\x6c\xd3\x9d\x1c\x92\x60\xc0\xe5\x64\xda\x50\x8d\xa4\x97\x99\xf9\x8b\x67\xe0\xb8\xe6\x52\x51\x6b\x67\x4f\x9d\xf2\x98\x2c\x16\x8f\x4f\x38\x7d\x3f\xc9\xf2\xaa\x26\xb9\xa4\x58\x07\xaa\xed\xed\x57\x4d\x32\xb0\x3f\x0a\xd1\xc9\xa8\x48\xfc\xa4\x2c\x3e\xaa\x37\xd6\x47\xcb\x33\xfe\xa4\x2c\x8b\x72\x72\xf7\x31\xc9\xf3\xa2\x06\x92\x27\x00\x01\xaa\x52\x40\x2a\x40\x1a\xbc\xdf\xd5\xc3\xe1\x36\xed\xac\xa8\xaa\x2c\x5d\x70\xa7\x02\xad\x4e\x4c\x2a\xbe\x10\x33\x05\xac\x69\x9a\x8c\xea\xd6\xfe\x92\x0b\x5e\xf2\x9c\xda\x26\x28\x9b\x0a\x27\xa4\xca\xf7\x6a\x90\x72\x2e\x75\xf6\x4c\xea\x82\x59\xc5\x95\x59\xa4\xf3\x33\x5e\x4e\xa6\x9d\x1c\xb2\x06\xce\x74\xd3\xec\x5d\x70\xd9\x83\xaf\xbf\x06\x13\x39\x98\x85\xd0\xdf\x87\x87\x87\xe0\x6e\xa1\xe8\xf0\xae\xba\x99\xda\x4f\x6b\x7b\x09\xbe\xd1\xd1\xfb\x40\xb6\xf8\xa0\xdb\xe3\x2c\x3f\xe1\x65\x56\x57\x93\xea\x3c\x7d\xac\x87\x4e\x35\x4b\xfd\xb6\x5d\x35\xc0\xdb\x04\xf0\x55\xa7\x0a\xd9\xba\x5e\xa2\xd4\x7e\x46\x87\xe6\x95\xcc\x2b\x35\xcb\x92\x57\x95\x6c\xc6\xe9\xb9\xd4\xd3\xb2\xfa\x84\x97\x20\xe5\x5a\x75\x2a\x4a\x67\xac\x66\x40\x8e\xe5\x5d\x70\x1f\xac\xb4\x45\xa1\xca\xb6\xbe\xa5\xfa\x56\x72\x6b\x39\x36\x71\x1a\xd8\x69\xae\xcb\x28\xbf\x03\xda\x8e\xfc\xbe\x92\x49\x8b\x73\xbe\x0f\x5a\xe4\xb4\x62\x66\x5f\x0b\x99\x19\xb0\xe2\x61\x5f\x49\x87\x19\x70\x25\x8d\x8e\x93\x64\x66\x39\xcf\x41\xae\x69\x5f\xc5\xeb\x9f\x6d\x13\x5e\x08\xf0\xcd\x70\xfc\xc8\x00\xb5\x6d\x9b\x1f\x1f\xab\x9e\xa8\xc9\xad\xcd\xa2\xc6\xdb\x28\xee\xff\x2d\xb2\x05\x7f\xf1\x81\x97\x1f\x32\xfe\x11\xa8\x29\x17\xfc\x50\x66\x4c\xa9\xb7\xfa\x3f\xc9\xc3\x2a\x41\xc6\x6f\x73\x1f\x7b\x48\x47\x18\xdc\x5c\xd6\x7c\x2f\x57\xb6\x4a\x24\xc8\x19\x58\xcb\x88\xce\xe4\x72\xfc\xb8\x38\x3d\x2b\x72\x9e\x9b\x9b\xa6\x2d\x81\x36\xad\x9a\x01\x27\x53\x77\x2d\xdd\xe4\x69\xd6\x61\x7d\x69\x23\x59\x72\xd6\xe6\xd3\xe5\x1b\x8d\x7c\x8d\x00\xd0\x05\xdb\x56\x38\xe8\xfe\xf4\xc9\x0e\xd9\xbb\xee\x90\xb5\xd5\x4c\xe7\xe4\xec\x6c\xb1\x34\x50\x9a\x39\x7f\xda\x2e\xc8\xdd\xe9\xd6\xed\xeb\x1b\xdd\x8f\xf7\x7c\xb9\x0f\xf6\x24\xfc\x62\xb1\x7c\x57\xe4\x3f\x93\xfa\x64\x6f\x66\x76\x0c\x14\x8d\x36\x48\xe8\x66\x9a\x94\x84\x65\xe7\x95\xc5\x87\x5e\xad\x28\xdd\x50\x3b\x13\xc9\x14\x03\x9c\x55\xb3\xc6\xf7\x3f\x00\xf4\x42\x8e\x8e\x9e\xa4\xe9\x45\x27\x65\xe9\xa4\x2c\xdd\x14\xb9\xb2\x2d\x1f\xe5\xef\x16\xca\xf8\xb3\xc9\xe2\x44\xca\xc5\x4a\xdb\x80\x33\xa2\x16\x4b\x7b\x7b\x07\x36\xd6\xc9\x3a\x17\x45\xf9\x84\xd0\x93\x49\x4b\x16\x44\x26\xcc\x40\xd6\x76\xc3\xc0\x29\xb2\xbc\xde\x86\x4c\x87\xf4\x4c\x6b\x66\x4e\x55\x7d\x54\x3c\x26\x65\xcd\xab\x8c\xe4\x9a\x5e\xe9\xc5\x0c\xd0\xe5\x0c\x68\xfc\xcd\x80\x6a\xc2\xb4\x69\xaf\x7e\x19\xd0\x69\x10\xd0\xdd\xba\x7f\x08\xf6\x9e\x81\x3d\x70\x5f\xb7\x6e\x7e\x01\xee\x83\xbd\x59\xfb\xbd\x3c\x68\x4a\x5c\x02\xbe\xa8\xf8\x30\x88\x9f\xb6\x04\x61\x7e\x5d\x4e\x6d\x5c\x03\xe1\xff\xb6\xd8\xb5\x17\xcd\x89\x5e\x80\xda\x62\x4a\x2e\xc8\xff\xee\x81\xef\x4a\xf2\x11\x90\x8b\xac\x92\xeb\x64\xd9\x67\xb2\x50\x5b\x08\x36\xdd\xac\xb1\xc1\xef\x6f\x24\x71\xbf\xbd\x54\x6b\x71\x99\xa1\x32\x39\x1e\xde\xd1\x26\x70\x5c\x7a\x2d\x95\x40\xf8\xb9\x1d\xda\x11\x92\x5d\xc9\x37\x19\xa2\x57\xbc\x0d\xc1\xe2\x71\x8a\xc5\x3d\x92\xcd\xf2\x9c\x97\x2f\xd5\xf0\x3a\x79\x9c\x58\x37\x73\x71\x5e\x0f\x64\x76\x62\x37\x31\x03\x1e\xe6\x06\xa5\x4a\xb8\xf9\x3f\x7d\x02\xee\xb7\xd1\x92\x5d\x3a\x33\x23\x21\x67\x49\x3b\xe6\x97\x2e\x6f\x19\xde\xb6\x6b\x98\x49\x5b\xb2\xaa\xcb\xe2\x3d\xdf\x07\x7b\xff\x87\x52\xba\x67\xcb\x6e\xf1\xb2\x67\x68\x0d\xf5\xe6\xee\x7b\xc5\x3e\x4a\xe8\xf1\xca\x5a\x93\x7a\x54\xd7\x65\x96\x1a\x07\x06\x6f\xa7\x93\x76\xc4\xa6\xd3\x3e\x3d\x5e\x61\x99\x3f\x27\x66\x22\x7f\xa2\xb7\x73\x26\x4d\xa7\xf6\xde\xed\xb5\xb8\xff\x5d\x6b\x7a\xcf\xc9\x29\x57\xf4\x47\x4f\x48\x59\x57\x0f\x14\x42\x1f\xbc\x2b\x33\xf6\x40\xf1\xf1\x1e\xb8\x6c\xcb\xb8\xd8\x3e\x25\x67\x8e\xd8\xe1\x79\x5d\x2e\x7b\x62\x47\x23\x59\x3b\xe5\xfa\xac\x82\xc7\x25\x44\xa0\x5a\x32\x3d\xe8\xb5\x82\xe7\x5b\xcd\xd1\xbb\xb7\xc1\xa5\xef\xa6\x0d\x4e\x23\x6e\x60\x1c\xf7\xa4\x10\xd9\x9b\x39\xe4\x7a\x69\x56\x8f\xb3\x0e\xd6\xad\x4c\x91\xd9\x1f\x48\x51\x98\xcd\x3a\xa9\x17\x68\xdf\x18\x4e\xbb\xe8\x26\x2c\x9b\x84\x65\xaf\x04\xde\x57\x16\xd8\xfa\xf9\x4d\xf4\xd2\x89\xbd\x9c\x3a\xb8\xbf\x9c\x9a\x9f\xd3\x75\xb2\x94\x16\x39\x95\x18\xcb\x28\xa0\x59\x49\x17\x8d\xa0\x6c\xb6\x36\x9f\x9f\x9f\xa6\xbc\xbc\x34\x33\x8c\x12\xa8\xe6\xa7\xd4\xe4\x55\x99\xb1\x22\x59\xce\xf8\x05\x50\x45\xf4\xcf\xd1\x12\x9a\x38\x2e\x01\xbf\xa8\x4b\xa2\x96\x71\xe0\x89\xfc\xa9\x51\xbc\x22\xdd\x15\x83\x9b\xa1\xb9\xec\x82\x1c\x17\xf0\x8f\x9b\xae\x3e\x56\x05\xd6\x4a\xf9\x7e\xe6\x89\x9d\x60\x55\x47\x66\x4e\x43\x87\xe6\x00\x6f\x9b\x39\xc0\x1b\x9f\x03\xbc\x39\x5d\x1e\xdc\xf9\xb7\x90\x96\x2e\xf9\x8b\x6c\xb1\xd8\x07\x7b\x79\x91\x73\xa7\x21\x0e\xaa\x6e\x52\xb2\xee\x51\x33\x8a\x1b\x78\x72\x93\xa4\x6d\x39\xe0\x01\x75\xe9\xa2\x25\x1f\x1d\xad\xb9\x59\x8d\x7e\x0b\xfb\x62\x1f\xb8\x83\x48\x97\xfb\xc0\x9d\xbd\xcb\x7d\xc3\x2b\x77\x7a\x0c\xba\x91\x19\xcf\xb4\x6e\xbc\x89\x1b\xe5\x7f\x5d\x8e\x34\x05\x37\xb0\xa4\x2d\xd7\xb0\xe5\x48\xb1\x6b\xf1\x65\x17\xe6\x36\x8c\x69\x56\x04\x5b\x72\xa6\xc9\xbd\x2d\x6b\x7e\xe1\xa1\x55\x1e\x3a\x53\x0b\xb4\x9b\xe3\xa0\xb3\xce\x00\xb6\x03\x2d\xeb\x19\x62\x20\xb6\xaf\xe5\xe4\xf0\x6a\x70\x95\x6b\x36\xb1\x8d\x5c\x1a\x6c\xa0\xca\xc7\x23\xb9\xeb\x82\x15\xe0\x85\x31\x3e\xaa\xce\xe5\x72\x72\x7a\x95\x59\x65\xcd\x62\x77\x28\x6b\x7f\xf1\x20\xf1\x60\xd7\x0e\x1d\xd9\xaf\xa7\x04\x7f\x74\x4a\x51\x23\xd1\xd3\xf9\xfd\xb9\x13\xeb\x66\x96\x03\x76\xa4\x37\x9e\x6c\x4e\x1b\x35\xa4\xed\x1b\xb0\x8d\xb6\xaf\xbf\xb7\xd5\xf6\xff\x78\x35\xba\x25\x8d\x55\x5d\xda\xf4\x65\x1b\x5d\xda\xf4\xa0\x45\xde\xe1\xa1\x9d\x16\xf6\xc0\x37\x66\xec\xe6\x23\x9a\x43\x0b\x72\x7f\x2c\xa7\x95\x64\x4d\xd6\xf5\x6a\xdc\x20\x21\xae\x25\xbd\x1e\xb1\x75\x97\x89\x2d\x59\xb9\x2b\xc5\x2e\x39\xb8\x25\xfe\x72\x08\xe0\x9f\x7f\xec\x3b\x03\xae\xba\x38\xb0\x7e\x1f\xcc\xd1\xe7\xd3\x81\x01\x78\x3b\x75\x2f\x3e\x34\x1b\x61\x07\x77\x2e\xb7\x39\xd0\x7d\x73\xb7\xd9\x1a\xbc\xfb\x76\xda\x1c\x43\xcc\x59\x56\x9d\x2d\xc8\x52\xf6\x09\x1c\x82\xbd\x06\xec\x5e\x9b\x45\x0e\x93\x24\xc1\xee\x44\x76\xb9\xce\xc6\xe0\xf0\x1c\xa5\xad\xa5\xfe\xfc\xf2\xc9\xab\x27\xcf\x8f\x1e\x1d\x3d\x7d\xf1\xfc\xf8\xd1\xd1\xd1\xcb\xa7\xdf\xfe\x72\xf4\xe4\x95\x36\x5b\x28\x47\x58\x6a\x38\x57\x3d\x07\x9e\x93\x79\xae\xd4\x0d\x89\x5d\xa9\x12\x5d\x0b\x80\xb3\xc0\xbc\x26\x24\x87\x86\xaf\x05\xe9\x4e\x67\x31\xbe\x13\x28\x75\x97\xe2\x85\xd8\xfa\x64\x7c\xa5\x15\x8a\x72\x1d\x31\xf6\x07\xb6\xc2\x4a\xc5\x9d\x9a\xa0\xbc\x80\x4f\xde\xec\x35\x8a\x43\x23\x57\xdf\x4e\xef\x5c\xba\xbc\xa1\x8b\xfc\x6c\x94\x38\x4b\x9b\xd0\xd2\x18\x5c\xa1\x15\xb8\x32\xe6\xb0\xdb\xdc\xa6\xd2\x3b\x97\xe6\x04\x50\xdb\x02\xd7\x55\x5e\xc7\x96\x75\x67\xe7\xbe\x77\xf9\x65\xad\xf9\x4d\x03\x6a\xfc\xc2\x8b\x94\xde\x29\xa9\xb8\xd4\xc2\xf9\xe9\xf9\xe9\xd8\x15\x01\x3f\x34\xb2\x4d\x66\x7e\x5a\xf3\x92\xd4\x9c\x8f\x5e\x22\xc4\x4e\xe6\x67\x23\xf7\x38\x26\x9e\x32\xc7\x64\x4f\x69\x8e\x4e\xb2\x0a\x9c\xf2\xfa\xa4\x60\x20\xab\xc0\x22\x7b\xcf\xc1\x6f\xc7\xf3\xd3\x2c\xff\x0d\xf0\x0b\xca\xcf\x6a\x50\x9f\x90\x1a\x64\x35\x20\x54\x7e\x56\xe0\xb7\xcc\xb4\xe3\x37\xf0\xf1\x24\xa3\x27\x40\x6a\x5f\xf7\x40\x96\x7f\x28\xde\x73\xa6\x8e\xe0\x39\xa1\x27\xcd\x55\xa8\x2c\xb7\x57\xa1\x40\x5d\x80\x77\x3c\x57\xa5\x95\x6a\x46\x4b\x09\x4b\xce\x6f\xe9\x52\x03\x93\x90\x64\x8a\x9a\xff\x64\x8b\x4a\x92\xbf\xe7\x6c\xae\x97\x39\x16\x01\x59\xd5\x54\xf7\x31\xab\x4f\x40\x91\xf3\xe6\x9c\x63\x1f\x4c\x54\xe1\xe9\xd6\x37\xc3\xfc\x39\xec\xdf\x0c\xfb\x89\xd4\x27\xdb\x5d\x0c\x33\x6d\x02\xc5\x07\x5e\xce\xdd\x22\xdf\x1b\xa2\xb8\x04\x6f\x6c\xbb\x0f\x8f\xe7\x19\xe3\x79\x9d\xd5\xcb\xb7\xbd\x0e\x99\xde\xa8\xa3\x4a\x8d\xb7\xf5\x97\xcd\x4e\xb3\x3c\x93\x74\xa3\xba\x3a\x74\xc5\x4c\xe9\x07\x6a\xdd\x23\xf9\xec\xcd\xef\x60\x2f\xdf\xdb\x07\x48\x29\x1d\xfa\x37\x06\x97\x6f\x0f\x9a\x0b\x69\xa7\x59\xfe\xed\x72\x62\x4a\x38\x96\x63\x0a\xc7\x74\x4c\x31\xcf\xb5\xdd\x98\xe6\xb2\x5a\x0b\xd6\x00\x7a\xf8\x50\x75\xec\xb7\x63\x35\xc5\xf1\xb2\x5e\xfe\xd6\xf6\xb2\x3a\x29\xca\xfa\x84\xe4\x6c\x3e\x58\xe7\x5e\xbe\x37\x0a\xdb\xb9\x11\xa7\x4b\xa9\x01\x98\x35\xb0\xbb\xae\xe7\xf4\xe8\x7c\xfd\x75\xe7\x32\x9c\x35\x55\xee\xf2\x9d\x05\xe3\xb2\xd7\xc4\xc2\x9c\x01\x3c\x9d\x19\x66\xd2\x85\x37\xde\x94\x53\x6d\x1b\xb8\x2a\xb7\xd6\x54\xec\xd6\xd2\xe2\x25\xc9\xdf\x8d\x71\x7f\xe2\x43\xc3\xfd\x59\x65\x7b\xf2\x58\x1d\xd0\x8f\x48\x01\xcf\x64\xaf\x0b\xed\x51\x61\x14\x2e\x72\xc4\xc5\x63\xa5\xd2\x55\x80\xc8\x11\x56\xf6\x78\x7e\x03\x45\xd9\x7c\xbc\xcc\xde\x9d\xd4\xbf\x35\xc4\xd3\x70\xe0\x59\x99\x7d\x20\x35\x77\xd9\x23\x2d\x8a\x05\x27\x92\x3b\x44\x59\x9c\xaa\x82\x6f\x81\x36\xda\xbe\x34\xa3\x9a\xe5\xef\x80\x4c\x04\xa5\x4c\x95\xcc\xb6\xe0\xa2\xcf\x17\x2d\x9b\xb9\xec\x91\xf3\x8f\xda\x5c\x50\xa7\x2d\x0e\x11\x69\xdd\x54\x21\x74\xd2\x34\xa0\x43\x44\x03\xee\x34\xba\x3e\x16\xf4\xdd\x16\x7e\x26\xe9\xcc\x5e\x14\x90\x9f\x5f\x1d\x82\x3d\x3d\xaf\xee\xc9\xa4\xee\x70\xac\x42\x6b\x55\x70\xbd\xc1\xae\x60\x1c\xba\x84\x06\xda\x9d\xa6\x87\xe0\x49\x5e\x9d\x97\x5a\x7a\xaa\x3b\x62\x85\x00\xbf\x3d\x80\xbf\x49\x91\x78\x56\xf2\x8a\x97\x1f\xb8\x64\x2f\xb5\x1b\xa2\x4f\x0d\xec\x00\xeb\xaa\x8d\xfa\x2b\x1b\xaf\xea\x3b\x74\xaa\x5a\x6d\x0a\x29\x6b\xbb\x16\xb0\xe0\xa0\x69\x50\xf7\x34\x51\x17\x68\xaa\xe2\x39\xeb\x6c\x91\x99\x4e\xe9\x3f\x6e\x95\xe0\x1b\xa0\xdb\x05\xfe\xa2\x60\x7c\x03\x10\xd8\x07\x0f\x90\xba\x41\xde\x36\x9c\x9f\x75\xef\xa3\x37\xdc\xb0\x82\xcf\x19\x68\x87\xb3\x35\xfd\xb4\xc2\xa8\xce\xf8\xaf\xb2\xab\xbf\xd6\x36\x70\xf7\x92\x32\xf8\xf6\x3c\x5b\xd4\x0f\xb2\xdc\xce\xa2\xa5\xbd\x97\x53\x19\x57\x27\x45\xc5\xf5\x2c\xa5\xc6\x4c\x2e\x0a\x72\x19\x90\x0a\x14\xea\x0e\xca\x6f\x8b\x82\x91\xea\xe4\x37\x03\xa0\x9a\xcb\xca\x95\x8d\x2c\xe5\x4b\xe1\x31\xcf\x16\xd6\xce\x1b\xe5\xd9\x42\x73\xad\x4e\xfb\x89\x5c\xd8\xa4\x53\x72\xe1\xce\xea\x5c\xa1\xa8\xef\x7b\x45\x12\x4b\xc3\xb7\x24\x67\x7d\xc6\xd5\xf3\x39\x2b\x78\x95\xef\xd5\x12\x10\x2d\x78\x49\xb9\x73\xbb\x70\x0d\x47\xe7\x66\x6f\x52\x0f\xa7\x6c\x82\xfe\x55\x08\xd5\x73\x6d\xed\x6b\xa8\x80\x1c\x77\x99\x5d\xfe\xdd\x98\x59\x91\xd0\x51\xa3\x21\xc8\x19\x38\xa7\xa5\xb9\x74\x5d\x02\xc6\xed\x47\xba\x9c\x7f\x0e\x79\x63\x34\x01\x57\xd8\x68\x41\x53\x08\xa0\xdb\x58\xf5\x44\xcd\x76\xb4\xda\x5c\xee\xd6\x7b\xb9\x87\xe0\x41\xf3\x9e\xa3\xb9\xee\xdd\x0c\xfa\xa4\x25\x8d\x49\xdf\xed\x9d\x96\x49\x9f\x3e\x01\x34\x9d\xce\x00\x6c\xd6\xc6\x25\xaf\xf4\xe5\x5e\xd5\x83\x89\x99\x13\xd5\xfa\xf7\xe3\x49\xb6\xe0\xc0\x44\x3d\x78\xd0\x3e\x2b\x90\x25\x5a\x7c\x81\x6f\x6c\x53\xf6\xc1\xfd\xfb\xaa\x9d\x6f\xbb\x52\x42\x0f\xf8\x7d\xcd\xe8\xfa\xb6\x49\x6b\xbd\x4d\x41\x1b\xe6\xc6\x06\x45\x03\xbc\xb8\xd6\xd2\xf3\x56\x53\x67\x5d\xe8\x6d\xf3\x31\x57\x12\xb1\x67\x66\x38\xf0\x4b\xc5\x99\x64\xcc\x1e\x0f\x7f\x20\x65\x56\x9c\x57\xe0\x37\x0d\xe7\x37\x7d\x71\x8b\x48\x7e\xb0\xbc\xfa\xf4\xf9\xf7\x4f\x9f\x3f\x3d\x7a\x0d\x0e\x01\x02\x0f\xed\xcb\x9c\x9f\x1e\xfd\xfd\xf8\xe9\xf3\xa3\x27\x3f\x3c\x79\xa9\x8c\x2d\x46\x49\x14\x26\x1e\xf2\xfc\x38\xc4\x1e\x0a\x22\x7e\xdf\x83\xb1\x33\xbb\x16\xf9\x07\x2e\x31\xf2\x9b\x22\x6e\xa5\x2f\x13\x20\xf4\xf4\xac\x89\xeb\x0a\x4a\x2d\xc2\x7d\xad\xf6\x19\xc9\xdf\xb9\x3c\x71\xef\xd2\x70\x51\x87\x9f\xa8\x6e\x45\x8f\xee\x2d\xff\xb9\x84\x6f\x72\x72\xe6\x34\x6e\xf5\xa9\x43\x23\xc6\xbd\x39\xee\x3c\x74\x98\xe3\xd5\x3c\x1a\xc3\xf3\x9f\x9e\x3e\x3f\xfe\xdb\xa3\x67\xbf\x3c\x71\x0b\x04\xfc\x81\x87\xfd\xd5\x32\x4f\x73\x85\xa2\xa5\x9b\x77\x04\xd7\xab\x85\xf7\xbc\x39\xde\x5b\x6d\x96\xc3\xbf\x4d\x56\xbd\xac\x68\x0c\x75\x7e\xe5\x7c\x37\x54\xae\xb1\x28\xa7\x38\x08\xbe\x31\x5f\xfb\x7a\xce\xbc\xbc\x03\x6c\x72\x43\x92\x06\xe6\x81\x01\xd9\x96\x6e\xe8\xe9\xd3\x27\x07\xe6\x03\x1b\xed\x3e\xe0\x52\x6a\xc0\xa1\x2d\xfc\x17\x55\xf1\x03\x39\x8b\xa2\xee\x9c\xa9\xf2\xdd\x73\x69\xb2\xc7\xa1\x6d\x3d\xfa\x57\xa7\xfd\x43\x6c\x6b\x31\x33\xc0\xb5\x7f\x2a\x0b\xdf\x7a\x82\x3d\xce\x2a\xab\x2c\x8e\xdf\xc9\xdf\xd1\x54\xf1\x60\x1d\xd7\x7a\x34\x32\x00\x6f\xd7\x47\x1e\x9f\xe5\x69\x0c\xba\x81\xa7\x31\xe8\x7a\x4f\x63\xf0\x67\x7c\x1a\x83\x6f\xea\x69\x0c\xbe\x81\xa7\x31\xde\xe7\x7f\x1a\x73\xd5\x77\x2b\x77\xbe\xbc\x5c\xf9\xf2\x72\xe5\xcb\xcb\x95\xcf\xf8\x72\x45\x6f\x8b\xfd\x9a\xd5\x27\xc5\x79\xed\x54\x5b\xa4\xff\x50\x54\x5b\x59\x62\xd0\x08\x05\x87\xe0\xf7\xcb\x03\x97\x8c\xb2\x1c\x14\xe9\x3f\x2c\x42\x64\x89\xb9\xd2\xd9\x5f\x88\x49\x36\x05\x7f\x55\xa7\x7f\xb4\xc8\xeb\x2c\xb7\x63\xfc\xd5\x56\x9c\xa3\x1a\x90\x4d\xdd\xc2\x86\x79\x32\xc9\x3a\x45\xfa\x0f\x45\x8c\xab\x1c\xf3\xe5\x5d\xce\x97\x77\x39\x5f\xde\xe5\xfc\xb9\xde\xe5\xb4\x57\x71\x07\xde\xe6\x34\x89\xdb\xbe\xcf\x19\x52\x54\x3e\xcb\xfb\x9c\x4e\xcb\xd6\xbc\xd1\xe9\xe4\xdb\xf0\x4e\xa7\x93\xf7\xca\x6f\x75\x3a\xa5\xb7\x79\xaf\xd3\xad\xee\x8a\x6f\x76\x7a\xfd\x7f\xb3\x7a\x8f\xe4\x59\x96\xf3\xa7\x35\x3f\x5d\x7b\x9f\xc4\x66\x9a\x14\x67\x9a\xc1\xce\x56\xef\xdb\x2d\x4c\x1e\x70\x08\x3e\x14\x19\x93\x6b\x41\xe7\x42\xc9\x15\x16\x08\x73\x32\xcf\xaa\xbf\x91\x45\xc6\xec\x95\x10\x5d\xeb\xd4\xbd\x84\xe2\xd4\x76\x35\xd0\x74\x51\xe4\xbc\x0b\xd8\x76\xa7\xb9\xcd\xa2\xb7\xac\xd7\x37\x7b\xed\x4a\x6e\x32\xdd\xd0\x66\x9d\x3a\x19\xac\xb7\xfb\x98\x48\xd9\x32\xd1\x0a\xde\x05\xea\xdf\x21\x6f\x92\x96\xa8\x7f\x8b\xbc\x2d\x85\xfb\x37\xc9\xdb\x52\xbd\x24\xa9\x25\xdb\x34\xa9\x6b\x75\x12\xd5\x26\xb4\xba\x87\x32\xa6\x71\x98\x9b\x84\x6f\xf6\x2e\xd0\xde\x0c\xec\x2d\x55\x78\x81\xd5\x6f\x15\xbe\xe7\xcb\xbd\xb7\xee\x5d\xfd\xdd\x47\x71\xf3\x6d\xfd\xcf\x79\x99\x53\xe3\x62\xda\x7d\x0b\x70\x81\xf6\x41\x77\x88\x96\x68\x1f\x74\x47\xe6\x02\xef\x83\xee\x80\x2c\xf1\x3e\xe8\x8e\x83\x7b\x25\xd4\x8d\x57\x5c\xfb\x9e\x2f\x9d\xbb\x62\xd3\xb1\x0b\x58\x16\xb1\x6b\x2f\x52\xd6\x27\x1c\x9c\x14\x65\xf6\xaf\x22\xaf\xc9\x42\xdd\x94\xe8\x3c\x9e\xea\x9f\x6a\xb7\x79\x7f\x2e\xb2\xbc\xae\xec\x24\x7c\x46\x2a\xa9\xa3\x64\xb9\x54\x99\xf4\xb5\xdb\xa2\x6c\x0e\xf0\x99\xde\x2b\xb7\x12\x65\xe5\xba\xe6\x0f\x65\x71\x7e\x76\x09\x7e\x6c\x1b\xb2\xdd\x03\xae\xb6\xc0\x5a\xd1\xd5\x66\x9b\xf4\xdb\x7f\xb5\x1b\x99\xa3\x17\x32\x9d\x77\x89\x9d\x0b\xfe\x1f\x33\xa6\x76\xe3\x4d\x9a\xfa\x74\xd3\x1d\xd4\x37\x99\xda\xb8\xde\xf5\xcc\x15\xdc\x7f\xfa\x04\x56\x22\xaf\x78\x51\x53\xa9\xff\x35\x3f\x95\x5d\x5b\x01\xb5\xf9\x9e\xe4\xf0\x25\x6b\x75\xb7\x46\xdd\x7a\x1c\x78\x2e\xa3\x58\xa4\xcf\x21\x1a\x76\x9f\x49\xc0\x7d\xb0\x82\x31\xfd\x08\xa6\x97\x7b\xdd\x03\x1c\xb5\x8e\xd9\x07\x99\xc3\x32\x8e\xf4\xb1\x73\xb6\x7b\x49\xb3\x99\xe9\x5a\x84\xac\x4c\x0f\x57\xb8\x93\xbd\x59\x76\x5d\xe9\xba\x23\xb5\xd3\xb9\xbe\xee\xda\xb6\xb1\x73\xfb\x51\x8d\x69\xff\x16\xe3\xa0\x04\xf8\x20\x25\x37\xdd\x86\xf7\x6d\xce\xcf\xc0\xf9\x7f\xb3\x8d\xd8\x8e\xef\x6d\xf6\xb5\x5c\x6f\x33\x4d\xba\xed\x1e\xe0\x78\x6f\x9c\xe3\xc7\x9f\x76\xba\xcf\x37\x3b\xc4\x78\xc2\xd5\x01\x58\x9b\xaa\x23\xdc\x2c\x0d\xce\xdb\x4c\x36\xaa\xc7\xf3\x3d\x9c\x4b\x8e\xef\x46\x5d\x83\xdf\x7b\x80\xae\xcb\xed\xde\x18\xb7\xaf\xb0\xab\x9a\x13\xfb\xdc\xbe\x9a\x4b\xce\x8a\xe0\x3e\x58\x45\xdf\xcd\xb0\xbb\xd7\x67\x77\x8b\x8f\x3f\x2f\xb3\xdb\x16\x6e\x66\xf5\x11\xc6\xf9\x96\xd0\xf7\xef\xca\xe2\x3c\x67\x6b\x59\xa7\xcd\xd6\xbb\x45\x2e\xf5\x92\xee\xf5\x71\x19\xd3\xa3\x59\x95\xe9\xd3\x27\x93\xf9\xf0\xd0\xe8\x31\x57\x21\xd1\x4d\x6f\xea\x24\xe8\x17\x67\x84\x66\xb5\xfb\x82\xce\x89\x1d\x9e\x9c\xbd\xee\xec\xec\x96\x5d\x8e\x4f\xdb\xde\xc0\xbc\xdd\xe5\x71\xcf\xf0\x78\x8b\x88\x1b\x20\x14\x49\x05\xf5\x9e\xcb\x4e\x17\x9d\x99\x73\xd9\x61\x22\xd5\xc4\xfd\xfe\x7c\xa9\x9b\xb5\xbf\xc2\x43\xcd\xeb\xa7\x9e\x86\xa9\xf5\x4e\x19\x76\xe3\x0c\x56\xf7\xc1\x20\x8a\xb7\x21\xdd\xf4\xdd\x9e\xc3\x4e\x6b\x89\xf4\x2a\xcf\x1a\x36\xbd\x94\xb9\x70\x5e\xbd\x8c\x8c\xbd\xbf\x6e\xec\xfd\x8d\x63\xef\x0f\xc8\xf7\x01\xb5\xce\x77\xf4\xba\xb5\x53\x81\xdf\x4c\x05\xc3\x10\x1f\x17\x45\xc9\xb2\x9c\xd4\xbc\xfa\x41\x4f\xb2\xda\x2e\xe4\x4a\x2d\x43\x19\x87\x6a\xde\x00\x70\x5d\xb6\x0e\xa6\x1f\x5d\x64\xee\x6b\x24\xf5\xdd\xc1\x78\x2f\xc3\xb2\x9f\xa1\x10\xa2\xe2\x2e\x62\x75\x44\xe7\xc1\xac\xa4\xad\x5f\x7b\x23\xd4\x46\xae\x64\xfd\xb1\x3f\x56\x4e\x6c\x57\x6a\xe9\x61\xff\xcb\xa1\xf6\xa7\x69\xc6\xd8\x7e\x5e\xa8\x2d\xca\xfb\x17\xf2\xf7\x52\xff\x5e\x5e\x5d\x9c\x05\xa3\x54\xba\xa2\xd9\xdb\x06\x07\xf3\x7e\xd2\xd0\x08\xae\x14\xea\x26\x74\x3b\xba\xfb\x76\xc6\x7a\xd2\xea\x6c\x73\x0c\x74\x68\x7d\xe9\xc9\xef\x9a\x3e\xf6\xf5\x9f\x99\x95\x67\xc3\x63\x6b\xc5\x9a\x33\x9a\x33\x43\x3e\xfb\x96\x8c\x2e\x57\x17\xc6\xd7\xeb\xfe\x3a\x46\xe8\x74\x7e\x65\x58\xd6\x95\x9c\xfc\xae\x39\x67\x5f\xff\xf9\x3c\x1d\xff\x63\xd5\x96\xb1\x67\x59\xae\x96\x31\x1b\x20\x1d\x75\x59\xb6\xcd\xbe\x6e\x15\x3f\x5b\x41\x7e\xaf\xf0\xd8\x62\x60\x40\x6f\xea\x3e\xf4\xea\xec\x9e\xae\x7f\xec\x85\xae\xf8\xd8\xab\x03\xfa\x0f\x7c\xf0\xb5\xf6\xbd\xd7\xf0\xe5\x86\xce\x23\xab\xb5\xcf\xbd\xb6\x28\x6f\x28\xfe\x5a\x30\x2c\x63\x5c\x0f\x48\x43\x56\x3b\x01\x52\x0f\x9b\xe4\xc0\x4d\xde\xec\x52\x5a\xed\x55\xae\x1b\xe4\xd1\xa2\xe6\x15\xc8\x4e\x65\xa5\x7a\xb5\x53\xc1\xb4\x28\x16\x6f\x15\xe3\x59\x96\xfa\x82\xb4\x2b\x20\xad\x2f\xc2\x76\x42\xde\xe6\xd7\x7c\x1b\xa8\xbe\x33\x7e\x7f\x78\x43\xd6\xab\x08\x3b\x35\x4c\x8d\xd4\x9d\xf5\xca\xee\xb5\x00\x9b\xc9\x7b\x77\xda\xbd\x03\xac\xe6\x73\x2d\x18\x56\x09\xb8\x16\x90\x56\xe9\xb8\xa6\x24\x75\xf4\x93\x6b\x40\xda\xf4\x1a\xd4\x3e\x06\xb5\x6f\x41\xcd\x44\x02\xdd\x09\x01\xf6\x05\xbb\x3a\x73\xef\x48\x2d\x1b\x63\xde\xa3\x35\x04\x02\x0a\x31\x7a\x36\xb2\xca\xbe\x6f\xde\x3a\x30\x48\x5a\xd1\xac\xaa\x88\x82\x31\xbc\xc3\xda\xe7\x3a\x59\xfe\x4e\xdf\x2e\x89\x04\xd9\x31\x0f\x72\xd3\xcf\x56\x57\x0e\xb2\x7b\x77\x73\xbd\x3f\xd3\xdd\xdc\x63\xbb\xab\xfc\x58\xdf\x52\x57\x0c\x2d\x29\x6d\xf4\xfe\x61\x10\xed\x7a\x63\xf5\xb8\xd1\x61\x8f\x9f\x65\x39\x1f\xad\x01\xe3\x1d\xaf\x01\x63\xb7\x8a\xbf\x4b\x09\x30\x5a\x47\xec\xef\x7c\x17\xb4\xad\xe2\xf5\xfa\x2a\xae\x79\x17\xb4\xa1\xa3\x0d\xf7\x41\x91\xbe\x63\x3b\x70\xbb\x44\x62\x19\xa8\xd1\x74\x6e\x96\xec\x4c\xd7\xdb\x38\xa6\x18\xa7\xa6\xc1\x7b\x28\xbf\x5b\xb9\x66\x56\x3b\xb2\xc1\x2a\xbf\xe2\xd2\x1f\x4a\x72\x76\xa2\x41\x64\x0b\xb6\xfe\x61\xfc\x0a\x6d\x0d\xd4\x27\x61\x92\x8b\xac\x6a\x56\x12\x52\x44\xfc\xae\xa2\xcc\x53\x76\x35\xf3\xec\xcd\xc0\x23\x93\x6b\xbd\xa0\x5d\x25\xb6\x81\x4a\xf5\x8b\x5f\xa7\x8e\xe5\x15\xea\x18\xa2\xb6\xc1\x3a\x54\xdf\x44\x51\x9e\x92\x5a\xe6\xfa\x89\xac\x05\x3b\x46\x61\x16\x74\x07\x90\xac\xe0\x8e\x3a\x13\xef\x0b\x32\xff\xf6\x7c\x05\xa5\x59\xce\xb2\xfc\x5d\xcf\x53\x50\x7b\x05\x9c\x4d\x06\xeb\xbb\x9b\xde\x9d\x75\xfc\xb5\xd8\x25\x28\xff\xc0\xf3\xfa\x31\xcf\x6b\x5e\xea\x27\xd5\x37\x58\x27\x19\xa9\xf3\xd5\xeb\xe7\x8f\x8f\x9f\xfc\xed\xc9\xf3\xa3\x95\x2a\xb7\x97\xd7\xaa\xe1\xe3\xc2\x20\xf1\x77\x14\x3a\x2d\xe4\x6b\x3d\x9b\xb0\x40\x9a\x2b\xea\x0e\xa2\xc1\xa1\xba\x83\x78\x95\x36\xcc\x89\xba\xb2\xab\x5e\xcb\xb6\x80\xe6\x15\xaf\x7f\x22\x17\xcf\xb2\xaa\x96\xe2\xc6\x1c\x3f\xae\xc9\x30\x51\x22\xf2\xd2\x34\xa9\x1d\x07\x70\xd8\x6e\xb0\xcc\xab\x65\x4e\x7f\x2a\xce\x2b\xfe\x44\x35\x62\x6f\x95\xde\xd7\xfa\xc6\xea\x3c\x4b\x7d\x08\x1e\x17\x67\x4b\xfd\x8e\xf1\xff\x2d\x96\x6a\x4d\xf4\x34\xa7\x73\xf5\xe8\x53\x3f\x3b\x7d\x5e\x30\xf5\x82\x4b\xdf\x80\x29\xca\x6a\x7e\xe7\xe1\x43\x59\xf2\x67\x5e\x9e\x66\xfa\x4a\x66\x56\x81\x13\x5e\xf2\x74\x09\xde\x95\x24\xaf\x39\x9b\x01\x51\x72\xf5\xd6\x51\x36\xfa\x1d\x9f\xa9\x27\x6a\xf9\x12\x9c\xf1\xb2\x2a\x72\x50\xa4\x35\xc9\xf2\x2c\x7f\x07\x88\x04\xa5\x1c\x16\xa9\x27\x9d\x59\x05\xaa\x42\xd4\x1f\x49\xc9\x55\x1b\x48\x55\x15\x34\x53\x87\xc9\xac\xa0\xe7\xed\x13\x55\x39\x7f\x54\x60\x52\x9f\x70\x09\xe0\xee\x2b\x53\xe8\xee\x54\x55\xc5\x38\x59\x80\x2c\x57\x57\x5c\x6c\x92\x7a\x5c\x5b\x9c\xd7\xa0\xe4\x9a\x83\xd5\xd5\xaf\x2c\xa7\x8b\x73\xc9\x3e\x12\x8c\xcd\xb1\xc8\x4e\x33\x53\x8f\x7a\xb8\x29\xf1\x53\x49\xb8\xe7\x95\xba\xb3\x79\xb6\x9c\x81\xd3\x82\x65\x42\xfe\xe5\xaa\x7f\x67\xe7\xe9\x22\xab\x4e\x66\x12\x0c\xcb\x2a\x73\x5f\x68\x06\x2a\x19\x4f\x79\x2e\x0b\x92\x9c\x3d\x2c\x4a\x50\xf1\xc5\x42\x02\xc9\xb4\x9a\xe9\xb6\x51\xe5\x91\x15\x9d\x49\xe4\xd6\x12\x98\xc6\x98\xaa\xfd\xe3\x49\x71\xda\xed\x52\x56\x01\x71\x5e\xe6\x59\x75\xc2\x55\x31\x56\x80\xaa\x50\x95\xca\x29\x50\xc6\x18\x04\x89\x62\xb1\x28\x3e\x4a\x84\xd3\x22\x67\x99\xec\x5a\xb5\x6f\x06\x52\x2b\xad\xc5\x07\xae\x7a\xa6\x89\x21\x2f\xea\x8c\xea\x21\x50\x83\x72\xd6\x0e\xb6\x49\xaa\x4e\xc8\x62\x01\x52\x6e\x30\xc8\x99\x04\x95\xe5\x80\x38\x9d\x2b\x65\x4b\xd4\x0b\xc8\x8c\x2c\x80\xa4\x3b\x59\x6f\xbf\xd3\x96\xa0\x8e\x7e\x7c\x02\x5e\xbd\xf8\xfe\xe8\xd7\x47\x2f\x9f\x80\xa7\xaf\xc0\xcf\x2f\x5f\xfc\xed\xe9\x77\x4f\xbe\x03\x77\x1f\xbd\x02\x4f\x5f\xdd\x9d\x81\x5f\x9f\x1e\xfd\xf8\xe2\x97\x23\xf0\xeb\xa3\x97\x2f\x1f\x3d\x3f\x7a\x0d\x5e\x7c\x0f\x1e\x3d\x7f\x0d\xfe\xe7\xe9\xf3\xef\x66\xe0\xc9\xdf\x7f\x7e\xf9\xe4\xd5\x2b\x09\xea\xc5\x4b\xf0\xf4\xa7\x9f\x9f\x3d\x7d\xf2\xdd\x0c\x3c\x7d\xfe\xf8\xd9\x2f\xdf\x3d\x7d\xfe\x03\xf8\xf6\x97\x23\xf0\xfc\xc5\x11\x78\xf6\xf4\xa7\xa7\x47\x4f\xbe\x03\x47\x2f\x54\x9d\x06\xda\xd3\x27\xaf\xc0\x8b\xef\x65\xe9\x9f\x9e\xbc\x7c\xfc\xe3\xa3\xe7\x47\x8f\xbe\x7d\xfa\xec\xe9\xd1\xeb\x19\xf8\xfe\xe9\xd1\xf3\x27\xaf\x5e\x81\xef\x5f\xbc\x04\x8f\xc0\xcf\x8f\x5e\x1e\x3d\x7d\xfc\xcb\xb3\x47\x2f\xc1\xcf\xbf\xbc\xfc\xf9\xc5\xab\x27\xe0\xd1\xf3\xef\xc0\xf3\x17\xcf\x9f\x3e\xff\xfe\xe5\xd3\xe7\x3f\x3c\xf9\xe9\xc9\xf3\xa3\x39\x78\xfa\x5c\x02\x7b\xfe\x02\x68\x1e\x7e\xf5\xe3\xa3\x67\xcf\x54\x85\x8f\x7e\x39\xfa\xf1\xc5\xcb\x57\xb2\x95\x8f\x5f\xfc\xfc\xfa\xe5\xd3\x1f\x7e\x3c\x02\x3f\xbe\x78\xf6\xdd\x93\x97\xaf\xc0\xb7\x4f\xc0\xb3\xa7\x8f\xbe\x7d\xf6\x44\xd7\xf6\xfc\x35\x78\xfc\xec\xd1\xd3\x9f\x14\x61\x7d\xf7\xe8\xa7\x47\x3f\x3c\x51\x05\x5f\x1c\xfd\xf8\xe4\xa5\xca\x69\xda\xf8\xeb\x8f\x4f\x54\xd4\xd3\xe7\xe0\xd1\x73\xf0\xe8\xf1\xd1\xd3\x17\xcf\x25\x7e\x1e\xbf\x78\x7e\xf4\xf2\xd1\xe3\xa3\x19\x38\x7a\xf1\xf2\x08\xbc\x78\xa9\xf0\x23\xb3\xfe\xfa\xf4\xd5\x93\x19\x78\xf4\xf2\xe9\x2b\x89\x9c\xef\x5f\xbe\xf8\x69\x06\x24\x76\x5f\x7c\xaf\xf0\xf7\x5c\x16\x7d\xfe\x44\x03\x92\x98\xef\x0e\xd0\x8b\x97\xf2\x5b\x02\xfb\xe5\xd5\x93\xb6\x45\xdf\x3d\x79\xf4\xec\xe9\xf3\x1f\x5e\xc9\xf2\x6e\xfe\xb9\x73\x91\x5c\x09\xae\x27\xa7\x59\x5d\x37\x67\x7a\x6a\xbb\xd6\x88\x55\x7b\x54\x62\x3f\x3f\x7d\x02\xbf\x5f\x1e\x34\x99\x4e\x1d\x81\xd9\x64\xed\x44\x7e\xfa\xd4\xb5\xbf\xb1\xf2\x20\xd1\x6d\xc0\x81\x12\x83\xdf\x12\xfa\xfe\x23\x29\x59\xf5\x80\x16\xa7\x67\xa4\xd6\x2f\xf1\x73\x29\xfb\xe0\x1c\xc1\xf9\xc5\x1d\xb7\xcc\xdc\xfd\x58\x85\xd7\xc9\xda\x3e\x92\x68\xbb\xe7\xb4\x6e\x2c\x6f\xaf\x97\x4e\x09\xd5\xdc\x56\x27\x76\x01\x54\xe0\x63\xb6\x58\x80\xb3\x32\xcb\x6b\x40\xc0\x47\x52\x2a\x19\x9b\x09\x70\x5a\x28\x63\x10\x24\x07\x08\x82\x45\x03\x98\x94\x4a\x3a\x10\xc6\xb4\xfc\xc8\xea\xb9\x36\xf5\x93\x55\x80\x48\x69\x27\xce\x17\x4d\x4d\xfa\xd5\xff\x09\x5f\x9c\x55\x40\x68\x9d\x03\x9c\xf2\xd3\xa2\x5c\x82\x05\x27\xef\xab\x79\xb7\x33\xa6\xd8\x4f\xdd\x8e\x20\xa8\x7b\xf0\x22\xfd\x90\x15\xe7\xd5\x62\xa9\x2e\xeb\x4b\xa1\xd1\xf4\xa1\x3a\x29\xce\x17\x4c\x8a\x16\x25\x87\x75\xcb\x10\x34\x2d\x6b\xa8\x88\x48\x89\x56\x49\x58\xca\xf2\x50\x5d\x18\x61\x54\x72\x52\x71\x36\x07\xaf\xb8\x8a\xfc\x17\x2f\x0b\xf5\xdc\xe5\x3c\x37\xe0\xe6\x63\x48\xef\xcd\xc6\xae\x0b\xbd\xdc\x79\xcf\x9b\x55\xe6\x51\x6e\xae\x16\xe2\xb9\x7a\x4b\xfb\xe9\x13\xc8\xaa\xe7\xe4\xf9\x24\x9f\xea\x83\x05\xfd\x98\xa1\x7d\xc8\xb0\x67\x5e\x2e\xa4\x1c\x10\x70\x56\x54\x59\x9d\x7d\xb0\xaf\xb5\xd5\xc3\xe2\x61\xf2\xce\x1d\xdf\x6c\xfa\x9e\xd2\xe5\x38\x85\xf1\xd3\xac\x76\x5b\x2d\x23\x5b\x8b\x01\xbc\x9c\x81\x13\x92\xb3\x85\xfc\xb1\xe0\xb9\xba\x3f\x5e\xcd\x40\x36\x6b\x29\x42\x1d\x7f\xa8\x5e\xba\x2c\x68\x7b\xd4\xe1\xd1\xdf\xb5\x37\xc0\x87\x0f\xc1\x53\x25\xcf\xf5\x74\x94\x17\x60\x8f\xcb\x0e\xef\x69\x45\xa7\x01\x2d\xb3\xe4\x1a\x2b\x73\x53\x47\xdd\x18\x57\xd4\x25\x5c\x8b\x29\x9d\xfa\xe7\x2a\x1d\x7c\xfa\xd4\x1c\xf5\x4c\xb2\xca\x2c\xf3\x56\xf3\x4d\xc1\xd7\x5f\x83\x81\xf2\xf6\xba\x94\x63\xbe\xa4\xec\x3c\x19\xd4\xce\x21\x6d\x0b\x78\xe9\x3e\x23\x7a\xa2\x21\xff\xee\x1c\x66\xc9\xf1\x95\x6a\xb9\x14\x81\xb9\x46\x2c\xeb\x76\xde\x9e\xc5\xf5\x2f\x76\x3f\x7c\x08\x1e\xd5\x92\x69\xaa\x1a\xbc\x93\x64\x50\x15\xa7\x1c\xbc\xcf\xb4\x61\x0b\xa9\x6c\xf1\x0b\x3b\x7b\x4b\x2e\x2c\x3b\xd7\xb0\x78\x69\x55\x54\x43\x59\xbf\xe4\x94\x9c\xab\xe3\xc0\xf3\xbc\x52\xa6\x2a\x32\xce\xc0\x5d\xd5\x92\xbb\xba\x25\x73\x30\xd9\x03\xf7\x65\x87\xef\x83\xbd\xe9\x9e\x63\x71\x92\x97\xea\x35\x9f\xaa\xf1\x50\xf6\x67\xa5\x87\x65\xd7\xa0\xff\xa5\x7d\x69\x60\x68\xa9\x27\xae\xb5\x2b\x86\x86\x8e\xb2\xea\x17\x2b\xba\x26\xa6\x80\x61\x10\xfb\x6e\xaf\xf1\x3e\xaa\xb3\xdb\xf3\xd7\x36\xb7\x41\x5c\xf5\x31\xab\xe9\x09\x98\xf4\x1f\x82\xb6\x83\x22\xf5\x1c\x89\x52\x4a\x2a\x7b\x91\x50\xfd\x06\x68\xbf\x3d\x62\xd4\x50\xf5\x13\x35\xd9\x6e\x07\x15\x69\xc9\xc9\xfb\x03\xb7\x20\x5e\x53\x70\xd6\xa1\x9c\xb5\x60\xbc\xad\xc1\xb8\x5f\x78\x14\xe8\xc3\x87\xa0\x5a\x14\x1f\x1b\xba\x30\xa2\xb6\xad\x45\x32\xb6\x35\xe1\xe1\x0a\x38\xa9\x8a\xea\xaa\x9b\x6a\x66\xcd\xfb\x7f\xb7\x79\xbd\x57\x26\x95\x7b\x48\xda\x3e\x8f\x68\x98\xb0\x3f\x56\x3b\xd5\xbf\x70\xc4\x9e\x6d\x87\x2a\x31\xb1\x19\x78\x0e\x0e\xdb\x6c\x8e\xf3\x4a\xa0\x1f\x34\x3a\x6f\x62\x17\x3c\xd7\x4f\x61\x4d\xd7\x9a\x52\x6f\xb2\xb7\xc3\xbd\xbb\x74\x4e\x7e\xd5\xc3\xd4\x75\x92\x96\x30\x66\xa5\x74\x5f\xe0\xb6\xd2\xb4\x15\xbd\xa7\xad\x5c\x75\x28\xbc\xc9\x37\x32\x63\x34\xa2\xb3\x9d\x38\x6c\x4d\x7b\xd3\x9d\x24\xf5\x51\x01\x88\x7a\x9d\x53\x72\x7a\x5e\xea\xb5\x9b\x5e\xe3\x28\x3a\xd5\x13\xa9\x95\xca\x77\x73\xfe\xd1\x76\xf2\xee\x57\xe0\x5b\x2e\x8a\x92\x6b\x38\x84\xa9\xd9\x3f\x6b\x84\x54\x83\xde\x19\x10\x59\x59\xd5\x40\x4d\x45\x1d\x08\x8d\xd4\x77\x05\xb3\x93\xc1\x69\xba\x2c\x3c\xd9\x73\xd2\xf6\x66\xaa\x59\xdd\x17\x29\x00\x0c\xe0\x72\xde\x22\xff\x9b\x5e\xee\x95\x2c\x60\xbf\x1d\xaa\x61\x74\x6a\x61\xa6\x5b\x26\x95\x16\xd7\x5e\xb4\xc2\x58\x21\x94\x51\xc1\x06\x34\xf8\xae\xc8\xf7\x6a\x90\x73\xa9\xb5\x9c\x70\x6d\xc9\xdb\x58\x01\xd4\x67\x2d\xf3\x95\x11\xd2\x95\x38\x94\x2d\xa9\x71\x95\xc7\x06\xda\xd5\x34\xec\xa9\x00\x1f\xf9\xde\x07\x0e\xc8\xa2\xe4\x84\x2d\xc1\x3b\xa9\x54\xe5\xc0\x98\xad\xfb\x87\xa4\x1f\x72\x76\xc6\x73\x36\x56\xfd\xfc\xec\xbc\x3a\x99\x38\xe8\xd0\x4d\xb0\x15\x3c\xd2\x03\xae\x4c\x53\x71\xb9\x84\x04\xcd\x19\xaa\xee\x6b\x21\x57\xfa\xf9\x3b\x65\x19\x46\x5b\xd3\x1b\xef\xe7\x9b\xd5\xd8\x96\x69\xde\x5a\x5a\x55\x6f\xee\x14\x5f\x37\xe3\x25\xd5\xcc\x66\xa2\x18\x47\xcb\xca\xfc\x6f\xba\x28\xf5\xe1\xd6\x7a\x99\xe1\xc6\x76\x7a\x5a\xd5\xbf\x1c\x55\xe1\x74\x70\xa9\x31\x68\xe3\xec\xb4\xb7\x22\x18\xd2\x84\x3b\xd7\xf2\x65\x4b\x4e\x65\xa3\x4f\xc1\x5f\x01\x6c\x6e\xaf\x74\x1b\x6f\x4c\x2a\xfd\x15\x9c\xb6\x8d\x1a\xed\xa3\x7d\x5b\x6f\x27\xa1\x22\xaf\x0a\xb9\x02\xd2\x72\x65\x22\xd7\x35\x53\xbb\x3c\xd8\x07\xf6\xd1\x62\xa7\xd5\x56\xb5\xdf\x03\xf7\x7b\x7c\xa4\xff\xdb\x93\x83\x01\x18\xaf\x39\x95\x3a\x35\xf8\x2f\xe6\xae\x2b\xe4\x82\x62\x3e\x5e\xf6\x97\x8a\x2b\x09\x31\xb4\x07\x36\x6d\x8c\x75\x49\x06\x53\x3a\xfb\x7c\xaf\xcf\xf9\xa3\xfd\x6f\xec\x55\x19\x09\xd1\xbe\x48\xb6\x48\xa8\x4b\x42\x8d\xda\xd9\x4a\xd3\xae\x72\x26\x97\x24\xd5\xf9\x99\x5c\x2e\xea\xe7\x0d\x4f\x9f\x00\x04\xdb\x3b\xaf\x2e\xa4\xc9\x74\x44\x3d\xda\x56\x69\x2f\xf2\x3e\xbd\x0c\x4e\x33\xeb\x00\x28\xd3\x17\x6b\x27\xa1\x9b\x9f\x7a\xf4\x95\xf0\x52\xd1\xda\x80\x07\xf9\x77\xcd\x65\x5d\x73\x13\xeb\xb4\xf8\xc0\x6d\x5f\x4c\x13\xdf\xd9\xcb\xf5\xe6\xea\x78\xe9\x9a\x16\xb4\xb0\x5d\x3a\x6e\xc4\xec\xf0\x23\xd8\x83\xee\x00\xbc\x6b\x05\x7d\x57\xb6\xaa\x16\x35\x88\x7a\xd7\xb9\xf3\xd5\x0e\xd7\xc3\x87\x8a\x44\xe5\x42\x78\xaf\xdb\x7c\xbb\xb4\xc9\x84\xe8\x4c\x7e\xe0\xa3\xb2\x09\x26\xb3\xb2\xb1\xc1\xea\x42\xda\x46\x77\x90\x31\x33\xb3\x62\x2c\xf2\x99\xb1\xad\x36\x03\xd9\x6d\xe9\x14\xea\xe5\xc9\xd8\xac\xd8\x41\xdb\x1d\x3d\x44\x23\x2b\x02\xc7\x42\x9d\xcc\xe5\xa8\x6f\xb6\x73\xca\x9c\x5d\xd3\x08\x0d\xea\xb0\x1d\xbb\x76\x01\x38\xe9\xf5\xd8\x99\xf5\xbf\xfe\x1a\x74\x62\x3a\x10\x1a\x81\xce\xf8\x82\x2b\xe3\xc2\x43\xcd\x1c\xd0\x53\xba\xc3\x36\x75\xe5\xaf\x56\x56\x7a\x14\x62\xf4\x95\x9e\x7e\x31\xa4\x3a\xcb\x1c\x4d\xb3\x1a\x2d\xb6\x31\xe6\xf2\xe0\x81\x9c\x13\x0e\x5a\xbe\xb0\x98\x51\x56\x34\x06\x91\xa3\x10\x64\xb2\xb4\x68\x30\x78\xe9\xc4\x0d\xa2\x06\x80\xce\x80\x64\x23\x6b\x90\xcb\xfe\x0c\xd6\x94\xf9\x0b\x80\xd3\xee\xe5\x53\xe7\x81\x95\x6d\xbe\x9d\xcf\x64\x13\x50\x5b\x75\x27\xc9\xda\x10\xdd\x38\x5c\xbd\x09\x58\x01\xa9\xce\xd4\xd2\xa1\xe5\x1b\x34\x5d\x99\x74\x6f\x7a\x88\xaf\x28\xf9\x35\xc0\x47\x8b\xc5\xe0\x96\x53\x77\xf3\x46\xd9\xbe\xd9\x6a\x9b\xa6\x8f\x73\x33\x9f\xe9\xb2\xca\x76\x65\x51\x82\x6e\x5f\x66\x20\x2f\x1a\x3d\x4e\x76\x76\x08\x7a\x1f\x41\x8e\x1a\xd5\x5f\x92\x6b\xc3\x76\xd3\x01\x2d\xc5\xac\x46\x64\x74\xc3\x0a\x63\xa2\x65\xe3\xb0\x77\x7a\x6a\x70\x6f\xa4\x76\xaf\x83\xaa\xcf\x64\xb1\x70\x54\x14\xbd\x83\xa8\x25\x79\x75\x67\x6d\x3f\x5c\xe6\x34\x96\xa4\x3a\x68\xef\xf0\xa6\x7a\x44\x7f\x78\xb8\x32\x67\x38\x76\x70\x5c\xbc\xac\xd2\x80\x84\xd0\x31\x8a\x3b\x96\x6f\xa5\x86\x83\xb1\xc5\xdf\x18\xb2\x16\x2b\xfb\xe8\x23\x7b\x38\x2b\xd3\x4b\xab\x1a\x8f\x4f\xef\x6d\xde\x83\xae\xec\x5b\x74\x0f\x44\xd5\xa0\x3d\x7b\xfa\xfd\x0b\x50\x94\xcc\xec\x69\x58\x53\xa3\xbd\xb5\xfe\x74\x15\x75\x63\x95\xbe\xe9\x97\x05\x0f\x80\xd9\xa6\x91\x68\x5d\x43\x5a\x57\xe0\xe0\xc5\x66\xc6\x2d\x79\x7d\xb0\xcb\xac\x2a\xd7\x49\x6f\x7b\x2b\xc1\x66\x18\x46\xd7\x82\xa6\xe0\x6a\xfa\xdb\xce\x8a\x4e\x67\x1b\x50\x9f\x9d\xfd\x96\xc6\x1e\x6b\xbd\x15\x0a\x1e\x17\xe7\xf9\xc8\xe6\x73\x9f\xc9\x5d\xab\x94\xfc\x83\xa3\xa4\x8d\x8c\xc6\x0a\x15\xb6\x85\xa6\xbd\x99\x06\xf5\x64\x8b\x93\xb3\x9b\xb1\x4d\x70\xf4\x10\xc7\xc8\x25\x1c\xe8\xf4\x68\x57\xcd\x52\x46\xcf\x08\x1d\xeb\xe0\x7c\xa8\xa8\x46\x8d\xae\xa0\x51\x98\x9d\xee\x91\xf2\x5d\x07\x88\x59\xc0\x90\xf2\x5d\x6f\xd9\xa2\xee\x0a\x38\x10\xcc\xb9\xc4\xa6\xf2\xe6\xd0\xa1\x5f\xda\x28\x24\x9b\x4a\xeb\x6d\x8c\x3d\x6d\x36\xff\x5d\x63\xc0\xa9\x0f\xad\x5d\x57\xf7\x01\x5a\x48\xd6\x4c\xcc\xe5\xaa\x59\xd0\xf0\xcb\xd5\xc3\xe3\x6f\xc9\xb8\xf9\x46\x8c\xe3\x2f\x37\x0f\x6f\xe2\xe6\xe1\xb7\xa4\xfc\xb7\xba\x78\xf8\x2d\x29\xaf\x7d\xef\x50\x11\xd6\x97\x6b\x87\x9f\xfd\xda\x61\xf4\x67\x12\x62\x9f\xcf\x04\x2e\xbc\x29\x13\xb8\xf0\x06\x4c\xe0\xa2\x5b\x94\xd6\xf8\xf8\x58\xb9\xe4\x3a\x6e\x7d\xcc\xad\x95\x76\x28\xc0\x3b\x4b\x54\xa7\x22\xed\xde\x6a\x43\x4d\x3b\x5a\x6b\xf6\x07\x9c\x72\x8f\x7a\x86\xd9\xad\x8a\xa0\xe9\x4c\x36\x7e\xb3\xde\x4b\xc2\x31\x89\xfd\x73\xb6\x7a\x55\xfc\x33\x8a\xec\xb5\x04\xb5\x95\xc8\xfe\x39\xdb\xe9\xaa\x78\x17\x4f\x23\xe2\x5a\xa9\xca\x46\x70\x66\xd6\x8a\xdf\x82\xbf\xe3\x39\x7b\x5c\xe4\xb5\x72\x73\xb5\x47\x65\x55\x25\xd7\x6e\x5a\xd7\x0b\x78\x62\x89\x78\x7b\x21\x3f\xcc\x02\xdb\x48\xfa\xb2\x21\xe4\xed\xc5\xfd\x08\x1f\xdc\xa0\xd0\xef\xfa\xa3\x4f\x87\x05\xfe\xec\x4e\x73\xe8\xae\x1e\x25\xed\x9b\x15\xcd\x82\x2c\x8b\x73\x85\x73\xe3\x86\x54\x9f\x5b\x28\x7f\x17\x0a\x3b\xfb\xd6\xe5\x03\xcf\x99\x89\xf0\x42\x13\x45\x2f\xf6\xc1\x5e\x00\xff\xcb\x14\xa2\xcb\xce\xe7\xaa\xb3\xbb\x9e\xbb\xbb\xbd\x18\xfe\xd7\x9e\xb2\xab\x71\x07\x80\xe6\x1d\x71\xbf\x65\x57\x95\xe3\x8e\xd3\x3e\xdb\xa7\xb7\xd3\xd5\x5e\xed\x00\xb6\x7d\x31\xe6\x62\xe3\x9a\x80\xd6\x3b\xb0\x5c\xdf\xc5\x4d\x2f\x51\x37\x35\x60\x97\x8a\xe5\xa4\x9e\xbf\xb3\x18\x5d\xef\x3d\xf3\xcf\xde\xfa\x2d\x5d\x77\xfe\xd9\xbb\xb1\xa5\xdf\xd0\x3f\x6f\x37\xd4\x46\xc6\xa0\x46\xba\xd6\x19\xe5\x17\x6f\x1b\x5f\xbc\x6d\x7c\xf1\xb6\x71\x15\xad\x5c\xe3\xa9\x3a\x2d\x8a\xfa\x64\x5c\x95\xdd\x79\x1b\xa5\x0b\xfe\x1a\xbd\xed\x83\xda\x75\x6d\xa0\x5e\x1c\xe7\xe4\x74\xcd\xc0\xee\xb8\xc2\xe9\xc2\xbe\x46\x57\xbb\x80\x76\x5e\xa1\xd0\x22\xaf\x49\x96\xf3\xf2\xf8\xd5\x79\x29\x08\x1d\x5f\xa9\x24\x3b\xca\xa6\xd0\xad\xe4\x19\x59\xae\xf3\xd5\x92\xec\x56\x45\x74\x7c\x5c\x9d\x90\x33\x7e\xfc\x92\xd3\x5a\x69\xf6\xe3\x1b\x71\x3b\x8e\x5b\x7c\x45\x77\x30\x3b\x54\x91\x48\x44\x99\xf5\xca\xf1\x51\x51\x2c\xea\xec\x6c\x4d\x25\x3b\xee\x8b\x22\xf8\xf9\x7d\xe7\x20\x64\xf7\x95\xe4\x72\x70\x3d\xb6\x30\x6e\x9d\xe7\x7c\xf1\x1c\xf3\xc5\x73\xcc\x0d\x79\x8e\xc1\x07\x5f\x1c\x32\x7d\xf1\x9e\xf3\xc5\x7b\xce\x17\xef\x39\x5f\xbc\xe7\xdc\xa2\xf7\x9c\xa3\x92\xf3\x53\x72\xb6\xb2\x6d\xdd\xba\xd0\x91\x2a\xce\x79\xcd\xd5\x63\x7b\x67\x8e\x77\xa2\x27\xc7\x25\x17\xed\xb5\x12\xc6\xcf\xb4\x21\xd4\x92\x8b\xb9\xfa\xb0\x57\xa4\x73\x0d\x43\x25\xc8\xdf\x36\xde\x3a\x0c\x56\x09\xea\xc3\xa6\x28\xd4\xff\x8f\x72\xfe\xa1\x12\xed\xf7\x81\xa9\xcb\x6e\x20\x83\x43\x05\x7c\x6e\xbf\x9b\x7b\xc0\x2a\xe2\x3b\xd3\x22\xdd\xb2\xfb\xfa\x2a\x86\xd3\x37\xf6\xb8\x05\xd3\x40\xfc\xfa\xeb\xe6\xb7\xbd\xa6\xf3\x4d\x1b\xd3\x35\x4b\xae\xa2\x1d\xb3\xe4\x96\x69\x1d\x1c\xfd\xae\x6b\xdf\x77\x5a\x34\x53\x6d\x36\x31\xb3\xc6\x46\xf8\xac\xe9\xf5\x7e\xdb\x7f\x6d\x3e\xf3\x52\x8e\xb5\xb5\xe7\x2a\x3b\x60\xbd\xb1\x3a\x7e\x6d\x24\x81\xad\xe9\x44\x7b\xc3\x45\x97\xec\xa3\x60\x5e\x72\x76\x4e\xb9\xd3\x39\xed\xf6\x78\xa6\x01\xb5\x37\xca\x3a\x4e\x91\xc1\x7d\x9d\xac\x07\xc8\x5c\x11\x9b\x01\xe8\xde\xaf\xea\xd6\x6b\x9e\xa4\x16\x8c\xbf\xb1\x9d\x7c\xab\x1f\xad\x76\xa2\xb4\xb1\xdb\x6f\x00\x94\x1d\xef\xa4\xf4\xef\x34\x76\x6c\x52\x2a\xea\x32\x35\x5a\x04\xec\xaf\xf4\xb5\x63\xd1\x59\xfd\x99\xd9\x51\xd2\x74\xdb\x8c\x89\xfc\x73\x47\x1b\x89\xb6\x6e\x13\x45\xb6\xa8\x79\x29\x17\x30\x2e\x5b\xb4\xb1\xe6\x29\x83\x73\xbb\xe4\x77\x70\xa1\x3b\x31\xbf\x98\x81\xa5\xf9\xb9\x6c\x6c\xab\xaa\x4f\x6d\xd7\xb9\xb1\x13\xa6\xe2\x8c\xd9\xdf\xcb\xe6\xf2\xf7\x63\xdd\x0f\x75\xc3\x9b\x94\x9c\xa8\x59\x9f\x13\x7a\xa2\xfb\xaa\x9c\x51\x33\x50\x58\x7f\xb8\x5f\x83\x8a\x92\x05\x9f\xab\x66\xbf\xe3\xf5\xa3\x92\x93\x17\xc2\xa1\xf9\xf6\x6a\x7c\x3f\xb1\xa1\xa4\x99\xaa\xe8\x6f\x12\xde\x4b\x52\x67\x85\x73\x8b\x4c\x7e\x2a\x75\xca\x4d\x37\x5e\x7c\xe5\xb0\x75\x13\xdc\x4b\x6c\xeb\xb8\xc9\xbd\x89\xa5\xfa\x78\xe8\x52\x18\xb8\xa7\xeb\xed\xf9\xb8\x72\x49\xc0\x70\x95\x25\x57\x09\x63\xdf\x50\x9d\xfc\xad\x68\x4d\x01\x76\x28\x4c\x7e\x6b\xda\x35\xec\xd6\x47\xb9\xf6\x1a\x5d\xd1\xa2\xe4\xc6\x37\x3e\x07\xed\xbb\xd6\xb2\xf8\x38\x93\xea\x85\x8c\xfd\x58\x94\x55\x0d\x88\x4c\xac\x75\x5b\x1b\xfc\xff\x2a\x93\x5e\x29\x18\x5d\xdc\xb7\x09\x13\x05\xea\x8c\x94\x3c\xaf\x5f\x65\xff\xe2\x33\x03\xa9\x87\x7b\x9d\xe1\x91\x46\x4f\x9b\x1b\xdc\x73\x3e\xac\xa8\x28\x8b\x8f\x26\x63\x59\x7c\x9c\xab\x9e\xdf\x6b\x7e\x36\xf2\xf2\xb8\x2c\x3e\xfe\x3f\x5a\x04\x98\x9c\xdb\xc9\x03\x4b\xe2\xf6\xa1\x51\x96\xef\x1b\xaf\xfe\x59\x6e\x4a\xc8\x9f\xa6\x94\xaa\xb3\x31\x8f\x7b\x4a\x2e\x6c\x66\x72\xd1\x64\x26\x17\x9d\xcc\x7a\x58\x0e\x8c\x75\x76\x5d\x81\x75\x9b\x3d\xd3\x20\xa0\xda\x4e\x6e\x1a\xa0\xe6\x8c\xa6\x37\xaa\xf6\xb6\xc2\x7e\x22\xb9\x70\x09\xd3\xe2\xea\x9b\xb6\x59\x0e\xaa\xef\x29\x00\xf7\xdc\x21\x01\x0f\x6d\x99\x59\x53\xf8\x21\xe8\x15\xca\xf2\x6e\xa1\xa9\x94\xe6\xb6\x0f\xad\x60\x71\x8d\xf8\x35\x77\xdd\x1b\xf4\xaf\xa6\xae\xd2\x8a\xfe\xfd\x52\xd9\x20\xcd\xaa\xef\x17\xe7\xd5\x89\xc3\xaf\xc5\xc7\xc6\xfe\xb8\x43\x32\xa6\xab\xda\xf0\x71\x43\x21\x0f\x9d\x2c\x53\xed\x46\xbb\xbd\x79\x2b\xe1\x4a\x2e\x6a\x21\xfe\xd5\xa9\xda\x88\xad\x86\x40\x56\xaa\x75\x32\x35\xb2\x5c\x4d\xca\xe7\xe5\xdf\xbb\x99\x2e\x3a\xd3\xbd\x33\xdd\x81\xde\xd6\xc1\xcc\x3c\xc4\x95\xed\x6f\x96\x7e\xee\x93\x5b\x77\x4a\xd0\xf9\xe4\x5a\xa5\x8d\x9b\x4b\xc2\x90\x0d\x70\xe3\x96\xdd\xd6\x2c\xdd\xb4\xc6\xec\x7e\xd3\x3f\x37\xd5\x5a\xed\x6f\x39\xa1\xc1\x42\x07\xdf\x2d\x9d\x6b\x42\xfa\xd1\xa0\x6e\x5f\x76\xc9\x45\x04\xb8\xef\x7e\x6a\xf0\x0f\x54\x83\xcd\x15\x6b\x85\xbc\xfb\x87\x6e\xfd\xf6\xfa\xe8\xc3\x87\xe0\xe3\x09\xa9\xf7\x2a\xf0\xaf\x3b\xb6\x81\xff\x72\x9e\x31\xe9\xc7\xb3\xda\xac\x10\x3f\x25\x59\x0e\x2e\x9a\x37\xb4\xa4\xaa\xd5\x6b\xd2\x42\xc8\xe6\xdd\xe9\xf6\xef\xfe\xe1\x96\x6d\x3c\x18\x9b\xae\x5d\x82\xd5\x23\xb4\xdc\xef\xa0\x1c\xdc\x6f\xd1\xa2\xb9\xd8\xce\x90\x2b\xb4\x04\x1e\xb4\x59\x7b\x53\x76\x6b\xdc\x72\x95\xaf\xfa\x69\x57\xe7\x2a\xeb\x00\xe0\xc6\x98\x4a\x03\xfc\xeb\x0a\x36\x1d\x96\xea\xd6\xd9\x66\xe9\x33\xd4\xeb\x01\x12\xbe\x3d\x86\xea\xb3\xb2\xcb\x58\xb2\x71\x43\x2c\x63\x3b\x37\xc8\x6c\x2e\x3f\x69\x14\xac\x65\xa7\x5f\x35\xd6\xfa\xdc\xb4\xec\x52\x6a\x43\x3e\xb2\x49\x2d\x3b\xbd\x6e\xd9\xc9\x15\x56\x2e\x07\x99\x47\x86\xbd\x66\x76\xd9\x62\x5d\x65\x57\xe0\x8b\x8b\xfd\x3e\xaf\xd9\xfe\x69\xb6\x30\xba\xe4\x00\x03\xda\x7c\x3d\x9e\x38\x1b\xe0\x85\xb3\xab\xf3\x80\xda\x77\x6c\x09\xff\xf0\x70\x95\x26\x7b\xaa\xc2\xae\x13\x59\x5f\xef\xdf\x8d\x71\x1b\xc5\xee\xa5\x36\x37\xf0\x81\x2f\x96\xea\x75\x78\xfe\xce\x2a\x79\x8d\x5a\x27\x95\xf0\xbd\xaa\x5d\x19\x66\x79\x5d\x80\xea\x9f\xe7\xa4\x6c\xd4\xbe\x4a\x2b\x77\x26\x72\xe9\x22\xd3\xc6\x4d\xf4\x9a\x64\x50\x8f\x5b\xbb\x8c\xdd\x7a\x41\x57\x82\xd2\xac\x46\x7a\x8b\x90\x83\x36\x43\xf1\xb1\x79\xbd\xa1\x63\x52\xae\x5e\x45\x36\x6a\x08\x50\x56\x8b\xb8\x8e\x97\xd9\xb5\xb2\x5b\x15\x40\x90\xb2\x29\xd5\x95\x1b\x8e\x07\x1f\xa3\xd5\x1a\x79\x62\x81\xd1\xf3\x52\x0e\x41\x0b\xaf\x01\x54\x29\x6a\x71\x55\x45\x4b\x2e\x33\xd5\x1b\xab\x45\x28\x50\x66\xe7\x0c\x14\x65\x66\xad\xed\xb5\x80\xe4\x12\xc7\x59\xd3\xac\x5b\xca\xb4\x95\x48\x15\xd8\x61\xc7\x87\x1a\xfd\x6a\x89\xe1\x60\xad\xe6\xa7\x67\x0e\xe8\x4e\x55\xed\xbb\x14\x2b\x93\xe7\x66\xb9\x62\xdd\xcc\x9a\x07\x43\x2e\x90\xf6\xc9\x3c\xec\xd8\x88\x91\xf8\x51\x46\x2a\xec\x1a\xbb\xf8\xa8\xad\x1f\x58\x7c\xbb\x40\xde\xc0\xd6\x0a\x4b\x53\x6d\x23\xab\x1a\xad\xde\x1d\x96\x81\x35\x46\xb5\xb2\xba\x70\x1f\xa8\xeb\x82\x7f\x39\x54\xe4\xd0\x7b\x8a\x6e\xb7\x7f\xb5\x41\x32\xb5\xcd\xd9\x1f\x18\xf5\x20\xca\xed\x77\x75\x92\x89\x7a\xe2\x1a\x8f\xd1\xe4\xa7\xea\x19\xf5\x36\x2b\x35\x93\xb4\x28\x6b\x63\x83\xb0\x5c\x02\x02\x58\x26\xd4\x3e\x6b\x3d\x58\x69\x83\x8f\x07\x7a\xee\x3a\x2b\xce\x26\x53\x83\x93\x26\x8f\x66\x96\xae\xb0\xd3\xe8\x28\x95\xac\x50\x62\xdd\x69\xeb\xd6\xb4\xda\x69\x46\xf3\x64\xb4\x4b\x1a\x3d\x04\xb4\xcb\x00\x83\x83\xfe\x83\xd0\x16\x94\xbb\x05\xb3\xa1\x07\x52\xb5\xeb\xd0\xc8\x9a\xc6\x5c\x8e\x2f\xa5\xcd\x6e\x8a\xb3\x93\xd2\x65\x81\xde\xf2\x7d\xc0\x07\x51\x23\x04\xe9\x30\xad\x5d\x4e\xed\x92\xdb\x91\xec\xb2\xda\x76\xa2\x32\x3b\x95\xdb\x38\xf1\x1e\x3c\x32\xdd\xc6\x8b\x37\xbe\xb2\x1b\x6f\xd3\xaa\x35\x0e\xbc\x4d\x8e\x89\x2b\xa7\x8f\x4b\x2e\xb0\xe1\x4e\xed\xef\x91\x9f\x9e\x19\x87\x85\x33\x99\x5a\x9b\xc4\x61\x3f\xdf\x06\xa4\x95\x39\x8d\xca\x76\xac\x95\xb5\xfe\xf1\xd7\xac\x63\xf4\x68\x22\x73\x4d\x67\xe0\x58\xfb\x54\x86\x07\xfa\xd7\x5f\x54\x69\xfd\xd1\xea\x75\xda\x5e\xd2\x9b\x63\x73\x86\xd5\x1e\x99\xa9\x98\x41\xc2\xd1\x0f\xf8\x1a\xaf\xe8\x13\xd5\x29\xe5\x05\x6a\x93\x03\x72\x85\x15\x70\x68\xbb\xb7\x8d\x0b\x72\x8b\x89\xa9\x3a\x9a\x32\xc6\x17\x14\x9c\x99\x7e\x6a\xf8\x76\x4e\x8b\x9c\x12\xf5\x76\xac\x9a\x4e\xa7\x06\xc9\xf6\xef\xbc\xaa\x49\xad\xf6\xa4\xd5\x97\x3e\x25\xf8\x4e\x53\xc8\x2b\x99\x34\x99\x5a\xd3\xf6\xb3\x75\x3d\x70\x46\x6e\xc4\xdf\x79\x43\x28\x1d\x4f\xe7\xcd\xfd\x81\x5f\xb3\xc5\xe2\x25\xa7\x3c\xfb\xa0\x8e\x59\xab\x11\x6f\x73\xa3\xf9\x27\x39\xbf\xa8\x7f\xee\xfa\x3e\x97\x62\xa3\x89\x9e\x33\x52\x13\x75\x2a\xe3\xb8\x49\x94\x71\x5d\xcb\x71\x12\x25\xdc\x74\x7d\x14\x25\x03\x76\x45\x3a\x1e\x5c\x35\x52\x2a\xcb\x6a\x52\x1a\x55\xbc\x06\x1a\xd7\x76\xdb\xac\x36\xfc\xac\x2e\xa4\xcf\x6d\xd1\xc6\x05\xab\x1e\xef\x4b\xf0\xeb\x49\xb1\xe0\xea\xec\x48\x15\x37\xf9\x86\x9c\xb0\xae\xb6\x74\x0c\x89\x03\x5d\xea\x6f\x6b\xb7\x38\xc9\x2a\x73\xb5\xe3\x11\xad\xb3\x0f\xcd\x89\x4f\x93\x4e\x54\xf4\x73\xb5\x93\x9f\x9f\x2f\x16\x16\x35\xa3\xee\x04\xb5\x01\x31\x6d\x27\x39\xaf\x47\x1d\x0b\xf6\xb3\x19\xfd\x91\x0f\x79\x1a\x1c\x75\xe1\x56\xe4\x2d\x80\xd6\x97\xb3\x1b\xdb\x75\x4e\xd7\xe8\x38\x26\x67\x47\x11\xb5\x75\xd6\x1a\x1f\xc6\x3d\xfa\x46\x69\x3c\x74\x13\xe7\xcd\xdd\x4c\x5f\x5f\xcf\x72\xbd\x1b\xff\xed\xf2\x68\x79\xc6\xb5\x50\x6e\x15\xb5\xab\xde\xbd\x19\x92\xf1\x1d\x67\xff\x4e\xd3\xc7\xe9\xde\xf5\x14\xbb\x32\xfa\xd6\x2d\xc7\xe0\xf0\x17\x8c\x37\x49\x97\xb3\xee\x85\x18\x17\xa8\x00\x13\x77\x0c\xba\xa9\xdd\x51\x6b\x86\xfd\xc0\xc9\x72\xd9\xd6\xd2\xf7\xd1\xbf\x0e\xf6\x5a\xb8\x97\x5b\xd0\xeb\x33\x4e\x3e\x8c\x71\x55\x3f\xdb\x3a\x7a\x1d\xf7\x5f\x6c\x9a\xa8\x20\x38\x7e\x88\xdd\xe8\xb5\x14\x8b\xbf\x90\xec\x26\x81\x35\x2a\xb2\xb6\xa5\x59\x35\x0a\x23\x34\xdb\x1d\xfa\xab\xd3\xec\x0a\xec\xb5\x70\x37\xd0\xec\xe3\x45\x46\xdf\xaf\x25\x57\x95\xc3\x39\xa9\xb3\xf4\x52\xe4\x2a\xa5\xeb\x54\xd8\x44\x76\x1d\x57\x9a\xc8\x6e\x93\x1d\xb0\x1b\x9b\xaa\x3d\x01\x3e\xca\xb3\x53\x52\x73\xf6\xd4\x3e\x95\x1a\xf3\x34\xeb\x66\x9c\x50\xfd\x92\x4a\x6b\xe8\xe6\x42\x58\x56\x3d\xe3\x44\x0c\xf8\x13\xc7\xe3\xfe\xc4\xc7\x5d\x1a\x67\x95\xae\x30\x2b\x72\x4d\x4e\x8e\x77\xe1\x95\xb4\x0e\x8d\xd9\xa4\x6f\xf9\xbb\x2c\x77\x4a\x75\x13\x06\x8b\x7c\x77\x5e\x12\xb3\x27\xb5\x52\xca\xa6\x0d\x16\x7c\x42\xaa\x2c\x7f\x37\x54\x4c\xa7\x74\x7b\xf6\xcb\x19\x23\x35\x5f\xd7\xbf\xc1\x1c\x07\x0e\xfa\xec\x6e\x65\x83\xff\x35\x8e\x79\xdb\x3c\xab\xae\x79\x2f\x3a\xe9\x2b\x2e\x81\xdb\xa4\x65\x57\xac\x95\x24\xaf\x16\xa4\xe6\xe6\xc0\xa4\xe2\x4f\xf3\x7a\x32\xd1\x5b\xa1\x24\x67\xc5\xe9\x64\x0a\xee\x01\x0c\x1e\x00\x24\x7f\x98\xc5\x2a\x82\x53\xb7\x13\xda\x64\x58\x63\x8c\x13\x34\x56\x2d\xba\x84\x04\xda\x8c\x23\x1a\xc6\xbe\x26\xa2\xbe\xe6\x32\x4f\xb3\x9c\x19\x25\xbf\xe9\xc9\x74\x4c\xea\xaf\x02\x51\xd1\xdb\x00\x51\x6c\xd7\x29\xaf\x62\x86\x8b\xb6\xe2\xe8\xb3\x3a\x26\xbd\xfa\x35\xfa\x39\x71\x3c\x99\x3a\xfd\x13\x65\x71\xba\xaf\x2f\x11\xe8\xfb\x03\xed\xd5\x81\xde\xad\x01\x7b\x61\xc0\xc5\x4e\x5d\xec\x5e\x96\x19\x9e\xdb\x5f\x65\x51\x37\x1b\x57\x3c\xb6\xdf\x67\xc7\x9e\x38\x31\x93\xd2\x08\x73\x39\x53\x51\xf3\xd3\x59\x87\x97\x5c\x78\xdd\x99\xc7\x1c\x70\xa8\x23\x43\x95\xdc\xe5\x1e\xa0\x37\xf1\xd5\x01\x88\x4e\x5e\x0e\x25\x37\xce\x9b\x55\x96\x15\x1e\xb6\xd9\x5a\xc7\xcd\x2a\xdf\x89\x73\xe0\x77\xf3\x94\x73\x7d\xea\xe9\x53\x50\x4b\x45\x7b\x8d\xe4\x50\xc6\xb7\x1d\x39\x72\x1f\xec\x9d\x5d\xcc\xc0\x50\xec\x74\xc5\xd6\xa5\x24\x2a\x07\x14\x9c\x01\xb8\x9a\x89\xd4\xc6\xe5\x88\x79\x75\xac\xf2\x8b\xa2\x3c\x5d\xc9\x99\xca\x19\x61\x1f\x8c\xcf\x10\x60\x3b\x2a\x03\x3d\x4a\x5b\x33\x4d\x81\xf5\xe4\xdd\xc9\x79\x39\xdb\x72\x6c\xae\x38\xc8\xeb\x40\x0d\x3d\xc6\x18\x79\x71\xdd\x41\x92\x94\xd4\xfd\x48\xad\x05\x18\xd7\xc3\xe6\x11\x76\x57\x8d\x58\xd9\xf5\x33\x3a\x45\x9f\x88\x06\xf4\x82\x2d\xf0\x3c\x3a\xe7\xee\x83\xaf\x46\x52\x56\x41\x58\x47\xd4\x96\x69\x57\x73\x34\xde\xa8\x1b\x86\x5d\xcd\x73\xa1\x93\xff\xbe\x9a\xb2\xd4\x29\xaf\x7b\x09\x97\xd3\x69\x27\xc6\xfd\x72\xd4\x5c\xab\xe4\x4e\x47\x57\xff\x2b\xd8\x5f\xab\xed\x0d\x8e\x52\x3b\x87\x75\xb6\x7a\xae\x46\x8f\x59\xf5\x37\xb2\xc8\x98\x25\x48\x03\x7c\x3a\xb0\x77\x7b\x45\x3a\x5f\x14\x39\xef\x41\x75\x9b\x3c\xa0\xfa\xef\xee\xfc\x7c\x4d\xab\x4d\xd2\x64\xa0\xe6\x1b\x9c\xe6\xaf\xf6\xc4\x69\x88\x71\x1d\x9e\x6b\x27\x3c\xed\x5b\xf3\xff\x08\x21\x1c\x19\xd9\xfa\xe0\x84\x10\xee\xd9\xce\xb8\xb8\xdd\x44\x75\x72\xc5\xb7\x96\xdc\xd4\x4d\xd5\xb2\x28\x6a\xbb\xe7\x9f\x0d\xac\x23\xbc\xa1\x75\x84\x41\x77\x77\xc1\x64\x22\x3b\x19\x9b\xd6\xf6\xdd\x88\xef\xb8\x28\x7f\xaf\x30\xaa\xb6\x85\x79\x65\xcf\x81\x1e\xd9\x29\xa7\xd2\xcb\xf3\xb6\x4d\xd3\xf6\x34\x43\xf6\x73\x5f\x85\xce\x8a\x54\xdd\x7c\x50\x8a\x2f\x38\x04\x5f\x75\x0e\x63\x95\x59\xbc\x4e\x4c\x63\x9f\xed\x56\xf5\xc6\x2b\x4f\x09\xbf\x37\x44\x60\x1c\xe1\x9b\xad\xd7\x07\xb2\x33\x0f\xe4\x4c\x9f\xcd\x86\x3d\xe6\xdb\x8c\xea\x36\xac\xca\xa9\xfa\xaf\xef\x51\x0f\xbb\xcf\xdf\x76\x7d\xda\x16\xee\x22\xf9\xeb\xaf\xc1\x10\x8e\xc1\x37\xbd\xe8\xe1\x0b\xd8\x39\xe3\x17\x5d\xfd\xd0\x8e\x89\xa2\xdc\xb9\x43\xe6\x9a\x0c\x3a\x05\x1d\x39\x6e\x2f\x5a\x6f\x29\xcf\x1f\x2d\x16\x12\xe8\xd8\xb6\x7d\x37\xd3\x64\x68\x4b\xcc\x1f\x5d\x82\xdb\x35\xa6\xc9\xb7\x66\x85\x69\x73\xac\xae\x2f\xd5\xe6\x7f\x9b\x41\x7e\xf6\x93\xcd\x2d\x7b\x27\xc7\xff\xf0\x8e\xae\xec\x5e\x77\x6c\x33\x3a\xb1\xed\xc6\x88\xbe\x6a\x50\xd4\xed\xfd\x72\x7d\x07\xbe\x81\x66\x6e\x59\xc3\x2e\x15\xec\x77\xce\x18\x55\x23\xb5\x37\x65\xed\x4b\x79\xeb\x15\x8b\xb9\xb5\xed\x40\x6f\x6f\xd4\x9b\x8e\x59\xf1\x39\xed\x08\x27\x6d\x4d\xe5\xa5\x6e\x79\x73\x66\xa9\x05\x62\xf7\xd8\xb2\xcb\xf1\x0e\xfd\xab\x8e\xb6\x70\x66\xc0\xfd\x0d\x37\xd1\x91\xd9\xb9\x5b\x4b\x46\x26\xcf\x20\x15\x05\xa3\x54\xb4\xb2\x53\x1a\x34\xbc\xe4\x66\xcb\xc9\x29\x77\x29\x21\x98\x9b\x98\xff\x94\xed\xd4\xaf\x46\xf6\x53\xed\x99\xb3\x79\x5c\x01\x5c\x45\xa1\xc5\x6f\xb8\x25\x97\x86\x1b\xb9\x34\x1c\xe1\x52\x17\xf9\xa1\x65\x43\x77\x76\x3a\xb6\x47\x96\xed\xf9\x65\x77\x85\xdd\xd9\xfd\x95\xb0\x54\x9e\x79\x2f\x61\x78\x3f\xb8\xcd\xde\xc6\x75\x46\xfe\x43\xc6\x3f\x7e\x5b\x5c\x80\x43\xbd\x99\xb0\x25\x6b\x1e\x74\x34\x05\xeb\xca\x1c\x1c\xba\x35\x7f\xe3\x0c\xc6\xc5\xbe\x93\xa2\x6e\xb9\x39\x9f\x1a\xd3\x0f\x01\x6e\xbb\xb0\xec\xe4\x5f\x76\xf3\x37\x77\x7b\x70\xa3\x7a\xee\x77\xc6\x59\xdf\xa4\x5f\x2e\x0a\xc2\xd4\xc3\x94\x2e\x02\xbf\xfe\xba\xdb\xca\x37\x8e\x2d\x72\x5d\xc8\xad\xdc\x11\x68\x6a\x2e\xdd\x7c\x57\x61\xe8\xe9\xf5\x9b\xbb\x1f\xad\x5a\xa3\x5e\x4e\x7c\xbb\xfc\xce\x90\x86\x62\x0f\xa7\x3a\xcb\xb0\x33\xb0\xb7\x37\xed\xc9\xbb\x5b\xa8\xdd\xd0\xa7\x5d\x0d\x5d\xbe\x05\xfb\xea\x76\xd9\xb5\x14\x22\x77\x05\xe1\x70\xab\xbb\x0c\x35\x64\xb8\x6f\x7f\xf4\x8f\x63\xf7\xfb\xc3\xd8\x66\x68\xe9\x6f\xdf\xf9\xdd\xa6\x2f\x48\xca\xa5\xf6\xed\x68\xde\xcd\x38\x9b\x1f\xce\xe4\x01\xd6\x49\xf3\xb5\x62\x7c\xd2\x5d\xbd\x7d\xb5\xa3\x14\xfd\xa7\x1a\xaa\x0f\x72\x2d\x47\x6a\xae\x96\xc4\x66\x97\xaa\xd1\x7c\x87\x96\x47\x1b\xe4\x5c\xb4\xa5\x9c\x8b\x36\xca\xb9\x68\x40\xce\x35\xba\xa6\x93\xab\x89\x73\x33\x56\xf5\x72\xe1\x66\x52\xdf\x6b\x67\xb5\x68\x70\x56\x53\xfe\x82\xd5\x8a\x63\xec\x55\xb5\x29\x3d\x03\x6f\xf6\x54\x8f\xf6\x66\x60\x4f\x37\x5c\xfe\x6a\x1a\x27\x3f\x54\x23\x54\xac\xb5\x5e\xf7\xb6\xab\x45\x90\xba\x2e\xab\xdd\xe7\xc5\xad\x56\x34\xba\x47\x2b\x8a\xc8\x8d\x2c\x3d\xf6\x58\xf6\x61\x6f\x78\x0f\xda\x59\x25\x5c\xd5\x64\xca\x64\x3a\x69\x17\x16\x1f\x4b\x72\x76\xa6\x3c\x15\x34\x10\xa7\x2b\x03\xbf\xdf\x5d\x20\xea\xc1\x07\xbf\x37\xf7\xdd\x14\x9f\x2d\x88\x64\x6f\x09\xe8\xbc\xac\x8a\x72\x1f\xec\x99\xfa\xf6\x36\x4d\x4a\xce\x09\xc0\x6c\x8b\x65\xd7\x95\x36\xf5\xae\x6a\xc2\x65\xc3\x96\x5e\x07\x0f\x8a\xbc\x24\x1e\x36\x74\xaf\xb3\xfb\xef\x2c\xd0\x9a\x55\x88\x9b\x61\x47\x5a\x7d\x67\x74\xb8\x45\xcd\xcb\x57\x1f\xde\x19\x4c\x54\x5d\x2d\xae\x45\xf4\x74\x70\xc9\xd8\x28\xb4\x03\x8b\xad\xb7\x1d\x17\x38\xe6\x12\xd5\xc1\x9d\xcb\x6d\x76\xbb\xde\xdc\x6d\xee\xe4\xdd\x7d\x3b\x6d\x0c\x4e\xcc\x59\x56\x9d\x2d\xc8\xd2\x08\xa0\x3d\x03\x74\xaf\xcd\xd0\x98\x28\x34\x67\x5d\x06\xd1\x57\xb5\xfe\xd4\x31\x00\x68\x87\xe7\x5a\x40\xe4\x74\xbb\x13\x08\xed\x6d\xed\x4e\xcb\x58\x57\x07\xa1\x25\xa7\x32\xd4\xd9\xae\x84\xae\xd9\x1f\x6a\x2d\x81\xee\xd2\x9e\x6d\x8c\xd9\x8d\x96\x6e\x7c\xc4\xed\x50\x56\x4e\xe4\xda\x24\x9f\xde\xa8\xdb\x01\x84\x36\x88\xa7\x07\x44\xef\xea\x5d\x0b\xc8\x56\x62\x79\x0b\x38\x46\x99\xfc\x03\xc6\xc3\xb4\xe1\x1a\xe4\x74\xbd\x91\x34\x8a\xec\xff\xc2\x9e\xb7\x1b\x2e\xb7\xde\x75\x25\x95\x5e\x88\xad\xad\xe1\xb9\x5d\x2f\x18\x9f\xee\x86\xb4\x82\x71\xd9\xf3\x3b\xfd\xbb\x0b\x3b\x62\x71\x76\xa7\x7f\x7f\xe1\x5a\x80\xcc\x1d\x86\x9d\x61\xdc\x19\x3c\x9b\xdb\x01\x5c\x5a\x14\x8b\xd9\x9d\x35\x67\x76\xd7\x80\xd9\x3d\xe1\xbd\xe6\x24\xb2\x72\x68\x7b\x53\xf0\x9e\x98\x93\xe6\x5d\xf9\x62\xf2\x66\x8f\x93\x4a\x2d\x15\xe4\xdf\x07\x59\xde\xfc\x2c\xce\x6b\x27\xda\x7e\x2e\xb2\x9c\x93\x72\xef\xed\xf4\xce\xa5\xa3\xad\x38\xc6\x9c\x8d\x3e\xd2\x08\xab\x3d\xb5\xb4\xdc\x5b\x99\x94\xe1\x3c\x00\xf7\xc0\x04\x81\xfb\xfa\xb5\x4a\xf5\xcf\xb2\x9e\x04\xd3\xe9\x6c\x98\x3a\x76\x5d\x7b\xe6\x4a\xfb\xcb\xaa\x57\x55\xa9\x35\xbe\xe9\x5a\x82\xb9\xd9\x6a\xfa\x34\x04\x47\x68\x01\x05\x10\x0e\x0e\xab\x45\xb7\x42\xb6\x7a\xfd\x31\x55\x46\x21\x34\xe2\x0f\xae\x61\xba\xdd\x79\x9f\xd1\x33\x73\x9b\x7c\x31\x73\xfb\xa7\x31\x73\x6b\x40\x55\xe7\xa7\xdf\x2e\xc7\x8d\x68\x06\x3b\x1a\x84\xed\xc3\xbf\x96\xd9\xdb\x2e\xa8\x5d\x2d\xd4\x1a\x28\xa7\xd9\xf8\x40\x7b\xc1\x8e\x16\x24\xbb\xd0\xaf\x65\xff\xd6\x05\xb4\xab\x81\x5a\x0b\x83\x5c\xac\x19\x5b\x2f\xd9\xb1\xb3\x7d\xf8\xd7\x32\x80\xdb\x05\xb5\xab\x91\xda\xcf\x62\xb3\xd9\xbf\x01\x9b\xcd\xfe\xf5\x6c\x36\x07\x9f\xd1\x66\x73\x70\x53\x36\x9b\x83\x1b\xb0\xd9\x1c\x7e\x46\x1b\xc6\xe1\x4d\xd9\x30\x0e\x6f\xc0\x86\x71\x74\x1b\x36\x8c\xe3\xcf\x6f\xc3\xf8\xf6\xac\xff\x7e\x6e\x53\xc9\xcd\x21\xd0\xe7\xb4\x30\x8c\x3f\xbf\x3d\x66\xe4\x5d\xd9\x8a\xf1\x17\x43\xc6\x5f\x0c\x19\xdf\xb0\x21\xe3\x2f\x76\x8c\xbf\xd8\x31\xfe\x62\xc7\xf8\x8b\x1d\xe3\x2f\x76\x8c\x6f\xc1\x8e\xf1\x7a\xfb\xc5\x7a\x96\x55\xca\xee\xe3\xe6\xa6\xc7\x0b\x61\x94\xb5\xde\x1d\x26\x60\x0d\x8d\x64\x79\xcd\xcb\xb3\x62\xa1\x36\x8b\x7e\xd0\x1e\xf6\xd4\x1c\xdd\xba\x10\x1e\xcc\x31\x21\x33\x90\x3a\x6e\xf1\x09\x38\x04\xf7\x89\xb5\xb4\xf6\x3e\x05\x87\x20\x05\x0f\xc0\x7b\xe2\xb8\xb0\x76\x66\x82\x9e\x79\xac\xf7\x04\xdc\x97\x85\xee\x01\x6d\x70\x4c\x19\x42\x51\xf7\xa7\xb8\xac\xfd\x75\xc7\x16\xb3\x8e\x5a\xb5\x38\x9b\xdb\xeb\x50\xfa\xda\xee\x12\x3c\x04\xb8\x01\x64\xaf\xf7\xf4\x8c\x90\xaa\xb8\x09\xcf\xeb\x72\xd9\xf5\x17\x2d\x63\x24\xb5\xa9\x1f\xc6\x0c\xeb\xa7\x4f\xc6\x1d\xb5\x01\xf8\xea\xfc\xf4\x85\x78\xca\xaa\x1e\x4c\x1b\x3d\x59\x64\xf9\xfb\x6a\x06\x32\x56\x75\x60\x67\xac\x1a\xb7\x33\x9a\xf5\x8d\x8c\x36\x26\x87\x9b\xd6\x2a\xb0\x6f\x32\x66\x9c\xa8\xeb\x8b\x96\x9d\x56\xc9\xf9\xe7\x57\x75\x04\xcb\xd9\x2b\x3b\x73\xf6\x9a\xb8\x9a\x67\x52\x97\x5c\x79\x6e\xbf\x4e\xab\x65\x23\x24\x04\x70\x08\x9a\x76\xb6\xb6\xa5\xf4\x74\x6a\xee\xde\xc9\xea\xde\xc8\x4c\x73\x1d\xfd\xb6\x6b\xdf\xb6\xb5\xb5\x6c\x06\xbc\x2d\x3c\x05\xf7\x76\x45\xc7\x91\x9d\x77\xd7\xa0\x43\xe7\xb9\x05\x74\xe8\x49\x76\x05\x1d\x3a\x7a\x13\x3a\xda\xc2\x5b\xa3\x83\x54\x94\xe7\x2c\xcb\xdf\x75\x18\xaa\x8d\x75\x98\xda\xfa\x08\x9f\x2f\xc1\x03\x90\xce\x1d\x8b\xad\x15\x27\x25\x3d\xd1\x38\xaa\x1e\xe5\x86\x78\x3a\x4c\x30\x92\xa5\x65\x88\x56\x70\xb4\x83\x5a\x35\xb6\xda\xda\xf8\x67\xb2\x40\x27\xbe\xed\xf5\x50\xbc\x9b\x7f\xd4\xbc\xa3\x6a\xc5\x5a\x03\x8f\xab\xa3\xe6\x3a\xc0\x77\x48\x56\x4d\xd8\x99\x63\x27\xdc\x69\x9e\xb6\x65\xe6\x0c\x68\x73\xe3\xde\x69\xab\xce\x94\x4d\x3b\xc6\x85\x9a\x4a\xac\x92\xd8\xab\xc4\xc1\x99\x53\x89\xd1\x7d\x0f\x3a\x99\x06\x2b\xe9\x1a\x9e\xfa\xdd\x85\xb7\xef\x7e\xcc\x5c\x20\xfb\xee\xc7\xcc\xed\xc3\xbe\xfb\x31\x73\x51\xb0\xdf\x19\xae\xcb\x96\x86\xce\xd5\x99\x89\xb2\x0b\xff\x42\x18\x3a\x71\x09\x68\x28\xdd\xf0\x23\x3d\x2f\x9f\x37\x92\x7f\x95\x22\x4c\xf2\xdc\x89\x5d\x43\x0a\xee\x70\x6d\x22\x88\x46\x63\x57\x8c\xea\x94\x7c\x93\xbd\x75\xc9\xa3\x59\xe5\x74\x46\x7b\x6e\x1d\x05\x34\x36\x96\x6d\x4b\x1b\x3b\xfd\xb3\x4e\xd6\xf6\xb6\xdb\x1a\x64\x74\x08\x4b\x0f\xac\x45\xb1\x6d\x9d\xd4\x19\x7a\xe2\xae\x89\x57\x4f\x8c\x67\xf6\x4e\x95\x9c\x36\x7f\x6d\x6d\x57\xda\xf7\x4b\x95\xeb\xc4\xa0\xb9\x1d\xb9\x30\x9c\xa6\x52\xd4\x47\x63\x55\xbb\xd6\x35\xaa\xec\xbd\x97\x2b\x6a\x36\xed\xbd\x5c\xd1\xa6\x1c\x2b\xbd\x47\xb7\x49\x72\x98\x97\x2b\xae\x60\xec\x5c\x17\x33\x15\x58\x41\xdc\xbe\x19\x50\xca\x60\x83\xfb\x81\x59\xda\x58\xe2\x76\x88\x7c\x3a\x1b\x9a\xcd\x4d\x3e\x87\xe4\xa7\xcd\x45\x2f\xfb\xd0\x43\x0f\x47\x63\x55\x7d\x9c\xfc\x4a\xce\x37\xd2\x5d\xee\x4c\x0f\x1d\x39\xa4\x9f\x67\xb9\xc2\xa0\x6f\x32\x6f\x0d\xe5\x38\xe6\x3a\x2e\x8d\x89\x57\x59\xd9\x29\xb9\xb0\xfe\x23\xae\x7e\x22\x30\x99\x1a\xe0\xbd\x01\xef\x69\x34\x5a\xa5\x52\xb8\xd2\x18\xb2\xbf\x8d\xf9\xcf\xa6\x0d\x7f\x3d\x04\xc8\xc5\x84\xba\xbc\x61\x1f\xaf\x4f\xac\xa9\x57\x87\x6c\x1f\x36\xed\xd7\x3d\x6b\x6d\xc5\x19\xb4\x1f\x0f\xe0\xfd\x38\x6b\xcd\xc1\x65\xae\x31\x38\x55\xd0\xc5\xfe\x71\xf6\xb6\xfb\xba\x42\xa5\xce\x57\x85\x88\x7b\x05\xf9\xd8\x79\x44\x76\xd8\x6b\x5f\xfb\x84\x56\xe7\x52\x86\xda\x9d\xfc\xf7\x9c\x2e\x1f\x74\x72\x32\x6b\x43\xc3\x49\x5b\x15\xec\xb2\xd5\xfb\x40\x8f\x89\xad\x79\xbf\x1d\x63\x47\x20\xbf\xe3\xb5\x8a\x1b\x90\x16\x4d\xbc\x1a\x5c\xc7\x08\xb4\xe5\xd9\xb5\x93\xed\x35\x49\x5c\x57\xf2\xa6\xc5\xc9\x5b\xd7\x78\x59\x3f\xcd\xb1\xf6\xda\xd8\xe9\xeb\xe7\xd1\x93\x61\x43\xfe\x2e\xc2\x74\xe6\xfe\x2c\xf5\xfa\x85\xe8\x63\xa5\x93\x30\x61\x16\x41\xf6\x5a\xaa\x79\x01\x48\x18\x53\x77\x9d\x94\xe0\x68\xf1\xb6\x6c\x1e\x95\x5d\xf1\x7c\x71\x32\x6d\xab\xea\xc9\x55\x25\x6b\x7b\x6c\x36\x69\xac\x2e\xeb\x64\xfb\xb6\xd0\x58\x47\x71\x9a\x28\x19\xe7\xea\x67\xbb\x93\xa9\x86\x3b\x6b\x74\x4f\x23\xf0\x7a\x12\x8f\x69\x72\x70\x24\x4b\xdb\x0b\x4b\x18\x0c\xfc\xa5\x65\x0d\xc0\x5a\xea\x18\x26\xaa\x06\xc0\x1b\xf6\x76\x2d\x71\x75\xc8\xcb\x2d\xf5\xc6\x61\x65\xb3\x6e\x3c\x04\xd9\x81\x1b\xc3\xac\x2d\x9a\xc6\x09\xc7\xd2\x3c\xfc\x1b\x62\x36\xad\x54\x76\x47\x45\xc6\xf5\x06\xa5\x33\x59\xc9\xf4\x19\xf8\x1d\xb0\xe5\x7e\x57\x7f\x9f\x36\x95\xf5\x7c\x73\x18\xbe\x2b\x16\x1f\xf8\xe3\x62\xb1\xc8\xaa\xac\xc8\x3b\x8a\xd3\x4a\xe2\x06\xea\xd4\xcd\xdb\x80\xe5\xad\xf8\xb7\xea\x60\x38\x73\x56\x39\x79\xa3\x0c\x74\x5e\x10\x3f\x7c\x08\x5e\x15\x65\x0d\xd2\xa5\xb2\x90\xa8\x91\x5c\x08\xa0\x5f\x2b\xea\x02\x55\x51\xd6\x93\x76\x7d\x32\x75\xac\x88\x2e\x61\x6b\xcd\xb5\x69\xff\x3f\xf4\x49\xc4\x3f\xc0\x5f\x40\x7e\x00\xfe\x31\x42\x08\x0a\xf6\x9b\x7f\xbc\x75\x9f\x44\xa9\xd1\x5e\x42\x33\x9f\x38\x96\x87\xa4\x18\x62\xcb\xae\xf1\xe2\x86\x66\xee\x1f\x02\xb6\x5c\x79\x59\xa2\x9a\xb6\xb2\x1b\x71\xdf\xc5\x7b\x47\x48\xa9\xfc\xd6\x8e\xfa\x6a\xae\x76\x16\x93\xdd\xcb\x25\x03\x1f\xc8\xdf\x7f\xd5\xf6\x4c\xff\xf1\xe0\xc1\xc0\x9c\x85\x9b\x7e\x1e\x77\x3b\x7a\xac\x7a\xaa\xf3\xa8\xf6\x99\x9f\xfd\x16\x82\x07\x60\x09\x3b\x58\x38\x5e\x45\x43\x03\xe6\xc1\xa1\x04\xdc\x3e\x29\x56\x5d\xb2\xa9\xa3\xa6\x8e\xd3\x92\x93\xf7\x03\x36\xc3\x1c\x5a\x5f\x90\x8b\x67\x5c\xd4\x47\xc5\x4b\xf3\xd0\xc6\x21\xf5\x6e\x9a\xd1\x3d\x1c\x7a\x37\x1a\x1b\x59\x9c\x9d\x90\x61\x42\x5f\x2b\x94\xb2\x8e\x50\xda\x8a\xe4\x07\xa8\xd1\x72\x53\x87\x03\x14\x85\x2a\x4e\xda\x4c\xa3\xce\x08\x38\x0a\xdf\x33\x67\x11\xeb\x8e\x48\xbb\x76\x7e\x75\x7e\xaa\x8d\x60\xf7\x35\xd8\x3e\x14\xe7\x25\xb8\xb2\xf2\x65\x37\x85\x9c\xf2\x9b\x36\x8b\x36\x80\x94\x14\xe7\x82\x7d\xd8\x36\xb1\xe9\x9f\xcb\x53\x93\x25\x78\xd0\xdd\xe7\x93\x12\x51\x8d\xe3\x08\xb5\x34\xc4\xa2\x48\xe1\xa8\x90\x74\xb1\x42\x2c\x4e\xda\x95\x89\xa5\x4f\x1e\x9a\x0b\x33\xc3\x84\x59\xcb\x83\x7f\x2c\x71\xb8\x5b\x0b\xc3\xc4\xa1\x73\xac\x27\x0e\x77\x71\x73\x35\xe2\x18\xda\x3a\xdb\x00\x72\x95\x38\x9a\x26\xde\x20\x71\x34\x2a\x9b\xdd\x22\x5a\x55\xe6\x54\x8a\xdb\xf4\x75\x93\xe3\x4e\x7a\x6d\xc3\xa0\xcb\x76\xee\x52\x63\xb2\x74\x2c\xe8\xaf\x8c\xa3\x9a\x04\x5b\xad\xa2\xdd\xa3\x03\xce\x9b\x7c\xbb\x79\x58\xbd\x21\x6f\xed\x06\xa2\xda\xbb\x73\x52\x52\x27\xe5\xc0\x59\xa3\x82\x15\xfe\xdd\xa1\x4e\xb3\x87\x3b\x50\x67\x93\xd2\xd6\x39\xc8\x0a\xf5\xb3\xd6\x27\xc4\x2a\x1d\x6b\xb6\x90\x79\x06\xf8\xa2\xb3\x59\xd7\x07\xf0\xe6\x1f\x6f\xbb\x9c\xe2\xea\x65\xc0\xec\x65\xcc\xd5\x98\x54\xce\x14\x56\x29\x6a\x53\x69\x6c\xd8\x52\xbd\x33\x31\x63\xdd\x85\xca\xe9\xc2\xaa\x9c\x3e\x50\x19\xff\xa2\x72\xa9\xdf\x2b\xab\xcd\xd5\x7e\x38\x50\xde\x1c\xff\x03\xf7\x7a\x72\xdc\xef\xca\xb1\xde\x37\x94\x7d\xa9\x9d\xbe\xd4\xaa\x2f\xc7\x23\x9d\x71\x67\x5c\x63\xc1\xe2\x3b\x6d\x42\xa3\xef\x00\x53\x46\x6b\x8b\xe3\x8e\x07\x4c\x63\x6d\x43\xc6\x76\x6c\x6d\x7c\x74\xcc\xcc\xe1\xee\xd3\xd9\x13\xd7\xb4\x1c\xee\x3d\x9a\xcd\x6a\xae\xaf\x33\x57\x4d\x86\x36\x6a\xe6\xa8\xe8\xbf\x76\x2a\x68\x62\xdc\x2c\x56\x99\x71\x33\x39\xca\x95\xa5\x1d\x25\xac\x49\x4d\x7a\x3b\x59\xc7\xbd\x4d\xb4\xce\xde\x99\xb6\xd8\xb1\xb2\x77\x66\x6b\x37\xbb\x60\x1d\x10\x73\x19\xd9\x40\x67\xce\x82\x7b\x75\x9d\x6d\x9b\x97\xf3\x8f\x56\x64\xed\xb2\xec\x34\x0f\x0a\xaf\xb8\x2a\x68\xda\xa8\xc4\xaa\xba\xa3\xd1\x97\x84\xfa\xd6\xc6\xa1\x33\x5a\x1d\xf1\xb7\x79\xc2\xb5\x1d\x33\x73\x2e\xb8\x77\x08\xe0\x3c\x49\xda\xdd\xbd\x5d\xda\x0c\xb6\x50\x0b\x7b\x15\x5f\xa3\x42\x23\x09\x06\x67\x10\x5b\x4b\xe7\x49\xe7\xef\x7a\xea\xb6\x7b\x32\x0b\xbd\x7d\xde\x0c\x71\x77\x43\x66\xf8\x14\xd7\xdd\x9a\x19\xc8\x31\xe1\x8b\x99\x3a\x69\x6f\x3d\x15\xe9\x33\xf5\xc3\x43\xb0\x27\x2b\xdf\xeb\x3b\x31\x04\x17\xfb\x80\x2f\x94\xdd\x09\xbe\x70\xec\x4d\x80\xa5\x8a\x5f\xea\xf8\xd6\xae\x84\xf1\x4b\xe8\xf6\x4a\xc1\xbb\xd8\x07\x13\xbe\x30\x02\xeb\xef\xba\x94\x96\xc2\x7f\x9f\xb6\x06\x2c\x96\x6e\xae\xd7\x6e\xae\xd7\x53\x63\xb5\xa2\x8b\x85\x9f\xb5\x15\x82\x31\x14\xf4\x93\x9b\xfe\x37\xc6\x22\x5c\x07\x92\xd6\xec\x05\x5f\xcc\xcd\x47\xb3\xeb\xb8\x1e\x4b\x8d\x1d\x8c\xc6\x3a\x02\x5f\x34\x72\x66\x4b\xdb\x17\x43\x17\xf6\x36\x58\x9f\x30\xb5\x0d\x1b\xbe\xd8\xda\xec\xc5\x75\x2a\x36\x8f\x6e\x8c\x47\xca\xb7\xd6\x1d\x98\xf6\x80\xa5\xf2\xd8\xa3\xb0\xaf\xbf\xb6\xc8\x99\x77\x8f\x40\x9c\x63\x3e\xfd\x08\xf9\x73\xb6\x78\x6e\xef\x73\xb9\x18\x5b\x39\x71\xbd\x85\x76\xd8\x4b\x83\xdd\x76\x5c\x8d\xa6\x1c\xac\xdd\x07\x7b\xe0\x81\x36\x54\xda\x74\xe1\x8f\x27\x84\x56\x06\xbc\x79\xdb\x72\xed\x2b\x92\x6b\x77\x2b\xdb\x5b\x64\xb9\xaa\xef\x9a\x2b\xbb\xae\xd1\x6d\x5a\xe3\xb9\x46\x67\x98\x9c\xb9\xa6\x26\x87\x1d\xd2\xe8\x9c\xd3\x8e\x47\x9b\x6d\xbd\xbe\xe8\xb2\xdb\x38\x7b\x31\xb5\x68\x5f\x2f\xa6\xf8\x99\x35\x7c\xa8\x5b\xb7\x9d\x4f\x97\x33\xc7\x1e\xa4\x6b\x1f\x6e\xd8\x73\x8b\xc5\xd3\xed\x39\x6e\xf9\xb0\xd9\xb1\x47\xc7\xa0\xdb\x8a\x3d\xb7\xae\x91\x96\x8d\x36\x5a\x06\x4c\xb4\x9c\x92\xd2\x35\xdb\x3e\xd7\xdf\x1d\x43\x53\x1d\x9d\x54\xe7\x5a\x55\x4a\x57\x14\x53\x9d\x71\x45\x33\x1d\xd0\x4e\xdb\x9c\x56\x81\x73\xf3\xf6\xec\x94\xad\x98\x29\x1b\x71\x7e\xa3\x7e\x7c\xfa\x04\xda\x24\x8d\x2b\x99\xa6\x7f\x75\x12\x0d\xa2\x64\xaa\xf9\xf9\xe9\xd3\x16\xef\x18\x47\x98\x38\x55\x4c\x5c\x9d\x90\xc5\xa2\xf8\xf8\xe4\x9f\xe7\x64\xa1\x39\xb9\xad\xcf\xa0\xd9\xa0\x7f\xda\x6d\x8c\x83\x71\xd9\x20\xe7\xb3\x93\xad\x45\xb7\xba\xbb\xd8\x7c\xad\x64\xb2\xb8\xb6\xd9\xec\x77\x37\xa3\x41\xb4\xca\xe4\xaa\x0f\x46\xa7\xdf\xca\x63\x90\x63\x7f\xf3\x46\x7c\x07\x55\x5a\x9c\xf6\x5c\x07\x9d\x91\x92\x9c\x82\xd6\x75\x90\xe6\xa0\x23\xe5\xbf\xb6\xe6\x55\xad\x23\x9a\xec\x7f\x8c\xa7\xa1\xb3\x55\x56\x37\xbc\xbc\x9e\x95\x37\x71\xf2\x46\x46\xde\x8a\x8f\xb7\x65\xe3\xad\xb9\x78\x85\x89\x87\xac\xc6\x5a\xa8\xf6\xfc\x7a\x62\x1a\xfd\xf5\xd7\xa6\xf9\xf3\x05\x17\x8a\xf5\xe0\x74\x30\xb9\xb4\xac\xd9\x75\x6c\x60\xc0\x37\x56\xdb\xdb\xe3\xbf\x15\x08\x75\x71\xb6\x06\x7e\x5a\xd4\x75\x71\x6a\x2b\x70\xa5\x74\x77\x73\xc0\xdd\x13\x70\x8c\x5d\x2a\xab\x2d\xdd\x81\xb5\x66\xac\x1d\x04\xb4\x89\x8d\x05\x6b\xb7\xfd\x8e\x79\xcb\x66\x78\xf6\x9d\xdf\xce\x8a\x7b\xbf\xfd\xd9\x59\x9f\xed\xbb\x1f\x96\x0d\x3b\x66\x80\x9a\x3b\x2c\x4e\x4f\xf4\x0e\x40\x7f\x88\x57\x72\xe5\xcd\xc5\x22\x30\xe4\x46\x4b\xdb\x65\x33\x06\x82\xb4\xfd\xbd\xbe\xd1\x36\x93\x78\xb4\x3c\xe3\xfd\x0c\x9b\x7c\xda\x98\x35\xa4\x39\x7d\x35\x8b\x48\xf5\xc7\x76\xf3\xc6\xdd\x71\xb5\xab\xaa\xdd\x5c\x1c\x75\x7d\x72\xe1\xed\x9d\x72\xdd\x8c\x8b\xa3\xc1\x07\x59\xff\x36\x3e\x8e\x7a\xd4\xc4\x17\xab\xe6\x2c\x3b\xd4\xa4\x06\xca\x15\x7a\x43\x6e\xbd\x9a\xf4\x9b\x72\xdd\xe5\x92\xc8\x4d\xbb\xef\x1a\x82\x7d\xe3\x2e\xbc\x36\xd0\xf8\xb8\xdb\xa0\x41\x37\x5e\xde\xf6\x6e\xbc\xbc\x2f\x34\x3e\x22\xf3\xae\x48\xa4\x9b\x7d\x75\x5d\x8f\x48\xd7\xfb\xeb\xba\x12\x91\x6a\x63\x70\xcf\xb2\xfc\xfd\x46\xb7\x08\x36\xd3\xa4\x38\xd3\x0f\x6a\xce\xae\xe2\x0e\x61\xe5\x59\xfb\xaa\x3b\x04\x0d\xf7\x6a\xde\x10\x86\xc0\x76\x6c\x99\x76\x1b\x7b\xa3\x8e\x10\xc6\xdb\xab\x53\x26\x67\xc3\x2e\x10\xda\x8d\xa8\xbf\x37\xca\x9a\xf9\xee\x98\x63\x34\x7b\x93\xdd\x2c\xaf\x57\xb3\x3c\x2e\xf2\xba\x2c\x16\x7d\x60\x36\xba\x63\x92\x50\x6f\x84\x36\x39\xcd\xf7\x6a\x96\xd7\xbd\x2c\xaf\x57\xb3\xac\x54\xdb\x8d\xee\x6b\x38\x5d\x2d\xb6\x89\xb9\x9a\xc5\x50\x2d\xf3\xc0\x9b\x3d\x83\x2f\x65\x1a\x54\xe3\xa5\xfd\x69\x5b\x20\x63\x4c\x07\xdb\x9f\xaf\xdb\x9f\x6e\xbe\xa6\x3d\xae\x5d\xd1\xdd\xa8\xaf\x63\x9e\x72\xef\x8c\x28\xbb\xa6\x03\x0e\x27\x06\x8d\xff\xeb\x45\xd6\x03\xd9\x1c\xc7\x1a\x28\xdb\x07\x7b\xff\x5f\xde\x22\xea\xa7\x3d\x70\x1f\xb4\x3b\xdc\x7b\xb3\xf6\xfb\xb5\xfc\x76\xf3\x3e\x6e\xd3\x9a\x11\x1b\x28\xe2\xec\xe9\xad\x64\xb3\x24\xd1\xcd\x36\x98\xde\xd6\xec\x34\xdf\xb8\xd6\xc8\x8b\x9c\x0f\xba\xd6\xf0\x3c\x6f\x25\xde\xe8\xd4\x03\x74\xa2\xd3\x5f\x9c\x11\x9a\xd5\x52\x84\xc1\x39\x76\x1c\x73\xec\x3a\x3f\x5d\xc5\x00\xec\x46\x9f\x1f\xea\x18\x65\xa3\x30\xed\x5c\x76\xe8\xef\x44\x6d\x70\x1e\x38\xee\xb9\x40\xc2\x7c\x7c\x5e\x7e\x20\xf5\x79\xc9\x1d\x9f\x01\x9d\xf8\x95\x02\x8d\x27\x11\x37\xfb\x9a\xbd\x29\xdf\x2c\x6a\x7b\x9a\xc2\x99\xba\x5b\xdc\x59\xdc\xb9\x6b\xc3\x85\xbe\x0e\xd3\x5f\x5f\xde\x24\xc3\x35\x4d\xbe\x9a\x9d\x8a\x0d\xbe\x3c\x36\xf1\x6a\xb5\x37\xeb\xfb\xfb\xe8\xa4\xba\xd6\x6e\xc7\xae\x68\x76\x1c\xbf\x80\xce\x3c\xf1\xd2\x58\xdc\x7d\x6d\x0e\xe5\xe7\xd5\x8a\x43\x35\xcd\x83\x2b\x19\xeb\x95\x8c\xae\x2c\x6e\x0e\xe2\x07\x6b\x6d\x6e\xf8\x74\x1f\xc7\x75\xb3\x36\xcf\x51\x9c\xac\xcd\xc3\xb1\x21\xa8\x7f\x6f\x9e\xb3\xab\xb3\x3e\xf3\x93\xc9\xdf\x92\x20\x86\xe1\xff\xbd\x79\x24\x33\x1f\xcb\xd8\x79\x1f\x2a\xe7\x6b\x70\x38\xf6\x66\xd4\x4e\xb6\x16\xf8\x74\xb8\xa5\xce\x04\xb7\x02\x7c\xd2\x61\xa7\x15\x00\x2b\x33\xe4\x2a\x00\x04\x1e\x80\xf5\x40\x5a\x05\xc0\x20\x69\xd9\xe0\xab\x1d\xe7\xfb\xce\x80\x3e\x04\x58\x4a\xe3\xe2\x6c\xb8\x39\xaf\x5b\x24\x2e\x1b\xa9\xbd\x11\x52\x0f\x94\xcc\xb3\xea\x4a\xa8\x43\x63\x06\xbd\xf6\xdc\xa8\xc5\xb3\x7d\x87\xd5\xf3\x00\x66\xfa\x69\xf3\xbf\xb6\xf9\x5f\xdb\xfc\xaf\x87\xf2\x5b\xe4\xee\xf7\xbe\x67\x3d\xe4\xef\x83\x71\xbd\x04\xf4\xd1\xb9\xdf\x8f\x98\xf5\xd1\xb4\xdf\x8f\xe8\xc2\x6b\x50\x38\x38\x75\x81\xd6\x4f\x4a\xd6\x8d\x6d\xce\xde\x06\x6f\x66\xeb\x46\xd9\xc6\xd9\x36\xd9\xa6\xb8\x56\xb5\x3f\xff\x1c\xe8\x4c\x17\xd3\x15\x92\x55\x2e\xf0\xaa\x9e\xb7\xd2\x15\x9b\x9f\xda\x25\xde\xb0\xc7\x52\x9d\x38\x6b\xe9\xcc\x28\x67\xff\x3f\x7b\xd7\xd6\xdb\x36\x8e\x85\xdf\xfd\x2b\xce\x3e\xb4\x8e\x9b\xac\xe3\xf8\x92\x7a\xdd\xcd\x16\x49\x11\x2c\x0a\xcc\xb4\x45\x9a\x19\xcc\x4c\x11\xd8\xac\xc5\xc4\x44\x6d\xc9\x90\xe4\x24\x9e\x20\xff\x7d\x20\x5e\x24\x4a\x22\xa9\xab\x33\x4e\xc6\x2f\x81\x22\x8b\x87\x3c\xe4\xe1\xe1\xc7\xc3\xcb\xd7\x6c\x1d\x68\xa7\x53\x2a\x91\x12\x7f\xa9\x5e\xa4\x5c\x6d\x31\x4b\xaf\x73\x20\x82\x7a\x07\x23\x88\x5d\x4d\xce\x47\x1d\xaa\x0e\xec\x03\x09\x9a\x9f\x35\x42\xa2\xbe\x62\x3c\x84\xe1\x54\x4e\x6a\x4c\xa9\x7e\x74\x3c\x7b\xaa\xbb\xc2\x75\x94\x67\x99\xd3\x49\xf1\xd1\x6e\x3a\x59\x71\x3a\x59\x83\xad\x16\xbc\x0a\x2b\x2f\xa5\x9e\x09\x35\xd9\x11\x2d\x1e\x48\xec\x7b\x9d\xce\x70\x78\x9d\xfc\x41\xc6\xfa\x43\x09\xeb\x2f\x73\x13\xf0\x99\xc1\x38\xbb\x9a\x5f\x87\xc2\x95\xd4\x7b\x59\xcc\x4f\x81\xb0\x24\xa8\x1e\xd0\x70\xbd\x01\x54\x0f\x76\xa0\x5a\x36\x0f\x3d\xa8\x66\xbf\xca\xa0\x5a\x75\xca\xd7\x4e\xb2\x29\x8a\x1a\x13\x87\x16\xd3\xac\xc5\xe1\x59\xab\x14\x6c\x0e\x4f\x3a\xb6\xad\x54\xaa\xe8\x88\x96\x02\x4b\xdb\xa5\xb9\x17\xab\x8c\xd2\x92\xfd\xb5\x92\x54\xb2\xf7\x23\x10\x20\x3a\xae\xc9\x7a\x04\x6b\x06\xfb\xe2\xef\xf9\xba\x59\x52\x71\xb1\x62\x66\xad\x0b\x21\x9c\xa0\x68\xf2\xc0\x5b\x01\x44\xf4\x4c\x20\xa2\x17\x63\x40\xe4\xdb\xe9\x32\x41\x44\xcf\x04\x22\x94\x22\x5f\x0c\x88\xa0\xea\x64\x83\x08\x99\xd0\x91\x0e\xe0\x92\xad\x29\xb9\xde\xcb\x81\x88\xaa\xac\x7c\x7a\xd6\xb8\xd4\xc2\xc7\xb1\x92\xbf\xa8\x0e\x72\xb9\xe4\x8e\x99\xe3\x3a\x98\xfd\xb6\x6a\x85\xa5\x34\xb5\xdf\xa6\x18\xf5\x78\xd7\x49\x92\xea\xf1\xd7\xc6\x25\x4b\x4d\x9a\xe0\xa7\xcd\xf3\xf1\x89\x72\xbf\xd7\xed\xa8\x8e\xeb\x91\x2e\x7d\x0b\x46\x86\x8b\xb7\xd4\xbc\x7b\x8a\xac\x53\x3b\x99\xb3\xf2\x95\x76\x38\x17\xe3\xa1\xcb\x04\xdb\x3b\x1e\xba\xac\x3e\xbf\x23\xa2\xdb\x3a\x22\x3a\xe6\x41\xba\x5a\xcf\x16\xee\xf6\x61\xdf\x19\x36\xfa\xf0\x0f\xe2\x7b\x7c\x6e\x8b\x70\xdd\xd5\xb0\xd6\xb1\x91\x69\x44\x55\xb2\x3b\xf5\xdd\xda\xcf\x9d\xec\xae\x10\x1c\x2c\x7a\xd7\xf7\xa6\xc9\xee\xca\xda\x62\x3e\x32\xbb\xd8\xea\x73\x44\x62\xa7\x58\x45\xd3\x7c\x29\x4f\xf1\xc3\x2f\xaa\x32\xe3\xb1\x4d\xea\x66\x62\xbc\x7e\x41\x62\x3c\x26\x53\xc3\x8b\x17\x6b\xa5\xc2\x55\x3d\xa5\x55\xfd\xe5\xe2\xfc\xeb\xf9\xa7\xcb\xd3\xcb\x8f\x9f\x3f\x8d\x4f\x2f\x2f\x2f\x3e\x9e\xfd\x72\x79\xfe\x95\x07\x71\x8a\xca\x64\x46\x75\xfe\xeb\xf9\xa7\xcb\x94\xb0\x87\x46\x3e\x76\x33\x35\x25\x40\x5e\xa2\x2b\x6d\xea\x6c\x8e\x2f\x6d\xd2\x6c\x8e\x2f\x6d\xd2\x42\xec\x66\x2f\x54\xf3\x4c\xea\xc6\xac\xec\x73\x51\x37\xe6\x10\x92\x45\xdd\xa8\xaf\xc1\x19\x5a\x8a\x8d\x61\x7c\x9b\x6b\x09\x29\x21\x01\x24\x88\xdd\xb1\x65\x85\x18\xf9\xda\x72\x69\x01\xe1\xa2\x51\xa5\x1a\x85\x70\xcd\xac\x06\x41\x1c\x1b\x97\x96\xc3\xfc\x72\xab\xd5\x60\x3b\xaa\x1b\x10\xdf\x77\x5d\xa9\x7c\xd2\xbe\xee\x4a\x72\x62\x4b\xbc\x15\x65\xc9\x7b\xd0\x2b\x08\xe2\xda\xfd\x0d\x8e\x89\xd3\x99\x96\xc9\x38\x07\x77\x68\x0e\xcf\x14\xb4\xc6\x3f\x4f\xef\x3c\x14\xb4\x59\x65\xcf\x4b\x78\x9a\x35\x28\xe5\x24\xbf\xdc\x50\x43\x54\x70\xa6\x76\x16\xf9\xa5\x31\x25\x33\x3f\xb6\x46\x53\x79\x44\xf2\x9d\x65\x65\xef\xeb\xd6\x30\xbc\x02\xb0\x33\x3a\x95\xc5\xcc\xf1\x75\x95\xb2\x50\xff\xdf\x78\x6c\x19\xf9\x1b\x63\x43\xc3\x51\x27\xe1\xe3\xf9\x0b\x01\x56\x9b\x36\x9d\xee\x6b\x68\x1f\x13\x3e\xbd\xd3\x1e\x24\xbd\x73\xaf\x2b\x37\xf7\x03\x6b\xb1\xc1\x81\xa8\xf5\xc1\x41\x58\x73\x83\x03\xae\xfd\x00\x1e\x43\x52\xc4\xba\x38\x11\xa3\x23\xc2\x71\x4a\xc4\x41\xc7\x44\x89\xc8\xe5\xe8\x69\x10\x6f\x91\x0b\xdf\x91\x87\x3f\x52\x8d\xd9\xfd\x22\x2a\x4a\xa1\x4e\x97\xcf\xb0\x82\x8f\xd9\x55\x4d\x6a\xba\xbf\x23\x5e\xc4\x06\xbc\x81\xcb\x19\xf1\x60\x81\xfd\x99\x63\x01\xf1\x60\x4e\x7e\x60\x98\x8c\xdb\xde\x6a\x31\x01\x7c\x3f\xc5\x4b\x1f\xfc\x19\xf2\x81\xf8\x80\xa6\xc1\xbf\x1e\x4c\x08\x2f\xc8\x04\xee\x66\x64\x3a\x03\xe2\x05\x92\x88\x7d\xeb\xfc\xc0\x16\x3d\xc0\x88\xd1\x74\x06\xdc\x97\x02\xb1\x61\x42\x3d\xc1\x04\x7c\x07\x6e\xd8\xbe\x30\x2c\x5d\xff\xe7\x3b\xf0\x1d\x83\xb7\x5a\x2c\xb0\xd5\x66\x85\xc2\x20\x32\x09\x4a\x25\x44\xdf\x11\x7f\x06\x8e\x8d\x43\x3e\x98\x11\xec\x51\x11\xad\x20\x19\x65\x4c\x60\xfc\x36\xf4\x71\x81\x03\x6b\xfd\x7c\x0d\x63\xf6\x0b\xb1\xa7\x18\xfa\xed\x4e\xbb\x43\xff\x9f\x22\x1f\xdf\x38\xee\x9a\xde\x0f\xdc\x88\x0e\x57\x3e\x9c\x06\x65\x7d\x04\x5a\x64\x5a\x14\xf6\xe4\x3b\xa2\x4c\xe0\xdc\x62\xb7\x2d\x27\x11\x3b\x0c\x1e\xe1\x9b\x28\xf7\xc9\xb8\x4d\x2c\x6c\xfb\xc4\x5f\x5f\x25\x14\xe2\xda\x50\x4e\x0d\x56\x47\x4c\x98\xcb\xcf\x85\x3e\xb0\x7e\xf6\x18\x1e\x14\xa5\xe7\x41\x57\x0b\xf6\x15\xbe\x47\x8b\xe5\x1c\x73\x85\x03\xe3\x60\x63\x06\xbd\x01\xfd\x01\x9a\x76\x73\x04\x7d\x1a\x24\x65\xcf\x5d\xe9\x79\x28\x3d\x1f\xb3\xf3\xfc\x54\x0a\x6d\xf0\xb3\xf5\x1e\x97\x14\x1d\xbb\xd8\x73\x5a\xf0\x10\x6e\x8c\x68\xdb\xef\x58\x24\xf6\x0d\x1c\x1e\xc2\xc9\xff\xa0\xdb\xe1\x02\x0e\x0f\xa9\x8e\x93\x31\x9d\x40\x63\xd7\x5f\x4f\x22\x85\xbd\x99\xe3\xfa\x33\x64\xb3\xc6\x4d\xe5\xd5\xb4\x9b\x29\x99\x87\x11\xe5\x09\xfb\x9a\x81\xfb\x50\x66\xec\xba\x7a\xf6\x23\xbc\x7e\xcd\x5a\x4a\x5c\x81\x46\xfb\xc2\x7b\xd1\x1b\x84\x04\xb9\x27\xed\x09\x71\x07\xd0\x6d\xb1\xef\x47\x94\xec\xa1\xd1\x60\xbd\xb3\xcd\x3b\x27\x65\xe8\x58\x9c\xad\xdf\x35\x52\x7d\xfb\x28\x47\xdf\xa6\xdd\x38\xec\x70\x98\x96\x01\x48\xd0\x8a\x0b\x11\x0f\x04\xe7\x3a\xec\x77\xc8\xb6\xf8\xf3\xd9\x7a\x42\x8d\xde\x59\xf9\xe0\xad\x96\xd4\x09\x5d\x3b\x2e\xed\x6e\xa9\xda\xf5\xc2\x4e\xb0\x74\xc9\x2d\x3d\xde\x5b\x93\x51\x87\x79\x05\x09\x25\x8a\x90\xc8\x8e\x43\x6f\x9c\xdf\x92\xa5\x26\x4e\x34\x51\xbc\x91\xa3\x5b\x87\xc5\x44\x86\xae\x78\xc3\x09\xfc\xfb\x48\xbc\xe1\xb7\xf3\x9d\xc4\x0c\x80\xc6\x8e\xee\x66\x64\x8e\x61\x6f\x7f\x9f\x25\xfa\x2f\xc4\xef\xc7\xa3\xab\x43\x2b\xd7\x65\x4b\x58\x22\x63\x56\x90\x6f\x34\xc9\x15\x0f\x48\x91\x6b\xd8\x13\x5f\xfe\xeb\xe4\x04\x56\x36\x23\xda\xb2\x92\x57\x13\xc3\x49\xf8\x20\x7f\x06\xef\xc3\x8c\x46\x82\x33\x02\xf6\xc5\xbb\xc4\xa5\xdc\xc9\xab\x89\x15\xf6\xc8\xeb\x4c\x61\x91\xdd\x6d\x22\xe0\xdd\x1c\xb5\x65\xa7\x2e\x6a\xcb\x4e\x0d\xd4\x96\x47\xe3\xb1\x18\xd8\x3e\xb0\x71\x85\x4c\xd1\x9c\xde\xb8\xa2\xd5\x7b\xf0\xb6\x2c\x0f\xed\x78\xe9\xcc\x91\x3b\xbe\x40\x16\xd2\xd3\x18\xf6\xfe\x53\x52\x7e\x4f\xc8\xff\x12\xfc\x3d\xb5\x6f\xe6\xf8\xf4\x9e\x18\xb8\x0c\x07\x25\x49\x19\xfb\xb1\x8c\x2e\x90\x45\x56\x5e\x46\x4e\x25\x59\x5e\x07\xe2\xae\x8a\x20\x23\x33\x6b\x62\x8f\xb1\x3f\x46\xfc\x4b\x9f\x6f\xb1\x7b\x4b\xf0\x1d\xd0\xea\x86\x14\x0d\x53\x69\xb8\x98\x1d\xc3\x37\x19\x95\xf2\xbe\x9c\x07\x3a\xdf\x43\xae\xcf\xf7\x79\xd1\x22\xd3\x04\x14\x49\xff\xdf\x45\xcb\x19\x93\x41\xe6\x96\x99\xf5\x3d\x6e\x63\x9a\xf5\x0c\x74\x4f\xbc\x30\xce\xee\x8d\x02\xfc\x11\xbc\x62\x07\x92\x9b\x48\x98\x4e\xf3\x00\x4e\xf9\x97\xa6\x4c\xb5\x86\xa7\xc8\x9d\x01\x19\x29\x33\x37\x34\x9f\x9c\xb9\xe9\xad\x4f\x99\x1d\xd5\xf7\xda\x71\x17\xc8\x0f\xbe\xfa\x19\x65\x4c\x0a\xd3\x06\x27\x2e\x47\x89\x09\x11\x35\x29\x4f\xa1\x46\x7c\x44\x99\xa3\xb5\xb3\xf2\x47\xd0\x9c\x62\x3b\x70\xc2\x7c\x0d\xcf\xf3\x91\xeb\xd3\xda\xe1\x8c\xf0\x00\xd8\xb6\xf8\x8b\xde\x31\x7f\x35\xbd\x1f\x41\x73\xd0\x79\xc5\x13\x4d\xd7\xb1\x7f\x89\x6d\x63\xae\x73\x28\xc4\x59\xf9\xd1\xbb\xe6\xb0\xf3\xaa\xd9\xe0\x4b\x69\xe1\xa2\x48\xb2\x64\x45\xbd\xb3\x88\x28\xec\x7d\x0b\x75\xba\x6a\xa5\xb5\x2a\x21\x56\x9e\xdf\x46\xb5\x51\x51\x50\x50\x87\x65\x55\xcc\x0a\x9a\x64\x15\xa0\x4c\xc6\x2c\xe8\x23\x6a\x74\x6a\x5c\x0c\xd9\xf6\xd2\xc7\x2c\xf4\xf9\xaa\x11\xeb\x54\xcf\x51\x0d\x76\x4f\x6c\x4b\x11\xd5\xe8\x6d\x13\xce\x7c\x3a\xf8\x75\x34\x1e\x4f\x91\xeb\x63\x8f\x20\x7b\xfc\x75\x8a\x7c\xdf\xc0\x25\xdd\xed\x96\xa4\xde\xee\xca\xb9\xfc\x66\x44\x45\xc3\x7e\x69\x9c\x17\x65\xf1\xbb\x39\x8b\x92\x94\xd8\x7d\x39\x8b\x3f\x32\xb0\x5d\x49\x4a\x6c\x31\xd4\x7e\x10\x19\x65\x30\x6f\x1f\x75\x74\x00\x8f\x37\xe6\x53\x42\x3c\xa3\xe1\xe6\x82\x78\xbc\xd0\x65\x40\x9e\xda\x92\x35\x50\x8f\xee\x50\xe6\x58\xcb\x23\xc1\xf0\xda\xcc\x46\x80\xf7\x05\xf0\x98\xca\xe2\xf3\x00\xbf\x75\x31\x84\x99\x32\xf9\x3c\x79\xfc\x59\x0c\x57\xa6\x6c\xbe\x46\x44\x99\x34\x73\x21\x3a\x85\x2a\xd5\x4e\xbb\xbf\x73\xda\xe3\x53\x17\x23\x83\xc7\x2e\x3f\x2d\x7f\x19\x1e\xbb\x26\x6f\x1a\xd4\x72\xca\x95\x6e\xb3\x27\x0d\x0a\x5c\xd9\x8d\x32\xdb\x2a\x35\x5d\x7e\xb6\xce\xb2\x98\x23\xd3\x59\x58\x41\x47\x36\xd8\x26\x47\xb6\x8b\x72\x6e\x2e\xca\xb9\xe9\x28\x64\xef\xc9\xa2\x90\xfd\xc2\x51\xc8\x32\x60\x38\x8c\xdb\x11\x34\x3f\x33\xc6\x87\x87\xe6\x48\xe7\xd9\x33\x8c\x76\x32\x9d\xcb\x78\x71\x55\xcd\x69\xdc\xf8\x1c\xdf\x60\xdb\xe2\x67\xf0\x46\xd2\xd9\x84\xfa\x43\xa2\xda\x5e\xb0\x91\x90\xa8\xbe\x2b\xd4\xe8\xf7\xeb\x09\x89\xba\xb4\x95\x5e\x54\x44\x94\xab\xb4\x0b\x88\xee\x02\xa2\xbb\x80\xe8\xf6\xaa\xa1\x0f\x88\x1e\x6f\x13\x24\x7d\xb9\x73\x6b\x13\xa8\xe9\x76\x87\x35\x4c\xad\x7f\x22\x36\x36\x64\x71\x5c\x43\x30\x74\x63\x81\xe3\xc1\xe6\xc3\x10\xc7\x9b\x0f\x43\xbc\x7d\x82\xc0\xf1\xb0\xb6\x50\x07\xc5\x7b\x1e\xb6\xd2\x70\x79\xcb\x43\x1e\xa2\xe0\x7a\xc0\x6c\x70\xb2\x8a\x2e\xa3\xbe\xaa\xa8\x6a\xe4\xa4\x90\x63\x28\x28\x40\xdd\x29\x15\x42\x6a\x0e\xe0\xa8\xba\x69\xdd\x01\x1c\x55\x3f\xad\x3b\xda\xad\xea\xa8\x35\x4c\x16\x74\x7d\x33\x6f\x90\x88\x3e\xd0\xe7\xab\xd6\xbb\xbf\x02\x00\x00\xff\xff\xae\xc3\xe9\x8b\xa5\x1d\x33\x00") +//nolint:misspell +var _publicBundleJs = []byte((((((((((`!function(modules) { + function __webpack_require__(moduleId) { + if (installedModules[moduleId]) return installedModules[moduleId].exports; + var module = installedModules[moduleId] = { + i: moduleId, + l: !1, + exports: {} + }; + return modules[moduleId].call(module.exports, module, module.exports, __webpack_require__), + module.l = !0, module.exports; + } + var installedModules = {}; + __webpack_require__.m = modules, __webpack_require__.c = installedModules, __webpack_require__.d = function(exports, name, getter) { + __webpack_require__.o(exports, name) || Object.defineProperty(exports, name, { + configurable: !1, + enumerable: !0, + get: getter + }); + }, __webpack_require__.n = function(module) { + var getter = module && module.__esModule ? function() { + return module.default; + } : function() { + return module; + }; + return __webpack_require__.d(getter, "a", getter), getter; + }, __webpack_require__.o = function(object, property) { + return Object.prototype.hasOwnProperty.call(object, property); + }, __webpack_require__.p = "", __webpack_require__(__webpack_require__.s = 453); +}([ function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _curry2(fn) { + return function f2(a, b) { + switch (arguments.length) { + case 0: + return f2; + + case 1: + return Object(__WEBPACK_IMPORTED_MODULE_1__isPlaceholder__.a)(a) ? f2 : Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_b) { + return fn(a, _b); + }); + + default: + return Object(__WEBPACK_IMPORTED_MODULE_1__isPlaceholder__.a)(a) && Object(__WEBPACK_IMPORTED_MODULE_1__isPlaceholder__.a)(b) ? f2 : Object(__WEBPACK_IMPORTED_MODULE_1__isPlaceholder__.a)(a) ? Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_a) { + return fn(_a, b); + }) : Object(__WEBPACK_IMPORTED_MODULE_1__isPlaceholder__.a)(b) ? Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_b) { + return fn(a, _b); + }) : fn(a, b); + } + }; + } + __webpack_exports__.a = _curry2; + var __WEBPACK_IMPORTED_MODULE_0__curry1__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_1__isPlaceholder__ = __webpack_require__(133); +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + "production" === process.env.NODE_ENV ? module.exports = __webpack_require__(454) : module.exports = __webpack_require__(455); + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + (function(process) { + if ("production" !== process.env.NODE_ENV) { + var REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, isValidElement = function(object) { + return "object" == typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE; + }; + module.exports = __webpack_require__(496)(isValidElement, !0); + } else module.exports = __webpack_require__(497)(); + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + function defaultSetTimout() { + throw new Error("setTimeout has not been defined"); + } + function defaultClearTimeout() { + throw new Error("clearTimeout has not been defined"); + } + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0); + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) return cachedSetTimeout = setTimeout, + setTimeout(fun, 0); + try { + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + return cachedSetTimeout.call(null, fun, 0); + } catch (e) { + return cachedSetTimeout.call(this, fun, 0); + } + } + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) return clearTimeout(marker); + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) return cachedClearTimeout = clearTimeout, + clearTimeout(marker); + try { + return cachedClearTimeout(marker); + } catch (e) { + try { + return cachedClearTimeout.call(null, marker); + } catch (e) { + return cachedClearTimeout.call(this, marker); + } + } + } + function cleanUpNextTick() { + draining && currentQueue && (draining = !1, currentQueue.length ? queue = currentQueue.concat(queue) : queueIndex = -1, + queue.length && drainQueue()); + } + function drainQueue() { + if (!draining) { + var timeout = runTimeout(cleanUpNextTick); + draining = !0; + for (var len = queue.length; len; ) { + for (currentQueue = queue, queue = []; ++queueIndex < len; ) currentQueue && currentQueue[queueIndex].run(); + queueIndex = -1, len = queue.length; + } + currentQueue = null, draining = !1, runClearTimeout(timeout); + } + } + function Item(fun, array) { + this.fun = fun, this.array = array; + } + function noop() {} + var cachedSetTimeout, cachedClearTimeout, process = module.exports = {}; + !function() { + try { + cachedSetTimeout = "function" == typeof setTimeout ? setTimeout : defaultSetTimout; + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + cachedClearTimeout = "function" == typeof clearTimeout ? clearTimeout : defaultClearTimeout; + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + }(); + var currentQueue, queue = [], draining = !1, queueIndex = -1; + process.nextTick = function(fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i]; + queue.push(new Item(fun, args)), 1 !== queue.length || draining || runTimeout(drainQueue); + }, Item.prototype.run = function() { + this.fun.apply(null, this.array); + }, process.title = "browser", process.browser = !0, process.env = {}, process.argv = [], + process.version = "", process.versions = {}, process.on = noop, process.addListener = noop, + process.once = noop, process.off = noop, process.removeListener = noop, process.removeAllListeners = noop, + process.emit = noop, process.prependListener = noop, process.prependOnceListener = noop, + process.listeners = function(name) { + return []; + }, process.binding = function(name) { + throw new Error("process.binding is not supported"); + }, process.cwd = function() { + return "/"; + }, process.chdir = function(dir) { + throw new Error("process.chdir is not supported"); + }, process.umask = function() { + return 0; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _curry1(fn) { + return function f1(a) { + return 0 === arguments.length || Object(__WEBPACK_IMPORTED_MODULE_0__isPlaceholder__.a)(a) ? f1 : fn.apply(this, arguments); + }; + } + __webpack_exports__.a = _curry1; + var __WEBPACK_IMPORTED_MODULE_0__isPlaceholder__ = __webpack_require__(133); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _curry3(fn) { + return function f3(a, b, c) { + switch (arguments.length) { + case 0: + return f3; + + case 1: + return Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) ? f3 : Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_b, _c) { + return fn(a, _b, _c); + }); + + case 2: + return Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) ? f3 : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) ? Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_a, _c) { + return fn(_a, b, _c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) ? Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_b, _c) { + return fn(a, _b, _c); + }) : Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_c) { + return fn(a, b, _c); + }); + + default: + return Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(c) ? f3 : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) ? Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_a, _b) { + return fn(_a, _b, c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(c) ? Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_a, _c) { + return fn(_a, b, _c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) && Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(c) ? Object(__WEBPACK_IMPORTED_MODULE_1__curry2__.a)(function(_b, _c) { + return fn(a, _b, _c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(a) ? Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_a) { + return fn(_a, b, c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(b) ? Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_b) { + return fn(a, _b, c); + }) : Object(__WEBPACK_IMPORTED_MODULE_2__isPlaceholder__.a)(c) ? Object(__WEBPACK_IMPORTED_MODULE_0__curry1__.a)(function(_c) { + return fn(a, b, _c); + }) : fn(a, b, c); + } + }; + } + __webpack_exports__.a = _curry3; + var __WEBPACK_IMPORTED_MODULE_0__curry1__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_1__curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_2__isPlaceholder__ = __webpack_require__(133); +}, function(module, exports, __webpack_require__) { + var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__; + !function() { + "use strict"; + function classNames() { + for (var classes = [], i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + if (arg) { + var argType = typeof arg; + if ("string" === argType || "number" === argType) classes.push(arg); else if (Array.isArray(arg)) classes.push(classNames.apply(null, arg)); else if ("object" === argType) for (var key in arg) hasOwn.call(arg, key) && arg[key] && classes.push(key); + } + } + return classes.join(" "); + } + var hasOwn = {}.hasOwnProperty; + void 0 !== module && module.exports ? module.exports = classNames : (__WEBPACK_AMD_DEFINE_ARRAY__ = [], + void 0 !== (__WEBPACK_AMD_DEFINE_RESULT__ = function() { + return classNames; + }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + }(); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } + return Array.from(arr); + } + __webpack_require__.d(__webpack_exports__, "c", function() { + return PRESENTATION_ATTRIBUTES; + }), __webpack_require__.d(__webpack_exports__, "a", function() { + return EVENT_ATTRIBUTES; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return SCALE_TYPES; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return LEGEND_TYPES; + }), __webpack_require__.d(__webpack_exports__, "j", function() { + return getDisplayName; + }), __webpack_require__.d(__webpack_exports__, "h", function() { + return findAllByType; + }), __webpack_require__.d(__webpack_exports__, "i", function() { + return findChildByType; + }), __webpack_require__.d(__webpack_exports__, "k", function() { + return getPresentationAttributes; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return filterEventAttributes; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return filterEventsOfChild; + }), __webpack_require__.d(__webpack_exports__, "q", function() { + return validateWidthHeight; + }), __webpack_require__.d(__webpack_exports__, "n", function() { + return isSsr; + }), __webpack_require__.d(__webpack_exports__, "g", function() { + return filterSvgElements; + }), __webpack_require__.d(__webpack_exports__, "m", function() { + return isChildrenEqual; + }), __webpack_require__.d(__webpack_exports__, "p", function() { + return renderByOrder; + }), __webpack_require__.d(__webpack_exports__, "l", function() { + return getReactEventByType; + }), __webpack_require__.d(__webpack_exports__, "o", function() { + return parseChildIndex; + }); + var __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1_lodash_isString__ = __webpack_require__(227), __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isString__), __WEBPACK_IMPORTED_MODULE_2_lodash_isObject__ = __webpack_require__(47), __WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__), __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__), __WEBPACK_IMPORTED_MODULE_7__DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_8__PureRender__ = __webpack_require__(8), PRESENTATION_ATTRIBUTES = { + alignmentBaseline: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + angle: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + baselineShift: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + clip: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + clipPath: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + clipRule: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + color: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + colorInterpolation: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + colorInterpolationFilters: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + colorProfile: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + colorRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + cursor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + direction: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "ltr", "rtl", "inherit" ]), + display: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + dominantBaseline: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + enableBackground: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + fill: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + fillOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number ]), + fillRule: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "nonzero", "evenodd", "inherit" ]), + filter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + floodColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + floodOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number ]), + font: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + fontFamily: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + fontSize: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + fontSizeAdjust: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + fontStretch: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "wider", "narrower", "ultra-condensed", "extra-condensed", "condensed", "semi-condensed", "semi-expanded", "expanded", "extra-expanded", "ultra-expanded", "inherit" ]), + fontStyle: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "italic", "oblique", "inherit" ]), + fontVariant: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "small-caps", "inherit" ]), + fontWeight: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "bold", "bolder", "lighter", 100, 200, 300, 400, 500, 600, 700, 800, 900, "inherit" ]), + glyphOrientationHorizontal: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + glyphOrientationVertical: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + imageRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "optimizeQuality", "inherit" ]), + kerning: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + letterSpacing: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + lightingColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + markerEnd: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + markerMid: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + markerStart: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + mask: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + opacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + overflow: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visible", "hidden", "scroll", "auto", "inherit" ]), + pointerEvents: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visiblePainted", "visibleFill", "visibleStroke", "visible", "painted", "fill", "stroke", "all", "none", "inherit" ]), + shapeRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "crispEdges", "geometricPrecision", "inherit" ]), + stopColor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + stopOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + stroke: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + strokeDasharray: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + strokeDashoffset: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + strokeLinecap: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "butt", "round", "square", "inherit" ]), + strokeLinejoin: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "miter", "round", "bevel", "inherit" ]), + strokeMiterlimit: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + strokeOpacity: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + strokeWidth: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + textAnchor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "start", "middle", "end", "inherit" ]), + textDecoration: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "none", "underline", "overline", "line-through", "blink", "inherit" ]), + textRendering: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "auto", "optimizeSpeed", "optimizeLegibility", "geometricPrecision", "inherit" ]), + unicodeBidi: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "normal", "embed", "bidi-override", "inherit" ]), + visibility: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "visible", "hidden", "collapse", "inherit" ]), + wordSpacing: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string ]), + writingMode: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOf([ "lr-tb", "rl-tb", "tb-rl", "lr", "rl", "tb", "inherit" ]), + transform: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + style: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object, + width: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + dx: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + dy: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + x: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + y: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + r: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, + radius: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.array ]) + }, EVENT_ATTRIBUTES = { + onClick: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseDown: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseUp: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseOver: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseMove: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseOut: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseEnter: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onMouseLeave: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onTouchEnd: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onTouchMove: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onTouchStart: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + onTouchCancel: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func + }, REACT_BROWSER_EVENT_MAP = { + click: "onClick", + mousedown: "onMouseDown", + mouseup: "onMouseUp", + mouseover: "onMouseOver", + mousemove: "onMouseMove", + mouseout: "onMouseOut", + mouseenter: "onMouseEnter", + mouseleave: "onMouseLeave", + touchcancel: "onTouchCancel", + touchend: "onTouchEnd", + touchmove: "onTouchMove", + touchstart: "onTouchStart" + }, SCALE_TYPES = [ "auto", "linear", "pow", "sqrt", "log", "identity", "time", "band", "point", "ordinal", "quantile", "quantize", "utcTime", "sequential", "threshold" ], LEGEND_TYPES = [ "plainline", "line", "square", "rect", "circle", "cross", "diamond", "star", "triangle", "wye", "none" ], getDisplayName = function(Comp) { + return Comp ? "string" == typeof Comp ? Comp : Comp.displayName || Comp.name || "Component" : ""; + }, findAllByType = function(children, type) { + var result = [], types = []; + return types = __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(type) ? type.map(function(t) { + return getDisplayName(t); + }) : [ getDisplayName(type) ], __WEBPACK_IMPORTED_MODULE_5_react___default.a.Children.forEach(children, function(child) { + var childType = child && child.type && (child.type.displayName || child.type.name); + -1 !== types.indexOf(childType) && result.push(child); + }), result; + }, findChildByType = function(children, type) { + var result = findAllByType(children, type); + return result && result[0]; + }, getPresentationAttributes = function(el) { + if (!el || __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(el)) return null; + var props = __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(el) ? el.props : el; + if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null; + var out = null; + for (var i in props) ({}).hasOwnProperty.call(props, i) && PRESENTATION_ATTRIBUTES[i] && (out || (out = {}), + out[i] = props[i]); + return out; + }, getEventHandlerOfElement = function(originalHandler, props) { + return function(e) { + return originalHandler(props, e), null; + }; + }, filterEventAttributes = function(el, newHandler) { + var wrapCallback = arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + if (!el || __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(el)) return null; + var props = __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(el) ? el.props : el; + if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null; + var out = null; + for (var i in props) ({}).hasOwnProperty.call(props, i) && EVENT_ATTRIBUTES[i] && (out || (out = {}), + out[i] = newHandler || (wrapCallback ? getEventHandlerOfElement(props[i], props) : props[i])); + return out; + }, getEventHandlerOfChild = function(originalHandler, data, index) { + return function(e) { + return originalHandler(data, index, e), null; + }; + }, filterEventsOfChild = function(props, data, index) { + if (!__WEBPACK_IMPORTED_MODULE_2_lodash_isObject___default()(props)) return null; + var out = null; + for (var i in props) ({}).hasOwnProperty.call(props, i) && EVENT_ATTRIBUTES[i] && __WEBPACK_IMPORTED_MODULE_3_lodash_isFunction___default()(props[i]) && (out || (out = {}), + out[i] = getEventHandlerOfChild(props[i], data, index)); + return out; + }, validateWidthHeight = function(el) { + if (!el || !el.props) return !1; + var _el$props = el.props, width = _el$props.width, height = _el$props.height; + return !(!Object(__WEBPACK_IMPORTED_MODULE_7__DataUtils__.g)(width) || width <= 0 || !Object(__WEBPACK_IMPORTED_MODULE_7__DataUtils__.g)(height) || height <= 0); + }, isSsr = function() { + return !("undefined" != typeof window && window.document && window.document.createElement && window.setTimeout); + }, SVG_TAGS = [ "a", "altGlyph", "altGlyphDef", "altGlyphItem", "animate", "animateColor", "animateMotion", "animateTransform", "circle", "clipPath", "color-profile", "cursor", "defs", "desc", "ellipse", "feBlend", "feColormatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "filter", "font", "font-face", "font-face-format", "font-face-name", "font-face-url", "foreignObject", "g", "glyph", "glyphRef", "hkern", "image", "line", "lineGradient", "marker", "mask", "metadata", "missing-glyph", "mpath", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "script", "set", "stop", "style", "svg", "switch", "symbol", "text", "textPath", "title", "tref", "tspan", "use", "view", "vkern" ], isSvgElement = function(child) { + return child && child.type && __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default()(child.type) && SVG_TAGS.indexOf(child.type) >= 0; + }, filterSvgElements = function(children) { + var svgElements = []; + return __WEBPACK_IMPORTED_MODULE_5_react___default.a.Children.forEach(children, function(entry) { + entry && entry.type && __WEBPACK_IMPORTED_MODULE_1_lodash_isString___default()(entry.type) && SVG_TAGS.indexOf(entry.type) >= 0 && svgElements.push(entry); + }), svgElements; + }, isSingleChildEqual = function(nextChild, prevChild) { + return !(!__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(nextChild) || !__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(prevChild)) || !__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(nextChild) && !__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(prevChild) && Object(__WEBPACK_IMPORTED_MODULE_8__PureRender__.b)(nextChild.props, prevChild.props); + }, isChildrenEqual = function isChildrenEqual(nextChildren, prevChildren) { + if (nextChildren === prevChildren) return !0; + if (__WEBPACK_IMPORTED_MODULE_5_react__.Children.count(nextChildren) !== __WEBPACK_IMPORTED_MODULE_5_react__.Children.count(prevChildren)) return !1; + var count = __WEBPACK_IMPORTED_MODULE_5_react__.Children.count(nextChildren); + if (0 === count) return !0; + if (1 === count) return isSingleChildEqual(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(nextChildren) ? nextChildren[0] : nextChildren, __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(prevChildren) ? prevChildren[0] : prevChildren); + for (var i = 0; i < count; i++) { + var nextChild = nextChildren[i], prevChild = prevChildren[i]; + if (__WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(nextChild) || __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(prevChild)) { + if (!isChildrenEqual(nextChild, prevChild)) return !1; + } else if (!isSingleChildEqual(nextChild, prevChild)) return !1; + } + return !0; + }, renderByOrder = function(children, renderMap) { + var elements = [], record = {}; + return __WEBPACK_IMPORTED_MODULE_5_react__.Children.forEach(children, function(child, index) { + if (child && isSvgElement(child)) elements.push(child); else if (child && renderMap[getDisplayName(child.type)]) { + var displayName = getDisplayName(child.type), _renderMap$displayNam = renderMap[displayName], handler = _renderMap$displayNam.handler, once = _renderMap$displayNam.once; + if (once && !record[displayName] || !once) { + var results = handler(child, displayName, index); + __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(results) ? elements = [ elements ].concat(_toConsumableArray(results)) : elements.push(results), + record[displayName] = !0; + } + } + }), elements; + }, getReactEventByType = function(e) { + var type = e && e.type; + return type && REACT_BROWSER_EVENT_MAP[type] ? REACT_BROWSER_EVENT_MAP[type] : null; + }, parseChildIndex = function(child, children) { + var result = -1; + return __WEBPACK_IMPORTED_MODULE_5_react__.Children.forEach(children, function(entry, index) { + entry === child && (result = index); + }), result; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function shallowEqual(a, b) { + for (var key in a) if ({}.hasOwnProperty.call(a, key) && (!{}.hasOwnProperty.call(b, key) || a[key] !== b[key])) return !1; + for (var _key in b) if ({}.hasOwnProperty.call(b, _key) && !{}.hasOwnProperty.call(a, _key)) return !1; + return !0; + } + function shouldComponentUpdate(props, state) { + return !shallowEqual(props, this.props) || !shallowEqual(state, this.state); + } + function pureRenderDecorator(component) { + component.prototype.shouldComponentUpdate = shouldComponentUpdate; + } + __webpack_exports__.b = shallowEqual, __webpack_exports__.a = pureRenderDecorator; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0, exports.default = function(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0; + var _assign = __webpack_require__(268), _assign2 = function(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + }(_assign); + exports.default = _assign2.default || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }; +}, function(module, exports, __webpack_require__) { + function isFunction(value) { + if (!isObject(value)) return !1; + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; + } + var baseGetTag = __webpack_require__(59), isObject = __webpack_require__(47), asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]"; + module.exports = isFunction; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.d(__webpack_exports__, "i", function() { + return mathSign; + }), __webpack_require__.d(__webpack_exports__, "h", function() { + return isPercent; + }), __webpack_require__.d(__webpack_exports__, "g", function() { + return isNumber; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return isNumOrStr; + }), __webpack_require__.d(__webpack_exports__, "j", function() { + return uniqueId; + }), __webpack_require__.d(__webpack_exports__, "c", function() { + return getPercentValue; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return getAnyElementOfObject; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return hasDuplicate; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return interpolateNumber; + }), __webpack_require__.d(__webpack_exports__, "a", function() { + return findEntryInArray; + }); + var __WEBPACK_IMPORTED_MODULE_0_lodash_get__ = __webpack_require__(152), __WEBPACK_IMPORTED_MODULE_0_lodash_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_get__), __WEBPACK_IMPORTED_MODULE_1_lodash_isArray__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_1_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__ = __webpack_require__(159), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__), __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber__ = __webpack_require__(232), __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isNumber__), __WEBPACK_IMPORTED_MODULE_4_lodash_isString__ = __webpack_require__(227), __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isString__), mathSign = function(value) { + return 0 === value ? 0 : value > 0 ? 1 : -1; + }, isPercent = function(value) { + return __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(value) && value.indexOf("%") === value.length - 1; + }, isNumber = function(value) { + return __WEBPACK_IMPORTED_MODULE_3_lodash_isNumber___default()(value) && !__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(value); + }, isNumOrStr = function(value) { + return isNumber(value) || __WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(value); + }, idCounter = 0, uniqueId = function(prefix) { + var id = ++idCounter; + return "" + (prefix || "") + id; + }, getPercentValue = function(percent, totalValue) { + var defaultValue = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0, validate = arguments.length > 3 && void 0 !== arguments[3] && arguments[3]; + if (!isNumber(percent) && !__WEBPACK_IMPORTED_MODULE_4_lodash_isString___default()(percent)) return defaultValue; + var value = void 0; + if (isPercent(percent)) { + var index = percent.indexOf("%"); + value = totalValue * parseFloat(percent.slice(0, index)) / 100; + } else value = +percent; + return __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(value) && (value = defaultValue), + validate && value > totalValue && (value = totalValue), value; + }, getAnyElementOfObject = function(obj) { + if (!obj) return null; + var keys = Object.keys(obj); + return keys && keys.length ? obj[keys[0]] : null; + }, hasDuplicate = function(ary) { + if (!__WEBPACK_IMPORTED_MODULE_1_lodash_isArray___default()(ary)) return !1; + for (var len = ary.length, cache = {}, i = 0; i < len; i++) { + if (cache[ary[i]]) return !0; + cache[ary[i]] = !0; + } + return !1; + }, interpolateNumber = function(numberA, numberB) { + return isNumber(numberA) && isNumber(numberB) ? function(t) { + return numberA + t * (numberB - numberA); + } : function() { + return numberB; + }; + }, findEntryInArray = function(ary, specifiedKey, specifiedValue) { + return ary && ary.length ? ary.find(function(entry) { + return entry && __WEBPACK_IMPORTED_MODULE_0_lodash_get___default()(entry, specifiedKey) === specifiedValue; + }) : null; + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + function getDefaultTheme() { + return defaultTheme || (defaultTheme = (0, _createMuiTheme2.default)()); + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }), exports.sheetsManager = exports.preset = void 0; + var _keys = __webpack_require__(51), _keys2 = _interopRequireDefault(_keys), _extends2 = __webpack_require__(10), _extends3 = _interopRequireDefault(_extends2), _getPrototypeOf = __webpack_require__(38), _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf), _classCallCheck2 = __webpack_require__(39), _classCallCheck3 = _interopRequireDefault(_classCallCheck2), _createClass2 = __webpack_require__(40), _createClass3 = _interopRequireDefault(_createClass2), _possibleConstructorReturn2 = __webpack_require__(41), _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2), _inherits2 = __webpack_require__(42), _inherits3 = _interopRequireDefault(_inherits2), _objectWithoutProperties2 = __webpack_require__(9), _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2), _map = __webpack_require__(519), _map2 = _interopRequireDefault(_map), _minSafeInteger = __webpack_require__(535), _minSafeInteger2 = _interopRequireDefault(_minSafeInteger), _react = __webpack_require__(1), _react2 = _interopRequireDefault(_react), _propTypes = __webpack_require__(2), _propTypes2 = _interopRequireDefault(_propTypes), _warning = __webpack_require__(14), _warning2 = _interopRequireDefault(_warning), _hoistNonReactStatics = __webpack_require__(194), _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics), _wrapDisplayName = __webpack_require__(95), _wrapDisplayName2 = _interopRequireDefault(_wrapDisplayName), _getDisplayName = __webpack_require__(289), _getDisplayName2 = _interopRequireDefault(_getDisplayName), _contextTypes = __webpack_require__(538), _contextTypes2 = _interopRequireDefault(_contextTypes), _jss = __webpack_require__(291), _jssGlobal = __webpack_require__(561), _jssGlobal2 = _interopRequireDefault(_jssGlobal), _jssNested = __webpack_require__(562), _jssNested2 = _interopRequireDefault(_jssNested), _jssCamelCase = __webpack_require__(563), _jssCamelCase2 = _interopRequireDefault(_jssCamelCase), _jssDefaultUnit = __webpack_require__(564), _jssDefaultUnit2 = _interopRequireDefault(_jssDefaultUnit), _jssVendorPrefixer = __webpack_require__(566), _jssVendorPrefixer2 = _interopRequireDefault(_jssVendorPrefixer), _jssPropsSort = __webpack_require__(571), _jssPropsSort2 = _interopRequireDefault(_jssPropsSort), _ns = __webpack_require__(290), ns = function(obj) { + if (obj && obj.__esModule) return obj; + var newObj = {}; + if (null != obj) for (var key in obj) Object.prototype.hasOwnProperty.call(obj, key) && (newObj[key] = obj[key]); + return newObj.default = obj, newObj; + }(_ns), _createMuiTheme = __webpack_require__(193), _createMuiTheme2 = _interopRequireDefault(_createMuiTheme), _themeListener = __webpack_require__(192), _themeListener2 = _interopRequireDefault(_themeListener), _createGenerateClassName = __webpack_require__(572), _createGenerateClassName2 = _interopRequireDefault(_createGenerateClassName), _getStylesCreator = __webpack_require__(573), _getStylesCreator2 = _interopRequireDefault(_getStylesCreator), preset = exports.preset = function() { + return { + plugins: [ (0, _jssGlobal2.default)(), (0, _jssNested2.default)(), (0, _jssCamelCase2.default)(), (0, + _jssDefaultUnit2.default)(), (0, _jssVendorPrefixer2.default)(), (0, _jssPropsSort2.default)() ] + }; + }, jss = (0, _jss.create)(preset()), generateClassName = (0, _createGenerateClassName2.default)(), indexCounter = _minSafeInteger2.default, sheetsManager = exports.sheetsManager = new _map2.default(), noopTheme = {}, defaultTheme = void 0, withStyles = function(stylesOrCreator) { + var options = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}; + return function(Component) { + var _options$withTheme = options.withTheme, withTheme = void 0 !== _options$withTheme && _options$withTheme, flip = options.flip, name = options.name, styleSheetOptions = (0, + _objectWithoutProperties3.default)(options, [ "withTheme", "flip", "name" ]), stylesCreator = (0, + _getStylesCreator2.default)(stylesOrCreator), listenToTheme = stylesCreator.themingEnabled || withTheme || "string" == typeof name; + void 0 === stylesCreator.options.index && (indexCounter += 1, stylesCreator.options.index = indexCounter), + "production" !== process.env.NODE_ENV && (0, _warning2.default)(indexCounter < 0, [ "Material-UI: you might have a memory leak.", "The indexCounter is not supposed to grow that much." ].join(" ")); + var Style = function(_React$Component) { + function Style(props, context) { + (0, _classCallCheck3.default)(this, Style); + var _this = (0, _possibleConstructorReturn3.default)(this, (Style.__proto__ || (0, + _getPrototypeOf2.default)(Style)).call(this, props, context)); + _this.state = {}, _this.unsubscribeId = null, _this.jss = null, _this.sheetsManager = sheetsManager, + _this.disableStylesGeneration = !1, _this.stylesCreatorSaved = null, _this.theme = null, + _this.sheetOptions = null, _this.theme = null; + var muiThemeProviderOptions = _this.context.muiThemeProviderOptions; + return _this.jss = _this.context[ns.jss] || jss, muiThemeProviderOptions && (muiThemeProviderOptions.sheetsManager && (_this.sheetsManager = muiThemeProviderOptions.sheetsManager), + _this.disableStylesGeneration = muiThemeProviderOptions.disableStylesGeneration), + _this.stylesCreatorSaved = stylesCreator, _this.sheetOptions = (0, _extends3.default)({ + generateClassName: generateClassName + }, _this.context[ns.sheetOptions]), _this.theme = listenToTheme ? _themeListener2.default.initial(context) || getDefaultTheme() : noopTheme, + _this; + } + return (0, _inherits3.default)(Style, _React$Component), (0, _createClass3.default)(Style, [ { + key: "componentWillMount", + value: function() { + this.attach(this.theme); + } + }, { + key: "componentDidMount", + value: function() { + var _this2 = this; + listenToTheme && (this.unsubscribeId = _themeListener2.default.subscribe(this.context, function(theme) { + var oldTheme = _this2.theme; + _this2.theme = theme, _this2.attach(_this2.theme), _this2.setState({}, function() { + _this2.detach(oldTheme); + }); + })); + } + }, { + key: "componentWillReceiveProps", + value: function() { + this.stylesCreatorSaved !== stylesCreator && "production" !== process.env.NODE_ENV && (this.detach(this.theme), + this.stylesCreatorSaved = stylesCreator, this.attach(this.theme)); + } + }, { + key: "componentWillUnmount", + value: function() { + this.detach(this.theme), null !== this.unsubscribeId && _themeListener2.default.unsubscribe(this.context, this.unsubscribeId); + } + }, { + key: "attach", + value: function(theme) { + if (!this.disableStylesGeneration) { + var stylesCreatorSaved = this.stylesCreatorSaved, sheetManager = this.sheetsManager.get(stylesCreatorSaved); + sheetManager || (sheetManager = new _map2.default(), this.sheetsManager.set(stylesCreatorSaved, sheetManager)); + var sheetManagerTheme = sheetManager.get(theme); + if (sheetManagerTheme || (sheetManagerTheme = { + refs: 0, + sheet: null + }, sheetManager.set(theme, sheetManagerTheme)), 0 === sheetManagerTheme.refs) { + var styles = stylesCreatorSaved.create(theme, name), meta = void 0; + "production" !== process.env.NODE_ENV && (meta = name || (0, _getDisplayName2.default)(Component)); + var sheet = this.jss.createStyleSheet(styles, (0, _extends3.default)({ + meta: meta, + flip: "boolean" == typeof flip ? flip : "rtl" === theme.direction, + link: !1 + }, this.sheetOptions, stylesCreatorSaved.options, { + name: name + }, styleSheetOptions)); + sheetManagerTheme.sheet = sheet, sheet.attach(); + var sheetsRegistry = this.context[ns.sheetsRegistry]; + sheetsRegistry && sheetsRegistry.add(sheet); + } + sheetManagerTheme.refs += 1; + } + } + }, { + key: "detach", + value: function(theme) { + if (!this.disableStylesGeneration) { + var stylesCreatorSaved = this.stylesCreatorSaved, sheetManager = this.sheetsManager.get(stylesCreatorSaved), sheetManagerTheme = sheetManager.get(theme); + if (sheetManagerTheme.refs -= 1, 0 === sheetManagerTheme.refs) { + sheetManager.delete(theme), this.jss.removeStyleSheet(sheetManagerTheme.sheet); + var sheetsRegistry = this.context[ns.sheetsRegistry]; + sheetsRegistry && sheetsRegistry.remove(sheetManagerTheme.sheet); + } + } + } + }, { + key: "render", + value: function() { + var _this3 = this, _props = this.props, classesProp = _props.classes, innerRef = _props.innerRef, other = (0, + _objectWithoutProperties3.default)(_props, [ "classes", "innerRef" ]), classes = void 0, renderedClasses = {}; + if (!this.disableStylesGeneration) { + var sheetManager = this.sheetsManager.get(this.stylesCreatorSaved), sheetsManagerTheme = sheetManager.get(this.theme); + renderedClasses = sheetsManagerTheme.sheet.classes; + } + classes = classesProp ? (0, _extends3.default)({}, renderedClasses, (0, _keys2.default)(classesProp).reduce(function(accumulator, key) { + return "production" !== process.env.NODE_ENV && (0, _warning2.default)(renderedClasses[key] || _this3.disableStylesGeneration, [ "Material-UI: the key ` + "`") + (`" + key + "` + ("`" + ` provided to the classes property is not implemented in " + (0, + _getDisplayName2.default)(Component) + ".", "You can only override one of the following: " + (0, + _keys2.default)(renderedClasses).join(",") ].join("\n")), "production" !== process.env.NODE_ENV && (0, + _warning2.default)(!classesProp[key] || "string" == typeof classesProp[key], [ "Material-UI: the key `))) + (("`" + (`" + key + "` + "`")) + (` provided to the classes property is not valid for " + (0, + _getDisplayName2.default)(Component) + ".", "You need to provide a non empty string instead of: " + classesProp[key] + "." ].join("\n")), + classesProp[key] && (accumulator[key] = renderedClasses[key] + " " + classesProp[key]), + accumulator; + }, {})) : renderedClasses; + var more = {}; + return withTheme && (more.theme = this.theme), _react2.default.createElement(Component, (0, + _extends3.default)({ + classes: classes + }, more, other, { + ref: innerRef + })); + } + } ]), Style; + }(_react2.default.Component); + return Style.propTypes = "production" !== process.env.NODE_ENV ? { + classes: _propTypes2.default.object, + innerRef: _propTypes2.default.func + } : {}, Style.contextTypes = (0, _extends3.default)({ + muiThemeProviderOptions: _propTypes2.default.object + }, _contextTypes2.default, listenToTheme ? _themeListener2.default.contextTypes : {}), + "production" !== process.env.NODE_ENV && (Style.displayName = (0, _wrapDisplayName2.default)(Component, "withStyles")), + (0, _hoistNonReactStatics2.default)(Style, Component), "production" !== process.env.NODE_ENV && (Style.Naked = Component, + Style.options = options), Style; + }; + }; + exports.default = withStyles; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + var warning = function() {}; + "production" !== process.env.NODE_ENV && (warning = function(condition, format, args) { + var len = arguments.length; + args = new Array(len > 2 ? len - 2 : 0); + for (var key = 2; key < len; key++) args[key - 2] = arguments[key]; + if (void 0 === format) throw new Error("` + ("`" + `warning(condition, format, ...args)`)))) + ((("`" + (` requires a warning message argument"); + if (format.length < 10 || /^[s\W]*$/.test(format)) throw new Error("The warning format should be able to uniquely identify this warning. Please, use a more descriptive format than: " + format); + if (!condition) { + var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + "undefined" != typeof console && console.error(message); + try { + throw new Error(message); + } catch (x) {} + } + }), module.exports = warning; + }).call(exports, __webpack_require__(3)); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _dispatchable(methodNames, xf, fn) { + return function() { + if (0 === arguments.length) return fn(); + var args = Array.prototype.slice.call(arguments, 0), obj = args.pop(); + if (!Object(__WEBPACK_IMPORTED_MODULE_0__isArray__.a)(obj)) { + for (var idx = 0; idx < methodNames.length; ) { + if ("function" == typeof obj[methodNames[idx]]) return obj[methodNames[idx]].apply(obj, args); + idx += 1; + } + if (Object(__WEBPACK_IMPORTED_MODULE_1__isTransformer__.a)(obj)) { + return xf.apply(null, args)(obj); + } + } + return fn.apply(this, arguments); + }; + } + __webpack_exports__.a = _dispatchable; + var __WEBPACK_IMPORTED_MODULE_0__isArray__ = __webpack_require__(57), __WEBPACK_IMPORTED_MODULE_1__isTransformer__ = __webpack_require__(200); +}, function(module, exports) { + var isArray = Array.isArray; + module.exports = isArray; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0; + var _defineProperty = __webpack_require__(185), _defineProperty2 = function(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + }(_defineProperty); + exports.default = function(obj, key, value) { + return key in obj ? (0, _defineProperty2.default)(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }) : obj[key] = value, obj; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function Layer(props) { + var children = props.children, className = props.className, others = _objectWithoutProperties(props, [ "children", "className" ]), layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-layer", className); + return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("g", _extends({ + className: layerClass + }, others), children); + } + var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, propTypes = { + className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node ]) + }; + Layer.propTypes = propTypes, __webpack_exports__.a = Layer; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = { + init: function() { + return this.xf["@@transducer/init"](); + }, + result: function(result) { + return this.xf["@@transducer/result"](result); + } + }; +}, function(module, exports, __webpack_require__) { + var global = __webpack_require__(221), core = __webpack_require__(222), hide = __webpack_require__(363), redefine = __webpack_require__(839), ctx = __webpack_require__(842), $export = function(type, name, source) { + var key, own, out, exp, IS_FORCED = type & $export.F, IS_GLOBAL = type & $export.G, IS_STATIC = type & $export.S, IS_PROTO = type & $export.P, IS_BIND = type & $export.B, target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {}).prototype, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}), expProto = exports.prototype || (exports.prototype = {}); + IS_GLOBAL && (source = name); + for (key in source) own = !IS_FORCED && target && void 0 !== target[key], out = (own ? target : source)[key], + exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && "function" == typeof out ? ctx(Function.call, out) : out, + target && redefine(target, key, out, type & $export.U), exports[key] != out && hide(exports, key, exp), + IS_PROTO && expProto[key] != out && (expProto[key] = out); + }; + global.core = core, $export.F = 1, $export.G = 2, $export.S = 4, $export.P = 8, + $export.B = 16, $export.W = 32, $export.U = 64, $export.R = 128, module.exports = $export; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _defineProperty(obj, key, value) { + return key in obj ? Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }) : obj[key] = value, obj; + } + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } + return Array.from(arr); + } + __webpack_require__.d(__webpack_exports__, "w", function() { + return getValueByDataKey; + }), __webpack_require__.d(__webpack_exports__, "n", function() { + return getDomainOfDataByKey; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return calculateActiveTickIndex; + }), __webpack_require__.d(__webpack_exports__, "r", function() { + return getMainColorOfGraphicItem; + }), __webpack_require__.d(__webpack_exports__, "q", function() { + return getLegendProps; + }), __webpack_require__.d(__webpack_exports__, "i", function() { + return getBarSizeList; + }), __webpack_require__.d(__webpack_exports__, "h", function() { + return getBarPosition; + }), __webpack_require__.d(__webpack_exports__, "a", function() { + return appendOffsetOfLegend; + }), __webpack_require__.d(__webpack_exports__, "z", function() { + return parseErrorBarsOfAxis; + }), __webpack_require__.d(__webpack_exports__, "o", function() { + return getDomainOfItemsWithSameAxis; + }), __webpack_require__.d(__webpack_exports__, "x", function() { + return isCategorialAxis; + }), __webpack_require__.d(__webpack_exports__, "m", function() { + return getCoordinatesOfGrid; + }), __webpack_require__.d(__webpack_exports__, "u", function() { + return getTicksOfAxis; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return combineEventHandlers; + }), __webpack_require__.d(__webpack_exports__, "A", function() { + return parseScale; + }), __webpack_require__.d(__webpack_exports__, "c", function() { + return checkDomainOfScale; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return findPositionOfBar; + }), __webpack_require__.d(__webpack_exports__, "C", function() { + return truncateByDomain; + }), __webpack_require__.d(__webpack_exports__, "s", function() { + return getStackGroupsByAxisId; + }), __webpack_require__.d(__webpack_exports__, "v", function() { + return getTicksOfScale; + }), __webpack_require__.d(__webpack_exports__, "l", function() { + return getCateCoordinateOfLine; + }), __webpack_require__.d(__webpack_exports__, "k", function() { + return getCateCoordinateOfBar; + }), __webpack_require__.d(__webpack_exports__, "j", function() { + return getBaseValueOfBar; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return detectReferenceElementsDomain; + }), __webpack_require__.d(__webpack_exports__, "t", function() { + return getStackedDataOfItem; + }), __webpack_require__.d(__webpack_exports__, "p", function() { + return getDomainOfStackGroups; + }), __webpack_require__.d(__webpack_exports__, "B", function() { + return parseSpecifiedDomain; + }), __webpack_require__.d(__webpack_exports__, "D", function() { + return validateCoordinateInRange; + }), __webpack_require__.d(__webpack_exports__, "g", function() { + return getBandSizeOfAxis; + }), __webpack_require__.d(__webpack_exports__, "y", function() { + return parseDomainOfCategoryAxis; + }); + var __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual__ = __webpack_require__(49), __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isEqual__), __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy__ = __webpack_require__(402), __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_sortBy__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__ = __webpack_require__(159), __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNaN__), __WEBPACK_IMPORTED_MODULE_3_lodash_isString__ = __webpack_require__(227), __WEBPACK_IMPORTED_MODULE_3_lodash_isString___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_isString__), __WEBPACK_IMPORTED_MODULE_4_lodash_max__ = __webpack_require__(1010), __WEBPACK_IMPORTED_MODULE_4_lodash_max___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_max__), __WEBPACK_IMPORTED_MODULE_5_lodash_min__ = __webpack_require__(405), __WEBPACK_IMPORTED_MODULE_5_lodash_min___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_lodash_min__), __WEBPACK_IMPORTED_MODULE_6_lodash_isArray__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_8_lodash_get__ = __webpack_require__(152), __WEBPACK_IMPORTED_MODULE_8_lodash_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_lodash_get__), __WEBPACK_IMPORTED_MODULE_9_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_9_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_10_recharts_scale__ = __webpack_require__(1011), __WEBPACK_IMPORTED_MODULE_11_d3_scale__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_10_recharts_scale__), + __webpack_require__(408)), __WEBPACK_IMPORTED_MODULE_12_d3_shape__ = __webpack_require__(235), __WEBPACK_IMPORTED_MODULE_13__DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_14__cartesian_ReferenceDot__ = __webpack_require__(441), __WEBPACK_IMPORTED_MODULE_15__cartesian_ReferenceLine__ = __webpack_require__(442), __WEBPACK_IMPORTED_MODULE_16__cartesian_ReferenceArea__ = __webpack_require__(443), __WEBPACK_IMPORTED_MODULE_17__cartesian_ErrorBar__ = __webpack_require__(117), __WEBPACK_IMPORTED_MODULE_18__component_Legend__ = __webpack_require__(233), __WEBPACK_IMPORTED_MODULE_19__ReactUtils__ = __webpack_require__(7), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, getValueByDataKey = function(obj, dataKey, defaultValue) { + return __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(obj) || __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(dataKey) ? defaultValue : Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.f)(dataKey) ? __WEBPACK_IMPORTED_MODULE_8_lodash_get___default()(obj, dataKey, defaultValue) : __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(dataKey) ? dataKey(obj) : defaultValue; + }, getDomainOfDataByKey = function(data, key, type, filterNil) { + var flattenData = data.reduce(function(result, entry) { + var value = getValueByDataKey(entry, key); + return __WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(value) ? [].concat(_toConsumableArray(result), _toConsumableArray(value)) : [].concat(_toConsumableArray(result), [ value ]); + }, []); + if ("number" === type) { + var domain = flattenData.filter(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g); + return [ Math.min.apply(null, domain), Math.max.apply(null, domain) ]; + } + return (filterNil ? flattenData.filter(function(entry) { + return !__WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(entry); + }) : flattenData).map(function(entry) { + return Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.f)(entry) ? entry : ""; + }); + }, calculateActiveTickIndex = function(coordinate, ticks, unsortedTicks, axis) { + var index = -1, len = ticks.length; + if (len > 1) { + if (axis && "angleAxis" === axis.axisType && Math.abs(Math.abs(axis.range[1] - axis.range[0]) - 360) <= 1e-6) for (var range = axis.range, i = 0; i < len; i++) { + var before = i > 0 ? unsortedTicks[i - 1].coordinate : unsortedTicks[len - 1].coordinate, cur = unsortedTicks[i].coordinate, after = i >= len - 1 ? unsortedTicks[0].coordinate : unsortedTicks[i + 1].coordinate, sameDirectionCoord = void 0; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.i)(cur - before) !== Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.i)(after - cur)) { + var diffInterval = []; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.i)(after - cur) === Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.i)(range[1] - range[0])) { + sameDirectionCoord = after; + var curInRange = cur + range[1] - range[0]; + diffInterval[0] = Math.min(curInRange, (curInRange + before) / 2), diffInterval[1] = Math.max(curInRange, (curInRange + before) / 2); + } else { + sameDirectionCoord = before; + var afterInRange = after + range[1] - range[0]; + diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2), diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2); + } + var sameInterval = [ Math.min(cur, (sameDirectionCoord + cur) / 2), Math.max(cur, (sameDirectionCoord + cur) / 2) ]; + if (coordinate > sameInterval[0] && coordinate <= sameInterval[1] || coordinate >= diffInterval[0] && coordinate <= diffInterval[1]) { + index = unsortedTicks[i].index; + break; + } + } else { + var min = Math.min(before, after), max = Math.max(before, after); + if (coordinate > (min + cur) / 2 && coordinate <= (max + cur) / 2) { + index = unsortedTicks[i].index; + break; + } + } + } else for (var _i = 0; _i < len; _i++) if (0 === _i && coordinate <= (ticks[_i].coordinate + ticks[_i + 1].coordinate) / 2 || _i > 0 && _i < len - 1 && coordinate > (ticks[_i].coordinate + ticks[_i - 1].coordinate) / 2 && coordinate <= (ticks[_i].coordinate + ticks[_i + 1].coordinate) / 2 || _i === len - 1 && coordinate > (ticks[_i].coordinate + ticks[_i - 1].coordinate) / 2) { + index = ticks[_i].index; + break; + } + } else index = 0; + return index; + }, getMainColorOfGraphicItem = function(item) { + var displayName = item.type.displayName, result = void 0; + switch (displayName) { + case "Line": + case "Area": + case "Radar": + result = item.props.stroke; + break; + + default: + result = item.props.fill; + } + return result; + }, getLegendProps = function(_ref) { + var children = _ref.children, formatedGraphicalItems = _ref.formatedGraphicalItems, legendWidth = _ref.legendWidth, legendContent = _ref.legendContent, legendItem = Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_18__component_Legend__.a); + if (!legendItem) return null; + var legendData = void 0; + return legendData = legendItem.props && legendItem.props.payload ? legendItem.props && legendItem.props.payload : "children" === legendContent ? (formatedGraphicalItems || []).reduce(function(result, _ref2) { + var item = _ref2.item, props = _ref2.props, data = props.sectors || props.data || []; + return result.concat(data.map(function(entry) { + return { + type: legendItem.props.iconType || item.props.legendType, + value: entry.name, + color: entry.fill, + payload: entry + }; + })); + }, []) : (formatedGraphicalItems || []).map(function(_ref3) { + var item = _ref3.item, _item$props = item.props, dataKey = _item$props.dataKey, name = _item$props.name, legendType = _item$props.legendType; + return { + inactive: _item$props.hide, + dataKey: dataKey, + type: legendItem.props.iconType || legendType || "square", + color: getMainColorOfGraphicItem(item), + value: name || dataKey, + payload: item.props + }; + }), _extends({}, legendItem.props, __WEBPACK_IMPORTED_MODULE_18__component_Legend__.a.getWithHeight(legendItem, legendWidth), { + payload: legendData, + item: legendItem + }); + }, getBarSizeList = function(_ref4) { + var globalSize = _ref4.barSize, _ref4$stackGroups = _ref4.stackGroups, stackGroups = void 0 === _ref4$stackGroups ? {} : _ref4$stackGroups; + if (!stackGroups) return {}; + for (var result = {}, numericAxisIds = Object.keys(stackGroups), i = 0, len = numericAxisIds.length; i < len; i++) for (var sgs = stackGroups[numericAxisIds[i]].stackGroups, stackIds = Object.keys(sgs), j = 0, sLen = stackIds.length; j < sLen; j++) { + var _sgs$stackIds$j = sgs[stackIds[j]], items = _sgs$stackIds$j.items, cateAxisId = _sgs$stackIds$j.cateAxisId, barItems = items.filter(function(item) { + return Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.j)(item.type).indexOf("Bar") >= 0; + }); + if (barItems && barItems.length) { + var selfSize = barItems[0].props.barSize, cateId = barItems[0].props[cateAxisId]; + result[cateId] || (result[cateId] = []), result[cateId].push({ + item: barItems[0], + stackList: barItems.slice(1), + barSize: __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(selfSize) ? globalSize : selfSize + }); + } + } + return result; + }, getBarPosition = function(_ref5) { + var barGap = _ref5.barGap, barCategoryGap = _ref5.barCategoryGap, bandSize = _ref5.bandSize, _ref5$sizeList = _ref5.sizeList, sizeList = void 0 === _ref5$sizeList ? [] : _ref5$sizeList, maxBarSize = _ref5.maxBarSize, len = sizeList.length; + if (len < 1) return null; + var realBarGap = Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.c)(barGap, bandSize, 0, !0), result = void 0; + if (sizeList[0].barSize === +sizeList[0].barSize) { + var useFull = !1, fullBarSize = bandSize / len, sum = sizeList.reduce(function(res, entry) { + return res + entry.barSize || 0; + }, 0); + sum += (len - 1) * realBarGap, sum >= bandSize && (sum -= (len - 1) * realBarGap, + realBarGap = 0), sum >= bandSize && fullBarSize > 0 && (useFull = !0, fullBarSize *= .9, + sum = len * fullBarSize); + var offset = (bandSize - sum) / 2 >> 0, prev = { + offset: offset - realBarGap, + size: 0 + }; + result = sizeList.reduce(function(res, entry) { + var newRes = [].concat(_toConsumableArray(res), [ { + item: entry.item, + position: { + offset: prev.offset + prev.size + realBarGap, + size: useFull ? fullBarSize : entry.barSize + } + } ]); + return prev = newRes[newRes.length - 1].position, entry.stackList && entry.stackList.length && entry.stackList.forEach(function(item) { + newRes.push({ + item: item, + position: prev + }); + }), newRes; + }, []); + } else { + var _offset = Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.c)(barCategoryGap, bandSize, 0, !0); + bandSize - 2 * _offset - (len - 1) * realBarGap <= 0 && (realBarGap = 0); + var originalSize = (bandSize - 2 * _offset - (len - 1) * realBarGap) / len; + originalSize > 1 && (originalSize >>= 0); + var size = maxBarSize === +maxBarSize ? Math.min(originalSize, maxBarSize) : originalSize; + result = sizeList.reduce(function(res, entry, i) { + var newRes = [].concat(_toConsumableArray(res), [ { + item: entry.item, + position: { + offset: _offset + (originalSize + realBarGap) * i + (originalSize - size) / 2, + size: size + } + } ]); + return entry.stackList && entry.stackList.length && entry.stackList.forEach(function(item) { + newRes.push({ + item: item, + position: newRes[newRes.length - 1].position + }); + }), newRes; + }, []); + } + return result; + }, appendOffsetOfLegend = function(offset, items, props, legendBox) { + var children = props.children, width = props.width, height = props.height, margin = props.margin, legendWidth = width - (margin.left || 0) - (margin.right || 0), legendHeight = height - (margin.top || 0) - (margin.bottom || 0), legendProps = getLegendProps({ + children: children, + items: items, + legendWidth: legendWidth, + legendHeight: legendHeight + }), newOffset = offset; + if (legendProps) { + var box = legendBox || {}, align = legendProps.align, verticalAlign = legendProps.verticalAlign, layout = legendProps.layout; + ("vertical" === layout || "horizontal" === layout && "center" === verticalAlign) && Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(offset[align]) && (newOffset = _extends({}, offset, _defineProperty({}, align, newOffset[align] + (box.width || 0)))), + ("horizontal" === layout || "vertical" === layout && "center" === align) && Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(offset[verticalAlign]) && (newOffset = _extends({}, offset, _defineProperty({}, verticalAlign, newOffset[verticalAlign] + (box.height || 0)))); + } + return newOffset; + }, getDomainOfErrorBars = function(data, item, dataKey, axisType) { + var children = item.props.children, errorBars = Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_17__cartesian_ErrorBar__.a).filter(function(errorBarChild) { + var direction = errorBarChild.props.direction; + return !(!__WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(direction) && !__WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(axisType)) || axisType.indexOf(direction) >= 0; + }); + if (errorBars && errorBars.length) { + var keys = errorBars.map(function(errorBarChild) { + return errorBarChild.props.dataKey; + }); + return data.reduce(function(result, entry) { + var entryValue = getValueByDataKey(entry, dataKey, 0), mainValue = __WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(entryValue) ? [ __WEBPACK_IMPORTED_MODULE_5_lodash_min___default()(entryValue), __WEBPACK_IMPORTED_MODULE_4_lodash_max___default()(entryValue) ] : [ entryValue, entryValue ], errorDomain = keys.reduce(function(prevErrorArr, k) { + var errorValue = getValueByDataKey(entry, k, 0), lowerValue = mainValue[0] - Math.abs(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(errorValue) ? errorValue[0] : errorValue), upperValue = mainValue[1] + Math.abs(__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(errorValue) ? errorValue[1] : errorValue); + return [ Math.min(lowerValue, prevErrorArr[0]), Math.max(upperValue, prevErrorArr[1]) ]; + }, [ 1 / 0, -1 / 0 ]); + return [ Math.min(errorDomain[0], result[0]), Math.max(errorDomain[1], result[1]) ]; + }, [ 1 / 0, -1 / 0 ]); + } + return null; + }, parseErrorBarsOfAxis = function(data, items, dataKey, axisType) { + var domains = items.map(function(item) { + return getDomainOfErrorBars(data, item, dataKey, axisType); + }).filter(function(entry) { + return !__WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(entry); + }); + return domains && domains.length ? domains.reduce(function(result, entry) { + return [ Math.min(result[0], entry[0]), Math.max(result[1], entry[1]) ]; + }, [ 1 / 0, -1 / 0 ]) : null; + }, getDomainOfItemsWithSameAxis = function(data, items, type, filterNil) { + var domains = items.map(function(item) { + var dataKey = item.props.dataKey; + return "number" === type && dataKey ? getDomainOfErrorBars(data, item, dataKey) || getDomainOfDataByKey(data, dataKey, type, filterNil) : getDomainOfDataByKey(data, dataKey, type, filterNil); + }); + if ("number" === type) return domains.reduce(function(result, entry) { + return [ Math.min(result[0], entry[0]), Math.max(result[1], entry[1]) ]; + }, [ 1 / 0, -1 / 0 ]); + var tag = {}; + return domains.reduce(function(result, entry) { + for (var i = 0, len = entry.length; i < len; i++) tag[entry[i]] || (tag[entry[i]] = !0, + result.push(entry[i])); + return result; + }, []); + }, isCategorialAxis = function(layout, axisType) { + return "horizontal" === layout && "xAxis" === axisType || "vertical" === layout && "yAxis" === axisType || "centric" === layout && "angleAxis" === axisType || "radial" === layout && "radiusAxis" === axisType; + }, getCoordinatesOfGrid = function(ticks, min, max) { + var hasMin = void 0, hasMax = void 0, values = ticks.map(function(entry) { + return entry.coordinate === min && (hasMin = !0), entry.coordinate === max && (hasMax = !0), + entry.coordinate; + }); + return hasMin || values.push(min), hasMax || values.push(max), values; + }, getTicksOfAxis = function(axis, isGrid, isAll) { + if (!axis) return null; + var scale = axis.scale, duplicateDomain = axis.duplicateDomain, type = axis.type, range = axis.range, offset = (isGrid || isAll) && "category" === type && scale.bandwidth ? scale.bandwidth() / 2 : 0; + return offset = "angleAxis" === axis.axisType ? 2 * Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.i)(range[0] - range[1]) * offset : offset, + isGrid && (axis.ticks || axis.niceTicks) ? (axis.ticks || axis.niceTicks).map(function(entry) { + var scaleContent = duplicateDomain ? duplicateDomain.indexOf(entry) : entry; + return { + coordinate: scale(scaleContent) + offset, + value: entry, + offset: offset + }; + }) : axis.isCategorial && axis.categoricalDomain ? axis.categoricalDomain.map(function(entry, index) { + return { + coordinate: scale(entry), + value: entry, + index: index, + offset: offset + }; + }) : scale.ticks && !isAll ? scale.ticks(axis.tickCount).map(function(entry) { + return { + coordinate: scale(entry) + offset, + value: entry, + offset: offset + }; + }) : scale.domain().map(function(entry, index) { + return { + coordinate: scale(entry) + offset, + value: duplicateDomain ? duplicateDomain[entry] : entry, + index: index, + offset: offset + }; + }); + }, combineEventHandlers = function(defaultHandler, parentHandler, childHandler) { + var customizedHandler = void 0; + return __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(childHandler) ? customizedHandler = childHandler : __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(parentHandler) && (customizedHandler = parentHandler), + __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(defaultHandler) || customizedHandler ? function(arg1, arg2, arg3, arg4) { + __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(defaultHandler) && defaultHandler(arg1, arg2, arg3, arg4), + __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(customizedHandler) && customizedHandler(arg1, arg2, arg3, arg4); + } : null; + }, parseScale = function(axis, chartType) { + var scale = axis.scale, type = axis.type, layout = axis.layout, axisType = axis.axisType; + if ("auto" === scale) return "radial" === layout && "radiusAxis" === axisType ? { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scaleBand(), + realScaleType: "band" + } : "radial" === layout && "angleAxis" === axisType ? { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scaleLinear(), + realScaleType: "linear" + } : "category" === type && chartType && (chartType.indexOf("LineChart") >= 0 || chartType.indexOf("AreaChart") >= 0) ? { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scalePoint(), + realScaleType: "point" + } : "category" === type ? { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scaleBand(), + realScaleType: "band" + } : { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scaleLinear(), + realScaleType: "linear" + }; + if (__WEBPACK_IMPORTED_MODULE_3_lodash_isString___default()(scale)) { + var name = "scale" + scale.slice(0, 1).toUpperCase() + scale.slice(1); + return { + scale: (__WEBPACK_IMPORTED_MODULE_11_d3_scale__[name] || __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scalePoint)(), + realScaleType: __WEBPACK_IMPORTED_MODULE_11_d3_scale__[name] ? name : "point" + }; + } + return __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(scale) ? { + scale: scale + } : { + scale: __WEBPACK_IMPORTED_MODULE_11_d3_scale__.scalePoint(), + realScaleType: "point" + }; + }, checkDomainOfScale = function(scale) { + var domain = scale.domain(); + if (domain && !(domain.length <= 2)) { + var len = domain.length, range = scale.range(), min = Math.min(range[0], range[1]) - 1e-4, max = Math.max(range[0], range[1]) + 1e-4, first = scale(domain[0]), last = scale(domain[len - 1]); + (first < min || first > max || last < min || last > max) && scale.domain([ domain[0], domain[len - 1] ]); + } + }, findPositionOfBar = function(barPosition, child) { + if (!barPosition) return null; + for (var i = 0, len = barPosition.length; i < len; i++) if (barPosition[i].item === child) return barPosition[i].position; + return null; + }, truncateByDomain = function(value, domain) { + if (!domain || 2 !== domain.length || !Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(domain[0]) || !Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(domain[1])) return value; + var min = Math.min(domain[0], domain[1]), max = Math.max(domain[0], domain[1]), result = [ value[0], value[1] ]; + return (!Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(value[0]) || value[0] < min) && (result[0] = min), + (!Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(value[1]) || value[1] > max) && (result[1] = max), + result[0] > max && (result[0] = max), result[1] < min && (result[1] = min), result; + }, offsetSign = function(series) { + var n = series.length; + if (!(n <= 0)) for (var j = 0, m = series[0].length; j < m; ++j) for (var positive = 0, negative = 0, i = 0; i < n; ++i) { + var value = __WEBPACK_IMPORTED_MODULE_2_lodash_isNaN___default()(series[i][j][1]) ? series[i][j][0] : series[i][j][1]; + value >= 0 ? (series[i][j][0] = positive, series[i][j][1] = positive + value, positive = series[i][j][1]) : (series[i][j][0] = negative, + series[i][j][1] = negative + value, negative = series[i][j][1]); + } + }, STACK_OFFSET_MAP = { + sign: offsetSign, + expand: __WEBPACK_IMPORTED_MODULE_12_d3_shape__.o, + none: __WEBPACK_IMPORTED_MODULE_12_d3_shape__.p, + silhouette: __WEBPACK_IMPORTED_MODULE_12_d3_shape__.q, + wiggle: __WEBPACK_IMPORTED_MODULE_12_d3_shape__.r + }, getStackedData = function(data, stackItems, offsetType) { + var dataKeys = stackItems.map(function(item) { + return item.props.dataKey; + }); + return Object(__WEBPACK_IMPORTED_MODULE_12_d3_shape__.n)().keys(dataKeys).value(function(d, key) { + return +getValueByDataKey(d, key, 0); + }).order(__WEBPACK_IMPORTED_MODULE_12_d3_shape__.s).offset(STACK_OFFSET_MAP[offsetType])(data); + }, getStackGroupsByAxisId = function(data, _items, numericAxisId, cateAxisId, offsetType, reverseStackOrder) { + if (!data) return null; + var items = reverseStackOrder ? _items.reverse() : _items, stackGroups = items.reduce(function(result, item) { + var _item$props2 = item.props, stackId = _item$props2.stackId; + if (_item$props2.hide) return result; + var axisId = item.props[numericAxisId], parentGroup = result[axisId] || { + hasStack: !1, + stackGroups: {} + }; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.f)(stackId)) { + var childGroup = parentGroup.stackGroups[stackId] || { + numericAxisId: numericAxisId, + cateAxisId: cateAxisId, + items: [] + }; + childGroup.items.push(item), parentGroup.hasStack = !0, parentGroup.stackGroups[stackId] = childGroup; + } else parentGroup.stackGroups[Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.j)("_stackId_")] = { + numericAxisId: numericAxisId, + cateAxisId: cateAxisId, + items: [ item ] + }; + return _extends({}, result, _defineProperty({}, axisId, parentGroup)); + }, {}); + return Object.keys(stackGroups).reduce(function(result, axisId) { + var group = stackGroups[axisId]; + return group.hasStack && (group.stackGroups = Object.keys(group.stackGroups).reduce(function(res, stackId) { + var g = group.stackGroups[stackId]; + return _extends({}, res, _defineProperty({}, stackId, { + numericAxisId: numericAxisId, + cateAxisId: cateAxisId, + items: g.items, + stackedData: getStackedData(data, g.items, offsetType) + })); + }, {})), _extends({}, result, _defineProperty({}, axisId, group)); + }, {}); + }, calculateDomainOfTicks = function(ticks, type) { + return "number" === type ? [ Math.min.apply(null, ticks), Math.max.apply(null, ticks) ] : ticks; + }, getTicksOfScale = function(scale, opts) { + var realScaleType = opts.realScaleType, type = opts.type, tickCount = opts.tickCount, originalDomain = opts.originalDomain, allowDecimals = opts.allowDecimals, scaleType = realScaleType || opts.scale; + if ("auto" !== scaleType && "linear" !== scaleType) return null; + if (tickCount && "number" === type && originalDomain && ("auto" === originalDomain[0] || "auto" === originalDomain[1])) { + var domain = scale.domain(), tickValues = Object(__WEBPACK_IMPORTED_MODULE_10_recharts_scale__.getNiceTickValues)(domain, tickCount, allowDecimals); + return scale.domain(calculateDomainOfTicks(tickValues, type)), { + niceTicks: tickValues + }; + } + if (tickCount && "number" === type) { + var _domain = scale.domain(); + return { + niceTicks: Object(__WEBPACK_IMPORTED_MODULE_10_recharts_scale__.getTickValuesFixedDomain)(_domain, tickCount, allowDecimals) + }; + } + return null; + }, getCateCoordinateOfLine = function(_ref6) { + var axis = _ref6.axis, ticks = _ref6.ticks, bandSize = _ref6.bandSize, entry = _ref6.entry, index = _ref6.index; + if ("category" === axis.type) { + if (!axis.allowDuplicatedCategory && axis.dataKey && !__WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(entry[axis.dataKey])) { + var matchedTick = Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.a)(ticks, "value", entry[axis.dataKey]); + if (matchedTick) return matchedTick.coordinate + bandSize / 2; + } + return ticks[index] ? ticks[index].coordinate + bandSize / 2 : null; + } + var value = getValueByDataKey(entry, axis.dataKey); + return __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(value) ? null : axis.scale(value); + }, getCateCoordinateOfBar = function(_ref7) { + var axis = _ref7.axis, ticks = _ref7.ticks, offset = _ref7.offset, bandSize = _ref7.bandSize, entry = _ref7.entry, index = _ref7.index; + if ("category" === axis.type) return ticks[index] ? ticks[index].coordinate + offset : null; + var value = getValueByDataKey(entry, axis.dataKey, axis.domain[index]); + return __WEBPACK_IMPORTED_MODULE_9_lodash_isNil___default()(value) ? null : axis.scale(value) - bandSize / 2 + offset; + }, getBaseValueOfBar = function(_ref8) { + var numericAxis = _ref8.numericAxis, domain = numericAxis.scale.domain(); + if ("number" === numericAxis.type) { + var min = Math.min(domain[0], domain[1]), max = Math.max(domain[0], domain[1]); + return min <= 0 && max >= 0 ? 0 : max < 0 ? max : min; + } + return domain[0]; + }, detectReferenceElementsDomain = function(children, domain, axisId, axisType, specifiedTicks) { + var lines = Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_15__cartesian_ReferenceLine__.a), dots = Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_14__cartesian_ReferenceDot__.a), elements = lines.concat(dots), areas = Object(__WEBPACK_IMPORTED_MODULE_19__ReactUtils__.h)(children, __WEBPACK_IMPORTED_MODULE_16__cartesian_ReferenceArea__.a), idKey = axisType + "Id", valueKey = axisType[0], finalDomain = domain; + if (elements.length && (finalDomain = elements.reduce(function(result, el) { + if (el.props[idKey] === axisId && el.props.alwaysShow && Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(el.props[valueKey])) { + var value = el.props[valueKey]; + return [ Math.min(result[0], value), Math.max(result[1], value) ]; + } + return result; + }, finalDomain)), areas.length) { + var key1 = valueKey + "1", key2 = valueKey + "2"; + finalDomain = areas.reduce(function(result, el) { + if (el.props[idKey] === axisId && el.props.alwaysShow && Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(el.props[key1]) && Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(el.props[key2])) { + var value1 = el.props[key1], value2 = el.props[key2]; + return [ Math.min(result[0], value1, value2), Math.max(result[1], value1, value2) ]; + } + return result; + }, finalDomain); + } + return specifiedTicks && specifiedTicks.length && (finalDomain = specifiedTicks.reduce(function(result, tick) { + return Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(tick) ? [ Math.min(result[0], tick), Math.max(result[1], tick) ] : result; + }, finalDomain)), finalDomain; + }, getStackedDataOfItem = function(item, stackGroups) { + var stackId = item.props.stackId; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.f)(stackId)) { + var group = stackGroups[stackId]; + if (group && group.items.length) { + for (var itemIndex = -1, i = 0, len = group.items.length; i < len; i++) if (group.items[i] === item) { + itemIndex = i; + break; + } + return itemIndex >= 0 ? group.stackedData[itemIndex] : null; + } + } + return null; + }, getDomainOfSingle = function(data) { + return data.reduce(function(result, entry) { + return [ Math.min.apply(null, entry.concat([ result[0] ]).filter(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)), Math.max.apply(null, entry.concat([ result[1] ]).filter(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)) ]; + }, [ 1 / 0, -1 / 0 ]); + }, getDomainOfStackGroups = function(stackGroups, startIndex, endIndex) { + return Object.keys(stackGroups).reduce(function(result, stackId) { + var group = stackGroups[stackId], stackedData = group.stackedData, domain = stackedData.reduce(function(res, entry) { + var s = getDomainOfSingle(entry.slice(startIndex, endIndex + 1)); + return [ Math.min(res[0], s[0]), Math.max(res[1], s[1]) ]; + }, [ 1 / 0, -1 / 0 ]); + return [ Math.min(domain[0], result[0]), Math.max(domain[1], result[1]) ]; + }, [ 1 / 0, -1 / 0 ]).map(function(result) { + return result === 1 / 0 || result === -1 / 0 ? 0 : result; + }); + }, MIN_VALUE_REG = /^dataMin[\s]*-[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/, MAX_VALUE_REG = /^dataMax[\s]*\+[\s]*([0-9]+([.]{1}[0-9]+){0,1})$/, parseSpecifiedDomain = function(specifiedDomain, dataDomain, allowDataOverflow) { + if (!__WEBPACK_IMPORTED_MODULE_6_lodash_isArray___default()(specifiedDomain)) return dataDomain; + var domain = []; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(specifiedDomain[0])) domain[0] = allowDataOverflow ? specifiedDomain[0] : Math.min(specifiedDomain[0], dataDomain[0]); else if (MIN_VALUE_REG.test(specifiedDomain[0])) { + var value = +MIN_VALUE_REG.exec(specifiedDomain[0])[1]; + domain[0] = dataDomain[0] - value; + } else __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(specifiedDomain[0]) ? domain[0] = specifiedDomain[0](dataDomain[0]) : domain[0] = dataDomain[0]; + if (Object(__WEBPACK_IMPORTED_MODULE_13__DataUtils__.g)(specifiedDomain[1])) domain[1] = allowDataOverflow ? specifiedDomain[1] : Math.max(specifiedDomain[1], dataDomain[1]); else if (MAX_VALUE_REG.test(specifiedDomain[1])) { + var _value = +MAX_VALUE_REG.exec(specifiedDomain[1])[1]; + domain[1] = dataDomain[1] + _value; + } else __WEBPACK_IMPORTED_MODULE_7_lodash_isFunction___default()(specifiedDomain[1]) ? domain[1] = specifiedDomain[1](dataDomain[1]) : domain[1] = dataDomain[1]; + return domain; + }, validateCoordinateInRange = function(coordinate, scale) { + if (!scale) return !1; + var range = scale.range(), first = range[0], last = range[range.length - 1]; + return first <= last ? coordinate >= first && coordinate <= last : coordinate >= last && coordinate <= first; + }, getBandSizeOfAxis = function(axis, ticks) { + if (axis && axis.scale && axis.scale.bandwidth) return axis.scale.bandwidth(); + if (axis && ticks && ticks.length >= 2) { + for (var orderedTicks = __WEBPACK_IMPORTED_MODULE_1_lodash_sortBy___default()(ticks, function(o) { + return o.coordinate; + }), bandSize = 1 / 0, i = 1, len = orderedTicks.length; i < len; i++) { + var cur = orderedTicks[i], prev = orderedTicks[i - 1]; + bandSize = Math.min((cur.coordinate || 0) - (prev.coordinate || 0), bandSize); + } + return bandSize === 1 / 0 ? 0 : bandSize; + } + return 0; + }, parseDomainOfCategoryAxis = function(specifiedDomain, calculatedDomain, axisChild) { + return specifiedDomain && specifiedDomain.length ? __WEBPACK_IMPORTED_MODULE_0_lodash_isEqual___default()(specifiedDomain, __WEBPACK_IMPORTED_MODULE_8_lodash_get___default()(axisChild, "type.defaultProps.domain")) ? calculatedDomain : specifiedDomain : calculatedDomain; + }; +}, function(module, exports) { + var core = module.exports = { + version: "2.5.3" + }; + "number" == typeof __e && (__e = core); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_arity__ = __webpack_require__(43), __WEBPACK_IMPORTED_MODULE_1__internal_curry1__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_2__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_3__internal_curryN__ = __webpack_require__(135), curryN = Object(__WEBPACK_IMPORTED_MODULE_2__internal_curry2__.a)(function(length, fn) { + return 1 === length ? Object(__WEBPACK_IMPORTED_MODULE_1__internal_curry1__.a)(fn) : Object(__WEBPACK_IMPORTED_MODULE_0__internal_arity__.a)(length, Object(__WEBPACK_IMPORTED_MODULE_3__internal_curryN__.a)(length, [], fn)); + }); + __webpack_exports__.a = curryN; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function newInterval(floori, offseti, count, field) { + function interval(date) { + return floori(date = new Date(+date)), date; + } + return interval.floor = interval, interval.ceil = function(date) { + return floori(date = new Date(date - 1)), offseti(date, 1), floori(date), date; + }, interval.round = function(date) { + var d0 = interval(date), d1 = interval.ceil(date); + return date - d0 < d1 - date ? d0 : d1; + }, interval.offset = function(date, step) { + return offseti(date = new Date(+date), null == step ? 1 : Math.floor(step)), date; + }, interval.range = function(start, stop, step) { + var previous, range = []; + if (start = interval.ceil(start), step = null == step ? 1 : Math.floor(step), !(start < stop && step > 0)) return range; + do { + range.push(previous = new Date(+start)), offseti(start, step), floori(start); + } while (previous < start && start < stop); + return range; + }, interval.filter = function(test) { + return newInterval(function(date) { + if (date >= date) for (;floori(date), !test(date); ) date.setTime(date - 1); + }, function(date, step) { + if (date >= date) if (step < 0) for (;++step <= 0; ) for (;offseti(date, -1), !test(date); ) ; else for (;--step >= 0; ) for (;offseti(date, 1), + !test(date); ) ; + }); + }, count && (interval.count = function(start, end) { + return t0.setTime(+start), t1.setTime(+end), floori(t0), floori(t1), Math.floor(count(t0, t1)); + }, interval.every = function(step) { + return step = Math.floor(step), isFinite(step) && step > 0 ? step > 1 ? interval.filter(field ? function(d) { + return field(d) % step == 0; + } : function(d) { + return interval.count(0, d) % step == 0; + }) : interval : null; + }), interval; + } + __webpack_exports__.a = newInterval; + var t0 = new Date(), t1 = new Date(); +}, function(module, exports, __webpack_require__) { + var global = __webpack_require__(36), core = __webpack_require__(22), ctx = __webpack_require__(64), hide = __webpack_require__(56), $export = function(type, name, source) { + var key, own, out, IS_FORCED = type & $export.F, IS_GLOBAL = type & $export.G, IS_STATIC = type & $export.S, IS_PROTO = type & $export.P, IS_BIND = type & $export.B, IS_WRAP = type & $export.W, exports = IS_GLOBAL ? core : core[name] || (core[name] = {}), expProto = exports.prototype, target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {}).prototype; + IS_GLOBAL && (source = name); + for (key in source) (own = !IS_FORCED && target && void 0 !== target[key]) && key in exports || (out = own ? target[key] : source[key], + exports[key] = IS_GLOBAL && "function" != typeof target[key] ? source[key] : IS_BIND && own ? ctx(out, global) : IS_WRAP && target[key] == out ? function(C) { + var F = function(a, b, c) { + if (this instanceof C) { + switch (arguments.length) { + case 0: + return new C(); + + case 1: + return new C(a); + + case 2: + return new C(a, b); + } + return new C(a, b, c); + } + return C.apply(this, arguments); + }; + return F.prototype = C.prototype, F; + }(out) : IS_PROTO && "function" == typeof out ? ctx(Function.call, out) : out, IS_PROTO && ((exports.virtual || (exports.virtual = {}))[key] = out, + type & $export.R && expProto && !expProto[key] && hide(expProto, key, out))); + }; + $export.F = 1, $export.G = 2, $export.S = 4, $export.P = 8, $export.B = 16, $export.W = 32, + $export.U = 64, $export.R = 128, module.exports = $export; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _has(prop, obj) { + return Object.prototype.hasOwnProperty.call(obj, prop); + } + __webpack_exports__.a = _has; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__internal_dispatchable__ = __webpack_require__(15), __WEBPACK_IMPORTED_MODULE_2__internal_map__ = __webpack_require__(136), __WEBPACK_IMPORTED_MODULE_3__internal_reduce__ = __webpack_require__(30), __WEBPACK_IMPORTED_MODULE_4__internal_xmap__ = __webpack_require__(582), __WEBPACK_IMPORTED_MODULE_5__curryN__ = __webpack_require__(23), __WEBPACK_IMPORTED_MODULE_6__keys__ = __webpack_require__(44), map = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(Object(__WEBPACK_IMPORTED_MODULE_1__internal_dispatchable__.a)([ "fantasy-land/map", "map" ], __WEBPACK_IMPORTED_MODULE_4__internal_xmap__.a, function(fn, functor) { + switch (Object.prototype.toString.call(functor)) { + case "[object Function]": + return Object(__WEBPACK_IMPORTED_MODULE_5__curryN__.a)(functor.length, function() { + return fn.call(this, functor.apply(this, arguments)); + }); + + case "[object Object]": + return Object(__WEBPACK_IMPORTED_MODULE_3__internal_reduce__.a)(function(acc, key) { + return acc[key] = fn(functor[key]), acc; + }, {}, Object(__WEBPACK_IMPORTED_MODULE_6__keys__.a)(functor)); + + default: + return Object(__WEBPACK_IMPORTED_MODULE_2__internal_map__.a)(fn, functor); + } + })); + __webpack_exports__.a = map; +}, function(module, exports) { + function isNil(value) { + return null == value; + } + module.exports = isNil; +}, function(module, exports, __webpack_require__) { + var store = __webpack_require__(182)("wks"), uid = __webpack_require__(124), Symbol = __webpack_require__(36).Symbol, USE_SYMBOL = "function" == typeof Symbol; + (module.exports = function(name) { + return store[name] || (store[name] = USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)("Symbol." + name)); + }).store = store; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _arrayReduce(xf, acc, list) { + for (var idx = 0, len = list.length; idx < len; ) { + if ((acc = xf["@@transducer/step"](acc, list[idx])) && acc["@@transducer/reduced"]) { + acc = acc["@@transducer/value"]; + break; + } + idx += 1; + } + return xf["@@transducer/result"](acc); + } + function _iterableReduce(xf, acc, iter) { + for (var step = iter.next(); !step.done; ) { + if ((acc = xf["@@transducer/step"](acc, step.value)) && acc["@@transducer/reduced"]) { + acc = acc["@@transducer/value"]; + break; + } + step = iter.next(); + } + return xf["@@transducer/result"](acc); + } + function _methodReduce(xf, acc, obj, methodName) { + return xf["@@transducer/result"](obj[methodName](Object(__WEBPACK_IMPORTED_MODULE_2__bind__.a)(xf["@@transducer/step"], xf), acc)); + } + function _reduce(fn, acc, list) { + if ("function" == typeof fn && (fn = Object(__WEBPACK_IMPORTED_MODULE_1__xwrap__.a)(fn)), + Object(__WEBPACK_IMPORTED_MODULE_0__isArrayLike__.a)(list)) return _arrayReduce(fn, acc, list); + if ("function" == typeof list["fantasy-land/reduce"]) return _methodReduce(fn, acc, list, "fantasy-land/reduce"); + if (null != list[symIterator]) return _iterableReduce(fn, acc, list[symIterator]()); + if ("function" == typeof list.next) return _iterableReduce(fn, acc, list); + if ("function" == typeof list.reduce) return _methodReduce(fn, acc, list, "reduce"); + throw new TypeError("reduce: list must be array or iterable"); + } + __webpack_exports__.a = _reduce; + var __WEBPACK_IMPORTED_MODULE_0__isArrayLike__ = __webpack_require__(137), __WEBPACK_IMPORTED_MODULE_1__xwrap__ = __webpack_require__(298), __WEBPACK_IMPORTED_MODULE_2__bind__ = __webpack_require__(299), symIterator = "undefined" != typeof Symbol ? Symbol.iterator : "@@iterator"; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__internal_equals__ = __webpack_require__(605), equals = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(a, b) { + return Object(__WEBPACK_IMPORTED_MODULE_1__internal_equals__.a)(a, b, [], []); + }); + __webpack_exports__.a = equals; +}, function(module, exports, __webpack_require__) { + var anObject = __webpack_require__(65), IE8_DOM_DEFINE = __webpack_require__(270), toPrimitive = __webpack_require__(176), dP = Object.defineProperty; + exports.f = __webpack_require__(37) ? Object.defineProperty : function(O, P, Attributes) { + if (anObject(O), P = toPrimitive(P, !0), anObject(Attributes), IE8_DOM_DEFINE) try { + return dP(O, P, Attributes); + } catch (e) {} + if ("get" in Attributes || "set" in Attributes) throw TypeError("Accessors not supported!"); + return "value" in Attributes && (O[P] = Attributes.value), O; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _concat(set1, set2) { + set1 = set1 || [], set2 = set2 || []; + var idx, len1 = set1.length, len2 = set2.length, result = []; + for (idx = 0; idx < len1; ) result[result.length] = set1[idx], idx += 1; + for (idx = 0; idx < len2; ) result[result.length] = set2[idx], idx += 1; + return result; + } + __webpack_exports__.a = _concat; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_checkForMethod__ = __webpack_require__(99), __WEBPACK_IMPORTED_MODULE_1__internal_curry3__ = __webpack_require__(5), slice = Object(__WEBPACK_IMPORTED_MODULE_1__internal_curry3__.a)(Object(__WEBPACK_IMPORTED_MODULE_0__internal_checkForMethod__.a)("slice", function(fromIndex, toIndex, list) { + return Array.prototype.slice.call(list, fromIndex, toIndex); + })); + __webpack_exports__.a = slice; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _defineProperty(obj, key, value) { + return key in obj ? Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }) : obj[key] = value, obj; + } + __webpack_require__.d(__webpack_exports__, "a", function() { + return RADIAN; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return polarToCartesian; + }), __webpack_require__.d(__webpack_exports__, "c", function() { + return getMaxRadius; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return formatAxisMap; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return inRangeOfSector; + }); + var __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1__DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_2__ChartUtils__ = __webpack_require__(21), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, RADIAN = Math.PI / 180, radianToDegree = function(angleInRadian) { + return 180 * angleInRadian / Math.PI; + }, polarToCartesian = function(cx, cy, radius, angle) { + return { + x: cx + Math.cos(-RADIAN * angle) * radius, + y: cy + Math.sin(-RADIAN * angle) * radius + }; + }, getMaxRadius = function(width, height) { + var offset = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : { + top: 0, + right: 0, + bottom: 0, + left: 0 + }; + return Math.min(Math.abs(width - (offset.left || 0) - (offset.right || 0)), Math.abs(height - (offset.top || 0) - (offset.bottom || 0))) / 2; + }, formatAxisMap = function(props, axisMap, offset, axisType, chartName) { + var width = props.width, height = props.height, startAngle = props.startAngle, endAngle = props.endAngle, cx = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.c)(props.cx, width, width / 2), cy = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.c)(props.cy, height, height / 2), maxRadius = getMaxRadius(width, height, offset), innerRadius = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.c)(props.innerRadius, maxRadius, 0), outerRadius = Object(__WEBPACK_IMPORTED_MODULE_1__DataUtils__.c)(props.outerRadius, maxRadius, .8 * maxRadius); + return Object.keys(axisMap).reduce(function(result, id) { + var axis = axisMap[id], domain = axis.domain, reversed = axis.reversed, range = void 0; + __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(axis.range) ? ("angleAxis" === axisType ? range = [ startAngle, endAngle ] : "radiusAxis" === axisType && (range = [ innerRadius, outerRadius ]), + reversed && (range = [ range[1], range[0] ])) : (range = axis.range, startAngle = range[0], + endAngle = range[1]); + var _parseScale = Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.A)(axis, chartName), realScaleType = _parseScale.realScaleType, scale = _parseScale.scale; + scale.domain(domain).range(range), Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.c)(scale); + var ticks = Object(__WEBPACK_IMPORTED_MODULE_2__ChartUtils__.v)(scale, _extends({}, axis, { + realScaleType: realScaleType + })), finalAxis = _extends({}, axis, ticks, { + range: range, + radius: outerRadius, + realScaleType: realScaleType, + scale: scale, + cx: cx, + cy: cy, + innerRadius: innerRadius, + outerRadius: outerRadius, + startAngle: startAngle, + endAngle: endAngle + }); + return _extends({}, result, _defineProperty({}, id, finalAxis)); + }, {}); + }, distanceBetweenPoints = function(point, anotherPoint) { + var x1 = point.x, y1 = point.y, x2 = anotherPoint.x, y2 = anotherPoint.y; + return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2)); + }, getAngleOfPoint = function(_ref, _ref2) { + var x = _ref.x, y = _ref.y, cx = _ref2.cx, cy = _ref2.cy, radius = distanceBetweenPoints({ + x: x, + y: y + }, { + x: cx, + y: cy + }); + if (radius <= 0) return { + radius: radius + }; + var cos = (x - cx) / radius, angleInRadian = Math.acos(cos); + return y > cy && (angleInRadian = 2 * Math.PI - angleInRadian), { + radius: radius, + angle: radianToDegree(angleInRadian), + angleInRadian: angleInRadian + }; + }, formatAngleOfSector = function(_ref3) { + var startAngle = _ref3.startAngle, endAngle = _ref3.endAngle, startCnt = Math.floor(startAngle / 360), endCnt = Math.floor(endAngle / 360), min = Math.min(startCnt, endCnt); + return { + startAngle: startAngle - 360 * min, + endAngle: endAngle - 360 * min + }; + }, reverseFormatAngleOfSetor = function(angle, _ref4) { + var startAngle = _ref4.startAngle, endAngle = _ref4.endAngle, startCnt = Math.floor(startAngle / 360), endCnt = Math.floor(endAngle / 360); + return angle + 360 * Math.min(startCnt, endCnt); + }, inRangeOfSector = function(_ref5, sector) { + var x = _ref5.x, y = _ref5.y, _getAngleOfPoint = getAngleOfPoint({ + x: x, + y: y + }, sector), radius = _getAngleOfPoint.radius, angle = _getAngleOfPoint.angle, innerRadius = sector.innerRadius, outerRadius = sector.outerRadius; + if (radius < innerRadius || radius > outerRadius) return !1; + if (0 === radius) return !0; + var _formatAngleOfSector = formatAngleOfSector(sector), startAngle = _formatAngleOfSector.startAngle, endAngle = _formatAngleOfSector.endAngle, formatAngle = angle, inRange = void 0; + if (startAngle <= endAngle) { + for (;formatAngle > endAngle; ) formatAngle -= 360; + for (;formatAngle < startAngle; ) formatAngle += 360; + inRange = formatAngle >= startAngle && formatAngle <= endAngle; + } else { + for (;formatAngle > startAngle; ) formatAngle -= 360; + for (;formatAngle < endAngle; ) formatAngle += 360; + inRange = formatAngle >= endAngle && formatAngle <= startAngle; + } + return inRange ? _extends({}, sector, { + radius: radius, + angle: reverseFormatAngleOfSetor(formatAngle, sector) + }) : null; + }; +}, function(module, exports) { + var global = module.exports = "undefined" != typeof window && window.Math == Math ? window : "undefined" != typeof self && self.Math == Math ? self : Function("return this")(); + "number" == typeof __g && (__g = global); +}, function(module, exports, __webpack_require__) { + module.exports = !__webpack_require__(66)(function() { + return 7 != Object.defineProperty({}, "a", { + get: function() { + return 7; + } + }).a; + }); +}, function(module, exports, __webpack_require__) { + module.exports = { + default: __webpack_require__(472), + __esModule: !0 + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0, exports.default = function(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0; + var _defineProperty = __webpack_require__(185), _defineProperty2 = function(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + }(_defineProperty); + exports.default = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), (0, _defineProperty2.default)(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(); +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0; + var _typeof2 = __webpack_require__(126), _typeof3 = function(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + }(_typeof2); + exports.default = function(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" !== (void 0 === call ? "undefined" : (0, _typeof3.default)(call)) && "function" != typeof call ? self : call; + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + exports.__esModule = !0; + var _setPrototypeOf = __webpack_require__(489), _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf), _create = __webpack_require__(493), _create2 = _interopRequireDefault(_create), _typeof2 = __webpack_require__(126), _typeof3 = _interopRequireDefault(_typeof2); + exports.default = function(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + (void 0 === superClass ? "undefined" : (0, + _typeof3.default)(superClass))); + subClass.prototype = (0, _create2.default)(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (_setPrototypeOf2.default ? (0, _setPrototypeOf2.default)(subClass, superClass) : subClass.__proto__ = superClass); + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _arity(n, fn) { + switch (n) { + case 0: + return function() { + return fn.apply(this, arguments); + }; + + case 1: + return function(a0) { + return fn.apply(this, arguments); + }; + + case 2: + return function(a0, a1) { + return fn.apply(this, arguments); + }; + + case 3: + return function(a0, a1, a2) { + return fn.apply(this, arguments); + }; + + case 4: + return function(a0, a1, a2, a3) { + return fn.apply(this, arguments); + }; + + case 5: + return function(a0, a1, a2, a3, a4) { + return fn.apply(this, arguments); + }; + + case 6: + return function(a0, a1, a2, a3, a4, a5) { + return fn.apply(this, arguments); + }; + + case 7: + return function(a0, a1, a2, a3, a4, a5, a6) { + return fn.apply(this, arguments); + }; + + case 8: + return function(a0, a1, a2, a3, a4, a5, a6, a7) { + return fn.apply(this, arguments); + }; + + case 9: + return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { + return fn.apply(this, arguments); + }; + + case 10: + return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return fn.apply(this, arguments); + }; + + default: + throw new Error("First argument to _arity must be a non-negative integer no greater than ten"); + } + } + __webpack_exports__.a = _arity; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry1__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_1__internal_has__ = __webpack_require__(26), __WEBPACK_IMPORTED_MODULE_2__internal_isArguments__ = __webpack_require__(300), hasEnumBug = !{ + toString: null + }.propertyIsEnumerable("toString"), nonEnumerableProps = [ "constructor", "valueOf", "isPrototypeOf", "toString", "propertyIsEnumerable", "hasOwnProperty", "toLocaleString" ], hasArgsEnumBug = function() { + return arguments.propertyIsEnumerable("length"); + }(), contains = function(list, item) { + for (var idx = 0; idx < list.length; ) { + if (list[idx] === item) return !0; + idx += 1; + } + return !1; + }, _keys = "function" != typeof Object.keys || hasArgsEnumBug ? function(obj) { + if (Object(obj) !== obj) return []; + var prop, nIdx, ks = [], checkArgsLength = hasArgsEnumBug && Object(__WEBPACK_IMPORTED_MODULE_2__internal_isArguments__.a)(obj); + for (prop in obj) !Object(__WEBPACK_IMPORTED_MODULE_1__internal_has__.a)(prop, obj) || checkArgsLength && "length" === prop || (ks[ks.length] = prop); + if (hasEnumBug) for (nIdx = nonEnumerableProps.length - 1; nIdx >= 0; ) prop = nonEnumerableProps[nIdx], + Object(__WEBPACK_IMPORTED_MODULE_1__internal_has__.a)(prop, obj) && !contains(ks, prop) && (ks[ks.length] = prop), + nIdx -= 1; + return ks; + } : function(obj) { + return Object(obj) !== obj ? [] : Object.keys(obj); + }, keys = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry1__.a)(_keys); + __webpack_exports__.a = keys; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry3__ = __webpack_require__(5), __WEBPACK_IMPORTED_MODULE_1__internal_reduce__ = __webpack_require__(30), reduce = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry3__.a)(__WEBPACK_IMPORTED_MODULE_1__internal_reduce__.a); + __webpack_exports__.a = reduce; +}, function(module, exports, __webpack_require__) { + var freeGlobal = __webpack_require__(365), freeSelf = "object" == typeof self && self && self.Object === Object && self, root = freeGlobal || freeSelf || Function("return this")(); + module.exports = root; +}, function(module, exports) { + function isObject(value) { + var type = typeof value; + return null != value && ("object" == type || "function" == type); + } + module.exports = isObject; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }), exports.translateStyle = exports.AnimateGroup = exports.configBezier = exports.configSpring = void 0; + var _Animate = __webpack_require__(383), _Animate2 = _interopRequireDefault(_Animate), _easing = __webpack_require__(395), _util = __webpack_require__(165), _AnimateGroup = __webpack_require__(986), _AnimateGroup2 = _interopRequireDefault(_AnimateGroup); + exports.configSpring = _easing.configSpring, exports.configBezier = _easing.configBezier, + exports.AnimateGroup = _AnimateGroup2.default, exports.translateStyle = _util.translateStyle, + exports.default = _Animate2.default; +}, function(module, exports, __webpack_require__) { + function isEqual(value, other) { + return baseIsEqual(value, other); + } + var baseIsEqual = __webpack_require__(240); + module.exports = isEqual; +}, function(module, exports) { + module.exports = function(it) { + return "object" == typeof it ? null !== it : "function" == typeof it; + }; +}, function(module, exports, __webpack_require__) { + module.exports = { + default: __webpack_require__(500), + __esModule: !0 + }; +}, function(module, exports) { + function isObjectLike(value) { + return null != value && "object" == typeof value; + } + module.exports = isObjectLike; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__src_bisect__ = __webpack_require__(409); + __webpack_require__.d(__webpack_exports__, "b", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_bisect__.a; + }); + var __WEBPACK_IMPORTED_MODULE_1__src_ascending__ = __webpack_require__(84); + __webpack_require__.d(__webpack_exports__, "a", function() { + return __WEBPACK_IMPORTED_MODULE_1__src_ascending__.a; + }); + var __WEBPACK_IMPORTED_MODULE_2__src_bisector__ = __webpack_require__(410); + __webpack_require__.d(__webpack_exports__, "c", function() { + return __WEBPACK_IMPORTED_MODULE_2__src_bisector__.a; + }); + var __WEBPACK_IMPORTED_MODULE_18__src_quantile__ = (__webpack_require__(1015), __webpack_require__(1016), + __webpack_require__(412), __webpack_require__(414), __webpack_require__(1017), __webpack_require__(1020), + __webpack_require__(1021), __webpack_require__(418), __webpack_require__(1022), + __webpack_require__(1023), __webpack_require__(1024), __webpack_require__(1025), + __webpack_require__(419), __webpack_require__(411), __webpack_require__(1026), __webpack_require__(248)); + __webpack_require__.d(__webpack_exports__, "d", function() { + return __WEBPACK_IMPORTED_MODULE_18__src_quantile__.a; + }); + var __WEBPACK_IMPORTED_MODULE_19__src_range__ = __webpack_require__(416); + __webpack_require__.d(__webpack_exports__, "e", function() { + return __WEBPACK_IMPORTED_MODULE_19__src_range__.a; + }); + var __WEBPACK_IMPORTED_MODULE_23__src_ticks__ = (__webpack_require__(1027), __webpack_require__(1028), + __webpack_require__(1029), __webpack_require__(417)); + __webpack_require__.d(__webpack_exports__, "h", function() { + return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.a; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.b; + }), __webpack_require__.d(__webpack_exports__, "g", function() { + return __WEBPACK_IMPORTED_MODULE_23__src_ticks__.c; + }); + __webpack_require__(420), __webpack_require__(413), __webpack_require__(1030); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.d(__webpack_exports__, "d", function() { + return durationSecond; + }), __webpack_require__.d(__webpack_exports__, "c", function() { + return durationMinute; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return durationHour; + }), __webpack_require__.d(__webpack_exports__, "a", function() { + return durationDay; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return durationWeek; + }); + var durationSecond = 1e3, durationMinute = 6e4, durationHour = 36e5, durationDay = 864e5, durationWeek = 6048e5; +}, function(module, exports, __webpack_require__) { + "use strict"; + function makeEmptyFunction(arg) { + return function() { + return arg; + }; + } + var emptyFunction = function() {}; + emptyFunction.thatReturns = makeEmptyFunction, emptyFunction.thatReturnsFalse = makeEmptyFunction(!1), + emptyFunction.thatReturnsTrue = makeEmptyFunction(!0), emptyFunction.thatReturnsNull = makeEmptyFunction(null), + emptyFunction.thatReturnsThis = function() { + return this; + }, emptyFunction.thatReturnsArgument = function(arg) { + return arg; + }, module.exports = emptyFunction; +}, function(module, exports, __webpack_require__) { + var dP = __webpack_require__(32), createDesc = __webpack_require__(91); + module.exports = __webpack_require__(37) ? function(object, key, value) { + return dP.f(object, key, createDesc(1, value)); + } : function(object, key, value) { + return object[key] = value, object; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = Array.isArray || function(val) { + return null != val && val.length >= 0 && "[object Array]" === Object.prototype.toString.call(val); + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _reduced(x) { + return x && x["@@transducer/reduced"] ? x : { + "@@transducer/value": x, + "@@transducer/reduced": !0 + }; + } + __webpack_exports__.a = _reduced; +}, function(module, exports, __webpack_require__) { + function baseGetTag(value) { + return null == value ? void 0 === value ? undefinedTag : nullTag : symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value); + } + var Symbol = __webpack_require__(104), getRawTag = __webpack_require__(861), objectToString = __webpack_require__(862), nullTag = "[object Null]", undefinedTag = "[object Undefined]", symToStringTag = Symbol ? Symbol.toStringTag : void 0; + module.exports = baseGetTag; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } + return Array.from(arr); + } + function Label(props) { + var viewBox = props.viewBox, position = props.position, value = props.value, children = props.children, content = props.content, _props$className = props.className, className = void 0 === _props$className ? "" : _props$className; + if (!viewBox || __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(value) && __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(children) && !Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(content) && !__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(content)) return null; + if (Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(content)) return Object(__WEBPACK_IMPORTED_MODULE_3_react__.cloneElement)(content, props); + var label = void 0; + if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(content)) { + if (label = content(props), Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(label)) return label; + } else label = getLabel(props); + var isPolarLabel = isPolar(viewBox), attrs = Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.k)(props); + if (isPolarLabel && ("insideStart" === position || "insideEnd" === position || "end" === position)) return renderRadialLabel(props, label, attrs); + var positionAttrs = isPolarLabel ? getAttrsOfPolarLabel(props) : getAttrsOfCartesianLabel(props); + return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_6__Text__.a, _extends({ + className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-label", className) + }, attrs, positionAttrs), label); + } + var __WEBPACK_IMPORTED_MODULE_0_lodash_isObject__ = __webpack_require__(47), __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_3_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_3_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react__), __WEBPACK_IMPORTED_MODULE_4_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_4_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_prop_types__), __WEBPACK_IMPORTED_MODULE_5_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_5_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_classnames__), __WEBPACK_IMPORTED_MODULE_6__Text__ = __webpack_require__(72), __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__ = __webpack_require__(7), __WEBPACK_IMPORTED_MODULE_8__util_DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__ = __webpack_require__(35), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, cartesianViewBoxShape = __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.shape({ + x: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + y: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + width: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number + }), polarViewBoxShape = __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.shape({ + cx: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + cy: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + innerRadius: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + outerRadius: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + startAngle: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + endAngle: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number + }), propTypes = { + viewBox: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ cartesianViewBoxShape, polarViewBoxShape ]), + formatter: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func, + value: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string ]), + offset: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.number, + position: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOf([ "top", "left", "right", "bottom", "inside", "outside", "insideLeft", "insideRight", "insideTop", "insideBottom", "insideTopLeft", "insideBottomLeft", "insideTopRight", "insideBottomRight", "insideStart", "insideEnd", "end", "center" ]), + children: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.node ]), + className: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.string, + content: __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.element, __WEBPACK_IMPORTED_MODULE_4_prop_types___default.a.func ]) + }, defaultProps = { + offset: 5 + }, getLabel = function(props) { + var value = props.value, formatter = props.formatter, label = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(props.children) ? value : props.children; + return __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(formatter) ? formatter(label) : label; + }, getDeltaAngle = function(startAngle, endAngle) { + return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.i)(endAngle - startAngle) * Math.min(Math.abs(endAngle - startAngle), 360); + }, renderRadialLabel = function(labelProps, label, attrs) { + var position = labelProps.position, viewBox = labelProps.viewBox, offset = labelProps.offset, className = labelProps.className, cx = viewBox.cx, cy = viewBox.cy, innerRadius = viewBox.innerRadius, outerRadius = viewBox.outerRadius, startAngle = viewBox.startAngle, endAngle = viewBox.endAngle, clockWise = viewBox.clockWise, radius = (innerRadius + outerRadius) / 2, deltaAngle = getDeltaAngle(startAngle, endAngle), sign = deltaAngle >= 0 ? 1 : -1, labelAngle = void 0, direction = void 0; + "insideStart" === position ? (labelAngle = startAngle + sign * offset, direction = clockWise) : "insideEnd" === position ? (labelAngle = endAngle - sign * offset, + direction = !clockWise) : "end" === position && (labelAngle = endAngle + sign * offset, + direction = clockWise), direction = deltaAngle <= 0 ? direction : !direction; + var startPoint = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, radius, labelAngle), endPoint = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, radius, labelAngle + 359 * (direction ? 1 : -1)), path = "M" + startPoint.x + "," + startPoint.y + "\n A" + radius + "," + radius + ",0,1," + (direction ? 0 : 1) + ",\n " + endPoint.x + "," + endPoint.y, id = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(labelProps.id) ? Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.j)("recharts-radial-line-") : labelProps.id; + return __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("text", _extends({}, attrs, { + dominantBaseline: "central", + className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-radial-bar-label", className) + }), __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("defs", null, __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("path", { + id: id, + d: path + })), __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement("textPath", { + xlinkHref: "#" + id + }, label)); + }, getAttrsOfPolarLabel = function(props) { + var viewBox = props.viewBox, offset = props.offset, position = props.position, cx = viewBox.cx, cy = viewBox.cy, innerRadius = viewBox.innerRadius, outerRadius = viewBox.outerRadius, startAngle = viewBox.startAngle, endAngle = viewBox.endAngle, midAngle = (startAngle + endAngle) / 2; + if ("outside" === position) { + var _polarToCartesian = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, outerRadius + offset, midAngle), _x = _polarToCartesian.x; + return { + x: _x, + y: _polarToCartesian.y, + textAnchor: _x >= cx ? "start" : "end", + verticalAnchor: "middle" + }; + } + if ("center" === position) return { + x: cx, + y: cy, + textAnchor: "middle", + verticalAnchor: "middle" + }; + var r = (innerRadius + outerRadius) / 2, _polarToCartesian2 = Object(__WEBPACK_IMPORTED_MODULE_9__util_PolarUtils__.e)(cx, cy, r, midAngle); + return { + x: _polarToCartesian2.x, + y: _polarToCartesian2.y, + textAnchor: "middle", + verticalAnchor: "middle" + }; + }, getAttrsOfCartesianLabel = function(props) { + var viewBox = props.viewBox, offset = props.offset, position = props.position, x = viewBox.x, y = viewBox.y, width = viewBox.width, height = viewBox.height, sign = height >= 0 ? 1 : -1; + return "top" === position ? { + x: x + width / 2, + y: y - sign * offset, + textAnchor: "middle", + verticalAnchor: "end" + } : "bottom" === position ? { + x: x + width / 2, + y: y + height + sign * offset, + textAnchor: "middle", + verticalAnchor: "start" + } : "left" === position ? { + x: x - offset, + y: y + height / 2, + textAnchor: "end", + verticalAnchor: "middle" + } : "right" === position ? { + x: x + width + offset, + y: y + height / 2, + textAnchor: "start", + verticalAnchor: "middle" + } : "insideLeft" === position ? { + x: x + offset, + y: y + height / 2, + textAnchor: "start", + verticalAnchor: "middle" + } : "insideRight" === position ? { + x: x + width - offset, + y: y + height / 2, + textAnchor: "end", + verticalAnchor: "middle" + } : "insideTop" === position ? { + x: x + width / 2, + y: y + sign * offset, + textAnchor: "middle", + verticalAnchor: "start" + } : "insideBottom" === position ? { + x: x + width / 2, + y: y + height - sign * offset, + textAnchor: "middle", + verticalAnchor: "end" + } : "insideTopLeft" === position ? { + x: x + offset, + y: y + sign * offset, + textAnchor: "start", + verticalAnchor: "start" + } : "insideTopRight" === position ? { + x: x + width - offset, + y: y + sign * offset, + textAnchor: "end", + verticalAnchor: "start" + } : "insideBottomLeft" === position ? { + x: x + offset, + y: y + height - sign * offset, + textAnchor: "start", + verticalAnchor: "end" + } : "insideBottomRight" === position ? { + x: x + width - offset, + y: y + height - sign * offset, + textAnchor: "end", + verticalAnchor: "end" + } : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(position) && (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(position.x) || Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(position.x)) && (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(position.y) || Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.h)(position.y)) ? { + x: x + Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.c)(position.x, width), + y: y + Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.c)(position.y, height), + textAnchor: "end", + verticalAnchor: "end" + } : { + x: x + width / 2, + y: y + height / 2, + textAnchor: "middle", + verticalAnchor: "middle" + }; + }, isPolar = function(viewBox) { + return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(viewBox.cx); + }; + Label.displayName = "Label", Label.defaultProps = defaultProps, Label.propTypes = propTypes; + var parseViewBox = function(props) { + var cx = props.cx, cy = props.cy, angle = props.angle, startAngle = props.startAngle, endAngle = props.endAngle, r = props.r, radius = props.radius, innerRadius = props.innerRadius, outerRadius = props.outerRadius, x = props.x, y = props.y, top = props.top, left = props.left, width = props.width, height = props.height, clockWise = props.clockWise; + if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(width) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(height)) { + if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(x) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(y)) return { + x: x, + y: y, + width: width, + height: height + }; + if (Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(top) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(left)) return { + x: top, + y: left, + width: width, + height: height + }; + } + return Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(x) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(y) ? { + x: x, + y: y, + width: 0, + height: 0 + } : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(cx) && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(cy) ? { + cx: cx, + cy: cy, + startAngle: startAngle || angle || 0, + endAngle: endAngle || angle || 0, + innerRadius: innerRadius || 0, + outerRadius: outerRadius || radius || r || 0, + clockWise: clockWise + } : props.viewBox ? props.viewBox : {}; + }, parseLabel = function(label, viewBox) { + return label ? !0 === label ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, { + key: "label-implicit", + viewBox: viewBox + }) : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.f)(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, { + key: "label-implicit", + viewBox: viewBox, + value: label + }) : Object(__WEBPACK_IMPORTED_MODULE_3_react__.isValidElement)(label) || __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, { + key: "label-implicit", + content: label, + viewBox: viewBox + }) : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(label) ? __WEBPACK_IMPORTED_MODULE_3_react___default.a.createElement(Label, _extends({ + viewBox: viewBox + }, label, { + key: "label-implicit" + })) : null : null; + }, renderCallByParent = function(parentProps, viewBox) { + var ckeckPropsLabel = !(arguments.length > 2 && void 0 !== arguments[2]) || arguments[2]; + if (!parentProps || !parentProps.children && ckeckPropsLabel && !parentProps.label) return null; + var children = parentProps.children, parentViewBox = parseViewBox(parentProps), explicitChilren = Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.h)(children, Label).map(function(child, index) { + return Object(__WEBPACK_IMPORTED_MODULE_3_react__.cloneElement)(child, { + viewBox: viewBox || parentViewBox, + key: "label-" + index + }); + }); + return ckeckPropsLabel ? [ parseLabel(parentProps.label, viewBox || parentViewBox) ].concat(_toConsumableArray(explicitChilren)) : explicitChilren; + }; + Label.parseViewBox = parseViewBox, Label.renderCallByParent = renderCallByParent, + __webpack_exports__.a = Label; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__src_color__ = __webpack_require__(251); + __webpack_require__.d(__webpack_exports__, "a", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_color__.e; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_color__.g; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_color__.f; + }); + var __WEBPACK_IMPORTED_MODULE_1__src_lab__ = __webpack_require__(1038); + __webpack_require__.d(__webpack_exports__, "e", function() { + return __WEBPACK_IMPORTED_MODULE_1__src_lab__.a; + }), __webpack_require__.d(__webpack_exports__, "c", function() { + return __WEBPACK_IMPORTED_MODULE_1__src_lab__.b; + }); + var __WEBPACK_IMPORTED_MODULE_2__src_cubehelix__ = __webpack_require__(1039); + __webpack_require__.d(__webpack_exports__, "b", function() { + return __WEBPACK_IMPORTED_MODULE_2__src_cubehelix__.a; + }); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } + return Array.from(arr); + } + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function LabelList(props) { + var data = props.data, valueAccessor = props.valueAccessor, dataKey = props.dataKey, clockWise = props.clockWise, id = props.id, others = _objectWithoutProperties(props, [ "data", "valueAccessor", "dataKey", "clockWise", "id" ]); + return data && data.length ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_8__container_Layer__.a, { + className: "recharts-label-list" + }, data.map(function(entry, index) { + var value = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(dataKey) ? valueAccessor(entry, index) : Object(__WEBPACK_IMPORTED_MODULE_10__util_ChartUtils__.w)(entry && entry.payload, dataKey), idProps = __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(id) ? {} : { + id: id + "-" + index + }; + return __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_7__Label__.a, _extends({}, Object(__WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__.k)(entry), others, idProps, { + index: index, + value: value, + viewBox: __WEBPACK_IMPORTED_MODULE_7__Label__.a.parseViewBox(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default()(clockWise) ? entry : _extends({}, entry, { + clockWise: clockWise + })), + key: "label-" + index + })); + })) : null; + } + var __WEBPACK_IMPORTED_MODULE_0_lodash_isObject__ = __webpack_require__(47), __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isObject__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_2_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_3_lodash_last__ = __webpack_require__(1089), __WEBPACK_IMPORTED_MODULE_3_lodash_last___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_last__), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_5_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_5_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_react__), __WEBPACK_IMPORTED_MODULE_6_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_6_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_prop_types__), __WEBPACK_IMPORTED_MODULE_7__Label__ = __webpack_require__(60), __WEBPACK_IMPORTED_MODULE_8__container_Layer__ = __webpack_require__(18), __WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__ = __webpack_require__(7), __WEBPACK_IMPORTED_MODULE_10__util_ChartUtils__ = __webpack_require__(21), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, propTypes = { + id: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, + data: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.object), + valueAccessor: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func, + clockWise: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.bool, + dataKey: __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_6_prop_types___default.a.func ]) + }, defaultProps = { + valueAccessor: function(entry) { + return __WEBPACK_IMPORTED_MODULE_4_lodash_isArray___default()(entry.value) ? __WEBPACK_IMPORTED_MODULE_3_lodash_last___default()(entry.value) : entry.value; + } + }; + LabelList.propTypes = propTypes, LabelList.displayName = "LabelList"; + var parseLabelList = function(label, data) { + return label ? !0 === label ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, { + key: "labelList-implicit", + data: data + }) : __WEBPACK_IMPORTED_MODULE_5_react___default.a.isValidElement(label) || __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(label) ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, { + key: "labelList-implicit", + data: data, + content: label + }) : __WEBPACK_IMPORTED_MODULE_0_lodash_isObject___default()(label) ? __WEBPACK_IMPORTED_MODULE_5_react___default.a.createElement(LabelList, _extends({ + data: data + }, label, { + key: "labelList-implicit" + })) : null : null; + }, renderCallByParent = function(parentProps, data) { + var ckeckPropsLabel = !(arguments.length > 2 && void 0 !== arguments[2]) || arguments[2]; + if (!parentProps || !parentProps.children && ckeckPropsLabel && !parentProps.label) return null; + var children = parentProps.children, explicitChilren = Object(__WEBPACK_IMPORTED_MODULE_9__util_ReactUtils__.h)(children, LabelList).map(function(child, index) { + return Object(__WEBPACK_IMPORTED_MODULE_5_react__.cloneElement)(child, { + data: data, + key: "labelList-" + index + }); + }); + return ckeckPropsLabel ? [ parseLabelList(parentProps.label, data) ].concat(_toConsumableArray(explicitChilren)) : explicitChilren; + }; + LabelList.renderCallByParent = renderCallByParent, LabelList.defaultProps = defaultProps, + __webpack_exports__.a = LabelList; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function _defineProperty(obj, key, value) { + return key in obj ? Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }) : obj[key] = value, obj; + } + function _toConsumableArray(arr) { + if (Array.isArray(arr)) { + for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; + return arr2; + } + return Array.from(arr); + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy__ = __webpack_require__(402), __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_sortBy__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_lodash_get__ = __webpack_require__(152), __WEBPACK_IMPORTED_MODULE_2_lodash_get___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_lodash_get__), __WEBPACK_IMPORTED_MODULE_3_lodash_range__ = __webpack_require__(450), __WEBPACK_IMPORTED_MODULE_3_lodash_range___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_lodash_range__), __WEBPACK_IMPORTED_MODULE_4_lodash_throttle__ = __webpack_require__(1097), __WEBPACK_IMPORTED_MODULE_4_lodash_throttle___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_lodash_throttle__), __WEBPACK_IMPORTED_MODULE_5_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_6_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_6_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_6_react__), __WEBPACK_IMPORTED_MODULE_7_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_7_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_7_prop_types__), __WEBPACK_IMPORTED_MODULE_8_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_8_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_8_classnames__), __WEBPACK_IMPORTED_MODULE_9__container_Surface__ = __webpack_require__(103), __WEBPACK_IMPORTED_MODULE_10__container_Layer__ = __webpack_require__(18), __WEBPACK_IMPORTED_MODULE_11__component_Tooltip__ = __webpack_require__(164), __WEBPACK_IMPORTED_MODULE_12__component_Legend__ = __webpack_require__(233), __WEBPACK_IMPORTED_MODULE_13__shape_Curve__ = __webpack_require__(86), __WEBPACK_IMPORTED_MODULE_14__shape_Cross__ = __webpack_require__(444), __WEBPACK_IMPORTED_MODULE_15__shape_Sector__ = __webpack_require__(170), __WEBPACK_IMPORTED_MODULE_16__shape_Dot__ = __webpack_require__(74), __WEBPACK_IMPORTED_MODULE_17__shape_Rectangle__ = __webpack_require__(85), __WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__ = __webpack_require__(7), __WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__ = __webpack_require__(451), __WEBPACK_IMPORTED_MODULE_20__cartesian_Brush__ = __webpack_require__(449), __WEBPACK_IMPORTED_MODULE_21__util_DOMUtils__ = __webpack_require__(247), __WEBPACK_IMPORTED_MODULE_22__util_DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__ = __webpack_require__(21), __WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__ = __webpack_require__(35), __WEBPACK_IMPORTED_MODULE_25__util_PureRender__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_26__util_Events__ = __webpack_require__(1098), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), ORIENT_MAP = { + xAxis: [ "bottom", "top" ], + yAxis: [ "left", "right" ] + }, originCoordinate = { + x: 0, + y: 0 + }, generateCategoricalChart = function(_ref) { + var _class, _temp, _initialiseProps, chartName = _ref.chartName, GraphicalChild = _ref.GraphicalChild, _ref$eventType = _ref.eventType, eventType = void 0 === _ref$eventType ? "axis" : _ref$eventType, axisComponents = _ref.axisComponents, legendContent = _ref.legendContent, formatAxisMap = _ref.formatAxisMap, defaultProps = _ref.defaultProps, propTypes = _ref.propTypes; + return _temp = _class = function(_Component) { + function CategoricalChartWrapper(props) { + _classCallCheck(this, CategoricalChartWrapper); + var _this = _possibleConstructorReturn(this, (CategoricalChartWrapper.__proto__ || Object.getPrototypeOf(CategoricalChartWrapper)).call(this, props)); + _initialiseProps.call(_this); + var defaultState = _this.constructor.createDefaultState(props); + return _this.state = _extends({}, defaultState, { + updateId: 0 + }, _this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({ + props: props + }, defaultState, { + updateId: 0 + }))), _this.uniqueChartId = __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(props.id) ? Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.j)("recharts") : props.id, + props.throttleDelay && (_this.triggeredAfterMouseMove = __WEBPACK_IMPORTED_MODULE_4_lodash_throttle___default()(_this.triggeredAfterMouseMove, props.throttleDelay)), + _this; + } + return _inherits(CategoricalChartWrapper, _Component), _createClass(CategoricalChartWrapper, [ { + key: "componentDidMount", + value: function() { + __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(this.props.syncId) || this.addListener(); + } + }, { + key: "componentWillReceiveProps", + value: function(nextProps) { + var _props = this.props, data = _props.data, children = _props.children, width = _props.width, height = _props.height, layout = _props.layout, stackOffset = _props.stackOffset, margin = _props.margin, updateId = this.state.updateId; + if (nextProps.data === data && nextProps.width === width && nextProps.height === height && nextProps.layout === layout && nextProps.stackOffset === stackOffset && Object(__WEBPACK_IMPORTED_MODULE_25__util_PureRender__.b)(nextProps.margin, margin)) { + if (!Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.m)(nextProps.children, children)) { + var hasGlobalData = !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(nextProps.data), newUpdateId = hasGlobalData ? updateId : updateId + 1, _state = this.state, dataStartIndex = _state.dataStartIndex, dataEndIndex = _state.dataEndIndex, _defaultState = _extends({}, this.constructor.createDefaultState(nextProps), { + dataEndIndex: dataEndIndex, + dataStartIndex: dataStartIndex + }); + this.setState(_extends({}, _defaultState, { + updateId: newUpdateId + }, this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({ + props: nextProps + }, _defaultState, { + updateId: newUpdateId + })))); + } + } else { + var defaultState = this.constructor.createDefaultState(nextProps); + this.setState(_extends({}, defaultState, { + updateId: updateId + 1 + }, this.updateStateOfAxisMapsOffsetAndStackGroups(_extends({ + props: nextProps + }, defaultState, { + updateId: updateId + 1 + })))); + } + __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(this.props.syncId) && !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(nextProps.syncId) && this.addListener(), + !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(this.props.syncId) && __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(nextProps.syncId) && this.removeListener(); + } + }, { + key: "componentWillUnmount", + value: function() { + __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(this.props.syncId) || this.removeListener(), + "function" == typeof this.triggeredAfterMouseMove.cancel && this.triggeredAfterMouseMove.cancel(); + } + }, { + key: "getAxisMap", + value: function(props, _ref2) { + var _ref2$axisType = _ref2.axisType, axisType = void 0 === _ref2$axisType ? "xAxis" : _ref2$axisType, AxisComp = _ref2.AxisComp, graphicalItems = _ref2.graphicalItems, stackGroups = _ref2.stackGroups, dataStartIndex = _ref2.dataStartIndex, dataEndIndex = _ref2.dataEndIndex, children = props.children, axisIdKey = axisType + "Id", axes = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.h)(children, AxisComp), axisMap = {}; + return axes && axes.length ? axisMap = this.getAxisMapByAxes(props, { + axes: axes, + graphicalItems: graphicalItems, + axisType: axisType, + axisIdKey: axisIdKey, + stackGroups: stackGroups, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + }) : graphicalItems && graphicalItems.length && (axisMap = this.getAxisMapByItems(props, { + Axis: AxisComp, + graphicalItems: graphicalItems, + axisType: axisType, + axisIdKey: axisIdKey, + stackGroups: stackGroups, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + })), axisMap; + } + }, { + key: "getAxisMapByAxes", + value: function(props, _ref3) { + var _this2 = this, axes = _ref3.axes, graphicalItems = _ref3.graphicalItems, axisType = _ref3.axisType, axisIdKey = _ref3.axisIdKey, stackGroups = _ref3.stackGroups, dataStartIndex = _ref3.dataStartIndex, dataEndIndex = _ref3.dataEndIndex, layout = props.layout, children = props.children, stackOffset = props.stackOffset, isCategorial = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.x)(layout, axisType); + return axes.reduce(function(result, child) { + var _child$props = child.props, type = _child$props.type, dataKey = _child$props.dataKey, allowDataOverflow = _child$props.allowDataOverflow, allowDuplicatedCategory = _child$props.allowDuplicatedCategory, scale = _child$props.scale, ticks = _child$props.ticks, axisId = child.props[axisIdKey], displayedData = _this2.constructor.getDisplayedData(props, { + graphicalItems: graphicalItems.filter(function(item) { + return item.props[axisIdKey] === axisId; + }), + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + }), len = displayedData.length; + if (!result[axisId]) { + var domain = void 0, duplicateDomain = void 0, categoricalDomain = void 0; + if (dataKey) { + if (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.n)(displayedData, dataKey, type), + "category" === type && isCategorial) { + var duplicate = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.d)(domain); + allowDuplicatedCategory && duplicate ? (duplicateDomain = domain, domain = __WEBPACK_IMPORTED_MODULE_3_lodash_range___default()(0, len)) : allowDuplicatedCategory || (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.y)(child.props.domain, domain, child).reduce(function(finalDomain, entry) { + return finalDomain.indexOf(entry) >= 0 ? finalDomain : [].concat(_toConsumableArray(finalDomain), [ entry ]); + }, [])); + } else if ("category" === type) domain = allowDuplicatedCategory ? domain.filter(function(entry) { + return "" !== entry && !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(entry); + }) : Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.y)(child.props.domain, domain, child).reduce(function(finalDomain, entry) { + return finalDomain.indexOf(entry) >= 0 || "" === entry || __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(entry) ? finalDomain : [].concat(_toConsumableArray(finalDomain), [ entry ]); + }, []); else if ("number" === type) { + var errorBarsDomain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.z)(displayedData, graphicalItems.filter(function(item) { + return item.props[axisIdKey] === axisId && !item.props.hide; + }), dataKey, axisType); + errorBarsDomain && (domain = errorBarsDomain); + } + !isCategorial || "number" !== type && "auto" === scale || (categoricalDomain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.n)(displayedData, dataKey, "category")); + } else domain = isCategorial ? __WEBPACK_IMPORTED_MODULE_3_lodash_range___default()(0, len) : stackGroups && stackGroups[axisId] && stackGroups[axisId].hasStack && "number" === type ? "expand" === stackOffset ? [ 0, 1 ] : Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.p)(stackGroups[axisId].stackGroups, dataStartIndex, dataEndIndex) : Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.o)(displayedData, graphicalItems.filter(function(item) { + return item.props[axisIdKey] === axisId && !item.props.hide; + }), type, !0); + return "number" === type && (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.e)(children, domain, axisId, axisType, ticks), + child.props.domain && (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.B)(child.props.domain, domain, allowDataOverflow))), + _extends({}, result, _defineProperty({}, axisId, _extends({}, child.props, { + axisType: axisType, + domain: domain, + categoricalDomain: categoricalDomain, + duplicateDomain: duplicateDomain, + originalDomain: child.props.domain, + isCategorial: isCategorial, + layout: layout + }))); + } + return result; + }, {}); + } + }, { + key: "getAxisMapByItems", + value: function(props, _ref4) { + var graphicalItems = _ref4.graphicalItems, Axis = _ref4.Axis, axisType = _ref4.axisType, axisIdKey = _ref4.axisIdKey, stackGroups = _ref4.stackGroups, dataStartIndex = _ref4.dataStartIndex, dataEndIndex = _ref4.dataEndIndex, layout = props.layout, children = props.children, displayedData = this.constructor.getDisplayedData(props, { + graphicalItems: graphicalItems, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + }), len = displayedData.length, isCategorial = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.x)(layout, axisType), index = -1; + return graphicalItems.reduce(function(result, child) { + var axisId = child.props[axisIdKey]; + if (!result[axisId]) { + index++; + var domain = void 0; + return isCategorial ? domain = __WEBPACK_IMPORTED_MODULE_3_lodash_range___default()(0, len) : stackGroups && stackGroups[axisId] && stackGroups[axisId].hasStack ? (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.p)(stackGroups[axisId].stackGroups, dataStartIndex, dataEndIndex), + domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.e)(children, domain, axisId, axisType)) : (domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.B)(Axis.defaultProps.domain, Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.o)(displayedData, graphicalItems.filter(function(item) { + return item.props[axisIdKey] === axisId && !item.props.hide; + }), "number"), Axis.defaultProps.allowDataOverflow), domain = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.e)(children, domain, axisId, axisType)), + _extends({}, result, _defineProperty({}, axisId, _extends({ + axisType: axisType + }, Axis.defaultProps, { + hide: !0, + orientation: ORIENT_MAP[axisType] && ORIENT_MAP[axisType][index % 2], + domain: domain, + originalDomain: Axis.defaultProps.domain, + isCategorial: isCategorial, + layout: layout + }))); + } + return result; + }, {}); + } + }, { + key: "getActiveCoordinate", + value: function(tooltipTicks, activeIndex, rangeObj) { + var layout = this.props.layout, entry = __WEBPACK_IMPORTED_MODULE_2_lodash_get___default()(tooltipTicks.filter(function(tick) { + return tick && tick.index === activeIndex; + }), "[0]"); + if (entry) { + if ("horizontal" === layout) return { + x: entry.coordinate, + y: rangeObj.y + }; + if ("vertical" === layout) return { + x: rangeObj.x, + y: entry.coordinate + }; + if ("centric" === layout) { + var _angle = entry.coordinate, _radius = rangeObj.radius; + return _extends({}, rangeObj, Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(rangeObj.cx, rangeObj.cy, _radius, _angle), { + angle: _angle, + radius: _radius + }); + } + var radius = entry.coordinate, angle = rangeObj.angle; + return _extends({}, rangeObj, Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(rangeObj.cx, rangeObj.cy, radius, angle), { + angle: angle, + radius: radius + }); + } + return originCoordinate; + } + }, { + key: "getMouseInfo", + value: function(event) { + if (!this.container) return null; + var containerOffset = Object(__WEBPACK_IMPORTED_MODULE_21__util_DOMUtils__.b)(this.container), e = Object(__WEBPACK_IMPORTED_MODULE_21__util_DOMUtils__.a)(event, containerOffset), rangeObj = this.inRange(e.chartX, e.chartY); + if (!rangeObj) return null; + var _state2 = this.state, xAxisMap = _state2.xAxisMap, yAxisMap = _state2.yAxisMap; + if ("axis" !== eventType && xAxisMap && yAxisMap) { + var xScale = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(xAxisMap).scale, yScale = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(yAxisMap).scale, xValue = xScale && xScale.invert ? xScale.invert(e.chartX) : null, yValue = yScale && yScale.invert ? yScale.invert(e.chartY) : null; + return _extends({}, e, { + xValue: xValue, + yValue: yValue + }); + } + var _state3 = this.state, ticks = _state3.orderedTooltipTicks, axis = _state3.tooltipAxis, tooltipTicks = _state3.tooltipTicks, pos = this.calculateTooltipPos(rangeObj), activeIndex = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.b)(pos, ticks, tooltipTicks, axis); + if (activeIndex >= 0 && tooltipTicks) { + var activeLabel = tooltipTicks[activeIndex] && tooltipTicks[activeIndex].value, activePayload = this.getTooltipContent(activeIndex, activeLabel), activeCoordinate = this.getActiveCoordinate(ticks, activeIndex, rangeObj); + return _extends({}, e, { + activeTooltipIndex: activeIndex, + activeLabel: activeLabel, + activePayload: activePayload, + activeCoordinate: activeCoordinate + }); + } + return null; + } + }, { + key: "getTooltipContent", + value: function(activeIndex, activeLabel) { + var _state4 = this.state, graphicalItems = _state4.graphicalItems, tooltipAxis = _state4.tooltipAxis, displayedData = this.constructor.getDisplayedData(this.props, this.state); + return activeIndex < 0 || !graphicalItems || !graphicalItems.length || activeIndex >= displayedData.length ? null : graphicalItems.reduce(function(result, child) { + if (child.props.hide) return result; + var _child$props2 = child.props, dataKey = _child$props2.dataKey, name = _child$props2.name, unit = _child$props2.unit, formatter = _child$props2.formatter, data = _child$props2.data, payload = void 0; + return payload = tooltipAxis.dataKey && !tooltipAxis.allowDuplicatedCategory ? Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.a)(data || displayedData, tooltipAxis.dataKey, activeLabel) : displayedData[activeIndex], + payload ? [].concat(_toConsumableArray(result), [ _extends({}, Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.k)(child), { + dataKey: dataKey, + unit: unit, + formatter: formatter, + name: name || dataKey, + color: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.r)(child), + value: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.w)(payload, dataKey), + payload: payload + }) ]) : result; + }, []); + } + }, { + key: "getFormatItems", + value: function(props, currentState) { + var _this3 = this, graphicalItems = currentState.graphicalItems, stackGroups = currentState.stackGroups, offset = currentState.offset, updateId = currentState.updateId, dataStartIndex = currentState.dataStartIndex, dataEndIndex = currentState.dataEndIndex, barSize = props.barSize, layout = props.layout, barGap = props.barGap, barCategoryGap = props.barCategoryGap, globalMaxBarSize = props.maxBarSize, _getAxisNameByLayout = this.getAxisNameByLayout(layout), numericAxisName = _getAxisNameByLayout.numericAxisName, cateAxisName = _getAxisNameByLayout.cateAxisName, hasBar = this.constructor.hasBar(graphicalItems), sizeList = hasBar && Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.i)({ + barSize: barSize, + stackGroups: stackGroups + }), formatedItems = []; + return graphicalItems.forEach(function(item, index) { + var displayedData = _this3.constructor.getDisplayedData(props, { + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + }, item), _item$props = item.props, dataKey = _item$props.dataKey, childMaxBarSize = _item$props.maxBarSize, numericAxisId = item.props[numericAxisName + "Id"], cateAxisId = item.props[cateAxisName + "Id"], axisObj = axisComponents.reduce(function(result, entry) { + var _extends4, axisMap = currentState[entry.axisType + "Map"], id = item.props[entry.axisType + "Id"], axis = axisMap && axisMap[id]; + return _extends({}, result, (_extends4 = {}, _defineProperty(_extends4, entry.axisType, axis), + _defineProperty(_extends4, entry.axisType + "Ticks", Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(axis)), + _extends4)); + }, {}), cateAxis = axisObj[cateAxisName], cateTicks = axisObj[cateAxisName + "Ticks"], stackedData = stackGroups && stackGroups[numericAxisId] && stackGroups[numericAxisId].hasStack && Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.t)(item, stackGroups[numericAxisId].stackGroups), bandSize = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.g)(cateAxis, cateTicks), maxBarSize = __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(childMaxBarSize) ? globalMaxBarSize : childMaxBarSize, barPosition = hasBar && Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.h)({ + barGap: barGap, + barCategoryGap: barCategoryGap, + bandSize: bandSize, + sizeList: sizeList[cateAxisId], + maxBarSize: maxBarSize + }), componsedFn = item && item.type && item.type.getComposedData; + if (componsedFn) { + var _extends5; + formatedItems.push({ + props: _extends({}, componsedFn(_extends({}, axisObj, { + displayedData: displayedData, + props: props, + dataKey: dataKey, + item: item, + bandSize: bandSize, + barPosition: barPosition, + offset: offset, + stackedData: stackedData, + layout: layout, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex, + onItemMouseLeave: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.d)(_this3.handleItemMouseLeave, null, item.props.onMouseLeave), + onItemMouseEnter: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.d)(_this3.handleItemMouseEnter, null, item.props.onMouseEnter) + })), (_extends5 = { + key: item.key || "item-" + index + }, _defineProperty(_extends5, numericAxisName, axisObj[numericAxisName]), _defineProperty(_extends5, cateAxisName, axisObj[cateAxisName]), + _defineProperty(_extends5, "animationId", updateId), _extends5)), + childIndex: Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.o)(item, props.children), + item: item + }); + } + }), formatedItems; + } + }, { + key: "getCursorRectangle", + value: function() { + var layout = this.props.layout, _state5 = this.state, activeCoordinate = _state5.activeCoordinate, offset = _state5.offset, tooltipAxisBandSize = _state5.tooltipAxisBandSize, halfSize = tooltipAxisBandSize / 2; + return { + stroke: "none", + fill: "#ccc", + x: "horizontal" === layout ? activeCoordinate.x - halfSize : offset.left + .5, + y: "horizontal" === layout ? offset.top + .5 : activeCoordinate.y - halfSize, + width: "horizontal" === layout ? tooltipAxisBandSize : offset.width - 1, + height: "horizontal" === layout ? offset.height - 1 : tooltipAxisBandSize + }; + } + }, { + key: "getCursorPoints", + value: function() { + var layout = this.props.layout, _state6 = this.state, activeCoordinate = _state6.activeCoordinate, offset = _state6.offset, x1 = void 0, y1 = void 0, x2 = void 0, y2 = void 0; + if ("horizontal" === layout) x1 = activeCoordinate.x, x2 = x1, y1 = offset.top, + y2 = offset.top + offset.height; else if ("vertical" === layout) y1 = activeCoordinate.y, + y2 = y1, x1 = offset.left, x2 = offset.left + offset.width; else if (!__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(activeCoordinate.cx) || !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(activeCoordinate.cy)) { + if ("centric" !== layout) { + var _cx = activeCoordinate.cx, _cy = activeCoordinate.cy, radius = activeCoordinate.radius, startAngle = activeCoordinate.startAngle, endAngle = activeCoordinate.endAngle, startPoint = Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(_cx, _cy, radius, startAngle), endPoint = Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(_cx, _cy, radius, endAngle); + return { + points: [ startPoint, endPoint ], + cx: _cx, + cy: _cy, + radius: radius, + startAngle: startAngle, + endAngle: endAngle + }; + } + var cx = activeCoordinate.cx, cy = activeCoordinate.cy, innerRadius = activeCoordinate.innerRadius, outerRadius = activeCoordinate.outerRadius, angle = activeCoordinate.angle, innerPoint = Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(cx, cy, innerRadius, angle), outerPoint = Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.e)(cx, cy, outerRadius, angle); + x1 = innerPoint.x, y1 = innerPoint.y, x2 = outerPoint.x, y2 = outerPoint.y; + } + return [ { + x: x1, + y: y1 + }, { + x: x2, + y: y2 + } ]; + } + }, { + key: "getAxisNameByLayout", + value: function(layout) { + return "horizontal" === layout ? { + numericAxisName: "yAxis", + cateAxisName: "xAxis" + } : "vertical" === layout ? { + numericAxisName: "xAxis", + cateAxisName: "yAxis" + } : "centric" === layout ? { + numericAxisName: "radiusAxis", + cateAxisName: "angleAxis" + } : { + numericAxisName: "angleAxis", + cateAxisName: "radiusAxis" + }; + } + }, { + key: "calculateTooltipPos", + value: function(rangeObj) { + var layout = this.props.layout; + return "horizontal" === layout ? rangeObj.x : "vertical" === layout ? rangeObj.y : "centric" === layout ? rangeObj.angle : rangeObj.radius; + } + }, { + key: "inRange", + value: function(x, y) { + var layout = this.props.layout; + if ("horizontal" === layout || "vertical" === layout) { + var offset = this.state.offset; + return x >= offset.left && x <= offset.left + offset.width && y >= offset.top && y <= offset.top + offset.height ? { + x: x, + y: y + } : null; + } + var _state7 = this.state, angleAxisMap = _state7.angleAxisMap, radiusAxisMap = _state7.radiusAxisMap; + if (angleAxisMap && radiusAxisMap) { + var angleAxis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(angleAxisMap); + return Object(__WEBPACK_IMPORTED_MODULE_24__util_PolarUtils__.d)({ + x: x, + y: y + }, angleAxis); + } + return null; + } + }, { + key: "parseEventsOfWrapper", + value: function() { + var children = this.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_11__component_Tooltip__.a), tooltipEvents = tooltipItem && "axis" === eventType ? { + onMouseEnter: this.handleMouseEnter, + onMouseMove: this.handleMouseMove, + onMouseLeave: this.handleMouseLeave, + onTouchMove: this.handleTouchMove + } : {}, outerEvents = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.e)(this.props, this.handleOuterEvent); + return _extends({}, outerEvents, tooltipEvents); + } + }, { + key: "updateStateOfAxisMapsOffsetAndStackGroups", + value: function(_ref5) { + var _this4 = this, props = _ref5.props, dataStartIndex = _ref5.dataStartIndex, dataEndIndex = _ref5.dataEndIndex, updateId = _ref5.updateId; + if (!Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.q)({ + props: props + })) return null; + var children = props.children, layout = props.layout, stackOffset = props.stackOffset, data = props.data, reverseStackOrder = props.reverseStackOrder, _getAxisNameByLayout2 = this.getAxisNameByLayout(layout), numericAxisName = _getAxisNameByLayout2.numericAxisName, cateAxisName = _getAxisNameByLayout2.cateAxisName, graphicalItems = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.h)(children, GraphicalChild), stackGroups = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.s)(data, graphicalItems, numericAxisName + "Id", cateAxisName + "Id", stackOffset, reverseStackOrder), axisObj = axisComponents.reduce(function(result, entry) { + var name = entry.axisType + "Map"; + return _extends({}, result, _defineProperty({}, name, _this4.getAxisMap(props, _extends({}, entry, { + graphicalItems: graphicalItems, + stackGroups: entry.axisType === numericAxisName && stackGroups, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + })))); + }, {}), offset = this.calculateOffset(_extends({}, axisObj, { + props: props, + graphicalItems: graphicalItems + })); + Object.keys(axisObj).forEach(function(key) { + axisObj[key] = formatAxisMap(props, axisObj[key], offset, key.replace("Map", ""), chartName); + }); + var cateAxisMap = axisObj[cateAxisName + "Map"], ticksObj = this.tooltipTicksGenerator(cateAxisMap), formatedGraphicalItems = this.getFormatItems(props, _extends({}, axisObj, { + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex, + updateId: updateId, + graphicalItems: graphicalItems, + stackGroups: stackGroups, + offset: offset + })); + return _extends({ + formatedGraphicalItems: formatedGraphicalItems, + graphicalItems: graphicalItems, + offset: offset, + stackGroups: stackGroups + }, ticksObj, axisObj); + } + }, { + key: "addListener", + value: function() { + __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.on(__WEBPACK_IMPORTED_MODULE_26__util_Events__.a, this.handleReceiveSyncEvent), + __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.setMaxListeners && __WEBPACK_IMPORTED_MODULE_26__util_Events__.b._maxListeners && __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.setMaxListeners(__WEBPACK_IMPORTED_MODULE_26__util_Events__.b._maxListeners + 1); + } + }, { + key: "removeListener", + value: function() { + __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.removeListener(__WEBPACK_IMPORTED_MODULE_26__util_Events__.a, this.handleReceiveSyncEvent), + __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.setMaxListeners && __WEBPACK_IMPORTED_MODULE_26__util_Events__.b._maxListeners && __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.setMaxListeners(__WEBPACK_IMPORTED_MODULE_26__util_Events__.b._maxListeners - 1); + } + }, { + key: "calculateOffset", + value: function(_ref6) { + var props = _ref6.props, graphicalItems = _ref6.graphicalItems, _ref6$xAxisMap = _ref6.xAxisMap, xAxisMap = void 0 === _ref6$xAxisMap ? {} : _ref6$xAxisMap, _ref6$yAxisMap = _ref6.yAxisMap, yAxisMap = void 0 === _ref6$yAxisMap ? {} : _ref6$yAxisMap, width = props.width, height = props.height, children = props.children, margin = props.margin || {}, brushItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_20__cartesian_Brush__.a), legendItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_12__component_Legend__.a), offsetH = Object.keys(yAxisMap).reduce(function(result, id) { + var entry = yAxisMap[id], orientation = entry.orientation; + return entry.mirror || entry.hide ? result : _extends({}, result, _defineProperty({}, orientation, result[orientation] + entry.width)); + }, { + left: margin.left || 0, + right: margin.right || 0 + }), offsetV = Object.keys(xAxisMap).reduce(function(result, id) { + var entry = xAxisMap[id], orientation = entry.orientation; + return entry.mirror || entry.hide ? result : _extends({}, result, _defineProperty({}, orientation, result[orientation] + entry.height)); + }, { + top: margin.top || 0, + bottom: margin.bottom || 0 + }), offset = _extends({}, offsetV, offsetH), brushBottom = offset.bottom; + if (brushItem && (offset.bottom += brushItem.props.height || __WEBPACK_IMPORTED_MODULE_20__cartesian_Brush__.a.defaultProps.height), + legendItem && this.legendInstance) { + var legendBox = this.legendInstance.getBBox(); + offset = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.a)(offset, graphicalItems, props, legendBox); + } + return _extends({ + brushBottom: brushBottom + }, offset, { + width: width - offset.left - offset.right, + height: height - offset.top - offset.bottom + }); + } + }, { + key: "triggerSyncEvent", + value: function(data) { + var syncId = this.props.syncId; + __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(syncId) || __WEBPACK_IMPORTED_MODULE_26__util_Events__.b.emit(__WEBPACK_IMPORTED_MODULE_26__util_Events__.a, syncId, this.uniqueChartId, data); + } + }, { + key: "filterFormatItem", + value: function(item, displayName, childIndex) { + for (var formatedGraphicalItems = this.state.formatedGraphicalItems, i = 0, len = formatedGraphicalItems.length; i < len; i++) { + var entry = formatedGraphicalItems[i]; + if (entry.item === item || entry.props.key === item.key || displayName === Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.j)(entry.item.type) && childIndex === entry.childIndex) return entry; + } + return null; + } + }, { + key: "renderAxis", + value: function(axisOptions, element, displayName, index) { + var _props2 = this.props, width = _props2.width, height = _props2.height; + return __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__.a, _extends({}, axisOptions, { + className: "recharts-" + axisOptions.axisType + " " + axisOptions.axisType, + key: element.key || displayName + "-" + index, + viewBox: { + x: 0, + y: 0, + width: width, + height: height + }, + ticksGenerator: this.axesTicksGenerator + })); + } + }, { + key: "renderLegend", + value: function() { + var _this5 = this, formatedGraphicalItems = this.state.formatedGraphicalItems, _props3 = this.props, children = _props3.children, width = _props3.width, height = _props3.height, margin = this.props.margin || {}, legendWidth = width - (margin.left || 0) - (margin.right || 0), legendHeight = height - (margin.top || 0) - (margin.bottom || 0), props = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.q)({ + children: children, + formatedGraphicalItems: formatedGraphicalItems, + legendWidth: legendWidth, + legendHeight: legendHeight, + legendContent: legendContent + }); + if (!props) return null; + var item = props.item, otherProps = _objectWithoutProperties(props, [ "item" ]); + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(item, _extends({}, otherProps, { + chartWidth: width, + chartHeight: height, + margin: margin, + ref: function(legend) { + _this5.legendInstance = legend; + }, + onBBoxUpdate: this.handleLegendBBoxUpdate + })); + } + }, { + key: "renderTooltip", + value: function() { + var children = this.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_11__component_Tooltip__.a); + if (!tooltipItem) return null; + var _state8 = this.state, isTooltipActive = _state8.isTooltipActive, activeCoordinate = _state8.activeCoordinate, activePayload = _state8.activePayload, activeLabel = _state8.activeLabel, offset = _state8.offset; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(tooltipItem, { + viewBox: _extends({}, offset, { + x: offset.left, + y: offset.top + }), + active: isTooltipActive, + label: activeLabel, + payload: isTooltipActive ? activePayload : [], + coordinate: activeCoordinate + }); + } + }, { + key: "renderActiveDot", + value: function(option, props) { + var dot = void 0; + return dot = Object(__WEBPACK_IMPORTED_MODULE_6_react__.isValidElement)(option) ? Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(option, props) : __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(option) ? option(props) : __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_16__shape_Dot__.a, props), + __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_10__container_Layer__.a, { + className: "recharts-active-dot", + key: props.key + }, dot); + } + }, { + key: "renderActivePoints", + value: function(_ref7) { + var item = _ref7.item, activePoint = _ref7.activePoint, basePoint = _ref7.basePoint, childIndex = _ref7.childIndex, isRange = _ref7.isRange, result = [], key = item.props.key, _item$item$props = item.item.props, activeDot = _item$item$props.activeDot, dataKey = _item$item$props.dataKey, dotProps = _extends({ + index: childIndex, + dataKey: dataKey, + cx: activePoint.x, + cy: activePoint.y, + r: 4, + fill: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.r)(item.item), + strokeWidth: 2, + stroke: "#fff", + payload: activePoint.payload, + value: activePoint.value, + key: key + "-activePoint-" + childIndex + }, Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.k)(activeDot), Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.e)(activeDot)); + return result.push(this.renderActiveDot(activeDot, dotProps, childIndex)), basePoint ? result.push(this.renderActiveDot(activeDot, _extends({}, dotProps, { + cx: basePoint.x, + cy: basePoint.y, + key: key + "-basePoint-" + childIndex + }), childIndex)) : isRange && result.push(null), result; + } + }, { + key: "render", + value: function() { + var _this6 = this; + if (!Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.q)(this)) return null; + var _props4 = this.props, children = _props4.children, className = _props4.className, width = _props4.width, height = _props4.height, style = _props4.style, compact = _props4.compact, others = _objectWithoutProperties(_props4, [ "children", "className", "width", "height", "style", "compact" ]), attrs = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.k)(others), map = { + CartesianGrid: { + handler: this.renderGrid, + once: !0 + }, + ReferenceArea: { + handler: this.renderReferenceElement + }, + ReferenceLine: { + handler: this.renderReferenceElement + }, + ReferenceDot: { + handler: this.renderReferenceElement + }, + XAxis: { + handler: this.renderXAxis + }, + YAxis: { + handler: this.renderYAxis + }, + Brush: { + handler: this.renderBrush, + once: !0 + }, + Bar: { + handler: this.renderGraphicChild + }, + Line: { + handler: this.renderGraphicChild + }, + Area: { + handler: this.renderGraphicChild + }, + Radar: { + handler: this.renderGraphicChild + }, + RadialBar: { + handler: this.renderGraphicChild + }, + Scatter: { + handler: this.renderGraphicChild + }, + Pie: { + handler: this.renderGraphicChild + }, + Tooltip: { + handler: this.renderCursor, + once: !0 + }, + PolarGrid: { + handler: this.renderPolarGrid, + once: !0 + }, + PolarAngleAxis: { + handler: this.renderPolarAxis + }, + PolarRadiusAxis: { + handler: this.renderPolarAxis + } + }; + if (compact) return __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__container_Surface__.a, _extends({}, attrs, { + width: width, + height: height + }), Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.p)(children, map)); + var events = this.parseEventsOfWrapper(); + return __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement("div", _extends({ + className: __WEBPACK_IMPORTED_MODULE_8_classnames___default()("recharts-wrapper", className), + style: _extends({}, style, { + position: "relative", + cursor: "default", + width: width, + height: height + }) + }, events, { + ref: function(node) { + _this6.container = node; + } + }), __WEBPACK_IMPORTED_MODULE_6_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_9__container_Surface__.a, _extends({}, attrs, { + width: width, + height: height + }), Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.p)(children, map)), this.renderLegend(), this.renderTooltip()); + } + } ]), CategoricalChartWrapper; + }(__WEBPACK_IMPORTED_MODULE_6_react__.Component), _class.displayName = chartName, + _class.propTypes = _extends({ + syncId: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number ]), + compact: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool, + width: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + data: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object), + layout: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOf([ "horizontal", "vertical" ]), + stackOffset: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOf([ "sign", "expand", "none", "wiggle", "silhouette" ]), + throttleDelay: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + margin: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.shape({ + top: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + right: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + bottom: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + left: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number + }), + barCategoryGap: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string ]), + barGap: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string ]), + barSize: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string ]), + maxBarSize: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.number, + style: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.object, + className: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string, + children: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.node ]), + onClick: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + onMouseLeave: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + onMouseEnter: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + onMouseMove: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + onMouseDown: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + onMouseUp: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.func, + reverseStackOrder: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.bool, + id: __WEBPACK_IMPORTED_MODULE_7_prop_types___default.a.string + }, propTypes), _class.defaultProps = _extends({ + layout: "horizontal", + stackOffset: "none", + barCategoryGap: "10%", + barGap: 4, + margin: { + top: 5, + right: 5, + bottom: 5, + left: 5 + }, + reverseStackOrder: !1 + }, defaultProps), _class.createDefaultState = function(props) { + var children = props.children, brushItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_20__cartesian_Brush__.a); + return { + chartX: 0, + chartY: 0, + dataStartIndex: brushItem && brushItem.props && brushItem.props.startIndex || 0, + dataEndIndex: brushItem && brushItem.props && brushItem.props.endIndex || props.data && props.data.length - 1 || 0, + activeTooltipIndex: -1, + isTooltipActive: !1 + }; + }, _class.hasBar = function(graphicalItems) { + return !(!graphicalItems || !graphicalItems.length) && graphicalItems.some(function(item) { + var name = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.j)(item && item.type); + return name && name.indexOf("Bar") >= 0; + }); + }, _class.getDisplayedData = function(props, _ref8, item) { + var graphicalItems = _ref8.graphicalItems, dataStartIndex = _ref8.dataStartIndex, dataEndIndex = _ref8.dataEndIndex, itemsData = (graphicalItems || []).reduce(function(result, child) { + var itemData = child.props.data; + return itemData && itemData.length ? [].concat(_toConsumableArray(result), _toConsumableArray(itemData)) : result; + }, []); + if (itemsData && itemsData.length > 0) return itemsData; + if (item && item.props && item.props.data && item.props.data.length > 0) return item.props.data; + var data = props.data; + return data && data.length && Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(dataStartIndex) && Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(dataEndIndex) ? data.slice(dataStartIndex, dataEndIndex + 1) : []; + }, _initialiseProps = function() { + var _this7 = this; + this.handleLegendBBoxUpdate = function(box) { + if (box && _this7.legendInstance) { + var _state9 = _this7.state, dataStartIndex = _state9.dataStartIndex, dataEndIndex = _state9.dataEndIndex, updateId = _state9.updateId; + _this7.setState(_this7.updateStateOfAxisMapsOffsetAndStackGroups({ + props: _this7.props, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex, + updateId: updateId + })); + } + }, this.handleReceiveSyncEvent = function(cId, chartId, data) { + var _props5 = _this7.props, syncId = _props5.syncId, layout = _props5.layout, updateId = _this7.state.updateId; + if (syncId === cId && chartId !== _this7.uniqueChartId) { + var dataStartIndex = data.dataStartIndex, dataEndIndex = data.dataEndIndex; + if (__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(data.dataStartIndex) && __WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(data.dataEndIndex)) if (__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(data.activeTooltipIndex)) _this7.setState(data); else { + var chartX = data.chartX, chartY = data.chartY, activeTooltipIndex = data.activeTooltipIndex, _state10 = _this7.state, offset = _state10.offset, tooltipTicks = _state10.tooltipTicks; + if (!offset) return; + var viewBox = _extends({}, offset, { + x: offset.left, + y: offset.top + }), validateChartX = Math.min(chartX, viewBox.x + viewBox.width), validateChartY = Math.min(chartY, viewBox.y + viewBox.height), activeLabel = tooltipTicks[activeTooltipIndex] && tooltipTicks[activeTooltipIndex].value, activePayload = _this7.getTooltipContent(activeTooltipIndex), activeCoordinate = tooltipTicks[activeTooltipIndex] ? { + x: "horizontal" === layout ? tooltipTicks[activeTooltipIndex].coordinate : validateChartX, + y: "horizontal" === layout ? validateChartY : tooltipTicks[activeTooltipIndex].coordinate + } : originCoordinate; + _this7.setState(_extends({}, data, { + activeLabel: activeLabel, + activeCoordinate: activeCoordinate, + activePayload: activePayload + })); + } else _this7.setState(_extends({ + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex + }, _this7.updateStateOfAxisMapsOffsetAndStackGroups({ + props: _this7.props, + dataStartIndex: dataStartIndex, + dataEndIndex: dataEndIndex, + updateId: updateId + }))); + } + }, this.handleBrushChange = function(_ref9) { + var startIndex = _ref9.startIndex, endIndex = _ref9.endIndex; + if (startIndex !== _this7.state.dataStartIndex || endIndex !== _this7.state.dataEndIndex) { + var updateId = _this7.state.updateId; + _this7.setState(_extends({ + dataStartIndex: startIndex, + dataEndIndex: endIndex + }, _this7.updateStateOfAxisMapsOffsetAndStackGroups({ + props: _this7.props, + dataStartIndex: startIndex, + dataEndIndex: endIndex, + updateId: updateId + }))), _this7.triggerSyncEvent({ + dataStartIndex: startIndex, + dataEndIndex: endIndex + }); + } + }, this.handleMouseEnter = function(e) { + var onMouseEnter = _this7.props.onMouseEnter, mouse = _this7.getMouseInfo(e); + if (mouse) { + var nextState = _extends({}, mouse, { + isTooltipActive: !0 + }); + _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseEnter) && onMouseEnter(nextState, e); + } + }, this.triggeredAfterMouseMove = function(e) { + var onMouseMove = _this7.props.onMouseMove, mouse = _this7.getMouseInfo(e), nextState = mouse ? _extends({}, mouse, { + isTooltipActive: !0 + }) : { + isTooltipActive: !1 + }; + _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseMove) && onMouseMove(nextState, e); + }, this.handleItemMouseEnter = function(el) { + _this7.setState({ + isTooltipActive: !0, + activeItem: el, + activePayload: el.tooltipPayload, + activeCoordinate: el.tooltipPosition || { + x: el.cx, + y: el.cy + } + }); + }, this.handleItemMouseLeave = function() { + _this7.setState({ + isTooltipActive: !1 + }); + }, this.handleMouseMove = function(e) { + e && __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(e.persist) && e.persist(), + _this7.triggeredAfterMouseMove(e); + }, this.handleMouseLeave = function(e) { + var onMouseLeave = _this7.props.onMouseLeave, nextState = { + isTooltipActive: !1 + }; + _this7.setState(nextState), _this7.triggerSyncEvent(nextState), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseLeave) && onMouseLeave(nextState, e); + }, this.handleOuterEvent = function(e) { + var eventName = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.l)(e); + if (eventName && __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(_this7.props[eventName])) { + var mouse = _this7.getMouseInfo(e); + (0, _this7.props[eventName])(mouse, e); + } + }, this.handleClick = function(e) { + var onClick = _this7.props.onClick; + if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onClick)) { + onClick(_this7.getMouseInfo(e), e); + } + }, this.handleMouseDown = function(e) { + var onMouseDown = _this7.props.onMouseDown; + if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseDown)) { + onMouseDown(_this7.getMouseInfo(e), e); + } + }, this.handleMouseUp = function(e) { + var onMouseUp = _this7.props.onMouseUp; + if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(onMouseUp)) { + onMouseUp(_this7.getMouseInfo(e), e); + } + }, this.handleTouchMove = function(e) { + null != e.changedTouches && e.changedTouches.length > 0 && _this7.handleMouseMove(e.changedTouches[0]); + }, this.verticalCoordinatesGenerator = function(_ref10) { + var xAxis = _ref10.xAxis, width = _ref10.width, height = _ref10.height, offset = _ref10.offset; + return Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.m)(__WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__.a.getTicks(_extends({}, __WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__.a.defaultProps, xAxis, { + ticks: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(xAxis, !0), + viewBox: { + x: 0, + y: 0, + width: width, + height: height + } + })), offset.left, offset.left + offset.width); + }, this.horizontalCoordinatesGenerator = function(_ref11) { + var yAxis = _ref11.yAxis, width = _ref11.width, height = _ref11.height, offset = _ref11.offset; + return Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.m)(__WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__.a.getTicks(_extends({}, __WEBPACK_IMPORTED_MODULE_19__cartesian_CartesianAxis__.a.defaultProps, yAxis, { + ticks: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(yAxis, !0), + viewBox: { + x: 0, + y: 0, + width: width, + height: height + } + })), offset.top, offset.top + offset.height); + }, this.axesTicksGenerator = function(axis) { + return Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(axis, !0); + }, this.tooltipTicksGenerator = function(axisMap) { + var axis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(axisMap), tooltipTicks = Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(axis, !1, !0); + return { + tooltipTicks: tooltipTicks, + orderedTooltipTicks: __WEBPACK_IMPORTED_MODULE_0_lodash_sortBy___default()(tooltipTicks, function(o) { + return o.coordinate; + }), + tooltipAxis: axis, + tooltipAxisBandSize: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.g)(axis) + }; + }, this.renderCursor = function(element) { + var _state11 = _this7.state, isTooltipActive = _state11.isTooltipActive, activeCoordinate = _state11.activeCoordinate, activePayload = _state11.activePayload, offset = _state11.offset; + if (!(element && element.props.cursor && isTooltipActive && activeCoordinate)) return null; + var layout = _this7.props.layout, restProps = void 0, cursorComp = __WEBPACK_IMPORTED_MODULE_13__shape_Curve__.a; + if ("ScatterChart" === chartName) restProps = activeCoordinate, cursorComp = __WEBPACK_IMPORTED_MODULE_14__shape_Cross__.a; else if ("BarChart" === chartName) restProps = _this7.getCursorRectangle(), + cursorComp = __WEBPACK_IMPORTED_MODULE_17__shape_Rectangle__.a; else if ("radial" === layout) { + var _getCursorPoints = _this7.getCursorPoints(), cx = _getCursorPoints.cx, cy = _getCursorPoints.cy, radius = _getCursorPoints.radius, startAngle = _getCursorPoints.startAngle, endAngle = _getCursorPoints.endAngle; + restProps = { + cx: cx, + cy: cy, + startAngle: startAngle, + endAngle: endAngle, + innerRadius: radius, + outerRadius: radius + }, cursorComp = __WEBPACK_IMPORTED_MODULE_15__shape_Sector__.a; + } else restProps = { + points: _this7.getCursorPoints() + }, cursorComp = __WEBPACK_IMPORTED_MODULE_13__shape_Curve__.a; + var key = element.key || "_recharts-cursor", cursorProps = _extends({ + stroke: "#ccc" + }, offset, restProps, Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.k)(element.props.cursor), { + payload: activePayload, + key: key, + className: "recharts-tooltip-cursor" + }); + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.isValidElement)(element.props.cursor) ? Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element.props.cursor, cursorProps) : Object(__WEBPACK_IMPORTED_MODULE_6_react__.createElement)(cursorComp, cursorProps); + }, this.renderPolarAxis = function(element, displayName, index) { + var axisType = element.type.axisType, axisMap = _this7.state[axisType + "Map"], axisOption = axisMap[element.props[axisType + "Id"]]; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, _extends({}, axisOption, { + className: axisType, + key: element.key || displayName + "-" + index, + ticks: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(axisOption, !0) + })); + }, this.renderXAxis = function(element, displayName, index) { + var xAxisMap = _this7.state.xAxisMap, axisObj = xAxisMap[element.props.xAxisId]; + return _this7.renderAxis(axisObj, element, displayName, index); + }, this.renderYAxis = function(element, displayName, index) { + var yAxisMap = _this7.state.yAxisMap, axisObj = yAxisMap[element.props.yAxisId]; + return _this7.renderAxis(axisObj, element, displayName, index); + }, this.renderGrid = function(element) { + var _state12 = _this7.state, xAxisMap = _state12.xAxisMap, yAxisMap = _state12.yAxisMap, offset = _state12.offset, _props6 = _this7.props, width = _props6.width, height = _props6.height, xAxis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(xAxisMap), yAxis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(yAxisMap), props = element.props || {}; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, { + key: element.key || "grid", + x: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(props.x) ? props.x : offset.left, + y: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(props.y) ? props.y : offset.top, + width: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(props.width) ? props.width : offset.width, + height: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(props.height) ? props.height : offset.height, + xAxis: xAxis, + yAxis: yAxis, + offset: offset, + chartWidth: width, + chartHeight: height, + verticalCoordinatesGenerator: _this7.verticalCoordinatesGenerator, + horizontalCoordinatesGenerator: _this7.horizontalCoordinatesGenerator + }); + }, this.renderPolarGrid = function(element) { + var _state13 = _this7.state, radiusAxisMap = _state13.radiusAxisMap, angleAxisMap = _state13.angleAxisMap, radiusAxis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(radiusAxisMap), angleAxis = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.b)(angleAxisMap), cx = angleAxis.cx, cy = angleAxis.cy, innerRadius = angleAxis.innerRadius, outerRadius = angleAxis.outerRadius; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, { + polarAngles: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(angleAxis, !0).map(function(entry) { + return entry.coordinate; + }), + polarRadius: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.u)(radiusAxis, !0).map(function(entry) { + return entry.coordinate; + }), + cx: cx, + cy: cy, + innerRadius: innerRadius, + outerRadius: outerRadius, + key: element.key || "polar-grid" + }); + }, this.renderBrush = function(element) { + var _props7 = _this7.props, margin = _props7.margin, data = _props7.data, _state14 = _this7.state, offset = _state14.offset, dataStartIndex = _state14.dataStartIndex, dataEndIndex = _state14.dataEndIndex, updateId = _state14.updateId; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, { + key: element.key || "_recharts-brush", + onChange: Object(__WEBPACK_IMPORTED_MODULE_23__util_ChartUtils__.d)(_this7.handleBrushChange, null, element.props.onChange), + data: data, + x: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(element.props.x) ? element.props.x : offset.left, + y: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(element.props.y) ? element.props.y : offset.top + offset.height + offset.brushBottom - (margin.bottom || 0), + width: Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.g)(element.props.width) ? element.props.width : offset.width, + startIndex: dataStartIndex, + endIndex: dataEndIndex, + updateId: "brush-" + updateId + }); + }, this.renderReferenceElement = function(element, displayName, index) { + if (!element) return null; + var _state15 = _this7.state, xAxisMap = _state15.xAxisMap, yAxisMap = _state15.yAxisMap, offset = _state15.offset, _element$props = element.props, xAxisId = _element$props.xAxisId, yAxisId = _element$props.yAxisId; + return Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, { + key: element.key || displayName + "-" + index, + xAxis: xAxisMap[xAxisId], + yAxis: yAxisMap[yAxisId], + viewBox: { + x: offset.left, + y: offset.top, + width: offset.width, + height: offset.height + } + }); + }, this.renderGraphicChild = function(element, displayName, index) { + var item = _this7.filterFormatItem(element, displayName, index); + if (!item) return null; + var graphicalItem = Object(__WEBPACK_IMPORTED_MODULE_6_react__.cloneElement)(element, item.props), _state16 = _this7.state, isTooltipActive = _state16.isTooltipActive, tooltipAxis = _state16.tooltipAxis, activeTooltipIndex = _state16.activeTooltipIndex, activeLabel = _state16.activeLabel, children = _this7.props.children, tooltipItem = Object(__WEBPACK_IMPORTED_MODULE_18__util_ReactUtils__.i)(children, __WEBPACK_IMPORTED_MODULE_11__component_Tooltip__.a), _item$props2 = item.props, points = _item$props2.points, isRange = _item$props2.isRange, baseLine = _item$props2.baseLine, _item$item$props2 = item.item.props, activeDot = _item$item$props2.activeDot; + if (!_item$item$props2.hide && isTooltipActive && tooltipItem && activeDot && activeTooltipIndex >= 0) { + var activePoint = void 0, basePoint = void 0; + if (tooltipAxis.dataKey && !tooltipAxis.allowDuplicatedCategory ? (activePoint = Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.a)(points, "payload." + tooltipAxis.dataKey, activeLabel), + basePoint = isRange && baseLine && Object(__WEBPACK_IMPORTED_MODULE_22__util_DataUtils__.a)(baseLine, "payload." + tooltipAxis.dataKey, activeLabel)) : (activePoint = points[activeTooltipIndex], + basePoint = isRange && baseLine && baseLine[activeTooltipIndex]), !__WEBPACK_IMPORTED_MODULE_5_lodash_isNil___default()(activePoint)) return [ graphicalItem ].concat(_toConsumableArray(_this7.renderActivePoints({ + item: item, + activePoint: activePoint, + basePoint: basePoint, + childIndex: activeTooltipIndex, + isRange: isRange + }))); + } + return isRange ? [ graphicalItem, null, null ] : [ graphicalItem, null ]; + }; + }, _temp; + }; + __webpack_exports__.a = generateCategoricalChart; +}, function(module, exports, __webpack_require__) { + var aFunction = __webpack_require__(269); + module.exports = function(fn, that, length) { + if (aFunction(fn), void 0 === that) return fn; + switch (length) { + case 1: + return function(a) { + return fn.call(that, a); + }; + + case 2: + return function(a, b) { + return fn.call(that, a, b); + }; + + case 3: + return function(a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function() { + return fn.apply(that, arguments); + }; + }; +}, function(module, exports, __webpack_require__) { + var isObject = __webpack_require__(50); + module.exports = function(it) { + if (!isObject(it)) throw TypeError(it + " is not an object!"); + return it; + }; +}, function(module, exports) { + module.exports = function(exec) { + try { + return !!exec(); + } catch (e) { + return !0; + } + }; +}, function(module, exports) { + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function(it, key) { + return hasOwnProperty.call(it, key); + }; +}, function(module, exports) { + var g; + g = function() { + return this; + }(); + try { + g = g || Function("return this")() || (0, eval)("this"); + } catch (e) { + "object" == typeof window && (g = window); + } + module.exports = g; +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + function capitalizeFirstLetter(string) { + return "production" !== process.env.NODE_ENV && (0, _warning2.default)("string" == typeof string, "Material-UI: capitalizeFirstLetter(string) expects a string argument."), + string.charAt(0).toUpperCase() + string.slice(1); + } + function contains(obj, pred) { + return (0, _keys2.default)(pred).every(function(key) { + return obj.hasOwnProperty(key) && obj[key] === pred[key]; + }); + } + function findIndex(arr, pred) { + for (var predType = void 0 === pred ? "undefined" : (0, _typeof3.default)(pred), i = 0; i < arr.length; i += 1) { + if ("function" === predType && !0 == !!pred(arr[i], i, arr)) return i; + if ("object" === predType && contains(arr[i], pred)) return i; + if (-1 !== [ "string", "number", "boolean" ].indexOf(predType)) return arr.indexOf(pred); + } + return -1; + } + function find(arr, pred) { + var index = findIndex(arr, pred); + return index > -1 ? arr[index] : void 0; + } + function createChainedFunction() { + for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) funcs[_key] = arguments[_key]; + return funcs.filter(function(func) { + return null != func; + }).reduce(function(acc, func) { + return "production" !== process.env.NODE_ENV && (0, _warning2.default)("function" == typeof func, "Material-UI: invalid Argument Type, must only provide functions, undefined, or null."), + function() { + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2]; + acc.apply(this, args), func.apply(this, args); + }; + }, function() {}); + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }); + var _typeof2 = __webpack_require__(126), _typeof3 = _interopRequireDefault(_typeof2), _keys = __webpack_require__(51), _keys2 = _interopRequireDefault(_keys); + exports.capitalizeFirstLetter = capitalizeFirstLetter, exports.contains = contains, + exports.findIndex = findIndex, exports.find = find, exports.createChainedFunction = createChainedFunction; + var _warning = __webpack_require__(14), _warning2 = _interopRequireDefault(_warning); + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : void 0; + } + var baseIsNative = __webpack_require__(869), getValue = __webpack_require__(872); + module.exports = getNative; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(x) { + return function() { + return x; + }; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _temp2, __WEBPACK_IMPORTED_MODULE_0_lodash_isNil__ = __webpack_require__(28), __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isNil__), __WEBPACK_IMPORTED_MODULE_1_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_react__), __WEBPACK_IMPORTED_MODULE_2_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_2_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_prop_types__), __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc__ = __webpack_require__(994), __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_reduce_css_calc__), __WEBPACK_IMPORTED_MODULE_4_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_4_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_4_classnames__), __WEBPACK_IMPORTED_MODULE_5__util_DataUtils__ = __webpack_require__(12), __WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__ = __webpack_require__(7), __WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__ = __webpack_require__(247), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), BREAKING_SPACES = /[ \f\n\r\t\v\u2028\u2029]+/, calculateWordWidths = function(props) { + try { + return { + wordsWithComputedWidth: (__WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(props.children) ? [] : props.children.toString().split(BREAKING_SPACES)).map(function(word) { + return { + word: word, + width: Object(__WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__.c)(word, props.style).width + }; + }), + spaceWidth: Object(__WEBPACK_IMPORTED_MODULE_7__util_DOMUtils__.c)(" ", props.style).width + }; + } catch (e) { + return null; + } + }, Text = (_temp2 = _class = function(_Component) { + function Text() { + var _ref, _temp, _this, _ret; + _classCallCheck(this, Text); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key]; + return _temp = _this = _possibleConstructorReturn(this, (_ref = Text.__proto__ || Object.getPrototypeOf(Text)).call.apply(_ref, [ this ].concat(args))), + _this.state = { + wordsByLines: [] + }, _ret = _temp, _possibleConstructorReturn(_this, _ret); + } + return _inherits(Text, _Component), _createClass(Text, [ { + key: "componentWillMount", + value: function() { + this.updateWordsByLines(this.props, !0); + } + }, { + key: "componentWillReceiveProps", + value: function(nextProps) { + var needCalculate = this.props.children !== nextProps.children || this.props.style !== nextProps.style; + this.updateWordsByLines(nextProps, needCalculate); + } + }, { + key: "updateWordsByLines", + value: function(props, needCalculate) { + if (!props.width && !props.scaleToFit || Object(__WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.n)()) this.updateWordsWithoutCalculate(props); else { + if (needCalculate) { + var wordWidths = calculateWordWidths(props); + if (!wordWidths) return void this.updateWordsWithoutCalculate(props); + var wordsWithComputedWidth = wordWidths.wordsWithComputedWidth, spaceWidth = wordWidths.spaceWidth; + this.wordsWithComputedWidth = wordsWithComputedWidth, this.spaceWidth = spaceWidth; + } + var wordsByLines = this.calculateWordsByLines(this.wordsWithComputedWidth, this.spaceWidth, props.width); + this.setState({ + wordsByLines: wordsByLines + }); + } + } + }, { + key: "updateWordsWithoutCalculate", + value: function(props) { + var words = __WEBPACK_IMPORTED_MODULE_0_lodash_isNil___default()(props.children) ? [] : props.children.toString().split(BREAKING_SPACES); + this.setState({ + wordsByLines: [ { + words: words + } ] + }); + } + }, { + key: "calculateWordsByLines", + value: function(wordsWithComputedWidth, spaceWidth, lineWidth) { + var scaleToFit = this.props.scaleToFit; + return wordsWithComputedWidth.reduce(function(result, _ref2) { + var word = _ref2.word, width = _ref2.width, currentLine = result[result.length - 1]; + if (currentLine && (null == lineWidth || scaleToFit || currentLine.width + width + spaceWidth < lineWidth)) currentLine.words.push(word), + currentLine.width += width + spaceWidth; else { + var newLine = { + words: [ word ], + width: width + }; + result.push(newLine); + } + return result; + }, []); + } + }, { + key: "render", + value: function() { + var _props = this.props, dx = _props.dx, dy = _props.dy, textAnchor = _props.textAnchor, verticalAnchor = _props.verticalAnchor, scaleToFit = _props.scaleToFit, angle = _props.angle, lineHeight = _props.lineHeight, capHeight = _props.capHeight, className = _props.className, textProps = _objectWithoutProperties(_props, [ "dx", "dy", "textAnchor", "verticalAnchor", "scaleToFit", "angle", "lineHeight", "capHeight", "className" ]), wordsByLines = this.state.wordsByLines; + if (!Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.f)(textProps.x) || !Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.f)(textProps.y)) return null; + var x = textProps.x + (Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.g)(dx) ? dx : 0), y = textProps.y + (Object(__WEBPACK_IMPORTED_MODULE_5__util_DataUtils__.g)(dy) ? dy : 0), startDy = void 0; + switch (verticalAnchor) { + case "start": + startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + capHeight + ")"); + break; + + case "middle": + startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + (wordsByLines.length - 1) / 2 + " * -" + lineHeight + " + (" + capHeight + " / 2))"); + break; + + default: + startDy = __WEBPACK_IMPORTED_MODULE_3_reduce_css_calc___default()("calc(" + (wordsByLines.length - 1) + " * -" + lineHeight + ")"); + } + var transforms = []; + if (scaleToFit) { + var lineWidth = wordsByLines[0].width; + transforms.push("scale(" + this.props.width / lineWidth + ")"); + } + return angle && transforms.push("rotate(" + angle + ", " + x + ", " + y + ")"), + transforms.length && (textProps.transform = transforms.join(" ")), __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement("text", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.k)(textProps), { + x: x, + y: y, + className: __WEBPACK_IMPORTED_MODULE_4_classnames___default()("recharts-text", className), + textAnchor: textAnchor + }), wordsByLines.map(function(line, index) { + return __WEBPACK_IMPORTED_MODULE_1_react___default.a.createElement("tspan", { + x: x, + dy: 0 === index ? startDy : lineHeight, + key: index + }, line.words.join(" ")); + })); + } + } ]), Text; + }(__WEBPACK_IMPORTED_MODULE_1_react__.Component), _class.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_6__util_ReactUtils__.c, { + scaleToFit: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.bool, + angle: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.number, + textAnchor: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOf([ "start", "middle", "end", "inherit" ]), + verticalAnchor: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.oneOf([ "start", "middle", "end" ]), + style: __WEBPACK_IMPORTED_MODULE_2_prop_types___default.a.object + }), _class.defaultProps = { + x: 0, + y: 0, + lineHeight: "1em", + capHeight: "0.71em", + scaleToFit: !1, + textAnchor: "start", + verticalAnchor: "end" + }, _temp2); + __webpack_exports__.a = Text; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_require__.d(__webpack_exports__, "a", function() { + return map; + }), __webpack_require__.d(__webpack_exports__, "b", function() { + return slice; + }); + var array = Array.prototype, map = array.map, slice = array.slice; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3__util_PureRender__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__ = __webpack_require__(7), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), Dot = Object(__WEBPACK_IMPORTED_MODULE_3__util_PureRender__.a)((_temp = _class2 = function(_Component) { + function Dot() { + return _classCallCheck(this, Dot), _possibleConstructorReturn(this, (Dot.__proto__ || Object.getPrototypeOf(Dot)).apply(this, arguments)); + } + return _inherits(Dot, _Component), _createClass(Dot, [ { + key: "render", + value: function() { + var _props = this.props, cx = _props.cx, cy = _props.cy, r = _props.r, className = _props.className, layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-dot", className); + return cx === +cx && cy === +cy && r === +r ? __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("circle", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_4__util_ReactUtils__.e)(this.props, null, !0), { + className: layerClass, + cx: cx, + cy: cy, + r: r + })) : null; + } + } ]), Dot; + }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "Dot", _class2.propTypes = { + className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + cx: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + cy: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + r: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number + }, _class = _temp)) || _class; + __webpack_exports__.a = Dot; +}, function(module, exports, __webpack_require__) { + var IObject = __webpack_require__(177), defined = __webpack_require__(179); + module.exports = function(it) { + return IObject(defined(it)); + }; +}, function(module, exports, __webpack_require__) { + var defined = __webpack_require__(179); + module.exports = function(it) { + return Object(defined(it)); + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }); + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), _warning = __webpack_require__(14), _warning2 = _interopRequireDefault(_warning), _toCss = __webpack_require__(195), _toCss2 = _interopRequireDefault(_toCss), _toCssValue = __webpack_require__(196), _toCssValue2 = _interopRequireDefault(_toCssValue), StyleRule = function() { + function StyleRule(key, style, options) { + _classCallCheck(this, StyleRule), this.type = "style", this.isProcessed = !1; + var sheet = options.sheet, Renderer = options.Renderer, selector = options.selector; + this.key = key, this.options = options, this.style = style, selector && (this.selectorText = selector), + this.renderer = sheet ? sheet.renderer : new Renderer(); + } + return _createClass(StyleRule, [ { + key: "prop", + value: function(name, nextValue) { + if (null != nextValue) { + if (this.style[name] !== nextValue) if (nextValue = this.options.jss.plugins.onChangeValue(nextValue, name, this), + this.style[name] = nextValue, this.renderable) this.renderer.setStyle(this.renderable, name, nextValue); else { + var sheet = this.options.sheet; + sheet && sheet.attached && (0, _warning2.default)(!1, 'Rule is not linked. Missing sheet option "link: true".'); + } + return this; + } + return this.style[name]; + } + }, { + key: "applyTo", + value: function(renderable) { + var json = this.toJSON(); + for (var prop in json) this.renderer.setStyle(renderable, prop, json[prop]); + return this; + } + }, { + key: "toJSON", + value: function() { + var json = {}; + for (var prop in this.style) { + var value = this.style[prop]; + "object" !== (void 0 === value ? "undefined" : _typeof(value)) ? json[prop] = value : Array.isArray(value) && (json[prop] = (0, + _toCssValue2.default)(value)); + } + return json; + } + }, { + key: "toString", + value: function(options) { + var sheet = this.options.sheet, link = !!sheet && sheet.options.link, opts = link ? _extends({}, options, { + allowEmpty: !0 + }) : options; + return (0, _toCss2.default)(this.selector, this.style, opts); + } + }, { + key: "selector", + set: function(selector) { + if (selector !== this.selectorText && (this.selectorText = selector, this.renderable)) { + if (!this.renderer.setSelector(this.renderable, selector) && this.renderable) { + var renderable = this.renderer.replaceRule(this.renderable, this); + renderable && (this.renderable = renderable); + } + } + }, + get: function() { + return this.selectorText; + } + } ]), StyleRule; + }(); + exports.default = StyleRule; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry1__ = __webpack_require__(4), always = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry1__.a)(function(val) { + return function() { + return val; + }; + }); + __webpack_exports__.a = always; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), max = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(a, b) { + return b > a ? b : a; + }); + __webpack_exports__.a = max; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), path = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(paths, obj) { + for (var val = obj, idx = 0; idx < paths.length; ) { + if (null == val) return; + val = val[paths[idx]], idx += 1; + } + return val; + }); + __webpack_exports__.a = path; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _contains(a, list) { + return Object(__WEBPACK_IMPORTED_MODULE_0__indexOf__.a)(list, a, 0) >= 0; + } + __webpack_exports__.a = _contains; + var __WEBPACK_IMPORTED_MODULE_0__indexOf__ = __webpack_require__(316); +}, function(module, exports, __webpack_require__) { + function isSymbol(value) { + return "symbol" == typeof value || isObjectLike(value) && baseGetTag(value) == symbolTag; + } + var baseGetTag = __webpack_require__(59), isObjectLike = __webpack_require__(52), symbolTag = "[object Symbol]"; + module.exports = isSymbol; +}, function(module, exports) { + function identity(value) { + return value; + } + module.exports = identity; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(a, b) { + return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _class2, _temp2, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3_react_smooth__ = __webpack_require__(48), __WEBPACK_IMPORTED_MODULE_3_react_smooth___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_react_smooth__), __WEBPACK_IMPORTED_MODULE_4__util_PureRender__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__ = __webpack_require__(7), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), getRectangePath = function(x, y, width, height, radius) { + var maxRadius = Math.min(Math.abs(width) / 2, Math.abs(height) / 2), sign = height >= 0 ? 1 : -1, clockWise = height >= 0 ? 1 : 0, path = void 0; + if (maxRadius > 0 && radius instanceof Array) { + for (var newRadius = [], i = 0; i < 4; i++) newRadius[i] = radius[i] > maxRadius ? maxRadius : radius[i]; + path = "M" + x + "," + (y + sign * newRadius[0]), newRadius[0] > 0 && (path += "A " + newRadius[0] + "," + newRadius[0] + ",0,0," + clockWise + "," + (x + newRadius[0]) + "," + y), + path += "L " + (x + width - newRadius[1]) + "," + y, newRadius[1] > 0 && (path += "A " + newRadius[1] + "," + newRadius[1] + ",0,0," + clockWise + ",\n " + (x + width) + "," + (y + sign * newRadius[1])), + path += "L " + (x + width) + "," + (y + height - sign * newRadius[2]), newRadius[2] > 0 && (path += "A " + newRadius[2] + "," + newRadius[2] + ",0,0," + clockWise + ",\n " + (x + width - newRadius[2]) + "," + (y + height)), + path += "L " + (x + newRadius[3]) + "," + (y + height), newRadius[3] > 0 && (path += "A " + newRadius[3] + "," + newRadius[3] + ",0,0," + clockWise + ",\n " + x + "," + (y + height - sign * newRadius[3])), + path += "Z"; + } else if (maxRadius > 0 && radius === +radius && radius > 0) { + var _newRadius = Math.min(maxRadius, radius); + path = "M " + x + "," + (y + sign * _newRadius) + "\n A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + _newRadius) + "," + y + "\n L " + (x + width - _newRadius) + "," + y + "\n A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + width) + "," + (y + sign * _newRadius) + "\n L " + (x + width) + "," + (y + height - sign * _newRadius) + "\n A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + (x + width - _newRadius) + "," + (y + height) + "\n L " + (x + _newRadius) + "," + (y + height) + "\n A " + _newRadius + "," + _newRadius + ",0,0," + clockWise + "," + x + "," + (y + height - sign * _newRadius) + " Z"; + } else path = "M " + x + "," + y + " h " + width + " v " + height + " h " + -width + " Z"; + return path; + }, Rectangle = Object(__WEBPACK_IMPORTED_MODULE_4__util_PureRender__.a)((_temp2 = _class2 = function(_Component) { + function Rectangle() { + var _ref, _temp, _this, _ret; + _classCallCheck(this, Rectangle); + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key]; + return _temp = _this = _possibleConstructorReturn(this, (_ref = Rectangle.__proto__ || Object.getPrototypeOf(Rectangle)).call.apply(_ref, [ this ].concat(args))), + _this.state = { + totalLength: -1 + }, _ret = _temp, _possibleConstructorReturn(_this, _ret); + } + return _inherits(Rectangle, _Component), _createClass(Rectangle, [ { + key: "componentDidMount", + value: function() { + if (this.node && this.node.getTotalLength) { + var totalLength = this.node.getTotalLength(); + totalLength && this.setState({ + totalLength: totalLength + }); + } + } + }, { + key: "render", + value: function() { + var _this2 = this, _props = this.props, x = _props.x, y = _props.y, width = _props.width, height = _props.height, radius = _props.radius, className = _props.className, totalLength = this.state.totalLength, _props2 = this.props, animationEasing = _props2.animationEasing, animationDuration = _props2.animationDuration, animationBegin = _props2.animationBegin, isAnimationActive = _props2.isAnimationActive, isUpdateAnimationActive = _props2.isUpdateAnimationActive; + if (x !== +x || y !== +y || width !== +width || height !== +height || 0 === width || 0 === height) return null; + var layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-rectangle", className); + return isUpdateAnimationActive ? __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3_react_smooth___default.a, { + canBegin: totalLength > 0, + from: { + width: width, + height: height, + x: x, + y: y + }, + to: { + width: width, + height: height, + x: x, + y: y + }, + duration: animationDuration, + animationEasing: animationEasing, + isActive: isUpdateAnimationActive + }, function(_ref2) { + var currWidth = _ref2.width, currHeight = _ref2.height, currX = _ref2.x, currY = _ref2.y; + return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_3_react_smooth___default.a, { + canBegin: totalLength > 0, + from: "0px " + (-1 === totalLength ? 1 : totalLength) + "px", + to: totalLength + "px 0px", + attributeName: "strokeDasharray", + begin: animationBegin, + duration: animationDuration, + isActive: isAnimationActive, + easing: animationEasing + }, __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.k)(_this2.props), Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.e)(_this2.props), { + className: layerClass, + d: getRectangePath(currX, currY, currWidth, currHeight, radius), + ref: function(node) { + _this2.node = node; + } + }))); + }) : __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.e)(this.props), { + className: layerClass, + d: getRectangePath(x, y, width, height, radius) + })); + } + } ]), Rectangle; + }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "Rectangle", + _class2.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.c, __WEBPACK_IMPORTED_MODULE_5__util_ReactUtils__.a, { + className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + x: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + y: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + radius: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array ]), + isAnimationActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + isUpdateAnimationActive: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + animationBegin: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + animationDuration: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + animationEasing: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "ease", "ease-in", "ease-out", "ease-in-out", "linear" ]) + }), _class2.defaultProps = { + x: 0, + y: 0, + width: 0, + height: 0, + radius: 0, + isAnimationActive: !1, + isUpdateAnimationActive: !1, + animationBegin: 0, + animationDuration: 1500, + animationEasing: "ease" + }, _class = _temp2)) || _class; + __webpack_exports__.a = Rectangle; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_lodash_isArray__ = __webpack_require__(16), __WEBPACK_IMPORTED_MODULE_0_lodash_isArray___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_lodash_isArray__), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__ = __webpack_require__(11), __WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction__), __WEBPACK_IMPORTED_MODULE_2_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_2_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_react__), __WEBPACK_IMPORTED_MODULE_3_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_3_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_3_prop_types__), __WEBPACK_IMPORTED_MODULE_4_d3_shape__ = __webpack_require__(235), __WEBPACK_IMPORTED_MODULE_5_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_5_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_5_classnames__), __WEBPACK_IMPORTED_MODULE_6__util_PureRender__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__ = __webpack_require__(7), __WEBPACK_IMPORTED_MODULE_8__util_DataUtils__ = __webpack_require__(12), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), CURVE_FACTORIES = { + curveBasisClosed: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.c, + curveBasisOpen: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.d, + curveBasis: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.b, + curveLinearClosed: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.f, + curveLinear: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.e, + curveMonotoneX: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.g, + curveMonotoneY: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.h, + curveNatural: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.i, + curveStep: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.j, + curveStepAfter: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.k, + curveStepBefore: __WEBPACK_IMPORTED_MODULE_4_d3_shape__.l + }, defined = function(p) { + return p.x === +p.x && p.y === +p.y; + }, getX = function(p) { + return p.x; + }, getY = function(p) { + return p.y; + }, getCurveFactory = function(type, layout) { + if (__WEBPACK_IMPORTED_MODULE_1_lodash_isFunction___default()(type)) return type; + var name = "curve" + type.slice(0, 1).toUpperCase() + type.slice(1); + return "curveMonotone" === name && layout ? CURVE_FACTORIES[name + ("vertical" === layout ? "Y" : "X")] : CURVE_FACTORIES[name] || __WEBPACK_IMPORTED_MODULE_4_d3_shape__.e; + }, Curve = Object(__WEBPACK_IMPORTED_MODULE_6__util_PureRender__.a)((_temp = _class2 = function(_Component) { + function Curve() { + return _classCallCheck(this, Curve), _possibleConstructorReturn(this, (Curve.__proto__ || Object.getPrototypeOf(Curve)).apply(this, arguments)); + } + return _inherits(Curve, _Component), _createClass(Curve, [ { + key: "getPath", + value: function() { + var _props = this.props, type = _props.type, points = _props.points, baseLine = _props.baseLine, layout = _props.layout, connectNulls = _props.connectNulls, curveFactory = getCurveFactory(type, layout), formatPoints = connectNulls ? points.filter(function(entry) { + return defined(entry); + }) : points, lineFunction = void 0; + if (__WEBPACK_IMPORTED_MODULE_0_lodash_isArray___default()(baseLine)) { + var areaPoints = formatPoints.map(function(entry, index) { + return _extends({}, entry, { + base: baseLine[index] + }); + }); + return lineFunction = "vertical" === layout ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().y(getY).x1(getX).x0(function(d) { + return d.base.x; + }) : Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().x(getX).y1(getY).y0(function(d) { + return d.base.y; + }), lineFunction.defined(defined).curve(curveFactory), lineFunction(areaPoints); + } + return lineFunction = "vertical" === layout && Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(baseLine) ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().y(getY).x1(getX).x0(baseLine) : Object(__WEBPACK_IMPORTED_MODULE_8__util_DataUtils__.g)(baseLine) ? Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.a)().x(getX).y1(getY).y0(baseLine) : Object(__WEBPACK_IMPORTED_MODULE_4_d3_shape__.m)().x(getX).y(getY), + lineFunction.defined(defined).curve(curveFactory), lineFunction(formatPoints); + } + }, { + key: "render", + value: function() { + var _props2 = this.props, className = _props2.className, points = _props2.points, path = _props2.path, pathRef = _props2.pathRef; + if (!(points && points.length || path)) return null; + var realPath = points && points.length ? this.getPath() : path; + return __WEBPACK_IMPORTED_MODULE_2_react___default.a.createElement("path", _extends({}, Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.k)(this.props), Object(__WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.e)(this.props, null, !0), { + className: __WEBPACK_IMPORTED_MODULE_5_classnames___default()("recharts-curve", className), + d: realPath, + ref: pathRef + })); + } + } ]), Curve; + }(__WEBPACK_IMPORTED_MODULE_2_react__.Component), _class2.displayName = "Curve", + _class2.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_7__util_ReactUtils__.c, { + className: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string, + type: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOf([ "basis", "basisClosed", "basisOpen", "linear", "linearClosed", "natural", "monotoneX", "monotoneY", "monotone", "step", "stepBefore", "stepAfter" ]), __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.func ]), + layout: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOf([ "horizontal", "vertical" ]), + baseLine: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.array ]), + points: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.object), + connectNulls: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.bool, + path: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.string, + pathRef: __WEBPACK_IMPORTED_MODULE_3_prop_types___default.a.func + }), _class2.defaultProps = { + type: "linear", + points: [], + connectNulls: !1 + }, _class = _temp)) || _class; + __webpack_exports__.a = Curve; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), + __webpack_require__(2)), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__util_PureRender__ = __webpack_require__(8), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(7), _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), XAxis = Object(__WEBPACK_IMPORTED_MODULE_2__util_PureRender__.a)((_temp = _class2 = function(_Component) { + function XAxis() { + return _classCallCheck(this, XAxis), _possibleConstructorReturn(this, (XAxis.__proto__ || Object.getPrototypeOf(XAxis)).apply(this, arguments)); + } + return _inherits(XAxis, _Component), _createClass(XAxis, [ { + key: "render", + value: function() { + return null; + } + } ]), XAxis; + }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "XAxis", + _class2.propTypes = { + allowDecimals: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + allowDuplicatedCategory: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + hide: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + name: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + unit: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + xAxisId: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + domain: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "dataMin", "dataMax" ]) ])), + dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]), + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + mirror: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + orientation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "top", "bottom" ]), + type: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "number", "category" ]), + ticks: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array, + tickCount: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + tickFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, + padding: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ + left: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + right: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number + }), + allowDataOverflow: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + scale: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.d), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]), + tick: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.element ]), + axisLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]), + tickLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]), + minTickGap: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + tickSize: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + interval: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "preserveStart", "preserveEnd", "preserveStartEnd" ]) ]), + reversed: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool + }, _class2.defaultProps = { + allowDecimals: !0, + hide: !1, + orientation: "bottom", + width: 0, + height: 30, + mirror: !1, + xAxisId: 0, + tickCount: 5, + type: "category", + domain: [ 0, "auto" ], + padding: { + left: 0, + right: 0 + }, + allowDataOverflow: !1, + scale: "auto", + reversed: !1, + allowDuplicatedCategory: !0 + }, _class = _temp)) || _class; + __webpack_exports__.a = XAxis; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _class2, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), + __webpack_require__(2)), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__util_PureRender__ = __webpack_require__(8), _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), YAxis = Object(__WEBPACK_IMPORTED_MODULE_2__util_PureRender__.a)((_temp = _class2 = function(_Component) { + function YAxis() { + return _classCallCheck(this, YAxis), _possibleConstructorReturn(this, (YAxis.__proto__ || Object.getPrototypeOf(YAxis)).apply(this, arguments)); + } + return _inherits(YAxis, _Component), _createClass(YAxis, [ { + key: "render", + value: function() { + return null; + } + } ]), YAxis; + }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class2.displayName = "YAxis", + _class2.propTypes = { + allowDecimals: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + allowDuplicatedCategory: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + hide: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + name: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + unit: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + yAxisId: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number ]), + domain: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "dataMin", "dataMax" ]) ])), + dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]), + ticks: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array, + tickCount: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + tickFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + mirror: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + orientation: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "left", "right" ]), + type: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "number", "category" ]), + padding: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ + top: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + bottom: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number + }), + allowDataOverflow: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, + scale: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "auto", "linear", "pow", "sqrt", "log", "identity", "time", "band", "point", "ordinal", "quantile", "quantize", "utcTime", "sequential", "threshold" ]), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]), + tick: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.element ]), + axisLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]), + tickLine: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object ]), + minTickGap: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + tickSize: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + interval: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOf([ "preserveStart", "preserveEnd", "preserveStartEnd" ]) ]), + reversed: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.bool + }, _class2.defaultProps = { + allowDuplicatedCategory: !0, + allowDecimals: !0, + hide: !1, + orientation: "left", + width: 60, + height: 0, + mirror: !1, + yAxisId: 0, + tickCount: 5, + type: "number", + domain: [ 0, "auto" ], + padding: { + top: 0, + bottom: 0 + }, + allowDataOverflow: !1, + scale: "auto", + reversed: !1 + }, _class = _temp)) || _class; + __webpack_exports__.a = YAxis; +}, function(module, exports, __webpack_require__) { + "use strict"; + function toObject(val) { + if (null === val || void 0 === val) throw new TypeError("Object.assign cannot be called with null or undefined"); + return Object(val); + } + var getOwnPropertySymbols = Object.getOwnPropertySymbols, hasOwnProperty = Object.prototype.hasOwnProperty, propIsEnumerable = Object.prototype.propertyIsEnumerable; + module.exports = function() { + try { + if (!Object.assign) return !1; + var test1 = new String("abc"); + if (test1[5] = "de", "5" === Object.getOwnPropertyNames(test1)[0]) return !1; + for (var test2 = {}, i = 0; i < 10; i++) test2["_" + String.fromCharCode(i)] = i; + if ("0123456789" !== Object.getOwnPropertyNames(test2).map(function(n) { + return test2[n]; + }).join("")) return !1; + var test3 = {}; + return "abcdefghijklmnopqrst".split("").forEach(function(letter) { + test3[letter] = letter; + }), "abcdefghijklmnopqrst" === Object.keys(Object.assign({}, test3)).join(""); + } catch (err) { + return !1; + } + }() ? Object.assign : function(target, source) { + for (var from, symbols, to = toObject(target), s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + for (var key in from) hasOwnProperty.call(from, key) && (to[key] = from[key]); + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) propIsEnumerable.call(from, symbols[i]) && (to[symbols[i]] = from[symbols[i]]); + } + } + return to; + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + function invariant(condition, format, a, b, c, d, e, f) { + if (validateFormat(format), !condition) { + var error; + if (void 0 === format) error = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."); else { + var args = [ a, b, c, d, e, f ], argIndex = 0; + error = new Error(format.replace(/%s/g, function() { + return args[argIndex++]; + })), error.name = "Invariant Violation"; + } + throw error.framesToPop = 1, error; + } + } + var validateFormat = function(format) {}; + "production" !== process.env.NODE_ENV && (validateFormat = function(format) { + if (void 0 === format) throw new Error("invariant requires an error message argument"); + }), module.exports = invariant; + }).call(exports, __webpack_require__(3)); +}, function(module, exports) { + module.exports = function(bitmap, value) { + return { + enumerable: !(1 & bitmap), + configurable: !(2 & bitmap), + writable: !(4 & bitmap), + value: value + }; + }; +}, function(module, exports, __webpack_require__) { + var $keys = __webpack_require__(272), enumBugKeys = __webpack_require__(183); + module.exports = Object.keys || function(O) { + return $keys(O, enumBugKeys); + }; +}, function(module, exports) { + module.exports = {}; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + function createBreakpoints(breakpoints) { + function up(key) { + return "@media (min-width:" + ("number" == typeof values[key] ? values[key] : key) + unit + ")"; + } + function down(key) { + return "@media (max-width:" + (("number" == typeof values[key] ? values[key] : key) - step / 100) + unit + ")"; + } + function between(start, end) { + var endIndex = keys.indexOf(end) + 1; + return endIndex === keys.length ? up(start) : "@media (min-width:" + values[start] + unit + ") and (max-width:" + (values[keys[endIndex]] - step / 100) + unit + ")"; + } + function only(key) { + return between(key, key); + } + function width(key) { + return values[key]; + } + var _breakpoints$values = breakpoints.values, values = void 0 === _breakpoints$values ? { + xs: 0, + sm: 600, + md: 960, + lg: 1280, + xl: 1920 + } : _breakpoints$values, _breakpoints$unit = breakpoints.unit, unit = void 0 === _breakpoints$unit ? "px" : _breakpoints$unit, _breakpoints$step = breakpoints.step, step = void 0 === _breakpoints$step ? 5 : _breakpoints$step, other = (0, + _objectWithoutProperties3.default)(breakpoints, [ "values", "unit", "step" ]); + return (0, _extends3.default)({ + keys: keys, + values: values, + up: up, + down: down, + between: between, + only: only, + width: width + }, other); + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }), exports.keys = void 0; + var _extends2 = __webpack_require__(10), _extends3 = _interopRequireDefault(_extends2), _objectWithoutProperties2 = __webpack_require__(9), _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2); + exports.default = createBreakpoints; + var keys = exports.keys = [ "xs", "sm", "md", "lg", "xl" ]; +}, function(module, exports, __webpack_require__) { + "use strict"; + exports.__esModule = !0; + var _getDisplayName = __webpack_require__(289), _getDisplayName2 = function(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + }(_getDisplayName), wrapDisplayName = function(BaseComponent, hocName) { + return hocName + "(" + (0, _getDisplayName2.default)(BaseComponent) + ")"; + }; + exports.default = wrapDisplayName; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + Object.defineProperty(exports, "__esModule", { + value: !0 + }); + var _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), _createRule = __webpack_require__(131), _createRule2 = _interopRequireDefault(_createRule), _linkRule = __webpack_require__(294), _linkRule2 = _interopRequireDefault(_linkRule), _StyleRule = __webpack_require__(77), _StyleRule2 = _interopRequireDefault(_StyleRule), _escape = __webpack_require__(546), _escape2 = _interopRequireDefault(_escape), RuleList = function() { + function RuleList(options) { + _classCallCheck(this, RuleList), this.map = {}, this.raw = {}, this.index = [], + this.options = options, this.classes = options.classes; + } + return _createClass(RuleList, [ { + key: "add", + value: function(name, decl, options) { + var _options = this.options, parent = _options.parent, sheet = _options.sheet, jss = _options.jss, Renderer = _options.Renderer, generateClassName = _options.generateClassName; + options = _extends({ + classes: this.classes, + parent: parent, + sheet: sheet, + jss: jss, + Renderer: Renderer, + generateClassName: generateClassName + }, options), !options.selector && this.classes[name] && (options.selector = "." + (0, + _escape2.default)(this.classes[name])), this.raw[name] = decl; + var rule = (0, _createRule2.default)(name, decl, options), className = void 0; + !options.selector && rule instanceof _StyleRule2.default && (className = generateClassName(rule, sheet), + rule.selector = "." + (0, _escape2.default)(className)), this.register(rule, className); + var index = void 0 === options.index ? this.index.length : options.index; + return this.index.splice(index, 0, rule), rule; + } + }, { + key: "get", + value: function(name) { + return this.map[name]; + } + }, { + key: "remove", + value: function(rule) { + this.unregister(rule), this.index.splice(this.indexOf(rule), 1); + } + }, { + key: "indexOf", + value: function(rule) { + return this.index.indexOf(rule); + } + }, { + key: "process", + value: function() { + var plugins = this.options.jss.plugins; + this.index.slice(0).forEach(plugins.onProcessRule, plugins); + } + }, { + key: "register", + value: function(rule, className) { + this.map[rule.key] = rule, rule instanceof _StyleRule2.default && (this.map[rule.selector] = rule, + className && (this.classes[rule.key] = className)); + } + }, { + key: "unregister", + value: function(rule) { + delete this.map[rule.key], rule instanceof _StyleRule2.default && (delete this.map[rule.selector], + delete this.classes[rule.key]); + } + }, { + key: "update", + value: function(name, data) { + var _options2 = this.options, plugins = _options2.jss.plugins, sheet = _options2.sheet; + if ("string" == typeof name) return void plugins.onUpdate(data, this.get(name), sheet); + for (var index = 0; index < this.index.length; index++) plugins.onUpdate(name, this.index[index], sheet); + } + }, { + key: "link", + value: function(cssRules) { + for (var map = this.options.sheet.renderer.getUnescapedKeysMap(this.index), i = 0; i < cssRules.length; i++) { + var cssRule = cssRules[i], _key = this.options.sheet.renderer.getKey(cssRule); + map[_key] && (_key = map[_key]); + var rule = this.map[_key]; + rule && (0, _linkRule2.default)(rule, cssRule); + } + } + }, { + key: "toString", + value: function(options) { + for (var str = "", sheet = this.options.sheet, link = !!sheet && sheet.options.link, index = 0; index < this.index.length; index++) { + var rule = this.index[index], css = rule.toString(options); + (css || link) && (str && (str += "\n"), str += css); + } + return str; + } + } ]), RuleList; + }(); + exports.default = RuleList; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__map__ = __webpack_require__(27), __WEBPACK_IMPORTED_MODULE_2__prop__ = __webpack_require__(201), pluck = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(p, list) { + return Object(__WEBPACK_IMPORTED_MODULE_1__map__.a)(Object(__WEBPACK_IMPORTED_MODULE_2__prop__.a)(p), list); + }); + __webpack_exports__.a = pluck; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _isString(x) { + return "[object String]" === Object.prototype.toString.call(x); + } + __webpack_exports__.a = _isString; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _checkForMethod(methodname, fn) { + return function() { + var length = arguments.length; + if (0 === length) return fn(); + var obj = arguments[length - 1]; + return Object(__WEBPACK_IMPORTED_MODULE_0__isArray__.a)(obj) || "function" != typeof obj[methodname] ? fn.apply(this, arguments) : obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1)); + }; + } + __webpack_exports__.a = _checkForMethod; + var __WEBPACK_IMPORTED_MODULE_0__isArray__ = __webpack_require__(57); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry1__ = __webpack_require__(4), __WEBPACK_IMPORTED_MODULE_1__internal_toString__ = __webpack_require__(604), toString = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry1__.a)(function(val) { + return Object(__WEBPACK_IMPORTED_MODULE_1__internal_toString__.a)(val, []); + }); + __webpack_exports__.a = toString; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__internal_isString__ = __webpack_require__(98), nth = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(offset, list) { + var idx = offset < 0 ? list.length + offset : offset; + return Object(__WEBPACK_IMPORTED_MODULE_1__internal_isString__.a)(list) ? list.charAt(idx) : list[idx]; + }); + __webpack_exports__.a = nth; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__internal_curry2__ = __webpack_require__(0), __WEBPACK_IMPORTED_MODULE_1__internal_isFunction__ = __webpack_require__(140), __WEBPACK_IMPORTED_MODULE_2__curryN__ = __webpack_require__(23), __WEBPACK_IMPORTED_MODULE_3__toString__ = __webpack_require__(100), invoker = Object(__WEBPACK_IMPORTED_MODULE_0__internal_curry2__.a)(function(arity, method) { + return Object(__WEBPACK_IMPORTED_MODULE_2__curryN__.a)(arity + 1, function() { + var target = arguments[arity]; + if (null != target && Object(__WEBPACK_IMPORTED_MODULE_1__internal_isFunction__.a)(target[method])) return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity)); + throw new TypeError(Object(__WEBPACK_IMPORTED_MODULE_3__toString__.a)(target) + ' does not have a method named "' + method + '"'); + }); + }); + __webpack_exports__.a = invoker; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function Surface(props) { + var children = props.children, width = props.width, height = props.height, viewBox = props.viewBox, className = props.className, style = props.style, others = _objectWithoutProperties(props, [ "children", "width", "height", "viewBox", "className", "style" ]), svgView = viewBox || { + width: width, + height: height, + x: 0, + y: 0 + }, layerClass = __WEBPACK_IMPORTED_MODULE_2_classnames___default()("recharts-surface", className), attrs = Object(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.k)(others); + return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("svg", _extends({}, attrs, { + className: layerClass, + width: width, + height: height, + style: style, + viewBox: svgView.x + " " + svgView.y + " " + svgView.width + " " + svgView.height, + version: "1.1" + }), children); + } + var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2_classnames__ = __webpack_require__(6), __WEBPACK_IMPORTED_MODULE_2_classnames___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_2_classnames__), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(7), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, propTypes = { + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number.isRequired, + height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number.isRequired, + viewBox: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.shape({ + x: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + y: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + height: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number + }), + className: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + style: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, + children: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.arrayOf(__WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node), __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.node ]) + }; + Surface.propTypes = propTypes, __webpack_exports__.a = Surface; +}, function(module, exports, __webpack_require__) { + var root = __webpack_require__(46), Symbol = root.Symbol; + module.exports = Symbol; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__src_path__ = __webpack_require__(891); + __webpack_require__.d(__webpack_exports__, "a", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_path__.a; + }); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function acos(x) { + return x > 1 ? 0 : x < -1 ? pi : Math.acos(x); + } + function asin(x) { + return x >= 1 ? halfPi : x <= -1 ? -halfPi : Math.asin(x); + } + __webpack_require__.d(__webpack_exports__, "a", function() { + return abs; + }), __webpack_require__.d(__webpack_exports__, "d", function() { + return atan2; + }), __webpack_require__.d(__webpack_exports__, "e", function() { + return cos; + }), __webpack_require__.d(__webpack_exports__, "h", function() { + return max; + }), __webpack_require__.d(__webpack_exports__, "i", function() { + return min; + }), __webpack_require__.d(__webpack_exports__, "k", function() { + return sin; + }), __webpack_require__.d(__webpack_exports__, "l", function() { + return sqrt; + }), __webpack_require__.d(__webpack_exports__, "f", function() { + return epsilon; + }), __webpack_require__.d(__webpack_exports__, "j", function() { + return pi; + }), __webpack_require__.d(__webpack_exports__, "g", function() { + return halfPi; + }), __webpack_require__.d(__webpack_exports__, "m", function() { + return tau; + }), __webpack_exports__.b = acos, __webpack_exports__.c = asin; + var abs = Math.abs, atan2 = Math.atan2, cos = Math.cos, max = Math.max, min = Math.min, sin = Math.sin, sqrt = Math.sqrt, epsilon = 1e-12, pi = Math.PI, halfPi = pi / 2, tau = 2 * pi; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(series, order) { + if ((n = series.length) > 1) for (var j, s0, n, i = 1, s1 = series[order[0]], m = s1.length; i < n; ++i) for (s0 = s1, + s1 = series[order[i]], j = 0; j < m; ++j) s1[j][1] += s1[j][0] = isNaN(s0[j][1]) ? s0[j][0] : s0[j][1]; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(series) { + for (var n = series.length, o = new Array(n); --n >= 0; ) o[n] = n; + return o; + }; +}, function(module, exports, __webpack_require__) { + function isArrayLike(value) { + return null != value && isLength(value.length) && !isFunction(value); + } + var isFunction = __webpack_require__(11), isLength = __webpack_require__(244); + module.exports = isArrayLike; +}, function(module, exports, __webpack_require__) { + function baseIteratee(value) { + return "function" == typeof value ? value : null == value ? identity : "object" == typeof value ? isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value) : property(value); + } + var baseMatches = __webpack_require__(976), baseMatchesProperty = __webpack_require__(979), identity = __webpack_require__(83), isArray = __webpack_require__(16), property = __webpack_require__(983); + module.exports = baseIteratee; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function Cell() { + return null; + } + var __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_1__util_ReactUtils__ = (__webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), + __webpack_require__(7)), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }; + Cell.propTypes = _extends({}, __WEBPACK_IMPORTED_MODULE_1__util_ReactUtils__.c), + Cell.displayName = "Cell", __webpack_exports__.a = Cell; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(x) { + return null === x ? NaN : +x; + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function linearish(scale) { + var domain = scale.domain; + return scale.ticks = function(count) { + var d = domain(); + return Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.h)(d[0], d[d.length - 1], null == count ? 10 : count); + }, scale.tickFormat = function(count, specifier) { + return Object(__WEBPACK_IMPORTED_MODULE_3__tickFormat__.a)(domain(), count, specifier); + }, scale.nice = function(count) { + null == count && (count = 10); + var step, d = domain(), i0 = 0, i1 = d.length - 1, start = d[i0], stop = d[i1]; + return stop < start && (step = start, start = stop, stop = step, step = i0, i0 = i1, + i1 = step), step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count), + step > 0 ? (start = Math.floor(start / step) * step, stop = Math.ceil(stop / step) * step, + step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count)) : step < 0 && (start = Math.ceil(start * step) / step, + stop = Math.floor(stop * step) / step, step = Object(__WEBPACK_IMPORTED_MODULE_0_d3_array__.f)(start, stop, count)), + step > 0 ? (d[i0] = Math.floor(start / step) * step, d[i1] = Math.ceil(stop / step) * step, + domain(d)) : step < 0 && (d[i0] = Math.ceil(start * step) / step, d[i1] = Math.floor(stop * step) / step, + domain(d)), scale; + }, scale; + } + function linear() { + var scale = Object(__WEBPACK_IMPORTED_MODULE_2__continuous__.b)(__WEBPACK_IMPORTED_MODULE_2__continuous__.c, __WEBPACK_IMPORTED_MODULE_1_d3_interpolate__.c); + return scale.copy = function() { + return Object(__WEBPACK_IMPORTED_MODULE_2__continuous__.a)(scale, linear()); + }, linearish(scale); + } + __webpack_exports__.b = linearish, __webpack_exports__.a = linear; + var __WEBPACK_IMPORTED_MODULE_0_d3_array__ = __webpack_require__(53), __WEBPACK_IMPORTED_MODULE_1_d3_interpolate__ = __webpack_require__(114), __WEBPACK_IMPORTED_MODULE_2__continuous__ = __webpack_require__(168), __WEBPACK_IMPORTED_MODULE_3__tickFormat__ = __webpack_require__(1050); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + var __WEBPACK_IMPORTED_MODULE_0__src_value__ = __webpack_require__(250); + __webpack_require__.d(__webpack_exports__, "a", function() { + return __WEBPACK_IMPORTED_MODULE_0__src_value__.a; + }); + var __WEBPACK_IMPORTED_MODULE_5__src_number__ = (__webpack_require__(426), __webpack_require__(253), + __webpack_require__(424), __webpack_require__(427), __webpack_require__(167)); + __webpack_require__.d(__webpack_exports__, "c", function() { + return __WEBPACK_IMPORTED_MODULE_5__src_number__.a; + }); + var __WEBPACK_IMPORTED_MODULE_7__src_round__ = (__webpack_require__(428), __webpack_require__(1040)); + __webpack_require__.d(__webpack_exports__, "d", function() { + return __WEBPACK_IMPORTED_MODULE_7__src_round__.a; + }); + var __WEBPACK_IMPORTED_MODULE_15__src_cubehelix__ = (__webpack_require__(429), __webpack_require__(1041), + __webpack_require__(1044), __webpack_require__(423), __webpack_require__(1045), + __webpack_require__(1046), __webpack_require__(1047), __webpack_require__(1048)); + __webpack_require__.d(__webpack_exports__, "b", function() { + return __WEBPACK_IMPORTED_MODULE_15__src_cubehelix__.a; + }); + __webpack_require__(1049); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function linear(a, d) { + return function(t) { + return a + t * d; + }; + } + function exponential(a, b, y) { + return a = Math.pow(a, y), b = Math.pow(b, y) - a, y = 1 / y, function(t) { + return Math.pow(a + t * b, y); + }; + } + function hue(a, b) { + var d = b - a; + return d ? linear(a, d > 180 || d < -180 ? d - 360 * Math.round(d / 360) : d) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a); + } + function gamma(y) { + return 1 == (y = +y) ? nogamma : function(a, b) { + return b - a ? exponential(a, b, y) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a); + }; + } + function nogamma(a, b) { + var d = b - a; + return d ? linear(a, d) : Object(__WEBPACK_IMPORTED_MODULE_0__constant__.a)(isNaN(a) ? b : a); + } + __webpack_exports__.c = hue, __webpack_exports__.b = gamma, __webpack_exports__.a = nogamma; + var __WEBPACK_IMPORTED_MODULE_0__constant__ = __webpack_require__(425); +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + __webpack_exports__.a = function(s) { + return s.match(/.{6}/g).map(function(x) { + return "#" + x; + }); + }; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _objectWithoutProperties(obj, keys) { + var target = {}; + for (var i in obj) keys.indexOf(i) >= 0 || Object.prototype.hasOwnProperty.call(obj, i) && (target[i] = obj[i]); + return target; + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function"); + } + function _possibleConstructorReturn(self, call) { + if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return !call || "object" != typeof call && "function" != typeof call ? self : call; + } + function _inherits(subClass, superClass) { + if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass); + } + var _class, _temp, __WEBPACK_IMPORTED_MODULE_0_react__ = __webpack_require__(1), __WEBPACK_IMPORTED_MODULE_0_react___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_react__), __WEBPACK_IMPORTED_MODULE_1_prop_types__ = __webpack_require__(2), __WEBPACK_IMPORTED_MODULE_1_prop_types___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_1_prop_types__), __WEBPACK_IMPORTED_MODULE_2__container_Layer__ = __webpack_require__(18), __WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__ = __webpack_require__(7), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, _createClass = function() { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, + "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor); + } + } + return function(Constructor, protoProps, staticProps) { + return protoProps && defineProperties(Constructor.prototype, protoProps), staticProps && defineProperties(Constructor, staticProps), + Constructor; + }; + }(), ErrorBar = (_temp = _class = function(_Component) { + function ErrorBar() { + return _classCallCheck(this, ErrorBar), _possibleConstructorReturn(this, (ErrorBar.__proto__ || Object.getPrototypeOf(ErrorBar)).apply(this, arguments)); + } + return _inherits(ErrorBar, _Component), _createClass(ErrorBar, [ { + key: "renderErrorBars", + value: function() { + var _props = this.props, offset = _props.offset, layout = _props.layout, width = _props.width, dataKey = _props.dataKey, data = _props.data, dataPointFormatter = _props.dataPointFormatter, xAxis = _props.xAxis, yAxis = _props.yAxis, others = _objectWithoutProperties(_props, [ "offset", "layout", "width", "dataKey", "data", "dataPointFormatter", "xAxis", "yAxis" ]), props = Object(__WEBPACK_IMPORTED_MODULE_3__util_ReactUtils__.k)(others); + return data.map(function(entry, i) { + var _dataPointFormatter = dataPointFormatter(entry, dataKey), x = _dataPointFormatter.x, y = _dataPointFormatter.y, value = _dataPointFormatter.value, errorVal = _dataPointFormatter.errorVal; + if (!errorVal) return null; + var xMid = void 0, yMid = void 0, xMin = void 0, yMin = void 0, xMax = void 0, yMax = void 0, scale = void 0, coordsTop = void 0, coordsMid = void 0, coordsBot = void 0, lowBound = void 0, highBound = void 0; + return Array.isArray(errorVal) ? (lowBound = errorVal[0], highBound = errorVal[1]) : (lowBound = errorVal, + highBound = errorVal), "vertical" === layout ? (scale = xAxis.scale, xMid = value, + yMid = y + offset, xMin = scale(xMid - lowBound), yMin = yMid + width, xMax = scale(xMid + highBound), + yMax = yMid - width, coordsTop = { + x1: xMax, + y1: yMin, + x2: xMax, + y2: yMax + }, coordsMid = { + x1: xMin, + y1: yMid, + x2: xMax, + y2: yMid + }, coordsBot = { + x1: xMin, + y1: yMin, + x2: xMin, + y2: yMax + }) : "horizontal" === layout && (scale = yAxis.scale, xMid = x + offset, yMid = value, + xMin = xMid - width, xMax = xMid + width, yMin = scale(yMid - lowBound), yMax = scale(yMid + highBound), + coordsTop = { + x1: xMin, + y1: yMax, + x2: xMax, + y2: yMax + }, coordsMid = { + x1: xMid, + y1: yMin, + x2: xMid, + y2: yMax + }, coordsBot = { + x1: xMin, + y1: yMin, + x2: xMax, + y2: yMin + }), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__container_Layer__.a, _extends({ + className: "recharts-errorBar", + key: i + }, props), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsTop), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsMid), __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement("line", coordsBot)); + }); + } + }, { + key: "render", + value: function() { + return __WEBPACK_IMPORTED_MODULE_0_react___default.a.createElement(__WEBPACK_IMPORTED_MODULE_2__container_Layer__.a, { + className: "recharts-errorBars" + }, this.renderErrorBars()); + } + } ]), ErrorBar; + }(__WEBPACK_IMPORTED_MODULE_0_react__.Component), _class.propTypes = { + dataKey: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.oneOfType([ __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func ]).isRequired, + data: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.array, + xAxis: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, + yAxis: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.object, + layout: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + dataPointFormatter: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.func, + stroke: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.string, + strokeWidth: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + width: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number, + offset: __WEBPACK_IMPORTED_MODULE_1_prop_types___default.a.number + }, _class.defaultProps = { + stroke: "black", + strokeWidth: 1.5, + width: 5, + offset: 0, + layout: "horizontal" + }, _temp); + __webpack_exports__.a = ErrorBar; +}, function(module, __webpack_exports__, __webpack_require__) { + "use strict"; + function _defineProperty(obj, key, value) { + return key in obj ? Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }) : obj[key] = value, obj; + } + __webpack_require__.d(__webpack_exports__, "a", function() { + return formatAxisMap; + }); + var __WEBPACK_IMPORTED_MODULE_0__ChartUtils__ = __webpack_require__(21), _extends = Object.assign || function(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]); + } + return target; + }, formatAxisMap = function(props, axisMap, offset, axisType, chartName) { + var width = props.width, height = props.height, layout = props.layout, ids = Object.keys(axisMap), steps = { + left: offset.left, + leftMirror: offset.left, + right: width - offset.right, + rightMirror: width - offset.right, + top: offset.top, + topMirror: offset.top, + bottom: height - offset.bottom, + bottomMirror: height - offset.bottom + }; + return ids.reduce(function(result, id) { + var axis = axisMap[id], orientation = axis.orientation, domain = axis.domain, _axis$padding = axis.padding, padding = void 0 === _axis$padding ? {} : _axis$padding, mirror = axis.mirror, reversed = axis.reversed, offsetKey = orientation + (mirror ? "Mirror" : ""), range = void 0, x = void 0, y = void 0, needSpace = void 0; + range = "xAxis" === axisType ? [ offset.left + (padding.left || 0), offset.left + offset.width - (padding.right || 0) ] : "yAxis" === axisType ? "horizontal" === layout ? [ offset.top + offset.height - (padding.bottom || 0), offset.top + (padding.top || 0) ] : [ offset.top + (padding.top || 0), offset.top + offset.height - (padding.bottom || 0) ] : axis.range, + reversed && (range = [ range[1], range[0] ]); + var _parseScale = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.A)(axis, chartName), scale = _parseScale.scale, realScaleType = _parseScale.realScaleType; + scale.domain(domain).range(range), Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.c)(scale); + var ticks = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.v)(scale, _extends({}, axis, { + realScaleType: realScaleType + })); + "xAxis" === axisType ? (needSpace = "top" === orientation && !mirror || "bottom" === orientation && mirror, + x = offset.left, y = steps[offsetKey] - needSpace * axis.height) : "yAxis" === axisType && (needSpace = "left" === orientation && !mirror || "right" === orientation && mirror, + x = steps[offsetKey] - needSpace * axis.width, y = offset.top); + var finalAxis = _extends({}, axis, ticks, { + realScaleType: realScaleType, + x: x, + y: y, + scale: scale, + width: "xAxis" === axisType ? offset.width : axis.width, + height: "yAxis" === axisType ? offset.height : axis.height + }); + return finalAxis.bandSize = Object(__WEBPACK_IMPORTED_MODULE_0__ChartUtils__.g)(finalAxis, ticks), + axis.hide || "xAxis" !== axisType ? axis.hide || (steps[offsetKey] += (needSpace ? -1 : 1) * finalAxis.width) : steps[offsetKey] += (needSpace ? -1 : 1) * finalAxis.height, + _extends({}, result, _defineProperty({}, id, finalAxis)); + }, {}); + }; +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + var emptyObject = {}; + "production" !== process.env.NODE_ENV && Object.freeze(emptyObject), module.exports = emptyObject; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + var emptyFunction = __webpack_require__(55), warning = emptyFunction; + if ("production" !== process.env.NODE_ENV) { + var printWarning = function(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key]; + var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + "undefined" != typeof console && console.error(message); + try { + throw new Error(message); + } catch (x) {} + }; + warning = function(condition, format) { + if (void 0 === format) throw new Error("` + "`")) + (`warning(condition, format, ...args)` + ("`" + ` requires a warning message argument"); + if (0 !== format.indexOf("Failed Composite propType: ") && !condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2]; + printWarning.apply(void 0, [ format ].concat(args)); + } + }; + } + module.exports = warning; + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + (function(process) { + function checkDCE() { + if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE) { + if ("production" !== process.env.NODE_ENV) throw new Error("^_^"); + try { + __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE); + } catch (err) { + console.error(err); + } + } + } + "production" === process.env.NODE_ENV ? (checkDCE(), module.exports = __webpack_require__(456)) : module.exports = __webpack_require__(459); + }).call(exports, __webpack_require__(3)); +}, function(module, exports, __webpack_require__) { + "use strict"; + function is(x, y) { + return x === y ? 0 !== x || 0 !== y || 1 / x == 1 / y : x !== x && y !== y; + } + function shallowEqual(objA, objB) { + if (is(objA, objB)) return !0; + if ("object" != typeof objA || null === objA || "object" != typeof objB || null === objB) return !1; + var keysA = Object.keys(objA), keysB = Object.keys(objB); + if (keysA.length !== keysB.length) return !1; + for (var i = 0; i < keysA.length; i++) if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) return !1; + return !0; + } + var hasOwnProperty = Object.prototype.hasOwnProperty; + module.exports = shallowEqual; +}, function(module, exports, __webpack_require__) { + var toInteger = __webpack_require__(180), min = Math.min; + module.exports = function(it) { + return it > 0 ? min(toInteger(it), 9007199254740991) : 0; + }; +}, function(module, exports) { + var id = 0, px = Math.random(); + module.exports = function(key) { + return "Symbol(".concat(void 0 === key ? "" : key, ")_", (++id + px).toString(36)); + }; +}, function(module, exports) { + exports.f = {}.propertyIsEnumerable; +}, function(module, exports, __webpack_require__) { + "use strict"; + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + exports.__esModule = !0; + var _iterator = __webpack_require__(474), _iterator2 = _interopRequireDefault(_iterator), _symbol = __webpack_require__(482), _symbol2 = _interopRequireDefault(_symbol), _typeof = "function" == typeof _symbol2.default && "symbol" == typeof _iterator2.default ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && "function" == typeof _symbol2.default && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : typeof obj; + }; + exports.default = "function" == typeof _symbol2.default && "symbol" === _typeof(_iterator2.default) ? function(obj) { + return void 0 === obj ? "undefined" : _typeof(obj); + } : function(obj) { + return obj && "function" == typeof _symbol2.default && obj.constructor === _symbol2.default && obj !== _symbol2.default.prototype ? "symbol" : void 0 === obj ? "undefined" : _typeof(obj); + }; +}, function(module, exports, __webpack_require__) { + var anObject = __webpack_require__(65), dPs = __webpack_require__(478), enumBugKeys = __webpack_require__(183), IE_PROTO = __webpack_require__(181)("IE_PROTO"), Empty = function() {}, createDict = function() { + var iframeDocument, iframe = __webpack_require__(271)("iframe"), i = enumBugKeys.length; + for (iframe.style.display = "none", __webpack_require__(479).appendChild(iframe), + iframe.src = "javascript:", iframeDocument = iframe.contentWindow.document, iframeDocument.open(), + iframeDocument.write(" + + +`) func publicDashboardHtmlBytes() ([]byte, error) { - return bindataRead( - _publicDashboardHtml, - "public/dashboard.html", - ) + return _publicDashboardHtml, nil } func publicDashboardHtml() (*asset, error) { diff --git a/dashboard/assets/.eslintrc b/dashboard/assets/.eslintrc index 04ae15d013..67c11dcc05 100644 --- a/dashboard/assets/.eslintrc +++ b/dashboard/assets/.eslintrc @@ -16,37 +16,68 @@ // React syntax style mostly according to https://github.com/airbnb/javascript/tree/master/react { - "plugins": [ - "react" - ], - "parser": "babel-eslint", - "parserOptions": { - "ecmaFeatures": { - "jsx": true, - "modules": true - } - }, - "rules": { - "react/prefer-es6-class": 2, - "react/prefer-stateless-function": 2, - "react/jsx-pascal-case": 2, - "react/jsx-closing-bracket-location": [1, {"selfClosing": "tag-aligned", "nonEmpty": "tag-aligned"}], - "react/jsx-closing-tag-location": 1, - "jsx-quotes": ["error", "prefer-double"], - "no-multi-spaces": "error", - "react/jsx-tag-spacing": 2, - "react/jsx-curly-spacing": [2, {"when": "never", "children": true}], - "react/jsx-boolean-value": 2, - "react/no-string-refs": 2, - "react/jsx-wrap-multilines": 2, - "react/self-closing-comp": 2, - "react/jsx-no-bind": 2, - "react/require-render-return": 2, - "react/no-is-mounted": 2, - "key-spacing": ["error", {"align": { - "beforeColon": false, - "afterColon": true, - "on": "value" - }}] - } + 'env': { + 'browser': true, + 'node': true, + 'es6': true, + }, + 'parser': 'babel-eslint', + 'parserOptions': { + 'sourceType': 'module', + 'ecmaVersion': 6, + 'ecmaFeatures': { + 'jsx': true, + } + }, + 'extends': 'airbnb', + 'plugins': [ + 'flowtype', + 'react', + ], + 'rules': { + 'no-tabs': 'off', + 'indent': ['error', 'tab'], + 'react/jsx-indent': ['error', 'tab'], + 'react/jsx-indent-props': ['error', 'tab'], + 'react/prefer-stateless-function': 'off', + + // Specifies the maximum length of a line. + 'max-len': ['warn', 120, 2, { + 'ignoreUrls': true, + 'ignoreComments': false, + 'ignoreRegExpLiterals': true, + 'ignoreStrings': true, + 'ignoreTemplateLiterals': true, + }], + // Enforces spacing between keys and values in object literal properties. + 'key-spacing': ['error', {'align': { + 'beforeColon': false, + 'afterColon': true, + 'on': 'value' + }}], + // Prohibits padding inside curly braces. + 'object-curly-spacing': ['error', 'never'], + 'no-use-before-define': 'off', // messageAPI + 'default-case': 'off', + + 'flowtype/boolean-style': ['error', 'boolean'], + 'flowtype/define-flow-type': 'warn', + 'flowtype/generic-spacing': ['error', 'never'], + 'flowtype/no-primitive-constructor-types': 'error', + 'flowtype/no-weak-types': 'error', + 'flowtype/object-type-delimiter': ['error', 'comma'], + 'flowtype/require-valid-file-annotation': 'error', + 'flowtype/semi': ['error', 'always'], + 'flowtype/space-after-type-colon': ['error', 'always'], + 'flowtype/space-before-generic-bracket': ['error', 'never'], + 'flowtype/space-before-type-colon': ['error', 'never'], + 'flowtype/union-intersection-spacing': ['error', 'always'], + 'flowtype/use-flow-type': 'warn', + 'flowtype/valid-syntax': 'warn', + }, + 'settings': { + 'flowtype': { + 'onlyFilesWithFlowAnnotation': true, + } + }, } diff --git a/dashboard/assets/.flowconfig b/dashboard/assets/.flowconfig new file mode 100644 index 0000000000..8051ae5de5 --- /dev/null +++ b/dashboard/assets/.flowconfig @@ -0,0 +1,9 @@ +[ignore] +/node_modules/material-ui/.*\.js\.flow + +[libs] +/flow-typed/ +node_modules/jss/flow-typed + +[options] +include_warnings=true diff --git a/dashboard/assets/components/Body.jsx b/dashboard/assets/components/Body.jsx new file mode 100644 index 0000000000..14e9ac3585 --- /dev/null +++ b/dashboard/assets/components/Body.jsx @@ -0,0 +1,64 @@ +// @flow + +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +import React, {Component} from 'react'; + +import withStyles from 'material-ui/styles/withStyles'; + +import SideBar from './SideBar'; +import Main from './Main'; +import type {Content} from '../types/content'; + +// Styles for the Body component. +const styles = () => ({ + body: { + display: 'flex', + width: '100%', + height: '100%', + }, +}); +export type Props = { + classes: Object, + opened: boolean, + changeContent: () => {}, + active: string, + content: Content, + shouldUpdate: Object, +}; +// Body renders the body of the dashboard. +class Body extends Component { + render() { + const {classes} = this.props; // The classes property is injected by withStyles(). + + return ( +
+ +
+
+ ); + } +} + +export default withStyles(styles)(Body); diff --git a/dashboard/assets/components/ChartGrid.jsx b/dashboard/assets/components/ChartGrid.jsx new file mode 100644 index 0000000000..45dde7499e --- /dev/null +++ b/dashboard/assets/components/ChartGrid.jsx @@ -0,0 +1,49 @@ +// @flow + +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +import React, {Component} from 'react'; +import type {Node} from 'react'; + +import Grid from 'material-ui/Grid'; +import {ResponsiveContainer} from 'recharts'; + +export type Props = { + spacing: number, + children: Node, +}; +// ChartGrid renders a grid container for responsive charts. +// The children are Recharts components extended with the Material-UI's xs property. +class ChartGrid extends Component { + render() { + return ( + + { + React.Children.map(this.props.children, child => ( + + + {React.cloneElement(child, {data: child.props.values.map(value => ({value}))})} + + + )) + } + + ); + } +} + +export default ChartGrid; diff --git a/dashboard/assets/components/Common.jsx b/dashboard/assets/components/Common.jsx index 5129939c5a..d8723830e9 100644 --- a/dashboard/assets/components/Common.jsx +++ b/dashboard/assets/components/Common.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -14,39 +16,78 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -// isNullOrUndefined returns true if the given variable is null or undefined. -export const isNullOrUndefined = variable => variable === null || typeof variable === 'undefined'; - -export const LIMIT = { - memory: 200, // Maximum number of memory data samples. - traffic: 200, // Maximum number of traffic data samples. - log: 200, // Maximum number of logs. -}; +type ProvidedMenuProp = {|title: string, icon: string|}; +const menuSkeletons: Array<{|id: string, menu: ProvidedMenuProp|}> = [ + { + id: 'home', + menu: { + title: 'Home', + icon: 'home', + }, + }, { + id: 'chain', + menu: { + title: 'Chain', + icon: 'link', + }, + }, { + id: 'txpool', + menu: { + title: 'TxPool', + icon: 'credit-card', + }, + }, { + id: 'network', + menu: { + title: 'Network', + icon: 'globe', + }, + }, { + id: 'system', + menu: { + title: 'System', + icon: 'tachometer', + }, + }, { + id: 'logs', + menu: { + title: 'Logs', + icon: 'list', + }, + }, +]; +export type MenuProp = {|...ProvidedMenuProp, id: string|}; // The sidebar menu and the main content are rendered based on these elements. -export const TAGS = (() => { - const T = { - home: { title: "Home", }, - chain: { title: "Chain", }, - transactions: { title: "Transactions", }, - network: { title: "Network", }, - system: { title: "System", }, - logs: { title: "Logs", }, - }; - // Using the key is circumstantial in some cases, so it is better to insert it also as a value. - // This way the mistyping is prevented. - for(let key in T) { - T[key]['id'] = key; - } - return T; -})(); +// Using the id is circumstantial in some cases, so it is better to insert it also as a value. +// This way the mistyping is prevented. +export const MENU: Map = new Map(menuSkeletons.map(({id, menu}) => ([id, {id, ...menu}]))); -export const DATA_KEYS = (() => { - const DK = {}; - ["memory", "traffic", "logs"].map(key => { - DK[key] = key; - }); - return DK; -})(); +type ProvidedSampleProp = {|limit: number|}; +const sampleSkeletons: Array<{|id: string, sample: ProvidedSampleProp|}> = [ + { + id: 'memory', + sample: { + limit: 200, + }, + }, { + id: 'traffic', + sample: { + limit: 200, + }, + }, { + id: 'logs', + sample: { + limit: 200, + }, + }, +]; +export type SampleProp = {|...ProvidedSampleProp, id: string|}; +export const SAMPLE: Map = new Map(sampleSkeletons.map(({id, sample}) => ([id, {id, ...sample}]))); -// Temporary - taken from Material-UI -export const DRAWER_WIDTH = 240; +export const DURATION = 200; + +export const LENS: Map = new Map([ + 'content', + ...menuSkeletons.map(({id}) => id), + ...sampleSkeletons.map(({id}) => id), +].map(lens => [lens, lens])); diff --git a/dashboard/assets/components/Dashboard.jsx b/dashboard/assets/components/Dashboard.jsx index 740acf9592..b60736d8c0 100644 --- a/dashboard/assets/components/Dashboard.jsx +++ b/dashboard/assets/components/Dashboard.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,155 +17,183 @@ // along with the go-ethereum library. If not, see . import React, {Component} from 'react'; -import PropTypes from 'prop-types'; -import {withStyles} from 'material-ui/styles'; -import SideBar from './SideBar.jsx'; -import Header from './Header.jsx'; -import Main from "./Main.jsx"; -import {isNullOrUndefined, LIMIT, TAGS, DATA_KEYS,} from "./Common.jsx"; +import withStyles from 'material-ui/styles/withStyles'; +import {lensPath, view, set} from 'ramda'; -// Styles for the Dashboard component. +import Header from './Header'; +import Body from './Body'; +import {MENU, SAMPLE} from './Common'; +import type {Message, HomeMessage, LogsMessage, Chart} from '../types/message'; +import type {Content} from '../types/content'; + +// appender appends an array (A) to the end of another array (B) in the state. +// lens is the path of B in the state, samples is A, and limit is the maximum size of the changed array. +// +// appender retrieves a function, which overrides the state's value at lens, and returns with the overridden state. +const appender = (lens, samples, limit) => (state) => { + const newSamples = [ + ...view(lens, state), // retrieves a specific value of the state at the given path (lens). + ...samples, + ]; + // set is a function of ramda.js, which needs the path, the new value, the original state, and retrieves + // the altered state. + return set( + lens, + newSamples.slice(newSamples.length > limit ? newSamples.length - limit : 0), + state + ); +}; +// Lenses for specific data fields in the state, used for a clearer deep update. +// NOTE: This solution will be changed very likely. +const memoryLens = lensPath(['content', 'home', 'memory']); +const trafficLens = lensPath(['content', 'home', 'traffic']); +const logLens = lensPath(['content', 'logs', 'log']); +// styles retrieves the styles for the Dashboard component. const styles = theme => ({ - appFrame: { - position: 'relative', - display: 'flex', - width: '100%', - height: '100%', - background: theme.palette.background.default, - }, + dashboard: { + display: 'flex', + flexFlow: 'column', + width: '100%', + height: '100%', + background: theme.palette.background.default, + zIndex: 1, + overflow: 'hidden', + }, }); +export type Props = { + classes: Object, +}; +type State = { + active: string, // active menu + sideBar: boolean, // true if the sidebar is opened + content: $Shape, // the visualized data + shouldUpdate: Set // labels for the components, which need to rerender based on the incoming message +}; +// Dashboard is the main component, which renders the whole page, makes connection with the server and +// listens for messages. When there is an incoming message, updates the page's content correspondingly. +class Dashboard extends Component { + constructor(props: Props) { + super(props); + this.state = { + active: MENU.get('home').id, + sideBar: true, + content: {home: {memory: [], traffic: []}, logs: {log: []}}, + shouldUpdate: new Set(), + }; + } -// Dashboard is the main component, which renders the whole page, makes connection with the server and listens for messages. -// When there is an incoming message, updates the page's content correspondingly. -class Dashboard extends Component { - constructor(props) { - super(props); - this.state = { - active: TAGS.home.id, // active menu - sideBar: true, // true if the sidebar is opened - memory: [], - traffic: [], - logs: [], - shouldUpdate: {}, - }; - } + // componentDidMount initiates the establishment of the first websocket connection after the component is rendered. + componentDidMount() { + this.reconnect(); + } - // componentDidMount initiates the establishment of the first websocket connection after the component is rendered. - componentDidMount() { - this.reconnect(); - } + // reconnect establishes a websocket connection with the server, listens for incoming messages + // and tries to reconnect on connection loss. + reconnect = () => { + this.setState({ + content: {home: {memory: [], traffic: []}, logs: {log: []}}, + }); + const server = new WebSocket(`${((window.location.protocol === 'https:') ? 'wss://' : 'ws://') + window.location.host}/api`); + server.onmessage = (event) => { + const msg: Message = JSON.parse(event.data); + if (!msg) { + return; + } + this.update(msg); + }; + server.onclose = () => { + setTimeout(this.reconnect, 3000); + }; + }; - // reconnect establishes a websocket connection with the server, listens for incoming messages - // and tries to reconnect on connection loss. - reconnect = () => { - const server = new WebSocket(((window.location.protocol === "https:") ? "wss://" : "ws://") + window.location.host + "/api"); + // samples retrieves the raw data of a chart field from the incoming message. + samples = (chart: Chart) => { + let s = []; + if (chart.history) { + s = chart.history.map(({value}) => (value || 0)); // traffic comes without value at the beginning + } + if (chart.new) { + s = [...s, chart.new.value || 0]; + } + return s; + }; - server.onmessage = event => { - const msg = JSON.parse(event.data); - if (isNullOrUndefined(msg)) { - return; - } - this.update(msg); - }; + // handleHome changes the home-menu related part of the state. + handleHome = (home: HomeMessage) => { + this.setState((prevState) => { + let newState = prevState; + newState.shouldUpdate = new Set(); + if (home.memory) { + newState = appender(memoryLens, this.samples(home.memory), SAMPLE.get('memory').limit)(newState); + newState.shouldUpdate.add('memory'); + } + if (home.traffic) { + newState = appender(trafficLens, this.samples(home.traffic), SAMPLE.get('traffic').limit)(newState); + newState.shouldUpdate.add('traffic'); + } + return newState; + }); + }; - server.onclose = () => { - setTimeout(this.reconnect, 3000); - }; - }; + // handleLogs changes the logs-menu related part of the state. + handleLogs = (logs: LogsMessage) => { + this.setState((prevState) => { + let newState = prevState; + newState.shouldUpdate = new Set(); + if (logs.log) { + newState = appender(logLens, [logs.log], SAMPLE.get('logs').limit)(newState); + newState.shouldUpdate.add('logs'); + } + return newState; + }); + }; - // update analyzes the incoming message, and updates the charts' content correspondingly. - update = msg => { - console.log(msg); - this.setState(prevState => { - let newState = []; - newState.shouldUpdate = {}; - const insert = (key, values, limit) => { - newState[key] = [...prevState[key], ...values]; - while (newState[key].length > limit) { - newState[key].shift(); - } - newState.shouldUpdate[key] = true; - }; - // (Re)initialize the state with the past data. - if (!isNullOrUndefined(msg.history)) { - const memory = DATA_KEYS.memory; - const traffic = DATA_KEYS.traffic; - newState[memory] = []; - newState[traffic] = []; - if (!isNullOrUndefined(msg.history.memorySamples)) { - newState[memory] = msg.history.memorySamples.map(elem => isNullOrUndefined(elem.value) ? 0 : elem.value); - while (newState[memory].length > LIMIT.memory) { - newState[memory].shift(); - } - newState.shouldUpdate[memory] = true; - } - if (!isNullOrUndefined(msg.history.trafficSamples)) { - newState[traffic] = msg.history.trafficSamples.map(elem => isNullOrUndefined(elem.value) ? 0 : elem.value); - while (newState[traffic].length > LIMIT.traffic) { - newState[traffic].shift(); - } - newState.shouldUpdate[traffic] = true; - } - } - // Insert the new data samples. - if (!isNullOrUndefined(msg.memory)) { - insert(DATA_KEYS.memory, [isNullOrUndefined(msg.memory.value) ? 0 : msg.memory.value], LIMIT.memory); - } - if (!isNullOrUndefined(msg.traffic)) { - insert(DATA_KEYS.traffic, [isNullOrUndefined(msg.traffic.value) ? 0 : msg.traffic.value], LIMIT.traffic); - } - if (!isNullOrUndefined(msg.log)) { - insert(DATA_KEYS.logs, [msg.log], LIMIT.log); - } + // update analyzes the incoming message, and updates the charts' content correspondingly. + update = (msg: Message) => { + if (msg.home) { + this.handleHome(msg.home); + } + if (msg.logs) { + this.handleLogs(msg.logs); + } + }; - return newState; - }); - }; + // changeContent sets the active label, which is used at the content rendering. + changeContent = (newActive: string) => { + this.setState(prevState => (prevState.active !== newActive ? {active: newActive} : {})); + }; - // The change of the active label on the SideBar component will trigger a new render in the Main component. - changeContent = active => { - this.setState(prevState => prevState.active !== active ? {active: active} : {}); - }; + // openSideBar opens the sidebar. + openSideBar = () => { + this.setState({sideBar: true}); + }; - openSideBar = () => { - this.setState({sideBar: true}); - }; + // closeSideBar closes the sidebar. + closeSideBar = () => { + this.setState({sideBar: false}); + }; - closeSideBar = () => { - this.setState({sideBar: false}); - }; + render() { + const {classes} = this.props; // The classes property is injected by withStyles(). - render() { - // The classes property is injected by withStyles(). - const {classes} = this.props; - - return ( -
-
- -
-
- ); - } + return ( +
+
+ +
+ ); + } } -Dashboard.propTypes = { - classes: PropTypes.object.isRequired, -}; - export default withStyles(styles)(Dashboard); diff --git a/dashboard/assets/components/Header.jsx b/dashboard/assets/components/Header.jsx index 7cf57c9c03..e29507bef0 100644 --- a/dashboard/assets/components/Header.jsx +++ b/dashboard/assets/components/Header.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,73 +17,89 @@ // along with the go-ethereum library. If not, see . import React, {Component} from 'react'; -import PropTypes from 'prop-types'; -import classNames from 'classnames'; -import {withStyles} from 'material-ui/styles'; + +import withStyles from 'material-ui/styles/withStyles'; import AppBar from 'material-ui/AppBar'; import Toolbar from 'material-ui/Toolbar'; -import Typography from 'material-ui/Typography'; +import Transition from 'react-transition-group/Transition'; import IconButton from 'material-ui/IconButton'; -import MenuIcon from 'material-ui-icons/Menu'; +import Typography from 'material-ui/Typography'; +import ChevronLeftIcon from 'material-ui-icons/ChevronLeft'; -import {DRAWER_WIDTH} from './Common.jsx'; +import {DURATION} from './Common'; +// arrowDefault is the default style of the arrow button. +const arrowDefault = { + transition: `transform ${DURATION}ms`, +}; +// arrowTransition is the additional style of the arrow button corresponding to the transition's state. +const arrowTransition = { + entered: {transform: 'rotate(180deg)'}, +}; // Styles for the Header component. const styles = theme => ({ - appBar: { - position: 'absolute', - transition: theme.transitions.create(['margin', 'width'], { - easing: theme.transitions.easing.sharp, - duration: theme.transitions.duration.leavingScreen, - }), - }, - appBarShift: { - marginLeft: DRAWER_WIDTH, - width: `calc(100% - ${DRAWER_WIDTH}px)`, - transition: theme.transitions.create(['margin', 'width'], { - easing: theme.transitions.easing.easeOut, - duration: theme.transitions.duration.enteringScreen, - }), - }, - menuButton: { - marginLeft: 12, - marginRight: 20, - }, - hide: { - display: 'none', - }, + header: { + backgroundColor: theme.palette.background.appBar, + color: theme.palette.getContrastText(theme.palette.background.appBar), + zIndex: theme.zIndex.appBar, + }, + toolbar: { + paddingLeft: theme.spacing.unit, + paddingRight: theme.spacing.unit, + }, + mainText: { + paddingLeft: theme.spacing.unit, + }, }); +export type Props = { + classes: Object, + opened: boolean, + openSideBar: () => {}, + closeSideBar: () => {}, +}; +// Header renders the header of the dashboard. +class Header extends Component { + shouldComponentUpdate(nextProps) { + return nextProps.opened !== this.props.opened; + } -// Header renders a header, which contains a sidebar opener icon when that is closed. -class Header extends Component { - render() { - // The classes property is injected by withStyles(). - const {classes} = this.props; + // changeSideBar opens or closes the sidebar corresponding to the previous state. + changeSideBar = () => { + if (this.props.opened) { + this.props.closeSideBar(); + } else { + this.props.openSideBar(); + } + }; - return ( - - - - - - - Go Ethereum Dashboard - - - - ); - } + // arrowButton is connected to the sidebar; changes its state. + arrowButton = (transitionState: string) => ( + + + + ); + + render() { + const {classes, opened} = this.props; // The classes property is injected by withStyles(). + + return ( + + + + {this.arrowButton} + + + Go Ethereum Dashboard + + + + ); + } } -Header.propTypes = { - classes: PropTypes.object.isRequired, - opened: PropTypes.bool.isRequired, - open: PropTypes.func.isRequired, -}; - export default withStyles(styles)(Header); diff --git a/dashboard/assets/components/Home.jsx b/dashboard/assets/components/Home.jsx index f67bac5559..d3e1004f90 100644 --- a/dashboard/assets/components/Home.jsx +++ b/dashboard/assets/components/Home.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,75 +17,56 @@ // along with the go-ethereum library. If not, see . import React, {Component} from 'react'; -import PropTypes from 'prop-types'; -import Grid from 'material-ui/Grid'; -import {LineChart, AreaChart, Area, YAxis, CartesianGrid, Line, ResponsiveContainer} from 'recharts'; -import {withTheme} from 'material-ui/styles'; -import {isNullOrUndefined, DATA_KEYS} from "./Common.jsx"; +import withTheme from 'material-ui/styles/withTheme'; +import {LineChart, AreaChart, Area, YAxis, CartesianGrid, Line} from 'recharts'; -// ChartGrid renders a grid container for responsive charts. -// The children are Recharts components extended with the Material-UI's xs property. -class ChartGrid extends Component { - render() { - return ( - - { - React.Children.map(this.props.children, child => ( - - - {React.cloneElement(child, {data: child.props.values.map(value => ({value: value}))})} - - - )) - } - - ); - } -} +import ChartGrid from './ChartGrid'; +import type {ChartEntry} from '../types/message'; -ChartGrid.propTypes = { - spacing: PropTypes.number.isRequired, +export type Props = { + theme: Object, + memory: Array, + traffic: Array, + shouldUpdate: Object, }; +// Home renders the home content. +class Home extends Component { + constructor(props: Props) { + super(props); + const {theme} = props; // The theme property is injected by withTheme(). + this.memoryColor = theme.palette.primary[300]; + this.trafficColor = theme.palette.secondary[300]; + } -// Home renders the home component. -class Home extends Component { - shouldComponentUpdate(nextProps) { - return !isNullOrUndefined(nextProps.shouldUpdate[DATA_KEYS.memory]) || - !isNullOrUndefined(nextProps.shouldUpdate[DATA_KEYS.traffic]); - } + shouldComponentUpdate(nextProps) { + return nextProps.shouldUpdate.has('memory') || nextProps.shouldUpdate.has('traffic'); + } - render() { - const {theme} = this.props; - const memoryColor = theme.palette.primary[300]; - const trafficColor = theme.palette.secondary[300]; + render() { + const {memory, traffic} = this.props; - return ( - - - - - - - - - - - - - - - - - - - ); - } + return ( + + + + + + + + + + + + + + + + + + + ); + } } -Home.propTypes = { - theme: PropTypes.object.isRequired, - shouldUpdate: PropTypes.object.isRequired, -}; - export default withTheme()(Home); diff --git a/dashboard/assets/components/Main.jsx b/dashboard/assets/components/Main.jsx index b119d1ffd5..6f1668a29f 100644 --- a/dashboard/assets/components/Main.jsx +++ b/dashboard/assets/components/Main.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,95 +17,52 @@ // along with the go-ethereum library. If not, see . import React, {Component} from 'react'; -import PropTypes from 'prop-types'; -import classNames from 'classnames'; -import {withStyles} from 'material-ui/styles'; -import {TAGS, DRAWER_WIDTH} from "./Common.jsx"; -import Home from './Home.jsx'; +import withStyles from 'material-ui/styles/withStyles'; -// ContentSwitch chooses and renders the proper page content. -class ContentSwitch extends Component { - render() { - switch(this.props.active) { - case TAGS.home.id: - return ; - case TAGS.chain.id: - return null; - case TAGS.transactions.id: - return null; - case TAGS.network.id: - // Only for testing. - return null; - case TAGS.system.id: - return null; - case TAGS.logs.id: - return
{this.props.logs.map((log, index) =>
{log}
)}
; - } - return null; - } -} +import Home from './Home'; +import {MENU} from './Common'; +import type {Content} from '../types/content'; -ContentSwitch.propTypes = { - active: PropTypes.string.isRequired, - shouldUpdate: PropTypes.object.isRequired, -}; - -// styles contains the styles for the Main component. +// Styles for the Content component. const styles = theme => ({ - content: { - width: '100%', - marginLeft: -DRAWER_WIDTH, - flexGrow: 1, - backgroundColor: theme.palette.background.default, - padding: theme.spacing.unit * 3, - transition: theme.transitions.create('margin', { - easing: theme.transitions.easing.sharp, - duration: theme.transitions.duration.leavingScreen, - }), - marginTop: 56, - overflow: 'auto', - [theme.breakpoints.up('sm')]: { - content: { - height: 'calc(100% - 64px)', - marginTop: 64, - }, - }, - }, - contentShift: { - marginLeft: 0, - transition: theme.transitions.create('margin', { - easing: theme.transitions.easing.easeOut, - duration: theme.transitions.duration.enteringScreen, - }), - }, + content: { + flexGrow: 1, + backgroundColor: theme.palette.background.default, + padding: theme.spacing.unit * 3, + overflow: 'auto', + }, }); - -// Main renders a component for the page content. -class Main extends Component { - render() { - // The classes property is injected by withStyles(). - const {classes} = this.props; - - return ( -
- -
- ); - } -} - -Main.propTypes = { - classes: PropTypes.object.isRequired, - opened: PropTypes.bool.isRequired, - active: PropTypes.string.isRequired, - shouldUpdate: PropTypes.object.isRequired, +export type Props = { + classes: Object, + active: string, + content: Content, + shouldUpdate: Object, }; +// Main renders the chosen content. +class Main extends Component { + render() { + const { + classes, active, content, shouldUpdate, + } = this.props; + + let children = null; + switch (active) { + case MENU.get('home').id: + children = ; + break; + case MENU.get('chain').id: + case MENU.get('txpool').id: + case MENU.get('network').id: + case MENU.get('system').id: + children =
Work in progress.
; + break; + case MENU.get('logs').id: + children =
{content.logs.log.map((log, index) =>
{log}
)}
; + } + + return
{children}
; + } +} export default withStyles(styles)(Main); diff --git a/dashboard/assets/components/SideBar.jsx b/dashboard/assets/components/SideBar.jsx index ef077f1e0e..319e6f3057 100644 --- a/dashboard/assets/components/SideBar.jsx +++ b/dashboard/assets/components/SideBar.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,92 +17,106 @@ // along with the go-ethereum library. If not, see . import React, {Component} from 'react'; -import PropTypes from 'prop-types'; -import {withStyles} from 'material-ui/styles'; -import Drawer from 'material-ui/Drawer'; -import {IconButton} from "material-ui"; -import List, {ListItem, ListItemText} from 'material-ui/List'; -import ChevronLeftIcon from 'material-ui-icons/ChevronLeft'; -import {TAGS, DRAWER_WIDTH} from './Common.jsx'; +import withStyles from 'material-ui/styles/withStyles'; +import List, {ListItem, ListItemIcon, ListItemText} from 'material-ui/List'; +import Icon from 'material-ui/Icon'; +import Transition from 'react-transition-group/Transition'; +import {Icon as FontAwesome} from 'react-fa'; +import {MENU, DURATION} from './Common'; + +// menuDefault is the default style of the menu. +const menuDefault = { + transition: `margin-left ${DURATION}ms`, +}; +// menuTransition is the additional style of the menu corresponding to the transition's state. +const menuTransition = { + entered: {marginLeft: -200}, +}; // Styles for the SideBar component. const styles = theme => ({ - drawerPaper: { - position: 'relative', - height: '100%', - width: DRAWER_WIDTH, - }, - drawerHeader: { - display: 'flex', - alignItems: 'center', - justifyContent: 'flex-end', - padding: '0 8px', - ...theme.mixins.toolbar, - transitionDuration: { - enter: theme.transitions.duration.enteringScreen, - exit: theme.transitions.duration.leavingScreen, - } - }, + list: { + background: theme.palette.background.appBar, + }, + listItem: { + minWidth: theme.spacing.unit * 3, + }, + icon: { + fontSize: theme.spacing.unit * 3, + }, }); +export type Props = { + classes: Object, + opened: boolean, + changeContent: () => {}, +}; +// SideBar renders the sidebar of the dashboard. +class SideBar extends Component { + constructor(props) { + super(props); -// SideBar renders a sidebar component. -class SideBar extends Component { - constructor(props) { - super(props); + // clickOn contains onClick event functions for the menu items. + // Instantiate only once, and reuse the existing functions to prevent the creation of + // new function instances every time the render method is triggered. + this.clickOn = {}; + MENU.forEach((menu) => { + this.clickOn[menu.id] = (event) => { + event.preventDefault(); + props.changeContent(menu.id); + }; + }); + } - // clickOn contains onClick event functions for the menu items. - // Instantiate only once, and reuse the existing functions to prevent the creation of - // new function instances every time the render method is triggered. - this.clickOn = {}; - for(let key in TAGS) { - const id = TAGS[key].id; - this.clickOn[id] = event => { - event.preventDefault(); - console.log(event.target.key); - this.props.changeContent(id); - }; - } - } + shouldComponentUpdate(nextProps) { + return nextProps.opened !== this.props.opened; + } - render() { - // The classes property is injected by withStyles(). - const {classes} = this.props; + menuItems = (transitionState) => { + const {classes} = this.props; + const children = []; + MENU.forEach((menu) => { + children.push( + + + + + + + + , + ); + }); + return children; + }; - return ( - -
-
- - - -
- - { - Object.values(TAGS).map(tag => { - return ( - - - - ); - }) - } - -
- - ); - } + // menu renders the list of the menu items. + menu = (transitionState) => { + const {classes} = this.props; // The classes property is injected by withStyles(). + + return ( +
+ + {this.menuItems(transitionState)} + +
+ ); + }; + + render() { + return ( + + {this.menu} + + ); + } } -SideBar.propTypes = { - classes: PropTypes.object.isRequired, - opened: PropTypes.bool.isRequired, - close: PropTypes.func.isRequired, - changeContent: PropTypes.func.isRequired, -}; - export default withStyles(styles)(SideBar); diff --git a/dashboard/assets/fa-only-woff-loader.js b/dashboard/assets/fa-only-woff-loader.js new file mode 100644 index 0000000000..4d30357361 --- /dev/null +++ b/dashboard/assets/fa-only-woff-loader.js @@ -0,0 +1,25 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// fa-only-woff-loader removes the .eot, .ttf, .svg dependencies of the FontAwesome library, +// because they produce unused extra blobs. +module.exports = function(content) { + return content + .replace(/src.*url(?!.*url.*(\.eot)).*(\.eot)[^;]*;/,'') + .replace(/url(?!.*url.*(\.eot)).*(\.eot)[^,]*,/,'') + .replace(/url(?!.*url.*(\.ttf)).*(\.ttf)[^,]*,/,'') + .replace(/,[^,]*url(?!.*url.*(\.svg)).*(\.svg)[^;]*;/,';'); +}; diff --git a/dashboard/assets/index.jsx b/dashboard/assets/index.jsx index 1e5fdc8929..e10095bafc 100644 --- a/dashboard/assets/index.jsx +++ b/dashboard/assets/index.jsx @@ -1,3 +1,5 @@ +// @flow + // Copyright 2017 The go-ethereum Authors // This file is part of the go-ethereum library. // @@ -15,22 +17,25 @@ // along with the go-ethereum library. If not, see . import React from 'react'; -import {hydrate} from 'react-dom'; -import {createMuiTheme, MuiThemeProvider} from 'material-ui/styles'; +import {render} from 'react-dom'; -import Dashboard from './components/Dashboard.jsx'; +import MuiThemeProvider from 'material-ui/styles/MuiThemeProvider'; +import createMuiTheme from 'material-ui/styles/createMuiTheme'; + +import Dashboard from './components/Dashboard'; -// Theme for the dashboard. const theme = createMuiTheme({ palette: { type: 'dark', }, }); - -// Renders the whole dashboard. -hydrate( - - - , - document.getElementById('dashboard') -); +const dashboard = document.getElementById('dashboard'); +if (dashboard) { + // Renders the whole dashboard. + render( + + + , + dashboard, + ); +} diff --git a/dashboard/assets/package-lock.json b/dashboard/assets/package-lock.json new file mode 100644 index 0000000000..38a7cea24f --- /dev/null +++ b/dashboard/assets/package-lock.json @@ -0,0 +1,6806 @@ +{ + "requires": true, + "lockfileVersion": 1, + "dependencies": { + "@babel/code-frame": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.31.tgz", + "integrity": "sha512-yd7CkUughvHQoEahQqcMdrZw6o/6PwUxiRkfZuVDVHCDe77mysD/suoNyk5mK6phTnRW1kyIbPHyCJgxw++LXg==", + "requires": { + "chalk": "2.3.0", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "@babel/helper-function-name": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.0.0-beta.31.tgz", + "integrity": "sha512-c+DAyp8LMm2nzSs2uXEuxp4LYGSUYEyHtU3fU57avFChjsnTmmpWmXj2dv0yUxHTEydgVAv5fIzA+4KJwoqWDA==", + "requires": { + "@babel/helper-get-function-arity": "7.0.0-beta.31", + "@babel/template": "7.0.0-beta.31", + "@babel/traverse": "7.0.0-beta.31", + "@babel/types": "7.0.0-beta.31" + } + }, + "@babel/helper-get-function-arity": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0-beta.31.tgz", + "integrity": "sha512-m7rVVX/dMLbbB9NCzKYRrrFb0qZxgpmQ4Wv6y7zEsB6skoJHRuXVeb/hAFze79vXBbuD63ci7AVHXzAdZSk9KQ==", + "requires": { + "@babel/types": "7.0.0-beta.31" + } + }, + "@babel/template": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.0.0-beta.31.tgz", + "integrity": "sha512-97IRmLvoDhIDSQkqklVt3UCxJsv0LUEVb/0DzXWtc8Lgiyxj567qZkmTG9aR21CmcJVVIvq2Y/moZj4oEpl5AA==", + "requires": { + "@babel/code-frame": "7.0.0-beta.31", + "@babel/types": "7.0.0-beta.31", + "babylon": "7.0.0-beta.31", + "lodash": "4.17.4" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.31.tgz", + "integrity": "sha512-6lm2mV3S51yEnKmQQNnswoABL1U1H1KHoCCVwdwI3hvIv+W7ya4ki7Aw4o4KxtUHjNKkK5WpZb22rrMMOcJXJQ==" + } + } + }, + "@babel/traverse": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.0.0-beta.31.tgz", + "integrity": "sha512-3N+VJW+KlezEjFBG7WSYeMyC5kIqVLPb/PGSzCDPFcJrnArluD1GIl7Y3xC7cjKiTq2/JohaLWHVPjJWHlo9Gg==", + "requires": { + "@babel/code-frame": "7.0.0-beta.31", + "@babel/helper-function-name": "7.0.0-beta.31", + "@babel/types": "7.0.0-beta.31", + "babylon": "7.0.0-beta.31", + "debug": "3.1.0", + "globals": "10.4.0", + "invariant": "2.2.2", + "lodash": "4.17.4" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.31.tgz", + "integrity": "sha512-6lm2mV3S51yEnKmQQNnswoABL1U1H1KHoCCVwdwI3hvIv+W7ya4ki7Aw4o4KxtUHjNKkK5WpZb22rrMMOcJXJQ==" + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "requires": { + "ms": "2.0.0" + } + }, + "globals": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-10.4.0.tgz", + "integrity": "sha512-uNUtxIZpGyuaq+5BqGGQHsL4wUlJAXRqOm6g3Y48/CWNGTLONgBibI0lh6lGxjR2HljFYUfszb+mk4WkgMntsA==" + } + } + }, + "@babel/types": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.0.0-beta.31.tgz", + "integrity": "sha512-exAHB+NeFGxkfQ5dSUD03xl3zYGneeSk2Mw2ldTt/nTvYxuDiuSp3DlxgUBgzbdTFG4fbwPk0WtKWOoTXCmNGg==", + "requires": { + "esutils": "2.0.2", + "lodash": "4.17.4", + "to-fast-properties": "2.0.0" + }, + "dependencies": { + "to-fast-properties": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz", + "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=" + } + } + }, + "acorn": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.2.1.tgz", + "integrity": "sha512-jG0u7c4Ly+3QkkW18V+NRDN+4bWHdln30NL1ZL2AvFZZmQe/BfopYCtghCKKVBUSetZ4QKcyA0pY6/4Gw8Pv8w==" + }, + "acorn-dynamic-import": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-2.0.2.tgz", + "integrity": "sha1-x1K9IQvvZ5UBtsbLf8hPj0cVjMQ=", + "requires": { + "acorn": "4.0.13" + }, + "dependencies": { + "acorn": { + "version": "4.0.13", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz", + "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=" + } + } + }, + "acorn-jsx": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz", + "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=", + "requires": { + "acorn": "3.3.0" + }, + "dependencies": { + "acorn": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz", + "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=" + } + } + }, + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "requires": { + "co": "4.6.0", + "fast-deep-equal": "1.0.0", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1" + } + }, + "ajv-keywords": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-2.1.1.tgz", + "integrity": "sha1-YXmX/F9gV2iUxDX5QNgZ4TW4B2I=" + }, + "align-text": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/align-text/-/align-text-0.1.4.tgz", + "integrity": "sha1-DNkKVhCT810KmSVsIrcGlDP60Rc=", + "requires": { + "kind-of": "3.2.2", + "longest": "1.0.1", + "repeat-string": "1.6.1" + } + }, + "alphanum-sort": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/alphanum-sort/-/alphanum-sort-1.0.2.tgz", + "integrity": "sha1-l6ERlkmyEa0zaR2fn0hqjsn74KM=" + }, + "ansi-escapes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.0.0.tgz", + "integrity": "sha512-O/klc27mWNUigtv0F8NJWbLF00OcegQalkqKURWdosW08YZKi4m6CnSUSvIZG1otNJbTWhN01Hhz389DW7mvDQ==" + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=" + }, + "anymatch": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz", + "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==", + "requires": { + "micromatch": "2.3.11", + "normalize-path": "2.1.1" + } + }, + "argparse": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.9.tgz", + "integrity": "sha1-c9g7wmP4bpf4zE9rrhsOkKfSLIY=", + "requires": { + "sprintf-js": "1.0.3" + } + }, + "aria-query": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-0.7.0.tgz", + "integrity": "sha512-/r2lHl09V3o74+2MLKEdewoj37YZqiQZnfen1O4iNlrOjUgeKuu1U2yF3iKh6HJxqF+OXkLMfQv65Z/cvxD6vA==", + "requires": { + "ast-types-flow": "0.0.7" + } + }, + "arr-diff": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz", + "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=", + "requires": { + "arr-flatten": "1.1.0" + } + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==" + }, + "array-includes": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.0.3.tgz", + "integrity": "sha1-GEtI9i2S10UrsxsyMWXH+L0CJm0=", + "requires": { + "define-properties": "1.1.2", + "es-abstract": "1.10.0" + } + }, + "array-union": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz", + "integrity": "sha1-mjRBDk9OPaI96jdb5b5w8kd47Dk=", + "requires": { + "array-uniq": "1.0.3" + } + }, + "array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha1-r2rId6Jcx/dOBYiUdThY39sk/bY=" + }, + "array-unique": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz", + "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=" + }, + "arrify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", + "integrity": "sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0=" + }, + "asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY=" + }, + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=" + }, + "asn1.js": { + "version": "4.9.2", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.9.2.tgz", + "integrity": "sha512-b/OsSjvWEo8Pi8H0zsDd2P6Uqo2TK2pH8gNLSJtNLM2Db0v2QaAZ0pBQJXVjAn4gBuugeVDr7s63ZogpUIwWDg==", + "requires": { + "bn.js": "4.11.8", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "assert": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz", + "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=", + "requires": { + "util": "0.10.3" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "ast-types-flow": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.7.tgz", + "integrity": "sha1-9wtzXGvKGlycItmCw+Oef+ujva0=" + }, + "async": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.0.tgz", + "integrity": "sha512-xAfGg1/NTLBBKlHFmnd7PlmUW9KhVQIUuSrYem9xzFUZy13ScvtyGGejaae9iAVRiRq9+Cx7DPFaAAhCpyxyPw==", + "requires": { + "lodash": "4.17.4" + } + }, + "async-each": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz", + "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=" + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + }, + "autoprefixer": { + "version": "6.7.7", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-6.7.7.tgz", + "integrity": "sha1-Hb0cg1ZY41zj+ZhAmdsAWFx4IBQ=", + "requires": { + "browserslist": "1.7.7", + "caniuse-db": "1.0.30000784", + "normalize-range": "0.1.2", + "num2fraction": "1.2.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + }, + "dependencies": { + "browserslist": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz", + "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", + "requires": { + "caniuse-db": "1.0.30000784", + "electron-to-chromium": "1.3.30" + } + } + } + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + }, + "aws4": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.6.0.tgz", + "integrity": "sha1-g+9cqGCysy5KDe7e6MdxudtXRx4=" + }, + "axobject-query": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-0.1.0.tgz", + "integrity": "sha1-YvWdvFnJ+SQnWco0mWDnov48NsA=", + "requires": { + "ast-types-flow": "0.0.7" + } + }, + "babel-code-frame": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", + "requires": { + "chalk": "1.1.3", + "esutils": "2.0.2", + "js-tokens": "3.0.2" + } + }, + "babel-core": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.0.tgz", + "integrity": "sha1-rzL3izGm/O8RnIew/Y2XU/A6C7g=", + "requires": { + "babel-code-frame": "6.26.0", + "babel-generator": "6.26.0", + "babel-helpers": "6.24.1", + "babel-messages": "6.23.0", + "babel-register": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "convert-source-map": "1.5.1", + "debug": "2.6.9", + "json5": "0.5.1", + "lodash": "4.17.4", + "minimatch": "3.0.4", + "path-is-absolute": "1.0.1", + "private": "0.1.8", + "slash": "1.0.0", + "source-map": "0.5.7" + } + }, + "babel-eslint": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/babel-eslint/-/babel-eslint-8.0.3.tgz", + "integrity": "sha512-7D4iUpylEiKJPGbeSAlNddGcmA41PadgZ6UAb6JVyh003h3d0EbZusYFBR/+nBgqtaVJM2J2zUVa3N0hrpMH6g==", + "requires": { + "@babel/code-frame": "7.0.0-beta.31", + "@babel/traverse": "7.0.0-beta.31", + "@babel/types": "7.0.0-beta.31", + "babylon": "7.0.0-beta.31" + }, + "dependencies": { + "babylon": { + "version": "7.0.0-beta.31", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.31.tgz", + "integrity": "sha512-6lm2mV3S51yEnKmQQNnswoABL1U1H1KHoCCVwdwI3hvIv+W7ya4ki7Aw4o4KxtUHjNKkK5WpZb22rrMMOcJXJQ==" + } + } + }, + "babel-generator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.0.tgz", + "integrity": "sha1-rBriAHC3n248odMmlhMFN3TyDcU=", + "requires": { + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "detect-indent": "4.0.0", + "jsesc": "1.3.0", + "lodash": "4.17.4", + "source-map": "0.5.7", + "trim-right": "1.0.1" + } + }, + "babel-helper-bindify-decorators": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-bindify-decorators/-/babel-helper-bindify-decorators-6.24.1.tgz", + "integrity": "sha1-FMGeXxQte0fxmlJDHlKxzLxAozA=", + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-builder-binary-assignment-operator-visitor": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz", + "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=", + "requires": { + "babel-helper-explode-assignable-expression": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-builder-react-jsx": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-builder-react-jsx/-/babel-helper-builder-react-jsx-6.26.0.tgz", + "integrity": "sha1-Of+DE7dci2Xc7/HzHTg+D/KkCKA=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "esutils": "2.0.2" + } + }, + "babel-helper-call-delegate": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", + "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-define-map": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", + "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-helper-explode-assignable-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz", + "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=", + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-explode-class": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-explode-class/-/babel-helper-explode-class-6.24.1.tgz", + "integrity": "sha1-fcKjkQ3uAHBW4eMdZAztPVTqqes=", + "requires": { + "babel-helper-bindify-decorators": "6.24.1", + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", + "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", + "requires": { + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-get-function-arity": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", + "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-hoist-variables": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", + "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-optimise-call-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", + "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-regex": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", + "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-helper-remap-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz", + "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=", + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helper-replace-supers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", + "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", + "requires": { + "babel-helper-optimise-call-expression": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-helpers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz", + "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-loader": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-7.1.2.tgz", + "integrity": "sha512-jRwlFbINAeyDStqK6Dd5YuY0k5YuzQUvlz2ZamuXrXmxav3pNqe9vfJ402+2G+OmlJSXxCOpB6Uz0INM7RQe2A==", + "requires": { + "find-cache-dir": "1.0.0", + "loader-utils": "1.1.0", + "mkdirp": "0.5.1" + } + }, + "babel-messages": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", + "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-check-es2015-constants": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", + "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-syntax-async-functions": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz", + "integrity": "sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU=" + }, + "babel-plugin-syntax-async-generators": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-generators/-/babel-plugin-syntax-async-generators-6.13.0.tgz", + "integrity": "sha1-a8lj67FuzLrmuStZbrfzXDQqi5o=" + }, + "babel-plugin-syntax-class-constructor-call": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-class-constructor-call/-/babel-plugin-syntax-class-constructor-call-6.18.0.tgz", + "integrity": "sha1-nLnTn+Q8hgC+yBRkVt3L1OGnZBY=" + }, + "babel-plugin-syntax-class-properties": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz", + "integrity": "sha1-1+sjt5oxf4VDlixQW4J8fWysJ94=" + }, + "babel-plugin-syntax-decorators": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-decorators/-/babel-plugin-syntax-decorators-6.13.0.tgz", + "integrity": "sha1-MSVjtNvePMgGzuPkFszurd0RrAs=" + }, + "babel-plugin-syntax-do-expressions": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-do-expressions/-/babel-plugin-syntax-do-expressions-6.13.0.tgz", + "integrity": "sha1-V0d1YTmqJtOQ0JQQsDdEugfkeW0=" + }, + "babel-plugin-syntax-dynamic-import": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-dynamic-import/-/babel-plugin-syntax-dynamic-import-6.18.0.tgz", + "integrity": "sha1-jWomIpyDdFqZgqRBBRVyyqF5sdo=" + }, + "babel-plugin-syntax-exponentiation-operator": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz", + "integrity": "sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4=" + }, + "babel-plugin-syntax-export-extensions": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-export-extensions/-/babel-plugin-syntax-export-extensions-6.13.0.tgz", + "integrity": "sha1-cKFITw+QiaToStRLrDU8lbmxJyE=" + }, + "babel-plugin-syntax-flow": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz", + "integrity": "sha1-TDqyCiryaqIM0lmVw5jE63AxDI0=" + }, + "babel-plugin-syntax-function-bind": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-function-bind/-/babel-plugin-syntax-function-bind-6.13.0.tgz", + "integrity": "sha1-SMSV8Xe98xqYHnMvVa3AvdJgH0Y=" + }, + "babel-plugin-syntax-jsx": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-jsx/-/babel-plugin-syntax-jsx-6.18.0.tgz", + "integrity": "sha1-CvMqmm4Tyno/1QaeYtew9Y0NiUY=" + }, + "babel-plugin-syntax-object-rest-spread": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz", + "integrity": "sha1-/WU28rzhODb/o6VFjEkDpZe7O/U=" + }, + "babel-plugin-syntax-trailing-function-commas": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz", + "integrity": "sha1-ugNgk3+NBuQBgKQ/4NVhb/9TLPM=" + }, + "babel-plugin-transform-async-generator-functions": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-generator-functions/-/babel-plugin-transform-async-generator-functions-6.24.1.tgz", + "integrity": "sha1-8FiQAUX9PpkHpt3yjaWfIVJYpds=", + "requires": { + "babel-helper-remap-async-to-generator": "6.24.1", + "babel-plugin-syntax-async-generators": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz", + "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=", + "requires": { + "babel-helper-remap-async-to-generator": "6.24.1", + "babel-plugin-syntax-async-functions": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-class-constructor-call": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-class-constructor-call/-/babel-plugin-transform-class-constructor-call-6.24.1.tgz", + "integrity": "sha1-gNwoVQWsBn3LjWxl4vbxGrd2Xvk=", + "requires": { + "babel-plugin-syntax-class-constructor-call": "6.18.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-class-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.24.1.tgz", + "integrity": "sha1-anl2PqYdM9NvN7YRqp3vgagbRqw=", + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-plugin-syntax-class-properties": "6.13.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-decorators": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-decorators/-/babel-plugin-transform-decorators-6.24.1.tgz", + "integrity": "sha1-eIAT2PjGtSIr33s0Q5Df13Vp4k0=", + "requires": { + "babel-helper-explode-class": "6.24.1", + "babel-plugin-syntax-decorators": "6.13.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-decorators-legacy": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-decorators-legacy/-/babel-plugin-transform-decorators-legacy-1.3.4.tgz", + "integrity": "sha1-dBtY9sW86eYCfgiC2cmU8E82aSU=", + "requires": { + "babel-plugin-syntax-decorators": "6.13.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-do-expressions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-do-expressions/-/babel-plugin-transform-do-expressions-6.22.0.tgz", + "integrity": "sha1-KMyvkoEtlJws0SgfaQyP3EaK6bs=", + "requires": { + "babel-plugin-syntax-do-expressions": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-arrow-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", + "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoped-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", + "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-block-scoping": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", + "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "lodash": "4.17.4" + } + }, + "babel-plugin-transform-es2015-classes": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", + "requires": { + "babel-helper-define-map": "6.26.0", + "babel-helper-function-name": "6.24.1", + "babel-helper-optimise-call-expression": "6.24.1", + "babel-helper-replace-supers": "6.24.1", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-computed-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", + "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", + "requires": { + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-destructuring": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", + "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-duplicate-keys": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", + "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-for-of": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", + "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", + "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", + "requires": { + "babel-helper-function-name": "6.24.1", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", + "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-amd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", + "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", + "requires": { + "babel-plugin-transform-es2015-modules-commonjs": "6.26.0", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-commonjs": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.0.tgz", + "integrity": "sha1-DYOUApt9xqvhqX7xgeAHWN0uXYo=", + "requires": { + "babel-plugin-transform-strict-mode": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-systemjs": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", + "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", + "requires": { + "babel-helper-hoist-variables": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-umd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", + "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", + "requires": { + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0" + } + }, + "babel-plugin-transform-es2015-object-super": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", + "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", + "requires": { + "babel-helper-replace-supers": "6.24.1", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-parameters": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", + "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", + "requires": { + "babel-helper-call-delegate": "6.24.1", + "babel-helper-get-function-arity": "6.24.1", + "babel-runtime": "6.26.0", + "babel-template": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-shorthand-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", + "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-spread": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", + "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-sticky-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", + "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-plugin-transform-es2015-template-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", + "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-typeof-symbol": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", + "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-es2015-unicode-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", + "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", + "requires": { + "babel-helper-regex": "6.26.0", + "babel-runtime": "6.26.0", + "regexpu-core": "2.0.0" + } + }, + "babel-plugin-transform-exponentiation-operator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz", + "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=", + "requires": { + "babel-helper-builder-binary-assignment-operator-visitor": "6.24.1", + "babel-plugin-syntax-exponentiation-operator": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-export-extensions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-export-extensions/-/babel-plugin-transform-export-extensions-6.22.0.tgz", + "integrity": "sha1-U3OLR+deghhYnuqUbLvTkQm75lM=", + "requires": { + "babel-plugin-syntax-export-extensions": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-flow-strip-types": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz", + "integrity": "sha1-hMtnKTXUNxT9wyvOhFaNh0Qc988=", + "requires": { + "babel-plugin-syntax-flow": "6.18.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-function-bind": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-function-bind/-/babel-plugin-transform-function-bind-6.22.0.tgz", + "integrity": "sha1-xvuOlqwpajELjPjqQBRiQH3fapc=", + "requires": { + "babel-plugin-syntax-function-bind": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-object-rest-spread": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-object-rest-spread/-/babel-plugin-transform-object-rest-spread-6.26.0.tgz", + "integrity": "sha1-DzZpLVD+9rfi1LOsFHgTepY7ewY=", + "requires": { + "babel-plugin-syntax-object-rest-spread": "6.13.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-react-display-name": { + "version": "6.25.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-display-name/-/babel-plugin-transform-react-display-name-6.25.0.tgz", + "integrity": "sha1-Z+K/Hx6ck6sI25Z5LgU5K/LMKNE=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-react-jsx": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-jsx/-/babel-plugin-transform-react-jsx-6.24.1.tgz", + "integrity": "sha1-hAoCjn30YN/DotKfDA2R9jduZqM=", + "requires": { + "babel-helper-builder-react-jsx": "6.26.0", + "babel-plugin-syntax-jsx": "6.18.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-react-jsx-self": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-jsx-self/-/babel-plugin-transform-react-jsx-self-6.22.0.tgz", + "integrity": "sha1-322AqdomEqEh5t3XVYvL7PBuY24=", + "requires": { + "babel-plugin-syntax-jsx": "6.18.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-react-jsx-source": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-jsx-source/-/babel-plugin-transform-react-jsx-source-6.22.0.tgz", + "integrity": "sha1-ZqwSFT9c0tF7PBkmj0vwGX9E7NY=", + "requires": { + "babel-plugin-syntax-jsx": "6.18.0", + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-regenerator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", + "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", + "requires": { + "regenerator-transform": "0.10.1" + } + }, + "babel-plugin-transform-runtime": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-runtime/-/babel-plugin-transform-runtime-6.23.0.tgz", + "integrity": "sha1-iEkNRGUC6puOfvsP4J7E2ZR5se4=", + "requires": { + "babel-runtime": "6.26.0" + } + }, + "babel-plugin-transform-strict-mode": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", + "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0" + } + }, + "babel-polyfill": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-polyfill/-/babel-polyfill-6.26.0.tgz", + "integrity": "sha1-N5k3q8Z9eJWXCtxiHyhM2WbPIVM=", + "requires": { + "babel-runtime": "6.26.0", + "core-js": "2.5.3", + "regenerator-runtime": "0.10.5" + }, + "dependencies": { + "regenerator-runtime": { + "version": "0.10.5", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.10.5.tgz", + "integrity": "sha1-M2w+/BIgrc7dosn6tntaeVWjNlg=" + } + } + }, + "babel-preset-env": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/babel-preset-env/-/babel-preset-env-1.6.1.tgz", + "integrity": "sha512-W6VIyA6Ch9ePMI7VptNn2wBM6dbG0eSz25HEiL40nQXCsXGTGZSTZu1Iap+cj3Q0S5a7T9+529l/5Bkvd+afNA==", + "requires": { + "babel-plugin-check-es2015-constants": "6.22.0", + "babel-plugin-syntax-trailing-function-commas": "6.22.0", + "babel-plugin-transform-async-to-generator": "6.24.1", + "babel-plugin-transform-es2015-arrow-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "6.22.0", + "babel-plugin-transform-es2015-block-scoping": "6.26.0", + "babel-plugin-transform-es2015-classes": "6.24.1", + "babel-plugin-transform-es2015-computed-properties": "6.24.1", + "babel-plugin-transform-es2015-destructuring": "6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "6.24.1", + "babel-plugin-transform-es2015-for-of": "6.23.0", + "babel-plugin-transform-es2015-function-name": "6.24.1", + "babel-plugin-transform-es2015-literals": "6.22.0", + "babel-plugin-transform-es2015-modules-amd": "6.24.1", + "babel-plugin-transform-es2015-modules-commonjs": "6.26.0", + "babel-plugin-transform-es2015-modules-systemjs": "6.24.1", + "babel-plugin-transform-es2015-modules-umd": "6.24.1", + "babel-plugin-transform-es2015-object-super": "6.24.1", + "babel-plugin-transform-es2015-parameters": "6.24.1", + "babel-plugin-transform-es2015-shorthand-properties": "6.24.1", + "babel-plugin-transform-es2015-spread": "6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "6.24.1", + "babel-plugin-transform-es2015-template-literals": "6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "6.24.1", + "babel-plugin-transform-exponentiation-operator": "6.24.1", + "babel-plugin-transform-regenerator": "6.26.0", + "browserslist": "2.10.0", + "invariant": "2.2.2", + "semver": "5.4.1" + } + }, + "babel-preset-flow": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-preset-flow/-/babel-preset-flow-6.23.0.tgz", + "integrity": "sha1-5xIYiHCFrpoktb5Baa/7WZgWxJ0=", + "requires": { + "babel-plugin-transform-flow-strip-types": "6.22.0" + } + }, + "babel-preset-react": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-react/-/babel-preset-react-6.24.1.tgz", + "integrity": "sha1-umnfrqRfw+xjm2pOzqbhdwLJE4A=", + "requires": { + "babel-plugin-syntax-jsx": "6.18.0", + "babel-plugin-transform-react-display-name": "6.25.0", + "babel-plugin-transform-react-jsx": "6.24.1", + "babel-plugin-transform-react-jsx-self": "6.22.0", + "babel-plugin-transform-react-jsx-source": "6.22.0", + "babel-preset-flow": "6.23.0" + } + }, + "babel-preset-stage-0": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-stage-0/-/babel-preset-stage-0-6.24.1.tgz", + "integrity": "sha1-VkLRUEL5E4TX5a+LyIsduVsDnmo=", + "requires": { + "babel-plugin-transform-do-expressions": "6.22.0", + "babel-plugin-transform-function-bind": "6.22.0", + "babel-preset-stage-1": "6.24.1" + } + }, + "babel-preset-stage-1": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-stage-1/-/babel-preset-stage-1-6.24.1.tgz", + "integrity": "sha1-dpLNfc1oSZB+auSgqFWJz7niv7A=", + "requires": { + "babel-plugin-transform-class-constructor-call": "6.24.1", + "babel-plugin-transform-export-extensions": "6.22.0", + "babel-preset-stage-2": "6.24.1" + } + }, + "babel-preset-stage-2": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-stage-2/-/babel-preset-stage-2-6.24.1.tgz", + "integrity": "sha1-2eKWD7PXEYfw5k7sYrwHdnIZvcE=", + "requires": { + "babel-plugin-syntax-dynamic-import": "6.18.0", + "babel-plugin-transform-class-properties": "6.24.1", + "babel-plugin-transform-decorators": "6.24.1", + "babel-preset-stage-3": "6.24.1" + } + }, + "babel-preset-stage-3": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-preset-stage-3/-/babel-preset-stage-3-6.24.1.tgz", + "integrity": "sha1-g2raCp56f6N8sTj7kyb4eTSkg5U=", + "requires": { + "babel-plugin-syntax-trailing-function-commas": "6.22.0", + "babel-plugin-transform-async-generator-functions": "6.24.1", + "babel-plugin-transform-async-to-generator": "6.24.1", + "babel-plugin-transform-exponentiation-operator": "6.24.1", + "babel-plugin-transform-object-rest-spread": "6.26.0" + } + }, + "babel-register": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz", + "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", + "requires": { + "babel-core": "6.26.0", + "babel-runtime": "6.26.0", + "core-js": "2.5.3", + "home-or-tmp": "2.0.0", + "lodash": "4.17.4", + "mkdirp": "0.5.1", + "source-map-support": "0.4.18" + } + }, + "babel-runtime": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", + "requires": { + "core-js": "2.5.3", + "regenerator-runtime": "0.11.1" + } + }, + "babel-template": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", + "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", + "requires": { + "babel-runtime": "6.26.0", + "babel-traverse": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "lodash": "4.17.4" + } + }, + "babel-traverse": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", + "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", + "requires": { + "babel-code-frame": "6.26.0", + "babel-messages": "6.23.0", + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "babylon": "6.18.0", + "debug": "2.6.9", + "globals": "9.18.0", + "invariant": "2.2.2", + "lodash": "4.17.4" + } + }, + "babel-types": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", + "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", + "requires": { + "babel-runtime": "6.26.0", + "esutils": "2.0.2", + "lodash": "4.17.4", + "to-fast-properties": "1.0.3" + } + }, + "babylon": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==" + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base64-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.1.tgz", + "integrity": "sha512-dwVUVIXsBZXwTuwnXI9RK8sBmgq09NDHzyR9SAph9eqk76gKK2JSQmZARC2zRC81JC2QTtxD0ARU5qTS25gIGw==" + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz", + "integrity": "sha1-Y7xdy2EzG5K8Bf1SiVPDNGKgb40=", + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "big.js": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-3.2.0.tgz", + "integrity": "sha512-+hN/Zh2D08Mx65pZ/4g5bsmNiZUuChDiQfTUQ7qJr4/kuopCr88xZsAXv6mBoZEsUI4OuGHlX59qE94K2mMW8Q==" + }, + "binary": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/binary/-/binary-0.3.0.tgz", + "integrity": "sha1-n2BVO8XOjDOG87VTz/R0Yq3sqnk=", + "requires": { + "buffers": "0.1.1", + "chainsaw": "0.1.0" + } + }, + "binary-extensions": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.11.0.tgz", + "integrity": "sha1-RqoXUftqL5PuXmibsQh9SxTGwgU=" + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==" + }, + "boom": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/boom/-/boom-4.3.1.tgz", + "integrity": "sha1-T4owBctKfjiJ90kDD9JbluAdLjE=", + "requires": { + "hoek": "4.2.0" + } + }, + "brace-expansion": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.8.tgz", + "integrity": "sha1-wHshHHyVLsH479Uad+8NHTmQopI=", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz", + "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=", + "requires": { + "expand-range": "1.8.2", + "preserve": "0.2.0", + "repeat-element": "1.1.2" + } + }, + "brcast": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/brcast/-/brcast-3.0.1.tgz", + "integrity": "sha512-eI3yqf9YEqyGl9PCNTR46MGvDylGtaHjalcz6Q3fAPnP/PhpKkkve52vFdfGpwp4VUvK6LUr4TQN+2stCrEwTg==" + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=" + }, + "browserify-aes": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.1.1.tgz", + "integrity": "sha512-UGnTYAnB2a3YuYKIRy1/4FB2HdM866E0qC46JXvVTYKlBlZlnvfpSfY6OKfXZAkv70eJ2a1SqzpAo5CRhZGDFg==", + "requires": { + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "browserify-cipher": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.0.tgz", + "integrity": "sha1-mYgkSHS/XtTijalWZtzWasj8Njo=", + "requires": { + "browserify-aes": "1.1.1", + "browserify-des": "1.0.0", + "evp_bytestokey": "1.0.3" + } + }, + "browserify-des": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.0.tgz", + "integrity": "sha1-2qJ3cXRwki7S/hhZQRihdUOXId0=", + "requires": { + "cipher-base": "1.0.4", + "des.js": "1.0.0", + "inherits": "2.0.3" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "requires": { + "bn.js": "4.11.8", + "randombytes": "2.0.5" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "elliptic": "6.4.0", + "inherits": "2.0.3", + "parse-asn1": "5.1.0" + } + }, + "browserify-zlib": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", + "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", + "requires": { + "pako": "1.0.6" + } + }, + "browserslist": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-2.10.0.tgz", + "integrity": "sha512-WyvzSLsuAVPOjbljXnyeWl14Ae+ukAT8MUuagKVzIDvwBxl4UAwD1xqtyQs2eWYPGUKMeC3Ol62goqYuKqTTcw==", + "requires": { + "caniuse-lite": "1.0.30000784", + "electron-to-chromium": "1.3.30" + } + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "requires": { + "base64-js": "1.2.1", + "ieee754": "1.1.8", + "isarray": "1.0.0" + } + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=" + }, + "buffers": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/buffers/-/buffers-0.1.1.tgz", + "integrity": "sha1-skV5w77U1tOWru5tmorn9Ugqt7s=" + }, + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=" + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=" + }, + "caller-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz", + "integrity": "sha1-lAhe9jWB7NPaqSREqP6U6CV3dR8=", + "requires": { + "callsites": "0.2.0" + } + }, + "callsites": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-0.2.0.tgz", + "integrity": "sha1-r6uWJikQp/M8GaV3WCXGnzTjUMo=" + }, + "camelcase": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", + "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=" + }, + "caniuse-api": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-1.6.1.tgz", + "integrity": "sha1-tTTnxzTE+B7F++isoq0kNUuWLGw=", + "requires": { + "browserslist": "1.7.7", + "caniuse-db": "1.0.30000784", + "lodash.memoize": "4.1.2", + "lodash.uniq": "4.5.0" + }, + "dependencies": { + "browserslist": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz", + "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", + "requires": { + "caniuse-db": "1.0.30000784", + "electron-to-chromium": "1.3.30" + } + } + } + }, + "caniuse-db": { + "version": "1.0.30000784", + "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30000784.tgz", + "integrity": "sha1-G+lQEtlInHcZB0+BruV9vf/mNhs=" + }, + "caniuse-lite": { + "version": "1.0.30000784", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30000784.tgz", + "integrity": "sha1-EpztdOmhKApEGIC2zSvOMO9Z5sA=" + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "center-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/center-align/-/center-align-0.1.3.tgz", + "integrity": "sha1-qg0yYptu6XIgBBHL1EYckHvCt60=", + "requires": { + "align-text": "0.1.4", + "lazy-cache": "1.0.4" + } + }, + "chain-function": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/chain-function/-/chain-function-1.0.0.tgz", + "integrity": "sha1-DUqzfn4Y6tC9xHuSB2QRjOWHM9w=" + }, + "chainsaw": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/chainsaw/-/chainsaw-0.1.0.tgz", + "integrity": "sha1-XqtQsor+WAdNDVgpE4iCi15fvJg=", + "requires": { + "traverse": "0.3.9" + } + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "change-emitter": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/change-emitter/-/change-emitter-0.1.6.tgz", + "integrity": "sha1-6LL+PX8at9aaMhma/5HqaTFAlRU=" + }, + "chardet": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.4.2.tgz", + "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=" + }, + "charenc": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz", + "integrity": "sha1-wKHS86cJLgN3S/qD8UwPxXkKhmc=" + }, + "child-process": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/child-process/-/child-process-1.0.2.tgz", + "integrity": "sha1-mJdNx+0e5MYin44wX6cxOmiFp/I=" + }, + "chokidar": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz", + "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=", + "requires": { + "anymatch": "1.3.2", + "async-each": "1.0.1", + "glob-parent": "2.0.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "2.0.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0" + } + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "circular-json": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/circular-json/-/circular-json-0.3.3.tgz", + "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==" + }, + "clap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/clap/-/clap-1.2.3.tgz", + "integrity": "sha512-4CoL/A3hf90V3VIEjeuhSvlGFEHKzOz+Wfc2IVZc+FaUgU0ZQafJTP49fvnULipOPcAfqhyI2duwQyns6xqjYA==", + "requires": { + "chalk": "1.1.3" + } + }, + "classnames": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/classnames/-/classnames-2.2.5.tgz", + "integrity": "sha1-+zgB1FNGdknvNgPH1hoCvRKb3m0=" + }, + "cli-cursor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz", + "integrity": "sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU=", + "requires": { + "restore-cursor": "2.0.0" + } + }, + "cli-width": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-2.2.0.tgz", + "integrity": "sha1-/xnt6Kml5XkyQUewwR8PvLq+1jk=" + }, + "cliui": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", + "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wrap-ansi": "2.1.0" + }, + "dependencies": { + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "1.0.1" + } + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + } + } + }, + "clone": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.3.tgz", + "integrity": "sha1-KY1+IjFmD0DAA8LtMUDezz9TCF8=" + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "coa": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/coa/-/coa-1.0.4.tgz", + "integrity": "sha1-qe8VNmDWqGqL3sAomlxoTSF0Mv0=", + "requires": { + "q": "1.5.1" + } + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=" + }, + "color": { + "version": "0.11.4", + "resolved": "https://registry.npmjs.org/color/-/color-0.11.4.tgz", + "integrity": "sha1-bXtcdPtl6EHNSHkq0e1eB7kE12Q=", + "requires": { + "clone": "1.0.3", + "color-convert": "1.9.1", + "color-string": "0.3.0" + } + }, + "color-convert": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.1.tgz", + "integrity": "sha512-mjGanIiwQJskCC18rPR6OmrZ6fm2Lc7PeGFYwCmy5J34wC6F1PzdGL6xeMfmgicfYcNLGuVFA3WzXtIDCQSZxQ==", + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=" + }, + "color-string": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/color-string/-/color-string-0.3.0.tgz", + "integrity": "sha1-J9RvtnAlxcL6JZk7+/V55HhBuZE=", + "requires": { + "color-name": "1.1.3" + } + }, + "colormin": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colormin/-/colormin-1.1.2.tgz", + "integrity": "sha1-6i90IKcrlogaOKrlnsEkpvcpgTM=", + "requires": { + "color": "0.11.4", + "css-color-names": "0.0.4", + "has": "1.0.1" + } + }, + "colors": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.1.2.tgz", + "integrity": "sha1-FopHAXVran9RoSzgyXv6KMCE7WM=" + }, + "combined-stream": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.5.tgz", + "integrity": "sha1-k4NwpXtKUd6ix3wV1cX9+JUWQAk=", + "requires": { + "delayed-stream": "1.0.0" + } + }, + "commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha1-3dgA2gxmEnOTzKWVDqloo6rxJTs=" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz", + "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "typedarray": "0.0.6" + } + }, + "console-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz", + "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", + "requires": { + "date-now": "0.1.4" + } + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=" + }, + "contains-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/contains-path/-/contains-path-0.1.0.tgz", + "integrity": "sha1-/ozxhP9mcLa67wGp1IYaXL7EEgo=" + }, + "convert-source-map": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", + "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=" + }, + "core-js": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.3.tgz", + "integrity": "sha1-isw4NFgk8W2DZbfJtCWRaOjtYD4=" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "create-ecdh": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.0.tgz", + "integrity": "sha1-iIxyNZbN92EvZJgjPuvXo1MBc30=", + "requires": { + "bn.js": "4.11.8", + "elliptic": "6.4.0" + } + }, + "create-hash": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.1.3.tgz", + "integrity": "sha1-YGBCrIuSYnUPSDyt2rD1gZFy2P0=", + "requires": { + "cipher-base": "1.0.4", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "sha.js": "2.4.9" + } + }, + "create-hmac": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.6.tgz", + "integrity": "sha1-rLniIaThe9sHbpBlfEK5PjcmzwY=", + "requires": { + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.9" + } + }, + "cross-spawn": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", + "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", + "requires": { + "lru-cache": "4.1.1", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + }, + "crypt": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz", + "integrity": "sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs=" + }, + "cryptiles": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-3.1.2.tgz", + "integrity": "sha1-qJ+7Ig9c4l7FboxKqKT9e1sNKf4=", + "requires": { + "boom": "5.2.0" + }, + "dependencies": { + "boom": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/boom/-/boom-5.2.0.tgz", + "integrity": "sha512-Z5BTk6ZRe4tXXQlkqftmsAUANpXmuwlsF5Oov8ThoMbQRzdGTA1ngYRW160GexgOgjsFOKJz0LYhoNi+2AMBUw==", + "requires": { + "hoek": "4.2.0" + } + } + } + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "requires": { + "browserify-cipher": "1.0.0", + "browserify-sign": "4.0.4", + "create-ecdh": "4.0.0", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "diffie-hellman": "5.0.2", + "inherits": "2.0.3", + "pbkdf2": "3.0.14", + "public-encrypt": "4.0.0", + "randombytes": "2.0.5", + "randomfill": "1.0.3" + } + }, + "css-color-names": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/css-color-names/-/css-color-names-0.0.4.tgz", + "integrity": "sha1-gIrcLnnPhHOAabZGyyDsJ762KeA=" + }, + "css-loader": { + "version": "0.28.7", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-0.28.7.tgz", + "integrity": "sha512-GxMpax8a/VgcfRrVy0gXD6yLd5ePYbXX/5zGgTVYp4wXtJklS8Z2VaUArJgc//f6/Dzil7BaJObdSv8eKKCPgg==", + "requires": { + "babel-code-frame": "6.26.0", + "css-selector-tokenizer": "0.7.0", + "cssnano": "3.10.0", + "icss-utils": "2.1.0", + "loader-utils": "1.1.0", + "lodash.camelcase": "4.3.0", + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-modules-extract-imports": "1.1.0", + "postcss-modules-local-by-default": "1.2.0", + "postcss-modules-scope": "1.1.0", + "postcss-modules-values": "1.3.0", + "postcss-value-parser": "3.3.0", + "source-list-map": "2.0.0" + } + }, + "css-selector-tokenizer": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/css-selector-tokenizer/-/css-selector-tokenizer-0.7.0.tgz", + "integrity": "sha1-5piEdK6MlTR3v15+/s/OzNnPTIY=", + "requires": { + "cssesc": "0.1.0", + "fastparse": "1.1.1", + "regexpu-core": "1.0.0" + }, + "dependencies": { + "regexpu-core": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-1.0.0.tgz", + "integrity": "sha1-hqdj9Y7k18L2sQLkdkBQ3n7ZDGs=", + "requires": { + "regenerate": "1.3.3", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" + } + } + } + }, + "css-vendor": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/css-vendor/-/css-vendor-0.3.8.tgz", + "integrity": "sha1-ZCHP0wNM5mT+dnOXL9ARn8KJQfo=", + "requires": { + "is-in-browser": "1.1.3" + } + }, + "cssesc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-0.1.0.tgz", + "integrity": "sha1-yBSQPkViM3GgR3tAEJqq++6t27Q=" + }, + "cssnano": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-3.10.0.tgz", + "integrity": "sha1-Tzj2zqK5sX+gFJDyPx3GjqZcHDg=", + "requires": { + "autoprefixer": "6.7.7", + "decamelize": "1.2.0", + "defined": "1.0.0", + "has": "1.0.1", + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-calc": "5.3.1", + "postcss-colormin": "2.2.2", + "postcss-convert-values": "2.6.1", + "postcss-discard-comments": "2.0.4", + "postcss-discard-duplicates": "2.1.0", + "postcss-discard-empty": "2.1.0", + "postcss-discard-overridden": "0.1.1", + "postcss-discard-unused": "2.2.3", + "postcss-filter-plugins": "2.0.2", + "postcss-merge-idents": "2.1.7", + "postcss-merge-longhand": "2.0.2", + "postcss-merge-rules": "2.1.2", + "postcss-minify-font-values": "1.0.5", + "postcss-minify-gradients": "1.0.5", + "postcss-minify-params": "1.2.2", + "postcss-minify-selectors": "2.1.1", + "postcss-normalize-charset": "1.1.1", + "postcss-normalize-url": "3.0.8", + "postcss-ordered-values": "2.2.3", + "postcss-reduce-idents": "2.4.0", + "postcss-reduce-initial": "1.0.1", + "postcss-reduce-transforms": "1.0.4", + "postcss-svgo": "2.1.6", + "postcss-unique-selectors": "2.0.2", + "postcss-value-parser": "3.3.0", + "postcss-zindex": "2.2.0" + } + }, + "csso": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/csso/-/csso-2.3.2.tgz", + "integrity": "sha1-3dUsWHAz9J6Utx/FVWnyUuj/X4U=", + "requires": { + "clap": "1.2.3", + "source-map": "0.5.7" + } + }, + "d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", + "requires": { + "es5-ext": "0.10.37" + } + }, + "d3-array": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.1.tgz", + "integrity": "sha512-CyINJQ0SOUHojDdFDH4JEM0552vCR1utGyLHegJHyYH0JyCpSeTPxi4OBqHMA2jJZq4NH782LtaJWBImqI/HBw==" + }, + "d3-collection": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/d3-collection/-/d3-collection-1.0.4.tgz", + "integrity": "sha1-NC39EoN8kJdPM/HMCnha6lcNzcI=" + }, + "d3-color": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-1.0.3.tgz", + "integrity": "sha1-vHZD/KjlOoNH4vva/6I2eWtYUJs=" + }, + "d3-format": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-1.2.1.tgz", + "integrity": "sha512-U4zRVLDXW61bmqoo+OJ/V687e1T5nVd3TAKAJKgtpZ/P1JsMgyod0y9br+mlQOryTAACdiXI3wCjuERHFNp91w==" + }, + "d3-interpolate": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-1.1.6.tgz", + "integrity": "sha512-mOnv5a+pZzkNIHtw/V6I+w9Lqm9L5bG3OTXPM5A+QO0yyVMQ4W1uZhR+VOJmazaOZXri2ppbiZ5BUNWT0pFM9A==", + "requires": { + "d3-color": "1.0.3" + } + }, + "d3-path": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.5.tgz", + "integrity": "sha1-JB6xhJvZ6egCHA0KeZ+KDo5EF2Q=" + }, + "d3-scale": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-1.0.6.tgz", + "integrity": "sha1-vOGdqA06DPQiyVQ64zIghiILNO0=", + "requires": { + "d3-array": "1.2.1", + "d3-collection": "1.0.4", + "d3-color": "1.0.3", + "d3-format": "1.2.1", + "d3-interpolate": "1.1.6", + "d3-time": "1.0.8", + "d3-time-format": "2.1.1" + } + }, + "d3-shape": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.2.0.tgz", + "integrity": "sha1-RdAVOPBkuv0F6j1tLLdI/YxB93c=", + "requires": { + "d3-path": "1.0.5" + } + }, + "d3-time": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-1.0.8.tgz", + "integrity": "sha512-YRZkNhphZh3KcnBfitvF3c6E0JOFGikHZ4YqD+Lzv83ZHn1/u6yGenRU1m+KAk9J1GnZMnKcrtfvSktlA1DXNQ==" + }, + "d3-time-format": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-2.1.1.tgz", + "integrity": "sha512-8kAkymq2WMfzW7e+s/IUNAtN/y3gZXGRrdGfo6R8NKPAA85UBTxZg5E61bR6nLwjPjj4d3zywSQe1CkYLPFyrw==", + "requires": { + "d3-time": "1.0.8" + } + }, + "damerau-levenshtein": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.4.tgz", + "integrity": "sha1-AxkcQyy27qFou3fzpV/9zLiXhRQ=" + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "date-now": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz", + "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=" + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + }, + "decompress-response": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", + "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", + "requires": { + "mimic-response": "1.0.0" + } + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=" + }, + "deepmerge": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-2.0.1.tgz", + "integrity": "sha512-VIPwiMJqJ13ZQfaCsIFnp5Me9tnjURiaIFxfz7EH0Ci0dTSQpZtSLrqOicXqEd/z2r+z+Klk9GzmnRsgpgbOsQ==" + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "requires": { + "foreach": "2.0.5", + "object-keys": "1.0.11" + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" + }, + "del": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz", + "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=", + "requires": { + "globby": "5.0.0", + "is-path-cwd": "1.0.0", + "is-path-in-cwd": "1.0.0", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "rimraf": "2.6.2" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "detect-indent": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz", + "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", + "requires": { + "repeating": "2.0.1" + } + }, + "diffie-hellman": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.2.tgz", + "integrity": "sha1-tYNXOScM/ias9jIJn97SoH8gnl4=", + "requires": { + "bn.js": "4.11.8", + "miller-rabin": "4.0.1", + "randombytes": "2.0.5" + } + }, + "doctrine": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.0.2.tgz", + "integrity": "sha512-y0tm5Pq6ywp3qSTZ1vPgVdAnbDEoeoc5wlOHXoY1c4Wug/a7JvqHIl7BTvwodaHmejWkK/9dSb3sCYfyo/om8A==", + "requires": { + "esutils": "2.0.2" + } + }, + "dom-helpers": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-3.3.1.tgz", + "integrity": "sha512-2Sm+JaYn74OiTM2wHvxJOo3roiq/h25Yi69Fqk269cNUwIXsCvATB6CRSFC9Am/20G2b28hGv/+7NiWydIrPvg==" + }, + "dom-walk": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.1.tgz", + "integrity": "sha1-ZyIm3HTI95mtNTB9+TaroRrNYBg=" + }, + "domain-browser": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.1.7.tgz", + "integrity": "sha1-hnqksJP6oF8d4IwG9NeyH9+GmLw=" + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=" + }, + "ecc-jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz", + "integrity": "sha1-D8c6ntXw1Tw4GTOYUj735UN3dQU=", + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "electron-releases": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/electron-releases/-/electron-releases-2.1.0.tgz", + "integrity": "sha512-cyKFD1bTE/UgULXfaueIN1k5EPFzs+FRc/rvCY5tIynefAPqopQEgjr0EzY+U3Dqrk/G4m9tXSPuZ77v6dL/Rw==" + }, + "electron-to-chromium": { + "version": "1.3.30", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.30.tgz", + "integrity": "sha512-zx1Prv7kYLfc4OA60FhxGbSo4qrEjgSzpo1/37i7l9ltXPYOoQBtjQxY9KmsgfHnBxHlBGXwLlsbt/gub1w5lw==", + "requires": { + "electron-releases": "2.1.0" + } + }, + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0", + "hash.js": "1.1.3", + "hmac-drbg": "1.0.1", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "emoji-regex": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-6.5.1.tgz", + "integrity": "sha512-PAHp6TxrCy7MGMFidro8uikr+zlJJKJ/Q6mm2ExZ7HwkyR9lSVFfE3kt36qcwa24BQL7y0G9axycGjK1A/0uNQ==" + }, + "emojis-list": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz", + "integrity": "sha1-TapNnbAPmBmIDHn6RXrlsJof04k=" + }, + "encoding": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz", + "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=", + "requires": { + "iconv-lite": "0.4.19" + } + }, + "enhanced-resolve": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-3.4.1.tgz", + "integrity": "sha1-BCHjOf1xQZs9oT0Smzl5BAIwR24=", + "requires": { + "graceful-fs": "4.1.11", + "memory-fs": "0.4.1", + "object-assign": "4.1.1", + "tapable": "0.2.8" + } + }, + "errno": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.6.tgz", + "integrity": "sha512-IsORQDpaaSwcDP4ZZnHxgE85werpo34VYn1Ud3mq+eUsF593faR8oCZNXrROVkpFu2TsbrNhHin0aUrTsQ9vNw==", + "requires": { + "prr": "1.0.1" + } + }, + "error-ex": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz", + "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", + "requires": { + "is-arrayish": "0.2.1" + } + }, + "es-abstract": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.10.0.tgz", + "integrity": "sha512-/uh/DhdqIOSkAWifU+8nG78vlQxdLckUdI/sPgy0VhuXi2qJ7T8czBmqIYtLQVpCIFYafChnsRsB5pyb1JdmCQ==", + "requires": { + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.1", + "is-callable": "1.1.3", + "is-regex": "1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "requires": { + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" + } + }, + "es5-ext": { + "version": "0.10.37", + "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.37.tgz", + "integrity": "sha1-DudB0Ui4AGm6J9AgOTdWryV978M=", + "requires": { + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1" + } + }, + "es6-iterator": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", + "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37", + "es6-symbol": "3.1.1" + } + }, + "es6-map": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/es6-map/-/es6-map-0.1.5.tgz", + "integrity": "sha1-kTbgUD3MBqMBaQ8LsU/042TpSfA=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37", + "es6-iterator": "2.0.3", + "es6-set": "0.1.5", + "es6-symbol": "3.1.1", + "event-emitter": "0.3.5" + } + }, + "es6-set": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/es6-set/-/es6-set-0.1.5.tgz", + "integrity": "sha1-0rPsXU2ADO2BjbU40ol02wpzzLE=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37", + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1", + "event-emitter": "0.3.5" + } + }, + "es6-symbol": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.1.tgz", + "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37" + } + }, + "es6-weak-map": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.2.tgz", + "integrity": "sha1-XjqzIlH/0VOKH45f+hNXdy+S2W8=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37", + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1" + } + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" + }, + "escope": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/escope/-/escope-3.6.0.tgz", + "integrity": "sha1-4Bl16BJ4GhY6ba392AOY3GTIicM=", + "requires": { + "es6-map": "0.1.5", + "es6-weak-map": "2.0.2", + "esrecurse": "4.2.0", + "estraverse": "4.2.0" + } + }, + "eslint": { + "version": "4.13.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.13.1.tgz", + "integrity": "sha512-UCJVV50RtLHYzBp1DZ8CMPtRSg4iVZvjgO9IJHIKyWU/AnJVjtdRikoUPLB29n5pzMB7TnsLQWf0V6VUJfoPfw==", + "requires": { + "ajv": "5.5.2", + "babel-code-frame": "6.26.0", + "chalk": "2.3.0", + "concat-stream": "1.6.0", + "cross-spawn": "5.1.0", + "debug": "3.1.0", + "doctrine": "2.0.2", + "eslint-scope": "3.7.1", + "espree": "3.5.2", + "esquery": "1.0.0", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "file-entry-cache": "2.0.0", + "functional-red-black-tree": "1.0.1", + "glob": "7.1.2", + "globals": "11.1.0", + "ignore": "3.3.7", + "imurmurhash": "0.1.4", + "inquirer": "3.3.0", + "is-resolvable": "1.0.1", + "js-yaml": "3.10.0", + "json-stable-stringify-without-jsonify": "1.0.1", + "levn": "0.3.0", + "lodash": "4.17.4", + "minimatch": "3.0.4", + "mkdirp": "0.5.1", + "natural-compare": "1.4.0", + "optionator": "0.8.2", + "path-is-inside": "1.0.2", + "pluralize": "7.0.0", + "progress": "2.0.0", + "require-uncached": "1.0.3", + "semver": "5.4.1", + "strip-ansi": "4.0.0", + "strip-json-comments": "2.0.1", + "table": "4.0.2", + "text-table": "0.2.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" + }, + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "requires": { + "ms": "2.0.0" + } + }, + "esprima": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz", + "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==" + }, + "globals": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-11.1.0.tgz", + "integrity": "sha512-uEuWt9mqTlPDwSqi+sHjD4nWU/1N+q0fiWI9T1mZpD2UENqX20CFD5T/ziLZvztPaBKl7ZylUi1q6Qfm7E2CiQ==" + }, + "js-yaml": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.10.0.tgz", + "integrity": "sha512-O2v52ffjLa9VeM43J4XocZE//WT9N0IiwDa3KSHH7Tu8CtH+1qM8SIZvnsTh6v+4yFy5KUY3BHUVwjpfAWsjIA==", + "requires": { + "argparse": "1.0.9", + "esprima": "4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "requires": { + "ansi-regex": "3.0.0" + } + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "eslint-config-airbnb": { + "version": "16.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb/-/eslint-config-airbnb-16.1.0.tgz", + "integrity": "sha512-zLyOhVWhzB/jwbz7IPSbkUuj7X2ox4PHXTcZkEmDqTvd0baJmJyuxlFPDlZOE/Y5bC+HQRaEkT3FoHo9wIdRiw==", + "requires": { + "eslint-config-airbnb-base": "12.1.0" + } + }, + "eslint-config-airbnb-base": { + "version": "12.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-airbnb-base/-/eslint-config-airbnb-base-12.1.0.tgz", + "integrity": "sha512-/vjm0Px5ZCpmJqnjIzcFb9TKZrKWz0gnuG/7Gfkt0Db1ELJR51xkZth+t14rYdqWgX836XbuxtArbIHlVhbLBA==", + "requires": { + "eslint-restricted-globals": "0.1.1" + } + }, + "eslint-import-resolver-node": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.1.tgz", + "integrity": "sha512-yUtXS15gIcij68NmXmP9Ni77AQuCN0itXbCc/jWd8C6/yKZaSNXicpC8cgvjnxVdmfsosIXrjpzFq7GcDryb6A==", + "requires": { + "debug": "2.6.9", + "resolve": "1.5.0" + } + }, + "eslint-loader": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/eslint-loader/-/eslint-loader-1.9.0.tgz", + "integrity": "sha512-40aN976qSNPyb9ejTqjEthZITpls1SVKtwguahmH1dzGCwQU/vySE+xX33VZmD8csU0ahVNCtFlsPgKqRBiqgg==", + "requires": { + "loader-fs-cache": "1.0.1", + "loader-utils": "1.1.0", + "object-assign": "4.1.1", + "object-hash": "1.2.0", + "rimraf": "2.6.2" + } + }, + "eslint-module-utils": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.1.1.tgz", + "integrity": "sha512-jDI/X5l/6D1rRD/3T43q8Qgbls2nq5km5KSqiwlyUbGo5+04fXhMKdCPhjwbqAa6HXWaMxj8Q4hQDIh7IadJQw==", + "requires": { + "debug": "2.6.9", + "pkg-dir": "1.0.0" + }, + "dependencies": { + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "requires": { + "pinkie-promise": "2.0.1" + } + }, + "pkg-dir": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-1.0.0.tgz", + "integrity": "sha1-ektQio1bstYp1EcFb/TpyTFM89Q=", + "requires": { + "find-up": "1.1.2" + } + } + } + }, + "eslint-plugin-flowtype": { + "version": "2.40.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-2.40.1.tgz", + "integrity": "sha512-0EBDPR3/iguDQin7nb5WMT1ZWYB95eNllY+oiFZjvLa1oqE0BGO6ZSFnMdNE9HEkajB6Cw850PRIBbp+O+EzYQ==", + "requires": { + "lodash": "4.17.4" + } + }, + "eslint-plugin-import": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.8.0.tgz", + "integrity": "sha512-Rf7dfKJxZ16QuTgVv1OYNxkZcsu/hULFnC+e+w0Gzi6jMC3guQoWQgxYxc54IDRinlb6/0v5z/PxxIKmVctN+g==", + "requires": { + "builtin-modules": "1.1.1", + "contains-path": "0.1.0", + "debug": "2.6.9", + "doctrine": "1.5.0", + "eslint-import-resolver-node": "0.3.1", + "eslint-module-utils": "2.1.1", + "has": "1.0.1", + "lodash.cond": "4.5.2", + "minimatch": "3.0.4", + "read-pkg-up": "2.0.0" + }, + "dependencies": { + "doctrine": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-1.5.0.tgz", + "integrity": "sha1-N53Ocw9hZvds76TmcHoVmwLFpvo=", + "requires": { + "esutils": "2.0.2", + "isarray": "1.0.0" + } + } + } + }, + "eslint-plugin-jsx-a11y": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.0.3.tgz", + "integrity": "sha1-VFg9GuRCSDFi4EDhPMMYZUZRAOU=", + "requires": { + "aria-query": "0.7.0", + "array-includes": "3.0.3", + "ast-types-flow": "0.0.7", + "axobject-query": "0.1.0", + "damerau-levenshtein": "1.0.4", + "emoji-regex": "6.5.1", + "jsx-ast-utils": "2.0.1" + } + }, + "eslint-plugin-react": { + "version": "7.5.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.5.1.tgz", + "integrity": "sha512-YGSjB9Qu6QbVTroUZi66pYky3DfoIPLdHQ/wmrBGyBRnwxQsBXAov9j2rpXt/55i8nyMv6IRWJv2s4d4YnduzQ==", + "requires": { + "doctrine": "2.0.2", + "has": "1.0.1", + "jsx-ast-utils": "2.0.1", + "prop-types": "15.6.0" + } + }, + "eslint-restricted-globals": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz", + "integrity": "sha1-NfDVy8ZMLj7WLpO0saevBbp+1Nc=" + }, + "eslint-scope": { + "version": "3.7.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-3.7.1.tgz", + "integrity": "sha1-PWPD7f2gLgbgGkUq2IyqzHzctug=", + "requires": { + "esrecurse": "4.2.0", + "estraverse": "4.2.0" + } + }, + "espree": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.2.tgz", + "integrity": "sha512-sadKeYwaR/aJ3stC2CdvgXu1T16TdYN+qwCpcWbMnGJ8s0zNWemzrvb2GbD4OhmJ/fwpJjudThAlLobGbWZbCQ==", + "requires": { + "acorn": "5.2.1", + "acorn-jsx": "3.0.1" + } + }, + "esprima": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz", + "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=" + }, + "esquery": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.0.0.tgz", + "integrity": "sha1-z7qLV9f7qT8XKYqKAGoEzaE9gPo=", + "requires": { + "estraverse": "4.2.0" + } + }, + "esrecurse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.0.tgz", + "integrity": "sha1-+pVo2Y04I/mkHZHpAtyrnqblsWM=", + "requires": { + "estraverse": "4.2.0", + "object-assign": "4.1.1" + } + }, + "estraverse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=" + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=" + }, + "event-emitter": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz", + "integrity": "sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.37" + } + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=" + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "requires": { + "md5.js": "1.3.4", + "safe-buffer": "5.1.1" + } + }, + "execa": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz", + "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", + "requires": { + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + } + }, + "expand-brackets": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz", + "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=", + "requires": { + "is-posix-bracket": "0.1.1" + } + }, + "expand-range": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz", + "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=", + "requires": { + "fill-range": "2.2.3" + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=" + }, + "external-editor": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.1.0.tgz", + "integrity": "sha512-E44iT5QVOUJBKij4IIV3uvxuNlbKS38Tw1HiupxEIHPv9qtC2PrDYohbXV5U+1jnfIXttny8gUhj+oZvflFlzA==", + "requires": { + "chardet": "0.4.2", + "iconv-lite": "0.4.19", + "tmp": "0.0.33" + } + }, + "extglob": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", + "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=", + "requires": { + "is-extglob": "1.0.0" + } + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "fast-deep-equal": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz", + "integrity": "sha1-liVqO8l1WV6zbYLpkp0GDYk0Of8=" + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=" + }, + "fastparse": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/fastparse/-/fastparse-1.1.1.tgz", + "integrity": "sha1-0eJkOzipTXWDtHkGDmxK/8lAcfg=" + }, + "fbjs": { + "version": "0.8.16", + "resolved": "https://registry.npmjs.org/fbjs/-/fbjs-0.8.16.tgz", + "integrity": "sha1-XmdDL1UNxBtXK/VYR7ispk5TN9s=", + "requires": { + "core-js": "1.2.7", + "isomorphic-fetch": "2.2.1", + "loose-envify": "1.3.1", + "object-assign": "4.1.1", + "promise": "7.3.1", + "setimmediate": "1.0.5", + "ua-parser-js": "0.7.17" + }, + "dependencies": { + "core-js": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-1.2.7.tgz", + "integrity": "sha1-ZSKUwUZR2yj6k70tX/KYOk8IxjY=" + } + } + }, + "figures": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz", + "integrity": "sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI=", + "requires": { + "escape-string-regexp": "1.0.5" + } + }, + "file-entry-cache": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-2.0.0.tgz", + "integrity": "sha1-w5KZDD5oR4PYOLjISkXYoEhFg2E=", + "requires": { + "flat-cache": "1.3.0", + "object-assign": "4.1.1" + } + }, + "file-loader": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-1.1.6.tgz", + "integrity": "sha512-873ztuL+/hfvXbLDJ262PGO6XjERnybJu2gW1/5j8HUfxSiFJI9Hj/DhZ50ZGRUxBvuNiazb/cM2rh9pqrxP6Q==", + "requires": { + "loader-utils": "1.1.0", + "schema-utils": "0.3.0" + } + }, + "filename-regex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz", + "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=" + }, + "fill-range": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.3.tgz", + "integrity": "sha1-ULd9/X5Gm8dJJHCWNpn+eoSFpyM=", + "requires": { + "is-number": "2.1.0", + "isobject": "2.1.0", + "randomatic": "1.1.7", + "repeat-element": "1.1.2", + "repeat-string": "1.6.1" + }, + "dependencies": { + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "requires": { + "isarray": "1.0.0" + } + } + } + }, + "find-cache-dir": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-1.0.0.tgz", + "integrity": "sha1-kojj6ePMN0hxfTnq3hfPcfww7m8=", + "requires": { + "commondir": "1.0.1", + "make-dir": "1.1.0", + "pkg-dir": "2.0.0" + } + }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "requires": { + "locate-path": "2.0.0" + } + }, + "flat-cache": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz", + "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=", + "requires": { + "circular-json": "0.3.3", + "del": "2.2.2", + "graceful-fs": "4.1.11", + "write": "0.2.1" + } + }, + "flatten": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/flatten/-/flatten-1.0.2.tgz", + "integrity": "sha1-2uRqnXj74lKSJYzB54CkHZXAN4I=" + }, + "flow-bin": { + "version": "0.61.0", + "resolved": "https://registry.npmjs.org/flow-bin/-/flow-bin-0.61.0.tgz", + "integrity": "sha512-w6SGi5CDfKLNGzYssRhW6N37qKclDXijsxDQ5M8c3WbivRYta0Horv22bwakegfKBVDnyeS0lRW3OqBC74eq2g==" + }, + "flow-bin-loader": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/flow-bin-loader/-/flow-bin-loader-1.0.2.tgz", + "integrity": "sha1-5c6CL/S51tXYJnAk21OnaYNIC+M=", + "requires": { + "child-process": "1.0.2" + } + }, + "flow-typed": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/flow-typed/-/flow-typed-2.2.3.tgz", + "integrity": "sha512-xCKOrKn/DnA4BPbNKyp3s2vW7Pzvff1zJhEdzNviTgwpiEkTG6uxQLjofcqvKdzTyZ/PjHBzkx02iyhP/2NrCg==", + "requires": { + "babel-polyfill": "6.26.0", + "colors": "1.1.2", + "fs-extra": "4.0.3", + "github": "0.2.4", + "glob": "7.1.2", + "got": "7.1.0", + "md5": "2.2.1", + "mkdirp": "0.5.1", + "request": "2.83.0", + "rimraf": "2.6.2", + "semver": "5.4.1", + "table": "4.0.2", + "through": "2.3.8", + "unzip": "0.1.11", + "which": "1.3.0", + "yargs": "4.8.1" + } + }, + "font-awesome": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/font-awesome/-/font-awesome-4.7.0.tgz", + "integrity": "sha1-j6jPBBGhoxr9B7BtKQK7n8gVoTM=" + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=" + }, + "for-own": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz", + "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=", + "requires": { + "for-in": "1.0.2" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=" + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.1.tgz", + "integrity": "sha1-b7lPvXGIUwbXPRXMSX/kzE7NRL8=", + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.5", + "mime-types": "2.1.17" + } + }, + "fs-extra": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz", + "integrity": "sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==", + "requires": { + "graceful-fs": "4.1.11", + "jsonfile": "4.0.0", + "universalify": "0.1.1" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fstream": { + "version": "0.1.31", + "resolved": "https://registry.npmjs.org/fstream/-/fstream-0.1.31.tgz", + "integrity": "sha1-czfwWPu7vvqMn1YaKMqwhJICyYg=", + "requires": { + "graceful-fs": "3.0.11", + "inherits": "2.0.3", + "mkdirp": "0.5.1", + "rimraf": "2.6.2" + }, + "dependencies": { + "graceful-fs": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-3.0.11.tgz", + "integrity": "sha1-dhPHeKGv6mLyXGMKCG1/Osu92Bg=", + "requires": { + "natives": "1.1.1" + } + } + } + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=" + }, + "get-caller-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz", + "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=" + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=" + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "1.0.0" + } + }, + "github": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/github/-/github-0.2.4.tgz", + "integrity": "sha1-JPp/DhP6EblGr5ETTFGYKpHOU4s=", + "requires": { + "mime": "1.6.0" + } + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "glob-base": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz", + "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=", + "requires": { + "glob-parent": "2.0.0", + "is-glob": "2.0.1" + } + }, + "glob-parent": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz", + "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=", + "requires": { + "is-glob": "2.0.1" + } + }, + "global": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/global/-/global-4.3.2.tgz", + "integrity": "sha1-52mJJopsdMOJCLEwWxD8DjlOnQ8=", + "requires": { + "min-document": "2.19.0", + "process": "0.5.2" + } + }, + "globals": { + "version": "9.18.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz", + "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==" + }, + "globby": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz", + "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=", + "requires": { + "array-union": "1.0.2", + "arrify": "1.0.1", + "glob": "7.1.2", + "object-assign": "4.1.1", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + }, + "got": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz", + "integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==", + "requires": { + "decompress-response": "3.3.0", + "duplexer3": "0.1.4", + "get-stream": "3.0.0", + "is-plain-obj": "1.1.0", + "is-retry-allowed": "1.1.0", + "is-stream": "1.1.0", + "isurl": "1.0.0", + "lowercase-keys": "1.0.0", + "p-cancelable": "0.3.0", + "p-timeout": "1.2.1", + "safe-buffer": "5.1.1", + "timed-out": "4.0.1", + "url-parse-lax": "1.0.0", + "url-to-options": "1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + }, + "har-validator": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.0.3.tgz", + "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", + "requires": { + "ajv": "5.5.2", + "har-schema": "2.0.0" + } + }, + "has": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.1.tgz", + "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=", + "requires": { + "function-bind": "1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "requires": { + "ansi-regex": "2.1.1" + } + }, + "has-flag": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz", + "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=" + }, + "has-symbol-support-x": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.1.tgz", + "integrity": "sha512-JkaetveU7hFbqnAC1EV1sF4rlojU2D4Usc5CmS69l6NfmPDnpnFUegzFg33eDkkpNCxZ0mQp65HwUDrNFS/8MA==" + }, + "has-to-string-tag-x": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz", + "integrity": "sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==", + "requires": { + "has-symbol-support-x": "1.4.1" + } + }, + "hash-base": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-2.0.2.tgz", + "integrity": "sha1-ZuodhW206KVHDK32/OI65SRO8uE=", + "requires": { + "inherits": "2.0.3" + } + }, + "hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "hawk": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/hawk/-/hawk-6.0.2.tgz", + "integrity": "sha512-miowhl2+U7Qle4vdLqDdPt9m09K6yZhkLDTWGoUiUzrQCn+mHHSmfJgAyGaLRZbPmTqfFFjRV1QWCW0VWUJBbQ==", + "requires": { + "boom": "4.3.1", + "cryptiles": "3.1.2", + "hoek": "4.2.0", + "sntp": "2.1.0" + } + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "requires": { + "hash.js": "1.1.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "hoek": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/hoek/-/hoek-4.2.0.tgz", + "integrity": "sha512-v0XCLxICi9nPfYrS9RL8HbYnXi9obYAeLbSP00BmnZwCK9+Ih9WOjoZ8YoHCoav2csqn4FOz4Orldsy2dmDwmQ==" + }, + "hoist-non-react-statics": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-2.3.1.tgz", + "integrity": "sha1-ND24TGAYxlB3iJgkATWhQg7iLOA=" + }, + "home-or-tmp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz", + "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "hosted-git-info": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.5.0.tgz", + "integrity": "sha512-pNgbURSuab90KbTqvRPsseaTxOJCZBD0a7t+haSN33piP9cCM4l0CqdzAif2hUqm716UovKB2ROmiabGAKVXyg==" + }, + "html-comment-regex": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/html-comment-regex/-/html-comment-regex-1.1.1.tgz", + "integrity": "sha1-ZouTd26q5V696POtRkswekljYl4=" + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "requires": { + "assert-plus": "1.0.0", + "jsprim": "1.4.1", + "sshpk": "1.13.1" + } + }, + "https-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", + "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=" + }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==" + }, + "icss-replace-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/icss-replace-symbols/-/icss-replace-symbols-1.1.0.tgz", + "integrity": "sha1-Bupvg2ead0njhs/h/oEq5dsiPe0=" + }, + "icss-utils": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-2.1.0.tgz", + "integrity": "sha1-g/Cg7DeL8yRheLbCrZE28TWxyWI=", + "requires": { + "postcss": "6.0.14" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "postcss": { + "version": "6.0.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.14.tgz", + "integrity": "sha512-NJ1z0f+1offCgadPhz+DvGm5Mkci+mmV5BqD13S992o0Xk9eElxUfPPF+t2ksH5R/17gz4xVK8KWocUQ5o3Rog==", + "requires": { + "chalk": "2.3.0", + "source-map": "0.6.1", + "supports-color": "4.5.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "ieee754": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.8.tgz", + "integrity": "sha1-vjPUCsEO8ZJnAfbwii2G+/0a0+Q=" + }, + "ignore": { + "version": "3.3.7", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.7.tgz", + "integrity": "sha512-YGG3ejvBNHRqu0559EOxxNFihD0AjpvHlC/pdGKd3X3ofe+CoJkYazwNJYTNebqpPKN+VVQbh4ZFn1DivMNuHA==" + }, + "imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha1-khi5srkoojixPcT7a21XbyMUU+o=" + }, + "indexes-of": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/indexes-of/-/indexes-of-1.0.1.tgz", + "integrity": "sha1-8w9xbI4r00bHtn0985FVZqfAVgc=" + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "inquirer": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-3.3.0.tgz", + "integrity": "sha512-h+xtnyk4EwKvFWHrUYsWErEVR+igKtLdchu+o0Z1RL7VU/jVMFbYir2bp6bAj8efFNxWqHX0dIss6fJQ+/+qeQ==", + "requires": { + "ansi-escapes": "3.0.0", + "chalk": "2.3.0", + "cli-cursor": "2.1.0", + "cli-width": "2.2.0", + "external-editor": "2.1.0", + "figures": "2.0.0", + "lodash": "4.17.4", + "mute-stream": "0.0.7", + "run-async": "2.3.0", + "rx-lite": "4.0.8", + "rx-lite-aggregates": "4.0.8", + "string-width": "2.1.1", + "strip-ansi": "4.0.0", + "through": "2.3.8" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" + }, + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "requires": { + "ansi-regex": "3.0.0" + } + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "interpret": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.1.0.tgz", + "integrity": "sha1-ftGxQQxqDg94z5XTuEQMY/eLhhQ=" + }, + "invariant": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.2.tgz", + "integrity": "sha1-nh9WrArNtr8wMwbzOL47IErmA2A=", + "requires": { + "loose-envify": "1.3.1" + } + }, + "invert-kv": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", + "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=" + }, + "is-absolute-url": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-absolute-url/-/is-absolute-url-2.1.0.tgz", + "integrity": "sha1-UFMN+4T8yap9vnhS6Do3uTufKqY=" + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=" + }, + "is-binary-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", + "requires": { + "binary-extensions": "1.11.0" + } + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==" + }, + "is-builtin-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", + "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", + "requires": { + "builtin-modules": "1.1.1" + } + }, + "is-callable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz", + "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=" + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=" + }, + "is-dotfile": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", + "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=" + }, + "is-equal-shallow": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz", + "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=", + "requires": { + "is-primitive": "2.0.0" + } + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=" + }, + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=" + }, + "is-finite": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz", + "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=" + }, + "is-function": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-function/-/is-function-1.0.1.tgz", + "integrity": "sha1-Es+5i2W1fdPRk6MSH19uL0N2ArU=" + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "requires": { + "is-extglob": "1.0.0" + } + }, + "is-in-browser": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-in-browser/-/is-in-browser-1.1.3.tgz", + "integrity": "sha1-Vv9NtoOgeMYILrldrX3GLh0E+DU=" + }, + "is-number": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz", + "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=", + "requires": { + "kind-of": "3.2.2" + } + }, + "is-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz", + "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=" + }, + "is-path-cwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz", + "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=" + }, + "is-path-in-cwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz", + "integrity": "sha1-ZHdYK4IU1gI0YJRWcAO+ip6sBNw=", + "requires": { + "is-path-inside": "1.0.1" + } + }, + "is-path-inside": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.1.tgz", + "integrity": "sha1-jvW33lBDej/cprToZe96pVy0gDY=", + "requires": { + "path-is-inside": "1.0.2" + } + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=" + }, + "is-plain-object": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz", + "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==", + "requires": { + "isobject": "3.0.1" + } + }, + "is-posix-bracket": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz", + "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=" + }, + "is-primitive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz", + "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=" + }, + "is-promise": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-2.1.0.tgz", + "integrity": "sha1-eaKp7OfwlugPNtKy87wWwf9L8/o=" + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "requires": { + "has": "1.0.1" + } + }, + "is-resolvable": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.0.1.tgz", + "integrity": "sha512-y5CXYbzvB3jTnWAZH1Nl7ykUWb6T3BcTs56HUruwBf8MhF56n1HWqhDWnVFo8GHrUPDgvUUNVhrc2U8W7iqz5g==" + }, + "is-retry-allowed": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz", + "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=" + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "is-svg": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-svg/-/is-svg-2.1.0.tgz", + "integrity": "sha1-z2EJDaDZ77yrhyLeum8DIgjbsOk=", + "requires": { + "html-comment-regex": "1.1.1" + } + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=" + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-utf8": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=" + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=" + }, + "isobject": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz", + "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=" + }, + "isomorphic-fetch": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/isomorphic-fetch/-/isomorphic-fetch-2.2.1.tgz", + "integrity": "sha1-YRrhrPFPXoH3KVB0coGf6XM1WKk=", + "requires": { + "node-fetch": "1.7.3", + "whatwg-fetch": "2.0.3" + } + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "isurl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz", + "integrity": "sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==", + "requires": { + "has-to-string-tag-x": "1.4.1", + "is-object": "1.0.1" + } + }, + "js-base64": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-2.4.0.tgz", + "integrity": "sha512-Wehd+7Pf9tFvGb+ydPm9TjYjV8X1YHOVyG8QyELZxEMqOhemVwGRmoG8iQ/soqI3n8v4xn59zaLxiCJiaaRzKA==" + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=" + }, + "js-yaml": { + "version": "3.7.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.7.0.tgz", + "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=", + "requires": { + "argparse": "1.0.9", + "esprima": "2.7.3" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "optional": true + }, + "jsesc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", + "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=" + }, + "json-loader": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/json-loader/-/json-loader-0.5.7.tgz", + "integrity": "sha512-QLPs8Dj7lnf3e3QYS1zkCo+4ZwqOiF9d/nZnYozTISxXWCfNs9yuky5rJw4/W34s7POaNlbZmQGaB5NiXCbP4w==" + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + }, + "json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE=" + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json5": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", + "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=" + }, + "jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=", + "requires": { + "graceful-fs": "4.1.11" + } + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "jss": { + "version": "9.4.0", + "resolved": "https://registry.npmjs.org/jss/-/jss-9.4.0.tgz", + "integrity": "sha512-ckJpElL5CimehboeLDQoHeY7mlxn0KPnPn2EZVbn6pomhfbTXiQJ6fAJXSp9rUM2hPtE0PG8Swzdy9vhB2v82w==", + "requires": { + "is-in-browser": "1.1.3", + "symbol-observable": "1.1.0", + "warning": "3.0.0" + } + }, + "jss-camel-case": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/jss-camel-case/-/jss-camel-case-6.0.0.tgz", + "integrity": "sha512-XAYa7JpGkLdlLgEfuzSQSVONRzSVvv4Tvyv5H8hLmJuHeFHTWwVrJrW1Cg/buED3izXKwTU2KBGpeXjIR5Eaew==" + }, + "jss-compose": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/jss-compose/-/jss-compose-5.0.0.tgz", + "integrity": "sha512-YofRYuiA0+VbeOw0VjgkyO380sA4+TWDrW52nSluD9n+1FWOlDzNbgpZ/Sb3Y46+DcAbOS21W5jo6SAqUEiuwA==", + "requires": { + "warning": "3.0.0" + } + }, + "jss-default-unit": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/jss-default-unit/-/jss-default-unit-8.0.2.tgz", + "integrity": "sha512-WxNHrF/18CdoAGw2H0FqOEvJdREXVXLazn7PQYU7V6/BWkCV0GkmWsppNiExdw8dP4TU1ma1dT9zBNJ95feLmg==" + }, + "jss-expand": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/jss-expand/-/jss-expand-5.1.0.tgz", + "integrity": "sha512-WTxmNipgj0V8kr8gc8Gc6Et7uQZH60H7FFNG9zZHjR6TPJoj7TDK+/EBxwRHtCRQD4B8RTwoa7MyEKD4ReKfXw==" + }, + "jss-extend": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jss-extend/-/jss-extend-6.1.0.tgz", + "integrity": "sha512-bSNwLDOZnMxABsUqvq2lwLJ/MMFs8ThligiLZBOUeyoZCoHqAbcTghvunk2QDVxiOhRTDS57VvhXVJZETW58Bw==", + "requires": { + "warning": "3.0.0" + } + }, + "jss-global": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/jss-global/-/jss-global-3.0.0.tgz", + "integrity": "sha512-wxYn7vL+TImyQYGAfdplg7yaxnPQ9RaXY/cIA8hawaVnmmWxDHzBK32u1y+RAvWboa3lW83ya3nVZ/C+jyjZ5Q==" + }, + "jss-nested": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/jss-nested/-/jss-nested-6.0.1.tgz", + "integrity": "sha512-rn964TralHOZxoyEgeq3hXY8hyuCElnvQoVrQwKHVmu55VRDd6IqExAx9be5HgK0yN/+hQdgAXQl/GUrBbbSTA==", + "requires": { + "warning": "3.0.0" + } + }, + "jss-preset-default": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/jss-preset-default/-/jss-preset-default-4.0.1.tgz", + "integrity": "sha512-ZBj1ifZAPDn8iiC9PuB1jDCm/I0Bn53UNL9NHBgOY6AyMorDPgEb3IRjt6H+OHKwnEuCHw8tC/e3/q4I4DgTIw==", + "requires": { + "jss-camel-case": "6.0.0", + "jss-compose": "5.0.0", + "jss-default-unit": "8.0.2", + "jss-expand": "5.1.0", + "jss-extend": "6.1.0", + "jss-global": "3.0.0", + "jss-nested": "6.0.1", + "jss-props-sort": "6.0.0", + "jss-template": "1.0.0", + "jss-vendor-prefixer": "7.0.0" + } + }, + "jss-props-sort": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/jss-props-sort/-/jss-props-sort-6.0.0.tgz", + "integrity": "sha512-E89UDcrphmI0LzmvYk25Hp4aE5ZBsXqMWlkFXS0EtPkunJkRr+WXdCNYbXbksIPnKlBenGB9OxzQY+mVc70S+g==" + }, + "jss-template": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/jss-template/-/jss-template-1.0.0.tgz", + "integrity": "sha512-NFAgcAp8V2fUxffWGGQ5zAolJq3neAvNjmWIwSmy9M6bmXTK9rnTu0fBlAcUh0ALC94B596/2TRphdkE5WRECQ==", + "requires": { + "warning": "3.0.0" + } + }, + "jss-vendor-prefixer": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/jss-vendor-prefixer/-/jss-vendor-prefixer-7.0.0.tgz", + "integrity": "sha512-Agd+FKmvsI0HLcYXkvy8GYOw3AAASBUpsmIRvVQheps+JWaN892uFOInTr0DRydwaD91vSSUCU4NssschvF7MA==", + "requires": { + "css-vendor": "0.3.8" + } + }, + "jsx-ast-utils": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-2.0.1.tgz", + "integrity": "sha1-6AGxs5mF4g//yHtA43SAgOLcrH8=", + "requires": { + "array-includes": "3.0.3" + } + }, + "keycode": { + "version": "2.1.9", + "resolved": "https://registry.npmjs.org/keycode/-/keycode-2.1.9.tgz", + "integrity": "sha1-lkojxU5IiUBbSGGlyfBIDUUUHfo=" + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "requires": { + "is-buffer": "1.1.6" + } + }, + "lazy-cache": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz", + "integrity": "sha1-odePw6UEdMuAhF07O24dpJpEbo4=" + }, + "lcid": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", + "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", + "requires": { + "invert-kv": "1.0.0" + } + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "requires": { + "prelude-ls": "1.1.2", + "type-check": "0.3.2" + } + }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "strip-bom": "3.0.0" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + }, + "loader-fs-cache": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/loader-fs-cache/-/loader-fs-cache-1.0.1.tgz", + "integrity": "sha1-VuC/CL2XCLJqdltoUJhAyN7J/bw=", + "requires": { + "find-cache-dir": "0.1.1", + "mkdirp": "0.5.1" + }, + "dependencies": { + "find-cache-dir": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-0.1.1.tgz", + "integrity": "sha1-yN765XyKUqinhPnjHFfHQumToLk=", + "requires": { + "commondir": "1.0.1", + "mkdirp": "0.5.1", + "pkg-dir": "1.0.0" + } + }, + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "requires": { + "pinkie-promise": "2.0.1" + } + }, + "pkg-dir": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-1.0.0.tgz", + "integrity": "sha1-ektQio1bstYp1EcFb/TpyTFM89Q=", + "requires": { + "find-up": "1.1.2" + } + } + } + }, + "loader-runner": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-2.3.0.tgz", + "integrity": "sha1-9IKuqC1UPgeSFwDVpG7yb9rGuKI=" + }, + "loader-utils": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-1.1.0.tgz", + "integrity": "sha1-yYrvSIvM7aL/teLeZG1qdUQp9c0=", + "requires": { + "big.js": "3.2.0", + "emojis-list": "2.1.0", + "json5": "0.5.1" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "requires": { + "p-locate": "2.0.0", + "path-exists": "3.0.0" + } + }, + "lodash": { + "version": "4.17.4", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.4.tgz", + "integrity": "sha1-eCA6TRwyiuHYbcpkYONptX9AVa4=" + }, + "lodash.assign": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", + "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=" + }, + "lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha1-soqmKIorn8ZRA1x3EfZathkDMaY=" + }, + "lodash.cond": { + "version": "4.5.2", + "resolved": "https://registry.npmjs.org/lodash.cond/-/lodash.cond-4.5.2.tgz", + "integrity": "sha1-9HGh2khr5g9quVXRcRVSPdHSVdU=" + }, + "lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4=" + }, + "lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha1-0CJTc662Uq3BvILklFM5qEJ1R3M=" + }, + "longest": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz", + "integrity": "sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=" + }, + "loose-envify": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.3.1.tgz", + "integrity": "sha1-0aitM/qc4OcT1l/dCsi3SNR4yEg=", + "requires": { + "js-tokens": "3.0.2" + } + }, + "lowercase-keys": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.0.tgz", + "integrity": "sha1-TjNms55/VFfjXxMkvfb4jQv8cwY=" + }, + "lru-cache": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.1.tgz", + "integrity": "sha512-q4spe4KTfsAS1SUHLO0wz8Qiyf1+vMIAgpRYioFYDMNqKfHQbg+AVDH3i4fvpl71/P1L0dBl+fQi+P37UYf0ew==", + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + } + }, + "macaddress": { + "version": "0.2.8", + "resolved": "https://registry.npmjs.org/macaddress/-/macaddress-0.2.8.tgz", + "integrity": "sha1-WQTcU3w57G2+/q6QIycTX6hRHxI=" + }, + "make-dir": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.1.0.tgz", + "integrity": "sha512-0Pkui4wLJ7rxvmfUvs87skoEaxmu0hCUApF8nonzpl7q//FWp9zu8W61Scz4sd/kUiqDxvUhtoam2efDyiBzcA==", + "requires": { + "pify": "3.0.0" + } + }, + "match-stream": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/match-stream/-/match-stream-0.0.2.tgz", + "integrity": "sha1-mesFAJOzTf+t5CG5rAtBCpz6F88=", + "requires": { + "buffers": "0.1.1", + "readable-stream": "1.0.34" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "material-ui": { + "version": "1.0.0-beta.24", + "resolved": "https://registry.npmjs.org/material-ui/-/material-ui-1.0.0-beta.24.tgz", + "integrity": "sha512-tPKQeR9RXXSJFj/QIhU5+mAnnZm5Gk6WcTufbVBDd0946wpfMJA2NY2J+M/SK9NXe+BTTVUCnWY92UCw5YA9tA==", + "requires": { + "babel-runtime": "6.26.0", + "brcast": "3.0.1", + "classnames": "2.2.5", + "deepmerge": "2.0.1", + "dom-helpers": "3.3.1", + "hoist-non-react-statics": "2.3.1", + "jss": "9.4.0", + "jss-preset-default": "4.0.1", + "keycode": "2.1.9", + "lodash": "4.17.4", + "normalize-scroll-left": "0.1.2", + "prop-types": "15.6.0", + "react-event-listener": "0.5.2", + "react-jss": "8.2.0", + "react-popper": "0.7.4", + "react-scrollbar-size": "2.0.2", + "react-transition-group": "2.2.1", + "recompose": "0.26.0", + "scroll": "2.0.1", + "warning": "3.0.0" + } + }, + "material-ui-icons": { + "version": "1.0.0-beta.17", + "resolved": "https://registry.npmjs.org/material-ui-icons/-/material-ui-icons-1.0.0-beta.17.tgz", + "integrity": "sha1-XxmvVKLZnu7zR6VUFKaFPhyFDcM=", + "requires": { + "recompose": "0.26.0" + } + }, + "math-expression-evaluator": { + "version": "1.2.17", + "resolved": "https://registry.npmjs.org/math-expression-evaluator/-/math-expression-evaluator-1.2.17.tgz", + "integrity": "sha1-3oGf282E3M2PrlnGrreWFbnSZqw=" + }, + "md5": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/md5/-/md5-2.2.1.tgz", + "integrity": "sha1-U6s41f48iJG6RlMp6iP6wFQBJvk=", + "requires": { + "charenc": "0.0.2", + "crypt": "0.0.2", + "is-buffer": "1.1.6" + } + }, + "md5.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz", + "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", + "requires": { + "hash-base": "3.0.4", + "inherits": "2.0.3" + }, + "dependencies": { + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + } + } + }, + "mem": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mem/-/mem-1.1.0.tgz", + "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=", + "requires": { + "mimic-fn": "1.1.0" + } + }, + "memory-fs": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz", + "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=", + "requires": { + "errno": "0.1.6", + "readable-stream": "2.3.3" + } + }, + "micromatch": { + "version": "2.3.11", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz", + "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=", + "requires": { + "arr-diff": "2.0.0", + "array-unique": "0.2.1", + "braces": "1.8.5", + "expand-brackets": "0.1.5", + "extglob": "0.3.2", + "filename-regex": "2.0.1", + "is-extglob": "1.0.0", + "is-glob": "2.0.1", + "kind-of": "3.2.2", + "normalize-path": "2.1.1", + "object.omit": "2.0.1", + "parse-glob": "3.0.4", + "regex-cache": "0.4.4" + } + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0" + } + }, + "mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==" + }, + "mime-db": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.30.0.tgz", + "integrity": "sha1-dMZD2i3Z1qRTmZY0ZbJtXKfXHwE=" + }, + "mime-types": { + "version": "2.1.17", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.17.tgz", + "integrity": "sha1-Cdejk/A+mVp5+K+Fe3Cp4KsWVXo=", + "requires": { + "mime-db": "1.30.0" + } + }, + "mimic-fn": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.1.0.tgz", + "integrity": "sha1-5md4PZLonb00KBi1IwudYqZyrRg=" + }, + "mimic-response": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.0.tgz", + "integrity": "sha1-3z02Uqc/3ta5sLJBRub9BSNTRY4=" + }, + "min-document": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/min-document/-/min-document-2.19.0.tgz", + "integrity": "sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU=", + "requires": { + "dom-walk": "0.1.1" + } + }, + "minimalistic-assert": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.0.tgz", + "integrity": "sha1-cCvi3aazf0g2vLP121ZkG2Sh09M=" + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.8" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "mute-stream": { + "version": "0.0.7", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz", + "integrity": "sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s=" + }, + "natives": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/natives/-/natives-1.1.1.tgz", + "integrity": "sha512-8eRaxn8u/4wN8tGkhlc2cgwwvOLMLUMUn4IYTexMgWd+LyUDfeXVkk2ygQR0hvIHbJQXgHujia3ieUUDwNGkEA==" + }, + "natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=" + }, + "node-fetch": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.3.tgz", + "integrity": "sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==", + "requires": { + "encoding": "0.1.12", + "is-stream": "1.1.0" + } + }, + "node-libs-browser": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.1.0.tgz", + "integrity": "sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==", + "requires": { + "assert": "1.4.1", + "browserify-zlib": "0.2.0", + "buffer": "4.9.1", + "console-browserify": "1.1.0", + "constants-browserify": "1.0.0", + "crypto-browserify": "3.12.0", + "domain-browser": "1.1.7", + "events": "1.1.1", + "https-browserify": "1.0.0", + "os-browserify": "0.3.0", + "path-browserify": "0.0.0", + "process": "0.11.10", + "punycode": "1.4.1", + "querystring-es3": "0.2.1", + "readable-stream": "2.3.3", + "stream-browserify": "2.0.1", + "stream-http": "2.7.2", + "string_decoder": "1.0.3", + "timers-browserify": "2.0.4", + "tty-browserify": "0.0.0", + "url": "0.11.0", + "util": "0.10.3", + "vm-browserify": "0.0.4" + }, + "dependencies": { + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=" + } + } + }, + "normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", + "requires": { + "hosted-git-info": "2.5.0", + "is-builtin-module": "1.0.0", + "semver": "5.4.1", + "validate-npm-package-license": "3.0.1" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "requires": { + "remove-trailing-separator": "1.1.0" + } + }, + "normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha1-LRDAa9/TEuqXd2laTShDlFa3WUI=" + }, + "normalize-scroll-left": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-scroll-left/-/normalize-scroll-left-0.1.2.tgz", + "integrity": "sha512-F9YMRls0zCF6BFIE2YnXDRpHPpfd91nOIaNdDgrx5YMoPLo8Wqj+6jNXHQsYBavJeXP4ww8HCt0xQAKc5qk2Fg==" + }, + "normalize-url": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-1.9.1.tgz", + "integrity": "sha1-LMDWazHqIwNkWENuNiDYWVTGbDw=", + "requires": { + "object-assign": "4.1.1", + "prepend-http": "1.0.4", + "query-string": "4.3.4", + "sort-keys": "1.1.2" + } + }, + "npm-run-path": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", + "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", + "requires": { + "path-key": "2.0.1" + } + }, + "num2fraction": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/num2fraction/-/num2fraction-1.2.2.tgz", + "integrity": "sha1-b2gragJ6Tp3fpFZM0lidHU5mnt4=" + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=" + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-1.2.0.tgz", + "integrity": "sha512-smRWXzkvxw72VquyZ0wggySl7PFUtoDhvhpdwgESXxUrH7vVhhp9asfup1+rVLrhsl7L45Ee1Q/l5R2Ul4MwUg==" + }, + "object-keys": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.11.tgz", + "integrity": "sha1-xUYBd4rVYPEULODgG8yotW0TQm0=" + }, + "object.omit": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", + "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=", + "requires": { + "for-own": "0.1.5", + "is-extendable": "0.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } + }, + "onetime": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz", + "integrity": "sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ=", + "requires": { + "mimic-fn": "1.1.0" + } + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "requires": { + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" + } + }, + "os-browserify": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", + "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=" + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=" + }, + "os-locale": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", + "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", + "requires": { + "lcid": "1.0.0" + } + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=" + }, + "over": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/over/-/over-0.0.5.tgz", + "integrity": "sha1-8phS5w/X4l82DgE6jsRMgq7bVwg=" + }, + "p-cancelable": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz", + "integrity": "sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==" + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=" + }, + "p-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.1.0.tgz", + "integrity": "sha1-sH/y2aXYi+yAYDWJWiurZqJ5iLw=" + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "requires": { + "p-limit": "1.1.0" + } + }, + "p-timeout": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz", + "integrity": "sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=", + "requires": { + "p-finally": "1.0.0" + } + }, + "pako": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.6.tgz", + "integrity": "sha512-lQe48YPsMJAig+yngZ87Lus+NF+3mtu7DVOBu6b/gHO1YpKwIj5AWjZ/TOS7i46HD/UixzWb1zeWDZfGZ3iYcg==" + }, + "parse-asn1": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.0.tgz", + "integrity": "sha1-N8T5t+06tlx0gXtfJICTf7+XxxI=", + "requires": { + "asn1.js": "4.9.2", + "browserify-aes": "1.1.1", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "pbkdf2": "3.0.14" + } + }, + "parse-glob": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz", + "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=", + "requires": { + "glob-base": "0.3.0", + "is-dotfile": "1.0.3", + "is-extglob": "1.0.0", + "is-glob": "2.0.1" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "requires": { + "error-ex": "1.3.1" + } + }, + "path": { + "version": "0.12.7", + "resolved": "https://registry.npmjs.org/path/-/path-0.12.7.tgz", + "integrity": "sha1-1NwqUGxM4hl+tIHr/NWzbAFAsQ8=", + "requires": { + "process": "0.11.10", + "util": "0.10.3" + }, + "dependencies": { + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=" + } + } + }, + "path-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", + "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=" + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=" + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-is-inside": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz", + "integrity": "sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM=" + }, + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=" + }, + "path-parse": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", + "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=" + }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "requires": { + "pify": "2.3.0" + }, + "dependencies": { + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + } + } + }, + "pbkdf2": { + "version": "3.0.14", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.14.tgz", + "integrity": "sha512-gjsZW9O34fm0R7PaLHRJmLLVfSoesxztjPjE9o6R+qtVJij90ltg1joIovN9GKrRW3t1PzhDDG3UMEMFfZ+1wA==", + "requires": { + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.9" + } + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=" + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=" + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "requires": { + "pinkie": "2.0.4" + } + }, + "pkg-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-2.0.0.tgz", + "integrity": "sha1-9tXREJ4Z1j7fQo4L1X4Sd3YVM0s=", + "requires": { + "find-up": "2.1.0" + } + }, + "pluralize": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-7.0.0.tgz", + "integrity": "sha512-ARhBOdzS3e41FbkW/XWrTEtukqqLoK5+Z/4UeDaLuSW+39JPeFgs4gCGqsrJHVZX0fUrx//4OF0K1CUGwlIFow==" + }, + "popper.js": { + "version": "1.12.9", + "resolved": "https://registry.npmjs.org/popper.js/-/popper.js-1.12.9.tgz", + "integrity": "sha1-DfvC3/lsRRuzMu3Pz6r1ZtMx1bM=" + }, + "postcss": { + "version": "5.2.18", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-5.2.18.tgz", + "integrity": "sha512-zrUjRRe1bpXKsX1qAJNJjqZViErVuyEkMTRrwu4ud4sbTtIBRmtaYDrHmcGgmrbsW3MHfmtIf+vJumgQn+PrXg==", + "requires": { + "chalk": "1.1.3", + "js-base64": "2.4.0", + "source-map": "0.5.7", + "supports-color": "3.2.3" + }, + "dependencies": { + "has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo=" + }, + "supports-color": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz", + "integrity": "sha1-ZawFBLOVQXHYpklGsq48u4pfVPY=", + "requires": { + "has-flag": "1.0.0" + } + } + } + }, + "postcss-calc": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-5.3.1.tgz", + "integrity": "sha1-d7rnypKK2FcW4v2kLyYb98HWW14=", + "requires": { + "postcss": "5.2.18", + "postcss-message-helpers": "2.0.0", + "reduce-css-calc": "1.3.0" + } + }, + "postcss-colormin": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-2.2.2.tgz", + "integrity": "sha1-ZjFBfV8OkJo9fsJrJMio0eT5bks=", + "requires": { + "colormin": "1.1.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-convert-values": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-2.6.1.tgz", + "integrity": "sha1-u9hZPFwf0uPRwyK7kl3K6Nrk1i0=", + "requires": { + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-discard-comments": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-2.0.4.tgz", + "integrity": "sha1-vv6J+v1bPazlzM5Rt2uBUUvgDj0=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-discard-duplicates": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-2.1.0.tgz", + "integrity": "sha1-uavye4isGIFYpesSq8riAmO5GTI=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-discard-empty": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-2.1.0.tgz", + "integrity": "sha1-0rS9nVztXr2Nyt52QMfXzX9PkrU=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-discard-overridden": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-0.1.1.tgz", + "integrity": "sha1-ix6vVU9ob7KIzYdMVWZ7CqNmjVg=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-discard-unused": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-2.2.3.tgz", + "integrity": "sha1-vOMLLMWR/8Y0Mitfs0ZLbZNPRDM=", + "requires": { + "postcss": "5.2.18", + "uniqs": "2.0.0" + } + }, + "postcss-filter-plugins": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/postcss-filter-plugins/-/postcss-filter-plugins-2.0.2.tgz", + "integrity": "sha1-bYWGJTTXNaxCDkqFgG4fXUKG2Ew=", + "requires": { + "postcss": "5.2.18", + "uniqid": "4.1.1" + } + }, + "postcss-merge-idents": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-2.1.7.tgz", + "integrity": "sha1-TFUwMTwI4dWzu/PSu8dH4njuonA=", + "requires": { + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-merge-longhand": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-2.0.2.tgz", + "integrity": "sha1-I9kM0Sewp3mUkVMyc5A0oaTz1lg=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-merge-rules": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-2.1.2.tgz", + "integrity": "sha1-0d9d+qexrMO+VT8OnhDofGG19yE=", + "requires": { + "browserslist": "1.7.7", + "caniuse-api": "1.6.1", + "postcss": "5.2.18", + "postcss-selector-parser": "2.2.3", + "vendors": "1.0.1" + }, + "dependencies": { + "browserslist": { + "version": "1.7.7", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz", + "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=", + "requires": { + "caniuse-db": "1.0.30000784", + "electron-to-chromium": "1.3.30" + } + } + } + }, + "postcss-message-helpers": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/postcss-message-helpers/-/postcss-message-helpers-2.0.0.tgz", + "integrity": "sha1-pPL0+rbk/gAvCu0ABHjN9S+bpg4=" + }, + "postcss-minify-font-values": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-1.0.5.tgz", + "integrity": "sha1-S1jttWZB66fIR0qzUmyv17vey2k=", + "requires": { + "object-assign": "4.1.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-minify-gradients": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-1.0.5.tgz", + "integrity": "sha1-Xb2hE3NwP4PPtKPqOIHY11/15uE=", + "requires": { + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-minify-params": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-1.2.2.tgz", + "integrity": "sha1-rSzgcTc7lDs9kwo/pZo1jCjW8fM=", + "requires": { + "alphanum-sort": "1.0.2", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0", + "uniqs": "2.0.0" + } + }, + "postcss-minify-selectors": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-2.1.1.tgz", + "integrity": "sha1-ssapjAByz5G5MtGkllCBFDEXNb8=", + "requires": { + "alphanum-sort": "1.0.2", + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-selector-parser": "2.2.3" + } + }, + "postcss-modules-extract-imports": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-1.1.0.tgz", + "integrity": "sha1-thTJcgvmgW6u41+zpfqh26agXds=", + "requires": { + "postcss": "6.0.14" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "postcss": { + "version": "6.0.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.14.tgz", + "integrity": "sha512-NJ1z0f+1offCgadPhz+DvGm5Mkci+mmV5BqD13S992o0Xk9eElxUfPPF+t2ksH5R/17gz4xVK8KWocUQ5o3Rog==", + "requires": { + "chalk": "2.3.0", + "source-map": "0.6.1", + "supports-color": "4.5.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "postcss-modules-local-by-default": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-1.2.0.tgz", + "integrity": "sha1-99gMOYxaOT+nlkRmvRlQCn1hwGk=", + "requires": { + "css-selector-tokenizer": "0.7.0", + "postcss": "6.0.14" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "postcss": { + "version": "6.0.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.14.tgz", + "integrity": "sha512-NJ1z0f+1offCgadPhz+DvGm5Mkci+mmV5BqD13S992o0Xk9eElxUfPPF+t2ksH5R/17gz4xVK8KWocUQ5o3Rog==", + "requires": { + "chalk": "2.3.0", + "source-map": "0.6.1", + "supports-color": "4.5.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "postcss-modules-scope": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-1.1.0.tgz", + "integrity": "sha1-1upkmUx5+XtipytCb75gVqGUu5A=", + "requires": { + "css-selector-tokenizer": "0.7.0", + "postcss": "6.0.14" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "postcss": { + "version": "6.0.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.14.tgz", + "integrity": "sha512-NJ1z0f+1offCgadPhz+DvGm5Mkci+mmV5BqD13S992o0Xk9eElxUfPPF+t2ksH5R/17gz4xVK8KWocUQ5o3Rog==", + "requires": { + "chalk": "2.3.0", + "source-map": "0.6.1", + "supports-color": "4.5.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "postcss-modules-values": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-1.3.0.tgz", + "integrity": "sha1-7P+p1+GSUYOJ9CrQ6D9yrsRW6iA=", + "requires": { + "icss-replace-symbols": "1.1.0", + "postcss": "6.0.14" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "postcss": { + "version": "6.0.14", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-6.0.14.tgz", + "integrity": "sha512-NJ1z0f+1offCgadPhz+DvGm5Mkci+mmV5BqD13S992o0Xk9eElxUfPPF+t2ksH5R/17gz4xVK8KWocUQ5o3Rog==", + "requires": { + "chalk": "2.3.0", + "source-map": "0.6.1", + "supports-color": "4.5.0" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "postcss-normalize-charset": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-1.1.1.tgz", + "integrity": "sha1-757nEhLX/nWceO0WL2HtYrXLk/E=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-normalize-url": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-3.0.8.tgz", + "integrity": "sha1-EI90s/L82viRov+j6kWSJ5/HgiI=", + "requires": { + "is-absolute-url": "2.1.0", + "normalize-url": "1.9.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-ordered-values": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-2.2.3.tgz", + "integrity": "sha1-7sbCpntsQSqNsgQud/6NpD+VwR0=", + "requires": { + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-reduce-idents": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-2.4.0.tgz", + "integrity": "sha1-wsbSDMlYKE9qv75j92Cb9AkFmtM=", + "requires": { + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-reduce-initial": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-1.0.1.tgz", + "integrity": "sha1-aPgGlfBF0IJjqHmtJA343WT2ROo=", + "requires": { + "postcss": "5.2.18" + } + }, + "postcss-reduce-transforms": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-1.0.4.tgz", + "integrity": "sha1-/3b02CEkN7McKYpC0uFEQCV3GuE=", + "requires": { + "has": "1.0.1", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0" + } + }, + "postcss-selector-parser": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-2.2.3.tgz", + "integrity": "sha1-+UN3iGBsPJrO4W/+jYsWKX8nu5A=", + "requires": { + "flatten": "1.0.2", + "indexes-of": "1.0.1", + "uniq": "1.0.1" + } + }, + "postcss-svgo": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-2.1.6.tgz", + "integrity": "sha1-tt8YqmE7Zm4TPwittSGcJoSsEI0=", + "requires": { + "is-svg": "2.1.0", + "postcss": "5.2.18", + "postcss-value-parser": "3.3.0", + "svgo": "0.7.2" + } + }, + "postcss-unique-selectors": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-2.0.2.tgz", + "integrity": "sha1-mB1X0p3csz57Hf4f1DuGSfkzyh0=", + "requires": { + "alphanum-sort": "1.0.2", + "postcss": "5.2.18", + "uniqs": "2.0.0" + } + }, + "postcss-value-parser": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-3.3.0.tgz", + "integrity": "sha1-h/OPnxj3dKSrTIojL1xc6IcqnRU=" + }, + "postcss-zindex": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-2.2.0.tgz", + "integrity": "sha1-0hCd3AVbka9n/EyzsCWUZjnSryI=", + "requires": { + "has": "1.0.1", + "postcss": "5.2.18", + "uniqs": "2.0.0" + } + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=" + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=" + }, + "preserve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz", + "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=" + }, + "private": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", + "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==" + }, + "process": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/process/-/process-0.5.2.tgz", + "integrity": "sha1-FjjYqONML0QKkduVq5rrZ3/Bhc8=" + }, + "process-nextick-args": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz", + "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=" + }, + "progress": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.0.tgz", + "integrity": "sha1-ihvjZr+Pwj2yvSPxDG/pILQ4nR8=" + }, + "promise": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/promise/-/promise-7.3.1.tgz", + "integrity": "sha512-nolQXZ/4L+bP/UGlkfaIujX9BKxGwmQ9OT4mOt5yvy8iK1h3wqTEJCijzGANTCCl9nWjY41juyAn2K3Q1hLLTg==", + "requires": { + "asap": "2.0.6" + } + }, + "prop-types": { + "version": "15.6.0", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.6.0.tgz", + "integrity": "sha1-zq8IMCL8RrSjX2nhPvda7Q1jmFY=", + "requires": { + "fbjs": "0.8.16", + "loose-envify": "1.3.1", + "object-assign": "4.1.1" + } + }, + "prr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz", + "integrity": "sha1-0/wRS6BplaRexok/SEzrHXj19HY=" + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=" + }, + "public-encrypt": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.0.tgz", + "integrity": "sha1-OfaZ86RlYN1eusvKaTyvfGXBjMY=", + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "parse-asn1": "5.1.0", + "randombytes": "2.0.5" + } + }, + "pullstream": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/pullstream/-/pullstream-0.4.1.tgz", + "integrity": "sha1-1vs79a7Wl+gxFQ6xACwlo/iuExQ=", + "requires": { + "over": "0.0.5", + "readable-stream": "1.0.34", + "setimmediate": "1.0.5", + "slice-stream": "1.0.0" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + }, + "q": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", + "integrity": "sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc=" + }, + "qs": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz", + "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A==" + }, + "query-string": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/query-string/-/query-string-4.3.4.tgz", + "integrity": "sha1-u7aTucqRXCMlFbIosaArYJBD2+s=", + "requires": { + "object-assign": "4.1.1", + "strict-uri-encode": "1.1.0" + } + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=" + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=" + }, + "raf": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.0.tgz", + "integrity": "sha512-pDP/NMRAXoTfrhCfyfSEwJAKLaxBU9eApMeBPB1TkDouZmvPerIClV8lTAd+uF8ZiTaVl69e1FCxQrAd/VTjGw==", + "requires": { + "performance-now": "2.1.0" + } + }, + "rafl": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/rafl/-/rafl-1.2.2.tgz", + "integrity": "sha1-/pMPdYIRAg1H44gV9Rlqi+QVB0A=", + "requires": { + "global": "4.3.2" + } + }, + "ramda": { + "version": "0.25.0", + "resolved": "https://registry.npmjs.org/ramda/-/ramda-0.25.0.tgz", + "integrity": "sha512-GXpfrYVPwx3K7RQ6aYT8KPS8XViSXUVJT1ONhoKPE9VAleW42YE+U+8VEyGWt41EnEQW7gwecYJriTI0pKoecQ==" + }, + "randomatic": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-1.1.7.tgz", + "integrity": "sha512-D5JUjPyJbaJDkuAazpVnSfVkLlpeO3wDlPROTMLGKG1zMFNFRgrciKo1ltz/AzNTkqE0HzDx655QOL51N06how==", + "requires": { + "is-number": "3.0.0", + "kind-of": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "randombytes": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.5.tgz", + "integrity": "sha512-8T7Zn1AhMsQ/HI1SjcCfT/t4ii3eAqco3yOcSzS4mozsOz69lHLsoMXmF9nZgnFanYscnSlUSgs8uZyKzpE6kg==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "randomfill": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.3.tgz", + "integrity": "sha512-YL6GrhrWoic0Eq8rXVbMptH7dAxCs0J+mh5Y0euNekPPYaxEmdVGim6GdoxoRzKW2yJoU8tueifS7mYxvcFDEQ==", + "requires": { + "randombytes": "2.0.5", + "safe-buffer": "5.1.1" + } + }, + "react": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/react/-/react-16.2.0.tgz", + "integrity": "sha512-ZmIomM7EE1DvPEnSFAHZn9Vs9zJl5A9H7el0EGTE6ZbW9FKe/14IYAlPbC8iH25YarEQxZL+E8VW7Mi7kfQrDQ==", + "requires": { + "fbjs": "0.8.16", + "loose-envify": "1.3.1", + "object-assign": "4.1.1", + "prop-types": "15.6.0" + } + }, + "react-dom": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-16.2.0.tgz", + "integrity": "sha512-zpGAdwHVn9K0091d+hr+R0qrjoJ84cIBFL2uU60KvWBPfZ7LPSrfqviTxGHWN0sjPZb2hxWzMexwrvJdKePvjg==", + "requires": { + "fbjs": "0.8.16", + "loose-envify": "1.3.1", + "object-assign": "4.1.1", + "prop-types": "15.6.0" + } + }, + "react-event-listener": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/react-event-listener/-/react-event-listener-0.5.2.tgz", + "integrity": "sha512-E22Sc/PtzVWw/fRidkEy1ZNnpSMJARUVV/5LymsDe4NjIHzNcVpNLV/R2Kt40NN8X6tu/X5p2inCny7vqd97mg==", + "requires": { + "babel-runtime": "6.26.0", + "fbjs": "0.8.16", + "prop-types": "15.6.0", + "warning": "3.0.0" + } + }, + "react-fa": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/react-fa/-/react-fa-5.0.0.tgz", + "integrity": "sha512-pBEJigNkDJPAP/P9mQXT55VbJbbtwqi4ayieXuFvGpd+gl3aZ9IbjjVKJihdhdysJP0XRgrSa3sT3yOmkQi8wQ==", + "requires": { + "font-awesome": "4.7.0", + "prop-types": "15.6.0" + } + }, + "react-jss": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/react-jss/-/react-jss-8.2.0.tgz", + "integrity": "sha512-GaD9lPMFeNaLGbgrGNVKn8MwqxEULfi2+nuU0chYALK4wivhVJ2qya7UN6UNXzqxb+rjR1rOqdUQejHKCTQRTg==", + "requires": { + "hoist-non-react-statics": "2.3.1", + "jss": "9.4.0", + "jss-preset-default": "4.0.1", + "prop-types": "15.6.0", + "theming": "1.3.0" + } + }, + "react-popper": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/react-popper/-/react-popper-0.7.4.tgz", + "integrity": "sha512-dx1fcKYYkidq7f71I1g+YX7g3QBLZ9taqiSRdJ7wbP7v/o7F6JsrUaNWGbVNul+TqdDDIZ5/k0xPUol9baqQJQ==", + "requires": { + "popper.js": "1.12.9", + "prop-types": "15.6.0" + } + }, + "react-resize-detector": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/react-resize-detector/-/react-resize-detector-1.1.0.tgz", + "integrity": "sha512-68KVcQlhcWQGXMAie82YueCa4f4yqwEoiQbVyYlSgJEin1zMtNBLLeU/+6FLNf1TTgjwSfpbMTJTw/uU0HNgtQ==", + "requires": { + "prop-types": "15.6.0" + } + }, + "react-scrollbar-size": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/react-scrollbar-size/-/react-scrollbar-size-2.0.2.tgz", + "integrity": "sha512-scpDs2PZFf9CJteBeDu7jkk7s+YX06Si4rQGVHsH6vjR/p7417q1Jv5SpOblLLesOgNrfWekwoHQG1g0/p3tvw==", + "requires": { + "babel-runtime": "6.26.0", + "prop-types": "15.6.0", + "react-event-listener": "0.5.2" + } + }, + "react-smooth": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/react-smooth/-/react-smooth-1.0.0.tgz", + "integrity": "sha1-sp2+vd3bBtIbWwiWIWf7nqwYl9g=", + "requires": { + "lodash": "4.17.4", + "prop-types": "15.6.0", + "raf": "3.4.0", + "react-transition-group": "2.2.1" + } + }, + "react-transition-group": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-2.2.1.tgz", + "integrity": "sha512-q54UBM22bs/CekG8r3+vi9TugSqh0t7qcEVycaRc9M0p0aCEu+h6rp/RFiW7fHfgd1IKpd9oILFTl5QK+FpiPA==", + "requires": { + "chain-function": "1.0.0", + "classnames": "2.2.5", + "dom-helpers": "3.3.1", + "loose-envify": "1.3.1", + "prop-types": "15.6.0", + "warning": "3.0.0" + } + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "requires": { + "load-json-file": "2.0.0", + "normalize-package-data": "2.4.0", + "path-type": "2.0.0" + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "requires": { + "find-up": "2.1.0", + "read-pkg": "2.0.0" + } + }, + "readable-stream": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.3.tgz", + "integrity": "sha512-m+qzzcn7KUxEmd1gMbchF+Y2eIUbieUaxkWtptyHywrX0rE8QEYqPC07Vuy4Wm32/xE16NcdBctb8S0Xe/5IeQ==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "readdirp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz", + "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", + "requires": { + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "readable-stream": "2.3.3", + "set-immediate-shim": "1.0.1" + } + }, + "recharts": { + "version": "1.0.0-beta.7", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-1.0.0-beta.7.tgz", + "integrity": "sha1-/M+T6vWVH3Q4y3a1pd0P50rVRFA=", + "requires": { + "classnames": "2.2.5", + "core-js": "2.5.1", + "d3-interpolate": "1.1.6", + "d3-scale": "1.0.6", + "d3-shape": "1.2.0", + "lodash": "4.17.4", + "prop-types": "15.6.0", + "react-resize-detector": "1.1.0", + "react-smooth": "1.0.0", + "recharts-scale": "0.3.2", + "reduce-css-calc": "1.3.0" + }, + "dependencies": { + "core-js": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.1.tgz", + "integrity": "sha1-rmh03GaTd4m4B1T/VCjfZoGcpQs=" + } + } + }, + "recharts-scale": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/recharts-scale/-/recharts-scale-0.3.2.tgz", + "integrity": "sha1-2sdiFxSkdl0VLLKtvDDHO4MSCMk=" + }, + "recompose": { + "version": "0.26.0", + "resolved": "https://registry.npmjs.org/recompose/-/recompose-0.26.0.tgz", + "integrity": "sha512-KwOu6ztO0mN5vy3+zDcc45lgnaUoaQse/a5yLVqtzTK13czSWnFGmXbQVmnoMgDkI5POd1EwIKSbjU1V7xdZog==", + "requires": { + "change-emitter": "0.1.6", + "fbjs": "0.8.16", + "hoist-non-react-statics": "2.3.1", + "symbol-observable": "1.1.0" + } + }, + "reduce-css-calc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/reduce-css-calc/-/reduce-css-calc-1.3.0.tgz", + "integrity": "sha1-dHyRTgSWFKTJz7umKYca0dKSdxY=", + "requires": { + "balanced-match": "0.4.2", + "math-expression-evaluator": "1.2.17", + "reduce-function-call": "1.0.2" + }, + "dependencies": { + "balanced-match": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz", + "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=" + } + } + }, + "reduce-function-call": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/reduce-function-call/-/reduce-function-call-1.0.2.tgz", + "integrity": "sha1-WiAL+S4ON3UXUv5FsKszD9S2vpk=", + "requires": { + "balanced-match": "0.4.2" + }, + "dependencies": { + "balanced-match": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz", + "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=" + } + } + }, + "regenerate": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.3.3.tgz", + "integrity": "sha512-jVpo1GadrDAK59t/0jRx5VxYWQEDkkEKi6+HjE3joFVLfDOh9Xrdh0dF1eSq+BI/SwvTQ44gSscJ8N5zYL61sg==" + }, + "regenerator-runtime": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", + "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==" + }, + "regenerator-transform": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz", + "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", + "requires": { + "babel-runtime": "6.26.0", + "babel-types": "6.26.0", + "private": "0.1.8" + } + }, + "regex-cache": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz", + "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==", + "requires": { + "is-equal-shallow": "0.1.3" + } + }, + "regexpu-core": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", + "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", + "requires": { + "regenerate": "1.3.3", + "regjsgen": "0.2.0", + "regjsparser": "0.1.5" + } + }, + "regjsgen": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=" + }, + "regjsparser": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", + "requires": { + "jsesc": "0.5.0" + }, + "dependencies": { + "jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=" + } + } + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=" + }, + "repeat-element": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz", + "integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=" + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=" + }, + "repeating": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", + "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", + "requires": { + "is-finite": "1.0.2" + } + }, + "request": { + "version": "2.83.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.83.0.tgz", + "integrity": "sha512-lR3gD69osqm6EYLk9wB/G1W/laGWjzH90t1vEa2xuxHD5KUrSzp9pUSfTm+YC5Nxt2T8nMPEvKlhbQayU7bgFw==", + "requires": { + "aws-sign2": "0.7.0", + "aws4": "1.6.0", + "caseless": "0.12.0", + "combined-stream": "1.0.5", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.3.1", + "har-validator": "5.0.3", + "hawk": "6.0.2", + "http-signature": "1.2.0", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.17", + "oauth-sign": "0.8.2", + "performance-now": "2.1.0", + "qs": "6.5.1", + "safe-buffer": "5.1.1", + "stringstream": "0.0.5", + "tough-cookie": "2.3.3", + "tunnel-agent": "0.6.0", + "uuid": "3.1.0" + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=" + }, + "require-main-filename": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", + "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=" + }, + "require-uncached": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/require-uncached/-/require-uncached-1.0.3.tgz", + "integrity": "sha1-Tg1W1slmL9MeQwEcS5WqSZVUIdM=", + "requires": { + "caller-path": "0.1.0", + "resolve-from": "1.0.1" + } + }, + "resolve": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.5.0.tgz", + "integrity": "sha512-hgoSGrc3pjzAPHNBg+KnFcK2HwlHTs/YrAGUr6qgTVUZmXv1UEXXl0bZNBKMA9fud6lRYFdPGz0xXxycPzmmiw==", + "requires": { + "path-parse": "1.0.5" + } + }, + "resolve-from": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-1.0.1.tgz", + "integrity": "sha1-Jsv+k10a7uq7Kbw/5a6wHpPUQiY=" + }, + "restore-cursor": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz", + "integrity": "sha1-n37ih/gv0ybU/RYpI9YhKe7g368=", + "requires": { + "onetime": "2.0.1", + "signal-exit": "3.0.2" + } + }, + "right-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz", + "integrity": "sha1-YTObci/mo1FWiSENJOFMlhSGE+8=", + "requires": { + "align-text": "0.1.4" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "requires": { + "glob": "7.1.2" + } + }, + "ripemd160": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.1.tgz", + "integrity": "sha1-D0WEKVxTo2KK9+bXmsohzlfRxuc=", + "requires": { + "hash-base": "2.0.2", + "inherits": "2.0.3" + } + }, + "run-async": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.3.0.tgz", + "integrity": "sha1-A3GrSuC91yDUFm19/aZP96RFpsA=", + "requires": { + "is-promise": "2.1.0" + } + }, + "rx-lite": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite/-/rx-lite-4.0.8.tgz", + "integrity": "sha1-Cx4Rr4vESDbwSmQH6S2kJGe3lEQ=" + }, + "rx-lite-aggregates": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/rx-lite-aggregates/-/rx-lite-aggregates-4.0.8.tgz", + "integrity": "sha1-dTuHqJoRyVRnxKwWJsTvxOBcZ74=", + "requires": { + "rx-lite": "4.0.8" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==" + }, + "schema-utils": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-0.3.0.tgz", + "integrity": "sha1-9YdyIs4+kx7a4DnxfrNxbnE3+M8=", + "requires": { + "ajv": "5.5.2" + } + }, + "scroll": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/scroll/-/scroll-2.0.1.tgz", + "integrity": "sha1-tMfSfovPOuiligQvJyaK4/VfnM0=", + "requires": { + "rafl": "1.2.2" + } + }, + "semver": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz", + "integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==" + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + }, + "set-immediate-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", + "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=" + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=" + }, + "sha.js": { + "version": "2.4.9", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.9.tgz", + "integrity": "sha512-G8zektVqbiPHrylgew9Zg1VRB1L/DtXNUVAM6q4QLy8NE3qtHlFXTf8VLL4k1Yl6c7NMjtZUTdXV+X44nFaT6A==", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "requires": { + "shebang-regex": "1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=" + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=" + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=" + }, + "slice-ansi": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-1.0.0.tgz", + "integrity": "sha512-POqxBK6Lb3q6s047D/XsDVNPnF9Dl8JSaqe9h9lURl0OdNqy/ujDrOiIHtsqXMGbWWTIomRzAMaTyawAU//Reg==", + "requires": { + "is-fullwidth-code-point": "2.0.0" + } + }, + "slice-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slice-stream/-/slice-stream-1.0.0.tgz", + "integrity": "sha1-WzO9ZvATsaf4ZGCwPUY97DmtPqA=", + "requires": { + "readable-stream": "1.0.34" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "sntp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/sntp/-/sntp-2.1.0.tgz", + "integrity": "sha512-FL1b58BDrqS3A11lJ0zEdnJ3UOKqVxawAkF3k7F0CVN7VQ34aZrV+G8BZ1WC9ZL7NyrwsW0oviwsWDgRuVYtJg==", + "requires": { + "hoek": "4.2.0" + } + }, + "sort-keys": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/sort-keys/-/sort-keys-1.1.2.tgz", + "integrity": "sha1-RBttTTRnmPG05J6JIK37oOVD+a0=", + "requires": { + "is-plain-obj": "1.1.0" + } + }, + "source-list-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.0.tgz", + "integrity": "sha512-I2UmuJSRr/T8jisiROLU3A3ltr+swpniSmNPI4Ml3ZCX6tVnDsuZzK7F2hl5jTqbZBWCEKlj5HRQiPExXLgE8A==" + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" + }, + "source-map-support": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz", + "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==", + "requires": { + "source-map": "0.5.7" + } + }, + "spdx-correct": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-1.0.2.tgz", + "integrity": "sha1-SzBz2TP/UfORLwOsVRlJikFQ20A=", + "requires": { + "spdx-license-ids": "1.2.2" + } + }, + "spdx-expression-parse": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz", + "integrity": "sha1-m98vIOH0DtRH++JzJmGR/O1RYmw=" + }, + "spdx-license-ids": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz", + "integrity": "sha1-yd96NCRZSt5r0RkA1ZZpbcBrrFc=" + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=" + }, + "sshpk": { + "version": "1.13.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.13.1.tgz", + "integrity": "sha1-US322mKHFEMW3EwY/hzx2UBzm+M=", + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + } + }, + "stream-browserify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz", + "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.3" + } + }, + "stream-http": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.7.2.tgz", + "integrity": "sha512-c0yTD2rbQzXtSsFSVhtpvY/vS6u066PcXOX9kBB3mSO76RiUQzL340uJkGBWnlBg4/HZzqiUXtaVA7wcRcJgEw==", + "requires": { + "builtin-status-codes": "3.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.3", + "to-arraybuffer": "1.0.1", + "xtend": "4.0.1" + } + }, + "strict-uri-encode": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz", + "integrity": "sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=" + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=" + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "stringstream": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz", + "integrity": "sha1-TkhM1N5aC7vuGORjB3EKioFiGHg=" + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=" + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=" + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=" + }, + "style-loader": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-0.19.1.tgz", + "integrity": "sha512-IRE+ijgojrygQi3rsqT0U4dd+UcPCqcVvauZpCnQrGAlEe+FUIyrK93bUDScamesjP08JlQNsFJU+KmPedP5Og==", + "requires": { + "loader-utils": "1.1.0", + "schema-utils": "0.3.0" + } + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=" + }, + "svgo": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-0.7.2.tgz", + "integrity": "sha1-n1dyQTlSE1xv779Ar+ak+qiLS7U=", + "requires": { + "coa": "1.0.4", + "colors": "1.1.2", + "csso": "2.3.2", + "js-yaml": "3.7.0", + "mkdirp": "0.5.1", + "sax": "1.2.4", + "whet.extend": "0.9.9" + } + }, + "symbol-observable": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/symbol-observable/-/symbol-observable-1.1.0.tgz", + "integrity": "sha512-dQoid9tqQ+uotGhuTKEY11X4xhyYePVnqGSoSm3OGKh2E8LZ6RPULp1uXTctk33IeERlrRJYoVSBglsL05F5Uw==" + }, + "table": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/table/-/table-4.0.2.tgz", + "integrity": "sha512-UUkEAPdSGxtRpiV9ozJ5cMTtYiqz7Ni1OGqLXRCynrvzdtR1p+cfOWe2RJLwvUG8hNanaSRjecIqwOjqeatDsA==", + "requires": { + "ajv": "5.5.2", + "ajv-keywords": "2.1.1", + "chalk": "2.3.0", + "lodash": "4.17.4", + "slice-ansi": "1.0.0", + "string-width": "2.1.1" + }, + "dependencies": { + "ansi-styles": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz", + "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==", + "requires": { + "color-convert": "1.9.1" + } + }, + "chalk": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.3.0.tgz", + "integrity": "sha512-Az5zJR2CBujap2rqXGaJKaPHyJ0IrUimvYNX+ncCy8PJP4ltOGTrHUIo097ZaL2zMeKYpiCdqDvS6zdrTFok3Q==", + "requires": { + "ansi-styles": "3.2.0", + "escape-string-regexp": "1.0.5", + "supports-color": "4.5.0" + } + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + } + } + }, + "tapable": { + "version": "0.2.8", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-0.2.8.tgz", + "integrity": "sha1-mTcqXJmb8t8WCvwNdL7U9HlIzSI=" + }, + "text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha1-f17oI66AUgfACvLfSoTsP8+lcLQ=" + }, + "theming": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/theming/-/theming-1.3.0.tgz", + "integrity": "sha512-ya5Ef7XDGbTPBv5ENTwrwkPUexrlPeiAg/EI9kdlUAZhNlRbCdhMKRgjNX1IcmsmiPcqDQZE6BpSaH+cr31FKw==", + "requires": { + "brcast": "3.0.1", + "is-function": "1.0.1", + "is-plain-object": "2.0.4", + "prop-types": "15.6.0" + } + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "timed-out": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz", + "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=" + }, + "timers-browserify": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-2.0.4.tgz", + "integrity": "sha512-uZYhyU3EX8O7HQP+J9fTVYwsq90Vr68xPEFo7yrVImIxYvHgukBEgOB/SgGoorWVTzGM/3Z+wUNnboA4M8jWrg==", + "requires": { + "setimmediate": "1.0.5" + } + }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "requires": { + "os-tmpdir": "1.0.2" + } + }, + "to-arraybuffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", + "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=" + }, + "to-fast-properties": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz", + "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=" + }, + "tough-cookie": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.3.tgz", + "integrity": "sha1-C2GKVWW23qkL80JdBNVe3EdadWE=", + "requires": { + "punycode": "1.4.1" + } + }, + "traverse": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/traverse/-/traverse-0.3.9.tgz", + "integrity": "sha1-cXuPIgzAu3tE5AUUwisui7xw2Lk=" + }, + "trim-right": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz", + "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=" + }, + "tty-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", + "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=" + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "requires": { + "prelude-ls": "1.1.2" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + }, + "ua-parser-js": { + "version": "0.7.17", + "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.17.tgz", + "integrity": "sha512-uRdSdu1oA1rncCQL7sCj8vSyZkgtL7faaw9Tc9rZ3mGgraQ7+Pdx7w5mnOSF3gw9ZNG6oc+KXfkon3bKuROm0g==" + }, + "uglify-js": { + "version": "2.8.29", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz", + "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=", + "requires": { + "source-map": "0.5.7", + "uglify-to-browserify": "1.0.2", + "yargs": "3.10.0" + }, + "dependencies": { + "camelcase": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz", + "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=" + }, + "cliui": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz", + "integrity": "sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE=", + "requires": { + "center-align": "0.1.3", + "right-align": "0.1.3", + "wordwrap": "0.0.2" + } + }, + "window-size": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz", + "integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=" + }, + "wordwrap": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz", + "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=" + }, + "yargs": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz", + "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=", + "requires": { + "camelcase": "1.2.1", + "cliui": "2.1.0", + "decamelize": "1.2.0", + "window-size": "0.1.0" + } + } + } + }, + "uglify-to-browserify": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz", + "integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=", + "optional": true + }, + "uglifyjs-webpack-plugin": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/uglifyjs-webpack-plugin/-/uglifyjs-webpack-plugin-0.4.6.tgz", + "integrity": "sha1-uVH0q7a9YX5m9j64kUmOORdj4wk=", + "requires": { + "source-map": "0.5.7", + "uglify-js": "2.8.29", + "webpack-sources": "1.1.0" + } + }, + "uniq": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz", + "integrity": "sha1-sxxa6CVIRKOoKBVBzisEuGWnNP8=" + }, + "uniqid": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/uniqid/-/uniqid-4.1.1.tgz", + "integrity": "sha1-iSIN32t1GuUrX3JISGNShZa7hME=", + "requires": { + "macaddress": "0.2.8" + } + }, + "uniqs": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/uniqs/-/uniqs-2.0.0.tgz", + "integrity": "sha1-/+3ks2slKQaW5uFl1KWe25mOawI=" + }, + "universalify": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.1.tgz", + "integrity": "sha1-+nG63UQ3r0wUiEHjs7Fl+enlkLc=" + }, + "unzip": { + "version": "0.1.11", + "resolved": "https://registry.npmjs.org/unzip/-/unzip-0.1.11.tgz", + "integrity": "sha1-iXScY7BY19kNYZ+GuYqhU107l/A=", + "requires": { + "binary": "0.3.0", + "fstream": "0.1.31", + "match-stream": "0.0.2", + "pullstream": "0.4.1", + "readable-stream": "1.0.34", + "setimmediate": "1.0.5" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=" + } + } + }, + "url-loader": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/url-loader/-/url-loader-0.6.2.tgz", + "integrity": "sha512-h3qf9TNn53BpuXTTcpC+UehiRrl0Cv45Yr/xWayApjw6G8Bg2dGke7rIwDQ39piciWCWrC+WiqLjOh3SUp9n0Q==", + "requires": { + "loader-utils": "1.1.0", + "mime": "1.6.0", + "schema-utils": "0.3.0" + } + }, + "url-parse-lax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz", + "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=", + "requires": { + "prepend-http": "1.0.4" + } + }, + "url-to-options": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz", + "integrity": "sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=" + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "requires": { + "inherits": "2.0.1" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "uuid": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.1.0.tgz", + "integrity": "sha512-DIWtzUkw04M4k3bf1IcpS2tngXEL26YUD2M0tMDUpnUrz2hgzUBlD55a4FjdLGPvfHxS6uluGWvaVEqgBcVa+g==" + }, + "validate-npm-package-license": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz", + "integrity": "sha1-KAS6vnEq0zeUWaz74kdGqywwP7w=", + "requires": { + "spdx-correct": "1.0.2", + "spdx-expression-parse": "1.0.4" + } + }, + "vendors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/vendors/-/vendors-1.0.1.tgz", + "integrity": "sha1-N61zyO5Bf7PVgOeFMSMH0nSEfyI=" + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "requires": { + "assert-plus": "1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "1.3.0" + } + }, + "vm-browserify": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", + "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=", + "requires": { + "indexof": "0.0.1" + } + }, + "warning": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/warning/-/warning-3.0.0.tgz", + "integrity": "sha1-MuU3fLVy3kqwR1O9+IIcAe1gW3w=", + "requires": { + "loose-envify": "1.3.1" + } + }, + "watchpack": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.4.0.tgz", + "integrity": "sha1-ShRyvLuVK9Cpu0A2gB+VTfs5+qw=", + "requires": { + "async": "2.6.0", + "chokidar": "1.7.0", + "graceful-fs": "4.1.11" + } + }, + "webpack": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-3.10.0.tgz", + "integrity": "sha512-fxxKXoicjdXNUMY7LIdY89tkJJJ0m1Oo8PQutZ5rLgWbV5QVKI15Cn7+/IHnRTd3vfKfiwBx6SBqlorAuNA8LA==", + "requires": { + "acorn": "5.2.1", + "acorn-dynamic-import": "2.0.2", + "ajv": "5.5.2", + "ajv-keywords": "2.1.1", + "async": "2.6.0", + "enhanced-resolve": "3.4.1", + "escope": "3.6.0", + "interpret": "1.1.0", + "json-loader": "0.5.7", + "json5": "0.5.1", + "loader-runner": "2.3.0", + "loader-utils": "1.1.0", + "memory-fs": "0.4.1", + "mkdirp": "0.5.1", + "node-libs-browser": "2.1.0", + "source-map": "0.5.7", + "supports-color": "4.5.0", + "tapable": "0.2.8", + "uglifyjs-webpack-plugin": "0.4.6", + "watchpack": "1.4.0", + "webpack-sources": "1.1.0", + "yargs": "8.0.2" + }, + "dependencies": { + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=" + }, + "os-locale": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-2.1.0.tgz", + "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==", + "requires": { + "execa": "0.7.0", + "lcid": "1.0.0", + "mem": "1.1.0" + } + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "requires": { + "has-flag": "2.0.0" + } + }, + "which-module": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", + "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=" + }, + "yargs": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-8.0.2.tgz", + "integrity": "sha1-YpmpBVsc78lp/355wdkY3Osiw2A=", + "requires": { + "camelcase": "4.1.0", + "cliui": "3.2.0", + "decamelize": "1.2.0", + "get-caller-file": "1.0.2", + "os-locale": "2.1.0", + "read-pkg-up": "2.0.0", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "2.1.1", + "which-module": "2.0.0", + "y18n": "3.2.1", + "yargs-parser": "7.0.0" + } + }, + "yargs-parser": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-7.0.0.tgz", + "integrity": "sha1-jQrELxbqVd69MyyvTEA4s+P139k=", + "requires": { + "camelcase": "4.1.0" + } + } + } + }, + "webpack-sources": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.1.0.tgz", + "integrity": "sha512-aqYp18kPphgoO5c/+NaUvEeACtZjMESmDChuD3NBciVpah3XpMEU9VAAtIaB1BsfJWWTSdv8Vv1m3T0aRk2dUw==", + "requires": { + "source-list-map": "2.0.0", + "source-map": "0.6.1" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==" + } + } + }, + "whatwg-fetch": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-2.0.3.tgz", + "integrity": "sha1-nITsLc9oGH/wC8ZOEnS0QhduHIQ=" + }, + "whet.extend": { + "version": "0.9.9", + "resolved": "https://registry.npmjs.org/whet.extend/-/whet.extend-0.9.9.tgz", + "integrity": "sha1-+HfVv2SMl+WqVC+twW1qJZucEaE=" + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", + "requires": { + "isexe": "2.0.0" + } + }, + "which-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", + "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=" + }, + "window-size": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.2.0.tgz", + "integrity": "sha1-tDFbtCFKPXBY6+7okuE/ok2YsHU=" + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=" + }, + "wrap-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", + "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "1.0.1" + } + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "write": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/write/-/write-0.2.1.tgz", + "integrity": "sha1-X8A4KOJkzqP+kUVUdvejxWbLB1c=", + "requires": { + "mkdirp": "0.5.1" + } + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + }, + "y18n": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", + "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=" + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=" + }, + "yargs": { + "version": "4.8.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-4.8.1.tgz", + "integrity": "sha1-wMQpJMpKqmsObaFznfshZDn53cA=", + "requires": { + "cliui": "3.2.0", + "decamelize": "1.2.0", + "get-caller-file": "1.0.2", + "lodash.assign": "4.2.0", + "os-locale": "1.4.0", + "read-pkg-up": "1.0.1", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "1.0.2", + "which-module": "1.0.0", + "window-size": "0.2.0", + "y18n": "3.2.1", + "yargs-parser": "2.4.1" + }, + "dependencies": { + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "requires": { + "path-exists": "2.1.0", + "pinkie-promise": "2.0.1" + } + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "1.0.1" + } + }, + "load-json-file": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "pinkie-promise": "2.0.1", + "strip-bom": "2.0.0" + } + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "requires": { + "pinkie-promise": "2.0.1" + } + }, + "path-type": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", + "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", + "requires": { + "graceful-fs": "4.1.11", + "pify": "2.3.0", + "pinkie-promise": "2.0.1" + } + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + }, + "read-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", + "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", + "requires": { + "load-json-file": "1.1.0", + "normalize-package-data": "2.4.0", + "path-type": "1.1.0" + } + }, + "read-pkg-up": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", + "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", + "requires": { + "find-up": "1.1.2", + "read-pkg": "1.1.0" + } + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "strip-bom": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", + "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", + "requires": { + "is-utf8": "0.2.1" + } + } + } + }, + "yargs-parser": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-2.4.1.tgz", + "integrity": "sha1-hVaN488VD/SfpRgl8DqMiA3cxcQ=", + "requires": { + "camelcase": "3.0.0", + "lodash.assign": "4.2.0" + } + } + } +} diff --git a/dashboard/assets/package.json b/dashboard/assets/package.json index 53376e5c8c..5bbfc185cd 100644 --- a/dashboard/assets/package.json +++ b/dashboard/assets/package.json @@ -1,22 +1,41 @@ { - "dependencies": { - "babel-core": "^6.26.0", - "babel-eslint": "^8.0.1", - "babel-loader": "^7.1.2", - "babel-preset-env": "^1.6.1", - "babel-preset-react": "^6.24.1", - "babel-preset-stage-0": "^6.24.1", - "classnames": "^2.2.5", - "eslint": "^4.5.0", - "eslint-plugin-react": "^7.4.0", - "material-ui": "^1.0.0-beta.18", - "material-ui-icons": "^1.0.0-beta.17", - "path": "^0.12.7", - "prop-types": "^15.6.0", - "recharts": "^1.0.0-beta.0", - "react": "^16.0.0", - "react-dom": "^16.0.0", - "url": "^0.11.0", - "webpack": "^3.5.5" - } + "dependencies": { + "babel-core": "^6.26.0", + "babel-eslint": "^8.0.3", + "babel-loader": "^7.1.2", + "babel-plugin-transform-class-properties": "^6.24.1", + "babel-plugin-transform-decorators-legacy": "^1.3.4", + "babel-plugin-transform-flow-strip-types": "^6.22.0", + "babel-plugin-transform-runtime": "^6.23.0", + "babel-preset-env": "^1.6.1", + "babel-preset-react": "^6.24.1", + "babel-preset-stage-0": "^6.24.1", + "babel-runtime": "^6.26.0", + "classnames": "^2.2.5", + "css-loader": "^0.28.7", + "eslint": "^4.13.1", + "eslint-config-airbnb": "^16.1.0", + "eslint-loader": "^1.9.0", + "eslint-plugin-import": "^2.8.0", + "eslint-plugin-jsx-a11y": "^6.0.3", + "eslint-plugin-react": "^7.5.1", + "eslint-plugin-flowtype": "^2.40.1", + "file-loader": "^1.1.6", + "flow-bin": "^0.61.0", + "flow-bin-loader": "^1.0.2", + "flow-typed": "^2.2.3", + "material-ui": "^1.0.0-beta.24", + "material-ui-icons": "^1.0.0-beta.17", + "path": "^0.12.7", + "ramda": "^0.25.0", + "react": "^16.2.0", + "react-dom": "^16.2.0", + "react-fa": "^5.0.0", + "react-transition-group": "^2.2.1", + "recharts": "^1.0.0-beta.6", + "style-loader": "^0.19.1", + "url": "^0.11.0", + "url-loader": "^0.6.2", + "webpack": "^3.10.0" + } } diff --git a/dashboard/assets/public/dashboard.html b/dashboard/assets/public/dashboard.html index e064a2b512..2491bf1eaf 100644 --- a/dashboard/assets/public/dashboard.html +++ b/dashboard/assets/public/dashboard.html @@ -6,9 +6,15 @@ Go Ethereum Dashboard - - - + +
diff --git a/dashboard/assets/types/content.jsx b/dashboard/assets/types/content.jsx new file mode 100644 index 0000000000..f8a2b1e50f --- /dev/null +++ b/dashboard/assets/types/content.jsx @@ -0,0 +1,53 @@ +// @flow + +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +import type {ChartEntry} from './message'; + +export type Content = { + home: Home, + chain: Chain, + txpool: TxPool, + network: Network, + system: System, + logs: Logs, +}; + +export type Home = { + memory: Array, + traffic: Array, +}; + +export type Chain = { + /* TODO (kurkomisi) */ +}; + +export type TxPool = { + /* TODO (kurkomisi) */ +}; + +export type Network = { + /* TODO (kurkomisi) */ +}; + +export type System = { + /* TODO (kurkomisi) */ +}; + +export type Logs = { + log: Array, +}; diff --git a/dashboard/assets/types/message.jsx b/dashboard/assets/types/message.jsx new file mode 100644 index 0000000000..a806196ca2 --- /dev/null +++ b/dashboard/assets/types/message.jsx @@ -0,0 +1,61 @@ +// @flow + +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +export type Message = { + home?: HomeMessage, + chain?: ChainMessage, + txpool?: TxPoolMessage, + network?: NetworkMessage, + system?: SystemMessage, + logs?: LogsMessage, +}; + +export type HomeMessage = { + memory?: Chart, + traffic?: Chart, +}; + +export type Chart = { + history?: Array, + new?: ChartEntry, +}; + +export type ChartEntry = { + time: Date, + value: number, +}; + +export type ChainMessage = { + /* TODO (kurkomisi) */ +}; + +export type TxPoolMessage = { + /* TODO (kurkomisi) */ +}; + +export type NetworkMessage = { + /* TODO (kurkomisi) */ +}; + +export type SystemMessage = { + /* TODO (kurkomisi) */ +}; + +export type LogsMessage = { + log: string, +}; diff --git a/dashboard/assets/webpack.config.js b/dashboard/assets/webpack.config.js index 13f8c3fbc6..cf92e6c979 100644 --- a/dashboard/assets/webpack.config.js +++ b/dashboard/assets/webpack.config.js @@ -14,23 +14,61 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . +const webpack = require('webpack'); const path = require('path'); module.exports = { - entry: './index.jsx', - output: { - path: path.resolve(__dirname, 'public'), - filename: 'bundle.js', - }, - module: { - loaders: [ - { - test: /\.jsx$/, // regexp for JSX files - loader: 'babel-loader', // The babel configuration is in the package.json. - query: { - presets: ['env', 'react', 'stage-0'] - } - }, - ], - }, + resolve: { + extensions: ['.js', '.jsx'], + }, + entry: './index', + output: { + path: path.resolve(__dirname, 'public'), + filename: 'bundle.js', + }, + plugins: [ + new webpack.optimize.UglifyJsPlugin({ + comments: false, + mangle: false, + beautify: true, + }), + ], + module: { + rules: [ + { + test: /\.jsx$/, // regexp for JSX files + exclude: /node_modules/, + use: [ // order: from bottom to top + { + loader: 'babel-loader', + options: { + plugins: [ // order: from top to bottom + // 'transform-decorators-legacy', // @withStyles, @withTheme + 'transform-class-properties', // static defaultProps + 'transform-flow-strip-types', + ], + presets: [ // order: from bottom to top + 'env', + 'react', + 'stage-0', + ], + }, + }, + // 'eslint-loader', // show errors not only in the editor, but also in the console + ], + }, + { + test: /font-awesome\.css$/, + use: [ + 'style-loader', + 'css-loader', + path.resolve(__dirname, './fa-only-woff-loader.js'), + ], + }, + { + test: /\.woff2?$/, // font-awesome icons + use: 'url-loader', + }, + ], + }, }; diff --git a/dashboard/dashboard.go b/dashboard/dashboard.go index 10a3636192..513099e01e 100644 --- a/dashboard/dashboard.go +++ b/dashboard/dashboard.go @@ -16,7 +16,10 @@ package dashboard -//go:generate go-bindata -nometadata -o assets.go -prefix assets -pkg dashboard assets/public/... +//go:generate ./assets/node_modules/.bin/webpack --config ./assets/webpack.config.js --context ./assets +//go:generate go-bindata -nometadata -o assets.go -prefix assets -nocompress -pkg dashboard assets/public/... +//go:generate gofmt -s -w assets.go +//go:generate sed -i "s#var _public#//nolint:misspell\\n&#" assets.go import ( "fmt" @@ -40,7 +43,7 @@ const ( trafficSampleLimit = 200 // Maximum number of traffic data samples ) -var nextId uint32 // Next connection id +var nextID uint32 // Next connection id // Dashboard contains the dashboard internals. type Dashboard struct { @@ -48,46 +51,30 @@ type Dashboard struct { listener net.Listener conns map[uint32]*client // Currently live websocket connections - charts charts // The collected data samples to plot - lock sync.RWMutex // Lock protecting the dashboard's internals + charts *HomeMessage + lock sync.RWMutex // Lock protecting the dashboard's internals quit chan chan error // Channel used for graceful exit wg sync.WaitGroup } -// message embraces the data samples of a client message. -type message struct { - History *charts `json:"history,omitempty"` // Past data samples - Memory *chartEntry `json:"memory,omitempty"` // One memory sample - Traffic *chartEntry `json:"traffic,omitempty"` // One traffic sample - Log string `json:"log,omitempty"` // One log -} - // client represents active websocket connection with a remote browser. type client struct { conn *websocket.Conn // Particular live websocket connection - msg chan message // Message queue for the update messages + msg chan Message // Message queue for the update messages logger log.Logger // Logger for the particular live websocket connection } -// charts contains the collected data samples. -type charts struct { - Memory []*chartEntry `json:"memorySamples,omitempty"` - Traffic []*chartEntry `json:"trafficSamples,omitempty"` -} - -// chartEntry represents one data sample -type chartEntry struct { - Time time.Time `json:"time,omitempty"` - Value float64 `json:"value,omitempty"` -} - // New creates a new dashboard instance with the given configuration. func New(config *Config) (*Dashboard, error) { return &Dashboard{ conns: make(map[uint32]*client), config: config, quit: make(chan chan error), + charts: &HomeMessage{ + Memory: &Chart{}, + Traffic: &Chart{}, + }, }, nil } @@ -183,13 +170,13 @@ func (db *Dashboard) webHandler(w http.ResponseWriter, r *http.Request) { // apiHandler handles requests for the dashboard. func (db *Dashboard) apiHandler(conn *websocket.Conn) { - id := atomic.AddUint32(&nextId, 1) + id := atomic.AddUint32(&nextID, 1) client := &client{ conn: conn, - msg: make(chan message, 128), + msg: make(chan Message, 128), logger: log.New("id", id), } - done := make(chan struct{}) // Buffered channel as sender may exit early + done := make(chan struct{}) // Start listening for messages to send. db.wg.Add(1) @@ -210,8 +197,15 @@ func (db *Dashboard) apiHandler(conn *websocket.Conn) { } }() // Send the past data. - client.msg <- message{ - History: &db.charts, + client.msg <- Message{ + Home: &HomeMessage{ + Memory: &Chart{ + History: db.charts.Memory.History, + }, + Traffic: &Chart{ + History: db.charts.Traffic.History, + }, + }, } // Start tracking the connection and drop at connection loss. db.lock.Lock() @@ -245,29 +239,34 @@ func (db *Dashboard) collectData() { inboundTraffic := metrics.DefaultRegistry.Get("p2p/InboundTraffic").(metrics.Meter).Rate1() memoryInUse := metrics.DefaultRegistry.Get("system/memory/inuse").(metrics.Meter).Rate1() now := time.Now() - memory := &chartEntry{ + memory := &ChartEntry{ Time: now, Value: memoryInUse, } - traffic := &chartEntry{ + traffic := &ChartEntry{ Time: now, Value: inboundTraffic, } - // Remove the first elements in case the samples' amount exceeds the limit. first := 0 - if len(db.charts.Memory) == memorySampleLimit { + if len(db.charts.Memory.History) == memorySampleLimit { first = 1 } - db.charts.Memory = append(db.charts.Memory[first:], memory) + db.charts.Memory.History = append(db.charts.Memory.History[first:], memory) first = 0 - if len(db.charts.Traffic) == trafficSampleLimit { + if len(db.charts.Traffic.History) == trafficSampleLimit { first = 1 } - db.charts.Traffic = append(db.charts.Traffic[first:], traffic) + db.charts.Traffic.History = append(db.charts.Traffic.History[first:], traffic) - db.sendToAll(&message{ - Memory: memory, - Traffic: traffic, + db.sendToAll(&Message{ + Home: &HomeMessage{ + Memory: &Chart{ + New: memory, + }, + Traffic: &Chart{ + New: traffic, + }, + }, }) } } @@ -277,6 +276,7 @@ func (db *Dashboard) collectData() { func (db *Dashboard) collectLogs() { defer db.wg.Done() + id := 1 // TODO (kurkomisi): log collection comes here. for { select { @@ -284,15 +284,18 @@ func (db *Dashboard) collectLogs() { errc <- nil return case <-time.After(db.config.Refresh / 2): - db.sendToAll(&message{ - Log: "This is a fake log.", + db.sendToAll(&Message{ + Logs: &LogsMessage{ + Log: fmt.Sprintf("%-4d: This is a fake log.", id), + }, }) + id++ } } } // sendToAll sends the given message to the active dashboards. -func (db *Dashboard) sendToAll(msg *message) { +func (db *Dashboard) sendToAll(msg *Message) { db.lock.Lock() for _, c := range db.conns { select { diff --git a/dashboard/message.go b/dashboard/message.go new file mode 100644 index 0000000000..240de0c340 --- /dev/null +++ b/dashboard/message.go @@ -0,0 +1,63 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package dashboard + +import "time" + +type Message struct { + Home *HomeMessage `json:"home,omitempty"` + Chain *ChainMessage `json:"chain,omitempty"` + TxPool *TxPoolMessage `json:"txpool,omitempty"` + Network *NetworkMessage `json:"network,omitempty"` + System *SystemMessage `json:"system,omitempty"` + Logs *LogsMessage `json:"logs,omitempty"` +} + +type HomeMessage struct { + Memory *Chart `json:"memory,omitempty"` + Traffic *Chart `json:"traffic,omitempty"` +} + +type Chart struct { + History []*ChartEntry `json:"history,omitempty"` + New *ChartEntry `json:"new,omitempty"` +} + +type ChartEntry struct { + Time time.Time `json:"time,omitempty"` + Value float64 `json:"value,omitempty"` +} + +type ChainMessage struct { + /* TODO (kurkomisi) */ +} + +type TxPoolMessage struct { + /* TODO (kurkomisi) */ +} + +type NetworkMessage struct { + /* TODO (kurkomisi) */ +} + +type SystemMessage struct { + /* TODO (kurkomisi) */ +} + +type LogsMessage struct { + Log string `json:"log,omitempty"` +} diff --git a/eth/api.go b/eth/api.go index c748f75de4..0db3eb5548 100644 --- a/eth/api.go +++ b/eth/api.go @@ -17,24 +17,19 @@ package eth import ( - "bytes" "compress/gzip" "context" "fmt" "io" - "io/ioutil" "math/big" "os" "strings" - "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/core/vm" - "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/params" @@ -43,8 +38,6 @@ import ( "github.com/ethereum/go-ethereum/trie" ) -const defaultTraceTimeout = 5 * time.Second - // PublicEthereumAPI provides an API to access Ethereum full node-related // information. type PublicEthereumAPI struct { @@ -348,248 +341,6 @@ func NewPrivateDebugAPI(config *params.ChainConfig, eth *Ethereum) *PrivateDebug return &PrivateDebugAPI{config: config, eth: eth} } -// BlockTraceResult is the returned value when replaying a block to check for -// consensus results and full VM trace logs for all included transactions. -type BlockTraceResult struct { - Validated bool `json:"validated"` - StructLogs []ethapi.StructLogRes `json:"structLogs"` - Error string `json:"error"` -} - -// TraceArgs holds extra parameters to trace functions -type TraceArgs struct { - *vm.LogConfig - Tracer *string - Timeout *string -} - -// TraceBlock processes the given block'api RLP but does not import the block in to -// the chain. -func (api *PrivateDebugAPI) TraceBlock(blockRlp []byte, config *vm.LogConfig) BlockTraceResult { - var block types.Block - err := rlp.Decode(bytes.NewReader(blockRlp), &block) - if err != nil { - return BlockTraceResult{Error: fmt.Sprintf("could not decode block: %v", err)} - } - - validated, logs, err := api.traceBlock(&block, config) - return BlockTraceResult{ - Validated: validated, - StructLogs: ethapi.FormatLogs(logs), - Error: formatError(err), - } -} - -// TraceBlockFromFile loads the block'api RLP from the given file name and attempts to -// process it but does not import the block in to the chain. -func (api *PrivateDebugAPI) TraceBlockFromFile(file string, config *vm.LogConfig) BlockTraceResult { - blockRlp, err := ioutil.ReadFile(file) - if err != nil { - return BlockTraceResult{Error: fmt.Sprintf("could not read file: %v", err)} - } - return api.TraceBlock(blockRlp, config) -} - -// TraceBlockByNumber processes the block by canonical block number. -func (api *PrivateDebugAPI) TraceBlockByNumber(blockNr rpc.BlockNumber, config *vm.LogConfig) BlockTraceResult { - // Fetch the block that we aim to reprocess - var block *types.Block - switch blockNr { - case rpc.PendingBlockNumber: - // Pending block is only known by the miner - block = api.eth.miner.PendingBlock() - case rpc.LatestBlockNumber: - block = api.eth.blockchain.CurrentBlock() - default: - block = api.eth.blockchain.GetBlockByNumber(uint64(blockNr)) - } - - if block == nil { - return BlockTraceResult{Error: fmt.Sprintf("block #%d not found", blockNr)} - } - - validated, logs, err := api.traceBlock(block, config) - return BlockTraceResult{ - Validated: validated, - StructLogs: ethapi.FormatLogs(logs), - Error: formatError(err), - } -} - -// TraceBlockByHash processes the block by hash. -func (api *PrivateDebugAPI) TraceBlockByHash(hash common.Hash, config *vm.LogConfig) BlockTraceResult { - // Fetch the block that we aim to reprocess - block := api.eth.BlockChain().GetBlockByHash(hash) - if block == nil { - return BlockTraceResult{Error: fmt.Sprintf("block #%x not found", hash)} - } - - validated, logs, err := api.traceBlock(block, config) - return BlockTraceResult{ - Validated: validated, - StructLogs: ethapi.FormatLogs(logs), - Error: formatError(err), - } -} - -// traceBlock processes the given block but does not save the state. -func (api *PrivateDebugAPI) traceBlock(block *types.Block, logConfig *vm.LogConfig) (bool, []vm.StructLog, error) { - // Validate and reprocess the block - var ( - blockchain = api.eth.BlockChain() - validator = blockchain.Validator() - processor = blockchain.Processor() - ) - - structLogger := vm.NewStructLogger(logConfig) - - config := vm.Config{ - Debug: true, - Tracer: structLogger, - } - if err := api.eth.engine.VerifyHeader(blockchain, block.Header(), true); err != nil { - return false, structLogger.StructLogs(), err - } - statedb, err := blockchain.StateAt(blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1).Root()) - if err != nil { - switch err.(type) { - case *trie.MissingNodeError: - return false, structLogger.StructLogs(), fmt.Errorf("required historical state unavailable") - default: - return false, structLogger.StructLogs(), err - } - } - - receipts, _, usedGas, err := processor.Process(block, statedb, config) - if err != nil { - return false, structLogger.StructLogs(), err - } - if err := validator.ValidateState(block, blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1), statedb, receipts, usedGas); err != nil { - return false, structLogger.StructLogs(), err - } - return true, structLogger.StructLogs(), nil -} - -// formatError formats a Go error into either an empty string or the data content -// of the error itself. -func formatError(err error) string { - if err == nil { - return "" - } - return err.Error() -} - -type timeoutError struct{} - -func (t *timeoutError) Error() string { - return "Execution time exceeded" -} - -// TraceTransaction returns the structured logs created during the execution of EVM -// and returns them as a JSON object. -func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, txHash common.Hash, config *TraceArgs) (interface{}, error) { - var tracer vm.Tracer - if config != nil && config.Tracer != nil { - timeout := defaultTraceTimeout - if config.Timeout != nil { - var err error - if timeout, err = time.ParseDuration(*config.Timeout); err != nil { - return nil, err - } - } - - var err error - if tracer, err = ethapi.NewJavascriptTracer(*config.Tracer); err != nil { - return nil, err - } - - // Handle timeouts and RPC cancellations - deadlineCtx, cancel := context.WithTimeout(ctx, timeout) - go func() { - <-deadlineCtx.Done() - tracer.(*ethapi.JavascriptTracer).Stop(&timeoutError{}) - }() - defer cancel() - } else if config == nil { - tracer = vm.NewStructLogger(nil) - } else { - tracer = vm.NewStructLogger(config.LogConfig) - } - - // Retrieve the tx from the chain and the containing block - tx, blockHash, _, txIndex := core.GetTransaction(api.eth.ChainDb(), txHash) - if tx == nil { - return nil, fmt.Errorf("transaction %x not found", txHash) - } - msg, context, statedb, err := api.computeTxEnv(blockHash, int(txIndex)) - if err != nil { - switch err.(type) { - case *trie.MissingNodeError: - return nil, fmt.Errorf("required historical state unavailable") - default: - return nil, err - } - } - - // Run the transaction with tracing enabled. - vmenv := vm.NewEVM(context, statedb, api.config, vm.Config{Debug: true, Tracer: tracer}) - ret, gas, failed, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())) - if err != nil { - return nil, fmt.Errorf("tracing failed: %v", err) - } - switch tracer := tracer.(type) { - case *vm.StructLogger: - return ðapi.ExecutionResult{ - Gas: gas, - Failed: failed, - ReturnValue: fmt.Sprintf("%x", ret), - StructLogs: ethapi.FormatLogs(tracer.StructLogs()), - }, nil - case *ethapi.JavascriptTracer: - return tracer.GetResult() - default: - panic(fmt.Sprintf("bad tracer type %T", tracer)) - } -} - -// computeTxEnv returns the execution environment of a certain transaction. -func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int) (core.Message, vm.Context, *state.StateDB, error) { - // Create the parent state. - block := api.eth.BlockChain().GetBlockByHash(blockHash) - if block == nil { - return nil, vm.Context{}, nil, fmt.Errorf("block %x not found", blockHash) - } - parent := api.eth.BlockChain().GetBlock(block.ParentHash(), block.NumberU64()-1) - if parent == nil { - return nil, vm.Context{}, nil, fmt.Errorf("block parent %x not found", block.ParentHash()) - } - statedb, err := api.eth.BlockChain().StateAt(parent.Root()) - if err != nil { - return nil, vm.Context{}, nil, err - } - txs := block.Transactions() - - // Recompute transactions up to the target index. - signer := types.MakeSigner(api.config, block.Number()) - for idx, tx := range txs { - // Assemble the transaction call message - msg, _ := tx.AsMessage(signer) - context := core.NewEVMContext(msg, block.Header(), api.eth.BlockChain(), nil) - if idx == txIndex { - return msg, context, statedb, nil - } - - vmenv := vm.NewEVM(context, statedb, api.config, vm.Config{}) - gp := new(core.GasPool).AddGas(tx.Gas()) - _, _, _, err := core.ApplyMessage(vmenv, msg, gp) - if err != nil { - return nil, vm.Context{}, nil, fmt.Errorf("tx %x failed: %v", tx.Hash(), err) - } - statedb.DeleteSuicides() - } - return nil, vm.Context{}, nil, fmt.Errorf("tx index %d out of range for block %x", txIndex, blockHash) -} - // Preimage is a debug API function that returns the preimage for a sha3 hash, if known. func (api *PrivateDebugAPI) Preimage(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) { db := core.PreimageTable(api.eth.ChainDb()) @@ -617,7 +368,7 @@ type storageEntry struct { // StorageRangeAt returns the storage at the given block height and transaction index. func (api *PrivateDebugAPI) StorageRangeAt(ctx context.Context, blockHash common.Hash, txIndex int, contractAddress common.Address, keyStart hexutil.Bytes, maxResult int) (StorageRangeResult, error) { - _, _, statedb, err := api.computeTxEnv(blockHash, txIndex) + _, _, statedb, err := api.computeTxEnv(blockHash, txIndex, 0) if err != nil { return StorageRangeResult{}, err } diff --git a/eth/api_tracer.go b/eth/api_tracer.go new file mode 100644 index 0000000000..d49f077aed --- /dev/null +++ b/eth/api_tracer.go @@ -0,0 +1,727 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package eth + +import ( + "bytes" + "context" + "errors" + "fmt" + "io/ioutil" + "runtime" + "sync" + "sync/atomic" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/internal/ethapi" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/rpc" + "github.com/ethereum/go-ethereum/trie" +) + +const ( + // defaultTraceTimeout is the amount of time a single transaction can execute + // by default before being forcefully aborted. + defaultTraceTimeout = 5 * time.Second + + // defaultTraceReexec is the number of blocks the tracer is willing to go back + // and reexecute to produce missing historical state necessary to run a specific + // trace. + defaultTraceReexec = uint64(128) +) + +// TraceConfig holds extra parameters to trace functions. +type TraceConfig struct { + *vm.LogConfig + Tracer *string + Timeout *string + Reexec *uint64 +} + +// txTraceResult is the result of a single transaction trace. +type txTraceResult struct { + Result interface{} `json:"result,omitempty"` // Trace results produced by the tracer + Error string `json:"error,omitempty"` // Trace failure produced by the tracer +} + +// blockTraceTask represents a single block trace task when an entire chain is +// being traced. +type blockTraceTask struct { + statedb *state.StateDB // Intermediate state prepped for tracing + block *types.Block // Block to trace the transactions from + results []*txTraceResult // Trace results procudes by the task +} + +// blockTraceResult represets the results of tracing a single block when an entire +// chain is being traced. +type blockTraceResult struct { + Block hexutil.Uint64 `json:"block"` // Block number corresponding to this trace + Hash common.Hash `json:"hash"` // Block hash corresponding to this trace + Traces []*txTraceResult `json:"traces"` // Trace results produced by the task +} + +// txTraceTask represents a single transaction trace task when an entire block +// is being traced. +type txTraceTask struct { + statedb *state.StateDB // Intermediate state prepped for tracing + index int // Transaction offset in the block +} + +// ephemeralDatabase is a memory wrapper around a proper database, which acts as +// an ephemeral write layer. This construct is used by the chain tracer to write +// state tries for intermediate blocks without serializing to disk, but at the +// same time to allow disk fallback for reads that do no hit the memory layer. +type ephemeralDatabase struct { + diskdb ethdb.Database // Persistent disk database to fall back to with reads + memdb *ethdb.MemDatabase // Ephemeral memory database for primary reads and writes +} + +func (db *ephemeralDatabase) Put(key []byte, value []byte) error { return db.memdb.Put(key, value) } +func (db *ephemeralDatabase) Delete(key []byte) error { return errors.New("delete not supported") } +func (db *ephemeralDatabase) Close() { db.memdb.Close() } +func (db *ephemeralDatabase) NewBatch() ethdb.Batch { + return db.memdb.NewBatch() +} +func (db *ephemeralDatabase) Has(key []byte) (bool, error) { + if has, _ := db.memdb.Has(key); has { + return has, nil + } + return db.diskdb.Has(key) +} +func (db *ephemeralDatabase) Get(key []byte) ([]byte, error) { + if blob, _ := db.memdb.Get(key); blob != nil { + return blob, nil + } + return db.diskdb.Get(key) +} + +// Prune does a state sync into a new memory write layer and replaces the old one. +// This allows us to discard entries that are no longer referenced from the current +// state. +func (db *ephemeralDatabase) Prune(root common.Hash) { + // Pull the still relevant state data into memory + sync := state.NewStateSync(root, db.diskdb) + for sync.Pending() > 0 { + hash := sync.Missing(1)[0] + + // Move the next trie node from the memory layer into a sync struct + node, err := db.memdb.Get(hash[:]) + if err != nil { + panic(err) // memdb must have the data + } + if _, _, err := sync.Process([]trie.SyncResult{{Hash: hash, Data: node}}); err != nil { + panic(err) // it's not possible to fail processing a node + } + } + // Discard the old memory layer and write a new one + db.memdb, _ = ethdb.NewMemDatabaseWithCap(db.memdb.Len()) + if _, err := sync.Commit(db); err != nil { + panic(err) // writing into a memdb cannot fail + } +} + +// TraceChain returns the structured logs created during the execution of EVM +// between two blocks (excluding start) and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceChain(ctx context.Context, start, end rpc.BlockNumber, config *TraceConfig) (*rpc.Subscription, error) { + // Fetch the block interval that we want to trace + var from, to *types.Block + + switch start { + case rpc.PendingBlockNumber: + from = api.eth.miner.PendingBlock() + case rpc.LatestBlockNumber: + from = api.eth.blockchain.CurrentBlock() + default: + from = api.eth.blockchain.GetBlockByNumber(uint64(start)) + } + switch end { + case rpc.PendingBlockNumber: + to = api.eth.miner.PendingBlock() + case rpc.LatestBlockNumber: + to = api.eth.blockchain.CurrentBlock() + default: + to = api.eth.blockchain.GetBlockByNumber(uint64(end)) + } + // Trace the chain if we've found all our blocks + if from == nil { + return nil, fmt.Errorf("starting block #%d not found", start) + } + if to == nil { + return nil, fmt.Errorf("end block #%d not found", end) + } + return api.traceChain(ctx, from, to, config) +} + +// traceChain configures a new tracer according to the provided configuration, and +// executes all the transactions contained within. The return value will be one item +// per transaction, dependent on the requestd tracer. +func (api *PrivateDebugAPI) traceChain(ctx context.Context, start, end *types.Block, config *TraceConfig) (*rpc.Subscription, error) { + // Tracing a chain is a **long** operation, only do with subscriptions + notifier, supported := rpc.NotifierFromContext(ctx) + if !supported { + return &rpc.Subscription{}, rpc.ErrNotificationsUnsupported + } + sub := notifier.CreateSubscription() + + // Ensure we have a valid starting state before doing any work + origin := start.NumberU64() + + memdb, _ := ethdb.NewMemDatabase() + db := &ephemeralDatabase{ + diskdb: api.eth.ChainDb(), + memdb: memdb, + } + if number := start.NumberU64(); number > 0 { + start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1) + if start == nil { + return nil, fmt.Errorf("parent block #%d not found", number-1) + } + } + statedb, err := state.New(start.Root(), state.NewDatabase(db)) + if err != nil { + // If the starting state is missing, allow some number of blocks to be reexecuted + reexec := defaultTraceReexec + if config != nil && config.Reexec != nil { + reexec = *config.Reexec + } + // Find the most recent block that has the state available + for i := uint64(0); i < reexec; i++ { + start = api.eth.blockchain.GetBlock(start.ParentHash(), start.NumberU64()-1) + if start == nil { + break + } + if statedb, err = state.New(start.Root(), state.NewDatabase(db)); err == nil { + break + } + } + // If we still don't have the state available, bail out + if err != nil { + switch err.(type) { + case *trie.MissingNodeError: + return nil, errors.New("required historical state unavailable") + default: + return nil, err + } + } + } + // Execute all the transaction contained within the chain concurrently for each block + blocks := int(end.NumberU64() - origin) + + threads := runtime.NumCPU() + if threads > blocks { + threads = blocks + } + var ( + pend = new(sync.WaitGroup) + tasks = make(chan *blockTraceTask, threads) + results = make(chan *blockTraceTask, threads) + ) + for th := 0; th < threads; th++ { + pend.Add(1) + go func() { + defer pend.Done() + + // Fetch and execute the next block trace tasks + for task := range tasks { + signer := types.MakeSigner(api.config, task.block.Number()) + + // Trace all the transactions contained within + for i, tx := range task.block.Transactions() { + msg, _ := tx.AsMessage(signer) + vmctx := core.NewEVMContext(msg, task.block.Header(), api.eth.blockchain, nil) + + res, err := api.traceTx(ctx, msg, vmctx, task.statedb, config) + if err != nil { + task.results[i] = &txTraceResult{Error: err.Error()} + log.Warn("Tracing failed", "err", err) + break + } + task.statedb.DeleteSuicides() + task.results[i] = &txTraceResult{Result: res} + } + // Stream the result back to the user or abort on teardown + select { + case results <- task: + case <-notifier.Closed(): + return + } + } + }() + } + // Start a goroutine to feed all the blocks into the tracers + begin := time.Now() + complete := start.NumberU64() + + go func() { + var ( + logged time.Time + number uint64 + traced uint64 + failed error + ) + // Ensure everything is properly cleaned up on any exit path + defer func() { + close(tasks) + pend.Wait() + + switch { + case failed != nil: + log.Warn("Chain tracing failed", "start", start.NumberU64(), "end", end.NumberU64(), "transactions", traced, "elapsed", time.Since(begin), "err", failed) + case number < end.NumberU64(): + log.Warn("Chain tracing aborted", "start", start.NumberU64(), "end", end.NumberU64(), "abort", number, "transactions", traced, "elapsed", time.Since(begin)) + default: + log.Info("Chain tracing finished", "start", start.NumberU64(), "end", end.NumberU64(), "transactions", traced, "elapsed", time.Since(begin)) + } + close(results) + }() + // Feed all the blocks both into the tracer, as well as fast process concurrently + for number = start.NumberU64() + 1; number <= end.NumberU64(); number++ { + // Stop tracing if interruption was requested + select { + case <-notifier.Closed(): + return + default: + } + // Print progress logs if long enough time elapsed + if time.Since(logged) > 8*time.Second { + if number > origin { + log.Info("Tracing chain segment", "start", origin, "end", end.NumberU64(), "current", number, "transactions", traced, "elapsed", time.Since(begin)) + } else { + log.Info("Preparing state for chain trace", "block", number, "start", origin, "elapsed", time.Since(begin)) + } + logged = time.Now() + } + // Retrieve the next block to trace + block := api.eth.blockchain.GetBlockByNumber(number) + if block == nil { + failed = fmt.Errorf("block #%d not found", number) + break + } + // Send the block over to the concurrent tracers (if not in the fast-forward phase) + if number > origin { + txs := block.Transactions() + + select { + case tasks <- &blockTraceTask{statedb: statedb.Copy(), block: block, results: make([]*txTraceResult, len(txs))}: + case <-notifier.Closed(): + return + } + traced += uint64(len(txs)) + } else { + atomic.StoreUint64(&complete, number) + } + // Generate the next state snapshot fast without tracing + _, _, _, err := api.eth.blockchain.Processor().Process(block, statedb, vm.Config{}) + if err != nil { + failed = err + break + } + // Finalize the state so any modifications are written to the trie + root, err := statedb.CommitTo(db, true) + if err != nil { + failed = err + break + } + if err := statedb.Reset(root); err != nil { + failed = err + break + } + // After every N blocks, prune the database to only retain relevant data + if (number-start.NumberU64())%4096 == 0 { + // Wait until currently pending trace jobs finish + for atomic.LoadUint64(&complete) != number { + select { + case <-time.After(100 * time.Millisecond): + case <-notifier.Closed(): + return + } + } + // No more concurrent access at this point, prune the database + var ( + nodes = db.memdb.Len() + start = time.Now() + ) + db.Prune(root) + log.Info("Pruned tracer state entries", "deleted", nodes-db.memdb.Len(), "left", db.memdb.Len(), "elapsed", time.Since(start)) + + statedb, _ = state.New(root, state.NewDatabase(db)) + } + } + }() + + // Keep reading the trace results and stream the to the user + go func() { + var ( + done = make(map[uint64]*blockTraceResult) + next = origin + 1 + ) + for res := range results { + // Queue up next received result + result := &blockTraceResult{ + Block: hexutil.Uint64(res.block.NumberU64()), + Hash: res.block.Hash(), + Traces: res.results, + } + done[uint64(result.Block)] = result + + // Stream completed traces to the user, aborting on the first error + for result, ok := done[next]; ok; result, ok = done[next] { + if len(result.Traces) > 0 || next == end.NumberU64() { + notifier.Notify(sub.ID, result) + } + atomic.StoreUint64(&complete, next) + delete(done, next) + next++ + } + } + }() + return sub, nil +} + +// TraceBlockByNumber returns the structured logs created during the execution of +// EVM and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceBlockByNumber(ctx context.Context, number rpc.BlockNumber, config *TraceConfig) ([]*txTraceResult, error) { + // Fetch the block that we want to trace + var block *types.Block + + switch number { + case rpc.PendingBlockNumber: + block = api.eth.miner.PendingBlock() + case rpc.LatestBlockNumber: + block = api.eth.blockchain.CurrentBlock() + default: + block = api.eth.blockchain.GetBlockByNumber(uint64(number)) + } + // Trace the block if it was found + if block == nil { + return nil, fmt.Errorf("block #%d not found", number) + } + return api.traceBlock(ctx, block, config) +} + +// TraceBlockByHash returns the structured logs created during the execution of +// EVM and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceBlockByHash(ctx context.Context, hash common.Hash, config *TraceConfig) ([]*txTraceResult, error) { + block := api.eth.blockchain.GetBlockByHash(hash) + if block == nil { + return nil, fmt.Errorf("block #%x not found", hash) + } + return api.traceBlock(ctx, block, config) +} + +// TraceBlock returns the structured logs created during the execution of EVM +// and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceBlock(ctx context.Context, blob []byte, config *TraceConfig) ([]*txTraceResult, error) { + block := new(types.Block) + if err := rlp.Decode(bytes.NewReader(blob), block); err != nil { + return nil, fmt.Errorf("could not decode block: %v", err) + } + return api.traceBlock(ctx, block, config) +} + +// TraceBlockFromFile returns the structured logs created during the execution of +// EVM and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceBlockFromFile(ctx context.Context, file string, config *TraceConfig) ([]*txTraceResult, error) { + blob, err := ioutil.ReadFile(file) + if err != nil { + return nil, fmt.Errorf("could not read file: %v", err) + } + return api.TraceBlock(ctx, blob, config) +} + +// traceBlock configures a new tracer according to the provided configuration, and +// executes all the transactions contained within. The return value will be one item +// per transaction, dependent on the requestd tracer. +func (api *PrivateDebugAPI) traceBlock(ctx context.Context, block *types.Block, config *TraceConfig) ([]*txTraceResult, error) { + // Create the parent state database + if err := api.eth.engine.VerifyHeader(api.eth.blockchain, block.Header(), true); err != nil { + return nil, err + } + parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1) + if parent == nil { + return nil, fmt.Errorf("parent %x not found", block.ParentHash()) + } + reexec := defaultTraceReexec + if config != nil && config.Reexec != nil { + reexec = *config.Reexec + } + statedb, err := api.computeStateDB(parent, reexec) + if err != nil { + return nil, err + } + // Execute all the transaction contained within the block concurrently + var ( + signer = types.MakeSigner(api.config, block.Number()) + + txs = block.Transactions() + results = make([]*txTraceResult, len(txs)) + + pend = new(sync.WaitGroup) + jobs = make(chan *txTraceTask, len(txs)) + ) + threads := runtime.NumCPU() + if threads > len(txs) { + threads = len(txs) + } + for th := 0; th < threads; th++ { + pend.Add(1) + go func() { + defer pend.Done() + + // Fetch and execute the next transaction trace tasks + for task := range jobs { + msg, _ := txs[task.index].AsMessage(signer) + vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil) + + res, err := api.traceTx(ctx, msg, vmctx, task.statedb, config) + if err != nil { + results[task.index] = &txTraceResult{Error: err.Error()} + continue + } + results[task.index] = &txTraceResult{Result: res} + } + }() + } + // Feed the transactions into the tracers and return + var failed error + for i, tx := range txs { + // Send the trace task over for execution + jobs <- &txTraceTask{statedb: statedb.Copy(), index: i} + + // Generate the next state snapshot fast without tracing + msg, _ := tx.AsMessage(signer) + vmctx := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil) + + vmenv := vm.NewEVM(vmctx, statedb, api.config, vm.Config{}) + if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.Gas())); err != nil { + failed = err + break + } + // Finalize the state so any modifications are written to the trie + statedb.Finalise(true) + } + close(jobs) + pend.Wait() + + // If execution failed in between, abort + if failed != nil { + return nil, failed + } + return results, nil +} + +// computeStateDB retrieves the state database associated with a certain block. +// If no state is locally available for the given block, a number of blocks are +// attempted to be reexecuted to generate the desired state. +func (api *PrivateDebugAPI) computeStateDB(block *types.Block, reexec uint64) (*state.StateDB, error) { + // If we have the state fully available, use that + statedb, err := api.eth.blockchain.StateAt(block.Root()) + if err == nil { + return statedb, nil + } + // Otherwise try to reexec blocks until we find a state or reach our limit + origin := block.NumberU64() + + memdb, _ := ethdb.NewMemDatabase() + db := &ephemeralDatabase{ + diskdb: api.eth.ChainDb(), + memdb: memdb, + } + for i := uint64(0); i < reexec; i++ { + block = api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1) + if block == nil { + break + } + if statedb, err = state.New(block.Root(), state.NewDatabase(db)); err == nil { + break + } + } + if err != nil { + switch err.(type) { + case *trie.MissingNodeError: + return nil, errors.New("required historical state unavailable") + default: + return nil, err + } + } + // State was available at historical point, regenerate + var ( + start = time.Now() + logged time.Time + ) + for block.NumberU64() < origin { + // Print progress logs if long enough time elapsed + if time.Since(logged) > 8*time.Second { + log.Info("Regenerating historical state", "block", block.NumberU64()+1, "target", origin, "elapsed", time.Since(start)) + logged = time.Now() + } + // Retrieve the next block to regenerate and process it + if block = api.eth.blockchain.GetBlockByNumber(block.NumberU64() + 1); block == nil { + return nil, fmt.Errorf("block #%d not found", block.NumberU64()+1) + } + _, _, _, err := api.eth.blockchain.Processor().Process(block, statedb, vm.Config{}) + if err != nil { + return nil, err + } + // Finalize the state so any modifications are written to the trie + root, err := statedb.CommitTo(db, true) + if err != nil { + return nil, err + } + if err := statedb.Reset(root); err != nil { + return nil, err + } + // After every N blocks, prune the database to only retain relevant data + if block.NumberU64()%4096 == 0 || block.NumberU64() == origin { + var ( + nodes = db.memdb.Len() + begin = time.Now() + ) + db.Prune(root) + log.Info("Pruned tracer state entries", "deleted", nodes-db.memdb.Len(), "left", db.memdb.Len(), "elapsed", time.Since(begin)) + + statedb, _ = state.New(root, state.NewDatabase(db)) + } + } + log.Info("Historical state regenerated", "block", block.NumberU64(), "elapsed", time.Since(start)) + return statedb, nil +} + +// TraceTransaction returns the structured logs created during the execution of EVM +// and returns them as a JSON object. +func (api *PrivateDebugAPI) TraceTransaction(ctx context.Context, hash common.Hash, config *TraceConfig) (interface{}, error) { + // Retrieve the transaction and assemble its EVM context + tx, blockHash, _, index := core.GetTransaction(api.eth.ChainDb(), hash) + if tx == nil { + return nil, fmt.Errorf("transaction %x not found", hash) + } + reexec := defaultTraceReexec + if config != nil && config.Reexec != nil { + reexec = *config.Reexec + } + msg, vmctx, statedb, err := api.computeTxEnv(blockHash, int(index), reexec) + if err != nil { + return nil, err + } + // Trace the transaction and return + return api.traceTx(ctx, msg, vmctx, statedb, config) +} + +// traceTx configures a new tracer according to the provided configuration, and +// executes the given message in the provided environment. The return value will +// be tracer dependent. +func (api *PrivateDebugAPI) traceTx(ctx context.Context, message core.Message, vmctx vm.Context, statedb *state.StateDB, config *TraceConfig) (interface{}, error) { + // Assemble the structured logger or the JavaScript tracer + var ( + tracer vm.Tracer + err error + ) + switch { + case config != nil && config.Tracer != nil: + // Define a meaningful timeout of a single transaction trace + timeout := defaultTraceTimeout + if config.Timeout != nil { + if timeout, err = time.ParseDuration(*config.Timeout); err != nil { + return nil, err + } + } + // Constuct the JavaScript tracer to execute with + if tracer, err = tracers.New(*config.Tracer); err != nil { + return nil, err + } + // Handle timeouts and RPC cancellations + deadlineCtx, cancel := context.WithTimeout(ctx, timeout) + go func() { + <-deadlineCtx.Done() + tracer.(*tracers.Tracer).Stop(errors.New("execution timeout")) + }() + defer cancel() + + case config == nil: + tracer = vm.NewStructLogger(nil) + + default: + tracer = vm.NewStructLogger(config.LogConfig) + } + // Run the transaction with tracing enabled. + vmenv := vm.NewEVM(vmctx, statedb, api.config, vm.Config{Debug: true, Tracer: tracer}) + + ret, gas, failed, err := core.ApplyMessage(vmenv, message, new(core.GasPool).AddGas(message.Gas())) + if err != nil { + return nil, fmt.Errorf("tracing failed: %v", err) + } + // Depending on the tracer type, format and return the output + switch tracer := tracer.(type) { + case *vm.StructLogger: + return ðapi.ExecutionResult{ + Gas: gas, + Failed: failed, + ReturnValue: fmt.Sprintf("%x", ret), + StructLogs: ethapi.FormatLogs(tracer.StructLogs()), + }, nil + + case *tracers.Tracer: + return tracer.GetResult() + + default: + panic(fmt.Sprintf("bad tracer type %T", tracer)) + } +} + +// computeTxEnv returns the execution environment of a certain transaction. +func (api *PrivateDebugAPI) computeTxEnv(blockHash common.Hash, txIndex int, reexec uint64) (core.Message, vm.Context, *state.StateDB, error) { + // Create the parent state database + block := api.eth.blockchain.GetBlockByHash(blockHash) + if block == nil { + return nil, vm.Context{}, nil, fmt.Errorf("block %x not found", blockHash) + } + parent := api.eth.blockchain.GetBlock(block.ParentHash(), block.NumberU64()-1) + if parent == nil { + return nil, vm.Context{}, nil, fmt.Errorf("parent %x not found", block.ParentHash()) + } + statedb, err := api.computeStateDB(parent, reexec) + if err != nil { + return nil, vm.Context{}, nil, err + } + // Recompute transactions up to the target index. + signer := types.MakeSigner(api.config, block.Number()) + + for idx, tx := range block.Transactions() { + // Assemble the transaction call message and return if the requested offset + msg, _ := tx.AsMessage(signer) + context := core.NewEVMContext(msg, block.Header(), api.eth.blockchain, nil) + if idx == txIndex { + return msg, context, statedb, nil + } + // Not yet the searched for transaction, execute on top of the current state + vmenv := vm.NewEVM(context, statedb, api.config, vm.Config{}) + if _, _, _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(tx.Gas())); err != nil { + return nil, vm.Context{}, nil, fmt.Errorf("tx %x failed: %v", tx.Hash(), err) + } + statedb.DeleteSuicides() + } + return nil, vm.Context{}, nil, fmt.Errorf("tx index %d out of range for block %x", txIndex, blockHash) +} diff --git a/eth/bind.go b/eth/bind.go index d09977dbc2..769a6c741c 100644 --- a/eth/bind.go +++ b/eth/bind.go @@ -83,9 +83,7 @@ func toCallArgs(msg ethereum.CallMsg) ethapi.CallArgs { To: msg.To, From: msg.From, Data: msg.Data, - } - if msg.Gas != nil { - args.Gas = hexutil.Big(*msg.Gas) + Gas: hexutil.Uint64(msg.Gas), } if msg.GasPrice != nil { args.GasPrice = hexutil.Big(*msg.GasPrice) @@ -124,9 +122,9 @@ func (b *ContractBackend) SuggestGasPrice(ctx context.Context) (*big.Int, error) // the backend blockchain. There is no guarantee that this is the true gas limit // requirement as other transactions may be added or removed by miners, but it // should provide a basis for setting a reasonable default. -func (b *ContractBackend) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (*big.Int, error) { - out, err := b.bcapi.EstimateGas(ctx, toCallArgs(msg)) - return out.ToInt(), err +func (b *ContractBackend) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) { + gas, err := b.bcapi.EstimateGas(ctx, toCallArgs(msg)) + return uint64(gas), err } // SendTransaction implements bind.ContractTransactor injects the transaction diff --git a/eth/downloader/downloader_test.go b/eth/downloader/downloader_test.go index 7d1cc8c340..ad5a62c481 100644 --- a/eth/downloader/downloader_test.go +++ b/eth/downloader/downloader_test.go @@ -26,6 +26,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" @@ -107,7 +108,7 @@ func newTester() *downloadTester { // reassembly. func (dl *downloadTester) makeChain(n int, seed byte, parent *types.Block, parentReceipts types.Receipts, heavy bool) ([]common.Hash, map[common.Hash]*types.Header, map[common.Hash]*types.Block, map[common.Hash]types.Receipts) { // Generate the block chain - blocks, receipts := core.GenerateChain(params.TestChainConfig, parent, dl.peerDb, n, func(i int, block *core.BlockGen) { + blocks, receipts := core.GenerateChain(params.TestChainConfig, parent, ethash.NewFaker(), dl.peerDb, n, func(i int, block *core.BlockGen) { block.SetCoinbase(common.Address{seed}) // If a heavy chain is requested, delay blocks to raise difficulty @@ -117,7 +118,7 @@ func (dl *downloadTester) makeChain(n int, seed byte, parent *types.Block, paren // If the block number is multiple of 3, send a bonus transaction to the miner if parent == dl.genesis && i%3 == 0 { signer := types.MakeSigner(params.TestChainConfig, block.Number()) - tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), new(big.Int).SetUint64(params.TxGas), nil, nil), signer, testKey) + tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, nil, nil), signer, testKey) if err != nil { panic(err) } diff --git a/eth/downloader/statesync.go b/eth/downloader/statesync.go index a0b05c9be6..937828b949 100644 --- a/eth/downloader/statesync.go +++ b/eth/downloader/statesync.go @@ -132,7 +132,10 @@ func (d *Downloader) runStateSync(s *stateSync) *stateSync { // Send the next finished request to the current sync: case deliverReqCh <- deliverReq: - finished = append(finished[:0], finished[1:]...) + // Shift out the first request, but also set the emptied slot to nil for GC + copy(finished, finished[1:]) + finished[len(finished)-1] = nil + finished = finished[:len(finished)-1] // Handle incoming state packs: case pack := <-d.stateCh: diff --git a/eth/fetcher/fetcher_test.go b/eth/fetcher/fetcher_test.go index 9889e6cc53..9d53b98b60 100644 --- a/eth/fetcher/fetcher_test.go +++ b/eth/fetcher/fetcher_test.go @@ -25,6 +25,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -45,13 +46,13 @@ var ( // contains a transaction and every 5th an uncle to allow testing correct block // reassembly. func makeChain(n int, seed byte, parent *types.Block) ([]common.Hash, map[common.Hash]*types.Block) { - blocks, _ := core.GenerateChain(params.TestChainConfig, parent, testdb, n, func(i int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(params.TestChainConfig, parent, ethash.NewFaker(), testdb, n, func(i int, block *core.BlockGen) { block.SetCoinbase(common.Address{seed}) // If the block number is multiple of 3, send a bonus transaction to the miner if parent == genesis && i%3 == 0 { signer := types.MakeSigner(params.TestChainConfig, block.Number()) - tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), new(big.Int).SetUint64(params.TxGas), nil, nil), signer, testKey) + tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, nil, nil), signer, testKey) if err != nil { panic(err) } diff --git a/eth/filters/filter_system_test.go b/eth/filters/filter_system_test.go index 7da114fda4..dd6d4433d6 100644 --- a/eth/filters/filter_system_test.go +++ b/eth/filters/filter_system_test.go @@ -26,6 +26,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/bloombits" "github.com/ethereum/go-ethereum/core/types" @@ -136,7 +137,7 @@ func TestBlockSubscription(t *testing.T) { backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed} api = NewPublicFilterAPI(backend, false) genesis = new(core.Genesis).MustCommit(db) - chain, _ = core.GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *core.BlockGen) {}) + chain, _ = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 10, func(i int, gen *core.BlockGen) {}) chainEvents = []core.ChainEvent{} ) @@ -194,11 +195,11 @@ func TestPendingTxFilter(t *testing.T) { api = NewPublicFilterAPI(backend, false) transactions = []*types.Transaction{ - types.NewTransaction(0, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), new(big.Int), new(big.Int), nil), - types.NewTransaction(1, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), new(big.Int), new(big.Int), nil), - types.NewTransaction(2, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), new(big.Int), new(big.Int), nil), - types.NewTransaction(3, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), new(big.Int), new(big.Int), nil), - types.NewTransaction(4, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), new(big.Int), new(big.Int), nil), + types.NewTransaction(0, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil), + types.NewTransaction(1, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil), + types.NewTransaction(2, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil), + types.NewTransaction(3, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil), + types.NewTransaction(4, common.HexToAddress("0xb794f5ea0ba39494ce83a213fffba74279579268"), new(big.Int), 0, new(big.Int), nil), } hashes []common.Hash diff --git a/eth/filters/filter_test.go b/eth/filters/filter_test.go index 11235e95a7..0018142c46 100644 --- a/eth/filters/filter_test.go +++ b/eth/filters/filter_test.go @@ -24,6 +24,7 @@ import ( "testing" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -33,7 +34,7 @@ import ( ) func makeReceipt(addr common.Address) *types.Receipt { - receipt := types.NewReceipt(nil, false, new(big.Int)) + receipt := types.NewReceipt(nil, false, 0) receipt.Logs = []*types.Log{ {Address: addr}, } @@ -65,7 +66,7 @@ func BenchmarkFilters(b *testing.B) { defer db.Close() genesis := core.GenesisBlockForTesting(db, addr1, big.NewInt(1000000)) - chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, db, 100010, func(i int, gen *core.BlockGen) { + chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 100010, func(i int, gen *core.BlockGen) { switch i { case 2403: receipt := makeReceipt(addr1) @@ -132,10 +133,10 @@ func TestFilters(t *testing.T) { defer db.Close() genesis := core.GenesisBlockForTesting(db, addr, big.NewInt(1000000)) - chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, db, 1000, func(i int, gen *core.BlockGen) { + chain, receipts := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 1000, func(i int, gen *core.BlockGen) { switch i { case 1: - receipt := types.NewReceipt(nil, false, new(big.Int)) + receipt := types.NewReceipt(nil, false, 0) receipt.Logs = []*types.Log{ { Address: addr, @@ -144,7 +145,7 @@ func TestFilters(t *testing.T) { } gen.AddUncheckedReceipt(receipt) case 2: - receipt := types.NewReceipt(nil, false, new(big.Int)) + receipt := types.NewReceipt(nil, false, 0) receipt.Logs = []*types.Log{ { Address: addr, @@ -153,7 +154,7 @@ func TestFilters(t *testing.T) { } gen.AddUncheckedReceipt(receipt) case 998: - receipt := types.NewReceipt(nil, false, new(big.Int)) + receipt := types.NewReceipt(nil, false, 0) receipt.Logs = []*types.Log{ { Address: addr, @@ -162,7 +163,7 @@ func TestFilters(t *testing.T) { } gen.AddUncheckedReceipt(receipt) case 999: - receipt := types.NewReceipt(nil, false, new(big.Int)) + receipt := types.NewReceipt(nil, false, 0) receipt.Logs = []*types.Log{ { Address: addr, diff --git a/eth/handler.go b/eth/handler.go index bec5126dc8..074cffd96f 100644 --- a/eth/handler.go +++ b/eth/handler.go @@ -394,14 +394,14 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { case query.Reverse: // Number based traversal towards the genesis block if query.Origin.Number >= query.Skip+1 { - query.Origin.Number -= (query.Skip + 1) + query.Origin.Number -= query.Skip + 1 } else { unknown = true } case !query.Reverse: // Number based traversal towards the leaf block - query.Origin.Number += (query.Skip + 1) + query.Origin.Number += query.Skip + 1 } } return p.SendBlockHeaders(headers) @@ -744,22 +744,24 @@ func (self *ProtocolManager) txBroadcastLoop() { } } -// EthNodeInfo represents a short summary of the Ethereum sub-protocol metadata known -// about the host peer. -type EthNodeInfo struct { - Network uint64 `json:"network"` // Ethereum network ID (1=Frontier, 2=Morden, Ropsten=3) - Difficulty *big.Int `json:"difficulty"` // Total difficulty of the host's blockchain - Genesis common.Hash `json:"genesis"` // SHA3 hash of the host's genesis block - Head common.Hash `json:"head"` // SHA3 hash of the host's best owned block +// NodeInfo represents a short summary of the Ethereum sub-protocol metadata +// known about the host peer. +type NodeInfo struct { + Network uint64 `json:"network"` // Ethereum network ID (1=Frontier, 2=Morden, Ropsten=3, Rinkeby=4) + Difficulty *big.Int `json:"difficulty"` // Total difficulty of the host's blockchain + Genesis common.Hash `json:"genesis"` // SHA3 hash of the host's genesis block + Config *params.ChainConfig `json:"config"` // Chain configuration for the fork rules + Head common.Hash `json:"head"` // SHA3 hash of the host's best owned block } // NodeInfo retrieves some protocol metadata about the running host node. -func (self *ProtocolManager) NodeInfo() *EthNodeInfo { +func (self *ProtocolManager) NodeInfo() *NodeInfo { currentBlock := self.blockchain.CurrentBlock() - return &EthNodeInfo{ + return &NodeInfo{ Network: self.networkId, Difficulty: self.blockchain.GetTd(currentBlock.Hash(), currentBlock.NumberU64()), Genesis: self.blockchain.Genesis().Hash(), + Config: self.blockchain.Config(), Head: currentBlock.Hash(), } } diff --git a/eth/handler_test.go b/eth/handler_test.go index 6752cd2a84..9a02eddfb2 100644 --- a/eth/handler_test.go +++ b/eth/handler_test.go @@ -37,8 +37,6 @@ import ( "github.com/ethereum/go-ethereum/params" ) -var bigTxGas = new(big.Int).SetUint64(params.TxGas) - // Tests that protocol versions and modes of operations are matched up properly. func TestProtocolCompatibility(t *testing.T) { // Define the compatibility chart @@ -315,13 +313,13 @@ func testGetNodeData(t *testing.T, protocol int) { switch i { case 0: // In block 1, the test bank sends account #1 some ether. - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) block.AddTx(tx) case 1: // In block 2, the test bank sends some more ether to account #1. // acc1Addr passes it on to account #2. - tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, testBankKey) - tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, acc1Key) + tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey) + tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key) block.AddTx(tx1) block.AddTx(tx2) case 2: @@ -407,13 +405,13 @@ func testGetReceipt(t *testing.T, protocol int) { switch i { case 0: // In block 1, the test bank sends account #1 some ether. - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) block.AddTx(tx) case 1: // In block 2, the test bank sends some more ether to account #1. // acc1Addr passes it on to account #2. - tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, testBankKey) - tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, acc1Key) + tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBank), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey) + tx2, _ := types.SignTx(types.NewTransaction(block.TxNonce(acc1Addr), acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key) block.AddTx(tx1) block.AddTx(tx2) case 2: @@ -498,7 +496,7 @@ func testDAOChallenge(t *testing.T, localForked, remoteForked bool, timeout bool } // Create a block to reply to the challenge if no timeout is simulated if !timeout { - blocks, _ := core.GenerateChain(¶ms.ChainConfig{}, genesis, db, 1, func(i int, block *core.BlockGen) { + blocks, _ := core.GenerateChain(¶ms.ChainConfig{}, genesis, ethash.NewFaker(), db, 1, func(i int, block *core.BlockGen) { if remoteForked { block.SetExtra(params.DAOForkBlockExtra) } diff --git a/eth/helper_test.go b/eth/helper_test.go index f02242b152..d44574b86b 100644 --- a/eth/helper_test.go +++ b/eth/helper_test.go @@ -61,7 +61,7 @@ func newTestProtocolManager(mode downloader.SyncMode, blocks int, generator func genesis = gspec.MustCommit(db) blockchain, _ = core.NewBlockChain(db, gspec.Config, engine, vm.Config{}) ) - chain, _ := core.GenerateChain(gspec.Config, genesis, db, blocks, generator) + chain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, blocks, generator) if _, err := blockchain.InsertChain(chain); err != nil { panic(err) } @@ -130,7 +130,7 @@ func (p *testTxPool) SubscribeTxPreEvent(ch chan<- core.TxPreEvent) event.Subscr // newTestTransaction create a new dummy transaction. func newTestTransaction(from *ecdsa.PrivateKey, nonce uint64, datasize int) *types.Transaction { - tx := types.NewTransaction(nonce, common.Address{}, big.NewInt(0), big.NewInt(100000), big.NewInt(0), make([]byte, datasize)) + tx := types.NewTransaction(nonce, common.Address{}, big.NewInt(0), 100000, big.NewInt(0), make([]byte, datasize)) tx, _ = types.SignTx(tx, types.HomesteadSigner{}, from) return tx } diff --git a/eth/tracers/internal/tracers/4byte_tracer.js b/eth/tracers/internal/tracers/4byte_tracer.js new file mode 100644 index 0000000000..0a6b088cca --- /dev/null +++ b/eth/tracers/internal/tracers/4byte_tracer.js @@ -0,0 +1,86 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// 4byteTracer searches for 4byte-identifiers, and collects them for post-processing. +// It collects the methods identifiers along with the size of the supplied data, so +// a reversed signature can be matched against the size of the data. +// +// Example: +// > debug.traceTransaction( "0x214e597e35da083692f5386141e69f47e973b2c56e7a8073b1ea08fd7571e9de", {tracer: "4byteTracer"}) +// { +// 0x27dc297e-128: 1, +// 0x38cc4831-0: 2, +// 0x524f3889-96: 1, +// 0xadf59f99-288: 1, +// 0xc281d19e-0: 1 +// } +{ + // ids aggregates the 4byte ids found. + ids : {}, + + // callType returns 'false' for non-calls, or the peek-index for the first param + // after 'value', i.e. meminstart. + callType: function(opstr){ + switch(opstr){ + case "CALL": case "CALLCODE": + // gas, addr, val, memin, meminsz, memout, memoutsz + return 3; // stack ptr to memin + + case "DELEGATECALL": case "STATICCALL": + // gas, addr, memin, meminsz, memout, memoutsz + return 2; // stack ptr to memin + } + return false; + }, + + // store save the given indentifier and datasize. + store: function(id, size){ + var key = "" + toHex(id) + "-" + size; + this.ids[key] = this.ids[key] + 1 || 1; + }, + + // step is invoked for every opcode that the VM executes. + step: function(log, db) { + // Skip any opcodes that are not internal calls + var ct = this.callType(log.op.toString()); + if (!ct) { + return; + } + // Skip any pre-compile invocations, those are just fancy opcodes + if (isPrecompiled(toAddress(log.stack.peek(1)))) { + return; + } + // Gather internal call details + var inSz = log.stack.peek(ct + 1).valueOf(); + if (inSz >= 4) { + var inOff = log.stack.peek(ct).valueOf(); + this.store(log.memory.slice(inOff, inOff + 4), inSz-4); + } + }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) { }, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function(ctx) { + // Save the outer calldata also + if (ctx.input.length > 4) { + this.store(slice(ctx.input, 0, 4), ctx.input.length-4) + } + return this.ids; + }, +} diff --git a/eth/tracers/internal/tracers/assets.go b/eth/tracers/internal/tracers/assets.go new file mode 100644 index 0000000000..cb0421008c --- /dev/null +++ b/eth/tracers/internal/tracers/assets.go @@ -0,0 +1,350 @@ +// Code generated by go-bindata. +// sources: +// 4byte_tracer.js +// call_tracer.js +// evmdis_tracer.js +// noop_tracer.js +// opcount_tracer.js +// prestate_tracer.js +// DO NOT EDIT! + +package tracers + +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 __4byte_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x56\x5b\x6f\xdb\x4a\x0e\x7e\xb6\x7f\x05\xd7\x2f\xb5\x51\x59\x8e\x2f\x89\x2f\xd9\x16\xf0\xe6\xa4\x6d\x80\x9c\x24\x88\xdd\x3d\x28\x16\xfb\x30\x9e\xa1\xac\xd9\xc8\x33\xc2\x0c\xe5\x4b\x73\xf2\xdf\x17\x1c\x49\x89\x93\xd3\x62\xbb\x4f\x96\x47\xc3\x8f\x1f\xc9\x8f\xa4\x7a\x3d\xb8\xb0\xf9\xc1\xe9\x75\x4a\x30\x38\xe9\x8f\x61\x99\x22\xac\x6d\x17\x29\x45\x87\xc5\x06\xe6\x05\xa5\xd6\xf9\x66\xaf\x07\xcb\x54\x7b\x48\x74\x86\xa0\x3d\xe4\xc2\x11\xd8\x04\xe8\xcd\xfd\x4c\xaf\x9c\x70\x87\xb8\xd9\xeb\x95\x36\x3f\x7c\xcd\x08\x89\x43\x04\x6f\x13\xda\x09\x87\x33\x38\xd8\x02\xa4\x30\xe0\x50\x69\x4f\x4e\xaf\x0a\x42\xd0\x04\xc2\xa8\x9e\x75\xb0\xb1\x4a\x27\x07\x86\xd4\x04\x85\x51\xe8\x82\x6b\x42\xb7\xf1\x35\x8f\xcf\x37\x5f\xe1\x1a\xbd\x47\x07\x9f\xd1\xa0\x13\x19\xdc\x15\xab\x4c\x4b\xb8\xd6\x12\x8d\x47\x10\x1e\x72\x3e\xf1\x29\x2a\x58\x05\x38\x36\xfc\xc4\x54\x16\x15\x15\xf8\x64\x0b\xa3\x04\x69\x6b\x22\x40\xcd\xcc\x61\x8b\xce\x6b\x6b\x60\x58\xbb\xaa\x00\x23\xb0\x8e\x41\xda\x82\x38\x00\x07\x36\x67\xbb\x0e\x08\x73\x80\x4c\xd0\x8b\xe9\x2f\x24\xe4\x25\x6e\x05\xda\x04\x37\xa9\xcd\x11\x28\x15\xc4\x51\xef\x74\x96\xc1\x0a\xa1\xf0\x98\x14\x59\xc4\x68\xab\x82\xe0\x8f\xab\xe5\x97\xdb\xaf\x4b\x98\xdf\x7c\x83\x3f\xe6\xf7\xf7\xf3\x9b\xe5\xb7\x73\xd8\x69\x4a\x6d\x41\x80\x5b\x2c\xa1\xf4\x26\xcf\x34\x2a\xd8\x09\xe7\x84\xa1\x03\xd8\x84\x11\x7e\xbf\xbc\xbf\xf8\x32\xbf\x59\xce\xff\x71\x75\x7d\xb5\xfc\x06\xd6\xc1\xa7\xab\xe5\xcd\xe5\x62\x01\x9f\x6e\xef\x61\x0e\x77\xf3\xfb\xe5\xd5\xc5\xd7\xeb\xf9\x3d\xdc\x7d\xbd\xbf\xbb\x5d\x5c\xc6\xb0\x40\x66\x85\x6c\xff\xbf\x73\x9e\x84\xea\x39\x04\x85\x24\x74\xe6\xeb\x4c\x7c\xb3\x05\xf8\xd4\x16\x99\x82\x54\x6c\x11\x1c\x4a\xd4\x5b\x54\x20\x40\xda\xfc\xf0\xcb\x45\x65\x2c\x91\x59\xb3\x0e\x31\xff\x54\x90\x70\x95\x80\xb1\x14\x81\x47\x84\xbf\xa7\x44\xf9\xac\xd7\xdb\xed\x76\xf1\xda\x14\xb1\x75\xeb\x5e\x56\xc2\xf9\xde\xc7\xb8\xc9\x98\xa3\xd5\x81\x70\xe9\x84\x44\x07\x1e\x85\x93\x29\xfa\x10\x4c\x78\xd1\xd5\x0a\x0d\xe9\x44\xa3\xf3\x11\x8b\x14\xa4\xcd\x32\x94\xe4\x99\xc1\x26\x5c\xcc\xad\xa7\x6e\xee\xac\x44\xef\xb5\x59\x73\xe0\x70\x45\xaf\x2e\xc2\x06\x29\xb5\xca\xc3\x11\xdc\xdb\x68\xbc\xfe\x8e\x75\x36\x7c\x91\x97\x65\x54\x82\x44\x04\xde\x86\xe8\xc1\x21\xcb\x0c\x15\x78\xbd\x36\x82\x0a\x87\xa1\x97\x56\x08\x1b\x41\x92\xc5\x2e\xd6\x42\x1b\x4f\x7f\x01\x64\x9c\xba\x22\x97\x7b\xb1\xc9\x33\x9c\xf1\x33\xc0\x47\x50\xb8\x2a\xd6\x31\x71\x0a\x96\x4e\x18\x2f\x24\x8b\xbb\x0d\xad\x93\xfd\xa0\x3f\xc2\xd3\xe9\x18\x87\xa7\x4a\x9c\x4c\x86\x67\xd3\x41\x72\x3a\x9c\x9c\xf5\x47\x7d\x3c\x9b\x26\xa3\x31\x4e\xc7\xc3\xd5\x40\x9e\x9e\xe1\x58\x4c\x4e\xc6\xc3\x55\x1f\xc5\xc9\x24\x51\xe3\xd3\x71\x1f\xa7\x0a\x5b\x11\x3c\x06\x60\x37\x83\xd6\x51\xa6\x5b\x4f\x9d\xd2\xfb\x63\xf9\x03\x70\xb2\x1f\x8c\x95\x1c\x4c\xc7\xd8\xed\x0f\x26\x33\xe8\x47\x2f\x6f\x86\x13\x29\x47\x93\x61\xbf\x7b\x32\x83\xc1\xd1\xf9\xe9\x60\x94\x0c\x27\x93\x69\x77\x7a\xf6\xda\x40\xa8\xe4\x74\x9a\x4c\xa7\xdd\xc1\xe4\x0d\x94\x1c\x4c\xfa\xaa\x3f\x45\x86\xea\x97\xc7\x4f\xcd\xc7\x66\x83\x07\x8e\xf2\x20\xd6\x6b\x87\x6b\x41\x58\x56\x2d\x30\x0e\x2f\x12\x1e\x16\x71\xb3\xc1\xcf\x33\x78\x7c\x8a\x9a\xc1\x46\x8a\x2c\x5b\x1e\x72\x56\x35\x15\xce\x78\x78\x97\x88\xcc\xe3\xbb\xa0\x0b\x63\x4d\x97\x2f\x78\x1e\x1f\x01\x2f\x47\x7c\xe8\x6a\xa3\x70\x1f\x2e\xf0\x51\xa2\x9d\x27\x1e\xb3\x62\x13\x10\x45\xc2\xd3\xe4\xdd\x56\x64\x05\xbe\x8b\x40\xc7\x18\xc3\x06\x37\x5c\x54\xe1\x28\x6e\x36\x6a\x97\x33\x48\x0a\x53\x56\xca\xe6\x9e\x5c\xe7\xb1\xd9\x68\xf8\x9d\x26\x99\x1e\x1d\x48\xe1\x11\x5a\x17\xf3\xeb\xeb\xd6\x0c\x5e\xfe\x5c\xdc\xfe\x76\xd9\x9a\x35\x1b\x0d\x76\xb9\x16\x2c\x6d\xa5\x5c\x04\x5b\x91\x45\xa5\xbb\xea\xc7\x7f\x0f\x0f\xb6\xa0\xfa\xd7\x7f\x67\xb3\x32\x5e\x18\x9e\x43\xaf\x07\x9e\x84\x7c\x80\x9c\x1c\x90\x2d\xcd\x9a\xcf\xae\x7f\xbb\xbc\xbe\xfc\x3c\x5f\x5e\xbe\xa2\xb0\x58\xce\x97\x57\x17\xe5\xd1\x5f\x49\xfc\x1f\xfe\x07\x3f\xf3\xdf\x68\x3c\x35\x9f\x6f\x85\x9a\x9c\x37\x1b\x75\xd5\x3c\xf1\x9c\xf2\x3c\x8d\xc2\x18\xd1\x3c\x3c\xb9\x2c\x55\x6b\x86\x3e\xe7\x8e\xe1\x0e\x8a\x9b\x8d\x70\xff\x28\xdf\x5a\x45\xa1\xb9\x42\x86\xb7\xc2\xc1\x03\x1e\xe0\x03\xb4\x5a\xf0\x1e\xc8\x7e\xc1\x7d\x5b\xab\x0e\xbc\x87\x56\x97\x4f\xf8\xe6\x79\xb3\xd1\xa0\x54\xfb\x58\x2b\xff\xaf\x07\x3c\xfc\x1b\x3e\xc0\xeb\xff\xef\xa1\x0f\x7f\xfe\x09\xfd\x57\x34\x31\xe7\x85\xa1\xcd\xd6\x3e\xa0\x0a\x92\xe1\x01\x70\x00\x9b\x4b\xab\xaa\x8d\xc1\x11\xfc\xf3\x77\xc0\x3d\xca\x82\xd0\x07\xba\x98\x1f\xb1\xcd\xec\x3a\x02\xb5\xea\x00\xb3\xed\xf5\x60\xf1\xa0\xf3\xb0\xb8\x4a\x14\x5f\xc2\xf0\x46\x34\x96\x40\x1b\x42\x67\x44\x16\xa4\xed\xab\xf8\x24\xd5\x7c\x6b\xf5\x31\x6a\x6c\xf3\x98\xec\x82\x9c\x36\xeb\x76\xa7\xc3\x31\xea\x04\xda\x7f\x93\x54\xfa\xaa\xd2\x7f\x5e\x15\xe3\xd8\x75\xee\xb0\x2b\xed\x26\x0f\x5f\x19\x66\x6b\x65\xd8\xc3\x3e\x02\x4a\x2d\xef\x6f\x87\xf0\x9f\xc2\x13\x24\xc2\xc8\x67\xa2\x15\xbe\xf6\x77\x0e\x2b\x63\xd5\x26\x3b\x57\xca\xa1\xf7\x81\x51\x50\x42\xcc\x6d\xd6\xee\x77\x3a\x9d\x9f\xf1\xf8\x2c\xc2\xba\x7f\x15\x6b\xbd\xb7\xaa\x90\xb5\x59\x7c\x87\x0f\xf0\x06\x54\x12\x17\xaa\x13\x87\xf6\xbc\x4d\xda\xcf\x41\x87\xeb\x1f\x3f\xc0\xa8\x72\x59\x42\xdc\x26\xc9\x8f\x30\xde\xd8\x97\xca\x08\x22\x0b\x41\xb0\xce\xdd\x21\xf6\xbc\xa9\xda\x01\x24\xaa\xb0\xde\xc3\xa8\x13\x05\x6a\xdd\x51\xa7\x8a\xa7\x56\x4b\x22\x8a\x8c\x8e\xe5\xb2\x4b\xab\x4f\x02\x21\xa9\x10\x59\xa5\x10\xfe\xbc\xb1\x09\x08\x53\x8b\x28\x29\x97\x75\x23\xd8\xff\x50\x36\x50\xbb\x70\xe8\x7f\xe4\x83\x93\xc7\x7e\x6a\x3d\x85\x35\xbf\x42\xee\x29\x42\x27\xf8\x3b\xc7\x6e\xab\xae\xaa\xe6\x64\x80\x2b\xc7\x1f\xe7\xbf\x02\xae\x76\x15\x2f\x8c\xb0\x47\x1b\xe5\xf9\x11\x29\x49\xfb\x17\x1d\xd7\xfd\x6b\x0b\x1e\x99\x5c\x43\xee\x59\x10\x99\xb7\x55\x55\x24\xed\x63\x6d\xf2\x82\xe2\x0c\xcd\x9a\x52\xf8\xf8\x5c\xa0\xa3\x9c\x97\x89\x7e\xbe\x1b\xc1\x49\x14\xf2\xfc\xd6\xba\x3b\xea\xbc\x9e\x2b\x75\x07\x97\x3d\xfb\xd4\xfc\x6f\x00\x00\x00\xff\xff\x08\x1e\xd9\xac\x67\x0b\x00\x00") + +func _4byte_tracerJsBytes() ([]byte, error) { + return bindataRead( + __4byte_tracerJs, + "4byte_tracer.js", + ) +} + +func _4byte_tracerJs() (*asset, error) { + bytes, err := _4byte_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "4byte_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _call_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x59\xdf\x6f\x1b\x37\xf2\x7f\x96\xfe\x8a\x49\x1e\x6a\x09\x51\x24\x27\xe9\xb7\x5f\xc0\xae\x7a\xd0\x39\x4a\x6a\xc0\x8d\x03\x5b\x69\x10\x04\x79\xa0\x76\x67\x25\xd6\x5c\x72\x4b\x72\x2d\xef\xa5\xfe\xdf\x0f\x33\xe4\xae\x56\x3f\xec\xe8\x7a\xb8\x43\xef\x45\xd0\x2e\x67\x86\xc3\x99\xcf\xfc\xe2\x8e\x46\x70\x66\x8a\xca\xca\xc5\xd2\xc3\xcb\xe3\x17\xff\x0f\xb3\x25\xc2\xc2\x3c\x47\xbf\x44\x8b\x65\x0e\x93\xd2\x2f\x8d\x75\xdd\xd1\x08\x66\x4b\xe9\x20\x93\x0a\x41\x3a\x28\x84\xf5\x60\x32\xf0\x5b\xf4\x4a\xce\xad\xb0\xd5\xb0\x3b\x1a\x05\x9e\xbd\xcb\x24\x21\xb3\x88\xe0\x4c\xe6\x57\xc2\xe2\x09\x54\xa6\x84\x44\x68\xb0\x98\x4a\xe7\xad\x9c\x97\x1e\x41\x7a\x10\x3a\x1d\x19\x0b\xb9\x49\x65\x56\x91\x48\xe9\xa1\xd4\x29\x5a\xde\xda\xa3\xcd\x5d\xad\xc7\xdb\x77\x1f\xe0\x02\x9d\x43\x0b\x6f\x51\xa3\x15\x0a\xde\x97\x73\x25\x13\xb8\x90\x09\x6a\x87\x20\x1c\x14\xf4\xc6\x2d\x31\x85\x39\x8b\x23\xc6\x37\xa4\xca\x75\x54\x05\xde\x98\x52\xa7\xc2\x4b\xa3\x07\x80\x92\x34\x87\x5b\xb4\x4e\x1a\x0d\xaf\xea\xad\xa2\xc0\x01\x18\x4b\x42\x7a\xc2\xd3\x01\x2c\x98\x82\xf8\xfa\x20\x74\x05\x4a\xf8\x35\xeb\x01\x06\x59\x9f\x3b\x05\xa9\x79\x9b\xa5\x29\x10\xfc\x52\x78\x3a\xf5\x4a\x2a\x05\x73\x84\xd2\x61\x56\xaa\x01\x49\x9b\x97\x1e\x3e\x9e\xcf\x7e\xbe\xfc\x30\x83\xc9\xbb\x4f\xf0\x71\x72\x75\x35\x79\x37\xfb\x74\x0a\x2b\xe9\x97\xa6\xf4\x80\xb7\x18\x44\xc9\xbc\x50\x12\x53\x58\x09\x6b\x85\xf6\x15\x98\x8c\x24\xfc\x32\xbd\x3a\xfb\x79\xf2\x6e\x36\xf9\xfb\xf9\xc5\xf9\xec\x13\x18\x0b\x6f\xce\x67\xef\xa6\xd7\xd7\xf0\xe6\xf2\x0a\x26\xf0\x7e\x72\x35\x3b\x3f\xfb\x70\x31\xb9\x82\xf7\x1f\xae\xde\x5f\x5e\x4f\x87\x70\x8d\xa4\x15\x12\xff\xb7\x6d\x9e\xb1\xf7\x2c\x42\x8a\x5e\x48\xe5\x6a\x4b\x7c\x32\x25\xb8\xa5\x29\x55\x0a\x4b\x71\x8b\x60\x31\x41\x79\x8b\x29\x08\x48\x4c\x51\x1d\xec\x54\x92\x25\x94\xd1\x0b\x3e\xf3\x83\x80\x84\xf3\x0c\xb4\xf1\x03\x70\x88\xf0\xe3\xd2\xfb\xe2\x64\x34\x5a\xad\x56\xc3\x85\x2e\x87\xc6\x2e\x46\x2a\x88\x73\xa3\x9f\x86\x5d\x92\x99\x08\xa5\x66\x56\x24\x68\xc9\x39\x02\xb2\x92\xcc\xaf\xcc\x4a\x83\xb7\x42\x3b\x91\x90\xab\xe9\x7f\xc2\x60\x14\x1e\xf0\x8e\x9e\xbc\x23\xd0\x82\xc5\xc2\x58\xfa\xaf\x54\x8d\x33\xa9\x3d\x5a\x2d\x14\xcb\x76\x90\x8b\x14\x61\x5e\x81\x68\x0b\x1c\xb4\x0f\x43\x30\x0a\xee\x06\xa9\x33\x63\x73\x86\xe5\xb0\xfb\xb5\xdb\x89\x1a\x3a\x2f\x92\x1b\x52\x90\xe4\x27\xa5\xb5\xa8\x3d\x99\xb2\xb4\x4e\xde\x22\x93\x40\xa0\x89\xf6\x9c\xfe\xfa\x0b\xe0\x1d\x26\x65\x90\xd4\x69\x84\x9c\xc0\xe7\xaf\xf7\x5f\x06\x5d\x16\x9d\xa2\x4b\x50\xa7\x98\xf2\xf9\x6e\x1c\xac\x96\x6c\x51\x58\xe1\xd1\x2d\xc2\x6f\xa5\xf3\x2d\x9a\xcc\x9a\x1c\x84\x06\x53\x12\xe2\xdb\xd6\x91\xda\x1b\x16\x28\xe8\xbf\x46\xcb\x1a\x0d\xbb\x9d\x86\xf9\x04\x32\xa1\x1c\xc6\x7d\x9d\xc7\x82\x4e\x23\xf5\xad\xb9\x21\xc9\xc6\x12\x84\x6d\x05\xa6\x48\x4c\x1a\x83\x81\xce\xd1\x1c\x03\xdd\xb0\xdb\x21\xbe\x13\xc8\x4a\xcd\xdb\xf6\x94\x59\x0c\x20\x9d\xf7\xe1\x6b\xb7\x43\x62\xcf\x44\xe1\x4b\x8b\x6c\x4f\xb4\xd6\x58\x07\x32\xcf\x31\x95\xc2\xa3\xaa\xba\x9d\xce\xad\xb0\x61\x01\xc6\xa0\xcc\x62\xb8\x40\x3f\xa5\xc7\x5e\xff\xb4\xdb\xe9\xc8\x0c\x7a\x61\xf5\xc9\x78\xcc\xd9\x27\x93\x1a\xd3\x20\xbe\xe3\x97\xd2\x0d\x33\x51\x2a\xdf\xec\x4b\x4c\x1d\x8b\xbe\xb4\x9a\xfe\xde\x07\x2d\x3e\x22\x18\xad\x2a\x48\x28\xcb\x88\x39\x85\xa7\xab\x9c\xc7\x3c\x1e\xce\x0d\x20\x13\x8e\x4c\x28\x33\x58\x21\x14\x16\x9f\x27\x4b\x24\xdf\xe9\x04\xa3\x96\xae\x72\xec\xd4\x31\xd0\x6e\x43\x53\x0c\xbd\x79\x57\xe6\x73\xb4\xbd\x3e\x7c\x07\xc7\x77\xd9\x71\x1f\xc6\x63\xfe\x53\xeb\x1e\x79\xa2\xbe\x24\xc5\x14\xf1\xa0\xcc\x7f\xed\xad\xd4\x8b\x70\xd6\xa8\xeb\x79\x06\x02\x34\xae\x20\x31\x9a\x41\x4d\x5e\x99\xa3\xd4\x0b\x48\x2c\x0a\x8f\xe9\x00\x44\x9a\x82\x37\x01\x79\x0d\xce\x36\xb7\x84\xef\xbe\xe3\xbd\xc6\x70\x74\x76\x35\x9d\xcc\xa6\x47\x2d\x25\xa4\xbe\xcc\xb2\xa8\x07\xf3\x0e\x0b\xc4\x9b\xde\x8b\xfe\xf0\x56\xa8\x12\x2f\xb3\xa0\x51\xa4\x9d\xea\x14\xc6\x91\xe7\xd9\x36\xcf\xcb\x0d\x1e\x62\x1a\x8d\x60\xe2\x1c\xe6\x73\x85\xbb\xb1\x17\x83\x93\xe3\xd4\x79\x4a\x4e\x04\xb4\xc4\xe4\x85\x42\x02\x50\xbd\x6b\xb4\x34\x6b\xdc\xf1\x55\x81\x27\x00\x00\xa6\x18\xf0\x0b\x82\x3d\xbf\xf0\xe6\x67\xbc\x63\x77\xd4\xd6\x22\x00\x4d\xd2\xd4\xa2\x73\xbd\x7e\x3f\x90\x4b\x5d\x94\xfe\x64\x83\x3c\xc7\xdc\xd8\x6a\xe8\x28\xf7\xf4\xf8\x68\x83\x70\xd2\x9a\x67\x21\xdc\xb9\x26\x9e\x08\xca\xb7\xc2\xf5\xd6\x4b\x67\xc6\xf9\x93\x7a\x89\x1e\xea\x35\xb6\x05\xb1\x1d\x1d\xdf\x1d\xed\x5a\xeb\xb8\xbf\x76\xfa\x8b\x1f\xfa\xc4\x72\x7f\xda\x40\xb9\xc9\x08\xc3\xa2\x74\xcb\x1e\x23\x67\xbd\xba\x8e\xfa\x31\x78\x5b\xe2\x5e\xa4\x33\x7a\x76\x91\xe3\x50\x65\x94\x36\xbc\x2d\x13\x46\xd0\x42\x70\x52\xe1\xa0\x16\x94\x64\x5d\x39\x67\x9b\x7b\x63\x1e\x04\xd2\xf5\xf4\xe2\xcd\xeb\xe9\xf5\xec\xea\xc3\xd9\xac\x0d\x27\x85\x99\x27\xa5\x36\xcf\xa0\x50\x2f\xfc\x92\xf5\x27\x71\x9b\xab\x9f\x89\xe7\xf9\x8b\x2f\xe1\x0d\x8c\xf7\x44\x77\xe7\x71\x0e\xf8\xfc\x85\x65\xdf\xef\x9a\x6f\x93\x34\x18\xf3\x6b\x00\x91\x29\xee\xdb\x39\x62\x4f\xd8\xe5\xe8\x97\x26\xe5\x3c\x98\x88\x90\x4a\x6b\x2b\xa6\x46\xe3\xc1\xc1\xd7\xab\xa3\x6f\x72\x71\x71\x04\x7f\xfc\x01\xad\xe7\xb3\xcb\xd7\xd3\xf6\xbb\xd7\xd3\x8b\xe9\xdb\xc9\x6c\xba\x4d\x7b\x3d\x9b\xcc\xce\xcf\xf8\x6d\x3f\x5a\x65\x34\x82\xeb\x1b\x59\x70\x42\xe5\x34\x65\xf2\x82\x3b\xc3\x46\x5f\x37\x00\xbf\x34\xd4\x73\xd9\x58\x2f\x32\xa1\x93\x3a\x8f\xbb\xda\x69\xde\x90\xcb\x4c\x1d\x2b\xbb\xa9\xa0\x0d\xd4\x7e\xe3\x46\xe9\xde\x5b\x8c\x9b\xa6\x3d\x6f\x6a\xbd\xd6\x06\x0d\x1e\xe1\x5c\xc7\x49\xa6\x77\xf8\x21\xe1\x6f\x70\x0c\x27\xf0\x22\x66\x92\x47\x52\xd5\x4b\x78\x46\xe2\xff\x44\xc2\x7a\xb5\x87\xf3\xaf\x99\xb6\xbc\x61\xe2\x9a\xdc\x9b\xff\x7e\x3a\x33\xa5\xbf\xcc\xb2\x13\xd8\x36\xe2\xf7\x3b\x46\x6c\xe8\x2f\x50\xef\xd2\xff\xdf\x0e\xfd\x3a\xf5\x11\xaa\x4c\x01\x4f\x76\x20\x12\x12\xcf\x93\xad\x38\x88\xc6\xe5\x6e\x86\xa5\xc1\xf8\x81\x64\xfb\x72\x13\xc3\x0f\x65\x8b\x7f\x2b\xd9\xee\xed\xca\xa8\xf7\xda\xec\xbb\x06\x60\xd1\x5b\x89\xb7\x34\x59\x1d\x39\x16\x49\xfd\xa9\x59\x09\x9d\xe0\x10\x3e\x62\x90\xa8\x11\x39\xb9\xc4\x7e\x96\xda\x11\x6e\xf1\xa8\x27\x8d\x93\x09\x43\x4c\x70\xdb\x69\x11\x72\x51\xd1\x64\x92\x95\xfa\xa6\x82\x85\x70\x90\x56\x5a\xe4\x32\x71\x41\x1e\xf7\xb2\x16\x17\xc2\xb2\x58\x8b\xbf\x97\xe8\x68\xcc\x21\x20\x8b\xc4\x97\x42\xa9\x0a\x16\x92\x66\x15\xe2\xee\xbd\x7c\x75\x7c\x0c\xce\xcb\x02\x75\x3a\x80\x1f\x5e\x8d\x7e\xf8\x1e\x6c\xa9\xb0\x3f\xec\xb6\xd2\x78\x73\xd4\xe8\x0d\x5a\x88\xe8\x79\x8d\x85\x5f\xf6\xfa\xf0\xd3\x03\xf5\xe0\x81\xe4\xbe\x97\x16\x9e\xc3\x8b\x2f\x43\xd2\x6b\xbc\x81\xdb\xe0\x49\x40\xe5\x30\x4a\xa3\xf9\xee\xf2\xf5\x65\xef\x46\x58\xa1\xc4\x1c\xfb\x27\x3c\xef\xb1\xad\x56\x22\x36\xfc\xe4\x14\x28\x94\x90\x1a\x44\x92\x98\x52\x7b\x32\x7c\xdd\xbb\xab\x8a\xf2\xfb\x91\xaf\xe5\xf1\x68\x24\x92\x04\x9d\xab\xd3\x3d\x7b\x8d\xd4\x11\x39\x71\x83\xd4\x4e\xa6\xd8\xf2\x0a\x65\x07\xc3\xa9\x39\x52\xd0\xe4\x58\x0b\xcc\x8d\xa3\x4d\xe6\x08\x2b\x4b\x73\x86\x93\x3a\xe1\x41\x3b\x45\xb2\xb6\x03\xa3\x41\x80\x32\x3c\xdd\x73\x8c\x83\xb0\x0b\x37\x0c\xf9\x9e\xb6\xa5\x9c\xa3\xcd\x6a\xb8\x09\xe4\x36\x54\xb9\xa3\xdf\x6a\x07\x34\xe0\x9d\x74\x9e\x1b\x48\xd2\x52\x3a\x08\x48\x96\x7a\x31\x80\xc2\x14\x9c\xa7\x0f\xec\x25\xaf\xa6\xbf\x4e\xaf\x9a\xe2\x7f\xb8\x13\xeb\x16\xff\x69\x33\x01\x81\xa5\xf1\xc2\x63\xfa\x74\x4f\xcf\xbe\x07\x50\xe3\x07\x00\x45\xf2\xd7\xb5\xf1\x7d\xeb\x38\x4a\x38\xbf\x76\xcc\x02\xc3\xf8\xd2\x56\xc0\x95\xca\xbb\xad\xdc\xbd\x9d\x1c\x4c\x51\x57\x08\x52\x8a\xd3\x0e\x25\xf6\x3d\x9d\x75\x34\xb8\x6f\x03\x4f\x40\xa0\x69\x25\x00\x5e\xaf\x3b\x34\x11\x72\x3e\x6b\x68\x4a\x4f\x4e\xa7\x2a\xbd\x4e\x71\x0b\xe1\x3e\x38\xf6\x6d\x4c\x72\x73\xb9\x38\xd7\xbe\x57\x2f\x9e\x6b\x78\x0e\xf5\x03\xa5\x6e\x78\xbe\x11\x2b\x7b\x72\x60\x27\x45\x85\x1e\x61\x2d\xe2\x14\xb6\x5e\x91\xa0\x70\x68\x36\x8d\x45\xbf\x5b\x82\x8f\xa3\x34\x32\xcb\x13\x8b\x7e\x88\xbf\x97\x42\xb9\xde\x71\xd3\x12\x84\x13\x78\xc3\x45\x6c\xdc\x94\xb1\xba\xce\x11\xcf\x46\x93\x11\x05\x06\xb6\x68\x8d\x9a\x2d\x9d\x87\xda\x94\xe2\xa3\x12\xa2\x88\x98\x1c\x1a\x8f\x45\xf8\xed\xeb\x32\x3b\x6d\x02\x78\xda\x94\xfd\x4c\x48\x55\x5a\x7c\x7a\x0a\x7b\x92\x8b\x2b\x6d\x26\x12\xf6\xa5\x43\xe0\x11\xd4\x81\x33\x39\x2e\xcd\x2a\x28\xb0\x2f\x45\xed\x82\xa3\xc1\xc1\x56\x91\xe0\xbb\x14\xe1\xa0\x74\x62\x81\x2d\x70\x34\x06\xaf\x1d\xb5\x77\x2e\xfe\xd3\xd0\x79\xd6\x3c\x7e\x03\x45\x61\x97\x6f\x42\xe3\x31\x6c\xec\xf5\xf2\x4e\x2f\x53\x13\x71\x47\xd3\x7a\xa8\x55\x0d\x0d\x47\x83\x9c\x7f\xc5\xef\xff\x19\xc7\x07\xcf\xc7\xdf\x43\x03\x6d\x9b\x36\x9c\x71\x93\x38\x9c\x74\xdd\xc4\x7c\x1b\x05\xcd\xea\x43\x00\x78\xa8\x3f\x22\xa8\xea\xdf\x30\xf1\x6b\xb8\x72\x4b\x43\x4f\x85\xc5\x5b\x69\x4a\xaa\x56\xf8\xbf\x34\xff\x35\xfd\xdd\x7d\xb7\x73\x1f\xef\xbc\xd8\x7d\xed\x4b\xaf\xd5\x32\xde\xd9\x86\xd6\xa8\x55\x2b\x0c\x17\xd2\x78\x15\x96\x85\xdb\xd4\x0e\xf3\x3f\x72\xf9\x15\xe3\xdd\x9b\x82\x6a\x7f\x2c\x45\xca\xa2\x48\xab\xa6\xfa\x0d\x42\xd7\x01\x4b\xa1\xd3\x38\x79\x88\x34\x95\x24\x8f\xb1\x48\x1a\x8a\x85\x90\xba\xbb\xd7\x8c\xdf\x2c\xb9\xfb\x90\xb1\xd3\xc8\xb6\xab\x66\x9c\x18\x69\xbc\x63\x8d\xbb\x07\x54\xc7\xad\x58\xda\xbe\xc7\x8b\x57\x81\x46\xbb\x32\xe7\xb6\x17\xc4\xad\x90\x4a\xd0\xa8\xc5\xed\x94\x4e\x21\x51\x28\x74\xb8\xbd\xc7\xcc\x9b\x5b\xb4\xae\x7b\x00\xc8\xff\x0c\xc6\xb7\x92\x63\xfd\x18\xcd\x71\x78\xcc\x1e\x1a\xb1\xe1\xf8\x6f\x94\xf0\x3e\xc2\xab\x65\xde\x10\x59\xd2\xf3\x87\x1d\xd4\xbe\x7b\x58\x48\x71\x83\x44\x34\x3f\xc1\x71\xab\x09\xff\xab\x04\xd9\x2e\xc4\x2e\x9a\x66\x2c\x1e\xde\x1b\x33\x00\x85\x82\x47\xa2\xfa\xb3\x4b\xdd\x7c\x3e\x36\xa1\xd5\xd1\x1b\xda\xb7\x9d\xf0\xe5\x4b\xac\x25\xd6\xd7\x1d\xa1\x8f\x9f\x23\x6a\x90\x1e\xad\xa0\xe1\x87\xd0\x15\xbf\x14\x90\x96\x8e\xc5\xb1\x5f\x24\x05\x5d\x14\x1c\xaf\xed\xa9\x3e\x4b\xbd\x18\x76\x3b\xe1\x7d\x2b\xde\x13\x7f\xb7\x8e\xf7\x50\x0c\x99\x33\x5e\x00\x34\xf3\x7f\xe2\xef\xb8\x67\xe4\x19\x79\xeb\x12\x80\xd6\xe8\x55\x18\xa0\xb7\x46\x7e\x66\x8c\x63\xff\xf6\xcd\x22\xad\xf1\xbb\x0d\x80\x33\xe9\x42\xb8\x20\x66\x2b\x24\xfc\xdd\x6e\x44\xd4\x0c\x14\x0c\x27\xfb\x19\x68\x69\x0f\xd3\xd6\x35\x04\x11\xf3\xab\xb0\x1a\x0a\xfb\x49\x7b\x35\xbc\x8a\x07\x95\x79\xcb\x36\x32\x67\xdb\xdc\x9f\xee\x4f\x72\xc7\x35\x1e\xf7\x27\x33\xb2\x79\x03\xd8\x07\x58\xdb\x83\xc5\x2e\xc9\x63\xa9\x92\xa5\xd7\x99\xed\x01\x56\x96\xde\x6a\x3d\xfc\xdd\xe1\x22\x1b\xe2\xb6\x8a\x1b\x34\xfb\x84\xc4\x3c\x13\xe9\x82\x65\x6b\x01\x01\xd5\x41\x57\x46\xb4\xfc\x07\x46\x89\xed\xf8\xa9\x97\xc0\x62\xf8\xb0\xc0\x0d\x29\x85\x8f\x99\x73\xf1\x2f\x1d\xcd\x8c\xeb\xb8\x48\xd1\x49\x8b\x29\x64\x12\x55\x0a\x26\x45\xcb\x13\xe9\x6f\xce\xe8\xf0\x09\x09\xad\x24\x89\xe1\x53\x59\xf8\x6a\xcd\x1f\xf0\xb4\x4c\xd0\x57\x90\xa1\xe0\x6f\x41\xde\x40\x21\x9c\x83\x1c\x05\xcd\xa0\x59\xa9\x54\x05\xc6\xa6\x48\xc2\x9b\xa1\x8c\x42\xd2\x40\xe9\xd0\x3a\x58\x2d\x4d\x2c\x93\xdc\xa5\x15\xd4\x74\x4a\x3f\x88\xf7\x2e\xd2\x15\x4a\x54\x20\x3d\x95\xe4\x78\xa8\x76\x94\x36\x1f\x60\xf8\x2b\x8e\xa1\xaa\xbb\x1b\xa2\xf5\x5c\xb7\x19\xa3\xfc\x9a\x9e\x36\xa3\x33\xce\x35\x9b\x71\xb9\xbe\x91\xda\x0c\xc2\xba\x6c\x6c\x46\x5a\xbb\x08\x6d\x86\x13\xaf\xf0\xd3\x66\x20\xb5\xfa\x65\x5e\x60\x70\x34\x0c\xfc\xb4\x15\x5a\xac\x65\x8c\xad\xf0\xb9\xb1\x21\xe7\xa7\x41\x04\x0c\x79\xb1\x47\xc6\xb9\xc1\x8a\x32\x71\xb0\x51\xab\xac\x84\x17\x9f\x6f\xb0\xfa\xb2\xbf\x8a\x44\x38\xb6\xe8\x9a\xb2\x51\x43\x3a\xac\x3d\x12\xc8\x8d\x16\x72\x7c\x7c\x0a\xf2\xc7\x36\x43\x5d\xf9\x40\x3e\x7b\x56\xef\xd9\x5e\xff\x2c\xbf\xd4\xd1\xd9\x20\x7e\x6b\xbd\xbf\xa1\x51\x8c\x91\x40\x43\x41\xd1\xbd\xef\xfe\x33\x00\x00\xff\xff\xb5\x25\x8b\x4d\x94\x21\x00\x00") + +func call_tracerJsBytes() ([]byte, error) { + return bindataRead( + _call_tracerJs, + "call_tracer.js", + ) +} + +func call_tracerJs() (*asset, error) { + bytes, err := call_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "call_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _evmdis_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x57\xdf\x6f\xda\xca\x12\x7e\x86\xbf\x62\x94\x27\x50\x29\x60\x63\x08\x38\x27\x47\xe2\xa6\xf4\x1c\xae\xd2\x24\x02\x72\x8f\x2a\x94\x87\x05\xc6\xb0\xaa\xf1\x5a\xbb\x6b\x72\xb8\x55\xfe\xf7\xab\xd9\x59\x03\xf9\x75\xdb\x4a\xa7\x0f\x3b\xb5\x77\xbe\x6f\xbe\x9d\x19\xcf\x92\x56\x0b\xae\x54\xbe\xd7\x72\xbd\xb1\x10\xb6\x83\x73\x98\x6d\x10\xd6\xea\x23\xda\x0d\x6a\x2c\xb6\x30\x2c\xec\x46\x69\x53\x6d\xb5\x60\xb6\x91\x06\x12\x99\x22\x48\x03\xb9\xd0\x16\x54\x02\xf6\x85\x7f\x2a\x17\x5a\xe8\x7d\xb3\xda\x6a\x31\xe6\xcd\x6d\x62\x48\x34\x22\x18\x95\xd8\x47\xa1\x31\x86\xbd\x2a\x60\x29\x32\xd0\xb8\x92\xc6\x6a\xb9\x28\x2c\x82\xb4\x20\xb2\x55\x4b\x69\xd8\xaa\x95\x4c\xf6\x44\x29\x2d\x14\xd9\x0a\xb5\x0b\x6d\x51\x6f\x4d\xa9\xe3\x8f\x9b\x7b\xb8\x46\x63\x50\xc3\x1f\x98\xa1\x16\x29\xdc\x15\x8b\x54\x2e\xe1\x5a\x2e\x31\x33\x08\xc2\x40\x4e\x6f\xcc\x06\x57\xb0\x70\x74\x04\xfc\x4c\x52\xa6\x5e\x0a\x7c\x56\x45\xb6\x12\x56\xaa\xac\x01\x28\x49\x39\xec\x50\x1b\xa9\x32\xe8\x94\xa1\x3c\x61\x03\x94\x26\x92\x9a\xb0\x74\x00\x0d\x2a\x27\x5c\x1d\x44\xb6\x87\x54\xd8\x23\xf4\x27\x12\x72\x3c\xf7\x0a\x64\xe6\xc2\x6c\x54\x8e\x60\x37\xc2\xd2\xa9\x1f\x65\x9a\xc2\x02\xa1\x30\x98\x14\x69\x83\xd8\x16\x85\x85\xbf\xc6\xb3\x3f\x6f\xef\x67\x30\xbc\xf9\x0a\x7f\x0d\x27\x93\xe1\xcd\xec\xeb\x05\x3c\x4a\xbb\x51\x85\x05\xdc\x21\x53\xc9\x6d\x9e\x4a\x5c\xc1\xa3\xd0\x5a\x64\x76\x0f\x2a\x21\x86\x2f\xa3\xc9\xd5\x9f\xc3\x9b\xd9\xf0\x5f\xe3\xeb\xf1\xec\x2b\x28\x0d\x9f\xc7\xb3\x9b\xd1\x74\x0a\x9f\x6f\x27\x30\x84\xbb\xe1\x64\x36\xbe\xba\xbf\x1e\x4e\xe0\xee\x7e\x72\x77\x3b\x1d\x35\x61\x8a\xa4\x0a\x09\xff\xe3\x9c\x27\xae\x7a\x1a\x61\x85\x56\xc8\xd4\x94\x99\xf8\xaa\x0a\x30\x1b\x55\xa4\x2b\xd8\x88\x1d\x82\xc6\x25\xca\x1d\xae\x40\xc0\x52\xe5\xfb\x9f\x2e\x2a\x71\x89\x54\x65\x6b\x77\xe6\x77\x1b\x12\xc6\x09\x64\xca\x36\xc0\x20\xc2\x6f\x1b\x6b\xf3\xb8\xd5\x7a\x7c\x7c\x6c\xae\xb3\xa2\xa9\xf4\xba\x95\x32\x9d\x69\xfd\xde\xac\x12\x27\xee\xb6\x2b\x69\x66\x5a\x2c\x51\x83\x46\x5b\xe8\xcc\x80\x29\x92\x84\xfc\x2c\xc8\x2c\x51\x7a\xeb\xda\x04\x12\xad\xb6\x20\xc0\x92\x2f\x58\x05\x39\x6a\xda\xf4\x14\x1f\x8d\xdd\xa7\x4e\xe6\x4a\x1a\x61\x0c\x6e\x17\xe9\xbe\x59\xfd\x5e\xad\x18\x2b\x96\xdf\x62\x98\x7f\x57\xb9\x89\x61\xfe\xf0\xf4\xd0\xa8\x56\x2b\x59\x5e\x98\x0d\x9a\x18\xbe\xb7\x63\x68\x37\x20\x88\x21\x68\x40\xe8\xd6\x8e\x5b\x23\xb7\x76\xdd\xda\x73\xeb\xb9\x5b\xfb\x6e\x1d\xb8\x35\x68\xb3\x61\x74\xc0\x6e\x01\xfb\x05\xec\x18\xb0\x67\xc8\x9e\xa1\x8f\xc3\x81\x42\x8e\x14\x72\xa8\x90\x63\x85\xcc\xd2\x61\x97\x88\x59\x22\x66\xe9\x32\x4b\x97\x59\xba\xec\xd2\x65\x96\xae\x17\xdc\x75\xe7\xe9\x32\x4b\xf7\x9c\x9f\x98\xa5\xcb\x2c\x3d\x3e\x72\x8f\x01\x3d\x7f\x44\x06\xf4\x58\x7c\x8f\x01\x3d\x06\xf4\x19\xd0\xe7\xb0\xfd\x90\x9f\x3a\x6c\x98\xa5\xcf\x61\xfb\x3d\x36\x1c\xb6\xcf\x2c\x7d\x66\x19\xb0\xf8\x41\xe0\xf6\x06\x1c\x6f\xc0\xf1\x06\x3e\xab\x65\x5a\x7d\x5e\xdb\x3e\xb1\xed\xd0\xdb\x8e\xb7\x91\xb7\x5d\x6f\x7d\xe6\xdb\x3e\xf5\x6d\x9f\xfb\xb6\xe7\x3b\xd4\xc9\xf3\x05\x9e\x2f\xf0\x7c\x81\xe7\x0b\x3c\x5f\x59\xc9\xb2\x94\x65\x2d\x7d\x31\x03\x5f\xcd\xc0\x97\x33\xf0\xf5\x0c\x7c\x41\x03\x5f\xd1\xc0\x97\x34\xf0\x35\x0d\x42\xcf\x17\xf6\x63\x08\xc9\x0e\x62\xe8\x34\x20\xe8\xb4\x63\x88\xc8\x06\x31\x74\xc9\x86\x31\xf4\xc8\x76\x62\x38\x27\x1b\xc5\xd0\x27\xdb\x8d\x61\x40\x96\xf8\xa8\x6b\x3b\x44\x48\x8c\x1d\x52\x48\x94\x1d\x92\x48\x9c\x11\x69\x24\xd2\x88\x44\x12\x6b\x44\x2a\x89\x36\x22\x99\xc4\x1b\x45\xac\x23\xea\xb2\x8e\xa8\xc7\x3a\xa2\x73\xd6\x41\xdd\xe7\x00\x03\xd6\x41\xfd\x47\x3a\xa8\x01\x49\x87\xeb\x40\xd2\xe1\x7a\x90\x74\xb8\x2e\x24\x4a\xea\x43\xa7\xc3\x75\x22\x91\x52\x2f\x3a\x1d\xae\x1b\x89\xd6\xf5\x23\xf1\xfa\x8e\x0c\x7a\x81\xb7\xa1\xb7\x1d\x6f\x23\x67\xc3\xc8\x7f\x45\x91\xff\x8c\x22\xff\x1d\x45\x1d\xbf\xef\xfd\xdc\x47\xf0\x44\xdf\x79\xab\x05\x1a\x4d\x91\x5a\x1a\xfe\x32\xdb\xa9\x6f\x34\x9e\x37\x98\x81\x48\x53\x37\xc7\x54\xbe\x54\x2b\x34\x3c\x1f\x17\x88\x19\x48\x8b\x5a\xd0\x05\xa1\x76\xa8\xe9\x6e\x2c\x27\x93\xa3\x23\x4c\x22\x33\x91\x96\xc4\x7e\x86\xd2\x60\x92\xd9\xba\x59\xad\xf0\xfb\x18\x92\x22\x5b\xd2\xe8\xaa\xd5\xe1\xbb\xa7\x00\xbb\x91\xa6\xe9\x46\xd2\xbc\xfd\xd0\x54\xb9\xb9\x80\x52\x67\x22\xde\x92\x49\xd4\x62\x69\x0b\x91\x02\xfe\x8d\xcb\xc2\xcd\x42\x95\x80\xc8\xbc\x72\x48\x78\xe0\x57\x1c\xfe\x24\x6a\xaa\xd6\x0d\x58\x2d\x28\x78\x19\xc2\x58\xcc\x4f\x23\xd0\xb5\x81\x3b\xd4\xfb\x92\xcb\x5d\x83\x14\xf2\x3f\x5f\x7c\x38\x24\x6a\xc2\xbd\xc9\x5c\xad\x54\x76\x42\x43\xa2\xc5\x16\xe1\xf2\xf4\x74\xc7\xff\x36\x53\xcc\xd6\x76\x03\x1f\x21\x78\xb8\xa8\x7a\x04\x6a\xad\x34\x5c\x42\xaa\xd6\xcd\x35\xda\x11\x3d\xd6\xea\x17\xd5\x4a\x45\x26\x50\x73\xbb\x4c\x5f\x71\xdc\xf3\x33\xf7\xea\xec\x01\x2e\x19\x4a\x9e\x4f\x80\xa9\x41\x20\x80\xa7\xf9\x84\xb9\xdd\xd4\xea\x70\x79\x2a\xc5\xc7\xf7\x74\x2a\xa7\x4b\x05\x2e\xf9\xa9\xa2\xf2\x18\xe8\x1f\x11\xa8\xbc\x69\xd5\x4d\xb1\x5d\xa0\xae\xd5\x1b\x6e\x7b\x45\x84\x10\xc3\x73\x7e\xde\x2b\xcb\x3c\x7f\x70\xcf\x4f\x24\xc9\xa9\x77\x8a\xa9\xb6\xe5\xc9\x7f\x87\xb6\x8f\xee\xce\x9e\x6b\xdc\xa9\x1c\x2e\xe1\xe0\x38\x7f\x05\xe1\x64\x11\x22\x51\xba\x46\x28\x09\x97\xd0\xbe\x00\x09\xbf\xf1\xd9\xfc\x0d\x36\x67\xb6\xa6\xca\x1f\x2e\x40\x7e\xf8\x50\x77\xa0\x8a\x7f\xcb\x1a\x9b\xe4\xea\x72\xc4\x09\xc9\x11\xbf\xd5\x64\xbd\x69\xd5\xd4\x6a\x99\xad\x6b\x41\xaf\xee\x72\x5f\x79\xa2\xc5\x3c\x4a\xbb\x64\x7f\x97\x12\xef\x54\xf7\x67\x58\x0a\x83\x70\x76\x35\xbc\xbe\x3e\x8b\xe1\xf8\x70\x75\xfb\x69\x74\x16\x1f\x0e\x29\x33\x63\xe9\xe7\x2b\x97\xf8\x24\x6e\xa7\xde\xdc\x89\xb4\xc0\xdb\x84\xeb\x7d\x70\x97\xff\xc5\xd7\xde\xd1\x2b\x6f\x2e\xe0\xfc\x6c\x2d\x8c\x6b\x87\x17\x80\xf6\xbb\x00\xab\xde\xf2\x0f\x9e\xa7\xe1\x39\xc4\x31\xbd\x85\x0a\x4f\x50\x2f\x30\x32\xcb\x0b\x7b\xc0\x6c\x71\xab\xf4\xbe\x69\xe8\x87\x4f\xcd\xe7\xa4\x71\x48\xce\x07\x7f\xee\x17\x14\xc7\x5e\xcf\x8a\x34\x7d\xbe\xc7\x73\xe4\x9d\x4d\x95\x73\x4e\xe6\xbe\x77\x4e\x3e\x02\xd7\x02\xec\xe7\xa3\x2d\x34\x8a\x6f\x17\xc7\x8a\x7e\x1a\x5d\x8f\xfe\x18\xce\x46\xcf\x2a\x3b\x9d\x0d\x67\xe3\x2b\x7e\xf5\xe3\xda\x86\xbf\x54\xdb\xd7\x9d\x70\x3c\x87\x3b\x06\xbc\x6a\xc1\xb7\x5b\xe0\x97\x7b\xe0\x97\x9a\xe0\x58\xd0\x7f\xa2\xa2\xff\xbf\xa4\xff\x74\x4d\x27\xa3\xd9\xfd\xe4\xe6\xa4\x74\xf4\xe7\xca\x4f\x7c\x33\xde\xf5\xed\xba\x05\xaf\xdc\x79\x7c\xf9\x2b\xee\x8d\xc6\x57\x85\x6d\xb8\xd0\x1f\x4a\xd6\x77\xf4\x4e\x67\xb7\x77\xc7\xde\xbb\x1f\x5f\x8d\x0f\x43\xe5\x47\x31\xda\x0d\x68\xbf\xc3\xfa\xef\xfb\x2f\x77\x9f\x46\xd3\x99\x67\x2a\x33\x9b\x2f\x0f\x9f\xe9\x1a\xed\xdd\x55\xed\x64\x06\xca\xa4\x9c\x7f\xd2\xdc\x51\x9a\xcb\xe9\x77\x40\xa7\x98\x1d\xe0\xcf\x6e\x0e\xf8\x08\xed\xbf\xbb\x78\xe4\x3a\x0e\xf7\x97\x05\xf3\x37\x98\x23\x3e\xd6\xf5\xd9\x45\x7a\x3c\xdd\xf3\x3b\x88\xf1\xd5\xca\x53\xf5\xa9\xfa\xbf\x00\x00\x00\xff\xff\x51\x4b\xdc\x7e\x62\x10\x00\x00") + +func evmdis_tracerJsBytes() ([]byte, error) { + return bindataRead( + _evmdis_tracerJs, + "evmdis_tracer.js", + ) +} + +func evmdis_tracerJs() (*asset, error) { + bytes, err := evmdis_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "evmdis_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _noop_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x93\x4f\x6f\xdb\x46\x10\xc5\xcf\xe6\xa7\x78\xc7\x04\x50\xc5\xfe\x39\x14\x70\x8b\x02\xac\x61\x27\x2a\x1c\xd9\x90\xe8\x06\x3e\x0e\xc9\xa1\xb8\xe9\x6a\x87\x9d\x9d\x95\x22\x04\xf9\xee\xc5\x92\x52\x13\x14\x69\x9b\x9b\xb0\xd2\xfb\xbd\x37\xf3\x46\x65\x89\x1b\x19\x4f\xea\x76\x83\xe1\xfb\x6f\xbf\xfb\x11\xf5\xc0\xd8\xc9\x37\x6c\x03\x2b\xa7\x3d\xaa\x64\x83\x68\x2c\xca\x12\xf5\xe0\x22\x7a\xe7\x19\x2e\x62\x24\x35\x48\x0f\xfb\xc7\xef\xbd\x6b\x94\xf4\xb4\x2c\xca\x72\xd6\x7c\xf1\xeb\x4c\xe8\x95\x19\x51\x7a\x3b\x92\xf2\x35\x4e\x92\xd0\x52\x80\x72\xe7\xa2\xa9\x6b\x92\x31\x9c\x81\x42\x57\x8a\x62\x2f\x9d\xeb\x4f\x19\xe9\x0c\x29\x74\xac\x93\xb5\xb1\xee\xe3\x25\xc7\xab\xf5\x13\xee\x39\x46\x56\xbc\xe2\xc0\x4a\x1e\x8f\xa9\xf1\xae\xc5\xbd\x6b\x39\x44\x06\x45\x8c\xf9\x25\x0e\xdc\xa1\x99\x70\x59\x78\x97\xa3\x6c\xcf\x51\x70\x27\x29\x74\x64\x4e\xc2\x02\xec\x72\x72\x1c\x58\xa3\x93\x80\x1f\x2e\x56\x67\xe0\x02\xa2\x19\xf2\x82\x2c\x0f\xa0\x90\x31\xeb\x5e\x82\xc2\x09\x9e\xec\x93\xf4\x2b\x16\xf2\x69\xee\x0e\x2e\x4c\x36\x83\x8c\x0c\x1b\xc8\xf2\xd4\x47\xe7\x3d\x1a\x46\x8a\xdc\x27\xbf\xc8\xb4\x26\x19\xde\xae\xea\xd7\x0f\x4f\x35\xaa\xf5\x33\xde\x56\x9b\x4d\xb5\xae\x9f\x7f\xc2\xd1\xd9\x20\xc9\xc0\x07\x9e\x51\x6e\x3f\x7a\xc7\x1d\x8e\xa4\x4a\xc1\x4e\x90\x3e\x13\xde\xdc\x6e\x6e\x5e\x57\xeb\xba\xfa\x75\x75\xbf\xaa\x9f\x21\x8a\xbb\x55\xbd\xbe\xdd\x6e\x71\xf7\xb0\x41\x85\xc7\x6a\x53\xaf\x6e\x9e\xee\xab\x0d\x1e\x9f\x36\x8f\x0f\xdb\xdb\x25\xb6\x9c\x53\x71\xd6\xff\xff\xce\xfb\xa9\x3d\x65\x74\x6c\xe4\x7c\xbc\x6c\xe2\x59\x12\xe2\x20\xc9\x77\x18\xe8\xc0\x50\x6e\xd9\x1d\xb8\x03\xa1\x95\xf1\xf4\xd5\xa5\x66\x16\x79\x09\xbb\x69\xe6\x7f\x3d\x48\xac\x7a\x04\xb1\x05\x22\x33\x7e\x1e\xcc\xc6\xeb\xb2\x3c\x1e\x8f\xcb\x5d\x48\x4b\xd1\x5d\xe9\x67\x5c\x2c\x7f\x59\x16\x99\x19\x44\xc6\x5a\xa9\x65\xcd\xe5\xbc\x4b\xd1\x26\x76\x43\xca\x8d\x04\x46\x23\xce\xb3\x8e\xb9\x65\xb4\xd2\xe5\x01\xfe\x4c\x4e\xb9\x43\xaf\xb2\x07\xe1\x37\x3a\xd0\xb6\x55\x37\x5a\xc6\x49\xf3\x8e\x5b\x83\xc9\x5c\x21\x35\x7e\x3a\x47\x82\x29\x85\x48\x6d\xbe\x9b\xfc\xb9\x65\x5d\x16\x1f\x8a\xab\xb2\x44\x34\x1e\xb3\xb7\x0b\x07\xf9\x23\x73\x45\x73\x9f\x7a\x82\x8c\x93\xe3\x74\x19\x39\xd4\xef\x6f\xc0\xef\xb9\x4d\xc6\x71\x59\x5c\x65\xdd\x35\xfa\x14\x26\xe8\x0b\x2f\xbb\x05\xba\xe6\x25\x3e\xe0\xe3\xa2\x98\xc8\x3d\x25\x6f\x9f\xa3\x8f\xc3\xf9\x4c\xa8\xb5\x44\xfe\x4c\xcb\x91\xa4\x07\x85\x8b\x61\x3f\x17\x78\x35\xe9\xff\xdb\x42\x39\x7e\xc9\x83\xbc\x9f\x7c\x66\x60\x9c\xab\x6f\x98\x03\x9c\xb1\x52\xbe\x7d\x39\xb0\xe6\xbf\x3d\x94\x2d\x69\x88\x13\x2e\x6b\x7a\x17\xc8\x5f\xc0\xe7\xf3\xc8\x1b\x73\x61\xb7\x2c\xae\xe6\xf7\xcf\x42\xb5\xf6\xfe\xef\x50\xc5\xc7\xe2\xaf\x00\x00\x00\xff\xff\x13\x5b\x7d\x37\xec\x04\x00\x00") + +func noop_tracerJsBytes() ([]byte, error) { + return bindataRead( + _noop_tracerJs, + "noop_tracer.js", + ) +} + +func noop_tracerJs() (*asset, error) { + bytes, err := noop_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "noop_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _opcount_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x8c\x94\xcf\x6e\xdb\x46\x10\x87\xcf\xe2\x53\xfc\x8e\x09\xa2\x92\x69\x7b\x28\xe0\x16\x05\x58\xc3\x4e\x04\xd8\xb2\x21\xd1\x09\x7c\x5c\x92\x43\x71\x9b\xd5\x2e\x31\x3b\x2b\x86\x08\xfc\xee\xc5\x2e\xc5\xc6\x08\x5c\xd4\xd7\xd5\xcc\xf7\xcd\x3f\xb1\x28\x70\xe9\x86\x89\xf5\xa1\x17\xfc\xf2\xfe\xe7\xdf\x50\xf5\x84\x83\xfb\x89\xa4\x27\xa6\x70\x44\x19\xa4\x77\xec\xb3\xa2\x40\xd5\x6b\x8f\x4e\x1b\x82\xf6\x18\x14\x0b\x5c\x07\xf9\x21\xde\xe8\x9a\x15\x4f\x79\x56\x14\x73\xce\x8b\x3f\x47\x42\xc7\x44\xf0\xae\x93\x51\x31\x5d\x60\x72\x01\x8d\xb2\x60\x6a\xb5\x17\xd6\x75\x10\x82\x16\x28\xdb\x16\x8e\x71\x74\xad\xee\xa6\x88\xd4\x82\x60\x5b\xe2\xa4\x16\xe2\xa3\x5f\xea\xf8\xb0\x7d\xc0\x0d\x79\x4f\x8c\x0f\x64\x89\x95\xc1\x7d\xa8\x8d\x6e\x70\xa3\x1b\xb2\x9e\xa0\x3c\x86\xf8\xe2\x7b\x6a\x51\x27\x5c\x4c\xbc\x8e\xa5\xec\xcf\xa5\xe0\xda\x05\xdb\x2a\xd1\xce\xae\x41\x3a\x56\x8e\x13\xb1\xd7\xce\xe2\xd7\x45\x75\x06\xae\xe1\x38\x42\xde\x28\x89\x0d\x30\xdc\x10\xf3\xde\x42\xd9\x09\x46\xc9\xf7\xd4\x57\x0c\xe4\x7b\xdf\x2d\xb4\x4d\x9a\xde\x0d\x04\xe9\x95\xc4\xae\x47\x6d\x0c\x6a\x42\xf0\xd4\x05\xb3\x8e\xb4\x3a\x08\x3e\x6f\xaa\x8f\x77\x0f\x15\xca\xed\x23\x3e\x97\xbb\x5d\xb9\xad\x1e\x7f\xc7\xa8\xa5\x77\x41\x40\x27\x9a\x51\xfa\x38\x18\x4d\x2d\x46\xc5\xac\xac\x4c\x70\x5d\x24\xdc\x5e\xed\x2e\x3f\x96\xdb\xaa\xfc\x6b\x73\xb3\xa9\x1e\xe1\x18\xd7\x9b\x6a\x7b\xb5\xdf\xe3\xfa\x6e\x87\x12\xf7\xe5\xae\xda\x5c\x3e\xdc\x94\x3b\xdc\x3f\xec\xee\xef\xf6\x57\x39\xf6\x14\xab\xa2\x98\xff\xff\x33\xef\xd2\xf6\x98\xd0\x92\x28\x6d\xfc\x32\x89\x47\x17\xe0\x7b\x17\x4c\x8b\x5e\x9d\x08\x4c\x0d\xe9\x13\xb5\x50\x68\xdc\x30\xbd\x7a\xa9\x91\xa5\x8c\xb3\x87\xd4\xf3\x7f\x1e\x24\x36\x1d\xac\x93\x35\x3c\x11\xfe\xe8\x45\x86\x8b\xa2\x18\xc7\x31\x3f\xd8\x90\x3b\x3e\x14\x66\xc6\xf9\xe2\xcf\x3c\x8b\x4c\x37\x34\x2e\x58\xa9\x58\x35\xc4\x71\x3f\x0a\x5e\x1d\x07\x43\x90\xf9\x29\xed\xe5\xef\xe0\x05\x29\xd0\x27\xb5\x0d\xc7\x9a\x38\x16\xaf\xad\x17\x0e\x4d\xbc\x87\xf4\xf7\xa1\xaf\xd4\xa4\xdd\xd6\x53\x8a\xbc\xfa\x74\x8b\x9a\xba\x38\x99\x74\xc9\xac\xac\x57\x29\x3c\x5d\xb5\xb6\x4a\xa8\xcd\xb3\x6f\xd9\xaa\x28\x66\x43\x12\x7f\xf9\xd1\x13\x39\xcf\x5d\xff\x8a\xf2\x6c\x95\xd2\x2e\xf0\x7e\x9d\x25\x8a\x17\x1a\x62\x27\xda\x9e\xdc\x17\x6a\xd3\x6a\xe8\x44\x3c\xa5\x66\xdb\xf3\xa9\x45\xfc\xa7\xdb\x05\xe3\xf3\x6c\x15\xf3\x2e\xd0\x05\x9b\x0c\x6f\x8c\x3b\xac\xd1\xd6\x6f\xf1\x0d\xd2\x6b\x9f\x27\xcb\xbb\x77\x78\x3a\x6b\x3a\x15\x8c\x3c\xf7\x8c\xfd\xf9\x08\x55\x23\x41\x99\x33\x3a\x76\xea\x3a\x28\xbb\xd8\xbb\xf9\x3c\x56\x29\xff\x65\xdf\xa2\x60\xf2\x2f\x39\x94\x31\xc9\x33\x03\xfd\x7c\x58\x35\x91\x85\x16\xe2\x38\x50\xb8\x13\x71\xfc\xa8\x80\x49\x02\x5b\x9f\x70\x31\xa7\xd3\x56\x99\x05\x7c\x3e\xbe\x38\x70\x6d\x0f\x79\xb6\x9a\xdf\x9f\x15\xd5\xc8\xd7\xa5\xa8\x99\xf4\x6c\x16\x78\xca\x9e\xb2\x7f\x02\x00\x00\xff\xff\xdd\xd8\xa1\x0a\x5c\x05\x00\x00") + +func opcount_tracerJsBytes() ([]byte, error) { + return bindataRead( + _opcount_tracerJs, + "opcount_tracer.js", + ) +} + +func opcount_tracerJs() (*asset, error) { + bytes, err := opcount_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "opcount_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)} + a := &asset{bytes: bytes, info: info} + return a, nil +} + +var _prestate_tracerJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x57\xdd\x6f\x1b\xb9\x11\x7f\xde\xfd\x2b\xa6\x7e\x91\x84\x53\x56\xce\x15\xb8\x02\x72\x5d\x60\xa3\x28\x89\x00\x9d\x6d\x48\x4a\x5d\xf7\x70\x0f\x5c\x72\x76\xc5\x13\x45\x2e\x48\xae\x3e\x10\xf8\x7f\x2f\x86\xfb\x21\xcb\x67\x27\x6e\xeb\x27\x2f\x39\xfc\xcd\xf7\x6f\x46\xa3\x11\x4c\x4c\x79\xb4\xb2\x58\x7b\xf8\xf9\xf2\xfd\xdf\x60\xb5\x46\x28\xcc\x3b\xf4\x6b\xb4\x58\x6d\x21\xad\xfc\xda\x58\x17\x8f\x46\xb0\x5a\x4b\x07\xb9\x54\x08\xd2\x41\xc9\xac\x07\x93\x83\x7f\x26\xaf\x64\x66\x99\x3d\x26\xf1\x68\x54\xbf\x79\xf1\x9a\x10\x72\x8b\x08\xce\xe4\x7e\xcf\x2c\x8e\xe1\x68\x2a\xe0\x4c\x83\x45\x21\x9d\xb7\x32\xab\x3c\x82\xf4\xc0\xb4\x18\x19\x0b\x5b\x23\x64\x7e\x24\x48\xe9\xa1\xd2\x02\x6d\x50\xed\xd1\x6e\x5d\x6b\xc7\xe7\x9b\xaf\x30\x47\xe7\xd0\xc2\x67\xd4\x68\x99\x82\xbb\x2a\x53\x92\xc3\x5c\x72\xd4\x0e\x81\x39\x28\xe9\xc4\xad\x51\x40\x16\xe0\xe8\xe1\x27\x32\x65\xd9\x98\x02\x9f\x4c\xa5\x05\xf3\xd2\xe8\x21\xa0\x24\xcb\x61\x87\xd6\x49\xa3\xe1\xaf\xad\xaa\x06\x70\x08\xc6\x12\x48\x9f\x79\x72\xc0\x82\x29\xe9\xdd\x00\x98\x3e\x82\x62\xfe\xf4\xf4\x0d\x01\x39\xf9\x2d\x40\xea\xa0\x66\x6d\x4a\x04\xbf\x66\x9e\xbc\xde\x4b\xa5\x20\x43\xa8\x1c\xe6\x95\x1a\x12\x5a\x56\x79\xb8\x9f\xad\xbe\xdc\x7e\x5d\x41\x7a\xf3\x00\xf7\xe9\x62\x91\xde\xac\x1e\xae\x60\x2f\xfd\xda\x54\x1e\x70\x87\x35\x94\xdc\x96\x4a\xa2\x80\x3d\xb3\x96\x69\x7f\x04\x93\x13\xc2\xaf\xd3\xc5\xe4\x4b\x7a\xb3\x4a\x3f\xcc\xe6\xb3\xd5\x03\x18\x0b\x9f\x66\xab\x9b\xe9\x72\x09\x9f\x6e\x17\x90\xc2\x5d\xba\x58\xcd\x26\x5f\xe7\xe9\x02\xee\xbe\x2e\xee\x6e\x97\xd3\x04\x96\x48\x56\x21\xbd\xff\x71\xcc\xf3\x90\x3d\x8b\x20\xd0\x33\xa9\x5c\x1b\x89\x07\x53\x81\x5b\x9b\x4a\x09\x58\xb3\x1d\x82\x45\x8e\x72\x87\x02\x18\x70\x53\x1e\xdf\x9c\x54\xc2\x62\xca\xe8\x22\xf8\xfc\x6a\x41\xc2\x2c\x07\x6d\xfc\x10\x1c\x22\xfc\x7d\xed\x7d\x39\x1e\x8d\xf6\xfb\x7d\x52\xe8\x2a\x31\xb6\x18\xa9\x1a\xce\x8d\xfe\x91\xc4\x84\x59\x5a\x74\x9e\x79\x5c\x59\xc6\xd1\x82\xa9\x7c\x59\x79\x07\xae\xca\x73\xc9\x25\x6a\x0f\x52\xe7\xc6\x6e\x43\xa5\x80\x37\xc0\x2d\x32\x8f\xc0\x40\x19\xce\x14\xe0\x01\x79\x15\xee\xea\x48\x87\x72\xb5\x4c\x3b\xc6\xc3\x69\x6e\xcd\x96\x7c\xad\x9c\xa7\x7f\x9c\xc3\x6d\xa6\x50\x40\x81\x1a\x9d\x74\x90\x29\xc3\x37\x49\xfc\x2d\x8e\x9e\x18\x43\x75\x12\x3c\x6c\x84\x42\x6d\xec\xb1\x67\x11\xb2\x4a\x2a\x21\x75\x91\xc4\x51\x2b\x3d\x06\x5d\x29\x35\x8c\x03\x84\x32\x66\x53\x95\x29\xe7\xa6\x0a\xb6\xff\x81\xdc\xd7\x60\xae\x44\x2e\x73\x2a\x0e\xd6\xdd\x7a\x13\xae\x3a\xbd\x26\x23\xf9\x24\x8e\xce\x60\xc6\x90\x57\x3a\xb8\xd3\x67\x42\xd8\x21\x88\x6c\xf0\x2d\x8e\xa2\x1d\xb3\x84\x05\xd7\xe0\xcd\x17\x3c\x84\xcb\xc1\x55\x1c\x45\x32\x87\xbe\x5f\x4b\x97\xb4\xc0\xbf\x31\xce\x7f\x87\xeb\xeb\xeb\xd0\xd4\xb9\xd4\x28\x06\x40\x10\xd1\x4b\x62\xf5\x4d\x94\x31\xc5\x34\xc7\x31\xf4\x2e\x0f\x3d\xf8\x09\x44\x96\x14\xe8\x3f\xd4\xa7\xb5\xb2\xc4\x9b\xa5\xb7\x52\x17\xfd\xf7\xbf\x0c\x86\xe1\x95\x36\xe1\x0d\x34\xe2\x37\xa6\x13\xae\xef\xb9\x11\xe1\xba\xb1\xb9\x96\x9a\x18\xd1\x08\x35\x52\xce\x1b\xcb\x0a\x1c\xc3\xb7\x47\xfa\x7e\x24\xaf\x1e\xe3\xe8\xf1\x2c\xca\xcb\x5a\xe8\x95\x28\x37\x10\x80\xda\xdb\xae\xce\x0b\x49\x9d\xfa\x34\x01\x01\xef\x7b\x49\x58\xb6\xa6\x3c\x4b\xc2\x06\x8f\x3f\xce\x04\x5d\x48\x71\xe8\x2e\x36\x78\x1c\x5c\xc5\xaf\xa6\x28\x69\x8c\xfe\x4d\x8a\xc3\xcb\xf9\x22\xc0\x1d\x53\x1d\x60\x1d\xbf\x25\x21\x9c\xec\x1a\x04\xdd\x41\x07\xc9\xfe\xe5\x1a\x2e\x2e\x0f\x97\xff\xe7\xdf\x45\x63\xc1\x0b\x25\xf3\xcc\xec\x37\x98\xf6\x78\x9e\x4f\x8b\xae\x52\x9e\xda\x4e\xea\x9d\xd9\x10\x81\xae\x29\x4f\x4a\x85\xd4\x98\x92\xaa\xc6\xd5\x0c\x96\x21\x6a\x90\x1e\x2d\x23\x0a\x37\x3b\xb4\x34\xbd\xc0\xa2\xaf\xac\x76\x5d\x3a\x73\xa9\x99\x6a\x81\x9b\xec\x7b\xcb\x78\xdd\xbb\xf5\xf9\x93\x9c\x72\x7f\x08\xd9\x0c\x3e\x8e\x46\x90\x7a\x20\x3f\xa1\x34\x52\xfb\x21\xec\x11\x34\xa2\x20\x02\x12\x28\x2a\xee\x03\x5e\x6f\xc7\x54\x85\xbd\x9a\x64\x88\xaa\xc3\x53\x53\xd1\x44\x7a\x42\x42\xc3\x60\xe0\xd6\xec\xc2\xa8\xcd\x18\xdf\x40\xd3\xf8\xc6\xca\x42\xea\xb8\x89\xe9\x59\xd3\x93\x45\x09\x01\x07\xb3\x42\xcd\x50\xee\xe9\xe4\x43\xc8\x7f\x26\x8b\x99\xf6\xcf\x8a\xa8\x8e\x7c\xfb\x74\xf0\x7b\xd2\x34\x71\xe2\x88\x78\xfb\x3f\x0f\x86\xf0\xfe\x97\xae\x32\xbd\x21\x28\xf8\x31\x98\x37\xaf\x43\xc5\xcf\x2b\xe2\xe5\x67\x41\x0d\x31\xc9\x4f\x41\x6b\xe2\xaa\x8c\xd2\x51\xfb\x19\xe2\x78\xce\x26\x57\xdf\xc1\x3d\xf7\xad\xc5\x6d\x42\x93\x30\x21\x5e\x07\xad\x53\xf4\x11\xb9\xc5\x2d\x4d\x17\xca\x02\x67\x4a\xa1\xed\x39\x08\xdc\x35\x6c\xca\x29\xe4\x0b\xb7\xa5\x3f\xb6\x33\xc7\x33\x5b\xa0\x77\x3f\x36\x2c\xe0\xbc\x7b\xd7\x52\x71\x08\xc5\xb1\x44\xb8\xbe\x86\xde\x64\x31\x4d\x57\xd3\x5e\xd3\x4c\xa3\x11\xdc\x63\xd8\xc8\x32\x25\x33\xa1\x8e\x20\x50\xa1\xc7\xda\x2e\xa3\x43\x88\x3a\x6a\x1a\xd2\x6a\x45\x4b\x0f\x1e\xa4\xf3\x52\x17\x50\x33\xd6\x9e\xe6\x7b\x03\x17\x7a\x84\xb3\xca\x51\xb5\x3e\x1b\x86\xde\xd0\x66\x63\x91\xf8\x8d\xe6\x50\x68\x37\xa6\x64\xb7\x09\xe5\xd2\x3a\x0f\xa5\x62\x1c\x13\xc2\xeb\x8c\x79\x3d\xbf\x0d\x33\x93\xea\x45\x68\xc1\x00\x74\x1a\xb4\x4c\xd1\xa0\x26\xf5\x0e\xfa\x2d\xc6\x20\x8e\x22\xdb\x4a\x3f\xc1\xbe\x3a\x51\x82\xf3\x58\x3e\x25\x04\x5a\x70\x70\x87\x44\xe5\x81\x0d\xea\xa1\x4c\xba\xfe\xf9\x6b\xb3\x05\xa0\x4b\xe2\x88\xde\x3d\xe9\x6b\x65\x8a\xf3\xbe\x16\x75\x58\x78\x65\x2d\xe5\xbf\x1b\x05\x39\xf5\xf8\x1f\x95\xf3\x14\x53\x4b\xe1\x69\xd8\xe2\x25\xb2\x0e\xd4\x4c\x53\x7f\xf0\xe7\x21\x4a\xf3\x33\xcc\x2b\x52\xd7\x4c\xcb\x7a\xab\x2c\x8d\x47\xed\x25\x53\xea\x48\x79\xd8\x5b\x5a\xa7\x68\x81\x1a\x82\x93\x24\x15\x18\x27\x88\x4a\xcd\x55\x25\xea\x32\x08\x75\xdc\xe0\xb9\x60\xf3\xf9\x1e\xb6\x45\xe7\x58\x81\x09\x55\x52\x2e\x0f\xcd\x26\xab\xa1\x57\x93\x5c\x7f\xd0\x4b\x3a\x23\xcf\x29\x46\x99\x22\x69\x8b\x8c\xb8\x3a\x15\xc2\xa2\x73\xfd\x41\xc3\x39\x5d\x66\xef\xd7\xa8\x29\xf8\xa0\x71\x0f\xdd\x8a\xc4\x38\xa7\x95\x51\x0c\x81\x09\x41\xd4\xf6\x6c\x9d\x89\xa3\xc8\xed\xa5\xe7\x6b\x08\x9a\x4c\x79\xea\xc5\x41\x53\xff\x9c\x39\x84\x8b\xe9\xbf\x56\x93\xdb\x8f\xd3\xc9\xed\xdd\xc3\xc5\x18\xce\xce\x96\xb3\x7f\x4f\xbb\xb3\x0f\xe9\x3c\xbd\x99\x4c\x2f\xc6\xa7\x39\x74\xee\x90\x37\xad\x0b\xa4\xd0\x79\xc6\x37\x49\x89\xb8\xe9\x5f\x9e\xf3\xc0\xc9\xc1\x28\xca\x2c\xb2\xcd\xd5\xc9\x98\xba\x41\x1b\x1d\x2d\xe5\xc2\x35\xbc\x1a\xac\xab\xd7\xad\x99\x34\xf2\xfd\x96\xc8\x4f\x2b\x51\xa0\x8a\xef\xda\x91\xce\xe7\x9d\xe7\xf4\x41\xe1\xe8\x0e\x3e\x4e\xe7\xd3\xcf\xe9\x6a\x7a\x26\xb5\x5c\xa5\xab\xd9\xa4\x3e\xfa\xaf\x43\xf4\xfe\xcd\x21\xea\x2d\x97\xab\xdb\xc5\xb4\x37\x6e\xbe\xe6\xb7\xe9\xc7\xde\x9f\x14\x36\x7b\xd3\xf7\x8a\xcc\x9b\x7b\x63\xc5\xff\x92\xab\x27\xbb\x43\xce\x5e\x5a\x1d\x02\x09\x71\x5f\x3d\xfb\x89\x00\x4c\xb7\xfc\x91\xd7\x3f\x93\xa2\xf0\xfe\x45\xc6\x78\x8c\x1f\xe3\xff\x04\x00\x00\xff\xff\xb5\x44\x89\xaf\xbc\x0f\x00\x00") + +func prestate_tracerJsBytes() ([]byte, error) { + return bindataRead( + _prestate_tracerJs, + "prestate_tracer.js", + ) +} + +func prestate_tracerJs() (*asset, error) { + bytes, err := prestate_tracerJsBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "prestate_tracer.js", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 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){ + "4byte_tracer.js": _4byte_tracerJs, + "call_tracer.js": call_tracerJs, + "evmdis_tracer.js": evmdis_tracerJs, + "noop_tracer.js": noop_tracerJs, + "opcount_tracer.js": opcount_tracerJs, + "prestate_tracer.js": prestate_tracerJs, +} + +// 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{ + "4byte_tracer.js": {_4byte_tracerJs, map[string]*bintree{}}, + "call_tracer.js": {call_tracerJs, map[string]*bintree{}}, + "evmdis_tracer.js": {evmdis_tracerJs, map[string]*bintree{}}, + "noop_tracer.js": {noop_tracerJs, map[string]*bintree{}}, + "opcount_tracer.js": {opcount_tracerJs, map[string]*bintree{}}, + "prestate_tracer.js": {prestate_tracerJs, 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/eth/tracers/internal/tracers/call_tracer.js b/eth/tracers/internal/tracers/call_tracer.js new file mode 100644 index 0000000000..83495b1574 --- /dev/null +++ b/eth/tracers/internal/tracers/call_tracer.js @@ -0,0 +1,246 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// callTracer is a full blown transaction tracer that extracts and reports all +// the internal calls made by a transaction, along with any useful information. +{ + // callstack is the current recursive call stack of the EVM execution. + callstack: [{}], + + // descended tracks whether we've just descended from an outer transaction into + // an inner call. + descended: false, + + // step is invoked for every opcode that the VM executes. + step: function(log, db) { + // Capture any errors immediately + var error = log.getError(); + if (error !== undefined) { + this.fault(log, db); + return; + } + // We only care about system opcodes, faster if we pre-check once + var syscall = (log.op.toNumber() & 0xf0) == 0xf0; + if (syscall) { + var op = log.op.toString(); + } + // If a new contract is being created, add to the call stack + if (syscall && op == 'CREATE') { + var inOff = log.stack.peek(1).valueOf(); + var inEnd = inOff + log.stack.peek(2).valueOf(); + + // Assemble the internal call report and store for completion + var call = { + type: op, + from: toHex(log.contract.getAddress()), + input: toHex(log.memory.slice(inOff, inEnd)), + gasIn: log.getGas(), + gasCost: log.getCost(), + value: '0x' + log.stack.peek(0).toString(16) + }; + this.callstack.push(call); + this.descended = true + return; + } + // If a contract is being self destructed, gather that as a subcall too + if (syscall && op == 'SELFDESTRUCT') { + var left = this.callstack.length; + if (this.callstack[left-1].calls === undefined) { + this.callstack[left-1].calls = []; + } + this.callstack[left-1].calls.push({type: op}); + return + } + // If a new method invocation is being done, add to the call stack + if (syscall && (op == 'CALL' || op == 'CALLCODE' || op == 'DELEGATECALL' || op == 'STATICCALL')) { + // Skip any pre-compile invocations, those are just fancy opcodes + var to = toAddress(log.stack.peek(1).toString(16)); + if (isPrecompiled(to)) { + return + } + var off = (op == 'DELEGATECALL' || op == 'STATICCALL' ? 0 : 1); + + var inOff = log.stack.peek(2 + off).valueOf(); + var inEnd = inOff + log.stack.peek(3 + off).valueOf(); + + // Assemble the internal call report and store for completion + var call = { + type: op, + from: toHex(log.contract.getAddress()), + to: toHex(to), + input: toHex(log.memory.slice(inOff, inEnd)), + gasIn: log.getGas(), + gasCost: log.getCost(), + outOff: log.stack.peek(4 + off).valueOf(), + outLen: log.stack.peek(5 + off).valueOf() + }; + if (op != 'DELEGATECALL' && op != 'STATICCALL') { + call.value = '0x' + log.stack.peek(2).toString(16); + } + this.callstack.push(call); + this.descended = true + return; + } + // If we've just descended into an inner call, retrieve it's true allowance. We + // need to extract if from within the call as there may be funky gas dynamics + // with regard to requested and actually given gas (2300 stipend, 63/64 rule). + if (this.descended) { + if (log.getDepth() >= this.callstack.length) { + this.callstack[this.callstack.length - 1].gas = log.getGas(); + } else { + // TODO(karalabe): The call was made to a plain account. We currently don't + // have access to the true gas amount inside the call and so any amount will + // mostly be wrong since it depends on a lot of input args. Skip gas for now. + } + this.descended = false; + } + // If an existing call is returning, pop off the call stack + if (syscall && op == 'REVERT') { + this.callstack[this.callstack.length - 1].error = "execution reverted"; + return; + } + if (log.getDepth() == this.callstack.length - 1) { + // Pop off the last call and get the execution results + var call = this.callstack.pop(); + + if (call.type == 'CREATE') { + // If the call was a CREATE, retrieve the contract address and output code + call.gasUsed = '0x' + bigInt(call.gasIn - call.gasCost - log.getGas()).toString(16); + delete call.gasIn; delete call.gasCost; + + var ret = log.stack.peek(0); + if (!ret.equals(0)) { + call.to = toHex(toAddress(ret.toString(16))); + call.output = toHex(db.getCode(toAddress(ret.toString(16)))); + } else if (call.error === undefined) { + call.error = "internal failure"; // TODO(karalabe): surface these faults somehow + } + } else { + // If the call was a contract call, retrieve the gas usage and output + if (call.gas !== undefined) { + call.gasUsed = '0x' + bigInt(call.gasIn - call.gasCost + call.gas - log.getGas()).toString(16); + + var ret = log.stack.peek(0); + if (!ret.equals(0)) { + call.output = toHex(log.memory.slice(call.outOff, call.outOff + call.outLen)); + } else if (call.error === undefined) { + call.error = "internal failure"; // TODO(karalabe): surface these faults somehow + } + } + delete call.gasIn; delete call.gasCost; + delete call.outOff; delete call.outLen; + } + if (call.gas !== undefined) { + call.gas = '0x' + bigInt(call.gas).toString(16); + } + // Inject the call into the previous one + var left = this.callstack.length; + if (this.callstack[left-1].calls === undefined) { + this.callstack[left-1].calls = []; + } + this.callstack[left-1].calls.push(call); + } + }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) { + // If the topmost call already reverted, don't handle the additional fault again + if (this.callstack[this.callstack.length - 1].error !== undefined) { + return; + } + // Pop off the just failed call + var call = this.callstack.pop(); + call.error = log.getError(); + + // Consume all available gas and clean any leftovers + if (call.gas !== undefined) { + call.gas = '0x' + bigInt(call.gas).toString(16); + call.gasUsed = call.gas + } + delete call.gasIn; delete call.gasCost; + delete call.outOff; delete call.outLen; + + // Flatten the failed call into its parent + var left = this.callstack.length; + if (left > 0) { + if (this.callstack[left-1].calls === undefined) { + this.callstack[left-1].calls = []; + } + this.callstack[left-1].calls.push(call); + return; + } + // Last call failed too, leave it in the stack + this.callstack.push(call); + }, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function(ctx, db) { + var result = { + type: ctx.type, + from: toHex(ctx.from), + to: toHex(ctx.to), + value: '0x' + ctx.value.toString(16), + gas: '0x' + bigInt(ctx.gas).toString(16), + gasUsed: '0x' + bigInt(ctx.gasUsed).toString(16), + input: toHex(ctx.input), + output: toHex(ctx.output), + time: ctx.time, + }; + if (this.callstack[0].calls !== undefined) { + result.calls = this.callstack[0].calls; + } + if (this.callstack[0].error !== undefined) { + result.error = this.callstack[0].error; + } else if (ctx.error !== undefined) { + result.error = ctx.error; + } + if (result.error !== undefined) { + delete result.output; + } + return this.finalize(result); + }, + + // finalize recreates a call object using the final desired field oder for json + // serialization. This is a nicety feature to pass meaningfully ordered results + // to users who don't interpret it, just display it. + finalize: function(call) { + var sorted = { + type: call.type, + from: call.from, + to: call.to, + value: call.value, + gas: call.gas, + gasUsed: call.gasUsed, + input: call.input, + output: call.output, + error: call.error, + time: call.time, + calls: call.calls, + } + for (var key in sorted) { + if (sorted[key] === undefined) { + delete sorted[key]; + } + } + if (sorted.calls !== undefined) { + for (var i=0; i. + +// evmdisTracer returns sufficent information from a trace to perform evmdis-style +// disassembly. +{ + stack: [{ops: []}], + + npushes: {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 9: 1, 10: 1, 11: 1, 16: 1, 17: 1, 18: 1, 19: 1, 20: 1, 21: 1, 22: 1, 23: 1, 24: 1, 25: 1, 26: 1, 32: 1, 48: 1, 49: 1, 50: 1, 51: 1, 52: 1, 53: 1, 54: 1, 55: 0, 56: 1, 57: 0, 58: 1, 59: 1, 60: 0, 64: 1, 65: 1, 66: 1, 67: 1, 68: 1, 69: 1, 80: 0, 81: 1, 82: 0, 83: 0, 84: 1, 85: 0, 86: 0, 87: 0, 88: 1, 89: 1, 90: 1, 91: 0, 96: 1, 97: 1, 98: 1, 99: 1, 100: 1, 101: 1, 102: 1, 103: 1, 104: 1, 105: 1, 106: 1, 107: 1, 108: 1, 109: 1, 110: 1, 111: 1, 112: 1, 113: 1, 114: 1, 115: 1, 116: 1, 117: 1, 118: 1, 119: 1, 120: 1, 121: 1, 122: 1, 123: 1, 124: 1, 125: 1, 126: 1, 127: 1, 128: 2, 129: 3, 130: 4, 131: 5, 132: 6, 133: 7, 134: 8, 135: 9, 136: 10, 137: 11, 138: 12, 139: 13, 140: 14, 141: 15, 142: 16, 143: 17, 144: 2, 145: 3, 146: 4, 147: 5, 148: 6, 149: 7, 150: 8, 151: 9, 152: 10, 153: 11, 154: 12, 155: 13, 156: 14, 157: 15, 158: 16, 159: 17, 160: 0, 161: 0, 162: 0, 163: 0, 164: 0, 240: 1, 241: 1, 242: 1, 243: 0, 244: 0, 255: 0}, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function() { return this.stack[0].ops; }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) { }, + + // step is invoked for every opcode that the VM executes. + step: function(log, db) { + var frame = this.stack[this.stack.length - 1]; + + var error = log.getError(); + if (error) { + frame["error"] = error; + } else if (log.getDepth() == this.stack.length) { + opinfo = { + op: log.op.toNumber(), + depth : log.getDepth(), + result: [], + }; + if (frame.ops.length > 0) { + var prevop = frame.ops[frame.ops.length - 1]; + for(var i = 0; i < this.npushes[prevop.op]; i++) + prevop.result.push(log.stack.peek(i).toString(16)); + } + switch(log.op.toString()) { + case "CALL": case "CALLCODE": + var instart = log.stack.peek(3).valueOf(); + var insize = log.stack.peek(4).valueOf(); + opinfo["gas"] = log.stack.peek(0).valueOf(); + opinfo["to"] = log.stack.peek(1).toString(16); + opinfo["value"] = log.stack.peek(2).toString(); + opinfo["input"] = log.memory.slice(instart, instart + insize); + opinfo["error"] = null; + opinfo["return"] = null; + opinfo["ops"] = []; + this.stack.push(opinfo); + break; + case "DELEGATECALL": case "STATICCALL": + var instart = log.stack.peek(2).valueOf(); + var insize = log.stack.peek(3).valueOf(); + opinfo["op"] = log.op.toString(); + opinfo["gas"] = log.stack.peek(0).valueOf(); + opinfo["to"] = log.stack.peek(1).toString(16); + opinfo["input"] = log.memory.slice(instart, instart + insize); + opinfo["error"] = null; + opinfo["return"] = null; + opinfo["ops"] = []; + this.stack.push(opinfo); + break; + case "RETURN": + var out = log.stack.peek(0).valueOf(); + var outsize = log.stack.peek(1).valueOf(); + frame.return = log.memory.slice(out, out + outsize); + break; + case "STOP": case "SUICIDE": + frame.return = log.memory.slice(0, 0); + break; + case "JUMPDEST": + opinfo["pc"] = log.getPC(); + } + if(log.op.isPush()) { + opinfo["len"] = log.op.toNumber() - 0x5e; + } + frame.ops.push(opinfo); + } else { + this.stack = this.stack.slice(0, log.getDepth()); + } + } +} diff --git a/eth/tracers/internal/tracers/noop_tracer.js b/eth/tracers/internal/tracers/noop_tracer.js new file mode 100644 index 0000000000..f966ddc7d3 --- /dev/null +++ b/eth/tracers/internal/tracers/noop_tracer.js @@ -0,0 +1,29 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// noopTracer is just the barebone boilerplate code required from a JavaScript +// object to be usable as a transaction tracer. +{ + // step is invoked for every opcode that the VM executes. + step: function(log, db) { }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) { }, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function(ctx, db) { } +} diff --git a/eth/tracers/internal/tracers/opcount_tracer.js b/eth/tracers/internal/tracers/opcount_tracer.js new file mode 100644 index 0000000000..f7984c741a --- /dev/null +++ b/eth/tracers/internal/tracers/opcount_tracer.js @@ -0,0 +1,32 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// opcountTracer is a sample tracer that just counts the number of instructions +// executed by the EVM before the transaction terminated. +{ + // count tracks the number of EVM instructions executed. + count: 0, + + // step is invoked for every opcode that the VM executes. + step: function(log, db) { this.count++ }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) { }, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function(ctx, db) { return this.count } +} diff --git a/eth/tracers/internal/tracers/prestate_tracer.js b/eth/tracers/internal/tracers/prestate_tracer.js new file mode 100644 index 0000000000..99f71d2c33 --- /dev/null +++ b/eth/tracers/internal/tracers/prestate_tracer.js @@ -0,0 +1,103 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// prestateTracer outputs sufficient information to create a local execution of +// the transaction from a custom assembled genesis block. +{ + // prestate is the genesis that we're building. + prestate: null, + + // lookupAccount injects the specified account into the prestate object. + lookupAccount: function(addr, db){ + var acc = toHex(addr); + if (this.prestate[acc] === undefined) { + this.prestate[acc] = { + balance: '0x' + db.getBalance(addr).toString(16), + nonce: db.getNonce(addr), + code: toHex(db.getCode(addr)), + storage: {} + }; + } + }, + + // lookupStorage injects the specified storage entry of the given account into + // the prestate object. + lookupStorage: function(addr, key, db){ + var acc = toHex(addr); + var idx = toHex(key); + + if (this.prestate[acc].storage[idx] === undefined) { + var val = toHex(db.getState(addr, key)); + if (val != "0x0000000000000000000000000000000000000000000000000000000000000000") { + this.prestate[acc].storage[idx] = toHex(db.getState(addr, key)); + } + } + }, + + // result is invoked when all the opcodes have been iterated over and returns + // the final result of the tracing. + result: function(ctx, db) { + // At this point, we need to deduct the 'value' from the + // outer transaction, and move it back to the origin + this.lookupAccount(ctx.from, db); + + var fromBal = bigInt(this.prestate[toHex(ctx.from)].balance.slice(2), 16); + var toBal = bigInt(this.prestate[toHex(ctx.to)].balance.slice(2), 16); + + this.prestate[toHex(ctx.to)].balance = '0x'+toBal.subtract(ctx.value).toString(16); + this.prestate[toHex(ctx.from)].balance = '0x'+fromBal.add(ctx.value).toString(16); + + // Decrement the caller's nonce, and remove empty create targets + this.prestate[toHex(ctx.from)].nonce--; + if (ctx.type == 'CREATE') { + // We can blibdly delete the contract prestate, as any existing state would + // have caused the transaction to be rejected as invalid in the first place. + delete this.prestate[toHex(ctx.to)]; + } + // Return the assembled allocations (prestate) + return this.prestate; + }, + + // step is invoked for every opcode that the VM executes. + step: function(log, db) { + // Add the current account if we just started tracing + if (this.prestate === null){ + this.prestate = {}; + // Balance will potentially be wrong here, since this will include the value + // sent along with the message. We fix that in 'result()'. + this.lookupAccount(log.contract.getAddress(), db); + } + // Whenever new state is accessed, add it to the prestate + switch (log.op.toString()) { + case "EXTCODECOPY": case "EXTCODESIZE": case "BALANCE": + this.lookupAccount(toAddress(log.stack.peek(0).toString(16)), db); + break; + case "CREATE": + var from = log.contract.getAddress(); + this.lookupAccount(toContract(from, db.getNonce(from)), db); + break; + case "CALL": case "CALLCODE": case "DELEGATECALL": case "STATICCALL": + this.lookupAccount(toAddress(log.stack.peek(1).toString(16)), db); + break; + case 'SSTORE':case 'SLOAD': + this.lookupStorage(log.contract.getAddress(), toWord(log.stack.peek(0).toString(16)), db); + break; + } + }, + + // fault is invoked when the actual execution of an opcode fails. + fault: function(log, db) {} +} diff --git a/eth/tracers/internal/tracers/tracers.go b/eth/tracers/internal/tracers/tracers.go new file mode 100644 index 0000000000..dcf0d49dae --- /dev/null +++ b/eth/tracers/internal/tracers/tracers.go @@ -0,0 +1,21 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +//go:generate go-bindata -nometadata -o assets.go -pkg tracers -ignore ((tracers)|(assets)).go ./... +//go:generate gofmt -s -w assets.go + +// Package tracers contains the actual JavaScript tracer assets. +package tracers diff --git a/eth/tracers/testdata/call_tracer_create.json b/eth/tracers/testdata/call_tracer_create.json new file mode 100644 index 0000000000..8699bf3e7e --- /dev/null +++ b/eth/tracers/testdata/call_tracer_create.json @@ -0,0 +1,58 @@ +{ + "context": { + "difficulty": "3755480783", + "gasLimit": "5401723", + "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511", + "number": "2294702", + "timestamp": "1513676146" + }, + "genesis": { + "alloc": { + "0x13e4acefe6a6700604929946e70e6443e4e73447": { + "balance": "0xcf3e0938579f000", + "code": "0x", + "nonce": "9", + "storage": {} + }, + "0x7dc9c9730689ff0b0fd506c67db815f12d90a448": { + "balance": "0x0", + "code": "0x", + "nonce": "0", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3757315409", + "extraData": "0x566961425443", + "gasLimit": "5406414", + "hash": "0xae107f592eebdd9ff8d6ba00363676096e6afb0e1007a7d3d0af88173077378d", + "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511", + "mixHash": "0xc927aa05a38bc3de864e95c33b3ae559d3f39c4ccd51cef6f113f9c50ba0caf1", + "nonce": "0x93363bbd2c95f410", + "number": "2294701", + "stateRoot": "0x6b6737d5bde8058990483e915866bd1578014baeff57bd5e4ed228a2bfad635c", + "timestamp": "1513676127", + "totalDifficulty": "7160808139332585" + }, + "input": "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", + "result": { + "from": "0x13e4acefe6a6700604929946e70e6443e4e73447", + "gas": "0x5e106", + "gasUsed": "0x5e106", + "input": "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", + "output": "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", + "to": "0x7dc9c9730689ff0b0fd506c67db815f12d90a448", + "type": "CREATE", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_deep_calls.json b/eth/tracers/testdata/call_tracer_deep_calls.json new file mode 100644 index 0000000000..0353d4cfa9 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_deep_calls.json @@ -0,0 +1,415 @@ +{ + "context": { + "difficulty": "117066904", + "gasLimit": "4712384", + "miner": "0x1977c248e1014cc103929dd7f154199c916e39ec", + "number": "25001", + "timestamp": "1479891545" + }, + "genesis": { + "alloc": { + "0x2a98c5f40bfa3dee83431103c535f6fae9a8ad38": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396" + } + }, + "0x2cccf5e0538493c235d1c5ef6580f77d99e91396": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0684ac65a9fa32414dda56996f4183597d695987fdb82b145d722743891a6fe8": "0x0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "0x1cd76f78169a420d99346e3501dd3e541622c38a226f9b63e01cfebc69879dc7": "0x000000000000000000000000b4fe7aa695b326c9d219158d2ca50db77b39f99f", + "0x8e54a4494fe5da016bfc01363f4f6cdc91013bb5434bd2a4a3359f13a23afa2f": "0x000000000000000000000000cf00ffd997ad14939736f026006498e3f099baaf", + "0x94edf7f600ba56655fd65fca1f1424334ce369326c1dc3e53151dcd1ad06bc13": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xbbee47108b275f55f98482c6800f6372165e88b0330d3f5dae6419df4734366c": "0x0000000000000000000000002a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "0xd38c0c4e84de118cfdcc775130155d83b8bbaaf23dc7f3c83a626b10473213bd": "0x0000000000000000000000000000000000000000000000000000000000000001", + "0xfb3aa5c655c2ec9d40609401f88d505d1da61afaa550e36ef5da0509ada257ba": "0x0000000000000000000000007986bad81f4cbd9317f5a46861437dae58d69113" + } + }, + "0x3e9286eafa2db8101246c2131c09b49080d00690": { + "balance": "0x0", + "code": "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", + "nonce": "16", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396" + } + }, + "0x70c9217d814985faef62b124420f8dfbddd96433": { + "balance": "0x4ef436dcbda6cd4a", + "code": "0x", + "nonce": "1634", + "storage": {} + }, + "0x7986bad81f4cbd9317f5a46861437dae58d69113": { + "balance": "0x0", + "code": "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", + "nonce": "7", + "storage": { + "0xffc4df2d4f3d2cffad590bed6296406ab7926ca9e74784f74a95191fa069a174": "0x00000000000000000000000070c9217d814985faef62b124420f8dfbddd96433" + } + }, + "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396" + } + }, + "0xc212e03b9e060e36facad5fd8f4435412ca22e6b": { + "balance": "0x0", + "code": "0x606060405236156101745760e060020a600035046302d05d3f811461017c57806304a7fdbc1461018e5780630e90f957146101fb5780630fb5a6b41461021257806314baa1b61461021b57806317fc45e21461023a5780632b096926146102435780632e94420f1461025b578063325a19f11461026457806336da44681461026d5780633f81a2c01461027f5780633fc306821461029757806345ecd3d7146102d45780634665096d146102dd5780634e71d92d146102e657806351a34eb8146103085780636111bb951461032d5780636f265b93146103445780637e9014e11461034d57806390ba009114610360578063927df5e014610393578063a7f437791461046c578063ad8f50081461046e578063bc6d909414610477578063bdec3ad114610557578063c19d93fb1461059a578063c9503fe2146105ad578063e0a73a93146105b6578063ea71b02d146105bf578063ea8a1af0146105d1578063ee4a96f9146105f3578063f1ff78a01461065c575b61046c610002565b610665600054600160a060020a031681565b6040805160c081810190925261046c9160049160c4918390600690839083908082843760408051808301909152929750909561018495509193509091908390839080828437509095505050505050600554600090600160a060020a0390811633909116146106a857610002565b61068260015460a060020a900460ff166000145b90565b61069660085481565b61046c600435600154600160a060020a03166000141561072157610002565b610696600d5481565b610696600435600f8160068110156100025750015481565b61069660045481565b61069660035481565b610665600554600160a060020a031681565b61069660043560158160068110156100025750015481565b6106966004355b600b54600f5460009160028202808203928083039290810191018386101561078357601054840186900394505b50505050919050565b61069660025481565b61069660095481565b61046c600554600090600160a060020a03908116339091161461085857610002565b61046c600435600554600090600160a060020a03908116339091161461092e57610002565b6106826001805460a060020a900460ff161461020f565b610696600b5481565b61068260075460a060020a900460ff1681565b6106966004355b600b54601554600091600282028082039280830392908101910183861015610a6c5760165494506102cb565b61046c6004356024356044356040805160015460e360020a631c2d8fb302825260b260020a691858d8dbdd5b9d18dd1b02600483015291516000928392600160a060020a03919091169163e16c7d9891602481810192602092909190829003018187876161da5a03f1156100025750505060405180519060200150905080600160a060020a031663c4b0c96a336040518260e060020a0281526004018082600160a060020a031681526020019150506020604051808303816000876161da5a03f1156100025750506040515115159050610b4657610002565b005b610696600a5481565b61046c60006000600060006000600160009054906101000a9004600160a060020a0316600160a060020a031663e16c7d986040518160e060020a028152600401808060b260020a691858d8dbdd5b9d18dd1b0281526020015060200190506020604051808303816000876161da5a03f1156100025750505060405180519060200150905080600160a060020a031663c4b0c96a336040518260e060020a0281526004018082600160a060020a031681526020019150506020604051808303816000876161da5a03f1156100025750506040515115159050610f1757610002565b61046c5b60015b60058160ff16101561071e57600f6001820160ff166006811015610002578101549060ff83166006811015610002570154101561129057610002565b61069660015460a060020a900460ff1681565b61069660065481565b610696600c5481565b610665600754600160a060020a031681565b61046c600554600090600160a060020a0390811633909116146112c857610002565b6040805160c081810190925261046c9160049160c4918390600690839083908082843760408051808301909152929750909561018495509193509091908390839080828437509095505050505050600154600090600160a060020a03168114156113fb57610002565b610696600e5481565b60408051600160a060020a03929092168252519081900360200190f35b604080519115158252519081900360200190f35b60408051918252519081900360200190f35b5060005b60068160ff16101561070857828160ff166006811015610002576020020151600f60ff831660068110156100025701558160ff82166006811015610002576020020151601560ff831660068110156100025701556001016106ac565b61071061055b565b505050565b600e8054820190555b50565b6040805160015460e060020a6313bc6d4b02825233600160a060020a03908116600484015292519216916313bc6d4b9160248181019260209290919082900301816000876161da5a03f115610002575050604051511515905061071557610002565b83861015801561079257508286105b156107b457600f546010546011548689039082030291909104900394506102cb565b8286101580156107c55750600b5486105b156107e757600f546011546012548589039082030291909104900394506102cb565b600b5486108015906107f857508186105b1561081d57600b54600f546012546013549289039281039290920204900394506102cb565b81861015801561082c57508086105b1561084e57600f546013546014548489039082030291909104900394506102cb565b60145494506102cb565b60015460a060020a900460ff1660001461087157610002565b600254600a01431161088257610002565b6040805160015460e360020a631c2d8fb302825260a860020a6a636f6e74726163746170690260048301529151600160a060020a03929092169163e16c7d989160248181019260209290919082900301816000876161da5a03f1156100025750505060405180519060200150905080600160a060020a031663771d50e16040518160e060020a0281526004018090506000604051808303816000876161da5a03f1156100025750505050565b60015460a060020a900460ff1660001461094757610002565b600254600a01431161095857610002565b6040805160015460e360020a631c2d8fb302825260a860020a6a636f6e74726163746170690260048301529151600160a060020a03929092169163e16c7d989160248181019260209290919082900301816000876161da5a03f1156100025750506040805180517f51a34eb8000000000000000000000000000000000000000000000000000000008252600482018690529151919350600160a060020a03841692506351a34eb8916024808301926000929190829003018183876161da5a03f11561000257505050600b8290554360025560408051838152905130600160a060020a0316917fa609f6bd4ad0b4f419ddad4ac9f0d02c2b9295c5e6891469055cf73c2b568fff919081900360200190a25050565b838610158015610a7b57508286105b15610a9d576015546016546017548689039082900302919091040194506102cb565b828610158015610aae5750600b5486105b15610ad0576015546017546018548589039082900302919091040194506102cb565b600b548610801590610ae157508186105b15610b0657600b546015546018546019549289039281900392909202040194506102cb565b818610158015610b1557508086105b15610b3757601554601954601a548489039082900302919091040194506102cb565b601a54860181900394506102cb565b60015460a060020a900460ff16600014610b5f57610002565b6001805460a060020a60ff02191660a060020a17908190556040805160e360020a631c2d8fb302815260a860020a6a636f6e74726163746170690260048201529051600160a060020a03929092169163e16c7d989160248181019260209290919082900301816000876161da5a03f1156100025750506040805180516004805460e260020a633e4baddd028452908301529151919450600160a060020a038516925063f92eb77491602482810192602092919082900301816000876161da5a03f115610002575050604080518051600a556005547ffebf661200000000000000000000000000000000000000000000000000000000825233600160a060020a03908116600484015216602482015260448101879052905163febf661291606480820192600092909190829003018183876161da5a03f115610002575050508215610cc7576007805473ffffffffffffffffffffffffffffffffffffffff191633179055610dbb565b6040805160055460065460e060020a63599efa6b028352600160a060020a039182166004840152602483015291519184169163599efa6b91604481810192600092909190829003018183876161da5a03f115610002575050604080516006547f56ccb6f000000000000000000000000000000000000000000000000000000000825233600160a060020a03166004830152602482015290516356ccb6f091604480820192600092909190829003018183876161da5a03f115610002575050600580546007805473ffffffffffffffffffffffffffffffffffffffff19908116600160a060020a038416179091551633179055505b6007805460a060020a60ff02191660a060020a87810291909117918290556008544301600955900460ff1615610df757600a54610e039061029e565b600a54610e0b90610367565b600c55610e0f565b600c555b600c54670de0b6b3a7640000850204600d55600754600554604080517f759297bb000000000000000000000000000000000000000000000000000000008152600160a060020a039384166004820152918316602483015260448201879052519184169163759297bb91606481810192600092909190829003018183876161da5a03f11561000257505060408051600754600a54600d54600554600c5460a060020a850460ff161515865260208601929092528486019290925260608401529251600160a060020a0391821694509281169230909116917f3b3d1986083d191be01d28623dc19604728e29ae28bdb9ba52757fdee1a18de2919081900360800190a45050505050565b600954431015610f2657610002565b6001805460a060020a900460ff1614610f3e57610002565b6001805460a060020a60ff0219167402000000000000000000000000000000000000000017908190556040805160e360020a631c2d8fb302815260a860020a6a636f6e74726163746170690260048201529051600160a060020a03929092169163e16c7d989160248181019260209290919082900301816000876161da5a03f1156100025750506040805180516004805460e260020a633e4baddd028452908301529151919750600160a060020a038816925063f92eb77491602482810192602092919082900301816000876161da5a03f115610002575050604051516007549095506000945060a060020a900460ff1615905061105c57600a5484111561105757600a54600d54670de0b6b3a7640000918603020492505b61107e565b600a5484101561107e57600a54600d54670de0b6b3a764000091869003020492505b60065483111561108e5760065492505b6006548390039150600083111561111857604080516005546007547f5928d37f000000000000000000000000000000000000000000000000000000008352600160a060020a0391821660048401528116602483015260448201869052915191871691635928d37f91606481810192600092909190829003018183876161da5a03f115610002575050505b600082111561117a576040805160055460e060020a63599efa6b028252600160a060020a0390811660048301526024820185905291519187169163599efa6b91604481810192600092909190829003018183876161da5a03f115610002575050505b6040805185815260208101849052808201859052905130600160a060020a0316917f89e690b1d5aaae14f3e85f108dc92d9ab3763a58d45aed8b59daedbbae8fe794919081900360600190a260008311156112285784600160a060020a0316634cc927d785336040518360e060020a0281526004018083815260200182600160a060020a03168152602001925050506000604051808303816000876161da5a03f11561000257505050611282565b84600160a060020a0316634cc927d7600a60005054336040518360e060020a0281526004018083815260200182600160a060020a03168152602001925050506000604051808303816000876161da5a03f115610002575050505b600054600160a060020a0316ff5b60156001820160ff166006811015610002578101549060ff8316600681101561000257015411156112c057610002565b60010161055e565b60015460a060020a900460ff166000146112e157610002565b600254600a0143116112f257610002565b6001546040805160e360020a631c2d8fb302815260a860020a6a636f6e74726163746170690260048201529051600160a060020a03929092169163e16c7d989160248181019260209290919082900301816000876161da5a03f11561000257505060408051805160055460065460e060020a63599efa6b028452600160a060020a03918216600485015260248401529251909450918416925063599efa6b916044808301926000929190829003018183876161da5a03f1156100025750505080600160a060020a0316632b68bb2d6040518160e060020a0281526004018090506000604051808303816000876161da5a03f115610002575050600054600160a060020a03169050ff5b6001546040805160e060020a6313bc6d4b02815233600160a060020a039081166004830152915191909216916313bc6d4b91602480830192602092919082900301816000876161da5a03f11561000257505060405151151590506106a85761000256", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396", + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000000000000000000000000000000000000000006195", + "0x0000000000000000000000000000000000000000000000000000000000000004": "0x5842545553440000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000005": "0x00000000000000000000000070c9217d814985faef62b124420f8dfbddd96433", + "0x0000000000000000000000000000000000000000000000000000000000000006": "0x0000000000000000000000000000000000000000000000008ac7230489e80000", + "0x000000000000000000000000000000000000000000000000000000000000000b": "0x0000000000000000000000000000000000000000000000283c7b9181eca20000" + } + }, + "0xcf00ffd997ad14939736f026006498e3f099baaf": { + "balance": "0x0", + "code": "0x606060405236156100cf5760e060020a600035046302d05d3f81146100d7578063031e7f5d146100e95780631ab9075a1461010b5780632243118a1461014657806327aad68a1461016557806338a699a4146101da5780635188f996146101f8578063581d5d601461021e57806381738c5914610246578063977da54014610269578063a07421ce14610288578063a7f43779146102be578063bdbdb086146102dc578063e1c7111914610303578063f4f2821b14610325578063f905c15a1461034a578063f92eb77414610353575b610387610002565b610389600054600160a060020a031681565b610387600435602435600254600160a060020a0316600014156103a857610002565b610387600435600254600160a060020a031660001480159061013c575060025433600160a060020a03908116911614155b1561042957610002565b610387600435600254600160a060020a03166000141561044b57610002565b6102ac60043560008181526004602081815260408320547f524d81d3000000000000000000000000000000000000000000000000000000006060908152610100909104600160a060020a031692839263524d81d3926064928188876161da5a03f1156100025750506040515192506103819050565b61039c60043560008181526004602052604090205460ff165b919050565b6103876004356024356002546000908190600160a060020a031681141561079457610002565b61038760043560243560025460009081908190600160a060020a031681141561080457610002565b61038960043560008181526004602052604081205460ff1615156109e357610002565b610387600435600254600160a060020a0316600014156109fb57610002565b600435600090815260096020526040902054670de0b6b3a764000090810360243502045b60408051918252519081900360200190f35b61038760025433600160a060020a03908116911614610a9257610002565b600435600090815260086020526040902054670de0b6b3a7640000602435909102046102ac565b610387600435602435600254600160a060020a031660001415610aa057610002565b61038760043560025460009081908190600160a060020a0316811415610b3657610002565b6102ac60035481565b6102ac600435600081815260076020908152604080832054600690925290912054670de0b6b3a76400000204805b50919050565b005b600160a060020a03166060908152602090f35b15156060908152602090f35b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b906084906020906024816000876161da5a03f11561000257505060405151151590506103fe57610002565b60008281526004602052604090205460ff16151561041b57610002565b600860205260406000205550565b6002805473ffffffffffffffffffffffffffffffffffffffff19168217905550565b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b906084906020906024816000876161da5a03f11561000257505060405151151590506104a157610002565b604080516000838152600460205291909120805460ff1916600117905561040280610de2833901809050604051809103906000f0600460005060008360001916815260200190815260200160002060005060000160016101000a815481600160a060020a030219169083021790555066470de4df8200006008600050600083600019168152602001908152602001600020600050819055506703782dace9d9000060096000506000836000191681526020019081526020016000206000508190555050565b600460005060008560001916815260200190815260200160002060005060000160019054906101000a9004600160a060020a0316915081600160a060020a031663524d81d36040518160e060020a0281526004018090506020604051808303816000876161da5a03f11561000257505060405151821415905061060057838152600660209081526040808320839055600790915281208190555b81600160a060020a0316630a3b0a4f846040518260e060020a0281526004018082600160a060020a031681526020019150506000604051808303816000876161da5a03f11561000257505050600160a060020a038316808252600560209081526040808420879055805160e160020a6364a81ff102815290518694670de0b6b3a7640000949363c9503fe29360048181019492939183900301908290876161da5a03f11561000257505060408051805160e060020a636f265b930282529151919291636f265b939160048181019260209290919082900301816000876161da5a03f11561000257505050604051805190602001500204600660005060008660001916815260200190815260200160002060008282825054019250508190555080600160a060020a031663c9503fe26040518160e060020a0281526004018090506020604051808303816000876161da5a03f115610002575050506040518051906020015060076000506000866000191681526020019081526020016000206000828282505401925050819055505b50505050565b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b9060849060209060248187876161da5a03f11561000257505060405151151590506107e957610002565b8381526004602052604081205460ff16151561056657610002565b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b9060849060209060248187876161da5a03f115610002575050604051511515905061085957610002565b849250670de0b6b3a764000083600160a060020a031663c9503fe26040518160e060020a0281526004018090506020604051808303816000876161da5a03f115610002575060408051805160e160020a6364a81ff102825291519189028590049650600481810192602092909190829003018188876161da5a03f11561000257505060408051805160e060020a636f265b930282529151919291636f265b9391600481810192602092909190829003018189876161da5a03f115610002575050506040518051906020015002049050806006600050600085600160a060020a0316632e94420f6040518160e060020a0281526004018090506020604051808303816000876161da5a03f1156100025750604080518051855260208681528286208054989098039097557f2e94420f00000000000000000000000000000000000000000000000000000000815290518896600483810193919291829003018187876161da5a03f115610002575050604080515183526020939093525020805490910190555050505050565b60409020546101009004600160a060020a03166101f3565b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b906084906020906024816000876161da5a03f1156100025750506040515115159050610a5157610002565b60008181526004602052604090205460ff161515610a6e57610002565b6040600020805474ffffffffffffffffffffffffffffffffffffffffff1916905550565b600254600160a060020a0316ff5b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b906084906020906024816000876161da5a03f1156100025750506040515115159050610af657610002565b60008281526004602052604090205460ff161515610b1357610002565b670de0b6b3a7640000811115610b2857610002565b600960205260406000205550565b60025460e060020a6313bc6d4b02606090815233600160a060020a03908116606452909116906313bc6d4b9060849060209060248187876161da5a03f1156100025750506040515115159050610b8b57610002565b600160a060020a038416815260056020908152604080832054808452600490925282205490935060ff161515610bc057610002565b600460005060008460001916815260200190815260200160002060005060000160019054906101000a9004600160a060020a0316915081600160a060020a031663b9caebf4856040518260e060020a0281526004018082600160a060020a031681526020019150506000604051808303816000876161da5a03f115610002575050506005600050600085600160a060020a0316815260200190815260200160002060005060009055839050600082600160a060020a031663524d81d36040518160e060020a0281526004018090506020604051808303816000876161da5a03f115610002575050604051519190911115905061078e57670de0b6b3a764000081600160a060020a031663c9503fe26040518160e060020a0281526004018090506020604051808303816000876161da5a03f11561000257505060408051805160e060020a636f265b930282529151919291636f265b939160048181019260209290919082900301816000876161da5a03f11561000257505050604051805190602001500204600660005060008560001916815260200190815260200160002060008282825054039250508190555080600160a060020a031663c9503fe26040518160e060020a0281526004018090506020604051808303816000876161da5a03f115610002575050506040518051906020015060076000506000856000191681526020019081526020016000206000828282505403925050819055505050505056606060405260008054600160a060020a031916331790556103de806100246000396000f3606060405236156100615760e060020a600035046302d05d3f81146100695780630a3b0a4f1461007b5780630d327fa7146100f6578063524d81d314610109578063a7f4377914610114578063b9caebf414610132578063bbec3bae14610296575b6102ce610002565b6102d0600054600160a060020a031681565b6102ce600435600254600090600160a060020a03168114156102ed5760028054600160a060020a03199081168417808355600160a060020a03808616855260036020526040852060018101805493831694909316939093179091559154815461010060a860020a031916921661010002919091179055610372565b6102d0600254600160a060020a03165b90565b6102e3600154610106565b6102ce60005433600160a060020a039081169116146103c657610002565b6102ce600435600160a060020a038116600090815260036020526040812054819060ff16801561016457506001548190115b1561029157506040808220600180820154915461010090819004600160a060020a039081168087528587209093018054600160a060020a031916948216948517905583865293909420805461010060a860020a03191694820294909417909355600254909190811690841614156101e85760028054600160a060020a031916821790555b600254600160a060020a0390811690841614156102105760028054600160a060020a03191690555b6003600050600084600160a060020a0316815260200190815260200160002060006000820160006101000a81549060ff02191690556000820160016101000a815490600160a060020a0302191690556001820160006101000a815490600160a060020a03021916905550506001600081815054809291906001900391905055505b505050565b600160a060020a036004358181166000908152600360205260408120600101546002546102d09491821691168114156103d4576103d8565b005b600160a060020a03166060908152602090f35b6060908152602090f35b60028054600160a060020a03908116835260036020526040808420805461010060a860020a0319808216610100808a029190911790935590829004841680875283872060019081018054600160a060020a03199081168b179091559654868a168952949097209687018054949095169390951692909217909255835416908202179091555b60016003600050600084600160a060020a0316815260200190815260200160002060005060000160006101000a81548160ff0219169083021790555060016000818150548092919060010191905055505050565b600054600160a060020a0316ff5b8091505b5091905056", + "nonce": "3", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396", + "0x3571d73f14f31a1463bd0a2f92f7fde1653d4e1ead7aedf4b0a5df02f16092ab": "0x0000000000000000000000000000000000000000000007d634e4c55188be0000", + "0x4e64fe2d1b72d95a0a31945cc6e4f4e524ac5ad56d6bd44a85ec7bc9cc0462c0": "0x000000000000000000000000000000000000000000000002b5e3af16b1880000" + } + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "117124093", + "extraData": "0xd5830105008650617269747986312e31322e31826d61", + "gasLimit": "4707788", + "hash": "0xad325e4c49145fb7a4058a68ac741cc8607a71114e23fc88083c7e881dd653e7", + "miner": "0x00714b9ac97fd6bd9325a059a70c9b9fa94ce050", + "mixHash": "0x0af918f65cb4af04b608fc1f14a849707696986a0e7049e97ef3981808bcc65f", + "nonce": "0x38dee147326a8d40", + "number": "25000", + "stateRoot": "0xc5d6bbcd46236fcdcc80b332ffaaa5476b980b01608f9708408cfef01b58bd5b", + "timestamp": "1479891517", + "totalDifficulty": "1895410389427" + }, + "input": "0xf88b8206628504a817c8008303d09094c212e03b9e060e36facad5fd8f4435412ca22e6b80a451a34eb80000000000000000000000000000000000000000000000280faf689c35ac00002aa0a7ee5b7877811bf671d121b40569462e722657044808dc1d6c4f1e4233ec145ba0417e7543d52b65738d9df419cbe40a708424f4d54b0fc145c0a64545a2bb1065", + "result": { + "calls": [ + { + "from": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "gas": "0x31217", + "gasUsed": "0x334", + "input": "0xe16c7d98636f6e7472616374617069000000000000000000000000000000000000000000", + "output": "0x000000000000000000000000b4fe7aa695b326c9d219158d2ca50db77b39f99f", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f", + "gas": "0x2a68d", + "gasUsed": "0x334", + "input": "0xe16c7d98636f6e747261637463746c000000000000000000000000000000000000000000", + "output": "0x0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x23ac9", + "gasUsed": "0x334", + "input": "0xe16c7d98636f6e7472616374646200000000000000000000000000000000000000000000", + "output": "0x0000000000000000000000007986bad81f4cbd9317f5a46861437dae58d69113", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x23366", + "gasUsed": "0x273", + "input": "0x16c66cc6000000000000000000000000c212e03b9e060e36facad5fd8f4435412ca22e6b", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x7986bad81f4cbd9317f5a46861437dae58d69113", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f", + "gas": "0x29f35", + "gasUsed": "0xf8d", + "input": "0x16c66cc6000000000000000000000000c212e03b9e060e36facad5fd8f4435412ca22e6b", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f", + "gas": "0x28a9e", + "gasUsed": "0x334", + "input": "0xe16c7d98636f6e747261637463746c000000000000000000000000000000000000000000", + "output": "0x0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x21d79", + "gasUsed": "0x24d", + "input": "0x13bc6d4b000000000000000000000000b4fe7aa695b326c9d219158d2ca50db77b39f99f", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x2165b", + "gasUsed": "0x334", + "input": "0xe16c7d986d61726b65746462000000000000000000000000000000000000000000000000", + "output": "0x000000000000000000000000cf00ffd997ad14939736f026006498e3f099baaf", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x1a8e8", + "gasUsed": "0x24d", + "input": "0x13bc6d4b0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x1a2c6", + "gasUsed": "0x3cb", + "input": "0xc9503fe2", + "output": "0x0000000000000000000000000000000000000000000000008ac7230489e80000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x19b72", + "gasUsed": "0x3cb", + "input": "0xc9503fe2", + "output": "0x0000000000000000000000000000000000000000000000008ac7230489e80000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x19428", + "gasUsed": "0x305", + "input": "0x6f265b93", + "output": "0x0000000000000000000000000000000000000000000000283c7b9181eca20000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x18d45", + "gasUsed": "0x229", + "input": "0x2e94420f", + "output": "0x5842545553440000000000000000000000000000000000000000000000000000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "gas": "0x1734e", + "gasUsed": "0x229", + "input": "0x2e94420f", + "output": "0x5842545553440000000000000000000000000000000000000000000000000000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x20ee1", + "gasUsed": "0x5374", + "input": "0x581d5d60000000000000000000000000c212e03b9e060e36facad5fd8f4435412ca22e6b0000000000000000000000000000000000000000000000280faf689c35ac0000", + "output": "0x", + "to": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x1b6c1", + "gasUsed": "0x334", + "input": "0xe16c7d986c6f676d67720000000000000000000000000000000000000000000000000000", + "output": "0x0000000000000000000000002a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x1af69", + "gasUsed": "0x229", + "input": "0x2e94420f", + "output": "0x5842545553440000000000000000000000000000000000000000000000000000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0x2a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "gas": "0x143a5", + "gasUsed": "0x24d", + "input": "0x13bc6d4b0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x1a91d", + "gasUsed": "0x12fa", + "input": "0x0accce0600000000000000000000000000000000000000000000000000000000000000025842545553440000000000000000000000000000000000000000000000000000000000000000000000000000c212e03b9e060e36facad5fd8f4435412ca22e6b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "output": "0x", + "to": "0x2a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x19177", + "gasUsed": "0x334", + "input": "0xe16c7d986c6f676d67720000000000000000000000000000000000000000000000000000", + "output": "0x0000000000000000000000002a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x18a22", + "gasUsed": "0x229", + "input": "0x2e94420f", + "output": "0x5842545553440000000000000000000000000000000000000000000000000000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x18341", + "gasUsed": "0x334", + "input": "0xe16c7d986d61726b65746462000000000000000000000000000000000000000000000000", + "output": "0x000000000000000000000000cf00ffd997ad14939736f026006498e3f099baaf", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x17bec", + "gasUsed": "0x229", + "input": "0x2e94420f", + "output": "0x5842545553440000000000000000000000000000000000000000000000000000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + }, + { + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x1764e", + "gasUsed": "0x45c", + "input": "0xf92eb7745842545553440000000000000000000000000000000000000000000000000000", + "output": "0x00000000000000000000000000000000000000000000002816d180e30c390000", + "to": "0xcf00ffd997ad14939736f026006498e3f099baaf", + "type": "CALL", + "value": "0x0" + }, + { + "calls": [ + { + "from": "0x2a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "gas": "0x108ba", + "gasUsed": "0x24d", + "input": "0x13bc6d4b0000000000000000000000003e9286eafa2db8101246c2131c09b49080d00690", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x2cccf5e0538493c235d1c5ef6580f77d99e91396", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "gas": "0x16e62", + "gasUsed": "0xebb", + "input": "0x645a3b72584254555344000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002816d180e30c390000", + "output": "0x", + "to": "0x2a98c5f40bfa3dee83431103c535f6fae9a8ad38", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f", + "gas": "0x283b9", + "gasUsed": "0xc51c", + "input": "0x949ae479000000000000000000000000c212e03b9e060e36facad5fd8f4435412ca22e6b0000000000000000000000000000000000000000000000280faf689c35ac0000", + "output": "0x", + "to": "0x3e9286eafa2db8101246c2131c09b49080d00690", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "gas": "0x30b4a", + "gasUsed": "0xedb7", + "input": "0x51a34eb80000000000000000000000000000000000000000000000280faf689c35ac0000", + "output": "0x", + "to": "0xb4fe7aa695b326c9d219158d2ca50db77b39f99f", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0x70c9217d814985faef62b124420f8dfbddd96433", + "gas": "0x37b38", + "gasUsed": "0x12bb3", + "input": "0x51a34eb80000000000000000000000000000000000000000000000280faf689c35ac0000", + "output": "0x", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_delegatecall.json b/eth/tracers/testdata/call_tracer_delegatecall.json new file mode 100644 index 0000000000..f7ad6df5f5 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_delegatecall.json @@ -0,0 +1,97 @@ +{ + "context": { + "difficulty": "31927752", + "gasLimit": "4707788", + "miner": "0x5659922ce141eedbc2733678f9806c77b4eebee8", + "number": "11495", + "timestamp": "1479735917" + }, + "genesis": { + "alloc": { + "0x13204f5d64c28326fd7bd05fd4ea855302d7f2ff": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x4d140b25abf3c71052885c66f73ce07cff141c1afabffdaf5cba04d625b7ebcc": "0x0000000000000000000000000000000000000000000000000000000000000001" + } + }, + "0x269296dddce321a6bcbaa2f0181127593d732cba": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x000113204f5d64c28326fd7bd05fd4ea855302d7f2ff00000000000000000000" + } + }, + "0x42b02b5deeb78f34cd5ac896473b63e6c99a71a2": { + "balance": "0x0", + "code": "0x6504032353da7150606060405236156100695760e060020a60003504631bf7509d811461006e57806321ce24d41461008157806333556e84146100ec578063685a1f3c146101035780637d65837a1461011757806389489a8714610140578063f775b6b5146101fc575b610007565b61023460043560006100fd82600061010d565b610246600435602435600160a060020a03811660009081526020839052604081205415156102cb57826001016000508054806001018281815481835581811511610278576000838152602090206102789181019083015b808211156102d057600081556001016100d8565b610248600435602435600182015481105b92915050565b6102346004356024355b60018101906100fd565b610248600435602435600160a060020a03811660009081526020839052604090205415156100fd565b61024660043560243580600160a060020a031632600160a060020a03161415156101f857600160a060020a038116600090815260208390526040902054156101f857600160a060020a038116600090815260208390526040902054600183018054909160001901908110156100075760009182526020808320909101805473ffffffffffffffffffffffffffffffffffffffff19169055600160a060020a038316825283905260408120556002820180546000190190555b5050565b61025c60043560243560008260010160005082815481101561000757600091825260209091200154600160a060020a03169392505050565b60408051918252519081900360200190f35b005b604080519115158252519081900360200190f35b60408051600160a060020a039092168252519081900360200190f35b50505060009283526020808420909201805473ffffffffffffffffffffffffffffffffffffffff191686179055600160a060020a0385168352908590526040909120819055600284018054600101905590505b505050565b509056", + "nonce": "1", + "storage": {} + }, + "0xa529806c67cc6486d4d62024471772f47f6fd672": { + "balance": "0x67820e39ac8fe9800", + "code": "0x", + "nonce": "68", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "31912170", + "extraData": "0xd783010502846765746887676f312e372e33856c696e7578", + "gasLimit": "4712388", + "hash": "0x0855914bdc581bccdc62591fd438498386ffb59ea4d5361ed5c3702e26e2c72f", + "miner": "0x334391aa808257952a462d1475562ee2106a6c90", + "mixHash": "0x64bb70b8ca883cadb8fbbda2c70a861612407864089ed87b98e5de20acceada6", + "nonce": "0x684129f283aaef18", + "number": "11494", + "stateRoot": "0x7057f31fe3dab1d620771adad35224aae43eb70e94861208bc84c557ff5b9d10", + "timestamp": "1479735912", + "totalDifficulty": "90744064339" + }, + "input": "0xf889448504a817c800832dc6c094269296dddce321a6bcbaa2f0181127593d732cba80a47065cb480000000000000000000000001523e55a1ca4efbae03355775ae89f8d7699ad9e29a080ed81e4c5e9971a730efab4885566e2c868cd80bd4166d0ed8c287fdf181650a069d7c49215e3d4416ad239cd09dbb71b9f04c16b33b385d14f40b618a7a65115", + "result": { + "calls": [ + { + "calls": [ + { + "from": "0x13204f5d64c28326fd7bd05fd4ea855302d7f2ff", + "gas": "0x2bf459", + "gasUsed": "0x2aa", + "input": "0x7d65837a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a529806c67cc6486d4d62024471772f47f6fd672", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x42b02b5deeb78f34cd5ac896473b63e6c99a71a2", + "type": "DELEGATECALL" + } + ], + "from": "0x269296dddce321a6bcbaa2f0181127593d732cba", + "gas": "0x2cae73", + "gasUsed": "0xa9d", + "input": "0x5dbe47e8000000000000000000000000a529806c67cc6486d4d62024471772f47f6fd672", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x13204f5d64c28326fd7bd05fd4ea855302d7f2ff", + "type": "CALL", + "value": "0x0" + } + ], + "from": "0xa529806c67cc6486d4d62024471772f47f6fd672", + "gas": "0x2d6e28", + "gasUsed": "0x64bd", + "input": "0x7065cb480000000000000000000000001523e55a1ca4efbae03355775ae89f8d7699ad9e", + "output": "0x", + "to": "0x269296dddce321a6bcbaa2f0181127593d732cba", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_inner_create_oog_outer_throw.json b/eth/tracers/testdata/call_tracer_inner_create_oog_outer_throw.json new file mode 100644 index 0000000000..b8a4cdd233 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_inner_create_oog_outer_throw.json @@ -0,0 +1,77 @@ +{ + "context": { + "difficulty": "3451177886", + "gasLimit": "4709286", + "miner": "0x1585936b53834b021f68cc13eeefdec2efc8e724", + "number": "2290744", + "timestamp": "1513616439" + }, + "genesis": { + "alloc": { + "0x1d3ddf7caf024f253487e18bc4a15b1a360c170a": { + "balance": "0x0", + "code": "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", + "nonce": "789", + "storage": { + "0xfe9ec0542a1c009be8b1f3acf43af97100ffff42eb736850fb038fa1151ad4d9": "0x000000000000000000000000e4a13bc304682a903e9472f469c33801dd18d9e8" + } + }, + "0x5cb4a6b902fcb21588c86c3517e797b07cdaadb9": { + "balance": "0x0", + "code": "0x", + "nonce": "0", + "storage": {} + }, + "0xe4a13bc304682a903e9472f469c33801dd18d9e8": { + "balance": "0x33c763c929f62c4f", + "code": "0x", + "nonce": "14", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3451177886", + "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444", + "gasLimit": "4713874", + "hash": "0x5d52a672417cd1269bf4f7095e25dcbf837747bba908cd5ef809dc1bd06144b5", + "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3", + "mixHash": "0x01a12845ed546b94a038a7a03e8df8d7952024ed41ccb3db7a7ade4abc290ce1", + "nonce": "0x28c446f1cb9748c1", + "number": "2290743", + "stateRoot": "0x4898aceede76739daef76448a367d10015a2c022c9e7909b99a10fbf6fb16708", + "timestamp": "1513616414", + "totalDifficulty": "7146523769022564" + }, + "input": "0xf8aa0e8509502f9000830493e0941d3ddf7caf024f253487e18bc4a15b1a360c170a80b8443b91f506000000000000000000000000a14bdd7e5666d784dcce98ad24d383a6b1cd4182000000000000000000000000e4a13bc304682a903e9472f469c33801dd18d9e829a0524564944fa419f5c189b5074044f89210c6d6b2d77ee8f7f12a927d59b636dfa0015b28986807a424b18b186ee6642d76739df36cad802d20e8c00e79a61d7281", + "result": { + "calls": [ + { + "error": "internal failure", + "from": "0x1d3ddf7caf024f253487e18bc4a15b1a360c170a", + "gas": "0x39ff0", + "gasUsed": "0x39ff0", + "input": "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", + "type": "CREATE", + "value": "0x0" + } + ], + "error": "invalid jump destination (PUSH1) 0", + "from": "0xe4a13bc304682a903e9472f469c33801dd18d9e8", + "gas": "0x435c8", + "gasUsed": "0x435c8", + "input": "0x3b91f506000000000000000000000000a14bdd7e5666d784dcce98ad24d383a6b1cd4182000000000000000000000000e4a13bc304682a903e9472f469c33801dd18d9e8", + "to": "0x1d3ddf7caf024f253487e18bc4a15b1a360c170a", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_inner_throw_outer_revert.json b/eth/tracers/testdata/call_tracer_inner_throw_outer_revert.json new file mode 100644 index 0000000000..edd80e5b84 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_inner_throw_outer_revert.json @@ -0,0 +1,81 @@ +{ + "context": { + "difficulty": "3956606365", + "gasLimit": "5413248", + "miner": "0x00d8ae40d9a06d0e7a2877b62e32eb959afbe16d", + "number": "2295104", + "timestamp": "1513681256" + }, + "genesis": { + "alloc": { + "0x33056b5dcac09a9b4becad0e1dcf92c19bd0af76": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x0000000000000000000000008d69d00910d0b2afb2a99ed6c16c8129fa8e1751", + "0x0000000000000000000000000000000000000000000000000000000000000003": "0x000000000000000000000000e819f024b41358d2c08e3a868a5c5dd0566078d4", + "0x0000000000000000000000000000000000000000000000000000000000000007": "0x000000000000000000000000000000000000000000000000000000005a388981", + "0x0000000000000000000000000000000000000000000000000000000000000008": "0x000000000000000000000000000000000000000000000000000000005a3b38e6" + } + }, + "0xd4fcab9f0a6dc0493af47c864f6f17a8a5e2e826": { + "balance": "0x2a2dd979a35cf000", + "code": "0x", + "nonce": "0", + "storage": {} + }, + "0xe819f024b41358d2c08e3a868a5c5dd0566078d4": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3956606365", + "extraData": "0x566961425443", + "gasLimit": "5418523", + "hash": "0x6f37eb930a25da673ea1bb80fd9e32ddac19cdf7cd4bb2eac62cc13598624077", + "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511", + "mixHash": "0x10971cde68c587c750c23b8589ae868ce82c2c646636b97e7d9856470c5297c7", + "nonce": "0x810f923ff4b450a1", + "number": "2295103", + "stateRoot": "0xff403612573d76dfdaf4fea2429b77dbe9764021ae0e38dc8ac79a3cf551179e", + "timestamp": "1513681246", + "totalDifficulty": "7162347056825919" + }, + "input": "0xf86d808504e3b292008307dfa69433056b5dcac09a9b4becad0e1dcf92c19bd0af76880e92596fd62900008029a0e5f27bb66431f7081bb7f1f242003056d7f3f35414c352cd3d1848b52716dac2a07d0be78980edb0bd2a0678fc53aa90ea9558ce346b0d947967216918ac74ccea", + "result": { + "calls": [ + { + "error": "invalid opcode 0xfe", + "from": "0x33056b5dcac09a9b4becad0e1dcf92c19bd0af76", + "gas": "0x75fe3", + "gasUsed": "0x75fe3", + "input": "0xa9059cbb000000000000000000000000d4fcab9f0a6dc0493af47c864f6f17a8a5e2e82600000000000000000000000000000000000000000000000000000000000002f4", + "to": "0xe819f024b41358d2c08e3a868a5c5dd0566078d4", + "type": "CALL", + "value": "0x0" + } + ], + "error": "execution reverted", + "from": "0xd4fcab9f0a6dc0493af47c864f6f17a8a5e2e826", + "gas": "0x78d9e", + "gasUsed": "0x76fc0", + "input": "0x", + "to": "0x33056b5dcac09a9b4becad0e1dcf92c19bd0af76", + "type": "CALL", + "value": "0xe92596fd6290000" + } +} diff --git a/eth/tracers/testdata/call_tracer_oog.json b/eth/tracers/testdata/call_tracer_oog.json new file mode 100644 index 0000000000..de4fed6ab1 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_oog.json @@ -0,0 +1,60 @@ +{ + "context": { + "difficulty": "3699098917", + "gasLimit": "5258985", + "miner": "0xd049bfd667cb46aa3ef5df0da3e57db3be39e511", + "number": "2294631", + "timestamp": "1513675366" + }, + "genesis": { + "alloc": { + "0x43064693d3d38ad6a7cb579e0d6d9718c8aa6b62": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x296b66049cc4f9c8bf3d4f14752add261d1a980b39bdd194a7897baf39ac7579": "0x0000000000000000000000000000000000000000033b2e3c9fc9653f9e72b1e0" + } + }, + "0x94194bc2aaf494501d7880b61274a169f6502a54": { + "balance": "0xea8c39a876d19888d", + "code": "0x", + "nonce": "265", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3699098917", + "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444", + "gasLimit": "5263953", + "hash": "0x03a0f62a8106793dafcfae7b75fd2654322062d585a19cea568314d7205790dc", + "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3", + "mixHash": "0x15482cc64b7c00a947f5bf015dfc010db1a6a668c74df61974d6a7848c174408", + "nonce": "0xd1bdb150f6fd170e", + "number": "2294630", + "stateRoot": "0x1ab1a534e84cc787cda1db21e0d5920ab06017948075b759166cfea7274657a1", + "timestamp": "1513675347", + "totalDifficulty": "7160543502214733" + }, + "input": "0xf8ab820109855d21dba00082ca1d9443064693d3d38ad6a7cb579e0d6d9718c8aa6b6280b844a9059cbb000000000000000000000000e77b1ac803616503510bed0086e3a7be2627a69900000000000000000000000000000000000000000000000000000009502f90001ba0ce3ad83f5530136467b7c2bb225f406bd170f4ad59c254e5103c34eeabb5bd69a0455154527224a42ab405cacf0fe92918a75641ce4152f8db292019a5527aa956", + "result": { + "error": "out of gas", + "from": "0x94194bc2aaf494501d7880b61274a169f6502a54", + "gas": "0x7045", + "gasUsed": "0x7045", + "input": "0xa9059cbb000000000000000000000000e77b1ac803616503510bed0086e3a7be2627a69900000000000000000000000000000000000000000000000000000009502f9000", + "to": "0x43064693d3d38ad6a7cb579e0d6d9718c8aa6b62", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_revert.json b/eth/tracers/testdata/call_tracer_revert.json new file mode 100644 index 0000000000..059040a1c8 --- /dev/null +++ b/eth/tracers/testdata/call_tracer_revert.json @@ -0,0 +1,58 @@ +{ + "context": { + "difficulty": "3665057456", + "gasLimit": "5232723", + "miner": "0xf4d8e706cfb25c0decbbdd4d2e2cc10c66376a3f", + "number": "2294501", + "timestamp": "1513673601" + }, + "genesis": { + "alloc": { + "0x0f6cef2b7fbb504782e35aa82a2207e816a2b7a9": { + "balance": "0x2a3fc32bcc019283", + "code": "0x", + "nonce": "10", + "storage": {} + }, + "0xabbcd5b340c80b5f1c0545c04c987b87310296ae": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3672229776", + "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444", + "gasLimit": "5227619", + "hash": "0xa07b3d6c6bf63f5f981016db9f2d1d93033833f2c17e8bf7209e85f1faf08076", + "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3", + "mixHash": "0x806e151ce2817be922e93e8d5921fa0f0d0fd213d6b2b9a3fa17458e74a163d0", + "nonce": "0xbc5d43adc2c30c7d", + "number": "2294500", + "stateRoot": "0xca645b335888352ef9d8b1ef083e9019648180b259026572e3139717270de97d", + "timestamp": "1513673552", + "totalDifficulty": "7160066586979149" + }, + "input": "0xf9018b0a8505d21dba00832dc6c094abbcd5b340c80b5f1c0545c04c987b87310296ae80b9012473b40a5c000000000000000000000000400de2e016bda6577407dfc379faba9899bc73ef0000000000000000000000002cc31912b2b0f3075a87b3640923d45a26cef3ee000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000064d79d8e6c7265636f76657279416464726573730000000000000000000000000000000000000000000000000000000000383e3ec32dc0f66d8fe60dbdc2f6815bdf73a988383e3ec32dc0f66d8fe60dbdc2f6815bdf73a988000000000000000000000000000000000000000000000000000000000000000000000000000000001ba0fd659d76a4edbd2a823e324c93f78ad6803b30ff4a9c8bce71ba82798975c70ca06571eecc0b765688ec6c78942c5ee8b585e00988c0141b518287e9be919bc48a", + "result": { + "error": "execution reverted", + "from": "0x0f6cef2b7fbb504782e35aa82a2207e816a2b7a9", + "gas": "0x2d55e8", + "gasUsed": "0xc3", + "input": "0x73b40a5c000000000000000000000000400de2e016bda6577407dfc379faba9899bc73ef0000000000000000000000002cc31912b2b0f3075a87b3640923d45a26cef3ee000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000064d79d8e6c7265636f76657279416464726573730000000000000000000000000000000000000000000000000000000000383e3ec32dc0f66d8fe60dbdc2f6815bdf73a988383e3ec32dc0f66d8fe60dbdc2f6815bdf73a98800000000000000000000000000000000000000000000000000000000000000000000000000000000", + "to": "0xabbcd5b340c80b5f1c0545c04c987b87310296ae", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_simple.json b/eth/tracers/testdata/call_tracer_simple.json new file mode 100644 index 0000000000..b46432122d --- /dev/null +++ b/eth/tracers/testdata/call_tracer_simple.json @@ -0,0 +1,78 @@ +{ + "context": { + "difficulty": "3502894804", + "gasLimit": "4722976", + "miner": "0x1585936b53834b021f68cc13eeefdec2efc8e724", + "number": "2289806", + "timestamp": "1513601314" + }, + "genesis": { + "alloc": { + "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5": { + "balance": "0x0", + "code": "0x", + "nonce": "22", + "storage": {} + }, + "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe": { + "balance": "0x4d87094125a369d9bd5", + "code": "0x606060405236156100935763ffffffff60e060020a60003504166311ee8382811461009c57806313af4035146100be5780631f5e8f4c146100ee57806324daddc5146101125780634921a91a1461013b57806363e4bff414610157578063764978f91461017f578063893d20e8146101a1578063ba40aaa1146101cd578063cebc9a82146101f4578063e177246e14610216575b61009a5b5b565b005b34156100a457fe5b6100ac61023d565b60408051918252519081900360200190f35b34156100c657fe5b6100da600160a060020a0360043516610244565b604080519115158252519081900360200190f35b34156100f657fe5b6100da610307565b604080519115158252519081900360200190f35b341561011a57fe5b6100da6004351515610318565b604080519115158252519081900360200190f35b6100da6103d6565b604080519115158252519081900360200190f35b6100da600160a060020a0360043516610420565b604080519115158252519081900360200190f35b341561018757fe5b6100ac61046c565b60408051918252519081900360200190f35b34156101a957fe5b6101b1610473565b60408051600160a060020a039092168252519081900360200190f35b34156101d557fe5b6100da600435610483565b604080519115158252519081900360200190f35b34156101fc57fe5b6100ac61050d565b60408051918252519081900360200190f35b341561021e57fe5b6100da600435610514565b604080519115158252519081900360200190f35b6003545b90565b60006000610250610473565b600160a060020a031633600160a060020a03161415156102705760006000fd5b600160a060020a03831615156102865760006000fd5b50600054600160a060020a0390811690831681146102fb57604051600160a060020a0380851691908316907ffcf23a92150d56e85e3a3d33b357493246e55783095eb6a733eb8439ffc752c890600090a360008054600160a060020a031916600160a060020a03851617905560019150610300565b600091505b5b50919050565b60005460a060020a900460ff165b90565b60006000610324610473565b600160a060020a031633600160a060020a03161415156103445760006000fd5b5060005460a060020a900460ff16801515831515146102fb576000546040805160a060020a90920460ff1615158252841515602083015280517fe6cd46a119083b86efc6884b970bfa30c1708f53ba57b86716f15b2f4551a9539281900390910190a16000805460a060020a60ff02191660a060020a8515150217905560019150610300565b600091505b5b50919050565b60006103e0610307565b801561040557506103ef610473565b600160a060020a031633600160a060020a031614155b156104105760006000fd5b610419336105a0565b90505b5b90565b600061042a610307565b801561044f5750610439610473565b600160a060020a031633600160a060020a031614155b1561045a5760006000fd5b610463826105a0565b90505b5b919050565b6001545b90565b600054600160a060020a03165b90565b6000600061048f610473565b600160a060020a031633600160a060020a03161415156104af5760006000fd5b506001548281146102fb57604080518281526020810185905281517f79a3746dde45672c9e8ab3644b8bb9c399a103da2dc94b56ba09777330a83509929181900390910190a160018381559150610300565b600091505b5b50919050565b6002545b90565b60006000610520610473565b600160a060020a031633600160a060020a03161415156105405760006000fd5b506002548281146102fb57604080518281526020810185905281517ff6991a728965fedd6e927fdf16bdad42d8995970b4b31b8a2bf88767516e2494929181900390910190a1600283905560019150610300565b600091505b5b50919050565b60006000426105ad61023d565b116102fb576105c46105bd61050d565b4201610652565b6105cc61046c565b604051909150600160a060020a038416908290600081818185876187965a03f1925050501561063d57604080518281529051600160a060020a038516917f9bca65ce52fdef8a470977b51f247a2295123a4807dfa9e502edf0d30722da3b919081900360200190a260019150610300565b6102fb42610652565b5b600091505b50919050565b60038190555b505600a165627a7a72305820f3c973c8b7ed1f62000b6701bd5b708469e19d0f1d73fde378a56c07fd0b19090029", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000000": "0x000000000000000000000001b436ba50d378d4bbc8660d312a13df6af6e89dfb", + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x00000000000000000000000000000000000000000000000006f05b59d3b20000", + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x000000000000000000000000000000000000000000000000000000000000003c", + "0x0000000000000000000000000000000000000000000000000000000000000003": "0x000000000000000000000000000000000000000000000000000000005a37b834" + } + }, + "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb": { + "balance": "0x1780d77678137ac1b775", + "code": "0x", + "nonce": "29072", + "storage": {} + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "3509749784", + "extraData": "0x4554482e45544846414e532e4f52472d4641313738394444", + "gasLimit": "4727564", + "hash": "0x609948ac3bd3c00b7736b933248891d6c901ee28f066241bddb28f4e00a9f440", + "miner": "0xbbf5029fd710d227630c8b7d338051b8e76d50b3", + "mixHash": "0xb131e4507c93c7377de00e7c271bf409ec7492767142ff0f45c882f8068c2ada", + "nonce": "0x4eb12e19c16d43da", + "number": "2289805", + "stateRoot": "0xc7f10f352bff82fac3c2999d3085093d12652e19c7fd32591de49dc5d91b4f1f", + "timestamp": "1513601261", + "totalDifficulty": "7143276353481064" + }, + "input": "0xf88b8271908506fc23ac0083015f90943b873a919aa0512d5a0f09e6dcceaa4a6727fafe80a463e4bff40000000000000000000000000024f658a46fbb89d8ac105e98d7ac7cbbaf27c52aa0bdce0b59e8761854e857fe64015f06dd08a4fbb7624f6094893a79a72e6ad6bea01d9dde033cff7bb235a3163f348a6d7ab8d6b52bc0963a95b91612e40ca766a4", + "result": { + "calls": [ + { + "from": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe", + "input": "0x", + "to": "0x0024f658a46fbb89d8ac105e98d7ac7cbbaf27c5", + "type": "CALL", + "value": "0x6f05b59d3b20000" + } + ], + "from": "0xb436ba50d378d4bbc8660d312a13df6af6e89dfb", + "gas": "0x10738", + "gasUsed": "0x3ef9", + "input": "0x63e4bff40000000000000000000000000024f658a46fbb89d8ac105e98d7ac7cbbaf27c5", + "output": "0x0000000000000000000000000000000000000000000000000000000000000001", + "to": "0x3b873a919aa0512d5a0f09e6dcceaa4a6727fafe", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/testdata/call_tracer_throw.json b/eth/tracers/testdata/call_tracer_throw.json new file mode 100644 index 0000000000..60d4d1071d --- /dev/null +++ b/eth/tracers/testdata/call_tracer_throw.json @@ -0,0 +1,62 @@ +{ + "context": { + "difficulty": "117009631", + "gasLimit": "4712388", + "miner": "0x294e5d6c39a36ce38af1dca70c1060f78dee8070", + "number": "25009", + "timestamp": "1479891666" + }, + "genesis": { + "alloc": { + "0x70c9217d814985faef62b124420f8dfbddd96433": { + "balance": "0x4ecd70668f5d854a", + "code": "0x", + "nonce": "1638", + "storage": {} + }, + "0xc212e03b9e060e36facad5fd8f4435412ca22e6b": { + "balance": "0x0", + "code": "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", + "nonce": "1", + "storage": { + "0x0000000000000000000000000000000000000000000000000000000000000001": "0x0000000000000000000000002cccf5e0538493c235d1c5ef6580f77d99e91396", + "0x0000000000000000000000000000000000000000000000000000000000000002": "0x00000000000000000000000000000000000000000000000000000000000061a9", + "0x0000000000000000000000000000000000000000000000000000000000000005": "0x00000000000000000000000070c9217d814985faef62b124420f8dfbddd96433" + } + } + }, + "config": { + "byzantiumBlock": 1700000, + "chainId": 3, + "daoForkSupport": true, + "eip150Block": 0, + "eip150Hash": "0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d", + "eip155Block": 10, + "eip158Block": 10, + "ethash": {}, + "homesteadBlock": 0 + }, + "difficulty": "117066792", + "extraData": "0xd783010502846765746887676f312e372e33856c696e7578", + "gasLimit": "4712388", + "hash": "0xe23e8d4562a1045b70cbc99fefb20c101a8f0fc8559a80d65fea8896e2f1d46e", + "miner": "0x71842f946b98800fe6feb49f0ae4e253259031c9", + "mixHash": "0x0aada9d6e93dd4db0d09c0488dc0a048fca2ccdc1f3fc7b83ba2a8d393a3a4ff", + "nonce": "0x70849d5838dee2e9", + "number": "25008", + "stateRoot": "0x1e01d2161794768c5b917069e73d86e8dca80cd7f3168c0597de420ab93a3b7b", + "timestamp": "1479891641", + "totalDifficulty": "1896347038589" + }, + "input": "0xf88b8206668504a817c8008303d09094c212e03b9e060e36facad5fd8f4435412ca22e6b80a451a34eb8000000000000000000000000000000000000000000000027fad02094277c000029a0692a3b4e7b2842f8dd7832e712c21e09f451f416c8976d5b8d02e8c0c2b4bea9a07645e90fc421b63dd755767fd93d3c03b4ec0c4d8fafa059558d08cf11d59750", + "result": { + "error": "invalid jump destination (PUSH1) 2", + "from": "0x70c9217d814985faef62b124420f8dfbddd96433", + "gas": "0x37b38", + "gasUsed": "0x37b38", + "input": "0x51a34eb8000000000000000000000000000000000000000000000027fad02094277c0000", + "to": "0xc212e03b9e060e36facad5fd8f4435412ca22e6b", + "type": "CALL", + "value": "0x0" + } +} diff --git a/eth/tracers/tracer.go b/eth/tracers/tracer.go new file mode 100644 index 0000000000..f3f848fc1b --- /dev/null +++ b/eth/tracers/tracer.go @@ -0,0 +1,618 @@ +// Copyright 2016 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package tracers + +import ( + "encoding/json" + "errors" + "fmt" + "math/big" + "sync/atomic" + "time" + "unsafe" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" + duktape "gopkg.in/olebedev/go-duktape.v3" +) + +// bigIntegerJS is the minified version of https://github.com/peterolson/BigInteger.js. +const bigIntegerJS = `var bigInt=function(undefined){"use strict";var BASE=1e7,LOG_BASE=7,MAX_INT=9007199254740992,MAX_INT_ARR=smallToArray(MAX_INT),LOG_MAX_INT=Math.log(MAX_INT);function Integer(v,radix){if(typeof v==="undefined")return Integer[0];if(typeof radix!=="undefined")return+radix===10?parseValue(v):parseBase(v,radix);return parseValue(v)}function BigInteger(value,sign){this.value=value;this.sign=sign;this.isSmall=false}BigInteger.prototype=Object.create(Integer.prototype);function SmallInteger(value){this.value=value;this.sign=value<0;this.isSmall=true}SmallInteger.prototype=Object.create(Integer.prototype);function isPrecise(n){return-MAX_INT0)return Math.floor(n);return Math.ceil(n)}function add(a,b){var l_a=a.length,l_b=b.length,r=new Array(l_a),carry=0,base=BASE,sum,i;for(i=0;i=base?1:0;r[i]=sum-carry*base}while(i0)r.push(carry);return r}function addAny(a,b){if(a.length>=b.length)return add(a,b);return add(b,a)}function addSmall(a,carry){var l=a.length,r=new Array(l),base=BASE,sum,i;for(i=0;i0){r[i++]=carry%base;carry=Math.floor(carry/base)}return r}BigInteger.prototype.add=function(v){var n=parseValue(v);if(this.sign!==n.sign){return this.subtract(n.negate())}var a=this.value,b=n.value;if(n.isSmall){return new BigInteger(addSmall(a,Math.abs(b)),this.sign)}return new BigInteger(addAny(a,b),this.sign)};BigInteger.prototype.plus=BigInteger.prototype.add;SmallInteger.prototype.add=function(v){var n=parseValue(v);var a=this.value;if(a<0!==n.sign){return this.subtract(n.negate())}var b=n.value;if(n.isSmall){if(isPrecise(a+b))return new SmallInteger(a+b);b=smallToArray(Math.abs(b))}return new BigInteger(addSmall(b,Math.abs(a)),a<0)};SmallInteger.prototype.plus=SmallInteger.prototype.add;function subtract(a,b){var a_l=a.length,b_l=b.length,r=new Array(a_l),borrow=0,base=BASE,i,difference;for(i=0;i=0){value=subtract(a,b)}else{value=subtract(b,a);sign=!sign}value=arrayToSmall(value);if(typeof value==="number"){if(sign)value=-value;return new SmallInteger(value)}return new BigInteger(value,sign)}function subtractSmall(a,b,sign){var l=a.length,r=new Array(l),carry=-b,base=BASE,i,difference;for(i=0;i=0)};SmallInteger.prototype.minus=SmallInteger.prototype.subtract;BigInteger.prototype.negate=function(){return new BigInteger(this.value,!this.sign)};SmallInteger.prototype.negate=function(){var sign=this.sign;var small=new SmallInteger(-this.value);small.sign=!sign;return small};BigInteger.prototype.abs=function(){return new BigInteger(this.value,false)};SmallInteger.prototype.abs=function(){return new SmallInteger(Math.abs(this.value))};function multiplyLong(a,b){var a_l=a.length,b_l=b.length,l=a_l+b_l,r=createArray(l),base=BASE,product,carry,i,a_i,b_j;for(i=0;i0){r[i++]=carry%base;carry=Math.floor(carry/base)}return r}function shiftLeft(x,n){var r=[];while(n-- >0)r.push(0);return r.concat(x)}function multiplyKaratsuba(x,y){var n=Math.max(x.length,y.length);if(n<=30)return multiplyLong(x,y);n=Math.ceil(n/2);var b=x.slice(n),a=x.slice(0,n),d=y.slice(n),c=y.slice(0,n);var ac=multiplyKaratsuba(a,c),bd=multiplyKaratsuba(b,d),abcd=multiplyKaratsuba(addAny(a,b),addAny(c,d));var product=addAny(addAny(ac,shiftLeft(subtract(subtract(abcd,ac),bd),n)),shiftLeft(bd,2*n));trim(product);return product}function useKaratsuba(l1,l2){return-.012*l1-.012*l2+15e-6*l1*l2>0}BigInteger.prototype.multiply=function(v){var n=parseValue(v),a=this.value,b=n.value,sign=this.sign!==n.sign,abs;if(n.isSmall){if(b===0)return Integer[0];if(b===1)return this;if(b===-1)return this.negate();abs=Math.abs(b);if(abs=0;shift--){quotientDigit=base-1;if(remainder[shift+b_l]!==divisorMostSignificantDigit){quotientDigit=Math.floor((remainder[shift+b_l]*base+remainder[shift+b_l-1])/divisorMostSignificantDigit)}carry=0;borrow=0;l=divisor.length;for(i=0;ib_l){highx=(highx+1)*base}guess=Math.ceil(highx/highy);do{check=multiplySmall(b,guess);if(compareAbs(check,part)<=0)break;guess--}while(guess);result.push(guess);part=subtract(part,check)}result.reverse();return[arrayToSmall(result),arrayToSmall(part)]}function divModSmall(value,lambda){var length=value.length,quotient=createArray(length),base=BASE,i,q,remainder,divisor;remainder=0;for(i=length-1;i>=0;--i){divisor=remainder*base+value[i];q=truncate(divisor/lambda);remainder=divisor-q*lambda;quotient[i]=q|0}return[quotient,remainder|0]}function divModAny(self,v){var value,n=parseValue(v);var a=self.value,b=n.value;var quotient;if(b===0)throw new Error("Cannot divide by zero");if(self.isSmall){if(n.isSmall){return[new SmallInteger(truncate(a/b)),new SmallInteger(a%b)]}return[Integer[0],self]}if(n.isSmall){if(b===1)return[self,Integer[0]];if(b==-1)return[self.negate(),Integer[0]];var abs=Math.abs(b);if(absb.length?1:-1}for(var i=a.length-1;i>=0;i--){if(a[i]!==b[i])return a[i]>b[i]?1:-1}return 0}BigInteger.prototype.compareAbs=function(v){var n=parseValue(v),a=this.value,b=n.value;if(n.isSmall)return 1;return compareAbs(a,b)};SmallInteger.prototype.compareAbs=function(v){var n=parseValue(v),a=Math.abs(this.value),b=n.value;if(n.isSmall){b=Math.abs(b);return a===b?0:a>b?1:-1}return-1};BigInteger.prototype.compare=function(v){if(v===Infinity){return-1}if(v===-Infinity){return 1}var n=parseValue(v),a=this.value,b=n.value;if(this.sign!==n.sign){return n.sign?1:-1}if(n.isSmall){return this.sign?-1:1}return compareAbs(a,b)*(this.sign?-1:1)};BigInteger.prototype.compareTo=BigInteger.prototype.compare;SmallInteger.prototype.compare=function(v){if(v===Infinity){return-1}if(v===-Infinity){return 1}var n=parseValue(v),a=this.value,b=n.value;if(n.isSmall){return a==b?0:a>b?1:-1}if(a<0!==n.sign){return a<0?-1:1}return a<0?1:-1};SmallInteger.prototype.compareTo=SmallInteger.prototype.compare;BigInteger.prototype.equals=function(v){return this.compare(v)===0};SmallInteger.prototype.eq=SmallInteger.prototype.equals=BigInteger.prototype.eq=BigInteger.prototype.equals;BigInteger.prototype.notEquals=function(v){return this.compare(v)!==0};SmallInteger.prototype.neq=SmallInteger.prototype.notEquals=BigInteger.prototype.neq=BigInteger.prototype.notEquals;BigInteger.prototype.greater=function(v){return this.compare(v)>0};SmallInteger.prototype.gt=SmallInteger.prototype.greater=BigInteger.prototype.gt=BigInteger.prototype.greater;BigInteger.prototype.lesser=function(v){return this.compare(v)<0};SmallInteger.prototype.lt=SmallInteger.prototype.lesser=BigInteger.prototype.lt=BigInteger.prototype.lesser;BigInteger.prototype.greaterOrEquals=function(v){return this.compare(v)>=0};SmallInteger.prototype.geq=SmallInteger.prototype.greaterOrEquals=BigInteger.prototype.geq=BigInteger.prototype.greaterOrEquals;BigInteger.prototype.lesserOrEquals=function(v){return this.compare(v)<=0};SmallInteger.prototype.leq=SmallInteger.prototype.lesserOrEquals=BigInteger.prototype.leq=BigInteger.prototype.lesserOrEquals;BigInteger.prototype.isEven=function(){return(this.value[0]&1)===0};SmallInteger.prototype.isEven=function(){return(this.value&1)===0};BigInteger.prototype.isOdd=function(){return(this.value[0]&1)===1};SmallInteger.prototype.isOdd=function(){return(this.value&1)===1};BigInteger.prototype.isPositive=function(){return!this.sign};SmallInteger.prototype.isPositive=function(){return this.value>0};BigInteger.prototype.isNegative=function(){return this.sign};SmallInteger.prototype.isNegative=function(){return this.value<0};BigInteger.prototype.isUnit=function(){return false};SmallInteger.prototype.isUnit=function(){return Math.abs(this.value)===1};BigInteger.prototype.isZero=function(){return false};SmallInteger.prototype.isZero=function(){return this.value===0};BigInteger.prototype.isDivisibleBy=function(v){var n=parseValue(v);var value=n.value;if(value===0)return false;if(value===1)return true;if(value===2)return this.isEven();return this.mod(n).equals(Integer[0])};SmallInteger.prototype.isDivisibleBy=BigInteger.prototype.isDivisibleBy;function isBasicPrime(v){var n=v.abs();if(n.isUnit())return false;if(n.equals(2)||n.equals(3)||n.equals(5))return true;if(n.isEven()||n.isDivisibleBy(3)||n.isDivisibleBy(5))return false;if(n.lesser(25))return true}BigInteger.prototype.isPrime=function(){var isPrime=isBasicPrime(this);if(isPrime!==undefined)return isPrime;var n=this.abs(),nPrev=n.prev();var a=[2,3,5,7,11,13,17,19],b=nPrev,d,t,i,x;while(b.isEven())b=b.divide(2);for(i=0;i-MAX_INT)return new SmallInteger(value-1);return new BigInteger(MAX_INT_ARR,true)};var powersOfTwo=[1];while(2*powersOfTwo[powersOfTwo.length-1]<=BASE)powersOfTwo.push(2*powersOfTwo[powersOfTwo.length-1]);var powers2Length=powersOfTwo.length,highestPower2=powersOfTwo[powers2Length-1];function shift_isSmall(n){return(typeof n==="number"||typeof n==="string")&&+Math.abs(n)<=BASE||n instanceof BigInteger&&n.value.length<=1}BigInteger.prototype.shiftLeft=function(n){if(!shift_isSmall(n)){throw new Error(String(n)+" is too large for shifting.")}n=+n;if(n<0)return this.shiftRight(-n);var result=this;while(n>=powers2Length){result=result.multiply(highestPower2);n-=powers2Length-1}return result.multiply(powersOfTwo[n])};SmallInteger.prototype.shiftLeft=BigInteger.prototype.shiftLeft;BigInteger.prototype.shiftRight=function(n){var remQuo;if(!shift_isSmall(n)){throw new Error(String(n)+" is too large for shifting.")}n=+n;if(n<0)return this.shiftLeft(-n);var result=this;while(n>=powers2Length){if(result.isZero())return result;remQuo=divModAny(result,highestPower2);result=remQuo[1].isNegative()?remQuo[0].prev():remQuo[0];n-=powers2Length-1}remQuo=divModAny(result,powersOfTwo[n]);return remQuo[1].isNegative()?remQuo[0].prev():remQuo[0]};SmallInteger.prototype.shiftRight=BigInteger.prototype.shiftRight;function bitwise(x,y,fn){y=parseValue(y);var xSign=x.isNegative(),ySign=y.isNegative();var xRem=xSign?x.not():x,yRem=ySign?y.not():y;var xDigit=0,yDigit=0;var xDivMod=null,yDivMod=null;var result=[];while(!xRem.isZero()||!yRem.isZero()){xDivMod=divModAny(xRem,highestPower2);xDigit=xDivMod[1].toJSNumber();if(xSign){xDigit=highestPower2-1-xDigit}yDivMod=divModAny(yRem,highestPower2);yDigit=yDivMod[1].toJSNumber();if(ySign){yDigit=highestPower2-1-yDigit}xRem=xDivMod[0];yRem=yDivMod[0];result.push(fn(xDigit,yDigit))}var sum=fn(xSign?1:0,ySign?1:0)!==0?bigInt(-1):bigInt(0);for(var i=result.length-1;i>=0;i-=1){sum=sum.multiply(highestPower2).add(bigInt(result[i]))}return sum}BigInteger.prototype.not=function(){return this.negate().prev()};SmallInteger.prototype.not=BigInteger.prototype.not;BigInteger.prototype.and=function(n){return bitwise(this,n,function(a,b){return a&b})};SmallInteger.prototype.and=BigInteger.prototype.and;BigInteger.prototype.or=function(n){return bitwise(this,n,function(a,b){return a|b})};SmallInteger.prototype.or=BigInteger.prototype.or;BigInteger.prototype.xor=function(n){return bitwise(this,n,function(a,b){return a^b})};SmallInteger.prototype.xor=BigInteger.prototype.xor;var LOBMASK_I=1<<30,LOBMASK_BI=(BASE&-BASE)*(BASE&-BASE)|LOBMASK_I;function roughLOB(n){var v=n.value,x=typeof v==="number"?v|LOBMASK_I:v[0]+v[1]*BASE|LOBMASK_BI;return x&-x}function max(a,b){a=parseValue(a);b=parseValue(b);return a.greater(b)?a:b}function min(a,b){a=parseValue(a);b=parseValue(b);return a.lesser(b)?a:b}function gcd(a,b){a=parseValue(a).abs();b=parseValue(b).abs();if(a.equals(b))return a;if(a.isZero())return b;if(b.isZero())return a;var c=Integer[1],d,t;while(a.isEven()&&b.isEven()){d=Math.min(roughLOB(a),roughLOB(b));a=a.divide(d);b=b.divide(d);c=c.multiply(d)}while(a.isEven()){a=a.divide(roughLOB(a))}do{while(b.isEven()){b=b.divide(roughLOB(b))}if(a.greater(b)){t=b;b=a;a=t}b=b.subtract(a)}while(!b.isZero());return c.isUnit()?a:a.multiply(c)}function lcm(a,b){a=parseValue(a).abs();b=parseValue(b).abs();return a.divide(gcd(a,b)).multiply(b)}function randBetween(a,b){a=parseValue(a);b=parseValue(b);var low=min(a,b),high=max(a,b);var range=high.subtract(low).add(1);if(range.isSmall)return low.add(Math.floor(Math.random()*range));var length=range.value.length-1;var result=[],restricted=true;for(var i=length;i>=0;i--){var top=restricted?range.value[i]:BASE;var digit=truncate(Math.random()*top);result.unshift(digit);if(digit=absBase){if(c==="1"&&absBase===1)continue;throw new Error(c+" is not a valid digit in base "+base+".")}else if(c.charCodeAt(0)-87>=absBase){throw new Error(c+" is not a valid digit in base "+base+".")}}}if(2<=base&&base<=36){if(length<=LOG_MAX_INT/Math.log(base)){var result=parseInt(text,base);if(isNaN(result)){throw new Error(c+" is not a valid digit in base "+base+".")}return new SmallInteger(parseInt(text,base))}}base=parseValue(base);var digits=[];var isNegative=text[0]==="-";for(i=isNegative?1:0;i");digits.push(parseValue(text.slice(start+1,i)))}else throw new Error(c+" is not a valid character")}return parseBaseFromArray(digits,base,isNegative)};function parseBaseFromArray(digits,base,isNegative){var val=Integer[0],pow=Integer[1],i;for(i=digits.length-1;i>=0;i--){val=val.add(digits[i].times(pow));pow=pow.times(base)}return isNegative?val.negate():val}function stringify(digit){var v=digit.value;if(typeof v==="number")v=[v];if(v.length===1&&v[0]<=35){return"0123456789abcdefghijklmnopqrstuvwxyz".charAt(v[0])}return"<"+v+">"}function toBase(n,base){base=bigInt(base);if(base.isZero()){if(n.isZero())return"0";throw new Error("Cannot convert nonzero numbers to base 0.")}if(base.equals(-1)){if(n.isZero())return"0";if(n.isNegative())return new Array(1-n).join("10");return"1"+new Array(+n).join("01")}var minusSign="";if(n.isNegative()&&base.isPositive()){minusSign="-";n=n.abs()}if(base.equals(1)){if(n.isZero())return"0";return minusSign+new Array(+n+1).join(1)}var out=[];var left=n,divmod;while(left.isNegative()||left.compareAbs(base)>=0){divmod=left.divmod(base);left=divmod.quotient;var digit=divmod.remainder;if(digit.isNegative()){digit=base.minus(digit).abs();left=left.next()}out.push(stringify(digit))}out.push(stringify(left));return minusSign+out.reverse().join("")}BigInteger.prototype.toString=function(radix){if(radix===undefined)radix=10;if(radix!==10)return toBase(this,radix);var v=this.value,l=v.length,str=String(v[--l]),zeros="0000000",digit;while(--l>=0){digit=String(v[l]);str+=zeros.slice(digit.length)+digit}var sign=this.sign?"-":"";return sign+str};SmallInteger.prototype.toString=function(radix){if(radix===undefined)radix=10;if(radix!=10)return toBase(this,radix);return String(this.value)};BigInteger.prototype.toJSON=SmallInteger.prototype.toJSON=function(){return this.toString()};BigInteger.prototype.valueOf=function(){return+this.toString()};BigInteger.prototype.toJSNumber=BigInteger.prototype.valueOf;SmallInteger.prototype.valueOf=function(){return this.value};SmallInteger.prototype.toJSNumber=SmallInteger.prototype.valueOf;function parseStringValue(v){if(isPrecise(+v)){var x=+v;if(x===truncate(x))return new SmallInteger(x);throw"Invalid integer: "+v}var sign=v[0]==="-";if(sign)v=v.slice(1);var split=v.split(/e/i);if(split.length>2)throw new Error("Invalid integer: "+split.join("e"));if(split.length===2){var exp=split[1];if(exp[0]==="+")exp=exp.slice(1);exp=+exp;if(exp!==truncate(exp)||!isPrecise(exp))throw new Error("Invalid integer: "+exp+" is not a valid exponent.");var text=split[0];var decimalPlace=text.indexOf(".");if(decimalPlace>=0){exp-=text.length-decimalPlace-1;text=text.slice(0,decimalPlace)+text.slice(decimalPlace+1)}if(exp<0)throw new Error("Cannot include negative exponent part for integers");text+=new Array(exp+1).join("0");v=text}var isValid=/^([0-9][0-9]*)$/.test(v);if(!isValid)throw new Error("Invalid integer: "+v);var r=[],max=v.length,l=LOG_BASE,min=max-l;while(max>0){r.push(+v.slice(min,max));min-=l;if(min<0)min=0;max-=l}trim(r);return new BigInteger(r,sign)}function parseNumberValue(v){if(isPrecise(v)){if(v!==truncate(v))throw new Error(v+" is not an integer.");return new SmallInteger(v)}return parseStringValue(v.toString())}function parseValue(v){if(typeof v==="number"){return parseNumberValue(v)}if(typeof v==="string"){return parseStringValue(v)}return v}for(var i=0;i<1e3;i++){Integer[i]=new SmallInteger(i);if(i>0)Integer[-i]=new SmallInteger(-i)}Integer.one=Integer[1];Integer.zero=Integer[0];Integer.minusOne=Integer[-1];Integer.max=max;Integer.min=min;Integer.gcd=gcd;Integer.lcm=lcm;Integer.isInstance=function(x){return x instanceof BigInteger||x instanceof SmallInteger};Integer.randBetween=randBetween;Integer.fromArray=function(digits,base,isNegative){return parseBaseFromArray(digits.map(parseValue),parseValue(base||10),isNegative)};return Integer}();if(typeof module!=="undefined"&&module.hasOwnProperty("exports")){module.exports=bigInt}if(typeof define==="function"&&define.amd){define("big-integer",[],function(){return bigInt})}; bigInt` + +// makeSlice convert an unsafe memory pointer with the given type into a Go byte +// slice. +// +// Note, the returned slice uses the same memory area as the input arguments. +// If those are duktape stack items, popping them off **will** make the slice +// contents change. +func makeSlice(ptr unsafe.Pointer, size uint) []byte { + var sl = struct { + addr uintptr + len int + cap int + }{uintptr(ptr), int(size), int(size)} + + return *(*[]byte)(unsafe.Pointer(&sl)) +} + +// popSlice pops a buffer off the JavaScript stack and returns it as a slice. +func popSlice(ctx *duktape.Context) []byte { + blob := common.CopyBytes(makeSlice(ctx.GetBuffer(-1))) + ctx.Pop() + return blob +} + +// pushBigInt create a JavaScript BigInteger in the VM. +func pushBigInt(n *big.Int, ctx *duktape.Context) { + ctx.GetGlobalString("bigInt") + ctx.PushString(n.String()) + ctx.Call(1) +} + +// opWrapper provides a JavaScript wrapper around OpCode. +type opWrapper struct { + op vm.OpCode +} + +// pushObject assembles a JSVM object wrapping a swappable opcode and pushes it +// onto the VM stack. +func (ow *opWrapper) pushObject(vm *duktape.Context) { + obj := vm.PushObject() + + vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushInt(int(ow.op)); return 1 }) + vm.PutPropString(obj, "toNumber") + + vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushString(ow.op.String()); return 1 }) + vm.PutPropString(obj, "toString") + + vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushBoolean(ow.op.IsPush()); return 1 }) + vm.PutPropString(obj, "isPush") +} + +// memoryWrapper provides a JavaScript wrapper around vm.Memory. +type memoryWrapper struct { + memory *vm.Memory +} + +// slice returns the requested range of memory as a byte slice. +func (mw *memoryWrapper) slice(begin, end int64) []byte { + if mw.memory.Len() < int(end) { + // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go + // runtime goes belly up https://github.com/golang/go/issues/15639. + log.Warn("Tracer accessed out of bound memory", "available", mw.memory.Len(), "offset", begin, "size", end-begin) + return nil + } + return mw.memory.Get(begin, end-begin) +} + +// getUint returns the 32 bytes at the specified address interpreted as a uint. +func (mw *memoryWrapper) getUint(addr int64) *big.Int { + if mw.memory.Len() < int(addr)+32 { + // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go + // runtime goes belly up https://github.com/golang/go/issues/15639. + log.Warn("Tracer accessed out of bound memory", "available", mw.memory.Len(), "offset", addr, "size", 32) + return new(big.Int) + } + return new(big.Int).SetBytes(mw.memory.GetPtr(addr, 32)) +} + +// pushObject assembles a JSVM object wrapping a swappable memory and pushes it +// onto the VM stack. +func (mw *memoryWrapper) pushObject(vm *duktape.Context) { + obj := vm.PushObject() + + // Generate the `slice` method which takes two ints and returns a buffer + vm.PushGoFunction(func(ctx *duktape.Context) int { + blob := mw.slice(int64(ctx.GetInt(-2)), int64(ctx.GetInt(-1))) + ctx.Pop2() + + ptr := ctx.PushFixedBuffer(len(blob)) + copy(makeSlice(ptr, uint(len(blob))), blob[:]) + return 1 + }) + vm.PutPropString(obj, "slice") + + // Generate the `getUint` method which takes an int and returns a bigint + vm.PushGoFunction(func(ctx *duktape.Context) int { + offset := int64(ctx.GetInt(-1)) + ctx.Pop() + + pushBigInt(mw.getUint(offset), ctx) + return 1 + }) + vm.PutPropString(obj, "getUint") +} + +// stackWrapper provides a JavaScript wrapper around vm.Stack. +type stackWrapper struct { + stack *vm.Stack +} + +// peek returns the nth-from-the-top element of the stack. +func (sw *stackWrapper) peek(idx int) *big.Int { + if len(sw.stack.Data()) <= idx { + // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go + // runtime goes belly up https://github.com/golang/go/issues/15639. + log.Warn("Tracer accessed out of bound stack", "size", len(sw.stack.Data()), "index", idx) + return new(big.Int) + } + return sw.stack.Data()[len(sw.stack.Data())-idx-1] +} + +// pushObject assembles a JSVM object wrapping a swappable stack and pushes it +// onto the VM stack. +func (sw *stackWrapper) pushObject(vm *duktape.Context) { + obj := vm.PushObject() + + vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushInt(len(sw.stack.Data())); return 1 }) + vm.PutPropString(obj, "length") + + // Generate the `peek` method which takes an int and returns a bigint + vm.PushGoFunction(func(ctx *duktape.Context) int { + offset := ctx.GetInt(-1) + ctx.Pop() + + pushBigInt(sw.peek(offset), ctx) + return 1 + }) + vm.PutPropString(obj, "peek") +} + +// dbWrapper provides a JavaScript wrapper around vm.Database. +type dbWrapper struct { + db vm.StateDB +} + +// pushObject assembles a JSVM object wrapping a swappable database and pushes it +// onto the VM stack. +func (dw *dbWrapper) pushObject(vm *duktape.Context) { + obj := vm.PushObject() + + // Push the wrapper for statedb.GetBalance + vm.PushGoFunction(func(ctx *duktape.Context) int { + pushBigInt(dw.db.GetBalance(common.BytesToAddress(popSlice(ctx))), ctx) + return 1 + }) + vm.PutPropString(obj, "getBalance") + + // Push the wrapper for statedb.GetNonce + vm.PushGoFunction(func(ctx *duktape.Context) int { + ctx.PushInt(int(dw.db.GetNonce(common.BytesToAddress(popSlice(ctx))))) + return 1 + }) + vm.PutPropString(obj, "getNonce") + + // Push the wrapper for statedb.GetCode + vm.PushGoFunction(func(ctx *duktape.Context) int { + code := dw.db.GetCode(common.BytesToAddress(popSlice(ctx))) + + ptr := ctx.PushFixedBuffer(len(code)) + copy(makeSlice(ptr, uint(len(code))), code[:]) + return 1 + }) + vm.PutPropString(obj, "getCode") + + // Push the wrapper for statedb.GetState + vm.PushGoFunction(func(ctx *duktape.Context) int { + hash := popSlice(ctx) + addr := popSlice(ctx) + + state := dw.db.GetState(common.BytesToAddress(addr), common.BytesToHash(hash)) + + ptr := ctx.PushFixedBuffer(len(state)) + copy(makeSlice(ptr, uint(len(state))), state[:]) + return 1 + }) + vm.PutPropString(obj, "getState") + + // Push the wrapper for statedb.Exists + vm.PushGoFunction(func(ctx *duktape.Context) int { + ctx.PushBoolean(dw.db.Exist(common.BytesToAddress(popSlice(ctx)))) + return 1 + }) + vm.PutPropString(obj, "exists") +} + +// contractWrapper provides a JavaScript wrapper around vm.Contract +type contractWrapper struct { + contract *vm.Contract +} + +// pushObject assembles a JSVM object wrapping a swappable contract and pushes it +// onto the VM stack. +func (cw *contractWrapper) pushObject(vm *duktape.Context) { + obj := vm.PushObject() + + // Push the wrapper for contract.Caller + vm.PushGoFunction(func(ctx *duktape.Context) int { + ptr := ctx.PushFixedBuffer(20) + copy(makeSlice(ptr, 20), cw.contract.Caller().Bytes()) + return 1 + }) + vm.PutPropString(obj, "getCaller") + + // Push the wrapper for contract.Address + vm.PushGoFunction(func(ctx *duktape.Context) int { + ptr := ctx.PushFixedBuffer(20) + copy(makeSlice(ptr, 20), cw.contract.Address().Bytes()) + return 1 + }) + vm.PutPropString(obj, "getAddress") + + // Push the wrapper for contract.Value + vm.PushGoFunction(func(ctx *duktape.Context) int { + pushBigInt(cw.contract.Value(), ctx) + return 1 + }) + vm.PutPropString(obj, "getValue") + + // Push the wrapper for contract.Input + vm.PushGoFunction(func(ctx *duktape.Context) int { + blob := cw.contract.Input + + ptr := ctx.PushFixedBuffer(len(blob)) + copy(makeSlice(ptr, uint(len(blob))), blob[:]) + return 1 + }) + vm.PutPropString(obj, "getInput") +} + +// Tracer provides an implementation of Tracer that evaluates a Javascript +// function for each VM execution step. +type Tracer struct { + inited bool // Flag whether the context was already inited from the EVM + + vm *duktape.Context // Javascript VM instance + + tracerObject int // Stack index of the tracer JavaScript object + stateObject int // Stack index of the global state to pull arguments from + + opWrapper *opWrapper // Wrapper around the VM opcode + stackWrapper *stackWrapper // Wrapper around the VM stack + memoryWrapper *memoryWrapper // Wrapper around the VM memory + contractWrapper *contractWrapper // Wrapper around the contract object + dbWrapper *dbWrapper // Wrapper around the VM environment + + pcValue *uint // Swappable pc value wrapped by a log accessor + gasValue *uint // Swappable gas value wrapped by a log accessor + costValue *uint // Swappable cost value wrapped by a log accessor + depthValue *uint // Swappable depth value wrapped by a log accessor + errorValue *string // Swappable error value wrapped by a log accessor + + ctx map[string]interface{} // Transaction context gathered throughout execution + err error // Error, if one has occurred + + interrupt uint32 // Atomic flag to signal execution interruption + reason error // Textual reason for the interruption +} + +// New instantiates a new tracer instance. code specifies a Javascript snippet, +// which must evaluate to an expression returning an object with 'step', 'fault' +// and 'result' functions. +func New(code string) (*Tracer, error) { + // Resolve any tracers by name and assemble the tracer object + if tracer, ok := tracer(code); ok { + code = tracer + } + tracer := &Tracer{ + vm: duktape.New(), + ctx: make(map[string]interface{}), + opWrapper: new(opWrapper), + stackWrapper: new(stackWrapper), + memoryWrapper: new(memoryWrapper), + contractWrapper: new(contractWrapper), + dbWrapper: new(dbWrapper), + pcValue: new(uint), + gasValue: new(uint), + costValue: new(uint), + depthValue: new(uint), + } + // Set up builtins for this environment + tracer.vm.PushGlobalGoFunction("toHex", func(ctx *duktape.Context) int { + ctx.PushString(hexutil.Encode(popSlice(ctx))) + return 1 + }) + tracer.vm.PushGlobalGoFunction("toWord", func(ctx *duktape.Context) int { + var word common.Hash + if ptr, size := ctx.GetBuffer(-1); ptr != nil { + word = common.BytesToHash(makeSlice(ptr, size)) + } else { + word = common.HexToHash(ctx.GetString(-1)) + } + ctx.Pop() + copy(makeSlice(ctx.PushFixedBuffer(32), 32), word[:]) + return 1 + }) + tracer.vm.PushGlobalGoFunction("toAddress", func(ctx *duktape.Context) int { + var addr common.Address + if ptr, size := ctx.GetBuffer(-1); ptr != nil { + addr = common.BytesToAddress(makeSlice(ptr, size)) + } else { + addr = common.HexToAddress(ctx.GetString(-1)) + } + ctx.Pop() + copy(makeSlice(ctx.PushFixedBuffer(20), 20), addr[:]) + return 1 + }) + tracer.vm.PushGlobalGoFunction("toContract", func(ctx *duktape.Context) int { + var from common.Address + if ptr, size := ctx.GetBuffer(-2); ptr != nil { + from = common.BytesToAddress(makeSlice(ptr, size)) + } else { + from = common.HexToAddress(ctx.GetString(-2)) + } + nonce := uint64(ctx.GetInt(-1)) + ctx.Pop2() + + contract := crypto.CreateAddress(from, nonce) + copy(makeSlice(ctx.PushFixedBuffer(20), 20), contract[:]) + return 1 + }) + tracer.vm.PushGlobalGoFunction("isPrecompiled", func(ctx *duktape.Context) int { + _, ok := vm.PrecompiledContractsByzantium[common.BytesToAddress(popSlice(ctx))] + ctx.PushBoolean(ok) + return 1 + }) + tracer.vm.PushGlobalGoFunction("slice", func(ctx *duktape.Context) int { + start, end := ctx.GetInt(-2), ctx.GetInt(-1) + ctx.Pop2() + + blob := popSlice(ctx) + size := end - start + + if start < 0 || start > end || end > len(blob) { + // TODO(karalabe): We can't js-throw from Go inside duktape inside Go. The Go + // runtime goes belly up https://github.com/golang/go/issues/15639. + log.Warn("Tracer accessed out of bound memory", "available", len(blob), "offset", start, "size", size) + ctx.PushFixedBuffer(0) + return 1 + } + copy(makeSlice(ctx.PushFixedBuffer(size), uint(size)), blob[start:end]) + return 1 + }) + // Push the JavaScript tracer as object #0 onto the JSVM stack and validate it + if err := tracer.vm.PevalString("(" + code + ")"); err != nil { + log.Warn("Failed to compile tracer", "err", err) + return nil, err + } + tracer.tracerObject = 0 // yeah, nice, eval can't return the index itself + + if !tracer.vm.GetPropString(tracer.tracerObject, "step") { + return nil, fmt.Errorf("Trace object must expose a function step()") + } + tracer.vm.Pop() + + if !tracer.vm.GetPropString(tracer.tracerObject, "fault") { + return nil, fmt.Errorf("Trace object must expose a function fault()") + } + tracer.vm.Pop() + + if !tracer.vm.GetPropString(tracer.tracerObject, "result") { + return nil, fmt.Errorf("Trace object must expose a function result()") + } + tracer.vm.Pop() + + // Tracer is valid, inject the big int library to access large numbers + tracer.vm.EvalString(bigIntegerJS) + tracer.vm.PutGlobalString("bigInt") + + // Push the global environment state as object #1 into the JSVM stack + tracer.stateObject = tracer.vm.PushObject() + + logObject := tracer.vm.PushObject() + + tracer.opWrapper.pushObject(tracer.vm) + tracer.vm.PutPropString(logObject, "op") + + tracer.stackWrapper.pushObject(tracer.vm) + tracer.vm.PutPropString(logObject, "stack") + + tracer.memoryWrapper.pushObject(tracer.vm) + tracer.vm.PutPropString(logObject, "memory") + + tracer.contractWrapper.pushObject(tracer.vm) + tracer.vm.PutPropString(logObject, "contract") + + tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.pcValue); return 1 }) + tracer.vm.PutPropString(logObject, "getPC") + + tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.gasValue); return 1 }) + tracer.vm.PutPropString(logObject, "getGas") + + tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.costValue); return 1 }) + tracer.vm.PutPropString(logObject, "getCost") + + tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { ctx.PushUint(*tracer.depthValue); return 1 }) + tracer.vm.PutPropString(logObject, "getDepth") + + tracer.vm.PushGoFunction(func(ctx *duktape.Context) int { + if tracer.errorValue != nil { + ctx.PushString(*tracer.errorValue) + } else { + ctx.PushUndefined() + } + return 1 + }) + tracer.vm.PutPropString(logObject, "getError") + + tracer.vm.PutPropString(tracer.stateObject, "log") + + tracer.dbWrapper.pushObject(tracer.vm) + tracer.vm.PutPropString(tracer.stateObject, "db") + + return tracer, nil +} + +// Stop terminates execution of the tracer at the first opportune moment. +func (jst *Tracer) Stop(err error) { + jst.reason = err + atomic.StoreUint32(&jst.interrupt, 1) +} + +// call executes a method on a JS object, catching any errors, formatting and +// returning them as error objects. +func (jst *Tracer) call(method string, args ...string) (json.RawMessage, error) { + // Execute the JavaScript call and return any error + jst.vm.PushString(method) + for _, arg := range args { + jst.vm.GetPropString(jst.stateObject, arg) + } + code := jst.vm.PcallProp(jst.tracerObject, len(args)) + defer jst.vm.Pop() + + if code != 0 { + err := jst.vm.SafeToString(-1) + return nil, errors.New(err) + } + // No error occurred, extract return value and return + return json.RawMessage(jst.vm.JsonEncode(-1)), nil +} + +func wrapError(context string, err error) error { + var message string + switch err := err.(type) { + default: + message = err.Error() + } + return fmt.Errorf("%v in server-side tracer function '%v'", message, context) +} + +// CaptureStart implements the Tracer interface to initialize the tracing operation. +func (jst *Tracer) CaptureStart(from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) error { + jst.ctx["type"] = "CALL" + if create { + jst.ctx["type"] = "CREATE" + } + jst.ctx["from"] = from + jst.ctx["to"] = to + jst.ctx["input"] = input + jst.ctx["gas"] = gas + jst.ctx["value"] = value + + return nil +} + +// CaptureState implements the Tracer interface to trace a single step of VM execution. +func (jst *Tracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { + if jst.err == nil { + // Initialize the context if it wasn't done yet + if !jst.inited { + jst.ctx["block"] = env.BlockNumber.Uint64() + jst.inited = true + } + // If tracing was interrupted, set the error and stop + if atomic.LoadUint32(&jst.interrupt) > 0 { + jst.err = jst.reason + return nil + } + jst.opWrapper.op = op + jst.stackWrapper.stack = stack + jst.memoryWrapper.memory = memory + jst.contractWrapper.contract = contract + jst.dbWrapper.db = env.StateDB + + *jst.pcValue = uint(pc) + *jst.gasValue = uint(gas) + *jst.costValue = uint(cost) + *jst.depthValue = uint(depth) + + jst.errorValue = nil + if err != nil { + jst.errorValue = new(string) + *jst.errorValue = err.Error() + } + _, err := jst.call("step", "log", "db") + if err != nil { + jst.err = wrapError("step", err) + } + } + return nil +} + +// CaptureFault implements the Tracer interface to trace an execution fault +// while running an opcode. +func (jst *Tracer) CaptureFault(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { + if jst.err == nil { + // Apart from the error, everything matches the previous invocation + jst.errorValue = new(string) + *jst.errorValue = err.Error() + + _, err := jst.call("fault", "log", "db") + if err != nil { + jst.err = wrapError("fault", err) + } + } + return nil +} + +// CaptureEnd is called after the call finishes to finalize the tracing. +func (jst *Tracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { + jst.ctx["output"] = output + jst.ctx["gasUsed"] = gasUsed + jst.ctx["time"] = t.String() + + if err != nil { + jst.ctx["error"] = err.Error() + } + return nil +} + +// GetResult calls the Javascript 'result' function and returns its value, or any accumulated error +func (jst *Tracer) GetResult() (json.RawMessage, error) { + // Transform the context into a JavaScript object and inject into the state + obj := jst.vm.PushObject() + + for key, val := range jst.ctx { + switch val := val.(type) { + case uint64: + jst.vm.PushUint(uint(val)) + + case string: + jst.vm.PushString(val) + + case []byte: + ptr := jst.vm.PushFixedBuffer(len(val)) + copy(makeSlice(ptr, uint(len(val))), val[:]) + + case common.Address: + ptr := jst.vm.PushFixedBuffer(20) + copy(makeSlice(ptr, 20), val[:]) + + case *big.Int: + pushBigInt(val, jst.vm) + + default: + panic(fmt.Sprintf("unsupported type: %T", val)) + } + jst.vm.PutPropString(obj, key) + } + jst.vm.PutPropString(jst.stateObject, "ctx") + + // Finalize the trace and return the results + result, err := jst.call("result", "ctx", "db") + if err != nil { + jst.err = wrapError("result", err) + } + // Clean up the JavaScript environment + jst.vm.DestroyHeap() + jst.vm.Destroy() + + return result, jst.err +} diff --git a/internal/ethapi/tracer_test.go b/eth/tracers/tracer_test.go similarity index 66% rename from internal/ethapi/tracer_test.go rename to eth/tracers/tracer_test.go index 5093dafd6e..7224a1489f 100644 --- a/internal/ethapi/tracer_test.go +++ b/eth/tracers/tracer_test.go @@ -14,12 +14,13 @@ // You should have received a copy of the GNU Lesser General Public License // along with the go-ethereum library. If not, see . -package ethapi +package tracers import ( + "bytes" + "encoding/json" "errors" "math/big" - "reflect" "testing" "time" @@ -42,22 +43,21 @@ func (account) ReturnGas(*big.Int) {} func (account) SetCode(common.Hash, []byte) {} func (account) ForEachStorage(cb func(key, value common.Hash) bool) {} -func runTrace(tracer *JavascriptTracer) (interface{}, error) { - env := vm.NewEVM(vm.Context{}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer}) +func runTrace(tracer *Tracer) (json.RawMessage, error) { + env := vm.NewEVM(vm.Context{BlockNumber: big.NewInt(1)}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer}) contract := vm.NewContract(account{}, account{}, big.NewInt(0), 10000) contract.Code = []byte{byte(vm.PUSH1), 0x1, byte(vm.PUSH1), 0x1, 0x0} - _, err := env.Interpreter().Run(0, contract, []byte{}) + _, err := env.Interpreter().Run(contract, []byte{}) if err != nil { return nil, err } - return tracer.GetResult() } func TestTracing(t *testing.T) { - tracer, err := NewJavascriptTracer("{count: 0, step: function() { this.count += 1; }, result: function() { return this.count; }}") + tracer, err := New("{count: 0, step: function() { this.count += 1; }, fault: function() {}, result: function() { return this.count; }}") if err != nil { t.Fatal(err) } @@ -66,18 +66,13 @@ func TestTracing(t *testing.T) { if err != nil { t.Fatal(err) } - - value, ok := ret.(float64) - if !ok { - t.Errorf("Expected return value to be float64, was %T", ret) - } - if value != 3 { - t.Errorf("Expected return value to be 3, got %v", value) + if !bytes.Equal(ret, []byte("3")) { + t.Errorf("Expected return value to be 3, got %s", string(ret)) } } func TestStack(t *testing.T) { - tracer, err := NewJavascriptTracer("{depths: [], step: function(log) { this.depths.push(log.stack.length()); }, result: function() { return this.depths; }}") + tracer, err := New("{depths: [], step: function(log) { this.depths.push(log.stack.length()); }, fault: function() {}, result: function() { return this.depths; }}") if err != nil { t.Fatal(err) } @@ -86,15 +81,13 @@ func TestStack(t *testing.T) { if err != nil { t.Fatal(err) } - - expected := []int{0, 1, 2} - if !reflect.DeepEqual(ret, expected) { - t.Errorf("Expected return value to be %#v, got %#v", expected, ret) + if !bytes.Equal(ret, []byte("[0,1,2]")) { + t.Errorf("Expected return value to be [0,1,2], got %s", string(ret)) } } func TestOpcodes(t *testing.T) { - tracer, err := NewJavascriptTracer("{opcodes: [], step: function(log) { this.opcodes.push(log.op.toString()); }, result: function() { return this.opcodes; }}") + tracer, err := New("{opcodes: [], step: function(log) { this.opcodes.push(log.op.toString()); }, fault: function() {}, result: function() { return this.opcodes; }}") if err != nil { t.Fatal(err) } @@ -103,16 +96,16 @@ func TestOpcodes(t *testing.T) { if err != nil { t.Fatal(err) } - - expected := []string{"PUSH1", "PUSH1", "STOP"} - if !reflect.DeepEqual(ret, expected) { - t.Errorf("Expected return value to be %#v, got %#v", expected, ret) + if !bytes.Equal(ret, []byte("[\"PUSH1\",\"PUSH1\",\"STOP\"]")) { + t.Errorf("Expected return value to be [\"PUSH1\",\"PUSH1\",\"STOP\"], got %s", string(ret)) } } func TestHalt(t *testing.T) { + t.Skip("duktape doesn't support abortion") + timeout := errors.New("stahp") - tracer, err := NewJavascriptTracer("{step: function() { while(1); }, result: function() { return null; }}") + tracer, err := New("{step: function() { while(1); }, result: function() { return null; }}") if err != nil { t.Fatal(err) } @@ -128,12 +121,12 @@ func TestHalt(t *testing.T) { } func TestHaltBetweenSteps(t *testing.T) { - tracer, err := NewJavascriptTracer("{step: function() {}, result: function() { return null; }}") + tracer, err := New("{step: function() {}, fault: function() {}, result: function() { return null; }}") if err != nil { t.Fatal(err) } - env := vm.NewEVM(vm.Context{}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer}) + env := vm.NewEVM(vm.Context{BlockNumber: big.NewInt(1)}, nil, params.TestChainConfig, vm.Config{Debug: true, Tracer: tracer}) contract := vm.NewContract(&account{}, &account{}, big.NewInt(0), 0) tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, contract, 0, nil) @@ -141,7 +134,7 @@ func TestHaltBetweenSteps(t *testing.T) { tracer.Stop(timeout) tracer.CaptureState(env, 0, 0, 0, 0, nil, nil, contract, 0, nil) - if _, err := tracer.GetResult(); err.Error() != "stahp in server-side tracer function 'step'" { + if _, err := tracer.GetResult(); err.Error() != timeout.Error() { t.Errorf("Expected timeout error, got %v", err) } } diff --git a/eth/tracers/tracers.go b/eth/tracers/tracers.go new file mode 100644 index 0000000000..4e1ef23ad2 --- /dev/null +++ b/eth/tracers/tracers.go @@ -0,0 +1,53 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// Package tracers is a collection of JavaScript transaction tracers. +package tracers + +import ( + "strings" + "unicode" + + "github.com/ethereum/go-ethereum/eth/tracers/internal/tracers" +) + +// all contains all the built in JavaScript tracers by name. +var all = make(map[string]string) + +// camel converts a snake cased input string into a camel cased output. +func camel(str string) string { + pieces := strings.Split(str, "_") + for i := 1; i < len(pieces); i++ { + pieces[i] = string(unicode.ToUpper(rune(pieces[i][0]))) + pieces[i][1:] + } + return strings.Join(pieces, "") +} + +// init retrieves the JavaScript transaction tracers included in go-ethereum. +func init() { + for _, file := range tracers.AssetNames() { + name := camel(strings.TrimSuffix(file, ".js")) + all[name] = string(tracers.MustAsset(file)) + } +} + +// tracer retrieves a specific JavaScript tracer by name. +func tracer(name string) (string, bool) { + if tracer, ok := all[name]; ok { + return tracer, true + } + return "", false +} diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go new file mode 100644 index 0000000000..bf8120228f --- /dev/null +++ b/eth/tracers/tracers_test.go @@ -0,0 +1,194 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package tracers + +import ( + "encoding/json" + "io/ioutil" + "math/big" + "path/filepath" + "reflect" + "strings" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/rlp" + "github.com/ethereum/go-ethereum/tests" +) + +// To generate a new callTracer test, copy paste the makeTest method below into +// a Geth console and call it with a transaction hash you which to export. + +/* +// makeTest generates a callTracer test by running a prestate reassembled and a +// call trace run, assembling all the gathered information into a test case. +var makeTest = function(tx, rewind) { + // Generate the genesis block from the block, transaction and prestate data + var block = eth.getBlock(eth.getTransaction(tx).blockHash); + var genesis = eth.getBlock(block.parentHash); + + delete genesis.gasUsed; + delete genesis.logsBloom; + delete genesis.parentHash; + delete genesis.receiptsRoot; + delete genesis.sha3Uncles; + delete genesis.size; + delete genesis.transactions; + delete genesis.transactionsRoot; + delete genesis.uncles; + + genesis.gasLimit = genesis.gasLimit.toString(); + genesis.number = genesis.number.toString(); + genesis.timestamp = genesis.timestamp.toString(); + + genesis.alloc = debug.traceTransaction(tx, {tracer: "prestateTracer", rewind: rewind}); + for (var key in genesis.alloc) { + genesis.alloc[key].nonce = genesis.alloc[key].nonce.toString(); + } + genesis.config = admin.nodeInfo.protocols.eth.config; + + // Generate the call trace and produce the test input + var result = debug.traceTransaction(tx, {tracer: "callTracer", rewind: rewind}); + delete result.time; + + console.log(JSON.stringify({ + genesis: genesis, + context: { + number: block.number.toString(), + difficulty: block.difficulty, + timestamp: block.timestamp.toString(), + gasLimit: block.gasLimit.toString(), + miner: block.miner, + }, + input: eth.getRawTransaction(tx), + result: result, + }, null, 2)); +} +*/ + +// callTrace is the result of a callTracer run. +type callTrace struct { + Type string `json:"type"` + From common.Address `json:"from"` + To common.Address `json:"to"` + Input hexutil.Bytes `json:"input"` + Output hexutil.Bytes `json:"output"` + Gas *hexutil.Uint64 `json:"gas,omitempty"` + GasUsed *hexutil.Uint64 `json:"gasUsed,omitempty"` + Value *hexutil.Big `json:"value,omitempty"` + Error string `json:"error,omitempty"` + Calls []callTrace `json:"calls,omitempty"` +} + +type callContext struct { + Number math.HexOrDecimal64 `json:"number"` + Difficulty *math.HexOrDecimal256 `json:"difficulty"` + Time math.HexOrDecimal64 `json:"timestamp"` + GasLimit math.HexOrDecimal64 `json:"gasLimit"` + Miner common.Address `json:"miner"` +} + +// callTracerTest defines a single test to check the call tracer against. +type callTracerTest struct { + Genesis *core.Genesis `json:"genesis"` + Context *callContext `json:"context"` + Input string `json:"input"` + Result *callTrace `json:"result"` +} + +// Iterates over all the input-output datasets in the tracer test harness and +// runs the JavaScript tracers against them. +func TestCallTracer(t *testing.T) { + files, err := ioutil.ReadDir("testdata") + if err != nil { + t.Fatalf("failed to retrieve tracer test suite: %v", err) + } + for _, file := range files { + if !strings.HasPrefix(file.Name(), "call_tracer_") { + continue + } + file := file // capture range variable + t.Run(camel(strings.TrimSuffix(strings.TrimPrefix(file.Name(), "call_tracer_"), ".json")), func(t *testing.T) { + t.Parallel() + + // Call tracer test found, read if from disk + blob, err := ioutil.ReadFile(filepath.Join("testdata", file.Name())) + if err != nil { + t.Fatalf("failed to read testcase: %v", err) + } + test := new(callTracerTest) + if err := json.Unmarshal(blob, test); err != nil { + t.Fatalf("failed to parse testcase: %v", err) + } + // Configure a blockchain with the given prestate + tx := new(types.Transaction) + if err := rlp.DecodeBytes(common.FromHex(test.Input), tx); err != nil { + t.Fatalf("failed to parse testcase input: %v", err) + } + signer := types.MakeSigner(test.Genesis.Config, new(big.Int).SetUint64(uint64(test.Context.Number))) + origin, _ := signer.Sender(tx) + + context := vm.Context{ + CanTransfer: core.CanTransfer, + Transfer: core.Transfer, + Origin: origin, + Coinbase: test.Context.Miner, + BlockNumber: new(big.Int).SetUint64(uint64(test.Context.Number)), + Time: new(big.Int).SetUint64(uint64(test.Context.Time)), + Difficulty: (*big.Int)(test.Context.Difficulty), + GasLimit: uint64(test.Context.GasLimit), + GasPrice: tx.GasPrice(), + } + db, _ := ethdb.NewMemDatabase() + statedb := tests.MakePreState(db, test.Genesis.Alloc) + + // Create the tracer, the EVM environment and run it + tracer, err := New("callTracer") + if err != nil { + t.Fatalf("failed to create call tracer: %v", err) + } + evm := vm.NewEVM(context, statedb, test.Genesis.Config, vm.Config{Debug: true, Tracer: tracer}) + + msg, err := tx.AsMessage(signer) + if err != nil { + t.Fatalf("failed to prepare transaction for tracing: %v", err) + } + st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas())) + if _, _, _, err = st.TransitionDb(); err != nil { + t.Fatalf("failed to execute transaction: %v", err) + } + // Retrieve the trace result and compare against the etalon + res, err := tracer.GetResult() + if err != nil { + t.Fatalf("failed to retrieve trace result: %v", err) + } + ret := new(callTrace) + if err := json.Unmarshal(res, ret); err != nil { + t.Fatalf("failed to unmarshal trace result: %v", err) + } + if !reflect.DeepEqual(ret, test.Result) { + t.Fatalf("trace mismatch: have %+v, want %+v", ret, test.Result) + } + }) + } +} diff --git a/ethclient/ethclient.go b/ethclient/ethclient.go index 7f73ab113c..87a912901a 100644 --- a/ethclient/ethclient.go +++ b/ethclient/ethclient.go @@ -455,13 +455,13 @@ func (ec *Client) SuggestGasPrice(ctx context.Context) (*big.Int, error) { // the current pending state of the backend blockchain. There is no guarantee that this is // the true gas limit requirement as other transactions may be added or removed by miners, // but it should provide a basis for setting a reasonable default. -func (ec *Client) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (*big.Int, error) { - var hex hexutil.Big +func (ec *Client) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) { + var hex hexutil.Uint64 err := ec.c.CallContext(ctx, &hex, "eth_estimateGas", toCallArg(msg)) if err != nil { - return nil, err + return 0, err } - return (*big.Int)(&hex), nil + return uint64(hex), nil } // SendTransaction injects a signed transaction into the pending pool for execution. @@ -487,8 +487,8 @@ func toCallArg(msg ethereum.CallMsg) interface{} { if msg.Value != nil { arg["value"] = (*hexutil.Big)(msg.Value) } - if msg.Gas != nil { - arg["gas"] = (*hexutil.Big)(msg.Gas) + if msg.Gas != 0 { + arg["gas"] = hexutil.Uint64(msg.Gas) } if msg.GasPrice != nil { arg["gasPrice"] = (*hexutil.Big)(msg.GasPrice) diff --git a/ethdb/memory_database.go b/ethdb/memory_database.go index 699bd0c9fd..0dd93a2791 100644 --- a/ethdb/memory_database.go +++ b/ethdb/memory_database.go @@ -37,6 +37,12 @@ func NewMemDatabase() (*MemDatabase, error) { }, nil } +func NewMemDatabaseWithCap(size int) (*MemDatabase, error) { + return &MemDatabase{ + db: make(map[string][]byte, size), + }, nil +} + func (db *MemDatabase) Put(key []byte, value []byte) error { db.lock.Lock() defer db.lock.Unlock() @@ -74,14 +80,6 @@ func (db *MemDatabase) Keys() [][]byte { return keys } -/* -func (db *MemDatabase) GetKeys() []*common.Key { - data, _ := db.Get([]byte("KeyRing")) - - return []*common.Key{common.NewKeyFromBytes(data)} -} -*/ - func (db *MemDatabase) Delete(key []byte) error { db.lock.Lock() defer db.lock.Unlock() @@ -96,6 +94,8 @@ func (db *MemDatabase) NewBatch() Batch { return &memBatch{db: db} } +func (db *MemDatabase) Len() int { return len(db.db) } + type kv struct{ k, v []byte } type memBatch struct { diff --git a/ethstats/ethstats.go b/ethstats/ethstats.go index 7065d71629..8204750be0 100644 --- a/ethstats/ethstats.go +++ b/ethstats/ethstats.go @@ -374,10 +374,10 @@ func (s *Service) login(conn *websocket.Conn) error { var network, protocol string if info := infos.Protocols["eth"]; info != nil { - network = fmt.Sprintf("%d", info.(*eth.EthNodeInfo).Network) + network = fmt.Sprintf("%d", info.(*eth.NodeInfo).Network) protocol = fmt.Sprintf("eth/%d", eth.ProtocolVersions[0]) } else { - network = fmt.Sprintf("%d", infos.Protocols["les"].(*eth.EthNodeInfo).Network) + network = fmt.Sprintf("%d", infos.Protocols["les"].(*les.NodeInfo).Network) protocol = fmt.Sprintf("les/%d", les.ClientProtocolVersions[0]) } auth := &authMsg{ @@ -473,8 +473,8 @@ type blockStats struct { ParentHash common.Hash `json:"parentHash"` Timestamp *big.Int `json:"timestamp"` Miner common.Address `json:"miner"` - GasUsed *big.Int `json:"gasUsed"` - GasLimit *big.Int `json:"gasLimit"` + GasUsed uint64 `json:"gasUsed"` + GasLimit uint64 `json:"gasLimit"` Diff string `json:"difficulty"` TotalDiff string `json:"totalDifficulty"` Txs []txStats `json:"transactions"` @@ -559,8 +559,8 @@ func (s *Service) assembleBlockStats(block *types.Block) *blockStats { ParentHash: header.ParentHash, Timestamp: header.Time, Miner: author, - GasUsed: new(big.Int).Set(header.GasUsed), - GasLimit: new(big.Int).Set(header.GasLimit), + GasUsed: header.GasUsed, + GasLimit: header.GasLimit, Diff: header.Difficulty.String(), TotalDiff: td.String(), Txs: txs, diff --git a/interfaces.go b/interfaces.go index 67f236ef75..1ae1eba48a 100644 --- a/interfaces.go +++ b/interfaces.go @@ -115,7 +115,7 @@ type ChainSyncReader interface { type CallMsg struct { From common.Address // the sender of the 'transaction' To *common.Address // the destination contract (nil for contract creation) - Gas *big.Int // if nil, the call executes with near-infinite gas + Gas uint64 // if 0, the call executes with near-infinite gas GasPrice *big.Int // wei <-> gas exchange ratio Value *big.Int // amount of wei sent along with the call Data []byte // input data, usually an ABI-encoded contract method invocation @@ -200,7 +200,7 @@ type PendingContractCaller interface { // true gas limit requirement as other transactions may be added or removed by miners, but // it should provide a basis for setting a reasonable default. type GasEstimator interface { - EstimateGas(ctx context.Context, call CallMsg) (usedGas *big.Int, err error) + EstimateGas(ctx context.Context, call CallMsg) (uint64, error) } // A PendingStateEventer provides access to real time notifications about changes to the diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index fe0ed81707..55bd5aa1ba 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -17,6 +17,7 @@ package ethapi import ( + "bytes" "context" "errors" "fmt" @@ -44,7 +45,6 @@ import ( ) const ( - defaultGas = 90000 defaultGasPrice = 50 * params.Shannon ) @@ -574,18 +574,18 @@ func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.A type CallArgs struct { From common.Address `json:"from"` To *common.Address `json:"to"` - Gas hexutil.Big `json:"gas"` + Gas hexutil.Uint64 `json:"gas"` GasPrice hexutil.Big `json:"gasPrice"` Value hexutil.Big `json:"value"` Data hexutil.Bytes `json:"data"` } -func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr rpc.BlockNumber, vmCfg vm.Config) ([]byte, *big.Int, bool, error) { +func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr rpc.BlockNumber, vmCfg vm.Config) ([]byte, uint64, bool, error) { defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) state, header, err := s.b.StateAndHeaderByNumber(ctx, blockNr) if state == nil || err != nil { - return nil, common.Big0, false, err + return nil, 0, false, err } // Set sender address or use a default if none specified addr := args.From @@ -597,9 +597,9 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr } } // Set default gas & gas price if none were set - gas, gasPrice := args.Gas.ToInt(), args.GasPrice.ToInt() - if gas.Sign() == 0 { - gas = big.NewInt(50000000) + gas, gasPrice := uint64(args.Gas), args.GasPrice.ToInt() + if gas == 0 { + gas = 50000000 } if gasPrice.Sign() == 0 { gasPrice = new(big.Int).SetUint64(defaultGasPrice) @@ -623,7 +623,7 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr // Get a new instance of the EVM. evm, vmError, err := s.b.GetEVM(ctx, msg, state, header, vmCfg) if err != nil { - return nil, common.Big0, false, err + return nil, 0, false, err } // Wait for the context to be done and cancel the evm. Even if the // EVM has finished, cancelling may be done (repeatedly) @@ -634,10 +634,10 @@ func (s *PublicBlockChainAPI) doCall(ctx context.Context, args CallArgs, blockNr // Setup the gas pool (also for unmetered requests) // and apply the message. - gp := new(core.GasPool).AddGas(math.MaxBig256) + gp := new(core.GasPool).AddGas(math.MaxUint64) res, gas, failed, err := core.ApplyMessage(evm, msg, gp) if err := vmError(); err != nil { - return nil, common.Big0, false, err + return nil, 0, false, err } return res, gas, failed, err } @@ -651,28 +651,29 @@ func (s *PublicBlockChainAPI) Call(ctx context.Context, args CallArgs, blockNr r // EstimateGas returns an estimate of the amount of gas needed to execute the // given transaction against the current pending block. -func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (*hexutil.Big, error) { - // Determine the lowest and highest possible gas limits to binary search in between +func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (hexutil.Uint64, error) { + // Binary search the gas requirement, as it may be higher than the amount used var ( lo uint64 = params.TxGas - 1 hi uint64 cap uint64 ) - if (*big.Int)(&args.Gas).Uint64() >= params.TxGas { - hi = (*big.Int)(&args.Gas).Uint64() + if uint64(args.Gas) >= params.TxGas { + hi = uint64(args.Gas) } else { // Retrieve the current pending block to act as the gas ceiling block, err := s.b.BlockByNumber(ctx, rpc.PendingBlockNumber) if err != nil { - return nil, err + return 0, err } - hi = block.GasLimit().Uint64() + hi = block.GasLimit() } cap = hi // Create a helper to check if a gas allowance results in an executable transaction executable := func(gas uint64) bool { - (*big.Int)(&args.Gas).SetUint64(gas) + args.Gas = hexutil.Uint64(gas) + _, _, failed, err := s.doCall(ctx, args, rpc.PendingBlockNumber, vm.Config{}) if err != nil || failed { return false @@ -691,17 +692,17 @@ func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (* // Reject the transaction as invalid if it still fails at the highest allowance if hi == cap { if !executable(hi) { - return nil, fmt.Errorf("gas required exceeds allowance or always failing transaction") + return 0, fmt.Errorf("gas required exceeds allowance or always failing transaction") } } - return (*hexutil.Big)(new(big.Int).SetUint64(hi)), nil + return hexutil.Uint64(hi), nil } // ExecutionResult groups all structured logs emitted by the EVM // while replaying a transaction in debug mode as well as transaction // execution status, the amount of gas used and the return value type ExecutionResult struct { - Gas *big.Int `json:"gas"` + Gas uint64 `json:"gas"` Failed bool `json:"failed"` ReturnValue string `json:"returnValue"` StructLogs []StructLogRes `json:"structLogs"` @@ -777,8 +778,8 @@ func (s *PublicBlockChainAPI) rpcOutputBlock(b *types.Block, inclTx bool, fullTx "totalDifficulty": (*hexutil.Big)(s.b.GetTd(b.Hash())), "extraData": hexutil.Bytes(head.Extra), "size": hexutil.Uint64(uint64(b.Size().Int64())), - "gasLimit": (*hexutil.Big)(head.GasLimit), - "gasUsed": (*hexutil.Big)(head.GasUsed), + "gasLimit": hexutil.Uint64(head.GasLimit), + "gasUsed": hexutil.Uint64(head.GasUsed), "timestamp": (*hexutil.Big)(head.Time), "transactionsRoot": head.TxHash, "receiptsRoot": head.ReceiptHash, @@ -821,7 +822,7 @@ type RPCTransaction struct { BlockHash common.Hash `json:"blockHash"` BlockNumber *hexutil.Big `json:"blockNumber"` From common.Address `json:"from"` - Gas *hexutil.Big `json:"gas"` + Gas hexutil.Uint64 `json:"gas"` GasPrice *hexutil.Big `json:"gasPrice"` Hash common.Hash `json:"hash"` Input hexutil.Bytes `json:"input"` @@ -846,7 +847,7 @@ func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber result := &RPCTransaction{ From: from, - Gas: (*hexutil.Big)(tx.Gas()), + Gas: hexutil.Uint64(tx.Gas()), GasPrice: (*hexutil.Big)(tx.GasPrice()), Hash: tx.Hash(), Input: hexutil.Bytes(tx.Data()), @@ -1003,9 +1004,12 @@ func (s *PublicTransactionPoolAPI) GetRawTransactionByHash(ctx context.Context, func (s *PublicTransactionPoolAPI) GetTransactionReceipt(hash common.Hash) (map[string]interface{}, error) { tx, blockHash, blockNumber, index := core.GetTransaction(s.b.ChainDb(), hash) if tx == nil { - return nil, nil + return nil, errors.New("unknown transaction") } receipt, _, _, _ := core.GetReceipt(s.b.ChainDb(), hash) // Old receipts don't have the lookup data available + if receipt == nil { + return nil, errors.New("unknown receipt") + } var signer types.Signer = types.FrontierSigner{} if tx.Protected() { @@ -1020,8 +1024,8 @@ func (s *PublicTransactionPoolAPI) GetTransactionReceipt(hash common.Hash) (map[ "transactionIndex": hexutil.Uint64(index), "from": from, "to": tx.To(), - "gasUsed": (*hexutil.Big)(receipt.GasUsed), - "cumulativeGasUsed": (*hexutil.Big)(receipt.CumulativeGasUsed), + "gasUsed": hexutil.Uint64(receipt.GasUsed), + "cumulativeGasUsed": hexutil.Uint64(receipt.CumulativeGasUsed), "contractAddress": nil, "logs": receipt.Logs, "logsBloom": receipt.Bloom, @@ -1064,17 +1068,21 @@ func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transacti type SendTxArgs struct { From common.Address `json:"from"` To *common.Address `json:"to"` - Gas *hexutil.Big `json:"gas"` + Gas *hexutil.Uint64 `json:"gas"` GasPrice *hexutil.Big `json:"gasPrice"` Value *hexutil.Big `json:"value"` - Data hexutil.Bytes `json:"data"` Nonce *hexutil.Uint64 `json:"nonce"` + // We accept "data" and "input" for backwards-compatibility reasons. "input" is the + // newer name and should be preferred by clients. + Data *hexutil.Bytes `json:"data"` + Input *hexutil.Bytes `json:"input"` } // setDefaults is a helper function that fills in default values for unspecified tx fields. func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error { if args.Gas == nil { - args.Gas = (*hexutil.Big)(big.NewInt(defaultGas)) + args.Gas = new(hexutil.Uint64) + *(*uint64)(args.Gas) = 90000 } if args.GasPrice == nil { price, err := b.SuggestPrice(ctx) @@ -1093,14 +1101,23 @@ func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error { } args.Nonce = (*hexutil.Uint64)(&nonce) } + if args.Data != nil && args.Input != nil && !bytes.Equal(*args.Data, *args.Input) { + return errors.New(`Both "data" and "input" are set and not equal. Please use "input" to pass transaction call data.`) + } return nil } func (args *SendTxArgs) toTransaction() *types.Transaction { - if args.To == nil { - return types.NewContractCreation(uint64(*args.Nonce), (*big.Int)(args.Value), (*big.Int)(args.Gas), (*big.Int)(args.GasPrice), args.Data) + var input []byte + if args.Data != nil { + input = *args.Data + } else if args.Input != nil { + input = *args.Input } - return types.NewTransaction(uint64(*args.Nonce), *args.To, (*big.Int)(args.Value), (*big.Int)(args.Gas), (*big.Int)(args.GasPrice), args.Data) + if args.To == nil { + return types.NewContractCreation(uint64(*args.Nonce), (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input) + } + return types.NewTransaction(uint64(*args.Nonce), *args.To, (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input) } // submitTransaction is a helper function that submits tx to txPool and logs a message. @@ -1248,7 +1265,7 @@ func (s *PublicTransactionPoolAPI) PendingTransactions() ([]*RPCTransaction, err // Resend accepts an existing transaction and a new gas price and limit. It will remove // the given transaction from the pool and reinsert it with the new gas price and limit. -func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxArgs, gasPrice, gasLimit *hexutil.Big) (common.Hash, error) { +func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error) { if sendArgs.Nonce == nil { return common.Hash{}, fmt.Errorf("missing transaction nonce in transaction spec") } diff --git a/internal/ethapi/backend.go b/internal/ethapi/backend.go index 368fa48726..af95d7906f 100644 --- a/internal/ethapi/backend.go +++ b/internal/ethapi/backend.go @@ -37,13 +37,14 @@ import ( // Backend interface provides the common API services (that are provided by // both full and light clients) with access to necessary functions. type Backend interface { - // general Ethereum API + // General Ethereum API Downloader() *downloader.Downloader ProtocolVersion() int SuggestPrice(ctx context.Context) (*big.Int, error) ChainDb() ethdb.Database EventMux() *event.TypeMux AccountManager() *accounts.Manager + // BlockChain API SetHead(number uint64) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) diff --git a/internal/ethapi/tracer.go b/internal/ethapi/tracer.go deleted file mode 100644 index 71cafc6e97..0000000000 --- a/internal/ethapi/tracer.go +++ /dev/null @@ -1,364 +0,0 @@ -// Copyright 2016 The go-ethereum Authors -// This file is part of the go-ethereum library. -// -// The go-ethereum library is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// The go-ethereum library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with the go-ethereum library. If not, see . - -package ethapi - -import ( - "encoding/json" - "errors" - "fmt" - "math/big" - "time" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/hexutil" - "github.com/ethereum/go-ethereum/core/vm" - "github.com/robertkrimen/otto" -) - -// fakeBig is used to provide an interface to Javascript for 'big.NewInt' -type fakeBig struct{} - -// NewInt creates a new big.Int with the specified int64 value. -func (fb *fakeBig) NewInt(x int64) *big.Int { - return big.NewInt(x) -} - -// OpCodeWrapper provides a JavaScript-friendly wrapper around OpCode, to convince Otto to treat it -// as an object, instead of a number. -type opCodeWrapper struct { - op vm.OpCode -} - -// toNumber returns the ID of this opcode as an integer -func (ocw *opCodeWrapper) toNumber() int { - return int(ocw.op) -} - -// toString returns the string representation of the opcode -func (ocw *opCodeWrapper) toString() string { - return ocw.op.String() -} - -// isPush returns true if the op is a Push -func (ocw *opCodeWrapper) isPush() bool { - return ocw.op.IsPush() -} - -// MarshalJSON serializes the opcode as JSON -func (ocw *opCodeWrapper) MarshalJSON() ([]byte, error) { - return json.Marshal(ocw.op.String()) -} - -// toValue returns an otto.Value for the opCodeWrapper -func (ocw *opCodeWrapper) toValue(vm *otto.Otto) otto.Value { - value, _ := vm.ToValue(ocw) - obj := value.Object() - obj.Set("toNumber", ocw.toNumber) - obj.Set("toString", ocw.toString) - obj.Set("isPush", ocw.isPush) - return value -} - -// memoryWrapper provides a JS wrapper around vm.Memory -type memoryWrapper struct { - memory *vm.Memory -} - -// slice returns the requested range of memory as a byte slice -func (mw *memoryWrapper) slice(begin, end int64) []byte { - return mw.memory.Get(begin, end-begin) -} - -// getUint returns the 32 bytes at the specified address interpreted -// as an unsigned integer -func (mw *memoryWrapper) getUint(addr int64) *big.Int { - ret := big.NewInt(0) - ret.SetBytes(mw.memory.GetPtr(addr, 32)) - return ret -} - -// toValue returns an otto.Value for the memoryWrapper -func (mw *memoryWrapper) toValue(vm *otto.Otto) otto.Value { - value, _ := vm.ToValue(mw) - obj := value.Object() - obj.Set("slice", mw.slice) - obj.Set("getUint", mw.getUint) - return value -} - -// stackWrapper provides a JS wrapper around vm.Stack -type stackWrapper struct { - stack *vm.Stack -} - -// peek returns the nth-from-the-top element of the stack. -func (sw *stackWrapper) peek(idx int) *big.Int { - return sw.stack.Data()[len(sw.stack.Data())-idx-1] -} - -// length returns the length of the stack -func (sw *stackWrapper) length() int { - return len(sw.stack.Data()) -} - -// toValue returns an otto.Value for the stackWrapper -func (sw *stackWrapper) toValue(vm *otto.Otto) otto.Value { - value, _ := vm.ToValue(sw) - obj := value.Object() - obj.Set("peek", sw.peek) - obj.Set("length", sw.length) - return value -} - -// dbWrapper provides a JS wrapper around vm.Database -type dbWrapper struct { - db vm.StateDB -} - -// getBalance retrieves an account's balance -func (dw *dbWrapper) getBalance(addr []byte) *big.Int { - return dw.db.GetBalance(common.BytesToAddress(addr)) -} - -// getNonce retrieves an account's nonce -func (dw *dbWrapper) getNonce(addr []byte) uint64 { - return dw.db.GetNonce(common.BytesToAddress(addr)) -} - -// getCode retrieves an account's code -func (dw *dbWrapper) getCode(addr []byte) []byte { - return dw.db.GetCode(common.BytesToAddress(addr)) -} - -// getState retrieves an account's state data for the given hash -func (dw *dbWrapper) getState(addr []byte, hash common.Hash) common.Hash { - return dw.db.GetState(common.BytesToAddress(addr), hash) -} - -// exists returns true iff the account exists -func (dw *dbWrapper) exists(addr []byte) bool { - return dw.db.Exist(common.BytesToAddress(addr)) -} - -// toValue returns an otto.Value for the dbWrapper -func (dw *dbWrapper) toValue(vm *otto.Otto) otto.Value { - value, _ := vm.ToValue(dw) - obj := value.Object() - obj.Set("getBalance", dw.getBalance) - obj.Set("getNonce", dw.getNonce) - obj.Set("getCode", dw.getCode) - obj.Set("getState", dw.getState) - obj.Set("exists", dw.exists) - return value -} - -// contractWrapper provides a JS wrapper around vm.Contract -type contractWrapper struct { - contract *vm.Contract -} - -func (c *contractWrapper) caller() common.Address { - return c.contract.Caller() -} - -func (c *contractWrapper) address() common.Address { - return c.contract.Address() -} - -func (c *contractWrapper) value() *big.Int { - return c.contract.Value() -} - -func (c *contractWrapper) calldata() []byte { - return c.contract.Input -} - -func (c *contractWrapper) toValue(vm *otto.Otto) otto.Value { - value, _ := vm.ToValue(c) - obj := value.Object() - obj.Set("caller", c.caller) - obj.Set("address", c.address) - obj.Set("value", c.value) - obj.Set("calldata", c.calldata) - return value -} - -// JavascriptTracer provides an implementation of Tracer that evaluates a -// Javascript function for each VM execution step. -type JavascriptTracer struct { - vm *otto.Otto // Javascript VM instance - traceobj *otto.Object // User-supplied object to call - op *opCodeWrapper // Wrapper around the VM opcode - log map[string]interface{} // (Reusable) map for the `log` arg to `step` - logvalue otto.Value // JS view of `log` - memory *memoryWrapper // Wrapper around the VM memory - stack *stackWrapper // Wrapper around the VM stack - db *dbWrapper // Wrapper around the VM environment - dbvalue otto.Value // JS view of `db` - contract *contractWrapper // Wrapper around the contract object - err error // Error, if one has occurred - result interface{} // Final result to return to the user -} - -// NewJavascriptTracer instantiates a new JavascriptTracer instance. -// code specifies a Javascript snippet, which must evaluate to an expression -// returning an object with 'step' and 'result' functions. -func NewJavascriptTracer(code string) (*JavascriptTracer, error) { - vm := otto.New() - vm.Interrupt = make(chan func(), 1) - - // Set up builtins for this environment - vm.Set("big", &fakeBig{}) - vm.Set("toHex", hexutil.Encode) - - jstracer, err := vm.Object("(" + code + ")") - if err != nil { - return nil, err - } - // Check the required functions exist - step, err := jstracer.Get("step") - if err != nil { - return nil, err - } - if !step.IsFunction() { - return nil, fmt.Errorf("Trace object must expose a function step()") - } - - result, err := jstracer.Get("result") - if err != nil { - return nil, err - } - if !result.IsFunction() { - return nil, fmt.Errorf("Trace object must expose a function result()") - } - // Create the persistent log object - var ( - op = new(opCodeWrapper) - mem = new(memoryWrapper) - stack = new(stackWrapper) - db = new(dbWrapper) - contract = new(contractWrapper) - ) - log := map[string]interface{}{ - "op": op.toValue(vm), - "memory": mem.toValue(vm), - "stack": stack.toValue(vm), - "contract": contract.toValue(vm), - } - logvalue, _ := vm.ToValue(log) - - return &JavascriptTracer{ - vm: vm, - traceobj: jstracer, - op: op, - log: log, - logvalue: logvalue, - memory: mem, - stack: stack, - db: db, - dbvalue: db.toValue(vm), - contract: contract, - err: nil, - }, nil -} - -// Stop terminates execution of any JavaScript -func (jst *JavascriptTracer) Stop(err error) { - jst.vm.Interrupt <- func() { - panic(err) - } -} - -// callSafely executes a method on a JS object, catching any panics and -// returning them as error objects. -func (jst *JavascriptTracer) callSafely(method string, argumentList ...interface{}) (ret interface{}, err error) { - defer func() { - if caught := recover(); caught != nil { - switch caught := caught.(type) { - case error: - err = caught - case string: - err = errors.New(caught) - case fmt.Stringer: - err = errors.New(caught.String()) - default: - panic(caught) - } - } - }() - - value, err := jst.traceobj.Call(method, argumentList...) - ret, _ = value.Export() - return ret, err -} - -func wrapError(context string, err error) error { - var message string - switch err := err.(type) { - case *otto.Error: - message = err.String() - default: - message = err.Error() - } - return fmt.Errorf("%v in server-side tracer function '%v'", message, context) -} - -// CaptureState implements the Tracer interface to trace a single step of VM execution -func (jst *JavascriptTracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, gas, cost uint64, memory *vm.Memory, stack *vm.Stack, contract *vm.Contract, depth int, err error) error { - if jst.err == nil { - jst.op.op = op - jst.memory.memory = memory - jst.stack.stack = stack - jst.db.db = env.StateDB - jst.contract.contract = contract - - jst.log["pc"] = pc - jst.log["gas"] = gas - jst.log["cost"] = cost - jst.log["depth"] = depth - jst.log["account"] = contract.Address() - - delete(jst.log, "error") - if err != nil { - jst.log["error"] = err - } - _, err := jst.callSafely("step", jst.logvalue, jst.dbvalue) - if err != nil { - jst.err = wrapError("step", err) - } - } - return nil -} - -// CaptureEnd is called after the call finishes -func (jst *JavascriptTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration, err error) error { - //TODO! @Arachnid please figure out of there's anything we can use this method for - return nil -} - -// GetResult calls the Javascript 'result' function and returns its value, or any accumulated error -func (jst *JavascriptTracer) GetResult() (result interface{}, err error) { - if jst.err != nil { - return nil, jst.err - } - - result, err = jst.callSafely("result") - if err != nil { - err = wrapError("result", err) - } - return -} diff --git a/internal/web3ext/web3ext.go b/internal/web3ext/web3ext.go index ef0d2b4e6e..e11aa402f5 100644 --- a/internal/web3ext/web3ext.go +++ b/internal/web3ext/web3ext.go @@ -196,26 +196,6 @@ web3._extend({ call: 'debug_setHead', params: 1 }), - new web3._extend.Method({ - name: 'traceBlock', - call: 'debug_traceBlock', - params: 1 - }), - new web3._extend.Method({ - name: 'traceBlockFromFile', - call: 'debug_traceBlockFromFile', - params: 1 - }), - new web3._extend.Method({ - name: 'traceBlockByNumber', - call: 'debug_traceBlockByNumber', - params: 1 - }), - new web3._extend.Method({ - name: 'traceBlockByHash', - call: 'debug_traceBlockByHash', - params: 1 - }), new web3._extend.Method({ name: 'seedHash', call: 'debug_seedHash', @@ -332,6 +312,30 @@ web3._extend({ call: 'debug_writeMemProfile', params: 1 }), + new web3._extend.Method({ + name: 'traceBlock', + call: 'debug_traceBlock', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'traceBlockFromFile', + call: 'debug_traceBlockFromFile', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'traceBlockByNumber', + call: 'debug_traceBlockByNumber', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'traceBlockByHash', + call: 'debug_traceBlockByHash', + params: 2, + inputFormatter: [null, null] + }), new web3._extend.Method({ name: 'traceTransaction', call: 'debug_traceTransaction', diff --git a/les/handler.go b/les/handler.go index 613fbb79fe..e310942ba0 100644 --- a/les/handler.go +++ b/les/handler.go @@ -32,7 +32,6 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth/downloader" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/event" @@ -73,6 +72,7 @@ func errResp(code errCode, format string, v ...interface{}) error { } type BlockChain interface { + Config() *params.ChainConfig HasHeader(hash common.Hash, number uint64) bool GetHeader(hash common.Hash, number uint64) *types.Header GetHeaderByHash(hash common.Hash) *types.Header @@ -454,14 +454,14 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { case query.Reverse: // Number based traversal towards the genesis block if query.Origin.Number >= query.Skip+1 { - query.Origin.Number -= (query.Skip + 1) + query.Origin.Number -= query.Skip + 1 } else { unknown = true } case !query.Reverse: // Number based traversal towards the leaf block - query.Origin.Number += (query.Skip + 1) + query.Origin.Number += query.Skip + 1 } } @@ -1123,12 +1123,23 @@ func (pm *ProtocolManager) txStatus(hashes []common.Hash) []txStatus { return stats } +// NodeInfo represents a short summary of the Ethereum sub-protocol metadata +// known about the host peer. +type NodeInfo struct { + Network uint64 `json:"network"` // Ethereum network ID (1=Frontier, 2=Morden, Ropsten=3, Rinkeby=4) + Difficulty *big.Int `json:"difficulty"` // Total difficulty of the host's blockchain + Genesis common.Hash `json:"genesis"` // SHA3 hash of the host's genesis block + Config *params.ChainConfig `json:"config"` // Chain configuration for the fork rules + Head common.Hash `json:"head"` // SHA3 hash of the host's best owned block +} + // NodeInfo retrieves some protocol metadata about the running host node. -func (self *ProtocolManager) NodeInfo() *eth.EthNodeInfo { - return ð.EthNodeInfo{ +func (self *ProtocolManager) NodeInfo() *NodeInfo { + return &NodeInfo{ Network: self.networkId, Difficulty: self.blockchain.GetTdByHash(self.blockchain.LastBlockHash()), Genesis: self.blockchain.Genesis().Hash(), + Config: self.blockchain.Config(), Head: self.blockchain.LastBlockHash(), } } diff --git a/les/handler_test.go b/les/handler_test.go index a9dac89b40..7d67af26a1 100644 --- a/les/handler_test.go +++ b/les/handler_test.go @@ -24,6 +24,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/consensus/ethash" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" @@ -442,16 +443,16 @@ func TestTransactionStatusLes2(t *testing.T) { signer := types.HomesteadSigner{} // test error status by sending an underpriced transaction - tx0, _ := types.SignTx(types.NewTransaction(0, acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), signer, testBankKey) + tx0, _ := types.SignTx(types.NewTransaction(0, acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) test(tx0, true, txStatus{Status: core.TxStatusUnknown, Error: core.ErrUnderpriced}) - tx1, _ := types.SignTx(types.NewTransaction(0, acc1Addr, big.NewInt(10000), bigTxGas, big.NewInt(100000000000), nil), signer, testBankKey) + tx1, _ := types.SignTx(types.NewTransaction(0, acc1Addr, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, testBankKey) test(tx1, false, txStatus{Status: core.TxStatusUnknown}) // query before sending, should be unknown test(tx1, true, txStatus{Status: core.TxStatusPending}) // send valid processable tx, should return pending test(tx1, true, txStatus{Status: core.TxStatusPending}) // adding it again should not return an error - tx2, _ := types.SignTx(types.NewTransaction(1, acc1Addr, big.NewInt(10000), bigTxGas, big.NewInt(100000000000), nil), signer, testBankKey) - tx3, _ := types.SignTx(types.NewTransaction(2, acc1Addr, big.NewInt(10000), bigTxGas, big.NewInt(100000000000), nil), signer, testBankKey) + tx2, _ := types.SignTx(types.NewTransaction(1, acc1Addr, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, testBankKey) + tx3, _ := types.SignTx(types.NewTransaction(2, acc1Addr, big.NewInt(10000), params.TxGas, big.NewInt(100000000000), nil), signer, testBankKey) // send transactions in the wrong order, tx3 should be queued test(tx3, true, txStatus{Status: core.TxStatusQueued}) test(tx2, true, txStatus{Status: core.TxStatusPending}) @@ -459,7 +460,7 @@ func TestTransactionStatusLes2(t *testing.T) { test(tx3, false, txStatus{Status: core.TxStatusPending}) // generate and add a block with tx1 and tx2 included - gchain, _ := core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), db, 1, func(i int, block *core.BlockGen) { + gchain, _ := core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), db, 1, func(i int, block *core.BlockGen) { block.AddTx(tx1) block.AddTx(tx2) }) @@ -483,7 +484,7 @@ func TestTransactionStatusLes2(t *testing.T) { test(tx2, false, txStatus{Status: core.TxStatusIncluded, Lookup: &core.TxLookupEntry{BlockHash: block1hash, BlockIndex: 1, Index: 1}}) // create a reorg that rolls them back - gchain, _ = core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), db, 2, func(i int, block *core.BlockGen) {}) + gchain, _ = core.GenerateChain(params.TestChainConfig, chain.GetBlockByNumber(0), ethash.NewFaker(), db, 2, func(i int, block *core.BlockGen) {}) if _, err := chain.InsertChain(gchain); err != nil { panic(err) } diff --git a/les/helper_test.go b/les/helper_test.go index a06f84ccac..b881b41ce8 100644 --- a/les/helper_test.go +++ b/les/helper_test.go @@ -56,8 +56,6 @@ var ( testContractDeployed = uint64(2) testBufLimit = uint64(100) - - bigTxGas = new(big.Int).SetUint64(params.TxGas) ) /* @@ -81,17 +79,17 @@ func testChainGen(i int, block *core.BlockGen) { switch i { case 0: // In block 1, the test bank sends account #1 some ether. - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) block.AddTx(tx) case 1: // In block 2, the test bank sends some more ether to account #1. // acc1Addr passes it on to account #2. // acc1Addr creates a test contract. - tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, testBankKey) + tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey) nonce := block.TxNonce(acc1Addr) - tx2, _ := types.SignTx(types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, acc1Key) + tx2, _ := types.SignTx(types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key) nonce++ - tx3, _ := types.SignTx(types.NewContractCreation(nonce, big.NewInt(0), big.NewInt(200000), big.NewInt(0), testContractCode), signer, acc1Key) + tx3, _ := types.SignTx(types.NewContractCreation(nonce, big.NewInt(0), 200000, big.NewInt(0), testContractCode), signer, acc1Key) testContractAddr = crypto.CreateAddress(acc1Addr, nonce) block.AddTx(tx1) block.AddTx(tx2) @@ -101,7 +99,7 @@ func testChainGen(i int, block *core.BlockGen) { block.SetCoinbase(acc2Addr) block.SetExtra([]byte("yeehaw")) data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001") - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) block.AddTx(tx) case 3: // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data). @@ -112,7 +110,7 @@ func testChainGen(i int, block *core.BlockGen) { b3.Extra = []byte("foo") block.AddUncle(b3) data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002") - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) block.AddTx(tx) } } @@ -149,7 +147,7 @@ func newTestProtocolManager(lightSync bool, blocks int, generator func(int, *cor chain, _ = light.NewLightChain(odr, gspec.Config, engine) } else { blockchain, _ := core.NewBlockChain(db, gspec.Config, engine, vm.Config{}) - gchain, _ := core.GenerateChain(gspec.Config, genesis, db, blocks, generator) + gchain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, blocks, generator) if _, err := blockchain.InsertChain(gchain); err != nil { panic(err) } diff --git a/les/odr_test.go b/les/odr_test.go index 865f5d83e5..cf609be882 100644 --- a/les/odr_test.go +++ b/les/odr_test.go @@ -129,13 +129,13 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai from := statedb.GetOrNewStateObject(testBankAddress) from.SetBalance(math.MaxBig256) - msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), big.NewInt(100000), new(big.Int), data, false)} + msg := callmsg{types.NewMessage(from.Address(), &testContractAddr, 0, new(big.Int), 100000, new(big.Int), data, false)} context := core.NewEVMContext(msg, header, bc, nil) vmenv := vm.NewEVM(context, statedb, config, vm.Config{}) //vmenv := core.NewEnv(statedb, config, bc, msg, header, vm.Config{}) - gp := new(core.GasPool).AddGas(math.MaxBig256) + gp := new(core.GasPool).AddGas(math.MaxUint64) ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp) res = append(res, ret...) } @@ -143,10 +143,10 @@ func odrContractCall(ctx context.Context, db ethdb.Database, config *params.Chai header := lc.GetHeaderByHash(bhash) state := light.NewState(ctx, header, lc.Odr()) state.SetBalance(testBankAddress, math.MaxBig256) - msg := callmsg{types.NewMessage(testBankAddress, &testContractAddr, 0, new(big.Int), big.NewInt(100000), new(big.Int), data, false)} + msg := callmsg{types.NewMessage(testBankAddress, &testContractAddr, 0, new(big.Int), 100000, new(big.Int), data, false)} context := core.NewEVMContext(msg, header, lc, nil) vmenv := vm.NewEVM(context, state, config, vm.Config{}) - gp := new(core.GasPool).AddGas(math.MaxBig256) + gp := new(core.GasPool).AddGas(math.MaxUint64) ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp) if state.Error() == nil { res = append(res, ret...) diff --git a/les/serverpool.go b/les/serverpool.go index dc1ea6bf02..a84c29c3ac 100644 --- a/les/serverpool.go +++ b/les/serverpool.go @@ -618,7 +618,7 @@ func (e *knownEntry) Weight() int64 { if e.state != psNotConnected || !e.known || e.delayedRetry { return 0 } - return int64(1000000000 * e.connectStats.recentAvg() * math.Exp(-float64(e.lastConnected.fails)*failDropLn-e.responseStats.recentAvg()/float64(responseScoreTC)-e.delayStats.recentAvg()/float64(delayScoreTC)) * math.Pow((1-e.timeoutStats.recentAvg()), timeoutPow)) + return int64(1000000000 * e.connectStats.recentAvg() * math.Exp(-float64(e.lastConnected.fails)*failDropLn-e.responseStats.recentAvg()/float64(responseScoreTC)-e.delayStats.recentAvg()/float64(delayScoreTC)) * math.Pow(1-e.timeoutStats.recentAvg(), timeoutPow)) } // poolEntryAddress is a separate object because currently it is necessary to remember diff --git a/light/lightchain.go b/light/lightchain.go index 30baeaccb7..03c7c1f0d0 100644 --- a/light/lightchain.go +++ b/light/lightchain.go @@ -169,7 +169,7 @@ func (bc *LightChain) SetHead(head uint64) { } // GasLimit returns the gas limit of the current HEAD block. -func (self *LightChain) GasLimit() *big.Int { +func (self *LightChain) GasLimit() uint64 { self.mu.RLock() defer self.mu.RUnlock() @@ -457,6 +457,9 @@ func (self *LightChain) GetHeaderByNumberOdr(ctx context.Context, number uint64) return GetHeaderByNumber(ctx, self.odr, number) } +// Config retrieves the header chain's chain configuration. +func (self *LightChain) Config() *params.ChainConfig { return self.hc.Config() } + func (self *LightChain) SyncCht(ctx context.Context) bool { if self.odr.ChtIndexer() == nil { return false diff --git a/light/lightchain_test.go b/light/lightchain_test.go index 40a4d396a8..0af7551d41 100644 --- a/light/lightchain_test.go +++ b/light/lightchain_test.go @@ -37,7 +37,7 @@ var ( // makeHeaderChain creates a deterministic chain of headers rooted at parent. func makeHeaderChain(parent *types.Header, n int, db ethdb.Database, seed int) []*types.Header { - blocks, _ := core.GenerateChain(params.TestChainConfig, types.NewBlockWithHeader(parent), db, n, func(i int, b *core.BlockGen) { + blocks, _ := core.GenerateChain(params.TestChainConfig, types.NewBlockWithHeader(parent), ethash.NewFaker(), db, n, func(i int, b *core.BlockGen) { b.SetCoinbase(common.Address{0: byte(seed), 19: byte(i)}) }) headers := make([]*types.Header, len(blocks)) diff --git a/light/odr_test.go b/light/odr_test.go index e6afb1a480..e3d07518a8 100644 --- a/light/odr_test.go +++ b/light/odr_test.go @@ -50,8 +50,6 @@ var ( testContractCode = common.Hex2Bytes("606060405260cc8060106000396000f360606040526000357c01000000000000000000000000000000000000000000000000000000009004806360cd2685146041578063c16431b914606b57603f565b005b6055600480803590602001909190505060a9565b6040518082815260200191505060405180910390f35b60886004808035906020019091908035906020019091905050608a565b005b80600060005083606481101560025790900160005b50819055505b5050565b6000600060005082606481101560025790900160005b5054905060c7565b91905056") testContractAddr common.Address - - bigTxGas = new(big.Int).SetUint64(params.TxGas) ) type testOdr struct { @@ -178,10 +176,10 @@ func odrContractCall(ctx context.Context, db ethdb.Database, bc *core.BlockChain // Perform read-only call. st.SetBalance(testBankAddress, math.MaxBig256) - msg := callmsg{types.NewMessage(testBankAddress, &testContractAddr, 0, new(big.Int), big.NewInt(1000000), new(big.Int), data, false)} + msg := callmsg{types.NewMessage(testBankAddress, &testContractAddr, 0, new(big.Int), 1000000, new(big.Int), data, false)} context := core.NewEVMContext(msg, header, chain, nil) vmenv := vm.NewEVM(context, st, config, vm.Config{}) - gp := new(core.GasPool).AddGas(math.MaxBig256) + gp := new(core.GasPool).AddGas(math.MaxUint64) ret, _, _, _ := core.ApplyMessage(vmenv, msg, gp) res = append(res, ret...) if st.Error() != nil { @@ -196,17 +194,17 @@ func testChainGen(i int, block *core.BlockGen) { switch i { case 0: // In block 1, the test bank sends account #1 some ether. - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), signer, testBankKey) block.AddTx(tx) case 1: // In block 2, the test bank sends some more ether to account #1. // acc1Addr passes it on to account #2. // acc1Addr creates a test contract. - tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, testBankKey) + tx1, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), acc1Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, testBankKey) nonce := block.TxNonce(acc1Addr) - tx2, _ := types.SignTx(types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), bigTxGas, nil, nil), signer, acc1Key) + tx2, _ := types.SignTx(types.NewTransaction(nonce, acc2Addr, big.NewInt(1000), params.TxGas, nil, nil), signer, acc1Key) nonce++ - tx3, _ := types.SignTx(types.NewContractCreation(nonce, big.NewInt(0), big.NewInt(1000000), big.NewInt(0), testContractCode), signer, acc1Key) + tx3, _ := types.SignTx(types.NewContractCreation(nonce, big.NewInt(0), 1000000, big.NewInt(0), testContractCode), signer, acc1Key) testContractAddr = crypto.CreateAddress(acc1Addr, nonce) block.AddTx(tx1) block.AddTx(tx2) @@ -216,7 +214,7 @@ func testChainGen(i int, block *core.BlockGen) { block.SetCoinbase(acc2Addr) block.SetExtra([]byte("yeehaw")) data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000001") - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) block.AddTx(tx) case 3: // Block 4 includes blocks 2 and 3 as uncle headers (with modified extra data). @@ -227,7 +225,7 @@ func testChainGen(i int, block *core.BlockGen) { b3.Extra = []byte("foo") block.AddUncle(b3) data := common.Hex2Bytes("C16431B900000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002") - tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), big.NewInt(100000), nil, data), signer, testBankKey) + tx, _ := types.SignTx(types.NewTransaction(block.TxNonce(testBankAddress), testContractAddr, big.NewInt(0), 100000, nil, data), signer, testBankKey) block.AddTx(tx) } } @@ -242,7 +240,7 @@ func testChainOdr(t *testing.T, protocol int, fn odrTestFn) { gspec.MustCommit(ldb) // Assemble the test environment blockchain, _ := core.NewBlockChain(sdb, params.TestChainConfig, ethash.NewFullFaker(), vm.Config{}) - gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, sdb, 4, testChainGen) + gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), sdb, 4, testChainGen) if _, err := blockchain.InsertChain(gchain); err != nil { t.Fatal(err) } diff --git a/light/trie.go b/light/trie.go index 7502b6e5dd..7a9c86b98d 100644 --- a/light/trie.go +++ b/light/trie.go @@ -151,7 +151,7 @@ func (t *odrTrie) do(key []byte, fn func() error) error { } r := &TrieRequest{Id: t.id, Key: key} if err := t.db.backend.Retrieve(t.db.ctx, r); err != nil { - return fmt.Errorf("can't fetch trie key %x: %v", key, err) + return err } } } diff --git a/light/trie_test.go b/light/trie_test.go index 5f45c01af9..d99664718f 100644 --- a/light/trie_test.go +++ b/light/trie_test.go @@ -41,7 +41,7 @@ func TestNodeIterator(t *testing.T) { ) gspec.MustCommit(lightdb) blockchain, _ := core.NewBlockChain(fulldb, params.TestChainConfig, ethash.NewFullFaker(), vm.Config{}) - gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, fulldb, 4, testChainGen) + gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), fulldb, 4, testChainGen) if _, err := blockchain.InsertChain(gchain); err != nil { panic(err) } diff --git a/light/txpool.go b/light/txpool.go index bd215b9928..ca41490bdc 100644 --- a/light/txpool.go +++ b/light/txpool.go @@ -358,7 +358,7 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error // Check the transaction doesn't exceed the current // block limit gas. header := pool.chain.GetHeaderByHash(pool.head) - if header.GasLimit.Cmp(tx.Gas()) < 0 { + if header.GasLimit < tx.Gas() { return core.ErrGasLimit } @@ -376,10 +376,13 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error } // Should supply enough intrinsic gas - if tx.Gas().Cmp(core.IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead)) < 0 { + gas, err := core.IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead) + if err != nil { + return err + } + if tx.Gas() < gas { return core.ErrIntrinsicGas } - return currentState.Error() } diff --git a/light/txpool_test.go b/light/txpool_test.go index fe7936ac28..b343f79b05 100644 --- a/light/txpool_test.go +++ b/light/txpool_test.go @@ -77,7 +77,7 @@ func txPoolTestChainGen(i int, block *core.BlockGen) { func TestTxPool(t *testing.T) { for i := range testTx { - testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), bigTxGas, nil, nil), types.HomesteadSigner{}, testBankKey) + testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey) } var ( @@ -89,7 +89,7 @@ func TestTxPool(t *testing.T) { gspec.MustCommit(ldb) // Assemble the test environment blockchain, _ := core.NewBlockChain(sdb, params.TestChainConfig, ethash.NewFullFaker(), vm.Config{}) - gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, sdb, poolTestBlocks, txPoolTestChainGen) + gchain, _ := core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), sdb, poolTestBlocks, txPoolTestChainGen) if _, err := blockchain.InsertChain(gchain); err != nil { panic(err) } diff --git a/miner/worker.go b/miner/worker.go index c1f848e327..638f759bf5 100644 --- a/miner/worker.go +++ b/miner/worker.go @@ -413,7 +413,6 @@ func (self *worker) commitNewWork() { ParentHash: parent.Hash(), Number: num.Add(num, common.Big1), GasLimit: core.CalcGasLimit(parent), - GasUsed: new(big.Int), Extra: self.extra, Time: big.NewInt(tstamp), } @@ -588,7 +587,7 @@ func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsB func (env *Work) commitTransaction(tx *types.Transaction, bc *core.BlockChain, coinbase common.Address, gp *core.GasPool) (error, []*types.Log) { snap := env.state.Snapshot() - receipt, _, err := core.ApplyTransaction(env.config, bc, &coinbase, gp, env.state, env.header, tx, env.header.GasUsed, vm.Config{}) + receipt, _, err := core.ApplyTransaction(env.config, bc, &coinbase, gp, env.state, env.header, tx, &env.header.GasUsed, vm.Config{}) if err != nil { env.state.RevertToSnapshot(snap) return err, nil diff --git a/mobile/bind.go b/mobile/bind.go index 7b79bedafd..1e861d0bcb 100644 --- a/mobile/bind.go +++ b/mobile/bind.go @@ -77,7 +77,7 @@ func (opts *TransactOpts) GetFrom() *Address { return &Address{opts.opts.From func (opts *TransactOpts) GetNonce() int64 { return opts.opts.Nonce.Int64() } func (opts *TransactOpts) GetValue() *BigInt { return &BigInt{opts.opts.Value} } func (opts *TransactOpts) GetGasPrice() *BigInt { return &BigInt{opts.opts.GasPrice} } -func (opts *TransactOpts) GetGasLimit() int64 { return opts.opts.GasLimit.Int64() } +func (opts *TransactOpts) GetGasLimit() int64 { return int64(opts.opts.GasLimit) } // GetSigner cannot be reliably implemented without identity preservation (https://github.com/golang/go/issues/16876) // func (opts *TransactOpts) GetSigner() Signer { return &signer{opts.opts.Signer} } @@ -99,7 +99,7 @@ func (opts *TransactOpts) SetSigner(s Signer) { } func (opts *TransactOpts) SetValue(value *BigInt) { opts.opts.Value = value.bigint } func (opts *TransactOpts) SetGasPrice(price *BigInt) { opts.opts.GasPrice = price.bigint } -func (opts *TransactOpts) SetGasLimit(limit int64) { opts.opts.GasLimit = big.NewInt(limit) } +func (opts *TransactOpts) SetGasLimit(limit int64) { opts.opts.GasLimit = uint64(limit) } func (opts *TransactOpts) SetContext(context *Context) { opts.opts.Context = context.context } // BoundContract is the base wrapper object that reflects a contract on the diff --git a/mobile/ethclient.go b/mobile/ethclient.go index 758863b6d9..66399c6b56 100644 --- a/mobile/ethclient.go +++ b/mobile/ethclient.go @@ -298,9 +298,9 @@ func (ec *EthereumClient) SuggestGasPrice(ctx *Context) (price *BigInt, _ error) // the current pending state of the backend blockchain. There is no guarantee that this is // the true gas limit requirement as other transactions may be added or removed by miners, // but it should provide a basis for setting a reasonable default. -func (ec *EthereumClient) EstimateGas(ctx *Context, msg *CallMsg) (gas *BigInt, _ error) { +func (ec *EthereumClient) EstimateGas(ctx *Context, msg *CallMsg) (gas int64, _ error) { rawGas, err := ec.client.EstimateGas(ctx.context, msg.msg) - return &BigInt{rawGas}, err + return int64(rawGas), err } // SendTransaction injects a signed transaction into the pending pool for execution. diff --git a/mobile/ethereum.go b/mobile/ethereum.go index c9bb3013c2..0eb1d90552 100644 --- a/mobile/ethereum.go +++ b/mobile/ethereum.go @@ -20,7 +20,6 @@ package geth import ( "errors" - "math/big" ethereum "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/common" @@ -49,7 +48,7 @@ func NewCallMsg() *CallMsg { } func (msg *CallMsg) GetFrom() *Address { return &Address{msg.msg.From} } -func (msg *CallMsg) GetGas() int64 { return msg.msg.Gas.Int64() } +func (msg *CallMsg) GetGas() int64 { return int64(msg.msg.Gas) } func (msg *CallMsg) GetGasPrice() *BigInt { return &BigInt{msg.msg.GasPrice} } func (msg *CallMsg) GetValue() *BigInt { return &BigInt{msg.msg.Value} } func (msg *CallMsg) GetData() []byte { return msg.msg.Data } @@ -61,7 +60,7 @@ func (msg *CallMsg) GetTo() *Address { } func (msg *CallMsg) SetFrom(address *Address) { msg.msg.From = address.address } -func (msg *CallMsg) SetGas(gas int64) { msg.msg.Gas = big.NewInt(gas) } +func (msg *CallMsg) SetGas(gas int64) { msg.msg.Gas = uint64(gas) } func (msg *CallMsg) SetGasPrice(price *BigInt) { msg.msg.GasPrice = price.bigint } func (msg *CallMsg) SetValue(value *BigInt) { msg.msg.Value = value.bigint } func (msg *CallMsg) SetData(data []byte) { msg.msg.Data = common.CopyBytes(data) } diff --git a/mobile/types.go b/mobile/types.go index b7f8a3bc15..4790afceff 100644 --- a/mobile/types.go +++ b/mobile/types.go @@ -112,8 +112,8 @@ func (h *Header) GetReceiptHash() *Hash { return &Hash{h.header.ReceiptHash} } func (h *Header) GetBloom() *Bloom { return &Bloom{h.header.Bloom} } func (h *Header) GetDifficulty() *BigInt { return &BigInt{h.header.Difficulty} } func (h *Header) GetNumber() int64 { return h.header.Number.Int64() } -func (h *Header) GetGasLimit() int64 { return h.header.GasLimit.Int64() } -func (h *Header) GetGasUsed() int64 { return h.header.GasUsed.Int64() } +func (h *Header) GetGasLimit() int64 { return int64(h.header.GasLimit) } +func (h *Header) GetGasUsed() int64 { return int64(h.header.GasUsed) } func (h *Header) GetTime() int64 { return h.header.Time.Int64() } func (h *Header) GetExtra() []byte { return h.header.Extra } func (h *Header) GetMixDigest() *Hash { return &Hash{h.header.MixDigest} } @@ -189,8 +189,8 @@ func (b *Block) GetReceiptHash() *Hash { return &Hash{b.block.ReceiptHash()} } func (b *Block) GetBloom() *Bloom { return &Bloom{b.block.Bloom()} } func (b *Block) GetDifficulty() *BigInt { return &BigInt{b.block.Difficulty()} } func (b *Block) GetNumber() int64 { return b.block.Number().Int64() } -func (b *Block) GetGasLimit() int64 { return b.block.GasLimit().Int64() } -func (b *Block) GetGasUsed() int64 { return b.block.GasUsed().Int64() } +func (b *Block) GetGasLimit() int64 { return int64(b.block.GasLimit()) } +func (b *Block) GetGasUsed() int64 { return int64(b.block.GasUsed()) } func (b *Block) GetTime() int64 { return b.block.Time().Int64() } func (b *Block) GetExtra() []byte { return b.block.Extra() } func (b *Block) GetMixDigest() *Hash { return &Hash{b.block.MixDigest()} } @@ -212,8 +212,8 @@ type Transaction struct { } // NewTransaction creates a new transaction with the given properties. -func NewTransaction(nonce int64, to *Address, amount, gasLimit, gasPrice *BigInt, data []byte) *Transaction { - return &Transaction{types.NewTransaction(uint64(nonce), to.address, amount.bigint, gasLimit.bigint, gasPrice.bigint, common.CopyBytes(data))} +func NewTransaction(nonce int64, to *Address, amount *BigInt, gasLimit int64, gasPrice *BigInt, data []byte) *Transaction { + return &Transaction{types.NewTransaction(uint64(nonce), to.address, amount.bigint, uint64(gasLimit), gasPrice.bigint, common.CopyBytes(data))} } // NewTransactionFromRLP parses a transaction from an RLP data dump. @@ -256,7 +256,7 @@ func (tx *Transaction) String() string { } func (tx *Transaction) GetData() []byte { return tx.tx.Data() } -func (tx *Transaction) GetGas() int64 { return tx.tx.Gas().Int64() } +func (tx *Transaction) GetGas() int64 { return int64(tx.tx.Gas()) } func (tx *Transaction) GetGasPrice() *BigInt { return &BigInt{tx.tx.GasPrice()} } func (tx *Transaction) GetValue() *BigInt { return &BigInt{tx.tx.Value()} } func (tx *Transaction) GetNonce() int64 { return int64(tx.tx.Nonce()) } @@ -353,10 +353,10 @@ func (r *Receipt) String() string { return r.receipt.String() } -func (r *Receipt) GetPostState() []byte { return r.receipt.PostState } -func (r *Receipt) GetCumulativeGasUsed() *BigInt { return &BigInt{r.receipt.CumulativeGasUsed} } -func (r *Receipt) GetBloom() *Bloom { return &Bloom{r.receipt.Bloom} } -func (r *Receipt) GetLogs() *Logs { return &Logs{r.receipt.Logs} } -func (r *Receipt) GetTxHash() *Hash { return &Hash{r.receipt.TxHash} } -func (r *Receipt) GetContractAddress() *Address { return &Address{r.receipt.ContractAddress} } -func (r *Receipt) GetGasUsed() *BigInt { return &BigInt{r.receipt.GasUsed} } +func (r *Receipt) GetPostState() []byte { return r.receipt.PostState } +func (r *Receipt) GetCumulativeGasUsed() int64 { return int64(r.receipt.CumulativeGasUsed) } +func (r *Receipt) GetBloom() *Bloom { return &Bloom{r.receipt.Bloom} } +func (r *Receipt) GetLogs() *Logs { return &Logs{r.receipt.Logs} } +func (r *Receipt) GetTxHash() *Hash { return &Hash{r.receipt.TxHash} } +func (r *Receipt) GetContractAddress() *Address { return &Address{r.receipt.ContractAddress} } +func (r *Receipt) GetGasUsed() int64 { return int64(r.receipt.GasUsed) } diff --git a/p2p/discover/database.go b/p2p/discover/database.go index 7206a63c63..b136609f24 100644 --- a/p2p/discover/database.go +++ b/p2p/discover/database.go @@ -226,14 +226,14 @@ func (db *nodeDB) ensureExpirer() { // expirer should be started in a go routine, and is responsible for looping ad // infinitum and dropping stale data from the database. func (db *nodeDB) expirer() { - tick := time.Tick(nodeDBCleanupCycle) + tick := time.NewTicker(nodeDBCleanupCycle) + defer tick.Stop() for { select { - case <-tick: + case <-tick.C: if err := db.expireNodes(); err != nil { log.Error("Failed to expire nodedb items", "err", err) } - case <-db.quit: return } diff --git a/p2p/discv5/database.go b/p2p/discv5/database.go index a3b044ec18..3c2d5744c3 100644 --- a/p2p/discv5/database.go +++ b/p2p/discv5/database.go @@ -239,14 +239,14 @@ func (db *nodeDB) ensureExpirer() { // expirer should be started in a go routine, and is responsible for looping ad // infinitum and dropping stale data from the database. func (db *nodeDB) expirer() { - tick := time.Tick(nodeDBCleanupCycle) + tick := time.NewTicker(nodeDBCleanupCycle) + defer tick.Stop() for { select { - case <-tick: + case <-tick.C: if err := db.expireNodes(); err != nil { log.Error(fmt.Sprintf("Failed to expire nodedb items: %v", err)) } - case <-db.quit: return } diff --git a/p2p/discv5/net.go b/p2p/discv5/net.go index 2fbb60824c..cd9981584d 100644 --- a/p2p/discv5/net.go +++ b/p2p/discv5/net.go @@ -51,16 +51,9 @@ const ( const testTopic = "foo" const ( - printDebugLogs = false printTestImgLogs = false ) -func debugLog(s string) { - if printDebugLogs { - fmt.Println(s) - } -} - // Network manages the table and all protocol interaction. type Network struct { db *nodeDB // database of known nodes @@ -388,14 +381,14 @@ func (net *Network) loop() { } }() resetNextTicket := func() { - t, timeout := net.ticketStore.nextFilteredTicket() - if t != nextTicket { - nextTicket = t + ticket, timeout := net.ticketStore.nextFilteredTicket() + if nextTicket != ticket { + nextTicket = ticket if nextRegisterTimer != nil { nextRegisterTimer.Stop() nextRegisterTime = nil } - if t != nil { + if ticket != nil { nextRegisterTimer = time.NewTimer(timeout) nextRegisterTime = nextRegisterTimer.C } @@ -423,13 +416,13 @@ loop: select { case <-net.closeReq: - debugLog("<-net.closeReq") + log.Trace("<-net.closeReq") break loop // Ingress packet handling. case pkt := <-net.read: //fmt.Println("read", pkt.ev) - debugLog("<-net.read") + log.Trace("<-net.read") n := net.internNode(&pkt) prestate := n.state status := "ok" @@ -444,7 +437,7 @@ loop: // State transition timeouts. case timeout := <-net.timeout: - debugLog("<-net.timeout") + log.Trace("<-net.timeout") if net.timeoutTimers[timeout] == nil { // Stale timer (was aborted). continue @@ -462,20 +455,20 @@ loop: // Querying. case q := <-net.queryReq: - debugLog("<-net.queryReq") + log.Trace("<-net.queryReq") if !q.start(net) { q.remote.deferQuery(q) } // Interacting with the table. case f := <-net.tableOpReq: - debugLog("<-net.tableOpReq") + log.Trace("<-net.tableOpReq") f() net.tableOpResp <- struct{}{} // Topic registration stuff. case req := <-net.topicRegisterReq: - debugLog("<-net.topicRegisterReq") + log.Trace("<-net.topicRegisterReq") if !req.add { net.ticketStore.removeRegisterTopic(req.topic) continue @@ -486,7 +479,7 @@ loop: // determination for new topics. // if topicRegisterLookupDone == nil { if topicRegisterLookupTarget.target == (common.Hash{}) { - debugLog("topicRegisterLookupTarget == null") + log.Trace("topicRegisterLookupTarget == null") if topicRegisterLookupTick.Stop() { <-topicRegisterLookupTick.C } @@ -496,7 +489,7 @@ loop: } case nodes := <-topicRegisterLookupDone: - debugLog("<-topicRegisterLookupDone") + log.Trace("<-topicRegisterLookupDone") net.ticketStore.registerLookupDone(topicRegisterLookupTarget, nodes, func(n *Node) []byte { net.ping(n, n.addr()) return n.pingEcho @@ -507,7 +500,7 @@ loop: topicRegisterLookupDone = nil case <-topicRegisterLookupTick.C: - debugLog("<-topicRegisterLookupTick") + log.Trace("<-topicRegisterLookupTick") if (topicRegisterLookupTarget.target == common.Hash{}) { target, delay := net.ticketStore.nextRegisterLookup() topicRegisterLookupTarget = target @@ -520,14 +513,14 @@ loop: } case <-nextRegisterTime: - debugLog("<-nextRegisterTime") + log.Trace("<-nextRegisterTime") net.ticketStore.ticketRegistered(*nextTicket) //fmt.Println("sendTopicRegister", nextTicket.t.node.addr().String(), nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong) net.conn.sendTopicRegister(nextTicket.t.node, nextTicket.t.topics, nextTicket.idx, nextTicket.t.pong) case req := <-net.topicSearchReq: if refreshDone == nil { - debugLog("<-net.topicSearchReq") + log.Trace("<-net.topicSearchReq") info, ok := searchInfo[req.topic] if ok { if req.delay == time.Duration(0) { @@ -588,7 +581,7 @@ loop: }) case <-statsDump.C: - debugLog("<-statsDump.C") + log.Trace("<-statsDump.C") /*r, ok := net.ticketStore.radius[testTopic] if !ok { fmt.Printf("(%x) no radius @ %v\n", net.tab.self.ID[:8], time.Now()) @@ -617,7 +610,7 @@ loop: // Periodic / lookup-initiated bucket refresh. case <-refreshTimer.C: - debugLog("<-refreshTimer.C") + log.Trace("<-refreshTimer.C") // TODO: ideally we would start the refresh timer after // fallback nodes have been set for the first time. if refreshDone == nil { @@ -631,7 +624,7 @@ loop: bucketRefreshTimer.Reset(bucketRefreshInterval) }() case newNursery := <-net.refreshReq: - debugLog("<-net.refreshReq") + log.Trace("<-net.refreshReq") if newNursery != nil { net.nursery = newNursery } @@ -641,7 +634,7 @@ loop: } net.refreshResp <- refreshDone case <-refreshDone: - debugLog("<-net.refreshDone") + log.Trace("<-net.refreshDone") refreshDone = nil list := searchReqWhenRefreshDone searchReqWhenRefreshDone = nil @@ -652,7 +645,7 @@ loop: }() } } - debugLog("loop stopped") + log.Trace("loop stopped") log.Debug(fmt.Sprintf("shutting down")) if net.conn != nil { @@ -1109,14 +1102,14 @@ func (net *Network) ping(n *Node, addr *net.UDPAddr) { //fmt.Println(" not sent") return } - debugLog(fmt.Sprintf("ping(node = %x)", n.ID[:8])) + log.Trace("Pinging remote node", "node", n.ID) n.pingTopics = net.ticketStore.regTopicSet() n.pingEcho = net.conn.sendPing(n, addr, n.pingTopics) net.timedEvent(respTimeout, n, pongTimeout) } func (net *Network) handlePing(n *Node, pkt *ingressPacket) { - debugLog(fmt.Sprintf("handlePing(node = %x)", n.ID[:8])) + log.Trace("Handling remote ping", "node", n.ID) ping := pkt.data.(*ping) n.TCP = ping.From.TCP t := net.topictab.getTicket(n, ping.Topics) @@ -1131,7 +1124,7 @@ func (net *Network) handlePing(n *Node, pkt *ingressPacket) { } func (net *Network) handleKnownPong(n *Node, pkt *ingressPacket) error { - debugLog(fmt.Sprintf("handleKnownPong(node = %x)", n.ID[:8])) + log.Trace("Handling known pong", "node", n.ID) net.abortTimedEvent(n, pongTimeout) now := mclock.Now() ticket, err := pongToTicket(now, n.pingTopics, n, pkt) @@ -1139,9 +1132,8 @@ func (net *Network) handleKnownPong(n *Node, pkt *ingressPacket) error { // fmt.Printf("(%x) ticket: %+v\n", net.tab.self.ID[:8], pkt.data) net.ticketStore.addTicket(now, pkt.data.(*pong).ReplyTok, ticket) } else { - debugLog(fmt.Sprintf(" error: %v", err)) + log.Trace("Failed to convert pong to ticket", "err", err) } - n.pingEcho = nil n.pingTopics = nil return err diff --git a/p2p/discv5/node.go b/p2p/discv5/node.go index 2db7a508f0..fd88a55b15 100644 --- a/p2p/discv5/node.go +++ b/p2p/discv5/node.go @@ -273,6 +273,11 @@ func (n NodeID) GoString() string { return fmt.Sprintf("discover.HexID(\"%x\")", n[:]) } +// TerminalString returns a shortened hex string for terminal logging. +func (n NodeID) TerminalString() string { + return hex.EncodeToString(n[:8]) +} + // HexID converts a hex string to a NodeID. // The string may be prefixed with 0x. func HexID(in string) (NodeID, error) { diff --git a/p2p/discv5/ticket.go b/p2p/discv5/ticket.go index 193cef4be5..b45ec4d2be 100644 --- a/p2p/discv5/ticket.go +++ b/p2p/discv5/ticket.go @@ -28,6 +28,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/mclock" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" ) const ( @@ -128,8 +129,11 @@ type ticketStore struct { // Contains buckets (for each absolute minute) of tickets // that can be used in that minute. // This is only set if the topic is being registered. - tickets map[Topic]topicTickets - regtopics []Topic + tickets map[Topic]*topicTickets + + regQueue []Topic // Topic registration queue for round robin attempts + regSet map[Topic]struct{} // Topic registration queue contents for fast filling + nodes map[*Node]*ticket nodeLastReq map[*Node]reqInfo @@ -152,14 +156,16 @@ type sentQuery struct { } type topicTickets struct { - buckets map[timeBucket][]ticketRef - nextLookup, nextReg mclock.AbsTime + buckets map[timeBucket][]ticketRef + nextLookup mclock.AbsTime + nextReg mclock.AbsTime } func newTicketStore() *ticketStore { return &ticketStore{ radius: make(map[Topic]*topicRadius), - tickets: make(map[Topic]topicTickets), + tickets: make(map[Topic]*topicTickets), + regSet: make(map[Topic]struct{}), nodes: make(map[*Node]*ticket), nodeLastReq: make(map[*Node]reqInfo), searchTopicMap: make(map[Topic]searchTopic), @@ -169,13 +175,13 @@ func newTicketStore() *ticketStore { // addTopic starts tracking a topic. If register is true, // the local node will register the topic and tickets will be collected. -func (s *ticketStore) addTopic(t Topic, register bool) { - debugLog(fmt.Sprintf(" addTopic(%v, %v)", t, register)) - if s.radius[t] == nil { - s.radius[t] = newTopicRadius(t) +func (s *ticketStore) addTopic(topic Topic, register bool) { + log.Trace("Adding discovery topic", "topic", topic, "register", register) + if s.radius[topic] == nil { + s.radius[topic] = newTopicRadius(topic) } - if register && s.tickets[t].buckets == nil { - s.tickets[t] = topicTickets{buckets: make(map[timeBucket][]ticketRef)} + if register && s.tickets[topic] == nil { + s.tickets[topic] = &topicTickets{buckets: make(map[timeBucket][]ticketRef)} } } @@ -194,7 +200,11 @@ func (s *ticketStore) removeSearchTopic(t Topic) { // removeRegisterTopic deletes all tickets for the given topic. func (s *ticketStore) removeRegisterTopic(topic Topic) { - debugLog(fmt.Sprintf(" removeRegisterTopic(%v)", topic)) + log.Trace("Removing discovery topic", "topic", topic) + if s.tickets[topic] == nil { + log.Warn("Removing non-existent discovery topic", "topic", topic) + return + } for _, list := range s.tickets[topic].buckets { for _, ref := range list { ref.t.refCnt-- @@ -216,23 +226,35 @@ func (s *ticketStore) regTopicSet() []Topic { } // nextRegisterLookup returns the target of the next lookup for ticket collection. -func (s *ticketStore) nextRegisterLookup() (lookup lookupInfo, delay time.Duration) { - debugLog("nextRegisterLookup()") - firstTopic, ok := s.iterRegTopics() - for topic := firstTopic; ok; { - debugLog(fmt.Sprintf(" checking topic %v, len(s.tickets[topic]) = %d", topic, len(s.tickets[topic].buckets))) - if s.tickets[topic].buckets != nil && s.needMoreTickets(topic) { - next := s.radius[topic].nextTarget(false) - debugLog(fmt.Sprintf(" %x 1s", next.target[:8])) - return next, 100 * time.Millisecond - } - topic, ok = s.iterRegTopics() - if topic == firstTopic { - break // We have checked all topics. +func (s *ticketStore) nextRegisterLookup() (lookupInfo, time.Duration) { + // Queue up any new topics (or discarded ones), preserving iteration order + for topic := range s.tickets { + if _, ok := s.regSet[topic]; !ok { + s.regQueue = append(s.regQueue, topic) + s.regSet[topic] = struct{}{} } } - debugLog(" null, 40s") - return lookupInfo{}, 40 * time.Second + // Iterate over the set of all topics and look up the next suitable one + for len(s.regQueue) > 0 { + // Fetch the next topic from the queue, and ensure it still exists + topic := s.regQueue[0] + s.regQueue = s.regQueue[1:] + delete(s.regSet, topic) + + if s.tickets[topic] == nil { + continue + } + // If the topic needs more tickets, return it + if s.tickets[topic].nextLookup < mclock.Now() { + next, delay := s.radius[topic].nextTarget(false), 100*time.Millisecond + log.Trace("Found discovery topic to register", "topic", topic, "target", next.target, "delay", delay) + return next, delay + } + } + // No registration topics found or all exhausted, sleep + delay := 40 * time.Second + log.Trace("No topic found to register", "delay", delay) + return lookupInfo{}, delay } func (s *ticketStore) nextSearchLookup(topic Topic) lookupInfo { @@ -246,40 +268,22 @@ func (s *ticketStore) nextSearchLookup(topic Topic) lookupInfo { return target } -// iterRegTopics returns topics to register in arbitrary order. -// The second return value is false if there are no topics. -func (s *ticketStore) iterRegTopics() (Topic, bool) { - debugLog("iterRegTopics()") - if len(s.regtopics) == 0 { - if len(s.tickets) == 0 { - debugLog(" false") - return "", false - } - // Refill register list. - for t := range s.tickets { - s.regtopics = append(s.regtopics, t) - } - } - topic := s.regtopics[len(s.regtopics)-1] - s.regtopics = s.regtopics[:len(s.regtopics)-1] - debugLog(" " + string(topic) + " true") - return topic, true -} - -func (s *ticketStore) needMoreTickets(t Topic) bool { - return s.tickets[t].nextLookup < mclock.Now() -} - // ticketsInWindow returns the tickets of a given topic in the registration window. -func (s *ticketStore) ticketsInWindow(t Topic) []ticketRef { - ltBucket := s.lastBucketFetched - var res []ticketRef - tickets := s.tickets[t].buckets - for g := ltBucket; g < ltBucket+timeWindow; g++ { - res = append(res, tickets[g]...) +func (s *ticketStore) ticketsInWindow(topic Topic) []ticketRef { + // Sanity check that the topic still exists before operating on it + if s.tickets[topic] == nil { + log.Warn("Listing non-existing discovery tickets", "topic", topic) + return nil } - debugLog(fmt.Sprintf("ticketsInWindow(%v) = %v", t, len(res))) - return res + // Gather all the tickers in the next time window + var tickets []ticketRef + + buckets := s.tickets[topic].buckets + for idx := timeBucket(0); idx < timeWindow; idx++ { + tickets = append(tickets, buckets[s.lastBucketFetched+idx]...) + } + log.Trace("Retrieved discovery registration tickets", "topic", topic, "from", s.lastBucketFetched, "tickets", len(tickets)) + return tickets } func (s *ticketStore) removeExcessTickets(t Topic) { @@ -317,53 +321,55 @@ func (s ticketRefByWaitTime) Swap(i, j int) { func (s *ticketStore) addTicketRef(r ticketRef) { topic := r.t.topics[r.idx] - t := s.tickets[topic] - if t.buckets == nil { + tickets := s.tickets[topic] + if tickets == nil { + log.Warn("Adding ticket to non-existent topic", "topic", topic) return } bucket := timeBucket(r.t.regTime[r.idx] / mclock.AbsTime(ticketTimeBucketLen)) - t.buckets[bucket] = append(t.buckets[bucket], r) + tickets.buckets[bucket] = append(tickets.buckets[bucket], r) r.t.refCnt++ min := mclock.Now() - mclock.AbsTime(collectFrequency)*maxCollectDebt - if t.nextLookup < min { - t.nextLookup = min + if tickets.nextLookup < min { + tickets.nextLookup = min } - t.nextLookup += mclock.AbsTime(collectFrequency) - s.tickets[topic] = t + tickets.nextLookup += mclock.AbsTime(collectFrequency) //s.removeExcessTickets(topic) } -func (s *ticketStore) nextFilteredTicket() (t *ticketRef, wait time.Duration) { +func (s *ticketStore) nextFilteredTicket() (*ticketRef, time.Duration) { now := mclock.Now() for { - t, wait = s.nextRegisterableTicket() - if t == nil { - return + ticket, wait := s.nextRegisterableTicket() + if ticket == nil { + return ticket, wait } + log.Trace("Found discovery ticket to register", "node", ticket.t.node, "serial", ticket.t.serial, "wait", wait) + regTime := now + mclock.AbsTime(wait) - topic := t.t.topics[t.idx] + topic := ticket.t.topics[ticket.idx] if regTime >= s.tickets[topic].nextReg { - return + return ticket, wait } - s.removeTicketRef(*t) + s.removeTicketRef(*ticket) } } -func (s *ticketStore) ticketRegistered(t ticketRef) { +func (s *ticketStore) ticketRegistered(ref ticketRef) { now := mclock.Now() - topic := t.t.topics[t.idx] - tt := s.tickets[topic] + topic := ref.t.topics[ref.idx] + tickets := s.tickets[topic] min := now - mclock.AbsTime(registerFrequency)*maxRegisterDebt - if min > tt.nextReg { - tt.nextReg = min + if min > tickets.nextReg { + tickets.nextReg = min } - tt.nextReg += mclock.AbsTime(registerFrequency) - s.tickets[topic] = tt + tickets.nextReg += mclock.AbsTime(registerFrequency) + s.tickets[topic] = tickets - s.removeTicketRef(t) + s.removeTicketRef(ref) } // nextRegisterableTicket returns the next ticket that can be used @@ -374,16 +380,7 @@ func (s *ticketStore) ticketRegistered(t ticketRef) { // // A ticket can be returned more than once with <= zero wait time in case // the ticket contains multiple topics. -func (s *ticketStore) nextRegisterableTicket() (t *ticketRef, wait time.Duration) { - defer func() { - if t == nil { - debugLog(" nil") - } else { - debugLog(fmt.Sprintf(" node = %x sn = %v wait = %v", t.t.node.ID[:8], t.t.serial, wait)) - } - }() - - debugLog("nextRegisterableTicket()") +func (s *ticketStore) nextRegisterableTicket() (*ticketRef, time.Duration) { now := mclock.Now() if s.nextTicketCached != nil { return s.nextTicketCached, time.Duration(s.nextTicketCached.topicRegTime() - now) @@ -412,9 +409,8 @@ func (s *ticketStore) nextRegisterableTicket() (t *ticketRef, wait time.Duration return nil, 0 } if nextTicket.t != nil { - wait = time.Duration(nextTicket.topicRegTime() - now) s.nextTicketCached = &nextTicket - return &nextTicket, wait + return &nextTicket, time.Duration(nextTicket.topicRegTime() - now) } s.lastBucketFetched = bucket } @@ -422,14 +418,17 @@ func (s *ticketStore) nextRegisterableTicket() (t *ticketRef, wait time.Duration // removeTicket removes a ticket from the ticket store func (s *ticketStore) removeTicketRef(ref ticketRef) { - debugLog(fmt.Sprintf("removeTicketRef(node = %x sn = %v)", ref.t.node.ID[:8], ref.t.serial)) + log.Trace("Removing discovery ticket reference", "node", ref.t.node.ID, "serial", ref.t.serial) + topic := ref.topic() - tickets := s.tickets[topic].buckets + tickets := s.tickets[topic] + if tickets == nil { + log.Warn("Removing tickets from unknown topic", "topic", topic) return } bucket := timeBucket(ref.t.regTime[ref.idx] / mclock.AbsTime(ticketTimeBucketLen)) - list := tickets[bucket] + list := tickets.buckets[bucket] idx := -1 for i, bt := range list { if bt.t == ref.t { @@ -442,9 +441,9 @@ func (s *ticketStore) removeTicketRef(ref ticketRef) { } list = append(list[:idx], list[idx+1:]...) if len(list) != 0 { - tickets[bucket] = list + tickets.buckets[bucket] = list } else { - delete(tickets, bucket) + delete(tickets.buckets, bucket) } ref.t.refCnt-- if ref.t.refCnt == 0 { @@ -523,21 +522,21 @@ func (s *ticketStore) adjustWithTicket(now mclock.AbsTime, targetHash common.Has } } -func (s *ticketStore) addTicket(localTime mclock.AbsTime, pingHash []byte, t *ticket) { - debugLog(fmt.Sprintf("add(node = %x sn = %v)", t.node.ID[:8], t.serial)) +func (s *ticketStore) addTicket(localTime mclock.AbsTime, pingHash []byte, ticket *ticket) { + log.Trace("Adding discovery ticket", "node", ticket.node.ID, "serial", ticket.serial) - lastReq, ok := s.nodeLastReq[t.node] + lastReq, ok := s.nodeLastReq[ticket.node] if !(ok && bytes.Equal(pingHash, lastReq.pingHash)) { return } - s.adjustWithTicket(localTime, lastReq.lookup.target, t) + s.adjustWithTicket(localTime, lastReq.lookup.target, ticket) - if lastReq.lookup.radiusLookup || s.nodes[t.node] != nil { + if lastReq.lookup.radiusLookup || s.nodes[ticket.node] != nil { return } topic := lastReq.lookup.topic - topicIdx := t.findIdx(topic) + topicIdx := ticket.findIdx(topic) if topicIdx == -1 { return } @@ -548,29 +547,29 @@ func (s *ticketStore) addTicket(localTime mclock.AbsTime, pingHash []byte, t *ti } if _, ok := s.tickets[topic]; ok { - wait := t.regTime[topicIdx] - localTime + wait := ticket.regTime[topicIdx] - localTime rnd := rand.ExpFloat64() if rnd > 10 { rnd = 10 } if float64(wait) < float64(keepTicketConst)+float64(keepTicketExp)*rnd { // use the ticket to register this topic - //fmt.Println("addTicket", t.node.ID[:8], t.node.addr().String(), t.serial, t.pong) - s.addTicketRef(ticketRef{t, topicIdx}) + //fmt.Println("addTicket", ticket.node.ID[:8], ticket.node.addr().String(), ticket.serial, ticket.pong) + s.addTicketRef(ticketRef{ticket, topicIdx}) } } - if t.refCnt > 0 { + if ticket.refCnt > 0 { s.nextTicketCached = nil - s.nodes[t.node] = t + s.nodes[ticket.node] = ticket } } func (s *ticketStore) getNodeTicket(node *Node) *ticket { if s.nodes[node] == nil { - debugLog(fmt.Sprintf("getNodeTicket(%x) sn = nil", node.ID[:8])) + log.Trace("Retrieving node ticket", "node", node.ID, "serial", nil) } else { - debugLog(fmt.Sprintf("getNodeTicket(%x) sn = %v", node.ID[:8], s.nodes[node].serial)) + log.Trace("Retrieving node ticket", "node", node.ID, "serial", s.nodes[node].serial) } return s.nodes[node] } diff --git a/p2p/discv5/topic.go b/p2p/discv5/topic.go index b6bea013c7..e7a7f8e02a 100644 --- a/p2p/discv5/topic.go +++ b/p2p/discv5/topic.go @@ -24,6 +24,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common/mclock" + "github.com/ethereum/go-ethereum/log" ) const ( @@ -235,7 +236,7 @@ func (t *topicTable) deleteEntry(e *topicEntry) { // It is assumed that topics and waitPeriods have the same length. func (t *topicTable) useTicket(node *Node, serialNo uint32, topics []Topic, idx int, issueTime uint64, waitPeriods []uint32) (registered bool) { - debugLog(fmt.Sprintf("useTicket %v %v %v", serialNo, topics, waitPeriods)) + log.Trace("Using discovery ticket", "serial", serialNo, "topics", topics, "waits", waitPeriods) //fmt.Println("useTicket", serialNo, topics, waitPeriods) t.collectGarbage() diff --git a/p2p/enr/enr.go b/p2p/enr/enr.go new file mode 100644 index 0000000000..2c3afb43e9 --- /dev/null +++ b/p2p/enr/enr.go @@ -0,0 +1,290 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +// Package enr implements Ethereum Node Records as defined in EIP-778. A node record holds +// arbitrary information about a node on the peer-to-peer network. +// +// Records contain named keys. To store and retrieve key/values in a record, use the Entry +// interface. +// +// Records must be signed before transmitting them to another node. Decoding a record verifies +// its signature. When creating a record, set the entries you want, then call Sign to add the +// signature. Modifying a record invalidates the signature. +// +// Package enr supports the "secp256k1-keccak" identity scheme. +package enr + +import ( + "bytes" + "crypto/ecdsa" + "errors" + "fmt" + "io" + "sort" + + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/crypto/sha3" + "github.com/ethereum/go-ethereum/rlp" +) + +const SizeLimit = 300 // maximum encoded size of a node record in bytes + +const ID_SECP256k1_KECCAK = ID("secp256k1-keccak") // the default identity scheme + +var ( + errNoID = errors.New("unknown or unspecified identity scheme") + errInvalidSigsize = errors.New("invalid signature size") + errInvalidSig = errors.New("invalid signature") + errNotSorted = errors.New("record key/value pairs are not sorted by key") + errDuplicateKey = errors.New("record contains duplicate key") + errIncompletePair = errors.New("record contains incomplete k/v pair") + errTooBig = fmt.Errorf("record bigger than %d bytes", SizeLimit) + errEncodeUnsigned = errors.New("can't encode unsigned record") + errNotFound = errors.New("no such key in record") +) + +// Record represents a node record. The zero value is an empty record. +type Record struct { + seq uint64 // sequence number + signature []byte // the signature + raw []byte // RLP encoded record + pairs []pair // sorted list of all key/value pairs +} + +// pair is a key/value pair in a record. +type pair struct { + k string + v rlp.RawValue +} + +// Signed reports whether the record has a valid signature. +func (r *Record) Signed() bool { + return r.signature != nil +} + +// Seq returns the sequence number. +func (r *Record) Seq() uint64 { + return r.seq +} + +// SetSeq updates the record sequence number. This invalidates any signature on the record. +// Calling SetSeq is usually not required because signing the redord increments the +// sequence number. +func (r *Record) SetSeq(s uint64) { + r.signature = nil + r.raw = nil + r.seq = s +} + +// Load retrieves the value of a key/value pair. The given Entry must be a pointer and will +// be set to the value of the entry in the record. +// +// Errors returned by Load are wrapped in KeyError. You can distinguish decoding errors +// from missing keys using the IsNotFound function. +func (r *Record) Load(e Entry) error { + i := sort.Search(len(r.pairs), func(i int) bool { return r.pairs[i].k >= e.ENRKey() }) + if i < len(r.pairs) && r.pairs[i].k == e.ENRKey() { + if err := rlp.DecodeBytes(r.pairs[i].v, e); err != nil { + return &KeyError{Key: e.ENRKey(), Err: err} + } + return nil + } + return &KeyError{Key: e.ENRKey(), Err: errNotFound} +} + +// Set adds or updates the given entry in the record. +// It panics if the value can't be encoded. +func (r *Record) Set(e Entry) { + r.signature = nil + r.raw = nil + blob, err := rlp.EncodeToBytes(e) + if err != nil { + panic(fmt.Errorf("enr: can't encode %s: %v", e.ENRKey(), err)) + } + + i := sort.Search(len(r.pairs), func(i int) bool { return r.pairs[i].k >= e.ENRKey() }) + + if i < len(r.pairs) && r.pairs[i].k == e.ENRKey() { + // element is present at r.pairs[i] + r.pairs[i].v = blob + return + } else if i < len(r.pairs) { + // insert pair before i-th elem + el := pair{e.ENRKey(), blob} + r.pairs = append(r.pairs, pair{}) + copy(r.pairs[i+1:], r.pairs[i:]) + r.pairs[i] = el + return + } + + // element should be placed at the end of r.pairs + r.pairs = append(r.pairs, pair{e.ENRKey(), blob}) +} + +// EncodeRLP implements rlp.Encoder. Encoding fails if +// the record is unsigned. +func (r Record) EncodeRLP(w io.Writer) error { + if !r.Signed() { + return errEncodeUnsigned + } + _, err := w.Write(r.raw) + return err +} + +// DecodeRLP implements rlp.Decoder. Decoding verifies the signature. +func (r *Record) DecodeRLP(s *rlp.Stream) error { + raw, err := s.Raw() + if err != nil { + return err + } + if len(raw) > SizeLimit { + return errTooBig + } + + // Decode the RLP container. + dec := Record{raw: raw} + s = rlp.NewStream(bytes.NewReader(raw), 0) + if _, err := s.List(); err != nil { + return err + } + if err = s.Decode(&dec.signature); err != nil { + return err + } + if err = s.Decode(&dec.seq); err != nil { + return err + } + // The rest of the record contains sorted k/v pairs. + var prevkey string + for i := 0; ; i++ { + var kv pair + if err := s.Decode(&kv.k); err != nil { + if err == rlp.EOL { + break + } + return err + } + if err := s.Decode(&kv.v); err != nil { + if err == rlp.EOL { + return errIncompletePair + } + return err + } + if i > 0 { + if kv.k == prevkey { + return errDuplicateKey + } + if kv.k < prevkey { + return errNotSorted + } + } + dec.pairs = append(dec.pairs, kv) + prevkey = kv.k + } + if err := s.ListEnd(); err != nil { + return err + } + + // Verify signature. + if err = dec.verifySignature(); err != nil { + return err + } + *r = dec + return nil +} + +type s256raw []byte + +func (s256raw) ENRKey() string { return "secp256k1" } + +// NodeAddr returns the node address. The return value will be nil if the record is +// unsigned. +func (r *Record) NodeAddr() []byte { + var entry s256raw + if r.Load(&entry) != nil { + return nil + } + return crypto.Keccak256(entry) +} + +// Sign signs the record with the given private key. It updates the record's identity +// scheme, public key and increments the sequence number. Sign returns an error if the +// encoded record is larger than the size limit. +func (r *Record) Sign(privkey *ecdsa.PrivateKey) error { + r.seq = r.seq + 1 + r.Set(ID_SECP256k1_KECCAK) + r.Set(Secp256k1(privkey.PublicKey)) + return r.signAndEncode(privkey) +} + +func (r *Record) appendPairs(list []interface{}) []interface{} { + list = append(list, r.seq) + for _, p := range r.pairs { + list = append(list, p.k, p.v) + } + return list +} + +func (r *Record) signAndEncode(privkey *ecdsa.PrivateKey) error { + // Put record elements into a flat list. Leave room for the signature. + list := make([]interface{}, 1, len(r.pairs)*2+2) + list = r.appendPairs(list) + + // Sign the tail of the list. + h := sha3.NewKeccak256() + rlp.Encode(h, list[1:]) + sig, err := crypto.Sign(h.Sum(nil), privkey) + if err != nil { + return err + } + sig = sig[:len(sig)-1] // remove v + + // Put signature in front. + r.signature, list[0] = sig, sig + r.raw, err = rlp.EncodeToBytes(list) + if err != nil { + return err + } + if len(r.raw) > SizeLimit { + return errTooBig + } + return nil +} + +func (r *Record) verifySignature() error { + // Get identity scheme, public key, signature. + var id ID + var entry s256raw + if err := r.Load(&id); err != nil { + return err + } else if id != ID_SECP256k1_KECCAK { + return errNoID + } + if err := r.Load(&entry); err != nil { + return err + } else if len(entry) != 33 { + return fmt.Errorf("invalid public key") + } + + // Verify the signature. + list := make([]interface{}, 0, len(r.pairs)*2+1) + list = r.appendPairs(list) + h := sha3.NewKeccak256() + rlp.Encode(h, list) + if !crypto.VerifySignature(entry, h.Sum(nil), r.signature) { + return errInvalidSig + } + return nil +} diff --git a/p2p/enr/enr_test.go b/p2p/enr/enr_test.go new file mode 100644 index 0000000000..ce7767d105 --- /dev/null +++ b/p2p/enr/enr_test.go @@ -0,0 +1,318 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package enr + +import ( + "bytes" + "encoding/hex" + "fmt" + "math/rand" + "testing" + "time" + + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +var ( + privkey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") + pubkey = &privkey.PublicKey +) + +var rnd = rand.New(rand.NewSource(time.Now().UnixNano())) + +func randomString(strlen int) string { + b := make([]byte, strlen) + rnd.Read(b) + return string(b) +} + +// TestGetSetID tests encoding/decoding and setting/getting of the ID key. +func TestGetSetID(t *testing.T) { + id := ID("someid") + var r Record + r.Set(id) + + var id2 ID + require.NoError(t, r.Load(&id2)) + assert.Equal(t, id, id2) +} + +// TestGetSetIP4 tests encoding/decoding and setting/getting of the IP4 key. +func TestGetSetIP4(t *testing.T) { + ip := IP4{192, 168, 0, 3} + var r Record + r.Set(ip) + + var ip2 IP4 + require.NoError(t, r.Load(&ip2)) + assert.Equal(t, ip, ip2) +} + +// TestGetSetIP6 tests encoding/decoding and setting/getting of the IP6 key. +func TestGetSetIP6(t *testing.T) { + ip := IP6{0x20, 0x01, 0x48, 0x60, 0, 0, 0x20, 0x01, 0, 0, 0, 0, 0, 0, 0x00, 0x68} + var r Record + r.Set(ip) + + var ip2 IP6 + require.NoError(t, r.Load(&ip2)) + assert.Equal(t, ip, ip2) +} + +// TestGetSetDiscPort tests encoding/decoding and setting/getting of the DiscPort key. +func TestGetSetDiscPort(t *testing.T) { + port := DiscPort(30309) + var r Record + r.Set(port) + + var port2 DiscPort + require.NoError(t, r.Load(&port2)) + assert.Equal(t, port, port2) +} + +// TestGetSetSecp256k1 tests encoding/decoding and setting/getting of the Secp256k1 key. +func TestGetSetSecp256k1(t *testing.T) { + var r Record + if err := r.Sign(privkey); err != nil { + t.Fatal(err) + } + + var pk Secp256k1 + require.NoError(t, r.Load(&pk)) + assert.EqualValues(t, pubkey, &pk) +} + +func TestLoadErrors(t *testing.T) { + var r Record + ip4 := IP4{127, 0, 0, 1} + r.Set(ip4) + + // Check error for missing keys. + var ip6 IP6 + err := r.Load(&ip6) + if !IsNotFound(err) { + t.Error("IsNotFound should return true for missing key") + } + assert.Equal(t, &KeyError{Key: ip6.ENRKey(), Err: errNotFound}, err) + + // Check error for invalid keys. + var list []uint + err = r.Load(WithEntry(ip4.ENRKey(), &list)) + kerr, ok := err.(*KeyError) + if !ok { + t.Fatalf("expected KeyError, got %T", err) + } + assert.Equal(t, kerr.Key, ip4.ENRKey()) + assert.Error(t, kerr.Err) + if IsNotFound(err) { + t.Error("IsNotFound should return false for decoding errors") + } +} + +// TestSortedGetAndSet tests that Set produced a sorted pairs slice. +func TestSortedGetAndSet(t *testing.T) { + type pair struct { + k string + v uint32 + } + + for _, tt := range []struct { + input []pair + want []pair + }{ + { + input: []pair{{"a", 1}, {"c", 2}, {"b", 3}}, + want: []pair{{"a", 1}, {"b", 3}, {"c", 2}}, + }, + { + input: []pair{{"a", 1}, {"c", 2}, {"b", 3}, {"d", 4}, {"a", 5}, {"bb", 6}}, + want: []pair{{"a", 5}, {"b", 3}, {"bb", 6}, {"c", 2}, {"d", 4}}, + }, + { + input: []pair{{"c", 2}, {"b", 3}, {"d", 4}, {"a", 5}, {"bb", 6}}, + want: []pair{{"a", 5}, {"b", 3}, {"bb", 6}, {"c", 2}, {"d", 4}}, + }, + } { + var r Record + for _, i := range tt.input { + r.Set(WithEntry(i.k, &i.v)) + } + for i, w := range tt.want { + // set got's key from r.pair[i], so that we preserve order of pairs + got := pair{k: r.pairs[i].k} + assert.NoError(t, r.Load(WithEntry(w.k, &got.v))) + assert.Equal(t, w, got) + } + } +} + +// TestDirty tests record signature removal on setting of new key/value pair in record. +func TestDirty(t *testing.T) { + var r Record + + if r.Signed() { + t.Error("Signed returned true for zero record") + } + if _, err := rlp.EncodeToBytes(r); err != errEncodeUnsigned { + t.Errorf("expected errEncodeUnsigned, got %#v", err) + } + + require.NoError(t, r.Sign(privkey)) + if !r.Signed() { + t.Error("Signed return false for signed record") + } + _, err := rlp.EncodeToBytes(r) + assert.NoError(t, err) + + r.SetSeq(3) + if r.Signed() { + t.Error("Signed returned true for modified record") + } + if _, err := rlp.EncodeToBytes(r); err != errEncodeUnsigned { + t.Errorf("expected errEncodeUnsigned, got %#v", err) + } +} + +// TestGetSetOverwrite tests value overwrite when setting a new value with an existing key in record. +func TestGetSetOverwrite(t *testing.T) { + var r Record + + ip := IP4{192, 168, 0, 3} + r.Set(ip) + + ip2 := IP4{192, 168, 0, 4} + r.Set(ip2) + + var ip3 IP4 + require.NoError(t, r.Load(&ip3)) + assert.Equal(t, ip2, ip3) +} + +// TestSignEncodeAndDecode tests signing, RLP encoding and RLP decoding of a record. +func TestSignEncodeAndDecode(t *testing.T) { + var r Record + r.Set(DiscPort(30303)) + r.Set(IP4{127, 0, 0, 1}) + require.NoError(t, r.Sign(privkey)) + + blob, err := rlp.EncodeToBytes(r) + require.NoError(t, err) + + var r2 Record + require.NoError(t, rlp.DecodeBytes(blob, &r2)) + assert.Equal(t, r, r2) + + blob2, err := rlp.EncodeToBytes(r2) + require.NoError(t, err) + assert.Equal(t, blob, blob2) +} + +func TestNodeAddr(t *testing.T) { + var r Record + if addr := r.NodeAddr(); addr != nil { + t.Errorf("wrong address on empty record: got %v, want %v", addr, nil) + } + + require.NoError(t, r.Sign(privkey)) + expected := "caaa1485d83b18b32ed9ad666026151bf0cae8a0a88c857ae2d4c5be2daa6726" + assert.Equal(t, expected, hex.EncodeToString(r.NodeAddr())) +} + +var pyRecord, _ = hex.DecodeString("f896b840954dc36583c1f4b69ab59b1375f362f06ee99f3723cd77e64b6de6d211c27d7870642a79d4516997f94091325d2a7ca6215376971455fb221d34f35b277149a1018664697363763582765f82696490736563703235366b312d6b656363616b83697034847f00000189736563703235366b31a103ca634cae0d49acb401d8a4c6b6fe8c55b70d115bf400769cc1400f3258cd3138") + +// TestPythonInterop checks that we can decode and verify a record produced by the Python +// implementation. +func TestPythonInterop(t *testing.T) { + var r Record + if err := rlp.DecodeBytes(pyRecord, &r); err != nil { + t.Fatalf("can't decode: %v", err) + } + + var ( + wantAddr, _ = hex.DecodeString("caaa1485d83b18b32ed9ad666026151bf0cae8a0a88c857ae2d4c5be2daa6726") + wantSeq = uint64(1) + wantIP = IP4{127, 0, 0, 1} + wantDiscport = DiscPort(30303) + ) + if r.Seq() != wantSeq { + t.Errorf("wrong seq: got %d, want %d", r.Seq(), wantSeq) + } + if addr := r.NodeAddr(); !bytes.Equal(addr, wantAddr) { + t.Errorf("wrong addr: got %x, want %x", addr, wantAddr) + } + want := map[Entry]interface{}{new(IP4): &wantIP, new(DiscPort): &wantDiscport} + for k, v := range want { + desc := fmt.Sprintf("loading key %q", k.ENRKey()) + if assert.NoError(t, r.Load(k), desc) { + assert.Equal(t, k, v, desc) + } + } +} + +// TestRecordTooBig tests that records bigger than SizeLimit bytes cannot be signed. +func TestRecordTooBig(t *testing.T) { + var r Record + key := randomString(10) + + // set a big value for random key, expect error + r.Set(WithEntry(key, randomString(300))) + if err := r.Sign(privkey); err != errTooBig { + t.Fatalf("expected to get errTooBig, got %#v", err) + } + + // set an acceptable value for random key, expect no error + r.Set(WithEntry(key, randomString(100))) + require.NoError(t, r.Sign(privkey)) +} + +// TestSignEncodeAndDecodeRandom tests encoding/decoding of records containing random key/value pairs. +func TestSignEncodeAndDecodeRandom(t *testing.T) { + var r Record + + // random key/value pairs for testing + pairs := map[string]uint32{} + for i := 0; i < 10; i++ { + key := randomString(7) + value := rnd.Uint32() + pairs[key] = value + r.Set(WithEntry(key, &value)) + } + + require.NoError(t, r.Sign(privkey)) + _, err := rlp.EncodeToBytes(r) + require.NoError(t, err) + + for k, v := range pairs { + desc := fmt.Sprintf("key %q", k) + var got uint32 + buf := WithEntry(k, &got) + require.NoError(t, r.Load(buf), desc) + require.Equal(t, v, got, desc) + } +} + +func BenchmarkDecode(b *testing.B) { + var r Record + for i := 0; i < b.N; i++ { + rlp.DecodeBytes(pyRecord, &r) + } + b.StopTimer() + r.NodeAddr() +} diff --git a/p2p/enr/entries.go b/p2p/enr/entries.go new file mode 100644 index 0000000000..7591e6effb --- /dev/null +++ b/p2p/enr/entries.go @@ -0,0 +1,160 @@ +// Copyright 2017 The go-ethereum Authors +// This file is part of the go-ethereum library. +// +// The go-ethereum library is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// The go-ethereum library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the go-ethereum library. If not, see . + +package enr + +import ( + "crypto/ecdsa" + "fmt" + "io" + "net" + + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/rlp" +) + +// Entry is implemented by known node record entry types. +// +// To define a new entry that is to be included in a node record, +// create a Go type that satisfies this interface. The type should +// also implement rlp.Decoder if additional checks are needed on the value. +type Entry interface { + ENRKey() string +} + +type generic struct { + key string + value interface{} +} + +func (g generic) ENRKey() string { return g.key } + +func (g generic) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, g.value) +} + +func (g *generic) DecodeRLP(s *rlp.Stream) error { + return s.Decode(g.value) +} + +// WithEntry wraps any value with a key name. It can be used to set and load arbitrary values +// in a record. The value v must be supported by rlp. To use WithEntry with Load, the value +// must be a pointer. +func WithEntry(k string, v interface{}) Entry { + return &generic{key: k, value: v} +} + +// DiscPort is the "discv5" key, which holds the UDP port for discovery v5. +type DiscPort uint16 + +func (v DiscPort) ENRKey() string { return "discv5" } + +// ID is the "id" key, which holds the name of the identity scheme. +type ID string + +func (v ID) ENRKey() string { return "id" } + +// IP4 is the "ip4" key, which holds a 4-byte IPv4 address. +type IP4 net.IP + +func (v IP4) ENRKey() string { return "ip4" } + +// EncodeRLP implements rlp.Encoder. +func (v IP4) EncodeRLP(w io.Writer) error { + ip4 := net.IP(v).To4() + if ip4 == nil { + return fmt.Errorf("invalid IPv4 address: %v", v) + } + return rlp.Encode(w, ip4) +} + +// DecodeRLP implements rlp.Decoder. +func (v *IP4) DecodeRLP(s *rlp.Stream) error { + if err := s.Decode((*net.IP)(v)); err != nil { + return err + } + if len(*v) != 4 { + return fmt.Errorf("invalid IPv4 address, want 4 bytes: %v", *v) + } + return nil +} + +// IP6 is the "ip6" key, which holds a 16-byte IPv6 address. +type IP6 net.IP + +func (v IP6) ENRKey() string { return "ip6" } + +// EncodeRLP implements rlp.Encoder. +func (v IP6) EncodeRLP(w io.Writer) error { + ip6 := net.IP(v) + return rlp.Encode(w, ip6) +} + +// DecodeRLP implements rlp.Decoder. +func (v *IP6) DecodeRLP(s *rlp.Stream) error { + if err := s.Decode((*net.IP)(v)); err != nil { + return err + } + if len(*v) != 16 { + return fmt.Errorf("invalid IPv6 address, want 16 bytes: %v", *v) + } + return nil +} + +// Secp256k1 is the "secp256k1" key, which holds a public key. +type Secp256k1 ecdsa.PublicKey + +func (v Secp256k1) ENRKey() string { return "secp256k1" } + +// EncodeRLP implements rlp.Encoder. +func (v Secp256k1) EncodeRLP(w io.Writer) error { + return rlp.Encode(w, crypto.CompressPubkey((*ecdsa.PublicKey)(&v))) +} + +// DecodeRLP implements rlp.Decoder. +func (v *Secp256k1) DecodeRLP(s *rlp.Stream) error { + buf, err := s.Bytes() + if err != nil { + return err + } + pk, err := crypto.DecompressPubkey(buf) + if err != nil { + return err + } + *v = (Secp256k1)(*pk) + return nil +} + +// KeyError is an error related to a key. +type KeyError struct { + Key string + Err error +} + +// Error implements error. +func (err *KeyError) Error() string { + if err.Err == errNotFound { + return fmt.Sprintf("missing ENR key %q", err.Key) + } + return fmt.Sprintf("ENR key %q: %v", err.Key, err.Err) +} + +// IsNotFound reports whether the given error means that a key/value pair is +// missing from a record. +func IsNotFound(err error) bool { + kerr, ok := err.(*KeyError) + return ok && kerr.Err == errNotFound +} diff --git a/params/bootnodes.go b/params/bootnodes.go index 82ab6d48c2..ecb1acd4f1 100644 --- a/params/bootnodes.go +++ b/params/bootnodes.go @@ -26,7 +26,7 @@ var MainnetBootnodes = []string{ "enode://158f8aab45f6d19c6cbf4a089c2670541a8da11978a2f90dbf6a502a4a3bab80d288afdbeb7ec0ef6d92de563767f3b1ea9e8e334ca711e9f8e2df5a0385e8e6@13.75.154.138:30303", // AU "enode://1118980bf48b0a3640bdba04e0fe78b1add18e1cd99bf22d53daac1fd9972ad650df52176e7c7d89d1114cfef2bc23a2959aa54998a46afcf7d91809f0855082@52.74.57.123:30303", // SG - // Ethereum Foundation Cpp Bootnodes + // Ethereum Foundation C++ Bootnodes "enode://979b7fa28feeb35a4741660a16076f1943202cb72b6af70d327f053e248bab9ba81760f39d0701ef1d8f89cc1fbd2cacba0710a12cd5314d5e0c9021aa3637f9@5.1.83.226:30303", // DE } @@ -42,6 +42,7 @@ var TestnetBootnodes = []string{ var RinkebyBootnodes = []string{ "enode://a24ac7c5484ef4ed0c5eb2d36620ba4e4aa13b8c84684e1b4aab0cebea2ae45cb4d375b77eab56516d34bfbd3c1a833fc51296ff084b770b94fb9028c4d25ccf@52.169.42.101:30303", // IE "enode://343149e4feefa15d882d9fe4ac7d88f885bd05ebb735e547f12e12080a9fa07c8014ca6fd7f373123488102fe5e34111f8509cf0b7de3f5b44339c9f25e87cb8@52.3.158.184:30303", // INFURA + "enode://b6b28890b006743680c52e64e0d16db57f28124885595fa03a562be1d2bf0f3a1da297d56b13da25fb992888fd556d4c1a27b1f39d531bde7de1921c90061cc6@159.89.28.211:30303", // AKASHA } // RinkebyV5Bootnodes are the enode URLs of the P2P bootstrap nodes running on the @@ -49,6 +50,7 @@ var RinkebyBootnodes = []string{ var RinkebyV5Bootnodes = []string{ "enode://a24ac7c5484ef4ed0c5eb2d36620ba4e4aa13b8c84684e1b4aab0cebea2ae45cb4d375b77eab56516d34bfbd3c1a833fc51296ff084b770b94fb9028c4d25ccf@52.169.42.101:30303?discport=30304", // IE "enode://343149e4feefa15d882d9fe4ac7d88f885bd05ebb735e547f12e12080a9fa07c8014ca6fd7f373123488102fe5e34111f8509cf0b7de3f5b44339c9f25e87cb8@52.3.158.184:30303?discport=30304", // INFURA + "enode://b6b28890b006743680c52e64e0d16db57f28124885595fa03a562be1d2bf0f3a1da297d56b13da25fb992888fd556d4c1a27b1f39d531bde7de1921c90061cc6@159.89.28.211:30303?discport=30304", // AKASHA } // DiscoveryV5Bootnodes are the enode URLs of the P2P bootstrap nodes for the diff --git a/params/protocol_params.go b/params/protocol_params.go index c56faf56f8..5a0b14d61a 100644 --- a/params/protocol_params.go +++ b/params/protocol_params.go @@ -18,7 +18,15 @@ package params import "math/big" +var ( + TargetGasLimit uint64 = GenesisGasLimit // The artificial target +) + const ( + GasLimitBoundDivisor uint64 = 1024 // The bound divisor of the gas limit, used in update calculations. + MinGasLimit uint64 = 5000 // Minimum the gas limit may ever be. + GenesisGasLimit uint64 = 4712388 // Gas limit of the Genesis block. + MaximumExtraDataSize uint64 = 32 // Maximum size extra data may be after Genesis. ExpByteGas uint64 = 10 // Times ceil(log256(exponent)) for the EXP instruction. SloadGas uint64 = 50 // Multiplied by the number of 32-byte words that are copied (round up) for any *COPY operation and added. @@ -72,12 +80,8 @@ const ( ) var ( - GasLimitBoundDivisor = big.NewInt(1024) // The bound divisor of the gas limit, used in update calculations. - MinGasLimit = big.NewInt(5000) // Minimum the gas limit may ever be. - GenesisGasLimit = big.NewInt(4712388) // Gas limit of the Genesis block. - TargetGasLimit = new(big.Int).Set(GenesisGasLimit) // The artificial target - DifficultyBoundDivisor = big.NewInt(2048) // The bound divisor of the difficulty, used in the update calculations. - GenesisDifficulty = big.NewInt(131072) // Difficulty of the Genesis block. - MinimumDifficulty = big.NewInt(131072) // The minimum that the difficulty may ever be. - DurationLimit = big.NewInt(13) // The decision boundary on the blocktime duration used to determine whether difficulty should go up or not. + DifficultyBoundDivisor = big.NewInt(2048) // The bound divisor of the difficulty, used in the update calculations. + GenesisDifficulty = big.NewInt(131072) // Difficulty of the Genesis block. + MinimumDifficulty = big.NewInt(131072) // The minimum that the difficulty may ever be. + DurationLimit = big.NewInt(13) // The decision boundary on the blocktime duration used to determine whether difficulty should go up or not. ) diff --git a/rpc/http.go b/rpc/http.go index a26559b122..d61b0e470b 100644 --- a/rpc/http.go +++ b/rpc/http.go @@ -177,7 +177,7 @@ func validateRequest(r *http.Request) (int, error) { return http.StatusRequestEntityTooLarge, err } mt, _, err := mime.ParseMediaType(r.Header.Get("content-type")) - if err != nil || mt != contentType { + if r.Method != http.MethodOptions && (err != nil || mt != contentType) { err := fmt.Errorf("invalid content type, only %s is supported", contentType) return http.StatusUnsupportedMediaType, err } diff --git a/swarm/api/api.go b/swarm/api/api.go index 79de29a1cf..8c4bca2ec0 100644 --- a/swarm/api/api.go +++ b/swarm/api/api.go @@ -83,7 +83,7 @@ func (self *Api) Resolve(uri *URI) (storage.Key, error) { // if the URI is immutable, check if the address is a hash isHash := hashMatcher.MatchString(uri.Addr) - if uri.Immutable() { + if uri.Immutable() || uri.DeprecatedImmutable() { if !isHash { return nil, fmt.Errorf("immutable address not a content hash: %q", uri.Addr) } diff --git a/swarm/api/api_test.go b/swarm/api/api_test.go index f9caed27f5..e673f76c42 100644 --- a/swarm/api/api_test.go +++ b/swarm/api/api_test.go @@ -216,7 +216,7 @@ func TestAPIResolve(t *testing.T) { api := &Api{dns: x.dns} uri := &URI{Addr: x.addr, Scheme: "bzz"} if x.immutable { - uri.Scheme = "bzzi" + uri.Scheme = "bzz-immutable" } res, err := api.Resolve(uri) if err == nil { diff --git a/swarm/api/client/client.go b/swarm/api/client/client.go index 7952d3fb68..8165d52d7e 100644 --- a/swarm/api/client/client.go +++ b/swarm/api/client/client.go @@ -57,7 +57,7 @@ func (c *Client) UploadRaw(r io.Reader, size int64) (string, error) { if size <= 0 { return "", errors.New("data size must be greater than zero") } - req, err := http.NewRequest("POST", c.Gateway+"/bzzr:/", r) + req, err := http.NewRequest("POST", c.Gateway+"/bzz-raw:/", r) if err != nil { return "", err } @@ -79,7 +79,7 @@ func (c *Client) UploadRaw(r io.Reader, size int64) (string, error) { // DownloadRaw downloads raw data from swarm func (c *Client) DownloadRaw(hash string) (io.ReadCloser, error) { - uri := c.Gateway + "/bzzr:/" + hash + uri := c.Gateway + "/bzz-raw:/" + hash res, err := http.DefaultClient.Get(uri) if err != nil { return nil, err @@ -269,7 +269,7 @@ func (c *Client) DownloadManifest(hash string) (*api.Manifest, error) { // // where entries ending with "/" are common prefixes. func (c *Client) List(hash, prefix string) (*api.ManifestList, error) { - res, err := http.DefaultClient.Get(c.Gateway + "/bzz:/" + hash + "/" + prefix + "?list=true") + res, err := http.DefaultClient.Get(c.Gateway + "/bzz-list:/" + hash + "/" + prefix) if err != nil { return nil, err } diff --git a/swarm/api/http/roundtripper.go b/swarm/api/http/roundtripper.go index 328177a218..0194317716 100644 --- a/swarm/api/http/roundtripper.go +++ b/swarm/api/http/roundtripper.go @@ -35,8 +35,8 @@ import ( client := httpclient.New() // for (private) swarm proxy running locally client.RegisterScheme("bzz", &http.RoundTripper{Port: port}) -client.RegisterScheme("bzzi", &http.RoundTripper{Port: port}) -client.RegisterScheme("bzzr", &http.RoundTripper{Port: port}) +client.RegisterScheme("bzz-immutable", &http.RoundTripper{Port: port}) +client.RegisterScheme("bzz-raw", &http.RoundTripper{Port: port}) The port you give the Roundtripper is the port the swarm proxy is listening on. If Host is left empty, localhost is assumed. diff --git a/swarm/api/http/server.go b/swarm/api/http/server.go index 65f6afab72..74341899d2 100644 --- a/swarm/api/http/server.go +++ b/swarm/api/http/server.go @@ -86,7 +86,7 @@ type Request struct { uri *api.URI } -// HandlePostRaw handles a POST request to a raw bzzr:/ URI, stores the request +// HandlePostRaw handles a POST request to a raw bzz-raw:/ URI, stores the request // body in swarm and returns the resulting storage key as a text/plain response func (s *Server) HandlePostRaw(w http.ResponseWriter, r *Request) { if r.uri.Path != "" { @@ -290,9 +290,12 @@ func (s *Server) HandleDelete(w http.ResponseWriter, r *Request) { fmt.Fprint(w, newKey) } -// HandleGetRaw handles a GET request to bzzr:// and responds with -// the raw content stored at the given storage key -func (s *Server) HandleGetRaw(w http.ResponseWriter, r *Request) { +// HandleGet handles a GET request to +// - bzz-raw:// and responds with the raw content stored at the +// given storage key +// - bzz-hash:// and responds with the hash of the content stored +// at the given storage key as a text/plain response +func (s *Server) HandleGet(w http.ResponseWriter, r *Request) { key, err := s.api.Resolve(r.uri) if err != nil { s.Error(w, r, fmt.Errorf("error resolving %s: %s", r.uri.Addr, err)) @@ -345,15 +348,22 @@ func (s *Server) HandleGetRaw(w http.ResponseWriter, r *Request) { return } - // allow the request to overwrite the content type using a query - // parameter - contentType := "application/octet-stream" - if typ := r.URL.Query().Get("content_type"); typ != "" { - contentType = typ - } - w.Header().Set("Content-Type", contentType) + switch { + case r.uri.Raw(): + // allow the request to overwrite the content type using a query + // parameter + contentType := "application/octet-stream" + if typ := r.URL.Query().Get("content_type"); typ != "" { + contentType = typ + } + w.Header().Set("Content-Type", contentType) - http.ServeContent(w, &r.Request, "", time.Now(), reader) + http.ServeContent(w, &r.Request, "", time.Now(), reader) + case r.uri.Hash(): + w.Header().Set("Content-Type", "text/plain") + w.WriteHeader(http.StatusOK) + fmt.Fprint(w, key) + } } // HandleGetFiles handles a GET request to bzz:/ with an Accept @@ -424,14 +434,13 @@ func (s *Server) HandleGetFiles(w http.ResponseWriter, r *Request) { } } -// HandleGetList handles a GET request to bzz:// which has -// the "list" query parameter set to "true" and returns a list of all files -// contained in under grouped into common prefixes using -// "/" as a delimiter +// HandleGetList handles a GET request to bzz-list:// and returns +// a list of all files contained in under grouped into +// common prefixes using "/" as a delimiter func (s *Server) HandleGetList(w http.ResponseWriter, r *Request) { // ensure the root path has a trailing slash so that relative URLs work if r.uri.Path == "" && !strings.HasSuffix(r.URL.Path, "/") { - http.Redirect(w, &r.Request, r.URL.Path+"/?list=true", http.StatusMovedPermanently) + http.Redirect(w, &r.Request, r.URL.Path+"/", http.StatusMovedPermanently) return } @@ -453,7 +462,11 @@ func (s *Server) HandleGetList(w http.ResponseWriter, r *Request) { if strings.Contains(r.Header.Get("Accept"), "text/html") { w.Header().Set("Content-Type", "text/html") err := htmlListTemplate.Execute(w, &htmlListData{ - URI: r.uri, + URI: &api.URI{ + Scheme: "bzz", + Addr: r.uri.Addr, + Path: r.uri.Path, + }, List: &list, }) if err != nil { @@ -589,7 +602,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { switch r.Method { case "POST": - if uri.Raw() { + if uri.Raw() || uri.DeprecatedRaw() { s.HandlePostRaw(w, req) } else { s.HandlePostFiles(w, req) @@ -601,7 +614,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // new manifest leaving the existing one intact, so it isn't // strictly a traditional PUT request which replaces content // at a URI, and POST is more ubiquitous) - if uri.Raw() { + if uri.Raw() || uri.DeprecatedRaw() { ShowError(w, r, fmt.Sprintf("No PUT to %s allowed.", uri), http.StatusBadRequest) return } else { @@ -609,15 +622,20 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } case "DELETE": - if uri.Raw() { + if uri.Raw() || uri.DeprecatedRaw() { ShowError(w, r, fmt.Sprintf("No DELETE to %s allowed.", uri), http.StatusBadRequest) return } s.HandleDelete(w, req) case "GET": - if uri.Raw() { - s.HandleGetRaw(w, req) + if uri.Raw() || uri.Hash() || uri.DeprecatedRaw() { + s.HandleGet(w, req) + return + } + + if uri.List() { + s.HandleGetList(w, req) return } @@ -626,11 +644,6 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - if r.URL.Query().Get("list") == "true" { - s.HandleGetList(w, req) - return - } - s.HandleGetFile(w, req) default: diff --git a/swarm/api/http/server_test.go b/swarm/api/http/server_test.go index ffeaf6e0d8..305d5cf7db 100644 --- a/swarm/api/http/server_test.go +++ b/swarm/api/http/server_test.go @@ -33,7 +33,7 @@ import ( "github.com/ethereum/go-ethereum/swarm/testutil" ) -func TestBzzrGetPath(t *testing.T) { +func TestBzzGetPath(t *testing.T) { var err error @@ -70,7 +70,7 @@ func TestBzzrGetPath(t *testing.T) { wg.Wait() } - _, err = http.Get(srv.URL + "/bzzr:/" + common.ToHex(key[0])[2:] + "/a") + _, err = http.Get(srv.URL + "/bzz-raw:/" + common.ToHex(key[0])[2:] + "/a") if err != nil { t.Fatalf("Failed to connect to proxy: %v", err) } @@ -79,7 +79,7 @@ func TestBzzrGetPath(t *testing.T) { var resp *http.Response var respbody []byte - url := srv.URL + "/bzzr:/" + url := srv.URL + "/bzz-raw:/" if k[:] != "" { url += common.ToHex(key[0])[2:] + "/" + k[1:] + "?content_type=text/plain" } @@ -104,16 +104,140 @@ func TestBzzrGetPath(t *testing.T) { } } + for k, v := range testrequests { + var resp *http.Response + var respbody []byte + + url := srv.URL + "/bzz-hash:/" + if k[:] != "" { + url += common.ToHex(key[0])[2:] + "/" + k[1:] + } + resp, err = http.Get(url) + if err != nil { + t.Fatalf("Request failed: %v", err) + } + defer resp.Body.Close() + respbody, err = ioutil.ReadAll(resp.Body) + if err != nil { + t.Fatalf("Read request body: %v", err) + } + + if string(respbody) != key[v].String() { + isexpectedfailrequest := false + + for _, r := range expectedfailrequests { + if k[:] == r { + isexpectedfailrequest = true + } + } + if !isexpectedfailrequest { + t.Fatalf("Response body does not match, expected: %v, got %v", key[v], string(respbody)) + } + } + } + + for _, c := range []struct { + path string + json string + html string + }{ + { + path: "/", + json: `{"common_prefixes":["a/"]}`, + html: "\n\n\n \n \n Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/\n\n\n\n

Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/

\n
\n \n \n \n\t\n\t\n\t\n \n \n\n \n \n\t\n\t \n\t \n\t \n\t\n \n\n \n
PathTypeSize
a/DIR-
\n
\n\n", + }, + { + path: "/a/", + json: `{"common_prefixes":["a/b/"],"entries":[{"hash":"011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce","path":"a/a","mod_time":"0001-01-01T00:00:00Z"}]}`, + html: "\n\n\n \n \n Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/a/\n\n\n\n

Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/a/

\n
\n \n \n \n\t\n\t\n\t\n \n \n\n \n \n\t\n\t \n\t \n\t \n\t\n \n\n \n\t\n\t \n\t \n\t \n\t\n \n
PathTypeSize
b/DIR-
a0
\n
\n\n", + }, + { + path: "/a/b/", + json: `{"entries":[{"hash":"011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce","path":"a/b/b","mod_time":"0001-01-01T00:00:00Z"},{"hash":"011b4d03dd8c01f1049143cf9c4c817e4b167f1d1b83e5c6f0f10d89ba1e7bce","path":"a/b/c","mod_time":"0001-01-01T00:00:00Z"}]}`, + html: "\n\n\n \n \n Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/a/b/\n\n\n\n

Swarm index of bzz:/262e5c08c03c2789b6daef487dfa14b4d132f5340d781a3ecb1d5122ab65640c/a/b/

\n
\n \n \n \n\t\n\t\n\t\n \n \n\n \n \n\n \n\t\n\t \n\t \n\t \n\t\n \n\t\n\t \n\t \n\t \n\t\n \n
PathTypeSize
b0
c0
\n
\n\n", + }, + { + path: "/x", + }, + { + path: "", + }, + } { + k := c.path + url := srv.URL + "/bzz-list:/" + if k[:] != "" { + url += common.ToHex(key[0])[2:] + "/" + k[1:] + } + t.Run("json list "+c.path, func(t *testing.T) { + resp, err := http.Get(url) + if err != nil { + t.Fatalf("HTTP request: %v", err) + } + defer resp.Body.Close() + respbody, err := ioutil.ReadAll(resp.Body) + if err != nil { + t.Fatalf("Read response body: %v", err) + } + + body := strings.TrimSpace(string(respbody)) + if body != c.json { + isexpectedfailrequest := false + + for _, r := range expectedfailrequests { + if k[:] == r { + isexpectedfailrequest = true + } + } + if !isexpectedfailrequest { + t.Errorf("Response list body %q does not match, expected: %v, got %v", k, c.json, body) + } + } + }) + t.Run("html list "+c.path, func(t *testing.T) { + req, err := http.NewRequest(http.MethodGet, url, nil) + if err != nil { + t.Fatalf("New request: %v", err) + } + req.Header.Set("Accept", "text/html") + resp, err := http.DefaultClient.Do(req) + if err != nil { + t.Fatalf("HTTP request: %v", err) + } + defer resp.Body.Close() + respbody, err := ioutil.ReadAll(resp.Body) + if err != nil { + t.Fatalf("Read response body: %v", err) + } + + if string(respbody) != c.html { + isexpectedfailrequest := false + + for _, r := range expectedfailrequests { + if k[:] == r { + isexpectedfailrequest = true + } + } + if !isexpectedfailrequest { + t.Errorf("Response list body %q does not match, expected: %q, got %q", k, c.html, string(respbody)) + } + } + }) + } + nonhashtests := []string{ srv.URL + "/bzz:/name", - srv.URL + "/bzzi:/nonhash", - srv.URL + "/bzzr:/nonhash", + srv.URL + "/bzz-immutable:/nonhash", + srv.URL + "/bzz-raw:/nonhash", + srv.URL + "/bzz-list:/nonhash", + srv.URL + "/bzz-hash:/nonhash", } nonhashresponses := []string{ "error resolving name: no DNS to resolve name: "name"", "error resolving nonhash: immutable address not a content hash: "nonhash"", "error resolving nonhash: no DNS to resolve name: "nonhash"", + "error resolving nonhash: no DNS to resolve name: "nonhash"", + "error resolving nonhash: no DNS to resolve name: "nonhash"", } for i, url := range nonhashtests { diff --git a/swarm/api/http/templates.go b/swarm/api/http/templates.go index 9ae434a7ed..53ce7b5a22 100644 --- a/swarm/api/http/templates.go +++ b/swarm/api/http/templates.go @@ -52,7 +52,7 @@ var htmlListTemplate = template.Must(template.New("html-list").Funcs(template.Fu {{ range .List.CommonPrefixes }} - {{ basename . }}/ + {{ basename . }}/ DIR - diff --git a/swarm/api/uri.go b/swarm/api/uri.go index caed4212d5..d8aafedf41 100644 --- a/swarm/api/uri.go +++ b/swarm/api/uri.go @@ -26,10 +26,18 @@ import ( type URI struct { // Scheme has one of the following values: // - // * bzz - an entry in a swarm manifest + // * bzz - an entry in a swarm manifest + // * bzz-raw - raw swarm content + // * bzz-immutable - immutable URI of an entry in a swarm manifest + // (address is not resolved) + // * bzz-list - list of all files contained in a swarm manifest + // + // Deprecated Schemes: // * bzzr - raw swarm content // * bzzi - immutable URI of an entry in a swarm manifest // (address is not resolved) + // * bzz-hash - hash of swarm content + // Scheme string // Addr is either a hexadecimal storage key or it an address which @@ -50,7 +58,8 @@ type URI struct { // * :// // * :/// // -// with scheme one of bzz, bzzr or bzzi +// with scheme one of bzz, bzz-raw, bzz-immutable, bzz-list or bzz-hash +// or deprecated ones bzzr and bzzi func Parse(rawuri string) (*URI, error) { u, err := url.Parse(rawuri) if err != nil { @@ -60,7 +69,7 @@ func Parse(rawuri string) (*URI, error) { // check the scheme is valid switch uri.Scheme { - case "bzz", "bzzi", "bzzr": + case "bzz", "bzz-raw", "bzz-immutable", "bzz-list", "bzz-hash", "bzzr", "bzzi": default: return nil, fmt.Errorf("unknown scheme %q", u.Scheme) } @@ -84,13 +93,29 @@ func Parse(rawuri string) (*URI, error) { } func (u *URI) Raw() bool { - return u.Scheme == "bzzr" + return u.Scheme == "bzz-raw" } func (u *URI) Immutable() bool { + return u.Scheme == "bzz-immutable" +} + +func (u *URI) List() bool { + return u.Scheme == "bzz-list" +} + +func (u *URI) DeprecatedRaw() bool { + return u.Scheme == "bzzr" +} + +func (u *URI) DeprecatedImmutable() bool { return u.Scheme == "bzzi" } +func (u *URI) Hash() bool { + return u.Scheme == "bzz-hash" +} + func (u *URI) String() string { return u.Scheme + ":/" + u.Addr + "/" + u.Path } diff --git a/swarm/api/uri_test.go b/swarm/api/uri_test.go index 7d4160601d..137b4505d4 100644 --- a/swarm/api/uri_test.go +++ b/swarm/api/uri_test.go @@ -23,11 +23,15 @@ import ( func TestParseURI(t *testing.T) { type test struct { - uri string - expectURI *URI - expectErr bool - expectRaw bool - expectImmutable bool + uri string + expectURI *URI + expectErr bool + expectRaw bool + expectImmutable bool + expectList bool + expectHash bool + expectDeprecatedRaw bool + expectDeprecatedImmutable bool } tests := []test{ { @@ -47,13 +51,13 @@ func TestParseURI(t *testing.T) { expectURI: &URI{Scheme: "bzz"}, }, { - uri: "bzzi:", - expectURI: &URI{Scheme: "bzzi"}, + uri: "bzz-immutable:", + expectURI: &URI{Scheme: "bzz-immutable"}, expectImmutable: true, }, { - uri: "bzzr:", - expectURI: &URI{Scheme: "bzzr"}, + uri: "bzz-raw:", + expectURI: &URI{Scheme: "bzz-raw"}, expectRaw: true, }, { @@ -69,18 +73,18 @@ func TestParseURI(t *testing.T) { expectURI: &URI{Scheme: "bzz", Addr: "abc123", Path: "path/to/entry"}, }, { - uri: "bzzr:/", - expectURI: &URI{Scheme: "bzzr"}, + uri: "bzz-raw:/", + expectURI: &URI{Scheme: "bzz-raw"}, expectRaw: true, }, { - uri: "bzzr:/abc123", - expectURI: &URI{Scheme: "bzzr", Addr: "abc123"}, + uri: "bzz-raw:/abc123", + expectURI: &URI{Scheme: "bzz-raw", Addr: "abc123"}, expectRaw: true, }, { - uri: "bzzr:/abc123/path/to/entry", - expectURI: &URI{Scheme: "bzzr", Addr: "abc123", Path: "path/to/entry"}, + uri: "bzz-raw:/abc123/path/to/entry", + expectURI: &URI{Scheme: "bzz-raw", Addr: "abc123", Path: "path/to/entry"}, expectRaw: true, }, { @@ -95,6 +99,46 @@ func TestParseURI(t *testing.T) { uri: "bzz://abc123/path/to/entry", expectURI: &URI{Scheme: "bzz", Addr: "abc123", Path: "path/to/entry"}, }, + { + uri: "bzz-hash:", + expectURI: &URI{Scheme: "bzz-hash"}, + expectHash: true, + }, + { + uri: "bzz-hash:/", + expectURI: &URI{Scheme: "bzz-hash"}, + expectHash: true, + }, + { + uri: "bzz-list:", + expectURI: &URI{Scheme: "bzz-list"}, + expectList: true, + }, + { + uri: "bzz-list:/", + expectURI: &URI{Scheme: "bzz-list"}, + expectList: true, + }, + { + uri: "bzzr:", + expectURI: &URI{Scheme: "bzzr"}, + expectDeprecatedRaw: true, + }, + { + uri: "bzzr:/", + expectURI: &URI{Scheme: "bzzr"}, + expectDeprecatedRaw: true, + }, + { + uri: "bzzi:", + expectURI: &URI{Scheme: "bzzi"}, + expectDeprecatedImmutable: true, + }, + { + uri: "bzzi:/", + expectURI: &URI{Scheme: "bzzi"}, + expectDeprecatedImmutable: true, + }, } for _, x := range tests { actual, err := Parse(x.uri) @@ -116,5 +160,17 @@ func TestParseURI(t *testing.T) { if actual.Immutable() != x.expectImmutable { t.Fatalf("expected %s immutable to be %t, got %t", x.uri, x.expectImmutable, actual.Immutable()) } + if actual.List() != x.expectList { + t.Fatalf("expected %s list to be %t, got %t", x.uri, x.expectList, actual.List()) + } + if actual.Hash() != x.expectHash { + t.Fatalf("expected %s hash to be %t, got %t", x.uri, x.expectHash, actual.Hash()) + } + if actual.DeprecatedRaw() != x.expectDeprecatedRaw { + t.Fatalf("expected %s deprecated raw to be %t, got %t", x.uri, x.expectDeprecatedRaw, actual.DeprecatedRaw()) + } + if actual.DeprecatedImmutable() != x.expectDeprecatedImmutable { + t.Fatalf("expected %s deprecated immutable to be %t, got %t", x.uri, x.expectDeprecatedImmutable, actual.DeprecatedImmutable()) + } } } diff --git a/swarm/dev/scripts/random-uploads.sh b/swarm/dev/scripts/random-uploads.sh index db7887e3c0..563a51befc 100755 --- a/swarm/dev/scripts/random-uploads.sh +++ b/swarm/dev/scripts/random-uploads.sh @@ -46,7 +46,7 @@ main() { } do_random_upload() { - curl -fsSL -X POST --data-binary "$(random_data)" "http://${addr}/bzzr:/" + curl -fsSL -X POST --data-binary "$(random_data)" "http://${addr}/bzz-raw:/" } random_data() { diff --git a/swarm/storage/chunker_test.go b/swarm/storage/chunker_test.go index 6178a7bb1c..6b828970b6 100644 --- a/swarm/storage/chunker_test.go +++ b/swarm/storage/chunker_test.go @@ -60,7 +60,7 @@ func (self *chunkerTester) Split(chunker Splitter, data io.Reader, size int64, c for { select { case <-timeout: - return errors.New(("Split timeout error")) + return errors.New("Split timeout error") case <-quitC: return nil case chunk := <-chunkC: @@ -97,7 +97,7 @@ func (self *chunkerTester) Append(chunker Splitter, rootKey Key, data io.Reader, for { select { case <-timeout: - return errors.New(("Append timeout error")) + return errors.New("Append timeout error") case <-quitC: return nil case chunk := <-chunkC: @@ -146,7 +146,7 @@ func (self *chunkerTester) Join(chunker Chunker, key Key, c int, chunkC chan *Ch for { select { case <-timeout: - return errors.New(("Join timeout error")) + return errors.New("Join timeout error") case chunk, ok := <-chunkC: if !ok { close(quitC) @@ -155,7 +155,7 @@ func (self *chunkerTester) Join(chunker Chunker, key Key, c int, chunkC chan *Ch // this just mocks the behaviour of a chunk store retrieval stored, success := self.chunks[chunk.Key.String()] if !success { - return errors.New(("Not found")) + return errors.New("Not found") } chunk.SData = stored.SData chunk.Size = int64(binary.LittleEndian.Uint64(chunk.SData[0:8])) diff --git a/swarm/storage/pyramid.go b/swarm/storage/pyramid.go index f2e85cb5b0..19d493405a 100644 --- a/swarm/storage/pyramid.go +++ b/swarm/storage/pyramid.go @@ -338,7 +338,7 @@ func (self *PyramidChunker) loadTree(chunkLevel [][]*TreeEntry, key Key, chunkC chunkLevel[depth-1] = append(chunkLevel[depth-1], newEntry) // Add the rest of the tree - for lvl := (depth - 1); lvl >= 1; lvl-- { + for lvl := depth - 1; lvl >= 1; lvl-- { //TODO(jmozah): instead of loading finished branches and then trim in the end, //avoid loading them in the first place diff --git a/tests/block_test_util.go b/tests/block_test_util.go index a789e6d887..e2d1a0b43b 100644 --- a/tests/block_test_util.go +++ b/tests/block_test_util.go @@ -77,8 +77,8 @@ type btHeader struct { UncleHash common.Hash ExtraData []byte Difficulty *big.Int - GasLimit *big.Int - GasUsed *big.Int + GasLimit uint64 + GasUsed uint64 Timestamp *big.Int } @@ -86,8 +86,8 @@ type btHeaderMarshaling struct { ExtraData hexutil.Bytes Number *math.HexOrDecimal256 Difficulty *math.HexOrDecimal256 - GasLimit *math.HexOrDecimal256 - GasUsed *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal64 + GasUsed *math.HexOrDecimal64 Timestamp *math.HexOrDecimal256 } @@ -141,8 +141,8 @@ func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis { Timestamp: t.json.Genesis.Timestamp.Uint64(), ParentHash: t.json.Genesis.ParentHash, ExtraData: t.json.Genesis.ExtraData, - GasLimit: t.json.Genesis.GasLimit.Uint64(), - GasUsed: t.json.Genesis.GasUsed.Uint64(), + GasLimit: t.json.Genesis.GasLimit, + GasUsed: t.json.Genesis.GasUsed, Difficulty: t.json.Genesis.Difficulty, Mixhash: t.json.Genesis.MixHash, Coinbase: t.json.Genesis.Coinbase, @@ -234,11 +234,11 @@ func validateHeader(h *btHeader, h2 *types.Header) error { if h.Difficulty.Cmp(h2.Difficulty) != 0 { return fmt.Errorf("Difficulty: want: %v have: %v", h.Difficulty, h2.Difficulty) } - if h.GasLimit.Cmp(h2.GasLimit) != 0 { - return fmt.Errorf("GasLimit: want: %v have: %v", h.GasLimit, h2.GasLimit) + if h.GasLimit != h2.GasLimit { + return fmt.Errorf("GasLimit: want: %d have: %d", h.GasLimit, h2.GasLimit) } - if h.GasUsed.Cmp(h2.GasUsed) != 0 { - return fmt.Errorf("GasUsed: want: %v have: %v", h.GasUsed, h2.GasUsed) + if h.GasUsed != h2.GasUsed { + return fmt.Errorf("GasUsed: want: %d have: %d", h.GasUsed, h2.GasUsed) } if h.Timestamp.Cmp(h2.Time) != 0 { return fmt.Errorf("Timestamp: want: %v have: %v", h.Timestamp, h2.Time) diff --git a/tests/gen_btheader.go b/tests/gen_btheader.go index 5d65e0dbce..1be659ecb5 100644 --- a/tests/gen_btheader.go +++ b/tests/gen_btheader.go @@ -29,8 +29,8 @@ func (b btHeader) MarshalJSON() ([]byte, error) { UncleHash common.Hash ExtraData hexutil.Bytes Difficulty *math.HexOrDecimal256 - GasLimit *math.HexOrDecimal256 - GasUsed *math.HexOrDecimal256 + GasLimit math.HexOrDecimal64 + GasUsed math.HexOrDecimal64 Timestamp *math.HexOrDecimal256 } var enc btHeader @@ -47,8 +47,8 @@ func (b btHeader) MarshalJSON() ([]byte, error) { enc.UncleHash = b.UncleHash enc.ExtraData = b.ExtraData enc.Difficulty = (*math.HexOrDecimal256)(b.Difficulty) - enc.GasLimit = (*math.HexOrDecimal256)(b.GasLimit) - enc.GasUsed = (*math.HexOrDecimal256)(b.GasUsed) + enc.GasLimit = (math.HexOrDecimal64)(b.GasLimit) + enc.GasUsed = (math.HexOrDecimal64)(b.GasUsed) enc.Timestamp = (*math.HexOrDecimal256)(b.Timestamp) return json.Marshal(&enc) } @@ -68,8 +68,8 @@ func (b *btHeader) UnmarshalJSON(input []byte) error { UncleHash *common.Hash ExtraData hexutil.Bytes Difficulty *math.HexOrDecimal256 - GasLimit *math.HexOrDecimal256 - GasUsed *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal64 + GasUsed *math.HexOrDecimal64 Timestamp *math.HexOrDecimal256 } var dec btHeader @@ -116,10 +116,10 @@ func (b *btHeader) UnmarshalJSON(input []byte) error { b.Difficulty = (*big.Int)(dec.Difficulty) } if dec.GasLimit != nil { - b.GasLimit = (*big.Int)(dec.GasLimit) + b.GasLimit = uint64(*dec.GasLimit) } if dec.GasUsed != nil { - b.GasUsed = (*big.Int)(dec.GasUsed) + b.GasUsed = uint64(*dec.GasUsed) } if dec.Timestamp != nil { b.Timestamp = (*big.Int)(dec.Timestamp) diff --git a/tests/gen_stenv.go b/tests/gen_stenv.go index c780524bc3..1d4baf2fd7 100644 --- a/tests/gen_stenv.go +++ b/tests/gen_stenv.go @@ -17,14 +17,14 @@ func (s stEnv) MarshalJSON() ([]byte, error) { type stEnv struct { Coinbase common.UnprefixedAddress `json:"currentCoinbase" gencodec:"required"` Difficulty *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"` - GasLimit *math.HexOrDecimal256 `json:"currentGasLimit" gencodec:"required"` + GasLimit math.HexOrDecimal64 `json:"currentGasLimit" gencodec:"required"` Number math.HexOrDecimal64 `json:"currentNumber" gencodec:"required"` Timestamp math.HexOrDecimal64 `json:"currentTimestamp" gencodec:"required"` } var enc stEnv enc.Coinbase = common.UnprefixedAddress(s.Coinbase) enc.Difficulty = (*math.HexOrDecimal256)(s.Difficulty) - enc.GasLimit = (*math.HexOrDecimal256)(s.GasLimit) + enc.GasLimit = math.HexOrDecimal64(s.GasLimit) enc.Number = math.HexOrDecimal64(s.Number) enc.Timestamp = math.HexOrDecimal64(s.Timestamp) return json.Marshal(&enc) @@ -34,7 +34,7 @@ func (s *stEnv) UnmarshalJSON(input []byte) error { type stEnv struct { Coinbase *common.UnprefixedAddress `json:"currentCoinbase" gencodec:"required"` Difficulty *math.HexOrDecimal256 `json:"currentDifficulty" gencodec:"required"` - GasLimit *math.HexOrDecimal256 `json:"currentGasLimit" gencodec:"required"` + GasLimit *math.HexOrDecimal64 `json:"currentGasLimit" gencodec:"required"` Number *math.HexOrDecimal64 `json:"currentNumber" gencodec:"required"` Timestamp *math.HexOrDecimal64 `json:"currentTimestamp" gencodec:"required"` } @@ -53,7 +53,7 @@ func (s *stEnv) UnmarshalJSON(input []byte) error { if dec.GasLimit == nil { return errors.New("missing required field 'currentGasLimit' for stEnv") } - s.GasLimit = (*big.Int)(dec.GasLimit) + s.GasLimit = uint64(*dec.GasLimit) if dec.Number == nil { return errors.New("missing required field 'currentNumber' for stEnv") } diff --git a/tests/gen_tttransaction.go b/tests/gen_tttransaction.go index b6759be912..840bdfdd81 100644 --- a/tests/gen_tttransaction.go +++ b/tests/gen_tttransaction.go @@ -17,7 +17,7 @@ var _ = (*ttTransactionMarshaling)(nil) func (t ttTransaction) MarshalJSON() ([]byte, error) { type ttTransaction struct { Data hexutil.Bytes `gencodec:"required"` - GasLimit *math.HexOrDecimal256 `gencodec:"required"` + GasLimit math.HexOrDecimal64 `gencodec:"required"` GasPrice *math.HexOrDecimal256 `gencodec:"required"` Nonce math.HexOrDecimal64 `gencodec:"required"` Value *math.HexOrDecimal256 `gencodec:"required"` @@ -28,7 +28,7 @@ func (t ttTransaction) MarshalJSON() ([]byte, error) { } var enc ttTransaction enc.Data = t.Data - enc.GasLimit = (*math.HexOrDecimal256)(t.GasLimit) + enc.GasLimit = (math.HexOrDecimal64)(t.GasLimit) enc.GasPrice = (*math.HexOrDecimal256)(t.GasPrice) enc.Nonce = math.HexOrDecimal64(t.Nonce) enc.Value = (*math.HexOrDecimal256)(t.Value) @@ -42,7 +42,7 @@ func (t ttTransaction) MarshalJSON() ([]byte, error) { func (t *ttTransaction) UnmarshalJSON(input []byte) error { type ttTransaction struct { Data hexutil.Bytes `gencodec:"required"` - GasLimit *math.HexOrDecimal256 `gencodec:"required"` + GasLimit *math.HexOrDecimal64 `gencodec:"required"` GasPrice *math.HexOrDecimal256 `gencodec:"required"` Nonce *math.HexOrDecimal64 `gencodec:"required"` Value *math.HexOrDecimal256 `gencodec:"required"` @@ -62,7 +62,7 @@ func (t *ttTransaction) UnmarshalJSON(input []byte) error { if dec.GasLimit == nil { return errors.New("missing required field 'gasLimit' for ttTransaction") } - t.GasLimit = (*big.Int)(dec.GasLimit) + t.GasLimit = uint64(*dec.GasLimit) if dec.GasPrice == nil { return errors.New("missing required field 'gasPrice' for ttTransaction") } diff --git a/tests/state_test.go b/tests/state_test.go index 5a67b290db..100c776c1a 100644 --- a/tests/state_test.go +++ b/tests/state_test.go @@ -39,16 +39,12 @@ func TestState(t *testing.T) { st.fails(`^stRevertTest/RevertPrefoundEmptyOOG\.json/EIP158`, "bug in test") st.fails(`^stRevertTest/RevertPrecompiledTouch\.json/Byzantium`, "bug in test") st.fails(`^stRevertTest/RevertPrefoundEmptyOOG\.json/Byzantium`, "bug in test") - st.fails(`^stRandom/randomStatetest645\.json/EIP150/.*`, "known bug #15119") - st.fails(`^stRandom/randomStatetest645\.json/Frontier/.*`, "known bug #15119") - st.fails(`^stRandom/randomStatetest645\.json/Homestead/.*`, "known bug #15119") - st.fails(`^stRandom/randomStatetest644\.json/EIP150/.*`, "known bug #15119") - st.fails(`^stRandom/randomStatetest644\.json/Frontier/.*`, "known bug #15119") - st.fails(`^stRandom/randomStatetest644\.json/Homestead/.*`, "known bug #15119") + st.fails(`^stRandom2/randomStatetest64[45]\.json/(EIP150|Frontier|Homestead)/.*`, "known bug #15119") st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/EIP158/2`, "known bug ") st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/EIP158/3`, "known bug ") st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/Byzantium/2`, "known bug ") st.fails(`^stCreateTest/TransactionCollisionToEmpty\.json/Byzantium/3`, "known bug ") + st.walk(t, stateTestDir, func(t *testing.T, name string, test *StateTest) { for _, subtest := range test.Subtests() { subtest := subtest @@ -68,8 +64,7 @@ func TestState(t *testing.T) { } // Transactions with gasLimit above this value will not get a VM trace on failure. -//const traceErrorLimit = 400000 -const traceErrorLimit = 0 +const traceErrorLimit = 400000 func withTrace(t *testing.T, gasLimit uint64, test func(vm.Config) error) { err := test(vm.Config{}) @@ -93,4 +88,6 @@ func withTrace(t *testing.T, gasLimit uint64, test func(vm.Config) error) { } else { t.Log("EVM operation log:\n" + buf.String()) } + t.Logf("EVM output: 0x%x", tracer.Output()) + t.Logf("EVM error: %v", tracer.Error()) } diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 352f840d9f..78c05b0245 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -76,7 +76,7 @@ type stPostState struct { type stEnv struct { Coinbase common.Address `json:"currentCoinbase" gencodec:"required"` Difficulty *big.Int `json:"currentDifficulty" gencodec:"required"` - GasLimit *big.Int `json:"currentGasLimit" gencodec:"required"` + GasLimit uint64 `json:"currentGasLimit" gencodec:"required"` Number uint64 `json:"currentNumber" gencodec:"required"` Timestamp uint64 `json:"currentTimestamp" gencodec:"required"` } @@ -84,7 +84,7 @@ type stEnv struct { type stEnvMarshaling struct { Coinbase common.UnprefixedAddress Difficulty *math.HexOrDecimal256 - GasLimit *math.HexOrDecimal256 + GasLimit math.HexOrDecimal64 Number math.HexOrDecimal64 Timestamp math.HexOrDecimal64 } @@ -127,7 +127,7 @@ func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config) (*state.StateD } block, _ := t.genesis(config).ToBlock() db, _ := ethdb.NewMemDatabase() - statedb := makePreState(db, t.json.Pre) + statedb := MakePreState(db, t.json.Pre) post := t.json.Post[subtest.Fork][subtest.Index] msg, err := t.json.Tx.toMessage(post) @@ -158,7 +158,7 @@ func (t *StateTest) gasLimit(subtest StateSubtest) uint64 { return t.json.Tx.GasLimit[t.json.Post[subtest.Fork][subtest.Index].Indexes.Gas] } -func makePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB { +func MakePreState(db ethdb.Database, accounts core.GenesisAlloc) *state.StateDB { sdb := state.NewDatabase(db) statedb, _ := state.New(common.Hash{}, sdb) for addr, a := range accounts { @@ -180,7 +180,7 @@ func (t *StateTest) genesis(config *params.ChainConfig) *core.Genesis { Config: config, Coinbase: t.json.Env.Coinbase, Difficulty: t.json.Env.Difficulty, - GasLimit: t.json.Env.GasLimit.Uint64(), + GasLimit: t.json.Env.GasLimit, Number: t.json.Env.Number, Timestamp: t.json.Env.Timestamp, Alloc: t.json.Pre, @@ -233,7 +233,7 @@ func (tx *stTransaction) toMessage(ps stPostState) (core.Message, error) { return nil, fmt.Errorf("invalid tx data %q", dataHex) } - msg := types.NewMessage(from, to, tx.Nonce, value, new(big.Int).SetUint64(gasLimit), tx.GasPrice, data, true) + msg := types.NewMessage(from, to, tx.Nonce, value, gasLimit, tx.GasPrice, data, true) return msg, nil } diff --git a/tests/testdata b/tests/testdata index 37f555fbc0..2bb0c3da3b 160000 --- a/tests/testdata +++ b/tests/testdata @@ -1 +1 @@ -Subproject commit 37f555fbc091fbf761aa6f02227132fb31f0681c +Subproject commit 2bb0c3da3bbb15c528bcef2a7e5ac4bd73f81f87 diff --git a/tests/transaction_test_util.go b/tests/transaction_test_util.go index 472b3d6f24..2028d2a278 100644 --- a/tests/transaction_test_util.go +++ b/tests/transaction_test_util.go @@ -46,7 +46,7 @@ type ttJSON struct { type ttTransaction struct { Data []byte `gencodec:"required"` - GasLimit *big.Int `gencodec:"required"` + GasLimit uint64 `gencodec:"required"` GasPrice *big.Int `gencodec:"required"` Nonce uint64 `gencodec:"required"` Value *big.Int `gencodec:"required"` @@ -58,7 +58,7 @@ type ttTransaction struct { type ttTransactionMarshaling struct { Data hexutil.Bytes - GasLimit *math.HexOrDecimal256 + GasLimit math.HexOrDecimal64 GasPrice *math.HexOrDecimal256 Nonce math.HexOrDecimal64 Value *math.HexOrDecimal256 @@ -100,8 +100,8 @@ func (tt *ttTransaction) verify(signer types.Signer, tx *types.Transaction) erro if !bytes.Equal(tx.Data(), tt.Data) { return fmt.Errorf("Tx input data mismatch: got %x want %x", tx.Data(), tt.Data) } - if tx.Gas().Cmp(tt.GasLimit) != 0 { - return fmt.Errorf("GasLimit mismatch: got %v, want %v", tx.Gas(), tt.GasLimit) + if tx.Gas() != tt.GasLimit { + return fmt.Errorf("GasLimit mismatch: got %d, want %d", tx.Gas(), tt.GasLimit) } if tx.GasPrice().Cmp(tt.GasPrice) != 0 { return fmt.Errorf("GasPrice mismatch: got %v, want %v", tx.GasPrice(), tt.GasPrice) diff --git a/tests/vm_test_util.go b/tests/vm_test_util.go index 0aa37955ce..b365167a69 100644 --- a/tests/vm_test_util.go +++ b/tests/vm_test_util.go @@ -80,7 +80,7 @@ type vmExecMarshaling struct { func (t *VMTest) Run(vmconfig vm.Config) error { db, _ := ethdb.NewMemDatabase() - statedb := makePreState(db, t.json.Pre) + statedb := MakePreState(db, t.json.Pre) ret, gasRemaining, err := t.exec(statedb, vmconfig) if t.json.GasRemaining == nil { diff --git a/trie/trie.go b/trie/trie.go index c211e75549..7c1b5e1b61 100644 --- a/trie/trie.go +++ b/trie/trie.go @@ -489,7 +489,7 @@ func (t *Trie) Commit() (root common.Hash, err error) { func (t *Trie) CommitTo(db DatabaseWriter) (root common.Hash, err error) { hash, cached, err := t.hashRoot(db) if err != nil { - return (common.Hash{}), err + return common.Hash{}, err } t.root = cached t.cachegen++ diff --git a/vendor/github.com/rjeczalik/notify/README.md b/vendor/github.com/rjeczalik/notify/README.md index a728d1dd04..02a5f32908 100644 --- a/vendor/github.com/rjeczalik/notify/README.md +++ b/vendor/github.com/rjeczalik/notify/README.md @@ -18,4 +18,4 @@ Filesystem event notification library on steroids. (under active development) - [github.com/rjeczalik/cmd/notify](https://godoc.org/github.com/rjeczalik/cmd/notify) - [github.com/cortesi/devd](https://github.com/cortesi/devd) - [github.com/cortesi/modd](https://github.com/cortesi/modd) - +- [github.com/syncthing/syncthing-inotify](https://github.com/syncthing/syncthing-inotify) diff --git a/vendor/github.com/rjeczalik/notify/appveyor.yml b/vendor/github.com/rjeczalik/notify/appveyor.yml index 8e762d05cb..a495bd7c73 100644 --- a/vendor/github.com/rjeczalik/notify/appveyor.yml +++ b/vendor/github.com/rjeczalik/notify/appveyor.yml @@ -16,7 +16,7 @@ install: build_script: - go tool vet -all . - go build ./... - - go test -v -race ./... + - go test -v -timeout 60s -race ./... test: off diff --git a/vendor/github.com/rjeczalik/notify/debug.go b/vendor/github.com/rjeczalik/notify/debug.go index bd9bc468df..2a3eb33700 100644 --- a/vendor/github.com/rjeczalik/notify/debug.go +++ b/vendor/github.com/rjeczalik/notify/debug.go @@ -2,10 +2,52 @@ // Use of this source code is governed by the MIT license that can be // found in the LICENSE file. -// +build !debug - package notify -func dbgprint(...interface{}) {} +import ( + "log" + "os" + "runtime" + "strings" +) -func dbgprintf(string, ...interface{}) {} +var dbgprint func(...interface{}) + +var dbgprintf func(string, ...interface{}) + +var dbgcallstack func(max int) []string + +func init() { + if _, ok := os.LookupEnv("NOTIFY_DEBUG"); ok || debugTag { + log.SetOutput(os.Stdout) + log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds) + dbgprint = func(v ...interface{}) { + v = append([]interface{}{"[D] "}, v...) + log.Println(v...) + } + dbgprintf = func(format string, v ...interface{}) { + format = "[D] " + format + log.Printf(format, v...) + } + dbgcallstack = func(max int) []string { + pc, stack := make([]uintptr, max), make([]string, 0, max) + runtime.Callers(2, pc) + for _, pc := range pc { + if f := runtime.FuncForPC(pc); f != nil { + fname := f.Name() + idx := strings.LastIndex(fname, string(os.PathSeparator)) + if idx != -1 { + stack = append(stack, fname[idx+1:]) + } else { + stack = append(stack, fname) + } + } + } + return stack + } + return + } + dbgprint = func(v ...interface{}) {} + dbgprintf = func(format string, v ...interface{}) {} + dbgcallstack = func(max int) []string { return nil } +} diff --git a/vendor/github.com/rjeczalik/notify/debug_debug.go b/vendor/github.com/rjeczalik/notify/debug_debug.go index f0622917f5..6fca891ab3 100644 --- a/vendor/github.com/rjeczalik/notify/debug_debug.go +++ b/vendor/github.com/rjeczalik/notify/debug_debug.go @@ -6,38 +6,4 @@ package notify -import ( - "fmt" - "os" - "runtime" - "strings" -) - -func dbgprint(v ...interface{}) { - fmt.Printf("[D] ") - fmt.Print(v...) - fmt.Printf("\n\n") -} - -func dbgprintf(format string, v ...interface{}) { - fmt.Printf("[D] ") - fmt.Printf(format, v...) - fmt.Printf("\n\n") -} - -func dbgcallstack(max int) []string { - pc, stack := make([]uintptr, max), make([]string, 0, max) - runtime.Callers(2, pc) - for _, pc := range pc { - if f := runtime.FuncForPC(pc); f != nil { - fname := f.Name() - idx := strings.LastIndex(fname, string(os.PathSeparator)) - if idx != -1 { - stack = append(stack, fname[idx+1:]) - } else { - stack = append(stack, fname) - } - } - } - return stack -} +var debugTag bool = true diff --git a/vendor/github.com/rjeczalik/notify/debug_nodebug.go b/vendor/github.com/rjeczalik/notify/debug_nodebug.go new file mode 100644 index 0000000000..be391a2769 --- /dev/null +++ b/vendor/github.com/rjeczalik/notify/debug_nodebug.go @@ -0,0 +1,9 @@ +// Copyright (c) 2014-2015 The Notify Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +// +build !debug + +package notify + +var debugTag bool = false diff --git a/vendor/github.com/rjeczalik/notify/doc.go b/vendor/github.com/rjeczalik/notify/doc.go index 8a99ddda62..60543c0838 100644 --- a/vendor/github.com/rjeczalik/notify/doc.go +++ b/vendor/github.com/rjeczalik/notify/doc.go @@ -12,11 +12,14 @@ // source file. // // On top of filesystem watchers notify maintains a watchpoint tree, which provides -// strategy for creating and closing filesystem watches and dispatching filesystem +// a strategy for creating and closing filesystem watches and dispatching filesystem // events to user channels. // // An event set is just an event list joint using bitwise OR operator // into a single event value. +// Both the platform-independent (see Constants) and specific events can be used. +// Refer to the event_*.go source files for information about the available +// events. // // A filesystem watch or just a watch is platform-specific entity which represents // a single path registered for notifications for specific event set. Setting a watch @@ -35,6 +38,6 @@ // A watchpoint is a list of user channel and event set pairs for particular // path (watchpoint tree's node). A single watchpoint can contain multiple // different user channels registered to listen for one or more events. A single -// user channel can be registered in one or more watchpoints, recurisve and +// user channel can be registered in one or more watchpoints, recursive and // non-recursive ones as well. package notify diff --git a/vendor/github.com/rjeczalik/notify/event.go b/vendor/github.com/rjeczalik/notify/event.go index e045edcecc..c128841972 100644 --- a/vendor/github.com/rjeczalik/notify/event.go +++ b/vendor/github.com/rjeczalik/notify/event.go @@ -73,7 +73,7 @@ func (e Event) String() string { // // https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags // -// Under Linux (inotify) Sys() always returns a non-nil *syscall.InotifyEvent +// Under Linux (inotify) Sys() always returns a non-nil *unix.InotifyEvent // value, defined as: // // type InotifyEvent struct { diff --git a/vendor/github.com/rjeczalik/notify/event_inotify.go b/vendor/github.com/rjeczalik/notify/event_inotify.go index 82954a9b38..1f32bb73e0 100644 --- a/vendor/github.com/rjeczalik/notify/event_inotify.go +++ b/vendor/github.com/rjeczalik/notify/event_inotify.go @@ -6,7 +6,7 @@ package notify -import "syscall" +import "golang.org/x/sys/unix" // Platform independent event values. const ( @@ -25,18 +25,18 @@ const ( // Inotify specific masks are legal, implemented events that are guaranteed to // work with notify package on linux-based systems. const ( - InAccess = Event(syscall.IN_ACCESS) // File was accessed - InModify = Event(syscall.IN_MODIFY) // File was modified - InAttrib = Event(syscall.IN_ATTRIB) // Metadata changed - InCloseWrite = Event(syscall.IN_CLOSE_WRITE) // Writtable file was closed - InCloseNowrite = Event(syscall.IN_CLOSE_NOWRITE) // Unwrittable file closed - InOpen = Event(syscall.IN_OPEN) // File was opened - InMovedFrom = Event(syscall.IN_MOVED_FROM) // File was moved from X - InMovedTo = Event(syscall.IN_MOVED_TO) // File was moved to Y - InCreate = Event(syscall.IN_CREATE) // Subfile was created - InDelete = Event(syscall.IN_DELETE) // Subfile was deleted - InDeleteSelf = Event(syscall.IN_DELETE_SELF) // Self was deleted - InMoveSelf = Event(syscall.IN_MOVE_SELF) // Self was moved + InAccess = Event(unix.IN_ACCESS) // File was accessed + InModify = Event(unix.IN_MODIFY) // File was modified + InAttrib = Event(unix.IN_ATTRIB) // Metadata changed + InCloseWrite = Event(unix.IN_CLOSE_WRITE) // Writtable file was closed + InCloseNowrite = Event(unix.IN_CLOSE_NOWRITE) // Unwrittable file closed + InOpen = Event(unix.IN_OPEN) // File was opened + InMovedFrom = Event(unix.IN_MOVED_FROM) // File was moved from X + InMovedTo = Event(unix.IN_MOVED_TO) // File was moved to Y + InCreate = Event(unix.IN_CREATE) // Subfile was created + InDelete = Event(unix.IN_DELETE) // Subfile was deleted + InDeleteSelf = Event(unix.IN_DELETE_SELF) // Self was deleted + InMoveSelf = Event(unix.IN_MOVE_SELF) // Self was moved ) var osestr = map[Event]string{ @@ -56,15 +56,15 @@ var osestr = map[Event]string{ // Inotify behavior events are not **currently** supported by notify package. const ( - inDontFollow = Event(syscall.IN_DONT_FOLLOW) - inExclUnlink = Event(syscall.IN_EXCL_UNLINK) - inMaskAdd = Event(syscall.IN_MASK_ADD) - inOneshot = Event(syscall.IN_ONESHOT) - inOnlydir = Event(syscall.IN_ONLYDIR) + inDontFollow = Event(unix.IN_DONT_FOLLOW) + inExclUnlink = Event(unix.IN_EXCL_UNLINK) + inMaskAdd = Event(unix.IN_MASK_ADD) + inOneshot = Event(unix.IN_ONESHOT) + inOnlydir = Event(unix.IN_ONLYDIR) ) type event struct { - sys syscall.InotifyEvent + sys unix.InotifyEvent path string event Event } @@ -72,4 +72,4 @@ type event struct { func (e *event) Event() Event { return e.event } func (e *event) Path() string { return e.path } func (e *event) Sys() interface{} { return &e.sys } -func (e *event) isDir() (bool, error) { return e.sys.Mask&syscall.IN_ISDIR != 0, nil } +func (e *event) isDir() (bool, error) { return e.sys.Mask&unix.IN_ISDIR != 0, nil } diff --git a/vendor/github.com/rjeczalik/notify/event_readdcw.go b/vendor/github.com/rjeczalik/notify/event_readdcw.go index 11ead9e297..f7b82de0c4 100644 --- a/vendor/github.com/rjeczalik/notify/event_readdcw.go +++ b/vendor/github.com/rjeczalik/notify/event_readdcw.go @@ -27,7 +27,11 @@ const ( dirmarker ) -// ReadDirectoryChangesW filters. +// ReadDirectoryChangesW filters +// On Windows the following events can be passed to Watch. A different set of +// events (see actions below) are received on the channel passed to Watch. +// For more information refer to +// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx const ( FileNotifyChangeFileName = Event(syscall.FILE_NOTIFY_CHANGE_FILE_NAME) FileNotifyChangeDirName = Event(syscall.FILE_NOTIFY_CHANGE_DIR_NAME) @@ -48,7 +52,13 @@ const ( // this flag should be declared in: http://golang.org/src/pkg/syscall/ztypes_windows.go const syscallFileNotifyChangeSecurity = 0x00000100 -// ReadDirectoryChangesW actions. +// ReadDirectoryChangesW actions +// The following events are returned on the channel passed to Watch, but cannot +// be passed to Watch itself (see filters above). You can find a table showing +// the relation between actions and filteres at +// https://github.com/rjeczalik/notify/issues/10#issuecomment-66179535 +// The msdn documentation on actions is part of +// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364391(v=vs.85).aspx const ( FileActionAdded = Event(syscall.FILE_ACTION_ADDED) << 12 FileActionRemoved = Event(syscall.FILE_ACTION_REMOVED) << 12 diff --git a/vendor/github.com/rjeczalik/notify/node.go b/vendor/github.com/rjeczalik/notify/node.go index 29c1bb20af..aced8b9c44 100644 --- a/vendor/github.com/rjeczalik/notify/node.go +++ b/vendor/github.com/rjeczalik/notify/node.go @@ -6,7 +6,6 @@ package notify import ( "errors" - "fmt" "io/ioutil" "os" "path/filepath" @@ -71,7 +70,11 @@ Traverse: case errSkip: continue Traverse default: - return fmt.Errorf("error while traversing %q: %v", nd.Name, err) + return &os.PathError{ + Op: "error while traversing", + Path: nd.Name, + Err: err, + } } // TODO(rjeczalik): tolerate open failures - add failed names to // AddDirError and notify users which names are not added to the tree. diff --git a/vendor/github.com/rjeczalik/notify/watcher_fen.go b/vendor/github.com/rjeczalik/notify/watcher_fen.go index dd069f2a26..dfe77f2f1d 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_fen.go +++ b/vendor/github.com/rjeczalik/notify/watcher_fen.go @@ -33,14 +33,7 @@ type fen struct { // watched is a data structure representing watched file/directory. type watched struct { - // p is a path to watched file/directory - p string - // fi provides information about watched file/dir - fi os.FileInfo - // eDir represents events watched directly - eDir Event - // eNonDir represents events watched indirectly - eNonDir Event + trgWatched } // Stop implements trigger. @@ -55,7 +48,7 @@ func (f *fen) Close() (err error) { // NewWatched implements trigger. func (*fen) NewWatched(p string, fi os.FileInfo) (*watched, error) { - return &watched{p: p, fi: fi}, nil + return &watched{trgWatched{p: p, fi: fi}}, nil } // Record implements trigger. diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go index 9062c17c7f..7d9b97b65d 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go +++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go @@ -12,8 +12,6 @@ import ( "sync/atomic" ) -// TODO(rjeczalik): get rid of calls to canonical, it's tree responsibility - const ( failure = uint32(FSEventsMustScanSubDirs | FSEventsUserDropped | FSEventsKernelDropped) filter = uint32(FSEventsCreated | FSEventsRemoved | FSEventsRenamed | @@ -189,9 +187,6 @@ func newWatcher(c chan<- EventInfo) watcher { } func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) { - if path, err = canonical(path); err != nil { - return err - } if _, ok := fse.watches[path]; ok { return errAlreadyWatched } @@ -211,9 +206,6 @@ func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) { } func (fse *fsevents) unwatch(path string) (err error) { - if path, err = canonical(path); err != nil { - return - } w, ok := fse.watches[path] if !ok { return errNotWatched diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go index 5be64632e8..2248a1b129 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go +++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go @@ -26,9 +26,9 @@ import "C" import ( "errors" "os" + "runtime" "sync" "sync/atomic" - "time" "unsafe" ) @@ -48,7 +48,7 @@ var wg sync.WaitGroup // used to wait until the runloop starts // started and is ready via the wg. It also serves purpose of a dummy source, // thanks to it the runloop does not return as it also has at least one source // registered. -var source = C.CFRunLoopSourceCreate(nil, 0, &C.CFRunLoopSourceContext{ +var source = C.CFRunLoopSourceCreate(refZero, 0, &C.CFRunLoopSourceContext{ perform: (C.CFRunLoopPerformCallBack)(C.gosource), }) @@ -63,6 +63,10 @@ var ( func init() { wg.Add(1) go func() { + // There is exactly one run loop per thread. Lock this goroutine to its + // thread to ensure that it's not rescheduled on a different thread while + // setting up the run loop. + runtime.LockOSThread() runloop = C.CFRunLoopGetCurrent() C.CFRunLoopAddSource(runloop, source, C.kCFRunLoopDefaultMode) C.CFRunLoopRun() @@ -73,7 +77,6 @@ func init() { //export gosource func gosource(unsafe.Pointer) { - time.Sleep(time.Second) wg.Done() } @@ -159,8 +162,8 @@ func (s *stream) Start() error { return nil } wg.Wait() - p := C.CFStringCreateWithCStringNoCopy(nil, C.CString(s.path), C.kCFStringEncodingUTF8, nil) - path := C.CFArrayCreate(nil, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil) + p := C.CFStringCreateWithCStringNoCopy(refZero, C.CString(s.path), C.kCFStringEncodingUTF8, refZero) + path := C.CFArrayCreate(refZero, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil) ctx := C.FSEventStreamContext{} ref := C.EventStreamCreate(&ctx, C.uintptr_t(s.info), path, C.FSEventStreamEventId(atomic.LoadUint64(&since)), latency, flags) if ref == nilstream { diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go new file mode 100644 index 0000000000..0edd3782f5 --- /dev/null +++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go @@ -0,0 +1,9 @@ +// Copyright (c) 2017 The Notify Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +// +build darwin,!kqueue,go1.10 + +package notify + +const refZero = 0 diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.9.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.9.go new file mode 100644 index 0000000000..b81c3c1859 --- /dev/null +++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.9.go @@ -0,0 +1,14 @@ +// Copyright (c) 2017 The Notify Authors. All rights reserved. +// Use of this source code is governed by the MIT license that can be +// found in the LICENSE file. + +// +build darwin,!kqueue,cgo,!go1.10 + +package notify + +/* +#include +*/ +import "C" + +var refZero = (*C.struct___CFAllocator)(nil) diff --git a/vendor/github.com/rjeczalik/notify/watcher_inotify.go b/vendor/github.com/rjeczalik/notify/watcher_inotify.go index 3ceaa8f3ab..d082baca0f 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_inotify.go +++ b/vendor/github.com/rjeczalik/notify/watcher_inotify.go @@ -13,14 +13,15 @@ import ( "runtime" "sync" "sync/atomic" - "syscall" "unsafe" + + "golang.org/x/sys/unix" ) // eventBufferSize defines the size of the buffer given to read(2) function. One // should not depend on this value, since it was arbitrary chosen and may be // changed in the future. -const eventBufferSize = 64 * (syscall.SizeofInotifyEvent + syscall.PathMax + 1) +const eventBufferSize = 64 * (unix.SizeofInotifyEvent + unix.PathMax + 1) // consumersCount defines the number of consumers in producer-consumer based // implementation. Each consumer is run in a separate goroutine and has read @@ -43,7 +44,7 @@ type inotify struct { fd int32 // inotify file descriptor pipefd []int // pipe's read and write descriptors epfd int // epoll descriptor - epes []syscall.EpollEvent // epoll events + epes []unix.EpollEvent // epoll events buffer [eventBufferSize]byte // inotify event buffer wg sync.WaitGroup // wait group used to close main loop c chan<- EventInfo // event dispatcher channel @@ -56,13 +57,13 @@ func newWatcher(c chan<- EventInfo) watcher { fd: invalidDescriptor, pipefd: []int{invalidDescriptor, invalidDescriptor}, epfd: invalidDescriptor, - epes: make([]syscall.EpollEvent, 0), + epes: make([]unix.EpollEvent, 0), c: c, } runtime.SetFinalizer(i, func(i *inotify) { i.epollclose() if i.fd != invalidDescriptor { - syscall.Close(int(i.fd)) + unix.Close(int(i.fd)) } }) return i @@ -82,13 +83,13 @@ func (i *inotify) Rewatch(path string, _, newevent Event) error { // one. If called for the first time, this function initializes inotify filesystem // monitor and starts producer-consumers goroutines. func (i *inotify) watch(path string, e Event) (err error) { - if e&^(All|Event(syscall.IN_ALL_EVENTS)) != 0 { + if e&^(All|Event(unix.IN_ALL_EVENTS)) != 0 { return errors.New("notify: unknown event") } if err = i.lazyinit(); err != nil { return } - iwd, err := syscall.InotifyAddWatch(int(i.fd), path, encode(e)) + iwd, err := unix.InotifyAddWatch(int(i.fd), path, encode(e)) if err != nil { return } @@ -119,13 +120,13 @@ func (i *inotify) lazyinit() error { i.Lock() defer i.Unlock() if atomic.LoadInt32(&i.fd) == invalidDescriptor { - fd, err := syscall.InotifyInit() + fd, err := unix.InotifyInit1(unix.IN_CLOEXEC) if err != nil { return err } i.fd = int32(fd) if err = i.epollinit(); err != nil { - _, _ = i.epollclose(), syscall.Close(int(fd)) // Ignore errors. + _, _ = i.epollclose(), unix.Close(int(fd)) // Ignore errors. i.fd = invalidDescriptor return err } @@ -145,33 +146,33 @@ func (i *inotify) lazyinit() error { // with inotify event queue and the read end of the pipe are added to epoll set. // Note that `fd` member must be set before this function is called. func (i *inotify) epollinit() (err error) { - if i.epfd, err = syscall.EpollCreate1(0); err != nil { + if i.epfd, err = unix.EpollCreate1(0); err != nil { return } - if err = syscall.Pipe(i.pipefd); err != nil { + if err = unix.Pipe(i.pipefd); err != nil { return } - i.epes = []syscall.EpollEvent{ - {Events: syscall.EPOLLIN, Fd: i.fd}, - {Events: syscall.EPOLLIN, Fd: int32(i.pipefd[0])}, + i.epes = []unix.EpollEvent{ + {Events: unix.EPOLLIN, Fd: i.fd}, + {Events: unix.EPOLLIN, Fd: int32(i.pipefd[0])}, } - if err = syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil { + if err = unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil { return } - return syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1]) + return unix.EpollCtl(i.epfd, unix.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1]) } // epollclose closes the file descriptor created by the call to epoll_create(2) // and two file descriptors opened by pipe(2) function. func (i *inotify) epollclose() (err error) { if i.epfd != invalidDescriptor { - if err = syscall.Close(i.epfd); err == nil { + if err = unix.Close(i.epfd); err == nil { i.epfd = invalidDescriptor } } for n, fd := range i.pipefd { if fd != invalidDescriptor { - switch e := syscall.Close(fd); { + switch e := unix.Close(fd); { case e != nil && err == nil: err = e case e == nil: @@ -187,10 +188,10 @@ func (i *inotify) epollclose() (err error) { // one of the event's consumers. If pipe fd became ready, loop function closes // all file descriptors opened by lazyinit method and returns afterwards. func (i *inotify) loop(esch chan<- []*event) { - epes := make([]syscall.EpollEvent, 1) + epes := make([]unix.EpollEvent, 1) fd := atomic.LoadInt32(&i.fd) for { - switch _, err := syscall.EpollWait(i.epfd, epes, -1); err { + switch _, err := unix.EpollWait(i.epfd, epes, -1); err { case nil: switch epes[0].Fd { case fd: @@ -199,17 +200,17 @@ func (i *inotify) loop(esch chan<- []*event) { case int32(i.pipefd[0]): i.Lock() defer i.Unlock() - if err = syscall.Close(int(fd)); err != nil && err != syscall.EINTR { + if err = unix.Close(int(fd)); err != nil && err != unix.EINTR { panic("notify: close(2) error " + err.Error()) } atomic.StoreInt32(&i.fd, invalidDescriptor) - if err = i.epollclose(); err != nil && err != syscall.EINTR { + if err = i.epollclose(); err != nil && err != unix.EINTR { panic("notify: epollclose error " + err.Error()) } close(esch) return } - case syscall.EINTR: + case unix.EINTR: continue default: // We should never reach this line. panic("notify: epoll_wait(2) error " + err.Error()) @@ -220,22 +221,22 @@ func (i *inotify) loop(esch chan<- []*event) { // read reads events from an inotify file descriptor. It does not handle errors // returned from read(2) function since they are not critical to watcher logic. func (i *inotify) read() (es []*event) { - n, err := syscall.Read(int(i.fd), i.buffer[:]) - if err != nil || n < syscall.SizeofInotifyEvent { + n, err := unix.Read(int(i.fd), i.buffer[:]) + if err != nil || n < unix.SizeofInotifyEvent { return } - var sys *syscall.InotifyEvent - nmin := n - syscall.SizeofInotifyEvent + var sys *unix.InotifyEvent + nmin := n - unix.SizeofInotifyEvent for pos, path := 0, ""; pos <= nmin; { - sys = (*syscall.InotifyEvent)(unsafe.Pointer(&i.buffer[pos])) - pos += syscall.SizeofInotifyEvent + sys = (*unix.InotifyEvent)(unsafe.Pointer(&i.buffer[pos])) + pos += unix.SizeofInotifyEvent if path = ""; sys.Len > 0 { endpos := pos + int(sys.Len) path = string(bytes.TrimRight(i.buffer[pos:endpos], "\x00")) pos = endpos } es = append(es, &event{ - sys: syscall.InotifyEvent{ + sys: unix.InotifyEvent{ Wd: sys.Wd, Mask: sys.Mask, Cookie: sys.Cookie, @@ -268,7 +269,7 @@ func (i *inotify) transform(es []*event) []*event { var multi []*event i.RLock() for idx, e := range es { - if e.sys.Mask&(syscall.IN_IGNORED|syscall.IN_Q_OVERFLOW) != 0 { + if e.sys.Mask&(unix.IN_IGNORED|unix.IN_Q_OVERFLOW) != 0 { es[idx] = nil continue } @@ -317,7 +318,7 @@ func encode(e Event) uint32 { // can be nil when the event should not be passed on. func decode(mask Event, e *event) (syse *event) { if sysmask := uint32(mask) & e.sys.Mask; sysmask != 0 { - syse = &event{sys: syscall.InotifyEvent{ + syse = &event{sys: unix.InotifyEvent{ Wd: e.sys.Wd, Mask: e.sys.Mask, Cookie: e.sys.Cookie, @@ -357,7 +358,7 @@ func (i *inotify) Unwatch(path string) (err error) { return errors.New("notify: path " + path + " is already watched") } fd := atomic.LoadInt32(&i.fd) - if _, err = syscall.InotifyRmWatch(int(fd), uint32(iwd)); err != nil { + if err = removeInotifyWatch(fd, iwd); err != nil { return } i.Lock() @@ -377,12 +378,12 @@ func (i *inotify) Close() (err error) { return nil } for iwd := range i.m { - if _, e := syscall.InotifyRmWatch(int(i.fd), uint32(iwd)); e != nil && err == nil { + if e := removeInotifyWatch(i.fd, iwd); e != nil && err == nil { err = e } delete(i.m, iwd) } - switch _, errwrite := syscall.Write(i.pipefd[1], []byte{0x00}); { + switch _, errwrite := unix.Write(i.pipefd[1], []byte{0x00}); { case errwrite != nil && err == nil: err = errwrite fallthrough @@ -394,3 +395,11 @@ func (i *inotify) Close() (err error) { } return } + +// if path was removed, notify already removed the watch and returns EINVAL error +func removeInotifyWatch(fd int32, iwd int32) (err error) { + if _, err = unix.InotifyRmWatch(int(fd), uint32(iwd)); err != nil && err != unix.EINVAL { + return + } + return nil +} diff --git a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go index 6d500b700d..22e3c2c4a4 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go +++ b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go @@ -36,16 +36,9 @@ type kq struct { // watched is a data structure representing watched file/directory. type watched struct { - // p is a path to watched file/directory. - p string + trgWatched // fd is a file descriptor for watched file/directory. fd int - // fi provides information about watched file/dir. - fi os.FileInfo - // eDir represents events watched directly. - eDir Event - // eNonDir represents events watched indirectly. - eNonDir Event } // Stop implements trigger. @@ -66,7 +59,10 @@ func (*kq) NewWatched(p string, fi os.FileInfo) (*watched, error) { if err != nil { return nil, err } - return &watched{fd: fd, p: p, fi: fi}, nil + return &watched{ + trgWatched: trgWatched{p: p, fi: fi}, + fd: fd, + }, nil } // Record implements trigger. diff --git a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go index 5923bfddae..1494fcd799 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go +++ b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go @@ -284,16 +284,18 @@ func (r *readdcw) watch(path string, event Event, recursive bool) (err error) { return } r.Lock() + defer r.Unlock() if wd, ok = r.m[path]; ok { - r.Unlock() + dbgprint("watch: exists already") return } if wd, err = newWatched(r.cph, uint32(event), recursive, path); err != nil { - r.Unlock() return } r.m[path] = wd - r.Unlock() + dbgprint("watch: new watch added") + } else { + dbgprint("watch: exists already") } return nil } @@ -337,33 +339,32 @@ func (r *readdcw) loop() { continue } overEx := (*overlappedEx)(unsafe.Pointer(overlapped)) - if n == 0 { - r.loopstate(overEx) - } else { + if n != 0 { r.loopevent(n, overEx) if err = overEx.parent.readDirChanges(); err != nil { // TODO: error handling } } + r.loopstate(overEx) } } // TODO(pknap) : doc func (r *readdcw) loopstate(overEx *overlappedEx) { - filter := atomic.LoadUint32(&overEx.parent.parent.filter) + r.Lock() + defer r.Unlock() + filter := overEx.parent.parent.filter if filter&onlyMachineStates == 0 { return } if overEx.parent.parent.count--; overEx.parent.parent.count == 0 { switch filter & onlyMachineStates { case stateRewatch: - r.Lock() + dbgprint("loopstate rewatch") overEx.parent.parent.recreate(r.cph) - r.Unlock() case stateUnwatch: - r.Lock() + dbgprint("loopstate unwatch") delete(r.m, syscall.UTF16ToString(overEx.parent.pathw)) - r.Unlock() case stateCPClose: default: panic(`notify: windows loopstate logic error`) @@ -450,8 +451,8 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool } var wd *watched r.Lock() - if wd, err = r.nonStateWatched(path); err != nil { - r.Unlock() + defer r.Unlock() + if wd, err = r.nonStateWatchedLocked(path); err != nil { return } if wd.filter&(onlyNotifyChanges|onlyNGlobalEvents) != oldevent { @@ -462,21 +463,19 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool if err = wd.closeHandle(); err != nil { wd.filter = oldevent wd.recursive = recursive - r.Unlock() return } - r.Unlock() return } // TODO : pknap -func (r *readdcw) nonStateWatched(path string) (wd *watched, err error) { +func (r *readdcw) nonStateWatchedLocked(path string) (wd *watched, err error) { wd, ok := r.m[path] if !ok || wd == nil { err = errors.New(`notify: ` + path + ` path is unwatched`) return } - if filter := atomic.LoadUint32(&wd.filter); filter&onlyMachineStates != 0 { + if wd.filter&onlyMachineStates != 0 { err = errors.New(`notify: another re/unwatching operation in progress`) return } @@ -497,17 +496,26 @@ func (r *readdcw) RecursiveUnwatch(path string) error { func (r *readdcw) unwatch(path string) (err error) { var wd *watched r.Lock() - if wd, err = r.nonStateWatched(path); err != nil { - r.Unlock() + defer r.Unlock() + if wd, err = r.nonStateWatchedLocked(path); err != nil { return } wd.filter |= stateUnwatch if err = wd.closeHandle(); err != nil { wd.filter &^= stateUnwatch - r.Unlock() return } - r.Unlock() + if _, attrErr := syscall.GetFileAttributes(&wd.pathw[0]); attrErr != nil { + for _, g := range wd.digrip { + if g != nil { + dbgprint("unwatch: posting") + if err = syscall.PostQueuedCompletionStatus(r.cph, 0, 0, (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped))); err != nil { + wd.filter &^= stateUnwatch + return + } + } + } + } return } diff --git a/vendor/github.com/rjeczalik/notify/watcher_trigger.go b/vendor/github.com/rjeczalik/notify/watcher_trigger.go index d079d59b0a..78151f909b 100644 --- a/vendor/github.com/rjeczalik/notify/watcher_trigger.go +++ b/vendor/github.com/rjeczalik/notify/watcher_trigger.go @@ -23,6 +23,7 @@ package notify import ( + "fmt" "os" "path/filepath" "strings" @@ -56,6 +57,19 @@ type trigger interface { IsStop(n interface{}, err error) bool } +// trgWatched is a the base data structure representing watched file/directory. +// The platform specific full data structure (watched) must embed this type. +type trgWatched struct { + // p is a path to watched file/directory. + p string + // fi provides information about watched file/dir. + fi os.FileInfo + // eDir represents events watched directly. + eDir Event + // eNonDir represents events watched indirectly. + eNonDir Event +} + // encode Event to native representation. Implementation is to be provided by // platform specific implementation. var encode func(Event, bool) int64 @@ -117,6 +131,9 @@ func (t *trg) Close() (err error) { dbgprintf("trg: closing native watch failed: %q\n", e) err = nonil(err, e) } + if remaining := len(t.pthLkp); remaining != 0 { + err = nonil(err, fmt.Errorf("Not all watches were removed: len(t.pthLkp) == %v", len(t.pthLkp))) + } t.Unlock() return } @@ -175,7 +192,7 @@ func decode(o int64, w Event) (e Event) { func (t *trg) watch(p string, e Event, fi os.FileInfo) error { if err := t.singlewatch(p, e, dir, fi); err != nil { if err != errAlreadyWatched { - return nil + return err } } if fi.IsDir() { @@ -361,7 +378,7 @@ func (t *trg) singleunwatch(p string, direct mode) error { } if w.eNonDir|w.eDir != 0 { mod := dir - if w.eNonDir == 0 { + if w.eNonDir != 0 { mod = ndir } if err := t.singlewatch(p, w.eNonDir|w.eDir, mod, diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock new file mode 100644 index 0000000000..c1b0e0a3fb --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.lock @@ -0,0 +1,21 @@ +# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. + + +[[projects]] + branch = "v1" + name = "gopkg.in/check.v1" + packages = ["."] + revision = "20d25e2804050c1cd24a7eea1e7a6447dd0e74ec" + +[[projects]] + branch = "v3" + name = "gopkg.in/olebedev/go-duktape.v3" + packages = ["."] + revision = "391c1c40178e77a6003d889b96e0e41129aeb894" + +[solve-meta] + analyzer-name = "dep" + analyzer-version = 1 + inputs-digest = "043f802c0b40e2622bf784443d3e3959f0d01e9a795e3bfe30a72060dec10c63" + solver-name = "gps-cdcl" + solver-version = 1 diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml new file mode 100644 index 0000000000..ea8dc6de3d --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/Gopkg.toml @@ -0,0 +1,3 @@ +[[constraint]] + branch = "v1" + name = "gopkg.in/check.v1" \ No newline at end of file diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md b/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md new file mode 100644 index 0000000000..785c85309e --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2015 Oleg Lebedev + +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/olebedev/go-duktape.v3/README.md b/vendor/gopkg.in/olebedev/go-duktape.v3/README.md new file mode 100644 index 0000000000..2ddaad5e10 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/README.md @@ -0,0 +1,124 @@ +# Duktape bindings for Go(Golang) + +[![wercker status](https://app.wercker.com/status/3a5bb2e639a4b4efaf4c8bf7cab7442d/s "wercker status")](https://app.wercker.com/project/bykey/3a5bb2e639a4b4efaf4c8bf7cab7442d) +[![Travis status](https://travis-ci.org/olebedev/go-duktape.svg?branch=v3)](https://travis-ci.org/olebedev/go-duktape) +[![Appveyor status](https://ci.appveyor.com/api/projects/status/github/olebedev/go-duktape?branch=v3&svg=true)](https://ci.appveyor.com/project/olebedev/go-duktape/branch/v3) +[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/olebedev/go-duktape?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) + +[Duktape](http://duktape.org/index.html) is a thin, embeddable javascript engine. +Most of the [api](http://duktape.org/api.html) is implemented. +The exceptions are listed [here](https://github.com/olebedev/go-duktape/blob/master/api.go#L1566). + +### Usage + +The package is fully go-getable, no need to install any external C libraries. +So, just type `go get gopkg.in/olebedev/go-duktape.v3` to install. + + +```go +package main + +import "fmt" +import "gopkg.in/olebedev/go-duktape.v3" + +func main() { + ctx := duktape.New() + ctx.PevalString(`2 + 3`) + result := ctx.GetNumber(-1) + ctx.Pop() + fmt.Println("result is:", result) + // To prevent memory leaks, don't forget to clean up after + // yourself when you're done using a context. + ctx.DestroyHeap() +} +``` + +### Go specific notes + +Bindings between Go and Javascript contexts are not fully functional. +However, binding a Go function to the Javascript context is available: +```go +package main + +import "fmt" +import "gopkg.in/olebedev/go-duktape.v3" + +func main() { + ctx := duktape.New() + ctx.PushGlobalGoFunction("log", func(c *duktape.Context) int { + fmt.Println(c.SafeToString(-1)) + return 0 + }) + ctx.PevalString(`log('Go lang Go!')`) +} +``` +then run it. +```bash +$ go run *.go +Go lang Go! +$ +``` + +### Timers + +There is a method to inject timers to the global scope: +```go +package main + +import "fmt" +import "gopkg.in/olebedev/go-duktape.v3" + +func main() { + ctx := duktape.New() + + // Let's inject `setTimeout`, `setInterval`, `clearTimeout`, + // `clearInterval` into global scope. + ctx.PushTimers() + + ch := make(chan string) + ctx.PushGlobalGoFunction("second", func(_ *Context) int { + ch <- "second step" + return 0 + }) + ctx.PevalString(` + setTimeout(second, 0); + print('first step'); + `) + fmt.Println(<-ch) +} +``` +then run it +```bash +$ go run *.go +first step +second step +$ +``` + +Also you can `FlushTimers()`. + +### Command line tool + +Install `go get gopkg.in/olebedev/go-duktape.v3/...`. +Execute file.js: `$GOPATH/bin/go-duk file.js`. + +### Benchmarks +| prog | time | +| ------------|-------| +|[otto](https://github.com/robertkrimen/otto)|200.13s| +|[anko](https://github.com/mattn/anko)|231.19s| +|[agora](https://github.com/PuerkitoBio/agora/)|149.33s| +|[GopherLua](https://github.com/yuin/gopher-lua/)|8.39s| +|**go-duktape**|**9.80s**| + +More details are [here](https://github.com/olebedev/go-duktape/wiki/Benchmarks). + +### Status + +The package is not fully tested, so be careful. + + +### Contribution + +Pull requests are welcome! Also, if you want to discuss something send a pull request with proposal and changes. +__Convention:__ fork the repository and make changes on your fork in a feature branch. diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/api.go b/vendor/gopkg.in/olebedev/go-duktape.v3/api.go new file mode 100644 index 0000000000..6617ec23db --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/api.go @@ -0,0 +1,1616 @@ +package duktape + +/* +#cgo !windows CFLAGS: -std=c99 -O3 -Wall -fomit-frame-pointer -fstrict-aliasing +#cgo windows CFLAGS: -O3 -Wall -fomit-frame-pointer -fstrict-aliasing + +#include "duktape.h" +#include "duk_logging.h" +#include "duk_v1_compat.h" +#include "duk_print_alert.h" +static void _duk_eval_string(duk_context *ctx, const char *str) { + duk_eval_string(ctx, str); +} +static void _duk_compile(duk_context *ctx, duk_uint_t flags) { + duk_compile(ctx, flags); +} +static void _duk_compile_file(duk_context *ctx, duk_uint_t flags, const char *path) { + duk_compile_file(ctx, flags, path); +} +static void _duk_compile_lstring(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) { + duk_compile_lstring(ctx, flags, src, len); +} +static void _duk_compile_lstring_filename(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) { + duk_compile_lstring_filename(ctx, flags, src, len); +} +static void _duk_compile_string(duk_context *ctx, duk_uint_t flags, const char *src) { + duk_compile_string(ctx, flags, src); +} +static void _duk_compile_string_filename(duk_context *ctx, duk_uint_t flags, const char *src) { + duk_compile_string_filename(ctx, flags, src); +} +static void _duk_dump_context_stderr(duk_context *ctx) { + duk_dump_context_stderr(ctx); +} +static void _duk_dump_context_stdout(duk_context *ctx) { + duk_dump_context_stdout(ctx); +} +static void _duk_eval(duk_context *ctx) { + duk_eval(ctx); +} +static void _duk_eval_file(duk_context *ctx, const char *path) { + duk_eval_file(ctx, path); +} +static void _duk_eval_file_noresult(duk_context *ctx, const char *path) { + duk_eval_file_noresult(ctx, path); +} +static void _duk_eval_lstring(duk_context *ctx, const char *src, duk_size_t len) { + duk_eval_lstring(ctx, src, len); +} +static void _duk_eval_lstring_noresult(duk_context *ctx, const char *src, duk_size_t len) { + duk_eval_lstring_noresult(ctx, src, len); +} +static void _duk_eval_noresult(duk_context *ctx) { + duk_eval_noresult(ctx); +} +static void _duk_eval_string_noresult(duk_context *ctx, const char *src) { + duk_eval_string_noresult(ctx, src); +} +static duk_bool_t _duk_is_error(duk_context *ctx, duk_idx_t index) { + return duk_is_error(ctx, index); +} +static duk_bool_t _duk_is_object_coercible(duk_context *ctx, duk_idx_t index) { + return duk_is_object_coercible(ctx, index); +} +static duk_int_t _duk_pcompile(duk_context *ctx, duk_uint_t flags) { + return duk_pcompile(ctx, flags); +} +static duk_int_t _duk_pcompile_file(duk_context *ctx, duk_uint_t flags, const char *path) { + return duk_pcompile_file(ctx, flags, path); +} +static duk_int_t _duk_pcompile_lstring(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) { + return duk_pcompile_lstring(ctx, flags, src, len); +} +static duk_int_t _duk_pcompile_lstring_filename(duk_context *ctx, duk_uint_t flags, const char *src, duk_size_t len) { + return duk_pcompile_lstring_filename(ctx, flags, src, len); +} +static duk_int_t _duk_pcompile_string(duk_context *ctx, duk_uint_t flags, const char *src) { + return duk_pcompile_string(ctx, flags, src); +} +static duk_int_t _duk_pcompile_string_filename(duk_context *ctx, duk_uint_t flags, const char *src) { + return duk_pcompile_string_filename(ctx, flags, src); +} +static duk_int_t _duk_peval(duk_context *ctx) { + return duk_peval(ctx); +} +static duk_int_t _duk_peval_file(duk_context *ctx, const char *path) { + return duk_peval_file(ctx, path); +} +static duk_int_t _duk_peval_file_noresult(duk_context *ctx, const char *path) { + return duk_peval_file_noresult(ctx, path); +} +static duk_int_t _duk_peval_lstring(duk_context *ctx, const char *src, duk_size_t len) { + return duk_peval_lstring(ctx, src, len); +} +static duk_int_t _duk_peval_lstring_noresult(duk_context *ctx, const char *src, duk_size_t len) { + return duk_peval_lstring_noresult(ctx, src, len); +} +static duk_int_t _duk_peval_noresult(duk_context *ctx) { + return duk_peval_noresult(ctx); +} +static duk_int_t _duk_peval_string(duk_context *ctx, const char *src) { + return duk_peval_string(ctx, src); +} +static duk_int_t _duk_peval_string_noresult(duk_context *ctx, const char *src) { + return duk_peval_string_noresult(ctx, src); +} +static const char *_duk_push_string_file(duk_context *ctx, const char *path) { + return duk_push_string_file(ctx, path); +} +static duk_idx_t _duk_push_thread(duk_context *ctx) { + return duk_push_thread(ctx); +} +static duk_idx_t _duk_push_thread_new_globalenv(duk_context *ctx) { + return duk_push_thread_new_globalenv(ctx); +} +static void _duk_require_object_coercible(duk_context *ctx, duk_idx_t index) { + duk_require_object_coercible(ctx, index); +} +static void _duk_require_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask) { + duk_require_type_mask(ctx, index, mask); +} +static const char *_duk_safe_to_string(duk_context *ctx, duk_idx_t index) { + return duk_safe_to_string(ctx, index); +} +static void _duk_xcopy_top(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count) { + duk_xcopy_top(to_ctx, from_ctx, count); +} +static void _duk_xmove_top(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count) { + duk_xmove_top(to_ctx, from_ctx, count); +} +static void *_duk_to_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk_to_buffer(ctx, index, out_size); +} +static void *_duk_to_dynamic_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk_to_dynamic_buffer(ctx, index, out_size); +} +static void *_duk_to_fixed_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) { + return duk_to_fixed_buffer(ctx, index, out_size); +} +static duk_int_t _duk_is_primitive(duk_context *ctx, duk_idx_t index) { + return duk_is_primitive(ctx, index); +} +static void *_duk_push_buffer(duk_context *ctx, duk_size_t size, duk_bool_t dynamic) { + return duk_push_buffer(ctx, size, dynamic); +} +static void *_duk_push_fixed_buffer(duk_context *ctx, duk_size_t size) { + return duk_push_fixed_buffer(ctx, size); +} +static void *_duk_push_dynamic_buffer(duk_context *ctx, duk_size_t size) { + return duk_push_dynamic_buffer(ctx, size); +} +static void _duk_error(duk_context *ctx, duk_errcode_t err_code, const char *str) { + duk_error(ctx, err_code, "%s", str); +} +static void _duk_push_error_object(duk_context *ctx, duk_errcode_t err_code, const char *str) { + duk_push_error_object(ctx, err_code, "%s", str); +} +static void _duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *text) { + duk_error_raw(ctx, err_code, filename, line, text); +} +static void _duk_log(duk_context *ctx, duk_int_t level, const char *str) { + duk_log(ctx, level, "%s", str); +} +static void _duk_push_external_buffer(duk_context *ctx) { + duk_push_external_buffer(ctx); +} +*/ +import "C" +import ( + "fmt" + "unsafe" +) + +// See: http://duktape.org/api.html#duk_alloc +func (d *Context) Alloc(size int) unsafe.Pointer { + return C.duk_alloc(d.duk_context, C.duk_size_t(size)) +} + +// See: http://duktape.org/api.html#duk_alloc_raw +func (d *Context) AllocRaw(size int) unsafe.Pointer { + return C.duk_alloc_raw(d.duk_context, C.duk_size_t(size)) +} + +// See: http://duktape.org/api.html#duk_base64_decode +func (d *Context) Base64Decode(index int) { + C.duk_base64_decode(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_base64_encode +func (d *Context) Base64Encode(index int) string { + if s := C.duk_base64_encode(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_call +func (d *Context) Call(nargs int) { + C.duk_call(d.duk_context, C.duk_idx_t(nargs)) +} + +// See: http://duktape.org/api.html#duk_call_method +func (d *Context) CallMethod(nargs int) { + C.duk_call_method(d.duk_context, C.duk_idx_t(nargs)) +} + +// See: http://duktape.org/api.html#duk_call_prop +func (d *Context) CallProp(objIndex int, nargs int) { + C.duk_call_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_idx_t(nargs)) +} + +// See: http://duktape.org/api.html#duk_check_stack +func (d *Context) CheckStack(extra int) bool { + return int(C.duk_check_stack(d.duk_context, C.duk_idx_t(extra))) == 1 +} + +// See: http://duktape.org/api.html#duk_check_stack_top +func (d *Context) CheckStackTop(top int) bool { + return int(C.duk_check_stack_top(d.duk_context, C.duk_idx_t(top))) == 1 +} + +// See: http://duktape.org/api.html#duk_check_type +func (d *Context) CheckType(index int, typ int) bool { + return int(C.duk_check_type(d.duk_context, C.duk_idx_t(index), C.duk_int_t(typ))) == 1 +} + +// See: http://duktape.org/api.html#duk_check_type_mask +func (d *Context) CheckTypeMask(index int, mask uint) bool { + return int(C.duk_check_type_mask(d.duk_context, C.duk_idx_t(index), C.duk_uint_t(mask))) == 1 +} + +// See: http://duktape.org/api.html#duk_compact +func (d *Context) Compact(objIndex int) { + C.duk_compact(d.duk_context, C.duk_idx_t(objIndex)) +} + +// See: http://duktape.org/api.html#duk_compile +func (d *Context) Compile(flags uint) { + C._duk_compile(d.duk_context, C.duk_uint_t(flags)) +} + +// See: http://duktape.org/api.html#duk_compile_file +func (d *Context) CompileFile(flags uint, path string) { + __path__ := C.CString(path) + C._duk_compile_file(d.duk_context, C.duk_uint_t(flags), __path__) + C.free(unsafe.Pointer(__path__)) +} + +// See: http://duktape.org/api.html#duk_compile_lstring +func (d *Context) CompileLstring(flags uint, src string, len int) { + __src__ := C.CString(src) + C._duk_compile_lstring(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len)) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_compile_lstring_filename +func (d *Context) CompileLstringFilename(flags uint, src string, len int) { + __src__ := C.CString(src) + C._duk_compile_lstring_filename(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len)) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_compile_string +func (d *Context) CompileString(flags uint, src string) { + __src__ := C.CString(src) + C._duk_compile_string(d.duk_context, C.duk_uint_t(flags), __src__) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_compile_string_filename +func (d *Context) CompileStringFilename(flags uint, src string) { + __src__ := C.CString(src) + C._duk_compile_string_filename(d.duk_context, C.duk_uint_t(flags), __src__) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_concat +func (d *Context) Concat(count int) { + C.duk_concat(d.duk_context, C.duk_idx_t(count)) +} + +// See: http://duktape.org/api.html#duk_copy +func (d *Context) Copy(fromIndex int, toIndex int) { + C.duk_copy(d.duk_context, C.duk_idx_t(fromIndex), C.duk_idx_t(toIndex)) +} + +// See: http://duktape.org/api.html#duk_del_prop +func (d *Context) DelProp(objIndex int) bool { + return int(C.duk_del_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_del_prop_index +func (d *Context) DelPropIndex(objIndex int, arrIndex uint) bool { + return int(C.duk_del_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_del_prop_string +func (d *Context) DelPropString(objIndex int, key string) bool { + __key__ := C.CString(key) + result := int(C.duk_del_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_def_prop +func (d *Context) DefProp(objIndex int, flags uint) { + C.duk_def_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_uint_t(flags)) +} + +// See: http://duktape.org/api.html#duk_destroy_heap +func (d *Context) DestroyHeap() { + d.Gc(0) + C.duk_destroy_heap(d.duk_context) + d.duk_context = nil +} + +// See: http://duktape.org/api.html#duk_dump_context_stderr +func (d *Context) DumpContextStderr() { + C._duk_dump_context_stderr(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_dump_context_stdout +func (d *Context) DumpContextStdout() { + C._duk_dump_context_stdout(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_dup +func (d *Context) Dup(fromIndex int) { + C.duk_dup(d.duk_context, C.duk_idx_t(fromIndex)) +} + +// See: http://duktape.org/api.html#duk_dup_top +func (d *Context) DupTop() { + C.duk_dup_top(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_enum +func (d *Context) Enum(objIndex int, enumFlags uint) { + C.duk_enum(d.duk_context, C.duk_idx_t(objIndex), C.duk_uint_t(enumFlags)) +} + +// See: http://duktape.org/api.html#duk_equals +func (d *Context) Equals(index1 int, index2 int) bool { + return int(C.duk_equals(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2))) == 1 +} + +// Error pushes a new Error object to the stack and throws it. This will call +// fmt.Sprint, forwarding arguments after the error code, to produce the +// Error's message. +// +// See: http://duktape.org/api.html#duk_error +func (d *Context) Error(errCode int, str string) { + __str__ := C.CString(str) + C._duk_error(d.duk_context, C.duk_errcode_t(errCode), __str__) + C.free(unsafe.Pointer(__str__)) +} + +func (d *Context) ErrorRaw(errCode int, filename string, line int, errMsg string) { + __filename__ := C.CString(filename) + __errMsg__ := C.CString(errMsg) + C._duk_error_raw(d.duk_context, C.duk_errcode_t(errCode), __filename__, C.duk_int_t(line), __errMsg__) + C.free(unsafe.Pointer(__filename__)) + C.free(unsafe.Pointer(__errMsg__)) +} + +// Errorf pushes a new Error object to the stack and throws it. This will call +// fmt.Sprintf, forwarding the format string and additional arguments, to +// produce the Error's message. +// +// See: http://duktape.org/api.html#duk_error +func (d *Context) Errorf(errCode int, format string, a ...interface{}) { + str := fmt.Sprintf(format, a...) + __str__ := C.CString(str) + C._duk_error(d.duk_context, C.duk_errcode_t(errCode), __str__) + C.free(unsafe.Pointer(__str__)) +} + +// See: http://duktape.org/api.html#duk_eval +func (d *Context) Eval() { + C._duk_eval(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_eval_file +func (d *Context) EvalFile(path string) { + __path__ := C.CString(path) + C._duk_eval_file(d.duk_context, __path__) + C.free(unsafe.Pointer(__path__)) +} + +// See: http://duktape.org/api.html#duk_eval_file_noresult +func (d *Context) EvalFileNoresult(path string) { + __path__ := C.CString(path) + C._duk_eval_file_noresult(d.duk_context, __path__) + C.free(unsafe.Pointer(__path__)) +} + +// See: http://duktape.org/api.html#duk_eval_lstring +func (d *Context) EvalLstring(src string, len int) { + __src__ := C.CString(src) + C._duk_eval_lstring(d.duk_context, __src__, C.duk_size_t(len)) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_eval_lstring_noresult +func (d *Context) EvalLstringNoresult(src string, len int) { + __src__ := C.CString(src) + C._duk_eval_lstring_noresult(d.duk_context, __src__, C.duk_size_t(len)) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_eval_noresult +func (d *Context) EvalNoresult() { + C._duk_eval_noresult(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_eval_string +func (d *Context) EvalString(src string) { + __src__ := C.CString(src) + C._duk_eval_string(d.duk_context, __src__) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_eval_string_noresult +func (d *Context) EvalStringNoresult(src string) { + __src__ := C.CString(src) + C._duk_eval_string_noresult(d.duk_context, __src__) + C.free(unsafe.Pointer(__src__)) +} + +// See: http://duktape.org/api.html#duk_fatal +func (d *Context) Fatal(errCode int, errMsg string) { + __errMsg__ := C.CString(errMsg) + defer C.free(unsafe.Pointer(__errMsg__)) + C.duk_fatal_raw(d.duk_context, __errMsg__) +} + +// See: http://duktape.org/api.html#duk_gc +func (d *Context) Gc(flags uint) { + C.duk_gc(d.duk_context, C.duk_uint_t(flags)) +} + +// See: http://duktape.org/api.html#duk_get_boolean +func (d *Context) GetBoolean(index int) bool { + return int(C.duk_get_boolean(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_get_buffer +func (d *Context) GetBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) { + rawPtr = C.duk_get_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize))) + return rawPtr, outSize +} + +// See: http://duktape.org/api.html#duk_get_context +func (d *Context) GetContext(index int) *Context { + return contextFromPointer(C.duk_get_context(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_current_magic +func (d *Context) GetCurrentMagic() int { + return int(C.duk_get_current_magic(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_get_error_code +func (d *Context) GetErrorCode(index int) int { + code := int(C.duk_get_error_code(d.duk_context, C.duk_idx_t(index))) + return code +} + +// See: http://duktape.org/api.html#duk_get_finalizer +func (d *Context) GetFinalizer(index int) { + C.duk_get_finalizer(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_get_global_string +func (d *Context) GetGlobalString(key string) bool { + __key__ := C.CString(key) + result := int(C.duk_get_global_string(d.duk_context, __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_get_heapptr +func (d *Context) GetHeapptr(index int) unsafe.Pointer { + return unsafe.Pointer(C.duk_get_heapptr(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_int +func (d *Context) GetInt(index int) int { + return int(C.duk_get_int(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_length +func (d *Context) GetLength(index int) int { + return int(C.duk_get_length(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_lstring +func (d *Context) GetLstring(index int) string { + if s := C.duk_get_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_get_magic +func (d *Context) GetMagic(index int) int { + return int(C.duk_get_magic(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_number +func (d *Context) GetNumber(index int) float64 { + return float64(C.duk_get_number(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_pointer +func (d *Context) GetPointer(index int) unsafe.Pointer { + return C.duk_get_pointer(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_get_prop +func (d *Context) GetProp(objIndex int) bool { + return int(C.duk_get_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_get_prop_index +func (d *Context) GetPropIndex(objIndex int, arrIndex uint) bool { + return int(C.duk_get_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_get_prop_string +func (d *Context) GetPropString(objIndex int, key string) bool { + __key__ := C.CString(key) + result := int(C.duk_get_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_get_prototype +func (d *Context) GetPrototype(index int) { + C.duk_get_prototype(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_get_string +func (d *Context) GetString(i int) string { + if s := C.duk_get_string(d.duk_context, C.duk_idx_t(i)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_get_top +func (d *Context) GetTop() int { + return int(C.duk_get_top(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_get_top_index +func (d *Context) GetTopIndex() int { + return int(C.duk_get_top_index(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_get_type +func (d *Context) GetType(index int) Type { + return Type(C.duk_get_type(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_type_mask +func (d *Context) GetTypeMask(index int) uint { + return uint(C.duk_get_type_mask(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_get_uint +func (d *Context) GetUint(index int) uint { + return uint(C.duk_get_uint(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_has_prop +func (d *Context) HasProp(objIndex int) bool { + return int(C.duk_has_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_has_prop_index +func (d *Context) HasPropIndex(objIndex int, arrIndex uint) bool { + return int(C.duk_has_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_has_prop_string +func (d *Context) HasPropString(objIndex int, key string) bool { + __key__ := C.CString(key) + result := int(C.duk_has_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_hex_decode +func (d *Context) HexDecode(index int) { + C.duk_hex_decode(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_hex_encode +func (d *Context) HexEncode(index int) string { + if s := C.duk_hex_encode(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_insert +func (d *Context) Insert(toIndex int) { + C.duk_insert(d.duk_context, C.duk_idx_t(toIndex)) +} + +// See: http://duktape.org/api.html#duk_is_array +func (d *Context) IsArray(index int) bool { + return int(C.duk_is_array(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_boolean +func (d *Context) IsBoolean(index int) bool { + return int(C.duk_is_boolean(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_bound_function +func (d *Context) IsBoundFunction(index int) bool { + return int(C.duk_is_bound_function(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_buffer +func (d *Context) IsBuffer(index int) bool { + return int(C.duk_is_buffer(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_c_function +func (d *Context) IsCFunction(index int) bool { + return int(C.duk_is_c_function(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_callable +func (d *Context) IsCallable(index int) bool { + return int(C.duk_is_function(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_constructor_call +func (d *Context) IsConstructorCall() bool { + return int(C.duk_is_constructor_call(d.duk_context)) == 1 +} + +// See: http://duktape.org/api.html#duk_is_dynamic_buffer +func (d *Context) IsDynamicBuffer(index int) bool { + return int(C.duk_is_dynamic_buffer(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_ecmascript_function +func (d *Context) IsEcmascriptFunction(index int) bool { + return int(C.duk_is_ecmascript_function(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_fixed_buffer +func (d *Context) IsFixedBuffer(index int) bool { + return int(C.duk_is_fixed_buffer(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_function +func (d *Context) IsFunction(index int) bool { + return int(C.duk_is_function(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_nan +func (d *Context) IsNan(index int) bool { + return int(C.duk_is_nan(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_null +func (d *Context) IsNull(index int) bool { + return int(C.duk_is_null(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_null_or_undefined +func (d *Context) IsNullOrUndefined(index int) bool { + return d.IsNull(index) || d.IsUndefined(index) +} + +// See: http://duktape.org/api.html#duk_is_number +func (d *Context) IsNumber(index int) bool { + return int(C.duk_is_number(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_object +func (d *Context) IsObject(index int) bool { + return int(C.duk_is_object(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_error +func (d *Context) IsError(index int) bool { + return int(C._duk_is_error(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_object_coercible +func (d *Context) IsObjectCoercible(index int) bool { + return int(C._duk_is_object_coercible(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_pointer +func (d *Context) IsPointer(index int) bool { + return int(C.duk_is_pointer(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_primitive +func (d *Context) IsPrimitive(index int) bool { + return int(C._duk_is_primitive(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_strict_call +func (d *Context) IsStrictCall() bool { + return int(C.duk_is_strict_call(d.duk_context)) == 1 +} + +// See: http://duktape.org/api.html#duk_is_string +func (d *Context) IsString(index int) bool { + return int(C.duk_is_string(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_thread +func (d *Context) IsThread(index int) bool { + return int(C.duk_is_thread(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_undefined +func (d *Context) IsUndefined(index int) bool { + return int(C.duk_is_undefined(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_valid_index +func (d *Context) IsValidIndex(index int) bool { + return int(C.duk_is_valid_index(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_join +func (d *Context) Join(count int) { + C.duk_join(d.duk_context, C.duk_idx_t(count)) +} + +// See: http://duktape.org/api.html#duk_json_decode +func (d *Context) JsonDecode(index int) { + C.duk_json_decode(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_json_encode +func (d *Context) JsonEncode(index int) string { + if s := C.duk_json_encode(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_new +func (d *Context) New(nargs int) { + C.duk_new(d.duk_context, C.duk_idx_t(nargs)) +} + +// See: http://duktape.org/api.html#duk_next +func (d *Context) Next(enumIndex int, getValue bool) bool { + var __getValue__ int + if getValue { + __getValue__ = 1 + } + return int(C.duk_next(d.duk_context, C.duk_idx_t(enumIndex), C.duk_bool_t(__getValue__))) == 1 +} + +// See: http://duktape.org/api.html#duk_normalize_index +func (d *Context) NormalizeIndex(index int) int { + return int(C.duk_normalize_index(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_pcall +func (d *Context) Pcall(nargs int) int { + return int(C.duk_pcall(d.duk_context, C.duk_idx_t(nargs))) +} + +// See: http://duktape.org/api.html#duk_pcall_method +func (d *Context) PcallMethod(nargs int) int { + return int(C.duk_pcall_method(d.duk_context, C.duk_idx_t(nargs))) +} + +// See: http://duktape.org/api.html#duk_pcall_prop +func (d *Context) PcallProp(objIndex int, nargs int) int { + return int(C.duk_pcall_prop(d.duk_context, C.duk_idx_t(objIndex), C.duk_idx_t(nargs))) +} + +// See: http://duktape.org/api.html#duk_pcompile +func (d *Context) Pcompile(flags uint) error { + result := int(C._duk_pcompile(d.duk_context, C.duk_uint_t(flags))) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_pcompile_file +func (d *Context) PcompileFile(flags uint, path string) error { + __path__ := C.CString(path) + result := int(C._duk_pcompile_file(d.duk_context, C.duk_uint_t(flags), __path__)) + C.free(unsafe.Pointer(__path__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_pcompile_lstring +func (d *Context) PcompileLstring(flags uint, src string, len int) error { + __src__ := C.CString(src) + result := int(C._duk_pcompile_lstring(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len))) + C.free(unsafe.Pointer(__src__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_pcompile_lstring_filename +func (d *Context) PcompileLstringFilename(flags uint, src string, len int) error { + __src__ := C.CString(src) + result := int(C._duk_pcompile_lstring_filename(d.duk_context, C.duk_uint_t(flags), __src__, C.duk_size_t(len))) + C.free(unsafe.Pointer(__src__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_pcompile_string +func (d *Context) PcompileString(flags uint, src string) error { + __src__ := C.CString(src) + result := int(C._duk_pcompile_string(d.duk_context, C.duk_uint_t(flags), __src__)) + C.free(unsafe.Pointer(__src__)) + fmt.Println("result herhehreh", result) + return nil //d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_pcompile_string_filename +func (d *Context) PcompileStringFilename(flags uint, src string) error { + __src__ := C.CString(src) + result := int(C._duk_pcompile_string_filename(d.duk_context, C.duk_uint_t(flags), __src__)) + C.free(unsafe.Pointer(__src__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_peval +func (d *Context) Peval() error { + result := int(C._duk_peval(d.duk_context)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_peval_file +func (d *Context) PevalFile(path string) error { + __path__ := C.CString(path) + result := int(C._duk_peval_file(d.duk_context, __path__)) + C.free(unsafe.Pointer(__path__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_peval_file_noresult +func (d *Context) PevalFileNoresult(path string) int { + __path__ := C.CString(path) + result := int(C._duk_peval_file_noresult(d.duk_context, __path__)) + C.free(unsafe.Pointer(__path__)) + return result +} + +// See: http://duktape.org/api.html#duk_peval_lstring +func (d *Context) PevalLstring(src string, len int) error { + __src__ := C.CString(src) + result := int(C._duk_peval_lstring(d.duk_context, __src__, C.duk_size_t(len))) + C.free(unsafe.Pointer(__src__)) + return d.castStringToError(result) + +} + +// See: http://duktape.org/api.html#duk_peval_lstring_noresult +func (d *Context) PevalLstringNoresult(src string, len int) int { + __src__ := C.CString(src) + result := int(C._duk_peval_lstring_noresult(d.duk_context, __src__, C.duk_size_t(len))) + C.free(unsafe.Pointer(__src__)) + return result +} + +// See: http://duktape.org/api.html#duk_peval_noresult +func (d *Context) PevalNoresult() int { + return int(C._duk_peval_noresult(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_peval_string +func (d *Context) PevalString(src string) error { + __src__ := C.CString(src) + result := int(C._duk_peval_string(d.duk_context, __src__)) + C.free(unsafe.Pointer(__src__)) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_peval_string_noresult +func (d *Context) PevalStringNoresult(src string) int { + __src__ := C.CString(src) + result := int(C._duk_peval_string_noresult(d.duk_context, __src__)) + C.free(unsafe.Pointer(__src__)) + return result +} + +func (d *Context) castStringToError(result int) error { + if result == 0 { + return nil + } + + err := &Error{} + for _, key := range []string{"name", "message", "fileName", "lineNumber", "stack"} { + d.GetPropString(-1, key) + + switch key { + case "name": + err.Type = d.SafeToString(-1) + case "message": + err.Message = d.SafeToString(-1) + case "fileName": + err.FileName = d.SafeToString(-1) + case "lineNumber": + if d.IsNumber(-1) { + err.LineNumber = d.GetInt(-1) + } + case "stack": + err.Stack = d.SafeToString(-1) + } + + d.Pop() + } + + return err +} + +// See: http://duktape.org/api.html#duk_pop +func (d *Context) Pop() { + if d.GetTop() == 0 { + return + } + C.duk_pop(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_pop_2 +func (d *Context) Pop2() { + d.PopN(2) +} + +// See: http://duktape.org/api.html#duk_pop_3 +func (d *Context) Pop3() { + d.PopN(3) +} + +// See: http://duktape.org/api.html#duk_pop_n +func (d *Context) PopN(count int) { + if d.GetTop() < count || count < 1 { + return + } + C.duk_pop_n(d.duk_context, C.duk_idx_t(count)) +} + +// See: http://duktape.org/api.html#duk_push_array +func (d *Context) PushArray() int { + return int(C.duk_push_array(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_push_boolean +func (d *Context) PushBoolean(val bool) { + var __val__ int + if val { + __val__ = 1 + } + C.duk_push_boolean(d.duk_context, C.duk_bool_t(__val__)) +} + +// See: http://duktape.org/api.html#duk_push_buffer +func (d *Context) PushBuffer(size int, dynamic bool) unsafe.Pointer { + var __dynamic__ int + if dynamic { + __dynamic__ = 1 + } + return C._duk_push_buffer(d.duk_context, C.duk_size_t(size), C.duk_bool_t(__dynamic__)) +} + +// See: http://duktape.org/api.html#duk_push_c_function +func (d *Context) PushCFunction(fn *[0]byte, nargs int64) int { + return int(C.duk_push_c_function(d.duk_context, fn, C.duk_idx_t(nargs))) +} + +// See: http://duktape.org/api.html#duk_push_context_dump +func (d *Context) PushContextDump() { + C.duk_push_context_dump(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_current_function +func (d *Context) PushCurrentFunction() { + C.duk_push_current_function(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_current_thread +func (d *Context) PushCurrentThread() { + C.duk_push_current_thread(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_dynamic_buffer +func (d *Context) PushDynamicBuffer(size int) unsafe.Pointer { + return C._duk_push_dynamic_buffer(d.duk_context, C.duk_size_t(size)) +} + +// See: http://duktape.org/api.html#duk_push_error_object +func (d *Context) PushErrorObject(errCode int, format string, value interface{}) { + __str__ := C.CString(fmt.Sprintf(format, value)) + C._duk_push_error_object(d.duk_context, C.duk_errcode_t(errCode), __str__) + C.free(unsafe.Pointer(__str__)) +} + +// See: http://duktape.org/api.html#duk_push_false +func (d *Context) PushFalse() { + C.duk_push_false(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_fixed_buffer +func (d *Context) PushFixedBuffer(size int) unsafe.Pointer { + return C._duk_push_fixed_buffer(d.duk_context, C.duk_size_t(size)) +} + +// See: http://duktape.org/api.html#duk_push_global_object +func (d *Context) PushGlobalObject() { + C.duk_push_global_object(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_global_stash +func (d *Context) PushGlobalStash() { + C.duk_push_global_stash(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_heapptr +func (d *Context) PushHeapptr(ptr unsafe.Pointer) { + C.duk_push_heapptr(d.duk_context, ptr) +} + +// See: http://duktape.org/api.html#duk_push_heap_stash +func (d *Context) PushHeapStash() { + C.duk_push_heap_stash(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_int +func (d *Context) PushInt(val int) { + C.duk_push_int(d.duk_context, C.duk_int_t(val)) +} + +// See: http://duktape.org/api.html#duk_push_lstring +func (d *Context) PushLstring(str string, len int) string { + __str__ := C.CString(str) + var result string + if s := C.duk_push_lstring(d.duk_context, __str__, C.duk_size_t(len)); s != nil { + result = C.GoString(s) + } + C.free(unsafe.Pointer(__str__)) + return result +} + +// See: http://duktape.org/api.html#duk_push_nan +func (d *Context) PushNan() { + C.duk_push_nan(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_null +func (d *Context) PushNull() { + C.duk_push_null(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_number +func (d *Context) PushNumber(val float64) { + C.duk_push_number(d.duk_context, C.duk_double_t(val)) +} + +// See: http://duktape.org/api.html#duk_push_object +func (d *Context) PushObject() int { + return int(C.duk_push_object(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_push_string +func (d *Context) PushString(str string) string { + __str__ := C.CString(str) + var result string + if s := C.duk_push_string(d.duk_context, __str__); s != nil { + result = C.GoString(s) + } + C.free(unsafe.Pointer(__str__)) + return result +} + +// See: http://duktape.org/api.html#duk_push_string_file +func (d *Context) PushStringFile(path string) string { + __path__ := C.CString(path) + var result string + if s := C._duk_push_string_file(d.duk_context, __path__); s != nil { + result = C.GoString(s) + } + C.free(unsafe.Pointer(__path__)) + return result +} + +// See: http://duktape.org/api.html#duk_push_this +func (d *Context) PushThis() { + C.duk_push_this(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_thread +func (d *Context) PushThread() int { + return int(C._duk_push_thread(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_push_thread_new_globalenv +func (d *Context) PushThreadNewGlobalenv() int { + return int(C._duk_push_thread_new_globalenv(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_push_thread_stash +func (d *Context) PushThreadStash(targetCtx *Context) { + C.duk_push_thread_stash(d.duk_context, targetCtx.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_true +func (d *Context) PushTrue() { + C.duk_push_true(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_push_uint +func (d *Context) PushUint(val uint) { + C.duk_push_uint(d.duk_context, C.duk_uint_t(val)) +} + +// See: http://duktape.org/api.html#duk_push_undefined +func (d *Context) PushUndefined() { + C.duk_push_undefined(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_put_global_string +func (d *Context) PutGlobalString(key string) bool { + __key__ := C.CString(key) + result := int(C.duk_put_global_string(d.duk_context, __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_put_prop +func (d *Context) PutProp(objIndex int) bool { + return int(C.duk_put_prop(d.duk_context, C.duk_idx_t(objIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_put_prop_index +func (d *Context) PutPropIndex(objIndex int, arrIndex uint) bool { + return int(C.duk_put_prop_index(d.duk_context, C.duk_idx_t(objIndex), C.duk_uarridx_t(arrIndex))) == 1 +} + +// See: http://duktape.org/api.html#duk_put_prop_string +func (d *Context) PutPropString(objIndex int, key string) bool { + __key__ := C.CString(key) + result := int(C.duk_put_prop_string(d.duk_context, C.duk_idx_t(objIndex), __key__)) == 1 + C.free(unsafe.Pointer(__key__)) + return result +} + +// See: http://duktape.org/api.html#duk_remove +func (d *Context) Remove(index int) { + C.duk_remove(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_replace +func (d *Context) Replace(toIndex int) { + C.duk_replace(d.duk_context, C.duk_idx_t(toIndex)) +} + +// See: http://duktape.org/api.html#duk_require_boolean +func (d *Context) RequireBoolean(index int) bool { + return int(C.duk_require_boolean(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_require_buffer +func (d *Context) RequireBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) { + rawPtr = C.duk_require_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize))) + return rawPtr, outSize +} + +// See: http://duktape.org/api.html#duk_require_callable +func (d *Context) RequireCallable(index int) { + // At present, duk_require_callable is a macro that just calls duk_require_function. + // cgo does not support such macros we have to call it directly. + C.duk_require_function(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_context +func (d *Context) RequireContext(index int) *Context { + return contextFromPointer(C.duk_require_context(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_function +func (d *Context) RequireFunction(index int) { + C.duk_require_function(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_heapptr +func (d *Context) RequireHeapptr(index int) unsafe.Pointer { + return unsafe.Pointer(C.duk_require_heapptr(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_int +func (d *Context) RequireInt(index int) int { + return int(C.duk_require_int(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_lstring +func (d *Context) RequireLstring(index int) string { + if s := C.duk_require_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_require_normalize_index +func (d *Context) RequireNormalizeIndex(index int) int { + return int(C.duk_require_normalize_index(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_null +func (d *Context) RequireNull(index int) { + C.duk_require_null(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_number +func (d *Context) RequireNumber(index int) float64 { + return float64(C.duk_require_number(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_object_coercible +func (d *Context) RequireObjectCoercible(index int) { + C._duk_require_object_coercible(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_pointer +func (d *Context) RequirePointer(index int) unsafe.Pointer { + return C.duk_require_pointer(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_stack +func (d *Context) RequireStack(extra int) { + C.duk_require_stack(d.duk_context, C.duk_idx_t(extra)) +} + +// See: http://duktape.org/api.html#duk_require_stack_top +func (d *Context) RequireStackTop(top int) { + C.duk_require_stack_top(d.duk_context, C.duk_idx_t(top)) +} + +// See: http://duktape.org/api.html#duk_require_string +func (d *Context) RequireString(index int) string { + if s := C.duk_require_string(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_require_top_index +func (d *Context) RequireTopIndex() int { + return int(C.duk_require_top_index(d.duk_context)) +} + +// See: http://duktape.org/api.html#duk_require_type_mask +func (d *Context) RequireTypeMask(index int, mask uint) { + C._duk_require_type_mask(d.duk_context, C.duk_idx_t(index), C.duk_uint_t(mask)) +} + +// See: http://duktape.org/api.html#duk_require_uint +func (d *Context) RequireUint(index int) uint { + return uint(C.duk_require_uint(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_require_undefined +func (d *Context) RequireUndefined(index int) { + C.duk_require_undefined(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_require_valid_index +func (d *Context) RequireValidIndex(index int) { + C.duk_require_valid_index(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_resize_buffer +func (d *Context) ResizeBuffer(index int, newSize int) unsafe.Pointer { + return C.duk_resize_buffer(d.duk_context, C.duk_idx_t(index), C.duk_size_t(newSize)) +} + +// See: http://duktape.org/api.html#duk_safe_call +func (d *Context) SafeCall(fn, args *[0]byte, nargs, nrets int) int { + return int(C.duk_safe_call( + d.duk_context, + fn, + unsafe.Pointer(&args), + C.duk_idx_t(nargs), + C.duk_idx_t(nrets), + )) +} + +// See: http://duktape.org/api.html#duk_safe_to_lstring +func (d *Context) SafeToLstring(index int) string { + if s := C.duk_safe_to_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_safe_to_string +func (d *Context) SafeToString(index int) string { + if s := C._duk_safe_to_string(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_set_finalizer +func (d *Context) SetFinalizer(index int) { + C.duk_set_finalizer(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_set_global_object +func (d *Context) SetGlobalObject() { + C.duk_set_global_object(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_set_magic +func (d *Context) SetMagic(index int, magic int) { + C.duk_set_magic(d.duk_context, C.duk_idx_t(index), C.duk_int_t(magic)) +} + +// See: http://duktape.org/api.html#duk_set_prototype +func (d *Context) SetPrototype(index int) { + C.duk_set_prototype(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_set_top +func (d *Context) SetTop(index int) { + C.duk_set_top(d.duk_context, C.duk_idx_t(index)) +} + +func (d *Context) StrictEquals(index1 int, index2 int) bool { + return int(C.duk_strict_equals(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2))) == 1 +} + +// See: http://duktape.org/api.html#duk_substring +func (d *Context) Substring(index int, startCharOffset int, endCharOffset int) { + C.duk_substring(d.duk_context, C.duk_idx_t(index), C.duk_size_t(startCharOffset), C.duk_size_t(endCharOffset)) +} + +// See: http://duktape.org/api.html#duk_swap +func (d *Context) Swap(index1 int, index2 int) { + C.duk_swap(d.duk_context, C.duk_idx_t(index1), C.duk_idx_t(index2)) +} + +// See: http://duktape.org/api.html#duk_swap_top +func (d *Context) SwapTop(index int) { + C.duk_swap_top(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_throw +func (d *Context) Throw() { + C.duk_throw_raw(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_to_boolean +func (d *Context) ToBoolean(index int) bool { + return int(C.duk_to_boolean(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_to_buffer +func (d *Context) ToBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) { + rawPtr = C._duk_to_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize))) + return rawPtr, outSize +} + +// See: http://duktape.org/api.html#duk_to_defaultvalue +func (d *Context) ToDefaultvalue(index int, hint int) { + C.duk_to_defaultvalue(d.duk_context, C.duk_idx_t(index), C.duk_int_t(hint)) +} + +// See: http://duktape.org/api.html#duk_to_dynamic_buffer +func (d *Context) ToDynamicBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) { + rawPtr = C._duk_to_dynamic_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize))) + return rawPtr, outSize +} + +// See: http://duktape.org/api.html#duk_to_fixed_buffer +func (d *Context) ToFixedBuffer(index int) (rawPtr unsafe.Pointer, outSize uint) { + rawPtr = C._duk_to_fixed_buffer(d.duk_context, C.duk_idx_t(index), (*C.duk_size_t)(unsafe.Pointer(&outSize))) + return rawPtr, outSize +} + +// See: http://duktape.org/api.html#duk_to_int +func (d *Context) ToInt(index int) int { + return int(C.duk_to_int(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_int32 +func (d *Context) ToInt32(index int) int32 { + return int32(C.duk_to_int32(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_lstring +func (d *Context) ToLstring(index int) string { + if s := C.duk_to_lstring(d.duk_context, C.duk_idx_t(index), nil); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_to_null +func (d *Context) ToNull(index int) { + C.duk_to_null(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_to_number +func (d *Context) ToNumber(index int) float64 { + return float64(C.duk_to_number(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_object +func (d *Context) ToObject(index int) { + C.duk_to_object(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_to_pointer +func (d *Context) ToPointer(index int) unsafe.Pointer { + return C.duk_to_pointer(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_to_primitive +func (d *Context) ToPrimitive(index int, hint int) { + C.duk_to_primitive(d.duk_context, C.duk_idx_t(index), C.duk_int_t(hint)) +} + +// See: http://duktape.org/api.html#duk_to_string +func (d *Context) ToString(index int) string { + if s := C.duk_to_string(d.duk_context, C.duk_idx_t(index)); s != nil { + return C.GoString(s) + } + return "" +} + +// See: http://duktape.org/api.html#duk_to_uint +func (d *Context) ToUint(index int) uint { + return uint(C.duk_to_uint(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_uint16 +func (d *Context) ToUint16(index int) uint16 { + return uint16(C.duk_to_uint16(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_uint32 +func (d *Context) ToUint32(index int) uint32 { + return uint32(C.duk_to_uint32(d.duk_context, C.duk_idx_t(index))) +} + +// See: http://duktape.org/api.html#duk_to_undefined +func (d *Context) ToUndefined(index int) { + C.duk_to_undefined(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_trim +func (d *Context) Trim(index int) { + C.duk_trim(d.duk_context, C.duk_idx_t(index)) +} + +// See: http://duktape.org/api.html#duk_xcopy_top +func (d *Context) XcopyTop(fromCtx *Context, count int) { + C._duk_xcopy_top(d.duk_context, fromCtx.duk_context, C.duk_idx_t(count)) +} + +// See: http://duktape.org/api.html#duk_xmove_top +func (d *Context) XmoveTop(fromCtx *Context, count int) { + C._duk_xmove_top(d.duk_context, fromCtx.duk_context, C.duk_idx_t(count)) +} + +// See: http://duktape.org/api.html#duk_push_pointer +func (d *Context) PushPointer(p unsafe.Pointer) { + C.duk_push_pointer(d.duk_context, p) +} + +//---[ Duktape 1.3 API ]--- // +// See: http://duktape.org/api.html#duk_debugger_attach +func (d *Context) DebuggerAttach( + readFn, + writeFn, + peekFn, + readFlushFn, + writeFlushFn, + detachedFn *[0]byte, + uData unsafe.Pointer) { + C.duk_debugger_attach( + d.duk_context, + readFn, + writeFn, + peekFn, + readFlushFn, + writeFlushFn, + nil, + detachedFn, + uData, + ) +} + +// See: http://duktape.org/api.html#duk_debugger_cooperate +func (d *Context) DebuggerCooperate() { + C.duk_debugger_cooperate(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_debugger_detach +func (d *Context) DebuggerDetach() { + C.duk_debugger_detach(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_dump_function +func (d *Context) DumpFunction() { + C.duk_dump_function(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_error_va +func (d *Context) ErrorVa(errCode int, a ...interface{}) { + str := fmt.Sprint(a...) + d.Error(errCode, str) +} + +// See: http://duktape.org/api.html#duk_instanceof +func (d *Context) Instanceof(idx1, idx2 int) bool { + return int(C.duk_instanceof(d.duk_context, C.duk_idx_t(idx1), C.duk_idx_t(idx2))) == 1 +} + +// See: http://duktape.org/api.html#duk_is_lightfunc +func (d *Context) IsLightfunc(index int) bool { + return int(C.duk_is_lightfunc(d.duk_context, C.duk_idx_t(index))) == 1 +} + +// See: http://duktape.org/api.html#duk_load_function +func (d *Context) LoadFunction() { + C.duk_load_function(d.duk_context) +} + +// See: http://duktape.org/api.html#duk_log +func (d *Context) Log(loglevel int, format string, value interface{}) { + __str__ := C.CString(fmt.Sprintf(format, value)) + C._duk_log(d.duk_context, C.duk_int_t(loglevel), __str__) + C.free(unsafe.Pointer(__str__)) +} + +// See: http://duktape.org/api.html#duk_log_va +func (d *Context) LogVa(logLevel int, format string, values ...interface{}) { + __str__ := C.CString(fmt.Sprintf(format, values...)) + C._duk_log(d.duk_context, C.duk_int_t(logLevel), __str__) + C.free(unsafe.Pointer(__str__)) +} + +// See: http://duktape.org/api.html#duk_pnew +func (d *Context) Pnew(nargs int) error { + result := int(C.duk_pnew(d.duk_context, C.duk_idx_t(nargs))) + return d.castStringToError(result) +} + +// See: http://duktape.org/api.html#duk_push_buffer_object +func (d *Context) PushBufferObject(bufferIdx, size, length int, flags uint) { + C.duk_push_buffer_object( + d.duk_context, + C.duk_idx_t(bufferIdx), + C.duk_size_t(size), + C.duk_size_t(length), + C.duk_uint_t(flags), + ) +} + +// See: http://duktape.org/api.html#duk_push_c_lightfunc +func (d *Context) PushCLightfunc(fn *[0]byte, nargs, length, magic int) int { + return int(C.duk_push_c_lightfunc( + d.duk_context, + fn, + C.duk_idx_t(nargs), + C.duk_idx_t(length), + C.duk_int_t(magic), + )) +} + +// See: http://duktape.org/api.html#duk_push_error_object_va +func (d *Context) PushErrorObjectVa(errCode int, format string, values ...interface{}) { + __str__ := C.CString(fmt.Sprintf(format, values...)) + C._duk_push_error_object(d.duk_context, C.duk_errcode_t(errCode), __str__) + C.free(unsafe.Pointer(__str__)) +} + +// See: http://duktape.org/api.html#duk_push_external_buffer +func (d *Context) PushExternalBuffer() { + C._duk_push_external_buffer(d.duk_context) +} + +/** + * Unimplemented. + * + * CharCodeAt see: http://duktape.org/api.html#duk_char_code_at + * CreateHeap see: http://duktape.org/api.html#duk_create_heap + * DecodeString see: http://duktape.org/api.html#duk_decode_string + * Free see: http://duktape.org/api.html#duk_free + * FreeRaw see: http://duktape.org/api.html#duk_free_raw + * GetCFunction see: http://duktape.org/api.html#duk_get_c_function + * GetMemoryFunctions see: http://duktape.org/api.html#duk_get_memory_functions + * MapString see: http://duktape.org/api.html#duk_map_string + * PushSprintf see: http://duktape.org/api.html#duk_push_sprintf + * PushVsprintf see: http://duktape.org/api.html#duk_push_vsprintf + * PutFunctionList see: http://duktape.org/api.html#duk_put_function_list + * PutNumberList see: http://duktape.org/api.html#duk_put_number_list + * Realloc see: http://duktape.org/api.html#duk_realloc + * ReallocRaw see: http://duktape.org/api.html#duk_realloc_raw + * RequireCFunction see: http://duktape.org/api.html#duk_require_c_function + * ConfigBuffer see: http://duktape.org/api.html#duk_config_buffer + * GetBufferData see: http://duktape.org/api.html#duk_get_buffer_data + * StealBuffer see: http://duktape.org/api.html#duk_steal_buffer + * RequireBufferData see: http://duktape.org/api.html#duk_require_buffer_data + * IsEvalError see: http://duktape.org/api.html#duk_is_eval_error + */ diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml b/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml new file mode 100644 index 0000000000..7d38d58b12 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/appveyor.yml @@ -0,0 +1,34 @@ +os: Visual Studio 2015 + +clone_folder: C:\gopath\src\gopkg.in/olebedev/go-duktape.v3 +clone_depth: 5 +version: "{branch}.{build}" +environment: + global: + GOPATH: C:\gopath + CC: gcc.exe + matrix: + - DUKTAPE_ARCH: amd64 + MSYS2_ARCH: x86_64 + MSYS2_BITS: 64 + MSYSTEM: MINGW64 + PATH: C:\msys64\mingw64\bin\;C:\Program Files (x86)\NSIS\;%PATH% + - DUKTAPE_ARCH: 386 + MSYS2_ARCH: i686 + MSYS2_BITS: 32 + MSYSTEM: MINGW32 + PATH: C:\msys64\mingw32\bin\;C:\Program Files (x86)\NSIS\;%PATH% + +install: + - rmdir C:\go /s /q + - appveyor DownloadFile https://storage.googleapis.com/golang/go1.9.2.windows-%DUKTAPE_ARCH%.zip + - 7z x go1.9.2.windows-%DUKTAPE_ARCH%.zip -y -oC:\ > NUL + - go version + - gcc --version + +build_script: + - go get -t + - go install ./... + +test_script: + - go test ./... diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go b/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go new file mode 100644 index 0000000000..f3dbd8bc84 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/conts.go @@ -0,0 +1,121 @@ +package duktape + +const ( + CompileEval uint = 1 << iota + CompileFunction + CompileStrict + CompileSafe + CompileNoResult + CompileNoSource + CompileStrlen +) + +const ( + TypeNone Type = iota + TypeUndefined + TypeNull + TypeBoolean + TypeNumber + TypeString + TypeObject + TypeBuffer + TypePointer + TypeLightFunc +) + +const ( + TypeMaskNone uint = 1 << iota + TypeMaskUndefined + TypeMaskNull + TypeMaskBoolean + TypeMaskNumber + TypeMaskString + TypeMaskObject + TypeMaskBuffer + TypeMaskPointer + TypeMaskLightFunc +) + +const ( + EnumIncludeNonenumerable uint = 1 << iota + EnumIncludeInternal + EnumOwnPropertiesOnly + EnumArrayIndicesOnly + EnumSortArrayIndices + NoProxyBehavior +) + +const ( + ErrNone int = 0 + + // Internal to Duktape + ErrUnimplemented int = 50 + iota + ErrUnsupported + ErrInternal + ErrAlloc + ErrAssertion + ErrAPI + ErrUncaughtError +) + +const ( + // Common prototypes + ErrError int = 1 + iota + ErrEval + ErrRange + ErrReference + ErrSyntax + ErrType + ErrURI +) + +const ( + // Returned error values + ErrRetUnimplemented int = -(ErrUnimplemented + iota) + ErrRetUnsupported + ErrRetInternal + ErrRetAlloc + ErrRetAssertion + ErrRetAPI + ErrRetUncaughtError +) + +const ( + ErrRetError int = -(ErrError + iota) + ErrRetEval + ErrRetRange + ErrRetReference + ErrRetSyntax + ErrRetType + ErrRetURI +) + +const ( + ExecSuccess = iota + ExecError +) + +const ( + LogTrace int = iota + LogDebug + LogInfo + LogWarn + LogError + LogFatal +) + +const ( + BufobjDuktapeAuffer = 0 + BufobjNodejsAuffer = 1 + BufobjArraybuffer = 2 + BufobjDataview = 3 + BufobjInt8array = 4 + BufobjUint8array = 5 + BufobjUint8clampedarray = 6 + BufobjInt16array = 7 + BufobjUint16array = 8 + BufobjInt32array = 9 + BufobjUint32array = 10 + BufobjFloat32array = 11 + BufobjFloat64array = 12 +) diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c new file mode 100755 index 0000000000..750fa71df1 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.c @@ -0,0 +1,612 @@ +/* + * Pool allocator for low memory targets. + */ + +#include +#include +#include +#include +#include +#include "duktape.h" +#include "duk_alloc_pool.h" + +/* Define to enable some debug printfs. */ +/* #define DUK_ALLOC_POOL_DEBUG */ + +/* Define to enable approximate waste tracking. */ +/* #define DUK_ALLOC_POOL_TRACK_WASTE */ + +/* Define to track global highwater for used and waste bytes. VERY SLOW, only + * useful for manual testing. + */ +/* #define DUK_ALLOC_POOL_TRACK_HIGHWATER */ + +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) +#if 0 /* This extern declaration is provided by duktape.h, array provided by duktape.c. */ +extern const void * const duk_rom_compressed_pointers[]; +#endif +const void *duk_alloc_pool_romptr_low = NULL; +const void *duk_alloc_pool_romptr_high = NULL; +static void duk__alloc_pool_romptr_init(void); +#endif + +#if defined(DUK_USE_HEAPPTR16) +void *duk_alloc_pool_ptrcomp_base = NULL; +#endif + +#if defined(DUK_ALLOC_POOL_DEBUG) +static void duk__alloc_pool_dprintf(const char *fmt, ...) { + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); +} +#endif + +/* + * Pool initialization + */ + +void *duk_alloc_pool_init(char *buffer, + size_t size, + const duk_pool_config *configs, + duk_pool_state *states, + int num_pools, + duk_pool_global *global) { + double t_min, t_max, t_curr, x; + int step, i, j, n; + size_t total; + char *p; + + /* XXX: check that 'size' is not too large when using pointer + * compression. + */ + + /* To optimize pool counts first come up with a 't' which still allows + * total pool size to fit within user provided region. After that + * sprinkle any remaining bytes to the counts. Binary search with a + * fixed step count; last round uses 't_min' as 't_curr' to ensure it + * succeeds. + */ + + t_min = 0.0; /* Unless config is insane, this should always be "good". */ + t_max = 1e6; + + for (step = 0; ; step++) { + if (step >= 100) { + /* Force "known good", rerun config, and break out. + * Deals with rounding corner cases where t_curr is + * persistently "bad" even though t_min is a valid + * solution. + */ + t_curr = t_min; + } else { + t_curr = (t_min + t_max) / 2.0; + } + + for (i = 0, total = 0; i < num_pools; i++) { + states[i].size = configs[i].size; + + /* Target bytes = A*t + B ==> target count = (A*t + B) / block_size. + * Rely on A and B being small enough so that 'x' won't wrap. + */ + x = ((double) configs[i].a * t_curr + (double) configs[i].b) / (double) configs[i].size; + + states[i].count = (unsigned int) x; + total += (size_t) states[i].size * (size_t) states[i].count; + if (total > size) { + goto bad; + } + } + + /* t_curr is good. */ +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: step=%d, t=[%lf %lf %lf] -> total %ld/%ld (good)\n", + step, t_min, t_curr, t_max, (long) total, (long) size); +#endif + if (step >= 100) { + /* Keep state[] initialization state. The state was + * created using the highest 't_min'. + */ + break; + } + t_min = t_curr; + continue; + + bad: + /* t_curr is bad. */ +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: step=%d, t=[%lf %lf %lf] -> total %ld/%ld (bad)\n", + step, t_min, t_curr, t_max, (long) total, (long) size); +#endif + + if (step >= 1000) { + /* Cannot find any good solution; shouldn't happen + * unless config is bad or 'size' is so small that + * even a baseline allocation won't fit. + */ + return NULL; + } + t_max = t_curr; + /* continue */ + } + + /* The base configuration is now good; sprinkle any leftovers to + * pools in descending order. Note that for good t_curr, 'total' + * indicates allocated bytes so far and 'size - total' indicates + * leftovers. + */ + for (i = num_pools - 1; i >= 0; i--) { + while (size - total >= states[i].size) { + /* Ignore potential wrapping of states[i].count as the count + * is 32 bits and shouldn't wrap in practice. + */ + states[i].count++; + total += states[i].size; +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: sprinkle %ld bytes (%ld left after) to pool index %ld, new count %ld\n", + (long) states[i].size, (long) (size - total), (long) i, (long) states[i].count); +#endif + } + } + + /* Pool counts are final. Allocate the user supplied region based + * on the final counts, initialize free lists for each block size, + * and otherwise finalize 'state' for use. + */ + p = buffer; + global->num_pools = num_pools; + global->states = states; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: global highwater mark tracking enabled, THIS IS VERY SLOW!\n"); +#endif + global->hwm_used_bytes = 0U; + global->hwm_waste_bytes = 0U; +#endif +#if defined(DUK_ALLOC_POOL_TRACK_WASTE) +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: approximate waste tracking enabled\n"); +#endif +#endif + +#if defined(DUK_USE_HEAPPTR16) + /* Register global base value for pointer compression, assumes + * a single active pool -4 allows a single subtract to be used and + * still ensures no non-NULL pointer encodes to zero. + */ + duk_alloc_pool_ptrcomp_base = (void *) (p - 4); +#endif + + for (i = 0; i < num_pools; i++) { + n = (int) states[i].count; + if (n > 0) { + states[i].first = (duk_pool_free *) p; + for (j = 0; j < n; j++) { + char *p_next = p + states[i].size; + ((duk_pool_free *) p)->next = + (j == n - 1) ? (duk_pool_free *) NULL : (duk_pool_free *) p_next; + p = p_next; + } + } else { + states[i].first = (duk_pool_free *) NULL; + } + states[i].alloc_end = p; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) + states[i].hwm_used_count = 0; +#endif + /* All members of 'state' now initialized. */ + +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool_init: block size %5ld, count %5ld, %8ld total bytes, " + "end %p\n", + (long) states[i].size, (long) states[i].count, + (long) states[i].size * (long) states[i].count, + (void *) states[i].alloc_end); +#endif + } + +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) + /* ROM pointer compression precomputation. Assumes a single active + * pool. + */ + duk__alloc_pool_romptr_init(); +#endif + + /* Use 'global' as udata. */ + return (void *) global; +} + +/* + * Misc helpers + */ + +#if defined(DUK_ALLOC_POOL_TRACK_WASTE) +static void duk__alloc_pool_set_waste_marker(void *ptr, size_t used, size_t size) { + /* Rely on the base pointer and size being divisible by 4 and thus + * aligned. Use 32-bit markers: a 4-byte resolution is good enough, + * and comparing 32 bits at a time makes false waste estimates less + * likely than when comparing as bytes. + */ + duk_uint32_t *p, *p_start, *p_end; + size_t used_round; + + used_round = (used + 3U) & ~0x03U; /* round up to 4 */ + p_end = (duk_uint32_t *) ((duk_uint8_t *) ptr + size); + p_start = (duk_uint32_t *) ((duk_uint8_t *) ptr + used_round); + p = (duk_uint32_t *) p_start; + while (p != p_end) { + *p++ = DUK_ALLOC_POOL_WASTE_MARKER; + } +} +#else /* DUK_ALLOC_POOL_TRACK_WASTE */ +static void duk__alloc_pool_set_waste_marker(void *ptr, size_t used, size_t size) { + (void) ptr; (void) used; (void) size; +} +#endif /* DUK_ALLOC_POOL_TRACK_WASTE */ + +#if defined(DUK_ALLOC_POOL_TRACK_WASTE) +static size_t duk__alloc_pool_get_waste_estimate(void *ptr, size_t size) { + duk_uint32_t *p, *p_end, *p_start; + + /* Assumes size is >= 4. */ + p_start = (duk_uint32_t *) ptr; + p_end = (duk_uint32_t *) ((duk_uint8_t *) ptr + size); + p = p_end; + + /* This scan may cause harmless valgrind complaints: there may be + * uninitialized bytes within the legitimate allocation or between + * the start of the waste marker and the end of the allocation. + */ + do { + p--; + if (*p == DUK_ALLOC_POOL_WASTE_MARKER) { + ; + } else { + return (size_t) (p_end - p - 1) * 4U; + } + } while (p != p_start); + + return size; +} +#else /* DUK_ALLOC_POOL_TRACK_WASTE */ +static size_t duk__alloc_pool_get_waste_estimate(void *ptr, size_t size) { + (void) ptr; (void) size; + return 0; +} +#endif /* DUK_ALLOC_POOL_TRACK_WASTE */ + +static int duk__alloc_pool_ptr_in_freelist(duk_pool_state *s, void *ptr) { + duk_pool_free *curr; + + for (curr = s->first; curr != NULL; curr = curr->next) { + if ((void *) curr == ptr) { + return 1; + } + } + return 0; +} + +void duk_alloc_pool_get_pool_stats(duk_pool_state *s, duk_pool_stats *res) { + void *curr; + size_t free_count; + size_t used_count; + size_t waste_bytes; + + curr = s->alloc_end - (s->size * s->count); + free_count = 0U; + waste_bytes = 0U; + while (curr != s->alloc_end) { + if (duk__alloc_pool_ptr_in_freelist(s, curr)) { + free_count++; + } else { + waste_bytes += duk__alloc_pool_get_waste_estimate(curr, s->size); + } + curr = curr + s->size; + } + used_count = (size_t) (s->count - free_count); + + res->used_count = used_count; + res->used_bytes = (size_t) (used_count * s->size); + res->free_count = free_count; + res->free_bytes = (size_t) (free_count * s->size); + res->waste_bytes = waste_bytes; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) + res->hwm_used_count = s->hwm_used_count; +#else + res->hwm_used_count = 0U; +#endif +} + +void duk_alloc_pool_get_global_stats(duk_pool_global *g, duk_pool_global_stats *res) { + int i; + size_t total_used = 0U; + size_t total_free = 0U; + size_t total_waste = 0U; + + for (i = 0; i < g->num_pools; i++) { + duk_pool_state *s = &g->states[i]; + duk_pool_stats stats; + + duk_alloc_pool_get_pool_stats(s, &stats); + + total_used += stats.used_bytes; + total_free += stats.free_bytes; + total_waste += stats.waste_bytes; + } + + res->used_bytes = total_used; + res->free_bytes = total_free; + res->waste_bytes = total_waste; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) + res->hwm_used_bytes = g->hwm_used_bytes; + res->hwm_waste_bytes = g->hwm_waste_bytes; +#else + res->hwm_used_bytes = 0U; + res->hwm_waste_bytes = 0U; +#endif +} + +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) +static void duk__alloc_pool_update_highwater(duk_pool_global *g) { + int i; + size_t total_used = 0U; + size_t total_free = 0U; + size_t total_waste = 0U; + + /* Per pool highwater used count, useful to checking if a pool is + * too small. + */ + for (i = 0; i < g->num_pools; i++) { + duk_pool_state *s = &g->states[i]; + duk_pool_stats stats; + + duk_alloc_pool_get_pool_stats(s, &stats); + if (stats.used_count > s->hwm_used_count) { +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk__alloc_pool_update_highwater: pool %ld (%ld bytes) highwater updated: count %ld -> %ld\n", + (long) i, (long) s->size, + (long) s->hwm_used_count, (long) stats.used_count); +#endif + s->hwm_used_count = stats.used_count; + } + + total_used += stats.used_bytes; + total_free += stats.free_bytes; + total_waste += stats.waste_bytes; + } + + /* Global highwater mark for used and waste bytes. Both fields are + * updated from the same snapshot based on highest used count. + * This is VERY, VERY slow and only useful for development. + * (Note that updating HWM states for pools individually and then + * summing them won't create a consistent global snapshot. There + * are still easy ways to make this much, much faster.) + */ + if (total_used > g->hwm_used_bytes) { +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk__alloc_pool_update_highwater: global highwater updated: used=%ld, bytes=%ld -> " + "used=%ld, bytes=%ld\n", + (long) g->hwm_used_bytes, (long) g->hwm_waste_bytes, + (long) total_used, (long) total_waste); +#endif + g->hwm_used_bytes = total_used; + g->hwm_waste_bytes = total_waste; + } +} +#else /* DUK_ALLOC_POOL_TRACK_HIGHWATER */ +static void duk__alloc_pool_update_highwater(duk_pool_global *g) { + (void) g; +} +#endif /* DUK_ALLOC_POOL_TRACK_HIGHWATER */ + +/* + * Allocation providers + */ + +void *duk_alloc_pool(void *udata, duk_size_t size) { + duk_pool_global *g = (duk_pool_global *) udata; + int i, n; + +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_alloc_pool: %p %ld\n", udata, (long) size); +#endif + + if (size == 0) { + return NULL; + } + + for (i = 0, n = g->num_pools; i < n; i++) { + duk_pool_state *st = g->states + i; + + if (size <= st->size) { + duk_pool_free *res = st->first; + if (res != NULL) { + st->first = res->next; + duk__alloc_pool_set_waste_marker((void *) res, size, st->size); + duk__alloc_pool_update_highwater(g); + return (void *) res; + } + } + + /* Allocation doesn't fit or no free entries, try to borrow + * from the next block size. There's no support for preventing + * a borrow at present. + */ + } + + return NULL; +} + +void *duk_realloc_pool(void *udata, void *ptr, duk_size_t size) { + duk_pool_global *g = (duk_pool_global *) udata; + int i, j, n; + +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_realloc_pool: %p %p %ld\n", udata, ptr, (long) size); +#endif + + if (ptr == NULL) { + return duk_alloc_pool(udata, size); + } + if (size == 0) { + duk_free_pool(udata, ptr); + return NULL; + } + + /* Non-NULL pointers are necessarily from the pool so we should + * always be able to find the allocation. + */ + + for (i = 0, n = g->num_pools; i < n; i++) { + duk_pool_state *st = g->states + i; + char *new_ptr; + + /* Because 'ptr' is assumed to be in the pool and pools are + * allocated in sequence, it suffices to check for end pointer + * only. + */ + if ((char *) ptr >= st->alloc_end) { + continue; + } + + if (size <= st->size) { + /* Allocation still fits existing allocation. Check if + * we can shrink the allocation to a smaller block size + * (smallest possible). + */ + for (j = 0; j < i; j++) { + duk_pool_state *st2 = g->states + j; + + if (size <= st2->size) { + new_ptr = (char *) st2->first; + if (new_ptr != NULL) { +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_realloc_pool: shrink, block size %ld -> %ld\n", + (long) st->size, (long) st2->size); +#endif + st2->first = ((duk_pool_free *) new_ptr)->next; + memcpy((void *) new_ptr, (const void *) ptr, (size_t) size); + ((duk_pool_free *) ptr)->next = st->first; + st->first = (duk_pool_free *) ptr; + duk__alloc_pool_set_waste_marker((void *) new_ptr, size, st2->size); + duk__alloc_pool_update_highwater(g); + return (void *) new_ptr; + } + } + } + + /* Failed to shrink; return existing pointer. */ + duk__alloc_pool_set_waste_marker((void *) ptr, size, st->size); + return ptr; + } + + /* Find first free larger block. */ + for (j = i + 1; j < n; j++) { + duk_pool_state *st2 = g->states + j; + + if (size <= st2->size) { + new_ptr = (char *) st2->first; + if (new_ptr != NULL) { + st2->first = ((duk_pool_free *) new_ptr)->next; + memcpy((void *) new_ptr, (const void *) ptr, (size_t) st->size); + ((duk_pool_free *) ptr)->next = st->first; + st->first = (duk_pool_free *) ptr; + duk__alloc_pool_set_waste_marker((void *) new_ptr, size, st2->size); + duk__alloc_pool_update_highwater(g); + return (void *) new_ptr; + } + } + } + + /* Failed to resize. */ + return NULL; + } + + /* We should never be here because 'ptr' should be a valid pool + * entry and thus always found above. + */ + return NULL; +} + +void duk_free_pool(void *udata, void *ptr) { + duk_pool_global *g = (duk_pool_global *) udata; + int i, n; + +#if defined(DUK_ALLOC_POOL_DEBUG) + duk__alloc_pool_dprintf("duk_free_pool: %p %p\n", udata, ptr); +#endif + + if (ptr == NULL) { + return; + } + + for (i = 0, n = g->num_pools; i < n; i++) { + duk_pool_state *st = g->states + i; + + /* Enough to check end address only. */ + if ((char *) ptr >= st->alloc_end) { + continue; + } + + ((duk_pool_free *) ptr)->next = st->first; + st->first = (duk_pool_free *) ptr; +#if 0 /* never necessary when freeing */ + duk__alloc_pool_update_highwater(g); +#endif + return; + } + + /* We should never be here because 'ptr' should be a valid pool + * entry and thus always found above. + */ +} + +/* + * Pointer compression + */ + +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) +static void duk__alloc_pool_romptr_init(void) { + /* Scan ROM pointer range for faster detection of "is 'p' a ROM pointer" + * later on. + */ + const void * const * ptrs = (const void * const *) duk_rom_compressed_pointers; + duk_alloc_pool_romptr_low = duk_alloc_pool_romptr_high = (const void *) *ptrs; + while (*ptrs) { + if (*ptrs > duk_alloc_pool_romptr_high) { + duk_alloc_pool_romptr_high = (const void *) *ptrs; + } + if (*ptrs < duk_alloc_pool_romptr_low) { + duk_alloc_pool_romptr_low = (const void *) *ptrs; + } + ptrs++; + } +} +#endif + +/* Encode/decode functions are defined in the header to allow inlining. */ + +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) +duk_uint16_t duk_alloc_pool_enc16_rom(void *ptr) { + /* The if-condition should be the fastest possible check + * for "is 'ptr' in ROM?". If pointer is in ROM, we'd like + * to compress it quickly. Here we just scan a ~1K array + * which is very bad for performance. + */ + const void * const * ptrs = duk_rom_compressed_pointers; + while (*ptrs) { + if (*ptrs == ptr) { + return DUK_ALLOC_POOL_ROMPTR_FIRST + (duk_uint16_t) (ptrs - duk_rom_compressed_pointers); + } + ptrs++; + } + + /* We should really never be here: Duktape should only be + * compressing pointers which are in the ROM compressed + * pointers list, which are known at 'make dist' time. + * We go on, causing a pointer compression error. + */ + return 0; +} +#endif diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h new file mode 100755 index 0000000000..286ec0166a --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_alloc_pool.h @@ -0,0 +1,223 @@ +#if !defined(DUK_ALLOC_POOL_H_INCLUDED) +#define DUK_ALLOC_POOL_H_INCLUDED + +#include "duktape.h" + +/* 32-bit (big endian) marker used at the end of pool entries so that wasted + * space can be detected. Waste tracking must be enabled explicitly. + */ +#if defined(DUK_ALLOC_POOL_TRACK_WASTE) +#define DUK_ALLOC_POOL_WASTE_MARKER 0xedcb2345UL +#endif + +/* Pointer compression with ROM strings/objects: + * + * For now, use DUK_USE_ROM_OBJECTS to signal the need for compressed ROM + * pointers. DUK_USE_ROM_PTRCOMP_FIRST is provided for the ROM pointer + * compression range minimum to avoid duplication in user code. + */ +#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16) +#define DUK_ALLOC_POOL_ROMPTR_COMPRESSION +#define DUK_ALLOC_POOL_ROMPTR_FIRST DUK_USE_ROM_PTRCOMP_FIRST + +/* This extern declaration is provided by duktape.h, array provided by duktape.c. + * Because duk_config.h may include this file (to get the inline functions) we + * need to forward declare this also here. + */ +extern const void * const duk_rom_compressed_pointers[]; +#endif + +/* Pool configuration for a certain block size. */ +typedef struct { + unsigned int size; /* must be divisible by 4 and >= sizeof(void *) */ + unsigned int a; /* bytes (not count) to allocate: a*t + b, t is an arbitrary scale parameter */ + unsigned int b; +} duk_pool_config; + +/* Freelist entry, must fit into the smallest block size. */ +struct duk_pool_free; +typedef struct duk_pool_free duk_pool_free; +struct duk_pool_free { + duk_pool_free *next; +}; + +/* Pool state for a certain block size. */ +typedef struct { + duk_pool_free *first; + char *alloc_end; + unsigned int size; + unsigned int count; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) + unsigned int hwm_used_count; +#endif +} duk_pool_state; + +/* Statistics for a certain pool. */ +typedef struct { + size_t used_count; + size_t used_bytes; + size_t free_count; + size_t free_bytes; + size_t waste_bytes; + size_t hwm_used_count; +} duk_pool_stats; + +/* Top level state for all pools. Pointer to this struct is used as the allocator + * userdata pointer. + */ +typedef struct { + int num_pools; + duk_pool_state *states; +#if defined(DUK_ALLOC_POOL_TRACK_HIGHWATER) + size_t hwm_used_bytes; + size_t hwm_waste_bytes; +#endif +} duk_pool_global; + +/* Statistics for the entire set of pools. */ +typedef struct { + size_t used_bytes; + size_t free_bytes; + size_t waste_bytes; + size_t hwm_used_bytes; + size_t hwm_waste_bytes; +} duk_pool_global_stats; + +/* Initialize a pool allocator, arguments: + * - buffer and size: continuous region to use for pool, must align to 4 + * - config: configuration for pools in ascending block size + * - state: state for pools, matches config order + * - num_pools: number of entries in 'config' and 'state' + * - global: global state structure + * + * The 'config', 'state', and 'global' pointers must be valid beyond the init + * call, as long as the pool is used. + * + * Returns a void pointer to be used as userdata for the allocator functions. + * Concretely the return value will be "(void *) global", i.e. the global + * state struct. If pool init fails, the return value will be NULL. + */ +void *duk_alloc_pool_init(char *buffer, + size_t size, + const duk_pool_config *configs, + duk_pool_state *states, + int num_pools, + duk_pool_global *global); + +/* Duktape allocation providers. Typing matches Duktape requirements. */ +void *duk_alloc_pool(void *udata, duk_size_t size); +void *duk_realloc_pool(void *udata, void *ptr, duk_size_t size); +void duk_free_pool(void *udata, void *ptr); + +/* Stats. */ +void duk_alloc_pool_get_pool_stats(duk_pool_state *s, duk_pool_stats *res); +void duk_alloc_pool_get_global_stats(duk_pool_global *g, duk_pool_global_stats *res); + +/* Duktape pointer compression global state (assumes single pool). */ +#if defined(DUK_USE_ROM_OBJECTS) && defined(DUK_USE_HEAPPTR16) +extern const void *duk_alloc_pool_romptr_low; +extern const void *duk_alloc_pool_romptr_high; +duk_uint16_t duk_alloc_pool_enc16_rom(void *ptr); +#endif +#if defined(DUK_USE_HEAPPTR16) +extern void *duk_alloc_pool_ptrcomp_base; +#endif + +#if 0 +duk_uint16_t duk_alloc_pool_enc16(void *ptr); +void *duk_alloc_pool_dec16(duk_uint16_t val); +#endif + +/* Inlined pointer compression functions. Gcc and clang -Os won't in + * practice inline these without an "always inline" attribute because it's + * more size efficient (by a few kB) to use explicit calls instead. Having + * these defined inline here allows performance optimized builds to inline + * pointer compression operations. + * + * Pointer compression assumes there's a single globally registered memory + * pool which makes pointer compression more efficient. This would be easy + * to fix by adding a userdata pointer to the compression functions and + * plumbing the heap userdata from the compression/decompression macros. + */ + +/* DUK_ALWAYS_INLINE is not a public API symbol so it may go away in even a + * minor update. But it's pragmatic for this extra because it handles many + * compilers via duk_config.h detection. Check that the macro exists so that + * if it's gone, we can still compile. + */ +#if defined(DUK_ALWAYS_INLINE) +#define DUK__ALLOC_POOL_ALWAYS_INLINE DUK_ALWAYS_INLINE +#else +#define DUK__ALLOC_POOL_ALWAYS_INLINE /* nop */ +#endif + +#if defined(DUK_USE_HEAPPTR16) +static DUK__ALLOC_POOL_ALWAYS_INLINE duk_uint16_t duk_alloc_pool_enc16(void *ptr) { + if (ptr == NULL) { + /* With 'return 0' gcc and clang -Os generate inefficient code. + * For example, gcc -Os generates: + * + * 0804911d : + * 804911d: 55 push %ebp + * 804911e: 85 c0 test %eax,%eax + * 8049120: 89 e5 mov %esp,%ebp + * 8049122: 74 0b je 804912f + * 8049124: 2b 05 e4 90 07 08 sub 0x80790e4,%eax + * 804912a: c1 e8 02 shr $0x2,%eax + * 804912d: eb 02 jmp 8049131 + * 804912f: 31 c0 xor %eax,%eax + * 8049131: 5d pop %ebp + * 8049132: c3 ret + * + * The NULL path checks %eax for zero; if it is zero, a zero + * is unnecessarily loaded into %eax again. The non-zero path + * has an unnecessary jump as a side effect of this. + * + * Using 'return (duk_uint16_t) (intptr_t) ptr;' generates similarly + * inefficient code; not sure how to make the result better. + */ + return 0; + } +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) + if (ptr >= duk_alloc_pool_romptr_low && ptr <= duk_alloc_pool_romptr_high) { + /* This is complex enough now to need a separate function. */ + return duk_alloc_pool_enc16_rom(ptr); + } +#endif + return (duk_uint16_t) (((size_t) ((char *) ptr - (char *) duk_alloc_pool_ptrcomp_base)) >> 2); +} + +static DUK__ALLOC_POOL_ALWAYS_INLINE void *duk_alloc_pool_dec16(duk_uint16_t val) { + if (val == 0) { + /* As with enc16 the gcc and clang -Os output is inefficient, + * e.g. gcc -Os: + * + * 08049133 : + * 8049133: 55 push %ebp + * 8049134: 66 85 c0 test %ax,%ax + * 8049137: 89 e5 mov %esp,%ebp + * 8049139: 74 0e je 8049149 + * 804913b: 8b 15 e4 90 07 08 mov 0x80790e4,%edx + * 8049141: 0f b7 c0 movzwl %ax,%eax + * 8049144: 8d 04 82 lea (%edx,%eax,4),%eax + * 8049147: eb 02 jmp 804914b + * 8049149: 31 c0 xor %eax,%eax + * 804914b: 5d pop %ebp + * 804914c: c3 ret + */ + return NULL; + } +#if defined(DUK_ALLOC_POOL_ROMPTR_COMPRESSION) + if (val >= DUK_ALLOC_POOL_ROMPTR_FIRST) { + /* This is a blind lookup, could check index validity. + * Duktape should never decompress a pointer which would + * be out-of-bounds here. + */ + return (void *) (intptr_t) (duk_rom_compressed_pointers[val - DUK_ALLOC_POOL_ROMPTR_FIRST]); + } +#endif + return (void *) ((char *) duk_alloc_pool_ptrcomp_base + (((size_t) val) << 2)); +} +#endif + +#endif /* DUK_ALLOC_POOL_H_INCLUDED */ diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h new file mode 100755 index 0000000000..3f217ef7d2 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_config.h @@ -0,0 +1,3672 @@ +/* + * duk_config.h configuration header generated by genconfig.py. + * + * Git commit: a459cf3c9bd1779fc01b435d69302b742675a08f + * Git describe: v2.2.0 + * Git branch: master + * + * Supported platforms: + * - Mac OSX, iPhone, Darwin + * - Orbis + * - OpenBSD + * - Generic BSD + * - Atari ST TOS + * - AmigaOS + * - Durango (XboxOne) + * - Windows + * - Flashplayer (Crossbridge) + * - QNX + * - TI-Nspire + * - Emscripten + * - Linux + * - Solaris + * - AIX + * - HPUX + * - Generic POSIX + * - Cygwin + * - Generic UNIX + * - Generic fallback + * + * Supported architectures: + * - x86 + * - x64 + * - x32 + * - ARM 32-bit + * - ARM 64-bit + * - MIPS 32-bit + * - MIPS 64-bit + * - PowerPC 32-bit + * - PowerPC 64-bit + * - SPARC 32-bit + * - SPARC 64-bit + * - SuperH + * - Motorola 68k + * - Emscripten + * - Generic + * + * Supported compilers: + * - Clang + * - GCC + * - MSVC + * - Emscripten + * - TinyC + * - VBCC + * - Bruce's C compiler + * - Generic + * + */ + +#if !defined(DUK_CONFIG_H_INCLUDED) +#define DUK_CONFIG_H_INCLUDED + +/* + * Intermediate helper defines + */ + +/* DLL build detection */ +/* not configured for DLL build */ +#undef DUK_F_DLL_BUILD + +/* Apple OSX, iOS */ +#if defined(__APPLE__) +#define DUK_F_APPLE +#endif + +/* FreeBSD */ +#if defined(__FreeBSD__) || defined(__FreeBSD) +#define DUK_F_FREEBSD +#endif + +/* Orbis (PS4) variant */ +#if defined(DUK_F_FREEBSD) && defined(__ORBIS__) +#define DUK_F_ORBIS +#endif + +/* OpenBSD */ +#if defined(__OpenBSD__) || defined(__OpenBSD) +#define DUK_F_OPENBSD +#endif + +/* NetBSD */ +#if defined(__NetBSD__) || defined(__NetBSD) +#define DUK_F_NETBSD +#endif + +/* BSD variant */ +#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \ + defined(__bsdi__) || defined(__DragonFly__) +#define DUK_F_BSD +#endif + +/* Atari ST TOS. __TOS__ defined by PureC. No platform define in VBCC + * apparently, so to use with VBCC user must define __TOS__ manually. + */ +#if defined(__TOS__) +#define DUK_F_TOS +#endif + +/* Motorola 68K. Not defined by VBCC, so user must define one of these + * manually when using VBCC. + */ +#if defined(__m68k__) || defined(M68000) || defined(__MC68K__) +#define DUK_F_M68K +#endif + +/* AmigaOS. Neither AMIGA nor __amigaos__ is defined on VBCC, so user must + * define 'AMIGA' manually when using VBCC. + */ +#if defined(AMIGA) || defined(__amigaos__) +#define DUK_F_AMIGAOS +#endif + +/* PowerPC */ +#if defined(__powerpc) || defined(__powerpc__) || defined(__PPC__) +#define DUK_F_PPC +#if defined(__PPC64__) || defined(__LP64__) || defined(_LP64) +#define DUK_F_PPC64 +#else +#define DUK_F_PPC32 +#endif +#endif + +/* Durango (Xbox One) */ +#if defined(_DURANGO) || defined(_XBOX_ONE) +#define DUK_F_DURANGO +#endif + +/* Windows, both 32-bit and 64-bit */ +#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \ + defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__) +#define DUK_F_WINDOWS +#if defined(_WIN64) || defined(WIN64) +#define DUK_F_WIN64 +#else +#define DUK_F_WIN32 +#endif +#endif + +/* Flash player (e.g. Crossbridge) */ +#if defined(__FLASHPLAYER__) +#define DUK_F_FLASHPLAYER +#endif + +/* QNX */ +#if defined(__QNX__) +#define DUK_F_QNX +#endif + +/* TI-Nspire (using Ndless) */ +#if defined(_TINSPIRE) +#define DUK_F_TINSPIRE +#endif + +/* Emscripten (provided explicitly by user), improve if possible */ +#if defined(EMSCRIPTEN) +#define DUK_F_EMSCRIPTEN +#endif + +/* BCC (Bruce's C compiler): this is a "torture target" for compilation */ +#if defined(__BCC__) || defined(__BCC_VERSION__) +#define DUK_F_BCC +#endif + +/* Linux */ +#if defined(__linux) || defined(__linux__) || defined(linux) +#define DUK_F_LINUX +#endif + +/* illumos / Solaris */ +#if defined(__sun) && defined(__SVR4) +#define DUK_F_SUN +#if defined(__SUNPRO_C) && (__SUNPRO_C < 0x550) +#define DUK_F_OLD_SOLARIS +/* Defines _ILP32 / _LP64 required by DUK_F_X86/DUK_F_X64. Platforms + * are processed before architectures, so this happens before the + * DUK_F_X86/DUK_F_X64 detection is emitted. + */ +#include +#endif +#endif + +/* AIX */ +#if defined(_AIX) +/* defined(__xlc__) || defined(__IBMC__): works but too wide */ +#define DUK_F_AIX +#endif + +/* HPUX */ +#if defined(__hpux) +#define DUK_F_HPUX +#if defined(__ia64) +#define DUK_F_HPUX_ITANIUM +#endif +#endif + +/* POSIX */ +#if defined(__posix) +#define DUK_F_POSIX +#endif + +/* Cygwin */ +#if defined(__CYGWIN__) +#define DUK_F_CYGWIN +#endif + +/* Generic Unix (includes Cygwin) */ +#if defined(__unix) || defined(__unix__) || defined(unix) || \ + defined(DUK_F_LINUX) || defined(DUK_F_BSD) +#define DUK_F_UNIX +#endif + +/* C++ */ +#undef DUK_F_CPP +#if defined(__cplusplus) +#define DUK_F_CPP +#endif + +/* Intel x86 (32-bit), x64 (64-bit) or x32 (64-bit but 32-bit pointers), + * define only one of DUK_F_X86, DUK_F_X64, DUK_F_X32. + * https://sites.google.com/site/x32abi/ + * + * With DUK_F_OLD_SOLARIS the header must be included + * before this. + */ +#if defined(__amd64__) || defined(__amd64) || \ + defined(__x86_64__) || defined(__x86_64) || \ + defined(_M_X64) || defined(_M_AMD64) +#if defined(__ILP32__) || defined(_ILP32) +#define DUK_F_X32 +#else +#define DUK_F_X64 +#endif +#elif defined(i386) || defined(__i386) || defined(__i386__) || \ + defined(__i486__) || defined(__i586__) || defined(__i686__) || \ + defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \ + defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__) +#if defined(__LP64__) || defined(_LP64) +/* This should not really happen, but would indicate x64. */ +#define DUK_F_X64 +#else +#define DUK_F_X86 +#endif +#endif + +/* ARM */ +#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM) || defined(__aarch64__) +#define DUK_F_ARM +#if defined(__LP64__) || defined(_LP64) || defined(__arm64) || defined(__arm64__) || defined(__aarch64__) +#define DUK_F_ARM64 +#else +#define DUK_F_ARM32 +#endif +#endif + +/* MIPS. Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */ +#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \ + defined(_R3000) || defined(_R4000) || defined(_R5900) || \ + defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \ + defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \ + defined(__mips) || defined(__MIPS__) +#define DUK_F_MIPS +#if defined(__LP64__) || defined(_LP64) || defined(__mips64) || \ + defined(__mips64__) || defined(__mips_n64) +#define DUK_F_MIPS64 +#else +#define DUK_F_MIPS32 +#endif +#endif + +/* SPARC */ +#if defined(sparc) || defined(__sparc) || defined(__sparc__) +#define DUK_F_SPARC +#if defined(__LP64__) || defined(_LP64) +#define DUK_F_SPARC64 +#else +#define DUK_F_SPARC32 +#endif +#endif + +/* SuperH */ +#if defined(__sh__) || \ + defined(__sh1__) || defined(__SH1__) || \ + defined(__sh2__) || defined(__SH2__) || \ + defined(__sh3__) || defined(__SH3__) || \ + defined(__sh4__) || defined(__SH4__) || \ + defined(__sh5__) || defined(__SH5__) +#define DUK_F_SUPERH +#endif + +/* Clang */ +#if defined(__clang__) +#define DUK_F_CLANG +#endif + +/* C99 or above */ +#undef DUK_F_C99 +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#define DUK_F_C99 +#endif + +/* C++11 or above */ +#undef DUK_F_CPP11 +#if defined(__cplusplus) && (__cplusplus >= 201103L) +#define DUK_F_CPP11 +#endif + +/* GCC. Clang also defines __GNUC__ so don't detect GCC if using Clang. */ +#if defined(__GNUC__) && !defined(__clang__) && !defined(DUK_F_CLANG) +#define DUK_F_GCC +#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__) +/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */ +#define DUK_F_GCC_VERSION (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__) +#else +#error cannot figure out gcc version +#endif +#endif + +/* MinGW. Also GCC flags (DUK_F_GCC) are enabled now. */ +#if defined(__MINGW32__) || defined(__MINGW64__) +#define DUK_F_MINGW +#endif + +/* MSVC */ +#if defined(_MSC_VER) +/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx + * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g. + * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp + */ +#define DUK_F_MSVC +#if defined(_MSC_FULL_VER) +#if (_MSC_FULL_VER > 100000000) +#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER +#else +#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10) +#endif +#endif +#endif /* _MSC_VER */ + +/* TinyC */ +#if defined(__TINYC__) +/* http://bellard.org/tcc/tcc-doc.html#SEC9 */ +#define DUK_F_TINYC +#endif + +/* VBCC */ +#if defined(__VBCC__) +#define DUK_F_VBCC +#endif + +#if defined(ANDROID) || defined(__ANDROID__) +#define DUK_F_ANDROID +#endif + +/* Atari Mint */ +#if defined(__MINT__) +#define DUK_F_MINT +#endif + +/* + * Platform autodetection + */ + +/* Workaround for older C++ compilers before including , + * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366 + */ +#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS) +#define __STDC_LIMIT_MACROS +#endif +#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS) +#define __STDC_CONSTANT_MACROS +#endif + +#if defined(DUK_F_APPLE) +/* --- Mac OSX, iPhone, Darwin --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */ +#if TARGET_IPHONE_SIMULATOR +#define DUK_USE_OS_STRING "iphone-sim" +#elif TARGET_OS_IPHONE +#define DUK_USE_OS_STRING "iphone" +#elif TARGET_OS_MAC +#define DUK_USE_OS_STRING "osx" +#else +#define DUK_USE_OS_STRING "osx-unknown" +#endif + +/* Use _setjmp() on Apple by default, see GH-55. */ +#define DUK_JMPBUF_TYPE jmp_buf +#define DUK_SETJMP(jb) _setjmp((jb)) +#define DUK_LONGJMP(jb) _longjmp((jb), 1) +#elif defined(DUK_F_ORBIS) +/* --- Orbis --- */ +/* Orbis = PS4 */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_S +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "orbis" +#elif defined(DUK_F_OPENBSD) +/* --- OpenBSD --- */ +/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "openbsd" +#elif defined(DUK_F_BSD) +/* --- Generic BSD --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "bsd" +#elif defined(DUK_F_TOS) +/* --- Atari ST TOS --- */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include + +#define DUK_USE_OS_STRING "tos" + +/* TOS on M68K is always big endian. */ +#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_M68K) +#define DUK_USE_BYTEORDER 3 +#endif +#elif defined(DUK_F_AMIGAOS) +/* --- AmigaOS --- */ +#if defined(DUK_F_M68K) +/* AmigaOS on M68k */ +#define DUK_USE_DATE_NOW_TIME +#define DUK_USE_DATE_TZO_GMTIME +/* no parsing (not an error) */ +#define DUK_USE_DATE_FMT_STRFTIME +#include +#elif defined(DUK_F_PPC) +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#if !defined(UINTPTR_MAX) +#define UINTPTR_MAX UINT_MAX +#endif +#else +#error AmigaOS but not M68K/PPC, not supported now +#endif + +#define DUK_USE_OS_STRING "amigaos" + +/* AmigaOS on M68K or PPC is always big endian. */ +#if !defined(DUK_USE_BYTEORDER) && (defined(DUK_F_M68K) || defined(DUK_F_PPC)) +#define DUK_USE_BYTEORDER 3 +#endif +#elif defined(DUK_F_DURANGO) +/* --- Durango (XboxOne) --- */ +/* Durango = XboxOne + * Configuration is nearly identical to Windows, except for + * DUK_USE_DATE_TZO_WINDOWS. + */ + +/* Initial fix: disable secure CRT related warnings when compiling Duktape + * itself (must be defined before including Windows headers). Don't define + * for user code including duktape.h. + */ +#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS +#endif + +/* MSVC does not have sys/param.h */ +#define DUK_USE_DATE_NOW_WINDOWS +#define DUK_USE_DATE_TZO_WINDOWS_NO_DST +/* Note: PRS and FMT are intentionally left undefined for now. This means + * there is no platform specific date parsing/formatting but there is still + * the ISO 8601 standard format. + */ +#if defined(DUK_COMPILING_DUKTAPE) +/* Only include when compiling Duktape to avoid polluting application build + * with a lot of unnecessary defines. + */ +#include +#endif + +#define DUK_USE_OS_STRING "durango" + +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#elif defined(DUK_F_WINDOWS) +/* --- Windows --- */ +/* Windows version can't obviously be determined at compile time, + * but _WIN32_WINNT indicates the minimum version targeted: + * - https://msdn.microsoft.com/en-us/library/6sehtctf.aspx + */ + +/* Initial fix: disable secure CRT related warnings when compiling Duktape + * itself (must be defined before including Windows headers). Don't define + * for user code including duktape.h. + */ +#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS) +#define _CRT_SECURE_NO_WARNINGS +#endif + +/* Windows 32-bit and 64-bit are currently the same. */ +/* MSVC does not have sys/param.h */ + +#if defined(DUK_COMPILING_DUKTAPE) +/* Only include when compiling Duktape to avoid polluting application build + * with a lot of unnecessary defines. + */ +#include +#endif + +/* GetSystemTimePreciseAsFileTime() available from Windows 8: + * https://msdn.microsoft.com/en-us/library/windows/desktop/hh706895(v=vs.85).aspx + */ +#if defined(DUK_USE_DATE_NOW_WINDOWS_SUBMS) || defined(DUK_USE_DATE_NOW_WINDOWS) +/* User forced provider. */ +#else +#if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0602) +#define DUK_USE_DATE_NOW_WINDOWS_SUBMS +#else +#define DUK_USE_DATE_NOW_WINDOWS +#endif +#endif + +#define DUK_USE_DATE_TZO_WINDOWS + +/* Note: PRS and FMT are intentionally left undefined for now. This means + * there is no platform specific date parsing/formatting but there is still + * the ISO 8601 standard format. + */ + +/* QueryPerformanceCounter() may go backwards in Windows XP, so enable for + * Vista and later: https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408(v=vs.85).aspx#qpc_support_in_windows_versions + */ +#if !defined(DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC) && \ + defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0600) +#define DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC +#endif + +#define DUK_USE_OS_STRING "windows" + +/* On Windows, assume we're little endian. Even Itanium which has a + * configurable endianness runs little endian in Windows. + */ +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#elif defined(DUK_F_FLASHPLAYER) +/* --- Flashplayer (Crossbridge) --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "flashplayer" + +#if !defined(DUK_USE_BYTEORDER) && defined(DUK_F_FLASHPLAYER) +#define DUK_USE_BYTEORDER 1 +#endif +#elif defined(DUK_F_QNX) +/* --- QNX --- */ +#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE) +/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */ +#define _XOPEN_SOURCE 600 +#define _POSIX_C_SOURCE 200112L +#endif + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "qnx" +#elif defined(DUK_F_TINSPIRE) +/* --- TI-Nspire --- */ +#if defined(DUK_COMPILING_DUKTAPE) && !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "tinspire" +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#if defined(DUK_COMPILING_DUKTAPE) +#if !defined(_POSIX_C_SOURCE) +#define _POSIX_C_SOURCE 200809L +#endif +#if !defined(_GNU_SOURCE) +#define _GNU_SOURCE /* e.g. getdate_r */ +#endif +#if !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif +#endif /* DUK_COMPILING_DUKTAPE */ + +#include +#if defined(DUK_F_BCC) +/* no endian.h */ +#else +#include +#endif /* DUK_F_BCC */ +#include +#include +#include +#include + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#define DUK_USE_OS_STRING "emscripten" +#elif defined(DUK_F_LINUX) +/* --- Linux --- */ +#if defined(DUK_COMPILING_DUKTAPE) +#if !defined(_POSIX_C_SOURCE) +#define _POSIX_C_SOURCE 200809L +#endif +#if !defined(_GNU_SOURCE) +#define _GNU_SOURCE /* e.g. getdate_r */ +#endif +#if !defined(_XOPEN_SOURCE) +#define _XOPEN_SOURCE /* e.g. strptime */ +#endif +#endif /* DUK_COMPILING_DUKTAPE */ + +#include +#if defined(DUK_F_BCC) +/* no endian.h or stdint.h */ +#else +#include +#include +#endif /* DUK_F_BCC */ +#include +#include +#include + +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#if 0 /* XXX: safe condition? */ +#define DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME +#endif + +#define DUK_USE_OS_STRING "linux" +#elif defined(DUK_F_SUN) +/* --- Solaris --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME + +#include +#if defined(DUK_F_OLD_SOLARIS) +/* Old Solaris with no endian.h, stdint.h */ +#define DUK_F_NO_STDINT_H +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#else /* DUK_F_OLD_SOLARIS */ +#include +#endif /* DUK_F_OLD_SOLARIS */ + +#include +#include +#include + +#define DUK_USE_OS_STRING "solaris" +#elif defined(DUK_F_AIX) +/* --- AIX --- */ +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include + +#define DUK_USE_OS_STRING "aix" +#elif defined(DUK_F_HPUX) +/* --- HPUX --- */ +#define DUK_F_NO_STDINT_H +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include + +#define DUK_USE_OS_STRING "hpux" +#elif defined(DUK_F_POSIX) +/* --- Generic POSIX --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_USE_OS_STRING "posix" +#elif defined(DUK_F_CYGWIN) +/* --- Cygwin --- */ +/* don't use strptime() for now */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#include +#include +#include + +#define DUK_JMPBUF_TYPE jmp_buf +#define DUK_SETJMP(jb) _setjmp((jb)) +#define DUK_LONGJMP(jb) _longjmp((jb), 1) + +#define DUK_USE_OS_STRING "windows" +#elif defined(DUK_F_UNIX) +/* --- Generic UNIX --- */ +#define DUK_USE_DATE_NOW_GETTIMEOFDAY +#define DUK_USE_DATE_TZO_GMTIME_R +#define DUK_USE_DATE_PRS_STRPTIME +#define DUK_USE_DATE_FMT_STRFTIME +#include +#include +#define DUK_USE_OS_STRING "unknown" +#else +/* --- Generic fallback --- */ +/* The most portable current time provider is time(), but it only has a + * one second resolution. + */ +#define DUK_USE_DATE_NOW_TIME + +/* The most portable way to figure out local time offset is gmtime(), + * but it's not thread safe so use with caution. + */ +#define DUK_USE_DATE_TZO_GMTIME + +/* Avoid custom date parsing and formatting for portability. */ +#undef DUK_USE_DATE_PRS_STRPTIME +#undef DUK_USE_DATE_FMT_STRFTIME + +/* Rely on C89 headers only; time.h must be here. */ +#include + +#define DUK_USE_OS_STRING "unknown" +#endif /* autodetect platform */ + +/* Shared includes: C89 */ +#include +#include +#include +#include /* varargs */ +#include +#include /* e.g. ptrdiff_t */ +#include +#include + +/* date.h is omitted, and included per platform */ + +/* Shared includes: stdint.h is C99 */ +#if defined(DUK_F_NO_STDINT_H) +/* stdint.h not available */ +#else +/* Technically C99 (C++11) but found in many systems. On some systems + * __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS must be defined before + * including stdint.h (see above). + */ +#include +#endif + +#if defined(DUK_F_CPP) +#include /* std::exception */ +#endif + +/* + * Architecture autodetection + */ + +#if defined(DUK_F_X86) +/* --- x86 --- */ +#define DUK_USE_ARCH_STRING "x86" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_X64) +/* --- x64 --- */ +#define DUK_USE_ARCH_STRING "x64" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_X32) +/* --- x32 --- */ +#define DUK_USE_ARCH_STRING "x32" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +/* XXX: This is technically not guaranteed because it's possible to configure + * an x86 to require aligned accesses with Alignment Check (AC) flag. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 1 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_ARM32) +/* --- ARM 32-bit --- */ +#define DUK_USE_ARCH_STRING "arm32" +/* Byte order varies, so rely on autodetect. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 4 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_ARM64) +/* --- ARM 64-bit --- */ +#define DUK_USE_ARCH_STRING "arm64" +/* Byte order varies, so rely on autodetect. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_MIPS32) +/* --- MIPS 32-bit --- */ +#define DUK_USE_ARCH_STRING "mips32" +/* MIPS byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_MIPS64) +/* --- MIPS 64-bit --- */ +#define DUK_USE_ARCH_STRING "mips64" +/* MIPS byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_PPC32) +/* --- PowerPC 32-bit --- */ +#define DUK_USE_ARCH_STRING "ppc32" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_PPC64) +/* --- PowerPC 64-bit --- */ +#define DUK_USE_ARCH_STRING "ppc64" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SPARC32) +/* --- SPARC 32-bit --- */ +#define DUK_USE_ARCH_STRING "sparc32" +/* SPARC byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SPARC64) +/* --- SPARC 64-bit --- */ +#define DUK_USE_ARCH_STRING "sparc64" +/* SPARC byte order varies so rely on autodetection. */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_SUPERH) +/* --- SuperH --- */ +#define DUK_USE_ARCH_STRING "sh" +/* Byte order varies, rely on autodetection. */ +/* Based on 'make checkalign' there are no alignment requirements on + * Linux SH4, but align by 4 is probably a good basic default. + */ +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 4 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_M68K) +/* --- Motorola 68k --- */ +#define DUK_USE_ARCH_STRING "m68k" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 3 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#define DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#define DUK_USE_ARCH_STRING "emscripten" +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#if !defined(DUK_USE_ALIGN_BY) +#define DUK_USE_ALIGN_BY 8 +#endif +#undef DUK_USE_PACKED_TVAL +#define DUK_F_PACKED_TVAL_PROVIDED +#else +/* --- Generic --- */ +/* These are necessary wild guesses. */ +#define DUK_USE_ARCH_STRING "generic" +/* Rely on autodetection for byte order, alignment, and packed tval. */ +#endif /* autodetect architecture */ + +/* + * Compiler autodetection + */ + +#if defined(DUK_F_CLANG) +/* --- Clang --- */ +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +/* C99 / C++11 and above: rely on va_copy() which is required. */ +#define DUK_VA_COPY(dest,src) va_copy(dest,src) +#else +/* Clang: assume we have __va_copy() in non-C99 mode. */ +#define DUK_VA_COPY(dest,src) __va_copy(dest,src) +#endif + +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) + +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unreachable) +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif +#endif + +#define DUK_USE_BRANCH_HINTS +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unpredictable) +#define DUK_UNPREDICTABLE(x) __builtin_unpredictable((x)) +#endif +#endif + +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +/* DUK_HOT */ +/* DUK_COLD */ + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#else +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and + * Clang. Based on documentation it should suffice to have the attribute + * in the declaration only, but in practice some warnings are generated unless + * the attribute is also applied to the definition. + */ +#define DUK_INTERNAL_DECL static __attribute__ ((unused)) +#define DUK_INTERNAL static __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#endif +#else +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#endif + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "clang" +#else +#define DUK_USE_COMPILER_STRING "clang" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +#define DUK_USE_UNION_INITIALIZERS + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS +#define DUK_USE_PACK_CLANG_ATTR +#elif defined(DUK_F_GCC) +/* --- GCC --- */ +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +/* C99 / C++11 and above: rely on va_copy() which is required. */ +#define DUK_VA_COPY(dest,src) va_copy(dest,src) +#else +/* GCC: assume we have __va_copy() in non-C99 mode. */ +#define DUK_VA_COPY(dest,src) __va_copy(dest,src) +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L) +/* since gcc-2.5 */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* since gcc-4.5 */ +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif + +#define DUK_USE_BRANCH_HINTS +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L) +/* GCC: test not very accurate; enable only in relatively recent builds + * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html) + */ +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#endif +/* XXX: equivalent of clang __builtin_unpredictable? */ + +#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \ + defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 30101) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \ + defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40300) +#define DUK_HOT __attribute__((hot)) +#define DUK_COLD __attribute__((cold)) +#endif + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#elif defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40000) +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and + * Clang. Based on documentation it should suffice to have the attribute + * in the declaration only, but in practice some warnings are generated unless + * the attribute is also applied to the definition. + */ +#define DUK_INTERNAL_DECL static __attribute__ ((unused)) +#define DUK_INTERNAL static __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#endif +#else +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#endif + +#if defined(DUK_F_MINGW) +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "mingw++" +#else +#define DUK_USE_COMPILER_STRING "mingw" +#endif +#else +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "g++" +#else +#define DUK_USE_COMPILER_STRING "gcc" +#endif +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__)) +#define DUK_USE_VARIADIC_MACROS +#endif + +#define DUK_USE_UNION_INITIALIZERS + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40600) +#define DUK_USE_GCC_PRAGMAS +#else +#undef DUK_USE_GCC_PRAGMAS +#endif + +#define DUK_USE_PACK_GCC_ATTR +#elif defined(DUK_F_MSVC) +/* --- MSVC --- */ +/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */ +#define DUK_NORETURN(decl) __declspec(noreturn) decl + +/* XXX: DUK_UNREACHABLE for msvc? */ + +#undef DUK_USE_BRANCH_HINTS + +/* XXX: DUK_LIKELY, DUK_UNLIKELY for msvc? */ +/* XXX: DUK_NOINLINE, DUK_INLINE, DUK_ALWAYS_INLINE for msvc? */ + +#if defined(DUK_F_DLL_BUILD) && defined(DUK_F_WINDOWS) +/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're + * compiling Duktape or the application. + */ +#if defined(DUK_COMPILING_DUKTAPE) +#define DUK_EXTERNAL_DECL extern __declspec(dllexport) +#define DUK_EXTERNAL __declspec(dllexport) +#else +#define DUK_EXTERNAL_DECL extern __declspec(dllimport) +#define DUK_EXTERNAL should_not_happen +#endif +#if defined(DUK_SINGLE_FILE) +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#else +#define DUK_INTERNAL_DECL extern +#define DUK_INTERNAL /*empty*/ +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static +#endif + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "msvc++" +#else +#define DUK_USE_COMPILER_STRING "msvc" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) +#define DUK_USE_VARIADIC_MACROS +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) +/* VS2005+ should have variadic macros even when they're not C99. */ +#define DUK_USE_VARIADIC_MACROS +#endif + +#undef DUK_USE_UNION_INITIALIZERS +#if defined(_MSC_VER) && (_MSC_VER >= 1800) +/* VS2013+ supports union initializers but there's a bug involving union-inside-struct: + * https://connect.microsoft.com/VisualStudio/feedback/details/805981 + * The bug was fixed (at least) in VS2015 so check for VS2015 for now: + * https://blogs.msdn.microsoft.com/vcblog/2015/07/01/c-compiler-front-end-fixes-in-vs2015/ + * Manually tested using VS2013, CL reports 18.00.31101, so enable for VS2013 too. + */ +#define DUK_USE_UNION_INITIALIZERS +#endif + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS + +#define DUK_USE_PACK_MSVC_PRAGMA + +/* These have been tested from VS2008 onwards; may work in older VS versions + * too but not enabled by default. + */ +#if defined(_MSC_VER) && (_MSC_VER >= 1500) +#define DUK_NOINLINE __declspec(noinline) +#define DUK_INLINE __inline +#define DUK_ALWAYS_INLINE __forceinline +#endif + +#if defined(_MSC_VER) && (_MSC_VER >= 1900) +#define DUK_SNPRINTF snprintf +#define DUK_VSNPRINTF vsnprintf +#else +/* (v)snprintf() is missing before MSVC 2015. Note that _(v)snprintf() does + * NOT NUL terminate on truncation, but Duktape code never assumes that. + * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 + */ +#define DUK_SNPRINTF _snprintf +#define DUK_VSNPRINTF _vsnprintf +#endif + +/* Avoid warning when doing DUK_UNREF(some_function). */ +#if defined(_MSC_VER) && (_MSC_VER < 1500) +#pragma warning(disable: 4100 4101 4550 4551) +#define DUK_UNREF(x) +#else +#define DUK_UNREF(x) do { __pragma(warning(suppress:4100 4101 4550 4551)) (x); } while (0) +#endif + +/* Older versions of MSVC don't support the LL/ULL suffix. */ +#define DUK_U64_CONSTANT(x) x##ui64 +#define DUK_I64_CONSTANT(x) x##i64 +#elif defined(DUK_F_EMSCRIPTEN) +/* --- Emscripten --- */ +#define DUK_NORETURN(decl) decl __attribute__((noreturn)) + +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unreachable) +#define DUK_UNREACHABLE() do { __builtin_unreachable(); } while (0) +#endif +#endif + +#define DUK_USE_BRANCH_HINTS +#define DUK_LIKELY(x) __builtin_expect((x), 1) +#define DUK_UNLIKELY(x) __builtin_expect((x), 0) +#if defined(__clang__) && defined(__has_builtin) +#if __has_builtin(__builtin_unpredictable) +#define DUK_UNPREDICTABLE(x) __builtin_unpredictable((x)) +#endif +#endif + +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_NOINLINE __attribute__((noinline)) +#define DUK_INLINE inline +#define DUK_ALWAYS_INLINE inline __attribute__((always_inline)) +#endif + +#define DUK_EXTERNAL_DECL __attribute__ ((visibility("default"))) extern +#define DUK_EXTERNAL __attribute__ ((visibility("default"))) +#if defined(DUK_SINGLE_FILE) +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +/* Minimize warnings for unused internal functions with GCC >= 3.1.1 and + * Clang. Based on documentation it should suffice to have the attribute + * in the declaration only, but in practice some warnings are generated unless + * the attribute is also applied to the definition. + */ +#define DUK_INTERNAL_DECL static __attribute__ ((unused)) +#define DUK_INTERNAL static __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL static +#define DUK_INTERNAL static +#endif +#else +#if (defined(DUK_F_GCC_VERSION) && DUK_F_GCC_VERSION >= 30101) || defined(DUK_F_CLANG) +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) __attribute__ ((unused)) +#else +#define DUK_INTERNAL_DECL __attribute__ ((visibility("hidden"))) extern +#define DUK_INTERNAL __attribute__ ((visibility("hidden"))) +#endif +#endif +#define DUK_LOCAL_DECL static +#define DUK_LOCAL static + +#define DUK_USE_COMPILER_STRING "emscripten" + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +#define DUK_USE_UNION_INITIALIZERS + +#undef DUK_USE_FLEX_C99 +#undef DUK_USE_FLEX_ZEROSIZE +#undef DUK_USE_FLEX_ONESIZE +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE +#endif + +#undef DUK_USE_GCC_PRAGMAS +#define DUK_USE_PACK_CLANG_ATTR +#elif defined(DUK_F_TINYC) +/* --- TinyC --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "tinyc++" +#else +#define DUK_USE_COMPILER_STRING "tinyc" +#endif + +/* http://bellard.org/tcc/tcc-doc.html#SEC7 */ +#define DUK_USE_VARIADIC_MACROS + +#define DUK_USE_UNION_INITIALIZERS + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER +#elif defined(DUK_F_VBCC) +/* --- VBCC --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "vbcc-c++" +#else +#define DUK_USE_COMPILER_STRING "vbcc" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +/* VBCC supports C99 so check only for C99 for union initializer support. + * Designated union initializers would possibly work even without a C99 check. + */ +#undef DUK_USE_UNION_INITIALIZERS +#if defined(DUK_F_C99) +#define DUK_USE_UNION_INITIALIZERS +#endif + +#define DUK_USE_FLEX_ZEROSIZE +#define DUK_USE_PACK_DUMMY_MEMBER +#elif defined(DUK_F_BCC) +/* --- Bruce's C compiler --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "bcc++" +#else +#define DUK_USE_COMPILER_STRING "bcc" +#endif + +/* Most portable */ +#undef DUK_USE_VARIADIC_MACROS + +/* Most portable, wastes space */ +#undef DUK_USE_UNION_INITIALIZERS + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER + +/* BCC, assume we're on x86. */ +#if !defined(DUK_USE_BYTEORDER) +#define DUK_USE_BYTEORDER 1 +#endif +#else +/* --- Generic --- */ +#undef DUK_USE_BRANCH_HINTS + +#if defined(DUK_F_CPP) +#define DUK_USE_COMPILER_STRING "generic-c++" +#else +#define DUK_USE_COMPILER_STRING "generic" +#endif + +#undef DUK_USE_VARIADIC_MACROS +#if defined(DUK_F_C99) || defined(DUK_F_CPP11) +#define DUK_USE_VARIADIC_MACROS +#endif + +/* C++ doesn't have standard designated union initializers ({ .foo = 1 }). */ +#undef DUK_USE_UNION_INITIALIZERS +#if defined(DUK_F_C99) +#define DUK_USE_UNION_INITIALIZERS +#endif + +/* Most portable, wastes space */ +#define DUK_USE_FLEX_ONESIZE + +/* Most portable, potentially wastes space */ +#define DUK_USE_PACK_DUMMY_MEMBER +#endif /* autodetect compiler */ + +/* uclibc */ +#if defined(__UCLIBC__) +#define DUK_F_UCLIBC +#endif + +/* + * Wrapper typedefs and constants for integer types, also sanity check types. + * + * C99 typedefs are quite good but not always available, and we want to avoid + * forcibly redefining the C99 typedefs. So, there are Duktape wrappers for + * all C99 typedefs and Duktape code should only use these typedefs. Type + * detection when C99 is not supported is best effort and may end up detecting + * some types incorrectly. + * + * Pointer sizes are a portability problem: pointers to different types may + * have a different size and function pointers are very difficult to manage + * portably. + * + * http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types + * + * Note: there's an interesting corner case when trying to define minimum + * signed integer value constants which leads to the current workaround of + * defining e.g. -0x80000000 as (-0x7fffffffL - 1L). See doc/code-issues.txt + * for a longer discussion. + * + * Note: avoid typecasts and computations in macro integer constants as they + * can then no longer be used in macro relational expressions (such as + * #if DUK_SIZE_MAX < 0xffffffffUL). There is internal code which relies on + * being able to compare DUK_SIZE_MAX against a limit. + */ + +/* XXX: add feature options to force basic types from outside? */ + +#if !defined(INT_MAX) +#error INT_MAX not defined +#endif + +/* Check that architecture is two's complement, standard C allows e.g. + * INT_MIN to be -2**31+1 (instead of -2**31). + */ +#if defined(INT_MAX) && defined(INT_MIN) +#if INT_MAX != -(INT_MIN + 1) +#error platform does not seem complement of two +#endif +#else +#error cannot check complement of two +#endif + +/* Pointer size determination based on __WORDSIZE or architecture when + * that's not available. + */ +#if defined(DUK_F_X86) || defined(DUK_F_X32) || \ + defined(DUK_F_M68K) || defined(DUK_F_PPC32) || \ + defined(DUK_F_BCC) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 32)) || \ + ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \ + defined(DUK_F_HPUX)) && defined(_ILP32)) || \ + defined(DUK_F_ARM32) +#define DUK_F_32BIT_PTRS +#elif defined(DUK_F_X64) || \ + (defined(__WORDSIZE) && (__WORDSIZE == 64)) || \ + ((defined(DUK_F_OLD_SOLARIS) || defined(DUK_F_AIX) || \ + defined(DUK_F_HPUX)) && defined(_LP64)) || \ + defined(DUK_F_ARM64) +#define DUK_F_64BIT_PTRS +#else +/* not sure, not needed with C99 anyway */ +#endif + +/* Intermediate define for 'have inttypes.h' */ +#undef DUK_F_HAVE_INTTYPES +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)) +/* vbcc + AmigaOS has C99 but no inttypes.h */ +#define DUK_F_HAVE_INTTYPES +#elif defined(__cplusplus) && (__cplusplus >= 201103L) +/* C++11 apparently ratified stdint.h */ +#define DUK_F_HAVE_INTTYPES +#endif + +/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise + * through automatic detection. + */ +#if defined(DUK_F_HAVE_INTTYPES) +/* C99 or compatible */ + +#define DUK_F_HAVE_64BIT +#include + +typedef uint8_t duk_uint8_t; +typedef int8_t duk_int8_t; +typedef uint16_t duk_uint16_t; +typedef int16_t duk_int16_t; +typedef uint32_t duk_uint32_t; +typedef int32_t duk_int32_t; +typedef uint64_t duk_uint64_t; +typedef int64_t duk_int64_t; +typedef uint_least8_t duk_uint_least8_t; +typedef int_least8_t duk_int_least8_t; +typedef uint_least16_t duk_uint_least16_t; +typedef int_least16_t duk_int_least16_t; +typedef uint_least32_t duk_uint_least32_t; +typedef int_least32_t duk_int_least32_t; +typedef uint_least64_t duk_uint_least64_t; +typedef int_least64_t duk_int_least64_t; +typedef uint_fast8_t duk_uint_fast8_t; +typedef int_fast8_t duk_int_fast8_t; +typedef uint_fast16_t duk_uint_fast16_t; +typedef int_fast16_t duk_int_fast16_t; +typedef uint_fast32_t duk_uint_fast32_t; +typedef int_fast32_t duk_int_fast32_t; +typedef uint_fast64_t duk_uint_fast64_t; +typedef int_fast64_t duk_int_fast64_t; +typedef uintptr_t duk_uintptr_t; +typedef intptr_t duk_intptr_t; +typedef uintmax_t duk_uintmax_t; +typedef intmax_t duk_intmax_t; + +#define DUK_UINT8_MIN 0 +#define DUK_UINT8_MAX UINT8_MAX +#define DUK_INT8_MIN INT8_MIN +#define DUK_INT8_MAX INT8_MAX +#define DUK_UINT_LEAST8_MIN 0 +#define DUK_UINT_LEAST8_MAX UINT_LEAST8_MAX +#define DUK_INT_LEAST8_MIN INT_LEAST8_MIN +#define DUK_INT_LEAST8_MAX INT_LEAST8_MAX +#define DUK_UINT_FAST8_MIN 0 +#define DUK_UINT_FAST8_MAX UINT_FAST8_MAX +#define DUK_INT_FAST8_MIN INT_FAST8_MIN +#define DUK_INT_FAST8_MAX INT_FAST8_MAX +#define DUK_UINT16_MIN 0 +#define DUK_UINT16_MAX UINT16_MAX +#define DUK_INT16_MIN INT16_MIN +#define DUK_INT16_MAX INT16_MAX +#define DUK_UINT_LEAST16_MIN 0 +#define DUK_UINT_LEAST16_MAX UINT_LEAST16_MAX +#define DUK_INT_LEAST16_MIN INT_LEAST16_MIN +#define DUK_INT_LEAST16_MAX INT_LEAST16_MAX +#define DUK_UINT_FAST16_MIN 0 +#define DUK_UINT_FAST16_MAX UINT_FAST16_MAX +#define DUK_INT_FAST16_MIN INT_FAST16_MIN +#define DUK_INT_FAST16_MAX INT_FAST16_MAX +#define DUK_UINT32_MIN 0 +#define DUK_UINT32_MAX UINT32_MAX +#define DUK_INT32_MIN INT32_MIN +#define DUK_INT32_MAX INT32_MAX +#define DUK_UINT_LEAST32_MIN 0 +#define DUK_UINT_LEAST32_MAX UINT_LEAST32_MAX +#define DUK_INT_LEAST32_MIN INT_LEAST32_MIN +#define DUK_INT_LEAST32_MAX INT_LEAST32_MAX +#define DUK_UINT_FAST32_MIN 0 +#define DUK_UINT_FAST32_MAX UINT_FAST32_MAX +#define DUK_INT_FAST32_MIN INT_FAST32_MIN +#define DUK_INT_FAST32_MAX INT_FAST32_MAX +#define DUK_UINT64_MIN 0 +#define DUK_UINT64_MAX UINT64_MAX +#define DUK_INT64_MIN INT64_MIN +#define DUK_INT64_MAX INT64_MAX +#define DUK_UINT_LEAST64_MIN 0 +#define DUK_UINT_LEAST64_MAX UINT_LEAST64_MAX +#define DUK_INT_LEAST64_MIN INT_LEAST64_MIN +#define DUK_INT_LEAST64_MAX INT_LEAST64_MAX +#define DUK_UINT_FAST64_MIN 0 +#define DUK_UINT_FAST64_MAX UINT_FAST64_MAX +#define DUK_INT_FAST64_MIN INT_FAST64_MIN +#define DUK_INT_FAST64_MAX INT_FAST64_MAX + +#define DUK_UINTPTR_MIN 0 +#define DUK_UINTPTR_MAX UINTPTR_MAX +#define DUK_INTPTR_MIN INTPTR_MIN +#define DUK_INTPTR_MAX INTPTR_MAX + +#define DUK_UINTMAX_MIN 0 +#define DUK_UINTMAX_MAX UINTMAX_MAX +#define DUK_INTMAX_MIN INTMAX_MIN +#define DUK_INTMAX_MAX INTMAX_MAX + +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX +#undef DUK_SIZE_MAX_COMPUTED + +#else /* C99 types */ + +/* When C99 types are not available, we use heuristic detection to get + * the basic 8, 16, 32, and (possibly) 64 bit types. The fast/least + * types are then assumed to be exactly the same for now: these could + * be improved per platform but C99 types are very often now available. + * 64-bit types are not available on all platforms; this is OK at least + * on 32-bit platforms. + * + * This detection code is necessarily a bit hacky and can provide typedefs + * and defines that won't work correctly on some exotic platform. + */ + +#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \ + (defined(UCHAR_MAX) && (UCHAR_MAX == 255)) +typedef unsigned char duk_uint8_t; +typedef signed char duk_int8_t; +#else +#error cannot detect 8-bit type +#endif + +#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL) +typedef unsigned short duk_uint16_t; +typedef signed short duk_int16_t; +#elif defined(UINT_MAX) && (UINT_MAX == 65535UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned int duk_uint16_t; +typedef signed int duk_int16_t; +#else +#error cannot detect 16-bit type +#endif + +#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL) +typedef unsigned int duk_uint32_t; +typedef signed int duk_int32_t; +#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL) +/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */ +typedef unsigned long duk_uint32_t; +typedef signed long duk_int32_t; +#else +#error cannot detect 32-bit type +#endif + +/* 64-bit type detection is a bit tricky. + * + * ULLONG_MAX is a standard define. __LONG_LONG_MAX__ and __ULONG_LONG_MAX__ + * are used by at least GCC (even if system headers don't provide ULLONG_MAX). + * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__. + * + * ULL / LL constants are rejected / warned about by some compilers, even if + * the compiler has a 64-bit type and the compiler/system headers provide an + * unsupported constant (ULL/LL)! Try to avoid using ULL / LL constants. + * As a side effect we can only check that e.g. ULONG_MAX is larger than 32 + * bits but can't be sure it is exactly 64 bits. Self tests will catch such + * cases. + */ +#undef DUK_F_HAVE_64BIT +#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX) +#if (ULONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX) +#if (ULLONG_MAX > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__) +#if (__ULONG_LONG_MAX__ > 4294967295UL) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__) +#if (__LONG_LONG_MAX__ > 2147483647L) +#define DUK_F_HAVE_64BIT +typedef unsigned long long duk_uint64_t; +typedef signed long long duk_int64_t; +#endif +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(DUK_F_MINGW) +#define DUK_F_HAVE_64BIT +typedef unsigned long duk_uint64_t; +typedef signed long duk_int64_t; +#endif +#if !defined(DUK_F_HAVE_64BIT) && defined(DUK_F_MSVC) +#define DUK_F_HAVE_64BIT +typedef unsigned __int64 duk_uint64_t; +typedef signed __int64 duk_int64_t; +#endif +#if !defined(DUK_F_HAVE_64BIT) +/* cannot detect 64-bit type, not always needed so don't error */ +#endif + +typedef duk_uint8_t duk_uint_least8_t; +typedef duk_int8_t duk_int_least8_t; +typedef duk_uint16_t duk_uint_least16_t; +typedef duk_int16_t duk_int_least16_t; +typedef duk_uint32_t duk_uint_least32_t; +typedef duk_int32_t duk_int_least32_t; +typedef duk_uint8_t duk_uint_fast8_t; +typedef duk_int8_t duk_int_fast8_t; +typedef duk_uint16_t duk_uint_fast16_t; +typedef duk_int16_t duk_int_fast16_t; +typedef duk_uint32_t duk_uint_fast32_t; +typedef duk_int32_t duk_int_fast32_t; +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uint_least64_t; +typedef duk_int64_t duk_int_least64_t; +typedef duk_uint64_t duk_uint_fast64_t; +typedef duk_int64_t duk_int_fast64_t; +#endif +#if defined(DUK_F_HAVE_64BIT) +typedef duk_uint64_t duk_uintmax_t; +typedef duk_int64_t duk_intmax_t; +#else +typedef duk_uint32_t duk_uintmax_t; +typedef duk_int32_t duk_intmax_t; +#endif + +/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and + * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are + * -not- portable. See code-issues.txt for a detailed discussion. + */ +#define DUK_UINT8_MIN 0UL +#define DUK_UINT8_MAX 0xffUL +#define DUK_INT8_MIN (-0x80L) +#define DUK_INT8_MAX 0x7fL +#define DUK_UINT_LEAST8_MIN 0UL +#define DUK_UINT_LEAST8_MAX 0xffUL +#define DUK_INT_LEAST8_MIN (-0x80L) +#define DUK_INT_LEAST8_MAX 0x7fL +#define DUK_UINT_FAST8_MIN 0UL +#define DUK_UINT_FAST8_MAX 0xffUL +#define DUK_INT_FAST8_MIN (-0x80L) +#define DUK_INT_FAST8_MAX 0x7fL +#define DUK_UINT16_MIN 0UL +#define DUK_UINT16_MAX 0xffffUL +#define DUK_INT16_MIN (-0x7fffL - 1L) +#define DUK_INT16_MAX 0x7fffL +#define DUK_UINT_LEAST16_MIN 0UL +#define DUK_UINT_LEAST16_MAX 0xffffUL +#define DUK_INT_LEAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_LEAST16_MAX 0x7fffL +#define DUK_UINT_FAST16_MIN 0UL +#define DUK_UINT_FAST16_MAX 0xffffUL +#define DUK_INT_FAST16_MIN (-0x7fffL - 1L) +#define DUK_INT_FAST16_MAX 0x7fffL +#define DUK_UINT32_MIN 0UL +#define DUK_UINT32_MAX 0xffffffffUL +#define DUK_INT32_MIN (-0x7fffffffL - 1L) +#define DUK_INT32_MAX 0x7fffffffL +#define DUK_UINT_LEAST32_MIN 0UL +#define DUK_UINT_LEAST32_MAX 0xffffffffUL +#define DUK_INT_LEAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_LEAST32_MAX 0x7fffffffL +#define DUK_UINT_FAST32_MIN 0UL +#define DUK_UINT_FAST32_MAX 0xffffffffUL +#define DUK_INT_FAST32_MIN (-0x7fffffffL - 1L) +#define DUK_INT_FAST32_MAX 0x7fffffffL + +/* 64-bit constants. Since LL / ULL constants are not always available, + * use computed values. These values can't be used in preprocessor + * comparisons; flag them as such. + */ +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINT64_MIN ((duk_uint64_t) 0) +#define DUK_UINT64_MAX ((duk_uint64_t) -1) +#define DUK_INT64_MIN ((duk_int64_t) (~(DUK_UINT64_MAX >> 1))) +#define DUK_INT64_MAX ((duk_int64_t) (DUK_UINT64_MAX >> 1)) +#define DUK_UINT_LEAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_LEAST64_MAX DUK_UINT64_MAX +#define DUK_INT_LEAST64_MIN DUK_INT64_MIN +#define DUK_INT_LEAST64_MAX DUK_INT64_MAX +#define DUK_UINT_FAST64_MIN DUK_UINT64_MIN +#define DUK_UINT_FAST64_MAX DUK_UINT64_MAX +#define DUK_INT_FAST64_MIN DUK_INT64_MIN +#define DUK_INT_FAST64_MAX DUK_INT64_MAX +#define DUK_UINT64_MIN_COMPUTED +#define DUK_UINT64_MAX_COMPUTED +#define DUK_INT64_MIN_COMPUTED +#define DUK_INT64_MAX_COMPUTED +#define DUK_UINT_LEAST64_MIN_COMPUTED +#define DUK_UINT_LEAST64_MAX_COMPUTED +#define DUK_INT_LEAST64_MIN_COMPUTED +#define DUK_INT_LEAST64_MAX_COMPUTED +#define DUK_UINT_FAST64_MIN_COMPUTED +#define DUK_UINT_FAST64_MAX_COMPUTED +#define DUK_INT_FAST64_MIN_COMPUTED +#define DUK_INT_FAST64_MAX_COMPUTED +#endif + +#if defined(DUK_F_HAVE_64BIT) +#define DUK_UINTMAX_MIN DUK_UINT64_MIN +#define DUK_UINTMAX_MAX DUK_UINT64_MAX +#define DUK_INTMAX_MIN DUK_INT64_MIN +#define DUK_INTMAX_MAX DUK_INT64_MAX +#define DUK_UINTMAX_MIN_COMPUTED +#define DUK_UINTMAX_MAX_COMPUTED +#define DUK_INTMAX_MIN_COMPUTED +#define DUK_INTMAX_MAX_COMPUTED +#else +#define DUK_UINTMAX_MIN 0UL +#define DUK_UINTMAX_MAX 0xffffffffUL +#define DUK_INTMAX_MIN (-0x7fffffffL - 1L) +#define DUK_INTMAX_MAX 0x7fffffffL +#endif + +/* This detection is not very reliable. */ +#if defined(DUK_F_32BIT_PTRS) +typedef duk_int32_t duk_intptr_t; +typedef duk_uint32_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT32_MIN +#define DUK_UINTPTR_MAX DUK_UINT32_MAX +#define DUK_INTPTR_MIN DUK_INT32_MIN +#define DUK_INTPTR_MAX DUK_INT32_MAX +#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT) +typedef duk_int64_t duk_intptr_t; +typedef duk_uint64_t duk_uintptr_t; +#define DUK_UINTPTR_MIN DUK_UINT64_MIN +#define DUK_UINTPTR_MAX DUK_UINT64_MAX +#define DUK_INTPTR_MIN DUK_INT64_MIN +#define DUK_INTPTR_MAX DUK_INT64_MAX +#define DUK_UINTPTR_MIN_COMPUTED +#define DUK_UINTPTR_MAX_COMPUTED +#define DUK_INTPTR_MIN_COMPUTED +#define DUK_INTPTR_MAX_COMPUTED +#else +#error cannot determine intptr type +#endif + +/* SIZE_MAX may be missing so use an approximate value for it. */ +#undef DUK_SIZE_MAX_COMPUTED +#if !defined(SIZE_MAX) +#define DUK_SIZE_MAX_COMPUTED +#define SIZE_MAX ((size_t) (-1)) +#endif +#define DUK_SIZE_MIN 0 +#define DUK_SIZE_MAX SIZE_MAX + +#endif /* C99 types */ + +/* A few types are assumed to always exist. */ +typedef size_t duk_size_t; +typedef ptrdiff_t duk_ptrdiff_t; + +/* The best type for an "all around int" in Duktape internals is "at least + * 32 bit signed integer" which is most convenient. Same for unsigned type. + * Prefer 'int' when large enough, as it is almost always a convenient type. + */ +#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL) +typedef int duk_int_t; +typedef unsigned int duk_uint_t; +#define DUK_INT_MIN INT_MIN +#define DUK_INT_MAX INT_MAX +#define DUK_UINT_MIN 0 +#define DUK_UINT_MAX UINT_MAX +#else +typedef duk_int_fast32_t duk_int_t; +typedef duk_uint_fast32_t duk_uint_t; +#define DUK_INT_MIN DUK_INT_FAST32_MIN +#define DUK_INT_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_MAX DUK_UINT_FAST32_MAX +#endif + +/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this + * distinction matters for the CPU. These types are used mainly in the + * executor where it might really matter. + */ +typedef duk_int_fast32_t duk_int_fast_t; +typedef duk_uint_fast32_t duk_uint_fast_t; +#define DUK_INT_FAST_MIN DUK_INT_FAST32_MIN +#define DUK_INT_FAST_MAX DUK_INT_FAST32_MAX +#define DUK_UINT_FAST_MIN DUK_UINT_FAST32_MIN +#define DUK_UINT_FAST_MAX DUK_UINT_FAST32_MAX + +/* Small integers (16 bits or more) can fall back to the 'int' type, but + * have a typedef so they are marked "small" explicitly. + */ +typedef int duk_small_int_t; +typedef unsigned int duk_small_uint_t; +#define DUK_SMALL_INT_MIN INT_MIN +#define DUK_SMALL_INT_MAX INT_MAX +#define DUK_SMALL_UINT_MIN 0 +#define DUK_SMALL_UINT_MAX UINT_MAX + +/* Fast variants of small integers, again for really fast paths like the + * executor. + */ +typedef duk_int_fast16_t duk_small_int_fast_t; +typedef duk_uint_fast16_t duk_small_uint_fast_t; +#define DUK_SMALL_INT_FAST_MIN DUK_INT_FAST16_MIN +#define DUK_SMALL_INT_FAST_MAX DUK_INT_FAST16_MAX +#define DUK_SMALL_UINT_FAST_MIN DUK_UINT_FAST16_MIN +#define DUK_SMALL_UINT_FAST_MAX DUK_UINT_FAST16_MAX + +/* Boolean values are represented with the platform 'unsigned int'. */ +typedef duk_small_uint_t duk_bool_t; +#define DUK_BOOL_MIN DUK_SMALL_INT_MIN +#define DUK_BOOL_MAX DUK_SMALL_INT_MAX + +/* Index values must have at least 32-bit signed range. */ +typedef duk_int_t duk_idx_t; +#define DUK_IDX_MIN DUK_INT_MIN +#define DUK_IDX_MAX DUK_INT_MAX + +/* Unsigned index variant. */ +typedef duk_uint_t duk_uidx_t; +#define DUK_UIDX_MIN DUK_UINT_MIN +#define DUK_UIDX_MAX DUK_UINT_MAX + +/* Array index values, could be exact 32 bits. + * Currently no need for signed duk_arridx_t. + */ +typedef duk_uint_t duk_uarridx_t; +#define DUK_UARRIDX_MIN DUK_UINT_MIN +#define DUK_UARRIDX_MAX DUK_UINT_MAX + +/* Duktape/C function return value, platform int is enough for now to + * represent 0, 1, or negative error code. Must be compatible with + * assigning truth values (e.g. duk_ret_t rc = (foo == bar);). + */ +typedef duk_small_int_t duk_ret_t; +#define DUK_RET_MIN DUK_SMALL_INT_MIN +#define DUK_RET_MAX DUK_SMALL_INT_MAX + +/* Error codes are represented with platform int. High bits are used + * for flags and such, so 32 bits are needed. + */ +typedef duk_int_t duk_errcode_t; +#define DUK_ERRCODE_MIN DUK_INT_MIN +#define DUK_ERRCODE_MAX DUK_INT_MAX + +/* Codepoint type. Must be 32 bits or more because it is used also for + * internal codepoints. The type is signed because negative codepoints + * are used as internal markers (e.g. to mark EOF or missing argument). + * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to + * ensure duk_uint32_t casts back and forth nicely. Almost everything + * else uses the signed one. + */ +typedef duk_int_t duk_codepoint_t; +typedef duk_uint_t duk_ucodepoint_t; +#define DUK_CODEPOINT_MIN DUK_INT_MIN +#define DUK_CODEPOINT_MAX DUK_INT_MAX +#define DUK_UCODEPOINT_MIN DUK_UINT_MIN +#define DUK_UCODEPOINT_MAX DUK_UINT_MAX + +/* IEEE float/double typedef. */ +typedef float duk_float_t; +typedef double duk_double_t; + +/* We're generally assuming that we're working on a platform with a 32-bit + * address space. If DUK_SIZE_MAX is a typecast value (which is necessary + * if SIZE_MAX is missing), the check must be avoided because the + * preprocessor can't do a comparison. + */ +#if !defined(DUK_SIZE_MAX) +#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX +#elif !defined(DUK_SIZE_MAX_COMPUTED) +#if DUK_SIZE_MAX < 0xffffffffUL +/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value + * which seems incorrect if size_t is (at least) an unsigned 32-bit type. + * However, it doesn't seem useful to error out compilation if this is the + * case. + */ +#endif +#endif + +/* Type used in public API declarations and user code. Typedef maps to + * 'struct duk_hthread' like the 'duk_hthread' typedef which is used + * exclusively in internals. + */ +typedef struct duk_hthread duk_context; + +/* Check whether we should use 64-bit integers or not. + * + * Quite incomplete now. Use 64-bit types if detected (C99 or other detection) + * unless they are known to be unreliable. For instance, 64-bit types are + * available on VBCC but seem to misbehave. + */ +#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC) +#define DUK_USE_64BIT_OPS +#else +#undef DUK_USE_64BIT_OPS +#endif + +/* + * Fill-ins for platform, architecture, and compiler + */ + +/* An abort()-like primitive is needed by the default fatal error handler. */ +#if !defined(DUK_ABORT) +#define DUK_ABORT abort +#endif + +#if !defined(DUK_SETJMP) +#define DUK_JMPBUF_TYPE jmp_buf +#define DUK_SETJMP(jb) setjmp((jb)) +#define DUK_LONGJMP(jb) longjmp((jb), 1) +#endif + +#if 0 +/* sigsetjmp() alternative */ +#define DUK_JMPBUF_TYPE sigjmp_buf +#define DUK_SETJMP(jb) sigsetjmp((jb)) +#define DUK_LONGJMP(jb) siglongjmp((jb), 1) +#endif + +/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h + * (which is unfortunately named). May sometimes need replacement, e.g. + * some compilers don't handle zero length or NULL correctly in realloc(). + */ +#if !defined(DUK_ANSI_MALLOC) +#define DUK_ANSI_MALLOC malloc +#endif +#if !defined(DUK_ANSI_REALLOC) +#define DUK_ANSI_REALLOC realloc +#endif +#if !defined(DUK_ANSI_CALLOC) +#define DUK_ANSI_CALLOC calloc +#endif +#if !defined(DUK_ANSI_FREE) +#define DUK_ANSI_FREE free +#endif + +/* ANSI C (various versions) and some implementations require that the + * pointer arguments to memset(), memcpy(), and memmove() be valid values + * even when byte size is 0 (even a NULL pointer is considered invalid in + * this context). Zero-size operations as such are allowed, as long as their + * pointer arguments point to a valid memory area. The DUK_MEMSET(), + * DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.: + * (1) pointers must be valid and non-NULL, (2) zero size must otherwise be + * allowed. If these are not fulfilled, a macro wrapper is needed. + * + * http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0 + * http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html + * + * Not sure what's the required behavior when a pointer points just past the + * end of a buffer, which often happens in practice (e.g. zero size memmoves). + * For example, if allocation size is 3, the following pointer would not + * technically point to a valid memory byte: + * + * <-- alloc --> + * | 0 | 1 | 2 | ..... + * ^-- p=3, points after last valid byte (2) + */ +#if !defined(DUK_MEMCPY) +#if defined(DUK_F_UCLIBC) +/* Old uclibcs have a broken memcpy so use memmove instead (this is overly wide + * now on purpose): http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html + */ +#define DUK_MEMCPY memmove +#else +#define DUK_MEMCPY memcpy +#endif +#endif +#if !defined(DUK_MEMMOVE) +#define DUK_MEMMOVE memmove +#endif +#if !defined(DUK_MEMCMP) +#define DUK_MEMCMP memcmp +#endif +#if !defined(DUK_MEMSET) +#define DUK_MEMSET memset +#endif +#if !defined(DUK_STRLEN) +#define DUK_STRLEN strlen +#endif +#if !defined(DUK_STRCMP) +#define DUK_STRCMP strcmp +#endif +#if !defined(DUK_STRNCMP) +#define DUK_STRNCMP strncmp +#endif +#if !defined(DUK_SPRINTF) +#define DUK_SPRINTF sprintf +#endif +#if !defined(DUK_SNPRINTF) +/* snprintf() is technically not part of C89 but usually available. */ +#define DUK_SNPRINTF snprintf +#endif +#if !defined(DUK_VSPRINTF) +#define DUK_VSPRINTF vsprintf +#endif +#if !defined(DUK_VSNPRINTF) +/* vsnprintf() is technically not part of C89 but usually available. */ +#define DUK_VSNPRINTF vsnprintf +#endif +#if !defined(DUK_SSCANF) +#define DUK_SSCANF sscanf +#endif +#if !defined(DUK_VSSCANF) +#define DUK_VSSCANF vsscanf +#endif +#if !defined(DUK_MEMZERO) +#define DUK_MEMZERO(p,n) DUK_MEMSET((p), 0, (n)) +#endif + +#if !defined(DUK_DOUBLE_INFINITY) +#undef DUK_USE_COMPUTED_INFINITY +#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600) +/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */ +#define DUK_DOUBLE_INFINITY (__builtin_inf()) +#elif defined(INFINITY) +#define DUK_DOUBLE_INFINITY ((double) INFINITY) +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) && \ + !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX) +#define DUK_DOUBLE_INFINITY (1.0 / 0.0) +#else +/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity. + * Use a computed infinity (initialized when a heap is created at the + * latest). + */ +#define DUK_USE_COMPUTED_INFINITY +#define DUK_DOUBLE_INFINITY duk_computed_infinity +#endif +#endif + +#if !defined(DUK_DOUBLE_NAN) +#undef DUK_USE_COMPUTED_NAN +#if defined(NAN) +#define DUK_DOUBLE_NAN NAN +#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC) && \ + !defined(DUK_F_OLD_SOLARIS) && !defined(DUK_F_AIX) +#define DUK_DOUBLE_NAN (0.0 / 0.0) +#else +/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN. + * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error. + * Use a computed NaN (initialized when a heap is created at the + * latest). + */ +#define DUK_USE_COMPUTED_NAN +#define DUK_DOUBLE_NAN duk_computed_nan +#endif +#endif + +/* Many platforms are missing fpclassify() and friends, so use replacements + * if necessary. The replacement constants (FP_NAN etc) can be anything but + * match Linux constants now. + */ +#undef DUK_USE_REPL_FPCLASSIFY +#undef DUK_USE_REPL_SIGNBIT +#undef DUK_USE_REPL_ISFINITE +#undef DUK_USE_REPL_ISNAN +#undef DUK_USE_REPL_ISINF + +/* Complex condition broken into separate parts. */ +#undef DUK_F_USE_REPL_ALL +#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \ + defined(FP_SUBNORMAL) && defined(FP_NORMAL)) +/* Missing some obvious constants. */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC) +/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue). */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_M68K) +/* AmigaOS + M68K seems to have math issues even when using GCC cross + * compilation. Use replacements for all AmigaOS versions on M68K + * regardless of compiler. + */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG) +/* Placeholder fix for (detection is wider than necessary): + * http://llvm.org/bugs/show_bug.cgi?id=17788 + */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_UCLIBC) +/* At least some uclibc versions have broken floating point math. For + * example, fpclassify() can incorrectly classify certain NaN formats. + * To be safe, use replacements. + */ +#define DUK_F_USE_REPL_ALL +#elif defined(DUK_F_AIX) +/* Older versions may be missing isnan(), etc. */ +#define DUK_F_USE_REPL_ALL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#define DUK_USE_REPL_FPCLASSIFY +#define DUK_USE_REPL_SIGNBIT +#define DUK_USE_REPL_ISFINITE +#define DUK_USE_REPL_ISNAN +#define DUK_USE_REPL_ISINF +#define DUK_FPCLASSIFY duk_repl_fpclassify +#define DUK_SIGNBIT duk_repl_signbit +#define DUK_ISFINITE duk_repl_isfinite +#define DUK_ISNAN duk_repl_isnan +#define DUK_ISINF duk_repl_isinf +#define DUK_FP_NAN 0 +#define DUK_FP_INFINITE 1 +#define DUK_FP_ZERO 2 +#define DUK_FP_SUBNORMAL 3 +#define DUK_FP_NORMAL 4 +#else +#define DUK_FPCLASSIFY fpclassify +#define DUK_SIGNBIT signbit +#define DUK_ISFINITE isfinite +#define DUK_ISNAN isnan +#define DUK_ISINF isinf +#define DUK_FP_NAN FP_NAN +#define DUK_FP_INFINITE FP_INFINITE +#define DUK_FP_ZERO FP_ZERO +#define DUK_FP_SUBNORMAL FP_SUBNORMAL +#define DUK_FP_NORMAL FP_NORMAL +#endif + +#if defined(DUK_F_USE_REPL_ALL) +#undef DUK_F_USE_REPL_ALL +#endif + +/* These functions don't currently need replacement but are wrapped for + * completeness. Because these are used as function pointers, they need + * to be defined as concrete C functions (not macros). + */ +#if !defined(DUK_FABS) +#define DUK_FABS fabs +#endif +#if !defined(DUK_FLOOR) +#define DUK_FLOOR floor +#endif +#if !defined(DUK_CEIL) +#define DUK_CEIL ceil +#endif +#if !defined(DUK_FMOD) +#define DUK_FMOD fmod +#endif +#if !defined(DUK_POW) +#define DUK_POW pow +#endif +#if !defined(DUK_ACOS) +#define DUK_ACOS acos +#endif +#if !defined(DUK_ASIN) +#define DUK_ASIN asin +#endif +#if !defined(DUK_ATAN) +#define DUK_ATAN atan +#endif +#if !defined(DUK_ATAN2) +#define DUK_ATAN2 atan2 +#endif +#if !defined(DUK_SIN) +#define DUK_SIN sin +#endif +#if !defined(DUK_COS) +#define DUK_COS cos +#endif +#if !defined(DUK_TAN) +#define DUK_TAN tan +#endif +#if !defined(DUK_EXP) +#define DUK_EXP exp +#endif +#if !defined(DUK_LOG) +#define DUK_LOG log +#endif +#if !defined(DUK_SQRT) +#define DUK_SQRT sqrt +#endif + +/* The functions below exist only in C99/C++11 or later and need a workaround + * for platforms that don't include them. MSVC isn't detected as C99, but + * these functions also exist in MSVC 2013 and later so include a clause for + * that too. Android doesn't have log2; disable all of these for Android. + */ +#if (defined(DUK_F_C99) || defined(DUK_F_CPP11) || (defined(_MSC_VER) && (_MSC_VER >= 1800))) && \ + !defined(DUK_F_ANDROID) && !defined(DUK_F_MINT) +#if !defined(DUK_CBRT) +#define DUK_CBRT cbrt +#endif +#if !defined(DUK_LOG2) +#define DUK_LOG2 log2 +#endif +#if !defined(DUK_LOG10) +#define DUK_LOG10 log10 +#endif +#if !defined(DUK_TRUNC) +#define DUK_TRUNC trunc +#endif +#endif /* DUK_F_C99 etc */ + +/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics, + * see test-bug-netbsd-math-pow.js. MinGW has similar (but different) + * issues, see test-bug-mingw-math-issues.js. Enable pow() workarounds + * for these targets. + */ +#undef DUK_USE_POW_WORKAROUNDS +#if defined(DUK_F_NETBSD) || defined(DUK_F_MINGW) +#define DUK_USE_POW_WORKAROUNDS +#endif + +/* Similar workarounds for atan2() semantics issues. MinGW issues are + * documented in test-bug-mingw-math-issues.js. + */ +#undef DUK_USE_ATAN2_WORKAROUNDS +#if defined(DUK_F_MINGW) +#define DUK_USE_ATAN2_WORKAROUNDS +#endif + +/* Rely as little as possible on compiler behavior for NaN comparison, + * signed zero handling, etc. Currently never activated but may be needed + * for broken compilers. + */ +#undef DUK_USE_PARANOID_MATH + +/* There was a curious bug where test-bi-date-canceling.js would fail e.g. + * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99. Some date computations + * using doubles would be optimized which then broke some corner case tests. + * The problem goes away by adding 'volatile' to the datetime computations. + * Not sure what the actual triggering conditions are, but using this on + * non-C99 systems solves the known issues and has relatively little cost + * on other platforms. + */ +#undef DUK_USE_PARANOID_DATE_COMPUTATION +#if !defined(DUK_F_C99) +#define DUK_USE_PARANOID_DATE_COMPUTATION +#endif + +/* + * Byte order and double memory layout detection + * + * Endianness detection is a major portability hassle because the macros + * and headers are not standardized. There's even variance across UNIX + * platforms. Even with "standard" headers, details like underscore count + * varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used + * (Crossbridge has a single underscore, for instance). + * + * The checks below are structured with this in mind: several approaches are + * used, and at the end we check if any of them worked. This allows generic + * approaches to be tried first, and platform/compiler specific hacks tried + * last. As a last resort, the user can force a specific endianness, as it's + * not likely that automatic detection will work on the most exotic platforms. + * + * Duktape supports little and big endian machines. There's also support + * for a hybrid used by some ARM machines where integers are little endian + * but IEEE double values use a mixed order (12345678 -> 43218765). This + * byte order for doubles is referred to as "mixed endian". + */ + +/* GCC and Clang provide endianness defines as built-in predefines, with + * leading and trailing double underscores (e.g. __BYTE_ORDER__). See + * output of "make gccpredefs" and "make clangpredefs". Clang doesn't + * seem to provide __FLOAT_WORD_ORDER__; assume not mixed endian for clang. + * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html + */ +#if !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) +#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__) +#define DUK_USE_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_USE_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 1 +#else +/* Byte order is little endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__) +#define DUK_USE_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER__) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 3 +#else +/* Byte order is big endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#else +/* Cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit + * integer ordering and is not relevant. + */ +#endif /* integer byte order */ +#endif /* !defined(DUK_USE_BYTEORDER) && defined(__BYTE_ORDER__) */ + +/* More or less standard endianness predefines provided by header files. + * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER + * will be big endian, see: http://lists.mysql.com/internals/443. + * On some platforms some defines may be present with an empty value which + * causes comparisons to fail: https://github.com/svaarala/duktape/issues/453. + */ +#if !defined(DUK_USE_BYTEORDER) +#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \ + defined(__LITTLE_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN) +#define DUK_USE_BYTEORDER 1 +#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_USE_BYTEORDER 2 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 1 +#else +/* Byte order is little endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \ + defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \ + defined(__BIG_ENDIAN__) +#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \ + defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN) +#define DUK_USE_BYTEORDER 3 +#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER) +/* Float word order not known, assume not a hybrid. */ +#define DUK_USE_BYTEORDER 3 +#else +/* Byte order is big endian but cannot determine IEEE double word order. */ +#endif /* float word order */ +#else +/* Cannot determine byte order. */ +#endif /* integer byte order */ +#endif /* !defined(DUK_USE_BYTEORDER) */ + +/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__: + * $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - > 24) | \ + ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \ + ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \ + (((duk_uint32_t) (x)) << 24)) +#endif +#if !defined(DUK_BSWAP16) +#define DUK_BSWAP16(x) \ + ((duk_uint16_t) (x) >> 8) | \ + ((duk_uint16_t) (x) << 8) +#endif + +/* DUK_USE_VARIADIC_MACROS: required from compilers, so no fill-in. */ +/* DUK_USE_UNION_INITIALIZERS: required from compilers, so no fill-in. */ + +#if !(defined(DUK_USE_FLEX_C99) || defined(DUK_USE_FLEX_ZEROSIZE) || defined(DUK_USE_FLEX_ONESIZE)) +#if defined(DUK_F_C99) +#define DUK_USE_FLEX_C99 +#else +#define DUK_USE_FLEX_ZEROSIZE /* Not standard but common enough */ +#endif +#endif + +#if !(defined(DUK_USE_PACK_GCC_ATTR) || defined(DUK_USE_PACK_CLANG_ATTR) || \ + defined(DUK_USE_PACK_MSVC_PRAGMA) || defined(DUK_USE_PACK_DUMMY_MEMBER)) +#define DUK_USE_PACK_DUMMY_MEMBER +#endif + +#if 0 /* not defined by default */ +#undef DUK_USE_GCC_PRAGMAS +#endif + +#if !defined(DUK_U64_CONSTANT) +#define DUK_U64_CONSTANT(x) x##ULL +#endif +#if !defined(DUK_I64_CONSTANT) +#define DUK_I64_CONSTANT(x) x##LL +#endif + +/* Workaround for GH-323: avoid inlining control when compiling from + * multiple sources, as it causes compiler portability trouble. + */ +#if !defined(DUK_SINGLE_FILE) +#undef DUK_NOINLINE +#undef DUK_INLINE +#undef DUK_ALWAYS_INLINE +#define DUK_NOINLINE /*nop*/ +#define DUK_INLINE /*nop*/ +#define DUK_ALWAYS_INLINE /*nop*/ +#endif + +/* + * Check whether or not a packed duk_tval representation is possible. + * What's basically required is that pointers are 32-bit values + * (sizeof(void *) == 4). Best effort check, not always accurate. + * If guess goes wrong, crashes may result; self tests also verify + * the guess. + */ + +/* Explicit marker needed; may be 'defined', 'undefined, 'or 'not provided'. */ +#if !defined(DUK_F_PACKED_TVAL_PROVIDED) +#undef DUK_F_PACKED_TVAL_POSSIBLE + +/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED) +#if (DUK_UINTPTR_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */ +#if !defined(DUK_F_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED) +#if (DUK_SIZE_MAX <= 0xffffffffUL) +#define DUK_F_PACKED_TVAL_POSSIBLE +#endif +#endif + +#undef DUK_USE_PACKED_TVAL +#if defined(DUK_F_PACKED_TVAL_POSSIBLE) +#define DUK_USE_PACKED_TVAL +#endif + +#undef DUK_F_PACKED_TVAL_POSSIBLE +#endif /* DUK_F_PACKED_TVAL_PROVIDED */ +/* Object property allocation layout has implications for memory and code + * footprint and generated code size/speed. The best layout also depends + * on whether the platform has alignment requirements or benefits from + * having mostly aligned accesses. + */ +#undef DUK_USE_HOBJECT_LAYOUT_1 +#undef DUK_USE_HOBJECT_LAYOUT_2 +#undef DUK_USE_HOBJECT_LAYOUT_3 +#if (DUK_USE_ALIGN_BY == 1) +/* On platforms without any alignment issues, layout 1 is preferable + * because it compiles to slightly less code and provides direct access + * to property keys. + */ +#define DUK_USE_HOBJECT_LAYOUT_1 +#else +/* On other platforms use layout 2, which requires some padding but + * is a bit more natural than layout 3 in ordering the entries. Layout + * 3 is currently not used. + */ +#define DUK_USE_HOBJECT_LAYOUT_2 +#endif + +/* GCC/clang inaccurate math would break compliance and probably duk_tval, + * so refuse to compile. Relax this if -ffast-math is tested to work. + */ +#if defined(__FAST_MATH__) +#error __FAST_MATH__ defined, refusing to compile +#endif + +/* + * Autogenerated defaults + */ + +#define DUK_USE_ARRAY_BUILTIN +#define DUK_USE_ARRAY_FASTPATH +#define DUK_USE_ARRAY_PROP_FASTPATH +#undef DUK_USE_ASSERTIONS +#define DUK_USE_AUGMENT_ERROR_CREATE +#define DUK_USE_AUGMENT_ERROR_THROW +#define DUK_USE_AVOID_PLATFORM_FUNCPTRS +#define DUK_USE_BASE64_FASTPATH +#define DUK_USE_BOOLEAN_BUILTIN +#define DUK_USE_BUFFEROBJECT_SUPPORT +#undef DUK_USE_BUFLEN16 +#define DUK_USE_BYTECODE_DUMP_SUPPORT +#define DUK_USE_CACHE_ACTIVATION +#define DUK_USE_CACHE_CATCHER +#define DUK_USE_CALLSTACK_LIMIT 10000 +#define DUK_USE_COMMONJS_MODULES +#define DUK_USE_COMPILER_RECLIMIT 2500 +#define DUK_USE_COROUTINE_SUPPORT +#undef DUK_USE_CPP_EXCEPTIONS +#undef DUK_USE_DATAPTR16 +#undef DUK_USE_DATAPTR_DEC16 +#undef DUK_USE_DATAPTR_ENC16 +#define DUK_USE_DATE_BUILTIN +#undef DUK_USE_DATE_FORMAT_STRING +#undef DUK_USE_DATE_GET_LOCAL_TZOFFSET +#undef DUK_USE_DATE_GET_NOW +#undef DUK_USE_DATE_PARSE_STRING +#undef DUK_USE_DATE_PRS_GETDATE +#undef DUK_USE_DEBUG +#undef DUK_USE_DEBUGGER_DUMPHEAP +#undef DUK_USE_DEBUGGER_INSPECT +#undef DUK_USE_DEBUGGER_PAUSE_UNCAUGHT +#undef DUK_USE_DEBUGGER_SUPPORT +#define DUK_USE_DEBUGGER_THROW_NOTIFY +#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE +#define DUK_USE_DEBUG_BUFSIZE 65536L +#define DUK_USE_DEBUG_LEVEL 0 +#undef DUK_USE_DEBUG_WRITE +#define DUK_USE_DOUBLE_LINKED_HEAP +#define DUK_USE_DUKTAPE_BUILTIN +#define DUK_USE_ENCODING_BUILTINS +#define DUK_USE_ERRCREATE +#define DUK_USE_ERRTHROW +#define DUK_USE_ES6 +#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY +#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF +#define DUK_USE_ES6_PROXY +#define DUK_USE_ES6_REGEXP_SYNTAX +#define DUK_USE_ES6_UNICODE_ESCAPE +#define DUK_USE_ES7 +#define DUK_USE_ES7_EXP_OPERATOR +#define DUK_USE_ES8 +#define DUK_USE_ES9 +#define DUK_USE_ESBC_LIMITS +#define DUK_USE_ESBC_MAX_BYTES 2147418112L +#define DUK_USE_ESBC_MAX_LINENUMBER 2147418112L +#undef DUK_USE_EXEC_FUN_LOCAL +#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK +#undef DUK_USE_EXEC_PREFER_SIZE +#define DUK_USE_EXEC_REGCONST_OPTIMIZE +#undef DUK_USE_EXEC_TIMEOUT_CHECK +#undef DUK_USE_EXPLICIT_NULL_INIT +#undef DUK_USE_EXTSTR_FREE +#undef DUK_USE_EXTSTR_INTERN_CHECK +#undef DUK_USE_FASTINT +#define DUK_USE_FAST_REFCOUNT_DEFAULT +#undef DUK_USE_FATAL_HANDLER +#define DUK_USE_FATAL_MAXLEN 128 +#define DUK_USE_FINALIZER_SUPPORT +#undef DUK_USE_FINALIZER_TORTURE +#undef DUK_USE_FUNCPTR16 +#undef DUK_USE_FUNCPTR_DEC16 +#undef DUK_USE_FUNCPTR_ENC16 +#define DUK_USE_FUNCTION_BUILTIN +#define DUK_USE_FUNC_FILENAME_PROPERTY +#define DUK_USE_FUNC_NAME_PROPERTY +#undef DUK_USE_GC_TORTURE +#undef DUK_USE_GET_MONOTONIC_TIME +#undef DUK_USE_GET_RANDOM_DOUBLE +#undef DUK_USE_GLOBAL_BINDING +#define DUK_USE_GLOBAL_BUILTIN +#undef DUK_USE_HEAPPTR16 +#undef DUK_USE_HEAPPTR_DEC16 +#undef DUK_USE_HEAPPTR_ENC16 +#define DUK_USE_HEX_FASTPATH +#define DUK_USE_HOBJECT_ARRAY_ABANDON_LIMIT 2 +#define DUK_USE_HOBJECT_ARRAY_FAST_RESIZE_LIMIT 9 +#define DUK_USE_HOBJECT_ARRAY_MINGROW_ADD 16 +#define DUK_USE_HOBJECT_ARRAY_MINGROW_DIVISOR 8 +#define DUK_USE_HOBJECT_ENTRY_MINGROW_ADD 16 +#define DUK_USE_HOBJECT_ENTRY_MINGROW_DIVISOR 8 +#define DUK_USE_HOBJECT_HASH_PART +#define DUK_USE_HOBJECT_HASH_PROP_LIMIT 8 +#define DUK_USE_HSTRING_ARRIDX +#define DUK_USE_HSTRING_CLEN +#undef DUK_USE_HSTRING_EXTDATA +#define DUK_USE_HSTRING_LAZY_CLEN +#define DUK_USE_HTML_COMMENTS +#define DUK_USE_IDCHAR_FASTPATH +#undef DUK_USE_INJECT_HEAP_ALLOC_ERROR +#undef DUK_USE_INTERRUPT_COUNTER +#undef DUK_USE_INTERRUPT_DEBUG_FIXUP +#define DUK_USE_JC +#define DUK_USE_JSON_BUILTIN +#define DUK_USE_JSON_DECNUMBER_FASTPATH +#define DUK_USE_JSON_DECSTRING_FASTPATH +#define DUK_USE_JSON_DEC_RECLIMIT 1000 +#define DUK_USE_JSON_EATWHITE_FASTPATH +#define DUK_USE_JSON_ENC_RECLIMIT 1000 +#define DUK_USE_JSON_QUOTESTRING_FASTPATH +#undef DUK_USE_JSON_STRINGIFY_FASTPATH +#define DUK_USE_JSON_SUPPORT +#define DUK_USE_JX +#define DUK_USE_LEXER_SLIDING_WINDOW +#undef DUK_USE_LIGHTFUNC_BUILTINS +#define DUK_USE_MARK_AND_SWEEP_RECLIMIT 256 +#define DUK_USE_MATH_BUILTIN +#define DUK_USE_NATIVE_CALL_RECLIMIT 1000 +#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER +#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER +#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT +#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY +#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY +#define DUK_USE_NONSTD_FUNC_STMT +#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT +#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029 +#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT +#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT +#define DUK_USE_NUMBER_BUILTIN +#define DUK_USE_OBJECT_BUILTIN +#undef DUK_USE_OBJSIZES16 +#undef DUK_USE_PARANOID_ERRORS +#define DUK_USE_PC2LINE +#define DUK_USE_PERFORMANCE_BUILTIN +#undef DUK_USE_PREFER_SIZE +#undef DUK_USE_PROMISE_BUILTIN +#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS +#undef DUK_USE_REFCOUNT16 +#define DUK_USE_REFCOUNT32 +#define DUK_USE_REFERENCE_COUNTING +#define DUK_USE_REFLECT_BUILTIN +#define DUK_USE_REGEXP_CANON_BITMAP +#undef DUK_USE_REGEXP_CANON_WORKAROUND +#define DUK_USE_REGEXP_COMPILER_RECLIMIT 10000 +#define DUK_USE_REGEXP_EXECUTOR_RECLIMIT 10000 +#define DUK_USE_REGEXP_SUPPORT +#undef DUK_USE_ROM_GLOBAL_CLONE +#undef DUK_USE_ROM_GLOBAL_INHERIT +#undef DUK_USE_ROM_OBJECTS +#define DUK_USE_ROM_PTRCOMP_FIRST 63488L +#undef DUK_USE_ROM_STRINGS +#define DUK_USE_SECTION_B +#undef DUK_USE_SELF_TESTS +#define DUK_USE_SHEBANG_COMMENTS +#undef DUK_USE_SHUFFLE_TORTURE +#define DUK_USE_SOURCE_NONBMP +#undef DUK_USE_STRHASH16 +#undef DUK_USE_STRHASH_DENSE +#define DUK_USE_STRHASH_SKIP_SHIFT 5 +#define DUK_USE_STRICT_DECL +#undef DUK_USE_STRICT_UTF8_SOURCE +#define DUK_USE_STRING_BUILTIN +#undef DUK_USE_STRLEN16 +#define DUK_USE_STRTAB_GROW_LIMIT 17 +#define DUK_USE_STRTAB_MAXSIZE 268435456L +#define DUK_USE_STRTAB_MINSIZE 1024 +#undef DUK_USE_STRTAB_PTRCOMP +#define DUK_USE_STRTAB_RESIZE_CHECK_MASK 255 +#define DUK_USE_STRTAB_SHRINK_LIMIT 6 +#undef DUK_USE_STRTAB_TORTURE +#undef DUK_USE_SYMBOL_BUILTIN +#define DUK_USE_TAILCALL +#define DUK_USE_TARGET_INFO "unknown" +#define DUK_USE_TRACEBACKS +#define DUK_USE_TRACEBACK_DEPTH 10 +#define DUK_USE_USER_DECLARE() /* no user declarations */ +#define DUK_USE_VALSTACK_GROW_SHIFT 2 +#define DUK_USE_VALSTACK_LIMIT 1000000L +#define DUK_USE_VALSTACK_SHRINK_CHECK_SHIFT 2 +#define DUK_USE_VALSTACK_SHRINK_SLACK_SHIFT 4 +#undef DUK_USE_VALSTACK_UNSAFE +#define DUK_USE_VERBOSE_ERRORS +#define DUK_USE_VERBOSE_EXECUTOR_ERRORS +#define DUK_USE_VOLUNTARY_GC +#define DUK_USE_ZERO_BUFFER_DATA + +/* + * You may add overriding #define/#undef directives below for + * customization. You of course cannot un-#include or un-typedef + * anything; these require direct changes above. + */ + +/* __OVERRIDE_DEFINES__ */ + +/* + * Date provider selection + * + * User may define DUK_USE_DATE_GET_NOW() etc directly, in which case we'll + * rely on an external provider. If this is not done, revert to previous + * behavior and use Unix/Windows built-in provider. + */ + +#if defined(DUK_COMPILING_DUKTAPE) + +#if defined(DUK_USE_DATE_GET_NOW) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_NOW_GETTIMEOFDAY) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_gettimeofday() +#elif defined(DUK_USE_DATE_NOW_TIME) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_time() +#elif defined(DUK_USE_DATE_NOW_WINDOWS) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows() +#elif defined(DUK_USE_DATE_NOW_WINDOWS_SUBMS) +#define DUK_USE_DATE_GET_NOW(ctx) duk_bi_date_get_now_windows_subms() +#else +#error no provider for DUK_USE_DATE_GET_NOW() +#endif + +#if defined(DUK_USE_DATE_GET_LOCAL_TZOFFSET) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_TZO_GMTIME_R) || defined(DUK_USE_DATE_TZO_GMTIME_S) || defined(DUK_USE_DATE_TZO_GMTIME) +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_gmtime((d)) +#elif defined(DUK_USE_DATE_TZO_WINDOWS) +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows((d)) +#elif defined(DUK_USE_DATE_TZO_WINDOWS_NO_DST) +#define DUK_USE_DATE_GET_LOCAL_TZOFFSET(d) duk_bi_date_get_local_tzoffset_windows_no_dst((d)) +#else +#error no provider for DUK_USE_DATE_GET_LOCAL_TZOFFSET() +#endif + +#if defined(DUK_USE_DATE_PARSE_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_PRS_STRPTIME) +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_strptime((ctx), (str)) +#elif defined(DUK_USE_DATE_PRS_GETDATE) +#define DUK_USE_DATE_PARSE_STRING(ctx,str) duk_bi_date_parse_string_getdate((ctx), (str)) +#else +/* No provider for DUK_USE_DATE_PARSE_STRING(), fall back to ISO 8601 only. */ +#endif + +#if defined(DUK_USE_DATE_FORMAT_STRING) +/* External provider already defined. */ +#elif defined(DUK_USE_DATE_FMT_STRFTIME) +#define DUK_USE_DATE_FORMAT_STRING(ctx,parts,tzoffset,flags) \ + duk_bi_date_format_parts_strftime((ctx), (parts), (tzoffset), (flags)) +#else +/* No provider for DUK_USE_DATE_FORMAT_STRING(), fall back to ISO 8601 only. */ +#endif + +#if defined(DUK_USE_GET_MONOTONIC_TIME) +/* External provider already defined. */ +#elif defined(DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME) +#define DUK_USE_GET_MONOTONIC_TIME(ctx) duk_bi_date_get_monotonic_time_clock_gettime() +#elif defined(DUK_USE_GET_MONOTONIC_TIME_WINDOWS_QPC) +#define DUK_USE_GET_MONOTONIC_TIME(ctx) duk_bi_date_get_monotonic_time_windows_qpc() +#else +/* No provider for DUK_USE_GET_MONOTONIC_TIME(), fall back to DUK_USE_DATE_GET_NOW(). */ +#endif + +#endif /* DUK_COMPILING_DUKTAPE */ + +/* + * Checks for legacy feature options (DUK_OPT_xxx) + */ + +#if defined(DUK_OPT_ASSERTIONS) +#error unsupported legacy feature option DUK_OPT_ASSERTIONS used +#endif +#if defined(DUK_OPT_BUFFEROBJECT_SUPPORT) +#error unsupported legacy feature option DUK_OPT_BUFFEROBJECT_SUPPORT used +#endif +#if defined(DUK_OPT_BUFLEN16) +#error unsupported legacy feature option DUK_OPT_BUFLEN16 used +#endif +#if defined(DUK_OPT_DATAPTR16) +#error unsupported legacy feature option DUK_OPT_DATAPTR16 used +#endif +#if defined(DUK_OPT_DATAPTR_DEC16) +#error unsupported legacy feature option DUK_OPT_DATAPTR_DEC16 used +#endif +#if defined(DUK_OPT_DATAPTR_ENC16) +#error unsupported legacy feature option DUK_OPT_DATAPTR_ENC16 used +#endif +#if defined(DUK_OPT_DDDPRINT) +#error unsupported legacy feature option DUK_OPT_DDDPRINT used +#endif +#if defined(DUK_OPT_DDPRINT) +#error unsupported legacy feature option DUK_OPT_DDPRINT used +#endif +#if defined(DUK_OPT_DEBUG) +#error unsupported legacy feature option DUK_OPT_DEBUG used +#endif +#if defined(DUK_OPT_DEBUGGER_DUMPHEAP) +#error unsupported legacy feature option DUK_OPT_DEBUGGER_DUMPHEAP used +#endif +#if defined(DUK_OPT_DEBUGGER_FWD_LOGGING) +#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_LOGGING used +#endif +#if defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT) +#error unsupported legacy feature option DUK_OPT_DEBUGGER_FWD_PRINTALERT used +#endif +#if defined(DUK_OPT_DEBUGGER_SUPPORT) +#error unsupported legacy feature option DUK_OPT_DEBUGGER_SUPPORT used +#endif +#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE) +#error unsupported legacy feature option DUK_OPT_DEBUGGER_TRANSPORT_TORTURE used +#endif +#if defined(DUK_OPT_DEBUG_BUFSIZE) +#error unsupported legacy feature option DUK_OPT_DEBUG_BUFSIZE used +#endif +#if defined(DUK_OPT_DECLARE) +#error unsupported legacy feature option DUK_OPT_DECLARE used +#endif +#if defined(DUK_OPT_DEEP_C_STACK) +#error unsupported legacy feature option DUK_OPT_DEEP_C_STACK used +#endif +#if defined(DUK_OPT_DLL_BUILD) +#error unsupported legacy feature option DUK_OPT_DLL_BUILD used +#endif +#if defined(DUK_OPT_DPRINT) +#error unsupported legacy feature option DUK_OPT_DPRINT used +#endif +#if defined(DUK_OPT_DPRINT_COLORS) +#error unsupported legacy feature option DUK_OPT_DPRINT_COLORS used +#endif +#if defined(DUK_OPT_DPRINT_RDTSC) +#error unsupported legacy feature option DUK_OPT_DPRINT_RDTSC used +#endif +#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK) +#error unsupported legacy feature option DUK_OPT_EXEC_TIMEOUT_CHECK used +#endif +#if defined(DUK_OPT_EXTERNAL_STRINGS) +#error unsupported legacy feature option DUK_OPT_EXTERNAL_STRINGS used +#endif +#if defined(DUK_OPT_EXTSTR_FREE) +#error unsupported legacy feature option DUK_OPT_EXTSTR_FREE used +#endif +#if defined(DUK_OPT_EXTSTR_INTERN_CHECK) +#error unsupported legacy feature option DUK_OPT_EXTSTR_INTERN_CHECK used +#endif +#if defined(DUK_OPT_FASTINT) +#error unsupported legacy feature option DUK_OPT_FASTINT used +#endif +#if defined(DUK_OPT_FORCE_ALIGN) +#error unsupported legacy feature option DUK_OPT_FORCE_ALIGN used +#endif +#if defined(DUK_OPT_FORCE_BYTEORDER) +#error unsupported legacy feature option DUK_OPT_FORCE_BYTEORDER used +#endif +#if defined(DUK_OPT_FUNCPTR16) +#error unsupported legacy feature option DUK_OPT_FUNCPTR16 used +#endif +#if defined(DUK_OPT_FUNCPTR_DEC16) +#error unsupported legacy feature option DUK_OPT_FUNCPTR_DEC16 used +#endif +#if defined(DUK_OPT_FUNCPTR_ENC16) +#error unsupported legacy feature option DUK_OPT_FUNCPTR_ENC16 used +#endif +#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY) +#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY used +#endif +#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY) +#error unsupported legacy feature option DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY used +#endif +#if defined(DUK_OPT_GC_TORTURE) +#error unsupported legacy feature option DUK_OPT_GC_TORTURE used +#endif +#if defined(DUK_OPT_HAVE_CUSTOM_H) +#error unsupported legacy feature option DUK_OPT_HAVE_CUSTOM_H used +#endif +#if defined(DUK_OPT_HEAPPTR16) +#error unsupported legacy feature option DUK_OPT_HEAPPTR16 used +#endif +#if defined(DUK_OPT_HEAPPTR_DEC16) +#error unsupported legacy feature option DUK_OPT_HEAPPTR_DEC16 used +#endif +#if defined(DUK_OPT_HEAPPTR_ENC16) +#error unsupported legacy feature option DUK_OPT_HEAPPTR_ENC16 used +#endif +#if defined(DUK_OPT_INTERRUPT_COUNTER) +#error unsupported legacy feature option DUK_OPT_INTERRUPT_COUNTER used +#endif +#if defined(DUK_OPT_JSON_STRINGIFY_FASTPATH) +#error unsupported legacy feature option DUK_OPT_JSON_STRINGIFY_FASTPATH used +#endif +#if defined(DUK_OPT_LIGHTFUNC_BUILTINS) +#error unsupported legacy feature option DUK_OPT_LIGHTFUNC_BUILTINS used +#endif +#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY) +#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY used +#endif +#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY) +#error unsupported legacy feature option DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY used +#endif +#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT) +#error unsupported legacy feature option DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT used +#endif +#if defined(DUK_OPT_NO_AUGMENT_ERRORS) +#error unsupported legacy feature option DUK_OPT_NO_AUGMENT_ERRORS used +#endif +#if defined(DUK_OPT_NO_BROWSER_LIKE) +#error unsupported legacy feature option DUK_OPT_NO_BROWSER_LIKE used +#endif +#if defined(DUK_OPT_NO_BUFFEROBJECT_SUPPORT) +#error unsupported legacy feature option DUK_OPT_NO_BUFFEROBJECT_SUPPORT used +#endif +#if defined(DUK_OPT_NO_BYTECODE_DUMP_SUPPORT) +#error unsupported legacy feature option DUK_OPT_NO_BYTECODE_DUMP_SUPPORT used +#endif +#if defined(DUK_OPT_NO_COMMONJS_MODULES) +#error unsupported legacy feature option DUK_OPT_NO_COMMONJS_MODULES used +#endif +#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY) +#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY used +#endif +#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF) +#error unsupported legacy feature option DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF used +#endif +#if defined(DUK_OPT_NO_ES6_PROXY) +#error unsupported legacy feature option DUK_OPT_NO_ES6_PROXY used +#endif +#if defined(DUK_OPT_NO_FILE_IO) +#error unsupported legacy feature option DUK_OPT_NO_FILE_IO used +#endif +#if defined(DUK_OPT_NO_FUNC_STMT) +#error unsupported legacy feature option DUK_OPT_NO_FUNC_STMT used +#endif +#if defined(DUK_OPT_NO_JC) +#error unsupported legacy feature option DUK_OPT_NO_JC used +#endif +#if defined(DUK_OPT_NO_JSONC) +#error unsupported legacy feature option DUK_OPT_NO_JSONC used +#endif +#if defined(DUK_OPT_NO_JSONX) +#error unsupported legacy feature option DUK_OPT_NO_JSONX used +#endif +#if defined(DUK_OPT_NO_JX) +#error unsupported legacy feature option DUK_OPT_NO_JX used +#endif +#if defined(DUK_OPT_NO_MARK_AND_SWEEP) +#error unsupported legacy feature option DUK_OPT_NO_MARK_AND_SWEEP used +#endif +#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE) +#error unsupported legacy feature option DUK_OPT_NO_MS_STRINGTABLE_RESIZE used +#endif +#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT used +#endif +#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER used +#endif +#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER used +#endif +#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT used +#endif +#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_FUNC_STMT used +#endif +#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029 used +#endif +#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT) +#error unsupported legacy feature option DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT used +#endif +#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY) +#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY used +#endif +#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF) +#error unsupported legacy feature option DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF used +#endif +#if defined(DUK_OPT_NO_OCTAL_SUPPORT) +#error unsupported legacy feature option DUK_OPT_NO_OCTAL_SUPPORT used +#endif +#if defined(DUK_OPT_NO_PACKED_TVAL) +#error unsupported legacy feature option DUK_OPT_NO_PACKED_TVAL used +#endif +#if defined(DUK_OPT_NO_PC2LINE) +#error unsupported legacy feature option DUK_OPT_NO_PC2LINE used +#endif +#if defined(DUK_OPT_NO_REFERENCE_COUNTING) +#error unsupported legacy feature option DUK_OPT_NO_REFERENCE_COUNTING used +#endif +#if defined(DUK_OPT_NO_REGEXP_SUPPORT) +#error unsupported legacy feature option DUK_OPT_NO_REGEXP_SUPPORT used +#endif +#if defined(DUK_OPT_NO_SECTION_B) +#error unsupported legacy feature option DUK_OPT_NO_SECTION_B used +#endif +#if defined(DUK_OPT_NO_SOURCE_NONBMP) +#error unsupported legacy feature option DUK_OPT_NO_SOURCE_NONBMP used +#endif +#if defined(DUK_OPT_NO_STRICT_DECL) +#error unsupported legacy feature option DUK_OPT_NO_STRICT_DECL used +#endif +#if defined(DUK_OPT_NO_TRACEBACKS) +#error unsupported legacy feature option DUK_OPT_NO_TRACEBACKS used +#endif +#if defined(DUK_OPT_NO_VERBOSE_ERRORS) +#error unsupported legacy feature option DUK_OPT_NO_VERBOSE_ERRORS used +#endif +#if defined(DUK_OPT_NO_VOLUNTARY_GC) +#error unsupported legacy feature option DUK_OPT_NO_VOLUNTARY_GC used +#endif +#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA) +#error unsupported legacy feature option DUK_OPT_NO_ZERO_BUFFER_DATA used +#endif +#if defined(DUK_OPT_OBJSIZES16) +#error unsupported legacy feature option DUK_OPT_OBJSIZES16 used +#endif +#if defined(DUK_OPT_PANIC_HANDLER) +#error unsupported legacy feature option DUK_OPT_PANIC_HANDLER used +#endif +#if defined(DUK_OPT_REFCOUNT16) +#error unsupported legacy feature option DUK_OPT_REFCOUNT16 used +#endif +#if defined(DUK_OPT_SEGFAULT_ON_PANIC) +#error unsupported legacy feature option DUK_OPT_SEGFAULT_ON_PANIC used +#endif +#if defined(DUK_OPT_SELF_TESTS) +#error unsupported legacy feature option DUK_OPT_SELF_TESTS used +#endif +#if defined(DUK_OPT_SETJMP) +#error unsupported legacy feature option DUK_OPT_SETJMP used +#endif +#if defined(DUK_OPT_SHUFFLE_TORTURE) +#error unsupported legacy feature option DUK_OPT_SHUFFLE_TORTURE used +#endif +#if defined(DUK_OPT_SIGSETJMP) +#error unsupported legacy feature option DUK_OPT_SIGSETJMP used +#endif +#if defined(DUK_OPT_STRHASH16) +#error unsupported legacy feature option DUK_OPT_STRHASH16 used +#endif +#if defined(DUK_OPT_STRICT_UTF8_SOURCE) +#error unsupported legacy feature option DUK_OPT_STRICT_UTF8_SOURCE used +#endif +#if defined(DUK_OPT_STRLEN16) +#error unsupported legacy feature option DUK_OPT_STRLEN16 used +#endif +#if defined(DUK_OPT_STRTAB_CHAIN) +#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN used +#endif +#if defined(DUK_OPT_STRTAB_CHAIN_SIZE) +#error unsupported legacy feature option DUK_OPT_STRTAB_CHAIN_SIZE used +#endif +#if defined(DUK_OPT_TARGET_INFO) +#error unsupported legacy feature option DUK_OPT_TARGET_INFO used +#endif +#if defined(DUK_OPT_TRACEBACK_DEPTH) +#error unsupported legacy feature option DUK_OPT_TRACEBACK_DEPTH used +#endif +#if defined(DUK_OPT_UNDERSCORE_SETJMP) +#error unsupported legacy feature option DUK_OPT_UNDERSCORE_SETJMP used +#endif +#if defined(DUK_OPT_USER_INITJS) +#error unsupported legacy feature option DUK_OPT_USER_INITJS used +#endif + +/* + * Checks for config option consistency (DUK_USE_xxx) + */ + +#if defined(DUK_USE_32BIT_PTRS) +#error unsupported config option used (option has been removed): DUK_USE_32BIT_PTRS +#endif +#if defined(DUK_USE_ALIGN_4) +#error unsupported config option used (option has been removed): DUK_USE_ALIGN_4 +#endif +#if defined(DUK_USE_ALIGN_8) +#error unsupported config option used (option has been removed): DUK_USE_ALIGN_8 +#endif +#if defined(DUK_USE_BROWSER_LIKE) +#error unsupported config option used (option has been removed): DUK_USE_BROWSER_LIKE +#endif +#if defined(DUK_USE_BUILTIN_INITJS) +#error unsupported config option used (option has been removed): DUK_USE_BUILTIN_INITJS +#endif +#if defined(DUK_USE_BYTEORDER_FORCED) +#error unsupported config option used (option has been removed): DUK_USE_BYTEORDER_FORCED +#endif +#if defined(DUK_USE_DATAPTR_DEC16) && !defined(DUK_USE_DATAPTR16) +#error config option DUK_USE_DATAPTR_DEC16 requires option DUK_USE_DATAPTR16 (which is missing) +#endif +#if defined(DUK_USE_DATAPTR_ENC16) && !defined(DUK_USE_DATAPTR16) +#error config option DUK_USE_DATAPTR_ENC16 requires option DUK_USE_DATAPTR16 (which is missing) +#endif +#if defined(DUK_USE_DDDPRINT) +#error unsupported config option used (option has been removed): DUK_USE_DDDPRINT +#endif +#if defined(DUK_USE_DDPRINT) +#error unsupported config option used (option has been removed): DUK_USE_DDPRINT +#endif +#if defined(DUK_USE_DEBUGGER_FWD_LOGGING) +#error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_LOGGING +#endif +#if defined(DUK_USE_DEBUGGER_FWD_PRINTALERT) +#error unsupported config option used (option has been removed): DUK_USE_DEBUGGER_FWD_PRINTALERT +#endif +#if defined(DUK_USE_DEBUGGER_SUPPORT) && !defined(DUK_USE_INTERRUPT_COUNTER) +#error config option DUK_USE_DEBUGGER_SUPPORT requires option DUK_USE_INTERRUPT_COUNTER (which is missing) +#endif +#if defined(DUK_USE_DEEP_C_STACK) +#error unsupported config option used (option has been removed): DUK_USE_DEEP_C_STACK +#endif +#if defined(DUK_USE_DOUBLE_BE) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_BE +#endif +#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_LE) +#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_LE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_BE) && defined(DUK_USE_DOUBLE_ME) +#error config option DUK_USE_DOUBLE_BE conflicts with option DUK_USE_DOUBLE_ME (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_LE) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_LE +#endif +#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_BE) +#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_BE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_LE) && defined(DUK_USE_DOUBLE_ME) +#error config option DUK_USE_DOUBLE_LE conflicts with option DUK_USE_DOUBLE_ME (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_ME) +#error unsupported config option used (option has been removed): DUK_USE_DOUBLE_ME +#endif +#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_LE) +#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_LE (which is also defined) +#endif +#if defined(DUK_USE_DOUBLE_ME) && defined(DUK_USE_DOUBLE_BE) +#error config option DUK_USE_DOUBLE_ME conflicts with option DUK_USE_DOUBLE_BE (which is also defined) +#endif +#if defined(DUK_USE_DPRINT) +#error unsupported config option used (option has been removed): DUK_USE_DPRINT +#endif +#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG) +#error config option DUK_USE_DPRINT requires option DUK_USE_DEBUG (which is missing) +#endif +#if defined(DUK_USE_DPRINT_COLORS) +#error unsupported config option used (option has been removed): DUK_USE_DPRINT_COLORS +#endif +#if defined(DUK_USE_DPRINT_RDTSC) +#error unsupported config option used (option has been removed): DUK_USE_DPRINT_RDTSC +#endif +#if defined(DUK_USE_ES6_REGEXP_BRACES) +#error unsupported config option used (option has been removed): DUK_USE_ES6_REGEXP_BRACES +#endif +#if defined(DUK_USE_ESBC_MAX_BYTES) && !defined(DUK_USE_ESBC_LIMITS) +#error config option DUK_USE_ESBC_MAX_BYTES requires option DUK_USE_ESBC_LIMITS (which is missing) +#endif +#if defined(DUK_USE_ESBC_MAX_LINENUMBER) && !defined(DUK_USE_ESBC_LIMITS) +#error config option DUK_USE_ESBC_MAX_LINENUMBER requires option DUK_USE_ESBC_LIMITS (which is missing) +#endif +#if defined(DUK_USE_EXEC_TIMEOUT_CHECK) && !defined(DUK_USE_INTERRUPT_COUNTER) +#error config option DUK_USE_EXEC_TIMEOUT_CHECK requires option DUK_USE_INTERRUPT_COUNTER (which is missing) +#endif +#if defined(DUK_USE_EXTSTR_FREE) && !defined(DUK_USE_HSTRING_EXTDATA) +#error config option DUK_USE_EXTSTR_FREE requires option DUK_USE_HSTRING_EXTDATA (which is missing) +#endif +#if defined(DUK_USE_EXTSTR_INTERN_CHECK) && !defined(DUK_USE_HSTRING_EXTDATA) +#error config option DUK_USE_EXTSTR_INTERN_CHECK requires option DUK_USE_HSTRING_EXTDATA (which is missing) +#endif +#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_64BIT_OPS) +#error config option DUK_USE_FASTINT requires option DUK_USE_64BIT_OPS (which is missing) +#endif +#if defined(DUK_USE_FILE_IO) +#error unsupported config option used (option has been removed): DUK_USE_FILE_IO +#endif +#if defined(DUK_USE_FULL_TVAL) +#error unsupported config option used (option has been removed): DUK_USE_FULL_TVAL +#endif +#if defined(DUK_USE_FUNCPTR_DEC16) && !defined(DUK_USE_FUNCPTR16) +#error config option DUK_USE_FUNCPTR_DEC16 requires option DUK_USE_FUNCPTR16 (which is missing) +#endif +#if defined(DUK_USE_FUNCPTR_ENC16) && !defined(DUK_USE_FUNCPTR16) +#error config option DUK_USE_FUNCPTR_ENC16 requires option DUK_USE_FUNCPTR16 (which is missing) +#endif +#if defined(DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS) +#error unsupported config option used (option has been removed): DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS +#endif +#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG) +#error config option DUK_USE_HEAPPTR16 conflicts with option DUK_USE_DEBUG (which is also defined) +#endif +#if defined(DUK_USE_HEAPPTR_DEC16) && !defined(DUK_USE_HEAPPTR16) +#error config option DUK_USE_HEAPPTR_DEC16 requires option DUK_USE_HEAPPTR16 (which is missing) +#endif +#if defined(DUK_USE_HEAPPTR_ENC16) && !defined(DUK_USE_HEAPPTR16) +#error config option DUK_USE_HEAPPTR_ENC16 requires option DUK_USE_HEAPPTR16 (which is missing) +#endif +#if defined(DUK_USE_INTEGER_BE) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_BE +#endif +#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_LE) +#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_LE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_BE) && defined(DUK_USE_INTEGER_ME) +#error config option DUK_USE_INTEGER_BE conflicts with option DUK_USE_INTEGER_ME (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_LE) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_LE +#endif +#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_BE) +#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_BE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_LE) && defined(DUK_USE_INTEGER_ME) +#error config option DUK_USE_INTEGER_LE conflicts with option DUK_USE_INTEGER_ME (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_ME) +#error unsupported config option used (option has been removed): DUK_USE_INTEGER_ME +#endif +#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_LE) +#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_LE (which is also defined) +#endif +#if defined(DUK_USE_INTEGER_ME) && defined(DUK_USE_INTEGER_BE) +#error config option DUK_USE_INTEGER_ME conflicts with option DUK_USE_INTEGER_BE (which is also defined) +#endif +#if defined(DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE) +#error unsupported config option used (option has been removed): DUK_USE_MARKANDSWEEP_FINALIZER_TORTURE +#endif +#if defined(DUK_USE_MARK_AND_SWEEP) +#error unsupported config option used (option has been removed): DUK_USE_MARK_AND_SWEEP +#endif +#if defined(DUK_USE_MATH_FMAX) +#error unsupported config option used (option has been removed): DUK_USE_MATH_FMAX +#endif +#if defined(DUK_USE_MATH_FMIN) +#error unsupported config option used (option has been removed): DUK_USE_MATH_FMIN +#endif +#if defined(DUK_USE_MATH_ROUND) +#error unsupported config option used (option has been removed): DUK_USE_MATH_ROUND +#endif +#if defined(DUK_USE_MS_STRINGTABLE_RESIZE) +#error unsupported config option used (option has been removed): DUK_USE_MS_STRINGTABLE_RESIZE +#endif +#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE) +#error unsupported config option used (option has been removed): DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE +#endif +#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST) +#error unsupported config option used (option has been removed): DUK_USE_NO_DOUBLE_ALIASING_SELFTEST +#endif +#if defined(DUK_USE_OCTAL_SUPPORT) +#error unsupported config option used (option has been removed): DUK_USE_OCTAL_SUPPORT +#endif +#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) +#error unsupported config option used (option has been removed): DUK_USE_PACKED_TVAL_POSSIBLE +#endif +#if defined(DUK_USE_PANIC_ABORT) +#error unsupported config option used (option has been removed): DUK_USE_PANIC_ABORT +#endif +#if defined(DUK_USE_PANIC_EXIT) +#error unsupported config option used (option has been removed): DUK_USE_PANIC_EXIT +#endif +#if defined(DUK_USE_PANIC_HANDLER) +#error unsupported config option used (option has been removed): DUK_USE_PANIC_HANDLER +#endif +#if defined(DUK_USE_PANIC_SEGFAULT) +#error unsupported config option used (option has been removed): DUK_USE_PANIC_SEGFAULT +#endif +#if defined(DUK_USE_POW_NETBSD_WORKAROUND) +#error unsupported config option used (option has been removed): DUK_USE_POW_NETBSD_WORKAROUND +#endif +#if defined(DUK_USE_RDTSC) +#error unsupported config option used (option has been removed): DUK_USE_RDTSC +#endif +#if defined(DUK_USE_REFZERO_FINALIZER_TORTURE) +#error unsupported config option used (option has been removed): DUK_USE_REFZERO_FINALIZER_TORTURE +#endif +#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_STRINGS) +#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_STRINGS (which is missing) +#endif +#if defined(DUK_USE_ROM_GLOBAL_CLONE) && !defined(DUK_USE_ROM_OBJECTS) +#error config option DUK_USE_ROM_GLOBAL_CLONE requires option DUK_USE_ROM_OBJECTS (which is missing) +#endif +#if defined(DUK_USE_ROM_GLOBAL_CLONE) && defined(DUK_USE_ROM_GLOBAL_INHERIT) +#error config option DUK_USE_ROM_GLOBAL_CLONE conflicts with option DUK_USE_ROM_GLOBAL_INHERIT (which is also defined) +#endif +#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_STRINGS) +#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_STRINGS (which is missing) +#endif +#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && !defined(DUK_USE_ROM_OBJECTS) +#error config option DUK_USE_ROM_GLOBAL_INHERIT requires option DUK_USE_ROM_OBJECTS (which is missing) +#endif +#if defined(DUK_USE_ROM_GLOBAL_INHERIT) && defined(DUK_USE_ROM_GLOBAL_CLONE) +#error config option DUK_USE_ROM_GLOBAL_INHERIT conflicts with option DUK_USE_ROM_GLOBAL_CLONE (which is also defined) +#endif +#if defined(DUK_USE_ROM_OBJECTS) && !defined(DUK_USE_ROM_STRINGS) +#error config option DUK_USE_ROM_OBJECTS requires option DUK_USE_ROM_STRINGS (which is missing) +#endif +#if defined(DUK_USE_ROM_STRINGS) && !defined(DUK_USE_ROM_OBJECTS) +#error config option DUK_USE_ROM_STRINGS requires option DUK_USE_ROM_OBJECTS (which is missing) +#endif +#if defined(DUK_USE_SETJMP) +#error unsupported config option used (option has been removed): DUK_USE_SETJMP +#endif +#if defined(DUK_USE_SIGSETJMP) +#error unsupported config option used (option has been removed): DUK_USE_SIGSETJMP +#endif +#if defined(DUK_USE_STRTAB_CHAIN) +#error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN +#endif +#if defined(DUK_USE_STRTAB_CHAIN_SIZE) +#error unsupported config option used (option has been removed): DUK_USE_STRTAB_CHAIN_SIZE +#endif +#if defined(DUK_USE_STRTAB_CHAIN_SIZE) && !defined(DUK_USE_STRTAB_CHAIN) +#error config option DUK_USE_STRTAB_CHAIN_SIZE requires option DUK_USE_STRTAB_CHAIN (which is missing) +#endif +#if defined(DUK_USE_STRTAB_PROBE) +#error unsupported config option used (option has been removed): DUK_USE_STRTAB_PROBE +#endif +#if defined(DUK_USE_STRTAB_PTRCOMP) && !defined(DUK_USE_HEAPPTR16) +#error config option DUK_USE_STRTAB_PTRCOMP requires option DUK_USE_HEAPPTR16 (which is missing) +#endif +#if defined(DUK_USE_TAILCALL) && defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY) +#error config option DUK_USE_TAILCALL conflicts with option DUK_USE_NONSTD_FUNC_CALLER_PROPERTY (which is also defined) +#endif +#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) +#error unsupported config option used (option has been removed): DUK_USE_UNALIGNED_ACCESSES_POSSIBLE +#endif +#if defined(DUK_USE_UNDERSCORE_SETJMP) +#error unsupported config option used (option has been removed): DUK_USE_UNDERSCORE_SETJMP +#endif +#if defined(DUK_USE_USER_INITJS) +#error unsupported config option used (option has been removed): DUK_USE_USER_INITJS +#endif + +#if defined(DUK_USE_CPP_EXCEPTIONS) && !defined(__cplusplus) +#error DUK_USE_CPP_EXCEPTIONS enabled but not compiling with a C++ compiler +#endif + +/* + * Convert DUK_USE_BYTEORDER, from whatever source, into currently used + * internal defines. If detection failed, #error out. + */ + +#if defined(DUK_USE_BYTEORDER) +#if (DUK_USE_BYTEORDER == 1) +#define DUK_USE_INTEGER_LE +#define DUK_USE_DOUBLE_LE +#elif (DUK_USE_BYTEORDER == 2) +#define DUK_USE_INTEGER_LE /* integer endianness is little on purpose */ +#define DUK_USE_DOUBLE_ME +#elif (DUK_USE_BYTEORDER == 3) +#define DUK_USE_INTEGER_BE +#define DUK_USE_DOUBLE_BE +#else +#error unsupported: byte order invalid +#endif /* byte order */ +#else +#error unsupported: byte order detection failed +#endif /* defined(DUK_USE_BYTEORDER) */ + +#endif /* DUK_CONFIG_H_INCLUDED */ diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c new file mode 100755 index 0000000000..9a29903cfb --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.c @@ -0,0 +1,163 @@ +/* + * Minimal 'console' binding. + * + * https://github.com/DeveloperToolsWG/console-object/blob/master/api.md + * https://developers.google.com/web/tools/chrome-devtools/debug/console/console-reference + * https://developer.mozilla.org/en/docs/Web/API/console + */ + +#include +#include +#include "duktape.h" +#include "duk_console.h" + +/* XXX: Add some form of log level filtering. */ + +/* XXX: For now logs everything to stdout, V8/Node.js logs debug/info level + * to stdout, warn and above to stderr. Should this extra do the same? + */ + +/* XXX: Should all output be written via e.g. console.write(formattedMsg)? + * This would make it easier for user code to redirect all console output + * to a custom backend. + */ + +/* XXX: Init console object using duk_def_prop() when that call is available. */ + +static duk_ret_t duk__console_log_helper(duk_context *ctx, const char *error_name) { + duk_idx_t i, n; + duk_uint_t flags; + + flags = (duk_uint_t) duk_get_current_magic(ctx); + + n = duk_get_top(ctx); + + duk_get_global_string(ctx, "console"); + duk_get_prop_string(ctx, -1, "format"); + + for (i = 0; i < n; i++) { + if (duk_check_type_mask(ctx, i, DUK_TYPE_MASK_OBJECT)) { + /* Slow path formatting. */ + duk_dup(ctx, -1); /* console.format */ + duk_dup(ctx, i); + duk_call(ctx, 1); + duk_replace(ctx, i); /* arg[i] = console.format(arg[i]); */ + } + } + + duk_pop_2(ctx); + + duk_push_string(ctx, " "); + duk_insert(ctx, 0); + duk_join(ctx, n); + + if (error_name) { + duk_push_error_object(ctx, DUK_ERR_ERROR, "%s", duk_require_string(ctx, -1)); + duk_push_string(ctx, "name"); + duk_push_string(ctx, error_name); + duk_def_prop(ctx, -3, DUK_DEFPROP_FORCE | DUK_DEFPROP_HAVE_VALUE); /* to get e.g. 'Trace: 1 2 3' */ + duk_get_prop_string(ctx, -1, "stack"); + } + + fprintf(stdout, "%s\n", duk_to_string(ctx, -1)); + if (flags & DUK_CONSOLE_FLUSH) { + fflush(stdout); + } + return 0; +} + +static duk_ret_t duk__console_assert(duk_context *ctx) { + if (duk_to_boolean(ctx, 0)) { + return 0; + } + duk_remove(ctx, 0); + + return duk__console_log_helper(ctx, "AssertionError"); +} + +static duk_ret_t duk__console_log(duk_context *ctx) { + return duk__console_log_helper(ctx, NULL); +} + +static duk_ret_t duk__console_trace(duk_context *ctx) { + return duk__console_log_helper(ctx, "Trace"); +} + +static duk_ret_t duk__console_info(duk_context *ctx) { + return duk__console_log_helper(ctx, NULL); +} + +static duk_ret_t duk__console_warn(duk_context *ctx) { + return duk__console_log_helper(ctx, NULL); +} + +static duk_ret_t duk__console_error(duk_context *ctx) { + return duk__console_log_helper(ctx, "Error"); +} + +static duk_ret_t duk__console_dir(duk_context *ctx) { + /* For now, just share the formatting of .log() */ + return duk__console_log_helper(ctx, 0); +} + +static void duk__console_reg_vararg_func(duk_context *ctx, duk_c_function func, const char *name, duk_uint_t flags) { + duk_push_c_function(ctx, func, DUK_VARARGS); + duk_push_string(ctx, "name"); + duk_push_string(ctx, name); + duk_def_prop(ctx, -3, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE); /* Improve stacktraces by displaying function name */ + duk_set_magic(ctx, -1, (duk_int_t) flags); + duk_put_prop_string(ctx, -2, name); +} + +void duk_console_init(duk_context *ctx, duk_uint_t flags) { + duk_push_object(ctx); + + /* Custom function to format objects; user can replace. + * For now, try JX-formatting and if that fails, fall back + * to ToString(v). + */ + duk_eval_string(ctx, + "(function (E) {" + "return function format(v){" + "try{" + "return E('jx',v);" + "}catch(e){" + "return String(v);" /* String() allows symbols, ToString() internal algorithm doesn't. */ + "}" + "};" + "})(Duktape.enc)"); + duk_put_prop_string(ctx, -2, "format"); + + duk__console_reg_vararg_func(ctx, duk__console_assert, "assert", flags); + duk__console_reg_vararg_func(ctx, duk__console_log, "log", flags); + duk__console_reg_vararg_func(ctx, duk__console_log, "debug", flags); /* alias to console.log */ + duk__console_reg_vararg_func(ctx, duk__console_trace, "trace", flags); + duk__console_reg_vararg_func(ctx, duk__console_info, "info", flags); + duk__console_reg_vararg_func(ctx, duk__console_warn, "warn", flags); + duk__console_reg_vararg_func(ctx, duk__console_error, "error", flags); + duk__console_reg_vararg_func(ctx, duk__console_error, "exception", flags); /* alias to console.error */ + duk__console_reg_vararg_func(ctx, duk__console_dir, "dir", flags); + + duk_put_global_string(ctx, "console"); + + /* Proxy wrapping: ensures any undefined console method calls are + * ignored silently. This is required specifically by the + * DeveloperToolsWG proposal (and is implemented also by Firefox: + * https://bugzilla.mozilla.org/show_bug.cgi?id=629607). + */ + + if (flags & DUK_CONSOLE_PROXY_WRAPPER) { + /* Tolerate errors: Proxy may be disabled. */ + duk_peval_string_noresult(ctx, + "(function(){" + "var D=function(){};" + "console=new Proxy(console,{" + "get:function(t,k){" + "var v=t[k];" + "return typeof v==='function'?v:D;" + "}" + "});" + "})();" + ); + } +} diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h new file mode 100755 index 0000000000..1488a95fa6 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_console.h @@ -0,0 +1,14 @@ +#if !defined(DUK_CONSOLE_H_INCLUDED) +#define DUK_CONSOLE_H_INCLUDED + +#include "duktape.h" + +/* Use a proxy wrapper to make undefined methods (console.foo()) no-ops. */ +#define DUK_CONSOLE_PROXY_WRAPPER (1 << 0) + +/* Flush output after every call. */ +#define DUK_CONSOLE_FLUSH (1 << 1) + +extern void duk_console_init(duk_context *ctx, duk_uint_t flags); + +#endif /* DUK_CONSOLE_H_INCLUDED */ diff --git a/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c new file mode 100755 index 0000000000..9be2c1c273 --- /dev/null +++ b/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c @@ -0,0 +1,380 @@ +/* + * Logging support + */ + +#include +#include +#include +#include "duktape.h" +#include "duk_logging.h" + +/* XXX: uses stderr always for now, configurable? */ + +#define DUK_LOGGING_FLUSH /* Duktape 1.x: flush stderr */ + +/* 3-letter log level strings. */ +static const char duk__log_level_strings[] = { + 'T', 'R', 'C', 'D', 'B', 'G', 'I', 'N', 'F', + 'W', 'R', 'N', 'E', 'R', 'R', 'F', 'T', 'L' +}; + +/* Log method names. */ +static const char *duk__log_method_names[] = { + "trace", "debug", "info", "warn", "error", "fatal" +}; + +/* Constructor. */ +static duk_ret_t duk__logger_constructor(duk_context *ctx) { + duk_idx_t nargs; + + /* Calling as a non-constructor is not meaningful. */ + if (!duk_is_constructor_call(ctx)) { + return DUK_RET_TYPE_ERROR; + } + + nargs = duk_get_top(ctx); + duk_set_top(ctx, 1); + + duk_push_this(ctx); + + /* [ name this ] */ + + if (nargs == 0) { + /* Automatic defaulting of logger name from caller. This + * would work poorly with tail calls, but constructor calls + * are currently never tail calls, so tail calls are not an + * issue now. + */ + + duk_inspect_callstack_entry(ctx, -2); + if (duk_is_object(ctx, -1)) { + if (duk_get_prop_string(ctx, -1, "function")) { + if (duk_get_prop_string(ctx, -1, "fileName")) { + if (duk_is_string(ctx, -1)) { + duk_replace(ctx, 0); + } + } + } + } + /* Leave values on stack on purpose, ignored below. */ + + /* Stripping the filename might be a good idea + * ("/foo/bar/quux.js" -> logger name "quux"), + * but now used verbatim. + */ + } + /* The stack is unbalanced here on purpose; we only rely on the + * initial two values: [ name this ]. + */ + + if (duk_is_string(ctx, 0)) { + duk_dup(ctx, 0); + duk_put_prop_string(ctx, 1, "n"); + } else { + /* don't set 'n' at all, inherited value is used as name */ + } + + duk_compact(ctx, 1); + + return 0; /* keep default instance */ +} + +/* Default function to format objects. Tries to use toLogString() but falls + * back to toString(). Any errors are propagated out without catching. + */ +static duk_ret_t duk__logger_prototype_fmt(duk_context *ctx) { + if (duk_get_prop_string(ctx, 0, "toLogString")) { + /* [ arg toLogString ] */ + + duk_dup(ctx, 0); + duk_call_method(ctx, 0); + + /* [ arg result ] */ + return 1; + } + + /* [ arg undefined ] */ + duk_pop(ctx); + duk_to_string(ctx, 0); + return 1; +} + +/* Default function to write a formatted log line. Writes to stderr, + * appending a newline to the log line. + * + * The argument is a buffer; avoid coercing the buffer to a string to + * avoid string table traffic. + */ +static duk_ret_t duk__logger_prototype_raw(duk_context *ctx) { + const char *data; + duk_size_t data_len; + + data = (const char *) duk_require_buffer(ctx, 0, &data_len); + fwrite((const void *) data, 1, data_len, stderr); + fputc((int) '\n', stderr); +#if defined(DUK_LOGGING_FLUSH) + fflush(stderr); +#endif + return 0; +} + +/* Log frontend shared helper, magic value indicates log level. Provides + * frontend functions: trace(), debug(), info(), warn(), error(), fatal(). + * This needs to have small footprint, reasonable performance, minimal + * memory churn, etc. + */ +static duk_ret_t duk__logger_prototype_log_shared(duk_context *ctx) { + duk_double_t now; + duk_time_components comp; + duk_small_int_t entry_lev; + duk_small_int_t logger_lev; + duk_int_t nargs; + duk_int_t i; + duk_size_t tot_len; + const duk_uint8_t *arg_str; + duk_size_t arg_len; + duk_uint8_t *buf, *p; + const duk_uint8_t *q; + duk_uint8_t date_buf[32]; /* maximum format length is 24+1 (NUL), round up. */ + duk_size_t date_len; + duk_small_int_t rc; + + /* XXX: sanitize to printable (and maybe ASCII) */ + /* XXX: better multiline */ + + /* + * Logger arguments are: + * + * magic: log level (0-5) + * this: logger + * stack: plain log args + * + * We want to minimize memory churn so a two-pass approach + * is used: first pass formats arguments and computes final + * string length, second pass copies strings into a buffer + * allocated directly with the correct size. If the backend + * function plays nice, it won't coerce the buffer to a string + * (and thus intern it). + */ + + entry_lev = duk_get_current_magic(ctx); + if (entry_lev < DUK_LOG_TRACE || entry_lev > DUK_LOG_FATAL) { + /* Should never happen, check just in case. */ + return 0; + } + nargs = duk_get_top(ctx); + + /* [ arg1 ... argN this ] */ + + /* + * Log level check + */ + + duk_push_this(ctx); + + duk_get_prop_string(ctx, -1, "l"); + logger_lev = (duk_small_int_t) duk_get_int(ctx, -1); + if (entry_lev < logger_lev) { + return 0; + } + /* log level could be popped but that's not necessary */ + + now = duk_get_now(ctx); + duk_time_to_components(ctx, now, &comp); + sprintf((char *) date_buf, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", + (int) comp.year, (int) comp.month + 1, (int) comp.day, + (int) comp.hours, (int) comp.minutes, (int) comp.seconds, + (int) comp.milliseconds); + + date_len = strlen((const char *) date_buf); + + duk_get_prop_string(ctx, -2, "n"); + duk_to_string(ctx, -1); + + /* [ arg1 ... argN this loggerLevel loggerName ] */ + + /* + * Pass 1 + */ + + /* Line format: