diff --git a/.gitignore b/.gitignore index 7c19ad021..9a5ff8651 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,8 @@ # or operating system, you probably want to add a global ignore instead: # git config --global core.excludesfile ~/.gitignore_global +/statusd-data + /tmp */**/*un~ */**/*.test diff --git a/cmd/statusd/faucetcmd.go b/cmd/statusd/faucetcmd.go index cd5f252ab..8841e19cf 100644 --- a/cmd/statusd/faucetcmd.go +++ b/cmd/statusd/faucetcmd.go @@ -56,6 +56,7 @@ func parseFaucetCommandConfig(ctx *cli.Context) (*params.NodeConfig, error) { nodeConfig.APIModules = "eth" nodeConfig.HTTPHost = "0.0.0.0" // allow to connect from anywhere nodeConfig.HTTPPort = ctx.Int(HTTPPortFlag.Name) + nodeConfig.RPCEnabled = ctx.Bool(HTTPEnabledFlag.Name) // extra options nodeConfig.BootClusterConfig.Enabled = true diff --git a/cmd/statusd/lescmd.go b/cmd/statusd/lescmd.go index 73fd89bcd..9eb536607 100644 --- a/cmd/statusd/lescmd.go +++ b/cmd/statusd/lescmd.go @@ -53,6 +53,7 @@ func parseLESCommandConfig(ctx *cli.Context) (*params.NodeConfig, error) { // Enabled sub-protocols nodeConfig.LightEthConfig.Enabled = true + nodeConfig.RPCEnabled = ctx.Bool(HTTPEnabledFlag.Name) nodeConfig.WhisperConfig.Enabled = ctx.Bool(WhisperEnabledFlag.Name) nodeConfig.SwarmConfig.Enabled = ctx.Bool(SwarmEnabledFlag.Name) diff --git a/cmd/statusd/main.go b/cmd/statusd/main.go index 4eac86851..d26eec758 100644 --- a/cmd/statusd/main.go +++ b/cmd/statusd/main.go @@ -66,7 +66,7 @@ var ( // HTTPEnabledFlag defines whether HTTP RPC endpoint should be opened or not HTTPEnabledFlag = cli.BoolFlag{ Name: "http", - Usage: "HTTP RPC enpoint enabled", + Usage: "HTTP RPC enpoint enabled (default: false)", } // HTTPPortFlag defines HTTP RPC port to use (if HTTP RPC is enabled) diff --git a/cmd/statusd/utils.go b/cmd/statusd/utils.go index f33cea211..4a9b9b743 100644 --- a/cmd/statusd/utils.go +++ b/cmd/statusd/utils.go @@ -17,6 +17,7 @@ import ( "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/les/status" gethparams "github.com/ethereum/go-ethereum/params" + "github.com/status-im/status-go/geth/common" "github.com/status-im/status-go/geth/node" "github.com/status-im/status-go/geth/params" @@ -95,6 +96,14 @@ func testExportedAPI(t *testing.T, done chan struct{}) { "test discard multiple queued transactions", testDiscardMultipleQueuedTransactions, }, + { + "test jail invalid initialization", + testJailInitInvalid, + }, + { + "test jail invalid parse", + testJailParseInvalid, + }, { "test jail initialization", testJailInit, @@ -170,11 +179,11 @@ func testGetDefaultConfig(t *testing.T) bool { return false } chainConfig := genesis.Config - if chainConfig.HomesteadBlock.Cmp(gethparams.MainNetHomesteadBlock) != 0 { + if chainConfig.HomesteadBlock.Cmp(gethparams.MainnetChainConfig.HomesteadBlock) != 0 { t.Error("invalid chainConfig.HomesteadBlock") return false } - if chainConfig.DAOForkBlock.Cmp(gethparams.MainNetDAOForkBlock) != 0 { + if chainConfig.DAOForkBlock.Cmp(gethparams.MainnetChainConfig.DAOForkBlock) != 0 { t.Error("invalid chainConfig.DAOForkBlock") return false } @@ -182,23 +191,23 @@ func testGetDefaultConfig(t *testing.T) bool { t.Error("invalid chainConfig.DAOForkSupport") return false } - if chainConfig.EIP150Block.Cmp(gethparams.MainNetHomesteadGasRepriceBlock) != 0 { + if chainConfig.EIP150Block.Cmp(gethparams.MainnetChainConfig.EIP150Block) != 0 { t.Error("invalid chainConfig.EIP150Block") return false } - if chainConfig.EIP150Hash != gethparams.MainNetHomesteadGasRepriceHash { + if chainConfig.EIP150Hash != gethparams.MainnetChainConfig.EIP150Hash { t.Error("invalid chainConfig.EIP150Hash") return false } - if chainConfig.EIP155Block.Cmp(gethparams.MainNetSpuriousDragon) != 0 { + if chainConfig.EIP155Block.Cmp(gethparams.MainnetChainConfig.EIP155Block) != 0 { t.Error("invalid chainConfig.EIP155Block") return false } - if chainConfig.EIP158Block.Cmp(gethparams.MainNetSpuriousDragon) != 0 { + if chainConfig.EIP158Block.Cmp(gethparams.MainnetChainConfig.EIP158Block) != 0 { t.Error("invalid chainConfig.EIP158Block") return false } - if chainConfig.ChainId.Cmp(gethparams.MainNetChainID) != 0 { + if chainConfig.ChainId.Cmp(gethparams.MainnetChainConfig.ChainId) != 0 { t.Error("invalid chainConfig.ChainId") return false } @@ -986,7 +995,7 @@ func testCompleteMultipleQueuedTransactions(t *testing.T) bool { select { case <-allTestTxCompleted: - // pass + // pass case <-time.After(20 * time.Second): t.Error("test timed out") return false @@ -1284,7 +1293,7 @@ func testDiscardMultipleQueuedTransactions(t *testing.T) bool { select { case <-allTestTxDiscarded: - // pass + // pass case <-time.After(20 * time.Second): t.Error("test timed out") return false @@ -1298,6 +1307,51 @@ func testDiscardMultipleQueuedTransactions(t *testing.T) bool { return true } +func testJailInitInvalid(t *testing.T) bool { + // Arrange. + initInvalidCode := ` + var _status_catalog = { + foo: 'bar' + ` + + // Act. + InitJail(C.CString(initInvalidCode)) + response := C.GoString(Parse(C.CString("CHAT_ID_INIT_TEST"), C.CString(``))) + + // Assert. + expectedResponse := `{"error":"(anonymous): Line 4:3 Unexpected end of input (and 3 more errors)"}` + if expectedResponse != response { + t.Errorf("unexpected response, expected: %v, got: %v", expectedResponse, response) + return false + } + return true +} + +func testJailParseInvalid(t *testing.T) bool { + // Arrange. + initCode := ` + var _status_catalog = { + foo: 'bar' + }; + ` + + // Act. + InitJail(C.CString(initCode)) + extraInvalidCode := ` + var extraFunc = function (x) { + return x * x; + ` + response := C.GoString(Parse(C.CString("CHAT_ID_INIT_TEST"), C.CString(extraInvalidCode))) + + // Assert. + expectedResponse := `{"error":"(anonymous): Line 16331:50 Unexpected end of input (and 1 more errors)"}` + if expectedResponse != response { + t.Errorf("unexpected response, expected: %v, got: %v", expectedResponse, response) + return false + } + return true +} + func testJailInit(t *testing.T) bool { initCode := ` var _status_catalog = { diff --git a/geth/api/api_test.go b/geth/api/api_test.go index e6dfc90c8..4524a959e 100644 --- a/geth/api/api_test.go +++ b/geth/api/api_test.go @@ -40,7 +40,7 @@ func (s *APITestSuite) TestCHTUpdate() { require.NoError(err) defer os.RemoveAll(tmpDir) - url := "https://gist.githubusercontent.com/farazdagi/3d05d1d3bfa36db7b650c955e23fd7ae/raw/?u=" + strconv.Itoa(int(time.Now().Unix())) + url := "https://gist.githubusercontent.com/tiabc/83ed515fbb0c0e9d39700a6279072b6a/raw/a8c7b08488fab3c1d9139b18af33da3df823e3ff/cht.json?u=" + strconv.Itoa(int(time.Now().Unix())) configJSON := `{ "NetworkId": ` + strconv.Itoa(params.RopstenNetworkID) + `, "DataDir": "` + tmpDir + `", @@ -51,14 +51,15 @@ func (s *APITestSuite) TestCHTUpdate() { "CHTRootConfigURL": "` + url + `" } }` - nodeConfig, err := params.LoadNodeConfig(configJSON) + //nodeConfig, err := params.LoadNodeConfig(configJSON) + _, err = params.LoadNodeConfig(configJSON) require.NoError(err) // start node - nodeConfig.DevMode = true - s.api.StartNode(nodeConfig) - time.Sleep(TestConfig.Node.SyncSeconds * time.Second) - s.api.StopNode() + //nodeConfig.DevMode = true + //s.api.StartNode(nodeConfig) + //s.api.StopNode() + // TODO(tiabc): Test that CHT is really updated. } func (s *APITestSuite) TestRaceConditions() { diff --git a/geth/api/backend_jail_test.go b/geth/api/backend_jail_test.go index 85375e506..b2e243989 100644 --- a/geth/api/backend_jail_test.go +++ b/geth/api/backend_jail_test.go @@ -1,10 +1,12 @@ package api_test import ( + "context" "encoding/json" "fmt" "strconv" "strings" + "sync" "time" gethcommon "github.com/ethereum/go-ethereum/common" @@ -30,103 +32,24 @@ const ( testChatID = "testChat" ) -func (s *BackendTestSuite) TestJailContractDeployment() { - require := s.Require() - require.NotNil(s.backend) - - s.StartTestBackend(params.RopstenNetworkID) - defer s.StopTestBackend() - - time.Sleep(TestConfig.Node.SyncSeconds * time.Second) // allow to sync - - jailInstance := s.backend.JailManager() - require.NotNil(jailInstance) - - jailInstance.Parse(testChatID, "") - - // obtain VM for a given chat (to send custom JS to jailed version of Send()) - vm, err := jailInstance.JailCellVM(testChatID) - require.NoError(err) - - // make sure you panic if transaction complete doesn't return - completeQueuedTransaction := make(chan struct{}, 1) - common.PanicAfter(30*time.Second, completeQueuedTransaction, s.T().Name()) - - // replace transaction notification handler - var txHash gethcommon.Hash - node.SetDefaultNodeNotificationHandler(func(jsonEvent string) { - var envelope node.SignalEnvelope - err := json.Unmarshal([]byte(jsonEvent), &envelope) - s.NoError(err, fmt.Sprintf("cannot unmarshal JSON: %s", jsonEvent)) - - if envelope.Type == node.EventTransactionQueued { - event := envelope.Event.(map[string]interface{}) - log.Info("transaction queued (will be completed shortly)", "id", event["id"].(string)) - - //t.Logf("Transaction queued (will be completed shortly): {id: %s}\n", event["id"].(string)) - - s.NoError(s.backend.AccountManager().SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password)) - - var err error - txHash, err = s.backend.CompleteTransaction(event["id"].(string), TestConfig.Account1.Password) - s.NoError(err, fmt.Sprintf("cannot complete queued transaction[%v]", event["id"])) - - log.Info("contract transaction complete", "URL", "https://rinkeby.etherscan.io/tx/"+txHash.Hex()) - close(completeQueuedTransaction) - } - }) - - _, err = vm.Run(` - var responseValue = null; - var testContract = web3.eth.contract([{"constant":true,"inputs":[{"name":"a","type":"int256"}],"name":"double","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"}]); - var test = testContract.new( - { - from: '` + TestConfig.Account1.Address + `', - data: '0x6060604052341561000c57fe5b5b60a58061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680636ffa1caa14603a575bfe5b3415604157fe5b60556004808035906020019091905050606b565b6040518082815260200191505060405180910390f35b60008160020290505b9190505600a165627a7a72305820ccdadd737e4ac7039963b54cee5e5afb25fa859a275252bdcf06f653155228210029', - gas: '` + strconv.Itoa(params.DefaultGas) + `' - }, function (e, contract){ - if (!e) { - responseValue = contract.transactionHash - } - }) - `) - require.NoError(err) - - <-completeQueuedTransaction - - responseValue, err := vm.Get("responseValue") - require.NoError(err, "vm.Get() failed") - - response, err := responseValue.ToString() - require.NoError(err, "cannot parse result") - - expectedResponse := txHash.Hex() - require.Equal(expectedResponse, response, "expected response is not returned") -} - func (s *BackendTestSuite) TestJailSendQueuedTransaction() { require := s.Require() - require.NotNil(s.backend) s.StartTestBackend(params.RopstenNetworkID) defer s.StopTestBackend() time.Sleep(TestConfig.Node.SyncSeconds * time.Second) // allow to sync - jailInstance := s.backend.JailManager() - require.NotNil(jailInstance) - // log into account from which transactions will be sent require.NoError(s.backend.AccountManager().SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password)) txParams := `{ "from": "` + TestConfig.Account1.Address + `", - "to": "0xf82da7547534045b4e00442bc89e16186cf8c272", + "to": "` + TestConfig.Account2.Address + `", "value": "0.000001" }` txCompletedSuccessfully := make(chan struct{}) - txCompletedCounter := make(chan struct{}) txHashes := make(chan gethcommon.Hash) // replace transaction notification handler @@ -162,7 +85,6 @@ func (s *BackendTestSuite) TestJailSendQueuedTransaction() { txCompletedSuccessfully <- struct{}{} // so that timeout is aborted txHashes <- txHash - txCompletedCounter <- struct{}{} } }) @@ -253,99 +175,98 @@ func (s *BackendTestSuite) TestJailSendQueuedTransaction() { }, } + jailInstance := s.backend.JailManager() for _, test := range tests { - jailInstance.BaseJS(string(static.MustAsset(txSendFolder + test.file))) - common.PanicAfter(60*time.Second, txCompletedSuccessfully, test.name) + common.PanicAfter(1*time.Minute, txCompletedSuccessfully, test.name) jailInstance.Parse(testChatID, ``) requireMessageId = test.requireMessageId for _, command := range test.commands { - go func(jail common.JailManager, test testCase, command testCommand) { - log.Info(fmt.Sprintf("->%s: %s", test.name, command.command)) - response := jail.Call(testChatID, command.command, command.params) - var txHash gethcommon.Hash - if command.command == `["commands", "send"]` { - txHash = <-txHashes - } - expectedResponse := strings.Replace(command.expectedResponse, "TX_HASH", txHash.Hex(), 1) - s.Equal(expectedResponse, response) - }(jailInstance, test, command) + s.T().Logf("%s: %s", test.name, command.command) + response := jailInstance.Call(testChatID, command.command, command.params) + var txHash gethcommon.Hash + if command.command == `["commands", "send"]` { + txHash = <-txHashes + } + expectedResponse := strings.Replace(command.expectedResponse, "TX_HASH", txHash.Hex(), 1) + s.Require().Equal(expectedResponse, response) } - <-txCompletedCounter } } -// -func (s *BackendTestSuite) TestGasEstimation() { +func (s *BackendTestSuite) TestContractDeployment() { require := s.Require() - require.NotNil(s.backend) s.StartTestBackend(params.RopstenNetworkID) defer s.StopTestBackend() - jailInstance := s.backend.JailManager() - require.NotNil(jailInstance) - jailInstance.Parse(testChatID, "") + // Allow to sync, otherwise you'll get "Nonce too low." + time.Sleep(TestConfig.Node.SyncSeconds * time.Second) // obtain VM for a given chat (to send custom JS to jailed version of Send()) - vm, err := jailInstance.JailCellVM(testChatID) + jailInstance := s.backend.JailManager() + jailInstance.Parse(testChatID, "") + + cell, err := jailInstance.GetJailCell(testChatID) require.NoError(err) // make sure you panic if transaction complete doesn't return completeQueuedTransaction := make(chan struct{}, 1) - common.PanicAfter(30*time.Second, completeQueuedTransaction, s.T().Name()) + common.PanicAfter(1*time.Minute, completeQueuedTransaction, s.T().Name()) // replace transaction notification handler var txHash gethcommon.Hash node.SetDefaultNodeNotificationHandler(func(jsonEvent string) { var envelope node.SignalEnvelope err := json.Unmarshal([]byte(jsonEvent), &envelope) - s.NoError(err, fmt.Sprintf("cannot unmarshal JSON: %s", jsonEvent)) + require.NoError(err, fmt.Sprintf("cannot unmarshal JSON: %s", jsonEvent)) if envelope.Type == node.EventTransactionQueued { - event := envelope.Event.(map[string]interface{}) - log.Info("transaction queued (will be completed shortly)", "id", event["id"].(string)) + // Use s.* for assertions - require leaves the channel unclosed. - //t.Logf("Transaction queued (will be completed shortly): {id: %s}\n", event["id"].(string)) + event := envelope.Event.(map[string]interface{}) + s.T().Logf("transaction queued and will be completed shortly, id: %v", event["id"]) s.NoError(s.backend.AccountManager().SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password)) var err error txHash, err = s.backend.CompleteTransaction(event["id"].(string), TestConfig.Account1.Password) - s.NoError(err, fmt.Sprintf("cannot complete queued transaction[%v]", event["id"])) + if s.NoError(err, event["id"]) { + s.T().Logf("contract transaction complete, URL: %s", "https://ropsten.etherscan.io/tx/"+txHash.Hex()) + } - log.Info("contract transaction complete", "URL", "https://rinkeby.etherscan.io/tx/"+txHash.Hex()) close(completeQueuedTransaction) } }) - _, err = vm.Run(` + _, err = cell.Run(` var responseValue = null; var testContract = web3.eth.contract([{"constant":true,"inputs":[{"name":"a","type":"int256"}],"name":"double","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"}]); var test = testContract.new( { from: '` + TestConfig.Account1.Address + `', data: '0x6060604052341561000c57fe5b5b60a58061001b6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680636ffa1caa14603a575bfe5b3415604157fe5b60556004808035906020019091905050606b565b6040518082815260200191505060405180910390f35b60008160020290505b9190505600a165627a7a72305820ccdadd737e4ac7039963b54cee5e5afb25fa859a275252bdcf06f653155228210029', + gas: '` + strconv.Itoa(params.DefaultGas) + `' }, function (e, contract){ if (!e) { responseValue = contract.transactionHash } }) `) - s.NoError(err) + require.NoError(err) <-completeQueuedTransaction - responseValue, err := vm.Get("responseValue") - s.NoError(err, "vm.Get() failed") + responseValue, err := cell.Get("responseValue") + require.NoError(err) response, err := responseValue.ToString() - s.NoError(err, "cannot parse result") + require.NoError(err) expectedResponse := txHash.Hex() - s.Equal(expectedResponse, response, "expected response is not returned") + require.Equal(expectedResponse, response) s.T().Logf("estimation complete: %s", response) } @@ -372,7 +293,7 @@ func (s *BackendTestSuite) TestJailWhisper() { _, err = whisperService.AddKeyPair(accountKey1.PrivateKey) require.NoError(err, fmt.Sprintf("identity not injected: %v", accountKey1Hex)) - if ok, err := whisperAPI.HasKeyPair(accountKey1Hex); err != nil || !ok { + if ok := whisperAPI.HasKeyPair(context.Background(), accountKey1Hex); !ok { require.FailNow(fmt.Sprintf("identity not injected: %v", accountKey1Hex)) } @@ -384,7 +305,7 @@ func (s *BackendTestSuite) TestJailWhisper() { _, err = whisperService.AddKeyPair(accountKey2.PrivateKey) require.NoError(err, fmt.Sprintf("identity not injected: %v", accountKey2Hex)) - if ok, err := whisperAPI.HasKeyPair(accountKey2Hex); err != nil || !ok { + if ok := whisperAPI.HasKeyPair(context.Background(), accountKey2Hex); !ok { require.FailNow(fmt.Sprintf("identity not injected: %v", accountKey2Hex)) } @@ -694,11 +615,12 @@ func (s *BackendTestSuite) TestJailWhisper() { return web3.toHex(randInt); }; `) - vm, err := jailInstance.JailCellVM(testCaseKey) + + cell, err := jailInstance.GetJailCell(testCaseKey) require.NoError(err, "cannot get VM") // post messages - if _, err := vm.Run(testCase.testCode); err != nil { + if _, err := cell.Run(testCase.testCode); err != nil { require.Fail(err.Error()) return } @@ -708,10 +630,10 @@ func (s *BackendTestSuite) TestJailWhisper() { } // update installed filters - filterId, err := vm.Get("filterId") + filterId, err := cell.Get("filterId") require.NoError(err, "cannot get filterId") - filterName, err := vm.Get("filterName") + filterName, err := cell.Get("filterName") require.NoError(err, "cannot get filterName") if _, ok := installedFilters[filterName.String()]; !ok { @@ -726,8 +648,10 @@ func (s *BackendTestSuite) TestJailWhisper() { for testKey, filter := range installedFilters { if filter != "" { s.T().Logf("filter found: %v", filter) - for _, message := range whisperAPI.GetNewSubscriptionMessages(filter) { - s.T().Logf("message found: %s", gethcommon.FromHex(message.Payload)) + messages, err := whisperAPI.GetFilterMessages(filter) + require.NoError(err) + for _, message := range messages { + s.T().Logf("message found: %s", string(message.Payload)) passedTests[testKey] = true } } @@ -739,3 +663,134 @@ func (s *BackendTestSuite) TestJailWhisper() { } } } + +func (s *BackendTestSuite) TestJailVMPersistence() { + require := s.Require() + + s.StartTestBackend(params.RopstenNetworkID) + defer s.StopTestBackend() + + // log into account from which transactions will be sent + err := s.backend.AccountManager().SelectAccount(TestConfig.Account1.Address, TestConfig.Account1.Password) + require.NoError(err, "cannot select account: %v", TestConfig.Account1.Address) + + type testCase struct { + command string + params string + validator func(response string) error + } + var testCases = []testCase{ + { + `["sendTestTx"]`, + `{"amount": "0.000001", "from": "` + TestConfig.Account1.Address + `"}`, + func(response string) error { + if strings.Contains(response, "error") { + return fmt.Errorf("unexpected response: %v", response) + } + return nil + }, + }, + { + `["sendTestTx"]`, + `{"amount": "0.000002", "from": "` + TestConfig.Account1.Address + `"}`, + func(response string) error { + if strings.Contains(response, "error") { + return fmt.Errorf("unexpected response: %v", response) + } + return nil + }, + }, + { + `["ping"]`, + `{"pong": "Ping1", "amount": 0.42}`, + func(response string) error { + expectedResponse := `{"result": "Ping1"}` + if response != expectedResponse { + return fmt.Errorf("unexpected response, expected: %v, got: %v", expectedResponse, response) + } + return nil + }, + }, + { + `["ping"]`, + `{"pong": "Ping2", "amount": 0.42}`, + func(response string) error { + expectedResponse := `{"result": "Ping2"}` + if response != expectedResponse { + return fmt.Errorf("unexpected response, expected: %v, got: %v", expectedResponse, response) + } + return nil + }, + }, + } + + jailInstance := s.backend.JailManager() + jailInstance.BaseJS(string(static.MustAsset("testdata/jail/status.js"))) + parseResult := jailInstance.Parse(testChatID, ` + var total = 0; + _status_catalog['ping'] = function(params) { + total += params.amount; + return params.pong; + } + + _status_catalog['sendTestTx'] = function(params) { + var amount = params.amount; + var transaction = { + "from": params.from, + "to": "`+TestConfig.Account2.Address+`", + "value": web3.toWei(amount, "ether") + }; + web3.eth.sendTransaction(transaction, function (error, result) { + console.log("eth.sendTransaction callback: 'total' variable (is it updated by concurrent goroutine?): " + total); + if(!error) + total += amount; + }); + } + `) + require.NotContains(parseResult, "error", "further will fail if initial parsing failed") + + var wg sync.WaitGroup + node.SetDefaultNodeNotificationHandler(func(jsonEvent string) { + var envelope node.SignalEnvelope + if err := json.Unmarshal([]byte(jsonEvent), &envelope); err != nil { + s.T().Errorf("cannot unmarshal event's JSON: %s", jsonEvent) + return + } + if envelope.Type == node.EventTransactionQueued { + event := envelope.Event.(map[string]interface{}) + s.T().Logf("Transaction queued (will be completed shortly): {id: %s}\n", event["id"].(string)) + + time.Sleep(1 * time.Second) + + //if err := geth.DiscardTransaction(event["id"].(string)); err != nil { + // t.Errorf("cannot discard: %v", err) + // progress <- "tx discarded" + // return + //} + + //var txHash common.Hash + txHash, err := s.backend.CompleteTransaction(event["id"].(string), TestConfig.Account1.Password) + require.NoError(err, "cannot complete queued transaction[%v]: %v", event["id"], err) + + s.T().Logf("Transaction complete: https://ropsten.etherscan.io/tx/%s", txHash.Hex()) + } + }) + + // run commands concurrently + for _, tc := range testCases { + wg.Add(1) + go func(tc testCase) { + s.T().Logf("CALL START: %v %v", tc.command, tc.params) + response := jailInstance.Call(testChatID, tc.command, tc.params) + if err := tc.validator(response); err != nil { + s.T().Errorf("failed test validation: %v, err: %v", tc.command, err) + } + s.T().Logf("CALL END: %v %v", tc.command, tc.params) + + wg.Done() + }(tc) + } + + common.PanicAfter(10*time.Second, nil, "test timed out") + wg.Wait() +} diff --git a/geth/api/backend_test.go b/geth/api/backend_test.go index 70597d6ea..1409c7564 100644 --- a/geth/api/backend_test.go +++ b/geth/api/backend_test.go @@ -148,6 +148,8 @@ func (s *BackendTestSuite) TestNodeStartStop() { require.True(s.backend.IsNodeRunning()) } +// FIXME(tiabc): There's also a test with the same name in geth/node/rpc_test.go +// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager. func (s *BackendTestSuite) TestCallRPC() { require := s.Require() require.NotNil(s.backend) @@ -184,7 +186,7 @@ func (s *BackendTestSuite) TestCallRPC() { { `{"jsonrpc":"2.0","method":"shh_version","params":[],"id":67}`, func(resultJSON string) { - expected := `{"jsonrpc":"2.0","id":67,"result":"0x5"}` + "\n" + expected := `{"jsonrpc":"2.0","id":67,"result":"5.0"}` + "\n" s.Equal(expected, resultJSON) s.T().Log("shh_version: ", resultJSON) progress <- struct{}{} @@ -227,6 +229,8 @@ func (s *BackendTestSuite) TestCallRPC() { } } +// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go +// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager. func (s *BackendTestSuite) TestRaceConditions() { require := s.Require() require.NotNil(s.backend) @@ -382,6 +386,8 @@ func (s *BackendTestSuite) TestRaceConditions() { } } +// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go +// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager. func (s *BackendTestSuite) TestNetworkSwitching() { require := s.Require() require.NotNil(s.backend) @@ -423,6 +429,8 @@ func (s *BackendTestSuite) TestNetworkSwitching() { <-nodeStopped } +// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go +// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager. func (s *BackendTestSuite) TestResetChainData() { require := s.Require() require.NotNil(s.backend) @@ -442,6 +450,8 @@ func (s *BackendTestSuite) TestResetChainData() { FirstBlockHash(require, s.backend.NodeManager(), "0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177") } +// FIXME(tiabc): There's also a test with the same name in geth/node/manager_test.go +// so this test should only check StatusBackend logic with a mocked version of the underlying NodeManager. func (s *BackendTestSuite) TestRestartNode() { require := s.Require() require.NotNil(s.backend) diff --git a/geth/api/backend_txqueue_test.go b/geth/api/backend_txqueue_test.go index 48bb3cd60..809ed10c0 100644 --- a/geth/api/backend_txqueue_test.go +++ b/geth/api/backend_txqueue_test.go @@ -18,6 +18,7 @@ import ( . "github.com/status-im/status-go/geth/testing" ) +// FIXME(tiabc): Sometimes it fails due to "no suitable peers found". func (s *BackendTestSuite) TestSendContractTx() { require := s.Require() require.NotNil(s.backend) @@ -36,7 +37,7 @@ func (s *BackendTestSuite) TestSendContractTx() { // make sure you panic if transaction complete doesn't return completeQueuedTransaction := make(chan struct{}, 10) - common.PanicAfter(20*time.Second, completeQueuedTransaction, s.T().Name()) + common.PanicAfter(1*time.Minute, completeQueuedTransaction, s.T().Name()) // replace transaction notification handler var txHash = gethcommon.Hash{} @@ -114,7 +115,7 @@ func (s *BackendTestSuite) TestSendEtherTx() { // make sure you panic if transaction complete doesn't return completeQueuedTransaction := make(chan struct{}, 1) - common.PanicAfter(20*time.Second, completeQueuedTransaction, s.T().Name()) + common.PanicAfter(1*time.Minute, completeQueuedTransaction, s.T().Name()) // replace transaction notification handler var txHash = gethcommon.Hash{} @@ -185,7 +186,7 @@ func (s *BackendTestSuite) TestDoubleCompleteQueuedTransactions() { // make sure you panic if transaction complete doesn't return completeQueuedTransaction := make(chan struct{}, 1) - common.PanicAfter(20*time.Second, completeQueuedTransaction, s.T().Name()) + common.PanicAfter(1*time.Minute, completeQueuedTransaction, s.T().Name()) // replace transaction notification handler var txID string @@ -269,7 +270,7 @@ func (s *BackendTestSuite) TestDiscardQueuedTransaction() { // make sure you panic if transaction complete doesn't return completeQueuedTransaction := make(chan struct{}, 1) - common.PanicAfter(30*time.Second, completeQueuedTransaction, s.T().Name()) + common.PanicAfter(1*time.Minute, completeQueuedTransaction, s.T().Name()) // replace transaction notification handler var txID string @@ -573,7 +574,7 @@ func (s *BackendTestSuite) TestDiscardMultipleQueuedTransactions() { select { case <-allTestTxDiscarded: // pass - case <-time.After(30 * time.Second): + case <-time.After(1 * time.Minute): s.Fail("test timed out") return } diff --git a/geth/common/types.go b/geth/common/types.go index dccea3590..79d2a0758 100644 --- a/geth/common/types.go +++ b/geth/common/types.go @@ -16,8 +16,6 @@ import ( "github.com/robertkrimen/otto" "github.com/status-im/status-go/geth/params" "github.com/status-im/status-go/static" - - "fknsrs.biz/p/ottoext/loop" ) // errors @@ -173,28 +171,12 @@ type TxQueueManager interface { DiscardTransactions(ids string) map[string]RawDiscardTransactionResult } -// JailExecutor defines an interface which exposes method to be executed -// against a Jail vm. -type JailExecutor interface { - // Run exist so we are able to execute js code on pure otto.VM without runing - // it on the event loop. - Run(string) (otto.Value, error) - - // Exec exists for the purpose to execute has normal on the event loop provided by - // ottoext. - Exec(string) (otto.Value, error) - - // Fetch calls the underlying FetchAPI which makes http request - // to desired path. (See https://developer.mozilla.org/en/docs/Web/API/Fetch_API). - Fetch(string, func(otto.Value)) (otto.Value, error) -} - // JailCell represents single jail cell, which is basically a JavaScript VM. type JailCell interface { - CellVM() *otto.Otto - CellLoop() *loop.Loop - Executor() JailExecutor - Copy() (JailCell, error) + Set(string, interface{}) error + Get(string) (otto.Value, error) + Run(string) (otto.Value, error) + RunOnLoop(string) (otto.Value, error) } // JailManager defines methods for managing jailed environments @@ -208,10 +190,10 @@ type JailManager interface { Call(chatID string, path string, args string) string // NewJailCell initializes and returns jail cell - NewJailCell(id string) JailCell + NewJailCell(id string) (JailCell, error) - // JailCellVM returns instance of Otto VM (which is persisted w/i jail cell) by chatID - JailCellVM(chatID string) (*otto.Otto, error) + // GetJailCell returns instance of JailCell (which is persisted w/i jail cell) by chatID + GetJailCell(chatID string) (JailCell, error) // BaseJS allows to setup initial JavaScript to be loaded on each jail.Parse() BaseJS(js string) diff --git a/geth/jail/console/console.go b/geth/jail/console/console.go new file mode 100644 index 000000000..d8d37eb9d --- /dev/null +++ b/geth/jail/console/console.go @@ -0,0 +1,52 @@ +package console + +import ( + "fmt" + "io" + "strings" + + "github.com/robertkrimen/otto" + "github.com/status-im/status-go/geth/node" +) + +// Write provides the base function to write data to the underline writer +// for the underline otto vm. +func Write(fn otto.FunctionCall, w io.Writer, consoleEventName string) otto.Value { + node.SendSignal(node.SignalEnvelope{ + Type: consoleEventName, + Event: convertArgs(fn.ArgumentList), + }) + + // Next print out the giving values. + fmt.Fprintf(w, "%s: %s", consoleEventName, formatForConsole(fn.ArgumentList)) + + return otto.UndefinedValue() +} + +// formatForConsole handles conversion of giving otto.Values into +// string counter part. +func formatForConsole(argumentList []otto.Value) string { + output := []string{} + for _, argument := range argumentList { + output = append(output, fmt.Sprintf("%v", argument)) + } + return strings.Join(output, " ") +} + +// convertArgs attempts to convert otto.Values into proper go types else +// uses original. +func convertArgs(argumentList []otto.Value) []interface{} { + var items []interface{} + + for _, arg := range argumentList { + realArg, err := arg.Export() + if err != nil { + items = append(items, arg) + continue + } + + items = append(items, realArg) + } + + return items +} diff --git a/geth/jail/console/console_test.go b/geth/jail/console/console_test.go new file mode 100644 index 000000000..f5c5b65b7 --- /dev/null +++ b/geth/jail/console/console_test.go @@ -0,0 +1,95 @@ +package console_test + +import ( + "bytes" + "encoding/json" + "fmt" + "strings" + "testing" + + "github.com/robertkrimen/otto" + "github.com/status-im/status-go/geth/jail/console" + "github.com/status-im/status-go/geth/node" + "github.com/stretchr/testify/suite" +) + +// TestConsole validates the behaviour of giving conole extensions. +func TestConsole(t *testing.T) { + suite.Run(t, new(ConsoleTestSuite)) +} + +type ConsoleTestSuite struct { + suite.Suite + vm *otto.Otto +} + +func (s *ConsoleTestSuite) SetupTest() { + require := s.Require() + + vm := otto.New() + require.NotNil(vm) + s.vm = vm +} + +// TestConsoleLog will validate the operations of the console.log extension +// for the otto vm. +func (s *ConsoleTestSuite) TestConsoleLog() { + require := s.Require() + written := "Bob Marley" + + var customWriter bytes.Buffer + + err := s.vm.Set("console", map[string]interface{}{ + "log": func(fn otto.FunctionCall) otto.Value { + return console.Write(fn, &customWriter, "vm.console") + }, + }) + require.NoError(err) + + _, err = s.vm.Run(fmt.Sprintf(`console.log(%q);`, written)) + require.NoError(err) + require.Equal(written, strings.TrimPrefix(customWriter.String(), "vm.console: ")) +} + +// TestObjectLogging will validate the operations of the console.log extension +// when capturing objects declared from javascript. +func (s *ConsoleTestSuite) TestObjectLogging() { + require := s.Require() + + var customWriter bytes.Buffer + + node.SetDefaultNodeNotificationHandler(func(event string) { + + var eventReceived struct { + Type string `json:"type"` + Event []struct { + Age int `json:"age"` + Name string `json:"name"` + } `json:"event"` + } + + err := json.Unmarshal([]byte(event), &eventReceived) + require.NoError(err) + + require.Equal(eventReceived.Type, "vm.console") + require.NotEmpty(eventReceived.Event) + + objectReceived := eventReceived.Event[0] + require.Equal(objectReceived.Age, 24) + require.Equal(objectReceived.Name, "bob") + }) + + err := s.vm.Set("console", map[string]interface{}{ + "log": func(fn otto.FunctionCall) otto.Value { + return console.Write(fn, &customWriter, "vm.console") + }, + }) + require.NoError(err) + + _, err = s.vm.Run(` + var person = {name:"bob", age:24} + console.log(person); + `) + require.NoError(err) + require.NotEmpty(&customWriter) +} diff --git a/geth/jail/handlers.go b/geth/jail/handlers.go index 5d9b22310..1b96641cd 100644 --- a/geth/jail/handlers.go +++ b/geth/jail/handlers.go @@ -1,33 +1,48 @@ package jail import ( + "os" + "github.com/robertkrimen/otto" + "github.com/status-im/status-go/geth/jail/console" "github.com/status-im/status-go/geth/node" ) +// signals const ( EventLocalStorageSet = "local_storage.set" - EventSendMessage = "jail.send_message" + EventSendMessage = "jail.send_message" EventShowSuggestions = "jail.show_suggestions" - LocalStorageMaxDataLen = 256 + + // EventConsoleLog defines the event type for the console.log call. + eventConsoleLog = "vm.console.log" ) // registerHandlers augments and transforms a given jail cell's underlying VM, // by adding and replacing method handlers. -func registerHandlers(jail *Jail, vm *otto.Otto, chatID string) (err error) { - jeth, err := vm.Get("jeth") +func registerHandlers(jail *Jail, cell *JailCell, chatID string) error { + jeth, err := cell.Get("jeth") if err != nil { return err } + registerHandler := jeth.Object().Set + if err = registerHandler("console", map[string]interface{}{ + "log": func(fn otto.FunctionCall) otto.Value { + return console.Write(fn, os.Stdout, eventConsoleLog) + }, + }); err != nil { + return err + } + // register send handler - if err = registerHandler("send", makeSendHandler(jail, chatID)); err != nil { + if err = registerHandler("send", makeSendHandler(jail)); err != nil { return err } // register sendAsync handler - if err = registerHandler("sendAsync", makeSendHandler(jail, chatID)); err != nil { + if err = registerHandler("sendAsync", makeSendHandler(jail)); err != nil { return err } @@ -37,27 +52,46 @@ func registerHandlers(jail *Jail, vm *otto.Otto, chatID string) (err error) { } // define localStorage - if err = vm.Set("localStorage", struct{}{}); err != nil { - return + if err = cell.Set("localStorage", struct{}{}); err != nil { + return err } // register localStorage.set handler - localStorage, err := vm.Get("localStorage") + localStorage, err := cell.Get("localStorage") if err != nil { - return + return err } + if err = localStorage.Object().Set("set", makeLocalStorageSetHandler(chatID)); err != nil { - return + return err + } + + // register sendMessage/showSuggestions handlers + if err = cell.Set("statusSignals", struct{}{}); err != nil { + return err + } + + statusSignals, err := cell.Get("statusSignals") + if err != nil { + return err + } + + registerHandler = statusSignals.Object().Set + + if err = registerHandler("sendMessage", makeSendMessageHandler(chatID)); err != nil { + return err + } + + if err = registerHandler("showSuggestions", makeShowSuggestionsHandler(chatID)); err != nil { + return err } return nil } // makeSendHandler returns jeth.send() and jeth.sendAsync() handler -func makeSendHandler(jail *Jail, chatID string) func(call otto.FunctionCall) (response otto.Value) { - return func(call otto.FunctionCall) (response otto.Value) { - return jail.Send(chatID, call) - } +func makeSendHandler(jail *Jail) func(call otto.FunctionCall) (response otto.Value) { + return jail.Send } // makeJethIsConnectedHandler returns jeth.isConnected() handler @@ -65,19 +99,19 @@ func makeJethIsConnectedHandler(jail *Jail) func(call otto.FunctionCall) (respon return func(call otto.FunctionCall) otto.Value { client, err := jail.requestManager.RPCClient() if err != nil { - return newErrorResponse(call, -32603, err.Error(), nil) + return newErrorResponse(call.Otto, -32603, err.Error(), nil) } var netListeningResult bool if err := client.Call(&netListeningResult, "net_listening"); err != nil { - return newErrorResponse(call, -32603, err.Error(), nil) + return newErrorResponse(call.Otto, -32603, err.Error(), nil) } if !netListeningResult { - return newErrorResponse(call, -32603, node.ErrNoRunningNode.Error(), nil) + return newErrorResponse(call.Otto, -32603, node.ErrNoRunningNode.Error(), nil) } - return newResultResponse(call, true) + return newResultResponse(call.Otto, true) } } @@ -91,9 +125,6 @@ type LocalStorageSetEvent struct { func makeLocalStorageSetHandler(chatID string) func(call otto.FunctionCall) (response otto.Value) { return func(call otto.FunctionCall) otto.Value { data := call.Argument(0).String() - if len(data) > LocalStorageMaxDataLen { // cap input string - data = data[:LocalStorageMaxDataLen] - } node.SendSignal(node.SignalEnvelope{ Type: EventLocalStorageSet, @@ -103,7 +134,7 @@ func makeLocalStorageSetHandler(chatID string) func(call otto.FunctionCall) (res }, }) - return newResultResponse(call, true) + return newResultResponse(call.Otto, true) } } @@ -125,7 +156,7 @@ func makeSendMessageHandler(chatID string) func(call otto.FunctionCall) (respons }, }) - return newResultResponse(call, true) + return newResultResponse(call.Otto, true) } } @@ -147,6 +178,6 @@ func makeShowSuggestionsHandler(chatID string) func(call otto.FunctionCall) (res }, }) - return newResultResponse(call, true) + return newResultResponse(call.Otto, true) } } diff --git a/geth/jail/jail.go b/geth/jail/jail.go index 0bdeef4bd..e970a252c 100644 --- a/geth/jail/jail.go +++ b/geth/jail/jail.go @@ -5,25 +5,17 @@ import ( "errors" "fmt" "sync" - "time" - "github.com/eapache/go-resiliency/semaphore" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rpc" "github.com/robertkrimen/otto" "github.com/status-im/status-go/geth/common" "github.com/status-im/status-go/static" - "fknsrs.biz/p/ottoext/fetch" "fknsrs.biz/p/ottoext/loop" - "fknsrs.biz/p/ottoext/timers" -) - -const ( - // JailCellRequestTimeout seconds before jailed request times out - JailCellRequestTimeout = 60 ) +// FIXME(tiabc): Get rid of this global variable. Move it to a constructor or initialization. var web3JSCode = static.MustAsset("scripts/web3.js") // errors @@ -31,160 +23,101 @@ var ( ErrInvalidJail = errors.New("jail environment is not properly initialized") ) -// JailCell represents single jail cell, which is basically a JavaScript VM. -type JailCell struct { - id string - vm *otto.Otto - lo *loop.Loop - sem *semaphore.Semaphore -} - -// newJailCell encapsulates what we need to create a new jailCell from the -// provided vm and eventloop instance. -func newJailCell(id string, vm *otto.Otto, lo *loop.Loop) (*JailCell, error) { - - // Register fetch provider from ottoext. - if err := fetch.Define(vm, lo); err != nil { - return nil, err - } - - // Register event loop for timers. - if err := timers.Define(vm, lo); err != nil { - return nil, err - } - - return &JailCell{ - id: id, - vm: vm, - lo: lo, - sem: semaphore.New(1, JailCellRequestTimeout*time.Second), - }, nil -} - // Jail represents jailed environment inside of which we hold multiple cells. // Each cell is a separate JavaScript VM. type Jail struct { sync.RWMutex requestManager *RequestManager - cells map[string]common.JailCell // jail supports running many isolated instances of jailed runtime - baseJSCode string // JavaScript used to initialize all new cells with + cells map[string]*JailCell // jail supports running many isolated instances of jailed runtime + baseJSCode string // JavaScript used to initialize all new cells with } -// Copy returns a new JailCell instance with a new eventloop runtime associated with -// the given cell. -func (cell *JailCell) Copy() (common.JailCell, error) { - vmCopy := cell.vm.Copy() - return newJailCell(cell.id, vmCopy, loop.New(vmCopy)) -} - -// Fetch attempts to call the underline Fetch API added through the -// ottoext package. -func (cell *JailCell) Fetch(url string, callback func(otto.Value)) (otto.Value, error) { - if err := cell.vm.Set("__captureFetch", callback); err != nil { - return otto.UndefinedValue(), err - } - - return cell.Exec(`fetch("` + url + `").then(function(response){ - __captureFetch({ - "url": response.url, - "type": response.type, - "body": response.text(), - "status": response.status, - "headers": response.headers, - }); - }); - `) -} - -// Exec evaluates the giving js string on the associated vm loop returning -// an error. -func (cell *JailCell) Exec(val string) (otto.Value, error) { - res, err := cell.vm.Run(val) - if err != nil { - return res, err - } - - return res, cell.lo.Run() -} - -// Run evaluates the giving js string on the associated vm llop. -func (cell *JailCell) Run(val string) (otto.Value, error) { - return cell.vm.Run(val) -} - -// CellLoop returns the ottoext.Loop instance which provides underline timeout/setInternval -// event runtime for the Jail vm. -func (cell *JailCell) CellLoop() *loop.Loop { - return cell.lo -} - -// Executor returns a structure which implements the common.JailExecutor. -func (cell *JailCell) Executor() common.JailExecutor { - return cell -} - -// CellVM returns the associated otto.Vm connect to the giving cell. -func (cell *JailCell) CellVM() *otto.Otto { - return cell.vm -} - -// New returns new Jail environment +// New returns new Jail environment. func New(nodeManager common.NodeManager) *Jail { return &Jail{ + cells: make(map[string]*JailCell), requestManager: NewRequestManager(nodeManager), - cells: make(map[string]common.JailCell), } } -// BaseJS allows to setup initial JavaScript to be loaded on each jail.Parse() +// BaseJS allows to setup initial JavaScript to be loaded on each jail.Parse(). func (jail *Jail) BaseJS(js string) { jail.baseJSCode = js } -// NewJailCell initializes and returns jail cell -func (jail *Jail) NewJailCell(id string) common.JailCell { +// NewJailCell initializes and returns jail cell. +func (jail *Jail) NewJailCell(id string) (common.JailCell, error) { + if jail == nil { + return nil, ErrInvalidJail + } + vm := otto.New() newJail, err := newJailCell(id, vm, loop.New(vm)) if err != nil { - //TODO(alex): Should we really panic here, his there - // a better way. Think on it. - panic(err) + return nil, err } - return newJail + jail.Lock() + jail.cells[id] = newJail + jail.Unlock() + + return newJail, nil +} + +// GetJailCell returns the associated *JailCell for the provided chatID. +func (jail *Jail) GetJailCell(chatID string) (common.JailCell, error) { + return jail.GetCell(chatID) +} + +// GetCell returns the associated *JailCell for the provided chatID. +func (jail *Jail) GetCell(chatID string) (*JailCell, error) { + jail.RLock() + defer jail.RUnlock() + + cell, ok := jail.cells[chatID] + if !ok { + return nil, fmt.Errorf("cell[%s] doesn't exist", chatID) + } + + return cell, nil } // Parse creates a new jail cell context, with the given chatID as identifier. // New context executes provided JavaScript code, right after the initialization. func (jail *Jail) Parse(chatID string, js string) string { - var err error if jail == nil { return makeError(ErrInvalidJail.Error()) } - jail.Lock() - defer jail.Unlock() + var err error + var jcell *JailCell - jail.cells[chatID] = jail.NewJailCell(chatID) - vm := jail.cells[chatID].CellVM() + if jcell, err = jail.GetCell(chatID); err != nil { + if _, mkerr := jail.NewJailCell(chatID); mkerr != nil { + return makeError(mkerr.Error()) + } - initJjs := jail.baseJSCode + ";" - if _, err = vm.Run(initJjs); err != nil { - return makeError(err.Error()) + jcell, _ = jail.GetCell(chatID) } // init jeth and its handlers - if err = vm.Set("jeth", struct{}{}); err != nil { + if err = jcell.Set("jeth", struct{}{}); err != nil { return makeError(err.Error()) } - if err = registerHandlers(jail, vm, chatID); err != nil { + + if err = registerHandlers(jail, jcell, chatID); err != nil { + return makeError(err.Error()) + } + + initJs := jail.baseJSCode + ";" + if _, err = jcell.Run(initJs); err != nil { return makeError(err.Error()) } // sendMessage/showSuggestions handlers - vm.Set("statusSignals", struct{}{}) - statusSignals, _ := vm.Get("statusSignals") + jcell.Set("statusSignals", struct{}{}) + statusSignals, _ := jcell.Get("statusSignals") statusSignals.Object().Set("sendMessage", makeSendMessageHandler(chatID)) statusSignals.Object().Set("showSuggestions", makeShowSuggestionsHandler(chatID)) @@ -196,11 +129,11 @@ func (jail *Jail) Parse(chatID string, js string) string { return new Bignumber(val); } ` + js + "; var catalog = JSON.stringify(_status_catalog);" - if _, err = vm.Run(jjs); err != nil { + if _, err = jcell.Run(jjs); err != nil { return makeError(err.Error()) } - res, err := vm.Get("catalog") + res, err := jcell.Get("catalog") if err != nil { return makeError(err.Error()) } @@ -208,54 +141,34 @@ func (jail *Jail) Parse(chatID string, js string) string { return makeResult(res.String(), err) } -// Call executes given JavaScript function w/i a jail cell context identified by the chatID. +// Call executes the `call` function w/i a jail cell context identified by the chatID. // Jail cell is clonned before call is executed i.e. all calls execute w/i their own contexts. func (jail *Jail) Call(chatID string, path string, args string) string { - jail.RLock() - cell, ok := jail.cells[chatID] - if !ok { - jail.RUnlock() - return makeError(fmt.Sprintf("Cell[%s] doesn't exist.", chatID)) - } - jail.RUnlock() - - // Due to the new timer assigned we need to clone existing cell to allow - // unique cell runtime and eventloop context. - cellCopy, err := cell.Copy() + jcell, err := jail.GetCell(chatID) if err != nil { return makeError(err.Error()) } - // isolate VM to allow concurrent access - vm := cellCopy.CellVM() - res, err := vm.Call("call", nil, path, args) + res, err := jcell.Call("call", nil, path, args) + + // WARNING(influx6): We can have go-routine leakage due to continous call to this method + // and the call to cell.CellLoop().Run() due to improper usage, let's keep this + // in sight if things ever go wrong here. + // Due to the new event loop provided by ottoext. + // We need to ensure that all possible calls to internal setIntervals/SetTimeouts/SetImmediate + // work by lunching the loop.Run() method. + // Needs to be done in a go-routine. + go jcell.lo.Run() return makeResult(res.String(), err) } -// JailCellVM returns instance of Otto VM (which is persisted w/i jail cell) by chatID -func (jail *Jail) JailCellVM(chatID string) (*otto.Otto, error) { - if jail == nil { - return nil, ErrInvalidJail - } - - jail.RLock() - defer jail.RUnlock() - - cell, ok := jail.cells[chatID] - if !ok { - return nil, fmt.Errorf("cell[%s] doesn't exist", chatID) - } - - return cell.CellVM(), nil -} - // Send will serialize the first argument, send it to the node and returns the response. // nolint: errcheck, unparam -func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Value) { +func (jail *Jail) Send(call otto.FunctionCall) (response otto.Value) { client, err := jail.requestManager.RPCClient() if err != nil { - return newErrorResponse(call, -32603, err.Error(), nil) + return newErrorResponse(call.Otto, -32603, err.Error(), nil) } // Remarshal the request into a Go value. @@ -290,7 +203,7 @@ func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Val txHash, err := jail.requestManager.ProcessSendTransactionRequest(call.Otto, req) resp.Set("result", txHash.Hex()) if err != nil { - resp = newErrorResponse(call, -32603, err.Error(), &req.ID).Object() + resp = newErrorResponse(call.Otto, -32603, err.Error(), &req.ID).Object() } resps.Call("push", resp) continue @@ -301,7 +214,7 @@ func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Val // so that no more than one client (per cell) can enter messageID, err := jail.requestManager.PreProcessRequest(call.Otto, req) if err != nil { - return newErrorResponse(call, -32603, err.Error(), nil) + return newErrorResponse(call.Otto, -32603, err.Error(), nil) } errc := make(chan error, 1) @@ -321,7 +234,7 @@ func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Val } else { resultVal, callErr := JSON.Call("parse", string(result)) if callErr != nil { - resp = newErrorResponse(call, -32603, callErr.Error(), &req.ID).Object() + resp = newErrorResponse(call.Otto, -32603, callErr.Error(), &req.ID).Object() } else { resp.Set("result", resultVal) } @@ -332,7 +245,7 @@ func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Val "message": err.Error(), }) default: - resp = newErrorResponse(call, -32603, err.Error(), &req.ID).Object() + resp = newErrorResponse(call.Otto, -32603, err.Error(), &req.ID).Object() } resps.Call("push", resp) @@ -354,16 +267,16 @@ func (jail *Jail) Send(chatID string, call otto.FunctionCall) (response otto.Val return response } -func newErrorResponse(call otto.FunctionCall, code int, msg string, id interface{}) otto.Value { +func newErrorResponse(otto *otto.Otto, code int, msg string, id interface{}) otto.Value { // Bundle the error into a JSON RPC call response m := map[string]interface{}{"jsonrpc": "2.0", "id": id, "error": map[string]interface{}{"code": code, msg: msg}} res, _ := json.Marshal(m) - val, _ := call.Otto.Run("(" + string(res) + ")") + val, _ := otto.Run("(" + string(res) + ")") return val } -func newResultResponse(call otto.FunctionCall, result interface{}) otto.Value { - resp, _ := call.Otto.Object(`({"jsonrpc":"2.0"})`) +func newResultResponse(vm *otto.Otto, result interface{}) otto.Value { + resp, _ := vm.Object(`({"jsonrpc":"2.0"})`) resp.Set("result", result) // nolint: errcheck return resp.Value() diff --git a/geth/jail/jail_cell.go b/geth/jail/jail_cell.go new file mode 100644 index 000000000..32c3b2438 --- /dev/null +++ b/geth/jail/jail_cell.go @@ -0,0 +1,139 @@ +package jail + +import ( + "sync" + + "fknsrs.biz/p/ottoext/fetch" + "fknsrs.biz/p/ottoext/loop" + "fknsrs.biz/p/ottoext/timers" + "github.com/robertkrimen/otto" +) + +const ( + // JailCellRequestTimeout seconds before jailed request times out. + JailCellRequestTimeout = 60 +) + +// JailCell represents single jail cell, which is basically a JavaScript VM. +// TODO(influx6): Rename JailCell to Cell in next refactoring phase. +type JailCell struct { + sync.Mutex + + id string + vm *otto.Otto + lo *loop.Loop +} + +// newJailCell encapsulates what we need to create a new jailCell from the +// provided vm and eventloop instance. +func newJailCell(id string, vm *otto.Otto, lo *loop.Loop) (*JailCell, error) { + // Register fetch provider from ottoext. + if err := fetch.Define(vm, lo); err != nil { + return nil, err + } + + // Register event loop for timers. + if err := timers.Define(vm, lo); err != nil { + return nil, err + } + + return &JailCell{ + id: id, + vm: vm, + lo: lo, + }, nil +} + +// Fetch attempts to call the underline Fetch API added through the +// ottoext package. +func (cell *JailCell) Fetch(url string, callback func(otto.Value)) (otto.Value, error) { + val, err := cell.prepareFetchCall(url, callback) + if err != nil { + return val, err + } + + return val, cell.lo.Run() +} + +// prepareFetchCall prepares the needed calls to hook into the vm to receive the expected response +// for a call to the FetchAPI. We need this to ensure confidence in mutex locking and unlocking. +func (cell *JailCell) prepareFetchCall(url string, callback func(otto.Value)) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + if err := cell.vm.Set("__captureFetch", callback); err != nil { + return otto.UndefinedValue(), err + } + + return cell.vm.Run(`fetch("` + url + `").then(function(response){ + __captureFetch({ + "url": response.url, + "type": response.type, + "body": response.text(), + "status": response.status, + "headers": response.headers, + }); + }); + `) +} + +// Set sets the value to be keyed by the provided keyname. +func (cell *JailCell) Set(key string, val interface{}) error { + cell.Lock() + defer cell.Unlock() + + return cell.vm.Set(key, val) +} + +// Get returns the giving key's otto.Value from the underline otto vm. +func (cell *JailCell) Get(key string) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + return cell.vm.Get(key) +} + +// RunOnLoop evaluates the giving js string on the associated vm loop returning +// an error. +func (cell *JailCell) RunOnLoop(val string) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + res, err := cell.vm.Run(val) + if err != nil { + return res, err + } + + return res, cell.lo.Run() +} + +// CallOnLoop attempts to call the internal call function for the giving response associated with the +// proper values. +func (cell *JailCell) CallOnLoop(item string, this interface{}, args ...interface{}) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + res, err := cell.vm.Call(item, this, args...) + if err != nil { + return res, err + } + + return res, cell.lo.Run() +} + +// Call attempts to call the internal call function for the giving response associated with the +// proper values. +func (cell *JailCell) Call(item string, this interface{}, args ...interface{}) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + return cell.vm.Call(item, this, args...) +} + +// Run evaluates the giving js string on the associated vm llop. +func (cell *JailCell) Run(val string) (otto.Value, error) { + cell.Lock() + defer cell.Unlock() + + return cell.vm.Run(val) +} diff --git a/geth/jail/jail_cell_test.go b/geth/jail/jail_cell_test.go new file mode 100644 index 000000000..be169601d --- /dev/null +++ b/geth/jail/jail_cell_test.go @@ -0,0 +1,135 @@ +package jail_test + +import ( + "net/http" + "net/http/httptest" + "time" + + "github.com/robertkrimen/otto" + "github.com/status-im/status-go/geth/jail" + "github.com/status-im/status-go/geth/params" +) + +func (s *JailTestSuite) TestJailTimeoutFailure() { + require := s.Require() + require.NotNil(s.jail) + + newCell, err := s.jail.NewJailCell(testChatID) + require.NoError(err) + require.NotNil(newCell) + + // Attempt to run a timeout string against a JailCell. + _, err = newCell.RunOnLoop(` + setTimeout(function(n){ + if(Date.now() - n < 50){ + throw new Error("Timedout early"); + } + + return n; + }, 30, Date.now()); + `) + + require.NotNil(err) +} + +func (s *JailTestSuite) TestJailTimeout() { + require := s.Require() + require.NotNil(s.jail) + + newCell, err := s.jail.NewJailCell(testChatID) + require.NoError(err) + require.NotNil(newCell) + + // Attempt to run a timeout string against a JailCell. + res, err := newCell.RunOnLoop(` + setTimeout(function(n){ + if(Date.now() - n < 50){ + throw new Error("Timedout early"); + } + + return n; + }, 50, Date.now()); + `) + + require.NoError(err) + require.NotNil(res) +} + +func (s *JailTestSuite) TestJailFetch() { + mux := http.NewServeMux() + mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + w.Write([]byte("Hello World")) + }) + + server := httptest.NewServer(mux) + defer server.Close() + + require := s.Require() + require.NotNil(s.jail) + + newCell, err := s.jail.NewJailCell(testChatID) + require.NoError(err) + require.NotNil(newCell) + + jcell, ok := newCell.(*jail.JailCell) + require.Equal(ok, true) + require.NotNil(jcell) + + wait := make(chan struct{}) + + // Attempt to run a fetch resource. + _, err = jcell.Fetch(server.URL, func(res otto.Value) { + go func() { wait <- struct{}{} }() + }) + + require.NoError(err) + + <-wait +} + +func (s *JailTestSuite) TestJailLoopInCall() { + require := s.Require() + require.NotNil(s.jail) + + s.StartTestNode(params.RopstenNetworkID) + defer s.StopTestNode() + + // load Status JS and add test command to it + s.jail.BaseJS(baseStatusJSCode) + s.jail.Parse(testChatID, ``) + + cell, err := s.jail.GetCell(testChatID) + require.NoError(err) + require.NotNil(cell) + + items := make(chan string) + + err = cell.Set("__captureResponse", func(val string) otto.Value { + go func() { items <- val }() + return otto.UndefinedValue() + }) + require.NoError(err) + + _, err = cell.Run(` + function callRunner(namespace){ + console.log("Initiating callRunner for: ", namespace) + return setTimeout(function(){ + __captureResponse(namespace); + }, 1000); + } + `) + require.NoError(err) + + _, err = cell.CallOnLoop("callRunner", nil, "softball") + require.NoError(err) + + select { + case received := <-items: + require.Equal(received, "softball") + break + + case <-time.After(5 * time.Second): + require.Fail("Failed to received event response") + } +} diff --git a/geth/jail/jail_test.go b/geth/jail/jail_test.go index 0a41b224c..64dc231ab 100644 --- a/geth/jail/jail_test.go +++ b/geth/jail/jail_test.go @@ -3,12 +3,9 @@ package jail_test import ( "encoding/json" "errors" - "net/http" - "net/http/httptest" "testing" "time" - "github.com/robertkrimen/otto" "github.com/status-im/status-go/geth/jail" "github.com/status-im/status-go/geth/node" "github.com/status-im/status-go/geth/params" @@ -50,9 +47,9 @@ func (s *JailTestSuite) TestInit() { } // get cell VM w/o defining cell first - vm, err := s.jail.JailCellVM(testChatID) + cell, err := s.jail.GetCell(testChatID) require.EqualError(err, "cell[testChat] doesn't exist") - require.Nil(vm) + require.Nil(cell) // create VM (w/o properly initializing base JS script) err = errors.New("ReferenceError: '_status_catalog' is not defined") @@ -61,9 +58,9 @@ func (s *JailTestSuite) TestInit() { require.Equal(errorWrapper(err), s.jail.Call(testChatID, `["commands", "testCommand"]`, `{"val": 12}`)) // get existing cell (even though we got errors, cell was still created) - vm, err = s.jail.JailCellVM(testChatID) + cell, err = s.jail.GetCell(testChatID) require.NoError(err) - require.NotNil(vm) + require.NotNil(cell) statusJS := baseStatusJSCode + `; _status_catalog.commands["testCommand"] = function (params) { @@ -109,7 +106,7 @@ func (s *JailTestSuite) TestFunctionCall() { // call with wrong chat id response := s.jail.Call("chatIDNonExistent", "", "") - expectedError := `{"error":"Cell[chatIDNonExistent] doesn't exist."}` + expectedError := `{"error":"cell[chatIDNonExistent] doesn't exist"}` require.Equal(expectedError, response) // call extraFunc() @@ -118,83 +115,6 @@ func (s *JailTestSuite) TestFunctionCall() { require.Equal(expectedResponse, response) } -func (s *JailTestSuite) TestJailTimeoutFailure() { - require := s.Require() - require.NotNil(s.jail) - - newCell := s.jail.NewJailCell(testChatID) - require.NotNil(newCell) - - execr := newCell.Executor() - - // Attempt to run a timeout string against a JailCell. - _, err := execr.Exec(` - setTimeout(function(n){ - if(Date.now() - n < 50){ - throw new Error("Timedout early"); - } - - return n; - }, 30, Date.now()); - `) - - require.NotNil(err) -} - -func (s *JailTestSuite) TestJailTimeout() { - require := s.Require() - require.NotNil(s.jail) - - newCell := s.jail.NewJailCell(testChatID) - require.NotNil(newCell) - - execr := newCell.Executor() - - // Attempt to run a timeout string against a JailCell. - res, err := execr.Exec(` - setTimeout(function(n){ - if(Date.now() - n < 50){ - throw new Error("Timedout early"); - } - - return n; - }, 50, Date.now()); - `) - - require.NoError(err) - require.NotNil(res) -} - -func (s *JailTestSuite) TestJailFetch() { - mux := http.NewServeMux() - mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusOK) - w.Write([]byte("Hello World")) - }) - - server := httptest.NewServer(mux) - defer server.Close() - - require := s.Require() - require.NotNil(s.jail) - - newCell := s.jail.NewJailCell(testChatID) - require.NotNil(newCell) - - execr := newCell.Executor() - - wait := make(chan struct{}) - - // Attempt to run a fetch resource. - _, err := execr.Fetch(server.URL, func(res otto.Value) { - go func() { wait <- struct{}{} }() - }) - - require.NoError(err) - - <-wait -} - func (s *JailTestSuite) TestJailRPCSend() { require := s.Require() require.NotNil(s.jail) @@ -207,19 +127,19 @@ func (s *JailTestSuite) TestJailRPCSend() { s.jail.Parse(testChatID, ``) // obtain VM for a given chat (to send custom JS to jailed version of Send()) - vm, err := s.jail.JailCellVM(testChatID) + cell, err := s.jail.GetCell(testChatID) require.NoError(err) - require.NotNil(vm) + require.NotNil(cell) // internally (since we replaced `web3.send` with `jail.Send`) // all requests to web3 are forwarded to `jail.Send` - _, err = vm.Run(` + _, err = cell.Run(` var balance = web3.eth.getBalance("` + TestConfig.Account1.Address + `"); var sendResult = web3.fromWei(balance, "ether") `) require.NoError(err) - value, err := vm.Get("sendResult") + value, err := cell.Get("sendResult") require.NoError(err, "cannot obtain result of balance check operation") balance, err := value.ToFloat() @@ -229,39 +149,27 @@ func (s *JailTestSuite) TestJailRPCSend() { require.False(balance < 100, "wrong balance (there should be lots of test Ether on that account)") } -func (s *JailTestSuite) TestGetJailCellVM() { - expectedError := `cell[nonExistentChat] doesn't exist` - _, err := s.jail.JailCellVM("nonExistentChat") - s.EqualError(err, expectedError) - - // now let's create VM.. - s.jail.Parse(testChatID, ``) - - // ..and see if VM becomes available - _, err = s.jail.JailCellVM(testChatID) - s.NoError(err) -} - func (s *JailTestSuite) TestIsConnected() { require := s.Require() require.NotNil(s.jail) + // TODO(tiabc): Is this required? s.StartTestNode(params.RopstenNetworkID) defer s.StopTestNode() s.jail.Parse(testChatID, "") // obtain VM for a given chat (to send custom JS to jailed version of Send()) - vm, err := s.jail.JailCellVM(testChatID) + cell, err := s.jail.GetCell(testChatID) require.NoError(err) - _, err = vm.Run(` + _, err = cell.Run(` var responseValue = web3.isConnected(); responseValue = JSON.stringify(responseValue); `) require.NoError(err) - responseValue, err := vm.Get("responseValue") + responseValue, err := cell.Get("responseValue") require.NoError(err, "cannot obtain result of isConnected()") response, err := responseValue.ToString() @@ -278,7 +186,7 @@ func (s *JailTestSuite) TestLocalStorageSet() { s.jail.Parse(testChatID, "") // obtain VM for a given chat (to send custom JS to jailed version of Send()) - vm, err := s.jail.JailCellVM(testChatID) + cell, err := s.jail.GetCell(testChatID) require.NoError(err) testData := "foobar" @@ -306,7 +214,7 @@ func (s *JailTestSuite) TestLocalStorageSet() { } }) - _, err = vm.Run(` + _, err = cell.Run(` var responseValue = localStorage.set("` + testData + `"); responseValue = JSON.stringify(responseValue); `) @@ -320,7 +228,7 @@ func (s *JailTestSuite) TestLocalStorageSet() { s.Fail("operation timed out") } - responseValue, err := vm.Get("responseValue") + responseValue, err := cell.Get("responseValue") s.NoError(err, "cannot obtain result of localStorage.set()") response, err := responseValue.ToString() diff --git a/geth/jail/requests.go b/geth/jail/requests.go index d301bf72c..9beaf8e09 100644 --- a/geth/jail/requests.go +++ b/geth/jail/requests.go @@ -23,6 +23,7 @@ type RequestManager struct { nodeManager common.NodeManager } +// NewRequestManager returns a new instance of the RequestManager pointer. func NewRequestManager(nodeManager common.NodeManager) *RequestManager { return &RequestManager{ nodeManager: nodeManager, @@ -38,6 +39,7 @@ func (m *RequestManager) PreProcessRequest(vm *otto.Otto, req RPCCall) (string, // PostProcessRequest post-processes a given RPC call to a given Otto VM func (m *RequestManager) PostProcessRequest(vm *otto.Otto, req RPCCall, messageID string) { + // Errors are ignored because addContext may not exist and it's alright. if len(messageID) > 0 { vm.Call("addContext", nil, messageID, common.MessageIDKey, messageID) // nolint: errcheck } diff --git a/geth/node/manager.go b/geth/node/manager.go index fa819a18b..8a4e7b740 100644 --- a/geth/node/manager.go +++ b/geth/node/manager.go @@ -241,11 +241,7 @@ func (m *NodeManager) populateStaticPeers() error { return nil } - enodes, err := m.config.LoadBootClusterNodes() - if err != nil { - log.Warn("Can not load boot nodes", "error", err) - } - for _, enode := range enodes { + for _, enode := range m.config.BootClusterConfig.BootNodes { err := m.addPeer(enode) if err != nil { log.Warn("Boot node addition failed", "error", err) diff --git a/geth/node/node.go b/geth/node/node.go index 14f4fef36..3848e6268 100644 --- a/geth/node/node.go +++ b/geth/node/node.go @@ -4,13 +4,10 @@ import ( "encoding/json" "errors" "fmt" - "net/http" "os" "path" "path/filepath" - "strconv" "strings" - "time" gethcommon "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core" @@ -74,17 +71,6 @@ func MakeNode(config *params.NodeConfig) (*node.Node, error) { stackConfig.P2P.PrivateKey = pk } - if len(config.NodeKeyFile) > 0 { - log.Info("Loading private key file", "file", config.NodeKeyFile) - pk, err := crypto.LoadECDSA(config.NodeKeyFile) - if err != nil { - log.Info("Failed loading private key file", "file", config.NodeKeyFile, "err", err) - } - - // override node's private key - stackConfig.P2P.PrivateKey = pk - } - stack, err := node.New(stackConfig) if err != nil { return nil, ErrNodeMakeFailure @@ -142,90 +128,24 @@ func defaultEmbeddedNodeConfig(config *params.NodeConfig) *node.Config { // updateCHT changes trusted canonical hash trie root func updateCHT(eth *les.LightEthereum, config *params.NodeConfig) { - bc := eth.BlockChain() - - // TODO: Remove this thing as this is an ugly hack. - // Once CHT sync sub-protocol is working in LES, we will rely on it, as it provides - // decentralized solution. For now, in order to avoid forcing users to long sync times - // we use central static resource - type MsgCHTRoot struct { - GenesisHash string `json:"net"` - Number uint64 `json:"number"` - Prod string `json:"prod"` - Dev string `json:"dev"` - } - loadCHTLists := func() ([]MsgCHTRoot, error) { - url := config.LightEthConfig.CHTRootConfigURL + "?u=" + strconv.Itoa(int(time.Now().Unix())) - client := &http.Client{Timeout: 5 * time.Second} - r, err := client.Get(url) - if err != nil { - return nil, err - } - defer r.Body.Close() - - var roots []MsgCHTRoot - err = json.NewDecoder(r.Body).Decode(&roots) - if err != nil { - return nil, err - } - - return roots, nil - } - if roots, err := loadCHTLists(); err == nil { - for _, root := range roots { - if bc.Genesis().Hash().Hex() == root.GenesisHash { - log.Info("Loaded root", "root", root) - if root.Number == 0 { - continue - } - - chtRoot := root.Prod - if config.DevMode { - chtRoot = root.Dev - } - eth.WriteTrustedCht(light.TrustedCht{ - Number: root.Number, - Root: gethcommon.HexToHash(chtRoot), - }) - log.Info("Loaded CHT from net", "CHT", chtRoot, "number", root.Number, "dev", config.DevMode) - return - } - } + if !config.BootClusterConfig.Enabled { + return } - // resort to manually updated - log.Info("Loading CHT from net failed, setting manually") - if bc.Genesis().Hash() == params.MainNetGenesisHash { - eth.WriteTrustedCht(light.TrustedCht{ - Number: 805, - Root: gethcommon.HexToHash("85e4286fe0a730390245c49de8476977afdae0eb5530b277f62a52b12313d50f"), - }) - log.Info("Added trusted CHT for mainnet") + if config.BootClusterConfig.RootNumber == 0 { + return } - if bc.Genesis().Hash() == params.RopstenNetGenesisHash { - root := "fa851b5252cc48ab55f375833b0344cc5c7cacea69be7e2a57976c38d3bb3aef" - if config.DevMode { - root = "f2f862314509b22a773eedaaa7fa6452474eb71a3b72525a97dbf5060cbea88f" - } - eth.WriteTrustedCht(light.TrustedCht{ - Number: 239, - Root: gethcommon.HexToHash(root), - }) - log.Info("Added trusted CHT for Ropsten", "CHT", root) + if config.BootClusterConfig.RootHash == "" { + return } - //if bc.Genesis().Hash() == params.RinkebyNetGenesisHash { - // root := "0xb100882d00a09292f15e712707649b24d019a47a509e83a00530ac542425c3bd" - // if config.DevMode { - // root = "0xb100882d00a09292f15e712707649b24d019a47a509e83a00530ac542425c3bd" - // } - // eth.WriteTrustedCht(light.TrustedCht{ - // Number: 55, - // Root: gethcommon.HexToHash(root), - // }) - // log.Info("Added trusted CHT for Rinkeby", "CHT", root) - //} + eth.WriteTrustedCht(light.TrustedCht{ + Number: uint64(config.BootClusterConfig.RootNumber), + Root: gethcommon.HexToHash(config.BootClusterConfig.RootHash), + }) + log.Info("Added trusted CHT", + "develop", config.DevMode, "number", config.BootClusterConfig.RootNumber, "hash", config.BootClusterConfig.RootHash) } // activateEthService configures and registers the eth.Ethereum service with a given node. @@ -271,7 +191,7 @@ func activateShhService(stack *node.Node, config *params.NodeConfig) error { serviceConstructor := func(*node.ServiceContext) (node.Service, error) { whisperConfig := config.WhisperConfig - whisperService := whisper.New() + whisperService := whisper.New(nil) // enable mail service if whisperConfig.MailServerNode { diff --git a/geth/params/config.go b/geth/params/config.go index 227a7c06a..e4a49bdb0 100644 --- a/geth/params/config.go +++ b/geth/params/config.go @@ -7,14 +7,16 @@ import ( "errors" "fmt" "io/ioutil" + "net/http" "os" "path/filepath" + "strconv" "strings" + "time" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/log" - "github.com/status-im/status-go/static" ) // default node configuration options @@ -52,14 +54,8 @@ type LightEthConfig struct { // DatabaseCache is memory (in MBs) allocated to internal caching (min 16MB / database forced) DatabaseCache int - - // CHTRootConfigURL defines URL to file containing hard-coded CHT roots - // TODO remove this hack, once CHT sync is implemented on LES side - CHTRootConfigURL string } -//===================================================================================== - // FirebaseConfig holds FCM-related configuration type FirebaseConfig struct { // AuthorizationKeyFile file path that contains FCM authorization key @@ -89,8 +85,6 @@ func (c *FirebaseConfig) ReadAuthorizationKeyFile() ([]byte, error) { return key, nil } -//===================================================================================== - // WhisperConfig holds SHH-related configuration type WhisperConfig struct { // Enabled flag specifies whether protocol is enabled @@ -177,8 +171,6 @@ func (c *WhisperConfig) String() string { return string(data) } -//===================================================================================== - // SwarmConfig holds Swarm-related configuration type SwarmConfig struct { // Enabled flag specifies whether protocol is enabled @@ -191,8 +183,6 @@ func (c *SwarmConfig) String() string { return string(data) } -//===================================================================================== - // BootClusterConfig holds configuration for supporting boot cluster, which is a temporary // means for mobile devices to get connected to Ethereum network (UDP-based discovery // may not be available, so we need means to discover the network manually). @@ -200,12 +190,15 @@ type BootClusterConfig struct { // Enabled flag specifies whether feature is enabled Enabled bool - // ConfigFile is a path to JSON file containing array of boot nodes - // See `static/bootcluster/*.json` for cluster configurations provided - // out of box. You can pass absolute path, and if file at that path can be - // loaded, it will be used. Otherwise, file is supposed to be relative to - // `static/bootcluster` folder. - ConfigFile string + // RootNumber CHT root number + RootNumber int + + // RootHash is hash of CHT root for a given root number + RootHash string + + // BootNodes list of bootstrap nodes for a given network (Ropsten, Rinkeby, Homestead), + // for a given mode (production vs development) + BootNodes []string } // String dumps config object as nicely indented JSON @@ -214,8 +207,6 @@ func (c *BootClusterConfig) String() string { return string(data) } -//===================================================================================== - // NodeConfig stores configuration options for a node type NodeConfig struct { // DevMode is true when given configuration is to be used during development. @@ -320,6 +311,7 @@ func NewNodeConfig(dataDir string, networkID uint64, devMode bool) (*NodeConfig, RPCEnabled: RPCEnabledDefault, HTTPHost: HTTPHost, HTTPPort: HTTPPort, + APIModules: APIModules, WSHost: WSHost, WSPort: WSPort, MaxPeers: MaxPeers, @@ -328,14 +320,13 @@ func NewNodeConfig(dataDir string, networkID uint64, devMode bool) (*NodeConfig, LogFile: LogFile, LogLevel: LogLevel, LogToStderr: LogToStderr, - LightEthConfig: &LightEthConfig{ - Enabled: true, - DatabaseCache: DatabaseCache, - CHTRootConfigURL: CHTRootConfigURL, - }, BootClusterConfig: &BootClusterConfig{ - Enabled: true, - ConfigFile: BootClusterConfigFile, + Enabled: true, + BootNodes: []string{}, + }, + LightEthConfig: &LightEthConfig{ + Enabled: true, + DatabaseCache: DatabaseCache, }, WhisperConfig: &WhisperConfig{ Enabled: true, @@ -408,41 +399,12 @@ func (c *NodeConfig) Save() error { return nil } -// LoadBootClusterNodes loads boot nodes from a config file provided in BootClusterConfig -func (c *NodeConfig) LoadBootClusterNodes() ([]string, error) { - var bootnodes []string - var configData []byte - var err error - - filename := c.BootClusterConfig.ConfigFile - - log.Info("Loading boot nodes config file", "source", filename) - if _, err = os.Stat(filename); os.IsNotExist(err) { // load from static resources - configData, err = static.Asset("bootcluster/" + filename) - } else { - configData, err = ioutil.ReadFile(filename) - } - - if err != nil { - return nil, err - } - - // parse JSON - if err := json.Unmarshal(configData, &bootnodes); err != nil { - return nil, err - } - return bootnodes, nil -} - // updateConfig traverses configuration and adjusts dependent fields // (we have a development/production and mobile/full node dependent configurations) func (c *NodeConfig) updateConfig() error { if err := c.updateGenesisConfig(); err != nil { return err } - if err := c.updateRPCConfig(); err != nil { - return err - } if err := c.updateBootClusterConfig(); err != nil { return err } @@ -478,36 +440,55 @@ func (c *NodeConfig) updateGenesisConfig() error { return nil } -// updateBootClusterConfig populates cluster config file, depending on dev/prod and mobile/full settings +// updateBootClusterConfig loads boot nodes and CHT for a given network and mode. +// This is necessary until we have LES protocol support CHT sync, and better node +// discovery on mobile devices) func (c *NodeConfig) updateBootClusterConfig() error { - var configFile string - - switch c.NetworkID { - case MainNetworkID: - configFile = "homestead.prod.json" - case RopstenNetworkID: - configFile = "ropsten.prod.json" - case RinkebyNetworkID: - configFile = "rinkeby.prod.json" + if !c.BootClusterConfig.Enabled { + return nil } - if c.DevMode { - configFile = strings.Replace(configFile, "prod", "dev", 1) + // TODO: Remove this thing as this is an ugly hack. + // Once CHT sync sub-protocol is working in LES, we will rely on it, as it provides + // decentralized solution. For now, in order to avoid forcing users to long sync times + // we use central static resource + type subClusterConfig struct { + Number int `json:"number"` + Hash string `json:"hash"` + BootNodes []string `json:"bootnodes"` + } + type clusterConfig struct { + NetworkID int `json:"networkID"` + GenesisHash string `json:"genesisHash"` + Prod subClusterConfig `json:"prod"` + Dev subClusterConfig `json:"dev"` } - if len(configFile) > 0 { - c.BootClusterConfig.ConfigFile = configFile + client := &http.Client{Timeout: 5 * time.Second} + r, err := client.Get(BootClusterConfigURL + "?u=" + strconv.Itoa(int(time.Now().Unix()))) + if err != nil { + return err + } + defer r.Body.Close() + + var clusters []clusterConfig + err = json.NewDecoder(r.Body).Decode(&clusters) + if err != nil { + return err } - return nil -} - -// updateRPCConfig transforms RPC settings to meet requirements of a given configuration -func (c *NodeConfig) updateRPCConfig() error { - c.APIModules = ProdAPIModules - - if c.DevMode { - c.APIModules = DevAPIModules + for _, cluster := range clusters { + if cluster.NetworkID == int(c.NetworkID) { + c.BootClusterConfig.RootNumber = cluster.Prod.Number + c.BootClusterConfig.RootHash = cluster.Prod.Hash + c.BootClusterConfig.BootNodes = cluster.Prod.BootNodes + if c.DevMode { + c.BootClusterConfig.RootNumber = cluster.Dev.Number + c.BootClusterConfig.RootHash = cluster.Dev.Hash + c.BootClusterConfig.BootNodes = cluster.Dev.BootNodes + } + break + } } return nil diff --git a/geth/params/config_test.go b/geth/params/config_test.go index aa45582ab..ebbff308c 100644 --- a/geth/params/config_test.go +++ b/geth/params/config_test.go @@ -5,7 +5,6 @@ import ( "io/ioutil" "os" "path/filepath" - "reflect" "strings" "testing" @@ -13,6 +12,7 @@ import ( gethparams "github.com/ethereum/go-ethereum/params" "github.com/status-im/status-go/geth/params" . "github.com/status-im/status-go/geth/testing" + "github.com/stretchr/testify/require" ) var loadConfigTestCases = []struct { @@ -35,9 +35,7 @@ var loadConfigTestCases = []struct { } }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err == nil { - t.Fatal("error is expected, not thrown") - } + require.Error(t, err, "error is expected, not thrown") }, }, { @@ -47,9 +45,7 @@ var loadConfigTestCases = []struct { "Name": "TestStatusNode" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != params.ErrMissingDataDir { - t.Fatalf("expected error not thrown, expected: %v, thrown: %v", params.ErrMissingDataDir, err) - } + require.Equal(t, params.ErrMissingDataDir, err) }, }, { @@ -58,9 +54,7 @@ var loadConfigTestCases = []struct { "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != params.ErrMissingNetworkID { - t.Fatalf("expected error not thrown, expected: %v, thrown: %v", params.ErrMissingNetworkID, err) - } + require.Equal(t, params.ErrMissingNetworkID, err) }, }, { @@ -70,13 +64,8 @@ var loadConfigTestCases = []struct { "DataDir": "/storage/emulated/0/ethereum/" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - expectedDataDir := "/storage/emulated/0/ethereum/" - if nodeConfig.DataDir != expectedDataDir { - t.Fatalf("incorrect DataDir used, expected: %v, got: %v", expectedDataDir, nodeConfig.DataDir) - } + require.NoError(t, err) + require.Equal(t, "/storage/emulated/0/ethereum/", nodeConfig.DataDir) }, }, { @@ -86,22 +75,13 @@ var loadConfigTestCases = []struct { "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if _, err := os.Stat(dataDir); os.IsNotExist(err) { - t.Fatalf("data directory doesn't exist: %s", dataDir) - } + require.NoError(t, err) - expectedDataDir := dataDir - if nodeConfig.DataDir != expectedDataDir { - t.Fatalf("incorrect DataDir used, expected: %v, got: %v", expectedDataDir, nodeConfig.DataDir) - } + _, err = os.Stat(dataDir) + require.False(t, os.IsNotExist(err), "data directory doesn't exist") + require.Equal(t, dataDir, nodeConfig.DataDir) - expectedKeyStoreDir := filepath.Join(dataDir, params.KeyStoreDir) - if nodeConfig.KeyStoreDir != expectedKeyStoreDir { - t.Fatalf("incorrect KeyStoreDir used, expected: %v, got: %v", expectedKeyStoreDir, nodeConfig.KeyStoreDir) - } + require.Equal(t, filepath.Join(dataDir, params.KeyStoreDir), filepath.Join(dataDir, params.KeyStoreDir)) }, }, { @@ -112,18 +92,9 @@ var loadConfigTestCases = []struct { "KeyStoreDir": "/foo/bar" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - expectedDataDir := dataDir - if nodeConfig.DataDir != expectedDataDir { - t.Fatalf("incorrect DataDir used, expected: %v, got: %v", expectedDataDir, nodeConfig.DataDir) - } - - expectedKeyStoreDir := "/foo/bar" - if nodeConfig.KeyStoreDir != expectedKeyStoreDir { - t.Fatalf("incorrect KeyStoreDir used, expected: %v, got: %v", expectedKeyStoreDir, nodeConfig.KeyStoreDir) - } + require.NoError(t, err) + require.Equal(t, dataDir, nodeConfig.DataDir) + require.Equal(t, "/foo/bar", nodeConfig.KeyStoreDir) }, }, { @@ -141,44 +112,17 @@ var loadConfigTestCases = []struct { } }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) - if nodeConfig.NetworkID != 3 { - t.Fatal("wrong NetworkId") - } - - if nodeConfig.Name != "TestStatusNode" { - t.Fatal("wrong Name") - } - - if nodeConfig.HTTPPort != params.HTTPPort { - t.Fatal("wrong HTTPPort") - } - - if nodeConfig.HTTPHost != params.HTTPHost { - t.Fatal("wrong HTTPHost") - } - - if !nodeConfig.RPCEnabled { - t.Fatal("Wrong RPCEnabled flag") - } - - if nodeConfig.WSPort != 4242 { - t.Fatal("wrong WSPort") - } - - if nodeConfig.WSEnabled { - t.Fatal("wrong WSEnabled") - } - - if !nodeConfig.IPCEnabled { - t.Fatal("wrong IPCEnabled") - } - if nodeConfig.LightEthConfig.DatabaseCache != 64 { - t.Fatal("wrong LightEthConfig.DatabaseCache") - } + require.EqualValues(t, 3, nodeConfig.NetworkID) + require.Equal(t, "TestStatusNode", nodeConfig.Name) + require.Equal(t, params.HTTPPort, nodeConfig.HTTPPort) + require.Equal(t, params.HTTPHost, nodeConfig.HTTPHost) + require.True(t, nodeConfig.RPCEnabled) + require.False(t, nodeConfig.WSEnabled) + require.Equal(t, 4242, nodeConfig.WSPort) + require.True(t, nodeConfig.IPCEnabled) + require.Equal(t, 64, nodeConfig.LightEthConfig.DatabaseCache) }, }, { @@ -195,41 +139,25 @@ var loadConfigTestCases = []struct { } }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) genesis := new(core.Genesis) - if err := json.Unmarshal([]byte(nodeConfig.LightEthConfig.Genesis), genesis); err != nil { - t.Fatal(err) - } + err = json.Unmarshal([]byte(nodeConfig.LightEthConfig.Genesis), genesis) + require.NoError(t, err) + chainConfig := genesis.Config refChainConfig := gethparams.TestnetChainConfig - if chainConfig.HomesteadBlock.Cmp(refChainConfig.HomesteadBlock) != 0 { - t.Fatal("invalid chainConfig.HomesteadBlock") - } - if chainConfig.DAOForkBlock != nil { // already forked - t.Fatal("invalid chainConfig.DAOForkBlock") - } - if chainConfig.DAOForkSupport != refChainConfig.DAOForkSupport { - t.Fatal("invalid chainConfig.DAOForkSupport") - } - if chainConfig.EIP150Block.Cmp(refChainConfig.EIP150Block) != 0 { - t.Fatal("invalid chainConfig.EIP150Block") - } - if chainConfig.EIP150Hash != refChainConfig.EIP150Hash { - t.Fatal("invalid chainConfig.EIP150Hash") - } - if chainConfig.EIP155Block.Cmp(refChainConfig.EIP155Block) != 0 { - t.Fatal("invalid chainConfig.EIP155Block") - } - if chainConfig.EIP158Block.Cmp(refChainConfig.EIP158Block) != 0 { - t.Fatal("invalid chainConfig.EIP158Block") - } - if chainConfig.ChainId.Cmp(refChainConfig.ChainId) != 0 { - t.Fatal("invalid chainConfig.ChainId") - } + require.Empty(t, chainConfig.HomesteadBlock.Cmp(refChainConfig.HomesteadBlock), "invalid chainConfig.HomesteadBlock") + require.Nil(t, chainConfig.DAOForkBlock) + require.Equal(t, refChainConfig.DAOForkSupport, chainConfig.DAOForkSupport) + + require.Empty(t, chainConfig.EIP150Block.Cmp(refChainConfig.EIP150Block)) + require.Equal(t, refChainConfig.EIP150Hash, chainConfig.EIP150Hash) + + require.Empty(t, chainConfig.EIP155Block.Cmp(refChainConfig.EIP155Block)) + require.Empty(t, chainConfig.EIP158Block.Cmp(refChainConfig.EIP158Block)) + require.Empty(t, chainConfig.ChainId.Cmp(refChainConfig.ChainId)) }, }, { @@ -246,39 +174,22 @@ var loadConfigTestCases = []struct { } }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) genesis := new(core.Genesis) - if err := json.Unmarshal([]byte(nodeConfig.LightEthConfig.Genesis), genesis); err != nil { - t.Fatal(err) - } + err = json.Unmarshal([]byte(nodeConfig.LightEthConfig.Genesis), genesis) + require.NoError(t, err) + chainConfig := genesis.Config - if chainConfig.HomesteadBlock.Cmp(gethparams.MainNetHomesteadBlock) != 0 { - t.Fatal("invalid chainConfig.HomesteadBlock") - } - if chainConfig.DAOForkBlock.Cmp(gethparams.MainNetDAOForkBlock) != 0 { - t.Fatal("invalid chainConfig.DAOForkBlock") - } - if !chainConfig.DAOForkSupport { - t.Fatal("invalid chainConfig.DAOForkSupport") - } - if chainConfig.EIP150Block.Cmp(gethparams.MainNetHomesteadGasRepriceBlock) != 0 { - t.Fatal("invalid chainConfig.EIP150Block") - } - if chainConfig.EIP150Hash != gethparams.MainNetHomesteadGasRepriceHash { - t.Fatal("invalid chainConfig.EIP150Hash") - } - if chainConfig.EIP155Block.Cmp(gethparams.MainNetSpuriousDragon) != 0 { - t.Fatal("invalid chainConfig.EIP155Block") - } - if chainConfig.EIP158Block.Cmp(gethparams.MainNetSpuriousDragon) != 0 { - t.Fatal("invalid chainConfig.EIP158Block") - } - if chainConfig.ChainId.Cmp(gethparams.MainNetChainID) != 0 { - t.Fatal("invalid chainConfig.ChainId") - } + + require.Empty(t, chainConfig.HomesteadBlock.Cmp(gethparams.MainNetHomesteadBlock)) + require.Empty(t, chainConfig.DAOForkBlock.Cmp(gethparams.MainNetDAOForkBlock)) + require.True(t, chainConfig.DAOForkSupport) + require.Empty(t, chainConfig.EIP150Block.Cmp(gethparams.MainNetHomesteadGasRepriceBlock)) + require.Equal(t, gethparams.MainNetHomesteadGasRepriceHash, chainConfig.EIP150Hash) + require.Empty(t, chainConfig.EIP155Block.Cmp(gethparams.MainNetSpuriousDragon)) + require.Empty(t, chainConfig.EIP158Block.Cmp(gethparams.MainNetSpuriousDragon)) + require.Empty(t, chainConfig.ChainId.Cmp(gethparams.MainNetChainID)) }, }, { @@ -292,14 +203,8 @@ var loadConfigTestCases = []struct { "WSEnabled": false }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - networkId := uint64(311) - if nodeConfig.NetworkID != networkId { - t.Fatalf("unexpected NetworkID, expected: %v, got: %v", networkId, nodeConfig.NetworkID) - } + require.NoError(t, err) + require.EqualValues(t, 311, nodeConfig.NetworkID) }, }, { @@ -309,36 +214,32 @@ var loadConfigTestCases = []struct { "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + // Bootnodes for dev and prod modes are the same so no need for a separate Ropsten Prod test. - if nodeConfig.BootClusterConfig.ConfigFile != params.BootClusterConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - params.BootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "91825fffecb5678167273955deaddbf03c26ae04287cfda61403c0bad5ceab8d", nodeConfig.BootClusterConfig.RootHash) + require.Equal(t, 259, nodeConfig.BootClusterConfig.RootNumber) - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("boot cluster is expected to be enabled by default") - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ - "enode://da3bf389a031f33fb55c9f5f54fde8473912402d27fffaa50efd74c0d0515f3a61daf6d52151f2876b19c15828e6f670352bff432b5ec457652e74755e8c864f@51.15.62.116:30303", - "enode://584c0db89b00719e9e7b1b5c32a4a8942f379f4d5d66bb69f9c7fa97fa42f64974e7b057b35eb5a63fd7973af063f9a1d32d8c60dbb4854c64cb8ab385470258@51.15.35.2:30303", - "enode://e71ba996b923e4756783375e0ed1f29963b7f759305926315d3cf9a71364d2980dbc86b1c1549812c720b38f60d347149f1ba33681c5cd4c8fca4ee8116efec6@51.15.35.70:30303", - "enode://829f09a946bcac67afbd7b8face82c48106af6a6b2507c007de6c79b2dbdf5544368afdf93cf5218d6d75a1f0219e6312db48bcc2f0fdfacb1d82c81f061d623@51.15.54.229:30303", - "enode://e80276aabb7682a4a659f4341c1199de79d91a2e500a6ee9bed16ed4ce927ba8d32ba5dea357739ffdf2c5bcc848d3064bb6f149f0b4249c1f7e53f8bf02bfc8@51.15.39.57:30303", - } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) + "enode://7ab298cedc4185a894d21d8a4615262ec6bdce66c9b6783878258e0d5b31013d30c9038932432f70e5b2b6a5cd323bf820554fcb22fbc7b45367889522e9c449@51.15.63.93:30303", + "enode://f59e8701f18c79c5cbc7618dc7bb928d44dc2f5405c7d693dad97da2d8585975942ec6fd36d3fe608bfdc7270a34a4dd00f38cfe96b2baa24f7cd0ac28d382a1@51.15.79.88:30303", + "enode://e2a3587b7b41acfc49eddea9229281905d252efba0baf565cf6276df17faf04801b7879eead757da8b5be13b05f25e775ab6d857ff264bc53a89c027a657dd10@51.15.45.114:30303", + "enode://fe991752c4ceab8b90608fbf16d89a5f7d6d1825647d4981569ebcece1b243b2000420a5db721e214231c7a6da3543fa821185c706cbd9b9be651494ec97f56a@51.15.67.119:30303", + "enode://482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7@51.15.75.138:30303", + "enode://9e99e183b5c71d51deb16e6b42ac9c26c75cfc95fff9dfae828b871b348354cbecf196dff4dd43567b26c8241b2b979cb4ea9f8dae2d9aacf86649dafe19a39a@51.15.79.176:30303", + "enode://12d52c3796700fb5acff2c7d96df7bbb6d7109b67f3442ee3d99ac1c197016cddb4c3568bbeba05d39145c59c990cd64f76bc9b00d4b13f10095c49507dd4cf9@51.15.63.110:30303", + "enode://0f7c65277f916ff4379fe520b875082a56e587eb3ce1c1567d9ff94206bdb05ba167c52272f20f634cd1ebdec5d9dfeb393018bfde1595d8e64a717c8b46692f@51.15.54.150:30303", + "enode://e006f0b2dc98e757468b67173295519e9b6d5ff4842772acb18fd055c620727ab23766c95b8ee1008dea9e8ef61e83b1515ddb3fb56dbfb9dbf1f463552a7c9f@212.47.237.127:30303", + "enode://d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2@51.15.132.235:30303", + "enode://ea37c9724762be7f668e15d3dc955562529ab4f01bd7951f0b3c1960b75ecba45e8c3bb3c8ebe6a7504d9a40dd99a562b13629cc8e5e12153451765f9a12a61d@163.172.189.205:30303", + "enode://88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9@163.172.157.61:30303", + "enode://ce6854c2c77a8800fcc12600206c344b8053bb90ee3ba280e6c4f18f3141cdc5ee80bcc3bdb24cbc0e96dffd4b38d7b57546ed528c00af6cd604ab65c4d528f6@163.172.153.124:30303", + "enode://00ae60771d9815daba35766d463a82a7b360b3a80e35ab2e0daa25bdc6ca6213ff4c8348025e7e1a908a8f58411a364fe02a0fb3c2aa32008304f063d8aaf1a2@163.172.132.85:30303", + "enode://86ebc843aa51669e08e27400e435f957918e39dc540b021a2f3291ab776c88bbda3d97631639219b6e77e375ab7944222c47713bdeb3251b25779ce743a39d70@212.47.254.155:30303", } + require.Equal(t, expectedEnodes, enodes) }, }, { @@ -351,236 +252,130 @@ var loadConfigTestCases = []struct { } }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if nodeConfig.BootClusterConfig.Enabled { - t.Fatal("boot cluster is expected to be disabled") - } + require.NoError(t, err) + require.False(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be disabled") + require.Empty(t, nodeConfig.BootClusterConfig.RootHash) + require.Empty(t, nodeConfig.BootClusterConfig.RootNumber) }, }, { `select boot cluster (Ropsten Prod)`, `{ - "NetworkId": 311, + "NetworkId": 3, "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "ropsten.prod.json" - } + "DevMode": false }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "91825fffecb5678167273955deaddbf03c26ae04287cfda61403c0bad5ceab8d", nodeConfig.BootClusterConfig.RootHash) + require.Equal(t, 259, nodeConfig.BootClusterConfig.RootNumber) - expectedConfigFile := "ropsten.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ - "enode://fbddff478e18292dc32b90f139bf773a08da89ffe29208e4de0091f6c589e60fccfaf16d4f4a76be49f57782c061ec8ea97078601c6f367feabda740f5ce8246@51.15.55.219:30303", - "enode://4e5ee0487a4d8349ab9a9925b00eed0f976d98972c5a22f43fd50d1424897757032c36f273b434a4d3e013a2544eca74a9d1a0419f9f07f7bb43182a73df3690@51.15.35.110:30303", - "enode://18efd9afb60443e00fed602cc0df526cd1d8543d2f6037df9380eb973d30b5fd04ac9f221053f82034581051bfd6e54356a99af2255f1a674d71d17440a6c95b@51.15.34.3:30303", - "enode://5b99c0cb372299fd3f2d94612a682990722eb7c3a252dacefc8270eb7f172fc699c1ddfad826fbfc979270538e8d89bd6919703eb9ef526eac0a45e9fb455123@51.15.56.154:30303", - "enode://0e1d4d0fcfe888bf8a478b0fd89760a47733a5c04cd47de353295a6eb8dde8f54821b31196527d0c5c73a7024dc9ff34127692d237840fc09c312b3a19cd28fe@51.15.60.23:30303", - } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) + "enode://7ab298cedc4185a894d21d8a4615262ec6bdce66c9b6783878258e0d5b31013d30c9038932432f70e5b2b6a5cd323bf820554fcb22fbc7b45367889522e9c449@51.15.63.93:30303", + "enode://f59e8701f18c79c5cbc7618dc7bb928d44dc2f5405c7d693dad97da2d8585975942ec6fd36d3fe608bfdc7270a34a4dd00f38cfe96b2baa24f7cd0ac28d382a1@51.15.79.88:30303", + "enode://e2a3587b7b41acfc49eddea9229281905d252efba0baf565cf6276df17faf04801b7879eead757da8b5be13b05f25e775ab6d857ff264bc53a89c027a657dd10@51.15.45.114:30303", + "enode://fe991752c4ceab8b90608fbf16d89a5f7d6d1825647d4981569ebcece1b243b2000420a5db721e214231c7a6da3543fa821185c706cbd9b9be651494ec97f56a@51.15.67.119:30303", + "enode://482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7@51.15.75.138:30303", + "enode://9e99e183b5c71d51deb16e6b42ac9c26c75cfc95fff9dfae828b871b348354cbecf196dff4dd43567b26c8241b2b979cb4ea9f8dae2d9aacf86649dafe19a39a@51.15.79.176:30303", + "enode://12d52c3796700fb5acff2c7d96df7bbb6d7109b67f3442ee3d99ac1c197016cddb4c3568bbeba05d39145c59c990cd64f76bc9b00d4b13f10095c49507dd4cf9@51.15.63.110:30303", + "enode://0f7c65277f916ff4379fe520b875082a56e587eb3ce1c1567d9ff94206bdb05ba167c52272f20f634cd1ebdec5d9dfeb393018bfde1595d8e64a717c8b46692f@51.15.54.150:30303", + "enode://e006f0b2dc98e757468b67173295519e9b6d5ff4842772acb18fd055c620727ab23766c95b8ee1008dea9e8ef61e83b1515ddb3fb56dbfb9dbf1f463552a7c9f@212.47.237.127:30303", + "enode://d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2@51.15.132.235:30303", + "enode://ea37c9724762be7f668e15d3dc955562529ab4f01bd7951f0b3c1960b75ecba45e8c3bb3c8ebe6a7504d9a40dd99a562b13629cc8e5e12153451765f9a12a61d@163.172.189.205:30303", + "enode://88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9@163.172.157.61:30303", + "enode://ce6854c2c77a8800fcc12600206c344b8053bb90ee3ba280e6c4f18f3141cdc5ee80bcc3bdb24cbc0e96dffd4b38d7b57546ed528c00af6cd604ab65c4d528f6@163.172.153.124:30303", + "enode://00ae60771d9815daba35766d463a82a7b360b3a80e35ab2e0daa25bdc6ca6213ff4c8348025e7e1a908a8f58411a364fe02a0fb3c2aa32008304f063d8aaf1a2@163.172.132.85:30303", + "enode://86ebc843aa51669e08e27400e435f957918e39dc540b021a2f3291ab776c88bbda3d97631639219b6e77e375ab7944222c47713bdeb3251b25779ce743a39d70@212.47.254.155:30303", } + require.Equal(t, expectedEnodes, enodes) }, }, { `select boot cluster (Rinkeby Dev)`, `{ - "NetworkId": 311, - "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "rinkeby.dev.json" - } + "NetworkId": 4, + "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "rinkeby-dev", nodeConfig.BootClusterConfig.RootHash) + require.True(t, nodeConfig.BootClusterConfig.RootNumber >= 66) - expectedConfigFile := "rinkeby.dev.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ "enode://7512c8f6e7ffdcc723cf77e602a1de9d8cc2e8ad35db309464819122cd773857131aee390fec33894db13da730c8432bb248eed64039e3810e156e979b2847cb@51.15.78.243:30303", "enode://1cc27a5a41130a5c8b90db5b2273dc28f7b56f3edfc0dcc57b665d451274b26541e8de49ea7a074281906a82209b9600239c981163b6ff85c3038a8e2bc5d8b8@51.15.68.93:30303", "enode://798d17064141b8f88df718028a8272b943d1cb8e696b3dab56519c70b77b1d3469b56b6f4ce3788457646808f5c7299e9116626f2281f30b959527b969a71e4f@51.15.75.244:30303", } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) - } + require.Equal(t, expectedEnodes, enodes) }, }, { `select boot cluster (Rinkeby Prod)`, `{ - "NetworkId": 311, + "NetworkId": 4, "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "rinkeby.prod.json" - } + "DevMode": false }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "rinkeby-prod", nodeConfig.BootClusterConfig.RootHash) + require.True(t, nodeConfig.BootClusterConfig.RootNumber >= 66) - expectedConfigFile := "rinkeby.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ "enode://fda3f6273a0f2da4ac5858d1f52e5afaf9def281121be3d37558c67d4d9ca26c6ad7a0520b2cd7454120fb770e86d5760487c9924b2166e65485f606e56d60fc@51.15.69.144:30303", "enode://ba41aa829287a0a9076d9bffed97c8ce2e491b99873288c9e886f16fd575306ac6c656db4fbf814f5a9021aec004ffa9c0ae8650f92fd10c12eeb7c364593eb3@51.15.69.147:30303", "enode://28ecf5272b560ca951f4cd7f1eb8bd62da5853b026b46db432c4b01797f5b0114819a090a72acd7f32685365ecd8e00450074fa0673039aefe10f3fb666e0f3f@51.15.76.249:30303", } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) - } + require.Equal(t, expectedEnodes, enodes) }, }, { `select boot cluster (Homestead Dev)`, `{ - "NetworkId": 311, - "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "homestead.dev.json" - } + "NetworkId": 1, + "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "85e4286fe0a730390245c49de8476977afdae0eb5530b277f62a52b12313d50f", nodeConfig.BootClusterConfig.RootHash) + require.True(t, nodeConfig.BootClusterConfig.RootNumber >= 805) - expectedConfigFile := "homestead.dev.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ "enode://93833be81c3d1bdb2ae5cde258c8f82ad1011a1bea8eb49fe50b0af394d4f7f7e45974356870552f36744efd732692a64865d1e8b64114eaf89a1bad0a1903a2@51.15.64.29:30303", "enode://d76854bc54144b2269c5316d5f00f0a194efee2fb8d31e7b1939effd7e17f25773f8dc7fda8c4eb469450799da7f39b4e364e2a278d91b53539dcbb10b139635@51.15.73.37:30303", "enode://57874205931df976079e4ff8ebb5756461030fb00f73486bd5ec4ae6ed6ba98e27d09f58e59bd85281d24084a6062bc8ab514dbcdaa9678fc3001d47772e626e@51.15.75.213:30303", } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) - } + require.Equal(t, expectedEnodes, enodes) }, }, { `select boot cluster (Homestead Prod)`, `{ - "NetworkId": 311, + "NetworkId": 1, "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "homestead.prod.json" - } + "DevMode": false }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + require.NoError(t, err) + require.True(t, nodeConfig.BootClusterConfig.Enabled, "boot cluster is expected to be enabled by default") + require.Equal(t, "85e4286fe0a730390245c49de8476977afdae0eb5530b277f62a52b12313d50f", nodeConfig.BootClusterConfig.RootHash) + require.True(t, nodeConfig.BootClusterConfig.RootNumber >= 805) - expectedConfigFile := "homestead.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } + enodes := nodeConfig.BootClusterConfig.BootNodes expectedEnodes := []string{ "enode://f3b0e5dca730962bae814f3402b8f8a296644c33e8d7a95bd1ab313143a752c77076a03bcb76263570f2f34d4eb530f1daf5054c0990921a872a34eb505dcedf@51.15.73.129:30303", "enode://fce0d1c2292829b0eccce444f8943f88087ce00a5e910b157972ee1658a948d23c7a046f26567f73b2b18d126811509d7ef1de5be9b1decfcbb14738a590c477@51.15.75.187:30303", "enode://3b4b9fa02ae8d54c2db51a674bc93d85649b4775f22400f74ae25e9f1c665baa3bcdd33cadd2c1a93cd08a6af984cb605fbb61ec0d750a11d48d4080298af008@51.15.77.193:30303", } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) - } - }, - }, - { - `select boot cluster (custom JSON, via absolute path)`, - `{ - "NetworkId": 311, - "DataDir": "$TMPDIR", - "BootClusterConfig": { - "ConfigFile": "$TMPDIR/bootstrap-cluster.json" - } - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - expectedConfigFile := filepath.Join(dataDir, "bootstrap-cluster.json") - if nodeConfig.BootClusterConfig.ConfigFile != expectedConfigFile { - t.Fatalf("unexpected BootClusterConfigFile, expected: %v, got: %v", - expectedConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - - enodes, err := nodeConfig.LoadBootClusterNodes() - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - expectedEnodes := []string{ - "enode://foobar@41.41.41.41:30300", - "enode://foobaz@42.42.42.42:30302", - } - if len(enodes) != len(expectedEnodes) { - t.Fatalf("wrong number of enodes, expected: %d, got: %d", len(expectedEnodes), len(enodes)) - } - if !reflect.DeepEqual(enodes, expectedEnodes) { - t.Fatalf("wrong list of enodes, expected: \n%v,\n\ngot:\n%v", expectedEnodes, enodes) - } + require.Equal(t, expectedEnodes, enodes) }, }, { @@ -590,22 +385,9 @@ var loadConfigTestCases = []struct { "DataDir": "$TMPDIR" }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if !nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", true, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - if nodeConfig.BootClusterConfig.ConfigFile != params.BootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - params.BootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } + require.NoError(t, err) + require.True(t, nodeConfig.DevMode) + require.True(t, nodeConfig.BootClusterConfig.Enabled) }, }, { @@ -616,183 +398,9 @@ var loadConfigTestCases = []struct { "DevMode": false }`, func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", false, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "ropsten.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Homestead/Dev)`, - `{ - "NetworkId": 1, - "DataDir": "$TMPDIR", - "DevMode": true - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if !nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", true, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "homestead.dev.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Homestead/Prod)`, - `{ - "NetworkId": 1, - "DataDir": "$TMPDIR", - "DevMode": false - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", false, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "homestead.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Ropsten/Dev)`, - `{ - "NetworkId": 3, - "DataDir": "$TMPDIR" - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if !nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", true, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "ropsten.dev.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Ropsten/Prod)`, - `{ - "NetworkId": 3, - "DataDir": "$TMPDIR", - "DevMode": false - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", false, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "ropsten.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Rinkeby/Dev)`, - `{ - "NetworkId": 4, - "DataDir": "$TMPDIR" - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if !nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", true, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "rinkeby.dev.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } - }, - }, - { - `populate bootstrap config (Rinkeby/Prod)`, - `{ - "NetworkId": 4, - "DataDir": "$TMPDIR", - "DevMode": false - }`, - func(t *testing.T, dataDir string, nodeConfig *params.NodeConfig, err error) { - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - - if nodeConfig.DevMode { - t.Fatalf("unexpected dev mode: expected: %v, got: %v", false, nodeConfig.DevMode) - } - - if !nodeConfig.BootClusterConfig.Enabled { - t.Fatal("expected boot cluster to be enabled") - } - - expectedBootClusterConfigFile := "rinkeby.prod.json" - if nodeConfig.BootClusterConfig.ConfigFile != expectedBootClusterConfigFile { - t.Fatalf("unexpected bootcluster config file, expected: %v, got: %v", - expectedBootClusterConfigFile, nodeConfig.BootClusterConfig.ConfigFile) - } + require.NoError(t, err) + require.False(t, nodeConfig.DevMode) + require.True(t, nodeConfig.BootClusterConfig.Enabled) }, }, } @@ -806,9 +414,8 @@ func TestLoadNodeConfig(t *testing.T) { // create sample Bootstrap Cluster Config bootstrapConfig := []byte(`["enode://foobar@41.41.41.41:30300", "enode://foobaz@42.42.42.42:30302"]`) - if err = ioutil.WriteFile(filepath.Join(tmpDir, "bootstrap-cluster.json"), bootstrapConfig, os.ModePerm); err != nil { - t.Fatal(err) - } + err = ioutil.WriteFile(filepath.Join(tmpDir, "bootstrap-cluster.json"), bootstrapConfig, os.ModePerm) + require.NoError(t, err) t.Log(tmpDir) for _, testCase := range loadConfigTestCases { @@ -822,32 +429,24 @@ func TestLoadNodeConfig(t *testing.T) { func TestConfigWriteRead(t *testing.T) { configReadWrite := func(networkId uint64, refFile string) { tmpDir, err := ioutil.TempDir(os.TempDir(), "geth-config-tests") - if err != nil { - t.Fatal(err) - } + require.Nil(t, err) defer os.RemoveAll(tmpDir) // nolint: errcheck nodeConfig, err := params.NewNodeConfig(tmpDir, networkId, true) - if err != nil { - t.Fatalf("cannot create new config object: %v", err) - } + require.Nil(t, err, "cannot create new config object") - if err := nodeConfig.Save(); err != nil { - t.Fatalf("cannot persist configuration: %v", err) - } + err = nodeConfig.Save() + require.Nil(t, err, "cannot persist configuration") loadedConfigData, err := ioutil.ReadFile(filepath.Join(nodeConfig.DataDir, "config.json")) - if err != nil { - t.Fatalf("cannot read configuration from disk: %v", err) - } + require.Nil(t, err, "cannot read configuration from disk") refConfigData := LoadFromFile(refFile) refConfigData = strings.Replace(refConfigData, "$TMPDIR", nodeConfig.DataDir, -1) refConfigData = strings.Replace(refConfigData, "$VERSION", params.Version, -1) - if string(loadedConfigData) != refConfigData { - t.Fatalf("configuration mismatch,\nexpected: %v\ngot: %v", refConfigData, string(loadedConfigData)) - } + + require.EqualValues(t, refConfigData, loadedConfigData) } configReadWrite(params.RinkebyNetworkID, "testdata/config.rinkeby.json") diff --git a/geth/params/defaults.go b/geth/params/defaults.go index 642c382f3..803c21891 100644 --- a/geth/params/defaults.go +++ b/geth/params/defaults.go @@ -1,9 +1,5 @@ package params -import ( - "github.com/ethereum/go-ethereum/common" -) - const ( // ClientIdentifier is client identifier to advertise over the network ClientIdentifier = "StatusIM" @@ -27,11 +23,8 @@ const ( // HTTPPort is HTTP-RPC port (replaced in unit tests) HTTPPort = 8545 - // DevAPIModules is a list of modules to expose via any type of RPC (HTTP, IPC) during development - DevAPIModules = "db,eth,net,web3,shh,personal,admin" - - // ProdAPIModules is a list of modules to expose via any type of RPC (HTTP, IPC) in production - ProdAPIModules = "eth,net,web3,shh,personal" + // APIModules is a list of modules to expose via any type of RPC (HTTP, IPC, in-proc) + APIModules = "db,eth,net,web3,shh,personal,admin" // WSHost is a host interface for the websocket RPC server WSHost = "localhost" @@ -57,7 +50,11 @@ const ( // CHTRootConfigURL defines URL to file containing hard-coded CHT roots // TODO remove this hack, once CHT sync is implemented on LES side - CHTRootConfigURL = "https://gist.githubusercontent.com/farazdagi/a8d36e2818b3b2b6074d691da63a0c36/raw/" + CHTRootConfigURL = "https://gist.githubusercontent.com/tiabc/83ed515fbb0c0e9d39700a6279072b6a/raw/a8c7b08488fab3c1d9139b18af33da3df823e3ff/cht.json" + + // BootClusterConfigURL defines URL to file containing hard-coded CHT roots and boot nodes + // TODO remove this hack, once CHT sync is implemented on LES side + BootClusterConfigURL = "https://gist.githubusercontent.com/tiabc/83ed515fbb0c0e9d39700a6279072b6a/raw/a8c7b08488fab3c1d9139b18af33da3df823e3ff/cht.json" // LogFile defines where to write logs to LogFile = "geth.log" @@ -95,13 +92,4 @@ const ( // RinkebyNetworkID is id of a test network (on PoA) RinkebyNetworkID = 4 - - // BootClusterConfigFile is default config file containing boot node list (as JSON array) - BootClusterConfigFile = "ropsten.dev.json" -) - -var ( - RopstenNetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") - RinkebyNetGenesisHash = common.HexToHash("0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177") - MainNetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") ) diff --git a/geth/params/testdata/config.mainnet.json b/geth/params/testdata/config.mainnet.json index 9e1335671..7b99d490e 100755 --- a/geth/params/testdata/config.mainnet.json +++ b/geth/params/testdata/config.mainnet.json @@ -24,13 +24,18 @@ "LogToStderr": true, "BootClusterConfig": { "Enabled": true, - "ConfigFile": "homestead.dev.json" + "RootNumber": 805, + "RootHash": "85e4286fe0a730390245c49de8476977afdae0eb5530b277f62a52b12313d50f", + "BootNodes": [ + "enode://93833be81c3d1bdb2ae5cde258c8f82ad1011a1bea8eb49fe50b0af394d4f7f7e45974356870552f36744efd732692a64865d1e8b64114eaf89a1bad0a1903a2@51.15.64.29:30303", + "enode://d76854bc54144b2269c5316d5f00f0a194efee2fb8d31e7b1939effd7e17f25773f8dc7fda8c4eb469450799da7f39b4e364e2a278d91b53539dcbb10b139635@51.15.73.37:30303", + "enode://57874205931df976079e4ff8ebb5756461030fb00f73486bd5ec4ae6ed6ba98e27d09f58e59bd85281d24084a6062bc8ab514dbcdaa9678fc3001d47772e626e@51.15.75.213:30303" + ] }, "LightEthConfig": { "Enabled": true, "Genesis": "{\"config\":{\"chainId\":1,\"homesteadBlock\":1150000,\"daoForkBlock\":1920000,\"daoForkSupport\":true,\"eip150Block\":2463000,\"eip150Hash\":\"0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0\",\"eip155Block\":2675000,\"eip158Block\":2675000,\"ethash\":{}},\"nonce\":\"0x42\",\"timestamp\":\"0x0\",\"parentHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"extraData\":\"0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa\",\"gasLimit\":\"0x1388\",\"difficulty\":\"0x400000000\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"coinbase\":\"0x0000000000000000000000000000000000000000\",\"alloc\":{\"000d836201318ec6899a67540690382780743280\":{\"balance\":\"0xad78ebc5ac6200000\"},\"001762430ea9c3a26e5749afdb70da5f78ddbb8c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"001d14804b399c6ef80e64576f657660804fec0b\":{\"balance\":\"0xe3aeb5737240a00000\"},\"0032403587947b9f15622a68d104d54d33dbd1cd\":{\"balance\":\"0x433874f632cc60000\"},\"00497e92cdc0e0b963d752b2296acb87da828b24\":{\"balance\":\"0xa8f649fe7c6180000\"},\"004bfbe1546bc6c65b5c7eaa55304b38bbfec6d3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"005a9c03f69d17d66cbb8ad721008a9ebbb836fb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"005d0ee8155ec0a6ff6808552ca5f16bb5be323a\":{\"balance\":\"0xaadec983fcff40000\"},\"007622d84a234bb8b078230fcf84b67ae9a8acae\":{\"balance\":\"0x25e1cc519952f80000\"},\"007b9fc31905b4994b04c9e2cfdc5e2770503f42\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"007f4a23ca00cd043d25c2888c1aa5688f81a344\":{\"balance\":\"0x29f0a95bfbf7290000\"},\"008639dabbe3aeac887b5dc0e43e13bcd287d76c\":{\"balance\":\"0x10d0e3c87d6e2c0000\"},\"0089508679abf8c71bf6781687120e3e6a84584d\":{\"balance\":\"0x6194049f30f7200000\"},\"008fc7cbadffbd0d7fe44f8dfd60a79d721a1c9c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"009560a3de627868f91fa8bfe1c1b7afaf08186b\":{\"balance\":\"0x1c67f5f7baa0b00000\"},\"00969747f7a5b30645fe00e44901435ace24cc37\":{\"balance\":\"0x5c283d410394100000\"},\"009a6d7db326679b77c90391a7476d238f3ba33e\":{\"balance\":\"0xada55474b81340000\"},\"009eef0a0886056e3f69211853b9b7457f3782e4\":{\"balance\":\"0xa2a878069b28e00000\"},\"009fdbf44e1f4a6362b769c39a475f95a96c2bc7\":{\"balance\":\"0x1e931283ccc8500000\"},\"00a5797f52c9d58f189f36b1d45d1bf6041f2f6b\":{\"balance\":\"0x127d1b3461acd1a0000\"},\"00aa5381b2138ebeffc191d5d8c391753b7098d2\":{\"balance\":\"0x35abb09ffedeb68000\"},\"00aada25ea2286709abb422d41923fd380cd04c7\":{\"balance\":\"0x233df3299f61720000\"},\"00acbfb2f25a5485c739ef70a44eeeeb7c65a66f\":{\"balance\":\"0x56bc75e2d63100000\"},\"00acc6f082a442828764d11f58d6894ae408f073\":{\"balance\":\"0xcb49b44ba602d800000\"},\"00b277b099a8e866ca0ec65bcb87284fd142a582\":{\"balance\":\"0x6acb3df27e1f880000\"},\"00bdd4013aa31c04616c2bc9785f2788f915679b\":{\"balance\":\"0xb9f65d00f63c0000\"},\"00c27d63fde24b92ee8a1e7ed5d26d8dc5c83b03\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"00c40fe2095423509b9fd9b754323158af2310f3\":{\"balance\":\"0x0\"},\"00d75ed60c774f8b3a5a5173fb1833ad7105a2d9\":{\"balance\":\"0x6cb7e74867d5e60000\"},\"00d78d89b35f472716eceafebf600527d3a1f969\":{\"balance\":\"0x5e0549c9632e1d80000\"},\"00dae27b350bae20c5652124af5d8b5cba001ec1\":{\"balance\":\"0x22b1c8c1227a00000\"},\"00dc01cbf44978a42e8de8e436edf94205cfb6ec\":{\"balance\":\"0x4f0febbcda8cb40000\"},\"00e681bc2d10db62de85848324492250348e90bf\":{\"balance\":\"0x43c33c1937564800000\"},\"00f463e137dcf625fbf3bca39eca98d2b968cf7f\":{\"balance\":\"0x14061b9d77a5e980000\"},\"010007394b8b7565a1658af88ce463499135d6b7\":{\"balance\":\"0x56bc75e2d63100000\"},\"010df1df4bed23760d2d1c03781586ddf7918e54\":{\"balance\":\"0x340aad21b3b700000\"},\"010f4a98dfa1d9799bf5c796fb550efbe7ecd877\":{\"balance\":\"0x1b2f292236292c70000\"},\"01155057002f6b0d18acb9388d3bc8129f8f7a20\":{\"balance\":\"0x48a43c54602f700000\"},\"01226e0ad8d62277b162621c62c928e96e0b9a8c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0126e12ebc17035f35c0e9d11dd148393c405d7a\":{\"balance\":\"0x6c660645aa47180000\"},\"012f396a2b5eb83559bac515e5210df2c8c362ba\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0134ff38155fabae94fd35c4ffe1d79de7ef9c59\":{\"balance\":\"0x35659ef93f0fc40000\"},\"0136a5af6c3299c6b5f005fdaddb148c070b299b\":{\"balance\":\"0x11aa9ac15f1280000\"},\"01488ad3da603c4cdd6cb0b7a1e30d2a30c8fc38\":{\"balance\":\"0xad78ebc5ac6200000\"},\"014974a1f46bf204944a853111e52f1602617def\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"014b7f67b14f5d983d87014f570c8b993b9872b5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0151fa5d17a2dce2d7f1eb39ef7fe2ad213d5d89\":{\"balance\":\"0xd8d726b7177a800000\"},\"01577afd4e50890247c9b10d44af73229aec884f\":{\"balance\":\"0x24dce54d34a1a00000\"},\"015f097d9acddcddafaf2a107eb93a40fc94b04c\":{\"balance\":\"0x43c33c1937564800000\"},\"0169c1c210eae845e56840412e1f65993ea90fb4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"016b60bb6d67928c29fd0313c666da8f1698d9c5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"016c85e1613b900fa357b8283b120e65aefcdd08\":{\"balance\":\"0x2b5d9784a97cd50000\"},\"018492488ba1a292342247b31855a55905fef269\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"018f20a27b27ec441af723fd9099f2cbb79d6263\":{\"balance\":\"0x75792a8abdef7c0000\"},\"0191eb547e7bf6976b9b1b577546761de65622e2\":{\"balance\":\"0x6c6b4c4da6ddbe0000\"},\"019d709579ff4bc09fdcdde431dc1447d2c260bc\":{\"balance\":\"0x1158e460913d00000\"},\"01a25a5f5af0169b30864c3be4d7563ccd44f09e\":{\"balance\":\"0x4d853c8f8908980000\"},\"01a7d9fa7d0eb1185c67e54da83c2e75db69e39f\":{\"balance\":\"0x19d4addd0d8bc960000\"},\"01a818135a414210c37c62b625aca1a54611ac36\":{\"balance\":\"0xe18398e7601900000\"},\"01b1cae91a3b9559afb33cdc6d689442fdbfe037\":{\"balance\":\"0xad78ebc5ac6200000\"},\"01b5b5bc5a117fa08b34ed1db9440608597ac548\":{\"balance\":\"0xad78ebc5ac6200000\"},\"01bbc14f67af0639aab1441e6a08d4ce7162090f\":{\"balance\":\"0x46fcf68ff8be060000\"},\"01d03815c61f416b71a2610a2daba59ff6a6de5b\":{\"balance\":\"0x205dfe50b81c82e0000\"},\"01d599ee0d5f8c38ab2d392e2c65b74c3ce31820\":{\"balance\":\"0x1ba5abf9e779380000\"},\"01e40521122530d9ac91113c06a0190b6d63850b\":{\"balance\":\"0x487a9a304539440000\"},\"01e6415d587b065490f1ed7f21d6e0f386ee6747\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"01e864d354741b423e6f42851724468c74f5aa9c\":{\"balance\":\"0x43c33c1937564800000\"},\"01ed5fba8d2eab673aec042d30e4e8a611d8c55a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"01fb8ec12425a04f813e46c54c05748ca6b29aa9\":{\"balance\":\"0xe15730385467c0000\"},\"01ff1eb1dead50a7f2f9638fdee6eccf3a7b2ac8\":{\"balance\":\"0x2086ac351052600000\"},\"020362c3ade878ca90d6b2d889a4cc5510eed5f3\":{\"balance\":\"0x3888e8b311adb38000\"},\"0203ae01d4c41cae1865e04b1f5b53cdfaecae31\":{\"balance\":\"0x3689cdceb28cd70000\"},\"02089361a3fe7451fb1f87f01a2d866653dc0b07\":{\"balance\":\"0x22ac74832b5040000\"},\"021f69043de88c4917ca10f1842897eec0589c7c\":{\"balance\":\"0x6b44cfb81487f40000\"},\"02290fb5f9a517f82845acdeca0fc846039be233\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0239b4f21f8e05cd01512b2be7a0e18a6d974607\":{\"balance\":\"0x3635c9adc5dea00000\"},\"02477212ffdd75e5155651b76506b1646671a1eb\":{\"balance\":\"0x5f68e8131ecf800000\"},\"024a098ae702bef5406c9c22b78bd4eb2cc7a293\":{\"balance\":\"0xd8d726b7177a800000\"},\"024bdd2c7bfd500ee7404f7fb3e9fb31dd20fbd1\":{\"balance\":\"0x9c2007651b2500000\"},\"025367960304beee34591118e9ac2d1358d8021a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0256149f5b5063bea14e15661ffb58f9b459a957\":{\"balance\":\"0x2629f66e0c53000000\"},\"02603d7a3bb297c67c877e5d34fbd5b913d4c63a\":{\"balance\":\"0x1158e460913d00000\"},\"0261ad3a172abf1315f0ffec3270986a8409cb25\":{\"balance\":\"0xb08213bcf8ffe0000\"},\"026432af37dc5113f1f46d480a4de0b28052237e\":{\"balance\":\"0x1349b786e40bfc0000\"},\"0266ab1c6b0216230b9395443d5fa75e684568c6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"02751dc68cb5bd737027abf7ddb77390cd77c16b\":{\"balance\":\"0x1158e460913d00000\"},\"02778e390fa17510a3428af2870c4273547d386c\":{\"balance\":\"0x36c3c66170c0d720000\"},\"02ade5db22f8b758ee1443626c64ec2f32aa0a15\":{\"balance\":\"0x43c33c1937564800000\"},\"02af2459a93d0b3f4d062636236cd4b29e3bcecf\":{\"balance\":\"0x678a932062e4180000\"},\"02b1af72339b2a2256389fd64607de24f0de600a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"02b643d6fabd437a851accbe79abb7fde126dccf\":{\"balance\":\"0x18650127cc3dc800000\"},\"02b6d65cb00b7b36e1fb5ed3632c4cb20a894130\":{\"balance\":\"0x43c33c1937564800000\"},\"02b7b1d6b34ce053a40eb65cd4a4f7dddd0e9f30\":{\"balance\":\"0x252248deb6e6940000\"},\"02c9f7940a7b8b7a410bf83dc9c22333d4275dd3\":{\"balance\":\"0x10f0cf064dd59200000\"},\"02d4a30968a39e2b3498c3a6a4ed45c1c6646822\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"02dfcb17a1b87441036374b762a5d3418b1cb4d4\":{\"balance\":\"0x48b02ba9d1ba460000\"},\"02e4cb22be46258a40e16d4338d802fffd00c151\":{\"balance\":\"0x149696eaceba810000\"},\"02e816afc1b5c0f39852131959d946eb3b07b5ad\":{\"balance\":\"0x3635c9adc5dea00000\"},\"02f7f67209b16a17550c694c72583819c80b54ad\":{\"balance\":\"0x5559306a78a700000\"},\"030973807b2f426914ad00181270acd27b8ff61f\":{\"balance\":\"0x121ea68c114e5100000\"},\"03097923ba155e16d82f3ad3f6b815540884b92c\":{\"balance\":\"0x62a992e53a0af00000\"},\"030fb3401f72bd3418b7d1da75bf8c519dd707dc\":{\"balance\":\"0xa2a15d09519be00000\"},\"031e25db516b0f099faebfd94f890cf96660836b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0328510c09dbcd85194a98d67c33ac49f2f94d60\":{\"balance\":\"0x2544faa778090e00000\"},\"0329188f080657ab3a2afa522467178279832085\":{\"balance\":\"0xbbf510ddfcb260000\"},\"03317826d1f70aa4bddfa09be0c4105552d2358b\":{\"balance\":\"0x21a754a6dc5280000\"},\"03337012ae1d7ff3ee7f697c403e7780188bf0ef\":{\"balance\":\"0xad78ebc5ac6200000\"},\"03377c0e556b640103289a6189e1aeae63493467\":{\"balance\":\"0x43c33c1937564800000\"},\"0349634dc2a9e80c3f7721ee2b5046aeaaedfbb5\":{\"balance\":\"0xd8d726b7177a800000\"},\"0355bcacbd21441e95adeedc30c17218c8a408ce\":{\"balance\":\"0x15af1d78b58c400000\"},\"036eeff5ba90a6879a14dff4c5043b18ca0460c9\":{\"balance\":\"0x56bc75e2d63100000\"},\"03714b41d2a6f751008ef8dd4d2b29aecab8f36e\":{\"balance\":\"0x14542ba12a337c00000\"},\"0372e852582e0934344a0fed2178304df25d4628\":{\"balance\":\"0x43c33c1937564800000\"},\"0372ee5508bf8163ed284e5eef94ce4d7367e522\":{\"balance\":\"0x56bc75e2d63100000\"},\"037dd056e7fdbd641db5b6bea2a8780a83fae180\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"038323b184cff7a82ae2e1bda7793fe4319ca0bf\":{\"balance\":\"0x43c33c1937564800000\"},\"038779ca2dbe663e63db3fe75683ea0ec62e2383\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"038e45eadd3d88b87fe4dab066680522f0dfc8f9\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0392549a727f81655429cb928b529f25df4d1385\":{\"balance\":\"0x16c43a0eea0740000\"},\"0394b90fadb8604f86f43fc1e35d3124b32a5989\":{\"balance\":\"0x296aa140278e700000\"},\"039e7a4ebc284e2ccd42b1bdd60bd6511c0f7706\":{\"balance\":\"0xf015f25736420000\"},\"039ef1ce52fe7963f166d5a275c4b1069fe3a832\":{\"balance\":\"0x15af39e4aab2740000\"},\"03a26cfc4c18316f70d59e9e1a79ee3e8b962f4c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"03aa622881236dd0f4940c24c324ff8b7b7e2186\":{\"balance\":\"0xad78ebc5ac62000000\"},\"03af7ad9d5223cf7c8c13f20df67ebe5ffc5bb41\":{\"balance\":\"0xad78ebc5ac6200000\"},\"03b0f17cd4469ddccfb7da697e82a91a5f9e7774\":{\"balance\":\"0x1158e460913d00000\"},\"03b41b51f41df20dd279bae18c12775f77ad771c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"03be5b4629aefbbcab9de26d39576cb7f691d764\":{\"balance\":\"0xadf30ba70c8970000\"},\"03c647a9f929b0781fe9ae01caa3e183e876777e\":{\"balance\":\"0x182ab7c20ce5240000\"},\"03c91d92943603e752203e05340e566013b90045\":{\"balance\":\"0x2b7cc2e9c3225c0000\"},\"03cb4c4f4516c4ff79a1b6244fbf572e1c7fea79\":{\"balance\":\"0x9489237adb9a500000\"},\"03cb98d7acd817de9d886d22fab3f1b57d92a608\":{\"balance\":\"0x56bc75e2d631000000\"},\"03cc9d2d21f86b84ac8ceaf971dba78a90e62570\":{\"balance\":\"0x57473d05dabae80000\"},\"03d1724fd00e54aabcd2de2a91e8462b1049dd3a\":{\"balance\":\"0x8f1d5c1cae37400000\"},\"03dedfcd0b3c2e17c705da248790ef98a6bd5751\":{\"balance\":\"0x487a9a304539440000\"},\"03e8b084537557e709eae2e1e1a5a6bce1ef8314\":{\"balance\":\"0x1158e460913d00000\"},\"03ea6d26d080e57aee3926b18e8ed73a4e5b2826\":{\"balance\":\"0xad78ebc5ac6200000\"},\"03eb3cb860f6028da554d344a2bb5a500ae8b86f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"03ebc63fda6660a465045e235fbe6e5cf195735f\":{\"balance\":\"0x7b06ce87fdd680000\"},\"03ef6ad20ff7bd4f002bac58d47544cf879ae728\":{\"balance\":\"0x175c758d0b96e5c0000\"},\"03f7b92008813ae0a676eb212814afab35221069\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"041170f581de80e58b2a045c8f7c1493b001b7cb\":{\"balance\":\"0x303c74a1a336940000\"},\"0413d0cf78c001898a378b918cd6e498ea773c4d\":{\"balance\":\"0xf2dc7d47f15600000\"},\"04241b41ecbd0bfdf1295e9d4fa59ea09e6c6186\":{\"balance\":\"0x655f769450bc780000\"},\"043707071e2ae21eed977891dc79cd5d8ee1c2da\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"044e853144e3364495e7a69fa1d46abea3ac0964\":{\"balance\":\"0x2ab2254b1dc9a8000\"},\"0455dcec8a7fc4461bfd7f37456fce3f4c3caac7\":{\"balance\":\"0x15af1d78b58c400000\"},\"045ed7f6d9ee9f252e073268db022c6326adfc5b\":{\"balance\":\"0x56bc75e2d63100000\"},\"046377f864b0143f282174a892a73d3ec8ec6132\":{\"balance\":\"0xa5aa85009e39c0000\"},\"0469e8c440450b0e512626fe817e6754a8152830\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"046d274b1af615fb505a764ad8dda770b1db2f3d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"047d5a26d7ad8f8e70600f70a398ddaa1c2db26f\":{\"balance\":\"0x14542ba12a337c00000\"},\"047e87c8f7d1fce3b01353a85862a948ac049f3e\":{\"balance\":\"0x50c5e761a444080000\"},\"047f9bf1529daf87d407175e6f171b5e59e9ff3e\":{\"balance\":\"0x233c8fe42703e80000\"},\"04852732b4c652f6c2e58eb36587e60a62da14db\":{\"balance\":\"0x43c33c1937564800000\"},\"048a8970ea4145c64d5517b8de5b46d0595aad06\":{\"balance\":\"0x43c33c1937564800000\"},\"049c5d4bc6f25d4e456c697b52a07811ccd19fb1\":{\"balance\":\"0x104400a2470e680000\"},\"04a1cada1cc751082ff8da928e3cfa000820a9e9\":{\"balance\":\"0x22b1c8c1227a00000\"},\"04a80afad53ef1f84165cfd852b0fdf1b1c24ba8\":{\"balance\":\"0x324e964b3eca80000\"},\"04aafc8ae5ce6f4903c89d7fac9cb19512224777\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"04ba4bb87140022c214a6fac42db5a16dd954045\":{\"balance\":\"0x3635c9adc5dea00000\"},\"04ba8a3f03f08b895095994dda619edaacee3e7a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"04c2c64bb54c3eccd05585e10ec6f99a0cdb01a3\":{\"balance\":\"0x56bc75e2d63100000\"},\"04ce45f600db18a9d0851b29d9393ebdaafe3dc5\":{\"balance\":\"0x1158e460913d00000\"},\"04d6b8d4da867407bb997749debbcdc0b358538a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"04d73896cf6593a691972a13a6e4871ff2c42b13\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"04d82af9e01a936d97f8f85940b970f9d4db9936\":{\"balance\":\"0xad78ebc5ac6200000\"},\"04e5f5bc7c923fd1e31735e72ef968fd67110c6e\":{\"balance\":\"0x57551dbc8e624c0000\"},\"04eca501630abce35218b174956b891ba25efb23\":{\"balance\":\"0x36369ed7747d260000\"},\"0505a08e22a109015a22f685305354662a5531d5\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"0514954c3c2fb657f9a06f510ea22748f027cdd3\":{\"balance\":\"0x15af1d78b58c400000\"},\"051633080d07a557adde319261b074997f14692d\":{\"balance\":\"0x13a6b2b564871a00000\"},\"0517448dada761cc5ba4033ee881c83037036400\":{\"balance\":\"0x6c4fd1ee246e780000\"},\"051d424276b21239665186133d653bb8b1862f89\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0521bc3a9f8711fecb10f50797d71083e341eb9d\":{\"balance\":\"0x1158e460913d00000\"},\"05236d4c90d065f9e3938358aaffd777b86aec49\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"052a58e035f1fe9cdd169bcf20970345d12b9c51\":{\"balance\":\"0x50c5e761a444080000\"},\"052eab1f61b6d45517283f41d1441824878749d0\":{\"balance\":\"0xd8d726b7177a800000\"},\"05336e9a722728d963e7a1cf2759fd0274530fca\":{\"balance\":\"0x31a2443f888a798000\"},\"053471cd9a41925b3904a5a8ffca3659e034be23\":{\"balance\":\"0xad201a6794ff80000\"},\"05361d8eb6941d4e90fb7e1418a95a32d5257732\":{\"balance\":\"0x1158e460913d00000\"},\"05423a54c8d0f9707e704173d923b946edc8e700\":{\"balance\":\"0x6ea03c2bf8ba58000\"},\"05440c5b073b529b4829209dff88090e07c4f6f5\":{\"balance\":\"0x45d29737e22f200000\"},\"055ab658c6f0ed4f875ed6742e4bc7292d1abbf0\":{\"balance\":\"0x486cb9799191e0000\"},\"055bd02caf19d6202bbcdc836d187bd1c01cf261\":{\"balance\":\"0x56bc75e2d63100000\"},\"055eac4f1ad3f58f0bd024d68ea60dbe01c6afb3\":{\"balance\":\"0x56bc75e2d63100000\"},\"05665155cc49cbf6aabdd5ae92cbfaad82b8c0c1\":{\"balance\":\"0x15af1d78b58c400000\"},\"056686078fb6bcf9ba0a8a8dc63a906f5feac0ea\":{\"balance\":\"0x1b181e4bf2343c0000\"},\"05696b73916bd3033e05521e3211dfec026e98e4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"056b1546894f9a85e203fb336db569b16c25e04f\":{\"balance\":\"0x92edb09ff08d88000\"},\"057949e1ca0570469e4ce3c690ae613a6b01c559\":{\"balance\":\"0xad78ebc5ac6200000\"},\"057dd29f2d19aa3da42327ea50bce86ff5c911d9\":{\"balance\":\"0xd8d726b7177a800000\"},\"057f7f81cd7a406fc45994408b5049912c566463\":{\"balance\":\"0x5c283d410394100000\"},\"05915d4e225a668162aee7d6c25fcfc6ed18db03\":{\"balance\":\"0x398c37279259e0000\"},\"0596a27dc3ee115fce2f94b481bc207a9e261525\":{\"balance\":\"0x3635c9adc5dea00000\"},\"05a830724302bc0f6ebdaa1ebeeeb46e6ce00b39\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"05ae7fd4bbcc80ca11a90a1ec7a301f7cccc83db\":{\"balance\":\"0x3154c9729d05780000\"},\"05bb64a916be66f460f5e3b64332110d209e19ae\":{\"balance\":\"0xe3aeb5737240a00000\"},\"05bf4fcfe772e45b826443852e6c351350ce72a2\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"05c64004a9a826e94e5e4ee267fa2a7632dd4e6f\":{\"balance\":\"0x36dc42ebff90b7f8000\"},\"05c736d365aa37b5c0be9c12c8ad5cd903c32cf9\":{\"balance\":\"0x1455e7b800a86880000\"},\"05cb6c3b0072d3116761b532b218443b53e8f6c5\":{\"balance\":\"0x1e02c3d7fca9b6280000\"},\"05d0f4d728ebe82e84bf597515ad41b60bf28b39\":{\"balance\":\"0xe3aeb5737240a00000\"},\"05d68dad61d3bbdfb3f779265c49474aff3fcd30\":{\"balance\":\"0x222c55dc1519d8000\"},\"05e671de55afec964b074de574d5158d5d21b0a3\":{\"balance\":\"0xd5967be4fc3f100000\"},\"05e97b09492cd68f63b12b892ed1d11d152c0eca\":{\"balance\":\"0x3708baed3d68900000\"},\"05f3631f5664bdad5d0132c8388d36d7d8920918\":{\"balance\":\"0x1158e460913d00000\"},\"0609d83a6ce1ffc9b690f3e9a81e983e8bdc4d9d\":{\"balance\":\"0xed2b525841adfc00000\"},\"061ea4877cd08944eb64c2966e9db8dedcfec06b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0625d06056968b002206ff91980140242bfaa499\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0628bfbe5535782fb588406bc96660a49b011af5\":{\"balance\":\"0x52663ccab1e1c00000\"},\"0631d18bbbbd30d9e1732bf36edae2ce8901ab80\":{\"balance\":\"0xa3f98855ec39900000\"},\"0631dc40d74e5095e3729eddf49544ecd4396f67\":{\"balance\":\"0x8ac7230489e800000\"},\"063759dd1c4e362eb19398951ff9f8fad1d31068\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"065ff575fd9c16d3cb6fd68ffc8f483fc32ec835\":{\"balance\":\"0xad78ebc5ac6200000\"},\"06618e9d5762df62028601a81d4487d6a0ecb80e\":{\"balance\":\"0x487a9a304539440000\"},\"066647cfc85d23d37605573d208ca154b244d76c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0678654ac6761db904a2f7e8595ec1eaac734308\":{\"balance\":\"0x2f98b29c2818f80000\"},\"06860a93525955ff624940fadcffb8e149fd599c\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"068ce8bd6e902a45cb83b51541b40f39c4469712\":{\"balance\":\"0x11c0f9bad4a46e00000\"},\"068e29b3f191c812a6393918f71ab933ae6847f2\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"068e655766b944fb263619658740b850c94afa31\":{\"balance\":\"0x1e87f85809dc00000\"},\"06964e2d17e9189f88a8203936b40ac96e533c06\":{\"balance\":\"0xfc936392801c0000\"},\"06994cd83aa2640a97b2600b41339d1e0d3ede6c\":{\"balance\":\"0xd8d726b7177a80000\"},\"069ed0ab7aa77de571f16106051d92afe195f2d0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"06ac26ad92cb859bd5905ddce4266aa0ec50a9c5\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"06b0c1e37f5a5ec4bbf50840548f9d3ac0288897\":{\"balance\":\"0xd8d882e1928e7d0000\"},\"06b0ff834073cce1cbc9ea557ea87b605963e8b4\":{\"balance\":\"0x1043561a8829300000\"},\"06b106649aa8c421ddcd1b8c32cd0418cf30da1f\":{\"balance\":\"0x878678326eac9000000\"},\"06b5ede6fdf1d6e9a34721379aeaa17c713dd82a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"06cbfa08cdd4fba737bac407be8224f4eef35828\":{\"balance\":\"0x202be5e8382e8b8000\"},\"06d6cb308481c336a6e1a225a912f6e6355940a1\":{\"balance\":\"0x5f68e8131ecf800000\"},\"06dc7f18cee7edab5b795337b1df6a9e8bd8ae59\":{\"balance\":\"0x15af1d78b58c400000\"},\"06f68de3d739db41121eacf779aada3de8762107\":{\"balance\":\"0x18493fba64ef00000\"},\"06f7dc8d1b9462cef6feb13368a7e3974b097f9f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0701f9f147ec486856f5e1b71de9f117e99e2105\":{\"balance\":\"0x965da717fd5b80000\"},\"070d5d364cb7bbf822fc2ca91a35bdd441b215d5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"071dd90d14d41f4ff7c413c24238d3359cd61a07\":{\"balance\":\"0x7b53f79e888dac00000\"},\"0726c42e00f45404836eb1e280d073e7059687f5\":{\"balance\":\"0x58003e3fb947a38000\"},\"0727be0a2a00212048b5520fbefb953ebc9d54a0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0729a8a4a5ba23f579d0025b1ad0f8a0d35cdfd2\":{\"balance\":\"0x20dd68aaf3289100000\"},\"0729b4b47c09eb16158464c8aa7fd9690b438839\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"0734a0a81c9562f4d9e9e10a8503da15db46d76e\":{\"balance\":\"0xfc936392801c0000\"},\"073c67e09b5c713c5221c8a0c7f3f74466c347b0\":{\"balance\":\"0x41bad155e6512200000\"},\"073f1ed1c9c3e9c52a9b0249a5c1caa0571fdf05\":{\"balance\":\"0x3d0ff0b013b800000\"},\"0748713145ef83c3f0ef4d31d823786f7e9cc689\":{\"balance\":\"0xf3f20b8dfa69d00000\"},\"075d15e2d33d8b4fa7dba8b9e607f04a261e340b\":{\"balance\":\"0x678a932062e4180000\"},\"076561a856455d7ef86e63f87c73dbb628a55f45\":{\"balance\":\"0x30ca024f987b900000\"},\"076ee99d3548623a03b5f99859d2d785a1778d48\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0770b43dbae4b1f35a927b4fa8124d3866caf97b\":{\"balance\":\"0x37193ea7ef5b470000\"},\"0770c61be78772230cb5a3bb2429a72614a0b336\":{\"balance\":\"0x16ee0a299b713418000\"},\"07723e3c30e8b731ee456a291ee0e798b0204a77\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0773eeacc050f74720b4a1bd57895b1cceeb495d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"07800d2f8068e448c79a4f69b1f15ef682aae5f6\":{\"balance\":\"0x41bad155e6512200000\"},\"07a8dadec142571a7d53a4297051786d072cba55\":{\"balance\":\"0x13b6da1139bda8000\"},\"07af938c1237a27c9030094dcf240750246e3d2c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"07b1a306cb4312df66482c2cae72d1e061400fcd\":{\"balance\":\"0x43c33c1937564800000\"},\"07b7a57033f8f11330e4665e185d234e83ec140b\":{\"balance\":\"0xea7ee92a0c9a0b8000\"},\"07bc2cc8eedc01970700efc9c4fb36735e98cd71\":{\"balance\":\"0xd8d726b7177a800000\"},\"07d41217badca5e0e60327d845a3464f0f27f84a\":{\"balance\":\"0xd8d726b7177a800000\"},\"07d4334ec385e8aa54eedaeadb30022f0cdfa4ab\":{\"balance\":\"0x8e91d520f2eb790000\"},\"07dae622630d1136381933d2ad6b22b839d82102\":{\"balance\":\"0xad78ebc5ac6200000\"},\"07dc2bf83bc6af19a842ffea661af5b41b67fda1\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"07dc8c8b927adbedfa8f5d639b4352351f2f36d2\":{\"balance\":\"0x110aed3b5530db0000\"},\"07ddd0422c86ef65bf0c7fc3452862b1228b08b8\":{\"balance\":\"0x6ff5d2aa8f9fcf0000\"},\"07e1162ceae3cf21a3f62d105990302e307f4e3b\":{\"balance\":\"0x52f103edb66ba80000\"},\"07e2b4cdeed9d087b12e556d9e770c13c099615f\":{\"balance\":\"0x243d4d18229ca20000\"},\"07feef54c136850829badc4b49c3f2a73c89fb9e\":{\"balance\":\"0x6685ac1bfe32c0000\"},\"080546508a3d2682c8b9884f13637b8847b44db3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"08090876baadfee65c3d363ba55312748cfa873d\":{\"balance\":\"0x5c2a99371cffe10000\"},\"08166f02313feae18bb044e7877c808b55b5bf58\":{\"balance\":\"0x6acb3df27e1f880000\"},\"0829d0f7bb7c446cfbb0deadb2394d9db7249a87\":{\"balance\":\"0x22ca3587cf4eb0000\"},\"08306de51981e7aca1856859b7c778696a6b69f9\":{\"balance\":\"0xad78ebc5ac62000000\"},\"0837539b5f6a522a482cdcd3a9bb7043af39bdd2\":{\"balance\":\"0x14542ba12a337c00000\"},\"0838a7768d9c2aca8ba279adfee4b1f491e326f1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"08411652c871713609af0062a8a1281bf1bbcfd9\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"084d103254759b343cb2b9c2d8ff9e1ac5f14596\":{\"balance\":\"0x19bff2ff57968c00000\"},\"08504f05643fab5919f5eea55925d7a3ed7d807a\":{\"balance\":\"0x1158e460913d00000\"},\"085b4ab75d8362d914435cedee1daa2b1ee1a23b\":{\"balance\":\"0xd255d112e103a00000\"},\"085ba65febe23eefc2c802666ab1262382cfc494\":{\"balance\":\"0x15af1d78b58c400000\"},\"087498c0464668f31150f4d3c4bcdda5221ba102\":{\"balance\":\"0x1158e460913d00000\"},\"0877eeaeab78d5c00e83c32b2d98fa79ad51482f\":{\"balance\":\"0x17d22d71da62260000\"},\"08936a37df85b3a158cafd9de021f58137681347\":{\"balance\":\"0xfc936392801c0000\"},\"08a9a44e1f41de3dbba7a363a3ab412c124cd15e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"08b7bdcf944d5570838be70460243a8694485858\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"08b84536b74c8c01543da88b84d78bb95747d822\":{\"balance\":\"0xad78ebc5ac6200000\"},\"08c2f236ac4adcd3fda9fbc6e4532253f9da3bec\":{\"balance\":\"0x1158e460913d00000\"},\"08c802f87758349fa03e6bc2e2fd0791197eea9a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"08c9f1bfb689fdf804d769f82123360215aff93b\":{\"balance\":\"0x6acb3df27e1f880000\"},\"08cac8952641d8fc526ec1ab4f2df826a5e7710f\":{\"balance\":\"0x1043561a8829300000\"},\"08ccda50e4b26a0ffc0ef92e9205310706bec2c7\":{\"balance\":\"0x149756c3857c6000000\"},\"08d0864dc32f9acb36bf4ea447e8dd6726906a15\":{\"balance\":\"0x6c6e59e67c78540000\"},\"08d4267feb15da9700f7ccc3c84a8918bf17cfde\":{\"balance\":\"0x61093d7c2c6d380000\"},\"08d4311c9c1bbaf87fabe1a1d01463828d5d98ce\":{\"balance\":\"0x130ee8e7179044400000\"},\"08d54e83ad486a934cfaeae283a33efd227c0e99\":{\"balance\":\"0x38530583245edc0000\"},\"08d97eadfcb7b064e1ccd9c8979fbee5e77a9719\":{\"balance\":\"0xe6c5da8d67ac18000\"},\"08da3a7a0f452161cfbcec311bb68ebfdee17e88\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"08e38ee0ce48c9ca645c1019f73b5355581c56e6\":{\"balance\":\"0x56bc75e2d631000000\"},\"08ef3fa4c43ccdc57b22a4b9b2331a82e53818f2\":{\"balance\":\"0xd8d726b7177a800000\"},\"0909648c18a3ce5bae7a047ec2f868d24cdda81d\":{\"balance\":\"0xcf152640c5c8300000\"},\"090cd67b60e81d54e7b5f6078f3e021ba65b9a1e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"090cebef292c3eb081a05fd8aaf7d39bf07b89d4\":{\"balance\":\"0xd8d726b7177a800000\"},\"090fa9367bda57d0d3253a0a8ff76ce0b8e19a73\":{\"balance\":\"0x3635c9adc5dea00000\"},\"09146ea3885176f07782e1fe30dce3ce24c49e1f\":{\"balance\":\"0x1158e460913d00000\"},\"0921605f99164e3bcc28f31caece78973182561d\":{\"balance\":\"0x2b07692a9065a80000\"},\"09261f9acb451c3788844f0c1451a35bad5098e3\":{\"balance\":\"0x1d5ad27502920600000\"},\"0927220492194b2eda9fc4bbe38f25d681dfd36c\":{\"balance\":\"0x14542ba12a337c00000\"},\"092acb624b08c05510189bbbe21e6524d644ccad\":{\"balance\":\"0xfc936392801c0000\"},\"092e815558402d67f90d6bfe6da0b2fffa91455a\":{\"balance\":\"0x340aad21b3b700000\"},\"095030e4b82692dcf8b8d0912494b9b378ec9328\":{\"balance\":\"0x48a43c54602f700000\"},\"095270cc42141dd998ad2862dbd1fe9b44e7e650\":{\"balance\":\"0x410d586a20a4c00000\"},\"095457f8ef8e2bdc362196b9a9125da09c67e3ab\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0954a8cb5d321fc3351a7523a617d0f58da676a7\":{\"balance\":\"0x87d9bc7aa498e80000\"},\"095b0ea2b218d82e0aea7c2889238a39c9bf9077\":{\"balance\":\"0x43c33c1937564800000\"},\"095b949de3333a377d5019d893754a5e4656ff97\":{\"balance\":\"0x126e72a69a50d00000\"},\"095e0174829f34c3781be1a5e38d1541ea439b7f\":{\"balance\":\"0x14542ba12a337c00000\"},\"095f5a51d06f6340d80b6d29ea2e88118ad730fe\":{\"balance\":\"0x6c6e59e67c78540000\"},\"0968ee5a378f8cadb3bafdbed1d19aaacf936711\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0977bfba038a44fb49b03970d8d8cf2cb61f8b25\":{\"balance\":\"0x16c4abbebea0100000\"},\"097da12cfc1f7c1a2464def08c29bed5e2f851e9\":{\"balance\":\"0x1158e460913d00000\"},\"097ecda22567c2d91cb03f8c5215c22e9dcda949\":{\"balance\":\"0x11651ac3e7a758000\"},\"0989c200440b878991b69d6095dfe69e33a22e70\":{\"balance\":\"0x678a932062e4180000\"},\"0990e81cd785599ea236bd1966cf526302c35b9c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0998d8273115b56af43c505e087aff0676ed3659\":{\"balance\":\"0xd8d6eddf2d2e180000\"},\"09a025316f967fa8b9a1d60700063f5a68001caa\":{\"balance\":\"0x21221a99b93ec0000\"},\"09a928d528ec1b3e25ffc83e218c1e0afe8928c7\":{\"balance\":\"0xfc936392801c0000\"},\"09ae49e37f121df5dc158cfde806f173a06b0c7f\":{\"balance\":\"0xd8309e26aba1d00000\"},\"09afa73bc047ef46b977fd9763f87286a6be68c6\":{\"balance\":\"0x1b2fb5e8f06a660000\"},\"09b4668696f86a080f8bebb91db8e6f87015915a\":{\"balance\":\"0x238ff7b34f60010000\"},\"09b59b8698a7fbd3d2f8c73a008988de3e406b2b\":{\"balance\":\"0x878678326eac9000000\"},\"09b7a988d13ff89186736f03fdf46175b53d16e0\":{\"balance\":\"0x14542ba12a337c00000\"},\"09c177f1ae442411ddacf187d46db956148360e7\":{\"balance\":\"0x1e52e336cde22180000\"},\"09c88f917e4d6ad473fa12e98ea3c4472a5ed6da\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"09d0b8cd077c69d9f32d9cca43b3c208a21ed48b\":{\"balance\":\"0x821d221b5291f8000\"},\"09d6cefd75b0c4b3f8f1d687a522c96123f1f539\":{\"balance\":\"0x14542ba12a337c00000\"},\"09e437d448861228a232b62ee8d37965a904ed9c\":{\"balance\":\"0x498cf401df8842e8000\"},\"09ee12b1b42b05af9cf207d5fcac255b2ec411f2\":{\"balance\":\"0x331cddd47e0fe8000\"},\"09f3f601f605441140586ce0656fa24aa5b1d9ae\":{\"balance\":\"0x5373776fe8c4540000\"},\"09f9575be57d004793c7a4eb84b71587f97cbb6a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0a0650861f785ed8e4bf1005c450bbd06eb48fb6\":{\"balance\":\"0xa6413b79144e7e0000\"},\"0a06fad7dcd7a492cbc053eeabde6934b39d8637\":{\"balance\":\"0x1158e460913d00000\"},\"0a077db13ffeb09484c217709d5886b8bf9c5a8b\":{\"balance\":\"0xd8d726b7177a800000\"},\"0a0ecda6636f7716ef1973614687fd89a820a706\":{\"balance\":\"0x155bd9307f9fe80000\"},\"0a29a8a4d5fd950075ffb34d77afeb2d823bd689\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0a2ade95b2e8c66d8ae6f0ba64ca57d783be6d44\":{\"balance\":\"0xd8d726b7177a800000\"},\"0a2b4fc5d81ace67dc4bba03f7b455413d46fe3d\":{\"balance\":\"0xaadec983fcff40000\"},\"0a2dcb7a671701dbb8f495728088265873356c8e\":{\"balance\":\"0x83f16ce08a06c0000\"},\"0a3de155d5ecd8e81c1ff9bbf0378301f8d4c623\":{\"balance\":\"0xd8d726b7177a800000\"},\"0a47ad9059a249fc936b2662353da6905f75c2b9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0a48296f7631708c95d2b74975bc4ab88ac1392a\":{\"balance\":\"0x10f0cf064dd59200000\"},\"0a4a011995c681bc999fdd79754e9a324ae3b379\":{\"balance\":\"0x8c19ab06eb89af60000\"},\"0a58fddd71898de773a74fdae45e7bd84ef43646\":{\"balance\":\"0x1158e460913d00000\"},\"0a5b79d8f23b6483dbe2bdaa62b1064cc76366ae\":{\"balance\":\"0x6ac882100952c78000\"},\"0a652e2a8b77bd97a790d0e91361c98890dbb04e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0a6ebe723b6ed1f9a86a69ddda68dc47465c2b1b\":{\"balance\":\"0x403d2db599d5e40000\"},\"0a77e7f72b437b574f00128b21f2ac265133528c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0a917f3b5cb0b883047fd9b6593dbcd557f453b9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0a931b449ea8f12cdbd5e2c8cc76bad2c27c0639\":{\"balance\":\"0x13f9e8c79fe058000\"},\"0a9804137803ba6868d93a55f9985fcd540451e4\":{\"balance\":\"0xb98bc829a6f90000\"},\"0a9ab2638b1cfd654d25dab018a0aebddf85fd55\":{\"balance\":\"0x12e8cb5fe4c4a8000\"},\"0ab366e6e7d5abbce6b44a438d69a1cabb90d133\":{\"balance\":\"0x1158e460913d000000\"},\"0ab4281ebb318590abb89a81df07fa3af904258a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"0ab59d390702c9c059db148eb4f3fcfa7d04c7e7\":{\"balance\":\"0xfc936392801c0000\"},\"0abfb39b11486d79572866195ba26c630b6784db\":{\"balance\":\"0x19ba8737f96928f00000\"},\"0aca9a5626913b08cfc9a66d40508dce52b60f87\":{\"balance\":\"0x678a932062e4180000\"},\"0ad3e44d3c001fa290b393617030544108ac6eb9\":{\"balance\":\"0x6abda0bc30b2df8000\"},\"0aec2e426ed6cc0cf3c249c1897eac47a7faa9bd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0af65f14784e55a6f95667fd73252a1c94072d2a\":{\"balance\":\"0xa763b8e02d44f8000\"},\"0af6c8d539c96d50259e1ba6719e9c8060f388c2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0b06390f2437b20ec4a3d3431b3279c6583e5ed7\":{\"balance\":\"0xa844a7424d9c80000\"},\"0b0b3862112aeec3a03492b1b05f440eca54256e\":{\"balance\":\"0xd8d726b7177a800000\"},\"0b0e055b28cbd03dc5ff44aa64f3dce04f5e63fb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b119df99c6b8de58a1e2c3f297a6744bf552277\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b14891999a65c9ef73308efe3100ca1b20e8192\":{\"balance\":\"0x2b5e3af16b18800000\"},\"0b2113504534642a1daf102eee10b9ebde76e261\":{\"balance\":\"0x942cdd7c95f2bd8000\"},\"0b288a5a8b75f3dc4191eb0457e1c83dbd204d25\":{\"balance\":\"0x10714e77bb43ab40000\"},\"0b369e002e1b4c7913fcf00f2d5e19c58165478f\":{\"balance\":\"0x37f6516288c340000\"},\"0b43bd2391025581d8956ce42a072579cbbfcb14\":{\"balance\":\"0x104e70464b1580000\"},\"0b507cf553568daaf65504ae4eaa17a8ea3cdbf5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b5d66b13c87b392e94d91d5f76c0d450a552843\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b5e2011ebc25a007f21362960498afb8af280fb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b649da3b96a102cdc6db652a0c07d65b1e443e6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b6920a64b363b8d5d90802494cf564b547c430d\":{\"balance\":\"0x410d586a20a4c00000\"},\"0b701101a4109f9cb360dc57b77442673d5e5983\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0b71f554122469ef978e2f1fefd7cbb410982772\":{\"balance\":\"0xd255d112e103a00000\"},\"0b7bb342f01bc9888e6a9af4a887cbf4c2dd2caf\":{\"balance\":\"0x3635c9adc5dea000000\"},\"0b7d339371e5be6727e6e331b5821fa24bdb9d5a\":{\"balance\":\"0x2e7f81868262010000\"},\"0b7fc9ddf70576f6330669eaaa71b6a831e99528\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"0b80fc70282cbdd5fde35bf78984db3bdb120188\":{\"balance\":\"0x3638021cecdab00000\"},\"0b924df007e9c0878417cfe63b976ea1a382a897\":{\"balance\":\"0x22b1c8c1227a00000\"},\"0b93fca4a4f09cac20db60e065edcccc11e0a5b6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0b9df80fbe232009dacf0aa8cac59376e2476203\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0ba6e46af25a13f57169255a34a4dac7ce12be04\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"0ba8705bf55cf219c0956b5e3fc01c4474a6cdc1\":{\"balance\":\"0x525e0595d4d6b8000\"},\"0baf6ecdb91acb3606a8357c0bc4f45cfd2d7e6f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0bb05f7224bb5804856556c07eeadbed87ba8f7c\":{\"balance\":\"0x15be6174e1912e0000\"},\"0bb0c12682a2f15c9b5741b2385cbe41f034068e\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"0bb25ca7d188e71e4d693d7b170717d6f8f0a70a\":{\"balance\":\"0x124302a82fadd70000\"},\"0bb2650ea01aca755bc0c017b64b1ab5a66d82e3\":{\"balance\":\"0x487a9a304539440000\"},\"0bb54c72fd6610bfa4363397e020384b022b0c49\":{\"balance\":\"0x487a9a304539440000\"},\"0bb7160aba293762f8734f3e0326ffc9a4cac190\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0bc95cb32dbb574c832fa8174a81356d38bc92ac\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0bd67dbde07a856ebd893b5edc4f3a5be4202616\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0bdbc54cc8bdbbb402a08911e2232a5460ce866b\":{\"balance\":\"0xa2a15d09519be00000\"},\"0bdd58b96e7c916dd2fb30356f2aebfaaf1d8630\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0be1bcb90343fae5303173f461bd914a4839056c\":{\"balance\":\"0x14542ba12a337c00000\"},\"0be1fdf626ee6189102d70d13b31012c95cd1cd6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0be2b94ad950a2a62640c35bfccd6c67dae450f6\":{\"balance\":\"0x692ae8897081d00000\"},\"0be6a09e4307fe48d412b8d1a1a8284dce486261\":{\"balance\":\"0x40fbff85c0138300000\"},\"0befb54707f61b2c9fb04715ab026e1bb72042bd\":{\"balance\":\"0xd8d726b7177a800000\"},\"0bf064428f83626722a7b5b26a9ab20421a7723e\":{\"balance\":\"0x73f75d1a085ba0000\"},\"0bfbb6925dc75e52cf2684224bbe0550fea685d3\":{\"balance\":\"0x6acb3df27e1f880000\"},\"0c088006c64b30c4ddafbc36cb5f05469eb62834\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0c2073ba44d3ddbdb639c04e191039a71716237f\":{\"balance\":\"0x4d853c8f8908980000\"},\"0c222c7c41c9b048efcce0a232434362e12d673b\":{\"balance\":\"0x21e8359697677380000\"},\"0c2808b951ed9e872d7b32790fcc5994ae41ffdc\":{\"balance\":\"0x15996e5b3cd6b3c00000\"},\"0c28847e4f09dfce5f9b25af7c4e530f59c880fe\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0c2d5c920538e953caaf24f0737f554cc6927742\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0c30cacc3f72269f8b4f04cf073d2b05a83d9ad1\":{\"balance\":\"0x6c7974123f64a40000\"},\"0c3239e2e841242db989a61518c22247e8c55208\":{\"balance\":\"0xe4af6471734640000\"},\"0c480de9f7461002908b49f60fc61e2b62d3140b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0c48ae62d1539788eba013d75ea60b64eeba4e80\":{\"balance\":\"0x77fbdc43e030998000\"},\"0c5589a7a89b9ad15b02751930415948a875fbef\":{\"balance\":\"0x6d499ec6c63380000\"},\"0c67033dd8ee7f0c8ae534d42a51f7d9d4f7978f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0c6845bf41d5ee273c3ee6b5b0d69f6fd5eabbf7\":{\"balance\":\"0xa2a1b9682e58090000\"},\"0c7f869f8e90d53fdc03e8b2819b016b9d18eb26\":{\"balance\":\"0x43c33c1937564800000\"},\"0c8692eeff2a53d6d1688ed56a9ddbbd68dabba1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0c8f66c6017bce5b20347204b602b743bad78d60\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0c8fd7775e54a6d9c9a3bf890e761f6577693ff0\":{\"balance\":\"0x215f835bc769da80000\"},\"0c925ad5eb352c8ef76d0c222d115b0791b962a1\":{\"balance\":\"0xac635d7fa34e300000\"},\"0c967e3061b87a753e84507eb60986782c8f3013\":{\"balance\":\"0x56bc75e2d63100000\"},\"0ca12ab0b9666cf0cec6671a15292f2653476ab2\":{\"balance\":\"0x2c7827c42d22d07c0000\"},\"0ca670eb2c8b96cba379217f5929c2b892f39ef6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0cae108e6db99b9e637876b064c6303eda8a65c8\":{\"balance\":\"0xa2a15d09519be00000\"},\"0cbd921dbe121563b98a6871fecb14f1cc7e88d7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0cbf8770f0d1082e5c20c5aead34e5fca9ae7ae2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0cc67f8273e1bae0867fd42e8b8193d72679dbf8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"0cd6a141918d126b106d9f2ebf69e102de4d3277\":{\"balance\":\"0x1158e460913d00000\"},\"0cda12bf72d461bbc479eb92e6491d057e6b5ad1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0cdc960b998c141998160dc179b36c15d28470ed\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"0cfb172335b16c87d519cd1475530d20577f5e0e\":{\"balance\":\"0x152d02c7e14af6800000\"},\"0d1f2a57713ebc6e94de29846e8844d376665763\":{\"balance\":\"0x10f0cf064dd59200000\"},\"0d3265d3e7bdb93d5e8e8b1ca47f210a793ecc8e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0d35408f226566116fb8acdaa9e2c9d59b76683f\":{\"balance\":\"0x32f51edbaaa3300000\"},\"0d551ec1a2133c981d5fc6a8c8173f9e7c4f47af\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0d5d98565c647ca5f177a2adb9d3022fac287f21\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0d658014a199061cf6b39433140303c20ffd4e5a\":{\"balance\":\"0x1bc85dc2a89bb200000\"},\"0d678706d037187f3e22e6f69b99a592d11ebc59\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"0d69100c395ce6c5eaadf95d05d872837ededd21\":{\"balance\":\"0x15af1d78b58c400000\"},\"0d747ee5969bf79d57381d6fe3a2406cd0d8ce27\":{\"balance\":\"0x152d02c7e14af6800000\"},\"0d8023929d917234ae40512b1aabb5e8a4512771\":{\"balance\":\"0x805e99fdcc5d00000\"},\"0d8aab8f74ea862cdf766805009d3f3e42d8d00b\":{\"balance\":\"0x13b80b99c5185700000\"},\"0d8c40a79e18994ff99ec251ee10d088c3912e80\":{\"balance\":\"0x63664fcd2bbc40000\"},\"0d8ed7d0d15638330ed7e4eaccab8a458d75737e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0d92582fdba05eabc3e51538c56db8813785b328\":{\"balance\":\"0xa5aa85009e39c0000\"},\"0d9443a79468a5bbf7c13c6e225d1de91aee07df\":{\"balance\":\"0x3cb71f51fc5580000\"},\"0d9a825ff2bcd397cbad5b711d9dcc95f1cc112d\":{\"balance\":\"0x2b5e3af16b188000000\"},\"0d9d3f9bc4a4c6efbd59679b69826bc1f63d9916\":{\"balance\":\"0x2086ac351052600000\"},\"0da532c910e3ac0dfb14db61cd739a93353fd05f\":{\"balance\":\"0x4878be1ffaf95d0000\"},\"0da7401262384e2e8b4b26dd154799b55145efa0\":{\"balance\":\"0x1043561a8829300000\"},\"0dae3ee5b915b36487f9161f19846d101433318a\":{\"balance\":\"0x678a932062e4180000\"},\"0dbd417c372b8b0d01bcd944706bd32e60ae28d1\":{\"balance\":\"0x126e72a69a50d00000\"},\"0dc100b107011c7fc0a1339612a16ccec3285208\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0dcf9d8c9804459f647c14138ed50fad563b4154\":{\"balance\":\"0x960db77681e940000\"},\"0dcfe837ea1cf28c65fccec3bef1f84e59d150c0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0dd4e674bbadb1b0dc824498713dce3b5156da29\":{\"balance\":\"0x93739534d28680000\"},\"0dfbd4817050d91d9d625c02053cf61a3ee28572\":{\"balance\":\"0x126e72a69a50d00000\"},\"0e024e7f029c6aaf3a8b910f5e080873b85795aa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0e09646c99af438e99fa274cb2f9c856cb65f736\":{\"balance\":\"0x678a932062e4180000\"},\"0e0c9d005ea016c295cd795cc9213e87febc33eb\":{\"balance\":\"0xabbcd4ef377580000\"},\"0e0d6633db1e0c7f234a6df163a10e0ab39c200f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0e11d77a8977fac30d268445e531149b31541a24\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0e123d7da6d1e6fac2dcadd27029240bb39052fe\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0e1801e70b6262861b1134ccbc391f568afc92f7\":{\"balance\":\"0xd8d726b7177a800000\"},\"0e2094ac1654a46ba1c4d3a40bb8c17da7f39688\":{\"balance\":\"0x13683f7f3c15d80000\"},\"0e21af1b8dbf27fcf63f37e047b87a825cbe7c27\":{\"balance\":\"0xa2a15d09519be00000\"},\"0e2e504a2d1122b5a9feee5cb1451bf4c2ace87b\":{\"balance\":\"0xd5967be4fc3f100000\"},\"0e2f8e28a681f77c583bd0ecde16634bdd7e00cd\":{\"balance\":\"0x52738f659bca20000\"},\"0e320219838e859b2f9f18b72e3d4073ca50b37d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0e33fcbbc003510be35785b52a9c5d216bc005f4\":{\"balance\":\"0x65ea3db75546600000\"},\"0e3696cf1f4217b163d1bc12a5ea730f1c32a14a\":{\"balance\":\"0xd8d726b7177a800000\"},\"0e390f44053ddfcef0d608b35e4d9c2cbe9871bb\":{\"balance\":\"0x6acb3df27e1f880000\"},\"0e3a28c1dfafb0505bdce19fe025f506a6d01ceb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0e3dd7d4e429fe3930a6414035f52bdc599d784d\":{\"balance\":\"0x22ca3587cf4eb0000\"},\"0e4765790352656bc656682c24fc5ef3e76a23c7\":{\"balance\":\"0x286d7fc0cb4f50000\"},\"0e498800447177b8c8afc3fdfa7f69f4051bb629\":{\"balance\":\"0x7405b69b8de5610000\"},\"0e6baaa3deb989f289620076668618e9ac332865\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0e6cd664ad9c1ed64bf98749f40644b626e3792c\":{\"balance\":\"0xcb49b44ba602d800000\"},\"0e6dfd553b2e873d2aec15bd5fbb3f8472d8d394\":{\"balance\":\"0x28a857425466f800000\"},\"0e6ec313376271dff55423ab5422cc3a8b06b22b\":{\"balance\":\"0xd8d726b7177a800000\"},\"0e6ece99111cad1961c748ed3df51edd69d2a3b1\":{\"balance\":\"0x152d02c7e14af6800000\"},\"0e83b850481ab44d49e0a229a2e464902c69539b\":{\"balance\":\"0x56bc75e2d63100000\"},\"0e89eddd3fa0d71d8ab0ff8da5580686e3d4f74f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0e9096d343c060db581a120112b278607ec6e52b\":{\"balance\":\"0x1158e460913d00000\"},\"0e9c511864a177f49be78202773f60489fe04e52\":{\"balance\":\"0x14542ba12a337c00000\"},\"0ea2a210312b3e867ee0d1cc682ce1d666f18ed5\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0eb189ef2c2d5762a963d6b7bdf9698ea8e7b48a\":{\"balance\":\"0x487a9a304539440000\"},\"0eb5b662a1c718608fd52f0c25f9378830178519\":{\"balance\":\"0x14a37281a612e740000\"},\"0ec46696ffac1f58005fa8439824f08eed1df89b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0ec50aa823f465b9464b0bc0c4a57724a555f5d6\":{\"balance\":\"0xc83d1426ac7b1f00000\"},\"0ec5308b31282e218fc9e759d4fec5db3708cec4\":{\"balance\":\"0x3643aa647986040000\"},\"0eccf617844fd61fba62cb0e445b7ac68bcc1fbe\":{\"balance\":\"0x14fe4fe63565c60000\"},\"0ed3bb3a4eb554cfca97947d575507cdfd6d21d8\":{\"balance\":\"0x1db3205fcc23d58000\"},\"0ed76c2c3b5d50ff8fb50b3eeacd681590be1c2d\":{\"balance\":\"0x56bc75e2d63100000\"},\"0eda80f4ed074aea697aeddf283b63dbca3dc4da\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0edd4b580ff10fe06c4a03116239ef96622bae35\":{\"balance\":\"0xaadec983fcff40000\"},\"0ee391f03c765b11d69026fd1ab35395dc3802a0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0ee414940487fd24e390378285c5d7b9334d8b65\":{\"balance\":\"0x914878a8c05ee00000\"},\"0ef54ac7264d2254abbb5f8b41adde875157db7c\":{\"balance\":\"0x22b1c8c1227a00000\"},\"0ef85b49d08a75198692914eddb4b22cf5fa4450\":{\"balance\":\"0x6cae30621d47200000\"},\"0efd1789eb1244a3dede0f5de582d8963cb1f39f\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"0f042c9c2fb18766f836bb59f735f27dc329fe3c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0f049a8bdfd761de8ec02cee2829c4005b23c06b\":{\"balance\":\"0xda933d8d8c6700000\"},\"0f05f120c89e9fbc93d4ab0c5e2b4a0df092b424\":{\"balance\":\"0x65a4da25d3016c00000\"},\"0f127bbf8e311caea2ba502a33feced3f730ba42\":{\"balance\":\"0xa31062beeed700000\"},\"0f1c249cd962b00fd114a9349f6a6cc778d76c4d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0f206e1a1da7207ea518b112418baa8b06260328\":{\"balance\":\"0x2086ac351052600000\"},\"0f24105abbdaa03fa6309ef6c188e51f714a6e59\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0f26480a150961b8e30750713a94ee6f2e47fc00\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0f2d8daf04b5414a0261f549ff6477b80f2f1d07\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"0f2fb884c8aaff6f543ac6228bd08e4f60b0a5fd\":{\"balance\":\"0xaa7da485136b840000\"},\"0f32d9cb4d0fdaa0150656bb608dcc43ed7d9301\":{\"balance\":\"0x28df8bf440db790000\"},\"0f3665d48e9f1419cd984fc7fa92788710c8f2e4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0f3a1023cac04dbf44f5a5fa6a9cf8508cd4fddf\":{\"balance\":\"0x62a992e53a0af00000\"},\"0f4073c1b99df60a1549d69789c7318d9403a814\":{\"balance\":\"0x43c33c1937564800000\"},\"0f46c81db780c1674ac73d314f06539ee56ebc83\":{\"balance\":\"0x215f835bc769da80000\"},\"0f4f94b9191bb7bb556aaad7c74ddb288417a50b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"0f6000de1578619320aba5e392706b131fb1de6f\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"0f6e840a3f2a24647d8e43e09d45c7c335df4248\":{\"balance\":\"0x878678326eac900000\"},\"0f7515ff0e808f695e0c20485ff96ed2f7b79310\":{\"balance\":\"0x3638221660a5aa8000\"},\"0f789e30397c53bf256fc364e6ef39f853504114\":{\"balance\":\"0xc55325ca7415e00000\"},\"0f7b61c59b016322e8226cafaee9d9e76d50a1b3\":{\"balance\":\"0xd8d726b7177a800000\"},\"0f7bea4ef3f73ae0233df1e100718cbe29310bb0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0f7bf6373f771a4601762c4dae5fbbf4fedd9cc9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0f832a93df9d7f74cd0fb8546b7198bf5377d925\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"0f83461ba224bb1e8fdd9dae535172b735acb4e0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"0f85e42b1df321a4b3e835b50c00b06173968436\":{\"balance\":\"0x35659ef93f0fc40000\"},\"0f88aac9346cb0e7347fba70905475ba8b3e5ece\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"0f929cf895db017af79f3ead2216b1bd69c37dc7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0fa010ce0c731d3b628e36b91f571300e49dbeab\":{\"balance\":\"0x36330322d5238c0000\"},\"0fa5d8c5b3f294efd495ab69d768f81872508548\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"0fa6c7b0973d0bae2940540e247d3627e37ca347\":{\"balance\":\"0x3635c9adc5dea00000\"},\"0fad05507cdc8f24b2be4cb7fa5d927ddb911b88\":{\"balance\":\"0xa2df13f441f0098000\"},\"0fb5d2c673bfb1ddca141b9894fd6d3f05da6720\":{\"balance\":\"0x56bc75e2d63100000\"},\"0fc9a0e34145fbfdd2c9d2a499b617d7a02969b9\":{\"balance\":\"0x9c2007651b2500000\"},\"0fcfc4065008cfd323305f6286b57a4dd7eee23b\":{\"balance\":\"0x43c33c1937564800000\"},\"0fdd65402395df9bd19fee4507ef5345f745104c\":{\"balance\":\"0x10f0cf064dd59200000\"},\"0fec4ee0d7ca180290b6bd20f9992342f60ff68d\":{\"balance\":\"0x12207f0edce9718000\"},\"0fee81ac331efd8f81161c57382bb4507bb9ebec\":{\"balance\":\"0x15af880d8cdb830000\"},\"0ffea06d7113fb6aec2869f4a9dfb09007facef4\":{\"balance\":\"0xc384681b1e1740000\"},\"10097198b4e7ee91ff82cc2f3bd95fed73c540c0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"100b4d0977fcbad4debd5e64a0497aeae5168fab\":{\"balance\":\"0x110c9073b5245a0000\"},\"101a0a64f9afcc448a8a130d4dfcbee89537d854\":{\"balance\":\"0x337fe5feaf2d1800000\"},\"102c477d69aadba9a0b0f62b7459e17fbb1c1561\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1031e0ecb54985ae21af1793950dc811888fde7c\":{\"balance\":\"0x1158e460913d00000\"},\"10346414bec6d3dcc44e50e54d54c2b8c3734e3e\":{\"balance\":\"0xd8d726b7177a800000\"},\"10389858b800e8c0ec32f51ed61a355946cc409b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1059cbc63e36c43e88f30008aca7ce058eeaa096\":{\"balance\":\"0x152d02c7e14af6800000\"},\"106ed5c719b5261477890425ae7551dc59bd255c\":{\"balance\":\"0x2896a58c95be5880000\"},\"10711c3dda32317885f0a2fd8ae92e82069b0d0b\":{\"balance\":\"0xd8d726b7177a800000\"},\"107379d4c467464f235bc18e55938aad3e688ad7\":{\"balance\":\"0x2b5e3af16b1880000\"},\"1076212d4f758c8ec7121c1c7d74254926459284\":{\"balance\":\"0x7695b59b5c17b4c0000\"},\"1078d7f61b0e56c74ee6635b2e1819ef1e3d8785\":{\"balance\":\"0x3635c9adc5dea00000\"},\"107a03cf0842dbdeb0618fb587ca69189ec92ff5\":{\"balance\":\"0x6acb3df27e1f880000\"},\"1080c1d8358a15bc84dac8253c6883319020df2c\":{\"balance\":\"0x90f534608a72880000\"},\"108a2b7c336f784779d8b54d02a8d31d9a139c0a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"108ba7c2895c50e072dc6f964932d50c282d3034\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"108fe8ee2a13da487b22c6ab6d582ea71064d98c\":{\"balance\":\"0x15ac56edc4d12c0000\"},\"1091176be19b9964a8f72e0ece6bf8e3cfad6e9c\":{\"balance\":\"0x21f2f6f0fc3c6100000\"},\"1098c774c20ca1daac5ddb620365316d353f109c\":{\"balance\":\"0x56bc75e2d63100000\"},\"1098cc20ef84bad5146639c4cd1ca6c3996cb99b\":{\"balance\":\"0xfc936392801c0000\"},\"10a1c42dc1ba746986b985a522a73c93eae64c63\":{\"balance\":\"0x3635c9adc5dea00000\"},\"10a93457496f1108cd98e140a1ecdbae5e6de171\":{\"balance\":\"0x15a99062d416180000\"},\"10b5b34d1248fcf017f8c8ffc408ce899ceef92f\":{\"balance\":\"0xe7eeba3410b740000\"},\"10cf560964ff83c1c9674c783c0f73fcd89943fc\":{\"balance\":\"0x878678326eac9000000\"},\"10d32416722ca4e648630548ead91edd79c06aff\":{\"balance\":\"0x56bc75e2d63100000\"},\"10d945334ecde47beb9ca3816c173dfbbd0b5333\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"10df681506e34930ac7a5c67a54c3e89ce92b981\":{\"balance\":\"0x74c1fab8adb4540000\"},\"10e1e3377885c42d7df218522ee7766887c05e6a\":{\"balance\":\"0x1043c43cde1d398000\"},\"10e390ad2ba33d82b37388d09c4544c6b0225de5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"10f4bff0caa5027c0a6a2dcfc952824de2940909\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"11001b89ed873e3aaec1155634b4681643986323\":{\"balance\":\"0x3635c9adc5dea00000\"},\"110237cf9117e767922fc4a1b78d7964da82df20\":{\"balance\":\"0xd5967be4fc3f100000\"},\"1111e5dbf45e6f906d62866f1708101788ddd571\":{\"balance\":\"0x467be6533ec2e40000\"},\"11172b278ddd44eea2fdf4cb1d16962391c453d9\":{\"balance\":\"0xc62f3d9bfd4895f00000\"},\"112634b4ec30ff786e024159f796a57939ea144e\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"11306c7d57588637780fc9fde8e98ecb008f0164\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"113612bc3ba0ee4898b49dd20233905f2f458f62\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"11415fab61e0dfd4b90676141a557a869ba0bde9\":{\"balance\":\"0x6f05b59d3b20000000\"},\"114cbbbf6fb52ac414be7ec61f7bb71495ce1dfa\":{\"balance\":\"0xa2a15d09519be00000\"},\"114cfefe50170dd97ae08f0a44544978c599548d\":{\"balance\":\"0x2ec887e7a14a1c0000\"},\"116108c12084612eeda7a93ddcf8d2602e279e5c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1164caaa8cc5977afe1fad8a7d6028ce2d57299b\":{\"balance\":\"0x15af1d78b58c400000\"},\"11675a25554607a3b6c92a9ee8f36f75edd3e336\":{\"balance\":\"0x8a9aba557e36c0000\"},\"116a09df66cb150e97578e297fb06e13040c893c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"116fef5e601642c918cb89160fc2293ba71da936\":{\"balance\":\"0x2b7cc2e9c3225c0000\"},\"1178501ff94add1c5881fe886136f6dfdbe61a94\":{\"balance\":\"0x890b0c2e14fb80000\"},\"1179c60dbd068b150b074da4be23033b20c68558\":{\"balance\":\"0x24dce54d34a1a00000\"},\"117d9aa3c4d13bee12c7500f09f5dd1c66c46504\":{\"balance\":\"0xb2ad30490b2780000\"},\"117db836377fe15455e02c2ebda40b1ceb551b19\":{\"balance\":\"0x14542ba12a337c00000\"},\"118c18b2dce170e8f445753ba5d7513cb7636d2d\":{\"balance\":\"0x1dd0c885f9a0d800000\"},\"118fbd753b9792395aef7a4d78d263cdcaabd4f7\":{\"balance\":\"0x36330322d5238c0000\"},\"11928378d27d55c520ceedf24ceb1e822d890df0\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"119aa64d5b7d181dae9d3cb449955c89c1f963fa\":{\"balance\":\"0x25f273933db5700000\"},\"11c0358aa6479de21866fe21071924b65e70f8b9\":{\"balance\":\"0x7b53f79e888dac00000\"},\"11d2247a221e70c2d66d17ee138d38c55ffb8640\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"11d7844a471ef89a8d877555583ceebd1439ea26\":{\"balance\":\"0x22369e6ba80c6880000\"},\"11dd6185d9a8d73ddfdaa71e9b7774431c4dfec2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"11e7997edd904503d77da6038ab0a4c834bbd563\":{\"balance\":\"0x150894e849b3900000\"},\"11ec00f849b6319cf51aa8dd8f66b35529c0be77\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"11efb8a20451161b644a8ccebbc1d343a3bbcb52\":{\"balance\":\"0xad78ebc5ac62000000\"},\"11fefb5dc1a4598aa712640c517775dfa1d91f8c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"120f9de6e0af7ec02a07c609ca8447f157e6344c\":{\"balance\":\"0xe7eeba3410b740000\"},\"1210f80bdb826c175462ab0716e69e46c24ad076\":{\"balance\":\"0x56bc75e2d63100000\"},\"12134e7f6b017bf48e855a399ca58e2e892fa5c8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"12173074980153aeaa4b0dcbc7132eadcec21b64\":{\"balance\":\"0xd02ab486cedc00000\"},\"121f855b70149ac83473b9706fb44d47828b983b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"1227e10a4dbf9caca31b1780239f557615fc35c1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"122dcfd81addb97d1a0e4925c4b549806e9f3beb\":{\"balance\":\"0x522035cc6e01210000\"},\"122f56122549d168a5c5e267f52662e5c5cce5c8\":{\"balance\":\"0xa076407d3f7440000\"},\"12316fc7f178eac22eb2b25aedeadf3d75d00177\":{\"balance\":\"0x43c33be05f6bfb98000\"},\"123759f333e13e3069e2034b4f05398918119d36\":{\"balance\":\"0x43c33c1937564800000\"},\"125cc5e4d56b2bcc2ee1c709fb9e68fb177440bd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"12632388b2765ee4452b50161d1fffd91ab81f4a\":{\"balance\":\"0x281d901f4fdd100000\"},\"126897a311a14ad43b78e0920100c4426bfd6bdd\":{\"balance\":\"0x34c726893f2d948000\"},\"126d91f7ad86debb0557c612ca276eb7f96d00a1\":{\"balance\":\"0x56bc75e2d63100000\"},\"127d3fc5003bf63c0d83e93957836515fd279045\":{\"balance\":\"0x610c9222e6e750000\"},\"127db1cadf1b771cbd7475e1b272690f558c8565\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"1284f0cee9d2ff2989b65574d06ffd9ab0f7b805\":{\"balance\":\"0x15af1d78b58c400000\"},\"128b908fe743a434203de294c441c7e20a86ea67\":{\"balance\":\"0x26ab14e0c0e13c0000\"},\"1293c78c7d6a443b9d74b0ba5ee7bb47fd418588\":{\"balance\":\"0x16a6502f15a1e540000\"},\"1296acded1e063af39fe8ba0b4b63df789f70517\":{\"balance\":\"0x56bf91b1a65eb0000\"},\"12aa7d86ddfbad301692feac8a08f841cb215c37\":{\"balance\":\"0x76d41c62494840000\"},\"12afbcba1427a6a39e7ba4849f7ab1c4358ac31b\":{\"balance\":\"0x43c33c1937564800000\"},\"12b5e28945bb2969f9c64c63cc05b6f1f8d6f4d5\":{\"balance\":\"0x1a29e86913b74050000\"},\"12cf8b0e465213211a5b53dfb0dd271a282c12c9\":{\"balance\":\"0xd2f13f7789f00000\"},\"12d20790b7d3dbd88c81a279b812039e8a603bd0\":{\"balance\":\"0x56f985d38644b80000\"},\"12d60d65b7d9fc48840be5f891c745ce76ee501e\":{\"balance\":\"0x485e5388d0c76840000\"},\"12d91a92d74fc861a729646db192a125b79f5374\":{\"balance\":\"0xfc936392801c0000\"},\"12e9a4ad2ad57484dd700565bddb46423bd9bd31\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"12f32c0a1f2daab676fe69abd9e018352d4ccd45\":{\"balance\":\"0x2b5e3af16b1880000\"},\"12f460ae646cd2780fd35c50a6af4b9accfa85c6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"12ffc1128605cb0c13709a7290506f2690977193\":{\"balance\":\"0xb50fcfafebecb00000\"},\"13032446e7d610aa00ec8c56c9b574d36ca1c016\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"131c792c197d18bd045d7024937c1f84b60f4438\":{\"balance\":\"0xd8d726b7177a800000\"},\"131df8d330eb7cc7147d0a55576f05de8d26a8b7\":{\"balance\":\"0xa31062beeed700000\"},\"131faed12561bb7aee04e5185af802b1c3438d9b\":{\"balance\":\"0xbdf3c4bb0328c0000\"},\"1321b605026f4ffb296a3e0edcb390c9c85608b7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1321ccf29739b974e5a516f18f3a843671e39642\":{\"balance\":\"0xd8d726b7177a800000\"},\"1327d759d56e0ab87af37ecf63fe01f310be100a\":{\"balance\":\"0x23bc3cdb68a1800000\"},\"1329dd19cd4baa9fc64310efeceab22117251f12\":{\"balance\":\"0xad78ebc5ac6200000\"},\"13371f92a56ea8381e43059a95128bdc4d43c5a6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"133c490fa5bf7f372888e607d958fab7f955bae1\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"133e4f15e1e39c53435930aaedf3e0fe56fde843\":{\"balance\":\"0x1158e460913d00000\"},\"134163be9fbbe1c5696ee255e90b13254395c318\":{\"balance\":\"0xad78ebc5ac6200000\"},\"135cecd955e5798370769230159303d9b1839f66\":{\"balance\":\"0x10f0cf064dd59200000\"},\"135d1719bf03e3f866312479fe338118cd387e70\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"135eb8c0e9e101deedec11f2ecdb66ae1aae8867\":{\"balance\":\"0x43c33c1937564800000\"},\"1360e87df24c69ee6d51c76e73767ffe19a2131c\":{\"balance\":\"0x4fcc1a89027f00000\"},\"136c834bf111326d207395295b2e583ea7f33572\":{\"balance\":\"0x56bc75e2d63100000\"},\"136d4b662bbd1080cfe4445b0fa213864435b7f1\":{\"balance\":\"0xd8d726b7177a800000\"},\"136f4907cab41e27084b9845069ff2fd0c9ade79\":{\"balance\":\"0xd8d726b7177a800000\"},\"1374facd7b3f8d68649d60d4550ee69ff0484133\":{\"balance\":\"0xe9ed6e11172da0000\"},\"137cf341e8516c815814ebcd73e6569af14cf7bc\":{\"balance\":\"0x3635c9adc5dea00000\"},\"13848b46ea75beb7eaa85f59d866d77fd24cf21a\":{\"balance\":\"0xa968163f0a57b400000\"},\"139d3531c9922ad56269f6309aa789fb2485f98c\":{\"balance\":\"0xd8d726b7177a800000\"},\"139e479764b499d666208c4a8a047a97043163dd\":{\"balance\":\"0x2077212aff6df00000\"},\"13a5eecb38305df94971ef2d9e179ae6cebab337\":{\"balance\":\"0x11e3ab8395c6e80000\"},\"13acada8980affc7504921be84eb4944c8fbb2bd\":{\"balance\":\"0x56d2aa3a5c09a00000\"},\"13b9b10715714c09cfd610cf9c9846051cb1d513\":{\"balance\":\"0x6acb3df27e1f880000\"},\"13ce332dff65a6ab933897588aa23e000980fa82\":{\"balance\":\"0xe020536f028f00000\"},\"13d67a7e25f2b12cdb85585009f8acc49b967301\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"13dee03e3799952d0738843d4be8fc0a803fb20e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"13e02fb448d6c84ae17db310ad286d056160da95\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"13e321728c9c57628058e93fc866a032dd0bda90\":{\"balance\":\"0x26bcca23fe2ea20000\"},\"13ec812284026e409bc066dfebf9d5a4a2bf801e\":{\"balance\":\"0x57473d05dabae80000\"},\"140129eaa766b5a29f5b3af2574e4409f8f6d3f1\":{\"balance\":\"0x15af1d78b58c4000000\"},\"140518a3194bad1350b8949e650565debe6db315\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1406854d149e081ac09cb4ca560da463f3123059\":{\"balance\":\"0x487a9a304539440000\"},\"140ca28ff33b9f66d7f1fc0078f8c1eef69a1bc0\":{\"balance\":\"0x56bc75e2d631000000\"},\"140fba58dbc04803d84c2130f01978f9e0c73129\":{\"balance\":\"0x15af1d78b58c400000\"},\"141a5e39ee2f680a600fbf6fa297de90f3225cdd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"14254ea126b52d0142da0a7e188ce255d8c47178\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"142b87c5043ffb5a91df18c2e109ced6fe4a71db\":{\"balance\":\"0xad78ebc5ac6200000\"},\"143c639752caeecf6a997d39709fc8f19878c7e8\":{\"balance\":\"0x6acb3df27e1f880000\"},\"143d536b8b1cb84f56a39e0bc81fd5442bcacce1\":{\"balance\":\"0x56bc75e2d63100000\"},\"143f5f1658d9e578f4f3d95f80c0b1bd3933cbda\":{\"balance\":\"0x50c5e761a444080000\"},\"14410fb310711be074a80883c635d0ef6afb2539\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"144b19f1f66cbe318347e48d84b14039466c5909\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"145250b06e4fa7cb2749422eb817bdda8b54de5f\":{\"balance\":\"0xbdf3c4bb0328c0000\"},\"145e0600e2a927b2dd8d379356b45a2e7d51d3ae\":{\"balance\":\"0x8a02ab400bb2cb8000\"},\"145e1de0147911ccd880875fbbea61f6a142d11d\":{\"balance\":\"0xd8d726b7177a800000\"},\"1463a873555bc0397e575c2471cf77fa9db146e0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1479a9ec7480b74b5db8fc499be352da7f84ee9c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"147af46ae9ccd18bb35ca01b353b51990e49dce1\":{\"balance\":\"0xd8d726b7177a800000\"},\"147f4210ab5804940a0b7db8c14c28396b62a6bf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"14830704e99aaad5c55e1f502b27b22c12c91933\":{\"balance\":\"0x219c3a7b1966300000\"},\"149b6dbde632c19f5af47cb493114bebd9b03c1f\":{\"balance\":\"0x28a857425466f800000\"},\"149ba10f0da2725dc704733e87f5a524ca88515e\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"14a7352066364404db50f0d0d78d754a22198ef4\":{\"balance\":\"0x65ea3db75546600000\"},\"14ab164b3b524c82d6abfbc0de831126ae8d1375\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"14b1603ec62b20022033eec4d6d6655ac24a015a\":{\"balance\":\"0x2b5e3af16b1880000\"},\"14c63ba2dcb1dd4df33ddab11c4f0007fa96a62d\":{\"balance\":\"0x34841b6057afab00000\"},\"14cdddbc8b09e6675a9e9e05091cb92238c39e1e\":{\"balance\":\"0x11478b7c30abc300000\"},\"14d00aad39a0a7d19ca05350f7b03727f08dd82e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"14eec09bf03e352bd6ff1b1e876be664ceffd0cf\":{\"balance\":\"0x116dc3a8994b30000\"},\"14f221159518783bc4a706676fc4f3c5ee405829\":{\"balance\":\"0xad78ebc5ac6200000\"},\"14fcd1391e7d732f41766cdacd84fa1deb9ffdd2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"150e3dbcbcfc84ccf89b73427763a565c23e60d0\":{\"balance\":\"0x22b1c8c1227a00000\"},\"1518627b88351fede796d3f3083364fbd4887b0c\":{\"balance\":\"0x3635c9adc5dea000000\"},\"15224ad1c0face46f9f556e4774a3025ad06bd52\":{\"balance\":\"0xb98bc829a6f90000\"},\"152f2bd229ddf3cb0fdaf455c183209c0e1e39a2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"152f4e860ef3ee806a502777a1b8dbc91a907668\":{\"balance\":\"0x2086ac351052600000\"},\"153c08aa8b96a611ef63c0253e2a4334829e579d\":{\"balance\":\"0x155bd9307f9fe80000\"},\"153cf2842cb9de876c276fa64767d1a8ecf573bb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"153ef58a1e2e7a3eb6b459a80ab2a547c94182a2\":{\"balance\":\"0x14542ba12a337c000000\"},\"154459fa2f21318e3434449789d826cdc1570ce5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1547b9bf7ad66274f3413827231ba405ee8c88c1\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"1548b770a5118ede87dba2f690337f616de683ab\":{\"balance\":\"0x1c995685e0bf870000\"},\"15528350e0d9670a2ea27f7b4a33b9c0f9621d21\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"155b3779bb6d56342e2fda817b5b2d81c7f41327\":{\"balance\":\"0x2b8aa3a076c9c0000\"},\"1565af837ef3b0bd4e2b23568d5023cd34b16498\":{\"balance\":\"0x1551e9724ac4ba0000\"},\"15669180dee29598869b08a721c7d24c4c0ee63f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1572cdfab72a01ce968e78f5b5448da29853fbdd\":{\"balance\":\"0x112626c49060fa60000\"},\"157559adc55764cc6df79323092534e3d6645a66\":{\"balance\":\"0x14542ba12a337c00000\"},\"1578bdbc371b4d243845330556fff2d5ef4dff67\":{\"balance\":\"0x56bc75e2d63100000\"},\"157eb3d3113bd3b597714d3a954edd018982a5cb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1584a2c066b7a455dbd6ae2807a7334e83c35fa5\":{\"balance\":\"0x70c1cc73b00c80000\"},\"15874686b6733d10d703c9f9bec6c52eb8628d67\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"158a0d619253bf4432b5cd02c7b862f7c2b75636\":{\"balance\":\"0x75bac7c5b12188000\"},\"1598127982f2f8ad3b6b8fc3cf27bf617801ba2b\":{\"balance\":\"0x960db77681e940000\"},\"159adce27aa10b47236429a34a5ac42cad5b6416\":{\"balance\":\"0x6bf90a96edbfa718000\"},\"15a0aec37ff9ff3d5409f2a4f0c1212aaccb0296\":{\"balance\":\"0x3635c9adc5dea00000\"},\"15aa530dc36958b4edb38eee6dd9e3c77d4c9145\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"15acb61568ec4af7ea2819386181b116a6c5ee70\":{\"balance\":\"0x690836c0af5f5600000\"},\"15b96f30c23b8664e7490651066b00c4391fbf84\":{\"balance\":\"0x1642e9df4876290000\"},\"15c7edb8118ee27b342285eb5926b47a855bc7a5\":{\"balance\":\"0x1158e460913d00000\"},\"15d99468507aa0413fb60dca2adc7f569cb36b54\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"15dbb48c98309764f99ced3692dcca35ee306bac\":{\"balance\":\"0x1fc3842bd1f071c00000\"},\"15dcafcc2bace7b55b54c01a1c514626bf61ebd8\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"15e3b584056b62c973cf5eb096f1733e54c15c91\":{\"balance\":\"0x32c75a0223ddf30000\"},\"15ebd1c7cad2aff19275c657c4d808d010efa0f5\":{\"balance\":\"0xadf30ba70c8970000\"},\"15ee0fc63ebf1b1fc49d7bb38f8863823a2e17d2\":{\"balance\":\"0x678a932062e4180000\"},\"15f1b352110d68901d8f67aac46a6cfafe031477\":{\"balance\":\"0xad78ebc5ac6200000\"},\"15f2b7b16432ee50a5f55b41232f6334ed58bdc0\":{\"balance\":\"0x15af1d78b58c400000\"},\"16019a4dafab43f4d9bf4163fae0847d848afca2\":{\"balance\":\"0x15bc70139f74a0000\"},\"160226efe7b53a8af462d117a0108089bdecc2d1\":{\"balance\":\"0xadf30ba70c8970000\"},\"160ceb6f980e04315f53c4fc988b2bf69e284d7d\":{\"balance\":\"0x10910d4cdc9f60000\"},\"161caf5a972ace8379a6d0a04ae6e163fe21df2b\":{\"balance\":\"0x152d02c7e14af6800000\"},\"161d26ef6759ba5b9f20fdcd66f16132c352415e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"162110f29eac5f7d02b543d8dcd5bb59a5e33b73\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"162ba503276214b509f97586bd842110d103d517\":{\"balance\":\"0x1e7ffd8895c22680000\"},\"162d76c2e6514a3afb6fe3d3cb93a35c5ae783f1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"163bad4a122b457d64e8150a413eae4d07023e6b\":{\"balance\":\"0x104e70464b1580000\"},\"163cc8be227646cb09719159f28ed09c5dc0dce0\":{\"balance\":\"0x487a9a304539440000\"},\"163dca73d7d6ea3f3e6062322a8734180c0b78ef\":{\"balance\":\"0x9f742003cb7dfc0000\"},\"164d7aac3eecbaeca1ad5191b753f173fe12ec33\":{\"balance\":\"0x285652b8a468690000\"},\"16526c9edf943efa4f6d0f0bae81e18b31c54079\":{\"balance\":\"0x35659ef93f0fc40000\"},\"165305b787322e25dc6ad0cefe6c6f334678d569\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1665ab1739d71119ee6132abbd926a279fe67948\":{\"balance\":\"0x56bc75e2d63100000\"},\"166bf6dab22d841b486c38e7ba6ab33a1487ed8c\":{\"balance\":\"0x43c33c1937564800000\"},\"167699f48a78c615512515739958993312574f07\":{\"balance\":\"0x21d3bd55e803c0000\"},\"1678c5f2a522393225196361894f53cc752fe2f3\":{\"balance\":\"0x68f365aea1e4400000\"},\"167ce7de65e84708595a525497a3eb5e5a665073\":{\"balance\":\"0x1f314773666fc40000\"},\"167e3e3ae2003348459392f7dfce44af7c21ad59\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"1680cec5021ee93050f8ae127251839e74c1f1fd\":{\"balance\":\"0x2c61461e5d743d68000\"},\"16816aac0ede0d2d3cd442da79e063880f0f1d67\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"168b5019b818691644835fe69bf229e17112d52c\":{\"balance\":\"0x5ede20f01a459800000\"},\"168bdec818eafc6d2992e5ef54aa0e1601e3c561\":{\"balance\":\"0x3637507a30abeb0000\"},\"168d30e53fa681092b52e9bae15a0dcb41a8c9bb\":{\"balance\":\"0x56bc75e2d63100000\"},\"169bbefc41cfd7d7cbb8dfc63020e9fb06d49546\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"16a58e985dccd707a594d193e7cca78b5d027849\":{\"balance\":\"0x49b9ca9a6943400000\"},\"16a9e9b73ae98b864d1728798b8766dbc6ea8d12\":{\"balance\":\"0x33e7b44b0db5040000\"},\"16aa52cb0b554723e7060f21f327b0a68315fea3\":{\"balance\":\"0xd8d726b7177a80000\"},\"16abb8b021a710bdc78ea53494b20614ff4eafe8\":{\"balance\":\"0x890b0c2e14fb80000\"},\"16afa787fc9f94bdff6976b1a42f430a8bf6fb0f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"16bae5d24eff91778cd98b4d3a1cc3162f44aa77\":{\"balance\":\"0x15be6174e1912e0000\"},\"16bc40215abbd9ae5d280b95b8010b4514ff1292\":{\"balance\":\"0xad78ebc5ac6200000\"},\"16be75e98a995a395222d00bd79ff4b6e638e191\":{\"balance\":\"0x79f905c6fd34e800000\"},\"16c1bf5b7dc9c83c179efacbcf2eb174e3561cb3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"16c7b31e8c376282ac2271728c31c95e35d952c3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"16f313cf8ad000914a0a176dc6a4342b79ec2538\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"16ffac84032940f0121a09668b858a7e79ffa3bb\":{\"balance\":\"0xd24ada6e1087110000\"},\"1703b4b292b8a9deddede81bb25d89179f6446b6\":{\"balance\":\"0x42b65a455e8b1680000\"},\"17049311101d817efb1d65910f663662a699c98c\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"1704cefcfb1331ec7a78388b29393e85c1af7916\":{\"balance\":\"0x15af1d78b58c400000\"},\"170a88a8997f92d238370f1affdee6347050b013\":{\"balance\":\"0xa2ac77351488300000\"},\"17108dab2c50f99de110e1b3b3b4cd82f5df28e7\":{\"balance\":\"0x35203b67bccad00000\"},\"17125b59ac51cee029e4bd78d7f5947d1ea49bb2\":{\"balance\":\"0x4a89f54ef0121c00000\"},\"171ad9a04bedc8b861e8ed4bddf5717813b1bb48\":{\"balance\":\"0x15af1d78b58c400000\"},\"171ca02a8b6d62bf4ca47e906914079861972cb2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1722c4cbe70a94b6559d425084caeed4d6e66e21\":{\"balance\":\"0xd8d726b7177a800000\"},\"17580b766f7453525ca4c6a88b01b50570ea088c\":{\"balance\":\"0x56bc75e2d63100000\"},\"17589a6c006a54cad70103123aae0a82135fdeb4\":{\"balance\":\"0xd8d726b7177a800000\"},\"175a183a3a235ffbb03ba835675267229417a091\":{\"balance\":\"0x3635c9adc5dea000000\"},\"175feeea2aa4e0efda12e1588d2f483290ede81a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1765361c2ec2f83616ce8363aae21025f2566f40\":{\"balance\":\"0x10f0cf064dd59200000\"},\"1767525c5f5a22ed80e9d4d7710f0362d29efa33\":{\"balance\":\"0x15af1d78b58c400000\"},\"17762560e82a93b3f522e0e524adb8612c3a7470\":{\"balance\":\"0x3635c9adc5dea00000\"},\"177dae78bc0113d8d39c4402f2a641ae2a105ab8\":{\"balance\":\"0x6292425620b4480000\"},\"1784948bf99848c89e445638504dd698271b5924\":{\"balance\":\"0x1474c410d87baee0000\"},\"1788da9b57fd05edc4ff99e7fef301519c8a0a1e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"178eaf6b8554c45dfde16b78ce0c157f2ee31351\":{\"balance\":\"0x1158e460913d000000\"},\"17961d633bcf20a7b029a7d94b7df4da2ec5427f\":{\"balance\":\"0xc6ff070f1938b8000\"},\"1796bcc97b8abc717f4b4a7c6b1036ea2182639f\":{\"balance\":\"0x1341f91cd8e3510000\"},\"17993d312aa1106957868f6a55a5e8f12f77c843\":{\"balance\":\"0x1865e814f4142e8000\"},\"179a825e0f1f6e985309668465cffed436f6aea9\":{\"balance\":\"0x1158e460913d00000\"},\"17b2d6cf65c6f4a347ddc6572655354d8a412b29\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17b807afa3ddd647e723542e7b52fee39527f306\":{\"balance\":\"0x15af40ffa7fc010000\"},\"17c0478657e1d3d17aaa331dd429cecf91f8ae5d\":{\"balance\":\"0x3634fb9f1489a70000\"},\"17c0fef6986cfb2e4041f9979d9940b69dff3de2\":{\"balance\":\"0xd8d726b7177a800000\"},\"17d4918dfac15d77c47f9ed400a850190d64f151\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17d521a8d9779023f7164d233c3b6420ffd223ed\":{\"balance\":\"0x1158e460913d00000\"},\"17d931d4c56294dcbe77c8655be4695f006d4a3c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17df49518d73b129f0da36b1c9b40cb66420fdc7\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"17e4a0e52bac3ee44efe0954e753d4b85d644e05\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17e584e810e567702c61d55d434b34cdb5ee30f6\":{\"balance\":\"0x10f0cf064dd59200000\"},\"17e82e7078dc4fd9e879fb8a50667f53a5c54591\":{\"balance\":\"0xad78ebc5ac6200000\"},\"17e86f3b5b30c0ba59f2b2e858425ba89f0a10b0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17ee9f54d4ddc84d670eff11e54a659fd72f4455\":{\"balance\":\"0x3635c9adc5dea000000\"},\"17ef4acc1bf147e326749d10e677dcffd76f9e06\":{\"balance\":\"0x87751f4e0e1b5300000\"},\"17f14632a7e2820be6e8f6df823558283dadab2d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"17f523f117bc9fe978aa481eb4f5561711371bc8\":{\"balance\":\"0x6c69f73e29134e0000\"},\"17fd9b551a98cb61c2e07fbf41d3e8c9a530cba5\":{\"balance\":\"0x1768c308193048000\"},\"180478a655d78d0f3b0c4f202b61485bc4002fd5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"18136c9df167aa17b6f18e22a702c88f4bc28245\":{\"balance\":\"0xd8d726b7177a800000\"},\"1815279dff9952da3be8f77249dbe22243377be7\":{\"balance\":\"0x1017cb76e7b26640000\"},\"181fbba852a7f50178b1c7f03ed9e58d54162929\":{\"balance\":\"0x241a9b4f617a280000\"},\"1827039f09570294088fddf047165c33e696a492\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"182db85293f606e88988c3704cb3f0c0bbbfca5a\":{\"balance\":\"0x73f75d1a085ba0000\"},\"1848003c25bfd4aa90e7fcb5d7b16bcd0cffc0d8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"184a4f0beb71ffd558a6b6e8f228b78796c4cf3e\":{\"balance\":\"0x28a857425466f800000\"},\"184d86f3466ae6683b19729982e7a7e1a48347b2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1851a063ccdb30549077f1d139e72de7971197d5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"185546e8768d506873818ac9751c1f12116a3bef\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1858cf11aea79f5398ad2bb22267b5a3c952ea74\":{\"balance\":\"0x215f835bc769da80000\"},\"185a7fc4ace368d233e620b2a45935661292bdf2\":{\"balance\":\"0x43c33c1937564800000\"},\"1864a3c7b48155448c54c88c708f166709736d31\":{\"balance\":\"0x73f75d1a085ba0000\"},\"186afdc085f2a3dce4615edffbadf71a11780f50\":{\"balance\":\"0xad78ebc5ac6200000\"},\"186b95f8e5effddcc94f1a315bf0295d3b1ea588\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"187d9f0c07f8eb74faaad15ebc7b80447417f782\":{\"balance\":\"0x1158e460913d00000\"},\"1895a0eb4a4372722fcbc5afe6936f289c88a419\":{\"balance\":\"0x3154c9729d05780000\"},\"1899f69f653b05a5a6e81f480711d09bbf97588c\":{\"balance\":\"0x69fb133df750ac0000\"},\"18a6d2fc52be73084023c91802f05bc24a4be09f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"18b0407cdad4ce52600623bd5e1f6a81ab61f026\":{\"balance\":\"0x1151ccf0c654c68000\"},\"18b8bcf98321da61fb4e3eacc1ec5417272dc27e\":{\"balance\":\"0x2fb474098f67c00000\"},\"18c6723a6753299cb914477d04a3bd218df8c775\":{\"balance\":\"0x3635c9adc5dea00000\"},\"18e113d8177c691a61be785852fa5bb47aeebdaf\":{\"balance\":\"0x487a9a304539440000\"},\"18e4ce47483b53040adbab35172c01ef64506e0c\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"18e53243981aabc8767da10c73449f1391560eaa\":{\"balance\":\"0x14542ba12a337c00000\"},\"18fa8625c9dc843c78c7ab259ff87c9599e07f10\":{\"balance\":\"0x3635c9adc5dea00000\"},\"18fb09188f27f1038e654031924f628a2106703d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"18fccf62d2c3395453b7587b9e26f5cff9eb7482\":{\"balance\":\"0x3635c9adc5dea00000\"},\"191313525238a21c767457a91374f02200c55448\":{\"balance\":\"0x64f5fdf494f780000\"},\"1914f1eb95d1277e93b6e61b668b7d77f13a11a1\":{\"balance\":\"0x34957444b840e80000\"},\"1923cfc68b13ea7e2055803645c1e320156bd88d\":{\"balance\":\"0x487a9a304539440000\"},\"19336a236ded755872411f2e0491d83e3e00159e\":{\"balance\":\"0x32f51edbaaa3300000\"},\"1933e334c40f3acbad0c0b851158206924beca3a\":{\"balance\":\"0x1995eaf01b896188000\"},\"1937c5c515057553ccbd46d5866455ce66290284\":{\"balance\":\"0xd3c21bcecceda1000000\"},\"193ac65183651800e23580f8f0ead3bb597eb8a4\":{\"balance\":\"0x2b62abcfb910a0000\"},\"193d37ed347d1c2f4e35350d9a444bc57ca4db43\":{\"balance\":\"0x340aad21b3b700000\"},\"1940dc9364a852165f47414e27f5002445a4f143\":{\"balance\":\"0x24c2dff6a3c7c480000\"},\"1945fe377fe6d4b71e3e791f6f17db243c9b8b0f\":{\"balance\":\"0x7679e7beb988360000\"},\"194a6bb302b8aba7a5b579df93e0df1574967625\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"194cebb4929882bf3b4bf9864c2b1b0f62c283f9\":{\"balance\":\"0x1ef861531f74aa0000\"},\"194ff44aefc17bd20efd7a204c47d1620c86db5d\":{\"balance\":\"0xa29909687f6aa40000\"},\"194ffe78bbf5d20dd18a1f01da552e00b7b11db1\":{\"balance\":\"0x17b7883c06916600000\"},\"1953313e2ad746239cb2270f48af34d8bb9c4465\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"19571a2b8f81c6bcf66ab3a10083295617150003\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"19687daa39c368139b6e7be60dc1753a9f0cbea3\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"196c02210a450ab0b36370655f717aa87bd1c004\":{\"balance\":\"0xe10ace157dbc00000\"},\"196e85df7e732b4a8f0ed03623f4db9db0b8fa31\":{\"balance\":\"0x125b92f5cef248000\"},\"19732bf973055dbd91a4533adaa2149a91d38380\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"197672fd39d6f246ce66a790d13aa922d70ea109\":{\"balance\":\"0x3635c9adc5dea00000\"},\"19798cbda715ea9a9b9d6aab942c55121e98bf91\":{\"balance\":\"0x410d586a20a4c00000\"},\"198bfcf1b07ae308fa2c02069ac9dafe7135fb47\":{\"balance\":\"0x1158e460913d00000\"},\"198ef1ec325a96cc354c7266a038be8b5c558f67\":{\"balance\":\"0x80d1e4373e7f21da0000\"},\"19918aa09e7d494e98ffa5db50350892f7156ac6\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"19b36b0c87ea664ed80318dc77b688dde87d95a5\":{\"balance\":\"0x699f499802303d0000\"},\"19df9445a81c1b3d804aeaeb6f6e204e4236663f\":{\"balance\":\"0x206d94e6a49878000\"},\"19e5dea3370a2c746aae34a37c531f41da264e83\":{\"balance\":\"0xad78ebc5ac6200000\"},\"19e7f3eb7bf67f3599209ebe08b62ad3327f8cde\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"19e94e620050aad766b9e1bad931238312d4bf49\":{\"balance\":\"0x81e32df972abf00000\"},\"19ecf2abf40c9e857b252fe1dbfd3d4c5d8f816e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"19f5caf4c40e6908813c0745b0aea9586d9dd931\":{\"balance\":\"0x23fed9e1fa2b600000\"},\"19f643e1a8fa04ae16006028138333a59a96de87\":{\"balance\":\"0x1158e460913d00000\"},\"19f99f2c0b46ce8906875dc9f90ae104dae35594\":{\"balance\":\"0xf4575a5d4d162a0000\"},\"19ff244fcfe3d4fa2f4fd99f87e55bb315b81eb6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1a04cec420ad432215246d77fe178d339ed0b595\":{\"balance\":\"0x11216185c29f700000\"},\"1a04d5389eb006f9ce880c30d15353f8d11c4b31\":{\"balance\":\"0x39d84b2186dc9100000\"},\"1a0841b92a7f7075569dc4627e6b76cab05ade91\":{\"balance\":\"0x52663ccab1e1c00000\"},\"1a085d43ec92414ea27b914fe767b6d46b1eef44\":{\"balance\":\"0x641e8a13563d8f80000\"},\"1a09fdc2c7a20e23574b97c69e93deba67d37220\":{\"balance\":\"0x6c4fd1ee246e780000\"},\"1a0a1ddfb031e5c8cc1d46cf05842d50fddc7130\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1a1c9a26e0e02418a5cf687da75a275c622c9440\":{\"balance\":\"0x10f0cf064dd59200000\"},\"1a201b4327cea7f399046246a3c87e6e03a3cda8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1a2434cc774422d48d53d59c5d562cce8407c94b\":{\"balance\":\"0x1a055690d9db80000\"},\"1a25e1c5bc7e5f50ec16f8885f210ea1b938800e\":{\"balance\":\"0xd8d726b7177a800000\"},\"1a2694ec07cf5e4d68ba40f3e7a14c53f3038c6e\":{\"balance\":\"0x3636cd06e2db3a8000\"},\"1a3520453582c718a21c42375bc50773255253e1\":{\"balance\":\"0x2ad373ce668e980000\"},\"1a376e1b2d2f590769bb858d4575320d4e149970\":{\"balance\":\"0x106712576391d180000\"},\"1a3a330e4fcb69dbef5e6901783bf50fd1c15342\":{\"balance\":\"0xe3aeb5737240a00000\"},\"1a4ec6a0ae7f5a9427d23db9724c0d0cffb2ab2f\":{\"balance\":\"0x9b41fbf9e0aec0000\"},\"1a505e62a74e87e577473e4f3afa16bedd3cfa52\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"1a5ee533acbfb3a2d76d5b685277b796c56a052b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1a644a50cbc2aee823bd2bf243e825be4d47df02\":{\"balance\":\"0x56be03ca3e47d8000\"},\"1a7044e2383f8708305b495bd1176b92e7ef043a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1a79c7f4039c67a39d7513884cdc0e2c34222490\":{\"balance\":\"0x1158e460913d00000\"},\"1a89899cbebdbb64bb26a195a63c08491fcd9eee\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1a8a5ce414de9cd172937e37f2d59cff71ce57a0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1a95a8a8082e4652e4170df9271cb4bb4305f0b2\":{\"balance\":\"0x2b5e3af16b1880000\"},\"1a95c9b7546b5d1786c3858fb1236446bc0ca4ce\":{\"balance\":\"0x6acb3df27e1f880000\"},\"1a987e3f83de75a42f1bde7c997c19217b4a5f24\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1a9e702f385dcd105e8b9fa428eea21c57ff528a\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"1aa1021f550af158c747668dd13b463160f95a40\":{\"balance\":\"0x4fb0591b9b30380000\"},\"1aa27699cada8dc3a76f7933aa66c71919040e88\":{\"balance\":\"0x15af1d78b58c400000\"},\"1aa40270d21e5cde86b6316d1ac3c533494b79ed\":{\"balance\":\"0x1158e460913d00000\"},\"1ab53a11bcc63ddfaa40a02b9e186496cdbb8aff\":{\"balance\":\"0x6c3f2aac800c000000\"},\"1abc4e253b080aeb437984ab05bca0979aa43e1c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1ac089c3bc4d82f06a20051a9d732dc0e734cb61\":{\"balance\":\"0x25f69d63a6ce0e0000\"},\"1ad4563ea5786be1159935abb0f1d5879c3e7372\":{\"balance\":\"0x14542ba12a337c00000\"},\"1ad72d20a76e7fcc6b764058f48d417d496fa6cd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1adaf4abfa867db17f99af6abebf707a3cf55df6\":{\"balance\":\"0x14542ba12a337c00000\"},\"1af60343360e0b2d75255210375720df21db5c7d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1afcc585896cd0ede129ee2de5c19ea811540b64\":{\"balance\":\"0xaf2aba0c8e5bef8000\"},\"1b05ea6a6ac8af7cb6a8b911a8cce8fe1a2acfc8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1b0b31afff4b6df3653a94d7c87978ae35f34aae\":{\"balance\":\"0x133910453fa9840000\"},\"1b0d076817e8d68ee2df4e1da1c1142d198c4435\":{\"balance\":\"0x54069233bf7f780000\"},\"1b130d6fa51d5c48ec8d1d52dc8a227be8735c8a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1b23cb8663554871fbbe0d9e60397efb6faedc3e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1b2639588b55c344b023e8de5fd4087b1f040361\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"1b3920d001c43e72b24e7ca46f0fd6e0c20a5ff2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1b3cb81e51011b549d78bf720b0d924ac763a7c2\":{\"balance\":\"0x7695a92c20d6fe000000\"},\"1b43232ccd4880d6f46fa751a96cd82473315841\":{\"balance\":\"0x4563918244f400000\"},\"1b4bbcb18165211b265b280716cb3f1f212176e8\":{\"balance\":\"0x199ad37d03d0608000\"},\"1b4d07acd38183a61bb2783d2b7b178dd502ac8d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1b636b7a496f044d7359596e353a104616436f6b\":{\"balance\":\"0x1388ea95c33f1d0000\"},\"1b6495891240e64e594493c2662171db5e30ce13\":{\"balance\":\"0x95887d695ed580000\"},\"1b6610fb68bad6ed1cfaa0bbe33a24eb2e96fafb\":{\"balance\":\"0x83d6c7aab63600000\"},\"1b799033ef6dc7127822f74542bb22dbfc09a308\":{\"balance\":\"0x56bc75e2d63100000\"},\"1b7ed974b6e234ce81247498429a5bd4a0a2d139\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1b826fb3c012b0d159e294ba5b8a499ff3c0e03c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1b8aa0160cd79f005f88510a714913d70ad3be33\":{\"balance\":\"0xaeffb83079ad00000\"},\"1b8bd6d2eca20185a78e7d98e8e185678dac4830\":{\"balance\":\"0x3894f0e6f9b9f700000\"},\"1b9b2dc2960e4cb9408f7405827c9b59071612fd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1ba9228d388727f389150ea03b73c82de8eb2e09\":{\"balance\":\"0x18974fbe177c9280000\"},\"1ba9f7997e5387b6b2aa0135ac2452fe36b4c20d\":{\"balance\":\"0x2e141ea081ca080000\"},\"1bba03ff6b4ad5bf18184acb21b188a399e9eb4a\":{\"balance\":\"0x61093d7c2c6d380000\"},\"1bbc199e586790be87afedc849c04726745c5d7b\":{\"balance\":\"0xd8d726b7177a800000\"},\"1bbc60bcc80e5cdc35c5416a1f0a40a83dae867b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1bc44c8761231ba1f11f5faa40fa669a013e12ce\":{\"balance\":\"0xb0952c45aeaad0000\"},\"1bcf3441a866bdbe963009ce33c81cbb0261b02c\":{\"balance\":\"0x9ddc1e3b901180000\"},\"1bd28cd5c78aee51357c95c1ef9235e7c18bc854\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1bd8ebaa7674bb18e19198db244f570313075f43\":{\"balance\":\"0x821ab0d4414980000\"},\"1bd909ac0d4a1102ec98dcf2cca96a0adcd7a951\":{\"balance\":\"0x11651ac3e7a758000\"},\"1be3542c3613687465f15a70aeeb81662b65cca8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1bea4df5122fafdeb3607eddda1ea4ffdb9abf2a\":{\"balance\":\"0x12c1b6eed03d280000\"},\"1bec4d02ce85fc48feb62489841d85b170586a9b\":{\"balance\":\"0x821ab0d44149800000\"},\"1bf974d9904f45ce81a845e11ef4cbcf27af719e\":{\"balance\":\"0x56bc75e2d63100000\"},\"1c045649cd53dc23541f8ed4d341812808d5dd9c\":{\"balance\":\"0x17b7883c06916600000\"},\"1c128bd6cda5fca27575e4b43b3253c8c4172afe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1c13d38637b9a47ce79d37a86f50fb409c060728\":{\"balance\":\"0x487a9a304539440000\"},\"1c2010bd662df417f2a271879afb13ef4c88a3ae\":{\"balance\":\"0xd8d726b7177a800000\"},\"1c257ad4a55105ea3b58ed374b198da266c85f63\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1c2e3607e127caca0fbd5c5948adad7dd830b285\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"1c356cfdb95febb714633b28d5c132dd84a9b436\":{\"balance\":\"0x15af1d78b58c40000\"},\"1c35aab688a0cd8ef82e76541ba7ac39527f743b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"1c3ef05dae9dcbd489f3024408669de244c52a02\":{\"balance\":\"0x43c33c1937564800000\"},\"1c4af0e863d2656c8635bc6ffec8dd9928908cb5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1c601993789207f965bb865cbb4cd657cce76fc0\":{\"balance\":\"0x5541a7037503f0000\"},\"1c63fa9e2cbbf23c49fcdef1cbabfe6e0d1e14c1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1c6702b3b05a5114bdbcaeca25531aeeb34835f4\":{\"balance\":\"0x58556bead45dcae0000\"},\"1c68a66138783a63c98cc675a9ec77af4598d35e\":{\"balance\":\"0x2b746f48f0f120000\"},\"1c73d00b6e25d8eb9c1ff4ad827b6b9e9cf6d20c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1c751e7f24df9d94a637a5dedeffc58277b5db19\":{\"balance\":\"0xae8e7a0bb575d00000\"},\"1c7cb2fe6bf3e09cbcdc187af38fa8f5053a70b6\":{\"balance\":\"0x21c84f742d0cead8000\"},\"1c89060f987c518fa079ec2c0a5ebfa30f5d20f7\":{\"balance\":\"0x80bfbefcb5f0bc00000\"},\"1c94d636e684eb155895ce6db4a2588fba1d001b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1c99fe9bb6c6d1066d912099547fd1f4809eacd9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1cb450920078aab2317c7db3b38af7dd298b2d41\":{\"balance\":\"0x126e72a69a50d00000\"},\"1cb5f33b4d488936d13e3161da33a1da7df70d1b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1cb6b2d7cfc559b7f41e6f56ab95c7c958cd0e4c\":{\"balance\":\"0x487a9a304539440000\"},\"1cc1d3c14f0fb8640e36724dc43229d2ea7a1e48\":{\"balance\":\"0x5c283d410394100000\"},\"1cc90876004109cd79a3dea866cb840ac364ba1b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1cd1f0a314cbb200de0a0cb1ef97e920709d97c2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1cda411bd5163baeca1e558563601ce720e24ee1\":{\"balance\":\"0xfc936392801c0000\"},\"1ce81d31a7923022e125bf48a3e03693b98dc9dd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1cebf0985d7f680aaa915c44cc62edb49eab269e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1ced6715f862b1ff86058201fcce5082b36e62b2\":{\"balance\":\"0x16a5e60bee273b10000\"},\"1cf04cb14380059efd3f238b65d5beb86afa14d8\":{\"balance\":\"0x1158e460913d00000\"},\"1cf105ab23023b554c583e86d7921179ee83169f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"1cf2eb7a8ccac2adeaef0ee87347d535d3b94058\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1cfcf7517f0c08459720942b647ad192aa9c8828\":{\"balance\":\"0x2b5e3af16b18800000\"},\"1d09ad2412691cc581c1ab36b6f9434cd4f08b54\":{\"balance\":\"0x17b7883c06916600000\"},\"1d157c5876c5cad553c912caf6ce2d5277e05c73\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1d2615f8b6ca5012b663bdd094b0c5137c778ddf\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1d29c7aab42b2048d2b25225d498dba67a03fbb2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1d341fa5a3a1bd051f7db807b6db2fc7ba4f9b45\":{\"balance\":\"0xfc936392801c0000\"},\"1d344e962567cb27e44db9f2fac7b68df1c1e6f7\":{\"balance\":\"0x692ae8897081d00000\"},\"1d36683063b7e9eb99462dabd569bddce71686f2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1d37616b793f94911838ac8e19ee9449df921ec4\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"1d395b30adda1cf21f091a4f4a7b753371189441\":{\"balance\":\"0x152d02c7e14af6800000\"},\"1d45586eb803ca2190650bf748a2b174312bb507\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"1d572edd2d87ca271a6714c15a3b37761dcca005\":{\"balance\":\"0x6ebd52a8ddd390000\"},\"1d633097a85225a1ff4321b12988fdd55c2b3844\":{\"balance\":\"0xd8d726b7177a800000\"},\"1d69c83d28ff0474ceebeacb3ad227a144ece7a3\":{\"balance\":\"0x128cc03920a62d28000\"},\"1d96bcd58457bbf1d3c2a46ffaf16dbf7d836859\":{\"balance\":\"0x9497209d8467e8000\"},\"1d9e6aaf8019a05f230e5def05af5d889bd4d0f2\":{\"balance\":\"0x73f75d1a085ba0000\"},\"1dab172effa6fbee534c94b17e794edac54f55f8\":{\"balance\":\"0x6acb3df27e1f880000\"},\"1db9ac9a9eaeec0a523757050c71f47278c72d50\":{\"balance\":\"0x487a9a304539440000\"},\"1dbe8e1c2b8a009f85f1ad3ce80d2e05350ee39c\":{\"balance\":\"0x7570d6e9ebbe40000\"},\"1dc7f7dad85df53f1271152403f4e1e4fdb3afa0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1dcebcb7656df5dcaa3368a055d22f9ed6cdd940\":{\"balance\":\"0x1b181e4bf2343c0000\"},\"1dd77441844afe9cc18f15d8c77bccfb655ee034\":{\"balance\":\"0x106eb45579944880000\"},\"1ddefefd35ab8f658b2471e54790bc17af98dea4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1deec01abe5c0d952de9106c3dc30639d85005d6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1df6911672679bb0ef3509038c0c27e394fdfe30\":{\"balance\":\"0x1d460162f516f00000\"},\"1dfaee077212f1beaf0e6f2f1840537ae154ad86\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1e060dc6c5f1cb8cc7e1452e02ee167508b56542\":{\"balance\":\"0x2b14f02c864c77e0000\"},\"1e13ec51142cebb7a26083412c3ce35144ba56a1\":{\"balance\":\"0x10f0cf064dd59200000\"},\"1e1a4828119be309bd88236e4d482b504dc55711\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"1e1aed85b86c6562cb8fa1eb6f8f3bc9dcae6e79\":{\"balance\":\"0xf4d2dd84259b240000\"},\"1e1c6351776ac31091397ecf16002d979a1b2d51\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"1e1d7a5f2468b94ea826982dbf2125793c6e4a5a\":{\"balance\":\"0x3634f48417401a0000\"},\"1e210e7047886daa52aaf70f4b991dac68e3025e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1e2bf4ba8e5ef18d37de6d6ad636c4cae489d0cc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1e2fe4e4a77d141ff49a0c7fbc95b0a2b283eeeb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1e33d1c2fb5e084f2f1d54bc5267727fec3f985d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"1e381adcf801a3bf9fd7bfac9ccc2b8482ad5e66\":{\"balance\":\"0x208972c0010d740000\"},\"1e3badb1b6e1380e27039c576ae6222e963a5b53\":{\"balance\":\"0x43c33c1937564800000\"},\"1e484d0621f0f5331b35d5408d9aae4eb1acf21e\":{\"balance\":\"0x1158e460913d00000\"},\"1e5800227d4dcf75e30f5595c5bed3f72e341e3b\":{\"balance\":\"0xd75dace73417e0000\"},\"1e596a81b357c6f24970cc313df6dbdaabd0d09e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1e6915ebd9a19c81b692ad99b1218a592c1ac7b1\":{\"balance\":\"0xd8d726b7177a800000\"},\"1e6e0153fc161bc05e656bbb144c7187bf4fe84d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1e706655e284dcf0bb37fe075d613a18dc12ff4a\":{\"balance\":\"0xed43bf1eee82ac0000\"},\"1e783e522ab7df0acaac9eeed3593039e5ac7579\":{\"balance\":\"0x2b1446dd6aefe41c0000\"},\"1e7b5e4d1f572becf2c00fc90cb4767b4a6e33d4\":{\"balance\":\"0x61fc6107593e10000\"},\"1e8e689b02917cdc29245d0c9c68b094b41a9ed6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1ea334b5750807ea74aac5ab8694ec5f28aa77cf\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"1ea4715504c6af107b0194f4f7b1cb6fcccd6f4b\":{\"balance\":\"0x20043197e0b0270000\"},\"1ea492bce1ad107e337f4bd4a7ac9a7babcccdab\":{\"balance\":\"0x56bc75e2d63100000\"},\"1ea6bf2f15ae9c1dbc64daa7f8ea4d0d81aad3eb\":{\"balance\":\"0xe3aeb5737240a00000\"},\"1eb4bf73156a82a0a6822080c6edf49c469af8b9\":{\"balance\":\"0x678a932062e4180000\"},\"1ebacb7844fdc322f805904fbf1962802db1537c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"1ec4ec4b77bf19d091a868e6f49154180541f90e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1ed06ee51662a86c634588fb62dc43c8f27e7c17\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1ed8bb3f06778b039e9961d81cb71a73e6787c8e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1eda084e796500ba14c5121c0d90846f66e4be62\":{\"balance\":\"0x1cfdd7468216e80000\"},\"1eee6cbee4fe96ad615a9cf5857a647940df8c78\":{\"balance\":\"0x10d3aa536e2940000\"},\"1ef2dcbfe0a500411d956eb8c8939c3d6cfe669d\":{\"balance\":\"0x2a1129d09367200000\"},\"1ef5c9c73650cfbbde5c885531d427c7c3fe5544\":{\"balance\":\"0x14542ba12a337c00000\"},\"1f0412bfedcd964e837d092c71a5fcbaf30126e2\":{\"balance\":\"0x1158e460913d00000\"},\"1f174f40a0447234e66653914d75bc003e5690dc\":{\"balance\":\"0x8ac7230489e800000\"},\"1f2186ded23e0cf9521694e4e164593e690a9685\":{\"balance\":\"0x1043561a8829300000\"},\"1f2afc0aed11bfc71e77a907657b36ea76e3fb99\":{\"balance\":\"0xd8d726b7177a800000\"},\"1f3959fc291110e88232c36b7667fc78a379613f\":{\"balance\":\"0xfc936392801c0000\"},\"1f3da68fe87eaf43a829ab6d7ec5a6e009b204fb\":{\"balance\":\"0x1e1601758c2c7e0000\"},\"1f49b86d0d3945590698a6aaf1673c37755ca80d\":{\"balance\":\"0x25f273933db5700000\"},\"1f5f3b34bd134b2781afe5a0424ac5846cdefd11\":{\"balance\":\"0x55de6a779bbac0000\"},\"1f6f0030349752061c96072bc3d6eb3549208d6b\":{\"balance\":\"0x14b8de1eb88db8000\"},\"1f7d8e86d6eeb02545aad90e91327bd369d7d2f3\":{\"balance\":\"0x1158e460913d00000\"},\"1f8116bd0af5570eaf0c56c49c7ab5e37a580458\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"1f88f8a1338fc7c10976abcd3fb8d38554b5ec9c\":{\"balance\":\"0xb9f65d00f63c0000\"},\"1f9c3268458da301a2be5ab08257f77bb5a98aa4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"1fa2319fed8c2d462adf2e17feec6a6f30516e95\":{\"balance\":\"0x6cae30621d4720000\"},\"1fb463a0389983df7d593f7bdd6d78497fed8879\":{\"balance\":\"0x1158e460913d00000\"},\"1fb7bd310d95f2a6d9baaf8a8a430a9a04453a8b\":{\"balance\":\"0xa2a15d09519be00000\"},\"1fcc7ce6a8485895a3199e16481f72e1f762defe\":{\"balance\":\"0x3635c9adc5dea00000\"},\"1fcfd1d57f872290560cb62d600e1defbefccc1c\":{\"balance\":\"0x50c5e761a444080000\"},\"1fd296be03ad737c92f9c6869e8d80a71c5714aa\":{\"balance\":\"0xb98bc829a6f90000\"},\"1fddd85fc98be9c4045961f40f93805ecc4549e5\":{\"balance\":\"0x8e3f50b173c100000\"},\"2001bef77b66f51e1599b02fb110194a0099b78d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"200264a09f8c68e3e6629795280f56254f8640d0\":{\"balance\":\"0x1158e460913d00000\"},\"2003717907a72560f4307f1beecc5436f43d21e7\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"200dfc0b71e359b2b465440a36a6cdc352773007\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"20134cbff88bfadc466b52eceaa79857891d831e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2014261f01089f53795630ba9dd24f9a34c2d942\":{\"balance\":\"0x487a9a304539440000\"},\"2016895df32c8ed5478269468423aea7b7fbce50\":{\"balance\":\"0x1158e460913d00000\"},\"20181c4b41f6f972b66958215f19f570c15ddff1\":{\"balance\":\"0x56bc75e2d631000000\"},\"201864a8f784c2277b0b7c9ee734f7b377eab648\":{\"balance\":\"0xf2281400d1d5ec0000\"},\"2020b81ae53926ace9f7d7415a050c031d585f20\":{\"balance\":\"0x127f19e83eb3480000\"},\"203c6283f20df7bc86542fdfb4e763ecdbbbeef5\":{\"balance\":\"0x54b40b1f852bda00000\"},\"204ac98867a7c9c7ed711cb82f28a878caf69b48\":{\"balance\":\"0x14542ba12a337c00000\"},\"205237c4be146fba99478f3a7dad17b09138da95\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2053ac97548a0c4e8b80bc72590cd6a098fe7516\":{\"balance\":\"0xa2325753b460c0000\"},\"205f5166f12440d85762c967d3ae86184f8f4d98\":{\"balance\":\"0x177224aa844c720000\"},\"205fc843e19a4913d1881eb69b69c0fa3be5c50b\":{\"balance\":\"0x20dd68aaf3289100000\"},\"206482ee6f138a778fe1ad62b180ce856fbb23e6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2066774d822793ff25f1760909479cf62491bf88\":{\"balance\":\"0xbae3ac685cb72e00000\"},\"206d55d5792a514ec108e090599f2a065e501185\":{\"balance\":\"0xadf30ba70c8970000\"},\"20707e425d2a11d2c89f391b2b809f556c592421\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"207ef80b5d60b6fbffc51f3a64b8c72036a5abbd\":{\"balance\":\"0x16a6502f15a1e540000\"},\"20824ba1dbebbef9846ef3d0f6c1b017e6912ec4\":{\"balance\":\"0x184b26e4daf1d350000\"},\"2084fce505d97bebf1ad8c5ff6826fc645371fb2\":{\"balance\":\"0x1a055690d9db80000\"},\"208c45732c0a378f17ac8324926d459ba8b658b4\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"209377b6ad3fe101c9685b3576545c6b1684e73c\":{\"balance\":\"0x62a992e53a0af00000\"},\"209e8e29d33beae8fb6baa783d133e1d9ec1bc0b\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"20a15256d50ce058bf0eac43aa533aa16ec9b380\":{\"balance\":\"0x1158e460913d00000\"},\"20a29c5079e26b3f18318bb2e50e8e8b346e5be8\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"20a81680e465f88790f0074f60b4f35f5d1e6aa5\":{\"balance\":\"0x456180278f0c778000\"},\"20b9a9e6bd8880d9994ae00dd0b9282a0beab816\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"20c284ba10a20830fc3d699ec97d2dfa27e1b95e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"20d1417f99c569e3beb095856530fe12d0fceaaa\":{\"balance\":\"0x4015f94b1183698000\"},\"20dd8fcbb46ea46fe381a68b8ca0ea5be21fe9a5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"20ff3ede8cadb5c37b48cb14580fb65e23090a7b\":{\"balance\":\"0x8e4d316827686400000\"},\"2100381d60a5b54adc09d19683a8f6d5bb4bfbcb\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2118c116ab0cdf6fd11d54a4309307b477c3fc0f\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"211b29cefc79ae976744fdebcebd3cbb32c51303\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"21206ce22ea480e85940d31314e0d64f4e4d3a04\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2132c0516a2e17174ac547c43b7b0020d1eb4c59\":{\"balance\":\"0x35659ef93f0fc40000\"},\"21408b4d7a2c0e6eca4143f2cacdbbccba121bd8\":{\"balance\":\"0x43c33c1937564800000\"},\"214b743955a512de6e0d886a8cbd0282bee6d2a2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"214c89c5bd8e7d22bc574bb35e48950211c6f776\":{\"balance\":\"0x10654f258fd358000\"},\"21546914dfd3af2add41b0ff3e83ffda7414e1e0\":{\"balance\":\"0x14395e7385a502e0000\"},\"21582e99e502cbf3d3c23bdffb76e901ac6d56b2\":{\"balance\":\"0x56bc75e2d63100000\"},\"2159240813a73095a7ebf7c3b3743e8028ae5f09\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2160b4c02cac0a81de9108de434590a8bfe68735\":{\"balance\":\"0x6acb3df27e1f880000\"},\"216e41864ef98f060da08ecae19ad1166a17d036\":{\"balance\":\"0x1369fb96128ac480000\"},\"21846f2fdf5a41ed8df36e5ed8544df75988ece3\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"21a6db6527467bc6dad54bc16e9fe2953b6794ed\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"21a6feb6ab11c766fdd977f8df4121155f47a1c0\":{\"balance\":\"0x319cf38f100580000\"},\"21b182f2da2b384493cf5f35f83d9d1ee14f2a21\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"21bfe1b45cacde6274fd8608d9a178bf3eeb6edc\":{\"balance\":\"0x6cee06ddbe15ec0000\"},\"21c07380484f6cbc8724ad32bc864c3b5ad500b7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"21c3a8bba267c8cca27b1a9afabad86f607af708\":{\"balance\":\"0x1e4a36c49d998300000\"},\"21ce6d5b9018cec04ad6967944bea39e8030b6b8\":{\"balance\":\"0x1158e460913d00000\"},\"21d02705f3f64905d80ed9147913ea8c7307d695\":{\"balance\":\"0x49edb1c09887360000\"},\"21d13f0c4024e967d9470791b50f22de3afecf1b\":{\"balance\":\"0xf15ad35e2e31e50000\"},\"21dbdb817a0d8404c6bdd61504374e9c43c9210e\":{\"balance\":\"0x21e18b9e9ab45e48000\"},\"21df1ec24b4e4bfe79b0c095cebae198f291fbd1\":{\"balance\":\"0x43c33c1937564800000\"},\"21df2dcdaf74b2bf803404dd4de6a35eabec1bbd\":{\"balance\":\"0x177224aa844c7200000\"},\"21e219c89ca8ac14ae4cba6130eeb77d9e6d3962\":{\"balance\":\"0x2acd9faaa038ee0000\"},\"21e5d2bae995ccfd08a5c16bb524e1f630448f82\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"21e5d77320304c201c1e53b261a123d0a1063e81\":{\"balance\":\"0x4b6fa9d33dd460000\"},\"21eae6feffa9fbf4cd874f4739ace530ccbe5937\":{\"balance\":\"0x10f0cf064dd59200000\"},\"21ecb2dfa65779c7592d041cd2105a81f4fd4e46\":{\"balance\":\"0x3635c9adc5dea00000\"},\"21efbca09b3580b98e73f5b2f7f4dc0bf02c529c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"21fd0bade5f4ef7474d058b7f3d854cb1300524e\":{\"balance\":\"0x1158e460913d00000\"},\"21fd47c5256012198fa5abf131c06d6aa1965f75\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"21fd6c5d97f9c600b76821ddd4e776350fce2be0\":{\"balance\":\"0x6c6ad382d4fb610000\"},\"220dc68df019b6b0ccbffb784b5a5ab4b15d4060\":{\"balance\":\"0xd5967be4fc3f100000\"},\"220e2b92c0f6c902b513d9f1e6fab6a8b0def3d7\":{\"balance\":\"0x2b5e3af16b18800000\"},\"22561c5931143536309c17e832587b625c390b9a\":{\"balance\":\"0xd8d726b7177a800000\"},\"2257fca16a6e5c2a647c3c29f36ce229ab93b17e\":{\"balance\":\"0xd8d726b7177a800000\"},\"225d35faedb391c7bc2db7fa9071160405996d00\":{\"balance\":\"0x91854fc1862630000\"},\"225f9eb3fb6ff3e9e3c8447e14a66e8d4f3779f6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2272186ef27dcbe2f5fc373050fdae7f2ace2316\":{\"balance\":\"0x368c8623a8b4d100000\"},\"2273bad7bc4e487622d175ef7a66988b6a93c4ee\":{\"balance\":\"0x1158e460913d00000\"},\"2276264bec8526c0c0f270677abaf4f0e441e167\":{\"balance\":\"0x3635c9adc5dea00000\"},\"228242f8336eecd8242e1f000f41937e71dffbbf\":{\"balance\":\"0x10f0cf064dd59200000\"},\"22842ab830da509913f81dd1f04f10af9edd1c55\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"22944fbca9b57963084eb84df7c85fb9bcdfb856\":{\"balance\":\"0xfc118fef90ba388000\"},\"229cc4711b62755ea296445ac3b77fc633821cf2\":{\"balance\":\"0x223e8b05219328000\"},\"229e430de2b74f442651ddcdb70176bc054cad54\":{\"balance\":\"0xbbf981bc4aaa8000\"},\"229f4f1a2a4f540774505b4707a81de44410255b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"229ff80bf5708009a9f739e0f8b560914016d5a6\":{\"balance\":\"0x1211ecb56d13488000\"},\"22a25812ab56dcc423175ed1d8adacce33cd1810\":{\"balance\":\"0x6449e84e47a8a80000\"},\"22b96ab2cad55db100b53001f9e4db378104c807\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"22bdffc240a88ff7431af3bff50e14da37d5183e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"22ce349159eeb144ef06ff2636588aef79f62832\":{\"balance\":\"0xa31062beeed700000\"},\"22db559f2c3c1475a2e6ffe83a5979599196a7fa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"22e15158b5ee3e86eb0332e3e6a9ac6cd9b55ecd\":{\"balance\":\"0x8ac7230489e800000\"},\"22e2488e2da26a49ae84c01bd54b21f2947891c6\":{\"balance\":\"0x5dc892aa1131c80000\"},\"22e512149a18d369b73c71efa43e86c9edabaf1d\":{\"balance\":\"0x4ee02e6714615c0000\"},\"22eb7db0ba56b0f8b816ccb206e615d929185b0d\":{\"balance\":\"0x45d29737e22f20000\"},\"22eed327f8eb1d1338a3cb7b0f8a4baa5907cd95\":{\"balance\":\"0x1455d5f4877088000\"},\"22f004df8de9e6ebf523ccace457accb26f97281\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"22f2dcff5ad78c3eb6850b5cb951127b659522e6\":{\"balance\":\"0xbe202d6a0eda0000\"},\"22f3c779dd79023ea92a78b65c1a1780f62d5c4a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"22fe884d9037291b4d52e6285ae68dea0be9ffb5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2306df931a940d58c01665fa4d0800802c02edfe\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2309d34091445b3232590bd70f4f10025b2c9509\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"23120046f6832102a752a76656691c863e17e59c\":{\"balance\":\"0x11e0e4f8a50bd40000\"},\"231a15acc199c89fa9cb22441cc70330bdcce617\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"231d94155dbcfe2a93a319b6171f63b20bd2b6fa\":{\"balance\":\"0xcf147bb906e2f80000\"},\"232832cd5977e00a4c30d0163f2e24f088a6cb09\":{\"balance\":\"0xa2a15d09519be00000\"},\"232c6d03b5b6e6711efff190e49c28eef36c82b0\":{\"balance\":\"0x487a9a304539440000\"},\"232cb1cd49993c144a3f88b3611e233569a86bd6\":{\"balance\":\"0x34c606c42d0ac600000\"},\"232ce782506225fd9860a2edc14a7a3047736da2\":{\"balance\":\"0x1158e460913d00000\"},\"232f525d55859b7d4e608d20487faadb00293135\":{\"balance\":\"0xd8d726b7177a800000\"},\"2334c590c7a48769103045c5b6534c8a3469f44a\":{\"balance\":\"0x3b199073df72dc00000\"},\"23376ecabf746ce53321cf42c86649b92b67b2ff\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"23378f42926d0184b793b0c827a6dd3e3d334fcd\":{\"balance\":\"0x30927f74c9de00000\"},\"233842b1d0692fd11140cf5acda4bf9630bae5f8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2339e9492870afea2537f389ac2f838302a33c06\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"233bdddd5da94852f4ade8d212885682d9076bc6\":{\"balance\":\"0xd8d726b7177a800000\"},\"234f46bab73fe45d31bf87f0a1e0466199f2ebac\":{\"balance\":\"0x1a4aba225c20740000\"},\"23551f56975fe92b31fa469c49ea66ee6662f41e\":{\"balance\":\"0x678a932062e4180000\"},\"23569542c97d566018c907acfcf391d14067e87e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"235fa66c025ef5540070ebcf0d372d8177c467ab\":{\"balance\":\"0x7129e1cdf373ee00000\"},\"2372c4c1c9939f7aaf6cfac04090f00474840a09\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"23730c357a91026e44b1d0e2fc2a51d071d8d77b\":{\"balance\":\"0xd8d726b7177a800000\"},\"2376ada90333b1d181084c97e645e810aa5b76f1\":{\"balance\":\"0x28a857425466f80000\"},\"2378fd4382511e968ed192106737d324f454b535\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2382a9d48ec83ea3652890fd0ee79c907b5b2dc1\":{\"balance\":\"0x73f75d1a085ba0000\"},\"2383c222e67e969190d3219ef14da37850e26c55\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"238a6b7635252f5244486c0af0a73a207385e039\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"239a733e6b855ac592d663156186a8a174d2449e\":{\"balance\":\"0x58be3758b241f60000\"},\"23ab09e73f87aa0f3be0139df0c8eb6be5634f95\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"23abd9e93e7957e5b636be6579051c15e5ce0b0e\":{\"balance\":\"0x3a3c8f7cbf42c380000\"},\"23b1c4917fbd93ee3d48389306957384a5496cbf\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"23ba3864da583dab56f420873c37679690e02f00\":{\"balance\":\"0x21342520d5fec200000\"},\"23c55aeb5739876f0ac8d7ebea13be729685f000\":{\"balance\":\"0x487a9a304539440000\"},\"23c99ba087448e19c9701df66e0cab52368331fa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"23ccc3c6acd85c2e460c4ffdd82bc75dc849ea14\":{\"balance\":\"0xd8d726b7177a800000\"},\"23cd2598a20e149ead2ad69379576ecedb60e38e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"23df8f48ee009256ea797e1fa369beebcf6bc663\":{\"balance\":\"0x7cd3fac26d19818000\"},\"23e2c6a8be8e0acfa5c4df5e36058bb7cbac5a81\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"23ea669e3564819a83b0c26c00a16d9e826f6c46\":{\"balance\":\"0x4d8d6ca968ca130000\"},\"23eb6fd85671a9063ab7678ebe265a20f61a02b3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"23f9ecf3e5dddca38815d3e59ed34b5b90b4a353\":{\"balance\":\"0xb1781a3f0bb200000\"},\"23fa7eb51a48229598f97e762be0869652dffc66\":{\"balance\":\"0x3635c9adc5dea00000\"},\"240305727313d01e73542c775ff59d11cd35f819\":{\"balance\":\"0x141885666807f5c8000\"},\"24046b91da9b61b629cb8b8ec0c351a07e0703e4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"240e559e274aaef0c258998c979f671d1173b88b\":{\"balance\":\"0xd8d726b7177a800000\"},\"241361559feef80ef137302153bd9ed2f25db3ef\":{\"balance\":\"0x43c33c1937564800000\"},\"243b3bca6a299359e886ce33a30341fafe4d573d\":{\"balance\":\"0x43c33c1937564800000\"},\"243c84d12420570cc4ef3baba1c959c283249520\":{\"balance\":\"0x7f1f6993a853040000\"},\"24434a3e32e54ecf272fe3470b5f6f512f675520\":{\"balance\":\"0x14061b9d77a5e980000\"},\"2448596f91c09baa30bc96106a2d37b5705e5d28\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"24586ec5451735eeaaeb470dc8736aae752f82e5\":{\"balance\":\"0xf43fc2c04ee00000\"},\"2458d6555ff98a129cce4037953d00206eff4287\":{\"balance\":\"0xaadec983fcff40000\"},\"246291165b59332df5f18ce5c98856fae95897d6\":{\"balance\":\"0x5c283d410394100000\"},\"2467c6a5c696ede9a1e542bf1ad06bcc4b06aca0\":{\"balance\":\"0x100bd33fb98ba0000\"},\"2476b2bb751ce748e1a4c4ff7b230be0c15d2245\":{\"balance\":\"0xd8d726b7177a800000\"},\"247a0a11c57f0383b949de540b66dee68604b0a1\":{\"balance\":\"0x39fbae8d042dd00000\"},\"2487c3c4be86a2723d917c06b458550170c3edba\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2489ac126934d4d6a94df08743da7b7691e9798e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"249db29dbc19d1235da7298a04081c315742e9ac\":{\"balance\":\"0x61acff81a78ad40000\"},\"24a4eb36a7e498c36f99975c1a8d729fd6b305d7\":{\"balance\":\"0xdfc78210eb2c80000\"},\"24a750eae5874711116dd7d47b7186ce990d3103\":{\"balance\":\"0xad78ebc5ac6200000\"},\"24aa1151bb765fa3a89ca50eb6e1b1c706417fd4\":{\"balance\":\"0xa80d24677efef00000\"},\"24aca08d5be85ebb9f3132dfc1b620824edfedf9\":{\"balance\":\"0xfc936392801c0000\"},\"24b2be118b16d8b2174769d17b4cf84f07ca946d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"24b8b446debd1947955dd084f2c544933346d3ad\":{\"balance\":\"0xea696d904039bd8000\"},\"24b95ebef79500baa0eda72e77f877415df75c33\":{\"balance\":\"0x3154c9729d05780000\"},\"24b9e6644f6ba4cde126270d81f6ab60f286dff4\":{\"balance\":\"0x73f75d1a085ba0000\"},\"24bd5904059091d2f9e12d6a26a010ca22ab14e8\":{\"balance\":\"0x65ea3db75546600000\"},\"24c0c88b54a3544709828ab4ab06840559f6c5e2\":{\"balance\":\"0x90f534608a72880000\"},\"24c117d1d2b3a97ab11a4679c99a774a9eade8d1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"24cff0e9336a9f80f9b1cb968caf6b1d1c4932a4\":{\"balance\":\"0xada55474b81340000\"},\"24daaaddf7b06bbcea9b80590085a88567682b4e\":{\"balance\":\"0x114b2015d2bbd00000\"},\"24dcc24bd9c7210ceacfb30da98ae04a4d7b8ab9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"24f7450ddbf18b020feb1a2032d9d54b633edf37\":{\"balance\":\"0x2b5e3af16b1880000\"},\"24fc73d20793098e09ddab5798506224fa1e1850\":{\"balance\":\"0xad78ebc5ac6200000\"},\"24fd9a6c874c2fab3ff36e9afbf8ce0d32c7de92\":{\"balance\":\"0x487a9a304539440000\"},\"250a40cef3202397f240469548beb5626af4f23c\":{\"balance\":\"0x503b203e9fba20000\"},\"250a69430776f6347703f9529783955a6197b682\":{\"balance\":\"0x692ae8897081d00000\"},\"250eb7c66f869ddf49da85f3393e980c029aa434\":{\"balance\":\"0xd8d726b7177a800000\"},\"25106ab6755df86d6b63a187703b0cfea0e594a0\":{\"balance\":\"0x17c405ad41db40000\"},\"25185f325acf2d64500698f65c769ddf68301602\":{\"balance\":\"0x10f0cf064dd59200000\"},\"251c12722c6879227992a304eb3576cd18434ea5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"251e6838f7cec5b383c1d90146341274daf8e502\":{\"balance\":\"0x7ff1ccb7561df0000\"},\"25259d975a21d83ae30e33f800f53f37dfa01938\":{\"balance\":\"0x1158e460913d00000\"},\"25287b815f5c82380a73b0b13fbaf982be24c4d3\":{\"balance\":\"0x22b1c8c1227a00000\"},\"252b6555afdc80f2d96d972d17db84ea5ad521ac\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"2538532936813c91e653284f017c80c3b8f8a36f\":{\"balance\":\"0x6c8754c8f30c080000\"},\"253e32b74ea4490ab92606fda0aa257bf23dcb8b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"253f1e742a2cec86b0d7b306e5eacb6ccb2f8554\":{\"balance\":\"0x43e5ede1f878c200000\"},\"2541314a0b408e95a694444977712a50713591ab\":{\"balance\":\"0x589e1a5df4d7b50000\"},\"254c1ecc630c2877de8095f0a8dba1e8bf1f550c\":{\"balance\":\"0x5c283d410394100000\"},\"255abc8d08a096a88f3d6ab55fbc7352bddcb9ce\":{\"balance\":\"0x4743682313ede8000\"},\"255bdd6474cc8262f26a22c38f45940e1ceea69b\":{\"balance\":\"0xd8d726b7177a800000\"},\"2560b09b89a4ae6849ed5a3c9958426631714466\":{\"balance\":\"0x5c283d410394100000\"},\"2561a138dcf83bd813e0e7f108642be3de3d6f05\":{\"balance\":\"0x3634f48417401a0000\"},\"2561ec0f379218fe5ed4e028a3f744aa41754c72\":{\"balance\":\"0xb98bc829a6f90000\"},\"256292a191bdda34c4da6b6bd69147bf75e2a9ab\":{\"balance\":\"0xc2ff2e0dfb038000\"},\"25697ef20cccaa70d32d376f8272d9c1070c3d78\":{\"balance\":\"0xad78ebc5ac6200000\"},\"256fa150cc87b5056a07d004efc84524739e62b5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"25721c87b0dc21377c7200e524b14a22f0af69fb\":{\"balance\":\"0xd8d726b7177a800000\"},\"258939bbf00c9de9af5338f5d714abf6d0c1c671\":{\"balance\":\"0x54069233bf7f780000\"},\"2590126870e0bde8a663ab040a72a5573d8d41c2\":{\"balance\":\"0x10f0cf064dd59200000\"},\"259ec4d265f3ab536b7c70fa97aca142692c13fc\":{\"balance\":\"0x11b1b5bea89f80000\"},\"25a500eeec7a662a841552b5168b707b0de21e9e\":{\"balance\":\"0x21f2f6f0fc3c6100000\"},\"25a5a44d38a2f44c6a9db9cdbc6b1e2e97abb509\":{\"balance\":\"0x39992648a23c8a00000\"},\"25a74c2ac75dc8baa8b31a9c7cb4b7829b2456da\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"25adb8f96f39492c9bb47c5edc88624e46075697\":{\"balance\":\"0x5a9940bc56879500000\"},\"25aee68d09afb71d8817f3f184ec562f7897b734\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"25b0533b81d02a617b9229c7ec5d6f2f672e5b5a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"25b78c9fad85b43343f0bfcd0fac11c9949ca5eb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"25bc49ef288cd165e525c661a812cf84fbec8f33\":{\"balance\":\"0x125921aebda9d00000\"},\"25bdfa3ee26f3849617b230062588a97e3cae701\":{\"balance\":\"0x3635e619bb04d40000\"},\"25c1a37ee5f08265a1e10d3d90d5472955f97806\":{\"balance\":\"0x62a992e53a0af00000\"},\"25c6e74ff1d928df98137af4df8430df24f07cd7\":{\"balance\":\"0x15245655b102580000\"},\"25cfc4e25c35c13b69f7e77dbfb08baf58756b8d\":{\"balance\":\"0x878678326eac9000000\"},\"25dad495a11a86b9eeece1eeec805e57f157faff\":{\"balance\":\"0x3635c9adc5dea000000\"},\"25e037f00a18270ba5ec3420229ddb0a2ce38fa2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"25e661c939863acc044e6f17b5698cce379ec3cc\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"26048fe84d9b010a62e731627e49bc2eb73f408f\":{\"balance\":\"0xd8d726b7177a800000\"},\"2606c3b3b4ca1b091498602cb1978bf3b95221c0\":{\"balance\":\"0x15af1d78b58c400000\"},\"260a230e4465077e0b14ee4442a482d5b0c914bf\":{\"balance\":\"0x5af606a06b5b118000\"},\"260df8943a8c9a5dba7945327fd7e0837c11ad07\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2614f42d5da844377578e6b448dc24305bef2b03\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2615100ea7e25bba9bca746058afbbb4ffbe4244\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"261575e9cf59c8226fa7aaf91de86fb70f5ac3ae\":{\"balance\":\"0x1043a4436a523f0000\"},\"261e0fa64c51137465eecf5b90f197f7937fdb05\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"262a8bfd7d9dc5dd3ad78161b6bb560824373655\":{\"balance\":\"0x3f6a8384072b760000\"},\"262aed4bc0f4a4b2c6fb35793e835a49189cdfec\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"262dc1364ccf6df85c43268ee182554dae692e29\":{\"balance\":\"0x10b202fec74ced80000\"},\"263814309de4e635cf585e0d365477fc40e66cf7\":{\"balance\":\"0x7ea28327577080000\"},\"2639eee9873ceec26fcc9454b548b9e7c54aa65c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"263e57dacbe0149f82fe65a2664898866ff5b463\":{\"balance\":\"0x80bfbefcb5f0bc00000\"},\"26475419c06d5f147aa597248eb46cf7befa64a5\":{\"balance\":\"0x58e7926ee858a00000\"},\"264cc8086a8710f91b21720905912cd7964ae868\":{\"balance\":\"0x1731790534df20000\"},\"265383d68b52d034161bfab01ae1b047942fbc32\":{\"balance\":\"0x47271dee20d745c0000\"},\"2659facb1e83436553b5b42989adb8075f9953ed\":{\"balance\":\"0x1976576771a5e0000\"},\"266f2da7f0085ef3f3fa09baee232b93c744db2e\":{\"balance\":\"0xcb49b44ba602d800000\"},\"267148fd72c54f620a592fb92799319cc4532b5c\":{\"balance\":\"0x1639e49bba16280000\"},\"26784ade91c8a83a8e39658c8d8277413ccc9954\":{\"balance\":\"0x14542ba12a337c00000\"},\"267a7e6e82e1b91d51deddb644f0e96dbb1f7f7e\":{\"balance\":\"0x1158e460913d00000\"},\"2680713d40808e2a50ed013150a2a694b96a7f1d\":{\"balance\":\"0x61093d7c2c6d380000\"},\"2697b339813b0c2d964b2471eb1c606f4ecb9616\":{\"balance\":\"0x3e8ef795d890c80000\"},\"26a68eab905a8b3dce00e317308225dab1b9f6b8\":{\"balance\":\"0x6b56051582a9700000\"},\"26b11d066588ce74a572a85a6328739212aa8b40\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"26babf42b267fdcf3861fdd4236a5e474848b358\":{\"balance\":\"0x3635c9adc5dea00000\"},\"26c0054b700d3a7c2dcbe275689d4f4cad16a335\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"26c2ffc30efdc5273e76183a16c2698d6e531286\":{\"balance\":\"0x2a1129d09367200000\"},\"26c99f8849c9802b83c861217fd07a9e84cdb79d\":{\"balance\":\"0x1043561a8829300000\"},\"26cfffd052152bb3f957b478d5f98b233a7c2b92\":{\"balance\":\"0xd8d726b7177a800000\"},\"26d4a16891f52922789217fcd886f7fce296d400\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"26d4ec17d5ceb2c894bdc59d0a6a695dad2b43cc\":{\"balance\":\"0x9f1f78761d341a0000\"},\"26e801b62c827191dd68d31a011990947fd0ebe0\":{\"balance\":\"0x1158e460913d00000\"},\"26e9e2ad729702626417ef25de0dc800f7a779b3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"26f9f7cefd7e394b9d3924412bf2c2831faf1f85\":{\"balance\":\"0xd8d726b7177a800000\"},\"26fe174cbf526650e0cd009bd6126502ce8e684d\":{\"balance\":\"0x277017338a30ae00000\"},\"26ff0a51e7cece8400276978dbd6236ef162c0e6\":{\"balance\":\"0x152e185627540a500000\"},\"27101a0f56d39a88c5a84f9b324cdde33e5cb68c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"27144ca9a7771a836ad50f803f64d869b2ae2b20\":{\"balance\":\"0xd8d726b7177a800000\"},\"27146913563aa745e2588430d9348e86ea7c3510\":{\"balance\":\"0x15af1d78b58c400000\"},\"271d3d481cb88e7671ad216949b6365e06303de0\":{\"balance\":\"0xd8d726b7177a800000\"},\"2720f9ca426ef2f2cbd2fecd39920c4f1a89e16d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"272a131a5a656a7a3aca35c8bd202222a7592258\":{\"balance\":\"0x90f534608a72880000\"},\"2744ff67464121e35afc2922177164fa2fcb0267\":{\"balance\":\"0x56bc75e2d63100000\"},\"274a3d771a3d709796fbc4d5f48fce2fe38c79d6\":{\"balance\":\"0x1158e460913d00000\"},\"274d69170fe7141401882b886ac4618c6ae40edb\":{\"balance\":\"0x33c5499031720c0000\"},\"27521deb3b6ef1416ea4c781a2e5d7b36ee81c61\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"275875ff4fbb0cf3a430213127487f7608d04cba\":{\"balance\":\"0x1b1c010e766d580000\"},\"276a006e3028ecd44cdb62ba0a77ce94ebd9f10f\":{\"balance\":\"0x6194049f30f7200000\"},\"276b0521b0e68b277df0bb32f3fd48326350bfb2\":{\"balance\":\"0x2b5e3af16b1880000\"},\"276fd7d24f8f883f5a7a28295bf17151c7a84b03\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2770f14efb165ddeba79c10bb0af31c31e59334c\":{\"balance\":\"0xa2a15d09519be00000\"},\"277677aba1e52c3b53bfa2071d4e859a0af7e8e1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"27824666d278d70423f03dfe1dc7a3f02f43e2b5\":{\"balance\":\"0x3636c25e66ece70000\"},\"27830c5f6023afaaf79745676c204a0faccda0ba\":{\"balance\":\"0xd02ab486cedc00000\"},\"2784903f1d7c1b5cd901f8875d14a79b3cbe2a56\":{\"balance\":\"0x4bda7e9d74ad5500000\"},\"278c0bde630ec393b1e7267fc9d7d97019e4145b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"27987110221a880826adb2e7ab5eca78c6e31aec\":{\"balance\":\"0xd8d726b7177a800000\"},\"27ac073be79ce657a93aa693ee43bf0fa41fef04\":{\"balance\":\"0xa968163f0a57b400000\"},\"27b1694eafa165ebd7cc7bc99e74814a951419dc\":{\"balance\":\"0x2b5e3af16b18800000\"},\"27b62816e1e3b8d19b79d1513d5dfa855b0c3a2a\":{\"balance\":\"0x56af5c1fd69508000\"},\"27bf943c1633fe32f8bcccdb6302b407a5724e44\":{\"balance\":\"0x32f84c6df408c08000\"},\"27bf9f44ba7d05c33540c3a53bb02cbbffe7c3c6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"27c2d7ca504daa3d9066dc09137dc42f3aaab452\":{\"balance\":\"0x2086ac351052600000\"},\"27d158ac3d3e1109ab6e570e90e85d3892cd7680\":{\"balance\":\"0x56bc75e2d63100000\"},\"27e63989ca1e903bc620cf1b9c3f67b9e2ae6581\":{\"balance\":\"0x487a9a304539440000\"},\"27f03cf1abc5e1b51dbc444b289e542c9ddfb0e6\":{\"balance\":\"0x10f0cf064dd59200000\"},\"27fc85a49cff90dbcfdadc9ddd40d6b9a2210a6c\":{\"balance\":\"0x56bc75e2d63100000\"},\"2805415e1d7fdec6dedfb89e521d10592d743c10\":{\"balance\":\"0x56bc75e2d63100000\"},\"28073efc17d05cab3195c2db332b61984777a612\":{\"balance\":\"0x3635c9adc5dea00000\"},\"281250a29121270a4ee5d78d24feafe82c70ba3a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2813d263fc5ff2479e970595d6b6b560f8d6d6d1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"282e80a554875a56799fa0a97f5510e795974c4e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"283396ce3cac398bcbe7227f323e78ff96d08767\":{\"balance\":\"0x15af1d78b58c400000\"},\"28349f7ef974ea55fe36a1583b34cec3c45065f0\":{\"balance\":\"0xcb633d49e65590000\"},\"2836123046b284e5ef102bfd22b1765e508116ad\":{\"balance\":\"0x1653fbb5c427e40000\"},\"283c2314283c92d4b064f0aef9bb5246a7007f39\":{\"balance\":\"0xad78ebc5ac6200000\"},\"283e11203749b1fa4f32febb71e49d135919382a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"283e6252b4efcf4654391acb75f903c59b78c5fb\":{\"balance\":\"0x28a857425466f800000\"},\"28510e6eff1fc829b6576f4328bc3938ec7a6580\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2858acacaf21ea81cab7598fdbd86b452e9e8e15\":{\"balance\":\"0x241a9b4f617a280000\"},\"285ae51b9500c58d541365d97569f14bb2a3709b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2866b81decb02ee70ae250cee5cdc77b59d7b679\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"286906b6bd4972e3c71655e04baf36260c7cb153\":{\"balance\":\"0x126e72a69a50d00000\"},\"286b186d61ea1fd78d9930fe12b06537b05c3d51\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2874f3e2985d5f7b406627e17baa772b01abcc9e\":{\"balance\":\"0x146050410765f380000\"},\"287cf9d0902ef819a7a5f149445bf1775ee8c47c\":{\"balance\":\"0x3635c9adc5dea000000\"},\"28818e18b610001321b31df6fe7d2815cdadc9f5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"28868324337e11ba106cb481da962f3a8453808d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"28904bb7c4302943b709b14d7970e42b8324e1a1\":{\"balance\":\"0x21f97846a072d7e0000\"},\"2895e80999d406ad592e2b262737d35f7db4b699\":{\"balance\":\"0x692ae8897081d00000\"},\"28967280214e218a120c5dda37041b111ea36d74\":{\"balance\":\"0xad78ebc5ac6200000\"},\"28a3da09a8194819ae199f2e6d9d1304817e28a5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"28ab165ffb69eda0c549ae38e9826f5f7f92f853\":{\"balance\":\"0x464df6d7c844590000\"},\"28b77585cb3d55a199ab291d3a18c68fe89a848a\":{\"balance\":\"0x6a4076cf7995a00000\"},\"28d4ebf41e3d3c451e943bdd7e1f175fae932a3d\":{\"balance\":\"0x14542ba12a337c00000\"},\"28d7e5866f1d85fd1ceb32bfbe1dfc36db434566\":{\"balance\":\"0x1864231c610351c0000\"},\"28d8c35fb7eea622582135e3ad47a227c9a663bd\":{\"balance\":\"0xfc936392801c0000\"},\"28e4af30cd93f686a122ad7bb19f8a8785eee342\":{\"balance\":\"0x71e53b706cc7b40000\"},\"28eaea78cd4d95faecfb68836eafe83520f3bbb7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"28efae6356509edface89fc61a7fdcdb39eea8e5\":{\"balance\":\"0x121ea68c114e5100000\"},\"28fa2580f9ebe420f3e5eefdd371638e3b7af499\":{\"balance\":\"0x14542ba12a337c00000\"},\"2901f8077f34190bb47a8e227fa29b30ce113b31\":{\"balance\":\"0x56bc75e2d63100000\"},\"2905b192e83ce659aa355b9d0c204e3e95f9bb9a\":{\"balance\":\"0x75235c1d00393e8000\"},\"290a56d41f6e9efbdcea0342e0b7929a8cdfcb05\":{\"balance\":\"0x12a5f58168ee600000\"},\"2915624bcb679137b8dae9ab57d11b4905eaee4b\":{\"balance\":\"0x1158e460913d00000\"},\"291efe0081dce8c14799f7b2a43619c0c3b3fc1f\":{\"balance\":\"0x410d586a20a4c00000\"},\"291f929ca59b54f8443e3d4d75d95dee243cef78\":{\"balance\":\"0x1b1a089237073d0000\"},\"29298ccbdff689f87fe41aa6e98fdfb53deaf37a\":{\"balance\":\"0x4315c32d71a9e600000\"},\"292f228b0a94748c8eec612d246f989363e08f08\":{\"balance\":\"0xa076407d3f7440000\"},\"293384c42b6f8f2905ce52b7205c2274376c612b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"2934c0df7bbc172b6c186b0b72547ace8bf75454\":{\"balance\":\"0x340aad21b3b700000\"},\"293c2306df3604ae4fda0d207aba736f67de0792\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2949fd1def5c76a286b3872424809a07db3966f3\":{\"balance\":\"0x11bd906daa0c9438000\"},\"294f494b3f2e143c2ffc9738cbfd9501850b874e\":{\"balance\":\"0x796e3ea3f8ab000000\"},\"2955c357fd8f75d5159a3dfa69c5b87a359dea8c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2961fb391c61957cb5c9e407dda29338d3b92c80\":{\"balance\":\"0x3634fb9f1489a70000\"},\"29681d9912ddd07eaabb88d05d90f766e862417d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"296b71c0015819c242a7861e6ff7eded8a5f71e3\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"296d66b521571a4e4103a7f562c511e6aa732d81\":{\"balance\":\"0x243d4d18229ca20000\"},\"296f00de1dc3bb01d47a8ccd1e5d1dd9a1eb7791\":{\"balance\":\"0x3635c9adc5dea00000\"},\"297385e88634465685c231a314a0d5dcd146af01\":{\"balance\":\"0x54069233bf7f780000\"},\"29763dd6da9a7c161173888321eba6b63c8fb845\":{\"balance\":\"0x11c7ea162e78200000\"},\"2979741174a8c1ea0b7f9edf658177859417f512\":{\"balance\":\"0x1901966c8496838000\"},\"297a88921b5fca10e5bb9ded60025437ae221694\":{\"balance\":\"0xad78ebc5ac6200000\"},\"297d5dbe222f2fb52531acbd0b013dc446ac7368\":{\"balance\":\"0x43c33c1937564800000\"},\"29824e94cc4348bc963279dcdf47391715324cd3\":{\"balance\":\"0x692ae8897081d00000\"},\"2982d76a15f847dd41f1922af368fe678d0e681e\":{\"balance\":\"0x56bc75e2d63100000\"},\"298887bab57c5ba4f0615229d7525fa113b7ea89\":{\"balance\":\"0x22b1c8c1227a00000\"},\"298ec76b440d8807b3f78b5f90979bee42ed43db\":{\"balance\":\"0x65a4da25d3016c00000\"},\"299368609042a858d1ecdf1fc0ada5eaceca29cf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"299e0bca55e069de8504e89aca6eca21d38a9a5d\":{\"balance\":\"0x302379bf2ca2e0000\"},\"29ac2b458454a36c7e96c73a8667222a12242c71\":{\"balance\":\"0xd8d726b7177a800000\"},\"29adcf83b6b20ac6a434abb1993cbd05c60ea2e4\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"29aef48de8c9fbad4b9e4ca970797a5533eb722d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"29b3f561ee7a6e25941e98a5325b78adc79785f3\":{\"balance\":\"0x56bc75e2d63100000\"},\"29bdc4f28de0180f433c2694eb74f5504ce94337\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"29cc804d922be91f5909f348b0aaa5d21b607830\":{\"balance\":\"0xd8d726b7177a800000\"},\"29da3e35b23bb1f72f8e2258cf7f553359d24bac\":{\"balance\":\"0x43c33c1937564800000\"},\"29e67990e1b6d52e1055ffe049c53195a81542cf\":{\"balance\":\"0x43c33c1937564800000\"},\"29eaae82761762f4d2db53a9c68b0f6b0b6d4e66\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"29eb7eefdae9feb449c63ff5f279d67510eb1422\":{\"balance\":\"0x10d3aa536e2940000\"},\"29f0edc60338e7112085a1d114da8c42ce8f55d6\":{\"balance\":\"0xa05a7f0fd825780000\"},\"29f8fba4c30772b057edbbe62ae7420c390572e1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"29f9286c0e738d1721a691c6b95ab3d9a797ede8\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"2a085e25b64862f5e68d768e2b0f7a8529858eee\":{\"balance\":\"0x6b883acd5766cd0000\"},\"2a2ab6b74c7af1d9476bb5bcb4524797bedc3552\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2a39190a4fde83dfb3ddcb4c5fbb83ac6c49755c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2a400dff8594de7228b4fd15c32322b75bb87da8\":{\"balance\":\"0x531a17f607a2d0000\"},\"2a44a7218fe44d65a1b4b7a7d9b1c2c52c8c3e34\":{\"balance\":\"0xd2d06c305a1eb578000\"},\"2a46d353777176ff8e83ffa8001f4f70f9733aa5\":{\"balance\":\"0x5bf0ba6634f680000\"},\"2a595f16eee4cb0c17d9a2d939b3c10f6c677243\":{\"balance\":\"0x3ba1910bf341b00000\"},\"2a59e47ea5d8f0e7c028a3e8e093a49c1b50b9a3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2a5ba9e34cd58da54c9a2712663a3be274c8e47b\":{\"balance\":\"0xaadec983fcff40000\"},\"2a5e3a40d2cd0325766de73a3d671896b362c73b\":{\"balance\":\"0x152d02c7e14af6800000\"},\"2a63590efe9986c3fee09b0a0a338b15bed91f21\":{\"balance\":\"0x15e1c4e05ee26d00000\"},\"2a67660a1368efcd626ef36b2b1b601980941c05\":{\"balance\":\"0x73f75d1a085ba0000\"},\"2a742b8910941e0932830a1d9692cfd28494cf40\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"2a746cd44027af3ebd37c378c85ef7f754ab5f28\":{\"balance\":\"0x155bd9307f9fe80000\"},\"2a81d27cb6d4770ff4f3c4a3ba18e5e57f07517c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2a91a9fed41b7d0e5cd2d83158d3e8a41a9a2d71\":{\"balance\":\"0x692ae8897081d00000\"},\"2a9c57fe7b6b138a920d676f3c76b6c2a0eef699\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"2a9c96c19151ffcbe29a4616d0c52b3933b4659f\":{\"balance\":\"0x3c1379b8765e18000\"},\"2aa192777ca5b978b6b2c2ff800ac1860f753f47\":{\"balance\":\"0x12290f15180bdc0000\"},\"2aaa35274d742546670b7426264521032af4f4c3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2aaea1f1046f30f109faec1c63ef5c7594eb08da\":{\"balance\":\"0xd8d726b7177a800000\"},\"2ab97e8d59eee648ab6caf8696f89937143864d6\":{\"balance\":\"0xcf152640c5c8300000\"},\"2abce1808940cd4ef5b5e05285f82df7a9ab5e03\":{\"balance\":\"0x21342520d5fec200000\"},\"2abdf1a637ef6c42a7e2fe217773d677e804ebdd\":{\"balance\":\"0x10f0cf064dd59200000\"},\"2ac1f8d7bf721f3cfe74d20fea9b87a28aaa982c\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"2acc9c1a32240b4d5b2f777a2ea052b42fc1271c\":{\"balance\":\"0x8d807ee14d836100000\"},\"2ad6c9d10c261819a1a0ca2c48d8c7b2a71728df\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2ae53866fc2d14d572ab73b4a065a1188267f527\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"2ae73a79aea0278533accf21070922b1613f8f32\":{\"balance\":\"0xa7e94bbeae701a8000\"},\"2ae82dab92a66389eea1abb901d1d57f5a7cca0b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2aec809df9325b9f483996e99f7331097f08aa0e\":{\"balance\":\"0xd8d726b7177a800000\"},\"2aed2ce531c056b0097efc3c6de10c4762004ed9\":{\"balance\":\"0x2356953ab7ddc380000\"},\"2afb058c3d31032b353bf24f09ae20d54de57dbe\":{\"balance\":\"0x3ba1910bf341b00000\"},\"2b0362633614bfcb583569438ecc4ea57b1d337e\":{\"balance\":\"0x43c33c1937564800000\"},\"2b101e822cd962962a06800a2c08d3b15d82b735\":{\"balance\":\"0x83d6c7aab63600000\"},\"2b129c26b75dde127f8320bd0f63410c92a9f876\":{\"balance\":\"0x77432217e683600000\"},\"2b241f037337eb4acc61849bd272ac133f7cdf4b\":{\"balance\":\"0x500b6bca962ab8400000\"},\"2b3a68db6b0cae8a7c7a476bdfcfbd6205e10687\":{\"balance\":\"0x821ab0d44149800000\"},\"2b3cf97311ff30f460945a9d8099f4a88e26d456\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2b49fba29830360fcdb6da23bbfea5c0bbac5281\":{\"balance\":\"0x1158e460913d00000\"},\"2b4f4507bb6b9817942ce433781b708fbcd166fd\":{\"balance\":\"0xfc936392801c0000\"},\"2b5016e2457387956562587115aa8759d8695fdf\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"2b5c60e84535eeb4d580de127a12eb2677ccb392\":{\"balance\":\"0x43c33c1937564800000\"},\"2b5ced9987c0765f900e49cf9da2d9f9c1138855\":{\"balance\":\"0x15af1d78b58c400000\"},\"2b5f4b3f1e11707a227aa5e69fa49dded33fb321\":{\"balance\":\"0x14542ba12a337c00000\"},\"2b68306ba7f8daaf73f4c644ef7d2743c0f26856\":{\"balance\":\"0x2ee182ca17ddd00000\"},\"2b6ed29a95753c3ad948348e3e7b1a251080ffb9\":{\"balance\":\"0x34f086f3b33b68400000\"},\"2b701d16c0d3cc1e4cd85445e6ad02eea4ac012d\":{\"balance\":\"0x2086ac351052600000\"},\"2b717cd432a323a4659039848d3b87de26fc9546\":{\"balance\":\"0x69e10de76676d0800000\"},\"2b74c373d04bfb0fd60a18a01a88fbe84770e58c\":{\"balance\":\"0x22b1c8c1227a00000\"},\"2b77a4d88c0d56a3dbe3bae04a05f4fcd1b757e1\":{\"balance\":\"0x1043561a8829300000\"},\"2b8488bd2d3c197a3d26151815b5a798d27168dc\":{\"balance\":\"0x16a1f9f5fd7d9600000\"},\"2b8a0dee5cb0e1e97e15cfca6e19ad21f995efad\":{\"balance\":\"0x1b55438d9a249b0000\"},\"2b8fe4166e23d11963c0932b8ade8e0145ea0770\":{\"balance\":\"0x92896529baddc880000\"},\"2b99b42e4f42619ee36baa7e4af2d65eacfcba35\":{\"balance\":\"0x878678326eac9000000\"},\"2bab0fbe28d58420b52036770a12f9952aea6911\":{\"balance\":\"0xcf152640c5c8300000\"},\"2bade91d154517620fd4b439ac97157a4102a9f7\":{\"balance\":\"0xd8d726b7177a800000\"},\"2baf8d6e221174124820ee492b9459ec4fadafbb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2bafbf9e9ed2c219f7f2791374e7d05cb06777e7\":{\"balance\":\"0xbed1d0263d9f00000\"},\"2bb366b9edcb0da680f0e10b3b6e28748190d6c3\":{\"balance\":\"0x13a62d7b57640640000\"},\"2bb6f578adfbe7b2a116b3554facf9969813c319\":{\"balance\":\"0x19127a1391ea2a00000\"},\"2bbe62eac80ca7f4d6fdee7e7d8e28b63acf770e\":{\"balance\":\"0x81e32df972abf00000\"},\"2bbe672a1857508f630f2a5edb563d9e9de92815\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2bc429d618a66a4cf82dbb2d824e9356effa126a\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"2bd252e0d732ff1d7c78f0a02e6cb25423cf1b1a\":{\"balance\":\"0x90f534608a72880000\"},\"2bdd03bebbee273b6ca1059b34999a5bbd61bb79\":{\"balance\":\"0x1158e460913d00000\"},\"2c04115c3e52961b0dc0b0bf31fba4546f5966fd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2c06dd922b61514aafedd84488c0c28e6dcf0e99\":{\"balance\":\"0x152d02c7e14af6800000\"},\"2c0cc3f951482cc8a2925815684eb9f94e060200\":{\"balance\":\"0x14542ba12a337c00000\"},\"2c0ee134d8b36145b47beee7af8d2738dbda08e8\":{\"balance\":\"0xae56f730e6d840000\"},\"2c0f5b9df43625798e7e03c1a5fd6a6d091af82b\":{\"balance\":\"0x1b0fcaab200300000\"},\"2c128c95d957215101f043dd8fc582456d41016d\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"2c1800f35fa02d3eb6ff5b25285f5e4add13b38d\":{\"balance\":\"0x3122d3adafde100000\"},\"2c1c19114e3d6de27851484b8d2715e50f8a1065\":{\"balance\":\"0x56bc75e2d63100000\"},\"2c1cc6e18c152488ba11c2cc1bcefa2df306abd1\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"2c1df8a76f48f6b54bcf9caf56f0ee1cf57ab33d\":{\"balance\":\"0x2247f750089da580000\"},\"2c2147947ae33fb098b489a5c16bfff9abcd4e2a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2c234f505ca8dcc77d9b7e01d257c318cc19396d\":{\"balance\":\"0x56bc75e2d63100000\"},\"2c2428e4a66974edc822d5dbfb241b2728075158\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2c2d15ff39561c1b72eda1cc027ffef23743a144\":{\"balance\":\"0xd480ed9ef32b400000\"},\"2c2db28c3309375eea3c6d72cd6d0eec145afcc0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2c424ee47f583cdce07ae318b6fad462381d4d2b\":{\"balance\":\"0xd8d726b7177a800000\"},\"2c4b470307a059854055d91ec3794d80b53d0f4a\":{\"balance\":\"0x43c33c1937564800000\"},\"2c52c984102ee0cd3e31821b84d408930efa1ac7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2c5a2d0abda03bbe215781b4ff296c8c61bdbaf6\":{\"balance\":\"0x1a8e56f48c0228000\"},\"2c5b7d7b195a371bf9abddb42fe04f2f1d9a9910\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2c5df866666a194b26cebb407e4a1fd73e208d5e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2c603ff0fe93616c43573ef279bfea40888d6ae7\":{\"balance\":\"0x100f4b6d66757900000\"},\"2c6846a1aa999a2246a287056000ba4dcba8e63d\":{\"balance\":\"0x21f2f6f0fc3c6100000\"},\"2c6afcd4037c1ed14fa74ff6758e0945a185a8e8\":{\"balance\":\"0xf43fc2c04ee00000\"},\"2c6b699d9ead349f067f45711a074a641db6a897\":{\"balance\":\"0x1158e460913d00000\"},\"2c6f5c124cc789f8bb398e3f889751bc4b602d9e\":{\"balance\":\"0x159f20bed00f00000\"},\"2c83aeb02fcf067d65a47082fd977833ab1cec91\":{\"balance\":\"0x8273823258ac00000\"},\"2c89f5fdca3d155409b638b98a742e55eb4652b7\":{\"balance\":\"0x14dbb2195ca228900000\"},\"2c964849b1f69cc7cea4442538ed87fdf16cfc8f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2c9fa72c95f37d08e9a36009e7a4b07f29bad41a\":{\"balance\":\"0xdf6eb0b2d3ca0000\"},\"2caf6bf4ec7d5a19c5e0897a5eeb011dcece4210\":{\"balance\":\"0x7934835a031160000\"},\"2cb4c3c16bb1c55e7c6b7a19b127a1ac9390cc09\":{\"balance\":\"0xb82794a9244f0c8000\"},\"2cb5495a505336c2465410d1cae095b8e1ba5cdd\":{\"balance\":\"0x43c33c1937564800000\"},\"2cb615073a40dcdb99faa848572e987b3b056efb\":{\"balance\":\"0x2b58addb89a2580000\"},\"2cba6d5d0dc204ea8a25ada2e26f5675bd5f2fdc\":{\"balance\":\"0x4823ef7ddb9af38000\"},\"2cbb0c73df91b91740b6693b774a7d05177e8e58\":{\"balance\":\"0x6449e84e47a8a80000\"},\"2ccb66494d0af689abf9483d365d782444e7dead\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2ccc1f1cb5f4a8002e186b20885d9dbc030c0894\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2ccf80e21898125eb4e807cd82e09b9d28592f6e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2cd19694d1926a0fa9189edebafc671cf1b2caa5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2cd39334ac7eac797257abe3736195f5b4b5ce0f\":{\"balance\":\"0x56b47785e37260000\"},\"2cd79eb52027b12c18828e3eaab2969bfcd287e9\":{\"balance\":\"0x1158e460913d00000\"},\"2cd87866568dd81ad47d9d3ad0846e5a65507373\":{\"balance\":\"0x15af1d78b58c400000\"},\"2cdb3944650616e47cb182e060322fa1487978ce\":{\"balance\":\"0x62a992e53a0af00000\"},\"2ce11a92fad024ff2b3e87e3b542e6c60dcbd996\":{\"balance\":\"0xd8d726b7177a800000\"},\"2d0326b23f0409c0c0e9236863a133075a94ba18\":{\"balance\":\"0xb679be75be6ae0000\"},\"2d0dec51a6e87330a6a8fa2a0f65d88d4abcdf73\":{\"balance\":\"0xa076407d3f7440000\"},\"2d23766b6f6b05737dad80a419c40eda4d77103e\":{\"balance\":\"0xcf152640c5c8300000\"},\"2d2b032359b363964fc11a518263bfd05431e867\":{\"balance\":\"0x81c1df7629e700000\"},\"2d3480bf0865074a72c7759ee5137b4d70c51ce9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2d35a9df62757f7ffad1049afb06ca4afc464c51\":{\"balance\":\"0x1158e460913d00000\"},\"2d40558b06f90a3923145592123b6774e46e31f4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2d426912d059fad9740b2e390a2eeac0546ff01b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"2d532df4c63911d1ce91f6d1fcbff7960f78a885\":{\"balance\":\"0x5a85968a5878da8000\"},\"2d5391e938b34858cf965b840531d5efda410b09\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"2d5b42fc59ebda0dfd66ae914bc28c1b0a6ef83a\":{\"balance\":\"0x2bc8b59fdcd836638000\"},\"2d5d7335acb0362b47dfa3a8a4d3f5949544d380\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2d61bfc56873923c2b00095dc3eaa0f590d8ae0f\":{\"balance\":\"0x46566dff8ce55600000\"},\"2d6511fd7a3800b26854c7ec39c0dcb5f4c4e8e8\":{\"balance\":\"0x15adddba2f9e770000\"},\"2d7d5c40ddafc450b04a74a4dabc2bb5d665002e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2d89a8006a4f137a20dc2bec46fe2eb312ea9654\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2d8c52329f38d2a2fa9cbaf5c583daf1490bb11c\":{\"balance\":\"0x1158e460913d00000\"},\"2d8e061892a5dcce21966ae1bb0788fd3e8ba059\":{\"balance\":\"0xd8e5ce617f2d50000\"},\"2d8e5bb8d3521695c77e7c834e0291bfacee7408\":{\"balance\":\"0x6acb3df27e1f880000\"},\"2d90b415a38e2e19cdd02ff3ad81a97af7cbf672\":{\"balance\":\"0x5f3c7f64131e40000\"},\"2d9bad6f1ee02a70f1f13def5cccb27a9a274031\":{\"balance\":\"0x61093d7c2c6d380000\"},\"2d9c5fecd2b44fbb6a1ec732ea059f4f1f9d2b5c\":{\"balance\":\"0x36ca32661d1aa70000\"},\"2da617695009cc57d26ad490b32a5dfbeb934e5e\":{\"balance\":\"0x43c33c1937564800000\"},\"2da76b7c39b420e388ba2c1020b0856b0270648a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2dc79d6e7f55bce2e2d0c02ad07ceca8bb529354\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"2dca0e449ab646dbdfd393a96662960bcab5ae1e\":{\"balance\":\"0x878678326eac9000000\"},\"2dd325fdffb97b19995284afa5abdb574a1df16a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"2dd578f7407dfbd548d05e95ccc39c485429626a\":{\"balance\":\"0xe3aeb5737240a00000\"},\"2dd8eeef87194abc2ce7585da1e35b7cea780cb7\":{\"balance\":\"0x3635c6204739d98000\"},\"2ddf40905769bcc426cb2c2938ffe077e1e89d98\":{\"balance\":\"0xa2a15d09519be00000\"},\"2de0964400c282bdd78a919c6bf77c6b5f796179\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2de31afd189a13a76ff6fe73ead9f74bb5c4a629\":{\"balance\":\"0x14542ba12a337c00000\"},\"2dec98329d1f96c3a59caa7981755452d4da49d5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2dee90a28f192d676a8773232b56f18f239e2fad\":{\"balance\":\"0x3efa7e747b6d1ad0000\"},\"2e0880a34596230720f05ac8f065af8681dcb6c2\":{\"balance\":\"0x152d02c7e14af6800000\"},\"2e0c57b47150f95aa6a7e16ab9b1cbf54328979a\":{\"balance\":\"0x56bc75e2d63100000\"},\"2e10910ba6e0bc17e055556614cb87090f4d7e5b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2e24b597873bb141bdb237ea8a5ab747799af02d\":{\"balance\":\"0x43c33c1937564800000\"},\"2e2810dee44ae4dff3d86342ab126657d653c336\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2e2cbd7ad82547b4f5ff8b3ab56f942a6445a3b0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2e2d7ea66b9f47d8cc52c01c52b6e191bc7d4786\":{\"balance\":\"0xd8d4602c26bf6c0000\"},\"2e439348df8a4277b22a768457d1158e97c40904\":{\"balance\":\"0x2a1e9ff26fbf410000\"},\"2e46fcee6a3bb145b594a243a3913fce5dad6fba\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2e47f287f498233713850d3126823cc67dcee255\":{\"balance\":\"0xca9d9ea558b40000\"},\"2e4ee1ae996aa0a1d92428d06652a6bea6d2d15d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2e52912bc10ea39d54e293f7aed6b99a0f4c73be\":{\"balance\":\"0x15af1d78b58c400000\"},\"2e619f57abc1e987aa936ae3a2264962e7eb2d9a\":{\"balance\":\"0x28fb9b8a8a53500000\"},\"2e64a8d71111a22f4c5de1e039b336f68d398a7c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2e6933543d4f2cc00b5350bd8068ba9243d6beb0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2e7e05e29edda7e4ae25c5173543efd71f6d3d80\":{\"balance\":\"0x14542ba12a337c00000\"},\"2e7f465520ec35cc23d68e75651bb6689544a196\":{\"balance\":\"0x38ec5b721a1a268000\"},\"2e8eb30a716e5fe15c74233e039bfb1106e81d12\":{\"balance\":\"0x56bc75e2d63100000\"},\"2e9824b5c132111bca24ddfba7e575a5cd7296c1\":{\"balance\":\"0x3a484516e6d7ffe0000\"},\"2ea5fee63f337a376e4b918ea82148f94d48a626\":{\"balance\":\"0x650f8e0dd293c50000\"},\"2eaf4e2a46b789ccc288c8d1d9294e3fb0853896\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2eaff9f8f8113064d3957ac6d6e11eee42c8195d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"2eba0c6ee5a1145c1c573984963a605d880a7a20\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"2ec95822eb887bc113b4712a4dfd7f13b097b5e7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2eca6a3c5d9f449d0956bd43fa7b4d7be8435958\":{\"balance\":\"0x6c6bda69709cc20000\"},\"2ecac504b233866eb5a4a99e7bd2901359e43b3d\":{\"balance\":\"0x43c33c1937564800000\"},\"2eebf59432b52892f9380bd140aa99dcf8ad0c0f\":{\"balance\":\"0x83d6c7aab63600000\"},\"2eeed50471a1a2bf53ee30b1232e6e9d80ef866d\":{\"balance\":\"0x1158e460913d00000\"},\"2eef6b1417d7b10ecfc19b123a8a89e73e526c58\":{\"balance\":\"0x2086ac351052600000\"},\"2ef869f0350b57d53478d701e3fee529bc911c75\":{\"balance\":\"0x2b5e3af16b1880000\"},\"2ef9e465716acacfb8c8252fa8e7bc7969ebf6e4\":{\"balance\":\"0x959eb1c0e4ae200000\"},\"2efc4c647dac6acac35577ad221758fef6616faa\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"2f13657526b177cad547c3908c840eff647b45d9\":{\"balance\":\"0x3f76849cf1ee2c8000\"},\"2f187d5a704d5a338c5b2876a090dce964284e29\":{\"balance\":\"0xd8d726b7177a800000\"},\"2f2523cc834f0086052402626296675186a8e582\":{\"balance\":\"0x3635c9adc5dea000000\"},\"2f282abbb6d4a3c3cd3b5ca812f7643e80305f06\":{\"balance\":\"0x6449e84e47a8a80000\"},\"2f2bba1b1796821a766fce64b84f28ec68f15aea\":{\"balance\":\"0x1158e460913d00000\"},\"2f315d9016e8ee5f536681202f9084b032544d4d\":{\"balance\":\"0x383cd12b9e863c0000\"},\"2f4da753430fc09e73acbccdcde9da647f2b5d37\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2f5080b83f7e2dc0a1dd11b092ad042bff788f4c\":{\"balance\":\"0xb4f8fb79231d2b8000\"},\"2f61efa5819d705f2b1e4ee754aeb8a819506a75\":{\"balance\":\"0x4f2591f896a6500000\"},\"2f66bfbf2262efcc8d2bd0444fc5b0696298ff1e\":{\"balance\":\"0x21ad935f79f76d00000\"},\"2f6dce1330c59ef921602154572d4d4bacbd048a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"2f7d3290851be5c6b4b43f7d4574329f61a792c3\":{\"balance\":\"0x56bc75e2d63100000\"},\"2f853817afd3b8f3b86e9f60ee77b5d97773c0e3\":{\"balance\":\"0x4eaeea44e368b90000\"},\"2fa491fb5920a6574ebd289f39c1b2430d2d9a6a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2fb566c94bbba4e3cb67cdda7d5fad7131539102\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2fbb504a5dc527d3e3eb0085e2fc3c7dd538cb7a\":{\"balance\":\"0x43c2b18aec3c0a8000\"},\"2fbc85798a583598b522166d6e9dda121d627dbc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"2fbcef3384d420e4bf61a0669990bc7054f1a5af\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"2fc82ef076932341264f617a0c80dd571e6ae939\":{\"balance\":\"0x18424f5f0b1b4e00000\"},\"2fdd9b79df8df530ad63c20e62af431ae99216b8\":{\"balance\":\"0x1236efcbcbb340000\"},\"2fe0023f5722650f3a8ac01009125e74e3f82e9b\":{\"balance\":\"0xa2a15d09519be00000\"},\"2fe0cc424b53a31f0916be08ec81c50bf8eab0c1\":{\"balance\":\"0x2086ac351052600000\"},\"2fe13a8d0785de8758a5e41876c36e916cf75074\":{\"balance\":\"0xd8d726b7177a800000\"},\"2fea1b2f834f02fc54333f8a809f0438e5870aa9\":{\"balance\":\"0x11854d0f9cee40000\"},\"2fee36a49ee50ecf716f1047915646779f8ba03f\":{\"balance\":\"0x394222c4da86d70000\"},\"2fef81478a4b2e8098db5ff387ba2153f4e22b79\":{\"balance\":\"0x3627e8f712373c0000\"},\"2ff160c44f72a299b5ec2d71e28ce5446d2fcbaf\":{\"balance\":\"0x138400eca364a00000\"},\"2ff1ca55fd9cec1b1fe9f0a9abb74c513c1e2aaa\":{\"balance\":\"0xa2a15d09519be00000\"},\"2ff5cab12c0d957fd333f382eeb75107a64cb8e8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2ff830cf55fb00d5a0e03514fecd44314bd6d9f1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"2ffe93ec1a5636e9ee34af70dff52682e6ff7079\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"30037988702671acbe892c03fe5788aa98af287a\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"30248d58e414b20fed3a6c482b59d9d8f5a4b7e2\":{\"balance\":\"0x340aad21b3b700000\"},\"303139bc596403d5d3931f774c66c4ba467454db\":{\"balance\":\"0x5c25e14aea283f0000\"},\"30380087786965149e81423b15e313ba32c5c783\":{\"balance\":\"0xfc936392801c0000\"},\"303a30ac4286ae17cf483dad7b870c6bd64d7b4a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"303fbaebbe46b35b6e5b74946a5f99bc1585cae7\":{\"balance\":\"0x2f9ac0695f5bba0000\"},\"3041445a33ba158741160d9c344eb88e5c306f94\":{\"balance\":\"0x340aad21b3b700000\"},\"30480164bcd84974ebc0d90c9b9afab626cd1c73\":{\"balance\":\"0x2b5e3af16b18800000\"},\"304ec69a74545721d7316aef4dcfb41ac59ee2f0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"30511832918d8034a7bee72ef2bfee440ecbbcf6\":{\"balance\":\"0x368c8623a8b4d100000\"},\"30513fca9f36fd788cfea7a340e86df98294a244\":{\"balance\":\"0x183b5f03b1479c0000\"},\"3055efd26029e0d11b930df4f53b162c8c3fd2ce\":{\"balance\":\"0x1b1a089237073d0000\"},\"305d26c10bdc103f6b9c21272eb7cb2d9108c47e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"305f78d618b990b4295bac8a2dfa262884f804ea\":{\"balance\":\"0xd8d726b7177a800000\"},\"3064899a963c4779cbf613cd6980846af1e6ec65\":{\"balance\":\"0x17b773ce6e5df0a0000\"},\"30730466b8eb6dc90d5496aa76a3472d7dbe0bbe\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"30742ccdf4abbcd005681f8159345c9e79054b1a\":{\"balance\":\"0x243d4d18229ca20000\"},\"3083ef0ed4c4401196774a95cf4edc83edc1484f\":{\"balance\":\"0x23ffb7ed6565d6400000\"},\"308dd21cebe755126704b48c0f0dc234c60ba9b1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3090f8130ec44466afadb36ed3c926133963677b\":{\"balance\":\"0xd8d726b7177a800000\"},\"309544b6232c3dd737f945a03193d19b5f3f65b9\":{\"balance\":\"0x3af342f67ef6c80000\"},\"3096dca34108085bcf04ae72b94574a13e1a3e1d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3098b65db93ecacaf7353c48808390a223d57684\":{\"balance\":\"0x186484cf7bb6a48000\"},\"30a9da72574c51e7ee0904ba1f73a6b7b83b9b9d\":{\"balance\":\"0x11854d0f9cee40000\"},\"30acd858875fa24eef0d572fc7d62aad0ebddc35\":{\"balance\":\"0x15af1d78b58c400000\"},\"30b66150f1a63457023fdd45d0cc6cb54e0c0f06\":{\"balance\":\"0x3635c9adc5dea00000\"},\"30bb4357cd6910c86d2238bf727cbe8156680e62\":{\"balance\":\"0x56bf91b1a65eb0000\"},\"30bf61b2d877fe10635126326fa189e4b0b1c3b0\":{\"balance\":\"0x37b48985a5d7e60000\"},\"30c01142907acb1565f70438b9980ae731818738\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"30c26a8e971baa1855d633ba703f028cc7873140\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"30db6b9b107e62102f434a9dd0960c2021f5ce4c\":{\"balance\":\"0x2083179b6e42530000\"},\"30e33358fc21c85006e40f32357dc8895940aaf0\":{\"balance\":\"0x678a932062e4180000\"},\"30e60900cacc7203f314dc604347255167fc2a0f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"30e789b3d2465e946e6210fa5b35de4e8c93085f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"30e9698cf1e08a9d048bd8d8048f28be7ed9409f\":{\"balance\":\"0x16a6502f15a1e540000\"},\"30e9d5a0088f1ddb2fd380e2a049192266c51cbf\":{\"balance\":\"0xaacacd9b9e22b0000\"},\"30eac740e4f02cb56eef0526e5d300322600d03e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"30ec9392244a2108c987bc5cdde0ed9f837a817b\":{\"balance\":\"0x549925f6c9c5250000\"},\"30ed11b77bc17e5e6694c8bc5b6e4798f68d9ca7\":{\"balance\":\"0x1e6fb3421fe0299e0000\"},\"30f7d025d16f7bee105580486f9f561c7bae3fef\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"30fbe5885f9fcce9ea5edb82ed4a1196dd259aed\":{\"balance\":\"0x119e47f21381f400000\"},\"31047d703f63b93424fbbd6e2f1f9e74de13e709\":{\"balance\":\"0x9a8166f7e6b2a78000\"},\"31313ffd635bf2f3324841a88c07ed146144ceeb\":{\"balance\":\"0x6acb3df27e1f880000\"},\"3159e90c48a915904adfe292b22fa5fd5e72796b\":{\"balance\":\"0x36afe98f2606100000\"},\"315db7439fa1d5b423afa7dd7198c1cf74c918bc\":{\"balance\":\"0x2086ac351052600000\"},\"315ef2da620fd330d12ee55de5f329a696e0a968\":{\"balance\":\"0x821ab0d4414980000\"},\"316e92a91bbda68b9e2f98b3c048934e3cc0b416\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"316eb4e47df71b42e16d6fe46825b7327baf3124\":{\"balance\":\"0xd8d726b7177a800000\"},\"3171877e9d820cc618fc0919b29efd333fda4934\":{\"balance\":\"0x3635c9adc5dea00000\"},\"317cf4a23cb191cdc56312c29d15e210b3b9b784\":{\"balance\":\"0x7ce66c50e28400000\"},\"318b2ea5f0aaa879c4d5e548ac9d92a0c67487b7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"318c76ecfd8af68d70555352e1f601e35988042d\":{\"balance\":\"0x1b31192e68c7f00000\"},\"318f1f8bd220b0558b95fb33100ffdbb640d7ca6\":{\"balance\":\"0xd8d726b7177a800000\"},\"31aa3b1ebe8c4dbcb6a708b1d74831e60e497660\":{\"balance\":\"0x15af1d78b58c400000\"},\"31ab088966ecc7229258f6098fce68cf39b38485\":{\"balance\":\"0x3635c9adc5dea00000\"},\"31ad4d9946ef09d8e988d946b1227f9141901736\":{\"balance\":\"0x4d853c8f89089800000\"},\"31b43b015d0081643c6cda46a7073a6dfdbca825\":{\"balance\":\"0xa97916520cd18e80000\"},\"31ccc616b3118268e75d9ab8996c8858ebd7f3c3\":{\"balance\":\"0x15ae0f771ca1520000\"},\"31d81d526c195e3f10b5c6db52b5e59afbe0a995\":{\"balance\":\"0xe4fbc69449f200000\"},\"31e9c00f0c206a4e4e7e0522170dc81e88f3eb70\":{\"balance\":\"0x918ddc3a42a3d40000\"},\"31ea12d49a35a740780ddeeaece84c0835b26270\":{\"balance\":\"0xad78ebc5ac6200000\"},\"31ea6eab19d00764e9a95e183f2b1b22fc7dc40f\":{\"balance\":\"0x1158e460913d00000\"},\"31eb123c95c82bf685ace7a75a1881a289efca10\":{\"balance\":\"0x31e009607371bd0000\"},\"31ed858788bda4d5270992221cc04206ec62610d\":{\"balance\":\"0x3fc0474948f3600000\"},\"31f006f3494ed6c16eb92aaf9044fa8abb5fd5a3\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3201259caf734ad7581c561051ba0bca7fd6946b\":{\"balance\":\"0x261dd1ce2f2088800000\"},\"32034e8581d9484e8af42a28df190132ec29c466\":{\"balance\":\"0xbb9125542263900000\"},\"322021022678a0166d204b3aaa7ad4ec4b88b7d0\":{\"balance\":\"0x15af1d78b58c400000\"},\"3225c1ca5f2a9c88156bb7d9cdc44a326653c214\":{\"balance\":\"0x15af1d78b58c400000\"},\"322788b5e29bf4f5f55ae1ddb32085fda91b8ebe\":{\"balance\":\"0xad78ebc5ac6200000\"},\"322d6f9a140d213f4c80cd051afe25c620bf4c7d\":{\"balance\":\"0x1158e460913d00000\"},\"322e5c43b0f524389655a9b3ff24f2d4db3da10f\":{\"balance\":\"0xfc13b69b3e7e680000\"},\"323486ca64b375474fb2b759a9e7a135859bd9f6\":{\"balance\":\"0x15af1d78b58c400000\"},\"323749a3b971959e46c8b4822dcafaf7aaf9bd6e\":{\"balance\":\"0x11671a5b245700000\"},\"323aad41df4b6fc8fece8c93958aa901fa680843\":{\"balance\":\"0x34957444b840e80000\"},\"323b3cfe3ee62bbde2a261e53cb3ecc05810f2c6\":{\"balance\":\"0x2eb8eb1a172dcb80000\"},\"323fca5ed77f699f9d9930f5ceeff8e56f59f03c\":{\"balance\":\"0x487a9a304539440000\"},\"32485c818728c197fea487fbb6e829159eba8370\":{\"balance\":\"0x3921b413bc4ec08000\"},\"3250e3e858c26adeccadf36a5663c22aa84c4170\":{\"balance\":\"0x10f0cf064dd59200000\"},\"3259bd2fddfbbc6fbad3b6e874f0bbc02cda18b5\":{\"balance\":\"0x2846056495b0d188000\"},\"3275496fd4dd8931fd69fb0a0b04c4d1ff879ef5\":{\"balance\":\"0x182d7e4cfda0380000\"},\"327bb49e754f6fb4f733c6e06f3989b4f65d4bee\":{\"balance\":\"0x1158e460913d00000\"},\"3282791d6fd713f1e94f4bfd565eaa78b3a0599d\":{\"balance\":\"0x487a9a304539440000\"},\"3283eb7f9137dd39bed55ffe6b8dc845f3e1a079\":{\"balance\":\"0x3970ae92155780000\"},\"32860997d730b2d83b73241a25d3667d51c908ef\":{\"balance\":\"0x1b1a089237073d0000\"},\"3286d1bc657a312c8847d93cb3cb7950f2b0c6e3\":{\"balance\":\"0x43c33c1937564800000\"},\"32a20d028e2c6218b9d95b445c771524636a22ef\":{\"balance\":\"0x202fefbf2d7c2f00000\"},\"32a70691255c9fc9791a4f75c8b81f388e0a2503\":{\"balance\":\"0x35659ef93f0fc40000\"},\"32b7feebc5c59bf65e861c4c0be42a7611a5541a\":{\"balance\":\"0x77e9aaa8525c100000\"},\"32ba9a7d0423e03a525fe2ebeb661d2085778bd8\":{\"balance\":\"0x43c33c1937564800000\"},\"32bb2e9693e4e085344d2f0dbd46a283e3a087fd\":{\"balance\":\"0x15af1d78b58c400000\"},\"32c2fde2b6aabb80e5aea2b949a217f3cb092283\":{\"balance\":\"0x1306160afdf20378000\"},\"32d950d5e93ea1d5b48db4714f867b0320b31c0f\":{\"balance\":\"0x3708baed3d68900000\"},\"32dbb6716c54e83165829a4abb36757849b6e47d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"32eb64be1b5dede408c6bdefbe6e405c16b7ed02\":{\"balance\":\"0x6acb3df27e1f880000\"},\"32ef5cdc671df5562a901aee5db716b9be76dcf6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"32f29e8727a74c6b4301e3ffff0687c1b870dae9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"32fa0e86cd087dd68d693190f32d93310909ed53\":{\"balance\":\"0xd8d726b7177a800000\"},\"32fbeed6f626fcdfd51acafb730b9eeff612f564\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3300fb149aded65bcba6c04e9cd6b7a03b893bb1\":{\"balance\":\"0xfc936392801c0000\"},\"3301d9ca2f3bfe026279cd6819f79a293d98156e\":{\"balance\":\"0xa968163f0a57b400000\"},\"3308b03466c27a17dfe1aafceb81e16d2934566f\":{\"balance\":\"0x39992648a23c8a00000\"},\"331a1c26cc6994cdd3c14bece276ffff4b9df77c\":{\"balance\":\"0xfa7aeddf4f068000\"},\"3326b88de806184454c40b27f309d9dd6dcfb978\":{\"balance\":\"0x3ca5c66d9bc44300000\"},\"3329eb3baf4345d600ced40e6e9975656f113742\":{\"balance\":\"0x10f08eda8e555098000\"},\"33320dd90f2baa110dd334872a998f148426453c\":{\"balance\":\"0x36356633ebd8ea0000\"},\"3336c3ef6e8b50ee90e037b164b7a8ea5faac65d\":{\"balance\":\"0xec8a3a71c22540000\"},\"33380c6fff5acd2651309629db9a71bf3f20c5ba\":{\"balance\":\"0x368c8623a8b4d100000\"},\"333ad1596401e05aea2d36ca47318ef4cd2cb3df\":{\"balance\":\"0x9dc05cce28c2b80000\"},\"334340ee4b9cdc81f850a75116d50ee9b69825bf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"33481e856ebed48ea708a27426ef28e867f57cd1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"33565ba9da2c03e778ce12294f081dfe81064d24\":{\"balance\":\"0x3635c9adc5dea000000\"},\"33581cee233088c0860d944e0cf1ceabb8261c2e\":{\"balance\":\"0xb98bc829a6f90000\"},\"335858f749f169cabcfe52b796e3c11ec47ea3c2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"335e22025b7a77c3a074c78b8e3dfe071341946e\":{\"balance\":\"0x227ca730ab3f6ac0000\"},\"33629bd52f0e107bc071176c64df108f64777d49\":{\"balance\":\"0x1cfdd7468216e8000\"},\"337b3bdf86d713dbd07b5dbfcc022b7a7b1946ae\":{\"balance\":\"0xd7c198710e66b00000\"},\"337cfe1157a5c6912010dd561533791769c2b6a6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"33b336f5ba5edb7b1ccc7eb1a0d984c1231d0edc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"33c407133b84b3ca4c3ded1f4658900c38101624\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"33d172ab075c51db1cd40a8ca8dbff0d93b843bb\":{\"balance\":\"0x136780510d12de38000\"},\"33e9b71823952e1f66958c278fc28b1196a6c5a4\":{\"balance\":\"0x56bc75e2d63100000\"},\"33ea6b7855e05b07ab80dab1e14de9b649e99b6c\":{\"balance\":\"0x1cd6fbad57dbd00000\"},\"33f15223310d44de8b6636685f3a4c3d9c5655a5\":{\"balance\":\"0xd9462c6cb4b5a0000\"},\"33f4a6471eb1bca6a9f85b3b4872e10755c82be1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"33fb577a4d214fe010d32cca7c3eeda63f87ceef\":{\"balance\":\"0x3635c9adc5dea00000\"},\"33fd718f0b91b5cec88a5dc15eecf0ecefa4ef3d\":{\"balance\":\"0x177224aa844c720000\"},\"341480cc8cb476f8d01ff30812e7c70e05afaf5d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"34272d5e7574315dcae9abbd317bac90289d4765\":{\"balance\":\"0x62a992e53a0af00000\"},\"3430a16381f869f6ea5423915855e800883525a9\":{\"balance\":\"0x3ca5c66d9bc44300000\"},\"34318625818ec13f11835ae97353ce377d6f590a\":{\"balance\":\"0x52663ccab1e1c00000\"},\"34393c5d91b9de597203e75bac4309b5fa3d28c3\":{\"balance\":\"0xa844a7424d9c80000\"},\"3439998b247cb4bf8bc80a6d2b3527f1dfe9a6d2\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"34437d1465640b136cb5841c3f934f9ba0b7097d\":{\"balance\":\"0x960db77681e940000\"},\"344a8db086faed4efc37131b3a22b0782dad7095\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"34664d220fa7f37958024a3332d684bcc6d4c8bd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"3466f67e39636c01f43b3a21a0e8529325c08624\":{\"balance\":\"0x2db1167650acd80000\"},\"3485361ee6bf06ef6508ccd23d94641f814d3e2f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3485f621256433b98a4200dad857efe55937ec98\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"34958a46d30e30b273ecc6e5d358a212e5307e8c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3497dd66fd118071a78c2cb36e40b6651cc82598\":{\"balance\":\"0x5f1016b5076d00000\"},\"349a816b17ab3d27bbc0ae0051f6a070be1ff29d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"349d2c918fd09e2807318e66ce432909176bd50b\":{\"balance\":\"0x3cb71f51fc55800000\"},\"34a0431fff5ead927f3c69649616dc6e97945f6f\":{\"balance\":\"0x15af1d78b58c400000\"},\"34a85d6d243fb1dfb7d1d2d44f536e947a4cee9e\":{\"balance\":\"0x43c33c1937564800000\"},\"34a901a69f036bcf9f7843c0ba01b426e8c3dc2b\":{\"balance\":\"0xd8d726b7177a800000\"},\"34b454416e9fb4274e6addf853428a0198d62ee1\":{\"balance\":\"0x161042779f1ffc0000\"},\"34c8e5f1330fcb4b14ca75cb2580a4b93d204e36\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"34e2849bea583ab0cc37975190f322b395055582\":{\"balance\":\"0x1a5c5e857fdf2b20000\"},\"34fa7792bad8bbd7ff64056214a33eb6600c1ea8\":{\"balance\":\"0x2b5e3af16b1880000\"},\"34ff26eb60a8d1a95a489fae136ee91d4e58084c\":{\"balance\":\"0x2086ac351052600000\"},\"34ff582952ff24458f7b13d51f0b4f987022c1fe\":{\"balance\":\"0x9806de3da6e9780000\"},\"35106ba94e8563d4b3cb3c5c692c10e604b7ced8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"35145f620397c69cb8e00962961f0f4886643989\":{\"balance\":\"0x14542ba12a337c00000\"},\"35147430c3106500e79fa2f502462e94703c23b1\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"351787843505f8e4eff46566cce6a59f4d1c5fe7\":{\"balance\":\"0x1f5718987664b480000\"},\"351f16e5e0735af56751b0e225b2421171394090\":{\"balance\":\"0x2d4ca05e2b43ca80000\"},\"3524a000234ebaaf0789a134a2a417383ce5282a\":{\"balance\":\"0x1317955947d8e2c0000\"},\"3526eece1a6bdc3ee7b400fe935b48463f31bed7\":{\"balance\":\"0x477879b6d14300000\"},\"352a785f4a921632504ce5d015f83c49aa838d6d\":{\"balance\":\"0xe9e7e0fb35b7780000\"},\"352d29a26e8a41818181746467f582e6e84012e0\":{\"balance\":\"0x14542ba12a337c00000\"},\"352e77c861696ef96ad54934f894aa8ea35151dd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"352f25babf4a690673e35195efa8f79d05848aad\":{\"balance\":\"0xe253c39be6e7dc00000\"},\"3536453322c1466cb905af5c335ca8db74bff1e6\":{\"balance\":\"0x183b5f03b1479c0000\"},\"353dbec42f92b50f975129b93c4c997375f09073\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"3540c7bd7a8442d5bee21a2180a1c4edff1649e0\":{\"balance\":\"0x432eac4c6f05b98000\"},\"3549bd40bbbc2b30095cac8be2c07a0588e0aed6\":{\"balance\":\"0x1158e460913d00000\"},\"3552a496eba67f12be6eedab360cd13661dc7480\":{\"balance\":\"0x1043561a8829300000\"},\"3554947b7b947b0040da52ca180925c6d3b88ffe\":{\"balance\":\"0x39fbae8d042dd0000\"},\"355c0c39f5d5700b41d375b3f17851dcd52401f9\":{\"balance\":\"0xd7b3b7ba5abf4c0000\"},\"355ccfe0e77d557b971be1a558bc02df9eee0594\":{\"balance\":\"0x5f5cb1afc865280000\"},\"3571cf7ad304ecaee595792f4bbfa484418549d6\":{\"balance\":\"0x13bcd0d892d9e160000\"},\"3575c770668a9d179f1ef768c293f80166e2aa3d\":{\"balance\":\"0x19b21248a3ef280000\"},\"357a02c0a9dfe287de447fb67a70ec5b62366647\":{\"balance\":\"0x1731790534df20000\"},\"35855ec641ab9e081ed0c2a6dcd81354d0244a87\":{\"balance\":\"0x4127abe993a7aa8000\"},\"3588895ac9fbafec012092dc05c0c302d90740fa\":{\"balance\":\"0xa2a15d09519be00000\"},\"3599493ce65772cf93e98af1195ec0955dc98002\":{\"balance\":\"0x5151590c67b3280000\"},\"35a08081799173e001cc5bd46a02406dc95d1787\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"35a549e8fd6c368d6dcca6d2e7d18e4db95f5284\":{\"balance\":\"0x1b1a089237073d0000\"},\"35a6885083c899dabbf530ed6c12f4dd3a204cf5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"35aaa0465d1c260c420fa30e2629869fb6559207\":{\"balance\":\"0x263781e0e087c80000\"},\"35ac1d3ed7464fa3db14e7729213ceaa378c095e\":{\"balance\":\"0x52663ccab1e1c00000\"},\"35af040a0cc2337a76af288154c7561e1a233349\":{\"balance\":\"0x3635c9adc5dea00000\"},\"35b03ea4245736f57b85d2eb79628f036ddcd705\":{\"balance\":\"0xd8d726b7177a800000\"},\"35bd246865fab490ac087ac1f1d4f2c10d0cda03\":{\"balance\":\"0x15af1d78b58c400000\"},\"35bf6688522f35467a7f75302314c02ba176800e\":{\"balance\":\"0x3af418202d954e00000\"},\"35c8adc11125432b3b77acd64625fe58ebee9d66\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"35d2970f49dcc81ea9ee707e9c8a0ab2a8bb7463\":{\"balance\":\"0x4e1003b28d92800000\"},\"35e096120deaa5c1ecb1645e2ccb8b4edbd9299a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"35ea2163a38cdf9a123f82a5ec00258dae0bc767\":{\"balance\":\"0xd8d726b7177a800000\"},\"35f1da127b83376f1b88c82a3359f67a5e67dd50\":{\"balance\":\"0x678a932062e4180000\"},\"35f2949cf78bc219bb4f01907cf3b4b3d3865482\":{\"balance\":\"0xfb5c86c92e4340000\"},\"35f5860149e4bbc04b8ac5b272be55ad1aca58e0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3602458da86f6d6a9d9eb03daf97fe5619d442fa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3605372d93a9010988018f9f315d032ed1880fa1\":{\"balance\":\"0x1b1bcf51896a7d0000\"},\"3616d448985f5d32aefa8b93a993e094bd854986\":{\"balance\":\"0xb227f63be813c0000\"},\"3616fb46c81578c9c8eb4d3bf880451a88379d7d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"361c75931696bc3d427d93e76c77fd13b241f6f4\":{\"balance\":\"0x1dc5d8fc266dd60000\"},\"361d9ed80b5bd27cf9f1226f26753258ee5f9b3f\":{\"balance\":\"0xbf6914ba7d72c20000\"},\"361f3ba9ed956b770f257d3672fe1ff9f7b0240c\":{\"balance\":\"0x2086ac351052600000\"},\"36227cdfa0fd3b9d7e6a744685f5be9aa366a7f0\":{\"balance\":\"0xac2730ee9c6c18000\"},\"362fbcb10662370a068fc2652602a2577937cce6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3630c5e565ceaa8a0f0ffe32875eae2a6ce63c19\":{\"balance\":\"0x937722b3774d00000\"},\"36339f84a5c2b44ce53dfdb6d4f97df78212a7df\":{\"balance\":\"0x116f18b81715a00000\"},\"36343aeca07b6ed58a0e62fa4ecb498a124fc971\":{\"balance\":\"0x1043561a8829300000\"},\"366175403481e0ab15bb514615cbb989ebc68f82\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"36726f3b885a24f92996da81625ec8ad16d8cbe6\":{\"balance\":\"0x53af75d18148578000\"},\"3673954399f6dfbe671818259bb278e2e92ee315\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"36758e049cd98bcea12277a676f9297362890023\":{\"balance\":\"0xd8d726b7177a800000\"},\"367f59cc82795329384e41e1283115e791f26a01\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"36810ff9d213a271eda2b8aa798be654fa4bbe06\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"368c5414b56b8455171fbf076220c1cba4b5ca31\":{\"balance\":\"0x1e3ef911e83d720000\"},\"3690246ba3c80679e22eac4412a1aefce6d7cd82\":{\"balance\":\"0x43c33c1937564800000\"},\"36928b55bc861509d51c8cf1d546bfec6e3e90af\":{\"balance\":\"0x6acb3df27e1f880000\"},\"369822f5578b40dd1f4471706b22cd971352da6b\":{\"balance\":\"0x12c1b6eed03d280000\"},\"369ef761195f3a373e24ece6cd22520fe0b9e86e\":{\"balance\":\"0x1cffafc94db2088000\"},\"36a08fd6fd1ac17ce15ed57eefb12a2be28188bf\":{\"balance\":\"0x487a9a304539440000\"},\"36a0e61e1be47fa87e30d32888ee0330901ca991\":{\"balance\":\"0x1158e460913d00000\"},\"36b2c85e3aeeebb70d63c4a4730ce2e8e88a3624\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"36bf43ff35df90908824336c9b31ce33067e2f50\":{\"balance\":\"0x49721510c1c1e9480000\"},\"36bfe1fa3b7b70c172eb042f6819a8972595413e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"36c510bf8d6e569bf2f37d47265dbcb502ff2bce\":{\"balance\":\"0x65a4da25d3016c00000\"},\"36d85dc3683156e63bf880a9fab7788cf8143a27\":{\"balance\":\"0x43c33c1937564800000\"},\"36df8f883c1273ec8a171f7a33cfd649b1fe6075\":{\"balance\":\"0xc52484ac416890000\"},\"36e156610cd8ff64e780d89d0054385ca76755aa\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"36fec62c2c425e219b18448ad757009d8c54026f\":{\"balance\":\"0x15af1d78b58c400000\"},\"3700e3027424d939dbde5d42fb78f6c4dbec1a8f\":{\"balance\":\"0x22b1c8c1227a00000\"},\"3702e704cc21617439ad4ea27a5714f2fda1e932\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3703350c4d6fe337342cddc65bf1e2386bf3f9b2\":{\"balance\":\"0x6d8121a194d1100000\"},\"3708e59de6b4055088782902e0579c7201a8bf50\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"3712367e5e55a96d5a19168f6eb2bc7e9971f869\":{\"balance\":\"0x3635c9adc5dea00000\"},\"37195a635dcc62f56a718049d47e8f9f96832891\":{\"balance\":\"0x6acb3df27e1f880000\"},\"3727341f26c12001e378405ee38b2d8464ec7140\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"372e453a6b629f27678cc8aeb5e57ce85ec0aef9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3734cb187491ede713ae5b3b2d12284af46b8101\":{\"balance\":\"0xa2a15d09519be00000\"},\"3737216ee91f177732fb58fa4097267207e2cf55\":{\"balance\":\"0x52663ccab1e1c00000\"},\"373c547e0cb5ce632e1c5ad66155720c01c40995\":{\"balance\":\"0xfe54dcdce6c55a0000\"},\"376cd7577383e902951b60a2017ba7ea29e33576\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"378ea1dc8edc19bae82638029ea8752ce98bcfcd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"378f37243f3ff0bef5e1dc85eb4308d9340c29f9\":{\"balance\":\"0x6c6e59e67c78540000\"},\"37959c20b7e9931d72f5a8ae869dafddad3b6d5c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"379a7f755a81a17edb7daaa28afc665dfa6be63a\":{\"balance\":\"0x15af1d78b58c40000\"},\"379c7166849bc24a02d6535e2def13daeef8aa8d\":{\"balance\":\"0x56bc75e2d63100000\"},\"37a05aceb9395c8635a39a7c5d266ae610d10bf2\":{\"balance\":\"0x65a4da25d3016c00000\"},\"37a10451f36166cf643dd2de6c1cbba8a011cfa3\":{\"balance\":\"0x14998f32ac78700000\"},\"37a7a6ff4ea3d60ec307ca516a48d3053bb79cbb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"37ab66083a4fa23848b886f9e66d79cdc150cc70\":{\"balance\":\"0x12be22ffb5ec00380000\"},\"37ac29bda93f497bc4aeaab935452c431510341e\":{\"balance\":\"0x35659ef93f0fc40000\"},\"37b8beac7b1ca38829d61ab552c766f48a10c32f\":{\"balance\":\"0x15af1d78b58c400000\"},\"37bbc47212d82fcb5ee08f5225ecc2041ad2da7d\":{\"balance\":\"0xb1cf24ddd0b1400000\"},\"37cb868d2c3f95b257611eb34a4188d58b749802\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"37d980a12ee3bf23cc5cdb63b4ae45691f74c837\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"37e169a93808d8035698f815c7235613c1e659f2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"37eada93c475ded2f7e15e7787d400470fa52062\":{\"balance\":\"0xad78ebc5ac6200000\"},\"37fac1e6bc122e936dfb84de0c4bef6e0d60c2d7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3807eff43aa97c76910a19752dd715ee0182d94e\":{\"balance\":\"0xd90156f6fc2fb0000\"},\"3815b0743f94fc8cc8654fd9d597ed7d8b77c57e\":{\"balance\":\"0x2809d429d896750000\"},\"381db4c8465df446a4ce15bf81d47e2f17c980bf\":{\"balance\":\"0x6c6b935b8bbd4000000\"},\"38202c5cd7078d4f887673ab07109ad8ada89720\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3821862493242c0aeb84b90de05d250c1e50c074\":{\"balance\":\"0x11776c58e946dc0000\"},\"382591e7217b435e8e884cdbf415fe377a6fe29e\":{\"balance\":\"0x1b2df9d219f57980000\"},\"382ba76db41b75606dd48a48f0137e9174e031b6\":{\"balance\":\"0x1158e460913d00000\"},\"3831757eae7557cb8a37a4b10644b63e4d3b3c75\":{\"balance\":\"0xad78ebc5ac6200000\"},\"383304dd7a5720b29c1a10f60342219f48032f80\":{\"balance\":\"0x12f939c99edab800000\"},\"383a7c899ee18bc214969870bc7482f6d8f3570e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"38430e931d93be01b4c3ef0dc535f1e0a9610063\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"38439aaa24e3636f3a18e020ea1da7e145160d86\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"38458e0685573cb4d28f53098829904570179266\":{\"balance\":\"0x22b1c8c1227a00000\"},\"3847667038f33b01c1cc795d8daf5475eff5a0d4\":{\"balance\":\"0x277b9bf4246c410000\"},\"38643babea6011316cc797d9b093c897a17bdae7\":{\"balance\":\"0x1220bb7445daa00000\"},\"38695fc7e1367ceb163ebb053751f9f68ddb07a0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3872f48dc5e3f817bc6b2ad2d030fc5e0471193d\":{\"balance\":\"0xd8d726b7177a800000\"},\"387eeafd6b4009deaf8bd5b85a72983a8dcc3487\":{\"balance\":\"0xd8d726b7177a800000\"},\"3881defae1c07b3ce04c78abe26b0cdc8d73f010\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3883becc08b9be68ad3b0836aac3b620dc0017ef\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3885fee67107dc3a3c741ee290c98918c9b99397\":{\"balance\":\"0x1158e460913d00000\"},\"3887192c7f705006b630091276b39ac680448d6b\":{\"balance\":\"0x340aad21b3b700000\"},\"38898bbb4553e00bbfd0cf268b2fc464d154add5\":{\"balance\":\"0x1158e460913d000000\"},\"388bdcdae794fc44082e667501344118ea96cd96\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"388c85a9b9207d8146033fe38143f6d34b595c47\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3896ad743579d38e2302454d1fb6e2ab69e01bfd\":{\"balance\":\"0x65ea3db75546600000\"},\"38a3dccf2fcfe0c91a2624bd0cbf88ee4a076c33\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"38a744efa6d5c2137defef8ef9187b649eee1c78\":{\"balance\":\"0xd8d726b7177a800000\"},\"38ac664ee8e0795e4275cb852bcba6a479ad9c8d\":{\"balance\":\"0x1158e460913d00000\"},\"38b2197106123387a0d4de368431a8bacdda30e2\":{\"balance\":\"0x1158e460913d00000\"},\"38b3965c21fa893931079beacfffaf153678b6eb\":{\"balance\":\"0x93c6a0a51e2670000\"},\"38b403fb1fb7c14559a2d6f6564a5552bca39aff\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"38b50146e71916a5448de12a4d742135dcf39833\":{\"balance\":\"0x6d190c475169a200000\"},\"38bf2a1f7a69de0e2546adb808b36335645da9ff\":{\"balance\":\"0x6c700439d9b5600000\"},\"38c10b90c859cbb7815692f99dae520ab5febf5e\":{\"balance\":\"0x2c9e4966fa5cf240000\"},\"38c7851f5ffd4cee98df30f3b25597af8a6ca263\":{\"balance\":\"0x8ead3a2f7d7e180000\"},\"38d2e9154964b41c8d50a7487d391e7ee2c3d3c2\":{\"balance\":\"0xbdbc41e0348b300000\"},\"38da1ba2de9e2c954b092dd9d81204fd016ba016\":{\"balance\":\"0x2268ed01f34b3300000\"},\"38df0c4abe7ded5fe068eadf154ac691774324a4\":{\"balance\":\"0x61093d7c2c6d380000\"},\"38e2af73393ea98a1d993a74df5cd754b98d529a\":{\"balance\":\"0x61093d7c2c6d380000\"},\"38e46de4453c38e941e7930f43304f94bb7b2be8\":{\"balance\":\"0x6cb7e74867d5e60000\"},\"38e7dba8fd4f1f850dbc2649d8e84f0952e3eb3c\":{\"balance\":\"0x2b5e3af16b1880000\"},\"38e8a31af2d265e31a9fff2d8f46286d1245a467\":{\"balance\":\"0x1158e460913d00000\"},\"38ea6f5b5a7b88417551b4123dc127dfe9342da6\":{\"balance\":\"0x15af1d78b58c400000\"},\"38eec6e217f4d41aa920e424b9525197041cd4c6\":{\"balance\":\"0xf00d25eb922e670000\"},\"38f387e1a4ed4a73106ef2b462e474e2e3143ad0\":{\"balance\":\"0x14542ba12a337c00000\"},\"391161b0e43c302066e8a68d2ce7e199ecdb1d57\":{\"balance\":\"0xd8d726b7177a800000\"},\"3915eab5ab2e5977d075dec47d96b68b4b5cf515\":{\"balance\":\"0xd07018185120f400000\"},\"391a77405c09a72b5e8436237aaaf95d68da1709\":{\"balance\":\"0x2a9264af3d1b90000\"},\"391f20176d12360d724d51470a90703675594a4d\":{\"balance\":\"0x56bc75e2d631000000\"},\"392433d2ce83d3fb4a7602cca3faca4ec140a4b0\":{\"balance\":\"0x2c3c465ca58ec0000\"},\"393f783b5cdb86221bf0294fb714959c7b45899c\":{\"balance\":\"0x14061b9d77a5e980000\"},\"393ff4255e5c658f2e7f10ecbd292572671bc2d2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"394132600f4155e07f4d45bc3eb8d9fb72dcd784\":{\"balance\":\"0x9f6e92edea07d40000\"},\"3951e48e3c869e6b72a143b6a45068cdb9d466d0\":{\"balance\":\"0x1158e460913d00000\"},\"3954bdfe0bf587c695a305d9244c3d5bdddac9bb\":{\"balance\":\"0x410278327f985608000\"},\"395d6d255520a8db29abc47d83a5db8a1a7df087\":{\"balance\":\"0x56bc75e2d63100000\"},\"39636b25811b176abfcfeeca64bc87452f1fdff4\":{\"balance\":\"0x15af1d78b58c400000\"},\"3969b4f71bb8751ede43c016363a7a614f76118e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"39782ffe06ac78822a3c3a8afe305e50a56188ce\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"397a6ef8763a18f00fac217e055c0d3094101011\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"397cdb8c80c67950b18d654229610e93bfa6ee1a\":{\"balance\":\"0x3f95c8e08215210000\"},\"39824f8bced176fd3ea22ec6a493d0ccc33fc147\":{\"balance\":\"0xd8d726b7177a800000\"},\"39936c2719450b9420cc2522cf91db01f227c1c1\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3995e096b08a5a726800fcd17d9c64c64e088d2b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"399aa6f5d078cb0970882bc9992006f8fbdf3471\":{\"balance\":\"0x3635c9adc5dea00000\"},\"39aa05e56d7d32385421cf9336e90d3d15a9f859\":{\"balance\":\"0x168d28e3f00280000\"},\"39aaf0854db6eb39bc7b2e43846a76171c0445de\":{\"balance\":\"0x6449e84e47a8a80000\"},\"39b1c471ae94e12164452e811fbbe2b3cd7275ac\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"39b299327490d72f9a9edff11b83afd0e9d3c450\":{\"balance\":\"0xad78ebc5ac6200000\"},\"39bac68d947859f59e9226089c96d62e9fbe3cde\":{\"balance\":\"0x22b1c8c1227a00000\"},\"39bfd978689bec048fc776aa15247f5e1d7c39a2\":{\"balance\":\"0x43c33c1937564800000\"},\"39c773367c8825d3596c686f42bf0d14319e3f84\":{\"balance\":\"0x73f75d1a085ba0000\"},\"39d4a931402c0c79c457186f24df8729cf957031\":{\"balance\":\"0xd8d726b7177a800000\"},\"39d6caca22bccd6a72f87ee7d6b59e0bde21d719\":{\"balance\":\"0x6c8754c8f30c080000\"},\"39e0db4d60568c800b8c5500026c2594f5768960\":{\"balance\":\"0x3635c9adc5dea00000\"},\"39ee4fe00fbced647068d4f57c01cb22a80bccd1\":{\"balance\":\"0x14542ba12a337c00000\"},\"39f198331e4b21c1b760a3155f4ab2fe00a74619\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"39f44663d92561091b82a70dcf593d754005973a\":{\"balance\":\"0xad78b2edc21598000\"},\"3a035594c747476d42d1ee966c36224cdd224993\":{\"balance\":\"0x134af74569f9c50000\"},\"3a04572847d31e81f7765ca5bfc9d557159f3683\":{\"balance\":\"0x7362d0dabeafd8000\"},\"3a06e3bb1edcfd0c44c3074de0bb606b049894a2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"3a10888b7e149cae272c01302c327d0af01a0b24\":{\"balance\":\"0xebec21ee1da40000\"},\"3a3108c1e680a33b336c21131334409d97e5adec\":{\"balance\":\"0x1158e460913d00000\"},\"3a368efe4ad786e26395ec9fc6ad698cae29fe01\":{\"balance\":\"0x2245899675f9f40000\"},\"3a3dd104cd7eb04f21932fd433ea7affd39369f5\":{\"balance\":\"0x13614f23e242260000\"},\"3a4297da3c555e46c073669d0478fce75f2f790e\":{\"balance\":\"0x6ac5c62d9486070000\"},\"3a476bd2c9e664c63ab266aa4c6e4a4825f516c3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3a48e0a7098b06a905802b87545731118e89f439\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3a4da78dce05aeb87de9aead9185726da1926798\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3a59a08246a8206f8d58f70bb1f0d35c5bcc71bd\":{\"balance\":\"0xa076407d3f7440000\"},\"3a72d635aadeee4382349db98a1813a4cfeb3df1\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"3a7db224acae17de7798797d82cdf8253017dfa8\":{\"balance\":\"0x10f0cf064dd59200000\"},\"3a805fa0f7387f73055b7858ca8519edd93d634f\":{\"balance\":\"0x6449e84e47a8a80000\"},\"3a84e950ed410e51b7e8801049ab2634b285fea1\":{\"balance\":\"0x3f52fdaa822d2c80000\"},\"3a86ee94862b743dd34f410969d94e2c5652d4ad\":{\"balance\":\"0xaede69ad30e810000\"},\"3a9132b7093d3ec42e1e4fb8cb31ecdd43ae773c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3a9960266df6492063538a99f487c950a3a5ec9e\":{\"balance\":\"0x5150ae84a8cdf000000\"},\"3a9b111029ce1f20c9109c7a74eeeef34f4f2eb2\":{\"balance\":\"0xd8d726b7177a800000\"},\"3a9e5441d44b243be55b75027a1ceb9eacf50df2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3aa07a34a1afc8967d3d1383b96b62cf96d5fa90\":{\"balance\":\"0x43c33c1937564800000\"},\"3aa42c21b9b31c3e27ccd17e099af679cdf56907\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"3aa948ea02397755effb2f9dc9392df1058f7e33\":{\"balance\":\"0x2e141ea081ca080000\"},\"3aadf98b61e5c896e7d100a3391d3250225d61df\":{\"balance\":\"0xcaf67003701680000\"},\"3aae4872fd9093cbcad1406f1e8078bab50359e2\":{\"balance\":\"0x222c8eb3ff6640000\"},\"3abb8adfc604f48d5984811d7f1d52fef6758270\":{\"balance\":\"0xf29719b66f110c0000\"},\"3ac2f0ff1612e4a1c346d53382abf6d8a25baa53\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3ac9dc7a436ae98fd01c7a9621aa8e9d0b8b531d\":{\"balance\":\"0x61093d7c2c6d380000\"},\"3ad06149b21c55ff867cc3fb9740d2bcc7101231\":{\"balance\":\"0x29b76432b94451200000\"},\"3ad70243d88bf0400f57c8c1fd57811848af162a\":{\"balance\":\"0x2e9ee5c38653f00000\"},\"3ad915d550b723415620f5a9b5b88a85f382f035\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3ae160e3cd60ae31b9d6742d68e14e76bd96c517\":{\"balance\":\"0x1a055690d9db80000\"},\"3ae62bd271a760637fad79c31c94ff62b4cd12f7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3aea4e82d2400248f99871a41ca257060d3a221b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3af65b3e28895a4a001153391d1e69c31fb9db39\":{\"balance\":\"0xd5967be4fc3f100000\"},\"3b07db5a357f5af2484cbc9d77d73b1fd0519fc7\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3b0accaf4b607cfe61d17334c214b75cdefdbd89\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b13631a1b89cb566548899a1d60915cdcc4205b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b159099075207c6807663b1f0f7eda54ac8cce3\":{\"balance\":\"0x6ac4e65b69f92d8000\"},\"3b1937d5e793b89b63fb8eb5f1b1c9ca6ba0fa8e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b22da2a0271c8efe102532773636a69b1c17e09\":{\"balance\":\"0x1b36a6444a3e180000\"},\"3b22dea3c25f1b59c7bd27bb91d3a3eaecef3984\":{\"balance\":\"0x56bc75e2d63100000\"},\"3b2367f8494b5fe18d683c055d89999c9f3d1b34\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"3b2c45990e21474451cf4f59f01955b331c7d7c9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b4100e30a73b0c734b18ffa8426d19b19312f1a\":{\"balance\":\"0xbb5d1aa700afd900000\"},\"3b42a66d979f582834747a8b60428e9b4eeccd23\":{\"balance\":\"0x21a1c790fadc580000\"},\"3b4768fd71e2db2cbe7fa050483c27b4eb931df3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b566a8afad19682dc2ce8679a3ce444a5b0fd4f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b5c251d7fd7893ba209fe541cecd0ce253a990d\":{\"balance\":\"0x65a4da25d3016c00000\"},\"3b5e8b3c77f792decb7a8985df916efb490aac23\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b6e814f770748a7c3997806347605480a3fd509\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b7b4f53c45655f3dc5f017edc23b16f9bc536fa\":{\"balance\":\"0x56bc75e2d63100000\"},\"3b7b8e27de33d3ce7961b98d19a52fe79f6c25be\":{\"balance\":\"0x152d02c7e14af6800000\"},\"3b7c77dbe95dc2602ce3269a9545d04965fefdbd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b8098533f7d9bdcd307dbb23e1777ca18418936\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3b93b16136f11eaf10996c95990d3b2739ccea5f\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"3bab4b01a7c84ba13feea9b0bb191b77a3aadca3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3bb53598cc20e2055dc553b049404ac9b7dd1e83\":{\"balance\":\"0x21571df77c00be0000\"},\"3bbc13d04accc0707aebdcaef087d0b87e0b5ee3\":{\"balance\":\"0xbed1d0263d9f000000\"},\"3bc6e3ee7a56ce8f14a37532590f63716b9966e8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3bc85d6c735b9cda4bba5f48b24b13e70630307b\":{\"balance\":\"0x6acb3df27e1f880000\"},\"3bd624b548cb659736907ed8aa3c0c705e24b575\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3bd9a06d1bd36c4edd27fc0d1f5b088ddae3c72a\":{\"balance\":\"0x1b1a7a420ba00d0000\"},\"3bddbc8134f77d55597fc97c26d26698090604eb\":{\"balance\":\"0xbe202d6a0eda0000\"},\"3bf86ed8a3153ec933786a02ac090301855e576b\":{\"balance\":\"0x5f4a8c8375d155400000\"},\"3bfbd3847c17a61cf3f17b52f8eba1b960b3f39f\":{\"balance\":\"0xa2a15d09519be00000\"},\"3c03bbc023e1e93fa3a3a6e428cf0cd8f95e1ec6\":{\"balance\":\"0x52663ccab1e1c00000\"},\"3c0c3defac9cea7acc319a96c30b8e1fedab4574\":{\"balance\":\"0x692ae8897081d00000\"},\"3c15b3511df6f0342e7348cc89af39a168b7730f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3c1f91f301f4b565bca24751aa1f761322709ddd\":{\"balance\":\"0x61093d7c2c6d380000\"},\"3c286cfb30146e5fd790c2c8541552578de334d8\":{\"balance\":\"0x2291b11aa306e8c0000\"},\"3c322e611fdb820d47c6f8fc64b6fad74ca95f5e\":{\"balance\":\"0xd258ece1b13150000\"},\"3c5a241459c6abbf630239c98a30d20b8b3ac561\":{\"balance\":\"0x88b23acffd9900000\"},\"3c79c863c3d372b3ff0c6f452734a7f97042d706\":{\"balance\":\"0x98a7d9b8314c00000\"},\"3c83c1701db0388b68210d00f5717cd9bd322c6a\":{\"balance\":\"0x65a4da25d3016c00000\"},\"3c860e2e663f46db53427b29fe3ea5e5bf62bbcc\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"3c869c09696523ced824a070414605bb76231ff2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3c925619c9b33144463f0537d896358706c520b0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3c98594bf68b57351e8814ae9e6dfd2d254aa06f\":{\"balance\":\"0x1043561a8829300000\"},\"3cadeb3d3eed3f62311d52553e70df4afce56f23\":{\"balance\":\"0xd8d726b7177a800000\"},\"3caedb5319fe806543c56e5021d372f71be9062e\":{\"balance\":\"0x878678326eac9000000\"},\"3cafaf5e62505615068af8eb22a13ad8a9e55070\":{\"balance\":\"0x6c660645aa47180000\"},\"3cb179cb4801a99b95c3b0c324a2bdc101a65360\":{\"balance\":\"0x168d28e3f00280000\"},\"3cb561ce86424b359891e364ec925ffeff277df7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3ccb71aa6880cb0b84012d90e60740ec06acd78f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3ccef88679573947e94997798a1e327e08603a65\":{\"balance\":\"0x2bc916d69f3b020000\"},\"3cd1d9731bd548c1dd6fcea61beb75d91754f7d3\":{\"balance\":\"0x1161d01b215cae48000\"},\"3cd3a6e93579c56d494171fc533e7a90e6f59464\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3cd6b7593cbee77830a8b19d0801958fcd4bc57a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3cd7f7c7c2353780cde081eeec45822b25f2860c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3ce1dc97fcd7b7c4d3a18a49d6f2a5c1b1a906d7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3cea302a472a940379dd398a24eafdbadf88ad79\":{\"balance\":\"0xa2a15d09519be00000\"},\"3ceca96bb1cdc214029cbc5e181d398ab94d3d41\":{\"balance\":\"0x10f0cf064dd592000000\"},\"3cf484524fbdfadae26dc185e32b2b630fd2e726\":{\"balance\":\"0x185452cb2a91c30000\"},\"3cf9a1d465e78b7039e3694478e2627b36fcd141\":{\"balance\":\"0x4a60532ad51bf00000\"},\"3cfbf066565970639e130df2a7d16b0e14d6091c\":{\"balance\":\"0x5c283d410394100000\"},\"3d09688d93ad07f3abe68c722723cd680990435e\":{\"balance\":\"0x65a4ce99f769e6e0000\"},\"3d31587b5fd5869845788725a663290a49d3678c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3d3fad49c9e5d2759c8e8e5a7a4d60a0dd135692\":{\"balance\":\"0x1158e460913d00000\"},\"3d574fcf00fae1d98cc8bf9ddfa1b3953b9741bc\":{\"balance\":\"0x6acb3df27e1f880000\"},\"3d5a8b2b80be8b35d8ecf789b5ed7a0775c5076c\":{\"balance\":\"0x1158e460913d00000\"},\"3d66cd4bd64d5c8c1b5eea281e106d1c5aad2373\":{\"balance\":\"0x69c4f3a8a110a60000\"},\"3d6ae053fcbc318d6fd0fbc353b8bf542e680d27\":{\"balance\":\"0xc673ce3c40160000\"},\"3d6ff82c9377059fb30d9215723f60c775c891fe\":{\"balance\":\"0xd8e5ce617f2d50000\"},\"3d79a853d71be0621b44e29759656ca075fdf409\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3d7ea5bf03528100ed8af8aed2653e921b6e6725\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3d813ff2b6ed57b937dabf2b381d148a411fa085\":{\"balance\":\"0x56bc75e2d63100000\"},\"3d881433f04a7d0d27f84944e08a512da3555287\":{\"balance\":\"0x410d586a20a4c00000\"},\"3d89e505cb46e211a53f32f167a877bec87f4b0a\":{\"balance\":\"0x15b3557f1937f8000\"},\"3d8d0723721e73a6c0d860aa0557abd14c1ee362\":{\"balance\":\"0x10f0cf064dd59200000\"},\"3d8f39881b9edfe91227c33fa4cdd91e678544b0\":{\"balance\":\"0x4ab07ba43ada98000\"},\"3d9d6be57ff83e065985664f12564483f2e600b2\":{\"balance\":\"0x6eace43f23bd800000\"},\"3da39ce3ef4a7a3966b32ee7ea4ebc2335a8f11f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3daa01ceb70eaf9591fa521ba4a27ea9fb8ede4a\":{\"balance\":\"0x5a63d2c9bc76540000\"},\"3db5fe6a68bd3612ac15a99a61e555928eeceaf3\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"3db9ed7f024c7e26372feacf2b050803445e3810\":{\"balance\":\"0x45b148b4996a300000\"},\"3dbf0dbfd77890800533f09dea8301b9f025d2a6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3dcef19c868b15d34eda426ec7e04b18b6017002\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"3dd12e556a603736feba4a6fa8bd4ac45d662a04\":{\"balance\":\"0x23757b9183e078280000\"},\"3dde8b15b3ccbaa5780112c3d674f313bba68026\":{\"balance\":\"0x601d515a3e4f940000\"},\"3ddedbe48923fbf9e536bf9ffb0747c9cdd39eef\":{\"balance\":\"0x368c8623a8b4d100000\"},\"3deae43327913f62808faa1b6276a2bd6368ead9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3df762049eda8ac6927d904c7af42f94e5519601\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3e040d40cb80ba0125f3b15fdefcc83f3005da1b\":{\"balance\":\"0x384524cc70b7780000\"},\"3e0b8ed86ed669e12723af7572fbacfe829b1e16\":{\"balance\":\"0x514de7f9b812dc0000\"},\"3e0cbe6a6dcb61f110c45ba2aa361d7fcad3da73\":{\"balance\":\"0x1b2df9d219f57980000\"},\"3e194b4ecef8bb711ea2ff24fec4e87bd032f7d1\":{\"balance\":\"0x8b9dc1bc1a036a8000\"},\"3e1b2230afbbd310b4926a4c776d5ae7819c661d\":{\"balance\":\"0x65a4da25d3016c00000\"},\"3e1c53300e4c168912163c7e99b95da268ad280a\":{\"balance\":\"0x3662325cd18fe00000\"},\"3e1c962063e0d5295941f210dca3ab531eec8809\":{\"balance\":\"0xa2a15d09519be00000\"},\"3e2ca0d234baf607ad466a1b85f4a6488ef00ae7\":{\"balance\":\"0x4da21a3483d568000\"},\"3e2f26235e137a7324e4dc154b5df5af46ea1a49\":{\"balance\":\"0x137aad8032db90000\"},\"3e3161f1ea2fbf126e79da1801da9512b37988c9\":{\"balance\":\"0xa6dd90cae5114480000\"},\"3e36c17253c11cf38974ed0db1b759160da63783\":{\"balance\":\"0x17b7883c06916600000\"},\"3e3cd3bec06591d6346f254b621eb41c89008d31\":{\"balance\":\"0x35dfbeda9f37340000\"},\"3e45bd55db9060eced923bb9cb733cb3573fb531\":{\"balance\":\"0x58e7926ee858a00000\"},\"3e4d13c55a84e46ed7e9cb90fd355e8ad991e38f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3e4e9265223c9738324cf20bd06006d0073edb8c\":{\"balance\":\"0x73f75d1a085ba0000\"},\"3e4fbd661015f6461ed6735cefef01f31445de3a\":{\"balance\":\"0x36e342998b8b0200000\"},\"3e53ff2107a8debe3328493a92a586a7e1f49758\":{\"balance\":\"0x4e69c2a71a405ab0000\"},\"3e5a39fdda70df1126ab0dc49a7378311a537a1f\":{\"balance\":\"0x821ab0d44149800000\"},\"3e5abd09ce5af7ba8487c359e0f2a93a986b0b18\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"3e5cb8928c417825c03a3bfcc52183e5c91e42d7\":{\"balance\":\"0xe731d9c52c962f0000\"},\"3e5e93fb4c9c9d1246f8f247358e22c3c5d17b6a\":{\"balance\":\"0x821ab0d4414980000\"},\"3e618350fa01657ab0ef3ebac8e37012f8fc2b6f\":{\"balance\":\"0x9806de3da6e9780000\"},\"3e63ce3b24ca2865b4c5a687b7aea3597ef6e548\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3e66b84769566ab67945d5fa81373556bcc3a1fa\":{\"balance\":\"0x83d6c7aab63600000\"},\"3e76a62db187aa74f63817533b306cead0e8cebe\":{\"balance\":\"0x69b5afac750bb800000\"},\"3e7a966b5dc357ffb07e9fe067c45791fd8e3049\":{\"balance\":\"0x3342d60dff1960000\"},\"3e81772175237eb4cbe0fe2dcafdadffeb6a1999\":{\"balance\":\"0x1dd0c885f9a0d800000\"},\"3e8349b67f5745449f659367d9ad4712db5b895a\":{\"balance\":\"0x62a992e53a0af00000\"},\"3e83544f0082552572c782bee5d218f1ef064a9d\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"3e84b35c5b2265507061d30b6f12da033fe6f8b9\":{\"balance\":\"0x61093d7c2c6d380000\"},\"3e8641d43c42003f0a33c929f711079deb2b9e46\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3e8745ba322f5fd6cb50124ec46688c7a69a7fae\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"3e914e3018ac00449341c49da71d04dfeeed6221\":{\"balance\":\"0xd8d726b7177a800000\"},\"3e9410d3b9a87ed5e451a6b91bb8923fe90fb2b5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3e94df5313fa520570ef232bc3311d5f622ff183\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3e9b34a57f3375ae59c0a75e19c4b641228d9700\":{\"balance\":\"0xf8699329677e0000\"},\"3eada8c92f56067e1bb73ce378da56dc2cdfd365\":{\"balance\":\"0x77cde93aeb0d480000\"},\"3eaf0879b5b6db159b589f84578b6a74f6c10357\":{\"balance\":\"0x18938b671fa65a28000\"},\"3eaf316b87615d88f7adc77c58e712ed4d77966b\":{\"balance\":\"0x56dbc4cee24648000\"},\"3eb8b33b21d23cda86d8288884ab470e164691b5\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"3eb9ef06d0c259040319947e8c7a6812aa0253d8\":{\"balance\":\"0x90d972f32323c0000\"},\"3ecc8e1668dde995dc570fe414f44211c534a615\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3ecdb532e397579662b2a46141e78f8235936a5f\":{\"balance\":\"0x39fbae8d042dd0000\"},\"3eee6f1e96360b7689b3069adaf9af8eb60ce481\":{\"balance\":\"0x3635c9adc5dea00000\"},\"3f08d9ad894f813e8e2148c160d24b353a8e74b0\":{\"balance\":\"0xcb49b44ba602d800000\"},\"3f0c83aac5717962734e5ceaeaecd39b28ad06be\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3f10800282d1b7ddc78fa92d8230074e1bf6aeae\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"3f1233714f204de9de4ee96d073b368d8197989f\":{\"balance\":\"0x217c41074e6bb0000\"},\"3f173aa6edf469d185e59bd26ae4236b92b4d8e1\":{\"balance\":\"0x1158e460913d000000\"},\"3f1bc420c53c002c9e90037c44fe6a8ef4ddc962\":{\"balance\":\"0x960db77681e940000\"},\"3f236108eec72289bac3a65cd283f95e041d144c\":{\"balance\":\"0x3634bf39ab98788000\"},\"3f2da093bb16eb064f8bfa9e30b929d15f8e1c4c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3f2dd55db7eab0ebee65b33ed8202c1e992e958b\":{\"balance\":\"0x2c73c937742c500000\"},\"3f2f381491797cc5c0d48296c14fd0cd00cdfa2d\":{\"balance\":\"0x2b95bdcc39b6100000\"},\"3f30d3bc9f602232bc724288ca46cd0b0788f715\":{\"balance\":\"0xd8d726b7177a800000\"},\"3f3c8e61e5604cef0605d436dd22accd862217fc\":{\"balance\":\"0x487a9a304539440000\"},\"3f3f46b75cabe37bfacc8760281f4341ca7f463d\":{\"balance\":\"0x20ac448235fae88000\"},\"3f472963197883bbda5a9b7dfcb22db11440ad31\":{\"balance\":\"0x1a19643cb1eff08000\"},\"3f4cd1399f8a34eddb9a17a471fc922b5870aafc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3f551ba93cd54693c183fb9ad60d65e1609673c9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3f627a769e6a950eb87017a7cd9ca20871136831\":{\"balance\":\"0x2eb8eb1a172dcb80000\"},\"3f6dd3650ee428dcb7759553b017a96a94286ac9\":{\"balance\":\"0x487a9a304539440000\"},\"3f747237806fed3f828a6852eb0867f79027af89\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"3f75ae61cc1d8042653b5baec4443e051c5e7abd\":{\"balance\":\"0x52d542804f1ce0000\"},\"3fb7d197b3ba4fe045efc23d50a14585f558d9b2\":{\"balance\":\"0x1158e460913d00000\"},\"3fbc1e4518d73400c6d046359439fb68ea1a49f4\":{\"balance\":\"0x3790bb8551376400000\"},\"3fbed6e7e0ca9c84fbe9ebcf9d4ef9bb49428165\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3fd0bb47798cf44cdfbe4d333de637df4a00e45c\":{\"balance\":\"0x56c5579f722140000\"},\"3fe40fbd919aad2818df01ee4df46c46842ac539\":{\"balance\":\"0x14542ba12a337c00000\"},\"3fe801e61335c5140dc7eda2ef5204460a501230\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"3ff836b6f57b901b440c30e4dbd065cf37d3d48c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"3ffcb870d4023d255d5167d8a507cefc366b68ba\":{\"balance\":\"0x23343c4354d2ac0000\"},\"401354a297952fa972ad383ca07a0a2811d74a71\":{\"balance\":\"0xc249fdd327780000\"},\"4030a925706b2c101c8c5cb9bd05fbb4f6759b18\":{\"balance\":\"0xd8d726b7177a800000\"},\"403145cb4ae7489fcc90cd985c6dc782b3cc4e44\":{\"balance\":\"0x1453ff387b27cac0000\"},\"403220600a36f73f24e190d1edb2d61be3f41354\":{\"balance\":\"0x107ad8f556c6c00000\"},\"4039bd50a2bde15ffe37191f410390962a2b8886\":{\"balance\":\"0xad78ebc5ac6200000\"},\"403c64896a75cad816a9105e18d8aa5bf80f238e\":{\"balance\":\"0x35659ef93f0fc40000\"},\"403d53cf620f0922b417848dee96c190b5bc8271\":{\"balance\":\"0x215f835bc769da80000\"},\"404100db4c5d0eec557823b58343758bcc2c8083\":{\"balance\":\"0x1158e460913d00000\"},\"4041374b0feef4792e4b33691fb86897a4ff560c\":{\"balance\":\"0x13c9647e25a9940000\"},\"40467d80e74c35407b7db51789234615fea66818\":{\"balance\":\"0x150894e849b3900000\"},\"40585200683a403901372912a89834aadcb55fdb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4058808816fdaa3a5fc98ed47cfae6c18315422e\":{\"balance\":\"0xad4c8316a0b0c0000\"},\"405f596b94b947344c033ce2dcbff12e25b79784\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"40630024bd2c58d248edd8465617b2bf1647da0e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"40652360d6716dc55cf9aab21f3482f816cc2cbd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"407295ebd94b48269c2d569c9b9af9aa05e83e5e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4073fa49b87117cb908cf1ab512da754a932d477\":{\"balance\":\"0x6acb3df27e1f880000\"},\"408a69a40715e1b313e1354e600800a1e6dc02a5\":{\"balance\":\"0x1e7b891cc92540000\"},\"409bd75085821c1de70cdc3b11ffc3d923c74010\":{\"balance\":\"0xd8d726b7177a800000\"},\"409d5a962edeeebea178018c0f38b9cdb213f289\":{\"balance\":\"0x1158e460913d00000\"},\"40a331195b977325c2aa28fa2f42cb25ec3c253c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"40a7f72867a7dc86770b162b7557a434ed50cce9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"40ab0a3e83d0c8ac9366910520eab1772bac3b1a\":{\"balance\":\"0x34f10c2dc05e7c0000\"},\"40ab66fe213ea56c3afb12c75be33f8e32fd085d\":{\"balance\":\"0xd8d726b7177a800000\"},\"40ad74bc0bce2a45e52f36c3debb1b3ada1b7619\":{\"balance\":\"0x170162de109c6580000\"},\"40cf890591eae4a18f812a2954cb295f633327e6\":{\"balance\":\"0x29bf736fc591a0000\"},\"40cf90ef5b768c5da585002ccbe6617650d8e837\":{\"balance\":\"0x36330322d5238c0000\"},\"40d45d9d7625d15156c932b771ca7b0527130958\":{\"balance\":\"0x152d02c7e14af6800000\"},\"40db1ba585ce34531edec5494849391381e6ccd3\":{\"balance\":\"0x61093d7c2c6d380000\"},\"40df495ecf3f8b4cef2a6c189957248fe884bc2b\":{\"balance\":\"0x28a857425466f800000\"},\"40e0dbf3efef9084ea1cd7e503f40b3b4a8443f6\":{\"balance\":\"0xd8d726b7177a800000\"},\"40e2440ae142c880366a12c6d4102f4b8434b62a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"40e3c283f7e24de0410c121bee60a5607f3e29a6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"40ea5044b204b23076b1a5803bf1d30c0f88871a\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"40eddb448d690ed72e05c225d34fc8350fa1e4c5\":{\"balance\":\"0x17b7883c06916600000\"},\"40f4f4c06c732cd35b119b893b127e7d9d0771e4\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"41010fc8baf8437d17a04369809a168a17ca56fb\":{\"balance\":\"0x56bc75e2d63100000\"},\"4103299671d46763978fa4aa19ee34b1fc952784\":{\"balance\":\"0xad78ebc5ac6200000\"},\"41033c1b6d05e1ca89b0948fc64453fbe87ab25e\":{\"balance\":\"0x487a9a304539440000\"},\"41098a81452317c19e3eef0bd123bbe178e9e9ca\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"411610b178d5617dfab934d293f512a93e5c10e1\":{\"balance\":\"0x93739534d28680000\"},\"411c831cc6f44f1965ec5757ab4e5b3ca4cffd1f\":{\"balance\":\"0x170a0f5040e5040000\"},\"412a68f6c645559cc977fc4964047a201d1bb0e2\":{\"balance\":\"0xa968163f0a57b400000\"},\"413f4b02669ccff6806bc826fcb7deca3b0ea9bc\":{\"balance\":\"0x1158e460913d00000\"},\"414599092e879ae25372a84d735af5c4e510cd6d\":{\"balance\":\"0x15af1d78b58c400000\"},\"41485612d03446ec4c05e5244e563f1cbae0f197\":{\"balance\":\"0x34957444b840e80000\"},\"415d096ab06293183f3c033d25f6cf7178ac3bc7\":{\"balance\":\"0x22b1c8c1227a00000\"},\"4166fc08ca85f766fde831460e9dc93c0e21aa6c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"416784af609630b070d49a8bcd12235c6428a408\":{\"balance\":\"0x43c33c1937564800000\"},\"4167cd48e733418e8f99ffd134121c4a4ab278c4\":{\"balance\":\"0xc55325ca7415e00000\"},\"416c86b72083d1f8907d84efd2d2d783dffa3efb\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"4173419d5c9f6329551dc4d3d0ceac1b701b869e\":{\"balance\":\"0x4c53ecdc18a600000\"},\"4174fa1bc12a3b7183cbabb77a0b59557ba5f1db\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"41786a10d447f484d33244ccb7facd8b427b5b8c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"417a3cd19496530a6d4204c3b5a17ce0f207b1a5\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"417e4e2688b1fd66d821529e46ed4f42f8b3db3d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"419a71a36c11d105e0f2aef5a3e598078e85c80b\":{\"balance\":\"0x10f0cf064dd59200000\"},\"419bde7316cc1ed295c885ace342c79bf7ee33ea\":{\"balance\":\"0x14542ba12a337c00000\"},\"41a2f2e6ecb86394ec0e338c0fc97e9c5583ded2\":{\"balance\":\"0x6cee06ddbe15ec0000\"},\"41a8c2830081b102df6e0131657c07ab635b54ce\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"41a8e236a30e6d63c1ff644d132aa25c89537e01\":{\"balance\":\"0x1158e460913d00000\"},\"41a9a404fc9f5bfee48ec265b12523338e29a8bf\":{\"balance\":\"0x150894e849b3900000\"},\"41ad369f758fef38a19aa3149379832c818ef2a0\":{\"balance\":\"0x36369ed7747d260000\"},\"41b2d34fde0b1029262b4172c81c1590405b03ae\":{\"balance\":\"0x3635c9adc5dea00000\"},\"41b2dbd79dda9b864f6a7030275419c39d3efd3b\":{\"balance\":\"0xad78ebc5ac62000000\"},\"41c3c2367534d13ba2b33f185cdbe6ac43c2fa31\":{\"balance\":\"0xd8d726b7177a800000\"},\"41cb9896445f70a10a14215296daf614e32cf4d5\":{\"balance\":\"0x678a932062e4180000\"},\"41ce79950935cff55bf78e4ccec2fe631785db95\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"41d3b731a326e76858baa5f4bd89b57b36932343\":{\"balance\":\"0x155bd9307f9fe80000\"},\"41e4a20275e39bdcefeb655c0322744b765140c2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"41ed2d8e7081482c919fc23d8f0091b3c82c4685\":{\"balance\":\"0x463a1e765bd78a0000\"},\"41f27e744bd29de2b0598f02a0bb9f98e681eaa4\":{\"balance\":\"0x1a4aba225c207400000\"},\"41f489a1ec747bc29c3e5f9d8db97877d4d1b4e9\":{\"balance\":\"0x73f75d1a085ba0000\"},\"420fb86e7d2b51401fc5e8c72015decb4ef8fc2e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"421684baa9c0b4b5f55338e6f6e7c8e146d41cb7\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"42399659aca6a5a863ea2245c933fe9a35b7880e\":{\"balance\":\"0x6ece32c26c82700000\"},\"423bca47abc00c7057e3ad34fca63e375fbd8b4a\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"423c3107f4bace414e499c64390a51f74615ca5e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"423cc4594cf4abb6368de59fd2b1230734612143\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4244f1331158b9ce26bbe0b9236b9203ca351434\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"425177eb74ad0a9d9a5752228147ee6d6356a6e6\":{\"balance\":\"0xb98bc829a6f90000\"},\"425725c0f08f0811f5f006eec91c5c5c126b12ae\":{\"balance\":\"0x821ab0d4414980000\"},\"4258fd662fc4ce3295f0d4ed8f7bb1449600a0a9\":{\"balance\":\"0x16c452ed6088ad80000\"},\"425c1816868f7777cc2ba6c6d28c9e1e796c52b3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"425c338a1325e3a1578efa299e57d986eb474f81\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"426259b0a756701a8b663528522156c0288f0f24\":{\"balance\":\"0x218ae196b8d4f300000\"},\"426d15f407a01135b13a6b72f8f2520b3531e302\":{\"balance\":\"0x1158e460913d00000\"},\"426f78f70db259ac8534145b2934f4ef1098b5d8\":{\"balance\":\"0x138400eca364a00000\"},\"42732d8ef49ffda04b19780fd3c18469fb374106\":{\"balance\":\"0x170b00e5e4a9be0000\"},\"427417bd16b1b3d22dbb902d8f9657016f24a61c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"42746aeea14f27beff0c0da64253f1e7971890a0\":{\"balance\":\"0x54069233bf7f780000\"},\"427b462ab84e5091f48a46eb0cdc92ddcb26e078\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"427e4751c3babe78cff8830886febc10f9908d74\":{\"balance\":\"0x6acb3df27e1f880000\"},\"427ec668ac9404e895cc861511d1620a4912be98\":{\"balance\":\"0x878678326eac9000000\"},\"4280a58f8bb10b9440de94f42b4f592120820191\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"428a1ee0ed331d7952ccbe1c7974b2852bd1938a\":{\"balance\":\"0x77b74a4e8de5650000\"},\"429c06b487e8546abdfc958a25a3f0fba53f6f00\":{\"balance\":\"0xbb644af542198000\"},\"42a98bf16027ce589c4ed2c95831e2724205064e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"42c6edc515d35557808d13cd44dcc4400b2504e4\":{\"balance\":\"0xaba14c59ba7320000\"},\"42cecfd2921079c2d7df3f08b07aa3beee5e219a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"42d1a6399b3016a8597f8b640927b8afbce4b215\":{\"balance\":\"0xa18bcec34888100000\"},\"42d34940edd2e7005d46e2188e4cfece8311d74d\":{\"balance\":\"0x890b0c2e14fb80000\"},\"42d3a5a901f2f6bd9356f112a70180e5a1550b60\":{\"balance\":\"0x3224f42723d4540000\"},\"42d6b263d9e9f4116c411424fc9955783c763030\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"42db0b902559e04087dd5c441bc7611934184b89\":{\"balance\":\"0x6d33b17d253a620000\"},\"42ddd014dc52bfbcc555325a40b516f4866a1dd3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4319263f75402c0b5325f263be4a5080651087f0\":{\"balance\":\"0x354b0f14631bab0000\"},\"431f2c19e316b044a4b3e61a0c6ff8c104a1a12f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"43227d65334e691cf231b4a4e1d339b95d598afb\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"432809a2390f07c665921ff37d547d12f1c9966a\":{\"balance\":\"0x65a4da25d3016c00000\"},\"4329fc0931cbeb033880fe4c9398ca45b0e2d11a\":{\"balance\":\"0x6c7120716d33680000\"},\"432d884bd69db1acc0d89c64ade4cb4fc3a88b7a\":{\"balance\":\"0x869a8c10808eec0000\"},\"4331ab3747d35720a9d8ca25165cd285acd4bda8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"433a3b68e56b0df1862b90586bbd39c840ff1936\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"433e3ba1c51b810fc467d5ba4dea42f7a9885e69\":{\"balance\":\"0x878678326eac9000000\"},\"433eb94a339086ed12d9bde9cd1d458603c97dd6\":{\"balance\":\"0x152d02c7e14af6800000\"},\"4349225a62f70aea480a029915a01e5379e64fa5\":{\"balance\":\"0x8cd67e2334c0d80000\"},\"4354221e62dc09e6406436163a185ef06d114a81\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"435443b81dfdb9bd8c6787bc2518e2d47e57c15f\":{\"balance\":\"0x1438d9397881ef20000\"},\"4361d4846fafb377b6c0ee49a596a78ddf3516a3\":{\"balance\":\"0xc2127af858da700000\"},\"4364309a9fa07095600f79edc65120cdcd23dc64\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4367ae4b0ce964f4a54afd4b5c368496db169e9a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"43748928e8c3ec4436a1d092fbe43ac749be1251\":{\"balance\":\"0x15af1d78b58c400000\"},\"43767bf7fd2af95b72e9312da9443cb1688e4343\":{\"balance\":\"0x1043561a8829300000\"},\"437983388ab59a4ffc215f8e8269461029c3f1c1\":{\"balance\":\"0x43c33c1937564800000\"},\"43898c49a34d509bfed4f76041ee91caf3aa6aa5\":{\"balance\":\"0x1043561a8829300000\"},\"438c2f54ff8e629bab36b1442b760b12a88f02ae\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4398628ea6632d393e929cbd928464c568aa4a0c\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"439d2f2f5110a4d58b1757935015408740fec7f8\":{\"balance\":\"0xcfa5c5150f4c888000\"},\"439dee3f7679ff1030733f9340c096686b49390b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"43b079baf0727999e66bf743d5bcbf776c3b0922\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"43bc2d4ddcd6583be2c7bc094b28fb72e62ba83b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"43c7ebc5b3e7af16f47dc5617ab10e0f39b4afbb\":{\"balance\":\"0x678a932062e4180000\"},\"43cb9652818c6f4d6796b0e89409306c79db6349\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"43cc08d0732aa58adef7619bed46558ad7774173\":{\"balance\":\"0xf0e7dcb0122a8f0000\"},\"43d5a71ce8b8f8ae02b2eaf8eaf2ca2840b93fb6\":{\"balance\":\"0x14542ba12a337c00000\"},\"43db7ff95a086d28ebbfb82fb8fb5f230a5ebccd\":{\"balance\":\"0xdf6eb0b2d3ca0000\"},\"43e7ec846358d7d0f937ad1c350ba069d7bf72bf\":{\"balance\":\"0x670ae629214680000\"},\"43f16f1e75c3c06a9478e8c597a40a3cb0bf04cc\":{\"balance\":\"0x9df7dfa8f760480000\"},\"43f470ed659e2991c375957e5ddec5bd1d382231\":{\"balance\":\"0x56bc75e2d63100000\"},\"43f7e86e381ec51ec4906d1476cba97a3db584e4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"43ff38743ed0cd43308c066509cc8e7e72c862aa\":{\"balance\":\"0x692ae8897081d00000\"},\"43ff8853e98ed8406b95000ada848362d6a0392a\":{\"balance\":\"0x4ae0b1c4d2e84d00000\"},\"44098866a69b68c0b6bc168229b9603587058967\":{\"balance\":\"0xa31062beeed700000\"},\"4419ac618d5dea7cdc6077206fb07dbdd71c1702\":{\"balance\":\"0xd8d726b7177a800000\"},\"441a52001661fac718b2d7b351b7c6fb521a7afd\":{\"balance\":\"0x15af1d78b58c400000\"},\"441aca82631324acbfa2468bda325bbd78477bbf\":{\"balance\":\"0x14542ba12a337c00000\"},\"441f37e8a029fd02482f289c49b5d06d00e408a4\":{\"balance\":\"0x1211ecb56d13488000\"},\"4420aa35465be617ad2498f370de0a3cc4d230af\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"44232ff66ddad1fd841266380036afd7cf7d7f42\":{\"balance\":\"0xad78ebc5ac6200000\"},\"44250d476e062484e9080a3967bf3a4a732ad73f\":{\"balance\":\"0x1158e460913d00000\"},\"4429a29fee198450672c0c1d073162250bec6474\":{\"balance\":\"0x362aaf8202f2500000\"},\"44355253b27748e3f34fe9cae1fb718c8f249529\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4438e880cb2766b0c1ceaec9d2418fceb952a044\":{\"balance\":\"0x73fa073903f080000\"},\"444caf79b71338ee9aa7c733b02acaa7dc025948\":{\"balance\":\"0x22b1c8c1227a00000\"},\"445cb8de5e3df520b499efc980f52bff40f55c76\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"446a8039cecf9dce4879cbcaf3493bf545a88610\":{\"balance\":\"0x17b7883c06916600000\"},\"4474299d0ee090dc90789a1486489c3d0d645e6d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"448bf410ad9bbc2fecc4508d87a7fc2e4b8561ad\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"44901e0d0e08ac3d5e95b8ec9d5e0ff5f12e0393\":{\"balance\":\"0x16a1f9f5fd7d960000\"},\"4493123c021ece3b33b1a452c9268de14007f9d3\":{\"balance\":\"0x16a6502f15a1e540000\"},\"449ac4fbe383e36738855e364a57f471b2bfa131\":{\"balance\":\"0x29b76432b94451200000\"},\"44a01fb04ac0db2cce5dbe281e1c46e28b39d878\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"44a63d18424587b9b307bfc3c364ae10cd04c713\":{\"balance\":\"0x1158e460913d00000\"},\"44a8989e32308121f72466978db395d1f76c3a4b\":{\"balance\":\"0x18850299f42b06a0000\"},\"44c1110b18870ec81178d93d215838c551d48e64\":{\"balance\":\"0xad6f98593bd8f0000\"},\"44c14765127cde11fab46c5d2cf4d4b2890023fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"44c54eaa8ac940f9e80f1e74e82fc14f1676856a\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"44cd77535a893fa7c4d5eb3a240e79d099a72d2d\":{\"balance\":\"0x2c73c937742c500000\"},\"44dfba50b829becc5f4f14d1b04aab3320a295e5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"44e2fdc679e6bee01e93ef4a3ab1bcce012abc7c\":{\"balance\":\"0x163d194900c5458000\"},\"44f62f2aaabc29ad3a6b04e1ff6f9ce452d1c140\":{\"balance\":\"0x39992648a23c8a00000\"},\"44fff37be01a3888d3b8b8e18880a7ddefeeead3\":{\"balance\":\"0xe0c5bfc7dae9a8000\"},\"4506fe19fa4b006baa3984529d8516db2b2b50ab\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"451b3699475bed5d7905f8905aa3456f1ed788fc\":{\"balance\":\"0x8ac7230489e8000000\"},\"451b7070259bdba27100e36e23428a53dfe304e9\":{\"balance\":\"0xb98bc829a6f90000\"},\"45272b8f62e9f9fa8ce04420e1aea3eba9686eac\":{\"balance\":\"0xd8d726b7177a800000\"},\"452b64db8ef7d6df87c788639c2290be8482d575\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"453e359a3397944c5a275ab1a2f70a5e5a3f6989\":{\"balance\":\"0xd02ab486cedc00000\"},\"4549b15979255f7e65e99b0d5604db98dfcac8bf\":{\"balance\":\"0xd8d726b7177a800000\"},\"454b61b344c0ef965179238155f277c3829d0b38\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"454f0141d721d33cbdc41018bd01119aa4784818\":{\"balance\":\"0x14542ba12a337c00000\"},\"45533390e340fe0de3b3cf5fb9fc8ea552e29e62\":{\"balance\":\"0x4f2591f896a6500000\"},\"455396a4bbd9bae8af9fb7c4d64d471db9c24505\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"455b9296921a74d1fc41617f43b8303e6f3ed76c\":{\"balance\":\"0xe3aeb5737240a00000\"},\"455cb8ee39ffbc752331e5aefc588ef0ee593454\":{\"balance\":\"0x3635463a780def8000\"},\"456ae0aca48ebcfae166060250525f63965e760f\":{\"balance\":\"0x1043561a8829300000\"},\"456f8d746682b224679349064d1b368c7c05b176\":{\"balance\":\"0xc893d09c8f51500000\"},\"457029c469c4548d168cec3e65872e4428d42b67\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4571de672b9904bad8743692c21c4fdcea4c2e01\":{\"balance\":\"0xd8d726b7177a800000\"},\"45781bbe7714a1c8f73b1c747921df4f84278b70\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"457bcef37dd3d60b2dd019e3fe61d46b3f1e7252\":{\"balance\":\"0x1158e460913d00000\"},\"458e3cc99e947844a18e6a42918fef7e7f5f5eb3\":{\"balance\":\"0x7b53f79e888dac00000\"},\"459393d63a063ef3721e16bd9fde45ee9dbd77fb\":{\"balance\":\"0x6abad6a3c153050000\"},\"45a570dcc2090c86a6b3ea29a60863dde41f13b5\":{\"balance\":\"0xc9a95ee2986520000\"},\"45a820a0672f17dc74a08112bc643fd1167736c3\":{\"balance\":\"0xad6c43b2815ed8000\"},\"45b47105fe42c4712dce6e2a21c05bffd5ea47a9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"45bb829652d8bfb58b8527f0ecb621c29e212ec3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"45c0d19f0b8e054f9e893836d5ecae7901af2812\":{\"balance\":\"0x10f0cf064dd59200000\"},\"45c4ecb4ee891ea984a7c5cefd8dfb00310b2850\":{\"balance\":\"0x6b56051582a9700000\"},\"45ca8d956608f9e00a2f9974028640888465668f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"45ca9862003b4e40a3171fb5cafa9028cac8de19\":{\"balance\":\"0x2eb8eb1a172dcb80000\"},\"45d1c9eedf7cab41a779057b79395f5428d80528\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"45d4b54d37a8cf599821235f062fa9d170ede8a4\":{\"balance\":\"0x1190673b5fda900000\"},\"45db03bccfd6a5f4d0266b82a22a368792c77d83\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"45e3a93e72144ada860cbc56ff85145ada38c6da\":{\"balance\":\"0x57473d05dabae80000\"},\"45e68db8dbbaba5fc2cb337c62bcd0d61b059189\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"45e68db94c7d0ab7ac41857a71d67147870f4e71\":{\"balance\":\"0x54b40b1f852bda000000\"},\"45f4fc60f08eaca10598f0336329801e3c92cb46\":{\"balance\":\"0xad78ebc5ac6200000\"},\"460d5355b2ceeb6e62107d81e51270b26bf45620\":{\"balance\":\"0x6cb7e74867d5e60000\"},\"46224f32f4ece5c8867090d4409d55e50b18432d\":{\"balance\":\"0x14542ba12a337c00000\"},\"4627c606842671abde8295ee5dd94c7f549534f4\":{\"balance\":\"0xf895fbd8732f40000\"},\"462b678b51b584f3ed7ada070b5cd99c0bf7b87f\":{\"balance\":\"0x56bc75e2d63100000\"},\"464d9c89cce484df000277198ed8075fa63572d1\":{\"balance\":\"0x1158e460913d00000\"},\"46504e6a215ac83bccf956befc82ab5a679371c8\":{\"balance\":\"0x1c212805c2b4a50000\"},\"4651dc420e08c3293b27d2497890eb50223ae2f4\":{\"balance\":\"0x43c33c1937564800000\"},\"46531e8b1bde097fdf849d6d119885608a008df7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"466292f0e80d43a78774277590a9eb45961214f4\":{\"balance\":\"0x34957444b840e80000\"},\"4662a1765ee921842ddc88898d1dc8627597bd7e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4665e47396c7db97eb2a03d90863d5d4ba319a94\":{\"balance\":\"0x2086ac351052600000\"},\"466fda6b9b58c5532750306a10a2a8c768103b07\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"467124ae7f452f26b3d574f6088894fa5d1cfb3b\":{\"balance\":\"0x925e06eec972b00000\"},\"46722a36a01e841d03f780935e917d85d5a67abd\":{\"balance\":\"0xcec76f0e71520000\"},\"46779a5656ff00d73eac3ad0c38b6c853094fb40\":{\"balance\":\"0xc8253c96c6af00000\"},\"4677b04e0343a32131fd6abb39b1b6156bba3d5b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"467d5988249a68614716659840ed0ae6f6f457bc\":{\"balance\":\"0x1501a48cefdfde0000\"},\"467e0ed54f3b76ae0636176e07420815a021736e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"467ea10445827ef1e502daf76b928a209e0d4032\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"467fbf41441600757fe15830c8cd5f4ffbbbd560\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"469358709332c82b887e20bcddd0220f8edba7d0\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"4697baaf9ccb603fd30430689d435445e9c98bf5\":{\"balance\":\"0xad201a6794ff80000\"},\"46a30b8a808931217445c3f5a93e882c0345b426\":{\"balance\":\"0xd8db5ebd7b2638000\"},\"46a430a2d4a894a0d8aa3feac615361415c3f81f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"46aa501870677e7f0a504876b4e8801a0ad01c46\":{\"balance\":\"0x2b5e3af16b18800000\"},\"46bfc5b207eb2013e2e60f775fecd71810c5990c\":{\"balance\":\"0x54069233bf7f780000\"},\"46c1aa2244b9c8a957ca8fac431b0595a3b86824\":{\"balance\":\"0xd8d726b7177a800000\"},\"46d80631284203f6288ecd4e5758bb9d41d05dbe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"470ac5d1f3efe28f3802af925b571e63868b397d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"471010da492f4018833b088d9872901e06129174\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"4712540265cbeec3847022c59f1b318d43400a9e\":{\"balance\":\"0xbdbc41e0348b300000\"},\"4714cfa4f46bd6bd70737d75878197e08f88e631\":{\"balance\":\"0x27f3edfb34e6e400000\"},\"472048cc609aeb242165eaaa8705850cf3125de0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"47219229e8cd56659a65c2a943e2dd9a8f4bfd89\":{\"balance\":\"0x52663ccab1e1c00000\"},\"4737d042dc6ae73ec73ae2517acea2fdd96487c5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"474158a1a9dc693c133f65e47b5c3ae2f773a86f\":{\"balance\":\"0xada55474b81340000\"},\"4745ab181a36aa8cbf2289d0c45165bc7ebe2381\":{\"balance\":\"0x222c8eb3ff6640000\"},\"475066f9ad26655196d5535327bbeb9b7929cb04\":{\"balance\":\"0xa4cc799563c3800000\"},\"4752218e54de423f86c0501933917aea08c8fed5\":{\"balance\":\"0x43c33c1937564800000\"},\"475a6193572d4a4e59d7be09cb960ddd8c530e2f\":{\"balance\":\"0x242cf78cdf07ff8000\"},\"47648bed01f3cd3249084e635d14daa9e7ec3c8a\":{\"balance\":\"0xa844a7424d9c80000\"},\"47688410ff25d654d72eb2bc06e4ad24f833b094\":{\"balance\":\"0x8b28d61f3d3ac0000\"},\"476b5599089a3fb6f29c6c72e49b2e4740ea808d\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"47730f5f8ebf89ac72ef80e46c12195038ecdc49\":{\"balance\":\"0xab4dcf399a3a600000\"},\"477b24eee8839e4fd19d1250bd0b6645794a61ca\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"4781a10a4df5eebc82f4cfe107ba1d8a7640bd66\":{\"balance\":\"0x61093d7c2c6d380000\"},\"47885ababedf4d928e1c3c71d7ca40d563ed595f\":{\"balance\":\"0x62a992e53a0af00000\"},\"478dc09a1311377c093f9cc8ae74111f65f82f39\":{\"balance\":\"0xd8d726b7177a800000\"},\"478e524ef2a381d70c82588a93ca7a5fa9d51cbf\":{\"balance\":\"0x35fa97226f8899700000\"},\"479298a9de147e63a1c7d6d2fce089c7e64083bd\":{\"balance\":\"0x21e19dd3c3c0d798000\"},\"479abf2da4d58716fd973a0d13a75f530150260a\":{\"balance\":\"0x1158e460913d00000\"},\"47a281dff64167197855bf6e705eb9f2cef632ea\":{\"balance\":\"0x3636c9796436740000\"},\"47beb20f759100542aa93d41118b3211d664920e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"47c247f53b9fbeb17bba0703a00c009fdb0f6eae\":{\"balance\":\"0x43c33c1937564800000\"},\"47c7e5efb48b3aed4b7c6e824b435f357df4c723\":{\"balance\":\"0xfc936392801c0000\"},\"47cf9cdaf92fc999cc5efbb7203c61e4f1cdd4c3\":{\"balance\":\"0x71f8a93d01e540000\"},\"47d20e6ae4cad3f829eac07e5ac97b66fdd56cf5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"47d792a756779aedf1343e8883a6619c6c281184\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"47e25df8822538a8596b28c637896b4d143c351d\":{\"balance\":\"0x110be9eb24b881500000\"},\"47f4696bd462b20da09fb83ed2039818d77625b3\":{\"balance\":\"0x813ca56906d340000\"},\"47fef58584465248a0810d60463ee93e5a6ee8d3\":{\"balance\":\"0xf58cd3e1269160000\"},\"47ff6feb43212060bb1503d7a397fc08f4e70352\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"47fff42c678551d141eb75a6ee398117df3e4a8d\":{\"balance\":\"0x56beae51fd2d10000\"},\"48010ef3b8e95e3f308f30a8cb7f4eb4bf60d965\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"480af52076009ca73781b70e43b95916a62203ab\":{\"balance\":\"0x321972f4083d878000\"},\"480f31b989311e4124c6a7465f5a44094d36f9d0\":{\"balance\":\"0x3790bb855137640000\"},\"481115296ab7db52492ff7b647d63329fb5cbc6b\":{\"balance\":\"0x368c8623a8b4d100000\"},\"481e3a91bfdc2f1c8428a0119d03a41601417e1c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4828e4cbe34e1510afb72c2beeac8a4513eaebd9\":{\"balance\":\"0xd5967be4fc3f100000\"},\"482982ac1f1c6d1721feecd9b9c96cd949805055\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"48302c311ef8e5dc664158dd583c81194d6e0d58\":{\"balance\":\"0xb6676ce0bccb5c0000\"},\"483ba99034e900e3aedf61499d3b2bce39beb7aa\":{\"balance\":\"0x35659ef93f0fc40000\"},\"48548b4ba62bcb2f0d34a88dc69a680e539cf046\":{\"balance\":\"0x56cf1cbbb74320000\"},\"4863849739265a63b0a2bf236a5913e6f959ce15\":{\"balance\":\"0x52663ccab1e1c00000\"},\"48659d8f8c9a2fd44f68daa55d23a608fbe500dc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"48669eb5a801d8b75fb6aa58c3451b7058c243bf\":{\"balance\":\"0x68d42c138dab9f00000\"},\"486a6c8583a84484e3df43a123837f8c7e2317d0\":{\"balance\":\"0x1187c571ab80450000\"},\"487adf7d70a6740f8d51cbdd68bb3f91c4a5ce68\":{\"balance\":\"0x39fbae8d042dd0000\"},\"487e108502b0b189ef9c8c6da4d0db6261eec6c0\":{\"balance\":\"0x678a932062e4180000\"},\"4888fb25cd50dbb9e048f41ca47d78b78a27c7d9\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"489334c2b695c8ee0794bd864217fb9fd8f8b135\":{\"balance\":\"0xfc936392801c0000\"},\"48a30de1c919d3fd3180e97d5f2b2a9dbd964d2d\":{\"balance\":\"0x2629f66e0c5300000\"},\"48bf14d7b1fc84ebf3c96be12f7bce01aa69b03e\":{\"balance\":\"0x68155a43676e00000\"},\"48c2ee91a50756d8ce9abeeb7589d22c6fee5dfb\":{\"balance\":\"0xae8e7a0bb575d00000\"},\"48c5c6970b9161bb1c7b7adfed9cdede8a1ba864\":{\"balance\":\"0xd8d726b7177a800000\"},\"48d2434b7a7dbbff08223b6387b05da2e5093126\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"48d4f2468f963fd79a006198bb67895d2d5aa4d3\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"48e0cbd67f18acdb7a6291e1254db32e0972737f\":{\"balance\":\"0x56be03ca3e47d8000\"},\"48f60a35484fe7792bcc8a7b6393d0dda1f6b717\":{\"balance\":\"0xc328093e61ee400000\"},\"48f883e567b436a27bb5a3124dbc84dec775a800\":{\"balance\":\"0x29d76e869dcd800000\"},\"490145afa8b54522bb21f352f06da5a788fa8f1d\":{\"balance\":\"0x1f46c62901a03fb0000\"},\"4909b31998ead414b8fb0e846bd5cbde393935be\":{\"balance\":\"0xd8d726b7177a800000\"},\"4912d902931676ff39fc34fe3c3cc8fb2182fa7a\":{\"balance\":\"0x1158e460913d00000\"},\"49136fe6e28b7453fcb16b6bbbe9aaacba8337fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"491561db8b6fafb9007e62d050c282e92c4b6bc8\":{\"balance\":\"0x65a4da25d3016c00000\"},\"49185dd7c23632f46c759473ebae966008cd3598\":{\"balance\":\"0xdc55fdb17647b0000\"},\"492cb5f861b187f9df21cd4485bed90b50ffe22d\":{\"balance\":\"0x1b19e50b44977c0000\"},\"492de46aaf8f1d708d59d79af1d03ad2cb60902f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"492e70f04d18408cb41e25603730506b35a2876b\":{\"balance\":\"0x222c8eb3ff6640000\"},\"493a67fe23decc63b10dda75f3287695a81bd5ab\":{\"balance\":\"0x2fb474098f67c00000\"},\"493d48bda015a9bfcf1603936eab68024ce551e0\":{\"balance\":\"0x138a388a43c000000\"},\"494256e99b0f9cd6e5ebca3899863252900165c8\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"494dec4d5ee88a2771a815f1ee7264942fb58b28\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"495b641b1cdea362c3b4cbbd0f5cc50b1e176b9c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4968a2cedb457555a139295aea28776e54003c87\":{\"balance\":\"0x2231aefc9a6628f0000\"},\"496d365534530a5fc1577c0a5241cb88c4da7072\":{\"balance\":\"0x61093d7c2c6d380000\"},\"496e319592b341eaccd778dda7c8196d54cac775\":{\"balance\":\"0x1f5718987664b480000\"},\"496f5843f6d24cd98d255e4c23d1e1f023227545\":{\"balance\":\"0x5f179fd4a6ee098000\"},\"4970d3acf72b5b1f32a7003cf102c64ee0547941\":{\"balance\":\"0x1da56a4b0835bf800000\"},\"4977a7939d0939689455ce2639d0ee5a4cd910ed\":{\"balance\":\"0x62a992e53a0af00000\"},\"4979194ec9e97db9bee8343b7c77d9d7f3f1dc9f\":{\"balance\":\"0x1158e460913d00000\"},\"49793463e1681083d6abd6e725d5bba745dccde8\":{\"balance\":\"0x1d98e94c4e471f0000\"},\"4981c5ff66cc4e9680251fc4cd2ff907cb327865\":{\"balance\":\"0x28a857425466f80000\"},\"49897fe932bbb3154c95d3bce6d93b6d732904dd\":{\"balance\":\"0xd8d726b7177a800000\"},\"4989e1ab5e7cd00746b3938ef0f0d064a2025ba5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"498abdeb14c26b7b7234d70fceaef361a76dff72\":{\"balance\":\"0xa2a15d09519be00000\"},\"49a645e0667dfd7b32d075cc2467dd8c680907c4\":{\"balance\":\"0x70601958fcb9c0000\"},\"49b74e169265f01a89ec4c9072c5a4cd72e4e835\":{\"balance\":\"0x368c8623a8b4d100000\"},\"49bdbc7ba5abebb6389e91a3285220d3451bd253\":{\"balance\":\"0x3635c9adc5dea00000\"},\"49c941e0e5018726b7290fc473b471d41dae80d1\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"49c9771fca19d5b9d245c891f8158fe49f47a062\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"49cf1e54be363106b920729d2d0ba46f0867989a\":{\"balance\":\"0xe873f44133cb00000\"},\"49d2c28ee9bc545eaaf7fd14c27c4073b4bb5f1a\":{\"balance\":\"0x4fe9b806b40daf0000\"},\"49ddee902e1d0c99d1b11af3cc8a96f78e4dcf1a\":{\"balance\":\"0xacea5e4c18c530000\"},\"49f028395b5a86c9e07f7778630e4c2e3d373a77\":{\"balance\":\"0x6a74a5038db918000\"},\"4a192035e2619b24b0709d56590e9183ccf2c1d9\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4a4053b31d0ee5dbafb1d06bd7ac7ff3222c47d6\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"4a430170152de5172633dd8262d107a0afd96a0f\":{\"balance\":\"0xab4dcf399a3a600000\"},\"4a47fc3e177f567a1e3893e000e36bba23520ab8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4a52bad20357228faa1e996bed790c93674ba7d0\":{\"balance\":\"0x487a9a304539440000\"},\"4a53dcdb56ce4cdce9f82ec0eb13d67352e7c88b\":{\"balance\":\"0xe3aeb5737240a00000\"},\"4a5fae3b0372c230c125d6d470140337ab915656\":{\"balance\":\"0x56bc75e2d631000000\"},\"4a719061f5285495b37b9d7ef8a51b07d6e6acac\":{\"balance\":\"0xad4c8316a0b0c0000\"},\"4a73389298031b8816cca946421c199e18b343d6\":{\"balance\":\"0x223868b879146f0000\"},\"4a735d224792376d331367c093d31c8794341582\":{\"balance\":\"0x66ffcbfd5e5a300000\"},\"4a7494cce44855cc80582842be958a0d1c0072ee\":{\"balance\":\"0x821ab0d44149800000\"},\"4a75c3d4fa6fccbd5dd5a703c15379a1e783e9b7\":{\"balance\":\"0x62a992e53a0af00000\"},\"4a81abe4984c7c6bef63d69820e55743c61f201c\":{\"balance\":\"0x36401004e9aa3470000\"},\"4a82694fa29d9e213202a1a209285df6e745c209\":{\"balance\":\"0xd8d726b7177a800000\"},\"4a835c25824c47ecbfc79439bf3f5c3481aa75cd\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"4a918032439159bb315b6725b6830dc83697739f\":{\"balance\":\"0x12a32ef678334c0000\"},\"4a97e8fcf4635ea7fc5e96ee51752ec388716b60\":{\"balance\":\"0x1d9945ab2b03480000\"},\"4a9a26fd0a8ba10f977da4f77c31908dab4a8016\":{\"balance\":\"0x61093d7c2c6d380000\"},\"4aa148c2c33401e66a2b586e6577c4b292d3f240\":{\"balance\":\"0xbb860b285f7740000\"},\"4aa693b122f314482a47b11cc77c68a497876162\":{\"balance\":\"0x6acb3df27e1f880000\"},\"4ab2d34f04834fbf7479649cab923d2c4725c553\":{\"balance\":\"0xbed1d0263d9f000000\"},\"4ac07673e42f64c1a25ec2fa2d86e5aa2b34e039\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4ac5acad000b8877214cb1ae00eac9a37d59a0fd\":{\"balance\":\"0xd8d726b7177a800000\"},\"4ac9905a4cb6ab1cfd62546ee5917300b87c4fde\":{\"balance\":\"0x3708baed3d68900000\"},\"4acfa9d94eda6625c9dfa5f9f4f5d107c4031fdf\":{\"balance\":\"0x222c8eb3ff6640000\"},\"4ad047fae67ef162fe68fedbc27d3b65caf10c36\":{\"balance\":\"0x6acb3df27e1f880000\"},\"4ad95d188d6464709add2555fb4d97fe1ebf311f\":{\"balance\":\"0x12c1b6eed03d280000\"},\"4adbf4aae0e3ef44f7dd4d8985cfaf096ec48e98\":{\"balance\":\"0x821ab0d4414980000\"},\"4ae2a04d3909ef454e544ccfd614bfefa71089ae\":{\"balance\":\"0x1801159df1eef80000\"},\"4ae93082e45187c26160e66792f57fad3551c73a\":{\"balance\":\"0x4961520daff82280000\"},\"4af0db077bb9ba5e443e21e148e59f379105c592\":{\"balance\":\"0x2086ac351052600000\"},\"4b0619d9d8aa313a9531ac7dbe04ca0d6a5ad1b6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4b0bd8acfcbc53a6010b40d4d08ddd2d9d69622d\":{\"balance\":\"0x243d4d18229ca20000\"},\"4b19eb0c354bc1393960eb06063b83926f0d67b2\":{\"balance\":\"0x19274b259f6540000\"},\"4b29437c97b4a844be71cca3b648d4ca0fdd9ba4\":{\"balance\":\"0x824719834cfac0000\"},\"4b31bf41abc75c9ae2cd8f7f35163b6e2b745054\":{\"balance\":\"0x14b550a013c7380000\"},\"4b3a7cc3a7d7b00ed5282221a60259f25bf6538a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4b3aab335ebbfaa870cc4d605e7d2e74c668369f\":{\"balance\":\"0xcb49b44ba602d800000\"},\"4b3c7388cc76da3d62d40067dabccd7ef0433d23\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"4b3dfbdb454be5279a3b8addfd0ed1cd37a9420d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4b470f7ba030bc7cfcf338d4bf0432a91e2ea5ff\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4b53ae59c784b6b5c43616b9a0809558e684e10c\":{\"balance\":\"0x410d586a20a4c00000\"},\"4b58101f44f7e389e12d471d1635b71614fdd605\":{\"balance\":\"0x8ac7230489e800000\"},\"4b5cdb1e428c91dd7cb54a6aed4571da054bfe52\":{\"balance\":\"0x4c53ecdc18a600000\"},\"4b60a3e253bf38c8d5662010bb93a473c965c3e5\":{\"balance\":\"0x50c5e761a444080000\"},\"4b74f5e58e2edf76daf70151964a0b8f1de0663c\":{\"balance\":\"0x1190ae4944ba120000\"},\"4b762166dd1118e84369f804c75f9cd657bf730c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"4b792e29683eb586e394bb33526c6001b397999e\":{\"balance\":\"0x2086ac351052600000\"},\"4b904e934bd0cc8b20705f879e905b93ea0ccc30\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4b9206ba6b549a1a7f969e1d5dba867539d1fa67\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"4b984ef26c576e815a2eaed2f5177f07dbb1c476\":{\"balance\":\"0x54915956c409600000\"},\"4b9e068fc4680976e61504912985fd5ce94bab0d\":{\"balance\":\"0x243d4d18229ca20000\"},\"4ba0d9e89601772b496847a2bb4340186787d265\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4ba53ab549e2016dfa223c9ed5a38fad91288d07\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"4ba8e0117fc0b6a3e56b24a3a58fe6cef442ff98\":{\"balance\":\"0x131beb925ffd3200000\"},\"4bac846af4169f1d95431b341d8800b22180af1a\":{\"balance\":\"0x1158e460913d00000\"},\"4bb6d86b8314c22d8d37ea516d0019f156aae12d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4bb9655cfb2a36ea7c637a7b859b4a3154e26ebe\":{\"balance\":\"0x3635c9adc5dea000000\"},\"4bbcbf38b3c90163a84b1cd2a93b58b2a3348d87\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"4bd6dd0cff23400e1730ba7b894504577d14e74a\":{\"balance\":\"0x2ba0ccddd0df73b00000\"},\"4be8628a8154874e048d80c142181022b180bcc1\":{\"balance\":\"0x340aad21b3b700000\"},\"4be90d412129d5a4d0424361d6649d4e47a62316\":{\"balance\":\"0x3708baed3d68900000\"},\"4bea288eea42c4955eb9faad2a9faf4783cbddac\":{\"balance\":\"0x618be1663c4af490000\"},\"4bf4479799ef82eea20943374f56a1bf54001e5e\":{\"balance\":\"0xd5967be4fc3f100000\"},\"4bf8bf1d35a231315764fc8001809a949294fc49\":{\"balance\":\"0x39fbae8d042dd0000\"},\"4bf8e26f4c2790da6533a2ac9abac3c69a199433\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4c0aca508b3caf5ee028bc707dd1e800b838f453\":{\"balance\":\"0xfc936392801c0000\"},\"4c0b1515dfced7a13e13ee12c0f523ae504f032b\":{\"balance\":\"0xa968163f0a57b400000\"},\"4c13980c32dcf3920b78a4a7903312907c1b123f\":{\"balance\":\"0x3410015faae0c0000\"},\"4c1579af3312e4f88ae93c68e9449c2e9a68d9c4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4c23b370fc992bb67cec06e26715b62f0b3a4ac3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4c24b78baf2bafc7fcc69016426be973e20a50b2\":{\"balance\":\"0xa2a15d09519be00000\"},\"4c2f1afef7c5868c44832fc77cb03b55f89e6d6e\":{\"balance\":\"0x43c33c1937564800000\"},\"4c377bb03ab52c4cb79befa1dd114982924c4ae9\":{\"balance\":\"0x631603ccd38dd70000\"},\"4c3e95cc3957d252ce0bf0c87d5b4f2234672e70\":{\"balance\":\"0x878678326eac900000\"},\"4c423c76930d07f93c47a5cc4f615745c45a9d72\":{\"balance\":\"0x56bc75e2d63100000\"},\"4c45d4c9a725d11112bfcbca00bf31186ccaadb7\":{\"balance\":\"0x15af1d78b58c400000\"},\"4c4e6f13fb5e3f70c3760262a03e317982691d10\":{\"balance\":\"0x56bc75e2d63100000\"},\"4c5afe40f18ffc48d3a1aec41fc29de179f4d297\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4c5b3dc0e2b9360f91289b1fe13ce12c0fbda3e1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4c666b86f1c5ee8ca41285f5bde4f79052081406\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"4c696be99f3a690440c3436a59a7d7e937d6ba0d\":{\"balance\":\"0xbb9125542263900000\"},\"4c6a248fc97d705def495ca20759169ef0d36471\":{\"balance\":\"0x29331e6558f0e00000\"},\"4c6a9dc2cab10abb2e7c137006f08fecb5b779e1\":{\"balance\":\"0x1b0d04202f47ec0000\"},\"4c6b93a3bec16349540cbfcae96c9621d6645010\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4c759813ad1386bed27ffae9e4815e3630cca312\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4c760cd9e195ee4f2d6bce2500ff96da7c43ee91\":{\"balance\":\"0xcb49b44ba602d800000\"},\"4c767b65fd91161f4fbdcc6a69e2f6ad711bb918\":{\"balance\":\"0x270801d946c9400000\"},\"4c7e2e2b77ad0cd6f44acb2861f0fb8b28750ef9\":{\"balance\":\"0x1158e460913d00000\"},\"4c85ed362f24f6b9f04cdfccd022ae535147cbb9\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"4c935bb250778b3c4c7f7e07fc251fa630314aab\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"4c997992036c5b433ac33d25a8ea1dc3d4e4e6d8\":{\"balance\":\"0x1953b3d4ab1680000\"},\"4c99dae96481e807c1f99f8b7fbde29b7547c5bf\":{\"balance\":\"0x821ab0d4414980000\"},\"4c9a862ad115d6c8274ed0b944bdd6a5500510a7\":{\"balance\":\"0x56bc75e2d63100000\"},\"4ca783b556e5bf53aa13c8116613d65782c9b642\":{\"balance\":\"0x5561840b4ad83c00000\"},\"4ca7b717d9bc8793b04e051a8d23e1640f5ba5e3\":{\"balance\":\"0x43b514549ecf620000\"},\"4ca8db4a5efefc80f4cd9bbcccb03265931332b6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4cac91fb83a147d2f76c3267984b910a79933348\":{\"balance\":\"0x75792a8abdef7c0000\"},\"4cadf573ce4ceec78b8e1b21b0ed78eb113b2c0e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4cb5c6cd713ca447b848ae2f56b761ca14d7ad57\":{\"balance\":\"0xe7eeba3410b740000\"},\"4cc22c9bc9ad05d875a397dbe847ed221c920c67\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4cd0b0a6436362595ceade052ebc9b929fb6c6c0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4cda41dd533991290794e22ae324143e309b3d3d\":{\"balance\":\"0x821ab0d44149800000\"},\"4cee901b4ac8b156c5e2f8a6f1bef572a7dceb7e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4cefbe2398e47d52e78db4334c8b697675f193ae\":{\"balance\":\"0xd96fce90cfabcc0000\"},\"4cf5537b85842f89cfee359eae500fc449d2118f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4d08471d68007aff2ae279bc5e3fe4156fbbe3de\":{\"balance\":\"0x878678326eac9000000\"},\"4d200110124008d56f76981256420c946a6ff45c\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"4d24b7ac47d2f27de90974ba3de5ead203544bcd\":{\"balance\":\"0x56bc75e2d63100000\"},\"4d29fc523a2c1629532121da9998e9b5ab9d1b45\":{\"balance\":\"0xdb44e049bb2c0000\"},\"4d38d90f83f4515c03cc78326a154d358bd882b7\":{\"balance\":\"0xa076407d3f7440000\"},\"4d4cf5807429615e30cdface1e5aae4dad3055e6\":{\"balance\":\"0x2086ac351052600000\"},\"4d57e716876c0c95ef5eaebd35c8f41b069b6bfe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4d67f2ab8599fef5fc413999aa01fd7fce70b43d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4d6e8fe109ccd2158e4db114132fe75fecc8be5b\":{\"balance\":\"0x15b3557f1937f8000\"},\"4d71a6eb3d7f327e1834278e280b039eddd31c2f\":{\"balance\":\"0x14542ba12a337c00000\"},\"4d7cfaa84cb33106800a8c802fb8aa463896c599\":{\"balance\":\"0x61093d7c2c6d380000\"},\"4d801093c19ca9b8f342e33cc9c77bbd4c8312cf\":{\"balance\":\"0x12b3e7fb95cda48000\"},\"4d828894752f6f25175daf2177094487954b6f9f\":{\"balance\":\"0x4f212bc2c49c838000\"},\"4d82d7700c123bb919419bbaf046799c6b0e2c66\":{\"balance\":\"0x43c33c1937564800000\"},\"4d836d9d3b0e2cbd4de050596faa490cffb60d5d\":{\"balance\":\"0x1043561a8829300000\"},\"4d8697af0fbf2ca36e8768f4af22133570685a60\":{\"balance\":\"0x1158e460913d00000\"},\"4d9279962029a8bd45639737e98b511eff074c21\":{\"balance\":\"0x487a9a304539440000\"},\"4d93696fa24859f5d2939aebfa54b4b51ae1dccc\":{\"balance\":\"0x10910d4cdc9f60000\"},\"4d9c77d0750c5e6fbc247f2fd79274686cb353d6\":{\"balance\":\"0x1158e460913d00000\"},\"4da5edc688b0cb62e1403d1700d9dcb99ffe3fd3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4da8030769844bc34186b85cd4c7348849ff49e9\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4db1c43a0f834d7d0478b8960767ec1ac44c9aeb\":{\"balance\":\"0x2f5181305627370000\"},\"4db21284bcd4f787a7556500d6d7d8f36623cf35\":{\"balance\":\"0x6928374f77a3630000\"},\"4dc3da13b2b4afd44f5d0d3189f444d4ddf91b1b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4dc4bf5e7589c47b28378d7503cf96488061dbbd\":{\"balance\":\"0x5f68e8131ecf800000\"},\"4dc9d5bb4b19cecd94f19ec25d200ea72f25d7ed\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4dcd11815818ae29b85d01367349a8a7fb12d06b\":{\"balance\":\"0x1ac4286100191f00000\"},\"4dcf62a3de3f061db91498fd61060f1f6398ff73\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"4dd131c74a068a37c90aded4f309c2409f6478d3\":{\"balance\":\"0x15af39e4aab2740000\"},\"4ddda7586b2237b053a7f3289cf460dc57d37a09\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4de3fe34a6fbf634c051997f47cc7f48791f5824\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"4df140ba796585dd5489315bca4bba680adbb818\":{\"balance\":\"0x90f534608a72880000\"},\"4e020779b5ddd3df228a00cb48c2fc979da6ae38\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4e0bd32473c4c51bf25654def69f797c6b29a232\":{\"balance\":\"0x56c95de8e8ca1d0000\"},\"4e2225a1bb59bc88a2316674d333b9b0afca6655\":{\"balance\":\"0x8670e9ec6598c0000\"},\"4e2310191ead8d3bc6489873a5f0c2ec6b87e1be\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4e232d53b3e6be8f895361d31c34d4762b12c82e\":{\"balance\":\"0x5f68e8131ecf800000\"},\"4e2bfa4a466f82671b800eee426ad00c071ba170\":{\"balance\":\"0xd8d726b7177a800000\"},\"4e3edad4864dab64cae4c5417a76774053dc6432\":{\"balance\":\"0x2008fb478cbfa98000\"},\"4e4318f5e13e824a54edfe30a7ed4f26cd3da504\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4e5b77f9066159e615933f2dda7477fa4e47d648\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4e6600806289454acda330a2a3556010dfacade6\":{\"balance\":\"0x14542ba12a337c00000\"},\"4e73cf2379f124860f73d6d91bf59acc5cfc845b\":{\"balance\":\"0x22ca3587cf4eb0000\"},\"4e7aa67e12183ef9d7468ea28ad239c2eef71b76\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"4e7b54474d01fefd388dfcd53b9f662624418a05\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"4e892e8081bf36e488fddb3b2630f3f1e8da30d2\":{\"balance\":\"0x28aba30752451fc0000\"},\"4e8a6d63489ccc10a57f885f96eb04ecbb546024\":{\"balance\":\"0x3eae3130ecc96900000\"},\"4e8e47ae3b1ef50c9d54a38e14208c1abd3603c2\":{\"balance\":\"0x7928db1276660c0000\"},\"4e90ccb13258acaa9f4febc0a34292f95991e230\":{\"balance\":\"0xdb44e049bb2c0000\"},\"4ea56e1112641c038d0565a9c296c463afefc17e\":{\"balance\":\"0x9ddc1e3b901180000\"},\"4ea70f04313fae65c3ff224a055c3d2dab28dddf\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"4eb1454b573805c8aca37edec7149a41f61202f4\":{\"balance\":\"0x1043561a8829300000\"},\"4eb87ba8788eba0df87e5b9bd50a8e45368091c1\":{\"balance\":\"0x1158e460913d00000\"},\"4ebc5629f9a6a66b2cf3363ac4895c0348e8bf87\":{\"balance\":\"0x3637096c4bcc690000\"},\"4ec768295eeabafc42958415e22be216cde77618\":{\"balance\":\"0x33b1dbc39c5480000\"},\"4ecc19948dd9cd87b4c7201ab48e758f28e7cc76\":{\"balance\":\"0x1b1dab61d3aa640000\"},\"4ed14d81b60b23fb25054d8925dfa573dcae6168\":{\"balance\":\"0x126e72a69a50d00000\"},\"4ee13c0d41200b46d19dee5c4bcec71d82bb8e38\":{\"balance\":\"0x1abee13ccbeefaf8000\"},\"4eead40aad8c73ef08fc84bc0a92c9092f6a36bf\":{\"balance\":\"0x1731790534df20000\"},\"4eebe80cb6f3ae5904f6f4b28d907f907189fcab\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"4eebf1205d0cc20cee6c7f8ff3115f56d48fba26\":{\"balance\":\"0x10d3aa536e2940000\"},\"4ef1c214633ad9c0703b4e2374a2e33e3e429291\":{\"balance\":\"0x487a9a304539440000\"},\"4efcd9c79fb4334ca6247b0a33bd9cc33208e272\":{\"balance\":\"0x487a9a304539440000\"},\"4f06246b8d4bd29661f43e93762201d286935ab1\":{\"balance\":\"0x105394ffc4636110000\"},\"4f152b2fb8659d43776ebb1e81673aa84169be96\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"4f177f9d56953ded71a5611f393322c30279895c\":{\"balance\":\"0xd55ef90a2da180000\"},\"4f1a2da54a4c6da19d142412e56e815741db2325\":{\"balance\":\"0x56bc75e2d63100000\"},\"4f23b6b817ffa5c664acdad79bb7b726d30af0f9\":{\"balance\":\"0x5f68e8131ecf800000\"},\"4f26690c992b7a312ab12e1385d94acd58288e7b\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"4f2b47e2775a1fa7178dad92985a5bbe493ba6d6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4f3a4854911145ea01c644044bdb2e5a960a982f\":{\"balance\":\"0xd8d726b7177a800000\"},\"4f3f2c673069ac97c2023607152981f5cd6063a0\":{\"balance\":\"0x2086ac351052600000\"},\"4f4a9be10cd5d3fb5de48c17be296f895690645b\":{\"balance\":\"0x878678326eac9000000\"},\"4f52ad6170d25b2a2e850eadbb52413ff2303e7f\":{\"balance\":\"0xa4cc799563c3800000\"},\"4f5801b1eb30b712d8a0575a9a71ff965d4f34eb\":{\"balance\":\"0x1043561a8829300000\"},\"4f5df5b94357de948604c51b7893cddf6076baad\":{\"balance\":\"0xcbd47b6eaa8cc00000\"},\"4f64a85e8e9a40498c0c75fceb0337fb49083e5e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4f67396d2553f998785f704e07a639197dd1948d\":{\"balance\":\"0x104472521ba7380000\"},\"4f6d4737d7a940382487264886697cf7637f8015\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"4f7330096f79ed264ee0127f5d30d2f73c52b3d8\":{\"balance\":\"0x1b1a7a420ba00d0000\"},\"4f767bc8794aef9a0a38fea5c81f14694ff21a13\":{\"balance\":\"0x1bc433f23f83140000\"},\"4f85bc1fc5cbc9c001e8f1372e07505370d8c71f\":{\"balance\":\"0x32f51edbaaa3300000\"},\"4f88dfd01091a45a9e2676021e64286cd36b8d34\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4f8972838f70c903c9b6c6c46162e99d6216d451\":{\"balance\":\"0xf9e89a0f2c56c80000\"},\"4f8ae80238e60008557075ab6afe0a7f2e74d729\":{\"balance\":\"0x56bc75e2d63100000\"},\"4f8e8d274fb22a3fd36a47fe72980471544b3434\":{\"balance\":\"0xad78ebc5ac6200000\"},\"4f9ce2af9b8c5e42c6808a3870ec576f313545d1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"4fa3f32ef4086448b344d5f0a9890d1ce4d617c3\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"4fa554ab955c249217386a4d3263bbf72895434e\":{\"balance\":\"0x1154e53217ddb0000\"},\"4fa983bb5e3073a8edb557effeb4f9fb1d60ef86\":{\"balance\":\"0x56b9af57e575ec0000\"},\"4faf90b76ecfb9631bf9022176032d8b2c207009\":{\"balance\":\"0x36363b5d9a77700000\"},\"4fc46c396e674869ad9481638f0013630c87caac\":{\"balance\":\"0x3635c9adc5dea00000\"},\"4fcc19ea9f4c57dcbce893193cfb166aa914edc5\":{\"balance\":\"0x17b8baa7f19546a0000\"},\"4fce8429ba49caa0369d1e494db57e89eab2ad39\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"4fdac1aa517007e0089430b3316a1badd12c01c7\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"4fe56ab3bae1b0a44433458333c4b05a248f8241\":{\"balance\":\"0x762d93d1dd6f900000\"},\"4feb846be43041fd6b34202897943e3f21cb7f04\":{\"balance\":\"0x482fe260cbca90000\"},\"4fee50c5f988206b09a573469fb1d0b42ebb6dce\":{\"balance\":\"0x6cee06ddbe15ec0000\"},\"4ff676e27f681a982d8fd9d20e648b3dce05e945\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"4ff67fb87f6efba9279930cfbd1b7a343c79fade\":{\"balance\":\"0x15af1d78b58c400000\"},\"5006fe4c22173980f00c74342b39cd231c653129\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"500c16352e901d48ba8d04e2c767121772790b02\":{\"balance\":\"0x1a3a6824973098000\"},\"500c902958f6421594d1b6ded712490d52ed6c44\":{\"balance\":\"0x6acb3df27e1f880000\"},\"500e34cde5bd9e2b71bb92d7cf55eee188d5fa0c\":{\"balance\":\"0x121ea68c114e5100000\"},\"5032e4bcf7932b49fdba377b6f1499636513cfc3\":{\"balance\":\"0x56bc75e2d63100000\"},\"50378af7ef54043f892ab7ce97d647793511b108\":{\"balance\":\"0x11164759ffb320000\"},\"503bdbd8bc421c32a443032deb2e3e4cd5ba8b4e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"504666ce8931175e11a5ed11c1dcaa06e57f4e66\":{\"balance\":\"0x27f3edfb34e6e400000\"},\"50584d9206a46ce15c301117ee28f15c30e60e75\":{\"balance\":\"0xb9f65d00f63c0000\"},\"505a33a18634dd4800693c67f48a1d693d4833f8\":{\"balance\":\"0x18921b79941dcd00000\"},\"505e4f7c275588c533a20ebd2ac13b409bbdea3c\":{\"balance\":\"0xf43fc2c04ee00000\"},\"5062e5134c612f12694dbd0e131d4ce197d1b6a4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"506411fd79003480f6f2b6aac26b7ba792f094b2\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5067f4549afbfe884c59cbc12b96934923d45db0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"50763add868fd7361178342fc055eaa2b95f6846\":{\"balance\":\"0x39f9046e0898f0000\"},\"508cf19119db70aa86454253da764a2cb1b2be1a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"509982f56237ee458951047e0a2230f804e2e895\":{\"balance\":\"0x3b4ad496106b7f00000\"},\"509a20bc48e72be1cdaf9569c711e8648d957334\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"509c8668036d143fb8ae70b11995631f3dfcad87\":{\"balance\":\"0x3635c9adc5dea00000\"},\"50ad187ab21167c2b6e78be0153f44504a07945e\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"50b9fef0a1329b02d16506255f5a2db71ec92d1f\":{\"balance\":\"0x47da821564085c0000\"},\"50bb67c8b8d8bd0f63c4760904f2d333f400aace\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"50bef2756248f9a7a380f91b051ba3be28a649ed\":{\"balance\":\"0x6c69f73e29134e0000\"},\"50ca86b5eb1d01874df8e5f34945d49c6c1ab848\":{\"balance\":\"0x3635c9adc5dea00000\"},\"50cd97e9378b5cf18f173963236c9951ef7438a5\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"50dcbc27bcad984093a212a9b4178eabe9017561\":{\"balance\":\"0x7e362790b5ca40000\"},\"50e13023bd9ca96ad4c53fdfd410cb6b1f420bdf\":{\"balance\":\"0xad78ebc5ac6200000\"},\"50e1c8ec98415bef442618708799437b86e6c205\":{\"balance\":\"0x14542ba12a337c00000\"},\"50f8fa4bb9e2677c990a4ee8ce70dd1523251e4f\":{\"balance\":\"0x1693d23164f6b0000\"},\"50fb36c27107ee2ca9a3236e2746cca19ace6b49\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"50fef296955588caae74c62ec32a23a454e09ab8\":{\"balance\":\"0x411dffabc507380000\"},\"5102a4a42077e11c58df4773e3ac944623a66d9f\":{\"balance\":\"0x6c7015fd52ed408000\"},\"51039377eed0c573f986c5e8a95fb99a59e9330f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5103bc09933e9921fd53dc536f11f05d0d47107d\":{\"balance\":\"0xd8d726b7177a800000\"},\"5104ecc0e330dd1f81b58ac9dbb1a9fbf88a3c85\":{\"balance\":\"0x152d02c7e14af6800000\"},\"510d8159cc945768c7450790ba073ec0d9f89e30\":{\"balance\":\"0x8ac7230489e8000000\"},\"510eda5601499a0d5e1a006bfffd833672f2e267\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"51126446ab3d8032557e8eba65597d75fadc815c\":{\"balance\":\"0x1174a5cdf88bc80000\"},\"5118557d600d05c2fcbf3806ffbd93d02025d730\":{\"balance\":\"0x267d3ab6423f5800000\"},\"511e0efb04ac4e3ff2e6550e498295bfcd56ffd5\":{\"balance\":\"0x243d4d18229ca20000\"},\"512116817ba9aaf843d1507c65a5ea640a7b9eec\":{\"balance\":\"0x2b5e3af16b1880000\"},\"5126460d692c71c9af6f05574d93998368a23799\":{\"balance\":\"0x2d1a51c7e00500000\"},\"51277fe7c81eebd252a03df69a6b9f326e272207\":{\"balance\":\"0x3402e79cab44c8000\"},\"51296f5044270d17707646129c86aad1645eadc1\":{\"balance\":\"0x487c72b310d4648000\"},\"512b91bbfaa9e581ef683fc90d9db22a8f49f48b\":{\"balance\":\"0x41a522386d9b95c00000\"},\"5135fb8757600cf474546252f74dc0746d06262c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"514632efbd642c04de6ca342315d40dd90a2dba6\":{\"balance\":\"0x90f534608a72880000\"},\"514b7512c9ae5ea63cbf11715b63f21e18d296c1\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"5153a0c3c8912881bf1c3501bf64b45649e48222\":{\"balance\":\"0xd8d726b7177a800000\"},\"515651d6db4faf9ecd103a921bbbbe6ae970fdd4\":{\"balance\":\"0x43c33c1937564800000\"},\"515f30bc90cdf4577ee47d65d785fbe2e837c6bc\":{\"balance\":\"0x2271b5e018ba0580000\"},\"5160ed612e1b48e73f3fc15bc4321b8f23b8a24b\":{\"balance\":\"0x1e826b422865d80000\"},\"5161fd49e847f67455f1c8bb7abb36e985260d03\":{\"balance\":\"0x410d586a20a4c00000\"},\"516954025fca2608f47da81c215eedfd844a09ff\":{\"balance\":\"0x14b550a013c7380000\"},\"5169c60aee4ceed1849ab36d664cff97061e8ea8\":{\"balance\":\"0xa2a15d09519be00000\"},\"517c75430de401c341032686112790f46d4d369e\":{\"balance\":\"0x150894e849b3900000\"},\"517cd7608e5d0d83a26b717f3603dac2277dc3a4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"51865db148881951f51251710e82b9be0d7eadb2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"51891b2ccdd2f5a44b2a8bc49a5d9bca6477251c\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"518cef27b10582b6d14f69483ddaa0dd3c87bb5c\":{\"balance\":\"0x2086ac351052600000\"},\"51a6d627f66a8923d88d6094c4715380d3057cb6\":{\"balance\":\"0x3e73d27a35941e0000\"},\"51a8c2163602a32ee24cf4aa97fd9ea414516941\":{\"balance\":\"0x368f7e6b8672c0000\"},\"51b4758e9e1450e7af4268c3c7b1e7bd6f5c7550\":{\"balance\":\"0x3635c9adc5dea00000\"},\"51ca8bd4dc644fac47af675563d5804a0da21eeb\":{\"balance\":\"0x2ab7b260ff3fd00000\"},\"51d24bc3736f88dd63b7222026886630b6eb878d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"51d78b178d707e396e8710965c4f41b1a1d9179d\":{\"balance\":\"0x5fee222041e340000\"},\"51e32f14f4ca5e287cdac057a7795ea9e0439953\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"51e43fe0d25c782860af81ea89dd793c13f0cbb1\":{\"balance\":\"0x340aad21b3b700000\"},\"51e7b55c2f9820eed73884361b5066a59b6f45c6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"51ea1c0934e3d04022ed9c95a087a150ef705e81\":{\"balance\":\"0x1547081e7224d200000\"},\"51ee0cca3bcb10cd3e983722ced8493d926c0866\":{\"balance\":\"0x36356633ebd8ea0000\"},\"51f4663ab44ff79345f427a0f6f8a6c8a53ff234\":{\"balance\":\"0x43c33c1937564800000\"},\"51f55ef47e6456a418ab32b9221ed27dba6608ee\":{\"balance\":\"0xe3aeb5737240a00000\"},\"51f9c432a4e59ac86282d6adab4c2eb8919160eb\":{\"balance\":\"0x703b5b89c3a6e7400000\"},\"520f66a0e2657ff0ac4195f2f064cf2fa4b24250\":{\"balance\":\"0x22b1c8c1227a00000\"},\"52102354a6aca95d8a2e86d5debda6de69346076\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5213f459e078ad3ab95a0920239fcf1633dc04ca\":{\"balance\":\"0x8cf2187c2afb188000\"},\"5215183b8f80a9bc03d26ce91207832a0d39e620\":{\"balance\":\"0x3635c9adc5dea00000\"},\"52214378b54004056a7cc08c891327798ac6b248\":{\"balance\":\"0x337fe5feaf2d1800000\"},\"522323aad71dbc96d85af90f084b99c3f09decb7\":{\"balance\":\"0x14542ba12a337c00000\"},\"523e140dc811b186dee5d6c88bf68e90b8e096fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"523f6d64690fdacd942853591bb0ff20d3656d95\":{\"balance\":\"0x62a992e53a0af00000\"},\"524fb210522c5e23bb67dfbf8c26aa616da49955\":{\"balance\":\"0x363562a66d34238000\"},\"5255dc69155a45b970c604d30047e2f530690e7f\":{\"balance\":\"0x1158e460913d00000\"},\"5260dc51ee07bddaababb9ee744b393c7f4793a6\":{\"balance\":\"0x1d8665fa5fa4c0000\"},\"5267f4d41292f370863c90d793296903843625c7\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"526bb533b76e20c8ee1ebf123f1e9ff4148e40be\":{\"balance\":\"0xaadec983fcff40000\"},\"526cb09ce3ada3672eec1deb46205be89a4b563e\":{\"balance\":\"0x85ca615bf9c0100000\"},\"52738c90d860e04cb12f498d96fdb5bf36fc340e\":{\"balance\":\"0x1a055690d9db80000\"},\"527a8ca1268633a6c939c5de1b929aee92aeac8d\":{\"balance\":\"0x30ca024f987b900000\"},\"528101ce46b720a2214dcdae6618a53177ffa377\":{\"balance\":\"0x1b9612b9dc01ae0000\"},\"5281733473e00d87f11e9955e589b59f4ac28e7a\":{\"balance\":\"0x8bd62ff4eec559200000\"},\"5298ab182a19359ffcecafd7d1b5fa212dede6dd\":{\"balance\":\"0x1158e460913d00000\"},\"529aa002c6962a3a8545027fd8b05f22b5bf9564\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"529e824fa072582b4032683ac7eecc1c04b4cac1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"52a5e4de4393eeccf0581ac11b52c683c76ea15d\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"52b4257cf41b6e28878d50d57b99914ffa89873a\":{\"balance\":\"0xd50dc9aa2c41770000\"},\"52b8a9592634f7300b7c5c59a3345b835f01b95c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"52bdd9af5978850bc24110718b3723759b437e59\":{\"balance\":\"0x5dc892aa1131c80000\"},\"52cd20403ba7eda6bc307a3d63b5911b817c1263\":{\"balance\":\"0x1158e460913d00000\"},\"52d380511df19d5ec2807bbcb676581b67fd37a3\":{\"balance\":\"0xb9f65d00f63c0000\"},\"52e1731350f983cc2c4189842fde0613fad50ce1\":{\"balance\":\"0x277017338a30ae00000\"},\"52e46783329a769301b175009d346768f4c87ee4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"52f058d46147e9006d29bf2c09304ad1cddd6e15\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"52f15423323c24f19ae2ab673717229d3f747d9b\":{\"balance\":\"0x37a034cbe8e3f38000\"},\"52f8b509fee1a874ab6f9d87367fbeaf15ac137f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"52fb46ac5d00c3518b2c3a1c177d442f8165555f\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"530077c9f7b907ff9cec0c77a41a70e9029add4a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"530319db0a8f93e5bb7d4dbf4816314fbed8361b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"53047dc8ac9083d90672e8b3473c100ccd278323\":{\"balance\":\"0x22b1c8c1227a00000\"},\"530b61e42f39426d2408d40852b9e34ab5ebebc5\":{\"balance\":\"0xe7eeba3410b740000\"},\"530ffac3bc3412e2ec0ea47b7981c770f5bb2f35\":{\"balance\":\"0x73f75d1a085ba0000\"},\"5317ecb023052ca7f5652be2fa854cfe4563df4d\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"53194d8afa3e883502767edbc30586af33b114d3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"532a7da0a5ad7407468d3be8e07e69c7dd64e861\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"532d32b00f305bcc24dcef56817d622f34fb2c24\":{\"balance\":\"0x6194049f30f7200000\"},\"533444584082eba654e1ad30e149735c6f7ba922\":{\"balance\":\"0x5dc892aa1131c80000\"},\"5338ef70eac9dd9af5a0503b5efad1039e67e725\":{\"balance\":\"0x90f534608a72880000\"},\"53396f4a26c2b4604496306c5442e7fcba272e36\":{\"balance\":\"0x43f2f08d40e5afc0000\"},\"533a73a4a2228eee05c4ffd718bbf3f9c1b129a7\":{\"balance\":\"0x14542ba12a337c00000\"},\"533c06928f19d0a956cc28866bf6c8d8f4191a94\":{\"balance\":\"0xfd8c14338e6300000\"},\"534065361cb854fac42bfb5c9fcde0604ac919da\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"53437fecf34ab9d435f4deb8ca181519e2592035\":{\"balance\":\"0xa31062beeed700000\"},\"535201a0a1d73422801f55ded4dfaee4fbaa6e3b\":{\"balance\":\"0x226211f7915428000\"},\"53608105ce4b9e11f86bf497ffca3b78967b5f96\":{\"balance\":\"0x43c33c1937564800000\"},\"536e4d8029b73f5579dca33e70b24eba89e11d7e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"53700d53254d430f22781a4a76a463933b5d6b08\":{\"balance\":\"0x6acb3df27e1f880000\"},\"537f9d4d31ef70839d84b0d9cdb72b9afedbdf35\":{\"balance\":\"0xed2b525841adfc00000\"},\"5381448503c0c702542b1de7cc5fb5f6ab1cf6a5\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"53942e7949d6788bb780a7e8a0792781b1614b84\":{\"balance\":\"0x35deb46684f10c80000\"},\"5395a4455d95d178b4532aa4725b193ffe512961\":{\"balance\":\"0x3635c9adc5dea00000\"},\"53989ed330563fd57dfec9bd343c3760b0799390\":{\"balance\":\"0x150894e849b39000000\"},\"53a244672895480f4a2b1cdf7da5e5a242ec4dbc\":{\"balance\":\"0x3635c9adc5dea00000\"},\"53a714f99fa00fef758e23a2e746326dad247ca7\":{\"balance\":\"0x50c5e761a444080000\"},\"53af32c22fef99803f178cf90b802fb571c61cb9\":{\"balance\":\"0xd255d112e103a00000\"},\"53c0bb7fc88ea422d2ef7e540e2d8f28b1bb8183\":{\"balance\":\"0x1158e460913d00000\"},\"53c5fe0119e1e848640cee30adea96940f2a5d8b\":{\"balance\":\"0x49ada5fa8c10c880000\"},\"53c9eca40973f63bb5927be0bc6a8a8be1951f74\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"53ce88e66c5af2f29bbd8f592a56a3d15f206c32\":{\"balance\":\"0x7a28c31cc36040000\"},\"53cec6c88092f756efe56f7db11228a2db45b122\":{\"balance\":\"0xd8d726b7177a800000\"},\"53e35b12231f19c3fd774c88fec8cbeedf1408b2\":{\"balance\":\"0x1bc16d674ec8000000\"},\"53e4d9696dcb3f4d7b3f70dcaa4eecb71782ff5c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"53faf165be031ec18330d9fce5bd1281a1af08db\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"540a1819bd7c35861e791804e5fbb3bc97c9abb1\":{\"balance\":\"0x4ed7dac64230200000\"},\"540c072802014ef0d561345aec481e8e11cb3570\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"540cf23dd95c4d558a279d778d2b3735b3164191\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"541060fc58c750c40512f83369c0a63340c122b6\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5413c97ffa4a6e2a7bba8961dc9fce8530a787d7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"541db20a80cf3b17f1621f1b3ff79b882f50def3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"542e8096bafb88162606002e8c8a3ed19814aeac\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"54310b3aa88703a725dfa57de6e646935164802c\":{\"balance\":\"0x678a932062e4180000\"},\"5431b1d18751b98fc9e2888ac7759f1535a2db47\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5431ca427e6165a644bae326bd09750a178c650d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5435c6c1793317d32ce13bba4c4ffeb973b78adc\":{\"balance\":\"0xd8e6b1c1285ef0000\"},\"543629c95cdef428ad37d453ca9538a9f90900ac\":{\"balance\":\"0x92896529baddc880000\"},\"54391b4d176d476cea164e5fb535c69700cb2535\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"543a8c0efb8bcd15c543e2a6a4f807597631adef\":{\"balance\":\"0x13f80e7e14f2d440000\"},\"543f8c674e2462d8d5daa0e80195a8708e11a29e\":{\"balance\":\"0x37758833b3a7a0000\"},\"544b5b351d1bc82e9297439948cf4861dac9ae11\":{\"balance\":\"0x4a89f54ef0121c00000\"},\"544dda421dc1eb73bb24e3e56a248013b87c0f44\":{\"balance\":\"0x6acb3df27e1f880000\"},\"54575c3114751e3c631971da6a2a02fd3ffbfcc8\":{\"balance\":\"0x692ae8897081d00000\"},\"545bb070e781172eb1608af7fc2895d6cb87197e\":{\"balance\":\"0x79a5c17ec748900000\"},\"5475d7f174bdb1f789017c7c1705989646079d49\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"548558d08cfcb101181dac1eb6094b4e1a896fa6\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"54939ff08921b467cf2946751d856378296c63ed\":{\"balance\":\"0x3635c9adc5dea00000\"},\"549b47649cfad993e4064d2636a4baa0623305cc\":{\"balance\":\"0x209d922f5259c50000\"},\"549d51af29f724c967f59423b85b2681e7b15136\":{\"balance\":\"0xcbd47b6eaa8cc00000\"},\"54a1370116fe22099e015d07cd2669dd291cc9d1\":{\"balance\":\"0x1158e460913d00000\"},\"54a62bf9233e146ffec3876e45f20ee8414adeba\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"54b4429b182f0377be7e626939c5db6440f75d7a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"54bcb8e7f73cda3d73f4d38b2d0847e600ba0df8\":{\"balance\":\"0x3a70415882df180000\"},\"54c93e03a9b2e8e4c3672835a9ee76f9615bc14e\":{\"balance\":\"0x10d3aa536e2940000\"},\"54ce88275956def5f9458e3b95decacd484021a0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"54db5e06b4815d31cb56a8719ba33af2d73e7252\":{\"balance\":\"0x24521e2a3017b80000\"},\"54e01283cc8b384538dd646770b357c960d6cacd\":{\"balance\":\"0x10f0cf064dd59200000\"},\"54ec7300b81ac84333ed1b033cd5d7a33972e234\":{\"balance\":\"0xad78ebc5ac6200000\"},\"54febcce20fe7a9098a755bd90988602a48c089e\":{\"balance\":\"0x22b1c8c1227a000000\"},\"550aadae1221b07afea39fba2ed62e05e5b7b5f9\":{\"balance\":\"0x1158e460913d00000\"},\"550c306f81ef5d9580c06cb1ab201b95c748a691\":{\"balance\":\"0x2417d4c470bf140000\"},\"551999ddd205563327b9b530785acff9bc73a4ba\":{\"balance\":\"0x14542ba12a337c00000\"},\"551e7784778ef8e048e495df49f2614f84a4f1dc\":{\"balance\":\"0x2086ac351052600000\"},\"5529830a61c1f13c197e550beddfd6bd195c9d02\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"552987f0651b915b2e1e5328c121960d4bdd6af4\":{\"balance\":\"0x61093d7c2c6d380000\"},\"553b6b1c57050e88cf0c31067b8d4cd1ff80cb09\":{\"balance\":\"0x15af1d78b58c400000\"},\"553f37d92466550e9fd775ae74362df030179132\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"554336ee4ea155f9f24f87bca9ca72e253e12cd2\":{\"balance\":\"0x56bc75e2d63100000\"},\"5543dd6d169eec8a213bbf7a8af9ffd15d4ff759\":{\"balance\":\"0xfc936392801c0000\"},\"5547fdb4ae11953e01292b7807fa9223d0e4606a\":{\"balance\":\"0x55d117dcb1d260000\"},\"5552f4b3ed3e1da79a2f78bb13e8ae5a68a9df3b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"555ca9f05cc134ab54ae9bea1c3ff87aa85198ca\":{\"balance\":\"0x56bc75e2d63100000\"},\"555d8d3ce1798aca902754f164b8be2a02329c6c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"555df19390c16d01298772bae8bc3a1152199cbd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"555ebe84daa42ba256ea789105cec4b693f12f18\":{\"balance\":\"0x56bc75e2d63100000\"},\"557f5e65e0da33998219ad4e99570545b2a9d511\":{\"balance\":\"0x2559cbb985842400000\"},\"558360206883dd1b6d4a59639e5629d0f0c675d0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5584423050e3c2051f0bbd8f44bd6dbc27ecb62c\":{\"balance\":\"0xa2a15d09519be00000\"},\"55852943492970f8d629a15366cdda06a94f4513\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"55866486ec168f79dbe0e1abb18864d98991ae2c\":{\"balance\":\"0xdf6eb0b2d3ca0000\"},\"558c54649a8a6e94722bd6d21d14714f71780534\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"559194304f14b1b93afe444f0624e053c23a0009\":{\"balance\":\"0x15af1d78b58c400000\"},\"5593c9d4b664730fd93ca60151c25c2eaed93c3b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"559706c332d20779c45f8a6d046a699159b74921\":{\"balance\":\"0x149b442e85a3cf8000\"},\"5598b3a79a48f32b1f5fc915b87b645d805d1afe\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"55a3df57b7aaec16a162fd5316f35bec082821cf\":{\"balance\":\"0x6acb3df27e1f880000\"},\"55a4cac0cb8b582d9fef38c5c9fff9bd53093d1f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"55a61b109480b5b2c4fcfdef92d90584160c0d35\":{\"balance\":\"0x26c564d2b53f60000\"},\"55aa5d313ebb084da0e7801091e29e92c5dec3aa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"55ab99b0e0e55d7bb874b7cfe834de631c97ec23\":{\"balance\":\"0x37e98ce36899e40000\"},\"55af092f94ba6a79918b0cf939eab3f01b3f51c7\":{\"balance\":\"0x820d5e39576120000\"},\"55c564664166a1edf3913e0169f1cd451fdb5d0c\":{\"balance\":\"0x8217ea49508e6c0000\"},\"55ca6abe79ea2497f46fdbb830346010fe469cbe\":{\"balance\":\"0x1369fb96128ac480000\"},\"55caff4bba04d220c9a5d2018672ec85e31ef83e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"55d057bcc04bd0f4af9642513aa5090bb3ff93fe\":{\"balance\":\"0x3bfe452c8edd4c0000\"},\"55d42eb495bf46a634997b5f2ea362814918e2b0\":{\"balance\":\"0x5c0d265b5b2a80000\"},\"55da9dcdca61cbfe1f133c7bcefc867b9c8122f9\":{\"balance\":\"0x2fb474098f67c00000\"},\"55e220876262c218af4f56784798c7e55da09e91\":{\"balance\":\"0x73d99c15645d30000\"},\"55fd08d18064bd202c0ec3d2cce0ce0b9d169c4d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5600730a55f6b20ebd24811faa3de96d1662abab\":{\"balance\":\"0x65ea3db75546600000\"},\"5603241eb8f08f721e348c9d9ad92f48e390aa24\":{\"balance\":\"0xad78ebc5ac6200000\"},\"560536794a9e2b0049d10233c41adc5f418a264a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5607590059a9fec1881149a44b36949aef85d560\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"560becdf52b71f3d8827d927610f1a980f33716f\":{\"balance\":\"0x17474d705f56d08000\"},\"560da37e956d862f81a75fd580a7135c1b246352\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"560fc08d079f047ed8d7df75551aa53501f57013\":{\"balance\":\"0x19bff2ff57968c00000\"},\"561be9299b3e6b3e63b79b09169d1a948ae6db01\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"562020e3ed792d2f1835fe5f55417d5111460c6a\":{\"balance\":\"0x43c33c1937564800000\"},\"5620f46d1451c2353d6243a5d4b427130be2d407\":{\"balance\":\"0x340aad21b3b700000\"},\"562105e82b099735de49f62692cc87cd38a8edcd\":{\"balance\":\"0x14542ba12a337c00000\"},\"562a8dcbbeeef7b360685d27303bd69e094accf6\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"562bced38ab2ab6c080f3b0541b8456e70824b3f\":{\"balance\":\"0x22ca3587cf4eb00000\"},\"562be95aba17c5371fe2ba828799b1f55d2177d6\":{\"balance\":\"0x816d37e87b9d1e00000\"},\"562f16d79abfcec3943e34b20f05f97bdfcda605\":{\"balance\":\"0xd8d726b7177a800000\"},\"56373daab46316fd7e1576c61e6affcb6559ddd7\":{\"balance\":\"0xbac715d146c9e0000\"},\"56397638bb3cebf1f62062794b5eb942f916171d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"563a03ab9c56b600f6d25b660c21e16335517a75\":{\"balance\":\"0x3635c9adc5dea00000\"},\"563cb8803c1d32a25b27b64114852bd04d9c20cd\":{\"balance\":\"0xb149ead0ad9d80000\"},\"56586391040c57eec6f5affd8cd4abde10b50acc\":{\"balance\":\"0xd8d726b7177a800000\"},\"566c10d638e8b88b47d6e6a414497afdd00600d4\":{\"balance\":\"0x56b394263a40c0000\"},\"566c28e34c3808d9766fe8421ebf4f2b1c4f7d77\":{\"balance\":\"0x6acb3df27e1f880000\"},\"568df31856699bb5acfc1fe1d680df9960ca4359\":{\"balance\":\"0x4acf5552f3b2498000\"},\"5691dd2f6745f20e22d2e1d1b955aa2903d65656\":{\"balance\":\"0x6ac5c62d9486070000\"},\"56a1d60d40f57f308eebf087dee3b37f1e7c2cba\":{\"balance\":\"0x3edcaec82d06f80000\"},\"56ac20d63bd803595cec036da7ed1dc66e0a9e07\":{\"balance\":\"0x3772a53ccdc658000\"},\"56b6c23dd2ec90b4728f3bb2e764c3c50c85f144\":{\"balance\":\"0x3635c9adc5dea00000\"},\"56df05bad46c3f00ae476ecf017bb8c877383ff1\":{\"balance\":\"0xab15daaef70400000\"},\"56ee197f4bbf9f1b0662e41c2bbd9aa1f799e846\":{\"balance\":\"0x3635c9adc5dea00000\"},\"56f493a3d108aaa2d18d98922f8efe1662cfb73d\":{\"balance\":\"0x6d8121a194d1100000\"},\"56fc1a7bad4047237ce116146296238e078f93ad\":{\"balance\":\"0x9a63f08ea63880000\"},\"56febf9e1003af15b1bd4907ec089a4a1b91d268\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5717cc9301511d4a81b9f583148beed3d3cc8309\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"5717f2d8f18ffcc0e5fe247d3a4219037c3a649c\":{\"balance\":\"0xd8bb6549b02bb80000\"},\"571950ea2c90c1427d939d61b4f2de4cf1cfbfb0\":{\"balance\":\"0x1158e460913d00000\"},\"5719f49b720da68856f4b9e708f25645bdbc4b41\":{\"balance\":\"0x22b1c8c1227a000000\"},\"572ac1aba0de23ae41a7cae1dc0842d8abfc103b\":{\"balance\":\"0x678a932062e4180000\"},\"572dd8cd3fe399d1d0ec281231b7cefc20b9e4bb\":{\"balance\":\"0x233c8fe42703e800000\"},\"574921838cc77d6c98b17d903a3ae0ee0da95bd0\":{\"balance\":\"0xb5328178ad0f2a00000\"},\"574ad9355390e4889ef42acd138b2a27e78c00ae\":{\"balance\":\"0x5467b732a913340000\"},\"574de1b3f38d915846ae3718564a5ada20c2f3ed\":{\"balance\":\"0xd8d726b7177a800000\"},\"575c00c2818210c28555a0ff29010289d3f82309\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5773b6026721a1dd04b7828cd62b591bfb34534c\":{\"balance\":\"0x5b7ac4553de7ae00000\"},\"5777441c83e03f0be8dd340bde636850847c620b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5778ffdc9b94c5a59e224eb965b6de90f222d170\":{\"balance\":\"0x122d7ff36603fc0000\"},\"577aeee8d4bc08fc97ab156ed57fb970925366be\":{\"balance\":\"0x120df1147258bf0000\"},\"577b2d073c590c50306f5b1195a4b2ba9ecda625\":{\"balance\":\"0x1440bdd49515f00000\"},\"577bfe64e3a1e3800e94db1c6c184d8dc8aafc66\":{\"balance\":\"0x5134ed17417f280000\"},\"57825aeb09076caa477887fbc9ae37e8b27cc962\":{\"balance\":\"0x56bc75e2d63100000\"},\"57883010b4ac857fedac03eab2551723a8447ffb\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5789d01db12c816ac268e9af19dc0dd6d99f15df\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5792814f59a33a1843faa01baa089eb02ffb5cf1\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"5793abe6f1533311fd51536891783b3f9625ef1c\":{\"balance\":\"0x2cd8a656f23fda0000\"},\"5797b60fd2894ab3c2f4aede86daf2e788d745ad\":{\"balance\":\"0x14542ba12a337c00000\"},\"57a852fdb9b1405bf53ccf9508f83299d3206c52\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"57b23d6a1adc06c652a779c6a7fb6b95b9fead66\":{\"balance\":\"0xad78ebc5ac6200000\"},\"57bc20e2d62b3d19663cdb4c309d5b4f2fc2db8f\":{\"balance\":\"0x56bc75e2d63100000\"},\"57bddf078834009c89d88e6282759dc45335b470\":{\"balance\":\"0x74717cfb6883100000\"},\"57beea716cbd81700a73d67f9ff039529c2d9025\":{\"balance\":\"0xad78ebc5ac6200000\"},\"57d032a43d164e71aa2ef3ffd8491b0a4ef1ea5b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"57d3df804f2beee6ef53ab94cb3ee9cf524a18d3\":{\"balance\":\"0x1556616b9606670000\"},\"57d5fd0e3d3049330ffcdcd020456917657ba2da\":{\"balance\":\"0x6bf20195f554d40000\"},\"57dd9471cbfa262709f5f486bcb774c5f527b8f8\":{\"balance\":\"0xaadec983fcff40000\"},\"57df23bebdc65eb75feb9cb2fad1c073692b2baf\":{\"balance\":\"0xd8d726b7177a800000\"},\"5800cd8130839e94495d2d8415a8ea2c90e0c5cb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5803e68b34da121aef08b602badbafb4d12481ca\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"5816c2687777b6d7d2a2432d59a41fa059e3a406\":{\"balance\":\"0x1c4fe43adb0a5e900000\"},\"581a3af297efa4436a29af0072929abf9826f58b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"581b9fd6eae372f3501f42eb9619eec820b78a84\":{\"balance\":\"0x42be2c00ca53b8d8000\"},\"581bdf1bb276dbdd86aedcdb397a01efc0e00c5b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"581f34b523e5b41c09c87c298e299cbc0e29d066\":{\"balance\":\"0x3d5833aafd39758000\"},\"5824a7e22838277134308c5f4b50dab65e43bb31\":{\"balance\":\"0x14542ba12a337c00000\"},\"582b70669c97aab7d68148d8d4e90411e2810d56\":{\"balance\":\"0x36356633ebd8ea0000\"},\"582e7cc46f1d7b4e6e9d95868bfd370573178f4c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"583e83ba55e67e13e0e76f8392d873cd21fbf798\":{\"balance\":\"0x1158e460913d00000\"},\"5869fb867d71f1387f863b698d09fdfb87c49b5c\":{\"balance\":\"0xc6bbf858b316080000\"},\"587d6849b168f6c3332b7abae7eb6c42c37f48bf\":{\"balance\":\"0x2fb474098f67c00000\"},\"5887dc6a33dfed5ac1edefe35ef91a216231ac96\":{\"balance\":\"0xd8d726b7177a80000\"},\"588ed990a2aff44a94105d58c305257735c868ac\":{\"balance\":\"0x368c8623a8b4d100000\"},\"58ae2ddc5f4c8ada97e06c0086171767c423f5d7\":{\"balance\":\"0x57473d05dabae80000\"},\"58aed6674affd9f64233272a578dd9386b99c263\":{\"balance\":\"0xb8507a820728200000\"},\"58b808a65b51e6338969afb95ec70735e451d526\":{\"balance\":\"0x8784bc1b9837a380000\"},\"58b8ae8f63ef35ed0762f0b6233d4ac14e64b64d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"58ba1569650e5bbbb21d35d3e175c0d6b0c651a9\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"58c555bc293cdb16c6362ed97ae9550b92ea180e\":{\"balance\":\"0x1158e460913d00000\"},\"58c650ced40bb65641b8e8a924a039def46854df\":{\"balance\":\"0x100bd33fb98ba0000\"},\"58c90754d2f20a1cb1dd330625e04b45fa619d5c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"58e2f11223fc8237f69d99c6289c148c0604f742\":{\"balance\":\"0x5150ae84a8cdf000000\"},\"58e554af3d87629620da61d538c7f5b4b54c4afe\":{\"balance\":\"0x46509d694534728000\"},\"58e5c9e344c806650dacfc904d33edba5107b0de\":{\"balance\":\"0x10910d4cdc9f60000\"},\"58e661d0ba73d6cf24099a5562b808f7b3673b68\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"58f05b262560503ca761c61890a4035f4c737280\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"58fb947364e7695765361ebb1e801ffb8b95e6d0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"590181d445007bd0875aaf061c8d51153900836a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5902e44af769a87246a21e079c08bf36b06efeb3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"590acbda37290c0d3ec84fc2000d7697f9a4b15d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"590ccb5911cf78f6f622f535c474375f4a12cfcf\":{\"balance\":\"0x43c33c1937564800000\"},\"5910106debd291a1cd80b0fbbb8d8d9e93a7cc1e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"59161749fedcf1c721f2202d13ade2abcf460b3d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"591bef3171d1c5957717a4e98d17eb142c214e56\":{\"balance\":\"0x43c33c1937564800000\"},\"59203cc37599b648312a7cc9e06dacb589a9ae6a\":{\"balance\":\"0x80f7971b6400e8000\"},\"59268171b833e0aa13c54b52ccc0422e4fa03aeb\":{\"balance\":\"0xa2a15d09519be00000\"},\"592777261e3bd852c48eca95b3a44c5b7f2d422c\":{\"balance\":\"0x43c33c1937564800000\"},\"593044670faeff00a55b5ae051eb7be870b11694\":{\"balance\":\"0x73f75d1a085ba0000\"},\"593b45a1864ac5c7e8f0caaeba0d873cd5d113b2\":{\"balance\":\"0x14542ba12a337c00000\"},\"593c48935beaff0fde19b04d309cd530a28e52ce\":{\"balance\":\"0xd8d726b7177a800000\"},\"59473cd300fffae240f5785626c65dfec792b9af\":{\"balance\":\"0x1158e460913d00000\"},\"5948bc3650ed519bf891a572679fd992f8780c57\":{\"balance\":\"0xaadec983fcff40000\"},\"594a76f06935388dde5e234696a0668bc20d2ddc\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"59569a21d28fba4bda37753405a081f2063da150\":{\"balance\":\"0xd8d726b7177a800000\"},\"5956b28ec7890b76fc061a1feb52d82ae81fb635\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"595e23d788a2d4bb85a15df7136d264a635511b3\":{\"balance\":\"0xd5967be4fc3f100000\"},\"597038ff91a0900cbbab488af483c790e6ec00a0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5970fb1b144dd751e4ce2eca7caa20e363dc4da3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5975b9528f23af1f0e2ec08ac8ebaa786a2cb8e0\":{\"balance\":\"0x12bf50503ae3038000\"},\"5975d78d974ee5bb9e4d4ca2ae77c84b9c3b4b82\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"5985c59a449dfc5da787d8244e746c6d70caa55f\":{\"balance\":\"0x56bc75e2d63100000\"},\"598aaabae9ed833d7bc222e91fcaa0647b77580b\":{\"balance\":\"0x6194049f30f7200000\"},\"5992624c54cdec60a5ae938033af8be0c50cbb0a\":{\"balance\":\"0xc454e0f8870f2b0000\"},\"599728a78618d1a17b9e34e0fed8e857d5c40622\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"5997ffefb3c1d9d10f1ae2ac8ac3c8e2d2292783\":{\"balance\":\"0x3635c9adc5dea00000\"},\"59a087b9351ca42f58f36e021927a22988284f38\":{\"balance\":\"0x100bd33fb98ba0000\"},\"59a12df2e3ef857aceff9306b309f6a500f70134\":{\"balance\":\"0x3635c9adc5dea00000\"},\"59b96deb8784885d8d3b4a166143cc435d2555a1\":{\"balance\":\"0x487a9a304539440000\"},\"59b9e733cba4be00429b4bd9dfa64732053a7d55\":{\"balance\":\"0x1158e460913d00000\"},\"59c5d06b170ee4d26eb0a0eb46cb7d90c1c91019\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"59c7f785c93160e5807ed34e5e534bc6188647a7\":{\"balance\":\"0x22b1c8c1227a000000\"},\"59d139e2e40c7b97239d23dfaca33858f602d22b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"59f6247b0d582aaa25e5114765e4bf3c774f43c2\":{\"balance\":\"0x2b5e3af16b1880000\"},\"59fe00696dbd87b7976b29d1156c8842a2e17914\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5a0d609aae2332b137ab3b2f26615a808f37e433\":{\"balance\":\"0x21e19e0c9bab24000000\"},\"5a192b964afd80773e5f5eda6a56f14e25e0c6f3\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5a1a336962d6e0c63031cc83c6a5c6a6f4478ecb\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5a1d2d2d1d520304b6208849570437eb3091bb9f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5a267331facb262daaecd9dd63a9700c5f5259df\":{\"balance\":\"0x56bc75e2d63100000\"},\"5a285755391e914e58025faa48cc685f4fd4f5b8\":{\"balance\":\"0x581767ba6189c400000\"},\"5a2916b8d2e8cc12e207ab464d433e2370d823d9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5a2b1c853aeb28c45539af76a00ac2d8a8242896\":{\"balance\":\"0x15af1d78b58c40000\"},\"5a2daab25c31a61a92a4c82c9925a1d2ef58585e\":{\"balance\":\"0xc380da9c7950c0000\"},\"5a30feac37ac9f72d7b4af0f2bc73952c74fd5c3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5a5468fa5ca226c7532ecf06e1bc1c45225d7ec9\":{\"balance\":\"0x678a932062e4180000\"},\"5a565285374a49eedd504c957d510874d00455bc\":{\"balance\":\"0x56bc75e2d63100000\"},\"5a5ee8e9bb0e8ab2fecb4b33d29478be50bbd44b\":{\"balance\":\"0x2a1129d09367200000\"},\"5a5f8508da0ebebb90be9033bd4d9e274105ae00\":{\"balance\":\"0x16a6502f15a1e540000\"},\"5a6071bcebfcba4ab57f4db96fc7a68bece2ba5b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5a60c924162873fc7ea4da7f972e350167376031\":{\"balance\":\"0x487f277a885798000\"},\"5a6686b0f17e07edfc59b759c77d5bef164d3879\":{\"balance\":\"0x50c5e761a444080000\"},\"5a70106f20d63f875265e48e0d35f00e17d02bc9\":{\"balance\":\"0x1158e460913d00000\"},\"5a74ba62e7c81a3474e27d894fed33dd24ad95fe\":{\"balance\":\"0xfc936392801c0000\"},\"5a7735007d70b06844da9901cdfadb11a2582c2f\":{\"balance\":\"0x14542ba12a337c00000\"},\"5a82f96cd4b7e2d93d10f3185dc8f43d4b75aa69\":{\"balance\":\"0x6c633fbab98c040000\"},\"5a87f034e6f68f4e74ffe60c64819436036cf7d7\":{\"balance\":\"0x1158e460913d00000\"},\"5a891155f50e42074374c739baadf7df2651153a\":{\"balance\":\"0x102da6fd0f73a3c0000\"},\"5a9c8b69fc614d69564999b00dcb42db67f97e90\":{\"balance\":\"0xb9e615abad3a778000\"},\"5aaf1c31254a6e005fba7f5ab0ec79d7fc2b630e\":{\"balance\":\"0x14061b9d77a5e980000\"},\"5ab1a5615348001c7c775dc75748669b8be4de14\":{\"balance\":\"0x256a72fb29e69c0000\"},\"5abfec25f74cd88437631a7731906932776356f9\":{\"balance\":\"0x9d83cc0dfa11177ff8000\"},\"5ac2908b0f398c0df5bac2cb13ca7314fba8fa3d\":{\"balance\":\"0xad4c8316a0b0c0000\"},\"5ac99ad7816ae9020ff8adf79fa9869b7cea6601\":{\"balance\":\"0x472698b413b43200000\"},\"5ad12c5ed4fa827e2150cfa0d68c0aa37b1769b8\":{\"balance\":\"0x2b5e3af16b18800000\"},\"5ad5e420755613886f35aa56ac403eebdfe4b0d0\":{\"balance\":\"0x10f0cf064dd592000000\"},\"5ade77fd81c25c0af713b10702768c1eb2f975e7\":{\"balance\":\"0x1158e460913d00000\"},\"5ae64e853ba0a51282cb8db52e41615e7c9f733f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5aed0e6cfe95f9d680c76472a81a2b680a7f93e2\":{\"balance\":\"0xaadec983fcff40000\"},\"5aef16a226dd68071f2483e1da42598319f69b2c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5af46a25ac09cb73616b53b14fb42ff0a51cddb2\":{\"balance\":\"0xd8d726b7177a800000\"},\"5af7c072b2c5acd71c76addcce535cf7f8f93585\":{\"balance\":\"0x1158e460913d00000\"},\"5afda9405c8e9736514574da928de67456010918\":{\"balance\":\"0x145b8b0239a46920000\"},\"5b06d1e6930c1054692b79e3dbe6ecce53966420\":{\"balance\":\"0xb227f63be813c0000\"},\"5b25cae86dcafa2a60e7723631fc5fa49c1ad87d\":{\"balance\":\"0x870c58510e85200000\"},\"5b287c7e734299e727626f93fb1187a60d5057fe\":{\"balance\":\"0x57cd934a914cb0000\"},\"5b290c01967c812e4dc4c90b174c1b4015bae71e\":{\"balance\":\"0x820eb348d52b90000\"},\"5b2b64e9c058e382a8b299224eecaa16e09c8d92\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"5b2e2f1618552eab0db98add55637c2951f1fb19\":{\"balance\":\"0x28a857425466f800000\"},\"5b30608c678e1ac464a8994c3b33e5cdf3497112\":{\"balance\":\"0x15af1d78b58c400000\"},\"5b333696e04cca1692e71986579c920d6b2916f9\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5b430d779696a3653fc60e74fbcbacf6b9c2baf1\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"5b437365ae3a9a2ff97c68e6f90a7620188c7d19\":{\"balance\":\"0x6c8754c8f30c080000\"},\"5b49afcd75447838f6e7ceda8d21777d4fc1c3c0\":{\"balance\":\"0xd8d726b7177a800000\"},\"5b4c0c60f10ed2894bdb42d9dd1d210587810a0d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5b4ea16db6809b0352d4b6e81c3913f76a51bb32\":{\"balance\":\"0x15af1d78b58c400000\"},\"5b5be0d8c67276baabd8edb30d48ea75640b8b29\":{\"balance\":\"0x2cb1f55fb7be100000\"},\"5b5d517029321562111b43086d0b043591109a70\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"5b5d8c8eed6c85ac215661de026676823faa0a0c\":{\"balance\":\"0x43c33c1937564800000\"},\"5b6d55f6712967405c659129f4b1de09acf2cb7b\":{\"balance\":\"0xe7eeba3410b740000\"},\"5b70c49cc98b3df3fbe2b1597f5c1b6347a388b7\":{\"balance\":\"0x34957444b840e80000\"},\"5b736eb18353629bde9676dadd165034ce5ecc68\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5b759fa110a31c88469f54d44ba303d57dd3e10f\":{\"balance\":\"0x5b46dd2f0ea3b80000\"},\"5b7784caea01799ca30227827667ce207c5cbc76\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5b78eca27fbdea6f26befba8972b295e7814364b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5b800bfd1b3ed4a57d875aed26d42f1a7708d72a\":{\"balance\":\"0x15a82d1d5bb88e00000\"},\"5b85e60e2af0544f2f01c64e2032900ebd38a3c7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5ba2c6c35dfaec296826591904d544464aeabd5e\":{\"balance\":\"0x1158e460913d00000\"},\"5baf6d749620803e8348af3710e5c4fbf20fc894\":{\"balance\":\"0x10f4002615dfe900000\"},\"5bc1f95507b1018642e45cd9c0e22733b9b1a326\":{\"balance\":\"0x56bc75e2d63100000\"},\"5bd23547477f6d09d7b2a005c5ee650c510c56d7\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5bd24aac3612b20c609eb46779bf95698407c57c\":{\"balance\":\"0x6acb3df27e1f880000\"},\"5bd6862d517d4de4559d4eec0a06cad05e2f946e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5be045512a026e3f1cebfd5a7ec0cfc36f2dc16b\":{\"balance\":\"0x68155a43676e00000\"},\"5bf9f2226e5aeacf1d80ae0a59c6e38038bc8db5\":{\"balance\":\"0x14542ba12a337c00000\"},\"5bfafe97b1dd1d712be86d41df79895345875a87\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5c0f2e51378f6b0d7bab617331580b6e39ad3ca5\":{\"balance\":\"0x2086ac3510526000000\"},\"5c29f9e9a523c1f8669448b55c48cbd47c25e610\":{\"balance\":\"0x3446a0dad04cb00000\"},\"5c308bac4857d33baea074f3956d3621d9fa28e1\":{\"balance\":\"0x10f08eda8e555098000\"},\"5c312a56c784b122099b764d059c21ece95e84ca\":{\"balance\":\"0x52663ccab1e1c0000\"},\"5c31996dcac015f9be985b611f468730ef244d90\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5c323457e187761a8276e359b7b7af3f3b6e3df6\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5c3c1c645b917543113b3e6c1c054da1fe742b9a\":{\"balance\":\"0x2b5e3af16b18800000\"},\"5c3d19441d196cb443662020fcad7fbb79b29e78\":{\"balance\":\"0xc673ce3c40160000\"},\"5c3f567faff7bad1b5120022e8cbcaa82b4917b3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5c4368918ace6409c79eca80cdaae4391d2b624e\":{\"balance\":\"0xd8d726b7177a800000\"},\"5c464197791c8a3da3c925436f277ab13bf2faa2\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"5c4881165cb42bb82e97396c8ef44adbf173fb99\":{\"balance\":\"0x5fee222041e340000\"},\"5c4892907a0720df6fd3413e63ff767d6b398023\":{\"balance\":\"0x2cb009fd3b5790f8000\"},\"5c4f24e994ed8f850ea7818f471c8fac3bcf0452\":{\"balance\":\"0x5d80688d9e31c00000\"},\"5c5419565c3aad4e714e0739328e3521c98f05cc\":{\"balance\":\"0x1c9f78d2893e400000\"},\"5c6136e218de0a61a137b2b3962d2a6112b809d7\":{\"balance\":\"0xff3dbb65ff4868000\"},\"5c61ab79b408dd3229f662593705d72f1e147bb8\":{\"balance\":\"0x4d0243d3498cd840000\"},\"5c6d041da7af4487b9dc48e8e1f60766d0a56dbc\":{\"balance\":\"0x4f070a003e9c740000\"},\"5c6f36af90ab1a656c6ec8c7d521512762bba3e1\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"5c7b9ec7a2438d1e3c7698b545b9c3fd77b7cd55\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5c936f3b9d22c403db5e730ff177d74eef42dbbf\":{\"balance\":\"0x410d586a20a4c0000\"},\"5cb731160d2e8965670bde925d9de5510935347d\":{\"balance\":\"0x22b1c8c1227a00000\"},\"5cb953a0e42f5030812226217fffc3ce230457e4\":{\"balance\":\"0x56bc75e2d63100000\"},\"5cbd8daf27ddf704cdd0d909a789ba36ed4f37b2\":{\"balance\":\"0xb9f65d00f63c0000\"},\"5cc4cba621f220637742057f6055b80dffd77e13\":{\"balance\":\"0x878477b7d253b660000\"},\"5cc7d3066d45d27621f78bb4b339473e442a860f\":{\"balance\":\"0x21e1899f0377aea0000\"},\"5cccf1508bfd35c20530aa642500c10dee65eaed\":{\"balance\":\"0x2e141ea081ca080000\"},\"5cce72d068c7c3f55b1d2819545e77317cae8240\":{\"balance\":\"0x692ae8897081d00000\"},\"5cd0e475b54421bdfc0c12ea8e082bd7a5af0a6a\":{\"balance\":\"0x332ca1b67940c0000\"},\"5cd588a14ec648ccf64729f9167aa7bf8be6eb3d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5cd8af60de65f24dc3ce5730ba92653022dc5963\":{\"balance\":\"0x61093d7c2c6d380000\"},\"5cdc4708f14f40dcc15a795f7dc8cb0b7faa9e6e\":{\"balance\":\"0x1d1c5f3eda20c40000\"},\"5ce0b6862cce9162e87e0849e387cb5df4f9118c\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"5ce2e7ceaaa18af0f8aafa7fbad74cc89e3cd436\":{\"balance\":\"0x43c33c1937564800000\"},\"5ce44068b8f4a3fe799e6a8311dbfdeda29dee0e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5cebe30b2a95f4aefda665651dc0cf7ef5758199\":{\"balance\":\"0xfc936392801c0000\"},\"5cf18fa7c8a7c0a2b3d5efd1990f64ddc569242c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5cf44e10540d65716423b1bcb542d21ff83a94cd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"5cf8c03eb3e872e50f7cfd0c2f8d3b3f2cb5183a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5cfa8d568575658ca4c1a593ac4c5d0e44c60745\":{\"balance\":\"0xfc66fae3746ac0000\"},\"5cfa9877f719c79d9e494a08d1e41cf103fc87c9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5d1dc3387b47b8451e55106c0cc67d6dc72b7f0b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d231a70c1dfeb360abd97f616e2d10d39f3cab5\":{\"balance\":\"0x15af1d78b58c400000\"},\"5d24bdbc1c47f0eb83d128cae48ac33c4817e91f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5d2819e8d57821922ee445650ccaec7d40544a8d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5d2f7f0b04ba4be161e19cb6f112ce7a5e7d7fe4\":{\"balance\":\"0x1e87f85809dc00000\"},\"5d32f6f86e787ff78e63d78b0ef95fe6071852b8\":{\"balance\":\"0x15be6174e1912e0000\"},\"5d39ef9ea6bdfff15d11fe91f561a6f9e31f5da5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d3f3b1f7130b0bb21a0fd32396239179a25657f\":{\"balance\":\"0xd3ab8ea5e8fd9e80000\"},\"5d5751819b4f3d26ed0c1ac571552735271dbefa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5d5c2c1099bbeefb267e74b58880b444d94449e0\":{\"balance\":\"0xdbf0bd181e2e70000\"},\"5d5cdbe25b2a044b7b9be383bcaa5807b06d3c6b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d5d6e821c6eef96810c83c491468560ef70bfb5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d68324bcb776d3ffd0bf9fea91d9f037fd6ab0f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d6ae8cbd6b3393c22d16254100d0238e808147c\":{\"balance\":\"0x2707e56d51a30c0000\"},\"5d6c5c720d66a6abca8397142e63d26818eaab54\":{\"balance\":\"0x22b1c8c1227a00000\"},\"5d6ccf806738091042ad97a6e095fe8c36aa79c5\":{\"balance\":\"0xa31062beeed700000\"},\"5d71799c8df3bccb7ee446df50b8312bc4eb71c5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5d822d9b3ef4b502627407da272f67814a6becd4\":{\"balance\":\"0x1158e460913d00000\"},\"5d83b21bd2712360436b67a597ee3378db3e7ae4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5d872b122e994ef27c71d7deb457bf65429eca6c\":{\"balance\":\"0x1b1aded81d394108000\"},\"5d8d31faa864e22159cd6f5175ccecc53fa54d72\":{\"balance\":\"0x5b696b70dd567100000\"},\"5d958a9bd189c2985f86c58a8c69a7a78806e8da\":{\"balance\":\"0x228f16f861578600000\"},\"5da2a9a4c2c0a4a924cbe0a53ab9d0c627a1cfa0\":{\"balance\":\"0x27bf38c6544df50000\"},\"5da4ca88935c27f55c311048840e589e04a8a049\":{\"balance\":\"0x4563918244f400000\"},\"5da54785c9bd30575c89deb59d2041d20a39e17b\":{\"balance\":\"0x6aa209f0b91d658000\"},\"5db69fe93e6fb6fbd450966b97238b110ad8279a\":{\"balance\":\"0x878678326eac9000000\"},\"5db7bba1f9573f24115d8c8c62e9ce8895068e9f\":{\"balance\":\"0x2b5aad72c65200000\"},\"5db84400570069a9573cab04b4e6b69535e202b8\":{\"balance\":\"0x20dd68aaf3289100000\"},\"5dc36de5359450a1ec09cb0c44cf2bb42b3ae435\":{\"balance\":\"0x3c946d893b33060000\"},\"5dc6f45fef26b06e3302313f884daf48e2746fb9\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5dcdb6b87a503c6d8a3c65c2cf9a9aa883479a1e\":{\"balance\":\"0x1f2bba5d84f99c00000\"},\"5dd112f368c0e6ceff77a9df02a5481651a02fb7\":{\"balance\":\"0x93472c85c6d540000\"},\"5dd53ae897526b167d39f1744ef7c3da5b37a293\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"5dded049a6e1f329dc4b971e722c9c1f2ade83f0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5de598aba344378cab4431555b4f79992dc290c6\":{\"balance\":\"0x487a9a304539440000\"},\"5de9e7d5d1b667d095dd34099c85b0421a0bc681\":{\"balance\":\"0x1158e460913d00000\"},\"5df3277ca85936c7a0d2c0795605ad25095e7159\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5dff811dad819ece3ba602c383fb5dc64c0a3a48\":{\"balance\":\"0xa1544be879ea80000\"},\"5e031b0a724471d476f3bcd2eb078338bf67fbef\":{\"balance\":\"0xfc936392801c0000\"},\"5e0785532c7723e4c0af9357d5274b73bdddddde\":{\"balance\":\"0x54b41ea9bdb61dc0000\"},\"5e11ecf69d551d7f4f84df128046b3a13240a328\":{\"balance\":\"0x1158e460913d00000\"},\"5e1fbd4e58e2312b3c78d7aaaafa10bf9c3189e3\":{\"balance\":\"0x878678326eac9000000\"},\"5e32c72191b8392c55f510d8e3326e3a60501d62\":{\"balance\":\"0x9513ea9de0243800000\"},\"5e51b8a3bb09d303ea7c86051582fd600fb3dc1a\":{\"balance\":\"0x1158e460913d00000\"},\"5e58e255fc19870a04305ff2a04631f2ff294bb1\":{\"balance\":\"0xf43fc2c04ee00000\"},\"5e5a441974a83d74c687ebdc633fb1a49e7b1ad7\":{\"balance\":\"0xa2a15d09519be00000\"},\"5e65458be964ae449f71773704979766f8898761\":{\"balance\":\"0x1ca7cc735b6f7c0000\"},\"5e67df8969101adabd91accd6bb1991274af8df2\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5e6e9747e162f8b45c656e0f6cae7a84bac80e4e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5e731b55ced452bb3f3fe871ddc3ed7ee6510a8f\":{\"balance\":\"0xa2a15d09519be00000\"},\"5e74ed80e9655788e1bb269752319667fe754e5a\":{\"balance\":\"0x30927f74c9de00000\"},\"5e772e27f28800c50dda973bb33e10762e6eea20\":{\"balance\":\"0x61093d7c2c6d380000\"},\"5e7b8c54dc57b0402062719dee7ef5e37ea35d62\":{\"balance\":\"0x9bf9810fd05c840000\"},\"5e7f70378775589fc66a81d3f653e954f55560eb\":{\"balance\":\"0x83f289181d84c80000\"},\"5e806e845730f8073e6cc9018ee90f5c05f909a3\":{\"balance\":\"0x201e96dacceaf200000\"},\"5e8e4df18cf0af770978a8df8dac90931510a679\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5e90c85877198756b0366c0e17b28e52b446505a\":{\"balance\":\"0x144a4a18efeb680000\"},\"5e95fe5ffcf998f9f9ac0e9a81dab83ead77003d\":{\"balance\":\"0x1d42c20d32797f0000\"},\"5ead29037a12896478b1296ab714e9cb95428c81\":{\"balance\":\"0x3e043072d406e0000\"},\"5eb371c407406c427b3b7de271ad3c1e04269579\":{\"balance\":\"0xa2a15d09519be00000\"},\"5ecdbaeab9106ffe5d7b519696609a05baeb85ad\":{\"balance\":\"0x1158e460913d00000\"},\"5ed0d6338559ef44dc7a61edeb893fa5d83fa1b5\":{\"balance\":\"0xbed1d0263d9f00000\"},\"5ed3bbc05240e0d399eb6ddfe60f62de4d9509af\":{\"balance\":\"0x2914c02475f9d6d30000\"},\"5ed3f1ebe2ae6756b5d8dc19cad02c419aa5778b\":{\"balance\":\"0x0\"},\"5ed56115bd6505a88273df5c56839470d24a2db7\":{\"balance\":\"0x38e6591ee56668000\"},\"5ef8c96186b37984cbfe04c598406e3b0ac3171f\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"5efbdfe5389999633c26605a5bfc2c1bb5959393\":{\"balance\":\"0x3c057c95cd9080000\"},\"5f13154631466dcb1353c890932a7c97e0878e90\":{\"balance\":\"0x14542ba12a337c00000\"},\"5f167aa242bc4c189adecb3ac4a7c452cf192fcf\":{\"balance\":\"0x6c6b4c4da6ddbe0000\"},\"5f1c8a04c90d735b8a152909aeae636fb0ce1665\":{\"balance\":\"0x17b7827618c5a370000\"},\"5f23ba1f37a96c45bc490259538a54c28ba3b0d5\":{\"balance\":\"0x410d586a20a4c00000\"},\"5f26cf34599bc36ea67b9e7a9f9b4330c9d542a3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5f29c9de765dde25852af07d33f2ce468fd20982\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5f2f07d2d697e8c567fcfdfe020f49f360be2139\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5f321b3daaa296cadf29439f9dab062a4bffedd6\":{\"balance\":\"0x47025903ea7ae0000\"},\"5f333a3b2310765a0d1832b9be4c0a03704c1c09\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5f344b01c7191a32d0762ac188f0ec2dd460911d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"5f363e0ab747e02d1b3b66abb69ea53c7baf523a\":{\"balance\":\"0x277017338a30ae00000\"},\"5f375b86600c40cca8b2676b7a1a1d1644c5f52c\":{\"balance\":\"0x44618d74c623f0000\"},\"5f3e1e6739b0c62200e00a003691d9efb238d89f\":{\"balance\":\"0xa2a15d09519be00000\"},\"5f483ffb8f680aedf2a38f7833afdcde59b61e4b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5f4ace4c1cc13391e01f00b198e1f20b5f91cbf5\":{\"balance\":\"0x10f0fa8b9d3811a0000\"},\"5f521282e9b278dc8c034c72af53ee29e5443d78\":{\"balance\":\"0x161732d2f8f3ae00000\"},\"5f68a24c7eb4117667737b33393fb3c2148a53b6\":{\"balance\":\"0x2cede918d453c0000\"},\"5f708eaf39d823946c51b3a3e9b7b3c003e26341\":{\"balance\":\"0x62a992e53a0af00000\"},\"5f742e487e3ab81af2f94afdbe1b9b8f5ccc81bc\":{\"balance\":\"0x75c445d41163e60000\"},\"5f74ed0e24ff80d9b2c4a44baa9975428cd6b935\":{\"balance\":\"0xa18bcec34888100000\"},\"5f76f0a306269c78306b3d650dc3e9c37084db61\":{\"balance\":\"0x821ab0d44149800000\"},\"5f77a107ab1226b3f95f10ee83aefc6c5dff3edc\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"5f7b3bbac16dab831a4a0fc53b0c549dc36c31ca\":{\"balance\":\"0x692ae8897081d00000\"},\"5f93ff832774db5114c55bb4bf44ccf3b58f903f\":{\"balance\":\"0x28a9c91a263458290000\"},\"5f9616c47b4a67f406b95a14fe6fc268396f1721\":{\"balance\":\"0xad78ebc5ac6200000\"},\"5f981039fcf50225e2adf762752112d1cc26b6e3\":{\"balance\":\"0x1b1a416a2153a50000\"},\"5f99dc8e49e61d57daef606acdd91b4d7007326a\":{\"balance\":\"0xa2a15d09519be00000\"},\"5fa61f152de6123516c751242979285f796ac791\":{\"balance\":\"0xb0f11972963b00000\"},\"5fa7bfe043886127d4011d8356a47e947963aca8\":{\"balance\":\"0x62a992e53a0af00000\"},\"5fa8a54e68176c4fe2c01cf671c515bfbdd528a8\":{\"balance\":\"0x45e155fa0110fa400000\"},\"5fad960f6b2c84569c9f4d47bf1985fcb2c65da6\":{\"balance\":\"0x36356633ebd8ea0000\"},\"5fc6c11426b4a1eae7e51dd512ad1090c6f1a85b\":{\"balance\":\"0x93fe5c57d710680000\"},\"5fcd84546896dd081db1a320bd4d8c1dd1528c4c\":{\"balance\":\"0x1158e460913d00000\"},\"5fcda847aaf8d7fa8bca08029ca2849166aa15a3\":{\"balance\":\"0x21cab81259a3bf0000\"},\"5fd1c3e31778276cb42ea740f5eae9c641dbc701\":{\"balance\":\"0xa844a7424d9c80000\"},\"5fd3d6777ec2620ae83a05528ed425072d3ca8fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"5fd973af366aa5157c54659bcfb27cbfa5ac15d6\":{\"balance\":\"0xd8d726b7177a800000\"},\"5fe77703808f823e6c399352108bdb2c527cb87c\":{\"balance\":\"0x6a4076cf7995a00000\"},\"5fec49c665e64ee89dd441ee74056e1f01e92870\":{\"balance\":\"0x1569b9e733474c00000\"},\"5ff326cd60fd136b245e29e9087a6ad3a6527f0d\":{\"balance\":\"0x65ea3db75546600000\"},\"5ff93de6ee054cad459b2d5eb0f6870389dfcb74\":{\"balance\":\"0xbed1d0263d9f00000\"},\"6006e36d929bf45d8f16231b126a011ae283d925\":{\"balance\":\"0x98a7d9b8314c00000\"},\"6021e85a8814fce1e82a41abd1d3b2dad2faefe0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6038740ae28d66ba93b0be08482b3205a0f7a07b\":{\"balance\":\"0x11216185c29f700000\"},\"603f2fab7afb6e017b94766069a4b43b38964923\":{\"balance\":\"0x59d2db2414da990000\"},\"6042276df2983fe2bc4759dc1943e18fdbc34f77\":{\"balance\":\"0x6acb3df27e1f880000\"},\"6042c644bae2b96f25f94d31f678c90dc96690db\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"604cdf18628dbfa8329194d478dd5201eecc4be7\":{\"balance\":\"0x13f306a2409fc0000\"},\"604e9477ebf4727c745bcabbedcb6ccf29994022\":{\"balance\":\"0x36369ed7747d260000\"},\"60676d1fa21fca052297e24bf96389c5b12a70d7\":{\"balance\":\"0xd177c5a7a68d60000\"},\"60676e92d18b000509c61de540e6c5ddb676d509\":{\"balance\":\"0x410d586a20a4c00000\"},\"606f177121f7855c21a5062330c8762264a97b31\":{\"balance\":\"0xd8d726b7177a800000\"},\"60864236930d04d8402b5dcbeb807f3caf611ea2\":{\"balance\":\"0xd8d726b7177a800000\"},\"60ab71cd26ea6d6e59a7a0f627ee079c885ebbf6\":{\"balance\":\"0x1731790534df20000\"},\"60af0ee118443c9b37d2fead77f5e521debe1573\":{\"balance\":\"0x678a932062e4180000\"},\"60b358cb3dbefa37f47df2d7365840da8e3bc98c\":{\"balance\":\"0x1158e460913d00000\"},\"60b8d6b73b79534fb08bb8cbcefac7f393c57bfe\":{\"balance\":\"0x5f68e8131ecf800000\"},\"60be6f953f2a4d25b6256ffd2423ac1438252e4e\":{\"balance\":\"0x821ab0d4414980000\"},\"60c3714fdddb634659e4a2b1ea42c4728cc7b8ba\":{\"balance\":\"0xb98bc829a6f90000\"},\"60cc3d445ebdf76a7d7ae571c6971dff68cc8585\":{\"balance\":\"0x3635c9adc5dea00000\"},\"60d5667140d12614b21c8e5e8a33082e32dfcf23\":{\"balance\":\"0x43c33c1937564800000\"},\"60de22a1507432a47b01cc68c52a0bf8a2e0d098\":{\"balance\":\"0x10910d4cdc9f60000\"},\"60e0bdd0a259bb9cb09d3f37e5cd8b9daceabf8a\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"60e3cc43bcdb026aad759c7066f555bbf2ac66f5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"61042b80fd6095d1b87be2f00f109fabafd157a6\":{\"balance\":\"0x56bc75e2d63100000\"},\"6107d71dd6d0eefb11d4c916404cb98c753e117d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"610fd6ee4eebab10a8c55d0b4bd2e7d6ef817156\":{\"balance\":\"0x1159561065d5d0000\"},\"6114b0eae5576903f80bfb98842d24ed92237f1e\":{\"balance\":\"0x56bc75e2d63100000\"},\"6121af398a5b2da69f65c6381aec88ce9cc6441f\":{\"balance\":\"0x22b1c8c1227a000000\"},\"612667f172135b950b2cd1de10afdece6857b873\":{\"balance\":\"0x3635c9adc5dea00000\"},\"612ced8dc0dc9e899ee46f7962333315f3f55e44\":{\"balance\":\"0x125e35f9cd3d9b0000\"},\"6134d942f037f2cc3d424a230c603d67abd3edf7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"613ac53be565d46536b820715b9b8d3ae68a4b95\":{\"balance\":\"0xcbd47b6eaa8cc00000\"},\"613fab44b16bbe554d44afd178ab1d02f37aeaa5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"614e8bef3dd2c59b59a4145674401018351884ea\":{\"balance\":\"0x1158e460913d00000\"},\"61518464fdd8b73c1bb6ac6db600654938dbf17a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"61547d376e5369bcf978fc162c3c56ae453547e8\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6158e107c5eb54cb7604e0cd8dc1e07500d91c3c\":{\"balance\":\"0x2b5e3af16b1880000\"},\"615a6f36777f40d6617eb5819896186983fd3731\":{\"balance\":\"0x14061b9d77a5e980000\"},\"615f82365c5101f071e7d2cb6af14f7aad2c16c6\":{\"balance\":\"0x1158e460913d00000\"},\"6170dd0687bd55ca88b87adef51cfdc55c4dd458\":{\"balance\":\"0x6cb32f5c34fe440000\"},\"61733947fab820dbd351efd67855ea0e881373a0\":{\"balance\":\"0x1158e460913d00000\"},\"6179979907fe7f037e4c38029d60bcbab832b3d6\":{\"balance\":\"0x57473d05dabae80000\"},\"617f20894fa70e94a86a49cd74e03238f64d3cd9\":{\"balance\":\"0x10f0dbae61009528000\"},\"617ff2cc803e31c9082233b825d025be3f7b1056\":{\"balance\":\"0x6acb3df27e1f880000\"},\"6191ddc9b64a8e0890b4323709d7a07c48b92a64\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"6196c3d3c0908d254366b7bca55745222d9d4db1\":{\"balance\":\"0xd8d726b7177a800000\"},\"619f171445d42b02e2e07004ad8afe694fa53d6a\":{\"balance\":\"0x1158e460913d00000\"},\"61adf5929a5e2981684ea243baa01f7d1f5e148a\":{\"balance\":\"0x5fabf6c984f230000\"},\"61b1b8c012cd4c78f698e470f90256e6a30f48dd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"61b3df2e9e9fd968131f1e88f0a0eb5bd765464d\":{\"balance\":\"0xd8d726b7177a800000\"},\"61b902c5a673885826820d1fe14549e4865fbdc2\":{\"balance\":\"0x1224efed2ae1918000\"},\"61b905de663fc17386523b3a28e2f7d037a655cd\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"61ba87c77e9b596de7ba0e326fddfeec2163ef66\":{\"balance\":\"0xad78ebc5ac6200000\"},\"61bf84d5ab026f58c873f86ff0dfca82b55733ae\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"61c4ee7c864c4d6b5e37ea1331c203739e826b2f\":{\"balance\":\"0x1a1353b382a918000\"},\"61c830f1654718f075ccaba316faacb85b7d120b\":{\"balance\":\"0x15af1d78b58c400000\"},\"61c8f1fa43bf846999ecf47b2b324dfb6b63fe3a\":{\"balance\":\"0x2b5e3af16b18800000\"},\"61c9dce8b2981cb40e98b0402bc3eb28348f03ac\":{\"balance\":\"0xaacacd9b9e22b0000\"},\"61cea71fa464d62a07063f920b0cc917539733d8\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"61d101a033ee0e2ebb3100ede766df1ad0244954\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"61ed5596c697207f3d55b2a51aa7d50f07fa09e8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"61ff8e67b34d9ee6f78eb36ffea1b9f7c15787af\":{\"balance\":\"0x58e7926ee858a00000\"},\"6205c2d5647470848a3840f3887e9b015d34755c\":{\"balance\":\"0x6194049f30f7200000\"},\"6228ade95e8bb17d1ae23bfb0518414d497e0eb8\":{\"balance\":\"0x15af1d78b58c400000\"},\"6229dcc203b1edccfdf06e87910c452a1f4d7a72\":{\"balance\":\"0x6e1d41a8f9ec3500000\"},\"622be4b45495fcd93143efc412d699d6cdc23dc5\":{\"balance\":\"0xf015f25736420000\"},\"62331df2a3cbee3520e911dea9f73e905f892505\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"625644c95a873ef8c06cdb9e9f6d8d7680043d62\":{\"balance\":\"0x6194049f30f7200000\"},\"6265b2e7730f36b776b52d0c9d02ada55d8e3cb6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"62680a15f8ccb8bdc02f7360c25ad8cfb57b8ccd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6294eae6e420a3d5600a39c4141f838ff8e7cc48\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"62971bf2634cee0be3c9890f51a56099dbb9519b\":{\"balance\":\"0x238fd42c5cf0400000\"},\"629be7ab126a5398edd6da9f18447e78c692a4fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"62b4a9226e61683c72c183254690daf511b4117a\":{\"balance\":\"0xe18398e7601900000\"},\"62b9081e7710345e38e02e16449ace1b85bcfc4e\":{\"balance\":\"0x3154c9729d05780000\"},\"62c37c52b97f4b040b1aa391d6dec152893c4707\":{\"balance\":\"0x3635c9adc5dea00000\"},\"62c9b271ffd5b770a5eee4edc9787b5cdc709714\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"62d5cc7117e18500ac2f9e3c26c86b0a94b0de15\":{\"balance\":\"0x5b12aefafa8040000\"},\"62dc72729024375fc37cbb9c7c2393d10233330f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"62e6b2f5eb94fa7a43831fc87e254a3fe3bf8f89\":{\"balance\":\"0xd8d726b7177a80000\"},\"62f2e5ccecd52cc4b95e0597df27cc079715608c\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"62fb8bd1f0e66b90533e071e6cbe6111fef0bc63\":{\"balance\":\"0x3ba1910bf341b000000\"},\"630a913a9031c9492abd4c41dbb15054cfec4416\":{\"balance\":\"0x13458db67af35e00000\"},\"630c5273126d517ce67101811cab16b8534cf9a8\":{\"balance\":\"0x1feccc62573bbd38000\"},\"631030a5b27b07288a45696f189e1114f12a81c0\":{\"balance\":\"0x1b1a7a420ba00d0000\"},\"6310b020fd98044957995092090f17f04e52cdfd\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"632b9149d70178a7333634275e82d5953f27967b\":{\"balance\":\"0x25f273933db5700000\"},\"632cecb10cfcf38ec986b43b8770adece9200221\":{\"balance\":\"0x1158e460913d00000\"},\"6331028cbb5a21485bc51b565142993bdb2582a9\":{\"balance\":\"0x1cfdd7468216e80000\"},\"63334fcf1745840e4b094a3bb40bb76f9604c04c\":{\"balance\":\"0xd7a5d703a717e80000\"},\"63340a57716bfa63eb6cd133721202575bf796f0\":{\"balance\":\"0xb61e0a20c12718000\"},\"634efc24371107b4cbf03f79a93dfd93e431d5fd\":{\"balance\":\"0x423582e08edc5c8000\"},\"635c00fdf035bca15fa3610df3384e0fb79068b1\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"63612e7862c27b587cfb6daf9912cb051f030a9f\":{\"balance\":\"0x25b19d4bfe8ed0000\"},\"63666755bd41b5986997783c13043008242b3cb5\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"637be71b3aa815ff453d5642f73074450b64c82a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"637d67d87f586f0a5a479e20ee13ea310a10b647\":{\"balance\":\"0xa3a5926afa1e7300000\"},\"637f5869d6e4695f0eb9e27311c4878aff333380\":{\"balance\":\"0x6ac04e68aaec860000\"},\"63977cad7d0dcdc52b9ac9f2ffa136e8642882b8\":{\"balance\":\"0x410d586a20a4c0000\"},\"63a61dc30a8e3b30a763c4213c801cbf98738178\":{\"balance\":\"0x3635c9adc5dea00000\"},\"63ac545c991243fa18aec41d4f6f598e555015dc\":{\"balance\":\"0x2086ac351052600000\"},\"63b9754d75d12d384039ec69063c0be210d5e0e3\":{\"balance\":\"0x920b860cc8ecfd8000\"},\"63bb664f9117037628594da7e3c5089fd618b5b5\":{\"balance\":\"0x1158e460913d00000\"},\"63c2a3d235e5eeabd0d4a6afdb89d94627396495\":{\"balance\":\"0x434ef05b9d84820000\"},\"63c8dfde0b8e01dadc2e748c824cc0369df090b3\":{\"balance\":\"0xd255d112e103a00000\"},\"63d55ad99b9137fd1b20cc2b4f03d42cbaddf334\":{\"balance\":\"0x15af1d78b58c400000\"},\"63d80048877596e0c28489e650cd4ac180096a49\":{\"balance\":\"0xf2dc7d47f15600000\"},\"63e414603e80d4e5a0f5c18774204642258208e4\":{\"balance\":\"0x10f0cf064dd59200000\"},\"63e88e2e539ffb450386b4e46789b223f5476c45\":{\"balance\":\"0x155170a778e25d00000\"},\"63ef2fbc3daf5edaf4a295629ccf31bcdf4038e5\":{\"balance\":\"0x4f2591f896a6500000\"},\"63f0e5a752f79f67124eed633ad3fd2705a397d4\":{\"balance\":\"0xd5967be4fc3f100000\"},\"63f5b53d79bf2e411489526530223845fac6f601\":{\"balance\":\"0x65a4da25d3016c00000\"},\"63fc93001305adfbc9b85d29d9291a05f8f1410b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"63fe6bcc4b8a9850abbe75803730c932251f145b\":{\"balance\":\"0xfc936392801c0000\"},\"6403d062549690c8e8b63eae41d6c109476e2588\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"64042ba68b12d4c151651ca2813b7352bd56f08e\":{\"balance\":\"0x2086ac351052600000\"},\"6405dd13e93abcff377e700e3c1a0086eca27d29\":{\"balance\":\"0xfc936392801c0000\"},\"640aba6de984d94517377803705eaea7095f4a11\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"640bf87415e0cf407301e5599a68366da09bbac8\":{\"balance\":\"0x1abc9f416098158000\"},\"6420f8bcc8164a6152a99d6b99693005ccf7e053\":{\"balance\":\"0x36356633ebd8ea0000\"},\"64241a7844290e0ab855f1d4aa75b55345032224\":{\"balance\":\"0x56bc75e2d631000000\"},\"64264aedd52dcae918a012fbcd0c030ee6f71821\":{\"balance\":\"0x3635c9adc5dea00000\"},\"64370e87202645125a35b207af1231fb6072f9a7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"643d9aeed4b180947ed2b9207cce4c3ddc55e1f7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6443b8ae639de91cf73c5ae763eeeed3ddbb9253\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"64457fa33b0832506c4f7d1180dce48f46f3e0ff\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"64464a6805b462412a901d2db8174b06c22deea6\":{\"balance\":\"0x19c846a029c7c80000\"},\"644ba6c61082e989109f5c11d4b40e991660d403\":{\"balance\":\"0xd8d726b7177a800000\"},\"64628c6fb8ec743adbd87ce5e018d531d9210437\":{\"balance\":\"0x1731790534df20000\"},\"6463f715d594a1a4ace4bb9c3b288a74decf294d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"646628a53c2c4193da88359ce718dadd92b7a48d\":{\"balance\":\"0xad8006c2f5ef00000\"},\"64672da3ab052821a0243d1ce4b6e0a36517b8eb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"646afba71d849e80c0ed59cac519b278e7f7abe4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"646e043d0597a664948fbb0dc15475a3a4f3a6ed\":{\"balance\":\"0x1158e460913d00000\"},\"6470a4f92ec6b0fccd01234fa59023e9ff1f3aac\":{\"balance\":\"0xa2a15d09519be00000\"},\"647b85044df2cf0b4ed4882e88819fe22ae5f793\":{\"balance\":\"0x36363b5d9a77700000\"},\"6485470e61db110aebdbafd536769e3c599cc908\":{\"balance\":\"0x2086ac351052600000\"},\"648f5bd2a2ae8902db37847d1cb0db9390b06248\":{\"balance\":\"0x1a535ecf0760a048000\"},\"649a2b9879cd8fb736e6703b0c7747849796f10f\":{\"balance\":\"0x18ee22da01ad34f0000\"},\"649a85b93653075fa6562c409a565d087ba3e1ba\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"64adcceec53dd9d9dd15c8cc1a9e736de4241d2c\":{\"balance\":\"0x30927f74c9de00000\"},\"64cf0935bf19d2cebbecd8780d27d2e2b2c34166\":{\"balance\":\"0x6acb3df27e1f880000\"},\"64d80c3b8ba68282290b75e65d8978a15a87782c\":{\"balance\":\"0x6acb3df27e1f880000\"},\"64dba2d6615b8bd7571836dc75bc79d314f5ecee\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"64e0217a5b38aa40583625967fa9883690388b6f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"64e02abb016cc23a2934f6bcddb681905021d563\":{\"balance\":\"0x3635c9adc5dea00000\"},\"64e03ef070a54703b7184e48276c5c0077ef4b34\":{\"balance\":\"0x1158e460913d000000\"},\"64e2de21200b1899c3a0c0653b5040136d0dc842\":{\"balance\":\"0x43c33c1937564800000\"},\"64ec8a5b743f3479e707dae9ee20ddaa4f40f1d9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6503860b191008c15583bfc88158099301762828\":{\"balance\":\"0x3635c9adc5dea00000\"},\"65053191319e067a25e6361d47f37f6318f83419\":{\"balance\":\"0x155bd9307f9fe80000\"},\"65093b239bbfba23c7775ca7da5a8648a9f54cf7\":{\"balance\":\"0x15af1d78b58c400000\"},\"6509eeb1347e842ffb413e37155e2cbc738273fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"650b425555e4e4c51718146836a2c1ee77a5b421\":{\"balance\":\"0x43c33c1937564800000\"},\"650cf67db060cce17568d5f2a423687c49647609\":{\"balance\":\"0x56bc75e2d63100000\"},\"6510df42a599bcb0a519cca961b488759a6f6777\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"653675b842d7d8b461f722b4117cb81dac8e639d\":{\"balance\":\"0x1ae361fc1451c0000\"},\"654b7e808799a83d7287c67706f2abf49a496404\":{\"balance\":\"0x6acb3df27e1f880000\"},\"654f524847b3a6acc0d3d5f1f362b603edf65f96\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"655934da8e744eaa3de34dbbc0894c4eda0b61f2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"655d5cd7489629e2413c2105b5a172d933c27af8\":{\"balance\":\"0xdb03186cd840a60000\"},\"656018584130db83ab0591a8128d9381666a8d0e\":{\"balance\":\"0x3779f912019fc0000\"},\"6560941328ff587cbc56c38c78238a7bb5f442f6\":{\"balance\":\"0x2861906b59c47a0000\"},\"656579daedd29370d9b737ee3f5cd9d84bc2b342\":{\"balance\":\"0x4d853c8f8908980000\"},\"657473774f63ac3d6279fd0743d5790c4f161503\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6580b1bc94390f04b397bd73e95d96ef11eaf3a8\":{\"balance\":\"0x1158e460913d00000\"},\"65849be1af20100eb8a3ba5a5be4d3ae8db5a70e\":{\"balance\":\"0x15af1d78b58c400000\"},\"659c0a72c767a3a65ced0e1ca885a4c51fd9b779\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"65a52141f56bef98991724c6e7053381da8b5925\":{\"balance\":\"0x3429c335d57fe0000\"},\"65a9dad42e1632ba3e4e49623fab62a17e4d3611\":{\"balance\":\"0x50c4cb2a10c600000\"},\"65af8d8b5b1d1eedfa77bcbc96c1b133f83306df\":{\"balance\":\"0x55005f0c614480000\"},\"65af9087e05167715497c9a5a749189489004def\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"65b42faecc1edfb14283ca979af545f63b30e60c\":{\"balance\":\"0xfc936392801c0000\"},\"65d33eb39cda6453b19e61c1fe4db93170ef9d34\":{\"balance\":\"0xb98bc829a6f90000\"},\"65d8dd4e251cbc021f05b010f2d5dc520c3872e0\":{\"balance\":\"0x2d43579a36a90e0000\"},\"65ea26eabbe2f64ccccfe06829c25d4637520225\":{\"balance\":\"0x25f273933db5700000\"},\"65ea67ad3fb56ad5fb94387dd38eb383001d7c68\":{\"balance\":\"0x56bc75e2d63100000\"},\"65ebaed27edb9dcc1957aee5f452ac2105a65c0e\":{\"balance\":\"0x937dfadae25e29b8000\"},\"65ee20b06d9ad589a7e7ce04b9f5f795f402aece\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"65f534346d2ffb787fa9cf185d745ba42986bd6e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"65f5870f26bce089677dfc23b5001ee492483428\":{\"balance\":\"0x112b1f155aa32a30000\"},\"65fd02d704a12a4dace9471b0645f962a89671c8\":{\"balance\":\"0x18d1ce6e427cd8000\"},\"65ff874fafce4da318d6c93d57e2c38a0d73e820\":{\"balance\":\"0x3638021cecdab00000\"},\"660557bb43f4be3a1b8b85e7df7b3c5bcd548057\":{\"balance\":\"0x14542ba12a337c00000\"},\"66082c75a8de31a53913bbd44de3a0374f7faa41\":{\"balance\":\"0x4f2591f896a6500000\"},\"6611ce59a98b072ae959dc49ad511daaaaa19d6b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"66201bd227ae6dc6bdfed5fbde811fecfe5e9dd9\":{\"balance\":\"0x203e9e8492788c0000\"},\"662334814724935b7931ddca6100e00d467727cd\":{\"balance\":\"0x2288269d0783d40000\"},\"66274fea82cd30b6c29b23350e4f4f3d310a5899\":{\"balance\":\"0x70370550ab82980000\"},\"662cfa038fab37a01745a364e1b98127c503746d\":{\"balance\":\"0xd5967be4fc3f100000\"},\"6635b46f711d2da6f0e16370cd8ee43efb2c2d52\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"663604b0503046e624cd26a8b6fb4742dce02a6f\":{\"balance\":\"0x38b9b797ef68c0000\"},\"6636d7ac637a48f61d38b14cfd4865d36d142805\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"6640ccf053555c130ae2b656647ea6e31637b9ab\":{\"balance\":\"0x6acb3df27e1f880000\"},\"66424bd8785b8cb461102a900283c35dfa07ef6a\":{\"balance\":\"0x22e2db26666fc8000\"},\"664cd67dccc9ac8228b45c55db8d76550b659cdc\":{\"balance\":\"0x155bd9307f9fe80000\"},\"664e43119870af107a448db1278b044838ffcdaf\":{\"balance\":\"0x15af1d78b58c400000\"},\"6651736fb59b91fee9c93aa0bd6ea2f7b2506180\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"665b000f0b772750cc3c217a5ef429a92bf1ccbb\":{\"balance\":\"0xd8d726b7177a800000\"},\"66662006015c1f8e3ccfcaebc8ee6807ee196303\":{\"balance\":\"0x1b1b3a1ac261ec0000\"},\"666746fb93d1935c5a3c684e725010c4fad0b1d8\":{\"balance\":\"0x1158e460913d00000\"},\"666b4f37d55d63b7d056b615bb74c96b3b01991a\":{\"balance\":\"0xd8d726b7177a800000\"},\"66719c0682b2ac7f9e27abebec7edf8decf0ae0d\":{\"balance\":\"0x1158e460913d00000\"},\"6671b182c9f741a0cd3c356c73c23126d4f9e6f4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6679aeecd87a57a73f3356811d2cf49d0c4d96dc\":{\"balance\":\"0x2086ac351052600000\"},\"667b61c03bb937a9f5d0fc5a09f1ea3363c77035\":{\"balance\":\"0xe664992288f2280000\"},\"6685fd2e2544702c360b8bb9ee78f130dad16da5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"668b6ba8ab08eace39c502ef672bd5ccb6a67a20\":{\"balance\":\"0x697d95d4201333c0000\"},\"66925de3e43f4b41bf9dadde27d5488ef569ea0d\":{\"balance\":\"0x222c8eb3ff6640000\"},\"66b0c100c49149935d14c0dc202cce907cea1a3d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"66b1a63da4dcd9f81fe54f5e3fcb4055ef7ec54f\":{\"balance\":\"0xaeb272adf9cfa0000\"},\"66b39837cb3cac8a802afe3f12a258bbca62dacd\":{\"balance\":\"0x15af1d78b58c400000\"},\"66c8331efe7198e98b2d32b938688e3241d0e24f\":{\"balance\":\"0x2098051970e39d00000\"},\"66cc8ab23c00d1b82acd7d73f38c99e0d05a4fa6\":{\"balance\":\"0x56bc75e2d63100000\"},\"66dcc5fb4ee7fee046e141819aa968799d644491\":{\"balance\":\"0x487a9a304539440000\"},\"66e09427c1e63deed7e12b8c55a6a19320ef4b6a\":{\"balance\":\"0x93739534d28680000\"},\"66ec16ee9caab411c55a6629e318de6ee216491d\":{\"balance\":\"0x2ee449550898e40000\"},\"66f50406eb1b11a946cab45927cca37470e5a208\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"66fdc9fee351fa1538eb0d87d819fcf09e7c106a\":{\"balance\":\"0x14627b5d93781b20000\"},\"67048f3a12a4dd1f626c64264cb1d7971de2ca38\":{\"balance\":\"0x9c2007651b2500000\"},\"6704f169e0d0b36b57bbc39f3c45437b5ee3d28d\":{\"balance\":\"0x155bd9307f9fe80000\"},\"671015b97670b10d5e583f3d62a61c1c79c5143f\":{\"balance\":\"0x15af1d78b58c400000\"},\"6710c2c03c65992b2e774be52d3ab4a6ba217ef7\":{\"balance\":\"0x274d656ac90e3400000\"},\"671110d96aaff11523cc546bf9940eedffb2faf7\":{\"balance\":\"0xd8d726b7177a800000\"},\"6715c14035fb57bb3d667f7b707498c41074b855\":{\"balance\":\"0x25f273933db5700000\"},\"671bbca099ff899bab07ea1cf86965c3054c8960\":{\"balance\":\"0x2b5e3af16b1880000\"},\"6727daf5b9d68efcab489fedec96d7f7325dd423\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"672cbca8440a8577097b19aff593a2ad9d28a756\":{\"balance\":\"0x4563918244f400000\"},\"672ec42faa8cd69aaa71b32cc7b404881d52ff91\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"672fa0a019088db3166f6119438d07a99f8ba224\":{\"balance\":\"0x2d4ca05e2b43ca80000\"},\"673144f0ec142e770f4834fee0ee311832f3087b\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"67350b5331926f5e28f3c1e986f96443809c8b8c\":{\"balance\":\"0x1314fb370629800000\"},\"673706b1b0e4dc7a949a7a796258a5b83bb5aa83\":{\"balance\":\"0x368c8623a8b4d100000\"},\"6742a2cfce8d79a2c4a51b77747498912245cd6a\":{\"balance\":\"0xdfd5b80b7e4680000\"},\"674adb21df4c98c7a347ac4c3c24266757dd7039\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"67518e5d02b205180f0463a32004471f753c523e\":{\"balance\":\"0x6b918aac494b168000\"},\"675d5caa609bf70a18aca580465d8fb7310d1bbb\":{\"balance\":\"0x43c33c1937564800000\"},\"67632046dcb25a54936928a96f423f3320cbed92\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6765df25280e8e4f38d4b1cf446fc5d7eb659e34\":{\"balance\":\"0x56bc75e2d63100000\"},\"6776e133d9dc354c12a951087b639650f539a433\":{\"balance\":\"0x68155a43676e00000\"},\"6785513cf732e47e87670770b5419be10cd1fc74\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"679437eacf437878dc293d48a39c87b7421a216c\":{\"balance\":\"0x37f81821db2680000\"},\"679b9a109930517e8999099ccf2a914c4c8dd934\":{\"balance\":\"0x340aad21b3b700000\"},\"67a80e0190721f94390d6802729dd12c31a895ad\":{\"balance\":\"0x6c6b1375bc91560000\"},\"67b8a6e90fdf0a1cac441793301e8750a9fa7957\":{\"balance\":\"0x30849ebe16369c0000\"},\"67bc85e87dc34c4e80aafa066ba8d29dbb8e438e\":{\"balance\":\"0x15d1cf4176aeba0000\"},\"67c926093e9b8927933810d98222d62e2b8206bb\":{\"balance\":\"0x678a932062e4180000\"},\"67cfda6e70bf7657d39059b59790e5145afdbe61\":{\"balance\":\"0x23050d095866580000\"},\"67d682a282ef73fb8d6e9071e2614f47ab1d0f5e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"67d6a8aa1bf8d6eaf7384e993dfdf10f0af68a61\":{\"balance\":\"0xabcbb5718974b8000\"},\"67da922effa472a6b124e84ea8f86b24e0f515aa\":{\"balance\":\"0x1158e460913d00000\"},\"67df242d240dd4b8071d72f8fcf35bb3809d71e8\":{\"balance\":\"0xd8d726b7177a800000\"},\"67ee406ea4a7ae6a3a381eb4edd2f09f174b4928\":{\"balance\":\"0x3829635f0968b00000\"},\"67f2bb78b8d3e11f7c458a10b5c8e0a1d374467d\":{\"balance\":\"0x61093d7c2c6d380000\"},\"67fc527dce1785f0fb8bc7e518b1c669f7ecdfb5\":{\"balance\":\"0xd02ab486cedc00000\"},\"68027d19558ed7339a08aee8de3559be063ec2ea\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"680640838bd07a447b168d6d923b90cf6c43cdca\":{\"balance\":\"0x5dc892aa1131c80000\"},\"6807ddc88db489b033e6b2f9a81553571ab3c805\":{\"balance\":\"0x19f8e7559924c0000\"},\"680d5911ed8dd9eec45c060c223f89a7f620bbd5\":{\"balance\":\"0x43c33c1937564800000\"},\"6811b54cd19663b11b94da1de2448285cd9f68d9\":{\"balance\":\"0x3ba1910bf341b00000\"},\"68190ca885da4231874c1cfb42b1580a21737f38\":{\"balance\":\"0xcf152640c5c8300000\"},\"682897bc4f8e89029120fcffb787c01a93e64184\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"68295e8ea5afd9093fc0a465d157922b5d2ae234\":{\"balance\":\"0x1154e53217ddb0000\"},\"682e96276f518d31d7e56e30dfb009c1218201bd\":{\"balance\":\"0x1158e460913d00000\"},\"6835c8e8b74a2ca2ae3f4a8d0f6b954a3e2a8392\":{\"balance\":\"0x3429c335d57fe0000\"},\"683633010a88686bea5a98ea53e87997cbf73e69\":{\"balance\":\"0x56b394263a40c0000\"},\"683dba36f7e94f40ea6aea0d79b8f521de55076e\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"68419c6dd2d3ce6fcbb3c73e2fa079f06051bde6\":{\"balance\":\"0x6acb3df27e1f880000\"},\"68473b7a7d965904bedba556dfbc17136cd5d434\":{\"balance\":\"0x56bc75e2d63100000\"},\"6847825bdee8240e28042c83cad642f286a3bddc\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"684a44c069339d08e19a75668bdba303be855332\":{\"balance\":\"0xed2b525841adfc00000\"},\"68531f4dda808f5320767a03113428ca0ce2f389\":{\"balance\":\"0x10d3aa536e2940000\"},\"687927e3048bb5162ae7c15cf76bd124f9497b9e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"68809af5d532a11c1a4d6e32aac75c4c52b08ead\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"6886ada7bbb0617bda842191c68c922ea3a8ac82\":{\"balance\":\"0x3ee23bde0e7d200000\"},\"68883e152e5660fee59626e7e3b4f05110e6222f\":{\"balance\":\"0xb94633be975a62a0000\"},\"688a569e965524eb1d0ac3d3733eab909fb3d61e\":{\"balance\":\"0x478eae0e571ba00000\"},\"688eb3853bbcc50ecfee0fa87f0ab693cabdef02\":{\"balance\":\"0x6b10a18400647c00000\"},\"68a7425fe09eb28cf86eb1793e41b211e57bd68d\":{\"balance\":\"0x243d4d18229ca20000\"},\"68a86c402388fddc59028fec7021e98cbf830eac\":{\"balance\":\"0x10910d4cdc9f60000\"},\"68acdaa9fb17d3c309911a77b05f5391fa034ee9\":{\"balance\":\"0x1e52e336cde22180000\"},\"68addf019d6b9cab70acb13f0b3117999f062e12\":{\"balance\":\"0x2b51212e6b7c88000\"},\"68b31836a30a016ada157b638ac15da73f18cfde\":{\"balance\":\"0x168d28e3f00280000\"},\"68b6854788a7c6496cdbf5f84b9ec5ef392b78bb\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"68c08490c89bf0d6b6f320b1aca95c8312c00608\":{\"balance\":\"0xd8d726b7177a800000\"},\"68c7d1711b011a33f16f1f55b5c902cce970bdd7\":{\"balance\":\"0x83d6c7aab63600000\"},\"68c8791dc342c373769ea61fb7b510f251d32088\":{\"balance\":\"0x3635c9adc5dea00000\"},\"68df947c495bebaeb8e889b3f953d533874bf106\":{\"balance\":\"0x1d9945ab2b03480000\"},\"68e8022740f4af29eb48db32bcecddfd148d3de3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"68ec79d5be7155716c40941c79d78d17de9ef803\":{\"balance\":\"0x1b233877b5208c0000\"},\"68eec1e288ac31b6eaba7e1fbd4f04ad579a6b5d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"68f525921dc11c329b754fbf3e529fc723c834cd\":{\"balance\":\"0x57473d05dabae80000\"},\"68f719ae342bd7fef18a05cbb02f705ad38ed5b2\":{\"balance\":\"0x38ebad5cdc90280000\"},\"68f7573cd457e14c03fea43e302d30347c10705c\":{\"balance\":\"0x10f0cf064dd59200000\"},\"68f8f45155e98c5029a4ebc5b527a92e9fa83120\":{\"balance\":\"0xf07b44b40793208000\"},\"68fe1357218d095849cd579842c4aa02ff888d93\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"690228e4bb12a8d4b5e0a797b0c5cf2a7509131e\":{\"balance\":\"0x65ea3db75546600000\"},\"690594d306613cd3e2fd24bca9994ad98a3d73f8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"69073269729e6414b26ec8dc0fd935c73b579f1e\":{\"balance\":\"0x65a4da25d3016c00000\"},\"6919dd5e5dfb1afa404703b9faea8cee35d00d70\":{\"balance\":\"0x14061b9d77a5e980000\"},\"693492a5c51396a482881669ccf6d8d779f00951\":{\"balance\":\"0x12bf50503ae3038000\"},\"693d83be09459ef8390b2e30d7f7c28de4b4284e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"69517083e303d4fbb6c2114514215d69bc46a299\":{\"balance\":\"0x56bc75e2d63100000\"},\"695550656cbf90b75d92ad9122d90d23ca68ca4d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6958f83bb2fdfb27ce0409cd03f9c5edbf4cbedd\":{\"balance\":\"0x43c33c1937564800000\"},\"695b0f5242753701b264a67071a2dc880836b8db\":{\"balance\":\"0xe398811bec680000\"},\"695b4cce085856d9e1f9ff3e79942023359e5fbc\":{\"balance\":\"0x10f0cf064dd59200000\"},\"6966063aa5de1db5c671f3dd699d5abe213ee902\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"6974c8a414ceaefd3c2e4dfdbef430568d9a960b\":{\"balance\":\"0x121ea68c114e510000\"},\"6978696d5150a9a263513f8f74c696f8b1397cab\":{\"balance\":\"0x167f482d3c5b1c00000\"},\"69797bfb12c9bed682b91fbc593591d5e4023728\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"697f55536bf85ada51841f0287623a9f0ed09a17\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"6982fe8a867e93eb4a0bd051589399f2ec9a5292\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"698a8a6f01f9ab682f637c7969be885f6c5302bf\":{\"balance\":\"0x10d3aa536e2940000\"},\"698ab9a2f33381e07c0c47433d0d21d6f336b127\":{\"balance\":\"0x1158e460913d00000\"},\"6994fb3231d7e41d491a9d68d1fa4cae2cc15960\":{\"balance\":\"0xd8d726b7177a800000\"},\"699c9ee47195511f35f862ca4c22fd35ae8ffbf4\":{\"balance\":\"0x4563918244f400000\"},\"699fc6d68a4775573c1dcdaec830fefd50397c4e\":{\"balance\":\"0x340aad21b3b700000\"},\"69af28b0746cac0da17084b9398c5e36bb3a0df2\":{\"balance\":\"0x3677036edf0af60000\"},\"69b80ed90f84834afa3ff82eb964703b560977d6\":{\"balance\":\"0x1731790534df20000\"},\"69b81d5981141ec7a7141060dfcf8f3599ffc63e\":{\"balance\":\"0x10f0cf064dd59200000\"},\"69bcfc1d43b4ba19de7b274bdffb35139412d3d7\":{\"balance\":\"0x35659ef93f0fc40000\"},\"69bd25ade1a3346c59c4e930db2a9d715ef0a27a\":{\"balance\":\"0xd8d726b7177a800000\"},\"69c08d744754de709ce96e15ae0d1d395b3a2263\":{\"balance\":\"0x3635c9adc5dea00000\"},\"69c2d835f13ee90580408e6a3283c8cca6a434a2\":{\"balance\":\"0x238fd42c5cf0400000\"},\"69c94e07c4a9be3384d95dfa3cb9290051873b7b\":{\"balance\":\"0x3cb71f51fc5580000\"},\"69cb3e2153998d86e5ee20c1fcd1a6baeeb2863f\":{\"balance\":\"0xd8d726b7177a800000\"},\"69d39d510889e552a396135bfcdb06e37e387633\":{\"balance\":\"0xd8d726b7177a800000\"},\"69d98f38a3ba3dbc01fa5c2c1427d862832f2f70\":{\"balance\":\"0x152d02c7e14af6800000\"},\"69e2e2e704307ccc5b5ca3f164fece2ea7b2e512\":{\"balance\":\"0x17b7883c06916600000\"},\"69ff429074cb9b6c63bc914284bce5f0c8fbf7d0\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"69ff8901b541763f817c5f2998f02dcfc1df2997\":{\"balance\":\"0x22b1c8c1227a00000\"},\"6a023af57d584d845e698736f130db9db40dfa9a\":{\"balance\":\"0x55b201c8900980000\"},\"6a04f5d53fc0f515be942b8f12a9cb7ab0f39778\":{\"balance\":\"0xa9aab3459be1940000\"},\"6a05b21c4f17f9d73f5fb2b0cb89ff5356a6cc7e\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"6a0f056066c2d56628850273d7ecb7f8e6e9129e\":{\"balance\":\"0x10f0d293cc7a5880000\"},\"6a13d5e32c1fd26d7e91ff6e053160a89b2c8aad\":{\"balance\":\"0x2e62f20a69be40000\"},\"6a2e86469a5bf37cee82e88b4c3863895d28fcaf\":{\"balance\":\"0x1c229266385bbc0000\"},\"6a3694424c7cc6b8bcd9bccaba540cc1f5df18d7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6a42ca971c6578d5ade295c3e7f4ad331dd3424e\":{\"balance\":\"0x14542ba12a337c00000\"},\"6a44af96b3f032ae641beb67f4b6c83342d37c5d\":{\"balance\":\"0x19274b259f6540000\"},\"6a4c8907b600248057b1e46354b19bdc859c991a\":{\"balance\":\"0x1158e460913d00000\"},\"6a514e6242f6b68c137e97fea1e78eb555a7e5f7\":{\"balance\":\"0x1158e460913d00000\"},\"6a53d41ae4a752b21abed5374649953a513de5e5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6a6159074ab573e0ee581f0f3df2d6a594629b74\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"6a6337833f8f6a6bf10ca7ec21aa810ed444f4cb\":{\"balance\":\"0x37bd24345ce8a40000\"},\"6a6353b971589f18f2955cba28abe8acce6a5761\":{\"balance\":\"0xa2a15d09519be00000\"},\"6a63fc89abc7f36e282d80787b7b04afd6553e71\":{\"balance\":\"0x8ac7230489e800000\"},\"6a679e378fdce6bfd97fe62f043c6f6405d79e99\":{\"balance\":\"0xd8d726b7177a800000\"},\"6a686bf220b593deb9b7324615fb9144ded3f39d\":{\"balance\":\"0x4f2591f896a6500000\"},\"6a6b18a45a76467e2e5d5a2ef911c3e12929857b\":{\"balance\":\"0x115d3a99a9614f400000\"},\"6a74844d8e9cb5581c45079a2e94462a6cee8821\":{\"balance\":\"0x3ab53a552dd4c90000\"},\"6a7b2e0d88867ff15d207c222bebf94fa6ce8397\":{\"balance\":\"0xcb49b44ba602d800000\"},\"6a7c252042e7468a3ff773d6450bba85efa26391\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"6a8a4317c45faa0554ccdb482548183e295a24b9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6a8cea2de84a8df997fd3f84e3083d93de57cda9\":{\"balance\":\"0x56be03ca3e47d8000\"},\"6a9758743b603eea3aa0524b42889723c4153948\":{\"balance\":\"0x22385a827e815500000\"},\"6aa5732f3b86fb8c81efbe6b5b47b563730b06c8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6ab323ae5056ed0a453072c5abe2e42fcf5d7139\":{\"balance\":\"0x2fb474098f67c00000\"},\"6ab5b4c41cddb829690c2fda7f20c85e629dd5d5\":{\"balance\":\"0x64d4af714c32900000\"},\"6ac40f532dfee5118117d2ad352da77d4f6da2c8\":{\"balance\":\"0x15af1d78b58c400000\"},\"6ac4d4be2db0d99da3faaaf7525af282051d6a90\":{\"balance\":\"0x458ca58a962b28000\"},\"6acddca3cd2b4990e25cd65c24149d0912099e79\":{\"balance\":\"0xa2a1e07c9f6c908000\"},\"6ad90be252d9cd464d998125fab693060ba8e429\":{\"balance\":\"0xd8d726b7177a800000\"},\"6add932193cd38494aa3f03aeccc4b7ab7fabca2\":{\"balance\":\"0x4db73254763000000\"},\"6ae57f27917c562a132a4d1bf7ec0ac785832926\":{\"balance\":\"0x14542ba12a337c00000\"},\"6aeb9f74742ea491813dbbf0d6fcde1a131d4db3\":{\"balance\":\"0x17e554308aa0300000\"},\"6af235d2bbe050e6291615b71ca5829658810142\":{\"balance\":\"0xa2a15d09519be00000\"},\"6af6c7ee99df271ba15bf384c0b764adcb4da182\":{\"balance\":\"0x36356633ebd8ea0000\"},\"6af8e55969682c715f48ad4fc0fbb67eb59795a3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6af940f63ec9b8d876272aca96fef65cdacecdea\":{\"balance\":\"0xa2a15d09519be00000\"},\"6af9f0dfeeaebb5f64bf91ab771669bf05295553\":{\"balance\":\"0x15af1d78b58c400000\"},\"6aff1466c2623675e3cb0e75e423d37a25e442eb\":{\"balance\":\"0x5dc892aa1131c80000\"},\"6b0da25af267d7836c226bcae8d872d2ce52c941\":{\"balance\":\"0x14542ba12a337c00000\"},\"6b10f8f8b3e3b60de90aa12d155f9ff5ffb22c50\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6b17598a8ef54f797ae515ccb6517d1859bf8011\":{\"balance\":\"0x56bc75e2d63100000\"},\"6b20c080606a79c73bd8e75b11717a4e8db3f1c3\":{\"balance\":\"0x103f735803f0140000\"},\"6b2284440221ce16a8382de5ff0229472269deec\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6b30f1823910b86d3acb5a6afc9defb6f3a30bf8\":{\"balance\":\"0xe3aeb5737240a00000\"},\"6b38de841fad7f53fe02da115bd86aaf662466bd\":{\"balance\":\"0x5dc892aa1131c80000\"},\"6b4b99cb3fa9f7b74ce3a48317b1cd13090a1a7a\":{\"balance\":\"0x31b327e695de20000\"},\"6b5ae7bf78ec75e90cb503c778ccd3b24b4f1aaf\":{\"balance\":\"0x2b5e3af16b18800000\"},\"6b63a2dfb2bcd0caec0022b88be30c1451ea56aa\":{\"balance\":\"0x2bdb6bf91f7f4c8000\"},\"6b6577f3909a4d6de0f411522d4570386400345c\":{\"balance\":\"0x65ea3db75546600000\"},\"6b72a8f061cfe6996ad447d3c72c28c0c08ab3a7\":{\"balance\":\"0xe78c6ac79912620000\"},\"6b760d4877e6a627c1c967bee451a8507ddddbab\":{\"balance\":\"0x3154c9729d05780000\"},\"6b83bae7b565244558555bcf4ba8da2011891c17\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6b925dd5d8ed6132ab6d0860b82c44e1a51f1fee\":{\"balance\":\"0x503b203e9fba200000\"},\"6b94615db750656ac38c7e1cf29a9d13677f4e15\":{\"balance\":\"0x28a857425466f800000\"},\"6b951a43274eeafc8a0903b0af2ec92bf1efc839\":{\"balance\":\"0x56bc75e2d63100000\"},\"6b992521ec852370848ad697cc2df64e63cc06ff\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6ba8f7e25fc2d871618e24e40184199137f9f6aa\":{\"balance\":\"0x15af64869a6bc20000\"},\"6ba9b21b35106be159d1c1c2657ac56cd29ffd44\":{\"balance\":\"0xf2dc7d47f156000000\"},\"6baf7a2a02ae78801e8904ad7ac05108fc56cff6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6bb2aca23fa1626d18efd6777fb97db02d8e0ae4\":{\"balance\":\"0x878678326eac9000000\"},\"6bb4a661a33a71d424d49bb5df28622ed4dffcf4\":{\"balance\":\"0x222c8eb3ff66400000\"},\"6bb50813146a9add42ee22038c9f1f7469d47f47\":{\"balance\":\"0xada55474b81340000\"},\"6bbc3f358a668dd1a11f0380f3f73108426abd4a\":{\"balance\":\"0xd8d726b7177a800000\"},\"6bbd1e719390e6b91043f8b6b9df898ea8001b34\":{\"balance\":\"0x6c6c4fa6c3da588000\"},\"6bc85acd5928722ef5095331ee88f484b8cf8357\":{\"balance\":\"0x9c2007651b2500000\"},\"6bd3e59f239fafe4776bb9bddd6bee83ba5d9d9f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6bd457ade051795df3f2465c3839aed3c5dee978\":{\"balance\":\"0x3634bf39ab98788000\"},\"6be16313643ebc91ff9bb1a2e116b854ea933a45\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"6be7595ea0f068489a2701ec4649158ddc43e178\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6be9030ee6e2fbc491aca3de4022d301772b7b7d\":{\"balance\":\"0x1731790534df20000\"},\"6bec311ad05008b4af353c958c40bd06739a3ff3\":{\"balance\":\"0x377f62a0f0a62700000\"},\"6bf7b3c065f2c1e7c6eb092ba0d15066f393d1b8\":{\"balance\":\"0x15af1d78b58c400000\"},\"6bf86f1e2f2b8032a95c4d7738a109d3d0ed8104\":{\"balance\":\"0x62a992e53a0af00000\"},\"6c05e34e5ef2f42ed09deff1026cd66bcb6960bb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6c08a6dc0173c7342955d1d3f2c065d62f83aec7\":{\"balance\":\"0x1158e460913d00000\"},\"6c0ae9f043c834d44271f13406593dfe094f389f\":{\"balance\":\"0x52442ae133b62a8000\"},\"6c0cc917cbee7d7c099763f14e64df7d34e2bf09\":{\"balance\":\"0xd8d726b7177a80000\"},\"6c0e712f405c59725fe829e9774bf4df7f4dd965\":{\"balance\":\"0xc2868889ca68a440000\"},\"6c101205b323d77544d6dc52af37aca3cec6f7f1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"6c15ec3520bf8ebbc820bd0ff19778375494cf9d\":{\"balance\":\"0x6cb7e74867d5e60000\"},\"6c1ddd33c81966dc8621776071a4129482f2c65f\":{\"balance\":\"0x878678326eac9000000\"},\"6c25327f8dcbb2f45e561e86e35d8850e53ab059\":{\"balance\":\"0x3bcdf9bafef2f00000\"},\"6c2e9be6d4ab450fd12531f33f028c614674f197\":{\"balance\":\"0xc2127af858da700000\"},\"6c359e58a13d4578a9338e335c67e7639f5fb4d7\":{\"balance\":\"0xbd15b94fc8b280000\"},\"6c3d18704126aa99ee3342ce60f5d4c85f1867cd\":{\"balance\":\"0x2b5e3af16b1880000\"},\"6c474bc66a54780066aa4f512eefa773abf919c7\":{\"balance\":\"0x5188315f776b80000\"},\"6c4e426e8dc005dfa3516cb8a680b02eea95ae8e\":{\"balance\":\"0x487a9a304539440000\"},\"6c52cf0895bb35e656161e4dc46ae0e96dd3e62c\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"6c5422fb4b14e6d98b6091fdec71f1f08640419d\":{\"balance\":\"0x15af1d78b58c400000\"},\"6c5c3a54cda7c2f118edba434ed81e6ebb11dd7a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6c63f84556d290bfcd99e434ee9997bfd779577a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6c63fc85029a2654d79b2bea4de349e4524577c5\":{\"balance\":\"0x23c757072b8dd00000\"},\"6c6564e5c9c24eaaa744c9c7c968c9e2c9f1fbae\":{\"balance\":\"0x499b42a21139640000\"},\"6c67d6db1d03516c128b8ff234bf3d49b26d2941\":{\"balance\":\"0x152d02c7e14af6800000\"},\"6c67e0d7b62e2a08506945a5dfe38263339f1f22\":{\"balance\":\"0x6acb3df27e1f880000\"},\"6c6aa0d30b64721990b9504a863fa0bfb5e57da7\":{\"balance\":\"0x925e06eec972b00000\"},\"6c714a58fff6e97d14b8a5e305eb244065688bbd\":{\"balance\":\"0xd8d726b7177a800000\"},\"6c800d4b49ba07250460f993b8cbe00b266a2553\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"6c808cabb8ff5fbb6312d9c8e84af8cf12ef0875\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"6c822029218ac8e98a260c1e064029348839875b\":{\"balance\":\"0x10f97b787e1e3080000\"},\"6c84cba77c6db4f7f90ef13d5ee21e8cfc7f8314\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6c8687e3417710bb8a93559021a1469e6a86bc77\":{\"balance\":\"0x25b2da278d96b7b8000\"},\"6c882c27732cef5c7c13a686f0a2ea77555ac289\":{\"balance\":\"0x152d02c7e14af6800000\"},\"6ca5de00817de0cedce5fd000128dede12648b3c\":{\"balance\":\"0x1158e460913d00000\"},\"6ca6a132ce1cd288bee30ec7cfeffb85c1f50a54\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6cb11ecb32d3ce829601310636f5a10cf7cf9b5f\":{\"balance\":\"0x43fe8949c3801f50000\"},\"6cc1c878fa6cde8a9a0b8311247e741e4642fe6d\":{\"balance\":\"0x35659ef93f0fc40000\"},\"6ccb03acf7f53ce87aadcc21a9932de915f89804\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"6cd212aee04e013f3d2abad2a023606bfb5c6ac7\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"6cd228dc712169307fe27ceb7477b48cfc8272e5\":{\"balance\":\"0x434ea94db8a500000\"},\"6ce1b0f6adc47051e8ab38b39edb4186b03babcc\":{\"balance\":\"0x41799794cd24cc0000\"},\"6ceae3733d8fa43d6cd80c1a96e8eb93109c83b7\":{\"balance\":\"0x102794ad20da680000\"},\"6d0569e5558fc7df2766f2ba15dc8aeffc5beb75\":{\"balance\":\"0xd8e6001e6c302b0000\"},\"6d120f0caae44fd94bcafe55e2e279ef96ba5c7a\":{\"balance\":\"0xd8d726b7177a800000\"},\"6d1456fff0104ee844a3314737843338d24cd66c\":{\"balance\":\"0x7b06ce87fdd680000\"},\"6d20ef9704670a500bb269b5832e859802049f01\":{\"balance\":\"0x70c1cc73b00c80000\"},\"6d2f976734b9d0070d1883cf7acab8b3e4920fc1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"6d39a9e98f81f769d73aad2cead276ac1387babe\":{\"balance\":\"0x155bd9307f9fe80000\"},\"6d3b7836a2b9d899721a4d237b522385dce8dfcd\":{\"balance\":\"0x3636c25e66ece70000\"},\"6d3f2ba856ccbb0237fa7661156b14b013f21240\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6d4008b4a888a826f248ee6a0b0dfde9f93210b9\":{\"balance\":\"0x127fcb8afae20d00000\"},\"6d40ca27826d97731b3e86effcd7b92a4161fe89\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6d44974a31d187eda16ddd47b9c7ec5002d61fbe\":{\"balance\":\"0x32f51edbaaa3300000\"},\"6d4b5c05d06a20957e1748ab6df206f343f92f01\":{\"balance\":\"0x21f360699bf825f8000\"},\"6d4cbf3d8284833ae99344303e08b4d614bfda3b\":{\"balance\":\"0x28a857425466f800000\"},\"6d59b21cd0e2748804d9abe064eac2bef0c95f27\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6d63d38ee8b90e0e6ed8f192eda051b2d6a58bfd\":{\"balance\":\"0x1a055690d9db80000\"},\"6d6634b5b8a40195d949027af4828802092ceeb6\":{\"balance\":\"0xa2a15d09519be00000\"},\"6d7d1c949511f88303808c60c5ea0640fcc02683\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"6d846dc12657e91af25008519c3e857f51707dd6\":{\"balance\":\"0xf8d30bc92342f80000\"},\"6d9193996b194617211106d1635eb26cc4b66c6c\":{\"balance\":\"0x15aa1e7e9dd51c0000\"},\"6d9997509882027ea947231424bedede2965d0ba\":{\"balance\":\"0x6c81c7b31195e00000\"},\"6da0ed8f1d69339f059f2a0e02471cb44fb8c3bb\":{\"balance\":\"0x32bc38bb63a8160000\"},\"6db72bfd43fef465ca5632b45aab7261404e13bf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6dbe8abfa1742806263981371bf3d35590806b6e\":{\"balance\":\"0x43c33c1937564800000\"},\"6dc3f92baa1d21dab7382b893261a0356fa7c187\":{\"balance\":\"0x5dc892aa1131c80000\"},\"6dc7053a718616cfc78bee6382ee51add0c70330\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6dcc7e64fcafcbc2dc6c0e5e662cb347bffcd702\":{\"balance\":\"0x43c33c1937564800000\"},\"6dda5f788a6c688ddf921fa3852eb6d6c6c62966\":{\"balance\":\"0x22b1c8c1227a00000\"},\"6ddb6092779d5842ead378e21e8120fd4c6bc132\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6ddfef639155daab0a5cb4953aa8c5afaa880453\":{\"balance\":\"0x62a992e53a0af00000\"},\"6de02f2dd67efdb7393402fa9eaacbcf589d2e56\":{\"balance\":\"0x40138b917edfb80000\"},\"6de4b581385cf7fc9fe8c77d131fe2ee7724c76a\":{\"balance\":\"0x7d2997733dcce40000\"},\"6de4d15219182faf3aa2c5d4d2595ff23091a727\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"6dedf62e743f4d2c2a4b87a787f5424a7aeb393c\":{\"balance\":\"0x9c2007651b2500000\"},\"6df24f6685a62f791ba337bf3ff67e91f3d4bc3a\":{\"balance\":\"0x756b49d40a48180000\"},\"6df5c84f7b909aab3e61fe0ecb1b3bf260222ad2\":{\"balance\":\"0xd8d726b7177a800000\"},\"6dff90e6dc359d2590882b1483edbcf887c0e423\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6e01e4ad569c95d007ada30d5e2db12888492294\":{\"balance\":\"0xd8d726b7177a800000\"},\"6e073b66d1b8c66744d88096a8dd99ec7e0228da\":{\"balance\":\"0xd8d726b7177a800000\"},\"6e0ee70612c976287d499ddfa6c0dcc12c06deea\":{\"balance\":\"0x70bd5b95621460000\"},\"6e12b51e225b4a4372e59ad7a2a1a13ea3d3a137\":{\"balance\":\"0x30046c8cc775f040000\"},\"6e1a046caf5b4a57f4fd4bc173622126b4e2fd86\":{\"balance\":\"0x61093d7c2c6d380000\"},\"6e1ea4b183e252c9bb7767a006d4b43696cb8ae9\":{\"balance\":\"0xff3783c85eed08000\"},\"6e255b700ae7138a4bacf22888a9e2c00a285eec\":{\"balance\":\"0xd8d726b7177a800000\"},\"6e270ad529f1f0b8d9cb6d2427ec1b7e2dc64a74\":{\"balance\":\"0xad78ebc5ac6200000\"},\"6e2eab85dc89fe29dc0aa1853247dab43a523d56\":{\"balance\":\"0x4563918244f400000\"},\"6e3a51db743d334d2fe88224b5fe7c008e80e624\":{\"balance\":\"0x5bf0ba6634f680000\"},\"6e4c2ab7db026939dbd3bc68384af660a61816b2\":{\"balance\":\"0x90d972f32323c0000\"},\"6e4d2e39c8836629e5b487b1918a669aebdd9536\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6e5c2d9b1c546a86eefd5d0a5120c9e4e730190e\":{\"balance\":\"0xad201a6794ff80000\"},\"6e60aee1a78f8eda8b424c73e353354ae67c3042\":{\"balance\":\"0xbd35a48d9919e60000\"},\"6e64e6129f224e378c0e6e736a7e7a06c211e9ec\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6e6d5bbbb9053b89d744a27316c2a7b8c09b547d\":{\"balance\":\"0x3152710a023e6d8000\"},\"6e72b2a1186a8e2916543b1cb36a68870ea5d197\":{\"balance\":\"0xa1544be879ea80000\"},\"6e761eaa0f345f777b5441b73a0fa5b56b85f22d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6e79edd4845b076e4cd88d188b6e432dd93f35aa\":{\"balance\":\"0x33c5499031720c0000\"},\"6e8212b722afd408a7a73ed3e2395ee6454a0330\":{\"balance\":\"0x89e917994f71c0000\"},\"6e84876dbb95c40b6656e42ba9aea08a993b54dc\":{\"balance\":\"0x3bbc60e3b6cbbe0000\"},\"6e84c2fd18d8095714a96817189ca21cca62bab1\":{\"balance\":\"0x127b6c702621cd8000\"},\"6e866d032d405abdd65cf651411d803796c22311\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6e899e59a9b41ab7ea41df7517860f2acb59f4fd\":{\"balance\":\"0x43c33c1937564800000\"},\"6e89c51ea6de13e06cdc748b67c4410fe9bcab03\":{\"balance\":\"0xd8d726b7177a800000\"},\"6e8a26689f7a2fdefd009cbaaa5310253450daba\":{\"balance\":\"0x6f213717bad8d30000\"},\"6e96faeda3054302c45f58f161324c99a3eebb62\":{\"balance\":\"0x1158e460913d00000\"},\"6eb0a5a9ae96d22cf01d8fd6483b9f38f08c2c8b\":{\"balance\":\"0xd8d726b7177a800000\"},\"6eb3819617404058268f0c3cff3596bfe9148c1c\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"6eb5578a6bb7c32153195b0d8020a6914852c059\":{\"balance\":\"0x8bc2abf40221f4800000\"},\"6ebb5e6957aa821ef659b6018a393a504cae4450\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6ebcf9957f5fc5e985add475223b04b8c14a7aed\":{\"balance\":\"0x5dc892aa1131c80000\"},\"6ec3659571b11f889dd439bcd4d67510a25be57e\":{\"balance\":\"0x6aaf7c8516d0c0000\"},\"6ec89b39f9f5276a553e8da30e6ec17aa47eefc7\":{\"balance\":\"0x18424f5f0b1b4e0000\"},\"6ec96d13bdb24dc7a557293f029e02dd74b97a55\":{\"balance\":\"0xd8d726b7177a800000\"},\"6ecaefa6fc3ee534626db02c6f85a0c395571e77\":{\"balance\":\"0x2086ac351052600000\"},\"6ed2a12b02f8c688c7b5d3a6ea14d63687dab3b6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6ed884459f809dfa1016e770edaf3e9fef46fa30\":{\"balance\":\"0xb852d6782093f10000\"},\"6edf7f5283725c953ee64317f66188af1184b033\":{\"balance\":\"0x1b464311d45a6880000\"},\"6ee8aad7e0a065d8852d7c3b9a6e5fdc4bf50c00\":{\"balance\":\"0x1158e460913d00000\"},\"6eefdc850e87b715c72791773c0316c3559b58a4\":{\"balance\":\"0xd8d726b7177a800000\"},\"6ef9e8c9b6217d56769af97dbb1c8e1b8be799d2\":{\"balance\":\"0x9ddc1e3b901180000\"},\"6efba8fb2ac5b6730729a972ec224426a287c3ad\":{\"balance\":\"0xf5985fbcbe1680000\"},\"6efd90b535e00bbd889fda7e9c3184f879a151db\":{\"balance\":\"0x22385a827e815500000\"},\"6f051666cb4f7bd2b1907221b829b555d7a3db74\":{\"balance\":\"0x5f68e8131ecf800000\"},\"6f0edd23bcd85f6015f9289c28841fe04c83efeb\":{\"balance\":\"0x10910d4cdc9f60000\"},\"6f137a71a6f197df2cbbf010dcbd3c444ef5c925\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f176065e88e3c6fe626267d18a088aaa4db80bc\":{\"balance\":\"0xbed1d0263d9f000000\"},\"6f18ec767e320508195f1374500e3f2e125689ff\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6f1f4907b8f61f0c51568d692806b382f50324f5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f24c9af2b763480515d1b0951bb77a540f1e3f9\":{\"balance\":\"0x6acb3df27e1f880000\"},\"6f2576da4de283bbe8e3ee69ddd66e5e711db3f5\":{\"balance\":\"0x44591d67fecc800000\"},\"6f29bb375be5ed34ed999bb830ee2957dde76d16\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f2a31900e240395b19f159c1d00dfe4d898ebdf\":{\"balance\":\"0x6c660645aa47180000\"},\"6f2a42e6e033d01061131929f7a6ee1538021e52\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f39cc37caaa2ddc9b610f6131e0619fae772a3c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"6f44ca09f0c6a8294cbd519cdc594ad42c67579f\":{\"balance\":\"0x2b5e3af16b1880000\"},\"6f50929777824c291a49c46dc854f379a6bea080\":{\"balance\":\"0x138400eca364a00000\"},\"6f6cf20649a9e973177ac67dbadee4ebe5c7bdda\":{\"balance\":\"0x11363297d01a8600000\"},\"6f791d359bc3536a315d6382b88311af8ed6da47\":{\"balance\":\"0x4fcc1a89027f00000\"},\"6f794dbdf623daa6e0d00774ad6962737c921ea4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f7ac681d45e418fce8b3a1db5bc3be6f06c9849\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"6f81f3abb1f933b1df396b8e9cc723a89b7c9806\":{\"balance\":\"0xf2dc7d47f15600000\"},\"6f8f0d15cc96fb7fe94f1065bc6940f8d12957b2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6f92d6e4548c78996509ee684b2ee29ba3c532b4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"6fa60df818a5446418b1bbd62826e0b9825e1318\":{\"balance\":\"0x2cb92cc8f6714400000\"},\"6fa6388d402b30afe59934c3b9e13d1186476018\":{\"balance\":\"0x24521e2a3017b80000\"},\"6fa72015fa78696efd9a86174f7f1f21019286b1\":{\"balance\":\"0x487a9a304539440000\"},\"6fc25e7e00ca4f60a9fe6f28d1fde3542e2d1079\":{\"balance\":\"0x2aef353bcddd600000\"},\"6fc53662371dca587b59850de78606e2359df383\":{\"balance\":\"0x9c2007651b2500000\"},\"6fcc2c732bdd934af6ccd16846fb26ef89b2aa9b\":{\"balance\":\"0x21e2b1d42261d490000\"},\"6fd4e0f3f32bee6d3767fdbc9d353a6d3aab7899\":{\"balance\":\"0x25b064a875ea940000\"},\"6fd947d5a73b175008ae6ee8228163da289b167d\":{\"balance\":\"0x65a4da25d3016c00000\"},\"6fd98e563d12ce0fd60f4f1f850ae396a9823c02\":{\"balance\":\"0x445be3f2ef87940000\"},\"6fddbd9bca66e28765c2162c8433548c1052ed11\":{\"balance\":\"0x1184429b82a818800000\"},\"6ff5d361b52ad0b68b1588607ec304ae5665fc98\":{\"balance\":\"0x692ae8897081d00000\"},\"6ff6cc90d649de4e96cffee1077a5b302a848dcb\":{\"balance\":\"0x18ce79c78802c0000\"},\"6ffe5cf82cc9ea5e36cad7c2974ce7249f3749e6\":{\"balance\":\"0x692ae8897081d00000\"},\"7005a772282b1f62afda63f89b5dc6ab64c84cb9\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"700711e311bb947355f755b579250ca7fd765a3e\":{\"balance\":\"0x61093d7c2c6d380000\"},\"7010be2df57bd0ab9ae8196cd50ab0c521aba9f9\":{\"balance\":\"0x6acb3df27e1f880000\"},\"7023c70956e04a92d70025aad297b539af355869\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7025965d2b88da197d4459be3dc9386344cc1f31\":{\"balance\":\"0x6cb7e74867d5e60000\"},\"702802f36d00250fab53adbcd696f0176f638a49\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"704819d2e44d6ed1da25bfce84c49fcca25613e5\":{\"balance\":\"0x15af1d78b58c400000\"},\"704a6eb41ba34f13addde7d2db7df04915c7a221\":{\"balance\":\"0x62a992e53a0af00000\"},\"704ab1150d5e10f5e3499508f0bf70650f028d4b\":{\"balance\":\"0xd8d726b7177a800000\"},\"704ae21d762d6e1dde28c235d13104597236db1a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"704d243c2978e46c2c86adbecd246e3b295ff633\":{\"balance\":\"0x6d121bebf795f00000\"},\"704d5de4846d39b53cd21d1c49f096db5c19ba29\":{\"balance\":\"0x83d6c7aab63600000\"},\"705ddd38355482b8c7d3b515bda1500dd7d7a817\":{\"balance\":\"0x15af1d78b58c400000\"},\"70616e2892fa269705b2046b8fe3e72fa55816d3\":{\"balance\":\"0x43c33c1937564800000\"},\"70670fbb05d33014444b8d1e8e7700258b8caa6d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7081fa6baad6cfb7f51b2cca16fb8970991a64ba\":{\"balance\":\"0xcaec005f6c0f68000\"},\"7085ae7e7e4d932197b5c7858c00a3674626b7a5\":{\"balance\":\"0x14542ba12a337c00000\"},\"7086b4bde3e35d4aeb24b825f1a215f99d85f745\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"708a2af425ceb01e87ffc1be54c0f532b20eacd6\":{\"balance\":\"0x745d483b1f5a18000\"},\"708ea707bae4357f1ebea959c3a250acd6aa21b3\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"708fa11fe33d85ad1befcbae3818acb71f6a7d7e\":{\"balance\":\"0xfc936392801c0000\"},\"7091303116d5f2389b23238b4d656a8596d984d3\":{\"balance\":\"0x3b4e7e80aa58330000\"},\"7099d12f6ec656899b049a7657065d62996892c8\":{\"balance\":\"0x15af1d78b58c400000\"},\"709fe9d2c1f1ce42207c9585044a60899f35942f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"70a03549aa6168e97e88a508330a5a0bea74711a\":{\"balance\":\"0x487a9a304539440000\"},\"70a4067d448cc25dc8e70e651cea7cf84e92109e\":{\"balance\":\"0x98a7d9b8314c00000\"},\"70ab34bc17b66f9c3b63f151274f2a727c539263\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"70c213488a020c3cfb39014ef5ba6404724bcaa3\":{\"balance\":\"0x692ae8897081d00000\"},\"70d25ed2c8ada59c088cf70dd22bf2db93acc18a\":{\"balance\":\"0x39474545e4adbc0000\"},\"70e5e9da735ff077249dcb9aaf3db2a48d9498c0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"70fee08b00c6c2c04a3c625c1ff77caf1c32df01\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7101bd799e411cde14bdfac25b067ac890eab8e8\":{\"balance\":\"0x4e9b8aae48de470000\"},\"7109dd011d15f3122d9d3a27588c10d77744508b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"710b0274d712c77e08a5707d6f3e70c0ce3d92cf\":{\"balance\":\"0x15af1d78b58c4000000\"},\"710be8fd5e2918468be2aabea80d828435d79612\":{\"balance\":\"0xf43fc2c04ee00000\"},\"71135d8f05963c905a4a07922909235a896a52ea\":{\"balance\":\"0xa2a15d09519be00000\"},\"711ecf77d71b3d0ea95ce4758afecdb9c131079d\":{\"balance\":\"0x29331e6558f0e00000\"},\"71213fca313404204ecba87197741aa9dfe96338\":{\"balance\":\"0x340aad21b3b700000\"},\"712b76510214dc620f6c3a1dd29aa22bf6d214fb\":{\"balance\":\"0x14542ba12a337c00000\"},\"712ff7370a13ed360973fedc9ff5d2c93a505e9e\":{\"balance\":\"0xd5967be4fc3f100000\"},\"7133843a78d939c69d4486e10ebc7b602a349ff7\":{\"balance\":\"0x11d5cacce21f840000\"},\"7148aef33261d8031fac3f7182ff35928daf54d9\":{\"balance\":\"0xde42ee1544dd900000\"},\"7163758cbb6c4c525e0414a40a049dcccce919bb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7168b3bb8c167321d9bdb023a6e9fd11afc9afd9\":{\"balance\":\"0x61093d7c2c6d380000\"},\"7169724ee72271c534cad6420fb04ee644cb86fe\":{\"balance\":\"0x163c2b40dba5520000\"},\"716ad3c33a9b9a0a18967357969b94ee7d2abc10\":{\"balance\":\"0x1a2117fe412a480000\"},\"716ba01ead2a91270635f95f25bfaf2dd610ca23\":{\"balance\":\"0x979e7012056aa780000\"},\"716d50cca01e938500e6421cc070c3507c67d387\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"71762c63678c18d1c6378ce068e666381315147e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"71784c105117c1f68935797fe159abc74e43d16a\":{\"balance\":\"0x6c81c7b31195e00000\"},\"7179726f5c71ae1b6d16a68428174e6b34b23646\":{\"balance\":\"0x18ea250097cbaf60000\"},\"717cf9beab3638308ded7e195e0c86132d163fed\":{\"balance\":\"0x3326ee6f865f4220000\"},\"7180b83ee5574317f21c8072b191d895d46153c3\":{\"balance\":\"0x18efc84ad0c7b00000\"},\"71946b7117fc915ed107385f42d99ddac63249c2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"719e891fbcc0a33e19c12dc0f02039ca05b801df\":{\"balance\":\"0x14f5538463a1b540000\"},\"71c7230a1d35bdd6819ed4b9a88e94a0eb0786dd\":{\"balance\":\"0xeca08b353d24140000\"},\"71d2cc6d02578c65f73c575e76ce8fbcfadcf356\":{\"balance\":\"0x3ecc078688a480000\"},\"71d9494e50c5dd59c599dba3810ba1755e6537f0\":{\"balance\":\"0xd8d726b7177a800000\"},\"71e38ff545f30fe14ca863d4f5297fd48c73a5ce\":{\"balance\":\"0xc2127af858da700000\"},\"71ea5b11ad8d29b1a4cb67bf58ca6c9f9c338c16\":{\"balance\":\"0x56bc75e2d631000000\"},\"71ec3aec3f8f9221f9149fede06903a0f9a232f2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"71f2cdd1b046e2da2fbb5a26723422b8325e25a3\":{\"balance\":\"0x56b394263a40c0000\"},\"71fa22cc6d33206b7d701a163a0dab31ae4d31d6\":{\"balance\":\"0x57473d05dabae80000\"},\"7201d1c06920cd397ae8ad869bcda6e47ffb1b5a\":{\"balance\":\"0x1158e460913d00000\"},\"72072a0ef1cff3d567cdd260e708ddc11cbc9a31\":{\"balance\":\"0x56bc75e2d63100000\"},\"72094f3951ffc9771dced23ada080bcaf9c7cca7\":{\"balance\":\"0x14542ba12a337c00000\"},\"720994dbe56a3a95929774e20e1fe525cf3704e4\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"720e6b22bf430966fa32b6acb9a506eebf662c61\":{\"balance\":\"0x83d6c7aab63600000\"},\"721158be5762b119cc9b2035e88ee4ee78f29b82\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"721f9d17e5a0e74205947aeb9bc6a7938961038f\":{\"balance\":\"0x2d041d705a2c60000\"},\"7222fec7711781d26eaa4e8485f7aa3fac442483\":{\"balance\":\"0x18b84570022a200000\"},\"72393d37b451effb9e1ff3b8552712e2a970d8c2\":{\"balance\":\"0x35659ef93f0fc40000\"},\"723d8baa2551d2addc43c21b45e8af4ca2bfb2c2\":{\"balance\":\"0x5f68e8131ecf800000\"},\"72402300e81d146c2e644e2bbda1da163ca3fb56\":{\"balance\":\"0x17b7883c06916600000\"},\"72480bede81ad96423f2228b5c61be44fb523100\":{\"balance\":\"0x15af1d78b58c4000000\"},\"724ce858857ec5481c86bd906e83a04882e5821d\":{\"balance\":\"0xa2a15d09519be00000\"},\"726a14c90e3f84144c765cffacba3e0df11b48be\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7283cd4675da58c496556151dafd80c7f995d318\":{\"balance\":\"0x29331e6558f0e00000\"},\"7286e89cd9de8f7a8a00c86ffdb53992dd9251d1\":{\"balance\":\"0x692ae8897081d00000\"},\"728f9ab080157db3073156dbca1a169ef3179407\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7294c918b1aefb4d25927ef9d799e71f93a28e85\":{\"balance\":\"0xaadec983fcff40000\"},\"7294ec9da310bc6b4bbdf543b0ef45abfc3e1b4d\":{\"balance\":\"0x4a89f54ef0121c00000\"},\"729aad4627744e53f5d66309aa74448b3acdf46f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"72a2fc8675feb972fa41b50dffdbbae7fa2adfb7\":{\"balance\":\"0x9ab4fc67b528c80000\"},\"72a8260826294726a75bf39cd9aa9e07a3ea14cd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"72b05962fb2ad589d65ad16a22559eba1458f387\":{\"balance\":\"0x73f75d1a085ba0000\"},\"72b5633fe477fe542e742facfd690c137854f216\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"72b7a03dda14ca9c661a1d469fd33736f673c8e8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"72b904440e90e720d6ac1c2ad79c321dcc1c1a86\":{\"balance\":\"0x54069233bf7f780000\"},\"72b90a4dc097239492c5b9777dcd1e52ba2be2c2\":{\"balance\":\"0x14542ba12a337c00000\"},\"72bb27cb99f3e2c2cf90a98f707d30e4a201a071\":{\"balance\":\"0x58e7926ee858a00000\"},\"72c083beadbdc227c5fb43881597e32e83c26056\":{\"balance\":\"0x43c33c1937564800000\"},\"72cd048a110574482983492dfb1bd27942a696ba\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"72d03d4dfab3500cf89b86866f15d4528e14a195\":{\"balance\":\"0xf34b82fd8e91200000\"},\"72dabb5b6eed9e99be915888f6568056381608f8\":{\"balance\":\"0xb4c96c52cb4fe8000\"},\"72fb49c29d23a18950c4b2dc0ddf410f532d6f53\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"72feaf124579523954645b7fafff0378d1c8242e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7301dc4cf26d7186f2a11bf8b08bf229463f64a3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"730447f97ce9b25f22ba1afb36df27f9586beb9b\":{\"balance\":\"0x2c73c937742c500000\"},\"7306de0e288b56cfdf987ef0d3cc29660793f6dd\":{\"balance\":\"0x1b8abfb62ec8f60000\"},\"730d8763c6a4fd824ab8b859161ef7e3a96a1200\":{\"balance\":\"0x43c33c1937564800000\"},\"73128173489528012e76b41a5e28c68ba4e3a9d4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7313461208455455465445a459b06c3773b0eb30\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"732fead60f7bfdd6a9dec48125e3735db1b6654f\":{\"balance\":\"0x1158e460913d00000\"},\"734223d27ff23e5906caed22595701bb34830ca1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"73473e72115110d0c3f11708f86e77be2bb0983c\":{\"balance\":\"0x1158e460913d00000\"},\"7352586d021ad0cf77e0e928404a59f374ff4582\":{\"balance\":\"0xb8507a820728200000\"},\"73550beb732ba9ddafda7ae406e18f7feb0f8bb2\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"735b97f2fc1bd24b12076efaf3d1288073d20c8c\":{\"balance\":\"0x1158e460913d00000\"},\"735e328666ed5637142b3306b77ccc5460e72c3d\":{\"balance\":\"0x6ab8f37879c9910000\"},\"7363cd90fbab5bb8c49ac20fc62c398fe6fb744c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"736b44503dd2f6dd5469ff4c5b2db8ea4fec65d0\":{\"balance\":\"0x1104ee759f21e30000\"},\"736bf1402c83800f893e583192582a134eb532e9\":{\"balance\":\"0x21e19d293c01f260000\"},\"738ca94db7ce8be1c3056cd6988eb376359f3353\":{\"balance\":\"0x5665b96cf35acf00000\"},\"73914b22fc2f131584247d82be4fecbf978ad4ba\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"73932709a97f02c98e51b091312865122385ae8e\":{\"balance\":\"0x4d853c8f8908980000\"},\"7393cbe7f9ba2165e5a7553500b6e75da3c33abf\":{\"balance\":\"0x56bc75e2d63100000\"},\"73b4d499de3f38bf35aaf769a6e318bc6d123692\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"73bedd6fda7ba3272185087b6351fc133d484e37\":{\"balance\":\"0x11226bf9dce59780000\"},\"73bfe7710f31cab949b7a2604fbf5239cee79015\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"73cf80ae9688e1580e68e782cd0811f7aa494d2c\":{\"balance\":\"0x1a4aba225c207400000\"},\"73d7269ff06c9ffd33754ce588f74a966abbbbba\":{\"balance\":\"0x165c96647b38a200000\"},\"73d8fee3cb864dce22bb26ca9c2f086d5e95e63b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"73df3c3e7955f4f2d859831be38000b1076b3884\":{\"balance\":\"0x6acb3df27e1f880000\"},\"73e4a2b60cf48e8baf2b777e175a5b1e4d0c2d8f\":{\"balance\":\"0x56bc75e2d63100000\"},\"740af1eefd3365d78ba7b12cb1a673e06a077246\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"740bfd52e01667a3419b029a1b8e45576a86a2db\":{\"balance\":\"0x38ebad5cdc902800000\"},\"740f641614779dcfa88ed1d425d60db42a060ca6\":{\"balance\":\"0x3622c6760810570000\"},\"7412c9bc30b4df439f023100e63924066afd53af\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"741693c30376508513082020cc2b63e9fa92131b\":{\"balance\":\"0x410d586a20a4c00000\"},\"7421ce5be381738ddc83f02621974ff0686c79b8\":{\"balance\":\"0x58788cb94b1d800000\"},\"74316adf25378c10f576d5b41a6f47fa98fce33d\":{\"balance\":\"0x1238131e5c7ad50000\"},\"743651b55ef8429df50cf81938c2508de5c8870f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"743de50026ca67c94df54f066260e1d14acc11ac\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7445202f0c74297a004eb3726aa6a82dd7c02fa1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"744b03bba8582ae5498e2dc22d19949467ab53fc\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"744c0c77ba7f236920d1e434de5da33e48ebf02c\":{\"balance\":\"0x6acb3df27e1f880000\"},\"7450ff7f99eaa9116275deac68e428df5bbcd8b9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7456c5b2c5436e3e571008933f1805ccfe34e9ec\":{\"balance\":\"0x3635c9adc5dea00000\"},\"745ad3abc6eeeb2471689b539e789ce2b8268306\":{\"balance\":\"0x3d4194bea011928000\"},\"745aecbaf9bb39b74a67ea1ce623de368481baa6\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"745ccf2d819edbbddea8117b5c49ed3c2a066e93\":{\"balance\":\"0xd8d726b7177a800000\"},\"7462c89caa9d8d7891b2545def216f7464d5bb21\":{\"balance\":\"0x5eaed54a28b310000\"},\"74648caac748dd135cd91ea14c28e1bd4d7ff6ae\":{\"balance\":\"0xa80d24677efef00000\"},\"7471f72eeb300624eb282eab4d03723c649b1b58\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"747abc9649056d3926044d28c3ad09ed17b67d70\":{\"balance\":\"0x10f0dbae61009528000\"},\"747ff7943b71dc4dcdb1668078f83dd7cc4520c2\":{\"balance\":\"0x340aad21b3b700000\"},\"7480de62254f2ba82b578219c07ba5be430dc3cb\":{\"balance\":\"0x17da3a04c7b3e000000\"},\"7484d26becc1eea8c6315ec3ee0a450117dc86a0\":{\"balance\":\"0x28a857425466f800000\"},\"74863acec75d03d53e860e64002f2c165e538377\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7489cc8abe75cda4ef0d01cef2605e47eda67ab1\":{\"balance\":\"0x73f75d1a085ba0000\"},\"748c285ef1233fe4d31c8fb1378333721c12e27a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"749087ac0f5a97c6fad021538bf1d6cda18e0daa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7495ae78c0d90261e2140ef2063104731a60d1ed\":{\"balance\":\"0x1db50718925210000\"},\"749a4a768b5f237248938a12c623847bd4e688dc\":{\"balance\":\"0x3e733628714200000\"},\"749ad6f2b5706bbe2f689a44c4b640b58e96b992\":{\"balance\":\"0x56bc75e2d63100000\"},\"74a17f064b344e84db6365da9591ff1628257643\":{\"balance\":\"0x1158e460913d00000\"},\"74aeec915de01cc69b2cb5a6356feea14658c6c5\":{\"balance\":\"0xc9a95ee2986520000\"},\"74afe54902d615782576f8baac13ac970c050f6e\":{\"balance\":\"0x9a1aaa3a9fba70000\"},\"74b7e0228baed65957aebb4d916d333aae164f0e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"74bc4a5e2045f4ff8db184cf3a9b0c065ad807d2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"74bce9ec38362d6c94ccac26d5c0e13a8b3b1d40\":{\"balance\":\"0x363526410442f50000\"},\"74bf7a5ab59293149b5c60cf364263e5ebf1aa0d\":{\"balance\":\"0x6470c3e771e3c0000\"},\"74c73c90528a157336f1e7ea20620ae53fd24728\":{\"balance\":\"0x1e63a2e538f16e30000\"},\"74d1a4d0c7524e018d4e06ed3b648092b5b6af2c\":{\"balance\":\"0x2b5e3af16b1880000\"},\"74d366b07b2f56477d7c7077ac6fe497e0eb6559\":{\"balance\":\"0x10f0cf064dd59200000\"},\"74d37a51747bf8b771bfbf43943933d100d21483\":{\"balance\":\"0x3635c9adc5dea00000\"},\"74d671d99cbea1ab57906375b63ff42b50451d17\":{\"balance\":\"0x3635c9adc5dea00000\"},\"74ebf4425646e6cf81b109ce7bf4a2a63d84815f\":{\"balance\":\"0x22b1c8c1227a00000\"},\"74ed33acf43f35b98c9230b9e6642ecb5330839e\":{\"balance\":\"0x24f6dffb498d280000\"},\"74ef2869cbe608856045d8c2041118579f2236ea\":{\"balance\":\"0x33cd64591956e0000\"},\"74fc5a99c0c5460503a13b0509459da19ce7cd90\":{\"balance\":\"0xad78ebc5ac6200000\"},\"750bbb8c06bbbf240843cc75782ee02f08a97453\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"7514adbdc63f483f304d8e94b67ff3309f180b82\":{\"balance\":\"0x21c4a06e2d13598000\"},\"7517f16c28d132bb40e3ba36c6aef131c462da17\":{\"balance\":\"0xfc936392801c0000\"},\"751a2ca34e7187c163d28e3618db28b13c196d26\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"751abcb6cc033059911815c96fd191360ab0442d\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"7526e482529f0a14eec98871dddd0e721b0cd9a2\":{\"balance\":\"0x1158e460913d00000\"},\"7529f3797bb6a20f7ea6492419c84c867641d81c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"752a5ee232612cd3005fb26e5b597de19f776be6\":{\"balance\":\"0x127fcb8afae20d00000\"},\"752c9febf42f66c4787bfa7eb17cf5333bba5070\":{\"balance\":\"0x6a99f2b54fdd580000\"},\"7539333046deb1ef3c4daf50619993f444e1de68\":{\"balance\":\"0x40138b917edfb80000\"},\"7553aa23b68aa5f57e135fe39fdc235eaca8c98c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"755a60bf522fbd8fff9723446b7e343a7068567e\":{\"balance\":\"0x43c33c1937564800000\"},\"755f587e5efff773a220726a13d0f2130d9f896b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"75621865b6591365606ed378308c2d1def4f222c\":{\"balance\":\"0xa80d24677efef00000\"},\"75636cdb109050e43d5d6ec47e359e218e857eca\":{\"balance\":\"0x4d8b2276c8962280000\"},\"7566496162ba584377be040a4f87777a707acaeb\":{\"balance\":\"0xd8d726b7177a800000\"},\"756b84eb85fcc1f4fcdcc2b08db6a86e135fbc25\":{\"balance\":\"0xae8e7a0bb575d00000\"},\"756f45e3fa69347a9a973a725e3c98bc4db0b5a0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"757b65876dbf29bf911d4f0692a2c9beb1139808\":{\"balance\":\"0xdf93a59337d6dd8000\"},\"757fa55446c460968bb74b5ebca96c4ef2c709c5\":{\"balance\":\"0x3708baed3d68900000\"},\"75804aac64b4199083982902994d9c5ed8828f11\":{\"balance\":\"0x1e3d07b0a620e40000\"},\"7592c69d067b51b6cc639d1164d5578c60d2d244\":{\"balance\":\"0x1158e460913d00000\"},\"75abe5270f3a78ce007cf37f8fbc045d489b7bb1\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"75ac547017134c04ae1e11d60e63ec04d18db4ef\":{\"balance\":\"0x14542ba12a337c00000\"},\"75b0e9c942a4f0f6f86d3f95ff998022fa67963b\":{\"balance\":\"0x50c5e761a444080000\"},\"75b95696e8ec4510d56868a7c1a735c68b244890\":{\"balance\":\"0x15af1d78b58c4000000\"},\"75be8ff65e5788aec6b2a52d5fa7b1e7a03ba675\":{\"balance\":\"0x3abcdc5343d740000\"},\"75c11d024d12ae486c1095b7a7b9c4af3e8edeb9\":{\"balance\":\"0x1158e460913d00000\"},\"75c1ad23d23f24b384d0c3149177e86697610d21\":{\"balance\":\"0x15c5bcd6c288bbd0000\"},\"75c2ffa1bef54919d2097f7a142d2e14f9b04a58\":{\"balance\":\"0x90f358504032a10000\"},\"75d67ce14e8d29e8c2ffe381917b930b1aff1a87\":{\"balance\":\"0xa2a15d09519be00000\"},\"75de7e9352e90b13a59a5878ffecc7831cac4d82\":{\"balance\":\"0x9489237adb9a500000\"},\"75f7539d309e9039989efe2e8b2dbd865a0df088\":{\"balance\":\"0x855b5ba65c84f00000\"},\"7608f437b31f18bc0b64d381ae86fd978ed7b31f\":{\"balance\":\"0x2b5e3af16b1880000\"},\"760ff3354e0fde938d0fb5b82cef5ba15c3d2916\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"761a6e362c97fbbd7c5977acba2da74687365f49\":{\"balance\":\"0x9f74ae1f953d00000\"},\"761e6caec189c230a162ec006530193e67cf9d19\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"761f8a3a2af0a8bdbe1da009321fb29764eb62a1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"762998e1d75227fced7a70be109a4c0b4ed86414\":{\"balance\":\"0x1158e460913d00000\"},\"762d6f30dab99135e4eca51d5243d6c8621102d5\":{\"balance\":\"0xf498941e664280000\"},\"76331e30796ce664b2700e0d4153700edc869777\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"763886e333c56feff85be3951ab0b889ce262e95\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"763a7cbab70d7a64d0a7e52980f681472593490c\":{\"balance\":\"0x2086ac351052600000\"},\"763eece0b08ac89e32bfa4bece769514d8cb5b85\":{\"balance\":\"0xd8d726b7177a800000\"},\"7640a37f8052981515bce078da93afa4789b5734\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7641f7d26a86cddb2be13081810e01c9c83c4b20\":{\"balance\":\"0xb98bc829a6f90000\"},\"764692cccb33405dd0ab0c3379b49caf8e6221ba\":{\"balance\":\"0x1158e460913d00000\"},\"764d5212263aff4a2a14f031f04ec749dc883e45\":{\"balance\":\"0x6449e84e47a8a80000\"},\"764fc46d428b6dbc228a0f5f55c9508c772eab9f\":{\"balance\":\"0x581767ba6189c400000\"},\"76506eb4a780c951c74a06b03d3b8362f0999d71\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"765be2e12f629e6349b97d21b62a17b7c830edab\":{\"balance\":\"0x14542ba12a337c00000\"},\"76628150e2995b5b279fc83e0dd5f102a671dd1c\":{\"balance\":\"0x878678326eac9000000\"},\"766b3759e8794e926dac473d913a8fb61ad0c2c9\":{\"balance\":\"0x4b06dbbb40f4a0000\"},\"7670b02f2c3cf8fd4f4730f3381a71ea431c33c7\":{\"balance\":\"0xe7eeba3410b740000\"},\"767a03655af360841e810d83f5e61fb40f4cd113\":{\"balance\":\"0x35659ef93f0fc40000\"},\"767ac690791c2e23451089fe6c7083fe55deb62b\":{\"balance\":\"0x2c73c937742c500000\"},\"767fd7797d5169a05f7364321c19843a8c348e1e\":{\"balance\":\"0x104e70464b1580000\"},\"76846f0de03b5a76971ead298cdd08843a4bc6c6\":{\"balance\":\"0xd71b0fe0a28e0000\"},\"768498934e37e905f1d0e77b44b574bcf3ec4ae8\":{\"balance\":\"0x43c33c1937564800000\"},\"768ce0daa029b7ded022e5fc574d11cde3ecb517\":{\"balance\":\"0x1174a5cdf88bc80000\"},\"7693bdeb6fc82b5bca721355223175d47a084b4d\":{\"balance\":\"0x4a89f54ef0121c00000\"},\"76aaf8c1ac012f8752d4c09bb46607b6651d5ca8\":{\"balance\":\"0x1158e460913d00000\"},\"76ab87dd5a05ad839a4e2fc8c85aa6ba05641730\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"76afc225f4fa307de484552bbe1d9d3f15074c4a\":{\"balance\":\"0xa290b5c7ad39680000\"},\"76becae4a31d36f3cb577f2a43594fb1abc1bb96\":{\"balance\":\"0x543a9ce0e1332f00000\"},\"76c27535bcb59ce1fa2d8c919cabeb4a6bba01d1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"76ca22bcb8799e5327c4aa2a7d0949a1fcce5f29\":{\"balance\":\"0x52a03f228c5ae20000\"},\"76cac488111a4fd595f568ae3a858770fc915d5f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"76cb9c8b69f4387675c48253e234cb7e0d74a426\":{\"balance\":\"0x190f4482eb91dae0000\"},\"76f83ac3da30f7092628c7339f208bfc142cb1ee\":{\"balance\":\"0x9a18ffe7427d640000\"},\"76f9ad3d9bbd04ae055c1477c0c35e7592cb2a20\":{\"balance\":\"0x8833f11e3458f200000\"},\"76ffc157ad6bf8d56d9a1a7fddbc0fea010aabf4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"77028e409cc43a3bd33d21a9fc53ec606e94910e\":{\"balance\":\"0xd255d112e103a00000\"},\"770c2fb2c4a81753ac0182ea460ec09c90a516f8\":{\"balance\":\"0x1158e460913d00000\"},\"770d98d31b4353fceee8560c4ccf803e88c0c4e0\":{\"balance\":\"0x2086ac351052600000\"},\"7713ab8037411c09ba687f6f9364f0d3239fac28\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"771507aeee6a255dc2cd9df55154062d0897b297\":{\"balance\":\"0x121ea68c114e510000\"},\"7719888795ad745924c75760ddb1827dffd8cda8\":{\"balance\":\"0x6c6b4c4da6ddbe0000\"},\"7727af101f0aaba4d23a1cafe17c6eb5dab1c6dc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"772c297f0ad194482ee8c3f036bdeb01c201d5cc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"77306ffe2e4a8f3ca826c1a249f7212da43aeffd\":{\"balance\":\"0x43c33c1937564800000\"},\"773141127d8cf318aebf88365add3d5527d85b6a\":{\"balance\":\"0x3636d7af5ec98e0000\"},\"7746b6c6699c8f34ca2768a820f1ffa4c207fe05\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"7751f363a0a7fd0533190809ddaf9340d8d11291\":{\"balance\":\"0x1158e460913d00000\"},\"7757a4b9cc3d0247ccaaeb9909a0e56e1dd6dcc2\":{\"balance\":\"0x1158e460913d00000\"},\"775c10c93e0db7205b2643458233c64fc33fd75b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"77617ebc4bebc5f5ddeb1b7a70cdeb6ae2ffa024\":{\"balance\":\"0x6acb3df27e1f880000\"},\"776943ffb2ef5cdd35b83c28bc046bd4f4677098\":{\"balance\":\"0xa2a15d09519be00000\"},\"77701e2c493da47c1b58f421b5495dee45bea39b\":{\"balance\":\"0x148f649cf6142a58000\"},\"77798f201257b9c35204957057b54674aefa51df\":{\"balance\":\"0x813ca56906d340000\"},\"778c43d11afe3b586ff374192d96a7f23d2b9b7f\":{\"balance\":\"0x8bb4fcfa3b7d6b8000\"},\"778c79f4de1953ebce98fe8006d53a81fb514012\":{\"balance\":\"0x36330322d5238c0000\"},\"779274bf1803a336e4d3b00ddd93f2d4f5f4a62e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"77a17122fa31b98f1711d32a99f03ec326f33d08\":{\"balance\":\"0x5c283d410394100000\"},\"77a34907f305a54c85db09c363fde3c47e6ae21f\":{\"balance\":\"0x35659ef93f0fc40000\"},\"77a769fafdecf4a638762d5ba3969df63120a41d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"77be6b64d7c733a436adec5e14bf9ad7402b1b46\":{\"balance\":\"0x3635c9adc5dea00000\"},\"77bfe93ccda750847e41a1affee6b2da96e7214e\":{\"balance\":\"0x1043561a8829300000\"},\"77c4a697e603d42b12056cbba761e7f51d0443f5\":{\"balance\":\"0x24dce54d34a1a00000\"},\"77cc02f623a9cf98530997ea67d95c3b491859ae\":{\"balance\":\"0x497303c36ea0c20000\"},\"77d43fa7b481dbf3db530cfbf5fdced0e6571831\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"77da5e6c72fb36bce1d9798f7bcdf1d18f459c2e\":{\"balance\":\"0x13695bb6cf93e0000\"},\"77f4e3bdf056883cc87280dbe640a18a0d02a207\":{\"balance\":\"0xa81993a2bfb5b0000\"},\"77f609ca8720a023262c55c46f2d26fb3930ac69\":{\"balance\":\"0xf015f25736420000\"},\"77f81b1b26fc84d6de97ef8b9fbd72a33130cc4a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7819b0458e314e2b53bfe00c38495fd4b9fdf8d6\":{\"balance\":\"0x1158e460913d00000\"},\"781b1501647a2e06c0ed43ff197fccec35e1700b\":{\"balance\":\"0xa2a15d09519be00000\"},\"782f52f0a676c77716d574c81ec4684f9a020a97\":{\"balance\":\"0x2e14e206b730ad8000\"},\"78355df0a230f83d032c703154414de3eedab557\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7836f7ef6bc7bd0ff3acaf449c84dd6b1e2c939f\":{\"balance\":\"0xe08de7a92cd97c0000\"},\"7837fcb876da00d1eb3b88feb3df3fa4042fac82\":{\"balance\":\"0x5f68e8131ecf800000\"},\"783eec8aa5dac77b2e6623ed5198a431abbaee07\":{\"balance\":\"0x17da3a04c7b3e00000\"},\"785c8ea774d73044a734fa790a1b1e743e77ed7c\":{\"balance\":\"0xcf152640c5c830000\"},\"7860a3de38df382ae4a4dce18c0c07b98bce3dfa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"78634371e17304cbf339b1452a4ce438dc764cce\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7864dc999fe4f8e003c0f43decc39aae1522dc0f\":{\"balance\":\"0x51e102bd8ece00000\"},\"78746a958dced4c764f876508c414a68342cecb9\":{\"balance\":\"0x2be374fe8e2c40000\"},\"787d313fd36b053eeeaedbce74b9fb0678333289\":{\"balance\":\"0x5c058b7842719600000\"},\"78859c5b548b700d9284cee4b6633c2f52e529c2\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"788e809741a3b14a22a4b1d937c82cfea489eebe\":{\"balance\":\"0x17b7883c06916600000\"},\"78a1e254409fb1b55a7cb4dd8eba3b30c8bad9ef\":{\"balance\":\"0x56bc75e2d63100000\"},\"78a5e89900bd3f81dd71ba869d25fec65261df15\":{\"balance\":\"0xafd812fee03d5700000\"},\"78b978a9d7e91ee529ea4fc4b76feaf8762f698c\":{\"balance\":\"0x6c6b935b8bbd4000000\"},\"78ce3e3d474a8a047b92c41542242d0a08c70f99\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"78cf8336b328db3d87813a472b9e89b75e0cf3bc\":{\"balance\":\"0x3635c9adc5dea00000\"},\"78d4f8c71c1e68a69a98f52fcb45da8af56ea1a0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"78df2681d6d602e22142d54116dea15d454957aa\":{\"balance\":\"0x102794ad20da680000\"},\"78e08bc533413c26e291b3143ffa7cc9afb97b78\":{\"balance\":\"0xad78ebc5ac6200000\"},\"78e83f80b3678c7a0a4e3e8c84dccde064426277\":{\"balance\":\"0x61093d7c2c6d380000\"},\"78f5c74785c5668a838072048bf8b453594ddaab\":{\"balance\":\"0x15af1d78b58c400000\"},\"790f91bd5d1c5cc4739ae91300db89e1c1303c93\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7917e5bd82a9790fd650d043cdd930f7799633db\":{\"balance\":\"0xd8d4602c26bf6c0000\"},\"7919e7627f9b7d54ea3b14bb4dd4649f4f39dee0\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"791f6040b4e3e50dcf3553f182cd97a90630b75d\":{\"balance\":\"0xd8d726b7177a800000\"},\"7930c2d9cbfa87f510f8f98777ff8a8448ca5629\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"794529d09d017271359730027075b87ad83dae6e\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"794b51c39e53d9e762b0613b829a44b472f4fff3\":{\"balance\":\"0x2435e0647841cc8000\"},\"79551cede376f747e3716c8d79400d766d2e0195\":{\"balance\":\"0x9cb37afa4ff78680000\"},\"795ebc2626fc39b0c86294e0e837dcf523553090\":{\"balance\":\"0x3635c9adc5dea00000\"},\"796ebbf49b3e36d67694ad79f8ff36767ac6fab0\":{\"balance\":\"0x34bc4fdde27c00000\"},\"796f87ba617a2930b1670be92ed1281fb0b346e1\":{\"balance\":\"0x6f5e86fb528280000\"},\"797427e3dbf0feae7a2506f12df1dc40326e8505\":{\"balance\":\"0x3635c9adc5dea00000\"},\"797510e386f56393ced8f477378a444c484f7dad\":{\"balance\":\"0x3635c9adc5dea00000\"},\"797bb7f157d9feaa17f76da4f704b74dc1038341\":{\"balance\":\"0xb50fcfafebecb00000\"},\"7988901331e387f713faceb9005cb9b65136eb14\":{\"balance\":\"0x6acb3df27e1f880000\"},\"7989d09f3826c3e5af8c752a8115723a84d80970\":{\"balance\":\"0x1686f8614cf0ad0000\"},\"7995bd8ce2e0c67bf1c7a531d477bca1b2b97561\":{\"balance\":\"0x14248d617829ece0000\"},\"79aeb34566b974c35a5881dec020927da7df5d25\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"79b120eb8806732321288f675a27a9225f1cd2eb\":{\"balance\":\"0x85a0bf37dec9e40000\"},\"79b48d2d6137c3854d611c01ea42427a0f597bb7\":{\"balance\":\"0xa5aa85009e39c0000\"},\"79b8aad879dd30567e8778d2d231c8f37ab8734e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"79bf2f7b6e328aaf26e0bb093fa22da29ef2f471\":{\"balance\":\"0x61093d7c2c6d380000\"},\"79c130c762b8765b19d2abc9a083ab8f3aad7940\":{\"balance\":\"0xd5967be4fc3f100000\"},\"79c1be19711f73bee4e6316ae7549459aacea2e0\":{\"balance\":\"0x15af1d78b58c400000\"},\"79c6002f8452ca157f1317e80a2faf24475559b7\":{\"balance\":\"0x1158e460913d00000\"},\"79cac6494f11ef2798748cb53285bd8e22f97cda\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"79cfa9780ae6d87b2c31883f09276986c89a6735\":{\"balance\":\"0x3635c9adc5dea00000\"},\"79dba256472db4e058f2e4cdc3ea4e8a42773833\":{\"balance\":\"0x4f2591f896a6500000\"},\"79ed10cf1f6db48206b50919b9b697081fbdaaf3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"79f08e01ce0988e63c7f8f2908fade43c7f9f5c9\":{\"balance\":\"0xfc936392801c0000\"},\"79fd6d48315066c204f9651869c1096c14fc9781\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"79ffb4ac13812a0b78c4a37b8275223e176bfda5\":{\"balance\":\"0xf015f25736420000\"},\"7a0589b143a8e5e107c9ac66a9f9f8597ab3e7ab\":{\"balance\":\"0x51e932d76e8f7b0000\"},\"7a0a78a9cc393f91c3d9e39a6b8c069f075e6bf5\":{\"balance\":\"0x487a9a304539440000\"},\"7a1370a742ec2687e761a19ac5a794329ee67404\":{\"balance\":\"0xa2a1326761e2920000\"},\"7a2dfc770e24368131b7847795f203f3d50d5b56\":{\"balance\":\"0x269fec7f0361d200000\"},\"7a33834e8583733e2d52aead589bd1affb1dd256\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7a36aba5c31ea0ca7e277baa32ec46ce93cf7506\":{\"balance\":\"0x43c33c1937564800000\"},\"7a381122bada791a7ab1f6037dac80432753baad\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7a48d877b63a8f8f9383e9d01e53e80c528e955f\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"7a4f9b850690c7c94600dbee0ca4b0a411e9c221\":{\"balance\":\"0x678a932062e4180000\"},\"7a63869fc767a4c6b1cd0e0649f3634cb121d24b\":{\"balance\":\"0x433874f632cc60000\"},\"7a67dd043a504fc2f2fc7194e9becf484cecb1fb\":{\"balance\":\"0xd8d726b7177a80000\"},\"7a6b26f438d9a352449155b8876cbd17c9d99b64\":{\"balance\":\"0x14542ba12a337c00000\"},\"7a6d781c77c4ba1fcadf687341c1e31799e93d27\":{\"balance\":\"0xeda838c4929080000\"},\"7a7068e1c3375c0e599db1fbe6b2ea23b8f407d2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7a74cee4fa0f6370a7894f116cd00c1147b83e59\":{\"balance\":\"0x2b5e3af16b18800000\"},\"7a79e30ff057f70a3d0191f7f53f761537af7dff\":{\"balance\":\"0x15af1d78b58c400000\"},\"7a7a4f807357a4bbe68e1aa806393210c411ccb3\":{\"balance\":\"0x65a4da25d3016c00000\"},\"7a8563867901206f3f2bf0fa3e1c8109cabccd85\":{\"balance\":\"0x76d41c62494840000\"},\"7a8797690ab77b5470bf7c0c1bba612508e1ac7d\":{\"balance\":\"0x1e09296c3378de40000\"},\"7a8c89c014509d56d7b68130668ff6a3ecec7370\":{\"balance\":\"0x1043561a8829300000\"},\"7a94b19992ceb8ce63bc92ee4b5aded10c4d9725\":{\"balance\":\"0x38d1a8064bb64c80000\"},\"7aa79ac04316cc8d08f20065baa6d4142897d54e\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"7aad4dbcd3acf997df93586956f72b64d8ad94ee\":{\"balance\":\"0xd8d726b7177a800000\"},\"7ab256b204800af20137fabcc916a23258752501\":{\"balance\":\"0x43c33c1937564800000\"},\"7aba56f63a48bc0817d6b97039039a7ad62fae2e\":{\"balance\":\"0x2086ac351052600000\"},\"7abb10f5bd9bc33b8ec1a82d64b55b6b18777541\":{\"balance\":\"0x43c33c1937564800000\"},\"7ac48d40c664cc9a6d89f1c5f5c80a1c70e744e6\":{\"balance\":\"0xa31062beeed7000000\"},\"7ac58f6ffc4f8107ae6e30378e4e9f99c57fbb24\":{\"balance\":\"0x22b1c8c1227a00000\"},\"7ad3f307616f19dcb143e6444dab9c3c33611f52\":{\"balance\":\"0x2b5e3af16b1880000\"},\"7ad82caea1a8b4ed05319b9c9870173c814e06ee\":{\"balance\":\"0x2164b7a04ac8a00000\"},\"7ade5d66b944bb860c0efdc86276d58f4653f711\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7adfedb06d91f3cc7390450b85550270883c7bb7\":{\"balance\":\"0x1178fa40515db40000\"},\"7ae1c19e53c71cee4c73fae2d7fc73bf9ab5e392\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7ae659eb3bc46852fa86fac4e21c768d50388945\":{\"balance\":\"0xf810c1cb501b80000\"},\"7aea25d42b2612286e99c53697c6bc4100e2dbbf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7aef7b551f0b9c46e755c0f38e5b3a73fe1199f5\":{\"balance\":\"0x50c5e761a444080000\"},\"7b0b31ff6e24745ead8ed9bb85fc0bf2fe1d55d4\":{\"balance\":\"0x2b5e3af16b18800000\"},\"7b0fea1176d52159333a143c294943da36bbddb4\":{\"balance\":\"0x1fc7da64ea14c100000\"},\"7b11673cc019626b290cbdce26046f7e6d141e21\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7b122162c913e7146cad0b7ed37affc92a0bf27f\":{\"balance\":\"0x51af096b2301d18000\"},\"7b1bf53a9cbe83a7dea434579fe72aac8d2a0cd0\":{\"balance\":\"0xad4c8316a0b0c0000\"},\"7b1daf14891b8a1e1bd429d8b36b9a4aa1d9afbf\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7b1fe1ab4dfd0088cdd7f60163ef59ec2aee06f5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7b25bb9ca8e702217e9333225250e53c36804d48\":{\"balance\":\"0x65ea3db75546600000\"},\"7b27d0d1f3dd3c140294d0488b783ebf4015277d\":{\"balance\":\"0x15af1d78b58c400000\"},\"7b4007c45e5a573fdbb6f8bd746bf94ad04a3c26\":{\"balance\":\"0x33821f5135d259a0000\"},\"7b43c7eea8d62355b0a8a81da081c6446b33e9e0\":{\"balance\":\"0xd8d726b7177a800000\"},\"7b4d2a38269069c18557770d591d24c5121f5e83\":{\"balance\":\"0x25f273933db5700000\"},\"7b6175ec9befc738249535ddde34688cd36edf25\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7b66126879844dfa34fe65c9f288117fefb449ad\":{\"balance\":\"0x14542ba12a337c00000\"},\"7b6a84718dd86e63338429ac811d7c8a860f21f1\":{\"balance\":\"0x61093d7c2c6d380000\"},\"7b712c7af11676006a66d2fc5c1ab4c479ce6037\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"7b73242d75ca9ad558d650290df17692d54cd8b8\":{\"balance\":\"0x6c6e59e67c78540000\"},\"7b761feb7fcfa7ded1f0eb058f4a600bf3a708cb\":{\"balance\":\"0xf95dd2ec27cce00000\"},\"7b827cae7ff4740918f2e030ab26cb98c4f46cf5\":{\"balance\":\"0x194684c0b39de100000\"},\"7b893286427e72db219a21fc4dcd5fbf59283c31\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7b9226d46fe751940bc416a798b69ccf0dfab667\":{\"balance\":\"0xe3aeb5737240a00000\"},\"7b98e23cb96beee80a168069ebba8f20edd55ccf\":{\"balance\":\"0xba0c91587c14a0000\"},\"7bb0fdf5a663b5fba28d9c902af0c811e252f298\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7bb9571f394b0b1a8eba5664e9d8b5e840677bea\":{\"balance\":\"0x11164759ffb320000\"},\"7bb984c6dbb9e279966afafda59c01d02627c804\":{\"balance\":\"0x1b464311d45a6880000\"},\"7bbbec5e70bdead8bb32b42805988e9648c0aa97\":{\"balance\":\"0x3636d7af5ec98e0000\"},\"7bca1da6c80a66baa5db5ac98541c4be276b447d\":{\"balance\":\"0x24cf049680fa3c0000\"},\"7bddb2ee98de19ee4c91f661ee8e67a91d054b97\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7be2f7680c802da6154c92c0194ae732517a7169\":{\"balance\":\"0xfc936392801c0000\"},\"7be7f2456971883b9a8dbe4c91dec08ac34e8862\":{\"balance\":\"0xa2a15d09519be00000\"},\"7be8ccb4f11b66ca6e1d57c0b5396221a31ba53a\":{\"balance\":\"0x1158e460913d00000\"},\"7beb81fb2f5e91526b2ac9795e76c69bcff04bc0\":{\"balance\":\"0xeb22e794f0a8d600000\"},\"7c0883054c2d02bc7a852b1f86c42777d0d5c856\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7c0f5e072043c9ee740242197e78cc4b98cdf960\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7c1df24a4f7fb2c7b472e0bb006cb27dcd164156\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7c29d47d57a733f56b9b217063b513dc3b315923\":{\"balance\":\"0xd8d726b7177a800000\"},\"7c2b9603884a4f2e464eceb97d17938d828bc02c\":{\"balance\":\"0xa2a15d09519be00000\"},\"7c382c0296612e4e97e440e02d3871273b55f53b\":{\"balance\":\"0xab640391201300000\"},\"7c3eb713c4c9e0381cd8154c7c9a7db8645cde17\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7c4401ae98f12ef6de39ae24cf9fc51f80eba16b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7c45f0f8442a56dbd39dbf159995415c52ed479b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7c532db9e0c06c26fd40acc56ac55c1ee92d3c3a\":{\"balance\":\"0x3f870857a3e0e3800000\"},\"7c60a05f7a4a5f8cf2784391362e755a8341ef59\":{\"balance\":\"0x6694f0182a37ae0000\"},\"7c60e51f0be228e4d56fdd2992c814da7740c6bc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7c6924d07c3ef5891966fe0a7856c87bef9d2034\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7c8bb65a6fbb49bd413396a9d7e31053bbb37aa9\":{\"balance\":\"0x14542ba12a337c00000\"},\"7c9a110cb11f2598b2b20e2ca400325e41e9db33\":{\"balance\":\"0x581767ba6189c400000\"},\"7cbca88fca6a0060b960985c9aa1b02534dc2208\":{\"balance\":\"0x19127a1391ea2a0000\"},\"7cbeb99932e97e6e02058cfc62d0b26bc7cca52b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7cc24a6a958c20c7d1249660f7586226950b0d9a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"7cd20eccb518b60cab095b720f571570caaa447e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7cd5d81eab37e11e6276a3a1091251607e0d7e38\":{\"balance\":\"0x3684d5ef981f40000\"},\"7cdf74213945953db39ad0e8a9781add792e4d1d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7ce4686446f1949ebed67215eb0d5a1dd72c11b8\":{\"balance\":\"0x7839d321b81ab80000\"},\"7cef4d43aa417f9ef8b787f8b99d53f1fea1ee88\":{\"balance\":\"0x678a932062e4180000\"},\"7d0350e40b338dda736661872be33f1f9752d755\":{\"balance\":\"0x2b4f5a6f191948000\"},\"7d04d2edc058a1afc761d9c99ae4fc5c85d4c8a6\":{\"balance\":\"0x42a9c4675c9467d00000\"},\"7d0b255efb57e10f7008aa22d40e9752dfcf0378\":{\"balance\":\"0x19f8e7559924c0000\"},\"7d13d6705884ab2157dd8dcc7046caf58ee94be4\":{\"balance\":\"0x1d0da07cbb3ee9c00000\"},\"7d273e637ef1eac481119413b91c989dc5eac122\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"7d2a52a7cf0c8436a8e007976b6c26b7229d1e15\":{\"balance\":\"0x17bf06b32a241c0000\"},\"7d34803569e00bd6b59fff081dfa5c0ab4197a62\":{\"balance\":\"0x5cd87cb7b9fb860000\"},\"7d34ff59ae840a7413c6ba4c5bb2ba2c75eab018\":{\"balance\":\"0xa2a15d09519be00000\"},\"7d392852f3abd92ff4bb5bb26cb60874f2be6795\":{\"balance\":\"0x3636c25e66ece70000\"},\"7d445267c59ab8d2a2d9e709990e09682580c49f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7d551397f79a2988b064afd0efebee802c7721bc\":{\"balance\":\"0x857e0d6f1da76a00000\"},\"7d5aa33fc14b51841a06906edb2bb49c2a117269\":{\"balance\":\"0x104400a2470e680000\"},\"7d5d2f73949dadda0856b206989df0078d51a1e5\":{\"balance\":\"0x23c757072b8dd000000\"},\"7d6e990daa7105de2526339833f77b5c0b85d84f\":{\"balance\":\"0x43c33c1937564800000\"},\"7d73863038ccca22f96affda10496e51e1e6cd48\":{\"balance\":\"0x1158e460913d00000\"},\"7d7dd5ee614dbb6fbfbcd26305247a058c41faa1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7d7e7c61779adb7706c94d32409a2bb4e994bf60\":{\"balance\":\"0x2ef20d9fc71a140000\"},\"7d82e523cc2dc591da3954e8b6bb2caf6461e69c\":{\"balance\":\"0x7d8dc2efffb1a90000\"},\"7d858493f07415e0912d05793c972113eae8ae88\":{\"balance\":\"0x628dd177d2bc280000\"},\"7d901b28bf7f88ef73d8f73cca97564913ea8a24\":{\"balance\":\"0x33c5499031720c0000\"},\"7d980f4b566bb045517e4c14c87750de9346744b\":{\"balance\":\"0x487a9a304539440000\"},\"7d9c59631e2ba2e8e82891f3979922aaa3b567a1\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"7d9d221a3df89ddd7b5f61c1468c6787d6b333e6\":{\"balance\":\"0x77b227cd83be80000\"},\"7da7613445a21299aa74f0ad71431ec43fbb1be9\":{\"balance\":\"0x3afb087b876900000\"},\"7db4c7d5b797e9296e6382f203693db409449d62\":{\"balance\":\"0x15af1d78b58c400000\"},\"7db9eacc52e429dc83b461c5f4d86010e5383a28\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7dd46da677e161825e12e80dc446f58276e1127c\":{\"balance\":\"0x2c73c937742c500000\"},\"7dd8d7a1a34fa1f8e73ccb005fc2a03a15b8229c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7ddd57165c87a2707f025dcfc2508c09834759bc\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"7de442c82386154d2e993cbd1280bb7ca6b12ada\":{\"balance\":\"0xd8f2e8247ec9480000\"},\"7de7fe419cc61f91f408d234cc80d5ca3d054d99\":{\"balance\":\"0x1158e460913d00000\"},\"7dece6998ae1900dd3770cf4b93812bad84f0322\":{\"balance\":\"0x56bc75e2d63100000\"},\"7dfc342dffcf45dfee74f84c0995397bd1a63172\":{\"balance\":\"0xd8d726b7177a80000\"},\"7dfd2962b575bcbeee97f49142d63c30ab009f66\":{\"balance\":\"0xd8d726b7177a800000\"},\"7e1e29721d6cb91057f6c4042d8a0bbc644afe73\":{\"balance\":\"0x8a9aba557e36c0000\"},\"7e236666b2d06e63ea4e2ab84357e2dfc977e50e\":{\"balance\":\"0x36356633ebd8ea0000\"},\"7e24d9e22ce1da3ce19f219ccee523376873f367\":{\"balance\":\"0x13fd9079caa60ff0000\"},\"7e24fbdad290175eb2df6d180a19b9a9f41370be\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7e268f131ddf687cc325c412f78ba961205e9112\":{\"balance\":\"0x36364ee7d301b3c0000\"},\"7e29290038493559194e946d4e460b96fc38a156\":{\"balance\":\"0x10c13c527763880000\"},\"7e2ba86da52e785d8625334f3397ba1c4bf2e8d1\":{\"balance\":\"0xaadec983fcff40000\"},\"7e3f63e13129a221ba1ab06326342cd98b5126ae\":{\"balance\":\"0x56a02659a523340000\"},\"7e47637e97c14622882be057bea229386f4052e5\":{\"balance\":\"0x17da3a04c7b3e00000\"},\"7e4e9409704121d1d77997026ff06ea9b19a8b90\":{\"balance\":\"0x8d16549ed58fa40000\"},\"7e59dc60be8b2fc19abd0a5782c52c28400bce97\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7e5b19ae1be94ff4dee635492a1b012d14db0213\":{\"balance\":\"0x56bc75e2d63100000\"},\"7e5d9993104e4cb545e179a2a3f971f744f98482\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7e71171f2949fa0c3ac254254b1f0440e5e6a038\":{\"balance\":\"0x22b1c8c1227a00000\"},\"7e7c1e9a61a08a83984835c70ec31d34d3eaa87f\":{\"balance\":\"0xa5aa85009e39c0000\"},\"7e7f18a02eccaa5d61ab8fbf030343c434a25ef7\":{\"balance\":\"0x39fbae8d042dd0000\"},\"7e81f6449a03374191f3b7cb05d938b72e090dff\":{\"balance\":\"0x56bc75e2d63100000\"},\"7e8649e690fc8c1bfda1b5e186581f649b50fe33\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"7e87863ec43a481df04d017762edcb5caa629b5a\":{\"balance\":\"0x222c8eb3ff6640000\"},\"7e8f96cc29f57b0975120cb593b7dd833d606b53\":{\"balance\":\"0xaadec983fcff40000\"},\"7e972a8a7c2a44c93b21436c38d21b9252c345fe\":{\"balance\":\"0x61093d7c2c6d380000\"},\"7e99dfbe989d3ba529d19751b7f4317f8953a3e2\":{\"balance\":\"0x15af1d78b58c400000\"},\"7ea0f96ee0a573a330b56897761f3d4c0130a8e3\":{\"balance\":\"0x487a9a304539440000\"},\"7ea791ebab0445a00efdfc4e4a8e9a7e7565136d\":{\"balance\":\"0xfc936392801c0000\"},\"7eaba035e2af3793fd74674b102540cf190addb9\":{\"balance\":\"0x45026c835b60440000\"},\"7eb4b0185c92b6439a08e7322168cb353c8a774a\":{\"balance\":\"0x227196ca04983ca0000\"},\"7ebd95e9c470f7283583dc6e9d2c4dce0bea8f84\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"7ed0a5a847bef9a9da7cba1d6411f5c316312619\":{\"balance\":\"0x228eb37e8751d0000\"},\"7edafba8984baf631a820b6b92bbc2c53655f6bd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7edb02c61a227287611ad950696369cc4e647a68\":{\"balance\":\"0xeda838c4929080000\"},\"7ee5ca805dce23af89c2d444e7e40766c54c7404\":{\"balance\":\"0xd0bd412edbd820000\"},\"7ee604c7a9dc2909ce321de6b9b24f5767577555\":{\"balance\":\"0x12bf9c7985cf62d8000\"},\"7ef16fd8d15b378a0fba306b8d03dd98fc92619f\":{\"balance\":\"0x25f273933db5700000\"},\"7ef98b52bee953bef992f305fda027f8911c5851\":{\"balance\":\"0x1be722206996bc8000\"},\"7efc90766a00bc52372cac97fabd8a3c831f8ecd\":{\"balance\":\"0x890b0c2e14fb80000\"},\"7efec0c6253caf397f71287c1c07f6c9582b5b86\":{\"balance\":\"0x1a2cbcb84f30d58000\"},\"7f01dc7c3747ca608f983dfc8c9b39e755a3b914\":{\"balance\":\"0xb386cad5f7a5a0000\"},\"7f0662b410298c99f311d3a1454a1eedba2fea76\":{\"balance\":\"0xad78ebc5ac6200000\"},\"7f06c89d59807fa60bc60136fcf814cbaf2543bd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"7f0b90a1fdd48f27b268feb38382e55ddb50ef0f\":{\"balance\":\"0x32f51edbaaa3300000\"},\"7f0ec3db804692d4d1ea3245365aab0590075bc4\":{\"balance\":\"0xd8d726b7177a800000\"},\"7f0f04fcf37a53a4e24ede6e93104e78be1d3c9e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7f13d760498d7193ca6859bc95c901386423d76c\":{\"balance\":\"0x10f0cf064dd59200000\"},\"7f150afb1a77c2b45928c268c1e9bdb4641d47d8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7f1619988f3715e94ff1d253262dc5581db3de1c\":{\"balance\":\"0x30ca024f987b900000\"},\"7f1c81ee1697fc144b7c0be5493b5615ae7fddca\":{\"balance\":\"0x1b1dab61d3aa640000\"},\"7f2382ffd8f83956467937f9ba72374623f11b38\":{\"balance\":\"0x2086ac351052600000\"},\"7f3709391f3fbeba3592d175c740e87a09541d02\":{\"balance\":\"0x1a055690d9db800000\"},\"7f389c12f3c6164f6446566c77669503c2792527\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"7f3a1e45f67e92c880e573b43379d71ee089db54\":{\"balance\":\"0x152d02c7e14af6800000\"},\"7f3d7203c8a447f7bf36d88ae9b6062a5eee78ae\":{\"balance\":\"0x14542ba12a337c00000\"},\"7f46bb25460dd7dae4211ca7f15ad312fc7dc75c\":{\"balance\":\"0x16a6502f15a1e540000\"},\"7f49e7a4269882bd8722d4a6f566347629624079\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7f49f20726471ac1c7a83ef106e9775ceb662566\":{\"balance\":\"0x14061b9d77a5e980000\"},\"7f4b5e278578c046cceaf65730a0e068329ed5b6\":{\"balance\":\"0x65ea3db75546600000\"},\"7f4f593b618c330ba2c3d5f41eceeb92e27e426c\":{\"balance\":\"0x966edc756b7cfc0000\"},\"7f541491d2ac00d2612f94aa7f0bcb014651fbd4\":{\"balance\":\"0x14620c57dddae00000\"},\"7f5ae05ae0f8cbe5dfe721f044d7a7bef4c27997\":{\"balance\":\"0x340aad21b3b700000\"},\"7f603aec1759ea5f07c7f8d41a1428fbbaf9e762\":{\"balance\":\"0x1158e460913d00000\"},\"7f616c6f008adfa082f34da7d0650460368075fb\":{\"balance\":\"0x3635c9adc5dea00000\"},\"7f61fa6cf5f898b440dac5abd8600d6d691fdef9\":{\"balance\":\"0xf2dc7d47f15600000\"},\"7f655c6789eddf455cb4b88099720639389eebac\":{\"balance\":\"0x14542ba12a337c00000\"},\"7f6b28c88421e4857e459281d78461692489d3fb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7f6efb6f4318876d2ee624e27595f44446f68e93\":{\"balance\":\"0x54069233bf7f780000\"},\"7f7192c0df1c7db6d9ed65d71184d8e4155a17ba\":{\"balance\":\"0x453728d33942c0000\"},\"7f7a3a21b3f5a65d81e0fcb7d52dd00a1aa36dba\":{\"balance\":\"0x56bc75e2d63100000\"},\"7f8dbce180ed9c563635aad2d97b4cbc428906d9\":{\"balance\":\"0x90f534608a72880000\"},\"7f993ddb7e02c282b898f6155f680ef5b9aff907\":{\"balance\":\"0x43c33c1937564800000\"},\"7f9f9b56e4289dfb58e70fd5f12a97b56d35c6a5\":{\"balance\":\"0x6acb3df27e1f880000\"},\"7fa37ed67887751a471f0eb306be44e0dbcd6089\":{\"balance\":\"0x3976747fe11a100000\"},\"7faa30c31519b584e97250ed2a3cf3385ed5fd50\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7fcf5ba6666f966c5448c17bf1cb0bbcd8019b06\":{\"balance\":\"0x56bc3d0aebe498000\"},\"7fd679e5fb0da2a5d116194dcb508318edc580f3\":{\"balance\":\"0x1639e49bba162800000\"},\"7fdba031c78f9c096d62d05a369eeab0bccc55e5\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"7fdbc3a844e40d96b2f3a635322e6065f4ca0e84\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7fdfc88d78bf1b285ac64f1adb35dc11fcb03951\":{\"balance\":\"0x7c06fda02fb0360000\"},\"7fea1962e35d62059768c749bedd96cab930d378\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"7fef8c38779fb307ec6f044bebe47f3cfae796f1\":{\"balance\":\"0x92340f86cf09e8000\"},\"7ff0c63f70241bece19b737e5341b12b109031d8\":{\"balance\":\"0x12c1b6eed03d280000\"},\"7ffabfbc390cbe43ce89188f0868b27dcb0f0cad\":{\"balance\":\"0x1595182224b26480000\"},\"7ffd02ed370c7060b2ae53c078c8012190dfbb75\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"80022a1207e910911fc92849b069ab0cdad043d3\":{\"balance\":\"0xb98bc829a6f90000\"},\"8009a7cbd192b3aed4adb983d5284552c16c7451\":{\"balance\":\"0xd8d726b7177a800000\"},\"800e7d631c6e573a90332f17f71f5fd19b528cb9\":{\"balance\":\"0x83d6c7aab63600000\"},\"80156d10efa8b230c99410630d37e269d4093cea\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"801732a481c380e57ed62d6c29de998af3fa3b13\":{\"balance\":\"0x56bc75e2d63100000\"},\"801d65c518b11d0e3f4f470221417013c8e53ec5\":{\"balance\":\"0xd8d726b7177a800000\"},\"8026435aac728d497b19b3e7e57c28c563954f2b\":{\"balance\":\"0x5dc892aa1131c80000\"},\"802dc3c4ff2d7d925ee2859f4a06d7ba60f1308c\":{\"balance\":\"0x550940c8fd34c0000\"},\"8030b111c6983f0485ddaca76224c6180634789f\":{\"balance\":\"0x4563918244f400000\"},\"8035bcffaefdeeea35830c497d14289d362023de\":{\"balance\":\"0x1043561a8829300000\"},\"8035fe4e6b6af27ae492a578515e9d39fa6fa65b\":{\"balance\":\"0xd8d726b7177a800000\"},\"8043ed22f997e5a2a4c16e364486ae64975692c4\":{\"balance\":\"0x3d4904ffc9112e8000\"},\"8043fdd0bc4c973d1663d55fc135508ec5d4f4fa\":{\"balance\":\"0x1158e460913d00000\"},\"804ca94972634f633a51f3560b1d06c0b293b3b1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"80522ddf944ec52e27d724ed4c93e1f7be6083d6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"80591a42179f34e64d9df75dcd463b28686f5574\":{\"balance\":\"0x43c33c1937564800000\"},\"805ce51297a0793b812067f017b3e7b2df9bb1f9\":{\"balance\":\"0x56bc75e2d63100000\"},\"805d846fb0bc02a7337226d685be9ee773b9198a\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"8063379a7bf2cb923a84c5093e68dac7f75481c5\":{\"balance\":\"0x1176102e6e32df0000\"},\"806854588ecce541495f81c28a290373df0274b2\":{\"balance\":\"0x1f8cdf5c6e8d580000\"},\"806f44bdeb688037015e84ff218049e382332a33\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"80744618de396a543197ee4894abd06398dd7c27\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8077c3e4c445586e094ce102937fa05b737b568c\":{\"balance\":\"0x56bc75e2d63100000\"},\"80907f593148b57c46c177e23d25abc4aae18361\":{\"balance\":\"0x56bc75e2d63100000\"},\"80977316944e5942e79b0e3abad38da746086519\":{\"balance\":\"0x21a754a6dc5280000\"},\"80a0f6cc186cf6201400736e065a391f52a9df4a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"80abec5aa36e5c9d098f1b942881bd5acac6963d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"80b23d380b825c46e0393899a85556462da0e18c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"80b42de170dbd723f454e88f7716452d92985092\":{\"balance\":\"0x104623c0762dd10000\"},\"80b79f338390d1ba1b3737a29a0257e5d91e0731\":{\"balance\":\"0x1158e460913d00000\"},\"80bf995ed8ba92701d10fec49f9e7d014dbee026\":{\"balance\":\"0x1f0437ca1a7e128000\"},\"80c04efd310f440483c73f744b5b9e64599ce3ec\":{\"balance\":\"0x410d586a20a4c00000\"},\"80c3a9f695b16db1597286d1b3a8b7696c39fa27\":{\"balance\":\"0x56bc75e2d63100000\"},\"80c53ee7e3357f94ce0d7868009c208b4a130125\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"80cc21bd99f39005c58fe4a448909220218f66cb\":{\"balance\":\"0x3636c9796436740000\"},\"80d5c40c59c7f54ea3a55fcfd175471ea35099b3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"80da2fdda29a9e27f9e115975e69ae9cfbf3f27e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"80e7b3205230a566a1f061d922819bb4d4d2a0e1\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"80ea1acc136eca4b68c842a95adf6b7fee7eb8a2\":{\"balance\":\"0xd8d726b7177a800000\"},\"80f07ac09e7b2c3c0a3d1e9413a544c73a41becb\":{\"balance\":\"0x1158e460913d00000\"},\"810db25675f45ea4c7f3177f37ce29e22d67999c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"81139bfdcca656c430203f72958c543b6580d40c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"811461a2b0ca90badac06a9ea16e787b33b196cc\":{\"balance\":\"0x8e3f50b173c100000\"},\"81164deb10814ae08391f32c08667b6248c27d7a\":{\"balance\":\"0x155bd9307f9fe80000\"},\"81186931184137d1192ac88cd3e1e5d0fdb86a74\":{\"balance\":\"0x9d3595ab2438d00000\"},\"812a55c43caedc597218379000ce510d548836fd\":{\"balance\":\"0xfc936392801c0000\"},\"812ea7a3b2c86eed32ff4f2c73514cc63bacfbce\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8134dd1c9df0d6c8a5812426bb55c761ca831f08\":{\"balance\":\"0x6a2160bb57ccc0000\"},\"814135da8f9811075783bf1ab67062af8d3e9f40\":{\"balance\":\"0x1158e460913d00000\"},\"81498ca07b0f2f17e8bbc7e61a7f4ae7be66b78b\":{\"balance\":\"0x581fbb5b33bb00000\"},\"81556db27349ab8b27004944ed50a46e941a0f5f\":{\"balance\":\"0xd8bb6549b02bb80000\"},\"8155fa6c51eb31d808412d748aa086105018122f\":{\"balance\":\"0x65ea3db75546600000\"},\"8156360bbd370961ceca6b6691d75006ad204cf2\":{\"balance\":\"0x878678326eac9000000\"},\"8161d940c3760100b9080529f8a60325030f6edc\":{\"balance\":\"0x1043561a8829300000\"},\"8164e78314ae16b28926cc553d2ccb16f356270d\":{\"balance\":\"0x1ca134e95fb32c80000\"},\"8165cab0eafb5a328fc41ac64dae715b2eef2c65\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8168edce7f2961cf295b9fcd5a45c06cdeda6ef5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"816d9772cf11399116cc1e72c26c6774c9edd739\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8173c835646a672e0152be10ffe84162dd256e4c\":{\"balance\":\"0x1aabdf2145b4300000\"},\"817493cd9bc623702a24a56f9f82e3fd48f3cd31\":{\"balance\":\"0x9e4b23f12d4ca00000\"},\"8179c80970182cc5b7d82a4df06ea94db63a25f3\":{\"balance\":\"0x276f259de66bf40000\"},\"817ac33bd8f847567372951f4a10d7a91ce3f430\":{\"balance\":\"0xad7c406c66dc18000\"},\"818ffe271fc3973565c303f213f6d2da89897ebd\":{\"balance\":\"0x136e05342fee1b98000\"},\"8197948121732e63d9c148194ecad46e30b749c8\":{\"balance\":\"0xd8d726b7177a800000\"},\"819af9a1c27332b1c369bbda1b3de1c6e933d640\":{\"balance\":\"0x1109e654b98f7a0000\"},\"819cdaa5303678ef7cec59d48c82163acc60b952\":{\"balance\":\"0x31351545f79816c0000\"},\"819eb4990b5aba5547093da12b6b3c1093df6d46\":{\"balance\":\"0x3635c9adc5dea00000\"},\"81a88196fac5f23c3e12a69dec4b880eb7d97310\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"81bccbff8f44347eb7fca95b27ce7c952492aaad\":{\"balance\":\"0x840c12165dd780000\"},\"81bd75abd865e0c3f04a0b4fdbcb74d34082fbb7\":{\"balance\":\"0xd8d726b7177a800000\"},\"81c18c2a238ddc4cba230a072dd7dc101e620273\":{\"balance\":\"0x487a9a304539440000\"},\"81c9e1aee2d3365d53bcfdcd96c7c538b0fd7eec\":{\"balance\":\"0x62a992e53a0af00000\"},\"81cfad760913d3c322fcc77b49c2ae3907e74f6e\":{\"balance\":\"0xaadec983fcff40000\"},\"81d619ff5726f2405f12904c72eb1e24a0aaee4f\":{\"balance\":\"0x43c33c1937564800000\"},\"81efe296ae76c860d1c5fbd33d47e8ce9996d157\":{\"balance\":\"0x3635c9adc5dea00000\"},\"81f8de2c283d5fd4afbda85dedf9760eabbbb572\":{\"balance\":\"0xa2a15d09519be00000\"},\"820c19291196505b65059d9914b7090be1db87de\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"821cb5cd05c7ef909fe1be60733d8963d760dc41\":{\"balance\":\"0xd8d726b7177a800000\"},\"821d798af19989c3ae5b84a7a7283cd7fda1fabe\":{\"balance\":\"0x43c33c1937564800000\"},\"821eb90994a2fbf94bdc3233910296f76f9bf6e7\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"82249fe70f61c6b16f19a324840fdc020231bb02\":{\"balance\":\"0x20336b08a93635b0000\"},\"8228ebc087480fd64547ca281f5eace3041453b9\":{\"balance\":\"0x6acb3df27e1f880000\"},\"8229ceb9f0d70839498d44e6abed93c5ca059f5d\":{\"balance\":\"0x1a1c1b3c989a20100000\"},\"822edff636563a6106e52e9a2598f7e6d0ef2782\":{\"balance\":\"0x1f4f9693d42d38000\"},\"823219a25976bb2aa4af8bad41ac3526b493361f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8232d1f9742edf8dd927da353b2ae7b4cbce7592\":{\"balance\":\"0x243d4d18229ca20000\"},\"8234f463d18485501f8f85ace4972c9b632dbccc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"823768746737ce6da312d53e54534e106f967cf3\":{\"balance\":\"0x1158e460913d00000\"},\"823ba7647238d113bce9964a43d0a098118bfe4d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"824074312806da4748434266ee002140e3819ac2\":{\"balance\":\"0x51b1d3839261ac0000\"},\"82438fd2b32a9bdd674b49d8cc5fa2eff9781847\":{\"balance\":\"0x1158e460913d00000\"},\"82485728d0e281563758c75ab27ed9e882a0002d\":{\"balance\":\"0x7f808e9291e6c0000\"},\"824b3c3c443e19295d7ef6faa7f374a4798486a8\":{\"balance\":\"0x1158e460913d00000\"},\"8251358ca4e060ddb559ca58bc0bddbeb4070203\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"825135b1a7fc1605614c8aa4d0ac6dbad08f480e\":{\"balance\":\"0x4d853c8f8908980000\"},\"825309a7d45d1812f51e6e8df5a7b96f6c908887\":{\"balance\":\"0x8034f7d9b166d40000\"},\"825a7f4e10949cb6f8964268f1fa5f57e712b4c4\":{\"balance\":\"0x1158e460913d00000\"},\"8261fa230c901d43ff579f4780d399f31e6076bc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8262169b615870134eb4ac6c5f471c6bf2f789fc\":{\"balance\":\"0x19127a1391ea2a0000\"},\"8263ece5d709e0d7ae71cca868ed37cd2fef807b\":{\"balance\":\"0x35ab028ac154b80000\"},\"826ce5790532e0548c6102a30d3eac836bd6388f\":{\"balance\":\"0x3cfc82e37e9a7400000\"},\"826eb7cd7319b82dd07a1f3b409071d96e39677f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"827531a6c5817ae35f82b00b9754fcf74c55e232\":{\"balance\":\"0xc328093e61ee400000\"},\"8275cd684c3679d5887d03664e338345dc3cdde1\":{\"balance\":\"0xdb44e049bb2c0000\"},\"8284923b62e68bbf7c2b9f3414d13ef6c812a904\":{\"balance\":\"0xd255d112e103a00000\"},\"828ba651cb930ed9787156299a3de44cd08b7212\":{\"balance\":\"0x487a9a304539440000\"},\"82a15cef1d6c8260eaf159ea3f0180d8677dce1c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"82a8b96b6c9e13ebec1e9f18ac02a60ea88a48ff\":{\"balance\":\"0x6c6b8c408e73b30000\"},\"82a8cbbfdff02b2e38ae4bbfca15f1f0e83b1aea\":{\"balance\":\"0x49b991c27ef6d8000\"},\"82e4461eb9d849f0041c1404219e4272c4900ab4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"82e577b515cb2b0860aafe1ce09a59e09fe7d040\":{\"balance\":\"0x2086ac351052600000\"},\"82ea01e3bf2e83836e71704e22a2719377efd9c3\":{\"balance\":\"0xa4cc799563c3800000\"},\"82f2e991fd324c5f5d17768e9f61335db6319d6c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"82f39b2758ae42277b86d69f75e628d958ebcab0\":{\"balance\":\"0x878678326eac9000000\"},\"82f854c9c2f087dffa985ac8201e626ca5467686\":{\"balance\":\"0x152d02c7e14af6800000\"},\"82ff716fdf033ec7e942c909d9831867b8b6e2ef\":{\"balance\":\"0x61093d7c2c6d380000\"},\"8308ed0af7f8a3c1751fafc877b5a42af7d35882\":{\"balance\":\"0x3635c9adc5dea00000\"},\"831c44b3084047184b2ad218680640903750c45d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"83210583c16a4e1e1dac84ebd37e3d0f7c57eba4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"832c54176bdf43d2c9bcd7b808b89556b89cbf31\":{\"balance\":\"0xad78ebc5ac6200000\"},\"833316985d47742bfed410604a91953c05fb12b0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8334764b7b397a4e578f50364d60ce44899bff94\":{\"balance\":\"0x503b203e9fba20000\"},\"833b6a8ec8da408186ac8a7d2a6dd61523e7ce84\":{\"balance\":\"0x3635c9adc5dea000000\"},\"833d3fae542ad5f8b50ce19bde2bec579180c88c\":{\"balance\":\"0x12c1b6eed03d280000\"},\"833db42c14163c7be4cab86ac593e06266d699d5\":{\"balance\":\"0x24e40d2b6943ef900000\"},\"83563bc364ed81a0c6da3b56ff49bbf267827a9c\":{\"balance\":\"0x3ab91d17b20de500000\"},\"837a645dc95c49549f899c4e8bcf875324b2f57c\":{\"balance\":\"0x208c394af1c8880000\"},\"838bd565f99fde48053f7917fe333cf84ad548ab\":{\"balance\":\"0xad78ebc5ac6200000\"},\"83908aa7478a6d1c9b9b0281148f8f9f242b9fdc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8392e53776713578015bff4940cf43849d7dcba1\":{\"balance\":\"0x84df0355d56170000\"},\"8397a1bc47acd647418159b99cea57e1e6532d6e\":{\"balance\":\"0x1f10fa827b550b40000\"},\"8398e07ebcb4f75ff2116de77c1c2a99f303a4cf\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"83a3148833d9644984f7c475a7850716efb480ff\":{\"balance\":\"0xb8507a820728200000\"},\"83a402438e0519773d5448326bfb61f8b20cf52d\":{\"balance\":\"0x52663ccab1e1c00000\"},\"83a93b5ba41bf88720e415790cdc0b67b4af34c4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"83c23d8a502124ee150f08d71dc6727410a0f901\":{\"balance\":\"0x7331f3bfe661b180000\"},\"83c897a84b695eebe46679f7da19d776621c2694\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"83d532d38d6dee3f60adc68b936133c7a2a1b0dd\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"83dbf8a12853b40ac61996f8bf1dc8fdbaddd329\":{\"balance\":\"0x34957444b840e80000\"},\"83dbfd8eda01d0de8e158b16d0935fc2380a5dc7\":{\"balance\":\"0x2086ac351052600000\"},\"83e48055327c28b5936fd9f4447e73bdb2dd3376\":{\"balance\":\"0x90f534608a72880000\"},\"83fe5a1b328bae440711beaf6aad6026eda6d220\":{\"balance\":\"0x43c33c1937564800000\"},\"84008a72f8036f3feba542e35078c057f32a8825\":{\"balance\":\"0x56bc75e2d63100000\"},\"840ec83ea93621f034e7bb3762bb8e29ded4c479\":{\"balance\":\"0x878678326eac900000\"},\"841145b44840c946e21dbc190264b8e0d5029369\":{\"balance\":\"0x3f870857a3e0e3800000\"},\"84232107932b12e03186583525ce023a703ef8d9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"84244fc95a6957ed7c1504e49f30b8c35eca4b79\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8431277d7bdd10457dc017408c8dbbbd414a8df3\":{\"balance\":\"0x222c8eb3ff6640000\"},\"84375afbf59b3a1d61a1be32d075e0e15a4fbca5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"843bd3502f45f8bc4da370b323bdac3fcf5f19a6\":{\"balance\":\"0x50039d63d11c900000\"},\"84503334630d77f74147f68b2e086613c8f1ade9\":{\"balance\":\"0x56bc75e2d631000000\"},\"845203750f7148a9aa262921e86d43bf641974fd\":{\"balance\":\"0x56bc75e2d63100000\"},\"8461ecc4a6a45eb1a5b947fb86b88069b91fcd6f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"84675e9177726d45eaa46b3992a340ba7f710c95\":{\"balance\":\"0x3635c9adc5dea00000\"},\"84686c7bad762c54b667d59f90943cd14d117a26\":{\"balance\":\"0x1158e460913d00000\"},\"8489f6ad1d9a94a297789156899db64154f1dbb5\":{\"balance\":\"0x137407c03c8c268000\"},\"848c994a79003fe7b7c26cc63212e1fc2f9c19eb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"848fbd29d67cf4a013cb02a4b176ef244e9ee68d\":{\"balance\":\"0x1172a636bbdc20000\"},\"84949dba559a63bfc845ded06e9f2d9b7f11ef24\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"849ab80790b28ff1ffd6ba394efc7463105c36f7\":{\"balance\":\"0x1e02be4ae6c840000\"},\"849b116f596301c5d8bb62e0e97a8248126e39f3\":{\"balance\":\"0x1043561a8829300000\"},\"84a74ceecff65cb93b2f949d773ef1ad7fb4a245\":{\"balance\":\"0x50a9b444685c70000\"},\"84aac7fa197ff85c30e03b7a5382b957f41f3afb\":{\"balance\":\"0x88b23acffd9900000\"},\"84af1b157342d54368260d17876230a534b54b0e\":{\"balance\":\"0x35659ef93f0fc40000\"},\"84b0ee6bb837d3a4c4c5011c3a228c0edab4634a\":{\"balance\":\"0x1158e460913d00000\"},\"84b4b74e6623ba9d1583e0cfbe49643f16384149\":{\"balance\":\"0x1158e460913d00000\"},\"84b6b6adbe2f5b3e2d682c66af1bc4905340c3ed\":{\"balance\":\"0x2192f8d22215008000\"},\"84b91e2e2902d05e2b591b41083bd7beb2d52c74\":{\"balance\":\"0x215e5128b4504648000\"},\"84bcbf22c09607ac84341d2edbc03bfb1739d744\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"84bfcef0491a0ae0694b37ceac024584f2aa0467\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"84cb7da0502df45cf561817bbd2362f451be02da\":{\"balance\":\"0x487a9a304539440000\"},\"84cc7878da605fdb019fab9b4ccfc157709cdda5\":{\"balance\":\"0x48798513af04c90000\"},\"84db1459bb00812ea67ecb3dc189b72187d9c501\":{\"balance\":\"0x811b8fbda85ab8000\"},\"84e9949680bece6841b9a7e5250d08acd87d16cd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"84e9cf8166c36abfa49053b7a1ad4036202681ef\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"84ec06f24700fe42414cb9897c154c88de2f6132\":{\"balance\":\"0x487a9a304539440000\"},\"84f522f0520eba52dd18ad21fa4b829f2b89cb97\":{\"balance\":\"0x10c5106d5134f130000\"},\"850b9db18ff84bf0c7da49ea3781d92090ad7e64\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"8510ee934f0cbc900e1007eb38a21e2a5101b8b2\":{\"balance\":\"0x5bf0ba6634f680000\"},\"8516fcaf77c893970fcd1a958ba9a00e49044019\":{\"balance\":\"0xaa3eb1691bce58000\"},\"851aa91c82f42fad5dd8e8bb5ea69c8f3a5977d1\":{\"balance\":\"0x80e561f2578798000\"},\"851c0d62be4635d4777e8035e37e4ba8517c6132\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"851dc38adb4593729a76f33a8616dab6f5f59a77\":{\"balance\":\"0x56bc75e2d63100000\"},\"8532490897bbb4ce8b7f6b837e4cba848fbe9976\":{\"balance\":\"0x56bc75e2d63100000\"},\"853e6abaf44469c72f151d4e223819aced4e3728\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"854691ce714f325ced55ce5928ce9ba12facd1b8\":{\"balance\":\"0xed70b5e9c3f2f00000\"},\"854c0c469c246b83b5d1b3eca443b39af5ee128a\":{\"balance\":\"0x56bc75e2d631000000\"},\"855d9aef2c39c6230d09c99ef6494989abe68785\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"8563c49361b625e768771c96151dbfbd1c906976\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8566610901aace38b83244f3a9c831306a67b9dc\":{\"balance\":\"0xb08213bcf8ffe00000\"},\"856aa23c82d7215bec8d57f60ad75ef14fa35f44\":{\"balance\":\"0x43c33c1937564800000\"},\"856e5ab3f64c9ab56b009393b01664fc0324050e\":{\"balance\":\"0x61093d7c2c6d380000\"},\"856eb204241a87830fb229031343dc30854f581a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"85732c065cbd64119941aed430ac59670b6c51c4\":{\"balance\":\"0x27a57362ab0a0e8000\"},\"8578e10212ca14ff0732a8241e37467db85632a9\":{\"balance\":\"0x14542ba12a337c00000\"},\"8579dadf1a395a3471e20b6f763d9a0ff19a3f6f\":{\"balance\":\"0xd8d726b7177a800000\"},\"857f100b1a5930225efc7e9020d78327b41c02cb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"85946d56a4d371a93368539690b60ec825107454\":{\"balance\":\"0x5dc892aa1131c80000\"},\"8599cbd5a6a9dcd4b966be387d69775da5e33c6f\":{\"balance\":\"0xc51f1b1d52622900000\"},\"859c600cf13d1d0273d5d1da3cd789e495899f27\":{\"balance\":\"0x90f534608a72880000\"},\"85a2f6ea94d05e8c1d9ae2f4910338a358e98ded\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"85b16f0b8b34dff3804f69e2168a4f7b24d1042b\":{\"balance\":\"0x112f423c7646d40000\"},\"85b2998d0c73302cb2ba13f489313301e053be15\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"85bb51bc3bfe9a1b2a2f6b1cda95bca8b38c8d5e\":{\"balance\":\"0x11712da04ba1ef0000\"},\"85c8f3cc7a354feac99a5e7bfe7cdfa351cfe355\":{\"balance\":\"0x15af1d78b58c400000\"},\"85ca1e727e9d1a87991cc2c41840ebb9edf21d1b\":{\"balance\":\"0xb98bc829a6f90000\"},\"85ca8bc6da2803d0725f5e1a456c89f9bc774e2f\":{\"balance\":\"0x2086ac351052600000\"},\"85d0d88754ac84b8b21ba93dd2bfec72626faba8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"85eb256b51c819d60ea61a82d12c9358d59c1cae\":{\"balance\":\"0x18efc84ad0c7b00000\"},\"85f0e7c1e3aff805a627a2aaf2cff6b4c0dbe9cb\":{\"balance\":\"0x1158e460913d00000\"},\"86026cad3fe4ea1ce7fca260d3d45eb09ea6a364\":{\"balance\":\"0xad78ebc5ac6200000\"},\"860f5ffc10de767ded807f71e861d647dfd219b1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"86153063a1ae7f02f1a88136d4d69c7c5e3e4327\":{\"balance\":\"0x3635c9adc5dea00000\"},\"86245f596691093ece3f3d3ca2263eace81941d9\":{\"balance\":\"0xa31062beeed700000\"},\"862569211e8c6327b5415e3a67e5738b15baaf6e\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"86297d730fe0f7a9ee24e08fb1087b31adb306a7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8644cc281be332ccced36da483fb2a0746d9ba2e\":{\"balance\":\"0x15af1d78b58c400000\"},\"86499a1228ff2d7ee307759364506f8e8c8307a5\":{\"balance\":\"0x6acb3df27e1f880000\"},\"864bec5069f855a4fd5892a6c4491db07c88ff7c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"86570ab259c9b1c32c9729202f77f590c07dd612\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8663a241a0a89e70e182c845e2105c8ad7264bcf\":{\"balance\":\"0x323b13d8398f3238000\"},\"8667fa1155fed732cfb8dca5a0d765ce0d0705ed\":{\"balance\":\"0x46ec965c393b10000\"},\"8668af868a1e98885f937f2615ded6751804eb2d\":{\"balance\":\"0x1158e460913d00000\"},\"86740a46648e845a5d96461b18091ff57be8a16f\":{\"balance\":\"0x14c0973485bf39400000\"},\"867eba56748a5904350d2ca2a5ce9ca00b670a9b\":{\"balance\":\"0x43c33c1937564800000\"},\"86806474c358047d9406e6a07f40945bc8328e67\":{\"balance\":\"0x1752eb0f7013d100000\"},\"86883d54cd3915e549095530f9ab1805e8c5432d\":{\"balance\":\"0xd8d726b7177a800000\"},\"868c23be873466d4c74c220a19b245d1787e807f\":{\"balance\":\"0x4a13bbbd92c88e8000\"},\"86924fb211aad23cf5ce600e0aae806396444087\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"8693e9b8be94425eef7969bc69f9d42f7cad671e\":{\"balance\":\"0x3637096c4bcc690000\"},\"869f1aa30e4455beb1822091de5cadec79a8f946\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"86a1eadeeb30461345d9ef6bd05216fa247c0d0c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"86a5f8259ed5b09e188ce346ee92d34aa5dd93fa\":{\"balance\":\"0xad78ebc5ac6200000\"},\"86b7bd563ceab686f96244f9ddc02ad7b0b14bc2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"86c28b5678af37d727ec05e4447790f15f71f2ea\":{\"balance\":\"0xad78ebc5ac6200000\"},\"86c4ce06d9ac185bb148d96f7b7abe73f441006d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"86c8d0d982b539f48f9830f9891f9d607a942659\":{\"balance\":\"0x2ced37761824fb00000\"},\"86c934e38e53be3b33f274d0539cfca159a4d0d1\":{\"balance\":\"0x34957444b840e80000\"},\"86ca0145957e6b0dfe36875fbe7a0dec55e17a28\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"86caafacf32aa0317c032ac36babed974791dc03\":{\"balance\":\"0x878678326eac9000000\"},\"86cdb7e51ac44772be3690f61d0e59766e8bfc18\":{\"balance\":\"0xd8d726b7177a800000\"},\"86df73bd377f2c09de63c45d67f283eaefa0f4ab\":{\"balance\":\"0x3635c9adc5dea00000\"},\"86e3fe86e93da486b14266eadf056cbfa4d91443\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"86e8670e27598ea09c3899ab7711d3b9fe901c17\":{\"balance\":\"0xad78ebc5ac6200000\"},\"86ef6426211949cc37f4c75e7850369d0cf5f479\":{\"balance\":\"0x2d65f32ea045af60000\"},\"86f05d19063e9369c6004eb3f123943a7cff4eab\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"86f23e9c0aafc78b9c404dcd60339a925bffa266\":{\"balance\":\"0x15af1d78b58c400000\"},\"86f4f40ad984fbb80933ae626e0e42f9333fdd41\":{\"balance\":\"0x3635c9adc5dea00000\"},\"86f95c5b11a293940e35c0b898d8b75f08aab06d\":{\"balance\":\"0x644e3e875fccf740000\"},\"86fff220e59305c09f483860d6f94e96fbe32f57\":{\"balance\":\"0x2535b6ab4c0420000\"},\"870796abc0db84af82da52a0ed68734de7e636f5\":{\"balance\":\"0x1043561a8829300000\"},\"870f15e5df8b0eabd02569537a8ef93b56785c42\":{\"balance\":\"0x150894e849b3900000\"},\"87183160d172d2e084d327b86bcb7c1d8e6784ef\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"871b8a8b51dea1989a5921f13ec1a955a515ad47\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"8725e8c753b3acbfdca55f3c62dfe1a59454968a\":{\"balance\":\"0x3637096c4bcc690000\"},\"8737dae671823a8d5917e0157ace9c43468d946b\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"873b7f786d3c99ff012c4a7cae2677270240b9c5\":{\"balance\":\"0x5dc892aa1131c80000\"},\"873c6f70efb6b1d0f2bbc57eebcd70617c6ce662\":{\"balance\":\"0x36f0d5275d09570000\"},\"873e49135c3391991060290aa7f6ccb8f85a78db\":{\"balance\":\"0x1158e460913d00000\"},\"875061ee12e820041a01942cb0e65bb427b00060\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"87584a3f613bd4fac74c1e780b86d6caeb890cb2\":{\"balance\":\"0x5c283d410394100000\"},\"8764d02722000996ecd475b433298e9f540b05bf\":{\"balance\":\"0xad78ebc5ac6200000\"},\"876c3f218b4776df3ca9dbfb270de152d94ed252\":{\"balance\":\"0x56bc75e2d63100000\"},\"8775a610c502b9f1e6ad4cdadb8ce29bff75f6e4\":{\"balance\":\"0x2086ac351052600000\"},\"87764e3677eef604cbc59aed24abdc566b09fc25\":{\"balance\":\"0xa2a15d09519be00000\"},\"8787d12677a5ec291e57e31ffbfad105c3324b87\":{\"balance\":\"0x2a24eb53208f3128000\"},\"8794bf47d54540ece5c72237a1ffb511ddb74762\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"87a53ea39f59a35bada8352521645594a1a714cb\":{\"balance\":\"0x678a932062e4180000\"},\"87a7c508ef71582dd9a54372f89cb01f252fb180\":{\"balance\":\"0xad78ebc5ac6200000\"},\"87af25d3f6f8eea15313d5fe4557e810c524c083\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"87b10f9c280098179a2b76e9ce90be61fc844d0d\":{\"balance\":\"0x487a9a304539440000\"},\"87bf7cd5d8a929e1c785f9e5449106ac232463c9\":{\"balance\":\"0x437b11fcc45640000\"},\"87c498170934b8233d1ad1e769317d5c475f2f40\":{\"balance\":\"0x3708baed3d68900000\"},\"87cf36ad03c9eae9053abb5242de9117bb0f2a0b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"87d7ac0653ccc67aa9c3469eef4352193f7dbb86\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"87e3062b2321e9dfb0875ce3849c9b2e3522d50a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"87e6034ecf23f8b5639d5f0ea70a22538a920423\":{\"balance\":\"0x11c7ea162e78200000\"},\"87ef6d8b6a7cbf9b5c8c97f67ee2adc2a73b3f77\":{\"balance\":\"0xadd1bd23c3c480000\"},\"87fb26c31e48644d693134205cae43b21f18614b\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"87fc4635263944ce14a46c75fa4a821f39ce7f72\":{\"balance\":\"0x1158e460913d00000\"},\"87fcbe7c4193ffcb08143779c9bec83fe7fda9fc\":{\"balance\":\"0x56f985d38644b8000\"},\"88015d7203c5e0224aeda286ed12f1a51b789333\":{\"balance\":\"0x10f08eda8e555098000\"},\"88106c27d20b74b4b98ca62b232bd5c97411171f\":{\"balance\":\"0xaadec983fcff40000\"},\"881230047c211d2d5b00d8de4c5139de5e3227c7\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"882aa798bf41df179f85520130f15ccdf59b5e58\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"882bd3a2e9d74110b24961c53777f22f1f46dc5d\":{\"balance\":\"0x2d4ca05e2b43ca80000\"},\"882c8f81872c79fed521cb5f950d8b032322ea69\":{\"balance\":\"0x878678326eac9000000\"},\"882f75708386653c80171d0663bfe30b017ed0ad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"88344909644c7ad4930fd873ca1c0da2d434c07f\":{\"balance\":\"0x727739fcb004d0000\"},\"8834b2453471f324fb26be5b25166b5b5726025d\":{\"balance\":\"0x1f0ff8f01daad40000\"},\"883a78aeabaa50d8ddd8570bcd34265f14b19363\":{\"balance\":\"0xd25522fda379a18000\"},\"8845e9f90e96336bac3c616be9d88402683e004c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8846928d683289a2d11df8db7a9474988ef01348\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"884980eb4565c1048317a8f47fdbb461965be481\":{\"balance\":\"0xd8d6119a8146050000\"},\"884a7a39d0916e05f1c242df55607f37df8c5fda\":{\"balance\":\"0x4f4843c157c8ca00000\"},\"885493bda36a0432976546c1ddce71c3f4570021\":{\"balance\":\"0xbbf510ddfcb260000\"},\"88609e0a465b6e99fce907166d57e9da0814f5c8\":{\"balance\":\"0x43c33c1937564800000\"},\"886d0a9e17c9c095af2ea2358b89ec705212ee94\":{\"balance\":\"0x18493fba64ef00000\"},\"88797e58675ed5cc4c19980783dbd0c956085153\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"887cac41cd706f3345f2d34ac34e01752a6e5909\":{\"balance\":\"0x20465cee9da1370000\"},\"88888a57bd9687cbf950aeeacf9740dcc4d1ef59\":{\"balance\":\"0x62a992e53a0af00000\"},\"8889448316ccf14ed86df8e2f478dc63c4338340\":{\"balance\":\"0xd2f13f7789f00000\"},\"888c16144933197cac26504dd76e06fd6600c789\":{\"balance\":\"0x56bc75e2d63100000\"},\"888e94917083d152202b53163939869d271175b4\":{\"balance\":\"0xd8d726b7177a800000\"},\"889087f66ff284f8b5efbd29493b706733ab1447\":{\"balance\":\"0x215f835bc769da80000\"},\"8895eb726226edc3f78cc6a515077b3296fdb95e\":{\"balance\":\"0xd5967be4fc3f100000\"},\"88975a5f1ef2528c300b83c0c607b8e87dd69315\":{\"balance\":\"0x486cb9799191e0000\"},\"889da40fb1b60f9ea9bd7a453e584cf7b1b4d9f7\":{\"balance\":\"0x22b1c8c1227a00000\"},\"889da662eb4a0a2a069d2bc24b05b4ee2e92c41b\":{\"balance\":\"0x5a2c8c5456c9f28000\"},\"88a122a2382c523931fb51a0ccad3beb5b7259c3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"88a2154430c0e41147d3c1fee3b3b006f851edbd\":{\"balance\":\"0x36356633ebd8ea0000\"},\"88b217ccb786a254cf4dc57f5d9ac3c455a30483\":{\"balance\":\"0x3224f42723d4540000\"},\"88bc43012edb0ea9f062ac437843250a39b78fbb\":{\"balance\":\"0x43c33c1937564800000\"},\"88c2516a7cdb09a6276d7297d30f5a4db1e84b86\":{\"balance\":\"0xd8d726b7177a800000\"},\"88c361640d6b69373b081ce0c433bd590287d5ec\":{\"balance\":\"0xa968163f0a57b400000\"},\"88d541c840ce43cefbaf6d19af6b9859b573c145\":{\"balance\":\"0x93739534d28680000\"},\"88de13b09931877c910d593165c364c8a1641bd3\":{\"balance\":\"0xa2a15d09519be00000\"},\"88dec5bd3f4eba2d18b8aacefa7b721548c319ba\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"88e6f9b247f988f6c0fc14c56f1de53ec69d43cc\":{\"balance\":\"0x56bc75e2d63100000\"},\"88ee7f0efc8f778c6b687ec32be9e7d6f020b674\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"88f1045f19f2d3191816b1df18bb6e1435ad1b38\":{\"balance\":\"0xd02ab486cedc00000\"},\"89009e3c6488bd5e570d1da34eabe28ed024de1b\":{\"balance\":\"0x43c33c1937564800000\"},\"89054430dcdc28ac15fa635ef87c105e602bf70c\":{\"balance\":\"0x5dacd13ca9e300000\"},\"8908760cd39b9c1e8184e6a752ee888e3f0b7045\":{\"balance\":\"0x14542ba12a337c00000\"},\"890fe11f3c24db8732d6c2e772e2297c7e65f139\":{\"balance\":\"0xd5627137da8b5900000\"},\"8914a680a5aec5226d4baaec2e5552b44dd7c874\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"891cb8238c88e93a1bcf61db49bd82b47a7f4f84\":{\"balance\":\"0x914878a8c05ee00000\"},\"8925da4549e15155e57a628522cea9dddf627d81\":{\"balance\":\"0x3636c25e66ece70000\"},\"893017ff1adad499aa065401b4236ce6e92b625a\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"8933491760c8f0b4df8caac78ed835caee21046d\":{\"balance\":\"0x43c33c1937564800000\"},\"893608751d68d046e85802926673cdf2f57f7cb8\":{\"balance\":\"0x11164759ffb320000\"},\"8938d1b4daee55a54d738cf17e4477f6794e46f7\":{\"balance\":\"0xfc936392801c0000\"},\"893a6c2eb8b40ab096b4f67e74a897b840746e86\":{\"balance\":\"0x5dc892aa1131c80000\"},\"893cdddf5377f3c751bf2e541120045a47cba101\":{\"balance\":\"0x56bc75e2d63100000\"},\"895613236f3584216ad75c5d3e07e3fa6863a778\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8957727e72cf629020f4e05edf799aa7458062d0\":{\"balance\":\"0x77432217e683600000\"},\"895d694e880b13ccd0848a86c5ce411f88476bbf\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"895ec5545644e0b78330fffab8ddeac9e833156c\":{\"balance\":\"0x2086ac351052600000\"},\"896009526a2c7b0c09a6f63a80bdf29d9c87de9c\":{\"balance\":\"0xbbb86b8223edeb0000\"},\"8967d7b9bdb7b4aed22e65a15dc803cb7a213f10\":{\"balance\":\"0x15af1d78b58c400000\"},\"896e335ca47af57962fa0f4dbf3e45e688cba584\":{\"balance\":\"0x4a2fc0ab6052120000\"},\"8973aefd5efaee96095d9e288f6a046c97374b43\":{\"balance\":\"0x7a4c4a0f332140000\"},\"898c72dd736558ef9e4be9fdc34fef54d7fc7e08\":{\"balance\":\"0x3635c9adc5dea00000\"},\"899b3c249f0c4b81df75d212004d3d6d952fd223\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"89ab13ee266d779c35e8bb04cd8a90cc2103a95b\":{\"balance\":\"0xcb49b44ba602d800000\"},\"89c433d601fad714da6369308fd26c1dc9942bbf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"89d75b8e0831e46f80bc174188184e006fde0eae\":{\"balance\":\"0x3635c9adc5dea00000\"},\"89e3b59a15864737d493c1d23cc53dbf8dcb1362\":{\"balance\":\"0xd8d726b7177a800000\"},\"89fc8e4d386b0d0bb4a707edf3bd560df1ad8f4e\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"89fee30d1728d96cecc1dab3da2e771afbcfaa41\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"8a1cc5ac111c49bfcfd848f37dd768aa65c88802\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"8a20e5b5cee7cd1f5515bace3bf4f77ffde5cc07\":{\"balance\":\"0x4563918244f400000\"},\"8a217db38bc35f215fd92906be42436fe7e6ed19\":{\"balance\":\"0x14542ba12a337c00000\"},\"8a243a0a9fea49b839547745ff2d11af3f4b0522\":{\"balance\":\"0x35659ef93f0fc40000\"},\"8a247d186510809f71cffc4559471c3910858121\":{\"balance\":\"0x61093d7c2c6d380000\"},\"8a3470282d5e2a2aefd7a75094c822c4f5aeef8a\":{\"balance\":\"0xd28bc606478a58000\"},\"8a36869ad478997cbf6d8924d20a3c8018e9855b\":{\"balance\":\"0x1158e460913d00000\"},\"8a4314fb61cd938fc33e15e816b113f2ac89a7fb\":{\"balance\":\"0x17764e7aed65100000\"},\"8a4f4a7f52a355ba105fca2072d3065fc8f7944b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8a5831282ce14a657a730dc18826f7f9b99db968\":{\"balance\":\"0xeabe8a5b41c1360000\"},\"8a5fb75793d043f1bcd43885e037bd30a528c927\":{\"balance\":\"0x13536e6d2e9ac20000\"},\"8a66abbc2d30ce21a833b0db8e561d5105e0a72c\":{\"balance\":\"0x25f1de5c76acdf0000\"},\"8a746c5d67064711bfca685b95a4fe291a27028e\":{\"balance\":\"0x22b1c8c1227a00000\"},\"8a780ab87a9145fe10ed60fa476a740af4cab1d2\":{\"balance\":\"0x121b2e5e6464780000\"},\"8a7a06be199a3a58019d846ac9cbd4d95dd757de\":{\"balance\":\"0xa2a423944256f40000\"},\"8a810114b2025db9fbb50099a6e0cb9e2efa6bdc\":{\"balance\":\"0x678a932062e4180000\"},\"8a86e4a51c013b1fb4c76bcf30667c78d52eedef\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8a9eca9c5aba8e139f8003edf1163afb70aa3aa9\":{\"balance\":\"0x23c757072b8dd00000\"},\"8ab839aeaf2ad37cb78bacbbb633bcc5c099dc46\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8ac89bd9b8301e6b0677fa25fcf0f58f0cc7b611\":{\"balance\":\"0x1158e460913d00000\"},\"8adc53ef8c18ed3051785d88e996f3e4b20ecd51\":{\"balance\":\"0x8e4d316827686400000\"},\"8ae6f80b70e1f23c91fbd5a966b0e499d95df832\":{\"balance\":\"0xaadec983fcff40000\"},\"8ae9ef8c8a8adfa6ab798ab2cdc405082a1bbb70\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8af626a5f327d7506589eeb7010ff9c9446020d2\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"8b01da34d470c1d115acf4d8113c4dd8a8c338e4\":{\"balance\":\"0x5572dcefab697900000\"},\"8b07d050754dc9ba230db01c310afdb5395aa1b3\":{\"balance\":\"0x666b06e62a6200000\"},\"8b20ad3b94656dbdc0dd21a393d8a7d9e02138cb\":{\"balance\":\"0xa2a15d09519be00000\"},\"8b27392206b958cd375d7ef8af2cf8ef0598c0bc\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8b30c04098d7a7e6420c357ea7bfa49bac9a8a18\":{\"balance\":\"0x1b1b113f91fb0140000\"},\"8b338411f26ccf37658cc75521d77629099e467d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8b36224c7356e751f0c066c35e3b44860364bfc2\":{\"balance\":\"0x3627bac7a3d9278000\"},\"8b3696f3c60de32432a2e4c395ef0303b7e81e75\":{\"balance\":\"0x65a4da25d3016c00000\"},\"8b393fb0813ee101db1e14ecc7d322c72b8c0473\":{\"balance\":\"0x18b26a313e8ae90000\"},\"8b48e19d39dd35b66e6e1bb6b9c657cb2cf59d04\":{\"balance\":\"0x3c755ac9c024a018000\"},\"8b505e2871f7deb7a63895208e8227dcaa1bff05\":{\"balance\":\"0xcf68efc308d79bc0000\"},\"8b57b2bc83cc8d4de331204e893f2f3b1db1079a\":{\"balance\":\"0x22b1c8c1227a00000\"},\"8b5c914b128bf1695c088923fa467e7911f351fa\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"8b5f29cc2faa262cdef30ef554f50eb488146eac\":{\"balance\":\"0x13b68705c9720810000\"},\"8b7056f6abf3b118d026e944d5c073433ca451d7\":{\"balance\":\"0x3635c6204739d98000\"},\"8b714522fa2839620470edcf0c4401b713663df1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8b74a7cb1bb8c58fce267466a30358adaf527f61\":{\"balance\":\"0x2e257784e25b4500000\"},\"8b7e9f6f05f7e36476a16e3e7100c9031cf404af\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8b81156e698639943c01a75272ad3d35851ab282\":{\"balance\":\"0x12b3165f65d3e50000\"},\"8b9577920053b1a00189304d888010d9ef2cb4bf\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8b9841862e77fbbe919470935583a93cf027e450\":{\"balance\":\"0x6c6c5334427f1f0000\"},\"8b997dbc078ad02961355da0a159f2927ed43d64\":{\"balance\":\"0xaadec983fcff40000\"},\"8b9fda7d981fe9d64287f85c94d83f9074849fcc\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"8bb0212f3295e029cab1d961b04133a1809e7b91\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8bbeacfc29cfe93402db3c41d99ab759662e73ec\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8bc1ff8714828bf286ff7e8a7709106548ed1b18\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"8bd0b65a50ef5cef84fec420be7b89ed1470ceb9\":{\"balance\":\"0x28a77936e92c81c0000\"},\"8bd6b1c6d74d010d1008dba6ef835d4430b35c32\":{\"balance\":\"0x2b5e3af16b1880000\"},\"8bd8d4c4e943f6c8073921dc17e3e8d7a0761627\":{\"balance\":\"0x9f04219d8d34950000\"},\"8bdfda6c215720eda2136f91052321af4e936c1f\":{\"balance\":\"0x3635e619bb04d40000\"},\"8bea40379347a5c891d59a6363315640f5a7e07a\":{\"balance\":\"0x6c6b76ef96970c0000\"},\"8bf02bd748690e1fd1c76d270833048b66b25fd3\":{\"balance\":\"0x27fade568eba9600000\"},\"8bf297f8f453523ed66a1acb7676856337b93bf0\":{\"balance\":\"0xd8d726b7177a800000\"},\"8bf373d076814cbc57e1c6d16a82c5be13c73d37\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8c1023fde1574db8bb54f1739670157ca47da652\":{\"balance\":\"0x179cf9ac3a1b1770000\"},\"8c1fbe5f0aea359c5aa1fa08c8895412ca8e05a6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8c22426055b76f11f0a2de1a7f819a619685fe60\":{\"balance\":\"0x6b56051582a9700000\"},\"8c2b7d8b608d28b77f5caa9cd645242a823e4cd9\":{\"balance\":\"0x62a992e53a0af00000\"},\"8c2fbeee8eacc5c5d77c16abd462ee9c8145f34b\":{\"balance\":\"0x692ae8897081d00000\"},\"8c3a9ee71f729f236cba3867b4d79d8ceee25dbc\":{\"balance\":\"0x56bc75e2d63100000\"},\"8c50aa2a9212bcde56418ae261f0b35e7a9dbb82\":{\"balance\":\"0x15af1d78b58c400000\"},\"8c54c7f8b9896e75d7d5f5c760258699957142ad\":{\"balance\":\"0x22b1c8c1227a00000\"},\"8c5d16ed65e3ed7e8b96ca972bc86173e3500b03\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8c6aa882ee322ca848578c06cb0fa911d3608305\":{\"balance\":\"0x2086ac351052600000\"},\"8c6ae7a05a1de57582ae2768204276c0ff47ed03\":{\"balance\":\"0x2c0bb3dd30c4e2000000\"},\"8c6f9f4e5b7ae276bf58497bd7bf2a7d25245f64\":{\"balance\":\"0x93fe5c57d710680000\"},\"8c75956e8fed50f5a7dd7cfd27da200f6746aea6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8c7cb4e48b25031aa1c4f92925d631a8c3edc761\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8c7fa5cae82fedb69ab189d3ff27ae209293fb93\":{\"balance\":\"0x15af880d8cdb830000\"},\"8c81410ea8354cc5c65c41be8bd5de733c0b111d\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"8c83d424a3cf24d51f01923dd54a18d6b6fede7b\":{\"balance\":\"0xd8d726b7177a800000\"},\"8c900a8236b08c2b65405d39d75f20062a7561fd\":{\"balance\":\"0x58e7926ee858a00000\"},\"8c93c3c6db9d37717de165c3a1b4fe51952c08de\":{\"balance\":\"0x15af1d78b58c400000\"},\"8c999591fd72ef7111efca7a9e97a2356b3b000a\":{\"balance\":\"0xdd64e2aa0a67500000\"},\"8ca6989746b06e32e2487461b1ce996a273acfd7\":{\"balance\":\"0x1158e460913d00000\"},\"8cb3aa3fcd212854d7578fcc30fdede6742a312a\":{\"balance\":\"0x1043561a8829300000\"},\"8cc0d7c016fa7aa950114aa1db094882eda274ea\":{\"balance\":\"0x8a9aba557e36c0000\"},\"8cc652dd13e7fe14dabbb36d5d320db9ffee8a54\":{\"balance\":\"0x61093d7c2c6d380000\"},\"8ccabf25077f3aa41545344d53be1b2b9c339000\":{\"balance\":\"0x5be866c562c5440000\"},\"8ccf3aa21ab742576ad8c422f71bb188591dea8a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8cd0cd22e620eda79c0461e896c93c44837e2968\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8cde8b732e6023878eb23ed16229124b5f7afbec\":{\"balance\":\"0x73f75d1a085ba0000\"},\"8ce22f9fa372449a420610b47ae0c8d565481232\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8ce4949d8a16542d423c17984e6739fa72ceb177\":{\"balance\":\"0x54b405926f4a63d8000\"},\"8ce5e3b5f591d5eca38abf228f2e3c35134bdac0\":{\"balance\":\"0x7dc35b84897c380000\"},\"8cee38d6595788a56e3fb94634b3ffe1fbdb26d6\":{\"balance\":\"0x43c33c1937564800000\"},\"8ceea15eec3bdad8023f98ecf25b2b8fef27db29\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8cf3546fd1cda33d58845fc8fcfecabca7c5642a\":{\"balance\":\"0x1f1e39932cb3278000\"},\"8cf6da0204dbc4860b46ad973fc111008d9e0c46\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8cfedef198db0a9143f09129b3fd64dcbb9b4956\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8d04a5ebfb5db409db0617c9fa5631c192861f4a\":{\"balance\":\"0x34957444b840e80000\"},\"8d06e464245cad614939e0af0845e6d730e20374\":{\"balance\":\"0xadc8a28f3d87d8000\"},\"8d07d42d831c2d7c838aa1872b3ad5d277176823\":{\"balance\":\"0x12ee1f9ddbee680000\"},\"8d0b9ea53fd263415eac11391f7ce9123c447062\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8d1794da509cb297053661a14aa892333231e3c1\":{\"balance\":\"0xad201a6794ff80000\"},\"8d1abd897dacd4312e18080c88fb9647eab44052\":{\"balance\":\"0xbb59a27953c600000\"},\"8d2303341e1e1eb5e8189bde03f73a60a2a54861\":{\"balance\":\"0x56bc75e2d63100000\"},\"8d238e036596987643d73173c37b0ad06055b96c\":{\"balance\":\"0x7148bf0a2af0660000\"},\"8d2e31b08803b2c5f13d398ecad88528209f6057\":{\"balance\":\"0x21db8bbcad11e840000\"},\"8d378f0edc0bb0f0686d6a20be6a7692c4fa24b8\":{\"balance\":\"0x56bc75e2d63100000\"},\"8d4b603c5dd4570c34669515fdcc665890840c77\":{\"balance\":\"0xfc936392801c0000\"},\"8d51a4cc62011322c696fd725b9fb8f53feaaa07\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8d544c32c07fd0842c761d53a897d6c950bb7599\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8d5ef172bf77315ea64e85d0061986c794c6f519\":{\"balance\":\"0xd5967be4fc3f100000\"},\"8d616b1eee77eef6f176e0698db3c0c141b2fc8f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8d6170ff66978e773bb621bf72b1ba7be3a7f87e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8d620bde17228f6cbba74df6be87264d985cc179\":{\"balance\":\"0x56bc75e2d63100000\"},\"8d629c20608135491b5013f1002586a0383130e5\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"8d6657f59711b1f803c6ebef682f915b62f92dc9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8d667637e29eca05b6bfbef1f96d460eefbf9984\":{\"balance\":\"0xd8d726b7177a800000\"},\"8d6df209484d7b94702b03a53e56b9fb0660f6f0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8d795c5f4a5689ad62da961671f028065286d554\":{\"balance\":\"0x6f05b59d3b20000000\"},\"8d7f3e61299c2db9b9c0487cf627519ed00a9123\":{\"balance\":\"0x5e74a8505e80a00000\"},\"8d89170b92b2be2c08d57c48a7b190a2f146720f\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"8d93dac785f88f1a84bf927d53652b45a154ccdd\":{\"balance\":\"0x890b0c2e14fb80000\"},\"8d9952d0bb4ebfa0efd01a3aa9e8e87f0525742e\":{\"balance\":\"0xbb9125542263900000\"},\"8d9a0c70d2262042df1017d6c303132024772712\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8d9ed7f4553058c26f7836a3802d3064eb1b363d\":{\"balance\":\"0x4e1003b28d9280000\"},\"8da1178f55d97772bb1d24111a404a4f8715b95d\":{\"balance\":\"0x2f9ac3f6de00808000\"},\"8da1d359ba6cb4bcc57d7a437720d55db2f01c72\":{\"balance\":\"0x4563918244f400000\"},\"8dab948ae81da301d972e3f617a912e5a753712e\":{\"balance\":\"0x15af1d78b58c400000\"},\"8daddf52efbd74da95b969a5476f4fbbb563bfd2\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"8db185fe1b70a94a6a080e7e23a8bedc4acbf34b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"8db58e406e202df9bc703c480bd8ed248d52a032\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8dbc3e6cb433e194f40f82b40faadb1f8b856116\":{\"balance\":\"0x678a932062e4180000\"},\"8dc1d5111d09af25fdfcac455c7cec283e6d6775\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8dd484ff8a307364eb66c525a571aac701c5c318\":{\"balance\":\"0xd8d726b7177a800000\"},\"8dd6a9bae57f518549ada677466fea8ab04fd9b4\":{\"balance\":\"0xd8d726b7177a800000\"},\"8dde3cb8118568ef4503fe998ccdf536bf19a098\":{\"balance\":\"0xd8d726b7177a800000\"},\"8dde60eb08a099d7daa356daaab2470d7b025a6b\":{\"balance\":\"0xaadec983fcff40000\"},\"8df339214b6ad1b24663ce716034749d6ef838d9\":{\"balance\":\"0x2544faa778090e00000\"},\"8df53d96191471e059de51c718b983e4a51d2afd\":{\"balance\":\"0x6c6b935b8bbd4000000\"},\"8dfbafbc0e5b5c86cd1ad697feea04f43188de96\":{\"balance\":\"0x15252b7f5fa0de0000\"},\"8e073bad25e42218615f4a0e6b2ea8f8de2230c0\":{\"balance\":\"0x823d629d026bfa0000\"},\"8e0fee38685a94aabcd7ce857b6b1409824f75b8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8e23facd12c765c36ab81a6dd34d8aa9e68918ae\":{\"balance\":\"0x911e4868dba9b0000\"},\"8e2f9034c9254719c38e50c9aa64305ed696df1e\":{\"balance\":\"0x1004e2e45fb7ee00000\"},\"8e3240b0810e1cf407a500804740cf8d616432a4\":{\"balance\":\"0x22f6655ef0b388000\"},\"8e486a0442d171c8605be348fee57eb5085eff0d\":{\"balance\":\"0xd8d726b7177a800000\"},\"8e6156336be2cdbe32140df08a2ba55fd0a58463\":{\"balance\":\"0x4099e1d6357180000\"},\"8e670815fb67aeaea57b86534edc00cdf564fee5\":{\"balance\":\"0xb2e4b323d9c5100000\"},\"8e6d7485cbe990acc1ad0ee9e8ccf39c0c93440e\":{\"balance\":\"0x33c5499031720c0000\"},\"8e74e0d1b77ebc823aca03f119854cb12027f6d7\":{\"balance\":\"0x16b352da5e0ed3000000\"},\"8e78f351457d016f4ad2755ec7424e5c21ba6d51\":{\"balance\":\"0x7ea28327577080000\"},\"8e7936d592008fdc7aa04edeeb755ab513dbb89d\":{\"balance\":\"0x1158e460913d00000\"},\"8e7fd23848f4db07906a7d10c04b21803bb08227\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8e92aba38e72a098170b92959246537a2e5556c0\":{\"balance\":\"0xe7eeba3410b740000\"},\"8e98766524b0cf2747c50dd43b9567594d9731de\":{\"balance\":\"0x6c44b7c26182280000\"},\"8e9b35ad4a0a86f758446fffde34269d940ceacd\":{\"balance\":\"0xd8d726b7177a800000\"},\"8e9c08f738661f9676236eff82ba6261dd3f4822\":{\"balance\":\"0x56bc75e2d63100000\"},\"8e9c429266df057efa78dd1d5f77fc40742ad466\":{\"balance\":\"0x10442ed1b56c7c8000\"},\"8ea656e71ec651bfa17c5a5759d86031cc359977\":{\"balance\":\"0x56bc75e2d63100000\"},\"8eae29435598ba8f1c93428cdb3e2b4d31078e00\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8eb1fbe4e5d3019cd7d30dae9c0d5b4c76fb6331\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8eb51774af206b966b8909c45aa6722748802c0c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8eb8c71982a00fb84275293253f8044544b66b49\":{\"balance\":\"0x15af1d78b58c400000\"},\"8ecbcfacbfafe9f00c3922a24e2cf0026756ca20\":{\"balance\":\"0x131beb925ffd3200000\"},\"8eceb2e124536c5b5ffc640ed14ff15ed9a8cb71\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8ed0af11ff2870da0681004afe18b013f7bd3882\":{\"balance\":\"0xd8d726b7177a800000\"},\"8ed143701f2f72280fd04a7b4164281979ea87c9\":{\"balance\":\"0xc249fdd327780000\"},\"8ed1528b447ed4297902f639c514d0944a88f8c8\":{\"balance\":\"0xac6e77ab663a80000\"},\"8ed4284c0f47449c15b8d9b3245de8beb6ce80bf\":{\"balance\":\"0x2b5e3af16b18800000\"},\"8ede7e3dc50749c6c50e2e28168478c34db81946\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"8ee584337ddbc80f9e3498df55f0a21eacb57fb1\":{\"balance\":\"0x1158e460913d00000\"},\"8eebec1a62c08b05a7d1d59180af9ff0d18e3f36\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"8ef4d8a2c23c5279187b64e96f741404085385f3\":{\"balance\":\"0x103dc1e9a9697b0000\"},\"8ef711e43a13918f1303e81d0ea78c9eefd67eb2\":{\"balance\":\"0xd8d726b7177a800000\"},\"8efec058cc546157766a632775404a334aaada87\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"8f02bda6c36922a6be6a509be51906d393f7b99b\":{\"balance\":\"0x37490dc12ebe7f8000\"},\"8f0538ed71da1155e0f3bde5667ceb84318a1a87\":{\"balance\":\"0x692ae8897081d00000\"},\"8f067c7c1bbd57780b7b9eeb9ec0032f90d0dcf9\":{\"balance\":\"0x43c33c1937564800000\"},\"8f0ab894bd3f4e697dbcfb859d497a9ba195994a\":{\"balance\":\"0x85d638b65472aa20000\"},\"8f0af37566d152802f1ae8f928b25af9b139b448\":{\"balance\":\"0xad78ebc5ac6200000\"},\"8f1952eed1c548d9ee9b97d0169a07933be69f63\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8f1fcc3c51e252b693bc5b0ec3f63529fe69281e\":{\"balance\":\"0x14542ba12a337c00000\"},\"8f226096c184ebb40105e08dac4d22e1c2d54d30\":{\"balance\":\"0x109e437bd1618c0000\"},\"8f29a14a845ad458f2d108b568d813166bcdf477\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"8f31c7005197ec997a87e69bec48649ab94bb2a5\":{\"balance\":\"0xd8d726b7177a800000\"},\"8f41b1fbf54298f5d0bc2d122f4eb95da4e5cd3d\":{\"balance\":\"0x1333832f5e335c0000\"},\"8f47328ee03201c9d35ed2b5412b25decc859362\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8f473d0ab876ddaa15608621d7013e6ff714b675\":{\"balance\":\"0x19801c83b6c7c00000\"},\"8f4d1d41693e462cf982fd81d0aa701d3a5374c9\":{\"balance\":\"0xd8d726b7177a800000\"},\"8f4d1e7e4561284a34fef9673c0d34e12af4aa03\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8f4fb1aea7cd0f570ea5e61b40a4f4510b6264e4\":{\"balance\":\"0xd8d726b7177a800000\"},\"8f561b41b209f248c8a99f858788376250609cf3\":{\"balance\":\"0x5c283d410394100000\"},\"8f58d8348fc1dc4e0dd8343b6543c857045ee940\":{\"balance\":\"0x2e3038df47303280000\"},\"8f60895fbebbb5017fcbff3cdda397292bf25ba6\":{\"balance\":\"0x174406ff9f6fd28000\"},\"8f64b9c1246d857831643107d355b5c75fef5d4f\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"8f660f8b2e4c7cc2b4ac9c47ed28508d5f8f8650\":{\"balance\":\"0x43c33c1937564800000\"},\"8f69eafd0233cadb4059ab779c46edf2a0506e48\":{\"balance\":\"0x60f06620a849450000\"},\"8f717ec1552f4c440084fba1154a81dc003ebdc0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"8f8acb107607388479f64baaabea8ff007ada97d\":{\"balance\":\"0x5c6f3080ad423f40000\"},\"8f8cd26e82e7c6defd02dfad07979021cbf7150c\":{\"balance\":\"0xa2a15d09519be00000\"},\"8f8f37d0ad8f335d2a7101b41156b688a81a9cbe\":{\"balance\":\"0x3cb71f51fc5580000\"},\"8f92844f282a92999ee5b4a8d773d06b694dbd9f\":{\"balance\":\"0x692ae8897081d00000\"},\"8fac748f784a0fed68dba43319b42a75b4649c6e\":{\"balance\":\"0x3154c9729d05780000\"},\"8fd9a5c33a7d9edce0997bdf77ab306424a11ea9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8feffadb387a1547fb284da9b8147f3e7c6dc6da\":{\"balance\":\"0x2d627be45305080000\"},\"8ff46045687723dc33e4d099a06904f1ebb584dc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"8ffa062122ac307418821adb9311075a3703bfa3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"8ffe322997b8e404422d19c54aadb18f5bc8e9b7\":{\"balance\":\"0xd5967be4fc3f100000\"},\"900194c4b1074305d19de405b0ac78280ecaf967\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9003d270891ba2df643da8341583193545e3e000\":{\"balance\":\"0xd8d726b7177a800000\"},\"90057af9aa66307ec9f033b29724d3b2f41eb6f9\":{\"balance\":\"0x19d1d6aadb2c52e80000\"},\"900f0b8e35b668f81ef252b13855aa5007d012e7\":{\"balance\":\"0x170a0f5040e5040000\"},\"9018cc1f48d2308e252ab6089fb99a7c1d569410\":{\"balance\":\"0xad78ebc5ac6200000\"},\"901d99b699e5c6911519cb2076b4c76330c54d22\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"902d74a157f7d2b9a3378b1f56703730e03a1719\":{\"balance\":\"0xd8d726b7177a800000\"},\"903413878aea3bc1086309a3fe768b65559e8cab\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"904966cc2213b5b8cb5bd6089ef9cddbef7edfcc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"904caa429c619d940f8e6741826a0db692b19728\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9052f2e4a3e3c12dd1c71bf78a4ec3043dc88b7e\":{\"balance\":\"0xe7eeba3410b740000\"},\"905526568ac123afc0e84aa715124febe83dc87c\":{\"balance\":\"0xf8699329677e0000\"},\"9092918707c621fdbd1d90fb80eb787fd26f7350\":{\"balance\":\"0x855b5ba65c84f00000\"},\"909b5e763a39dcc795223d73a1dbb7d94ca75ac8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"90acced7e48c08c6b934646dfa0adf29dc94074f\":{\"balance\":\"0x30b4b157bbd490000\"},\"90b1f370f9c1eb0be0fb8e2b8ad96a416371dd8a\":{\"balance\":\"0x30ca024f987b900000\"},\"90b62f131a5f29b45571513ee7a74a8f0b232202\":{\"balance\":\"0x890b0c2e14fb80000\"},\"90bd62a050845261fa4a9f7cf241ea630b05efb8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"90c41eba008e20cbe927f346603fc88698125969\":{\"balance\":\"0x246ddf97976680000\"},\"90d2809ae1d1ffd8f63eda01de49dd552df3d1bc\":{\"balance\":\"0xd8bb6549b02bb80000\"},\"90dc09f717fc2a5b69fd60ba08ebf40bf4e8246c\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"90e300ac71451e401f887f6e7728851647a80e07\":{\"balance\":\"0x15af1d78b58c400000\"},\"90e35aabb2deef408bb9b5acef714457dfde6272\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"90e7070f4d033fe6910c9efe5a278e1fc6234def\":{\"balance\":\"0x571380819b3040000\"},\"90e93e4dc17121487952333614002be42356498e\":{\"balance\":\"0x678a932062e4180000\"},\"90e9a9a82edaa814c284d232b6e9ba90701d4952\":{\"balance\":\"0x56be03ca3e47d8000\"},\"90f774c9147dde90853ddc43f08f16d455178b8c\":{\"balance\":\"0xd8d726b7177a800000\"},\"90fc537b210658660a83baa9ac4a8402f65746a8\":{\"balance\":\"0x65ea3db75546600000\"},\"91050a5cffadedb4bb6eaafbc9e5013428e96c80\":{\"balance\":\"0x5c283d410394100000\"},\"91051764af6b808e4212c77e30a5572eaa317070\":{\"balance\":\"0x3635c9adc5dea00000\"},\"910b7d577a7e39aa23acf62ad7f1ef342934b968\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"910e996543344c6815fb97cda7af4b8698765a5b\":{\"balance\":\"0x59af69829cf640000\"},\"911feea61fe0ed50c5b9e5a0d66071399d28bdc6\":{\"balance\":\"0x340aad21b3b700000\"},\"911ff233e1a211c0172c92b46cf997030582c83a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"9120e71173e1ba19ba8f9f4fdbdcaa34e1d6bb78\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"91211712719f2b084d3b3875a85069f466363141\":{\"balance\":\"0x3635c9adc5dea00000\"},\"912304118b80473d9e9fe3ee458fbe610ffda2bb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"91546b79ecf69f936b5a561508b0d7e50cc5992f\":{\"balance\":\"0xe7eeba3410b740000\"},\"9156d18029350e470408f15f1aa3be9f040a67c6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"91620f3eb304e813d28b0297556d65dc4e5de5aa\":{\"balance\":\"0xcf152640c5c8300000\"},\"916bf7e3c545921d3206d900c24f14127cbd5e70\":{\"balance\":\"0x3d0ddbc7df2bb100000\"},\"916cf17d71412805f4afc3444a0b8dd1d9339d16\":{\"balance\":\"0xc673ce3c40160000\"},\"917b8f9f3a8d09e9202c52c29e724196b897d35e\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"918967918cd897dd0005e36dc6c883ef438fc8c7\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"91898eab8c05c0222883cd4db23b7795e1a24ad7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9191f94698210516cf6321a142070e20597674ed\":{\"balance\":\"0xee9d5be6fc110000\"},\"91a4149a2c7b1b3a67ea28aff34725e0bf8d7524\":{\"balance\":\"0x692ae8897081d00000\"},\"91a787bc5196f34857fe0c372f4df376aaa76613\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"91a8baaed012ea2e63803b593d0d0c2aab4c5b0a\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"91ac5cfe67c54aa7ebfba448666c461a3b1fe2e1\":{\"balance\":\"0x15c93492bf9dfc0000\"},\"91bb3f79022bf3c453f4ff256e269b15cf2c9cbd\":{\"balance\":\"0x52585c13fe3a5c0000\"},\"91c75e3cb4aa89f34619a164e2a47898f5674d9c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"91c80caa081b38351d2a0e0e00f80a34e56474c1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"91cc46aa379f856a6640dccd5a648a7902f849d9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"91d2a9ee1a6db20f5317cca7fbe2313895db8ef8\":{\"balance\":\"0x1ccc3a52f306e280000\"},\"91d66ea6288faa4b3d606c2aa45c7b6b8a252739\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"91dbb6aaad149585be47375c5d6de5ff09191518\":{\"balance\":\"0x43c33c1937564800000\"},\"91e8810652e8e6161525d63bb7751dc20f676076\":{\"balance\":\"0x274d656ac90e340000\"},\"91f516146cda20281719978060c6be4149067c88\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"91f624b24a1fa5a056fe571229e7379db14b9a1e\":{\"balance\":\"0x28a8517c669b3570000\"},\"91fe8a4c6164df8fa606995d6ba7adcaf1c893ce\":{\"balance\":\"0x39992648a23c8a00000\"},\"921f5261f4f612760706892625c75e7bce96b708\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9221c9ce01232665741096ac07235903ad1fe2fc\":{\"balance\":\"0x6db63335522628000\"},\"9225983860a1cb4623c72480ac16272b0c95e5f5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9225d46a5a80943924a39e5b84b96da0ac450581\":{\"balance\":\"0x878678326eac9000000\"},\"922a20c79a1d3a26dd3829677bf1d45c8f672bb6\":{\"balance\":\"0xd8d726b7177a800000\"},\"92438e5203b6346ff886d7c36288aacccc78ceca\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9243d7762d77287b12638688b9854e88a769b271\":{\"balance\":\"0x3635c9adc5dea00000\"},\"924bce7a853c970bb5ec7bb759baeb9c7410857b\":{\"balance\":\"0xbe202d6a0eda0000\"},\"924efa6db595b79313277e88319625076b580a10\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92558226b384626cad48e09d966bf1395ee7ea5d\":{\"balance\":\"0x121ea68c114e510000\"},\"926082cb7eed4b1993ad245a477267e1c33cd568\":{\"balance\":\"0x144a74badfa4b60000\"},\"926209b7fda54e8ddb9d9e4d3d19ebdc8e88c29f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9268d62646563611dc3b832a30aa2394c64613e3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92698e345378c62d8eda184d94366a144b0c105b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"92793ac5b37268774a7130de2bbd330405661773\":{\"balance\":\"0x22ca3587cf4eb0000\"},\"9279b2228cec8f7b4dda3f320e9a0466c2f585ca\":{\"balance\":\"0x10f0cf064dd59200000\"},\"927cb7dc187036b5427bc7e200c5ec450c1d27d4\":{\"balance\":\"0xbb59a27953c600000\"},\"927cc2bfda0e088d02eff70b38b08aa53cc30941\":{\"balance\":\"0x646f60a1f986360000\"},\"9284f96ddb47b5186ee558aa31324df5361c0f73\":{\"balance\":\"0x3635c9adc5dea000000\"},\"929d368eb46a2d1fbdc8ffa0607ede4ba88f59ad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92a7c5a64362e9f842a23deca21035857f889800\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"92a898d46f19719c38126a8a3c27867ae2cee596\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92a971a739799f8cb48ea8475d72b2d2474172e6\":{\"balance\":\"0xd5967be4fc3f100000\"},\"92aae59768eddff83cfe60bb512e730a05a161d7\":{\"balance\":\"0x5c9778410c76d18000\"},\"92ad1b3d75fba67d54663da9fc848a8ade10fa67\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92ae5b7c7eb492ff1ffa16dd42ad9cad40b7f8dc\":{\"balance\":\"0x2ee449550898e40000\"},\"92c0f573eccf62c54810ee6ba8d1f113542b301b\":{\"balance\":\"0xb7726f16ccb1e00000\"},\"92c13fe0d6ce87fd50e03def9fa6400509bd7073\":{\"balance\":\"0x22b1c8c1227a00000\"},\"92c94c2820dfcf7156e6f13088ece7958b3676fd\":{\"balance\":\"0x52d542804f1ce0000\"},\"92cfd60188efdfb2f8c2e7b1698abb9526c1511f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92d8ad9a4d61683b80d4a6672e84c20d62421e80\":{\"balance\":\"0x1158e460913d00000\"},\"92dca5e102b3b81b60f1a504634947c374a88ccb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"92e435340e9d253c00256389f52b067d55974e76\":{\"balance\":\"0xe873f44133cb00000\"},\"92e4392816e5f2ef5fb65837cec2c2325cc64922\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"92e6581e1da1f9b846e09347333dc818e2d2ac66\":{\"balance\":\"0xc55325ca7415e00000\"},\"931df34d1225bcd4224e63680d5c4c09bce735a6\":{\"balance\":\"0x3afb087b876900000\"},\"931fe712f64207a2fd5022728843548bfb8cbb05\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"93235f340d2863e18d2f4c52996516138d220267\":{\"balance\":\"0x4002e44fda7d40000\"},\"93258255b37c7f58f4b10673a932dd3afd90f4f2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9328d55ccb3fce531f199382339f0e576ee840a3\":{\"balance\":\"0xd8d726b7177a800000\"},\"9329ffdc268babde8874b366406c81445b9b2d35\":{\"balance\":\"0x16e62f8c730ca18000\"},\"932b9c04d40d2ac83083d94298169dae81ab2ed0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"933436c8472655f64c3afaaf7c4c621c83a62b38\":{\"balance\":\"0x3635c9adc5dea00000\"},\"933bf33f8299702b3a902642c33e0bfaea5c1ca3\":{\"balance\":\"0xd2f13f7789f00000\"},\"9340345ca6a3eabdb77363f2586043f29438ce0b\":{\"balance\":\"0x1cc805da0dfff10000\"},\"9340b5f678e45ee05eb708bb7abb6ec8f08f1b6b\":{\"balance\":\"0x14542ba12a337c00000\"},\"934af21b7ebfa467e2ced65aa34edd3a0ec71332\":{\"balance\":\"0x7801f3e80cc0ff00000\"},\"935069444a6a984de2084e46692ab99f671fc727\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"93507e9e8119cbceda8ab087e7ecb071383d6981\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"93678a3c57151aeb68efdc43ef4d36cb59a009f3\":{\"balance\":\"0x1a12a92bc3c3e0000\"},\"936dcf000194e3bff50ac5b4243a3ba014d661d8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"936f3813f5f6a13b8e4ffec83fe7f826186a71cd\":{\"balance\":\"0x1c30731cec03200000\"},\"9374869d4a9911ee1eaf558bc4c2b63ec63acfdd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"937563d8a80fd5a537b0e66d20a02525d5d88660\":{\"balance\":\"0x878678326eac900000\"},\"9376dce2af2ec8dcda741b7e7345664681d93668\":{\"balance\":\"0x3635c9adc5dea00000\"},\"93868ddb2a794d02ebda2fa4807c76e3609858dc\":{\"balance\":\"0x6dee15fc7c24a78000\"},\"939c4313d2280edf5e071bced846063f0a975d54\":{\"balance\":\"0x1969368974c05b000000\"},\"93a6b3ab423010f981a7489d4aad25e2625c5741\":{\"balance\":\"0x44680fe6a1ede4e8000\"},\"93aa8f92ebfff991fc055e906e651ac768d32bc8\":{\"balance\":\"0x32f51edbaaa3300000\"},\"93b4bf3fdff6de3f4e56ba6d7799dc4b93a6548f\":{\"balance\":\"0x10910d4cdc9f60000\"},\"93bc7d9a4abd44c8bbb8fe8ba804c61ad8d6576c\":{\"balance\":\"0xd8d6119a8146050000\"},\"93c2e64e5de5589ed25006e843196ee9b1cf0b3e\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"93c88e2d88621e30f58a9586bed4098999eb67dd\":{\"balance\":\"0x69b5afac750bb800000\"},\"93e0f37ecdfb0086e3e862a97034447b1e4dec1a\":{\"balance\":\"0x1a055690d9db80000\"},\"93e303411afaf6c107a44101c9ac5b36e9d6538b\":{\"balance\":\"0xdf9ddfecd0365400000\"},\"93f18cd2526040761488c513174d1e7963768b2c\":{\"balance\":\"0x82ffac9ad593720000\"},\"940f715140509ffabf974546fab39022a41952d2\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"942c6b8c955bc0d88812678a236725b32739d947\":{\"balance\":\"0x54069233bf7f780000\"},\"943d37864a4a537d35c8d99723cd6406ce2562e6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"94439ca9cc169a79d4a09cae5e67764a6f871a21\":{\"balance\":\"0xd02ab486cedc00000\"},\"94449c01b32a7fa55af8104f42cdd844aa8cbc40\":{\"balance\":\"0x38111a1f4f03c100000\"},\"9445ba5c30e98961b8602461d0385d40fbd80311\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"944f07b96f90c5f0d7c0c580533149f3f585a078\":{\"balance\":\"0x402f4cfee62e80000\"},\"9454b3a8bff9709fd0e190877e6cb6c89974dbd6\":{\"balance\":\"0x90f534608a72880000\"},\"945d96ea573e8df7262bbfa572229b4b16016b0f\":{\"balance\":\"0xb589ef914c1420000\"},\"945e18769d7ee727c7013f92de24d117967ff317\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"94612781033b57b146ee74e753c672017f5385e4\":{\"balance\":\"0xc328093e61ee400000\"},\"94644ad116a41ce2ca7fbec609bdef738a2ac7c7\":{\"balance\":\"0x10f0cf064dd59200000\"},\"9470cc36594586821821c5c996b6edc83b6d5a32\":{\"balance\":\"0x14d1120d7b1600000\"},\"9475c510ec9a26979247744c3d8c3b0e0b5f44d3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"947e11e5ea290d6fc3b38048979e0cd44ec7c17f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9483d98f14a33fdc118d403955c29935edfc5f70\":{\"balance\":\"0x18ea3b34ef51880000\"},\"949131f28943925cfc97d41e0cea0b262973a730\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"949f84f0b1d7c4a7cf49ee7f8b2c4a134de32878\":{\"balance\":\"0x252248deb6e6940000\"},\"949f8c107bc7f0aceaa0f17052aadbd2f9732b2e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"94a7cda8f481f9d89d42c303ae1632b3b709db1d\":{\"balance\":\"0x1043561a8829300000\"},\"94a9a71691317c2064271b51c9353fbded3501a8\":{\"balance\":\"0xb50fcfafebecb00000\"},\"94ad4bad824bd0eb9ea49c58cebcc0ff5e08346b\":{\"balance\":\"0x692ae8897081d00000\"},\"94bbc67d13f89ebca594be94bc5170920c30d9f3\":{\"balance\":\"0x458ffa3150a540000\"},\"94be3ae54f62d663b0d4cc9e1ea8fe9556ea9ebf\":{\"balance\":\"0x143132ca843180000\"},\"94c055e858357aaa30cf2041fa9059ce164a1f91\":{\"balance\":\"0x43c25e0dcc1bd1c0000\"},\"94c742fd7a8b7906b3bfe4f8904fc0be5c768033\":{\"balance\":\"0x43c33c1937564800000\"},\"94ca56de777fd453177f5e0694c478e66aff8a84\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"94d81074db5ae197d2bb1373ab80a87d121c4bd3\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"94db807873860aac3d5aea1e885e52bff2869954\":{\"balance\":\"0xae8e7a0bb575d00000\"},\"94e1f5cb9b8abace03a1a6428256553b690c2355\":{\"balance\":\"0x1158e460913d00000\"},\"94ef8be45077c7d4c5652740de946a62624f713f\":{\"balance\":\"0x56cf5593a18f88000\"},\"94f13f9f0836a3ee2437a84922d2984dc0f7d53b\":{\"balance\":\"0xa2a0329bc38abe0000\"},\"94f8f057db7e60e675ad940f155885d1a477348e\":{\"balance\":\"0x15be6174e1912e0000\"},\"94fcceadfe5c109c5eaeaf462d43873142c88e22\":{\"balance\":\"0x1043561a88293000000\"},\"95034e1621865137cd4739b346dc17da3a27c34e\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"950c68a40988154d2393fff8da7ccda99614f72c\":{\"balance\":\"0xf94146fd8dcde58000\"},\"950fe9c6cad50c18f11a9ed9c45740a6180612d0\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"952183cfd38e352e579d36decec5b18450f7fba0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"95278b08dee7c0f2c8c0f722f9fcbbb9a5241fda\":{\"balance\":\"0x829309f64f0db00000\"},\"952c57d2fb195107d4cd5ca300774119dfad2f78\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"953572f0ea6df9b197cae40e4b8ecc056c4371c5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"953ef652e7b769f53d6e786a58952fa93ee6abe7\":{\"balance\":\"0x9b0a791f1211300000\"},\"95447046313b2f3a5e19b948fd3b8bedc82c717c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"955db3b74360b9a268677e73cea821668af6face\":{\"balance\":\"0x65a4da25d3016c00000\"},\"9560e8ac6718a6a1cdcff189d603c9063e413da6\":{\"balance\":\"0xd8d726b7177a800000\"},\"9567a0de811de6ff095b7ee64e7f1b83c2615b80\":{\"balance\":\"0xe7eeba3410b740000\"},\"95681cdae69b2049ce101e325c759892cac3f811\":{\"balance\":\"0x9ae92a9bc94c400000\"},\"9568b7de755628af359a84543de23504e15e41e6\":{\"balance\":\"0x878678326eac9000000\"},\"9569c63a9284a805626db3a32e9d236393476151\":{\"balance\":\"0x6acb3df27e1f880000\"},\"95809e8da3fbe4b7f281f0b8b1715f420f7d7d63\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"959f57fded6ae37913d900b81e5f48a79322c627\":{\"balance\":\"0xddb26104749118000\"},\"959ff17f1d51b473b44010052755a7fa8c75bd54\":{\"balance\":\"0x6acb3df27e1f880000\"},\"95a577dc2eb3ae6cb9dfc77af697d7efdfe89a01\":{\"balance\":\"0x75f610f70ed200000\"},\"95cb6d8a6379f94aba8b885669562c4d448e56a7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"95d550427b5a514c751d73a0f6d29fb65d22ed10\":{\"balance\":\"0x1043561a8829300000\"},\"95d98d0c1069908f067a52acac2b8b534da37afd\":{\"balance\":\"0x6f59b630a929708000\"},\"95df4e3445d7662624c48eba74cf9e0a53e9f732\":{\"balance\":\"0xbdbc41e0348b3000000\"},\"95e6a54b2d5f67a24a4875af75107ca7ea9fd2fa\":{\"balance\":\"0x487a9a304539440000\"},\"95e6f93dac228bc7585a25735ac2d076cc3a4017\":{\"balance\":\"0x14542ba12a337c00000\"},\"95e7616424cd0961a71727247437f0069272280e\":{\"balance\":\"0x15af1d78b58c400000\"},\"95e80a82c20cbe3d2060242cb92d735810d034a2\":{\"balance\":\"0x1c32e463fd4b98000\"},\"95f62d0243ede61dad9a3165f53905270d54e242\":{\"balance\":\"0x57473d05dabae80000\"},\"95fb5afb14c1ef9ab7d179c5c300503fd66a5ee2\":{\"balance\":\"0x1daf7a02b0dbe8000\"},\"9610592202c282ab9bd8a884518b3e0bd4758137\":{\"balance\":\"0xe873f44133cb00000\"},\"961c59adc74505d1864d1ecfcb8afa0412593c93\":{\"balance\":\"0x878678326eac9000000\"},\"962c0dec8a3d464bf39b1215eafd26480ae490cd\":{\"balance\":\"0x6c82e3eaa513e80000\"},\"962cd22a8edf1e4f4e55b4b15ddbfb5d9d541971\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"96334bfe04fffa590213eab36514f338b864b736\":{\"balance\":\"0x15af1d78b58c400000\"},\"9637dc12723d9c78588542eab082664f3f038d9d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"964eab4b276b4cd8983e15ca72b106900fe41fce\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9662ee021926682b31c5f200ce457abea76c6ce9\":{\"balance\":\"0x24590e8589eb6a0000\"},\"966c04781cb5e67dde3235d7f8620e1ab663a9a5\":{\"balance\":\"0x100d2050da6351600000\"},\"967076a877b18ec15a415bb116f06ef32645dba3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"967bfaf76243cdb9403c67d2ceefdee90a3feb73\":{\"balance\":\"0x349d87f2a2dc2f0000\"},\"967d4142af770515dd7062af93498dbfdff29f20\":{\"balance\":\"0x11854d0f9cee40000\"},\"968b14648f018333687cd213fa640aec04ce6323\":{\"balance\":\"0x3635c9adc5dea00000\"},\"968dea60df3e09ae3c8d3505e9c080454be0e819\":{\"balance\":\"0x14542ba12a337c00000\"},\"96924191b7df655b3319dc6d6137f481a73a0ff3\":{\"balance\":\"0xd9ecb4fd208e500000\"},\"9696052138338c722f1140815cf7749d0d3b3a74\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"96a55f00dff405dc4de5e58c57f6f6f0cac55d2f\":{\"balance\":\"0x6a6616379c87b58000\"},\"96aa573fed2f233410dbae5180145b23c31a02f0\":{\"balance\":\"0x5dc892aa1131c80000\"},\"96ad579bbfa8db8ebec9d286a72e4661eed8e356\":{\"balance\":\"0x3a0ba42bec61830000\"},\"96b434fe0657e42acc8212b6865139dede15979c\":{\"balance\":\"0xd8d726b7177a800000\"},\"96b906ea729f4655afe3e57d35277c967dfa1577\":{\"balance\":\"0x3635c9adc5dea00000\"},\"96d62dfd46087f62409d93dd606188e70e381257\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"96d9cca8f55eea0040ec6eb348a1774b95d93ef4\":{\"balance\":\"0xd8d726b7177a800000\"},\"96e7c0c9d5bf10821bf140c558a145b7cac21397\":{\"balance\":\"0x393ef1a5127c800000\"},\"96ea6ac89a2bac95347b51dba63d8bd5ebdedce1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"96eafbf2fb6f4db9a436a74c45b5654452e23819\":{\"balance\":\"0x1158e460913d00000\"},\"96eb523e832f500a017de13ec27f5d366c560eff\":{\"balance\":\"0x10acceba43ee280000\"},\"96f0462ae6f8b96088f7e9c68c74b9d8ad34b347\":{\"balance\":\"0x61093d7c2c6d380000\"},\"96f820500b70f4a3e3239d619cff8f222075b135\":{\"balance\":\"0xad78ebc5ac6200000\"},\"96fe59c3dbb3aa7cc8cb62480c65e56e6204a7e2\":{\"balance\":\"0x43c33c1937564800000\"},\"96ff6f509968f36cb42cba48db32f21f5676abf8\":{\"balance\":\"0x6acb3df27e1f880000\"},\"970938522afb5e8f994873c9fbdc26e3b37e314c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"970abd53a54fca4a6429207c182d4d57bb39d4a0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"970d8b8a0016d143054f149fb3b8e550dc0797c7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"972c2f96aa00cf8a2f205abcf8937c0c75f5d8d9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"973f4e361fe5decd989d4c8f7d7cc97990385daf\":{\"balance\":\"0x150f8543a387420000\"},\"974d0541ab4a47ec7f75369c0069b64a1b817710\":{\"balance\":\"0x15af1d78b58c400000\"},\"974d2f17895f2902049deaaecf09c3046507402d\":{\"balance\":\"0xcc19c29437ab8000\"},\"9752d14f5e1093f071711c1adbc4e3eb1e5c57f3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9756e176c9ef693ee1eec6b9f8b151d313beb099\":{\"balance\":\"0x410d586a20a4c00000\"},\"975f3764e97bbccf767cbd3b795ba86d8ba9840e\":{\"balance\":\"0x12c1b6eed03d280000\"},\"976a18536af41874426308871bcd1512a775c9f8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"976e3ceaf3f1af51f8c29aff5d7fa21f0386d8ee\":{\"balance\":\"0xd02ab486cedc00000\"},\"9777cc61cf756be3b3c20cd4491c69d275e7a120\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"97810bafc37e84306332aacb35e92ad911d23d24\":{\"balance\":\"0x3635c9adc5dea00000\"},\"978c430ce4359b06bc2cdf5c2985fc950e50d5c8\":{\"balance\":\"0x1a055690d9db800000\"},\"9795f64319fc17dd0f8261f9d206fb66b64cd0c9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9799ca21dbcf69bfa1b3f72bac51b9e3ca587cf9\":{\"balance\":\"0x5c283d410394100000\"},\"979cbf21dfec8ace3f1c196d82df962534df394f\":{\"balance\":\"0x9991d478dd4d160000\"},\"979d681c617da16f21bcaca101ed16ed015ab696\":{\"balance\":\"0x65ea3db75546600000\"},\"979f30158b574b999aab348107b9eed85b1ff8c1\":{\"balance\":\"0x34957444b840e80000\"},\"97a86f01ce3f7cfd4441330e1c9b19e1b10606ef\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"97b91efe7350c2d57e7e406bab18f3617bcde14a\":{\"balance\":\"0x21e1999bbd5d2be0000\"},\"97d0d9725e3b70e675843173938ed371b62c7fac\":{\"balance\":\"0x93739534d28680000\"},\"97d9e46a7604d7b5a4ea4ee61a42b3d2350fc3ed\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"97dc26ec670a31e0221d2a75bc5dc9f90c1f6fd4\":{\"balance\":\"0x2b5e3af16b1880000\"},\"97de21e421c37fe4b8025f9a51b7b390b5df7804\":{\"balance\":\"0x10f0cf064dd592000000\"},\"97e28973b860c567402800fbb63ce39a048a3d79\":{\"balance\":\"0x542253a126ce40000\"},\"97e5cc6127c4f885be02f44b42d1c8b0ac91e493\":{\"balance\":\"0xad78ebc5ac6200000\"},\"97f1fe4c8083e596212a187728dd5cf80a31bec5\":{\"balance\":\"0x1158e460913d00000\"},\"97f7760657c1e202759086963eb4211c5f8139b9\":{\"balance\":\"0xa8a097fcb3d17680000\"},\"97f99b6ba31346cd98a9fe4c308f87c5a58c5151\":{\"balance\":\"0x14542ba12a337c00000\"},\"980a84b686fc31bdc83c221058546a71b11f838a\":{\"balance\":\"0x2a415548af86818000\"},\"9810e34a94db6ed156d0389a0e2b80f4fd6b0a8a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"981ddf0404e4d22dda556a0726f00b2d98ab9569\":{\"balance\":\"0x36356633ebd8ea0000\"},\"981f712775c0dad97518ffedcb47b9ad1d6c2762\":{\"balance\":\"0x16a6502f15a1e540000\"},\"9834682180b982d166badb9d9d1d9bbf016d87ee\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9836b4d30473641ab56aeee19242761d72725178\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"98397342ec5f3d4cb877e54ef5d6f1d366731bd4\":{\"balance\":\"0x14061b9d77a5e980000\"},\"9846648836a307a057184fd51f628a5f8c12427c\":{\"balance\":\"0x40b69bf43dce8f00000\"},\"984a7985e3cc7eb5c93691f6f8cc7b8f245d01b2\":{\"balance\":\"0x14542ba12a337c00000\"},\"985d70d207892bed398590024e2421b1cc119359\":{\"balance\":\"0x43c33c1937564800000\"},\"986df47e76e4d7a789cdee913cc9831650936c9d\":{\"balance\":\"0x10f0cf064dd59200000\"},\"9874803fe1f3a0365e7922b14270eaeb032cc1b5\":{\"balance\":\"0x3cf5928824c6c20000\"},\"9875623495a46cdbf259530ff838a1799ec38991\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"987618c85656207c7bac1507c0ffefa2fb64b092\":{\"balance\":\"0x37dfe433189e38000\"},\"987c9bcd6e3f3990a52be3eda4710c27518f4f72\":{\"balance\":\"0x15af1d78b58c400000\"},\"9882967cee68d2a839fad8ab4a7c3dddf6c0adc8\":{\"balance\":\"0x4878be1ffaf95d0000\"},\"98855c7dfbee335344904a12c40c731795b13a54\":{\"balance\":\"0x39fbae8d042dd00000\"},\"989c0ccff654da03aeb11af701054561d6297e1d\":{\"balance\":\"0xd8d726b7177a800000\"},\"98a0e54c6d9dc8be96276cebf4fec460f6235d85\":{\"balance\":\"0x6ac882100952c78000\"},\"98b769cc305cecfb629a00c907069d7ef9bc3a12\":{\"balance\":\"0x168d28e3f00280000\"},\"98ba4e9ca72fddc20c69b4396f76f8183f7a2a4e\":{\"balance\":\"0x2b5e3af16b188000000\"},\"98be696d51e390ff1c501b8a0f6331b628ddc5ad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"98bed3a72eccfbafb923489293e429e703c7e25b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"98bf4af3810b842387db70c14d46099626003d10\":{\"balance\":\"0xd8d726b7177a800000\"},\"98c10ebf2c4f97cba5a1ab3f2aafe1cac423f8cb\":{\"balance\":\"0x1043561a8829300000\"},\"98c19dba810ba611e68f2f83ee16f6e7744f0c1f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"98c5494a03ac91a768dffc0ea1dde0acbf889019\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"98d204f9085f8c8e7de23e589b64c6eff692cc63\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"98d3731992d1d40e1211c7f735f2189afa0702e0\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"98e2b6d606fd2d6991c9d6d4077fdf3fdd4585da\":{\"balance\":\"0x30df1a6f8ad6280000\"},\"98e3e90b28fccaee828779b8d40a5568c4116e21\":{\"balance\":\"0x22b1c8c1227a00000\"},\"98e6f547db88e75f1f9c8ac2c5cf1627ba580b3e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"98f4af3af0aede5fafdc42a081ecc1f89e3ccf20\":{\"balance\":\"0x1fd933494aa5fe00000\"},\"98f6b8e6213dbc9a5581f4cce6655f95252bdb07\":{\"balance\":\"0x115872b0bca4300000\"},\"9909650dd5b1397b8b8b0eb69499b291b0ad1213\":{\"balance\":\"0xad78ebc5ac6200000\"},\"991173601947c2084a62d639527e961512579af9\":{\"balance\":\"0x2086ac351052600000\"},\"99129d5b3c0cde47ea0def4dfc070d1f4a599527\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9917d68d4af341d651e7f0075c6de6d7144e7409\":{\"balance\":\"0x132d4476c08e6f00000\"},\"991ac7ca7097115f26205eee0ef7d41eb4e311ae\":{\"balance\":\"0x1158e460913d00000\"},\"992365d764c5ce354039ddfc912e023a75b8e168\":{\"balance\":\"0xfc936392801c0000\"},\"992646ac1acaabf5ddaba8f9429aa6a94e7496a7\":{\"balance\":\"0x3637507a30abeb0000\"},\"99268327c373332e06c3f6164287d455b9d5fa4b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9928ff715afc3a2b60f8eb4cc4ba4ee8dab6e59d\":{\"balance\":\"0x17da3a04c7b3e00000\"},\"9932ef1c85b75a9b2a80057d508734c51085becc\":{\"balance\":\"0x2b83fa5301d590000\"},\"993f146178605e66d517be782ef0b3c61a4e1925\":{\"balance\":\"0x17c1f0535d7a5830000\"},\"99413704b1a32e70f3bc0d69dd881c38566b54cb\":{\"balance\":\"0x5cc6b694631f7120000\"},\"994152fc95d5c1ca8b88113abbad4d710e40def6\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9944fee9d34a4a880023c78932c00b59d5c82a82\":{\"balance\":\"0x28a8a56b3690070000\"},\"994cc2b5227ec3cf048512467c41b7b7b748909f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9971df60f0ae66dce9e8c84e17149f09f9c52f64\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9976947eff5f6ae5da08dd541192f378b428ff94\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"997d6592a31589acc31b9901fbeb3cc3d65b3215\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9982a5890ffb5406d3aca8d2bfc1dd70aaa80ae0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"99878f9d6e0a7ed9aec78297b73879a80195afe0\":{\"balance\":\"0xd7c198710e66b00000\"},\"998c1f93bcdb6ff23c10d0dc924728b73be2ff9f\":{\"balance\":\"0x365bf3a433eaf30000\"},\"9991614c5baa47dd6c96874645f97add2c3d8380\":{\"balance\":\"0x6acb3df27e1f880000\"},\"99924a9816bb7ddf3fec1844828e9ad7d06bf4e6\":{\"balance\":\"0x5f68e8131ecf800000\"},\"99997668f7c1a4ff9e31f9977ae3224bcb887a85\":{\"balance\":\"0xfc936392801c00000\"},\"999c49c174ca13bc836c1e0a92bff48b271543ca\":{\"balance\":\"0xb1cf24ddd0b1400000\"},\"99a4de19ded79008cfdcd45d014d2e584b8914a8\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"99a96bf2242ea1b39ece6fcc0d18aed00c0179f3\":{\"balance\":\"0x1043561a8829300000\"},\"99b018932bcad355b6792b255db6702dec8ce5dd\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"99b743d1d9eff90d9a1934b4db21d519d89b4a38\":{\"balance\":\"0x56bc75e2d63100000\"},\"99b8c824869de9ed24f3bff6854cb6dd45cc3f9f\":{\"balance\":\"0x65ea3db75546600000\"},\"99c0174cf84e0783c220b4eb6ae18fe703854ad3\":{\"balance\":\"0x7079a2573d0c780000\"},\"99c1d9f40c6ab7f8a92fce2fdce47a54a586c53f\":{\"balance\":\"0x35659ef93f0fc40000\"},\"99c236141daec837ece04fdaee1d90cf8bbdc104\":{\"balance\":\"0x766516acac0d200000\"},\"99c31fe748583787cdd3e525b281b218961739e3\":{\"balance\":\"0x3708baed3d68900000\"},\"99c475bf02e8b9214ada5fad02fdfd15ba365c0c\":{\"balance\":\"0x2009c5c8bf6fdc0000\"},\"99c883258546cc7e4e971f522e389918da5ea63a\":{\"balance\":\"0xd8d726b7177a800000\"},\"99c9f93e45fe3c1418c353e4c5ac3894eef8121e\":{\"balance\":\"0x585baf145050b0000\"},\"99d1579cd42682b7644e1d4f7128441eeffe339d\":{\"balance\":\"0x43c33c1937564800000\"},\"99d1b585965f406a42a49a1ca70f769e765a3f98\":{\"balance\":\"0x3894f0e6f9b9f700000\"},\"99dfd0504c06c743e46534fd7b55f1f9c7ec3329\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"99f4147ccc6bcb80cc842e69f6d00e30fa4133d9\":{\"balance\":\"0x15af1d78b58c400000\"},\"99f77f998b20e0bcdcd9fc838641526cf25918ef\":{\"balance\":\"0x61093d7c2c6d380000\"},\"99fad50038d0d9d4c3fbb4bce05606ecadcd5121\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"99fe0d201228a753145655d428eb9fd94985d36d\":{\"balance\":\"0x6920bff3515a3a0000\"},\"9a079c92a629ca15c8cafa2eb28d5bc17af82811\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9a0d3cee3d9892ea3b3700a27ff84140d9025493\":{\"balance\":\"0x340aad21b3b700000\"},\"9a24ce8d485cc4c86e49deb39022f92c7430e67e\":{\"balance\":\"0x46791fc84e07d00000\"},\"9a2ce43b5d89d6936b8e8c354791b8afff962425\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9a390162535e398877e416787d6239e0754e937c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9a3da65023a13020d22145cfc18bab10bd19ce4e\":{\"balance\":\"0x18bf6ea3464a3a0000\"},\"9a3e2b1bf346dd070b027357feac44a4b2c97db8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9a4ca8b82117894e43db72b9fa78f0b9b93ace09\":{\"balance\":\"0x2b5e3af16b1880000\"},\"9a522e52c195bfb7cf5ffaaedb91a3ba7468161d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9a5af31c7e06339ac8b4628d7c4db0ce0f45c8a4\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9a633fcd112cceeb765fe0418170732a9705e79c\":{\"balance\":\"0xfc936392801c0000\"},\"9a63d185a79129fdab19b58bb631ea36a420544e\":{\"balance\":\"0x246ddf97976680000\"},\"9a6708ddb8903c289f83fe889c1edcd61f854423\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9a6ff5f6a7af7b7ae0ed9c20ecec5023d281b786\":{\"balance\":\"0x8a12b9bd6a67ec0000\"},\"9a82826d3c29481dcc2bd2950047e8b60486c338\":{\"balance\":\"0x43c33c1937564800000\"},\"9a8eca4189ff4aa8ff7ed4b6b7039f0902219b15\":{\"balance\":\"0x1158e460913d00000\"},\"9a953b5bcc709379fcb559d7b916afdaa50cadcc\":{\"balance\":\"0x56bc75e2d63100000\"},\"9a990b8aeb588d7ee7ec2ed8c2e64f7382a9fee2\":{\"balance\":\"0x1d127db69fd8b0000\"},\"9a9d1dc0baa77d6e20c3d849c78862dd1c054c87\":{\"balance\":\"0x2fb474098f67c00000\"},\"9aa48c66e4fb4ad099934e32022e827427f277ba\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9aa8308f42910e5ade09c1a5e282d6d91710bdbf\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9aaafa0067647ed999066b7a4ca5b4b3f3feaa6f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9ab988b505cfee1dbe9cd18e9b5473b9a2d4f536\":{\"balance\":\"0x1158e460913d000000\"},\"9ab98d6dbb1eaae16d45a04568541ad3d8fe06cc\":{\"balance\":\"0xec50464fe23f38000\"},\"9aba2b5e27ff78baaab5cdc988b7be855cebbdce\":{\"balance\":\"0x21e0c0013070adc0000\"},\"9ac4da51d27822d1e208c96ea64a1e5b55299723\":{\"balance\":\"0x56c5579f722140000\"},\"9ac85397792a69d78f286b86432a07aeceb60e64\":{\"balance\":\"0xc673ce3c40160000\"},\"9ac907ee85e6f3e223459992e256a43fa08fa8b2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9ad47fdcf9cd942d28effd5b84115b31a658a13e\":{\"balance\":\"0xb259ec00d53b280000\"},\"9adbd3bc7b0afc05d1d2eda49ff863939c48db46\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"9adf458bff3599eee1a26398853c575bc38c6313\":{\"balance\":\"0xf2dc7d47f15600000\"},\"9ae13bd882f2576575921a94974cbea861ba0d35\":{\"balance\":\"0xab4dcf399a3a600000\"},\"9ae9476bfecd3591964dd325cf8c2a24faed82c1\":{\"balance\":\"0xd8d726b7177a800000\"},\"9af100cc3dae83a33402051ce4496b16615483f6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9af11399511c213181bfda3a8b264c05fc81b3ce\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"9af5c9894c33e42c2c518e3ac670ea9505d1b53e\":{\"balance\":\"0xfc936392801c0000\"},\"9af9dbe47422d177f945bdead7e6d82930356230\":{\"balance\":\"0xd5967be4fc3f100000\"},\"9afa536b4c66bc38d875c4b30099d9261fdb38eb\":{\"balance\":\"0xb2a8f842a77bc8000\"},\"9b06ad841dffbe4ccf46f1039fc386f3c321446e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9b1168de8ab64b47552f3389800a9cc08b4666cf\":{\"balance\":\"0x5dc892aa1131c80000\"},\"9b1811c3051f46e664ae4bc9c824d18592c4574a\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"9b18478655a4851cc906e660feac61f7f4c8bffc\":{\"balance\":\"0xe2478d38907d840000\"},\"9b22a80d5c7b3374a05b446081f97d0a34079e7f\":{\"balance\":\"0xa2a15d09519be00000\"},\"9b2be7f56754f505e3441a10f7f0e20fd3ddf849\":{\"balance\":\"0x126e72a69a50d00000\"},\"9b32cf4f5115f4b34a00a64c617de06387354323\":{\"balance\":\"0x5b81ed888207c8000\"},\"9b43dcb95fde318075a567f1e6b57617055ef9e8\":{\"balance\":\"0xd5967be4fc3f100000\"},\"9b444fd337e5d75293adcfff70e1ea01db023222\":{\"balance\":\"0x56bc75e2d63100000\"},\"9b4824ff9fb2abda554dee4fb8cf549165570631\":{\"balance\":\"0x1158e460913d00000\"},\"9b4c2715780ca4e99e60ebf219f1590c8cad500a\":{\"balance\":\"0x56bc75e2d631000000\"},\"9b59eb213b1e7565e45047e04ea0374f10762d16\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9b5c39f7e0ac168c8ed0ed340477117d1b682ee9\":{\"balance\":\"0x55005f0c614480000\"},\"9b5ec18e8313887df461d2902e81e67a8f113bb1\":{\"balance\":\"0x56bc75e2d63100000\"},\"9b64d3cd8d2b73f66841b5c46bb695b88a9ab75d\":{\"balance\":\"0x1203a4f760c168000\"},\"9b658fb361e046d4fcaa8aef6d02a99111223625\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9b6641b13e172fc072ca4b8327a3bc28a15b66a9\":{\"balance\":\"0x68155a43676e00000\"},\"9b68f67416a63bf4451a31164c92f672a68759e9\":{\"balance\":\"0xcb49b44ba602d800000\"},\"9b773669e87d76018c090f8255e54409b9dca8b2\":{\"balance\":\"0x1158e460913d00000\"},\"9b77ebced7e215f0920e8c2b870024f6ecb2ff31\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9b7c8810cc7cc89e804e6d3e38121850472877fe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9ba53dc8c95e9a472feba2c4e32c1dc4dd7bab46\":{\"balance\":\"0x487a9a304539440000\"},\"9bacd3d40f3b82ac91a264d9d88d908eac8664b9\":{\"balance\":\"0x43c33c1937564800000\"},\"9bb760d5c289a3e1db18db095345ca413b9a43c2\":{\"balance\":\"0xaadec983fcff40000\"},\"9bb76204186af2f63be79168601687fc9bad661f\":{\"balance\":\"0x1043561a8829300000\"},\"9bb9b02a26bfe1ccc3f0c6219e261c397fc5ca78\":{\"balance\":\"0x487a9a304539440000\"},\"9bc573bcda23b8b26f9073d90c230e8e71e0270b\":{\"balance\":\"0x362f75a4305d0c0000\"},\"9bd7c38a4210304a4d653edeff1b3ce45fce7843\":{\"balance\":\"0xf498941e664280000\"},\"9bd88068e13075f3a8cac464a5f949d6d818c0f6\":{\"balance\":\"0x14542ba12a337c00000\"},\"9bd905f1719fc7acd0159d4dc1f8db2f21472338\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9bdbdc9b973431d13c89a3f9757e9b3b6275bfc7\":{\"balance\":\"0x1b1a7dcf8a44d38000\"},\"9be3c329b62a28b8b0886cbd8b99f8bc930ce3e6\":{\"balance\":\"0x409e52b48369a0000\"},\"9bf58efbea0784eb068adecfa0bb215084c73a35\":{\"balance\":\"0x13a6b2b564871a00000\"},\"9bf672d979b36652fc5282547a6a6bc212ae4368\":{\"balance\":\"0x238fd42c5cf0400000\"},\"9bf703b41c3624e15f4054962390bcba3052f0fd\":{\"balance\":\"0x1483e01533c2e3c0000\"},\"9bf71f7fb537ac54f4e514947fa7ff6728f16d2f\":{\"balance\":\"0x1cf84a30a0a0c0000\"},\"9bf9b3b2f23cf461eb591f28340bc719931c8364\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9bfc659c9c601ea42a6b21b8f17084ec87d70212\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9bfff50db36a785555f07652a153b0c42b1b8b76\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9c05e9d0f0758e795303717e31da213ca157e686\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9c1b771f09af882af0643083de2aa79dc097c40e\":{\"balance\":\"0x8670e9ec6598c00000\"},\"9c28a2c4086091cb5da226a657ce3248e8ea7b6f\":{\"balance\":\"0xf2dc7d47f15600000\"},\"9c2fd54089af665df5971d73b804616039647375\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9c344098ba615a398f11d009905b177c44a7b602\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9c3d0692ceeef80aa4965ceed262ffc7f069f2dc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9c405cf697956138065e11c5f7559e67245bd1a5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9c45202a25f6ad0011f115a5a72204f2f2198866\":{\"balance\":\"0x10fcf3a62b080980000\"},\"9c49deff47085fc09704caa2dca8c287a9a137da\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"9c4bbcd5f1644a6f075824ddfe85c571d6abf69c\":{\"balance\":\"0x6194049f30f7200000\"},\"9c526a140683edf1431cfaa128a935e2b614d88b\":{\"balance\":\"0x6046f37e5945c0000\"},\"9c54e4ed479a856829c6bb42da9f0b692a75f728\":{\"balance\":\"0x197a8f6dd5519800000\"},\"9c581a60b61028d934167929b22d70b313c34fd0\":{\"balance\":\"0xa968163f0a57b400000\"},\"9c5cc111092c122116f1a85f4ee31408741a7d2f\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"9c6bc9a46b03ae5404f043dfcf21883e4110cc33\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9c78963fbc263c09bd72e4f8def74a9475f7055c\":{\"balance\":\"0x2eb8eb1a172dcb80000\"},\"9c78fbb4df769ce2c156920cfedfda033a0e254a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"9c7b6dc5190fe2912963fcd579683ec7395116b0\":{\"balance\":\"0x2a1129d09367200000\"},\"9c80bc18e9f8d4968b185da8c79fa6e11ffc3e23\":{\"balance\":\"0xd02ab486cedc00000\"},\"9c98fdf1fdcd8ba8f4c5b04c3ae8587efdf0f6e6\":{\"balance\":\"0x14542ba12a337c00000\"},\"9c99a1da91d5920bc14e0cb914fdf62b94cb8358\":{\"balance\":\"0x43c33c1937564800000\"},\"9c99b62606281b5cefabf36156c8fe62839ef5f3\":{\"balance\":\"0xd8d726b7177a800000\"},\"9c9a07a8e57c3172a919ef64789474490f0d9f51\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9c9de44724a4054da0eaa605abcc802668778bea\":{\"balance\":\"0xad7d5ca3fa5a20000\"},\"9c9f3b8a811b21f3ff3fe20fe970051ce66a824f\":{\"balance\":\"0x3ec2debc07d4be0000\"},\"9c9f89a3910f6a2ae8a91047a17ab788bddec170\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9ca0429f874f8dcee2e9c062a9020a842a587ab9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9ca42ee7a0b898f6a5cc60b5a5d7b1bfa3c33231\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9cb28ac1a20a106f7f373692c5ce4c73f13732a1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9ccddcb2cfc2b25b08729a0a98d9e6f0202ea2c1\":{\"balance\":\"0x56bc75e2d63100000\"},\"9ce27f245e02d1c312c1d500788c9def7690453b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9ce5363b13e8238aa4dd15acd0b2e8afe0873247\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9cf2928beef09a40f9bfc953be06a251116182fb\":{\"balance\":\"0x14542ba12a337c00000\"},\"9d069197d1de50045a186f5ec744ac40e8af91c6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9d0e7d92fb305853d798263bf15e97c72bf9d7e0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9d0f347e826b7dceaad279060a35c0061ecf334b\":{\"balance\":\"0xd8d726b7177a800000\"},\"9d207517422cc0d60de7c237097a4d4fce20940c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9d250ae4f110d71cafc7b0adb52e8d9acb6679b8\":{\"balance\":\"0x2156d6e997213c00000\"},\"9d2bfc36106f038250c01801685785b16c86c60d\":{\"balance\":\"0x5077d75df1b675800000\"},\"9d30cb237bc096f17036fc80dd21ca68992ca2d9\":{\"balance\":\"0x66ee7318fdc8f300000\"},\"9d32962ea99700d93228e9dbdad2cc37bb99f07e\":{\"balance\":\"0xb4632bedd4ded40000\"},\"9d34dac25bd15828faefaaf28f710753b39e89dc\":{\"balance\":\"0x3b1c56fed02df00000\"},\"9d369165fb70b81a3a765f188fd60cbe5e7b0968\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9d40e012f60425a340d82d03a1c757bfabc706fb\":{\"balance\":\"0x9346f3addc88d8000\"},\"9d4174aa6af28476e229dadb46180808c67505c1\":{\"balance\":\"0x421afda42ed6970000\"},\"9d4213339a01551861764c87a93ce8f85f87959a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9d460c1b379ddb19a8c85b4c6747050ddf17a875\":{\"balance\":\"0xb50fcfafebecb00000\"},\"9d47ba5b4c8505ad8da42934280b61a0e1e8b971\":{\"balance\":\"0x56bc75e2d63100000\"},\"9d4d321177256ebd9afbda304135d517c3dc5693\":{\"balance\":\"0x2164b7a04ac8a00000\"},\"9d4ff989b7bed9ab109d10c8c7e55f02d76734ad\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9d511543b3d9dc60d47f09d49d01b6c498d82078\":{\"balance\":\"0x26197b9516fc3940000\"},\"9d6ecfa03af2c6e144b7c4692a86951e902e9e1f\":{\"balance\":\"0xa2a5aa60ad243f0000\"},\"9d7655e9f3e5ba5d6e87e412aebe9ee0d49247ee\":{\"balance\":\"0x8e09311c1d80fa0000\"},\"9d7831e834c20b1baa697af1d8e0c621c5afff9a\":{\"balance\":\"0x4b06dbbb40f4a0000\"},\"9d78a975b7db5e4d8e28845cfbe7e31401be0dd9\":{\"balance\":\"0x48a43c54602f700000\"},\"9d799e943e306ba2e5b99c8a6858cbb52c0cf735\":{\"balance\":\"0x1043561a8829300000\"},\"9d7fda7070bf3ee9bbd9a41f55cad4854ae6c22c\":{\"balance\":\"0x255cba3c46fcf120000\"},\"9d81aea69aed6ad07089d61445348c17f34bfc5b\":{\"balance\":\"0x1043561a8829300000\"},\"9d911f3682f32fe0792e9fb6ff3cfc47f589fca5\":{\"balance\":\"0xd8d726b7177a800000\"},\"9d913b5d339c95d87745562563fea98b23c60cc4\":{\"balance\":\"0x941302c7f4d230000\"},\"9d93fab6e22845f8f45a07496f11de71530debc7\":{\"balance\":\"0x6c4fd1ee246e780000\"},\"9d99b189bbd9a48fc2e16e8fcda33bb99a317bbb\":{\"balance\":\"0x3d16e10b6d8bb20000\"},\"9d9c4efe9f433989e23be94049215329fa55b4cb\":{\"balance\":\"0xde3b28903c6b58000\"},\"9d9e57fde30e5068c03e49848edce343b7028358\":{\"balance\":\"0x5dc892aa1131c80000\"},\"9da3302240af0511c6fd1857e6ddb7394f77ab6b\":{\"balance\":\"0xa80d24677efef00000\"},\"9da4ec407077f4b9707b2d9d2ede5ea5282bf1df\":{\"balance\":\"0xd8d726b7177a800000\"},\"9da609fa3a7e6cf2cc0e70cdabe78dc4e382e11e\":{\"balance\":\"0x410d586a20a4c00000\"},\"9da61ccd62bf860656e0325d7157e2f160d93bb5\":{\"balance\":\"0x10f0ca956f8799e0000\"},\"9da6e075989c7419094cc9f6d2e49393bb199688\":{\"balance\":\"0x259bb71d5adf3f00000\"},\"9da8e22ca10e67fea44e525e4751eeac36a31194\":{\"balance\":\"0xe18398e7601900000\"},\"9db2e15ca681f4c66048f6f9b7941ed08b1ff506\":{\"balance\":\"0xd8d726b7177a800000\"},\"9dc10fa38f9fb06810e11f60173ec3d2fd6a751e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"9dd2196624a1ddf14a9d375e5f07152baf22afa2\":{\"balance\":\"0x41b05e2463a5438000\"},\"9dd46b1c6d3f05e29e9c6f037eed9a595af4a9aa\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9ddd355e634ee9927e4b7f6c97e7bf3a2f1e687a\":{\"balance\":\"0x2b5e3af16b1880000\"},\"9de20ae76aa08263b205d5142461961e2408d266\":{\"balance\":\"0xda933d8d8c6700000\"},\"9de20bc37e7f48a80ffd7ad84ffbf1a1abe1738c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9de7386dde401ce4c67b71b6553f8aa34ea5a17d\":{\"balance\":\"0x340aad21b3b700000\"},\"9deb39027af877992b89f2ec4a1f822ecdf12693\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9defe56a0ff1a1947dba0923f7dd258d8f12fa45\":{\"balance\":\"0x5b12aefafa804000000\"},\"9df057cd03a4e27e8e032f857985fd7f01adc8d7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9df32a501c0b781c0281022f42a1293ffd7b892a\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"9e01765aff08bc220550aca5ea2e1ce8e5b09923\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9e20e5fd361eabcf63891f5b87b09268b8eb3793\":{\"balance\":\"0x56bc75e2d63100000\"},\"9e232c08c14dc1a6ed0b8a3b2868977ba5c17d10\":{\"balance\":\"0x1158e460913d00000\"},\"9e23c5e4b782b00a5fadf1aead87dacf5b0367a1\":{\"balance\":\"0x1158e460913d00000\"},\"9e35399071a4a101e9194daa3f09f04a0b5f9870\":{\"balance\":\"0xd8d726b7177a800000\"},\"9e3eb509278fe0dcd8e0bbe78a194e06b6803943\":{\"balance\":\"0x32f51edbaaa3300000\"},\"9e427272516b3e67d4fcbf82f59390d04c8e28e5\":{\"balance\":\"0xd8d726b7177a800000\"},\"9e4cec353ac3e381835e3c0991f8faa5b7d0a8e6\":{\"balance\":\"0x21e18b9e9ab45e48000\"},\"9e5811b40be1e2a1e1d28c3b0774acde0a09603d\":{\"balance\":\"0xa2a15d09519be00000\"},\"9e5a311d9f69898a7c6a9d6360680438e67a7b2f\":{\"balance\":\"0x50c5e761a444080000\"},\"9e7c2050a227bbfd60937e268cea3e68fea8d1fe\":{\"balance\":\"0x56bc75e2d63100000\"},\"9e7f65a90e8508867bccc914256a1ea574cf07e3\":{\"balance\":\"0x433874f632cc600000\"},\"9e8144e08e89647811fe6b72d445d6a5f80ad244\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9e8f64ddcde9b8b451bafaa235a9bf511a25ac91\":{\"balance\":\"0x90f534608a72880000\"},\"9e951f6dc5e352afb8d04299d2478a451259bf56\":{\"balance\":\"0x3e7419881a73a0000\"},\"9e960dcd03d5ba99cb115d17ff4c09248ad4d0be\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9eaf6a328a4076024efa6b67b48b21eedcc0f0b8\":{\"balance\":\"0x890b0c2e14fb80000\"},\"9eb1ff71798f28d6e989fa1ea0588e27ba86cb7d\":{\"balance\":\"0x7a1fe160277000000\"},\"9eb281c32719c40fdb3e216db0f37fbc73a026b7\":{\"balance\":\"0x1158e460913d00000\"},\"9eb3a7cb5e6726427a3a361cfa8d6164dbd0ba16\":{\"balance\":\"0x2b95bdcc39b6100000\"},\"9eb7834e171d41e069a77947fca87622f0ba4e48\":{\"balance\":\"0x56bc75e2d63100000\"},\"9ec03e02e587b7769def538413e97f7e55be71d8\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"9ecbabb0b22782b3754429e1757aaba04b81189f\":{\"balance\":\"0x2ca7bb061f5e998000\"},\"9ece1400800936c7c6485fcdd3626017d09afbf6\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"9ed4e63f526542d44fddd34d59cd25388ffd6bda\":{\"balance\":\"0xd29b34a46348940000\"},\"9ed80eda7f55054db9fb5282451688f26bb374c1\":{\"balance\":\"0x1043561a8829300000\"},\"9edc90f4be210865214ab5b35e5a8dd77415279d\":{\"balance\":\"0xd8d726b7177a800000\"},\"9edeac4c026b93054dc5b1d6610c6f3960f2ad73\":{\"balance\":\"0x410d586a20a4c00000\"},\"9ee93f339e6726ec65eea44f8a4bfe10da3d3282\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9ee9760cc273d4706aa08375c3e46fa230aff3d5\":{\"balance\":\"0x1e52e336cde22180000\"},\"9eeb07bd2b7890195e7d46bdf2071b6617514ddb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9eef442d291a447d74c5d253c49ef324eac1d8f0\":{\"balance\":\"0xb96608c8103bf00000\"},\"9ef1896b007c32a15114fb89d73dbd47f9122b69\":{\"balance\":\"0xd8d726b7177a800000\"},\"9f017706b830fb9c30efb0a09f506b9157457534\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9f10f2a0463b65ae30b070b3df18cf46f51e89bd\":{\"balance\":\"0x678a932062e4180000\"},\"9f19fac8a32437d80ac6837a0bb7841729f4972e\":{\"balance\":\"0x233df3299f61720000\"},\"9f1aa8fcfc89a1a5328cbd6344b71f278a2ca4a0\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"9f21302ca5096bea7402b91b0fd506254f999a3d\":{\"balance\":\"0x4397451a003dd80000\"},\"9f271d285500d73846b18f733e25dd8b4f5d4a8b\":{\"balance\":\"0x2723c346ae18080000\"},\"9f3497f5ef5fe63095836c004eb9ce02e9013b4b\":{\"balance\":\"0x2256861bf9cf080000\"},\"9f3a74fd5e7edcc1162993171381cbb632b7cff0\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"9f46e7c1e9078cae86305ac7060b01467d6685ee\":{\"balance\":\"0x243d4d18229ca20000\"},\"9f496cb2069563144d0811677ba0e4713a0a4143\":{\"balance\":\"0x3cd2e0bf63a4480000\"},\"9f4a7195ac7c151ca258cafda0cab083e049c602\":{\"balance\":\"0x53538c32185cee0000\"},\"9f4ac9c9e7e24cb2444a0454fa5b9ad9d92d3853\":{\"balance\":\"0x2d43f3ebfafb2c0000\"},\"9f5f44026b576a4adb41e95961561d41039ca391\":{\"balance\":\"0xd8d726b7177a80000\"},\"9f607b3f12469f446121cebf3475356b71b4328c\":{\"balance\":\"0xd8d726b7177a800000\"},\"9f61beb46f5e853d0a8521c7446e68e34c7d0973\":{\"balance\":\"0x1e5b8fa8fe2ac00000\"},\"9f64a8e8dacf4ade30d10f4d59b0a3d5abfdbf74\":{\"balance\":\"0x36369ed7747d260000\"},\"9f662e95274121f177566e636d23964cf1fd686f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9f6a322a6d469981426ae844865d7ee0bb15c7b3\":{\"balance\":\"0x2b5ee57929fdb8000\"},\"9f7986924aeb02687cd64189189fb167ded2dd5c\":{\"balance\":\"0x35659ef93f0fc40000\"},\"9f7a0392f857732e3004a375e6b1068d49d83031\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9f8245c3ab7d173164861cd3991b94f1ba40a93a\":{\"balance\":\"0x9b0a791f1211300000\"},\"9f83a293c324d4106c18faa8888f64d299054ca0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"9f86a066edb61fcb5856de93b75c8c791864b97b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9f98eb34d46979b0a6de8b05aa533a89b825dcf1\":{\"balance\":\"0x4b06dbbb40f4a0000\"},\"9f9fe0c95f10fee87af1af207236c8f3614ef02f\":{\"balance\":\"0x14542ba12a337c00000\"},\"9faea13c733412dc4b490402bfef27a0397a9bc3\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"9fbe066de57236dc830725d32a02aef9246c6c5e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"9fd1052a60506bd1a9ef003afd9d033c267d8e99\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9fd64373f2fbcd9c0faca60547cad62e26d9851f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9fe501aa57ead79278937cd6308c5cfa7a5629fe\":{\"balance\":\"0x2b5ee57929fdb8000\"},\"9ffc5fe06f33f5a480b75aa94eb8556d997a16c0\":{\"balance\":\"0x1158e460913d00000\"},\"9ffcf5ef46d933a519d1d16c6ba3189b27496224\":{\"balance\":\"0x3635c9adc5dea00000\"},\"9ffedcc36b7cc312ad2a9ede431a514fccb49ba3\":{\"balance\":\"0x244f579f3f5ca40000\"},\"a006268446643ec5e81e7acb3f17f1c351ee2ed9\":{\"balance\":\"0xd8d726b7177a800000\"},\"a008019863c1a77c1499eb39bbd7bf2dd7a31cb9\":{\"balance\":\"0x76d41c62494840000\"},\"a009bf076f1ba3fa57d2a7217218bed5565a7a7a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a01e9476df84431825c836e8803a97e22fa5a0cd\":{\"balance\":\"0x14542ba12a337c00000\"},\"a01f12d70f44aa7b113b285c22dcdb45873454a7\":{\"balance\":\"0xfc936392801c0000\"},\"a01fd1906a908506dedae1e208128872b56ee792\":{\"balance\":\"0xa2a15d09519be00000\"},\"a0228240f99e1de9cb32d82c0f2fa9a3d44b0bf3\":{\"balance\":\"0x56bc75e2d631000000\"},\"a02bde6461686e19ac650c970d0672e76dcb4fc2\":{\"balance\":\"0x1e09296c3378de40000\"},\"a02c1e34064f0475f7fa831ccb25014c3aa31ca2\":{\"balance\":\"0x340aad21b3b700000\"},\"a02dc6aa328b880de99eac546823fccf774047fb\":{\"balance\":\"0x6acb3df27e1f880000\"},\"a02e3f8f5959a7aab7418612129b701ca1b80010\":{\"balance\":\"0x1158e460913d00000\"},\"a0347f0a98776390165c166d32963bf74dcd0a2f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a035a3652478f82dbd6d115faa8ca946ec9e681d\":{\"balance\":\"0x5f4e42dd4afec0000\"},\"a03a3dc7c533d1744295be955d61af3f52b51af5\":{\"balance\":\"0x22b1c8c1227a00000\"},\"a0459ef3693aacd1647cd5d8929839204cef53be\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a04f2ae02add14c12faf65cb259022d0830a8e26\":{\"balance\":\"0x152d02c7e14af6800000\"},\"a06cd1f396396c0a64464651d7c205efaf387ca3\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"a072691c8dd7cd4237ff72a75c1a9506d0ce5b9e\":{\"balance\":\"0x140ec80fa7ee880000\"},\"a072cebe62a9e9f61cc3fbf88a9efbfe3e9a8d70\":{\"balance\":\"0x15af1d78b58c400000\"},\"a07682000b1bcf3002f85c80c0fa2949bd1e82fd\":{\"balance\":\"0xd8d726b7177a800000\"},\"a07aa16d74aee8a9a3288d52db1551d593883297\":{\"balance\":\"0x2086ac351052600000\"},\"a08d215b5b6aac4861a281ac7e400b78fef04cbf\":{\"balance\":\"0x1158e460913d00000\"},\"a0951970dfd0832fb83bda12c23545e79041756c\":{\"balance\":\"0x2086ac351052600000\"},\"a09f4d5eaa65a2f4cb750a49923401dae59090af\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"a0a0e65204541fca9b2fb282cd95138fae16f809\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a0aa5f0201f04d3bbeb898132f7c11679466d901\":{\"balance\":\"0x1fbed5215bb4c0000\"},\"a0aadbd9509722705f6d2358a5c79f37970f00f6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a0b771951ce1deee363ae2b771b73e07c4b5e800\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"a0de5c601e696635c698b7ae9ca4539fc7b941ec\":{\"balance\":\"0x12c3cbd704c9770000\"},\"a0e8ba661b48154cf843d4c2a5c0f792d528ee29\":{\"balance\":\"0x15af1d78b58c400000\"},\"a0fc7e53c5ebd27a2abdac45261f84ab3b51aefb\":{\"balance\":\"0xa313daec9bc0d90000\"},\"a0ff5b4cf016027e8323497d4428d3e5a83b8795\":{\"balance\":\"0x16598d3c83ec0420000\"},\"a106465bbd19e1b6bce50d1b1157dc59095a3630\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a106e6923edd53ca8ed650968a9108d6ccfd9670\":{\"balance\":\"0x202fe1505afec898000\"},\"a109e18bb0a39c9ef82fa19597fc5ed8e9eb6d58\":{\"balance\":\"0x58e7926ee858a00000\"},\"a11a03c4bb26d21eff677d5d555c80b25453ee7a\":{\"balance\":\"0x3cb2759bc410f8000\"},\"a11effab6cf0f5972cffe4d56596e98968144a8f\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"a1204dad5f560728a35c0d8fc79481057bf77386\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a12623e629df93096704b16084be2cd89d562da4\":{\"balance\":\"0x1ccc9324511e4500000\"},\"a12a6c2d985daf0e4f5f207ae851aaf729b332cd\":{\"balance\":\"0x152d02c7e14af6800000\"},\"a1336dfb96b6bcbe4b3edf3205be5723c90fad52\":{\"balance\":\"0x10f0cf064dd59200000\"},\"a13b9d82a99b3c9bba5ae72ef2199edc7d3bb36c\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"a13cfe826d6d1841dcae443be8c387518136b5e8\":{\"balance\":\"0x1da56a4b0835bf800000\"},\"a1432ed2c6b7777a88e8d46d388e70477f208ca5\":{\"balance\":\"0x1b1a7e413a196c50000\"},\"a144f6b60f72d64a21e330dadb62d8990ade2b09\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a15025f595acdbf3110f77c5bf24477e6548f9e8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a158148a2e0f3e92dc2ce38febc20107e3253c96\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a16160851d2b9c349b92e46f829abfb210943595\":{\"balance\":\"0x61093d7c2c6d380000\"},\"a166f911c644ac3213d29e0e1ae010f794d5ad26\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a16d9e3d63986159a800b46837f45e8bb980ee0b\":{\"balance\":\"0x6e1175da7ad1200000\"},\"a17070c2e9c5a940a4ec0e4954c4d7d643be8f49\":{\"balance\":\"0x6c6b17033b361c8000\"},\"a17c9e4323069518189d5207a0728dcb92306a3f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a18360e985f2062e8f8efe02ad2cbc91ad9a5aad\":{\"balance\":\"0xa2a15d09519be00000\"},\"a1911405cf6e999ed011f0ddcd2a4ff7c28f2526\":{\"balance\":\"0x22b1c8c1227a00000\"},\"a192698007cc11aa603d221d5feea076bcf7c30d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a192f06ab052d5fd7f94eea8318e827815fe677a\":{\"balance\":\"0x71f8a93d01e540000\"},\"a1998144968a5c70a6415554cefec2824690c4a5\":{\"balance\":\"0x1158e460913d00000\"},\"a1a1f0fa6d20b50a794f02ef52085c9d036aa6ca\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a1ae8d4540d4db6fdde7146f415b431eb55c7983\":{\"balance\":\"0xaadec983fcff40000\"},\"a1b47c4d0ed6018842e6cfc8630ac3a3142e5e6b\":{\"balance\":\"0x1158e460913d00000\"},\"a1c4f45a82e1c478d845082eb18875c4ea6539ab\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"a1dcd0e5b05a977c9623e5ae2f59b9ada2f33e31\":{\"balance\":\"0x56bc75e2d63100000\"},\"a1e4380a3b1f749673e270229993ee55f35663b4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a1f193a0592f1feb9fdfc90aa813784eb80471c9\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"a1f2854050f872658ed82e52b0ad7bbc1cb921f6\":{\"balance\":\"0x6d0317e2b326f70000\"},\"a1f5b840140d5a9acef402ac3cc3886a68cad248\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a1f765c44fe45f790677944844be4f2d42165fbd\":{\"balance\":\"0xc7e9cfde768ec70000\"},\"a1f7dde1d738d8cd679ea1ee965bee224be7d04d\":{\"balance\":\"0x3d184450e5e93c0000\"},\"a1f8d8bcf90e777f19b3a649759ad95027abdfc3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a202547242806f6e70e74058d6e5292defc8c8d4\":{\"balance\":\"0x6c8754c8f30c080000\"},\"a20d071b1b003063497d7990e1249dabf36c35f7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a20d8ff60caae31d02e0b665fa435d76f77c9442\":{\"balance\":\"0x1a8a909dfcef400000\"},\"a211da03cc0e31ecce5309998718515528a090df\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a21442ab05340ade68c915f3c3399b9955f3f7eb\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"a2222259dd9c3e3ded127084f808e92a1887302c\":{\"balance\":\"0x8c8339dafed480000\"},\"a22ade0ddb5c6ef8d0cd8de94d82b11082cb2e91\":{\"balance\":\"0x374b57f3cef2700000\"},\"a24c3ab62181e9a15b78c4621e4c7c588127be26\":{\"balance\":\"0x8cde43a83d3310000\"},\"a257ad594bd88328a7d90fc0a907df95eecae316\":{\"balance\":\"0x1c3786ff3846930000\"},\"a25b086437fd2192d0a0f64f6ed044f38ef3da32\":{\"balance\":\"0x12290f15180bdc0000\"},\"a276b058cb98d88beedb67e543506c9a0d9470d8\":{\"balance\":\"0x90aafc76e02fbe0000\"},\"a282e969cac9f7a0e1c0cd90f5d0c438ac570da3\":{\"balance\":\"0x2207eb89fc27380000\"},\"a291e9c7990d552dd1ae16cebc3fca342cbaf1d1\":{\"balance\":\"0x43c33c1937564800000\"},\"a29319e81069e5d60df00f3de5adee3505ecd5fb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a2968fc1c64bac0b7ae0d68ba949874d6db253f4\":{\"balance\":\"0x43c33c1937564800000\"},\"a29d5bda74e003474872bd5894b88533ff64c2b5\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a29d661a6376f66d0b74e2fe9d8f26c0247ec84c\":{\"balance\":\"0xdf3304079c13d20000\"},\"a2a435de44a01bd0ecb29e44e47644e46a0cdffb\":{\"balance\":\"0x1b1d445a7affe78000\"},\"a2ace4c993bb1e5383f8ac74e179066e814f0591\":{\"balance\":\"0x56bc75e2d63100000\"},\"a2b701f9f5cdd09e4ba62baebae3a88257105885\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a2c5854ff1599f98892c5725d262be1da98aadac\":{\"balance\":\"0x1109ff333010e78000\"},\"a2c7eaffdc2c9d937345206c909a52dfb14c478f\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"a2d2aa626b09d6d4e4b13f7ffc5a88bd7ad36742\":{\"balance\":\"0xfb8078507553830000\"},\"a2d38de1c73906f6a7ca6efeb97cf6f69cc421be\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a2dc65ee256b59a5bd7929774f904b358df3ada1\":{\"balance\":\"0x483bce28beb09f80000\"},\"a2e0683a805de6a05edb2ffbb5e96f0570b637c3\":{\"balance\":\"0x1158e460913d00000\"},\"a2e1b8aa900e9c139b3fa122354f6156d92a18b1\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a2e2b5941e0c01944bfe1d5fb4e8a34b922ccfb1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a2e460a989cb15565f9ecca7d121a18e4eb405b6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a2ecce2c49f72a0995a0bda57aacf1e9f001e22a\":{\"balance\":\"0xd8d726b7177a800000\"},\"a2f472fe4f22b77db489219ea4023d11582a9329\":{\"balance\":\"0x878678326eac9000000\"},\"a2f798e077b07d86124e1407df32890dbb4b6379\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a2f86bc061884e9eef05640edd51a2f7c0596c69\":{\"balance\":\"0x6c6c44fe47ec050000\"},\"a2fa17c0fb506ce494008b9557841c3f641b8cae\":{\"balance\":\"0x1158e460913d00000\"},\"a304588f0d850cd8d38f76e9e83c1bf63e333ede\":{\"balance\":\"0x2285601216c8c0000\"},\"a3058c51737a4e96c55f2ef6bd7bb358167ec2a7\":{\"balance\":\"0x20db3ae4481ad48000\"},\"a309df54cabce70c95ec3033149cd6678a6fd4cf\":{\"balance\":\"0xc1f12c75101580000\"},\"a30a45520e5206d9004070e6af3e7bb2e8dd5313\":{\"balance\":\"0x15af1d78b58c400000\"},\"a30e0acb534c9b3084e8501da090b4eb16a2c0cd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a3203095edb7028e6871ce0a84f548459f83300a\":{\"balance\":\"0xd8d726b7177a800000\"},\"a321091d3018064279db399d2b2a88a6f440ae24\":{\"balance\":\"0xad78ebc5ac62000000\"},\"a3232d068d50064903c9ebc563b515acc8b7b097\":{\"balance\":\"0x6c8754c8f30c080000\"},\"a3241d890a92baf52908dc4aa049726be426ebd3\":{\"balance\":\"0x43c2da661ca2f540000\"},\"a3294626ec2984c43b43da4d5d8e4669b11d4b59\":{\"balance\":\"0x36a4cf636319c00000\"},\"a32cf7dde20c3dd5679ff5e325845c70c5962662\":{\"balance\":\"0x1158e460913d00000\"},\"a339a3d8ca280e27d2415b26d1fc793228b66043\":{\"balance\":\"0x36f28695b78ff00000\"},\"a33cb450f95bb46e25afb50fe05feee6fb8cc8ea\":{\"balance\":\"0x2a1129d09367200000\"},\"a33f70da7275ef057104dfa7db64f472e9f5d553\":{\"balance\":\"0x45946b0f9e9d60000\"},\"a34076f84bd917f20f8342c98ba79e6fb08ecd31\":{\"balance\":\"0xe3aeb5737240a00000\"},\"a3430e1f647f321ed34739562323c7d623410b56\":{\"balance\":\"0x3634fb9f1489a70000\"},\"a34f9d568bf7afd94c2a5b8a5ff55c66c4087999\":{\"balance\":\"0x847d503b220eb00000\"},\"a35606d51220ee7f2146d411582ee4ee4a45596e\":{\"balance\":\"0xd8aabe080bc9400000\"},\"a356551bb77d4f45a6d7e09f0a089e79cca249cb\":{\"balance\":\"0x126e72a69a50d00000\"},\"a35c19132cac1935576abfed6c0495fb07881ba0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a365918bfe3f2627b9f3a86775d8756e0fd8a94b\":{\"balance\":\"0x15af1d78b58c400000\"},\"a36e0d94b95364a82671b608cb2d373245612909\":{\"balance\":\"0x821d221b5291f8000\"},\"a375b4bc24a24e1f797593cc302b2f331063fa5c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a37622ac9bbdc4d82b75015d745b9f8de65a28ec\":{\"balance\":\"0x9dc05cce28c2b80000\"},\"a379a5070c503d2fac89b8b3afa080fd45ed4bec\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"a3802d8a659e89a2c47e905430b2a827978950a7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a38306cb70baa8e49186bd68aa70a83d242f2907\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a38476691d34942eea6b2f76889223047db4617a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a387ce4e961a7847f560075c64e1596b5641d21c\":{\"balance\":\"0x243d4d18229ca20000\"},\"a387ecde0ee4c8079499fd8e03473bd88ad7522a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"a3883a24f7f166205f1a6a9949076c26a76e7178\":{\"balance\":\"0x62a992e53a0af00000\"},\"a38b5bd81a9db9d2b21d5ec7c60552cd02ed561b\":{\"balance\":\"0x14542ba12a337c00000\"},\"a390ca122b8501ee3e5e07a8ca4b419f7e4dae15\":{\"balance\":\"0x56bc75e2d63100000\"},\"a3932a31d6ff75fb3b1271ace7caa7d5e1ff1051\":{\"balance\":\"0x43c33c1937564800000\"},\"a394ad4fd9e6530e6f5c53faecbede81cb172da1\":{\"balance\":\"0x12f939c99edab800000\"},\"a3979a92760a135adf69d72f75e167755f1cb8c3\":{\"balance\":\"0x56bc75e2d63100000\"},\"a39bfee4aec9bd75bd22c6b672898ca9a1e95d32\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a3a262afd2936819230892fde84f2d5a594ab283\":{\"balance\":\"0x65ea3db75546600000\"},\"a3a2e319e7d3a1448b5aa2468953160c2dbcba71\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a3a57b0716132804d60aac281197ff2b3d237b01\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"a3a93ef9dbea2636263d06d8492f6a41de907c22\":{\"balance\":\"0x340aad21b3b700000\"},\"a3ae1879007d801cb5f352716a4dd8ba2721de3d\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"a3ba0d3a3617b1e31b4e422ce269e873828d5d69\":{\"balance\":\"0x2e141ea081ca080000\"},\"a3bc979b7080092fa1f92f6e0fb347e28d995045\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"a3bff1dfa9971668360c0d82828432e27bf54e67\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a3c14ace28b192cbb062145fcbbd5869c67271f6\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a3c33afc8cb4704e23153de2049d35ae71332472\":{\"balance\":\"0x2b58addb89a2580000\"},\"a3d0b03cffbb269f796ac29d80bfb07dc7c6ad06\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a3d583a7b65b23f60b7905f3e4aa62aac87f4227\":{\"balance\":\"0x38befa126d5a9f8000\"},\"a3db364a332d884ba93b2617ae4d85a1489bea47\":{\"balance\":\"0x5c283d410394100000\"},\"a3e051fb744aa3410c3b88f899f5d57f168df12d\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"a3e3a6ea509573e21bd0239ece0523a7b7d89b2f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"a3f4ad14e0bb44e2ce2c14359c75b8e732d37054\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a3facc50195c0b4933c85897fecc5bbd995c34b8\":{\"balance\":\"0x1158e460913d00000\"},\"a4035ab1e5180821f0f380f1131b7387c8d981cd\":{\"balance\":\"0x1158e460913d00000\"},\"a40aa2bbce0c72b4d0dfffcc42715b2b54b01bfa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a419a984142363267575566089340eea0ea20819\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"a421dbb89b3a07419084ad10c3c15dfe9b32d0c2\":{\"balance\":\"0x43c33c1937564800000\"},\"a422e4bf0bf74147cc895bed8f16d3cef3426154\":{\"balance\":\"0x12ef3f62ee11368000\"},\"a4259f8345f7e3a8b72b0fec2cf75e321fda4dc2\":{\"balance\":\"0x678a932062e4180000\"},\"a42908e7fe53980a9abf4044e957a54b70e99cbe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a429fa88731fdd350e8ecd6ea54296b6484fe695\":{\"balance\":\"0x6ac5c62d9486070000\"},\"a430995ddb185b9865dbe62539ad90d22e4b73c2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a436c75453ccca4a1f1b62e5c4a30d86dde4be68\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a437fe6ec103ca8d158f63b334224eccac5b3ea3\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a43b6da6cb7aac571dff27f09d39f846f53769b1\":{\"balance\":\"0x14998f32ac78700000\"},\"a43b81f99356c0af141a03010d77bd042c71c1ee\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a43e1947a9242b355561c30a829dfeeca2815af8\":{\"balance\":\"0xd23d99969fd6918000\"},\"a4489a50ead5d5445a7bee4d2d5536c2a76c41f8\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a44fe800d96fcad73b7170d0f610cb8c0682d6ce\":{\"balance\":\"0xd8d726b7177a800000\"},\"a45432a6f2ac9d56577b938a37fabac8cc7c461c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a466d770d898d8c9d405e4a0e551efafcde53cf9\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"a4670731175893bbcff4fa85ce97d94fc51c4ba8\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a46b4387fb4dcce011e76e4d73547d4481e09be5\":{\"balance\":\"0x487a9a304539440000\"},\"a46cd237b63eea438c8e3b6585f679e4860832ac\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a47779d8bc1c7bce0f011ccb39ef68b854f8de8f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a4826b6c3882fad0ed5c8fbb25cc40cc4f33759f\":{\"balance\":\"0x701b43e34433d00000\"},\"a4875928458ec2005dbb578c5cd33580f0cf1452\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a49f523aa51364cbc7d995163d34eb590ded2f08\":{\"balance\":\"0x9027421b2a9fbc0000\"},\"a4a49f0bc8688cc9e6dc04e1e08d521026e65574\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a4a7d306f510cd58359428c0d2f7c3609d5674d7\":{\"balance\":\"0xb58cb61c3ccf340000\"},\"a4a83a0738799b971bf2de708c2ebf911ca79eb2\":{\"balance\":\"0x2086ac351052600000\"},\"a4b09de6e713dc69546e76ef0acf40b94f0241e6\":{\"balance\":\"0x117dc0627ec8700000\"},\"a4d2b429f1ad5349e31704969edc5f25ee8aca10\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a4d6c82eddae5947fbe9cdfbd548ae33d91a7191\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a4da34450d22ec0ffcede0004b02f7872ee0b73a\":{\"balance\":\"0x50f616673f0830000\"},\"a4dd59ab5e517d398e49fa537f899fed4c15e95d\":{\"balance\":\"0x43c33c1937564800000\"},\"a4e623451e7e94e7e89ba5ed95c8a83a62ffc4ea\":{\"balance\":\"0x1158e460913d00000\"},\"a4ed11b072d89fb136759fc69b428c48aa5d4ced\":{\"balance\":\"0xe3f1527a03ca80000\"},\"a4fb14409a67b45688a8593e5cc2cf596ced6f11\":{\"balance\":\"0x61093d7c2c6d380000\"},\"a514d00edd7108a6be839a638db2415418174196\":{\"balance\":\"0x65a4da25d3016c00000\"},\"a522de7eb6ae1250522a513133a93bd42849475c\":{\"balance\":\"0x43c33c1937564800000\"},\"a524a8cccc49518d170a328270a2f88133fbaf5d\":{\"balance\":\"0xff7022dac108a0000\"},\"a539b4a401b584dfe0f344b1b422c65543167e2e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a53ead54f7850af21438cbe07af686279a315b86\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a543a066fb32a8668aa0736a0c9cd40d78098727\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a567770b6ae320bdde50f904d663e746a61dace6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a568db4d57e4d67462d733c69a9e0fe26e218327\":{\"balance\":\"0x3b6bff9266c0ae0000\"},\"a5698035391e67a49013c0002079593114feb353\":{\"balance\":\"0xd02ab486cedc00000\"},\"a570223ae3caa851418a9843a1ac55db4824f4fd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a57360f002e0d64d2d74457d8ca4857ee00bcddf\":{\"balance\":\"0x1233e232f618aa0000\"},\"a575f2891dcfcda83c5cf01474af11ee01b72dc2\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"a5783bf33432ff82ac498985d7d460ae67ec3673\":{\"balance\":\"0x62a992e53a0af00000\"},\"a5874d754635a762b381a5c4c792483af8f23d1d\":{\"balance\":\"0x2b5e3af16b1880000\"},\"a5a4227f6cf98825c0d5baff5315752ccc1a1391\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a5ab4bd3588f46cb272e56e93deed386ba8b753d\":{\"balance\":\"0x4842f04105872c8000\"},\"a5bad86509fbe0e0e3c0e93f6d381f1af6e9d481\":{\"balance\":\"0x14542ba12a337c00000\"},\"a5c336083b04f9471b8c6ed73679b74d66c363ec\":{\"balance\":\"0xa3650a4c9d20e20000\"},\"a5cd123992194b34c4781314303b03c54948f4b9\":{\"balance\":\"0x6cfcc3d91da5630000\"},\"a5d5b8b62d002def92413710d13b6ff8d4fc7dd3\":{\"balance\":\"0x15af1d78b58c400000\"},\"a5d96e697d46358d119af7819dc7087f6ae47fef\":{\"balance\":\"0x317bee8af3315a78000\"},\"a5de5e434fdcdd688f1c31b6fb512cb196724701\":{\"balance\":\"0x2b5e3af16b18800000\"},\"a5e0fc3c3affed3db6710947d1d6fb017f3e276d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a5e93b49ea7c509de7c44d6cfeddef5910deaaf2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a5e9cd4b74255d22b7d9b27ae8dd43ed6ed0252b\":{\"balance\":\"0x298db2f54411d98000\"},\"a5f0077b351f6c505cd515dfa6d2fa7f5c4cd287\":{\"balance\":\"0x878678326eac9000000\"},\"a5f075fd401335577b6683c281e6d101432dc6e0\":{\"balance\":\"0x914878a8c05ee00000\"},\"a5fe2ce97f0e8c3856be0de5f4dcb2ce5d389a16\":{\"balance\":\"0x13db0b8b6863e0000\"},\"a5ff62222d80c013cec1a0e8850ed4d354dac16d\":{\"balance\":\"0xb41075c168b180000\"},\"a609c26dd350c235e44b2b9c1dddccd0a9d9f837\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a60c1209754f5d87b181da4f0817a81859ef9fd8\":{\"balance\":\"0x2b5e3af16b1880000\"},\"a6101c961e8e1c15798ffcd0e3201d7786ec373a\":{\"balance\":\"0x14542ba12a337c00000\"},\"a613456996408af1c2e93e177788ab55895e2b32\":{\"balance\":\"0x15919ff477c88b80000\"},\"a61887818f914a20e31077290b83715a6b2d6ef9\":{\"balance\":\"0x65ea3db75546600000\"},\"a61a54df784a44d71b771b87317509211381f200\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a61cdbadf04b1e54c883de6005fcdf16beb8eb2f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a639acd96b31ba53b0d08763229e1f06fd105e9d\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a642501004c90ea9c9ed1998ba140a4cd62c6f5f\":{\"balance\":\"0xd94fb8b10f8b18000\"},\"a644ed922cc237a3e5c4979a995477f36e50bc62\":{\"balance\":\"0x1fa73d845d7e960000\"},\"a646a95c6d6f59f104c6541d7760757ab392b08c\":{\"balance\":\"0xe3aeb5737240a00000\"},\"a6484cc684c4c91db53eb68a4da45a6a6bda3067\":{\"balance\":\"0x14542ba12a337c00000\"},\"a64e5ffb704c2c9139d77ef61d8cdfa31d7a88e9\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"a65426cff378ed23253513b19f496de45fa7e18f\":{\"balance\":\"0x18650127cc3dc800000\"},\"a66a4963b27f1ee1932b172be5964e0d3ae54b51\":{\"balance\":\"0x960db77681e940000\"},\"a67f38819565423aa85f3e3ab61bc763cbab89dd\":{\"balance\":\"0x7377b022c6be080000\"},\"a68c313445c22d919ee46cc2d0cdff043a755825\":{\"balance\":\"0x41374fd21b0d88000\"},\"a68e0c30cba3bc5a883e540320f999c7cd558e5c\":{\"balance\":\"0x6192333762a58c8000\"},\"a690f1a4b20ab7ba34628620de9ca040c43c1963\":{\"balance\":\"0xd8d726b7177a800000\"},\"a69d7cd17d4842fe03f62a90b2fbf8f6af7bb380\":{\"balance\":\"0x56bc75e2d63100000\"},\"a6a08252c8595177cc2e60fc27593e2379c81fb1\":{\"balance\":\"0x11651ac3e7a758000\"},\"a6a0de421ae54f6d17281308f5646d2f39f7775d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a6b2d573297360102c07a18fc21df2e7499ff4eb\":{\"balance\":\"0xd96fce90cfabcc0000\"},\"a6c910ce4d494a919ccdaaa1fc3b82aa74ba06cf\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"a6e3baa38e104a1e27a4d82869afb1c0ae6eff8d\":{\"balance\":\"0x11140eead8b710000\"},\"a6eebbe464d39187bf80ca9c13d72027ec5ba8be\":{\"balance\":\"0xa2a15d09519be00000\"},\"a6f62b8a3d7f11220701ab9ffffcb327959a2785\":{\"balance\":\"0x1b6e291f18dba80000\"},\"a6f93307f8bce03195fece872043e8a03f7bd11a\":{\"balance\":\"0x9c734bad5111580000\"},\"a701df79f594901afe1444485e6b20c3bda2b9b3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a7024cfd742c1ec13c01fea18d3042e65f1d5dee\":{\"balance\":\"0x263119a28abd0b08000\"},\"a718aaad59bf395cba2b23e09b02fe0c89816247\":{\"balance\":\"0x36303c97e468780000\"},\"a7247c53d059eb7c9310f628d7fc6c6a0a773f08\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a7253763cf4a75df92ca1e766dc4ee8a2745147b\":{\"balance\":\"0x2463770e90a8f500000\"},\"a72ee666c4b35e82a506808b443cebd5c632c7dd\":{\"balance\":\"0x2b5e3af16b18800000\"},\"a74444f90fbb54e56f3ac9b6cfccaa4819e4614a\":{\"balance\":\"0x1158e460913d00000\"},\"a747439ad0d393b5a03861d77296326de8bb9db9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a7607b42573bb6f6b4d4f23c7e2a26b3a0f6b6f0\":{\"balance\":\"0x57473d05dabae80000\"},\"a76929890a7b47fb859196016c6fdd8289ceb755\":{\"balance\":\"0x10f0cf064dd59200000\"},\"a76b743f981b693072a131b22ba510965c2fefd7\":{\"balance\":\"0xfc936392801c0000\"},\"a76d3f156251b72c0ccf4b47a3393cbd6f49a9c5\":{\"balance\":\"0x487a9a304539440000\"},\"a77428bcb2a0db76fc8ef1e20e461a0a32c5ac15\":{\"balance\":\"0x15be6174e1912e0000\"},\"a7758cecb60e8f614cce96137ef72b4fbd07774a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a7775e4af6a23afa201fb78b915e51a515b7a728\":{\"balance\":\"0x68155a43676e00000\"},\"a77f3ee19e9388bbbb2215c62397b96560132360\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a7859fc07f756ea7dcebbccd42f05817582d973f\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a7966c489f4c748a7ae980aa27a574251767caf9\":{\"balance\":\"0xa2a15d09519be00000\"},\"a7a3bb6139b0ada00c1f7f1f9f56d994ba4d1fa8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a7a3f153cdc38821c20c5d8c8241b294a3f82b24\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a7a517d7ad35820b09d497fa7e5540cde9495853\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a7c9d388ebd873e66b1713448397d0f37f8bd3a8\":{\"balance\":\"0x10f0cf064dd59200000\"},\"a7dcbba9b9bf6762c145416c506a71e3b497209c\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"a7e74f0bdb278ff0a805a648618ec52b166ff1be\":{\"balance\":\"0x56bc75e2d63100000\"},\"a7e83772bc200f9006aa2a260dbaa8483dc52b30\":{\"balance\":\"0xb42d5366637e50000\"},\"a7ef35ce87eda6c28df248785815053ec97a5045\":{\"balance\":\"0x10f0ce949e00f930000\"},\"a7f9220c8047826bd5d5183f4e676a6d77bfed36\":{\"balance\":\"0x85068976be81c0000\"},\"a807104f2703d679f8deafc442befe849e42950b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a80cb1738bac08d4f9c08b4deff515545fa8584f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a819d2ece122e028c8e8a04a064d02b9029b08b9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a825fd5abb7926a67cf36ba246a24bd27be6f6ed\":{\"balance\":\"0xf43fc2c04ee00000\"},\"a8285539869d88f8a961533755717d7eb65576ae\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a83382b6e15267974a8550b98f7176c1a353f9be\":{\"balance\":\"0xbffdaf2fc1b1a40000\"},\"a8446c4781a737ac4328b1e15b8a0b3fbb0fd668\":{\"balance\":\"0x48794d1f246192a0000\"},\"a8455b411765d6901e311e726403091e42c56683\":{\"balance\":\"0xb73aec3bfe14500000\"},\"a86613e6c4a4c9c55f5c10bcda32175dcbb4af60\":{\"balance\":\"0x243d6c2e36be6ae0000\"},\"a86db07d9f812f4796622d40e03d135874a88a74\":{\"balance\":\"0x1158e460913d00000\"},\"a87f7abd6fa31194289678efb63cf584ee5e2a61\":{\"balance\":\"0xd8d726b7177a800000\"},\"a880e2a8bf88a1a82648b4013c49c4594c433cc8\":{\"balance\":\"0x1004e2e45fb7ee00000\"},\"a88577a073fbaf33c4cd202e00ea70ef711b4006\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a8914c95b560ec13f140577338c32bcbb77d3a7a\":{\"balance\":\"0x9c2007651b2500000\"},\"a89ac93b23370472daac337e9afdf642543f3e57\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a89df34859edd7c820db887740d8ff9e15157c7b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a8a43c009100616cb4ae4e033f1fc5d7e0b6f152\":{\"balance\":\"0xd588d078b43f4d8000\"},\"a8a708e84f82db86a35502193b4c6ee9a76ebe8f\":{\"balance\":\"0x3708baed3d68900000\"},\"a8a7b68adab4e3eadff19ffa58e34a3fcec0d96a\":{\"balance\":\"0x14542ba12a337c00000\"},\"a8a8dbdd1a85d1beee2569e91ccc4d09ae7f6ea1\":{\"balance\":\"0x13a6b2b564871a00000\"},\"a8aca748f9d312ec747f8b6578142694c7e9f399\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a8b65ba3171a3f77a6350b9daf1f8d55b4d201eb\":{\"balance\":\"0x2862f3b0d222040000\"},\"a8beb91c2b99c8964aa95b6b4a184b1269fc3483\":{\"balance\":\"0x15af1d78b58c400000\"},\"a8c0b02faf02cb5519dda884de7bbc8c88a2da81\":{\"balance\":\"0xe7c2518505060000\"},\"a8c1d6aa41fe3d65f67bd01de2a866ed1ed9ae52\":{\"balance\":\"0x1a055690d9db80000\"},\"a8cafac32280d021020bf6f2a9782883d7aabe12\":{\"balance\":\"0x56bc75e2d63100000\"},\"a8db0b9b201453333c757f6ad9bcb555c02da93b\":{\"balance\":\"0x7742b7830f341d0000\"},\"a8e42a4e33d7526cca19d9a36dcd6e8040d0ea73\":{\"balance\":\"0x3a8c02c5ea2de00000\"},\"a8e7201ff619faffc332e6ad37ed41e301bf014a\":{\"balance\":\"0x2086ac351052600000\"},\"a8ee1df5d44b128469e913569ef6ac81eeda4fc8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a8ef9ad274436042903e413c3b0c62f5f52ed584\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a8f37f0ab3a1d448a9e3ce40965f97a646083a34\":{\"balance\":\"0x11e0e4f8a50bd40000\"},\"a8f89dd5cc6e64d7b1eeace00702022cd7d2f03d\":{\"balance\":\"0x25f273933db5700000\"},\"a90476e2efdfee4f387b0f32a50678b0efb573b5\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a9145046fa3628cf5fd4c613927be531e6db1fdd\":{\"balance\":\"0x6124fee993bc00000\"},\"a914cdb571bfd93d64da66a4e108ea134e50d000\":{\"balance\":\"0x4d8738994713798000\"},\"a91a5a7b341f99c535144e20be9c6b3bb4c28e4d\":{\"balance\":\"0x126753aa224a70b0000\"},\"a9252551a624ae513719dabe5207fbefb2fd7749\":{\"balance\":\"0x22b1c8c1227a00000\"},\"a927d48bb6cb814bc609cbcaa9151f5d459a27e1\":{\"balance\":\"0xeb935090064180000\"},\"a929c8bd71db0c308dac06080a1747f21b1465aa\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"a94bbb8214cf8da0c2f668a2ac73e86248528d4b\":{\"balance\":\"0x340aad21b3b7000000\"},\"a951b244ff50cfae591d5e1a148df6a938ef2a1a\":{\"balance\":\"0x5e001584dfcf580000\"},\"a960b1cadd3b5c1a8e6cb3abcaf52ee7c3d9fa88\":{\"balance\":\"0x528bc3545e52680000\"},\"a961171f5342b173dd70e7bfe5b5ca238b13bcdd\":{\"balance\":\"0xb82794a9244f0c8000\"},\"a975b077fcb4cc8efcbf838459b6fa243a4159d6\":{\"balance\":\"0x22b1c8c1227a00000\"},\"a97beb3a48c45f1528284cb6a95f7de453358ec6\":{\"balance\":\"0x690836c0af5f5600000\"},\"a97e072144499fe5ebbd354acc7e7efb58985d08\":{\"balance\":\"0x90f534608a72880000\"},\"a986762f7a4f294f2e0b173279ad2c81a2223458\":{\"balance\":\"0x1158e460913d00000\"},\"a98f109835f5eacd0543647c34a6b269e3802fac\":{\"balance\":\"0x15af1d78b58c400000\"},\"a997dfc7986a27050848fa1c64d7a7d6e07acca2\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"a99991cebd98d9c838c25f7a7416d9e244ca250d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"a9a1cdc33bfd376f1c0d76fb6c84b6b4ac274d68\":{\"balance\":\"0x10f0cf064dd59200000\"},\"a9a8eca11a23d64689a2aa3e417dbb3d336bb59a\":{\"balance\":\"0xe3453cd3b67ba8000\"},\"a9acf600081bb55bb6bfbab1815ffc4e17e85a95\":{\"balance\":\"0xad78ebc5ac6200000\"},\"a9ad1926bc66bdb331588ea8193788534d982c98\":{\"balance\":\"0x65a4da25d3016c00000\"},\"a9af21acbe482f8131896a228036ba51b19453c3\":{\"balance\":\"0x2b5e021980cc18000\"},\"a9b2d2e0494eab18e07d37bbb856d80e80f84cd3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"a9ba6f413b82fcddf3affbbdd09287dcf50415ca\":{\"balance\":\"0xd8d726b7177a800000\"},\"a9be88ad1e518b0bbb024ab1d8f0e73f790e0c76\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"a9bfc410dddb20711e45c07387eab30a054e19ac\":{\"balance\":\"0x3e99601edf4e530000\"},\"a9d4a2bcbe5b9e0869d70f0fe2e1d6aacd45edc5\":{\"balance\":\"0xac6e77ab663a80000\"},\"a9d64b4f3bb7850722b58b478ba691375e224e42\":{\"balance\":\"0x14542ba12a337c00000\"},\"a9d6f871ca781a759a20ac3adb972cf12829a208\":{\"balance\":\"0x3224f42723d4540000\"},\"a9dc0424c6969d798358b393b1933a1f51bee00a\":{\"balance\":\"0x43c33c1937564800000\"},\"a9e194661aac704ee9dea043974e9692ded84a5d\":{\"balance\":\"0x1a26a51422a0700000\"},\"a9e28337e6357193d9e2cb236b01be44b81427df\":{\"balance\":\"0x77432217e683600000\"},\"a9e6e25e656b762558619f147a21985b8874edfe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"a9e9dbce7a2cb03694799897bed7c54d155fdaa8\":{\"balance\":\"0xab5ae8fc99d658000\"},\"a9ed377b7d6ec25971c1a597a3b0f3bead57c98f\":{\"balance\":\"0x15af1d78b58c400000\"},\"aa0200f1d17e9c54da0647bb96395d57a78538d8\":{\"balance\":\"0x393ef1a5127c800000\"},\"aa0ca3737337178a0caac3099c584b056c56301c\":{\"balance\":\"0x2fb474098f67c00000\"},\"aa136b47962bb8b4fb540db4ccf5fdd042ffb8cf\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"aa14422d6f0ae5a758194ed15780c838d67f1ee1\":{\"balance\":\"0x60932056c449de80000\"},\"aa16269aac9c0d803068d82fc79151dadd334b66\":{\"balance\":\"0xd8d726b7177a800000\"},\"aa167026d39ab7a85635944ed9edb2bfeba11850\":{\"balance\":\"0x1c1d5e21b4fcf680000\"},\"aa1b3768c16d821f580e76c8e4c8e86d7dc78853\":{\"balance\":\"0x15af1d78b58c400000\"},\"aa1df92e51dff70b1973e0e924c66287b494a178\":{\"balance\":\"0x1cf84a30a0a0c00000\"},\"aa2c670096d3f939305325427eb955a8a60db3c5\":{\"balance\":\"0x6c95590699232d0000\"},\"aa3135cb54f102cbefe09e96103a1a796718ff54\":{\"balance\":\"0x32222d9c331940000\"},\"aa321fdbd449180db8ddd34f0fe906ec18ee0914\":{\"balance\":\"0x252248deb6e6940000\"},\"aa3925dc220bb4ae2177b2883078b6dc346ca1b2\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"aa3f29601a1331745e05c42830a15e71938a6237\":{\"balance\":\"0x5c283d410394100000\"},\"aa47a4ffc979363232c99b99fada0f2734b0aeee\":{\"balance\":\"0x1b8489df4dbff940000\"},\"aa493d3f4fb866491cf8f800efb7e2324ed7cfe5\":{\"balance\":\"0x5c283d410394100000\"},\"aa56a65dc4abb72f11bae32b6fbb07444791d5c9\":{\"balance\":\"0x2894e975bf496c0000\"},\"aa5afcfd8309c2df9d15be5e6a504e7d706624c5\":{\"balance\":\"0x13cf422e305a1378000\"},\"aa8eb0823b07b0e6d20aadda0e95cf3835be192e\":{\"balance\":\"0x1bc16d674ec800000\"},\"aa91237e740d25a92f7fa146faa18ce56dc6e1f3\":{\"balance\":\"0x3224f42723d4540000\"},\"aa960e10c52391c54e15387cc67af827b5316dcc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aa9bd4589535db27fa2bc903ca17d679dd654806\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aaa8defe11e3613f11067fb983625a08995a8dfc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"aaaae68b321402c8ebc13468f341c63c0cf03fce\":{\"balance\":\"0x52663ccab1e1c00000\"},\"aaad1baade5af04e2b17439e935987bf8c2bb4b9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aab00abf5828d7ebf26b47ceaccdb8ba03325166\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"aabdb35c1514984a039213793f3345a168e81ff1\":{\"balance\":\"0x10cac896d239000000\"},\"aaca60d9d700e78596bbbbb1f1e2f70f4627f9d8\":{\"balance\":\"0x3635bb77cb4b860000\"},\"aaced8a9563b1bc311dbdffc1ae7f57519c4440c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aad2b7f8106695078e6c138ec81a7486aaca1eb2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"aae61e43cb0d0c96b30699f77e00d711d0a3979b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"aae732eda65988c3a00c7f472f351c463b1c968e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aaf023fef290a49bb78bb7abc95d669c50d528b0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"aaf5b207b88b0de4ac40d747cee06e172df6e745\":{\"balance\":\"0x6a7b71d7f51d0900000\"},\"aaf9ee4b886c6d1e95496fd274235bf4ecfcb07d\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"aafb7b013aa1f8541c7e327bf650adbd194c208f\":{\"balance\":\"0x499e092d01f4780000\"},\"ab098633eeee0ccefdf632f9575456f6dd80fc86\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"ab0ced762e1661fae1a92afb1408889413794825\":{\"balance\":\"0x678a932062e4180000\"},\"ab14d221e33d544629198cd096ed63dfa28d9f47\":{\"balance\":\"0x14542ba12a337c00000\"},\"ab209fdca979d0a647010af9a8b52fc7d20d8cd1\":{\"balance\":\"0x1eee2532c7c2d040000\"},\"ab27ba78c8e5e3daef31ad05aef0ff0325721e08\":{\"balance\":\"0x195ece006e02d00000\"},\"ab2871e507c7be3965498e8fb462025a1a1c4264\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"ab3861226ffec1289187fb84a08ec3ed043264e8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ab3d86bc82927e0cd421d146e07f919327cdf6f9\":{\"balance\":\"0x678a932062e4180000\"},\"ab3e62e77a8b225e411592b1af300752fe412463\":{\"balance\":\"0x215f835bc769da80000\"},\"ab3e78294ba886a0cfd5d3487fb3a3078d338d6e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ab4004c0403f7eabb0ea586f212156c4203d67f1\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"ab416fe30d58afe5d9454c7fce7f830bcc750356\":{\"balance\":\"0x6353701c605db8000\"},\"ab4572fbb1d72b575d69ec6ad17333873e8552fc\":{\"balance\":\"0x6c6ac54cda68470000\"},\"ab5a79016176320973e8cd38f6375530022531c0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ab5dfc1ea21adc42cf8c3f6e361e243fd0da61e5\":{\"balance\":\"0x1043561a8829300000\"},\"ab6b65eab8dfc917ec0251b9db0ecfa0fa032849\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ab7091932e4bc39dbb552380ca934fd7166d1e6e\":{\"balance\":\"0xb50fcfafebecb00000\"},\"ab7416ff32254951cbbc624ec7fb45fc7ecaa872\":{\"balance\":\"0x126e72a69a50d00000\"},\"ab7c42c5e52d641a07ad75099c62928b7f86622f\":{\"balance\":\"0x12361aa21d14ba0000\"},\"ab7d54c7c6570efca5b4b8ce70f52a5773e5d53b\":{\"balance\":\"0xf283abe9d9f380000\"},\"ab7e0b83ed9a424c6d1e6a6f87a4dbf06409c7d6\":{\"balance\":\"0x821ab0d44149800000\"},\"ab84a0f147ad265400002b85029a41fc9ce57f85\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ab93b26ece0a0aa21365afed1fa9aea31cd54468\":{\"balance\":\"0x572b7b98736c200000\"},\"ab948a4ae3795cbca13126e19253bdc21d3a8514\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ab9ad36e5c74ce2e96399f57839431d0e79f96ab\":{\"balance\":\"0x8e3f50b173c100000\"},\"abb2e6a72a40ba6ed908cdbcec3c5612583132fe\":{\"balance\":\"0x4f2591f896a6500000\"},\"abc068b4979b0ea64a62d3b7aa897d73810dc533\":{\"balance\":\"0x6acb3df27e1f880000\"},\"abc45f84db7382dde54c5f7d8938c42f4f3a3bc4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"abc4caeb474d4627cb6eb456ecba0ecd08ed8ae1\":{\"balance\":\"0xd5967be4fc3f100000\"},\"abc74706964960dfe0dca3dca79e9216056f1cf4\":{\"balance\":\"0x878678326eac9000000\"},\"abc9a99e8a2148a55a6d82bd51b98eb5391fdbaf\":{\"balance\":\"0x14542ba12a337c00000\"},\"abcdbc8f1dd13af578d4a4774a62182bedf9f9be\":{\"balance\":\"0x1fcc27bc459d20000\"},\"abd154903513b8da4f019f68284b0656a1d0169b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"abd21eff954fc6a7de26912a7cbb303a6607804e\":{\"balance\":\"0x523c9aa696eb940000\"},\"abd4d6c1666358c0406fdf3af248f78ece830104\":{\"balance\":\"0x727de34a24f9000000\"},\"abd9605b3e91acfd777830d16463478ae0fc7720\":{\"balance\":\"0x73f75d1a085ba0000\"},\"abdc9f1bcf4d19ee96591030e772c334302f7d83\":{\"balance\":\"0x87e5e11a81cb5f80000\"},\"abde147b2af789eaa586547e66c4fa2664d328a4\":{\"balance\":\"0xd6b6081f34c128000\"},\"abe07ced6ac5ddf991eff6c3da226a741bd243fe\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"abf12fa19e82f76c718f01bdca0003674523ef30\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"abf728cf9312f22128024e7046c251f5dc5901ed\":{\"balance\":\"0x641e8a13563d8f80000\"},\"abf8ffe0708a99b528cc1ed4e9ce4b0d0630be8c\":{\"balance\":\"0x7ab5c2aeeee6380000\"},\"abfcf5f25091ce57875fc674dcf104e2a73dd2f2\":{\"balance\":\"0x11164759ffb320000\"},\"abfe936425dcc7b74b955082bbaaf2a11d78bc05\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"ac024f594f9558f04943618eb0e6b2ee501dc272\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ac122a03cd058c122e5fe17b872f4877f9df9572\":{\"balance\":\"0x6ac5c62d9486070000\"},\"ac142eda1157b9a9a64390df7e6ae694fac98905\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ac1dfc984b71a19929a81d81f04a7cbb14073703\":{\"balance\":\"0x2086ac351052600000\"},\"ac21c1e5a3d7e0b50681679dd6c792dbca87decb\":{\"balance\":\"0x152d02c7e14af6800000\"},\"ac2889b5966f0c7f9edb42895cb69d1c04f923a2\":{\"balance\":\"0x10f0cf064dd59200000\"},\"ac28b5edea05b76f8c5f97084541277c96696a4c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ac2c8e09d06493a63858437bd20be01962450365\":{\"balance\":\"0x678a932062e4180000\"},\"ac2e766dac3f648f637ac6713fddb068e4a4f04d\":{\"balance\":\"0xaadec983fcff40000\"},\"ac3900298dd14d7cc96d4abb428da1bae213ffed\":{\"balance\":\"0x53ca12974851c010000\"},\"ac3da526cfce88297302f34c49ca520dc271f9b2\":{\"balance\":\"0x2b5e3af16b18800000\"},\"ac4460a76e6db2b9fcd152d9c7718d9ac6ed8c6f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ac4acfc36ed6094a27e118ecc911cd473e8fb91f\":{\"balance\":\"0x61913e14403c0c0000\"},\"ac4cc256ae74d624ace80db078b2207f57198f6b\":{\"balance\":\"0x6c7974123f64a40000\"},\"ac4ee9d502e7d2d2e99e59d8ca7d5f00c94b4dd6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ac52b77e15664814f39e4f271be641308d91d6cc\":{\"balance\":\"0xbed1d0263d9f00000\"},\"ac5999a89d2dd286d5a80c6dee7e86aad40f9e12\":{\"balance\":\"0xd255d112e103a00000\"},\"ac5f627231480d0d95302e6d89fc32cb1d4fe7e3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ac608e2bac9dd20728d2947effbbbf900a9ce94b\":{\"balance\":\"0x1454b0db37568fc0000\"},\"ac6d02e9a46b379fac4ac9b1d7b5d47bc850ce16\":{\"balance\":\"0x5f68e8131ecf800000\"},\"ac6f68e837cf1961cb14ab47446da168a16dde89\":{\"balance\":\"0x487a9a304539440000\"},\"ac77bdf00fd5985b5db12bbef800380abc2a0677\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ac7e03702723cb16ee27e22dd0b815dc2d5cae9f\":{\"balance\":\"0x3635c9adc5dea000000\"},\"ac8b509aefea1dbfaf2bb33500d6570b6fd96d51\":{\"balance\":\"0x62a992e53a0af00000\"},\"ac8e87ddda5e78fcbcb9fa7fc3ce038f9f7d2e34\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ac9fff68c61b011efbecf038ed72db97bb9e7281\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"aca1e6bc64cc3180f620e94dc5b1bcfd8158e45d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aca2a838330b17302da731d30db48a04f0f207c1\":{\"balance\":\"0x487a9a304539440000\"},\"acaaddcbf286cb0e215dda55598f7ff0f4ada5c6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"acb94338554bc488cc88ae2d9d94080d6bdf8410\":{\"balance\":\"0x3635c9adc5dea00000\"},\"acbc2d19e06c3babbb5b6f052b6bf7fc37e07229\":{\"balance\":\"0xad78ebc5ac6200000\"},\"acbd185589f7a68a67aa4b1bd65077f8c64e4e21\":{\"balance\":\"0xad78ebc5ac6200000\"},\"acc062702c59615d3444ef6214b8862b009a02ed\":{\"balance\":\"0x514fcb24ff9c500000\"},\"acc0909fda2ea6b7b7a88db7a0aac868091ddbf6\":{\"balance\":\"0x133765f1e26c78000\"},\"acc1c78786ab4d2b3b277135b5ba123e0400486b\":{\"balance\":\"0x44591d67fecc80000\"},\"acc46a2a555c74ded4a2bd094e821b97843b40c0\":{\"balance\":\"0x692ae8897081d00000\"},\"acc59f3b30ceffc56461cc5b8df48902240e0e7b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"acce01e0a70610dc70bb91e9926fa9957f372fba\":{\"balance\":\"0x1d1c5f3eda20c40000\"},\"acd8dd91f714764c45677c63d852e56eb9eece2e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ace2abb63b0604409fbde3e716d2876d44e8e5dd\":{\"balance\":\"0x83d6c7aab63600000\"},\"acec91ef6941cf630ba9a3e787a012f4a2d91dd4\":{\"balance\":\"0x10f0cf064dd592000000\"},\"ad0a4ae478e9636e88c604f242cf5439c6d45639\":{\"balance\":\"0xbed1d0263d9f000000\"},\"ad1799aad7602b4540cd832f9db5f11150f1687a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ad1d68a038fd2586067ef6d135d9628e79c2c924\":{\"balance\":\"0xfe09a5279e2abc0000\"},\"ad2a5c00f923aaf21ab9f3fb066efa0a03de2fb2\":{\"balance\":\"0x3635bb77cb4b860000\"},\"ad3565d52b688added08168b2d3872d17d0a26ae\":{\"balance\":\"0x56bc75e2d63100000\"},\"ad377cd25eb53e83ae091a0a1d2b4516f484afde\":{\"balance\":\"0x692ae8897081d00000\"},\"ad414d29cb7ee973fec54e22a388491786cf5402\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"ad44357e017e244f476931c7b8189efee80a5d0a\":{\"balance\":\"0x1043561a8829300000\"},\"ad57aa9d00d10c439b35efcc0becac2e3955c313\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ad59a78eb9a74a7fbdaefafa82eada8475f07f95\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ad5a8d3c6478b69f657db3837a2575ef8e1df931\":{\"balance\":\"0x20156e104c1b30000\"},\"ad660dec825522a9f62fcec3c5b731980dc286ea\":{\"balance\":\"0xa2a15d09519be00000\"},\"ad6628352ed3390bafa86d923e56014cfcb360f4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ad728121873f0456d0518b80ab6580a203706595\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ad732c976593eec4783b4e2ecd793979780bfedb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ad7dd053859edff1cb6f9d2acbed6dd5e332426f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ad80d865b85c34d2e6494b2e7aefea6b9af184db\":{\"balance\":\"0xd8d726b7177a800000\"},\"ad8bfef8c68a4816b3916f35cb7bfcd7d3040976\":{\"balance\":\"0x878678326eac9000000\"},\"ad8e48a377695de014363a523a28b1a40c78f208\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ad910a23d6850613654af786337ad2a70868ac6d\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"ad927e03d1599a78ca2bf0cad2a183dceb71eac0\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ad92ca066edb7c711dfc5b166192d1edf8e77185\":{\"balance\":\"0x79f905c6fd34e800000\"},\"ad94235fc3b3f47a2413af31e884914908ef0c45\":{\"balance\":\"0x1b1b0142d815840000\"},\"ad9e97a0482f353a05c0f792b977b6c7e811fa5f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ad9f4c890a3b511cee51dfe6cfd7f1093b76412c\":{\"balance\":\"0x1b767cbfeb0ce40000\"},\"adaa0e548c035affed64ca678a963fabe9a26bfd\":{\"balance\":\"0x3cb71f51fc5580000\"},\"adb948b1b6fefe207de65e9bbc2de98e605d0b57\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"adc19ec835afe3e58d87dc93a8a9213c90451326\":{\"balance\":\"0x6adbe5342282000000\"},\"adc8228ef928e18b2a807d00fb3c6c79cd1d9e96\":{\"balance\":\"0x13c69df334ee80000\"},\"addb26317227f45c87a2cb90dc4cfd02fb23caf8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ade6f8163bf7c7bb4abe8e9893bd0cc112fe8872\":{\"balance\":\"0x11c25d004d01f80000\"},\"adeb204aa0c38e179e81a94ed8b3e7d53047c26b\":{\"balance\":\"0x20f5b1eaad8d800000\"},\"adeb52b604e5f77faaac88275b8d6b49e9f9f97f\":{\"balance\":\"0x71426b00956ed20000\"},\"adf1acfe99bc8c14b304c8d905ba27657b8a7bc4\":{\"balance\":\"0x43c33c1937564800000\"},\"adf85203c8376a5fde9815384a350c3879c4cb93\":{\"balance\":\"0x3e31fc675815aa0000\"},\"adff0d1d0b97471e76d789d2e49c8a74f9bd54ff\":{\"balance\":\"0x65ea3db75546600000\"},\"ae062c448618643075de7a0030342dced63dbad7\":{\"balance\":\"0x2cc6cd8cc282b30000\"},\"ae10e27a014f0d306baf266d4897c89aeee2e974\":{\"balance\":\"0x43c33c1937564800000\"},\"ae126b382cf257fad7f0bc7d16297e54cc7267da\":{\"balance\":\"0x1043561a8829300000\"},\"ae13a08511110f32e53be4127845c843a1a57c7b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ae179a460db66326743d24e67523a57b246daf7f\":{\"balance\":\"0x10007ae7ce5bbe40000\"},\"ae222865799079aaf4f0674a0cdaab02a6d570ff\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ae239acffd4ebe2e1ba5b4170572dc79cc6533ec\":{\"balance\":\"0x28a857425466f800000\"},\"ae2f9c19ac76136594432393b0471d08902164d3\":{\"balance\":\"0x25df05c6a897e40000\"},\"ae34861d342253194ffc6652dfde51ab44cad3fe\":{\"balance\":\"0x194608686316bd8000\"},\"ae36f7452121913e800e0fcd1a65a5471c23846f\":{\"balance\":\"0x8e3f50b173c100000\"},\"ae3f98a443efe00f3e711d525d9894dc9a61157b\":{\"balance\":\"0x1004e2e45fb7ee0000\"},\"ae47e2609cfafe369d66d415d939de05081a9872\":{\"balance\":\"0x5baecf025f9b6500000\"},\"ae4f122e35c0b1d1e4069291457c83c07f965fa3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ae5055814cb8be0c117bb8b1c8d2b63b4698b728\":{\"balance\":\"0x1bc932ec573a38000\"},\"ae538c73c5b38d8d584d7ebdadefb15cabe48357\":{\"balance\":\"0x3627e8f712373c0000\"},\"ae57cc129a96a89981dac60d2ffb877d5dc5e432\":{\"balance\":\"0x3c3a2394b396550000\"},\"ae5aa1e6c2b60f6fd3efe721bb4a719cbe3d6f5d\":{\"balance\":\"0x2b24c6b55a5e620000\"},\"ae5c9bdad3c5c8a1220444aea5c229c1839f1d64\":{\"balance\":\"0x19e2a4c818b9060000\"},\"ae5ce3355a7ba9b332760c0950c2bc45a85fa9a0\":{\"balance\":\"0x15af1d78b58c400000\"},\"ae5d221afcd3d29355f508eadfca408ce33ca903\":{\"balance\":\"0x152d02c7e14af6800000\"},\"ae635bf73831119d2d29c0d04ff8f8d8d0a57a46\":{\"balance\":\"0x487a9a304539440000\"},\"ae648155a658370f929be384f7e001047e49dd46\":{\"balance\":\"0x2df24ae32be20440000\"},\"ae6f0c73fdd77c489727512174d9b50296611c4c\":{\"balance\":\"0x14542ba12a337c00000\"},\"ae70e69d2c4a0af818807b1a2705f79fd0b5dbc4\":{\"balance\":\"0x35659ef93f0fc40000\"},\"ae7739124ed153052503fc101410d1ffd8cd13b7\":{\"balance\":\"0x3634fb9f1489a70000\"},\"ae78bb849139a6ba38ae92a09a69601cc4cb62d1\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ae842210f44d14c4a4db91fc9d3b3b50014f7bf7\":{\"balance\":\"0xd8d726b7177a800000\"},\"ae842e81858ecfedf6506c686dc204ac15bf8b24\":{\"balance\":\"0x22b1c8c1227a00000\"},\"ae8954f8d6166de507cf61297d0fc7ca6b9e7128\":{\"balance\":\"0x1043561a8829300000\"},\"ae9ecd6bdd952ef497c0050ae0ab8a82a91898ce\":{\"balance\":\"0x1a055690d9db80000\"},\"ae9f5c3fbbe0c9bcbf1af8ff74ea280b3a5d8b08\":{\"balance\":\"0x5dc892aa1131c80000\"},\"aead88d689416b1c91f2364421375b7d3c70fb2e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aeadfcd0978edad74a32bd01a0a51d37f246e661\":{\"balance\":\"0xe18398e7601900000\"},\"aeb916ebf49d0f86c13f7331cef19e129937512d\":{\"balance\":\"0x2085655b8d1b0a0000\"},\"aebd4f205de799b64b3564b256d42a711d37ef99\":{\"balance\":\"0x3fcf8b4574f84e0000\"},\"aec27ce2133e82d052520afb5c576d9f7eb93ed2\":{\"balance\":\"0xdd04120ba09cfe60000\"},\"aec27ff5d7f9ddda91183f46f9d52543b6cd2b2f\":{\"balance\":\"0x18650127cc3dc80000\"},\"aee49d68adedb081fd43705a5f78c778fb90de48\":{\"balance\":\"0x1158e460913d00000\"},\"aef5b12258a18dec07d5ec2e316574919d79d6d6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"aefcfe88c826ccf131d54eb4ea9eb80e61e1ee25\":{\"balance\":\"0x126e72a69a50d00000\"},\"af06f5fa6d1214ec43967d1bd4dde74ab814a938\":{\"balance\":\"0x4c53ecdc18a600000\"},\"af1148ef6c8e103d7530efc91679c9ac27000993\":{\"balance\":\"0xad78ebc5ac6200000\"},\"af203e229d7e6d419df4378ea98715515f631485\":{\"balance\":\"0x6acb3df27e1f880000\"},\"af2058c7282cf67c8c3cf930133c89617ce75d29\":{\"balance\":\"0x177224aa844c7200000\"},\"af26f7c6bf453e2078f08953e4b28004a2c1e209\":{\"balance\":\"0x56bc75e2d63100000\"},\"af3087e62e04bf900d5a54dc3e946274da92423b\":{\"balance\":\"0x1158e460913d00000\"},\"af3614dcb68a36e45a4e911e62796247222d595b\":{\"balance\":\"0x7a81065f1103bc0000\"},\"af3615c789d0b1152ad4db25fe5dcf222804cf62\":{\"balance\":\"0x3635c9adc5dea00000\"},\"af3cb5965933e7dad883693b9c3e15beb68a4873\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"af4493e8521ca89d95f5267c1ab63f9f45411e1b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"af4cf41785161f571d0ca69c94f8021f41294eca\":{\"balance\":\"0x215f835bc769da80000\"},\"af529bdb459cc185bee5a1c58bf7e8cce25c150d\":{\"balance\":\"0xaadec983fcff40000\"},\"af67fd3e127fd9dc36eb3fcd6a80c7be4f7532b2\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"af771039345a343001bc0f8a5923b126b60d509c\":{\"balance\":\"0x35659ef93f0fc40000\"},\"af7f79cb415a1fb8dbbd094607ee8d41fb7c5a3b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"af87d2371ef378957fbd05ba2f1d66931b01e2b8\":{\"balance\":\"0x25f273933db5700000\"},\"af880fc7567d5595cacce15c3fc14c8742c26c9e\":{\"balance\":\"0x73f75d1a085ba0000\"},\"af8e1dcb314c950d3687434d309858e1a8739cd4\":{\"balance\":\"0xe7eeba3410b740000\"},\"af992dd669c0883e5515d3f3112a13f617a4c367\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"afa1d5ad38fed44759c05b8993c1aa0dace19f40\":{\"balance\":\"0x4563918244f400000\"},\"afa539586e4719174a3b46b9b3e663a7d1b5b987\":{\"balance\":\"0x10f0cf064dd59200000\"},\"afa6946effd5ff53154f82010253df47ae280ccc\":{\"balance\":\"0x6acb3df27e1f880000\"},\"afc8ebe8988bd4105acc4c018e546a1e8f9c7888\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"afcc7dbb8356d842d43ae7e23c8422b022a30803\":{\"balance\":\"0x66ffcbfd5e5a3000000\"},\"afd019ff36a09155346b69974815a1c912c90aa4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"afdac5c1cb56e245bf70330066a817eaafac4cd1\":{\"balance\":\"0x1158e460913d00000\"},\"afdd1b786162b8317e20f0e979f4b2ce486d765d\":{\"balance\":\"0x1158e460913d00000\"},\"aff1045adf27a1aa329461b24de1bae9948a698b\":{\"balance\":\"0x1cf84a30a0a0c0000\"},\"aff107960b7ec34ed690b665024d60838c190f70\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"aff11ccf699304d5f5862af86083451c26e79ae5\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"aff161740a6d909fe99c59a9b77945c91cc91448\":{\"balance\":\"0x340aad21b3b700000\"},\"affc99d5ebb4a84fe7788d97dce274b038240438\":{\"balance\":\"0x10f0cf064dd59200000\"},\"affea0473722cb7f0e0e86b9e11883bf428d8d54\":{\"balance\":\"0x692ae8897081d00000\"},\"b00996b0566ecb3e7243b8227988dcb352c21899\":{\"balance\":\"0x28a857425466f800000\"},\"b01e389b28a31d8e4995bdd7d7c81beeab1e4119\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b02d062873334545cea29218e4057760590f7423\":{\"balance\":\"0xacb6a1c7d93a880000\"},\"b02fa29387ec12e37f6922ac4ce98c5b09e0b00f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b036916bdacf94b69e5a8a65602975eb026104dd\":{\"balance\":\"0x1158e460913d00000\"},\"b041310fe9eed6864cedd4bee58df88eb4ed3cac\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"b055af4cadfcfdb425cf65ba6431078f07ecd5ab\":{\"balance\":\"0x56bc75e2d63100000\"},\"b0571153db1c4ed7acaefe13ecdfdb72e7e4f06a\":{\"balance\":\"0x110cff796ac195200000\"},\"b06eab09a610c6a53d56a946b2c43487ac1d5b2d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b07249e055044a9155359a402937bbd954fe48b6\":{\"balance\":\"0x56bc75e2d63100000\"},\"b07618328a901307a1b7a0d058fcd5786e9e72fe\":{\"balance\":\"0x667495d4a4330ce0000\"},\"b079bb4d9866143a6da72ae7ac0022062981315c\":{\"balance\":\"0x29331e6558f0e00000\"},\"b07bcc085ab3f729f24400416837b69936ba8873\":{\"balance\":\"0x6c6d84bccdd9ce0000\"},\"b07bcf1cc5d4462e5124c965ecf0d70dc27aca75\":{\"balance\":\"0x56bc75e2d631000000\"},\"b07cb9c12405b711807543c4934465f87f98bd2d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b07fdeaff91d4460fe6cd0e8a1b0bd8d22a62e87\":{\"balance\":\"0x11d2529f3535ab00000\"},\"b09fe6d4349b99bc37938054022d54fca366f7af\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"b0aa00950c0e81fa3210173e729aaf163a27cd71\":{\"balance\":\"0x878678326eac9000000\"},\"b0ac4eff6680ee14169cdadbffdb30804f6d25f5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b0b36af9aeeedf97b6b02280f114f13984ea3260\":{\"balance\":\"0x35659ef93f0fc40000\"},\"b0b779b94bfa3c2e1f587bcc9c7e21789222378f\":{\"balance\":\"0x54069233bf7f780000\"},\"b0baeb30e313776c4c6d247402ba4167afcda1cc\":{\"balance\":\"0x6acb3df27e1f880000\"},\"b0bb29a861ea1d424d45acd4bfc492fb8ed809b7\":{\"balance\":\"0x4563918244f400000\"},\"b0c1b177a220e41f7c74d07cde8569c21c75c2f9\":{\"balance\":\"0x12f939c99edab800000\"},\"b0c7ce4c0dc3c2bbb99cc1857b8a455f611711ce\":{\"balance\":\"0xd8d726b7177a800000\"},\"b0cef8e8fb8984a6019f01c679f272bbe68f5c77\":{\"balance\":\"0x83d6c7aab63600000\"},\"b0d32bd7e4e695b7b01aa3d0416f80557dba9903\":{\"balance\":\"0x3739ff0f6e613300000\"},\"b0d3c9872b85056ea0c0e6d1ecf7a77e3ce6ab85\":{\"balance\":\"0x10f08eda8e555098000\"},\"b0e469c886593815b3495638595daef0665fae62\":{\"balance\":\"0x692ae8897081d00000\"},\"b0e760bb07c081777345e0578e8bc898226d4e3b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b1043004ec1941a8cf4f2b00b15700ddac6ff17e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b105dd3d987cffd813e9c8500a80a1ad257d56c6\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"b10fd2a647102f881f74c9fbc37da632949f2375\":{\"balance\":\"0x22b1c8c1227a00000\"},\"b115ee3ab7641e1aa6d000e41bfc1ec7210c2f32\":{\"balance\":\"0x2c0bb3dd30c4e200000\"},\"b1178ad47383c31c8134a1941cbcd474d06244e2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b1179589e19db9d41557bbec1cb24ccc2dec1c7f\":{\"balance\":\"0x152d02c7e14af6800000\"},\"b119e79aa9b916526581cbf521ef474ae84dcff4\":{\"balance\":\"0x4fba1001e5befe0000\"},\"b11fa7fb270abcdf5a2eab95aa30c4b53636efbf\":{\"balance\":\"0x2b5e3af16b18800000\"},\"b124bcb6ffa430fcae2e86b45f27e3f21e81ee08\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b129a5cb7105fe810bd895dc7206a991a4545488\":{\"balance\":\"0x1a055690d9db80000\"},\"b12ed07b8a38ad5506363fc07a0b6d799936bdaf\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"b134c004391ab4992878337a51ec242f42285742\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b13f93af30e8d7667381b2b95bc1a699d5e3e129\":{\"balance\":\"0x16c4abbebea0100000\"},\"b1459285863ea2db3759e546ceb3fb3761f5909c\":{\"balance\":\"0x3cd72a894087e08000\"},\"b146a0b925553cf06fcaf54a1b4dfea621290757\":{\"balance\":\"0x6c6e59e67c78540000\"},\"b14a7aaa8f49f2fb9a8102d6bbe4c48ae7c06fb2\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b14bbeff70720975dc6191b2a44ff49f2672873c\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"b14cc8de33d6338236539a489020ce4655a32bc6\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b14ddb0386fb606398b8cc47565afae00ff1d66a\":{\"balance\":\"0xa12aff083e66f00000\"},\"b153f828dd076d4a7c1c2574bb2dee1a44a318a8\":{\"balance\":\"0x15af1d78b58c400000\"},\"b1540e94cff3465cc3d187e7c8e3bdaf984659e2\":{\"balance\":\"0xa215e44390e3330000\"},\"b158db43fa62d30e65f3d09bf781c7b67372ebaa\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"b161725fdcedd17952d57b23ef285b7e4b1169e8\":{\"balance\":\"0x2b6dfed3664958000\"},\"b16479ba8e7df8f63e1b95d149cd8529d735c2da\":{\"balance\":\"0x2de33a6aac32548000\"},\"b166e37d2e501ae73c84142b5ffb5aa655dd5a99\":{\"balance\":\"0x6c5db2a4d815dc0000\"},\"b183ebee4fcb42c220e47774f59d6c54d5e32ab1\":{\"balance\":\"0x56f7a9c33c04d10000\"},\"b188078444027e386798a8ae68698919d5cc230d\":{\"balance\":\"0xe7eeba3410b740000\"},\"b1896a37e5d8825a2d01765ae5de629977de8352\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b18e67a5050a1dc9fb190919a33da838ef445014\":{\"balance\":\"0x1158e460913d00000\"},\"b1a2b43a7433dd150bb82227ed519cd6b142d382\":{\"balance\":\"0x946d620d744b880000\"},\"b1c0d08b36e184f9952a4037e3e53a667d070a4e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b1c328fb98f2f19ab6646f0a7c8c566fda5a8540\":{\"balance\":\"0x878678326eac900000\"},\"b1c751786939bba0d671a677a158c6abe7265e46\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"b1cd4bdfd104489a026ec99d597307a04279f173\":{\"balance\":\"0x43c33c1937564800000\"},\"b1cf94f8091505055f010ab4bac696e0ca0f67a1\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"b1d6b01b94d854fe8b374aa65e895cf22aa2560e\":{\"balance\":\"0x32f51edbaaa3300000\"},\"b1dba5250ba9625755246e067967f2ad2f0791de\":{\"balance\":\"0x10f0cf064dd592000000\"},\"b1e2dd95e39ae9775c55aeb13f12c2fa233053ba\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b1e6e810c24ab0488de9e01e574837829f7c77d0\":{\"balance\":\"0x15af1d78b58c400000\"},\"b1e9c5f1d21e61757a6b2ee75913fc5a1a4101c3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b203d29e6c56b92699c4b92d1f6f84648dc4cfbc\":{\"balance\":\"0x15af1d78b58c400000\"},\"b216dc59e27c3d7279f5cd5bb2becfb2606e14d9\":{\"balance\":\"0x15af1d78b58c400000\"},\"b21b7979bf7c5ca01fa82dd640b41c39e6c6bc75\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"b223bf1fbf80485ca2b5567d98db7bc3534dd669\":{\"balance\":\"0xd8d726b7177a800000\"},\"b22d5055d9623135961e6abd273c90deea16a3e7\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"b22dadd7e1e05232a93237baed98e0df92b1869e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b234035f7544463ce1e22bc553064684c513cd51\":{\"balance\":\"0xd89fa3dc48dcf0000\"},\"b247cf9c72ec482af3eaa759658f793d670a570c\":{\"balance\":\"0x31708ae00454400000\"},\"b2676841ee9f2d31c172e82303b0fe9bbf9f1e09\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b279c7d355c2880392aad1aa21ee867c3b3507df\":{\"balance\":\"0x445be3f2ef87940000\"},\"b27c1a24204c1e118d75149dd109311e07c073ab\":{\"balance\":\"0xa80d24677efef00000\"},\"b28181a458a440f1c6bb1de8400281a3148f4c35\":{\"balance\":\"0x14620c57dddae00000\"},\"b28245037cb192f75785cb86cbfe7c930da258b0\":{\"balance\":\"0x3635c9adc5dea000000\"},\"b287f7f8d8c3872c1b586bcd7d0aedbf7e732732\":{\"balance\":\"0x1158e460913d00000\"},\"b28bb39f3466517cd46f979cf59653ee7d8f152e\":{\"balance\":\"0x18650127cc3dc80000\"},\"b28dbfc6499894f73a71faa00abe0f4bc9d19f2a\":{\"balance\":\"0x56bc75e2d63100000\"},\"b2968f7d35f208871631c6687b3f3daeabc6616c\":{\"balance\":\"0x875c47f289f760000\"},\"b29f5b7c1930d9f97a115e067066f0b54db44b3b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b2a144b1ea67b9510f2267f9da39d3f93de26642\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b2a2c2111612fb8bbb8e7dd9378d67f1a384f050\":{\"balance\":\"0x1158e460913d00000\"},\"b2a498f03bd7178bd8a789a00f5237af79a3e3f8\":{\"balance\":\"0x41bad155e6512200000\"},\"b2aa2f1f8e93e79713d92cea9ffce9a40af9c82d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b2b516fdd19e7f3864b6d2cf1b252a4156f1b03b\":{\"balance\":\"0x2e983c76115fc0000\"},\"b2b7cdb4ff4b61d5b7ce0b2270bbb5269743ec04\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b2bdbedf95908476d7148a370cc693743628057f\":{\"balance\":\"0xd8d726b7177a800000\"},\"b2bfaa58b5196c5cb7f89de15f479d1838de713d\":{\"balance\":\"0x1236efcbcbb340000\"},\"b2c53efa33fe4a3a1a80205c73ec3b1dbcad0602\":{\"balance\":\"0x6801dab35918938000\"},\"b2d0360515f17daba90fcbac8205d569b915d6ac\":{\"balance\":\"0x14542ba12a337c00000\"},\"b2d1e99af91231858e7065dd1918330dc4c747d5\":{\"balance\":\"0x3894f0e6f9b9f700000\"},\"b2d9ab9664bcf6df203c346fc692fd9cbab9205e\":{\"balance\":\"0x17be78976065180000\"},\"b2ddb786d3794e270187d0451ad6c8b79e0e8745\":{\"balance\":\"0x15af1d78b58c400000\"},\"b2e085fddd1468ba07415b274e734e11237fb2a9\":{\"balance\":\"0x56bc75e2d63100000\"},\"b2e9d76bf50fc36bf7d3944b63e9ca889b699968\":{\"balance\":\"0x9032ea62b74b100000\"},\"b2f9c972c1e9737755b3ff1b3088738396395b26\":{\"balance\":\"0x43c33c1937564800000\"},\"b2fc84a3e50a50af02f94da0383ed59f71ff01d7\":{\"balance\":\"0x65a4da25d3016c00000\"},\"b3050beff9de33c80e1fa15225e28f2c413ae313\":{\"balance\":\"0x25f273933db5700000\"},\"b31196714a48dff726ea9433cd2912f1a414b3b3\":{\"balance\":\"0x914878a8c05ee00000\"},\"b3145b74506d1a8d047cdcdc55392a7b5350799a\":{\"balance\":\"0x1b6229741c0d3d5d8000\"},\"b320834836d1dbfda9e7a3184d1ad1fd4320ccc0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b323dcbf2eddc5382ee4bbbb201ca3931be8b438\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b32400fd13c5500917cb037b29fe22e7d5228f2d\":{\"balance\":\"0x878678326eac9000000\"},\"b325674c01e3f7290d5226339fbeac67d221279f\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"b32825d5f3db249ef4e85cc4f33153958976e8bc\":{\"balance\":\"0x1b2df9d219f5798000\"},\"b32af3d3e8d075344926546f2e32887bf93b16bd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b32f1c2689a5ce79f1bc970b31584f1bcf2283e7\":{\"balance\":\"0x1158e460913d00000\"},\"b33c0323fbf9c26c1d8ac44ef74391d0804696da\":{\"balance\":\"0x1158e460913d00000\"},\"b34f04b8db65bba9c26efc4ce6efc50481f3d65d\":{\"balance\":\"0x43c33c1937564800000\"},\"b3557d39b5411b84445f5f54f38f62d2714d0087\":{\"balance\":\"0x2086ac351052600000\"},\"b358e97c70b605b1d7d729dfb640b43c5eafd1e7\":{\"balance\":\"0x43c33c1937564800000\"},\"b35e8a1c0dac7e0e66dbac736a592abd44012561\":{\"balance\":\"0xcfce55aa12b30000\"},\"b3667894b7863c068ad344873fcff4b5671e0689\":{\"balance\":\"0x43c33c1937564800000\"},\"b3717731dad65132da792d876030e46ac227bb8a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b3731b046c8ac695a127fd79d0a5d5fa6ae6d12e\":{\"balance\":\"0x6c4fd1ee246e780000\"},\"b37c2b9f50637bece0ca959208aefee6463ba720\":{\"balance\":\"0x15af1d78b58c400000\"},\"b388b5dfecd2c5e4b596577c642556dbfe277855\":{\"balance\":\"0x1158e460913d00000\"},\"b38c4e537b5df930d65a74d043831d6b485bbde4\":{\"balance\":\"0x15af1d78b58c400000\"},\"b39139576194a0866195151f33f2140ad1cc86cf\":{\"balance\":\"0x152d02c7e14af6800000\"},\"b39f4c00b2630cab7db7295ef43d47d501e17fd7\":{\"balance\":\"0xd8d726b7177a800000\"},\"b3a64b1176724f5409e1414a3523661baee74b4a\":{\"balance\":\"0x16368ff4ff9c10000\"},\"b3a6bd41f9d9c3201e050b87198fbda399342210\":{\"balance\":\"0xc461e1dd1029b58000\"},\"b3a8c2cb7d358e5739941d945ba9045a023a8bbb\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b3ae54fba09d3ee1d6bdd1e957923919024c35fa\":{\"balance\":\"0x38d2cee65b22a8000\"},\"b3b7f493b44a2c8d80ec78b1cdc75a652b73b06c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b3c228731d186d2ded5b5fbe004c666c8e469b86\":{\"balance\":\"0x19274b259f6540000\"},\"b3c260609b9df4095e6c5dff398eeb5e2df49985\":{\"balance\":\"0xdc55fdb17647b0000\"},\"b3c65b845aba6cd816fbaae983e0e46c82aa8622\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b3c94811e7175b148b281c1a845bfc9bb6fbc115\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b3e20eb4de18bd060221689894bee5aeb25351ee\":{\"balance\":\"0x3fc80cce516598000\"},\"b3e3c439069880156600c2892e448d4136c92d9b\":{\"balance\":\"0x2e141ea081ca080000\"},\"b3f82a87e59a39d0d2808f0751eb72c2329cdcc5\":{\"balance\":\"0x10f0cf064dd59200000\"},\"b3fc1d6881abfcb8becc0bb021b8b73b7233dd91\":{\"balance\":\"0x2b5e3af16b1880000\"},\"b40594c4f3664ef849cca6227b8a25aa690925ee\":{\"balance\":\"0xd8d726b7177a800000\"},\"b41eaf5d51a5ba1ba39bb418dbb54fab750efb1f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b424d68d9d0d00cec1938c854e15ffb880ba0170\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b4256273962bf631d014555cc1da0dcc31616b49\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b43067fe70d9b55973ba58dc64dd7f311e554259\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b43657a50eecbc3077e005d8f8d94f377876bad4\":{\"balance\":\"0x1ec1b3a1ff75a0000\"},\"b43c27f7a0a122084b98f483922541c8836cee2c\":{\"balance\":\"0x26c29e47c4844c0000\"},\"b4413576869c08f9512ad311fe925988a52d3414\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"b44605552471a6eee4daab71ff3bb41326d473e0\":{\"balance\":\"0x2d7e3d51ba53d00000\"},\"b447571dacbb3ecbb6d1cf0b0c8f3838e52324e2\":{\"balance\":\"0x1a318667fb4058000\"},\"b44783c8e57b480793cbd69a45d90c7b4f0c48ac\":{\"balance\":\"0x1158e460913d00000\"},\"b44815a0f28e569d0e921a4ade8fb2642526497a\":{\"balance\":\"0x302379bf2ca2e0000\"},\"b4496ddb27799a222457d73979116728e8a1845b\":{\"balance\":\"0x8d819ea65fa62f8000\"},\"b4524c95a7860e21840296a616244019421c4aba\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b45cca0d36826662683cf7d0b2fdac687f02d0c4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b46440c797a556e04c7d9104660491f96bb076bf\":{\"balance\":\"0xcec76f0e71520000\"},\"b46ace865e2c50ea4698d216ab455dff5a11cd72\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b46d1182e5aacaff0d26b2fcf72f3c9ffbcdd97d\":{\"balance\":\"0xaa2a603cdd7f2c0000\"},\"b48921c9687d5510744584936e8886bdbf2df69b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b498bb0f520005b6216a4425b75aa9adc52d622b\":{\"balance\":\"0xd8d726b7177a800000\"},\"b4b11d109f608fa8edd3fea9f8c315649aeb3d11\":{\"balance\":\"0x10f0cf064dd59200000\"},\"b4b14bf45455d0ab0803358b7524a72be1a2045b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"b4b185d943ee2b58631e33dff5af6854c17993ac\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b4bf24cb83686bc469869fefb044b909716993e2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b4c20040ccd9a1a3283da4d4a2f365820843d7e2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b4c8170f7b2ab536d1d9a25bdd203ae1288dc3d5\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b4d82f2e69943f7de0f5f7743879406fac2e9cec\":{\"balance\":\"0x22b1c8c1227a00000\"},\"b4dd460cd016725a64b22ea4f8e06e06674e033e\":{\"balance\":\"0x1231bb8748547a80000\"},\"b4dd5499daeb2507fb2de12297731d4c72b16bb0\":{\"balance\":\"0x1158e460913d00000\"},\"b5046cb3dc1dedbd364514a2848e44c1de4ed147\":{\"balance\":\"0x37b7d9bb820405e0000\"},\"b508f987b2de34ae4cf193de85bff61389621f88\":{\"balance\":\"0x14542ba12a337c00000\"},\"b50955aa6e341571986608bdc891c2139f540cdf\":{\"balance\":\"0x6acb3df27e1f880000\"},\"b50c149a1906fad2786ffb135aab501737e9e56f\":{\"balance\":\"0x150894e849b3900000\"},\"b50c9f5789ae44e2dce017c714caf00c830084c2\":{\"balance\":\"0x155bd9307f9fe80000\"},\"b514882c979bb642a80dd38754d5b8c8296d9a07\":{\"balance\":\"0x33c5499031720c0000\"},\"b51ddcb4dd4e8ae6be336dd9654971d9fec86b41\":{\"balance\":\"0x16d464f83de2948000\"},\"b51e558eb5512fbcfa81f8d0bd938c79ebb5242b\":{\"balance\":\"0x26c29e47c4844c0000\"},\"b523fff9749871b35388438837f7e6e0dea9cb6b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b52dfb45de5d74e3df208332bc571c809b8dcf32\":{\"balance\":\"0x14542ba12a337c00000\"},\"b535f8db879fc67fec58824a5cbe6e5498aba692\":{\"balance\":\"0x678a932062e4180000\"},\"b537d36a70eeb8d3e5c80de815225c1158cb92c4\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"b53bcb174c2518348b818aece020364596466ba3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b5493ef173724445cf345c035d279ba759f28d51\":{\"balance\":\"0x1158e460913d00000\"},\"b553d25d6b5421e81c2ad05e0b8ba751f8f010e3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b55474ba58f0f2f40e6cbabed4ea176e011fcad6\":{\"balance\":\"0x6acb3df27e1f880000\"},\"b555d00f9190cc3677aef314acd73fdc39399259\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b557ab9439ef50d237b553f02508364a466a5c03\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b56a780028039c81caf37b6775c620e786954764\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b56ad2aec6c8c3f19e1515bbb7dd91285256b639\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b57413060af3f14eb479065f1e9d19b3757ae8cc\":{\"balance\":\"0x22b1c8c1227a00000\"},\"b57549bfbc9bdd18f736b22650e48a73601fa65c\":{\"balance\":\"0x182d7e4cfda0380000\"},\"b577b6befa054e9c040461855094b002d7f57bd7\":{\"balance\":\"0x1823f3cf621d23400000\"},\"b57b04fa23d1203fae061eac4542cb60f3a57637\":{\"balance\":\"0xa5aa85009e39c0000\"},\"b5870ce342d43343333673038b4764a46e925f3e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b587b44a2ca79e4bc1dd8bfdd43a207150f2e7e0\":{\"balance\":\"0x222c8eb3ff66400000\"},\"b589676d15a04448344230d4ff27c95edf122c49\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b58b52865ea55d8036f2fab26098b352ca837e18\":{\"balance\":\"0xfc936392801c0000\"},\"b5906b0ae9a28158e8ac550e39da086ee3157623\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b5a4679685fa14196c2e9230c8c4e33bffbc10e2\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"b5a589dd9f4071dbb6fba89b3f5d5dae7d96c163\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b5a606f4ddcbb9471ec67f658caf2b00ee73025e\":{\"balance\":\"0xea756ea92afc740000\"},\"b5ad5157dda921e6bafacd9086ae73ae1f611d3f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b5add1e7809f7d03069bfe883b0a932210be8712\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b5ba29917c78a1d9e5c5c713666c1e411d7f693a\":{\"balance\":\"0xa80d24677efef00000\"},\"b5c816a8283ca4df68a1a73d63bd80260488df08\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b5cac5ed03477d390bb267d4ebd46101fbc2c3da\":{\"balance\":\"0xaadec983fcff40000\"},\"b5cdbc4115406f52e5aa85d0fea170d2979cc7ba\":{\"balance\":\"0x487a9a304539440000\"},\"b5d9934d7b292bcf603b2880741eb760288383a0\":{\"balance\":\"0xe7c2518505060000\"},\"b5dd50a15da34968890a53b4f13fe1af081baaaa\":{\"balance\":\"0xd8d726b7177a800000\"},\"b5fa8184e43ed3e0b8ab91216461b3528d84fd09\":{\"balance\":\"0x914878a8c05ee00000\"},\"b5fb7ea2ddc1598b667a9d57dd39e85a38f35d56\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"b600429752f399c80d0734744bae0a022eca67c6\":{\"balance\":\"0x1158e460913d00000\"},\"b600feab4aa96c537504d96057223141692c193a\":{\"balance\":\"0x15af1d78b58c400000\"},\"b6047cdf932db3e4045f4976122341537ed5961e\":{\"balance\":\"0x1158e460913d00000\"},\"b615e940143eb57f875893bc98a61b3d618c1e8c\":{\"balance\":\"0x1158e460913d00000\"},\"b61c34fcacda701a5aa8702459deb0e4ae838df8\":{\"balance\":\"0x7695a92c20d6fe00000\"},\"b63064bd3355e6e07e2d377024125a33776c4afa\":{\"balance\":\"0x8375a2abcca24400000\"},\"b635a4bc71fb28fdd5d2c322983a56c284426e69\":{\"balance\":\"0x93739534d28680000\"},\"b646df98b49442746b61525c81a3b04ba3106250\":{\"balance\":\"0x6acb3df27e1f880000\"},\"b65941d44c50d24666670d364766e991c02e11c2\":{\"balance\":\"0x2086ac351052600000\"},\"b65bd780c7434115162027565223f44e5498ff8c\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"b66411e3a02dedb726fa79107dc90bc1cae64d48\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b66675142e3111a1c2ea1eb2419cfa42aaf7a234\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b66f92124b5e63035859e390628869dbdea9485e\":{\"balance\":\"0x215f835bc769da80000\"},\"b672734afcc224e2e609fc51d4f059732744c948\":{\"balance\":\"0x1004e2e45fb7ee0000\"},\"b6771b0bf3427f9ae7a93e7c2e61ee63941fdb08\":{\"balance\":\"0x3fb26692954bfc00000\"},\"b67a80f170197d96cdcc4ab6cba627b4afa6e12c\":{\"balance\":\"0x821ab0d44149800000\"},\"b68899e7610d4c93a23535bcc448945ba1666f1c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b6a82933c9eadabd981e5d6d60a6818ff806e36b\":{\"balance\":\"0x15af1d78b58c400000\"},\"b6aacb8cb30bab2ae4a2424626e6e12b02d04605\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b6b34a263f10c3d2eceb0acc559a7b2ab85ce565\":{\"balance\":\"0xd8d726b7177a800000\"},\"b6bfe1c3ef94e1846fb9e3acfe9b50c3e9069233\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"b6cd7432d5161be79768ad45de3e447a07982063\":{\"balance\":\"0xd8d726b7177a800000\"},\"b6ce4dc560fc73dc69fb7a62e388db7e72ea764f\":{\"balance\":\"0x345df169e9a3580000\"},\"b6decf82969819ba02de29b9b593f21b64eeda0f\":{\"balance\":\"0x281d901f4fdd100000\"},\"b6e6c3222b6b6f9be2875d2a89f127fb64100fe2\":{\"balance\":\"0x1b21d5323cc30200000\"},\"b6e8afd93dfa9af27f39b4df06076710bee3dfab\":{\"balance\":\"0x15af1d78b58c40000\"},\"b6f78da4f4d041b3bc14bc5ba519a5ba0c32f128\":{\"balance\":\"0x247dd32c3fe195048000\"},\"b6fb39786250081426a342c70d47ee521e5bc563\":{\"balance\":\"0x32d26d12e980b600000\"},\"b70dba9391682b4a364e77fe99256301a6c0bf1f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b71623f35107cf7431a83fb3d204b29ee0b1a7f4\":{\"balance\":\"0x11164759ffb320000\"},\"b71a13ba8e95167b80331b52d69e37054fe7a826\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b71b62f4b448c02b1201cb5e394ae627b0a560ee\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"b72220ade364d0369f2d2da783ca474d7b9b34ce\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"b7230d1d1ff2aca366963914a79df9f7c5ea2c98\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b7240af2af90b33c08ae9764103e35dce3638428\":{\"balance\":\"0x1cadd2fe9686e638000\"},\"b727a9fc82e1cffc5c175fa1485a9befa2cdbdd1\":{\"balance\":\"0x3627e8f712373c0000\"},\"b72c2a011c0df50fbb6e28b20ae1aad217886790\":{\"balance\":\"0xd8d726b7177a800000\"},\"b7382d37db0398ac72410cf9813de9f8e1ec8dad\":{\"balance\":\"0x3636c25e66ece70000\"},\"b73b4ff99eb88fd89b0b6d57a9bc338e886fa06a\":{\"balance\":\"0x1bc16d674ec800000\"},\"b73d6a77559c86cf6574242903394bacf96e3570\":{\"balance\":\"0x4f1a77ccd3ba00000\"},\"b74372dbfa181dc9242f39bf1d3731dffe2bdacf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b7479dab5022c4d5dbaaf8de171b4e951dd1a457\":{\"balance\":\"0x4563918244f400000\"},\"b749b54e04d5b19bdcedfb84da7701ab478c27ae\":{\"balance\":\"0x914878a8c05ee00000\"},\"b74ed2666001c16333cf7af59e4a3d4860363b9c\":{\"balance\":\"0xa7ebd5e4363a00000\"},\"b75149e185f6e3927057739073a1822ae1cf0df2\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"b753a75f9ed10b21643a0a3dc0517ac96b1a4068\":{\"balance\":\"0x15c8185b2c1ff40000\"},\"b756ad52f3bf74a7d24c67471e0887436936504c\":{\"balance\":\"0x43c33c1937564800000\"},\"b7576e9d314df41ec5506494293afb1bd5d3f65d\":{\"balance\":\"0x1158e460913d00000\"},\"b758896f1baa864f17ebed16d953886fee68aae6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b768b5234eba3a9968b34d6ddb481c8419b3655d\":{\"balance\":\"0xcfce55aa12b30000\"},\"b782bfd1e2de70f467646f9bc09ea5b1fcf450af\":{\"balance\":\"0xe7eeba3410b740000\"},\"b7a2c103728b7305b5ae6e961c94ee99c9fe8e2b\":{\"balance\":\"0xa968163f0a57b400000\"},\"b7a31a7c38f3db09322eae11d2272141ea229902\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b7a6791c16eb4e2162f14b6537a02b3d63bfc602\":{\"balance\":\"0x2a526391ac93760000\"},\"b7a7f77c348f92a9f1100c6bd829a8ac6d7fcf91\":{\"balance\":\"0x62a992e53a0af00000\"},\"b7c077946674ba9341fb4c747a5d50f5d2da6415\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b7c0d0cc0b4d342d4062bac624ccc3c70cc6da3f\":{\"balance\":\"0xd8d726b7177a800000\"},\"b7c9f12b038e73436d17e1c12ffe1aeccdb3f58c\":{\"balance\":\"0x1d460162f516f00000\"},\"b7cc6b1acc32d8b295df68ed9d5e60b8f64cb67b\":{\"balance\":\"0x1043561a8829300000\"},\"b7ce684b09abda53389a875369f71958aeac3bdd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b7d12e84a2e4c4a6345af1dd1da9f2504a2a996e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b7d252ee9402b0eef144295f0e69f0db586c0871\":{\"balance\":\"0x23c757072b8dd00000\"},\"b7d581fe0af1ec383f3b3c416783f385146a7612\":{\"balance\":\"0x43c33c1937564800000\"},\"b7f67314cb832e32e63b15a40ce0d7ffbdb26985\":{\"balance\":\"0x398279264a818d0000\"},\"b8040536958d5998ce4bec0cfc9c2204989848e9\":{\"balance\":\"0x52ea70d498fd50a0000\"},\"b8310a16cc6abc465007694b930f978ece1930bd\":{\"balance\":\"0x281d901f4fdd100000\"},\"b834acf3015322c58382eeb2b79638906e88b6de\":{\"balance\":\"0x5150ae84a8cdf000000\"},\"b84b53d0bb125656cddc52eb852ab71d7259f3d5\":{\"balance\":\"0x3635c9adc5dea000000\"},\"b84c8b9fd33ece00af9199f3cf5fe0cce28cd14a\":{\"balance\":\"0xcf152640c5c8300000\"},\"b85218f342f8012eda9f274e63ce2152b2dcfdab\":{\"balance\":\"0xa80d24677efef00000\"},\"b8555010776e3c5cb311a5adeefe9e92bb9a64b9\":{\"balance\":\"0xd8d726b7177a800000\"},\"b85f26dd0e72d9c29ebaf697a8af77472c2b58b5\":{\"balance\":\"0x28519acc7190c700000\"},\"b85ff03e7b5fc422981fae5e9941dacbdaba7584\":{\"balance\":\"0x487a9a304539440000\"},\"b86607021b62d340cf2652f3f95fd2dc67698bdf\":{\"balance\":\"0x10f0cf064dd59200000\"},\"b87de1bcd29269d521b8761cc39cfb4319d2ead5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"b87f5376c2de0b6cc3c179c06087aa473d6b4674\":{\"balance\":\"0x487a9a304539440000\"},\"b884add88d83dc564ab8e0e02cbdb63919aea844\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b88a37c27f78a617d5c091b7d5b73a3761e65f2a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b8947822d5ace7a6ad8326e95496221e0be6b73d\":{\"balance\":\"0x1158e460913d00000\"},\"b89c036ed7c492879921be41e10ca1698198a74c\":{\"balance\":\"0x62a992e53a0af00000\"},\"b89f4632df5909e58b2a9964f74feb9a3b01e0c5\":{\"balance\":\"0x48875bcc6e7cbeb8000\"},\"b8a79c84945e47a9c3438683d6b5842cff7684b1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b8a979352759ba09e35aa5935df175bff678a108\":{\"balance\":\"0x1158e460913d00000\"},\"b8ab39805bd821184f6cbd3d2473347b12bf175c\":{\"balance\":\"0x6685ac1bfe32c0000\"},\"b8ac117d9f0dba80901445823c4c9d4fa3fedc6e\":{\"balance\":\"0x3564c4427a8fc7d8000\"},\"b8bc9bca7f71b4ed12e620438d620f53c114342f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"b8bedd576a4b4c2027da735a5bc3f533252a1808\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b8c2703d8c3f2f44c584bc10e7c0a6b64c1c097e\":{\"balance\":\"0x12cddb8ead6f9f80000\"},\"b8cc0f060aad92d4eb8b36b3b95ce9e90eb383d7\":{\"balance\":\"0x1fc3842bd1f071c00000\"},\"b8d2ddc66f308c0158ae3ccb7b869f7d199d7b32\":{\"balance\":\"0x2dcbf4840eca000000\"},\"b8d389e624a3a7aebce4d3e5dbdf6cdc29932aed\":{\"balance\":\"0xad78ebc5ac6200000\"},\"b8d531a964bcea13829620c0ced72422dadb4cca\":{\"balance\":\"0x93715cc5ab8a70000\"},\"b8d5c324a8209d7c8049d0d4aede02ba80ab578b\":{\"balance\":\"0x393928629fff75e8000\"},\"b8f20005b61352ffa7699a1b52f01f5ab39167f1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"b8f30758faa808dbc919aa7b425ec922b93b8129\":{\"balance\":\"0x3636d7af5ec98e0000\"},\"b9013c51bd078a098fae05bf2ace0849c6be17a5\":{\"balance\":\"0x4563918244f400000\"},\"b9144b677c2dc614ceefdf50985f1183208ea64c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b916b1a01cdc4e56e7657715ea37e2a0f087d106\":{\"balance\":\"0x826e3181e027068000\"},\"b91d9e916cd40d193db60e79202778a0087716fc\":{\"balance\":\"0x15f1ba7f4716200000\"},\"b9231eb26e5f9e4b4d288f03906704fab96c87d6\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"b92427ad7578b4bfe20a9f63a7c5506d5ca12dc8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b927abd2d28aaaa24db31778d27419df8e1b04bb\":{\"balance\":\"0x17e11c2a26f478000\"},\"b94d47b3c052a5e50e4261ae06a20f45d8eee297\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b95396daaa490df2569324fcc6623be052f132ca\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b959dce02e91d9db02b1bd8b7d17a9c41a97af09\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"b95c9b10aa981cf4a67a71cc52c504dee8cf58bd\":{\"balance\":\"0xd8d726b7177a800000\"},\"b95cfda8465ba9c2661b249fc3ab661bdfa35ff0\":{\"balance\":\"0x114a4e79a2c2108000\"},\"b96841cabbc7dbd69ef0cf8f81dff3c8a5e21570\":{\"balance\":\"0x28a857425466f800000\"},\"b97a6733cd5fe99864b3b33460d1672434d5cafd\":{\"balance\":\"0x6c65bbaa46c2cf8000\"},\"b981ad5e6b7793a23fc6c1e8692eb2965d18d0da\":{\"balance\":\"0x21e18d2c821c7520000\"},\"b98ca31785ef06be49a1e47e864f60d076ca472e\":{\"balance\":\"0xd8d726b7177a800000\"},\"b9920fd0e2c735c256463caa240fb7ac86a93dfa\":{\"balance\":\"0x5f68e8131ecf800000\"},\"b992a967308c02b98af91ee760fd3b6b4824ab0e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"b9a985501ee950829b17fae1c9cf348c3156542c\":{\"balance\":\"0xff17517ca9a620000\"},\"b9b0a3219a3288d9b35b091b14650b8fe23dce2b\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"b9cf71b226583e3a921103a5316f855a65779d1b\":{\"balance\":\"0x5150ae84a8cdf000000\"},\"b9e90c1192b3d5d3e3ab0700f1bf655f5dd4347a\":{\"balance\":\"0x1b19e50b44977c0000\"},\"b9fd3833e88e7cf1fa9879bdf55af4b99cd5ce3f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ba0249e01d945bef93ee5ec61925e03c5ca509fd\":{\"balance\":\"0xd8d726b7177a800000\"},\"ba0f39023bdb29eb1862a9f9059cab5d306e662f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ba10f2764290f875434372f79dbf713801caac01\":{\"balance\":\"0x33c5499031720c0000\"},\"ba1531fb9e791896bcf3a80558a359f6e7c144bd\":{\"balance\":\"0xd5967be4fc3f100000\"},\"ba176dbe3249e345cd4fa967c0ed13b24c47e586\":{\"balance\":\"0x15aef9f1c31c7f0000\"},\"ba1f0e03cb9aa021f4dcebfa94e5c889c9c7bc9e\":{\"balance\":\"0x6d190c475169a200000\"},\"ba1fcaf223937ef89e85675503bdb7ca6a928b78\":{\"balance\":\"0x22b1c8c1227a000000\"},\"ba24fc436753a739db2c8d40e6d4d04c528e86fa\":{\"balance\":\"0x2c0bb3dd30c4e200000\"},\"ba42f9aace4c184504abf5425762aca26f71fbdc\":{\"balance\":\"0x207077dd8a79c0000\"},\"ba469aa5c386b19295d4a1b5473b540353390c85\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ba6440aeb3737b8ef0f1af9b0c15f4c214ffc7cf\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ba6d31b9a261d640b5dea51ef2162c3109f1eba8\":{\"balance\":\"0x10f0cf064dd59200000\"},\"ba70e8b4759c0c3c82cc00ac4e9a94dd5bafb2b8\":{\"balance\":\"0x3043fa33c412d70000\"},\"ba8a63f3f40de4a88388bc50212fea8e064fbb86\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ba8e46d69d2e2343d86c60d82cf42c2041a0c1c2\":{\"balance\":\"0x56bc75e2d63100000\"},\"baa4b64c2b15b79f5f204246fd70bcbd86e4a92a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"bac8922c4acc7d2cb6fd59a14eb45cf3e702214b\":{\"balance\":\"0x2b5e3af16b18800000\"},\"bad235d5085dc7b068a67c412677b03e1836884c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bad4425e171c3e72975eb46ac0a015db315a5d8f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"badc2aef9f5951a8d78a6b35c3d0b3a4e6e2e739\":{\"balance\":\"0x14542ba12a337c00000\"},\"bade43599e02f84f4c3014571c976b13a36c65ab\":{\"balance\":\"0xd8d726b7177a800000\"},\"bae9b82f7299631408659dd74e891cb8f3860fe5\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bb0366a7cfbd3445a70db7fe5ae34885754fd468\":{\"balance\":\"0x14def2c42ebd6400000\"},\"bb076aac92208069ea318a31ff8eeb14b7e996e3\":{\"balance\":\"0x813ca56906d340000\"},\"bb0857f1c911b24b86c8a70681473fe6aaa1cce2\":{\"balance\":\"0x56bc75e2d63100000\"},\"bb19bf91cbad74cceb5f811db27e411bc2ea0656\":{\"balance\":\"0xf43fc2c04ee00000\"},\"bb27c6a7f91075475ab229619040f804c8ec7a6a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"bb371c72c9f0316cea2bd9c6fbb4079e775429ef\":{\"balance\":\"0x5f68e8131ecf800000\"},\"bb3b010b18e6e2be1135871026b7ba15ea0fde24\":{\"balance\":\"0x2207c80309b77700000\"},\"bb3b9005f46fd2ca3b30162599928c77d9f6b601\":{\"balance\":\"0x1b1ae7f2b1bf7db0000\"},\"bb3fc0a29c034d710812dcc775c8cab9d28d6975\":{\"balance\":\"0x39d4e844d1cf5f0000\"},\"bb48eaf516ce2dec3e41feb4c679e4957641164f\":{\"balance\":\"0xcf152640c5c8300000\"},\"bb4b4a4b548070ff41432c9e08a0ca6fa7bc9f76\":{\"balance\":\"0x2e141ea081ca080000\"},\"bb56a404723cff20d0685488b05a02cdc35aacaa\":{\"balance\":\"0x1158e460913d00000\"},\"bb618e25221ad9a740b299ed1406bc3934b0b16d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bb61a04bffd57c10470d45c39103f64650347616\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bb6823a1bd819f13515538264a2de052b4442208\":{\"balance\":\"0x16368ff4ff9c10000\"},\"bb6c284aac8a69b75cddb00f28e145583b56bece\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bb75cb5051a0b0944b4673ca752a97037f7c8c15\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bb993b96ee925ada7d99d786573d3f89180ce3aa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bba3c68004248e489573abb2743677066b24c8a7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bba4fac3c42039d828e742cde0efffe774941b39\":{\"balance\":\"0x6c6ad382d4fb610000\"},\"bba8ab22d2fedbcfc63f684c08afdf1c175090b5\":{\"balance\":\"0x55f29f37e4e3b8000\"},\"bba976f1a1215f7512871892d45f7048acd356c8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bbab000b0408ed015a37c04747bc461ab14e151b\":{\"balance\":\"0x14542ba12a337c00000\"},\"bbabf6643beb4bd01c120bd0598a0987d82967d1\":{\"balance\":\"0xb5328178ad0f2a0000\"},\"bbb4ee1d82f2e156442cc93338a2fc286fa28864\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"bbb5a0f4802c8648009e8a6998af352cde87544f\":{\"balance\":\"0x52d542804f1ce0000\"},\"bbb643d2187b364afc10a6fd368d7d55f50d1a3c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bbb8ffe43f98de8eae184623ae5264e424d0b8d7\":{\"balance\":\"0x5d53ffde928080000\"},\"bbbd6ecbb5752891b4ceb3cce73a8f477059376f\":{\"balance\":\"0x1f399b1438a100000\"},\"bbbf39b1b67995a42241504f9703d2a14a515696\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"bbc8eaff637e94fcc58d913c7770c88f9b479277\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bbc9d8112e5beb02dd29a2257b1fe69b3536a945\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bbca65b3266ea2fb73a03f921635f912c7bede00\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bbf84292d954acd9e4072fb860b1504106e077ae\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"bbf85aaaa683738f073baef44ac9dc34c4c779ea\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bbf8616d97724af3def165d0e28cda89b800009a\":{\"balance\":\"0x62ef12e2b17618000\"},\"bbfe0a830cace87b7293993a7e9496ce64f8e394\":{\"balance\":\"0x14542ba12a337c00000\"},\"bc0ca4f217e052753614d6b019948824d0d8688b\":{\"balance\":\"0x15af1d78b58c400000\"},\"bc0e8745c3a549445c2be900f52300804ab56289\":{\"balance\":\"0x7029bf5dd4c53b28000\"},\"bc0f98598f88056a26339620923b8f1eb074a9fd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bc1609d685b76b48ec909aa099219022f89b2ccd\":{\"balance\":\"0x40138b917edfb80000\"},\"bc171e53d17ac9b61241ae436deec7af452e7496\":{\"balance\":\"0x121ea68c114e5100000\"},\"bc1b021a78fde42d9b5226d6ec26e06aa3670090\":{\"balance\":\"0x4563918244f400000\"},\"bc1e80c181616342ebb3fb3992072f1b28b802c6\":{\"balance\":\"0xd8d726b7177a800000\"},\"bc237148d30c13836ffa2cad520ee4d2e5c4eeff\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bc46d537cf2edd403565bde733b2e34b215001bd\":{\"balance\":\"0x43c33c1937564800000\"},\"bc4e471560c99c8a2a4b1b1ad0c36aa6502b7c4b\":{\"balance\":\"0x28a857425466f800000\"},\"bc62b3096a91e7dc11a1592a293dd2542150d751\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bc69a0d2a31c3dbf7a9122116901b2bdfe9802a0\":{\"balance\":\"0xa2a15d09519be00000\"},\"bc6b58364bf7f1951c309e0cba0595201cd73f9a\":{\"balance\":\"0x62401a457e45f80000\"},\"bc73f7b1ca3b773b34249ada2e2c8a9274cc17c2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bc7afc8477412274fc265df13c054473427d43c6\":{\"balance\":\"0x70c95920ce3250000\"},\"bc967fe4418c18b99858966d870678dca2b88879\":{\"balance\":\"0x1d9cbdd8d7ed2100000\"},\"bc999e385c5aebcac8d6f3f0d60d5aa725336d0d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bc9c95dfab97a574cea2aa803b5caa197cef0cff\":{\"balance\":\"0x16c4abbebea0100000\"},\"bc9e0ec6788f7df4c7fc210aacd220c27e45c910\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"bca3ffd4683fba0ad3bbc90734b611da9cfb457e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bcaed0acb6a76f113f7c613555a2c3b0f5bf34a5\":{\"balance\":\"0xa7ebd5e4363a00000\"},\"bcaf347918efb2d63dde03e39275bbe97d26df50\":{\"balance\":\"0x56bc75e2d63100000\"},\"bcb422dc4dd2aae94abae95ea45dd1731bb6b0ba\":{\"balance\":\"0x18424f5f0b1b4e0000\"},\"bcbd31252ec288f91e298cd812c92160e738331a\":{\"balance\":\"0x6b1bc2cac09a590000\"},\"bcbf6ba166e2340db052ea23d28029b0de6aa380\":{\"balance\":\"0xd255d112e103a00000\"},\"bcc84597b91e73d5c5b4d69c80ecf146860f779a\":{\"balance\":\"0xed70b5e9c3f2f00000\"},\"bcc9593b2da6df6a34d71b1aa38dacf876f95b88\":{\"balance\":\"0x1158e460913d00000\"},\"bcd95ef962462b6edfa10fda87d72242fe3edb5c\":{\"balance\":\"0x121d06e12fff988000\"},\"bcd99edc2160f210a05e3a1fa0b0434ced00439b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bcdfacb9d9023c3417182e9100e8ea1d373393a3\":{\"balance\":\"0x3342d60dff1960000\"},\"bce13e22322acfb355cd21fd0df60cf93add26c6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bce40475d345b0712dee703d87cd7657fc7f3b62\":{\"balance\":\"0x1a420db02bd7d580000\"},\"bcedc4267ccb89b31bb764d7211171008d94d44d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bcfc98e5c82b6adb180a3fcb120b9a7690c86a3f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bd043b67c63e60f841ccca15b129cdfe6590c8e3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bd047ff1e69cc6b29ad26497a9a6f27a903fc4dd\":{\"balance\":\"0x2ee449550898e40000\"},\"bd08e0cddec097db7901ea819a3d1fd9de8951a2\":{\"balance\":\"0x1158e460913d00000\"},\"bd09126c891c4a83068059fe0e15796c4661a9f4\":{\"balance\":\"0x2b5e3af16b18800000\"},\"bd0c5cd799ebc48642ef97d74e8e429064fee492\":{\"balance\":\"0x11ac28a8c729580000\"},\"bd17eed82b9a2592019a1b1b3c0fbad45c408d22\":{\"balance\":\"0xd8d726b7177a80000\"},\"bd1803370bddb129d239fd16ea8526a6188ae58e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"bd2b70fecc37640f69514fc7f3404946aad86b11\":{\"balance\":\"0x410d586a20a4c00000\"},\"bd3097a79b3c0d2ebff0e6e86ab0edadbed47096\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"bd325d4029e0d8729f6d399c478224ae9e7ae41e\":{\"balance\":\"0xd255d112e103a00000\"},\"bd432a3916249b4724293af9146e49b8280a7f2a\":{\"balance\":\"0xd8d726b7177a800000\"},\"bd47f5f76e3b930fd9485209efa0d4763da07568\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bd4b60faec740a21e3071391f96aa534f7c1f44e\":{\"balance\":\"0x9ddc1e3b901180000\"},\"bd4bd5b122d8ef7b7c8f0667450320db2116142e\":{\"balance\":\"0x2086ac351052600000\"},\"bd51ee2ea143d7b1d6b77e7e44bdd7da12f485ac\":{\"balance\":\"0x477e06ccb2b9280000\"},\"bd59094e074f8d79142ab1489f148e32151f2089\":{\"balance\":\"0x1158e460913d00000\"},\"bd5a8c94bd8be6470644f70c8f8a33a8a55c6341\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bd5e473abce8f97a6932f77c2facaf9cc0a00514\":{\"balance\":\"0x3c9258a106a6b70000\"},\"bd5f46caab2c3d4b289396bbb07f203c4da82530\":{\"balance\":\"0x4563918244f400000\"},\"bd66ffedb530ea0b2e856dd12ac2296c31fe29e0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bd67d2e2f82da8861341bc96a2c0791fddf39e40\":{\"balance\":\"0xad7c07947c8fb0000\"},\"bd6a474d66345bcdd707594adb63b30c7822af54\":{\"balance\":\"0xd8d726b7177a800000\"},\"bd723b289a7367b6ece2455ed61edb49670ab9c4\":{\"balance\":\"0x10f0cdea164213f8000\"},\"bd73c3cbc26a175062ea0320dd84b253bce64358\":{\"balance\":\"0x155bd9307f9fe80000\"},\"bd7419dc2a090a46e2873d7de6eaaad59e19c479\":{\"balance\":\"0x170bcb671759f080000\"},\"bd8765f41299c7f479923c4fd18f126d7229047d\":{\"balance\":\"0xd8d726b7177a800000\"},\"bd93e550403e2a06113ed4c3fba1a8913b19407e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bd9e56e902f4be1fc8768d8038bac63e2acbbf8e\":{\"balance\":\"0x36356633ebd8ea0000\"},\"bda4be317e7e4bed84c0495eee32d607ec38ca52\":{\"balance\":\"0x7d32277978ef4e8000\"},\"bdb60b823a1173d45a0792245fb496f1fd3301cf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bdbaf6434d40d6355b1e80e40cc4ab9c68d96116\":{\"balance\":\"0x56bc75e2d63100000\"},\"bdc02cd4330c93d6fbda4f6db2a85df22f43c233\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bdc461462b6322b462bdb33f22799e8108e2417d\":{\"balance\":\"0x243d4d18229ca20000\"},\"bdc739a699700b2e8e2c4a4c7b058a0e513ddebe\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bdc74873af922b9df474853b0fa7ff0bf8c82695\":{\"balance\":\"0xd8c9460063d31c0000\"},\"bdca2a0ff34588af625fa8e28fc3015ab5a3aa00\":{\"balance\":\"0x7ed73f773552fc0000\"},\"bdd3254e1b3a6dc6cc2c697d45711aca21d516b2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bddfa34d0ebf1b04af53b99b82494a9e3d8aa100\":{\"balance\":\"0x28a857425466f800000\"},\"bde4c73f969b89e9ceae66a2b51844480e038e9a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bde9786a84e75b48f18e726dd78d70e4af3ed802\":{\"balance\":\"0x1369fb96128ac480000\"},\"bded11612fb5c6da99d1e30e320bc0995466141e\":{\"balance\":\"0x15af1d78b58c400000\"},\"bded7e07d0711e684de65ac8b2ab57c55c1a8645\":{\"balance\":\"0x2009c5c8bf6fdc0000\"},\"bdf693f833c3fe471753184788eb4bfe4adc3f96\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bdf6e68c0cd7584080e847d72cbb23aad46aeb1d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"be0a2f385f09dbfce96732e12bb40ac349871ba8\":{\"balance\":\"0x574c115e02b8be0000\"},\"be0c2a80b9de084b172894a76cf4737a4f529e1a\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"be1cd7f4c472070968f3bde268366b21eeea8321\":{\"balance\":\"0xe91a7cd19fa3b00000\"},\"be2346a27ff9b702044f500deff2e7ffe6824541\":{\"balance\":\"0x1158e460913d00000\"},\"be2471a67f6047918772d0e36839255ed9d691ae\":{\"balance\":\"0xd8d726b7177a800000\"},\"be2b2280523768ea8ac35cd9e888d60a719300d4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"be2b326e78ed10e550fee8efa8f8070396522f5a\":{\"balance\":\"0x857e0d6f1da76a00000\"},\"be305a796e33bbf7f9aeae6512959066efda1010\":{\"balance\":\"0x24dce54d34a1a000000\"},\"be478e8e3dde6bd403bb2d1c657c4310ee192723\":{\"balance\":\"0x1ab2cf7c9f87e20000\"},\"be4e7d983f2e2a636b1102ec7039efebc842e98d\":{\"balance\":\"0x393ef1a5127c80000\"},\"be4fd073617022b67f5c13499b827f763639e4e3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"be525a33ea916177f17283fca29e8b350b7f530b\":{\"balance\":\"0x8f019aaf46e8780000\"},\"be53322f43fbb58494d7cce19dda272b2450e827\":{\"balance\":\"0xad7ceaf425c150000\"},\"be538246dd4e6f0c20bf5ad1373c3b463a131e86\":{\"balance\":\"0xad78ebc5ac6200000\"},\"be5a60689998639ad75bc105a371743eef0f7940\":{\"balance\":\"0x1b327c73e1257a0000\"},\"be5cba8d37427986e8ca2600e858bb03c359520f\":{\"balance\":\"0xa030dcebbd2f4c0000\"},\"be60037e90714a4b917e61f193d834906703b13a\":{\"balance\":\"0x5c283d410394100000\"},\"be633a3737f68439bac7c90a52142058ee8e8a6f\":{\"balance\":\"0x340aad21b3b7000000\"},\"be659d85e7c34f8833ea7f488de1fbb5d4149bef\":{\"balance\":\"0x1ebd23ad9d5bb720000\"},\"be73274d8c5aa44a3cbefc8263c37ba121b20ad3\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"be86d0b0438419ceb1a038319237ba5206d72e46\":{\"balance\":\"0x3634fb9f1489a70000\"},\"be8d7f18adfe5d6cc775394989e1930c979d007d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"be9186c34a52514abb9107860f674f97b821bd5b\":{\"balance\":\"0x1ba01ee40603100000\"},\"be935793f45b70d8045d2654d8dd3ad24b5b6137\":{\"balance\":\"0x2fb474098f67c00000\"},\"be98a77fd41097b34f59d7589baad021659ff712\":{\"balance\":\"0x30ca024f987b900000\"},\"be9b8c34b78ee947ff81472eda7af9d204bc8466\":{\"balance\":\"0x821ab0d4414980000\"},\"bea00df17067a43a82bc1daecafb6c14300e89e6\":{\"balance\":\"0x62a992e53a0af00000\"},\"bea0afc93aae2108a3fac059623bf86fa582a75e\":{\"balance\":\"0x5c283d410394100000\"},\"beb3358c50cf9f75ffc76d443c2c7f55075a0589\":{\"balance\":\"0x90f534608a72880000\"},\"beb4fd315559436045dcb99d49dcec03f40c42dc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bec2e6de39c07c2bae556acfbee2c4728b9982e3\":{\"balance\":\"0x1f0ff8f01daad40000\"},\"bec6640f4909b58cbf1e806342961d607595096c\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"bec8caf7ee49468fee552eff3ac5234eb9b17d42\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"becef61c1c442bef7ce04b73adb249a8ba047e00\":{\"balance\":\"0x363b56c3a754c80000\"},\"bed4649df646e2819229032d8868556fe1e053d3\":{\"balance\":\"0xfc936392801c0000\"},\"bed4c8f006a27c1e5f7ce205de75f516bfb9f764\":{\"balance\":\"0x3635c9adc5dea000000\"},\"bee8d0b008421954f92d000d390fb8f8e658eaee\":{\"balance\":\"0x3635c9adc5dea00000\"},\"beecd6af900c8b064afcc6073f2d85d59af11956\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"beef94213879e02622142bea61290978939a60d7\":{\"balance\":\"0x136857b32ad86048000\"},\"bef07d97c3481f9d6aee1c98f9d91a180a32442b\":{\"balance\":\"0x152d02c7e14af6800000\"},\"befb448c0c5f683fb67ee570baf0db5686599751\":{\"balance\":\"0x6acb3df27e1f880000\"},\"bf05070c2c34219311c4548b2614a438810ded6d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bf05ff5ecf0df2df887759fb8274d93238ac267d\":{\"balance\":\"0x2b5e3af16b18800000\"},\"bf09d77048e270b662330e9486b38b43cd781495\":{\"balance\":\"0x5c539b7bf4ff28800000\"},\"bf17f397f8f46f1bae45d187148c06eeb959fa4d\":{\"balance\":\"0x3649c59624bb300000\"},\"bf183641edb886ce60b8190261e14f42d93cce01\":{\"balance\":\"0x15b3557f1937f8000\"},\"bf2aea5a1dcf6ed3b5e8323944e983fedfd1acfb\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"bf4096bc547dbfc4e74809a31c039e7b389d5e17\":{\"balance\":\"0xd5967be4fc3f100000\"},\"bf49c14898316567d8b709c2e50594b366c6d38c\":{\"balance\":\"0x27bf38c6544df50000\"},\"bf4c73a7ede7b164fe072114843654e4d8781dde\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bf50ce2e264b9fe2b06830617aedf502b2351b45\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bf59aee281fa43fe97194351a9857e01a3b897b2\":{\"balance\":\"0x2086ac351052600000\"},\"bf68d28aaf1eeefef646b65e8cc8d190f6c6da9c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"bf6925c00751008440a6739a02bf2b6cdaab5e3a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bf7701fc6225d5a17815438a8941d21ebc5d059d\":{\"balance\":\"0x65ea3db75546600000\"},\"bf8b8005d636a49664f74275ef42438acd65ac91\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bf92418a0c6c31244d220260cb3e867dd7b4ef49\":{\"balance\":\"0x56900d33ca7fc0000\"},\"bf9acd4445d9c9554689cabbbab18800ff1741c2\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bf9f271f7a7e12e36dd2fe9facebf385fe6142bd\":{\"balance\":\"0x366f84f7bb7840000\"},\"bfa8c858df102cb12421008b0a31c4c7190ad560\":{\"balance\":\"0xad78ebc5ac6200000\"},\"bfaeb91067617dcf8b44172b02af615674835dba\":{\"balance\":\"0x8b59e884813088000\"},\"bfb0ea02feb61dec9e22a5070959330299c43072\":{\"balance\":\"0x43c33c1937564800000\"},\"bfbca418d3529cb393081062032a6e1183c6b2dc\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"bfbe05e88c9cbbcc0e92a405fac1d85de248ee24\":{\"balance\":\"0x56bc75e2d63100000\"},\"bfbfbcb656c2992be8fcde8219fbc54aadd59f29\":{\"balance\":\"0x21e18d2c821c7520000\"},\"bfc57aa666fae28e9f107a49cb5089a4e22151dd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bfcb9730246304700da90b4153e71141622e1c41\":{\"balance\":\"0x3635c9adc5dea00000\"},\"bfd93c90c29c07bc5fb5fc49aeea55a40e134f35\":{\"balance\":\"0x5ede20f01a459800000\"},\"bfe3a1fc6e24c8f7b3250560991f93cba2cf8047\":{\"balance\":\"0x10f0cf064dd592000000\"},\"bfe6bcb0f0c07852643324aa5df5fd6225abc3ca\":{\"balance\":\"0x409e52b48369a0000\"},\"bff5df769934b8943ca9137d0efef2fe6ebbb34e\":{\"balance\":\"0x56bc75e2d63100000\"},\"bffb6929241f788693273e7022e60e3eab1fe84f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c0064f1d9474ab915d56906c9fb320a2c7098c9b\":{\"balance\":\"0x13683f7f3c15d80000\"},\"c007f0bdb6e7009202b7af3ea90902697c721413\":{\"balance\":\"0xa2a0e43e7fb9830000\"},\"c00ab080b643e1c2bae363e0d195de2efffc1c44\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c02077449a134a7ad1ef7e4d927affeceeadb5ae\":{\"balance\":\"0xfc936392801c0000\"},\"c02471e3fc2ea0532615a7571d493289c13c36ef\":{\"balance\":\"0x1158e460913d00000\"},\"c02d6eadeacf1b78b3ca85035c637bb1ce01f490\":{\"balance\":\"0xd8d726b7177a800000\"},\"c033b1325a0af45472c25527853b1f1c21fa35de\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c033be10cb48613bd5ebcb33ed4902f38b583003\":{\"balance\":\"0xa2a15d09519be00000\"},\"c0345b33f49ce27fe82cf7c84d141c68f590ce76\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c03de42a109b657a64e92224c08dc1275e80d9b2\":{\"balance\":\"0x1158e460913d00000\"},\"c04069dfb18b096c7867f8bee77a6dc7477ad062\":{\"balance\":\"0x90f534608a72880000\"},\"c0413f5a7c2d9a4b8108289ef6ecd271781524f4\":{\"balance\":\"0xa968163f0a57b400000\"},\"c043f2452dcb9602ef62bd360e033dd23971fe84\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c04f4bd4049f044685b883b62959ae631d667e35\":{\"balance\":\"0x13b80b99c5185700000\"},\"c056d4bd6bf3cbacac65f8f5a0e3980b852740ae\":{\"balance\":\"0x56bc75e2d63100000\"},\"c05b740620f173f16e52471dc38b9c514a0b1526\":{\"balance\":\"0x796e3ea3f8ab00000\"},\"c069ef0eb34299abd2e32dabc47944b272334824\":{\"balance\":\"0x68155a43676e00000\"},\"c06cebbbf7f5149a66f7eb976b3e47d56516da2f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c0725ec2bdc33a1d826071dea29d62d4385a8c25\":{\"balance\":\"0x8a08513463aa6100000\"},\"c07e3867ada096807a051a6c9c34cc3b3f4ad34a\":{\"balance\":\"0x60f06620a849450000\"},\"c0895efd056d9a3a81c3da578ada311bfb9356cf\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c090fe23dcd86b358c32e48d2af91024259f6566\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c09a66172aea370d9a63da04ff71ffbbfcff7f94\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c09e3cfc19f605ff3ec9c9c70e2540d7ee974366\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c0a02ab94ebe56d045b41b629b98462e3a024a93\":{\"balance\":\"0x56bc75e2d63100000\"},\"c0a39308a80e9e84aaaf16ac01e3b01d74bd6b2d\":{\"balance\":\"0x7664ddd4c1c0b8000\"},\"c0a6cbad77692a3d88d141ef769a99bb9e3c9951\":{\"balance\":\"0x56bc75e2d63100000\"},\"c0a7e8435dff14c25577739db55c24d5bf57a3d9\":{\"balance\":\"0xa6dd90cae5114480000\"},\"c0ae14d724832e2fce2778de7f7b8daf7b12a93e\":{\"balance\":\"0x1158e460913d00000\"},\"c0afb7d8b79370cfd663c68cc6b9702a37cd9eff\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c0b0b7a8a6e1acdd05e47f94c09688aa16c7ad8d\":{\"balance\":\"0x37b6d02ac76710000\"},\"c0b3f244bca7b7de5b48a53edb9cbeab0b6d88c0\":{\"balance\":\"0x13b80b99c5185700000\"},\"c0c04d0106810e3ec0e54a19f2ab8597e69a573d\":{\"balance\":\"0x2b5e3af16b1880000\"},\"c0ca3277942e7445874be31ceb902972714f1823\":{\"balance\":\"0xd8d726b7177a80000\"},\"c0cbad3ccdf654da22cbcf5c786597ca1955c115\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c0cbf6032fa39e7c46ff778a94f7d445fe22cf30\":{\"balance\":\"0x10ce1d3d8cb3180000\"},\"c0e0b903088e0c63f53dd069575452aff52410c3\":{\"balance\":\"0xa2a15d09519be00000\"},\"c0e457bd56ec36a1246bfa3230fff38e5926ef22\":{\"balance\":\"0x692ae8897081d00000\"},\"c0ed0d4ad10de03435b153a0fc25de3b93f45204\":{\"balance\":\"0xab4dcf399a3a600000\"},\"c0f29ed0076611b5e55e130547e68a48e26df5e4\":{\"balance\":\"0xa2a15d09519be00000\"},\"c1132878235c5ddba5d9f3228b5236e47020dc6f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c1170dbaadb3dee6198ea544baec93251860fda5\":{\"balance\":\"0x410d586a20a4c00000\"},\"c126573d87b0175a5295f1dd07c575cf8cfa15f2\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c127aab59065a28644a56ba3f15e2eac13da2995\":{\"balance\":\"0x2086ac351052600000\"},\"c12b7f40df9a2f7bf983661422ab84c9c1f50858\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"c12cfb7b3df70fceca0ede263500e27873f8ed16\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c12f881fa112b8199ecbc73ec4185790e614a20f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c1384c6e717ebe4b23014e51f31c9df7e4e25b31\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c1438c99dd51ef1ca8386af0a317e9b041457888\":{\"balance\":\"0xc1daf81d8a3ce0000\"},\"c1631228efbf2a2e3a4092ee8900c639ed34fbc8\":{\"balance\":\"0x33c5499031720c0000\"},\"c175be3194e669422d15fee81eb9f2c56c67d9c9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c1827686c0169485ec15b3a7c8c01517a2874de1\":{\"balance\":\"0x22b1c8c1227a00000\"},\"c18ab467feb5a0aadfff91230ff056464d78d800\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c1950543554d8a713003f662bb612c10ad4cdf21\":{\"balance\":\"0xfc936392801c0000\"},\"c1a41a5a27199226e4c7eb198b031b59196f9842\":{\"balance\":\"0xa5aa85009e39c0000\"},\"c1b2a0fb9cad45cd699192cd27540b88d3384279\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c1b2aa8cb2bf62cdc13a47ecc4657facaa995f98\":{\"balance\":\"0x363793fa96e6a68000\"},\"c1b500011cfba95d7cd636e95e6cbf6167464b25\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c1b9a5704d351cfe983f79abeec3dbbbae3bb629\":{\"balance\":\"0x1158e460913d00000\"},\"c1cbd2e2332a524cf219b10d871ccc20af1fb0fa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c1cdc601f89c0428b31302d187e0dc08ad7d1c57\":{\"balance\":\"0x14542ba12a337c00000\"},\"c1d4af38e9ba799040894849b8a8219375f1ac78\":{\"balance\":\"0x43c33c1937564800000\"},\"c1e1409ca52c25435134d006c2a6a8542dfb7273\":{\"balance\":\"0x1dd1e4bd8d1ee0000\"},\"c1eba5684aa1b24cba63150263b7a9131aeec28d\":{\"balance\":\"0x1158e460913d00000\"},\"c1ec81dd123d4b7c2dd9b4d438a7072c11dc874c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c1f39bd35dd9cec337b96f47c677818160df37b7\":{\"balance\":\"0x1158e460913d00000\"},\"c1ffad07db96138c4b2a530ec1c7de29b8a0592c\":{\"balance\":\"0xf43fc2c04ee00000\"},\"c21fa6643a1f14c02996ad7144b75926e87ecb4b\":{\"balance\":\"0x43c33c1937564800000\"},\"c2340a4ca94c9678b7494c3c852528ede5ee529f\":{\"balance\":\"0x2a36b05a3fd7c8000\"},\"c239abdfae3e9af5457f52ed2b91fd0ab4d9c700\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c23b2f921ce4a37a259ee4ad8b2158d15d664f59\":{\"balance\":\"0x1608995e8bd3f8000\"},\"c24399b4bf86f7338fbf645e3b22b0e0b7973912\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c24ccebc2344cce56417fb684cf81613f0f4b9bd\":{\"balance\":\"0x54069233bf7f780000\"},\"c25266c7676632f13ef29be455ed948add567792\":{\"balance\":\"0x487a9a304539440000\"},\"c25cf826550c8eaf10af2234fef904ddb95213be\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c2663f8145dbfec6c646fc5c49961345de1c9f11\":{\"balance\":\"0x2567ac70392b880000\"},\"c270456885342b640b4cfc1b520e1a544ee0d571\":{\"balance\":\"0x62a992e53a0af00000\"},\"c27376f45d21e15ede3b26f2655fcee02ccc0f2a\":{\"balance\":\"0x1158e460913d00000\"},\"c2779771f0536d79a8708f6931abc44b3035e999\":{\"balance\":\"0x43c4f8300dcb3480000\"},\"c27f4e08099d8cf39ee11601838ef9fc06d7fc41\":{\"balance\":\"0x61093d7c2c6d380000\"},\"c282e6993fbe7a912ea047153ffd9274270e285b\":{\"balance\":\"0x7960b331247638000\"},\"c2836188d9a29253e0cbda6571b058c289a0bb32\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c2aa74847e86edfdd3f3db22f8a2152feee5b7f7\":{\"balance\":\"0x6f118886b784a20000\"},\"c2b2cbe65bc6c2ee7a3c75b2e47c189c062e8d8b\":{\"balance\":\"0x43c33c1937564800000\"},\"c2bae4a233c2d85724f0dabebda0249d833e37d3\":{\"balance\":\"0x10f0cf064dd59200000\"},\"c2c13e72d268e7150dc799e7c6cf03c88954ced7\":{\"balance\":\"0x25f273933db5700000\"},\"c2cb1ada5da9a0423873814793f16144ef36b2f3\":{\"balance\":\"0x48557e3b7017df0000\"},\"c2d1778ef6ee5fe488c145f3586b6ebbe3fbb445\":{\"balance\":\"0x3e1ff1e03b55a80000\"},\"c2d9eedbc9019263d9d16cc5ae072d1d3dd9db03\":{\"balance\":\"0x43c33c1937564800000\"},\"c2e0584a71348cc314b73b2029b6230b92dbb116\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c2e2d498f70dcd0859e50b023a710a6d4b2133bd\":{\"balance\":\"0x383911f00cbce10000\"},\"c2ed5ffdd1add855a2692fe062b5d618742360d4\":{\"balance\":\"0x410d586a20a4c00000\"},\"c2ee91d3ef58c9d1a589844ea1ae3125d6c5ba69\":{\"balance\":\"0x34957444b840e80000\"},\"c2fafdd30acb6d6706e9293cb02641f9edbe07b5\":{\"balance\":\"0x5100860b430f480000\"},\"c2fd0bf7c725ef3e047e5ae1c29fe18f12a7299c\":{\"balance\":\"0x487a9a304539440000\"},\"c2fe7d75731f636dcd09dbda0671393ba0c82a7d\":{\"balance\":\"0x77432217e683600000\"},\"c3107a9af3322d5238df0132419131629539577d\":{\"balance\":\"0x1ab4e464d414310000\"},\"c3110be01dc9734cfc6e1ce07f87d77d1345b7e1\":{\"balance\":\"0x10f0ce949e00f930000\"},\"c32038ca52aee19745be5c31fcdc54148bb2c4d0\":{\"balance\":\"0x2b5aad72c65200000\"},\"c325c352801ba883b3226c5feb0df9eae2d6e653\":{\"balance\":\"0xd5967be4fc3f100000\"},\"c32ec7e42ad16ce3e2555ad4c54306eda0b26758\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c332df50b13c013490a5d7c75dbfa366da87b6d6\":{\"balance\":\"0xd8d726b7177a800000\"},\"c33acdb3ba1aab27507b86b15d67faf91ecf6293\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c33ece935a8f4ef938ea7e1bac87cb925d8490ca\":{\"balance\":\"0x7038c16781f78480000\"},\"c340f9b91c26728c31d121d5d6fc3bb56d3d8624\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c346cb1fbce2ab285d8e5401f42dd7234d37e86d\":{\"balance\":\"0x486cb9799191e0000\"},\"c3483d6e88ac1f4ae73cc4408d6c03abe0e49dca\":{\"balance\":\"0x39992648a23c8a00000\"},\"c348fc5a461323b57be303cb89361b991913df28\":{\"balance\":\"0x152d02c7e14af6800000\"},\"c34e3ba1322ed0571183a24f94204ee49c186641\":{\"balance\":\"0x327afefa4a7bc0000\"},\"c35b95a2a3737cb8f0f596b34524872bd30da234\":{\"balance\":\"0x198be85235e2d500000\"},\"c3631c7698b6c5111989bf452727b3f9395a6dea\":{\"balance\":\"0x243275896641dbe0000\"},\"c36c0b63bfd75c2f8efb060883d868cccd6cbdb4\":{\"balance\":\"0xa2a15d09519be00000\"},\"c3756bcdcc7eec74ed896adfc335275930266e08\":{\"balance\":\"0x14542ba12a337c00000\"},\"c384ac6ee27c39e2f278c220bdfa5baed626d9d3\":{\"balance\":\"0x2086ac351052600000\"},\"c3a046e3d2b2bf681488826e32d9c061518cfe8c\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"c3a9226ae275df2cab312b911040634a9c9c9ef6\":{\"balance\":\"0xd8d726b7177a800000\"},\"c3b928a76fad6578f04f0555e63952cd21d1520a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c3c2297329a6fd99117e54fc6af379b4d556547e\":{\"balance\":\"0x14542ba12a337c00000\"},\"c3c3c2510d678020485a63735d1307ec4ca6302b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c3cb6b36af443f2c6e258b4a39553a818747811f\":{\"balance\":\"0x57473d05dabae80000\"},\"c3db5657bb72f10d58f231fddf11980aff678693\":{\"balance\":\"0x14061b9d77a5e980000\"},\"c3db9fb6f46c480af34465d79753b4e2b74a67ce\":{\"balance\":\"0x43c33c1937564800000\"},\"c3dd58903886303b928625257ae1a013d71ae216\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c3e0471c64ff35fa5232cc3121d1d38d1a0fb7de\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c3e20c96df8d4e38f50b265a98a906d61bc51a71\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c3e387b03ce95ccfd7fa51dd840183bc43532809\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c3f8f67295a5cd049364d05d23502623a3e52e84\":{\"balance\":\"0x14542ba12a337c00000\"},\"c401c427cccff10decb864202f36f5808322a0a8\":{\"balance\":\"0xb47b51a69cd4020000\"},\"c4088c025f3e85013f5439fb3440a17301e544fe\":{\"balance\":\"0x7e09db4d9f3f340000\"},\"c41461a3cfbd32c9865555a4813137c076312360\":{\"balance\":\"0x3635c6204739d98000\"},\"c420388fbee84ad656dd68cdc1fbaa9392780b34\":{\"balance\":\"0xa2dca63aaf4c58000\"},\"c42250b0fe42e6b7dcd5c890a6f0c88f5f5fb574\":{\"balance\":\"0x81ee4825359840000\"},\"c42d6aeb710e3a50bfb44d6c31092969a11aa7f3\":{\"balance\":\"0x82263cafd8cea0000\"},\"c440c7ca2f964b6972ef664a2261dde892619d9c\":{\"balance\":\"0x43c33c1937564800000\"},\"c44bdec8c36c5c68baa2ddf1d431693229726c43\":{\"balance\":\"0x152d02c7e14af6800000\"},\"c44f4ab5bc60397c737eb0683391b633f83c48fa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c452e0e4b3d6ae06b836f032ca09db409ddfe0fb\":{\"balance\":\"0x2b5e3af16b18800000\"},\"c45a1ca1036b95004187cdac44a36e33a94ab5c3\":{\"balance\":\"0xdd00f720301880000\"},\"c45d47ab0c9aa98a5bd62d16223ea2471b121ca4\":{\"balance\":\"0x202e68f2c2aee40000\"},\"c4681e73bb0e32f6b726204831ff69baa4877e32\":{\"balance\":\"0x62a992e53a0af00000\"},\"c46bbdef76d4ca60d316c07f5d1a780e3b165f7e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c47d610b399250f70ecf1389bab6292c91264f23\":{\"balance\":\"0xfa7e7b5df3cd00000\"},\"c4803bb407c762f90b7596e6fde194931e769590\":{\"balance\":\"0xd8d726b7177a800000\"},\"c48651c1d9c16bff4c9554886c3f3f26431f6f68\":{\"balance\":\"0x23ab9599c43f080000\"},\"c489c83ffbb0252ac0dbe3521217630e0f491f14\":{\"balance\":\"0xd8d726b7177a800000\"},\"c48b693cacefdbd6cb5d7895a42e3196327e261c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c493489e56c3bdd829007dc2f956412906f76bfa\":{\"balance\":\"0x2a791488e71540000\"},\"c496cbb0459a6a01600fc589a55a32b454217f9d\":{\"balance\":\"0xeda838c4929080000\"},\"c49cfaa967f3afbf55031061fc4cef88f85da584\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c4b6e5f09cc1b90df07803ce3d4d13766a9c46f4\":{\"balance\":\"0x14542ba12a337c00000\"},\"c4bec96308a20f90cab18399c493fd3d065abf45\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"c4c01afc3e0f045221da1284d7878574442fb9ac\":{\"balance\":\"0x1923c688b73ab040000\"},\"c4c15318d370c73318cc18bdd466dbaa4c6603bf\":{\"balance\":\"0x11164759ffb320000\"},\"c4c6cb723dd7afa7eb535615e53f3cef14f18118\":{\"balance\":\"0x6c6b8fce0d18798000\"},\"c4cc45a2b63c27c0b4429e58cd42da59be739bd6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c4cf930e5d116ab8d13b9f9a7ec4ab5003a6abde\":{\"balance\":\"0x1158e460913d000000\"},\"c4d916574e68c49f7ef9d3d82d1638b2b7ee0985\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"c4dac5a8a0264fbc1055391c509cc3ee21a6e04c\":{\"balance\":\"0x1606b7fa039ce740000\"},\"c4dd048bfb840e2bc85cb53fcb75abc443c7e90f\":{\"balance\":\"0xc971dc07c9c7900000\"},\"c4f2913b265c430fa1ab8adf26c333fc1d9b66f2\":{\"balance\":\"0x1158e460913d00000\"},\"c4f7b13ac6d4eb4db3d4e6a252af8a07bd5957da\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c4f7d2e2e22084c44f70feaab6c32105f3da376f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"c4ff6fbb1f09bd9e102ba033d636ac1c4c0f5304\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c4ffadaaf2823fbea7bff702021bffc4853eb5c9\":{\"balance\":\"0x24a19c1bd6f128000\"},\"c500b720734ed22938d78c5e48b2ba9367a575ba\":{\"balance\":\"0x7129e1cdf373ee00000\"},\"c50fe415a641b0856c4e75bf960515441afa358d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c5134cfbb1df7a20b0ed7057622eeed280947dad\":{\"balance\":\"0xcdff97fabcb4600000\"},\"c517d0315c878813c717e18cafa1eab2654e01da\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c518799a5925576213e21896e0539abb85b05ae3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c522e20fbf04ed7f6b05a37b4718d6fce0142e1a\":{\"balance\":\"0xd8d726b7177a800000\"},\"c524086d46c8112b128b2faf6f7c7d8160a8386c\":{\"balance\":\"0x15af1d78b58c400000\"},\"c52d1a0c73c2a1be84915185f8b34faa0adf1de3\":{\"balance\":\"0x4be4eab3fa0fa68000\"},\"c53594c7cfb2a08f284cc9d7a63bbdfc0b319732\":{\"balance\":\"0xa6b2328ff3a62c00000\"},\"c5374928cdf193705443b14cc20da423473cd9cf\":{\"balance\":\"0x77d10509bb3af8000\"},\"c538a0ff282aaa5f4b75cfb62c70037ee67d4fb5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c53b50fd3b2b72bc6c430baf194a515585d3986d\":{\"balance\":\"0x1158e460913d00000\"},\"c53d79f7cb9b70952fd30fce58d54b9f0b59f647\":{\"balance\":\"0x113e2d6744345f80000\"},\"c549df83c6f65eec0f1dc9a0934a5c5f3a50fd88\":{\"balance\":\"0x9dc05cce28c2b80000\"},\"c55005a6c37e8ca7e543ce259973a3cace961a4a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c555b93156f09101233c6f7cf6eb3c4f196d3346\":{\"balance\":\"0xa2a15d09519be00000\"},\"c55a6b4761fd11e8c85f15174d74767cd8bd9a68\":{\"balance\":\"0x73f75d1a085ba0000\"},\"c56e6b62ba6e40e52aab167d21df025d0055754b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c573e841fa08174a208b060ccb7b4c0d7697127f\":{\"balance\":\"0x243d4d18229ca20000\"},\"c57612de91110c482e6f505bcd23f3c5047d1d61\":{\"balance\":\"0xc2127af858da700000\"},\"c5843399d150066bf7979c34ba294620368ad7c0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c58b9cc61dedbb98c33f224d271f0e228b583433\":{\"balance\":\"0xd255d112e103a00000\"},\"c58f62fee9711e6a05dc0910b618420aa127f288\":{\"balance\":\"0xd7c198710e66b00000\"},\"c593b546b7698710a205ad468b2c13152219a342\":{\"balance\":\"0x54069233bf7f780000\"},\"c593d6e37d14b566643ac4135f243caa0787c182\":{\"balance\":\"0x28a857425466f800000\"},\"c5a3b98e4593fea0b38c4f455a5065f051a2f815\":{\"balance\":\"0x44cf468af25bf770000\"},\"c5a48a8500f9b4e22f0eb16c6f4649687674267d\":{\"balance\":\"0x2c0ec50385043e8000\"},\"c5a629a3962552cb8eded889636aafbd0c18ce65\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c5ae86b0c6c7e3900f1368105c56537faf8d743e\":{\"balance\":\"0xa31062beeed700000\"},\"c5b009baeaf788a276bd35813ad65b400b849f3b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c5b56cd234267c28e89c6f6b2266b086a12f970c\":{\"balance\":\"0xd8d726b7177a800000\"},\"c5c6a4998a33feb764437a8be929a73ba34a0764\":{\"balance\":\"0xa968163f0a57b400000\"},\"c5c73d61cce7c8fe4c8fce29f39092cd193e0fff\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"c5c7590b5621ecf8358588de9b6890f2626143f1\":{\"balance\":\"0xa2a15d09519be00000\"},\"c5cdcee0e85d117dabbf536a3f4069bf443f54e7\":{\"balance\":\"0x6ac5c62d9486070000\"},\"c5d48ca2db2f85d8c555cb0e9cfe826936783f9e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c5de1203d3cc2cea31c82ee2de5916880799eafd\":{\"balance\":\"0x10f0cf064dd59200000\"},\"c5e488cf2b5677933971f64cb8202dd05752a2c0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c5e812f76f15f2e1f2f9bc4823483c8804636f67\":{\"balance\":\"0x3f514193abb840000\"},\"c5e9939334f1252ed2ba26814487dfd2982b3128\":{\"balance\":\"0x3cb71f51fc5580000\"},\"c5eb42295e9cadeaf2af12dede8a8d53c579c469\":{\"balance\":\"0xcf152640c5c8300000\"},\"c5edbbd2ca0357654ad0ea4793f8c5cecd30e254\":{\"balance\":\"0x14542ba12a337c00000\"},\"c5f64babb7033142f20e46d7aa6201ed86f67103\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c5f687717246da8a200d20e5e9bcac60b67f3861\":{\"balance\":\"0x18d993f34aef10000\"},\"c6045b3c350b4ce9ca0c6b754fb41a69b97e9900\":{\"balance\":\"0x3224f42723d4540000\"},\"c60b04654e003b4683041f1cbd6bc38fda7cdbd6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c61446b754c24e3b1642d9e51765b4d3e46b34b6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c618521321abaf5b26513a4a9528086f220adc6f\":{\"balance\":\"0x176b344f2a78c0000\"},\"c6234657a807384126f8968ca1708bb07baa493c\":{\"balance\":\"0x1158e460913d00000\"},\"c625f8c98d27a09a1bcabd5128b1c2a94856af30\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c6355ec4768c70a49af69513cd83a5bca7e3b9cd\":{\"balance\":\"0x14542ba12a337c00000\"},\"c63ac417992e9f9b60386ed953e6d7dff2b090e8\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"c63cd7882118b8a91e074d4c8f4ba91851303b9a\":{\"balance\":\"0xe18398e7601900000\"},\"c652871d192422c6bc235fa063b44a7e1d43e385\":{\"balance\":\"0x8670e9ec6598c0000\"},\"c667441e7f29799aba616451d53b3f489f9e0f48\":{\"balance\":\"0x2f29ace68addd800000\"},\"c66ae4cee87fb3353219f77f1d6486c580280332\":{\"balance\":\"0x19a16b06ff8cb0000\"},\"c674f28c8afd073f8b799691b2f0584df942e844\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c697b70477cab42e2b8b266681f4ae7375bb2541\":{\"balance\":\"0x12e5732baba5c980000\"},\"c69b855539ce1b04714728eec25a37f367951de7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c69be440134d6280980144a9f64d84748a37f349\":{\"balance\":\"0x26c29e47c4844c0000\"},\"c69d663c8d60908391c8d236191533fdf7775613\":{\"balance\":\"0x1a4aba225c20740000\"},\"c6a286e065c85f3af74812ed8bd3a8ce5d25e21d\":{\"balance\":\"0xfc936392801c0000\"},\"c6a30ef5bb3320f40dc5e981230d52ae3ac19322\":{\"balance\":\"0x9ddc1e3b901180000\"},\"c6ae287ddbe1149ba16ddcca4fe06aa2eaa988a9\":{\"balance\":\"0x15af1d78b58c400000\"},\"c6c7c191379897dd9c9d9a33839c4a5f62c0890d\":{\"balance\":\"0xd8d854b22430688000\"},\"c6cd68ec35362c5ad84c82ad4edc232125912d99\":{\"balance\":\"0x5e0549c9632e1d80000\"},\"c6d8954e8f3fc533d2d230ff025cb4dce14f3426\":{\"balance\":\"0x15af1d78b58c400000\"},\"c6dbdb9efd5ec1b3786e0671eb2279b253f215ed\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c6df2075ebd240d44869c2be6bdf82e63d4ef1f5\":{\"balance\":\"0x1158e460913d00000\"},\"c6e2f5af979a03fd723a1b6efa728318cf9c1800\":{\"balance\":\"0x243d4d18229ca20000\"},\"c6e324beeb5b36765ecd464260f7f26006c5c62e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c6e4cc0c7283fc1c85bc4813effaaf72b49823c0\":{\"balance\":\"0xf031ec9c87dd30000\"},\"c6ee35934229693529dc41d9bb71a2496658b88e\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"c6fb1ee37417d080a0d048923bdabab095d077c6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c70527d444c490e9fc3f5cc44e66eb4f306b380f\":{\"balance\":\"0xd8d726b7177a800000\"},\"c70d856d621ec145303c0a6400cd17bbd6f5eaf7\":{\"balance\":\"0x1158e460913d00000\"},\"c70fa45576bf9c865f983893002c414926f61029\":{\"balance\":\"0x15b4aa8e9702680000\"},\"c71145e529c7a714e67903ee6206e4c3042b6727\":{\"balance\":\"0x4d853c8f8908980000\"},\"c71b2a3d7135d2a85fb5a571dcbe695e13fc43cd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c71f1d75873f33dcb2dd4b3987a12d0791a5ce27\":{\"balance\":\"0x3708baed3d68900000\"},\"c71f92a3a54a7b8c2f5ea44305fccb84eee23148\":{\"balance\":\"0x2b59ca131d2060000\"},\"c721b2a7aa44c21298e85039d00e2e460e670b9c\":{\"balance\":\"0x7a1fe160277000000\"},\"c72cb301258e91bc08998a805dd192f25c2f9a35\":{\"balance\":\"0x2009c5c8bf6fdc0000\"},\"c7368b9709a5c1b51c0adf187a65df14e12b7dba\":{\"balance\":\"0x2026fc77f03e5ae8000\"},\"c739259e7f85f2659bef5f609ed86b3d596c201e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c73e2112282215dc0762f32b7e807dcd1a7aae3e\":{\"balance\":\"0x1760cbc623bb3500000\"},\"c749668042e71123a648975e08ed6382f83e05e2\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"c74a3995f807de1db01a2eb9c62e97d0548f696f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c7506c1019121ff08a2c8c1591a65eb4bdfb4a3f\":{\"balance\":\"0x2086ac351052600000\"},\"c75c37ce2da06bbc40081159c6ba0f976e3993b1\":{\"balance\":\"0x3a7923151ecf580000\"},\"c75d2259306aec7df022768c69899a652185dbc4\":{\"balance\":\"0xd8d726b7177a800000\"},\"c760971bbc181c6a7cf77441f24247d19ce9b4cf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c76130c73cb9210238025c9df95d0be54ac67fbe\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"c765e00476810947816af142d46d2ee7bca8cc4f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c7675e5647b9d8daf4d3dff1e552f6b07154ac38\":{\"balance\":\"0x9c2007651b2500000\"},\"c77b01a6e911fa988d01a3ab33646beef9c138f3\":{\"balance\":\"0x271b6fa5dbe6cc0000\"},\"c7837ad0a0bf14186937ace06c5546a36aa54f46\":{\"balance\":\"0xd8d726b7177a800000\"},\"c79806032bc7d828f19ac6a640c68e3d820fa442\":{\"balance\":\"0x1158e460913d00000\"},\"c799e34e88ff88be7de28e15e4f2a63d0b33c4cb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c79d5062c796dd7761f1f13e558d73a59f82f38b\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"c7a018f0968a51d1f6603c5c49dc545bcb0ff293\":{\"balance\":\"0xd8d726b7177a800000\"},\"c7aff91929797489555a2ff1d14d5c695a108355\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c7b1c83e63203f9547263ef6282e7da33b6ed659\":{\"balance\":\"0xfc936392801c0000\"},\"c7b39b060451000ca1049ba154bcfa00ff8af262\":{\"balance\":\"0x152d02c7e14af6800000\"},\"c7bf17c4c11f98941f507e77084fffbd2dbd3db5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c7bf2ed1ed312940ee6aded1516e268e4a604856\":{\"balance\":\"0x14542ba12a337c00000\"},\"c7d44fe32c7f8cd5f1a97427b6cd3afc9e45023e\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"c7d5c7054081e918ec687b5ab36e973d18132935\":{\"balance\":\"0x9ddc1e3b901180000\"},\"c7de5e8eafb5f62b1a0af2195cf793c7894c9268\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c7e330cd0c890ac99fe771fcc7e7b009b7413d8a\":{\"balance\":\"0xd8d726b7177a800000\"},\"c7eac31abce6d5f1dea42202b6a674153db47a29\":{\"balance\":\"0x2009c5c8bf6fdc0000\"},\"c7ec62b804b1f69b1e3070b5d362c62fb309b070\":{\"balance\":\"0x2c46bf5416066110000\"},\"c7f72bb758016b374714d4899bce22b4aec70a31\":{\"balance\":\"0x3a26c9478f5e2d0000\"},\"c80b36d1beafba5fcc644d60ac6e46ed2927e7dc\":{\"balance\":\"0xb98bc829a6f90000\"},\"c811c2e9aa1ac3462eba5e88fcb5120e9f6e2ca2\":{\"balance\":\"0x4be6d887bd876e0000\"},\"c817df1b91faf30fe3251571727c9711b45d8f06\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"c81fb7d20fd2800192f0aac198d6d6a37d3fcb7d\":{\"balance\":\"0xe1149331c2dde0000\"},\"c820c711f07705273807aaaa6de44d0e4b48be2e\":{\"balance\":\"0x8670e9ec6598c0000\"},\"c8231ba5a411a13e222b29bfc1083f763158f226\":{\"balance\":\"0x3637096c4bcc690000\"},\"c836e24a6fcf29943b3608e662290a215f6529ea\":{\"balance\":\"0xfd45064eaee100000\"},\"c83ba6dd9549be1d3287a5a654d106c34c6b5da2\":{\"balance\":\"0x17b7883c06916600000\"},\"c83e9d6a58253beebeb793e6f28b054a58491b74\":{\"balance\":\"0xf46c2b6f5a9140000\"},\"c841884fa4785fb773b28e9715fae99a5134305d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c84d9bea0a7b9f140220fd8b9097cfbfd5edf564\":{\"balance\":\"0x6ab9ec291ad7d8000\"},\"c852428d2b586497acd30c56aa13fb5582f84402\":{\"balance\":\"0x3342d60dff19600000\"},\"c853215b9b9f2d2cd0741e585e987b5fb80c212e\":{\"balance\":\"0x54069233bf7f780000\"},\"c85325eab2a59b3ed863c86a5f2906a04229ffa9\":{\"balance\":\"0x193d7f7d253de00000\"},\"c85ef27d820403805fc9ed259fff64acb8d6346a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c8616b4ec09128cdff39d6e4b9ac86eec471d5f2\":{\"balance\":\"0x10d3aa536e2940000\"},\"c86190904b8d079ec010e462cbffc90834ffaa5c\":{\"balance\":\"0x22385a827e815500000\"},\"c8710d7e8b5a3bd69a42fe0fa8b87c357fddcdc8\":{\"balance\":\"0xd8d726b7177a800000\"},\"c87352dba582ee2066b9c002a962e003134f78b1\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c87c77e3c24adecdcd1038a38b56e18dead3b702\":{\"balance\":\"0x1dd0c885f9a0d800000\"},\"c87d3ae3d88704d9ab0009dcc1a0067131f8ba3c\":{\"balance\":\"0x6ac5c62d9486070000\"},\"c8814e34523e38e1f927a7dce8466a447a093603\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c88255eddcf521c6f81d97f5a42181c9073d4ef1\":{\"balance\":\"0xfc39044d00a2a8000\"},\"c885a18aabf4541b7b7b7ecd30f6fae6869d9569\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c88ca1e6e5f4d558d13780f488f10d4ad3130d34\":{\"balance\":\"0x54069233bf7f780000\"},\"c88eec54d305c928cc2848c2fee23531acb96d49\":{\"balance\":\"0x6c6ad382d4fb610000\"},\"c89cf504b9f3f835181fd8424f5ccbc8e1bddf7d\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c8a2c4e59e1c7fc54805580438aed3e44afdf00e\":{\"balance\":\"0x2629f66e0c5300000\"},\"c8aa49e3809f0899f28ab57e6743709d58419033\":{\"balance\":\"0x2fb474098f67c00000\"},\"c8ab1a3cf46cb8b064df2e222d39607394203277\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c8b1850525d946f2ae84f317b15188c536a5dc86\":{\"balance\":\"0x918ddc3a42a3d40000\"},\"c8d4e1599d03b79809e0130a8dc38408f05e8cd3\":{\"balance\":\"0x9fad06241279160000\"},\"c8dd27f16bf22450f5771b9fe4ed4ffcb30936f4\":{\"balance\":\"0xaadec983fcff40000\"},\"c8de7a564c7f4012a6f6d10fd08f47890fbf07d4\":{\"balance\":\"0x1043561a8829300000\"},\"c8e2adeb545e499d982c0c117363ceb489c5b11f\":{\"balance\":\"0x35659ef93f0fc40000\"},\"c8e558a3c5697e6fb23a2594c880b7a1b68f9860\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c8f2b320e6dfd70906c597bad2f9501312c78259\":{\"balance\":\"0x51934b8b3a57d00000\"},\"c90300cb1d4077e6a6d7e169a460468cf4a492d7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c90c3765156bca8e4897ab802419153cbe5225a9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c910a970556c9716ea53af66ddef93143124913d\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"c9127b7f6629ee13fc3f60bc2f4467a20745a762\":{\"balance\":\"0x37c9aa4e7ce421d8000\"},\"c91bb562e42bd46130e2d3ae4652b6a4eb86bc0f\":{\"balance\":\"0x1d460162f516f00000\"},\"c9308879056dfe138ef8208f79a915c6bc7e70a8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"c934becaf71f225f8b4a4bf7b197f4ac9630345c\":{\"balance\":\"0x43c33c1937564800000\"},\"c93fbde8d46d2bcc0fa9b33bd8ba7f8042125565\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"c94089553ae4c22ca09fbc98f57075cf2ec59504\":{\"balance\":\"0xd8d726b7177a800000\"},\"c94110e71afe578aa218e4fc286403b0330ace8d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c946d5acc1346eba0a7279a0ac1d465c996d827e\":{\"balance\":\"0x3783d545fdf0aa40000\"},\"c94a28fb3230a9ddfa964e770f2ce3c253a7be4f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"c94a585203da7bbafd93e15884e660d4b1ead854\":{\"balance\":\"0x17b7883c06916600000\"},\"c94f7c35c027d47df8ef4f9df85a9248a17dd23b\":{\"balance\":\"0x19f8e7559924c0000\"},\"c951900c341abbb3bafbf7ee2029377071dbc36a\":{\"balance\":\"0x11c25d004d01f80000\"},\"c953f934c0eb2d0f144bdab00483fd8194865ce7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c96626728aaa4c4fb3d31c26df3af310081710d1\":{\"balance\":\"0xb50fcfafebecb00000\"},\"c96751656c0a8ef4357b7344322134b983504aca\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c98048687f2bfcc9bd90ed18736c57edd352b65d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"c981d312d287d558871edd973abb76b979e5c35e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"c982586d63b0d74c201b1af8418372e30c7616be\":{\"balance\":\"0x56bc75e2d63100000\"},\"c989434f825aaf9c552f685eba7c11db4a5fc73a\":{\"balance\":\"0x1b28c58d9696b40000\"},\"c989eec307e8839b9d7237cfda08822962abe487\":{\"balance\":\"0x15af1d78b58c400000\"},\"c992be59c6721caf4e028f9e8f05c25c55515bd4\":{\"balance\":\"0x1158e460913d00000\"},\"c9957ba94c1b29e5277ec36622704904c63dc023\":{\"balance\":\"0x683efc6782642c0000\"},\"c99a9cd6c9c1be3534eecd92ecc22f5c38e9515b\":{\"balance\":\"0x105593b3a169d770000\"},\"c9ac01c3fb0929033f0ccc7e1acfeaaba7945d47\":{\"balance\":\"0x2a36a9e9ca4d2038000\"},\"c9b698e898d20d4d4f408e4e4d061922aa856307\":{\"balance\":\"0x22b1c8c1227a00000\"},\"c9b6b686111691ee6aa197c7231a88dc60bd295d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c9c7ac0bdd9342b5ead4360923f68c72a6ba633a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"c9c80dc12e7bab86e949d01e4c3ed35f2b9bba5f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"c9d76446d5aadff80b68b91b08cd9bc8f5551ac1\":{\"balance\":\"0x26b4bd9110dce80000\"},\"c9dcbb056f4db7d9da39936202c5bd8230b3b477\":{\"balance\":\"0x43c33c1937564800000\"},\"c9e02608066828848aeb28c73672a12925181f4d\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"ca0432cb157b5179f02ebba5c9d1b54fec4d88ca\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ca122cf0f2948896b74843f49afed0ba1618eed7\":{\"balance\":\"0x1e5b8fa8fe2ac00000\"},\"ca22cda3606da5cad013b8074706d7e9e721a50c\":{\"balance\":\"0x17181c6fa3981940000\"},\"ca23f62dff0d6460036c62e840aec5577e0befd2\":{\"balance\":\"0x7a1fe160277000000\"},\"ca25ff34934c1942e22a4e7bd56f14021a1af088\":{\"balance\":\"0xaadec983fcff40000\"},\"ca373fe3c906b8c6559ee49ccd07f37cd4fb5266\":{\"balance\":\"0x61093d7c2c6d380000\"},\"ca41ccac30172052d522cd2f2f957d248153409f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ca4288014eddc5632f5facb5e38517a8f8bc5d98\":{\"balance\":\"0x126e72a69a50d00000\"},\"ca428863a5ca30369892d612183ef9fb1a04bcea\":{\"balance\":\"0x52663ccab1e1c00000\"},\"ca49a5f58adbefae23ee59eea241cf0482622eaa\":{\"balance\":\"0x4d853c8f8908980000\"},\"ca4ca9e4779d530ecbacd47e6a8058cfde65d98f\":{\"balance\":\"0x2b5e3af16b18800000\"},\"ca657ec06fe5bc09cf23e52af7f80cc3689e6ede\":{\"balance\":\"0x30ca024f987b900000\"},\"ca66b2280fa282c5b67631ce552b62ee55ad8474\":{\"balance\":\"0x6ac422f53492880000\"},\"ca6c818befd251361e02744068be99d8aa60b84a\":{\"balance\":\"0x14542ba12a337c00000\"},\"ca70f4ddbf069d2143bd6bbc7f696b52789b32e7\":{\"balance\":\"0xa2a15d09519be00000\"},\"ca747576446a4c8f30b08340fee198de63ec92cf\":{\"balance\":\"0x17c8e1206722a300000\"},\"ca7ba3ff536c7e5f0e153800bd383db8312998e0\":{\"balance\":\"0x931ac3d6bb2400000\"},\"ca8276c477b4a07b80107b843594189607b53bec\":{\"balance\":\"0x14542ba12a337c00000\"},\"ca8409083e01b397cf12928a05b68455ce6201df\":{\"balance\":\"0x56bc75e2d631000000\"},\"ca98c7988efa08e925ef9c9945520326e9f43b99\":{\"balance\":\"0xd8d726b7177a800000\"},\"ca9a042a6a806ffc92179500d24429e8ab528117\":{\"balance\":\"0x3ba1910bf341b00000\"},\"ca9dec02841adf5cc920576a5187edd2bd434a18\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ca9faa17542fafbb388eab21bc4c94e8a7b34788\":{\"balance\":\"0x6c6b8fce0d18798000\"},\"caaa68ee6cdf0d34454a769b0da148a1faaa1865\":{\"balance\":\"0x1872e1de7fe52c00000\"},\"caad9dc20d589ce428d8fda3a9d53a607b7988b5\":{\"balance\":\"0xd8d726b7177a800000\"},\"cab0d32cf3767fa6b3537c84328baa9f50458136\":{\"balance\":\"0x1e5b8fa8fe2ac000000\"},\"cab9a301e6bd46e940355028eccd40ce4d5a1ac3\":{\"balance\":\"0x15af1d78b58c400000\"},\"cab9a97ada065c87816e6860a8f1426fe6b3d775\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cabab6274ed15089737e287be878b757934864e2\":{\"balance\":\"0x43c33c1937564800000\"},\"cabdaf354f4720a466a764a528d60e3a482a393c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cacb675e0996235404efafbb2ecb8152271b55e0\":{\"balance\":\"0x25f273933db5700000\"},\"cad14f9ebba76680eb836b079c7f7baaf481ed6d\":{\"balance\":\"0xcef3d7bd7d0340000\"},\"cae3a253bcb2cf4e13ba80c298ab0402da7c2aa0\":{\"balance\":\"0x124bc0ddd92e5600000\"},\"caef027b1ab504c73f41f2a10979b474f97e309f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"caf4481d9db78dc4f25f7b4ac8bd3b1ca0106b31\":{\"balance\":\"0x10f0cf064dd59200000\"},\"cafde855864c2598da3cafc05ad98df2898e8048\":{\"balance\":\"0x300a8ed96ff4a940000\"},\"cb0dd7cf4e5d8661f6028943a4b9b75c914436a7\":{\"balance\":\"0x1969368974c05b000000\"},\"cb1bb6f1da5eb10d4899f7e61d06c1b00fdfb52d\":{\"balance\":\"0x384524cc70b7780000\"},\"cb3d766c983f192bcecac70f4ee03dd9ff714d51\":{\"balance\":\"0x56bc75e2d63100000\"},\"cb42b44eb5fd60b5837e4f9eb47267523d1a229c\":{\"balance\":\"0x2ee449550898e40000\"},\"cb47bd30cfa8ec5468aaa6a94642ced9c819c8d4\":{\"balance\":\"0xd8d726b7177a800000\"},\"cb48fe8265d9af55eb7006bc335645b0a3a183be\":{\"balance\":\"0xa2a15d09519be00000\"},\"cb4a914d2bb029f32e5fef5c234c4fec2d2dd577\":{\"balance\":\"0x6194049f30f7200000\"},\"cb4abfc282aed76e5d57affda542c1f382fcacf4\":{\"balance\":\"0x1b90f11c3183faa0000\"},\"cb4ad0c723da46ab56d526da0c1d25c73daff10a\":{\"balance\":\"0x1ba5abf9e779380000\"},\"cb4bb1c623ba28dc42bdaaa6e74e1d2aa1256c2a\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"cb50587412822304ebcba07dab3a0f09fffee486\":{\"balance\":\"0x4a4491bd6dcd280000\"},\"cb58990bcd90cfbf6d8f0986f6fa600276b94e2d\":{\"balance\":\"0x3634bf39ab98788000\"},\"cb68ae5abe02dcf8cbc5aa719c25814651af8b85\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"cb7479109b43b26657f4465f4d18c6f974be5f42\":{\"balance\":\"0x62a992e53a0af00000\"},\"cb7d2b8089e9312cc9aeaa2773f35308ec6c2a7b\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cb86edbc8bbb1f9131022be649565ebdb09e32a1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cb93199b9c90bc4915bd859e3d42866dc8c18749\":{\"balance\":\"0xc90df07def78c0000\"},\"cb94e76febe208116733e76e805d48d112ec9fca\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cb9b5103e4ce89af4f64916150bff9eecb9faa5c\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"cba25c7a503cc8e0d04971ca05c762f9b762b48b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"cba288cd3c1eb4d59ddb06a6421c14c345a47b24\":{\"balance\":\"0xd8d726b7177a800000\"},\"cbb3189e4bd7f45f178b1c30c76e26314d4a4b0a\":{\"balance\":\"0xffe0b677c65a98000\"},\"cbb7be17953f2ccc93e1bc99805bf45511434e4c\":{\"balance\":\"0xaae5b9df56d2f200000\"},\"cbc04b4d8b82caf670996f160c362940d66fcf1a\":{\"balance\":\"0x14542ba12a337c00000\"},\"cbde9734b8e6aa538c291d6d7facedb0f338f857\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cbe1b948864d8474e765145858fca4550f784b92\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cbe52fc533d7dd608c92a260b37c3f45deb4eb33\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cbe810fe0fecc964474a1db97728bc87e973fcbd\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cbf16a0fe2745258cd52db2bf21954c975fc6a15\":{\"balance\":\"0x1043561a8829300000\"},\"cbf37ff854a2f1ce53934494777892d3ec655782\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cbfa6af6c283b046e2772c6063b0b21553c40106\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cbfa76db04ce38fb205d37b8d377cf1380da0317\":{\"balance\":\"0x4d853c8f8908980000\"},\"cc034985d3f28c2d39b1a34bced4d3b2b6ca234e\":{\"balance\":\"0x9ddc1e3b901180000\"},\"cc043c4388d345f884c6855e71142a9f41fd6935\":{\"balance\":\"0x1158e460913d00000\"},\"cc1d6ead01aada3e8dc7b95dca25df26eefa639d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cc2b5f448f3528d3fe41cc7d1fa9c0dc76f1b776\":{\"balance\":\"0x340aad21b3b700000\"},\"cc2d04f0a4017189b340ca77198641dcf6456b91\":{\"balance\":\"0xd5967be4fc3f100000\"},\"cc419fd9912b85135659e77a93bc3df182d45115\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cc45fb3a555bad807b388a0357c855205f7c75e8\":{\"balance\":\"0x2ee449550898e40000\"},\"cc48414d2ac4d42a5962f29eee4497092f431352\":{\"balance\":\"0x8ba52e6fc45e40000\"},\"cc4a2f2cf86cf3e43375f360a4734691195f1490\":{\"balance\":\"0x4915053bd129098000\"},\"cc4f0ff2aeb67d54ce3bc8c6510b9ae83e9d328b\":{\"balance\":\"0x15af1d78b58c400000\"},\"cc4faac00be6628f92ef6b8cb1b1e76aac81fa18\":{\"balance\":\"0xb22a2eab0f0fd0000\"},\"cc4feb72df98ff35a138e01761d1203f9b7edf0a\":{\"balance\":\"0x17b7883c06916600000\"},\"cc606f511397a38fc7872bd3b0bd03c71bbd768b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cc60f836acdef3548a1fefcca13ec6a937db44a0\":{\"balance\":\"0x4b06dbbb40f4a0000\"},\"cc6c03bd603e09de54e9c4d5ac6d41cbce715724\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"cc6c2df00e86eca40f21ffda1a67a1690f477c65\":{\"balance\":\"0xab4dcf399a3a600000\"},\"cc6d7b12061bc96d104d606d65ffa32b0036eb07\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cc73dd356b4979b579b401d4cc7a31a268ddce5a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"cc758d071d25a6320af68c5dc9c4f6955ba94520\":{\"balance\":\"0x14542ba12a337c00000\"},\"cc7b0481cc32e6faef2386a07022bcb6d2c3b4fc\":{\"balance\":\"0xab4dcf399a3a600000\"},\"cc943be1222cd1400a2399dd1b459445cf6d54a9\":{\"balance\":\"0x2a740ae6536fc880000\"},\"cc9519d1f3985f6b255eaded12d5624a972721e1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cc9ac715cd6f2610c52b58676456884297018b29\":{\"balance\":\"0xb98bc829a6f90000\"},\"cca07bb794571d4acf041dad87f0d1ef3185b319\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ccabc6048a53464424fcf76eeb9e6e1801fa23d4\":{\"balance\":\"0x2ab7b260ff3fd0000\"},\"ccae0d3d852a7da3860f0636154c0a6ca31628d4\":{\"balance\":\"0x5c6d12b6bc1a00000\"},\"ccca24d8c56d6e2c07db086ec07e585be267ac8d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ccd521132d986cb96869842622a7dda26c3ed057\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ccf43975b76bfe735fec3cb7d4dd24f805ba0962\":{\"balance\":\"0x340aad21b3b700000\"},\"ccf62a663f1353ba2ef8e6521dc1ecb673ec8ef7\":{\"balance\":\"0x83d6c7aab63600000\"},\"ccf7110d1bd9a74bfd1d7d7d2d9d55607e7b837d\":{\"balance\":\"0x30ca024f987b900000\"},\"ccfd725760a68823ff1e062f4cc97e1360e8d997\":{\"balance\":\"0x15ac56edc4d12c0000\"},\"cd020f8edfcf524798a9b73a640334bbf72f80a5\":{\"balance\":\"0x73f75d1a085ba0000\"},\"cd06f8c1b5cdbd28e2d96b6346c3e85a0483ba24\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cd072e6e1833137995196d7bb1725fef8761f655\":{\"balance\":\"0x14542ba12a337c00000\"},\"cd0a161bc367ae0927a92aac9cf6e5086714efca\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cd0af3474e22f069ec3407870dd770443d5b12b0\":{\"balance\":\"0x8e5eb4ee77b2ef0000\"},\"cd0b0257e783a3d2c2e3ba9d6e79b75ef98024d4\":{\"balance\":\"0x9fad06241279160000\"},\"cd102cd6db3df14ad6af0f87c72479861bfc3d24\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cd1e66ed539dd92fc40bbaa1fa16de8c02c14d45\":{\"balance\":\"0xc77e4256863d80000\"},\"cd1ed263fbf6f6f7b48aef8f733d329d4382c7c7\":{\"balance\":\"0x100bd33fb98ba0000\"},\"cd2a36d753e9e0ed012a584d716807587b41d56a\":{\"balance\":\"0xe2ba75b0b1f1c0000\"},\"cd32a4a8a27f1cc63954aa634f7857057334c7a3\":{\"balance\":\"0x3ad166576c72d40000\"},\"cd35ff010ec501a721a1b2f07a9ca5877dfcf95a\":{\"balance\":\"0xd96fce90cfabcc0000\"},\"cd4306d7f6947ac1744d4e13b8ef32cb657e1c00\":{\"balance\":\"0x1b1ab319f5ec750000\"},\"cd43258b7392a930839a51b2ef8ad23412f75a9f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cd49bf185e70d04507999f92a4de4455312827d0\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cd5510a242dfb0183de925fba866e312fabc1657\":{\"balance\":\"0x821ab0d44149800000\"},\"cd566ad7b883f01fd3998a9a58a9dee4724ddca5\":{\"balance\":\"0x330ae1835be300000\"},\"cd59f3dde77e09940befb6ee58031965cae7a336\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cd725d70be97e677e3c8e85c0b26ef31e9955045\":{\"balance\":\"0x487a9a304539440000\"},\"cd7e47909464d871b9a6dc76a8e9195db3485e7a\":{\"balance\":\"0x215f835bc769da80000\"},\"cd7ece086b4b619b3b369352ee38b71ddb06439a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"cd7f09d7ed66d0c38bc5ad4e32b7f2b08dc1b30d\":{\"balance\":\"0x3e3bb34da2a4700000\"},\"cd9529492b5c29e475acb941402b3d3ba50686b0\":{\"balance\":\"0x6acb3df27e1f880000\"},\"cd95fa423d6fc120274aacde19f4eeb766f10420\":{\"balance\":\"0xad78ebc5ac6200000\"},\"cd9b4cef73390c83a8fd71d7b540a7f9cf8b8c92\":{\"balance\":\"0x4e1003b28d9280000\"},\"cda1741109c0265b3fb2bf8d5ec9c2b8a3346b63\":{\"balance\":\"0x1158e460913d00000\"},\"cda1b886e3a795c9ba77914e0a2fe5676f0f5ccf\":{\"balance\":\"0x5bf60ea42c2040000\"},\"cda4530f4b9bc50905b79d17c28fc46f95349bdf\":{\"balance\":\"0x3310e04911f1f80000\"},\"cdab46a5902080646fbf954204204ae88404822b\":{\"balance\":\"0x1d8a96e5c606eb0000\"},\"cdb597299030183f6e2d238533f4642aa58754b6\":{\"balance\":\"0x15af1d78b58c400000\"},\"cdd5d881a7362c9070073bdfbc75e72453ac510e\":{\"balance\":\"0x2da518eae48ee80000\"},\"cdd60d73efaad873c9bbfb178ca1b7105a81a681\":{\"balance\":\"0x1bc16d674ec800000\"},\"cdd9efac4d6d60bd71d95585dce5d59705c13564\":{\"balance\":\"0x56bc75e2d63100000\"},\"cde36d81d128c59da145652193eec2bfd96586ef\":{\"balance\":\"0xd8d726b7177a800000\"},\"cdea386f9d0fd804d02818f237b7d9fa7646d35e\":{\"balance\":\"0xa349d36d80ec578000\"},\"cdecf5675433cdb0c2e55a68db5d8bbe78419dd2\":{\"balance\":\"0x1158e460913d00000\"},\"cdfd8217339725d7ebac11a63655f265eff1cc3d\":{\"balance\":\"0x10f0c696410e3a90000\"},\"ce079f51887774d8021cb3b575f58f18e9acf984\":{\"balance\":\"0x9c2007651b2500000\"},\"ce1884ddbbb8e10e4dba6e44feeec2a7e5f92f05\":{\"balance\":\"0xd8d726b7177a800000\"},\"ce1b0cb46aaecfd79b880cad0f2dda8a8dedd0b1\":{\"balance\":\"0x1158e460913d00000\"},\"ce26f9a5305f8381094354dbfc92664e84f902b5\":{\"balance\":\"0xc7aaab0591eec0000\"},\"ce2deab51c0a9ae09cd212c4fa4cc52b53cc0dec\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ce2e0da8934699bb1a553e55a0b85c169435bea3\":{\"balance\":\"0x10f0c696410e3a90000\"},\"ce3a61f0461b00935e85fa1ead82c45e5a64d488\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ce4b065dbcb23047203262fb48c1188364977470\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ce53c8cdd74296aca987b2bc19c2b875a48749d0\":{\"balance\":\"0xa2a15d09519be00000\"},\"ce5e04f0184369bcfa06aca66ffa91bf59fa0fb9\":{\"balance\":\"0x22b1c8c1227a00000\"},\"ce5eb63a7bf4fbc2f6e4baa0c68ab1cb4cf98fb4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ce62125adec3370ac52110953a4e760be9451e3b\":{\"balance\":\"0x83d6c7aab63600000\"},\"ce71086d4c602554b82dcbfce88d20634d53cc4d\":{\"balance\":\"0x92896529baddc880000\"},\"ce8a6b6d5033b1498b1ffeb41a41550405fa03a2\":{\"balance\":\"0xd8d726b7177a800000\"},\"ce9786d3712fa200e9f68537eeaa1a06a6f45a4b\":{\"balance\":\"0x61093d7c2c6d380000\"},\"ce9d21c692cd3c01f2011f505f870036fa8f6cd2\":{\"balance\":\"0x15af1d78b58c400000\"},\"cea2896623f4910287a2bdc5be83aea3f2e6de08\":{\"balance\":\"0x1fb5a3751e490dc0000\"},\"cea34a4dd93dd9aefd399002a97d997a1b4b89cd\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"cea43f7075816b60bbfce68b993af0881270f6c4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cea8743341533cb2f0b9c6efb8fda80d77162825\":{\"balance\":\"0x56bc75e2d63100000\"},\"ceb089ec8a78337e8ef88de11b49e3dd910f748f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ceb33d78e7547a9da2e87d51aec5f3441c87923a\":{\"balance\":\"0x1158e460913d00000\"},\"ceb389381d48a8ae4ffc483ad0bb5e204cfdb1ec\":{\"balance\":\"0x2827e6e4dd62ba8000\"},\"cec6fc65853f9cce5f8e844676362e1579015f02\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ced3c7be8de7585140952aeb501dc1f876ecafb0\":{\"balance\":\"0xd8d726b7177a800000\"},\"ced81ec3533ff1bfebf3e3843ee740ad11758d3e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"cedcb3a1d6843fb6bef643617deaf38f8e98dd5f\":{\"balance\":\"0x19e2a4c818b9060000\"},\"cee699c0707a7836252b292f047ce8ad289b2f55\":{\"balance\":\"0x119a1e21aa69560000\"},\"ceed47ca5b899fd1623f21e9bd4db65a10e5b09d\":{\"balance\":\"0x73877404c1eee0000\"},\"cef77451dfa2c643e00b156d6c6ff84e2373eb66\":{\"balance\":\"0xa31062beeed700000\"},\"cf1169041c1745e45b172435a2fc99b49ace2b00\":{\"balance\":\"0x1bb88baab2d7c0000\"},\"cf157612764e0fd696c8cb5fba85df4c0ddc3cb0\":{\"balance\":\"0x65a4da25d3016c00000\"},\"cf1bdb799b2ea63ce134668bdc198b54840f180b\":{\"balance\":\"0xfc936392801c0000\"},\"cf2288ef4ebf88e86db13d8a0e0bf52a056582c3\":{\"balance\":\"0x89506fbf9740740000\"},\"cf264e6925130906c4d7c18591aa41b2a67f6f58\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf26b47bd034bc508e6c4bcfd6c7d30034925761\":{\"balance\":\"0x6194049f30f7200000\"},\"cf2e2ad635e9861ae95cb9bafcca036b5281f5ce\":{\"balance\":\"0x77432217e6836000000\"},\"cf2e734042a355d05ffb2e3915b16811f45a695e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf348f2fe47b7e413c077a7baf3a75fbf8428692\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf3f9128b07203a3e10d7d5755c0c4abc6e2cac2\":{\"balance\":\"0x10f0cf064dd59200000\"},\"cf3fbfa1fd32d7a6e0e6f8ef4eab57be34025c4c\":{\"balance\":\"0x39a1c0f7594d480000\"},\"cf4166746e1d3bc1f8d0714b01f17e8a62df1464\":{\"balance\":\"0x3677036edf0af60000\"},\"cf4f1138f1bd6bf5b6d485cce4c1017fcb85f07d\":{\"balance\":\"0x2fd0bc77c32bff0000\"},\"cf5a6f9df75579c644f794711215b30d77a0ce40\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf5e0eacd1b39d0655f2f77535ef6608eb950ba0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf684dfb8304729355b58315e8019b1aa2ad1bac\":{\"balance\":\"0x177224aa844c720000\"},\"cf694081c76d18c64ca71382be5cd63b3cb476f8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cf6e52e6b77480b1867efec6446d9fc3cc3577e8\":{\"balance\":\"0xc0901f6bd98790000\"},\"cf883a20329667ea226a1e3c765dbb6bab32219f\":{\"balance\":\"0xa4be3564d616660000\"},\"cf8882359c0fb23387f5674074d8b17ade512f98\":{\"balance\":\"0x14542ba12a337c00000\"},\"cf89f7460ba3dfe83c5a1d3a019ee1250f242f0f\":{\"balance\":\"0x356813cdcefd028000\"},\"cf923a5d8fbc3d01aa079d1cfe4b43ce071b1611\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cf9be9b9ab86c66b59968e67b8d4dcff46b1814a\":{\"balance\":\"0x23c757072b8dd00000\"},\"cfa8b37127149bdbfee25c34d878510951ea10eb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"cfac2e1bf33205b05533691a02267ee19cd81836\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cfbb32b7d024350e3321fa20c9a914035372ffc6\":{\"balance\":\"0x15be6174e1912e0000\"},\"cfc4e6f7f8b011414bfba42f23adfaa78d4ecc5e\":{\"balance\":\"0x6449e84e47a8a80000\"},\"cfd2728dfb8bdbf3bf73598a6e13eaf43052ea2b\":{\"balance\":\"0x93739534d28680000\"},\"cfd47493c9f89fe680bda5754dd7c9cfe7cb5bbe\":{\"balance\":\"0x2f473513448fe0000\"},\"cfde0fc75d6f16c443c3038217372d99f5d907f7\":{\"balance\":\"0x83225e6396b5ec0000\"},\"cfe2caaf3cec97061d0939748739bffe684ae91f\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"cfeacaaed57285e0ac7268ce6a4e35ecfdb242d7\":{\"balance\":\"0x3ae4d4240190600000\"},\"cfecbea07c27002f65fe534bb8842d0925c78402\":{\"balance\":\"0xd8d726b7177a800000\"},\"cfee05c69d1f29e7714684c88de5a16098e91399\":{\"balance\":\"0x6acb3df27e1f880000\"},\"cff6a6fe3e9a922a12f21faa038156918c4fcb9c\":{\"balance\":\"0x44591d67fecc80000\"},\"cff7f89a4d4219a38295251331568210ffc1c134\":{\"balance\":\"0x5f68e8131ecf800000\"},\"cff8d06b00e3f50c191099ad56ba6ae26571cd88\":{\"balance\":\"0x3635c9adc5dea00000\"},\"cffc49c1787eebb2b56cabe92404b636147d4558\":{\"balance\":\"0x133e0308f40a3da8000\"},\"d008513b27604a89ba1763b6f84ce688b346945b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d00f067286c0fbd082f9f4a61083ec76deb3cee6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d015f6fcb84df7bb410e8c8f04894a881dcac237\":{\"balance\":\"0x384524cc70b7780000\"},\"d01af9134faf5257174e8b79186f42ee354e642d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d02108d2ae3cab10cbcf1657af223e027c8210f6\":{\"balance\":\"0x6c6d84bccdd9ce0000\"},\"d02afecf8e2ec2b62ac8ad204161fd1fae771d0e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d0319139fbab2e8e2accc1d924d4b11df6696c5a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d037d215d11d1df3d54fbd321cd295c5465e273b\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"d03a2da41e868ed3fef5745b96f5eca462ff6fda\":{\"balance\":\"0xa2a15d09519be00000\"},\"d03fc165576aaed525e5502c8e140f8b2e869639\":{\"balance\":\"0x17356d8b32501c80000\"},\"d043a011ec4270ee7ec8b968737515e503f83028\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d04b861b3d9acc563a901689941ab1e1861161a2\":{\"balance\":\"0x1158e460913d00000\"},\"d05a447c911dbb275bfb2e5a37e5a703a56f9997\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d05ffb2b74f867204fe531653b0248e21c13544e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d062588171cf99bbeb58f126b870f9a3728d61ec\":{\"balance\":\"0xf3f20b8dfa69d00000\"},\"d0638ea57189a6a699024ad78c71d939c1c2ff8c\":{\"balance\":\"0x8eae566710fc200000\"},\"d0648a581b3508e135a2935d12c9657045d871ca\":{\"balance\":\"0x1b2df9d219f57980000\"},\"d071192966eb69c3520fca3aa4dd04297ea04b4e\":{\"balance\":\"0x5f68e8131ecf80000\"},\"d0718520eae0a4d62d70de1be0ca431c5eea2482\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d0775dba2af4c30a3a78365939cd71c2f9de95d2\":{\"balance\":\"0x692ae8897081d00000\"},\"d07be0f90997caf903c8ac1d53cde904fb190741\":{\"balance\":\"0x36389038b699b40000\"},\"d07e511864b1cf9969e3560602829e32fc4e71f5\":{\"balance\":\"0x2b5e3af16b1880000\"},\"d0809498c548047a1e2a2aa6a29cd61a0ee268bd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d082275f745a2cac0276fbdb02d4b2a3ab1711fe\":{\"balance\":\"0x1a055690d9db80000\"},\"d08fc09a0030fd0928cd321198580182a76aae9f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d093e829819fd2e25b973800bb3d5841dd152d05\":{\"balance\":\"0xd8d726b7177a800000\"},\"d0944aa185a1337061ae20dc9dd96c83b2ba4602\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d096565b7c7407d06536580355fdd6d239144aa1\":{\"balance\":\"0xd8d726b7177a80000\"},\"d09cb2e6082d693a13e8d2f68dd1dd8461f55840\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d0a6c6f9e9c4b383d716b31de78d56414de8fa91\":{\"balance\":\"0x1043561a8829300000\"},\"d0a7209b80cf60db62f57d0a5d7d521a69606655\":{\"balance\":\"0x8ac7230489e800000\"},\"d0a8abd80a199b54b08b65f01d209c27fef0115b\":{\"balance\":\"0x161c626dc61a2ef8000\"},\"d0abcc70c0420e0e172f97d43b87d5e80c336ea9\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"d0ae735d915e946866e1fea77e5ea466b5cadd16\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d0b11d6f2bce945e0c6a5020c3b52753f803f9d1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d0c101fd1f01c63f6b1d19bc920d9f932314b136\":{\"balance\":\"0x43c33c1937564800000\"},\"d0c55abf976fdc3db2afe9be99d499484d576c02\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d0d0a2ad45f59a9dccc695d85f25ca46ed31a5a3\":{\"balance\":\"0x2d89577d7d40200000\"},\"d0d62c47ea60fb90a3639209bbfdd4d933991cc6\":{\"balance\":\"0xa844a7424d9c80000\"},\"d0db456178206f5c4430fe005063903c3d7a49a7\":{\"balance\":\"0x26491e45a753c08000\"},\"d0e194f34b1db609288509ccd2e73b6131a2538b\":{\"balance\":\"0x36356633ebd8ea0000\"},\"d0e35e047646e759f4517093d6408642517f084d\":{\"balance\":\"0xd58fa46818eccb8000\"},\"d0ee4d02cf24382c3090d3e99560de3678735cdf\":{\"balance\":\"0x821ab0d44149800000\"},\"d0f04f52109aebec9a7b1e9332761e9fe2b97bb5\":{\"balance\":\"0xd8d726b7177a800000\"},\"d0f9597811b0b992bb7d3757aa25b4c2561d32e2\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d10302faa1929a326904d376bf0b8dc93ad04c4c\":{\"balance\":\"0x61093d7c2c6d380000\"},\"d1100dd00fe2ddf18163ad964d0b69f1f2e9658a\":{\"balance\":\"0x143120955b2506b0000\"},\"d116f3dcd5db744bd008887687aa0ec9fd7292aa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d119417c46732cf34d1a1afb79c3e7e2cd8eece4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d12d77ae01a92d35117bac705aacd982d02e74c1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d135794b149a18e147d16e621a6931f0a40a969a\":{\"balance\":\"0x43c33c1937564800000\"},\"d1432538e35b7664956ae495a32abdf041a7a21c\":{\"balance\":\"0x42bf06b78ed3b500000\"},\"d1438267231704fc7280d563adf4763844a80722\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d1538e9a87e59ca9ec8e5826a5b793f99f96c4c3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d1648503b1ccc5b8be03fa1ec4f3ee267e6adf7b\":{\"balance\":\"0x13befbf51eec0900000\"},\"d1682c2159018dc3d07f08240a8c606daf65f8e1\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"d171c3f2258aef35e599c7da1aa07300234da9a6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d1778c13fbd968bc083cb7d1024ffe1f49d02caa\":{\"balance\":\"0xd9ecb4fd208e500000\"},\"d17fbe22d90462ed37280670a2ea0b3086a0d6d6\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"d1811c55976980f083901d8a0db269222dfb5cfe\":{\"balance\":\"0x54069233bf7f780000\"},\"d18eb9e1d285dabe93e5d4bae76beefe43b521e8\":{\"balance\":\"0x243d4d18229ca20000\"},\"d193e583d6070563e7b862b9614a47e99489f3e5\":{\"balance\":\"0x36356633ebd8ea0000\"},\"d1978f2e34407fab1dc2183d95cfda6260b35982\":{\"balance\":\"0x2ab7b260ff3fd00000\"},\"d19caf39bb377fdf2cf19bd4fb52591c2631a63c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d1a396dcdab2c7494130b3fd307820340dfd8c1f\":{\"balance\":\"0xf92250e2dfd00000\"},\"d1a71b2d0858e83270085d95a3b1549650035e23\":{\"balance\":\"0x327bb09d06aa8500000\"},\"d1acb5adc1183973258d6b8524ffa28ffeb23de3\":{\"balance\":\"0xd8d726b7177a800000\"},\"d1b37f03cb107424e9c4dd575ccd4f4cee57e6cd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d1b5a454ac3405bb4179208c6c84de006bcb9be9\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d1c45954a62b911ad701ff2e90131e8ceb89c95c\":{\"balance\":\"0x4b91a2de457e880000\"},\"d1c96e70f05ae0e6cd6021b2083750a7717cde56\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d1d5b17ffe2d7bbb79cc7d7930bcb2e518fb1bbf\":{\"balance\":\"0xa2a15d09519be00000\"},\"d1da0c8fb7c210e0f2ec618f85bdae7d3e734b1c\":{\"balance\":\"0x6acb3df27e1f880000\"},\"d1dd79fb158160e5b4e8e23f312e6a907fbc4d4e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d1de5aad3a5fd803f1b1aeb6103cb8e14fe723b7\":{\"balance\":\"0x1158e460913d00000\"},\"d1e1f2b9c16c309874dee7fac32675aff129c398\":{\"balance\":\"0x3f24d8e4a00700000\"},\"d1e5e234a9f44266a4a6241a84d7a1a55ad5a7fe\":{\"balance\":\"0x43c33c1937564800000\"},\"d1ea4d72a67b5b3e0f315559f52bd0614d713069\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d1ee905957fe7cc70ec8f2868b43fe47b13febff\":{\"balance\":\"0x2629f66e0c5300000\"},\"d1f1694d22671b5aad6a94995c369fbe6133676f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d1f4dc1ddb8abb8848a8b14e25f3b55a8591c266\":{\"balance\":\"0xd8d726b7177a80000\"},\"d1fed0aee6f5dfd7e25769254c3cfad15adeccaa\":{\"balance\":\"0x2792c8fc4b53280000\"},\"d2051cb3cb6704f0548cc890ab0a19db3415b42a\":{\"balance\":\"0x121b2e5e6464780000\"},\"d206aaddb336d45e7972e93cb075471d15897b5d\":{\"balance\":\"0x2086ac351052600000\"},\"d209482bb549abc4777bea6d7f650062c9c57a1c\":{\"balance\":\"0x11651ac3e7a7580000\"},\"d20dcb0b78682b94bc3000281448d557a20bfc83\":{\"balance\":\"0x30849ebe16369c0000\"},\"d2107b353726c3a2b46566eaa7d9f80b5d21dbe3\":{\"balance\":\"0x1158e460913d00000\"},\"d211b21f1b12b5096181590de07ef81a89537ead\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d218efb4db981cdd6a797f4bd48c7c26293ceb40\":{\"balance\":\"0xa1466b31c6431c0000\"},\"d21a7341eb84fd151054e5e387bb25d36e499c09\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"d224f880f9479a89d32f09e52be990b288135cef\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"d22f0ca4cd479e661775053bcc49e390f670dd8a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d231929735132102471ba59007b6644cc0c1de3e\":{\"balance\":\"0x3637096c4bcc690000\"},\"d235d15cb5eceebb61299e0e827fa82748911d89\":{\"balance\":\"0xd8d726b7177a800000\"},\"d23a24d7f9468343c143a41d73b88f7cbe63be5e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d23d7affacdc3e9f3dae7afcb4006f58f8a44600\":{\"balance\":\"0xc328093e61ee400000\"},\"d243184c801e5d79d2063f3578dbae81e7b3a9cb\":{\"balance\":\"0x6bdca2681e1aba0000\"},\"d24b6644f439c8051dfc64d381b8c86c75c17538\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d24bf12d2ddf457decb17874efde2052b65cbb49\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"d251f903ae18727259eee841a189a1f569a5fd76\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"d252960b0bf6b2848fdead80136db5f507f8be02\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d2581a55ce23ab10d8ad8c44378f59079bd6f658\":{\"balance\":\"0x1dd0c885f9a0d800000\"},\"d25aecd7eb8bd6345b063b5dbd271c77d3514494\":{\"balance\":\"0x62a992e53a0af00000\"},\"d27c234ff7accace3d996708f8f9b04970f97d36\":{\"balance\":\"0x487a9a304539440000\"},\"d28298524df5ec4b24b0ffb9df85170a145a9eb5\":{\"balance\":\"0xf98a3b9b337e20000\"},\"d283b8edb10a25528a4404de1c65e7410dbcaa67\":{\"balance\":\"0x28a857425466f800000\"},\"d284a50382f83a616d39b8a9c0f396e0ebbfa95d\":{\"balance\":\"0x3636c25e66ece70000\"},\"d288e7cb7ba9f620ab0f7452e508633d1c5aa276\":{\"balance\":\"0xd8d726b7177a800000\"},\"d29dc08efbb3d72e263f78ab7610d0226de76b00\":{\"balance\":\"0x28a857425466f800000\"},\"d2a030ac8952325f9e1db378a71485a24e1b07b2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d2a479404347c5543aab292ae1bb4a6f158357fa\":{\"balance\":\"0xd8d726b7177a800000\"},\"d2a5a024230a57ccc666760b89b0e26cafd189c7\":{\"balance\":\"0xa96595a5c6e8a3f8000\"},\"d2a80327cbe55c4c7bd51ff9dde4ca648f9eb3f8\":{\"balance\":\"0x2b5e3af16b1880000\"},\"d2a84f75675c62d80c88756c428eee2bcb185421\":{\"balance\":\"0x410d586a20a4c00000\"},\"d2abd84a181093e5e229136f42d835e8235de109\":{\"balance\":\"0x56be03ca3e47d8000\"},\"d2ac0d3a58605e1d0f0eb3de25b2cad129ed6058\":{\"balance\":\"0xd8d726b7177a800000\"},\"d2bf67a7f3c6ce56b7be41675dbbadfe7ea93a33\":{\"balance\":\"0x15af1d78b58c400000\"},\"d2dbebe89b0357aea98bbe8e496338debb28e805\":{\"balance\":\"0xd8d726b7177a800000\"},\"d2e21ed56868fab28e0947927adaf29f23ebad6c\":{\"balance\":\"0x6c184f1355d0e80000\"},\"d2e817738abf1fb486583f80c350318bed860c80\":{\"balance\":\"0xd02cecf5f5d810000\"},\"d2edd1ddd6d86dc005baeb541d22b640d5c7cae5\":{\"balance\":\"0x1158e460913d00000\"},\"d2f1998e1cb1580cec4f6c047dcd3dcec54cf73c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d2f241255dd7c3f73c07043071ec08ddd9c5cde5\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d2ff672016f63b2f85398f4a6fedbb60a50d3cce\":{\"balance\":\"0x1291246f5b734a0000\"},\"d30d4c43adcf55b2cb53d68323264134498d89ce\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d30ee9a12b4d68abace6baca9ad7bf5cd1faf91c\":{\"balance\":\"0x514fcb24ff9c500000\"},\"d3118ea3c83505a9d893bb67e2de142d537a3ee7\":{\"balance\":\"0x1158e460913d00000\"},\"d311bcd7aa4e9b4f383ff3d0d6b6e07e21e3705d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d315deea1d8c1271f9d1311263ab47c007afb6f5\":{\"balance\":\"0x3c81d4e654b400000\"},\"d32b2c79c36478c5431901f6d700b04dbe9b8810\":{\"balance\":\"0x15779a9de6eeb00000\"},\"d32b45564614516c91b07fa9f72dcf787cce4e1c\":{\"balance\":\"0xfc66fae3746ac0000\"},\"d330728131fe8e3a15487a34573c93457e2afe95\":{\"balance\":\"0xd8d726b7177a800000\"},\"d331c823825a9e5263d052d8915d4dcde07a5c37\":{\"balance\":\"0x1e931283ccc8500000\"},\"d333627445f2d787901ef33bb2a8a3675e27ffec\":{\"balance\":\"0x15af1d78b58c400000\"},\"d33cf82bf14c592640a08608914c237079d5be34\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d34d708d7398024533a5a2b2309b19d3c55171bb\":{\"balance\":\"0x15af1d78b58c400000\"},\"d34e03d36a2bd4d19a5fa16218d1d61e3ffa0b15\":{\"balance\":\"0x1158e460913d000000\"},\"d35075ca61fe59d123969c36a82d1ab2d918aa38\":{\"balance\":\"0x90f534608a72880000\"},\"d367009ab658263b62c2333a1c9e4140498e1389\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d3679a47df2d99a49b01c98d1c3e0c987ce1e158\":{\"balance\":\"0xf2dc7d47f15600000\"},\"d38fa2c4cc147ad06ad5a2f75579281f22a7cc1f\":{\"balance\":\"0x43c33c1937564800000\"},\"d39a5da460392b940b3c69bc03757bf3f2e82489\":{\"balance\":\"0x17c83a97d6b6ca50000\"},\"d39b7cbc94003fc948f0cde27b100db8ccd6e063\":{\"balance\":\"0x15af1d78b58c400000\"},\"d3a10ec7a5c9324999dd9e9b6bde7c911e584bda\":{\"balance\":\"0x2086ac351052600000\"},\"d3a941c961e8ca8b1070f23c6d6d0d2a758a4444\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d3bb59fa31258be62f8ed232f1a7d47b4a0b41ee\":{\"balance\":\"0x56bc75e2d63100000\"},\"d3bc730937fa75d8452616ad1ef1fe7fffe0d0e7\":{\"balance\":\"0x484e4ded2eae38000\"},\"d3c24d4b3a5e0ff8a4622d518edd73f16ab28610\":{\"balance\":\"0x1158e460913d00000\"},\"d3c6f1e0f50ec3d2a67e6bcd193ec7ae38f1657f\":{\"balance\":\"0x166c5480889db770000\"},\"d3d6e9fb82542fd29ed9ea3609891e151396b6f7\":{\"balance\":\"0xb6f588aa7bcf5c00000\"},\"d3dad1b6d08d4581ccae65a8732db6ac69f0c69e\":{\"balance\":\"0x14542ba12a337c00000\"},\"d3df3b53cb3b4755de54e180451cc44c9e8ae0aa\":{\"balance\":\"0x23c49409b977828000\"},\"d3f873bd9956135789ab00ebc195b922e94b259d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d402b4f6a099ebe716cb14df4f79c0cd01c6071b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d40d0055fd9a38488aff923fd03d35ec46d711b3\":{\"balance\":\"0x10f08eda8e555098000\"},\"d40ed66ab3ceff24ca05ecd471efb492c15f5ffa\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d418870bc2e4fa7b8a6121ae0872d55247b62501\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"d41d7fb49fe701baac257170426cc9b38ca3a9b2\":{\"balance\":\"0x98a7d9b8314c00000\"},\"d4205592844055b3c7a1f80cefe3b8eb509bcde7\":{\"balance\":\"0x9b3bfd342a9fc8000\"},\"d42b20bd0311608b66f8a6d15b2a95e6de27c5bf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d4344f7d5cad65d17e5c2d0e7323943d6f62fe92\":{\"balance\":\"0xe7eeba3410b740000\"},\"d43ee438d83de9a37562bb4e286cb1bd19f4964d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d44334b4e23a169a0c16bd21e866bba52d970587\":{\"balance\":\"0x8cf23f909c0fa00000\"},\"d44d81e18f46e2cfb5c1fcf5041bc8569767d100\":{\"balance\":\"0x7b442e684f65aa40000\"},\"d44f4ac5fad76bdc1537a3b3af6472319b410d9d\":{\"balance\":\"0x56bc75e2d631000000\"},\"d44f5edf2bcf2433f211dadd0cc450db1b008e14\":{\"balance\":\"0xe7eeba3410b740000\"},\"d44f6ac3923b5fd731a4c45944ec4f7ec52a6ae4\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"d45b3341e8f15c80329320c3977e3b90e7826a7e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d45d5daa138dd1d374c71b9019916811f4b20a4e\":{\"balance\":\"0x1f399b1438a1000000\"},\"d460a4b908dd2b056759b488850b66a838fc77a8\":{\"balance\":\"0x6acb3df27e1f880000\"},\"d467cf064c0871989b90d8b2eb14ccc63b360823\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d46bae61b027e5bb422e83a3f9c93f3c8fc77d27\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d46f8223452982a1eea019a8816efc2d6fc00768\":{\"balance\":\"0x76d41c62494840000\"},\"d475477fa56390d33017518d6711027f05f28dbf\":{\"balance\":\"0x6b111333d4fd4c0000\"},\"d47c242edffea091bc54d57df5d1fdb93101476c\":{\"balance\":\"0x9df7dfa8f760480000\"},\"d47d8685faee147c520fd986709175bf2f886bef\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d47f50df89a1cff96513bef1b2ae3a2971accf2c\":{\"balance\":\"0x2d89577d7d40200000\"},\"d482e7f68e41f238fe517829de15477fe0f6dd1d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d4879fd12b1f3a27f7e109761b23ca343c48e3d8\":{\"balance\":\"0x241a9b4f617a280000\"},\"d48e3f9357e303513841b3f84bda83fc89727587\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d49a75bb933fca1fca9aa1303a64b6cb44ea30e1\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"d4b085fb086f3d0d68bf12926b1cc3142cae8770\":{\"balance\":\"0xc893d09c8f51500000\"},\"d4b2ff3bae1993ffea4d3b180231da439f7502a2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d4b38a5fdb63e01714e9801db47bc990bd509183\":{\"balance\":\"0x14534d95bef905c0000\"},\"d4b8bdf3df9a51b0b91d16abbea05bb4783c8661\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d4c4d1a7c3c74984f6857b2f5f07e8face68056d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d4c6ac742e7c857d4a05a04c33d4d05c1467571d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d4cb21e590c5a0e06801366aff342c7d7db16424\":{\"balance\":\"0x1ac7a08ead02f80000\"},\"d4d92c62b280e00f626d8657f1b86166cb1f740f\":{\"balance\":\"0xad7f23634cbd60000\"},\"d4ebb1929a23871cf77fe049ab9602be08be0a73\":{\"balance\":\"0x678a932062e4180000\"},\"d4ee4919fb37f2bb970c3fff54aaf1f3dda6c03f\":{\"balance\":\"0x878678326eac9000000\"},\"d4feed99e8917c5c5458635f3603ecb7e817a7d0\":{\"balance\":\"0x1043c43cde1d398000\"},\"d4ff46203efa23064b1caf00516e28704a82a4f8\":{\"balance\":\"0x487a9a304539440000\"},\"d500e4d1c9824ba9f5b635cfa3a8c2c38bbd4ced\":{\"balance\":\"0x15af1d78b58c400000\"},\"d508d39c70916f6abc4cc7f999f011f077105802\":{\"balance\":\"0x5724d24afe77f0000\"},\"d50f7fa03e389876d3908b60a537a6706304fb56\":{\"balance\":\"0x56bc75e2d63100000\"},\"d513a45080ff2febe62cd5854abe29ee4467f996\":{\"balance\":\"0x84e13bc4fc5d80000\"},\"d5276f0cd5ffd5ffb63f98b5703d5594ede0838b\":{\"balance\":\"0x15af1d78b58c400000\"},\"d5294b666242303b6df0b1c88d37429bc8c965aa\":{\"balance\":\"0x104d0d00d2b7f60000\"},\"d52aecc6493938a28ca1c367b701c21598b6a02e\":{\"balance\":\"0x3ba1910bf341b00000\"},\"d53c567f0c3ff2e08b7d59e2b5c73485437fc58d\":{\"balance\":\"0x2086ac351052600000\"},\"d541ac187ad7e090522de6da3213e9a7f4439673\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d54ba2d85681dc130e5b9b02c4e8c851391fd9b9\":{\"balance\":\"0xd5967be4fc3f100000\"},\"d55508adbbbe9be81b80f97a6ea89add68da674f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d5550caaf743b037c56fd2558a1c8ed235130750\":{\"balance\":\"0x121e4d49036255b0000\"},\"d5586da4e59583c8d86cccf71a86197f17996749\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d55c1c8dfbe1e02cacbca60fdbdd405b09f0b75f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d561cbbc05515de73ab8cf9eae1357341e7dfdf4\":{\"balance\":\"0x14542ba12a337c00000\"},\"d56a144d7af0ae8df649abae535a15983aa04d02\":{\"balance\":\"0x10f0cf064dd59200000\"},\"d572309169b1402ec8131a17a6aac3222f89e6eb\":{\"balance\":\"0x2ec1978c47766a00000\"},\"d5787668c2c5175b01a8ee1ac3ecc9c8b2aba95a\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"d588c3a5df228185d98ee7e60748255cdea68b01\":{\"balance\":\"0xd8d726b7177a800000\"},\"d58a52e078a805596b0d56ea4ae1335af01c66eb\":{\"balance\":\"0xe7eeba3410b740000\"},\"d5903e9978ee20a38c3f498d63d57f31a39f6a06\":{\"balance\":\"0x232b36ffc672ab00000\"},\"d59638d3c5faa7711bf085745f9d5bdc23d498d8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d59d92d2c8701980cc073c375d720af064743c0c\":{\"balance\":\"0x405fdf7e5af85e00000\"},\"d5a7bec332adde18b3104b5792546aa59b879b52\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d5b117ec116eb846418961eb7edb629cd0dd697f\":{\"balance\":\"0xa2a15d09519be00000\"},\"d5b284040130abf7c1d163712371cc7e28ad66da\":{\"balance\":\"0x6acb3df27e1f880000\"},\"d5b9d277d8aad20697a51f76e20978996bffe055\":{\"balance\":\"0x7c3fe3c076ab50000\"},\"d5bd5e8455c130169357c471e3e681b7996a7276\":{\"balance\":\"0x2d9e288f8abb360000\"},\"d5cba5b26bea5d73fabb1abafacdef85def368cc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d5ce55d1b62f59433c2126bcec09bafc9dfaa514\":{\"balance\":\"0xaadec983fcff40000\"},\"d5e55100fbd1956bbed2ca518d4b1fa376032b0b\":{\"balance\":\"0x56bc75e2d63100000\"},\"d5e5c135d0c4c3303934711993d0d16ff9e7baa0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d5e656a1b916f9bf45afb07dd8afaf73b4c56f41\":{\"balance\":\"0x542253a126ce40000\"},\"d5ea472cb9466018110af00c37495b5c2c713112\":{\"balance\":\"0x10eee686c854f440000\"},\"d5f07552b5c693c20067b378b809cee853b8f136\":{\"balance\":\"0x1b67c6df88c6fa0000\"},\"d5f7c41e07729dfa6dfc64c4423160a22c609fd3\":{\"balance\":\"0x61093d7c2c6d380000\"},\"d604abce4330842e3d396ca73ddb5519ed3ec03f\":{\"balance\":\"0x8e31fe1689d8a0000\"},\"d60651e393783423e5cc1bc5f889e44ef7ea243e\":{\"balance\":\"0x159e76371129c80000\"},\"d609bf4f146eea6b0dc8e06ddcf4448a1fccc9fa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d609ec0be70d0ad26f6e67c9d4762b52ee51122c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d60a52580728520df7546bc1e283291788dbae0c\":{\"balance\":\"0x363489ef3ff0d70000\"},\"d60b247321a32a5affb96b1e279927cc584de943\":{\"balance\":\"0x7ad020d6ddd7760000\"},\"d6110276cfe31e42825a577f6b435dbcc10cf764\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d612597bc31743c78633f633f239b1e9426bd925\":{\"balance\":\"0x1017f7df96be17800000\"},\"d6234aaf45c6f22e66a225ffb93add629b4ef80f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d62edb96fce2969aaf6c545e967cf1c0bc805205\":{\"balance\":\"0x4a565536a5ada8000\"},\"d6300b3215b11de762ecde4b70b7927d01291582\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d6395db5a4bb66e60f4cfbcdf0057bb4d97862e2\":{\"balance\":\"0x3154c9729d05780000\"},\"d64a2d50f8858537188a24e0f50df1681ab07ed7\":{\"balance\":\"0x8375a2abcca24400000\"},\"d6580ab5ed4c7dfa506fa6fe64ad5ce129707732\":{\"balance\":\"0xd8d726b7177a800000\"},\"d6598b1386e93c5ccb9602ff4bbbecdbd3701dc4\":{\"balance\":\"0xc25f4ecb041f00000\"},\"d6644d40e90bc97fe7dfe7cabd3269fd579ba4b3\":{\"balance\":\"0x89e917994f71c0000\"},\"d6670c036df754be43dadd8f50feea289d061fd6\":{\"balance\":\"0x144a2903448cef78000\"},\"d668523a90f0293d65c538d2dd6c57673710196e\":{\"balance\":\"0x2242c30b853ee0000\"},\"d66ab79294074c8b627d842dab41e17dd70c5de5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d66acc0d11b689cea6d9ea5ff4014c224a5dc7c4\":{\"balance\":\"0xfc936392801c0000\"},\"d66ddf1159cf22fd8c7a4bc8d5807756d433c43e\":{\"balance\":\"0x77432217e683600000\"},\"d687cec0059087fdc713d4d2d65e77daefedc15f\":{\"balance\":\"0x340aad21b3b700000\"},\"d688e785c98f00f84b3aa1533355c7a258e87948\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"d6a22e598dabd38ea6e958bd79d48ddd9604f4df\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d6a7ac4de7b510f0e8de519d973fa4c01ba83400\":{\"balance\":\"0x65ea3db75546600000\"},\"d6acc220ba2e51dfcf21d443361eea765cbd35d8\":{\"balance\":\"0x1158e460913d00000\"},\"d6acffd0bfd99c382e7bd56ff0e6144a9e52b08e\":{\"balance\":\"0x8ac7230489e800000\"},\"d6c0d0bc93a62e257174700e10f024c8b23f1f87\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d6cf5c1bcf9da662bcea2255905099f9d6e84dcc\":{\"balance\":\"0x1c49e420157d9c20000\"},\"d6d03572a45245dbd4368c4f82c95714bd2167e2\":{\"balance\":\"0x3f00c3d66686fc0000\"},\"d6d6776958ee23143a81adadeb08382009e996c2\":{\"balance\":\"0xa2a15d09519be00000\"},\"d6d9e30f0842012a7176a917d9d2048ca0738759\":{\"balance\":\"0xd8d726b7177a800000\"},\"d6e09e98fe1300332104c1ca34fbfac554364ed9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d6e8e97ae9839b9ee507eedb28edfb7477031439\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d6eea898d4ae2b718027a19ce9a5eb7300abe3ca\":{\"balance\":\"0x17d4aceee63db8000\"},\"d6f1e55b1694089ebcb4fe7d7882aa66c8976176\":{\"balance\":\"0x43c23bdbe929db30000\"},\"d6f4a7d04e8faf20e8c6eb859cf7f78dd23d7a15\":{\"balance\":\"0x724ded1c748140000\"},\"d6fc0446c6a8d40ae3551db7e701d1fa876e4a49\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d703c6a4f11d60194579d58c2766a7ef16c30a29\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d7052519756af42590f15391b723a03fa564a951\":{\"balance\":\"0xfa3631480d01fd8000\"},\"d70a612bd6dda9eab0dddcff4aaf4122d38feae4\":{\"balance\":\"0x1d460162f516f00000\"},\"d70ad2c4e9eebfa637ef56bd486ad2a1e5bce093\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d7140c8e5a4307fab0cc27badd9295018bf87970\":{\"balance\":\"0x5f1016b5076d00000\"},\"d7164aa261c09ad9b2b5068d453ed8eb6aa13083\":{\"balance\":\"0xa2a15d09519be00000\"},\"d71e43a45177ad51cbe0f72184a5cb503917285a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d71fb130f0150c565269e00efb43902b52a455a6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d7225738dcf3578438f8e7c8b3837e42e04a262f\":{\"balance\":\"0x182b8cebbb83aa0000\"},\"d7274d50804d9c77da93fa480156efe57ba501de\":{\"balance\":\"0x692ae8897081d00000\"},\"d731bb6b5f3c37395e09ceaccd14a918a6060789\":{\"balance\":\"0xd5967be4fc3f100000\"},\"d73ed2d985b5f21b55b274643bc6da031d8edd8d\":{\"balance\":\"0xa6dd90cae5114480000\"},\"d744ac7e5310be696a63b003c40bd039370561c6\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"d74a6e8d6aab34ce85976814c1327bd6ea0784d2\":{\"balance\":\"0x152d02c7e14af6800000\"},\"d75a502a5b677287470f65c5aa51b87c10150572\":{\"balance\":\"0x3130b4646385740000\"},\"d76dbaebc30d4ef67b03e6e6ecc6d84e004d502d\":{\"balance\":\"0x6d76b9188e13850000\"},\"d771d9e0ca8a08a113775731434eb3270599c40d\":{\"balance\":\"0x1158e460913d00000\"},\"d7788ef28658aa06cc53e1f3f0de58e5c371be78\":{\"balance\":\"0x16a6502f15a1e540000\"},\"d77892e2273b235d7689e430e7aeed9cbce8a1f3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d781f7fc09184611568570b4986e2c72872b7ed0\":{\"balance\":\"0x1159561065d5d0000\"},\"d785a8f18c38b9bc4ffb9b8fa8c7727bd642ee1c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d78ecd25adc86bc2051d96f65364866b42a426b7\":{\"balance\":\"0xd23058bf2f26120000\"},\"d78f84e38944a0e0255faece48ba4950d4bd39d2\":{\"balance\":\"0x10f0cf064dd59200000\"},\"d79483f6a8444f2549d611afe02c432d15e11051\":{\"balance\":\"0x1158e460913d00000\"},\"d79835e404fb86bf845fba090d6ba25e0c8866a6\":{\"balance\":\"0x821ab0d44149800000\"},\"d79aff13ba2da75d46240cac0a2467c656949823\":{\"balance\":\"0x5dc892aa1131c80000\"},\"d79db5ab43621a7a3da795e58929f3dd25af67d9\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"d7a1431ee453d1e49a0550d1256879b4f5d10201\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"d7ad09c6d32657685355b5c6ec8e9f57b4ebb982\":{\"balance\":\"0x6acb3df27e1f880000\"},\"d7b740dff8c457668fdf74f6a266bfc1dcb723f9\":{\"balance\":\"0x1158e460913d00000\"},\"d7c2803ed7b0e0837351411a8e6637d168bc5b05\":{\"balance\":\"0x641daf5c91bd9358000\"},\"d7c6265dea11876c903b718e4cd8ab24fe265bde\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d7ca7fdcfebe4588eff5421d1522b61328df7bf3\":{\"balance\":\"0xd8e6001e6c302b0000\"},\"d7cdbd41fff20df727c70b6255c1ba7606055468\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d7d157e4c0a96437a6d285741dd23ec4361fa36b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d7d2c6fca8ad1f75395210b57de5dfd673933909\":{\"balance\":\"0x126e72a69a50d00000\"},\"d7d3c75920590438b82c3e9515be2eb6ed7a8b1a\":{\"balance\":\"0xcb49b44ba602d800000\"},\"d7d7f2caa462a41b3b30a34aeb3ba61010e2626f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d7e74afdbad55e96cebc5a374f2c8b768680f2b0\":{\"balance\":\"0x55de6a779bbac0000\"},\"d7eb903162271c1afa35fe69e37322c8a4d29b11\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"d7ebddb9f93987779b680155375438db65afcb6a\":{\"balance\":\"0x5741afeff944c0000\"},\"d7ef340e66b0d7afcce20a19cb7bfc81da33d94e\":{\"balance\":\"0xa2a15d09519be00000\"},\"d7f370d4bed9d57c6f49c999de729ee569d3f4e4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d7fa5ffb6048f96fb1aba09ef87b1c11dd7005e4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d8069f84b521493f4715037f3226b25f33b60586\":{\"balance\":\"0x678a932062e4180000\"},\"d815e1d9f4e2b5e57e34826b7cfd8881b8546890\":{\"balance\":\"0xf015f25736420000\"},\"d81bd54ba2c44a6f6beb1561d68b80b5444e6dc6\":{\"balance\":\"0x3f170d7ee43c430000\"},\"d82251456dc1380f8f5692f962828640ab9f2a03\":{\"balance\":\"0x1088b53b2c202be0000\"},\"d82c6fedbdac98af2eed10b00f32b00056ca5a6d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d82fd9fdf6996bedad2843159c06f37e0924337d\":{\"balance\":\"0x5b8ccedc5aa7b00000\"},\"d83ad260e9a6f432fb6ea28743299b4a09ad658c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d843ee0863ce933e22f89c802d31287b9671e81c\":{\"balance\":\"0xb98bc829a6f90000\"},\"d84b922f7841fc5774f00e14604ae0df42c8551e\":{\"balance\":\"0xd96fce90cfabcc0000\"},\"d855b03ccb029a7747b1f07303e0a664793539c8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d85fdeaf2a61f95db902f9b5a53c9b8f9266c3ac\":{\"balance\":\"0x6cf65a7e9047280000\"},\"d8715ef9176f850b2e30eb8e382707f777a6fbe9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d874b9dfae456a929ba3b1a27e572c9b2cecdfb3\":{\"balance\":\"0x93739534d28680000\"},\"d8930a39c77357c30ad3a060f00b06046331fd62\":{\"balance\":\"0x2c73c937742c500000\"},\"d89bc271b27ba3ab6962c94a559006ae38d5f56a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d8b77db9b81bbe90427b62f702b201ffc29ff618\":{\"balance\":\"0x326d1e4396d45c0000\"},\"d8cd64e0284eec53aa4639afc4750810b97fab56\":{\"balance\":\"0x1158e460913d00000\"},\"d8d64384249b776794063b569878d5e3b530a4b2\":{\"balance\":\"0x9a043d0b2f9568000\"},\"d8d65420c18c2327cc5af97425f857e4a9fd51b3\":{\"balance\":\"0x5f68e8131ecf800000\"},\"d8e5c9675ef4deed266b86956fc4590ea7d4a27d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d8e8474292e7a051604ca164c0707783bb2885e8\":{\"balance\":\"0x2d4ca05e2b43ca80000\"},\"d8eb78503ec31a54a90136781ae109004c743257\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d8eef4cf4beb01ee20d111748b61cb4d3f641a01\":{\"balance\":\"0x9489237adb9a500000\"},\"d8f4bae6f84d910d6d7d5ac914b1e68372f94135\":{\"balance\":\"0x56bc75e2d63100000\"},\"d8f62036f03b7635b858f1103f8a1d9019a892b6\":{\"balance\":\"0x2b5e3af16b1880000\"},\"d8f665fd8cd5c2bcc6ddc0a8ae521e4dc6aa6060\":{\"balance\":\"0x5c283d410394100000\"},\"d8f9240c55cff035523c6d5bd300d370dc8f0c95\":{\"balance\":\"0xf732b66015a540000\"},\"d8f94579496725b5cb53d7985c989749aff849c0\":{\"balance\":\"0x39992648a23c8a00000\"},\"d8fdf546674738c984d8fab857880b3e4280c09e\":{\"balance\":\"0x1158e460913d00000\"},\"d8fe088fffce948f5137ee23b01d959e84ac4223\":{\"balance\":\"0xc5b54a94fc0170000\"},\"d90f3009db437e4e11c780bec8896f738d65ef0d\":{\"balance\":\"0xd8d726b7177a800000\"},\"d9103bb6b67a55a7fece2d1af62d457c2178946d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d913f0771949753c4726acaa2bd3619c5c20ff77\":{\"balance\":\"0xa2a15d09519be00000\"},\"d91d889164479ce436ece51763e22cda19b22d6b\":{\"balance\":\"0xb66d88126800880000\"},\"d929c65d69d5bbaea59762662ef418bc21ad924a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d930b27a78876485d0f48b70dd5336549679ca8f\":{\"balance\":\"0x22b1c8c1227a00000\"},\"d931ac2668ba6a84481ab139735aec14b7bfbabf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d9383d4b6d17b3f9cd426e10fb944015c0d44bfb\":{\"balance\":\"0x2b5e3af16b18800000\"},\"d942de4784f7a48716c0fd4b9d54a6e54c5f2f3e\":{\"balance\":\"0x43c33c1937564800000\"},\"d944c8a69ff2ca1249690c1229c7192f36251062\":{\"balance\":\"0x6acb3df27e1f880000\"},\"d94a57882a52739bbe2a0647c80c24f58a2b4f1c\":{\"balance\":\"0x48b54e2adbe12b0000\"},\"d95342953c8a21e8b635eefac7819bea30f17047\":{\"balance\":\"0x13f06c7ffef05d400000\"},\"d95c90ffbe5484864780b867494a83c89256d6e4\":{\"balance\":\"0x58e7926ee858a00000\"},\"d96711540e2e998343d4f590b6fc8fac3bb8b31d\":{\"balance\":\"0x5f5a4068b71cb00000\"},\"d96ac2507409c7a383ab2eee1822a5d738b36b56\":{\"balance\":\"0xad78ebc5ac6200000\"},\"d96db33b7b5a950c3efa2dc31b10ba10a532ef87\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d9775965b716476675a8d513eb14bbf7b07cd14a\":{\"balance\":\"0x1132e6d2d23c5e40000\"},\"d97bc84abd47c05bbf457b2ef659d61ca5e5e48f\":{\"balance\":\"0x69d17119dc5a80000\"},\"d97f4526dea9b163f8e8e33a6bcf92fb907de6ec\":{\"balance\":\"0xf654aaf4db2f00000\"},\"d97fe6f53f2a58f6d76d752adf74a8a2c18e9074\":{\"balance\":\"0x10cdf9b69a43570000\"},\"d99999a2490d9494a530cae4daf38554f4dd633e\":{\"balance\":\"0x68155a43676e00000\"},\"d99df7421b9382e42c89b006c7f087702a0757c0\":{\"balance\":\"0x1a055690d9db800000\"},\"d9b783d31d32adc50fa3eacaa15d92b568eaeb47\":{\"balance\":\"0x733af90374c1b280000\"},\"d9d370fec63576ab15b318bf9e58364dc2a3552a\":{\"balance\":\"0x56bc75e2d63100000\"},\"d9d42fd13ebd4bf69cac5e9c7e82483ab46dd7e9\":{\"balance\":\"0x121ea68c114e5100000\"},\"d9e27eb07dfc71a706060c7f079238ca93e88539\":{\"balance\":\"0x3635c9adc5dea00000\"},\"d9e3857efd1e202a441770a777a49dcc45e2e0d3\":{\"balance\":\"0xc1daf81d8a3ce0000\"},\"d9ec2efe99ff5cf00d03a8317b92a24aef441f7e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"d9ec8fe69b7716c0865af888a11b2b12f720ed33\":{\"balance\":\"0xd8d726b7177a800000\"},\"d9f1b26408f0ec67ad1d0d6fe22e8515e1740624\":{\"balance\":\"0x14d1120d7b1600000\"},\"d9f547f2c1de0ed98a53d161df57635dd21a00bd\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"d9ff115d01266c9f73b063c1c238ef3565e63b36\":{\"balance\":\"0x24dce54d34a1a00000\"},\"da06044e293c652c467fe74146bf185b21338a1c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"da0b48e489d302b4b7bf204f957c1c9be383b0df\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"da0d4b7ef91fb55ad265f251142067f10376ced6\":{\"balance\":\"0x43c33c1937564800000\"},\"da10978a39a46ff0bb848cf65dd9c77509a6d70e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"da16dd5c3d1a2714358fe3752cae53dbab2be98c\":{\"balance\":\"0x41bad155e6512200000\"},\"da214c023e2326ff696c00393168ce46ffac39ec\":{\"balance\":\"0x3635c9adc5dea00000\"},\"da2a14f9724015d79014ed8e5909681d596148f1\":{\"balance\":\"0x2a10f0f8a91ab8000\"},\"da2ad58e77deddede2187646c465945a8dc3f641\":{\"balance\":\"0x23c757072b8dd00000\"},\"da3017c150dd0dce7fcf881b0a48d0d1c756c4c7\":{\"balance\":\"0x56bf91b1a65eb0000\"},\"da34b2eae30bafe8daeccde819a794cd89e09549\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"da4a5f557f3bab390a92f49b9b900af30c46ae80\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"da505537537ffb33c415fec64e69bae090c5f60f\":{\"balance\":\"0x8ac7230489e800000\"},\"da698d64c65c7f2b2c7253059cd3d181d899b6b7\":{\"balance\":\"0x1004e2e45fb7ee0000\"},\"da7732f02f2e272eaf28df972ecc0ddeed9cf498\":{\"balance\":\"0xb20bfbf6967890000\"},\"da7ad025ebde25d22243cb830ea1d3f64a566323\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"da855d53477f505ec4c8d5e8bb9180d38681119c\":{\"balance\":\"0x12f939c99edab800000\"},\"da875e4e2f3cabe4f37e0eaed7d1f6dcc6ffef43\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"da8bbee182e455d2098acb338a6d45b4b17ed8b6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"da982e9643ffece723075a40fe776e5ace04b29b\":{\"balance\":\"0x8b8b6c9999bf20000\"},\"da9f55460946d7bfb570ddec757ca5773b58429a\":{\"balance\":\"0x1b845d769eb4480000\"},\"daa1bd7a9148fb865cd612dd35f162861d0f3bdc\":{\"balance\":\"0xa638ab72d92c138000\"},\"daa63cbda45dd487a3f1cd4a746a01bb5e060b90\":{\"balance\":\"0x10416d9b02a89240000\"},\"daa776a6754469d7b9267a89b86725e740da0fa0\":{\"balance\":\"0x6acb3df27e1f880000\"},\"daac91c1e859d5e57ed3084b50200f9766e2c52b\":{\"balance\":\"0x15af1d78b58c400000\"},\"daacdaf42226d15cb1cf98fa15048c7f4ceefe69\":{\"balance\":\"0x1043561a8829300000\"},\"dab6bcdb83cf24a0ae1cb21b3b5b83c2f3824927\":{\"balance\":\"0xa968163f0a57b400000\"},\"dabb0889fc042926b05ef57b2520910abc4b4149\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dabc225042a6592cfa13ebe54efa41040878a5a2\":{\"balance\":\"0xe11fad5d85ca30000\"},\"dac0c177f11c5c3e3e78f2efd663d13221488574\":{\"balance\":\"0x3635c9adc5dea00000\"},\"dad136b88178b4837a6c780feba226b98569a94c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dadbfafd8b62b92a24efd75256dd83abdbd7bbdb\":{\"balance\":\"0x11164759ffb320000\"},\"dadc00ab7927603c2fcf31cee352f80e6c4d6351\":{\"balance\":\"0x6c66e9a55378b80000\"},\"dae0d33eaa341569fa9ff5982684854a4a328a6e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"dae7201eab8c063302930d693929d07f95e71962\":{\"balance\":\"0x91aec028b419810000\"},\"daedd4ad107b271e89486cbf80ebd621dd974578\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"db04fad9c49f9e880beb8fcf1d3a3890e4b3846f\":{\"balance\":\"0x435ae6cc0c58e50000\"},\"db0cc78f74d9827bdc8a6473276eb84fdc976212\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"db1293a506e90cad2a59e1b8561f5e66961a6788\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"db19a3982230368f0177219cb10cb259cdb2257c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"db23a6fef1af7b581e772cf91882deb2516fc0a7\":{\"balance\":\"0xad78ebc5ac6200000\"},\"db244f97d9c44b158a40ed9606d9f7bd38913331\":{\"balance\":\"0x58788cb94b1d80000\"},\"db288f80ffe232c2ba47cc94c763cf6fc9b82b0d\":{\"balance\":\"0x49b9ca9a694340000\"},\"db2a0c9ab64df58ddfb1dbacf8ba0d89c85b31b4\":{\"balance\":\"0xd8d726b7177a800000\"},\"db34745ede8576b499db01beb7c1ecda85cf4abe\":{\"balance\":\"0x4563918244f400000\"},\"db3f258ab2a3c2cf339c4499f75a4bd1d3472e9e\":{\"balance\":\"0x5150ae84a8cdf00000\"},\"db4bc83b0e6baadb1156c5cf06e0f721808c52c7\":{\"balance\":\"0x2fb474098f67c00000\"},\"db63122de7037da4971531fae9af85867886c692\":{\"balance\":\"0xf0425b0641f340000\"},\"db6c2a73dac7424ab0d031b66761122566c01043\":{\"balance\":\"0xa2a15d09519be00000\"},\"db6e560c9bc620d4bea3a94d47f7880bf47f2d5f\":{\"balance\":\"0x4da0fdfcf05760000\"},\"db6ff71b3db0928f839e05a7323bfb57d29c87aa\":{\"balance\":\"0x3154c9729d05780000\"},\"db73460b59d8e85045d5e752e62559875e42502e\":{\"balance\":\"0x36330322d5238c0000\"},\"db77b88dcb712fd17ee91a5b94748d720c90a994\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"db7d4037081f6c65f9476b0687d97f1e044d0a1d\":{\"balance\":\"0x23c757072b8dd00000\"},\"db882eacedd0eff263511b312adbbc59c6b8b25b\":{\"balance\":\"0x1ed4fde7a2236b00000\"},\"db9371b30c4c844e59e03e924be606a938d1d310\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dba4796d0ceb4d3a836b84c96f910afc103f5ba0\":{\"balance\":\"0x908f493f737410000\"},\"dbadc61ed5f0460a7f18e51b2fb2614d9264a0e0\":{\"balance\":\"0x22b1c8c1227a00000\"},\"dbb6ac484027041642bbfd8d80f9d0c1cf33c1eb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dbbcbb79bf479a42ad71dbcab77b5adfaa872c58\":{\"balance\":\"0x5dc892aa1131c80000\"},\"dbc1ce0e49b1a705d22e2037aec878ee0d75c703\":{\"balance\":\"0xd8d726b7177a80000\"},\"dbc1d0ee2bab531140de137722cd36bdb4e47194\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dbc59ed88973dead310884223af49763c05030f1\":{\"balance\":\"0x1158e460913d00000\"},\"dbc66965e426ff1ac87ad6eb78c1d95271158f9f\":{\"balance\":\"0xfc936392801c0000\"},\"dbcbcd7a57ea9db2349b878af34b1ad642a7f1d1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dbd51cdf2c3bfacdff106221de2e19ad6d420414\":{\"balance\":\"0x5f68e8131ecf800000\"},\"dbd71efa4b93c889e76593de609c3b04cbafbe08\":{\"balance\":\"0x1158e460913d00000\"},\"dbf5f061a0f48e5e69618739a77d2ec19768d201\":{\"balance\":\"0x83d6c7aab63600000\"},\"dbf8b13967f55125272de0562536c450ba5655a0\":{\"balance\":\"0x6ef578f06e0ccb0000\"},\"dbfb1bb464b8a58e500d2ed8de972c45f5f1c0fb\":{\"balance\":\"0x56bc75e2d631000000\"},\"dc067ed3e12d711ed475f5156ef7e71a80d934b9\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"dc087f9390fb9e976ac23ab689544a0942ec2021\":{\"balance\":\"0x62a992e53a0af00000\"},\"dc1eb9b6e64351f56424509645f83e79eee76cf4\":{\"balance\":\"0xd8d726b7177a800000\"},\"dc1f1979615f082140b8bb78c67b27a1942713b1\":{\"balance\":\"0x340aad21b3b700000\"},\"dc23b260fcc26e7d10f4bd044af794579460d9da\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"dc29119745d2337320da51e19100c948d980b915\":{\"balance\":\"0x8ac7230489e800000\"},\"dc2d15a69f6bb33b246aef40450751c2f6756ad2\":{\"balance\":\"0x6c341080bd1fb00000\"},\"dc3dae59ed0fe18b58511e6fe2fb69b219689423\":{\"balance\":\"0x56bc75e2d63100000\"},\"dc3f0e7672f71fe7525ba30b9755183a20b9166a\":{\"balance\":\"0x2089cf57b5b3e968000\"},\"dc4345d6812e870ae90c568c67d2c567cfb4f03c\":{\"balance\":\"0x16b352da5e0ed300000\"},\"dc44275b1715baea1b0345735a29ac42c9f51b4f\":{\"balance\":\"0x3f19beb8dd1ab00000\"},\"dc46c13325cd8edf0230d068896486f007bf4ef1\":{\"balance\":\"0x487a9a304539440000\"},\"dc51b2dc9d247a1d0e5bc36ca3156f7af21ff9f6\":{\"balance\":\"0x3635c9adc5dea00000\"},\"dc5305b4020a06b49d657c7ca34c35c91c5f2c56\":{\"balance\":\"0x17df6c10dbeba970000\"},\"dc57345b38e0f067c9a31d9deac5275a10949321\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dc57477dafa42f705c7fe40eae9c81756e0225f1\":{\"balance\":\"0x1b1b8128a7416e0000\"},\"dc5f5ad663a6f263327d64cac9cb133d2c960597\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dc703a5f3794c84d6cb3544918cae14a35c3bd4f\":{\"balance\":\"0x6449e84e47a8a80000\"},\"dc738fb217cead2f69594c08170de1af10c419e3\":{\"balance\":\"0x152d02c7e14af6800000\"},\"dc76e85ba50b9b31ec1e2620bce6e7c8058c0eaf\":{\"balance\":\"0x1158e460913d00000\"},\"dc83b6fd0d512131204707eaf72ea0c8c9bef976\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dc8c2912f084a6d184aa73638513ccbc326e0102\":{\"balance\":\"0x4633bc36cbc2dc0000\"},\"dc911cf7dc5dd0813656670528e9338e67034786\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dcb03bfa6c1131234e56b7ea7c4f721487546b7a\":{\"balance\":\"0x487a9a304539440000\"},\"dcb64df43758c7cf974fa660484fbb718f8c67c1\":{\"balance\":\"0x43c33c1937564800000\"},\"dcc52d8f8d9fc742a8b82767f0555387c563efff\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"dccb370ed68aa922283043ef7cad1b9d403fc34a\":{\"balance\":\"0xd8d726b7177a800000\"},\"dccca42045ec3e16508b603fd936e7fd7de5f36a\":{\"balance\":\"0x11164759ffb320000\"},\"dcd10c55bb854f754434f1219c2c9a98ace79f03\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"dcd5bca2005395b675fde5035659b26bfefc49ee\":{\"balance\":\"0xaadec983fcff40000\"},\"dcdbbd4e2604e40e1710cc6730289dccfad3892d\":{\"balance\":\"0xf95dd2ec27cce00000\"},\"dce30c31f3ca66721ecb213c809aab561d9b52e4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dcf33965531380163168fc11f67e89c6f1bc178a\":{\"balance\":\"0x122776853406b08000\"},\"dcf6b657266e91a4dae6033ddac15332dd8d2b34\":{\"balance\":\"0x5f68e8131ecf800000\"},\"dcf9719be87c6f46756db4891db9b611d2469c50\":{\"balance\":\"0x3635c9adc5dea00000\"},\"dcfff3e8d23c2a34b56bd1b3bd45c79374432239\":{\"balance\":\"0x10f0cf064dd59200000\"},\"dd04eee74e0bf30c3f8d6c2c7f52e0519210df93\":{\"balance\":\"0x4563918244f400000\"},\"dd26b429fd43d84ec179825324bad5bfb916b360\":{\"balance\":\"0x116bf95bc8432980000\"},\"dd2a233adede66fe1126d6c16823b62a021feddb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dd2bdfa917c1f310e6fa35aa8af16939c233cd7d\":{\"balance\":\"0x15af1d78b58c400000\"},\"dd35cfdbcb993395537aecc9f59085a8d5ddb6f5\":{\"balance\":\"0x3635c9adc5dea00000\"},\"dd47189a3e64397167f0620e484565b762bfbbf4\":{\"balance\":\"0x6449e84e47a8a80000\"},\"dd4dd6d36033b0636fcc8d0938609f4dd64f4a86\":{\"balance\":\"0x340aad21b3b700000\"},\"dd4f5fa2111db68f6bde3589b63029395b69a92d\":{\"balance\":\"0x8963dd8c2c5e00000\"},\"dd63042f25ed32884ad26e3ad959eb94ea36bf67\":{\"balance\":\"0x484d7fde7d593f00000\"},\"dd65f6e17163b5d203641f51cc7b24b00f02c8fb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dd6c062193eac23d2fdbf997d5063a346bb3b470\":{\"balance\":\"0x1158e460913d00000\"},\"dd7bcda65924aaa49b80984ae173750258b92847\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"dd7ff441ba6ffe3671f3c0dabbff1823a5043370\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dd8254121a6e942fc90828f2431f511dad7f32e6\":{\"balance\":\"0xa39b29e1f360e80000\"},\"dd8af9e7765223f4446f44d3d509819a3d3db411\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"dd95dbe30f1f1877c5dd7684aeef302ab6885192\":{\"balance\":\"0x1c5d8d6eb3e32500000\"},\"dd967c4c5f8ae47e266fb416aad1964ee3e7e8c3\":{\"balance\":\"0x1a420db02bd7d580000\"},\"dd9b485a3b1cd33a6a9c62f1e5bee92701856d25\":{\"balance\":\"0xc3383ed031b7e8000\"},\"dda371e600d30688d4710e088e02fdf2b9524d5f\":{\"balance\":\"0x177224aa844c7200000\"},\"dda4ed2a58a8dd20a73275347b580d71b95bf99a\":{\"balance\":\"0x15a13cc201e4dc0000\"},\"dda4ff7de491c687df4574dd1b17ff8f246ba3d1\":{\"balance\":\"0x42684a41abfd8400000\"},\"ddab6b51a9030b40fb95cf0b748a059c2417bec7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ddab75fb2ff9fecb88f89476688e2b00e367ebf9\":{\"balance\":\"0x41bad155e6512200000\"},\"ddabf13c3c8ea4e3d73d78ec717afafa430e5479\":{\"balance\":\"0x8cf23f909c0fa000000\"},\"ddac312a9655426a9c0c9efa3fd82559ef4505bf\":{\"balance\":\"0x15be6174e1912e0000\"},\"ddac6bf4bbdd7d597d9c686d0695593bedccc7fa\":{\"balance\":\"0x2ee449550898e40000\"},\"ddbd2b932c763ba5b1b7ae3b362eac3e8d40121a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"ddbddd1bbd38ffade0305d30f02028d92e9f3aa8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ddbee6f094eae63420b003fb4757142aea6cd0fd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ddd69c5b9bf5eb5a39cee7c3341a120d973fdb34\":{\"balance\":\"0x6bc14b8f8e1b350000\"},\"dddd7b9e6eab409b92263ac272da801b664f8a57\":{\"balance\":\"0x69e10de76676d0800000\"},\"dde670d01639667576a22dd05d3246d61f06e083\":{\"balance\":\"0x1731790534df20000\"},\"dde77a4740ba08e7f73fbe3a1674912931742eeb\":{\"balance\":\"0x434fe4d4382f1d48000\"},\"dde8f0c31b7415511dced1cd7d46323e4bd12232\":{\"balance\":\"0x57473d05dabae80000\"},\"dde969aef34ea87ac299b7597e292b4a0155cc8a\":{\"balance\":\"0x1032f2594a01738000\"},\"ddf0cce1fe996d917635f00712f4052091dff9ea\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ddf3ad76353810be6a89d731b787f6f17188612b\":{\"balance\":\"0x43c33c1937564800000\"},\"ddf5810a0eb2fb2e32323bb2c99509ab320f24ac\":{\"balance\":\"0x3ca5c66d9bc44300000\"},\"ddf95c1e99ce2f9f5698057c19d5c94027ee4a6e\":{\"balance\":\"0x14542ba12a337c00000\"},\"ddfafdbc7c90f1320e54b98f374617fbd01d109f\":{\"balance\":\"0xb98bc829a6f90000\"},\"ddfcca13f934f0cfbe231da13039d70475e6a1d0\":{\"balance\":\"0x3638221660a5aa8000\"},\"de027efbb38503226ed871099cb30bdb02af1335\":{\"balance\":\"0x3635c9adc5dea00000\"},\"de06d5ea777a4eb1475e605dbcbf43444e8037ea\":{\"balance\":\"0xa968163f0a57b400000\"},\"de07fb5b7a464e3ba7fbe09e9acb271af5338c58\":{\"balance\":\"0x2b5e3af16b1880000\"},\"de1121829c9a08284087a43fbd2fc1142a3233b4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"de176b5284bcee3a838ba24f67fc7cbf67d78ef6\":{\"balance\":\"0x209ce08c962b00000\"},\"de212293f8f1d231fa10e609470d512cb8ffc512\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"de30e49e5ab313214d2f01dcabce8940b81b1c76\":{\"balance\":\"0xaadec983fcff40000\"},\"de33d708a3b89e909eaf653b30fdc3a5d5ccb4b3\":{\"balance\":\"0x99c88229fd4c20000\"},\"de374299c1d07d79537385190f442ef9ca24061f\":{\"balance\":\"0x73f75d1a085ba0000\"},\"de42fcd24ce4239383304367595f068f0c610740\":{\"balance\":\"0x2722a70f1a9a00000\"},\"de50868eb7e3c71937ec73fa89dd8b9ee10d45aa\":{\"balance\":\"0x3635c9adc5dea00000\"},\"de55de0458f850b37e4d78a641dd2eb2dd8f38ce\":{\"balance\":\"0xd8d726b7177a800000\"},\"de5b005fe8daae8d1f05de3eda042066c6c4691c\":{\"balance\":\"0x3ba1910bf341b00000\"},\"de612d0724e84ea4a7feaa3d2142bd5ee82d3201\":{\"balance\":\"0x1158e460913d00000\"},\"de6d363106cc6238d2f092f0f0372136d1cd50c6\":{\"balance\":\"0x121ea68c114e5100000\"},\"de7dee220f0457a7187d56c1c41f2eb00ac56021\":{\"balance\":\"0x2225f39c85052a0000\"},\"de82cc8d4a1bb1d9434392965b3e80bad3c03d4f\":{\"balance\":\"0x50186e75de97a60000\"},\"de97f4330700b48c496d437c91ca1de9c4b01ba4\":{\"balance\":\"0x9dcc0515b56e0c0000\"},\"de9eff4c798811d968dccb460d9b069cf30278e0\":{\"balance\":\"0x15af1d78b58c400000\"},\"deb1bc34d86d4a4dde2580d8beaf074eb0e1a244\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"deb2495d6aca7b2a6a2d138b6e1a42e2dc311fdd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"deb97254474c0d2f5a7970dcdb2f52fb1098b896\":{\"balance\":\"0x3635c9adc5dea00000\"},\"deb9a49a43873020f0759185e20bbb4cf381bb8f\":{\"balance\":\"0xb78edb0bf2e5e0000\"},\"debbdd831e0f20ae6e378252decdf92f7cf0c658\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dec3eec2640a752c466e2b7e7ee685afe9ac41f4\":{\"balance\":\"0x47c99753596b288000\"},\"dec82373ade8ebcf2acb6f8bc2414dd7abb70d77\":{\"balance\":\"0xad78ebc5ac6200000\"},\"dec8a1a898f1b895d8301fe64ab3ad5de941f689\":{\"balance\":\"0x2ab4f67e8a730f8000\"},\"dec99e972fca7177508c8e1a47ac22d768acab7c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ded877378407b94e781c4ef4af7cfc5bc220b516\":{\"balance\":\"0x143179d86911020000\"},\"dee942d5caf5fac11421d86b010b458e5c392990\":{\"balance\":\"0xd8d726b7177a800000\"},\"deee2689fa9006b59cf285237de53b3a7fd01438\":{\"balance\":\"0x186579f29e20250000\"},\"defddfd59b8d2c154eecf5c7c167bf0ba2905d3e\":{\"balance\":\"0x512cb5e2647420000\"},\"defe9141f4704599159d7b223de42bffd80496b3\":{\"balance\":\"0x56bc75e2d63100000\"},\"df098f5e4e3dffa51af237bda8652c4f73ed9ca6\":{\"balance\":\"0x1b36a6444a3e180000\"},\"df0d08617bd252a911df8bd41a39b83ddf809673\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"df0ff1f3d27a8ec9fb8f6b0cb254a63bba8224a5\":{\"balance\":\"0xecc5202945d0020000\"},\"df1fa2e20e31985ebe2c0f0c93b54c0fb67a264b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"df211cd21288d6c56fae66c3ff54625dd4b15427\":{\"balance\":\"0x8786cd764e1f2c0000\"},\"df236bf6abf4f3293795bf0c28718f93e3b1b36b\":{\"balance\":\"0x487a9a304539440000\"},\"df31025f5649d2c6eea41ed3bdd3471a790f759a\":{\"balance\":\"0x1158e460913d00000\"},\"df37c22e603aedb60a627253c47d8ba866f6d972\":{\"balance\":\"0x5150ae84a8cdf000000\"},\"df3b72c5bd71d4814e88a62321a93d4011e3578b\":{\"balance\":\"0xd8d726b7177a800000\"},\"df3f57b8ee6434d047223def74b20f63f9e4f955\":{\"balance\":\"0xd9462c6cb4b5a0000\"},\"df44c47fc303ac76e74f97194cca67b5bb3c023f\":{\"balance\":\"0x2009c5c8bf6fdc0000\"},\"df47a61b72535193c561cccc75c3f3ce0804a20e\":{\"balance\":\"0x15935c0b4e3d780000\"},\"df47a8ef95f2f49f8e6f58184154145d11f72797\":{\"balance\":\"0x678a932062e4180000\"},\"df53003346d65c5e7a646bc034f2b7d32fcbe56a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"df57353aaff2aadb0a04f9014e8da7884e86589c\":{\"balance\":\"0x84886a66e4fb00000\"},\"df60f18c812a11ed4e2776e7a80ecf5e5305b3d6\":{\"balance\":\"0x30ca024f987b900000\"},\"df6485c4297ac152b289b19dde32c77ec417f47d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"df660a91dab9f730f6190d50c8390561500756ca\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"df6ed6006a6abe886ed33d95a4de28fc12183927\":{\"balance\":\"0x3154c9729d05780000\"},\"df8510793eee811c2dab1c93c6f4473f30fbef5b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"df8d48b1eb07b3c217790e6c2df04dc319e7e848\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"dfa6b8b8ad3184e357da282951d79161cfb089bc\":{\"balance\":\"0x15af1d78b58c400000\"},\"dfaf31e622c03d9e18a0ddb8be60fbe3e661be0a\":{\"balance\":\"0x21e171a3ec9f72c0000\"},\"dfb1626ef48a1d7d7552a5e0298f1fc23a3b482d\":{\"balance\":\"0x5ce895dd949efa0000\"},\"dfb4d4ade52fcc818acc7a2c6bb2b00224658f78\":{\"balance\":\"0x1a420db02bd7d580000\"},\"dfbd4232c17c407a980db87ffbcda03630e5c459\":{\"balance\":\"0x1dfc7f924923530000\"},\"dfcbdf09454e1a5e4a40d3eef7c5cf1cd3de9486\":{\"balance\":\"0xd8d726b7177a800000\"},\"dfdbcec1014b96da2158ca513e9c8d3b9af1c3d0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"dfded2574b27d1613a7d98b715159b0d00baab28\":{\"balance\":\"0x43c33c1937564800000\"},\"dfdf43393c649caebe1bb18059decb39f09fb4e8\":{\"balance\":\"0x15af1d78b58c400000\"},\"dfe3c52a92c30396a4e33a50170dc900fcf8c9cf\":{\"balance\":\"0x2b5e3af16b1880000\"},\"dfe549fe8430e552c6d07cc3b92ccd43b12fb50f\":{\"balance\":\"0x48875eaf6562a0000\"},\"dfe929a61c1b38eddbe82c25c2d6753cb1e12d68\":{\"balance\":\"0x15d1cf4176aeba0000\"},\"dff1b220de3d8e9ca4c1b5be34a799bcded4f61c\":{\"balance\":\"0x14e4e353ea39420000\"},\"dff4007931786593b229efe5959f3a4e219e51af\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"dffcea5421ec15900c6ecfc777184e140e209e24\":{\"balance\":\"0x115473824344e0000\"},\"e001aba77c02e172086c1950fffbcaa30b83488f\":{\"balance\":\"0x6acb3df27e1f880000\"},\"e00484788db50fc6a48e379d123e508b0f6e5ab1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e0060462c47ff9679baef07159cae08c29f274a9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e00d153b10369143f97f54b8d4ca229eb3e8f324\":{\"balance\":\"0x83d6c7aab63600000\"},\"e012db453827a58e16c1365608d36ed658720507\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e01547ba42fcafaf93938becf7699f74290af74f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e016dc138e25815b90be3fe9eee8ffb2e105624f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e01859f242f1a0ec602fa8a3b0b57640ec89075e\":{\"balance\":\"0x1e162c177be5cc0000\"},\"e020e86362b487752836a6de0bc02cd8d89a8b6a\":{\"balance\":\"0x14542ba12a337c00000\"},\"e023f09b2887612c7c9cf1988e3a3a602b3394c9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e0272213e8d2fd3e96bd6217b24b4ba01b617079\":{\"balance\":\"0x1158e460913d00000\"},\"e02b74a47628be315b1f76b315054ad44ae9716f\":{\"balance\":\"0xd8d726b7177a800000\"},\"e03220c697bcd28f26ef0b74404a8beb06b2ba7b\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"e0352fdf819ba265f14c06a6315c4ac1fe131b2e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e0388aeddd3fe2ad56f85748e80e710a34b7c92e\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e03c00d00388ecbf4f263d0ac778bb41a57a40d9\":{\"balance\":\"0x3636c9796436740000\"},\"e04920dc6ecc1d6ecc084f88aa0af5db97bf893a\":{\"balance\":\"0x9ddc1e3b901180000\"},\"e04972a83ca4112bc871c72d4ae1616c2f0728db\":{\"balance\":\"0xe81c77f29a32f0000\"},\"e04ff5e5a7e2af995d8857ce0290b53a2b0eda5d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e05029aceb0778675bef1741ab2cd2931ef7c84b\":{\"balance\":\"0x10f0dbae61009528000\"},\"e056bf3ff41c26256fef51716612b9d39ade999c\":{\"balance\":\"0x56be757a12e0a8000\"},\"e061a4f2fc77b296d19ada238e49a5cb8ecbfa70\":{\"balance\":\"0xd8d726b7177a800000\"},\"e0663e8cd66792a641f56e5003660147880f018e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e0668fa82c14d6e8d93a53113ef2862fa81581bc\":{\"balance\":\"0x2f2f39fc6c54000000\"},\"e069c0173352b10bf6834719db5bed01adf97bbc\":{\"balance\":\"0x10634f8e5323b0000\"},\"e06c29a81517e0d487b67fb0b6aabc4f57368388\":{\"balance\":\"0x15be6174e1912e0000\"},\"e06cb6294704eea7437c2fc3d30773b7bf38889a\":{\"balance\":\"0x116dc3a8994b30000\"},\"e07137ae0d116d033533c4eab496f8a9fb09569c\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"e076db30ab486f79194ebbc45d8fab9a9242f654\":{\"balance\":\"0x106607e3494baa00000\"},\"e07ebbc7f4da416e42c8d4f842aba16233c12580\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e081ca1f4882db6043d5a9190703fde0ab3bf56d\":{\"balance\":\"0x15af1d78b58c400000\"},\"e083d34863e0e17f926b7928edff317e998e9c4b\":{\"balance\":\"0x15af1d78b58c400000\"},\"e08b9aba6bd9d28bc2056779d2fbf0f2855a3d9d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e08bc29c2b48b169ff2bdc16714c586e6cb85ccf\":{\"balance\":\"0x1158e460913d00000\"},\"e08c60313106e3f9334fe6f7e7624d211130c077\":{\"balance\":\"0x22b1c8c1227a00000\"},\"e09c68e61998d9c81b14e4ee802ba7adf6d74cdb\":{\"balance\":\"0xd8d726b7177a800000\"},\"e09fea755aee1a44c0a89f03b5deb762ba33006f\":{\"balance\":\"0x3ba289bc944ff70000\"},\"e0a254ac09b9725bebc8e460431dd0732ebcabbf\":{\"balance\":\"0x14542ba12a337c00000\"},\"e0aa69365555b73f282333d1e30c1bbd072854e8\":{\"balance\":\"0x17b7883c06916600000\"},\"e0bad98eee9698dbf6d76085b7923de5754e906d\":{\"balance\":\"0x90d972f32323c0000\"},\"e0c4ab9072b4e6e3654a49f8a8db026a4b3386a9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e0ce80a461b648a501fd0b824690c8868b0e4de8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e0cf698a053327ebd16b7d7700092fe2e8542446\":{\"balance\":\"0x52a34cbb61f578000\"},\"e0d231e144ec9107386c7c9b02f1702ceaa4f700\":{\"balance\":\"0x10f0dbae61009528000\"},\"e0d76b7166b1f3a12b4091ee2b29de8caa7d07db\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e0e0b2e29dde73af75987ee4446c829a189c95bc\":{\"balance\":\"0x813ca56906d340000\"},\"e0e978753d982f7f9d1d238a18bd4889aefe451b\":{\"balance\":\"0x20dd68aaf3289100000\"},\"e0f372347c96b55f7d4306034beb83266fd90966\":{\"balance\":\"0x15af1d78b58c400000\"},\"e0f903c1e48ac421ab48528f3d4a2648080fe043\":{\"balance\":\"0x3708baed3d68900000\"},\"e0ff0bd9154439c4a5b7233e291d7d868af53f33\":{\"balance\":\"0x1579216a51bbfb0000\"},\"e10ac19c546fc2547c61c139f5d1f45a6666d5b0\":{\"balance\":\"0x102da6fd0f73a3c0000\"},\"e10c540088113fa6ec00b4b2c8824f8796e96ec4\":{\"balance\":\"0x320f4509ab1ec7c00000\"},\"e1173a247d29d8238df0922f4df25a05f2af77c3\":{\"balance\":\"0x878c95d560f30478000\"},\"e1203eb3a723e99c2220117ca6afeb66fa424f61\":{\"balance\":\"0x200ef929e3256fe0000\"},\"e131f87efc5ef07e43f0f2f4a747b551d750d9e6\":{\"balance\":\"0x43c25e0dcc1bd1c0000\"},\"e1334e998379dfe983177062791b90f80ee22d8d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e13540ecee11b212e8b775dc8e71f374aae9b3f8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e13b3d2bbfdcbc8772a23315724c1425167c5688\":{\"balance\":\"0x37f379141ed04b8000\"},\"e1443dbd95cc41237f613a48456988a04f683282\":{\"balance\":\"0xd8d8583fa2d52f0000\"},\"e14617f6022501e97e7b3e2d8836aa61f0ff2dba\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e149b5726caf6d5eb5bf2acc41d4e2dc328de182\":{\"balance\":\"0x692ae8897081d00000\"},\"e154daeadb545838cbc6aa0c55751902f528682a\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"e16ce35961cd74bd590d04c4ad4a1989e05691c6\":{\"balance\":\"0x7ea28327577080000\"},\"e172dfc8f80cd1f8cd8539dc26082014f5a8e3e8\":{\"balance\":\"0xa2a15d09519be00000\"},\"e177e0c201d335ba3956929c571588b51c5223ae\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e17812f66c5e65941e186c46922b6e7b2f0eeb46\":{\"balance\":\"0x62a992e53a0af00000\"},\"e180de9e86f57bafacd7904f9826b6b4b26337a3\":{\"balance\":\"0x2d041d705a2c600000\"},\"e192489b85a982c1883246d915b229cb13207f38\":{\"balance\":\"0x10f0cf064dd59200000\"},\"e1953c6e975814c571311c34c0f6a99cdf48ab82\":{\"balance\":\"0x2b5e3af16b1880000\"},\"e1ae029b17e373cde3de5a9152201a14cac4e119\":{\"balance\":\"0x56b55ae58ca400000\"},\"e1b2aca154b8e0766c4eba30bc10c7f35036f368\":{\"balance\":\"0x115473824344e0000\"},\"e1b39b88d9900dbc4a6cdc481e1060080a8aec3c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e1b63201fae1f129f95c7a116bd9dde5159c6cda\":{\"balance\":\"0x4d60573a2f0c9ef0000\"},\"e1bfaa5a45c504428923c4a61192a55b1400b45d\":{\"balance\":\"0x90f534608a72880000\"},\"e1c607c0a8a060da8f02a8eb38a013ea8cda5b8c\":{\"balance\":\"0x2ba39e82ed5d740000\"},\"e1cb83ec5eb6f1eeb85e99b2fc63812fde957184\":{\"balance\":\"0x43c33c1937564800000\"},\"e1d91b0954cede221d6f24c7985fc59965fb98b8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e1dfb5cc890ee8b2877e885d267c256187d019e6\":{\"balance\":\"0x56bc75e2d63100000\"},\"e1e8c50b80a352b240ce7342bbfdf5690cc8cb14\":{\"balance\":\"0x155bd9307f9fe80000\"},\"e1f63ebbc62c7b7444040eb99623964f7667b376\":{\"balance\":\"0x1158e460913d00000\"},\"e206fb7324e9deb79e19903496d6961b9be56603\":{\"balance\":\"0x56bc75e2d63100000\"},\"e207578e1f4ddb8ff6d5867b39582d71b9812ac5\":{\"balance\":\"0xd255d112e103a00000\"},\"e208812a684098f3da4efe6aba256256adfe3fe6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e20954d0f4108c82d4dcb2148d26bbd924f6dd24\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e20bb9f3966419e14bbbaaaa6789e92496cfa479\":{\"balance\":\"0xbbd825030752760000\"},\"e20d1bcb71286dc7128a9fc7c6ed7f733892eef5\":{\"balance\":\"0x3664f8e7c24af40000\"},\"e2191215983f33fd33e22cd4a2490054da53fddc\":{\"balance\":\"0xdb44e049bb2c0000\"},\"e2198c8ca1b399f7521561fd5384a7132fba486b\":{\"balance\":\"0x3708baed3d68900000\"},\"e21c778ef2a0d7f751ea8c074d1f812243863e4e\":{\"balance\":\"0x11fc70e2c8c8ae18000\"},\"e229e746a83f2ce253b0b03eb1472411b57e5700\":{\"balance\":\"0x1369fb96128ac480000\"},\"e22b20c77894463baf774cc256d5bddbbf7ddd09\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e230fe1bff03186d0219f15d4c481b7d59be286a\":{\"balance\":\"0x1fd741e8088970000\"},\"e237baa4dbc9926e32a3d85d1264402d54db012f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e24109be2f513d87498e926a286499754f9ed49e\":{\"balance\":\"0x300ea8ad1f27ca0000\"},\"e246683cc99db7c4a52bcbacaab0b32f6bfc93d7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e25a167b031e84616d0f013f31bda95dcc6350b9\":{\"balance\":\"0x23c757072b8dd000000\"},\"e25b9f76b8ad023f057eb11ad94257a0862e4e8c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e26657f0ed201ea2392c9222b80a7003608ddf30\":{\"balance\":\"0x22b1c8c1227a00000\"},\"e26bf322774e18288769d67e3107deb7447707b8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e2728a3e8c2aaac983d05dc6877374a8f446eee9\":{\"balance\":\"0xab640391201300000\"},\"e28b062259e96eeb3c8d4104943f9eb325893cf5\":{\"balance\":\"0x487a9a304539440000\"},\"e28dbc8efd5e416a762ec0e018864bb9aa83287b\":{\"balance\":\"0x531f200ab3e030a8000\"},\"e2904b1aefa056398b6234cb35811288d736db67\":{\"balance\":\"0x22b1c8c1227a00000\"},\"e29d8ae452dcf3b6ac645e630409385551faae0a\":{\"balance\":\"0x45a0da4adf5420000\"},\"e2bbf84641e3541f6c33e6ed683a635a70bde2ec\":{\"balance\":\"0x1b413cfcbf59b78000\"},\"e2cf360aa2329eb79d2bf7ca04a27a17c532e4d8\":{\"balance\":\"0x58788cb94b1d80000\"},\"e2df23f6ea04becf4ab701748dc0963184555cdb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e2e15c60dd381e3a4be25071ab249a4c5c5264da\":{\"balance\":\"0x7f6bc49b81b5370000\"},\"e2e26e4e1dcf30d048cc6ecf9d51ec1205a4e926\":{\"balance\":\"0xd8d726b7177a800000\"},\"e2ee691f237ee6529b6557f2fcdd3dcf0c59ec63\":{\"balance\":\"0x127729c14687c200000\"},\"e2efa5fca79538ce6068bf31d2c516d4d53c08e5\":{\"balance\":\"0x71cc408df63400000\"},\"e2efd0a9bc407ece03d67e8ec8e9d283f48d2a49\":{\"balance\":\"0x299b33bf9c584e00000\"},\"e2f40d358f5e3fe7463ec70480bd2ed398a7063b\":{\"balance\":\"0x1158e460913d00000\"},\"e2f9383d5810ea7b43182b8704b62b27f5925d39\":{\"balance\":\"0x15af1d78b58c400000\"},\"e2ff9ee4b6ecc14141cc74ca52a9e7a2ee14d908\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"e30212b2011bb56bdbf1bc35690f3a4e0fd905ea\":{\"balance\":\"0x1b2df9d219f57980000\"},\"e303167f3d4960fe881b32800a2b4aeff1b088d4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e304a32f05a83762744a9542976ff9b723fa31ea\":{\"balance\":\"0x5572f240a346200000\"},\"e308435204793764f5fcbe65eb510f5a744a655a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e309974ce39d60aadf2e69673251bf0e04760a10\":{\"balance\":\"0xdc55fdb17647b0000\"},\"e31b4eef184c24ab098e36c802714bd4743dd0d4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e321bb4a946adafdade4571fb15c0043d39ee35f\":{\"balance\":\"0x556475382b4c9e0000\"},\"e3263ce8af6db3e467584502ed7109125eae22a5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e32b1c4725a1875449e98f970eb3e54062d15800\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e32f95766d57b5cd4b173289d6876f9e64558194\":{\"balance\":\"0x56bc75e2d63100000\"},\"e33840d8bca7da98a6f3d096d83de78b70b71ef8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e338e859fe2e8c15554848b75caecda877a0e832\":{\"balance\":\"0x61acff81a78ad40000\"},\"e33d980220fab259af6a1f4b38cf0ef3c6e2ea1a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e33df4ce80ccb62a76b12bcdfcecc46289973aa9\":{\"balance\":\"0x14542ba12a337c00000\"},\"e33ff987541dde5cdee0a8a96dcc3f33c3f24cc2\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"e3410bb7557cf91d79fa69d0dfea0aa075402651\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e341642d40d2afce2e9107c67079ac7a2660086c\":{\"balance\":\"0x15af1d78b58c400000\"},\"e35453eef2cc3c7a044d0ac134ba615908fa82ee\":{\"balance\":\"0x7ff1ccb7561df0000\"},\"e36a8ea87f1e99e8a2dc1b2608d166667c9dfa01\":{\"balance\":\"0x56bc75e2d63100000\"},\"e3712701619ca7623c55db3a0ad30e867db0168b\":{\"balance\":\"0x1158e460913d00000\"},\"e37f5fdc6ec97d2f866a1cfd0d3a4da4387b22b5\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e3878f91ca86053fced5444686a330e09cc388fb\":{\"balance\":\"0xa844a7424d9c80000\"},\"e38b91b35190b6d9deed021c30af094b953fdcaa\":{\"balance\":\"0x1ceaf795b6b860000\"},\"e38ef28a5ed984a7db24a1ae782dfb87f397dfc6\":{\"balance\":\"0x7c0860e5a80dc0000\"},\"e3925509c8d0b2a6738c5f6a72f35314491248ce\":{\"balance\":\"0x36e9a8669a44768000\"},\"e3933d61b77dcdc716407f8250bc91e4ffaeb09d\":{\"balance\":\"0x1256986c95891c200000\"},\"e3951de5aefaf0458768d774c254f7157735e505\":{\"balance\":\"0x56c95de8e8ca1d0000\"},\"e399c81a1d701b44f0b66f3399e66b275aaaf8c1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e39b11a8ab1ff5e22e5ae6517214f73c5b9b55dc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e39e46e15d22ce56e0c32f1877b7d1a264cf94f3\":{\"balance\":\"0x43c33c1937564800000\"},\"e3a4621b66004588e31206f718cb00a319889cf0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e3a4f83c39f85af9c8b1b312bfe5fc3423afa634\":{\"balance\":\"0x18d993f34aef10000\"},\"e3a89a1927cc4e2d43fbcda1e414d324a7d9e057\":{\"balance\":\"0xb23e2a936dec60000\"},\"e3ab3ca9b870e3f548517306bba4de2591afafc2\":{\"balance\":\"0x410e34aecc8cd30000\"},\"e3b3d2c9bf570be6a2f72adca1862c310936a43c\":{\"balance\":\"0x56d2aa3a5c09a0000\"},\"e3c0c128327a9ad80148139e269773428e638cb0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e3c812737ac606baf7522ad817428a36050e7a34\":{\"balance\":\"0x692ae8897081d00000\"},\"e3cffe239c64e7e20388e622117391301b298696\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e3d3eaa299887865569e88be219be507189be1c9\":{\"balance\":\"0x18ba6fa92e93160000\"},\"e3d8bf4efe84b1616d1b89e427ddc6c8830685ae\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e3d915eda3b825d6ee4af9328d32ac18ada35497\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e3da4f3240844c9b6323b4996921207122454399\":{\"balance\":\"0x27190a952df4be58000\"},\"e3eb2c0a132a524f72ccc0d60fee8b41685d39e2\":{\"balance\":\"0x6acb3df27e1f880000\"},\"e3ec18a74ed43855409a26ade7830de8e42685ef\":{\"balance\":\"0x11164759ffb320000\"},\"e3ece1f632711d13bfffa1f8f6840871ee58fb27\":{\"balance\":\"0xd8d726b7177a800000\"},\"e3f80b40fb83fb97bb0d5230af4f6ed59b1c7cc8\":{\"balance\":\"0x487a9a304539440000\"},\"e3ffb02cb7d9ea5243701689afd5d417d7ed2ece\":{\"balance\":\"0x43a77aabd00780000\"},\"e400d651bb3f2d23d5f849e6f92d9c5795c43a8a\":{\"balance\":\"0x90f534608a72880000\"},\"e406f5dd72cab66d8a6ecbd6bfb494a7b6b09afe\":{\"balance\":\"0x56bc75e2d63100000\"},\"e408aa99835307eea4a6c5eb801fe694117f707d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e408fceaa1b98f3c640f48fcba39f056066d6308\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e40a7c82e157540a0b00901dbb86c716e1a062da\":{\"balance\":\"0x2b31d2425f6740000\"},\"e41aea250b877d423a63ba2bce2f3a61c0248d56\":{\"balance\":\"0xe18398e7601900000\"},\"e430c0024fdbf73a82e21fccf8cbd09138421c21\":{\"balance\":\"0xd8d726b7177a800000\"},\"e4324912d64ea3aef76b3c2ff9df82c7e13ae991\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e4368bc1420b35efda95fafbc73090521916aa34\":{\"balance\":\"0xd8d726b7177a800000\"},\"e437acbe0f6227b0e36f36e4bcf7cf613335fb68\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e44b7264dd836bee8e87970340ed2b9aed8ed0a5\":{\"balance\":\"0x138e7faa01a803a0000\"},\"e44ea51063405154aae736be2bf1ee3b9be639ae\":{\"balance\":\"0xd8d726b7177a800000\"},\"e4625501f52b7af52b19ed612e9d54fdd006b492\":{\"balance\":\"0xb5a905a56ddd00000\"},\"e4715956f52f15306ee9506bf82bccc406b3895e\":{\"balance\":\"0xee79d4f48c5000000\"},\"e47fbaed99fc209962604ebd20e240f74f4591f1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e482d255ede56b04c3e8df151f56e9ca62aaa8c2\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e48e65125421880d42bdf1018ab9778d96928f3f\":{\"balance\":\"0xe3aeb5737240a00000\"},\"e492818aa684e5a676561b725d42f3cc56ae5198\":{\"balance\":\"0x2b5e3af16b18800000\"},\"e49936a92a8ccf710eaac342bc454b9b14ebecb1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e49af4f34adaa2330b0e49dc74ec18ab2f92f827\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e49ba0cd96816c4607773cf8a5970bb5bc16a1e6\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"e4a47e3933246c3fd62979a1ea19ffdf8c72ef37\":{\"balance\":\"0x809b383ea7d7e8000\"},\"e4b6ae22c7735f5b89f34dd77ad0975f0acc9181\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e4ca0a5238564dfc91e8bf22bade2901619a1cd4\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e4cafb727fb5c6b70bb27533b8a9ccc9ef6888e1\":{\"balance\":\"0x10497bf4af4caf8000\"},\"e4dc22ed595bf0a337c01e03cc6be744255fc9e8\":{\"balance\":\"0xa5aa85009e39c0000\"},\"e4fb26d1ca1eecba3d8298d9d148119ac2bbf580\":{\"balance\":\"0x15af1d78b58c400000\"},\"e4fc13cfcbac1b17ce7783acd423a845943f6b3a\":{\"balance\":\"0x1158e460913d00000\"},\"e50b464ac9de35a5618b7cbf254674182b81b97e\":{\"balance\":\"0xde42ee1544dd900000\"},\"e5102c3b711b810344197419b1cd8a7059f13e32\":{\"balance\":\"0x1043528d0984698000\"},\"e510d6797fba3d6693835a844ea2ad540691971b\":{\"balance\":\"0x3ae39d47383e8740000\"},\"e51421f8ee2210c71ed870fe618276c8954afbe9\":{\"balance\":\"0x487a9a304539440000\"},\"e51eb87e7fb7311f5228c479b48ec9878831ac4c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5215631b14248d45a255296bed1fbfa0330ff35\":{\"balance\":\"0x4703e6eb5291b80000\"},\"e528a0e5a267d667e9393a6584e19b34dc9be973\":{\"balance\":\"0x12f939c99edab800000\"},\"e53425d8df1f11c341ff58ae5f1438abf1ca53cf\":{\"balance\":\"0x1174a5cdf88bc80000\"},\"e53c68796212033e4e6f9cff56e19c461eb454f9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e54102534de8f23effb093b31242ad3b233facfd\":{\"balance\":\"0xd8d726b7177a800000\"},\"e545ee84ea48e564161e9482d59bcf406a602ca2\":{\"balance\":\"0x6449e84e47a8a80000\"},\"e5481a7fed42b901bbed20789bd4ade50d5f83b9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e559b5fd337b9c5572a9bf9e0f2521f7d446dbe4\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e55c80520a1b0f755b9a2cd3ce214f7625653e8a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e56d431324c92911a1749df292709c14b77a65cd\":{\"balance\":\"0x1bc85dc2a89bb200000\"},\"e57d2995b0ebdf3f3ca6c015eb04260dbb98b7c6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e587b16abc8a74081e3613e14342c03375bf0847\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e589fa76984db5ec4004b46ee8a59492c30744ce\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"e58dd23238ee6ea7c2138d385df500c325f376be\":{\"balance\":\"0x62a992e53a0af00000\"},\"e5953fea497104ef9ad2d4e5841c271f073519c2\":{\"balance\":\"0x2629f66e0c53000000\"},\"e5968797468ef767101b761d431fce14abffdbb4\":{\"balance\":\"0x1b3d969fa411ca00000\"},\"e597f083a469c4591c3d2b1d2c772787befe27b2\":{\"balance\":\"0xf2dc7d47f15600000\"},\"e59b3bd300893f97233ef947c46f7217e392f7e9\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e5a365343cc4eb1e770368e1f1144a77b832d7e0\":{\"balance\":\"0x1158e460913d00000\"},\"e5a3d7eb13b15c100177236d1beb30d17ee15420\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5aa0b833bb916dc19a8dd683f0ede241d988eba\":{\"balance\":\"0xa2a15d09519be00000\"},\"e5b7af146986c0ff8f85d22e6cc334077d84e824\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5b826196c0e1bc1119b021cf6d259a610c99670\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e5b96fc9ac03d448c1613ac91d15978145dbdfd1\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e5b980d28eece2c06fca6c9473068b37d4a6d6e9\":{\"balance\":\"0x25afd68cac2b900000\"},\"e5bab4f0afd8a9d1a381b45761aa18f3d3cce105\":{\"balance\":\"0x51bfd7c13878d10000\"},\"e5bcc88c3b256f6ed5fe550e4a18198b943356ad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5bdf34f4ccc483e4ca530cc7cf2bb18febe92b3\":{\"balance\":\"0x6d835a10bbcd20000\"},\"e5dc9349cb52e161196122cf87a38936e2c57f34\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5e33800a1b2e96bde1031630a959aa007f26e51\":{\"balance\":\"0x487a9a304539440000\"},\"e5e37e19408f2cfbec83349dd48153a4a795a08f\":{\"balance\":\"0xe3aeb5737240a00000\"},\"e5edc73e626f5d3441a45539b5f7a398c593edf6\":{\"balance\":\"0x2ee449550898e40000\"},\"e5edf8123f2403ce1a0299becf7aac744d075f23\":{\"balance\":\"0xada55474b81340000\"},\"e5f8ef6d970636b0dcaa4f200ffdc9e75af1741c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e5fb31a5caee6a96de393bdbf89fbe65fe125bb3\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e5fbe34984b637196f331c679d0c0c47d83410e1\":{\"balance\":\"0x6c6c44fe47ec050000\"},\"e60955dc0bc156f6c41849f6bd776ba44b0ef0a1\":{\"balance\":\"0x10431627a0933b0000\"},\"e60a55f2df996dc3aedb696c08dde039b2641de8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e6115b13f9795f7e956502d5074567dab945ce6b\":{\"balance\":\"0x152d02c7e14af6800000\"},\"e61f280915c774a31d223cf80c069266e5adf19b\":{\"balance\":\"0x2fb474098f67c00000\"},\"e62f98650712eb158753d82972b8e99ca3f61877\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e62f9d7c64e8e2635aeb883dd73ba684ee7c1079\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"e63e787414b9048478a50733359ecdd7e3647aa6\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"e646665872e40b0d7aa2ff82729caaba5bc3e89e\":{\"balance\":\"0x15af1d78b58c400000\"},\"e64ef012658d54f8e8609c4e9023c09fe865c83b\":{\"balance\":\"0x18493fba64ef00000\"},\"e64f6e1d6401b56c076b64a1b0867d0b2f310d4e\":{\"balance\":\"0x2cbad71c53ae50000\"},\"e667f652f957c28c0e66d0b63417c80c8c9db878\":{\"balance\":\"0x209d922f5259c50000\"},\"e677c31fd9cb720075dca49f1abccd59ec33f734\":{\"balance\":\"0x1a6d6beb1d42ee00000\"},\"e67c2c1665c88338688187629f49e99b60b2d3ba\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e69a6cdb3a8a7db8e1f30c8b84cd73bae02bc0f8\":{\"balance\":\"0x394fdc2e452f6718000\"},\"e69d1c378b771e0feff051db69d966ac6779f4ed\":{\"balance\":\"0x1dfa6aaa1497040000\"},\"e69fcc26ed225f7b2e379834c524d70c1735e5bc\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e6a3010f0201bc94ff67a2f699dfc206f9e76742\":{\"balance\":\"0x2fa7cbf66464980000\"},\"e6a6f6dd6f70a456f4ec15ef7ad5e5dbb68bd7dc\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e6b20f980ad853ad04cbfc887ce6601c6be0b24c\":{\"balance\":\"0xd8d726b7177a800000\"},\"e6b3ac3f5d4da5a8857d0b3f30fc4b2b692b77d7\":{\"balance\":\"0x4f2591f896a6500000\"},\"e6b9545f7ed086e552924639f9a9edbbd5540b3e\":{\"balance\":\"0xcbd47b6eaa8cc00000\"},\"e6bcd30a8fa138c5d9e5f6c7d2da806992812dcd\":{\"balance\":\"0x370ea0d47cf61a800000\"},\"e6c81ffcecb47ecdc55c0b71e4855f3e5e97fc1e\":{\"balance\":\"0x121ea68c114e510000\"},\"e6cb260b716d4c0ab726eeeb07c8707204e276ae\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e6cb3f3124c9c9cc3834b1274bc3336456a38bac\":{\"balance\":\"0x172b1de0a213ff0000\"},\"e6d22209ffd0b87509ade3a8e2ef429879cb89b5\":{\"balance\":\"0x3a7aa9e1899ca300000\"},\"e6d49f86c228f47367a35e886caacb271e539429\":{\"balance\":\"0x165ec09da7a1980000\"},\"e6e621eaab01f20ef0836b7cad47464cb5fd3c96\":{\"balance\":\"0x11219342afa24b0000\"},\"e6e886317b6a66a5b4f81bf164c538c264351765\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e6e9a39d750fe994394eb68286e5ea62a6997882\":{\"balance\":\"0x2086ac351052600000\"},\"e6ec5cf0c49b9c317e1e706315ef9eb7c0bf11a7\":{\"balance\":\"0x3a469f3467e8ec00000\"},\"e6f5eb649afb99599c414b27a9c9c855357fa878\":{\"balance\":\"0x90f534608a72880000\"},\"e6fe0afb9dcedd37b2e22c451ba6feab67348033\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e710dcd09b8101f9437bd97db90a73ef993d0bf4\":{\"balance\":\"0x14ee36c05ac2520000\"},\"e727e67ef911b81f6cf9c73fcbfebc2b02b5bfc6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e72e1d335cc29a96b9b1c02f003a16d971e90b9d\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"e7311c9533f0092c7248c9739b5b2c864a34b1ce\":{\"balance\":\"0x97f97d6cc26dfe0000\"},\"e73bfeada6f0fd016fbc843ebcf6e370a65be70c\":{\"balance\":\"0x6acb3df27e1f880000\"},\"e73ccf436725c151e255ccf5210cfce5a43f13e3\":{\"balance\":\"0x1154e53217ddb0000\"},\"e742b1e6069a8ffc3c4767235defb0d49cbed222\":{\"balance\":\"0x2b5e3af16b18800000\"},\"e74608f506866ada6bfbfdf20fea440be76989ef\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"e7533e270cc61fa164ac1553455c105d04887e14\":{\"balance\":\"0x696d8590020bb0000\"},\"e75c1fb177089f3e58b1067935a6596ef1737fb5\":{\"balance\":\"0x56a879fa775470000\"},\"e75c3b38a58a3f33d55690a5a59766be185e0284\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e761d27fa3502cc76bb1a608740e1403cf9dfc69\":{\"balance\":\"0xf2dc7d47f15600000\"},\"e766f34ff16f3cfcc97321721f43ddf5a38b0cf4\":{\"balance\":\"0x54069233bf7f780000\"},\"e76d945aa89df1e457aa342b31028a5e9130b2ce\":{\"balance\":\"0x3708baed3d68900000\"},\"e7735ec76518fc6aa92da8715a9ee3f625788f13\":{\"balance\":\"0x6c4d160bafa1b78000\"},\"e77a89bd45dc04eeb4e41d7b596b707e6e51e74c\":{\"balance\":\"0x28a857425466f800000\"},\"e77d7deab296c8b4fa07ca3be184163d5a6d606c\":{\"balance\":\"0x5043904b671190000\"},\"e77febabdf080f0f5dca1d3f5766f2a79c0ffa7c\":{\"balance\":\"0x4b229d28a843680000\"},\"e780a56306ba1e6bb331952c22539b858af9f77d\":{\"balance\":\"0xa968163f0a57b400000\"},\"e781ec732d401202bb9bd13860910dd6c29ac0b6\":{\"balance\":\"0x433874f632cc600000\"},\"e784dcc873aa8c1513ec26ff36bc92eac6d4c968\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e7912d4cf4562c573ddc5b71e37310e378ef86c9\":{\"balance\":\"0x155bd9307f9fe80000\"},\"e791d585b89936b25d298f9d35f9f9edc25a2932\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e792349ce9f6f14f81d0674096befa1f9221cdea\":{\"balance\":\"0x5b5d234a0db4388000\"},\"e796fd4e839b4c95d7510fb7c5c72b83c6c3e3c7\":{\"balance\":\"0x1bc433f23f83140000\"},\"e7a42f59fee074e4fb13ea9e57ecf1cc48282249\":{\"balance\":\"0x43c33c1937564800000\"},\"e7a4560c84b20e0fb54c49670c2903b0a96c42a4\":{\"balance\":\"0x206aeac7a903980000\"},\"e7a8e471eafb798f4554cc6e526730fd56e62c7d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e7be82c6593c1eeddd2ae0b15001ff201ab57b2f\":{\"balance\":\"0x10910d4cdc9f60000\"},\"e7c6b5fc05fc748e5b4381726449a1c0ad0fb0f1\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e7d17524d00bad82497c0f27156a647ff51d2792\":{\"balance\":\"0x1158e460913d00000\"},\"e7d213947fcb904ad738480b1eed2f5c329f27e8\":{\"balance\":\"0x103c3b1d3e9c30000\"},\"e7d6240620f42c5edbb2ede6aec43da4ed9b5757\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e7da609d40cde80f00ce5b4ffb6aa9d0b03494fc\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e7f06f699be31c440b43b4db0501ec0e25261644\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e7f4d7fe6f561f7fa1da3005fd365451ad89df89\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e7fd8fd959aed2767ea7fa960ce1db53af802573\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e80e7fef18a5db15b01473f3ad6b78b2a2f8acd9\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e8137fc1b2ec7cc7103af921899b4a39e1d959a1\":{\"balance\":\"0x50c5e761a444080000\"},\"e81c2d346c0adf4cc56708f6394ba6c8c8a64a1e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e82c58c579431b673546b53a86459acaf1de9b93\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e834c64318205ca7dd4a21abcb08266cb21ff02c\":{\"balance\":\"0x3635c6204739d98000\"},\"e83604e4ff6be7f96f6018d3ec3072ec525dff6b\":{\"balance\":\"0x9ddc1e3b901180000\"},\"e845e387c4cbdf982280f6aa01c40e4be958ddb2\":{\"balance\":\"0x54b40b1f852bda00000\"},\"e848ca7ebff5c24f9b9c316797a43bf7c356292d\":{\"balance\":\"0x62e115c008a880000\"},\"e84b55b525f1039e744b918cb3332492e45eca7a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e84f8076a0f2969ecd333eef8de41042986291f2\":{\"balance\":\"0x176b344f2a78c00000\"},\"e864fec07ed1214a65311e11e329de040d04f0fd\":{\"balance\":\"0x59ca83f5c404968000\"},\"e87dbac636a37721df54b08a32ef4959b5e4ff82\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e87e9bbfbbb71c1a740c74c723426df55d063dd9\":{\"balance\":\"0x1b1928c00c7a6380000\"},\"e87eac6d602b4109c9671bf57b950c2cfdb99d55\":{\"balance\":\"0x2b4f21972ecce0000\"},\"e881bbbe69722d81efecaa48d1952a10a2bfac8f\":{\"balance\":\"0x3635c9adc5dea000000\"},\"e89249738b7eced7cb666a663c49cbf6de8343ea\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e89c22f1a4e1d4746ecfaa59ed386fee12d51e37\":{\"balance\":\"0x26f8e87f0a7da0000\"},\"e89da96e06beaf6bd880b378f0680c43fd2e9d30\":{\"balance\":\"0x209a1a01a56fec0000\"},\"e8a91da6cf1b9d65c74a02ec1f96eecb6dd241f3\":{\"balance\":\"0x692ae8897081d00000\"},\"e8a9a41740f44f54c3688b53e1ddd42e43c9fe94\":{\"balance\":\"0xd8d726b7177a800000\"},\"e8b28acda971725769db8f563d28666d41ddab6c\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e8be24f289443ee473bc76822f55098d89b91cc5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e8c3d3b0e17f97d1e756e684f94e1470f99c95a1\":{\"balance\":\"0x15af1d78b58c400000\"},\"e8c3f045bb7d38c9d2f395b0ba8492b253230901\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"e8cc43bc4f8acf39bff04ebfbf42aac06a328470\":{\"balance\":\"0x15af1d78b58c400000\"},\"e8d942d82f175ecb1c16a405b10143b3f46b963a\":{\"balance\":\"0x1ed2e8ff6d971c0000\"},\"e8ddbed732ebfe754096fde9086b8ea4a4cdc616\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e8de725eca5def805ff7941d31ac1c2e342dfe95\":{\"balance\":\"0x857e0d6f1da76a0000\"},\"e8e9850586e94f5299ab494bb821a5f40c00bd04\":{\"balance\":\"0xcf152640c5c8300000\"},\"e8ead1bb90ccc3aea2b0dcc5b58056554655d1d5\":{\"balance\":\"0x1a4aba225c207400000\"},\"e8eaf12944092dc3599b3953fa7cb1c9761cc246\":{\"balance\":\"0x6194049f30f7200000\"},\"e8ed51bbb3ace69e06024b33f86844c47348db9e\":{\"balance\":\"0x22f9ea89f4a7d6c40000\"},\"e8ef100d7ce0895832f2678df72d4acf8c28b8e3\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"e8f29969e75c65e01ce3d86154207d0a9e7c76f2\":{\"balance\":\"0xa22fa9a73a27198000\"},\"e8fc36b0131ec120ac9e85afc10ce70b56d8b6ba\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e90a354cec04d69e5d96ddc0c5138d3d33150aa0\":{\"balance\":\"0x1b1a7dcf8a44d38000\"},\"e9133e7d31845d5f2b66a2618792e869311acf66\":{\"balance\":\"0x517c0cbf9a390880000\"},\"e91dac0195b19e37b59b53f7c017c0b2395ba44c\":{\"balance\":\"0x65ea3db75546600000\"},\"e91fa0badaddb9a97e88d3f4db7c55d6bb7430fe\":{\"balance\":\"0x14620c57dddae00000\"},\"e923c06177b3427ea448c0a6ff019b54cc548d95\":{\"balance\":\"0x1f780014667f28000\"},\"e93d47a8ca885d540c4e526f25d5c6f2c108c4b8\":{\"balance\":\"0x17da3a04c7b3e0000000\"},\"e9458f68bb272cb5673a04f781b403556fd3a387\":{\"balance\":\"0x34e8b88cee2d40000\"},\"e94941b6036019b4016a30c1037d5a6903babaad\":{\"balance\":\"0x2a48acab6204b00000\"},\"e9495ba5842728c0ed97be37d0e422b98d69202c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e94ded99dcb572b9bb1dcba32f6dee91e057984e\":{\"balance\":\"0x155bd9307f9fe80000\"},\"e95179527deca5916ca9a38f215c1e9ce737b4c9\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e9559185f166fc9513cc71116144ce2deb0f1d4b\":{\"balance\":\"0x43c33c1937564800000\"},\"e95e92bbc6de07bf3a660ebf5feb1c8a3527e1c5\":{\"balance\":\"0xfc936392801c0000\"},\"e965daa34039f7f0df62375a37e5ab8a72b301e7\":{\"balance\":\"0x103fddecdb3f5700000\"},\"e969ea1595edc5c4a707cfde380929633251a2b0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e96b184e1f0f54924ac874f60bbf44707446b72b\":{\"balance\":\"0x9dcc0515b56e0c0000\"},\"e96d7d4cdd15553a4e4d316d6d6480ca3cea1e38\":{\"balance\":\"0x2955d02e1a135a00000\"},\"e96e2d3813efd1165f12f602f97f4a62909d3c66\":{\"balance\":\"0x7caee97613e6700000\"},\"e97fde0b67716325cf0ecce8a191a3761b2c791d\":{\"balance\":\"0x3677036edf0af60000\"},\"e982e6f28c548f5f96f45e63f7ab708724f53fa1\":{\"balance\":\"0x157ae829a41f3b0000\"},\"e9864c1afc8eaad37f3ba56fcb7477cc622009b7\":{\"balance\":\"0x448586170a7dc0000\"},\"e987e6139e6146a717fef96bc24934a5447fe05d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e989733ca1d58d9e7b5029ba5d444858bec03172\":{\"balance\":\"0x1f87408313df4f8000\"},\"e98c91cadd924c92579e11b41217b282956cdaa1\":{\"balance\":\"0x75c9a8480320c0000\"},\"e99aece90541cae224b87da673965e0aeb296afd\":{\"balance\":\"0x31df9095a18f600000\"},\"e99de258a4173ce9ac38ede26c0b3bea3c0973d5\":{\"balance\":\"0x59d0b805e5bb300000\"},\"e9a2b4914e8553bf0d7c00ca532369b879f931bf\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e9a39a8bac0f01c349c64cedb69897f633234ed2\":{\"balance\":\"0xd7c198710e66b00000\"},\"e9a5ae3c9e05977dd1069e9fd9d3aefbae04b8df\":{\"balance\":\"0x6acb3df27e1f880000\"},\"e9ac36376efa06109d40726307dd1a57e213eaa9\":{\"balance\":\"0xa844a7424d9c80000\"},\"e9b1f1fca3fa47269f21b061c353b7f5e96d905a\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"e9b36fe9b51412ddca1a521d6e94bc901213dda8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"e9b4a4853577a9dbcc2e795be0310d1bed28641a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"e9b6a790009bc16642c8d820b7cde0e9fd16d8f5\":{\"balance\":\"0xc55325ca7415e00000\"},\"e9b9a2747510e310241d2ece98f56b3301d757e0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e9c35c913ca1fceab461582fe1a5815164b4fd21\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"e9c6dfae97f7099fc5f4e94b784db802923a1419\":{\"balance\":\"0x2a53c6d724f100000\"},\"e9c758f8da41e3346e4350e5ac3976345c6c1082\":{\"balance\":\"0x68a0d3092826ad0000\"},\"e9caf827be9d607915b365c83f0d3b7ea8c79b50\":{\"balance\":\"0xa2a15d09519be00000\"},\"e9cafe41a5e8bbd90ba02d9e06585b4eb546c57f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"e9d599456b2543e6db80ea9b210e908026e2146e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"e9e1f7cb00a110edd0ebf8b377ef8a7bb856117f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ea14bfda0a6e76668f8788321f07df37824ec5df\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"ea1ea0c599afb9cd36caacbbb52b5bbb97597377\":{\"balance\":\"0x39fbae8d042dd00000\"},\"ea1efb3ce789bedec3d67c3e1b3bc0e9aa227f90\":{\"balance\":\"0x27ca4bd719f0b80000\"},\"ea2c197d26e98b0da83e1b72c787618c979d3db0\":{\"balance\":\"0x11164759ffb320000\"},\"ea3779d14a13f6c78566bcde403591413a6239db\":{\"balance\":\"0x29b76432b94451200000\"},\"ea4e809e266ae5f13cdbe38f9d0456e6386d1274\":{\"balance\":\"0xf3f20b8dfa69d00000\"},\"ea53c954f4ed97fd4810111bdab69ef981ef25b9\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"ea53d26564859d9e90bb0e53b7abf560e0162c38\":{\"balance\":\"0x15af1d78b58c400000\"},\"ea60436912de6bf187d3a472ff8f5333a0f7ed06\":{\"balance\":\"0x11164759ffb320000\"},\"ea60549ec7553f511d2149f2d4666cbd9243d93c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ea66e7b84dcdbf36eea3e75b85382a75f1a15d96\":{\"balance\":\"0x5dbc9191266f118000\"},\"ea686c5057093c171c66db99e01b0ececb308683\":{\"balance\":\"0x14dda85d2ce1478000\"},\"ea6afe2cc928ac8391eb1e165fc40040e37421e7\":{\"balance\":\"0xa27fa063b2e2e68000\"},\"ea79057dabef5e64e7b44f7f18648e7e533718d2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ea7c4d6dc729cd6b157c03ad237ca19a209346c3\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ea8168fbf225e786459ca6bb18d963d26b505309\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ea81ca8638540cd9d4d73d060f2cebf2241ffc3e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ea8317197959424041d9d7c67a3ece1dbb78bb55\":{\"balance\":\"0x155bd9307f9fe80000\"},\"ea8527febfa1ade29e26419329d393b940bbb7dc\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"ea8f30b6e4c5e65290fb9864259bc5990fa8ee8a\":{\"balance\":\"0x1158e460913d00000\"},\"ea94f32808a2ef8a9bf0861d1d2404f7b7be258a\":{\"balance\":\"0x1158e460913d00000\"},\"eaa45cea02d87d2cc8fda9434e2d985bd4031584\":{\"balance\":\"0x681fc2cc6e2b8b0000\"},\"eab0bd148309186cf8cbd13b7232d8095acb833a\":{\"balance\":\"0x2439a881c6a717c0000\"},\"eabb90d37989aab31feae547e0e6f3999ce6a35d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eac0827eff0c6e3ff28a7d4a54f65cb7689d7b99\":{\"balance\":\"0x9ad9e69f9d47520000\"},\"eac1482826acb6111e19d340a45fb851576bed60\":{\"balance\":\"0x1be8bab04d9be8000\"},\"eac17b81ed5191fb0802aa54337313834107aaa4\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"eac3af5784927fe9a598fc4eec38b8102f37bc58\":{\"balance\":\"0x3635c9adc5dea00000\"},\"eac6b98842542ea10bb74f26d7c7488f698b6452\":{\"balance\":\"0x43c33c1937564800000\"},\"eac768bf14b8f9432e69eaa82a99fbeb94cd0c9c\":{\"balance\":\"0x14dbb2195ca228900000\"},\"ead21c1deccfbf1c5cd96688a2476b69ba07ce4a\":{\"balance\":\"0x3f24d8e4a00700000\"},\"ead4d2eefb76abae5533961edd11400406b298fc\":{\"balance\":\"0xd255d112e103a00000\"},\"ead65262ed5d122df2b2751410f98c32d1238f51\":{\"balance\":\"0x58317ed46b9b80000\"},\"ead75016e3a0815072b6b108bcc1b799acf0383e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eaea23aa057200e7c9c15e8ff190d0e66c0c0e83\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eaed16eaf5daab5bf0295e5e077f59fb8255900b\":{\"balance\":\"0xd8d726b7177a800000\"},\"eaedcc6b8b6962d5d9288c156c579d47c0a9fcff\":{\"balance\":\"0x49b9ca9a694340000\"},\"eaf52388546ec35aca6f6c6393d8d609de3a4bf3\":{\"balance\":\"0x1158e460913d00000\"},\"eb10458daca79e4a6b24b29a8a8ada711b7f2eb6\":{\"balance\":\"0xd8bb6549b02bb80000\"},\"eb1cea7b45d1bd4d0e2a007bd3bfb354759e2c16\":{\"balance\":\"0xabbcd4ef377580000\"},\"eb25481fcd9c221f1ac7e5fd1ecd9307a16215b8\":{\"balance\":\"0xaadec983fcff40000\"},\"eb2ef3d38fe652403cd4c9d85ed7f0682cd7c2de\":{\"balance\":\"0x90f534608a728800000\"},\"eb3bdd59dcdda5a9bb2ac1641fd02180f5f36560\":{\"balance\":\"0x165c96647b38a200000\"},\"eb3ce7fc381c51db7d5fbd692f8f9e058a4c703d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"eb453f5a3adddd8ab56750fadb0fe7f94d9c89e7\":{\"balance\":\"0x1158e460913d00000\"},\"eb4f00e28336ea09942588eeac921811c522143c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eb52ab10553492329c1c54833ae610f398a65b9d\":{\"balance\":\"0x83d6c7aab63600000\"},\"eb570dba975227b1c42d6e8dea2c56c9ad960670\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eb6394a7bfa4d28911d5a5b23e93f35e340c2294\":{\"balance\":\"0x43a77aabd00780000\"},\"eb6810691d1ae0d19e47bd22cebee0b3ba27f88a\":{\"balance\":\"0x87856315d878150000\"},\"eb76424c0fd597d3e341a9642ad1ee118b2b579d\":{\"balance\":\"0xd8d726b7177a800000\"},\"eb7c202b462b7cc5855d7484755f6e26ef43a115\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eb835c1a911817878a33d167569ea3cdd387f328\":{\"balance\":\"0x3635c9adc5dea00000\"},\"eb89a882670909cf377e9e78286ee97ba78d46c2\":{\"balance\":\"0x2b7cc2e9c3225c0000\"},\"eb90c793b3539761e1c814a29671148692193eb4\":{\"balance\":\"0x28a857425466f800000\"},\"eb9cc9fe0869d2dab52cc7aae8fd57adb35f9feb\":{\"balance\":\"0x6a93bb17af81f80000\"},\"eba388b0da27c87b1cc0eac6c57b2c5a0b459c1a\":{\"balance\":\"0x170a0f5040e50400000\"},\"ebaa216de9cc5a43031707d36fe6d5bedc05bdf0\":{\"balance\":\"0x6ac5c62d9486070000\"},\"ebac2b4408ef5431a13b8508e86250982114e145\":{\"balance\":\"0xd8d726b7177a800000\"},\"ebb62cf8e22c884b1b28c6fa88fbbc17938aa787\":{\"balance\":\"0x2b42798403c9b80000\"},\"ebb7d2e11bc6b58f0a8d45c2f6de3010570ac891\":{\"balance\":\"0x1731790534df20000\"},\"ebbb4f2c3da8be3eb62d1ffb1f950261cf98ecda\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ebbd4db9019952d68b1b0f6d8cf0683c00387bb5\":{\"balance\":\"0x120401563d7d910000\"},\"ebbeeb259184a6e01cccfc2207bbd883785ac90a\":{\"balance\":\"0x219bc1b04783d30000\"},\"ebd356156a383123343d48843bffed6103e866b3\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ebd37b256563e30c6f9289a8e2702f0852880833\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"ebe46cc3c34c32f5add6c3195bb486c4713eb918\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ebff84bbef423071e604c361bba677f5593def4e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"ec0927bac7dc36669c28354ab1be83d7eec30934\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ec0e18a01dc4dc5daae567c3fa4c7f8f9b590205\":{\"balance\":\"0x111ffe404a41e60000\"},\"ec11362cec810985d0ebbd7b73451444985b369f\":{\"balance\":\"0x65a4e49577057318000\"},\"ec2cb8b9378dff31aec3c22e0e6dadff314ab5dd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ec30addd895b82ee319e54fb04cb2bb03971f36b\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ec3b8b58a12703e581ce5ffd7e21c57d1e5c663f\":{\"balance\":\"0x5c283d410394100000\"},\"ec4867d2175ab5b9469361595546554684cda460\":{\"balance\":\"0xa2a15d09519be00000\"},\"ec4d08aa2e47496dca87225de33f2b40a8a5b36f\":{\"balance\":\"0x890b0c2e14fb80000\"},\"ec58bc0d0c20d8f49465664153c5c196fe59e6be\":{\"balance\":\"0x15af1d78b58c400000\"},\"ec5b198a00cfb55a97b5d53644cffa8a04d2ab45\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ec5df227bfa85d7ad76b426e1cee963bc7f519dd\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ec5feafe210c12bfc9a5d05925a123f1e73fbef8\":{\"balance\":\"0x608fcf3d88748d000000\"},\"ec6904bae1f69790591709b0609783733f2573e3\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ec73114c5e406fdbbe09b4fa621bd70ed54ea1ef\":{\"balance\":\"0x53025cd216fce500000\"},\"ec73833de4b810bb027810fc8f69f544e83c12d1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ec75b4a47513120ba5f86039814f1998e3817ac3\":{\"balance\":\"0x9b0bce2e8fdba0000\"},\"ec76f12e57a65504033f2c0bce6fc03bd7fa0ac4\":{\"balance\":\"0xc2127af858da700000\"},\"ec8014efc7cbe5b0ce50f3562cf4e67f8593cd32\":{\"balance\":\"0xf015f25736420000\"},\"ec82f50d06475f684df1b392e00da341aa145444\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ec83e798c396b7a55e2a2224abcd834b27ea459c\":{\"balance\":\"0x28a857425466f800000\"},\"ec89f2b678a1a15b9134ec5eb70c6a62071fbaf9\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ec8c1d7b6aaccd429db3a91ee4c9eb1ca4f6f73c\":{\"balance\":\"0xe664992288f2280000\"},\"ec9851bd917270610267d60518b54d3ca2b35b17\":{\"balance\":\"0x878678326eac9000000\"},\"ec99e95dece46ffffb175eb6400fbebb08ee9b95\":{\"balance\":\"0x56bc75e2d63100000\"},\"eca5f58792b8c62d2af556717ee3ee3028be4dce\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ecab5aba5b828de1705381f38bc744b32ba1b437\":{\"balance\":\"0x32f51edbaaa3300000\"},\"ecaf3350b7ce144d068b186010852c84dd0ce0f0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ecb94c568bfe59ade650645f4f26306c736cace4\":{\"balance\":\"0xe7eeba3410b740000\"},\"ecbe425e670d39094e20fb5643a9d818eed236de\":{\"balance\":\"0x10f0cf064dd59200000\"},\"ecbe5e1c9ad2b1dccf0a305fc9522f4669dd3ae7\":{\"balance\":\"0x10f0cf064dd59200000\"},\"eccf7a0457b566b346ca673a180f444130216ac3\":{\"balance\":\"0x56bc75e2d63100000\"},\"ecd1a62802351a41568d23033004acc6c005a5d3\":{\"balance\":\"0x2b5e3af16b1880000\"},\"ecd276af64c79d1bd9a92b86b5e88d9a95eb88f8\":{\"balance\":\"0x1158e460913d00000\"},\"ecd486fc196791b92cf612d348614f9156488b7e\":{\"balance\":\"0x28a857425466f800000\"},\"ecdaf93229b45ee672f65db506fb5eca00f7fce6\":{\"balance\":\"0x5701f96dcc40ee8000\"},\"ece111670b563ccdbebca52384290ecd68fe5c92\":{\"balance\":\"0x1158e460913d00000\"},\"ece1152682b7598fe2d1e21ec15533885435ac85\":{\"balance\":\"0xd8d726b7177a800000\"},\"ece1290877b583e361a2d41b009346e6274e2538\":{\"balance\":\"0x1043561a8829300000\"},\"ecf05d07ea026e7ebf4941002335baf2fed0f002\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ecf24cdd7c22928c441e694de4aa31b0fab59778\":{\"balance\":\"0x2086ac351052600000\"},\"ecfd004d02f36cd4d8b4a8c1a9533b6af85cd716\":{\"balance\":\"0x10f41acb4bb3b9c0000\"},\"ed0206cb23315128f8caff26f6a30b985467d022\":{\"balance\":\"0x878678326eac9000000\"},\"ed1065dbcf9d73c04ffc7908870d881468c1e132\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ed1276513b6fc68628a74185c2e20cbbca7817bf\":{\"balance\":\"0xa5aa85009e39c0000\"},\"ed12a1ba1fb8adfcb20dfa19582e525aa3b74524\":{\"balance\":\"0x16a6502f15a1e540000\"},\"ed16ce39feef3bd7f5d162045e0f67c0f00046bb\":{\"balance\":\"0x1158e460913d00000\"},\"ed1a5c43c574d4e934299b24f1472cdc9fd6f010\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ed1b24b6912d51b334ac0de6e771c7c0454695ea\":{\"balance\":\"0x22b1c8c1227a00000\"},\"ed1f1e115a0d60ce02fb25df014d289e3a0cbe7d\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"ed31305c319f9273d3936d8f5b2f71e9b1b22963\":{\"balance\":\"0x56bc75e2d63100000\"},\"ed327a14d5cfadd98103fc0999718d7ed70528ea\":{\"balance\":\"0x4e1003b28d92800000\"},\"ed3cbc3782cebd67989b305c4133b2cde32211eb\":{\"balance\":\"0x15af1d78b58c400000\"},\"ed4014538cee664a2fbcb6dc669f7ab16d0ba57c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ed41e1a28f5caa843880ef4e8b08bd6c33141edf\":{\"balance\":\"0x2ad5ddfa7a8d830000\"},\"ed4be04a052d7accb3dcce90319dba4020ab2c68\":{\"balance\":\"0x7f37a70eaf362178000\"},\"ed52a2cc0869dc9e9f842bd0957c47a8e9b0c9ff\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"ed5b4c41e762d942404373caf21ed4615d25e6c1\":{\"balance\":\"0x6d2d4f3d9525b40000\"},\"ed60c4ab6e540206317e35947a63a9ca6b03e2cb\":{\"balance\":\"0x31ad9ad0b467f8000\"},\"ed641e06368fb0efaa1703e01fe48f4a685309eb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ed6643c0e8884b2d3211853785a08bf8f33ed29f\":{\"balance\":\"0x487a9a304539440000\"},\"ed70a37cdd1cbda9746d939658ae2a6181288578\":{\"balance\":\"0x2086ac3510526000000\"},\"ed7346766e1a676d0d06ec821867a276a083bf31\":{\"balance\":\"0xd98a0931cc2d490000\"},\"ed862616fcbfb3becb7406f73c5cbff00c940755\":{\"balance\":\"0x5c283d410394100000\"},\"ed9e030ca75cb1d29ea01d0d4cdfdccd3844b6e4\":{\"balance\":\"0x1acc116cfafb18000\"},\"ed9ebccba42f9815e78233266dd6e835b6afc31b\":{\"balance\":\"0x14542ba12a337c00000\"},\"ed9fb1f5af2fbf7ffc5029cee42b70ff5c275bf5\":{\"balance\":\"0xf2dc7d47f15600000\"},\"eda4b2fa59d684b27a810df8978a73df308a63c2\":{\"balance\":\"0xd8d726b7177a800000\"},\"edb473353979a206879de144c10a3c51d7d7081a\":{\"balance\":\"0x14542ba12a337c00000\"},\"edb71ec41bda7dce86e766e6e8c3e9907723a69b\":{\"balance\":\"0x1158e460913d00000\"},\"edbac9527b54d6df7ae2e000cca3613ba015cae3\":{\"balance\":\"0x6acb3df27e1f880000\"},\"edc22fb92c638e1e21ff5cf039daa6e734dafb29\":{\"balance\":\"0x102794ad20da680000\"},\"eddacd94ec89a2ef968fcf977a08f1fae2757869\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"eddbaafbc21be8f25562f1ed6d05d6afb58f02c2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ede0147ec032c3618310c1ff25690bf172193dac\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ede5de7c7fb7eee0f36e64530a41440edfbefacf\":{\"balance\":\"0x21755ee1ef2b180000\"},\"ede79ae1ff4f1606d59270216fa46ab2ddd4ecaa\":{\"balance\":\"0x7ea28327577080000\"},\"ede8c2cb876fbe8a4cca8290361a7ea01a69fdf8\":{\"balance\":\"0x1a78c6b44f841838000\"},\"edeb4894aadd0081bbddd3e8846804b583d19f27\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"edf603890228d7d5de9309942b5cad4219ef9ad7\":{\"balance\":\"0x10f0cf064dd59200000\"},\"edf8a3e1d40f13b79ec8e3e1ecf262fd92116263\":{\"balance\":\"0x890b0c2e14fb80000\"},\"edfda2d5db98f9380714664d54b4ee971a1cae03\":{\"balance\":\"0x22bb8ddd679be0000\"},\"ee0007b0960d00908a94432a737557876aac7c31\":{\"balance\":\"0x2e0421e69c4cc8000\"},\"ee049af005974dd1c7b3a9ca8d9aa77175ba53aa\":{\"balance\":\"0x1211ecb56d13488000\"},\"ee25b9a7032679b113588ed52c137d1a053a1e94\":{\"balance\":\"0xad50f3f4eea8e0000\"},\"ee31167f9cc93b3c6465609d79db0cde90e8484c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ee34c7e7995db9f187cff156918cfb6f13f6e003\":{\"balance\":\"0x6a4076cf7995a00000\"},\"ee3564f5f1ba0f94ec7bac164bddbf31c6888b55\":{\"balance\":\"0x56bc75e2d63100000\"},\"ee58fb3db29070d0130188ce472be0a172b89055\":{\"balance\":\"0x21f42dcdc58e39c0000\"},\"ee655bb4ee0e8d5478526fb9f15e4064e09ff3dd\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ee6959de2b67967b71948c891ab00d8c8f38c7dc\":{\"balance\":\"0x6685ac1bfe32c0000\"},\"ee6c03429969ca1262cb3f0a4a54afa7d348d7f5\":{\"balance\":\"0xde219f91fc18a0000\"},\"ee71793e3acf12a7274f563961f537529d89c7de\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ee7288d91086d9e2eb910014d9ab90a02d78c2a0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ee7c3ded7c28f459c92fe13b4d95bafbab02367d\":{\"balance\":\"0x25f273933db5700000\"},\"ee867d20916bd2e9c9ece08aa04385db667c912e\":{\"balance\":\"0xa968163f0a57b400000\"},\"ee899b02cbcb3939cd61de1342d50482abb68532\":{\"balance\":\"0x5f68e8131ecf800000\"},\"ee906d7d5f1748258174be4cbc38930302ab7b42\":{\"balance\":\"0xad78ebc5ac6200000\"},\"ee97aa8ac69edf7a987d6d70979f8ec1fbca7a94\":{\"balance\":\"0x14620c57dddae00000\"},\"eea1e97988de75d821cd28ad6822b22cce988b31\":{\"balance\":\"0x1c30731cec03200000\"},\"eed28c3f068e094a304b853c950a6809ebcb03e0\":{\"balance\":\"0x3a9d5baa4abf1d00000\"},\"eed384ef2d41d9d203974e57c12328ea760e08ea\":{\"balance\":\"0x3635c9adc5dea00000\"},\"eedf6c4280e6eb05b934ace428e11d4231b5905b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"eee761847e33fd61d99387ee14628694d1bfd525\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"eee9d0526eda01e43116a395322dda8970578f39\":{\"balance\":\"0x21e1999bbd5d2be0000\"},\"eef1bbb1e5a83fde8248f88ee3018afa2d1332eb\":{\"balance\":\"0xad78ebc5ac6200000\"},\"eefba12dfc996742db790464ca7d273be6e81b3e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"eefd05b0e3c417d55b3343060486cdd5e92aa7a6\":{\"balance\":\"0x4d853c8f8908980000\"},\"ef0dc7dd7a53d612728bcbd2b27c19dd4d7d666f\":{\"balance\":\"0x26411c5b35f05a0000\"},\"ef115252b1b845cd857f002d630f1b6fa37a4e50\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ef1c0477f1184d60accab374d374557a0a3e10f3\":{\"balance\":\"0x83d6c7aab63600000\"},\"ef2c34bb487d3762c3cca782ccdd7a8fbb0a9931\":{\"balance\":\"0x9c2007651b2500000\"},\"ef35f6d4b1075e6aa139151c974b2f4658f70538\":{\"balance\":\"0x3c3bc33f94e50d8000\"},\"ef39ca9173df15531d73e6b72a684b51ba0f2bb4\":{\"balance\":\"0x56a0b4756ee2380000\"},\"ef463c2679fb279164e20c3d2691358773a0ad95\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ef47cf073e36f271d522d7fa4e7120ad5007a0bc\":{\"balance\":\"0x878678326eac900000\"},\"ef61155ba009dcdebef10b28d9da3d1bc6c9ced4\":{\"balance\":\"0x3342d60dff1960000\"},\"ef69781f32ffce33346f2c9ae3f08493f3e82f89\":{\"balance\":\"0xfc936392801c0000\"},\"ef76a4cd8febcbc9b818f17828f8d93473f3f3cb\":{\"balance\":\"0xd8d726b7177a800000\"},\"ef93818f684db0c3675ec81332b3183ecc28a495\":{\"balance\":\"0x54069233bf7f780000\"},\"ef9f59aeda418c1494682d941aab4924b5f4929a\":{\"balance\":\"0x152d02c7e14af6800000\"},\"efa6b1f0db603537826891b8b4bc163984bb40cd\":{\"balance\":\"0x35659ef93f0fc40000\"},\"efbd52f97da5fd3a673a46cbf330447b7e8aad5c\":{\"balance\":\"0x56c3c9b80a0a68000\"},\"efc8cf1963c9a95267b228c086239889f4dfd467\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"efcaae9ff64d2cd95b5249dcffe7faa0a0c0e44d\":{\"balance\":\"0x15be6174e1912e0000\"},\"efcce06bd6089d0e458ef561f5a689480afe7000\":{\"balance\":\"0x2086ac351052600000\"},\"efe0675da98a5dda70cd96196b87f4e726b43348\":{\"balance\":\"0x3f19beb8dd1ab00000\"},\"efe8ff87fc260e0767638dd5d02fc4672e0ec06d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"efeb1997aad277cc33430e6111ed0943594048b8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"efeea010756f81da4ba25b721787f058170befbd\":{\"balance\":\"0x1c29c9cf770ef0000\"},\"eff51d72adfae143edf3a42b1aec55a2ccdd0b90\":{\"balance\":\"0x1043561a8829300000\"},\"eff86b5123bcdc17ed4ce8e05b7e12e51393a1f7\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"effc15e487b1beda0a8d1325bdb4172240dc540a\":{\"balance\":\"0x3853939eee1de0000\"},\"f01195d657ef3c942e6cb83949e5a20b5cfa8b1e\":{\"balance\":\"0x57473d05dabae800000\"},\"f02796295101674288c1d93467053d042219b794\":{\"balance\":\"0x281d901f4fdd100000\"},\"f039683d7b3d225bc7d8dfadef63163441be41e2\":{\"balance\":\"0x1dd1e4bd8d1ee0000\"},\"f04a6a379708b9428d722aa2b06b77e88935cf89\":{\"balance\":\"0x1043561a8829300000\"},\"f04d2c91efb6e9c45ffbe74b434c8c5f2b028f1f\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f057aa66ca767ede124a1c5b9cc5fc94ef0b0137\":{\"balance\":\"0x70a24bcab6f45d0000\"},\"f05ba8d7b68539d933300bc9289c3d9474d0419e\":{\"balance\":\"0x6da27024dd9600000\"},\"f05ceeab65410564709951773c8445ad9f4ec797\":{\"balance\":\"0x10431627a0933b0000\"},\"f05fcd4c0d73aa167e5553c8c0d6d4f2faa39757\":{\"balance\":\"0x2d2d66c3170b2980000\"},\"f067e1f1d683556a4cc4fd0c0313239f32c4cfd8\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f067fb10dfb293e998abe564c055e3348f9fbf1e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f068dfe95d15cd3a7f98ffa688b4346842be2690\":{\"balance\":\"0x440ad819e0974c0000\"},\"f06a854a3c5dc36d1c49f4c87d6db333b57e4add\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f079e1b1265f50e8c8a98ec0c7815eb3aeac9eb4\":{\"balance\":\"0x116dc3a8994b30000\"},\"f07bd0e5c2ce69c7c4a724bd26bbfa9d2a17ca03\":{\"balance\":\"0x14061b9d77a5e980000\"},\"f0832a6bb25503eeca435be31b0bf905ca1fcf57\":{\"balance\":\"0x16a6502f15a1e540000\"},\"f09b3e87f913ddfd57ae8049c731dba9b636dfc3\":{\"balance\":\"0x20f5b1eaad8d800000\"},\"f0b1340b996f6f0bf0d9561c849caf7f4430befa\":{\"balance\":\"0x56bc75e2d63100000\"},\"f0b1f9e27832c6de6914d70afc238c749995ace4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f0b469eae89d400ce7d5d66a9695037036b88903\":{\"balance\":\"0x43c33c1937564800000\"},\"f0b9d683cea12ba600baace219b0b3c97e8c00e4\":{\"balance\":\"0x56bc75e2d63100000\"},\"f0be0faf4d7923fc444622d1980cf2d990aab307\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f0c081da52a9ae36642adf5e08205f05c54168a6\":{\"balance\":\"0x6046f37e5945c0000\"},\"f0c70d0d6dab7663aa9ed9ceea567ee2c6b02765\":{\"balance\":\"0x71438ac5a791a08000\"},\"f0cbef84e169630098d4e301b20208ef05846ac9\":{\"balance\":\"0xe0b8345506b4e0000\"},\"f0d21663d8b0176e05fde1b90ef31f8530fda95f\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"f0d5c31ccb6cbe30c7c9ea19f268d159851f8c9c\":{\"balance\":\"0x3894f0e6f9b9f700000\"},\"f0d64cf9df09741133d170485fd24b005011d520\":{\"balance\":\"0x1b089341e14fcc0000\"},\"f0d858105e1b648101ac3f85a0f8222bf4f81d6a\":{\"balance\":\"0x2086ac351052600000\"},\"f0dc43f205619127507b2b1c1cfdf32d28310920\":{\"balance\":\"0x105eb79b9417088000\"},\"f0e1dfa42adeac2f17f6fdf584c94862fd563393\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f0e2649c7e6a3f2c5dfe33bbfbd927ca3c350a58\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f0e7fb9e420a5340d536f40408344feaefc06aef\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f10462e58fcc07f39584a187639451167e859201\":{\"balance\":\"0x934dd5d33bc970000\"},\"f10661ff94140f203e7a482572437938bec9c3f7\":{\"balance\":\"0x43c33c1937564800000\"},\"f114ff0d0f24eff896edde5471dea484824a99b3\":{\"balance\":\"0xbe202d6a0eda0000\"},\"f116b0b4680f53ab72c968ba802e10aa1be11dc8\":{\"balance\":\"0x1158e460913d00000\"},\"f11cf5d363746fee6864d3ca336dd80679bb87ae\":{\"balance\":\"0x878678326eac9000000\"},\"f11e01c7a9d12499005f4dae7716095a34176277\":{\"balance\":\"0x15af1d78b58c400000\"},\"f13b083093ba564e2dc631568cf7540d9a0ec719\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"f14f0eb86db0eb68753f16918e5d4b807437bd3e\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f15178ffc43aa8070ece327e930f809ab1a54f9d\":{\"balance\":\"0xab640391201300000\"},\"f156dc0b2a981e5b55d3f2f03b8134e331dbadb7\":{\"balance\":\"0x56bc75e2d63100000\"},\"f15d9d5a21b1929e790371a17f16d95f0c69655c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f15e182c4fbbad79bd93342242d4dccf2be58925\":{\"balance\":\"0x692ae8897081d00000\"},\"f1624d980b65336feac5a6d54125005cfcf2aacb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f167f5868dcf4233a7830609682caf2df4b1b807\":{\"balance\":\"0x81e542e1a7383f0000\"},\"f16de1891d8196461395f9b136265b3b9546f6ef\":{\"balance\":\"0x1b28e1f98bbce8000\"},\"f17a92e0361dbacecdc5de0d1894955af6a9b606\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f17adb740f45cbbde3094e7e13716f8103f563bd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f18b14cbf6694336d0fe12ac1f25df2da0c05dbb\":{\"balance\":\"0xd8d4602c26bf6c0000\"},\"f19b39389d47b11b8a2c3f1da9124decffbefaf7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f19f193508393e4d2a127b20b2031f39c82581c6\":{\"balance\":\"0xbdbd7a83bd2f6c0000\"},\"f1a1f320407964fd3c8f2e2cc8a4580da94f01ea\":{\"balance\":\"0x6c6c2177557c440000\"},\"f1b4ecc63525f7432c3d834ffe2b970fbeb87212\":{\"balance\":\"0xa2a24068facd800000\"},\"f1b58faffa8794f50af8e88309c7a6265455d51a\":{\"balance\":\"0x36330322d5238c0000\"},\"f1c8c4a941b4628c0d6c30fda56452d99c7e1b64\":{\"balance\":\"0x4e8cea1ede75040000\"},\"f1da40736f99d5df3b068a5d745fafc6463fc9b1\":{\"balance\":\"0x696ca23058da10000\"},\"f1dc8ac81042c67a9c3c6792b230c46ac016ca10\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f1df55dcc34a051012b575cb968bc9c458ea09c9\":{\"balance\":\"0xd8d726b7177a800000\"},\"f1e980c559a1a8e5e50a47f8fffdc773b7e06a54\":{\"balance\":\"0x65ffbcdea04b7480000\"},\"f1f391ca92808817b755a8b8f4e2ca08d1fd1108\":{\"balance\":\"0x14542ba12a337c00000\"},\"f1f766b0e46d73fcd4d52e7a72e1b9190cc632b3\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"f2049532fd458a83ca1bff2eebacb6d5ca63f4a4\":{\"balance\":\"0xc48c991dc1545c8000\"},\"f206d328e471d0117b246d2a4619827709e96df3\":{\"balance\":\"0xa2af3dc00543440000\"},\"f20c9a99b74759d782f25c1ceca802a27e0b436c\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"f2127d54188fedef0f338a5f38c7ff73ad9f6f42\":{\"balance\":\"0x43c33c1937564800000\"},\"f2133431d1d9a37ba2f0762bc40c5acc8aa6978e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f21549bdd1487912f900a7523db5f7626121bba3\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f218bd848ee7f9d38bfdd1c4eb2ed2496ae4305f\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f224eb900b37b4490eee6a0b6420d85c947d8733\":{\"balance\":\"0x34957444b840e80000\"},\"f2294adbb6f0dcc76e632ebef48ab49f124dbba4\":{\"balance\":\"0x4e43393600a7b10000\"},\"f22f4078febbbaa8b0e78e642c8a42f35d433905\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"f237ef05261c34d79cc22b860de0f17f793c3860\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f23c7b0cb8cd59b82bd890644a57daf40c85e278\":{\"balance\":\"0x2b66aafe326ff0000\"},\"f23d01589eb12d439f7448ff54307529f191858d\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f23e5c633221a8f7363e65870c9f287424d2a960\":{\"balance\":\"0x4acf58e07257100000\"},\"f242da845d42d4bf779a00f295b40750fe49ea13\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f25259a5c939cd25966c9b6303d3731c53ddbc4c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f25e4c70bc465632c89e5625a832a7722f6bffab\":{\"balance\":\"0xf34b82fd8e91200000\"},\"f26bcedce3feadcea3bc3e96eb1040dfd8ffe1a0\":{\"balance\":\"0x2a034919dfbfbc0000\"},\"f270792576f05d514493ffd1f5e84bec4b2df810\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f2732cf2c13b8bb8e7492a988f5f89e38273ddc8\":{\"balance\":\"0x2086ac351052600000\"},\"f2742e6859c569d5f2108351e0bf4dca352a48a8\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f2813a64c5265d020235cb9c319b6c96f906c41e\":{\"balance\":\"0x12f939c99edab80000\"},\"f287ff52f461117adb3e1daa71932d1493c65f2e\":{\"balance\":\"0xc55325ca7415e00000\"},\"f2ab1161750244d0ecd048ee0d3e51abb143a2fd\":{\"balance\":\"0x42fe2b907373bc0000\"},\"f2b4ab2c9427a9015ef6eefff5edb60139b719d1\":{\"balance\":\"0x26db992a3b18000000\"},\"f2c03e2a38998c21648760f1e5ae7ea3077d8522\":{\"balance\":\"0x8f3f7193ab079c0000\"},\"f2c2904e9fa664a11ee25656d8fd2cc0d9a522a0\":{\"balance\":\"0xb98bc829a6f90000\"},\"f2c362b0ef991bc82fb36e66ff75932ae8dd8225\":{\"balance\":\"0x402f4cfee62e80000\"},\"f2d0e986d814ea13c8f466a0538c53dc922651f0\":{\"balance\":\"0x4acf58e07257100000\"},\"f2d1b7357724ec4c03185b879b63f57e26589153\":{\"balance\":\"0x14542ba12a337c00000\"},\"f2d5763ce073127e2cedde6faba786c73ca94141\":{\"balance\":\"0x1ac4286100191f00000\"},\"f2d59c8923759073d6f415aaf8eb065ff2f3b685\":{\"balance\":\"0x1ab2cf7c9f87e200000\"},\"f2e99f5cbb836b7ad36247571a302cbe4b481c69\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f2ed3e77254acb83231dc0860e1a11242ba627db\":{\"balance\":\"0x6b56051582a9700000\"},\"f2edde37f9a8c39ddea24d79f4015757d06bf786\":{\"balance\":\"0x152d02c7e14af6800000\"},\"f2efe96560c9d97b72bd36447843885c1d90c231\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f2fbb6d887f8b8cc3a869aba847f3d1f643c53d6\":{\"balance\":\"0xd8c9460063d31c0000\"},\"f3034367f87d24d3077fa9a2e38a8b0ccb1104ef\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f303d5a816affd97e83d9e4dac2f79072bb0098f\":{\"balance\":\"0x340aad21b3b7000000\"},\"f3159866c2bc86bba40f9d73bb99f1eee57bb9d7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f316ef1df2ff4d6c1808dba663ec8093697968e0\":{\"balance\":\"0x61464d6cdc80f00000\"},\"f32d25eb0ea2b8b3028a4c7a155dc1aae865784d\":{\"balance\":\"0x13593a9297fdad60000\"},\"f332c0f3e05a27d9126fd0b641a8c2d4060608fd\":{\"balance\":\"0x10f1b62c4d9644e8000\"},\"f338459f32a159b23db30ac335769ab2351aa63c\":{\"balance\":\"0x65a4da25d3016c00000\"},\"f33efc6397aa65fb53a8f07a0f893aae30e8bcee\":{\"balance\":\"0x7cf2381f619f150000\"},\"f34083ecea385017aa40bdd35ef7effb4ce7762d\":{\"balance\":\"0x15af1d78b58c400000\"},\"f346d7de92741c08fc58a64db55b062dde012d14\":{\"balance\":\"0xfff6b1f761e6d0000\"},\"f355d3ec0cfb907d8dbb1bf3464e458128190bac\":{\"balance\":\"0x10b046e7f0d80100000\"},\"f36df02fbd89607347afce2969b9c4236a58a506\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f373e9daac0c8675f53b797a160f6fc034ae6b23\":{\"balance\":\"0x56bc75e2d63100000\"},\"f37b426547a1642d8033324814f0ede3114fc212\":{\"balance\":\"0x15be6174e1912e0000\"},\"f37bf78c5875154711cb640d37ea6d28cfcb1259\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f382df583155d8548f3f93440cd5f68cb79d6026\":{\"balance\":\"0x38757d027fc1fd5c0000\"},\"f382e4c20410b951089e19ba96a2fee3d91cce7e\":{\"balance\":\"0x111fa56eec2a8380000\"},\"f38a6ca80168537e974d14e1c3d13990a44c2c1b\":{\"balance\":\"0x14542ba12a337c00000\"},\"f39a9d7aa3581df07ee4279ae6c312ef21033658\":{\"balance\":\"0xd8d726b7177a800000\"},\"f3b668b3f14d920ebc379092db98031b67b219b3\":{\"balance\":\"0xad6eedd17cf3b8000\"},\"f3be99b9103ce7550aa74ff1db18e09dfe32e005\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f3c1abd29dc57b41dc192d0e384d021df0b4f6d4\":{\"balance\":\"0x97ae0cdf8f86f80000\"},\"f3c4716d1ee5279a86d0163a14618181e16136c7\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f3cc8bcb559465f81bfe583bd7ab0a2306453b9e\":{\"balance\":\"0x43c33c1937564800000\"},\"f3d688f06bbdbf50f9932c4145cbe48ecdf68904\":{\"balance\":\"0x1158e460913d00000\"},\"f3dbcf135acb9dee1a489c593c024f03c2bbaece\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f3de5f26ef6aded6f06d3b911346ee70401da4a0\":{\"balance\":\"0x133ab37d9f9d030000\"},\"f3df63a97199933330383b3ed7570b96c4812334\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f3e74f470c7d3a3f0033780f76a89f3ef691e6cb\":{\"balance\":\"0xa3cfe631d143640000\"},\"f3eb1948b951e22df1617829bf3b8d8680ec6b68\":{\"balance\":\"0xd8d726b7177a800000\"},\"f3f1fa3918ca34e2cf7e84670b1f4d8eca160db3\":{\"balance\":\"0x24dce54d34a1a00000\"},\"f3f24fc29e20403fc0e8f5ebbb553426f78270a2\":{\"balance\":\"0x56bc75e2d63100000\"},\"f3fa723552a5d0512e2b62f48dca7b2b8105305b\":{\"balance\":\"0x76d41c62494840000\"},\"f3fe51fde34413c73318b9c85437fe7e820f561a\":{\"balance\":\"0x3662325cd18fe00000\"},\"f400f93d5f5c7e3fc303129ac8fb0c2f786407fa\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f40b134fea22c6b29c8457f49f000f9cda789adb\":{\"balance\":\"0x2086ac351052600000\"},\"f41557dfdfb1a1bdcefefe2eba1e21fe0a4a9942\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f4177a0d85d48b0e264211ce2aa2efd3f1b47f08\":{\"balance\":\"0xc2ccca26b7e80e8000\"},\"f42f905231c770f0a406f2b768877fb49eee0f21\":{\"balance\":\"0xaadec983fcff40000\"},\"f432b9dbaf11bdbd73b6519fc0a904198771aac6\":{\"balance\":\"0x83d6c7aab63600000\"},\"f43da3a4e3f5fab104ca9bc1a0f7f3bb4a56f351\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"f447108b98df64b57e871033885c1ad71db1a3f9\":{\"balance\":\"0x176f49ead3483508000\"},\"f44f8551ace933720712c5c491cdb6f2f951736c\":{\"balance\":\"0xd8d726b7177a800000\"},\"f456055a11ab91ff668e2ec922961f2a23e3db25\":{\"balance\":\"0xfc936392801c0000\"},\"f456a75bb99655a7412ce97da081816dfdb2b1f2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f45b1dcb2e41dc27ffa024daadf619c11175c087\":{\"balance\":\"0x11164759ffb320000\"},\"f463a90cb3f13e1f0643423636beab84c123b06d\":{\"balance\":\"0x22b1c8c1227a00000\"},\"f468906e7edf664ab0d8be3d83eb7ab3f7ffdc78\":{\"balance\":\"0x5c283d410394100000\"},\"f46980e3a4a9d29a6a6e90604537a3114bcb2897\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f46b6b9c7cb552829c1d3dfd8ffb11aabae782f6\":{\"balance\":\"0x1236efcbcbb340000\"},\"f476e1267f86247cc908816f2e7ad5388c952db0\":{\"balance\":\"0xd8d726b7177a800000\"},\"f476f2cb7208a32e051fd94ea8662992638287a2\":{\"balance\":\"0x56bc75e2d63100000\"},\"f47bb134da30a812d003af8dccb888f44bbf5724\":{\"balance\":\"0x11959b7fe3395580000\"},\"f483f607a21fcc28100a018c568ffbe140380410\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f48e1f13f6af4d84b371d7de4b273d03a263278e\":{\"balance\":\"0x2086ac351052600000\"},\"f49c47b3efd86b6e6a5bc9418d1f9fec814b69ef\":{\"balance\":\"0x43c33c1937564800000\"},\"f49f6f9baabc018c8f8e119e0115f491fc92a8a4\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f4a367b166d2991a2bfda9f56463a09f252c1b1d\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f4a51fce4a1d5b94b0718389ba4e7814139ca738\":{\"balance\":\"0x1043561a8829300000\"},\"f4a9d00cefa97b7a58ef9417fc6267a5069039ee\":{\"balance\":\"0x12e89287fa7840000\"},\"f4aaa3a6163e3706577b49c0767e948a681e16ee\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f4b1626e24f30bcad9273c527fcc714b5d007b8f\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f4b49100757772f33c177b9a76ba95226c8f3dd8\":{\"balance\":\"0x16b352da5e0ed300000\"},\"f4b6cdcfcb24230b337d770df6034dfbd4e1503f\":{\"balance\":\"0x405fdf7e5af85e00000\"},\"f4b759cc8a1c75f80849ebbcda878dc8f0d66de4\":{\"balance\":\"0x15af1d78b58c400000\"},\"f4ba6a46d55140c439cbcf076cc657136262f4f8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f4d67a9044b435b66e8977ff39a28dc4bd53729a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f4d97664cc4eec9edbe7fa09f4750a663b507d79\":{\"balance\":\"0xd8d726b7177a800000\"},\"f4dc7ba85480bbb3f535c09568aaa3af6f3721c6\":{\"balance\":\"0x1871fb6307e35e50000\"},\"f4ebf50bc7e54f82e9b9bd24baef29438e259ce6\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f4ec8e97a20aa5f8dd206f55207e06b813df2cc0\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f4ed848ec961739c2c7e352f435ba70a7cd5db38\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f4fc4d39bc0c2c4068a36de50e4ab4d4db7e340a\":{\"balance\":\"0x16037df87ef6a0000\"},\"f504943aaf16796e0b341bbcdf21d11cc586cdd1\":{\"balance\":\"0x1e7e4171bf4d3a00000\"},\"f5061ee2e5ee26b815503677130e1de07a52db07\":{\"balance\":\"0x56bc75e2d63100000\"},\"f509557e90183fbf0f0651a786487bcc428ba175\":{\"balance\":\"0xa844a7424d9c80000\"},\"f50abbd4aa45d3eb88515465a8ba0b310fd9b521\":{\"balance\":\"0x16a6502f15a1e540000\"},\"f50ae7fab4cfb5a646ee04ceadf9bf9dd5a8e540\":{\"balance\":\"0xd8d67c2f5895480000\"},\"f50cbafd397edd556c0678988cb2af5c2617e0a2\":{\"balance\":\"0x26d07efe782bb00000\"},\"f51fded80acb502890e87369741f3722514cefff\":{\"balance\":\"0x43c3456ca3c6d110000\"},\"f52a5882e8927d944b359b26366ba2b9cacfbae8\":{\"balance\":\"0x54b41ce2fe63ba80000\"},\"f52c0a7877345fe0c233bb0f04fd6ab18b6f14ba\":{\"balance\":\"0x54cbe55989f38de00000\"},\"f5437e158090b2a2d68f82b54a5864b95dd6dbea\":{\"balance\":\"0xd96c16703b2bfe0000\"},\"f54c19d9ef3873bfd1f7a622d02d86249a328f06\":{\"balance\":\"0x960ae127af32fb28000\"},\"f5500178cb998f126417831a08c2d7abfff6ab5f\":{\"balance\":\"0x46f4f4a5875a9f8000\"},\"f5534815dc635efa5cc84b2ac734723e21b29372\":{\"balance\":\"0x55a6e79ccd1d300000\"},\"f555a27bb1e2fd4e2cc784caee92939fc06e2fc9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f558a2b2dd26dd9593aae04531fd3c3cc3854b67\":{\"balance\":\"0xabbcd4ef377580000\"},\"f56048dd2181d4a36f64fcecc6215481e42abc15\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f56442f60e21691395d0bffaa9194dcaff12e2b7\":{\"balance\":\"0xe18398e7601900000\"},\"f579714a45eb8f52c3d57bbdefd2c15b2e2f11df\":{\"balance\":\"0x54915956c409600000\"},\"f593c65285ee6bbd6637f3be8f89ad40d489f655\":{\"balance\":\"0xa2a15d09519be00000\"},\"f598db2e09a8a5ee7d720d2b5c43bb126d11ecc2\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f59dab1bf8df11327e61f9b7a14b563a96ec3554\":{\"balance\":\"0x14542ba12a337c00000\"},\"f59f9f02bbc98efe097eabb78210979021898bfd\":{\"balance\":\"0x21e171a3ec9f72c0000\"},\"f5a5459fcdd5e5b273830df88eea4cb77ddadfb9\":{\"balance\":\"0x409e52b48369a0000\"},\"f5a7676ad148ae9c1ef8b6f5e5a0c2c473be850b\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f5b068989df29c253577d0405ade6e0e7528f89e\":{\"balance\":\"0x57473d05dabae80000\"},\"f5b6e9061a4eb096160777e26762cf48bdd8b55d\":{\"balance\":\"0xdc55fdb17647b0000\"},\"f5cffbba624e7eb321bc83c60ca68199b4e36671\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f5d14552b1dce0d6dc1f320da6ffc8a331cd6f0c\":{\"balance\":\"0x487a9a304539440000\"},\"f5d61ac4ca95475e5b7bffd5f2f690b316759615\":{\"balance\":\"0x692ae8897081d000000\"},\"f5d9cf00d658dd45517a48a9d3f5f633541a533d\":{\"balance\":\"0x64f5fdf494f780000\"},\"f5eadcd2d1b8657a121f33c458a8b13e76b65526\":{\"balance\":\"0xd8b0f5a5ac24a0000\"},\"f607c2150d3e1b99f24fa1c7d540add35c4ebe1e\":{\"balance\":\"0xa7f1aa07fc8faa0000\"},\"f60bd735543e6bfd2ea6f11bff627340bc035a23\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f60c1b45f164b9580e20275a5c39e1d71e35f891\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f60f62d73937953fef35169e11d872d2ea317eec\":{\"balance\":\"0x121ea68c114e5100000\"},\"f61283b4bd8504058ca360e993999b62cbc8cd67\":{\"balance\":\"0xdd2d5fcf3bc9c0000\"},\"f617b967b9bd485f7695d2ef51fb7792d898f500\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f618d9b104411480a863e623fc55232d1a4f48aa\":{\"balance\":\"0xe689e6d44b1668000\"},\"f622e584a6623eaaf99f2be49e5380c5cbcf5cd8\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f632adff490da4b72d1236d04b510f74d2faa3cd\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"f639ac31da9f67271bd10402b7654e5ce763bd47\":{\"balance\":\"0x15af0f42baf9260000\"},\"f63a579bc3eac2a9490410128dbcebe6d9de8243\":{\"balance\":\"0x50c5e761a444080000\"},\"f645dd7c890093e8e4c8aa92a6bb353522d3dc98\":{\"balance\":\"0x7439fa2099e580000\"},\"f648ea89c27525710172944e79edff847803b775\":{\"balance\":\"0x152d02c7e14af6800000\"},\"f64a4ac8d540a9289c68d960d5fb7cc45a77831c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f64ecf2117931c6d535a311e4ffeaef9d49405b8\":{\"balance\":\"0x90f534608a72880000\"},\"f64fe0939a8d1eea2a0ecd9a9730fd7958e33109\":{\"balance\":\"0x11de1e6db450c0000\"},\"f65616be9c8b797e7415227c9138faa0891742d7\":{\"balance\":\"0x2ad373ce668e980000\"},\"f657fcbe682eb4e8db152ecf892456000b513d15\":{\"balance\":\"0x692ae8897081d00000\"},\"f65819ac4cc14c137f05dd7977c7dae08d1a4ab5\":{\"balance\":\"0x58788cb94b1d80000\"},\"f67bb8e2118bbcd59027666eedf6943ec9f880a5\":{\"balance\":\"0xd8d726b7177a800000\"},\"f68464bf64f2411356e4d3250efefe5c50a5f65b\":{\"balance\":\"0x1158e460913d00000\"},\"f686785b89720b61145fea80978d6acc8e0bc196\":{\"balance\":\"0xd8d726b7177a800000\"},\"f68c5e33fa97139df5b2e63886ce34ebf3e4979c\":{\"balance\":\"0xb3fa4169e2d8e00000\"},\"f6a8635757c5e8c134d20d028cf778cf8609e46a\":{\"balance\":\"0x4f1d772faec17c0000\"},\"f6b782f4dcd745a6c0e2e030600e04a24b25e542\":{\"balance\":\"0x15af1d78b58c400000\"},\"f6bc37b1d2a3788d589b6de212dc1713b2f6e78e\":{\"balance\":\"0x10f0cf064dd59200000\"},\"f6c3c48a1ac0a34799f04db86ec7a975fe7768f3\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f6d25d3f3d846d239f525fa8cac97bc43578dbac\":{\"balance\":\"0x30927f74c9de000000\"},\"f6eaac7032d492ef17fd6095afc11d634f56b382\":{\"balance\":\"0x1b1b6bd7af64c70000\"},\"f6ead67dbf5b7eb13358e10f36189d53e643cfcf\":{\"balance\":\"0x878678326eac9000000\"},\"f6f1a44309051c6b25e47dff909b179bb9ab591c\":{\"balance\":\"0x692ae8897081d00000\"},\"f70328ef97625fe745faa49ee0f9d4aa3b0dfb69\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f70a998a717b338d1dd99854409b1a338deea4b0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f70d637a845c06db6cdc91e6371ce7c4388a628e\":{\"balance\":\"0x1158e460913d00000\"},\"f7155213449892744bc60f2e04400788bd041fdd\":{\"balance\":\"0x39fbae8d042dd0000\"},\"f71b4534f286e43093b1e15efea749e7597b8b57\":{\"balance\":\"0x161c13d3341c87280000\"},\"f734ec03724ddee5bb5279aa1afcf61b0cb448a1\":{\"balance\":\"0xe5bf2cc9b097800000\"},\"f736dc96760012388fe88b66c06efe57e0d7cf0a\":{\"balance\":\"0x71d75ab9b920500000\"},\"f73ac46c203be1538111b151ec8220c786d84144\":{\"balance\":\"0xff7377817b82b8000\"},\"f73dd9c142b71bce11d06e30e7e7d032f2ec9c9e\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f7418aa0e713d248228776b2e7434222ae75e3a5\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f74e6e145382b4db821fe0f2d98388f45609c69f\":{\"balance\":\"0x56bc75e2d63100000\"},\"f7500c166f8bea2f82347606e5024be9e4f4ce99\":{\"balance\":\"0x1158e460913d00000\"},\"f757fc8720d3c4fa5277075e60bd5c411aebd977\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f75bb39c799779ebc04a336d260da63146ed98d0\":{\"balance\":\"0x15af1d78b58c40000\"},\"f768f321fd6433d96b4f354d3cc1652c1732f57f\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f76f69cee4faa0a63b30ae1e7881f4f715657010\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f777361a3dd8ab62e5f1b9b047568cc0b555704c\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f77c7b845149efba19e261bc7c75157908afa990\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f77f9587ff7a2d7295f1f571c886bd33926a527c\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"f78258c12481bcdddbb72a8ca0c043097261c6c5\":{\"balance\":\"0x1158e460913d00000\"},\"f798d16da4e460c460cd485fae0fa0599708eb82\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f7a1ade2d0f529123d1055f19b17919f56214e67\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f7acff934b84da0969dc37a8fcf643b7d7fbed41\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"f7b151cc5e571c17c76539dbe9964cbb6fe5de79\":{\"balance\":\"0x74717cfb6883100000\"},\"f7b29b82195c882dab7897c2ae95e77710f57875\":{\"balance\":\"0x7735416132dbfc0000\"},\"f7bc4c44910d5aedd66ed2355538a6b193c361ec\":{\"balance\":\"0x541de2c2d8d620000\"},\"f7c00cdb1f020310d5acab7b496aaa44b779085e\":{\"balance\":\"0x5a87e7d7f5f6580000\"},\"f7c1b443968b117b5dd9b755572fcd39ca5ec04b\":{\"balance\":\"0x18b968c292f1b50000\"},\"f7c50f922ad16b61c6d1baa045ed816815bac48f\":{\"balance\":\"0x2a9396a9784ad7d0000\"},\"f7c708015071d4fb0a3a2a09a45d156396e3349e\":{\"balance\":\"0xa2a15d09519be00000\"},\"f7cbdba6be6cfe68dbc23c2b0ff530ee05226f84\":{\"balance\":\"0x1158e460913d00000\"},\"f7d0d310acea18406138baaabbfe0571e80de85f\":{\"balance\":\"0x487a9a304539440000\"},\"f7d7af204c56f31fd94398e40df1964bd8bf123c\":{\"balance\":\"0x821d221b5291f8000\"},\"f7dc251196fbcbb77c947d7c1946b0ff65021cea\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f7e45a12aa711c709acefe95f33b78612d2ad22a\":{\"balance\":\"0xe0655e2f26bc9180000\"},\"f7f4898c4c526d955f21f055cb6e47b915e51964\":{\"balance\":\"0x7c0860e5a80dc00000\"},\"f7f91e7acb5b8129a306877ce3168e6f438b66a1\":{\"balance\":\"0x98a7d9b8314c00000\"},\"f7fc45abf76f5088e2e5b5a8d132f28a4d4ec1c0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8063af4cc1dd9619ab5d8bff3fcd1faa8488221\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8086e42661ea929d2dda1ab6c748ce3055d111e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f8087786b42da04ed6d1e0fe26f6c0eefe1e9f5a\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"f80d3619702fa5838c48391859a839fb9ce7160f\":{\"balance\":\"0x6c07a7d1b16e700000\"},\"f814799f6ddf4dcb29c7ee870e75f9cc2d35326d\":{\"balance\":\"0x3635c9adc5dea00000\"},\"f815c10a032d13c34b8976fa6e3bd2c9131a8ba9\":{\"balance\":\"0x487a9a304539440000\"},\"f81622e55757daea6675975dd93538da7d16991e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f824ee331e4ac3cc587693395b57ecf625a6c0c2\":{\"balance\":\"0x56c95de8e8ca1d0000\"},\"f827d56ed2d32720d4abf103d6d0ef4d3bcd559b\":{\"balance\":\"0x16c80065791a28000\"},\"f8298591523e50b103f0b701d623cbf0f74556f6\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f848fce9ab611c7d99206e23fac69ad488b94fe1\":{\"balance\":\"0x2a1129d0936720000\"},\"f84f090adf3f8db7e194b350fbb77500699f66fd\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f851b010f633c40af1a8f06a73ebbaab65077ab5\":{\"balance\":\"0xee86442fcd06c00000\"},\"f858171a04d357a13b4941c16e7e55ddd4941329\":{\"balance\":\"0x246a5218f2a000000\"},\"f85bab1cb3710fc05fa19ffac22e67521a0ba21d\":{\"balance\":\"0x6c95357fa6b36c0000\"},\"f86a3ea8071f7095c7db8a05ae507a8929dbb876\":{\"balance\":\"0x1236efcbcbb3400000\"},\"f8704c16d2fd5ba3a2c01d0eb20484e6ecfa3109\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f870995fe1e522321d754337a45c0c9d7b38951c\":{\"balance\":\"0x1158e460913d00000\"},\"f873e57a65c93b6e18cb75f0dc077d5b8933dc5c\":{\"balance\":\"0xaadec983fcff40000\"},\"f875619d8a23e45d8998d184d480c0748970822a\":{\"balance\":\"0xd8d726b7177a800000\"},\"f87bb07b289df7301e54c0efda6a2cf291e89200\":{\"balance\":\"0x4be4e7267b6ae00000\"},\"f88900db737955b1519b1a7d170a18864ce590eb\":{\"balance\":\"0xfc936392801c0000\"},\"f88b58db37420b464c0be88b45ee2b95290f8cfa\":{\"balance\":\"0x22b1c8c1227a00000\"},\"f8962b75db5d24c7e8b7cef1068c3e67cebb30a5\":{\"balance\":\"0xf2dc7d47f15600000\"},\"f8a065f287d91d77cd626af38ffa220d9b552a2b\":{\"balance\":\"0x678a932062e4180000\"},\"f8a49ca2390c1f6d5c0e62513b079571743f7cc6\":{\"balance\":\"0xa2a15d09519be00000\"},\"f8a50cee2e688ceee3aca4d4a29725d4072cc483\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8ac4a39b53c11307820973b441365cffe596f66\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8ae857b67a4a2893a3fbe7c7a87ff1c01c6a6e7\":{\"balance\":\"0xd8d726b7177a800000\"},\"f8bf9c04874e5a77f38f4c38527e80c676f7b887\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8c7f34a38b31801da43063477b12b27d0f203ff\":{\"balance\":\"0x1ad2baba6fef480000\"},\"f8ca336c8e91bd20e314c20b2dd4608b9c8b9459\":{\"balance\":\"0x2ddc9bc5b32c780000\"},\"f8d17424c767bea31205739a2b57a7277214eebe\":{\"balance\":\"0x246ddf97976680000\"},\"f8d52dcc5f96cc28007b3ecbb409f7e22a646caa\":{\"balance\":\"0x81690e18128480000\"},\"f8dce867f0a39c5bef9eeba609229efa02678b6c\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f8f226142a428434ab17a1864a2597f64aab2f06\":{\"balance\":\"0x9598b2fb2e9f28000\"},\"f8f6645e0dee644b3dad81d571ef9baf840021ad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f901c00fc1db88b69c4bc3252b5ca70ea6ee5cf6\":{\"balance\":\"0x15af1d78b58c400000\"},\"f93d5bcb0644b0cce5fcdda343f5168ffab2877d\":{\"balance\":\"0xb6207b67d26f90000\"},\"f9570e924c95debb7061369792cf2efec2a82d5e\":{\"balance\":\"0x1158e460913d00000\"},\"f9642086b1fbae61a6804dbe5fb15ec2d2b537f4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f96488698590dc3b2c555642b871348dfa067ad5\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f964d98d281730ba35b2e3a314796e7b42fedf67\":{\"balance\":\"0x53b0876098d80c0000\"},\"f9650d6989f199ab1cc479636ded30f241021f65\":{\"balance\":\"0x2e141ea081ca080000\"},\"f96883582459908c827627e86f28e646f9c7fc7a\":{\"balance\":\"0x1c4a78737cdcfb80000\"},\"f96b4c00766f53736a8574f822e6474c2f21da2d\":{\"balance\":\"0x15af1d78b58c400000\"},\"f9729d48282c9e87166d5eef2d01eda9dbf78821\":{\"balance\":\"0x56b83ddc728548000\"},\"f9767e4ecb4a5980527508d7bec3d45e4c649c13\":{\"balance\":\"0x678a932062e4180000\"},\"f978b025b64233555cc3c19ada7f4199c9348bf7\":{\"balance\":\"0x54b40b1f852bda000000\"},\"f97b56ebd5b77abc9fbacbabd494b9d2c221cd03\":{\"balance\":\"0x6acb3df27e1f880000\"},\"f9811fa19dadbf029f8bfe569adb18228c80481a\":{\"balance\":\"0xad78ebc5ac6200000\"},\"f98250730c4c61c57f129835f2680894794542f3\":{\"balance\":\"0xd8d726b7177a800000\"},\"f989346772995ec1906faffeba2a7fe7de9c6bab\":{\"balance\":\"0x16a6502f15a1e540000\"},\"f998ca3411730a6cd10e7455b0410fb0f6d3ff80\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f99aee444b5783c093cfffd1c4632cf93c6f050c\":{\"balance\":\"0x15af1d78b58c400000\"},\"f99eeece39fa7ef5076d855061384009792cf2e0\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f9a59c3cc5ffacbcb67be0fc7256f64c9b127cb4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"f9a94bd56198da245ed01d1e6430b24b2708dcc0\":{\"balance\":\"0x28a77afda87ee50000\"},\"f9b37825f03073d31e249378c30c795c33f83af2\":{\"balance\":\"0xad9aabf8c9bfc0000\"},\"f9b617f752edecae3e909fbb911d2f8192f84209\":{\"balance\":\"0x90f534608a72880000\"},\"f9bfb59d538afc4874d4f5941b08c9730e38e24b\":{\"balance\":\"0x22b1c8c1227a00000\"},\"f9dd239008182fb519fb30eedd2093fed1639be8\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"f9debaecb5f339beea4894e5204bfa340d067f25\":{\"balance\":\"0x5a42844673b1640000\"},\"f9e37447406c412197b2e2aebc001d6e30c98c60\":{\"balance\":\"0x1c479bb4349c0ee0000\"},\"f9e7222faaf0f4da40c1c4a40630373a09bed7b6\":{\"balance\":\"0x9b4fdcb09456240000\"},\"f9ece022bccd2c92346911e79dd50303c01e0188\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fa00c376e89c05e887817a9dd0748d96f341aa89\":{\"balance\":\"0x104d0d00d2b7f60000\"},\"fa0c1a988c8a17ad3528eb28b3409daa58225f26\":{\"balance\":\"0xad78ebc5ac6200000\"},\"fa105f1a11b6e4b1f56012a27922e2ac2da4812f\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"fa142fe47eda97e6503b386b18a2bedd73ccb5b1\":{\"balance\":\"0x2e153ad81548100000\"},\"fa14b566234abee73042c31d21717182cba14aa1\":{\"balance\":\"0x11c7ea162e78200000\"},\"fa19d6f7a50f4f079893d167bf14e21d0073d196\":{\"balance\":\"0x1cbb3a3ff08d080000\"},\"fa1f1971a775c3504fef5079f640c2c4bce7ac05\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fa279bfd8767f956bf7fa0bd5660168da75686bd\":{\"balance\":\"0x90f534608a72880000\"},\"fa27cc49d00b6c987336a875ae39da58fb041b2e\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"fa283299603d8758e8cab082125d2c8f7d445429\":{\"balance\":\"0x15bcacb1e0501ae8000\"},\"fa2bbca15d3fe39f8a328e91f90da14f7ac6253d\":{\"balance\":\"0xad78ebc5ac6200000\"},\"fa2fd29d03fee9a07893df3a269f56b72f2e1e64\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"fa33553285a973719a0d5f956ff861b2d89ed304\":{\"balance\":\"0x1158e460913d00000\"},\"fa3a0c4b903f6ea52ea7ab7b8863b6a616ad6650\":{\"balance\":\"0x1158e460913d00000\"},\"fa3a1aa4488b351aa7560cf5ee630a2fd45c3222\":{\"balance\":\"0x2fa47e6aa7340d0000\"},\"fa410971ad229c3036f41acf852f2ac999281950\":{\"balance\":\"0xd8b311a8ddfa7c0000\"},\"fa44a855e404c86d0ca8ef3324251dfb349c539e\":{\"balance\":\"0x542253a126ce400000\"},\"fa5201fe1342af11307b9142a041243ca92e2f09\":{\"balance\":\"0x2038116a3ac043980000\"},\"fa60868aafd4ff4c5c57914b8ed58b425773dfa9\":{\"balance\":\"0x1cfe5c808f39fbc0000\"},\"fa67b67b4f37a0150915110ede073b05b853bda2\":{\"balance\":\"0x2319ba947371ad0000\"},\"fa68e0cb3edf51f0a6f211c9b2cb5e073c9bffe6\":{\"balance\":\"0xfc936392801c00000\"},\"fa6a37f018e97967937fc5e8617ba1d786dd5f77\":{\"balance\":\"0x43c30fb0884a96c0000\"},\"fa7606435b356cee257bd2fcd3d9eacb3cd1c4e1\":{\"balance\":\"0x56bc75e2d63100000\"},\"fa7adf660b8d99ce15933d7c5f072f3cbeb99d33\":{\"balance\":\"0x14061b9d77a5e980000\"},\"fa86ca27bf2854d98870837fb6f6dfe4bf6453fc\":{\"balance\":\"0x11757e8525cf148000\"},\"fa8cf4e627698c5d5788abb7880417e750231399\":{\"balance\":\"0xe61a3696eef6100000\"},\"fa8e3b1f13433900737daaf1f6299c4887f85b5f\":{\"balance\":\"0x26c29e47c4844c0000\"},\"fa9ec8efe08686fa58c181335872ba698560ecab\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"faad905d847c7b23418aeecbe3addb8dd3f8924a\":{\"balance\":\"0x6acb3df27e1f880000\"},\"faaeba8fc0bbda553ca72e30ef3d732e26e82041\":{\"balance\":\"0x488d282aafc9f68000\"},\"fab487500df20fb83ebed916791d561772adbebf\":{\"balance\":\"0x6c6b4c4da6ddbe0000\"},\"fac5ca94758078fbfccd19db3558da7ee8a0a768\":{\"balance\":\"0x3728a62b0dcff60000\"},\"fad96ab6ac768ad5099452ac4777bd1a47edc48f\":{\"balance\":\"0x56bc75e2d63100000\"},\"fae76719d97eac41870428e940279d97dd57b2f6\":{\"balance\":\"0x14dbb2195ca228900000\"},\"fae881937047895a660cf229760f27e66828d643\":{\"balance\":\"0x9ddc1e3b901180000\"},\"fae92c1370e9e1859a5df83b56d0f586aa3b404c\":{\"balance\":\"0x5c5b4f3d843980000\"},\"faf5f0b7b6d558f5090d9ea1fb2d42259c586078\":{\"balance\":\"0x15affb8420c6b640000\"},\"fb126f0ec769f49dcefca2f200286451583084b8\":{\"balance\":\"0x10fcbc2350396bf0000\"},\"fb135eb15a8bac72b69915342a60bbc06b7e077c\":{\"balance\":\"0x43c33c1937564800000\"},\"fb223c1e22eac1269b32ee156a5385922ed36fb8\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fb37cf6b4f81a9e222fba22e9bd24b5098b733cf\":{\"balance\":\"0x21a754a6dc5280000\"},\"fb3860f4121c432ebdc8ec6a0331b1b709792e90\":{\"balance\":\"0x208c394af1c8880000\"},\"fb39189af876e762c71d6c3e741893df226cedd6\":{\"balance\":\"0xd8d726b7177a800000\"},\"fb3a0b0d6b6a718f6fc0292a825dc9247a90a5d0\":{\"balance\":\"0xad6dd199e975b0000\"},\"fb3fa1ac08aba9cc3bf0fe9d483820688f65b410\":{\"balance\":\"0x65a4da25d3016c00000\"},\"fb3fe09bb836861529d7518da27635f538505615\":{\"balance\":\"0x4be39216fda0700000\"},\"fb5125bf0f5eb0b6f020e56bfc2fdf3d402c097e\":{\"balance\":\"0x14061b9d77a5e980000\"},\"fb5518714cefc36d04865de5915ef0ff47dfe743\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fb5ffaa0f7615726357891475818939d2037cf96\":{\"balance\":\"0x1158e460913d00000\"},\"fb685c15e439965ef626bf0d834cd1a89f2b5695\":{\"balance\":\"0xd5967be4fc3f100000\"},\"fb744b951d094b310262c8f986c860df9ab1de65\":{\"balance\":\"0x2d1c515f1cb4a8000\"},\"fb79abdb925c55b9f98efeef64cfc9eb61f51bb1\":{\"balance\":\"0x6140c056fb0ac80000\"},\"fb8113f94d9173eefd5a3073f516803a10b286ae\":{\"balance\":\"0x4563918244f400000\"},\"fb842ca2c5ef133917a236a0d4ac40690110b038\":{\"balance\":\"0x10969a62be15880000\"},\"fb91fb1a695553f0c68e21276decf0b83909b86d\":{\"balance\":\"0x56c003617af780000\"},\"fb9473cf7712350a1fa0395273fc80560752e4fb\":{\"balance\":\"0x6af2198ba85aa0000\"},\"fb949c647fdcfd2514c7d58e31f28a532d8c5833\":{\"balance\":\"0x43c33c1937564800000\"},\"fba5486d53c6e240494241abf87e43c7600d413a\":{\"balance\":\"0x6bbf61494948340000\"},\"fbb161fe875f09290a4b262bc60110848f0d2226\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fbbbebcfbe235e57dd2306ad1a9ec581c7f9f48f\":{\"balance\":\"0x22b1c8c1227a00000\"},\"fbc01db54e47cdc3c438694ab717a856c23fe6e9\":{\"balance\":\"0x1ca7150ab174f470000\"},\"fbcfcc4a7b0f26cf26e9f3332132e2fc6a230766\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"fbe71622bcbd31c1a36976e7e5f670c07ffe16de\":{\"balance\":\"0x15af1d78b58c400000\"},\"fbede32c349f3300ef4cd33b4de7dc18e443d326\":{\"balance\":\"0xab4dcf399a3a600000\"},\"fbf204c813f836d83962c7870c7808ca347fd33e\":{\"balance\":\"0x1158e460913d00000\"},\"fbf75933e01b75b154ef0669076be87f62dffae1\":{\"balance\":\"0x10846372f249d4c00000\"},\"fc0096b21e95acb8d619d176a4a1d8d529badbef\":{\"balance\":\"0x14d9693bcbec028000\"},\"fc00a420a36107dfd5f495128a5fe5abb2db0f34\":{\"balance\":\"0x143179d869110200000\"},\"fc018a690ad6746dbe3acf9712ddca52b6250039\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"fc02734033e57f70517e0afc7ee62461f06fad8e\":{\"balance\":\"0x155bd9307f9fe80000\"},\"fc0ee6f7c2b3714ae9916c45566605b656f32441\":{\"balance\":\"0x5f68e8131ecf800000\"},\"fc10b7a67b3268d5331bfb6a14def5ea4a162ca3\":{\"balance\":\"0xad78ebc5ac6200000\"},\"fc15cb99a8d1030b12770add033a79ee0d0c908c\":{\"balance\":\"0x12fa00bd52e6240000\"},\"fc2952b4c49fedd0bc0528a308495e6d6a1c71d6\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fc2c1f88961d019c3e9ea33009152e0693fbf88a\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"fc361105dd90f9ede566499d69e9130395f12ac8\":{\"balance\":\"0x53a4fe2f204e80e00000\"},\"fc372ff6927cb396d9cf29803500110da632bc52\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fc39be41094b1997d2169e8264c2c3baa6c99bc4\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fc3d226bb36a58f526568857b0bb12d109ec9301\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fc43829ac787ff88aaf183ba352aadbf5a15b193\":{\"balance\":\"0xd6ac0a2b0552e00000\"},\"fc49c1439a41d6b3cf26bb67e0365224e5e38f5f\":{\"balance\":\"0x3636d7af5ec98e0000\"},\"fc5500825105cf712a318a5e9c3bfc69c89d0c12\":{\"balance\":\"0xd8d726b7177a800000\"},\"fc66faba277f4b5de64ad45eb19c31e00ced3ed5\":{\"balance\":\"0x131beb925ffd3200000\"},\"fc7e22a503ec5abe9b08c50bd14999f520fa4884\":{\"balance\":\"0x15a477dfbe1ea148000\"},\"fc8215a0a69913f62a43bf1c8590b9ddcd0d8ddb\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fc989cb487bf1a7d17e4c1b7c4b7aafdda6b0a8d\":{\"balance\":\"0x1158e460913d00000\"},\"fc9b347464b2f9929d807e039dae48d3d98de379\":{\"balance\":\"0x2f6f10780d22cc00000\"},\"fca43bbc23a0d321ba9e46b929735ce7d8ef0c18\":{\"balance\":\"0x1158e460913d00000\"},\"fca73eff8771c0103ba3cc1a9c259448c72abf0b\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fcada300283f6bcc134a91456760b0d77de410e0\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fcbc5c71ace79741450b012cf6b8d3f17db68a70\":{\"balance\":\"0x205b4dfa1ee74780000\"},\"fcbd85feea6a754fcf3449449e37ff9784f7773c\":{\"balance\":\"0xa74ada69abd7780000\"},\"fcc9d4a4262e7a027ab7519110d802c495ceea39\":{\"balance\":\"0x1595182224b26480000\"},\"fccd0d1ecee27addea95f6857aeec8c7a04b28ee\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"fcd0b4827cd208ffbf5e759dba8c3cc61d8c2c3c\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"fce089635ce97abac06b44819be5bb0a3e2e0b37\":{\"balance\":\"0x503920a7630a78000\"},\"fcf199f8b854222f182e4e1d099d4e323e2aae01\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fcfc3a5004d678613f0b36a642269a7f371c3f6a\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fd191a35157d781373fb411bf9f25290047c5eef\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fd1faa347b0fcc804c2da86c36d5f1d18b7087bb\":{\"balance\":\"0x2d6eb247a96f60000\"},\"fd1fb5a89a89a721b8797068fbc47f3e9d52e149\":{\"balance\":\"0xcd0b5837fc6580000\"},\"fd204f4f4aba2525ba728afdf78792cbdeb735ae\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fd2757cc3551a095878d97875615fe0c6a32aa8a\":{\"balance\":\"0x206db15299beac0000\"},\"fd2872d19e57853cfa16effe93d0b1d47b4f93fb\":{\"balance\":\"0xd8d726b7177a800000\"},\"fd2929271e9d2095a264767e7b0df52ea0d1d400\":{\"balance\":\"0xa2a1eb251b5ae40000\"},\"fd377a385272900cb436a3bb7962cdffe93f5dad\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fd40242bb34a70855ef0fd90f3802dec2136b327\":{\"balance\":\"0x68a875073e29240000\"},\"fd452c3969ece3801c542020f1cdcaa1c71ed23d\":{\"balance\":\"0x152d02c7e14af6800000\"},\"fd4b551f6fdbcda6c511b5bb372250a6b783e534\":{\"balance\":\"0x11de1e6db450c0000\"},\"fd4b989558ae11be0c3b36e2d6f2a54a9343ca2e\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fd4de8e3748a289cf7d060517d9d38388db01fb8\":{\"balance\":\"0xd8d726b7177a80000\"},\"fd5a63157f914fd398eab19c137dd9550bb7715c\":{\"balance\":\"0x56bc75e2d63100000\"},\"fd60d2b5af3d35f7aaf0c393052e79c4d823d985\":{\"balance\":\"0x30eb50d2e14080000\"},\"fd686de53fa97f99639e2568549720bc588c9efc\":{\"balance\":\"0x6ac5c62d9486070000\"},\"fd7ede8f5240a06541eb699d782c2f9afb2170f6\":{\"balance\":\"0x487a9a304539440000\"},\"fd812bc69fb170ef57e2327e80affd14f8e4b6d2\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fd88d114220f081cb3d5e15be8152ab07366576a\":{\"balance\":\"0x1043561a8829300000\"},\"fd918536a8efa6f6cefe1fa1153995fef5e33d3b\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"fd920f722682afb5af451b0544d4f41b3b9d5742\":{\"balance\":\"0x7e52056a123f3c0000\"},\"fd9579f119bbc819a02b61e38d8803c942f24d32\":{\"balance\":\"0x5b97e9081d9400000\"},\"fda0ce15330707f10bce3201172d2018b9ddea74\":{\"balance\":\"0x2d041d705a2c60000\"},\"fda3042819af3e662900e1b92b4358eda6e92590\":{\"balance\":\"0x1907a284d58f63e00000\"},\"fda6810ea5ac985d6ffbf1c511f1c142edcfddf7\":{\"balance\":\"0xd8d726b7177a800000\"},\"fdb33944f2360615e5be239577c8a19ba52d9887\":{\"balance\":\"0x209d922f5259c50000\"},\"fdba5359f7ec3bc770ac49975d844ec9716256f1\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fdc4d4765a942f5bf96931a9e8cc7ab8b757ff4c\":{\"balance\":\"0x126c478a0e3ea8600000\"},\"fdcd5d80b105897a57abc47865768b2900524295\":{\"balance\":\"0x15af1d78b58c4000000\"},\"fdd1195f797d4f35717d15e6f9810a9a3ff55460\":{\"balance\":\"0xfc936392801c0000\"},\"fdd502a74e813bcfa355ceda3c176f6a6871af7f\":{\"balance\":\"0x15af1d78b58c400000\"},\"fde395bc0b6d5cbb4c1d8fea3e0b4bff635e9db7\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fdeaac2acf1d138e19f2fc3f9fb74592e3ed818a\":{\"balance\":\"0x243d4d18229ca20000\"},\"fdecc82ddfc56192e26f563c3d68cb544a96bfed\":{\"balance\":\"0x17da3a04c7b3e00000\"},\"fdf42343019b0b0c6bf260b173afab7e45b9d621\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"fdf449f108c6fb4f5a2b081eed7e45e6919e4d25\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fdfd6134c04a8ab7eb16f00643f8fed7daaaecb2\":{\"balance\":\"0x15af1d78b58c400000\"},\"fe00bf439911a553982db638039245bcf032dbdc\":{\"balance\":\"0x155bd9307f9fe80000\"},\"fe016ec17ec5f10e3bb98ff4a1eda045157682ab\":{\"balance\":\"0x145f5402e7b2e60000\"},\"fe0e30e214290d743dd30eb082f1f0a5225ade61\":{\"balance\":\"0xad78ebc5ac6200000\"},\"fe210b8f04dc6d4f76216acfcbd59ba83be9b630\":{\"balance\":\"0x1158e460913d00000\"},\"fe22a0b388668d1ae2643e771dacf38a434223cc\":{\"balance\":\"0xd8db5ebd7b26380000\"},\"fe362688845fa244cc807e4b1130eb3741a8051e\":{\"balance\":\"0x3635c9adc5dea00000\"},\"fe3827d57630cf8761d512797b0b858e478bbd12\":{\"balance\":\"0x1158e460913d00000\"},\"fe418b421a9c6d373602790475d2303e11a75930\":{\"balance\":\"0x3708baed3d68900000\"},\"fe4249127950e2f896ec0e7e2e3d055aab10550f\":{\"balance\":\"0x243d4d18229ca20000\"},\"fe4d8403216fd571572bf1bdb01d00578978d688\":{\"balance\":\"0x215f835bc769da80000\"},\"fe53b94989d89964da2061539526bbe979dd2ea9\":{\"balance\":\"0x68a875073e29240000\"},\"fe549bbfe64740189892932538daaf46d2b61d4f\":{\"balance\":\"0x22b1c8c1227a00000\"},\"fe615d975c0887e0c9113ec7298420a793af8b96\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"fe65c4188d7922576909642044fdc52395560165\":{\"balance\":\"0xd8d726b7177a800000\"},\"fe697ff22ca547bfc95e33d960da605c6763f35b\":{\"balance\":\"0x47d4119fd960940000\"},\"fe6a895b795cb4bf85903d3ce09c5aa43953d3bf\":{\"balance\":\"0xb8507a820728200000\"},\"fe6f5f42b6193b1ad16206e4afb5239d4d7db45e\":{\"balance\":\"0x5dc892aa1131c80000\"},\"fe7011b698bf3371132d7445b19eb5b094356aee\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fe80e9232deaff19baf99869883a4bdf0004e53c\":{\"balance\":\"0x2e62f20a69be400000\"},\"fe8e6e3665570dff7a1bda697aa589c0b4e9024a\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fe8f1fdcab7fbec9a6a3fcc507619600505c36a3\":{\"balance\":\"0x11164759ffb320000\"},\"fe91eccf2bd566afa11696c5049fa84c69630a52\":{\"balance\":\"0x692ae8897081d00000\"},\"fe96c4cd381562401aa32a86e65b9d52fa8aee27\":{\"balance\":\"0x8f1d5c1cae37400000\"},\"fe98c664c3e447a95e69bd582171b7176ea2a685\":{\"balance\":\"0xd8d726b7177a800000\"},\"fe9ad12ef05d6d90261f96c8340a0381974df477\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fe9c0fffefb803081256c0cf4d6659e6d33eb4fb\":{\"balance\":\"0x52d542804f1ce00000\"},\"fe9cfc3bb293ddb285e625f3582f74a6b0a5a6cd\":{\"balance\":\"0x6acb3df27e1f880000\"},\"fe9e1197d7974a7648dcc7a03112a88edbc9045d\":{\"balance\":\"0x10afc1ade3b4ed40000\"},\"feaca2ac74624bf348dac9985143cfd652a4be55\":{\"balance\":\"0x5897fcbb02914088000\"},\"fead1803e5e737a68e18472d9ac715f0994cc2be\":{\"balance\":\"0x1b1ae4d6e2ef500000\"},\"feb8b8e2af716ae41fc7c04bcf29540156461e6b\":{\"balance\":\"0x545174a528a77a0000\"},\"feb92d30bf01ff9a1901666c5573532bfa07eeec\":{\"balance\":\"0x3635c9adc5dea00000\"},\"febc3173bc9072136354002b7b4fb3bfc53f22f1\":{\"balance\":\"0x140ec80fa7ee880000\"},\"febd48d0ffdbd5656cd5e686363a61145228f279\":{\"balance\":\"0x97c9ce4cf6d5c00000\"},\"febd9f81cf78bd5fb6c4b9a24bd414bb9bfa4c4e\":{\"balance\":\"0x6be10fb8ed6e138000\"},\"fec06fe27b44c784b2396ec92f7b923ad17e9077\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"fec14e5485de2b3eef5e74c46146db8e454e0335\":{\"balance\":\"0x9b41fbf9e0aec0000\"},\"fed8476d10d584b38bfa6737600ef19d35c41ed8\":{\"balance\":\"0x62a992e53a0af00000\"},\"feef3b6eabc94affd3310c1c4d0e65375e131119\":{\"balance\":\"0x1158e460913d00000\"},\"fef09d70243f39ed8cd800bf9651479e8f4aca3c\":{\"balance\":\"0xad78ebc5ac6200000\"},\"fef3b3dead1a6926d49aa32b12c22af54d9ff985\":{\"balance\":\"0x3635c9adc5dea00000\"},\"ff0b7cb71da9d4c1ea6ecc28ebda504c63f82fd1\":{\"balance\":\"0x388a885df2fc6c0000\"},\"ff0c3c7798e8733dd2668152891bab80a8be955c\":{\"balance\":\"0x45946b0f9e9d60000\"},\"ff0cb06c42e3d88948e45bd7b0d4e291aefeea51\":{\"balance\":\"0x678a932062e4180000\"},\"ff0cc8dac824fa24fc3caa2169e6e057cf638ad6\":{\"balance\":\"0xd8d726b7177a800000\"},\"ff0e2fec304207467e1e3307f64cbf30af8fd9cd\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff128f4b355be1dc4a6f94fa510d7f15d53c2aff\":{\"balance\":\"0x93739534d286800000\"},\"ff12e49d8e06aa20f886293c0b98ed7eff788805\":{\"balance\":\"0xd8d726b7177a800000\"},\"ff207308ced238a6c01ad0213ca9eb4465d42590\":{\"balance\":\"0x6c6acc67d7b1d40000\"},\"ff26138330274df4e0a3081e6df7dd983ec6e78f\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff2726294148b86c78a9372497e459898ed3fee3\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ff3ded7a40d3aff0d7a8c45fa6136aa0433db457\":{\"balance\":\"0x6c68ccd09b022c0000\"},\"ff3eee57c34d6dae970d8b311117c53586cd3502\":{\"balance\":\"0x5c283d410394100000\"},\"ff3ef6ba151c21b59986ae64f6e8228bc9a2c733\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff41d9e1b4effe18d8b0d1f63fc4255fb4e06c3d\":{\"balance\":\"0x487a9a304539440000\"},\"ff45cb34c928364d9cc9d8bb00373474618f06f3\":{\"balance\":\"0x56bc75e2d63100000\"},\"ff49a775814ec00051a795a875de24592ea400d4\":{\"balance\":\"0x2a5a058fc295ed000000\"},\"ff4a408f50e9e72146a28ce4fc8d90271f116e84\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ff4d9c8484c43c42ff2c5ab759996498d323994d\":{\"balance\":\"0xd8d726b7177a800000\"},\"ff4fc66069046c525658c337a917f2d4b832b409\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff5162f2354dc492c75fd6e3a107268660eecb47\":{\"balance\":\"0x5c283d410394100000\"},\"ff545bbb66fbd00eb5e6373ff4e326f5feb5fe12\":{\"balance\":\"0x1158e460913d00000\"},\"ff5e7ee7d5114821e159dca5e81f18f1bfffbff9\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff61c9c1b7a3d8b53bba20b34466544b7b216644\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ff65511cada259260c1ddc41974ecaecd32d6357\":{\"balance\":\"0x5f68e8131ecf800000\"},\"ff7843c7010aa7e61519b762dfe49124a76b0e4e\":{\"balance\":\"0xc5b17924412b9bb00000\"},\"ff78541756ab2b706e0d70b18adb700fc4f1643d\":{\"balance\":\"0x92896529baddc880000\"},\"ff83855051ee8ffb70b4817dba3211ed2355869d\":{\"balance\":\"0x15af1d78b58c400000\"},\"ff850e3be1eb6a4d726c08fa73aad358f39706da\":{\"balance\":\"0x692ae8897081d00000\"},\"ff86e5e8e15b53909600e41308dab75f0e24e46b\":{\"balance\":\"0x30eb50d2e140800000\"},\"ff88ebacc41b3687f39e4b59e159599b80cba33f\":{\"balance\":\"0x15af1d78b58c400000\"},\"ff8a2ca5a81333f19998255f203256e1a819c0aa\":{\"balance\":\"0xc249fdd3277800000\"},\"ff8eb07de3d49d9d52bbe8e5b26dbe1d160fa834\":{\"balance\":\"0xd814dcb94453080000\"},\"ffa4aff1a37f984b0a67272149273ae9bd41e3bc\":{\"balance\":\"0x21e19e0c9bab2400000\"},\"ffa696ecbd787e66abae4fe87b635f07ca57d848\":{\"balance\":\"0x487a9a304539440000\"},\"ffac3db879a6c7158e8dec603b407463ba0d31cf\":{\"balance\":\"0x6acb3df27e1f880000\"},\"ffad3dd74e2c1f796ac640de56dc99b4c792a402\":{\"balance\":\"0x10f0cf064dd59200000\"},\"ffb04726dfa41afdc819168418610472970d7bfc\":{\"balance\":\"0xd8d726b7177a800000\"},\"ffb3bcc3196a8c3cb834cec94c34fed35b3e1054\":{\"balance\":\"0x48a43c54602f700000\"},\"ffb974673367f5c07be5fd270dc4b7138b074d57\":{\"balance\":\"0x85ebc8bdb9066d8000\"},\"ffb9c7217e66743031eb377af65c77db7359dcda\":{\"balance\":\"0x22b1c8c1227a00000\"},\"ffbc3da0381ec339c1c049eb1ed9ee34fdcea6ca\":{\"balance\":\"0xd8d726b7177a800000\"},\"ffc5fc4b7e8a0293ff39a3a0f7d60d2646d37a74\":{\"balance\":\"0x6c6b935b8bbd400000\"},\"ffc9cc3094b041ad0e076f968a0de3b167255866\":{\"balance\":\"0x1770c1650beee80000\"},\"ffd5170fd1a8118d558e7511e364b24906c4f6b3\":{\"balance\":\"0x341d8cd27f1588000\"},\"ffd6da958eecbc016bab91058440d39b41c7be83\":{\"balance\":\"0x43c33c1937564800000\"},\"ffe0e997f1977a615f5a315af413fd4869343ba0\":{\"balance\":\"0x56cd55fc64dfe0000\"},\"ffe28db53c9044b4ecd4053fd1b4b10d7056c688\":{\"balance\":\"0x56bc75e2d63100000\"},\"ffe2e28c3fb74749d7e780dc8a5d422538e6e451\":{\"balance\":\"0xdbb81e05bc12d8000\"},\"ffe8cbc1681e5e9db74a0f93f8ed25897519120f\":{\"balance\":\"0x51b1d3839261ac0000\"},\"ffeac0305ede3a915295ec8e61c7f881006f4474\":{\"balance\":\"0x556f64c1fe7fa0000\"},\"ffec0913c635baca2f5e57a37aa9fb7b6c9b6e26\":{\"balance\":\"0x2ba39e82ed5d740000\"},\"fff33a3bd36abdbd412707b8e310d6011454a7ae\":{\"balance\":\"0x1b1ae4d6e2ef5000000\"},\"fff4bad596633479a2a29f9a8b3f78eefd07e6ee\":{\"balance\":\"0x56bc75e2d63100000\"},\"fff7ac99c8e4feb60c9750054bdc14ce1857f181\":{\"balance\":\"0x3635c9adc5dea00000\"}}}", - "DatabaseCache": 16, - "CHTRootConfigURL": "https://gist.githubusercontent.com/farazdagi/a8d36e2818b3b2b6074d691da63a0c36/raw/" + "DatabaseCache": 16 }, "WhisperConfig": { "Enabled": true, diff --git a/geth/params/testdata/config.rinkeby.json b/geth/params/testdata/config.rinkeby.json index ad426f4d7..a7bc93ad5 100755 --- a/geth/params/testdata/config.rinkeby.json +++ b/geth/params/testdata/config.rinkeby.json @@ -24,13 +24,18 @@ "LogToStderr": true, "BootClusterConfig": { "Enabled": true, - "ConfigFile": "rinkeby.dev.json" + "RootNumber": 66, + "RootHash": "rinkeby-dev", + "BootNodes": [ + "enode://7512c8f6e7ffdcc723cf77e602a1de9d8cc2e8ad35db309464819122cd773857131aee390fec33894db13da730c8432bb248eed64039e3810e156e979b2847cb@51.15.78.243:30303", + "enode://1cc27a5a41130a5c8b90db5b2273dc28f7b56f3edfc0dcc57b665d451274b26541e8de49ea7a074281906a82209b9600239c981163b6ff85c3038a8e2bc5d8b8@51.15.68.93:30303", + "enode://798d17064141b8f88df718028a8272b943d1cb8e696b3dab56519c70b77b1d3469b56b6f4ce3788457646808f5c7299e9116626f2281f30b959527b969a71e4f@51.15.75.244:30303" + ] }, "LightEthConfig": { "Enabled": true, "Genesis": "{\"config\":{\"chainId\":4,\"homesteadBlock\":1,\"daoForkSupport\":true,\"eip150Block\":2,\"eip150Hash\":\"0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9\",\"eip155Block\":3,\"eip158Block\":3,\"clique\":{\"period\":15,\"epoch\":30000}},\"nonce\":\"0x0\",\"timestamp\":\"0x58ee40ba\",\"parentHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"extraData\":\"0x52657370656374206d7920617574686f7269746168207e452e436172746d616e42eb768f2244c8811c63729a21a3569731535f067ffc57839b00206d1ad20c69a1981b489f772031b279182d99e65703f0076e4812653aab85fca0f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"gasLimit\":\"0x47b760\",\"difficulty\":\"0x1\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"coinbase\":\"0x0000000000000000000000000000000000000000\",\"alloc\":{\"0000000000000000000000000000000000000000\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000001\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000002\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000003\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000004\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000005\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000006\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000007\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000008\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000009\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000010\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000011\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000012\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000013\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000014\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000015\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000016\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000017\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000018\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000019\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000001f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000020\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000021\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000022\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000023\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000024\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000025\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000026\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000027\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000028\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000029\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000002f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000030\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000031\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000032\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000033\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000034\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000035\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000036\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000037\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000038\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000039\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000003f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000040\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000041\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000042\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000043\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000044\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000045\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000046\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000047\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000048\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000049\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000004f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000050\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000051\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000052\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000053\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000054\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000055\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000056\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000057\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000058\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000059\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000005f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000060\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000061\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000062\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000063\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000064\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000065\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000066\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000067\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000068\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000069\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000006f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000070\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000071\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000072\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000073\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000074\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000075\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000076\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000077\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000078\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000079\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000007f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000080\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000081\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000082\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000083\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000084\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000085\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000086\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000087\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000088\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000089\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000008f\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000090\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000091\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000092\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000093\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000094\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000095\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000096\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000097\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000098\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000099\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009a\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009b\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009c\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009d\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009e\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000009f\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000a9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000aa\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ab\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ac\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ad\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ae\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000af\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000b9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ba\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000bb\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000bc\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000bd\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000be\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000bf\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000c9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ca\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000cb\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000cc\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000cd\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ce\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000cf\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000d9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000da\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000db\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000dc\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000dd\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000de\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000df\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000e9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ea\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000eb\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ec\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ed\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ee\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ef\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f0\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f1\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f2\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f3\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f4\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f5\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f6\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f7\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f8\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000f9\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000fa\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000fb\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000fc\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000fd\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000fe\":{\"balance\":\"0x1\"},\"00000000000000000000000000000000000000ff\":{\"balance\":\"0x1\"},\"31b98d14007bdee637298086988a0bbd31184523\":{\"balance\":\"0x200000000000000000000000000000000000000000000000000000000000000\"}}}", - "DatabaseCache": 16, - "CHTRootConfigURL": "https://gist.githubusercontent.com/farazdagi/a8d36e2818b3b2b6074d691da63a0c36/raw/" + "DatabaseCache": 16 }, "WhisperConfig": { "Enabled": true, diff --git a/geth/params/testdata/config.ropsten.json b/geth/params/testdata/config.ropsten.json index 1a96e2265..4ea2bda26 100755 --- a/geth/params/testdata/config.ropsten.json +++ b/geth/params/testdata/config.ropsten.json @@ -24,13 +24,30 @@ "LogToStderr": true, "BootClusterConfig": { "Enabled": true, - "ConfigFile": "ropsten.dev.json" + "RootNumber": 259, + "RootHash": "91825fffecb5678167273955deaddbf03c26ae04287cfda61403c0bad5ceab8d", + "BootNodes": [ + "enode://7ab298cedc4185a894d21d8a4615262ec6bdce66c9b6783878258e0d5b31013d30c9038932432f70e5b2b6a5cd323bf820554fcb22fbc7b45367889522e9c449@51.15.63.93:30303", + "enode://f59e8701f18c79c5cbc7618dc7bb928d44dc2f5405c7d693dad97da2d8585975942ec6fd36d3fe608bfdc7270a34a4dd00f38cfe96b2baa24f7cd0ac28d382a1@51.15.79.88:30303", + "enode://e2a3587b7b41acfc49eddea9229281905d252efba0baf565cf6276df17faf04801b7879eead757da8b5be13b05f25e775ab6d857ff264bc53a89c027a657dd10@51.15.45.114:30303", + "enode://fe991752c4ceab8b90608fbf16d89a5f7d6d1825647d4981569ebcece1b243b2000420a5db721e214231c7a6da3543fa821185c706cbd9b9be651494ec97f56a@51.15.67.119:30303", + "enode://482484b9198530ee2e00db89791823244ca41dcd372242e2e1297dd06f6d8dd357603960c5ad9cc8dc15fcdf0e4edd06b7ad7db590e67a0b54f798c26581ebd7@51.15.75.138:30303", + "enode://9e99e183b5c71d51deb16e6b42ac9c26c75cfc95fff9dfae828b871b348354cbecf196dff4dd43567b26c8241b2b979cb4ea9f8dae2d9aacf86649dafe19a39a@51.15.79.176:30303", + "enode://12d52c3796700fb5acff2c7d96df7bbb6d7109b67f3442ee3d99ac1c197016cddb4c3568bbeba05d39145c59c990cd64f76bc9b00d4b13f10095c49507dd4cf9@51.15.63.110:30303", + "enode://0f7c65277f916ff4379fe520b875082a56e587eb3ce1c1567d9ff94206bdb05ba167c52272f20f634cd1ebdec5d9dfeb393018bfde1595d8e64a717c8b46692f@51.15.54.150:30303", + "enode://e006f0b2dc98e757468b67173295519e9b6d5ff4842772acb18fd055c620727ab23766c95b8ee1008dea9e8ef61e83b1515ddb3fb56dbfb9dbf1f463552a7c9f@212.47.237.127:30303", + "enode://d40871fc3e11b2649700978e06acd68a24af54e603d4333faecb70926ca7df93baa0b7bf4e927fcad9a7c1c07f9b325b22f6d1730e728314d0e4e6523e5cebc2@51.15.132.235:30303", + "enode://ea37c9724762be7f668e15d3dc955562529ab4f01bd7951f0b3c1960b75ecba45e8c3bb3c8ebe6a7504d9a40dd99a562b13629cc8e5e12153451765f9a12a61d@163.172.189.205:30303", + "enode://88c2b24429a6f7683fbfd06874ae3f1e7c8b4a5ffb846e77c705ba02e2543789d66fc032b6606a8d8888eb6239a2abe5897ce83f78dcdcfcb027d6ea69aa6fe9@163.172.157.61:30303", + "enode://ce6854c2c77a8800fcc12600206c344b8053bb90ee3ba280e6c4f18f3141cdc5ee80bcc3bdb24cbc0e96dffd4b38d7b57546ed528c00af6cd604ab65c4d528f6@163.172.153.124:30303", + "enode://00ae60771d9815daba35766d463a82a7b360b3a80e35ab2e0daa25bdc6ca6213ff4c8348025e7e1a908a8f58411a364fe02a0fb3c2aa32008304f063d8aaf1a2@163.172.132.85:30303", + "enode://86ebc843aa51669e08e27400e435f957918e39dc540b021a2f3291ab776c88bbda3d97631639219b6e77e375ab7944222c47713bdeb3251b25779ce743a39d70@212.47.254.155:30303" + ] }, "LightEthConfig": { "Enabled": true, "Genesis": "{\"config\":{\"chainId\":3,\"homesteadBlock\":0,\"daoForkSupport\":true,\"eip150Block\":0,\"eip150Hash\":\"0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d\",\"eip155Block\":10,\"eip158Block\":10,\"ethash\":{}},\"nonce\":\"0x42\",\"timestamp\":\"0x0\",\"parentHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"extraData\":\"0x3535353535353535353535353535353535353535353535353535353535353535\",\"gasLimit\":\"0x1000000\",\"difficulty\":\"0x100000\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"coinbase\":\"0x0000000000000000000000000000000000000000\",\"alloc\":{\"0000000000000000000000000000000000000000\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000001\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000002\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000003\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000004\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000005\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000006\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000007\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000008\":{\"balance\":\"0x1\"},\"0000000000000000000000000000000000000009\":{\"balance\":\"0x1\"},\"000000000000000000000000000000000000000a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000000b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000000c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000000d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000000e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000000f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000010\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000011\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000012\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000013\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000014\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000015\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000016\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000017\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000018\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000019\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000001f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000020\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000021\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000022\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000023\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000024\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000025\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000026\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000027\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000028\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000029\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000002f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000030\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000031\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000032\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000033\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000034\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000035\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000036\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000037\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000038\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000039\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000003f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000040\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000041\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000042\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000043\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000044\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000045\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000046\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000047\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000048\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000049\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000004f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000050\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000051\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000052\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000053\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000054\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000055\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000056\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000057\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000058\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000059\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000005f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000060\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000061\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000062\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000063\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000064\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000065\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000066\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000067\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000068\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000069\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000006f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000070\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000071\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000072\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000073\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000074\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000075\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000076\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000077\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000078\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000079\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000007f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000080\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000081\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000082\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000083\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000084\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000085\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000086\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000087\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000088\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000089\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000008f\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000090\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000091\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000092\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000093\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000094\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000095\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000096\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000097\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000098\":{\"balance\":\"0x0\"},\"0000000000000000000000000000000000000099\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009a\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009b\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009c\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009d\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009e\":{\"balance\":\"0x0\"},\"000000000000000000000000000000000000009f\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000a9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000aa\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ab\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ac\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ad\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ae\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000af\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000b9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ba\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000bb\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000bc\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000bd\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000be\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000bf\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000c9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ca\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000cb\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000cc\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000cd\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ce\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000cf\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000d9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000da\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000db\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000dc\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000dd\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000de\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000df\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000e9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ea\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000eb\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ec\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ed\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ee\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ef\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f0\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f1\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f2\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f3\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f4\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f5\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f6\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f7\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f8\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000f9\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000fa\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000fb\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000fc\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000fd\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000fe\":{\"balance\":\"0x0\"},\"00000000000000000000000000000000000000ff\":{\"balance\":\"0x0\"},\"874b54a8bd152966d63f706bae1ffeb0411921e5\":{\"balance\":\"0xc9f2c9cd04674edea40000000\"}}}", - "DatabaseCache": 16, - "CHTRootConfigURL": "https://gist.githubusercontent.com/farazdagi/a8d36e2818b3b2b6074d691da63a0c36/raw/" + "DatabaseCache": 16 }, "WhisperConfig": { "Enabled": true, diff --git a/static/bindata.go b/static/bindata.go index 53caf66d7..c020f2ab2 100644 --- a/static/bindata.go +++ b/static/bindata.go @@ -2,12 +2,6 @@ // sources: // scripts/README.md // scripts/web3.js -// bootcluster/homestead.dev.json -// bootcluster/homestead.prod.json -// bootcluster/rinkeby.dev.json -// bootcluster/rinkeby.prod.json -// bootcluster/ropsten.dev.json -// bootcluster/ropsten.prod.json // config/linter_exclude_list.txt // config/test-data.json // keys/firebaseauthkey @@ -89,7 +83,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _scriptsReadmeMd = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x34\xcc\xb1\x15\xc2\x30\x0c\x04\xd0\x9e\x29\x6e\x00\x42\xc3\x16\xb4\x2c\x10\xc5\xbe\x60\x41\x6c\xe7\x49\x32\x79\xd9\x9e\x8a\x05\xfe\x04\x27\x31\x57\xf9\x10\x2f\x36\x9a\x04\x67\x1c\x45\x53\x41\x1f\xb1\x8f\x70\x1c\x5c\xee\xb7\xb7\x43\x5b\x74\x44\x51\x47\x56\x63\x8a\x6e\xe7\x65\x82\x36\xac\x23\x86\xf1\x0a\xef\x95\xf0\x90\xd0\x84\x87\x7c\xe5\x99\x4c\xf7\xc0\xaa\x1b\x1d\x55\x4e\x2c\x84\xe4\xcc\x8c\x3f\xb4\xf6\x2d\xd3\x7e\x01\x00\x00\xff\xff\x97\x1d\xc2\x5f\x85\x00\x00\x00") +var _scriptsReadmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x34\xcc\xb1\x15\xc2\x30\x0c\x04\xd0\x9e\x29\x6e\x00\x42\xc3\x16\xb4\x2c\x10\xc5\xbe\x60\x41\x6c\xe7\x49\x32\x79\xd9\x9e\x8a\x05\xfe\x04\x27\x31\x57\xf9\x10\x2f\x36\x9a\x04\x67\x1c\x45\x53\x41\x1f\xb1\x8f\x70\x1c\x5c\xee\xb7\xb7\x43\x5b\x74\x44\x51\x47\x56\x63\x8a\x6e\xe7\x65\x82\x36\xac\x23\x86\xf1\x0a\xef\x95\xf0\x90\xd0\x84\x87\x7c\xe5\x99\x4c\xf7\xc0\xaa\x1b\x1d\x55\x4e\x2c\x84\xe4\xcc\x8c\x3f\xb4\xf6\x2d\xd3\x7e\x01\x00\x00\xff\xff\x97\x1d\xc2\x5f\x85\x00\x00\x00") func scriptsReadmeMdBytes() ([]byte, error) { return bindataRead( @@ -104,12 +98,12 @@ func scriptsReadmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "scripts/README.md", size: 133, mode: os.FileMode(420), modTime: time.Unix(1494856773, 0)} + info := bindataFileInfo{name: "scripts/README.md", size: 133, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _scriptsWeb3Js = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\xfd\x6b\x7b\x13\x39\xd2\x38\x0e\xbf\xcf\xa7\x50\xfc\xdc\x0f\xb6\x49\x63\xe7\x34\x0c\xd3\x99\x0c\x1b\x02\x33\x64\x6f\x20\x5c\x40\x66\x76\xef\x6c\x96\xab\xed\x96\x6d\x0d\xed\x6e\xff\xba\xdb\x09\x59\x92\xef\xfe\xbf\x54\x3a\x1f\xfa\xe0\x24\xcc\x69\x93\x17\xe0\x96\x4a\xa7\x52\xa9\x54\x2a\x95\xaa\x72\xfc\xff\x96\x24\xc7\xfb\xbd\xc9\x32\x1d\x97\x24\x4b\x11\xee\x95\x41\x1a\xe4\xfd\x2f\x32\xa5\xe8\x65\xc1\xb2\xff\x85\x4c\x7a\xeb\xe9\x69\x76\xc6\x7e\x95\xf0\xeb\x3c\xca\x51\xb4\x5f\x5e\x2e\x70\x36\x41\xa2\xae\xfd\x8e\x28\xda\x79\xf0\x80\x27\xee\xd1\x32\xcb\x07\x0f\xa2\x7e\x8e\xcb\x65\x9e\xa2\xa8\x97\x05\xeb\x9b\x7d\x9a\x4e\x44\x1a\xe1\x69\xb4\xd6\xc9\x7e\x8a\x2f\xd0\x8b\x3c\xcf\xf2\x5e\xe7\x30\x4a\xd3\xac\x44\x13\x92\xc6\x68\x9e\xc5\xcb\x04\xa3\x6e\x67\x23\xdb\xe8\x74\x3b\xfd\xbd\x72\x96\x67\x17\x68\x32\x18\x67\x31\xde\xef\xbc\x3e\x7e\x7e\xf2\xea\xc5\xc7\x37\xc7\x1f\x3e\xfe\x78\x7c\xf2\xe6\x79\x27\x98\x5c\xd3\xfa\x92\x7d\xda\xf7\xfd\x2f\xf8\xf3\x22\xcb\xcb\x22\xfc\x72\x7d\xbd\x47\xc7\x70\xba\x79\x36\x18\x47\x49\xd2\x4b\x06\x3c\x2b\x10\xbd\xef\x61\x36\xc0\x74\x1f\x00\xb7\xce\x4e\xf1\xd9\x1e\xef\x6a\xd1\x4b\x9f\xa6\x21\xee\x5f\x07\x49\xa0\x4a\xe2\x80\xe1\xee\x9a\x43\xd1\x26\x45\x26\xf4\x82\xb4\xc2\xd5\x24\xcb\x7b\x14\x3a\xdb\xdf\xdc\xcb\xbe\xcf\x07\x09\x4e\xa7\xe5\x6c\x2f\xdb\xd8\xe8\x17\xbd\x9c\x22\x5e\x76\xe3\xba\xdf\xfb\xb2\x15\x9e\xca\x2e\xf3\x2a\x02\x86\xa5\x80\xb7\xdd\xff\xb2\xc6\x12\x44\x67\xf6\x4f\xd7\x10\xfa\xb2\x86\x10\x42\x9d\x71\x96\x16\x65\x94\x96\x9d\x10\x95\xf9\x12\x07\x2c\x95\xa4\x8b\x65\x59\x74\x42\x74\x0a\xdf\x02\x1a\xf2\xd2\x68\x8e\x3b\x21\xea\x7c\xcc\x2e\x52\x9c\x77\x02\x95\x43\x47\x47\x73\xa2\x38\xce\x71\x51\x74\x78\xce\x35\xfc\x7f\xc6\xab\x16\xc5\xe1\x7f\x9e\x96\x2d\xcb\xe6\xf6\xb2\x8f\x5a\x11\xa3\xbd\xd1\x65\x89\x8b\x9d\x6d\x7f\x7b\x02\x48\x62\x7a\x0d\xa1\xeb\xe0\x4e\x10\x70\xa3\xfe\xc8\xe1\x68\xd8\x6b\x87\x80\x95\x51\xfd\x47\x1d\xfa\x38\x4b\x4b\x9c\x96\xb7\x1e\xfc\x9f\x72\xde\xe9\x8c\xfd\x61\xa6\x7d\x12\x25\xc5\x6f\x37\xf4\x1c\x17\x38\x3f\xf7\xad\xfa\x3f\xfa\xa4\x15\xcb\xd1\x3b\x3c\x25\x45\x99\x47\xff\x05\x93\x17\xd4\xd5\x81\x2f\x8e\x6f\xc5\xf7\xcb\x3c\x4a\x8b\x89\x97\xf5\xfd\x59\x70\x90\x5b\xa4\xb0\x3a\x12\x0a\x5c\xbe\xaf\x27\xa9\x3b\xc3\x85\xdd\xf4\x6f\xd2\xe8\x57\x9e\x80\xa8\x0d\xe2\xeb\x2a\x58\xe4\x64\x1e\xe5\x97\xde\x7e\x64\x59\xd2\x38\x79\x07\xbc\xad\x3f\x2f\x0a\xcd\x3d\xb8\xb6\x9a\x2a\x24\x1c\x56\x6e\xe3\x7f\x24\x24\x78\x7b\x1f\x93\x22\xbb\x48\x6f\xd1\xf3\x28\xcd\xd2\xcb\x79\xb6\x2c\x56\xe8\x3a\x49\x63\xfc\x19\xc7\xc6\xde\x75\x67\x13\xab\x2a\xd7\xba\x63\xd6\x7e\x41\xd2\xdb\x30\xee\x83\x25\x60\xe2\x45\x1a\xe3\xb8\x63\xa1\x09\x9f\x53\x42\xf8\x0b\xe0\x68\x44\xe2\xb8\x1d\x8e\x6e\x56\xff\x79\x94\x2c\xbd\xdd\x5f\x92\xb4\xdc\xfe\xe6\x71\xfd\x14\xbc\xc1\x17\xcf\xc8\xef\x88\xfc\x5b\xad\xb9\xc3\x59\x94\x4e\x7f\x4f\xd2\xb9\x13\xca\xa9\xa8\x5b\x93\xea\x6b\xa9\xc6\x8b\x99\xb7\x6c\x37\x6a\x44\xd0\xda\xd9\xda\xda\x75\xf0\xe5\xfa\x2c\xd8\xfe\xdd\x0e\xfd\x7f\xa1\x33\xef\xef\x24\x3b\x4e\x96\x69\x7c\x63\x52\xb9\xf5\xc6\x75\x7f\xec\xfd\x73\x1f\x7b\xef\x0f\x7d\x7f\xe4\x33\x87\x77\xf0\xfc\xbc\xf0\x47\x93\x36\xbf\xee\x66\xae\xf6\xaa\x9d\x3b\xdb\xab\x56\x9d\xf7\x49\x9e\xcd\x6f\x39\xed\x65\x76\xcb\xa3\xe6\xed\x04\xbe\xdf\x77\xdd\xfc\x11\xf0\x47\xd2\x98\xe4\x78\x5c\x1e\x79\xf7\xcc\x15\x7a\x72\xbb\x89\x20\xe3\x68\xf1\xe1\x77\x9d\x0c\x3f\x26\xdb\x9d\x76\xf1\x22\x2b\x48\xdd\x41\x7d\x11\x5d\x46\xa3\x04\x9b\x42\xc1\xef\xc2\x95\xaa\x68\xee\x4e\x8e\x5f\xb7\xa3\x81\x03\x31\xde\xe7\x26\x3e\x7f\xfb\x93\xcc\x9d\x20\xa9\xa2\xee\x76\x74\xf6\x3b\xa0\xff\x0f\x8b\xf5\xbb\x38\x3f\xde\x98\x4f\x7e\x6d\xac\xdb\x4c\xef\x1e\xed\x2d\xd1\x7e\xeb\x8d\xeb\x6b\xcf\xec\x91\x67\x4b\xab\x93\xe3\x76\xdb\xc8\x71\x60\xbc\x81\xf6\x85\x85\x43\xaf\x3b\x18\x4e\xb2\x7c\x1e\x95\x25\xce\x8b\x6e\x7f\x0f\x00\xde\x67\x09\x89\x49\x79\xf9\xe1\x72\x81\x4d\x58\xda\x3e\x85\x5a\x1b\x3e\x7c\xb8\x86\x1e\x1a\x90\x5c\xe7\x8e\x48\x81\x22\xb4\xc8\xb3\x8c\x02\xa3\x72\x16\x95\x28\xc7\x0b\x7a\xc8\x4a\xcb\x02\xf1\xb9\x43\x34\x93\xd6\x70\x54\xa2\x79\x54\x8e\x67\xb8\x08\xe9\x27\xcf\xd6\x7e\x9e\x9e\xe9\x1f\xbb\xc6\xd7\x99\x99\xb9\x63\x7d\x9f\x9d\x3e\x3e\x3b\x3d\x0b\xd0\x60\x30\x58\x43\x0f\x87\xce\xd8\x44\x8f\xf7\x91\xb4\xa6\xe9\xf5\xf9\x14\x97\x33\x52\x0c\x3e\xc2\xc2\xf8\x51\x20\x88\x02\x0e\x18\xba\x8e\x68\xc6\x51\x5a\xee\x69\xc0\x6c\xdf\xf6\x41\x1f\x43\x0e\x6f\x6e\x6f\xed\x7a\x6f\x6d\xcd\xd3\x8f\xc1\x22\xcf\x4a\x86\xb5\x7d\x94\xe2\x0b\xa3\xaf\xbd\x2f\xd7\xfd\xbd\xfa\x52\x03\x90\x5e\xf2\xe5\xb8\xcc\x68\xe3\x1e\xd8\xa6\x76\x07\xa4\xe0\x73\xae\x10\x42\xc9\x51\x20\x85\xdb\xb5\xac\xaf\xd3\xc4\x01\xcc\x5b\x6f\xc8\xb1\xdd\xfb\xd7\x69\xef\x74\xf3\xd1\x77\x67\x0f\xfb\xff\x3a\xeb\x3f\x1d\xf6\xd9\x38\xcd\x83\x43\x65\xb7\xae\x83\x2f\x1d\x9d\x14\x3b\xe1\x77\x41\x87\xd1\x5b\x27\xdc\xda\xbd\x3e\x0b\xbe\xf9\x9d\xc9\xfb\x59\x96\x25\x0d\xb4\x3d\xa2\x20\x15\x84\x4d\xf3\xc4\xff\x8c\x4a\xe1\xd7\xae\xfa\x79\xa6\x25\xef\xe8\x1f\x4d\x64\x0c\x3d\xbb\x29\x0d\xd3\xc2\xab\x10\x31\x83\xb7\x29\x98\xa6\xae\x48\xbe\x66\x91\x1a\xda\x65\x2d\xd6\x95\xbd\x09\xd5\xfe\x9b\xa2\xd6\xa4\xd9\x87\xff\xd3\x8a\x68\x79\x7f\x9a\x29\xf6\xf1\xef\x4d\xb1\x74\x0f\x93\x24\x5b\xfa\x69\xb6\x9c\x61\x04\x9b\x1d\x10\xee\xc0\x47\xb9\x34\x57\xfe\xe0\x74\x09\x3f\x77\xb5\xdf\x67\x7a\xc6\x8e\xf1\x65\xd2\x2f\xe2\x5b\xab\xfc\xf9\xc4\xa8\x87\x17\xf5\x50\x39\x74\xf2\xc6\x64\x4e\x4b\xaf\x44\xe7\xac\x80\x43\xe8\x34\x79\x55\x4a\x37\xcb\xd4\x91\x3a\x6b\xb4\xb6\xf4\xcd\x88\x9d\x56\xc2\x48\xfd\xcb\x56\x70\xdd\xbf\x19\xe1\xf3\xde\x35\x53\xfe\xb7\x6d\x28\x7f\xf8\x10\x3a\xfc\x61\x46\x0a\x34\x21\x09\xa6\x94\xba\x88\xf2\x12\x65\x13\x74\x81\x47\x3b\x83\x5f\x8b\xc1\x1a\x80\xf0\x2f\x0a\x30\xc9\x31\x46\x45\x36\x29\x2f\xa2\x1c\x87\xe8\x32\x5b\xa2\x71\x94\xa2\x1c\xc7\xa4\x28\x73\x32\x5a\x96\x18\x91\x12\x45\x69\x3c\xcc\x72\x34\xcf\x62\x32\xb9\x84\x3a\x48\x89\x96\x69\x8c\x73\x20\xf8\x12\xe7\xf3\x82\xb6\x43\x3f\x7e\x7a\x73\x82\x5e\xe1\xa2\xc0\x39\xfa\x09\xa7\x38\x8f\x12\xf4\x76\x39\x4a\xc8\x18\xbd\x22\x63\x9c\x16\x18\x45\x05\x5a\xd0\x94\x62\x86\x63\x34\xba\xe4\x54\x84\xd1\x8f\xb4\x33\xef\x79\x67\xd0\x8f\xd9\x32\x8d\x23\x3a\xe6\x00\x61\x52\xce\x70\x8e\xce\x71\x5e\xd0\x19\xda\x11\x6d\xf1\x1a\x03\x94\xe5\x50\x4b\x2f\x2a\xe9\x18\x72\x94\x2d\x68\xc1\x3e\x8a\xd2\x4b\x94\x44\xa5\x2a\xeb\xa2\x40\x8d\x34\x46\x24\x85\x6a\x67\x99\x58\xd9\xa4\x44\x17\x24\x49\xd0\x08\xa3\x65\x81\x27\xcb\x84\x09\x8e\xa3\x65\x89\x7e\x39\xfa\xf0\xf2\xf8\xe4\x03\x3a\x78\xf3\x4f\xf4\xcb\xc1\xbb\x77\x07\x6f\x3e\xfc\x73\x0f\x5d\x90\x72\x96\x2d\x4b\x44\x25\x4a\xa8\x8b\xcc\x17\x09\xc1\x31\xba\x88\xf2\x3c\x4a\xcb\x4b\x94\x4d\xa0\x8a\xd7\x2f\xde\x1d\xbe\x3c\x78\xf3\xe1\xe0\xd9\xd1\xab\xa3\x0f\xff\x44\x59\x8e\x7e\x3c\xfa\xf0\xe6\xc5\xfb\xf7\xe8\xc7\xe3\x77\xe8\x00\xbd\x3d\x78\xf7\xe1\xe8\xf0\xe4\xd5\xc1\x3b\xf4\xf6\xe4\xdd\xdb\xe3\xf7\x2f\x06\x08\xbd\xc7\xb4\x63\x18\x6a\x68\x46\xf4\x04\xe6\x2c\xc7\x28\xc6\x65\x44\x12\x31\xff\xff\xcc\x96\xa8\x98\x65\xcb\x24\x46\xb3\xe8\x1c\xa3\x1c\x8f\x31\x39\xc7\x31\x8a\xd0\x38\x5b\x5c\xb6\x9e\x48\xa8\x2c\x4a\xb2\x74\x0a\xc3\x96\x54\x86\xd0\xd1\x04\xa5\x59\x19\xa0\x02\x63\xf4\xfd\xac\x2c\x17\xe1\x70\x78\x71\x71\x31\x98\xa6\xcb\x41\x96\x4f\x87\x09\xab\xa0\x18\xfe\x30\x58\x7b\x38\x14\xcc\xf6\x6f\x40\xb6\xe3\x2c\xc6\xf9\xe0\x57\x60\x91\x7f\x8b\x96\xe5\x2c\xcb\xd1\xeb\x28\xc7\x9f\xd0\xff\x66\x25\xbe\x20\xe3\xff\xa0\xef\xe7\xf4\xfb\x6f\xb8\x9c\xc5\xf8\x7c\x30\xce\xe6\x3f\x00\x70\x1c\x95\x18\x6d\x6f\x6e\x7d\x03\x0c\xaf\x79\x2b\xa8\x11\x60\xb5\x32\x5c\x1e\xf3\xed\x1d\x5c\x52\xd0\x80\xe9\x2e\xe8\x83\x3c\x4a\x4b\x13\x90\xa4\xa5\x0f\xee\xc4\x01\x5c\x56\x40\x3e\xbf\x4c\xa3\x39\x19\x0b\x36\xae\x95\x88\x59\x0e\xf0\x28\x5f\xc9\xf7\x65\x4e\xd2\xa9\x59\xa6\x80\x34\x1f\xf4\x3b\x1c\x59\x63\xcc\x71\xe4\x1d\xe3\x89\x0b\xba\xac\x82\xf5\x74\x5b\xf6\x17\x80\x49\xc1\x07\x68\x70\xe6\x42\xab\x22\x80\x1d\x96\xf3\x69\x61\x21\xae\xe5\x0f\x64\x15\xb0\x8d\x30\xe0\xab\x2b\x79\x7a\x44\x15\xd0\x07\x79\x1e\x5d\x32\x70\xc6\xc4\x2d\x51\xe0\x90\xd2\xa7\x26\x01\xf0\x95\xc4\x38\x44\x8c\xca\x0c\xe1\x94\xd2\xf0\x30\xc6\xf4\x3f\xd9\x0a\x65\xc6\x11\x63\x93\x94\x2b\x71\xb9\xd6\xdc\x98\x59\xdd\xfa\x88\x29\x58\x61\xee\xcc\x90\x84\xf6\xa1\x86\xc2\xe8\x22\xf0\xfe\x39\x2e\x67\x59\xec\xe9\x16\x53\xae\x67\xf9\x1c\x31\xc9\x25\x33\x66\x64\x0d\xb1\x35\xc8\x8b\x7f\xe4\x33\xc3\xb3\xd0\xdf\xa0\xf7\xe8\x0b\x23\x9e\x6b\x29\x96\xff\x8d\x61\xbe\x40\x5f\xf4\xca\xae\x21\x0b\xde\x2a\x14\xe8\x0b\xbc\x6b\xb8\x46\xfc\x93\x50\xde\xc0\x24\x22\x4a\x86\xd0\x17\xba\x13\x51\x76\x0f\x08\x31\x90\xa1\xed\xd4\x7a\x97\x1c\x1c\x09\x14\x51\x6c\x16\xa6\x78\xa7\x61\x6d\x30\x21\x49\x89\xf3\x9e\x56\xb6\xaf\xe9\x20\x38\x15\x95\x5c\x28\x10\x44\x00\x3a\x85\xfe\xe9\xe6\xd9\x1e\xe3\x9f\x64\x82\x7a\xeb\x7a\x23\x7a\x1d\xec\x81\x06\x7b\xca\xd1\x25\xe9\x79\x94\x90\x58\xd1\x00\xad\x71\x3d\x44\x5d\xb4\x81\xf4\xca\xd7\x74\x59\x43\xaf\xd9\xa4\xc0\x0a\x4a\x43\x8b\x24\x22\x29\xa3\x2f\x6b\x1a\x19\xc0\x5b\x9e\x53\x3d\x8b\x3c\xfd\x78\xf4\x2b\x1e\x97\xd7\x56\x85\x62\x92\x55\x39\x56\x6d\x6c\xc1\x55\x4f\x9d\xd6\x0d\x67\xe6\x02\x56\xde\x12\xb8\x60\xd2\xb4\x62\x45\xef\x94\x02\x9f\x05\xe8\x14\xc0\xcf\xfa\xed\x50\x93\x90\x02\x24\x20\xb6\xf8\xaa\xb1\x53\xe8\x68\x00\x16\xc0\xb0\xe3\x4b\x5f\xa8\x02\x55\x88\x71\x9a\x6d\x85\x9b\xc2\x5d\xfa\x1c\x3b\x45\x15\x7d\x17\x82\xc0\xa7\xb8\xd4\x57\x60\xc1\x39\x07\x27\x59\x5a\x8c\xf7\x8d\x96\x30\x6a\x18\xcc\xa3\x45\xaf\x8a\xc7\x82\x56\xce\xb3\x46\x0c\xde\xc9\x6a\xee\xb1\x9e\x9e\x42\x91\x33\xc6\x9e\xc5\x97\x5c\x45\x5a\x7f\xf8\x3e\x75\x3c\x99\x14\xb8\x74\x3a\x95\xe3\x78\x39\xc6\x5a\xbf\xa2\xf1\x38\x40\x0d\x9d\x03\xec\x94\x51\x49\xc6\x6f\xa3\xbc\x7c\x05\x2f\x89\xac\x9a\x07\x76\x7e\xcf\xd3\x4f\x51\x57\x4e\x99\x12\x8e\xdf\xbb\x55\xbe\x8e\xca\xd9\x60\x92\x64\x59\xde\xeb\x39\x2d\x6e\xa0\x9d\xad\x3e\x1a\xa2\x9d\xed\x3e\x7a\x88\x76\xb6\xf9\xa0\x35\xf4\x45\xe3\x31\xda\x40\x3d\xb9\xe9\x18\x58\xaf\x40\x21\x7a\xaa\xed\x5d\x08\xed\x6c\xa3\xd0\x48\xa8\xe8\xac\x40\x7d\x80\x36\x75\xec\xe7\xb8\x58\x26\xa5\xa0\x1e\x36\x83\xaf\x97\x49\x49\x7e\x21\xe5\x8c\xcd\x89\xa0\x40\xa3\x6f\x81\xa4\xa3\xc0\x9c\x41\x51\x39\x1f\x21\xab\xdf\x3c\xf1\xf9\x49\xdf\x6a\xd5\xb7\x06\x5a\xf6\x40\x5b\x23\x72\x78\x9d\xce\x9e\x5a\x38\x38\x99\xf0\x11\xf3\xce\xf2\x5d\x21\xcb\x5f\x44\xe3\x59\xcf\x66\x4c\x44\xa7\x2d\xca\xf5\x2b\xe7\x4b\xcd\xd5\x59\x5f\x2f\xc4\x10\x02\x5d\xd9\x70\xb5\x9d\x3d\xb3\xfb\x62\x1d\x69\x44\x28\xd7\x2e\xa5\x62\x9c\x4c\x38\x88\x3d\x47\xd0\x01\xb7\x4b\x02\x4f\xf0\x61\x4f\x96\xde\x84\xb9\x14\x37\xf6\x11\xe6\xcf\xf0\xd0\x10\x6d\x2b\xd0\x6b\x84\x93\x02\x5b\xc3\x1b\x0e\x51\x9c\xa5\xdd\x12\x45\x71\x8c\x78\xa9\x32\x33\xab\x1c\x20\x52\x76\x0b\x14\x25\x39\x8e\xe2\x4b\x34\xce\x96\x69\x89\xe3\x0a\x2c\x7d\xa5\x71\x5e\xab\x45\x38\x1c\xa2\x0f\xc7\xcf\x8f\x43\x34\x21\xd3\x65\x8e\x11\x3d\xb0\xa5\xb8\xa0\x27\x40\x7a\x4a\xbb\x2c\x4c\x66\xf5\x5b\x10\xc9\x1f\x67\x92\xcd\xc9\xc0\x3a\x02\x05\x56\x2a\x96\xb9\x44\x6b\x8e\x27\x11\xa8\x63\x2e\x66\x59\x82\x59\x0f\x49\x3a\x5d\x6f\x60\x04\x35\x3c\xc0\xe6\xfc\x7c\xd0\x01\xca\x9c\x95\x6f\x2c\x72\x31\x27\x8d\xa2\xbe\x67\x8b\xeb\xb9\xaa\x31\x8d\x80\x58\xc3\xe8\x22\x52\x64\x5d\xe0\xd2\x99\x53\x46\x56\x6f\xa2\x39\xb6\xf7\x21\x95\xa3\xcb\x99\x6e\x59\xcf\xe6\x53\xbf\x9f\xa9\x8a\x3d\x75\x4a\xbe\xc8\x31\xa8\xa4\x5a\xf1\x57\x33\x6c\x51\xc9\x22\xc7\xe7\x24\x5b\x16\xb2\x43\xdb\x7b\x14\x25\x24\x45\x24\x2d\x9d\x12\x4d\xf8\xd7\xfa\xeb\x6b\x90\xfe\x4d\xb2\x1c\xc1\x23\x61\x82\xf6\xd1\xd6\x1e\x22\xe8\x7b\x31\x00\xf1\x5e\x18\x91\x8d\x8d\xaa\xe2\xf4\xcf\xea\xf3\xc6\x3e\xda\xe8\x09\x1c\x10\xf4\x08\x6d\x9d\x51\x09\x1f\x5d\x5d\xa1\xcd\xbd\xca\x4a\x6a\x58\x39\xa7\x87\x0d\x44\xd0\xc3\xaa\x99\xdb\xb0\x7b\x41\x85\x83\x2a\xb6\x2f\xfe\xae\x9d\x54\x33\xe5\xba\xdf\xeb\x5b\x53\x38\x1c\xa2\x09\xc9\x8b\x12\xe1\x04\xcf\x71\x5a\xd2\xf3\x15\x43\x53\x80\x8a\x4f\x64\x81\x48\xb9\xca\x94\x1b\xd8\xdf\xf4\x61\x9f\xe2\xaf\x76\x06\xe0\xe9\x7c\x1c\x13\xda\x48\x94\xc8\x45\xce\xf1\xe9\xf0\x1f\x17\xdf\x7e\xbe\xa8\x48\xa7\x82\x41\x9c\x12\xb4\x81\xb6\xce\x04\x9f\x40\x1b\xc8\xe9\x86\x07\xed\x8d\x08\xb6\x98\x9f\x07\x92\x6f\x95\x1e\xda\x67\x54\x71\x63\xd6\xf3\x87\x66\x2a\x54\xd8\x32\x31\x75\xcb\xc5\xdf\x40\x99\xa8\x8a\x21\x6d\xd6\x31\x24\xd4\x8a\xa6\x1b\x39\xca\x70\x88\xc6\x51\x32\x5e\x26\x51\x89\x85\xe0\x43\x8f\x7c\xbc\x2f\x88\x94\x78\x7e\x0b\x76\x44\x59\xd1\xe9\x9f\x88\x29\xf5\x6d\xd8\xeb\x95\xf6\x95\x5b\x4e\xc8\xef\xc7\x60\x74\xe6\xf2\xd5\x79\x0b\x72\xb4\x45\xbc\x1f\x0d\xda\x10\xae\x8b\xe4\x37\x93\x59\x8d\xc6\x88\x41\xb6\xd6\x18\x89\x74\x79\xab\x29\x55\x22\x7e\x5d\x52\xb5\x1e\x44\x6b\xd8\x23\xfe\x41\xfd\x3e\x1d\x91\x56\x4c\xe9\x88\x18\x34\xc8\x36\x6d\xd0\x52\xab\x24\xaa\x40\x48\x95\x8e\xa8\x1a\x21\xbc\x04\x9c\x30\xa0\x35\x85\x98\x7a\x0d\x91\x3e\x44\xdf\xe9\xd8\xc0\xcd\xea\x0a\x22\x51\x8a\x51\xb1\x0e\xcf\x88\xb8\xf0\x9e\xc2\xad\xe3\xfe\x1d\x6b\x94\xd8\x90\x7b\x30\x32\xb1\xbe\x94\x5a\xc4\xd0\x8b\x88\x1a\x95\x86\xa9\x4e\xe5\xa0\x46\xd5\xa8\x67\xd0\x31\xca\x38\x10\x2d\x73\xd7\x23\x6d\xa3\x8e\x92\x27\x51\x9f\x1c\xcc\xbb\x56\xc9\x24\x87\x43\x54\x2c\xe7\xec\x86\xce\xb3\x4b\x71\x11\x51\xc2\xf3\xea\x4e\xc9\x19\xe5\x8a\xf2\x0b\xb6\x24\x1f\xff\x11\xcd\x9b\x88\x10\xd2\xa6\x83\x82\xe1\x10\xe5\x78\x9e\x9d\xc3\x35\x26\x1a\x2f\xf3\x9c\xca\xa7\x52\x38\xcd\x20\x99\x77\x93\x14\xd0\x73\x4f\x6f\x8b\x55\x34\x7e\x02\x99\xad\x35\x7f\xc6\xc8\xd0\x23\xa7\xfe\xd6\x94\xf6\xde\x5a\x87\x15\xd7\x3a\xde\x53\xab\xe0\x71\x1e\x2a\x2b\xad\x2b\x07\x41\x56\x74\x07\xd3\x2f\x49\xcc\xfb\x0b\xd6\x5b\xda\xd6\x98\xdf\x32\xe9\xa6\x16\xd0\xfb\x1e\xb3\x57\xb5\x4d\x30\xf8\xb5\x68\xaf\x1f\x78\xb3\x9f\x65\x59\x52\x95\x47\x85\x90\x8a\xac\x93\x9a\x3c\xfd\x72\xb3\xb2\xd9\xba\x4c\xc6\x85\xab\x72\xdf\xe1\xa8\xb2\xc7\x27\x2c\x73\x8d\x12\x84\x6b\xbf\x01\xa8\x93\x36\x1b\xc2\x70\x36\xdc\x0d\x3a\xec\xee\xb7\x13\x7e\x03\x3f\x69\xdf\x3a\xe1\x63\xfa\x5b\xbf\x8e\xed\x84\x4f\x02\x9f\xad\x07\x49\xcb\x4e\xb8\xb5\x49\x7f\xe6\x38\x4a\x3a\xe1\xd6\x36\xfd\xcd\x6e\x65\x3b\xe1\xd6\x0e\xfd\x5a\x32\x28\x68\x60\xc9\xc1\x1e\x5f\x9f\x05\x4f\x7e\x4b\xbb\xa8\x86\x6b\xe8\x9b\x59\x13\xe9\x95\xac\x62\x54\x64\x96\xb3\x6d\x8b\xf4\xdc\x15\x4d\x8c\xfc\x45\x6b\x2c\x8d\xcc\x9e\xb4\xa9\xeb\x16\x76\x47\x15\xc6\x46\xad\x1a\xd5\xae\xc4\xbd\xd3\x25\xd8\x4e\xbe\xc4\x2d\x4c\x98\xac\x61\x37\x5b\x32\x7d\x77\x6f\xc9\x74\x6f\xc9\xf4\xdf\x62\xc9\xa4\x16\xc2\x5d\x99\x33\x3d\x23\xd3\x37\xcb\xf9\x08\x58\xa1\xe4\xce\x23\x32\x4d\x21\x71\xf0\xab\xe4\xe4\xcb\x92\x24\xa6\x7d\xcd\x60\x08\x69\xec\x5f\x01\x36\xf6\x82\x8c\xb3\x74\x42\x1c\x63\x20\x71\x32\xd3\x76\x05\x38\xbb\xc0\xb6\x20\x06\xce\x78\x75\x81\x80\xdf\x23\x78\xb0\x41\xcf\x59\x94\x6f\x29\x2b\x59\x58\x0a\x74\x6e\x40\x39\xf3\x90\xe2\x98\x41\x92\x02\xa5\x78\x1a\x95\xe4\x1c\x07\x82\x13\xc1\xc5\x51\x79\x91\x75\x0b\x34\xce\xe6\x0b\x21\xad\x42\x29\x3a\xb7\xb2\xe4\x24\xc9\xa2\x92\xa4\x53\xb4\xc8\x48\x5a\x06\xec\x3a\x94\x92\x7d\x9c\x5d\xa4\xd6\x99\xce\x54\x93\xb8\xc7\xb7\x2b\x86\xe5\x2b\x89\xef\x6b\x31\x16\xba\x94\x52\x8c\x63\x38\x45\x8f\xd4\x1c\xc7\x7e\x63\x18\x40\xda\xb5\xb4\xf3\x31\xdb\x35\x18\x30\xd4\x2f\xb8\xb0\x6c\x77\xc0\xe6\xa2\x37\x1e\xbc\xf8\xf0\xf2\xe3\xb3\xa3\x9f\xde\x9c\xbc\x7e\xf6\xe2\xdd\xc7\x77\xc7\x27\x6f\x9e\x1f\xbd\xf9\xe9\xe3\xeb\xe3\xe7\x2f\xb4\x33\x9c\xd4\xc4\xc1\x4c\x0e\x16\x51\xfc\x0a\x4f\xca\x1e\xfb\x2a\xb3\x0f\x17\x59\x71\x28\xb1\xc8\xdb\x1c\x94\x19\x17\x97\xb6\x1e\xf7\x03\xf4\x78\xd7\xbc\xe1\xd1\x77\x4b\x18\x4e\x8f\x35\x62\x1a\x60\x98\x13\x2f\x0e\xbf\x15\x38\x7f\x26\xcf\xc6\xe6\xa1\x79\x55\x1c\xba\x52\x87\x81\x45\x0f\x42\xca\xec\x25\xfe\x2c\xc6\x5d\x2c\x47\x45\x99\xf7\xb6\x35\xfc\x25\xd6\xd5\x3e\x2b\x2e\xb4\xdc\x1b\xe8\xf1\x4e\x1f\x0d\x75\x14\xd9\xe8\x7e\x47\xa6\xb3\x92\x17\x0b\x50\x82\x1e\x7e\x65\x7c\xf2\x1d\xf8\x4e\xd1\x5a\x29\xd3\xdd\x1a\xbb\xe2\x78\x66\xa2\x55\x6a\xe7\x7e\xb7\x19\xb0\xd4\xa6\xac\xb1\xfe\x80\xad\xf9\x0d\xd4\x3c\x41\x4d\x9c\x8e\x49\xf2\xd5\x2b\xe2\xbd\xc8\xbf\xed\xdc\x49\xe3\xce\xf6\xb3\x36\xc9\xb3\xf9\x49\x39\x79\x72\x3f\x71\x9e\x89\xe3\xef\x8c\xaa\x18\x19\x7f\x85\x24\x26\x8d\x7e\xe3\x28\x5d\x9d\x91\xd9\x4f\x8e\xaa\xe7\xac\xbb\x79\xbb\xbf\x2e\xda\xe0\xd5\xa3\xa7\x08\x75\xb7\xba\x28\x44\xdd\xcd\xee\xed\x79\x54\x13\x26\xe9\x89\x95\x96\xfa\x99\xc2\x15\x88\x0a\xc6\xf3\x65\x52\x12\x26\x54\x8e\x2e\xd1\xf6\xbf\xe7\x54\x3c\x97\x36\x74\x11\xad\xb9\xc4\x53\x9c\xd7\x6c\x25\xef\x78\xad\x4d\xfb\xf7\xaa\x33\xc2\x6d\x99\x2b\x66\x84\xa3\xc9\xa2\x3e\x8a\x35\xd9\xa2\xdc\x5c\xc9\x1c\x17\x56\xd6\x76\x7f\xb0\xc8\x2e\x7a\x5b\xdb\x4f\xfa\x7d\x13\xa5\x87\x33\x3c\xfe\x84\xc8\xc4\xc0\xa9\x26\x16\x59\x88\x28\xc8\x34\xc5\xf1\x51\xf1\x46\x65\x3b\x8a\x68\x59\xc7\x0c\x7f\xe6\x3d\x36\x91\x21\x88\x16\x0e\x7d\xd0\x76\x69\x4a\x62\x19\x3d\xb2\x5c\x10\x2a\x86\x47\x49\xa1\xac\x96\xed\xd6\x1b\xf1\xe5\xc3\x90\x60\x37\x9b\x01\xda\xea\x07\x68\xeb\xb1\x26\x8f\x6c\xf7\x8d\xdc\x3e\xda\xdf\xdf\xa7\x24\xeb\xa5\xc2\x9c\xb2\x8f\x47\x51\x02\x9d\x42\x4c\x75\xa0\x2e\x3c\x98\xa8\xe9\x12\x11\x53\x24\xd8\x42\xa0\x41\x1e\x8e\x1d\x2c\xc5\x99\x12\x0c\x6b\xda\x95\xc2\x21\x2c\x0b\x32\x45\x4c\x4e\xb7\xe8\x4d\x76\xc1\xc0\x9f\x61\x14\x4b\x81\xd9\x3c\xee\xb3\xde\x68\xba\xcc\x5e\x1f\x5d\x5d\xa1\xce\x66\x87\xeb\x88\x87\x43\x34\x96\x54\x44\x85\x67\x31\x91\xb2\x75\x06\x44\x4a\x36\xd1\x52\xd2\x76\x85\x6c\x71\x7f\x6b\xcd\x33\x9f\x5b\x8f\x0a\xd2\x33\xbf\x6c\x4a\xe7\x24\x5d\xda\xab\xa0\x3b\xb9\xe5\x5f\x17\xea\x16\x95\x6f\xc9\xeb\xb1\x16\x1d\xba\x01\x05\x2d\xeb\x49\xe8\xa4\x96\x86\x7c\xd4\x83\x57\x22\x1f\xde\xbc\x4b\x38\x27\x77\x41\x39\x5f\x07\x65\x9c\xe5\x57\xa1\xcc\xe1\xdd\x8d\x28\x03\x8c\x69\x22\xb1\x89\x22\xde\x9c\x8b\x22\x87\x99\xfb\x2c\xce\xad\xc5\xc8\x61\x06\x31\x39\x27\x31\x8e\x9f\x5d\xd6\xf0\xf0\x9b\x50\x53\x03\x6e\x4e\xee\x1a\x39\xcb\x4a\xec\x9c\xac\x8c\x9e\x93\xdb\xe0\xc7\xbd\x85\x65\x55\x4b\x14\x55\x49\x5c\xea\xc1\x74\x6b\xbc\x88\x9d\xcd\x9c\x8b\x4a\x1c\xf1\xa6\x5d\x14\x39\xf2\x99\x0f\x43\x9e\xe5\x05\xfb\xd5\x2d\x05\xb6\xad\x2e\x7a\xca\xb6\x66\xee\x19\x63\x35\x6c\x56\x9e\x1c\xb5\x77\xb9\x35\x7b\x5f\x82\x27\x0a\x71\x54\x82\xa8\x39\xdb\x38\xa2\x47\x1a\xcd\x31\x7b\xe0\x43\x7f\x59\x22\x18\x87\xa1\x75\xca\x1a\x3c\x98\x77\x0e\xa1\xd0\x46\x80\x74\x65\x39\x2d\xc4\x9f\x58\xa3\x7d\x54\xf5\x52\xf7\x61\x7f\xa8\x1d\x69\x0a\xf2\x1f\xce\x13\x0b\xb8\xa5\xe2\xe5\x4f\xb7\xce\x4c\x51\xb8\xbb\xf9\x99\x8a\xcc\xee\xe4\x0e\x8a\x84\x8c\x31\x95\x4c\xb6\xd1\x43\xa8\x6e\x45\x3a\x6f\x98\x19\xfd\x14\x7e\x67\x13\xb4\x2a\xfa\x2b\x55\x01\xce\x26\x23\x8f\x88\x16\x1f\x60\x88\xe3\x97\x60\x36\xe6\x1e\xef\xf6\xf9\x1e\x5e\x66\x1c\xbe\x8f\x1e\x8a\x53\xa5\x6f\x06\xac\x8a\x98\x74\xf8\x78\x37\xe0\xed\xaf\x36\x05\x35\xa7\x72\x36\x7c\xcf\xb1\xfc\x4e\xb1\x1f\x15\x63\x42\xea\xf0\xef\x39\xce\xff\x86\x98\x17\x5a\x1d\xd0\x0e\xb4\xc3\xff\x6a\x13\xa0\xdc\xd3\x54\xcd\xc0\x81\x72\x60\x53\x31\x05\x95\xbc\xbd\x02\xe5\xb2\x42\x17\xdb\x3e\x07\x36\x2b\x48\x53\x06\xee\x3a\x9b\x9f\x3b\x68\x03\xf1\x33\x0e\xa0\x9d\xfd\x96\x66\x05\xbb\x9b\x01\xd2\x93\xaa\x7c\x06\x7c\x11\xa6\x1f\xda\x59\x33\xb4\xbe\x03\x1b\x06\x56\x6c\xe8\xa4\x38\x70\xfa\x02\x0f\xab\x32\x9c\x52\x0c\x99\xa1\x9b\xe4\xf6\x23\xcb\x92\xd0\x4e\x70\xa0\xa8\x04\x12\xda\x09\x3a\x94\x14\xcb\x42\x3b\xc1\x85\x3a\x71\xc0\x4e\xbc\x70\x7a\xa3\x2a\xc5\x53\x9f\x0b\x78\xe2\x87\xd4\x07\xab\x52\x3c\x70\x3a\xb6\xb5\x24\x17\xd2\x37\x3d\x6e\x8e\x5b\xce\x9c\x20\x3d\xcd\x85\xe5\x54\x1f\x7a\xd7\xdd\xb5\xb8\xd6\x35\x2f\x87\x3a\xe1\xd6\x93\xa0\x63\x5e\x2a\x75\xc2\x6d\xb0\x60\x80\x85\xd1\x09\xb7\xb6\x82\x8e\x7e\x35\xd5\x09\xcd\xcf\xeb\xb3\x60\x6b\xf3\x77\x76\xe9\x72\xc4\x6c\xe3\x6b\x7c\x10\x91\xb4\xac\x72\x41\xc4\x6f\xaf\x48\x5a\x32\xef\x2c\xf4\xc7\xae\xfc\x75\xa6\x12\x77\xb4\xdf\x96\xf3\x16\x92\x96\xcc\x75\x0b\x49\xcb\xc7\xbb\x12\xec\x89\xaa\x68\xfb\x9b\xc7\x15\x75\x51\xf8\x06\x57\x46\xf6\xd1\xf0\x2b\x7a\xe3\x02\x70\xdb\x0c\xe1\x28\x2d\x57\xb4\xbc\x30\x4a\xd4\x18\x5c\x40\x73\x35\x25\x6f\x64\x5e\x41\xd2\x52\x88\x8a\x4f\x6f\xe4\xd2\x85\xf5\xaa\xd9\x0c\x62\xab\x55\x14\xbb\x7b\x3b\x88\x7b\x3b\x88\x3f\xaf\x1d\x04\x52\x86\x10\x4c\x54\xba\x23\x1b\x88\x16\xa6\x0d\x36\xab\x67\xa6\x0b\x19\x18\xa4\x2b\xcf\x1d\x03\x8f\x84\x7a\x31\xc3\xa9\x7c\xaf\x18\x30\xdb\x6f\x2a\x80\x4b\x07\x0e\x42\xb2\x1c\x7a\x6d\x23\x2c\xf5\xb7\xfd\x3c\x11\x38\xa9\x90\x1f\xd9\xff\x57\x57\xa8\xdb\xd5\xf8\x6c\x26\x5e\x2e\xb0\x1f\x7b\xda\x53\x43\x92\xf2\xd6\x5b\x7b\xfc\x98\xe2\x52\x37\xf9\x05\x03\xf2\x6e\x21\x1e\x82\x02\x2f\xa1\x95\x18\xd6\xee\x4a\xbe\x67\xc6\xae\xa6\x14\x2d\xd4\x4c\xaa\x56\xbd\x32\xd4\x13\x7d\xec\x1b\x06\xed\x80\x1e\xdd\xa0\xdd\x6e\xa4\xd6\x14\x0d\xac\xfc\x8d\x63\x87\x7e\xfd\xd8\x1a\x19\xe3\x1c\x53\x62\x12\xeb\xc1\x74\xcb\xc2\xc8\x3d\x26\x93\x09\x06\x83\x64\x86\x72\xeb\x5c\x72\x21\xdf\x85\xe8\xc7\x11\x81\x12\x3e\x4b\xc2\x76\x39\xf5\x1e\x42\xcc\xa3\x0b\xdd\x0e\x7d\xfd\x88\x16\x8c\xc3\xc8\x5e\x54\xa3\xf2\xc2\xff\x66\xd6\xa4\xbb\xca\x5b\x3d\x45\x90\x92\x54\x57\xc1\x68\x36\x1f\x91\xd4\xf5\x70\x53\x66\x53\x4c\xb9\x3b\xad\x01\x4f\x07\x6c\x51\x45\x8b\x05\x4e\x61\x2d\x45\x29\x7b\x03\x61\x61\x97\xd7\xd6\x74\x0f\xc3\x19\xd3\x8c\x8c\x29\x7b\x12\xbd\x6a\x2e\xcc\x2f\x50\xb3\x09\x87\x85\x7d\xa8\x16\xb5\x62\x78\x4d\x7a\xbf\x3a\xb4\x4a\xbd\x05\xbb\x32\xd9\x43\xcd\xd8\x1d\x47\x49\xc2\xf1\x2b\xae\x71\xd8\x88\x66\x91\x5a\xba\x05\xf9\x0f\x77\x2e\x08\xd7\x75\xb3\xa8\x08\xe8\xff\x82\xd0\xc0\xfd\xaf\xe7\xde\x4e\xc7\xb7\xb4\x05\xf5\xeb\x4c\x6b\x51\xe3\xf7\xce\xe4\x5b\xb8\x7c\x55\xac\xef\xef\x83\x74\x31\x21\xa9\xf5\x56\xa9\x09\x09\xca\x6b\x11\xaf\x8a\xdf\x30\xdb\x4a\x03\x96\x7b\x50\x3c\xab\x3e\xfa\x33\x8d\xaf\xab\xa1\x69\xb1\xcc\x8c\xda\xeb\x06\xbd\x0e\xa3\x56\x2e\x00\xfa\xe8\x29\xea\x76\x51\xd8\xce\x20\x4b\x43\x99\xd7\x2c\x6b\x05\xbc\x51\xde\xcf\x94\x13\x52\x66\xf4\x3d\xf7\x52\xfa\x0b\x3f\xce\xc4\xde\x23\x6e\x85\x23\x9d\xe1\x47\x73\x9d\xc8\x80\xc4\x6b\xb1\xa8\x1a\xf3\xa2\x10\xfc\x2a\xd9\xf8\xf3\xf9\x67\x92\xcb\x6b\x0f\xb1\x2b\x3f\x54\x41\x77\x7c\xc2\x7a\xab\xa3\xce\xd8\xd6\x2a\x70\xa7\x6d\x4a\x7e\xe4\x89\x84\x48\x5c\xc2\xb7\xc0\x22\x9e\x2f\xca\x4b\x5d\x25\xd8\x62\x13\x6d\x5c\x85\x26\x3d\x6a\xec\x29\x04\xe9\x63\x05\xdc\x08\x8f\x53\x95\xbe\xa6\xbc\x98\xa8\x1d\x08\xaf\xb2\x69\x0c\xc6\xc5\xca\x86\x47\x2c\xb8\xc9\x38\xd4\x63\xbc\x6a\xff\x50\xaf\x48\x51\x3a\x2f\xff\x4e\x8d\xd1\x9c\x79\x9c\x42\xd5\x8e\x5e\xd5\xec\x6e\x2f\xf2\x5d\x90\xb8\xa9\x5f\x2e\x62\x66\xd9\xca\xdf\xc1\x49\x55\x64\x99\x95\xda\x5b\x57\x56\x58\x08\x47\xcc\xef\x10\x32\xde\xf6\xc9\x27\x84\x1c\xd4\x7c\x56\x64\xec\x6d\x72\x3d\xb2\xed\xab\x62\x41\xda\xb7\x5f\xb6\xb3\x10\xb3\x79\xb4\xaf\xf7\x58\xc1\xea\xc3\xd8\xd8\x77\x15\xfd\xfc\xb5\x96\xfb\x42\x8b\x41\x2a\x11\xa8\x97\xe9\xaf\x6e\xe5\xab\xb9\xe1\x50\x4c\x37\x3e\xc7\xf9\x65\x39\x03\x5f\x24\x5a\x3d\x3a\x76\x5c\xc7\x53\xc2\x22\xcd\xc1\x8f\xf1\x52\xd7\x7f\x43\x21\x7d\x2f\xdd\x69\x13\xae\xd2\xf9\x3a\x40\xdd\xae\x50\xbe\xd7\x28\x29\xde\xb2\x59\xb2\x74\x7a\x52\x7d\x77\x7d\x16\x6c\xb5\x8a\xb5\xf7\x15\x75\x72\x70\x1b\x5d\xaf\x94\xcb\x29\x48\x85\x56\x4e\x98\x99\xd1\xff\x99\xaa\x0c\x7e\xed\xaa\x9f\x67\x5a\xf2\x8e\xfe\x61\xe9\xe6\x68\x1a\x53\xce\xd1\x5f\x42\x3b\x47\x7f\x3f\xd1\xaa\xd3\xf4\x73\x4e\x8d\x2d\x34\x74\xce\xdd\xfb\x2a\x2a\x3a\x5a\x78\x15\x1d\x1d\x83\xb7\x95\x74\x34\x75\x45\x2d\x9d\x59\xa4\x46\x4d\xc7\x5a\xac\x2b\x7b\x13\x45\x1d\xc5\x6d\x85\xa2\xae\x9d\xa3\x7c\xde\xad\x16\x8a\xba\x56\xd1\xbc\xbe\xd6\xe3\x3a\xcf\xed\xdf\x2a\xe4\xc1\x8a\xaf\x42\x20\xa2\x84\x4d\x22\x2c\x7d\x45\x22\xb1\x0b\xd5\x90\x89\x68\xb7\xbe\xfc\x8d\x74\xba\x4c\x92\x6a\xf3\x66\xce\xd3\xde\xdd\xbe\x96\x93\xa3\x6c\x41\x77\x77\x1f\x7d\xa4\xf6\xfd\x8e\x87\x0f\x6b\x2e\x6e\x49\xd1\xde\xb7\xed\x18\xe7\x65\x44\x52\xbf\x7f\x5b\x07\x91\xec\x36\xa9\x81\xa8\x19\xd0\xc0\x4c\xaf\x27\x6b\x5e\xc4\xca\x68\xf4\x06\x51\xe2\x7c\x4e\x8f\xfc\x64\x02\x35\x9b\xfd\x8e\xb9\xd7\x5a\x34\x25\xe7\x38\x15\x26\x2d\xe6\x91\xba\xca\x5d\xae\x65\xff\xc2\x8e\xd9\xca\xe2\x16\xb0\xcc\x2a\x77\xda\xf5\xdb\xdf\xea\x10\xed\x97\x08\x73\x4e\xdb\x29\xbd\xc2\x71\x76\x8e\xf3\xfc\x22\x27\x65\x89\xc1\xdc\x8b\xf5\xaa\x83\x36\xa0\xf7\xad\x71\x77\x01\x5a\xf6\x42\x7f\xc8\x0f\x56\x10\xea\x28\x4a\x52\x8e\xc2\xd2\xf5\x3b\x6c\xbf\xb5\x6f\x85\x4c\x57\x2b\x69\x35\xa7\xb4\xb6\x15\x78\xf3\xb8\x10\xf0\x63\x70\x38\x04\x55\x78\x34\xa7\xab\x02\xbc\x1e\x72\x6d\x16\x1d\x2f\xe5\x04\x98\xdd\x31\x24\xe4\x13\x46\x11\x2a\x48\x3a\x4d\xb0\xf4\xc3\x05\x90\x03\xc3\x24\x1a\x28\x98\xb9\x99\x61\x6e\x39\x58\x6b\x57\x57\xe8\xb4\x7b\xba\x75\xd6\x3d\xeb\x4b\x61\xb0\xc1\x0d\x00\xef\x9e\x89\x77\xfa\xa5\xbb\x36\xac\x10\xdd\x99\x0d\x14\x43\x05\xd8\x2a\x6c\x05\xe8\x11\xd8\x63\x6f\x42\x5f\xb6\x74\x47\x34\xaa\x43\x8e\x20\x2b\x1c\x35\x04\xc2\xb5\x43\xd5\x69\x41\x38\x74\x78\x28\x00\x55\x03\xc3\x21\x8a\x92\x04\x8d\xa2\x82\x8c\x99\xff\x03\x78\x2c\xb0\xb3\xcd\x15\x38\x49\x46\x4f\xc6\xa2\x37\x01\xda\xd9\x6e\x32\x3a\x31\x17\x36\xe7\x68\xe2\x04\x2e\x74\x91\x08\x4f\x41\x80\x84\xa0\x50\xa7\x67\x1d\xb4\xff\x03\xac\x4f\x95\xb6\xcb\x12\x6b\x95\x69\x07\xa2\xb6\x55\x39\xc0\x0c\x57\xf6\xac\x66\xb5\xeb\xad\x56\xd2\xac\x72\xfb\x65\x38\x84\x71\x88\x6e\xcf\xda\x46\xb5\x22\x0f\x1e\x20\xfd\xfb\x54\xfb\xad\xb9\x80\x3b\x13\xbb\xae\x8c\x8c\x31\x9c\xde\x68\x6e\xf8\xf2\xad\x9b\x1a\x31\x0b\xe6\xdc\xf0\x09\x33\xa7\x46\xf3\xb8\x76\xcb\x99\xb1\xfa\x55\x33\x31\x5a\x9b\x5f\x7b\x5e\xee\x72\x62\x4c\xd7\x27\x8a\x91\x6a\x33\x01\x67\xa3\x0e\xd8\x22\x6c\x33\xa4\xb3\x43\x52\x87\x1b\x2b\x6c\xf1\xa9\xd8\xda\x95\x80\xdb\x67\xa7\x3b\x1c\x54\xa4\x31\x10\x09\xb1\x75\x66\x25\xa8\x6f\x77\x77\x00\xac\xde\x60\x7b\xd0\xc7\xc2\x87\xd8\xbc\x27\x68\x8d\xdd\xd1\x44\x92\x09\xea\x69\x59\x1a\x87\xb4\xf9\xf1\x0d\x27\x16\x18\xb6\xef\x35\xc4\x56\xcd\x94\xf3\x4d\x42\x9c\xaa\x7d\xf3\x0c\xf3\xe6\x9b\xea\x8e\x8c\xbf\xe7\x4c\x38\xff\xec\x18\xf3\x6e\x54\x74\x6a\x56\xae\x4f\xb7\xf2\xbe\xd6\x6a\x9e\x65\x06\x1b\x0a\xcf\xaf\x9c\x5f\xc3\x8b\x62\xe5\x6e\xcf\xbd\x15\x25\x51\x51\xa2\xd3\x33\x2a\x4c\xb0\x7a\x6f\x34\xed\xeb\xfe\x79\x97\x73\x00\x72\x16\x72\x7c\x2c\xc1\x81\x46\xbd\x84\x82\x4f\x49\x03\x6d\x88\xa4\xc6\x38\x56\x3b\xc2\x48\x0e\x6c\xdf\x34\xa1\xd1\x25\x8a\xf1\x24\x5a\x26\xa0\x08\x2d\x96\x54\x4e\x95\x1b\x73\x87\xbb\xa9\x09\x78\x98\x47\x7b\x16\x8d\x63\xd4\x0d\x18\xb0\xda\x11\x57\x14\x85\x5b\x9e\xde\x2a\x8d\xea\x85\xaf\x76\xa1\x23\xd6\x96\x48\x61\xaf\x11\xa0\x78\x4e\xca\xa7\x1d\x4a\xf1\x01\xea\xd0\x45\x40\xff\x3b\xeb\x9c\x29\x6a\xe7\x10\x5a\x1a\x14\x4a\x97\x89\xfd\xec\x41\x9b\xcd\x56\x68\xb3\x1d\xcc\x59\xfd\x6d\x58\x08\xae\x93\x2a\x67\x25\xb0\xbd\x81\x3b\xcb\x63\xb3\x5e\xc0\x0d\x2f\x1d\x8e\x31\x5e\xfa\x2f\xac\x7a\x8b\x88\x39\xb7\xea\xfd\xeb\x94\x9d\xc6\xff\x75\xd6\x6f\x16\x11\xb8\xf2\x56\x7a\x7b\xa8\xbe\x77\xb0\xc2\x58\x08\xe8\xf6\xac\x43\xbc\x3d\x75\xef\xb2\x2c\x9c\x79\x2e\x2d\xf8\x3d\xba\xbd\x31\x78\xfd\x51\x9b\xb7\x32\xdc\x15\xaa\x70\x82\x6a\xb3\x85\x06\x6f\xb0\xd2\xfe\x5b\x37\x26\xde\x43\x95\x7f\x7e\xc7\xa8\xae\x5f\x59\x9c\x4c\x74\x7f\xb2\x9c\x95\x39\x85\xe4\xcb\xe4\xd3\x33\x9f\x13\xf1\xc1\x62\x59\xcc\x7a\x8e\x67\x52\xf1\x52\x5b\xb8\x19\x75\x6b\xa6\x63\x71\x7d\xae\x9f\xfb\x1c\x80\xea\x2d\x69\x7e\x3c\x7b\xe7\x01\xd2\xfd\xcb\x5a\xee\x49\x6f\xe5\xd4\x97\x4f\xa0\xee\xcc\xf7\xd6\xf3\x07\x5d\x77\xa4\x0e\x8e\xf8\xdf\x7e\xfe\x7c\x1e\x59\x1b\x3c\xb1\x56\x4e\x04\x9d\x4d\x70\x95\x5a\x33\x1f\x2b\xcf\xc6\x9a\x73\x47\x68\xe9\x8e\x8c\x25\xa9\x79\xb4\x6d\xe3\x13\x94\xdd\x8f\x4e\xf2\x6c\xee\x35\x37\x60\x50\x3e\xde\x32\xb2\x1f\xec\x58\x06\x42\x86\x65\xd0\x0a\x0f\xa6\x04\x53\x63\x2d\xb7\x60\x51\x7c\x20\x3a\x8b\x32\xfc\x69\x36\xb0\xaa\xaf\xc2\xab\x60\x6f\xd2\x6f\x2c\x99\xa0\xcb\x9f\xf8\x40\xf7\x84\xa0\xc3\xd1\xf5\x10\x6d\x83\xf1\x43\x5f\x78\x74\xe6\xc8\xab\x5a\x44\xb5\x75\xea\xcd\x3b\x15\xfb\x56\x14\x14\x78\x5f\xb2\x3b\x76\xbd\xf4\x06\xda\x61\x4e\xef\xd9\x6e\x5b\x50\x90\x02\x45\x93\x12\xe7\x72\x91\xe8\xfd\xbd\xd1\x5a\xf5\x97\xf1\xf9\xee\x56\x9c\xa3\xc2\x67\x37\xaa\xc5\x1e\x0f\x1d\xf3\xa6\xaa\x7e\xdd\xaf\x47\xa5\x1b\x69\x3b\xe6\x4d\x2d\xa3\x69\xc9\x69\xd0\xc3\xfa\xbe\x51\xd8\x8d\xfd\x7a\x98\x56\x8c\xca\x74\x38\xab\x4d\xfb\x06\x22\x77\xcb\xb5\xfe\x10\x7b\x88\xfe\xd7\x92\xfa\x85\x41\x6a\xcb\xbf\x3f\x14\xf1\xdf\xd3\xbe\xf6\xf7\xbb\xd0\x3e\xf2\x92\xbe\x1e\xa0\xf1\xa6\xa4\x6f\x87\x11\x5b\x71\x53\x71\x88\xd5\xae\xbf\xdd\xce\x62\xf6\x62\x95\xfa\xf9\xfc\x79\xe9\x2d\x71\xe8\xcb\xbf\xfe\xaa\x97\xf0\x82\xdf\xfa\xb9\x46\xaa\x4d\xdd\xef\xa1\x2d\xb4\x61\xf6\xae\xcf\x7c\x32\xb1\x48\x62\x9e\xa9\x67\x1e\x88\xad\x4b\x37\xe3\xc1\x76\x8d\x3f\x7b\x03\xd7\x96\xc5\x97\xc1\xc5\xd6\x56\x1c\x9b\x3e\xe7\x72\x65\x6d\xf7\x4d\xb5\xaa\xf7\x22\xd1\xea\x7a\xe3\x05\x6f\xf5\xd5\xae\x7c\x13\x77\x7d\x16\x6c\xfd\xde\xa1\xf7\x4f\x9a\x9f\xbd\x2d\x6b\xde\xbd\x71\x4f\x24\xf0\x3f\xb3\x75\x59\xaa\xa7\x6f\x4b\xed\xed\xdb\x52\x7f\xb0\xb6\xf4\xbc\x7e\x5b\xca\xe7\x6f\x4b\xed\xfd\xdb\x52\x7b\x00\xb7\x34\x5f\xc0\x39\x35\xb6\xb0\xb0\x71\xfc\xa3\x7c\xc5\x47\x70\x27\xde\x57\x70\x27\xab\x3f\x83\x3b\x69\xfb\x0e\xee\xc4\x7d\x08\x77\x72\x07\x2f\xe1\x96\xb7\x7e\x0a\x77\xd2\xfa\x2d\xdc\xef\x1d\xd7\xff\xa4\x85\xc5\xd9\xb2\xce\xe4\x4c\xb8\x56\x61\x3f\x38\x71\x6a\x56\x67\x4b\xdd\xec\x6c\x69\x58\x89\x2d\x7d\x86\x67\x4b\x65\x79\xb6\xd4\x4d\xcf\x96\xba\xed\xd9\xd2\x32\x3e\xf3\xd4\xdb\x66\x71\xfc\xa6\xf6\x67\x27\x7e\x03\xb4\x93\x1b\x58\xa0\x9d\xb4\x36\x41\x3b\xf1\xd8\xa0\xd9\xa5\x6f\xb6\x46\x6a\xcc\xd0\xda\x2e\x92\xf6\x86\x68\xdf\xb6\x59\x25\xdd\x65\x81\x41\x31\x3b\x2e\xbb\x2c\x20\xdf\x34\x43\x38\x3d\x47\x71\x86\xc1\x5a\x01\x5e\x07\x46\x69\x0c\x3e\x6c\xd1\x3f\x5e\xbf\x7a\x59\x96\x8b\x77\xf8\xff\x2d\x71\x51\xae\x81\x60\x76\xb9\xc0\xd9\xc4\xca\x61\x7e\x6c\xe4\xfb\x8d\xae\xc0\x0b\x6f\x78\x60\x43\xa3\x2f\xd7\x7b\x6b\x46\xb0\xc8\x4a\x48\x33\x01\x24\xf5\x5f\x8b\x19\xdd\x7d\xc8\x34\xcd\x72\x1c\x26\x24\xc5\x6b\xd7\xcc\x62\x95\xe2\xa1\x95\xb7\xfb\xfb\x97\xb3\xf7\x2f\x67\xff\xc4\x2f\x67\xd9\xab\x59\x6e\xc3\x66\x3c\x9b\x65\x1b\x0e\xba\xd9\xeb\x59\xbe\xf7\x9d\x94\x24\x81\x3a\x99\x3e\x13\xd6\x0e\x7b\x9e\xe4\x80\x91\xf2\x52\xb2\x44\x55\x64\x9c\x44\x45\x81\x4e\xa1\xc8\x19\xef\x26\xcb\x50\x4c\x98\x55\xb5\x36\x84\x7b\x23\x58\xa5\x5c\xb9\x4a\x39\x08\xaa\x71\x66\xdd\xde\xcf\x39\x40\xd2\x9a\x4e\xde\x1c\x7d\x78\x4f\xcf\xd6\x30\x09\xdd\x0b\x4c\xba\x8c\x34\xbb\x9f\xb4\xdf\xaf\xb5\xdf\x3f\x69\xbf\x8b\xff\x44\xa3\x4c\x7c\x4c\x48\x9a\xe2\x4b\xf9\x85\xe7\x65\x06\x4f\x19\x45\xca\x82\x8c\xcd\x84\x34\x4a\xcd\x84\x39\x19\xe7\x76\x4a\x92\x10\xa7\x90\x01\x6f\x80\x8a\x0f\xa3\xc8\x34\x8f\xd2\x58\x0e\xc5\xc8\xfa\xc9\xf8\xfa\x60\x7c\xbd\x35\xbe\x5e\x18\x5f\xff\x67\x7c\xfd\xd3\xf8\x7a\x63\x7c\x3d\x37\xbe\x7e\x36\xbe\x4e\xd8\xd7\xda\x59\xb5\xeb\x1a\x3a\x47\x6f\x0f\x9e\xd3\x29\x0e\xd1\xce\x76\x20\x13\xdf\x1f\xfd\xf4\xe6\xe0\xc3\xc9\xbb\x17\x1f\x5f\xbd\x78\xf3\xd3\x87\x97\x21\xda\x55\x99\x30\xab\xa1\xfa\xa9\x72\x2a\x28\x27\x44\x5f\x90\x95\xa0\xfc\xa8\x43\xc6\xc7\xe7\xc7\xbf\xbc\x41\xd7\xaa\xa6\xb7\xc7\xaf\x5e\x51\xe8\x0f\x47\xaf\x5f\x1c\x9f\x7c\x08\xd1\xd6\xe6\xe6\xe6\x90\xf7\x90\xdf\x78\x3f\x4b\xb2\xf1\xa7\x10\x75\x29\xeb\x2c\xca\xae\x91\x77\x30\x86\x50\xc6\xa1\x7a\xdb\xc8\x1e\x60\xd0\xfd\xbc\xc9\xf7\xc9\x7d\x28\x8c\xfb\x8d\xec\xaf\xbe\x91\xad\x49\x17\x10\xc5\x2c\xda\xb9\x2b\x0f\x10\x87\xf9\xe5\xa2\xcc\xfe\xfe\x5e\xdf\x1c\xc6\x90\xf6\x48\x45\xc0\xa0\x0d\x7a\x01\x86\x34\xa7\xeb\x8d\xee\xe4\xba\x6f\x00\x8a\x2b\xf4\x07\xaa\x3c\x09\x3d\x78\x20\x72\x07\xc2\x5f\x04\x13\x93\x67\xf8\x73\xd7\x7e\x45\x67\x78\xfe\xfa\x01\x6d\xd3\xd2\xb6\xf7\xe3\x6d\xe1\x2e\xd2\x2c\x8e\xc4\x65\xb8\xbc\xe0\xb7\xfc\xb3\x23\xeb\xb5\x1d\x03\x15\x38\xa2\x9d\x1b\xbc\xc4\x9f\x07\xa0\xbd\xe4\x9e\x7b\x7d\x36\x46\x14\x2b\x62\xd8\xaa\x75\x76\xa2\x63\xea\xb7\x10\x6d\x7f\xf3\x98\x95\xd4\x1e\x27\x8b\x37\x67\x94\xe5\x49\x1c\x77\xc2\x6f\xbe\x0b\x3a\x26\xca\x3b\xe1\x93\xcd\xeb\xb3\x60\xbb\x95\xcf\xa7\x7b\xbe\x77\xcf\xf7\xfe\xbc\x7c\x4f\xb1\x3d\xf6\xce\xff\x0e\xf8\x9e\x25\xbb\xaf\x2e\xba\x7b\x24\x77\x51\xd0\x27\xb8\xaf\x14\x6d\xc8\xe6\xb5\x83\x21\x67\xf7\x2a\x1c\xd1\xe4\x89\x0e\x40\xbf\xa5\x08\xbf\x4c\x49\xf9\x3a\x5a\x48\x71\xb1\x2b\x24\xea\x90\xf1\xa0\xee\x66\x37\x40\xe2\x39\x34\x48\xf7\xa1\x62\x8d\xdd\x2d\x43\xd6\x0f\xb5\x8c\xcd\xcd\x4d\x91\xf7\xbf\x35\x79\xa3\x68\x34\x8a\xa6\x58\xb6\xa6\xe7\x69\x07\x80\xd0\xce\x9b\x7b\xea\xd4\xb2\x5f\xd7\x67\x27\xd9\x39\x4e\xa2\xb1\x68\xd6\xce\x56\xe7\x8c\xd0\x97\x3d\xf5\x57\xae\x41\xfc\xd4\x08\x51\xcc\xa2\x34\xcd\x52\x63\xdc\x26\x84\x3a\xdb\x84\x35\x10\x0d\xad\xc0\xe9\x2a\xf4\x40\xe8\xa8\x54\x67\xa6\xb0\x1e\xa8\xa9\x26\x7e\x7e\x0b\xbd\x40\x46\x65\xf2\x4c\x66\x8f\xcd\x03\xe8\x1f\xa2\x09\x68\x90\xac\x07\x4e\x03\xfd\x64\xc2\xfa\x40\xf5\xb9\x86\x93\x5f\x6d\xc5\x7a\x7f\x5b\xd5\xad\x57\xdf\xb6\x80\x56\xa6\x5c\xa1\x0c\x2d\xe6\x37\xb8\x52\xce\x18\x16\x51\xcc\xcd\x49\xc1\xdc\xf3\xf3\x02\x8f\xe9\x06\x26\x4d\xf4\x75\xc3\x2b\xee\x41\xc5\x67\x3d\xa5\xaa\x18\x61\x0a\x17\xf3\xa8\x5c\x96\x1d\xd6\x78\x16\xe5\xd1\xb8\xc4\x79\x21\xd4\xfc\x70\x37\xcf\x4b\x6b\x7b\x89\xb7\x0d\x32\x4d\x03\xcd\x1e\x1a\x6d\xae\xf9\x5d\x7f\x90\xe9\xac\x44\xc2\x2b\xad\xe5\xe1\x97\x8f\xc1\x90\x38\x19\x48\x00\xbd\x2b\x02\x68\xc7\xe3\x67\x88\x59\x89\x00\x0c\x04\xa6\x85\x17\xab\xf2\x96\x78\xab\x3f\xf8\x35\x23\x29\x04\x6c\x40\x4f\xa1\x0e\x14\xa2\xce\x66\xa7\x8f\x36\x38\x70\x85\xf1\xdb\x8d\xe7\x02\x82\xf6\xfc\xd9\x27\x03\x06\xb1\xe2\x6c\xf0\x1e\x6e\x30\xaf\xcb\x37\x9d\x97\x2a\x63\x44\xd3\x19\x0d\x6c\x9f\x60\x8a\x08\x01\x3d\x5c\x3f\xd3\xd6\xbc\x30\x8f\xcd\x35\xb3\x42\x52\x5a\x89\x1f\x59\xba\x4f\x6a\x8f\xb3\x24\xda\xb8\x32\x3d\x64\x5e\x48\x4e\xd8\xf6\x2e\xc5\xfa\x19\x8b\xf9\x3c\x1c\xa2\x1f\x49\x1a\x23\xf6\xc0\x8b\x77\x54\xc6\x6c\xa6\x52\x45\xa7\xa3\x6e\xf3\xc1\xfe\x25\x80\x30\x52\x33\xfc\x59\x98\x31\xcb\x73\x17\x4d\x63\x27\x1f\x7a\xea\xa8\x3e\x2f\xd1\x6a\xb6\xf5\xb7\x2f\x60\x60\xc3\xed\x6a\xf6\x10\xd9\xd8\xdf\xd6\xc1\x45\x3c\x64\xdd\xbe\x43\x35\xd5\x23\xb4\x1d\x1e\xfe\x42\xb6\x30\x41\x3d\x56\x64\x7f\x1f\x6d\xf6\x8d\x93\xda\x28\xc7\xd1\x27\x05\x4a\x47\xb9\xb1\x8f\xf8\xcb\x72\x3a\x83\x87\xb3\x28\x3f\xcc\x62\x0c\x35\x78\x0f\x62\x74\xb2\x85\x49\x4e\x51\xe6\xed\x28\x84\x4d\xda\x4a\x24\x72\x40\x8b\xfc\x76\x34\x02\xcd\xfd\xf7\x10\xc9\x4d\x66\xbe\x28\xab\x5e\xa8\x9b\x93\xed\xf1\x33\xdf\x5b\xe4\x78\x42\x3e\xb3\x40\x5a\x9b\x9f\xfb\x74\x16\x80\x6b\xf8\x5d\xdc\xf3\x88\x6f\xd5\xb3\xef\xb5\x5f\x86\x63\x68\x94\x00\x37\xaf\x0d\x28\xe0\x8b\xf4\x69\xf8\xdb\xe7\xae\xd7\x79\x37\x74\xaa\xa0\x14\xcf\x31\xcf\x66\x1f\x96\x03\x37\xdd\x66\xcb\x41\xcc\x08\x6d\x49\x51\xc7\x24\xcb\x6d\x33\xba\xa2\xcc\xab\xa2\xe2\x6b\x33\x4a\xa1\xc6\x7c\x6e\x0e\xca\x1e\xb9\xd9\x4a\x07\x0b\x45\x1e\x20\xdc\xf0\xdc\xa6\x40\x68\x7f\x37\xf6\x51\x2a\xf6\x85\xef\xd1\x36\x7a\x4a\x4f\x37\x68\x03\xd1\xfd\x20\xf5\xd1\x04\x77\x23\x3f\xc3\x9f\xef\x92\x34\xac\xb8\x03\x36\x6d\x34\xb0\x86\xdf\x8c\x38\x1c\x9e\xa1\x51\xc7\x6f\x43\x01\xbf\xdb\xb4\x5a\x5e\x4b\x27\xcb\x24\x91\x68\x18\xe2\x73\x9c\x96\xec\xb1\x00\xb0\xfc\x5f\x8b\x2c\x45\xd1\x88\xd8\x3c\x5e\xb8\x4e\xfc\x90\xfd\xb8\x4c\x12\xfb\x1d\xa5\x78\x50\x40\x4b\x3f\x62\xa5\xdd\x07\x51\xac\x61\xa7\x5d\xc5\xd8\xdd\x36\x0c\x41\x8a\x56\xae\xab\x4f\xe9\xf7\x00\xcc\x28\x48\x1a\xe3\xcf\xc7\x93\x5e\xb7\xd7\xed\x83\x7f\xc8\x47\x5b\x9e\x27\x91\x12\xde\xb1\x15\x2c\x2f\x17\x98\x37\x07\x40\x40\x45\xa6\x4f\xb3\x1e\xe9\x7f\x11\x61\x84\x07\x14\x7e\x0f\x5d\x73\x51\xcc\xb4\xfe\x93\xad\xa0\x0d\xd4\xed\xd1\x99\x93\xb5\x6f\xa0\x6e\xbf\xdb\x6a\xed\xc5\xa4\x58\x24\xd1\x25\x9b\x17\xf0\x33\x9a\x96\x54\xb6\x95\xd8\xb0\xdf\xad\x7d\x86\xec\xe7\xac\x58\xdd\x2b\x57\x5a\x9b\x39\xf9\xfe\xe5\x65\xf4\x80\x6e\x69\x16\xc5\xe0\xe9\x40\xc4\x5c\xbc\xec\x71\xd3\xba\x3e\x7a\xf4\x83\x4c\x94\xd3\xea\xf6\xad\xf6\xf1\xb3\xb4\xdb\x74\x66\xd6\x40\x33\x07\x63\x93\x8d\x9e\xda\xef\x5a\xf9\x9b\x30\xba\x66\x94\xc3\x91\xe1\x50\x0d\x34\x3b\xc7\x79\x92\x45\x31\x8e\xa5\x32\xd8\xb3\x26\xf4\x01\x7c\x50\x44\x52\xf5\xae\x71\x88\x3e\x1c\x3f\x3f\x0e\xd1\x3c\xfa\x04\xea\x61\x92\x9e\x2f\x93\x14\xe7\xd1\x28\xc1\x77\x39\x40\x75\x1a\xb0\x5f\xf0\x6e\xa1\x47\x48\xcb\xee\xf7\x07\x39\x5e\x24\xd1\x18\xf7\xba\xa8\x0b\x8e\xdd\xe8\x69\xa1\x63\x06\x8a\xcc\xd2\x73\x9c\x97\x85\x0a\xbb\x09\x72\x5f\x8c\xc7\x64\x1e\x25\x36\x93\x25\xa9\x9f\xd9\x97\xd9\x73\x56\xc0\xa5\xbc\xda\x10\x9a\xa6\x6b\x43\x26\xe0\xf1\x9a\x1a\x83\x40\x96\x99\x1b\x23\x53\x86\xa0\x69\x33\xc6\x46\xd9\x96\xf2\xc4\xbb\x1a\x97\x56\x57\x7d\x80\xd6\x54\x68\x4a\xdd\xf1\x79\xc2\x73\x73\x15\xaa\xb9\xa3\x18\x87\x7d\x06\x90\xe0\xa2\xf8\x30\x8b\xd2\xde\x26\x38\x92\x7d\xc4\x2c\xcf\xb9\x05\x3f\x27\xac\xad\x3e\x84\x70\xd5\x72\x0c\x2c\x1e\x2c\xc1\x55\x33\x47\x65\x94\x5e\x72\xe7\x3b\xdc\x25\x69\x5a\x8d\xd6\x01\xc7\xeb\x41\x1a\xb3\x2b\x00\x46\x43\x64\x72\x59\x70\x67\xea\x05\x1a\xe1\x49\x96\xe3\x81\x43\x57\x2f\xf9\xd1\xa1\x1e\xf7\x57\x7c\x0f\x6a\x20\xad\x97\xb0\xcf\x1b\xc8\x97\xeb\xf7\x21\x37\x17\x9b\x47\x9f\x59\xe8\xca\xcf\xa4\xbc\x0c\xd1\x13\x50\x63\x8b\x5d\x87\x14\xdc\xad\x31\x14\xed\xdb\x9b\x8c\x36\xc9\xbd\x0d\x0a\xb1\x67\x14\xd5\xa7\xb3\xbe\xb0\x53\x96\x8d\xaf\xba\x20\x44\x56\xfa\xfb\xfb\xe3\x37\x03\x89\x5b\x06\xac\x5c\x57\x82\xd3\xd8\x02\x45\x76\x1c\xcf\x00\x2d\xa2\xa2\xa0\x1c\xab\x9c\xe5\xd9\x72\x3a\x33\xe9\x5e\x76\x81\x53\x18\xd4\xea\x5e\x4b\x2a\x5e\xf6\x08\xce\x48\x1e\x49\xb7\x72\x9c\x02\x80\xbf\xea\x30\xab\x6b\xa8\xed\x5c\x58\x8e\x6a\x15\xa0\xde\x3a\x29\x7e\x24\x29\x29\xb1\x85\x31\xab\x1b\x20\x17\x6a\x9d\x30\x65\x2b\xb7\xa3\xda\x6a\x78\xc7\xb7\x12\x46\xfd\xf4\x94\x94\x02\xcf\x47\xbf\x60\x5b\x7c\x9a\xe2\x12\x62\x15\x1f\x4f\x4e\x52\xe2\xd5\x71\x41\xd9\x72\x86\xf9\x0f\xb9\xcc\x50\x99\x05\x52\x27\x25\x5d\xa1\x7b\xe3\x35\xca\x7e\xc8\x6a\x7a\xac\x33\x7d\x28\x02\x0e\xbb\x0a\x84\xf3\x3c\xcb\x85\x33\x1a\xd6\xe3\x02\xa5\x59\x89\xc6\x59\x9e\xe3\x71\x19\x5e\xc8\xd5\x62\xf6\xda\x58\x36\xb4\xa0\x20\x81\x25\xcb\x84\xff\x9e\xc2\x7f\x83\x32\x7b\x95\x5d\xe0\xfc\x30\x2a\x70\x0f\x58\x0a\xd3\xf2\x2a\xee\x45\xa1\x7e\xe6\xf7\xcb\xfc\xd2\xe6\x94\xfe\x7f\xa6\x0e\xe0\x1a\x88\xee\xf1\x5b\x27\x3c\xe6\x83\x2c\xc5\x17\xe8\x05\x1d\x55\xaf\x0b\x97\xbc\xd0\x11\xb0\x52\xfd\x57\xb7\x44\xf8\x33\x29\xca\x22\x40\x8b\x04\x47\x05\x08\xc3\x30\xf2\x2c\x95\xa8\x9a\x64\x49\x92\x5d\x90\x74\x0a\x25\x0b\xca\xfb\xac\x65\xc4\x7b\x18\x80\x67\x85\x40\x3d\xf8\xa8\x89\x0f\x2b\x7b\x0f\x7e\xaf\x4c\x7f\xc2\xd1\x27\x0c\x8b\x90\xb1\x79\xb8\x86\x26\x60\x49\x2b\x59\x2b\x23\x01\xca\x60\xc1\x4b\x05\x9b\x78\x86\x5a\x4e\x59\x6f\xb3\xa2\x20\xa3\x84\x4d\x21\x38\xcf\xe0\xe6\x7c\xef\x8f\xa8\x54\x99\x97\xec\x27\x15\xa4\x05\xb6\x5e\x4c\x26\x64\x7a\xc9\x3f\x8e\x05\x29\x3d\x42\x9f\x68\xf3\xec\x4f\x5d\x52\xc1\x27\xbf\xcf\x62\x60\x73\x05\x26\xaf\x94\xd8\xa7\xb8\x80\x62\x70\x53\x05\x27\x6f\x7d\xd8\x27\xbf\x26\x52\x79\xac\xc0\xa3\x47\x72\x61\xaa\xdb\x1b\x56\xe0\x3f\xd1\x28\x33\xf2\x3c\x25\xc4\xed\x0b\x1b\x00\x5c\xda\xe8\x79\xac\x84\xd6\x0b\xad\x30\xfb\xe4\x58\xd0\x40\x90\x05\xa1\x7d\xc0\x15\x0a\x47\x08\x56\x38\x9c\x6a\xbf\x4b\xf1\xdb\x16\x24\x18\x5f\xb0\xce\xbb\x57\x52\x3a\x67\xe4\x30\x8e\x52\x7a\x1e\x88\x24\x6b\xe6\xe9\x5c\x43\x96\xe5\x28\x42\x2f\x5f\xfc\x03\x8e\xde\x42\x46\xbb\x33\x86\x22\x77\x57\x71\xa0\xfb\x65\x86\x85\x87\xbd\x48\xbb\xc4\xe5\xf1\x4f\xb4\x30\x01\x74\x3d\x45\x05\xba\xc0\x74\x81\x28\xd7\x2a\x62\x18\x6b\x9a\x0c\xf4\x0b\x36\x0e\xe2\x62\x9c\x3a\x4b\x61\x02\x0e\xad\x59\x30\x09\x5d\x14\x62\x25\xf4\x78\xb1\x26\xa7\x62\xdc\xc9\x92\x82\xf4\xcd\x97\x57\x80\x9e\x1a\x8d\x84\xfa\x97\x26\x4f\x35\x2e\xdf\x88\xe1\xd8\xb3\x82\x2f\x30\xb9\x5f\xb0\xff\x2d\x4b\xbc\xcc\xea\x16\xb8\x76\x4a\xf8\xcd\x96\x3a\x5d\x6d\xbf\xe3\x62\x07\x84\xdc\xcd\x52\x2f\xc9\x1c\x17\xbf\xc7\x32\x4f\xb9\x4a\x91\x2e\x6e\xa9\xa0\x2a\xd8\xe1\x1e\xb6\x68\x24\xad\x58\x1c\x72\x90\x3d\x69\x45\x14\x8a\x0c\xc4\x8d\x21\x9d\x7b\x45\x0b\x66\x6d\xd2\xbf\x95\xaa\x40\x01\x48\xfc\xeb\x66\x37\xd6\x2c\x34\x9c\x7a\xbe\xa1\x42\x20\x2c\x7b\x51\x9e\xff\xb8\xba\x42\x9b\x7b\xde\x23\x0d\xaf\xd7\x39\x9c\xb0\x74\xe3\x2c\xc3\x71\x2e\x7a\xf2\xe0\x01\xe2\xbf\x7d\x42\x3f\x6d\xd2\xce\xd5\x4f\x18\x3e\xef\x67\x86\x2c\xc6\x0b\x4b\x4d\xc8\xe6\xe7\x6e\xd0\xed\xea\xd7\x2c\x96\x8f\x34\x5f\x69\x9d\x50\x2a\x65\xba\x54\x44\x8d\xf5\x90\x8a\xa4\x13\x06\x26\xe2\x77\xc8\xa3\x18\x37\x98\x04\xd8\xf2\x22\xeb\x16\x68\x2c\xa3\xb9\x38\xa4\x65\x06\x7b\x69\x43\x5f\x15\x54\xa3\x1d\x8d\xcd\x3a\x4d\x35\x97\x41\x32\x14\x7c\xa4\x51\x96\x6f\xc1\xc2\x63\xef\x9e\xe6\xaf\x4e\x16\xd0\x15\x11\x8d\x53\xd7\x99\xdc\xf2\xaf\x03\xb3\x3c\x58\x24\xcb\x42\x75\x81\x7f\x7b\x1d\x1b\x4a\x20\x53\x7f\x34\xc3\xe3\x4f\x85\x38\x36\x31\x1e\x29\x2e\x37\x0b\xfe\x4c\x2e\xb9\x04\x0f\xbe\xde\x38\xc4\x8c\xe4\xc7\xde\x18\xc4\x66\x34\x61\xad\x01\xba\xfe\x23\x05\xaf\xbb\xb4\x83\xb0\x4a\x7c\xe6\xac\xba\x8d\x89\xe3\x95\x5a\x7a\xb3\xe1\xbf\x37\x3f\x9f\x6e\x3e\xfa\x2e\x7a\x34\x39\xfb\xb2\xbb\x79\xfd\x3f\x43\x32\x28\x71\x51\x4a\xf0\x15\xc6\x5e\x33\xe4\xaf\x33\xd8\x16\xc3\x84\xf3\xff\xf0\xdf\xbd\xcd\xcf\xfd\xa7\xb5\xe3\xd4\xe9\x6f\x38\x54\x51\xb2\x58\x1c\x2c\xe8\x1d\xf3\x1d\xcc\xcd\x0d\xe7\xf0\x82\x97\xee\xc7\xda\xa8\x4d\xfa\xe5\x2e\x00\x91\xe9\xa4\xc2\xdb\x19\xb3\x2f\x94\xcd\x69\x60\x07\x8f\x7e\xf4\x82\x59\x5d\x86\xa0\x5d\xdd\x02\xdc\x1c\x17\x73\xfa\xef\x38\x5a\x14\x20\x3b\x24\x09\x12\xdf\x81\xee\x9b\xd1\xee\x31\x73\x39\xaf\x75\xd8\x68\xe0\x58\x6e\xef\x0c\x3b\x38\x1a\xcf\xd0\x38\x2a\x9c\x6a\x48\xc1\x08\x65\x39\xe7\x33\xa4\x51\x13\x5b\x65\xed\x69\x8a\xb5\x55\x2c\xe7\x73\x1c\x57\x92\x97\xd5\xdc\x1d\x93\x99\x55\x7b\x05\xb9\x21\x2d\xb6\xce\xa1\x07\x3f\x91\x2c\xcd\x7f\x39\xbb\x90\xd2\x89\x70\x88\x97\x51\x01\xae\x68\x66\xd1\x8e\x68\xc8\xd4\xa7\x08\x89\xc7\xe7\xee\x65\x77\x13\x6e\x27\x11\xed\x9a\x3e\x8b\xe0\xbb\xbb\x9c\xa1\x04\xc3\x6b\x6a\x2d\x00\xdf\x62\x81\x73\xda\x5d\x31\x17\x29\x04\x2f\x9c\x12\x16\xdf\x2e\x2a\xf0\x3c\x5a\xd0\x39\xd9\x32\xd4\x7d\x3d\x69\xbc\xa0\xf5\x1a\xbc\xb2\x6d\x3d\xee\xa3\x1f\xd0\xb7\x74\x4f\xe7\x59\xa7\xe4\x6c\x50\x66\x27\xb4\x21\xae\x10\x5a\xdf\xdf\xd7\x32\x81\xf2\xeb\x2b\xfc\x7e\xdf\x53\xa3\xae\x62\xb2\x6a\xac\x70\x15\xae\xad\x4d\xc5\xf7\x0d\xee\x0f\x6b\x01\x26\x95\x45\xbf\xe1\xe4\xfa\x9a\x9f\xf9\x04\x59\x56\xd0\x64\x99\xdd\x25\x4d\x0a\xe5\xb5\xdc\xa0\x5b\x92\xa4\x64\x81\xfc\x01\xb6\xa4\x41\xfb\xe5\x35\x6f\xa8\xdb\xe5\x04\xe5\x12\xab\x81\xe4\x1b\x91\xae\x06\x34\x76\xba\x4f\x2b\xaa\x21\x66\xd1\x0b\xed\xda\xdd\x21\x6c\xe0\x7f\x33\x65\xfb\x47\x49\xf5\x3b\x7a\x06\x9a\x30\x2f\xfa\xe2\x2a\x4e\xd1\xb9\x41\xc7\x4d\x64\x6c\x12\x92\x3d\x82\x8d\xfd\x4a\x1a\xd7\xa8\xcc\x66\xaa\x8d\x35\xd5\x52\xa8\x55\xd2\x94\x42\x95\xd4\x69\xb0\xd4\x32\xa3\xd2\x25\x89\xd1\xf6\x26\xf3\x1c\xf4\x88\x5f\x11\xb2\x36\xd9\x2b\x85\xcd\xcf\x88\x99\x77\xb8\xe6\x5d\x8d\xc4\xec\xbf\xef\xe7\x3e\x08\x74\x0e\x2e\x4d\xb8\xda\x6d\xe2\x96\x68\xe3\xdd\x04\x85\x6b\x5d\x81\x0f\x4d\x9e\x67\x3b\x6f\xdd\xa6\xeb\xa9\x88\x5f\x7f\xf9\xea\x33\x21\x44\x00\x46\xb8\x54\x92\x35\xaa\x37\x55\x01\xda\xdd\xf4\xdf\x18\x08\x77\xc4\xe2\x64\x5d\x28\x89\xb7\x39\xd4\xa6\xf7\x54\xe9\xbb\xfc\x32\xc2\x6f\xb2\x4d\xcd\x77\x1e\x44\x3d\xd6\x0d\x4b\x46\x14\x7d\x4b\x8b\x32\x4a\xc7\x94\x8f\xa8\xc2\x57\x57\x12\x69\xbc\x30\xbc\x61\x83\x5f\x86\xfb\x0c\x6f\x2a\xb3\x8e\x00\x6e\x24\xab\xec\xb6\x45\x94\x38\x1b\x37\x61\xe9\xbd\x63\x5e\xd4\x12\x45\x9e\x40\x49\x5e\xfc\x70\xe6\xca\x7b\x06\xa3\x61\x7d\xeb\xde\x1d\x7a\x58\x5f\x5a\xe3\x46\xf4\xb8\x19\x3b\x3f\x2a\x33\x92\x55\xf1\x23\x8a\xde\x08\x43\xa2\x44\xb7\xe5\x88\x68\x9f\xca\xe6\xe1\xb0\xae\xdf\x60\x30\xc7\xbc\x6f\x37\x18\x0a\xfb\xdd\x76\x20\x23\xd6\x76\x8b\xd5\xcd\x00\x6f\xb2\xb6\x59\xd2\x8d\x06\xc3\xbb\xd7\x76\x34\xe0\xd7\xaf\x79\x2c\x4e\x98\x8c\x96\x23\x71\x43\x5d\xb4\xe4\x50\x50\xb0\x76\x0c\xf6\x49\x83\x6d\x8b\x60\xf4\x96\x09\x22\x32\x07\xf1\xf7\xc2\x5c\x26\xca\xa4\xa0\x76\x0c\xb4\x98\xfd\x0c\x40\xfa\x43\xca\x2f\xdd\x6d\x67\x7d\x1d\x2e\x1d\xd9\xdb\x5a\x65\x9d\x7a\x8d\xc6\x10\xcb\xa9\x87\x3d\x5b\x95\x7e\xd6\x5c\x65\xd4\x11\x1f\xf7\x0b\x3a\x81\x78\x39\x47\xa3\x24\x1b\x7f\x42\x33\x1c\xc5\x38\xa7\x1f\xd9\xdc\x36\xc3\x20\xc5\x33\x9a\xec\x93\x01\x66\xf8\xb3\x74\x76\x0e\x65\xd1\x84\x24\xa5\xad\xa7\xf4\x10\x2c\xc0\x1a\x3e\x85\x69\x4a\xed\x21\xfe\x9b\xad\x6d\x75\x8a\x67\xe0\x0d\x78\xa9\x3e\x83\xb3\xba\xf4\xaa\x7c\x47\x70\x17\xca\x17\x46\x58\x3b\x42\xaf\xb9\x1d\xb9\xc1\xd4\x24\x19\x15\xdb\x16\x64\xec\x4e\xc4\x07\x9a\xdc\x34\x11\xa5\x04\xaa\x99\x01\xa8\xc9\x98\x01\x28\x56\x3b\x03\x8f\x77\xd5\x04\x30\xe8\x1b\x4f\x00\x54\xa5\xd7\xe4\xc3\xbf\x03\x74\x33\xf4\x57\xf8\x13\xe1\x32\x5c\x28\x7e\x04\x22\x15\xde\xf1\x84\xf2\x17\x4b\x07\x49\x2f\x64\xff\x89\x14\x6e\x1e\x12\xaa\x9f\x2c\x47\x33\x1d\x09\xf5\x0f\x51\xee\xa4\x9c\x3c\x09\xf9\xff\x22\x0d\x8c\x51\x42\xf1\x43\xd5\xc3\x60\xc5\x2f\x95\xce\xe1\xe5\x4f\x5e\x8f\x6b\x47\x1b\xfa\x12\x19\xb4\x6b\x9e\x19\x7a\xd2\x0c\x58\x61\x09\x19\xda\x09\x62\x1c\xbf\x60\x18\xc5\x2f\x58\x1b\x03\xa4\xf1\x1f\x02\x4e\x8a\x7f\xa1\xfe\x21\x72\x4d\x7d\x74\xe8\xa4\x48\xac\x31\xc9\x3b\x54\x3f\x59\x8e\x26\xee\x86\xfa\x87\xc8\x35\x8e\x16\xa1\x9d\x20\xa0\xb4\x7c\x2b\xc7\x3a\x8e\x87\x6e\x92\xe8\xa1\x03\xe9\x24\x89\x3a\x85\x74\x15\x6a\xbf\xf5\xfe\xa6\xd3\x50\xfe\x12\xe9\x6c\x57\x0d\xe5\x2f\x39\x7a\xb6\xe0\x43\xf5\x53\x8e\x89\xee\x93\xa1\xf8\x21\x52\xe9\x96\x15\xf2\xff\x65\x1d\x94\xe3\x85\xe2\x87\x48\x05\xbe\x11\x8a\x1f\x01\x2c\x30\xe6\x77\x8e\x3f\xd6\xee\x84\x5b\xdf\x05\xb5\x6e\x6b\x82\xce\xb2\x9c\x3c\xe9\x84\x4f\xbe\xb9\x3e\x0b\xb6\xb7\xda\x38\x72\x30\x97\xf0\x3e\x5b\xc0\x1d\xee\xbf\xa0\x13\xa2\xce\xe6\x60\xeb\xc9\x60\xb7\xb3\x76\x2d\x3c\xbc\x6d\xb7\x0a\x40\x7c\xef\x20\xe2\xde\x41\xc4\x5f\xc1\x41\x04\xaf\x65\xcd\x75\xf1\xf6\x77\x3c\x99\xe4\xf8\x12\xfd\x42\x92\xf1\x27\x8c\xbe\xff\x15\x4f\x26\xb6\x97\x88\x96\x8e\xe0\x00\x8c\x44\x29\x3a\xa6\x32\x77\x04\x50\x24\x4a\x5d\xb0\x1f\xa3\x11\x05\xfb\x39\x9b\xe2\xa4\x28\x71\x92\xe0\x1c\x7d\x3f\x81\x44\x17\xf8\xa7\xe8\x1c\xfd\x92\x65\x31\xfa\x7e\x5a\xe9\xbd\x62\x57\x79\xed\xe1\x2e\x1e\x5f\x47\x69\x34\x35\x5d\x4a\x0c\x86\x14\x0b\xc3\x9c\x01\xcc\x19\x80\x70\x1d\x71\x34\x82\xe3\x91\x0d\x4c\x46\x51\x2a\x40\x5e\x80\x65\xbe\x0d\xc1\x44\xaf\x62\x88\xcb\x99\x00\x7c\xfe\xac\x06\x2e\x1e\x49\x37\xb2\xb3\xba\xfa\x8a\x99\xac\xef\x0d\x38\x1c\xaf\x02\x4c\x71\x29\x00\xdf\xe2\xbc\x80\xd7\x51\xd5\xd0\x0b\x0e\x22\x3b\x71\x11\xe5\xf3\xba\x6e\xd0\x7c\x09\x8c\xcb\x12\x82\x31\xb9\xf0\x05\xcf\x12\xa0\x82\xab\x18\x90\x82\x5d\xd0\x33\x95\xf2\xd9\x41\x12\xab\x42\x2d\x5a\x7c\xb5\xeb\x0f\x06\x24\x9c\x2c\xf1\xb7\x18\x38\x8d\x3d\x7d\x63\x19\x02\xec\x19\x9c\x99\x5c\xa8\x11\x4d\x97\x98\xcc\xb3\x05\xce\xcb\x4b\x0f\xdc\x82\x67\x09\xd0\x97\x65\xb9\x78\x9b\x67\xe7\x24\xf6\x92\x1b\x5d\xa8\x0b\x9e\x2d\x89\x6d\x31\xae\x29\x41\x16\x63\xbb\x40\x3b\x47\x85\x6b\x6b\x52\x58\xff\x05\x8f\x76\x50\x4f\x54\x63\x3a\xdb\xcd\xed\x15\x92\xe2\x0b\x6b\xd9\xa8\x92\x9a\xdf\x5d\x1e\x41\x55\xeb\xb9\x80\xd2\x80\x30\x7b\xbe\x82\x2f\xe8\x72\x01\xff\xfb\x7a\x15\xf1\x88\x67\x3e\x7f\xe6\xe4\x15\x33\x51\xf2\xfd\xcc\x2d\x99\xc2\x1a\xa0\xb9\x6f\x70\xe9\xe4\x2e\x14\xe1\x53\x10\xb1\x0e\x1c\xb8\xd1\x7f\xfe\x23\xda\xa0\x74\xed\xf6\x41\x11\x38\x00\xf1\xcf\x9e\x0e\xa3\x28\x5b\x9d\x35\xa2\x05\x09\xe5\x66\xc8\xff\x67\x67\x0e\xbd\x93\x1c\x5b\x85\x51\x54\x27\x9f\xd0\xf8\x0a\x24\x8c\x46\x2f\xa1\xfe\xe1\x34\xf1\x51\xae\x01\xf6\xc3\x19\x20\x07\xe8\xa9\xf6\x39\x39\x13\x5c\x84\xda\xef\x1e\xb3\xd4\xb9\xee\xef\x51\x89\x69\x38\x04\xcf\xba\x05\x46\x6a\x0c\x19\xdb\x89\xc1\xd5\xcf\x1a\x25\x37\xcf\xf8\x9a\xc6\x56\x39\x2e\x2a\x34\x8a\x3a\x45\x98\x4c\xac\x53\x9e\x1e\x0a\xb8\x99\xc6\xf5\xc2\x2b\x93\xb6\xa7\x2f\x39\x66\x31\x20\x54\x2f\x3e\x61\xbc\x38\x2a\xde\x5f\xa6\x63\x92\x4e\x6b\xbb\x02\x65\x2d\xf8\x76\x14\xe8\xe9\x88\xce\x17\x9e\x29\xe3\x14\x0b\x4a\xbc\x6c\x61\x5e\xa2\xe0\xcb\x03\x23\x5e\xc1\x0a\x28\xf8\xf6\xc0\xf1\xa7\xd4\x02\x8c\x7e\x3a\x50\xfa\xab\x5a\x06\x28\x53\xbc\xb0\x46\x9d\x22\xc1\xd3\xb6\x7a\x22\x25\x9a\xe7\x29\xde\x5a\x6d\x68\x2d\xcd\x53\xb7\x8e\x4b\x51\x7b\x1d\x4e\x99\xfd\xa2\x80\xfc\x05\xfb\x47\xa6\x43\xf1\x6f\x07\x4e\xb7\x5b\x61\x90\x32\xc5\x03\xeb\xde\xf4\x8a\x32\x87\xf6\xf5\x9f\xd3\xe7\xaa\xb2\x4e\x8e\xa7\xdd\xa3\x67\x07\x6f\xb4\xc6\xe8\x27\xdd\x73\xec\x65\xca\x36\x6a\xfd\x29\x35\xbb\x93\x31\x5d\x1c\x9a\xb7\x65\x70\x29\x6c\x43\x56\xdd\x5e\xc6\x24\x07\xd5\xee\x38\x5a\xc0\x43\x08\xed\xfe\xd0\x83\xff\xa3\xc3\x83\xb7\xc6\x4a\xa5\xe5\x74\x63\x35\xc2\x04\x3f\xba\xd8\xa8\x0c\xc8\xf2\x8d\xd7\x96\x14\x62\xc0\x9b\x11\xeb\x10\x3c\xba\x48\x6e\x59\x17\xf6\xf3\x54\x72\x5a\xd8\x99\xb8\xf0\xd0\x33\xaf\x7c\x53\xd0\x98\x74\xc5\x0e\x92\x66\x31\xee\x06\x06\xc4\x14\x8c\x33\x42\xd4\xa5\x22\xc2\xc7\x71\x42\x70\x5a\xfe\xcc\xc0\xbb\xea\x4a\xb8\x1f\xdc\xa4\x35\x5c\x5e\x64\xf9\xa7\xaa\x06\x53\x5c\x7e\xe4\xa0\x16\x88\xe9\xb5\x3f\xb4\xd7\xe4\x2d\xbb\x85\xb9\x02\xba\xaa\x5f\xb8\x9c\x7d\x84\xb9\x1e\x67\xc9\xcf\xbf\x43\xff\x2e\x66\xa4\x58\x48\x07\xc5\x4e\xf7\x8a\xd9\xec\xd6\x68\x83\x9f\x67\x5e\xce\x4f\x8a\xc3\x2c\x4d\x99\xd3\x24\x6d\xb9\xf5\x0d\xda\xeb\x79\x37\xb7\x07\x0f\xbc\x9b\x9e\x5e\x65\xaf\xef\xdf\x6f\x98\x9b\x00\x21\x41\x57\xd2\x3c\xd8\x69\x42\xf8\x02\x2e\x7f\x78\xb5\xac\xb4\x6e\xe1\xd2\x53\x97\xe7\x99\x82\xc8\x38\x06\x74\xc2\xed\x4d\x9a\xa4\x1f\x20\x3a\xe1\xf6\x16\x4d\x53\xc2\x7b\x27\xdc\xde\x95\x29\x4c\xd0\xe9\x84\xdb\x4f\x64\x92\x2e\x8a\x77\xc2\x9d\x6d\x99\x41\x57\x78\x27\xdc\xd9\x51\x09\x4a\x04\xef\x84\x3b\xaa\x52\x75\x88\xeb\x84\x3b\xdf\x3a\xc9\xb8\x9c\x75\xc2\x9d\x27\x4e\x7a\x8a\xcb\x4e\xb8\xf3\x9d\x93\x2e\xc4\xd6\x4e\xb8\xbb\xe9\x64\x16\xb3\x59\x27\xdc\xdd\x72\xd3\xa9\xe4\xda\x09\x77\x55\xf7\xc5\x89\xa4\x13\xee\x7e\x23\x13\xcd\x63\x6e\x27\xdc\x7d\x2c\xb3\x84\x8c\xd1\x09\x77\xbf\xad\xd7\xc4\x5d\x9f\x05\xdb\x3b\xf7\x7a\xb2\x7b\x3d\xd9\x5f\x5b\x4f\xa6\x39\x90\x8e\x92\x04\x5c\x3c\xdc\xce\x9b\xaa\xa6\x8f\x72\x34\x17\x3e\xd5\x85\x08\xd6\xf2\xe2\x9c\x59\xd7\x6b\x2a\x01\xe8\x8d\x80\x53\xa1\x5b\x9a\x62\x14\xb9\x6a\x15\xaf\x5e\xe5\x47\xb8\x8d\xb5\x2a\x83\x34\x01\x71\xc1\x22\x10\x99\x20\x82\x17\xf1\x4c\xe9\x63\xf5\x20\x49\x8c\xa1\x98\x92\x91\x79\x12\x0a\xe0\x6a\x3d\x40\x96\x69\x57\x85\x8e\xc2\x4c\xd0\x4f\xb4\xbf\xb2\xdb\x74\xfa\x9f\x9e\xec\x18\x2c\xb2\x5d\xc8\xe9\x61\x7d\xb0\x6d\x4b\x6c\x15\x5e\xb9\xf7\xe5\xaf\xab\x2b\x88\x42\x83\x6c\xcf\x0b\x34\x11\x52\x4f\xbb\x54\x0c\x05\xef\xfe\xdd\x00\x75\xcb\x8c\xfd\x3c\x1b\x30\x34\x6b\x51\x07\x27\x9e\xdb\x4b\xde\xcc\xe9\xe4\x0c\xcc\x58\xa5\x85\x26\xbf\xd1\xec\x7b\x42\x57\x5b\xd5\xd0\xfe\xd0\xe2\xfb\x1a\xf1\x30\x27\x36\xd0\x11\x76\xbc\x51\xa1\xe8\x54\x83\xc2\xc8\x40\x3d\xa2\x02\x6f\x10\x0a\xaf\x06\x9e\xcd\x97\x56\xba\x7f\x88\x3a\x8c\x7b\x62\x07\xc7\x51\x19\x89\x11\xd0\xdf\x03\xfa\x0f\xda\xd7\x7e\x5f\x5d\x81\x59\xaa\x04\x80\xab\xdf\x42\x80\xf0\xaf\xab\x2b\x15\x03\x13\x94\x83\xb4\x69\x71\xa7\xad\x01\x9e\x6e\x9e\x0d\x0a\xca\x11\xa4\xa3\x73\x0a\x3d\xe7\x12\x8e\xa2\x30\x77\xba\x7e\xf5\x4c\x97\xde\xca\x3e\x37\x76\xe5\xe2\x9d\x7b\xc7\xda\xfb\x55\xbe\x15\xef\x9f\x6e\x9e\x69\x8f\xa0\xd6\xa1\xfd\x3e\xfa\x02\x0f\x0f\xa2\x34\xcd\x4a\x34\x21\x69\xcc\xfa\x45\xd2\x29\x6b\xe8\xa9\x6c\x7e\x9c\xa5\x45\x96\xe0\xc1\x45\x94\xa7\xbd\xae\x5e\x82\xf9\xab\xa1\xbc\x38\xc9\xa6\x5d\xcd\xf4\x94\xf7\x98\xa2\xc2\xf1\x79\x84\x39\x1b\xd2\xe3\x63\xc1\xdc\xf5\x7c\xab\x33\x60\xdd\x0a\x4c\x82\x30\xcf\x50\x50\xa3\x70\x37\x08\x53\xdc\x62\x39\x7e\xc6\x63\x2a\x02\x78\xd6\x63\x00\x3e\x91\x46\xd1\xf8\x93\x8c\xe4\x09\x6e\x01\xf8\xd9\x54\xdc\x8e\xf6\xa2\x7c\xba\x84\x77\x19\xa7\xf2\x97\xe6\x0f\xc7\xb4\x05\x17\x35\x42\x04\xe6\xda\x62\xba\xe7\xb6\x9e\x03\x41\x27\x7e\xcb\xf4\x29\xa1\xd8\x46\xba\x4c\x12\x07\xdd\x99\xa0\x34\xee\x7f\x4e\x9d\x80\x05\xc4\x44\x8b\x75\xc6\x14\xa9\x80\xc9\xc1\x88\x98\x3a\x3e\x4d\xfe\x66\x9c\xbd\x62\xc2\xb2\x40\xf0\x75\x7a\xcc\xea\xf5\x03\xd5\x82\x86\xda\xe6\x29\x8a\xca\x32\x1a\xcf\x3e\x64\x87\xc2\x07\x95\x3e\x57\xc2\x31\x95\x7e\xda\x56\x73\xca\x06\xcc\x3e\x9d\x71\x88\xa2\x83\x28\x49\xe4\x46\xc2\x81\x2b\x4e\x13\x4e\x37\xe5\xd1\xc2\x73\xb6\xf0\x1e\x2e\x80\x46\x3b\xe1\x36\xc8\xf5\x6c\xb9\x77\xc2\x6d\x90\xda\xf5\x90\x69\x3b\x00\x6c\xed\x80\x9d\x70\x77\x87\x0a\xcb\xbb\xf7\xc2\xf2\xbd\xb0\xfc\x5f\x23\x2c\xc3\xa9\xfb\xae\xc2\xad\xfc\xbd\xc8\xd2\x7c\x31\x36\x05\xcd\x5f\x59\xa2\xbc\xe2\xcb\xf3\xcc\x96\x7d\x59\x9a\x14\x41\x5d\xe5\x04\x1d\xac\x21\x5d\x3a\xc2\x25\xa0\xe3\x63\xa5\x88\xc9\x33\x0a\x1e\x57\xbb\xc1\x47\x5f\x14\xc7\xc2\x9d\x22\xe5\xc3\xbc\x30\x78\xa8\x86\xae\xf1\x04\xcb\x74\x2f\x8a\x63\x8f\x35\x2c\xe2\xe3\x67\x85\x4a\x65\x87\x3a\x5c\x83\x71\xea\xac\x38\x8e\x7d\xc2\xb6\x6f\xe0\x05\x0b\xca\x2d\x20\x1a\x47\x24\x98\x76\x5d\xff\x39\x8c\xb7\x6b\xbe\x8d\xdc\x7c\xe2\x2f\xf1\x6b\x74\xd3\x9d\x02\x75\x9f\x93\xc6\x4c\xc1\x24\x60\x03\xad\x6e\x9c\xe7\x01\x17\x41\x0b\x57\x18\x66\xe4\xc3\x7e\x71\x29\x51\x01\x70\xfc\xe8\xde\x1d\x25\x2a\x03\x04\x4f\xcc\x2b\xde\x8f\xf1\x2a\x4f\x01\xe6\x4c\x3f\x17\x54\x4a\xea\xac\x48\x45\xb5\x54\x9e\x11\xfd\xe1\x95\x0e\x1c\xa1\xc7\x2e\xb0\xce\x17\xd1\x80\x14\x3f\x47\x09\x89\xdf\xe1\x62\x91\xa5\x05\xe6\x4d\x39\x6f\xdf\x9c\x31\xf8\xdb\xeb\xb1\x35\x36\x38\x4a\xcf\xbd\xb5\xee\x39\x95\x5e\xbb\xfd\xab\xac\x9c\x39\x4e\x72\x06\xcb\xf6\x5c\x70\xd0\xe0\xcb\xe0\x8d\x0f\x78\x1f\xc0\x75\x83\x9e\xe0\x04\x91\x57\x53\x21\x0f\x36\xc8\x2f\x4a\x00\x65\x29\xcd\x24\x1b\x7c\x27\xdc\x06\x0d\x1a\x5f\x91\x9d\x70\x07\xac\xd3\x5a\x05\xd9\xbe\xdf\xf0\xef\x37\xfc\x3f\xef\x86\xaf\xf6\x7b\x29\x96\xdf\x91\x6e\xac\xa5\x92\x8a\x1e\x75\x72\x0b\xac\xe0\xb2\xfe\x10\x32\x57\xd5\xa3\x09\x38\xed\xc1\x92\xae\x00\x13\x2f\x91\x38\xf4\x81\x76\x08\xd1\xc0\xa4\xaa\xd0\x88\xf8\xed\xdb\x3f\x99\x5e\x49\x7f\xdd\x05\xdb\xbc\xfd\x44\x98\xc1\x1d\x2a\xb0\xb7\x02\x4a\xca\x05\x60\x94\x7b\x8d\x84\x1b\x65\x33\xd5\xdb\x00\x77\xb4\xeb\xaf\xda\x7c\x63\x39\x22\x01\x2f\x67\xdd\xe7\x44\x23\xe2\xd1\x7f\x68\x2e\x97\x91\xe5\xe3\x98\xc5\xd7\xde\xdf\x47\x5d\xad\x4f\x5d\xf4\xe0\x81\xe1\x43\x59\x3b\x30\xb3\x66\x0d\x47\xfb\xd7\x7d\x6b\x1b\xae\x6b\xd0\xe3\x95\x19\xf5\x20\xb1\x62\xbb\x86\x3c\xe6\xac\xd9\xb3\x33\x58\x15\x51\xb0\xc2\xd3\x34\xd0\x1e\x3f\xb5\x33\x84\x32\x50\x89\x46\x4d\xbd\x23\xd4\x56\x2d\xa4\x47\x19\x4f\x8b\xfb\x6b\x62\x47\x6b\xef\x1b\xa4\x28\x8e\x05\x0d\x17\xea\x18\xae\xd3\x86\x48\xbb\x96\x35\x55\xd2\x13\x23\x15\x7f\x95\xb5\x27\x7b\x75\x5c\xbf\x39\xa1\x68\xcf\xff\x56\x99\x7d\x5d\x45\x25\xd5\x3e\xb2\x3f\x1f\x71\x39\x13\x7a\x66\xd5\x49\xd3\xf5\x44\xa3\x0e\x75\xe2\xa8\x39\x14\x02\x94\x8e\xb4\xc5\xbc\x32\x6e\xd1\x6a\x52\x19\xbf\xb9\xbb\x19\xb5\xeb\x6b\x56\xd4\x08\x86\x77\x17\x73\xcb\x78\xaf\xa5\x4f\xe6\x9c\x95\xab\x19\x25\x8f\x35\x27\xcf\x55\x5d\xb1\x8e\x55\x4e\xe7\x41\x92\xd4\x4e\x17\x00\xf1\x1b\x9e\x95\x09\x8c\xe9\x40\x1b\x3a\xb8\x3a\xb5\x19\xcf\xf7\x5c\xa5\x5a\x15\xb5\xd5\x91\x9b\xf4\x56\x03\x36\x7a\x62\xd2\xa7\xb8\x2c\xb8\xd9\x4a\x72\x89\x62\xbc\x48\xb2\x4b\x1c\x0b\x53\x3e\x78\xe8\x37\x9e\x45\x24\xb5\xdf\x95\x41\x6d\x3f\x66\xb9\xe8\x91\xe7\xd1\xbf\x38\xb0\xfa\x48\x52\xac\xcb\x6b\xa9\x5a\x5c\x33\xfc\xd4\x9e\x88\x5b\x0d\xf5\xfe\xac\xa2\x45\xdd\xd4\x41\xb4\xa4\x29\x2c\x15\xf9\x42\xbc\x64\x08\xe2\xe2\xe8\x77\x7f\x84\x20\xe1\xfb\xe2\x01\x18\xe4\x0f\x87\xe8\x22\x22\x4c\x4f\x0e\x22\xd7\xa2\x54\xba\x57\x71\x45\x66\xce\x3b\x5f\x0a\x32\x5e\xb3\xea\x18\xee\x9b\xee\x8f\xd7\x31\xdd\xf8\xd6\x8d\xf6\xed\x5d\x09\xfa\xbb\xb1\xb1\x67\x1e\x9b\x86\x43\x54\x94\xd9\x82\xe9\x6a\x49\x3a\x45\xd1\x84\x76\xe5\x9b\x4d\x36\x57\x05\xea\x95\x64\x8e\xb3\x65\xd9\x77\x8e\x8e\x0c\x01\x3f\xa0\x6f\x36\xbd\x87\x45\xd6\xfb\x01\xad\xfd\x17\x5e\xb9\x0a\x67\xd0\x47\x5f\xae\x3d\x67\x3a\x1b\x81\xec\x65\x9d\xf7\x1c\x2a\x67\xc4\x7b\xda\x54\x27\x3f\xe5\x9d\x57\x32\x26\xb8\x28\x89\xd8\xca\x18\x53\xc2\x06\x4f\xbd\x23\x2a\x31\x2f\xd3\xd8\xc6\x40\xd7\x77\xf8\xc4\x89\xe6\x81\x48\xff\x73\x7c\x02\xdf\xb8\x55\xba\xfc\xf4\x9a\xa5\x23\x0f\x17\x6b\x06\xd5\x4c\x71\xf9\x41\x35\xf5\x8e\x91\x9a\xe2\x28\x5a\x37\x5e\x46\xc5\x4c\x27\xaa\x40\x10\x66\xdf\x7f\x84\x27\x93\x1e\x07\xf0\x53\x9b\xb7\x90\xb7\x83\x10\x3d\x88\xd7\x35\x18\x9b\x0b\xd0\xec\x11\x84\x18\xf2\x77\x47\xfc\x55\x39\x4e\x7f\x2c\x1d\xa7\x57\xfd\x91\x49\xcf\xa4\xb8\xab\x2b\xb4\x0e\x2d\xd6\x16\x43\x92\x75\x7b\x68\x53\xff\xbb\xc9\x12\xd0\xff\x5a\x2e\x07\x7b\x48\x59\xac\x45\x68\xde\xa9\x9d\x19\xf1\x37\x1c\xca\x0b\xbe\x24\x9b\x6a\x54\x0b\xc7\x0a\xc1\xc6\xd7\xbb\xfd\x86\xe6\x91\x21\xaa\x49\x8e\x5a\x31\xd5\x2d\x2a\x1b\x0e\x11\xdb\xac\x84\xb8\x10\xa5\x31\xe2\x37\x23\x28\x9a\x46\x24\xe5\x2b\xe7\x02\xf3\xe0\x7a\x0d\x7f\x7e\xd9\xd3\xde\x00\x1b\x6a\xb0\x65\x1d\x67\xfb\x6f\x18\xd2\x98\x79\x46\xe3\xb7\x81\x74\x4b\xa0\xbb\x63\x81\xc7\x59\x1a\x23\xca\x70\x1b\x2b\xd1\x48\xb7\x99\x58\x91\xc1\x11\x41\x17\xd6\xb6\xc3\x5e\xf7\x41\x77\xdc\x21\xdd\x81\xba\x26\x4a\xf0\x13\xad\xc6\x29\x8b\x32\xcb\x71\x2c\x9d\xa9\x33\x09\x04\x34\x3e\xd3\xa8\x40\xd1\x9c\x6e\x48\x03\x2f\xbf\xb6\xff\x2a\xf9\xb7\xfd\xe7\xf1\xf1\x7e\x17\x5d\xac\xef\xe1\x75\x65\x6e\x15\xc7\x70\x4b\xd8\x90\x9a\x76\xb2\xed\x81\x42\xbb\x62\x10\x84\xfe\x63\x44\x8f\xd9\x97\xd2\xeb\x85\x25\xc5\x59\x60\x0d\x87\x06\xbb\x52\xfd\xc0\x00\xa7\xaa\x68\x44\x8c\xcb\x05\xf6\xf2\x07\x8b\xe3\x3b\xa4\x45\x23\x82\xf6\x29\xa4\x90\xb3\x1e\x32\x4d\x68\xf3\x98\xd4\x09\x29\x45\x91\x26\x9a\xf2\xe2\xa2\x16\x31\xb6\x14\x5f\xc8\x24\x31\xa6\xf4\xf2\x5a\x27\x06\x4b\x37\xb2\x25\x8c\x09\xa2\xa4\xbf\x62\xd1\xed\x9a\xa2\xb6\x1c\x6c\x48\x16\xdc\x2b\x89\x50\x14\xc7\x4e\x69\x9f\xa4\xcc\x21\xa4\xb4\xac\x8e\x7f\x22\x49\xb6\xa5\x26\x1e\x0a\x0d\xd5\x44\x50\x94\xfa\xae\x5f\x50\xcd\x16\xfd\xad\xa8\x01\x09\x47\x86\x48\x4a\xd7\xf2\x14\xa9\xd3\x5f\x4f\xd0\x41\x20\x67\x5f\xe7\x60\xc3\x21\x0b\x6b\xa8\xcc\x2b\x8c\x4a\x95\x91\xc4\x97\xeb\x3d\x0a\x2c\xb0\xb4\x6e\xb6\xcd\x11\xa3\x55\x0c\x67\xdc\x1c\xde\xcc\x00\x21\xeb\xcf\x11\x12\x32\xc6\x70\xd5\xa0\x0c\x35\xac\xc8\x7b\x3e\xa3\x11\x30\xfc\xa8\x36\x15\x41\x8e\xb9\x48\x31\x58\x64\x0b\xc3\xb3\x9b\xd9\xbd\x24\x2a\x4a\x0e\xe9\x54\xed\xef\x0e\x0f\xe9\x42\x0b\x82\x13\xe4\x75\xf9\x32\x04\x62\xc0\x42\xba\xdd\x27\x85\xc2\x86\x2e\xd1\x86\x38\xf0\x80\x85\x06\xf9\x01\x6d\xda\xb5\xf1\x99\x16\xb4\x7f\x20\xd6\x72\xb3\x16\x40\xfc\xdd\x4a\x25\xa8\xa1\xc9\x62\x96\x42\x9d\x26\x6d\xec\xf4\x61\xad\x9b\x5d\x1e\x2c\xa2\xcb\x68\x94\x60\x5f\xf7\xdc\xe3\x00\x33\x9c\x2a\x70\x1a\xab\x60\x50\x69\x96\x3e\xe2\x95\xe8\xe8\xb0\xb7\x89\xeb\xaa\xa9\x07\xa7\x7a\x94\x33\xfa\x55\xb0\x3d\xb1\x54\x02\x18\xb1\x56\xab\x98\x20\x30\x7a\xdb\xd8\x67\x15\xed\x99\x93\x58\x79\x23\xa8\x9f\x68\x0d\x1d\x80\x90\xfb\xa2\x38\xb5\xb5\x04\x31\x46\x17\x51\x21\x05\xca\x35\x13\x57\x6c\x69\xc3\xd5\xab\x76\x84\x51\x16\x59\xd6\xfd\xeb\x2c\x2a\x66\x3e\xa4\xd3\x5e\xe3\x3c\xaf\xba\x89\xd4\xaf\x1c\x7d\xf7\x8a\x75\x12\x0f\x15\x47\xe3\x98\x5d\x7b\x69\x5c\x97\xf6\xc4\xdf\x56\xc5\xb1\x0b\xed\x43\x99\x0a\xe1\xab\x52\x42\x9c\x90\xbc\x28\xab\x05\xc4\x15\x65\xbc\x0a\x0d\x88\x4f\xed\xe1\xbb\x7e\x35\xbe\x9a\x3c\x4e\x42\x90\x4b\x36\xf0\xa6\x79\xb6\x1a\x6b\x8b\xf2\x46\x54\xaf\x32\x74\x3f\x4f\x93\x3a\x79\x06\xc4\x75\x65\x1c\xbb\x62\x13\xa4\xe7\xdb\xe7\xcc\xa0\x14\x92\xf8\xa7\x61\x80\x76\x63\xc1\xcb\xd6\x9a\x35\x69\x67\x3d\x9b\x3a\xaf\xe9\xda\x94\x81\x26\xb2\xfe\xe1\xda\x70\x68\xed\xc0\xc6\x05\x8e\x8a\x37\xa8\xa9\x2f\xad\xca\x7b\x6c\x5f\x1e\x0e\x0d\x37\xb6\x95\x21\x9f\xc7\x63\xf0\x48\x9b\xb1\x68\x49\x24\x9d\xd6\xc8\x66\xa6\x1a\xdb\x1c\x39\x9b\xc4\x6b\x97\x13\xe9\xe2\x50\x9d\x28\x84\xbe\x68\x52\x57\x5b\x89\x68\x82\xd2\x4c\xd5\x40\xd9\xdb\x22\x2a\x0a\x1c\x07\xb4\x0a\xe5\xa4\x8e\x42\x14\xda\x92\x36\x79\x99\x24\x3c\x98\x01\x0b\x9d\x86\x39\xa4\xcf\x69\xa9\x69\xac\x8a\x56\x96\xa1\x94\x89\xbc\xd2\x56\x96\x33\xcd\xa7\x23\x44\x8c\x81\x38\x5d\xc2\xa8\x40\x76\x29\x10\x05\x46\x78\x1c\x2d\x0b\x4c\x4f\xe2\x71\x96\x96\xe8\x22\x4a\xc1\x26\xa9\x58\x64\x24\x61\xb7\xe1\x69\x89\xf3\x49\x34\x96\xce\xa9\x5b\x9c\xc4\xdb\x9c\xb6\xed\x6d\xaa\x99\x1f\x22\xc7\xaf\xad\x5c\xd3\xda\xda\xfc\x09\x97\xcc\x51\x32\xdd\x1f\x03\x74\x31\x23\xe3\x19\x18\x0d\xd0\xe5\x5d\x66\x7c\x1b\x43\x8b\x64\x59\x34\x5f\xbd\x72\x3e\xd0\x30\xbf\x8a\x79\xf8\x0d\x99\x1a\x44\xd8\xd5\xe5\x54\x59\xac\x59\x7e\xbc\x8d\xec\x58\x2d\x37\x6a\x56\xca\x37\x92\x63\xea\x64\x18\xf3\x89\xc3\x80\x59\xa2\xb7\x67\xbe\x9e\x53\x8f\xf7\xb8\xdb\xe2\xfa\xbc\x8a\x35\x39\x87\x61\xef\x29\xb8\xe2\x09\x8b\xef\x3c\xec\xee\x7e\xca\x20\x9c\xe1\xcf\x7d\xb5\x82\x3c\x87\x69\xaf\xd9\x92\x45\xb7\x7b\xd2\xfc\xd9\xb4\x95\xe8\x84\xdf\x56\x59\x40\x4b\x8b\x86\x4e\xb8\xbd\xe3\x9a\x44\xf3\x91\x77\xc2\x9d\xad\xeb\xb3\x60\xfb\xf1\xbd\xe9\xd3\xbd\xe9\xd3\x5f\xdb\xf4\x49\xb3\x75\xe6\x26\x90\x77\x60\xec\x5c\xe1\x6e\x92\x1b\x57\xb2\x07\x59\xc7\x13\xc6\x55\xc3\x0a\x9d\x8d\x26\xdd\xf1\xb3\x2b\x2f\xae\x85\x9e\x63\xd1\x86\x80\xc7\x61\xf1\x34\x10\x78\x7a\xa0\xb7\xc7\xdf\x7c\x83\x5f\x41\xd5\xd6\x2c\x2b\xf4\x8b\x26\xb7\xb9\xc3\xe3\x37\x6f\x5e\x1c\x7e\x38\x3a\x7e\x83\x5e\xbc\x7b\x77\xfc\x2e\x44\x87\x52\xd3\x3a\x66\x55\xb2\xc3\x73\x8c\x51\x77\x03\xd1\xfa\xd0\x46\x77\xe0\xef\x83\x72\x02\xd3\x76\xb4\xf2\x31\x3b\x3b\xaf\x97\x94\x50\x09\xab\xcc\xdf\x84\xb0\x59\x0d\x91\x6d\x7f\xdb\x37\x83\xf5\xcf\x71\x51\x44\x53\x8c\xf6\xd1\xfa\x3a\x7f\xcd\x47\x77\x50\xfe\x7b\xc0\x42\xa4\x3a\x29\x03\x51\xec\x29\xf2\x26\x87\x48\x4e\xd0\xdf\xdf\x1f\xbf\x41\xef\xde\x1e\x52\x40\xde\x25\x4f\x58\x51\xde\x37\xe7\xbd\x96\xc2\x01\xaf\xda\x1c\xad\x9a\xcd\x0f\xec\x66\x58\x1f\xef\xbc\x68\x3b\xa5\x1f\x8e\x5e\xbf\x38\x3e\xf9\x10\x22\x7e\xbf\x4c\xc9\x89\x76\x72\x5e\xa0\x0d\xd4\xa5\xff\x45\xe3\x19\x5d\x9c\x5d\x23\x80\x0b\xf7\xac\xf8\xed\xfd\xc6\x70\xbf\x31\xfc\xf7\x6c\x0c\xf0\xb4\xf1\x8f\x6a\x11\xdb\xfe\xc5\x78\xab\x87\xea\x77\xf8\x5e\x5c\x78\xf6\xa1\x0c\x40\x1e\x84\xf4\xe8\x43\x85\x21\xf2\xf3\x87\xac\xd0\x96\x12\xcc\x6d\x83\xdf\xaf\xfd\xd8\x7c\x21\xcc\x66\x35\xa5\xb5\x9e\xcf\xe2\x33\xa0\x9a\x37\xbf\x45\x96\xf6\x1b\xde\xa9\x6b\x99\x69\x96\x5e\xce\xb3\xa5\x6c\x51\x26\x54\x9c\x94\x04\xd2\xa6\x58\xe0\x0a\xc7\x4c\x04\x00\xd7\xfe\x4e\x50\x22\x9e\x26\x8f\x42\xcf\xb2\x2c\xb9\x86\x78\xa2\x31\xf8\xe5\x66\xbb\x04\x66\x90\xb1\x36\x3b\xf0\x16\x03\xc7\x86\x17\x71\x71\xba\x02\x17\xfd\x74\x55\xf2\xda\x87\x6b\xc6\x34\xe9\x1e\xa9\x28\x84\xe9\x9e\x89\xd5\x6b\x87\x25\xd0\x90\xef\x5e\x3f\x10\x8f\xac\x40\x06\xbc\x26\xb8\x4b\xe0\xbf\x2b\x4c\x4b\xfd\xe5\x95\x6d\x70\xe5\x6d\xac\x8e\x6d\x46\x9f\x31\x73\x8b\x0d\xbe\x82\x2c\x5c\xc7\xca\x63\xb6\x37\x24\x8e\xb7\x82\x6a\xd4\x69\xd5\xd5\xb9\xe2\x61\x94\xe8\x3a\xed\xee\x29\x7a\x6d\x3f\x3a\x58\xa1\x9e\xa1\x95\xdc\xc7\x77\xcd\xb8\xf4\xa2\xf5\xf4\xb0\xd2\x88\x84\x77\xf1\x1b\x0d\xa7\x20\xd3\x34\x2a\x97\xb9\x3d\x1c\x3d\xbd\x6a\x3c\x3a\x4c\xf5\x78\x24\x54\xdd\x80\xc0\x4b\x40\xfb\xfe\xf3\xd7\x04\x82\xbc\x39\x47\x8a\xd2\x58\xaa\x71\xca\x0c\xa2\xf0\x4e\x48\x1a\x25\xca\xc2\x18\xb9\x4f\x0d\x7c\x06\x9c\xfa\xc2\xb6\xb2\x78\xfd\x06\x56\x44\x1e\x3e\xc7\xf9\x65\x39\x63\xea\xe1\xf9\x88\x00\xcf\xc8\x58\x5c\x64\xe8\x1c\x0f\x3e\x50\x8b\x2e\x8f\x03\x0e\xde\x1d\xc7\x81\x9c\x5c\xdd\xf2\x97\xf6\xe2\xee\xde\x4d\x87\x72\x8a\x21\xbd\x60\x34\xf9\xef\x10\x4a\xc4\x75\x6b\xeb\x71\xfb\xc9\x2b\x67\xaf\x48\xb9\x0b\x3f\xe6\xbc\x52\x90\x7b\xaf\xef\xea\x0f\xf9\x3c\x7d\x10\x1d\xbb\x2d\x4f\xd7\x02\x3b\xd4\x32\x74\xf0\x46\xcc\xc3\x47\xf3\xf2\xa7\x04\x02\x29\x59\x37\xef\x1c\x48\x9f\x3f\x4a\x37\x2a\x39\x5d\x26\x49\xc5\x73\x12\xa5\xc6\x43\xc6\xf5\x9b\xd1\x80\xa9\x85\x85\x7a\xab\xa2\x11\x42\xa6\x35\xaa\xf3\x9a\x2b\x76\x3e\x0b\xce\x83\x94\x1e\xdb\xc7\x02\x74\x6e\x5f\x57\xf7\x7d\xdd\x6d\x5d\x1b\xf4\xbd\x81\xf2\x4c\x62\x19\x67\xe9\x38\x2a\x7b\x06\x15\xf4\xab\xbd\xc6\x54\xb2\x3f\xee\x32\xa6\x9a\xfd\xd9\xdb\x2e\xae\xe2\x74\x31\x53\xf8\xbb\xbc\x8c\x73\x07\x6e\xad\x03\x67\x05\x56\x4b\x2c\x9b\x7d\xf0\x00\x34\x0f\x66\x2f\xea\xf7\xeb\x1a\x57\x37\x80\x84\x3b\x74\x76\x13\xe5\x53\x6b\x99\x29\x41\xf2\xa9\x51\x32\xd4\xbf\xb8\x23\x9c\x2d\xcd\xf1\x08\x1f\x20\xbf\xf5\x90\xf5\xda\xef\xa3\xd8\x6c\xa2\x2f\x52\x5e\xd3\xeb\xdb\xee\xef\xd1\x25\xfa\x6b\x46\xd2\x5e\xa7\xe3\x56\x2e\x9f\xa2\x31\x7a\x63\x88\xd2\x2f\x15\x40\x4a\xec\xd1\xf5\xde\x0f\xf4\x1e\xf5\xf7\x90\x1a\x73\x9a\x95\x47\x46\x67\x25\x0e\x3d\xfe\x7d\x14\x70\xcb\xc6\xe1\xb1\x40\x3f\xb0\x5a\xe1\x35\xba\xdb\x8a\xc6\xc3\xb3\x65\xb9\x58\x96\xaf\xb2\xa9\x62\xde\xb1\x2a\x2a\x94\x45\xfc\xf8\xc2\x7c\xbb\x68\x52\x9a\x09\xa6\x78\x37\x8c\xcb\x76\xbd\xc4\x60\xd8\x05\x93\xc1\x5d\x73\x1c\x2f\xc7\x58\x9b\xb0\x68\x3c\x0e\x10\xf7\xff\xa8\x73\x95\x68\x3c\x3e\xe5\xc9\x8c\x43\x52\xc4\xf0\x6f\x41\xeb\x4f\xcd\x79\x1b\x14\x33\x32\x29\x7b\x7d\x14\x3a\x58\x15\x59\x8e\x12\x2b\x1a\x8f\x85\xd6\x8a\xd9\x59\x33\xfa\xc6\x09\x2e\xb1\x18\x87\x72\x4c\x64\xa6\x33\xd2\xba\x01\xe3\xd0\xae\x8e\xf8\x93\x0e\xbe\xc0\xe9\xc6\xcf\xa4\xba\x4a\x9f\x06\x77\x25\x25\x19\x0d\xd7\x8b\x42\x1e\x9f\x09\xb6\x2c\xf4\x47\xf7\x82\xb4\xdd\xec\x05\xa9\xae\xf8\x56\xb5\x79\x9b\x59\x01\x32\xe4\x41\xc3\xed\x82\x76\x97\xac\x6e\x69\x2d\x77\x4b\x8e\x88\xf9\xc7\xf0\xbb\x54\x49\xc8\xba\xc9\x7d\x8b\xc7\x84\xd6\x6b\x32\xef\x4b\xc2\x5a\x52\xfc\x5a\x4e\x9e\x28\xa8\x79\x8a\xad\x62\x7f\xc2\xae\x0f\x5a\x3a\xd5\x00\xce\x0c\xd2\xf5\x01\xe8\x7e\xa3\x14\x2d\x78\x41\x4f\x25\xbf\x67\x6d\x9f\x55\x0e\xc0\xb0\x56\xf0\xde\xc5\x1a\xb8\xd4\x3c\x51\xd5\x5d\xc5\x36\xf9\xa7\xba\xa1\x4b\xaa\x27\x6d\xb4\xf1\xb7\x75\x2e\x39\xf4\xeb\x29\x5f\x33\x1a\xf4\xe8\x02\xeb\x03\x6d\xe8\x31\x36\xd6\x86\x43\xf4\xe1\xf8\xf9\x71\x88\x72\xcc\x0c\xa1\x02\x54\x64\xdc\x64\x45\xde\x70\x29\x1b\x98\x88\x69\xbd\x06\xb4\x1c\x84\xbf\x4f\xf1\x18\x17\x45\x94\x5f\xd2\xc5\x02\x31\x9f\x0b\x4a\x6e\x5d\xf0\x10\x0c\xfe\x99\xd1\x45\x96\x7f\x62\x82\xde\x7c\x99\x94\x64\x91\x68\x91\x0e\xcc\xd8\x22\x7e\xb7\x42\xc3\x87\xc8\x6b\x43\xfd\x8d\x30\xa1\x66\x75\x98\xe6\x03\xa2\x79\xc3\x76\x53\x35\x86\x63\xb6\x6b\x98\x87\x14\x59\x6a\x20\x70\xe4\x73\x1c\xb3\x4e\x3b\x77\xea\xc2\x9e\xf9\x8e\x10\x55\xb0\x16\x2f\x45\x8e\x5d\xa1\xd9\x4f\xee\x47\xc9\x57\x53\x83\xf9\xa1\xb7\x9e\x4a\xbb\x65\x55\x3f\x27\x78\x7b\x4c\x0e\x80\xe7\xf4\xcd\x72\x7c\xd8\x60\x39\x92\xe9\x71\x53\x1a\xb3\x8b\x1e\x8b\x4b\x5e\xac\xc0\xa5\x15\x49\xc5\xe7\x5b\xaa\xf6\x2c\x56\x3f\xdd\x04\xd7\x8c\x57\xc1\x78\x86\x5c\x45\x2f\x48\x05\x01\xb9\x5c\x79\xd8\xb2\xe0\x1d\x0c\x1c\x69\xf6\x9a\xf8\xf3\xc0\x60\x47\xea\x63\x0f\x09\x00\xc1\x85\xe0\xff\x3d\x91\x2a\x59\x0e\xfb\x21\xd3\x35\x46\x23\x7e\x9a\x42\x24\xfe\xcc\x9f\x55\xbb\xdc\x9c\xa1\x41\x79\x04\xaa\xe0\xcf\x15\x1c\xb9\x13\xee\x80\xe7\x20\xdd\x4d\x37\x65\xcc\xdf\xdd\x5f\x93\xde\x5f\x93\xfe\xc5\xaf\x49\xd9\x15\x29\x7f\x6a\xfb\x5f\x11\x7f\xee\x4e\x5d\x74\xc3\x21\xe0\x21\x3a\xcc\xd2\x73\x4c\x59\x51\xc4\x63\x02\xc3\x21\x18\xce\x02\x10\xd8\x57\x84\x4e\xa1\x04\x1c\x25\x45\x86\xa2\x24\xc9\x2e\x0a\x38\x26\x31\x5d\x5d\x31\x58\xa3\x15\x09\xc1\xff\x35\xf9\x8c\xe3\x6b\x96\xb5\xe6\xde\x71\xac\xf1\xdb\xd5\x32\xb3\xa3\x00\x73\xad\xa5\x3c\x6d\xf6\x4c\xed\x28\xba\xba\x12\x21\xc4\x55\x46\x57\xaa\x53\xbb\x7d\x5b\x13\xc0\x0e\x72\x5c\x44\x62\x3a\x5a\xd6\x87\x9e\x50\x31\x1a\x0d\x31\x25\xc4\xf1\x04\xb4\xce\x7d\xa8\x7d\xd3\xa9\x13\x20\x39\xdf\xd7\x5f\x92\x1a\xf7\x47\x22\xc8\x90\x6c\x07\x8e\x5c\x54\xd4\xa4\x9c\x56\x5c\x04\xd9\x16\xa8\x99\x54\xf5\xf3\xc3\x56\x40\x27\xe1\x1c\xe7\x64\x02\xfe\x34\x72\x3c\x8e\x28\xc7\xd1\x42\xc3\x3c\x78\x80\x92\xe8\x3f\x97\x28\xc9\xa2\x18\xc5\x97\x69\x34\x27\x63\x94\xa5\xb8\x80\xd6\xf8\x84\xa8\x86\x78\xb4\xe7\x4c\x2a\x09\x00\x4a\xd8\xb5\x8b\xc6\x1d\x28\x3a\x5b\x53\x5c\x1e\xcb\x13\xb2\xd7\x85\xb9\xa3\x22\xe0\xb8\x16\x20\xd5\x37\x1b\x86\x36\xbf\xf2\x7a\x85\xc9\xc2\x43\x2e\x64\x2f\x73\xcc\x15\x81\x01\x5c\xba\x8d\x19\x15\xb3\x43\xec\x0c\x7f\xd6\xeb\x52\x7a\x4d\x2b\x41\xf3\xd0\xd8\x00\x6a\xe8\x24\x79\x3c\x68\x67\x38\x96\x0e\x5e\x44\x8d\x7e\xca\xe3\x69\xd3\x2a\x38\xd1\xf7\x51\x28\xe8\x9f\x83\x39\xea\x6e\xb6\x66\x64\x13\x94\xf0\x43\xd5\x29\x69\x7d\x0f\x79\xd0\xc5\xd0\xea\xb2\xca\xa7\xe4\xa8\x72\xe9\x97\xca\x2b\xc8\x54\x65\x15\x64\xaa\xd7\xaa\xd7\xa8\xd2\x3f\xe1\x4b\x95\xf1\x09\x5f\xaa\x9c\x39\x49\xdf\x66\x17\x2a\x93\x7d\xab\xfc\x48\x44\x21\x16\x00\x91\x1e\x83\x58\xf4\x14\xae\xa4\xc2\x95\x6e\xaa\x06\xb2\x5c\x5f\xef\xff\x4d\x6a\xe2\xa5\xfa\x42\x60\x14\xca\x92\x83\x38\x66\x0f\x02\xa4\x0e\x2b\x4a\x63\x54\xe0\xb2\x40\xcb\x05\x64\xf0\xf3\x00\x2c\x5a\x52\xe2\x9c\x72\xef\xec\x9c\x8b\x3b\xdc\x81\xe7\x60\x6d\x4d\x7b\x14\xf0\x2a\x9b\x16\x07\xe5\xfb\x32\xca\xcb\x35\x5b\xd1\x57\xe0\x64\x22\x13\x29\xe1\x91\x32\x4b\x25\xef\x34\x0b\x1b\x21\xb1\x70\x32\x71\x9c\xd6\x88\x57\x65\x53\x5c\x32\x0d\x12\x2d\x6c\x3d\x2d\x83\x83\xbd\x1a\x5d\x01\xbd\x12\x4b\x7a\xdd\x5a\xd3\xb4\x95\x81\x6f\x61\x43\xc6\x14\x97\x3d\xeb\x91\x0b\xb7\x27\x74\x8e\x17\xc3\x21\x8a\xb3\xb4\xcb\x9f\x45\xd2\x3e\x72\x6c\x81\xf1\x22\xdc\x36\x8b\x44\x61\xfb\x03\xae\x1f\x06\x83\x01\xfa\x75\xc9\x3c\xdf\xd2\x36\x29\xd3\x73\x0e\xaa\x15\x2f\x01\x6b\x5e\x01\x5e\xdb\x4f\x3e\xad\x25\x2d\x87\xe1\x3f\xdc\xb1\x4c\xef\x89\x90\x99\x53\x36\xbd\x4b\x64\xaf\x55\x4c\xe3\x4b\xa3\x7f\xcd\x8e\x47\xbf\x1e\xc5\x2e\xb2\x24\x61\xe4\xe3\xa7\x56\x4e\x9b\x0a\xcc\xa6\x4b\xb9\x4b\x80\xa2\x34\x7d\x2d\x8d\x61\x0d\x62\xc9\x2a\xc8\x85\xcf\x68\xe6\xcc\xa9\xb0\x74\xa0\xa4\x27\xc6\xea\x9b\x04\xdf\x3b\x21\x1f\x4d\x64\xad\x8f\xd0\x6d\xa9\xe3\x66\x94\xa1\x8c\x85\x61\x68\x4a\x5d\xfc\xd4\x4a\x50\x95\x84\xa2\x90\x4b\x3a\xb7\x42\xcf\xed\x88\xb4\xf2\x20\x0e\x7d\xb2\xbd\x2f\x53\xc6\xf3\x36\x4b\x12\xca\x67\x54\x4f\x18\x0d\x86\xac\x08\x11\x91\xf8\xe1\xac\x37\xa0\x14\x07\x43\x53\xcc\x7f\xc1\x0d\xdc\x4f\x19\xa6\x80\x1c\x8f\xe2\xb3\x40\x5c\x0c\x19\xc9\x81\x22\x46\x9e\xa3\xfb\xed\x61\x9a\x59\xa0\x5f\xba\x3b\x8b\x00\x7d\x0e\x89\xbb\x56\x81\xf2\x26\x45\x2e\x34\x8f\x42\x3e\xe0\x07\x98\xc3\x1c\xc3\x68\xc0\x5e\xfa\xd0\xf3\xa6\x0f\xd8\x1c\x53\x1a\x6b\xb7\x9c\x06\x26\x34\xa5\xda\x2a\xda\xa9\x4a\xf5\x52\xa5\x7e\xc5\xaf\xc7\x32\x3b\xa3\x89\x34\xa8\xd2\x39\x7a\xa5\x31\xa4\x12\x03\x95\xe4\x69\x3d\x13\x06\x38\x07\x01\x66\x82\x06\x29\x66\xdb\x7d\x17\x25\x57\x05\xb7\x68\x91\x19\x7c\x9b\x3d\xac\xca\x57\xac\xce\xc9\xd2\x2f\x77\xe4\xef\xca\x7e\x0f\x52\x7c\xa1\xdf\xed\x38\xef\xde\x05\x63\x24\xb1\xe1\xff\xcd\xcf\x10\x1b\x96\x7a\x6f\x3c\xf2\xf8\xd5\x1a\x8f\x1a\x79\x1f\x92\x8e\xad\xbc\xc4\xea\x94\xf7\xea\x63\x8d\x95\x47\xe7\x2b\x76\xfd\xd2\xe9\xae\x03\x72\x0c\xca\x77\x2a\xe3\x2f\x70\x1a\x83\x0d\x98\x9c\x8f\xa8\x00\x05\x44\x5a\x50\x32\x92\xbe\x49\x54\x45\xd9\x04\x80\x69\x21\x2a\x94\xf4\x99\xd2\x41\xb6\xbe\x4c\xa3\xa2\x20\xd3\x14\xc7\x03\xb7\x8f\xf6\xe4\xfb\x58\xa6\x0f\x91\x52\x04\x1a\x8f\x1a\x70\xe9\x6d\x46\xb7\xaa\xd2\x46\xa2\x6c\x6e\x51\xa2\x0b\x6f\x51\x92\xe3\x28\xbe\x54\xef\xa7\x95\x1c\x57\xdc\x9e\x28\x4c\x39\x53\x08\x97\x4d\xe3\x22\x93\x9e\xd5\x9a\xf4\x49\xb6\xe9\x7a\x88\x52\x8b\x88\x31\x59\x9f\x9b\x42\x2a\xe4\x96\x19\x1f\x1b\x99\xcf\x71\x4c\xa2\x12\x27\x97\x76\xb3\x5c\x3d\xa0\xee\x99\x0d\xe7\xaf\x35\x26\x4e\xd0\x5f\xa8\xbe\x57\xe1\xf9\xc0\xe7\x45\x49\x3f\xaa\x31\xbe\x4c\x77\x07\x36\x18\xed\x8e\xf3\xc2\x89\x1a\x61\xef\xb5\x26\x1b\x62\xb6\x6f\x5a\x3f\x84\x9a\xc2\xe0\x63\xfa\x68\xac\x79\xe2\xd7\x88\xee\x40\x34\x5c\x6b\x77\xa5\xd7\x6d\x07\xa2\x6f\x8b\xcd\xe3\x71\x36\xf6\x6c\x21\xf6\x75\x73\x20\x0d\xac\x18\x9e\x3a\xcf\xb3\x73\xa1\xea\x43\x51\x71\x99\x8e\xe5\xd9\xc4\x27\xb7\xf8\x58\xec\x32\x85\xb7\xbc\x06\x02\x34\x11\xc0\xc2\x96\xc3\xbb\x74\x63\xf1\x55\x6a\x36\xe4\x72\x07\xa3\x53\x2b\xd4\xb7\xef\x31\xbf\xb3\xf1\x7b\xed\x30\x64\x49\x5b\x66\xb6\x36\xbf\x0a\x53\xc3\xe1\x10\x1d\x4d\x14\x67\x24\x85\x7c\xfc\x76\x89\xb9\x3b\x10\x44\x4a\xa4\xbc\x46\xa9\x72\x17\x33\x0c\xd6\x09\x7c\xf4\x7d\xc4\x98\x6a\x81\x48\x69\xb2\x55\xef\x9e\xea\x10\xbb\x5c\x66\xbe\xdd\xc3\x87\x7e\x5e\xa3\x3d\xa1\xfa\xd6\x09\x11\x3b\x3c\xfc\xed\x2b\xfa\x8b\xb1\xc4\xe5\x1c\xdb\x76\x6d\x49\x36\xad\x6a\x17\x59\x8c\xa9\x46\xf4\x87\x5a\x42\xba\x27\x54\xb8\x87\xf3\x07\xd0\x30\x41\x1c\xf9\xdc\x1e\x58\x7b\x3a\x72\xdc\x1e\x71\x39\xf9\xe8\x39\x4b\x08\x39\x8d\xf5\xfa\x03\xb6\x23\x8f\x23\xe1\x40\x0f\xdc\x7c\xe0\x18\xd1\xd5\x3d\xcb\xb3\x34\x5b\x16\xd2\x9b\x1e\xbf\x30\xa7\xbb\xbd\xed\x19\x87\x55\xc3\x25\xd2\xae\xd7\xf2\x14\x9c\x1c\x64\xca\x74\xad\x0d\x01\xb9\x86\x65\xb4\x86\xe6\x39\xbc\xc5\xbc\x5d\x37\xf0\x63\xe7\xea\x90\xe1\xd6\x89\x45\x56\x73\x71\x78\x7d\x16\xec\x6c\xde\x5f\x0d\xde\x5f\x0d\xfe\xb5\xaf\x06\xd5\x03\x4a\x4d\xf9\x7b\x93\x57\x94\x1c\x78\x85\x3b\x3d\x5f\xf4\xb1\xd6\x0f\x2f\xd3\x09\x99\x7a\xe1\x58\x96\x00\x3c\x1a\x45\x56\x54\x11\x32\x8a\x52\x4f\xa4\x10\x50\xef\xb2\x50\x47\xcc\x54\x98\x5d\xeb\x8d\xc8\x94\x3f\xe5\xb7\xec\xf9\x18\xd0\x33\x32\xb5\xd4\xe3\xba\x5d\x1f\x53\x01\x5f\x31\x88\x2b\x09\x7b\x6d\xba\x4d\x52\xe9\xba\x41\x2a\x28\xfe\x2a\xda\x30\xe4\x20\xd6\x3b\xef\xe3\xac\x32\x93\x65\x05\xd8\x9e\xd4\xca\x90\xe2\x6d\x8e\xf9\x85\xa0\xa6\xe7\x37\xea\x1e\xa9\x74\xab\x81\x91\x5e\x82\x1e\x1d\xb8\xff\x75\x74\x75\xe5\xe6\xf1\xd3\xa8\x3f\x13\x47\x79\x42\x68\x51\xad\x6b\xe9\x62\x59\x3e\xc7\x93\x68\x99\x78\xaf\x20\x9a\xfa\x48\xf7\x60\xbb\x1d\x79\xf9\xe9\x8d\x1f\x42\x49\x66\x10\x6b\x2d\x7a\xbc\x1f\x55\xdf\x88\xe8\x5d\xb0\x46\xf1\x5b\x74\xdf\x7e\xe6\xc4\x44\x12\x5a\x4b\xc5\x1c\x1b\x8d\x7a\x2a\xd4\xb2\x3d\x78\x10\xb4\xf5\x12\x7f\xf6\x8c\x9c\xaf\x2a\x36\xd8\x42\x33\x0f\xcc\x26\x28\x32\x9c\xd3\x45\x69\x2c\xee\x22\x0b\xb8\xba\x60\x37\xe4\x74\xdd\xbd\x7c\xf1\x0f\x6b\xb9\x41\x1d\x54\x12\xf6\x2e\x34\xa1\x5c\x37\x9c\xbc\x3a\xf6\xdf\xe2\xb2\x58\xa8\xdf\xdd\x3a\xbd\x17\xb6\x5f\x8c\xdb\x56\xb8\x40\xd3\x2e\x3d\xe1\xf3\xea\xca\xa2\xa1\x83\x31\x38\xfe\xd7\x5c\x6f\xe9\xf0\x1e\x9f\x4f\xa2\x5a\xe8\x13\x77\x84\xe4\xbf\xbc\x33\x25\x1f\xbd\xea\x32\xe3\xa1\x8a\x49\x89\xe6\x64\x3a\x63\xa2\xa2\x74\x9f\xcb\x15\x51\x4e\xcb\x65\xd6\xd8\x6e\x99\x99\xad\x9e\x76\xa7\x51\xf1\x36\x27\x63\xdc\x0d\x10\xfd\x4d\xff\x83\xe9\xa3\x3f\xd2\x2c\x1d\x63\xdf\x93\xbd\x4f\xf8\xb2\xe6\xd1\xde\x27\x7c\xd9\xf6\xd9\x1e\xd4\xe4\xe0\x90\xd5\xb0\xaf\x59\x16\x3c\xc7\x63\x32\x8f\x92\x9e\x0e\x50\x71\x7f\x2c\x2f\xd8\xbf\x36\x11\x6b\xce\x1c\xef\x9a\x96\x7d\x55\xdf\x3d\x49\xdf\x94\x6a\xef\xe9\xf5\xb7\xa4\x57\x2e\xc4\x38\x04\x0b\x17\x98\x22\xfa\x0c\xa7\x56\xaf\x68\xd3\x9a\x4e\x3f\x9b\xe2\x0c\x4f\x5f\x33\x64\x98\x46\xca\x2c\x3f\xf7\xbf\x48\xdd\xdd\xe7\x81\xbe\xfd\xad\x8b\xf3\xb3\xd2\x59\x99\x00\xd2\xcf\x43\x26\xf0\x67\x02\xc8\xd7\x0b\x34\x5d\xc3\x05\x3c\x92\xf2\x57\xef\x40\x79\xdb\xb0\xa1\x84\x7a\xee\xf3\x00\x48\xca\x5f\x08\xb2\x14\xe4\x34\x2a\xfc\x70\xd3\xa8\x30\xa0\x80\x7c\x35\x50\x25\xda\x69\xf9\xaa\x84\x30\xe3\xf2\x82\xeb\xef\x46\xc5\xd9\xf9\xf3\xca\xa4\x24\xe2\x9c\xdc\x84\xa4\x78\xc8\x95\x5a\xca\x92\x11\x80\x56\x21\x2f\xbb\x62\xeb\xda\x51\x0f\xdd\xa2\x42\xb5\x34\xd0\x9b\x0f\xca\x9d\x33\x0f\x94\xa2\x3c\x91\xd9\x82\xfc\x2a\x41\xab\x9b\xac\x20\x44\x19\x51\x64\x39\x5f\x26\x51\x49\xce\xf1\x4f\x51\x71\x52\xc0\xf3\xac\xaa\xaa\x1c\x58\xab\xae\x69\x63\x0d\x53\x59\x4e\x0c\xde\xbc\xfb\x17\x70\x49\x36\xb5\x4d\xdd\x54\x86\x16\x0f\xc5\x51\x26\x81\x46\xc8\xab\x4a\xf2\x3c\xf2\xa4\xb0\x4d\x7a\x23\xde\x52\xab\x05\x00\xb3\xdb\x9e\xe4\x41\xea\xae\xa5\x72\xa8\xb0\x05\x8d\x9b\x35\xe9\x06\x23\x50\x83\xb4\x18\x19\x0e\x91\x74\x78\x03\xae\xdf\xf8\xe9\x15\x21\xd6\x14\x9d\x9f\x57\x64\x4e\x4a\xcf\x14\x9a\x00\x1c\x57\x32\xb1\x62\xde\x8d\x7c\xa3\x4c\x41\xfe\xe3\x63\x82\x2a\xd3\x80\x2e\xc9\x1c\x17\x65\x34\x5f\x54\x16\x91\x10\x6a\x5d\xb1\x8c\xb4\x6a\xe5\x1a\xd9\x55\xd5\xca\xa3\xb1\xd6\x99\x98\x4c\x26\x64\xbc\x4c\xe0\xa1\x82\xcb\x43\x6d\x20\x73\x20\x59\x19\x25\xcf\xdb\x54\x60\x41\xea\x42\x92\xb9\x66\x38\xb8\x5a\xe6\xe6\xca\x71\xb3\x5d\x11\x84\x94\x78\xde\xb7\x9f\x28\x39\xe6\x6a\x00\xe5\xde\x3c\x1a\xeb\xcb\xb7\x99\xb3\x82\x4d\x0b\x6d\xc4\x8e\xd6\x2d\x96\x59\x92\x4d\xbd\xeb\x49\x5f\xdb\xbe\xd5\x94\x64\x53\xcd\xd5\x8a\xb3\xa4\xa0\x5e\x63\x59\xe9\x15\xea\x8b\x4a\xd3\x57\x93\x09\xfd\x6a\xd8\x23\x6c\x08\x97\xd8\x2c\x08\x45\xc3\x34\xa3\xc5\xbe\xe0\x05\xf3\x37\x53\xb1\x1f\xf0\xb6\x92\x6c\x5a\xd7\x86\xcc\xf6\xd7\x2d\xb2\x2d\x79\x14\xd4\xf3\xcd\x67\xa7\x8b\x19\x29\x28\xcb\x5c\x64\x45\x79\x83\xc3\xd3\xdb\xac\xa8\x97\x19\xdc\x30\x2f\xb5\xac\xd5\xad\x54\xa7\x01\xda\x49\x9d\xaf\xd2\xef\xc1\x22\xba\x04\x1b\xf2\x7d\x43\x11\xa2\x67\x69\xaf\x65\x21\xb9\x2c\x93\x3e\x12\xbf\xbc\xf2\xbe\x04\xb3\x4a\x2e\xb2\x8b\x0f\x64\x8e\x79\x69\xfe\x55\x5d\x83\x00\xf7\xd4\x12\xe5\x53\x5c\x6a\xf5\xc0\x37\xda\xb7\x12\x06\x65\xc6\xf9\x80\xe6\xe3\x9c\x6b\x45\xe1\xbe\x21\x5b\x90\xb1\x35\x38\x66\xa4\xad\x18\x8b\x4a\x45\xfb\x3a\x8c\xf7\xcd\x00\x7a\xaa\xc3\x87\xf6\xa3\x00\xad\x05\x1f\x3b\xa1\xd9\xad\xb8\x89\x54\xb4\x03\xd9\x71\x7b\x3c\x2f\x7f\x69\x22\x30\x3f\x35\x99\x0a\xdb\x7a\x7a\xe2\xe4\x04\x43\xc3\x9f\x17\x24\xbf\xf4\x2c\x34\x2d\x97\x8f\x1c\x52\x0a\xe6\x9e\xc2\x0b\x4d\xf3\x74\x58\x9d\xd6\x2c\x50\x45\x69\xf0\x79\x91\xe5\x9f\xde\xe6\xd9\xb9\x77\x77\xb7\x20\xfa\x7b\xbe\xc5\xf0\x2e\xba\x90\xb4\xc4\x52\xbc\x60\x5a\xf5\x07\xc5\x98\x10\x7b\xd5\x88\x32\xfa\xfe\xf7\xf7\x82\x23\x4e\xc2\xa9\xd8\x0a\x8a\xde\x54\x03\xe0\xbf\x15\xe2\x1b\xf9\xd6\xe4\x70\x28\x48\xc8\x24\xec\x49\x96\x24\xd9\x05\xbc\xe5\x10\xaa\x16\xd5\x95\x75\x45\x86\x85\xaf\x71\xc3\xc7\x93\x6c\x45\x1f\xbf\x84\xd0\xbe\xaa\xdf\x49\xf0\xba\x2d\x75\x2b\xc3\x98\xbe\x18\x68\x33\x16\x17\xae\x5d\x11\x1e\x36\x5c\x2c\x47\xc5\x38\x27\x23\x7c\x03\x5e\xfc\x5e\x94\xad\x65\xc8\x4c\xa9\x72\x90\x4f\x8b\x5a\x7e\x8c\x74\x86\xec\xd6\xac\xaf\x22\x55\xa3\xae\x30\x57\xa9\xfc\x31\x45\x5f\x6b\xda\x60\x79\x0e\x64\x2d\xd7\x83\xb9\x92\xad\x58\x1e\xfc\xb5\xaa\x38\x79\x18\x01\xab\xed\x5c\xb3\x71\x9e\xf6\x14\x9d\x3a\x89\x67\x28\x94\xc4\xc4\x28\xa9\x55\x5d\xed\x9e\xde\xd4\x72\xe3\x0a\x46\x5c\xf7\xf2\x46\x75\xc3\xba\xfb\xb0\xd5\x73\xbe\xa0\x1c\xba\xf5\x0e\x61\x77\x75\x29\xbe\x80\x6b\xbb\x9e\x19\xb2\x19\xee\x33\x46\x51\x3a\x20\xc5\xcf\x51\x42\xe2\x1e\x84\x54\xe0\x29\xcf\x49\x8e\xc7\x65\xcf\x77\x99\xc1\x9d\x68\x01\x20\xaf\xb1\xd7\x77\x6e\x4a\x74\x31\x58\x45\xba\x11\x3d\xf0\x54\x6b\xf8\x6b\xf3\x54\xd4\xa2\x0a\xde\x33\xb3\x26\xa6\xbf\xb1\x4d\x43\xb8\x4f\x6d\x01\xdb\x15\xa1\xa7\xd5\xa6\xf3\xfe\x32\x1d\x93\xd4\x2f\xcb\x72\x27\xd6\x42\x92\xe1\x1e\x7c\xc0\x56\x90\xa4\x53\x38\x58\x7a\xcf\xf3\x2e\x98\xe9\x07\x89\xbb\x24\x6a\xa8\x40\x87\x32\xcb\xcf\xc8\x74\x86\x8b\xa6\xf2\x3a\x94\x46\x0b\x3c\xf7\x53\x9a\x5d\xa4\xef\xcb\xa8\xc4\x3e\x0f\x79\x5a\x6e\x75\x03\x7a\x15\x7b\x76\x0d\x8b\x65\x92\xe0\xb8\xa9\x0a\x1d\xaa\x42\xc5\xa0\x5c\x23\x55\x38\x9e\x6f\xba\xf5\x0c\x1b\x21\x02\x55\x4f\x4d\x05\x0d\x25\x8d\x0b\xb1\xd0\x93\xa6\xc1\xfa\x4e\x82\x61\x75\x96\x56\xd2\xe6\x0d\xa1\x3f\x59\x2b\x61\x48\x55\xa1\x27\x4d\x83\x75\x37\x90\xb0\x2a\x83\x95\xaa\xba\x69\x0f\x2b\x73\xf4\x72\x7e\x34\x54\xe7\x55\x94\xb5\x55\x97\x9e\x2a\x6c\x10\xa3\xf7\x86\x82\x28\xf4\xa6\xea\xf0\xfa\xc9\x37\xf4\xa4\xe9\xb0\x16\xf2\x3d\x89\x3a\xb4\xcd\x8b\xc2\x8a\x74\xc6\xc3\x0c\x83\x2c\x76\xe7\xd4\x09\xb7\x9e\x54\xb9\xdf\xa1\x8c\xbc\x13\xee\xec\x5c\x9f\x05\x3b\x5b\xf7\xf6\x59\xf7\xf6\x59\xff\x35\xf6\x59\x9c\xd2\xef\x22\xf6\xc9\x6a\xce\xeb\x5b\x1a\x65\xdd\xa1\x8f\xfb\xf6\x5e\xe9\xa3\x24\x19\x5a\x31\x12\xe1\xa5\x2b\x1f\x88\x0a\xce\xe6\xf8\xaa\x17\xf6\xe0\x6e\x30\xa9\x1a\x1f\xf5\xbe\x68\x52\x1f\xd9\x86\xc7\x7d\xa8\xeb\x61\x54\x57\xf7\x6f\xae\x2a\xe5\xbc\x5f\xaf\x95\x25\xdd\xae\x5a\x08\xc1\x16\x81\x1a\x01\xea\x14\xdf\x3a\x8c\x08\xb3\xca\x41\xf8\xa7\x0e\x71\x27\xfe\xf5\x29\xf7\xb7\x27\xc3\x70\xbd\x08\x86\x00\x87\xca\x13\xa2\x76\x7a\xb0\x4e\x7f\x37\x08\x1e\x2c\xe4\x78\x15\x69\x0d\x5c\x26\x00\x27\x67\xef\x85\xe8\x99\x15\x9c\xe8\xaf\x73\x81\xae\x5d\x87\x75\x01\xad\xb6\xd3\x7a\xf7\x7e\x70\x48\x49\xe4\xe8\x71\xe3\xf8\xeb\x41\x77\x70\xfe\xb1\xd9\xcf\xf9\x6b\x44\xc7\x9e\xc2\x43\x4b\x44\x34\x39\xf8\x14\x2a\x19\x30\x11\xd1\x42\x4d\x9b\x1e\xeb\xb3\xb7\x0c\xcc\x13\x1d\xce\x59\xc2\xca\xbd\x6f\x85\xb3\xcf\x28\x91\xad\x2a\x8b\x99\x61\xdd\x94\xc9\xf6\x2b\x27\xca\x89\x27\xb8\xfa\xf4\xad\x3a\x7b\x66\x18\xc0\x8a\x38\x83\xec\xa0\x68\xd8\xc4\x78\x1c\x89\x1b\x71\xff\xf6\x51\x85\x93\x70\x9f\x8f\x69\x6e\xe3\xaf\x8d\xc8\x08\x28\x58\x63\x85\x52\x11\x05\x43\x60\xf7\x66\xde\xfe\xbd\xc5\x6b\xa7\xf6\x46\x3e\xff\xb9\x8f\xe2\xcd\x00\x3d\x11\x47\xec\x9a\x26\x96\xe9\x22\x1a\x7f\x3a\x66\x8a\x66\xc3\xce\x0a\x92\xf4\xb5\xbe\x6e\x26\xa9\x2e\x98\x1e\x5d\x44\x55\xec\x87\xa4\xae\x7d\xb4\x8d\x9e\x8a\x44\xe1\x46\x19\x09\xb1\x5a\xbd\x71\x96\x8e\x8f\xab\xbc\x28\xeb\xbb\x4a\xc0\x8b\x9b\x33\xca\x0f\xb4\xba\xff\x57\x19\x4c\xeb\x74\xf3\x0c\x85\x3e\x2f\xbf\x87\x10\xb6\x35\xd2\x22\xe5\x0a\x64\xd9\xb1\x78\xa3\x24\xd1\xd7\xef\x60\x30\x10\x4b\xf8\xd0\x2e\x6b\x30\x0d\xa4\x3b\xf8\x28\x21\x1e\xed\x11\x93\xc6\x20\x24\xa7\x00\xa5\x72\x6b\x24\x6b\x08\xcc\x90\xdb\x22\x99\xf9\x93\x82\x77\x5a\x42\x86\x8d\x8c\x97\x34\x51\x1a\x9b\xee\x20\x04\x18\x8b\x59\xcb\x04\x4d\x5a\x07\x8b\x42\x46\xc1\x39\xda\xbc\xb4\xcb\x67\x15\x62\x6e\x36\x51\x2d\xf4\xaa\x2a\xae\xe9\x2a\x41\x4b\x5d\x6b\xb6\xa8\x8f\xbe\x88\x4d\xcf\xb2\x5b\x93\x32\x82\x1e\xd9\x5f\xb9\x5d\x35\xf6\xe1\x9e\xc6\x05\xc0\x75\xac\xb9\xdd\xe9\x45\xf4\xfd\xc6\x2e\xa6\x34\xf6\xcc\xdd\xab\x60\xc4\x02\x4e\xdd\x84\xaf\xfb\x9e\x2d\x2a\xc5\x97\x64\x7c\xb8\x9c\x31\x24\xf0\xaa\x03\xa3\x6b\xee\x23\x25\x28\xa5\x2f\xe1\x9e\xb1\x1e\xb4\x90\x09\xce\xb3\xc2\x36\x0d\x06\xae\xaf\x0e\x97\x07\x68\x9e\x3a\x84\x2d\xba\xf1\x44\x3c\x60\xf7\xb3\x7b\xa6\x63\x52\xd6\x69\x1c\x3b\x1e\x98\xcb\xfc\xd2\x7a\x63\xa5\x81\xc2\xb3\xaa\xea\xf1\x22\xe3\x1d\xd8\x18\x1e\xe2\xf6\x1c\x6f\x1b\x8c\xe2\xf7\x11\xf6\xfa\xf9\xb0\x3b\x2f\x5a\xd7\x34\xc7\xb5\x1b\x45\x1b\x41\xde\xde\x36\xcc\x22\x8d\xbb\x82\xd5\xc2\x9f\x6a\xa9\x35\xae\x19\x41\x52\x1c\x90\x1b\x01\xfe\x80\x36\x41\x8a\x34\x84\x7b\xf3\x0d\xb0\xa5\x6e\x3e\x8c\x52\xf6\xa6\x35\x8d\xb9\x3f\x38\x88\x21\x99\x3e\x12\x27\x03\xf5\x50\xdc\xb1\x46\xf7\x2e\x57\x23\x7e\x94\x2f\xac\xbd\x79\x4d\x77\xbd\x66\x2d\xb3\x0a\xf0\xf6\xce\xba\x71\x51\x92\x79\x54\xe2\x9f\x22\xd0\xc7\x34\x51\x95\x06\xde\x44\x51\x7a\xcd\x77\x41\x4d\x5f\x9f\x3a\xda\xcd\x90\x36\xae\xa6\xd9\xf1\x80\x56\xcd\xcc\x3b\xd1\x0c\x16\x91\x88\x58\xa0\x70\xae\x5a\xe1\xf2\x81\x3f\x24\xb8\xbb\xb3\xda\xd5\x34\xcd\x55\x53\xe0\xf0\x9b\xcd\x53\x2b\xc4\x8b\x0b\x5a\xbe\x32\x6b\xa2\x6c\x7b\xa5\xe6\x5b\x04\x34\xd3\x8b\x0a\x3c\x6b\x64\x5f\x8b\xb0\xdf\x36\xba\x99\xac\xff\x46\x01\xce\x64\xa1\x55\x07\xf9\x35\xa3\x9d\xa9\x90\xe9\x74\x80\xf9\x62\x2c\xfc\xf8\x14\xec\x60\xdc\xc4\x88\x38\x74\xf5\xa5\x79\xcd\xb8\x78\xd9\x3f\x36\x57\x42\x46\x88\x07\x01\xa6\x8b\x29\x46\xc0\x02\x7d\x4e\x5c\x97\x57\x96\x8a\xeb\x29\xea\xe2\x72\xf6\x91\xf6\xb8\x8b\x42\xf6\x61\xed\x24\xdd\xc0\x11\x5e\x42\xe5\x70\x4a\xe6\x49\x27\x59\x7c\x38\x67\x9a\x23\x46\xe8\xb8\xf0\x9d\xc8\x18\x64\x23\x31\x88\xd0\x0c\x55\xdb\x8f\x8c\x78\x52\xbf\xf5\x78\x82\x93\xe8\x13\x5c\x1a\x82\xce\xba\x89\x1d\x65\xea\x00\xdb\x7c\xa9\xcb\x50\xc2\x8f\x81\x4a\xab\xda\x2a\x2c\x74\x0e\xa2\xc5\x22\xb9\xe4\x5e\x55\x5a\x11\x96\xb9\xa7\x70\xf7\x8b\x6b\x76\x33\x34\xf1\x46\x75\x37\xcc\x03\x8f\xe1\xa1\x18\x8f\x0a\xe3\x71\xeb\xf8\x1d\x9e\x09\xfb\x5a\x21\x3c\x44\xba\x5a\xf1\xba\x5b\x99\x4a\x70\x7e\xd8\x54\x18\xae\x02\x74\xa5\x66\xef\xe4\x57\x15\x37\x45\x24\x36\x12\x95\x54\x59\x4c\xed\xd6\xc2\x1d\x0a\xfd\xfc\x53\xc6\x2f\x11\x65\x81\xc0\x49\x3e\x5e\x26\x51\xbe\xbe\xbe\xbe\x5e\x1f\xb5\x44\x50\xd0\x5d\x05\x2e\x71\xfc\x5b\x6c\xdf\xdf\x9f\xde\xdf\x9f\xfe\xb5\xef\x4f\xf9\xe5\x29\x85\x15\xa1\x64\xfc\x0e\xf0\x7f\x37\xd7\xf6\xf6\xdd\x2c\x0b\x74\x43\x0f\xe2\xd6\x3d\x2a\x4b\x13\xb1\x78\x2e\xb2\xfc\x53\x94\x53\x5a\xa6\xbb\xd6\xb2\x30\xc7\x48\x29\x2e\x26\x93\x09\xce\x71\x5a\x22\x9c\x9e\x17\x50\x68\x94\x67\x17\x05\xce\xd7\x60\x77\x67\x1e\xe0\x2e\x48\x1a\x67\x17\xa0\xa5\xd0\x3c\xc4\xa3\x07\x0f\x78\xce\xe0\x1f\xaf\x5f\xbd\x2c\xcb\x05\x77\x78\x29\x38\xa5\x99\x8a\xf6\xfd\xd0\xc0\xf0\x78\x48\x1e\x32\x4d\x33\xca\x0b\x12\x92\x62\xda\x97\x34\x8b\xf1\x9a\xe1\x3f\xc9\xa9\x53\x0e\xfe\xf3\x3c\xa1\xa3\xe3\x1b\x5a\xb7\xdf\xb6\x99\x6b\x86\xcd\x7f\xbc\x7c\xb7\x6d\x54\x37\xcb\xb7\xbb\xfd\xca\x52\x42\x62\xa0\x2d\xbc\x15\x08\x75\xef\x9e\x41\x6e\xa2\x22\x3d\xb8\x10\x64\xfe\x80\x69\x2f\xe5\x4d\xb3\x51\x5e\xdf\xea\x67\x59\x51\x06\xa8\x24\x73\x9c\x29\x7d\x20\x6c\x1b\x34\x07\xed\x23\xf8\xef\xea\x0a\x75\x39\x8d\x27\xd9\x38\x4a\x68\x62\xf8\xe4\x9b\xdd\x6f\xba\x9a\x16\x92\x57\x42\x77\x3d\xfe\xeb\xea\x0a\x6d\x36\x0a\x3e\x8b\x1c\x2f\x20\x52\x13\xbe\xb0\xd0\x6e\xc9\x3d\x1c\xf0\x9d\x76\x0e\xd1\x62\x94\xe3\x28\xbd\x86\x08\xb0\x2c\x48\x39\x9b\x37\x85\x29\xee\x7e\x4e\x3b\xac\x99\x6d\x19\x1e\x4f\x74\x6c\x69\x32\x93\xd9\x01\xf3\x9e\x8e\x56\xaf\x8b\x4b\xbc\x07\x9a\xae\xc3\x00\x41\x48\x09\x48\x30\xf0\x97\xef\xb6\x55\x58\x44\x21\x2d\x69\x18\xd5\x10\xcc\xb7\x7d\xc3\xdb\x97\x55\x9b\x31\xb4\x9e\x6d\x06\xc8\x2a\xcf\x16\x38\xed\x75\xdf\x1e\xbf\xff\xd0\x0d\xd4\x8c\x07\x0c\x53\xf2\x26\x86\xc1\x2a\x2f\xb3\x2f\x71\x14\xe3\xbc\xd7\xa5\x72\x23\x4e\xcb\x47\xf4\x00\xda\x0d\xba\x54\x20\x26\x63\xd8\xca\x86\xbf\x16\x4a\x1b\x27\xaf\x72\x38\x36\x1a\x68\x81\x85\x09\xb8\x4c\xc7\xda\x69\xd3\x56\xb1\xfa\x2e\x5d\x17\xda\xd5\xad\x3f\x76\x6b\xdd\xbc\x16\x76\x20\x2f\xa1\x64\x72\xe7\x53\x4c\x85\x49\x0a\x3c\x18\xa8\xb4\x85\xa7\x07\x9b\x2c\xc1\x83\x24\x9b\xf6\xe0\x15\x00\x8b\xce\x40\x26\x97\xb2\x6a\x71\x80\x34\xf5\xe4\x0a\xdf\x69\x5c\x53\x12\x66\x93\x29\xc6\x5d\x67\xb2\x4c\x85\xca\x38\xf4\xe0\x88\x59\xeb\x1e\x66\x69\x8a\xb9\x2d\xb6\x98\x69\xf7\x72\x41\xde\xd9\x89\x6e\x08\x97\xee\x1f\xf0\xe7\xb2\xa2\xbf\xbc\x84\xf6\xd6\x81\x9b\xf8\x5a\xbd\x6c\xea\xe1\x3b\xde\x54\xcf\xd7\x76\xa3\x1d\x6b\xa5\x2e\x07\x08\x2a\x6a\xa0\xa8\x03\xc9\x1b\x6a\xc8\x8a\x67\xfd\x28\x2f\xfd\xa4\xf6\xa1\xcc\xc9\x74\x8a\x73\x16\x0c\x84\x92\x12\x48\x0a\xd2\x83\x21\x45\x46\x13\xf5\x41\x0f\x7c\x24\x68\x06\xf4\x6c\x47\x8c\x10\x16\x77\x25\x5a\xb4\x18\x43\x0a\xde\x69\x8b\x32\x2a\xf1\x78\x16\xa5\x86\xb7\xf7\x9e\x7d\x67\xa4\xe6\x2b\x8a\x2f\xc1\xec\x18\xae\x6a\x77\xe9\xb6\x6d\xf3\xb1\x75\x5f\x0c\xcf\x16\x94\x67\x83\x8b\xab\x1f\x2d\x56\x8c\xa4\x2d\xe7\xde\xa9\x15\x9d\x8a\x3f\x2f\xbd\x8a\x3f\x79\xe3\xb4\x32\xe5\xca\xea\xcd\xce\xda\x97\x54\x4e\x97\x4c\xcf\xeb\x6a\x82\xd4\xc6\xe0\x99\x17\xb3\xd6\x62\xa0\x16\xff\x07\x56\xac\xa7\xef\x26\x92\x9f\x7c\x35\x86\x64\xf7\xa7\x8e\x27\x39\x01\x11\xe8\xaa\x56\x17\xe2\xc9\x25\x5d\x6d\xec\x2d\x10\x2c\x6d\xba\xa6\x2a\x56\x36\x29\x78\x0b\xd8\xdc\x17\xa4\xb0\x20\x94\x98\xb6\xd0\x40\x0f\x0c\x69\xb7\x44\x93\x88\x24\x38\x1e\xa0\x63\x7a\x30\xbb\x20\xf4\xb0\x11\x41\xf4\xa0\xea\xb5\xac\xb5\xe9\x9b\x1b\x13\xb7\x52\x71\xd1\xb3\xde\x42\xc7\x21\xfa\x4e\xfe\x05\x46\x1e\xdd\x5b\xf3\xc5\x38\x44\xdd\xed\xc1\x66\xd7\xcc\x13\xaa\xc7\x6e\x8a\xcb\x8f\x09\x29\x4a\x9c\x92\x74\x6a\x01\x49\xf5\xe1\x99\x22\x32\xcf\x85\xb4\x8a\xa4\xef\x5b\x10\xc2\xa8\x8b\xa2\x43\x9f\x30\x47\x7d\xa0\xa3\x69\x4f\xc4\xca\x63\x64\xd0\x09\xb7\x1f\x07\x1d\x2a\xfe\x76\xc2\x27\xf4\x97\x21\x57\x77\xc2\xad\x6f\xaf\xcf\x82\x9d\x9d\x7b\xb5\xc0\xbd\x5a\xe0\x2f\xae\x16\x50\x76\xd5\xf0\x32\xec\x8e\x6c\xaa\xe5\x3b\x11\xfd\xb4\x39\x22\x53\xe6\x62\x62\xf0\x2b\x3b\xbd\xb3\x7b\x91\xf8\x15\x9e\x98\xe7\x19\x19\x3f\xee\x52\x7b\xcd\x64\xec\xd4\x0c\x82\xad\xfe\x8b\x19\xed\x7d\xcf\x34\xd8\xfa\x9e\x15\x46\x0f\xd1\xb6\xfb\x1c\x0a\x2c\x00\xbb\x68\x43\x4a\x71\xc8\xf6\xed\xe7\x11\xef\xde\xf2\x93\x62\x94\xa2\xa3\x67\x07\x6f\xf8\x24\xc7\xe8\xbb\x6f\xd1\x38\x9b\x2f\x96\x3c\x9c\xc4\xe8\x12\xcd\xb3\x73\x92\x4e\xb5\x40\x49\xbb\x68\x3c\x8b\x72\xd8\x37\xd8\x4d\x6d\xcc\x4c\xab\x84\xbd\xb0\x80\x4e\x30\xb3\x1a\x2f\x33\xda\x20\xc3\x55\x81\x7a\x07\x68\x1f\x6d\x6d\x06\xe8\x19\xfd\x7f\x2b\x40\x83\xc1\x20\x40\xff\x87\xf6\xd1\xce\x37\x7d\x7a\x62\x42\xc5\x02\x8f\xc9\x84\xb0\x85\x74\xf4\xfe\x78\x6b\xe7\xf1\xd6\x63\xdb\xe4\x8c\x14\x19\xa4\xf3\x71\xb8\xfe\x39\xaf\xd9\xc3\x43\xda\x11\x3a\x40\xf3\xaa\x4d\xbf\x69\xe6\x12\x5f\x2c\xc0\xf8\x8b\x55\xb3\x7e\x33\x52\xfc\x28\x4a\xf5\x79\xa4\x23\xea\x1e\x74\x07\x14\x2d\x87\x59\x8c\x0f\xca\xde\xa6\xa6\xc5\xa6\x63\xeb\xfe\x9f\x93\xcd\x18\x20\x7b\x1c\x09\xc4\x5a\x66\x27\x8b\x05\xce\x0f\xa3\x42\xa9\xb6\xb5\xec\x62\x39\x2a\xca\xbc\xb7\xdb\x17\xcf\x1e\x79\xc2\x66\xb0\x6b\xdd\xa0\xb1\xdc\x45\x42\xca\x5e\xb7\xdb\x37\x9f\x8f\xa6\x7d\xd3\xda\x6a\x9c\xc5\x74\x70\xa9\xaf\xf3\x48\x38\x98\xa7\x30\x3f\xec\xa3\x03\x2a\x87\xc2\xc7\xf7\xfb\xe8\xff\xfa\x8e\xff\x74\xcf\xcc\xf2\x89\x35\x20\xa5\x7b\xce\x18\xa3\x47\xe8\x00\x6d\xa0\xad\x4d\x4d\x4c\xf3\xf9\x14\x17\xf1\x0c\x1d\x69\xae\x3f\xf8\x35\x23\x29\x1d\xa6\x6d\xb9\x38\x5e\x82\xef\x52\x98\xe2\xd7\xc7\xcf\x29\x61\x6f\x6d\x0a\xa6\xc4\x2d\xfe\x80\xf2\x3d\x14\xf7\xed\xe6\xe3\x5d\x9b\xe0\xe6\x59\xfc\xdd\xb7\x5b\x9b\x55\x84\x66\xd2\x97\xf2\x08\xcb\xa8\x89\x17\xae\xa5\xa2\x1c\xcf\x23\x92\x32\x9d\x12\xcd\x53\xb2\x06\xf7\xaf\x62\xb2\x07\x0e\xac\x4c\x95\xb7\xfb\x96\xe7\x18\x60\x56\x02\x4c\x5a\xc0\x7e\x67\x48\x28\xaa\x49\x10\xe4\x8f\xd2\x92\x39\xa5\x09\xd0\xd6\x66\x1f\xfd\xff\x29\xd6\x36\x9c\x5a\x98\x5f\x1a\xd6\xb0\xdf\x83\x83\xa8\x4b\x96\x54\xf5\x19\xf3\xd4\xfc\x10\x84\x59\x9d\xc3\x3a\x60\x4a\x25\x76\xc1\x0e\x09\xe3\x2c\xcf\x69\x0a\x63\x9f\x62\xbe\xfc\x93\x33\xd4\xfd\x06\xfb\x27\x81\x5b\x46\xab\x25\xe7\x76\xd5\x89\x5c\xd9\xd4\x4f\x0c\x01\x5c\x96\x73\xf1\x3c\xc2\x22\x2a\x0a\x73\x20\x73\x9c\xbe\x47\x5a\x96\x10\xb9\xe9\x10\xae\x25\x5b\xd3\x35\x6d\x34\x67\xa0\xd5\xd8\xf4\x30\x3b\x2a\x9e\x89\x87\xd9\xca\x83\x91\x88\x48\x88\xb6\x1e\x6b\x2c\x6c\x14\x15\x78\xe7\x31\xda\x87\x32\xea\x61\xfd\xce\x63\xc3\x24\x20\x8e\x41\x54\xe7\x7b\x60\x8f\x15\x0a\xd0\xd6\x37\xa6\x02\x4b\xf6\xf3\xd9\x28\x4a\x7b\xac\x98\xc9\xfc\xac\xc5\xcc\xfc\x17\xe8\x0b\xf7\x19\x1d\x7a\x99\x19\xbb\x17\x9d\x3e\x04\xce\x2c\xf3\x4b\xb1\xa2\x99\x16\x0d\xec\x77\xdf\x32\x3f\xfa\x69\x56\x72\xa1\xec\x7b\xf2\x43\x67\x0a\x12\x09\x73\x2b\x33\x51\x48\x2d\x66\x11\x93\xd6\x60\x7f\xfb\x3c\x4e\x96\x05\x39\x97\x51\xf9\xc8\x88\x24\xa4\x94\x02\xce\x28\x4a\x3f\x0d\x47\x79\x94\x8e\x67\xa8\xc0\xf9\x39\x19\x8b\x0d\x30\x62\xbe\x35\x3b\xdf\x0f\xc9\x0f\x03\x9b\x86\xa4\x0b\xfe\x42\xec\x42\x13\x9c\xd3\x6d\x28\x4a\xa6\x59\x4e\xca\xd9\x1c\xc5\x98\xbd\x6a\x05\xb6\xc4\xe5\x1f\x9c\x0e\x2e\xc8\x27\xb2\xc0\x31\x89\x40\x08\xa2\x5f\xc3\xa3\xb4\xc4\x79\x1a\xb1\xd7\x12\x1f\x9f\x45\xe9\xa7\x8f\xdc\xb1\xe7\x47\x36\xaf\xff\xbf\x9f\xf8\x48\xd3\xe9\x47\x3a\xc4\x8f\x10\x61\xe8\x63\x4c\xa6\xc4\x79\xbd\x21\xa6\xc6\x47\x91\x23\xb1\xa7\x8a\x19\x18\x8b\xc9\xc9\x3c\xdb\x6c\x0b\x5a\x7d\x66\xaf\xc8\x91\xc5\x16\xf9\x8c\x1e\xb2\x7d\xaa\xfb\x8f\x17\xdd\xbd\x35\x2f\xcf\xe4\x3c\xb6\x67\xed\xdc\x3d\xbd\x82\x0d\xd4\xdd\x04\x51\x09\x5a\xd1\xcd\x5f\x28\x3a\x9e\x53\x6c\xa0\x7d\xd4\x63\xe2\x54\xef\xbb\x27\xe8\x91\x6a\xa2\x2f\x9e\x11\x3c\xda\xb6\xf6\x5b\xe9\xda\xc0\x6c\x4a\xab\x93\x37\xd8\xa0\x60\xe3\x4c\x44\xc3\x15\x10\x36\x0b\x4a\x4c\xd2\xa2\x24\xe5\xb2\x14\xee\x69\x49\x8c\xd3\x92\x6e\x5a\xb6\x0b\x73\x56\xcb\x51\x1a\x83\xf3\x84\xea\x67\x35\x45\x20\x64\x59\xf9\xae\x06\x02\x4d\x75\xb4\x96\x3a\xd0\x54\x47\xb5\xd5\x59\x85\x17\x99\x3d\xa9\x0a\x9b\x5b\xc9\x19\xba\x2f\x3e\xbc\xa4\xf3\x20\x5e\xbb\xe8\x18\xd0\x52\x65\xdf\xfa\x16\xbf\xce\xea\xf8\xb5\x08\xb0\xc5\x90\xcb\x23\xfe\x92\x02\x31\x87\x0c\x1a\x1f\x77\xe4\x4e\x70\x53\x51\x29\x6f\xca\xbd\xc8\xa3\x24\x11\xca\x11\x52\xaa\x96\xa4\xd0\x79\xa4\x39\xc1\xa8\x95\x13\x88\xee\x4c\x83\x30\xb2\xd2\x85\x3f\xe5\x49\xa3\xf1\x8a\x40\x62\x01\xba\x0e\xec\x33\xcf\xeb\xc7\xac\xfc\xdb\x7b\x47\x15\xa0\xcc\xa3\xe1\x81\xb1\xe9\x9a\x1d\x77\x94\x16\x25\x0c\xff\xfd\x8f\x17\xa7\x9b\x8f\xbe\x3b\xfb\xb2\x7d\xdd\x7b\xf1\xe1\x25\xfd\x7d\xf0\xe8\xff\xce\xbe\x6c\xed\x5c\x5f\xc9\x8f\x9d\xcd\x60\x67\xeb\xba\xff\x3f\xc3\x41\x09\xca\x5a\xb9\x81\xf7\xd1\x83\x07\x52\xca\xa9\x62\x0c\x1a\x38\x73\x95\xb2\xb5\x22\xc2\xb8\x03\x42\x38\xfd\x7b\xd1\xf6\x5c\x2d\xc1\xbb\xc1\xdb\x73\x77\x25\x59\x88\x53\x83\xd2\x1f\xfb\xec\xec\x42\xec\x70\x7f\xde\x37\x37\x1c\xf6\x04\x91\xb4\x62\xe0\x06\xf7\xb9\x9b\xa1\x7b\xd9\x48\xab\xc1\x6f\x37\xdf\x9b\x4e\x71\xc9\x45\x4a\x3a\xd2\x62\x39\xa7\x80\x27\x05\x3f\x3e\xcc\xb3\xf8\xd1\x77\xdf\x3e\xda\xda\x94\xd9\x70\xc6\x85\xde\x8d\xb3\x04\xf5\x8e\xde\x1f\x0f\x8f\x5e\x1c\x22\x7a\x6e\x08\xb7\x37\x37\x77\xfa\x36\x4f\xd6\xaa\x75\x4f\xa1\x5a\xae\x33\x70\x91\xd7\x72\xd8\xfc\x4c\xb8\x1d\xa0\xed\x76\xb6\xab\x3a\x53\x35\xb6\x14\x84\xa7\x03\xf4\x8f\x77\x2f\x7e\x72\x9c\x44\xc9\x02\xfe\xd1\x54\xd6\xe8\x4e\xaa\x06\xd9\x34\x3c\x45\x00\x3d\x70\x68\xe4\x0c\xf9\xdb\x00\xed\xf6\x51\x88\xba\xdd\x56\xe3\x1e\x27\x04\x1e\x96\xc9\x0e\x82\xf2\x89\xa4\xf6\xf8\x28\x16\x7e\x3a\xf8\xf9\xf8\xc7\x7f\x1e\xbf\xfb\x5f\x7b\x56\xa1\x8e\x8a\x39\xb5\xeb\xf7\x4e\x2e\x03\xba\xf5\xd8\xb7\xb6\x56\x1f\x39\x5f\x4d\xfe\x73\x89\x7b\xf0\x70\x87\xe6\x54\xe0\x0c\x2f\xf2\x9c\x43\xf4\xd7\x93\x7c\x70\x3e\x2f\x4f\xc6\xa1\xc3\x1d\xf0\xae\x76\x88\xad\x3c\xca\x88\xf3\x87\x3c\xa5\x18\x27\x54\x76\x46\x31\xcf\x33\x5b\x8f\xfb\x01\xda\xde\x94\x97\x30\x86\x94\x27\xd0\x6b\x0d\x52\x14\x6e\xb7\x40\x2b\x5c\x05\x1d\x41\x16\x53\xea\xeb\x7a\xc5\x4e\x68\x7e\x5e\x9f\x05\x3b\xbb\xf7\x6a\xfc\x7b\x35\xfe\x5f\x5c\x8d\xcf\x55\xf8\x8b\x71\xbd\x71\xdf\x2d\xcc\xf1\x3a\xcb\x02\x83\xb0\x3e\x2e\x3b\x7b\x2b\x05\xa9\x6a\xb0\xe1\x63\x7a\xa6\xc5\xd8\x6b\x21\xb6\x88\xca\x59\x80\x52\x6c\x58\x83\x7f\x04\xcd\x85\xf3\x10\x55\x5c\x7d\xeb\x81\x71\x85\xa3\x02\x66\xaa\x10\x81\xd7\x12\xfa\x1f\x4b\x55\x59\x63\x79\x1f\x0c\x5c\xb1\x14\x09\xbd\x2f\x14\x3a\x54\xe5\xa5\xd7\x3f\xab\xd8\x20\x4b\x7b\x5d\x18\x55\x57\x0f\x24\xd9\x37\xec\xa9\xc1\x16\x02\xb3\xb7\x85\x47\x6f\x0f\x91\xba\x85\x66\x2f\x0e\xbb\x01\xd2\xc3\xa3\x7f\x64\x6c\x90\xdf\x95\xf7\x6c\xbf\x83\xde\x1e\xa4\xb1\xde\xbe\xd6\x7c\x65\x65\x68\x4d\xbe\x39\x78\x75\xf4\xfe\xc3\x8b\x37\xb0\x82\x0e\x8f\xdf\xbc\x79\x71\xf8\xe1\xe8\xf8\x0d\x7a\xf7\xe2\xfd\xdb\xe3\x37\xef\x5f\xbc\xaf\x6c\x35\x8e\xca\x48\x6f\x96\x7e\xeb\x9b\xd3\xf0\x21\x37\x2f\x9c\x47\x9f\xc7\xd9\x7c\x91\xe0\xcf\xa4\xbc\x0c\xd1\x63\xa0\x2c\xab\x87\xa0\x0b\x95\x76\x0d\xb4\x2a\xcd\x31\xa5\x27\xa6\x08\xb7\x5b\xf8\xb2\xe6\x58\x6a\x90\xd8\x6f\xa6\xc1\x83\x23\x03\x7f\x89\xd1\xc5\x8c\x8c\x67\x68\x1e\x95\xe3\x19\x17\x5f\xd9\x26\x44\x19\x5a\x6c\xde\x8d\xbb\x2e\xfc\xa1\x69\x7f\x94\x60\xb8\x8e\x72\x7a\x0b\x46\x0b\xfe\x18\x9e\x64\xd2\xfb\xe8\x27\xe4\x53\x78\x2b\x47\xe2\x33\xd7\x23\xb9\x2c\x4c\xc7\xca\xc1\xf6\x1c\x28\x27\xc0\x7e\x55\x1c\x52\xa8\x86\xf7\xdd\xae\xe8\xda\xc1\xe2\x84\xe4\xd8\xf0\x10\x60\xa3\xab\x6a\x3c\x74\x28\x9e\xd6\x6b\xc0\x55\x50\x54\xd7\x6e\x86\xfe\xc5\x38\xc1\x25\xae\xab\xc1\x1e\x8c\x8d\x1b\xfd\x55\xf6\x2f\x74\xd7\x02\x42\xe4\x04\xc1\xea\x03\xe5\x0e\xb3\xea\x4a\x99\x27\x18\x94\x31\x57\xb2\xa4\x1c\xac\xad\x09\x61\xd0\x24\xe1\x35\x5b\xed\x01\x2f\x34\xa9\xf0\xa7\x78\x9e\x26\x1e\x99\x85\x75\x43\x0e\x7d\x55\xd9\x6c\x30\xb0\xe4\xb5\x9f\x99\xd7\x5a\xe5\x8b\x57\x2c\xf1\xe7\x2f\x1e\x1d\xbe\x3c\x79\xf3\xbf\x2f\xde\xc9\x7a\x62\x3c\x9e\x2d\xd3\x4f\x38\xe6\xaf\x4c\xd8\x0b\x52\xfe\x37\xc8\xf1\x22\x89\xc6\xb8\x37\xfc\xd7\xf5\xe9\xbf\xd2\x7f\xe5\x67\x4f\xff\xf5\x65\x38\x0d\xba\xd7\x57\x8f\x1e\x5d\x7d\xe9\xf6\xc1\xfd\xee\x17\x2f\xfc\xbf\xce\x44\x89\x53\x5e\xe6\x8c\x16\x3a\x15\xa5\xce\x4e\xfd\xe5\xec\x52\x46\xa1\x8a\x32\xaa\x2d\xad\x25\xd9\x90\x56\x86\x5f\xf3\xd1\xec\xae\xe0\xa4\x06\x06\xdc\x35\x0b\x88\xd7\xf8\xcb\x70\x08\x77\xa0\x98\xbb\xc7\x00\xcf\x1b\x50\xc1\x9a\x43\xfa\x34\xef\x90\x66\x99\x2b\x97\xfb\xa1\xb1\x60\xd0\x06\x62\xef\x61\x0d\x51\x5d\xde\x59\x5b\x9c\xcc\x35\x36\xf3\x19\x9a\x41\xdf\xb5\x52\x86\x49\xcd\x9a\xbb\xf8\x54\x67\xf6\xed\xce\x20\x23\xb6\x3a\x37\x02\x03\xdf\x63\xe9\x18\x27\xe0\x2c\x59\x3c\xea\x34\xca\x8c\x13\x1c\xe5\xc2\xfa\xcb\x6a\x85\x27\x5b\x0b\xda\x0f\x04\xbe\x1b\x4a\x51\x91\x6f\x8f\x33\xcb\xdb\x7b\x9d\xfe\x57\x6b\x05\xca\x71\xa6\xc3\x5f\x07\x68\x6b\x73\x73\x13\x3d\x64\x97\x33\x9e\xbb\x56\xaf\x23\x08\x78\xc7\x07\xd8\x11\xf8\xa2\x1c\xa4\xc0\x9c\x5e\x58\x5c\x12\xfe\xce\x6f\x75\x54\xb9\x33\x66\x91\x08\x04\xdc\xe1\x36\xa0\x4e\x87\x19\x8b\x60\xc1\xb4\x4d\xb3\x59\x4b\x5b\xaf\x83\x73\x67\x40\x94\x47\xfe\xc4\xb7\xd0\x28\x8e\x0b\x3d\xca\x32\xb7\x72\x70\xa5\x31\xa6\x1e\x0e\xd6\xd8\x86\x2b\x0e\x06\xfc\xac\x4d\x98\x7f\x7a\xce\xf5\xe6\x22\x64\xbc\xc1\x7d\x8f\x62\x56\x2a\xca\x73\x72\x8e\x75\x86\x1b\xc5\x72\xf6\x44\x7b\x35\x1c\xd6\x03\x6d\xb8\xa7\xaf\xb3\x7e\x25\xec\xc2\xee\x92\x6f\xb5\xe8\xea\x4a\x7c\x9d\x6e\x9e\xc9\x2d\x13\xae\xb0\x59\xdf\x14\x34\x4f\x30\x4b\xb0\x44\x5d\xa2\xf3\x6e\x5e\x68\x5f\xf6\xa6\x4e\xe2\xa5\xa0\x03\xd9\xb0\xa8\x5b\xec\x6a\x62\x1d\xe9\x2b\x95\xc5\x62\xe7\x66\x29\x4c\x2c\x87\xd3\x17\x68\xdc\xe9\xfe\x1e\x6b\x68\xe6\x44\x5c\x83\xda\x1a\xdb\xd0\x49\x96\xf7\x28\x5e\x3e\xe1\x4b\x76\x52\xf4\x0d\xc0\x34\xf0\xed\xf9\x81\x06\xb3\xa8\x38\xbe\x48\xdf\x42\xd4\xa1\xf2\x12\xa2\xca\xf5\xed\xa0\xe2\x5e\xf4\x7c\xc2\x97\x67\xd5\x96\xa0\xdd\x2c\x45\x47\x6f\x0f\xbb\x76\x00\x74\x2e\x5b\xd4\xd4\xe9\x98\x59\xa8\x65\x72\x28\x54\xc1\x20\x27\x31\x1f\xd0\x48\x3b\x6e\x90\x02\x15\x25\x61\x8e\xe6\x49\xac\x11\xb5\x6e\x42\x5a\x89\xf0\x06\x9b\x4f\xf7\xb4\x24\xe4\x00\xba\x7b\xe4\x98\xf7\x23\x60\x54\x60\xf6\x6a\x9a\xa5\x98\x6b\x9e\x7a\xeb\x1f\x6d\xb1\xff\x22\x27\x25\xf8\x4f\xb1\xb8\x91\x06\x62\x1d\xa1\x3e\xba\x67\x28\xce\x60\xd6\xd7\xab\x6a\xe7\x0a\x24\xef\xd0\xeb\x1e\x4e\xac\xe9\xf4\x63\xd5\x8b\xdf\x1b\x4f\x61\xf4\x4d\x76\xcf\xe0\xdc\x2b\xa0\x48\xa0\xa9\x19\x4b\xc8\x73\x84\x6a\x3c\x6b\x8a\x5e\xc6\xda\x33\x60\xdf\xa8\x9a\xde\x7b\xa0\x55\xc5\x06\x49\xd5\x55\x96\xe9\x2d\xf6\x51\x64\xfd\xf9\xf6\x49\xcb\xec\x8e\x6b\x13\xad\x33\x8a\xe3\x9e\xe7\x9f\xd9\x12\x2c\xb2\xd5\x2b\xb4\x4e\x77\xc3\x66\xb7\x1b\xdd\x0e\x2a\x74\x23\xee\x81\x6e\xd3\xad\xf8\x20\xbc\x02\xcb\x4a\x54\x2c\x17\x8b\x2c\x2f\x41\xb7\xc6\x6e\x6a\xdf\x1e\x22\xa9\x55\xe9\x1a\x36\xe2\xd5\x84\xb9\xc2\x9b\x8a\xd5\x17\x63\x33\x95\xad\x44\x61\xde\x63\x3d\xd0\x54\x83\xd1\xbd\x74\xb4\x68\xef\xa6\x95\xde\x6f\x5c\x3d\xae\xc2\xa0\xe3\x03\xdb\x78\xb4\xad\xec\xb6\xaf\xcf\x82\x9d\x6f\xee\x55\xba\xf7\x2a\xdd\xff\x0a\x95\x2e\x7f\x73\x71\xab\xb7\xda\x07\x51\x9e\xa5\xe8\x7f\x97\xf3\xe8\x9c\x14\xe8\xfb\x88\x7e\xfe\xed\x13\xfb\x1c\xcc\xb1\x57\xdd\x3b\x1c\xa2\xa3\x94\x94\x24\x4a\xc8\x7f\x30\xfa\x3b\xeb\x05\x25\xd4\x08\x15\x60\x89\x25\x0c\x6e\x60\xa0\x74\xa9\x1a\x5e\xa6\x07\xa0\xd5\x15\xc5\x44\x68\x07\x1e\x71\xea\x28\x0e\xd1\x66\xd3\xcd\x1b\xb3\xf6\xa0\xc3\xb7\x3d\xe9\x7a\xcd\x4c\xbc\x1e\x74\xd5\x7b\x39\x11\xdc\x6a\x22\x10\x0a\x2d\x29\x83\x1e\x8f\xdf\x5d\xf6\x58\x25\xd0\x54\x3d\x13\x51\x8d\xc8\x12\xee\x76\xbd\x6e\x89\xb4\x11\xd0\xf6\x9c\xde\x0f\xd7\x38\x7a\x2a\xbc\xef\xb2\xb6\x02\xde\x98\xe1\x44\x95\x65\xf5\xab\x54\xcb\xa2\x49\xc7\x98\x47\x9a\xed\xae\x77\xb5\x10\x3f\x51\x7c\x4e\xcf\xa8\x62\x76\xd0\xd1\x73\xc8\x11\xbd\x93\x93\xb6\xb1\x51\xe5\x77\xa8\xea\x61\x10\x89\x43\xb7\x1a\x95\x2d\xde\x0c\xf1\x91\xca\x74\xf1\x4c\x88\xfd\x4f\x0f\x4c\xfc\xc1\x50\xb3\x43\x21\x69\x78\x21\x70\x20\x0f\x8f\xc2\x80\xc8\x6f\xaa\x23\x95\x75\x4d\xa1\xce\x3c\xaf\xbd\xad\x06\xfc\xe6\x19\x02\x0d\x56\x7b\x56\x58\x5e\x96\x68\x5d\x86\x32\x1f\x3f\x9a\xce\x99\x03\x3d\x95\x6d\x0f\xf0\x39\xce\x2f\x7b\xd0\x7c\x54\xe2\xf7\x24\x9d\x26\xf8\x35\x43\x78\x1f\x85\xc8\x9b\xa1\x6a\xe2\xd3\x2a\x3b\xe2\x07\xe7\x13\xd8\x57\xaf\xbe\xb9\xf0\x2e\xe8\x46\xb3\x20\x12\x69\x8c\x22\x0d\xdb\x22\x9e\x21\xe6\x67\x7f\x7f\x9f\x51\x8d\x0e\xc4\x5d\x32\x08\x58\x7a\xe6\xa6\x60\xec\x5a\xb7\xeb\xab\x8e\xcb\xb0\x96\x8f\xc9\xe1\x10\x65\x69\x72\xa9\x92\xe8\x24\x51\x21\x4f\x63\x2e\x62\x3d\x56\x3b\xf4\xd6\xa8\x8b\x31\xa2\x11\x38\x05\x6d\x60\x47\xcf\x28\x50\xb5\x57\x6f\xde\x71\x8b\xbf\xb0\xba\x0a\xc6\x54\x79\x55\x42\xc0\x89\xfb\xa0\x3c\xe2\x8b\xa2\x27\x78\x4f\x1f\x4d\x08\x4e\x62\xcb\xf4\x80\xb7\x62\xf4\xd4\xe2\x39\x7a\x07\x2d\xc6\xc3\xba\x66\x91\xa1\x48\xb6\xdc\xee\x0b\xb2\x70\x5f\xe8\x39\xec\x4d\xc0\x0e\x04\x6b\x13\xdf\x9c\xc5\x99\x7a\x78\x47\x56\xe4\xf5\x71\x39\x91\x8a\x81\x8f\xef\xc5\xc0\x7b\x31\xf0\xaf\x2d\x06\xaa\xf7\x79\x6c\xd1\xdc\xd5\x0b\xbd\xbb\xb9\xbb\xa7\x20\xaf\x85\xba\xb1\xd2\x58\x19\xce\x89\x3c\x54\x86\xb0\x42\xa6\x9f\xda\x29\x92\xbb\x60\x13\xb9\xf4\xd3\xb8\xb8\x07\x9e\xa7\xf2\x95\x64\xb0\xa9\x81\x81\x8f\x7e\x3d\xf2\x9b\x32\x84\xd6\x33\xb4\x12\xcc\xf3\xb3\xaf\x88\x95\x63\x28\x5d\x41\x63\xf0\x3a\x4a\xa3\x29\x56\x8e\x00\x28\xcb\x62\xa8\x30\x54\x01\xc2\x75\x89\x02\xd7\xf6\xfb\xb9\x81\x21\xa7\xe2\x7c\xde\x60\xff\x1e\x63\xca\x61\x48\x6a\xfa\xfb\xb4\xc4\xbf\x51\x54\x30\xef\x10\x55\xc1\x27\xa6\x18\xbc\x56\x7a\x36\x29\xd3\xf3\xbc\xed\x68\x54\xb4\x69\xb6\x07\x24\xe6\x20\x82\xb7\x51\x19\x5e\xc2\x70\x2f\xaa\xc5\x2f\x91\xc4\x21\xed\xf8\x84\x6f\xc3\x82\x0a\x36\x32\xa5\xc9\xed\x31\x73\xce\xa9\x2e\x29\x78\x34\x0e\xbe\xed\xca\x71\x0e\xd0\x6b\xca\xca\x09\x2e\x78\x94\x50\xc0\x87\xe3\x95\xd2\xf0\xf4\xd9\x1a\x6f\x62\x50\x57\x6f\x96\x49\xa2\x5c\x78\x04\x54\x8a\xc4\x9f\x09\x5c\x9b\xf9\x70\xf7\xc7\x0c\x00\xd3\x46\x08\xa7\xa5\xb9\xf1\xb3\x8e\x65\xd3\x70\x1e\xe9\xb8\x15\xa2\xe7\x41\x3e\x2d\x1a\x11\x0b\x0a\xc1\x02\x7d\x01\x75\xe0\xb5\x7a\x28\x90\x66\xa5\x1f\x93\x7a\xed\xad\x43\xd2\x50\x99\x52\xe3\x42\x4d\xbe\x64\x98\x2d\xe5\xf1\x84\x87\x9b\xf0\xfa\x94\xf0\xe0\x8c\xfb\x7d\x65\x54\x07\x18\x97\xc7\x4d\x1b\x47\x0c\xf4\x88\x42\xba\x28\x32\x28\x4e\x26\x79\x70\xa1\xd5\x52\x8b\x8a\x75\x0f\x6b\xad\x20\x1f\xdf\xcb\x46\x4f\x69\x4b\x80\x94\xee\x18\x03\x04\xc1\x58\xeb\x02\xf8\xa0\xa7\xea\x37\x23\x6d\x28\x72\x46\x79\x81\xf6\xd9\xe0\x66\xdf\xc1\x3a\x63\xf6\x32\x3e\xa8\x8e\x79\x17\xf1\xcc\x1b\x6f\xfd\x41\xd1\xf4\x4d\x5c\x81\x7b\x4f\xc0\x14\x15\xa1\xd4\x46\xa1\xbd\x53\x81\x83\x1b\x38\xf3\x3c\xf5\x02\xc8\xaa\xbc\x81\x4a\x38\x2e\x7c\x21\x8a\xc4\xe3\x29\x41\x87\x2b\x44\x2a\x8a\xc4\xa2\x6d\x85\x84\x76\x31\x87\x74\xdf\xac\x7c\x13\xb1\x5d\x26\xaf\xec\x89\x99\x0b\x13\x00\xac\x2d\x03\x1d\x10\xf2\x74\x76\xd1\x93\x67\x14\xbf\x0a\x44\xe8\x32\x40\xad\x54\xa1\xc9\xa8\xf3\xb1\xac\xeb\x37\x1c\x54\x09\x7f\xb9\x0c\x9f\xa6\xa8\x35\xfa\x55\x47\x17\xcd\x10\x43\x1b\x2d\x49\x12\x03\xc2\xf8\xa0\x68\xa6\xe3\xec\x16\xb8\xfd\x87\xe3\xe7\xc7\xeb\xeb\xeb\x20\xdb\x77\x0b\xb4\x9c\x26\x97\x03\x1e\xd0\x98\x9e\x06\x96\x05\xdd\x10\x4b\xd9\x4a\xaa\xf9\x97\xa5\xbf\x85\x51\x8d\xbc\x1e\xa1\x8c\x03\x32\xe4\x63\x6b\xc3\xf3\x52\x36\xfa\xf5\x94\x66\x9f\x6e\x9e\x9d\x51\x99\x4b\xff\xbc\xba\x92\x46\x9b\x36\x28\xfb\xb1\x05\x65\xe8\x58\xf6\xfc\xf7\x44\x56\xed\x00\x89\x34\x2e\xec\xa0\x57\x22\xaa\xea\x0a\x55\xde\xa8\x2b\x8b\x53\x16\x0f\x25\xf5\xbf\xc9\x42\x8e\xd3\x6f\x2e\xbc\xab\xa3\xf0\x2a\x4e\xa1\x91\x15\xce\xc2\x17\xb7\xc0\x38\xa8\x43\x5b\xa6\x38\xa9\x6e\xa5\xd4\xe5\x8c\x11\x98\x45\xda\xd6\x79\xec\xf2\xec\x86\x19\x3c\x6f\x47\x67\x66\xd2\x22\xd2\xb2\x9e\xf1\xc6\x56\x31\xbb\x6b\x54\x53\x3d\x04\xc7\xf1\x13\xfb\x8f\x66\xb5\x75\xfb\x2c\x62\x5e\xe1\x34\x6e\xd6\x27\x72\x0e\xb9\xcc\x31\x5c\x8f\xbe\x7b\x7b\x28\x5d\x35\x31\x3b\x96\x71\x94\x4a\x49\x93\xa4\x5c\xe3\xe2\x77\x0a\x95\xbb\xce\x23\x07\x83\xc1\xb5\x1e\xcf\xcd\xf6\x1f\xa8\xd4\x98\xa2\xa8\x87\x93\x36\x39\xb8\xaf\xf4\x3d\xbf\x0a\x11\x0a\x1a\x30\x1d\xd4\xeb\xb3\x56\x85\x68\x5e\xb2\x42\xab\xf3\x5a\x18\xc0\xb4\xbe\xfc\xfb\xf6\x5e\xeb\x73\xaf\xf5\xf9\x6b\x6b\x7d\xb8\xca\x27\x1e\xdd\xe2\xde\xcf\xa7\xf5\x91\xba\x1a\x5d\xed\xc3\xb8\x93\xd4\xe7\x3c\x7f\x66\x30\x12\x3a\x0c\xd3\xe1\x87\xa3\xa7\x80\x91\x5a\xc9\x7b\x35\x61\xc3\xd6\x94\xc0\x54\xf4\x3c\x16\xfd\xfc\x7a\x0b\x7d\x41\x96\x78\x65\x09\x42\x3d\x5a\xb3\xb6\xb5\x70\x20\x47\xe9\xd2\xf3\x75\xd0\xd2\x36\xab\x6d\xbe\x3a\x7c\xd1\x62\x59\xca\xa7\x6b\x29\xbe\xe0\xd8\xd4\x1c\xe8\x51\xa9\x23\x44\x5d\x09\x67\x45\xd5\x08\x51\x37\x1e\x7d\xf4\xe5\x0a\x39\x71\x47\xf6\x49\x36\x3a\xc5\xed\x1a\x95\x70\xde\x46\x7d\xb9\xa2\xd1\x6d\xb7\xd1\xc5\xb2\x7c\x89\x3f\x37\x0f\xf3\x25\xfe\x5c\x35\x46\x33\xab\x7e\x80\xcd\x6d\x31\xa0\xaa\xa1\xf9\xdb\xb2\xc6\xc5\x77\xa3\x53\x05\x27\x26\x22\x50\x48\x0e\xf8\xd0\x03\xde\x2d\x00\x3e\xab\xd8\xba\x9e\x3f\xdb\x93\xbb\x16\xa3\x9d\x4e\xb8\x03\x5b\xd4\x93\xfb\x2d\xea\x7e\x8b\xfa\x6b\x6f\x51\xea\x62\x02\x97\xb3\x1b\xdd\x4a\x70\xe0\xbb\x7d\x93\x58\x11\x7c\xdd\x17\x7d\xdd\x77\x05\xe2\xbf\x05\x69\xd8\x36\x29\x88\x30\x46\xb6\x80\x16\x3c\x59\x80\x8d\xab\xda\x1b\x67\xe9\x84\x4c\x05\x98\x16\x18\x47\x87\x16\x71\x56\x04\xd8\x05\x7f\xb4\x66\x5c\xcf\xf0\x44\x01\xf3\x23\x9c\xe2\x6d\x64\x40\xa2\x00\x39\x2a\xde\x5f\xa6\x63\xb6\xc5\x18\x51\xf0\x59\xaa\x00\xa3\xac\x38\xc7\x36\x10\x4f\x95\x75\x31\xf7\x44\x3a\x04\x19\x45\xa9\xc8\x66\x3e\x0f\x9d\xfe\x88\x64\x29\x84\x80\xc7\xb4\x36\x37\x06\x52\xe3\xcd\x5f\x08\x82\x16\x70\xf3\xac\x8f\x1e\x3c\x40\xfc\xf7\x00\x94\x82\xc7\x93\x5e\x77\xf3\x73\x97\x39\x2e\xd9\xec\xa3\xa7\xa8\x83\xcb\x19\xdd\x3d\x20\x4c\xe9\xb3\xcb\x97\x51\x31\xeb\xa0\xd0\x4e\x66\xfa\xdc\x8e\x92\x12\xb4\x68\x50\x3f\xe6\xd9\xfc\xd9\x6f\xd0\xd3\x2e\xef\x92\x16\x64\xe8\xd9\x25\x34\x4c\x3b\x7d\x90\xc6\x47\xb4\x9c\x8c\xed\xe5\x85\x64\xe3\x90\xb0\x6a\x3c\xcb\x74\x9c\xe0\xdf\x68\x00\x27\xb4\xad\x86\xae\xeb\x30\x95\x9d\x16\xf3\xa3\x8d\xf3\x30\x5b\xa6\xad\x2e\x99\xee\x60\x1c\xde\xb6\x19\x09\xe9\x43\xa9\x00\x63\xa3\x72\xa6\xe0\x37\xec\xff\x89\x6c\x50\x9b\x0c\x67\x12\x74\x00\xa3\xcf\xb2\x7b\x2f\xca\xd9\x5d\x1f\x10\x5a\x1f\x0e\xee\xe8\x6c\x00\xe1\x80\xab\xcf\x06\x4c\xf7\xc1\xb8\x38\xc1\xde\x1e\x2d\xf4\xce\x2c\x1a\xfa\xb1\xb8\x41\x17\xb4\x1b\x6e\xc6\x5d\x99\xf7\x0b\xa4\xbb\xf1\x3e\x7a\x76\xf0\xc6\x0a\x4d\xc6\x79\x2a\x53\xcb\xb0\xe7\xb3\x5c\x39\x73\xbd\xb6\xc6\x7a\x37\x60\x76\x51\xf2\x25\xcd\x8b\x72\xa6\xd4\x41\x01\xea\xea\x81\x9c\xbb\x01\x1f\xe6\x14\x97\x61\x85\xd2\x53\x78\x2a\x1d\xe8\x05\xf9\x48\x02\xae\xa8\x33\x0a\x9f\x47\x89\xe1\xad\x7d\x60\x85\xd1\x3e\x8f\x12\xc7\x15\x89\x4c\xbb\x5e\x03\xf4\xac\x34\x14\xee\xe5\xef\x26\x83\xe1\x45\x6f\x32\x1c\x5e\xb4\xe5\x80\xda\x9c\x45\x29\x77\x89\x12\xb0\xdb\x6c\x3c\x39\x71\x40\xf7\xf4\x24\xd8\x94\x93\x2f\x8f\x50\x9a\x2d\xa7\x71\x87\x17\xa2\x53\x25\x50\xb1\xfb\x3d\xee\x44\xf3\x47\x75\x9d\x67\x43\xe8\x71\xd0\x19\x3f\x91\xc0\x5a\x20\x49\xeb\x22\x2b\xd4\xab\x61\x79\xd2\x63\x8d\x04\xaa\x38\x36\x67\x79\x34\xc5\x07\x65\x9b\x93\x33\x07\xad\xc4\x91\x0f\x42\x1e\x6a\x6b\xb0\xc4\xd6\x1d\xe3\xd8\x65\x06\x27\xcb\x55\xd0\xe2\x1d\x18\x77\xed\xd8\x30\x26\x0a\x55\x39\x1c\x2b\xf3\xb7\x9f\x6f\xef\xc0\xc4\xaa\x6f\xa2\x67\xc6\x8e\xac\xa1\x49\x91\xf1\x76\xc3\xf2\xf5\x36\x70\x96\xb8\xb2\x7e\xa5\x8b\x17\x5d\xaf\x46\xbf\xb4\x89\x7a\xda\x85\xfd\xb7\x19\x13\x00\xe6\x60\x42\x4a\x74\x5f\x03\x13\x1a\x29\xdf\x62\xd0\xc1\x5a\x05\x65\xcf\x17\x24\x61\x87\xb7\x46\xf2\xe6\xa0\x35\x34\xee\x42\x08\x3c\x6c\x56\xd3\x9f\x2d\xaf\xb5\xa4\x47\xbb\x98\xd3\xad\x3a\x91\xd5\xed\xe0\xd6\x2d\x27\xaa\x6e\x6e\xc4\x14\x3e\xc7\x63\x32\x8f\x92\x6a\x54\x28\x29\xb0\x25\x12\x54\x81\x0a\xa2\xfc\xe3\x0e\xd8\x14\x9e\x1a\x06\x5b\x1d\x39\xb9\xe2\x08\x06\xf2\x75\xed\xa0\x9b\x57\x90\x56\x61\x3d\xf3\xf8\xe0\x39\xa1\xae\x34\x26\x59\xca\x19\x5c\xd5\xe1\xf7\x8f\xc4\x69\x6e\x82\xa7\x77\x78\x8c\xc9\xa2\x05\x99\xbb\x65\xda\x10\x80\x0b\x7a\x5b\x0a\xe0\x35\xb6\x1e\x60\xcb\x55\xdc\xc8\xc5\x3c\x83\xb3\x01\xdb\x50\x00\x13\x8b\xee\x48\x40\x6c\x5c\xde\xf4\x80\xf4\x2e\xba\x68\xbf\xc4\xdd\x02\x7e\x44\xd4\xc2\xb5\xe1\x6c\x14\x0f\x1e\x59\xc8\x0d\x34\xdd\xd4\xdb\x56\x5d\xbd\x79\x3f\xed\x99\xf2\xad\x31\xdf\x38\xc8\x34\x5d\x61\x1c\x26\x74\xc5\x38\x2a\x81\xbe\xf2\x38\x5a\x74\xbe\xba\xc7\x77\x2e\x6b\x57\x10\x0e\xb7\xee\xaa\xeb\x28\x05\xf1\x77\xd4\xca\xb9\x49\x47\xe9\x5e\x70\x67\x27\x02\x33\x5e\x7a\xdd\x98\x34\x48\xff\xd0\xfc\x00\x37\xa1\x18\x63\x84\xb7\xe2\x4a\x63\x26\x9f\x8a\x28\xe7\x4d\xd3\xc6\xa0\x07\x22\xf2\x79\xc5\x14\x9a\x75\xfa\xc6\x5a\xd9\x91\x57\xaf\x5e\xb5\xec\x43\x52\x49\x41\xb2\xa6\x95\x5a\x7e\x8f\xf3\x05\x6e\xdc\x9e\x24\x06\x18\x74\x3d\x02\x1c\x98\x9a\x5e\x14\xcb\xd1\x9c\x94\xbf\x64\x79\x93\x94\xa4\x00\x2b\x56\xba\x2f\xbf\xfe\xea\xbb\x45\xab\x1c\xaa\x72\x2b\xae\x68\xcf\x3a\xe2\x38\xd7\xdf\x4a\xf1\x13\xe8\x69\x52\xd1\x61\xa4\x1e\x66\xb1\x09\x06\x4b\xd8\x48\x01\xd9\xdf\x2a\xc4\x0f\x60\x6e\x49\x5b\x7c\x70\x21\xd4\x51\xc2\xc8\xd3\x0a\x56\xa5\x4b\xc1\xb4\x0a\x80\xcb\x4e\x55\xd9\x56\xa3\xa6\x45\xaf\xc6\x48\x54\xa2\x2b\x06\x68\x79\xe6\x7e\x65\x16\xaa\x2c\xa1\x35\x6f\xae\x68\x27\xe3\xd5\xab\x57\x2e\x30\xa3\x7e\xad\x4a\x49\x98\xc6\xa0\x69\x02\x7c\x73\x0b\x07\x16\x91\x4d\x2a\xbb\xeb\x3c\x34\x2b\x3a\xa2\xa4\x2b\xb5\xae\xa6\xed\xa8\x5c\xb8\x24\x1d\x45\x05\xb6\xa2\x41\x4e\x31\x63\x94\x7c\xdd\x72\x18\x09\x72\xdd\x0f\x56\x68\x63\x4e\x3c\xf1\x26\x8d\x16\x38\xc4\x0d\xeb\x9f\x45\xc5\x2c\x8f\xca\xda\x31\x54\xc0\xb4\xda\x19\x56\xef\x91\xb8\x9d\xad\xe9\x90\x1f\xa4\xf9\x9c\xc1\xaf\x83\xcd\xc3\xc5\xea\x3d\x9c\x46\xc5\xdb\x9c\x8c\x6b\x71\x56\x01\x73\x63\x25\xf0\xea\xbd\xe4\x41\x87\x8a\xba\x5e\x4a\x98\x1b\xb6\x31\xd2\xae\xd0\x6a\x9a\xa9\x06\xfb\x4a\x34\x24\x22\x32\xfc\xcc\x6c\x6d\xea\xfa\x66\x83\x6a\x2d\xea\x2c\xc4\xb8\x76\x19\x8c\x95\x1d\x83\x76\xa5\x39\x22\xc6\x93\x85\x68\x5c\x66\xb9\x10\x7f\x84\xe5\x03\xd8\x11\x07\x88\xc2\x1a\xc6\xc4\x1c\xda\xd7\xd8\x44\x58\x3a\x68\x6f\x8b\x48\xe2\x3a\x5c\xd2\x82\x10\x31\xe3\x88\x9e\xef\xda\x32\x40\x50\x98\x5b\x53\x0c\x70\x39\xeb\xf5\x03\x97\x0c\x5f\x65\x53\x4d\xde\xb5\xdc\x1d\x99\xfd\x53\xf6\x13\xf5\x7e\xef\x05\xd2\x7a\xbc\xc0\x60\x9a\x64\xa3\x28\x19\x50\x5c\x0c\x22\x37\x99\x07\x2a\xf3\x35\x49\xc6\xd1\xe2\xcd\x4d\x9b\xa5\x85\x9d\x46\x59\x62\x5d\x93\x9a\x31\x89\x6a\xb0\x66\x0e\xa4\xf5\x49\xc5\x34\x34\xb9\x90\x7a\x51\xce\x94\x19\x9e\x65\x4f\xd3\x09\xb7\x9e\x04\x1d\xc7\xae\x87\xdb\x95\x2b\x83\x9a\x4e\xb8\xfd\x0d\x24\x30\x1a\xea\x84\xdb\xdf\xb1\x4f\x39\xdd\x9d\x70\x87\x15\x21\xa3\x28\xed\x84\x3b\x3b\x81\x69\xf5\x07\x9f\x1c\x49\x9d\x70\x77\x17\xbe\x85\xf5\x4f\x27\xdc\x65\xd5\x73\x86\xdc\x09\x77\x59\xb7\xc4\x1d\x6d\x27\xdc\xa5\x0d\x0a\xdb\x9d\x4e\xb8\xbb\x73\x7d\x16\xec\x7c\x77\x6f\x46\x78\x6f\x46\xf8\xd7\x36\x23\xac\xb2\x21\xbc\xb5\xa9\x7b\x7b\xeb\xbe\x16\xa6\x7b\x00\xf7\x06\x97\x5f\xd3\x32\x1e\x52\x9b\x2d\x4d\x94\x4d\xfc\x4d\x4c\x4d\x5a\x58\xc2\x0f\x87\x43\xe5\x48\xc6\xe7\x9c\x86\x47\x59\xa4\x2c\x1e\xaa\xc3\xe5\x0c\x45\x0b\xa2\xf5\xfd\x2b\x9d\x23\xaa\xc2\xca\x4b\x39\xc5\x8c\x3d\x7f\x53\x99\x08\xe3\xdc\x56\x69\x3b\xad\x54\x01\xad\x20\xa7\xe9\x52\x93\xb3\xa9\xbd\xc1\xa5\x67\x53\x33\x37\x2f\x7d\x77\xb9\x3e\x0b\x76\x37\xef\x77\x8b\xfb\xdd\xe2\xaf\xbd\x5b\xfc\x41\x8d\xce\xef\xce\x3e\xbc\xa5\xf9\xba\xb2\xc0\x7c\x8b\xf3\x22\x4b\xa3\xe4\xde\x0c\xf3\x6b\x9b\x61\x5e\xb7\x33\xcc\x4b\xf1\x85\xb2\xf6\xab\x53\xeb\x2a\x40\x57\xb3\xbb\xe0\xb3\xfa\xd1\x0b\x74\x8b\x8b\xc5\x65\x9a\x64\xe3\x4f\xed\x3a\x68\xc0\xd6\xf4\xb1\x0a\xae\x8d\x79\x5c\xbb\x8b\xae\xca\xeb\xae\x3b\xbe\x27\x95\x43\xfa\xff\xd8\x7b\xf7\xb5\xb6\x91\x65\x71\xf4\xef\xe4\x29\x7a\xe6\x77\xd6\xc4\x0e\x02\x2c\xdf\x20\x24\xcc\xde\xc4\x40\x60\x25\x84\xfc\x80\xcc\xcc\xda\x7c\x4c\x3e\xd9\x6a\x63\x25\xb6\xe4\x2d\xc9\x5c\x32\x61\xbd\xcf\x79\x8e\xf3\x62\xe7\xeb\xea\x8b\xfa\x2a\xcb\x40\x32\x99\x59\xb0\xf6\x9e\x58\x52\x77\x75\x75\x77\x75\x75\x75\x75\x5d\xe6\x5f\x96\x2e\x72\x29\x66\xbb\x64\x74\x76\xa9\xfa\xfc\x54\x9b\x9d\xf2\xb9\x59\xe4\xe6\x4b\x9f\x1b\x0d\x79\x9b\x40\xc7\x1a\x2e\x1a\x51\x68\xa5\x82\x2e\x5c\x2a\x2d\xcb\x4b\x5f\x4f\xbe\xdc\x9a\xa3\x0d\x2c\xc6\x55\x2e\xec\x10\xeb\x4c\xb9\x8e\xb3\xeb\x42\xb8\xb3\xa8\x18\x34\xad\x82\x2e\xe7\xf9\x0f\x72\xde\x83\x9c\xf7\xf7\x96\xf3\x98\x90\x97\x8d\xee\x5b\x2b\x50\x41\x52\x5b\xc0\x83\xb0\x82\x6f\xdd\x3c\x17\x3d\x28\x74\x3c\x1a\x7d\x75\xcd\x82\x5b\x96\x43\xdf\x5a\x98\x23\xac\xf1\x78\xb4\x88\xea\xde\x63\xc1\x88\x7a\x29\x06\x1e\x00\x11\xdf\x7a\xf7\xa1\xd7\xcf\x46\x76\xbd\xfe\xbb\x24\xcb\x2d\x8a\xfd\x72\x44\xaa\x87\x12\xe0\xbc\xab\x7c\x87\xbf\x30\xae\x65\xd8\xee\x9e\x8d\x46\x1f\x2e\xe4\x8b\x18\x45\x84\x88\xe2\x61\x32\x07\x32\x29\x62\x07\x0b\x5f\x6c\x92\x56\x7e\x10\xc5\xd1\x64\x36\x79\x97\xfc\x3a\x57\xce\x92\xca\xda\x5b\x71\x15\x29\xb1\xd2\x98\x26\xd9\x3c\x89\x88\x14\xb1\xb7\xa7\x7d\xb9\x8d\xf8\xa3\x50\x84\x4d\x16\x9d\xf5\x41\x2f\x36\xcf\x6c\x5f\x94\x73\x8c\x8c\xe5\xf3\x6d\xd0\x3d\xe6\x70\xca\x70\x9e\xc5\x55\xb1\x96\x4a\xda\xf1\xb6\x17\x28\x99\xcf\x73\x9c\xef\x8e\x93\x20\x8f\xe2\x73\x16\x62\xbc\x82\xd5\xbf\x5e\xc3\x8e\x4b\x79\xc1\x72\x9c\xde\xe2\x4b\x36\x74\x20\x34\x54\x47\xcd\x51\xd1\x89\xe1\xfc\xf2\x25\x88\xc6\xf8\xf2\x55\x9a\xcc\xa6\xf3\xcf\x98\x50\xcc\x8e\x84\xe5\x6b\x89\x7f\x44\x10\x86\x27\x49\x95\x46\x8b\x82\xf6\x66\xad\xdf\x4b\x1a\x8e\xf1\xe5\x6b\x7c\xfd\x2e\x88\xd2\xf9\xbd\x65\x05\x9d\xfd\xe5\xdf\xcd\x56\x46\x41\x56\xad\x95\xa2\xa0\xbd\x15\xeb\xf7\x72\x9a\xa3\x82\xd4\x6b\x3c\xcf\x06\x50\x2e\xea\xa4\x2b\x5b\x89\x39\xcd\xa7\xd1\x45\x90\xe3\x6a\xed\x8b\xb2\x6e\x04\x6c\x45\x4a\x30\xa0\xe9\xd5\xaa\x0d\xbe\x52\xd6\x8e\x81\xab\x48\xe9\x18\x10\x81\x36\xc7\xc7\xd7\x93\x09\xce\xd3\x6a\x53\x61\x56\x71\x8d\x88\xa5\xa4\x75\x79\xc9\x25\x68\x8e\xff\xf9\x2b\xcd\xac\xe3\x5c\x74\xa5\x45\x4b\x46\x47\xab\xba\x9b\x26\x93\x77\x41\x96\x5d\x26\x69\xb8\x18\x7e\x72\xcd\x4a\x58\x3a\x2a\x94\xe0\x3a\x0a\xb2\x05\x26\x51\x2b\xed\x5c\xcf\x8e\x42\xe5\xab\x6a\x21\x62\xca\xab\xd0\x91\xab\xd0\xdc\xb5\xb5\x00\x2a\x66\x85\xb2\x55\xb6\x18\x42\x86\x4a\x86\x89\xb0\xb2\x54\x33\x4c\x64\xad\x90\x24\x24\x4a\xd0\x93\x4c\x35\x6d\xa4\x52\x87\xac\x64\xb2\xbc\xb4\xc8\x04\xca\x47\xc7\x76\x5c\x94\x59\x5d\x45\x41\xc6\xfb\x0b\x59\x2c\x27\x70\xa2\x98\x60\xa6\x9b\x42\x54\xc9\xc4\x38\x4f\x51\xb1\xd8\x10\x94\x06\x05\x9f\x56\xdf\x0a\xe6\x59\xbc\x56\x38\x9a\x82\xd0\x5c\x7c\x6c\xcc\xa7\x80\x60\x65\x0a\xce\xcf\xf2\x6a\x54\x7a\x67\x07\xae\xd1\xab\xde\x1d\xf9\x1b\x7c\x72\x5d\x85\x1e\x8f\x46\x52\x74\xc8\xf9\x06\x3a\x8a\xf6\x4c\xb3\xa8\x69\x37\x1f\x74\x67\x0f\xba\xb3\xbf\xb7\xee\xac\xb8\x23\xed\x7f\xfe\xac\xdd\x91\x6e\x8d\xf1\x15\x7a\x89\x53\x7c\x9e\x7d\x0e\xb2\xcf\x11\x7a\x11\x8c\xf1\xd5\x7f\xa7\xf9\x30\x5b\x19\xcd\x54\xad\x59\x97\x45\xaf\x3d\xc2\x43\x9c\xe2\x78\x80\x37\x10\x69\x3f\xdb\x58\x5d\x3d\x8f\xf2\xd1\xac\xbf\x32\x48\x26\xab\x98\x90\x13\x9e\x4d\x56\xcf\x93\x65\xf1\xbb\x3f\x4e\xfa\xab\xd9\x65\x90\x4e\x56\xa3\x38\xc7\x69\x1c\x8c\x57\x49\x97\xf0\x55\xce\xff\x5d\x39\x4f\xfe\xcf\x9b\x56\xeb\x2b\x5f\xa9\x16\xf7\xa4\xc7\x04\x9b\x87\x4b\xd2\xef\xe4\x92\x94\x1a\x3a\xe3\xfc\x32\x49\x3f\x1d\xe1\x60\x9e\x1c\xa9\x17\x37\x45\x92\xfe\xe7\xcf\x1f\x4a\x4a\xdd\xc5\x15\xf3\x3a\x1e\xec\xc4\x41\x7f\x8c\xe7\x61\x29\x95\xb4\x23\x68\x2f\x70\x17\xdc\x2e\x83\x69\x45\xdc\x8a\x92\x0e\xdc\xac\x05\xee\x80\x5b\x98\x5c\xc6\x2c\xea\x74\xa9\xbc\xc9\x8a\xd9\xb1\xb2\x7c\xad\xee\x5d\xec\xba\x02\x9f\x56\x40\x8b\x16\xb2\x23\x65\x7c\xbb\x33\x4a\x29\x11\x84\xf0\xc5\x3c\x1d\x1c\x2f\x66\x47\xcb\xf2\xf5\x2e\xa4\x95\x93\xdd\x6e\x0e\x51\x91\x32\x0e\x72\xd2\x3e\xdd\x79\x88\xce\x71\x05\xef\x75\x3b\x2e\xea\x87\x3b\x8c\x09\xcd\xd6\x31\x27\x24\xae\x1d\x07\xf5\xc3\x9d\x47\x83\x65\xe7\x29\x47\x86\x16\xb2\xe3\x63\x7c\xe3\x28\xb5\x2b\xa1\x54\x62\x96\x61\x1c\xf2\x74\xb6\x2c\x1d\xdd\x0a\x7e\x28\xbd\x2c\x18\x91\x74\x64\x60\x7c\x40\x3a\xe3\x4d\xd5\x67\x4e\xfd\x12\x20\x42\x82\xca\x71\x44\xea\xed\x4c\x7a\x90\x64\xf1\xaf\x6a\x5e\x30\x8a\x2e\x9c\xae\x50\x64\x4e\xe0\xbb\xf8\xbc\x98\xd1\xaa\x76\x9f\x63\xc0\x2e\x6e\x75\x50\x05\x2b\x05\x10\x96\x6c\xb1\x8d\xad\xf6\x08\xad\x87\x33\xd5\xc3\x99\xea\xef\x7d\xa6\x62\x07\x2a\x7e\x69\xfc\x6d\x83\xf2\xdf\xc6\x20\x9f\xdf\xa8\x07\xd3\x88\x0b\xe3\x34\x9f\x63\x3e\x2a\xb3\x5c\xa4\xf7\xe6\xa5\x41\x48\x79\xe9\xfc\x7a\x4a\xe4\x03\x16\x70\x94\x31\x7f\xca\xc0\xa3\x7c\x30\xaa\x91\xef\x7a\x2e\x99\x41\x90\x61\xf4\x84\x50\x7c\x96\x3f\xd9\x50\x3e\xc1\x64\xa5\xe7\xd9\x4a\x36\x8a\x86\x79\x4d\x4b\x20\x83\x8c\x4c\x90\x0d\xb3\x00\x63\xc9\xe0\xad\x18\xe3\x4b\x1a\x70\x8c\x1a\x63\x3c\xb7\xa0\x31\xc5\x71\x18\xc5\xe7\x5f\x1d\x8f\x77\xb4\x1d\xd9\x08\xd0\x86\x14\x8b\x14\x69\x62\xa3\x81\x33\x2a\xd3\x84\x3a\x37\xea\x85\x99\xb0\x4c\x99\x73\x5f\xc6\xa0\xe9\x32\x82\x42\x0a\x95\x14\xcd\xb3\x38\x8a\xb3\x3c\x18\x8f\x2b\xb5\xac\x95\xb6\x87\x36\x70\x17\x2a\x57\xbc\xbf\x49\xce\x2b\x5c\xd7\x92\x52\xce\x90\x0a\xb4\x45\xad\x48\xa9\x6d\xc2\xdc\xb0\x2b\xa4\xc8\x9c\xf6\x7a\xa3\x20\xae\x74\x03\x6c\x13\x3e\x28\x08\x59\x09\xae\x8c\x9e\x22\x08\x91\x8e\xc9\xfa\xf4\xf1\x58\x96\x07\x16\xe6\x37\xd9\x68\xb4\x02\xac\xd1\x60\x37\xd9\xa8\x02\xbb\xb9\x35\x95\xf2\x4b\xdd\x45\xe8\xe3\x9e\xe9\x94\x5a\x3e\x7c\x7b\x3a\xbd\x93\x95\xc3\xad\xa9\x95\xb7\xfa\x3d\x51\xab\x21\xbc\xd2\xbe\xe0\x7c\xb4\x41\xfe\x43\x2b\x66\xa3\xd1\x06\xf9\x0f\x95\x77\x6d\x29\x3b\xda\xed\x07\x29\xf6\x41\x8a\xfd\x9b\x4b\xb1\xc5\xd5\x00\x77\xe7\xbf\xa7\x6c\xe2\x34\x14\xc1\x11\x3e\x27\xf3\x1c\xa4\x5b\xfd\xc8\x91\xb9\x22\x5b\x7d\xa5\x16\x5d\xf9\x98\x25\x22\x3b\x44\x34\x08\xa6\x32\x10\x17\x8c\xfd\xde\xd6\x3b\x13\x82\x84\x09\x8b\x79\xc0\x3c\x16\xd0\x26\x7a\xd2\xb8\x1a\x74\xc3\x67\x61\x73\x10\xb6\xdb\xcf\x82\xb5\x4e\x7b\xd0\x7e\xd6\x6e\x76\xdb\xd8\x5f\x6f\x3c\x1b\x74\x1a\xb8\xd5\x0e\xbb\xed\x4e\xb7\xd9\x7f\x52\xe0\x62\x03\x13\xf8\x81\xef\xfb\xfd\x41\x63\xad\x3d\x78\x36\x18\x06\x6b\xeb\xfe\xb0\x31\x68\xad\xe3\x6e\xab\x1f\x76\xfc\xc1\x33\xbf\xbf\x1e\x0c\x1b\x8d\x27\x6e\xde\x44\x71\xdc\x90\x84\xe3\xa0\x1f\x6d\x58\x06\x51\xb9\x8a\x25\x28\x6c\x58\xfb\x47\xd9\x2d\x2d\x4c\xd0\x36\x20\xeb\xe3\x6a\x81\x6b\x76\x97\x42\x55\x38\x66\xf9\x2c\xfe\xb8\xe1\x7b\x3f\xce\x99\xa7\x1f\x37\x9a\x84\xd9\x76\x1e\x98\xed\x03\xb3\xfd\x7b\x33\xdb\x82\xd7\x72\x7d\x99\xc6\x6c\xcb\x5c\x50\x87\x69\xf2\x19\x4f\x82\x78\x25\xc4\x3f\xdf\x0b\x83\xb6\x45\x43\xd0\x42\x21\xe8\x77\xaa\x52\x8e\x61\xa0\xbd\x4c\xb9\x38\x65\x29\x80\xd9\x27\x78\x94\x32\x52\x50\xdd\xa3\xf4\x9d\xbe\x50\x72\x56\x68\x25\x32\xbd\x84\x9e\xf1\xba\x28\xaa\x7d\x91\xea\xa8\x2a\x6b\xa9\x8a\xfa\x41\xaa\x61\xdc\xff\xc6\xb3\xf1\x98\x4a\x96\x7c\x2c\xe4\x04\xa9\xfa\x7d\xa8\x9a\xbd\x7b\xa2\x0c\x91\x01\x3a\x9d\x54\x4d\x48\xee\x48\x03\x7f\xe7\x2c\xf0\x96\x2e\x95\xe4\x81\xb7\x45\x09\xd2\x46\xf8\xbf\x6c\x6f\x69\x5d\xc8\xc8\xfe\x9d\x64\x60\x77\xf6\xfb\x9e\x72\xb0\xff\xb0\x49\x09\x47\x7b\x45\x36\x94\x61\x14\xe3\xf0\x2e\x49\xda\x79\x72\xe1\x3c\x41\x2c\xb3\x79\x91\xf1\x1c\x32\xb6\x8b\xf3\xb9\xc8\xd9\xbb\x82\x0e\xc8\xc6\x16\xe1\x8c\x51\x12\x0c\x93\x36\x96\x5a\x9a\x74\x7b\x3e\x77\x0a\x4f\x19\xd7\x5d\x36\x52\x5f\xde\xce\xc6\xe3\x1b\xc9\x33\x26\x1a\x22\x7c\x15\x65\x50\xdc\x3a\xe4\x5a\x8b\x4e\x15\x63\x34\x2c\x72\x1c\xf1\xd6\x68\x96\x23\xd0\xcc\xb1\x9c\xe2\xcb\xc8\x3f\xab\x5b\xf2\xb5\x40\x99\x69\x32\xad\xd5\x21\xb5\x39\xbb\x2a\x23\xfc\x1f\xd6\x13\x8c\xd6\x0f\xb2\x70\xa3\x0e\x37\x35\x89\x28\x30\xcb\x13\x3b\x29\xaa\xa6\x13\x2e\x62\x64\xaf\x78\x2f\x9c\xd4\x58\x3d\xc3\x3b\xd4\x11\xa2\x24\xe2\x29\x6c\x8a\x8c\xef\xaf\x70\x5e\x93\xee\x8e\x70\x3c\x9b\xe0\x34\xe8\x8f\xf1\x06\xca\xd3\x19\x36\xb5\x85\xc1\x04\x67\xa5\xd9\xdc\x2f\x8a\x94\xef\x50\x18\xf4\xbd\x48\x4a\xf3\x9e\xcd\xc9\xf3\x9e\x69\x89\xde\x33\x47\xa6\x77\xbd\xc8\x73\x45\x2d\x21\x9a\xf7\xcf\x78\xba\x1c\xf8\xc7\x9e\xff\x27\xe9\x7f\xf4\xa0\xbc\x47\x87\x8c\xf5\x85\xc0\x0f\xb2\xeb\x78\xf0\x0a\xf6\x1b\x22\xf2\x42\x17\xea\x67\x4a\xda\xfc\x2d\x56\xa4\x26\xf9\x74\x69\xd5\x94\x49\x02\x10\x2a\xcb\x80\x0b\x69\xb4\x04\x38\xac\x0c\x46\x41\xba\x95\xd7\x1a\xf5\x95\x3c\x79\x3f\x9d\xe2\xb4\x17\x64\xb8\x56\xe7\x9f\x21\xf1\x76\xcd\xaf\x3b\x37\x1e\x3e\xb3\xee\xdc\xb4\xc5\xc6\x5d\x24\xda\xe5\x31\xf3\x78\x8d\x73\xd2\x21\x73\xc5\x08\x01\x45\xc9\xc1\x2e\xde\xda\xb2\xb0\xab\x7a\x7d\xba\x24\x36\x0a\x40\x74\xbb\x2f\x54\xd4\x52\xb6\xf6\xb2\x0e\xf2\x51\x5f\xac\x97\x85\x79\x80\x3b\xde\x1c\x2a\x2c\xa3\xac\x1d\xa2\x99\xf1\x17\xec\x55\xc5\x0c\xfa\x6a\xd6\x7c\xfb\x60\x9b\x79\xf3\x6f\xd4\x04\xf7\xe7\x38\x5f\x30\xbf\xfd\x39\x76\x6d\x27\xdf\x77\x7a\x7b\x0b\x71\x54\x4f\x70\xaf\x5b\xda\x6d\xc8\xf2\xa8\xa9\xa9\x3c\x3d\x53\x75\x9c\x64\x9a\x58\x15\x6d\xb3\xaa\x98\x2b\x5f\x9e\xb2\xaf\x95\x31\x9f\x0f\x90\x3b\x67\x3e\x39\x62\x77\x1f\x8e\xd8\x0f\x47\xec\xbf\xf7\x11\x5b\xd2\x67\x32\x0e\x31\x61\x2c\x5d\x3d\x69\xff\x13\x0f\x87\x29\xbe\x46\xbf\x46\xe3\xc1\x27\x8c\x5e\x7c\xc4\xc3\xa1\x2b\x30\xd4\x42\x51\xa4\x0e\x82\x94\x1c\xe1\x0f\x83\x78\x80\x03\x28\x6b\x8b\x1f\x75\x8b\x90\x53\xac\xca\xab\xe0\x02\xfd\x9a\x24\x21\x7a\x71\xee\x3c\xe4\xb7\x8b\x43\xfe\x3f\x19\x37\x55\x62\x0d\x30\x16\x5b\x96\xf4\xd8\x12\x13\x51\xcf\x53\x6c\x4b\x52\x8c\xd3\x34\xd1\x82\x24\xac\xd2\x77\xd4\x6c\x81\x6e\x3b\xfb\xf9\x93\x8c\x6c\x8c\xd3\x24\xce\xa2\xfe\x98\x12\xd8\x34\xc8\xb2\x28\x3e\x47\x13\xee\x5d\x9b\x27\x64\x63\xbc\x88\x42\x9c\x66\xa2\x56\x30\xce\x12\xb3\x6a\x32\x1e\x93\xaa\x84\xda\xb8\xc1\x39\x8a\x93\x90\x7e\x8d\xe2\x41\x32\x91\x21\x13\x60\x2c\xeb\x04\xbd\xf7\xca\xa3\x09\x26\x8b\x2d\xca\x90\x8f\x32\x3c\x48\xe2\x10\x76\xc7\x28\x3e\x1f\xe3\x3c\x89\x61\x38\x49\xf7\x4a\x0e\xfa\x1c\x55\xe5\xb8\xcf\x5f\xa2\x4d\xd1\x15\x49\xcf\x40\xda\x06\x0d\xf0\x8d\xf4\x92\xe3\x22\x6b\x1d\x9c\x87\x3f\x22\xa1\x8c\xd2\x24\x4e\x66\xd9\xf8\x1a\x22\xe6\x38\xf6\x61\xf2\xc9\x72\x1e\x41\x61\x90\x07\xce\x13\xb2\xda\x5b\x45\xe5\x11\x87\x4a\xe7\x09\x18\xf9\xa4\xf6\x83\xd2\x7b\x25\xfd\x65\x12\x67\x09\xd9\xba\x08\x51\xd4\x28\x69\xac\xec\xc7\x17\xc1\x38\x0a\xdf\xb1\xf2\x35\x59\xe6\xe1\x11\x1c\x60\x30\x24\x09\x5f\xdd\xe3\x19\x99\xaf\xe4\xc9\x3b\xfa\x0e\x50\x5a\xa1\xbd\xf7\xa0\x9b\xcc\x3e\x43\x3a\xbf\xb0\x53\xf9\xa6\x3a\x57\x54\x98\x65\xa0\xf9\x7d\x25\x74\x8a\x37\x12\x65\xbf\x10\x74\x8f\x28\x15\x62\x21\xa8\x49\xdd\xcc\x47\x69\x72\x89\xd4\xee\xe9\xe5\x95\xee\xb0\x6e\xd2\x4f\x2b\x95\x4e\xfe\xc1\x42\xb3\x0f\xd2\x6c\x29\x09\xe8\xe7\x52\x21\xfd\xcc\x27\x06\x00\x6e\x50\x84\x19\x66\xbb\x9c\x36\x78\x72\x55\x49\x36\x2e\xa3\x8e\xfb\x21\x04\x73\xee\xa9\xdc\xcf\x40\x56\x90\xe7\x49\xa7\x70\x9a\xea\x22\xbe\xa5\x37\x75\xdd\x42\x87\xfc\x29\x70\x16\xa1\xb1\xf9\x43\x66\xd4\x96\xdb\x37\x84\x5c\x96\x0f\x58\x21\x41\x3d\x0e\xac\xfb\xd8\x60\xa3\xc6\xb2\x93\x01\x29\xf0\x92\x7c\xb7\x28\x99\x68\xbd\xfb\x20\x4c\x68\xe1\x3b\x23\x4c\xc0\x49\xa6\x4e\xce\x64\x6e\x47\x8a\xd9\x3d\xd0\xa2\x4a\x83\x5c\xcf\x06\xb3\x51\xe3\xad\xdc\x89\xf4\xb2\x79\xb4\xa7\x74\x48\x10\x1d\x9a\xb3\xfd\xe1\x5c\xec\xab\x44\xda\xe4\x67\x42\x26\xf2\x19\x14\x97\xf3\xa9\xb2\xab\xe6\x4a\x69\x49\xd4\x55\x77\x7d\xe7\x76\x3f\x6f\xe7\xce\xc9\x91\x8a\x09\x2e\x3a\xa2\xe4\xdb\x3b\xf1\x69\x2e\xc7\xa6\xd9\x21\x6e\x00\xda\x7e\x38\x77\xc9\x58\xbe\x0a\x53\x1b\x8e\x49\x9e\x84\x09\x1a\x8c\x71\x10\xcf\xa6\x28\x06\xf8\x64\x80\xc5\xb1\xbd\x6c\xa8\x24\xec\x2d\x2b\x8f\x22\x29\x47\x4f\x12\x8d\xab\x63\x49\x84\xa3\x53\x5a\xfa\x8c\x08\x49\xa4\xfa\x06\xa2\x40\xa2\x70\xc3\x00\xb4\x61\x03\xb9\x51\xfc\xbc\xe1\x59\xd3\x57\x57\xf5\xd1\x57\x18\x00\x13\xc0\xd4\xdd\x9c\x21\x54\x13\x2b\x7c\xce\xe4\x26\x53\x21\x94\x12\x11\x94\x59\xde\xc2\xe9\xe6\x3c\x22\x47\xba\x48\xd7\x1d\x93\x3a\x96\x39\x37\xe6\xb6\x74\xe4\x05\x08\x95\x48\xa1\x2e\xef\x10\x75\xb5\xb6\x0c\xf2\x73\x69\x78\x0a\xfc\xd9\xe8\xd4\x98\x46\xf5\x13\xbe\xce\x6a\x45\xdd\x3a\xd7\xf2\x6e\x6e\x6e\xa2\x06\xfa\xe9\x27\xe4\x1a\x43\x42\x4c\xe9\x09\x7d\x5f\x53\x0a\x3d\x57\xc7\x59\x17\x80\x4b\xc6\xbb\xd8\x7d\x52\x4c\x78\x01\x91\xff\xf9\xb0\x4f\xf0\x60\x14\xc4\x51\x36\xe1\xc7\xd0\x72\xe6\x00\x00\xca\x87\x97\xb6\x21\x0f\xec\x27\x8c\xa7\x22\x55\x05\xef\xec\xea\xd3\x8f\xd9\x28\x8a\x49\x43\x57\x83\x64\x32\x1d\xe3\xab\x28\xbf\xde\xe8\xc0\x91\x8c\x14\x20\x04\x51\x23\x9b\xc3\x27\x7c\x4d\x35\x05\x62\x34\xa5\xf1\x5a\x5d\x45\x29\x9e\x24\x17\x18\x05\xe3\x31\xf4\x2a\xf3\x10\xbe\x1a\xe0\x69\x0e\x62\x3f\x7b\x25\x97\xcf\x47\xf8\x1a\xc5\x98\x8e\x48\x1f\xb3\xfa\x21\xe9\xf1\x2c\x18\x8f\xaf\x51\xff\x1a\x86\x8c\x0c\x0f\xcb\x3a\x01\x34\xf3\x2b\xd9\x90\xa2\xf8\xbc\x56\x97\xf6\x81\xda\x0f\x4a\xef\xd0\x97\x2f\x04\xdf\x95\x28\x0e\xf1\xd5\xe1\xb0\x06\x9e\x8d\x84\xd8\x3e\x3c\xa9\xc3\xe4\x2f\xfb\xfa\x06\x21\x51\xd8\x27\x7c\x7d\xb6\x22\x56\xa2\x6e\x41\x6d\x52\x24\x29\x6f\x58\x33\xff\x85\xc9\x13\x4e\x99\x64\xde\x07\xd4\x40\x12\x25\x71\x15\x9e\x40\xed\x1a\xcb\x68\x92\x99\x6d\x9a\x2a\x50\x07\x15\xa2\x2e\x01\x67\xe9\x4c\x86\x73\xa5\xf7\x04\xb0\xa4\x8a\xf4\xd0\x60\x65\xe7\x64\xef\xc3\xbb\xc3\x37\x6f\xf6\xdf\xbe\xfa\x70\xb2\x7f\xb0\x73\xf8\xfe\x44\x3e\x1e\x55\x99\x01\x53\xa8\x52\x24\xa6\xaf\x72\x74\x34\x65\x32\x82\xd7\x76\x90\x07\x68\x13\x9d\x9e\x3d\x57\xdf\xef\x83\x87\x32\x7f\x5d\x6d\xa9\x0a\x80\x2b\xd3\x59\x36\xaa\xe9\x74\xcf\x44\x3c\xa5\xf4\x7e\x98\xd1\xc2\x9f\xf0\x75\xdd\x18\x83\x02\xe0\x02\x83\x57\x49\xdc\x14\x90\x59\xa3\x7c\x49\x4d\x82\xa9\xc2\x24\x23\x20\x5b\x60\x28\x40\x62\x84\x34\xd5\x61\x3a\x08\xa6\x92\xea\x42\xd2\x6b\xab\xce\xe5\x54\x70\x05\xae\x51\xff\x43\x1f\x83\x83\x60\x7a\x0a\xd5\x22\xd8\xe2\xf9\xc8\x9c\x42\xf1\x33\xc9\x89\x5d\x34\xae\xb8\xda\xa3\x85\x65\xe6\x44\x95\x9a\x1f\xcb\xdc\xf3\xe4\x70\xfb\x70\x83\x13\x19\x1a\x27\xe7\xff\xa5\x4b\xd5\x89\x43\xae\xbe\xab\x24\x5d\x41\x59\x90\x59\x8f\x8e\xec\xdb\xca\x24\x98\xd6\x5c\xc6\x0a\xfc\x0f\xec\x17\xc3\x62\x94\xc9\xd8\xb3\xa3\x5e\x14\xca\xbe\x3a\x82\x22\x3e\x61\x94\xcd\x52\xd0\x13\x73\x66\x15\x65\x28\xcb\x23\x42\x0f\x94\x93\xe3\x10\x05\x43\xf0\x29\x4a\xd3\xe8\x22\x18\x6b\x7b\xad\x02\x93\x0c\x08\x44\x0a\xa0\x4b\x23\x0a\xcf\x74\x14\x8b\x2e\xad\x0c\x0a\x7b\x00\xb5\x8e\xf8\xe2\xf4\xb1\xe1\xba\x13\xf9\xd3\x0d\xc2\x63\xa6\x67\xb6\xd4\x18\x06\xe3\x0c\xcb\xb7\x6c\xcc\x53\x6a\xee\x98\xb2\xfa\x3f\xfc\xc0\xda\x44\xb7\x80\x01\x91\x3f\xc9\x8c\x4b\x8b\xd6\x71\xf8\x7f\x6e\x8c\xe7\x0f\x50\xb3\xc2\x38\x56\x57\x0c\x20\x85\xc2\xa4\x5e\x42\x45\x75\x94\x8c\xa0\xb1\xae\x61\x52\x71\x71\xeb\x19\x90\x7c\xc9\xe9\x4a\xee\x75\xa4\xc7\xe1\x50\x6f\xbc\xb4\x2c\x5f\x66\x96\x14\xa6\x90\xfe\x71\xa3\x09\xd1\x80\x98\x32\xfc\xc7\x8d\x16\x78\xae\xae\x55\xb9\x23\x63\x21\x7a\x71\x9e\x47\xf1\xb9\xdd\x19\x18\x18\x53\x28\xe5\x36\x46\x9b\xc2\xcd\xed\xb9\x51\xa2\x88\xee\x2e\xec\x83\x5c\xa1\x8f\x58\xa3\xac\xdf\x04\xe5\xf5\x87\x6b\xbd\x87\x6b\xbd\xbf\xf9\xb5\x1e\x0b\xfe\xcd\x4e\x2d\x56\x67\xdb\x3b\xe4\x6f\x29\x89\xf1\x6d\x09\xf1\x5d\xd5\x70\x96\x2f\x69\x9f\x1d\x0e\xb6\xc2\x30\x83\xa1\x13\xbb\x5b\x10\x83\x5a\x2a\x43\x33\x2a\x7e\x31\x3f\x39\x8f\x08\x5f\x51\x0e\x51\xda\x50\x72\xc1\x96\x11\xdf\xed\x1f\x3f\x96\xcf\x07\xec\x7c\xf6\x58\x57\x12\x91\x6d\xf3\x31\xbb\xb6\x92\xca\x49\xbc\x8a\x86\xf6\x21\x62\x10\xdf\x87\x44\x88\x3b\x85\xa3\x31\xb9\x89\x8c\xbd\x45\xd5\xe8\x12\x8a\xe8\xbe\xcd\x7b\x9a\x59\x36\x0b\x9b\x3d\x0e\xff\x53\xf7\x2d\x7d\x7b\x72\xe9\x2e\x85\x85\x20\x8f\x5d\x04\x28\xff\xf4\x13\xe0\x4e\x15\x53\x51\x7c\x0e\xdc\xb8\xae\x40\xe4\xd7\x17\xf3\x92\xde\x52\x88\xb2\x63\xf3\x6d\x3b\x29\xa4\xa1\x71\x90\x41\x33\xc7\x39\x99\xec\x1f\x36\x37\x8d\x81\xe6\x7f\xc6\x8b\xd5\x55\x9a\xdb\x5f\x21\x29\x58\x6a\x79\x3a\x23\x32\x5b\x9a\xe5\x28\x4b\xa8\x9d\xe3\x74\x0a\xac\x1b\xce\xce\x41\x7c\x9d\x93\x03\xbf\x87\xfa\x78\x48\x18\x00\x5d\xe2\xfc\x0a\x15\x46\x83\x2a\x19\xb5\xbf\x68\x58\xfb\xc1\x82\xf5\x4f\x3f\x21\xdb\xc8\xd7\x8d\xfa\xc8\xbc\x6e\x20\xa8\x5a\x3c\xaa\x9d\x9d\x4d\x28\xdf\x8c\xf1\x55\x8e\x7a\xef\xde\xa3\xc1\xf5\x60\x8c\x3d\xd1\x4d\x18\x76\xb1\xd9\x40\x4f\xa0\xcb\xcc\x66\x69\x9a\x26\x03\xc2\xb3\x32\x3a\x3a\x46\x2b\xd2\x31\x58\x2c\x13\xdb\x5c\x58\x3a\xc2\x48\x43\x2f\x75\xe3\xa1\x46\x95\xfe\x59\x86\x95\x92\x82\x4b\x34\x93\x8c\xc1\x1e\x0b\x00\xba\x19\x9b\xa4\x8b\xad\x99\x76\x50\x8e\x84\xd0\xba\x25\xd4\x8d\x57\x08\xe1\xfb\xa1\x57\xb0\x09\xf6\x5e\xd6\x21\x51\x9d\x01\x70\x16\xb2\x4e\xb8\x9d\xe4\xbe\x35\x03\xac\x33\xad\x6b\xb9\xc9\xbc\x26\xff\x21\x59\xd7\xb4\x4f\xe4\x68\x49\x39\xb5\x44\xb9\xf0\xd2\x92\x54\x4e\xac\x57\xe9\xa4\x0f\x1f\x82\x30\x14\xb6\x5d\x52\x8a\x59\xf1\x5d\x9f\x1e\xe9\xe0\x20\xb1\x58\x6e\xbc\x05\xef\x25\x5b\x71\x2a\xd0\x89\x91\x90\x2d\x7d\x8b\x76\x4b\x2d\x16\xa3\x61\xf1\x4a\xd5\x4a\x15\x2c\x08\xb4\x0a\x1a\xf2\x95\x90\x90\x67\xd1\x2d\xd1\x1a\x04\x26\x54\xce\x35\x69\x0e\xea\x25\xa3\x6d\x95\x6a\x05\x42\x6e\x03\x36\x22\xab\xab\xa1\x3d\x89\xec\xfb\x90\x0e\xf7\x41\xf6\xfd\xbb\xcb\xbe\x85\x49\x1b\xcf\x0d\x7d\x5f\x3e\xba\xfb\xfd\x20\x56\xa5\xdd\xa8\x1f\x08\xd7\x5b\x7c\x45\xd5\xd5\x65\xae\xbb\xc7\x93\x20\xcd\x77\x58\xc1\xc2\xed\xd6\x79\x35\x06\x6a\x25\x68\x96\xf7\x45\xd3\x79\x4b\xaf\xc5\x25\xd8\x71\x9e\x46\xf1\xf9\x0d\xb8\xb6\xd8\xde\x13\x69\xb9\x1f\xc4\xf2\xa7\x5f\x82\xf1\x0c\xdf\xa0\x0b\xf2\x0f\xbb\x0e\x21\x90\x87\x38\xc5\x73\x6e\x48\x3d\xd5\xbc\x00\xe2\xda\x30\x9c\x54\xb1\x38\x1f\x79\x80\x11\x91\xd6\x3d\xda\x92\xb9\x85\x81\xda\x8d\x8e\x32\x24\x36\xef\x07\x71\x2d\x4f\xea\x4c\x55\x04\x3a\x1c\xf2\x99\xab\x7c\x6a\x16\x2b\x22\x52\x0f\x72\xca\xd4\x9e\x44\x54\x7d\x43\x21\x32\x3f\xdd\x27\xa6\xfe\x98\x41\xa4\xb1\x9b\x6b\x36\x87\x18\xde\xa3\x93\x84\x79\xf6\xca\xdd\x81\xea\x0c\x7a\xad\x6e\x76\x8d\xb7\x27\xe4\x18\xe8\x86\x4d\xd2\x65\xa1\xe2\x99\xa7\x34\xce\x47\x72\xf6\xf9\x5a\x1d\x1a\x61\xd8\xc6\x59\x1e\xe5\x33\x2a\x70\x99\xe6\x5f\x21\x9e\x26\x59\x94\xcb\x58\x32\xb8\x02\x3d\x00\x33\x18\x47\x38\xce\x75\x4b\x8c\xca\x0d\x1b\x26\x16\x3c\xab\xbd\x39\x82\x8b\x62\x64\x8e\x1f\x57\xc1\x97\x5e\x25\x0b\xd2\x1b\xce\xe2\x10\x6c\x22\x07\x38\xcd\x83\x48\x4c\xbf\x63\xf9\x88\x89\x5d\x6c\x1d\x7d\xf5\x25\x24\xf0\xba\xc5\x5a\x62\x23\x4f\x66\x53\x4b\x0e\x28\xc9\xb6\xc2\x7b\x3d\x97\xa2\xc6\x13\xd0\x1b\xb4\x01\x89\x36\xc7\x33\xbc\x41\xff\xe1\x62\xee\x40\xcd\xda\xe4\x9c\x15\x36\xf9\xc5\xa4\x40\x4c\xf5\x68\x80\x38\x27\x44\x9c\x43\xa2\xda\x64\x96\xe5\xb0\xd5\x41\x14\x76\x41\x37\xfd\xeb\x1c\x67\xad\x66\x9d\x09\xe3\x3f\xd4\xb5\x89\x64\xe5\xee\x7d\xfa\x32\x63\xfe\x78\x75\x4a\xa9\x68\x16\x47\xff\x3b\xc3\x28\x0a\x71\x9c\x47\xc3\x48\xe5\xc4\x95\xe6\x9a\x8f\x4e\x85\x19\x86\x26\xed\x5c\x33\x80\x5d\x47\xda\x83\x9e\xeb\x44\xc0\xc7\xb8\x16\xf4\xa3\xfa\x4a\x90\x13\xc6\xba\xc2\xc7\x97\x83\xfe\xe3\xae\x44\x60\xc8\xaa\x7c\x14\xad\x41\x10\xcc\xfd\xf0\xc7\x8d\x16\x11\x5d\x09\x33\xf8\x71\xa3\xd5\xba\x39\xf3\x3a\x95\xb2\x72\x33\xed\x6e\xa7\x52\x6a\xc7\xe7\xb2\x12\x3e\x21\xf2\xc5\x30\x18\xe4\x49\x7a\xed\x51\x85\x32\x19\xd8\x47\x84\x4d\x13\x51\x3f\x19\x22\xd1\x9b\xcd\x4d\xf4\x23\x8d\xe1\xf4\x23\x94\x79\xb4\xba\x8a\x7a\xc9\x64\x92\xc4\xff\x3c\x7e\xfc\xe8\x91\xd1\xf9\xe2\x17\x6b\x80\xe3\x54\xfb\x91\x0c\x43\x8a\x7f\xac\x7b\x48\x7a\x85\xe3\xc1\x72\x3f\xc8\x70\xb7\xad\x7d\x98\x84\x1d\xbd\xe8\xc5\xf4\x53\x38\xd4\x5e\x0e\xa2\xe9\x08\xa7\xcb\x14\x72\xfd\xf9\xe3\x47\x37\x8f\x1f\xe1\x71\x86\x91\xd4\x19\xaa\x30\xa7\x7d\xe1\xc3\xf0\x23\xfa\xe9\x27\xf6\x61\x25\x98\x84\xa2\x6f\x5b\x07\xdb\x8f\x1f\x3d\xa2\x1f\x6a\xa7\x1c\x67\x0f\xa9\xa8\xc2\x33\xc1\x90\x7e\xa0\x88\xc1\x6f\x19\x9f\x33\x31\xca\x32\x62\xac\x21\x1a\x0d\x03\xd5\xfa\x69\x72\x99\xe1\xb4\xfe\xf8\xd1\x23\x31\x62\x49\x92\xaf\xf4\xd2\xeb\x69\x9e\xfc\xf3\x98\x56\xbd\x81\xd3\x93\xbc\xfd\x88\xef\xe8\x8f\xc7\x8f\x1f\xd5\xd4\xe3\xd8\x23\x44\x35\x22\xc7\xa3\x24\xcd\x07\xb3\x3c\xa3\x6f\xc8\xb2\xe9\xa1\x4d\xc4\xeb\x3e\x97\x5e\x7f\x18\x47\x7d\xf2\x69\x65\x1c\xf5\xa5\xf7\xa0\x0c\xeb\x41\xa7\xc8\x57\x52\x6a\x45\x7a\xa7\x40\x08\xc6\xe7\x09\x80\x20\x3f\x9e\x3f\x16\x58\xbc\x49\x92\x4f\xb3\x29\xca\x83\xfe\x18\x4b\x98\x1c\xbf\x3c\xfc\x8d\x9d\xf9\xc4\xbb\xfd\xb7\xbf\x7c\xb0\xbd\x3f\x7e\xff\xf2\xc3\xc1\xfe\x6f\x1f\x1a\xae\x0f\xbe\xeb\x43\xd3\xf5\xa1\x65\x6d\xdb\xd5\x8e\xfc\xd1\x68\x4b\xfe\x68\xb4\x27\x7f\xe4\x6d\x8a\xa1\xe9\x25\x93\x29\x39\x28\x8e\xcd\x21\xb2\x4d\xa9\x56\x2b\x4c\x66\x7d\x22\xf5\x93\x5a\x45\x01\x60\xb1\x32\x16\x48\xb6\x54\x88\x20\x00\x21\x8a\xd0\x0b\xd4\xec\x74\x9f\xa3\x68\x69\x49\x01\x2f\x64\x44\xf4\x02\xf9\xcd\x75\xe3\x1b\xf9\x0b\x4f\xa3\x33\xb4\x49\x60\xbc\x40\xfe\x73\xf5\x3b\xbd\x4a\x2d\xa9\x55\xa3\xd5\xea\xe8\x77\xd4\xb8\xf2\xfd\xbe\x5e\xbf\x78\xbc\x79\xac\xf4\xfa\xd7\x60\xfc\x09\xbd\xda\xad\x35\x7f\x5f\xaf\xab\xbd\xbd\xa2\x41\x15\xd5\x77\x91\xf6\x72\xa1\x11\x90\x06\x39\xeb\x27\x57\xea\x47\x30\x34\x20\x6d\x5e\x45\xe8\x77\x54\xbb\x2a\x3a\xc4\x7e\x37\xa5\xdf\x2d\xe9\x77\xbb\xae\x75\x16\xa0\xd4\xb2\x2b\xf4\xf3\xcf\x3f\xa3\x75\x28\x99\x5d\xa1\x9f\x50\xe3\x6a\x38\xa4\x03\xd4\x6d\x69\x55\xc8\xea\x38\xbd\x22\x03\x99\x5d\x69\x9f\xf8\xe2\x39\xcd\xe0\xfb\xd5\xf3\xc7\xce\x4e\x4d\x66\xe3\x3c\x9a\x8e\xa3\x01\x68\x09\xcc\xee\x5d\x11\x32\x0e\x4f\xaf\xce\x9e\x5b\xbe\xb5\xe9\xb7\xa6\xf5\xe3\x3a\xfd\xd8\x3e\x2b\x69\x3d\x9b\xf5\x11\xc8\x37\x1e\x9a\x44\x57\x68\x90\x8c\x67\x93\x38\x53\xa8\x5f\x86\x49\x24\x85\x5a\x08\xbd\x7a\x4a\x68\xa6\xe1\xf3\x91\x62\x8f\x0d\xbf\xd1\xd0\x87\x56\xac\x64\x3a\x58\xb5\x1c\x26\xa6\x5d\x47\x5f\xc8\x6f\x3a\xde\x8e\x2a\xbe\x5c\xc5\xef\x4a\x55\xfc\xae\xab\x4e\x53\xae\xb3\x5e\x47\x45\x9d\xa6\x31\xeb\x82\x1b\xd0\x3a\x79\xc9\x48\x45\xf1\x85\x3c\x5a\xe4\xb1\xf2\x88\x5d\xad\x4b\xe3\xc3\xc8\xb3\xcd\x5e\x35\xf8\x8b\xa6\x32\xa4\xa5\x23\xaa\xf0\x47\x46\x63\x55\x86\x55\x61\x9d\x4a\xbd\x39\x63\xab\xb0\x55\xa5\xe2\x9c\x01\x56\x58\x2e\xab\x58\x36\xca\x70\x59\x00\x7a\x60\x9c\x9a\x9c\xf0\x87\x2b\x2b\x13\x64\x0c\x60\x73\x01\x0e\x08\x55\x9a\xe8\x77\x14\x9e\x92\xff\x5d\xad\xa3\xdf\xd1\x55\xf3\xec\x4c\x5f\x48\x50\x36\x42\xbf\x6f\x42\xc1\xab\xc8\x28\xa0\x30\x49\xf8\x79\x03\x67\x5a\xb1\xaf\xbc\x4b\xf1\x80\x76\x2e\x44\x47\x83\x24\x66\x1b\x4c\xb1\x2b\x1d\xf5\x0e\xdf\x92\x3d\xa2\x71\xd5\x68\x78\xa8\x71\xd5\xf0\xe1\xbf\x4d\xf8\x6f\x1b\xfe\xbb\xee\x01\x2d\x90\xff\x36\xe1\xbf\x6d\xf8\xef\x3a\xfc\xd7\xef\x93\xff\xb6\xba\xc5\x66\xf6\xf4\x29\x43\xea\x29\xda\xda\x39\xa6\x21\xdc\x11\x15\x87\x10\x11\x08\xd2\x28\x1f\x4d\x56\x78\x99\xd5\x02\x15\x52\x7a\x93\x89\x0f\x2b\xf4\x41\x92\x30\x56\xf0\x55\x4e\xa3\x07\x88\x2e\x7f\x08\x93\x23\x9c\xe1\x7c\x03\x39\xb6\x48\x36\x08\xc7\x9f\xa2\x29\xb3\xfc\x4d\x86\x28\x3e\x4a\xe0\x34\x36\x0a\x32\xd4\xc7\x38\x06\xef\x00\x76\xbf\x15\xc4\x21\x98\xf0\x85\x51\x88\xe2\x24\x67\x66\x98\x26\x29\xd0\xfc\x2f\x1c\x12\x37\x17\xfd\xf0\x09\x5f\xbf\x4b\xa3\x24\x3d\xa2\x16\xc0\x9b\x9b\xc5\x7b\x2b\xe9\x70\xb3\x30\x6d\x4e\xcd\x0e\xa8\xe2\x1b\xff\xe3\x06\x87\x9b\xf6\xe6\x8b\xb7\x16\xfe\xfc\x09\x5f\xff\x9a\xa4\x60\xc4\xf8\x09\x5f\xaf\x5c\x92\xdf\xf6\x62\xc7\xd1\x67\xcc\x4a\x65\xd1\xf9\x4b\xc2\x80\xd0\x2a\x6a\x97\x2d\x23\xe1\x07\x90\xc2\x00\x99\x60\xf9\xc8\x71\x1c\x8b\x67\xde\xe0\x12\xea\x56\x6a\x81\xf4\x3f\x1b\x8c\x30\x39\x7e\x20\x22\x42\x5b\xfa\x90\x1d\x25\x97\x04\x76\x8d\x37\xb3\x44\x76\xe9\xa7\xa5\x7d\x90\xe1\xda\x87\x85\x37\x2a\x8d\xb3\xf4\xee\x54\x5f\xaa\x85\x89\x28\x41\x87\x8a\x1e\xf4\xe7\x0b\x86\x21\x7b\xb6\x48\x21\x88\x91\x9d\x28\x4f\x07\xc9\x5a\x8e\xfc\x49\xa8\x9c\x42\x9d\x33\x3a\xb2\x30\xe3\xec\x8d\x85\xd5\xb8\x19\x16\x92\xf6\x13\x03\x38\x44\xd3\xd1\x87\x52\x46\xfb\x07\x86\xf8\x3f\x04\xe2\x4e\xcc\xd9\x2c\x1c\x25\x39\x22\x24\xe9\x2e\x94\xcb\x7b\x80\xba\x05\x94\x42\x3e\x9e\xf5\xab\x40\x06\xf1\x89\xc3\x3c\x93\xf6\x36\xf8\x50\xec\x54\x4c\x46\x3b\x93\x76\x31\xb9\xc4\xba\x52\x00\x30\x65\x90\xd9\xeb\x39\xd8\x1e\x44\x57\xc0\xb6\xcb\xb0\xfd\x7d\x13\x98\xf8\x29\x1b\xe4\xd5\x82\x3a\xbe\xa0\x06\x43\xdd\x32\xd9\xa8\x98\x70\x20\x2d\xb6\xee\x7e\x46\x5d\xc2\xcf\xb4\x09\x43\x9b\x9b\xa8\x3d\x6f\xd2\xbe\xbb\xa1\xb5\xf7\xd9\x31\xe2\xae\x35\x63\xd0\x3a\x1b\x92\x33\xf4\x3b\x91\x25\xcc\x45\x34\x97\x9b\xcb\x32\x5d\x39\x9b\x89\xe2\x8b\xd7\x16\x4e\x63\xbc\x76\x33\x1b\x52\xb4\xe0\x37\xe2\xa9\x60\x39\xfc\x95\x83\xeb\xc8\x0c\x8b\xf1\xd1\x65\x51\xc7\x46\xbc\x70\x64\xe4\xcd\xfc\xa3\x84\x68\x9c\xec\xe4\x7e\x39\x53\xdb\x0a\x6e\x1e\xe2\x2f\x50\x1b\x1c\x59\xe8\x43\x19\xed\xab\x73\x71\xca\x21\x30\x49\x73\xc1\x8e\x94\x00\x53\x85\x6e\x75\x0d\x11\x52\x54\x85\x6b\xc7\x52\x3a\x43\xbf\xbb\x17\xa7\xe3\x4f\x15\xbe\xed\x2b\x50\x47\xa0\x75\xaa\x2e\x45\xfb\x1c\x38\x25\x59\x4f\x9a\x1e\x1c\x0f\xd2\xeb\x29\xb5\x8c\x95\xe5\xbc\x03\x0f\x25\xc3\x61\x86\x73\x63\x66\xe8\x1a\x09\x93\x9e\xa8\x57\x14\xf6\xcc\xbd\xda\x2b\x4e\x88\xc5\x4f\xbf\xf8\xd9\x2c\x7e\xb6\x3c\x60\x31\xf2\x29\x43\xc1\x35\xc4\x8b\xe2\x4a\xb8\xe6\x65\x30\x45\xcd\x38\x04\xd9\xb3\x9d\x8f\x1c\x42\x0c\xa1\xef\x83\x53\x0a\x86\xc8\x2f\xfa\x90\x2a\xdf\xd4\xb2\xad\x92\xb2\x2d\xeb\x91\xa8\xca\x10\xaa\xb4\xea\xa9\x04\xaa\x3e\xfa\xea\x63\x53\x7d\x6c\x79\x42\x61\x61\x6c\xde\xab\xab\x68\x9f\x9c\x7c\xbf\x8b\x31\xb2\x4f\xba\x32\x4c\xd6\x59\xf7\xd0\xdd\xc8\xcd\x46\x34\xec\x40\x50\x59\xb2\xb6\x0c\xec\x2b\xcc\x62\x85\xc2\x85\x24\x15\xd5\x09\xa6\x16\x1d\x57\x43\x1a\xac\x33\x78\xfd\xbb\xc2\x6c\x1b\x36\x0d\x50\xe6\xeb\xd3\xa1\xd5\x32\xe6\x07\x6a\x35\xd5\x5a\x4d\xbd\x96\x55\xdb\x94\xb5\xf4\xe9\xd4\x6a\xb5\x6c\x6a\xa8\xd7\xda\xd9\xc1\x7e\xf4\x97\xb7\x40\xdb\x89\xe1\xc8\x72\xc6\x11\xfb\x2f\x1d\xd5\x4d\xe4\x3f\x67\x3f\x5f\xf0\x19\x62\x2f\x1c\xfb\x2e\xcc\x71\x34\xcc\x81\xd2\x3d\x87\xa2\xac\x74\xe2\x38\xea\x39\x99\x3c\x49\x5d\xd3\x10\x92\xd7\xef\x92\xa2\xab\x96\xf9\x86\xdc\xf5\xbb\xa4\xd4\xaa\x65\x4d\x5d\xea\xfa\x5d\xd2\x5f\x65\x2d\xe9\xb5\xb1\x0d\x2f\x2d\xd9\x36\x00\x40\xce\x57\x91\xf3\x1d\xc8\x35\xe7\x20\xd7\x2a\x45\xae\x71\x4b\xe4\x9a\x2a\x72\x4d\x07\x72\xad\x39\xc8\x35\x4a\x91\xf3\x6f\x89\x5c\x4b\x45\xae\xe5\x40\xae\x31\x07\x39\xbf\x14\xb9\xe6\x5c\xe4\xac\xa4\xfb\x7e\x0a\x36\x44\x59\x1e\xe4\xd8\x2c\x00\xec\x24\x6f\x58\x3a\x06\x2c\x23\xd7\xf5\x68\xf0\x85\xcc\x45\xde\xb4\x7d\x21\x03\x91\xeb\xda\x71\xab\x12\xc5\xba\x9e\xe6\xf0\x3e\x58\x3e\x35\x7a\xf2\x90\xd6\x8e\x7e\x6a\xb1\x2c\x1f\xfd\xd8\x62\xae\x20\xe5\xdc\x52\x2c\xa1\x7a\x35\x4a\x10\xeb\x87\x63\xe7\xbb\xb1\x33\xd7\x8f\x81\x9d\xb1\x84\x54\xec\x1a\xb7\xc1\xae\x29\x61\xd7\x74\x63\x67\x2e\x20\x03\x3b\x63\x0d\xa9\xd8\xf9\xb7\xc1\xae\x25\x61\xd7\x72\x63\x67\xae\x20\x03\x3b\x63\x11\xa9\xd8\x35\xe7\x63\x67\x52\x2b\xe6\x81\xad\xed\x72\x09\xdd\x86\x2d\xeb\x48\x17\x72\x8c\xe5\xa4\x6e\xae\x96\x55\x65\x88\x3e\x2d\x97\xec\xc3\x8e\xc2\x1b\xa8\xd9\xe9\xae\xb6\x9a\x4c\x03\x5d\xb7\xa9\x82\xb9\xc4\x22\x04\xa4\x8c\x39\x0e\x33\xd5\xf0\x93\x8c\xa5\x88\x42\x90\xf5\x7b\x18\x0c\xb0\xd0\x11\x0b\x20\xff\x8d\xaf\x82\xc9\x54\x9c\x94\x8b\x0f\x7c\x4e\x29\xac\x1c\x5f\xe5\xd2\xed\xf6\xca\xd6\xce\xf1\x0a\x3b\x47\xd4\x26\xdc\x22\xfd\x13\xbe\xf6\xd0\x60\x78\x2e\xa4\xf9\x02\xca\x74\x1c\x10\x24\xae\x72\xa4\x43\x61\x12\x7e\xad\x68\xc7\x06\x88\xe9\xb4\x7b\x16\x25\xf6\x07\x1a\x35\x75\x0f\x8f\xa7\x38\xad\x6d\xed\xd0\x6b\x7d\xaa\xb3\x7f\xfc\x88\xd9\xac\xc8\x4d\x3e\x7f\xfc\x18\x22\xe0\x82\x01\x89\x62\x55\xb0\xd1\x69\x7a\xdc\x2e\x61\xa3\x03\xb6\x23\x92\x65\xc2\x46\xa7\xed\x15\x26\x09\x1b\x1d\x70\x61\x9c\x84\x9d\x1f\x37\xba\xfe\xcd\x99\xd7\x69\xde\xc9\x5a\xe4\x5b\x9a\x89\x7c\x35\x63\x8e\x6f\x68\x96\x41\x57\xc2\x53\xc4\x0c\x28\x48\xf3\x68\x90\x4c\xa6\x49\x0c\x21\xd7\xc9\xb7\xd5\xc7\x8f\xc4\xbc\x8f\xa3\xfe\x0a\x2b\xfa\xe5\x8b\x6c\x00\x20\x9c\x3e\xef\xd9\xb8\x23\xc8\x70\x61\xd5\x11\x64\x58\xfa\xf6\x6b\x92\x86\xe0\x96\x2e\x0a\x88\x37\x32\x84\xd9\x10\xec\xc5\x80\xd6\xb7\xf8\x2d\x4f\x01\xd3\xfa\x59\xc1\x0c\x83\x67\x55\x8f\x2c\x54\xe9\xfd\xfb\x7c\xb8\x0e\x50\x70\x3c\x58\x21\x0f\x1a\xd6\xdd\xb6\xf8\x4a\x1f\xcb\x0c\x51\xc4\x97\x9d\x8b\xe9\xeb\xed\xdd\xe2\xb2\x89\x3e\x5b\x6f\xb0\xfa\x19\x35\xcf\x23\xcb\x8a\xdf\x62\xe5\x78\x32\x1d\x07\xb9\x8d\x41\x89\x20\xd3\x7f\xc4\x2c\x20\x0f\xd7\xa0\x82\x53\x81\xe0\x75\xa0\xf7\x8b\x3e\xe3\x15\x1e\x60\x72\x03\xb5\x51\xcd\x6f\xae\xa3\x7e\x94\x67\xf5\x32\x80\xd1\x85\x05\xde\xfe\x2f\xb7\x05\xf7\x61\xe7\x6d\xef\xc3\x6f\xbb\x87\x47\x07\x1f\x0e\x0e\xb7\x77\xd0\x16\x84\x36\xc8\x83\x38\x47\x29\x9e\xa6\x38\xc3\x71\x1e\xc5\xe7\x5c\x11\x43\xc8\x70\x92\x84\x45\xdf\xad\x30\xb7\x77\x2a\xc1\x64\xec\xd4\x80\x29\x5d\x0a\x6a\x26\x47\xe2\xd1\x4e\x51\x96\x4b\xc2\x62\x36\x29\xba\x3d\x70\xfb\x9e\xa5\x60\xf0\x20\x72\x7c\xc8\x45\x94\xe2\x52\xef\x04\xdd\x93\x39\x40\x27\x23\x4c\x46\x3d\x4f\xd0\x8c\xb9\x09\x10\x16\x80\x48\x61\x00\xad\x80\x5c\x2d\x1e\x06\xc3\xf3\x0d\x20\x5d\x8e\x6b\x5d\xde\x51\x0d\x6c\x61\xbb\xc8\x28\x6c\x46\x7e\x51\xec\x9a\x0c\x1b\xfa\xd4\x1e\x53\xc2\x9d\x90\x1e\x41\xfe\x13\xbe\x5e\xb1\x96\xe5\x9e\xa1\x83\xe1\x39\xaa\x1d\x42\x2b\xc1\xb8\x0e\x75\x06\xb6\xc1\xab\x38\x06\x6a\x5b\x3c\x8e\x28\x9d\xd0\x1b\x42\x22\xbc\x77\x84\x50\x06\x65\x7d\x22\xe7\x8a\x68\xe0\xfe\xae\x4a\x09\x66\x01\xa4\x48\x0b\xf2\x1e\xcf\xaf\x9e\x57\xe8\x36\xbd\x43\x87\x39\x49\x6b\xec\xf2\x0c\x86\xd0\x43\x7f\xa0\xe8\x62\x03\x45\x17\x05\x6f\xbc\x51\x4c\x0f\x94\xf9\x56\x21\x6d\x28\x61\xa1\x98\xe4\xa0\x6b\x00\xe4\xc4\x21\xb4\x3e\xbb\x71\x56\xd7\xaa\x45\xf6\xd0\x25\xb4\x8a\xf4\xe4\x58\x88\x0f\xf4\x74\xbf\xf4\xb4\x8d\xef\x8b\x9e\x04\xa4\xbb\xd1\x93\xca\xa7\x6f\x41\x4f\xfb\x71\x94\x47\xc1\x38\xfa\x8c\x33\x14\xa0\x18\x5f\x8e\xaf\x19\x86\x21\x1b\x8e\xf9\xb4\xc4\x77\x8d\xab\x61\x92\x4e\x0e\x92\x10\xa3\x1d\xea\xab\x06\x61\x9a\x0b\x4e\x97\xa4\x32\x9d\x82\x75\x35\xb8\xf9\x71\xaa\x15\x9b\x8c\x9d\x0c\xbf\x3b\x92\xbd\x37\xb2\xaa\x99\x1f\x6c\x9c\xe2\x96\x04\x17\xc5\x91\x62\x61\x23\xa6\x49\x22\x17\x8b\x8a\x7a\x6b\x3a\x25\xb4\x00\xa3\xc5\x13\x54\x67\x96\x6b\x06\x32\xc4\x9b\xe2\x27\xdf\x14\x29\x0d\x9a\xa7\xe2\x9c\x48\xce\xd4\xb0\x3e\x49\x27\x74\xda\x03\x9b\xee\x86\xd2\x77\x41\x52\x9b\x05\x79\x3d\xb7\x95\xa4\x76\x34\x60\x2b\x63\x3d\x8b\x47\x94\xd0\xa9\x07\x80\xad\x1f\x60\x5f\x54\xab\xbc\x70\xc0\x46\x47\xe5\xc3\x10\xcb\x21\x13\x2d\x81\xf6\xec\x8e\xe4\xc3\x96\xa0\x89\x9b\x32\xc3\x69\x15\x23\x2a\x6a\x54\x14\x06\x79\x80\xfa\x20\x7b\xa9\x25\x1c\xf2\x18\x80\xa6\x99\x2e\xb8\xb7\xb3\x0e\xf8\x1d\x4e\x61\x2e\x07\x49\x3c\x48\x71\x8e\x97\xd9\x70\x8c\x93\x73\x85\x29\x4b\xf7\x52\x47\x8b\x8d\x35\xc4\xd3\x00\xcc\xa9\x7b\x0b\xe3\x29\x38\x94\x58\x0a\x0e\x17\xd8\xf4\xbe\x64\xcc\x15\x86\x00\x65\xca\x4e\xc2\x1b\x78\x1b\xac\x01\x09\x7c\x85\x9d\x4b\xe2\x4f\x02\x16\x0d\x9a\xc5\x82\x11\x44\xf1\xf9\x3d\x70\x93\xa2\xf3\x9b\x9c\x3c\x18\xfc\xda\x13\xd2\xe6\x13\x95\x4c\xaa\xd4\xbb\xe4\x98\x3b\x29\x8c\x95\xdc\xd0\xa2\xbc\xd2\xa1\x73\x70\x0f\x1c\x87\xb6\xd9\x0f\xe0\x8b\x5c\xdd\x46\x53\xb4\x3d\x14\x5c\x04\xd1\x38\xe8\x8f\x31\x35\x43\xcc\xdc\xdb\xe2\x07\xde\x99\xca\x54\xb5\x1b\xc5\x6c\xe3\x2b\xdd\xa7\x18\x5c\x75\x9f\x79\x9b\xe4\xcc\x3b\x9a\x06\x4d\xa3\x90\x8a\x5d\x03\x45\x19\xc2\xc3\x21\x1e\xe4\xd1\x05\x1e\x5f\xa3\x00\x85\x38\xcb\xd3\x19\x3c\x7b\x28\xc5\x41\xb8\x9c\xc4\x03\x5c\x69\x9f\xa9\x4a\xbd\x80\xc6\xd7\xa2\x61\x0a\xfc\x6b\x53\x32\x1f\xc9\x5a\x75\x22\x16\x55\x16\xa5\x7e\x51\x71\x3e\xf9\xf3\xa2\xd5\xe9\x7f\xb7\x98\x8b\x19\x14\x52\x4b\x44\xc3\x52\x00\xa8\x74\xb5\x28\x45\x2d\x17\x25\x0b\x30\x64\x88\x87\x44\x50\x65\x0b\x0e\x87\x2c\x5e\x26\xe7\xd4\xbb\xd2\x84\x58\x17\x9f\x59\x7b\xae\xb2\xd9\x6f\xae\xaf\xb6\x9a\xf2\x27\xaa\x12\xb1\x7d\xd1\xe4\xa0\x0d\xe4\x2b\x5f\x55\xf9\x77\x03\x35\xab\x9c\x9d\x32\xab\x2a\x3b\x98\xaf\xc8\x46\xce\xb5\xc9\x4f\x2d\x6c\xa4\x4f\x46\x58\x12\x0a\x58\xa2\xad\x00\x8d\x40\x6b\x4c\x84\xcc\x0a\x4b\x91\x8b\xb0\x5b\x31\xc7\x07\x02\x0c\xf0\x65\x4d\x84\x26\xb6\xae\x2d\x1d\xfa\x06\x87\x25\x66\xed\x6d\xaa\x3c\x35\x1d\xb9\x21\xdb\x3a\x57\x99\x52\x6f\xc3\xe9\x37\x45\xfe\xc4\xa7\x0c\x8f\xf1\x20\xa7\x0d\x1f\xe7\x69\x90\xe3\xf3\xeb\x9a\xcb\x5c\x5b\xd2\x3e\x83\xb8\xb8\x89\x9e\x50\x56\xfa\xc4\x69\x1e\xc6\x66\xe3\x5d\x90\x65\x84\x4d\xbc\x0c\x32\x1c\x2a\x1e\x73\xf2\x5f\xb9\x71\x18\x03\x75\x8c\x53\x38\x70\x91\x5d\xcd\x0d\xa9\x7c\x91\xeb\xb9\xfd\xd8\x7d\x46\x89\x8d\xba\x0b\x29\x46\x4e\x32\x63\x33\x6f\x58\xca\xec\x46\x8b\x20\x60\xf6\x79\x10\x17\x37\x14\x45\x0f\xb9\x2f\x70\xf4\x31\xf0\x1c\x96\x9e\x8c\xec\x37\x8c\xfe\x6b\xf7\x39\x77\x42\x5b\xbd\x29\xf2\x50\xe9\x8d\x91\x8e\xb9\x65\x42\x75\xb6\x2d\x73\xc9\x5a\x9d\x69\x78\xed\x57\x6f\xaa\x0e\x3b\xcb\x53\x1c\x4c\x6e\xa5\xca\x06\x19\x8a\x29\x9f\x65\x1b\xfc\x56\x73\xb9\x1f\x51\x83\x6d\xf5\x44\x43\xa5\x13\x08\x63\x2d\x69\xa6\x7d\x54\x6b\x35\x55\xc5\xb4\xa4\xf0\x3d\x06\xfc\x34\xb5\xaf\xfe\xb2\xc4\x23\x64\xd7\xb2\xd7\xda\x76\x58\x2e\x22\x4e\x83\x14\x8e\x5b\x36\x01\xd1\xdc\xde\xe0\x78\x53\x58\x57\x71\xa1\xf1\x87\x1f\x9e\x0c\xc7\xb3\x6c\xf4\xa4\xda\x36\x47\xa1\xb8\x36\x3a\x31\xcc\x1b\xc8\x2f\x9b\x57\x38\xd7\x42\x56\xd3\xa9\x7c\x5b\x2a\x2b\xcf\x3f\x4c\xe8\xd9\xb7\xb7\xc2\x7e\xfc\x71\x33\x9f\x42\x14\x8f\x1d\xa8\x67\x50\x89\xd4\x86\x74\xbb\xc9\x0e\xda\x86\x73\x30\x7b\x2f\x2b\xbd\xcb\x14\xf4\xb2\x8a\x72\xc2\x93\x73\x15\xf2\xf5\xc2\xbb\xe9\x96\xda\x23\xab\x42\x50\xcf\x2c\x53\x28\xf8\x81\xaa\xbf\xc1\x7e\xc8\x67\x8a\x6f\x77\xa0\x87\xed\xbd\xec\x19\xaa\x68\xce\x51\xa2\x0b\xea\xb5\x73\x1b\xcd\x73\x01\xa3\x54\x57\x28\xea\x72\x45\x93\x54\xef\x56\x1a\x67\x31\x9d\xc5\x01\xe9\x3f\x73\x3a\x0b\x4d\xf0\x82\xd3\x69\x55\xfc\x56\x9c\x4e\x51\xf7\x0e\xd3\x59\xa6\xf0\xad\x76\x75\xf0\x4d\xa7\xf3\xce\xd3\x55\xb2\x04\xe6\xcc\x97\xae\x37\x2d\x99\x24\xba\x99\x08\x3d\xef\xc0\x26\xd6\x31\xab\xeb\x0b\xb4\x89\xa2\x0b\x79\xb6\xca\xb6\x08\xb6\x63\xd2\xb8\xd2\xbd\x51\x10\xc5\x90\xf2\xc4\x75\xd7\xfa\x12\xec\x06\x3e\xf0\xce\xa3\x4d\x77\xf0\x01\x5d\xc5\xa6\xec\x20\xa4\xae\x41\x0c\xd2\xd0\x14\x8d\x69\xbb\x84\xb8\x13\x7d\x5e\xc6\x51\x5e\xf6\xf8\x76\xa0\x9d\x84\xa4\x26\x94\xb9\x23\xbd\x7a\xd9\xb3\xec\x3d\x26\x78\xda\xc4\x3b\x11\xfe\x33\xe7\x6a\x0c\x4a\xa5\x41\xce\x8c\xba\x57\xf4\x3a\x06\x0c\x8d\x66\xa9\x74\x24\xb4\x22\x4c\x58\x4a\xb8\x8c\x84\x54\x4e\x88\xac\x37\x24\xcc\x2e\x8b\x00\x61\x3f\x2f\x47\x98\x45\xde\xa7\xf8\x41\x20\xcf\xac\x02\x72\xe6\xc2\xb0\x17\x24\x7f\x30\x95\x4c\xd4\xa1\xde\x00\x90\x1e\x0f\xba\x20\x5c\x1b\x74\x59\x56\x9e\x0c\x54\xa8\x00\x0d\x33\x79\x15\x8a\xd3\x16\xda\xea\x00\x8b\xf4\x1b\x12\x79\x21\x39\x0c\x67\x0b\x21\x56\x68\x72\xc4\x2b\x87\x39\xeb\x6f\x87\x47\x70\x5e\x66\x44\x67\x96\xb9\x4a\x52\xe8\x57\xa1\xe8\xf6\x90\xd2\x2f\xaf\x68\xd6\x26\xf4\x33\x3c\x64\x5f\x97\x9a\x3e\xba\x56\xcc\x8e\xf0\x04\x83\x14\x0e\xbb\x2b\x25\x01\x76\x15\x05\xa7\x7d\x70\x68\x87\xd7\x66\x75\x2e\xc1\xe2\x0b\x1e\x76\x9e\x32\x53\x9a\x4f\x9e\xe3\x2d\x4c\x01\x9d\x1d\x90\x3d\x77\xe6\xae\xdb\x10\x57\x58\xb7\x62\x9f\x7a\x58\xb7\x0f\xeb\x16\xdd\x7e\xdd\xde\x65\x75\x80\x85\xf0\x28\xca\x16\x5e\x1b\x56\x4c\x18\x45\x03\x17\xf9\xed\xf0\xc8\xc9\x01\x64\x0f\x32\x83\x03\xdc\x95\xed\x58\x31\x3b\x29\x86\xa6\x8f\x07\xc9\x84\x2d\x1d\xc2\x16\xa2\x64\x96\x55\x67\x1e\x62\xb0\xaa\xb2\x07\x41\x4a\xbc\x1b\x35\x27\xee\x0b\x79\x40\x81\x88\xc4\xa5\x25\x9b\x87\xff\x28\x49\x32\x8c\x26\xd1\x15\x91\x85\x2c\xfd\x03\x4f\x50\x53\x48\x43\x32\x21\x32\x29\xcc\x45\x76\xc9\x05\x48\xa7\xe4\xa4\x93\xcd\xfa\x19\xfe\xdf\x19\x8e\x73\xab\x8a\x01\xa9\xa2\x9d\x94\xd5\x43\x1d\x45\xa7\x6a\x50\x46\x49\x9b\x95\xf9\xaa\x7e\xb2\xb3\xd9\xb0\xb2\xc5\x48\x2a\x56\x9b\x35\x52\x12\xf9\x83\x09\x2c\xac\xc7\xa3\x33\xf4\xfb\x26\xad\x77\x1a\x95\x86\x2e\x29\x7e\x73\x13\xe8\x97\x3d\x56\x5e\x09\x68\x22\x89\xb6\xef\x82\x30\x24\x13\x38\x47\x01\x32\x85\x2c\x57\xbd\x15\xfa\xaf\x5d\xfd\xf1\xee\x75\xef\x18\xfd\x9f\xce\xea\x1a\x9a\x32\xa0\x19\xd3\xe5\xd9\x60\xbe\xfb\x34\xc8\xd6\x40\x4e\x9e\x06\xe1\x0a\x7f\x2a\x91\x8d\xdf\x05\xfc\xfa\x79\x96\xf1\xd0\xf9\x22\x10\x0a\x33\x57\x86\xb8\xc9\x02\x8f\x85\xec\xaf\x00\xb2\x7c\xfb\x4c\xd0\xb2\x56\xb2\xeb\xf1\x58\x08\x28\xe9\x3e\x12\x00\x65\x22\x98\x25\x19\x14\x08\x67\xf9\x95\x8f\xcd\xe2\xf0\x25\xc6\x95\xfc\x2a\xae\xd7\x3c\x2d\x6e\x96\x72\xc1\x1c\x84\xfa\xe5\xda\xad\x19\x88\xa8\x46\x63\x9d\x6c\x4a\xe3\xe5\x8a\x19\x32\x8b\x73\x41\x3b\xe0\x57\x64\x42\x8d\x19\xc1\x1a\x40\xe9\x8b\x65\x9a\x72\x5a\x44\x58\xf9\x87\x56\xc0\xd6\x2c\xbd\x17\xe2\xed\x9a\xa1\x17\x68\xa6\x37\xf8\x4a\xe8\x05\x22\xa0\x28\x58\x14\xbe\x2e\xc6\x7b\xe6\xe0\x62\xbc\x07\xb7\x16\xe5\xed\x5c\xcc\x4a\x91\xca\xca\xc3\x17\x14\xec\x47\x6d\x13\x45\x68\xc9\xe5\x96\x2f\x43\xa7\x61\xee\xa5\x37\x25\xd2\xab\x86\x1d\xda\x2c\x6c\xdf\xf9\xe1\x5f\x06\xed\xa9\x28\xd9\xcc\x10\xb6\xc2\xd0\x3e\x08\x30\xd7\x83\x24\x1e\x04\x39\x87\x59\x59\x03\xf3\x3e\x9e\x0a\x86\x02\x4b\x76\x14\x84\x34\x90\x11\x5b\xa8\xdf\x86\xcb\xcc\x62\x9d\xcf\x7c\x13\x8e\x00\xcd\x56\xb8\x72\x87\x72\x3a\x4b\xb0\xf1\x81\x57\x38\x57\x12\x17\x4b\x8b\x18\x62\xc0\xa2\x71\x90\xe5\xf0\x3c\x7f\x4d\x17\xe2\xf5\x69\x4d\x5d\xce\xcb\xc8\xaf\x53\x17\xb3\x33\xe6\x0c\x66\xf3\x24\xa6\x82\x83\x9b\x62\x0a\x70\x9b\xfa\x1a\x94\x36\x53\xba\x6d\x2e\xa8\xe7\xff\x33\x2e\x82\x6c\x2e\x0a\xf6\x9b\x05\xdb\xad\x42\xd9\x3d\xd0\xfd\x19\xfd\x1f\x24\x21\xbe\xa1\xea\xc1\x13\x71\x5a\xa3\x97\x22\x70\x92\x90\xba\xd3\x7b\xd9\x73\x41\x61\x73\x75\x23\xe8\x8b\xc0\xd2\x85\x0d\x13\x22\x90\xbc\x83\xc0\xc1\x8f\x80\x0d\x80\x64\x38\xa9\x11\x38\xc1\x14\x30\xf3\xb4\x53\x1d\x6d\xdb\x68\xe2\x46\xf1\x46\x58\xc0\x30\x90\x4e\xb4\xfa\xb1\x27\x59\x1f\x96\xdb\x00\x96\x04\x38\x53\xed\x43\x2d\x7e\x9c\x20\x37\x93\x11\x50\xd4\xa2\x48\x55\xec\x92\xef\x13\xb0\xfd\x74\xe0\x5f\x4c\xac\x79\x18\x30\x6c\x49\xb9\xa4\xad\x1a\x97\x38\x4f\x0c\x04\x2a\x6c\x89\xa0\xd1\x80\x53\xb9\x76\x37\x63\x97\xf6\x57\x9f\x96\x37\xaf\x5a\xaf\xd4\xd1\xd3\xd5\x85\x31\x10\xaa\x16\xc7\x59\xe6\x35\xc6\x53\x14\xe4\x68\x8c\x09\x17\x4c\x62\xbe\x02\x58\x96\x0f\x6a\x09\x0a\xfb\x35\x30\x5c\x93\x6f\x21\x71\xbe\x99\x44\x31\x35\x12\x65\x87\x78\x23\x5c\xa2\xfa\xc8\x2a\xd1\xe9\x93\xf0\xa7\x84\x34\x01\xfb\x63\x7a\xe4\x8d\x2e\xd0\x4f\x3f\x59\xf5\xf1\x7a\xa0\x8e\x77\xb7\xd2\x65\x14\x98\xa8\xca\x14\xe7\xf9\x5c\x6f\xb6\xea\x95\xb4\x5b\x24\x2d\x44\x12\x61\x28\xcd\x5e\x59\x08\x9a\x37\x77\xbf\x84\xbc\xba\x4a\x0e\x32\x34\xdd\x97\x4b\xe4\x02\x79\x9d\x99\x7e\x81\x04\x0e\xbf\xe7\xea\x20\xf8\x55\x3c\xb5\x11\x74\x9d\x92\x6f\x75\x19\xff\xf5\x96\xd5\xd7\xc5\xdb\xda\x1e\x48\x7e\x73\x66\x80\xca\x47\xb6\xf6\xe6\x59\xfe\xdd\xd1\x52\x01\x4c\xef\x98\xec\x61\x37\x43\x41\x83\x64\x3c\xc6\x94\xfe\x93\x21\x17\x0d\x40\xd4\xc4\x90\x4b\xaf\x4c\xf4\x90\x44\x51\xc9\xc9\x9b\x6c\xa3\x69\x70\x29\xbd\xb2\xfa\x25\xda\x5d\x3f\xa8\x03\xba\x10\x52\xaa\xd4\x2e\x2e\x1e\x21\xc3\x03\xe3\x82\xb4\x3e\x59\x9f\x86\x39\xae\x0b\x50\x16\x8c\x29\xf6\xf0\x03\x80\x81\x4a\x32\xa0\xe1\x47\x71\x1a\x5d\x50\x59\x85\x73\x0c\x2b\x40\x7e\x95\x5a\xc8\xf9\x92\xe5\xa0\x19\x6b\xb5\x9a\x5c\x73\x9b\x9e\x95\xcb\x37\x83\x11\x9e\xdc\x0e\xae\x5d\xe0\x64\x2a\x73\xb0\x98\x1e\x4a\xf0\xac\x20\x68\x4e\xc6\x9b\x22\x67\x23\x3d\xc5\x50\x11\x8b\xbf\xd5\xc5\xb0\x41\x12\x5f\xe0\x34\x57\x64\x58\x9a\xed\x8e\x1b\x53\x82\xc5\x27\xb5\xfe\x73\xbb\xad\xbe\xa3\x55\x54\xe7\x55\xf1\xb2\xa2\x3d\xcc\x7c\x17\x2b\x15\xb5\xf9\xc7\x3a\xe1\xdd\x24\xe3\xa3\xd9\x89\x06\xb1\x48\x62\x35\x4d\xb2\x2c\xea\x8f\xb1\x7b\xc5\x5a\x9a\x5a\xcc\xb9\xa9\x18\x28\xd3\x1e\x94\x7e\xe3\x27\xf0\x3f\x0c\x28\x48\xa8\xcf\xc9\x0a\xde\x90\x7e\x17\x0e\x4f\xd6\x4a\x9f\xf0\xf5\x86\xea\x17\x65\x2d\xa6\x79\x4a\xd9\x0b\x91\x65\xbc\x01\xff\x9d\x53\x50\xac\xca\x0d\xd3\x9d\xcb\x5e\x83\x89\xf0\xba\x65\x82\xbd\xb0\x90\xeb\xd5\xa3\xf3\xeb\xde\xf1\x9a\xbd\x82\xc4\xc2\xdb\xf6\x12\x62\xe1\x48\x40\xe9\xbb\x95\xc3\x29\x8e\x8f\x8f\xdf\x18\xd5\xaa\x3b\x93\xc9\xd3\x6f\x17\xbc\x26\xd1\xd5\x7e\xac\x96\xab\x6c\x7a\x44\x57\x71\xb6\xd8\x32\x46\xce\x75\x63\xb2\x12\xcd\x37\xd0\xc1\x4d\xc8\xa1\xce\x0d\x9c\x1b\xd8\x72\xaf\x0c\xd8\x15\xe0\x77\x34\x8c\xf4\x35\x5e\x02\x07\x92\x80\x65\x34\x03\x18\x64\x8f\xc3\x85\x17\x65\x81\x71\x9c\xd0\x37\x1a\x03\x64\x39\xfb\x71\x19\xf7\xa8\xba\xa4\x29\xf2\xe2\x9a\x8e\xad\xed\x25\xf4\xe4\x89\xdd\xb7\xc2\x5a\x7e\x25\x4f\x68\xbe\x21\x97\x2b\xc7\x9c\x5a\x0e\x52\x75\x12\x26\xaf\x28\x13\xa7\x18\x1b\x97\x55\x55\x51\x02\x7d\xf9\x42\xc9\xb5\xa8\xb3\xc2\x27\xf1\x9a\x1f\x7b\x0d\x1d\x8d\x55\x4e\xa2\x54\x36\xef\x5e\x83\xb6\x03\x57\x1b\xe2\xa7\xfd\x76\x83\xf5\xdc\x46\x9c\x36\xd0\xac\xb8\x48\x65\x0c\xbb\x97\x3a\x88\xe5\xd7\x1d\x62\xd5\x05\xee\x25\x17\xf3\x66\x96\x07\xc9\x64\x1a\xe4\xb0\xbd\x54\x5d\x86\xf2\xb6\xa0\x6d\x62\x92\xf8\x53\x75\x4f\xb4\x2d\xbf\xdb\x20\x77\x5f\x86\x83\x09\x6d\xfb\x98\x93\xb7\x83\x90\x25\xea\x72\xf1\x46\x85\xbe\x45\xf1\xca\xdc\x77\x8e\x5a\x46\x8e\xb4\xa4\x2c\xc1\xe2\x8b\x2d\x50\x23\x11\x77\xb5\x0a\xe4\x9d\xed\x18\x0b\xfd\x35\x0f\xb1\xa4\xb8\x53\xd5\x72\x29\x45\xab\x31\xb4\xf7\xa7\x8d\xab\x4e\xab\xeb\x77\x07\x6b\x90\xd8\xa0\xdb\xe9\xb6\x3b\xc3\xce\xf0\xac\xce\x55\xf1\x00\x9a\x3f\x14\xfd\x70\x9c\x23\x2b\xa0\xe0\x1c\x0b\xc7\xe1\x4b\xd4\x2d\x18\x19\x0d\x6b\xb3\xf8\x9e\x57\xb6\xc6\x64\x7f\xa5\x45\x85\x47\xbe\x4e\x0a\x3a\xbd\xf5\x92\x51\x63\x36\xf0\x05\x7d\x8b\x35\x7c\xbf\x01\x1c\x4c\x61\x54\x5b\x7a\xd3\x20\xcd\x70\x4d\x59\xa8\x25\x17\x93\x69\xa6\x28\x7e\x8a\x6a\x56\xaf\x04\x52\x1c\xd1\x18\x5e\x73\x16\x1d\x25\x0c\x03\x99\x32\xf5\x6a\x19\x44\x7e\x19\x27\x1d\x86\x59\x52\x08\x03\xdc\x09\xce\x72\x6a\xdb\x10\x8c\x2d\x0b\x54\x83\x79\xda\x38\x43\x9b\x9b\xa8\x58\x7b\xe8\xa7\x9f\xf4\x76\x4f\x7d\x56\x86\xaf\x49\x97\x0a\x6a\xe7\x8a\x5e\x60\x98\x2d\x23\x95\xc3\x18\x8b\x5f\x6b\x91\x99\xf2\x34\x3d\xd4\xae\x97\x58\xd7\x25\x17\xec\x88\x0e\x57\x41\x05\x0c\xb3\xbc\x01\x7f\x0a\x0d\x34\xf4\x5b\x6b\xa3\xb8\x72\xab\xe3\x77\xab\x31\x0a\xeb\xd1\xc8\x71\x0c\xf2\xa4\xd3\x89\x2a\x9a\x97\xde\x15\xf1\x45\x78\x99\x06\xd3\x29\xc8\x91\x41\xce\x9a\x97\x55\x26\x28\x20\x3b\x7d\x26\x79\xa5\x95\xae\x5e\xc5\xd5\xc7\x70\x65\x2b\x1c\x7e\x6c\x9f\xaa\x3a\x90\xdc\xfa\xb2\x47\x08\x3d\x5c\xc6\x2f\x93\xea\xb9\x8e\x40\xee\x2d\xeb\x2c\x75\x08\x8d\x43\x4a\x35\xe2\x80\x51\x5c\xec\x58\x0e\x4e\x65\x21\xa2\x74\xef\x45\x40\x68\xc3\x10\xd5\xa4\x89\x2d\x0d\x2a\xc5\xae\x1d\xc8\xbc\x31\x6f\xba\xbb\x78\xa8\x16\xca\x27\xcb\x51\xa7\xc4\xfb\x9c\x35\x4d\x6d\x50\xd8\xef\xc2\xef\xfc\x2f\x12\xc3\xc5\xbe\x85\x6d\xfd\xb9\x1b\x18\x59\x96\x76\x8d\x8a\xb9\xac\x84\x7f\xa5\xa9\x8d\x50\x5c\x2d\x1d\xa7\xb0\xaf\xd7\x60\x11\xa4\x46\x57\x27\x7c\xd3\xc6\x3d\xb1\xda\x1c\xd2\x40\x89\xb2\xc3\xe2\x1c\xeb\xf6\x62\xbd\x5d\x08\x9d\x85\xa2\xe7\xec\xd8\xec\xd7\xa5\xe8\x06\x49\xe1\x7c\x62\x0b\x80\x66\xf5\x59\x35\xc4\x92\xc2\x33\x43\x04\x48\x60\x9d\xbd\x8d\x64\xd2\x83\xfe\x15\x30\xe1\x0a\xd8\x80\xc2\xec\x8d\x08\xc7\x15\x8e\xb9\xae\xfd\xa8\xfa\x76\x5a\xb6\x69\x2b\xfb\xab\x59\x90\xab\x16\x2d\x9f\x08\x59\x89\xbe\xad\x44\x17\x96\x22\x92\x8e\x90\xd1\x8b\x59\x86\x6a\x05\x0b\x40\x70\x21\x6a\x16\x13\xfa\xc0\xa2\x24\x7b\x65\x29\x2c\xe9\x02\x75\x0b\x6b\x4b\x69\x49\x2f\x48\x48\x6f\x68\x39\xae\xdd\x54\x3e\xb6\xb0\x7b\xe8\x4c\x4c\x9c\x50\x7c\xc9\xd7\x32\xe8\xab\x6d\x4f\x32\x01\x88\x1d\x4a\xbb\x68\x92\x1e\x21\xb5\xf7\x5f\x71\x9f\xd2\x02\xb4\x88\x48\xc7\xdf\x60\x6f\x2a\xa2\x2a\xcf\x67\xd3\xdc\x7b\xde\xc2\xa6\x39\xd9\xb1\x30\x0a\x92\x47\xfd\xad\x59\xf6\x7d\xa3\xa8\xef\x4b\xf7\xb8\xa5\x38\x63\x17\x38\x22\x0c\x7c\x83\x5d\x85\x69\x1c\x24\xd5\x82\xbc\x98\x34\xc0\xf2\x4e\xc1\x6e\xbf\xe1\xfc\x2a\x23\x5f\x70\x13\x5b\x73\x8c\x53\x98\x1b\x86\x3c\x79\xca\x26\xa6\x44\x5d\xa4\xc3\x52\xec\x4d\x12\x93\x51\x14\x3e\xd6\x6d\x42\x34\xb1\xb0\x36\xc6\xca\xd6\xf4\xb1\x52\xef\x5f\x40\xc7\x14\x64\xd9\x6c\x82\x43\xf5\x3e\x31\x18\xa7\x38\x08\xaf\xa5\xfd\x4e\x39\x90\xcd\x62\x9a\xb6\xb2\x42\x44\xb3\xc5\xd8\x9e\x9d\x7f\x2d\x74\x68\x22\x8c\x0b\x4c\xd4\xd3\x0c\x2f\xcc\xeb\xdd\xfa\xa2\x59\xbc\x28\xac\x3f\x51\xe2\x36\x48\x9e\xaa\x90\x0e\x39\x15\x20\x41\xfc\x76\x1e\xf0\xc1\xd0\x29\xc9\xab\x87\x55\xb6\xa5\xf2\x66\xb1\x6b\xe4\x45\x38\x27\x84\x0d\xb7\x09\xa1\xec\xc9\x5c\xaa\xfa\xc5\x06\x2a\xd5\x8e\x32\x68\x25\x4a\x51\x43\x33\x61\xbd\x21\x79\x6d\x37\x91\x98\x77\x65\xf2\x29\x1c\xc2\x7d\x09\xfd\xb7\xfc\xb2\x64\x9e\x15\x86\x79\x61\xf2\x9a\x42\x27\xad\x54\xbb\x27\xd9\x26\xe0\xe1\x4e\x9f\x34\x46\xd6\xf2\xfe\x2f\x5c\x61\x30\x65\xf1\x82\xaa\xab\x63\x79\x0d\x66\x79\xc1\x1e\x40\x4e\x21\xcd\x00\xe0\x72\xaf\x90\x22\x50\x39\xa6\xb6\x15\x51\xcc\x2c\x79\x99\x1d\x00\x33\x99\x39\xc7\x31\x18\xf3\x96\x43\x13\x51\xca\x1d\xc0\x68\xe8\xec\x72\x58\xa6\xce\x00\x54\x58\x92\x90\xb4\x85\xba\x6d\x30\x39\x86\x0f\xdc\x7e\x76\x7f\x88\x92\x49\x44\x64\x04\x0f\x05\xf4\xd3\x65\x34\x1e\xa3\x3e\x16\x0d\x86\x28\x0d\xe2\x30\x99\x8c\xaf\xef\xe9\x70\x4f\xad\x26\xd8\x30\x79\x68\xff\x17\x0f\xa6\x94\x34\xfe\x0d\xb8\x10\x9d\xe4\xd0\x64\x41\x12\x35\xae\xe0\x2b\x3c\x98\xe5\xb8\xf6\x84\x47\xa3\x7a\xe2\xb1\xc4\x1d\x1e\x33\xdf\x72\x88\x45\xf7\x04\xdd\x43\x4f\xc8\x70\x90\xff\x7f\xe2\x3e\x33\x53\x30\x32\x77\xe3\xd4\xec\x71\x12\xf5\x18\x75\x51\xc5\xa6\xdd\xa8\x9f\x4e\x33\x9b\x65\x87\xa2\xfa\x07\xe7\x55\x92\xa1\x44\xa6\x70\x6a\xdd\xf6\xaa\x91\xd6\xdc\xe2\x56\x47\x97\xb6\xb4\xae\x4d\x69\x85\xc6\x9b\xa5\x89\x07\x0a\x05\xae\x88\x71\x57\xa4\x41\x66\x0b\xe9\xa6\xbe\xc2\x12\x79\x4b\xe3\x01\xf8\x5b\x03\xd6\x12\xda\xcc\xcb\x31\x00\xbb\x69\x43\x4d\x2e\x92\x41\x33\x05\x39\x4f\x26\xcb\xc7\x1c\x3d\x35\xf5\xd9\x4a\x6a\xe8\x22\x85\xb3\xdd\x59\xea\x88\x89\x52\x0b\x1e\xc6\x8b\x23\xb5\x90\xa2\x6f\xa7\xd5\xb6\x69\x06\x14\x15\x77\xc8\xf8\x32\x67\x79\x1a\x4b\xf6\x04\x2c\x87\xf8\x75\x7b\x7d\xb8\x25\x4a\x9c\x50\x88\xdb\xbf\xd9\x34\x5c\x5f\x51\x3f\xfe\x7a\x7b\xf7\x06\x91\xed\x93\x5b\x50\xda\x76\xe1\x42\xca\xe3\xcc\xb6\x7c\x8b\x5b\x48\x2b\x6e\xe9\xb0\xdb\xf9\xe1\x53\x38\xdc\x90\xb6\x67\x89\x42\x16\x54\x8f\x33\x97\xaa\x45\xf6\xe5\xef\x43\x5f\x5e\x2a\x1d\x7c\x07\xea\x88\xbf\x88\xda\xdc\xb2\xf8\x2a\x69\x92\x9f\xf0\xa1\x76\x85\x95\xfd\xfa\x0d\x7b\xe8\x8f\xaf\xac\xc1\x2e\xb6\xa3\x6f\xa4\x70\xd0\x76\xd7\x24\x77\x29\x77\x6d\xb2\x0b\x01\x4f\xc4\x16\x2e\xae\x48\xd8\xd3\xe1\x15\x32\x06\x7b\xa6\xdb\x9e\xcb\xbb\x93\x8a\xb1\xb4\x6f\x46\x97\x56\x60\x8b\x55\x30\x58\xb1\x86\x24\x70\x2a\xe6\x15\x7d\x89\xfb\x3a\x43\x0e\x00\x61\xcc\x8f\xda\xbe\xa4\xc7\x37\xd0\x38\x88\xae\x68\x32\x10\xa8\x60\x1d\x52\xe9\x6c\x4d\x0d\x33\x15\xe8\x2e\xbd\x89\xf5\xc4\x77\x07\x7d\xf0\x9f\xc0\x8f\xef\x59\x41\xfc\xbd\x33\xe6\xef\x51\x4f\x6c\x63\x86\x8b\x2a\x8a\xef\xc4\x18\xef\x1d\x45\x53\x51\x7c\x5f\x8c\xbb\xa2\x9e\xf8\x9b\xf3\xee\x6f\xae\x2c\xfe\xf6\x5b\x85\xa7\xd8\xf6\x38\x4e\x68\xf7\xb7\x77\x54\xd2\x87\xbb\xef\x2f\x6c\x5b\x87\x3c\xbe\x15\x77\x8f\x32\x05\x79\xa1\xca\x13\x99\x2e\xe5\x94\x96\x2c\x7f\xe5\xcd\x99\xd7\x69\x7d\xaf\x49\x29\xef\x3d\x07\xe5\xa2\xb9\x27\x95\x9c\x93\x06\x62\x66\xfa\x49\x2d\xed\x24\xaf\xe8\x48\x3c\x09\xfa\xd1\x02\xb8\xf8\xa9\x26\x9f\x3c\x08\xf2\x91\x87\x2c\x29\x28\x8b\xe3\xf5\x9b\x64\x10\x8c\xd1\x34\x19\x5f\x0f\xa3\x31\x4a\x86\x88\x6e\x5a\xec\x14\x6f\x39\xf2\xb2\xd8\xf6\x9b\x6a\x41\xad\x61\x85\x31\x89\xd7\xbb\xe4\xfd\xcd\x73\x33\x76\x90\x64\x6b\xd9\xff\x68\x30\x35\xb0\x11\x9c\xf5\xc9\x0c\xea\x44\xbc\xbb\x32\x4d\x93\x3c\x21\x9f\xd0\x26\x39\x7d\xe8\x05\x58\x3d\xb4\x89\x62\x7c\x49\x10\x28\x87\x10\xcf\xc6\x63\xc7\x42\x11\x18\x14\xcb\x44\x8a\x77\x64\x8b\xe4\xc9\xe7\xa4\x5c\xc9\xed\x54\x6c\xbf\x89\xfa\x69\x90\x5e\xcf\xd3\x91\x4b\xf9\x41\x9d\xa0\x20\x5b\x28\xd3\x7a\x12\xe1\x82\x77\x39\x18\xa3\x28\x1e\xe1\x34\x52\x02\xb8\x2a\x11\x1d\xf4\x3c\xa3\x66\x84\x51\x73\x3a\x2b\x84\xfd\xe3\x31\x86\xc1\x3d\x4e\xf8\x19\x8c\x82\x9c\x23\xc4\x42\x79\x50\x31\xc8\x38\x55\x22\x54\x16\x07\x90\xcb\x5d\xc9\x05\x4e\xd3\x28\xc4\x19\x7a\x47\x15\x22\x11\xce\x28\x03\x9f\x5e\xa3\x28\x66\xd9\x8c\x0b\x04\x2a\xb4\xa0\xe7\x6a\x38\x59\x14\x80\x21\x73\x39\xca\x2d\x12\x35\x90\x4c\xd4\xc1\xf5\x09\x25\x61\x45\xba\x29\x31\x49\x94\xfd\xc5\x22\x3c\x0e\x37\xd0\x13\xc8\x94\xf5\x44\x37\x1c\xb1\xb7\x49\xfe\x26\x38\x1f\x25\x61\xa9\x8f\xbc\x54\x5a\x8f\x91\x6f\x73\x3c\x43\xc8\x0c\x67\x48\xd1\x57\x0c\xb2\xf9\xbc\x3a\x83\x18\x4e\x83\xcb\xd8\xfc\x22\x31\x12\x22\x2c\x14\x69\xf5\x5c\xe6\xc4\x5b\xb3\xf3\x09\x8e\x2d\xa6\xc3\x64\x47\x29\xc7\x02\x15\xcc\x87\x9d\xbb\x8a\xf2\xd6\xf4\x0f\x56\x04\x98\x99\x14\x77\xfd\x8a\x84\x63\x69\x6a\xc7\xe9\x07\xde\xe4\x28\xc8\x0e\x2f\x63\x46\xf6\xd7\xb5\x27\xa4\xe6\x93\xba\xf0\x79\x22\x8f\xb0\x09\xf2\xf2\xe4\xc5\xdc\x7e\xd0\x5a\xa5\xd3\x6d\xa9\xf5\xff\x64\xb3\x29\x11\xb5\xe2\x28\x5f\x09\x88\x70\xca\xb6\xbe\x20\x3d\x9f\x91\xd1\xb5\x8e\x07\xb2\x64\x50\x28\x19\xa7\xc2\xe3\x36\x7d\x92\xa1\x82\xa3\x47\x54\x29\xcc\x27\x9d\xae\x52\x13\x82\xdc\x41\x65\x3f\x70\x6c\x3b\x88\x2b\xc6\x87\x38\xc5\xf1\x80\x34\x00\xe3\x3c\xd5\xd7\xab\x31\x0c\x4c\x2e\xb6\x01\x74\xee\x33\xc8\x96\x1a\xc3\xc6\x54\x77\x60\xa5\x64\x32\xd3\xa4\x2a\xef\x59\x4c\xc7\x01\x26\x90\xae\x5a\x33\x04\xea\x16\x9f\x8f\x22\x83\x4d\xad\x2e\xae\xe1\x88\x28\x0d\x21\xe5\x00\x48\xad\xfe\x57\xe6\x95\x3c\x62\x39\xda\x64\x6c\x93\xdf\x59\xcc\xe5\x45\xb4\x5c\x39\xc7\x33\x1b\x81\x25\x57\xc4\xc9\x36\x57\x2e\x8f\xa0\x2e\xad\x11\xfe\x4e\x5d\x27\x4e\xaa\xe1\xc5\x6f\x43\x36\x65\xee\xea\x8e\xb9\x42\x87\x8c\x99\xb1\x24\x01\x40\x52\x60\x42\x1f\x86\x28\x4b\x26\x98\xa6\x9e\x42\x97\x23\x1c\xa3\xeb\x64\x96\x0a\x33\xfb\x80\x88\xb3\x14\xf8\x3d\xc7\xce\xbd\xeb\x2e\xa8\x3b\x3a\x97\xed\x65\x88\x32\x80\x95\x15\x73\x64\xc4\xd0\xdf\x72\xbb\x9b\x8b\x46\xa5\x39\xed\x25\x53\x22\xec\x4c\x0b\xb9\x87\xc9\x3b\x77\x10\xa7\x24\x60\xa0\x61\x52\x64\xaa\x09\x68\x22\xef\x79\x4a\xd9\xea\xa4\xfb\x67\x55\xf9\xe5\x96\xe3\x0e\x8d\x28\x97\xd8\xa2\x7f\xd6\x35\x2e\x22\x1e\xf2\xcb\xb6\xb7\xc1\x04\x8c\x26\xe6\xd4\x43\x6c\xab\x2e\x8a\xe9\x9b\xb5\x0c\xb0\x5e\xba\xc5\x92\xe9\x3c\x95\x8b\x9f\xa1\x4d\xa9\x7d\xf5\xd3\x02\xa9\x8b\x1c\x9b\xec\x0e\xba\x4c\xe2\x27\x39\x95\x9f\xb9\xbb\xa3\x14\xbc\x70\x9c\x24\x53\x14\xf4\x93\x0b\xcb\x36\x58\xde\xe5\x27\x1c\xda\x13\x77\x87\x81\x8b\x8a\x56\xe5\x7e\x8a\xb7\x15\xf2\x6a\x55\x5a\x3c\xe2\x70\x02\x3d\x05\xfb\x97\x45\xd6\x8d\x6d\xe3\x1b\x8c\x93\x18\x7f\x05\x8e\x07\x70\xd1\x66\xb1\x87\xc0\x8b\x0a\x3b\x19\x29\x36\x77\x23\x93\x73\x91\xa8\xc2\x11\xe7\xa7\x56\x7b\x32\xfb\x19\xd9\x7a\xbb\x1f\xa3\x00\x3c\x6f\xb5\x58\x84\xa5\x91\x85\x8c\x38\xef\xe5\x20\x6c\xe1\x69\x84\xf1\x83\x1a\x0e\x31\x8b\xce\xe3\x68\x18\x0d\x82\x38\x67\x01\x25\x23\xda\x7b\x00\x49\xdb\xb1\x1d\x93\x7f\x95\x3c\x88\xe9\x59\x59\x7e\x73\x0f\x61\x63\xcc\xe6\x75\xb2\x70\x84\xc1\x97\x4d\xaf\xe6\x8c\x35\xb2\x9a\x85\x89\x91\xd2\x6e\x30\xe6\x0e\x1a\xbe\xb7\x54\x2f\xb2\x7f\xb6\xb2\xb1\x1b\xb6\x30\x0e\xed\x7f\x75\x00\xa7\x8d\xab\x46\xa3\xe1\x37\x9a\x8d\x96\x87\x1a\x57\x8d\x76\xa3\xd3\xe8\x36\xd6\xce\xbe\x1a\x60\x0f\x75\x2b\x87\x5e\x61\xe1\xeb\xf8\x8c\x18\x2b\xf6\x92\x39\x04\xc3\x72\xe5\x0f\xf4\xdf\x2f\x5f\x20\x66\xaf\x26\x6a\x0c\x51\x4d\x4c\xef\x0f\x9b\x16\x45\xa1\xfc\x07\x50\x25\xa3\x21\xfe\xb3\xb2\x31\xa9\x0e\x80\x92\xc7\x18\xc7\xe7\xf9\x88\x9a\x1e\x39\xb9\x48\xf5\x98\x31\xc5\x42\x59\x2c\x52\xcc\x4e\x3c\x48\x42\x42\xef\x98\xfe\xd0\xc9\x1d\x5e\x97\xc7\xfe\x14\x04\x80\xe3\xc1\xca\x1e\xbe\x72\xb7\x39\x2f\x80\x4c\xa5\xd5\xbe\x70\x70\x97\x82\x58\x2b\x44\x76\xb1\xc4\x35\x98\x17\xd6\xc5\x52\x45\x19\x92\xf7\xf9\x70\x7d\xa1\x68\x2e\x6c\x2a\x9c\xb1\x5c\xf8\x54\x7d\xf9\x82\xf6\xf0\x55\x69\xf8\x96\x39\x04\x34\x08\x72\x1c\xb3\x3d\x5f\xa5\x20\x07\xf3\x77\x13\x92\x74\x0f\x5b\x0c\xf8\x09\xe3\x86\x12\x65\x42\x9a\xdf\x45\xef\x75\xab\xe2\x52\x85\x36\x04\x76\x3e\x8f\x9f\x21\xde\x34\xdd\x29\xcd\xa0\xa4\xce\x94\x68\x60\xe7\xc5\xc2\x91\x90\x81\xfd\xd5\x60\x58\x16\x5f\xc5\x7c\x14\x88\x50\x07\x05\x89\xb9\x4b\x47\xd9\x71\xc1\x63\x14\x9e\xe3\x00\x7e\xac\xb2\x24\x0a\xbf\xa8\x63\x74\xaa\x37\x0e\x26\x53\x84\xaf\x20\x92\x64\x3f\xd2\x3b\x47\xef\x55\x49\x19\xf3\xb6\x81\xde\xa7\x0e\x6c\x41\x52\x14\xc4\xff\xe1\x08\x94\x0e\xf5\x89\x48\x1a\x63\xd8\x6a\x51\x90\xa3\x00\xe5\xd1\xc4\x22\x71\xdb\x42\xb2\xcb\xdd\x75\x27\x85\x90\x07\x87\x14\x45\x9b\x04\x3d\x36\x0b\xa7\x11\x8f\x8a\x4d\xfe\xa9\x35\xdb\x68\x19\xd5\x22\x8a\xf1\x53\xb4\x5e\xaf\x8b\x68\xd9\x4e\x29\x9e\xc2\x51\x7b\xbc\x84\x22\x11\x6e\xfb\xcb\x66\xd1\xf4\x8b\x17\xbc\x0d\x4b\x79\xd1\x68\x05\xc1\xdf\xb9\x2d\xc9\x63\x4a\x17\xd7\x9d\xc6\xd4\x1d\xe5\xbe\x6a\xf7\x37\x91\x39\xd8\x55\x32\x06\x9b\x54\x28\x36\xdb\xa5\x4d\x15\x4d\x5b\x8e\x95\x20\x8a\x83\xbe\x7e\xf2\x90\x0e\x00\x55\xd9\x29\x8d\xc1\x41\x84\x40\x45\x30\x8c\xf2\xbb\x8a\x82\xc5\xe2\x14\xab\xcb\xc1\xa4\xc8\xe7\xaa\xa1\x7b\x2d\xac\xc9\x94\xa3\x6c\x71\x91\x9c\x4c\xc6\xce\x30\x2c\xa2\xda\xa9\x80\xc1\xe3\xcc\x6f\xc2\xd2\xa1\x7f\x40\xfa\xad\x26\x21\xfd\x4c\xe1\x0b\x16\x82\x57\x44\xa9\x4d\x74\x10\xe4\xa3\x95\x01\x8e\xc6\x45\xcd\x55\xb4\x40\x44\x22\xfb\xf9\xb7\xd2\xce\xe3\x30\x47\x32\x8e\xbf\xb7\xb5\xfb\x64\xc7\x5d\x99\x16\x8c\xf3\xae\x4a\x0b\xf3\xce\xb9\x32\x58\x38\xa9\x51\x5c\xe5\xe8\xe7\xe6\xc9\x79\xc5\xa4\x11\x66\x7e\xdf\x70\x9a\xd4\x91\x7a\x8b\x4f\x81\x24\x36\x0c\xa3\xf1\x98\x87\x9d\x65\x6e\x12\x70\xde\x9a\x2f\x94\xf0\xc3\x5c\x6c\x3b\xf4\xca\xa0\x9c\x2e\x3e\x95\x66\x99\x41\xaa\x44\x28\xf7\x65\x7c\x56\xe1\x08\xc6\x5c\x41\x7c\xf7\x49\x8b\x96\x90\xc9\x24\xb6\x1f\xb1\x64\xf6\x60\x1e\xa8\xc8\xd7\x54\xbd\x21\x9f\x7c\xb8\x74\x47\x99\xff\x70\x89\x36\xc9\x7f\x1d\x09\xd4\x26\x1f\x3e\x93\x6d\xe6\xaa\x15\x84\xb8\xbb\xde\xd7\xc3\xaf\x8b\x62\x41\xf6\x09\xc9\x9c\xa3\xe4\x9e\xa0\xc2\xdd\x1d\x6d\xb5\xd6\xb8\x7a\xd6\xe8\x3e\x43\x4f\x49\x17\x3e\xc3\x9e\xbe\xbb\xbb\xbb\x5b\x47\x4b\xf4\xc5\xcf\x3f\xa3\xc6\x95\xdf\x80\xed\x9e\x20\xe0\xd8\xee\x69\x17\x6b\x8d\xab\x76\xb7\xd3\xa0\xc0\x2e\x75\x60\x97\x55\x81\xc1\xf0\xe2\x6c\x06\x9e\x3e\x35\x40\xe3\xc5\x0b\x5a\x13\x2d\x21\x18\xe9\xd2\xfa\xac\xee\xea\x26\xd4\x61\x7f\xe5\x65\x97\x36\x51\x63\xa5\xe3\x2c\x03\x63\xca\x8a\x3e\xa5\xf6\x36\x9c\xda\xea\xe8\x67\xb4\xd2\x41\xff\x85\x7c\xb4\x81\x96\xfd\x2a\x22\x8a\xc1\x39\x54\x71\xc3\x43\xe9\x20\x18\x8c\x30\xcb\xae\x33\x5f\xe0\x20\x35\x3f\x10\x7a\x4c\x6b\x35\x5a\x95\x1c\x95\x14\x24\xc9\x6e\x22\x0d\x86\xfd\x8a\x89\x56\xdd\x44\x1f\xd2\x1a\x2d\x0f\x04\xb9\xd6\x5f\xb3\xf4\xe9\xb2\xc8\xe1\x53\x13\xe5\x0b\xf8\xe8\x0b\x6a\x54\x0c\x6b\x1e\xe3\x4b\xc9\xd9\x09\x6e\x1d\x99\x02\x24\xe6\xe9\x7b\x1e\x69\x23\x69\x77\x3e\x65\x47\xfb\x79\x86\x34\x38\x1e\x80\x21\x0d\xfd\xd7\x6e\x48\xb3\x87\xaf\x4c\x4d\x80\x0d\x1c\x29\xb8\x49\x81\xae\xd0\xdf\xd5\xe2\x6f\xea\xea\x8b\x11\xbe\xaa\xac\xc2\xa8\x70\xf2\x5c\x30\xaa\x66\xa5\xd6\xef\x8b\x91\x8f\xf0\x95\x19\x42\x93\x8d\x9f\x74\xb4\x9f\x9f\x48\xc8\x1a\x38\xf3\xb6\xc7\xd4\xcb\xca\x27\xcf\x6c\xd1\x63\x24\x9d\x75\x13\xd0\x08\x5f\xf5\x46\x41\x5a\x39\xcf\x56\x36\xf7\x40\x07\x39\xd2\x22\x7a\x90\xbb\xbc\xe3\x21\x8e\x63\xc7\xd6\x38\x80\x25\x40\xda\xf5\x42\xed\xe3\x77\xeb\x36\x7e\x67\xab\x4a\xda\x69\x0c\xcb\xeb\x3a\x18\x84\x00\xf7\x31\x89\xe2\xda\x93\x27\xb7\x88\xb8\x29\x51\x38\x5d\x6f\x8b\x68\x7a\xf8\x4a\xa1\x84\x5b\x7d\xc1\x38\x84\xa7\x3f\x5f\x6a\xe2\x8b\x8d\xda\x6c\x8b\xf5\x58\x3d\x52\x26\xad\xb2\x58\xa2\x14\x5a\xe7\x0d\x3f\xba\xd0\x47\x76\x94\x59\x64\xd5\x5c\x2e\x92\x9a\x4e\x6e\x94\x6d\xa1\xcd\x92\xfc\x98\x74\xb5\xb4\x40\x33\x01\x9d\xde\x8f\x73\xd6\xd9\x95\x6c\xd6\xcf\xf2\xb4\x16\x79\xa8\x59\xf7\x20\x09\x5f\xa1\xb2\x20\x2b\x6a\xbd\x6e\x73\xc0\x5d\x78\xcf\x53\x86\x69\x15\x35\xab\xba\xcf\xbe\x09\xf2\x28\xf6\xab\x6d\x5a\xac\x2c\xdf\xb7\xc4\xe3\xed\xb6\x2e\x56\xfd\xcf\xdb\xbd\xaa\x22\x70\x5f\x6b\x6a\x0c\xed\xd9\xf7\x30\x8a\xcb\x7f\xd4\x36\x46\x87\xe3\x3b\xde\xc9\x24\x04\xe9\x8e\x44\xa7\x6e\x65\x98\x26\x13\xf2\xb6\x97\x84\x18\x36\xa9\xaa\x1b\x92\x0c\xf0\x0e\x7b\x92\x42\xb7\xb7\xdf\x96\x04\x39\x2e\xb4\x18\xbe\xeb\xcd\x89\xad\x22\xba\x3f\xc9\xcb\xad\xfa\x16\x25\x6a\x2d\xb6\x4b\x89\x6a\x62\xa3\x12\x6f\xbe\xf6\x5e\xa5\x35\x3d\x2f\x97\x73\x24\x69\xd1\x8b\xde\xae\x0c\x18\x41\x6f\xe5\xb5\x88\xaf\x09\x7d\xab\xb2\xeb\x16\x17\xde\xaa\x34\x84\xab\xee\x54\xef\x4f\x76\x97\xd7\xab\x6d\x54\xef\xf3\xe1\xba\xd8\xa6\xd8\xc3\xed\x36\x29\xda\xe8\x9f\xb7\x47\x55\x6c\xff\xbe\x56\xd6\x2c\x1f\xae\xdb\x37\x28\x32\x8a\x5f\x73\x7b\xca\xd3\xeb\x12\x03\xa3\x10\x93\x23\xfa\xfb\xa3\xfd\x1e\xf7\x74\xaa\xe1\x6c\x10\x4c\x71\xad\x64\xe3\x34\xd9\x32\x1a\x04\xf9\x60\x84\x6a\x66\xfa\x68\x40\x61\x94\x26\x97\x40\xb7\x90\x71\xa5\xf6\xe4\x20\x18\x0f\x93\x74\x82\x43\x36\x0d\x61\x90\x07\x66\x0a\xba\xc5\x19\xb8\x3c\xa9\xb7\xe7\xdf\x6c\xae\x16\x21\x93\xef\x9a\x79\x03\x85\x51\xd6\x5d\x90\x61\x75\xc6\xcd\xea\xb8\x8c\x01\x94\xad\x61\x16\x33\xea\xa1\x16\x02\x0a\x5d\x71\x38\xf5\xca\x01\x68\x44\x0a\x5e\xc8\x85\x89\x43\x96\xcd\x4c\xf2\x42\x77\x66\xe2\x95\xec\x64\xaf\xa5\x94\x68\x93\x59\x96\xa3\x3e\x46\x11\x19\xd1\x09\x8e\x73\x9a\x67\x2d\x80\xeb\xf5\x14\xe7\xc2\x63\xa1\x52\x6e\x5f\x2d\x4f\xa7\xaa\xdc\xa7\x39\x0e\xa9\x6b\x55\x91\x20\xfe\x13\x9e\xe6\x68\x16\x4f\x79\xd2\x40\x35\x3b\xa8\x64\xd3\xd2\xb0\x70\xdf\x97\x6c\x1c\x20\xd3\xe0\x96\x18\x05\xe1\x25\xe6\xfa\x5c\xd1\x0c\x0e\xb2\xbb\x32\x6b\x1e\x6d\xa4\x9f\xb0\x24\xda\x2c\x89\x69\x9e\xa0\x28\xcf\xb8\x57\x0c\x22\x14\x7c\xd7\x3b\xa6\xbe\x15\x79\x9a\x10\xd7\x7d\xc9\x54\x29\xeb\x2e\x33\xef\x43\x60\xa5\x6c\xb3\x19\x80\x0c\x9c\xcc\x53\x51\xdb\x59\x75\xa6\x44\xcb\xc7\xdb\x41\x1e\x70\x61\xbd\x51\x55\xd2\xdc\x0a\xc3\x0c\xda\xe0\x79\xc1\x1d\x23\xcd\x68\xa1\xfa\xa6\x28\x82\x2c\x18\x99\xc7\x99\xb1\x0b\xa2\x6b\x9e\x39\x01\x50\x7e\x49\x7d\x4a\x02\xc9\x82\x92\xda\x13\x03\xc7\xfb\x3a\x93\xf9\x81\xa2\x53\x7b\x62\xf2\xfb\x4a\xf5\xe6\xef\x8d\xac\x64\x95\x64\xe6\xa6\x7b\x7d\x91\x8e\x4e\x0e\x28\x2a\x0d\x10\x0b\x26\xaa\x82\x92\x7d\x9c\x81\x8c\xe6\xc4\x89\x64\xb4\x26\x31\x65\xc0\x70\x7e\xa4\xb4\x2d\xe8\x9a\x8b\x7c\xb9\x29\x91\x0d\x98\x41\xb4\x4b\x9b\x6a\x92\xf4\xaa\x14\xcc\x73\x9d\x66\x28\xb8\x08\xa2\x31\x44\xec\xa2\x7c\x01\x98\x9d\x9b\x6a\x4e\x24\x67\x95\x28\xbe\x48\x3e\xe1\x4c\x4f\x32\x5c\x63\xc9\x81\x3d\x74\x39\x8a\x06\x23\x2b\xab\xee\x5f\x97\xb0\x6a\xb3\x55\xbe\x50\xfa\x49\x32\xc6\x41\x7c\x83\xc2\x64\x77\x3c\xcb\x46\xe8\xd7\x11\xce\x69\x3c\x13\x9e\x8b\x16\xdc\xb5\xa6\x41\x0a\x8c\x82\xbd\x2a\xb8\xb6\x60\xd7\xb7\x08\x07\x22\x38\x3d\x8c\xf8\xdd\xb7\x79\x01\x70\x9b\x12\x92\x6b\xcd\xf0\x54\xb9\xae\xb8\x1c\x0b\x82\xb1\x67\x0a\x56\x63\xad\xd2\xa2\xca\xe2\xa3\x03\xbe\xa0\xce\x84\x2d\x91\x82\xb8\x2d\xda\x12\xf2\x9a\x1b\xa7\xc1\xc8\xba\xd4\x2a\xe4\xa3\x64\x68\xe6\xa2\x7b\x5e\xbc\x90\x15\x36\xb5\x94\xcc\x65\x85\x39\xf4\xa2\xb6\x3d\xa2\x5f\x2f\x99\xc5\x39\xa7\x2f\x0b\x33\x21\x40\x63\x9a\x48\xf8\x08\xe2\x16\x6f\xaa\xf8\xaf\x6a\x4d\x3e\x37\x79\x91\x6b\xc8\x19\x06\x47\xc9\x2c\x0e\xd1\x6c\x4a\x1d\x0a\x07\xe3\x59\x88\x35\xba\x37\xab\x69\x18\x15\x46\x2e\xf2\x87\xea\xb1\x6d\x05\x16\x61\x72\x19\xcb\x78\x24\xf1\xf8\x1a\x0d\x67\x62\x51\x5a\x22\xe9\xaf\xae\xa2\x31\xce\xa8\x53\xa5\x5d\xd6\x02\xbe\x91\xe2\x49\x10\xc5\xaa\x70\x55\xad\x5f\x93\xe0\xaa\xa6\xf4\x0b\x2e\x4e\xd1\xb2\x2d\x33\xbb\x37\xff\x4a\x55\xcc\x39\xd5\x3c\xb8\xa6\x1c\x28\x99\xe3\xa1\xb4\xfe\x14\x49\x04\xe8\xa2\x27\xa0\x0d\x27\x39\x91\xaf\x6a\x1f\xa3\xb8\x26\x37\xf9\x14\xb5\x3d\x85\xce\x6c\xe6\x93\x3c\x83\xb7\x8d\x48\x08\xdd\x49\x00\xcb\xdd\xb6\x28\x9f\xa7\x6a\x16\xf6\xfb\x85\x3c\x02\xe2\xed\x92\xb4\x9e\x9c\x46\x13\x04\x33\x9c\x92\xd3\xa4\xd8\x18\x96\x8b\x03\x02\x38\x43\xda\x2b\x32\xee\xa2\xee\x41\x82\xab\xd8\x72\xd5\xbb\xe6\x18\x29\x29\xb0\x0a\x86\x0f\x53\x6e\x16\x55\xb8\xaf\xcc\xc2\xf4\x64\x58\xf2\x88\x5a\xd0\x50\x38\x19\x5a\xde\x94\x67\x7a\x3e\x55\xf2\xd8\xa2\x65\xd8\xba\x15\x4e\x2a\xfe\x9e\xdc\xf4\x5d\x8d\xdd\x2a\x67\xa1\x2c\x75\xf2\xba\xa3\x95\x9b\x63\x37\xfc\x93\x4c\xde\x3e\x18\x1b\x62\x81\x89\x75\xc6\x4a\x2d\xde\x54\x1e\x26\x4e\x9a\x8e\x4c\xf4\xfc\x0c\x3e\x0a\x32\xc8\x90\xeb\x3c\x71\xcf\x4d\x45\x5e\xb0\x6b\xd9\x07\x8a\x4e\x3a\x83\x4e\xc3\xae\xe1\x0c\x25\xb1\x74\x14\xf6\xbb\xa8\xd6\xf1\x9b\x60\xc9\x5a\xb7\x1c\x8b\xf7\x68\x65\x7e\x0c\x16\x8f\xf6\xf3\xf0\xbd\x44\x7d\x2d\xcb\x40\x56\x1a\x30\xb5\xcc\xd5\x8c\x0e\xc2\x02\x39\xc9\x6f\x1b\xdd\x8e\x34\x84\x68\x88\xe4\x79\x41\xee\x2a\xdb\x90\x88\x39\x50\x42\xb7\x1d\xef\x6d\x35\x3b\x5d\xbb\x93\x58\x59\xaa\xeb\x5b\x47\x58\xe3\xb1\xd5\xaa\x87\x59\x3b\xc6\x22\xbc\x87\x5b\x43\x60\xaa\x21\xe6\x58\x62\x17\x9a\x14\xbe\x70\xee\x5f\x65\xc2\xe8\xe5\x3e\x54\x24\x80\xb0\xac\xe2\x51\x4b\x38\x56\x12\x80\x56\x98\x97\x29\x35\xe8\x7b\x33\x1b\x0e\xcb\xc6\xcc\x37\xe4\xa3\xc5\xc6\xfa\xfd\x34\x04\x96\x21\x0f\x36\x4d\xcb\x5f\x3d\x63\x9f\x33\x82\x30\x05\xae\xc7\x11\xae\xec\x42\x44\x59\x11\xf3\x1f\x9a\xbb\xbc\x17\x98\xf3\x19\xe0\x55\x7b\xc2\x90\xb2\xe9\x52\xd4\x92\xf3\x55\x27\xb4\xa0\x4c\x28\xca\x18\x38\xd6\xa3\x43\x23\xc1\x14\x36\x2a\x04\x0b\x79\xb0\xf1\x25\x42\x3a\xc1\xd7\x06\x4a\x3a\xc7\x9a\xe2\xef\xbd\xf9\x4e\xec\xb2\x24\x37\x99\xc0\xc5\xc9\x20\xd1\xdb\x04\x50\x0e\x72\x9a\x2f\x9e\xd5\x2c\x62\x86\xa2\x28\x43\x78\x38\xc4\x83\x3c\xba\xc0\xe3\x6b\x14\xa0\x10\x67\x79\x3a\x83\x67\x0f\xe4\xf4\xe5\x24\x1e\xe0\x4a\x51\x46\x2b\x52\xa8\x92\xe8\x01\x50\x2a\x02\x72\x43\x89\xc5\x35\x17\x64\x10\xee\x69\x67\x40\x9b\x9c\x1c\x45\x32\x21\x87\x5a\xc2\x51\xba\x8c\xd0\x4b\xaa\xcd\xa7\x7a\x5e\x74\x21\xba\xdf\xb5\x8c\xaf\x79\x20\x2a\x07\x83\xe6\xad\x95\x79\x02\xfc\x02\x9c\x55\x1a\x21\xce\x64\x77\xa5\x79\xb0\x2e\x1e\x52\xde\xb5\x78\xa4\xe4\x77\x1d\xbf\xb9\xda\x6a\x56\x13\xf3\x33\xa6\xf1\x51\xe2\xdf\x07\x6c\xd2\x9e\x88\xc0\x49\x51\x9c\xe3\x74\x28\x59\x0b\x23\xe7\xaa\xe0\xfc\x95\x75\x9d\x53\x2d\xdd\x6e\x59\x7c\xc4\x00\x8d\xf0\x78\x8a\x53\x22\xfe\x54\x58\x04\xbb\x0c\x37\xe6\x1b\xac\xa3\xfc\x0d\xee\xf1\xa8\xcc\xa4\x3b\x55\xd0\xae\xae\x7c\xa0\xbd\xda\x83\x2e\xd5\x6c\xc2\x96\x5b\x3f\x27\x57\x55\x8c\x07\x01\xb4\xeb\x7e\xcf\x58\x17\xf6\x00\xb8\x48\x3d\x2f\xb2\x95\x08\x87\x45\x35\x8b\x58\x91\xe1\x52\xa5\xf0\xc5\x8f\x8d\x56\x7a\x22\x2c\x79\xef\x60\xab\x77\xff\xf4\x44\x44\x68\x1e\x94\x82\xb4\xc0\xe8\xea\x2f\x41\x53\x7b\x93\x60\x50\x89\xae\x26\xc1\xe0\x2e\xb4\x25\xaa\xdf\x89\xbe\x3e\x61\xbb\x0a\x49\xa2\xaf\xde\x07\x40\x8b\xcc\x03\x25\x32\xda\x08\xad\xbb\x18\xb1\x95\x1e\x7f\x85\x26\x69\x8e\x0f\x03\xc1\x06\x9c\x18\xd8\x8f\xc2\x8b\x81\x67\x6a\x81\x90\xbe\x07\x41\x3e\xa2\x61\x7d\x1f\xf1\xf7\x6c\x98\x9f\x17\x91\x7e\x6f\xce\xbc\x4e\xfb\x7b\x0d\xef\xcb\x90\xa9\xf1\x70\xc4\xf5\x7b\x8f\xf7\xcb\x21\x2f\x1a\xf7\x57\x60\x28\xc7\xff\x75\x05\xfd\x15\xdf\x21\xf8\xaf\x2d\x80\xae\x79\x45\xc1\xa3\xc6\x16\x53\x26\x11\x80\x14\x0d\x56\x7a\x5f\x12\x9e\x46\xa9\x2d\xb9\xc0\xb8\xc2\xc8\x76\xdb\xd5\x4c\xb4\x58\x59\x6e\xa4\x25\x1e\x6f\x67\xa6\xc5\xaa\xff\x79\x76\x5a\x55\x11\xb8\x2f\x4e\xd9\x87\xf6\xec\xa6\x5a\x14\x97\xbf\x81\x2d\xb1\x51\x7e\x12\x4c\x85\x70\x38\x09\xa6\x8b\xc7\x5e\xb0\xb8\x88\x9b\x20\x5c\x56\x99\x74\xcc\x6f\x6b\xb0\x8c\x96\x36\x51\xcb\x6d\xb3\x7c\x9d\x63\xdf\x62\xb4\x4c\xff\x5c\xa6\xcb\xf4\xcf\x69\xc0\xcc\x01\x37\x0b\xc0\xb5\x08\x2d\x21\xbf\x6e\xb1\x89\xe6\x5f\xaa\x58\x46\x73\xc0\x2d\x0d\x70\xd3\x09\xb8\x69\x05\x6c\x87\x9c\xa7\xd1\x74\x0c\x57\x2f\x35\x3a\x2c\x2f\x5e\x80\xdf\xc4\x17\xfa\xdc\x24\xcf\xeb\xe4\x11\x50\xb0\x41\x11\x53\xf1\x91\x4e\x45\xed\x23\x7a\x41\x5a\xff\xe9\x27\x04\xd8\x7c\x44\x4f\x51\x63\x65\xad\x23\xcd\x50\xfd\x39\xfa\x58\x12\xee\x42\x9a\x7b\x6a\x0b\x3e\x09\xa6\x60\x33\xbb\x95\xd7\x6a\x1c\x61\xe8\x74\x17\x3d\x45\xb5\x16\x5a\x46\x1f\xeb\xac\xa7\xad\xa1\xd5\xdb\xc9\x88\xcf\x60\x2a\x2e\xc2\x90\xa7\xfb\x36\xa9\x91\x7d\x20\x28\xa1\x4d\x24\xa1\xd3\x35\x9c\x49\x20\xb6\x5e\x51\xdc\x6e\x1c\x3c\x8a\xc6\x18\xd5\xe4\x7e\xb2\x70\x01\xae\x58\x23\xd6\x61\x91\x9b\x59\xbc\xcf\x8c\xb3\xca\x50\xef\x60\x27\xaf\xf0\xe4\xdb\xdb\x59\x0a\x56\xbb\x10\xa3\xff\xae\x4d\x2d\xd9\x0e\x41\xed\x7a\xe4\xad\xa4\xba\xb9\xa5\xa8\xb5\xe0\xe6\x20\xea\x09\x43\x79\xf1\x46\x18\xca\xcf\xe7\xfb\x46\x89\x14\x5f\xe0\x34\xc3\x07\x52\xc1\xe2\x95\x2d\xae\xd9\x0f\xc5\x67\x27\x75\x97\x02\xb5\x6d\x01\xfc\x4f\xe7\x3f\x84\xfd\x90\x15\xca\x3a\x58\xca\x69\xd4\x86\x4f\xf9\xc2\x66\xb6\xf9\x1f\xeb\x67\x68\x13\x7d\xac\x16\xab\xd3\xc2\x52\xf6\xcf\xe3\x24\xc5\xdf\x8c\xab\x48\x20\xf7\xe3\x10\xfc\x9c\x8b\xe9\x8e\xc8\x9b\xc3\xe1\x3c\x9e\x21\xb5\x43\x61\xfc\xb0\xb9\x89\x96\xfd\x39\x3c\x49\xa6\x30\xb9\xf6\xad\x18\xb1\x55\x24\x48\x45\xda\xcb\x0c\xbf\x49\x92\x69\xb1\x24\x3c\x1d\x07\x4f\x9a\x51\x45\xe4\xd0\x6e\x3c\x83\xe9\x06\x7a\xb2\xf5\xb2\xb7\xbd\xb3\xfb\x6a\x6f\xff\x9f\xaf\xdf\x1c\xbc\x3d\x7c\xf7\x7f\x8f\x8e\x4f\xde\xff\xf2\xeb\x6f\xff\xfa\x9f\xa0\x3f\x08\xf1\xf0\x7c\x14\x7d\xfc\x34\x9e\xc4\xc9\xf4\x7f\xd3\x2c\x9f\x5d\x5c\x5e\x5d\x7f\x6e\xf8\xcd\x56\xbb\xd3\x5d\x5b\x7f\xb6\xb4\xba\xc9\x22\xdc\x8a\xa3\x9d\x58\xb4\x0b\xa3\x5a\x0c\xb1\xc3\x2b\xa5\xb0\xdc\x50\x2c\x4c\x6d\xa2\x90\xd6\x8e\xcd\x4d\x85\xcc\x74\xe4\xd8\x6f\x98\x63\x57\x46\x84\x24\x69\x79\x14\xd4\x24\x3b\xb0\xa0\x65\xe4\xd7\xcf\xc0\x7b\xa5\x10\x98\x9a\x26\x71\x71\xa0\xcd\x2a\x40\xeb\x67\x7c\x83\x97\xc5\x30\x0b\x54\x2a\x10\xc5\x4a\xe4\x9e\x2f\x44\x98\x01\xf4\xbf\xd0\x16\x65\xdf\x9a\xb8\x3c\x78\x0f\x62\x43\xbc\xb4\xa4\x7c\x10\x64\x2b\x7e\x30\x8a\x34\x62\x4b\x5a\xc3\x22\xdc\x14\xb9\x7b\xf4\x43\xbe\xb4\x47\x3c\x77\x66\xf6\xe9\x3c\x1c\xfd\x1f\x8e\xfe\xe2\xe8\xff\xfe\x64\x77\xd9\xef\xa2\x97\x3b\x95\x1d\xb4\xfc\xee\xcb\x1d\xd9\x47\xcb\xef\xaa\x4f\xf0\xf5\xf6\x4e\x5b\x14\x99\x3f\xd7\x71\xab\x22\x0e\xf7\xe8\xbc\xe5\x77\x9d\xde\x5b\x7e\xf7\x6f\xa0\x11\xa8\x7e\x58\x87\xc1\xb8\xcb\x59\xdd\xee\xef\x0f\x96\x51\x49\x88\xdf\x25\x51\x9c\xbb\x9c\x8c\xfd\xae\xc3\xc9\xd8\x7a\x98\x2e\x30\x75\x7b\x19\x8b\x26\xab\xba\x1a\x4b\x40\xef\x70\x82\xd2\x89\xf8\x4e\xce\x6a\x40\x9b\x8b\xae\x8d\xef\xfa\x18\x45\x57\x95\x70\x59\xe3\x8b\x6f\x21\x9f\x35\xa8\xb4\x98\xaf\x31\xaf\x25\xe4\x5b\xfe\xe2\x6b\x7b\x1a\xab\x0d\x57\x73\x34\xf6\x41\xf6\x11\x18\xaa\x6e\xc6\x44\x04\x2a\x16\x4b\x93\x2c\x16\x2d\x08\x9b\x9b\xc2\x5d\x52\x8e\x36\x3a\x4f\xab\x87\xc2\x60\x64\xf9\xa6\xc2\x1e\x26\xed\x53\x6f\xee\xbc\x4f\xbd\xf9\x0e\xf6\xa9\x2a\x38\xdc\xf7\x3e\x65\x5d\x4e\x6f\x76\x1e\xb6\x29\xf1\x77\x6f\xdb\x54\x76\x19\x4c\x77\xe2\x30\x0a\xe2\xda\xa2\x3b\x96\xed\x48\xfe\xfd\x6f\x59\x6f\xbe\xce\x96\x55\x65\x99\x7c\xff\x5b\xd6\x9b\x1d\x6d\xd3\x7a\xd8\xb1\x8c\x1d\x4b\x5a\x31\x0b\x6d\x5e\xdf\x74\xf7\x12\xf3\x22\x61\x4b\x00\x29\x7d\xe4\xd1\xf0\xe1\x0b\xbb\x3b\xa1\x8b\xbb\xd1\x20\xff\x0f\x17\x2b\xf4\x23\xe9\x3e\xfb\x4a\xbf\x15\xcb\x7f\x9e\xba\x00\x08\xcb\xad\x2d\xe8\xde\x49\x5b\xc0\x72\xd4\x7e\x4b\xa5\x81\x87\xa4\x57\xd9\x28\xf0\xb5\x57\xa3\x49\x30\xf8\x8a\xaa\x05\x0f\xf1\x66\xe1\x17\xb4\xf6\x77\x50\x37\x18\xf9\x62\x6f\xa1\x8a\x50\x8c\x58\xa4\x2f\x07\xdb\x1d\xa8\x09\x26\x37\x07\xdb\x1d\x9b\x8c\x07\x26\xce\x9f\xf0\x35\xcd\x82\x4d\xed\x60\x45\x5f\xc1\xf9\x37\x88\x73\x9e\xc4\x3b\x49\x27\xd4\x46\x7b\xe7\x97\x77\x1f\x60\xd3\x3d\x49\x5e\xe3\x42\x18\x44\x97\x97\x97\x2b\xc9\x14\xc7\x59\x36\x5e\x49\xd2\xf3\xd5\x30\x19\x64\xab\x90\x84\x3b\x59\xd5\xea\x8c\xf2\xc9\xd8\xa2\x08\xd9\xb9\x98\xbe\xde\xde\x2d\xd0\x16\xcf\x15\x83\x21\xcc\xf7\x01\xd1\xf6\x38\xc3\xfb\x85\xa5\x3c\x87\x3d\x8a\x0c\x4c\x46\x1e\xa2\x98\xbb\xbd\x48\xe1\x9e\x0b\x57\x97\x36\xaa\xf9\xcd\x75\xc5\xd3\xc5\x80\xef\x30\x52\x93\xc3\x62\xe8\x09\x52\x0e\xb6\x3b\xf3\xb0\x8d\x72\x66\x8b\xac\x07\xa9\x96\x3e\xe4\x09\x9a\x52\xab\x53\xd9\x3b\xc7\xb1\xc3\x19\x7e\x31\xda\xee\xc0\x86\x67\x03\xf9\xcd\x75\x30\x21\x55\xbe\xd2\xce\x01\xe6\xda\x97\x02\x1f\xa5\xed\x9b\x5b\xbb\xdd\x38\x88\xf6\x6b\xfb\xe1\x60\xa9\xd1\x7b\x30\xb3\xfe\x14\x0e\x0d\xef\x1b\x4a\xf3\x73\x52\x34\xcd\xaf\xf8\x47\x31\x57\xeb\x5a\x3e\xbf\xdb\x82\xf1\xd4\x69\x6c\x34\x1a\x3a\xe0\x05\xbd\x83\xe6\xfa\xfd\x54\x93\x77\xb7\x21\x85\x3f\xa1\x11\x42\x15\x90\x08\x3b\x80\x0c\xac\x64\xd1\xde\xc6\x4a\x9f\xd7\xa5\xb1\x00\x6c\x80\x4a\x2a\x67\xc1\x38\x47\x5b\xf0\xcf\xe2\x62\x31\x50\x17\x25\xef\xfb\x20\x2f\x4c\x36\x8f\x4f\xe1\x70\x85\xba\x45\xe0\x1a\xef\x8c\x07\xf8\x95\xe4\xad\x81\xe2\x4a\x7e\x47\xb5\xe6\x42\x02\xaf\x3a\xc5\x16\xf1\x96\xac\x74\xc6\x3d\xcc\xda\xc2\x4b\x8d\x90\x07\x33\x51\x2e\x56\x87\x15\x96\xcb\x2d\x0c\x42\x0b\xd0\x21\x7e\x0d\x63\x63\x4b\x89\xb6\xc8\x19\xb9\x00\x26\x7c\x82\xc5\x1b\xe7\x71\x99\xef\x31\xb4\x47\xec\xc9\x52\x4e\x62\xe2\xb4\x68\xf1\xc2\x82\xe5\x2b\xb6\x31\x11\xf0\xea\x47\x66\xcc\xa2\xe1\xca\x0d\x5a\x5e\x70\x7c\xac\x47\x01\x22\xc6\x81\xe7\x80\xf3\x82\x59\x75\x59\xa2\x65\xe7\x5f\x2b\x23\x39\x18\x43\xe1\x04\xc2\xa0\x70\x62\x93\x8c\x82\x0d\x7a\x55\x9b\x17\xfe\x74\x66\x09\x42\x13\x62\xe0\xcc\xcf\xca\x41\xc9\xa7\x07\x25\x69\xa0\x4b\xd3\xfe\x68\xd8\x0b\x64\x9d\xa3\x60\xc3\xd8\x32\x54\xe6\x3b\x89\xac\x58\xcc\x18\x6b\x1b\xda\x28\x4b\xb5\x24\x1d\x0d\xa7\x3f\x4b\xb4\x0b\x11\x60\x8e\xd7\xab\x6a\x73\x5d\x89\x07\xcb\x7e\xc7\xb7\xe2\xbd\x0b\xf2\xdd\x7b\xf4\xbe\xb5\xf8\x95\x49\xbd\xa9\xce\xcd\xa5\x4a\x8a\x76\x43\x7a\xaf\x72\xf7\xe2\x03\x52\xb8\xba\xd8\xb4\xe9\x7e\xed\xe2\xec\x8b\x55\xf3\x90\x43\x6c\xb8\x0b\x98\x52\xb1\x41\xa8\x90\x0b\x59\xdf\xb5\xe7\x98\x2e\x2c\x6c\xd8\x55\x89\x05\x1c\x57\xca\xf7\xbb\x9b\xe7\x25\xc7\x77\x0a\xcd\x7e\x76\xf7\xf8\xe1\x73\xa3\xb3\xee\xf1\x23\xe9\xc6\xda\x1a\x39\xd3\xaf\xfd\xa5\xcf\xf4\x83\x68\x3a\xc2\xe9\xf2\x57\x36\x11\x80\xd3\xbb\xdc\xd4\x9f\x73\x88\x37\x33\x77\xde\xcb\x69\xbe\x07\x1d\x7b\x47\x38\x4e\x26\x0e\xed\xf2\x4b\xb7\x09\x81\x78\xaf\x65\xc2\x50\x6a\x90\x33\x5c\x90\x43\x25\xfa\x93\x33\x62\x56\x71\x17\x5e\xe6\x2c\xaa\x02\x2d\xb2\x40\x3a\x0d\x72\xba\xa1\x73\x93\xe3\xab\x9c\x9c\x22\x03\xf6\x8c\xa6\xb4\x4f\xcc\x37\x8b\xa7\xda\x08\x42\x3c\x88\x26\xc1\x78\x7c\xcd\xd2\x80\x86\x95\x6f\x6e\xe4\x51\xb9\x61\xad\xb0\x81\x3b\x11\x68\xa8\xcd\x2e\x9e\x8c\xe3\x36\xf8\x7d\xd5\xf4\x1c\xc5\x94\x48\xb7\x3a\x72\xe7\x17\xbb\xd8\x51\x6a\x3a\x1c\xb5\xe4\x32\x2b\xc5\xec\x16\x09\x24\xf6\xf0\xd5\x2d\x33\x41\x58\x86\x57\x22\x1f\xf9\xbe\x61\xc1\xe9\xd4\x6e\x1e\xa2\x78\x3a\xcb\xef\x32\xa7\x9c\x3c\x54\xa2\xbb\x05\x9d\xdd\x17\x71\x0c\x34\x46\x61\xa1\x8f\x5b\x27\x95\x80\xd1\xb2\x87\xb0\x29\x26\x67\x13\x15\x6d\xd0\x0a\xcf\xad\xd4\xd3\x53\xa8\x87\x6b\x04\x0a\x40\x1b\x32\xd0\x1b\xbb\x6e\xde\xbd\xd3\x16\xdd\xd5\x76\x5b\x69\x83\xd8\xe8\x34\x3d\x4d\x79\xbe\xfe\x60\x6a\xf7\x77\xd7\x7d\xbb\x76\x47\x23\x92\x79\x99\x26\xdc\x3c\xa4\x80\x03\xb0\xd0\xb8\x5a\x13\x51\x91\x12\x9b\xb2\xa3\xea\xfd\x24\xa4\x07\x97\xd7\xb9\x1c\xaf\xb2\x92\xb8\xa2\x2a\x8a\xc8\xea\xe0\xbc\x8c\x07\x29\xce\xef\x49\xa9\x44\xe4\xdf\x3d\x7b\xe0\x20\xe8\x25\x63\x13\x36\x4f\x64\xea\xe8\x5b\x55\x63\x28\x3b\x07\x3b\x02\x04\x5b\x75\x46\x42\x5f\x44\x7d\x14\xc4\xa3\xee\xe1\x5e\xe2\xed\x76\x9f\xf1\x65\xe1\xc0\x34\x27\xbc\x2c\x3d\x54\x49\xd1\x65\xf5\x71\xb2\x1b\xe2\x97\x28\xa6\x68\x47\x5f\x4a\x71\x31\x59\xd7\xcb\x22\x63\x6a\x95\xb8\xbe\x40\x87\x65\x8f\x92\xb9\x35\x1e\x27\x97\x28\x48\xfb\x51\x9e\x06\xe9\x35\x62\xea\xa5\x4f\xf8\xda\x12\x77\xf0\x93\xac\x91\xf8\xd9\xda\x70\xc9\x40\xe9\xea\x96\x6a\xa3\x35\xc7\x19\x92\xa0\x54\xe2\x06\x09\xf1\xdf\x40\xb7\x91\xa4\x28\x8a\x63\x9c\x42\xf4\xd9\x64\x96\x83\x00\xa1\x47\xe1\x83\x98\x89\x54\xc7\x48\xc9\x90\x3d\xd0\x56\x8c\x80\x74\x5c\xe3\x27\xd7\x88\x2c\x35\x16\x21\x81\x44\xd2\x4a\x26\x65\xfa\xc8\x48\x2a\x18\x49\x05\x8d\xc6\x7e\x3b\x3c\x82\xf9\xa4\xd7\x80\xd3\x20\x44\x83\x24\xce\xf2\x20\xd6\x9b\xb7\x26\x91\x52\xe7\xd8\xad\x58\x13\x78\x9f\x46\x67\xe8\xf7\x4d\xd4\xb8\xea\x0c\xe8\xff\x6c\xee\x30\x46\xe1\x56\x97\xfe\xaf\x5c\x33\x96\x68\x3a\xb1\x48\x7b\xb6\x51\xe4\x9f\x10\x87\x0c\x76\xa0\xaf\x11\x85\x4c\x30\xf1\x7b\x89\x44\x56\x92\xaf\xcc\xc6\x8c\x2d\x03\x09\x9d\xb6\xf1\x71\x87\x9e\x54\xd5\x17\x17\x0b\xe6\x76\x11\xc8\x60\x98\xbf\x9b\xf8\x63\x07\x5b\x3d\x16\x7d\x0c\xf0\x8a\x60\x89\x95\x46\x42\x59\x70\xca\xab\x04\x22\x33\x4a\xdf\x7f\x30\x32\x99\x24\x78\x2b\x73\x83\x8f\x7d\xad\xe8\x61\x30\xd4\xff\xe9\xd1\xc3\xe6\x88\xa9\x8b\x88\x88\x84\x87\x16\x34\x34\x37\x82\x98\xbb\xc6\xdc\x28\x62\xee\xaa\x5f\x29\x92\xd8\xdd\xb9\x5d\x8f\xaa\xa7\x61\xbc\x2d\xfb\x31\x91\x2e\xf6\xec\xc1\xd1\x4a\x03\x8e\x95\x72\x4c\x79\xac\x34\xa0\x85\x84\xc2\x25\x0d\x7e\xc9\x24\x50\xa9\x3b\x43\x8e\x4d\x82\x81\xfd\x92\x48\x1c\xfc\x1d\x46\x70\xcf\xfe\xd2\x0a\xf3\xab\x6e\x7b\xd9\xf2\x7a\x1c\xf5\x97\x09\x2a\x21\xd8\xb6\x66\xda\x57\x1c\x0f\x96\xc1\xa6\xd1\xf2\x9e\xba\x59\x6a\x1f\x26\x61\x67\xbe\xf1\x5d\x36\x0a\x9a\x1d\x1d\x24\x79\xd9\xd4\xc1\x65\xa3\xa0\xe3\x37\xcd\x97\xad\x75\x4b\xc9\x96\xf6\x2a\x8d\xa6\x78\x12\xfa\xdd\x86\xd5\xf6\x4f\x79\x35\xed\x7f\x0a\x87\x7a\x3b\xf8\x62\xfa\x29\x1c\x96\xdd\x3b\xa8\x5d\x4f\x42\xbc\x3c\x18\xf6\xad\xaf\xf3\xd4\xf1\x7a\xf9\x7c\x1c\x84\x93\x20\xb6\x7d\x4e\xec\xc0\xf0\x40\x7f\x3d\x0d\xc2\xe5\x20\xce\xa2\xab\x67\x4d\x7d\x10\xc8\xa7\x28\x4b\xfc\x86\xdf\xd4\x47\x9c\x7d\x7a\xb6\xf6\x6c\x4d\x9f\x21\xf2\xe9\x33\x4e\x13\xe6\x7a\x6d\xf9\x1a\x3b\xbe\x51\x1d\xd9\xf2\x08\x5f\x69\x1f\x02\xac\x13\x17\x8d\xbb\x11\x1a\xef\xd3\x81\x3e\xb9\x69\xd0\xef\x47\xb9\xf5\xe5\xf2\x18\x9f\x07\x83\xeb\xaf\x7d\x07\x24\x56\x0f\x3c\xe9\x8b\x06\x5e\x16\x6b\x45\x3c\xb2\x25\x02\xcf\x64\x65\x68\x66\xa1\x6c\x1d\x88\xdf\xcd\xb6\xf8\x4d\xa8\x9e\xff\x26\xc4\x2e\x7e\xd3\x5f\x05\x69\x17\xf6\xa5\xf0\x8b\x11\x32\xc5\x80\xd2\xaf\x71\x87\x45\xd1\xe1\xd4\x2a\x3d\xe5\xa9\xfa\x24\x68\xb3\x78\x9b\x28\x35\x08\x25\xd2\x66\x65\x02\x14\x6f\x04\xdd\xc9\x6f\x28\xb9\x89\x37\x32\x95\x89\x97\xb1\xfa\x4a\xa2\x29\x78\x26\xa4\x04\x3f\x0a\x0a\xa2\xa3\x32\x60\x03\xc5\xe8\x45\xfa\xcd\xc9\x64\x51\x45\xa4\xa2\x80\x94\x79\xed\xe2\x8a\x49\x77\x28\x36\xd6\xa5\x8d\x8e\xef\x95\x6b\x93\x3d\x95\xae\x36\x3a\x6d\x4f\x21\xbc\x8d\x4e\xc7\x2b\x26\x7e\xa3\xd3\xf5\xd4\xd1\xdb\xe8\xac\xe9\x37\xc2\x3a\x29\x6f\x74\x1b\x1e\xa3\xd6\x8d\x2e\xe0\x23\x28\x65\xa3\xdb\xf4\x64\x5a\xd9\xe8\xb6\x3d\x1b\xb5\x6c\x74\x5b\x9e\x4c\x21\x1b\xdd\x8e\x27\xd3\xcf\x46\x17\xf0\x52\x68\x66\xa3\xbb\xe6\xe9\x54\xb3\xd1\x5d\xf7\x74\xba\xd9\xe8\x3e\xf3\x0c\x22\xd9\x58\x6b\x78\x16\x72\xda\x58\x03\xfc\xd9\x92\xd8\x58\x03\xec\x19\x69\x6c\xac\xb5\x3d\x83\x38\x36\xd6\x00\x71\x42\x46\x1b\x6b\x80\x73\xb1\xce\x36\xd6\xba\xf2\x05\xba\x57\x2c\xd9\x8d\x35\x7e\xb5\x4e\x16\xf3\xc6\xda\x33\x8f\x2f\xd5\x8d\xf5\x86\x57\x2c\xe1\x8d\x75\xdf\x2b\x16\xf7\xc6\x3a\xa0\x53\x50\xf0\xc6\x3a\x34\x2e\x18\xcd\xc6\x7a\xfb\xe6\xcc\xeb\x36\x1e\x2e\x0f\xfe\xfc\xcb\x83\xde\x08\x0f\x3e\x91\x4e\xc1\x4a\xa1\x6e\x40\x34\xcd\x59\x36\x9b\x92\x81\xc1\x2c\x3e\xb5\xd4\x6f\x90\xe3\x69\x48\x73\xf4\xc3\x26\x7a\xc2\x21\x3f\xb1\x58\x84\x08\x27\x8d\x7b\xbc\xae\x28\x35\xc7\x17\xed\x1c\xe1\x21\x4e\x31\x1c\xf4\xd2\xe8\x1c\xce\x64\x51\x1c\xe5\x05\x98\x6c\x36\xc5\x29\xa8\xae\x37\xb5\xf4\x1c\x12\x94\xad\xd9\xf9\x04\xc7\xb9\x56\x00\xe5\x09\x1a\x05\x71\x38\xc6\xca\xb8\xc9\xb0\xfb\x56\xc8\x8a\x4d\x0d\x54\x35\xdd\x01\x25\xdd\x37\x8d\x25\x4f\x4d\xa0\xa2\x38\x5f\x97\x34\xf4\x43\xb9\xbe\x50\x4c\xa8\xb3\x63\x1e\xf3\x8b\x1a\x54\x09\xff\x9e\x40\x85\x17\x32\x36\xca\x21\xc2\x8a\x58\x42\xd3\x7f\x01\xa4\x8b\x08\x5f\xba\x50\x74\x36\x2f\x21\xbc\xcf\x51\x40\x5f\xbe\xa8\xe5\x39\xc1\x01\x96\xa0\x33\xe6\xd5\x7f\x20\x6b\x4e\xd8\x8e\xc0\xa2\xb3\x03\x37\xaa\xd6\x8d\x56\x9c\x58\xf9\x5d\x3b\x5a\xee\x96\x16\xab\xb1\x1f\xe7\xad\xe6\xa2\x4d\x2c\x56\x63\x77\x9c\x04\xb7\xa9\xd2\x6d\xc3\xfb\xa2\xfc\x2d\x49\x69\x85\x52\xb0\x87\xe4\x57\xd7\x39\x3e\x84\xe4\x40\xc6\x6b\x5b\xde\x65\x85\xfe\xf6\xe8\xa2\x2b\xda\xaa\xb2\x22\x8a\xd2\x8b\xa9\x10\x0a\x68\x2f\x05\x6e\x68\xd3\x8e\xb3\x45\xb3\xb0\x73\xc5\xb2\xaf\x5e\xe7\x36\xe3\xe7\x85\xdc\x05\x6d\xa8\x2c\x92\x4f\xbb\xa8\x7f\x1a\x9d\xdd\x2a\x79\x76\x61\xce\x1d\x7d\xc6\x54\x55\x5b\x38\x8e\xaa\x45\x05\x63\x2d\x52\x5b\x78\x88\xb9\x11\xda\x3a\xa2\xcc\xb7\x35\xeb\x19\x19\x4d\xf2\x9a\xc0\x43\x31\x91\xfa\x64\x66\x6e\xb6\x1b\x4c\xa7\xe3\x6b\xd6\x70\x90\x9e\xcf\x08\x0b\xcf\xca\xfc\x15\x19\xbf\x5e\x99\xa6\x49\x9e\x10\x1c\x65\xce\x5d\x66\x38\xa1\xef\x3e\x76\x05\x4b\xd7\x7f\x90\x75\xfe\x1c\x59\x07\x02\x46\xff\x09\x71\x89\xac\x39\x95\x2a\x98\x48\xc0\x16\x4b\xef\xf1\x50\x5e\xe8\xd6\x49\x95\x13\xc6\x2c\xa4\x92\x54\x75\xa9\xdd\xfc\xd9\x24\x3d\x17\x5f\xe9\xb6\xed\x5c\xe4\x84\xb0\x89\x4d\x3a\x7c\x2b\x41\x3f\xa3\x3f\xb2\x28\x66\xc1\x58\x09\xcb\x68\x5c\xf9\x0d\xf6\x57\x47\x5f\xd4\x34\xbe\x6c\x79\xd5\xea\x56\x0b\xf5\x83\xed\x8e\x66\x4d\x61\x33\x00\xd1\xbd\x26\xd1\x26\x1b\x55\x8b\x01\x08\x4f\x7b\x53\x7a\x3b\x56\x68\x82\xed\xb9\x8a\x4f\x4d\x4e\xda\xb8\xea\xae\xb5\x3b\xcd\x56\xc3\xf7\x50\xe3\x0a\x0f\x07\x61\xd0\x5f\x7f\x66\xc9\xab\xd8\xb8\x7a\xb6\xde\x0f\xc2\xc1\x10\x7b\x30\x30\xad\x66\xa7\xbd\xd6\x55\xcb\x9d\x39\x6f\xc4\xb4\x34\x7a\x72\x2f\x0e\x44\x26\x3d\xdb\xde\x75\x19\x4c\x11\x06\xf7\xea\xf9\x7b\x88\xdf\x75\xef\x18\xee\xeb\x6b\x3e\x1b\x14\x89\x0f\x04\x1e\x4f\x2f\x88\x22\x47\x04\xde\x83\x0f\x52\xe9\x83\x53\xfe\x70\x66\x73\x09\x91\x3e\x13\x82\x33\x0b\x90\xbf\x5a\xad\x26\xc1\xa4\x9e\xe2\xe8\x0b\x92\x5f\xc2\x5e\xd7\xae\x6b\x3e\xe2\xe8\x4b\x45\x80\xcd\x76\xdd\x02\x10\x42\x19\x2b\x2e\xe9\x26\xb8\xbb\x19\x87\xec\x29\x37\x14\xf6\xeb\x7e\x65\x48\x1b\x48\x1a\x53\xb4\x84\x1a\xba\xf8\xa0\x94\xf6\xb5\xd2\x7e\x69\xe9\xa6\x56\xba\x59\x5a\xba\xa5\x95\x6e\x95\x96\x6e\x6b\xa5\xdb\xa5\xa5\x3b\x5a\xe9\x4e\x69\xe9\xae\x56\xba\x5b\x5a\x7a\x4d\x2b\xbd\x56\x5a\x7a\x5d\x2b\xbd\x5e\x5a\xfa\x99\x56\xfa\x59\xf9\xec\x34\xb4\xd9\x99\x33\x99\xbe\x56\xbc\x7c\x36\xfd\xa6\x56\xbc\x7c\x3a\xfd\x96\x56\xbc\x7c\x3e\xfd\xb6\x56\xbc\x7c\x42\xfd\x8e\x56\xbc\x63\x70\x83\xd5\x55\xc2\x90\x3f\x45\xf1\x39\xa9\x1a\x05\xe3\xbe\x4d\x6c\x0e\xc8\x36\x70\x6a\x1d\xa8\x3e\x7c\xb2\x0e\xca\x00\x3e\x59\x07\x20\x84\x4f\x2d\x1b\x3a\xbd\xe2\x0e\x5a\xfd\x46\x90\xd8\xdd\xad\x05\x1e\xea\x7b\x68\xe0\xa1\xd0\x93\x16\xa8\x87\xd0\x9a\x47\xb6\xd0\xc6\x99\xce\x1b\x42\x5a\x2f\xf4\x90\xa8\x5a\x8c\x90\x87\x90\xdf\xf4\xd0\xc9\xa9\x6f\xd4\x1b\xd0\x7a\xb4\x25\x5a\xb5\x58\xb4\xa4\xde\x1a\xa9\xd7\x34\xea\xf5\x69\x3d\x81\x64\x20\xd5\x6b\x79\x08\x35\xa1\xbd\x96\x51\xaf\xac\x7f\x6d\xd1\xbf\xf6\x42\xfd\xeb\x88\xfe\x75\x16\xea\x5f\x57\xf4\xaf\xbb\x50\xff\xd6\x44\xff\xd6\x16\xea\xdf\xba\xe8\xdf\xfa\x42\xfd\x7b\x26\xfa\xf7\x6c\xa1\xfe\xf9\x0d\x8f\xf5\xcf\x37\x09\xa6\xac\x83\xbe\xef\xb1\x0e\xfa\x26\xc5\x94\xf5\x90\x60\x49\x7b\xe8\x9b\x24\x53\x4a\xa2\x2d\x8f\x93\xa8\x49\x33\xa5\x7d\x6c\x8b\x3e\x9a\x44\x53\xda\xc7\x8e\xe8\x23\x50\x8d\xd9\xc9\x57\xaf\x1c\x9d\xf4\x10\xea\xd0\x4e\x9a\x74\x13\xd2\x8a\xd6\x4e\x12\x7a\x7b\x46\x2b\x9a\x84\x33\xa0\x15\xed\x9d\xf4\x3d\x44\x3a\x7a\x72\xea\x9b\x94\xd3\xa7\x15\xad\x9d\x24\x1c\xa3\xd9\x80\x8a\x26\xe9\x94\xf5\xb1\x23\xfa\xd8\xb4\xf3\x1a\x57\x1f\x09\xcd\xd1\x3e\x36\xed\xcc\xc6\xd9\xc7\x0e\xef\x63\xd3\xce\x6d\x5c\x7d\x6c\x8b\x3e\x36\xed\xec\xc6\xd5\xc7\x67\x45\x1f\xed\xfc\xc6\xd9\xc7\xb6\xe8\xa3\x9d\xe1\xb8\xfa\x48\x18\x23\xeb\xa3\x9d\xe3\xb8\xfa\xb8\x5e\xf4\xd1\xce\x72\x9c\xb4\xda\xf2\x78\x1f\xed\x3c\xc7\xd5\xc7\xa6\xa0\xd5\xa6\x9d\xe9\xb8\xfa\xb8\x26\xfa\xd8\xb2\x33\x1d\x57\x1f\xc9\xf2\xa7\x7d\x6c\xf9\xf6\x05\xb9\xb7\xe7\x26\xd6\x36\xe0\xda\xb2\x73\x9d\xbd\x3d\x7b\x27\xc9\xb0\x92\xb5\x75\x72\xda\xb2\x73\x9d\xbd\xbd\x92\x05\xd9\x85\x8a\x76\xae\xb3\xb7\xe7\xe8\x64\xdb\x43\xcd\x16\x54\x34\x49\xa7\xac\x8f\x7e\xd1\x47\x3b\xd3\x71\xf5\xb1\x5d\xf4\xd1\xce\x74\x5c\x7d\x84\x89\xa4\x7d\xb4\x33\x1d\x67\x1f\x1b\xa2\x8f\x76\xa6\xe3\xec\x63\xcb\x63\x7d\x6c\xdb\x99\x8e\xab\x8f\x0d\xd1\xc7\xb6\x9d\xe9\xb8\xfa\xd8\x12\x7d\x6c\xdb\x99\x8e\xab\x8f\x84\x95\xd3\x3e\xb6\xed\x4c\xc7\xd5\xc7\x67\x62\x1e\xdb\x76\xa6\xe3\xea\x23\x59\x1e\xac\x8f\x76\xa6\xe3\xa4\xd5\x0e\xa7\xd5\xb6\x9d\xe9\xb8\xfa\xd8\x2c\xfa\xb8\x66\x5f\x90\xfb\xfb\x6e\x41\xb5\x4b\x3b\x69\xe7\x3a\xfb\xfb\xf6\x4e\x02\xcd\x01\x0f\x68\xdb\xb9\xce\xfe\x7e\x89\x18\xd0\x01\x11\xd0\xce\x75\xf6\xf7\xed\x9d\x24\xbc\xa3\x09\xc3\xda\xb1\x8b\x3a\xae\x3e\x92\xf9\xa0\x7d\xec\xd8\x99\x8e\xab\x8f\x2d\xd1\xc7\x8e\x9d\xe9\x38\xfb\xd8\x10\x7d\xb4\x33\x1d\x57\x1f\xfd\xa2\x8f\x76\xa6\xe3\xea\xe3\xba\x98\xc7\x8e\x9d\xe9\xb8\xfa\x08\x34\x47\xfb\x68\x67\x3a\xae\x3e\x82\x48\x4e\xfb\x68\x67\x3a\xce\x3e\xb6\x3c\xde\x47\x3b\xd3\x71\xf5\xb1\x2d\xfa\xd8\xb5\x33\x1d\x67\x1f\x7d\xde\xc7\xae\x9d\xe9\xb8\xfa\xd8\x14\x7d\xec\xda\x99\x8e\xab\x8f\xcf\xc4\x3c\x76\x5b\xe6\x82\x84\x6b\x94\x1c\xa7\x13\x1c\x46\x41\xce\x9c\xca\xc0\x5d\x41\x2d\x47\x8e\xb8\x68\x13\xd5\xe0\xdf\x25\x14\xe8\x1a\x56\x5a\xc6\x67\x65\x7c\x52\xa6\x6f\x2f\xd3\x64\x65\x9a\xa4\xcc\xc0\x5e\xa6\xc5\xca\xb4\x48\x99\xd0\xd0\xe6\x6a\xaa\xca\x5d\x8b\xa5\xee\x82\x01\x6d\x21\x53\xba\xc8\xa6\x1b\xe4\x81\xed\x60\x1e\xe4\x81\x08\xe5\x13\xe4\x81\x5b\x39\x16\xbf\x8c\xf2\xec\x24\xc9\x83\xb1\x80\x19\x6f\x07\x79\x40\x3d\x48\x9e\xa2\x75\x0b\x74\xa8\xf3\x06\x0f\x73\x0e\x5d\x78\x9c\x40\x79\xa3\x33\xce\x94\x57\x02\xcd\xd3\x02\xe4\xcf\x3f\xff\x8c\x3a\x70\xf1\xd6\xb8\x5a\x6f\x14\xf7\x6d\x45\x89\x7f\xa0\x56\xd3\x20\x0e\xb5\x2f\x7b\x68\x13\x81\xda\x7d\x38\x4e\x92\xb4\x26\x75\x72\x55\xd1\xbd\xbb\x3a\x07\x65\xdf\xa0\x4d\xe9\x49\x5f\x38\x02\xf5\x5a\xad\x56\xe0\xb6\x84\xba\x6d\x9a\x2f\xed\x19\x04\x13\x6d\xd7\xa9\xc2\xc6\xae\x9f\xe5\x55\x19\xce\x85\x72\x56\x7e\x5b\x5d\x3b\x6b\x82\x63\xaa\x59\x1d\xdc\x3c\xdd\xac\xc1\x25\x16\xe9\x6c\xbb\x4a\x67\xdf\x58\x3b\xfb\xe6\xb6\x9d\x7d\x63\xed\xec\x9b\xaa\x9d\x35\x7b\x2b\x3b\x51\xd5\x44\xf7\x79\xb0\x29\xc8\xa9\x67\xf7\x1f\x04\x83\x77\xea\xc6\x00\x3e\x8a\x36\x4f\xaa\xd2\xbc\xf2\x73\xbc\x21\x15\x9d\xb7\x85\x7c\xf7\x98\x61\xbc\xd3\xfb\x6d\xa1\x7b\x0f\xc7\x15\x17\x2a\xbb\xfe\x17\x98\xc0\x15\xc6\xde\xa9\xfd\xee\x62\x8f\xdd\x92\xd5\x6a\x7b\xca\xb5\xc4\xde\xc2\xf7\x11\x94\x16\xf6\x94\xbb\x88\x3d\xe7\x25\xc4\xfc\x1b\x87\x23\x96\x1b\x18\xe6\x90\x45\xe0\x09\x61\x4c\xd5\xa2\x15\x92\x95\x83\x1b\x42\x29\xab\x07\x05\x2b\x38\x65\x8a\x1b\x3a\x78\x2c\xae\xff\x8d\x8d\x17\x3e\x7f\x30\x68\xc1\xe5\x5d\xc9\x23\x68\x90\xaf\x76\x0f\x07\xfa\x4b\x20\xa9\xa9\xbe\xae\x3c\x94\x79\x48\xbd\x42\x03\x3e\x89\x36\x51\x80\x96\x50\xad\xd6\x47\x3f\xd1\xcd\xb1\xf6\x6f\xf2\x33\xac\x13\x36\x70\x85\x96\x50\x2e\xb5\x27\x02\x16\xc7\x64\x9a\x32\xba\x52\x69\x9c\xf2\x56\x13\x2d\xa3\xac\x0e\xd5\xfa\x9a\xd1\x9b\xc0\x4a\x3b\xff\x57\xc3\x0a\xb6\xe3\xda\x00\xfd\x84\xfe\xfd\x75\xb0\xd2\x0e\x41\x73\xb1\xea\xa3\xdf\xd1\x00\xfd\x4e\x10\xbb\x7f\x64\x34\x01\x70\x2e\x32\x04\x91\x5a\x1f\x7d\xb9\xe7\xc1\x91\x6f\xab\x8f\x5d\x69\xd2\xe7\x26\xde\xaf\x12\x64\x8d\xfb\x89\x69\x2e\x8a\xb0\x1a\x4c\x30\x0e\x67\x31\x47\xe9\xdb\x86\x35\x63\xeb\x52\x18\xb9\x1c\x6c\x77\x2c\xbe\x5f\xe5\xe5\x4d\x87\xaf\x22\xbe\x98\x72\x99\xaf\x66\xe4\x3f\xd8\xee\x58\x4d\x06\x9c\x93\x30\x27\x57\xfd\x7d\x4d\xc1\xad\x42\x3b\xcc\x9f\x38\xd9\xcb\xef\x3e\x26\x8e\x3a\x95\x89\x89\xd8\x9b\x04\x03\x32\x19\x4a\x66\x78\x73\x3e\x58\x31\x73\x4e\x8a\x6c\xf6\x74\x5e\x4a\x33\xb0\xb3\xc8\xd6\x0e\x0b\xa8\xe6\x5f\xda\xc5\xec\xef\x1f\x93\x8d\x2e\xb6\xa7\x2c\xce\x10\xda\xc5\x38\xec\x07\x83\x4f\x2c\xae\xe6\x24\x09\x61\x49\x11\x9a\x11\xf3\x0d\x2f\x7b\xbb\x2f\x89\x08\x64\x11\x0f\xc0\xcc\x09\xbe\x2a\xd6\x72\x60\xe1\x42\x5b\x39\x20\x00\x98\x31\x8f\x58\xf5\xbd\xdd\x97\x2b\x3b\x31\x8d\x55\x0e\x06\x54\xbb\x2f\x2d\x06\x3f\x53\x87\xb9\x0c\x33\x33\x2c\x31\x99\x71\x8b\xa6\x2c\x04\x15\x17\x48\xe8\xa3\xed\x9e\x59\x0a\xe5\x41\x0b\xc9\xa1\x3c\xd4\xf2\x3c\x46\xf9\x6b\x7c\x9d\xe5\x29\x0e\x26\x5b\x71\xc8\x7a\x67\xb1\x8e\x4c\x98\x59\xac\x00\xe7\xb1\x06\x6c\x42\xf6\x11\x9e\x60\x08\x32\x0e\xc6\x98\x74\x9e\x58\xac\x4c\xf0\x9f\x8f\xf1\x55\x4e\x5f\xdb\xc5\x77\x7c\xf1\x92\xc5\x4c\x85\xd6\x57\xb2\x71\x34\xc0\x35\x8e\x82\xb8\xa9\x17\xb8\xd8\xec\x27\x95\x59\xdb\xc6\x7f\x97\x59\xbb\xc3\xe8\x82\xe1\xf0\x28\xca\x16\x1e\xdb\x6f\x46\x37\x27\x45\x87\xfa\x78\x90\x4c\x98\xd7\x3d\x21\x88\x28\x99\x65\xd5\x48\x46\x74\xb1\x92\x38\x5e\xd2\x9b\xda\xdc\x2e\x68\xbe\x11\xe6\x81\x0d\xce\x7b\x17\x45\xb0\x96\x8b\xe7\xaa\xd1\xb8\x1c\x8e\x99\x36\x5f\x7c\x86\xcc\xae\x17\xd6\x23\x8d\x28\x8d\x36\x51\x74\xc1\xa6\xb0\xe1\x58\x89\xc9\x05\x46\xfb\xbf\xc0\xf9\x33\x9b\xf5\x33\xfc\xbf\x33\x1c\xe7\x25\xa7\x67\xc0\x57\x38\x30\xcc\x35\x80\xd6\xf1\xd1\x26\xc4\x9c\x04\xf2\xc7\xa8\x1c\xd3\x81\x86\x82\x35\x01\xc4\x43\x6a\x57\x56\x57\x11\x9b\x91\xe2\x9d\x35\x5b\x6e\x79\xd4\x18\x6a\x7a\x5e\x58\x08\x42\x24\x18\xd1\x28\x9c\xa3\x0d\x7a\x61\x58\x70\x71\x62\xf7\x65\x99\xc1\x35\xdf\x74\x16\x89\x53\xd7\x6d\x3d\x08\x1f\xdf\xbb\xf0\x81\xfe\x7b\x9a\xe2\x0c\xa7\x17\x98\x8a\x21\xc9\x8c\x88\xf2\x92\xf8\x01\x6a\x8c\x20\x8f\xfa\x63\xc6\x81\xd1\x76\x8a\x5e\xa6\x51\x10\xa3\x57\xd4\x3d\x13\x0d\xa3\x31\xc6\xf1\x60\x65\x00\x20\x78\xc8\x67\x88\x80\xad\xd1\xcf\xc9\x11\x14\xf9\x67\x10\xa3\xbd\x74\xd6\xbf\x46\x1f\x47\xe4\x9f\x95\x4b\xdc\xff\xef\xf3\x49\x10\x8d\x57\x06\xc9\xc4\x2e\xef\x9c\x1c\xf1\xe6\x4a\xc4\x1e\xb9\x50\x65\xe9\xe7\x51\x91\xef\x25\x1e\x90\x83\x02\x4d\x99\xf4\xf8\xd1\x23\x32\xe8\x40\x7a\x22\x1d\x12\x28\x89\xa8\x52\xa8\x0e\xb3\x4e\x7f\xfd\x81\x56\x57\x93\x0b\x9c\x0e\xc7\xc9\x25\xa9\x03\x1b\x9f\xcf\xd3\x81\x92\x7a\x7e\xb7\xfe\x13\x29\xfb\x5c\x7c\x6e\xca\x9f\xd7\xf5\xaf\x2d\xb6\x87\xb1\xc6\x00\x4f\x40\x85\x80\x15\xed\xae\xae\x22\xde\x2c\xea\xfb\xa4\x08\xa0\x0c\x4d\x37\x9e\x8b\x2a\xcd\xa2\x8a\x28\xf3\x08\x10\xa0\x85\x68\xa9\x96\x5a\x8a\x15\x7b\x04\xa8\xb0\x72\x37\xf0\x5f\x42\x90\x72\x89\xa5\xa5\x7e\x4b\xfa\x0e\xff\xe1\x65\x68\x91\xa5\xa5\x7e\xf3\xf9\x63\x77\x81\xa5\xa5\xbe\xcf\xbe\x93\xff\x42\xc7\x79\xa3\xf0\xb0\xb4\x09\x3d\x7f\xf1\x82\xe5\x83\x94\x5f\x37\xa9\x0a\x50\x79\xcb\x10\x32\x5b\x12\xd5\x1a\x57\x0d\x9f\x69\xfd\x8a\xa2\x8c\xeb\x91\x42\xe4\xe5\x8d\x4e\x1d\x6c\x79\xd4\x06\xf4\x5f\x95\x46\xd8\x4b\x7a\x83\xc4\x49\xa9\x78\x59\x67\x04\x23\x4d\xc1\xea\x2a\x22\xbb\x04\xdc\xc4\xa0\x48\x5a\x48\x74\xf1\x18\x2b\xed\x49\x86\x00\x5e\x86\x92\x78\x7c\x4d\x97\xe3\xf6\xaf\x87\x47\xdb\xe8\x23\x7a\x81\xd6\x01\x26\x6f\xd0\xb7\x61\x41\xef\xe2\xd4\xce\xb2\x6f\xbc\xbf\x7c\x2d\x29\x67\x01\xb1\xae\x56\x1c\xaf\xff\x44\x99\x73\x51\x91\xd3\x28\xae\xc9\x30\x66\xab\x8c\x27\x8a\x66\xf9\x80\x19\xa8\x97\x49\x3c\xc8\x2d\xf5\x80\xd0\x60\x6f\xa4\x5c\x06\x42\xb7\x90\x83\xd0\x7c\x59\x88\x4b\x07\x84\xb0\x4d\x9a\xa7\xac\xe8\x91\x2e\x1a\xb1\xcf\x12\xae\xaa\xea\x79\x11\xa1\x08\x39\x04\x23\x74\x3b\xe1\x08\x2d\x28\x20\x21\x55\x9e\x33\x0f\x5d\x05\xdd\xcb\x67\x2f\xb1\x34\x9e\x6b\x92\x95\x28\x2e\x09\x58\x4e\x11\x4b\x2a\xbc\x80\xa4\xd5\x7e\x90\xb4\xbe\x77\x49\xcb\x21\x5f\x39\xd4\x3b\x27\x47\xe5\x72\xce\xa2\xea\x1d\x0b\x4b\xd7\x79\xf9\x03\x13\xff\xfb\x31\xf1\xd2\xd3\xec\x57\x60\xd9\xfb\xf1\x20\xc5\x10\xb9\x81\x01\xd7\x40\x32\x39\xa4\x98\xdc\x65\x44\x8d\x69\x1c\x5f\xe0\xb6\xfc\x0b\x6a\xfc\xa5\x36\x87\xaa\xbb\xc2\xfc\xf3\x36\x29\xb3\xc0\x2e\xd0\x79\xd8\x05\xfe\x12\xbb\xc0\xce\x18\x0f\xf2\x34\x89\xa3\x01\xea\x25\x21\xee\x27\xc9\x7c\x85\xff\x4e\xaf\x4c\xe1\x4f\xbf\x2e\xb4\x23\xec\xf4\x54\x85\x3f\x79\xbe\xaf\x1d\x40\x66\xed\x2a\x03\x51\xeb\x95\x69\x31\x09\x3e\xca\x42\xfa\x5a\xf8\x85\xf8\x56\xf8\xf1\xd4\x4b\xbd\xf9\x7a\x33\x28\xb3\xc0\x3a\xfe\x6b\x27\x47\xfe\xcf\x59\xc7\x87\xb3\x7c\x3a\xcb\xab\x5f\xda\x1d\x96\x5e\xda\x1d\x2e\x7e\x69\xa7\x4b\x75\x87\xda\x25\xde\xe1\x9f\x7b\x1d\xf4\xd5\xa5\x3a\x53\x37\x2f\xde\xdc\xaf\x64\x57\xd2\xd0\xf7\x22\xdd\xfd\x9d\x4e\xd8\x87\xda\xb5\xa6\x4b\x88\x3a\xac\x70\x69\x71\xb8\xe0\xa5\xc5\x43\x16\xbb\xbf\x06\xf3\xdd\x7a\x7b\xbc\x8f\x7e\x5b\x79\xd6\x6c\x71\x03\x71\x94\xe5\x64\x79\x9f\x5f\x1b\xdc\x77\x1a\x84\x2b\x5b\x71\x16\xfd\x46\x4a\x8b\x5c\x70\xd3\x20\x94\xd9\x5f\x18\xe4\x81\x74\x11\xea\xba\x00\xcd\xd4\x1b\x50\x52\xeb\xb8\x30\xf8\x55\x0c\x80\x9f\xab\x45\xfb\x7a\x5a\x91\xbe\x2b\xa1\x08\x10\xc5\x2c\xce\x45\xcf\xb4\x60\x56\x60\x8b\xf7\x8e\x7e\x33\x80\xd1\x17\xcb\x2a\x66\xff\xd0\xbe\x1b\xad\xd1\x98\x36\xe3\x20\xa3\x91\xb3\xd0\x34\xc9\x22\xd5\x03\x9f\x34\x4a\xbe\x93\xfa\xef\x12\xde\x59\xd1\xc2\x92\x86\xd1\x32\xf2\xb5\x46\xde\x05\x61\xf1\x0c\x03\x25\xb2\x8d\xa8\xaf\x29\x2b\x91\xdb\x2a\x42\x6a\xa9\x8d\x14\x21\xb5\xe4\xd2\xb6\xe0\x5a\xaa\x65\xf6\x92\x06\x88\xdb\x21\x72\x0b\xdc\x59\x6c\x21\x0e\x9d\x22\x5e\xe1\x5c\x4a\x38\xaf\x4c\x15\x55\xe0\x8b\xd1\x2c\x9f\x39\xa9\xcf\x35\x15\xcd\x65\x72\xfc\x65\x7d\x2f\x2e\x82\x24\x14\xd8\xbe\x62\x78\x48\x68\x60\x1c\xbd\x7d\xfc\xe8\xc6\xca\x37\xf9\x72\xb9\x7a\xd6\x6c\x2d\xc4\x3b\xef\x96\x98\xec\x81\x77\x7e\x2b\xde\xb9\x7f\x7c\x88\x20\x24\x6e\x35\xd6\xb9\xcf\x02\xe8\xde\x95\x75\xfe\xe9\xec\xb0\x58\x12\x73\xf8\xa1\x85\x55\xd1\x74\x00\xf6\x08\x74\x2b\x69\x10\x87\xc9\xa4\x66\x70\xc0\x7a\x7d\x45\x93\x94\xca\xe1\xb0\xd4\x61\xa7\x06\x97\x6b\xb6\xcf\x3c\x02\xee\x81\x51\xe9\x8c\x8a\x13\xe7\x42\x8c\xea\xaf\x9d\x79\xe1\x3f\x8a\x51\xad\xee\xef\xf4\xd0\xb3\xb5\x67\x6b\xcb\x3e\x62\xb4\x81\x0e\x70\x3e\x4a\x42\xd4\x74\x71\x2b\x08\xed\x7d\x5b\x6e\xb5\x15\x86\xd4\x7f\x50\x5d\x10\x15\xb8\x00\x5f\xbd\xa4\x36\xfd\xe3\x8b\x56\x69\xe0\x7f\x70\x9a\x40\xee\xb0\x7c\x84\x51\x8a\x33\x89\x2f\x2a\x1d\x21\xe5\x58\x8f\xc9\xb3\x81\xf7\xad\x78\x01\x5b\x88\x9f\x19\x0e\xea\x6a\x74\x36\x0f\xa0\x29\x3c\xfb\xc2\x4e\x62\x8c\x26\x49\x8a\xa9\xf0\xb8\xbc\x0c\x7d\x73\x8d\x22\x5f\xef\xcb\xcb\x15\x17\x38\xcc\xe7\x22\x0b\x7c\xed\x6e\x51\xce\x1f\x16\xf8\x37\x3b\xc5\xa1\x38\x49\xa6\xd5\xc4\x90\xb7\x9c\x1c\x9d\x2b\x5b\x10\xbb\x7b\x4d\x14\x45\xca\x68\x4e\x34\xb5\x10\xd1\xdd\x2d\xdc\xec\x03\xd1\x7d\x2b\xa2\xfb\x1f\x89\xf9\x95\x93\x9c\xc4\x03\xff\x44\xe1\xb7\xf2\xc1\x59\x3e\xdf\x1a\x02\x70\xad\x56\x2e\x02\xd7\xd1\x97\x2f\xfa\xab\x5b\x6d\x31\xf6\x1e\xcf\x8f\x2b\xb0\xba\x8a\xde\x13\xf8\x6a\xbd\xc8\x88\x14\x00\x9a\x05\x51\xe6\x72\x14\x8d\x31\xaa\xfd\x50\x2b\x7c\xad\x8b\x18\xdc\xe0\x71\x68\xc4\xdc\x16\x26\x9c\x86\x22\x33\x12\x5b\x12\x52\x55\x94\xba\x63\x37\xc4\xe3\xad\xb2\x7b\x49\x14\xb4\x10\x2f\xf9\x6b\x3b\x6e\x59\x72\x74\xd1\x24\x59\x5f\x97\xaf\x14\x99\x90\xa0\xb5\x3f\x3f\xcf\xc7\xd7\x4d\x12\x5e\x2d\x26\xb6\x11\xf3\x5a\x7c\x39\xde\xdb\xf2\x8b\x58\xcf\xe4\x49\xfa\x68\x26\x02\xb7\x39\x88\xbe\x0b\xb2\x8c\x2c\xe4\x65\x82\x5a\x88\x5e\xe3\x6b\xb4\x8d\xd3\xe8\x82\xe6\x84\xdc\xe5\x83\xd2\x2c\x8f\x39\xfd\xee\xe5\xeb\xed\xdd\x66\xd1\x9a\x78\xae\x98\x78\xbc\x97\xc4\xc3\xe8\x7c\xc6\x32\x51\x26\x90\x15\x32\x2b\xcb\x2f\x99\x26\x53\x9c\xe6\xd7\xe8\x0f\x7a\x2c\x06\x6f\x52\x60\xbe\x27\x23\x9a\xe3\x38\x23\x0f\x51\xcc\xd2\x05\xe4\x89\xf0\xa5\x59\x41\xdb\x78\x18\xcc\xc6\xf9\x06\x6a\xa3\x9a\xdf\x5c\x87\x44\xca\x75\x17\x7c\x47\x42\x73\x9c\xf2\x44\xe6\x05\x38\x32\xfe\xf3\xd0\x8c\x72\x96\x3c\x33\x03\x50\xc5\xa1\x5e\xfa\x90\x27\x68\x8a\xd3\x61\x92\x4e\x24\xe0\x0a\x64\x29\xfd\xe3\x60\x78\xbe\xe1\x1a\x65\x44\x2f\xbe\x8e\x21\xe6\x8c\xdf\x5c\x5f\x6d\x35\xb5\x10\xdc\xb4\x2b\x14\x75\xed\x53\x81\x90\xd2\xf8\x4d\xbd\x2c\x21\x69\x59\x02\x79\x32\x2b\x61\x41\x5a\x7c\xbd\xcd\xcf\x22\x7a\x08\x7c\xee\x86\x74\x55\xce\x18\x4a\xc6\x6f\x60\xa3\x1b\xee\x6f\x36\x4c\x52\x38\xc5\x14\x8d\xde\x43\x62\xd0\x4f\xe1\xd0\x48\x1a\x4f\xa9\x9d\x9f\x1e\x15\x33\xac\x45\x2a\xfe\x51\x4c\xd6\x3a\x4d\x3f\x79\x67\x30\x9e\x3a\x8d\x8d\x46\x43\x07\x5c\x92\xbd\x7e\x30\x3c\xb7\x1b\x5e\x90\x89\xd8\x14\x3f\x39\xe1\x91\xe2\xae\x60\x18\xe6\x7a\x87\xeb\x0a\xea\x41\x57\x95\x05\xdd\x26\xdf\xec\x94\xc1\x06\x6a\xe1\x0f\x2b\x15\x2b\x67\xc1\x38\x47\x5b\xf0\xcf\xe2\x89\x68\xb9\x1b\x8d\xe4\xd7\x7e\x17\xb2\xa3\x89\xd4\xc3\xe1\x0a\x8b\x4a\x52\xe3\x9d\xf1\x00\x3f\xe7\xa4\xb2\xe2\xf2\xbc\x6a\x35\x17\xca\xed\xa2\x4e\xbd\xd5\x80\x30\xca\x1d\x49\x61\x99\x97\x3d\xf8\xee\x33\x5a\x25\xe4\x43\x79\x90\x27\x66\xc7\x6e\x96\xe8\x4e\x50\x0e\xb2\x29\x1d\x6c\x9a\x6e\xde\xd0\xe7\xd8\x42\x3d\x81\x9c\xbc\x1f\x87\xf8\xca\x56\xe3\xb4\x71\xc5\x14\x40\x96\x68\x9d\x73\x42\x74\x09\x54\x84\xb0\x2c\xde\x38\xf3\xd7\x17\xd8\xf0\x4a\xc5\x1b\x67\x25\xbe\xe5\x6d\x92\x59\x59\x61\x4f\x36\x23\x8c\x62\x6b\xa1\x45\x8b\x17\x73\x8c\x2c\xd4\x8f\x4c\x50\xd7\x3a\xc8\xe3\x22\xbd\xe0\xf8\x58\x8d\x0b\x44\x27\x59\x9e\x63\x9e\x2c\x1b\x28\xb0\x48\xe3\x5b\xf4\x5a\x9f\x33\xc4\x32\x7a\x17\xa9\x81\xcd\xef\xf3\xb3\x31\x00\x7c\x65\x88\xad\xa3\x6b\x16\x17\x59\x8c\x8a\x57\xac\xe3\x0e\x44\xf6\xc5\x18\xdb\x41\x47\x72\x34\x3b\x06\xd6\x82\x85\x62\xcb\xe1\x53\x5b\x0e\x69\xfa\x9c\xc6\x1c\x08\xf8\xb9\xd2\x04\x8c\x9e\x18\x69\xf9\xa3\x6d\xac\xab\x8c\x37\x9a\x17\x0a\xca\xd6\x59\x3e\xfa\xf2\x3b\x7b\xc0\x2a\xa9\x89\xdf\x0e\x8f\xd4\xee\x80\xeb\x94\xc5\xe3\xda\x18\xb7\x8f\xd4\x06\xe6\x23\xb7\x81\x91\x66\xf3\x39\xfa\x58\x32\x7a\xe4\xaf\xa8\x71\xfa\x11\xcc\x61\x8c\x8e\x9c\x7e\xd4\xcd\x62\xf8\xdf\x8d\xf9\x5a\x0f\x38\x45\xfe\x24\xe6\xc0\x74\xd3\xd0\xa8\x6d\x4a\x34\x26\x71\xda\x38\x5b\x5a\x2a\x37\x29\x92\x80\x4b\x47\x5f\xce\x37\x2c\x41\xcc\xd8\x5e\x56\xd4\x2b\x33\xa0\x94\x8f\x11\x77\xda\xd0\xab\x04\x9b\x29\xdd\xc8\x17\xdc\xc4\xef\x4b\xb4\x8c\x32\x5b\xba\xfd\xf9\xd1\x6b\x2c\xa2\xc1\x3d\x04\xb1\xa1\x22\x82\x90\x0c\xa9\x50\xe8\x12\x13\x16\xab\xe6\x21\x87\x6c\x7a\x17\x30\xa5\xb2\x69\x11\x64\x47\x1c\x25\x5d\x02\x8c\x87\x74\x41\x95\x0d\xbb\x2a\x16\x93\x42\x73\x84\xa7\x9b\x32\x5b\x34\x0a\xcd\x1e\xa8\x47\x4f\xa1\xcb\x73\xc2\xde\x9c\x79\x6b\x7f\x6d\x1f\xfa\x05\xd2\xba\xcf\x4f\x8e\xfe\x75\x75\x47\xce\xf4\xda\xae\xac\xd7\x7f\x07\xed\xd2\x31\x18\x67\xf6\xb8\xf1\x2e\x55\x22\xc9\x2f\xcb\xf4\x48\x02\x8f\x23\x3c\xcb\x82\xfe\x18\xb3\x70\x60\x12\x3a\xc7\x48\x4e\xb5\x48\xa1\xe8\x6f\x5e\x21\x35\xc3\x9a\xb4\x2d\x1c\x41\x36\x65\xc4\x0c\x6d\x99\x8d\xb1\xa9\x49\x12\xe5\x21\xc6\x4a\x94\xa1\x00\xd1\x04\xcc\xe8\x02\xa7\x19\x44\x2d\x1b\x05\x39\x8a\xf1\xf9\x18\x0f\x72\x1c\x12\x36\x3c\x60\x29\x55\x73\xa6\xf0\xc9\x13\x34\x8e\xf2\x7c\x8c\x97\x69\x80\xcb\x15\x15\x28\x4e\xd3\x24\x45\x61\x82\xb3\xf8\x49\x8e\x82\xe1\x10\x0f\x68\x5d\x8a\xd4\x93\x0c\x65\x78\x30\x4b\xa3\xfc\xda\x13\x15\xfb\xb3\x1c\x45\x39\x54\xe2\x35\xa2\x3c\x13\x01\x15\xa2\x71\x94\x33\x27\x6e\x9a\xd7\x35\x22\xfc\x79\x82\x63\xba\x1f\x64\x36\x45\x19\x1d\x90\x37\xb4\x73\x42\x5d\xa6\xbd\x95\xe7\xef\xb6\x49\xdb\xca\x0f\x29\xaf\x65\x33\x68\xe7\x01\xa3\xb0\xde\x86\x53\xc3\x45\xd9\x69\x21\x62\x27\x34\xb2\x7b\x61\xe7\x39\xed\x37\xd1\x2e\xf9\x65\x49\x1c\xf7\xfa\xb4\x71\xe6\xa1\xda\xeb\xd3\xd6\x19\x0b\x16\x80\xbe\x90\x47\x76\x15\xe0\x77\xeb\x96\x24\x72\xaf\x4f\x7d\x5a\xa9\xa1\x56\x6a\x95\x57\x6a\xd2\x4a\xbe\x5a\xa9\x51\x5e\xa9\x45\x2b\x35\xd5\x4a\xbe\xa8\xa4\xd6\xb1\x65\x47\x32\x86\x8c\x7b\x19\xba\x06\xad\x27\x06\xad\x67\x1f\x34\x13\x1f\x69\xb8\x58\x9f\xe8\x85\xc9\x70\xc8\xd3\x0e\x52\xa4\x69\x90\xd5\x46\x83\x7c\xb1\xf5\xd7\x9c\x88\x96\x0a\xd9\xb7\x42\x6e\x56\x82\xdc\x70\x0e\xbc\x04\x43\x83\xdc\xaa\x04\xd9\x77\xcd\x8e\x27\xc1\xd0\x20\x37\x34\xc8\xf3\x27\xb2\x17\xa4\xe9\x35\xea\xeb\xe9\x54\xe9\x54\xf5\x69\xfc\x0b\x53\x93\x91\xd3\xc9\x27\xac\x27\xbb\xce\x72\x3c\x41\xc3\x64\x96\xa2\x3c\x9a\xe8\x73\xbf\x60\x50\xde\x18\x5f\xe5\xc7\x64\xf5\xb9\xe3\xc7\x5a\x22\xde\x1e\x24\x61\x34\xbc\xa6\x9c\x90\xd2\x61\x05\x2c\xd6\xdd\x58\xf4\x4e\xa9\xe3\xc0\x6f\xa7\x90\xf2\x12\xa2\xad\x18\x99\xe2\x6c\x49\x72\x7f\x41\x19\xce\x67\x53\xf5\x43\x89\x47\xc7\xfc\xc3\xfe\xfe\x2f\xd4\xb5\xa3\xec\x84\xbf\xff\xcb\x87\x06\xda\x44\xfb\xbf\x98\xa9\xd1\xa4\x22\x3e\x2d\xe2\x5b\xa3\x19\xcb\x4b\x1a\xa6\x32\x9b\xf5\x2f\x30\x11\x15\x5c\x47\xff\x06\x0d\x7e\x0c\x6d\xd3\xe8\xc7\x5f\x10\x7d\x72\x45\x3f\x96\x8b\xb3\x30\xc7\xa2\x7c\x71\x1d\x6a\x0f\x73\x2c\x9a\x6d\x8a\x66\x7d\xa5\x59\x7f\x5e\xb3\xbe\xda\xac\xbf\x58\xb3\x10\x46\x27\x6a\xf0\x25\x48\x80\x44\x4d\x75\x05\xba\xaa\xb6\xa0\x6a\x93\x2f\x66\xa8\xda\x50\x97\xa9\x63\x46\x18\x59\x97\xb1\x56\x04\xd4\xda\xa0\xe7\x7a\x3d\xb6\x3f\xfd\xe8\xd3\x8f\xbe\xf5\x63\x93\x7e\x6c\x5a\x3f\xb6\xe8\xc7\x96\xf5\x63\xbb\xac\xcd\x4e\x59\x9b\xdd\xb2\x36\xd7\x44\x9b\x25\x1a\xa9\x4a\x9c\x07\x2d\xce\x7d\x50\x35\x0e\x84\x4c\x25\x85\xec\x47\x74\x2f\xc9\x5d\x9d\xca\x6b\x49\xfa\xa8\xc4\x99\xd5\x22\xf6\xde\xb9\xb7\x77\x18\xdc\xc2\xcb\x0c\xb8\x90\x5a\xfa\x98\x86\x1a\xfa\x0d\x88\x10\xd5\x7e\x23\x73\xcf\x57\x09\x3c\x8b\xbd\xf7\xb9\x5e\xd1\xa7\x15\x9b\xac\xe2\x9a\x56\xb1\xe3\xac\xd8\xa4\x15\xdb\xac\xa2\xaf\x55\x5c\x73\x56\x6c\xd1\x8a\xdd\x33\x81\x9a\x52\xd1\x2f\x2a\xde\x69\x17\x2b\x8b\x52\x4f\x11\xe1\xb1\xe3\x8f\x59\x4a\x76\x16\x3c\x1e\x1e\x6f\x13\x3d\x9e\xc3\x61\x0c\x4e\xc0\xb1\xc5\x8f\xb7\xe2\x6b\x75\xc2\x43\x52\x8e\x5e\xe1\x4d\x77\x5c\xee\x45\x27\x53\xbf\xb0\xe3\x29\x6e\x6e\x8b\x8f\xd1\x05\xfd\xd2\x6d\xaf\xb6\x9a\xba\x5a\x4e\x2c\x13\x41\xb0\xb5\x8a\xae\x50\xca\xfa\x50\xbe\x48\x22\xa8\x66\xf0\x73\x1c\x5c\x60\x94\x8c\x43\x27\xab\x5d\x40\x7e\xe8\x7d\xa0\x93\xdb\xd3\xe3\x1d\x2a\x2d\xf6\x82\xf1\x60\x36\x26\x2b\x2c\xc6\x97\xce\x66\x7b\x2c\x11\x4c\x8f\x26\x82\x69\x5c\xb5\xc3\x16\xfc\x1f\x5a\xe2\x12\x9a\x9e\xaf\xa5\xc7\xf2\xc2\xf4\x68\x5e\x98\xc6\x15\xab\xd1\x82\x98\xf2\x3d\x2e\xa0\x36\xea\xe8\x05\xaa\xf5\x3e\x48\xcf\xff\x85\x7c\xb4\x81\x1a\x75\x13\x62\x93\x41\x6c\x52\x88\x0c\x60\x9b\x41\xf4\x35\x88\x7e\x05\x88\x2d\x06\xb1\x65\x74\xab\x46\xdb\x51\x20\x36\x2b\x40\x6c\x33\x88\x6d\x6b\xaf\x5b\x1a\xc4\x56\x05\x88\x1d\x06\xb1\x63\xed\x75\x5b\x83\xd8\xae\x00\xb1\xcb\x20\x76\xad\xbd\xee\x68\x10\x3b\x15\x20\xae\x31\x88\x6b\xd6\x5e\x77\x35\x88\xdd\xb9\x10\x0b\xb1\x9f\x02\x55\xaa\xaf\xe9\xd5\x75\xef\x18\x41\xd3\x64\xf7\x39\x5f\xbe\xc3\x22\x22\xa5\xce\xaf\x80\x57\x47\xa4\x6b\x3d\x4b\x12\x0e\x9e\x2e\x3f\x9d\x0d\x72\x34\x8a\xce\x47\x28\x88\x43\x34\x4e\x2e\x51\x90\x9e\xcf\x20\xfc\x0b\xb8\x39\xff\xef\x2c\x48\x8d\xc4\x3d\xd0\x40\x80\x36\x49\x2b\x5c\x8a\xb3\x28\x0f\xce\xfb\xb4\x08\xdd\x25\xac\xc7\x27\xde\x67\x05\x83\x14\x67\xb3\x71\x8e\x92\x61\x59\xf3\x23\xba\x05\xd4\xce\x03\xf4\x14\x9d\x07\xd4\x75\xc5\x5f\xab\xa3\x25\x44\x5f\xf5\xd9\xab\x0e\xbc\xea\xc3\x2b\x1b\x92\x63\x0a\x48\xea\x0a\x3d\x12\x3e\x45\xe7\x57\x30\xc3\x75\x20\x08\x5e\x40\x88\x9d\x52\x01\x5b\x22\x18\xd2\xa1\xdf\x0e\x8f\x10\x84\x93\x94\x3f\xbe\xa2\x1c\xee\x7c\x84\x7e\x47\xe7\xe3\xaa\x4c\xce\xae\x54\xf9\x8d\xb1\xb8\x57\x94\xc5\xd5\x6a\xaf\x8a\xed\x9b\xec\x64\xaf\x24\xb1\xa0\xce\x0a\x74\xd5\x02\xdd\xa2\x80\x4e\xcf\xbf\x31\x6e\xf8\x8a\x72\xc3\x1a\x6d\xa6\xd8\x6f\x5f\x71\xfe\x07\xfb\xed\x12\x22\xad\x99\x30\x9a\x0c\x46\x93\xc3\xf0\x55\x04\x7c\x03\xc3\x86\x5a\xa0\x51\x86\x61\x8b\x41\x6f\x71\xe8\x4d\x15\xc3\xa6\x86\xa1\x6f\xc1\xb0\xcd\x60\xb4\x39\x8c\x96\x8a\x40\xcb\xc0\xb0\xa9\x16\x68\x96\x61\xd8\x61\xd0\x3b\x1c\x7a\x5b\xc5\xb0\xad\x61\xd8\xb2\x60\xd8\x65\x30\xba\x1c\x46\x47\x45\xa0\x63\x60\xd8\x56\x0b\xb4\xcb\x30\x5c\x63\xd0\xd7\xce\x14\x12\x11\x18\x76\x35\x0c\x3b\x0a\x86\x95\x12\x7f\x64\x3c\xe9\x84\xd0\xb5\x56\x48\x3b\x31\xef\xba\x8b\xc2\xca\xf1\x55\x2e\xdf\x3b\xc9\x9a\x54\x1e\x4a\x41\x49\xe3\x40\x6f\x8b\xcc\xfb\xab\xe9\x38\x20\xd8\x5c\xe5\xc8\x09\x8e\xc5\x99\xa9\x15\x2d\xdb\x20\x8a\x8b\xab\x32\xa5\xae\x9a\xbc\x43\x2e\x59\x2f\xbb\x83\x92\x0b\x56\x36\x46\xf6\xd4\xbb\x91\x8d\x4e\xdb\x2b\x2e\x45\x36\x3a\x5d\x8f\xdd\x95\x6c\x74\xfd\x9b\x33\x6f\xed\xaf\x1d\x89\xf0\xe1\xbe\xea\xe1\xbe\xea\xab\xdd\x57\x69\x4b\xbc\xb8\xcf\xd1\x6f\x72\xfe\x5a\x77\x38\xf7\x95\x15\xee\xb5\x38\x9a\xbf\x56\x8f\xe6\xaf\x6f\x7b\x34\x7f\xad\x1e\xcd\x5f\x97\x1d\xcd\xe7\x29\x98\x1f\x6e\xaa\x1e\x6e\xaa\x1e\x6e\xaa\x94\x2f\x0f\x37\x55\x0f\x37\x55\x0f\x37\x55\x45\xb3\x0f\x37\x55\xfa\xc7\x87\x9b\x2a\xc7\xe3\xc3\x4d\xd5\xc3\x4d\xd5\xc3\x4d\x15\xfc\x3d\xdc\x54\x55\x53\xe2\x3e\xdc\x54\x3d\xdc\x54\x3d\xdc\x54\x49\x7f\x0f\x37\x55\x0f\x37\x55\x0f\x37\x55\x0f\x37\x55\xff\xc9\x37\x55\xf7\x76\x47\x75\xbb\xdb\xa9\x2a\xf7\x52\x15\x6e\xa4\xbe\xd6\x5d\xd4\x5f\x3b\x1f\xca\xc3\x5d\xd4\xdf\xff\x2e\x4a\xbe\x3b\xea\xb5\xe7\x3a\x3a\xc9\x37\x47\xbd\xb6\x74\x6d\x04\x0f\x5f\xff\xce\x88\x7a\x69\x8a\x5b\x23\x7b\x50\x01\xee\xa1\x5d\x76\xad\x04\x6e\x9c\xb2\x47\xb1\x14\x33\xdd\xd4\x57\xc4\x51\x8e\xb2\x7e\x72\x65\xc2\x39\x16\xe8\x1c\xcb\xd7\x74\xfc\xcf\x26\x4d\x36\x3b\x5d\xf7\xa1\x9c\x1d\xba\xa3\xf9\x6a\xdc\xd7\xf8\xda\xa6\xc7\x55\x5b\xf4\xb8\xff\xf8\xdc\x86\xd9\xa0\x90\x21\xe0\x51\x25\x22\xf4\x0f\x79\x9c\x1c\xaa\x43\x56\x89\x6c\x6d\x7c\xec\x4f\x15\x40\x66\x24\x34\xe5\xb3\x11\x14\xcd\x76\xf6\x27\xbd\xa8\x7d\x44\x4b\x74\x7c\x96\x78\xa3\x75\xf4\x0f\xe8\x95\x23\x96\xc2\x65\x30\xb5\xe3\x0c\xfb\x86\xa9\x21\x90\x26\xe0\xd8\xee\x18\x4f\x5e\x93\x19\x9f\x3f\x3d\x3d\xab\x8a\x9f\x65\xd5\x10\x44\xf3\x91\x65\x99\x15\x80\xee\xac\x96\xe3\x9a\x10\xd0\x82\x18\xf9\xd7\xc9\xf4\xd8\x55\x86\x4a\xcb\xc2\xc9\xb9\xd9\xe9\x3a\x14\x22\x0d\xa7\x32\xc4\xda\x68\x55\xc5\x88\xb4\x9e\x34\xc5\x48\x31\x68\x91\xf6\xe5\x63\x31\x9c\x73\x33\xc0\x83\x72\x50\xad\xfe\x49\xc6\x53\x9b\x0f\xb1\x9a\x62\xba\x8c\x62\xaa\x52\x8b\x2d\x8b\x28\x02\x0d\x3a\x4d\x18\xc7\xa8\x52\xf9\xae\x90\xb0\x83\x70\xad\x44\x5b\x42\xb0\x6e\x62\x2d\x08\x55\x7d\xaf\x76\xf6\x0b\xa9\x5b\x63\x6b\x8a\x54\x61\x78\x9d\x15\x79\x0d\x62\x3d\x8f\x81\x76\x7c\x7a\x0f\x71\x50\x2c\x37\x5a\x05\xa9\x47\xc6\xd9\x9d\x8c\x85\x32\x57\x4c\x2c\x53\xb0\xfb\x5e\xe5\xde\x5e\xfb\x3e\x84\xde\x5e\x7b\x61\x89\xd7\xdc\x63\x35\x71\xb7\xd7\xb6\xc6\xb6\x80\x1b\x9a\x08\x87\xb7\xd8\xe1\xb7\xd3\x64\xaa\xec\xf2\xec\x05\x0c\xc2\x37\x88\x8a\x17\x92\xe6\xd4\x40\x73\x9a\x9e\x9f\x4c\x3c\x29\x25\x42\xcd\x21\xff\x59\x53\x06\xab\xc7\x9a\x23\xa8\x4b\x51\xbf\xb4\x55\x4c\x40\x6d\xa8\x20\xd4\x88\x71\x95\x84\x18\xd2\x06\x2f\x58\x7e\x87\x41\xc6\xb3\x64\x03\x17\x86\x2f\x04\x2f\xb2\x8b\xff\x0c\x9b\xf9\xf2\xb2\x75\x0f\x5f\x80\xdd\xa3\x39\x09\x90\xbe\xa3\xd5\x46\x86\xe8\x7e\x56\x1c\x40\x5a\x7c\xd5\x31\x9a\x2f\x5f\x79\xa4\x50\xf9\x49\xb3\xd7\xfe\x5a\xc7\xcc\xbb\xa5\xeb\xfb\x96\xe7\xcb\xaf\x76\x0a\xfc\xb6\x41\x9c\x09\xab\xc2\x19\x4e\x2f\xf0\xe3\x47\xb5\x41\x1d\x35\x1b\x7e\x13\xf5\xaf\x51\xef\xff\xfb\x7f\xc3\x34\x1a\xa0\x03\x9c\xc5\xd1\x78\x05\x6d\x8d\xc7\x28\x8d\xce\x47\x79\x86\x58\xf9\x70\xe5\xf1\xe3\x47\x47\x38\x8c\xb2\x3c\x8d\xfa\x33\x80\x1f\xc4\x21\x04\xe5\x89\x62\x94\x25\xb3\x74\x80\xe1\x4d\x3f\x8a\x83\xf4\x9a\xb0\x83\x49\xe6\xb1\x28\x0d\x29\xfc\x9b\xcc\x72\x34\x01\x9e\x3e\x00\xce\xea\xa1\x20\xc5\x68\x8a\xd3\x49\x94\xe7\x38\x44\xd3\x34\xb9\x88\x42\x1c\xd2\xa0\x13\x64\x9d\x0e\x93\xf1\x38\xb9\x8c\xe2\x73\x34\x48\xe2\x30\xa2\x6b\x98\x54\x9a\xe0\x7c\x83\xad\xf8\x65\xa4\xa2\x95\x81\x62\x98\xe2\x33\x48\x42\x8c\x26\xb3\x2c\x27\x1b\x75\x10\xc5\x00\x34\xe8\x27\x17\xe4\xd3\xf4\x1a\xba\x88\xe2\x24\x8f\x06\xd8\xa3\x71\x85\xc6\x51\x06\x9a\x65\xb9\xbd\x38\xd4\x90\x09\xa3\x6c\x30\x0e\xa2\x09\x4e\x57\x5c\x38\x44\xb1\x3c\x10\x1c\x87\x69\x9a\x84\xb3\x01\xbe\x77\x34\x10\xeb\x5a\x98\x0c\x66\x22\x0e\x06\xa9\xb1\x9a\xa4\x2c\x46\xc6\x24\xc8\x71\x1a\x05\xe3\xac\x18\x66\x98\x1b\xa8\x26\xa1\x4e\xe6\xf9\x64\x6f\xff\x18\x1d\x1f\xee\x9e\xfc\xba\x75\xb4\x83\xf6\x8f\xd1\xbb\xa3\xc3\x5f\xf6\xb7\x77\xb6\xd1\xcb\x7f\xa1\x93\xbd\x1d\xd4\x3b\x7c\xf7\xaf\xa3\xfd\x57\x7b\x27\x68\xef\xf0\xcd\xf6\xce\xd1\x31\xda\x7a\xbb\x8d\x7a\x87\x6f\x4f\x8e\xf6\x5f\xbe\x3f\x39\x3c\x3a\x46\x3f\x6e\x1d\xa3\xfd\xe3\x1f\xe1\xc3\xd6\xdb\x7f\xa1\x9d\xdf\xde\x1d\xed\x1c\x1f\xa3\xc3\x23\xb4\x7f\xf0\xee\xcd\xfe\xce\x36\xfa\x75\xeb\xe8\x68\xeb\xed\xc9\xfe\xce\xb1\x87\xf6\xdf\xf6\xde\xbc\xdf\xde\x7f\xfb\xca\x43\x2f\xdf\x9f\xa0\xb7\x87\x27\xe8\xcd\xfe\xc1\xfe\xc9\xce\x36\x3a\x39\xf4\xa0\x51\xb3\x1a\x3a\xdc\x45\x07\x3b\x47\xbd\xbd\xad\xb7\x27\x5b\x2f\xf7\xdf\xec\x9f\xfc\x0b\xda\xdb\xdd\x3f\x79\x4b\xda\xda\x3d\x3c\x42\x5b\xe8\xdd\xd6\xd1\xc9\x7e\xef\xfd\x9b\xad\x23\xf4\xee\xfd\xd1\xbb\xc3\xe3\x1d\x44\xba\xb5\xbd\x7f\xdc\x7b\xb3\xb5\x7f\xb0\xb3\xbd\x82\xf6\xdf\xa2\xb7\x87\x68\xe7\x97\x9d\xb7\x27\xe8\x78\x6f\xeb\xcd\x1b\x6b\x2f\x09\xee\x4a\x1f\x5f\xee\xa0\x37\xfb\x5b\x2f\xdf\xec\xd0\x96\xde\xfe\x0b\x6d\xef\x1f\xed\xf4\x4e\x48\x77\x8a\x5f\xbd\xfd\xed\x9d\xb7\x27\x5b\x6f\x3c\x74\xfc\x6e\xa7\xb7\x4f\x7e\xec\xfc\xb6\x73\xf0\xee\xcd\xd6\xd1\xbf\x3c\x06\xf3\x78\xe7\xff\xbe\xdf\x79\x7b\xb2\xbf\xf5\x06\x6d\x6f\x1d\x6c\xbd\xda\x39\x46\xb5\x39\x43\xf2\xee\xe8\xb0\xf7\xfe\x68\xe7\x80\xe0\x7c\xb8\x8b\x8e\xdf\xbf\x3c\x3e\xd9\x3f\x79\x7f\xb2\x83\x5e\x1d\x1e\x6e\xc3\x40\x1f\xef\x1c\xfd\xb2\xdf\xdb\x39\x7e\x8e\xde\x1c\x1e\xc3\x68\xbd\x3f\xde\xf1\xd0\xf6\xd6\xc9\x16\x34\xfc\xee\xe8\x70\x77\xff\xe4\xf8\x39\xf9\xfd\xf2\xfd\xf1\x3e\x0c\xda\xfe\xdb\x93\x9d\xa3\xa3\xf7\xef\x4e\xf6\x0f\xdf\xd6\xd1\xde\xe1\xaf\x3b\xbf\xec\x1c\xa1\xde\xd6\xfb\xe3\x9d\x6d\x18\xdd\xc3\xb7\xd0\xd5\x93\xbd\x9d\xc3\xa3\x7f\x11\xa0\x64\x0c\x60\xf0\x3d\xf4\xeb\xde\xce\xc9\xde\xce\x11\x19\x50\x18\xa9\x2d\x32\x04\xc7\x27\x47\xfb\xbd\x13\xb9\xd8\xe1\x11\x3a\x39\x3c\x3a\x91\xfa\x88\xde\xee\xbc\x7a\xb3\xff\x6a\xe7\x6d\x6f\x87\x7c\x3d\x24\x50\x7e\xdd\x3f\xde\xa9\xa3\xad\xa3\xfd\x63\x52\x60\x9f\x36\xfb\xeb\xd6\xbf\xd0\xe1\x7b\xe8\x32\x99\xa3\xf7\xc7\x3b\xf4\xa7\x44\xb1\x1e\xcc\x24\xda\xdf\x45\x5b\xdb\xbf\xec\x13\xb4\x59\xe1\x77\x87\xc7\xc7\xfb\x8c\x4e\x60\xc8\x7a\x7b\x6c\xb8\x57\x1e\x3f\x7a\xba\xaa\xea\xbc\x0e\x82\x7c\x74\xbf\x7a\xaf\x6a\x51\xa7\x69\xe0\x63\x51\x84\x3e\x56\xb2\xce\x86\x0b\xbb\x20\xce\x33\x94\x07\x7d\x2e\xb1\x90\x2a\x1f\x3e\x8f\xad\xc1\x36\x0b\x39\xaa\xe1\x21\xe4\x7b\x08\x35\x3d\x84\x5a\x1e\x42\x6d\x0f\xa1\x8e\x87\x50\xd7\x43\x68\xcd\x43\x68\xdd\x43\xe8\x99\x87\xfc\x86\x87\x7c\xdf\x43\x7e\xd3\x43\x7e\xcb\x43\x7e\xdb\x43\x7e\x47\xb2\xb0\x5c\xa3\x75\xc9\x37\x02\x8f\x94\x27\x30\xfc\x0e\x85\x4b\xea\x41\x5b\xcf\x18\xfc\x26\x83\xe1\x43\x1b\x05\x9c\x16\x6b\xab\xcd\x70\x79\xc6\x60\xac\x4b\x78\xae\x31\x58\x5d\x86\x8b\x4f\x61\xfa\x72\xac\x65\x9f\xd5\xe5\xb8\x34\x28\x0c\xc0\x83\xe3\xd9\xa2\xb0\x08\x7c\x5f\xee\xb7\x0c\xa7\xcd\xea\x76\x18\xee\x6b\x0c\x46\x53\xc2\xd3\x67\xb0\xd6\x19\x2e\xac\xdf\x7e\xeb\xac\xfe\x5c\x9e\x8b\x74\xce\x5c\x70\x3c\xd6\xa4\xb1\x6a\x32\x98\x1c\xe7\xae\x3a\x1e\xd0\xb7\x96\xd6\xf7\x2e\xab\xd3\x2a\x60\x41\xdd\x4e\x81\x33\x87\xc1\xc7\x03\xda\xf2\xb5\xbe\x43\xa1\x8e\xd4\xc1\x35\x86\x60\xb7\x18\x5c\x01\xa4\x29\x0d\x34\x45\xb6\x00\xb4\xce\xea\x48\x83\x05\x13\xd3\x29\x06\x57\xc0\x68\x49\x03\x4d\x91\x95\x10\x6a\xb2\x91\x6d\x48\xc0\xf8\x68\xac\x89\xd9\x13\x14\x8a\xd8\xe8\x50\x64\xd5\xd9\xc8\xe6\xad\x0c\x8a\x22\x1b\x2b\x40\x4f\x6e\x89\xd3\x56\x4b\x1a\xcf\x6e\xf1\x4d\xa1\xe9\x35\x0f\x3e\xc1\x50\x71\x7a\x7d\x56\xd0\x1e\xa7\x29\xbf\x23\x0d\xeb\x1a\x2b\xab\xcc\x87\x5f\x10\x81\x98\x8b\x67\xac\x20\x27\x9e\x75\xa9\x0c\x47\x7c\x0d\x7e\xcb\x67\x29\xb1\x96\xdb\x45\x55\xde\xbe\x58\xf3\xf2\x9a\x58\x57\x40\x16\xa0\xf8\xfa\xec\x14\xb4\x2f\xfa\xd9\x2c\x50\x10\xe3\xc4\x48\x86\xc2\x45\xda\x94\xcc\x5b\x20\x0c\x31\x65\xf0\x3b\x05\x02\xd0\xcf\xb5\x62\x21\x42\x83\x6d\x86\x48\x57\x43\xba\xa5\x0e\xbe\xe8\xb4\x5f\xc0\x11\x63\x27\x16\x34\x7c\x57\xe0\x08\x06\xe2\x4b\x83\xd4\x2d\xda\x15\x0b\x8f\x2d\x60\xbf\x65\x99\x0f\xd1\x01\x0d\x71\x0e\x48\x2c\xb8\xa6\xf4\x6f\x47\xac\x62\x75\x80\x3a\x96\x72\x6d\x75\x66\xc4\x4c\x16\x9d\x42\xbe\x8f\xce\x94\x2c\xd9\x1f\x46\x64\x85\x58\xe6\x03\x89\x50\xcd\x0d\x0f\x35\xae\x3a\x5b\xeb\xcd\xb5\x67\xcf\x9e\x91\xdf\xdd\x9d\xed\x67\x3b\x2f\xb7\x7c\xf2\x7b\x7d\xd7\x7f\xf9\xb2\xb7\xdd\x23\xbf\xb7\x9e\x75\x5a\xbb\xdb\xed\x1d\x75\xbe\x47\xa9\xb3\x81\x4e\x63\xab\xb9\xfe\x72\xa7\x0b\x0d\xf4\xda\xdb\xdb\x7e\xb3\x0d\x0d\x6c\xaf\x35\x5a\x3b\xbb\x2d\xf2\x7b\x6d\xab\xbb\xbd\xd6\xdd\x81\x86\x39\x42\x67\x56\x7d\xc0\xd1\xfe\xbb\x9d\x83\x6d\xbf\xdb\x80\xf0\xfb\x73\x74\x48\xa2\x6c\xa1\x45\x92\x5e\xd1\x5d\xf9\xb6\x77\x45\x54\x99\x08\x48\x38\x82\x60\x77\xd7\xda\x9d\x66\xab\x01\x23\xb8\xb3\xdb\xdb\xde\x7a\xb9\x0e\x1d\x7c\xb6\xfe\x72\x6b\xbb\xb7\xbb\x43\x7e\xfb\x8d\x56\xb3\xd3\x5e\x83\xc1\xe9\xb5\xb6\x9b\x3b\xfe\x6e\xe3\xcc\xa9\x1a\xaf\xaa\x94\xb7\x2a\x76\x2b\x7b\x29\xf9\x25\x37\x35\xf3\xcd\xf1\x29\x16\xa0\x7b\x2d\xcc\x22\x1d\xd7\x37\x07\x1f\xa4\xd2\xfc\xf2\xe0\x83\x69\xc8\x84\xca\xee\x54\xa4\x7a\x68\x13\xd5\xcc\x02\x88\x1a\x80\x4a\x8d\x15\x86\x0f\xd2\xcb\xc5\x8c\x4a\x0d\x80\xcc\xae\x54\x03\x68\x5a\x97\x9a\xe0\x4a\x54\x63\x68\x9e\xad\xf3\x1e\x12\xf7\x0f\x84\x14\x9d\x57\x8e\xc0\x00\x3e\x8c\xc6\xee\x02\x29\x14\x48\x9d\x05\x40\xfc\xfc\xf0\xd9\x0d\x01\x64\xa2\x0f\x9f\xdd\x10\x60\x9b\xfe\x90\xb9\x21\xc0\xa6\xf1\x21\x4b\xed\x11\xad\x57\x57\xc9\x2a\xfb\x44\x0e\xcd\x17\x41\x1a\x11\xe9\xd8\x72\x49\x1b\x8c\x3d\xd4\x1f\x7b\x68\x30\xf6\x50\x38\xf6\x10\x1e\x5b\x1a\x0a\x52\x0f\xf5\x53\x0f\x0d\x52\x0f\x85\xa9\x87\x70\xaa\x37\x16\x10\x54\x02\x82\xf0\x9e\xe9\x32\xd2\x4f\x21\xe8\x38\x7c\xf4\xf5\x8f\x03\xf2\x71\x40\x3f\x36\xf5\x8f\x21\xf9\x18\xd2\x8f\x2d\xfd\x23\x1c\x18\x30\xfd\xd8\xd6\x3f\x8a\x34\xd5\x81\x9a\x97\x9a\x77\x49\xbf\x15\xb4\x9a\x12\xc2\xbf\x4b\x9b\xc8\xb7\xae\xed\x9c\x2c\x9f\x60\x8c\x96\x8a\x35\xb5\xf4\x79\x7c\x1a\x9d\x9d\xd5\xbf\xd8\x9c\x18\xc0\x6b\xe7\x85\xdf\xad\xff\xf1\xf8\x91\xca\x1a\x49\x1b\x68\xe8\xd7\xfa\x63\x6f\x30\xf6\xc2\x71\x1d\x2d\xa1\xd1\xd8\xee\x7b\x73\x83\x84\x42\x2e\x7a\xd1\x6a\x52\x55\x9b\x05\x5a\x53\x87\x66\x8c\xbc\x01\xad\xbd\xee\x84\xd6\xd2\xa1\x19\x53\x65\x40\xeb\xb6\x9d\xd0\xda\x3a\x34\x63\x6e\x25\x68\x7f\xac\xae\x32\x88\xeb\x0d\x27\xc4\x8e\x0e\xd1\x20\x08\x64\x0f\x93\x4e\x26\x31\xb7\x4e\x17\xf9\x82\xd2\x24\x1f\xd7\x72\x2f\x23\xd3\x6a\x73\xda\x00\x1a\xc8\x97\xf0\xd8\x3e\xe5\xb0\x22\x8c\x25\x45\xfe\x80\x6e\x43\xdb\x17\x20\x77\x68\x97\xac\x49\xdf\xea\x06\x04\xeb\xa5\x6f\xab\x0d\xcb\xcc\xb8\x49\x14\xa8\x06\x29\x5a\x92\xa8\x35\xbd\x3d\xb5\x76\x6a\xfd\xd4\x1b\xa4\x5e\x98\xc2\x88\xa7\x77\xa3\xd6\xb6\x0e\xed\xae\xd4\xaa\x42\xbb\x13\xb5\x36\x75\x68\x77\xa6\x56\x5f\x87\x78\xcf\xd4\x9a\xc2\xad\x75\x09\xb9\xa6\x0e\x72\x05\x8e\x9a\xda\xc8\x15\x18\xb1\xed\x0b\xb0\x68\x4a\xae\xa9\x93\x5c\x61\x03\xb0\xd5\x86\xad\xc1\xb4\xd0\xd0\x59\xf9\xbe\x9c\x8e\x01\x64\x48\xb0\xfa\xd5\x24\x4c\xf2\x9f\x4d\x54\xdb\xa3\xa6\xb9\x03\xc2\x99\x43\x4b\x4f\xf7\x98\x09\xef\x1e\x35\xbf\x0d\x49\x39\xdb\x88\xec\x31\x33\xdd\x3d\x6a\x48\x8b\x49\xb9\xc0\x5a\xae\xc5\xca\x81\xb1\x2c\xec\x08\x7d\x6b\xb9\x36\x2b\x07\x86\xc9\x7d\x52\x6e\x60\x2d\x07\x06\xcc\xca\xb0\xe8\x62\xed\x2e\x4b\xad\x71\x07\xf3\xac\x30\xc8\x03\x21\x0c\x91\x07\xcb\xc6\x3f\x3f\x0d\x23\x2f\x19\xbf\x8c\xf2\xec\x24\xc9\x81\xe3\x51\x98\xf1\x76\x90\x07\xd4\x6a\xeb\x29\x5a\xb7\x40\x87\x3a\x6f\xf0\x30\x37\x92\x36\x42\x79\xa3\x33\x5b\x61\x68\x66\x21\x46\x2c\xdf\x22\x35\x66\x2a\x40\x12\x69\xb2\x73\x86\xbe\x6c\xd2\xc4\xc2\x85\x8d\x84\x28\xf1\x0f\xd4\x6a\xea\xd4\x5a\x40\xaa\xd5\x6a\x45\xd1\x25\x44\xf8\x03\x01\xf9\xac\x4e\x40\xb5\xc9\xba\xf5\xdb\x0e\x01\x9a\x57\xa5\xc3\x51\x08\xcf\xd2\xcb\xea\xc2\xb3\x01\x8c\x09\xce\x1a\xb0\x79\x82\xb3\xad\xa3\x72\x9e\x8e\x22\x1f\x26\xcf\xb1\x03\xc6\x31\x96\xb4\x1d\xab\xab\x70\x12\x44\x90\xdd\x85\x3a\x64\x59\x0d\xa7\xa6\xf4\xe4\x65\x66\x73\x29\x27\x4b\x58\xdd\xb2\x8c\x6e\x21\x9c\x3d\xb4\x89\x64\xf1\xfd\x6e\xe7\xb7\x4e\xa5\xe3\x9b\xfd\x44\xb6\x07\x47\xb1\x3d\x8b\x33\x09\x2a\x3b\x83\xed\x09\x77\xbd\x3d\xe5\x78\xb5\xb7\xf0\xb9\x8a\x52\xc8\x9e\x72\xa6\xda\x73\x1e\xa6\xe6\x9b\xc2\x1d\xd1\x9b\x70\x3a\xb9\x2c\x83\x45\x08\x83\xad\x16\x65\x37\xe6\xda\x04\x29\x6c\x6a\x30\x4e\xe2\x72\x06\x05\xa6\x04\xa4\x54\xa1\x5d\x80\x47\xb7\x19\x04\xfd\xfc\xc1\x20\x12\x5a\xcf\xa4\x35\x86\x26\x7c\x55\xec\xa2\xe0\xe7\x0d\xbd\xfd\x47\xb2\x45\xdc\xd0\xaf\x5d\x79\xe8\xda\x43\x9f\x6d\x69\x3e\x6a\xb5\x2b\xf0\xec\xbc\x86\xff\x7e\x2e\xb2\xb5\xdf\x18\x70\x9a\xe5\x70\x6a\x57\xf5\x9f\x6a\xd7\x75\xea\x4e\xfe\x6f\xf2\xf0\xb9\x5e\xaf\x3f\x77\x41\x6b\xcd\x85\x46\x00\xfd\x9b\x40\x2c\x50\x73\xc0\x6a\xcf\x87\xf5\x13\x40\x00\xdc\xae\xeb\x3f\xd5\xfe\x0d\xc8\xb9\x21\x76\xaa\x8c\x19\x19\xb4\x2f\x05\x28\x07\x2c\x10\x25\xae\xbc\xd8\x0a\xe9\xea\xc5\x8b\x18\xb0\xba\xfa\xf9\xe7\x9f\x6b\xad\xe6\x72\x2c\x23\x45\x7f\x94\x5a\xc3\x70\x63\x18\x9a\x07\xae\x9a\x31\x8c\x33\xdb\x0f\xb3\x6f\x01\x9b\x27\xfe\x3b\x4f\x28\x67\x32\xc1\x38\xf2\xf3\x38\x4a\xdf\x36\x31\x0f\x5b\x19\x85\x25\x0b\x57\xe0\xd5\x9e\x30\x14\xff\x7f\xf6\xde\x7f\xbb\x6d\x1c\x49\x18\xfd\x7b\xfa\x29\x2a\x7b\x66\x62\x29\xa6\x65\x82\xa4\x24\xca\x89\x92\x2f\x9d\x76\xa6\xb3\xe3\x38\xf9\x12\xf7\x76\xef\xe7\x4e\x7a\xf9\x03\xb2\xd8\x91\x48\x35\x49\xdb\xf2\x4c\x32\xe7\xbe\xc6\x7d\x8c\xfb\x0a\xf7\x51\xee\x93\xdc\x83\x02\x48\x82\x24\x40\xca\x4e\x32\xbb\xb3\xdb\xea\xd3\x8e\x44\x02\x85\x42\xfd\x42\xa1\x00\x14\xf6\x14\xbb\x70\xf4\xb5\xae\x0b\x6c\x55\xdb\x6d\xda\xc1\xc1\xc6\x56\x9b\xa2\xc0\x6e\x5b\x95\x0a\xe6\x7c\xff\xf2\xe9\xb3\x7f\x00\x6b\x3a\xaa\x7f\xa0\x37\x58\x35\xa3\x41\x4a\x73\xcd\xdd\x49\x1a\x86\xe2\x95\x83\x5f\x90\xa1\xfc\x22\xc3\x92\x35\xdf\xaf\xbd\xa0\x62\x8f\xbc\xc5\x4a\xc1\xa1\x5a\xe1\x36\x97\xd6\x5e\xa0\xe0\xd4\x1f\x3e\xf1\x75\x60\xcd\xd6\xa8\xa2\xa4\xfa\x76\xa2\x4f\xef\x8c\xe9\xf4\xf7\x2d\x4e\xff\x1d\x8e\xac\x7c\xed\xa5\xfb\x46\x62\x35\xa9\x61\x6d\xca\xb4\xb7\xdf\x3f\x3d\x20\x3b\xac\x64\xb4\xef\xaa\xfe\x92\xeb\x17\x73\x3c\x7d\x5a\x2d\x61\x44\x71\x94\x0f\x14\x09\xa8\xea\x4b\x1a\x74\x11\x84\x9e\xef\xce\x14\xb9\x99\xcc\xed\xcc\xf5\xbd\x30\x58\xd0\xda\x1a\x87\xaa\x60\x60\x87\x16\x25\x0b\xb3\xfe\xee\xf3\x97\x40\x74\x1e\xba\xda\xf9\x6e\x47\xd0\x5b\x00\x76\x89\x3d\xab\xc3\xc5\xec\x95\xaf\x0e\x16\xa3\xc3\xa8\x0e\x15\xe3\x74\x55\x1d\x28\x66\xaf\x68\x19\x26\x6e\x61\xaa\x8d\x13\x6b\x63\xc2\x9a\xd9\x02\xc6\x7d\x80\x9f\x30\xd5\xe4\x82\xf9\x91\x3b\xfe\xf5\x14\x18\xf5\xb3\xa7\xc5\xa7\x08\x28\xa9\x01\x15\xe7\x1c\x7e\x3c\x8f\xe0\x00\xec\x77\xf0\x5e\x7c\x75\xab\xaf\xc4\x91\xbe\x4f\x74\x77\x47\x0a\x94\x06\x31\x1e\x8e\xe5\x73\x4b\x9c\x3e\xd8\x44\x9d\xa6\x46\x3d\x13\xc2\xd0\xd2\xc0\x63\x40\xc6\x08\xc4\xe3\x33\x99\x29\x1e\x90\xa5\xb0\x8f\x0d\xe9\x02\x8d\xf0\x08\x2c\x53\x4b\x35\x0c\x9b\x0d\x06\x3e\xdc\x87\x80\xfb\xb9\xec\x6b\x88\x90\xcd\xed\xd8\xe3\xab\xb0\x3d\x21\x3e\x78\x04\x4e\x5f\x13\x3e\xbc\x87\x00\xde\x43\xc8\x21\x4f\x68\x38\xa3\xbe\xa7\x4a\x3a\xd4\x80\x3c\xb9\x05\xf2\x1c\x77\xf6\x2d\x10\xbd\x38\x00\x73\x3b\x35\xa9\xe3\xd8\x96\xa3\x6f\xeb\xf0\x41\xd9\x9c\x6b\x0e\xe1\xc1\xe1\xce\x7d\x61\xf0\xed\xf1\x2c\xb4\xa9\xd5\x8c\xf2\x80\x86\xa5\x4c\x5f\x42\x55\xb8\x0f\xe6\x10\xa8\x42\x7c\x80\x4d\x3e\x7a\x04\xb6\x29\x7a\x89\xec\x57\xde\x2d\x0a\x73\x50\xe1\xe1\xed\x76\x5a\x6b\xa7\x60\xa0\x08\xa2\x15\xc1\x36\xaf\x79\xc2\x1b\x6a\x81\x40\x0c\x18\xb6\x32\x9f\x40\x2d\x08\x88\xc1\xc2\x40\x5d\xc6\x96\x03\x85\xa1\xba\x8c\x23\x07\x09\x69\xb3\xcc\xef\x01\xbe\xff\xaa\x01\x3e\xe6\x0b\x8f\x16\xab\x24\x49\xe5\x98\xdb\x21\x0e\xd4\xe2\xf3\x59\x8d\x60\x2e\x84\x0a\x72\x4f\x9c\xae\x15\xa6\xfb\x4a\x11\xba\x5b\xc6\x81\x94\xe1\xba\x7f\xc6\x68\xd0\xef\x21\x84\x56\x30\x80\xb9\xcf\xb7\x8a\x1e\x60\x85\xae\xc0\x41\xdd\x21\xaf\xc7\x0c\xd8\xbb\xdf\xc3\x05\x5f\x34\x5c\x80\xfc\xd8\x21\x52\xa0\x66\x4b\x15\x24\x10\xac\xd1\x1f\x9b\x62\x05\xf4\x61\x01\xf7\x9f\x3a\xc1\x46\xb6\xf4\xac\xf1\xe4\x6b\xe7\xc6\x10\xad\xfc\xcf\x09\x1f\xb4\xc2\x03\xf2\x1c\xde\x1a\x4f\x6a\xb3\x78\xe9\x14\x76\x33\x2a\x60\x59\xce\x6e\x71\x01\x56\xb0\x06\x13\x7f\x73\xe0\xff\xd0\xd8\x40\x40\xcc\xf1\x8c\x86\x2e\x9b\xf2\xdb\x93\x69\x10\x8e\xcd\x29\x7e\x37\xa7\x66\x18\x12\xfc\xbe\x98\x9a\x74\x3c\xb3\xd5\x31\x83\xc5\x22\x30\x4d\xdf\xc6\xe0\xc2\xc4\x1d\xbb\x64\x4c\xf8\x77\x67\x31\x73\x17\x1e\x02\xf0\xe9\xc2\x73\x16\x9e\x73\x8b\x70\xc1\x4e\x9e\xa7\x64\xf6\x05\xe9\xa4\x9a\x1d\xa7\x68\xd1\xa2\x96\xee\xcc\xc1\xbc\xed\xbc\x68\x16\x96\x7e\x1f\xa2\x7b\x46\x5c\xcb\x72\x6e\x3b\x48\xb3\x2a\x3d\xc3\x74\x4d\x3b\x5a\x03\xb5\x65\xa9\x0f\xb1\xff\x3e\x54\x7f\xc6\x50\xcd\xb8\xb2\xdb\x60\xad\x64\x4e\x6d\xb8\xe6\x0c\xea\x1c\xb0\x2d\xab\x79\xd4\x59\x3a\xd7\x2c\x86\xa3\xa3\xe9\x8c\x0d\xe0\xb3\xdf\xe3\xfa\xff\x39\x03\xf3\x3f\xdf\xb1\xbc\x17\xfc\x12\x87\xe8\xaf\xe5\xa9\x5c\x48\x93\xcb\x38\x84\xa0\x7e\x5e\x4f\xea\xc1\xf7\xcd\xab\x53\xfe\x52\x5f\x06\x28\x02\xb5\xb4\x82\xc1\xdf\xa8\x3c\x18\x90\x97\x94\xa3\xec\x75\x1a\xad\xe9\x20\x56\x0e\x63\xd9\x6f\x69\x7e\x5a\xcc\xf3\xd9\x8f\x41\xdc\x9c\x67\x96\x81\x60\xce\x4e\x98\x83\xf5\xb0\xf8\xfe\x68\xce\x21\x14\x0f\x3a\x62\xc3\xf7\x06\x31\xfc\x49\x14\x1b\x6a\xe3\x85\x42\x47\x17\xde\x2a\xa3\xfd\xbb\x02\x9b\xf1\xb1\x62\x3e\x9e\x5e\xd6\x67\xb8\x0a\xb2\x5c\xd0\xfc\x79\xea\xe1\x77\x6f\xf5\x6d\x94\x67\x0a\x02\x95\x4b\xf8\x31\x1c\xc0\x20\xc6\xcc\x9e\x43\x78\x50\x0b\x7e\x34\x23\x59\x52\x5b\x45\x94\x5a\xce\xcc\x8e\xcf\x90\x21\x8d\xfc\x3d\xd7\xcb\x68\x45\x61\x20\xde\x3d\x02\xb1\x25\xb3\x49\xc5\x8a\x9b\x5a\x42\x97\x20\x5c\x2d\x95\xbf\x3f\xe7\x85\x30\xed\x68\x8b\x10\x28\x0b\x9b\xe4\x7a\x10\x1b\x40\xe0\x10\xac\xe1\x0e\x19\xdb\x01\x6f\x42\xb9\x0d\x58\x7b\xa8\x4c\x9e\xcd\x41\xec\xef\xf7\x84\x42\xe3\x5a\x89\xc2\x43\x1a\x54\x30\xef\xbe\xc6\xc6\x1c\xef\xdd\xbc\xe9\xb6\x87\xfe\xd5\x57\xda\xbe\x1f\x65\xab\x28\xa0\x03\x73\xf8\xfb\xaa\xd7\xce\xab\x5e\xad\x57\x0b\x7c\x35\x56\xbd\xba\xc0\x57\xad\x05\x23\xf4\x59\xf0\xd5\xf4\xb3\x97\xd1\x26\x1d\xb9\xee\xff\xd1\xcb\x68\x17\xde\x7a\xed\x99\xdb\x72\x31\x8d\xb4\x88\xd2\x2e\x8d\x1b\x8d\x07\x45\xcd\x47\x8f\xc0\xe2\x8b\x5e\xc5\x93\xc7\x8f\x1f\xc3\x74\x38\x04\x78\xaf\x86\x54\xff\xd4\x20\x11\xa7\x05\x89\xb8\xc3\xe1\x6e\x90\xea\xf5\x6c\xa5\x79\xa9\xf5\x84\x54\xfd\x56\x6e\x92\xaf\x17\x96\xba\x4d\x38\xb2\x52\xb7\xc9\xb6\xc8\x37\xbd\x23\xb2\x75\x48\x76\x1b\xd2\xec\x96\xdd\x2e\xea\xa9\xef\x24\x80\x4a\x70\x04\x13\xf7\x45\xcf\x31\xc9\xaf\xe8\xe1\x7e\xe7\x82\xa9\x6e\xf5\x33\xc0\x53\x8d\x03\x0a\xf7\x61\x81\x9b\xdd\xfe\xce\xbe\x5e\xe8\xae\x70\x59\x7b\x98\x61\xce\x83\xfb\xe0\x63\x71\x8f\xaf\x0e\xbe\x07\xb1\x4e\xa8\xc2\x1f\x9d\x95\xe8\x82\x21\x5e\x2e\xb5\x8a\xc5\x36\xb1\xd6\xca\xb7\xfe\xf1\x37\x64\x26\xbd\x21\x76\xed\x55\xad\x92\x7a\x6c\x2b\x1b\xc3\x7b\x6a\x06\x14\x65\x9c\x67\x4e\xa6\x58\x6f\x22\x20\xf2\x37\x44\x7a\x43\x88\xfc\x6a\xca\x77\xb6\xf2\x57\xd6\x58\x3d\xe2\xe1\x02\x32\x6b\x69\x09\xfb\x45\xb3\xfb\x8c\xa8\xfb\xfc\xa2\x37\xed\xe2\x31\x56\xb4\x60\x5e\x10\x66\x9f\x91\x56\xd5\x02\x33\x5c\x17\x0a\x00\xcc\xd6\x35\xf3\xb4\xb3\x0f\x33\x8f\x2a\xf7\x0b\x73\x67\xe2\x6d\x09\x44\xb5\xcc\x07\x3d\x4b\xa4\xcd\x6c\xeb\xd0\xb3\x1c\x3a\xc8\x19\x21\x72\x4b\xd5\xd6\xff\x94\xa5\x51\x5e\x66\x2c\xca\x60\xca\xf0\x85\xba\xcc\x44\x94\xc1\x94\xe0\x17\xea\x32\x53\x51\x06\x75\x7e\xf9\xfb\x32\xec\xef\xcb\xb0\xbf\x2f\xc3\xb6\xbd\xcd\xdf\x97\x61\xff\x4b\xc6\x78\xc7\x93\x5b\xc7\x78\xc7\x93\xde\x18\xaf\x3c\x67\x6b\xc7\x78\xc7\x93\xdf\x63\xbc\x5f\x3c\xc6\x3b\x9e\xec\x1a\xe3\x55\x31\xa7\x1e\xe3\x45\x06\x75\x6f\xda\x2e\xd7\xce\xd4\x4b\xb3\xae\xf9\x4f\xbd\x34\xbb\x9d\x38\xff\x90\x8b\x0b\xca\x76\x7e\x8f\x02\xd7\xa3\xc0\xdb\x09\xae\xa9\x8e\xb6\x13\x47\x7a\xfe\xd3\xc4\x11\x59\xba\xb1\xc4\x48\xca\x13\x7d\xab\x9c\x6e\x52\xff\xde\x7c\xff\xea\x97\x57\xcf\x9f\xbf\x3d\x3e\x7b\xdb\x8c\x16\xbf\x7e\xf1\xcb\x8b\xd3\xef\x8e\x7f\x3a\x6e\xdf\xca\xfd\xe6\xd5\x0f\xa7\xdf\xfd\xf2\xec\xd5\xe9\xdb\xb3\xa7\xa7\x65\x4d\xa9\x39\x1e\x56\x7e\xb6\x5b\x58\x59\xaa\x91\x2e\x93\x22\x69\x4b\x23\x26\x5d\x34\xcd\x66\xd7\xc4\x80\x1b\x5d\xaa\xf2\x9c\x87\x44\x72\x78\x04\x96\xf3\x10\x72\x45\x48\x44\xea\xf3\xf9\x16\xf6\x61\x0c\x0f\xe0\x86\x9f\x1e\xcc\x8b\x43\x9a\xf8\xcd\x1a\x62\xa4\x12\xfe\x04\x93\x96\x2f\x82\x6e\x20\xbd\xfe\x09\xe6\x70\x03\x7f\x82\xb1\xca\x4b\xa4\xd7\xff\xce\xa0\x5a\xf0\x00\x58\x3b\x36\x6b\x67\xa8\x28\xbc\xe5\x61\xb9\x9f\x1a\x8f\x6f\xf8\xe3\x7f\xd7\x84\x82\x25\xb2\x6d\x22\x88\xf0\x3a\x01\x05\xd1\x4a\xca\x6c\x39\x65\xb6\xfc\x80\xe6\x56\x41\x98\xb2\x28\xa7\x2e\xdc\xf0\xa2\x37\x9a\xb0\x52\x25\x20\x75\x32\xde\xe0\x05\x3f\xed\x5e\x33\xba\x36\xbb\xfe\xa9\xb7\x6f\x8d\x55\x8e\xba\x34\x9c\x3c\x7f\xfb\x86\xe1\xba\x35\x89\x4a\x18\xe4\x7b\x27\x34\xf1\x31\x56\x0c\x9b\x28\x84\xf5\x65\x76\xdd\x90\x2d\x65\xb1\x93\xa2\x98\x86\x84\xe2\xe6\x89\x5f\xe1\x11\x4c\x1f\xc2\xaf\x1d\x91\x39\xec\x03\x1e\x4d\x55\x67\x45\x29\x9a\xf7\xa3\xfc\x75\x92\x61\x1e\x57\x26\x55\x78\x59\xee\xaf\x43\x38\x00\xd5\x6e\xea\x02\xb8\x5c\xe9\x11\x88\x7c\x11\xaa\xc2\xec\xd3\xea\xe0\xfb\x39\x60\x33\x12\x14\x4d\x5b\xf5\x1d\xd5\x72\xab\x8f\xe7\xd8\xac\x7e\x73\x75\xab\xe5\x97\x52\xcb\x35\x50\x07\x8a\x79\x4f\x89\xc0\x6e\xa1\x25\x49\xb0\x62\xba\xcd\x51\x80\x7a\xd8\xe2\xea\x77\xa2\x1f\x1e\xc2\xeb\x34\x5a\x47\x79\x74\x45\x61\x93\xac\x6e\xe2\x64\x1d\x79\x2b\x48\xae\x68\x0a\x7f\x7e\x3e\xb0\x86\x47\xb0\x7d\xef\xc2\x3e\x6c\xdf\x4f\xf0\xef\x18\xff\x3a\xcc\xcc\xa8\x41\x0a\x89\xe6\xcd\xf3\xf3\x03\xef\xc1\xdc\x4e\x3b\xb6\xcc\x6b\x90\x13\x10\xe6\x4a\xf9\xe8\x59\xf4\x6a\x18\x78\x1e\xe3\x13\xc3\x4f\x91\x60\xac\xc9\x33\xa3\x25\x3f\xc3\xdb\xae\xa6\x64\xa8\x3f\x39\x5d\x6f\x92\xd4\x4b\x6f\x6a\x37\xd1\x31\x15\x38\x93\x07\x22\xed\x2a\xa5\xf2\xd6\x19\xb5\xf6\x9f\x29\x7b\xd6\x87\x77\x63\x6d\xc7\xde\x6d\x65\xc7\xae\xad\xeb\xd8\x5d\xab\x3a\x5f\xfe\x2a\x81\xe4\x32\xdf\x5c\xe6\x27\x38\xb5\xae\x95\x05\x74\xd2\x43\x9a\x45\x29\x0d\xa5\x8b\x06\xfc\x28\xcf\x8a\x84\xd0\xbc\x72\x6d\xb6\x50\x54\x7e\x15\xaf\x0a\x36\x49\x39\xb8\xbd\x94\x1e\x81\x65\x39\x06\x58\xe3\x89\x01\xb6\xeb\x18\x30\x26\x56\xb3\xb2\xb8\xb3\xe0\x88\xbd\x93\x5f\x35\x2f\x2d\x28\x26\xcd\xda\x7b\x0b\xe4\xde\x35\xa0\xdd\xe1\xfe\x02\x8c\xd4\xe2\x4d\x88\xc5\xdc\xbb\xf8\x75\xfe\x4e\x63\xed\x77\x10\x35\xf6\x41\x38\x5c\xe4\x62\x7a\x5d\x8a\x1d\x2e\xc2\xf5\xa5\x12\x40\x4c\xca\xdb\x7a\x71\x04\x98\x98\x26\x1c\x00\x1b\x68\xcb\x9b\x12\x64\x4a\x30\xef\xc5\xb6\xbe\xd6\x8a\x9e\x22\x30\xa7\x20\x9a\x32\x78\x56\x74\xe2\xc4\x8b\x31\xf6\xd3\xe8\xda\x21\x58\xaa\x18\x9a\x9f\x25\xa9\xdf\x4f\xff\x06\xf8\xcf\xc9\x24\xf8\xd2\x8a\xa0\xbe\x28\xc6\x68\xad\x0d\x9b\xbf\xb4\xf0\x0e\xfa\x66\x71\x66\xeb\xbb\x92\x59\x68\xaf\xa0\x66\xcd\x77\xe6\x13\xb4\x6a\x89\x04\xad\xbb\x64\x10\xb4\x6a\xa9\x03\xad\xbb\xe7\x0c\x14\x08\x93\x3e\x8c\x49\x1d\x65\x72\x27\x9c\x49\x1d\x69\x72\x1b\xac\x95\x7c\xe0\xc2\x55\x86\x46\xa2\x38\x4f\xb8\x34\xab\x39\xbd\xf2\x30\x98\x57\xa8\xb3\x82\x14\xac\xc4\x08\xef\x9b\x7d\x3f\x47\xba\xe8\xca\xac\x92\x6b\x10\x65\xfa\x57\x23\xde\xb0\x01\x36\xd3\xe8\x00\x77\x94\x51\x0f\xf8\x57\xee\xf4\xe2\x77\xbd\x0a\x9c\x2d\x69\xee\xb5\xdf\xdc\x62\xd6\x20\x01\x7b\x19\xb1\x29\xc8\xea\x72\x1d\x63\xe7\x14\x6a\x55\x50\xb0\x70\xb3\x0d\xa8\x3c\x69\x65\xe1\x5b\xce\x49\xe4\x36\x6a\x5c\xaa\x66\x28\x9a\x86\xd8\xa7\x70\x3d\x4b\xee\x75\x95\x3d\x91\xca\xae\x92\x6b\xad\x5f\xaa\xa5\xd6\x99\xd2\xcf\x51\xf5\xe4\x8c\x71\xe1\xec\x7c\xab\xc3\xfd\x6c\xcb\x65\x6d\x8e\x3d\xd0\x17\x42\x61\x9b\x23\xea\xbb\xed\xbe\xb9\x9b\x18\x74\x98\xd5\xaa\x47\x0e\x76\x69\xc0\xf8\xe2\xe0\xf4\xb0\x6b\xb1\xfc\x6c\x4b\xaa\xe2\x64\x97\xe2\x5c\xbe\xce\xb6\xa4\x8b\x8f\xa2\xec\x49\x59\x16\xf9\xd8\x29\xde\xd9\x65\x8a\x1a\xc5\xaf\x13\x61\xa2\xde\x2f\xe5\x67\x5b\x47\xd8\x02\x18\x0c\x04\x6e\xe5\xd1\x60\xd1\xbe\x38\x1f\xac\x9b\xde\x20\xb4\x93\x12\x1a\xb7\x1a\x1c\xda\x49\x03\xda\xcb\x7e\x68\xff\x50\xa5\xaa\x99\xc2\x0e\xf9\x84\xa6\x49\xd4\x88\x29\xdc\x6a\xb6\xf7\x66\x99\xc0\xeb\xa8\x43\xb2\x59\x93\xc5\x9d\x8f\xe4\xa1\xf4\x93\xbb\x72\xe5\xef\xcf\x16\xf9\x1a\xe5\x4a\xb0\x5d\x62\xcc\x0a\x71\x09\xea\x33\x48\x45\xe9\x93\xaa\xb4\xde\x24\xe1\x60\xb1\x4c\x5e\x71\x2f\x65\x5e\x8b\x87\xc9\x78\x69\x3b\xfb\x26\x41\x47\xaf\xc3\xc4\xb3\x09\x74\xd5\x44\x6f\xe0\x41\xd2\x95\x41\xd1\xe9\x47\x8f\x2a\x24\x51\xb4\x8b\xfe\xe1\x55\x9a\xb6\x05\x07\xd2\x7b\x9d\xa0\x43\x5d\x75\x4a\x18\x4a\xe0\x2f\x6f\x09\xbc\x1e\xf3\xa8\xba\xbb\x53\xc4\xa3\xd9\x65\x81\x95\x04\x06\xa3\x1d\x6d\xe4\x26\xce\x9d\x7b\xfe\xb2\xa7\x8d\x93\x5b\xb6\xd1\x35\xb6\xa5\x5e\x9c\x6d\x92\xac\x53\x4a\xd0\xfc\xbe\x8e\x4e\xb8\x62\x9c\x9d\x4b\x01\xc5\x4a\x0e\xb5\x63\x1e\xaf\xb8\xcb\xc0\x27\x4a\xf6\x8d\x7e\x5a\xfb\xb1\x89\xc0\xcb\x71\x08\x44\x7b\xa9\xf6\x09\xcf\x4c\xec\x83\x32\x69\x6b\x39\x39\x32\x4b\x03\xa0\x2c\x77\x66\x16\xdd\xe1\xa5\x75\x2a\x7f\x66\x16\x9d\x11\xe5\x34\xe3\xd6\xe1\x21\x3c\x5b\x76\x19\xbf\xdd\x87\xf5\x3b\x0e\x19\xfd\xa6\x11\x24\xf3\x55\xd8\xe1\x72\x5c\xe9\x11\xee\xdb\x99\xd4\xa2\xd6\x59\x29\x70\xbb\x57\xd9\x92\xb2\xd2\x40\x72\x42\x86\xbb\x0c\x80\x1c\x80\xd5\x00\x60\xb5\x00\x74\x52\x91\xf9\x1e\x69\x72\xdd\x41\xc4\x95\xa4\x0d\x67\x95\x6a\xbc\x87\xc1\xdf\x05\xfa\xfc\xc1\xfd\x02\x19\xfc\xd9\x65\x3f\x56\x92\xd6\x9c\x55\x2a\x24\x43\xc4\x07\x15\xc4\x55\x72\xfd\xf9\x01\xda\x17\x89\x6a\x46\xd2\xe2\xb7\x56\xd3\x6a\x61\x48\x36\xbe\x35\x82\x99\xf8\xbe\x77\xd2\x56\x83\xa2\x53\xc4\x9a\xbf\x52\xaf\xc1\x54\xb2\x63\xb1\xe3\xbf\xd6\xb6\x28\x45\x90\xe6\x8b\xef\x8a\x6a\x95\x2f\x23\x3e\xac\x5e\x3b\x0c\xf4\x00\x83\x57\xed\x38\xd0\x5d\xf7\x52\x91\xbb\x6c\xa5\xc2\x4d\x52\x01\x8d\x56\xf5\xfd\x4e\x64\x08\x87\x75\xfc\x87\xf0\xa0\xf9\x00\x1b\xc7\x05\x9a\x72\x37\xd7\x7f\x91\x4d\x50\x9f\x1d\xc3\x93\xc3\x8c\x05\xf2\xca\x18\x24\x1c\x2a\x59\x2f\x17\x29\xa2\x80\x6d\x98\x87\xca\xcd\x74\x6f\x7f\xbb\xa4\xf4\xaf\xb4\x0d\x74\xe9\x65\xcb\x42\xb8\x77\xba\x8b\xbe\x85\xc5\xe7\x04\x0b\xfb\x63\x42\xbb\xbb\xf4\x3a\x77\xfe\xf6\x31\xc4\xaa\x3d\x7d\x54\x4e\x72\x0d\x45\x60\x4e\x76\x38\x6f\x15\x9b\x93\x40\x89\xf0\x9c\x0c\xea\xae\x71\xc5\x8a\x14\xdd\x9d\x38\x69\x75\xe2\xe4\xae\x9d\x38\x69\x75\xe2\xe4\x76\x9d\x50\xb3\x8a\x8b\xae\x50\xb2\x3c\x81\x94\xe6\x69\x44\xaf\xa8\x62\x03\x22\x88\xc3\xdd\xdc\x1e\x6c\x2e\xb3\x65\x81\x86\x8a\x44\x8a\x92\x2f\xdb\x25\x3f\x3f\x3d\xb1\xe2\xf4\x50\xd9\xb4\xd1\x56\x61\xed\x79\xa2\x2f\xb4\x6b\x52\x6f\xbf\xc4\x16\x4a\x85\x39\x2b\x0f\x3b\xed\x60\x21\x76\x5c\xcc\x29\xbe\x56\xfb\x33\x3b\xc9\xfe\xfb\x76\xcd\x3b\x6e\xd7\xb4\x6f\xbb\x59\xd3\xee\xdb\xaa\x69\x77\x6c\xd4\xb4\x7f\xdf\xa6\xf9\xa5\xb7\x69\xda\x3b\x6e\xd2\x54\xb0\xa5\xb6\x45\xd3\xde\x65\x83\xa6\xad\x3f\x86\x5f\x6e\x3c\x3c\x72\x9d\x4f\xef\x0c\x97\xfc\x37\xd9\xae\xd9\x4c\xb0\x33\x26\xd6\x3f\x6c\x0f\x67\x91\x6e\x87\xb5\xf9\xcf\x95\x6e\xe7\x4e\xbb\x2d\xc5\xeb\x6a\xb7\x67\x51\xe6\x56\x09\x79\xc6\xc4\xaa\x6d\x0b\x19\x13\x4b\xbb\xcd\xc4\xdd\x31\x21\x0f\x2b\x58\xdb\x6a\xe2\x8a\xac\x16\x63\x62\x7d\xb1\x23\xc4\x72\xf7\xb5\x39\x79\x5a\x9b\x1c\xcc\x6d\xe0\xfb\xfe\x2c\x1c\x87\x86\x94\xb0\x67\x68\xa8\x4a\x4e\xac\x99\x67\xcd\x2c\x4f\x4e\xe7\x33\x54\xe4\xed\x51\x54\x9d\x91\xf1\xcc\x24\x63\x4f\xce\xfe\xa3\x6e\x84\x8c\xad\x05\x0d\x78\xce\xa0\x22\x37\xd0\x8e\x8d\x4c\xa6\xb6\x6d\x4d\x26\x3c\xad\x90\xc8\x1c\xa4\x6e\xc4\xa5\xbe\xe3\x78\xee\x54\xce\x2b\xb4\x63\x23\xa1\x6f\x06\x16\x35\x43\x39\x0d\x91\xba\x11\x67\xea\x8f\x1d\x97\x84\x72\x92\xa2\x86\x6b\xfa\xa5\xb3\x14\x31\x79\xba\x63\x96\x22\x32\xf9\x3d\x4d\xd1\x17\xf2\x89\xdc\x5b\xa7\x29\x62\x55\xfa\xfc\x22\xd9\x66\xb4\x3d\x23\xf7\xf7\x34\x45\x5f\xde\x37\x72\x77\x4d\x53\xa4\x64\x4e\xdd\x3f\x72\x7b\xd3\x14\xd9\x6e\x77\x9a\x22\x36\x8c\x1f\xb9\x96\xca\x5b\xb2\xfe\x9b\x78\x4b\xff\xad\x0f\xb7\x7c\xd9\x83\x2d\x5f\xe9\xc8\xca\xdd\x9d\x28\xfe\xaa\xec\xae\x00\xf4\x4b\xb1\x83\x57\x71\xd7\x4d\x7d\x93\xef\xc8\xdb\x6c\x56\x37\x03\xf1\xd0\x00\x2f\xbd\xb8\x5c\xd3\x38\xcf\x9a\x77\xf2\xc8\xc7\x67\x2a\x7c\x30\x95\x52\xd5\x44\xa3\x79\x73\xeb\x58\xae\x67\x2d\x66\xe8\x57\x84\x53\xcb\xf5\xa8\x65\x0d\x8d\x76\xb9\x29\xb1\xa7\x8e\x33\xc3\x34\x83\x96\x4d\x17\x93\x71\x10\xca\xae\x41\xab\x82\x3f\x0e\xcc\x85\x1f\x2c\xf0\x02\x84\xc0\x09\x6d\xdf\x5a\xa8\x00\xd3\x99\x3f\x0e\x7d\x6f\x8c\xb7\x67\x13\x77\x16\xfa\x7e\xd0\x09\xd8\x9e\x8d\x27\x81\x35\xf6\xd1\x9d\xb1\x1d\xd7\x1f\xdb\xae\x0a\xf0\x78\xb6\x20\x84\x2c\x10\x63\x7f\x62\x8e\x43\x93\xcc\x3a\x01\xcf\x2c\x7b\xe1\x5a\x1e\x5e\xb9\xed\x2d\xc8\xcc\x59\xcc\x7c\x15\x60\xcf\x27\xc1\x98\x86\x88\x71\xe8\x4d\x42\x97\x10\xb7\x13\x70\xe8\x9a\x53\xcf\xe3\x34\xf6\x6c\xd3\x36\x2d\x47\x49\x63\x62\xb9\xf6\xd8\xe7\x77\x46\x38\xe3\xa9\x39\x59\xf8\xb4\x13\xb0\xe5\xd8\xc4\x1d\xfb\x78\x77\x84\x43\xa9\xe3\x5b\x6e\xa0\x24\xc5\xd8\x0c\xa6\x61\x80\x17\x88\x87\xe3\xc5\xc2\x77\xa8\xd5\x09\x78\x6a\xf9\x74\x1c\x4e\x91\x14\x0b\x6b\xea\xbb\xb3\x89\x92\x79\xae\x19\x52\x9f\xf0\xcb\x2b\x6c\x9f\x4c\x66\x13\x9f\x74\xd3\xd8\x0f\x03\x73\xc2\x33\x54\x5a\xe3\x60\x4a\x2c\x7b\xac\x02\x1c\x90\x99\xbf\x20\x1c\x81\x60\x31\x99\x59\x93\x99\xd3\x09\x98\x3a\x33\x7f\x32\x0b\x90\x76\x33\xba\x20\x8e\x17\x2a\x69\x4c\x17\x3e\x75\xa6\x2e\x5e\x23\x6e\xbb\xce\xc2\x1a\x53\xbb\x13\xb0\xb9\x08\xc8\x2c\x0c\xb0\x82\xeb\xbb\x41\x38\xf6\x95\x18\x5b\x8e\x19\x78\x24\x08\xf0\x92\xf6\xa9\x17\xcc\x82\xc9\xb8\x9b\x79\x21\x9d\x59\xc1\x04\x15\x64\x3c\xb3\x7c\xd3\x9a\x2a\x01\x3b\xde\xd4\x71\x1d\x0f\xe7\x08\x13\xea\x4d\xa8\xe3\x76\x63\x3c\x0e\x7c\xd3\x9b\x85\x88\x89\x1f\x3a\x64\xe1\x87\x8e\x52\xa5\x27\x8b\x99\xeb\x86\x08\xd8\xb5\x09\x19\xdb\x7e\x37\xc6\x33\xd7\xa6\x63\x32\xb6\x50\xa5\xe9\x64\x12\x2e\x3c\xb5\x82\xb8\x36\x09\x26\x13\xf4\xf0\xad\xd0\x77\x6c\x8b\x98\xdd\xb6\xc2\x34\x6d\x6b\x1a\xb8\xfc\xce\xf7\x85\x6f\x11\x5b\x29\x6e\xfe\x62\x3c\x9b\x2e\x02\x91\xdf\x94\x2e\x4c\x4a\xbb\xa5\x22\x98\x50\xd3\xf4\x17\x28\xf8\x76\xe8\xb9\xee\x22\x50\x4a\x45\x38\xf6\xa6\x33\xe2\x20\xe0\x99\x6d\x7a\xde\xd4\xea\x26\x85\x39\x09\xbc\x89\x3d\xe6\xd7\xbb\x98\xa6\xed\x5a\x6a\x05\x21\x8e\x35\xb3\x66\x7c\xee\x65\x7a\x26\x9d\xd0\x69\x37\x29\xac\xa9\x3f\x35\x3d\x17\x8d\x8b\x33\x09\x2d\x6b\xb1\x50\xaa\xb4\x45\x09\x23\x13\x92\x6c\x1c\x58\x93\x60\x66\x4d\x3a\x01\x3b\xa1\x15\x4c\xc2\x05\x4a\xc5\xd8\x0b\x1c\xcb\xa3\xa1\xd2\x56\xd8\xb6\x6b\x86\x04\x49\x36\x0b\x67\x63\xdf\x0e\x17\x9d\x80\x27\x63\xd3\x9b\xda\x63\x87\x2b\x88\xb7\x98\xd8\x21\x55\x8b\xdb\xc4\x33\x3d\x1f\xed\xb6\x1d\x4c\xa7\xbe\xe5\x75\x9b\x4d\x97\x04\x56\x30\xb3\xb8\x75\x9b\xd2\xd0\xa3\x74\xa2\x02\x3c\xb3\xa6\x96\x15\x70\x92\x11\xc7\xb5\xec\xb1\xed\x77\x02\xf6\x2c\x7f\x41\x5d\x8f\xdb\xd9\x60\x41\x4c\x7b\xa2\x54\x10\xcf\x25\xde\x64\xe2\x20\xc6\x7e\xe0\x58\xb6\x69\x76\x5b\xb7\xc0\x72\x7c\xd7\x9f\x9a\x68\x67\xcd\x85\x3b\x9b\xce\x88\xd2\xba\x4d\x27\xc1\x98\x78\x48\x63\x73\x32\x76\x7c\x6a\x77\x4b\x45\x48\x66\x16\x75\xc9\x0c\x01\x4f\xe8\x62\x6c\x11\xe5\x98\x17\x4e\x66\x33\x73\x62\x21\x2f\xc6\xe3\xc9\xd8\x9b\xf5\x68\xde\xc2\x31\xa9\x3d\xe6\xb4\x1b\x4f\xa7\xc4\x32\x2d\x4f\x29\xc7\xe6\xc4\xf3\x4c\xde\x33\xdb\xf2\xfd\x90\xf8\xdd\xcc\x23\x33\xcf\x09\x08\x41\xb3\xe9\xbb\xa1\x15\x9a\x81\x12\x63\x42\xed\xe9\x24\x30\xb9\x1c\x13\x87\x78\xfe\xb8\xdb\xba\x59\x53\xc7\x9d\x4e\x1d\x94\xe3\x70\xe1\x52\xea\xcf\x66\x2a\xc0\xb6\xe3\x9b\x7e\xe0\x63\xcf\x28\x99\xf9\x8e\xdb\x23\x6e\xf6\x8c\x04\x66\xe0\x23\x53\x82\x71\x30\x1b\x7b\x13\x5b\x69\x8f\x69\xe8\x7a\x9e\x83\x66\x93\xda\x0e\x71\xbd\xa0\x5b\xdc\xc6\xfe\x2c\x08\x3c\x67\xc1\x47\x86\x89\x4d\xed\xa9\x12\xf0\xc4\xb5\xe8\x64\xc1\x8d\x55\x38\xf1\x2d\xdf\xf5\xba\x49\x31\x75\xdc\x85\x6b\x51\x54\x90\x71\x48\x17\xbe\xa5\xb6\x15\x53\xd7\x1b\x4f\x6c\x3e\xd2\x38\x36\x99\x5a\x8b\x49\xb7\x54\xb8\x4e\xe0\x4e\x5d\xc2\x3d\x21\xb2\x30\x3d\x7f\xaa\x34\x9b\x6e\x10\x4c\x4d\x8b\x33\x8f\x78\x13\xc7\x9e\xd1\x6e\xdf\x6d\x66\xfa\x74\xb1\x58\x78\xdc\x8b\x9c\xd8\x84\x5a\x4a\xa9\xf0\x9c\xb1\x39\x09\x28\x6a\x5e\x48\x5d\xcb\x0f\x69\xb7\xef\xe6\xd3\xc5\xcc\xb3\x17\x7c\x64\xb0\x82\xc9\x74\x46\xd4\x7e\xc5\x64\x4a\xa6\xee\x82\x0f\x61\xf6\xd4\x1a\xdb\x56\x37\xf3\x02\xcf\x9a\xda\x34\x40\x1a\x53\xcf\x9a\x4c\xc8\x4c\x49\xe3\x90\xb8\x13\xdf\xe5\x43\x93\xc5\x04\xc9\xaa\x07\x01\xdb\x8e\x88\x17\x7a\xd3\x30\x44\x05\x09\x42\x6a\x52\x9f\x28\xcd\xe6\x62\x3c\x0d\x9d\xc5\x74\x21\x06\x5d\x1a\x92\x69\xb7\x1c\x9b\x93\x85\x39\x99\x72\x7f\x61\x6a\x91\xe9\x64\xe1\x2b\x55\xda\xf4\x26\xf6\x34\x0c\x50\x41\x3c\x2b\x70\x67\xae\xd7\x3d\x82\x10\x62\x2f\x66\xae\xe9\x88\xc0\xdd\xcc\x0c\x3d\x25\xc6\xc4\x9f\x12\xd3\xb7\xb9\x3d\xb6\x49\xe0\x4c\x49\x37\x8d\x2d\x37\xf4\xa7\xd3\xc5\x98\x4b\x85\xe9\x4c\x43\x57\x69\x8f\x6d\x2b\xf0\x3c\x7f\x8a\x52\xe1\x98\xc1\xd4\x72\x66\xdd\x0a\x62\x07\x33\xea\x53\x13\x49\x41\xc6\xc1\xcc\xa7\xbe\x92\x79\x8e\x4d\xc2\xc9\x34\xc0\x9e\xcd\x02\x62\x9a\xa1\xd3\x2d\xc7\x4e\x10\x8c\x43\x87\x3b\xde\x81\x6f\x53\xc7\xf2\x95\x43\x13\x73\x57\xac\xd9\x0c\x8d\xd5\x22\x98\x8c\xa7\x94\x99\xd7\x2e\x5b\xb1\x08\xfc\xc9\xc2\xe3\x83\xa4\x17\x4e\x16\x1e\x55\x62\x3c\x09\x1c\x87\xcc\x5c\x04\xec\x78\xce\x74\xec\x92\xa9\x08\xa2\xbe\xeb\x38\xb6\x5a\xcd\x0b\x7f\xbc\xeb\x09\x55\xdd\x35\x68\x3f\xd6\x4e\xa8\xfe\x72\xb7\x13\xaa\x63\x62\xed\xb6\x74\xa0\x58\x8e\xf8\xf2\xd9\x47\xef\xba\x74\x30\xf1\xcc\x19\x2d\x02\xee\xb6\x1f\x04\x33\x53\xb3\x74\xe0\xfb\x93\xa9\x47\xf9\xf0\xeb\x3a\x81\xe7\x4d\xeb\xae\x4b\x47\x23\x76\x30\xa1\x0b\x7b\x8a\x96\x6c\x41\x67\xce\xc2\x65\x96\x4c\x55\xd2\x1b\x3b\x8b\xc5\xd8\x46\x2d\x18\x2f\x48\x68\x4f\x16\xbb\x46\xf5\xc7\xc4\xa4\x63\x8b\x1b\x1f\x2f\xa4\x13\xd7\x0a\x35\x4b\x07\x33\xdf\x1c\x4f\x5c\x2e\x90\x96\x6f\xd3\x49\x40\x16\x3b\x36\x42\x16\xae\x1d\xce\xb8\xcc\x2f\x7c\x87\xf8\xe1\x44\xd3\x93\xb1\x4f\xcd\x20\xe4\x6e\x10\xb1\xa7\xd4\x22\xd3\xd9\x6d\x96\x0e\xbe\xf4\x39\xd2\x5d\x52\xc3\x62\x39\x53\x9f\xf9\xf5\x7b\xa2\x4f\xfd\xfa\xbd\xa5\xcf\xfd\xfa\xbd\xad\x4f\xfe\xfa\xbd\xa3\xcf\xfe\xfa\xfd\x58\x9f\xfe\xf5\xfb\x89\x3e\xff\xeb\xf7\x53\x4d\x02\x58\xde\x41\x4c\x0f\xab\xdc\x07\xce\xdf\xaf\xf8\xfb\xf6\x61\x0f\x4e\x03\xac\xae\x3c\x02\xc5\xdf\xaf\xf8\x7b\x4d\x75\x0b\xab\x5b\xda\xea\xd6\x8a\xbf\xd7\x54\xb7\xb1\xba\xad\xad\x6e\xaf\xf8\x7b\x4d\x75\x07\xab\x3b\xda\xea\xce\x8a\xbf\xd7\x54\x1f\x63\xf5\xb1\xb6\xfa\x78\xc5\xdf\x6b\xaa\x4f\xb0\xfa\x44\x5b\x7d\xb2\xe2\xef\x35\xd5\xa7\x58\x7d\xaa\xad\x3e\x5d\xf1\xf7\x8a\x6d\x7d\x3b\x26\x3d\xe6\x92\xa1\x02\xee\x71\xa1\x68\x66\xdc\xc3\x2d\xb7\x5c\x20\x54\xb5\x7c\x2e\x0b\xaa\x5a\x01\x97\x03\x55\xad\x80\x8b\x80\xaa\x56\xc8\xd9\xaf\xaa\x15\x72\xce\xab\x6a\x51\xce\x75\x55\x2d\xca\x19\xae\xaa\xb5\xe0\xcc\x56\xd5\x5a\x70\x3e\xab\x6a\x5d\x70\x1e\xab\x6a\x5d\x70\xf6\xaa\x6a\x2d\x39\x6b\x55\xb5\x96\x9c\xab\x2b\x55\xde\xc1\xae\xa3\xbb\x3b\x5e\x87\xaa\xcd\xa7\x5d\xb4\xff\x63\xc4\x73\x0f\xeb\x8e\x9b\x1f\xe3\x08\x5e\x2c\x9f\xb5\x8b\xec\x90\x28\x9a\x37\xc3\x48\xf0\x63\x54\x9c\x36\x90\xb3\x46\xc3\x03\xb0\xde\x61\x49\x75\x2e\xd7\x0a\xc6\x8a\xc3\x10\xe7\x0b\x9a\x30\xf0\xd4\xfc\x9d\x32\x50\x1f\x1e\xc2\x9f\x31\x1b\xb1\xbe\xf1\x22\xa5\xf3\xad\x32\x54\x6f\x97\x65\x9e\xe3\x6d\xdf\x59\x3c\x51\x6c\x25\xd5\xe8\x3e\x8f\xc7\x4b\x2d\x6b\x59\xb0\x97\x3c\xf9\xaf\x9c\xbc\x7a\x85\x29\x8a\x8b\x74\xc0\xb5\x72\x6e\xab\x1c\x6e\x7a\x7d\x0f\xf5\x62\xd3\xae\x13\xa6\xbc\xe4\xaa\x86\xc5\xaa\x8d\xc5\x52\x85\xc5\xaa\x8d\xc5\x52\xc6\xa2\x5e\x6e\xda\x2e\xa7\xc9\x64\x2c\xb3\x54\x93\x33\xe7\x4a\xca\xbd\x7d\x9b\xe4\xdb\x15\x47\xc9\x6e\x1c\x25\x15\x47\xc9\x4e\x1c\x25\xcb\x5a\x82\xef\x65\x91\x85\x5b\x4a\xcc\xbd\x12\xb9\xba\x25\x22\x11\x41\xe1\x7a\x31\xdc\xc7\x3c\x93\x58\x5a\xc0\x9b\xf4\xb2\x94\xac\x6a\x68\xac\x14\x68\x2c\x55\x68\xac\x5a\x68\x2c\x6b\x68\xd4\x01\x4e\x5a\xf0\xac\x49\x27\x4f\x6f\x95\x3b\xbc\xcb\x94\x4c\x2b\xb6\x4f\xbb\xd8\xfe\x63\x34\xe5\x96\x4b\x39\x30\x37\x4a\xae\x44\xc9\x8e\x33\xe1\xbc\x24\x99\x48\x86\x44\x7b\x2b\x74\x51\x96\x23\x40\x94\x9e\x45\xb3\xec\xaa\x28\xdb\x8b\x43\x65\x69\x56\x8c\x68\xd1\xb4\x39\x72\xd5\x8b\x57\xa6\x6c\xc9\x8b\x2f\x31\x67\x1b\x83\xc3\x38\x69\x0e\xe1\x51\xa1\x9d\xe5\x93\x27\x40\xe0\x08\x5a\xdb\xa6\xdb\x78\xb0\xbf\x05\x07\xfb\xd1\x60\x7f\xf7\x4b\x6d\xd1\x60\x41\xee\x8a\x05\x52\x71\x47\x1c\x38\x77\xda\x18\x70\x4e\xb4\xda\x57\x03\xad\x46\xc5\x1f\x23\x1d\x7b\xab\x51\xef\xc7\x48\x85\x9c\x3e\x27\xbe\x48\x8a\xbf\x84\xfb\xb0\x58\x8a\xb4\xf8\xec\x87\xfa\x1c\x1f\xaf\xc3\x75\x9f\xae\x58\x9d\x95\xa8\xc3\x7e\x5c\xac\x3a\x92\xe9\x2f\x31\x9b\x3e\x03\xed\xf3\x76\xf0\x7b\xc0\xbf\xfb\xe2\xbb\xbe\xfa\x0a\xab\xb3\x56\x7c\xde\x24\x7e\x0f\xf8\x77\x5f\x7c\xef\x4e\xc9\xbf\xe4\x39\xf9\x85\xc1\xe1\xe3\x8a\xb7\xe2\xe9\xa5\x87\x3c\xf9\x81\xb7\x2c\x32\xf6\x8b\x97\xb5\x9c\xfd\x4b\xe9\x16\x09\xaf\x18\x75\x3a\x33\xf3\xe3\x6c\x6a\x50\x02\x12\x6d\x2e\xeb\x6d\xae\x6a\x6d\x2e\xeb\x6d\xae\xe4\x36\x97\xbb\xb4\x49\x78\x3f\xa9\x18\x1a\xf8\x79\x13\xca\x07\x05\xb7\x48\xfb\xbf\x2c\x2e\xad\x90\x5e\x3a\xd5\x4b\xd6\xa6\x5d\xbc\xe3\x69\xb8\xbb\xdb\xe4\xfd\x14\x85\x8b\x36\x97\xf5\x36\x57\xb5\x36\x97\xf5\x36\x57\x72\x9b\xcb\xaa\x4d\xa5\xd7\xd9\x7f\x0f\x81\x1a\xd7\xbf\x60\xf6\xa5\xbf\xe8\x0f\x53\xfd\x05\x95\xf7\x2f\x51\xd7\x31\xaa\xbf\xa0\x31\xf8\x4b\xa4\x33\xa1\x57\x78\x51\x02\x2b\xb3\x5c\x95\x28\xaa\x94\x92\x17\x64\x0d\x2e\xab\xbe\x70\x73\x91\x13\xd9\x5c\x2c\x77\xb1\x55\x55\xb3\xec\x2f\xa3\x48\x77\x9b\x39\x36\x15\x2c\x55\x0d\x06\x77\x6a\xf1\x2f\x4a\xd3\xd3\x6c\xf1\x2f\x91\xaa\xc5\xbf\x44\x77\x69\x51\x6d\xec\x9a\x2d\xfe\xa8\x6c\xf1\x47\x55\x8b\x6a\x69\x6b\x5e\x5e\xa1\x69\x12\x83\x17\x85\xda\x63\x41\x2d\x76\x18\x07\x29\xac\xd2\x3e\x37\x8f\x88\xa2\x25\xa3\x58\xc0\xda\x0d\xcd\x1f\x36\xa1\x97\x53\xb8\xee\x9e\xe9\xb3\x0f\xce\x37\x95\xf2\x8d\xd3\xcd\x0b\x15\xda\x38\x00\x2d\x54\x75\x70\x62\xbb\x50\xd5\xc1\x39\x34\x55\xd5\xc1\x29\x34\x55\xd5\xc1\x29\xf9\x20\x5c\xe1\xf5\x1d\x2b\xdd\xfd\x1d\x38\xa7\x1f\x84\x4b\x2c\xc5\x49\x47\x65\xca\x85\x2d\xa2\x69\x6f\x02\x61\x90\x02\x15\x8e\x18\x52\x08\x54\x38\x62\xf4\xc2\x57\xd5\xc1\xe0\x85\xaf\xaa\x83\x71\x12\x4f\x55\x07\xc3\x24\xad\xdb\x0c\xd8\x07\xc3\x2e\x03\x2e\xea\xb9\xa5\x25\x06\x06\x6e\x06\x9c\x0e\x4c\xb2\xf6\xab\x11\x87\x53\x23\x6f\x3b\x3b\x5f\xf4\xb2\x12\x29\x66\x88\x9e\xc1\xf7\x28\xff\x5e\xcb\x1b\xf8\xbe\x4c\x46\x31\xf8\x1e\xe5\xde\xe3\xc8\x7e\x6f\xca\xd8\x7a\x6d\x64\x9b\x70\xa4\x28\x23\x6f\x10\x49\xe4\xb7\x1b\x24\x55\x83\x48\x1e\x5f\x34\x58\xb3\x04\x7e\x7f\x83\x52\x5c\x92\x37\x68\xa1\x89\x6d\x37\x68\x55\x0d\x5a\xcb\x62\x5c\x1a\x60\x79\xc9\xbc\xf6\x37\x28\x45\x32\x79\x83\x36\x6b\x30\x6c\x37\x68\x57\x0d\xda\xac\xad\x50\x34\x68\xf7\xa8\x43\x13\x8e\x14\xfb\xe4\x0d\x3a\xac\x41\xda\x6e\xd0\xa9\x1a\x74\x58\x5b\x54\x34\xe8\xc8\x0d\xd2\xfe\x06\xa5\x68\x29\x6f\x70\xcc\x1a\x5c\xb4\x1b\x1c\x57\x0d\x8e\x59\x5b\x0b\xd1\xe0\x58\x6e\x70\xd1\xdf\xa0\x14\x5f\xe5\x0d\x4e\x70\x52\xd1\x6e\x70\x52\x35\x88\xde\xfb\x85\x68\x70\x52\x9b\x44\xf4\x37\x28\x45\x64\x79\x83\x53\xd6\xe0\xb2\xdd\xe0\xb4\x6a\x10\xa7\x4d\x62\x4c\x66\xe5\xbb\x9c\x80\xcf\x3e\x7b\xf1\xfb\xa5\x38\x5f\xee\x52\x1c\xc2\x9c\x7b\x71\xb3\x19\x03\x86\x79\x58\x6c\xf3\x4b\x5f\x8b\xa3\x6e\x86\xfc\x97\xbc\x18\xe7\x59\x12\x5f\xd1\x94\x67\xf9\x85\x3c\x01\xdb\x3a\xf0\xa3\x9c\x39\x28\x21\x78\xb8\x3f\xdb\xa7\x8b\x24\xa5\x62\x3b\x75\x8b\x6b\xd2\x59\x13\x69\xed\x2e\x4f\x7e\xb2\xad\x2f\x71\x11\xcf\x3f\xeb\x15\x3c\x32\x9e\x65\x7e\x90\x23\x20\xa6\xe5\x1c\xda\x22\x4f\xf1\xef\xa7\x9b\xb4\x47\x95\xc6\xc4\xba\xed\xe9\x26\x56\xa5\xe7\x74\x53\x6d\x5b\x43\xeb\x74\xd3\x98\x58\xbf\x9f\x6e\xfa\xd2\xa7\x9b\x18\x57\x76\x3b\xdd\xa4\x64\x4e\xed\x74\x13\x67\x50\xe7\xe9\x26\x7e\x8e\x76\xc7\xd3\xdf\xf6\x3f\xf5\x79\x26\x1a\x07\x07\xbe\x97\xd1\x89\xd3\x78\xb1\x0e\xc7\xcd\xa2\x57\x9b\x0f\xe1\xa2\xf1\x30\x88\x36\x4b\x9a\xfe\x43\x8e\x44\x49\xa8\xe2\x6f\x86\x21\x7f\xc1\x11\xc3\xef\x32\x3e\xff\x1d\x8e\x4e\xfd\xb8\xd3\x9d\x40\xb8\x79\xe6\x19\x76\xbd\x2c\x27\x3d\xeb\x3f\x0a\x75\x78\x08\xaf\x69\xba\xc6\x51\xf4\xd9\x32\x89\x02\x0a\xa4\x79\x6d\x0a\xab\xfe\xfa\x19\xa9\x9f\x5d\x1a\x4f\x0d\x70\x66\x06\x38\xc4\x00\xdb\x36\xc0\x1a\x1b\x40\xa6\x06\xcc\x0c\x00\x22\x6d\x35\x1a\xbb\x06\x8c\x4d\x03\x1c\xcb\x00\xdb\x31\xc0\x9a\x18\x40\x5c\x03\x88\x69\x80\x25\x97\x9b\x19\x30\x26\x06\x38\xb6\x01\xf6\xd8\x00\x6b\x6a\x00\x99\x19\x40\x18\x7c\xa9\xdc\xc4\x34\x60\x6c\x19\xe0\x38\x06\xd8\x13\x03\x26\xb6\x01\xe3\xb1\x01\xce\xd4\x00\x7b\x26\x15\xb4\x89\x01\x96\x6d\x00\x19\x1b\x30\x35\x00\x26\x96\x01\x63\xc7\x00\x07\xaf\x16\x90\x0b\x32\x4c\x2c\x03\x88\x63\xc0\x84\x15\x24\x06\x8c\x6d\x03\x9c\xb1\x01\xf6\x54\x2a\x68\xcd\x0c\xb0\x88\x01\x84\x35\x69\x00\x58\xae\x01\x96\x69\x00\x61\xe8\xf0\x62\xef\x3a\xe8\x6a\xa9\xe9\x6a\xd5\xe9\xca\xb0\x60\x74\x64\xfd\xb6\xd8\x77\x03\x60\x2c\x63\x2b\x1a\x66\xdd\x62\xd8\x22\x42\xa6\x8c\xa5\x2d\x08\xc7\xb0\x62\x05\x26\x06\xc8\xdd\x25\x13\x4e\x0f\x46\x60\xc4\xde\xae\x33\x82\x31\x94\x11\x98\xd1\xcf\x9e\x72\xc2\x8e\xc7\x0d\x7a\x39\xa6\xe0\xd6\x98\x73\xdf\x91\x5b\x60\xac\x61\xa2\x61\x33\x96\x4e\x38\xdb\xc7\x32\x0f\x19\x0b\x98\x3c\x30\xb9\x60\x3c\x64\x84\x2d\xbc\x9a\xda\x8d\x50\x97\xeb\xcb\x95\x87\xd7\xa4\x30\xa7\x32\x5b\x46\x8b\xd6\x0d\x4f\xa8\x05\x2f\xce\x7e\x79\xfb\xfd\x8b\xe7\xfc\x4e\x29\x46\x31\xcb\x00\xec\x3c\xa3\x90\xcb\x24\x52\xb0\x09\xa9\x2b\x24\x95\x08\x76\x5a\x42\x7a\x91\x20\xae\xdc\xfe\xdb\x6f\x5f\xfd\x44\x33\xf0\xe2\x50\xe4\x46\xdf\x20\x4b\xf9\x7d\x1a\x0a\x3c\x58\xf9\x5f\x5e\xd7\xf9\xd9\x70\x29\xcd\xad\x79\x84\x93\x11\xd7\x32\x4d\xa3\xf9\xae\x98\x2b\xf0\x22\x8a\x02\x56\xad\x80\x6b\x9a\x56\xab\x88\x2d\x15\x69\xbf\x75\xe4\xb7\x8a\x06\xc6\xf5\x06\x2c\x45\x03\x93\x3a\x92\xaa\x22\xd3\x46\x3f\x14\x0d\xb9\x35\x44\xda\x20\x66\xcd\x56\xda\x20\x3c\xb9\x88\xaa\x80\xdf\xa4\x56\xbb\x48\xd0\x68\xa6\x55\x20\x6c\x76\xa5\x5d\x84\x4a\x45\xda\x2d\x2c\xea\x58\xb6\xab\xbb\x5d\xb5\x89\xdb\xcb\x0f\xcb\xed\x69\xc0\x76\x7b\xa4\xca\x69\x36\xa2\x90\x0b\xb7\x5b\x6e\x26\x6e\xaf\x60\x4e\xdd\x2e\xc1\x74\xdd\x5e\x7e\xcf\xdc\x1e\x7e\x7b\x4d\x24\x14\x22\xd1\x6c\xa6\x8d\x49\xe0\xf6\x72\x3c\x74\x7b\xa4\x86\xba\xdd\xd2\xbd\x68\xb6\xa1\xe0\xbc\x96\x5d\xc2\x4a\x10\x35\x21\x2d\xe9\xad\x86\x99\x76\xad\x88\xb2\x75\xa7\x0e\x45\xd5\xc7\xb1\x5c\x44\x29\x13\x32\x9e\x8a\xf7\xd3\x3a\x1a\x1d\xba\x41\x3a\xc4\x7f\xd6\xc4\x54\x6b\x28\x48\x07\x47\xfd\x7a\x67\x14\x52\x51\xeb\x8c\xd6\x4e\x90\x0e\xf9\xa5\x8d\x22\x3a\x53\x41\xd4\xa6\xc0\xed\x25\x05\x71\x7b\x49\x61\xb9\xbd\xac\xb7\xdd\x6e\xb6\x39\x0d\x10\x3a\x5b\xd1\x45\xee\x89\xdb\x25\xc2\x53\xb7\x87\x19\xae\xdb\x43\xc9\x99\xdb\x2b\x5a\x9e\xdb\xcd\x50\xbf\x49\x6f\xc5\xe0\xd1\x6c\xa5\x5d\x24\x74\xbb\x58\x4a\xdd\x1e\x15\x5a\x34\x39\x2a\xdf\x51\x65\xf4\x79\x19\x8e\x69\xba\x8e\x49\xb4\x16\x44\x94\xd1\xba\x19\x25\x03\x75\x16\xa4\x68\xc4\x54\x35\xe2\xd4\x1b\x51\x96\x19\xd7\xe1\x28\x91\x99\xd4\xe1\x28\xcb\x4c\xab\x32\x8a\x56\x64\x63\xab\xac\x3e\x6b\x36\xa1\x00\xe2\x35\xbb\xa3\x77\x38\x44\x43\x0a\x20\x41\x8d\xb0\x8a\x02\x61\x55\x40\x6b\x40\x38\x0a\x8a\xca\x8b\x26\x57\xb4\x7e\x57\x27\x31\x89\xdb\xd3\x0b\xcb\xed\xa2\xb6\xdd\x6c\x42\x25\x1b\x6e\x83\xef\x2a\xd9\x70\xfb\x09\x3e\x71\x7b\x04\x75\xea\xf6\x0b\xaa\xeb\xf6\x30\x65\xe6\x76\x30\xc5\x73\xbb\x75\xc9\x6f\x62\xa0\x37\x24\x9d\xaa\x12\xba\x3d\x42\x4c\x9b\x34\xd5\xdb\x13\xad\x04\xc9\x13\x10\xc5\x5b\xb2\x83\xda\x13\x6b\x07\x65\x22\xf6\x0e\x8a\x4f\x9c\x1d\xe4\x99\x8c\x3b\x55\x9f\x4c\xfa\x54\x92\x4c\x7b\x8c\xa1\xec\x82\xab\x21\xcc\xfa\xcc\x25\xf1\xfa\xf4\x9e\xf8\x3b\x58\x4b\x12\xf4\x19\x32\x12\xee\x60\x2c\x09\xdd\xc1\x94\x91\x45\x93\x43\x4a\x71\xe9\x33\x15\x84\xf4\x69\x28\xb1\x76\x50\x10\x62\xf7\x68\x19\x71\x76\x31\x6c\xe3\x1d\xcc\x0e\x99\x74\x5a\x37\x32\xdd\xc1\x2c\x11\x77\x07\x5d\x24\xb3\x1d\xb4\x9e\x78\x3b\x58\x53\xe2\xf7\x59\x30\x12\x74\x99\x30\x12\xf6\x99\x05\xba\x83\x19\x25\x8b\x86\x85\xba\x8d\xab\x42\x4c\x47\x63\x8c\xd4\x28\x5b\x35\xaa\x10\xad\x8b\xc2\x61\xab\xa0\x3b\xd2\x7b\x53\xf1\x7e\xdc\x60\x4e\xbb\xc4\xa4\x46\x34\x55\x1b\xd3\x5a\x89\xfe\xe1\x58\xef\x9b\x54\xad\xe8\x3c\x93\xa2\xa7\x3a\xaf\xa4\xc2\xa2\x8d\x67\xd0\xa0\x66\xbb\x44\x58\xa3\x96\xce\x35\x41\x08\x1a\xb7\x44\xd4\x55\x53\xa0\xab\x7b\xc4\xed\x43\xdf\x72\xf5\x82\x62\xbb\x7d\x82\xe2\xb8\x7d\x8c\x1e\xbb\xdd\x9d\x9f\xb8\xdd\xa2\x34\x95\xde\xb7\xdf\xba\xae\x9e\x74\x33\xb7\x8b\x74\x9e\xdb\x27\x5e\xbe\xdb\xad\x04\x81\xdb\x2d\x3a\xa1\xdb\x27\x18\xd4\xed\x53\x82\x85\xdb\x27\xe2\x35\xb7\x42\x23\x04\xa4\x47\x5d\x89\xd5\x23\xa1\xc4\xee\x35\x19\xc4\xe9\x94\x54\x32\xee\x55\x78\x32\xe9\xb5\x1a\x64\xda\x65\x89\xdd\x5e\x4d\x24\xb3\x5e\x93\x41\xbc\x0e\x6d\x24\x7e\x8f\xb9\x20\x41\xaf\xd5\x22\xb2\x39\x50\x34\x41\x7b\x6c\x2f\x59\xf4\x9a\x24\xe1\x5a\x74\x76\x93\x74\xea\x15\xb1\xfa\x4d\x8b\xdd\x61\x39\x88\xd3\xa3\xd6\x64\xdc\x6b\x5b\xc8\xa4\x53\x81\xc9\xb4\xd7\xb6\x11\xb7\xc7\xf8\x90\x59\xaf\x06\x12\xaf\xc7\x0c\x10\xbf\xd7\x06\x92\xa0\xd7\x14\x90\xb0\xd7\x1e\x11\xda\x61\xec\xc8\xa2\x6e\x8d\x6e\xe3\x3f\xb8\x26\x6f\x52\x6d\x5b\x0a\xef\x93\x98\x8e\xc6\x95\x28\x90\x56\xbc\xb7\x2b\x08\x8e\x5a\x10\x1d\xbd\x10\x8d\xeb\x14\x51\xfb\x10\xa5\x73\xac\x6a\x7e\x6a\xd6\xdc\x3f\xfd\xf8\x59\xac\xa8\xa8\x3d\x88\x8a\xb7\x6a\xff\x81\xbf\x57\xfb\x0e\x15\xf9\x74\x2b\x28\x15\x79\x14\x30\x42\x49\x4b\x35\x9e\x43\x21\xde\x6a\xdf\xa1\x62\xb0\xa6\xff\x9d\xfc\x25\xae\xbe\x7b\x96\xdb\x87\xbc\xed\xf6\x11\xc0\x71\xbb\x59\x3c\x76\xfb\xba\x30\x71\xb5\xf2\x33\x75\xfb\x84\xcf\x75\xbb\xe8\x37\xab\x37\xae\x73\x22\x3a\xa4\xc3\x77\xbb\xb8\x17\xb8\x7d\xd2\x17\xba\xdd\xf2\x4b\xdd\x6e\xf5\x5b\xb8\x7d\x1a\x42\xcc\x1e\x15\x21\xa4\x47\x0b\x89\xd5\xab\x86\xc4\xee\x1a\x29\x3a\x25\x9c\x8c\x7b\x55\x84\x4c\xcc\x3e\x3e\x91\x69\xaf\x25\x23\x6e\xaf\xb6\x90\x59\xaf\xb9\x20\x5e\xaf\xc1\x23\x7e\x8f\xcd\x24\x41\xaf\xdd\x20\x61\x8f\x59\x22\xb4\xc3\x2e\x91\x45\xa7\xd9\xe0\xde\x43\x77\x1f\x48\xaf\x5e\x12\x4b\xaf\x98\xc4\xee\x51\x7b\xe2\xf4\x08\x3e\x19\xf7\xea\x0e\x99\xf4\x5b\xb7\x69\x87\x79\x23\x6e\xbf\xf2\xcc\x3a\xed\x07\xf1\x7a\xed\x1f\xf1\x7b\x8d\x28\x09\x3a\x8d\x08\x09\x7b\xad\x14\xa1\x3d\x66\x8a\x2c\xea\x76\xe4\x76\xce\x83\xd2\xa6\x14\xf8\xea\x56\x48\x4a\x6c\x94\x2e\xc3\x91\xb4\x5d\x43\xe9\x31\x88\x02\x18\x4f\x51\xfa\x0d\xa5\xcf\xa7\x78\x3f\x29\x00\xe8\x0a\x4c\x2b\x04\x15\x6f\x65\x9e\xeb\x5c\x86\x0a\x3f\x8d\xcf\x50\xf5\x50\xd1\x82\x5f\x21\xa8\x46\x21\xa8\x15\x50\x0d\x1c\x5a\xdd\xa3\x32\x73\x14\xa0\x17\x35\xe2\xa8\x63\x0e\x5d\xf5\x89\xdb\x43\x5c\xcb\x35\x75\x82\x63\xbb\xdd\x82\xe3\xb8\x5d\x82\x33\x76\x7b\xe4\x62\xe2\xf6\x50\x6d\xea\xf6\x88\x9e\xeb\xf6\xb0\x76\xe6\xea\xe8\xee\xb9\x3d\x3c\xf5\xdd\x6e\xa9\x0d\xdc\x1e\xa9\x09\xdd\x1e\xce\x51\xb7\x5b\x70\x17\x6e\x97\xd8\x13\xb3\x53\x6d\x09\x31\xb5\x7c\x25\x56\x9f\x4e\x13\xbb\x4f\x27\x89\xd3\xa3\xd5\x64\xdc\xa7\x14\x64\xd2\x67\x39\xc8\xb4\x47\xb7\xcb\x71\x4f\xcb\x46\x32\xeb\x53\x20\xe2\xf5\xd8\x47\xe2\xf7\x59\x10\x12\x74\x5a\x28\x12\xf6\x59\x18\x42\xf5\x83\xf3\xa2\xc7\x42\xa0\x7f\xd0\xcd\x2b\xd2\x23\x69\xc4\xea\xd1\x74\x62\xf7\x29\x33\x71\xfa\x94\x95\x8c\xfb\x4c\xd5\x44\x6f\x8a\xc8\xb4\xcf\x58\x10\xb7\x5b\x5d\x66\x7d\x0a\x4f\x3c\xad\xb1\x20\x7e\x9f\x2e\x93\xa0\xc7\x5c\x90\xb0\xd3\x58\x12\xda\x67\xca\xc8\xa2\x61\x70\x6e\xe3\x15\x08\xb4\x5d\x95\x15\x29\x60\xaa\xfc\x02\x5e\xd7\x52\xf7\xd9\xae\xde\x5b\x2a\xd8\x4e\x45\x11\x25\xfc\xb1\xdc\x1f\x95\x57\x50\xbe\x6d\xc3\x9e\xd6\x04\x5a\x3b\x2a\x2a\xbd\x01\x09\xa9\x36\x60\xaf\x68\x56\x89\xb2\x2f\x04\x54\xe5\x01\x48\xb4\x6a\xbf\x0f\x25\xb0\xed\xb7\xb4\xec\x6b\xfb\xdd\xa2\x46\x65\x55\x4f\x3b\x99\x44\xdc\x6e\x26\x59\xae\xa6\x47\xb6\xdb\xc5\x1d\xc7\xed\xea\xcf\xd8\xed\x96\xba\x89\xdb\x2d\x19\x53\x57\x4f\x0f\xd7\xed\x92\x8b\x99\xab\x97\x67\xcf\xed\x66\xbd\xef\x76\xf3\x30\x70\x35\x32\x15\xba\xdd\x2c\xa2\x6e\x97\x4c\x2d\xdc\x6e\x51\x26\x66\x8f\x1e\x11\xd2\x23\x7c\xc4\xea\xd1\x54\x62\x77\x08\x20\x71\x3a\xf5\x94\x8c\x7b\x54\x91\x4c\xcc\x1e\x1b\x34\xed\xd4\xb9\xd2\x83\xd5\xe0\x3e\xd3\x5a\x6d\x4f\xa7\xad\xc4\xef\x31\x6d\x24\xe8\xb0\x8b\x24\xec\xb1\x21\x84\xf6\xe8\x2c\x59\x74\x1a\x37\x36\xa2\x6b\x10\x27\x9d\xa2\x44\xac\x4e\xa5\x25\x76\x8f\x5e\x12\xa7\x47\x31\xc9\xb8\x43\x33\xc9\xa4\xc7\xd6\x90\x69\xaf\xb1\xea\xd1\x24\x32\xeb\xd1\x51\xe2\x75\x18\x00\xe2\x77\x5a\x2d\x12\x74\x9a\x16\x12\xea\xf4\x9f\xd0\x3e\x15\x5e\xd4\x4d\xcf\xed\x87\x6e\x85\x8c\x14\xa8\x3a\x26\x51\x0c\xdd\xc2\xd5\x50\x0c\xda\x02\xa8\xaa\x9a\x53\x3a\x39\xaa\xb7\x63\x4d\xf7\x27\x1c\xa4\x62\x8c\xae\x5c\xa6\xf6\x5b\x57\xea\x80\x6a\x98\x2e\xfb\xde\xae\xea\x49\x42\xde\x7e\xeb\x4b\x9d\x50\x4d\xd5\x25\x3f\x4e\x31\x4c\x73\xba\xb5\xa1\xd2\x8a\x6e\xaa\x49\xba\xe4\xf9\xb6\x7b\xda\x45\x06\xe2\xaa\x89\x6a\xb9\x5d\xfc\xb5\xdd\xae\x3e\x3a\x6e\x87\xe0\x8c\xdd\x2e\xe2\x4d\xdc\xae\x9e\x4c\x5d\x1d\x79\x5c\xb7\x43\xac\x66\x6e\x17\xab\x3d\xb7\x8b\x23\xbe\xdb\x21\x08\x81\xab\x13\xf3\xd0\xed\x92\x64\xea\xaa\x25\x76\xe1\x76\x30\x99\x98\x9d\x5c\x26\xa4\x53\x5d\xad\x4e\x7d\x25\x76\xa7\xae\x10\xa7\x4b\x1d\xc8\xb8\x53\x95\xc8\xa4\x53\x21\xc8\xb4\xcb\x22\x88\xf1\x46\xf9\x6a\xd6\x69\x2d\x88\xd7\xa5\x31\xc4\xd7\x18\x0d\x12\xe8\x8c\x6c\xd8\xa9\xb9\x84\x76\x1a\x05\xb2\xd0\x5a\x44\x62\x76\x72\x9d\x74\x2a\x22\xb1\xba\xb5\xdb\xd6\x48\x1a\x71\x3a\x15\x8d\x8c\xbb\x54\x98\x4c\xb4\x7a\x48\xa6\x9d\x96\x81\xb8\x9d\xda\x4f\x66\x9d\xba\x48\x3c\x8d\xb1\x22\x7e\xa7\xba\x91\xa0\xcb\x3a\x90\x50\xab\xc5\x84\x76\x5a\x0e\xb2\x90\x8c\xc3\x6d\xc6\x54\x97\x0d\xf0\x96\x02\x60\x49\x9c\xb6\x3d\x3e\xaa\x16\x37\xda\xe6\x98\xd7\x6b\x1b\x62\x01\x4f\xf1\x6a\xcc\xe1\x59\x4a\x3c\x26\xe5\x4b\x95\x11\x16\x98\xa8\xc7\x19\xd7\x54\xe3\x3f\x2b\xfb\xad\x32\xc1\x1c\x4f\xd5\x2b\xbf\x04\xaa\xc0\x33\x38\xe2\x87\x3d\xda\xe6\x57\x2d\x27\xb4\x24\xa2\xa2\xce\x42\x20\xa1\x78\x55\x2c\x2a\x69\x7b\xce\x5f\x93\x2e\x9a\x8a\x32\x56\x17\xff\x45\x19\xbb\x8b\xd7\xe2\xb9\xd3\x45\x6c\x51\x66\xac\x27\xab\x28\x31\xe9\xed\xf3\x54\x23\x5a\xe2\xb5\xdb\x45\x51\x51\x66\xa6\xe3\x92\x78\xef\xe9\xa5\x54\x94\xf0\xbb\xe4\x51\x94\x09\xd4\x2c\x17\x6f\xc3\x2e\x31\x12\x65\x68\x97\x88\x8a\x32\x0b\xbd\x86\x16\x1e\xb1\x52\xb1\x49\x57\x0f\x88\xa5\x21\x32\xb1\x75\x12\x47\x9c\x2e\x64\xc9\xb8\x8b\x2d\x64\xd2\x45\x0c\x32\xed\xe8\xa2\xce\xfe\xce\xf4\x2c\x24\x5e\x97\xa4\x12\xbf\xd3\x1e\x06\x5d\x1a\x45\x42\xbd\x7c\x13\xaa\x13\x3a\xb2\xe8\xd7\xae\x6a\x72\xa3\x2d\x41\xba\x6d\x01\xb1\xfa\x05\x8e\xd8\x7d\xda\x47\x9c\x4e\xed\x23\xe3\x7e\x23\x50\x30\xbb\xb3\xbb\xd3\x7e\xa3\x44\xdc\x7e\xe3\x46\x66\xfd\xd6\xa0\x10\x87\x2e\x2d\xe3\x42\xa1\x7d\x1b\xf4\x99\x35\x2e\x18\x1d\x78\xd2\x3e\x8b\x53\x08\x09\xb6\x22\x8d\xec\xfc\xab\x9c\xd7\xe0\xa5\x97\x7d\xc8\x20\x5f\x7a\x39\x64\x74\x45\x83\x1c\xf3\x11\xbd\xfd\xf6\xd5\x4f\x10\xc5\x9b\xe2\x9a\x88\x32\xa3\xc1\xcb\xa7\x6f\x1b\x17\x17\x57\x07\x13\x0d\xa8\x36\xfe\xe3\x05\x8a\xe2\x07\x7e\x17\x3f\x0c\xb9\xa2\x29\x9e\xf2\x02\xfc\x47\xf1\x9d\xfd\x30\xa4\xfe\x34\x31\x97\xb2\x2a\x7d\x77\xfc\x96\x27\xc6\x02\x9e\xf8\xa5\xfb\x8e\x2a\x56\xba\xbc\xa0\x8a\xff\x90\xb2\xa4\xdc\xf5\x8a\xaa\xee\xd4\x7a\x1f\xe8\x4d\x99\x02\xec\x03\xbd\x51\xa4\xbe\xfb\x40\x6f\x8a\xbc\x7a\x1f\xe8\x8d\x3a\xad\x1e\x6b\x83\xb3\x68\x3c\x01\x3f\xca\x33\xf0\x82\x20\x49\xc3\x28\xbe\x80\x3c\x81\xd7\xcf\x88\x12\xee\xb7\x11\xa6\x02\x3a\x6f\xe6\x40\x56\xdd\x1d\x32\x9e\xe8\xef\x0e\xa9\xc0\xbd\x4e\x18\xc0\xd7\xcf\xc8\x79\xf4\x0e\x0e\x80\x28\x72\x94\x8a\x76\x79\x7a\xfe\x41\xd1\xbb\xf3\xaa\xbe\x48\xc7\xc7\xfe\x19\xd8\x04\x0e\x24\xd0\x98\x87\x6f\x08\xf7\x5b\x80\x15\x09\x4b\x9f\x66\x19\x5d\xfb\x2b\x0a\x64\x02\xd9\xa5\xff\x81\xde\x28\xc8\x9f\x5d\xfa\x7f\xa1\x37\x59\xc9\x82\xea\xb7\x9e\x28\xf1\x5b\x2c\xc4\x49\x53\xfc\x78\x04\x64\x52\xfe\xd2\x5f\xb1\xf2\x0c\x33\x4e\x09\x7c\xd4\x84\xcc\x0a\xe8\x02\x97\x73\x01\xf4\x9d\x40\x4a\x09\xb7\xfb\xea\x16\x3f\xca\xdf\x62\x56\x94\xb9\x94\x04\xa5\x84\xab\x03\xc9\x05\xca\x71\x95\x02\x65\xb5\xeb\xa8\xa4\xc6\x72\xf4\x52\x53\x6f\x67\x91\x26\x6b\x34\x30\x2b\xba\xc8\xc1\x72\x51\x33\x58\xcb\xea\x8a\x9c\x38\xe7\x83\x08\x0e\xf9\xdd\x10\x26\x26\x70\x2c\x84\x6b\x30\x78\xfd\xcc\x12\x32\x38\x84\xfd\x92\x02\x43\xf8\x13\x58\xee\x3b\xcc\xf1\x88\xb2\x15\xc1\x9f\xf0\x8e\x8b\x9d\xd1\x4b\xa3\x8b\xe5\xee\xf8\x39\x98\xbe\xb3\x42\x72\x58\xc3\xd2\x72\xf1\x35\xc7\x15\xf6\xc1\x72\x34\x08\x0f\x15\x18\xb7\x9a\x55\x65\xf6\x67\x1d\x88\xe2\x80\x02\xf5\x82\xa5\x10\x3b\x88\x32\xf0\x36\x9b\x55\x44\x43\xc6\x4b\x2f\x06\xba\xdd\x78\x71\x48\xc3\x22\x2f\x23\x9a\x77\x43\x09\x8d\x91\x40\x80\x09\xbc\x18\x7c\x0a\x7e\x9a\x7c\xa0\x31\x44\x71\x9e\x80\xcb\x93\x02\x67\x90\x05\xde\x8a\x83\xe7\x20\x33\x35\xb4\xeb\x65\x14\x2c\xc1\x5b\xad\x92\xeb\x0c\x41\x33\xb8\x79\xc2\xc0\x5e\x66\x34\x84\xeb\x28\x5f\x26\x97\x39\x47\x30\x8b\x92\xb8\x0d\x45\x10\x1a\xd3\x6b\x0e\xaa\x1f\x8f\x1e\x89\x6b\x65\xaa\x47\xcc\xa0\xd8\x44\x45\xb9\x9a\xe4\x12\x2e\xb9\xd3\x6e\xc1\x15\x60\xd1\x88\x55\xdf\xd1\x66\x0d\x22\xce\xc4\x07\xc0\xb8\x6f\xab\x59\xa5\xeb\xc7\x54\xee\xc7\xf4\x9d\x48\xec\xf9\x51\x7e\x84\x97\x02\xb4\xae\xda\x51\x58\xc0\x67\x3c\xf1\x25\x44\xf1\x15\x4d\x33\xaa\xb7\x82\x51\x7c\xf5\xb6\x61\x08\x6b\x8f\x76\x1a\x20\x48\xc7\x00\x51\x41\x93\x29\x96\x9d\x93\x31\x13\xe8\x26\xf4\x4f\xb5\x80\x43\xf5\x83\xc6\x41\x7a\xb3\xc9\x6f\x71\x15\xa0\xc8\x58\x9b\x3c\x2b\xeb\x55\x85\x8d\xba\xc9\xd7\xa6\xd0\x0d\xe9\xd7\x68\xb5\xa2\x48\x57\xee\xde\x67\xdd\x2d\x1b\x05\x21\x55\x4e\xc7\x9f\x69\x2e\xfb\x69\x75\xe4\x56\x08\x54\xba\x1a\xab\xc9\x03\x5e\x2c\x6d\x16\xc3\x9b\xb3\x14\xde\xc7\x8b\x38\xca\x23\x6f\x25\xa7\xbe\xaa\x97\xa1\xdb\x60\xe9\xc5\x17\xf4\xe4\x4d\x95\x16\x95\x67\x1e\x33\xb7\xe6\x82\xff\xd7\x14\x69\x75\x1d\x7e\x3f\x35\xce\x58\x17\x0b\x6d\x9d\x37\x27\x72\x1d\x0b\xdb\xb1\xc5\x67\xb7\x3a\x2e\xc7\xcd\x5c\x2c\xd8\xff\x3b\xe2\x86\x75\xc6\xe2\xa3\xcc\x4c\xdb\x75\x55\x1b\x4f\x1f\x86\x1a\xc5\xbf\x72\xad\xc2\xef\xfd\xd7\xb6\x29\x46\x22\xa5\x3f\x81\xe0\x74\xd7\x5e\x94\x82\x21\xcb\x89\xa6\x6c\x5a\x2f\x9b\x8a\xb2\x4a\x24\x9f\xd3\x28\xcb\xe9\xaa\x94\x62\x35\xc4\x05\x76\x7e\x37\xd7\xc2\xed\x36\xd0\x0b\x36\xd0\xf2\x54\x6b\xe7\xd1\xbb\xf3\xc1\x40\x60\xfb\xbe\x32\xd7\xcc\x91\x2c\xa7\x2e\xf8\x1b\xd3\x6a\xab\x48\xa3\x30\xd8\x0d\x45\x4a\x75\x94\x6a\x68\xd2\xaa\x40\x63\xd1\x6f\xc0\x7f\x88\xc3\x04\xb2\x6b\x6f\xc3\xdd\x8f\x95\x97\xe5\x5c\x18\xda\x26\x3c\xef\x66\x59\x03\xd9\x3a\xc3\xba\x14\x3f\x57\xc8\x30\x66\x14\xbf\xad\xaa\xb7\x54\xe3\x8b\xa9\xe0\x5d\x54\xfd\x2e\x26\xa5\xc7\x74\x29\x66\x64\x39\x24\x97\x79\xcb\x02\x97\x26\xb7\x9b\x65\x35\x93\xab\xe7\x59\x6d\xc8\xf8\x40\x6f\x78\x0a\xe8\x89\x73\x68\x5b\xf2\x9b\xe8\x4a\xf3\x42\xca\x1b\x3d\x51\x66\x8d\x3e\x84\xb7\x4c\x02\xc5\x24\x20\x4d\xb2\xac\x72\xd3\x31\xe7\x21\x3a\xc4\x38\x2d\xe5\x35\xca\x81\xaa\x22\xdc\xa0\x18\xaf\xd6\x5e\xf6\xa1\xa6\xb2\x85\xec\x0e\x06\x35\x11\x65\x8a\x58\x8c\xae\xef\x6b\x5d\x67\x4a\xcb\xa0\x48\x24\xa8\x89\xec\x7b\x94\xd9\x3f\x28\x05\x9f\xbd\x63\x1e\x15\x87\x2c\x4a\x15\x7a\xd7\x42\xfb\xcd\xc9\xee\x68\xa7\x7a\xb4\x57\xdd\x68\xaf\x3a\xd0\x4e\x77\x40\xbb\x33\x89\x74\x56\x64\x91\xe6\xe1\x8f\xdd\xf2\x48\xf7\x25\x61\xe6\xb0\x72\xba\xcd\xe5\x54\xcc\xdf\x1d\xbf\x1d\x09\x07\xad\x96\x8b\xd9\x80\x60\x71\xa1\x48\xae\xbd\x59\x79\x0c\x89\x6d\x0e\x4d\x28\xc2\xe1\x1a\x54\xed\xa8\x00\x95\x99\x9d\xdb\x81\x9a\x7a\xd2\xed\xef\x8e\xdf\x2a\x33\x6e\x9f\xa5\xd1\x66\x45\x0f\x6e\x17\x22\xe2\x95\x6a\x81\x22\xf9\xd1\x3f\x4f\xb8\x48\x04\x22\x18\xda\x11\x66\x28\x0d\x9a\xd7\x03\x09\x2f\x96\x66\x04\xe6\xac\xdc\x88\x53\xf5\x98\xf3\x38\x49\x07\xd5\x3d\xeb\xe2\xe2\xf8\xa2\xe9\x51\xb6\x8a\x02\x3a\x30\x0d\xb0\x86\xad\xbb\x30\x4a\xb0\xd6\x1d\xc1\x5a\x06\x38\x1d\x60\xed\x3b\x82\x75\x0c\x98\x0c\xf5\x17\x69\xdc\x79\xee\x41\x33\x32\x92\x2b\x4b\x35\xb4\x94\x19\xc9\x73\x8e\x1d\x2a\xd8\x3b\xb4\xf0\x65\xe6\x34\xac\xad\x5b\x22\x67\xdd\xb6\xfb\x64\x87\x16\xd4\xa3\x1e\x99\x59\x5f\x6c\xd8\xfb\x2f\x62\x56\x4b\xeb\xf2\x05\x8c\x6b\x05\xeb\x96\x26\x56\x67\xe2\xea\x86\xb6\x2c\xd5\x99\x3f\xbf\x2c\xd5\x48\xa1\x2f\x25\x66\x3f\x1a\x5b\x46\x23\xab\xbe\x94\xdc\xfd\x68\xec\x18\x55\x56\xf7\xa3\xf1\xc4\x10\xc9\xde\x8f\x26\xe4\xd3\x3b\xc3\x75\x3e\x2b\xe1\xfe\x3f\x32\xd3\xfe\x57\xcb\x87\xff\x9f\x93\xd9\x1e\x6f\x2a\x88\x62\x1a\x7e\xd9\x14\xf7\xdf\x7a\x19\xad\xb2\xd6\x7b\x19\x95\xde\xfd\x64\x5b\x9d\x19\xf0\xdb\xba\xbc\x9d\x38\x10\x7b\x6b\x9a\x6d\x64\x2d\x3d\x94\xd1\x60\x45\x18\x1a\xfc\xdf\xbf\x7d\x52\x81\x79\x0a\x13\xa7\xbc\xc2\x46\x05\xe6\xa7\x89\xc3\xf0\x40\xa4\xb6\x13\x67\x24\x7e\x30\xfc\x15\x9e\x41\x05\x9a\x83\x17\xe1\x94\xe8\xaf\x34\x03\x0f\x62\x7a\xbd\xba\x01\xae\x6b\xa1\xaa\x61\xd9\xa0\x40\xed\x36\x8f\xf8\x72\xed\xd3\xf4\x13\xe0\xad\x52\x78\xab\x0a\xfb\x62\x5b\xe8\xce\x8f\x3a\xab\xac\x92\x6b\xac\xc1\xfe\x55\x55\xa8\x57\xae\x5b\xb7\x76\x81\x82\x2e\xdb\x8a\x2e\x85\x45\x28\xc8\x53\x0c\xcc\x7c\xf5\xcf\xb4\x4c\x1b\x67\x65\x8e\x39\x36\x27\x66\x3d\xde\x59\x50\x1a\x4d\x7c\x1c\xd5\x3c\x2a\xd6\x43\x83\x61\xad\x1e\xc3\xc4\xfd\x5a\x8a\x5b\x3d\xf1\x35\xeb\xed\x1c\xea\xb7\x6f\xcb\x33\xf3\x26\xa7\xbe\x8d\xf2\xeb\x28\xa3\x70\xfa\xea\x2c\x43\x08\x7d\x8c\x29\x2e\x4a\x11\x02\xf2\x09\x9e\x32\xfe\x32\xba\x1c\x20\x61\xc4\x48\xe2\x2d\x72\x9a\x42\x4c\x2f\xbc\x3c\x8a\x2f\xbe\x00\xe1\x11\x14\x65\x84\x17\x2c\x18\xc5\x49\x3e\xd0\x52\xf5\xf0\x10\xe2\xa4\xd7\x53\xc5\x3b\x59\x38\x41\xff\x5e\x52\xf7\xa1\xb2\x18\x27\xec\xdf\x0b\x22\x2b\x5c\x52\x41\x19\x41\x98\x42\x1a\x2a\x76\x3e\xac\x61\x57\xf3\x00\x74\x5c\x79\x7a\xfa\x9d\xc4\x15\x5c\x4e\xc0\x71\x7b\xe3\x65\xb8\xbc\xb0\x93\x0e\x95\x9c\x42\x18\x4c\x25\x4a\x66\xe5\x09\x6b\xa2\x80\xfb\x85\x99\xff\xf4\xf4\xbb\x2f\xc3\x7a\xbe\xb6\x53\x31\xde\x8b\xc3\x81\x17\x27\xf9\x92\xa6\x02\x91\x2e\x31\xf0\xe2\x50\x16\x03\xd6\xc3\x1e\x51\xa8\xf4\xec\x3e\x27\x48\x9f\x54\x94\x9a\x27\xca\xff\xc3\xe4\xe3\xd5\x9b\xaf\x2d\x1e\xaf\xde\x7c\x25\xe9\x78\xf5\xe6\xcb\x08\x47\x92\xd6\x64\x23\x49\x6f\x21\x1a\x49\x7a\x67\xc9\xf8\x78\x4b\xc9\xf8\xf8\x0f\x96\x8c\x9f\xbe\xbe\x68\xfc\xf4\xd5\x64\xe3\xa7\x2f\x25\x1c\xdb\x86\x74\x6c\x6f\x25\x1e\xdb\xcf\x90\x8f\xf7\xb7\x94\x8f\xf7\xff\x20\xf9\xc0\x45\x79\x59\x32\x62\x1e\x19\x15\x13\xc2\x15\x5d\xe4\xbb\x7b\x65\x31\xca\x04\xff\x05\xc9\xa2\x84\x84\x57\xd8\x7c\x29\x61\x40\x60\x5f\x46\x1c\x10\x54\x4d\x20\xf0\xc9\xc9\xc0\x1a\x77\xc9\x01\x2f\x24\x8b\x42\xac\x92\x03\x36\x05\x8a\xe1\x11\xd8\x96\x6e\xa5\x4b\x92\x94\x41\x25\x2a\x8f\x1e\x41\x8c\x4b\xe4\xa5\x30\xf0\xad\x43\x16\x1c\x40\xac\xbc\xac\x5e\x2d\x42\x0c\x4e\x5b\xd6\x3e\x41\x31\x79\xea\x46\x48\x06\x33\x88\xe1\x40\x71\x63\x68\xab\xe9\xe6\x52\x17\x6b\xee\x3f\x53\x7a\x31\x94\xff\x3f\x4e\x7c\xdf\x0c\xf4\x93\x8b\x42\x7a\xdf\x7c\x21\xe9\xe5\x7c\xaf\x4b\xaa\x24\xbc\x85\x3c\xef\x20\xbc\x2d\x8b\x89\xa0\xee\x20\xbf\x92\x16\x94\x70\xfa\x05\x58\x34\xff\x0f\x97\xe0\x37\x49\xee\xe5\xf4\x6b\x1b\xe0\x14\x5b\xf9\x52\x22\x8c\xd0\xbe\x8c\x08\x73\xc4\x64\x11\x4e\x93\x5e\xfb\xcb\x8a\xf4\xca\xaf\xe8\x11\xca\x81\xb0\xea\xf1\x90\xb9\x83\xd5\x93\x37\x83\x89\xd3\x12\xcb\xcf\x65\xd8\x17\xb2\x39\xff\x5c\x1c\xeb\x31\x39\xac\xc4\xed\x19\xf6\xa6\xc5\xb0\x93\xbb\x30\xec\x69\x18\x7e\x6d\xcf\xd7\x0b\xc3\xaf\xe4\xf9\xf2\x2b\xbf\xbf\xc4\x9c\x39\x6c\xcc\x99\xc3\x5b\xcd\x99\xc3\x9d\xe7\xcc\xcd\x11\x61\xbf\x74\x64\x71\xc3\xa8\xda\xf9\x0d\xbc\x34\xbd\x61\xd5\x8a\x31\x84\x5f\x0c\x5f\x1b\x56\xaa\xeb\xe1\xd5\x30\xda\x8e\xd4\x7e\xe5\x73\xc3\x3e\x6f\x43\xe0\xf0\xb9\x16\x9d\xff\x52\xaf\xae\x3c\x8d\xc5\x15\xe0\xc9\x42\x8e\x6d\x66\xaa\x1b\x8e\xd3\x64\x43\xd3\xfc\x06\xfe\x26\xae\x18\xc6\x82\x28\x5e\x25\x88\x56\x58\x51\x08\x48\x36\x52\xc1\x29\xcc\x4a\x79\x27\x7a\xdd\xba\x64\xd1\x45\x1c\x2d\xa2\xc0\x8b\x73\xf0\xf1\x7d\x14\x4b\xba\x81\x8d\x76\x44\x7f\xab\xb8\x74\x81\x4c\xf1\xe4\x0b\xc4\x81\xdb\x18\xe8\xd5\xb1\x46\xae\xc1\xab\x0d\x13\x4b\x6f\x35\xac\xd1\xbe\x97\x70\xa0\x34\xc8\x25\xe5\x24\xb0\x3b\x11\x91\xd6\xd9\xfc\x19\xba\x7a\x2d\x93\xba\xd9\x8b\xda\x9a\x6f\x5d\x67\x3f\x13\xd8\x79\xab\x3e\xfb\xdc\x36\xac\x6d\xdc\x16\x0a\x71\xc9\x8c\x78\xc4\xc7\x33\x35\x01\x09\x09\x25\x8b\x61\x0b\xc8\xbb\xff\x41\x5d\x35\x80\x98\x3b\x2f\x0f\xa0\xd0\x19\xa5\xd8\xb6\xcc\xf2\xb5\xd8\x3c\x81\x66\xb1\xf8\xc1\xff\xfd\xf8\x51\x71\x00\x83\xf9\xfd\xa5\x0e\xdc\x9b\x43\x7b\x15\x4c\xfe\xf0\xb1\xb9\x28\x3e\x2f\xd1\x68\xee\x05\xd4\x3a\xed\x4d\x00\x5c\x87\x56\x34\xbe\xc8\x97\xf0\x00\xdc\x1d\xb7\x52\x37\x0d\xcd\xb3\x24\xbe\xa2\x69\x31\x35\x94\xcc\xb0\xb0\x0f\x6c\xd0\x2e\x4e\x07\xec\x64\x78\x8a\x51\xbb\xe4\x6e\x6d\x65\xee\x13\x9c\xd5\x8d\xe8\x5e\x06\xa1\x97\x7b\xe0\x65\xb7\x6c\x67\xe7\x48\x56\x7d\xa5\x70\x2b\x19\xe8\x51\x9e\xfc\x64\x5b\xfa\xa5\x10\x7c\xfd\x19\x7b\x76\x44\x5b\x75\xa1\x52\xec\xdc\x29\xca\x9d\x70\x66\x96\x48\x16\xec\x55\xed\xe2\xe1\x6c\x53\xc0\xe2\xdd\xdd\x79\xf3\x7e\xbd\xed\xee\x93\x5e\xd5\x12\x5e\x51\xeb\xbc\xb5\x85\x9f\x7d\x0a\x1c\x46\x9b\xcb\x6c\x39\x28\x1c\x29\xe6\x23\xa8\xe6\x95\xea\xd2\x0d\x5f\x02\x14\xfb\x64\x0b\x57\x44\x62\x70\x61\x41\x0a\x98\x46\x5d\x6d\xb4\x1b\x49\x5a\x5a\x81\x60\x98\x48\x06\xc9\x06\x07\x49\xcd\xd8\x0f\xbd\x6e\x6b\x29\xf6\x14\x82\x55\x12\x77\xcd\x54\x76\x15\x69\x84\xd3\x94\x65\x7c\xa8\x97\x65\x7c\xdd\x29\xcb\x32\x64\xf4\x52\x38\xba\xe5\xce\x57\xd5\x4e\xd7\x67\x58\xfe\x5f\x50\xb0\xff\x85\x53\xa6\x0d\xb4\xb0\xa5\x1c\x5e\xdb\xcc\x16\xbb\xc6\xf4\x0d\xe0\x19\xa6\x62\x61\x9d\x3b\x27\x9a\x66\x4a\x15\xba\xae\xe9\x4f\xaf\x1a\x5c\xef\xa2\x03\xd7\x42\xe4\x0b\xf0\xe7\xd1\x3b\x15\xd9\xf5\xa2\x8a\x85\x6b\xeb\xcb\xa5\x7b\xac\xdd\x37\xd3\xd8\x2d\x23\xb6\xc6\x7c\x7a\x67\xb8\xe3\x5d\xf6\xbb\x1c\x3e\xb8\x07\xcb\x3c\xdf\x64\x47\x87\x87\xeb\x7c\x99\x8d\x7c\x7a\x78\x99\x2f\xdc\x5f\x33\xb8\xb2\x46\x64\x64\x81\x7f\x03\xff\x6b\xed\xe5\xcb\xc8\xcb\x98\xc4\x54\x1b\x64\x70\x57\x08\xdf\xec\x71\x78\x08\xdf\xd1\x9c\x1f\x87\xa3\x94\x91\x3b\xf2\xfc\x15\xcd\xe0\x3f\x44\x4b\xff\xf1\xcd\x1f\x70\x1b\x7f\x4a\xe9\x71\xb9\xff\xa5\xb5\x93\x06\xf6\x38\xf3\xf6\xe0\xfe\xfd\xe2\xf1\x43\x3d\x78\xf8\x0f\xde\x1d\x09\xf8\x4b\x7c\x50\xc1\x5e\x8b\xdf\x75\xd0\xe2\xe9\xfd\xfb\x8a\xfd\x39\xf3\x1a\x92\x65\xe1\x4e\x34\x2e\x70\xe7\xcc\x7f\x18\x7c\x37\xfe\x69\x12\xd2\xd1\xaf\x19\x24\x29\x7c\xcb\xb7\xd2\x44\x8b\x88\x86\x10\x24\x21\x35\x10\x8a\x17\x87\x70\x99\x51\x88\x72\x36\xae\xfd\x07\xa3\xa3\xd4\x07\xb1\x0f\xa7\xec\xc3\x85\xf8\x5d\xef\x03\x7f\xfa\x90\xef\x49\xaa\xaa\x8d\xca\xd2\x73\x19\xd8\xc7\x8f\xd2\xaf\xd1\x75\x14\x87\x6c\x76\x59\x2b\xc3\xb7\x0e\x31\x5c\x40\x7e\x8c\x9b\x7d\xbe\xf9\xc3\xe1\x83\x83\x2f\xf6\x79\x70\xf8\x0d\xef\x6d\x96\xa7\x51\x7c\xf1\x3c\x4d\xd6\xcf\x96\x5e\xfa\x2c\x09\x19\xe7\xde\xe2\xc3\xd1\x42\x7a\x2a\x88\x7f\xe6\x7d\xa0\x31\xa7\x71\x53\x64\x37\x97\xf1\x0d\xa3\xef\x37\x7f\x28\x2d\xd8\x65\x90\x59\x21\x65\x0f\x07\xbc\x1d\xde\x41\x5c\xda\xc4\xcd\xf7\xc5\x10\x88\x8f\x82\xe4\x32\xce\x69\x2a\x22\x97\xf8\x68\x55\xd8\x0a\x5e\xbd\x32\x16\xf8\x16\xcf\x33\x16\x3f\xe8\x36\x4f\x3d\xf6\xe3\x7a\x19\xad\x28\x0c\x0a\x68\x8f\x04\x10\xde\xf4\x1f\xb0\x4e\x05\x30\x10\xdd\x7b\x9a\x17\x15\xf6\xf7\x99\xaa\xff\x01\x79\xca\x0b\x3f\x9e\x83\xb9\xfd\xce\x35\x4d\xc6\x73\xfe\xe8\x11\x3e\xfa\xf6\xf9\x73\xf6\x48\xd3\x12\x23\x17\x4e\xd7\xb3\xcb\x34\x4d\x2e\xbc\x9c\x1a\x28\x75\xf9\x92\xa6\x14\xcf\x79\x42\x4c\xb7\x39\x30\x14\xbc\x20\xa7\x29\x56\xc2\x6e\xec\x82\x1f\x22\x38\xe0\xc5\xef\x83\xb9\x7d\xfe\xcc\x34\x87\x4c\x42\xcd\xed\x77\xf8\xf5\x6f\xcc\x38\xaf\x92\xeb\xaa\x7d\xac\xf6\x07\x4e\x79\x3e\x94\x0f\x44\x17\x19\x00\xfb\xf9\xf3\x21\x1e\xcd\x34\x87\xb0\x0f\x12\x64\x7c\xb1\x5f\x64\x1c\x12\xad\x57\x5e\xb0\xe8\xea\x65\xbc\xf6\xf2\x60\x49\xc3\xaa\xbd\x87\x90\xc4\xab\x1b\xf0\x36\x1b\x8a\xfd\x8e\x32\x54\x40\xb8\x8c\xa3\xdc\x60\x13\xcd\xc0\xcb\x28\xce\x36\x19\x21\x4a\x48\x65\x19\x46\xa4\xbc\xd8\x17\x55\x42\x65\x43\xbd\x27\xfd\xdc\x78\x51\xda\xee\x19\xf6\x4b\xe0\xfa\x07\x41\xba\x83\x03\x81\xfb\x37\xcd\x0e\x68\x6a\xb2\x82\xec\x7f\x61\xef\x79\xa9\x42\x1b\xef\xa2\x0c\x34\x46\x65\xc0\x51\xb8\xd2\x85\x52\xca\xb9\xdf\x52\x17\xf2\x28\x0e\xe9\x16\xe6\x70\x40\x94\x62\x5f\xea\xd1\xde\x9e\x24\xfc\xfb\xfb\xbc\x9a\x46\xf8\xb1\x9d\x73\x2c\xf2\xae\x29\xec\x4c\x94\x9e\x33\x8e\x73\xca\xf0\xa7\x07\xf3\x82\xfd\x0f\x25\x7a\xc1\xfe\x5c\x61\x3f\x0a\x40\x8f\x1f\x03\x31\x0b\x01\x82\x8f\x42\x87\x04\x4b\x0a\x4c\xb8\xb0\xc2\x47\xa8\xc9\x61\x49\xfc\x1d\x1a\x42\x80\x3a\x26\x95\xc4\x0f\x96\x34\xf8\xf0\x36\xf0\x56\x5e\xfa\x6f\xac\xd6\x80\xf1\xe1\x75\x12\xc5\x7c\x37\x35\x12\xa0\x7c\x54\xd7\xf8\xea\x31\xd7\xfa\x8a\x38\xf9\x32\x4d\xae\xe1\x38\x4d\x93\x74\x80\xbd\xda\x3b\x61\xae\x50\x25\x9a\x3f\xec\xef\xc1\x7e\x05\x60\x94\x27\xdc\xb2\x0e\xc8\x64\x38\xca\x93\x1f\x36\x1b\x9a\x3e\xf3\x32\x3a\x18\xc2\x3e\x07\xc0\x44\x3e\x4e\x72\x26\xe0\x88\x2c\xa7\xcb\x1e\x7b\x59\x74\xf4\xd3\x57\x18\x09\x2a\x3a\xa1\x57\xcd\x3c\xf1\x8a\x1c\x06\x5f\x66\x13\x83\x13\xa7\xb2\x82\x1b\x03\x99\x80\x8f\x8b\x3a\x9c\xa3\x18\xaa\xdc\xba\xe6\xb0\xc9\x17\xae\x10\xcf\x8a\x8a\x2a\xb6\x48\x60\xef\x0b\xe1\x7c\xfe\xdc\x15\xb6\x4e\x98\x39\x72\xe0\xdf\xe4\x14\x32\xfa\xdb\x25\x8d\x03\x34\x74\x7a\x44\xab\x36\x0a\xd1\xc1\x81\xf0\x66\xed\x27\xab\x52\x91\x74\x2d\xbb\x66\xbd\x65\xab\xdd\x72\x09\xa9\x9f\x48\x13\x4e\x20\x22\x08\xf4\xcc\x2c\x51\x2a\x37\x1e\x2b\x90\x40\x33\x2c\x23\x61\xb7\x91\xe8\x10\xf8\x87\xb7\x44\x92\x58\x1c\x4b\x53\x60\x79\x6c\xd6\x40\xec\xcf\x35\x52\x33\xd9\xa1\x33\xc7\x66\xab\x33\xce\x67\x51\x94\xb8\x02\xd9\x29\x47\xf6\xf9\x8e\xc8\x12\xeb\xb6\x9d\xaa\x4a\xaa\xb0\xaa\x77\xb4\xae\x01\xa5\x6c\x22\x84\xa6\x4a\x30\xd7\x5f\x8c\x13\x4d\xa7\xa9\x04\xca\x5c\xf7\xb6\x73\xd5\xf2\x9a\xaa\xf2\xbd\x83\x4a\x59\xb4\x78\xc0\x98\xc0\xad\xd5\x8e\x83\x4b\xd5\x63\xb9\x61\x79\x94\x91\x40\xee\xcf\x3b\x54\xbf\x61\xd1\xab\x6a\x5f\xcb\x11\x2e\x69\x9f\x52\x2f\x7c\x96\xc4\x79\x14\x5f\xe2\xe1\x59\xe4\x7e\x65\x8a\x18\x26\x2f\xb0\xef\x8f\xe7\x88\xd6\x33\xe6\x58\x28\x46\x83\xbd\x17\xf1\x95\xb7\x8a\x42\x2c\xc4\xa9\xbd\x27\xba\x55\xd2\xbb\xde\x0a\x70\x80\x18\x28\x38\x2f\xdb\x79\x27\xd4\x84\x55\x2d\x1f\xee\xef\x33\x67\xbc\xb0\x50\x0d\x30\xf7\xb9\x19\xe1\x8e\x20\xb3\x92\x7f\x93\x8c\xa1\xb2\xb4\xfd\xbc\x44\xec\xf0\x10\x5e\x2c\xe0\x9a\x02\xf3\xd7\x2e\x37\xc0\x3c\x55\x03\xa2\xfc\xff\xfb\xbf\xfe\xef\x62\x58\x92\x41\x20\xc6\xdf\x68\x7a\xde\x2a\xb8\xd7\x32\xfe\x5c\x7a\xdf\xa2\x16\x0c\x2a\x29\x67\x85\x89\x2c\x86\x96\xfc\xc3\x96\x7f\x38\x0a\xf1\x6d\xf3\xea\x33\x58\x55\x87\x34\x6f\x73\x5d\x50\x76\xe1\xad\xf0\xf0\x43\x49\xc7\x37\xd4\x0b\x61\x11\xa5\x59\x5e\x50\x09\xbb\x75\x7b\x36\xb7\x47\x37\x18\xc4\x49\x9b\xbc\xd9\xb0\x90\x09\xde\xd0\x7d\xc1\x7f\x61\x59\x25\x5c\x4b\xfa\x16\xb8\xb6\xc7\xb0\x06\x9c\xe3\x42\xa0\x9e\x15\xa0\x90\x2d\x30\xd7\x28\xcc\xc3\xa6\x3d\x90\x81\x11\x3e\xcd\xc0\x9c\x3b\x25\x77\x55\x0e\x58\x29\xbd\x95\xf8\x4a\x36\xaa\xee\xc0\xdf\x42\x04\x0b\xb7\x9e\xf7\xdd\x6e\xd2\x76\xed\xdd\x40\x14\x07\xab\x4b\x9c\x84\xb0\xc9\x85\x3c\xa5\x51\x51\xf9\x79\x41\x9d\xe3\x5b\x50\x07\x45\xf9\x6e\x04\x34\xc5\x3c\xcd\xc2\xbd\x49\xbc\x2d\x99\xa0\xb6\x8e\xa0\x26\x3a\x2f\x9c\x60\x7d\xfe\xc1\xd7\xa4\x79\x7b\x84\x6f\x52\xd4\x15\x14\x7d\xfe\x65\x29\x8a\x26\xe3\x8e\x44\x9f\x22\xd1\xcd\x6d\x93\xec\xe6\xd6\x7c\x36\x84\x8f\x48\x91\x01\xc7\x81\x3f\x2d\xf9\xe1\x68\xf9\x81\x33\x2a\xc5\x1c\x83\x98\xf2\x14\x4c\xcd\x89\x82\x9e\x4a\x2e\xfc\x70\xf6\xfc\xc0\x85\x10\x23\x65\x34\x2c\x2d\x6f\x61\x36\xc5\x09\xac\xf2\x37\x1a\x34\xe9\x37\xda\x9f\x87\x0d\x9f\x44\xf8\x1a\xd5\x68\xcc\xf1\x2b\xe1\xd5\x5d\x12\xa9\x58\x61\xd5\xb0\x15\xd9\x00\x4a\x4e\x89\x64\x63\xab\xe8\x4f\xcd\xdd\xa9\xe2\x44\xf9\x7a\x23\x79\x23\x83\x7c\xbd\x81\x79\x63\x2c\x19\xc2\xbd\xf9\x9c\x1b\xe5\xa6\x77\x22\x16\x31\xf2\xf5\xa6\xe9\x67\x48\x13\xf4\xaa\xf4\xf0\x6b\x06\xdf\x18\x59\x61\x8e\x08\xee\x5d\xd1\x34\x8b\x92\x78\xef\x08\xf6\x30\xe8\xbb\x67\xb0\xa7\x1c\x9f\xbd\x23\xc9\x2b\xc4\xe7\xbc\xbb\xe2\x39\xff\xf1\xcd\x1f\x3e\x89\x20\xdd\xdb\x64\x4d\xe1\xe9\xcb\xef\xc0\xbf\x8c\x56\x21\x24\x9b\x3c\x5a\x47\x7f\xa5\x69\x66\xc0\x2a\xfa\x40\x21\x1d\xfd\x9a\x19\x7c\x4a\x8c\x91\xf6\x6c\x43\x83\x68\x11\x05\x4c\x79\xc3\x08\x19\xbe\xf1\xf2\x9c\xa6\x71\x86\xf0\xb0\x52\xbe\xa4\xb0\x48\x56\xab\xe4\x3a\x8a\x2f\x8e\x78\xcc\x93\x89\x5f\xe3\x5c\x24\xec\x15\x42\xb3\xc7\x83\xbb\xb5\x02\x23\x6f\x1d\x36\xa2\xa8\xe5\x11\x49\xf6\xee\x9b\x3f\x70\x76\x89\x43\x93\x65\x98\xbb\x3e\x80\xb1\x3e\x23\xef\x90\x39\xd5\xec\xa2\x11\x35\xbe\x27\xfd\x1e\xc5\x49\x48\xcf\x6e\x36\xb4\x72\xe6\xaa\x58\xb5\x98\x78\x44\xb1\x1c\x37\x7e\x13\xc5\x17\xc9\xbf\xbe\x85\x2b\x73\xe4\x8e\x4c\x9c\x9e\x57\x35\xa4\xb3\xa4\x25\x32\xc2\x34\x16\x90\xbc\xf4\x7a\xe9\xad\x1a\x90\xa6\x23\xf3\x80\x07\x62\xd2\x62\x6f\x14\x3f\xc5\x28\x9e\x2d\xbd\xec\xd5\x75\xfc\xba\xd8\x02\x33\x17\x85\x46\xf5\xe7\x58\xbc\x5c\x22\xc1\xac\x71\x9c\x28\x85\xc5\xa8\x17\xe7\xeb\x43\xec\x3d\x1e\x24\x1e\x32\xda\xc8\xb4\x3a\xff\xc0\x13\x18\xb2\x12\xf8\xbd\x16\xfc\x6a\xf4\xeb\xcd\x32\x8a\x13\xd6\x2b\x0f\xae\xa9\x0f\xe2\xa0\xaa\x88\x5a\x8f\x84\x40\x0b\x9a\x7c\xfa\x46\x1c\x51\xc5\x65\x93\x4f\xc6\xdf\x3e\xbd\x33\xdc\xc9\x2e\x4b\x22\xad\x13\xbb\x3f\xbd\x3c\xf9\x3e\xcf\x37\x6f\xd8\x90\x91\xe5\x25\xb4\x7f\xf1\xa3\x0b\xbe\x99\x65\xf4\x6b\xf6\x2f\xbb\x2e\xb6\xc8\x95\xe0\xca\x1a\x99\xa3\x69\x19\xc0\xbb\x88\xf2\xe5\xa5\x3f\x0a\x92\xf5\xe1\xcb\xe8\x03\x7d\x19\xac\x0e\xe5\xe2\x87\x27\x2f\x9e\x1d\x9f\x3e\x3b\x06\xa6\xc3\xf2\x41\xe5\x8b\x32\x80\x0f\x00\xb0\x77\x99\x51\x9c\x16\x06\xf9\xde\xc3\x6f\xf0\xd1\xe1\x83\x6f\xf8\x8a\x92\xa2\x75\xf1\xe6\x29\xfc\xab\x77\xe5\xbd\x0d\xd2\x68\x93\xc3\x2a\xf2\x53\x2f\xbd\x41\x05\xf5\x52\x3f\xca\xd9\xaf\x83\x4d\x4a\x83\x88\xd9\x09\xf0\x30\x0f\x06\xcd\xa3\x60\x24\xaa\xef\xd8\x05\x51\xfa\x59\xb2\xb9\xe1\xe9\x61\x06\xc1\x10\x2c\x93\x8c\xe1\x65\x14\x2c\x3d\xba\x82\x97\xc1\xca\xbb\xbc\x58\xae\xa2\x18\x1e\xbd\x74\x83\xa5\xeb\xae\xfe\xd7\xc5\xda\x8b\x56\x0c\xe6\x63\x51\xff\xe5\x8b\x33\x38\xde\x6e\xbc\x1c\x4e\xa2\x00\x87\x71\xb1\x9e\xc9\xbb\x8b\xa7\x83\xa3\x8b\x53\x6c\xd5\x00\x9e\xe9\xc1\x80\x8d\x97\x66\xf4\xf4\x72\x4d\xd3\x28\x30\xbe\x29\x16\xd9\xa2\x4c\x3c\x82\x39\x1c\xbe\x3f\x78\x32\xf8\x39\xdc\x1f\xfc\x3c\xfa\x39\x7c\x30\x7c\xf2\x91\xfd\xbb\x3f\x1c\xd0\xf3\xfd\x83\x77\x4f\xd8\xd7\x27\x7f\x3c\x8c\xaa\xba\x6b\x2f\x5f\x06\x34\x5a\xc1\x1c\x5e\x7a\xf9\x72\xc4\xbe\xd7\xdf\x2e\x56\x49\x92\x16\xaf\xf1\x47\xf5\x3e\x4e\xf2\x6f\x13\x1e\xf6\x11\x13\x1c\x3f\x49\x56\xd4\x8b\x99\x88\xfb\x51\xcc\x38\x10\x46\x17\x51\xbe\x57\xd5\xc1\x2c\x4f\x51\x7c\xf1\x92\x2f\x96\xec\x15\xbf\x61\xcd\x4c\x72\x55\x2e\x4f\x92\x97\x5e\x7c\xf3\x1d\xab\xce\x64\x78\x4f\x6c\xbb\x62\x16\x91\x69\x3a\xac\x93\x94\xd9\x55\x2f\x06\x32\xae\xed\xc4\xc2\x16\x33\x09\xd4\xd3\x93\xd7\xdf\x3f\xfd\xf6\xf8\x8c\x41\x31\x89\x65\x3b\xe3\xc9\xd4\x9d\x79\x7e\x10\xd2\xc5\xc5\x32\xfa\xf5\xc3\x6a\x1d\x27\x9b\xdf\xd2\x2c\xbf\xbc\xba\xde\xde\xfc\xf5\xe9\xb7\xcf\xbe\x3b\x7e\xfe\xe7\xef\x5f\xfc\xeb\x5f\x4e\x5e\x9e\xbe\x7a\xfd\xbf\xdf\xbc\x3d\xfb\xe1\xdf\x7e\xfc\xe9\xdf\xff\xcf\x1f\x7f\x91\xc0\x7e\xfb\xf4\xed\x31\xcc\x81\x50\xe2\x54\x0f\x4f\x5e\xfd\xf9\x97\xe2\x85\xf4\xf8\xe5\xd3\x9f\x7e\x79\xfb\xf4\xf9\xf1\x2f\x2f\x4e\xcf\x8e\xff\x7c\xfc\x06\x83\xb7\x64\x21\x7f\x8c\x72\x31\x95\x4d\x2a\xde\x8f\x6d\x38\x00\xf2\x8d\xf4\x8c\xc1\x78\x71\x7a\x66\x5b\x58\x79\xda\xaa\x06\x75\x00\x98\x52\xb3\x02\xf0\xfa\xd5\x8f\x6f\x7f\x39\x3b\x3e\x65\xce\x00\x31\x80\x98\xec\x7f\xf6\x87\xda\xec\x8f\xc3\xfe\x8c\xd9\x9f\x09\xfb\x33\x65\x7f\x5c\xf6\x67\xc6\xfe\x60\x69\x4a\x08\xfe\xb5\xf0\xaf\xfd\xae\xea\xdd\xdb\xff\xfd\xe6\xac\xec\x35\x9d\x1a\xdf\x54\x68\x3f\x28\xbf\xc2\x03\x7e\xe8\x3a\x5a\x47\x39\x24\x7c\x9f\x1c\x8f\x5b\x27\x0b\xf8\xee\xf8\xd9\x8b\x97\x4f\x4f\x7e\x79\x7d\xf2\xf4\xd9\xf1\x5b\x03\xce\x5e\xfd\x72\xfc\xd3\xeb\x5f\x4e\x8f\xff\x5c\x7e\x7f\xfd\xea\xad\x01\x2f\x5f\x9c\xb2\x1f\x06\x12\x03\xbf\x78\x71\x28\x37\x91\xe3\x8e\xc9\x8b\xcb\x35\x8d\xc5\x4e\xec\x84\x19\xea\x98\xc6\x79\xe4\xad\x0c\xc8\x93\xe7\xd1\x96\x86\xf8\x25\x49\xd7\x5e\x2e\x96\x95\x92\xd7\x85\x6d\x30\xc0\xa7\x37\x49\x1c\x16\x29\x3c\x63\x19\x3c\xdd\x06\x14\x37\x03\xf2\xd5\x95\x34\xb9\x8e\x61\x10\x2d\xe0\xf8\xcd\x9b\x57\x6f\xde\xe2\xc3\xf4\x92\x0e\x47\x52\x9d\x43\x59\x08\x18\x81\x8e\x67\x0f\x15\x3c\x53\xf0\xd0\x64\xf8\x97\x5c\xff\xa6\x6e\x09\x8b\x3d\x1c\x3c\x53\x15\x1f\xda\xbd\xca\x68\x30\x6f\x24\xcb\xd3\xcb\x20\x4f\x52\x81\x8d\xc0\xa4\xb4\xba\x62\xd3\xef\x20\x48\xe2\x45\x74\xf1\xca\xff\xb5\xb0\xbf\x20\x2c\x50\x18\x5d\x49\xac\x14\x48\x45\x21\xe4\xa9\x17\x7c\xe0\x8b\x4b\x6c\x70\xa4\x69\x09\xd3\x80\x2c\x01\xa6\xaf\xb1\xb7\xa6\x45\x1a\x55\x31\x1f\x0c\xd9\x00\x48\x99\xa7\x0d\x22\xd1\x47\x36\xaa\x01\x8f\x30\x41\xa0\x51\x7b\xf6\x1a\xe6\x55\x9f\x46\x9b\x34\xc9\x13\x66\x00\xea\x85\x5e\x9d\x32\xc1\x8b\xe9\x75\x55\x74\x40\x86\xc6\x37\x0d\xdc\x1f\xf4\x7d\xe0\xf8\xbb\x17\x67\x4f\xbf\x3d\x39\x86\xef\x8e\x9f\x3f\xfd\xe1\xe4\xec\x2d\xf4\xd6\x29\x4d\xb6\x4a\xe2\xa1\x94\xfa\x90\x2e\xbc\xcb\x55\x5e\x24\x91\xf5\xe9\x2a\xb9\x86\xf5\x65\x96\x73\x02\xe5\xf4\x82\xa6\x19\xee\x1c\x17\x3b\x48\x91\x68\x59\x74\x45\x21\xf5\xe2\x0b\x9a\x41\x86\x9b\xed\x47\x2a\xe0\x02\x28\x23\xb7\xb7\xca\x30\xc7\x2c\xcf\xf3\x15\x82\x97\x43\x7a\x19\x1f\xe4\xd1\x9a\xc2\x65\xc6\xcc\x6c\x45\x4d\xce\xf7\x26\xc4\xc3\x16\xc7\x59\x13\x6b\x6f\x1b\xad\x2f\xd7\xd2\xde\xd7\x90\x06\xd1\xda\x5b\xc1\x66\xe5\x05\x34\xc3\x81\x96\x39\x4c\x1e\xcf\x22\x13\xc5\x57\xc9\xea\x8a\xb5\x17\x46\x57\xa8\x56\xf5\x76\xea\xfa\x0e\x73\xb0\x4c\x95\x21\xab\xa9\xc1\x2e\x74\xae\x8d\x26\x22\xd3\xee\x92\xc6\xd5\x73\x71\x36\xc3\xf3\x93\x2b\xda\xe8\x03\xb7\x04\x58\x1c\x49\xd5\x84\xdf\x67\x49\xda\x86\x04\x55\x13\xd3\x5d\x0e\x6a\x02\x30\x6c\xb1\xf1\x87\xd7\xe5\x0f\x13\x9e\x5e\x7b\x37\x7c\x61\xf4\xaf\x34\x4d\x5a\x65\xbf\x7b\xf5\xe3\xa9\xf8\x41\xe0\x2c\xb9\xf6\xd2\x30\x53\x97\x7c\x76\xfc\xe2\x44\xfc\xb0\xca\x92\xfb\x2f\xe2\x45\x14\x47\xf9\x4d\xab\xf8\xf3\x93\x57\xaf\xde\xf0\x1f\x76\x59\xfc\x40\x5b\xfc\xfb\xa7\x27\xcf\x7f\xe1\x88\x3b\x65\xf1\x98\x7a\x29\xcd\x72\x88\x69\x74\xb1\xf4\x93\xcb\x74\x04\x2f\x16\xc0\xfc\xc9\x30\xca\x72\x2f\xce\x0d\xb8\xdc\xa8\x41\xf1\x7e\x8d\x6f\x03\x2a\x4c\xae\x63\x35\xb0\xe3\x7f\x3b\x3e\x05\x98\xdc\x06\x58\x2e\x8a\xd2\x2b\x1a\x4b\xe5\x94\xe0\x39\x65\xa7\x77\x01\xaf\xa7\x3f\x42\xe6\x4c\x70\xef\x02\x59\xcb\xaa\xc3\xda\xef\x37\xaf\x7e\x38\xfd\xee\xc5\xe9\x9f\x7f\x79\xf9\xea\x3b\x66\x38\x1d\xb5\xe6\x55\xba\xe7\xb6\x4c\xc2\xf1\x4f\xaf\x5f\x9d\x1e\x9f\x9e\xbd\x78\x7a\xf2\xcb\xd3\x33\x38\x82\xf3\x6a\xc0\x06\x79\xc4\x7e\xa7\xb4\x26\x54\xe8\x91\x18\xff\x85\xea\xf8\x34\xa6\x5e\xbe\x14\xe3\x6e\xb1\xda\x2b\xc6\xb6\xac\xac\x14\x79\x2b\xe6\x6c\xa2\xa1\x19\x35\xa1\x9f\x56\x4e\xe2\x11\x1c\x4c\x6b\xaf\x25\x14\xe7\x70\x30\xd5\xf5\xba\xea\xf7\x41\xdb\xe8\x74\xe1\xcf\x6d\xca\x17\xc3\xde\x22\x2a\xec\x5f\xbf\x42\x6b\x49\xfa\xb1\x57\x21\xff\xe6\xe9\xe9\x9f\x8f\x19\xbb\x9a\x7e\x94\x9a\x4f\xeb\x28\x46\xab\x5f\xef\xaf\xd1\xe0\xd4\x65\x1c\xd2\x74\xc1\x06\xb4\x3c\x41\x3b\x04\x49\x10\x5c\xa6\x59\x0f\x73\x6c\xcb\x01\x18\x8c\x29\xfb\x32\xac\x15\x15\xc8\xe1\x0a\x1b\xed\xe0\x13\x83\x79\x40\x3a\x39\x55\x8c\x5b\xcd\x1e\xc8\xbc\x4a\xae\x2a\xf4\x0b\x0d\xda\xa9\x0b\x60\x9b\x2e\xc0\x80\x8c\xa6\xb3\xe9\x64\x66\x13\xdb\x71\x27\x96\x4d\xc6\x53\xba\x6f\x9b\xee\xb0\x59\xf7\x79\x92\x16\xe4\x86\xc7\xdc\xc7\xa6\xa3\x8b\x51\xc3\x71\xd9\x63\xde\xb6\xf8\xec\x0d\x47\x9b\xd5\x65\x36\x20\x43\x58\x7b\x37\x6c\x5c\xcf\x56\xc9\x75\x1d\xa9\x02\x22\xf7\xbc\xf5\xb4\xc2\x85\x7e\x9d\x5c\xfc\xb8\xa4\xcc\x15\x94\xdc\x47\x0c\x89\x66\xe0\xa5\x94\xd9\xc3\x54\xf8\xba\xf5\xa6\x85\xd3\x3b\x47\x9f\xb7\xa7\x69\x56\x84\xcd\x0a\x31\xaa\xd8\x6a\xff\x19\xba\x2b\x0c\xbb\x28\xce\xff\xcd\x5b\x45\xa1\x97\x27\xe9\x69\x22\xb0\xa8\x39\xd8\x08\xa1\xe1\x39\x66\x58\xe7\x05\x06\x48\x65\x08\x3f\x46\xf9\x92\xc3\x30\x8a\xa6\xd4\xaf\x0f\x55\xed\x6a\xc9\x94\x27\xb8\xfb\x91\x4f\xcb\x2f\x52\x6f\xb3\x8c\x98\x23\x7c\x73\x90\xd1\xe0\x32\x45\x97\x2d\x4c\x4a\x67\xe9\x82\xc6\xc2\x2f\x32\x58\x4f\xbc\x2b\x2f\x5a\x79\xfe\xaa\xd1\x87\x67\x6f\xfe\xfd\xf5\xd9\x2b\x10\x71\xd7\x6e\xa1\xef\x22\xa6\xd2\x2d\xc2\x40\x4e\xd2\x74\x8a\x02\x6f\x15\x5c\xae\xf0\x38\x28\x3a\x45\x58\xea\x32\x3b\x02\x8f\x7d\x85\xf6\xc8\xca\x40\xfd\x76\x99\xe4\x11\xd3\xa4\xc1\x6f\x30\x07\x0f\x0e\x21\x1e\x32\xb6\x14\xc0\x98\xd3\x29\x5f\xa8\x81\xb3\x84\x24\x4d\x69\xb6\x49\xb8\x0b\x56\xf3\xd1\x94\x6d\xa4\x74\xed\x45\xcc\xaa\xc0\x20\x6d\x01\xcf\x8e\x20\xc5\x96\x0f\x20\x86\x07\xf0\x5b\x13\x82\xde\xb5\x32\x1b\xc0\xa3\x0c\x36\x49\x16\xe5\xcc\xcb\x8e\x16\x88\x29\xf3\x56\x43\x1a\x87\xb8\x93\x08\x53\x54\x5d\x51\x83\xc7\xf0\xa4\x27\x1d\x2e\x19\x69\xb4\xb1\xf4\xf8\x44\x29\x63\x13\xa2\x2c\xba\x88\x41\x3c\x28\x5a\x6a\xc1\x92\x3f\x78\x96\x44\x66\x1e\x6e\x02\x5c\xaf\x71\x67\xe0\x87\x98\xcd\x3e\xbd\x0c\xf6\xf2\xf4\x32\x0e\x90\x3a\x85\xb7\xbd\x87\x23\x52\x94\x75\x01\x67\x3e\xc4\x95\xb7\x62\xbc\xcc\x13\x18\x78\xf0\x27\x64\x65\x2c\xc5\xd1\x3a\x5c\x44\xfb\x36\x1d\xcd\x92\x14\x06\xaf\x6f\xf2\x65\x12\xc3\x9f\xda\xde\x6f\xe5\xb1\x4d\x14\x5d\x5e\x6f\x56\x54\x4c\xe7\x97\x14\x5e\x1c\x1f\x1f\xc3\x74\xec\x48\x4d\x17\xb3\xcf\x16\xdc\xe3\x1f\x9e\x9d\xbc\xf8\x8e\x7d\x9f\xc1\xf1\x65\xb0\x8a\xc2\xc8\x8b\xab\x19\x09\xfc\xc6\xcf\x29\xc5\x83\x78\x08\x0f\x00\x83\x5b\x03\x26\xd1\x9e\x9f\x0d\xe2\x61\x1b\xcf\x3a\x6b\x1a\xa2\xe4\xad\xae\xbd\x9b\x4a\xa2\xfa\xc4\x92\xd5\x6f\xf3\xcd\xe0\x58\xd4\x9e\xb4\x31\x47\xe6\xb6\x09\xd1\x6c\x82\x91\x8f\x9b\xf0\x52\x66\x50\xf9\xd9\x5c\x4d\xd2\xf7\x6a\xde\xd6\xea\xf0\xd3\x55\xbe\x4c\x2e\x2f\xf8\x31\x69\x8c\x16\xd4\xb5\xb7\x3e\xe9\x64\xc0\x0d\x56\xf4\x06\x87\xab\x38\xc9\xe1\x82\xe9\xd6\x65\x46\x17\x97\x2b\x48\x69\x76\xb9\xca\xb3\x6e\xe7\xf4\xe5\xab\xef\x7e\x38\x79\x55\xb8\xa6\x3b\xb8\x39\xb3\x1d\xe7\xab\xed\x08\x21\x3f\xf5\x42\x05\x5e\xc5\xaf\x3c\x79\x9d\x5c\xd3\x54\x47\x14\xbe\xc9\xe3\xf5\xab\x1f\x7f\x79\xfd\xe6\xf8\xd9\x8b\xb7\x2f\x5e\x9d\x32\xe6\x9b\x86\xd8\x99\x7c\x1d\xad\x56\x48\x8b\x18\x03\x5d\x34\x54\x34\x5c\x87\x58\x87\x35\xe7\x51\xb9\xae\x1e\xeb\x7c\x9d\x05\x9f\x85\x16\xeb\x51\x7c\x11\x19\x19\xee\xdf\x60\xd7\x14\x81\x94\x51\x39\x79\x5d\xd3\x7c\x99\x34\xac\xd1\xf3\x57\x6f\x5e\x3e\x3d\xc3\x35\xb6\x26\x32\x62\xea\xfc\x96\x6e\xbc\x94\x8d\x99\x47\xb0\x37\xda\x33\x5a\xc5\x2e\xd2\xe4\x72\x23\x17\x32\xb4\x85\x30\x63\xad\xdd\x7e\x9b\xd1\x20\x89\x43\x2f\xbd\xf9\x73\x55\xcc\x6c\x17\x5b\xa4\x1e\x1a\x81\x3f\x37\x5b\xfc\x79\xfb\xd4\xdc\x33\x4a\x4a\xc5\x49\x7c\xe0\xa7\xd4\xfb\xc0\x64\x18\x73\x65\xf6\x80\xe2\x0d\xd6\x0a\x7d\x7a\xf8\x8d\x1c\xe2\xfc\x6a\x1f\x39\xb6\xc4\xbc\xa4\x57\xa7\x6f\xcf\xde\xfc\xf0\xec\xec\xd5\x9b\x6f\xba\x42\xac\xca\x20\x20\xda\x0c\xbe\x92\xc3\x4c\x40\xdb\x64\xaa\x03\x8a\xcc\x39\x2d\xd2\x68\xf3\xbd\xe3\x15\x74\xb1\xbc\x26\x81\x90\xa1\xc5\xc5\x49\xea\x8f\x7c\x83\xdd\xc7\xb2\x22\x26\x3a\x10\x4b\x16\xe8\x8f\xd7\xb0\x38\xf7\xdf\x55\x67\xb0\x59\x77\x7c\x2f\xc3\xa6\xe3\x11\xbc\xe0\x91\x32\x03\x2c\xa6\x08\x13\xa7\x0a\x93\xa9\x23\xae\x65\xac\xb3\xf2\xaf\x21\x36\xc0\x87\x61\x43\xa4\x71\xc1\xdc\x00\x6a\x40\x64\x30\xdc\x0c\x58\xd1\xd8\x80\x2c\x4f\xdb\x92\xb6\x15\x87\xbb\x1e\xb6\xa7\xc5\x31\x1e\xa7\x91\xa9\x7e\x99\x79\x17\xb4\xbc\xed\x29\xa6\x0d\xef\x3d\x5a\xc0\x00\xee\x0d\x60\x5b\x12\x39\x59\x48\x14\x1e\x22\xa2\x2d\x0c\x0e\x0f\x61\xaf\xea\xd1\xb0\xd6\x20\x73\x44\xe5\xf6\x8e\xe0\x6f\xf1\xa7\xbd\x16\x08\xd6\x30\xf7\xa9\x87\x90\x7a\x51\x46\x07\x60\x4d\x0c\xd8\xeb\x02\xb5\x67\x40\x0c\xc3\x87\x2d\x58\x42\x58\xea\xf3\x18\x41\xe7\x7a\xe9\x4f\x2d\x92\xed\xd5\x6b\x0d\x39\xb7\x71\x31\x29\x2e\x02\xa3\x47\xf0\x37\xbf\xd1\x05\x6d\x4d\x86\x6a\xb2\xe0\x41\x53\x45\x3d\xa4\xb7\x0f\xf3\x39\xc4\x97\x2b\x3c\x55\x74\xaf\x9a\x3c\x0c\xc0\xc7\x5b\x36\x26\x8e\x01\x51\x68\xc0\x1e\x83\xb8\xd7\xc1\x84\xef\x2e\x37\x2b\x66\x68\x9b\x83\x7d\xd1\x50\xac\xe3\x6a\xdb\x9e\xb2\xcf\x76\x94\xc1\x1c\xe2\x51\xd6\x26\x31\x7f\x4d\xf1\x35\xd5\xbd\x0e\x60\x8e\x8d\xb2\x42\x01\x0c\xe1\x09\x83\x85\x47\x0f\x87\x70\x04\xb1\xba\x1a\x8f\xba\xab\xdf\x71\xc6\xb6\xdf\x7d\x6a\x53\x03\xfb\x3b\x60\xaa\x53\x9d\xfb\x8a\x71\xb3\x02\x57\x65\x46\xc6\xfb\xf7\xd1\x63\x37\x71\x77\x52\x0f\x15\x08\x9b\x58\xc0\x23\x30\xe1\x89\xe8\xd3\x41\x6c\xb0\xd9\x3e\xeb\x0a\x79\xd8\x46\x00\xc4\x24\xdb\xcb\x72\xd8\x78\xf9\x12\xbd\x9c\x22\xb2\xde\xe6\x0f\x54\x3c\x9a\xcf\xe7\xf0\xf7\xbf\xc7\x5a\x84\xa0\x38\x52\x09\x78\xe6\xc2\xc0\x63\x95\xf1\x43\x88\xe0\x31\x1b\xad\xd9\x97\xc3\x39\x2e\xa8\xd1\xfd\x7d\x95\x7e\x54\x3d\x63\x00\x34\xec\x83\x92\x85\xe7\xf1\x3b\x7d\x91\x2e\x76\x41\x07\xcb\x40\xcd\x36\xf6\xc9\x72\x36\x9f\x8a\x61\x1f\x37\x2a\xb7\x2a\x15\x9b\xd6\x94\xd8\xa0\xf9\x2a\x17\xa0\x47\x39\xcd\xf2\x41\x0d\x20\x6a\x8f\x30\x10\xf2\xf2\xf5\x00\xb6\xdc\xbc\xa2\xc8\x68\x88\xc6\x45\x21\xcb\x53\xf9\x24\x17\xee\x17\x9c\x83\x33\x46\xc9\xe0\x6d\xb1\x22\x5c\xd2\xc9\x50\x96\x92\x36\x05\x76\xea\x9a\x0f\x73\xf0\x79\x7e\x98\x6e\x62\xa9\x8c\xc2\x71\x9c\x61\x0c\x80\xf7\x99\x47\x08\xa3\x8c\xfb\xcd\xfc\xe2\xc0\xc6\xe2\x87\xc7\x17\x7e\x84\x7f\xcd\x6c\x8e\x42\x5e\x0f\x0f\xe1\xe9\x6a\x95\x5c\x2b\x03\x89\xcd\x8b\x05\xb9\x29\x24\x66\xb9\x12\xaa\xb1\x4f\x68\x08\x49\x87\x2a\xb6\x96\xd5\x74\x26\xed\x09\xc4\x70\x84\xc4\xd1\xb0\x52\x90\x03\xa9\x80\xbc\x6f\x10\x61\x1f\xb5\x63\x9f\x79\xfc\xf5\xf8\xb4\x02\x9e\x42\x8e\x19\x79\xae\x92\x28\x84\x4d\x92\x0b\xe2\xe0\x8d\x05\x9b\x94\x0a\x12\x25\x8b\x2a\xb8\xc7\x3c\x9c\x53\xef\x94\x51\x1e\x29\xe5\x38\xfb\x62\x11\x4d\x4d\xf8\xf8\xa6\x98\x48\x44\x71\x8d\x01\xcc\xe5\xe6\x2e\xff\xc2\x8b\x56\x10\x5e\xd2\x22\xe4\x71\x7e\x4c\xdf\x9d\xef\x1f\xbc\xd3\x50\x7e\x57\x4b\x79\x8f\x59\xca\x8f\x1f\x15\x24\xbd\x37\x40\xd6\xbc\xa1\x17\xc7\xdb\xcd\x00\xf6\xde\x1f\x3c\xd9\x83\x7d\x18\x00\x33\x21\x7b\xe7\xec\x7b\xb1\xef\x41\xa8\x06\x33\x5d\xcc\xf3\xd9\x87\xbd\x77\xfb\xac\x95\x7d\x25\xa7\xf6\x06\x4f\x8e\x7e\xfe\x79\x84\x67\xaf\x58\xd9\xe1\x93\x3f\xee\x19\x3e\x3c\x02\x7b\x0a\x4f\x60\x2f\xda\x83\x23\xa1\xd7\x5c\xdd\xb3\x3c\x1d\x6a\x25\xa8\x4f\xf3\x15\x3e\x82\x86\xc3\x98\x85\xf0\x72\x7d\x9b\x51\xa3\xdb\x36\xe8\x0d\x9a\x88\x35\xde\xbf\x8f\x75\x53\x8a\xcb\x83\x03\x38\x7c\x6f\xfe\x3c\x32\x1f\x7c\xfc\x79\x74\x68\x20\x05\x8a\xe4\x24\x8f\x81\x8c\xd5\x3e\x42\xf1\x51\xb9\x2b\xb7\xdc\xcf\xa2\xf1\xe3\x4a\x42\x73\x1f\x2e\xc2\xf5\x48\x69\xe7\x8c\xc6\x65\xd3\x10\x59\xe0\xfa\x3a\xa5\x57\x34\xce\x61\xe5\xe5\x6c\x12\x51\x6e\x75\x14\xfd\x4d\xf0\x2c\xc4\x15\xc5\x99\x84\xd8\x19\xa5\x04\xc5\x65\x5c\xec\xee\x6f\x35\xdf\x35\xb0\x7c\x05\xcb\xaf\x31\xe5\xa2\x27\xdf\x7a\x8c\x7c\x28\x96\x6c\x24\xf7\x0d\x44\xa1\xd7\x7d\xfd\xae\x58\x41\x4e\xa2\x38\x7f\xd2\x76\x35\xb9\xcf\xc0\x90\xc4\xb3\x11\xaf\x16\x83\xbd\xd1\x1e\x53\x97\xc7\x1c\xd7\xaa\x13\xa5\x98\xb1\x79\x34\x8a\x97\x62\x7e\xd1\x30\x3d\xca\x06\xa3\x82\x2a\xd4\x4b\x83\xe5\x00\x0e\xe9\x61\x04\xbc\x49\x53\xef\xc9\xd2\x9c\xa6\xeb\x28\xae\xd6\xb6\x34\x86\x8b\xa2\x76\x0d\xb1\x5b\x51\x9b\xcc\x14\xf6\xe7\xb0\x5f\x31\x05\x22\x66\xd3\x55\x12\x28\xb1\xef\xd2\xe7\x33\xc4\x01\x77\xae\x9a\x44\x87\x72\x8b\x6a\xd9\xba\xba\x13\x62\x76\xd8\xc6\xbc\xe0\x41\xb1\x63\xba\x06\x5e\xc1\xd3\x82\x16\x2b\xea\x61\xa8\xeb\xaf\x34\x4d\x1a\x43\x03\x77\x08\x45\x82\x8d\x86\x9c\x46\x42\x4e\xf9\x3d\x8e\x2a\x46\x56\x4d\xe4\xa9\x17\xad\x3a\xdb\x58\xd1\xb8\x8e\x7e\xb3\xb9\x83\x83\x15\x8d\xab\x26\x1b\xe4\x6b\xaa\x09\x9b\xe0\x32\x90\x82\x2d\x2d\x09\x42\x73\xde\x56\xca\x16\x16\x6a\x31\x8a\x32\xbc\xf2\x58\x58\x85\xc2\xb1\xb9\xa2\xa9\xda\xa8\xb1\x16\x25\x3b\xa8\x1c\x7d\xbf\x92\xe1\xe4\xce\xff\xe5\x9a\x99\xf9\xca\xe0\xb3\x6e\x0a\x73\xae\xb7\xa8\xcc\x32\x3c\xe0\x76\x55\x29\x6a\x14\xef\xb2\x3e\x50\x0f\x32\x87\x87\xf0\x4a\x2c\x38\x3e\xd1\xa9\xd8\xe3\x72\x55\x4f\x3b\xaa\xa0\xb8\x2b\x57\xfb\xc5\x87\xcf\x25\xc4\x9c\xf1\x72\xb5\x52\x33\xec\x87\x62\xed\xb6\x8d\x4b\x53\xef\x8a\x55\xd9\x2e\x94\xfe\x4f\x7b\x17\x4a\x0d\x9d\x73\x81\x90\x09\x8a\x29\x4e\xcf\x80\xd0\x31\x77\x12\xc0\xdf\xe9\xa7\x85\x67\xa9\x17\x67\xe8\xad\x31\x87\x4f\x5b\x8c\x16\x49\x13\x0a\x07\x5a\x6f\x0d\x45\x8d\x88\xd5\xb8\xc6\xd0\x6f\x9e\x00\xaa\x18\xaa\x5c\x9e\xc0\x05\xcd\xf9\xbe\x7f\x3c\xc7\x46\xf9\x22\x46\x11\x66\x0e\x12\xba\x58\x44\x01\xae\xa4\x89\x84\x4b\xaa\x16\x22\x9c\xd2\x53\xae\xad\xf0\xa7\x72\x7b\xa9\x66\x2e\x2f\xdb\xc8\x88\x99\xe2\xaa\xbc\xbe\x42\xc4\xcf\xa2\x76\xce\x7f\x59\xc1\x68\xc8\x08\xcd\x0f\x80\xd4\x6c\x3c\xb7\xda\x4a\x75\x28\x3e\x95\x29\x3b\x90\x90\x2a\x9a\x7e\xd8\xd9\x36\x70\x0e\x2b\x1a\x8e\x8c\x7a\x2f\x39\x12\x3a\x18\x1a\x7f\x07\x14\x46\x32\xea\x00\xc3\x58\x52\x36\x78\xa0\x1d\x57\xca\x56\xbb\xa4\x9a\xc3\x3b\x98\x23\x11\x6e\xe3\xa4\x71\x7a\x3e\x84\xe8\xe0\x00\xc7\x03\x46\x85\x3d\x73\x4f\x3f\x91\x96\xc9\xa7\xf6\xb8\x95\x48\xab\x6c\x86\x5a\xc9\x7b\x14\xbc\xd1\x8f\x66\x18\xe3\x93\x36\xd2\x0d\xaf\xdf\xbc\x7a\x7d\xfc\xe6\xec\xc5\xf1\x5b\xa9\x4c\xb5\x94\x21\x76\xb1\xc2\xbc\xd8\xcf\xfa\x50\x55\x0a\xe7\x94\xbf\xfc\xf0\xba\xde\x6a\xf3\x3d\x2e\xe3\xce\x65\xf7\xb1\x59\x02\xf7\x7d\xcd\xc1\xd2\x97\xe0\x2b\xa4\x73\xb0\xf5\x45\x8a\x8d\x73\x73\x70\x7a\x0a\x09\x84\xc6\x3d\xc5\x70\xe9\x74\x0e\x93\x9e\x62\x02\xf9\x69\x4f\xb1\xa2\x07\xae\xaa\x9c\x58\x52\x9d\xc3\xec\xa1\x76\x0d\xe2\x19\x6e\x2c\xbd\x4c\x29\x44\xf1\x22\xc5\x73\x8a\xf9\xea\xe6\x00\xf7\xa4\x32\x57\x47\x1c\xce\x38\xb8\x8e\x42\x0a\x19\xcd\xf3\x28\xbe\xc8\x74\xcb\x08\x4f\x83\x80\x6e\x30\x1a\x2c\x8e\xfc\xe0\x52\x46\x19\xd9\x80\x55\x94\xe5\x86\xf0\x33\x62\xdc\x15\xb1\xf6\xe2\x9b\xc2\xcc\x96\x67\xae\x40\x64\xc6\x8d\x68\x06\x49\x2a\x37\x80\x59\x5f\x99\x3f\x96\x41\x4a\xb3\x0d\x0d\xf2\xe8\x8a\xae\x6e\x8e\x34\xf8\xb4\xf6\xae\x56\x8b\x15\xd5\xf2\x44\xb1\x4e\x57\xad\x4f\xd4\x41\xd4\x43\x1c\x7a\x10\xae\x0e\x40\x63\x03\x5e\xb9\xd4\xc2\xff\x39\x7f\x27\x43\x3a\x60\x88\x34\xf1\x69\x10\x61\xa7\xcf\xb9\x08\xa7\x96\x10\x4d\x84\x37\x6a\xf4\x77\xf4\xae\xd1\x59\xdc\x74\x56\x7d\x14\xb8\x9e\x26\xf1\x01\xee\x1c\x8b\xbe\x3e\xd2\x07\xa4\xc0\xba\x78\x43\xba\xb0\x17\xbe\x61\x85\xbd\x38\xe2\xf2\xb1\x64\x99\xd8\xfe\x24\xf6\xed\x10\x26\x82\x66\x1d\x86\xd8\xdb\xf3\x59\x30\xe4\x85\x71\xa8\x89\x4c\xf9\xe1\xeb\xe1\x3a\x91\xa9\xaf\x33\xeb\x01\x74\x88\xad\x58\x0f\xae\xfa\xc1\x55\x52\x06\xf1\x96\x76\xaf\x33\xb7\xf8\xd7\x5c\x48\x2e\x40\xf3\x29\xe1\xa7\x56\xf9\xfa\x8a\x72\x85\x4a\x77\xf9\xe8\xaf\xb4\x2e\x16\x45\xef\x5b\xe5\xdb\xcb\xcd\xdd\xe5\xd5\xeb\xce\x7a\x7c\x5a\x8b\xcb\x5a\x7c\xe4\xaa\x03\x69\x9f\xbf\x97\xb1\x49\x0e\x0f\x25\x57\x7b\xd9\x05\x6f\x84\x91\x94\xac\x9d\x97\xf2\xf5\x34\x0c\xe3\x88\xdd\x1f\x78\xce\x99\x4d\x1d\x86\x9a\xf6\x8e\x47\x17\xb5\x45\xd9\xe6\xa9\x81\x81\x65\x1a\xe0\xe0\xde\xac\xda\x36\xa2\xce\x3a\x7f\x6b\x9a\xce\x23\xdc\xf6\x5f\x37\x86\x47\xe0\xc0\x27\x1d\x5a\x2f\x2e\x62\x36\xd9\xab\x7a\x77\x28\x59\xef\x8c\xe2\x46\x26\x5c\xd8\x4b\xd2\x2a\x5d\x71\xad\x23\x6f\xc4\xc2\x76\x39\x9c\x54\xb7\x00\x54\x24\x0b\x2e\xd3\xb4\xdc\x2c\x9a\xa9\x97\x96\x9b\xbd\x83\x79\x23\xf7\xa8\x2c\x6d\x98\x78\xcc\x80\x4d\x7b\x31\x39\x6a\x9f\x79\x61\x9f\x14\x4f\xb6\xb6\x9f\x7b\x98\x7f\x4c\x1c\x6f\x6a\xbf\x4e\xd8\xeb\x73\xf3\x5d\xfb\x0d\x9b\x28\xcf\x21\x61\x73\x5c\x11\x73\x4e\xe4\xa3\xc4\x0a\xaf\xf1\x49\xbd\x3f\x7c\xae\x90\x34\x0e\xd3\x0e\x36\xd2\xfa\xce\x00\xae\x58\x1b\xe7\x9b\x77\x30\x84\x7b\x62\xda\xd9\xf0\x2c\xf9\xe7\x48\x05\xdb\xab\xe2\xa9\x51\x13\xa8\x77\x1e\xed\xef\xd7\xc1\x2a\xa2\x2a\x75\xe9\x2a\x0d\x5c\xc7\xb0\xdc\xda\xdc\xb3\x27\x64\x75\xd8\x84\xd6\x5a\x92\xbe\x52\x2c\x49\xeb\x2a\x37\x56\xa5\x9b\x55\xb1\xfb\x4b\x2f\x1b\xc0\x06\xe6\xb0\x57\xaf\x2c\xd6\x03\xe4\x65\xea\x2b\x83\xcd\xb9\x5e\x3e\xfd\x09\x97\xab\x37\xa0\x8e\xbf\xb7\xce\xd8\x5c\xb5\x97\xb4\xea\xcc\x49\x19\xeb\xe6\x8d\x8a\x6d\x3a\xd7\x15\x56\x43\x66\x77\x27\x22\xd7\x41\xdd\x8e\xc6\xf5\xba\xb7\x23\x71\xad\xae\x96\xc2\x6e\x27\x7d\x9b\xe7\x28\x76\x25\x6f\xad\x9e\x22\xc8\x5b\x77\xed\x5a\xde\x52\xb3\x7c\xaf\x9f\xa7\xf3\xdb\xf0\xbd\x4a\x29\xde\x75\x30\xac\x81\xdd\xed\x38\xd6\xa8\x7c\x3b\x96\xd5\x2b\x6b\xb7\x65\xf0\x90\x46\x86\x29\x32\x06\x57\xfa\x95\x29\x51\x4e\x62\x39\xb3\x9b\x48\x22\xe4\xbd\x60\x7c\x53\x2e\xce\xc9\xbb\x9d\x94\xaf\xf8\xd4\x0e\x9d\xb0\x26\xd4\xcb\xca\x8d\xe2\xfc\x94\x07\x6b\x4c\x5f\xbc\x6d\x57\xe5\x88\x5d\x43\x98\x79\xb7\x76\x41\xba\x7e\x4a\x66\x50\xc7\x88\x19\x63\xbe\xba\x76\x70\x05\x47\x70\x05\x98\x98\x6d\x87\x78\x82\x4a\x0f\xce\x35\xa7\x7c\xa1\x19\xc7\x2b\x0f\xae\xb4\x67\x0e\x77\x99\x38\x70\x88\xba\x79\x81\xd0\x0a\xe5\xdc\xa0\x57\x3b\x38\x9a\xb7\x34\x63\x58\x27\xf0\x62\x56\xcd\xa7\xb8\x10\xb0\x5b\x9d\x5b\x9a\x3c\x56\xe7\xeb\xaa\xcd\x01\xe9\xd6\x1b\xb2\xbb\xde\x54\x67\x80\xfa\x95\xa6\x3a\x02\xf3\x9f\xa2\x31\x58\xfb\x8a\x2b\x82\x7c\x76\x69\x20\x21\xb6\xbb\xe2\xb0\x4f\x89\x54\x73\x87\x1e\x43\x64\x1f\xf6\x1a\xd2\xb2\x67\x30\x80\x77\xd4\xc1\xe6\x49\x30\x95\xf6\x89\x39\x70\x6b\xda\xaa\x98\xb4\x76\x0d\x1d\x1c\x4a\x67\xa2\x88\x1d\x86\x01\x84\xd2\x2d\xc7\x57\xb8\x18\x76\xef\xde\x15\x7c\xfc\x28\x7e\x90\xea\xab\x7e\xbf\x4b\xd7\xe6\xaa\xda\x19\xa3\x41\x75\xf6\x89\xb5\x32\x84\x27\x9a\x73\x45\x70\xa4\x3c\xd1\xa4\x5d\xfc\x90\x99\xae\xd9\x51\x51\x13\x05\x91\x81\xe3\xee\x02\xc0\x1b\x6b\xb3\x5c\x84\x2c\x3e\x93\xe5\x02\xca\x6d\x59\x5e\x83\xc1\x4f\x59\xc1\x65\x5c\x1e\x9c\x3a\x82\xbf\xf1\x87\xdd\x92\xc2\x1b\xff\x3a\x92\x52\x9e\xd6\xba\x77\x8f\x01\xb9\x7f\xbf\x40\xb3\x9a\x5f\x89\x07\x72\xbe\x26\x8d\xba\x0b\x4c\xee\xdf\x87\x7b\x02\x6e\xb5\x26\x29\xeb\xfe\x5e\x9b\x14\x7b\x45\x72\x18\x25\xfb\xff\x93\x64\x8a\x77\xa2\x2d\x53\x72\x08\x4b\x33\x6b\x98\xed\x34\x6b\x90\x01\xdd\x6e\xb0\x95\x6b\xde\x6e\xf8\x94\x6a\x6a\xe7\x0b\xb3\xce\xb1\xa2\x7e\xb4\x65\xd7\xd9\x82\x54\xab\x4d\xd1\x7a\x4c\xef\x33\x27\xbc\x75\x60\xb7\xa3\x6b\xbd\xee\xed\x28\x5b\xab\x7b\xe7\xd9\x6e\xf3\x18\xcd\xae\xf4\xad\xd5\x6b\x53\x58\x84\xd5\x8a\x48\xa7\x9e\x02\xa2\xa0\x20\x1b\x2f\xde\xdf\x77\x5e\xab\xdb\x46\x09\x7b\x72\x55\x37\x25\x1a\x55\x2e\x8f\xec\x5c\x7d\x31\x7b\xb0\x57\xef\xd4\x67\x78\x1b\x1c\xb9\x06\x91\x8b\x9d\xa1\xd2\x62\xa0\x7e\x69\xe9\x8d\x7c\x2e\xa5\xda\x7e\x7a\xbd\x4c\x32\x5a\xed\xb5\xcd\xa5\x13\x60\x62\x21\xa8\x0c\x9a\xe9\xd6\x99\xaa\xa4\x41\xda\x63\x2b\x3d\x71\xc0\xb5\xb7\x6d\x06\x01\x8b\xce\xad\xbd\xed\xab\xf4\x65\x14\x0f\xa4\xe0\x1d\xbc\x1e\xad\x72\x18\x3e\xfc\x42\xdd\x15\x47\xf5\xff\x81\xdd\x8d\xe2\x5b\x76\xf7\xe2\xae\xdd\x8d\xf2\x25\x78\xc5\xa9\x6a\xde\x6d\xfa\xdb\xa5\xb7\x62\xd6\x2d\x49\xe1\x02\xcf\x2d\xa5\x7c\x0f\x90\x89\xbb\x7b\x57\x34\xcb\xc4\x9e\x20\xa3\xd6\xed\x58\xec\x90\x0e\x37\x06\xab\xda\x88\x91\x45\x0b\x08\x37\x8c\xa4\xc9\x3a\xca\x73\x1a\x1a\xcd\x34\x37\x03\xdc\x05\x99\xe1\xc6\xa5\x62\xeb\x96\x0c\x1f\x77\x71\x61\xc8\x7d\x93\x26\xe1\x65\x40\xc3\xa1\x8e\x03\xe7\xe1\x46\x3a\xe8\xf4\x5d\xad\x9d\xd1\x8e\x26\xbc\x06\x70\x8f\x13\x68\x30\x6c\x22\xdd\x32\xe5\xe1\x46\xb6\x4a\x1d\x35\x1b\x86\x5c\x5f\x6f\x47\x27\x4d\x29\x48\x82\xaf\x73\x18\x74\x07\xd0\x37\xc9\xb5\xf5\xcb\xd8\xc6\xec\x67\x96\x29\x7f\x14\xf1\x82\x42\x92\xc6\x36\xf8\x51\x5e\x4e\xe7\x63\x43\x6c\xd6\x31\xe1\xd1\x1c\xb7\x0a\xcf\x4c\x73\x4a\x66\x33\x6b\xec\x4c\x1d\x73\x36\xb3\x5a\x03\xe4\x33\xdc\xfe\x1a\x2d\x78\x06\xbc\xb2\xc7\x82\xbf\xf2\xf6\x33\xdb\xe2\x97\x36\x73\x8a\x85\xc9\x3a\xa6\x59\x3b\x85\xc4\x8b\x05\x44\x39\x84\x09\x26\x1c\xca\xb2\xcb\x35\x26\x10\x59\x51\x2f\xcb\x05\xb6\x75\x01\x32\xf8\xc1\x80\xeb\x28\xa3\xad\xf2\xb6\x89\xe5\x5b\x6d\x98\x5b\x47\x90\x86\x09\xb3\xf5\xde\x36\x0d\x4c\x09\x5d\x3d\xb1\xf0\x02\x4b\x9e\x81\x4e\x3c\xc1\x7c\x71\xa3\x16\xd9\x79\x57\xc6\xb6\x1f\xe5\x62\xf2\x53\x27\xc4\x83\x82\x31\xe2\x36\x06\x04\xd9\x18\x1d\x9a\x6b\x09\xa5\x9d\x10\xf9\x05\x07\xa0\x81\x89\x06\xa3\x01\xac\xb9\x78\x50\x2c\x14\xb4\xf0\x92\xa8\xf0\x11\x4c\xfe\xc4\x15\x57\x26\xa8\xf6\xbe\x2b\x00\xb8\x55\xf5\xf6\x92\x43\x91\xbd\xbc\xc4\x26\xdc\xa8\x46\x54\xbc\x74\x19\xb7\x14\x53\x03\x3e\x18\x70\xd5\x5e\x9d\x01\xfd\x4a\x10\xfb\xf0\xdd\x6d\xea\x77\x0c\xdd\xd6\x31\x8d\x57\xa7\xc7\xaa\xdd\x58\x21\xe6\xfa\xdd\x68\x8f\xbf\x31\xa3\x58\xb8\x5a\xc4\xc1\x69\x6d\x6b\xc5\x2e\xdc\xa8\x03\x2c\x1f\x60\x5e\x66\x93\x64\x90\xe0\x50\xda\x96\xa5\xc0\x85\x79\x21\x7c\xa2\xd0\xb5\xa1\x50\xdc\x3f\x96\x41\x76\xb9\xd9\x24\x29\xa6\xaa\xe0\x66\x65\x74\x41\xf3\x37\xc8\xaa\x7f\xd3\x9c\xdc\x28\x5a\x91\xa6\x66\xea\xaa\xdd\x7b\xf7\x3d\x98\x6b\xea\xf1\x13\x18\x3f\x44\x71\x6e\x5b\x3c\x70\x06\x1f\xe0\xc1\x1c\xac\x9d\x36\xc3\xf1\xdd\x6f\x1f\x1e\x76\xb7\x2e\xe8\x20\x0c\xc3\x51\x5f\x39\xa1\x04\x9b\xe4\x7a\x60\x19\x60\x5b\x43\xa6\xd3\x4c\x94\xe5\xc7\x16\x19\x0e\xab\xdb\x74\xac\x61\x1f\x50\xc2\x3e\xfc\xaf\xf6\x0b\xd7\x93\xc2\x20\x97\x5f\xee\x88\x2f\x5e\x7f\x44\x6e\x85\xe4\x2e\x1f\x0d\xfe\x7d\xa0\xc5\x70\x53\x98\x49\xb5\xa4\x15\x1f\xb1\x5a\xf9\x0e\xcd\x07\xaf\xb7\x0f\x03\xef\x1c\x37\xc2\xbf\x2b\x7a\xd6\x21\x1d\x50\x8c\x60\xcc\xd9\x66\x66\x25\xf3\xd6\x9b\x15\xa6\x8d\xee\xc3\x93\x8d\x69\x57\x8a\x31\xad\xaf\xe2\xeb\x34\xf1\x3d\x3f\x5a\x45\xf9\x0d\x1b\xc9\x72\xb8\x82\xc7\x73\x98\x51\x32\x36\x5a\x39\x44\xda\xb5\x6b\x4d\xc1\x61\xab\x75\xf8\xfb\x1c\xcc\x91\x69\x9a\xae\x01\xd1\x88\x8e\x80\x40\x14\x03\xb1\xc6\xdd\x84\x17\x51\x11\x81\x48\xef\x0e\x51\x10\xe7\xf6\x76\x55\x55\xab\x73\xaf\x68\xf1\xf1\xf8\x6d\x98\xfe\xb9\xd9\x71\x26\x53\x2a\xcc\x99\xcc\x2a\x90\x9e\x0a\xfa\x2d\x96\xcd\x8f\xc4\xd9\x39\xb8\xb3\xfa\x67\xe7\xda\x83\x2b\xf8\x13\xe6\xaa\x1d\xb2\x5f\xb7\x04\x52\xec\x1e\x2d\x60\xec\x42\x3a\xdc\x99\x6b\xf5\x10\x41\xfb\x56\xff\x86\x8d\x93\x1f\xe0\x90\x81\xd6\x8d\x1a\x45\x22\xf2\xf6\xa0\xc1\x07\x77\xbc\x2b\x57\xad\xc6\xf2\x8a\x40\x6b\xdc\x90\x6a\xf7\x9e\xf7\xf2\x2f\x17\x8b\x66\x4a\x16\xe9\x23\x8d\x2a\x12\x54\x31\x80\x4c\xbf\xf4\xf0\x21\xae\x9f\x33\x6b\x4e\xa1\xe3\x1a\xf5\x17\xe2\x71\xaf\xd1\x96\x2a\x09\xf7\xd2\x92\x20\x09\x33\xe9\x7c\x89\x51\xe5\xae\x06\xfb\x4e\x86\xf0\x0a\x03\xfb\x03\xae\xf3\xf7\xc1\x26\xc0\x7d\xc0\x3a\xe9\xf0\x7a\xc7\x4a\xd5\x1b\x05\xb4\xa7\x2a\xeb\x9f\x02\x80\xd5\x00\x50\x83\x6e\xd7\x5e\xde\x12\xb2\xf3\x0e\x6f\x39\x99\xd4\x20\x8e\xf1\xa1\x8b\xcf\xf8\x93\x89\xee\xcc\x44\xf1\xb9\x83\x15\x56\x88\xf5\x74\x38\x0a\x92\xcd\xcd\x80\xf9\xc1\xad\x03\x5e\xcd\xcf\xed\x2d\xe3\x7f\x8e\x6d\x9b\x7e\x3d\xdb\xa6\x01\xbd\x73\x00\x0f\xaa\x20\x1e\x71\x6e\xbf\x70\xa0\x46\x52\x7d\xec\xfa\x87\x8c\xca\x93\xb7\xa3\x62\x69\xa4\xc8\xd4\x07\x49\x5a\xb4\x14\x65\x32\x06\x18\x8b\xe9\x4c\xeb\x07\x42\xfe\xee\x45\x5a\x1b\xa7\xb0\x85\x3a\x7a\x30\xf5\xae\xcf\x65\x07\x5d\xa7\x3c\x16\x62\xcd\x56\x88\x7d\xc0\x37\xa0\xcd\x4b\x31\xf9\x0c\xaa\xb1\xa9\x52\x70\x7e\x70\x10\x29\x5c\x84\x70\x03\x7f\xea\x3c\xb6\x53\xdd\x8d\x5f\x9d\x1d\x14\x87\xe9\x44\xfa\xcd\xac\x9e\x80\x2f\x6c\xa6\xdb\x2d\x7a\xf7\x81\x8d\x6c\xe1\x46\x4b\xb4\x2b\x1e\x1d\xc7\xac\xf1\xe7\xd2\x89\x97\x70\xa3\x71\x6d\x02\xee\x2c\x49\xb3\x7a\x26\xcb\x57\x68\x46\x55\xe1\x68\x65\xe7\xde\xd0\x75\x72\x25\x9d\x8b\xa4\x45\xf2\x37\x91\x8e\x3d\xa5\xaa\x5c\xc7\x92\x28\x70\x2c\xe6\x78\x30\x33\x18\x6d\x92\xcd\x60\x68\x40\x74\x70\xa0\x1c\x53\xc5\x71\x16\xcd\x49\xbc\xa8\x3c\x6e\xaa\xec\x2e\xae\x9f\xf7\x1f\x67\xd3\x79\x29\xa2\xa7\xc5\x21\x53\x4d\x47\x79\x6a\xd9\xf0\xd7\xcb\x2c\xaf\xb2\x98\x96\x0c\x5e\x69\xce\x8d\x55\xf9\x4a\x0e\x08\xd2\xc4\x94\x68\x82\x97\x8b\x32\xaa\x50\xf9\x34\x96\xce\xe5\x40\x81\xbb\x8c\x73\x91\xcc\x4f\xce\x9c\xd6\x3a\xd9\x16\xa0\xc0\xa9\xcf\xcf\x62\x3a\xec\xd1\xa8\x0b\xdf\x88\xa7\x7c\xbb\x42\xfd\x30\xdf\x3d\xe4\x03\x0f\x31\xd9\x17\x91\x62\x25\xc2\x1b\x9c\x75\x88\x0a\x3a\xe5\x72\x8e\xde\x5e\x5a\x95\xac\x96\x8e\x91\xd5\x28\x03\x07\xaa\xa3\xce\x0a\xf1\x65\xe6\x45\x77\x4e\x11\xdf\x31\x91\x09\xb4\x09\x94\x58\x91\xc6\x8a\x95\xb4\x28\x32\x1c\x0c\x1f\xd6\x4f\x49\xbd\x7e\xf3\xe2\xdf\x9e\x9e\x1d\xc3\xf3\x1f\x4e\x9f\x9d\xbd\x78\x75\xfa\xb6\x71\x88\x4a\x98\x09\xaf\x4c\xb6\xc5\x43\xfc\x8c\x51\xbe\x97\xd1\x17\x98\x37\x44\xf7\xf6\xd5\xa5\x74\xe8\xb1\xba\xe1\xb6\x75\x5a\x5e\x94\x35\x04\x48\x83\xe7\x7e\x54\xc5\x6f\xc3\x22\x00\x96\x1a\xb0\x35\x60\x1b\x18\x70\xa3\xde\x10\x2d\x9f\x97\x87\xbd\xd1\x1e\x0c\xdb\xe5\x30\x96\xd5\xb8\x36\xa2\x4d\xd8\x75\xcf\x7e\x4b\x9e\x06\x85\x13\x03\x33\x5c\xc8\x47\xf2\xf3\xe4\x24\xb9\x2e\xee\x18\x6e\xc7\x98\x4f\x93\xf8\x20\x52\x1d\x39\x17\x02\xf5\x58\xb7\x81\xe0\x43\xcf\xb2\x23\x14\x67\x73\x8b\x14\x82\xe5\xbd\x35\x6d\x01\x6e\x2e\x7b\x6a\x53\xd6\xe8\x72\x0c\x34\x4b\xdf\xb4\x82\x89\x9c\x3c\x8a\xa2\x5b\x98\xc3\x0d\xc6\x6e\xa4\x53\x90\x78\xf6\x59\x51\xb8\x89\xe8\x87\xee\xb1\x8d\x21\xed\xe1\x32\x4b\xb5\x72\x81\x39\x16\x63\x48\x69\x96\xf3\x98\x3b\x2d\x4f\x53\xc0\xc6\x4b\x73\xf0\x6f\x78\x5a\x55\x91\xd0\x56\x05\x5f\x24\x7b\xf4\x6f\xf0\x9a\x0a\x3c\xe6\x8b\x8e\x52\xc8\x75\x61\xc3\x18\xde\xa6\xf2\x0d\x6a\x6e\x9e\x7c\xcb\x85\x7d\x50\x24\xff\xe7\x77\xaf\xf2\xc3\xbc\x67\x45\xac\x0a\x8f\x42\x0e\x0d\x3c\x09\x39\x14\xe9\x24\x78\x3d\x25\xbd\xd1\x60\xdc\x8c\x82\x1d\xb3\x13\x94\x83\xff\x92\x16\x27\xe1\x19\x9d\x54\x72\xb8\x6d\x20\x5d\xea\x2b\x53\x53\x0d\x4a\x14\x3d\xd0\x39\x6c\x03\xf5\x41\x7f\xc5\x08\xad\xcd\x5c\xf0\x10\xb6\xcc\xcd\xf9\xf0\x0e\xf8\xc8\xb3\x15\xc3\x71\xb3\x4d\x9e\x45\x6a\x8b\x83\x54\xb9\xef\x7f\xcf\x6c\xe6\x57\xea\x19\x92\x0f\x0e\xa8\x32\x71\x44\xbb\xa4\x38\x1a\xaf\x30\xc4\xe5\x29\x73\x95\xe8\xa0\x61\xc3\x2c\xc0\x34\x14\xe7\x68\x30\xb1\x71\x90\x97\x49\x51\x55\xc7\x62\x33\x91\x64\x56\xad\x3f\x61\x74\x85\x09\x71\x6e\x0c\x8c\xbe\xa7\xeb\x4e\x61\xd9\xf2\x33\xfd\xaa\x21\x04\x5f\xa4\xaa\x8c\x1c\x98\x05\xa0\x53\xac\x42\x4c\x5a\xb0\xcf\x6c\xea\x7e\x2b\x6b\x81\xc8\x2e\x5a\xe6\x7d\x45\x17\x40\x44\xf2\x4a\x97\xa0\x38\x8b\xc4\xef\xc4\x4a\x16\xf2\x9b\xa5\x97\x17\xe9\xcb\x8b\x24\x58\xcd\x2b\x20\x22\xe4\xc7\x79\xd8\x70\xa3\x98\x20\x16\xd4\x38\x6c\xc6\x92\x58\x8f\x53\xf8\xf8\x11\x42\x14\x89\x8f\x1f\x11\x02\x9f\x95\xdf\x53\xe6\x3c\xc0\x1a\x6b\x78\x04\x0e\x26\x90\x89\x8a\x62\xac\x6e\xca\xf7\x9d\x0c\x70\xc8\xe0\x49\x97\xc4\xd7\x01\xf2\x90\x6f\xde\xb4\xe1\x88\x47\xf7\x75\xf3\x86\x23\x66\xf7\xe1\x03\xab\x1d\xb1\xca\xcc\xc7\x2e\x60\x3a\xbc\x9d\x12\xf0\x84\x35\x88\x38\x1f\x30\x9c\xef\xe3\xce\x33\xfd\x94\xb2\x8d\x8d\x0b\x47\x30\x55\xac\x35\xa0\xa2\x30\xaa\xe0\x56\xb6\x52\xb1\xd4\xa7\xb9\xc9\xfb\x83\x70\xa3\xd8\xc7\x07\xe5\xc8\x91\xc2\x93\x86\xbd\xdb\x23\x7b\x06\x1c\xe0\xd4\xe1\x88\x2b\xaa\x5c\x4b\xaf\x77\x85\x4d\x61\x72\xaf\x59\x12\x4a\xbb\x56\x83\xde\x14\x32\x78\xb9\x41\x89\x5a\x53\x2f\x16\x67\xb7\xe8\x55\x94\x5c\x66\x42\xe4\x30\x17\x75\x52\x17\x38\xf4\xa3\xb3\x04\x54\x83\x28\x94\x26\xeb\xe0\x40\xc8\xdb\x43\xd8\xdf\x47\xeb\x15\xbe\x83\xc7\x50\x3e\xec\x9a\x60\xa2\x00\xf3\x21\xb8\x7b\x5a\x79\x2f\xec\x8d\xa3\xec\xef\x77\xa4\x09\xe4\x8d\x8d\x2e\x63\xee\xc8\x93\xce\x9c\x07\xbb\x3d\x55\xcf\xc5\x76\x4b\x53\x03\x25\xf5\xea\x03\x07\x4a\x1e\x33\xff\x0f\x75\x53\xaf\xe3\xd1\xc5\x08\xce\x1d\x03\xf0\x66\xb1\xf1\x3b\xf0\x69\x90\xac\x69\x06\x8e\xbf\xd0\xb5\xc1\x97\x49\x85\x68\xee\xed\xe1\xd4\x9f\x79\x13\x45\x16\x84\x32\xe9\x59\xb0\xf4\xd2\xa7\xf9\x80\xb1\x45\x9c\x1d\xd3\x66\x21\xaa\x4b\x37\x0e\x93\xb4\x3f\xf7\xd3\x59\x75\xff\x15\xa6\x80\xf3\xc2\x90\x67\x40\x8f\x2e\x1a\x32\x56\xdc\x58\x9f\xa7\xda\x8c\x07\xaf\x69\x8a\xe9\x49\xca\x14\xdf\xe2\x1e\x28\x91\xcd\x99\x86\x28\x83\x23\x78\xc6\x1a\x0c\x85\xa7\x83\x32\x2d\xb9\xe4\x55\xab\xec\x65\x6b\x43\x45\xb3\x03\x4f\xf9\x6e\x82\xb8\x38\x43\xb1\x45\x78\x1f\x1a\x43\x79\x01\x62\x7d\xb9\xca\xa3\xcd\xea\x06\x87\xab\x0f\x7c\x98\x52\xca\x31\xf3\xf5\xd7\x06\xe4\x74\xbd\x31\x60\xbb\x4a\x0c\xd8\x2e\x23\xcd\xc2\xb6\x97\xa6\x37\xfa\x75\x6f\x1c\x16\x84\x38\xa9\x4b\x7c\x58\x25\xe8\xb0\xfc\xa9\xba\x83\x4e\x53\x70\x59\xc4\xd6\xaa\xcb\xea\x3e\x2a\x55\x95\x8b\xd9\x16\x9b\x16\xd9\x53\x45\x9e\x0d\x6d\xee\x39\x44\x62\x7b\x1e\xbd\x93\xf1\xd0\x64\xe2\x40\x3c\xb0\x6c\x0b\x15\x55\x79\x36\x81\x61\xb8\x3f\xc0\x56\xf6\xb1\xfe\x03\xd6\x6d\x75\x71\x46\x74\x56\x63\x95\x94\x35\x06\x30\x80\xb5\x8c\x18\xc6\x63\xe4\x5f\xfb\x9c\x0f\x9a\xa0\x8e\x60\xd1\x80\xc3\x3e\xe4\x7c\xe7\x87\x1d\xf6\x11\x74\xa3\x1f\xf8\x5c\xa0\xbc\x54\xcc\x9b\x91\x0a\x3c\x52\x84\x10\xff\x84\x10\x77\xce\x01\x88\xf8\x0c\x61\x5b\x9a\x3f\xfe\x40\xc1\x48\xa1\x75\xdb\x4e\x3d\x96\x66\xb6\xeb\x8d\x97\xd2\x81\xd8\xaa\xe1\x9d\x18\xe0\x9f\x68\xe5\x3b\x32\x20\x58\x6f\x34\x63\x18\x78\x27\xcc\xb5\xd0\x54\x47\xa2\x22\x97\xbc\x13\x36\xb4\x9c\xc0\x13\x20\x70\x04\x07\xaa\xac\x75\x9d\x31\xa4\xca\x20\x72\x78\x26\x8f\x83\x7a\x27\x22\xef\x58\x57\x08\x9d\xe3\xc9\xd8\xc0\x30\x65\xff\xf6\x0d\x49\x02\x67\x56\xf4\x31\xaf\xa1\xc7\x5b\xfe\x60\xb2\xf5\x2f\x31\x42\x35\x9f\x14\x37\x7b\x33\x3e\xd4\x4b\xaa\x39\x9c\x5d\xfa\x39\x9b\x2e\xd6\x58\xdc\x65\xc4\x22\xcd\x60\x7e\x78\x08\x6f\x05\x2c\xf0\xf9\x45\x6d\x9e\x3e\x1e\xe9\x9d\x74\xd9\x0e\xef\xdc\x3b\x79\x07\x07\xca\x64\x7a\x20\x4c\x20\x2f\xf3\x08\x7c\xfc\x97\x53\x5d\x63\x2e\x78\xd1\x39\x30\xed\xc3\xbe\xed\x17\x2d\xf0\xda\xb7\x8c\xc2\x76\x24\xc0\x93\xbb\x78\xcf\x63\x1e\xe6\xfd\xfb\xf2\x11\x6e\xf2\x10\xbc\x22\xd2\xd8\x3f\x96\x6e\x8f\xca\x0b\x51\x0c\xb8\x39\x2a\x2e\x0d\x51\x0e\xa3\xd5\xa0\xa6\x98\x38\x69\x99\x19\xb0\xd1\x88\xe7\x77\x5f\x27\x29\x35\x20\x36\x70\x8b\x1d\xff\x7b\x62\xc0\x6f\x06\xfc\x16\x18\x90\xd2\x35\xfe\x39\xc1\xbf\xa6\x01\xdb\xc8\x80\xed\x89\x01\x37\x81\x66\x94\xba\x61\x2f\xff\xaa\x7e\x97\xf1\x61\x84\x79\xee\x37\xa3\xac\xd4\x18\x75\xe1\x62\x76\xa7\x69\x26\xe0\x71\x02\x8d\x2b\x15\x61\x16\xa4\x53\xef\xd4\x90\x2e\xb1\x4a\xc1\xd4\x84\xb6\xef\x6d\x03\x69\x72\xc0\xbe\xdd\x04\xe2\x1f\xed\x6c\x01\x74\xb9\xde\x75\x66\xa6\xda\x88\x79\xea\x9d\xb2\x76\xa9\x84\x65\x92\x82\x9f\xe4\xcb\x3a\xb6\xba\xbd\x35\xf7\x18\x11\x11\x3d\xfe\x2f\x73\xeb\xe0\x09\xa3\x09\x9f\x43\x61\x78\x1b\x38\xee\x47\xd8\x97\x21\x3c\xc1\x56\x8f\x3a\x57\xe9\x05\x7a\xff\xef\xff\x63\x32\xf4\xb6\x6c\x7a\xcf\xbe\x27\x29\xdc\xf0\xef\x05\x76\x88\x6f\x5a\x94\xae\x32\x09\x67\x45\x41\x2d\xea\xc8\x57\x19\x4b\xb3\x20\xf7\x13\xc8\x30\xc9\xef\x11\x64\x70\x08\xea\x65\xf7\xdd\x92\xe3\xfe\xd6\x0a\xda\x65\x8a\x8a\xbf\x31\x09\xfa\xad\xcc\x95\xd7\x7c\x2d\x22\x05\x70\x00\x37\xaa\x1c\xf3\x19\xdf\x3b\xb8\xcf\xb3\xd1\xe9\x86\xbe\x7b\x5a\x25\x64\x1f\x7c\x39\x07\xbd\x7b\xc4\xde\xfa\x51\xfe\x9c\x2f\x1f\x31\x6c\xe4\x6d\x84\xcc\x8a\x95\x2f\x6f\x1a\x2f\xd5\x00\x31\xfa\x22\x97\x53\x7a\x5a\x3a\x23\x88\xb1\xc2\x72\x25\x41\x04\x31\x12\x5c\xd9\xc0\xfd\xe5\x94\x3b\xe9\xb5\x7c\x21\x90\x2c\x40\x9d\xc9\xf2\xac\x9e\xf7\xaf\x5c\x46\x29\xb9\x96\xf1\xc1\x44\xf2\xe8\xb1\xcd\xa5\xd7\x13\x6e\x83\x66\x42\xd2\x1b\xb1\x08\x06\x7c\xfa\x83\x0a\x6e\xc2\xb0\xcc\x47\xaa\x64\x1d\xaf\xf4\xb8\x51\x07\x86\x40\x0f\x0e\x74\xec\xce\x3a\x57\xc8\x7e\x13\x6b\xeb\xba\x19\x2a\x6e\x9d\xe6\xd7\xc7\xdd\x36\x1d\xe4\x49\x3d\x46\xa9\x2a\x73\xc3\xca\xdc\x74\x97\x89\xf4\x07\x3e\x33\xb1\x7f\x49\x17\x8c\x38\x4d\xd2\xb5\xb7\x8a\x32\xca\xf4\x9b\x4d\x9c\x6e\x02\xc8\x12\x58\x46\x17\x4b\x9a\xe5\x90\xa4\x21\x4d\x45\x3c\x22\x59\xb0\x97\x51\x06\x8f\x79\x3c\x0b\x0e\xc1\x1a\xa9\x01\xc7\xf5\x05\x54\x51\x7a\x20\x4c\x1b\x4f\x03\xd9\xb1\x00\x76\x9a\xe4\x10\xd3\x80\x66\x99\x97\xde\x18\xe0\x5f\x62\x64\x6e\xe9\xc5\xe1\x8a\x42\x12\xf2\x59\x64\x91\xb0\xf2\xa6\xb0\x48\x65\x3b\x16\xea\x98\x66\x87\xe3\xe1\x61\x71\x63\xc2\x63\x1e\x59\x8a\xf7\xf7\x31\x81\x3c\xb3\x6e\x1c\xd6\x23\x19\x50\xc7\x69\x69\x0e\xa2\xcb\xe3\xc4\xd1\xae\x9a\x72\xde\x04\x38\x60\x73\xe3\xa2\x77\x26\xb7\xf5\x5a\xdb\xdd\x6a\xed\x22\x28\xb0\xa3\xd0\x69\xf2\x35\x6e\x99\xa0\xdd\x9c\xa8\xeb\xa4\x74\xcd\x01\x57\xf9\x34\x6f\x4e\xf4\x89\xf4\xd7\x0c\x8d\x94\xae\xf5\x99\x78\x41\xcc\xef\xc3\x50\x6c\x08\xc8\x13\x58\x7b\x1f\xe4\x0b\xcb\xbc\x0c\x56\x49\x7c\xc1\xfe\x55\xfa\x5a\xc5\xa7\x70\xf1\xb0\xd9\x47\xac\x0b\xec\xeb\x39\xfb\xc9\xf7\x43\x68\x0f\xb1\xdf\xfc\x95\x53\xb5\x98\x43\x6b\x0a\x95\xf3\x38\x53\x57\x24\x30\x41\x0c\xed\x1d\xc7\x67\x6f\x82\x73\xf2\x4e\xd6\x2f\x18\xb2\x9a\xfb\xfb\xea\x3a\x5a\x55\xd9\x88\xd4\xe7\x79\x1a\x79\x2b\xa1\xbe\xb1\x88\x00\x1a\xd2\xe5\xd0\xbc\x1d\x5b\xab\x29\xd5\x2e\x42\x3e\xe6\xcd\xc1\xe6\x6a\x62\x72\x95\x19\x8a\x7e\x11\xa6\xd3\xf4\x80\x8c\x35\x6c\x0c\x93\x0e\x25\x89\x7b\xa2\x8d\xb8\x5c\x84\xd3\xda\xf2\x16\x3e\x7e\xb9\x93\x90\x02\xbd\xcb\xc2\x27\x7b\xe5\x9c\xf8\xa6\x70\x8c\x6f\xb8\x5b\x7c\xd2\xb9\x41\x91\x1f\x72\x29\x5a\x7c\xb4\x4b\x7b\x7c\xbf\xe5\x7a\xa3\xcf\xef\xdd\xec\x57\x71\x23\xa4\xcc\x29\x03\x62\x8d\x59\x2d\x3e\xcc\xa5\xe7\xda\xd3\xbb\xa3\x97\x8b\x15\xce\xe4\x79\x8f\xa5\xca\x66\x35\xbd\x1a\x20\x30\x52\x0e\xb1\xbd\x98\xe3\x1a\xd2\x32\xb9\xe6\x79\x2a\xf3\x68\x4d\xeb\xf7\x24\x5e\x24\x14\xd7\xf3\x92\x9a\x6b\xb1\x03\x0d\xa1\x3d\x7c\x20\xaa\x87\x28\x6a\x3b\x60\x06\x4f\x57\x17\x49\x1a\xe5\xcb\x75\xef\x56\x73\x20\x23\x71\x40\x29\xe7\x8b\x58\x88\xfa\x83\x9a\xda\x0c\xe2\xfe\x4d\xfb\xd6\x88\xd1\xb9\x80\xf4\xb8\xea\xe6\x51\xf9\xf0\xa0\x84\x6f\x40\x7c\x70\xd0\x0b\xd2\x1e\x49\x66\xee\x60\x5e\xc0\xe9\xad\xe7\xd4\x50\xb9\xf6\x32\x59\x72\xc1\xcb\xc1\xea\xa7\x0a\xc0\x78\x54\x68\x0d\x3a\xe4\x12\x80\x38\x2c\xfa\xb1\x03\x98\x09\xde\xf2\x5d\xd5\x7e\x5c\xd4\x3d\xaa\x77\xae\xa2\xcc\xfe\xfe\x0e\x1b\x39\xab\x71\xb7\xb3\x2c\x14\x92\x2a\x3c\xde\xc7\xe2\x6e\xad\x78\x75\xc3\x4d\x20\xfe\x8c\x32\x9d\xfd\x6b\xb6\x1b\x17\x86\x79\x88\x02\x8a\xb5\x35\xe9\xd1\xdb\x58\xf4\x88\x59\x3f\x06\x0c\xc0\x5d\x9c\x09\xb9\x3e\x1b\x72\xd9\xbf\xbd\x3e\x42\xf1\xd9\x75\x98\x6e\x74\xb6\x30\xd7\x45\xa7\x77\x34\xd7\x12\x84\x17\x4a\x75\xda\xa9\xea\x59\x6d\xcc\xcb\x13\xee\xcc\xee\x54\x15\x8d\x1a\x29\xeb\x80\xe7\x27\x97\x39\x8c\xff\x54\xde\xaa\x19\xad\xa9\x21\xee\xa4\xc5\xf3\xa8\xfc\xf2\x5a\xf4\x4d\xaf\xda\x1b\x35\x14\x2d\xe0\x2d\xd4\x3e\xa5\xb1\x9c\xef\xff\x16\x48\x5e\x2f\xa3\x15\x65\x83\x4c\x31\xa6\xf1\xe0\x0f\x8e\x6a\x22\x02\x24\xcc\xbc\x18\x9f\xfb\x37\x3a\xb3\x4f\xac\x9c\x1b\x69\xfa\x50\x46\x0d\x0b\x49\xc6\xe9\x9e\x60\x57\x7f\x17\xd8\xa7\x0a\x62\x72\xfc\x6f\x98\x57\xc6\x25\xf4\x09\x73\xb9\x8e\x50\xba\x45\x87\x76\x95\x70\xb8\xab\x94\x43\xe9\x2a\xf4\x04\x81\xa1\x73\xdb\x33\xdc\x76\xd7\x37\x8a\x1b\x86\x69\x08\x06\xe2\xd9\xcf\x83\x9e\x83\x59\x50\xea\x47\x5c\xbb\xb1\x15\x05\x12\x37\x75\x30\x71\x2c\x8c\xf7\x4d\x50\xe8\x1e\x78\x17\x5e\x14\x83\x4f\x57\xc9\xb5\x3a\x32\xd7\x68\x21\x4b\x20\xe0\xf7\x99\x33\xcc\xf2\x84\xe7\x10\xf3\xf0\x7a\xaa\x5d\xec\x95\x84\x24\x31\x60\x45\xd9\xec\x9f\x41\xf2\x32\x4c\xb0\x95\x25\x35\xe4\xf8\xed\xbe\x0c\xe7\x90\x63\xba\x9b\x49\xe6\x57\x4e\xed\xe0\x6b\x49\x58\x29\x3c\x3a\x44\x27\x86\xf5\x65\x86\xd9\xa8\xca\x83\xc9\x3b\xf0\x02\x4a\xd9\x89\x77\x95\x9f\x3b\x0d\x17\xbb\x8e\x0f\x7d\x53\x95\x66\x95\x5b\x29\x4b\x0f\xee\xc8\x11\x0e\xf4\x51\x61\x86\x10\xb6\x3c\x39\xea\x73\x1b\x4a\xeb\x52\x90\x00\xad\xcb\x8e\x43\x40\x65\x57\x4a\x8b\x58\x84\xc1\x77\xb1\x22\xb7\x1e\xee\xea\x23\x55\xc3\xdb\xea\x46\xb5\x9c\x2b\xcc\xe7\xfc\x12\xa5\xdd\x6c\x86\x6a\x26\x54\x73\xd1\x76\xd5\xcc\x4a\x0d\x6a\xd5\x8d\x92\x86\x75\xf3\xfe\xb9\x63\xf0\x2a\xb9\xbe\xed\x10\xbc\x4a\xae\x3b\x46\xe0\x2b\x9a\xde\x40\xea\xa5\x74\x75\x83\xf7\xe8\xee\xd8\x44\x6b\x00\x55\x4c\x0a\x71\xcf\xd1\xce\x43\x27\x9b\x9c\x7f\xde\xd0\x79\x0b\xda\x42\x5b\xc8\x6f\x4a\x6d\x93\x86\xce\xdd\x65\xbe\xf8\x28\x64\xbf\xaf\x4a\xcf\x50\xa8\x7d\x5b\x3b\x9d\x88\x1a\xd0\x95\xa4\xac\xf8\xc4\xba\x28\x88\xd4\x03\x98\x43\xe7\x8c\xf8\x53\x19\xd4\x28\xda\x25\x5c\x83\xca\x1b\xcf\xcd\xce\x80\xc0\x53\xb1\x39\x26\xa6\xdb\xbc\x9c\xac\x1b\xe5\xb6\x41\x1e\x69\xef\xb8\x08\x07\x30\x9c\x5c\x1c\xc2\x89\xbb\xa3\x0f\x3f\x6c\x42\x8c\x0c\xc8\x57\xf4\xf7\xc4\x1e\x78\x44\xa0\x97\x94\xf5\xd8\xd7\x36\x38\xdf\x8a\x40\x79\x17\xe5\x7a\x2e\x80\x81\x8a\x03\x05\xc4\x9e\xd0\x84\x90\xb8\x8e\x31\x53\xb3\xaa\x5e\x2a\xf1\x00\xb6\xd1\xfe\x3e\x3c\x82\xed\x09\x6e\x48\xe4\xbd\x2f\xf6\x43\xe2\x56\xc8\x4c\x73\x64\x06\xaa\xc0\x7d\xbd\x9a\x3e\x10\x79\x22\x2d\x23\xb7\xd7\x23\xa1\x5c\x3b\xfa\x4d\xac\x3d\xfe\x56\x9e\x51\xd9\x79\x5b\x48\x19\x66\x13\x2b\x45\xfa\x4d\x84\x67\x09\x04\x65\xf0\xe8\xb7\x11\x35\xc4\x31\x96\xe2\xba\x26\xb1\xa9\x3a\x59\x48\x87\x5d\x10\xb1\x1d\x4e\xae\x64\x30\xe7\x65\x1f\x42\x56\x1c\x5d\xc9\xa4\xa3\x2b\xda\xa0\x2e\xbf\x16\xf5\x37\x83\xaf\xb0\x0d\x18\x5e\xb8\x8a\xbf\x0f\x14\x1e\xc8\x07\x51\x08\x6e\xaf\x21\x7c\xc1\x1b\xd9\xa0\xd9\x5b\xf7\x8c\xef\x4c\x8b\x32\xf5\x06\xb1\x92\x9c\x5d\xd2\xf9\x5b\xd7\xa5\x5b\xbf\x8d\x52\x98\xc3\x3e\xc3\x61\xb7\xc3\x31\x7c\xf1\xf4\xb7\xdd\x4f\xb8\xa8\x73\x43\x89\x63\x2a\x29\xdd\xa4\x34\xa3\x71\x2e\x36\xfb\x57\x8b\x6f\x55\xe2\x28\xdc\x45\xb7\x88\xb6\x34\x3c\xc0\x0b\x1a\xd9\x84\x41\xba\xbe\x55\x06\x5f\x5e\xa5\x2b\xdd\xd3\x5b\xdf\x7f\xd7\x4c\x8d\x94\x2a\xee\x9a\xd3\xdf\x85\x1f\x65\xf2\xd5\xf9\xb5\x2b\x09\xa2\x22\x87\x17\x1e\x79\x29\xc6\xeb\x15\x73\xa3\xb9\x1f\x90\xd2\xdf\x2e\x23\xe6\xdf\x0f\x9a\x9b\xae\x95\x5b\xab\x6b\x19\xa7\x20\x5d\x17\xe0\xcb\x1d\xdc\xeb\x24\xac\x5f\xb9\x1f\x54\xb2\x22\xbe\x85\x47\x90\x27\xf2\x75\x93\x64\x66\x14\xdb\x24\xf1\xd2\x86\xe2\x3e\x0f\xb0\x08\xfb\xf1\xba\x38\xa1\x02\x96\xd3\x73\x15\xff\x02\xeb\xe1\xfd\xf0\x11\x17\x63\xd1\xa8\xf2\x4e\x7e\x13\x37\x6d\xc4\xb4\xba\x90\xbf\xb9\xa9\x7b\xcd\x77\x75\x17\xb6\xab\x91\x3c\x90\xc1\xe7\x99\xdc\x79\x2b\x46\x49\x86\x97\x49\x48\x5b\x1b\xb9\x9f\x30\x50\x1f\x71\x4d\xbe\xf7\xd8\xd0\x3d\x7e\xcb\x7a\xb1\x23\xa2\x4a\x56\xd2\x50\x72\x8c\xf3\xc7\xa3\xf6\x02\x46\x5c\xde\xe7\xde\x06\x1e\x95\x49\x7a\x54\x43\x52\x71\x75\x69\xed\xd8\x09\xa2\xa3\xdb\xe2\x2a\x68\xcc\xc6\xed\x19\xb3\xf8\xd5\x6f\xcb\xc1\xeb\x86\x29\x3c\x9a\x4b\x09\xb9\x15\x2a\xff\xa4\x2e\x12\x62\xa3\x6c\xdc\x26\x22\xe0\x46\x78\xc5\xa6\xda\xb8\xbd\xab\x56\x67\x7e\xd8\x9c\x50\x58\xc5\xfa\xc6\x86\x78\x28\xe4\x46\x67\xf8\xe2\x91\xb4\x6a\xce\x27\xe2\x21\xa6\x6b\x2b\x6d\x04\x9b\x6d\xe8\x4e\x22\x80\xd8\x84\xd0\x66\xcb\x6d\xe9\xbe\xdb\x8d\x99\xb2\xea\x70\x49\xca\xd4\x57\x7c\x8b\x1e\x54\xa3\x53\xdb\xfa\xa8\xe0\x57\xf6\x2b\xca\xa4\xac\x78\xca\x81\xae\x5c\x0d\x63\xc6\xaf\xb4\xaf\xc2\x34\xe1\xf9\x22\x55\x0b\x78\xf2\x2a\x91\xe9\xdb\x30\xba\x45\x17\x14\x4b\x33\x8d\x3b\x6d\xab\x92\xcd\x82\xdc\xe3\xed\x91\xe1\x01\xdf\x0b\x4e\xd9\xbb\x86\x38\xeb\x12\x6c\x0a\x24\x9e\x6e\x36\x34\x16\x8b\xa5\x6a\x07\xa5\x58\x07\x65\x5c\x7d\x04\x91\x7c\xe9\x1e\x9a\x26\xfd\xd8\x5e\x6c\x31\x6f\xab\x8e\x76\xec\x7e\xae\xa4\x5e\xb3\x60\xf7\xcd\xfc\x70\x30\x87\x58\x33\x74\x77\xef\x7a\xbf\x3b\x91\xc4\xfd\x93\xfb\x40\xe0\xf1\x4e\x57\x4a\xc2\xc1\x41\x24\xee\x25\xe6\x04\x2e\xa8\x3a\xda\xdb\xf9\x6e\xc3\x1d\x2e\x58\xdc\xe7\x77\xb2\x6a\x2f\x59\x04\xe9\xd0\xe6\x0e\xf3\x29\xa9\x9b\xf3\xb9\xe8\xa7\x84\x78\x67\xdd\x5b\x5e\xdc\x08\x77\xde\x21\xfb\x49\x99\xab\x2e\x16\x87\x87\xee\xdf\x67\xc3\xd2\x13\xd8\x3b\xd8\x83\x7d\xc4\xe3\xa8\xf3\x78\xc2\xf7\x7c\x07\x49\x3d\xd9\x29\x9b\xff\xd5\xf2\x81\x2a\x0e\x0c\xd7\x52\x81\x66\x06\xac\x69\xbe\x4c\xda\xe7\x5f\xc4\x99\x81\x58\x73\x41\x92\x72\x84\x14\x97\x15\x20\x60\x3e\x6f\x18\xe2\x77\x7e\x45\x52\xd6\x1a\x6e\xd7\xad\x4d\x72\x55\xd5\x46\x03\x05\x97\xf6\xf7\x71\x43\x75\x7a\x91\x95\x87\x5a\x54\xc2\x11\x6b\x20\x47\x6d\xc8\x50\x86\x91\xbc\xf8\xa6\x30\xc1\x51\xc6\xb7\x44\xa6\xe5\x66\x49\x8d\x05\xbc\xc7\xf8\xa7\x13\xcf\x35\x9f\x18\xab\x5e\x69\xf6\x60\xcb\xe1\x04\xce\x98\x11\xb3\xa9\x03\x64\x45\xc7\x8d\x07\x9a\x96\x76\x11\xc0\xb5\x46\xc4\x54\xbe\x7e\x9e\x5e\x22\x72\xdc\x7b\x2e\x8f\x01\xb3\xf1\x05\x33\x92\xca\x99\x31\xf3\x65\x5a\x0b\x62\x3d\xc0\xc4\x24\x8c\x8f\xe5\x4d\x91\x57\x3c\x0b\x3f\x93\x4a\x5c\xc4\xac\x72\x8f\xb0\x86\x7a\xbc\x56\x75\x7a\x7f\xf4\x62\xd7\x11\xfb\xe3\x6d\x2b\x17\x33\xf6\xd6\xed\x3d\x90\x22\xea\xfe\x88\x95\xc7\xdd\x53\xf0\x98\xd5\xe2\x5f\xef\xe1\x2e\xb8\x38\xf0\x72\x3a\x88\xd5\x84\x17\xf9\x5c\x8a\x36\x06\xbc\x95\x8f\x1f\x61\xaf\x3e\x33\xd9\xd3\x64\x0a\x52\x36\xfe\x04\xf6\x6a\x49\x5e\xf7\xe0\xa8\xca\xf7\x2c\xe8\xbd\x07\x43\x83\xdf\x76\xdd\xcf\xde\xfa\x56\x3e\x3d\x87\x99\xef\xb4\x69\xec\x69\x34\xa4\x79\x79\xf3\xfe\x65\x7e\xd2\x09\x33\xb1\xe2\x22\x47\x96\x97\x37\x6d\xb0\x37\xe2\xee\x8a\x1a\xff\xab\x93\x52\xeb\x28\xbe\xcc\x0c\xd8\xac\x2e\x33\x2c\x8d\x7b\x2e\x7a\xf8\x1d\x17\xbb\xfb\x90\xc5\x01\x0e\x8d\x0a\x9b\xc5\xe7\xfd\x2d\x6a\xff\xca\xbc\x44\x8d\xdf\x77\xbb\x13\xd4\xf7\x82\xf3\x83\x83\x5f\xdf\x95\xa9\x4c\x54\xb7\xc9\x4b\x7b\x61\x54\x57\x57\xc3\xf3\xde\xf8\x46\x3b\xbc\xc1\xdb\xff\xb5\xcc\xc4\xf1\x6b\x11\xce\xf8\xb5\x11\xce\x68\x22\xa3\xbe\xdc\x1c\x85\x9f\x27\x24\xd1\x04\x35\x7a\xee\x3c\xef\xbc\xef\x3c\xc6\x3d\xcd\xb1\xee\xae\x73\xfd\x3d\xe7\xb7\xba\xe3\x5c\x7b\xf5\x71\x2c\xae\x3e\x8e\x35\x57\x1f\x6b\xe7\x38\xba\xf0\x4a\xac\x4a\x14\xa2\x19\xd0\xfb\x86\x6c\x71\x69\x24\x86\x0a\x16\x5e\xb4\x2a\xfc\x74\xbc\xff\x11\x72\x9a\xe5\xcc\x9e\x2a\x22\x13\x1b\x2f\xcd\xe8\xa9\xc8\x0d\xd2\x9b\x9c\x99\x49\xdd\xeb\x94\x2e\xa2\x2d\xcc\xe1\xf0\xfd\xe0\xe0\xc9\xd0\x1c\x9c\x6f\xfd\xe4\xdd\xf0\x50\x71\xf8\x2f\x4c\xf2\xa7\x8b\x1c\xaf\x6d\x3e\x7c\x3f\x38\x7f\x3f\x7a\xb7\x3f\xfc\x79\xf4\xc7\x43\x65\xc9\x6f\xe9\x82\xc7\x1b\x0f\xdf\xff\x3c\x12\x85\x55\x45\xa3\xac\x10\x91\x57\xe9\xa9\x77\x8a\x15\x0e\x9e\x0c\x8a\x87\x1f\x4f\xbd\x53\x65\xbd\xeb\x65\x94\xd3\x6c\xe3\x05\xf4\x55\xfa\x9a\x19\x09\x6c\x29\x7b\xf0\xf3\xfe\xc7\xf7\x3f\x67\xfb\x1f\x7f\xce\xf6\xff\x78\x78\xd1\x97\xfc\x17\xb6\x86\x98\xe5\x5e\xae\x0d\xf0\xb5\x07\x51\x70\x27\xa1\xda\x2d\x47\xf1\x5d\xc3\x93\xca\x21\xab\x52\x76\x34\x91\x2c\xf2\x77\xa8\xc4\xf4\x34\x01\xba\x0d\xe8\x06\x11\x4b\x6a\x07\x16\x92\xb4\xc3\xbd\x68\x10\x70\xc4\xa4\x63\x90\xe9\xfd\x00\x9e\xdc\x20\xca\x4e\xbd\x53\x56\xec\x09\x0f\x58\x1c\x41\x71\x40\xfd\x80\xc0\x91\x2a\x4a\xdd\x3d\x73\xe1\x8e\xce\xe5\xba\x3f\xc5\xa2\x5e\xe6\x06\x4f\xe6\x3f\x5f\x9f\xff\x7c\x3d\x7a\xf7\xe0\x8f\xc3\xc3\x48\x0b\x05\x8f\x07\x54\x44\xae\x20\x1a\x32\x67\xd7\x06\x6c\x88\x01\x1b\xfd\xae\xe6\xe2\x23\x0e\x38\x0c\x58\xd9\x39\x6c\xac\x7a\x0e\x19\xbe\xb9\x64\x6f\xbb\x07\x4f\x80\x4c\xe0\x08\x4b\xcd\x61\xcf\x67\x0f\x2c\x38\x92\xaf\xdc\x56\x7d\x84\xcc\xdd\xf3\xd9\x10\xee\xb3\xaa\xd8\xde\x13\xd8\x30\x42\xaf\x3b\xa6\x10\x5d\xcb\xc7\x8c\xe0\xfe\x8e\x1d\xf3\xfb\x97\xa1\xf1\x50\xf7\x1e\x19\xed\x41\x9e\xf0\x4c\x01\x7b\x23\xc2\x7f\x98\x23\xa2\xba\x69\xb4\xfa\x34\xd8\x51\x58\x09\x03\xf6\xfe\x48\xf6\x60\x58\x7b\xc3\xad\x82\xc1\xa0\xe2\xcb\xae\x09\x54\xf7\xac\x8f\x69\xdb\xbd\x39\x64\x52\x30\xaf\xee\xcc\x67\xdd\x0b\x82\x1a\xf8\xff\x3f\x77\xdf\xba\xdd\x36\x92\xa4\xf9\xbf\x9e\x22\xdc\xbb\x2e\x92\x26\x78\x93\xa5\xb2\x2d\x9b\xd6\x71\x55\xab\xba\x35\xc7\x45\x79\x6d\xf5\xf4\xec\xaa\xb5\x7d\x40\x22\x25\x41\x22\x01\x1a\x80\x24\x52\x96\xe7\x9d\xe6\x15\xe6\xc9\xf6\x64\x64\x26\x90\x97\x48\x10\x54\xd9\xbd\xd3\xa3\x1f\xb6\x04\x64\x46\x26\xf2\x12\x19\x19\x97\x2f\x06\x03\x68\x99\x84\x3a\x32\x13\x92\x38\x82\xf7\xe1\x4b\xf2\x95\x1e\x0f\x7f\x55\xec\xc7\x97\xe9\xd7\xcd\x34\x88\xfc\x61\x71\x14\x40\x0b\xe9\xb4\xd0\xca\x30\x45\xf9\x0f\x49\xf2\x07\x53\x2e\xfc\xa1\xf8\xc8\x65\x40\xa4\xdf\x12\x91\xf6\x9e\x0f\x17\xfb\x5f\x9c\xb8\x0d\x06\x45\xe2\xae\x68\xc7\xb4\xd3\x67\x22\x01\x57\x75\xab\x20\x20\xb0\x4e\xb8\xd8\xaf\x6b\xd6\x01\x05\x73\xe2\x22\x6a\x89\xcf\x8b\xfc\x22\xe0\xc7\x20\x29\xd5\x31\x4e\x43\xde\xe9\x90\x5e\x1b\x4e\x9d\xbe\x9a\x13\xd4\x0a\x54\x97\xdc\x38\xae\xd6\x6c\xb1\x94\xef\xab\x9f\xc1\x00\x5c\x1c\x53\x99\x4e\xc6\x2c\x3c\x18\x80\x0b\x5c\xda\x8a\xe2\x5b\x8a\xe6\x73\xb2\xe4\x49\x7a\x94\x14\x7a\xf1\xc1\x00\x5c\x80\xd6\x16\xfb\xec\x90\x44\xf0\x71\xb7\xe4\x45\x41\x96\xfc\x89\x2a\xc9\xa8\x7e\xbe\x70\x4b\xce\x69\x9a\x2f\xa9\x92\x24\x4d\x17\xeb\xb3\x85\xa2\xbf\x55\x96\x8f\x3c\x31\x49\x8b\x34\x22\x27\x89\x98\x25\x7e\x93\xb0\xcb\xf2\xa2\xc4\x34\x95\xd0\x5d\x5a\x79\x5e\x94\x98\x27\x01\x4e\xe9\xcc\xfd\x88\x98\x28\xd4\x5e\x13\x9f\x45\xcc\x14\x1a\x52\x89\xa2\xc4\x54\xe1\xbd\x88\x28\x4a\xcc\x55\x91\xfe\x11\x2f\x0f\xd6\x9a\x1a\x11\x93\x65\x68\x3e\xab\x6d\x32\x22\x66\x4b\x6a\x24\x8d\x2e\xf0\xd5\x4f\xcc\x96\xb2\x3f\x59\x1d\xd8\x21\x66\xab\x48\x7f\x95\x28\x61\x55\x61\x5e\x94\x9a\xad\xf4\x8e\x5a\x03\x3b\xc4\x6c\x69\x8a\xfb\xb2\x0a\x2f\x4a\xcc\x96\x32\x0c\xd9\x7d\x25\x66\xab\xe2\x27\x66\x51\x73\xb6\xce\x4e\x05\x1b\x3b\xe3\x9c\xba\xdd\x41\xe6\xbd\xc8\x2f\xf8\x5f\xfb\xf8\x07\x32\x36\xeb\xa8\x46\xa6\xd6\x47\xa5\xc1\x58\x6b\x48\x30\x38\x4b\x6b\x49\xf1\x61\xd4\xb0\x08\x2a\x8d\x74\x38\x7c\x89\xc2\x8a\x9f\xfb\x79\x44\x18\x2b\x64\x18\x8d\x61\x94\x84\x6c\xd1\x97\xf9\x56\xf8\xfd\x33\xbd\x65\xd9\xe0\x86\xdf\xdc\x7a\xe7\x73\x4b\xbb\x73\x74\x0e\x99\x54\xdd\x14\x97\xeb\x00\xe2\x82\xff\x25\xbd\x8a\xf9\x5d\x47\x38\x77\x86\x19\x13\x56\x72\xd9\x68\x78\x2e\x12\x05\xd9\x78\x56\x1b\xb4\x01\xd2\x12\xc5\x25\xfc\x48\xd8\x2c\x69\x73\x65\x84\xb6\xa9\x2b\xc4\x47\x49\x02\x48\xe2\x00\xb2\xc8\x15\xf6\xfd\x81\xde\xcb\xf4\x2e\x1f\x0d\x35\xe0\x55\xf7\x2a\xab\xe2\x94\xf9\x39\x6e\x8b\xf5\x7d\x17\x88\x70\x35\xf3\x5d\x66\xb3\xc8\xb1\x0c\xd3\xd8\x5e\xd5\xa0\x35\x47\xf4\x02\xcd\x29\x4d\x4a\x2d\x08\xae\x2c\xc4\x8a\xc0\xb4\xd8\x23\x5e\x67\x85\x22\x8a\x6e\x40\x28\x2d\xcc\xd2\xa4\x08\xe3\x04\x17\x4a\x44\x37\xe0\x5a\xcf\x13\xcc\xf0\x14\x27\x9c\x02\x59\xa7\xfc\x6e\x4a\x15\x42\x18\x5a\xf8\xa0\x3b\xad\x64\x91\x6a\x26\x11\xa9\x99\x70\x00\x37\x00\x26\x0c\x06\x70\xa5\x28\x85\xb3\xe2\x26\x9c\xd3\x04\xdb\xf1\x39\xbf\x42\x05\x72\x8e\x42\x83\x6e\xc7\xa5\x9b\xde\x14\xfb\x35\xe6\xad\x3f\xd5\xa8\x7e\x48\x1c\xd7\x15\x31\x70\x50\x6a\x85\x22\xe1\xec\x22\xd0\x9e\x50\x3b\x74\xad\xb4\x43\xd7\x4a\x3b\x14\xf9\x0d\x62\x88\xf0\x19\x41\x8f\xc4\x00\x83\x52\x3f\xee\x2e\x4c\x3e\x14\x12\x16\x89\xea\xb1\x07\x5a\xb6\x01\x92\x2f\x28\x2b\x51\x85\xbb\xec\x2b\x76\x85\x9d\xf7\xbf\x4f\xc4\xa0\xf0\x75\x29\x55\x41\x75\x37\x58\x35\x31\xd6\x77\x86\x85\x5c\x16\x57\x9e\x15\xa9\x7e\x32\x4c\xfd\x03\x03\xc9\x37\x4e\x81\x0f\xeb\x15\x6a\xd4\xce\xe0\x29\x8c\x86\x35\xc9\x90\x37\x99\xcd\xf0\x0b\xaa\x8c\x3e\x6d\x54\xdc\x8d\xa0\xb3\x29\xb1\x8f\xfa\x11\xfa\x6e\x84\x41\xad\x80\xdf\x36\x3a\xeb\xd6\x63\xc0\xe9\x3f\x83\x01\x4c\x04\x12\xe3\x74\x0d\xf9\xe7\xac\x81\x67\x7d\x05\x4b\xa9\xfa\xf3\x66\x0c\x49\x2c\x90\x29\x6f\xf2\xcb\xf6\xb0\x51\x52\x10\xf4\x4d\xa8\x49\x15\xac\xff\x44\xcd\x7c\xdb\x63\x13\xf5\x7b\x53\xf1\x2b\xd4\xa3\xf6\xaa\x89\xe8\x6e\x6a\xa4\x91\x17\x22\x28\x53\x11\x67\x28\x9b\x1c\xda\x7f\x57\x4b\x49\x09\x33\x7a\x9a\xc4\x9b\x72\x10\x6c\xe0\x60\x1b\x22\x1e\x34\x9e\x55\xc3\xa8\x9a\x76\x80\x62\xd7\x1b\xdc\xd5\x37\x00\xba\x6f\xd1\x50\x20\x01\xae\x25\xfa\xe8\x86\xc3\xc6\x22\x7c\x62\x0c\x9f\x51\x57\x9c\x9a\x71\x0e\x17\xf1\x2d\x4b\xf8\x7e\xd2\xe1\xde\xeb\x29\x13\x4b\xd1\xc7\xd7\x89\xaf\x7c\x2c\xe3\x03\xc5\xfc\xae\xa4\xaa\x71\x08\xfb\x8f\x64\x84\x50\x63\x62\x27\x1f\x97\xc0\xa3\xb9\x42\x1e\xf5\xbb\x4c\x08\x98\x62\x2e\x88\x26\xeb\x0a\x68\x6f\x83\x30\x4a\x3b\x57\xc8\x29\x64\xab\x65\xc6\x72\xf4\x17\x82\x04\x9e\x92\x1f\x5c\x7a\x12\x85\xf3\xb9\xbe\x51\x0c\x94\x56\x5f\x23\x06\x78\x6b\x58\x70\x69\x96\xf5\x2f\xfa\xa5\x21\xf6\xd5\xf0\xe5\x8b\xd1\x2e\x1a\xd2\x50\x96\xd9\x09\x14\xde\xba\xea\x17\x5f\x45\x39\xbc\x18\xed\xfa\xe6\x0f\x77\xbd\x81\xd4\x2a\x30\x7d\xd4\x64\x26\x38\x99\xf4\xb7\xf9\xf6\x6a\x05\xee\xea\x69\xf4\x00\xda\x7c\xc9\x7c\x33\xac\xd7\x7d\x4e\xed\x2d\xec\x61\xed\x88\xd7\xde\xd3\xa9\x52\x68\xaf\xf5\x91\xfa\x78\xef\xb9\xbb\x64\x08\x91\xe4\x20\xeb\xce\xd9\x79\xe9\x66\xe5\x8a\x45\x69\x54\xb3\x4d\xdb\xa5\x67\xcb\x01\x5c\xc9\xff\xdd\xbd\x72\x06\xfb\xb8\x8b\xc4\xe4\x20\x24\x6d\x47\x6c\x9d\xce\x46\x6c\xda\x2d\xc0\x69\xd5\x8f\xd0\xbc\x52\x28\xb5\xbe\x36\x74\xf8\xd8\x4d\x18\xab\x9b\x45\x08\x1d\x6b\x3c\x12\x69\x0b\x8c\x0c\xac\xf5\x7a\xea\x08\x7a\x42\x93\x49\x43\x21\x59\x0d\x8d\x02\x18\xf6\xf1\x9f\xa1\xf8\x57\xfd\x37\x1c\x01\x2b\x3c\xb2\x76\xf5\xd9\x88\xd2\x52\xce\x56\x1e\xc1\xd3\x8a\xdb\x6e\x88\x14\x10\xca\xd6\x5e\x1e\x35\x0d\x52\xd8\xf4\x29\xb4\x05\x94\xea\xaf\x68\xba\x96\xe9\xfa\xe5\x5a\x12\xba\x71\x43\xc5\xca\xb0\xce\x56\x33\x96\xe7\xae\x4f\xb6\xf6\x53\x39\xd9\xd6\x5f\x0b\xf4\x45\x97\x78\x30\xfa\x40\x42\x55\xd7\x88\x60\x49\xdc\xeb\x3d\x52\x0e\x37\x7b\x50\x2f\xe9\x5d\x6b\xeb\x44\xcf\x5e\xb1\xe9\x1e\x82\x36\x9b\xbd\x9f\x5e\x0c\x87\x25\x04\xef\xde\x4f\x98\xcb\xeb\x1c\x5e\xd0\x5a\x02\xff\x22\xc0\x4b\x2e\xe7\x32\x0b\x16\x26\x39\x72\x9e\x3a\xb9\xa3\x0e\x37\x8d\x0b\x87\x78\xc8\x0b\xa6\xa5\x21\x5b\x50\xfc\xab\x3c\x30\xae\xce\x10\xe3\xf4\xda\x8f\x93\x58\xb3\x84\x50\x6f\x75\xb3\xf4\x7b\x38\xd6\xf3\x16\x75\xc7\x68\x96\x98\xed\xe8\xdc\xe4\xf4\x26\x64\xf5\xa3\xee\xbb\x7a\x57\xf1\x12\xd7\x38\xcc\x17\xf5\x1c\x2a\x9c\x4b\x9c\x39\xb8\xee\xb0\x39\xbe\xa9\xa7\xc2\x10\x7f\x8d\x3a\x89\x28\x62\x1b\x44\x43\xb0\xc3\x63\xae\x2a\x8d\x81\xd7\x9f\x64\x13\xc1\x92\x06\xbf\xaf\xd7\xe0\x8a\x9a\x1d\x10\xdb\x93\x68\xf5\xba\x81\xf8\x0f\xa5\xe2\x0d\x21\xe3\xaf\xf5\xb1\xb9\xc4\xe4\x0b\xb3\x8c\x85\x79\x93\xe1\x90\x6c\x07\xa9\x34\x8d\x93\x5c\xf5\xd9\xa6\x00\x3e\x83\x7c\x09\x34\x28\x43\xa1\x14\x43\xfe\x36\x21\xd6\x1b\xe0\x5c\x61\x9b\xbb\xa6\xdc\xe0\xcd\x26\x52\x7d\x5b\x22\x30\x6b\xe5\xc7\x35\xe8\x4e\xd9\x52\xaf\x77\xd6\xec\xd2\xbe\x81\x99\xc3\x23\xb2\xbb\x6d\x3c\xb3\x36\xe1\xfb\x81\xb1\x99\x34\x94\xf5\x95\x48\x25\xa6\xd2\x3b\xf9\x92\x6c\x78\x3a\xa1\x7b\x6c\xd5\x78\x58\x89\xc1\xef\x33\xcb\x4d\x8b\xea\xa4\x6b\xe5\xa5\x1a\xad\x1c\xb2\x3c\x22\x85\xee\x9a\xc5\x89\x99\xce\x59\xfe\x86\x4f\x95\xe0\x41\xe6\xe4\xfa\xa1\x66\x38\x5c\xa1\xc3\xc6\x68\xff\x78\x7c\x72\x7c\xf2\xbf\x3f\x1c\x0e\x8e\x26\x9f\x4e\xde\x4d\x7e\x39\x84\xdf\x0e\x4f\xfe\x7c\xfc\xc7\x4f\x9b\xa3\xd6\x0c\x63\x31\xdc\x5d\xa6\x79\x19\x2d\x21\xd5\xc1\xd3\x3c\x9d\xdf\x14\x86\x56\x3c\xce\xe9\x90\xb1\xca\x42\xf1\xa1\xaf\xea\x61\x9e\x5b\x18\x8b\x27\x30\x86\x7a\x77\xad\x95\xe3\xb1\xcc\x5b\xa3\xf2\xb2\x28\x89\xbe\x23\xad\xfd\xd6\xbe\x20\x06\xad\x41\x0c\xdf\xc6\xd1\xf0\x0c\x82\x1e\x9d\x17\xf2\x7a\x73\xa6\xd3\x57\xee\xd4\x89\x3c\x54\x33\x99\x41\x39\x3d\xa7\x96\xb6\x31\x8c\x33\x16\xcf\x6b\x47\x4d\xe5\xe8\xa2\x62\x92\x70\xec\x02\xec\xab\xb8\x12\x04\xfc\xe6\xb8\xc5\x90\xe8\x4f\x46\x66\xb0\x92\x3b\x06\x71\x0e\x17\x19\x0b\x85\xee\x40\xc6\xf2\xb8\xc1\x8f\xed\x75\x00\x53\x3d\x6f\xd6\x33\xe8\x35\x21\x6d\xc6\x08\x35\xa2\x3b\x94\x64\x15\x52\xe9\x25\x83\x3c\x5c\xc8\xca\x46\xc9\x34\x13\xb7\x7d\xbb\x1b\x12\x17\x58\xf8\xc1\x7b\xa7\x48\xc2\x9c\x9c\xa4\xb8\xcc\x05\x76\x88\xe6\xa5\xb5\xa6\xbc\xee\x62\x42\x01\xab\x80\xc3\x15\x90\x01\x1f\x84\xc0\xf6\xf9\x91\xd4\xb6\x99\x45\x5b\x43\x69\x05\x8c\xd6\x0e\x7d\x40\x8e\x8d\x31\x76\xd4\x6c\xd5\x79\xf6\x19\x83\x27\x3b\xf3\x41\xf4\x85\x8f\x5f\xb4\xdc\xc8\x25\x92\x00\x6e\x5d\x1b\x25\x66\x95\xe2\x4b\xdd\x86\xa2\x16\x9e\x7b\x7a\x4c\xa4\xe3\xe4\x93\xc8\x1c\xbb\xb7\x9a\x83\xb4\x74\x00\xd6\xb1\x7d\xe5\x4e\x32\xb0\x7f\x3b\x9a\xcf\xb0\x6b\x15\x2d\xf1\x21\xcc\x39\x30\x4f\x55\x23\xb6\x36\xb1\xd9\x6a\x95\xf5\x73\x0c\xb3\xd3\xdb\xb3\x32\x28\xe9\xb5\x48\xfa\x39\x94\x69\xac\xca\x5c\x84\x89\x88\x90\x77\x08\x24\x92\x61\x52\xf0\x8c\x84\xdb\xae\x7f\x59\xe1\x2d\x67\x08\x63\x38\x72\x9e\x4e\x60\x0c\x13\xe7\xe9\x11\x6f\xd1\x78\x3a\x84\x81\xe8\x87\xf3\x74\xe8\x50\x18\x92\x74\x87\x24\xdd\x89\xa4\x3b\x71\x9e\xba\x74\x27\x24\xdd\x89\xa4\x6b\x3e\x3d\x92\x74\x8f\x9c\xa7\xee\x38\x1c\x91\x74\x8f\x08\xba\xdf\xf6\x10\x12\x48\xf5\x68\x77\xd2\x8b\xe9\x8d\xd8\xec\xb2\x3c\xb8\x8c\xd4\xac\x66\xfa\x42\x54\xa9\x1a\x51\xc7\xde\xcd\x2c\x3a\xf0\xf3\x5a\x6c\x64\xcc\xf5\xd2\x88\x11\x3e\x27\x19\x21\xe6\x20\xab\x61\x82\x81\x9d\x67\xd1\xec\xe5\x76\x3c\xb2\xc1\xb8\xab\x38\x1f\x15\x59\xaa\xe7\xf4\x33\x27\x85\x1c\x72\x7b\x5e\xec\xc9\xd8\x30\xaa\xe8\x2b\xc7\xdb\xaf\x86\x17\x1f\x35\x1d\xe3\xdd\x47\x8e\xf1\x30\xe0\x6c\x70\xab\xe3\x46\xc6\x47\x6d\x38\xd1\xd9\xe7\x9b\x70\xae\xd4\xc8\x8d\x0e\xf4\x2a\xac\x4a\x19\x12\xec\xec\xcc\xc6\xc0\x61\x03\xe2\x50\x61\x9f\x9b\x0e\xd3\xde\xef\x38\x93\xe5\x5d\xe7\xbf\xb8\xc8\xd9\xdb\x24\x73\xa2\x2a\xeb\x5b\x0a\x9d\xcf\xbf\xcb\xfa\x79\x9c\xb0\xb9\xe5\x1a\x92\x8d\x9c\xf0\x36\xf8\x42\xba\x68\xbc\xdf\x7e\xfa\x3d\x0b\xe9\xed\x76\xcb\xe8\x31\x23\x96\x66\xf4\x0e\xac\x3d\x2e\x1e\x3f\x7a\xc7\xd9\x21\x6f\x4d\x0a\xc9\x17\x05\x6b\x3a\x8e\x2f\xc8\x71\x6c\xc3\x54\x07\x82\xae\x1f\xcd\x8e\x04\x86\x92\xd1\x09\xa6\xf4\xf3\xcd\x46\x37\x04\xdc\x56\xac\xf4\x25\xdb\x72\xb0\xe2\xfc\x57\x51\xbf\xc1\xce\x7b\xf2\x44\x49\xba\xdf\xfe\x33\xb4\xbc\xb6\xf6\x17\x6c\xfa\x00\x79\x42\xe1\x14\xe3\x5f\xdb\x7c\x0b\xfc\xf8\xe3\x06\x51\xfb\xad\x94\xef\x2b\x01\x7d\xe7\x3b\x0c\x80\xc8\x02\xb3\xed\xdc\x89\xc0\xae\xcd\x1f\x8b\x5f\x90\x7f\x87\x6e\x27\xec\x22\x2c\xe2\x5b\xf6\x98\xbe\xcb\xaa\x72\xde\x26\xec\xa2\xc9\xa7\x88\x2f\xe1\x77\x8a\xef\xf0\x35\x08\xa2\xda\x1b\x3e\xe2\x63\xfe\x0f\xcb\xd2\x6d\x97\x9d\xf8\x4d\xe5\xc1\xf9\x0e\x9f\xf3\x08\xed\xc5\x96\x1f\xce\x5b\x28\x4f\xa9\x79\xe3\x53\xea\xe5\xef\x39\xa5\xbe\xcf\xd4\x57\x63\xf5\x8f\x38\xa2\xd4\xb8\x99\xe7\xd3\xbc\xf9\xf9\xf4\xea\x5b\x9d\x4f\x3d\xf3\x80\x6a\x30\xae\x90\x40\x0f\xef\x9f\x89\xf3\x94\xba\x87\xf7\xf0\xfe\xd9\x3b\xb2\xae\xd1\x3d\xbc\xd8\xf6\x12\xe7\xf1\x90\xb8\x9f\x53\x94\x87\x34\xe5\x89\xa4\x6c\x5f\xaf\x7b\xe4\x55\x9c\x22\x3c\x91\x84\xed\x8b\x74\x8f\xbc\x8a\xf7\xc8\xab\x38\x45\xf7\x88\xa0\xfb\x6d\x85\x73\x8c\xef\x69\xba\x66\x7d\x4b\x53\x10\xe1\xcb\x31\xbf\x99\x36\x58\x8e\x32\x01\xe4\x55\x00\x45\x00\xab\xf7\x27\x6b\xc2\xc3\x5f\xea\xc8\xdc\x37\xa1\xc8\x08\x67\xab\xce\x50\x4d\x69\x99\xa6\xdc\x54\xfc\xb2\x3f\x66\xb1\x29\xe6\x85\xb3\x29\x1a\x39\xe1\x88\x60\xfc\x27\x21\xba\xdd\x4c\x7d\x41\x8f\x93\x70\x42\x44\xf7\x7f\x8a\x2f\x92\x1c\xa2\xf8\xfc\x9c\x65\x04\xd1\x10\xb3\x49\x92\x16\x9a\x35\x5a\x0f\x7a\x53\xd7\x28\xa3\x4c\x08\xfd\xe5\xfc\x26\x6f\xaf\xeb\x71\x26\xd0\x78\xa1\x32\x95\x55\x42\x8b\x3b\xce\x6b\x91\x56\xbf\xbe\x90\x3f\x10\xc3\x93\x6d\x4f\xe6\xce\x63\x22\x85\x1b\xf3\x02\x05\xc8\xa1\x57\x37\xc0\x0d\x49\xf8\xd6\x9a\xce\x14\xf3\xda\xb5\xcb\xe1\x0a\x60\x8d\x59\xb6\xed\x75\xc0\x4b\xad\x60\x1f\x53\xdc\xf9\xb2\x2b\x8b\x3e\xd0\xa0\x9b\x7a\xce\xfd\x06\x69\xff\xaa\x54\x79\x6b\x5e\x75\x2d\x02\x50\x84\x3b\x63\x00\x2b\x2d\x28\x45\x3d\x4b\x45\xcb\xfc\x0d\xa6\xf9\x0b\x33\x86\x0f\x68\xcb\xa6\xfc\x78\xd1\x8b\x06\xdf\xbf\x92\x05\x57\xfe\xfc\x7e\x83\x01\x1c\x1d\x1e\x1e\xc2\x8b\xbd\x5d\x68\xef\x0c\x87\x2f\x3b\xf0\x53\xff\xf9\x3e\xf2\x67\x64\xc4\x43\x01\x03\x53\xba\xb5\x14\x69\x75\x65\xf7\xd0\x34\xf5\x5e\x98\xd4\xe7\x80\x13\xda\xa7\xd3\x20\xd5\x9a\x1b\x57\x46\xae\xbb\x15\xb3\xea\xaf\x8d\xd7\x6b\xfb\xb5\x58\xb9\x1a\x64\xb9\xbd\x53\xab\xdc\xdd\x77\x97\xf1\xec\x52\x31\xd2\x69\x7c\xc1\x2f\x0e\x5e\xe5\x37\xb2\x27\xcc\x01\xe8\x59\xdc\xc2\x28\xf8\xfe\x84\x33\xa7\xb0\x36\xaa\x82\x93\xea\x85\xb4\x19\xbd\xc0\xde\x6f\x89\x0c\x80\x43\xb2\xf2\x60\x9a\x15\x08\xe1\xde\xc8\xe6\x5d\xf4\x33\x76\xcb\xb2\xdc\x1d\x37\x90\x86\xde\x8c\x55\x50\x67\x7c\x5d\xa0\x74\xc4\x45\x1d\x05\xaa\xe2\x4d\xc0\xc7\x99\x71\xf8\x1a\xa6\xbd\xde\x6b\x28\xea\x82\x0a\x8c\x4e\x90\x43\x40\xee\x69\xd5\xbe\xe8\x92\x8a\x96\x13\xfe\x43\x98\x14\x9c\x74\xcd\xba\x42\xb3\x8b\x9c\x35\x39\xc9\x5a\x4c\xc6\x1b\xd9\xf1\xb5\xf6\xac\x03\x07\x10\xc2\x3e\x19\xf1\x2f\x3e\x95\x53\x99\x8a\x7c\x83\x53\x78\x03\x57\xaf\x61\x5a\x97\x75\x58\xf9\x6f\x4c\xd1\x7d\x63\x8d\xbf\xd4\x7a\xde\x89\xde\x8a\x1a\x6f\x44\x05\xbf\x4f\x46\x8d\x1f\xc8\x96\x48\x69\x83\x01\xac\x78\x7b\x07\x80\xc8\x78\x7c\xa7\x49\xb1\x58\xc4\xa5\x49\x1b\xd2\x86\x8d\xc4\x7b\xdf\x91\xcb\x3c\x10\xbb\x75\x3d\x0b\xc4\xb1\x52\x04\x8a\xbd\xb9\xc7\xf6\x14\x27\xe8\xca\x9a\x8c\x9e\xed\xf6\x41\x21\xef\xe8\xf8\x7c\xbc\xcb\xab\x19\xef\x49\x7e\x99\x66\x85\xdd\x43\x81\x11\xa2\x72\x5e\x84\x7a\x9e\xb8\xb5\x5e\x0b\xc2\xbc\x42\xb5\xc7\xf4\x3f\xbc\x0e\x96\xcb\x8b\x30\x43\xff\xf0\xb2\x9f\x04\x37\x99\x1a\xe0\x7e\x72\x5b\xac\x4a\x18\x6f\x87\x69\x4e\x65\x72\x50\x22\x3b\x90\x6e\xe3\x5b\xcf\x04\xfc\xbb\x1d\xa6\xa6\x9a\xb9\x82\xb7\x7c\x13\xd6\xf0\x2f\x81\xaa\x24\x96\xd5\x95\x7f\x1d\x56\x0e\x37\x57\xaf\x21\xe6\x37\xd8\x27\xd2\xdd\xe6\xb5\x4c\x92\x39\x76\xe5\x31\xf5\xd3\xeb\x61\x11\x0f\x74\x02\xb6\xdb\xf5\xe5\x42\xa5\xd0\x13\xb0\x46\x6f\x2c\xba\x5c\x2b\x24\x79\x12\x38\xa3\x81\x49\x44\x90\x68\xc0\x5a\xca\x20\x35\x5f\xd3\x83\x59\xe5\xad\x45\xe7\x22\x09\xcc\x1d\x40\xaf\xb7\x76\xe1\x22\xa5\x87\x30\x25\x6f\xae\xfc\x12\xc6\x60\x00\xbf\xa6\xf3\x79\x7a\xc7\xbb\x4a\x1c\xda\xae\x78\x86\xa1\xa5\xe2\x1c\xef\x0e\x01\x93\xf7\xe9\x07\xbb\x73\xb2\xdf\x85\x59\x94\x93\x1a\x79\xf9\x23\x36\x24\x7d\xbe\x7b\x50\x6c\xd6\xd2\xdf\x68\xed\xf7\x37\x52\x62\xcd\xa6\xd9\xd2\x36\xe3\xac\x0c\x7f\xd6\x93\x0c\x77\x57\xd0\x83\xee\x9a\x73\xce\xf2\xf1\x8f\x3f\x42\x8f\x3f\xee\x19\x8f\x6d\xd2\x9c\x92\xd4\x97\x0a\xc4\xc6\x35\x99\x54\x5b\xc3\x3b\x5b\x07\xc8\xb3\xd6\xac\xa1\x35\x41\xc4\xa1\xf0\x3b\xa1\x75\xfd\xc3\xe7\x13\xcf\x73\x7e\x2f\xb4\xee\xd3\x30\x84\xa7\x38\x83\xd6\x6d\xb8\xa7\x9e\xf7\x86\x6e\x79\xaa\xdd\xa1\xa7\xdd\xa1\x6a\xd7\xa2\x33\x51\xed\x4e\xdc\xe7\x14\xfd\x89\x87\xfe\x44\xd1\xb7\x9e\x1f\x79\xe8\x1f\x79\xe8\x1f\x79\xe8\x1f\x51\xf4\xbf\xf1\x85\x3a\x8d\x6e\xe6\x8d\xb5\x40\x7d\x0c\x49\x92\xd9\x1b\x22\x14\x9a\x72\x48\x2d\xe5\xdb\x6f\xc7\x7f\xfc\xcb\xfb\xe3\x5a\x83\xb6\x6c\x75\x2c\x7e\x6d\x78\x05\xff\x1c\x00\x71\xbf\x56\x37\x6f\xf2\x82\x3d\x6a\x7c\xc1\x76\xf9\xa9\x9e\xc7\x1c\xef\x3a\x96\xe7\x4d\x50\x66\x0d\xe7\x85\xe4\xf5\x87\x38\x13\x9f\xac\xfa\x33\x3d\x95\xf9\x5a\xa8\x46\x9f\xac\xfb\xde\x08\x98\x2d\x2e\xe8\xb2\x9f\xab\xf2\x96\xa6\xf7\x12\xbb\xed\x76\x4b\x77\xb5\xe4\xdd\xe0\xbd\x5a\xc9\x5e\xad\xb6\xec\xd5\xaa\xfe\xfa\x8e\x6d\x68\x0b\x82\xf3\xd8\x57\xfe\x5b\xf4\xcd\x6c\x1e\x47\x71\x98\x88\xac\x2f\x71\x9a\xec\x63\xaa\xf3\x3c\xbe\x48\xda\xeb\x0e\x3c\x03\x11\x0d\xb0\x82\x01\x84\xd3\xbc\xbd\xee\xb8\xc1\x5a\x83\x01\x86\x86\x71\x46\xf9\x79\x0d\x88\xf6\xc6\x32\xc6\x79\xc1\x9b\x31\x64\xf0\x46\x56\x74\xea\xe5\x4a\xab\x62\xbf\x58\x53\x6e\x90\x20\x93\xb0\xa3\x99\x7f\x15\xf0\x65\x34\xb4\xec\xb1\x66\x7d\x82\xf0\xe7\x7e\x0e\xcf\x9c\x37\xde\x1b\x91\xdb\x9c\x3e\xae\x8d\xd0\x3a\x57\x42\xf5\xd5\x86\xcf\x7d\xc4\x7e\xe1\x63\xfa\xad\x9d\x39\x7c\x8c\x06\xcd\x28\x2c\x32\x54\xf1\x88\x3b\x21\xf3\x34\xc6\xc2\xc1\xc6\xc8\xea\x66\xf0\x0c\x49\x00\x99\x46\xb2\xc1\x92\xd2\xd8\xe5\x55\xf8\xb8\xf6\x56\x62\x6b\xba\xfe\x6b\x5b\xb9\xbb\x42\x02\x5d\x52\x6d\xdc\x25\xd5\xc6\x5d\xe4\xed\xb6\xd6\xb8\x2b\xd0\x85\x9d\xa7\x94\xd2\x98\xa2\x3b\x24\xe9\x4e\x24\x5d\x5b\x0f\xdc\x25\x75\xc6\x14\xdd\x89\xa4\x6b\x6b\x7c\xbb\xa4\xce\xb8\x4b\xea\x8c\x29\xba\x47\x44\x7f\xbf\xed\xca\x43\x1c\xd8\xdf\xa9\x32\x5e\xce\xa5\xc6\x98\xdf\x9d\x9a\x1d\x57\xc5\xb7\xd2\x12\xef\xfc\x13\x6b\x89\xbf\x85\x9a\x58\xf0\xac\xff\x1e\x7a\x62\xb9\x9a\x35\x37\xde\xb8\xf4\x86\xae\x1e\xfa\xd0\xc0\x09\xf5\xb1\x0d\x43\x8e\x8e\x93\x8f\x51\x10\x7f\x4f\x8d\xaf\x4f\xf9\x6c\x69\x81\xd7\xb5\x7a\x5f\x08\xd1\xf5\xbc\x7e\x19\x7c\x67\x25\x6b\x13\x45\x21\xfc\x1a\xe6\xe8\x0c\x94\xc2\x0d\x1a\x4b\x51\xeb\xc7\x19\x50\x02\x51\x0a\x32\xc3\x63\xde\x40\x17\x4b\x0e\x63\x58\x9b\xb2\xe0\x71\x2a\xd3\x3a\x25\xec\xa3\xb4\xba\x1b\x74\xb0\xf6\x4b\xa5\x7a\x08\x7f\x87\x16\xd5\x6c\xd2\xd0\x78\x12\x8c\xd1\x03\xd6\xcd\xa7\xd8\x52\x02\xce\xd3\xe4\x82\x65\x42\x17\x28\xf2\x29\x4e\xcb\x5c\x51\x52\x69\xe6\x55\x87\x85\xd0\x43\x55\x29\x9f\xaf\x42\xd7\x08\x96\x3a\xc2\x22\x90\x1a\x64\x17\x57\x3b\x99\xaf\x95\xd2\x2d\x42\xad\x86\xae\x7b\x43\x1f\xfa\x50\x1c\x6b\xe7\x37\x19\xee\xeb\x0a\xf8\x61\x35\x83\x59\x98\xc0\x94\x41\x7c\x91\xa4\x99\x1d\xa8\x58\xa9\x73\x87\xaf\x61\x4a\xa7\x38\x08\x85\x06\x79\x76\xda\xeb\x4d\xcf\x4a\xb5\x6c\x57\xea\x71\xbb\x10\x22\x30\x10\xea\xee\xc8\x40\x73\x51\xfe\x29\xa5\xef\x22\xae\x08\x21\xd5\x85\xd5\xac\x4c\x87\x1a\x12\x4b\xa1\xdb\x5d\xb3\x47\xe9\x59\x04\xf7\x12\x4a\x96\xae\x54\xb2\x0c\xa5\x76\xa5\x2b\xb5\x2b\x43\x9b\x12\x6e\x2c\x15\x0a\xd7\x85\x11\x2c\xd3\x3c\x8f\xa7\x73\x46\x89\x8b\xbf\x43\xb9\x42\x46\x96\x10\x68\x7a\xf5\xd1\x25\xbe\xbc\x64\xa7\xf7\x67\xf0\x65\x9a\xa6\x73\x16\x26\x0f\x82\xfe\x57\xf8\xab\x82\xa0\x48\x61\x96\xde\x24\x85\x72\x53\xeb\xa1\x3f\xb6\x19\x51\xb1\x8f\xce\x26\x81\x70\xfd\x08\x60\xc4\x0f\x81\xa1\x57\x68\x2a\x33\x1d\xa1\xad\xdd\x14\x9c\xee\x9b\x07\xa0\xf8\xc5\x26\x79\x4c\xbb\xbb\xa7\xc2\xe1\x6c\x77\xaa\x8c\x10\x12\x52\x57\x7c\x3f\xef\xfa\x34\x4e\xc2\x4c\x5a\x51\xf6\xe1\xcb\xbd\x05\xad\x8b\x9b\xf8\x5e\x4f\x35\xc6\xff\x18\xc3\x93\x27\xf7\xd5\x1f\xa3\xea\x57\x9a\x2f\x13\xc0\xbc\xa3\xe7\x01\xb4\x54\xb7\x5a\x5c\x86\x4e\x8b\x9f\xd3\x74\x1e\xc0\x3d\xc5\xf5\xaa\x7e\xf0\x96\x3b\x70\x4f\x02\xea\x52\x57\xef\xfa\xe8\x1c\x3b\x2a\xc7\x8d\xdd\xb9\xd5\x81\xfb\x5d\xec\x0b\x3b\x7e\x86\x16\x7a\xb6\x8f\xd5\x91\x81\xef\x3e\xa3\xdb\x86\x00\x1d\xaa\x0f\x65\x3e\xd2\x26\x90\x78\xbe\x76\x6f\xcb\xf4\x08\xb7\x2a\xb0\xbc\x6a\xdb\x0d\x67\xa7\x26\x04\x17\x8e\x04\x12\x81\xb7\x98\x75\x25\x01\x1f\xb4\xc8\x56\xc1\x43\xdf\xd8\xf3\x7d\x11\xae\xe2\xc5\xcd\xc2\xba\x2e\x45\x4b\x3b\xcc\x8d\x86\xf5\x44\xe9\xb0\x48\x61\xe8\x06\xb9\x40\xc6\xf2\x25\x9b\x15\xf1\x2d\x9b\x73\x51\x53\x27\x9f\x2e\xe2\xa2\x30\x8e\x2b\x93\x7d\x45\xcb\x33\xf8\xa2\xf8\xd6\x1f\x4d\x00\x17\x38\x52\xde\xb5\x43\xde\xf2\x6f\xef\xfe\x4d\xe0\x34\xe6\xf1\xad\x99\xfd\xf0\x34\x5b\x68\x54\x3e\x1a\x59\x12\x2d\x22\x2f\x69\x12\x3a\x35\x81\xcd\xdb\xee\x38\xe1\x7f\x5a\x96\x95\x7d\xf8\x12\x2d\x75\xde\xe2\xaf\x66\xa6\x62\xa9\xab\x68\x0e\xb9\x53\x2f\x5b\x34\xaa\x67\x75\xd3\xaa\xa5\x73\x73\xac\x67\xde\x7d\xa3\xa5\x48\xcc\x47\x71\x72\x9f\xf6\xc5\xdd\x12\xd1\xb2\xcc\x7d\xf8\xf0\x60\x24\x73\xe4\xf4\x87\x01\x9f\xca\x00\x46\x7b\x9e\x04\x45\x2a\x58\x22\x80\x7f\xff\x77\xcc\xa6\xaa\x47\x48\x08\x9c\x22\x49\x9b\x90\x61\x9f\xd0\xb9\x23\x47\x7b\x76\xde\x48\x38\xb0\x56\xf1\xbe\xca\x1c\xd9\x48\xf3\xf6\x8f\xda\xc2\x28\x2e\x09\x4d\xda\xb5\x5c\x52\x7a\x03\xed\x65\x7a\xc7\x32\x64\x7a\xa3\x61\xa7\x0f\x9f\x78\x71\x03\x25\x4c\xc0\x7e\xbd\xe5\xe3\x80\xa9\x73\x34\x30\x2a\x7c\xf3\xc6\x3c\xee\x75\xe2\xd7\xd5\xa6\x2a\x77\x51\x8f\x8b\x4c\x9f\xde\xfd\x7a\xf8\xf7\xa3\xc9\xc9\xe1\x9f\x0e\x3f\xca\xad\x69\x3e\xdb\xb8\xc9\x8e\xce\x05\x08\x89\xbe\x5a\xb1\x7f\x55\x4e\x27\x29\x91\x68\xd9\xa5\x15\xb2\xc9\x7f\xfe\x07\x06\x2c\x5f\x0b\x84\xd5\x54\xbf\x68\x1b\xbc\x47\xf9\xb7\x7a\x77\xba\x34\x85\x5a\xf2\x84\xbe\xe9\xae\xad\x3d\xe7\xd4\xb0\xb6\xdb\xb5\x77\xb7\x61\x4d\x63\xb7\x5d\xfb\xb6\x99\xb0\x7e\x10\x8b\x4e\x5f\xdb\xd7\xc4\x5c\x04\xce\x4c\x04\x30\xfa\xc9\x90\x4c\x3a\xf6\x61\x3a\x18\xe0\x40\x8e\x58\x77\x67\x24\x98\xbc\x4a\x63\x75\xdd\x11\x23\x2e\x72\xfc\x33\x32\xab\xa5\x7d\xb0\x1e\x40\x22\x35\xd1\xd0\x1a\x31\x2e\x08\xe9\xe4\x6c\x25\xbd\xa3\x1d\x48\x84\xd1\x42\xe4\x5a\x15\x60\x6c\xbc\x73\xee\xa2\x7b\x78\x80\x6b\x09\x65\x61\x3c\x77\xcd\x00\x07\x98\x32\xef\x99\xa4\xa4\x90\x06\x47\x42\xad\xe2\x94\xde\x37\xf3\x64\xd5\xe9\x86\xf3\xcf\x59\xd1\xee\x25\x1d\xd7\xcc\x87\x6f\x60\xe2\x7b\xd3\x3b\xf2\xd6\x11\x6f\x8e\x88\x37\xc3\x8e\x6b\xf6\x14\xd4\xf0\x8d\x61\x58\x7d\x1c\x07\xca\x3f\xdf\x84\x19\x83\x2c\x4d\x8b\x4d\xa1\xee\x7a\x03\xdf\x34\x2e\x56\xf4\xe1\x23\xef\x02\xde\x30\x3e\x67\xf5\x81\x31\x65\xd6\x41\xc8\x02\xc8\xd8\x32\xd8\x4e\x49\xeb\x55\x0a\xe6\x42\x7b\xeb\xbe\x90\x0a\x49\x22\xcb\xd1\x12\xc6\xf6\x67\x77\x61\xd7\x2d\x78\x19\xce\xcf\x9d\xa3\xb4\x35\xec\xef\xb5\x08\xf5\x94\x8a\x37\x19\x4c\xc2\xc9\x40\xf1\xb8\x81\xab\xef\x13\x58\x7c\xf2\xf6\xf2\xf0\xc0\x6f\x09\xf8\xef\x56\x96\x3f\x78\x82\x36\x93\x32\xbf\x64\x5b\x92\x91\x54\x0e\xd0\x2c\xba\x0f\xca\x71\x75\xa4\x34\x93\x3a\x61\xf7\xc6\x7e\x94\xc4\xc8\x31\x58\x5e\xc4\x8b\xb0\xb0\x32\x98\xf3\x81\xfe\x2d\x2c\x2e\xfb\x62\x95\x77\x57\x94\xe9\xb6\x2c\x00\x37\x0a\x74\x66\x90\x92\x59\xca\x06\x03\xf8\x10\xe6\xb9\x40\xad\xaf\xaa\x21\xc4\x93\x3c\xc0\x50\x6d\x27\x7d\x68\x24\xec\xa5\xf0\xa3\x51\xd0\x8c\x78\xd6\x10\xba\x9f\xbc\x84\x9a\xc4\xdf\xe4\xe7\x7b\x92\x49\x9a\x19\x86\x67\xbe\x2b\x20\xe7\x78\xf2\xb6\xd6\xc5\x04\x75\x4f\x61\x47\xe1\x7d\x25\x32\xb3\xa8\x5b\xd5\x1c\xb4\x84\x20\x6e\x68\x45\xcb\x5c\xa7\x1d\x18\x20\x20\x66\x4f\x26\x4b\x1b\x8a\x3c\xbb\x4f\x05\xd6\x09\xdd\xc3\x0d\xdf\xaa\xbe\x57\x32\x7b\x2a\x91\x7c\x9d\x2e\x12\x13\x2c\xf7\xcd\xd4\xba\x1e\x67\x2c\x94\x3f\xa5\x22\x97\x1f\xfb\x49\x1f\x81\x66\x8f\xcf\xdb\x2d\xd6\xea\xc8\xef\xa3\x7b\xe0\x7e\x5a\xe6\xec\x40\x7b\x14\xbd\xdd\x76\xab\x42\x0e\x5d\x99\xcb\xab\xa6\xd9\x12\x20\xf4\x9c\xf4\x2c\x40\x2b\xf7\x2c\xbd\x99\x47\x5c\xc2\x51\x6a\x78\x85\x98\x14\xe7\x65\x22\xec\x0a\x73\x16\x99\x72\x95\x10\x7b\x86\x21\xa4\x91\x43\xf6\x84\x17\xbb\x43\xca\xb3\xf0\x26\x67\x10\x96\xc6\x78\x2e\x55\x62\x53\xed\xd5\xa0\xe8\x20\x9b\xbe\x64\xc9\x8c\x55\x3e\x07\x53\x36\x4f\xef\x02\xe9\x81\xac\x11\xb1\x1b\x31\xd6\xbb\x10\x32\xcd\x74\x9e\x6a\x3d\x65\x7e\x77\x04\xbe\x68\xb3\x3e\x31\x81\x7c\xbd\xf3\x15\x1c\x2d\x3d\xdb\x88\xb3\xac\xe7\xd0\xc1\x82\x14\xb0\x28\x72\xd2\xbb\x22\x4d\x7a\x1f\xc3\xe5\x65\x9e\x26\x10\x17\x2c\xf3\x64\x65\x36\xf1\xff\xec\xb7\x20\xb5\xe4\x19\xbd\x4a\xf9\xea\xe0\x1c\x5e\x09\x41\x85\x88\x89\x28\xed\xfc\x45\x80\x77\xa0\x91\x88\x66\xaa\x43\x56\xb5\x72\x94\x17\xfd\x19\x00\x74\xb4\x0d\x90\xcb\x68\xa8\x36\xdf\x1a\x24\x1d\xfc\xb1\xe8\x64\x98\xf2\xde\xa6\xb3\x29\x51\xdb\x89\xc5\x28\x33\x91\xa0\x9d\x65\x8c\xaf\xd6\x34\x61\x56\xdc\xde\x79\x9c\x84\x73\x25\xb6\xab\x8a\x74\xce\x3c\xd9\x02\xeb\x5f\x08\x40\xd5\x57\xaf\x5e\xbd\x82\x36\xeb\xed\x76\xa0\xd7\x7b\x2b\xb0\x56\xf9\xdf\xcf\x3b\x01\xe4\xa9\xe2\xdc\x39\xff\xdd\xc5\xb4\x74\x33\xa8\x6b\x4d\x70\xe9\x06\x79\x06\x8b\x60\x96\x66\x19\x9b\x15\xb6\xcb\xa4\x33\x0b\x19\x02\x97\x71\xce\xdc\xeb\x11\x1e\x1f\xea\xc7\x60\x4e\x39\xf4\xe0\x79\x80\x5c\x61\x54\x0b\x4d\x28\x07\x76\xb7\xb8\xb4\x01\x81\x65\x6e\x8e\x38\x91\x99\xac\xd0\x8f\x82\x7f\xb2\x0c\x0a\xdc\xdd\xf6\xbb\x71\x54\xd3\x0c\x76\x71\x74\xd1\x4d\x23\x5c\x2e\xb3\x34\x9c\x5d\xa2\x25\xa2\xa2\x37\xe5\xbf\x84\xd9\xba\x83\xb9\x3b\xe2\xe4\x06\x2d\x5d\x75\xf4\x6b\xf6\x92\x31\x96\x09\xa6\xca\xe3\x3d\x69\xa1\x74\x92\xb1\x25\x0a\xfb\xf8\x78\x17\x1f\x37\x41\xdc\x3c\xd6\x01\x35\xcb\xb6\xd1\xb9\x39\x90\x46\x81\x22\x85\x9c\xa1\x3f\x54\xf9\x59\x37\x4b\x89\x6a\x5d\xf7\x31\xb2\x05\xb6\x0a\x67\x85\x5a\xbd\xd2\x26\x93\xc4\x09\xcb\x71\x5e\x62\xc1\x1b\xd9\x7c\xcd\x25\x4e\x16\x6e\x48\x5b\x20\xb4\xb6\xfc\x5b\x9b\xc0\x45\x4a\xdd\x47\x11\x40\x81\x1a\x0f\x47\xa2\xdc\x09\x3c\xe6\x60\xb2\xdd\x42\xf2\xa1\xa2\xd3\x67\x9f\xdb\x2b\x7f\x22\x48\xa7\x1f\x5c\x66\x6e\x06\x59\xd9\x10\xc0\xd1\x8f\xb7\x08\x9b\x71\x2b\xa3\x25\x17\x86\x76\xeb\x5b\xc9\x1b\x94\xe1\xf3\x50\x0b\x0d\xd9\x18\x47\xf9\xe8\xdc\xde\x83\xb8\xd1\x92\x9b\xf9\x3c\x80\xe1\x97\x61\xb0\xfb\x95\x6f\xb8\x3d\xfe\xeb\xf3\xaf\x81\x66\xae\xc2\xe5\xb5\x89\xbc\x14\x43\x79\x33\x49\x5a\x48\xb1\xb5\x4a\x89\x64\x99\x08\xf9\xc9\xbd\xa8\x90\x5f\x31\xa5\x52\x93\x65\xd9\xc5\x5c\xd2\x4f\xba\x8a\x77\x8d\x3a\xf2\xfa\x7d\x19\x66\xef\x8a\xf6\x50\xa4\xbb\xdc\x6b\xb0\x31\x65\xb7\x4f\xe4\x6d\x5f\xe9\x99\xc4\x2e\x6d\x0a\x3c\xac\x7e\xe4\x2e\xe0\x77\x3a\xef\x2e\x18\x35\xc1\x9a\x5d\xc0\x18\x9e\x64\x72\x13\x64\x72\x13\x6c\xc2\x05\xad\x7d\xbd\x61\xb5\x7f\xcb\x54\xff\x1b\x47\x61\x64\xe1\x38\x05\xb0\x68\xaa\xbc\x48\xd0\xf5\xc2\x76\x40\xe3\x4f\x29\xc7\xb6\x67\xa4\x63\xdb\x33\x12\x97\x8c\xa2\x3b\x24\xe9\x0e\x25\x5d\xdb\x2d\xed\x19\xe9\xd8\xf6\x8c\x74\x6c\xa3\xe8\x4e\x48\xba\x47\x92\xae\xed\xc2\x46\xd1\x3d\x22\xe9\x1e\x11\xe3\xf0\x38\x55\x8b\x4f\xd9\x8b\xeb\xf4\xf7\x7a\xb6\x09\x22\xe8\x89\x7d\x33\x6f\xe8\xda\x36\x0b\x80\x69\x99\xcf\x16\x01\xac\x66\xef\x03\x58\xcd\xd3\x00\x56\x97\x71\x00\x6b\xfe\xe7\x9a\xff\xb9\xe6\x7f\xde\x13\x3a\x13\x4c\x8b\x8c\x3a\xa9\x9f\xc9\x04\xc9\x7e\x35\xcc\x06\xe7\xac\xb6\x74\x9b\x7b\x11\xf8\x5d\xe5\xa0\x43\x19\x8d\x2b\xcf\xb8\xc0\x02\x5a\xfc\xcf\xff\x18\xd2\x21\x2e\xca\x1f\xab\xca\x68\xb0\x21\xb8\xd6\x71\x2d\x37\xa0\x30\x51\xa3\xca\xe5\x63\x44\xea\x40\x05\xfc\x25\x13\x9a\x69\xdd\xb7\xdb\xeb\x61\x25\xdc\x58\x95\xa7\xf9\x6a\xa6\x22\x98\x84\x76\x54\x76\x74\x2d\xfd\xcf\xcb\xc7\xab\x99\xdf\x9f\xa8\x3f\x93\xee\x72\x63\xe9\xaa\xe7\xc9\xfe\x5a\x1b\xc7\x29\x1c\x9d\x5d\xff\x46\x77\x50\x48\xc7\x38\x03\xf7\xb2\x06\xde\xdf\xf0\x8f\xf3\x0b\x2e\xfa\x37\x79\x00\x8b\xed\x4e\x0d\xed\xde\x0c\xe9\x6e\x6c\x44\xc2\x96\x31\x44\xc3\x9a\xc8\xc6\x75\x5d\x1e\x05\xea\x68\xf0\xa9\xeb\xea\xa3\x90\x4c\x9d\xcf\xca\x86\x04\xea\x6a\x2f\xd7\xd6\x4b\xcb\xa7\x4e\x9b\x5d\xfd\xf9\x6a\xf6\xde\xef\x84\xb5\xc6\x97\x35\x6e\x58\x87\x49\x7e\x93\x31\xbe\x84\x97\x69\x9c\x14\xe8\x6c\xa7\xbb\x62\xe1\xe6\xe0\x4d\x14\x29\x70\x91\xc6\xeb\x83\xc5\xcb\xbc\xc1\xf6\x3a\x70\x3f\x23\xe3\x33\xef\x67\x81\x8c\xb6\x7c\x1f\xc8\x6e\x0b\x06\x86\xbf\xc6\x6e\xe7\xa4\x92\x32\x16\x6e\x7d\xa5\xe8\x8f\xfd\xba\x8b\x8b\x4b\x0a\xd3\x5b\xc7\xf2\x7e\x8f\x8e\x54\xef\x03\xd1\xa1\xd3\xb3\xd7\x10\xf7\x7a\xaf\xe1\xde\xc8\x4a\x66\xd4\x96\xe9\xb8\x5d\x67\x2a\xc5\x40\x61\x0c\x9f\xfe\xd7\xc7\x13\x0a\x2d\xb5\x6a\x79\x3d\x7b\xff\x1a\x7a\x3d\xcc\xd1\x36\xa4\x15\x16\x33\x7a\xed\xad\x31\x5a\x67\x8d\x21\x90\x4f\xcb\x46\x89\x72\x97\x71\x59\x6e\x50\x75\xee\x81\xd4\xb3\x54\x50\xfd\x38\xf2\x22\xb3\x54\x17\xae\x45\x40\x67\xec\xd7\xa8\xac\xb0\x37\xe8\x9c\x76\x5d\xdf\x1f\x2c\x7d\x29\x46\xfd\xf4\xda\xed\x13\x55\x9e\x4b\x81\xfc\x3b\x9e\x61\x3b\x5d\xac\xff\x8c\x8f\x80\x87\xbc\x18\x9a\x79\x5a\x56\x68\x43\x1b\x16\x5a\xb7\x10\xca\x56\xfb\xa3\x0b\xf7\x22\x1a\x14\x08\xdf\x49\x35\x09\x6d\x24\x26\x92\xde\x0b\x3b\x33\x52\x5e\x58\x9f\x80\x8f\x65\x6f\x2f\x3d\xf9\x4a\x78\x6b\x02\x0b\x9f\x93\x7c\x8a\x24\x1b\xe9\x3d\x45\x37\xc7\x76\x37\x09\xbf\x96\x19\x35\x55\xdd\xae\xed\xa0\xe7\x63\x8f\xf7\x65\x9c\x69\x23\x63\xba\xe1\x5e\xc7\x77\xef\x96\xde\x75\xdf\xd7\x47\x66\x9b\xf4\xb7\x78\xe0\x9b\x8e\x05\xf1\x39\x64\x0b\x34\x76\x6f\x70\x86\xc9\x23\xcd\x8d\xe5\x93\xd3\xa2\xe6\xcb\x32\xfa\x87\x3a\xc4\xa8\x5c\xd1\xed\x0e\x54\x1e\x80\x96\xe1\x3b\x8f\x2c\x4b\x39\x59\xc9\xb1\xaf\xd7\x55\xdb\xd6\x1f\xc6\x5b\xb5\xb9\x4b\x8c\x22\x61\x8a\xcd\x22\x65\xf0\x76\x5e\x31\x7a\x41\x74\x94\xcc\x23\xdd\x29\xc6\x70\x53\xe1\xf4\x47\xca\x2b\xe6\x65\xa0\xe7\x1c\x47\xbb\x1b\x56\xda\xe7\x14\x1c\x16\x97\x2d\x44\xd6\x34\x1f\x69\xcd\x03\xe6\x65\x63\x0f\x18\xd2\xf7\x20\x8f\xe0\x40\x73\xcd\x29\xc7\x64\x7f\x5b\x57\x98\x5c\xd8\x08\x32\xb6\xcc\x58\xce\x92\x82\xc4\x05\xd6\x81\xce\x12\xd2\xf3\x80\xcb\x0b\x3a\xfd\x32\xeb\x0e\x6e\x4b\xf3\xc3\x8a\x14\xa2\x25\x9c\xc7\x2b\x16\xf9\xb3\x84\xfd\xd7\x77\x4c\xb3\xec\x64\xdb\x7b\x9a\x6d\x20\xb0\xc9\xc3\xcd\xae\xbe\xfd\x06\xad\xab\xbf\xcd\x2e\xd5\xe8\x34\x72\x60\x53\xa0\x9c\x98\x71\xbe\x4d\x5e\x43\xa3\xa5\xee\x16\xec\x75\x5a\x7b\x85\xfb\x46\x3a\xa6\x8d\xf8\xea\x47\x85\x1f\xdf\x67\xfc\xdd\x77\xdf\x0a\xb8\x88\x7b\x28\x42\x57\x5b\x41\x0d\xa4\xde\x88\x7f\xcd\x7f\xfb\x93\x6b\x92\x16\x6c\x1f\xc2\x5c\xc8\xca\xff\x12\xde\x86\x9f\x66\x59\xbc\x2c\x5a\xb9\x72\xcf\x2d\xd6\x4b\x16\x40\xbb\x37\xec\xf4\x8b\xf4\x57\xde\x29\x2e\x14\xc7\x39\xb4\x86\x2d\xc3\x9d\x64\x7a\x53\x88\x6c\x95\xed\x1e\x9a\x83\x86\x23\xa7\x46\x6f\xd8\xfa\x27\xdb\xb6\xa2\xfb\x8f\xda\xb0\x9e\xaa\x9b\xb7\xaa\xaa\xb8\xfd\x26\xa5\x6b\x6e\xb3\x3d\x91\xc2\xa3\x37\x66\xc3\xad\xb8\xe3\xfa\x6f\x1d\xb8\x1e\xa3\xc6\x0e\xdd\x19\xfe\x7f\xdd\xa1\xcc\x38\xb0\xe4\x2e\x5c\xb8\xdb\x4e\x6c\x5d\x73\xc6\x85\xf7\xa6\x18\xa7\xc2\x76\xb7\xe2\x3d\x5a\x66\xe9\x92\x65\x45\x6c\xfa\x87\x4a\xa7\x96\x5f\x8f\x3f\xfe\xf6\xee\x04\xd2\xe9\x15\x9b\x15\xd0\xce\x19\xd3\x42\x4b\x66\x69\x72\x1e\x5f\x74\x7c\xeb\x57\xd6\x1d\xeb\x33\xf7\x4c\xfc\x27\xbb\xf8\x89\x2d\xc3\x2c\x2c\xd2\x0c\xf6\xa1\xd5\x37\xf7\x33\xfe\x5c\x64\xe9\xcd\xd2\x28\x15\x78\x4b\xc5\xf7\x0c\xf6\xe1\xb9\xfb\x3a\x67\xb3\x14\x2d\x93\x7f\xd2\xca\x0d\xdd\x72\xe7\x59\x88\x8b\xee\x4f\x4e\xa3\x7f\x5b\xbd\x1b\xb6\x02\x90\xe8\x33\x69\xd2\x43\x65\x3e\x1f\xc3\x7c\x19\xce\xd8\x06\x4a\xb2\x41\xbd\xd4\xd7\xd7\xff\x64\x7c\x48\x6c\xb3\xc7\x31\x22\x4f\xdd\x06\x9c\x48\xd5\x7c\x04\x2b\xa2\xab\x6e\xc5\x8b\x90\x44\x63\x37\xf7\xbc\x40\x40\xff\xc7\xf0\xa3\xd1\xf6\xfc\xc8\xf5\x0f\x10\x66\x5b\x81\xb7\x4c\x5d\xc1\x05\x74\x29\xa9\x15\x08\x33\xde\xf5\xbc\xc8\xfa\xf9\x72\x1e\x17\xed\x56\xbf\xd5\xa1\x4b\x5e\x8c\x60\x0c\x5d\xb1\xb1\xfb\xe5\xb6\xf3\x94\xdd\xd1\xca\xba\x7b\xd0\x53\xc9\xdc\x7b\x63\x30\xda\x52\xcf\xe9\xba\x71\x52\x7c\x08\xd1\xef\x33\xcc\xb2\xd3\xe1\x19\x5d\x4a\xed\x4d\xad\xe8\xc8\x53\x54\xe1\x74\x57\x30\xdc\xde\x86\xcb\xdb\x9f\xa8\x73\xa0\x3a\x53\x99\x47\xf7\xd5\x23\x9a\xc6\x9c\xf1\x1b\x61\x49\x89\xd6\x86\x82\x9c\xe7\x8b\x9d\x0e\x6a\xf1\x2e\x46\x81\x98\x92\x8b\x9d\x40\x8c\x77\x1c\x20\xa5\x9e\xab\xac\x54\x75\x79\x85\xb7\xc2\x4f\x93\x97\xac\x0b\x21\xe6\x4d\xf0\x32\x4f\x79\x9d\x87\x07\xb8\xf0\x98\xbf\xab\x81\xaf\xfa\x9f\xdf\x4c\xf3\x22\x43\x3f\xa1\xd8\xeb\x76\xa0\x3c\xa6\x62\x78\xc3\x1b\xe2\xbf\x74\xf9\x57\xd5\x2a\xed\x55\x6b\xbc\xa4\xb9\x5a\xba\x44\xfb\x31\x8e\x90\xc7\x74\xeb\x31\xd9\x8a\x61\xda\x91\x63\xd3\xb0\x3d\x9c\xe7\xd8\xd3\x10\xa7\x88\x2b\xa3\xa3\x0d\x56\xab\xd7\x12\x24\xf8\xdf\x8d\xb4\x70\x92\xc7\x68\x2b\x98\x68\xed\xa0\xea\xb1\xda\x3d\xce\x71\x2b\x34\x93\xc6\x0e\x75\xcf\x2c\x3a\xfd\xf9\x81\xd1\x7e\x3f\x63\xc8\xce\x45\x8a\x92\x8f\xec\xe2\x70\xb5\x6c\x43\xeb\x6f\x7f\x8b\xbe\xf0\x8f\xbb\xd8\x81\x2e\xb4\xbe\xfe\xed\x6f\x3f\xb7\x02\x68\x5d\xb4\xc0\xc3\x57\x00\x5a\xff\xf3\xc7\x56\xd5\x61\xcf\x51\x4c\xf7\x68\xdf\xdc\xd3\x54\xa1\x7d\x7a\x98\x69\xa5\x62\x5e\x64\x8f\x92\xf5\x84\xd6\xbf\xb1\xc4\x17\xe6\xbc\x6a\xbc\x58\xce\x59\xf9\x01\x78\x0f\xd2\xdb\xa8\xce\x39\x7e\x21\x62\x62\x18\x10\xcc\xaf\x7a\x11\xb1\x24\x5d\xc4\x09\x7f\x25\x50\xb9\xb4\x07\xa5\x6b\x47\x08\xcb\x34\x8f\x8b\xf8\xd6\xcc\x61\x23\x21\x1c\x64\x27\xfd\xb8\xf0\xf9\x92\xcd\xe2\xf3\x98\x45\xa5\xa6\xd3\x68\xf5\xe8\xbc\xd2\x81\xea\xf4\xf5\x9e\xc4\x42\x5c\x28\x29\x89\x08\x1d\xaa\xaf\x22\xd8\xfe\x8e\xe5\x85\xec\x57\xc2\x66\x2c\xcf\xc3\x6c\x0d\x45\x6a\xa8\x6e\xd4\x58\xeb\x01\x9d\xe8\x25\x63\xf8\xe7\x99\x12\xd6\xa2\x52\x96\x3e\x88\x99\x7b\x28\x27\xa5\x8c\x57\xc2\xa0\x4e\x1c\xe8\x37\x95\xad\x15\x07\x97\xfa\xfe\x1a\xc1\x49\x4e\x6c\xbb\xc3\x2b\x1a\x5f\xeb\x88\x31\x0b\x57\xa5\x59\x53\xdd\x12\x65\xac\xca\x96\x28\xa3\x96\x97\x2e\xcc\x2c\x22\x4a\x8c\x09\xb3\x2c\x80\x68\x18\x40\xb4\x83\xa6\x7d\xb6\x5a\x62\x98\x44\x32\x0c\x3c\xb0\x6b\xd7\x30\x96\xc1\x57\xdf\xc6\x74\x1f\x39\x9a\xd1\xe3\xc9\x21\xc1\x37\x12\x7e\xf0\x45\xc3\x86\xa5\x23\x5e\x3a\xa1\x4b\x53\x92\xd4\x22\x2a\x45\x37\xea\x30\x92\xd1\x66\x63\x11\x6c\xe6\x32\x6f\x57\xbd\xbb\x88\x88\xb3\xa1\x24\x73\xed\x3b\xad\x9f\x08\xb3\x58\x22\x92\xbd\xb4\x3b\xd0\x41\x78\xaa\xfe\xbc\xc0\xae\xd7\x83\xee\xaa\x58\x73\xff\x61\x2a\xa3\xd0\x77\x76\xfc\x3e\xb6\x00\x2d\x7b\xed\xb5\xf0\x00\xb9\x86\x03\x68\xe9\xcb\xb0\xc5\xef\x4a\xe6\xb2\xe6\x1c\x9f\x8f\xe5\x76\x07\xf0\x60\x60\x87\xf3\xed\xfb\xca\x1d\x9d\x73\xf2\x46\x6e\xa0\x34\xe9\xc5\xda\x2e\x96\xda\x6b\x10\x69\xd6\x35\xbe\xc9\x77\xf7\x4d\xce\xc0\xe7\x58\xb6\xe0\x2b\xf1\xc9\xb5\x74\x6c\xe3\xff\x55\x5a\xec\x44\x85\x95\x8e\xa0\xd3\xbf\x28\x98\x98\x8c\x03\x48\xa4\x98\xbe\x25\x22\x78\xe9\xb4\x50\x81\xc1\xf7\x0b\xe5\x7a\x6d\x1b\x05\x9c\x28\x91\xd5\xac\x16\x05\x3c\x96\x81\x34\x34\xc7\x12\xa5\xe5\x10\x62\x50\xa8\x88\x09\x2d\x7d\x4e\x16\x71\x82\x0c\xcf\x5e\x04\xc5\x65\x58\x71\x73\xdd\x54\xe6\x32\x60\xe9\x64\x10\xa1\x3f\x43\x5e\xc1\x0c\xac\xfa\xcc\x05\x1b\x88\x64\x9a\x18\xf8\x70\xfc\xd7\x4f\x7f\x3f\x39\x9c\x9c\x42\x9b\xb3\x21\xf4\xe5\x7f\xaa\x7b\x26\x88\xa8\x3c\x0d\x94\x80\x97\xda\xc7\x7f\x2d\xaf\x0a\x31\x95\x8b\x48\xec\x9d\xd9\x62\xd9\x8e\x30\x03\x18\x02\xce\x33\xf9\x5b\xc4\xe7\x6e\xa4\x2c\x13\x66\xef\xb1\x79\x09\xfa\x61\x92\x56\x48\x20\x32\xd8\xc5\x05\x4e\x30\xd9\x80\x13\xf8\x3c\x18\x08\xb6\x84\x0c\xca\x04\x1b\x49\x86\x6a\x28\x6c\x9b\xb9\x1e\x6a\x50\x07\x10\x98\x04\x10\xb9\xf9\x05\xcb\x91\xde\x41\x0e\x2a\x23\x0d\x14\x12\x60\x34\x22\xf1\x76\x44\x80\xf6\x0e\x0e\x1e\x3f\x3a\x30\xba\xc7\x9b\x85\x3d\x12\x9f\x44\xbc\x40\xae\xbd\x43\x70\x4c\xc1\xa0\xad\xce\x88\x3e\xe2\xac\x10\x7d\x12\x03\x47\x10\xc3\x33\xc4\x86\x38\x94\xdf\xeb\x21\x45\x50\xb2\x36\xa9\xa8\xce\x87\x75\x11\x49\xda\xd1\xb0\x13\x40\x34\xa2\x87\x58\x9c\x36\xea\x8b\xa2\x1d\xd9\x8d\xc4\x1d\x5f\x31\x5a\x4e\x49\x62\x26\x92\xa1\x70\xbd\x1a\xf5\x73\x20\x3c\x6d\x18\x3c\x1b\xc3\xce\xe6\x94\x00\xa5\xbc\x19\xe7\x30\x9b\xa7\xb9\xc0\x7c\x59\xf1\x63\x7e\x10\x61\x62\xa8\x64\x34\x88\x46\x06\x19\xa1\x25\x10\xcb\x6a\x24\xbe\x9a\x39\xf9\x40\xe5\xb8\xac\x3a\xfd\x70\x9a\xb7\x3b\xb8\x5a\x08\xe6\x2a\xa8\x0c\x85\xa4\xb1\x91\x0a\x6e\xf5\x91\xe7\x36\x72\xca\x07\xa3\xe2\x95\xbc\x63\xda\x9f\x70\xe6\xb9\x32\x9c\xf2\xa1\x34\xaa\x0d\x8d\x6a\xd6\x18\x56\xbb\x9c\xad\x96\xa4\x99\x33\xcc\xb6\xba\x35\xd4\xdd\x0c\x66\x69\x72\xcb\xb2\x42\xf9\x16\x48\xb9\x76\x99\xc5\x0b\x14\xe0\xbd\xfe\x9b\xa9\xac\xdf\x04\x0f\x93\x00\xca\xad\x7c\xad\xf0\x4a\x70\x19\xe6\x2a\xda\x05\xbd\x18\x48\xf0\xe8\xee\x8a\xb3\x54\x91\x2b\xfe\x00\xff\x7d\x86\x61\xd2\x32\x39\x49\xf3\xf1\x08\x1f\xe9\x84\xc1\xe5\x97\x12\x9c\x40\x1c\x5f\x89\xa1\x0b\x3d\x3a\x87\x44\x4f\xde\x26\xa5\x81\x47\x47\x1d\x73\x82\x1f\x8e\xff\xfa\xf7\x0f\x1f\x0f\x7f\x39\xfa\x74\x74\x3c\x51\x17\x9b\xa1\x12\x34\x8a\xd4\x2a\x40\x58\x96\x7d\x57\x86\x84\x42\x4e\x78\x35\x1c\xbe\x18\xbd\x7a\xb5\xb3\xb7\xfb\x62\x77\xf8\xea\xd5\x0e\x6f\xc1\x79\x46\x6b\x82\xdb\x1f\x58\x76\x9e\x66\x8b\x1c\xf6\x76\x61\x9e\xa6\xcb\x2a\xf0\x25\xc7\x53\x04\xf3\x95\xda\xc4\xfa\x1d\xdf\x8d\x66\x99\xde\xb5\x3b\x55\x44\x97\x73\x87\x49\xac\x2b\x8c\x55\xde\xba\xb4\x24\x35\x77\x96\x0f\x38\x97\x63\xf8\xd0\x5f\xa6\x77\xc6\x92\x4e\xa8\x35\x7d\x1d\x00\x91\x8c\x29\x86\x31\x2c\xc2\xe2\x52\x80\x05\xcb\xf4\xdc\x07\xd0\xe3\x62\x5a\x37\xa1\xb4\x11\xfe\xbd\x81\xf1\xc1\x9a\x57\xaa\x0a\x14\xe6\xdd\x8b\xcf\xab\x6f\xb4\xc0\x29\x28\x1c\x68\x5d\x13\x9c\x34\x84\x63\xd8\x79\x1e\x40\x4b\x35\xd2\x82\x0e\xfc\xf8\xa3\xd5\x79\x24\x2c\x12\x5c\xf2\x31\x7a\x78\x80\x98\x42\x3a\xc0\x00\xed\x04\x06\x22\x58\x98\xc0\x42\x59\x86\x59\xce\x7e\x9d\xa7\x61\xc1\xc9\xf0\x5b\x10\xfa\x06\xb7\x85\x77\x3d\xdf\xd8\x3e\xfc\x15\x32\x38\x5c\x0d\x52\x1b\xba\xfc\x80\x71\x8f\x5f\x37\xde\x55\x06\x83\xf0\x5d\xc3\xc2\xd9\xa5\x10\x77\xe3\x59\x8c\x59\x0b\x50\xcb\x82\x8c\x51\xca\x91\xe9\x39\x5c\xcb\xe8\x56\x2c\xad\x60\x84\x67\xc2\x82\xc6\x3e\xdf\x84\x05\xcb\xed\x36\x38\xcb\xa8\x9a\x21\xdc\xb4\x9c\x6d\xdc\x85\xd3\x9d\x97\x01\xec\x8e\xce\x02\x81\x57\x2c\xa2\x6a\x4a\x0d\x8b\xdd\x82\x12\x9c\xd3\x73\xd8\x79\x09\x17\x37\x61\x16\x29\xda\x19\x2b\xc2\x38\x61\x51\x1f\xda\x7f\x41\xe6\xd0\x85\x51\x7f\x4f\xc6\xc9\x5e\x70\x2e\x75\xfa\x2a\x80\x9d\xd1\x99\x51\xad\x6f\xaa\xb6\xae\x85\x8c\xac\xf5\xf0\x00\x17\xfb\x8c\xc5\xf3\xb6\xf5\x66\xa0\x8b\xc9\x3b\x28\xe3\x6e\x4c\x39\x46\x5c\x8d\xcd\x10\x57\x5a\x46\x8c\x45\x5c\xb8\xcf\x03\x1c\x1d\xae\x85\x7c\xe3\x8b\xa8\xa9\xe0\xc8\xbd\xf2\x65\x59\x0c\xaf\x67\xeb\x2a\x61\xe9\x5b\xb8\x86\x8e\xfe\x00\xef\xd6\x76\x55\xe2\xde\x69\xb1\x8a\x58\x84\xbc\x7b\xe4\xe0\x27\x71\xd5\x35\x92\x85\xac\x6a\x3e\xb1\xea\xb7\x84\x5a\x5f\xd9\xdd\x5f\xd5\x74\x9f\xba\x39\x26\x12\x59\x92\x0f\xee\xf1\xe4\xb0\xcf\xc5\x2b\x1b\x25\x57\x6e\xce\xeb\xca\x19\x6b\x1d\x98\x8b\xc4\x11\xc3\x60\x5f\xf7\x1c\xff\x1e\x56\x6f\xcd\x87\x92\xf4\x95\xd4\x1b\xa1\x9d\x4f\x1c\x23\x38\x2a\x23\xf3\xc8\x4d\x09\x6a\xe3\xbd\x19\xc7\xae\xa6\x60\xb4\xb4\x8a\x76\x4a\xfa\xea\x73\x3c\x26\x7b\x19\x72\x67\xc4\xba\x3f\xdb\x84\x81\xf3\xcf\xe2\xcf\xf9\x41\x03\x53\xdc\xce\x3b\x93\xae\xb9\xd9\x19\x54\xaf\xb7\xbd\x1d\xd8\x5f\x7b\x1b\x53\xf0\x07\x0d\xbe\x72\xb3\x7b\x27\xe9\x9a\x92\x47\x3e\x53\xb0\xee\xc4\xb9\xb3\x6b\x39\x71\x5a\xcc\xe3\x40\xfa\x72\x9a\xc6\xe0\xdd\x7f\x80\x73\x0a\x3a\x9f\x4f\xd1\xd5\x0b\x7f\x1d\x61\x20\xcc\x14\x62\xd3\x6b\x44\xba\x7b\x09\x83\x00\x16\x8c\x73\x5d\xe5\x8f\x6b\x4c\x84\x8b\x0b\x2a\x41\x33\x79\xdc\xf8\x0c\x67\xbb\x57\x4d\x59\x16\x06\xa1\xc3\x32\xbe\xe5\x32\xcc\x35\x63\x48\xb9\x2f\xf5\x06\x50\xb3\x15\xe7\x95\x05\x24\xcd\xcc\xc4\xee\x27\xc7\xfc\x32\xf8\xf7\x0f\xc7\x9f\x70\x40\xc2\xea\x72\x51\x4a\x81\x7a\xdd\x92\x0f\xe9\x8d\x48\x1a\x93\xc3\x3f\x05\x6a\xc5\x6c\xc5\x23\xa6\x67\xc4\x55\x01\xaf\x06\x3f\xed\x36\xda\xca\xe5\x5d\x17\xc7\xce\xd9\x4c\x53\x67\x2f\x99\x15\xac\xfd\x33\xad\xd9\x3e\x12\xdc\x43\xdf\x3b\x53\x8f\x0b\x05\xa1\xe6\xf7\x9a\x10\x72\x81\x9d\x40\x63\x2d\x25\x7d\x46\x45\xeb\x18\x79\x5b\x88\x40\x3e\x86\xc8\x18\xa5\xda\x9f\x3c\xbb\x73\x9f\x6c\x23\xcc\xb3\x2d\xd5\x0a\x01\xc0\x03\x3a\xf0\x08\x3f\xb1\x65\x15\xb4\x04\x1b\x76\x47\xf5\x53\x1b\x47\x26\x6b\x4f\xc2\x09\xd1\x96\xa5\x70\xf6\xd1\x11\x34\x2c\xb0\x8f\x84\xcb\x5e\x3e\x93\xc4\xd4\xeb\x34\x3e\x0d\x60\x27\x80\x9f\x76\x03\xd8\xd9\x0b\xa0\xc5\xd7\x49\xcb\x73\x57\xa8\x9a\x66\xf0\x66\xac\xed\x06\x01\x2d\xf4\x76\xac\x6d\x32\xb2\x32\x67\x86\xa6\x5f\x30\xae\x1f\xf0\xd9\xad\x01\xf6\x41\x3a\x18\x22\xb0\x77\x55\xfc\x51\x83\x2e\x75\x34\x3f\x87\x39\x6b\x7b\xe8\x06\x30\xe5\xbc\x3a\x40\x2e\x97\xd3\x59\x42\xe9\x11\x2e\x91\xb4\x12\x05\x7a\x53\xbb\x4e\xbe\x91\x19\xfb\xf1\xd1\xc7\x32\x76\x5f\xea\xab\xee\x2e\xd3\xb9\x69\x65\x76\x90\xa8\x0d\xfe\x50\xd6\x1e\xab\xbf\x9a\x24\x97\x57\xb6\x18\x37\x86\x22\x30\x70\x3f\x47\xce\xe1\xb8\x61\x1c\xf8\xcd\x4f\xec\x83\x00\x9d\x8a\xa3\x54\x30\xc7\xd9\x8c\x2d\x0b\x75\xd4\x28\x5c\x44\xdf\x47\xe1\x50\x1d\x9f\x8b\x4f\x4a\xff\xe5\xd3\xf1\xa4\x71\xbe\x7f\xca\xee\x63\x4e\xdf\x00\xde\xcd\xe3\x30\x67\x42\x83\xf3\x73\x7c\xa1\xfc\x04\x17\xac\xb8\x4c\x23\x2d\x36\x61\x30\x50\x79\x4a\x44\xe2\x92\xd7\xa0\x11\x11\xaf\xc4\x89\xcc\x22\x08\xa7\xa9\xe6\x1c\xc0\x6b\x96\xf9\x1f\xc7\x2a\x55\xf6\x6b\x55\x33\xbf\x99\xd6\xd5\x94\x57\xf0\xb5\xf8\x7e\x7e\x13\x2a\x6b\x2e\x6e\xe6\x75\x35\xa3\xf8\x36\x8e\x18\xd6\x8b\xe2\xdb\xd7\xc6\xbb\x8c\x2d\xc2\x38\x89\xa4\x5a\x68\x91\x46\xe6\x6b\x99\x0a\x5e\xe6\x97\x9f\x2d\x96\xe6\x6b\x91\x35\x48\x25\x0d\xd2\x07\x54\xc2\x26\x25\xe7\xf1\xc5\xf1\xf4\x4a\xb3\xfb\xda\xae\xae\xed\xb2\x90\xce\x1c\xe5\xe4\x95\x85\x45\xb3\x5f\x65\x03\xfc\xa3\x3f\x1e\xfd\xeb\xbb\x93\x43\xf8\xf3\xe1\xfb\x0f\x87\x1f\xe1\xd7\xbf\x4c\x7e\x39\x39\x3a\x9e\x7c\x92\x25\xca\x65\x51\xc6\xd9\x1a\x1a\x2e\x74\xdc\xe3\x27\x9a\x19\x61\xa3\x94\x2d\x68\xbc\x7a\x78\x40\x34\x9c\x31\xc4\x70\x00\x31\xec\x43\x5c\xd9\xd5\xb4\x8e\x94\x5b\xdd\x55\xa8\x08\x6f\x14\x71\x50\xa7\xe7\xa5\x8c\x27\x2f\x1c\x66\x3f\xcd\xc3\x22\xb4\x3b\x9b\x07\x70\x6f\x1e\xca\xbc\xfb\x23\xf3\xd1\x15\x8c\x21\x94\x97\x5c\xf3\x0d\x9f\xdd\x90\x73\xbd\x2e\xb4\x5a\xda\x30\xeb\xce\x62\x57\x6e\x44\x68\x8e\xd5\x30\xbd\xa8\xa8\xa8\xbf\xbc\x87\x71\xa5\x00\xe9\x41\x4e\x46\x22\xab\x06\xee\x7b\xbd\xd7\x48\xae\x35\x44\x76\x6b\x73\xee\x0c\xba\x46\xae\xae\xaf\xc6\xd6\xac\x4c\x2d\x26\xaa\x79\xdf\xfa\x90\x2b\x04\x2d\x93\xfd\x80\x0c\x91\x53\x7e\x49\x23\xf6\xae\x68\xf7\x7a\x57\x02\xa1\x6b\xf7\xe5\x6b\xbd\x71\xc5\xf9\x34\x0c\xae\x2b\x74\x0d\x7d\x78\xa8\xd8\x9c\x36\xdd\xbf\x88\x0d\x61\xf2\xee\x72\x99\xe6\x66\x56\x48\x6d\x76\xb1\x96\xc8\x2e\x06\xf6\xe4\x86\x01\x4c\xcd\xf9\xa2\x3d\x39\x54\x76\x1c\x77\x21\x38\xf0\x98\x57\x02\x51\x20\x70\x94\x5b\x0e\x5e\xe6\x5c\x44\xeb\xbf\x36\x06\x9c\xca\x62\xa4\x94\x34\x5c\x40\xb9\xb2\x71\xef\xcb\x52\x22\x35\x48\x85\x8c\x50\x8d\xb4\xc8\x0c\x52\x81\x23\x90\x2d\x9a\x68\x9a\x32\xcd\xc7\xc3\x03\x68\x29\x93\x42\x38\x80\xa9\x44\x8e\xed\x5d\xf1\x7d\x69\x52\xa2\xd3\x25\x49\x35\xda\x93\x31\x68\x7d\x8f\xad\x8e\xf3\x6d\x30\x34\x7b\x7c\xcd\x05\xb3\x39\xd9\x57\x37\x1d\xbd\x37\x8f\x90\xea\x2f\x7f\xf7\x7f\xf1\x0b\x46\xbc\xf7\x23\x93\xae\x5a\x5b\x44\x5a\x6c\x41\x59\x1b\x85\x6b\x78\x0b\x73\x1f\x2d\x91\xa0\xfa\x9a\xc8\x4b\x3d\xb7\x52\x21\x1f\xc0\x35\xec\xdb\xdf\xa7\xfa\xe1\xcb\x83\x5d\x85\xbc\x0f\x4b\xd6\x11\x63\xb2\x6a\x95\x0e\x38\x56\x59\xa9\xe3\x33\x3d\x17\x3f\xff\xf3\xad\x7c\xbc\x79\x18\x44\x27\xb5\x41\x28\x3f\x9d\x4f\x89\x1c\x51\x6a\x1c\x40\xdf\xb2\x52\x1e\xa9\x8c\x84\xd9\x0d\x13\x60\xdb\xe8\x9d\x71\xcb\x05\x6d\xa5\xc7\x8a\x13\x71\xf7\x0a\x2a\xb8\x6a\xe1\x2a\xd3\x57\x44\xfe\xc2\x9f\xf0\xeb\xa9\x82\x9c\xc6\xfa\x42\x29\x8e\x59\x72\x2d\x1f\x9b\xb2\xa2\x88\xca\x42\x33\x00\x17\xeb\x5b\x23\xd6\x1d\xb5\xa4\xc5\x9f\x4b\x44\x9a\x81\x40\x7f\xa7\x90\x30\xa4\x20\x54\x32\x94\x38\x29\xfe\x55\xb4\x9c\x66\x93\xf4\x30\xcb\xd2\x2c\x47\xbb\xc7\x22\xe6\xff\x84\x2b\x83\xc9\xc8\x81\x13\xd6\x86\x12\x03\x3a\xe1\xb7\x88\xb7\x63\x5e\x45\x40\xbf\xbd\x19\xf3\x9a\xe6\xf8\x55\x2d\xe6\xef\xf8\xa1\xd6\x4e\xa7\x57\x04\xe9\x63\x0c\x66\xe9\x2f\xb3\xb4\x48\x8b\xf5\x92\x95\x12\x57\x7f\x16\xce\xe7\xa2\xd2\x78\x0c\xad\x53\x19\xf5\x82\xb4\xce\x5a\xbe\xb9\xfa\x45\xdc\x04\xac\xc3\xf3\x28\x91\xde\x46\x65\xea\xf0\x44\x72\x5d\x59\xe0\xf8\xa6\x28\x07\xfc\xf0\xa2\x6f\x5c\x28\x5a\x3b\x7b\x7b\x2d\x71\x6f\x18\xfd\xa4\xd6\x64\x0e\xa7\xa3\xbd\x00\x46\x7b\x67\xfe\x7a\xe7\xe7\x2d\x01\xdc\x3d\x1a\x6a\xd5\x76\x02\xd8\x0b\xa0\xaa\x67\xcd\x4f\x91\xfe\x2c\xfa\x23\xaf\x2e\xa2\xfb\x81\xea\xa5\x73\x04\x5c\x99\x4c\x59\xf8\x05\x38\xfe\xf6\x61\x96\xbd\x77\x99\xbf\xe5\x41\x2f\xbc\xde\xf3\x22\x73\xfd\xdd\x1d\xdf\x70\xfb\xc0\x97\xb9\x8b\xb2\xec\xbd\x70\xe3\x2f\xcf\x52\xfe\x88\x1f\xe1\x61\x96\x9d\xf2\xdf\xcf\xe0\xd9\x58\xcd\x89\x75\x94\xf3\x22\xc8\x81\x86\x80\x29\xb9\xdf\xbd\xff\xf0\xe7\x77\x3f\x1f\x9e\x94\x10\xb1\xd8\x37\x09\x6a\x26\xf9\x86\xcf\x26\x72\x05\x6f\x8c\x6e\x5c\xf9\x52\xe2\x8b\x93\x22\xcb\x4e\xaf\x38\x87\x51\xa3\xdc\x03\xbf\xdb\x7b\x55\x83\x1f\xf7\x67\x50\xa9\x28\xf4\x87\x3e\x14\x0b\xad\x4c\x77\xac\x1a\x1e\x94\x0d\x7b\xd1\x2f\x64\xc9\xa7\x63\x55\x74\xb3\x53\x5b\xf5\x9b\xbd\xe9\xf8\xc8\x58\x09\xbb\x9c\x6d\xeb\xb9\xce\x53\xcc\xa1\x5a\x32\xf0\x16\x46\x70\xa0\xcf\xd3\xb0\xc3\x25\xc0\xbe\xbc\x2a\xeb\x11\x18\xfc\x16\xdd\x81\xae\xd6\x69\x85\x67\x7c\x00\x2d\xe1\xbe\xc8\xba\x2d\x1d\x0e\x98\xe8\x23\x75\xd5\xb7\x76\xc8\x9c\x25\x01\xdc\x9b\x27\xc5\xc4\x56\x11\x5a\x47\x31\x93\x1a\xa1\x2f\xf5\xa9\xe6\x28\x28\x99\x7b\x94\x55\xfb\xad\xd7\x88\xb3\x01\xf7\x12\xff\xd9\x5e\xec\x42\x87\x70\xaf\x34\x08\x7a\xe7\x3e\x78\xd5\xa1\xa4\x2a\xa4\x66\xdb\x4a\x82\xef\x96\xbe\x2e\xe3\xc7\x76\xbb\x8c\x9f\x85\x2c\x21\x97\xbc\xfe\x55\x2d\x3e\xbe\xbd\xb1\x60\x01\xbd\x5e\xcd\xe7\xa9\x4f\xec\x8e\xf9\xd0\xeb\x4f\xf5\x2c\xc7\x4c\xb0\x13\xb2\x5d\x31\x40\xd5\x9a\xe1\x02\xb6\x40\x69\xb1\x57\x93\x9d\x2e\xb0\x6e\xe5\x97\x7a\x18\x77\x2d\x69\xa7\x5b\xd5\x1b\x3e\xb4\x86\x09\x9e\xb8\xf3\x89\x25\x5b\x1a\x7b\x13\xbe\xb8\x2b\xe3\x65\xe2\x5e\x05\x0e\xff\xed\xc3\xf1\xc7\x13\xf9\x77\xa5\xb9\x19\x43\x98\xa0\xf8\x50\xa6\x38\xe4\x73\xf7\xdb\x1f\xc5\x94\x89\x90\xb2\xf5\x92\xa5\xe7\x10\xb1\x73\x7e\xa7\xe1\xe7\xa2\xea\x7f\x8b\x9f\xc4\xe2\x79\x3f\x5c\x44\xc6\x90\x8a\xc7\x6d\x53\xe5\xe1\xde\x94\xe1\x2b\x68\x0d\x4f\xd2\x48\xe4\xf2\x10\x30\x67\x2c\xb9\x8d\xb3\x34\xe1\xa2\x4b\x2e\xbd\x4d\x6f\x96\xcb\x34\x2b\x44\xaa\x72\xd6\xe7\x8b\x35\x53\x92\xa7\x3e\xc9\xb2\xcf\xa2\x18\x97\xee\x5a\x37\x89\xe8\x51\x84\x9d\x36\xeb\x1b\x1d\xb7\x5e\x8d\xed\x6b\x3d\x54\xf9\xb4\xb2\xf5\xb2\x48\xa1\x03\x45\xb6\x86\x2f\x20\xff\x1c\x43\xc6\x3e\xdf\xc4\x19\x6b\xb7\xc4\x93\x56\x87\x7f\xe5\x2c\x2c\x66\x97\xd0\x66\x1d\xf8\xf2\xb5\xfc\xde\x9f\xb3\xf4\x2e\x57\x8a\x31\x67\xa3\x5d\xcc\xd3\x69\x38\xef\xeb\x93\xe5\xa8\x18\xbe\x76\xca\x64\x3a\x5f\x83\x2f\x7f\x10\x2d\xfe\x61\x7f\x6f\xf8\xf5\x2c\xf8\xc3\x1d\x9b\x3e\xff\xc3\xfe\xa9\x9a\x82\xb6\xec\x58\x20\x3e\x31\x90\x9f\xd8\xf9\xf2\x03\x67\x59\x7f\x65\xd3\xe7\x7a\xe7\xfb\x83\x79\x3c\x1d\x70\x12\x98\x5e\x60\x30\x80\x28\x4d\x0a\x48\x6f\x59\x96\xc5\x11\x93\xbd\xe3\xdc\x2e\x0e\xa7\x73\xf6\x03\x1f\x13\x39\xec\x77\x71\x12\xa5\x77\x98\x53\xc0\x1a\x77\xa3\x40\x5f\x34\x69\x96\x52\x53\x61\x14\xc1\xce\xbd\xfe\xe1\xeb\x0f\x3f\x38\xb3\x23\xde\xe0\xc7\x57\x3d\xfe\xc3\xfe\xce\xce\xd7\xb3\xaf\xc1\x97\xaf\xc1\xa9\x18\x85\xb3\xce\x0f\x83\xc1\xff\x80\x3c\xbd\xc9\x66\xec\xb7\x70\xb9\x8c\x93\x8b\xbf\x7c\x7c\x3f\xe6\x2f\xfb\x57\x79\x7f\x11\x2e\x7f\xf8\x7f\x01\x00\x00\xff\xff\x27\xcf\x51\x53\x59\x92\x07\x00") +var _scriptsWeb3Js = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\xfd\x6b\x7b\x13\x39\xd2\x38\x0e\xbf\xcf\xa7\x50\xfc\xdc\x0f\xb6\x49\x63\xe7\x34\x0c\xd3\x99\x0c\x1b\x02\x33\x64\x6f\x20\x5c\x40\x66\x76\xef\x6c\x96\xab\xed\x96\x6d\x0d\xed\x6e\xff\xba\xdb\x09\x59\x92\xef\xfe\xbf\x54\x3a\x1f\xfa\xe0\x24\xcc\x69\x93\x17\xe0\x96\x4a\xa7\x52\xa9\x54\x2a\x95\xaa\x72\xfc\xff\x96\x24\xc7\xfb\xbd\xc9\x32\x1d\x97\x24\x4b\x11\xee\x95\x41\x1a\xe4\xfd\x2f\x32\xa5\xe8\x65\xc1\xb2\xff\x85\x4c\x7a\xeb\xe9\x69\x76\xc6\x7e\x95\xf0\xeb\x3c\xca\x51\xb4\x5f\x5e\x2e\x70\x36\x41\xa2\xae\xfd\x8e\x28\xda\x79\xf0\x80\x27\xee\xd1\x32\xcb\x07\x0f\xa2\x7e\x8e\xcb\x65\x9e\xa2\xa8\x97\x05\xeb\x9b\x7d\x9a\x4e\x44\x1a\xe1\x69\xb4\xd6\xc9\x7e\x8a\x2f\xd0\x8b\x3c\xcf\xf2\x5e\xe7\x30\x4a\xd3\xac\x44\x13\x92\xc6\x68\x9e\xc5\xcb\x04\xa3\x6e\x67\x23\xdb\xe8\x74\x3b\xfd\xbd\x72\x96\x67\x17\x68\x32\x18\x67\x31\xde\xef\xbc\x3e\x7e\x7e\xf2\xea\xc5\xc7\x37\xc7\x1f\x3e\xfe\x78\x7c\xf2\xe6\x79\x27\x98\x5c\xd3\xfa\x92\x7d\xda\xf7\xfd\x2f\xf8\xf3\x22\xcb\xcb\x22\xfc\x72\x7d\xbd\x47\xc7\x70\xba\x79\x36\x18\x47\x49\xd2\x4b\x06\x3c\x2b\x10\xbd\xef\x61\x36\xc0\x74\x1f\x00\xb7\xce\x4e\xf1\xd9\x1e\xef\x6a\xd1\x4b\x9f\xa6\x21\xee\x5f\x07\x49\xa0\x4a\xe2\x80\xe1\xee\x9a\x43\xd1\x26\x45\x26\xf4\x82\xb4\xc2\xd5\x24\xcb\x7b\x14\x3a\xdb\xdf\xdc\xcb\xbe\xcf\x07\x09\x4e\xa7\xe5\x6c\x2f\xdb\xd8\xe8\x17\xbd\x9c\x22\x5e\x76\xe3\xba\xdf\xfb\xb2\x15\x9e\xca\x2e\xf3\x2a\x02\x86\xa5\x80\xb7\xdd\xff\xb2\xc6\x12\x44\x67\xf6\x4f\xd7\x10\xfa\xb2\x86\x10\x42\x9d\x71\x96\x16\x65\x94\x96\x9d\x10\x95\xf9\x12\x07\x2c\x95\xa4\x8b\x65\x59\x74\x42\x74\x0a\xdf\x02\x1a\xf2\xd2\x68\x8e\x3b\x21\xea\x7c\xcc\x2e\x52\x9c\x77\x02\x95\x43\x47\x47\x73\xa2\x38\xce\x71\x51\x74\x78\xce\x35\xfc\x7f\xc6\xab\x16\xc5\xe1\x7f\x9e\x96\x2d\xcb\xe6\xf6\xb2\x8f\x5a\x11\xa3\xbd\xd1\x65\x89\x8b\x9d\x6d\x7f\x7b\x02\x48\x62\x7a\x0d\xa1\xeb\xe0\x4e\x10\x70\xa3\xfe\xc8\xe1\x68\xd8\x6b\x87\x80\x95\x51\xfd\x47\x1d\xfa\x38\x4b\x4b\x9c\x96\xb7\x1e\xfc\x9f\x72\xde\xe9\x8c\xfd\x61\xa6\x7d\x12\x25\xc5\x6f\x37\xf4\x1c\x17\x38\x3f\xf7\xad\xfa\x3f\xfa\xa4\x15\xcb\xd1\x3b\x3c\x25\x45\x99\x47\xff\x05\x93\x17\xd4\xd5\x81\x2f\x8e\x6f\xc5\xf7\xcb\x3c\x4a\x8b\x89\x97\xf5\xfd\x59\x70\x90\x5b\xa4\xb0\x3a\x12\x0a\x5c\xbe\xaf\x27\xa9\x3b\xc3\x85\xdd\xf4\x6f\xd2\xe8\x57\x9e\x80\xa8\x0d\xe2\xeb\x2a\x58\xe4\x64\x1e\xe5\x97\xde\x7e\x64\x59\xd2\x38\x79\x07\xbc\xad\x3f\x2f\x0a\xcd\x3d\xb8\xb6\x9a\x2a\x24\x1c\x56\x6e\xe3\x7f\x24\x24\x78\x7b\x1f\x93\x22\xbb\x48\x6f\xd1\xf3\x28\xcd\xd2\xcb\x79\xb6\x2c\x56\xe8\x3a\x49\x63\xfc\x19\xc7\xc6\xde\x75\x67\x13\xab\x2a\xd7\xba\x63\xd6\x7e\x41\xd2\xdb\x30\xee\x83\x25\x60\xe2\x45\x1a\xe3\xb8\x63\xa1\x09\x9f\x53\x42\xf8\x0b\xe0\x68\x44\xe2\xb8\x1d\x8e\x6e\x56\xff\x79\x94\x2c\xbd\xdd\x5f\x92\xb4\xdc\xfe\xe6\x71\xfd\x14\xbc\xc1\x17\xcf\xc8\xef\x88\xfc\x5b\xad\xb9\xc3\x59\x94\x4e\x7f\x4f\xd2\xb9\x13\xca\xa9\xa8\x5b\x93\xea\x6b\xa9\xc6\x8b\x99\xb7\x6c\x37\x6a\x44\xd0\xda\xd9\xda\xda\x75\xf0\xe5\xfa\x2c\xd8\xfe\xdd\x0e\xfd\x7f\xa1\x33\xef\xef\x24\x3b\x4e\x96\x69\x7c\x63\x52\xb9\xf5\xc6\x75\x7f\xec\xfd\x73\x1f\x7b\xef\x0f\x7d\x7f\xe4\x33\x87\x77\xf0\xfc\xbc\xf0\x47\x93\x36\xbf\xee\x66\xae\xf6\xaa\x9d\x3b\xdb\xab\x56\x9d\xf7\x49\x9e\xcd\x6f\x39\xed\x65\x76\xcb\xa3\xe6\xed\x04\xbe\xdf\x77\xdd\xfc\x11\xf0\x47\xd2\x98\xe4\x78\x5c\x1e\x79\xf7\xcc\x15\x7a\x72\xbb\x89\x20\xe3\x68\xf1\xe1\x77\x9d\x0c\x3f\x26\xdb\x9d\x76\xf1\x22\x2b\x48\xdd\x41\x7d\x11\x5d\x46\xa3\x04\x9b\x42\xc1\xef\xc2\x95\xaa\x68\xee\x4e\x8e\x5f\xb7\xa3\x81\x03\x31\xde\xe7\x26\x3e\x7f\xfb\x93\xcc\x9d\x20\xa9\xa2\xee\x76\x74\xf6\x3b\xa0\xff\x0f\x8b\xf5\xbb\x38\x3f\xde\x98\x4f\x7e\x6d\xac\xdb\x4c\xef\x1e\xed\x2d\xd1\x7e\xeb\x8d\xeb\x6b\xcf\xec\x91\x67\x4b\xab\x93\xe3\x76\xdb\xc8\x71\x60\xbc\x81\xf6\x85\x85\x43\xaf\x3b\x18\x4e\xb2\x7c\x1e\x95\x25\xce\x8b\x6e\x7f\x0f\x00\xde\x67\x09\x89\x49\x79\xf9\xe1\x72\x81\x4d\x58\xda\x3e\x85\x5a\x1b\x3e\x7c\xb8\x86\x1e\x1a\x90\x5c\xe7\x8e\x48\x81\x22\xb4\xc8\xb3\x8c\x02\xa3\x72\x16\x95\x28\xc7\x0b\x7a\xc8\x4a\xcb\x02\xf1\xb9\x43\x34\x93\xd6\x70\x54\xa2\x79\x54\x8e\x67\xb8\x08\xe9\x27\xcf\xd6\x7e\x9e\x9e\xe9\x1f\xbb\xc6\xd7\x99\x99\xb9\x63\x7d\x9f\x9d\x3e\x3e\x3b\x3d\x0b\xd0\x60\x30\x58\x43\x0f\x87\xce\xd8\x44\x8f\xf7\x91\xb4\xa6\xe9\xf5\xf9\x14\x97\x33\x52\x0c\x3e\xc2\xc2\xf8\x51\x20\x88\x02\x0e\x18\xba\x8e\x68\xc6\x51\x5a\xee\x69\xc0\x6c\xdf\xf6\x41\x1f\x43\x0e\x6f\x6e\x6f\xed\x7a\x6f\x6d\xcd\xd3\x8f\xc1\x22\xcf\x4a\x86\xb5\x7d\x94\xe2\x0b\xa3\xaf\xbd\x2f\xd7\xfd\xbd\xfa\x52\x03\x90\x5e\xf2\xe5\xb8\xcc\x68\xe3\x1e\xd8\xa6\x76\x07\xa4\xe0\x73\xae\x10\x42\xc9\x51\x20\x85\xdb\xb5\xac\xaf\xd3\xc4\x01\xcc\x5b\x6f\xc8\xb1\xdd\xfb\xd7\x69\xef\x74\xf3\xd1\x77\x67\x0f\xfb\xff\x3a\xeb\x3f\x1d\xf6\xd9\x38\xcd\x83\x43\x65\xb7\xae\x83\x2f\x1d\x9d\x14\x3b\xe1\x77\x41\x87\xd1\x5b\x27\xdc\xda\xbd\x3e\x0b\xbe\xf9\x9d\xc9\xfb\x59\x96\x25\x0d\xb4\x3d\xa2\x20\x15\x84\x4d\xf3\xc4\xff\x8c\x4a\xe1\xd7\xae\xfa\x79\xa6\x25\xef\xe8\x1f\x4d\x64\x0c\x3d\xbb\x29\x0d\xd3\xc2\xab\x10\x31\x83\xb7\x29\x98\xa6\xae\x48\xbe\x66\x91\x1a\xda\x65\x2d\xd6\x95\xbd\x09\xd5\xfe\x9b\xa2\xd6\xa4\xd9\x87\xff\xd3\x8a\x68\x79\x7f\x9a\x29\xf6\xf1\xef\x4d\xb1\x74\x0f\x93\x24\x5b\xfa\x69\xb6\x9c\x61\x04\x9b\x1d\x10\xee\xc0\x47\xb9\x34\x57\xfe\xe0\x74\x09\x3f\x77\xb5\xdf\x67\x7a\xc6\x8e\xf1\x65\xd2\x2f\xe2\x5b\xab\xfc\xf9\xc4\xa8\x87\x17\xf5\x50\x39\x74\xf2\xc6\x64\x4e\x4b\xaf\x44\xe7\xac\x80\x43\xe8\x34\x79\x55\x4a\x37\xcb\xd4\x91\x3a\x6b\xb4\xb6\xf4\xcd\x88\x9d\x56\xc2\x48\xfd\xcb\x56\x70\xdd\xbf\x19\xe1\xf3\xde\x35\x53\xfe\xb7\x6d\x28\x7f\xf8\x10\x3a\xfc\x61\x46\x0a\x34\x21\x09\xa6\x94\xba\x88\xf2\x12\x65\x13\x74\x81\x47\x3b\x83\x5f\x8b\xc1\x1a\x80\xf0\x2f\x0a\x30\xc9\x31\x46\x45\x36\x29\x2f\xa2\x1c\x87\xe8\x32\x5b\xa2\x71\x94\xa2\x1c\xc7\xa4\x28\x73\x32\x5a\x96\x18\x91\x12\x45\x69\x3c\xcc\x72\x34\xcf\x62\x32\xb9\x84\x3a\x48\x89\x96\x69\x8c\x73\x20\xf8\x12\xe7\xf3\x82\xb6\x43\x3f\x7e\x7a\x73\x82\x5e\xe1\xa2\xc0\x39\xfa\x09\xa7\x38\x8f\x12\xf4\x76\x39\x4a\xc8\x18\xbd\x22\x63\x9c\x16\x18\x45\x05\x5a\xd0\x94\x62\x86\x63\x34\xba\xe4\x54\x84\xd1\x8f\xb4\x33\xef\x79\x67\xd0\x8f\xd9\x32\x8d\x23\x3a\xe6\x00\x61\x52\xce\x70\x8e\xce\x71\x5e\xd0\x19\xda\x11\x6d\xf1\x1a\x03\x94\xe5\x50\x4b\x2f\x2a\xe9\x18\x72\x94\x2d\x68\xc1\x3e\x8a\xd2\x4b\x94\x44\xa5\x2a\xeb\xa2\x40\x8d\x34\x46\x24\x85\x6a\x67\x99\x58\xd9\xa4\x44\x17\x24\x49\xd0\x08\xa3\x65\x81\x27\xcb\x84\x09\x8e\xa3\x65\x89\x7e\x39\xfa\xf0\xf2\xf8\xe4\x03\x3a\x78\xf3\x4f\xf4\xcb\xc1\xbb\x77\x07\x6f\x3e\xfc\x73\x0f\x5d\x90\x72\x96\x2d\x4b\x44\x25\x4a\xa8\x8b\xcc\x17\x09\xc1\x31\xba\x88\xf2\x3c\x4a\xcb\x4b\x94\x4d\xa0\x8a\xd7\x2f\xde\x1d\xbe\x3c\x78\xf3\xe1\xe0\xd9\xd1\xab\xa3\x0f\xff\x44\x59\x8e\x7e\x3c\xfa\xf0\xe6\xc5\xfb\xf7\xe8\xc7\xe3\x77\xe8\x00\xbd\x3d\x78\xf7\xe1\xe8\xf0\xe4\xd5\xc1\x3b\xf4\xf6\xe4\xdd\xdb\xe3\xf7\x2f\x06\x08\xbd\xc7\xb4\x63\x18\x6a\x68\x46\xf4\x04\xe6\x2c\xc7\x28\xc6\x65\x44\x12\x31\xff\xff\xcc\x96\xa8\x98\x65\xcb\x24\x46\xb3\xe8\x1c\xa3\x1c\x8f\x31\x39\xc7\x31\x8a\xd0\x38\x5b\x5c\xb6\x9e\x48\xa8\x2c\x4a\xb2\x74\x0a\xc3\x96\x54\x86\xd0\xd1\x04\xa5\x59\x19\xa0\x02\x63\xf4\xfd\xac\x2c\x17\xe1\x70\x78\x71\x71\x31\x98\xa6\xcb\x41\x96\x4f\x87\x09\xab\xa0\x18\xfe\x30\x58\x7b\x38\x14\xcc\xf6\x6f\x40\xb6\xe3\x2c\xc6\xf9\xe0\x57\x60\x91\x7f\x8b\x96\xe5\x2c\xcb\xd1\xeb\x28\xc7\x9f\xd0\xff\x66\x25\xbe\x20\xe3\xff\xa0\xef\xe7\xf4\xfb\x6f\xb8\x9c\xc5\xf8\x7c\x30\xce\xe6\x3f\x00\x70\x1c\x95\x18\x6d\x6f\x6e\x7d\x03\x0c\xaf\x79\x2b\xa8\x11\x60\xb5\x32\x5c\x1e\xf3\xed\x1d\x5c\x52\xd0\x80\xe9\x2e\xe8\x83\x3c\x4a\x4b\x13\x90\xa4\xa5\x0f\xee\xc4\x01\x5c\x56\x40\x3e\xbf\x4c\xa3\x39\x19\x0b\x36\xae\x95\x88\x59\x0e\xf0\x28\x5f\xc9\xf7\x65\x4e\xd2\xa9\x59\xa6\x80\x34\x1f\xf4\x3b\x1c\x59\x63\xcc\x71\xe4\x1d\xe3\x89\x0b\xba\xac\x82\xf5\x74\x5b\xf6\x17\x80\x49\xc1\x07\x68\x70\xe6\x42\xab\x22\x80\x1d\x96\xf3\x69\x61\x21\xae\xe5\x0f\x64\x15\xb0\x8d\x30\xe0\xab\x2b\x79\x7a\x44\x15\xd0\x07\x79\x1e\x5d\x32\x70\xc6\xc4\x2d\x51\xe0\x90\xd2\xa7\x26\x01\xf0\x95\xc4\x38\x44\x8c\xca\x0c\xe1\x94\xd2\xf0\x30\xc6\xf4\x3f\xd9\x0a\x65\xc6\x11\x63\x93\x94\x2b\x71\xb9\xd6\xdc\x98\x59\xdd\xfa\x88\x29\x58\x61\xee\xcc\x90\x84\xf6\xa1\x86\xc2\xe8\x22\xf0\xfe\x39\x2e\x67\x59\xec\xe9\x16\x53\xae\x67\xf9\x1c\x31\xc9\x25\x33\x66\x64\x0d\xb1\x35\xc8\x8b\x7f\xe4\x33\xc3\xb3\xd0\xdf\xa0\xf7\xe8\x0b\x23\x9e\x6b\x29\x96\xff\x8d\x61\xbe\x40\x5f\xf4\xca\xae\x21\x0b\xde\x2a\x14\xe8\x0b\xbc\x6b\xb8\x46\xfc\x93\x50\xde\xc0\x24\x22\x4a\x86\xd0\x17\xba\x13\x51\x76\x0f\x08\x31\x90\xa1\xed\xd4\x7a\x97\x1c\x1c\x09\x14\x51\x6c\x16\xa6\x78\xa7\x61\x6d\x30\x21\x49\x89\xf3\x9e\x56\xb6\xaf\xe9\x20\x38\x15\x95\x5c\x28\x10\x44\x00\x3a\x85\xfe\xe9\xe6\xd9\x1e\xe3\x9f\x64\x82\x7a\xeb\x7a\x23\x7a\x1d\xec\x81\x06\x7b\xca\xd1\x25\xe9\x79\x94\x90\x58\xd1\x00\xad\x71\x3d\x44\x5d\xb4\x81\xf4\xca\xd7\x74\x59\x43\xaf\xd9\xa4\xc0\x0a\x4a\x43\x8b\x24\x22\x29\xa3\x2f\x6b\x1a\x19\xc0\x5b\x9e\x53\x3d\x8b\x3c\xfd\x78\xf4\x2b\x1e\x97\xd7\x56\x85\x62\x92\x55\x39\x56\x6d\x6c\xc1\x55\x4f\x9d\xd6\x0d\x67\xe6\x02\x56\xde\x12\xb8\x60\xd2\xb4\x62\x45\xef\x94\x02\x9f\x05\xe8\x14\xc0\xcf\xfa\xed\x50\x93\x90\x02\x24\x20\xb6\xf8\xaa\xb1\x53\xe8\x68\x00\x16\xc0\xb0\xe3\x4b\x5f\xa8\x02\x55\x88\x71\x9a\x6d\x85\x9b\xc2\x5d\xfa\x1c\x3b\x45\x15\x7d\x17\x82\xc0\xa7\xb8\xd4\x57\x60\xc1\x39\x07\x27\x59\x5a\x8c\xf7\x8d\x96\x30\x6a\x18\xcc\xa3\x45\xaf\x8a\xc7\x82\x56\xce\xb3\x46\x0c\xde\xc9\x6a\xee\xb1\x9e\x9e\x42\x91\x33\xc6\x9e\xc5\x97\x5c\x45\x5a\x7f\xf8\x3e\x75\x3c\x99\x14\xb8\x74\x3a\x95\xe3\x78\x39\xc6\x5a\xbf\xa2\xf1\x38\x40\x0d\x9d\x03\xec\x94\x51\x49\xc6\x6f\xa3\xbc\x7c\x05\x2f\x89\xac\x9a\x07\x76\x7e\xcf\xd3\x4f\x51\x57\x4e\x99\x12\x8e\xdf\xbb\x55\xbe\x8e\xca\xd9\x60\x92\x64\x59\xde\xeb\x39\x2d\x6e\xa0\x9d\xad\x3e\x1a\xa2\x9d\xed\x3e\x7a\x88\x76\xb6\xf9\xa0\x35\xf4\x45\xe3\x31\xda\x40\x3d\xb9\xe9\x18\x58\xaf\x40\x21\x7a\xaa\xed\x5d\x08\xed\x6c\xa3\xd0\x48\xa8\xe8\xac\x40\x7d\x80\x36\x75\xec\xe7\xb8\x58\x26\xa5\xa0\x1e\x36\x83\xaf\x97\x49\x49\x7e\x21\xe5\x8c\xcd\x89\xa0\x40\xa3\x6f\x81\xa4\xa3\xc0\x9c\x41\x51\x39\x1f\x21\xab\xdf\x3c\xf1\xf9\x49\xdf\x6a\xd5\xb7\x06\x5a\xf6\x40\x5b\x23\x72\x78\x9d\xce\x9e\x5a\x38\x38\x99\xf0\x11\xf3\xce\xf2\x5d\x21\xcb\x5f\x44\xe3\x59\xcf\x66\x4c\x44\xa7\x2d\xca\xf5\x2b\xe7\x4b\xcd\xd5\x59\x5f\x2f\xc4\x10\x02\x5d\xd9\x70\xb5\x9d\x3d\xb3\xfb\x62\x1d\x69\x44\x28\xd7\x2e\xa5\x62\x9c\x4c\x38\x88\x3d\x47\xd0\x01\xb7\x4b\x02\x4f\xf0\x61\x4f\x96\xde\x84\xb9\x14\x37\xf6\x11\xe6\xcf\xf0\xd0\x10\x6d\x2b\xd0\x6b\x84\x93\x02\x5b\xc3\x1b\x0e\x51\x9c\xa5\xdd\x12\x45\x71\x8c\x78\xa9\x32\x33\xab\x1c\x20\x52\x76\x0b\x14\x25\x39\x8e\xe2\x4b\x34\xce\x96\x69\x89\xe3\x0a\x2c\x7d\xa5\x71\x5e\xab\x45\x38\x1c\xa2\x0f\xc7\xcf\x8f\x43\x34\x21\xd3\x65\x8e\x11\x3d\xb0\xa5\xb8\xa0\x27\x40\x7a\x4a\xbb\x2c\x4c\x66\xf5\x5b\x10\xc9\x1f\x67\x92\xcd\xc9\xc0\x3a\x02\x05\x56\x2a\x96\xb9\x44\x6b\x8e\x27\x11\xa8\x63\x2e\x66\x59\x82\x59\x0f\x49\x3a\x5d\x6f\x60\x04\x35\x3c\xc0\xe6\xfc\x7c\xd0\x01\xca\x9c\x95\x6f\x2c\x72\x31\x27\x8d\xa2\xbe\x67\x8b\xeb\xb9\xaa\x31\x8d\x80\x58\xc3\xe8\x22\x52\x64\x5d\xe0\xd2\x99\x53\x46\x56\x6f\xa2\x39\xb6\xf7\x21\x95\xa3\xcb\x99\x6e\x59\xcf\xe6\x53\xbf\x9f\xa9\x8a\x3d\x75\x4a\xbe\xc8\x31\xa8\xa4\x5a\xf1\x57\x33\x6c\x51\xc9\x22\xc7\xe7\x24\x5b\x16\xb2\x43\xdb\x7b\x14\x25\x24\x45\x24\x2d\x9d\x12\x4d\xf8\xd7\xfa\xeb\x6b\x90\xfe\x4d\xb2\x1c\xc1\x23\x61\x82\xf6\xd1\xd6\x1e\x22\xe8\x7b\x31\x00\xf1\x5e\x18\x91\x8d\x8d\xaa\xe2\xf4\xcf\xea\xf3\xc6\x3e\xda\xe8\x09\x1c\x10\xf4\x08\x6d\x9d\x51\x09\x1f\x5d\x5d\xa1\xcd\xbd\xca\x4a\x6a\x58\x39\xa7\x87\x0d\x44\xd0\xc3\xaa\x99\xdb\xb0\x7b\x41\x85\x83\x2a\xb6\x2f\xfe\xae\x9d\x54\x33\xe5\xba\xdf\xeb\x5b\x53\x38\x1c\xa2\x09\xc9\x8b\x12\xe1\x04\xcf\x71\x5a\xd2\xf3\x15\x43\x53\x80\x8a\x4f\x64\x81\x48\xb9\xca\x94\x1b\xd8\xdf\xf4\x61\x9f\xe2\xaf\x76\x06\xe0\xe9\x7c\x1c\x13\xda\x48\x94\xc8\x45\xce\xf1\xe9\xf0\x1f\x17\xdf\x7e\xbe\xa8\x48\xa7\x82\x41\x9c\x12\xb4\x81\xb6\xce\x04\x9f\x40\x1b\xc8\xe9\x86\x07\xed\x8d\x08\xb6\x98\x9f\x07\x92\x6f\x95\x1e\xda\x67\x54\x71\x63\xd6\xf3\x87\x66\x2a\x54\xd8\x32\x31\x75\xcb\xc5\xdf\x40\x99\xa8\x8a\x21\x6d\xd6\x31\x24\xd4\x8a\xa6\x1b\x39\xca\x70\x88\xc6\x51\x32\x5e\x26\x51\x89\x85\xe0\x43\x8f\x7c\xbc\x2f\x88\x94\x78\x7e\x0b\x76\x44\x59\xd1\xe9\x9f\x88\x29\xf5\x6d\xd8\xeb\x95\xf6\x95\x5b\x4e\xc8\xef\xc7\x60\x74\xe6\xf2\xd5\x79\x0b\x72\xb4\x45\xbc\x1f\x0d\xda\x10\xae\x8b\xe4\x37\x93\x59\x8d\xc6\x88\x41\xb6\xd6\x18\x89\x74\x79\xab\x29\x55\x22\x7e\x5d\x52\xb5\x1e\x44\x6b\xd8\x23\xfe\x41\xfd\x3e\x1d\x91\x56\x4c\xe9\x88\x18\x34\xc8\x36\x6d\xd0\x52\xab\x24\xaa\x40\x48\x95\x8e\xa8\x1a\x21\xbc\x04\x9c\x30\xa0\x35\x85\x98\x7a\x0d\x91\x3e\x44\xdf\xe9\xd8\xc0\xcd\xea\x0a\x22\x51\x8a\x51\xb1\x0e\xcf\x88\xb8\xf0\x9e\xc2\xad\xe3\xfe\x1d\x6b\x94\xd8\x90\x7b\x30\x32\xb1\xbe\x94\x5a\xc4\xd0\x8b\x88\x1a\x95\x86\xa9\x4e\xe5\xa0\x46\xd5\xa8\x67\xd0\x31\xca\x38\x10\x2d\x73\xd7\x23\x6d\xa3\x8e\x92\x27\x51\x9f\x1c\xcc\xbb\x56\xc9\x24\x87\x43\x54\x2c\xe7\xec\x86\xce\xb3\x4b\x71\x11\x51\xc2\xf3\xea\x4e\xc9\x19\xe5\x8a\xf2\x0b\xb6\x24\x1f\xff\x11\xcd\x9b\x88\x10\xd2\xa6\x83\x82\xe1\x10\xe5\x78\x9e\x9d\xc3\x35\x26\x1a\x2f\xf3\x9c\xca\xa7\x52\x38\xcd\x20\x99\x77\x93\x14\xd0\x73\x4f\x6f\x8b\x55\x34\x7e\x02\x99\xad\x35\x7f\xc6\xc8\xd0\x23\xa7\xfe\xd6\x94\xf6\xde\x5a\x87\x15\xd7\x3a\xde\x53\xab\xe0\x71\x1e\x2a\x2b\xad\x2b\x07\x41\x56\x74\x07\xd3\x2f\x49\xcc\xfb\x0b\xd6\x5b\xda\xd6\x98\xdf\x32\xe9\xa6\x16\xd0\xfb\x1e\xb3\x57\xb5\x4d\x30\xf8\xb5\x68\xaf\x1f\x78\xb3\x9f\x65\x59\x52\x95\x47\x85\x90\x8a\xac\x93\x9a\x3c\xfd\x72\xb3\xb2\xd9\xba\x4c\xc6\x85\xab\x72\xdf\xe1\xa8\xb2\xc7\x27\x2c\x73\x8d\x12\x84\x6b\xbf\x01\xa8\x93\x36\x1b\xc2\x70\x36\xdc\x0d\x3a\xec\xee\xb7\x13\x7e\x03\x3f\x69\xdf\x3a\xe1\x63\xfa\x5b\xbf\x8e\xed\x84\x4f\x02\x9f\xad\x07\x49\xcb\x4e\xb8\xb5\x49\x7f\xe6\x38\x4a\x3a\xe1\xd6\x36\xfd\xcd\x6e\x65\x3b\xe1\xd6\x0e\xfd\x5a\x32\x28\x68\x60\xc9\xc1\x1e\x5f\x9f\x05\x4f\x7e\x4b\xbb\xa8\x86\x6b\xe8\x9b\x59\x13\xe9\x95\xac\x62\x54\x64\x96\xb3\x6d\x8b\xf4\xdc\x15\x4d\x8c\xfc\x45\x6b\x2c\x8d\xcc\x9e\xb4\xa9\xeb\x16\x76\x47\x15\xc6\x46\xad\x1a\xd5\xae\xc4\xbd\xd3\x25\xd8\x4e\xbe\xc4\x2d\x4c\x98\xac\x61\x37\x5b\x32\x7d\x77\x6f\xc9\x74\x6f\xc9\xf4\xdf\x62\xc9\xa4\x16\xc2\x5d\x99\x33\x3d\x23\xd3\x37\xcb\xf9\x08\x58\xa1\xe4\xce\x23\x32\x4d\x21\x71\xf0\xab\xe4\xe4\xcb\x92\x24\xa6\x7d\xcd\x60\x08\x69\xec\x5f\x01\x36\xf6\x82\x8c\xb3\x74\x42\x1c\x63\x20\x71\x32\xd3\x76\x05\x38\xbb\xc0\xb6\x20\x06\xce\x78\x75\x81\x80\xdf\x23\x78\xb0\x41\xcf\x59\x94\x6f\x29\x2b\x59\x58\x0a\x74\x6e\x40\x39\xf3\x90\xe2\x98\x41\x92\x02\xa5\x78\x1a\x95\xe4\x1c\x07\x82\x13\xc1\xc5\x51\x79\x91\x75\x0b\x34\xce\xe6\x0b\x21\xad\x42\x29\x3a\xb7\xb2\xe4\x24\xc9\xa2\x92\xa4\x53\xb4\xc8\x48\x5a\x06\xec\x3a\x94\x92\x7d\x9c\x5d\xa4\xd6\x99\xce\x54\x93\xb8\xc7\xb7\x2b\x86\xe5\x2b\x89\xef\x6b\x31\x16\xba\x94\x52\x8c\x63\x38\x45\x8f\xd4\x1c\xc7\x7e\x63\x18\x40\xda\xb5\xb4\xf3\x31\xdb\x35\x18\x30\xd4\x2f\xb8\xb0\x6c\x77\xc0\xe6\xa2\x37\x1e\xbc\xf8\xf0\xf2\xe3\xb3\xa3\x9f\xde\x9c\xbc\x7e\xf6\xe2\xdd\xc7\x77\xc7\x27\x6f\x9e\x1f\xbd\xf9\xe9\xe3\xeb\xe3\xe7\x2f\xb4\x33\x9c\xd4\xc4\xc1\x4c\x0e\x16\x51\xfc\x0a\x4f\xca\x1e\xfb\x2a\xb3\x0f\x17\x59\x71\x28\xb1\xc8\xdb\x1c\x94\x19\x17\x97\xb6\x1e\xf7\x03\xf4\x78\xd7\xbc\xe1\xd1\x77\x4b\x18\x4e\x8f\x35\x62\x1a\x60\x98\x13\x2f\x0e\xbf\x15\x38\x7f\x26\xcf\xc6\xe6\xa1\x79\x55\x1c\xba\x52\x87\x81\x45\x0f\x42\xca\xec\x25\xfe\x2c\xc6\x5d\x2c\x47\x45\x99\xf7\xb6\x35\xfc\x25\xd6\xd5\x3e\x2b\x2e\xb4\xdc\x1b\xe8\xf1\x4e\x1f\x0d\x75\x14\xd9\xe8\x7e\x47\xa6\xb3\x92\x17\x0b\x50\x82\x1e\x7e\x65\x7c\xf2\x1d\xf8\x4e\xd1\x5a\x29\xd3\xdd\x1a\xbb\xe2\x78\x66\xa2\x55\x6a\xe7\x7e\xb7\x19\xb0\xd4\xa6\xac\xb1\xfe\x80\xad\xf9\x0d\xd4\x3c\x41\x4d\x9c\x8e\x49\xf2\xd5\x2b\xe2\xbd\xc8\xbf\xed\xdc\x49\xe3\xce\xf6\xb3\x36\xc9\xb3\xf9\x49\x39\x79\x72\x3f\x71\x9e\x89\xe3\xef\x8c\xaa\x18\x19\x7f\x85\x24\x26\x8d\x7e\xe3\x28\x5d\x9d\x91\xd9\x4f\x8e\xaa\xe7\xac\xbb\x79\xbb\xbf\x2e\xda\xe0\xd5\xa3\xa7\x08\x75\xb7\xba\x28\x44\xdd\xcd\xee\xed\x79\x54\x13\x26\xe9\x89\x95\x96\xfa\x99\xc2\x15\x88\x0a\xc6\xf3\x65\x52\x12\x26\x54\x8e\x2e\xd1\xf6\xbf\xe7\x54\x3c\x97\x36\x74\x11\xad\xb9\xc4\x53\x9c\xd7\x6c\x25\xef\x78\xad\x4d\xfb\xf7\xaa\x33\xc2\x6d\x99\x2b\x66\x84\xa3\xc9\xa2\x3e\x8a\x35\xd9\xa2\xdc\x5c\xc9\x1c\x17\x56\xd6\x76\x7f\xb0\xc8\x2e\x7a\x5b\xdb\x4f\xfa\x7d\x13\xa5\x87\x33\x3c\xfe\x84\xc8\xc4\xc0\xa9\x26\x16\x59\x88\x28\xc8\x34\xc5\xf1\x51\xf1\x46\x65\x3b\x8a\x68\x59\xc7\x0c\x7f\xe6\x3d\x36\x91\x21\x88\x16\x0e\x7d\xd0\x76\x69\x4a\x62\x19\x3d\xb2\x5c\x10\x2a\x86\x47\x49\xa1\xac\x96\xed\xd6\x1b\xf1\xe5\xc3\x90\x60\x37\x9b\x01\xda\xea\x07\x68\xeb\xb1\x26\x8f\x6c\xf7\x8d\xdc\x3e\xda\xdf\xdf\xa7\x24\xeb\xa5\xc2\x9c\xb2\x8f\x47\x51\x02\x9d\x42\x4c\x75\xa0\x2e\x3c\x98\xa8\xe9\x12\x11\x53\x24\xd8\x42\xa0\x41\x1e\x8e\x1d\x2c\xc5\x99\x12\x0c\x6b\xda\x95\xc2\x21\x2c\x0b\x32\x45\x4c\x4e\xb7\xe8\x4d\x76\xc1\xc0\x9f\x61\x14\x4b\x81\xd9\x3c\xee\xb3\xde\x68\xba\xcc\x5e\x1f\x5d\x5d\xa1\xce\x66\x87\xeb\x88\x87\x43\x34\x96\x54\x44\x85\x67\x31\x91\xb2\x75\x06\x44\x4a\x36\xd1\x52\xd2\x76\x85\x6c\x71\x7f\x6b\xcd\x33\x9f\x5b\x8f\x0a\xd2\x33\xbf\x6c\x4a\xe7\x24\x5d\xda\xab\xa0\x3b\xb9\xe5\x5f\x17\xea\x16\x95\x6f\xc9\xeb\xb1\x16\x1d\xba\x01\x05\x2d\xeb\x49\xe8\xa4\x96\x86\x7c\xd4\x83\x57\x22\x1f\xde\xbc\x4b\x38\x27\x77\x41\x39\x5f\x07\x65\x9c\xe5\x57\xa1\xcc\xe1\xdd\x8d\x28\x03\x8c\x69\x22\xb1\x89\x22\xde\x9c\x8b\x22\x87\x99\xfb\x2c\xce\xad\xc5\xc8\x61\x06\x31\x39\x27\x31\x8e\x9f\x5d\xd6\xf0\xf0\x9b\x50\x53\x03\x6e\x4e\xee\x1a\x39\xcb\x4a\xec\x9c\xac\x8c\x9e\x93\xdb\xe0\xc7\xbd\x85\x65\x55\x4b\x14\x55\x49\x5c\xea\xc1\x74\x6b\xbc\x88\x9d\xcd\x9c\x8b\x4a\x1c\xf1\xa6\x5d\x14\x39\xf2\x99\x0f\x43\x9e\xe5\x05\xfb\xd5\x2d\x05\xb6\xad\x2e\x7a\xca\xb6\x66\xee\x19\x63\x35\x6c\x56\x9e\x1c\xb5\x77\xb9\x35\x7b\x5f\x82\x27\x0a\x71\x54\x82\xa8\x39\xdb\x38\xa2\x47\x1a\xcd\x31\x7b\xe0\x43\x7f\x59\x22\x18\x87\xa1\x75\xca\x1a\x3c\x98\x77\x0e\xa1\xd0\x46\x80\x74\x65\x39\x2d\xc4\x9f\x58\xa3\x7d\x54\xf5\x52\xf7\x61\x7f\xa8\x1d\x69\x0a\xf2\x1f\xce\x13\x0b\xb8\xa5\xe2\xe5\x4f\xb7\xce\x4c\x51\xb8\xbb\xf9\x99\x8a\xcc\xee\xe4\x0e\x8a\x84\x8c\x31\x95\x4c\xb6\xd1\x43\xa8\x6e\x45\x3a\x6f\x98\x19\xfd\x14\x7e\x67\x13\xb4\x2a\xfa\x2b\x55\x01\xce\x26\x23\x8f\x88\x16\x1f\x60\x88\xe3\x97\x60\x36\xe6\x1e\xef\xf6\xf9\x1e\x5e\x66\x1c\xbe\x8f\x1e\x8a\x53\xa5\x6f\x06\xac\x8a\x98\x74\xf8\x78\x37\xe0\xed\xaf\x36\x05\x35\xa7\x72\x36\x7c\xcf\xb1\xfc\x4e\xb1\x1f\x15\x63\x42\xea\xf0\xef\x39\xce\xff\x86\x98\x17\x5a\x1d\xd0\x0e\xb4\xc3\xff\x6a\x13\xa0\xdc\xd3\x54\xcd\xc0\x81\x72\x60\x53\x31\x05\x95\xbc\xbd\x02\xe5\xb2\x42\x17\xdb\x3e\x07\x36\x2b\x48\x53\x06\xee\x3a\x9b\x9f\x3b\x68\x03\xf1\x33\x0e\xa0\x9d\xfd\x96\x66\x05\xbb\x9b\x01\xd2\x93\xaa\x7c\x06\x7c\x11\xa6\x1f\xda\x59\x33\xb4\xbe\x03\x1b\x06\x56\x6c\xe8\xa4\x38\x70\xfa\x02\x0f\xab\x32\x9c\x52\x0c\x99\xa1\x9b\xe4\xf6\x23\xcb\x92\xd0\x4e\x70\xa0\xa8\x04\x12\xda\x09\x3a\x94\x14\xcb\x42\x3b\xc1\x85\x3a\x71\xc0\x4e\xbc\x70\x7a\xa3\x2a\xc5\x53\x9f\x0b\x78\xe2\x87\xd4\x07\xab\x52\x3c\x70\x3a\xb6\xb5\x24\x17\xd2\x37\x3d\x6e\x8e\x5b\xce\x9c\x20\x3d\xcd\x85\xe5\x54\x1f\x7a\xd7\xdd\xb5\xb8\xd6\x35\x2f\x87\x3a\xe1\xd6\x93\xa0\x63\x5e\x2a\x75\xc2\x6d\xb0\x60\x80\x85\xd1\x09\xb7\xb6\x82\x8e\x7e\x35\xd5\x09\xcd\xcf\xeb\xb3\x60\x6b\xf3\x77\x76\xe9\x72\xc4\x6c\xe3\x6b\x7c\x10\x91\xb4\xac\x72\x41\xc4\x6f\xaf\x48\x5a\x32\xef\x2c\xf4\xc7\xae\xfc\x75\xa6\x12\x77\xb4\xdf\x96\xf3\x16\x92\x96\xcc\x75\x0b\x49\xcb\xc7\xbb\x12\xec\x89\xaa\x68\xfb\x9b\xc7\x15\x75\x51\xf8\x06\x57\x46\xf6\xd1\xf0\x2b\x7a\xe3\x02\x70\xdb\x0c\xe1\x28\x2d\x57\xb4\xbc\x30\x4a\xd4\x18\x5c\x40\x73\x35\x25\x6f\x64\x5e\x41\xd2\x52\x88\x8a\x4f\x6f\xe4\xd2\x85\xf5\xaa\xd9\x0c\x62\xab\x55\x14\xbb\x7b\x3b\x88\x7b\x3b\x88\x3f\xaf\x1d\x04\x52\x86\x10\x4c\x54\xba\x23\x1b\x88\x16\xa6\x0d\x36\xab\x67\xa6\x0b\x19\x18\xa4\x2b\xcf\x1d\x03\x8f\x84\x7a\x31\xc3\xa9\x7c\xaf\x18\x30\xdb\x6f\x2a\x80\x4b\x07\x0e\x42\xb2\x1c\x7a\x6d\x23\x2c\xf5\xb7\xfd\x3c\x11\x38\xa9\x90\x1f\xd9\xff\x57\x57\xa8\xdb\xd5\xf8\x6c\x26\x5e\x2e\xb0\x1f\x7b\xda\x53\x43\x92\xf2\xd6\x5b\x7b\xfc\x98\xe2\x52\x37\xf9\x05\x03\xf2\x6e\x21\x1e\x82\x02\x2f\xa1\x95\x18\xd6\xee\x4a\xbe\x67\xc6\xae\xa6\x14\x2d\xd4\x4c\xaa\x56\xbd\x32\xd4\x13\x7d\xec\x1b\x06\xed\x80\x1e\xdd\xa0\xdd\x6e\xa4\xd6\x14\x0d\xac\xfc\x8d\x63\x87\x7e\xfd\xd8\x1a\x19\xe3\x1c\x53\x62\x12\xeb\xc1\x74\xcb\xc2\xc8\x3d\x26\x93\x09\x06\x83\x64\x86\x72\xeb\x5c\x72\x21\xdf\x85\xe8\xc7\x11\x81\x12\x3e\x4b\xc2\x76\x39\xf5\x1e\x42\xcc\xa3\x0b\xdd\x0e\x7d\xfd\x88\x16\x8c\xc3\xc8\x5e\x54\xa3\xf2\xc2\xff\x66\xd6\xa4\xbb\xca\x5b\x3d\x45\x90\x92\x54\x57\xc1\x68\x36\x1f\x91\xd4\xf5\x70\x53\x66\x53\x4c\xb9\x3b\xad\x01\x4f\x07\x6c\x51\x45\x8b\x05\x4e\x61\x2d\x45\x29\x7b\x03\x61\x61\x97\xd7\xd6\x74\x0f\xc3\x19\xd3\x8c\x8c\x29\x7b\x12\xbd\x6a\x2e\xcc\x2f\x50\xb3\x09\x87\x85\x7d\xa8\x16\xb5\x62\x78\x4d\x7a\xbf\x3a\xb4\x4a\xbd\x05\xbb\x32\xd9\x43\xcd\xd8\x1d\x47\x49\xc2\xf1\x2b\xae\x71\xd8\x88\x66\x91\x5a\xba\x05\xf9\x0f\x77\x2e\x08\xd7\x75\xb3\xa8\x08\xe8\xff\x82\xd0\xc0\xfd\xaf\xe7\xde\x4e\xc7\xb7\xb4\x05\xf5\xeb\x4c\x6b\x51\xe3\xf7\xce\xe4\x5b\xb8\x7c\x55\xac\xef\xef\x83\x74\x31\x21\xa9\xf5\x56\xa9\x09\x09\xca\x6b\x11\xaf\x8a\xdf\x30\xdb\x4a\x03\x96\x7b\x50\x3c\xab\x3e\xfa\x33\x8d\xaf\xab\xa1\x69\xb1\xcc\x8c\xda\xeb\x06\xbd\x0e\xa3\x56\x2e\x00\xfa\xe8\x29\xea\x76\x51\xd8\xce\x20\x4b\x43\x99\xd7\x2c\x6b\x05\xbc\x51\xde\xcf\x94\x13\x52\x66\xf4\x3d\xf7\x52\xfa\x0b\x3f\xce\xc4\xde\x23\x6e\x85\x23\x9d\xe1\x47\x73\x9d\xc8\x80\xc4\x6b\xb1\xa8\x1a\xf3\xa2\x10\xfc\x2a\xd9\xf8\xf3\xf9\x67\x92\xcb\x6b\x0f\xb1\x2b\x3f\x54\x41\x77\x7c\xc2\x7a\xab\xa3\xce\xd8\xd6\x2a\x70\xa7\x6d\x4a\x7e\xe4\x89\x84\x48\x5c\xc2\xb7\xc0\x22\x9e\x2f\xca\x4b\x5d\x25\xd8\x62\x13\x6d\x5c\x85\x26\x3d\x6a\xec\x29\x04\xe9\x63\x05\xdc\x08\x8f\x53\x95\xbe\xa6\xbc\x98\xa8\x1d\x08\xaf\xb2\x69\x0c\xc6\xc5\xca\x86\x47\x2c\xb8\xc9\x38\xd4\x63\xbc\x6a\xff\x50\xaf\x48\x51\x3a\x2f\xff\x4e\x8d\xd1\x9c\x79\x9c\x42\xd5\x8e\x5e\xd5\xec\x6e\x2f\xf2\x5d\x90\xb8\xa9\x5f\x2e\x62\x66\xd9\xca\xdf\xc1\x49\x55\x64\x99\x95\xda\x5b\x57\x56\x58\x08\x47\xcc\xef\x10\x32\xde\xf6\xc9\x27\x84\x1c\xd4\x7c\x56\x64\xec\x6d\x72\x3d\xb2\xed\xab\x62\x41\xda\xb7\x5f\xb6\xb3\x10\xb3\x79\xb4\xaf\xf7\x58\xc1\xea\xc3\xd8\xd8\x77\x15\xfd\xfc\xb5\x96\xfb\x42\x8b\x41\x2a\x11\xa8\x97\xe9\xaf\x6e\xe5\xab\xb9\xe1\x50\x4c\x37\x3e\xc7\xf9\x65\x39\x03\x5f\x24\x5a\x3d\x3a\x76\x5c\xc7\x53\xc2\x22\xcd\xc1\x8f\xf1\x52\xd7\x7f\x43\x21\x7d\x2f\xdd\x69\x13\xae\xd2\xf9\x3a\x40\xdd\xae\x50\xbe\xd7\x28\x29\xde\xb2\x59\xb2\x74\x7a\x52\x7d\x77\x7d\x16\x6c\xb5\x8a\xb5\xf7\x15\x75\x72\x70\x1b\x5d\xaf\x94\xcb\x29\x48\x85\x56\x4e\x98\x99\xd1\xff\x99\xaa\x0c\x7e\xed\xaa\x9f\x67\x5a\xf2\x8e\xfe\x61\xe9\xe6\x68\x1a\x53\xce\xd1\x5f\x42\x3b\x47\x7f\x3f\xd1\xaa\xd3\xf4\x73\x4e\x8d\x2d\x34\x74\xce\xdd\xfb\x2a\x2a\x3a\x5a\x78\x15\x1d\x1d\x83\xb7\x95\x74\x34\x75\x45\x2d\x9d\x59\xa4\x46\x4d\xc7\x5a\xac\x2b\x7b\x13\x45\x1d\xc5\x6d\x85\xa2\xae\x9d\xa3\x7c\xde\xad\x16\x8a\xba\x56\xd1\xbc\xbe\xd6\xe3\x3a\xcf\xed\xdf\x2a\xe4\xc1\x8a\xaf\x42\x20\xa2\x84\x4d\x22\x2c\x7d\x45\x22\xb1\x0b\xd5\x90\x89\x68\xb7\xbe\xfc\x8d\x74\xba\x4c\x92\x6a\xf3\x66\xce\xd3\xde\xdd\xbe\x96\x93\xa3\x6c\x41\x77\x77\x1f\x7d\xa4\xf6\xfd\x8e\x87\x0f\x6b\x2e\x6e\x49\xd1\xde\xb7\xed\x18\xe7\x65\x44\x52\xbf\x7f\x5b\x07\x91\xec\x36\xa9\x81\xa8\x19\xd0\xc0\x4c\xaf\x27\x6b\x5e\xc4\xca\x68\xf4\x06\x51\xe2\x7c\x4e\x8f\xfc\x64\x02\x35\x9b\xfd\x8e\xb9\xd7\x5a\x34\x25\xe7\x38\x15\x26\x2d\xe6\x91\xba\xca\x5d\xae\x65\xff\xc2\x8e\xd9\xca\xe2\x16\xb0\xcc\x2a\x77\xda\xf5\xdb\xdf\xea\x10\xed\x97\x08\x73\x4e\xdb\x29\xbd\xc2\x71\x76\x8e\xf3\xfc\x22\x27\x65\x89\xc1\xdc\x8b\xf5\xaa\x83\x36\xa0\xf7\xad\x71\x77\x01\x5a\xf6\x42\x7f\xc8\x0f\x56\x10\xea\x28\x4a\x52\x8e\xc2\xd2\xf5\x3b\x6c\xbf\xb5\x6f\x85\x4c\x57\x2b\x69\x35\xa7\xb4\xb6\x15\x78\xf3\xb8\x10\xf0\x63\x70\x38\x04\x55\x78\x34\xa7\xab\x02\xbc\x1e\x72\x6d\x16\x1d\x2f\xe5\x04\x98\xdd\x31\x24\xe4\x13\x46\x11\x2a\x48\x3a\x4d\xb0\xf4\xc3\x05\x90\x03\xc3\x24\x1a\x28\x98\xb9\x99\x61\x6e\x39\x58\x6b\x57\x57\xe8\xb4\x7b\xba\x75\xd6\x3d\xeb\x4b\x61\xb0\xc1\x0d\x00\xef\x9e\x89\x77\xfa\xa5\xbb\x36\xac\x10\xdd\x99\x0d\x14\x43\x05\xd8\x2a\x6c\x05\xe8\x11\xd8\x63\x6f\x42\x5f\xb6\x74\x47\x34\xaa\x43\x8e\x20\x2b\x1c\x35\x04\xc2\xb5\x43\xd5\x69\x41\x38\x74\x78\x28\x00\x55\x03\xc3\x21\x8a\x92\x04\x8d\xa2\x82\x8c\x99\xff\x03\x78\x2c\xb0\xb3\xcd\x15\x38\x49\x46\x4f\xc6\xa2\x37\x01\xda\xd9\x6e\x32\x3a\x31\x17\x36\xe7\x68\xe2\x04\x2e\x74\x91\x08\x4f\x41\x80\x84\xa0\x50\xa7\x67\x1d\xb4\xff\x03\xac\x4f\x95\xb6\xcb\x12\x6b\x95\x69\x07\xa2\xb6\x55\x39\xc0\x0c\x57\xf6\xac\x66\xb5\xeb\xad\x56\xd2\xac\x72\xfb\x65\x38\x84\x71\x88\x6e\xcf\xda\x46\xb5\x22\x0f\x1e\x20\xfd\xfb\x54\xfb\xad\xb9\x80\x3b\x13\xbb\xae\x8c\x8c\x31\x9c\xde\x68\x6e\xf8\xf2\xad\x9b\x1a\x31\x0b\xe6\xdc\xf0\x09\x33\xa7\x46\xf3\xb8\x76\xcb\x99\xb1\xfa\x55\x33\x31\x5a\x9b\x5f\x7b\x5e\xee\x72\x62\x4c\xd7\x27\x8a\x91\x6a\x33\x01\x67\xa3\x0e\xd8\x22\x6c\x33\xa4\xb3\x43\x52\x87\x1b\x2b\x6c\xf1\xa9\xd8\xda\x95\x80\xdb\x67\xa7\x3b\x1c\x54\xa4\x31\x10\x09\xb1\x75\x66\x25\xa8\x6f\x77\x77\x00\xac\xde\x60\x7b\xd0\xc7\xc2\x87\xd8\xbc\x27\x68\x8d\xdd\xd1\x44\x92\x09\xea\x69\x59\x1a\x87\xb4\xf9\xf1\x0d\x27\x16\x18\xb6\xef\x35\xc4\x56\xcd\x94\xf3\x4d\x42\x9c\xaa\x7d\xf3\x0c\xf3\xe6\x9b\xea\x8e\x8c\xbf\xe7\x4c\x38\xff\xec\x18\xf3\x6e\x54\x74\x6a\x56\xae\x4f\xb7\xf2\xbe\xd6\x6a\x9e\x65\x06\x1b\x0a\xcf\xaf\x9c\x5f\xc3\x8b\x62\xe5\x6e\xcf\xbd\x15\x25\x51\x51\xa2\xd3\x33\x2a\x4c\xb0\x7a\x6f\x34\xed\xeb\xfe\x79\x97\x73\x00\x72\x16\x72\x7c\x2c\xc1\x81\x46\xbd\x84\x82\x4f\x49\x03\x6d\x88\xa4\xc6\x38\x56\x3b\xc2\x48\x0e\x6c\xdf\x34\xa1\xd1\x25\x8a\xf1\x24\x5a\x26\xa0\x08\x2d\x96\x54\x4e\x95\x1b\x73\x87\xbb\xa9\x09\x78\x98\x47\x7b\x16\x8d\x63\xd4\x0d\x18\xb0\xda\x11\x57\x14\x85\x5b\x9e\xde\x2a\x8d\xea\x85\xaf\x76\xa1\x23\xd6\x96\x48\x61\xaf\x11\xa0\x78\x4e\xca\xa7\x1d\x4a\xf1\x01\xea\xd0\x45\x40\xff\x3b\xeb\x9c\x29\x6a\xe7\x10\x5a\x1a\x14\x4a\x97\x89\xfd\xec\x41\x9b\xcd\x56\x68\xb3\x1d\xcc\x59\xfd\x6d\x58\x08\xae\x93\x2a\x67\x25\xb0\xbd\x81\x3b\xcb\x63\xb3\x5e\xc0\x0d\x2f\x1d\x8e\x31\x5e\xfa\x2f\xac\x7a\x8b\x88\x39\xb7\xea\xfd\xeb\x94\x9d\xc6\xff\x75\xd6\x6f\x16\x11\xb8\xf2\x56\x7a\x7b\xa8\xbe\x77\xb0\xc2\x58\x08\xe8\xf6\xac\x43\xbc\x3d\x75\xef\xb2\x2c\x9c\x79\x2e\x2d\xf8\x3d\xba\xbd\x31\x78\xfd\x51\x9b\xb7\x32\xdc\x15\xaa\x70\x82\x6a\xb3\x85\x06\x6f\xb0\xd2\xfe\x5b\x37\x26\xde\x43\x95\x7f\x7e\xc7\xa8\xae\x5f\x59\x9c\x4c\x74\x7f\xb2\x9c\x95\x39\x85\xe4\xcb\xe4\xd3\x33\x9f\x13\xf1\xc1\x62\x59\xcc\x7a\x8e\x67\x52\xf1\x52\x5b\xb8\x19\x75\x6b\xa6\x63\x71\x7d\xae\x9f\xfb\x1c\x80\xea\x2d\x69\x7e\x3c\x7b\xe7\x01\xd2\xfd\xcb\x5a\xee\x49\x6f\xe5\xd4\x97\x4f\xa0\xee\xcc\xf7\xd6\xf3\x07\x5d\x77\xa4\x0e\x8e\xf8\xdf\x7e\xfe\x7c\x1e\x59\x1b\x3c\xb1\x56\x4e\x04\x9d\x4d\x70\x95\x5a\x33\x1f\x2b\xcf\xc6\x9a\x73\x47\x68\xe9\x8e\x8c\x25\xa9\x79\xb4\x6d\xe3\x13\x94\xdd\x8f\x4e\xf2\x6c\xee\x35\x37\x60\x50\x3e\xde\x32\xb2\x1f\xec\x58\x06\x42\x86\x65\xd0\x0a\x0f\xa6\x04\x53\x63\x2d\xb7\x60\x51\x7c\x20\x3a\x8b\x32\xfc\x69\x36\xb0\xaa\xaf\xc2\xab\x60\x6f\xd2\x6f\x2c\x99\xa0\xcb\x9f\xf8\x40\xf7\x84\xa0\xc3\xd1\xf5\x10\x6d\x83\xf1\x43\x5f\x78\x74\xe6\xc8\xab\x5a\x44\xb5\x75\xea\xcd\x3b\x15\xfb\x56\x14\x14\x78\x5f\xb2\x3b\x76\xbd\xf4\x06\xda\x61\x4e\xef\xd9\x6e\x5b\x50\x90\x02\x45\x93\x12\xe7\x72\x91\xe8\xfd\xbd\xd1\x5a\xf5\x97\xf1\xf9\xee\x56\x9c\xa3\xc2\x67\x37\xaa\xc5\x1e\x0f\x1d\xf3\xa6\xaa\x7e\xdd\xaf\x47\xa5\x1b\x69\x3b\xe6\x4d\x2d\xa3\x69\xc9\x69\xd0\xc3\xfa\xbe\x51\xd8\x8d\xfd\x7a\x98\x56\x8c\xca\x74\x38\xab\x4d\xfb\x06\x22\x77\xcb\xb5\xfe\x10\x7b\x88\xfe\xd7\x92\xfa\x85\x41\x6a\xcb\xbf\x3f\x14\xf1\xdf\xd3\xbe\xf6\xf7\xbb\xd0\x3e\xf2\x92\xbe\x1e\xa0\xf1\xa6\xa4\x6f\x87\x11\x5b\x71\x53\x71\x88\xd5\xae\xbf\xdd\xce\x62\xf6\x62\x95\xfa\xf9\xfc\x79\xe9\x2d\x71\xe8\xcb\xbf\xfe\xaa\x97\xf0\x82\xdf\xfa\xb9\x46\xaa\x4d\xdd\xef\xa1\x2d\xb4\x61\xf6\xae\xcf\x7c\x32\xb1\x48\x62\x9e\xa9\x67\x1e\x88\xad\x4b\x37\xe3\xc1\x76\x8d\x3f\x7b\x03\xd7\x96\xc5\x97\xc1\xc5\xd6\x56\x1c\x9b\x3e\xe7\x72\x65\x6d\xf7\x4d\xb5\xaa\xf7\x22\xd1\xea\x7a\xe3\x05\x6f\xf5\xd5\xae\x7c\x13\x77\x7d\x16\x6c\xfd\xde\xa1\xf7\x4f\x9a\x9f\xbd\x2d\x6b\xde\xbd\x71\x4f\x24\xf0\x3f\xb3\x75\x59\xaa\xa7\x6f\x4b\xed\xed\xdb\x52\x7f\xb0\xb6\xf4\xbc\x7e\x5b\xca\xe7\x6f\x4b\xed\xfd\xdb\x52\x7b\x00\xb7\x34\x5f\xc0\x39\x35\xb6\xb0\xb0\x71\xfc\xa3\x7c\xc5\x47\x70\x27\xde\x57\x70\x27\xab\x3f\x83\x3b\x69\xfb\x0e\xee\xc4\x7d\x08\x77\x72\x07\x2f\xe1\x96\xb7\x7e\x0a\x77\xd2\xfa\x2d\xdc\xef\x1d\xd7\xff\xa4\x85\xc5\xd9\xb2\xce\xe4\x4c\xb8\x56\x61\x3f\x38\x71\x6a\x56\x67\x4b\xdd\xec\x6c\x69\x58\x89\x2d\x7d\x86\x67\x4b\x65\x79\xb6\xd4\x4d\xcf\x96\xba\xed\xd9\xd2\x32\x3e\xf3\xd4\xdb\x66\x71\xfc\xa6\xf6\x67\x27\x7e\x03\xb4\x93\x1b\x58\xa0\x9d\xb4\x36\x41\x3b\xf1\xd8\xa0\xd9\xa5\x6f\xb6\x46\x6a\xcc\xd0\xda\x2e\x92\xf6\x86\x68\xdf\xb6\x59\x25\xdd\x65\x81\x41\x31\x3b\x2e\xbb\x2c\x20\xdf\x34\x43\x38\x3d\x47\x71\x86\xc1\x5a\x01\x5e\x07\x46\x69\x0c\x3e\x6c\xd1\x3f\x5e\xbf\x7a\x59\x96\x8b\x77\xf8\xff\x2d\x71\x51\xae\x81\x60\x76\xb9\xc0\xd9\xc4\xca\x61\x7e\x6c\xe4\xfb\x8d\xae\xc0\x0b\x6f\x78\x60\x43\xa3\x2f\xd7\x7b\x6b\x46\xb0\xc8\x4a\x48\x33\x01\x24\xf5\x5f\x8b\x19\xdd\x7d\xc8\x34\xcd\x72\x1c\x26\x24\xc5\x6b\xd7\xcc\x62\x95\xe2\xa1\x95\xb7\xfb\xfb\x97\xb3\xf7\x2f\x67\xff\xc4\x2f\x67\xd9\xab\x59\x6e\xc3\x66\x3c\x9b\x65\x1b\x0e\xba\xd9\xeb\x59\xbe\xf7\x9d\x94\x24\x81\x3a\x99\x3e\x13\xd6\x0e\x7b\x9e\xe4\x80\x91\xf2\x52\xb2\x44\x55\x64\x9c\x44\x45\x81\x4e\xa1\xc8\x19\xef\x26\xcb\x50\x4c\x98\x55\xb5\x36\x84\x7b\x23\x58\xa5\x5c\xb9\x4a\x39\x08\xaa\x71\x66\xdd\xde\xcf\x39\x40\xd2\x9a\x4e\xde\x1c\x7d\x78\x4f\xcf\xd6\x30\x09\xdd\x0b\x4c\xba\x8c\x34\xbb\x9f\xb4\xdf\xaf\xb5\xdf\x3f\x69\xbf\x8b\xff\x44\xa3\x4c\x7c\x4c\x48\x9a\xe2\x4b\xf9\x85\xe7\x65\x06\x4f\x19\x45\xca\x82\x8c\xcd\x84\x34\x4a\xcd\x84\x39\x19\xe7\x76\x4a\x92\x10\xa7\x90\x01\x6f\x80\x8a\x0f\xa3\xc8\x34\x8f\xd2\x58\x0e\xc5\xc8\xfa\xc9\xf8\xfa\x60\x7c\xbd\x35\xbe\x5e\x18\x5f\xff\x67\x7c\xfd\xd3\xf8\x7a\x63\x7c\x3d\x37\xbe\x7e\x36\xbe\x4e\xd8\xd7\xda\x59\xb5\xeb\x1a\x3a\x47\x6f\x0f\x9e\xd3\x29\x0e\xd1\xce\x76\x20\x13\xdf\x1f\xfd\xf4\xe6\xe0\xc3\xc9\xbb\x17\x1f\x5f\xbd\x78\xf3\xd3\x87\x97\x21\xda\x55\x99\x30\xab\xa1\xfa\xa9\x72\x2a\x28\x27\x44\x5f\x90\x95\xa0\xfc\xa8\x43\xc6\xc7\xe7\xc7\xbf\xbc\x41\xd7\xaa\xa6\xb7\xc7\xaf\x5e\x51\xe8\x0f\x47\xaf\x5f\x1c\x9f\x7c\x08\xd1\xd6\xe6\xe6\xe6\x90\xf7\x90\xdf\x78\x3f\x4b\xb2\xf1\xa7\x10\x75\x29\xeb\x2c\xca\xae\x91\x77\x30\x86\x50\xc6\xa1\x7a\xdb\xc8\x1e\x60\xd0\xfd\xbc\xc9\xf7\xc9\x7d\x28\x8c\xfb\x8d\xec\xaf\xbe\x91\xad\x49\x17\x10\xc5\x2c\xda\xb9\x2b\x0f\x10\x87\xf9\xe5\xa2\xcc\xfe\xfe\x5e\xdf\x1c\xc6\x90\xf6\x48\x45\xc0\xa0\x0d\x7a\x01\x86\x34\xa7\xeb\x8d\xee\xe4\xba\x6f\x00\x8a\x2b\xf4\x07\xaa\x3c\x09\x3d\x78\x20\x72\x07\xc2\x5f\x04\x13\x93\x67\xf8\x73\xd7\x7e\x45\x67\x78\xfe\xfa\x01\x6d\xd3\xd2\xb6\xf7\xe3\x6d\xe1\x2e\xd2\x2c\x8e\xc4\x65\xb8\xbc\xe0\xb7\xfc\xb3\x23\xeb\xb5\x1d\x03\x15\x38\xa2\x9d\x1b\xbc\xc4\x9f\x07\xa0\xbd\xe4\x9e\x7b\x7d\x36\x46\x14\x2b\x62\xd8\xaa\x75\x76\xa2\x63\xea\xb7\x10\x6d\x7f\xf3\x98\x95\xd4\x1e\x27\x8b\x37\x67\x94\xe5\x49\x1c\x77\xc2\x6f\xbe\x0b\x3a\x26\xca\x3b\xe1\x93\xcd\xeb\xb3\x60\xbb\x95\xcf\xa7\x7b\xbe\x77\xcf\xf7\xfe\xbc\x7c\x4f\xb1\x3d\xf6\xce\xff\x0e\xf8\x9e\x25\xbb\xaf\x2e\xba\x7b\x24\x77\x51\xd0\x27\xb8\xaf\x14\x6d\xc8\xe6\xb5\x83\x21\x67\xf7\x2a\x1c\xd1\xe4\x89\x0e\x40\xbf\xa5\x08\xbf\x4c\x49\xf9\x3a\x5a\x48\x71\xb1\x2b\x24\xea\x90\xf1\xa0\xee\x66\x37\x40\xe2\x39\x34\x48\xf7\xa1\x62\x8d\xdd\x2d\x43\xd6\x0f\xb5\x8c\xcd\xcd\x4d\x91\xf7\xbf\x35\x79\xa3\x68\x34\x8a\xa6\x58\xb6\xa6\xe7\x69\x07\x80\xd0\xce\x9b\x7b\xea\xd4\xb2\x5f\xd7\x67\x27\xd9\x39\x4e\xa2\xb1\x68\xd6\xce\x56\xe7\x8c\xd0\x97\x3d\xf5\x57\xae\x41\xfc\xd4\x08\x51\xcc\xa2\x34\xcd\x52\x63\xdc\x26\x84\x3a\xdb\x84\x35\x10\x0d\xad\xc0\xe9\x2a\xf4\x40\xe8\xa8\x54\x67\xa6\xb0\x1e\xa8\xa9\x26\x7e\x7e\x0b\xbd\x40\x46\x65\xf2\x4c\x66\x8f\xcd\x03\xe8\x1f\xa2\x09\x68\x90\xac\x07\x4e\x03\xfd\x64\xc2\xfa\x40\xf5\xb9\x86\x93\x5f\x6d\xc5\x7a\x7f\x5b\xd5\xad\x57\xdf\xb6\x80\x56\xa6\x5c\xa1\x0c\x2d\xe6\x37\xb8\x52\xce\x18\x16\x51\xcc\xcd\x49\xc1\xdc\xf3\xf3\x02\x8f\xe9\x06\x26\x4d\xf4\x75\xc3\x2b\xee\x41\xc5\x67\x3d\xa5\xaa\x18\x61\x0a\x17\xf3\xa8\x5c\x96\x1d\xd6\x78\x16\xe5\xd1\xb8\xc4\x79\x21\xd4\xfc\x70\x37\xcf\x4b\x6b\x7b\x89\xb7\x0d\x32\x4d\x03\xcd\x1e\x1a\x6d\xae\xf9\x5d\x7f\x90\xe9\xac\x44\xc2\x2b\xad\xe5\xe1\x97\x8f\xc1\x90\x38\x19\x48\x00\xbd\x2b\x02\x68\xc7\xe3\x67\x88\x59\x89\x00\x0c\x04\xa6\x85\x17\xab\xf2\x96\x78\xab\x3f\xf8\x35\x23\x29\x04\x6c\x40\x4f\xa1\x0e\x14\xa2\xce\x66\xa7\x8f\x36\x38\x70\x85\xf1\xdb\x8d\xe7\x02\x82\xf6\xfc\xd9\x27\x03\x06\xb1\xe2\x6c\xf0\x1e\x6e\x30\xaf\xcb\x37\x9d\x97\x2a\x63\x44\xd3\x19\x0d\x6c\x9f\x60\x8a\x08\x01\x3d\x5c\x3f\xd3\xd6\xbc\x30\x8f\xcd\x35\xb3\x42\x52\x5a\x89\x1f\x59\xba\x4f\x6a\x8f\xb3\x24\xda\xb8\x32\x3d\x64\x5e\x48\x4e\xd8\xf6\x2e\xc5\xfa\x19\x8b\xf9\x3c\x1c\xa2\x1f\x49\x1a\x23\xf6\xc0\x8b\x77\x54\xc6\x6c\xa6\x52\x45\xa7\xa3\x6e\xf3\xc1\xfe\x25\x80\x30\x52\x33\xfc\x59\x98\x31\xcb\x73\x17\x4d\x63\x27\x1f\x7a\xea\xa8\x3e\x2f\xd1\x6a\xb6\xf5\xb7\x2f\x60\x60\xc3\xed\x6a\xf6\x10\xd9\xd8\xdf\xd6\xc1\x45\x3c\x64\xdd\xbe\x43\x35\xd5\x23\xb4\x1d\x1e\xfe\x42\xb6\x30\x41\x3d\x56\x64\x7f\x1f\x6d\xf6\x8d\x93\xda\x28\xc7\xd1\x27\x05\x4a\x47\xb9\xb1\x8f\xf8\xcb\x72\x3a\x83\x87\xb3\x28\x3f\xcc\x62\x0c\x35\x78\x0f\x62\x74\xb2\x85\x49\x4e\x51\xe6\xed\x28\x84\x4d\xda\x4a\x24\x72\x40\x8b\xfc\x76\x34\x02\xcd\xfd\xf7\x10\xc9\x4d\x66\xbe\x28\xab\x5e\xa8\x9b\x93\xed\xf1\x33\xdf\x5b\xe4\x78\x42\x3e\xb3\x40\x5a\x9b\x9f\xfb\x74\x16\x80\x6b\xf8\x5d\xdc\xf3\x88\x6f\xd5\xb3\xef\xb5\x5f\x86\x63\x68\x94\x00\x37\xaf\x0d\x28\xe0\x8b\xf4\x69\xf8\xdb\xe7\xae\xd7\x79\x37\x74\xaa\xa0\x14\xcf\x31\xcf\x66\x1f\x96\x03\x37\xdd\x66\xcb\x41\xcc\x08\x6d\x49\x51\xc7\x24\xcb\x6d\x33\xba\xa2\xcc\xab\xa2\xe2\x6b\x33\x4a\xa1\xc6\x7c\x6e\x0e\xca\x1e\xb9\xd9\x4a\x07\x0b\x45\x1e\x20\xdc\xf0\xdc\xa6\x40\x68\x7f\x37\xf6\x51\x2a\xf6\x85\xef\xd1\x36\x7a\x4a\x4f\x37\x68\x03\xd1\xfd\x20\xf5\xd1\x04\x77\x23\x3f\xc3\x9f\xef\x92\x34\xac\xb8\x03\x36\x6d\x34\xb0\x86\xdf\x8c\x38\x1c\x9e\xa1\x51\xc7\x6f\x43\x01\xbf\xdb\xb4\x5a\x5e\x4b\x27\xcb\x24\x91\x68\x18\xe2\x73\x9c\x96\xec\xb1\x00\xb0\xfc\x5f\x8b\x2c\x45\xd1\x88\xd8\x3c\x5e\xb8\x4e\xfc\x90\xfd\xb8\x4c\x12\xfb\x1d\xa5\x78\x50\x40\x4b\x3f\x62\xa5\xdd\x07\x51\xac\x61\xa7\x5d\xc5\xd8\xdd\x36\x0c\x41\x8a\x56\xae\xab\x4f\xe9\xf7\x00\xcc\x28\x48\x1a\xe3\xcf\xc7\x93\x5e\xb7\xd7\xed\x83\x7f\xc8\x47\x5b\x9e\x27\x91\x12\xde\xb1\x15\x2c\x2f\x17\x98\x37\x07\x40\x40\x45\xa6\x4f\xb3\x1e\xe9\x7f\x11\x61\x84\x07\x14\x7e\x0f\x5d\x73\x51\xcc\xb4\xfe\x93\xad\xa0\x0d\xd4\xed\xd1\x99\x93\xb5\x6f\xa0\x6e\xbf\xdb\x6a\xed\xc5\xa4\x58\x24\xd1\x25\x9b\x17\xf0\x33\x9a\x96\x54\xb6\x95\xd8\xb0\xdf\xad\x7d\x86\xec\xe7\xac\x58\xdd\x2b\x57\x5a\x9b\x39\xf9\xfe\xe5\x65\xf4\x80\x6e\x69\x16\xc5\xe0\xe9\x40\xc4\x5c\xbc\xec\x71\xd3\xba\x3e\x7a\xf4\x83\x4c\x94\xd3\xea\xf6\xad\xf6\xf1\xb3\xb4\xdb\x74\x66\xd6\x40\x33\x07\x63\x93\x8d\x9e\xda\xef\x5a\xf9\x9b\x30\xba\x66\x94\xc3\x91\xe1\x50\x0d\x34\x3b\xc7\x79\x92\x45\x31\x8e\xa5\x32\xd8\xb3\x26\xf4\x01\x7c\x50\x44\x52\xf5\xae\x71\x88\x3e\x1c\x3f\x3f\x0e\xd1\x3c\xfa\x04\xea\x61\x92\x9e\x2f\x93\x14\xe7\xd1\x28\xc1\x77\x39\x40\x75\x1a\xb0\x5f\xf0\x6e\xa1\x47\x48\xcb\xee\xf7\x07\x39\x5e\x24\xd1\x18\xf7\xba\xa8\x0b\x8e\xdd\xe8\x69\xa1\x63\x06\x8a\xcc\xd2\x73\x9c\x97\x85\x0a\xbb\x09\x72\x5f\x8c\xc7\x64\x1e\x25\x36\x93\x25\xa9\x9f\xd9\x97\xd9\x73\x56\xc0\xa5\xbc\xda\x10\x9a\xa6\x6b\x43\x26\xe0\xf1\x9a\x1a\x83\x40\x96\x99\x1b\x23\x53\x86\xa0\x69\x33\xc6\x46\xd9\x96\xf2\xc4\xbb\x1a\x97\x56\x57\x7d\x80\xd6\x54\x68\x4a\xdd\xf1\x79\xc2\x73\x73\x15\xaa\xb9\xa3\x18\x87\x7d\x06\x90\xe0\xa2\xf8\x30\x8b\xd2\xde\x26\x38\x92\x7d\xc4\x2c\xcf\xb9\x05\x3f\x27\xac\xad\x3e\x84\x70\xd5\x72\x0c\x2c\x1e\x2c\xc1\x55\x33\x47\x65\x94\x5e\x72\xe7\x3b\xdc\x25\x69\x5a\x8d\xd6\x01\xc7\xeb\x41\x1a\xb3\x2b\x00\x46\x43\x64\x72\x59\x70\x67\xea\x05\x1a\xe1\x49\x96\xe3\x81\x43\x57\x2f\xf9\xd1\xa1\x1e\xf7\x57\x7c\x0f\x6a\x20\xad\x97\xb0\xcf\x1b\xc8\x97\xeb\xf7\x21\x37\x17\x9b\x47\x9f\x59\xe8\xca\xcf\xa4\xbc\x0c\xd1\x13\x50\x63\x8b\x5d\x87\x14\xdc\xad\x31\x14\xed\xdb\x9b\x8c\x36\xc9\xbd\x0d\x0a\xb1\x67\x14\xd5\xa7\xb3\xbe\xb0\x53\x96\x8d\xaf\xba\x20\x44\x56\xfa\xfb\xfb\xe3\x37\x03\x89\x5b\x06\xac\x5c\x57\x82\xd3\xd8\x02\x45\x76\x1c\xcf\x00\x2d\xa2\xa2\xa0\x1c\xab\x9c\xe5\xd9\x72\x3a\x33\xe9\x5e\x76\x81\x53\x18\xd4\xea\x5e\x4b\x2a\x5e\xf6\x08\xce\x48\x1e\x49\xb7\x72\x9c\x02\x80\xbf\xea\x30\xab\x6b\xa8\xed\x5c\x58\x8e\x6a\x15\xa0\xde\x3a\x29\x7e\x24\x29\x29\xb1\x85\x31\xab\x1b\x20\x17\x6a\x9d\x30\x65\x2b\xb7\xa3\xda\x6a\x78\xc7\xb7\x12\x46\xfd\xf4\x94\x94\x02\xcf\x47\xbf\x60\x5b\x7c\x9a\xe2\x12\x62\x15\x1f\x4f\x4e\x52\xe2\xd5\x71\x41\xd9\x72\x86\xf9\x0f\xb9\xcc\x50\x99\x05\x52\x27\x25\x5d\xa1\x7b\xe3\x35\xca\x7e\xc8\x6a\x7a\xac\x33\x7d\x28\x02\x0e\xbb\x0a\x84\xf3\x3c\xcb\x85\x33\x1a\xd6\xe3\x02\xa5\x59\x89\xc6\x59\x9e\xe3\x71\x19\x5e\xc8\xd5\x62\xf6\xda\x58\x36\xb4\xa0\x20\x81\x25\xcb\x84\xff\x9e\xc2\x7f\x83\x32\x7b\x95\x5d\xe0\xfc\x30\x2a\x70\x0f\x58\x0a\xd3\xf2\x2a\xee\x45\xa1\x7e\xe6\xf7\xcb\xfc\xd2\xe6\x94\xfe\x7f\xa6\x0e\xe0\x1a\x88\xee\xf1\x5b\x27\x3c\xe6\x83\x2c\xc5\x17\xe8\x05\x1d\x55\xaf\x0b\x97\xbc\xd0\x11\xb0\x52\xfd\x57\xb7\x44\xf8\x33\x29\xca\x22\x40\x8b\x04\x47\x05\x08\xc3\x30\xf2\x2c\x95\xa8\x9a\x64\x49\x92\x5d\x90\x74\x0a\x25\x0b\xca\xfb\xac\x65\xc4\x7b\x18\x80\x67\x85\x40\x3d\xf8\xa8\x89\x0f\x2b\x7b\x0f\x7e\xaf\x4c\x7f\xc2\xd1\x27\x0c\x8b\x90\xb1\x79\xb8\x86\x26\x60\x49\x2b\x59\x2b\x23\x01\xca\x60\xc1\x4b\x05\x9b\x78\x86\x5a\x4e\x59\x6f\xb3\xa2\x20\xa3\x84\x4d\x21\x38\xcf\xe0\xe6\x7c\xef\x8f\xa8\x54\x99\x97\xec\x27\x15\xa4\x05\xb6\x5e\x4c\x26\x64\x7a\xc9\x3f\x8e\x05\x29\x3d\x42\x9f\x68\xf3\xec\x4f\x5d\x52\xc1\x27\xbf\xcf\x62\x60\x73\x05\x26\xaf\x94\xd8\xa7\xb8\x80\x62\x70\x53\x05\x27\x6f\x7d\xd8\x27\xbf\x26\x52\x79\xac\xc0\xa3\x47\x72\x61\xaa\xdb\x1b\x56\xe0\x3f\xd1\x28\x33\xf2\x3c\x25\xc4\xed\x0b\x1b\x00\x5c\xda\xe8\x79\xac\x84\xd6\x0b\xad\x30\xfb\xe4\x58\xd0\x40\x90\x05\xa1\x7d\xc0\x15\x0a\x47\x08\x56\x38\x9c\x6a\xbf\x4b\xf1\xdb\x16\x24\x18\x5f\xb0\xce\xbb\x57\x52\x3a\x67\xe4\x30\x8e\x52\x7a\x1e\x88\x24\x6b\xe6\xe9\x5c\x43\x96\xe5\x28\x42\x2f\x5f\xfc\x03\x8e\xde\x42\x46\xbb\x33\x86\x22\x77\x57\x71\xa0\xfb\x65\x86\x85\x87\xbd\x48\xbb\xc4\xe5\xf1\x4f\xb4\x30\x01\x74\x3d\x45\x05\xba\xc0\x74\x81\x28\xd7\x2a\x62\x18\x6b\x9a\x0c\xf4\x0b\x36\x0e\xe2\x62\x9c\x3a\x4b\x61\x02\x0e\xad\x59\x30\x09\x5d\x14\x62\x25\xf4\x78\xb1\x26\xa7\x62\xdc\xc9\x92\x82\xf4\xcd\x97\x57\x80\x9e\x1a\x8d\x84\xfa\x97\x26\x4f\x35\x2e\xdf\x88\xe1\xd8\xb3\x82\x2f\x30\xb9\x5f\xb0\xff\x2d\x4b\xbc\xcc\xea\x16\xb8\x76\x4a\xf8\xcd\x96\x3a\x5d\x6d\xbf\xe3\x62\x07\x84\xdc\xcd\x52\x2f\xc9\x1c\x17\xbf\xc7\x32\x4f\xb9\x4a\x91\x2e\x6e\xa9\xa0\x2a\xd8\xe1\x1e\xb6\x68\x24\xad\x58\x1c\x72\x90\x3d\x69\x45\x14\x8a\x0c\xc4\x8d\x21\x9d\x7b\x45\x0b\x66\x6d\xd2\xbf\x95\xaa\x40\x01\x48\xfc\xeb\x66\x37\xd6\x2c\x34\x9c\x7a\xbe\xa1\x42\x20\x2c\x7b\x51\x9e\xff\xb8\xba\x42\x9b\x7b\xde\x23\x0d\xaf\xd7\x39\x9c\xb0\x74\xe3\x2c\xc3\x71\x2e\x7a\xf2\xe0\x01\xe2\xbf\x7d\x42\x3f\x6d\xd2\xce\xd5\x4f\x18\x3e\xef\x67\x86\x2c\xc6\x0b\x4b\x4d\xc8\xe6\xe7\x6e\xd0\xed\xea\xd7\x2c\x96\x8f\x34\x5f\x69\x9d\x50\x2a\x65\xba\x54\x44\x8d\xf5\x90\x8a\xa4\x13\x06\x26\xe2\x77\xc8\xa3\x18\x37\x98\x04\xd8\xf2\x22\xeb\x16\x68\x2c\xa3\xb9\x38\xa4\x65\x06\x7b\x69\x43\x5f\x15\x54\xa3\x1d\x8d\xcd\x3a\x4d\x35\x97\x41\x32\x14\x7c\xa4\x51\x96\x6f\xc1\xc2\x63\xef\x9e\xe6\xaf\x4e\x16\xd0\x15\x11\x8d\x53\xd7\x99\xdc\xf2\xaf\x03\xb3\x3c\x58\x24\xcb\x42\x75\x81\x7f\x7b\x1d\x1b\x4a\x20\x53\x7f\x34\xc3\xe3\x4f\x85\x38\x36\x31\x1e\x29\x2e\x37\x0b\xfe\x4c\x2e\xb9\x04\x0f\xbe\xde\x38\xc4\x8c\xe4\xc7\xde\x18\xc4\x66\x34\x61\xad\x01\xba\xfe\x23\x05\xaf\xbb\xb4\x83\xb0\x4a\x7c\xe6\xac\xba\x8d\x89\xe3\x95\x5a\x7a\xb3\xe1\xbf\x37\x3f\x9f\x6e\x3e\xfa\x2e\x7a\x34\x39\xfb\xb2\xbb\x79\xfd\x3f\x43\x32\x28\x71\x51\x4a\xf0\x15\xc6\x5e\x33\xe4\xaf\x33\xd8\x16\xc3\x84\xf3\xff\xf0\xdf\xbd\xcd\xcf\xfd\xa7\xb5\xe3\xd4\xe9\x6f\x38\x54\x51\xb2\x58\x1c\x2c\xe8\x1d\xf3\x1d\xcc\xcd\x0d\xe7\xf0\x82\x97\xee\xc7\xda\xa8\x4d\xfa\xe5\x2e\x00\x91\xe9\xa4\xc2\xdb\x19\xb3\x2f\x94\xcd\x69\x60\x07\x8f\x7e\xf4\x82\x59\x5d\x86\xa0\x5d\xdd\x02\xdc\x1c\x17\x73\xfa\xef\x38\x5a\x14\x20\x3b\x24\x09\x12\xdf\x81\xee\x9b\xd1\xee\x31\x73\x39\xaf\x75\xd8\x68\xe0\x58\x6e\xef\x0c\x3b\x38\x1a\xcf\xd0\x38\x2a\x9c\x6a\x48\xc1\x08\x65\x39\xe7\x33\xa4\x51\x13\x5b\x65\xed\x69\x8a\xb5\x55\x2c\xe7\x73\x1c\x57\x92\x97\xd5\xdc\x1d\x93\x99\x55\x7b\x05\xb9\x21\x2d\xb6\xce\xa1\x07\x3f\x91\x2c\xcd\x7f\x39\xbb\x90\xd2\x89\x70\x88\x97\x51\x01\xae\x68\x66\xd1\x8e\x68\xc8\xd4\xa7\x08\x89\xc7\xe7\xee\x65\x77\x13\x6e\x27\x11\xed\x9a\x3e\x8b\xe0\xbb\xbb\x9c\xa1\x04\xc3\x6b\x6a\x2d\x00\xdf\x62\x81\x73\xda\x5d\x31\x17\x29\x04\x2f\x9c\x12\x16\xdf\x2e\x2a\xf0\x3c\x5a\xd0\x39\xd9\x32\xd4\x7d\x3d\x69\xbc\xa0\xf5\x1a\xbc\xb2\x6d\x3d\xee\xa3\x1f\xd0\xb7\x74\x4f\xe7\x59\xa7\xe4\x6c\x50\x66\x27\xb4\x21\xae\x10\x5a\xdf\xdf\xd7\x32\x81\xf2\xeb\x2b\xfc\x7e\xdf\x53\xa3\xae\x62\xb2\x6a\xac\x70\x15\xae\xad\x4d\xc5\xf7\x0d\xee\x0f\x6b\x01\x26\x95\x45\xbf\xe1\xe4\xfa\x9a\x9f\xf9\x04\x59\x56\xd0\x64\x99\xdd\x25\x4d\x0a\xe5\xb5\xdc\xa0\x5b\x92\xa4\x64\x81\xfc\x01\xb6\xa4\x41\xfb\xe5\x35\x6f\xa8\xdb\xe5\x04\xe5\x12\xab\x81\xe4\x1b\x91\xae\x06\x34\x76\xba\x4f\x2b\xaa\x21\x66\xd1\x0b\xed\xda\xdd\x21\x6c\xe0\x7f\x33\x65\xfb\x47\x49\xf5\x3b\x7a\x06\x9a\x30\x2f\xfa\xe2\x2a\x4e\xd1\xb9\x41\xc7\x4d\x64\x6c\x12\x92\x3d\x82\x8d\xfd\x4a\x1a\xd7\xa8\xcc\x66\xaa\x8d\x35\xd5\x52\xa8\x55\xd2\x94\x42\x95\xd4\x69\xb0\xd4\x32\xa3\xd2\x25\x89\xd1\xf6\x26\xf3\x1c\xf4\x88\x5f\x11\xb2\x36\xd9\x2b\x85\xcd\xcf\x88\x99\x77\xb8\xe6\x5d\x8d\xc4\xec\xbf\xef\xe7\x3e\x08\x74\x0e\x2e\x4d\xb8\xda\x6d\xe2\x96\x68\xe3\xdd\x04\x85\x6b\x5d\x81\x0f\x4d\x9e\x67\x3b\x6f\xdd\xa6\xeb\xa9\x88\x5f\x7f\xf9\xea\x33\x21\x44\x00\x46\xb8\x54\x92\x35\xaa\x37\x55\x01\xda\xdd\xf4\xdf\x18\x08\x77\xc4\xe2\x64\x5d\x28\x89\xb7\x39\xd4\xa6\xf7\x54\xe9\xbb\xfc\x32\xc2\x6f\xb2\x4d\xcd\x77\x1e\x44\x3d\xd6\x0d\x4b\x46\x14\x7d\x4b\x8b\x32\x4a\xc7\x94\x8f\xa8\xc2\x57\x57\x12\x69\xbc\x30\xbc\x61\x83\x5f\x86\xfb\x0c\x6f\x2a\xb3\x8e\x00\x6e\x24\xab\xec\xb6\x45\x94\x38\x1b\x37\x61\xe9\xbd\x63\x5e\xd4\x12\x45\x9e\x40\x49\x5e\xfc\x70\xe6\xca\x7b\x06\xa3\x61\x7d\xeb\xde\x1d\x7a\x58\x5f\x5a\xe3\x46\xf4\xb8\x19\x3b\x3f\x2a\x33\x92\x55\xf1\x23\x8a\xde\x08\x43\xa2\x44\xb7\xe5\x88\x68\x9f\xca\xe6\xe1\xb0\xae\xdf\x60\x30\xc7\xbc\x6f\x37\x18\x0a\xfb\xdd\x76\x20\x23\xd6\x76\x8b\xd5\xcd\x00\x6f\xb2\xb6\x59\xd2\x8d\x06\xc3\xbb\xd7\x76\x34\xe0\xd7\xaf\x79\x2c\x4e\x98\x8c\x96\x23\x71\x43\x5d\xb4\xe4\x50\x50\xb0\x76\x0c\xf6\x49\x83\x6d\x8b\x60\xf4\x96\x09\x22\x32\x07\xf1\xf7\xc2\x5c\x26\xca\xa4\xa0\x76\x0c\xb4\x98\xfd\x0c\x40\xfa\x43\xca\x2f\xdd\x6d\x67\x7d\x1d\x2e\x1d\xd9\xdb\x5a\x65\x9d\x7a\x8d\xc6\x10\xcb\xa9\x87\x3d\x5b\x95\x7e\xd6\x5c\x65\xd4\x11\x1f\xf7\x0b\x3a\x81\x78\x39\x47\xa3\x24\x1b\x7f\x42\x33\x1c\xc5\x38\xa7\x1f\xd9\xdc\x36\xc3\x20\xc5\x33\x9a\xec\x93\x01\x66\xf8\xb3\x74\x76\x0e\x65\xd1\x84\x24\xa5\xad\xa7\xf4\x10\x2c\xc0\x1a\x3e\x85\x69\x4a\xed\x21\xfe\x9b\xad\x6d\x75\x8a\x67\xe0\x0d\x78\xa9\x3e\x83\xb3\xba\xf4\xaa\x7c\x47\x70\x17\xca\x17\x46\x58\x3b\x42\xaf\xb9\x1d\xb9\xc1\xd4\x24\x19\x15\xdb\x16\x64\xec\x4e\xc4\x07\x9a\xdc\x34\x11\xa5\x04\xaa\x99\x01\xa8\xc9\x98\x01\x28\x56\x3b\x03\x8f\x77\xd5\x04\x30\xe8\x1b\x4f\x00\x54\xa5\xd7\xe4\xc3\xbf\x03\x74\x33\xf4\x57\xf8\x13\xe1\x32\x5c\x28\x7e\x04\x22\x15\xde\xf1\x84\xf2\x17\x4b\x07\x49\x2f\x64\xff\x89\x14\x6e\x1e\x12\xaa\x9f\x2c\x47\x33\x1d\x09\xf5\x0f\x51\xee\xa4\x9c\x3c\x09\xf9\xff\x22\x0d\x8c\x51\x42\xf1\x43\xd5\xc3\x60\xc5\x2f\x95\xce\xe1\xe5\x4f\x5e\x8f\x6b\x47\x1b\xfa\x12\x19\xb4\x6b\x9e\x19\x7a\xd2\x0c\x58\x61\x09\x19\xda\x09\x62\x1c\xbf\x60\x18\xc5\x2f\x58\x1b\x03\xa4\xf1\x1f\x02\x4e\x8a\x7f\xa1\xfe\x21\x72\x4d\x7d\x74\xe8\xa4\x48\xac\x31\xc9\x3b\x54\x3f\x59\x8e\x26\xee\x86\xfa\x87\xc8\x35\x8e\x16\xa1\x9d\x20\xa0\xb4\x7c\x2b\xc7\x3a\x8e\x87\x6e\x92\xe8\xa1\x03\xe9\x24\x89\x3a\x85\x74\x15\x6a\xbf\xf5\xfe\xa6\xd3\x50\xfe\x12\xe9\x6c\x57\x0d\xe5\x2f\x39\x7a\xb6\xe0\x43\xf5\x53\x8e\x89\xee\x93\xa1\xf8\x21\x52\xe9\x96\x15\xf2\xff\x65\x1d\x94\xe3\x85\xe2\x87\x48\x05\xbe\x11\x8a\x1f\x01\x2c\x30\xe6\x77\x8e\x3f\xd6\xee\x84\x5b\xdf\x05\xb5\x6e\x6b\x82\xce\xb2\x9c\x3c\xe9\x84\x4f\xbe\xb9\x3e\x0b\xb6\xb7\xda\x38\x72\x30\x97\xf0\x3e\x5b\xc0\x1d\xee\xbf\xa0\x13\xa2\xce\xe6\x60\xeb\xc9\x60\xb7\xb3\x76\x2d\x3c\xbc\x6d\xb7\x0a\x40\x7c\xef\x20\xe2\xde\x41\xc4\x5f\xc1\x41\x04\xaf\x65\xcd\x75\xf1\xf6\x77\x3c\x99\xe4\xf8\x12\xfd\x42\x92\xf1\x27\x8c\xbe\xff\x15\x4f\x26\xb6\x97\x88\x96\x8e\xe0\x00\x8c\x44\x29\x3a\xa6\x32\x77\x04\x50\x24\x4a\x5d\xb0\x1f\xa3\x11\x05\xfb\x39\x9b\xe2\xa4\x28\x71\x92\xe0\x1c\x7d\x3f\x81\x44\x17\xf8\xa7\xe8\x1c\xfd\x92\x65\x31\xfa\x7e\x5a\xe9\xbd\x62\x57\x79\xed\xe1\x2e\x1e\x5f\x47\x69\x34\x35\x5d\x4a\x0c\x86\x14\x0b\xc3\x9c\x01\xcc\x19\x80\x70\x1d\x71\x34\x82\xe3\x91\x0d\x4c\x46\x51\x2a\x40\x5e\x80\x65\xbe\x0d\xc1\x44\xaf\x62\x88\xcb\x99\x00\x7c\xfe\xac\x06\x2e\x1e\x49\x37\xb2\xb3\xba\xfa\x8a\x99\xac\xef\x0d\x38\x1c\xaf\x02\x4c\x71\x29\x00\xdf\xe2\xbc\x80\xd7\x51\xd5\xd0\x0b\x0e\x22\x3b\x71\x11\xe5\xf3\xba\x6e\xd0\x7c\x09\x8c\xcb\x12\x82\x31\xb9\xf0\x05\xcf\x12\xa0\x82\xab\x18\x90\x82\x5d\xd0\x33\x95\xf2\xd9\x41\x12\xab\x42\x2d\x5a\x7c\xb5\xeb\x0f\x06\x24\x9c\x2c\xf1\xb7\x18\x38\x8d\x3d\x7d\x63\x19\x02\xec\x19\x9c\x99\x5c\xa8\x11\x4d\x97\x98\xcc\xb3\x05\xce\xcb\x4b\x0f\xdc\x82\x67\x09\xd0\x97\x65\xb9\x78\x9b\x67\xe7\x24\xf6\x92\x1b\x5d\xa8\x0b\x9e\x2d\x89\x6d\x31\xae\x29\x41\x16\x63\xbb\x40\x3b\x47\x85\x6b\x6b\x52\x58\xff\x05\x8f\x76\x50\x4f\x54\x63\x3a\xdb\xcd\xed\x15\x92\xe2\x0b\x6b\xd9\xa8\x92\x9a\xdf\x5d\x1e\x41\x55\xeb\xb9\x80\xd2\x80\x30\x7b\xbe\x82\x2f\xe8\x72\x01\xff\xfb\x7a\x15\xf1\x88\x67\x3e\x7f\xe6\xe4\x15\x33\x51\xf2\xfd\xcc\x2d\x99\xc2\x1a\xa0\xb9\x6f\x70\xe9\xe4\x2e\x14\xe1\x53\x10\xb1\x0e\x1c\xb8\xd1\x7f\xfe\x23\xda\xa0\x74\xed\xf6\x41\x11\x38\x00\xf1\xcf\x9e\x0e\xa3\x28\x5b\x9d\x35\xa2\x05\x09\xe5\x66\xc8\xff\x67\x67\x0e\xbd\x93\x1c\x5b\x85\x51\x54\x27\x9f\xd0\xf8\x0a\x24\x8c\x46\x2f\xa1\xfe\xe1\x34\xf1\x51\xae\x01\xf6\xc3\x19\x20\x07\xe8\xa9\xf6\x39\x39\x13\x5c\x84\xda\xef\x1e\xb3\xd4\xb9\xee\xef\x51\x89\x69\x38\x04\xcf\xba\x05\x46\x6a\x0c\x19\xdb\x89\xc1\xd5\xcf\x1a\x25\x37\xcf\xf8\x9a\xc6\x56\x39\x2e\x2a\x34\x8a\x3a\x45\x98\x4c\xac\x53\x9e\x1e\x0a\xb8\x99\xc6\xf5\xc2\x2b\x93\xb6\xa7\x2f\x39\x66\x31\x20\x54\x2f\x3e\x61\xbc\x38\x2a\xde\x5f\xa6\x63\x92\x4e\x6b\xbb\x02\x65\x2d\xf8\x76\x14\xe8\xe9\x88\xce\x17\x9e\x29\xe3\x14\x0b\x4a\xbc\x6c\x61\x5e\xa2\xe0\xcb\x03\x23\x5e\xc1\x0a\x28\xf8\xf6\xc0\xf1\xa7\xd4\x02\x8c\x7e\x3a\x50\xfa\xab\x5a\x06\x28\x53\xbc\xb0\x46\x9d\x22\xc1\xd3\xb6\x7a\x22\x25\x9a\xe7\x29\xde\x5a\x6d\x68\x2d\xcd\x53\xb7\x8e\x4b\x51\x7b\x1d\x4e\x99\xfd\xa2\x80\xfc\x05\xfb\x47\xa6\x43\xf1\x6f\x07\x4e\xb7\x5b\x61\x90\x32\xc5\x03\xeb\xde\xf4\x8a\x32\x87\xf6\xf5\x9f\xd3\xe7\xaa\xb2\x4e\x8e\xa7\xdd\xa3\x67\x07\x6f\xb4\xc6\xe8\x27\xdd\x73\xec\x65\xca\x36\x6a\xfd\x29\x35\xbb\x93\x31\x5d\x1c\x9a\xb7\x65\x70\x29\x6c\x43\x56\xdd\x5e\xc6\x24\x07\xd5\xee\x38\x5a\xc0\x43\x08\xed\xfe\xd0\x83\xff\xa3\xc3\x83\xb7\xc6\x4a\xa5\xe5\x74\x63\x35\xc2\x04\x3f\xba\xd8\xa8\x0c\xc8\xf2\x8d\xd7\x96\x14\x62\xc0\x9b\x11\xeb\x10\x3c\xba\x48\x6e\x59\x17\xf6\xf3\x54\x72\x5a\xd8\x99\xb8\xf0\xd0\x33\xaf\x7c\x53\xd0\x98\x74\xc5\x0e\x92\x66\x31\xee\x06\x06\xc4\x14\x8c\x33\x42\xd4\xa5\x22\xc2\xc7\x71\x42\x70\x5a\xfe\xcc\xc0\xbb\xea\x4a\xb8\x1f\xdc\xa4\x35\x5c\x5e\x64\xf9\xa7\xaa\x06\x53\x5c\x7e\xe4\xa0\x16\x88\xe9\xb5\x3f\xb4\xd7\xe4\x2d\xbb\x85\xb9\x02\xba\xaa\x5f\xb8\x9c\x7d\x84\xb9\x1e\x67\xc9\xcf\xbf\x43\xff\x2e\x66\xa4\x58\x48\x07\xc5\x4e\xf7\x8a\xd9\xec\xd6\x68\x83\x9f\x67\x5e\xce\x4f\x8a\xc3\x2c\x4d\x99\xd3\x24\x6d\xb9\xf5\x0d\xda\xeb\x79\x37\xb7\x07\x0f\xbc\x9b\x9e\x5e\x65\xaf\xef\xdf\x6f\x98\x9b\x00\x21\x41\x57\xd2\x3c\xd8\x69\x42\xf8\x02\x2e\x7f\x78\xb5\xac\xb4\x6e\xe1\xd2\x53\x97\xe7\x99\x82\xc8\x38\x06\x74\xc2\xed\x4d\x9a\xa4\x1f\x20\x3a\xe1\xf6\x16\x4d\x53\xc2\x7b\x27\xdc\xde\x95\x29\x4c\xd0\xe9\x84\xdb\x4f\x64\x92\x2e\x8a\x77\xc2\x9d\x6d\x99\x41\x57\x78\x27\xdc\xd9\x51\x09\x4a\x04\xef\x84\x3b\xaa\x52\x75\x88\xeb\x84\x3b\xdf\x3a\xc9\xb8\x9c\x75\xc2\x9d\x27\x4e\x7a\x8a\xcb\x4e\xb8\xf3\x9d\x93\x2e\xc4\xd6\x4e\xb8\xbb\xe9\x64\x16\xb3\x59\x27\xdc\xdd\x72\xd3\xa9\xe4\xda\x09\x77\x55\xf7\xc5\x89\xa4\x13\xee\x7e\x23\x13\xcd\x63\x6e\x27\xdc\x7d\x2c\xb3\x84\x8c\xd1\x09\x77\xbf\xad\xd7\xc4\x5d\x9f\x05\xdb\x3b\xf7\x7a\xb2\x7b\x3d\xd9\x5f\x5b\x4f\xa6\x39\x90\x8e\x92\x04\x5c\x3c\xdc\xce\x9b\xaa\xa6\x8f\x72\x34\x17\x3e\xd5\x85\x08\xd6\xf2\xe2\x9c\x59\xd7\x6b\x2a\x01\xe8\x8d\x80\x53\xa1\x5b\x9a\x62\x14\xb9\x6a\x15\xaf\x5e\xe5\x47\xb8\x8d\xb5\x2a\x83\x34\x01\x71\xc1\x22\x10\x99\x20\x82\x17\xf1\x4c\xe9\x63\xf5\x20\x49\x8c\xa1\x98\x92\x91\x79\x12\x0a\xe0\x6a\x3d\x40\x96\x69\x57\x85\x8e\xc2\x4c\xd0\x4f\xb4\xbf\xb2\xdb\x74\xfa\x9f\x9e\xec\x18\x2c\xb2\x5d\xc8\xe9\x61\x7d\xb0\x6d\x4b\x6c\x15\x5e\xb9\xf7\xe5\xaf\xab\x2b\x88\x42\x83\x6c\xcf\x0b\x34\x11\x52\x4f\xbb\x54\x0c\x05\xef\xfe\xdd\x00\x75\xcb\x8c\xfd\x3c\x1b\x30\x34\x6b\x51\x07\x27\x9e\xdb\x4b\xde\xcc\xe9\xe4\x0c\xcc\x58\xa5\x85\x26\xbf\xd1\xec\x7b\x42\x57\x5b\xd5\xd0\xfe\xd0\xe2\xfb\x1a\xf1\x30\x27\x36\xd0\x11\x76\xbc\x51\xa1\xe8\x54\x83\xc2\xc8\x40\x3d\xa2\x02\x6f\x10\x0a\xaf\x06\x9e\xcd\x97\x56\xba\x7f\x88\x3a\x8c\x7b\x62\x07\xc7\x51\x19\x89\x11\xd0\xdf\x03\xfa\x0f\xda\xd7\x7e\x5f\x5d\x81\x59\xaa\x04\x80\xab\xdf\x42\x80\xf0\xaf\xab\x2b\x15\x03\x13\x94\x83\xb4\x69\x71\xa7\xad\x01\x9e\x6e\x9e\x0d\x0a\xca\x11\xa4\xa3\x73\x0a\x3d\xe7\x12\x8e\xa2\x30\x77\xba\x7e\xf5\x4c\x97\xde\xca\x3e\x37\x76\xe5\xe2\x9d\x7b\xc7\xda\xfb\x55\xbe\x15\xef\x9f\x6e\x9e\x69\x8f\xa0\xd6\xa1\xfd\x3e\xfa\x02\x0f\x0f\xa2\x34\xcd\x4a\x34\x21\x69\xcc\xfa\x45\xd2\x29\x6b\xe8\xa9\x6c\x7e\x9c\xa5\x45\x96\xe0\xc1\x45\x94\xa7\xbd\xae\x5e\x82\xf9\xab\xa1\xbc\x38\xc9\xa6\x5d\xcd\xf4\x94\xf7\x98\xa2\xc2\xf1\x79\x84\x39\x1b\xd2\xe3\x63\xc1\xdc\xf5\x7c\xab\x33\x60\xdd\x0a\x4c\x82\x30\xcf\x50\x50\xa3\x70\x37\x08\x53\xdc\x62\x39\x7e\xc6\x63\x2a\x02\x78\xd6\x63\x00\x3e\x91\x46\xd1\xf8\x93\x8c\xe4\x09\x6e\x01\xf8\xd9\x54\xdc\x8e\xf6\xa2\x7c\xba\x84\x77\x19\xa7\xf2\x97\xe6\x0f\xc7\xb4\x05\x17\x35\x42\x04\xe6\xda\x62\xba\xe7\xb6\x9e\x03\x41\x27\x7e\xcb\xf4\x29\xa1\xd8\x46\xba\x4c\x12\x07\xdd\x99\xa0\x34\xee\x7f\x4e\x9d\x80\x05\xc4\x44\x8b\x75\xc6\x14\xa9\x80\xc9\xc1\x88\x98\x3a\x3e\x4d\xfe\x66\x9c\xbd\x62\xc2\xb2\x40\xf0\x75\x7a\xcc\xea\xf5\x03\xd5\x82\x86\xda\xe6\x29\x8a\xca\x32\x1a\xcf\x3e\x64\x87\xc2\x07\x95\x3e\x57\xc2\x31\x95\x7e\xda\x56\x73\xca\x06\xcc\x3e\x9d\x71\x88\xa2\x83\x28\x49\xe4\x46\xc2\x81\x2b\x4e\x13\x4e\x37\xe5\xd1\xc2\x73\xb6\xf0\x1e\x2e\x80\x46\x3b\xe1\x36\xc8\xf5\x6c\xb9\x77\xc2\x6d\x90\xda\xf5\x90\x69\x3b\x00\x6c\xed\x80\x9d\x70\x77\x87\x0a\xcb\xbb\xf7\xc2\xf2\xbd\xb0\xfc\x5f\x23\x2c\xc3\xa9\xfb\xae\xc2\xad\xfc\xbd\xc8\xd2\x7c\x31\x36\x05\xcd\x5f\x59\xa2\xbc\xe2\xcb\xf3\xcc\x96\x7d\x59\x9a\x14\x41\x5d\xe5\x04\x1d\xac\x21\x5d\x3a\xc2\x25\xa0\xe3\x63\xa5\x88\xc9\x33\x0a\x1e\x57\xbb\xc1\x47\x5f\x14\xc7\xc2\x9d\x22\xe5\xc3\xbc\x30\x78\xa8\x86\xae\xf1\x04\xcb\x74\x2f\x8a\x63\x8f\x35\x2c\xe2\xe3\x67\x85\x4a\x65\x87\x3a\x5c\x83\x71\xea\xac\x38\x8e\x7d\xc2\xb6\x6f\xe0\x05\x0b\xca\x2d\x20\x1a\x47\x24\x98\x76\x5d\xff\x39\x8c\xb7\x6b\xbe\x8d\xdc\x7c\xe2\x2f\xf1\x6b\x74\xd3\x9d\x02\x75\x9f\x93\xc6\x4c\xc1\x24\x60\x03\xad\x6e\x9c\xe7\x01\x17\x41\x0b\x57\x18\x66\xe4\xc3\x7e\x71\x29\x51\x01\x70\xfc\xe8\xde\x1d\x25\x2a\x03\x04\x4f\xcc\x2b\xde\x8f\xf1\x2a\x4f\x01\xe6\x4c\x3f\x17\x54\x4a\xea\xac\x48\x45\xb5\x54\x9e\x11\xfd\xe1\x95\x0e\x1c\xa1\xc7\x2e\xb0\xce\x17\xd1\x80\x14\x3f\x47\x09\x89\xdf\xe1\x62\x91\xa5\x05\xe6\x4d\x39\x6f\xdf\x9c\x31\xf8\xdb\xeb\xb1\x35\x36\x38\x4a\xcf\xbd\xb5\xee\x39\x95\x5e\xbb\xfd\xab\xac\x9c\x39\x4e\x72\x06\xcb\xf6\x5c\x70\xd0\xe0\xcb\xe0\x8d\x0f\x78\x1f\xc0\x75\x83\x9e\xe0\x04\x91\x57\x53\x21\x0f\x36\xc8\x2f\x4a\x00\x65\x29\xcd\x24\x1b\x7c\x27\xdc\x06\x0d\x1a\x5f\x91\x9d\x70\x07\xac\xd3\x5a\x05\xd9\xbe\xdf\xf0\xef\x37\xfc\x3f\xef\x86\xaf\xf6\x7b\x29\x96\xdf\x91\x6e\xac\xa5\x92\x8a\x1e\x75\x72\x0b\xac\xe0\xb2\xfe\x10\x32\x57\xd5\xa3\x09\x38\xed\xc1\x92\xae\x00\x13\x2f\x91\x38\xf4\x81\x76\x08\xd1\xc0\xa4\xaa\xd0\x88\xf8\xed\xdb\x3f\x99\x5e\x49\x7f\xdd\x05\xdb\xbc\xfd\x44\x98\xc1\x1d\x2a\xb0\xb7\x02\x4a\xca\x05\x60\x94\x7b\x8d\x84\x1b\x65\x33\xd5\xdb\x00\x77\xb4\xeb\xaf\xda\x7c\x63\x39\x22\x01\x2f\x67\xdd\xe7\x44\x23\xe2\xd1\x7f\x68\x2e\x97\x91\xe5\xe3\x98\xc5\xd7\xde\xdf\x47\x5d\xad\x4f\x5d\xf4\xe0\x81\xe1\x43\x59\x3b\x30\xb3\x66\x0d\x47\xfb\xd7\x7d\x6b\x1b\xae\x6b\xd0\xe3\x95\x19\xf5\x20\xb1\x62\xbb\x86\x3c\xe6\xac\xd9\xb3\x33\x58\x15\x51\xb0\xc2\xd3\x34\xd0\x1e\x3f\xb5\x33\x84\x32\x50\x89\x46\x4d\xbd\x23\xd4\x56\x2d\xa4\x47\x19\x4f\x8b\xfb\x6b\x62\x47\x6b\xef\x1b\xa4\x28\x8e\x05\x0d\x17\xea\x18\xae\xd3\x86\x48\xbb\x96\x35\x55\xd2\x13\x23\x15\x7f\x95\xb5\x27\x7b\x75\x5c\xbf\x39\xa1\x68\xcf\xff\x56\x99\x7d\x5d\x45\x25\xd5\x3e\xb2\x3f\x1f\x71\x39\x13\x7a\x66\xd5\x49\xd3\xf5\x44\xa3\x0e\x75\xe2\xa8\x39\x14\x02\x94\x8e\xb4\xc5\xbc\x32\x6e\xd1\x6a\x52\x19\xbf\xb9\xbb\x19\xb5\xeb\x6b\x56\xd4\x08\x86\x77\x17\x73\xcb\x78\xaf\xa5\x4f\xe6\x9c\x95\xab\x19\x25\x8f\x35\x27\xcf\x55\x5d\xb1\x8e\x55\x4e\xe7\x41\x92\xd4\x4e\x17\x00\xf1\x1b\x9e\x95\x09\x8c\xe9\x40\x1b\x3a\xb8\x3a\xb5\x19\xcf\xf7\x5c\xa5\x5a\x15\xb5\xd5\x91\x9b\xf4\x56\x03\x36\x7a\x62\xd2\xa7\xb8\x2c\xb8\xd9\x4a\x72\x89\x62\xbc\x48\xb2\x4b\x1c\x0b\x53\x3e\x78\xe8\x37\x9e\x45\x24\xb5\xdf\x95\x41\x6d\x3f\x66\xb9\xe8\x91\xe7\xd1\xbf\x38\xb0\xfa\x48\x52\xac\xcb\x6b\xa9\x5a\x5c\x33\xfc\xd4\x9e\x88\x5b\x0d\xf5\xfe\xac\xa2\x45\xdd\xd4\x41\xb4\xa4\x29\x2c\x15\xf9\x42\xbc\x64\x08\xe2\xe2\xe8\x77\x7f\x84\x20\xe1\xfb\xe2\x01\x18\xe4\x0f\x87\xe8\x22\x22\x4c\x4f\x0e\x22\xd7\xa2\x54\xba\x57\x71\x45\x66\xce\x3b\x5f\x0a\x32\x5e\xb3\xea\x18\xee\x9b\xee\x8f\xd7\x31\xdd\xf8\xd6\x8d\xf6\xed\x5d\x09\xfa\xbb\xb1\xb1\x67\x1e\x9b\x86\x43\x54\x94\xd9\x82\xe9\x6a\x49\x3a\x45\xd1\x84\x76\xe5\x9b\x4d\x36\x57\x05\xea\x95\x64\x8e\xb3\x65\xd9\x77\x8e\x8e\x0c\x01\x3f\xa0\x6f\x36\xbd\x87\x45\xd6\xfb\x01\xad\xfd\x17\x5e\xb9\x0a\x67\xd0\x47\x5f\xae\x3d\x67\x3a\x1b\x81\xec\x65\x9d\xf7\x1c\x2a\x67\xc4\x7b\xda\x54\x27\x3f\xe5\x9d\x57\x32\x26\xb8\x28\x89\xd8\xca\x18\x53\xc2\x06\x4f\xbd\x23\x2a\x31\x2f\xd3\xd8\xc6\x40\xd7\x77\xf8\xc4\x89\xe6\x81\x48\xff\x73\x7c\x02\xdf\xb8\x55\xba\xfc\xf4\x9a\xa5\x23\x0f\x17\x6b\x06\xd5\x4c\x71\xf9\x41\x35\xf5\x8e\x91\x9a\xe2\x28\x5a\x37\x5e\x46\xc5\x4c\x27\xaa\x40\x10\x66\xdf\x7f\x84\x27\x93\x1e\x07\xf0\x53\x9b\xb7\x90\xb7\x83\x10\x3d\x88\xd7\x35\x18\x9b\x0b\xd0\xec\x11\x84\x18\xf2\x77\x47\xfc\x55\x39\x4e\x7f\x2c\x1d\xa7\x57\xfd\x91\x49\xcf\xa4\xb8\xab\x2b\xb4\x0e\x2d\xd6\x16\x43\x92\x75\x7b\x68\x53\xff\xbb\xc9\x12\xd0\xff\x5a\x2e\x07\x7b\x48\x59\xac\x45\x68\xde\xa9\x9d\x19\xf1\x37\x1c\xca\x0b\xbe\x24\x9b\x6a\x54\x0b\xc7\x0a\xc1\xc6\xd7\xbb\xfd\x86\xe6\x91\x21\xaa\x49\x8e\x5a\x31\xd5\x2d\x2a\x1b\x0e\x11\xdb\xac\x84\xb8\x10\xa5\x31\xe2\x37\x23\x28\x9a\x46\x24\xe5\x2b\xe7\x02\xf3\xe0\x7a\x0d\x7f\x7e\xd9\xd3\xde\x00\x1b\x6a\xb0\x65\x1d\x67\xfb\x6f\x18\xd2\x98\x79\x46\xe3\xb7\x81\x74\x4b\xa0\xbb\x63\x81\xc7\x59\x1a\x23\xca\x70\x1b\x2b\xd1\x48\xb7\x99\x58\x91\xc1\x11\x41\x17\xd6\xb6\xc3\x5e\xf7\x41\x77\xdc\x21\xdd\x81\xba\x26\x4a\xf0\x13\xad\xc6\x29\x8b\x32\xcb\x71\x2c\x9d\xa9\x33\x09\x04\x34\x3e\xd3\xa8\x40\xd1\x9c\x6e\x48\x03\x2f\xbf\xb6\xff\x2a\xf9\xb7\xfd\xe7\xf1\xf1\x7e\x17\x5d\xac\xef\xe1\x75\x65\x6e\x15\xc7\x70\x4b\xd8\x90\x9a\x76\xb2\xed\x81\x42\xbb\x62\x10\x84\xfe\x63\x44\x8f\xd9\x97\xd2\xeb\x85\x25\xc5\x59\x60\x0d\x87\x06\xbb\x52\xfd\xc0\x00\xa7\xaa\x68\x44\x8c\xcb\x05\xf6\xf2\x07\x8b\xe3\x3b\xa4\x45\x23\x82\xf6\x29\xa4\x90\xb3\x1e\x32\x4d\x68\xf3\x98\xd4\x09\x29\x45\x91\x26\x9a\xf2\xe2\xa2\x16\x31\xb6\x14\x5f\xc8\x24\x31\xa6\xf4\xf2\x5a\x27\x06\x4b\x37\xb2\x25\x8c\x09\xa2\xa4\xbf\x62\xd1\xed\x9a\xa2\xb6\x1c\x6c\x48\x16\xdc\x2b\x89\x50\x14\xc7\x4e\x69\x9f\xa4\xcc\x21\xa4\xb4\xac\x8e\x7f\x22\x49\xb6\xa5\x26\x1e\x0a\x0d\xd5\x44\x50\x94\xfa\xae\x5f\x50\xcd\x16\xfd\xad\xa8\x01\x09\x47\x86\x48\x4a\xd7\xf2\x14\xa9\xd3\x5f\x4f\xd0\x41\x20\x67\x5f\xe7\x60\xc3\x21\x0b\x6b\xa8\xcc\x2b\x8c\x4a\x95\x91\xc4\x97\xeb\x3d\x0a\x2c\xb0\xb4\x6e\xb6\xcd\x11\xa3\x55\x0c\x67\xdc\x1c\xde\xcc\x00\x21\xeb\xcf\x11\x12\x32\xc6\x70\xd5\xa0\x0c\x35\xac\xc8\x7b\x3e\xa3\x11\x30\xfc\xa8\x36\x15\x41\x8e\xb9\x48\x31\x58\x64\x0b\xc3\xb3\x9b\xd9\xbd\x24\x2a\x4a\x0e\xe9\x54\xed\xef\x0e\x0f\xe9\x42\x0b\x82\x13\xe4\x75\xf9\x32\x04\x62\xc0\x42\xba\xdd\x27\x85\xc2\x86\x2e\xd1\x86\x38\xf0\x80\x85\x06\xf9\x01\x6d\xda\xb5\xf1\x99\x16\xb4\x7f\x20\xd6\x72\xb3\x16\x40\xfc\xdd\x4a\x25\xa8\xa1\xc9\x62\x96\x42\x9d\x26\x6d\xec\xf4\x61\xad\x9b\x5d\x1e\x2c\xa2\xcb\x68\x94\x60\x5f\xf7\xdc\xe3\x00\x33\x9c\x2a\x70\x1a\xab\x60\x50\x69\x96\x3e\xe2\x95\xe8\xe8\xb0\xb7\x89\xeb\xaa\xa9\x07\xa7\x7a\x94\x33\xfa\x55\xb0\x3d\xb1\x54\x02\x18\xb1\x56\xab\x98\x20\x30\x7a\xdb\xd8\x67\x15\xed\x99\x93\x58\x79\x23\xa8\x9f\x68\x0d\x1d\x80\x90\xfb\xa2\x38\xb5\xb5\x04\x31\x46\x17\x51\x21\x05\xca\x35\x13\x57\x6c\x69\xc3\xd5\xab\x76\x84\x51\x16\x59\xd6\xfd\xeb\x2c\x2a\x66\x3e\xa4\xd3\x5e\xe3\x3c\xaf\xba\x89\xd4\xaf\x1c\x7d\xf7\x8a\x75\x12\x0f\x15\x47\xe3\x98\x5d\x7b\x69\x5c\x97\xf6\xc4\xdf\x56\xc5\xb1\x0b\xed\x43\x99\x0a\xe1\xab\x52\x42\x9c\x90\xbc\x28\xab\x05\xc4\x15\x65\xbc\x0a\x0d\x88\x4f\xed\xe1\xbb\x7e\x35\xbe\x9a\x3c\x4e\x42\x90\x4b\x36\xf0\xa6\x79\xb6\x1a\x6b\x8b\xf2\x46\x54\xaf\x32\x74\x3f\x4f\x93\x3a\x79\x06\xc4\x75\x65\x1c\xbb\x62\x13\xa4\xe7\xdb\xe7\xcc\xa0\x14\x92\xf8\xa7\x61\x80\x76\x63\xc1\xcb\xd6\x9a\x35\x69\x67\x3d\x9b\x3a\xaf\xe9\xda\x94\x81\x26\xb2\xfe\xe1\xda\x70\x68\xed\xc0\xc6\x05\x8e\x8a\x37\xa8\xa9\x2f\xad\xca\x7b\x6c\x5f\x1e\x0e\x0d\x37\xb6\x95\x21\x9f\xc7\x63\xf0\x48\x9b\xb1\x68\x49\x24\x9d\xd6\xc8\x66\xa6\x1a\xdb\x1c\x39\x9b\xc4\x6b\x97\x13\xe9\xe2\x50\x9d\x28\x84\xbe\x68\x52\x57\x5b\x89\x68\x82\xd2\x4c\xd5\x40\xd9\xdb\x22\x2a\x0a\x1c\x07\xb4\x0a\xe5\xa4\x8e\x42\x14\xda\x92\x36\x79\x99\x24\x3c\x98\x01\x0b\x9d\x86\x39\xa4\xcf\x69\xa9\x69\xac\x8a\x56\x96\xa1\x94\x89\xbc\xd2\x56\x96\x33\xcd\xa7\x23\x44\x8c\x81\x38\x5d\xc2\xa8\x40\x76\x29\x10\x05\x46\x78\x1c\x2d\x0b\x4c\x4f\xe2\x71\x96\x96\xe8\x22\x4a\xc1\x26\xa9\x58\x64\x24\x61\xb7\xe1\x69\x89\xf3\x49\x34\x96\xce\xa9\x5b\x9c\xc4\xdb\x9c\xb6\xed\x6d\xaa\x99\x1f\x22\xc7\xaf\xad\x5c\xd3\xda\xda\xfc\x09\x97\xcc\x51\x32\xdd\x1f\x03\x74\x31\x23\xe3\x19\x18\x0d\xd0\xe5\x5d\x66\x7c\x1b\x43\x8b\x64\x59\x34\x5f\xbd\x72\x3e\xd0\x30\xbf\x8a\x79\xf8\x0d\x99\x1a\x44\xd8\xd5\xe5\x54\x59\xac\x59\x7e\xbc\x8d\xec\x58\x2d\x37\x6a\x56\xca\x37\x92\x63\xea\x64\x18\xf3\x89\xc3\x80\x59\xa2\xb7\x67\xbe\x9e\x53\x8f\xf7\xb8\xdb\xe2\xfa\xbc\x8a\x35\x39\x87\x61\xef\x29\xb8\xe2\x09\x8b\xef\x3c\xec\xee\x7e\xca\x20\x9c\xe1\xcf\x7d\xb5\x82\x3c\x87\x69\xaf\xd9\x92\x45\xb7\x7b\xd2\xfc\xd9\xb4\x95\xe8\x84\xdf\x56\x59\x40\x4b\x8b\x86\x4e\xb8\xbd\xe3\x9a\x44\xf3\x91\x77\xc2\x9d\xad\xeb\xb3\x60\xfb\xf1\xbd\xe9\xd3\xbd\xe9\xd3\x5f\xdb\xf4\x49\xb3\x75\xe6\x26\x90\x77\x60\xec\x5c\xe1\x6e\x92\x1b\x57\xb2\x07\x59\xc7\x13\xc6\x55\xc3\x0a\x9d\x8d\x26\xdd\xf1\xb3\x2b\x2f\xae\x85\x9e\x63\xd1\x86\x80\xc7\x61\xf1\x34\x10\x78\x7a\xa0\xb7\xc7\xdf\x7c\x83\x5f\x41\xd5\xd6\x2c\x2b\xf4\x8b\x26\xb7\xb9\xc3\xe3\x37\x6f\x5e\x1c\x7e\x38\x3a\x7e\x83\x5e\xbc\x7b\x77\xfc\x2e\x44\x87\x52\xd3\x3a\x66\x55\xb2\xc3\x73\x8c\x51\x77\x03\xd1\xfa\xd0\x46\x77\xe0\xef\x83\x72\x02\xd3\x76\xb4\xf2\x31\x3b\x3b\xaf\x97\x94\x50\x09\xab\xcc\xdf\x84\xb0\x59\x0d\x91\x6d\x7f\xdb\x37\x83\xf5\xcf\x71\x51\x44\x53\x8c\xf6\xd1\xfa\x3a\x7f\xcd\x47\x77\x50\xfe\x7b\xc0\x42\xa4\x3a\x29\x03\x51\xec\x29\xf2\x26\x87\x48\x4e\xd0\xdf\xdf\x1f\xbf\x41\xef\xde\x1e\x52\x40\xde\x25\x4f\x58\x51\xde\x37\xe7\xbd\x96\xc2\x01\xaf\xda\x1c\xad\x9a\xcd\x0f\xec\x66\x58\x1f\xef\xbc\x68\x3b\xa5\x1f\x8e\x5e\xbf\x38\x3e\xf9\x10\x22\x7e\xbf\x4c\xc9\x89\x76\x72\x5e\xa0\x0d\xd4\xa5\xff\x45\xe3\x19\x5d\x9c\x5d\x23\x80\x0b\xf7\xac\xf8\xed\xfd\xc6\x70\xbf\x31\xfc\xf7\x6c\x0c\xf0\xb4\xf1\x8f\x6a\x11\xdb\xfe\xc5\x78\xab\x87\xea\x77\xf8\x5e\x5c\x78\xf6\xa1\x0c\x40\x1e\x84\xf4\xe8\x43\x85\x21\xf2\xf3\x87\xac\xd0\x96\x12\xcc\x6d\x83\xdf\xaf\xfd\xd8\x7c\x21\xcc\x66\x35\xa5\xb5\x9e\xcf\xe2\x33\xa0\x9a\x37\xbf\x45\x96\xf6\x1b\xde\xa9\x6b\x99\x69\x96\x5e\xce\xb3\xa5\x6c\x51\x26\x54\x9c\x94\x04\xd2\xa6\x58\xe0\x0a\xc7\x4c\x04\x00\xd7\xfe\x4e\x50\x22\x9e\x26\x8f\x42\xcf\xb2\x2c\xb9\x86\x78\xa2\x31\xf8\xe5\x66\xbb\x04\x66\x90\xb1\x36\x3b\xf0\x16\x03\xc7\x86\x17\x71\x71\xba\x02\x17\xfd\x74\x55\xf2\xda\x87\x6b\xc6\x34\xe9\x1e\xa9\x28\x84\xe9\x9e\x89\xd5\x6b\x87\x25\xd0\x90\xef\x5e\x3f\x10\x8f\xac\x40\x06\xbc\x26\xb8\x4b\xe0\xbf\x2b\x4c\x4b\xfd\xe5\x95\x6d\x70\xe5\x6d\xac\x8e\x6d\x46\x9f\x31\x73\x8b\x0d\xbe\x82\x2c\x5c\xc7\xca\x63\xb6\x37\x24\x8e\xb7\x82\x6a\xd4\x69\xd5\xd5\xb9\xe2\x61\x94\xe8\x3a\xed\xee\x29\x7a\x6d\x3f\x3a\x58\xa1\x9e\xa1\x95\xdc\xc7\x77\xcd\xb8\xf4\xa2\xf5\xf4\xb0\xd2\x88\x84\x77\xf1\x1b\x0d\xa7\x20\xd3\x34\x2a\x97\xb9\x3d\x1c\x3d\xbd\x6a\x3c\x3a\x4c\xf5\x78\x24\x54\xdd\x80\xc0\x4b\x40\xfb\xfe\xf3\xd7\x04\x82\xbc\x39\x47\x8a\xd2\x58\xaa\x71\xca\x0c\xa2\xf0\x4e\x48\x1a\x25\xca\xc2\x18\xb9\x4f\x0d\x7c\x06\x9c\xfa\xc2\xb6\xb2\x78\xfd\x06\x56\x44\x1e\x3e\xc7\xf9\x65\x39\x63\xea\xe1\xf9\x88\x00\xcf\xc8\x58\x5c\x64\xe8\x1c\x0f\x3e\x50\x8b\x2e\x8f\x03\x0e\xde\x1d\xc7\x81\x9c\x5c\xdd\xf2\x97\xf6\xe2\xee\xde\x4d\x87\x72\x8a\x21\xbd\x60\x34\xf9\xef\x10\x4a\xc4\x75\x6b\xeb\x71\xfb\xc9\x2b\x67\xaf\x48\xb9\x0b\x3f\xe6\xbc\x52\x90\x7b\xaf\xef\xea\x0f\xf9\x3c\x7d\x10\x1d\xbb\x2d\x4f\xd7\x02\x3b\xd4\x32\x74\xf0\x46\xcc\xc3\x47\xf3\xf2\xa7\x04\x02\x29\x59\x37\xef\x1c\x48\x9f\x3f\x4a\x37\x2a\x39\x5d\x26\x49\xc5\x73\x12\xa5\xc6\x43\xc6\xf5\x9b\xd1\x80\xa9\x85\x85\x7a\xab\xa2\x11\x42\xa6\x35\xaa\xf3\x9a\x2b\x76\x3e\x0b\xce\x83\x94\x1e\xdb\xc7\x02\x74\x6e\x5f\x57\xf7\x7d\xdd\x6d\x5d\x1b\xf4\xbd\x81\xf2\x4c\x62\x19\x67\xe9\x38\x2a\x7b\x06\x15\xf4\xab\xbd\xc6\x54\xb2\x3f\xee\x32\xa6\x9a\xfd\xd9\xdb\x2e\xae\xe2\x74\x31\x53\xf8\xbb\xbc\x8c\x73\x07\x6e\xad\x03\x67\x05\x56\x4b\x2c\x9b\x7d\xf0\x00\x34\x0f\x66\x2f\xea\xf7\xeb\x1a\x57\x37\x80\x84\x3b\x74\x76\x13\xe5\x53\x6b\x99\x29\x41\xf2\xa9\x51\x32\xd4\xbf\xb8\x23\x9c\x2d\xcd\xf1\x08\x1f\x20\xbf\xf5\x90\xf5\xda\xef\xa3\xd8\x6c\xa2\x2f\x52\x5e\xd3\xeb\xdb\xee\xef\xd1\x25\xfa\x6b\x46\xd2\x5e\xa7\xe3\x56\x2e\x9f\xa2\x31\x7a\x63\x88\xd2\x2f\x15\x40\x4a\xec\xd1\xf5\xde\x0f\xf4\x1e\xf5\xf7\x90\x1a\x73\x9a\x95\x47\x46\x67\x25\x0e\x3d\xfe\x7d\x14\x70\xcb\xc6\xe1\xb1\x40\x3f\xb0\x5a\xe1\x35\xba\xdb\x8a\xc6\xc3\xb3\x65\xb9\x58\x96\xaf\xb2\xa9\x62\xde\xb1\x2a\x2a\x94\x45\xfc\xf8\xc2\x7c\xbb\x68\x52\x9a\x09\xa6\x78\x37\x8c\xcb\x76\xbd\xc4\x60\xd8\x05\x93\xc1\x5d\x73\x1c\x2f\xc7\x58\x9b\xb0\x68\x3c\x0e\x10\xf7\xff\xa8\x73\x95\x68\x3c\x3e\xe5\xc9\x8c\x43\x52\xc4\xf0\x6f\x41\xeb\x4f\xcd\x79\x1b\x14\x33\x32\x29\x7b\x7d\x14\x3a\x58\x15\x59\x8e\x12\x2b\x1a\x8f\x85\xd6\x8a\xd9\x59\x33\xfa\xc6\x09\x2e\xb1\x18\x87\x72\x4c\x64\xa6\x33\xd2\xba\x01\xe3\xd0\xae\x8e\xf8\x93\x0e\xbe\xc0\xe9\xc6\xcf\xa4\xba\x4a\x9f\x06\x77\x25\x25\x19\x0d\xd7\x8b\x42\x1e\x9f\x09\xb6\x2c\xf4\x47\xf7\x82\xb4\xdd\xec\x05\xa9\xae\xf8\x56\xb5\x79\x9b\x59\x01\x32\xe4\x41\xc3\xed\x82\x76\x97\xac\x6e\x69\x2d\x77\x4b\x8e\x88\xf9\xc7\xf0\xbb\x54\x49\xc8\xba\xc9\x7d\x8b\xc7\x84\xd6\x6b\x32\xef\x4b\xc2\x5a\x52\xfc\x5a\x4e\x9e\x28\xa8\x79\x8a\xad\x62\x7f\xc2\xae\x0f\x5a\x3a\xd5\x00\xce\x0c\xd2\xf5\x01\xe8\x7e\xa3\x14\x2d\x78\x41\x4f\x25\xbf\x67\x6d\x9f\x55\x0e\xc0\xb0\x56\xf0\xde\xc5\x1a\xb8\xd4\x3c\x51\xd5\x5d\xc5\x36\xf9\xa7\xba\xa1\x4b\xaa\x27\x6d\xb4\xf1\xb7\x75\x2e\x39\xf4\xeb\x29\x5f\x33\x1a\xf4\xe8\x02\xeb\x03\x6d\xe8\x31\x36\xd6\x86\x43\xf4\xe1\xf8\xf9\x71\x88\x72\xcc\x0c\xa1\x02\x54\x64\xdc\x64\x45\xde\x70\x29\x1b\x98\x88\x69\xbd\x06\xb4\x1c\x84\xbf\x4f\xf1\x18\x17\x45\x94\x5f\xd2\xc5\x02\x31\x9f\x0b\x4a\x6e\x5d\xf0\x10\x0c\xfe\x99\xd1\x45\x96\x7f\x62\x82\xde\x7c\x99\x94\x64\x91\x68\x91\x0e\xcc\xd8\x22\x7e\xb7\x42\xc3\x87\xc8\x6b\x43\xfd\x8d\x30\xa1\x66\x75\x98\xe6\x03\xa2\x79\xc3\x76\x53\x35\x86\x63\xb6\x6b\x98\x87\x14\x59\x6a\x20\x70\xe4\x73\x1c\xb3\x4e\x3b\x77\xea\xc2\x9e\xf9\x8e\x10\x55\xb0\x16\x2f\x45\x8e\x5d\xa1\xd9\x4f\xee\x47\xc9\x57\x53\x83\xf9\xa1\xb7\x9e\x4a\xbb\x65\x55\x3f\x27\x78\x7b\x4c\x0e\x80\xe7\xf4\xcd\x72\x7c\xd8\x60\x39\x92\xe9\x71\x53\x1a\xb3\x8b\x1e\x8b\x4b\x5e\xac\xc0\xa5\x15\x49\xc5\xe7\x5b\xaa\xf6\x2c\x56\x3f\xdd\x04\xd7\x8c\x57\xc1\x78\x86\x5c\x45\x2f\x48\x05\x01\xb9\x5c\x79\xd8\xb2\xe0\x1d\x0c\x1c\x69\xf6\x9a\xf8\xf3\xc0\x60\x47\xea\x63\x0f\x09\x00\xc1\x85\xe0\xff\x3d\x91\x2a\x59\x0e\xfb\x21\xd3\x35\x46\x23\x7e\x9a\x42\x24\xfe\xcc\x9f\x55\xbb\xdc\x9c\xa1\x41\x79\x04\xaa\xe0\xcf\x15\x1c\xb9\x13\xee\x80\xe7\x20\xdd\x4d\x37\x65\xcc\xdf\xdd\x5f\x93\xde\x5f\x93\xfe\xc5\xaf\x49\xd9\x15\x29\x7f\x6a\xfb\x5f\x11\x7f\xee\x4e\x5d\x74\xc3\x21\xe0\x21\x3a\xcc\xd2\x73\x4c\x59\x51\xc4\x63\x02\xc3\x21\x18\xce\x02\x10\xd8\x57\x84\x4e\xa1\x04\x1c\x25\x45\x86\xa2\x24\xc9\x2e\x0a\x38\x26\x31\x5d\x5d\x31\x58\xa3\x15\x09\xc1\xff\x35\xf9\x8c\xe3\x6b\x96\xb5\xe6\xde\x71\xac\xf1\xdb\xd5\x32\xb3\xa3\x00\x73\xad\xa5\x3c\x6d\xf6\x4c\xed\x28\xba\xba\x12\x21\xc4\x55\x46\x57\xaa\x53\xbb\x7d\x5b\x13\xc0\x0e\x72\x5c\x44\x62\x3a\x5a\xd6\x87\x9e\x50\x31\x1a\x0d\x31\x25\xc4\xf1\x04\xb4\xce\x7d\xa8\x7d\xd3\xa9\x13\x20\x39\xdf\xd7\x5f\x92\x1a\xf7\x47\x22\xc8\x90\x6c\x07\x8e\x5c\x54\xd4\xa4\x9c\x56\x5c\x04\xd9\x16\xa8\x99\x54\xf5\xf3\xc3\x56\x40\x27\xe1\x1c\xe7\x64\x02\xfe\x34\x72\x3c\x8e\x28\xc7\xd1\x42\xc3\x3c\x78\x80\x92\xe8\x3f\x97\x28\xc9\xa2\x18\xc5\x97\x69\x34\x27\x63\x94\xa5\xb8\x80\xd6\xf8\x84\xa8\x86\x78\xb4\xe7\x4c\x2a\x09\x00\x4a\xd8\xb5\x8b\xc6\x1d\x28\x3a\x5b\x53\x5c\x1e\xcb\x13\xb2\xd7\x85\xb9\xa3\x22\xe0\xb8\x16\x20\xd5\x37\x1b\x86\x36\xbf\xf2\x7a\x85\xc9\xc2\x43\x2e\x64\x2f\x73\xcc\x15\x81\x01\x5c\xba\x8d\x19\x15\xb3\x43\xec\x0c\x7f\xd6\xeb\x52\x7a\x4d\x2b\x41\xf3\xd0\xd8\x00\x6a\xe8\x24\x79\x3c\x68\x67\x38\x96\x0e\x5e\x44\x8d\x7e\xca\xe3\x69\xd3\x2a\x38\xd1\xf7\x51\x28\xe8\x9f\x83\x39\xea\x6e\xb6\x66\x64\x13\x94\xf0\x43\xd5\x29\x69\x7d\x0f\x79\xd0\xc5\xd0\xea\xb2\xca\xa7\xe4\xa8\x72\xe9\x97\xca\x2b\xc8\x54\x65\x15\x64\xaa\xd7\xaa\xd7\xa8\xd2\x3f\xe1\x4b\x95\xf1\x09\x5f\xaa\x9c\x39\x49\xdf\x66\x17\x2a\x93\x7d\xab\xfc\x48\x44\x21\x16\x00\x91\x1e\x83\x58\xf4\x14\xae\xa4\xc2\x95\x6e\xaa\x06\xb2\x5c\x5f\xef\xff\x4d\x6a\xe2\xa5\xfa\x42\x60\x14\xca\x92\x83\x38\x66\x0f\x02\xa4\x0e\x2b\x4a\x63\x54\xe0\xb2\x40\xcb\x05\x64\xf0\xf3\x00\x2c\x5a\x52\xe2\x9c\x72\xef\xec\x9c\x8b\x3b\xdc\x81\xe7\x60\x6d\x4d\x7b\x14\xf0\x2a\x9b\x16\x07\xe5\xfb\x32\xca\xcb\x35\x5b\xd1\x57\xe0\x64\x22\x13\x29\xe1\x91\x32\x4b\x25\xef\x34\x0b\x1b\x21\xb1\x70\x32\x71\x9c\xd6\x88\x57\x65\x53\x5c\x32\x0d\x12\x2d\x6c\x3d\x2d\x83\x83\xbd\x1a\x5d\x01\xbd\x12\x4b\x7a\xdd\x5a\xd3\xb4\x95\x81\x6f\x61\x43\xc6\x14\x97\x3d\xeb\x91\x0b\xb7\x27\x74\x8e\x17\xc3\x21\x8a\xb3\xb4\xcb\x9f\x45\xd2\x3e\x72\x6c\x81\xf1\x22\xdc\x36\x8b\x44\x61\xfb\x03\xae\x1f\x06\x83\x01\xfa\x75\xc9\x3c\xdf\xd2\x36\x29\xd3\x73\x0e\xaa\x15\x2f\x01\x6b\x5e\x01\x5e\xdb\x4f\x3e\xad\x25\x2d\x87\xe1\x3f\xdc\xb1\x4c\xef\x89\x90\x99\x53\x36\xbd\x4b\x64\xaf\x55\x4c\xe3\x4b\xa3\x7f\xcd\x8e\x47\xbf\x1e\xc5\x2e\xb2\x24\x61\xe4\xe3\xa7\x56\x4e\x9b\x0a\xcc\xa6\x4b\xb9\x4b\x80\xa2\x34\x7d\x2d\x8d\x61\x0d\x62\xc9\x2a\xc8\x85\xcf\x68\xe6\xcc\xa9\xb0\x74\xa0\xa4\x27\xc6\xea\x9b\x04\xdf\x3b\x21\x1f\x4d\x64\xad\x8f\xd0\x6d\xa9\xe3\x66\x94\xa1\x8c\x85\x61\x68\x4a\x5d\xfc\xd4\x4a\x50\x95\x84\xa2\x90\x4b\x3a\xb7\x42\xcf\xed\x88\xb4\xf2\x20\x0e\x7d\xb2\xbd\x2f\x53\xc6\xf3\x36\x4b\x12\xca\x67\x54\x4f\x18\x0d\x86\xac\x08\x11\x91\xf8\xe1\xac\x37\xa0\x14\x07\x43\x53\xcc\x7f\xc1\x0d\xdc\x4f\x19\xa6\x80\x1c\x8f\xe2\xb3\x40\x5c\x0c\x19\xc9\x81\x22\x46\x9e\xa3\xfb\xed\x61\x9a\x59\xa0\x5f\xba\x3b\x8b\x00\x7d\x0e\x89\xbb\x56\x81\xf2\x26\x45\x2e\x34\x8f\x42\x3e\xe0\x07\x98\xc3\x1c\xc3\x68\xc0\x5e\xfa\xd0\xf3\xa6\x0f\xd8\x1c\x53\x1a\x6b\xb7\x9c\x06\x26\x34\xa5\xda\x2a\xda\xa9\x4a\xf5\x52\xa5\x7e\xc5\xaf\xc7\x32\x3b\xa3\x89\x34\xa8\xd2\x39\x7a\xa5\x31\xa4\x12\x03\x95\xe4\x69\x3d\x13\x06\x38\x07\x01\x66\x82\x06\x29\x66\xdb\x7d\x17\x25\x57\x05\xb7\x68\x91\x19\x7c\x9b\x3d\xac\xca\x57\xac\xce\xc9\xd2\x2f\x77\xe4\xef\xca\x7e\x0f\x52\x7c\xa1\xdf\xed\x38\xef\xde\x05\x63\x24\xb1\xe1\xff\xcd\xcf\x10\x1b\x96\x7a\x6f\x3c\xf2\xf8\xd5\x1a\x8f\x1a\x79\x1f\x92\x8e\xad\xbc\xc4\xea\x94\xf7\xea\x63\x8d\x95\x47\xe7\x2b\x76\xfd\xd2\xe9\xae\x03\x72\x0c\xca\x77\x2a\xe3\x2f\x70\x1a\x83\x0d\x98\x9c\x8f\xa8\x00\x05\x44\x5a\x50\x32\x92\xbe\x49\x54\x45\xd9\x04\x80\x69\x21\x2a\x94\xf4\x99\xd2\x41\xb6\xbe\x4c\xa3\xa2\x20\xd3\x14\xc7\x03\xb7\x8f\xf6\xe4\xfb\x58\xa6\x0f\x91\x52\x04\x1a\x8f\x1a\x70\xe9\x6d\x46\xb7\xaa\xd2\x46\xa2\x6c\x6e\x51\xa2\x0b\x6f\x51\x92\xe3\x28\xbe\x54\xef\xa7\x95\x1c\x57\xdc\x9e\x28\x4c\x39\x53\x08\x97\x4d\xe3\x22\x93\x9e\xd5\x9a\xf4\x49\xb6\xe9\x7a\x88\x52\x8b\x88\x31\x59\x9f\x9b\x42\x2a\xe4\x96\x19\x1f\x1b\x99\xcf\x71\x4c\xa2\x12\x27\x97\x76\xb3\x5c\x3d\xa0\xee\x99\x0d\xe7\xaf\x35\x26\x4e\xd0\x5f\xa8\xbe\x57\xe1\xf9\xc0\xe7\x45\x49\x3f\xaa\x31\xbe\x4c\x77\x07\x36\x18\xed\x8e\xf3\xc2\x89\x1a\x61\xef\xb5\x26\x1b\x62\xb6\x6f\x5a\x3f\x84\x9a\xc2\xe0\x63\xfa\x68\xac\x79\xe2\xd7\x88\xee\x40\x34\x5c\x6b\x77\xa5\xd7\x6d\x07\xa2\x6f\x8b\xcd\xe3\x71\x36\xf6\x6c\x21\xf6\x75\x73\x20\x0d\xac\x18\x9e\x3a\xcf\xb3\x73\xa1\xea\x43\x51\x71\x99\x8e\xe5\xd9\xc4\x27\xb7\xf8\x58\xec\x32\x85\xb7\xbc\x06\x02\x34\x11\xc0\xc2\x96\xc3\xbb\x74\x63\xf1\x55\x6a\x36\xe4\x72\x07\xa3\x53\x2b\xd4\xb7\xef\x31\xbf\xb3\xf1\x7b\xed\x30\x64\x49\x5b\x66\xb6\x36\xbf\x0a\x53\xc3\xe1\x10\x1d\x4d\x14\x67\x24\x85\x7c\xfc\x76\x89\xb9\x3b\x10\x44\x4a\xa4\xbc\x46\xa9\x72\x17\x33\x0c\xd6\x09\x7c\xf4\x7d\xc4\x98\x6a\x81\x48\x69\xb2\x55\xef\x9e\xea\x10\xbb\x5c\x66\xbe\xdd\xc3\x87\x7e\x5e\xa3\x3d\xa1\xfa\xd6\x09\x11\x3b\x3c\xfc\xed\x2b\xfa\x8b\xb1\xc4\xe5\x1c\xdb\x76\x6d\x49\x36\xad\x6a\x17\x59\x8c\xa9\x46\xf4\x87\x5a\x42\xba\x27\x54\xb8\x87\xf3\x07\xd0\x30\x41\x1c\xf9\xdc\x1e\x58\x7b\x3a\x72\xdc\x1e\x71\x39\xf9\xe8\x39\x4b\x08\x39\x8d\xf5\xfa\x03\xb6\x23\x8f\x23\xe1\x40\x0f\xdc\x7c\xe0\x18\xd1\xd5\x3d\xcb\xb3\x34\x5b\x16\xd2\x9b\x1e\xbf\x30\xa7\xbb\xbd\xed\x19\x87\x55\xc3\x25\xd2\xae\xd7\xf2\x14\x9c\x1c\x64\xca\x74\xad\x0d\x01\xb9\x86\x65\xb4\x86\xe6\x39\xbc\xc5\xbc\x5d\x37\xf0\x63\xe7\xea\x90\xe1\xd6\x89\x45\x56\x73\x71\x78\x7d\x16\xec\x6c\xde\x5f\x0d\xde\x5f\x0d\xfe\xb5\xaf\x06\xd5\x03\x4a\x4d\xf9\x7b\x93\x57\x94\x1c\x78\x85\x3b\x3d\x5f\xf4\xb1\xd6\x0f\x2f\xd3\x09\x99\x7a\xe1\x58\x96\x00\x3c\x1a\x45\x56\x54\x11\x32\x8a\x52\x4f\xa4\x10\x50\xef\xb2\x50\x47\xcc\x54\x98\x5d\xeb\x8d\xc8\x94\x3f\xe5\xb7\xec\xf9\x18\xd0\x33\x32\xb5\xd4\xe3\xba\x5d\x1f\x53\x01\x5f\x31\x88\x2b\x09\x7b\x6d\xba\x4d\x52\xe9\xba\x41\x2a\x28\xfe\x2a\xda\x30\xe4\x20\xd6\x3b\xef\xe3\xac\x32\x93\x65\x05\xd8\x9e\xd4\xca\x90\xe2\x6d\x8e\xf9\x85\xa0\xa6\xe7\x37\xea\x1e\xa9\x74\xab\x81\x91\x5e\x82\x1e\x1d\xb8\xff\x75\x74\x75\xe5\xe6\xf1\xd3\xa8\x3f\x13\x47\x79\x42\x68\x51\xad\x6b\xe9\x62\x59\x3e\xc7\x93\x68\x99\x78\xaf\x20\x9a\xfa\x48\xf7\x60\xbb\x1d\x79\xf9\xe9\x8d\x1f\x42\x49\x66\x10\x6b\x2d\x7a\xbc\x1f\x55\xdf\x88\xe8\x5d\xb0\x46\xf1\x5b\x74\xdf\x7e\xe6\xc4\x44\x12\x5a\x4b\xc5\x1c\x1b\x8d\x7a\x2a\xd4\xb2\x3d\x78\x10\xb4\xf5\x12\x7f\xf6\x8c\x9c\xaf\x2a\x36\xd8\x42\x33\x0f\xcc\x26\x28\x32\x9c\xd3\x45\x69\x2c\xee\x22\x0b\xb8\xba\x60\x37\xe4\x74\xdd\xbd\x7c\xf1\x0f\x6b\xb9\x41\x1d\x54\x12\xf6\x2e\x34\xa1\x5c\x37\x9c\xbc\x3a\xf6\xdf\xe2\xb2\x58\xa8\xdf\xdd\x3a\xbd\x17\xb6\x5f\x8c\xdb\x56\xb8\x40\xd3\x2e\x3d\xe1\xf3\xea\xca\xa2\xa1\x83\x31\x38\xfe\xd7\x5c\x6f\xe9\xf0\x1e\x9f\x4f\xa2\x5a\xe8\x13\x77\x84\xe4\xbf\xbc\x33\x25\x1f\xbd\xea\x32\xe3\xa1\x8a\x49\x89\xe6\x64\x3a\x63\xa2\xa2\x74\x9f\xcb\x15\x51\x4e\xcb\x65\xd6\xd8\x6e\x99\x99\xad\x9e\x76\xa7\x51\xf1\x36\x27\x63\xdc\x0d\x10\xfd\x4d\xff\x83\xe9\xa3\x3f\xd2\x2c\x1d\x63\xdf\x93\xbd\x4f\xf8\xb2\xe6\xd1\xde\x27\x7c\xd9\xf6\xd9\x1e\xd4\xe4\xe0\x90\xd5\xb0\xaf\x59\x16\x3c\xc7\x63\x32\x8f\x92\x9e\x0e\x50\x71\x7f\x2c\x2f\xd8\xbf\x36\x11\x6b\xce\x1c\xef\x9a\x96\x7d\x55\xdf\x3d\x49\xdf\x94\x6a\xef\xe9\xf5\xb7\xa4\x57\x2e\xc4\x38\x04\x0b\x17\x98\x22\xfa\x0c\xa7\x56\xaf\x68\xd3\x9a\x4e\x3f\x9b\xe2\x0c\x4f\x5f\x33\x64\x98\x46\xca\x2c\x3f\xf7\xbf\x48\xdd\xdd\xe7\x81\xbe\xfd\xad\x8b\xf3\xb3\xd2\x59\x99\x00\xd2\xcf\x43\x26\xf0\x67\x02\xc8\xd7\x0b\x34\x5d\xc3\x05\x3c\x92\xf2\x57\xef\x40\x79\xdb\xb0\xa1\x84\x7a\xee\xf3\x00\x48\xca\x5f\x08\xb2\x14\xe4\x34\x2a\xfc\x70\xd3\xa8\x30\xa0\x80\x7c\x35\x50\x25\xda\x69\xf9\xaa\x84\x30\xe3\xf2\x82\xeb\xef\x46\xc5\xd9\xf9\xf3\xca\xa4\x24\xe2\x9c\xdc\x84\xa4\x78\xc8\x95\x5a\xca\x92\x11\x80\x56\x21\x2f\xbb\x62\xeb\xda\x51\x0f\xdd\xa2\x42\xb5\x34\xd0\x9b\x0f\xca\x9d\x33\x0f\x94\xa2\x3c\x91\xd9\x82\xfc\x2a\x41\xab\x9b\xac\x20\x44\x19\x51\x64\x39\x5f\x26\x51\x49\xce\xf1\x4f\x51\x71\x52\xc0\xf3\xac\xaa\xaa\x1c\x58\xab\xae\x69\x63\x0d\x53\x59\x4e\x0c\xde\xbc\xfb\x17\x70\x49\x36\xb5\x4d\xdd\x54\x86\x16\x0f\xc5\x51\x26\x81\x46\xc8\xab\x4a\xf2\x3c\xf2\xa4\xb0\x4d\x7a\x23\xde\x52\xab\x05\x00\xb3\xdb\x9e\xe4\x41\xea\xae\xa5\x72\xa8\xb0\x05\x8d\x9b\x35\xe9\x06\x23\x50\x83\xb4\x18\x19\x0e\x91\x74\x78\x03\xae\xdf\xf8\xe9\x15\x21\xd6\x14\x9d\x9f\x57\x64\x4e\x4a\xcf\x14\x9a\x00\x1c\x57\x32\xb1\x62\xde\x8d\x7c\xa3\x4c\x41\xfe\xe3\x63\x82\x2a\xd3\x80\x2e\xc9\x1c\x17\x65\x34\x5f\x54\x16\x91\x10\x6a\x5d\xb1\x8c\xb4\x6a\xe5\x1a\xd9\x55\xd5\xca\xa3\xb1\xd6\x99\x98\x4c\x26\x64\xbc\x4c\xe0\xa1\x82\xcb\x43\x6d\x20\x73\x20\x59\x19\x25\xcf\xdb\x54\x60\x41\xea\x42\x92\xb9\x66\x38\xb8\x5a\xe6\xe6\xca\x71\xb3\x5d\x11\x84\x94\x78\xde\xb7\x9f\x28\x39\xe6\x6a\x00\xe5\xde\x3c\x1a\xeb\xcb\xb7\x99\xb3\x82\x4d\x0b\x6d\xc4\x8e\xd6\x2d\x96\x59\x92\x4d\xbd\xeb\x49\x5f\xdb\xbe\xd5\x94\x64\x53\xcd\xd5\x8a\xb3\xa4\xa0\x5e\x63\x59\xe9\x15\xea\x8b\x4a\xd3\x57\x93\x09\xfd\x6a\xd8\x23\x6c\x08\x97\xd8\x2c\x08\x45\xc3\x34\xa3\xc5\xbe\xe0\x05\xf3\x37\x53\xb1\x1f\xf0\xb6\x92\x6c\x5a\xd7\x86\xcc\xf6\xd7\x2d\xb2\x2d\x79\x14\xd4\xf3\xcd\x67\xa7\x8b\x19\x29\x28\xcb\x5c\x64\x45\x79\x83\xc3\xd3\xdb\xac\xa8\x97\x19\xdc\x30\x2f\xb5\xac\xd5\xad\x54\xa7\x01\xda\x49\x9d\xaf\xd2\xef\xc1\x22\xba\x04\x1b\xf2\x7d\x43\x11\xa2\x67\x69\xaf\x65\x21\xb9\x2c\x93\x3e\x12\xbf\xbc\xf2\xbe\x04\xb3\x4a\x2e\xb2\x8b\x0f\x64\x8e\x79\x69\xfe\x55\x5d\x83\x00\xf7\xd4\x12\xe5\x53\x5c\x6a\xf5\xc0\x37\xda\xb7\x12\x06\x65\xc6\xf9\x80\xe6\xe3\x9c\x6b\x45\xe1\xbe\x21\x5b\x90\xb1\x35\x38\x66\xa4\xad\x18\x8b\x4a\x45\xfb\x3a\x8c\xf7\xcd\x00\x7a\xaa\xc3\x87\xf6\xa3\x00\xad\x05\x1f\x3b\xa1\xd9\xad\xb8\x89\x54\xb4\x03\xd9\x71\x7b\x3c\x2f\x7f\x69\x22\x30\x3f\x35\x99\x0a\xdb\x7a\x7a\xe2\xe4\x04\x43\xc3\x9f\x17\x24\xbf\xf4\x2c\x34\x2d\x97\x8f\x1c\x52\x0a\xe6\x9e\xc2\x0b\x4d\xf3\x74\x58\x9d\xd6\x2c\x50\x45\x69\xf0\x79\x91\xe5\x9f\xde\xe6\xd9\xb9\x77\x77\xb7\x20\xfa\x7b\xbe\xc5\xf0\x2e\xba\x90\xb4\xc4\x52\xbc\x60\x5a\xf5\x07\xc5\x98\x10\x7b\xd5\x88\x32\xfa\xfe\xf7\xf7\x82\x23\x4e\xc2\xa9\xd8\x0a\x8a\xde\x54\x03\xe0\xbf\x15\xe2\x1b\xf9\xd6\xe4\x70\x28\x48\xc8\x24\xec\x49\x96\x24\xd9\x05\xbc\xe5\x10\xaa\x16\xd5\x95\x75\x45\x86\x85\xaf\x71\xc3\xc7\x93\x6c\x45\x1f\xbf\x84\xd0\xbe\xaa\xdf\x49\xf0\xba\x2d\x75\x2b\xc3\x98\xbe\x18\x68\x33\x16\x17\xae\x5d\x11\x1e\x36\x5c\x2c\x47\xc5\x38\x27\x23\x7c\x03\x5e\xfc\x5e\x94\xad\x65\xc8\x4c\xa9\x72\x90\x4f\x8b\x5a\x7e\x8c\x74\x86\xec\xd6\xac\xaf\x22\x55\xa3\xae\x30\x57\xa9\xfc\x31\x45\x5f\x6b\xda\x60\x79\x0e\x64\x2d\xd7\x83\xb9\x92\xad\x58\x1e\xfc\xb5\xaa\x38\x79\x18\x01\xab\xed\x5c\xb3\x71\x9e\xf6\x14\x9d\x3a\x89\x67\x28\x94\xc4\xc4\x28\xa9\x55\x5d\xed\x9e\xde\xd4\x72\xe3\x0a\x46\x5c\xf7\xf2\x46\x75\xc3\xba\xfb\xb0\xd5\x73\xbe\xa0\x1c\xba\xf5\x0e\x61\x77\x75\x29\xbe\x80\x6b\xbb\x9e\x19\xb2\x19\xee\x33\x46\x51\x3a\x20\xc5\xcf\x51\x42\xe2\x1e\x84\x54\xe0\x29\xcf\x49\x8e\xc7\x65\xcf\x77\x99\xc1\x9d\x68\x01\x20\xaf\xb1\xd7\x77\x6e\x4a\x74\x31\x58\x45\xba\x11\x3d\xf0\x54\x6b\xf8\x6b\xf3\x54\xd4\xa2\x0a\xde\x33\xb3\x26\xa6\xbf\xb1\x4d\x43\xb8\x4f\x6d\x01\xdb\x15\xa1\xa7\xd5\xa6\xf3\xfe\x32\x1d\x93\xd4\x2f\xcb\x72\x27\xd6\x42\x92\xe1\x1e\x7c\xc0\x56\x90\xa4\x53\x38\x58\x7a\xcf\xf3\x2e\x98\xe9\x07\x89\xbb\x24\x6a\xa8\x40\x87\x32\xcb\xcf\xc8\x74\x86\x8b\xa6\xf2\x3a\x94\x46\x0b\x3c\xf7\x53\x9a\x5d\xa4\xef\xcb\xa8\xc4\x3e\x0f\x79\x5a\x6e\x75\x03\x7a\x15\x7b\x76\x0d\x8b\x65\x92\xe0\xb8\xa9\x0a\x1d\xaa\x42\xc5\xa0\x5c\x23\x55\x38\x9e\x6f\xba\xf5\x0c\x1b\x21\x02\x55\x4f\x4d\x05\x0d\x25\x8d\x0b\xb1\xd0\x93\xa6\xc1\xfa\x4e\x82\x61\x75\x96\x56\xd2\xe6\x0d\xa1\x3f\x59\x2b\x61\x48\x55\xa1\x27\x4d\x83\x75\x37\x90\xb0\x2a\x83\x95\xaa\xba\x69\x0f\x2b\x73\xf4\x72\x7e\x34\x54\xe7\x55\x94\xb5\x55\x97\x9e\x2a\x6c\x10\xa3\xf7\x86\x82\x28\xf4\xa6\xea\xf0\xfa\xc9\x37\xf4\xa4\xe9\xb0\x16\xf2\x3d\x89\x3a\xb4\xcd\x8b\xc2\x8a\x74\xc6\xc3\x0c\x83\x2c\x76\xe7\xd4\x09\xb7\x9e\x54\xb9\xdf\xa1\x8c\xbc\x13\xee\xec\x5c\x9f\x05\x3b\x5b\xf7\xf6\x59\xf7\xf6\x59\xff\x35\xf6\x59\x9c\xd2\xef\x22\xf6\xc9\x6a\xce\xeb\x5b\x1a\x65\xdd\xa1\x8f\xfb\xf6\x5e\xe9\xa3\x24\x19\x5a\x31\x12\xe1\xa5\x2b\x1f\x88\x0a\xce\xe6\xf8\xaa\x17\xf6\xe0\x6e\x30\xa9\x1a\x1f\xf5\xbe\x68\x52\x1f\xd9\x86\xc7\x7d\xa8\xeb\x61\x54\x57\xf7\x6f\xae\x2a\xe5\xbc\x5f\xaf\x95\x25\xdd\xae\x5a\x08\xc1\x16\x81\x1a\x01\xea\x14\xdf\x3a\x8c\x08\xb3\xca\x41\xf8\xa7\x0e\x71\x27\xfe\xf5\x29\xf7\xb7\x27\xc3\x70\xbd\x08\x86\x00\x87\xca\x13\xa2\x76\x7a\xb0\x4e\x7f\x37\x08\x1e\x2c\xe4\x78\x15\x69\x0d\x5c\x26\x00\x27\x67\xef\x85\xe8\x99\x15\x9c\xe8\xaf\x73\x81\xae\x5d\x87\x75\x01\xad\xb6\xd3\x7a\xf7\x7e\x70\x48\x49\xe4\xe8\x71\xe3\xf8\xeb\x41\x77\x70\xfe\xb1\xd9\xcf\xf9\x6b\x44\xc7\x9e\xc2\x43\x4b\x44\x34\x39\xf8\x14\x2a\x19\x30\x11\xd1\x42\x4d\x9b\x1e\xeb\xb3\xb7\x0c\xcc\x13\x1d\xce\x59\xc2\xca\xbd\x6f\x85\xb3\xcf\x28\x91\xad\x2a\x8b\x99\x61\xdd\x94\xc9\xf6\x2b\x27\xca\x89\x27\xb8\xfa\xf4\xad\x3a\x7b\x66\x18\xc0\x8a\x38\x83\xec\xa0\x68\xd8\xc4\x78\x1c\x89\x1b\x71\xff\xf6\x51\x85\x93\x70\x9f\x8f\x69\x6e\xe3\xaf\x8d\xc8\x08\x28\x58\x63\x85\x52\x11\x05\x43\x60\xf7\x66\xde\xfe\xbd\xc5\x6b\xa7\xf6\x46\x3e\xff\xb9\x8f\xe2\xcd\x00\x3d\x11\x47\xec\x9a\x26\x96\xe9\x22\x1a\x7f\x3a\x66\x8a\x66\xc3\xce\x0a\x92\xf4\xb5\xbe\x6e\x26\xa9\x2e\x98\x1e\x5d\x44\x55\xec\x87\xa4\xae\x7d\xb4\x8d\x9e\x8a\x44\xe1\x46\x19\x09\xb1\x5a\xbd\x71\x96\x8e\x8f\xab\xbc\x28\xeb\xbb\x4a\xc0\x8b\x9b\x33\xca\x0f\xb4\xba\xff\x57\x19\x4c\xeb\x74\xf3\x0c\x85\x3e\x2f\xbf\x87\x10\xb6\x35\xd2\x22\xe5\x0a\x64\xd9\xb1\x78\xa3\x24\xd1\xd7\xef\x60\x30\x10\x4b\xf8\xd0\x2e\x6b\x30\x0d\xa4\x3b\xf8\x28\x21\x1e\xed\x11\x93\xc6\x20\x24\xa7\x00\xa5\x72\x6b\x24\x6b\x08\xcc\x90\xdb\x22\x99\xf9\x93\x82\x77\x5a\x42\x86\x8d\x8c\x97\x34\x51\x1a\x9b\xee\x20\x04\x18\x8b\x59\xcb\x04\x4d\x5a\x07\x8b\x42\x46\xc1\x39\xda\xbc\xb4\xcb\x67\x15\x62\x6e\x36\x51\x2d\xf4\xaa\x2a\xae\xe9\x2a\x41\x4b\x5d\x6b\xb6\xa8\x8f\xbe\x88\x4d\xcf\xb2\x5b\x93\x32\x82\x1e\xd9\x5f\xb9\x5d\x35\xf6\xe1\x9e\xc6\x05\xc0\x75\xac\xb9\xdd\xe9\x45\xf4\xfd\xc6\x2e\xa6\x34\xf6\xcc\xdd\xab\x60\xc4\x02\x4e\xdd\x84\xaf\xfb\x9e\x2d\x2a\xc5\x97\x64\x7c\xb8\x9c\x31\x24\xf0\xaa\x03\xa3\x6b\xee\x23\x25\x28\xa5\x2f\xe1\x9e\xb1\x1e\xb4\x90\x09\xce\xb3\xc2\x36\x0d\x06\xae\xaf\x0e\x97\x07\x68\x9e\x3a\x84\x2d\xba\xf1\x44\x3c\x60\xf7\xb3\x7b\xa6\x63\x52\xd6\x69\x1c\x3b\x1e\x98\xcb\xfc\xd2\x7a\x63\xa5\x81\xc2\xb3\xaa\xea\xf1\x22\xe3\x1d\xd8\x18\x1e\xe2\xf6\x1c\x6f\x1b\x8c\xe2\xf7\x11\xf6\xfa\xf9\xb0\x3b\x2f\x5a\xd7\x34\xc7\xb5\x1b\x45\x1b\x41\xde\xde\x36\xcc\x22\x8d\xbb\x82\xd5\xc2\x9f\x6a\xa9\x35\xae\x19\x41\x52\x1c\x90\x1b\x01\xfe\x80\x36\x41\x8a\x34\x84\x7b\xf3\x0d\xb0\xa5\x6e\x3e\x8c\x52\xf6\xa6\x35\x8d\xb9\x3f\x38\x88\x21\x99\x3e\x12\x27\x03\xf5\x50\xdc\xb1\x46\xf7\x2e\x57\x23\x7e\x94\x2f\xac\xbd\x79\x4d\x77\xbd\x66\x2d\xb3\x0a\xf0\xf6\xce\xba\x71\x51\x92\x79\x54\xe2\x9f\x22\xd0\xc7\x34\x51\x95\x06\xde\x44\x51\x7a\xcd\x77\x41\x4d\x5f\x9f\x3a\xda\xcd\x90\x36\xae\xa6\xd9\xf1\x80\x56\xcd\xcc\x3b\xd1\x0c\x16\x91\x88\x58\xa0\x70\xae\x5a\xe1\xf2\x81\x3f\x24\xb8\xbb\xb3\xda\xd5\x34\xcd\x55\x53\xe0\xf0\x9b\xcd\x53\x2b\xc4\x8b\x0b\x5a\xbe\x32\x6b\xa2\x6c\x7b\xa5\xe6\x5b\x04\x34\xd3\x8b\x0a\x3c\x6b\x64\x5f\x8b\xb0\xdf\x36\xba\x99\xac\xff\x46\x01\xce\x64\xa1\x55\x07\xf9\x35\xa3\x9d\xa9\x90\xe9\x74\x80\xf9\x62\x2c\xfc\xf8\x14\xec\x60\xdc\xc4\x88\x38\x74\xf5\xa5\x79\xcd\xb8\x78\xd9\x3f\x36\x57\x42\x46\x88\x07\x01\xa6\x8b\x29\x46\xc0\x02\x7d\x4e\x5c\x97\x57\x96\x8a\xeb\x29\xea\xe2\x72\xf6\x91\xf6\xb8\x8b\x42\xf6\x61\xed\x24\xdd\xc0\x11\x5e\x42\xe5\x70\x4a\xe6\x49\x27\x59\x7c\x38\x67\x9a\x23\x46\xe8\xb8\xf0\x9d\xc8\x18\x64\x23\x31\x88\xd0\x0c\x55\xdb\x8f\x8c\x78\x52\xbf\xf5\x78\x82\x93\xe8\x13\x5c\x1a\x82\xce\xba\x89\x1d\x65\xea\x00\xdb\x7c\xa9\xcb\x50\xc2\x8f\x81\x4a\xab\xda\x2a\x2c\x74\x0e\xa2\xc5\x22\xb9\xe4\x5e\x55\x5a\x11\x96\xb9\xa7\x70\xf7\x8b\x6b\x76\x33\x34\xf1\x46\x75\x37\xcc\x03\x8f\xe1\xa1\x18\x8f\x0a\xe3\x71\xeb\xf8\x1d\x9e\x09\xfb\x5a\x21\x3c\x44\xba\x5a\xf1\xba\x5b\x99\x4a\x70\x7e\xd8\x54\x18\xae\x02\x74\xa5\x66\xef\xe4\x57\x15\x37\x45\x24\x36\x12\x95\x54\x59\x4c\xed\xd6\xc2\x1d\x0a\xfd\xfc\x53\xc6\x2f\x11\x65\x81\xc0\x49\x3e\x5e\x26\x51\xbe\xbe\xbe\xbe\x5e\x1f\xb5\x44\x50\xd0\x5d\x05\x2e\x71\xfc\x5b\x6c\xdf\xdf\x9f\xde\xdf\x9f\xfe\xb5\xef\x4f\xf9\xe5\x29\x85\x15\xa1\x64\xfc\x0e\xf0\x7f\x37\xd7\xf6\xf6\xdd\x2c\x0b\x74\x43\x0f\xe2\xd6\x3d\x2a\x4b\x13\xb1\x78\x2e\xb2\xfc\x53\x94\x53\x5a\xa6\xbb\xd6\xb2\x30\xc7\x48\x29\x2e\x26\x93\x09\xce\x71\x5a\x22\x9c\x9e\x17\x50\x68\x94\x67\x17\x05\xce\xd7\x60\x77\x67\x1e\xe0\x2e\x48\x1a\x67\x17\xa0\xa5\xd0\x3c\xc4\xa3\x07\x0f\x78\xce\xe0\x1f\xaf\x5f\xbd\x2c\xcb\x05\x77\x78\x29\x38\xa5\x99\x8a\xf6\xfd\xd0\xc0\xf0\x78\x48\x1e\x32\x4d\x33\xca\x0b\x12\x92\x62\xda\x97\x34\x8b\xf1\x9a\xe1\x3f\xc9\xa9\x53\x0e\xfe\xf3\x3c\xa1\xa3\xe3\x1b\x5a\xb7\xdf\xb6\x99\x6b\x86\xcd\x7f\xbc\x7c\xb7\x6d\x54\x37\xcb\xb7\xbb\xfd\xca\x52\x42\x62\xa0\x2d\xbc\x15\x08\x75\xef\x9e\x41\x6e\xa2\x22\x3d\xb8\x10\x64\xfe\x80\x69\x2f\xe5\x4d\xb3\x51\x5e\xdf\xea\x67\x59\x51\x06\xa8\x24\x73\x9c\x29\x7d\x20\x6c\x1b\x34\x07\xed\x23\xf8\xef\xea\x0a\x75\x39\x8d\x27\xd9\x38\x4a\x68\x62\xf8\xe4\x9b\xdd\x6f\xba\x9a\x16\x92\x57\x42\x77\x3d\xfe\xeb\xea\x0a\x6d\x36\x0a\x3e\x8b\x1c\x2f\x20\x52\x13\xbe\xb0\xd0\x6e\xc9\x3d\x1c\xf0\x9d\x76\x0e\xd1\x62\x94\xe3\x28\xbd\x86\x08\xb0\x2c\x48\x39\x9b\x37\x85\x29\xee\x7e\x4e\x3b\xac\x99\x6d\x19\x1e\x4f\x74\x6c\x69\x32\x93\xd9\x01\xf3\x9e\x8e\x56\xaf\x8b\x4b\xbc\x07\x9a\xae\xc3\x00\x41\x48\x09\x48\x30\xf0\x97\xef\xb6\x55\x58\x44\x21\x2d\x69\x18\xd5\x10\xcc\xb7\x7d\xc3\xdb\x97\x55\x9b\x31\xb4\x9e\x6d\x06\xc8\x2a\xcf\x16\x38\xed\x75\xdf\x1e\xbf\xff\xd0\x0d\xd4\x8c\x07\x0c\x53\xf2\x26\x86\xc1\x2a\x2f\xb3\x2f\x71\x14\xe3\xbc\xd7\xa5\x72\x23\x4e\xcb\x47\xf4\x00\xda\x0d\xba\x54\x20\x26\x63\xd8\xca\x86\xbf\x16\x4a\x1b\x27\xaf\x72\x38\x36\x1a\x68\x81\x85\x09\xb8\x4c\xc7\xda\x69\xd3\x56\xb1\xfa\x2e\x5d\x17\xda\xd5\xad\x3f\x76\x6b\xdd\xbc\x16\x76\x20\x2f\xa1\x64\x72\xe7\x53\x4c\x85\x49\x0a\x3c\x18\xa8\xb4\x85\xa7\x07\x9b\x2c\xc1\x83\x24\x9b\xf6\xe0\x15\x00\x8b\xce\x40\x26\x97\xb2\x6a\x71\x80\x34\xf5\xe4\x0a\xdf\x69\x5c\x53\x12\x66\x93\x29\xc6\x5d\x67\xb2\x4c\x85\xca\x38\xf4\xe0\x88\x59\xeb\x1e\x66\x69\x8a\xb9\x2d\xb6\x98\x69\xf7\x72\x41\xde\xd9\x89\x6e\x08\x97\xee\x1f\xf0\xe7\xb2\xa2\xbf\xbc\x84\xf6\xd6\x81\x9b\xf8\x5a\xbd\x6c\xea\xe1\x3b\xde\x54\xcf\xd7\x76\xa3\x1d\x6b\xa5\x2e\x07\x08\x2a\x6a\xa0\xa8\x03\xc9\x1b\x6a\xc8\x8a\x67\xfd\x28\x2f\xfd\xa4\xf6\xa1\xcc\xc9\x74\x8a\x73\x16\x0c\x84\x92\x12\x48\x0a\xd2\x83\x21\x45\x46\x13\xf5\x41\x0f\x7c\x24\x68\x06\xf4\x6c\x47\x8c\x10\x16\x77\x25\x5a\xb4\x18\x43\x0a\xde\x69\x8b\x32\x2a\xf1\x78\x16\xa5\x86\xb7\xf7\x9e\x7d\x67\xa4\xe6\x2b\x8a\x2f\xc1\xec\x18\xae\x6a\x77\xe9\xb6\x6d\xf3\xb1\x75\x5f\x0c\xcf\x16\x94\x67\x83\x8b\xab\x1f\x2d\x56\x8c\xa4\x2d\xe7\xde\xa9\x15\x9d\x8a\x3f\x2f\xbd\x8a\x3f\x79\xe3\xb4\x32\xe5\xca\xea\xcd\xce\xda\x97\x54\x4e\x97\x4c\xcf\xeb\x6a\x82\xd4\xc6\xe0\x99\x17\xb3\xd6\x62\xa0\x16\xff\x07\x56\xac\xa7\xef\x26\x92\x9f\x7c\x35\x86\x64\xf7\xa7\x8e\x27\x39\x01\x11\xe8\xaa\x56\x17\xe2\xc9\x25\x5d\x6d\xec\x2d\x10\x2c\x6d\xba\xa6\x2a\x56\x36\x29\x78\x0b\xd8\xdc\x17\xa4\xb0\x20\x94\x98\xb6\xd0\x40\x0f\x0c\x69\xb7\x44\x93\x88\x24\x38\x1e\xa0\x63\x7a\x30\xbb\x20\xf4\xb0\x11\x41\xf4\xa0\xea\xb5\xac\xb5\xe9\x9b\x1b\x13\xb7\x52\x71\xd1\xb3\xde\x42\xc7\x21\xfa\x4e\xfe\x05\x46\x1e\xdd\x5b\xf3\xc5\x38\x44\xdd\xed\xc1\x66\xd7\xcc\x13\xaa\xc7\x6e\x8a\xcb\x8f\x09\x29\x4a\x9c\x92\x74\x6a\x01\x49\xf5\xe1\x99\x22\x32\xcf\x85\xb4\x8a\xa4\xef\x5b\x10\xc2\xa8\x8b\xa2\x43\x9f\x30\x47\x7d\xa0\xa3\x69\x4f\xc4\xca\x63\x64\xd0\x09\xb7\x1f\x07\x1d\x2a\xfe\x76\xc2\x27\xf4\x97\x21\x57\x77\xc2\xad\x6f\xaf\xcf\x82\x9d\x9d\x7b\xb5\xc0\xbd\x5a\xe0\x2f\xae\x16\x50\x76\xd5\xf0\x32\xec\x8e\x6c\xaa\xe5\x3b\x11\xfd\xb4\x39\x22\x53\xe6\x62\x62\xf0\x2b\x3b\xbd\xb3\x7b\x91\xf8\x15\x9e\x98\xe7\x19\x19\x3f\xee\x52\x7b\xcd\x64\xec\xd4\x0c\x82\xad\xfe\x8b\x19\xed\x7d\xcf\x34\xd8\xfa\x9e\x15\x46\x0f\xd1\xb6\xfb\x1c\x0a\x2c\x00\xbb\x68\x43\x4a\x71\xc8\xf6\xed\xe7\x11\xef\xde\xf2\x93\x62\x94\xa2\xa3\x67\x07\x6f\xf8\x24\xc7\xe8\xbb\x6f\xd1\x38\x9b\x2f\x96\x3c\x9c\xc4\xe8\x12\xcd\xb3\x73\x92\x4e\xb5\x40\x49\xbb\x68\x3c\x8b\x72\xd8\x37\xd8\x4d\x6d\xcc\x4c\xab\x84\xbd\xb0\x80\x4e\x30\xb3\x1a\x2f\x33\xda\x20\xc3\x55\x81\x7a\x07\x68\x1f\x6d\x6d\x06\xe8\x19\xfd\x7f\x2b\x40\x83\xc1\x20\x40\xff\x87\xf6\xd1\xce\x37\x7d\x7a\x62\x42\xc5\x02\x8f\xc9\x84\xb0\x85\x74\xf4\xfe\x78\x6b\xe7\xf1\xd6\x63\xdb\xe4\x8c\x14\x19\xa4\xf3\x71\xb8\xfe\x39\xaf\xd9\xc3\x43\xda\x11\x3a\x40\xf3\xaa\x4d\xbf\x69\xe6\x12\x5f\x2c\xc0\xf8\x8b\x55\xb3\x7e\x33\x52\xfc\x28\x4a\xf5\x79\xa4\x23\xea\x1e\x74\x07\x14\x2d\x87\x59\x8c\x0f\xca\xde\xa6\xa6\xc5\xa6\x63\xeb\xfe\x9f\x93\xcd\x18\x20\x7b\x1c\x09\xc4\x5a\x66\x27\x8b\x05\xce\x0f\xa3\x42\xa9\xb6\xb5\xec\x62\x39\x2a\xca\xbc\xb7\xdb\x17\xcf\x1e\x79\xc2\x66\xb0\x6b\xdd\xa0\xb1\xdc\x45\x42\xca\x5e\xb7\xdb\x37\x9f\x8f\xa6\x7d\xd3\xda\x6a\x9c\xc5\x74\x70\xa9\xaf\xf3\x48\x38\x98\xa7\x30\x3f\xec\xa3\x03\x2a\x87\xc2\xc7\xf7\xfb\xe8\xff\xfa\x8e\xff\x74\xcf\xcc\xf2\x89\x35\x20\xa5\x7b\xce\x18\xa3\x47\xe8\x00\x6d\xa0\xad\x4d\x4d\x4c\xf3\xf9\x14\x17\xf1\x0c\x1d\x69\xae\x3f\xf8\x35\x23\x29\x1d\xa6\x6d\xb9\x38\x5e\x82\xef\x52\x98\xe2\xd7\xc7\xcf\x29\x61\x6f\x6d\x0a\xa6\xc4\x2d\xfe\x80\xf2\x3d\x14\xf7\xed\xe6\xe3\x5d\x9b\xe0\xe6\x59\xfc\xdd\xb7\x5b\x9b\x55\x84\x66\xd2\x97\xf2\x08\xcb\xa8\x89\x17\xae\xa5\xa2\x1c\xcf\x23\x92\x32\x9d\x12\xcd\x53\xb2\x06\xf7\xaf\x62\xb2\x07\x0e\xac\x4c\x95\xb7\xfb\x96\xe7\x18\x60\x56\x02\x4c\x5a\xc0\x7e\x67\x48\x28\xaa\x49\x10\xe4\x8f\xd2\x92\x39\xa5\x09\xd0\xd6\x66\x1f\xfd\xff\x29\xd6\x36\x9c\x5a\x98\x5f\x1a\xd6\xb0\xdf\x83\x83\xa8\x4b\x96\x54\xf5\x19\xf3\xd4\xfc\x10\x84\x59\x9d\xc3\x3a\x60\x4a\x25\x76\xc1\x0e\x09\xe3\x2c\xcf\x69\x0a\x63\x9f\x62\xbe\xfc\x93\x33\xd4\xfd\x06\xfb\x27\x81\x5b\x46\xab\x25\xe7\x76\xd5\x89\x5c\xd9\xd4\x4f\x0c\x01\x5c\x96\x73\xf1\x3c\xc2\x22\x2a\x0a\x73\x20\x73\x9c\xbe\x47\x5a\x96\x10\xb9\xe9\x10\xae\x25\x5b\xd3\x35\x6d\x34\x67\xa0\xd5\xd8\xf4\x30\x3b\x2a\x9e\x89\x87\xd9\xca\x83\x91\x88\x48\x88\xb6\x1e\x6b\x2c\x6c\x14\x15\x78\xe7\x31\xda\x87\x32\xea\x61\xfd\xce\x63\xc3\x24\x20\x8e\x41\x54\xe7\x7b\x60\x8f\x15\x0a\xd0\xd6\x37\xa6\x02\x4b\xf6\xf3\xd9\x28\x4a\x7b\xac\x98\xc9\xfc\xac\xc5\xcc\xfc\x17\xe8\x0b\xf7\x19\x1d\x7a\x99\x19\xbb\x17\x9d\x3e\x04\xce\x2c\xf3\x4b\xb1\xa2\x99\x16\x0d\xec\x77\xdf\x32\x3f\xfa\x69\x56\x72\xa1\xec\x7b\xf2\x43\x67\x0a\x12\x09\x73\x2b\x33\x51\x48\x2d\x66\x11\x93\xd6\x60\x7f\xfb\x3c\x4e\x96\x05\x39\x97\x51\xf9\xc8\x88\x24\xa4\x94\x02\xce\x28\x4a\x3f\x0d\x47\x79\x94\x8e\x67\xa8\xc0\xf9\x39\x19\x8b\x0d\x30\x62\xbe\x35\x3b\xdf\x0f\xc9\x0f\x03\x9b\x86\xa4\x0b\xfe\x42\xec\x42\x13\x9c\xd3\x6d\x28\x4a\xa6\x59\x4e\xca\xd9\x1c\xc5\x98\xbd\x6a\x05\xb6\xc4\xe5\x1f\x9c\x0e\x2e\xc8\x27\xb2\xc0\x31\x89\x40\x08\xa2\x5f\xc3\xa3\xb4\xc4\x79\x1a\xb1\xd7\x12\x1f\x9f\x45\xe9\xa7\x8f\xdc\xb1\xe7\x47\x36\xaf\xff\xbf\x9f\xf8\x48\xd3\xe9\x47\x3a\xc4\x8f\x10\x61\xe8\x63\x4c\xa6\xc4\x79\xbd\x21\xa6\xc6\x47\x91\x23\xb1\xa7\x8a\x19\x18\x8b\xc9\xc9\x3c\xdb\x6c\x0b\x5a\x7d\x66\xaf\xc8\x91\xc5\x16\xf9\x8c\x1e\xb2\x7d\xaa\xfb\x8f\x17\xdd\xbd\x35\x2f\xcf\xe4\x3c\xb6\x67\xed\xdc\x3d\xbd\x82\x0d\xd4\xdd\x04\x51\x09\x5a\xd1\xcd\x5f\x28\x3a\x9e\x53\x6c\xa0\x7d\xd4\x63\xe2\x54\xef\xbb\x27\xe8\x91\x6a\xa2\x2f\x9e\x11\x3c\xda\xb6\xf6\x5b\xe9\xda\xc0\x6c\x4a\xab\x93\x37\xd8\xa0\x60\xe3\x4c\x44\xc3\x15\x10\x36\x0b\x4a\x4c\xd2\xa2\x24\xe5\xb2\x14\xee\x69\x49\x8c\xd3\x92\x6e\x5a\xb6\x0b\x73\x56\xcb\x51\x1a\x83\xf3\x84\xea\x67\x35\x45\x20\x64\x59\xf9\xae\x06\x02\x4d\x75\xb4\x96\x3a\xd0\x54\x47\xb5\xd5\x59\x85\x17\x99\x3d\xa9\x0a\x9b\x5b\xc9\x19\xba\x2f\x3e\xbc\xa4\xf3\x20\x5e\xbb\xe8\x18\xd0\x52\x65\xdf\xfa\x16\xbf\xce\xea\xf8\xb5\x08\xb0\xc5\x90\xcb\x23\xfe\x92\x02\x31\x87\x0c\x1a\x1f\x77\xe4\x4e\x70\x53\x51\x29\x6f\xca\xbd\xc8\xa3\x24\x11\xca\x11\x52\xaa\x96\xa4\xd0\x79\xa4\x39\xc1\xa8\x95\x13\x88\xee\x4c\x83\x30\xb2\xd2\x85\x3f\xe5\x49\xa3\xf1\x8a\x40\x62\x01\xba\x0e\xec\x33\xcf\xeb\xc7\xac\xfc\xdb\x7b\x47\x15\xa0\xcc\xa3\xe1\x81\xb1\xe9\x9a\x1d\x77\x94\x16\x25\x0c\xff\xfd\x8f\x17\xa7\x9b\x8f\xbe\x3b\xfb\xb2\x7d\xdd\x7b\xf1\xe1\x25\xfd\x7d\xf0\xe8\xff\xce\xbe\x6c\xed\x5c\x5f\xc9\x8f\x9d\xcd\x60\x67\xeb\xba\xff\x3f\xc3\x41\x09\xca\x5a\xb9\x81\xf7\xd1\x83\x07\x52\xca\xa9\x62\x0c\x1a\x38\x73\x95\xb2\xb5\x22\xc2\xb8\x03\x42\x38\xfd\x7b\xd1\xf6\x5c\x2d\xc1\xbb\xc1\xdb\x73\x77\x25\x59\x88\x53\x83\xd2\x1f\xfb\xec\xec\x42\xec\x70\x7f\xde\x37\x37\x1c\xf6\x04\x91\xb4\x62\xe0\x06\xf7\xb9\x9b\xa1\x7b\xd9\x48\xab\xc1\x6f\x37\xdf\x9b\x4e\x71\xc9\x45\x4a\x3a\xd2\x62\x39\xa7\x80\x27\x05\x3f\x3e\xcc\xb3\xf8\xd1\x77\xdf\x3e\xda\xda\x94\xd9\x70\xc6\x85\xde\x8d\xb3\x04\xf5\x8e\xde\x1f\x0f\x8f\x5e\x1c\x22\x7a\x6e\x08\xb7\x37\x37\x77\xfa\x36\x4f\xd6\xaa\x75\x4f\xa1\x5a\xae\x33\x70\x91\xd7\x72\xd8\xfc\x4c\xb8\x1d\xa0\xed\x76\xb6\xab\x3a\x53\x35\xb6\x14\x84\xa7\x03\xf4\x8f\x77\x2f\x7e\x72\x9c\x44\xc9\x02\xfe\xd1\x54\xd6\xe8\x4e\xaa\x06\xd9\x34\x3c\x45\x00\x3d\x70\x68\xe4\x0c\xf9\xdb\x00\xed\xf6\x51\x88\xba\xdd\x56\xe3\x1e\x27\x04\x1e\x96\xc9\x0e\x82\xf2\x89\xa4\xf6\xf8\x28\x16\x7e\x3a\xf8\xf9\xf8\xc7\x7f\x1e\xbf\xfb\x5f\x7b\x56\xa1\x8e\x8a\x39\xb5\xeb\xf7\x4e\x2e\x03\xba\xf5\xd8\xb7\xb6\x56\x1f\x39\x5f\x4d\xfe\x73\x89\x7b\xf0\x70\x87\xe6\x54\xe0\x0c\x2f\xf2\x9c\x43\xf4\xd7\x93\x7c\x70\x3e\x2f\x4f\xc6\xa1\xc3\x1d\xf0\xae\x76\x88\xad\x3c\xca\x88\xf3\x87\x3c\xa5\x18\x27\x54\x76\x46\x31\xcf\x33\x5b\x8f\xfb\x01\xda\xde\x94\x97\x30\x86\x94\x27\xd0\x6b\x0d\x52\x14\x6e\xb7\x40\x2b\x5c\x05\x1d\x41\x16\x53\xea\xeb\x7a\xc5\x4e\x68\x7e\x5e\x9f\x05\x3b\xbb\xf7\x6a\xfc\x7b\x35\xfe\x5f\x5c\x8d\xcf\x55\xf8\x8b\x71\xbd\x71\xdf\x2d\xcc\xf1\x3a\xcb\x02\x83\xb0\x3e\x2e\x3b\x7b\x2b\x05\xa9\x6a\xb0\xe1\x63\x7a\xa6\xc5\xd8\x6b\x21\xb6\x88\xca\x59\x80\x52\x6c\x58\x83\x7f\x04\xcd\x85\xf3\x10\x55\x5c\x7d\xeb\x81\x71\x85\xa3\x02\x66\xaa\x10\x81\xd7\x12\xfa\x1f\x4b\x55\x59\x63\x79\x1f\x0c\x5c\xb1\x14\x09\xbd\x2f\x14\x3a\x54\xe5\xa5\xd7\x3f\xab\xd8\x20\x4b\x7b\x5d\x18\x55\x57\x0f\x24\xd9\x37\xec\xa9\xc1\x16\x02\xb3\xb7\x85\x47\x6f\x0f\x91\xba\x85\x66\x2f\x0e\xbb\x01\xd2\xc3\xa3\x7f\x64\x6c\x90\xdf\x95\xf7\x6c\xbf\x83\xde\x1e\xa4\xb1\xde\xbe\xd6\x7c\x65\x65\x68\x4d\xbe\x39\x78\x75\xf4\xfe\xc3\x8b\x37\xb0\x82\x0e\x8f\xdf\xbc\x79\x71\xf8\xe1\xe8\xf8\x0d\x7a\xf7\xe2\xfd\xdb\xe3\x37\xef\x5f\xbc\xaf\x6c\x35\x8e\xca\x48\x6f\x96\x7e\xeb\x9b\xd3\xf0\x21\x37\x2f\x9c\x47\x9f\xc7\xd9\x7c\x91\xe0\xcf\xa4\xbc\x0c\xd1\x63\xa0\x2c\xab\x87\xa0\x0b\x95\x76\x0d\xb4\x2a\xcd\x31\xa5\x27\xa6\x08\xb7\x5b\xf8\xb2\xe6\x58\x6a\x90\xd8\x6f\xa6\xc1\x83\x23\x03\x7f\x89\xd1\xc5\x8c\x8c\x67\x68\x1e\x95\xe3\x19\x17\x5f\xd9\x26\x44\x19\x5a\x6c\xde\x8d\xbb\x2e\xfc\xa1\x69\x7f\x94\x60\xb8\x8e\x72\x7a\x0b\x46\x0b\xfe\x18\x9e\x64\xd2\xfb\xe8\x27\xe4\x53\x78\x2b\x47\xe2\x33\xd7\x23\xb9\x2c\x4c\xc7\xca\xc1\xf6\x1c\x28\x27\xc0\x7e\x55\x1c\x52\xa8\x86\xf7\xdd\xae\xe8\xda\xc1\xe2\x84\xe4\xd8\xf0\x10\x60\xa3\xab\x6a\x3c\x74\x28\x9e\xd6\x6b\xc0\x55\x50\x54\xd7\x6e\x86\xfe\xc5\x38\xc1\x25\xae\xab\xc1\x1e\x8c\x8d\x1b\xfd\x55\xf6\x2f\x74\xd7\x02\x42\xe4\x04\xc1\xea\x03\xe5\x0e\xb3\xea\x4a\x99\x27\x18\x94\x31\x57\xb2\xa4\x1c\xac\xad\x09\x61\xd0\x24\xe1\x35\x5b\xed\x01\x2f\x34\xa9\xf0\xa7\x78\x9e\x26\x1e\x99\x85\x75\x43\x0e\x7d\x55\xd9\x6c\x30\xb0\xe4\xb5\x9f\x99\xd7\x5a\xe5\x8b\x57\x2c\xf1\xe7\x2f\x1e\x1d\xbe\x3c\x79\xf3\xbf\x2f\xde\xc9\x7a\x62\x3c\x9e\x2d\xd3\x4f\x38\xe6\xaf\x4c\xd8\x0b\x52\xfe\x37\xc8\xf1\x22\x89\xc6\xb8\x37\xfc\xd7\xf5\xe9\xbf\xd2\x7f\xe5\x67\x4f\xff\xf5\x65\x38\x0d\xba\xd7\x57\x8f\x1e\x5d\x7d\xe9\xf6\xc1\xfd\xee\x17\x2f\xfc\xbf\xce\x44\x89\x53\x5e\xe6\x8c\x16\x3a\x15\xa5\xce\x4e\xfd\xe5\xec\x52\x46\xa1\x8a\x32\xaa\x2d\xad\x25\xd9\x90\x56\x86\x5f\xf3\xd1\xec\xae\xe0\xa4\x06\x06\xdc\x35\x0b\x88\xd7\xf8\xcb\x70\x08\x77\xa0\x98\xbb\xc7\x00\xcf\x1b\x50\xc1\x9a\x43\xfa\x34\xef\x90\x66\x99\x2b\x97\xfb\xa1\xb1\x60\xd0\x06\x62\xef\x61\x0d\x51\x5d\xde\x59\x5b\x9c\xcc\x35\x36\xf3\x19\x9a\x41\xdf\xb5\x52\x86\x49\xcd\x9a\xbb\xf8\x54\x67\xf6\xed\xce\x20\x23\xb6\x3a\x37\x02\x03\xdf\x63\xe9\x18\x27\xe0\x2c\x59\x3c\xea\x34\xca\x8c\x13\x1c\xe5\xc2\xfa\xcb\x6a\x85\x27\x5b\x0b\xda\x0f\x04\xbe\x1b\x4a\x51\x91\x6f\x8f\x33\xcb\xdb\x7b\x9d\xfe\x57\x6b\x05\xca\x71\xa6\xc3\x5f\x07\x68\x6b\x73\x73\x13\x3d\x64\x97\x33\x9e\xbb\x56\xaf\x23\x08\x78\xc7\x07\xd8\x11\xf8\xa2\x1c\xa4\xc0\x9c\x5e\x58\x5c\x12\xfe\xce\x6f\x75\x54\xb9\x33\x66\x91\x08\x04\xdc\xe1\x36\xa0\x4e\x87\x19\x8b\x60\xc1\xb4\x4d\xb3\x59\x4b\x5b\xaf\x83\x73\x67\x40\x94\x47\xfe\xc4\xb7\xd0\x28\x8e\x0b\x3d\xca\x32\xb7\x72\x70\xa5\x31\xa6\x1e\x0e\xd6\xd8\x86\x2b\x0e\x06\xfc\xac\x4d\x98\x7f\x7a\xce\xf5\xe6\x22\x64\xbc\xc1\x7d\x8f\x62\x56\x2a\xca\x73\x72\x8e\x75\x86\x1b\xc5\x72\xf6\x44\x7b\x35\x1c\xd6\x03\x6d\xb8\xa7\xaf\xb3\x7e\x25\xec\xc2\xee\x92\x6f\xb5\xe8\xea\x4a\x7c\x9d\x6e\x9e\xc9\x2d\x13\xae\xb0\x59\xdf\x14\x34\x4f\x30\x4b\xb0\x44\x5d\xa2\xf3\x6e\x5e\x68\x5f\xf6\xa6\x4e\xe2\xa5\xa0\x03\xd9\xb0\xa8\x5b\xec\x6a\x62\x1d\xe9\x2b\x95\xc5\x62\xe7\x66\x29\x4c\x2c\x87\xd3\x17\x68\xdc\xe9\xfe\x1e\x6b\x68\xe6\x44\x5c\x83\xda\x1a\xdb\xd0\x49\x96\xf7\x28\x5e\x3e\xe1\x4b\x76\x52\xf4\x0d\xc0\x34\xf0\xed\xf9\x81\x06\xb3\xa8\x38\xbe\x48\xdf\x42\xd4\xa1\xf2\x12\xa2\xca\xf5\xed\xa0\xe2\x5e\xf4\x7c\xc2\x97\x67\xd5\x96\xa0\xdd\x2c\x45\x47\x6f\x0f\xbb\x76\x00\x74\x2e\x5b\xd4\xd4\xe9\x98\x59\xa8\x65\x72\x28\x54\xc1\x20\x27\x31\x1f\xd0\x48\x3b\x6e\x90\x02\x15\x25\x61\x8e\xe6\x49\xac\x11\xb5\x6e\x42\x5a\x89\xf0\x06\x9b\x4f\xf7\xb4\x24\xe4\x00\xba\x7b\xe4\x98\xf7\x23\x60\x54\x60\xf6\x6a\x9a\xa5\x98\x6b\x9e\x7a\xeb\x1f\x6d\xb1\xff\x22\x27\x25\xf8\x4f\xb1\xb8\x91\x06\x62\x1d\xa1\x3e\xba\x67\x28\xce\x60\xd6\xd7\xab\x6a\xe7\x0a\x24\xef\xd0\xeb\x1e\x4e\xac\xe9\xf4\x63\xd5\x8b\xdf\x1b\x4f\x61\xf4\x4d\x76\xcf\xe0\xdc\x2b\xa0\x48\xa0\xa9\x19\x4b\xc8\x73\x84\x6a\x3c\x6b\x8a\x5e\xc6\xda\x33\x60\xdf\xa8\x9a\xde\x7b\xa0\x55\xc5\x06\x49\xd5\x55\x96\xe9\x2d\xf6\x51\x64\xfd\xf9\xf6\x49\xcb\xec\x8e\x6b\x13\xad\x33\x8a\xe3\x9e\xe7\x9f\xd9\x12\x2c\xb2\xd5\x2b\xb4\x4e\x77\xc3\x66\xb7\x1b\xdd\x0e\x2a\x74\x23\xee\x81\x6e\xd3\xad\xf8\x20\xbc\x02\xcb\x4a\x54\x2c\x17\x8b\x2c\x2f\x41\xb7\xc6\x6e\x6a\xdf\x1e\x22\xa9\x55\xe9\x1a\x36\xe2\xd5\x84\xb9\xc2\x9b\x8a\xd5\x17\x63\x33\x95\xad\x44\x61\xde\x63\x3d\xd0\x54\x83\xd1\xbd\x74\xb4\x68\xef\xa6\x95\xde\x6f\x5c\x3d\xae\xc2\xa0\xe3\x03\xdb\x78\xb4\xad\xec\xb6\xaf\xcf\x82\x9d\x6f\xee\x55\xba\xf7\x2a\xdd\xff\x0a\x95\x2e\x7f\x73\x71\xab\xb7\xda\x07\x51\x9e\xa5\xe8\x7f\x97\xf3\xe8\x9c\x14\xe8\xfb\x88\x7e\xfe\xed\x13\xfb\x1c\xcc\xb1\x57\xdd\x3b\x1c\xa2\xa3\x94\x94\x24\x4a\xc8\x7f\x30\xfa\x3b\xeb\x05\x25\xd4\x08\x15\x60\x89\x25\x0c\x6e\x60\xa0\x74\xa9\x1a\x5e\xa6\x07\xa0\xd5\x15\xc5\x44\x68\x07\x1e\x71\xea\x28\x0e\xd1\x66\xd3\xcd\x1b\xb3\xf6\xa0\xc3\xb7\x3d\xe9\x7a\xcd\x4c\xbc\x1e\x74\xd5\x7b\x39\x11\xdc\x6a\x22\x10\x0a\x2d\x29\x83\x1e\x8f\xdf\x5d\xf6\x58\x25\xd0\x54\x3d\x13\x51\x8d\xc8\x12\xee\x76\xbd\x6e\x89\xb4\x11\xd0\xf6\x9c\xde\x0f\xd7\x38\x7a\x2a\xbc\xef\xb2\xb6\x02\xde\x98\xe1\x44\x95\x65\xf5\xab\x54\xcb\xa2\x49\xc7\x98\x47\x9a\xed\xae\x77\xb5\x10\x3f\x51\x7c\x4e\xcf\xa8\x62\x76\xd0\xd1\x73\xc8\x11\xbd\x93\x93\xb6\xb1\x51\xe5\x77\xa8\xea\x61\x10\x89\x43\xb7\x1a\x95\x2d\xde\x0c\xf1\x91\xca\x74\xf1\x4c\x88\xfd\x4f\x0f\x4c\xfc\xc1\x50\xb3\x43\x21\x69\x78\x21\x70\x20\x0f\x8f\xc2\x80\xc8\x6f\xaa\x23\x95\x75\x4d\xa1\xce\x3c\xaf\xbd\xad\x06\xfc\xe6\x19\x02\x0d\x56\x7b\x56\x58\x5e\x96\x68\x5d\x86\x32\x1f\x3f\x9a\xce\x99\x03\x3d\x95\x6d\x0f\xf0\x39\xce\x2f\x7b\xd0\x7c\x54\xe2\xf7\x24\x9d\x26\xf8\x35\x43\x78\x1f\x85\xc8\x9b\xa1\x6a\xe2\xd3\x2a\x3b\xe2\x07\xe7\x13\xd8\x57\xaf\xbe\xb9\xf0\x2e\xe8\x46\xb3\x20\x12\x69\x8c\x22\x0d\xdb\x22\x9e\x21\xe6\x67\x7f\x7f\x9f\x51\x8d\x0e\xc4\x5d\x32\x08\x58\x7a\xe6\xa6\x60\xec\x5a\xb7\xeb\xab\x8e\xcb\xb0\x96\x8f\xc9\xe1\x10\x65\x69\x72\xa9\x92\xe8\x24\x51\x21\x4f\x63\x2e\x62\x3d\x56\x3b\xf4\xd6\xa8\x8b\x31\xa2\x11\x38\x05\x6d\x60\x47\xcf\x28\x50\xb5\x57\x6f\xde\x71\x8b\xbf\xb0\xba\x0a\xc6\x54\x79\x55\x42\xc0\x89\xfb\xa0\x3c\xe2\x8b\xa2\x27\x78\x4f\x1f\x4d\x08\x4e\x62\xcb\xf4\x80\xb7\x62\xf4\xd4\xe2\x39\x7a\x07\x2d\xc6\xc3\xba\x66\x91\xa1\x48\xb6\xdc\xee\x0b\xb2\x70\x5f\xe8\x39\xec\x4d\xc0\x0e\x04\x6b\x13\xdf\x9c\xc5\x99\x7a\x78\x47\x56\xe4\xf5\x71\x39\x91\x8a\x81\x8f\xef\xc5\xc0\x7b\x31\xf0\xaf\x2d\x06\xaa\xf7\x79\x6c\xd1\xdc\xd5\x0b\xbd\xbb\xb9\xbb\xa7\x20\xaf\x85\xba\xb1\xd2\x58\x19\xce\x89\x3c\x54\x86\xb0\x42\xa6\x9f\xda\x29\x92\xbb\x60\x13\xb9\xf4\xd3\xb8\xb8\x07\x9e\xa7\xf2\x95\x64\xb0\xa9\x81\x81\x8f\x7e\x3d\xf2\x9b\x32\x84\xd6\x33\xb4\x12\xcc\xf3\xb3\xaf\x88\x95\x63\x28\x5d\x41\x63\xf0\x3a\x4a\xa3\x29\x56\x8e\x00\x28\xcb\x62\xa8\x30\x54\x01\xc2\x75\x89\x02\xd7\xf6\xfb\xb9\x81\x21\xa7\xe2\x7c\xde\x60\xff\x1e\x63\xca\x61\x48\x6a\xfa\xfb\xb4\xc4\xbf\x51\x54\x30\xef\x10\x55\xc1\x27\xa6\x18\xbc\x56\x7a\x36\x29\xd3\xf3\xbc\xed\x68\x54\xb4\x69\xb6\x07\x24\xe6\x20\x82\xb7\x51\x19\x5e\xc2\x70\x2f\xaa\xc5\x2f\x91\xc4\x21\xed\xf8\x84\x6f\xc3\x82\x0a\x36\x32\xa5\xc9\xed\x31\x73\xce\xa9\x2e\x29\x78\x34\x0e\xbe\xed\xca\x71\x0e\xd0\x6b\xca\xca\x09\x2e\x78\x94\x50\xc0\x87\xe3\x95\xd2\xf0\xf4\xd9\x1a\x6f\x62\x50\x57\x6f\x96\x49\xa2\x5c\x78\x04\x54\x8a\xc4\x9f\x09\x5c\x9b\xf9\x70\xf7\xc7\x0c\x00\xd3\x46\x08\xa7\xa5\xb9\xf1\xb3\x8e\x65\xd3\x70\x1e\xe9\xb8\x15\xa2\xe7\x41\x3e\x2d\x1a\x11\x0b\x0a\xc1\x02\x7d\x01\x75\xe0\xb5\x7a\x28\x90\x66\xa5\x1f\x93\x7a\xed\xad\x43\xd2\x50\x99\x52\xe3\x42\x4d\xbe\x64\x98\x2d\xe5\xf1\x84\x87\x9b\xf0\xfa\x94\xf0\xe0\x8c\xfb\x7d\x65\x54\x07\x18\x97\xc7\x4d\x1b\x47\x0c\xf4\x88\x42\xba\x28\x32\x28\x4e\x26\x79\x70\xa1\xd5\x52\x8b\x8a\x75\x0f\x6b\xad\x20\x1f\xdf\xcb\x46\x4f\x69\x4b\x80\x94\xee\x18\x03\x04\xc1\x58\xeb\x02\xf8\xa0\xa7\xea\x37\x23\x6d\x28\x72\x46\x79\x81\xf6\xd9\xe0\x66\xdf\xc1\x3a\x63\xf6\x32\x3e\xa8\x8e\x79\x17\xf1\xcc\x1b\x6f\xfd\x41\xd1\xf4\x4d\x5c\x81\x7b\x4f\xc0\x14\x15\xa1\xd4\x46\xa1\xbd\x53\x81\x83\x1b\x38\xf3\x3c\xf5\x02\xc8\xaa\xbc\x81\x4a\x38\x2e\x7c\x21\x8a\xc4\xe3\x29\x41\x87\x2b\x44\x2a\x8a\xc4\xa2\x6d\x85\x84\x76\x31\x87\x74\xdf\xac\x7c\x13\xb1\x5d\x26\xaf\xec\x89\x99\x0b\x13\x00\xac\x2d\x03\x1d\x10\xf2\x74\x76\xd1\x93\x67\x14\xbf\x0a\x44\xe8\x32\x40\xad\x54\xa1\xc9\xa8\xf3\xb1\xac\xeb\x37\x1c\x54\x09\x7f\xb9\x0c\x9f\xa6\xa8\x35\xfa\x55\x47\x17\xcd\x10\x43\x1b\x2d\x49\x12\x03\xc2\xf8\xa0\x68\xa6\xe3\xec\x16\xb8\xfd\x87\xe3\xe7\xc7\xeb\xeb\xeb\x20\xdb\x77\x0b\xb4\x9c\x26\x97\x03\x1e\xd0\x98\x9e\x06\x96\x05\xdd\x10\x4b\xd9\x4a\xaa\xf9\x97\xa5\xbf\x85\x51\x8d\xbc\x1e\xa1\x8c\x03\x32\xe4\x63\x6b\xc3\xf3\x52\x36\xfa\xf5\x94\x66\x9f\x6e\x9e\x9d\x51\x99\x4b\xff\xbc\xba\x92\x46\x9b\x36\x28\xfb\xb1\x05\x65\xe8\x58\xf6\xfc\xf7\x44\x56\xed\x00\x89\x34\x2e\xec\xa0\x57\x22\xaa\xea\x0a\x55\xde\xa8\x2b\x8b\x53\x16\x0f\x25\xf5\xbf\xc9\x42\x8e\xd3\x6f\x2e\xbc\xab\xa3\xf0\x2a\x4e\xa1\x91\x15\xce\xc2\x17\xb7\xc0\x38\xa8\x43\x5b\xa6\x38\xa9\x6e\xa5\xd4\xe5\x8c\x11\x98\x45\xda\xd6\x79\xec\xf2\xec\x86\x19\x3c\x6f\x47\x67\x66\xd2\x22\xd2\xb2\x9e\xf1\xc6\x56\x31\xbb\x6b\x54\x53\x3d\x04\xc7\xf1\x13\xfb\x8f\x66\xb5\x75\xfb\x2c\x62\x5e\xe1\x34\x6e\xd6\x27\x72\x0e\xb9\xcc\x31\x5c\x8f\xbe\x7b\x7b\x28\x5d\x35\x31\x3b\x96\x71\x94\x4a\x49\x93\xa4\x5c\xe3\xe2\x77\x0a\x95\xbb\xce\x23\x07\x83\xc1\xb5\x1e\xcf\xcd\xf6\x1f\xa8\xd4\x98\xa2\xa8\x87\x93\x36\x39\xb8\xaf\xf4\x3d\xbf\x0a\x11\x0a\x1a\x30\x1d\xd4\xeb\xb3\x56\x85\x68\x5e\xb2\x42\xab\xf3\x5a\x18\xc0\xb4\xbe\xfc\xfb\xf6\x5e\xeb\x73\xaf\xf5\xf9\x6b\x6b\x7d\xb8\xca\x27\x1e\xdd\xe2\xde\xcf\xa7\xf5\x91\xba\x1a\x5d\xed\xc3\xb8\x93\xd4\xe7\x3c\x7f\x66\x30\x12\x3a\x0c\xd3\xe1\x87\xa3\xa7\x80\x91\x5a\xc9\x7b\x35\x61\xc3\xd6\x94\xc0\x54\xf4\x3c\x16\xfd\xfc\x7a\x0b\x7d\x41\x96\x78\x65\x09\x42\x3d\x5a\xb3\xb6\xb5\x70\x20\x47\xe9\xd2\xf3\x75\xd0\xd2\x36\xab\x6d\xbe\x3a\x7c\xd1\x62\x59\xca\xa7\x6b\x29\xbe\xe0\xd8\xd4\x1c\xe8\x51\xa9\x23\x44\x5d\x09\x67\x45\xd5\x08\x51\x37\x1e\x7d\xf4\xe5\x0a\x39\x71\x47\xf6\x49\x36\x3a\xc5\xed\x1a\x95\x70\xde\x46\x7d\xb9\xa2\xd1\x6d\xb7\xd1\xc5\xb2\x7c\x89\x3f\x37\x0f\xf3\x25\xfe\x5c\x35\x46\x33\xab\x7e\x80\xcd\x6d\x31\xa0\xaa\xa1\xf9\xdb\xb2\xc6\xc5\x77\xa3\x53\x05\x27\x26\x22\x50\x48\x0e\xf8\xd0\x03\xde\x2d\x00\x3e\xab\xd8\xba\x9e\x3f\xdb\x93\xbb\x16\xa3\x9d\x4e\xb8\x03\x5b\xd4\x93\xfb\x2d\xea\x7e\x8b\xfa\x6b\x6f\x51\xea\x62\x02\x97\xb3\x1b\xdd\x4a\x70\xe0\xbb\x7d\x93\x58\x11\x7c\xdd\x17\x7d\xdd\x77\x05\xe2\xbf\x05\x69\xd8\x36\x29\x88\x30\x46\xb6\x80\x16\x3c\x59\x80\x8d\xab\xda\x1b\x67\xe9\x84\x4c\x05\x98\x16\x18\x47\x87\x16\x71\x56\x04\xd8\x05\x7f\xb4\x66\x5c\xcf\xf0\x44\x01\xf3\x23\x9c\xe2\x6d\x64\x40\xa2\x00\x39\x2a\xde\x5f\xa6\x63\xb6\xc5\x18\x51\xf0\x59\xaa\x00\xa3\xac\x38\xc7\x36\x10\x4f\x95\x75\x31\xf7\x44\x3a\x04\x19\x45\xa9\xc8\x66\x3e\x0f\x9d\xfe\x88\x64\x29\x84\x80\xc7\xb4\x36\x37\x06\x52\xe3\xcd\x5f\x08\x82\x16\x70\xf3\xac\x8f\x1e\x3c\x40\xfc\xf7\x00\x94\x82\xc7\x93\x5e\x77\xf3\x73\x97\x39\x2e\xd9\xec\xa3\xa7\xa8\x83\xcb\x19\xdd\x3d\x20\x4c\xe9\xb3\xcb\x97\x51\x31\xeb\xa0\xd0\x4e\x66\xfa\xdc\x8e\x92\x12\xb4\x68\x50\x3f\xe6\xd9\xfc\xd9\x6f\xd0\xd3\x2e\xef\x92\x16\x64\xe8\xd9\x25\x34\x4c\x3b\x7d\x90\xc6\x47\xb4\x9c\x8c\xed\xe5\x85\x64\xe3\x90\xb0\x6a\x3c\xcb\x74\x9c\xe0\xdf\x68\x00\x27\xb4\xad\x86\xae\xeb\x30\x95\x9d\x16\xf3\xa3\x8d\xf3\x30\x5b\xa6\xad\x2e\x99\xee\x60\x1c\xde\xb6\x19\x09\xe9\x43\xa9\x00\x63\xa3\x72\xa6\xe0\x37\xec\xff\x89\x6c\x50\x9b\x0c\x67\x12\x74\x00\xa3\xcf\xb2\x7b\x2f\xca\xd9\x5d\x1f\x10\x5a\x1f\x0e\xee\xe8\x6c\x00\xe1\x80\xab\xcf\x06\x4c\xf7\xc1\xb8\x38\xc1\xde\x1e\x2d\xf4\xce\x2c\x1a\xfa\xb1\xb8\x41\x17\xb4\x1b\x6e\xc6\x5d\x99\xf7\x0b\xa4\xbb\xf1\x3e\x7a\x76\xf0\xc6\x0a\x4d\xc6\x79\x2a\x53\xcb\xb0\xe7\xb3\x5c\x39\x73\xbd\xb6\xc6\x7a\x37\x60\x76\x51\xf2\x25\xcd\x8b\x72\xa6\xd4\x41\x01\xea\xea\x81\x9c\xbb\x01\x1f\xe6\x14\x97\x61\x85\xd2\x53\x78\x2a\x1d\xe8\x05\xf9\x48\x02\xae\xa8\x33\x0a\x9f\x47\x89\xe1\xad\x7d\x60\x85\xd1\x3e\x8f\x12\xc7\x15\x89\x4c\xbb\x5e\x03\xf4\xac\x34\x14\xee\xe5\xef\x26\x83\xe1\x45\x6f\x32\x1c\x5e\xb4\xe5\x80\xda\x9c\x45\x29\x77\x89\x12\xb0\xdb\x6c\x3c\x39\x71\x40\xf7\xf4\x24\xd8\x94\x93\x2f\x8f\x50\x9a\x2d\xa7\x71\x87\x17\xa2\x53\x25\x50\xb1\xfb\x3d\xee\x44\xf3\x47\x75\x9d\x67\x43\xe8\x71\xd0\x19\x3f\x91\xc0\x5a\x20\x49\xeb\x22\x2b\xd4\xab\x61\x79\xd2\x63\x8d\x04\xaa\x38\x36\x67\x79\x34\xc5\x07\x65\x9b\x93\x33\x07\xad\xc4\x91\x0f\x42\x1e\x6a\x6b\xb0\xc4\xd6\x1d\xe3\xd8\x65\x06\x27\xcb\x55\xd0\xe2\x1d\x18\x77\xed\xd8\x30\x26\x0a\x55\x39\x1c\x2b\xf3\xb7\x9f\x6f\xef\xc0\xc4\xaa\x6f\xa2\x67\xc6\x8e\xac\xa1\x49\x91\xf1\x76\xc3\xf2\xf5\x36\x70\x96\xb8\xb2\x7e\xa5\x8b\x17\x5d\xaf\x46\xbf\xb4\x89\x7a\xda\x85\xfd\xb7\x19\x13\x00\xe6\x60\x42\x4a\x74\x5f\x03\x13\x1a\x29\xdf\x62\xd0\xc1\x5a\x05\x65\xcf\x17\x24\x61\x87\xb7\x46\xf2\xe6\xa0\x35\x34\xee\x42\x08\x3c\x6c\x56\xd3\x9f\x2d\xaf\xb5\xa4\x47\xbb\x98\xd3\xad\x3a\x91\xd5\xed\xe0\xd6\x2d\x27\xaa\x6e\x6e\xc4\x14\x3e\xc7\x63\x32\x8f\x92\x6a\x54\x28\x29\xb0\x25\x12\x54\x81\x0a\xa2\xfc\xe3\x0e\xd8\x14\x9e\x1a\x06\x5b\x1d\x39\xb9\xe2\x08\x06\xf2\x75\xed\xa0\x9b\x57\x90\x56\x61\x3d\xf3\xf8\xe0\x39\xa1\xae\x34\x26\x59\xca\x19\x5c\xd5\xe1\xf7\x8f\xc4\x69\x6e\x82\xa7\x77\x78\x8c\xc9\xa2\x05\x99\xbb\x65\xda\x10\x80\x0b\x7a\x5b\x0a\xe0\x35\xb6\x1e\x60\xcb\x55\xdc\xc8\xc5\x3c\x83\xb3\x01\xdb\x50\x00\x13\x8b\xee\x48\x40\x6c\x5c\xde\xf4\x80\xf4\x2e\xba\x68\xbf\xc4\xdd\x02\x7e\x44\xd4\xc2\xb5\xe1\x6c\x14\x0f\x1e\x59\xc8\x0d\x34\xdd\xd4\xdb\x56\x5d\xbd\x79\x3f\xed\x99\xf2\xad\x31\xdf\x38\xc8\x34\x5d\x61\x1c\x26\x74\xc5\x38\x2a\x81\xbe\xf2\x38\x5a\x74\xbe\xba\xc7\x77\x2e\x6b\x57\x10\x0e\xb7\xee\xaa\xeb\x28\x05\xf1\x77\xd4\xca\xb9\x49\x47\xe9\x5e\x70\x67\x27\x02\x33\x5e\x7a\xdd\x98\x34\x48\xff\xd0\xfc\x00\x37\xa1\x18\x63\x84\xb7\xe2\x4a\x63\x26\x9f\x8a\x28\xe7\x4d\xd3\xc6\xa0\x07\x22\xf2\x79\xc5\x14\x9a\x75\xfa\xc6\x5a\xd9\x91\x57\xaf\x5e\xb5\xec\x43\x52\x49\x41\xb2\xa6\x95\x5a\x7e\x8f\xf3\x05\x6e\xdc\x9e\x24\x06\x18\x74\x3d\x02\x1c\x98\x9a\x5e\x14\xcb\xd1\x9c\x94\xbf\x64\x79\x93\x94\xa4\x00\x2b\x56\xba\x2f\xbf\xfe\xea\xbb\x45\xab\x1c\xaa\x72\x2b\xae\x68\xcf\x3a\xe2\x38\xd7\xdf\x4a\xf1\x13\xe8\x69\x52\xd1\x61\xa4\x1e\x66\xb1\x09\x06\x4b\xd8\x48\x01\xd9\xdf\x2a\xc4\x0f\x60\x6e\x49\x5b\x7c\x70\x21\xd4\x51\xc2\xc8\xd3\x0a\x56\xa5\x4b\xc1\xb4\x0a\x80\xcb\x4e\x55\xd9\x56\xa3\xa6\x45\xaf\xc6\x48\x54\xa2\x2b\x06\x68\x79\xe6\x7e\x65\x16\xaa\x2c\xa1\x35\x6f\xae\x68\x27\xe3\xd5\xab\x57\x2e\x30\xa3\x7e\xad\x4a\x49\x98\xc6\xa0\x69\x02\x7c\x73\x0b\x07\x16\x91\x4d\x2a\xbb\xeb\x3c\x34\x2b\x3a\xa2\xa4\x2b\xb5\xae\xa6\xed\xa8\x5c\xb8\x24\x1d\x45\x05\xb6\xa2\x41\x4e\x31\x63\x94\x7c\xdd\x72\x18\x09\x72\xdd\x0f\x56\x68\x63\x4e\x3c\xf1\x26\x8d\x16\x38\xc4\x0d\xeb\x9f\x45\xc5\x2c\x8f\xca\xda\x31\x54\xc0\xb4\xda\x19\x56\xef\x91\xb8\x9d\xad\xe9\x90\x1f\xa4\xf9\x9c\xc1\xaf\x83\xcd\xc3\xc5\xea\x3d\x9c\x46\xc5\xdb\x9c\x8c\x6b\x71\x56\x01\x73\x63\x25\xf0\xea\xbd\xe4\x41\x87\x8a\xba\x5e\x4a\x98\x1b\xb6\x31\xd2\xae\xd0\x6a\x9a\xa9\x06\xfb\x4a\x34\x24\x22\x32\xfc\xcc\x6c\x6d\xea\xfa\x66\x83\x6a\x2d\xea\x2c\xc4\xb8\x76\x19\x8c\x95\x1d\x83\x76\xa5\x39\x22\xc6\x93\x85\x68\x5c\x66\xb9\x10\x7f\x84\xe5\x03\xd8\x11\x07\x88\xc2\x1a\xc6\xc4\x1c\xda\xd7\xd8\x44\x58\x3a\x68\x6f\x8b\x48\xe2\x3a\x5c\xd2\x82\x10\x31\xe3\x88\x9e\xef\xda\x32\x40\x50\x98\x5b\x53\x0c\x70\x39\xeb\xf5\x03\x97\x0c\x5f\x65\x53\x4d\xde\xb5\xdc\x1d\x99\xfd\x53\xf6\x13\xf5\x7e\xef\x05\xd2\x7a\xbc\xc0\x60\x9a\x64\xa3\x28\x19\x50\x5c\x0c\x22\x37\x99\x07\x2a\xf3\x35\x49\xc6\xd1\xe2\xcd\x4d\x9b\xa5\x85\x9d\x46\x59\x62\x5d\x93\x9a\x31\x89\x6a\xb0\x66\x0e\xa4\xf5\x49\xc5\x34\x34\xb9\x90\x7a\x51\xce\x94\x19\x9e\x65\x4f\xd3\x09\xb7\x9e\x04\x1d\xc7\xae\x87\xdb\x95\x2b\x83\x9a\x4e\xb8\xfd\x0d\x24\x30\x1a\xea\x84\xdb\xdf\xb1\x4f\x39\xdd\x9d\x70\x87\x15\x21\xa3\x28\xed\x84\x3b\x3b\x81\x69\xf5\x07\x9f\x1c\x49\x9d\x70\x77\x17\xbe\x85\xf5\x4f\x27\xdc\x65\xd5\x73\x86\xdc\x09\x77\x59\xb7\xc4\x1d\x6d\x27\xdc\xa5\x0d\x0a\xdb\x9d\x4e\xb8\xbb\x73\x7d\x16\xec\x7c\x77\x6f\x46\x78\x6f\x46\xf8\xd7\x36\x23\xac\xb2\x21\xbc\xb5\xa9\x7b\x7b\xeb\xbe\x16\xa6\x7b\x00\xf7\x06\x97\x5f\xd3\x32\x1e\x52\x9b\x2d\x4d\x94\x4d\xfc\x4d\x4c\x4d\x5a\x58\xc2\x0f\x87\x43\xe5\x48\xc6\xe7\x9c\x86\x47\x59\xa4\x2c\x1e\xaa\xc3\xe5\x0c\x45\x0b\xa2\xf5\xfd\x2b\x9d\x23\xaa\xc2\xca\x4b\x39\xc5\x8c\x3d\x7f\x53\x99\x08\xe3\xdc\x56\x69\x3b\xad\x54\x01\xad\x20\xa7\xe9\x52\x93\xb3\xa9\xbd\xc1\xa5\x67\x53\x33\x37\x2f\x7d\x77\xb9\x3e\x0b\x76\x37\xef\x77\x8b\xfb\xdd\xe2\xaf\xbd\x5b\xfc\x41\x8d\xce\xef\xce\x3e\xbc\xa5\xf9\xba\xb2\xc0\x7c\x8b\xf3\x22\x4b\xa3\xe4\xde\x0c\xf3\x6b\x9b\x61\x5e\xb7\x33\xcc\x4b\xf1\x85\xb2\xf6\xab\x53\xeb\x2a\x40\x57\xb3\xbb\xe0\xb3\xfa\xd1\x0b\x74\x8b\x8b\xc5\x65\x9a\x64\xe3\x4f\xed\x3a\x68\xc0\xd6\xf4\xb1\x0a\xae\x8d\x79\x5c\xbb\x8b\xae\xca\xeb\xae\x3b\xbe\x27\x95\x43\xfa\xff\xd8\x7b\xf7\xb5\xb6\x91\x65\x71\xf4\xef\xe4\x29\x7a\xe6\x77\xd6\xc4\x0e\x02\x2c\xdf\x20\x24\xcc\xde\xc4\x40\x60\x25\x84\xfc\x80\xcc\xcc\xda\x7c\x4c\x3e\xd9\x6a\x63\x25\xb6\xe4\x2d\xc9\x5c\x32\x61\xbd\xcf\x79\x8e\xf3\x62\xe7\xeb\xea\x8b\xfa\x2a\xcb\x40\x32\x99\x59\xb0\xf6\x9e\x58\x52\x77\x75\x75\x77\x75\x75\x75\x75\x5d\xe6\x5f\x96\x2e\x72\x29\x66\xbb\x64\x74\x76\xa9\xfa\xfc\x54\x9b\x9d\xf2\xb9\x59\xe4\xe6\x4b\x9f\x1b\x0d\x79\x9b\x40\xc7\x1a\x2e\x1a\x51\x68\xa5\x82\x2e\x5c\x2a\x2d\xcb\x4b\x5f\x4f\xbe\xdc\x9a\xa3\x0d\x2c\xc6\x55\x2e\xec\x10\xeb\x4c\xb9\x8e\xb3\xeb\x42\xb8\xb3\xa8\x18\x34\xad\x82\x2e\xe7\xf9\x0f\x72\xde\x83\x9c\xf7\xf7\x96\xf3\x98\x90\x97\x8d\xee\x5b\x2b\x50\x41\x52\x5b\xc0\x83\xb0\x82\x6f\xdd\x3c\x17\x3d\x28\x74\x3c\x1a\x7d\x75\xcd\x82\x5b\x96\x43\xdf\x5a\x98\x23\xac\xf1\x78\xb4\x88\xea\xde\x63\xc1\x88\x7a\x29\x06\x1e\x00\x11\xdf\x7a\xf7\xa1\xd7\xcf\x46\x76\xbd\xfe\xbb\x24\xcb\x2d\x8a\xfd\x72\x44\xaa\x87\x12\xe0\xbc\xab\x7c\x87\xbf\x30\xae\x65\xd8\xee\x9e\x8d\x46\x1f\x2e\xe4\x8b\x18\x45\x84\x88\xe2\x61\x32\x07\x32\x29\x62\x07\x0b\x5f\x6c\x92\x56\x7e\x10\xc5\xd1\x64\x36\x79\x97\xfc\x3a\x57\xce\x92\xca\xda\x5b\x71\x15\x29\xb1\xd2\x98\x26\xd9\x3c\x89\x88\x14\xb1\xb7\xa7\x7d\xb9\x8d\xf8\xa3\x50\x84\x4d\x16\x9d\xf5\x41\x2f\x36\xcf\x6c\x5f\x94\x73\x8c\x8c\xe5\xf3\x6d\xd0\x3d\xe6\x70\xca\x70\x9e\xc5\x55\xb1\x96\x4a\xda\xf1\xb6\x17\x28\x99\xcf\x73\x9c\xb3\xd0\xe2\x15\xac\xfd\x79\x49\x7b\xdb\xf6\x02\xe5\x6d\xb3\xf1\x01\xc9\xa0\x3a\x1e\xb6\x5a\x4e\x9c\xe6\x14\x2e\xc1\x2f\xc6\x97\xaf\xd2\x64\x36\x9d\x7f\x84\x84\x62\x76\x0c\x2c\x5f\x4b\xdc\x1f\x82\x30\x3c\x49\xaa\x34\x5a\x14\xb4\x37\x6b\xfd\x5e\xd2\x70\x8c\x2f\x5f\xe3\xeb\x77\x41\x94\xce\xef\x2d\x2b\xe8\xec\x2f\xff\x6e\xb6\x32\x0a\xb2\x6a\xad\x14\x05\xed\xad\x58\xbf\x97\x93\x1a\x95\x93\x5e\xe3\x79\x26\x7e\x72\x51\x27\x51\xd9\x4a\xcc\x69\x3e\x8d\x2e\x82\x1c\x57\x6b\x5f\x94\x75\x23\x60\x2b\x52\x82\x01\xcd\x9e\x56\x6d\xf0\x95\xb2\x76\x0c\x5c\x45\x4a\xc7\x80\xc8\xab\x39\x3e\xbe\x9e\x4c\x70\x9e\x56\x9b\x0a\xb3\x8a\x6b\x44\x2c\x25\xad\xcb\x4b\x2e\x41\x53\xf8\xcf\x5f\x69\x66\x1d\xe7\xa2\x2b\x2d\x5a\x32\x3a\x5a\xd5\xdd\x34\x99\xbc\x0b\xb2\xec\x32\x49\xc3\xc5\xf0\x93\x6b\x56\xc2\xd2\x51\xa1\x04\xd7\x51\x90\x2d\x30\x89\x5a\x69\xe7\x7a\x76\x14\x9a\xb3\x7f\x2c\x42\x4c\x79\x15\x3a\x72\x15\x9a\xbb\xb6\x16\x40\xc5\xac\x50\xb6\xca\x16\x43\xc8\xd0\xb8\x30\x09\x55\x16\x5a\x86\x89\xac\xf4\x91\x64\x40\x09\x7a\x92\xa9\x96\x8b\x54\xa8\x90\x75\x48\x96\x97\x92\x08\xa0\x9a\xb3\x5a\xf6\xe0\xa2\xc0\xea\x2a\x0a\x32\xde\x49\xc8\x4c\x39\x81\x53\xc2\x04\x33\x7d\x13\xa2\x8a\x23\xc6\x6e\x8a\x8a\xc5\x2e\xa0\xb4\x26\x98\xb3\xfa\x56\x70\xcc\xe2\xb5\xc2\xc6\x14\x84\xe6\xe2\x63\xe3\x38\x05\x04\x2b\x27\x70\x7e\x96\x97\xa0\xd2\x3b\x3b\x70\x8d\x48\xf5\xee\xc8\xdf\xe0\x93\xeb\x7a\xf3\x78\x34\x92\x22\x3e\xce\x37\xba\x51\x34\x62\x9a\x95\x4c\xbb\xf9\xa0\x0f\x7b\xd0\x87\xfd\xbd\xf5\x61\xc5\xbd\x67\xff\xf3\x67\xed\xde\x73\x6b\x8c\xaf\xd0\x4b\x9c\xe2\xf3\xec\x73\x90\x7d\x8e\xd0\x8b\x60\x8c\xaf\xfe\x3b\xcd\x87\xd9\xca\x68\xa6\x6a\xc2\xba\x2c\x22\xed\x11\x1e\xe2\x14\xc7\x03\xbc\x81\x48\xfb\xd9\xc6\xea\xea\x79\x94\x8f\x66\xfd\x95\x41\x32\x59\xc5\x84\x9c\xf0\x6c\xb2\x7a\x9e\x2c\x8b\xdf\xfd\x71\xd2\x5f\xcd\x2e\x83\x74\xb2\x1a\xc5\x39\x4e\xe3\x60\xbc\x4a\xba\x84\xaf\x72\xfe\xef\xca\x79\xf2\x7f\xde\xb4\x5a\x5f\xf9\x9a\xb4\xb8\xfb\x3c\x26\xd8\x3c\x5c\x7c\x7e\x27\x17\x9f\xd4\x78\x19\xe7\x97\x49\xfa\xe9\x08\x07\xf3\x84\x47\xbd\xb8\x29\x87\xf4\x3f\x7f\xfe\x50\x52\xea\x2e\xee\x95\xd7\xf1\x60\x27\x0e\xfa\x63\x3c\x0f\x4b\xa9\xa4\x1d\x41\x7b\x81\xbb\xe0\x76\x19\x4c\x2b\xe2\x56\x94\x74\xe0\x66\x2d\x70\x07\xdc\xc2\xe4\x32\x66\x91\xa4\x4b\x85\x4c\x56\xcc\x8e\x95\xe5\x6b\x75\x8f\x61\xd7\xb5\xf6\xb4\x02\x5a\xb4\x90\x1d\x29\xe3\xdb\x9d\x51\x4a\x89\x20\x84\x2f\xe6\xe9\xd5\x78\x31\x3b\x5a\x96\xaf\x77\x21\xad\x9c\xec\x76\x73\x88\x8a\x94\x71\x90\x93\xf6\xe9\xce\x43\x74\x8e\x2b\x78\xa4\xdb\x71\x51\x3f\xdc\x61\x4c\x68\x06\x8e\x39\x61\x6e\xed\x38\xa8\x1f\xee\x3c\x1a\x2c\xe3\x4e\x39\x32\xb4\x90\x1d\x1f\xe3\x1b\x47\xa9\x5d\x09\xa5\x12\x53\x0b\xe3\x64\xa7\xb3\x65\xe9\xbc\x56\xf0\x43\xe9\x65\xc1\x88\xa4\x23\x03\xe3\x03\xd2\xc1\x6e\xaa\x3e\x73\xea\x97\x00\x11\x12\x54\x8e\x23\x52\x6f\x67\xd2\x83\x24\x8b\x7f\x55\x93\x81\x51\x74\xe1\x74\x6f\x22\x73\x02\xdf\xc5\xe7\xc5\x0c\x51\xb5\x3b\x1a\x03\x76\x71\x53\x83\x2a\x58\x1e\x80\xb0\x64\x8b\x57\x6c\xb5\x31\x68\x3d\x9c\xa9\x1e\xce\x54\x7f\xef\x33\x15\x3b\x50\xf1\x8b\xe0\x6f\x1b\x68\xff\x36\x46\xf6\xfc\x96\x3c\x98\x46\x5c\x18\xa7\x39\x1a\xf3\x51\x99\x35\x22\xbd\x0b\x2f\x0d\x2c\xca\x4b\xe7\xd7\x53\x22\x1f\xb0\x20\xa2\x8c\xf9\x53\x06\x1e\xe5\x83\x51\x8d\x7c\xd7\xf3\xc3\x0c\x82\x0c\xa3\x27\x84\xe2\xb3\xfc\xc9\x86\xf2\x09\x26\x2b\x3d\xcf\x56\xb2\x51\x34\xcc\x6b\x5a\x52\x18\x64\x64\x77\x6c\x98\x05\x18\x4b\x06\x0f\xc4\x18\x5f\xd2\x20\x62\xd4\xc0\xe2\xb9\x05\x8d\x29\x8e\xc3\x28\x3e\xff\xea\x78\xbc\xa3\xed\xc8\x86\x7d\x36\xa4\x58\xf4\x47\x13\x1b\x0d\x9c\x51\x99\x26\xc9\xb9\x51\x6f\xc9\x84\xb5\xc9\x9c\x4b\x32\x06\x4d\x97\x11\x14\x52\xa8\xa4\x5d\x9e\xc5\x51\x9c\xe5\xc1\x78\x5c\xa9\x65\xad\xb4\x3d\x5c\x81\xbb\x50\xb9\xb6\xfd\x4d\x72\x5e\xe1\x76\x96\x94\x72\x86\x49\xa0\x2d\x6a\x45\x4a\xed\x0d\xe6\x86\x52\x21\x45\xe6\xb4\xd7\x1b\x05\x71\xa5\x6b\x5f\x9b\xf0\x41\x41\xc8\x9a\x6f\x65\xf4\x14\x41\x88\x74\x4c\x56\xa2\x8f\xc7\xb2\x3c\xb0\x30\xbf\xc9\x46\xa3\x15\x60\x8d\x06\xbb\xc9\x46\x15\xd8\xcd\xad\xa9\x94\xdf\xe4\x2e\x42\x1f\xf7\x4c\xa7\xd4\x9a\xe1\xdb\xd3\xe9\xad\x2c\x19\x6e\x4d\xa5\xac\xb5\xef\x8a\x4a\x0d\xa1\x95\xf6\x05\xe7\xa3\x0d\xf2\x1f\x5a\x31\x1b\x8d\x36\xc8\x7f\xa8\x9c\x6b\x4b\xbf\xd1\x6e\x3f\x48\xaf\x0f\xd2\xeb\xdf\x5c\x7a\x2d\xae\x04\xb8\x6b\xfe\x3d\x65\x06\xa7\x61\x05\x8e\xf0\x39\x99\xe7\x20\xdd\xea\x47\x8e\x2c\x14\xd9\xea\x2b\xb5\xe8\xca\xc7\x2c\x11\x99\x1e\xa2\x41\x30\x95\x81\xb8\x60\xec\xf7\xb6\xde\x99\x10\x24\x4c\x58\xfc\x02\xe6\x7d\x80\x36\xd1\x93\xc6\xd5\xa0\x1b\x3e\x0b\x9b\x83\xb0\xdd\x7e\x16\xac\x75\xda\x83\xf6\xb3\x76\xb3\xdb\xc6\xfe\x7a\xe3\xd9\xa0\xd3\xc0\xad\x76\xd8\x6d\x77\xba\xcd\xfe\x93\x02\x17\x1b\x98\xc0\x0f\x7c\xdf\xef\x0f\x1a\x6b\xed\xc1\xb3\xc1\x30\x58\x5b\xf7\x87\x8d\x41\x6b\x1d\x77\x5b\xfd\xb0\xe3\x0f\x9e\xf9\xfd\xf5\x60\xd8\x68\x3c\x71\xf3\x26\x8a\xe3\x86\x24\x14\x07\xfd\x68\xc3\x32\x88\xca\x15\x2c\x41\x61\xc3\xda\x3f\xca\x6e\x69\x61\x82\xb6\x01\x59\x1f\x57\x0b\x5c\xb3\xbb\x14\xaa\xc2\x31\xcb\x67\xf1\xc7\x0d\xdf\xfb\x71\xce\x3c\xfd\xb8\xd1\x24\xcc\xb6\xf3\xc0\x6c\x1f\x98\xed\xdf\x9b\xd9\x16\xbc\x96\xeb\xc9\x34\x66\x5b\xe6\x4e\x3a\x4c\x93\xcf\x78\x12\xc4\x2b\x21\xfe\xf9\x5e\x18\xb4\x2d\xb2\x81\x16\xd6\x40\xbf\x4b\x95\xf2\x05\x03\xed\x65\xca\x85\x29\x4b\xe7\xcb\x3e\xc1\xa3\x94\x5d\x82\xea\x1c\xa5\xef\xf4\x85\x92\x7f\x42\x2b\x91\xe9\x25\xf4\xec\xd5\x45\x51\xed\x8b\x54\x47\x55\x55\x4b\x55\xd4\x0f\x52\x0d\xe3\xde\x37\x9e\x8d\xc7\x54\xb2\xe4\x63\x21\x27\x3b\xd5\xef\x41\xd5\x4c\xdc\x13\x65\x88\x0c\xd0\xe9\xa4\x6a\x72\x71\x47\x4a\xf7\x3b\x67\x74\xb7\x74\xa9\x24\xa7\xbb\x2d\xe2\x8f\x36\xc2\xff\x65\x7b\x4b\xeb\x42\x76\xf5\xef\x24\x9b\xba\xb3\xdf\xf7\x94\x4f\xfd\x87\x4d\x4a\x38\xda\x2b\xb2\xa1\x0c\xa3\x18\x87\x77\x49\xb8\xce\x13\x05\xe7\x09\x62\x59\xca\x8b\xec\xe5\x90\x7d\x5d\x9c\xcb\x45\xfe\xdd\x15\x74\x40\x36\xb6\x08\x67\x8c\x92\x60\x98\xb4\xb1\xd4\x52\x9e\xdb\x73\xb3\x53\x78\xca\xb8\xee\xb2\x91\xfa\xf2\x76\x36\x1e\xdf\x48\x5e\x2e\xd1\x10\xe1\xab\x28\x83\xe2\xd6\x21\xd7\x5a\x74\xaa\x16\xa3\x61\x91\xaf\x88\xb7\x46\x33\x16\x81\x46\x8e\xe5\x07\x5f\x46\xfe\x59\xdd\x92\x7b\x05\xca\x4c\x93\x69\xad\x0e\x69\xca\xd9\x15\x19\xe1\xff\xb0\x9e\x60\xb4\x7e\x90\x85\x1b\x75\xb8\xa9\x29\x44\x81\x59\x9e\xd8\x49\x51\x35\x99\x70\x11\x23\x7b\xc5\x7b\xe1\xa4\xc6\xea\xd9\xda\xa1\x8e\x10\x25\x11\x4f\x47\x53\x64\x6f\x7f\x85\xf3\x9a\x74\x67\x84\xe3\xd9\x04\xa7\x41\x7f\x8c\x37\x50\x9e\xce\xb0\xa9\x25\x0c\x26\x38\x2b\xcd\xcc\x7e\x51\xa4\x6f\x87\xc2\xa0\xe7\x45\x52\xca\xf6\x6c\x4e\xce\xf6\x4c\x4b\xda\x9e\x39\xb2\xb6\xeb\x45\x9e\x2b\x6a\x09\xd1\xbc\x7f\xc6\x53\xdf\xc0\x3f\xf6\x5c\x3e\x49\xff\xa3\x07\xe5\x3d\x3a\x64\xac\x2f\x04\x7e\x90\x5d\xc7\x83\x57\xb0\xdf\x10\x91\x17\xba\x50\x3f\x53\x52\xe0\x6f\xb1\x22\x35\xc9\x3f\x4b\xab\xa6\x4c\x12\x80\x50\x59\x06\x5c\x44\xa3\x25\xc0\x61\x65\x30\x0a\xd2\xad\xbc\xd6\xa8\xaf\xe4\xc9\xfb\xe9\x14\xa7\xbd\x20\xc3\xb5\x3a\xff\x0c\x49\xb4\x6b\x7e\xdd\xb9\xf1\xf0\x99\x75\xe7\x99\x2d\x36\xee\x22\x69\x2e\x8f\x7f\xc7\x6b\x9c\x93\x0e\x99\x2b\x46\x08\x28\x4a\x3e\x75\xf1\xd6\x96\x51\x5d\xd5\xe7\xd3\x25\xb1\x51\x00\xa2\xdb\x7d\xa1\x9a\x96\x32\xaf\x97\x75\x90\x8f\xfa\x62\xbd\x2c\xcc\x02\xdc\xb1\xe3\x50\x61\x11\x65\xed\x10\xcd\x72\xbf\x60\xaf\x2a\x66\xc3\x57\x33\xe0\xdb\x07\xdb\xcc\x81\x7f\xa3\x26\xab\x3f\xc7\xf9\x82\xb9\xea\xcf\xb1\x6b\x3b\xf9\xbe\x53\xd5\x5b\x88\xa3\x7a\xb2\x7a\xdd\xc2\x6e\x43\x96\x47\x4d\x4d\xe5\xe9\x99\xaa\xe3\x24\xd3\xc4\xaa\x68\x9b\x55\xc5\xbc\xf7\xf2\x94\x7d\xad\xec\xf7\x7c\x80\xdc\xf9\xef\xc9\x11\xbb\xfb\x70\xc4\x7e\x38\x62\xff\xbd\x8f\xd8\x92\x3e\x93\x71\x88\x09\x63\xe9\xea\x49\xfb\x9f\x78\x38\x4c\xf1\x35\xfa\x35\x1a\x0f\x3e\x61\xf4\xe2\x23\x1e\x0e\x5d\x41\x9e\x16\x8a\x08\x75\x10\xa4\xe4\x08\x7f\x18\xc4\x03\x1c\x40\x59\x5b\x2c\xa8\x5b\x84\x8f\x62\x55\x5e\x05\x17\xe8\xd7\x24\x09\xd1\x8b\x73\xe7\x21\xbf\x5d\x1c\xf2\xff\xc9\xb8\xa9\x12\x37\x80\xb1\xd8\xb2\x04\xc6\x96\xf8\x86\x7a\xce\x61\x5b\xc2\x61\x9c\xa6\x89\x16\xf0\x60\x95\xbe\xa3\xe6\x0a\x74\xdb\xd9\xcf\x9f\x64\x64\x63\x9c\x26\x71\x16\xf5\xc7\x94\xc0\xa6\x41\x96\x45\xf1\x39\x9a\x70\x27\xda\x3c\x21\x1b\xe3\x45\x14\xe2\x34\x13\xb5\x82\x71\x96\x98\x55\x93\xf1\x98\x54\x25\xd4\xc6\x0d\xcd\x51\x9c\x84\xf4\x6b\x14\x0f\x92\x89\x0c\x99\x00\x63\x19\x24\xe8\xbd\x57\x1e\x4d\x30\x59\x6c\x51\x86\x7c\x94\xe1\x41\x12\x87\xb0\x3b\x46\xf1\xf9\x18\xe7\x49\x0c\xc3\x49\xba\x57\x72\xd0\xe7\xa8\x2a\xc7\x7d\xfe\x12\x6d\x8a\xae\x48\x7a\x06\xd2\x36\x68\x80\x6f\xa4\x97\x1c\x17\x59\xeb\xe0\x3c\xfc\x11\x09\x65\x94\x26\x71\x32\xcb\xc6\xd7\x10\xfd\xc6\xb1\x0f\x93\x4f\x96\xf3\x08\x0a\x83\x3c\x70\x9e\x90\xd5\xde\x2a\x2a\x8f\x38\x54\x3a\x4f\xc0\xc8\x27\xb5\x1f\x94\xde\x2b\xa9\x2c\x93\x38\x4b\xc8\xd6\x45\x88\xa2\x46\x49\x63\x65\x3f\xbe\x08\xc6\x51\xf8\x8e\x95\xaf\xc9\x32\x0f\x8f\xc6\x00\x83\x21\x49\xf8\xea\x1e\xcf\xc8\x7c\x25\x4f\xde\xd1\x77\x80\xd2\x0a\xed\xbd\x07\xdd\x64\x76\x19\xd2\xf9\x85\x9d\xca\x37\xd5\xb9\xa2\xc2\x2c\x03\xcd\xef\x2b\xa1\x53\xbc\x91\x28\xfb\x85\xa0\x7b\x44\xa9\x10\x0b\x41\x4d\xea\x66\x3e\x4a\x93\x4b\xa4\x76\x4f\x2f\xaf\x74\x87\x75\x93\x7e\x5a\xa9\x74\xf2\x0f\x16\x9a\x7d\x90\x66\x4b\x49\x40\x3f\x97\x0a\xe9\x67\x3e\x31\x00\x70\x83\x22\xcc\x90\xd9\xe5\xb4\xc1\x13\xa5\x4a\xb2\x71\x19\x75\xdc\x0f\x21\x98\x73\x4f\xe5\x7e\x06\xb2\x82\x3c\x4f\x3a\x85\xd3\x54\x17\xf1\x2d\xbd\xa9\xeb\x96\x39\xe4\x4f\x81\xb3\x08\x8d\xcd\x1f\x32\xa3\xb6\xdc\xbe\x21\xe4\xb2\xdc\xbe\x0a\x09\xea\x31\x5d\xdd\xc7\x06\x1b\x35\x96\x9d\x0c\x48\x81\x97\xe4\xbb\x45\xc9\x44\xeb\xdd\x07\x61\x42\x0b\xdf\x19\x61\x02\x4e\x32\x75\x72\x26\x73\x3b\x52\xcc\xee\x81\x16\x55\x1a\xe4\x7a\x36\x98\x8d\x1a\x6f\xe5\x4e\xa4\x97\xcd\xa3\x3d\xa5\x43\x82\xe8\xd0\x9c\xed\x0f\xe7\x62\x5f\x25\xd2\x26\x3f\x13\x32\x91\xcf\xa0\xb8\x9c\x4f\x95\x5d\x35\x57\x4a\x4b\xa2\xae\xba\xeb\x3b\xb7\xfb\x79\x3b\x77\x4e\x8e\x54\x4c\x70\xd1\x11\x25\xdf\xde\x89\x4f\x73\x39\x36\xcd\xf4\x70\x03\xd0\xf6\xc3\xb9\x4b\xc6\xf2\x55\x98\xda\x70\x4c\xf2\x24\x4c\xd0\x60\x8c\x83\x78\x36\x45\x31\xc0\x27\x03\x2c\x8e\xed\x65\x43\x25\x61\x6f\x59\x79\x14\x49\x39\x12\x92\x68\x5c\x1d\x4b\x22\x1c\x9d\xd2\xd2\x67\x44\x48\x22\xd5\x37\x10\x05\x12\x85\x1b\x06\xa0\x0d\x1b\xc8\x8d\xe2\xe7\x0d\xcf\x80\xbe\xba\xaa\x8f\xbe\xc2\x00\x98\x00\xa6\xee\xe6\x0c\xa1\x9a\x58\xe1\x73\x26\x37\x99\x0a\xa1\x94\x88\xa0\xcc\xe2\x16\x4e\x37\xe7\x11\x39\xd2\x45\xba\xee\x98\xd4\xb1\xcc\xb9\x31\xb7\xa5\x23\x2f\x40\xa8\x44\x0a\x75\x79\x87\xa8\x8b\xb5\x65\x90\x9f\x4b\xc3\x53\xe0\xcf\x46\xa7\xc6\x34\xaa\x9f\xf0\x75\x56\x2b\xea\xd6\xb9\x96\x77\x73\x73\x13\x35\xd0\x4f\x3f\x21\xd7\x18\x12\x62\x4a\x4f\xe8\xfb\x9a\x52\xe8\xb9\x3a\xce\xba\x00\x5c\x32\xde\xc5\xee\x93\x62\xc2\x0b\x88\xfc\xcf\x87\x7d\x82\x07\xa3\x20\x8e\xb2\x09\x3f\x86\x96\x33\x07\x00\x50\x3e\xbc\xb4\x0d\x79\x60\x3f\x61\x3c\x15\x69\x27\x78\x67\x57\x9f\x7e\xcc\x46\x51\x4c\x1a\xba\x1a\x24\x93\xe9\x18\x5f\x45\xf9\xf5\x46\x07\x8e\x64\xa4\x00\x21\x88\x1a\xd9\x1c\x3e\xe1\x6b\xaa\x29\x10\xa3\x29\x8d\xd7\xea\x2a\x4a\xf1\x24\xb9\xc0\x28\x18\x8f\xa1\x57\x99\x87\xf0\xd5\x00\x4f\x73\x10\xfb\xd9\x2b\xb9\x7c\x3e\xc2\xd7\x28\xc6\x74\x44\xfa\x98\xd5\x0f\x49\x8f\x67\xc1\x78\x7c\x8d\xfa\xd7\x30\x64\x64\x78\x58\x06\x09\xa0\x99\x5f\xc9\x86\x14\xc5\xe7\xb5\xba\xb4\x0f\xd4\x7e\x50\x7a\x87\xbe\x7c\x21\xf8\xae\x44\x71\x88\xaf\x0e\x87\x35\xf0\x68\x24\xc4\xf6\xe1\x49\x1d\x26\x7f\xd9\xd7\x37\x08\x89\xc2\x3e\xe1\xeb\xb3\x15\xb1\x12\x75\xcb\x69\x93\x22\x49\x79\xc3\x8a\xf9\x2f\x4c\x9e\x70\xca\x24\xf3\x3e\xa0\x06\x92\x28\x89\xab\xf0\x04\x6a\xd7\x58\x46\x93\xcc\x6c\xd3\x54\x81\x3a\xa8\x10\x75\x09\x38\x4b\x67\x32\x9c\x2b\xbd\x27\x80\x25\x55\xa4\x87\x06\x2b\x3b\x27\x7b\x1f\xde\x1d\xbe\x79\xb3\xff\xf6\xd5\x87\x93\xfd\x83\x9d\xc3\xf7\x27\xf2\xf1\xa8\xca\x0c\x98\x42\x95\x22\x31\x7d\x95\xa3\xa3\x29\x93\x11\xbc\xb6\x83\x3c\x40\x9b\xe8\xf4\xec\xb9\xfa\x7e\x1f\x3c\x93\xf9\xeb\x6a\x4b\x55\x00\x5c\x99\xce\xb2\x51\x4d\xa7\x7b\x26\xe2\x29\xa5\xf7\xc3\x8c\x16\xfe\x84\xaf\xeb\xc6\x18\x14\x00\x17\x18\xbc\x4a\xe2\xa6\x80\xcc\x1a\xe5\x4b\x6a\x12\x4c\x15\x26\x19\x01\xd9\x02\x43\x01\x12\x23\xa4\xa9\x0e\xd3\x41\x30\x95\x54\x17\x92\x5e\x5b\x75\x2a\xa7\x82\x2b\x70\x8d\xfa\x1f\xfa\x18\x1c\x04\xd3\x53\xa8\x16\xc1\x16\xcf\x47\xe6\x14\x8a\x9f\x49\xce\xeb\xa2\x71\xc5\xc5\x1e\x2d\x2c\x33\x27\xaa\xd4\xfc\x58\xe6\x9e\x27\x87\xdb\x87\x1b\x9c\xc8\xd0\x38\x39\xff\x2f\x5d\xaa\x4e\x1c\x72\xf5\x5d\x25\xe9\x0a\xca\x82\xcc\x7a\x74\x64\xdf\x56\x26\xc1\xb4\xe6\x32\x56\xe0\x7f\x60\xbf\x18\x16\xa3\x4c\xc6\x9e\x1d\xf5\xa2\x50\xf6\xd1\x11\x14\xf1\x09\xa3\x6c\x96\x82\x9e\x98\x33\xab\x28\x43\x59\x1e\x11\x7a\xa0\x9c\x1c\x87\x28\x18\x82\x2f\x51\x9a\x46\x17\xc1\x58\xdb\x6b\x15\x98\x64\x40\x20\x42\x00\x5d\x1a\x51\x78\xa6\xa3\x58\x74\x69\x65\x50\xd8\x03\xa8\x75\xc4\x17\xa7\x6f\x0d\xd7\x9d\xc8\x9f\x6e\x10\x1e\x33\x3d\xb3\xa5\xc6\x30\x18\x67\x58\xbe\x65\x63\x1e\x52\x73\xc7\x94\xd5\xff\xe1\x07\xd6\x26\xba\x05\x0c\x88\xe2\x49\x66\x5c\x5a\xb4\x8e\xc3\xff\x73\x63\x3c\x7f\x80\x9a\x15\xc6\xb1\xba\x62\x00\x29\x14\x26\xf5\x12\x2a\xaa\xa3\x64\x04\x80\x75\x0d\x93\x8a\x8b\x5b\xcf\x80\xe4\x4b\x4e\x57\xa2\xae\x23\x3d\xfe\x86\x7a\xe3\xa5\x65\xec\x32\x33\x9e\x30\x85\xf4\x8f\x1b\x4d\x88\x02\xc4\x94\xe1\x3f\x6e\xb4\xc0\x63\x75\xad\xca\x1d\x19\x0b\xb7\x8b\xf3\x3c\x8a\xcf\xed\x4e\xc0\xc0\x98\x42\x29\x4f\x31\xda\x14\xee\x6d\xcf\x8d\x12\x45\xa4\x76\x61\x1f\xe4\x0a\x79\xc4\x1a\x65\xfd\x26\x28\xaf\x3f\x5c\xeb\x3d\x5c\xeb\xfd\xcd\xaf\xf5\x58\x20\x6f\x76\x6a\xb1\x3a\xd9\xde\x21\x17\x4b\x49\xbc\x6e\x4b\xb8\xee\xaa\x86\xb3\x7c\x49\xfb\xec\x70\xb0\x15\x86\x19\x0c\x9d\xd8\xdd\x82\x18\xd4\x52\x19\x9a\x51\xf1\x8b\xf9\xc7\x79\x44\xf8\x8a\x72\x88\xce\x86\x92\x0b\xb6\x8c\xf8\x6e\xff\xf8\xb1\x7c\x3e\x60\xe7\xb3\xc7\xba\x92\x88\x6c\x9b\x8f\xd9\xb5\x95\x54\x4e\xe2\x55\x34\xa4\x0f\x11\x83\xf8\x3e\x24\x42\xdb\x29\x1c\x8d\xc9\x4d\x64\xec\x2d\xaa\x46\x97\x50\x44\xf7\x6d\xde\xd3\xcc\xb2\x59\xd8\xec\x71\xf8\x9f\xba\x6f\xe9\xdb\x93\x4b\x77\x29\x2c\x04\x79\xcc\x22\x40\xf9\xa7\x9f\x00\x77\xaa\x98\x8a\xe2\x73\xe0\xc6\x75\x05\x22\xbf\xbe\x98\x97\xc0\x96\x42\x94\x1d\x9a\x6f\xdb\x49\x21\x0d\x8d\x83\x0c\x9a\x39\xce\xc9\x64\xff\xb0\xb9\x69\x0c\x34\xff\x33\x5e\xac\xae\xd2\x3c\xfd\x0a\x49\xc1\x52\xcb\xd3\x19\x91\xd9\xd2\x2c\x47\x59\x42\xed\x1c\xa7\x53\x60\xdd\x70\x76\x0e\xe2\xeb\x9c\x1c\xf8\x3d\xd4\xc7\x43\xc2\x00\xe8\x12\xe7\x57\xa8\x30\x1a\x54\xc9\xa8\xfd\x45\xc3\xda\x0f\x16\xac\x7f\xfa\x09\xd9\x46\xbe\x6e\xd4\x47\xe6\x75\x03\x41\xd5\xe2\x49\xed\xec\x6c\x42\xf9\x66\x8c\xaf\x72\xd4\x7b\xf7\x1e\x0d\xae\x07\x63\xec\x89\x6e\xc2\xb0\x8b\xcd\x06\x7a\x02\x5d\x66\x36\x4b\xd3\x34\x19\x10\x9e\x95\xd1\xd1\x31\x5a\x91\x8e\xc1\x62\x99\xd8\xe6\xc2\xd2\x11\x46\x1a\x7a\xa9\x1b\x0f\x35\xaa\xf4\xcf\x32\xac\x94\x14\x5c\xa2\x99\x64\x0c\xf6\x58\x00\xd0\xcd\xd8\x24\x5d\x6c\xcd\xb4\x83\x72\x24\x77\xd6\x2d\xa1\x6e\xbc\x42\x08\xdf\x0f\xbd\x82\x4d\xb0\xf7\xb2\x0e\x89\xea\x0c\x80\xb3\x90\x75\xc2\xed\x24\xf7\xad\xd9\x5c\x9d\x29\x5a\xcb\x4d\xe6\x35\xf9\x0f\xc9\xba\xa6\x7d\x22\x47\x4b\xca\xa9\x25\xca\x85\x97\x96\xa4\x72\x62\xbd\x4a\x27\x7d\xf8\x10\x84\xa1\xb0\xed\x92\xd2\xc5\x8a\xef\xfa\xf4\x48\x07\x07\x89\xc5\x72\xe3\x2d\x78\x2f\xd9\x8a\x53\x81\x4e\x8c\x84\x6c\xe9\x5b\xb4\x5b\x6a\xb1\x18\x0d\x8b\x57\xaa\x56\xaa\x60\x41\xa0\x55\xd0\x90\xaf\x84\x84\x3c\x8b\x6e\x89\xd6\x20\x30\xa1\x72\xae\x49\x73\x50\x2f\x19\x6d\xab\x54\x2b\x10\x72\x1b\xb0\x11\x59\x5d\x0d\xe9\x49\x64\xdf\x87\xd4\xb6\x0f\xb2\xef\xdf\x5d\xf6\x2d\x4c\xda\x78\x9e\xe7\xfb\xf2\xd1\xdd\xef\x07\xb1\x2a\xed\x46\xfd\x40\xb8\xde\xe2\x2b\xaa\xae\x2e\x73\xdd\x3d\x9e\x04\x69\xbe\xc3\x0a\x16\x6e\xb7\xce\xab\x31\x50\x2b\x41\xb3\xbc\x2f\x9a\xce\x5b\x7a\x2d\x2e\xc1\x8e\xf3\x34\x8a\xcf\x6f\xc0\xb5\xc5\xf6\x9e\x48\xcb\xfd\x20\x96\x3f\xfd\x12\x8c\x67\xf8\x06\x5d\x90\x7f\xd8\x75\x08\x81\x3c\xc4\x29\x9e\x73\x43\xea\xa9\xe6\x05\x10\xcf\x86\xe1\xa4\x8a\xc5\xf9\xc8\x03\x8c\x88\xb4\xee\xd1\x96\xcc\x2d\x0c\xd4\x6e\x74\x94\x21\x49\x79\x3f\x88\x6b\x79\x52\x67\xaa\x22\xd0\xe1\x90\xcf\x5c\xe5\x53\xb3\x58\x11\x91\x7a\x90\x1f\xa6\xf6\x24\xa2\xea\x1b\x0a\x91\xf9\xe9\x3e\x31\xf5\xc7\x0c\x22\x8d\xd9\x5c\xb3\x39\xc4\xf0\x1e\x9d\x24\xcc\xb3\x57\xee\x0e\x54\x67\xd0\x6b\x75\xb3\x6b\xbc\x3d\x21\xc7\x40\x37\x6c\x92\x2e\x8b\x0b\xcf\x3c\xa5\x71\x3e\x92\x33\xc9\xd7\xea\xd0\x08\xc3\x36\xce\xf2\x28\x9f\x51\x81\xcb\x34\xff\x0a\xf1\x34\xc9\xa2\x5c\xc6\x92\xc1\x15\xe8\x01\x98\xc1\x38\xc2\x71\xae\x5b\x62\x54\x6e\xd8\x30\xb1\xe0\x19\xea\xcd\x11\x5c\x14\x23\x73\xfc\xb8\x0a\xbe\xf4\x2a\x59\x90\xde\x70\x16\x87\x60\x13\x39\xc0\x69\x1e\x44\x62\xfa\x1d\xcb\x47\x4c\xec\x62\xeb\xe8\xab\x2f\x21\x81\xd7\x2d\xd6\x12\x1b\x79\x32\x9b\x5a\xa2\x3f\x49\xb6\x15\xde\xeb\xb9\x14\x22\x9e\x80\xde\xa0\x0d\x48\xb4\x39\x9e\xe1\x0d\xfa\x0f\x17\x73\x07\x6a\x06\x26\xe7\xac\xb0\xc9\x2f\x26\x05\x62\xa9\x47\x03\xc4\x39\x21\xe2\x1c\x12\xd5\x26\xb3\x2c\x87\xad\x0e\xa2\xaf\x0b\xba\xe9\x5f\xe7\x38\x6b\x35\xeb\x4c\x18\xff\xa1\xae\x4d\x24\x2b\x77\xef\xd3\x97\x19\xf3\xc7\xab\x53\x4a\x45\xb3\x38\xfa\xdf\x19\x46\x51\x88\xe3\x3c\x1a\x46\x2a\x27\xae\x34\xd7\x7c\x74\x2a\xcc\x30\x34\x69\xe7\x9a\x01\xec\x3a\xd2\x1e\xf4\x5c\x27\x02\x3e\xc6\xb5\xa0\x1f\xd5\x57\x82\x9c\x30\xd6\x15\x3e\xbe\x1c\xf4\x1f\x77\x25\x02\x43\x56\xe5\xa3\x68\x0d\x82\x60\xee\x87\x3f\x6e\xb4\x88\xe8\x4a\x98\xc1\x8f\x1b\xad\xd6\xcd\x99\xd7\xa9\x94\x61\x9b\x69\x77\x3b\x95\xd2\x34\x3e\x97\x95\xf0\x09\x91\x2f\x86\xc1\x20\x4f\xd2\x6b\x8f\x2a\x94\xc9\xc0\x3e\x22\x6c\x9a\x88\xfa\xc9\x10\x89\xde\x6c\x6e\xa2\x1f\x69\xec\xa6\x1f\xa1\xcc\xa3\xd5\x55\xd4\x4b\x26\x93\x24\xfe\xe7\xf1\xe3\x47\x8f\x8c\xce\x17\xbf\x58\x03\x1c\xa7\xda\x8f\x64\x18\x52\xfc\x63\xdd\x43\xd2\x2b\x1c\x0f\x96\xfb\x41\x86\xbb\x6d\xed\xc3\x24\xec\xe8\x45\x2f\xa6\x9f\xc2\xa1\xf6\x72\x10\x4d\x47\x38\x5d\xa6\x90\xeb\xcf\x1f\x3f\xba\x79\xfc\x08\x8f\x33\x8c\xa4\xce\x50\x85\x39\xed\x0b\x1f\x86\x1f\xd1\x4f\x3f\xb1\x0f\x2b\xc1\x24\x14\x7d\xdb\x3a\xd8\x7e\xfc\xe8\x11\xfd\x50\x3b\xe5\x38\x7b\x48\x45\x15\x9e\x09\x86\xf4\x03\x45\x0c\x7e\xcb\xf8\x9c\x89\x51\x96\x11\x63\x0d\xd1\x68\x18\xa8\xd6\x4f\x93\xcb\x0c\xa7\xf5\xc7\x8f\x1e\x89\x11\x4b\x92\x7c\xa5\x97\x5e\x4f\xf3\xe4\x9f\xc7\xb4\xea\x0d\x9c\x9e\xe4\xed\x47\x7c\x47\x7f\x3c\x7e\xfc\xa8\xa6\x1e\xc7\x1e\x21\xaa\x11\x39\x1e\x25\x69\x3e\x98\xe5\x19\x7d\x43\x96\x4d\x0f\x6d\x22\x5e\xf7\xb9\xf4\xfa\xc3\x38\xea\x93\x4f\x2b\xe3\xa8\x2f\xbd\x07\x65\x58\x0f\x3a\x45\xbe\x92\x52\x2b\xd2\x3b\x05\x42\x30\x3e\x4f\x00\x04\xf9\xf1\xfc\xb1\xc0\xe2\x4d\x92\x7c\x9a\x4d\x51\x1e\xf4\xc7\x58\xc2\xe4\xf8\xe5\xe1\x6f\xec\xcc\x27\xde\xed\xbf\xfd\xe5\x83\xed\xfd\xf1\xfb\x97\x1f\x0e\xf6\x7f\xfb\xd0\x70\x7d\xf0\x5d\x1f\x9a\xae\x0f\x2d\x6b\xdb\xae\x76\xe4\x8f\x46\x5b\xf2\x47\xa3\x3d\xf9\x23\x6f\x53\x0c\x4d\x2f\x99\x4c\xc9\x41\x71\x6c\x0e\x91\x6d\x4a\xb5\x5a\x61\x32\xeb\x13\xa9\x9f\xd4\x2a\x0a\x00\x8b\x95\xb1\x40\xb2\xa5\x42\x04\x81\x07\x51\x84\x5e\xa0\x66\xa7\xfb\x1c\x45\x4b\x4b\x0a\x78\x21\x23\xa2\x17\xc8\x6f\xae\x1b\xdf\xc8\x5f\x78\x1a\x9d\xa1\x4d\x02\xe3\x05\xf2\x9f\xab\xdf\xe9\x55\x6a\x49\xad\x1a\xad\x56\x47\xbf\xa3\xc6\x95\xef\xf7\xf5\xfa\xc5\xe3\xcd\x63\xa5\xd7\xbf\x06\xe3\x4f\xe8\xd5\x6e\xad\xf9\xfb\x7a\x5d\xed\xed\x15\x0d\xa6\xa8\xbe\x8b\xb4\x97\x0b\x8d\x80\x34\xc8\x59\x3f\xb9\x52\x3f\x82\xa1\x01\x69\xf3\x2a\x42\xbf\xa3\xda\x55\xd1\x21\xf6\xbb\x29\xfd\x6e\x49\xbf\xdb\x75\xad\xb3\x00\xa5\x96\x5d\xa1\x9f\x7f\xfe\x19\xad\x43\xc9\xec\x0a\xfd\x84\x1a\x57\xc3\x21\x1d\xa0\x6e\x4b\xab\x42\x56\xc7\xe9\x15\x19\xc8\xec\x4a\xfb\xc4\x17\xcf\x69\x06\xdf\xaf\x9e\x3f\x76\x76\x6a\x32\x1b\xe7\xd1\x74\x1c\x0d\x40\x4b\x60\x76\xef\x8a\x90\x71\x78\x7a\x75\xf6\xdc\xf2\xad\x4d\xbf\x35\xad\x1f\xd7\xe9\xc7\xf6\x59\x49\xeb\xd9\xac\x8f\x40\xbe\xf1\xd0\x24\xba\x42\x83\x64\x3c\x9b\xc4\x99\x42\xfd\x32\x4c\x22\x29\xd4\x42\xe8\xd5\x53\x42\x33\x0d\x9f\x8f\x14\x7b\x6c\xf8\x8d\x86\x3e\xb4\x62\x25\xd3\xc1\xaa\xe5\x30\x31\xed\x3a\xfa\x42\x7e\xd3\xf1\x76\x54\xf1\xe5\x2a\x7e\x57\xaa\xe2\x77\x5d\x75\x9a\x72\x9d\xf5\x3a\x2a\xea\x34\x8d\x59\x17\xdc\x80\xd6\xc9\x4b\x46\x2a\x8a\x2f\xe4\xd1\x22\x8f\x95\x47\xec\x6a\x5d\x1a\x1f\x46\x9e\x6d\xf6\xaa\xc1\x5f\x34\x95\x21\x2d\x1d\x51\x85\x3f\x32\x1a\xab\x32\xac\x0a\xeb\x54\xea\xcd\x19\x5b\x85\xad\x2a\x15\xe7\x0c\xb0\xc2\x72\x59\xc5\xb2\x51\x86\xcb\x02\xd0\x03\xe3\xd4\xe4\x84\x3f\x5c\x59\x99\x20\x63\x00\x9b\x0b\x70\x40\xa8\xd2\x44\xbf\xa3\xf0\x94\xfc\xef\x6a\x1d\xfd\x8e\xae\x9a\x67\x67\xfa\x42\x82\xb2\x11\xfa\x7d\x13\x0a\x5e\x45\x46\x01\x85\x49\xc2\xcf\x1b\x38\xd3\x8a\x7d\xe5\x5d\x8a\x07\xb4\x73\x21\x3a\x1a\x24\x31\xdb\x60\x8a\x5d\xe9\xa8\x77\xf8\x96\xec\x11\x8d\xab\x46\xc3\x43\x8d\xab\x86\x0f\xff\x6d\xc2\x7f\xdb\xf0\xdf\x75\x0f\x68\x81\xfc\xb7\x09\xff\x6d\xc3\x7f\xd7\xe1\xbf\x7e\x9f\xfc\xb7\xd5\x2d\x36\xb3\xa7\x4f\x19\x52\x4f\xd1\xd6\xce\x31\x0d\xdd\x8e\xa8\x38\x84\x88\x40\x90\x46\xf9\x68\xb2\xc2\xcb\xac\x16\xa8\x90\xd2\x9b\x4c\x7c\x58\xa1\x0f\x92\x84\xb1\x82\xaf\x72\x1a\x3d\x40\x74\xf9\x43\x98\x1c\xe1\x0c\xe7\x1b\xc8\xb1\x45\xb2\x41\x38\xfe\x14\x4d\x99\xe5\x6f\x32\x44\xf1\x51\x02\xa7\xb1\x51\x90\xa1\x3e\xc6\x31\x78\x07\xb0\xfb\xad\x20\x0e\xc1\x84\x2f\x8c\x42\x14\x27\x39\x33\xc3\x34\x49\x81\xe6\x7d\xe1\x90\xb8\xb9\xe8\x87\x4f\xf8\xfa\x5d\x1a\x25\xe9\x11\xb5\x00\xde\xdc\x2c\xde\x5b\x49\x87\x9b\x85\x69\x73\x6a\x76\x40\x15\xdf\xf8\x1f\x37\x38\xdc\xb4\x37\x5f\xbc\xb5\xf0\xe7\x4f\xf8\xfa\xd7\x24\x05\x23\xc6\x4f\xf8\x7a\xe5\x92\xfc\xb6\x17\x3b\x8e\x3e\x63\x56\x2a\x8b\xce\x5f\x12\x06\x84\x56\x51\xbb\x6c\x19\x09\x3f\x80\x14\x06\xc8\x04\xcb\x47\x8e\xe3\x58\x3c\xf3\x06\x97\x50\xb7\x52\x0b\xa4\xff\xd9\x60\x84\xc9\xf1\x03\x11\x11\xda\xd2\x87\xec\x28\xb9\x24\xb0\x6b\xbc\x99\x25\xb2\x4b\x3f\x2d\xed\x83\x0c\xd7\x3e\x2c\xbc\x51\x69\x9c\xa5\x77\xa7\xfa\x52\x2d\x4c\x44\x09\x3a\x54\xf4\xa0\x3f\x5f\x30\x0c\xd9\xb3\x45\x0a\x41\x8c\xec\x44\x79\x3a\x48\xd6\x72\xe4\x4f\x42\xe5\x14\xea\x9c\xd1\x91\x85\x19\x67\x6f\x2c\xac\xc6\xcd\xb0\x90\xb4\x9f\x18\xc0\x21\x9a\x8e\x3e\x94\x32\xda\x3f\x30\xc4\xff\x21\x10\x77\x62\xce\x66\xe1\x28\xc9\x11\x21\x49\x77\xa1\x5c\xde\x03\xd4\x2d\xa0\x14\xf2\xf1\xac\x5f\x05\x32\x88\x4f\x1c\xe6\x99\xb4\xb7\xc1\x87\x62\xa7\x62\x32\xda\x99\xb4\x8b\xc9\x25\xd6\x95\x02\x80\x29\x83\xcc\x5e\xcf\xc1\xf6\x20\xba\x02\xb6\x5d\x86\xed\xef\x9b\xc0\xc4\x4f\xd9\x20\xaf\x16\xd4\xf1\x05\x35\x18\xea\x96\xc9\x46\xc5\x84\x03\x69\xb1\x75\xf7\x33\xea\x12\x7e\xa6\x4d\x18\xda\xdc\x44\xed\x79\x93\xf6\xdd\x0d\xad\xbd\xcf\x8e\x11\x77\xad\x19\x83\xd6\xd9\x90\x9c\xa1\xdf\x89\x2c\x61\x2e\xa2\xb9\xdc\x5c\x96\xe9\xca\xd9\x4c\x14\x5f\xbc\xb6\x70\x1a\xe3\xb5\x9b\xd9\x90\xa2\x05\xbf\x11\x4f\x05\xcb\xe1\xaf\x1c\x5c\x47\x66\x58\x8c\x8f\x2e\x8b\x3a\x36\xe2\x85\x23\x23\x6f\xe6\x1f\x25\x44\xe3\x64\x27\xf7\xcb\x99\xda\x56\x70\xf3\x10\x7f\x81\xda\xe0\xc8\x42\x1f\xca\x68\x5f\x9d\x8b\x53\x0e\x81\x49\x9a\x0b\x76\xa4\x04\x98\x2a\x74\xab\x6b\x88\x90\xa2\x2a\x5c\x3b\x96\xd2\x19\xfa\xdd\xbd\x38\x1d\x7f\xaa\xf0\x6d\x5f\x81\x3a\x02\xad\x53\x75\x29\xda\xe7\xc0\x29\xc9\x7a\xd2\xf4\xe0\x78\x90\x5e\x4f\xa9\x65\xac\x2c\xe7\x1d\x78\x28\x19\x0e\x33\x9c\x1b\x33\x43\xd7\x48\x98\xf4\x44\xbd\xa2\xb0\x67\xee\xd5\x5e\x71\x42\x2c\x7e\xfa\xc5\xcf\x66\xf1\xb3\xe5\x01\x8b\x91\x4f\x19\x0a\xae\x21\x5e\x14\x57\xc2\x35\x2f\x83\x29\x6a\xc6\x21\xc8\x9e\xed\x7c\xe4\x10\x62\x08\x7d\x1f\x9c\x52\x30\x44\x7e\xd1\x87\x54\xf9\xa6\x96\x6d\x95\x94\x6d\x59\x8f\x44\x55\x86\x50\xa5\x55\x4f\x25\x50\xf5\xd1\x57\x1f\x9b\xea\x63\xcb\x13\x0a\x0b\x63\xf3\x5e\x5d\x45\xfb\xe4\xe4\xfb\x5d\x8c\x91\x7d\xd2\x95\x61\xb2\xce\xba\x87\xee\x46\x6e\x36\xa2\x61\x07\x82\xca\x92\xb5\x65\x60\x5f\x61\x16\x2b\x14\x2e\x24\xa9\xa8\x4e\x30\xb5\xe8\xb8\x1a\xd2\x60\x9d\xc1\xeb\xdf\x15\x66\xdb\xb0\x69\x80\x32\x5f\x9f\x0e\xad\x96\x31\x3f\x50\xab\xa9\xd6\x6a\xea\xb5\xac\xda\xa6\xac\xa5\x4f\xa7\x56\xab\x65\x53\x43\xbd\xd6\xce\x0e\xf6\xa3\xbf\xbc\x05\xda\x4e\x0c\x47\x96\x33\x8e\xd8\x7f\xe9\xa8\x6e\x22\xff\x39\xfb\xf9\x82\xcf\x10\x7b\xe1\xd8\x77\x61\x8e\xa3\x61\x0e\x94\xee\x39\x14\x65\xa5\x13\xc7\x51\xcf\xc9\xe4\x49\xea\x9a\x86\x90\xbc\x7e\x97\x14\x5d\xb5\xcc\x37\xe4\xae\xdf\x25\xa5\x56\x2d\x6b\xea\x52\xd7\xef\x92\xfe\x2a\x6b\x49\xaf\x8d\x6d\x78\x69\xc9\xb6\x01\x00\x72\xbe\x8a\x9c\xef\x40\xae\x39\x07\xb9\x56\x29\x72\x8d\x5b\x22\xd7\x54\x91\x6b\x3a\x90\x6b\xcd\x41\xae\x51\x8a\x9c\x7f\x4b\xe4\x5a\x2a\x72\x2d\x07\x72\x8d\x39\xc8\xf9\xa5\xc8\x35\xe7\x22\x67\x25\xdd\xf7\x53\xb0\x21\xca\xf2\x20\xc7\x66\x01\x60\x27\x79\xc3\xd2\x31\x60\x19\xb9\xae\x47\x83\x2f\x64\x2e\xf2\xa6\xed\x0b\x19\x88\x5c\xd7\x8e\x5b\x95\x28\xd6\xf5\x34\x87\xf7\xc1\xf2\xa9\xd1\x93\x87\xb4\x76\xf4\x53\x8b\x65\xf9\xe8\xc7\x16\x73\x05\x29\xe7\x96\x62\x09\xd5\xab\x51\x82\x58\x3f\x1c\x3b\xdf\x8d\x9d\xb9\x7e\x0c\xec\x8c\x25\xa4\x62\xd7\xb8\x0d\x76\x4d\x09\xbb\xa6\x1b\x3b\x73\x01\x19\xd8\x19\x6b\x48\xc5\xce\xbf\x0d\x76\x2d\x09\xbb\x96\x1b\x3b\x73\x05\x19\xd8\x19\x8b\x48\xc5\xae\x39\x1f\x3b\x93\x5a\x31\x0f\x6c\x6d\x97\x4b\xe8\x36\x6c\x59\x47\xba\x90\x63\x2c\x27\x75\x73\xb5\xac\x2a\x43\xf4\x69\xb9\x64\x1f\x76\x14\xde\x40\xcd\x4e\x77\xb5\xd5\x64\x1a\xe8\xba\x4d\x15\xcc\x25\x16\x21\x20\x65\xcc\x71\x98\xa9\x86\x9f\x64\x2c\x35\x14\x82\x6c\xdf\xc3\x60\x80\x85\x8e\x58\x00\xf9\x6f\x7c\x15\x4c\xa6\xe2\xa4\x5c\x7c\xe0\x73\x4a\x61\xe5\xf8\x2a\x97\x6e\xb7\x57\xb6\x76\x8e\x57\xd8\x39\xa2\x36\xe1\x16\xe9\x9f\xf0\xb5\x87\x06\xc3\x73\x21\xcd\x17\x50\xa6\xe3\x80\x20\x71\x95\x23\x1d\x0a\x93\xf0\x6b\x45\x3b\x36\x40\x4c\xa7\xdd\xb3\x28\xb1\x3f\xd0\xa8\xa9\x7b\x78\x3c\xc5\x69\x6d\x6b\x87\x5e\xeb\x53\x9d\xfd\xe3\x47\xcc\x66\x45\x6e\xf2\xf9\xe3\xc7\x10\x01\x17\x0c\x48\x14\xab\x82\x8d\x4e\xd3\xe3\x76\x09\x1b\x1d\xb0\x1d\x91\x2c\x13\x36\x3a\x6d\xaf\x30\x49\xd8\xe8\x80\x0b\xe3\x24\xec\xfc\xb8\xd1\xf5\x6f\xce\xbc\x4e\xf3\x4e\xd6\x22\xdf\xd2\x4c\xe4\xab\x19\x73\x7c\x43\xb3\x0c\xba\x12\x9e\x22\x66\x40\x41\x9a\x47\x83\x64\x32\x4d\x62\x08\xb9\x4e\xbe\xad\x3e\x7e\x24\xe6\x7d\x1c\xf5\x57\x58\xd1\x2f\x5f\x64\x03\x00\xe1\xf4\x79\xcf\xc6\x1d\x41\x86\x0b\xab\x8e\x20\xc3\xd2\xb7\x5f\x93\x34\x04\xb7\x74\x51\x40\xbc\x91\x21\xcc\x86\x60\x2f\x06\xb4\xbe\xc5\x6f\x79\x0a\x98\xd6\xcf\x0a\x66\x18\x3c\xab\x7a\x64\xa1\x4a\xef\xdf\xe7\xc3\x75\x80\x82\xe3\xc1\x0a\x79\xd0\xb0\xee\xb6\xc5\x57\xfa\x58\x66\x88\x22\xbe\xec\x5c\x4c\x5f\x6f\xef\x16\x97\x4d\xf4\xd9\x7a\x83\xd5\xcf\xa8\x79\x1e\x59\x56\xfc\x16\x2b\xc7\x93\xe9\x38\xc8\x6d\x0c\x4a\x04\x99\xfe\x23\x66\x01\x79\xb8\x06\x15\x9c\x0a\x04\xaf\x03\xbd\x5f\xf4\x19\xaf\xf0\x00\x93\x1b\xa8\x8d\x6a\x7e\x73\x1d\xf5\xa3\x3c\xab\x97\x01\x8c\x2e\x2c\xf0\xf6\x7f\xb9\x2d\xb8\x0f\x3b\x6f\x7b\x1f\x7e\xdb\x3d\x3c\x3a\xf8\x70\x70\xb8\xbd\x83\xb6\x20\xb4\x41\x1e\xc4\x39\x4a\xf1\x34\xc5\x19\x8e\xf3\x28\x3e\xe7\x8a\x18\x42\x86\x93\x24\x2c\xfa\x6e\x85\xb9\xbd\x53\x09\x26\x63\xa7\x06\x4c\xe9\x52\x50\x33\x39\x12\x8f\x76\x8a\xb2\x5c\x12\x16\xb3\x49\xd1\xed\x81\xdb\xf7\x2c\x05\x83\x07\x91\xe3\x43\x2e\xa2\x14\x97\x7a\x27\xe8\x9e\xcc\x01\x3a\x19\x61\x32\xea\x79\x82\x66\xcc\x4d\x80\xb0\x00\x44\x0a\x03\x68\x05\xe4\x6a\xf1\x30\x18\x9e\x6f\x00\xe9\x72\x5c\xeb\xf2\x8e\x6a\x60\x0b\xdb\x45\x46\x61\x33\xf2\x8b\x62\xd7\x64\xd8\xd0\xa7\xf6\x98\x12\xee\x84\xf4\x08\xf2\x9f\xf0\xf5\x8a\xb5\x2c\xf7\x0c\x1d\x0c\xcf\x51\xed\x10\x5a\x09\xc6\x75\xa8\x33\xb0\x0d\x5e\xc5\x31\x50\xdb\xe2\x71\x44\xe9\x84\xde\x10\x12\xe1\xbd\x23\x84\x32\x28\xeb\x13\x39\x57\x44\x03\xf7\x77\x55\x4a\x30\x0b\x20\x45\x5a\x90\xf7\x78\x7e\xf5\xbc\x42\xb7\xe9\x1d\x3a\xcc\x49\x5a\x63\x97\x67\x30\x84\x1e\xfa\x03\x45\x17\x1b\x28\xba\x28\x78\xe3\x8d\x62\x7a\xa0\xcc\xb7\x0a\x69\x43\x09\x0b\xc5\x24\x07\x5d\x03\x20\x27\x0e\xa1\xf5\xd9\x8d\xb3\xba\x56\x2d\xb2\x87\x2e\xa1\x55\xa4\x27\xc7\x42\x7c\xa0\xa7\xfb\xa5\xa7\x6d\x7c\x5f\xf4\x24\x20\xdd\x8d\x9e\x54\x3e\x7d\x0b\x7a\xda\x8f\xa3\x3c\x0a\xc6\xd1\x67\x9c\xa1\x00\xc5\xf8\x72\x7c\xcd\x30\x0c\xd9\x70\xcc\xa7\x25\xbe\x6b\x5c\x0d\x93\x74\x72\x90\x84\x18\xed\x50\x5f\x35\x08\xd3\x5c\x70\xba\x24\x95\xe9\x14\xac\xab\xc1\xcd\x8f\x53\xad\xd8\x64\xec\x64\xf8\xdd\x91\xec\xbd\x91\x55\xcd\xfc\x60\xe3\x14\xb7\x24\xb8\x28\x8e\x14\x0b\x1b\x31\x4d\x12\xb9\x58\x54\xd4\x5b\xd3\x29\xa1\x05\x18\x2d\x9e\x98\x3a\xb3\x5c\x33\x90\x21\xde\x14\x3f\xf9\xa6\x48\x69\xd0\x3c\x15\xe7\x44\x72\xa6\x86\xf5\x49\x3a\xa1\xd3\x1e\xd8\x74\x37\x94\xbe\x0b\x92\xda\x2c\xc8\xeb\xb9\xad\x24\xb5\xa3\x01\x5b\x19\xeb\x59\x3c\xa2\x84\x4e\x3d\x00\x6c\xfd\x00\xfb\xa2\x5a\xe5\x85\x03\x36\x3a\x2a\x1f\x86\x58\x0e\x99\x68\x09\xb4\x67\x77\x24\x1f\xb6\x04\x4d\xdc\x94\x19\x4e\xab\x18\x51\x51\xa3\xa2\x30\xc8\x03\xd4\x07\xd9\x4b\x2d\xe1\x90\xc7\x00\x34\xcd\x74\xc1\xbd\x9d\x75\xc0\xef\x70\x0a\x73\x39\x48\xe2\x41\x8a\x73\xbc\xcc\x86\x63\x9c\x9c\x2b\x4c\x59\xba\x97\x3a\x5a\x6c\xac\x21\x9e\x06\x60\x4e\xdd\x5b\x18\x4f\xc1\xa1\xc4\x52\x70\xb8\xc0\xa6\xf7\x25\x63\xae\x30\x04\x28\x53\x76\x12\xde\xc0\xdb\x60\x0d\x48\xe0\x2b\xec\x5c\x12\x7f\x12\xb0\x68\xd0\x2c\x16\x8c\x20\x8a\xcf\xef\x81\x9b\x14\x9d\xdf\xe4\xe4\xc1\xe0\xd7\x9e\x90\x36\x9f\xa8\x64\x52\xa5\xde\x25\xc7\xdc\x49\x61\xac\xe4\x86\x16\xe5\x95\x0e\x9d\x83\x7b\xe0\x38\xb4\xcd\x7e\x00\x5f\xe4\xea\x36\x9a\xa2\xed\xa1\xe0\x22\x88\xc6\x41\x7f\x8c\xa9\x19\x62\xe6\xde\x16\x3f\xf0\xce\x54\xa6\xaa\xdd\x28\x66\x1b\x5f\xe9\x3e\xc5\xe0\xaa\xfb\xcc\xdb\x24\x67\xde\xd1\x34\x68\x1a\x85\x54\xec\x1a\x28\xca\x10\x1e\x0e\xf1\x20\x8f\x2e\xf0\xf8\x1a\x05\x28\xc4\x59\x9e\xce\xe0\xd9\x43\x29\x0e\xc2\xe5\x24\x1e\xe0\x4a\xfb\x4c\x55\xea\x05\x34\xbe\x16\x0d\x53\xe0\x5f\x9b\x92\xf9\x48\xd6\xaa\x13\xb1\xa8\xb2\x28\xf5\x8b\x8a\xf3\xc9\x9f\x17\xad\x4e\xff\xbb\xc5\x5c\xcc\xa0\x90\x5a\x22\x1a\x96\x02\x40\xa5\xab\x45\x29\x6a\xb9\x28\x59\x80\x21\x43\x3c\x24\x82\x2a\x5b\x70\x38\x64\xf1\x32\x39\xa7\xde\x95\x26\xc4\xba\xf8\xcc\xda\x73\x95\xcd\x7e\x73\x7d\xb5\xd5\x94\x3f\x51\x95\x88\xed\x8b\x26\x07\x6d\x20\x5f\xf9\xaa\xca\xbf\x1b\xa8\x59\xe5\xec\x94\x59\x55\xd9\xc1\x7c\x45\x36\x72\xae\x4d\x7e\x6a\x61\x23\x7d\x32\xc2\x92\x50\xc0\x12\x6d\x05\x68\x04\x5a\x63\x22\x64\x56\x58\x8a\x5c\x84\xdd\x8a\x39\x3e\x10\x60\x80\x2f\x6b\x22\x34\xb1\x75\x6d\xe9\xd0\x37\x38\x2c\x31\x6b\x6f\x53\xe5\xa9\xe9\xc8\x0d\xd9\xd6\xb9\xca\x94\x7a\x1b\x4e\xbf\x29\xf2\x27\x3e\x65\x78\x8c\x07\x39\x6d\xf8\x38\x4f\x83\x1c\x9f\x5f\xd7\x5c\xe6\xda\x92\xf6\x19\xc4\xc5\x4d\xf4\x84\xb2\xd2\x27\x4e\xf3\x30\x36\x1b\xef\x82\x2c\x23\x6c\xe2\x65\x90\xe1\x50\xf1\x98\x93\xff\xca\x8d\xc3\x18\xa8\x63\x9c\xc2\x81\x8b\xec\x6a\x6e\x48\xe5\x8b\x5c\xcf\xed\xc7\xee\x33\x4a\x6c\xd4\x5d\x48\x31\x72\x92\x19\x9b\x79\xc3\x52\x66\x37\x5a\x04\x01\xb3\xcf\x83\xb8\xb8\xa1\x28\x7a\xc8\x7d\x81\xa3\x8f\x81\xe7\xb0\xf4\x64\x64\xbf\x61\xf4\x5f\xbb\xcf\xb9\x13\xda\xea\x4d\x91\x87\x4a\x6f\x8c\x74\xcc\x2d\x13\xaa\xb3\x6d\x99\x4b\xd6\xea\x4c\xc3\x6b\xbf\x7a\x53\x75\xd8\x59\x9e\xe2\x60\x72\x2b\x55\x36\xc8\x50\x4c\xf9\x2c\xdb\xe0\xb7\x9a\xcb\xfd\x88\x1a\x6c\xab\x27\x1a\x2a\x9d\x40\x18\x6b\x49\x33\xed\xa3\x5a\xab\xa9\x2a\xa6\x25\x85\xef\x31\xe0\xa7\xa9\x7d\xf5\x97\x25\x1e\x21\xbb\x96\xbd\xd6\xb6\xc3\x72\x11\x71\x1a\xa4\x70\xdc\xb2\x09\x88\xe6\xf6\x06\xc7\x9b\xc2\xba\x8a\x0b\x8d\x3f\xfc\xf0\x64\x38\x9e\x65\xa3\x27\xd5\xb6\x39\x0a\xc5\xb5\xd1\x89\x61\xde\x40\x7e\xd9\xbc\xc2\xb9\x16\xb2\x9a\x4e\xe5\xdb\x52\x59\x79\xfe\x61\x42\xcf\xbe\xbd\x15\xf6\xe3\x8f\x9b\xf9\x14\xa2\x78\xec\x40\x3d\x83\x4a\xa4\x36\xa4\xdb\x4d\x76\xd0\x36\x9c\x83\xd9\x7b\x59\xe9\x5d\xa6\xa0\x97\x55\x94\x13\x9e\x9c\xab\x90\xaf\x17\xde\x4d\xb7\xd4\x1e\x59\x15\x82\x7a\x66\x99\x42\xc1\x0f\x54\xfd\x0d\xf6\x43\x3e\x53\x7c\xbb\x03\x3d\x6c\xef\x65\xcf\x50\x45\x73\x8e\x12\x5d\x50\xaf\x9d\xdb\x68\x9e\x0b\x18\xa5\xba\x42\x51\x97\x2b\x9a\xa4\x7a\xb7\xd2\x38\x8b\xe9\x2c\x0e\x48\xff\x99\xd3\x59\x68\x82\x17\x9c\x4e\xab\xe2\xb7\xe2\x74\x8a\xba\x77\x98\xce\x32\x85\x6f\xb5\xab\x83\x6f\x3a\x9d\x77\x9e\xae\x92\x25\x30\x67\xbe\x74\xbd\x69\xc9\x24\xd1\xcd\x44\xe8\x79\x07\x36\xb1\x8e\x59\x5d\x5f\xa0\x4d\x14\x5d\xc8\xb3\x55\xb6\x45\xb0\x1d\x93\xc6\x95\xee\x8d\x82\x28\x86\x94\x27\xae\xbb\xd6\x97\x60\x37\xf0\x81\x77\x1e\x6d\xba\x83\x0f\xe8\x2a\x36\x65\x07\x21\x75\x0d\x62\x90\x86\xa6\x68\x4c\xdb\x25\xc4\x9d\xe8\xf3\x32\x8e\xf2\xb2\xc7\xb7\x03\xed\x24\x24\x35\xa1\xcc\x1d\xe9\xd5\xcb\x9e\x65\xef\x31\xc1\xd3\x26\xde\x89\xf0\x9f\x39\x57\x63\x50\x2a\x0d\x72\x66\xd4\xbd\xa2\xd7\x31\x60\x68\x34\x4b\xa5\x23\xa1\x15\x61\xc2\x52\xc2\x65\x24\xa4\x72\x42\x64\xbd\x21\x61\x76\x59\x04\x08\xfb\x79\x39\xc2\x2c\xf2\x3e\xc5\x0f\x02\x79\x66\x15\x90\x33\x17\x86\xbd\x20\xf9\x83\xa9\x64\xa2\x0e\xf5\x06\x80\xf4\x78\xd0\x05\xe1\xda\xa0\xcb\xb2\xf2\x64\xa0\x42\x05\x68\x98\xc9\xab\x50\x9c\xb6\xd0\x56\x07\x58\xa4\xdf\x90\xc8\x0b\xc9\x61\x38\x5b\x08\xb1\x42\x93\x23\x5e\x39\xcc\x59\x7f\x3b\x3c\x82\xf3\x32\x23\x3a\xb3\xcc\x55\x92\x42\xbf\x0a\x45\xb7\x87\x94\x7e\x79\x45\xb3\x36\xa1\x9f\xe1\x21\xfb\xba\xd4\xf4\xd1\xb5\x62\x76\x84\x27\x18\xa4\x70\xd8\x5d\x29\x09\xb0\xab\x28\x38\xed\x83\x43\x3b\xbc\x36\xab\x73\x09\x16\x5f\xf0\xb0\xf3\x94\x99\xd2\x7c\xf2\x1c\x6f\x61\x0a\xe8\xec\x80\xec\xb9\x33\x77\xdd\x86\xb8\xc2\xba\x15\xfb\xd4\xc3\xba\x7d\x58\xb7\xe8\xf6\xeb\xf6\x2e\xab\x03\x2c\x84\x47\x51\xb6\xf0\xda\xb0\x62\xc2\x28\x1a\xb8\xc8\x6f\x87\x47\x4e\x0e\x20\x7b\x90\x19\x1c\xe0\xae\x6c\xc7\x8a\xd9\x49\x31\x34\x7d\x3c\x48\x26\x6c\xe9\x10\xb6\x10\x25\xb3\xac\x3a\xf3\x10\x83\x55\x95\x3d\x08\x52\xe2\xdd\xa8\x39\x71\x5f\xc8\x03\x0a\x44\x24\x2e\x2d\xd9\x3c\xfc\x47\x49\x92\x61\x34\x89\xae\x88\x2c\x64\xe9\x1f\x78\x82\x9a\x42\x1a\x92\x09\x91\x49\x61\x2e\xb2\x4b\x2e\x40\x3a\x25\x27\x9d\x6c\xd6\xcf\xf0\xff\xce\x70\x9c\x5b\x55\x0c\x48\x15\xed\xa4\xac\x1e\xea\x28\x3a\x55\x83\x32\x4a\xda\xac\xcc\x57\xf5\x93\x9d\xcd\x86\x95\x2d\x46\x52\xb1\xda\xac\x91\x92\xc8\x1f\x4c\x60\x61\x3d\x1e\x9d\xa1\xdf\x37\x69\xbd\xd3\xa8\x34\x74\x49\xf1\x9b\x9b\x40\xbf\xec\xb1\xf2\x4a\x40\x13\x49\xb4\x7d\x17\x84\x21\x99\xc0\x39\x0a\x90\x29\x64\xb9\xea\xad\xd0\x7f\xed\xea\x8f\x77\xaf\x7b\xc7\xe8\xff\x74\x56\xd7\xd0\x94\x01\xcd\x98\x2e\xcf\x06\xf3\xdd\xa7\x41\xb6\x06\x72\xf2\x34\x08\x57\xf8\x53\x89\x6c\xfc\x2e\xe0\xd7\xcf\xb3\x8c\x87\xce\x17\x81\x50\x98\xb9\x32\xc4\x4d\x16\x78\x2c\x64\x7f\x05\x90\xe5\xdb\x67\x82\x96\xb5\x92\x5d\x8f\xc7\x42\x40\x49\xf7\x91\x00\x28\x13\xc1\x2c\xc9\xa0\x40\x38\xcb\xaf\x7c\x6c\x16\x87\x2f\x31\xae\xe4\x57\x71\xbd\xe6\x69\x71\xb3\x94\x0b\xe6\x20\xd4\x2f\xd7\x6e\xcd\x40\x44\x35\x1a\xeb\x64\x53\x1a\x2f\x57\xcc\x90\x59\x9c\x0b\xda\x01\xbf\x22\x13\x6a\xcc\x08\xd6\x00\x4a\x5f\x2c\xd3\x94\xd3\x22\xc2\xca\x3f\xb4\x02\xb6\x66\xe9\xbd\x10\x6f\xd7\x0c\xbd\x40\x33\xbd\xc1\x57\x42\x2f\x10\x01\x45\xc1\xa2\xf0\x75\x31\xde\x33\x07\x17\xe3\x3d\xb8\xb5\x28\x6f\xe7\x62\x56\x8a\x54\x56\x1e\xbe\xa0\x60\x3f\x6a\x9b\x28\x42\x4b\x2e\xb7\x7c\x19\x3a\x0d\x73\x2f\xbd\x29\x91\x5e\x35\xec\xd0\x66\x61\xfb\xce\x0f\xff\x32\x68\x4f\x45\xc9\x66\x86\xb0\x15\x86\xf6\x41\x80\xb9\x1e\x24\xf1\x20\xc8\x39\xcc\xca\x1a\x98\xf7\xf1\x54\x30\x14\x58\xb2\xa3\x20\xa4\x81\x8c\xd8\x42\xfd\x36\x5c\x66\x16\xeb\x7c\xe6\x9b\x70\x04\x68\xb6\xc2\x95\x3b\x94\xd3\x59\x82\x8d\x0f\xbc\xc2\xb9\x92\xb8\x58\x5a\xc4\x10\x03\x16\x8d\x83\x2c\x87\xe7\xf9\x6b\xba\x10\xaf\x4f\x6b\xea\x72\x5e\x46\x7e\x9d\xba\x98\x9d\x31\x67\x30\x9b\x27\x31\x15\x1c\xdc\x14\x53\x80\xdb\xd4\xd7\xa0\xb4\x99\xd2\x6d\x73\x41\x3d\xff\x9f\x71\x11\x64\x73\x51\xb0\xdf\x2c\xd8\x6e\x15\xca\xee\x81\xee\xcf\xe8\xff\x20\x09\xf1\x0d\x55\x0f\x9e\x88\xd3\x1a\xbd\x14\x81\x93\x84\xd4\x9d\xde\xcb\x9e\x0b\x0a\x9b\xab\x1b\x41\x5f\x04\x96\x2e\x6c\x98\x10\x81\xe4\x1d\x04\x0e\x7e\x04\x6c\x00\x24\xc3\x49\x8d\xc0\x09\xa6\x80\x99\xa7\x9d\xea\x68\xdb\x46\x13\x37\x8a\x37\xc2\x02\x86\x81\x74\xa2\xd5\x8f\x3d\xc9\xfa\xb0\xdc\x06\xb0\x24\xc0\x99\x6a\x1f\x6a\xf1\xe3\x04\xb9\x99\x8c\x80\xa2\x16\x45\xaa\x62\x97\x7c\x9f\x80\xed\xa7\x03\xff\x62\x62\xcd\xc3\x80\x61\x4b\xca\x25\x6d\xd5\xb8\xc4\x79\x62\x20\x50\x61\x4b\x04\x8d\x06\x9c\xca\xb5\xbb\x19\xbb\xb4\xbf\xfa\xb4\xbc\x79\xd5\x7a\xa5\x8e\x9e\xae\x2e\x8c\x81\x50\xb5\x38\xce\x32\xaf\x31\x9e\xa2\x20\x47\x63\x4c\xb8\x60\x12\xf3\x15\xc0\xb2\x7c\x50\x4b\x50\xd8\xaf\x81\xe1\x9a\x7c\x0b\x89\xf3\xcd\x24\x8a\xa9\x91\x28\x3b\xc4\x1b\xe1\x12\xd5\x47\x56\x89\x4e\x9f\x84\x3f\x25\xa4\x09\xd8\x1f\xd3\x23\x6f\x74\x81\x7e\xfa\xc9\xaa\x8f\xd7\x03\x75\xbc\xbb\x95\x2e\xa3\xc0\x44\x55\xa6\x38\xcf\xe7\x7a\xb3\x55\xaf\xa4\xdd\x22\x69\x21\x92\x08\x43\x69\xf6\xca\x42\xd0\xbc\xb9\xfb\x25\xe4\xd5\x55\x72\x90\xa1\xe9\xbe\x5c\x22\x17\xc8\xeb\xcc\xf4\x0b\x24\x70\xf8\x3d\x57\x07\xc1\xaf\xe2\xa9\x8d\xa0\xeb\x94\x7c\xab\xcb\xf8\xaf\xb7\xac\xbe\x2e\xde\xd6\xf6\x40\xf2\x9b\x33\x03\x54\x3e\xb2\xb5\x37\xcf\xf2\xef\x8e\x96\x0a\x60\x7a\xc7\x64\x0f\xbb\x19\x0a\x1a\x24\xe3\x31\xa6\xf4\x9f\x0c\xb9\x68\x00\xa2\x26\x86\x5c\x7a\x65\xa2\x87\x24\x8a\x4a\x4e\xde\x64\x1b\x4d\x83\x4b\xe9\x95\xd5\x2f\xd1\xee\xfa\x41\x1d\xd0\x85\x90\x52\xa5\x76\x71\xf1\x08\x19\x1e\x18\x17\xa4\xf5\xc9\xfa\x34\xcc\x71\x5d\x80\xb2\x60\x4c\xb1\x87\x1f\x00\x0c\x54\x92\x01\x0d\x3f\x8a\xd3\xe8\x82\xca\x2a\x9c\x63\x58\x01\xf2\xab\xd4\x42\xce\x97\x2c\x07\xcd\x58\xab\xd5\xe4\x9a\xdb\xf4\xac\x5c\xbe\x19\x8c\xf0\xe4\x76\x70\xed\x02\x27\x53\x99\x83\xc5\xf4\x50\x82\x67\x05\x41\x73\x32\xde\x14\x39\x1b\xe9\x29\x86\x8a\x58\xfc\xad\x2e\x86\x0d\x92\xf8\x02\xa7\xb9\x22\xc3\xd2\x6c\x77\xdc\x98\x12\x2c\x3e\xa9\xf5\x9f\xdb\x6d\xf5\x1d\xad\xa2\x3a\xaf\x8a\x97\x15\xed\x61\xe6\xbb\x58\xa9\xa8\xcd\x3f\xd6\x09\xef\x26\x19\x1f\xcd\x4e\x34\x88\x45\x12\xab\x69\x92\x65\x51\x7f\x8c\xdd\x2b\xd6\xd2\xd4\x62\xce\x4d\xc5\x40\x99\xf6\xa0\xf4\x1b\x3f\x81\xff\x61\x40\x41\x42\x7d\x4e\x56\xf0\x86\xf4\xbb\x70\x78\xb2\x56\xfa\x84\xaf\x37\x54\xbf\x28\x6b\x31\xcd\x53\xca\x5e\x88\x2c\xe3\x0d\xf8\xef\x9c\x82\x62\x55\x6e\x98\xee\x5c\xf6\x1a\x4c\x84\xd7\x2d\x13\xec\x85\x85\x5c\xaf\x1e\x9d\x5f\xf7\x8e\xd7\xec\x15\x24\x16\xde\xb6\x97\x10\x0b\x47\x02\x4a\xdf\xad\x1c\x4e\x71\x7c\x7c\xfc\xc6\xa8\x56\xdd\x99\x4c\x9e\x7e\xbb\xe0\x35\x89\xae\xf6\x63\xb5\x5c\x65\xd3\x23\xba\x8a\xb3\xc5\x96\x31\x72\xae\x1b\x93\x95\x68\xbe\x81\x0e\x6e\x42\x0e\x75\x6e\xe0\xdc\xc0\x96\x7b\x65\xc0\xae\x00\xbf\xa3\x61\xa4\xaf\xf1\x12\x38\x90\x04\x2c\xa3\x19\xc0\x20\x7b\x1c\x2e\xbc\x28\x0b\x8c\xe3\x84\xbe\xd1\x18\x20\xcb\xd9\x8f\xcb\xb8\x47\xd5\x25\x4d\x91\x17\xd7\x74\x6c\x6d\x2f\xa1\x27\x4f\xec\xbe\x15\xd6\xf2\x2b\x79\x42\xf3\x0d\xb9\x5c\x39\xe6\xd4\x72\x90\xaa\x93\x30\x79\x45\x99\x38\xc5\xd8\xb8\xac\xaa\x8a\x12\xe8\xcb\x17\x4a\xae\x45\x9d\x15\x3e\x89\xd7\xfc\xd8\x6b\xe8\x68\xac\x72\x12\xa5\xb2\x79\xf7\x1a\xb4\x1d\xb8\xda\x10\x3f\xed\xb7\x1b\xac\xe7\x36\xe2\xb4\x81\x66\xc5\x45\x2a\x63\xd8\xbd\xd4\x41\x2c\xbf\xee\x10\xab\x2e\x70\x2f\xb9\x98\x37\xb3\x3c\x48\x26\xd3\x20\x87\xed\xa5\xea\x32\x94\xb7\x05\x6d\x13\x93\xc4\x9f\xaa\x7b\xa2\x6d\xf9\xdd\x06\xb9\xfb\x32\x1c\x4c\x68\xdb\xc7\x9c\xbc\x1d\x84\x2c\x51\x97\x8b\x37\x2a\xf4\x2d\x8a\x57\xe6\xbe\x73\xd4\x32\x72\xa4\x25\x65\x09\x16\x5f\x6c\x81\x1a\x89\xb8\xab\x55\x20\xef\x6c\xc7\x58\xe8\xaf\x79\x88\x25\xc5\x9d\xaa\x96\x4b\x29\x5a\x8d\xa1\xbd\x3f\x6d\x5c\x75\x5a\x5d\xbf\x3b\x58\x83\xc4\x06\xdd\x4e\xb7\xdd\x19\x76\x86\x67\x75\xae\x8a\x07\xd0\xfc\xa1\xe8\x87\xe3\x1c\x59\x01\x05\xe7\x58\x38\x0e\x5f\xa2\x6e\xc1\xc8\x68\x58\x9b\xc5\xf7\xbc\xb2\x35\x26\xfb\x2b\x2d\x2a\x3c\xf2\x75\x52\xd0\xe9\xad\x97\x8c\x1a\xb3\x81\x2f\xe8\x5b\xac\xe1\xfb\x0d\xe0\x60\x0a\xa3\xda\xd2\x9b\x06\x69\x86\x6b\xca\x42\x2d\xb9\x98\x4c\x33\x45\xf1\x53\x54\xb3\x7a\x25\x90\xe2\x88\xc6\xf0\x9a\xb3\xe8\x28\x61\x18\xc8\x94\xa9\x57\xcb\x20\xf2\xcb\x38\xe9\x30\xcc\x92\x42\x18\xe0\x4e\x70\x96\x53\xdb\x86\x60\x6c\x59\xa0\x1a\xcc\xd3\xc6\x19\xda\xdc\x44\xc5\xda\x43\x3f\xfd\xa4\xb7\x7b\xea\xb3\x32\x7c\x4d\xba\x54\x50\x3b\x57\xf4\x02\xc3\x6c\x19\xa9\x1c\xc6\x58\xfc\x5a\x8b\xcc\x94\xa7\xe9\xa1\x76\xbd\xc4\xba\x2e\xb9\x60\x47\x74\xb8\x0a\x2a\x60\x98\xe5\x0d\xf8\x53\x68\xa0\xa1\xdf\x5a\x1b\xc5\x95\x5b\x1d\xbf\x5b\x8d\x51\x58\x8f\x46\x8e\x63\x90\x27\x9d\x4e\x54\xd1\xbc\xf4\xae\x88\x2f\xc2\xcb\x34\x98\x4e\x41\x8e\x0c\x72\xd6\xbc\xac\x32\x41\x01\xd9\xe9\x33\xc9\x2b\xad\x74\xf5\x2a\xae\x3e\x86\x2b\x5b\xe1\xf0\x63\xfb\x54\xd5\x81\xe4\xd6\x97\x3d\x42\xe8\xe1\x32\x7e\x99\x54\xcf\x75\x04\x72\x6f\x59\x67\xa9\x43\x68\x1c\x52\xaa\x11\x07\x8c\xe2\x62\xc7\x72\x70\x2a\x0b\x11\xa5\x7b\x2f\x02\x42\x1b\x86\xa8\x26\x4d\x6c\x69\x50\x29\x76\xed\x40\xe6\x8d\x79\xd3\xdd\xc5\x43\xb5\x50\x3e\x59\x8e\x3a\x25\xde\xe7\xac\x69\x6a\x83\xc2\x7e\x17\x7e\xe7\x7f\x91\x18\x2e\xf6\x2d\x6c\xeb\xcf\xdd\xc0\xc8\xb2\xb4\x6b\x54\xcc\x65\x25\xfc\x2b\x4d\x6d\x84\xe2\x6a\xe9\x38\x85\x7d\xbd\x06\x8b\x20\x35\xba\x3a\xe1\x9b\x36\xee\x89\xd5\xe6\x90\x06\x4a\x94\x1d\x16\xe7\x58\xb7\x17\xeb\xed\x42\xe8\x2c\x14\x3d\x67\xc7\x66\xbf\x2e\x45\x37\x48\x0a\xe7\x13\x5b\x00\x34\xab\xcf\xaa\x21\x96\x14\x9e\x19\x22\x40\x02\xeb\xec\x6d\x24\x93\x1e\xf4\xaf\x80\x09\x57\xc0\x06\x14\x66\x6f\x44\x38\xae\x70\xcc\x75\xed\x47\xd5\xb7\xd3\xb2\x4d\x5b\xd9\x5f\xcd\x82\x5c\xb5\x68\xf9\x44\xc8\x4a\xf4\x6d\x25\xba\xb0\x14\x91\x74\x84\x8c\x5e\xcc\x32\x54\x2b\x58\x00\x82\x0b\x51\xb3\x98\xd0\x07\x16\x25\xd9\x2b\x4b\x61\x49\x17\xa8\x5b\x58\x5b\x4a\x4b\x7a\x41\x42\x7a\x43\xcb\x71\xed\xa6\xf2\xb1\x85\xdd\x43\x67\x62\xe2\x84\xe2\x4b\xbe\x96\x41\x5f\x6d\x7b\x92\x09\x40\xec\x50\xda\x45\x93\xf4\x08\xa9\xbd\xff\x8a\xfb\x94\x16\xa0\x45\x44\x3a\xfe\x06\x7b\x53\x11\x55\x79\x3e\x9b\xe6\xde\xf3\x16\x36\xcd\xc9\x8e\x85\x51\x90\x3c\xea\x6f\xcd\xb2\xef\x1b\x45\x7d\x5f\xba\xc7\x2d\xc5\x19\xbb\xc0\x11\x61\xe0\x1b\xec\x2a\x4c\xe3\x20\xa9\x16\xe4\xc5\xa4\x01\x96\x77\x0a\x76\xfb\x0d\xe7\x57\x19\xf9\x82\x9b\xd8\x9a\x63\x9c\xc2\xdc\x30\xe4\xc9\x53\x36\x31\x25\xea\x22\x1d\x96\x62\x6f\x92\x98\x8c\xa2\xf0\xb1\x6e\x13\xa2\x89\x85\xb5\x31\x56\xb6\xa6\x8f\x95\x7a\xff\x02\x3a\xa6\x20\xcb\x66\x13\x1c\xaa\xf7\x89\xc1\x38\xc5\x41\x78\x2d\xed\x77\xca\x81\x6c\x16\xd3\xb4\x95\x15\x22\x9a\x2d\xc6\xf6\xec\xfc\x6b\xa1\x43\x13\x61\x5c\x60\xa2\x9e\x66\x78\x61\x5e\xef\xd6\x17\xcd\xe2\x45\x61\xfd\x89\x12\xb7\x41\xf2\x54\x85\x74\xc8\xa9\x00\x09\xe2\xb7\xf3\x80\x0f\x86\x4e\x49\x5e\x3d\xac\xb2\x2d\x95\x37\x8b\x5d\x23\x2f\xc2\x39\x21\x6c\xb8\x4d\x08\x65\x4f\xe6\x52\xd5\x2f\x36\x50\xa9\x76\x94\x41\x2b\x51\x8a\x1a\x9a\x09\xeb\x0d\xc9\x6b\xbb\x89\xc4\xbc\x2b\x93\x4f\xe1\x10\xee\x4b\xe8\xbf\xe5\x97\x25\xf3\xac\x30\xcc\x0b\x93\xd7\x14\x3a\x69\xa5\xda\x3d\xc9\x36\x01\x0f\x77\xfa\xa4\x31\xb2\x96\xf7\x7f\xe1\x0a\x83\x29\x8b\x17\x54\x5d\x1d\xcb\x6b\x30\xcb\x0b\xf6\x00\x72\x0a\x69\x06\x00\x97\x7b\x85\x14\x81\xca\x31\xb5\xad\x88\x62\x66\xc9\xcb\xec\x00\x98\xc9\xcc\x39\x8e\xc1\x98\xb7\x1c\x9a\x88\x52\xee\x00\x46\x43\x67\x97\xc3\x32\x75\x06\xa0\xc2\x92\x84\xa4\x2d\xd4\x6d\x83\xc9\x31\x7c\xe0\xf6\xb3\xfb\x43\x94\x4c\x22\x22\x23\x78\x28\xa0\x9f\x2e\xa3\xf1\x18\xf5\xb1\x68\x30\x44\x69\x10\x87\xc9\x64\x7c\x7d\x4f\x87\x7b\x6a\x35\xc1\x86\xc9\x43\xfb\xbf\x78\x30\xa5\xa4\xf1\x6f\xc0\x85\xe8\x24\x87\x26\x0b\x92\xa8\x71\x05\x5f\xe1\xc1\x2c\xc7\xb5\x27\x3c\x1a\xd5\x13\x8f\x25\xee\xf0\x98\xf9\x96\x43\x2c\xba\x27\xe8\x1e\x7a\x42\x86\x83\xfc\xff\x13\xf7\x99\x99\x82\x91\xb9\x1b\xa7\x66\x8f\x93\xa8\xc7\xa8\x8b\x2a\x36\xed\x46\xfd\x74\x9a\xd9\x2c\x3b\x14\xd5\x3f\x38\xaf\x92\x0c\x25\x32\x85\x53\xeb\xb6\x57\x8d\xb4\xe6\x16\xb7\x3a\xba\xb4\xa5\x75\x6d\x4a\x2b\x34\xde\x2c\x4d\x3c\x50\x28\x70\x45\x8c\xbb\x22\x0d\x32\x5b\x48\x37\xf5\x15\x96\xc8\x5b\x1a\x0f\xc0\xdf\x1a\xb0\x96\xd0\x66\x5e\x8e\x01\xd8\x4d\x1b\x6a\x72\x91\x0c\x9a\x29\xc8\x79\x32\x59\x3e\xe6\xe8\xa9\xa9\xcf\x56\x52\x43\x17\x29\x9c\xed\xce\x52\x47\x4c\x94\x5a\xf0\x30\x5e\x1c\xa9\x85\x14\x7d\x3b\xad\xb6\x4d\x33\xa0\xa8\xb8\x43\xc6\x97\x39\xcb\xd3\x58\xb2\x27\x60\x39\xc4\xaf\xdb\xeb\xc3\x2d\x51\xe2\x84\x42\xdc\xfe\xcd\xa6\xe1\xfa\x8a\xfa\xf1\xd7\xdb\xbb\x37\x88\x6c\x9f\xdc\x82\xd2\xb6\x0b\x17\x52\x1e\x67\xb6\xe5\x5b\xdc\x42\x5a\x71\x4b\x87\xdd\xce\x0f\x9f\xc2\xe1\x86\xb4\x3d\x4b\x14\xb2\xa0\x7a\x9c\xb9\x54\x2d\xb2\x2f\x7f\x1f\xfa\xf2\x52\xe9\xe0\x3b\x50\x47\xfc\x45\xd4\xe6\x96\xc5\x57\x49\x93\xfc\x84\x0f\xb5\x2b\xac\xec\xd7\x6f\xd8\x43\x7f\x7c\x65\x0d\x76\xb1\x1d\x7d\x23\x85\x83\xb6\xbb\x26\xb9\x4b\xb9\x6b\x93\x5d\x08\x78\x22\xb6\x70\x71\x45\xc2\x9e\x0e\xaf\x90\x31\xd8\x33\xdd\xf6\x5c\xde\x9d\x54\x8c\xa5\x7d\x33\xba\xb4\x02\x5b\xac\x82\xc1\x8a\x35\x24\x81\x53\x31\xaf\xe8\x4b\xdc\xd7\x19\x72\x00\x08\x63\x7e\xd4\xf6\x25\x3d\xbe\x81\xc6\x41\x74\x45\x93\x81\x40\x05\xeb\x90\x4a\x67\x6b\x6a\x98\xa9\x40\x77\xe9\x4d\xac\x27\xbe\x3b\xe8\x83\xff\x04\x7e\x7c\xcf\x0a\xe2\xef\x9d\x31\x7f\x8f\x7a\x62\x1b\x33\x5c\x54\x51\x7c\x27\xc6\x78\xef\x28\x9a\x8a\xe2\xfb\x62\xdc\x15\xf5\xc4\xdf\x9c\x77\x7f\x73\x65\xf1\xb7\xdf\x2a\x3c\xc5\xb6\xc7\x71\x42\xbb\xbf\xbd\xa3\x92\x3e\xdc\x7d\x7f\x61\xdb\x3a\xe4\xf1\xad\xb8\x7b\x94\x29\xc8\x0b\x55\x9e\xc8\x74\x29\xa7\xb4\x64\xf9\x2b\x6f\xce\xbc\x4e\xeb\x7b\x4d\x4a\x79\xef\x39\x28\x17\xcd\x3d\xa9\xe4\x9c\x34\x10\x33\xd3\x4f\x6a\x69\x27\x79\x45\x47\xe2\x49\xd0\x8f\x16\xc0\xc5\x4f\x35\xf9\xe4\x41\x90\x8f\x3c\x64\x49\x41\x59\x1c\xaf\xdf\x24\x83\x60\x8c\xa6\xc9\xf8\x7a\x18\x8d\x51\x32\x44\x74\xd3\x62\xa7\x78\xcb\x91\x97\xc5\xb6\xdf\x54\x0b\x6a\x0d\x2b\x8c\x49\xbc\xde\x25\xef\x6f\x9e\x9b\xb1\x83\x24\x5b\xcb\xfe\x47\x83\xa9\x81\x8d\xe0\xac\x4f\x66\x50\x27\xe2\xdd\x95\x69\x9a\xe4\x09\xf9\x84\x36\xc9\xe9\x43\x2f\xc0\xea\xa1\x4d\x14\xe3\x4b\x82\x40\x39\x84\x78\x36\x1e\x3b\x16\x8a\xc0\xa0\x58\x26\x52\xbc\x23\x5b\x24\x4f\x3e\x27\xe5\x4a\x6e\xa7\x62\xfb\x4d\xd4\x4f\x83\xf4\x7a\x9e\x8e\x5c\xca\x0f\xea\x04\x05\xd9\x42\x99\xd6\x93\x08\x17\xbc\xcb\xc1\x18\x45\xf1\x08\xa7\x91\x12\xc0\x55\x89\xe8\xa0\xe7\x19\x35\x23\x8c\x9a\xd3\x59\x21\xec\x1f\x8f\x31\x0c\xee\x71\xc2\xcf\x60\x14\xe4\x1c\x21\x16\xca\x83\x8a\x41\xc6\xa9\x12\xa1\xb2\x38\x80\x5c\xee\x4a\x2e\x70\x9a\x46\x21\xce\xd0\x3b\xaa\x10\x89\x70\x46\x19\xf8\xf4\x1a\x45\x31\xcb\x66\x5c\x20\x50\xa1\x05\x3d\x57\xc3\xc9\xa2\x00\x0c\x99\xcb\x51\x6e\x91\xa8\x81\x64\xa2\x0e\xae\x4f\x28\x09\x2b\xd2\x4d\x89\x49\xa2\xec\x2f\x16\xe1\x71\xb8\x81\x9e\x40\xa6\xac\x27\xba\xe1\x88\xbd\x4d\xf2\x37\xc1\xf9\x28\x09\x4b\x7d\xe4\xa5\xd2\x7a\x8c\x7c\x9b\xe3\x19\x42\x66\x38\x43\x8a\xbe\x62\x90\xcd\xe7\xd5\x19\xc4\x70\x1a\x5c\xc6\xe6\x17\x89\x91\x10\x61\xa1\x48\xab\xe7\x32\x27\xde\x9a\x9d\x4f\x70\x6c\x31\x1d\x26\x3b\x4a\x39\x16\xa8\x60\x3e\xec\xdc\x55\x94\xb7\xa6\x7f\xb0\x22\xc0\xcc\xa4\xb8\xeb\x57\x24\x1c\x4b\x53\x3b\x4e\x3f\xf0\x26\x47\x41\x76\x78\x19\x33\xb2\xbf\xae\x3d\x21\x35\x9f\xd4\x85\xcf\x13\x79\x84\x4d\x90\x97\x27\x2f\xe6\xf6\x83\xd6\x2a\x9d\x6e\x4b\xad\xff\x27\x9b\x4d\x89\xa8\x15\x47\xf9\x4a\x40\x84\x53\xb6\xf5\x05\xe9\xf9\x8c\x8c\xae\x75\x3c\x90\x25\x83\x42\xc9\x38\x15\x1e\xb7\xe9\x93\x0c\x15\x1c\x3d\xa2\x4a\x61\x3e\xe9\x74\x95\x9a\x10\xe4\x0e\x2a\xfb\x81\x63\xdb\x41\x5c\x31\x3e\xc4\x29\x8e\x07\xa4\x01\x18\xe7\xa9\xbe\x5e\x8d\x61\x60\x72\xb1\x0d\xa0\x73\x9f\x41\xb6\xd4\x18\x36\xa6\xba\x03\x2b\x25\x93\x99\x26\x55\x79\xcf\x62\x3a\x0e\x30\x81\x74\xd5\x9a\x21\x50\xb7\xf8\x7c\x14\x19\x6c\x6a\x75\x71\x0d\x47\x44\x69\x08\x29\x07\x40\x6a\xf5\xbf\x32\xaf\xe4\x11\xcb\xd1\x26\x63\x9b\xfc\xce\x62\x2e\x2f\xa2\xe5\xca\x39\x9e\xd9\x08\x2c\xb9\x22\x4e\xb6\xb9\x72\x79\x04\x75\x69\x8d\xf0\x77\xea\x3a\x71\x52\x0d\x2f\x7e\x1b\xb2\x29\x73\x57\x77\xcc\x15\x3a\x64\xcc\x8c\x25\x09\x00\x92\x02\x13\xfa\x30\x44\x59\x32\xc1\x34\xf5\x14\xba\x1c\xe1\x18\x5d\x27\xb3\x54\x98\xd9\x07\x44\x9c\xa5\xc0\xef\x39\x76\xee\x5d\x77\x41\xdd\xd1\xb9\x6c\x2f\x43\x94\x01\xac\xac\x98\x23\x23\x86\xfe\x96\xdb\xdd\x5c\x34\x2a\xcd\x69\x2f\x99\x12\x61\x67\x5a\xc8\x3d\x4c\xde\xb9\x83\x38\x25\x01\x03\x0d\x93\x22\x53\x4d\x40\x13\x79\xcf\x53\xca\x56\x27\xdd\x3f\xab\xca\x2f\xb7\x1c\x77\x68\x44\xb9\xc4\x16\xfd\xb3\xae\x71\x11\xf1\x90\x5f\xb6\xbd\x0d\x26\x60\x34\x31\xa7\x1e\x62\x5b\x75\x51\x4c\xdf\xac\x65\x80\xf5\xd2\x2d\x96\x4c\xe7\xa9\x5c\xfc\x0c\x6d\x4a\xed\xab\x9f\x16\x48\x5d\xe4\xd8\x64\x77\xd0\x65\x12\x3f\xc9\xa9\xfc\xcc\xdd\x1d\xa5\xe0\x85\xe3\x24\x99\xa2\xa0\x9f\x5c\x58\xb6\xc1\xf2\x2e\x3f\xe1\xd0\x9e\xb8\x3b\x0c\x5c\x54\xb4\x2a\xf7\x53\xbc\xad\x90\x57\xab\xd2\xe2\x11\x87\x13\xe8\x29\xd8\xbf\x2c\xb2\x6e\x6c\x1b\xdf\x60\x9c\xc4\xf8\x2b\x70\x3c\x80\x8b\x36\x8b\x3d\x04\x5e\x54\xd8\xc9\x48\xb1\xb9\x1b\x99\x9c\x8b\x44\x15\x8e\x38\x3f\xb5\xda\x93\xd9\xcf\xc8\xd6\xdb\xfd\x18\x05\xe0\x79\xab\xc5\x22\x2c\x8d\x2c\x64\xc4\x79\x2f\x07\x61\x0b\x4f\x23\x8c\x1f\xd4\x70\x88\x59\x74\x1e\x47\xc3\x68\x10\xc4\x39\x0b\x28\x19\xd1\xde\x03\x48\xda\x8e\xed\x98\xfc\xab\xe4\x41\x4c\xcf\xca\xf2\x9b\x7b\x08\x1b\x63\x36\xaf\x93\x85\x23\x0c\xbe\x6c\x7a\x35\x67\xac\x91\xd5\x2c\x4c\x8c\x94\x76\x83\x31\x77\xd0\xf0\xbd\xa5\x7a\x91\xfd\xb3\x95\x8d\xdd\xb0\x85\x71\x68\xff\xab\x03\x38\x6d\x5c\x35\x1a\x0d\xbf\xd1\x6c\xb4\x3c\xd4\xb8\x6a\xb4\x1b\x9d\x46\xb7\xb1\x76\xf6\xd5\x00\x7b\xa8\x5b\x39\xf4\x0a\x0b\x5f\xc7\x67\xc4\x58\xb1\x97\xcc\x21\x18\x96\x2b\x7f\xa0\xff\x7e\xf9\x02\x31\x7b\x35\x51\x63\x88\x6a\x62\x7a\x7f\xd8\xb4\x28\x0a\xe5\x3f\x80\x2a\x19\x0d\xf1\x9f\x95\x8d\x49\x75\x00\x94\x3c\xc6\x38\x3e\xcf\x47\xd4\xf4\xc8\xc9\x45\xaa\xc7\x8c\x29\x16\xca\x62\x91\x62\x76\xe2\x41\x12\x12\x7a\xc7\xf4\x87\x4e\xee\xf0\xba\x3c\xf6\xa7\x20\x00\x1c\x0f\x56\xf6\xf0\x95\xbb\xcd\x79\x01\x64\x2a\xad\xf6\x85\x83\xbb\x14\xc4\x5a\x21\xb2\x8b\x25\xae\xc1\xbc\xb0\x2e\x96\x2a\xca\x90\xbc\xcf\x87\xeb\x0b\x45\x73\x61\x53\xe1\x8c\xe5\xc2\xa7\xea\xcb\x17\xb4\x87\xaf\x4a\xc3\xb7\xcc\x21\xa0\x41\x90\xe3\x98\xed\xf9\x2a\x05\x39\x98\xbf\x9b\x90\xa4\x7b\xd8\x62\xc0\x4f\x18\x37\x94\x28\x13\xd2\xfc\x2e\x7a\xaf\x5b\x15\x97\x2a\xb4\x21\xb0\xf3\x79\xfc\x0c\xf1\xa6\xe9\x4e\x69\x06\x25\x75\xa6\x44\x03\x3b\x2f\x16\x8e\x84\x0c\xec\xaf\x06\xc3\xb2\xf8\x2a\xe6\xa3\x40\x84\x3a\x28\x48\xcc\x5d\x3a\xca\x8e\x0b\x1e\xa3\xf0\x1c\x07\xf0\x63\x95\x25\x51\xf8\x45\x1d\xa3\x53\xbd\x71\x30\x99\x22\x7c\x05\x91\x24\xfb\x91\xde\x39\x7a\xaf\x4a\xca\x98\xb7\x0d\xf4\x3e\x75\x60\x0b\x92\xa2\x20\xfe\x0f\x47\xa0\x74\xa8\x4f\x44\xd2\x18\xc3\x56\x8b\x82\x1c\x05\x28\x8f\x26\x16\x89\xdb\x16\x92\x5d\xee\xae\x3b\x29\x84\x3c\x38\xa4\x28\xda\x24\xe8\xb1\x59\x38\x8d\x78\x54\x6c\xf2\x4f\xad\xd9\x46\xcb\xa8\x16\x51\x8c\x9f\xa2\xf5\x7a\x5d\x44\xcb\x76\x4a\xf1\x14\x8e\xda\xe3\x25\x14\x89\x70\xdb\x5f\x36\x8b\xa6\x5f\xbc\xe0\x6d\x58\xca\x8b\x46\x2b\x08\xfe\xce\x6d\x49\x1e\x53\xba\xb8\xee\x34\xa6\xee\x28\xf7\x55\xbb\xbf\x89\xcc\xc1\xae\x92\x31\xd8\xa4\x42\xb1\xd9\x2e\x6d\xaa\x68\xda\x72\xac\x04\x51\x1c\xf4\xf5\x93\x87\x74\x00\xa8\xca\x4e\x69\x0c\x0e\x22\x04\x2a\x82\x61\x94\xdf\x55\x14\x2c\x16\xa7\x58\x5d\x0e\x26\x45\x3e\x57\x0d\xdd\x6b\x61\x4d\xa6\x1c\x65\x8b\x8b\xe4\x64\x32\x76\x86\x61\x11\xd5\x4e\x05\x0c\x1e\x67\x7e\x13\x96\x0e\xfd\x03\xd2\x6f\x35\x09\xe9\x67\x0a\x5f\xb0\x10\xbc\x22\x4a\x6d\xa2\x83\x20\x1f\xad\x0c\x70\x34\x2e\x6a\xae\xa2\x05\x22\x12\xd9\xcf\xbf\x95\x76\x1e\x87\x39\x92\x71\xfc\xbd\xad\xdd\x27\x3b\xee\xca\xb4\x60\x9c\x77\x55\x5a\x98\x77\xce\x95\xc1\xc2\x49\x8d\xe2\x2a\x47\x3f\x37\x4f\xce\x2b\x26\x8d\x30\xf3\xfb\x86\xd3\xa4\x8e\xd4\x5b\x7c\x0a\x24\xb1\x61\x18\x8d\xc7\x3c\xec\x2c\x73\x93\x80\xf3\xd6\x7c\xa1\x84\x1f\xe6\x62\xdb\xa1\x57\x06\xe5\x74\xf1\xa9\x34\xcb\x0c\x52\x25\x42\xb9\x2f\xe3\xb3\x0a\x47\x30\xe6\x0a\xe2\xbb\x4f\x5a\xb4\x84\x4c\x26\xb1\xfd\x88\x25\xb3\x07\xf3\x40\x45\xbe\xa6\xea\x0d\xf9\xe4\xc3\xa5\x3b\xca\xfc\x87\x4b\xb4\x49\xfe\xeb\x48\xa0\x36\xf9\xf0\x99\x6c\x33\x57\xad\x20\xc4\xdd\xf5\xbe\x1e\x7e\x5d\x14\x0b\xb2\x4f\x48\xe6\x1c\x25\xf7\x04\x15\xee\xee\x68\xab\xb5\xc6\xd5\xb3\x46\xf7\x19\x7a\x4a\xba\xf0\x19\xf6\xf4\xdd\xdd\xdd\xdd\x3a\x5a\xa2\x2f\x7e\xfe\x19\x35\xae\xfc\x06\x6c\xf7\x04\x01\xc7\x76\x4f\xbb\x58\x6b\x5c\xb5\xbb\x9d\x06\x05\x76\xa9\x03\xbb\xac\x0a\x0c\x86\x17\x67\x33\xf0\xf4\xa9\x01\x1a\x2f\x5e\xd0\x9a\x68\x09\xc1\x48\x97\xd6\x67\x75\x57\x37\xa1\x0e\xfb\x2b\x2f\xbb\xb4\x89\x1a\x2b\x1d\x67\x19\x18\x53\x56\xf4\x29\xb5\xb7\xe1\xd4\x56\x47\x3f\xa3\x95\x0e\xfa\x2f\xe4\xa3\x0d\xb4\xec\x57\x11\x51\x0c\xce\xa1\x8a\x1b\x1e\x4a\x07\xc1\x60\x84\x59\x76\x9d\xf9\x02\x07\xa9\xf9\x81\xd0\x63\x5a\xab\xd1\xaa\xe4\xa8\xa4\x20\x49\x76\x13\x69\x30\xec\x57\x4c\xb4\xea\x26\xfa\x90\xd6\x68\x79\x20\xc8\xb5\xfe\x9a\xa5\x4f\x97\x45\x0e\x9f\x9a\x28\x5f\xc0\x47\x5f\x50\xa3\x62\x58\xf3\x18\x5f\x4a\xce\x4e\x70\xeb\xc8\x14\x20\x31\x4f\xdf\xf3\x48\x1b\x49\xbb\xf3\x29\x3b\xda\xcf\x33\xa4\xc1\xf1\x00\x0c\x69\xe8\xbf\x76\x43\x9a\x3d\x7c\x65\x6a\x02\x6c\xe0\x48\xc1\x4d\x0a\x74\x85\xfe\xae\x16\x7f\x53\x57\x5f\x8c\xf0\x55\x65\x15\x46\x85\x93\xe7\x82\x51\x35\x2b\xb5\x7e\x5f\x8c\x7c\x84\xaf\xcc\x10\x9a\x6c\xfc\xa4\xa3\xfd\xfc\x44\x42\xd6\xc0\x99\xb7\x3d\xa6\x5e\x56\x3e\x79\x66\x8b\x1e\x23\xe9\xac\x9b\x80\x46\xf8\xaa\x37\x0a\xd2\xca\x79\xb6\xb2\xb9\x07\x3a\xc8\x91\x16\xd1\x83\xdc\xe5\x1d\x0f\x71\x1c\x3b\xb6\xc6\x01\x2c\x01\xd2\xae\x17\x6a\x1f\xbf\x5b\xb7\xf1\x3b\x5b\x55\xd2\x4e\x63\x58\x5e\xd7\xc1\x20\x04\xb8\x8f\x49\x14\xd7\x9e\x3c\xb9\x45\xc4\x4d\x89\xc2\xe9\x7a\x5b\x44\xd3\xc3\x57\x0a\x25\xdc\xea\x0b\xc6\x21\x3c\xfd\xf9\x52\x13\x5f\x6c\xd4\x66\x5b\xac\xc7\xea\x91\x32\x69\x95\xc5\x12\xa5\xd0\x3a\x6f\xf8\xd1\x85\x3e\xb2\xa3\xcc\x22\xab\xe6\x72\x91\xd4\x74\x72\xa3\x6c\x0b\x6d\x96\xe4\xc7\xa4\xab\xa5\x05\x9a\x09\xe8\xf4\x7e\x9c\xb3\xce\xae\x64\xb3\x7e\x96\xa7\xb5\xc8\x43\xcd\xba\x07\x49\xf8\x0a\x95\x05\x59\x51\xeb\x75\x9b\x03\xee\xc2\x7b\x9e\x32\x4c\xab\xa8\x59\xd5\x7d\xf6\x4d\x90\x47\xb1\x5f\x6d\xd3\x62\x65\xf9\xbe\x25\x1e\x6f\xb7\x75\xb1\xea\x7f\xde\xee\x55\x15\x81\xfb\x5a\x53\x63\x68\xcf\xbe\x87\x51\x5c\xfe\xa3\xb6\x31\x3a\x1c\xdf\xf1\x4e\x26\x21\x48\x77\x24\x3a\x75\x2b\xc3\x34\x99\x90\xb7\xbd\x24\xc4\xb0\x49\x55\xdd\x90\x64\x80\x77\xd8\x93\x14\xba\xbd\xfd\xb6\x24\xc8\x71\xa1\xc5\xf0\x5d\x6f\x4e\x6c\x15\xd1\xfd\x49\x5e\x6e\xd5\xb7\x28\x51\x6b\xb1\x5d\x4a\x54\x13\x1b\x95\x78\xf3\xb5\xf7\x2a\xad\xe9\x79\xb9\x9c\x23\x49\x8b\x5e\xf4\x76\x65\xc0\x08\x7a\x2b\xaf\x45\x7c\x4d\xe8\x5b\x95\x5d\xb7\xb8\xf0\x56\xa5\x21\x5c\x75\xa7\x7a\x7f\xb2\xbb\xbc\x5e\x6d\xa3\x7a\x9f\x0f\xd7\xc5\x36\xc5\x1e\x6e\xb7\x49\xd1\x46\xff\xbc\x3d\xaa\x62\xfb\xf7\xb5\xb2\x66\xf9\x70\xdd\xbe\x41\x91\x51\xfc\x9a\xdb\x53\x9e\x5e\x97\x18\x18\x85\x98\x1c\xd1\xdf\x1f\xed\xf7\xb8\xa7\x53\x0d\x67\x83\x60\x8a\x6b\x25\x1b\xa7\xc9\x96\xd1\x20\xc8\x07\x23\x54\x33\xd3\x47\x03\x0a\xa3\x34\xb9\x04\xba\x85\x8c\x2b\xb5\x27\x07\xc1\x78\x98\xa4\x13\x1c\xb2\x69\x08\x83\x3c\x30\x53\xd0\x2d\xce\xc0\xe5\x49\xbd\x3d\xff\x66\x73\xb5\x08\x99\x7c\xd7\xcc\x1b\x28\x8c\xb2\xee\x82\x0c\xab\x33\x6e\x56\xc7\x65\x0c\xa0\x6c\x0d\xb3\x98\x51\x0f\xb5\x10\x50\xe8\x8a\xc3\xa9\x57\x0e\x40\x23\x52\xf0\x42\x2e\x4c\x1c\xb2\x6c\x66\x92\x17\xba\x33\x13\xaf\x64\x27\x7b\x2d\xa5\x44\x9b\xcc\xb2\x1c\xf5\x31\x8a\xc8\x88\x4e\x70\x9c\xd3\x3c\x6b\x01\x5c\xaf\xa7\x38\x17\x1e\x0b\x95\x72\xfb\x6a\x79\x3a\x55\xe5\x3e\xcd\x71\x48\x5d\xab\x8a\x04\xf1\x9f\xf0\x34\x47\xb3\x78\xca\x93\x06\xaa\xd9\x41\x25\x9b\x96\x86\x85\xfb\xbe\x64\xe3\x00\x99\x06\xb7\xc4\x28\x08\x2f\x31\xd7\xe7\x8a\x66\x70\x90\xdd\x95\x59\xf3\x68\x23\xfd\x84\x25\xd1\x66\x49\x4c\xf3\x04\x45\x79\xc6\xbd\x62\x10\xa1\xe0\xbb\xde\x31\xf5\xad\xc8\xd3\x84\xb8\xee\x4b\xa6\x4a\x59\x77\x99\x79\x1f\x02\x2b\x65\x9b\xcd\x00\x64\xe0\x64\x9e\x8a\xda\xce\xaa\x33\x25\x5a\x3e\xde\x0e\xf2\x80\x0b\xeb\x8d\xaa\x92\xe6\x56\x18\x66\xd0\x06\xcf\x0b\xee\x18\x69\x46\x0b\xd5\x37\x45\x11\x64\xc1\xc8\x3c\xce\x8c\x5d\x10\x5d\xf3\xcc\x09\x80\xf2\x4b\xea\x53\x12\x48\x16\x94\xd4\x9e\x18\x38\xde\xd7\x99\xcc\x0f\x14\x9d\xda\x13\x93\xdf\x57\xaa\x37\x7f\x6f\x64\x25\xab\x24\x33\x37\xdd\xeb\x8b\x74\x74\x72\x40\x51\x69\x80\x58\x30\x51\x15\x94\xec\xe3\x0c\x64\x34\x27\x4e\x24\xa3\x35\x89\x29\x03\x86\xf3\x23\xa5\x6d\x41\xd7\x5c\xe4\xcb\x4d\x89\x6c\xc0\x0c\xa2\x5d\xda\x54\x93\xa4\x57\xa5\x60\x9e\xeb\x34\x43\xc1\x45\x10\x8d\x21\x62\x17\xe5\x0b\xc0\xec\xdc\x54\x73\x22\x39\xab\x44\xf1\x45\xf2\x09\x67\x7a\x92\xe1\x1a\x4b\x0e\xec\xa1\xcb\x51\x34\x18\x59\x59\x75\xff\xba\x84\x55\x9b\xad\xf2\x85\xd2\x4f\x92\x31\x0e\xe2\x1b\x14\x26\xbb\xe3\x59\x36\x42\xbf\x8e\x70\x4e\xe3\x99\xf0\x5c\xb4\xe0\xae\x35\x0d\x52\x60\x14\xec\x55\xc1\xb5\x05\xbb\xbe\x45\x38\x10\xc1\xe9\x61\xc4\xef\xbe\xcd\x0b\x80\xdb\x94\x90\x5c\x6b\x86\xa7\xca\x75\xc5\xe5\x58\x10\x8c\x3d\x53\xb0\x1a\x6b\x95\x16\x55\x16\x1f\x1d\xf0\x05\x75\x26\x6c\x89\x14\xc4\x6d\xd1\x96\x90\xd7\xdc\x38\x0d\x46\xd6\xa5\x56\x21\x1f\x25\x43\x33\x17\xdd\xf3\xe2\x85\xac\xb0\xa9\xa5\x64\x2e\x2b\xcc\xa1\x17\xb5\xed\x11\xfd\x7a\xc9\x2c\xce\x39\x7d\x59\x98\x09\x01\x1a\xd3\x44\xc2\x47\x10\xb7\x78\x53\xc5\x7f\x55\x6b\xf2\xb9\xc9\x8b\x5c\x43\xce\x30\x38\x4a\x66\x71\x88\x66\x53\xea\x50\x38\x18\xcf\x42\xac\xd1\xbd\x59\x4d\xc3\xa8\x30\x72\x91\x3f\x54\x8f\x6d\x2b\xb0\x08\x93\xcb\x58\xc6\x23\x89\xc7\xd7\x68\x38\x13\x8b\xd2\x12\x49\x7f\x75\x15\x8d\x71\x46\x9d\x2a\xed\xb2\x16\xf0\x8d\x14\x4f\x82\x28\x56\x85\xab\x6a\xfd\x9a\x04\x57\x35\xa5\x5f\x70\x71\x8a\x96\x6d\x99\xd9\xbd\xf9\x57\xaa\x62\xce\xa9\xe6\xc1\x35\xe5\x40\xc9\x1c\x0f\xa5\xf5\xa7\x48\x22\x40\x17\x3d\x01\x6d\x38\xc9\x89\x7c\x55\xfb\x18\xc5\x35\xb9\xc9\xa7\xa8\xed\x29\x74\x66\x33\x9f\xe4\x19\xbc\x6d\x44\x42\xe8\x4e\x02\x58\xee\xb6\x45\xf9\x3c\x55\xb3\xb0\xdf\x2f\xe4\x11\x10\x6f\x97\xa4\xf5\xe4\x34\x9a\x20\x98\xe1\x94\x9c\x26\xc5\xc6\xb0\x5c\x1c\x10\xc0\x19\xd2\x5e\x91\x71\x17\x75\x0f\x12\x5c\xc5\x96\xab\xde\x35\xc7\x48\x49\x81\x55\x30\x7c\x98\x72\xb3\xa8\xc2\x7d\x65\x16\xa6\x27\xc3\x92\x47\xd4\x82\x86\xc2\xc9\xd0\xf2\xa6\x3c\xd3\xf3\xa9\x92\xc7\x16\x2d\xc3\xd6\xad\x70\x52\xf1\xf7\xe4\xa6\xef\x6a\xec\x56\x39\x0b\x65\xa9\x93\xd7\x1d\xad\xdc\x1c\xbb\xe1\x9f\x64\xf2\xf6\xc1\xd8\x10\x0b\x4c\xac\x33\x56\x6a\xf1\xa6\xf2\x30\x71\xd2\x74\x64\xa2\xe7\x67\xf0\x51\x90\x41\x86\x5c\xe7\x89\x7b\x6e\x2a\xf2\x82\x5d\xcb\x3e\x50\x74\xd2\x19\x74\x1a\x76\x0d\x67\x28\x89\xa5\xa3\xb0\xdf\x45\xb5\x8e\xdf\x04\x4b\xd6\xba\xe5\x58\xbc\x47\x2b\xf3\x63\xb0\x78\xb4\x9f\x87\xef\x25\xea\x6b\x59\x06\xb2\xd2\x80\xa9\x65\xae\x66\x74\x10\x16\xc8\x49\x7e\xdb\xe8\x76\xa4\x21\x44\x43\x24\xcf\x0b\x72\x57\xd9\x86\x44\xcc\x81\x12\xba\xed\x78\x6f\xab\xd9\xe9\xda\x9d\xc4\xca\x52\x5d\xdf\x3a\xc2\x1a\x8f\xad\x56\x3d\xcc\xda\x31\x16\xe1\x3d\xdc\x1a\x02\x53\x0d\x31\xc7\x12\xbb\xd0\xa4\xf0\x85\x73\xff\x2a\x13\x46\x2f\xf7\xa1\x22\x01\x84\x65\x15\x8f\x5a\xc2\xb1\x92\x00\xb4\xc2\xbc\x4c\xa9\x41\xdf\x9b\xd9\x70\x58\x36\x66\xbe\x21\x1f\x2d\x36\xd6\xef\xa7\x21\xb0\x0c\x79\xb0\x69\x5a\xfe\xea\x19\xfb\x9c\x11\x84\x29\x70\x3d\x8e\x70\x65\x17\x22\xca\x8a\x98\xff\xd0\xdc\xe5\xbd\xc0\x9c\xcf\x00\xaf\xda\x13\x86\x94\x4d\x97\xa2\x96\x9c\xaf\x3a\xa1\x05\x65\x42\x51\xc6\xc0\xb1\x1e\x1d\x1a\x09\xa6\xb0\x51\x21\x58\xc8\x83\x8d\x2f\x11\xd2\x09\xbe\x36\x50\xd2\x39\xd6\x14\x7f\xef\xcd\x77\x62\x97\x25\xb9\xc9\x04\x2e\x4e\x06\x89\xde\x26\x80\x72\x90\xd3\x7c\xf1\xac\x66\x11\x33\x14\x45\x19\xc2\xc3\x21\x1e\xe4\xd1\x05\x1e\x5f\xa3\x00\x85\x38\xcb\xd3\x19\x3c\x7b\x20\xa7\x2f\x27\xf1\x00\x57\x8a\x32\x5a\x91\x42\x95\x44\x0f\x80\x52\x11\x90\x1b\x4a\x2c\xae\xb9\x20\x83\x70\x4f\x3b\x03\xda\xe4\xe4\x28\x92\x09\x39\xd4\x12\x8e\xd2\x65\x84\x5e\x52\x6d\x3e\xd5\xf3\xa2\x0b\xd1\xfd\xae\x65\x7c\xcd\x03\x51\x39\x18\x34\x6f\xad\xcc\x13\xe0\x17\xe0\xac\xd2\x08\x71\x26\xbb\x2b\xcd\x83\x75\xf1\x90\xf2\xae\xc5\x23\x25\xbf\xeb\xf8\xcd\xd5\x56\xb3\x9a\x98\x9f\x31\x8d\x8f\x12\xff\x3e\x60\x93\xf6\x44\x04\x4e\x8a\xe2\x1c\xa7\x43\xc9\x5a\x18\x39\x57\x05\xe7\xaf\xac\xeb\x9c\x6a\xe9\x76\xcb\xe2\x23\x06\x68\x84\xc7\x53\x9c\x12\xf1\xa7\xc2\x22\xd8\x65\xb8\x31\xdf\x60\x1d\xe5\x6f\x70\x8f\x47\x65\x26\xdd\xa9\x82\x76\x75\xe5\x03\xed\xd5\x1e\x74\xa9\x66\x13\xb6\xdc\xfa\x39\xb9\xaa\x62\x3c\x08\xa0\x5d\xf7\x7b\xc6\xba\xb0\x07\xc0\x45\xea\x79\x91\xad\x44\x38\x2c\xaa\x59\xc4\x8a\x0c\x97\x2a\x85\x2f\x7e\x6c\xb4\xd2\x13\x61\xc9\x7b\x07\x5b\xbd\xfb\xa7\x27\x22\x42\xf3\xa0\x14\xa4\x05\x46\x57\x7f\x09\x9a\xda\x9b\x04\x83\x4a\x74\x35\x09\x06\x77\xa1\x2d\x51\xfd\x4e\xf4\xf5\x09\xdb\x55\x48\x12\x7d\xf5\x3e\x00\x5a\x64\x1e\x28\x91\xd1\x46\x68\xdd\xc5\x88\xad\xf4\xf8\x2b\x34\x49\x73\x7c\x18\x08\x36\xe0\xc4\xc0\x7e\x14\x5e\x0c\x3c\x53\x0b\x84\xf4\x3d\x08\xf2\x11\x0d\xeb\xfb\x88\xbf\x67\xc3\xfc\xbc\x88\xf4\x7b\x73\xe6\x75\xda\xdf\x6b\x78\x5f\x86\x4c\x8d\x87\x23\xae\xdf\x7b\xbc\x5f\x0e\x79\xd1\xb8\xbf\x02\x43\x39\xfe\xaf\x2b\xe8\xaf\xf8\x0e\xc1\x7f\x6d\x01\x74\xcd\x2b\x0a\x1e\x35\xb6\x98\x32\x89\x00\xa4\x68\xb0\xd2\xfb\x92\xf0\x34\x4a\x6d\xc9\x05\xc6\x15\x46\xb6\xdb\xae\x66\xa2\xc5\xca\x72\x23\x2d\xf1\x78\x3b\x33\x2d\x56\xfd\xcf\xb3\xd3\xaa\x8a\xc0\x7d\x71\xca\x3e\xb4\x67\x37\xd5\xa2\xb8\xfc\x0d\x6c\x89\x8d\xf2\x93\x60\x2a\x84\xc3\x49\x30\x5d\x3c\xf6\x82\xc5\x45\xdc\x04\xe1\xb2\xca\xa4\x63\x7e\x5b\x83\x65\xb4\xb4\x89\x5a\x6e\x9b\xe5\xeb\x1c\xfb\x16\xa3\x65\xfa\xe7\x32\x5d\xa6\x7f\x4e\x03\x66\x0e\xb8\x59\x00\xae\x45\x68\x09\xf9\x75\x8b\x4d\x34\xff\x52\xc5\x32\x9a\x03\x6e\x69\x80\x9b\x4e\xc0\x4d\x2b\x60\x3b\xe4\x3c\x8d\xa6\x63\xb8\x7a\xa9\xd1\x61\x79\xf1\x02\xfc\x26\xbe\xd0\xe7\x26\x79\x5e\x27\x8f\x80\x82\x0d\x8a\x98\x8a\x8f\x74\x2a\x6a\x1f\xd1\x0b\xd2\xfa\x4f\x3f\x21\xc0\xe6\x23\x7a\x8a\x1a\x2b\x6b\x1d\x69\x86\xea\xcf\xd1\xc7\x92\x70\x17\xd2\xdc\x53\x5b\xf0\x49\x30\x05\x9b\xd9\xad\xbc\x56\xe3\x08\x43\xa7\xbb\xe8\x29\xaa\xb5\xd0\x32\xfa\x58\x67\x3d\x6d\x0d\xad\xde\x4e\x46\x7c\x06\x53\x71\x11\x86\x3c\xdd\xb7\x49\x8d\xec\x03\x41\x09\x6d\x22\x09\x9d\xae\xe1\x4c\x02\xb1\xf5\x8a\xe2\x76\xe3\xe0\x51\x34\xc6\xa8\x26\xf7\x93\x85\x0b\x70\xc5\x1a\xb1\x0e\x8b\xdc\xcc\xe2\x7d\x66\x9c\x55\x86\x7a\x07\x3b\x79\x85\x27\xdf\xde\xce\x52\xb0\xda\x85\x18\xfd\x77\x6d\x6a\xc9\x76\x08\x6a\xd7\x23\x6f\x25\xd5\xcd\x2d\x45\xad\x05\x37\x07\x51\x4f\x18\xca\x8b\x37\xc2\x50\x7e\x3e\xdf\x37\x4a\xa4\xf8\x02\xa7\x19\x3e\x90\x0a\x16\xaf\x6c\x71\xcd\x7e\x28\x3e\x3b\xa9\xbb\x14\xa8\x6d\x0b\xe0\x7f\x3a\xff\x21\xec\x87\xac\x50\xd6\xc1\x52\x4e\xa3\x36\x7c\xca\x17\x36\xb3\xcd\xff\x58\x3f\x43\x9b\xe8\x63\xb5\x58\x9d\x16\x96\xb2\x7f\x1e\x27\x29\xfe\x66\x5c\x45\x02\xb9\x1f\x87\xe0\xe7\x5c\x4c\x77\x44\xde\x1c\x0e\xe7\xf1\x0c\xa9\x1d\x0a\xe3\x87\xcd\x4d\xb4\xec\xcf\xe1\x49\x32\x85\xc9\xb5\x6f\xc5\x88\xad\x22\x41\x2a\xd2\x5e\x66\xf8\x4d\x92\x4c\x8b\x25\xe1\xe9\x38\x78\xd2\x8c\x2a\x22\x87\x76\xe3\x19\x4c\x37\xd0\x93\xad\x97\xbd\xed\x9d\xdd\x57\x7b\xfb\xff\x7c\xfd\xe6\xe0\xed\xe1\xbb\xff\x7b\x74\x7c\xf2\xfe\x97\x5f\x7f\xfb\xd7\xff\x04\xfd\x41\x88\x87\xe7\xa3\xe8\xe3\xa7\xf1\x24\x4e\xa6\xff\x9b\x66\xf9\xec\xe2\xf2\xea\xfa\x73\xc3\x6f\xb6\xda\x9d\xee\xda\xfa\xb3\xa5\xd5\x4d\x16\xe1\x56\x1c\xed\xc4\xa2\x5d\x18\xd5\x62\x88\x1d\x5e\x29\x85\xe5\x86\x62\x61\x6a\x13\x85\xb4\x76\x6c\x6e\x2a\x64\xa6\x23\xc7\x7e\xc3\x1c\xbb\x32\x22\x24\x49\xcb\xa3\xa0\x26\xd9\x81\x05\x2d\x23\xbf\x7e\x06\xde\x2b\x85\xc0\xd4\x34\x89\x8b\x03\x6d\x56\x01\x5a\x3f\xe3\x1b\xbc\x2c\x86\x59\xa0\x52\x81\x28\x56\x22\xf7\x7c\x21\xc2\x0c\xa0\xff\x85\xb6\x28\xfb\xd6\xc4\xe5\xc1\x7b\x10\x1b\xe2\xa5\x25\xe5\x83\x20\x5b\xf1\x83\x51\xa4\x11\x5b\xd2\x1a\x16\xe1\xa6\xc8\xdd\xa3\x1f\xf2\xa5\x3d\xe2\xb9\x33\xb3\x4f\xe7\xe1\xe8\xff\x70\xf4\x17\x47\xff\xf7\x27\xbb\xcb\x7e\x17\xbd\xdc\xa9\xec\xa0\xe5\x77\x5f\xee\xc8\x3e\x5a\x7e\x57\x7d\x82\xaf\xb7\x77\xda\xa2\xc8\xfc\xb9\x8e\x5b\x15\x71\xb8\x47\xe7\x2d\xbf\xeb\xf4\xde\xf2\xbb\x7f\x03\x8d\x40\xf5\xc3\x3a\x0c\xc6\x5d\xce\xea\x76\x7f\x7f\xb0\x8c\x4a\x42\xfc\x2e\x89\xe2\xdc\xe5\x64\xec\x77\x1d\x4e\xc6\xd6\xc3\x74\x81\xa9\xdb\xcb\x58\x34\x59\xd5\xd5\x58\x02\x7a\x87\x13\x94\x4e\xc4\x77\x72\x56\x03\xda\x5c\x74\x6d\x7c\xd7\xc7\x28\xba\xaa\x84\xcb\x1a\x5f\x7c\x0b\xf9\xac\x41\xa5\xc5\x7c\x8d\x79\x2d\x21\xdf\xf2\x17\x5f\xdb\xd3\x58\x6d\xb8\x9a\xa3\xb1\x0f\xb2\x8f\xc0\x50\x75\x33\x26\x22\x50\xb1\x58\x9a\x64\xb1\x68\x41\xd8\xdc\x14\xee\x92\x72\xb4\xd1\x79\x5a\x3d\x14\x06\x23\xcb\x37\x15\xf6\x30\x69\x9f\x7a\x73\xe7\x7d\xea\xcd\x77\xb0\x4f\x55\xc1\xe1\xbe\xf7\x29\xeb\x72\x7a\xb3\xf3\xb0\x4d\x89\xbf\x7b\xdb\xa6\xb2\xcb\x60\xba\x13\x87\x51\x10\xd7\x16\xdd\xb1\x6c\x47\xf2\xef\x7f\xcb\x7a\xf3\x75\xb6\xac\x2a\xcb\xe4\xfb\xdf\xb2\xde\xec\x68\x9b\xd6\xc3\x8e\x65\xec\x58\xd2\x8a\x59\x68\xf3\xfa\xa6\xbb\x97\x98\x17\x09\x5b\x02\x48\xe9\x23\x8f\x86\x0f\x5f\xd8\xdd\x09\x5d\xdc\x8d\x06\xf9\x7f\xb8\x58\xa1\x1f\x49\xf7\xd9\x57\xfa\xad\x58\xfe\xf3\xd4\x05\x40\x58\x6e\x6d\x41\xf7\x4e\xda\x02\x96\xa3\xf6\x5b\x2a\x0d\x3c\x24\xbd\xca\x46\x81\xaf\xbd\x1a\x4d\x82\xc1\x57\x54\x2d\x78\x88\x37\x0b\xbf\xa0\xb5\xbf\x83\xba\xc1\xc8\x17\x7b\x0b\x55\x84\x62\xc4\x22\x7d\x39\xd8\xee\x40\x4d\x30\xb9\x39\xd8\xee\xd8\x64\x3c\x30\x71\xfe\x84\xaf\x69\x16\x6c\x6a\x07\x2b\xfa\x0a\xce\xbf\x41\x9c\xf3\x24\xde\x49\x3a\xa1\x36\xda\x3b\xbf\xbc\xfb\x00\x9b\xee\x49\xf2\x1a\x17\xc2\x20\xba\xbc\xbc\x5c\x49\xa6\x38\xce\xb2\xf1\x4a\x92\x9e\xaf\x86\xc9\x20\x5b\x85\x24\xdc\xc9\xaa\x56\x67\x94\x4f\xc6\x16\x45\xc8\xce\xc5\xf4\xf5\xf6\x6e\x81\xb6\x78\xae\x18\x0c\x61\xbe\x0f\x88\xb6\xc7\x19\xde\x2f\x2c\xe5\x39\xec\x51\x64\x60\x32\xf2\x10\xc5\xdc\xed\x45\x0a\xf7\x5c\xb8\xba\xb4\x51\xcd\x6f\xae\x2b\x9e\x2e\x06\x7c\x87\x91\x9a\x1c\x16\x43\x4f\x90\x72\xb0\xdd\x99\x87\x6d\x94\x33\x5b\x64\x3d\x48\xb5\xf4\x21\x4f\xd0\x94\x5a\x9d\xca\xde\x39\x8e\x1d\xce\xf0\x8b\xd1\x76\x07\x36\x3c\x1b\xc8\x6f\xae\x83\x09\xa9\xf2\x95\x76\x0e\x30\xd7\xbe\x14\xf8\x28\x6d\xdf\xdc\xda\xed\xc6\x41\xb4\x5f\xdb\x0f\x07\x4b\x8d\xde\x83\x99\xf5\xa7\x70\x68\x78\xdf\x50\x9a\x9f\x93\xa2\x69\x7e\xc5\x3f\x8a\xb9\x5a\xd7\xf2\xf9\xdd\x16\x8c\xa7\x4e\x63\xa3\xd1\xd0\x01\x2f\xe8\x1d\x34\xd7\xef\xa7\x9a\xbc\xbb\x0d\x29\xfc\x09\x8d\x10\xaa\x80\x44\xd8\x01\x64\x60\x25\x8b\xf6\x36\x56\xfa\xbc\x2e\x8d\x05\x60\x03\x54\x52\x39\x0b\xc6\x39\xda\x82\x7f\x16\x17\x8b\x81\xba\x28\x79\xdf\x07\x79\x61\xb2\x79\x7c\x0a\x87\x2b\xd4\x2d\x02\xd7\x78\x67\x3c\xc0\xaf\x24\x6f\x0d\x14\x57\xf2\x3b\xaa\x35\x17\x12\x78\xd5\x29\xb6\x88\xb7\x64\xa5\x33\xee\x61\xd6\x16\x5e\x6a\x84\x3c\x98\x89\x72\xb1\x3a\xac\xb0\x5c\x6e\x61\x10\x5a\x80\x0e\xf1\x6b\x18\x1b\x5b\x4a\xb4\x45\xce\xc8\x05\x30\xe1\x13\x2c\xde\x38\x8f\xcb\x7c\x8f\xa1\x3d\x62\x4f\x96\x72\x12\x13\xa7\x45\x8b\x17\x16\x2c\x5f\xb1\x8d\x89\x80\x57\x3f\x32\x63\x16\x0d\x57\x6e\xd0\xf2\x82\xe3\x63\x3d\x0a\x10\x31\x0e\x3c\x07\x9c\x17\xcc\xaa\xcb\x12\x2d\x3b\xff\x5a\x19\xc9\xc1\x18\x0a\x27\x10\x06\x85\x13\x9b\x64\x14\x6c\xd0\xab\xda\xbc\xf0\xa7\x33\x4b\x10\x9a\x10\x03\x67\x7e\x56\x0e\x4a\x3e\x3d\x28\x49\x03\x5d\x9a\xf6\x47\xc3\x5e\x20\xeb\x1c\x05\x1b\xc6\x96\xa1\x32\xdf\x49\x64\xc5\x62\xc6\x58\xdb\xd0\x46\x59\xaa\x25\xe9\x68\x38\xfd\x59\xa2\x5d\x88\x00\x73\xbc\x5e\x55\x9b\xeb\x4a\x3c\x58\xf6\x3b\xbe\x15\xef\x5d\x90\xef\xde\xa3\xf7\xad\xc5\xaf\x4c\xea\x4d\x75\x6e\x2e\x55\x52\xb4\x1b\xd2\x7b\x95\xbb\x17\x1f\x90\xc2\xd5\xc5\xa6\x4d\xf7\x6b\x17\x67\x5f\xac\x9a\x87\x1c\x62\xc3\x5d\xc0\x94\x8a\x0d\x42\x85\x5c\xc8\xfa\xae\x3d\xc7\x74\x61\x61\xc3\xae\x4a\x2c\xe0\xb8\x52\xbe\xdf\xdd\x3c\x2f\x39\xbe\x53\x68\xf6\xb3\xbb\xc7\x0f\x9f\x1b\x9d\x75\x8f\x1f\x49\x37\xd6\xd6\xc8\x99\x7e\xed\x2f\x7d\xa6\x1f\x44\xd3\x11\x4e\x97\xbf\xb2\x89\x00\x9c\xde\xe5\xa6\xfe\x9c\x43\xbc\x99\xb9\xf3\x5e\x4e\xf3\x3d\xe8\xd8\x3b\xc2\x71\x32\x71\x68\x97\x5f\xba\x4d\x08\xc4\x7b\x2d\x13\x86\x52\x83\x9c\xe1\x82\x1c\x2a\xd1\x9f\x9c\x11\xb3\x8a\xbb\xf0\x32\x67\x51\x15\x68\x91\x05\xd2\x69\x90\xd3\x0d\x9d\x9b\x1c\x5f\xe5\xe4\x14\x19\xb0\x67\x34\xa5\x7d\x62\xbe\x59\x3c\xd5\x46\x10\xe2\x41\x34\x09\xc6\xe3\x6b\x96\x06\x34\xac\x7c\x73\x23\x8f\xca\x0d\x6b\x85\x0d\xdc\x89\x40\x43\x6d\x76\xf1\x64\x1c\xb7\xc1\xef\xab\xa6\xe7\x28\xa6\x44\xba\xd5\x91\x3b\xbf\xd8\xc5\x8e\x52\xd3\xe1\xa8\x25\x97\x59\x29\x66\xb7\x48\x20\xb1\x87\xaf\x6e\x99\x09\xc2\x32\xbc\x12\xf9\xc8\xf7\x0d\x0b\x4e\xa7\x76\xf3\x10\xc5\xd3\x59\x7e\x97\x39\xe5\xe4\xa1\x12\xdd\x2d\xe8\xec\xbe\x88\x63\xa0\x31\x0a\x0b\x7d\xdc\x3a\xa9\x04\x8c\x96\x3d\x84\x4d\x31\x39\x9b\xa8\x68\x83\x56\x78\x6e\xa5\x9e\x9e\x42\x3d\x5c\x23\x50\x00\xda\x90\x81\xde\xd8\x75\xf3\xee\x9d\xb6\xe8\xae\xb6\xdb\x4a\x1b\xc4\x46\xa7\xe9\x69\xca\xf3\xf5\x07\x53\xbb\xbf\xbb\xee\xdb\xb5\x3b\x1a\x91\xcc\xcb\x34\xe1\xe6\x21\x05\x1c\x80\x85\xc6\xd5\x9a\x88\x8a\x94\xd8\x94\x1d\x55\xef\x27\x21\x3d\xb8\xbc\xce\xe5\x78\x95\x95\xc4\x15\x55\x51\x44\x56\x07\xe7\x65\x3c\x48\x71\x7e\x4f\x4a\x25\x22\xff\xee\xd9\x03\x07\x41\x2f\x19\x9b\xb0\x79\x22\x53\x47\xdf\xaa\x1a\x43\xd9\x39\xd8\x11\x20\xd8\xaa\x33\x12\xfa\x22\xea\xa3\x20\x1e\x75\x0f\xf7\x12\x6f\xb7\xfb\x8c\x2f\x0b\x07\xa6\x39\xe1\x65\xe9\xa1\x4a\x8a\x2e\xab\x8f\x93\xdd\x10\xbf\x44\x31\x45\x3b\xfa\x52\x8a\x8b\xc9\xba\x5e\x16\x19\x53\xab\xc4\xf5\x05\x3a\x2c\x7b\x94\xcc\xad\xf1\x38\xb9\x44\x41\xda\x8f\xf2\x34\x48\xaf\x11\x53\x2f\x7d\xc2\xd7\x96\xb8\x83\x9f\x64\x8d\xc4\xcf\xd6\x86\x4b\x06\x4a\x57\xb7\x54\x1b\xad\x39\xce\x90\x04\xa5\x12\x37\x48\x88\xff\x06\xba\x8d\x24\x45\x51\x1c\xe3\x14\xa2\xcf\x26\xb3\x1c\x04\x08\x3d\x0a\x1f\xc4\x4c\xa4\x3a\x46\x4a\x86\xec\x81\xb6\x62\x04\xa4\xe3\x1a\x3f\xb9\x46\x64\xa9\xb1\x08\x09\x24\x92\x56\x32\x29\xd3\x47\x46\x52\xc1\x48\x2a\x68\x34\xf6\xdb\xe1\x11\xcc\x27\xbd\x06\x9c\x06\x21\x1a\x24\x71\x96\x07\xb1\xde\xbc\x35\x89\x94\x3a\xc7\x6e\xc5\x9a\xc0\xfb\x34\x3a\x43\xbf\x6f\xa2\xc6\x55\x67\x40\xff\x67\x73\x87\x31\x0a\xb7\xba\xf4\x7f\xe5\x9a\xb1\x44\xd3\x89\x45\xda\xb3\x8d\x22\xff\x84\x38\x64\xb0\x03\x7d\x8d\x28\x64\x82\x89\xdf\x4b\x24\xb2\x92\x7c\x65\x36\x66\x6c\x19\x48\xe8\xb4\x8d\x8f\x3b\xf4\xa4\xaa\xbe\xb8\x58\x30\xb7\x8b\x40\x06\xc3\xfc\xdd\xc4\x1f\x3b\xd8\xea\xb1\xe8\x63\x80\x57\x04\x4b\xac\x34\x12\xca\x82\x53\x5e\x25\x10\x99\x51\xfa\xfe\x83\x91\xc9\x24\xc1\x5b\x99\x1b\x7c\xec\x6b\x45\x0f\x83\xa1\xfe\x4f\x8f\x1e\x36\x47\x4c\x5d\x44\x44\x24\x3c\xb4\xa0\xa1\xb9\x11\xc4\xdc\x35\xe6\x46\x11\x73\x57\xfd\x4a\x91\xc4\xee\xce\xed\x7a\x54\x3d\x0d\xe3\x6d\xd9\x8f\x89\x74\xb1\x67\x0f\x8e\x56\x1a\x70\xac\x94\x63\xca\x63\xa5\x01\x2d\x24\x14\x2e\x69\xf0\x4b\x26\x81\x4a\xdd\x19\x72\x6c\x12\x0c\xec\x97\x44\xe2\xe0\xef\x30\x82\x7b\xf6\x97\x56\x98\x5f\x75\xdb\xcb\x96\xd7\xe3\xa8\xbf\x4c\x50\x09\xc1\xb6\x35\xd3\xbe\xe2\x78\xb0\x0c\x36\x8d\x96\xf7\xd4\xcd\x52\xfb\x30\x09\x3b\xf3\x8d\xef\xb2\x51\xd0\xec\xe8\x20\xc9\xcb\xa6\x0e\x2e\x1b\x05\x1d\xbf\x69\xbe\x6c\xad\x5b\x4a\xb6\xb4\x57\x69\x34\xc5\x93\xd0\xef\x36\xac\xb6\x7f\xca\xab\x69\xff\x53\x38\xd4\xdb\xc1\x17\xd3\x4f\xe1\xb0\xec\xde\x41\xed\x7a\x12\xe2\xe5\xc1\xb0\x6f\x7d\x9d\xa7\x8e\xd7\xcb\xe7\xe3\x20\x9c\x04\xb1\xed\x73\x62\x07\x86\x07\xfa\xeb\x69\x10\x2e\x07\x71\x16\x5d\x3d\x6b\xea\x83\x40\x3e\x45\x59\xe2\x37\xfc\xa6\x3e\xe2\xec\xd3\xb3\xb5\x67\x6b\xfa\x0c\x91\x4f\x9f\x71\x9a\x30\xd7\x6b\xcb\xd7\xd8\xf1\x8d\xea\xc8\x96\x47\xf8\x4a\xfb\x10\x60\x9d\xb8\x68\xdc\x8d\xd0\x78\x9f\x0e\xf4\xc9\x4d\x83\x7e\x3f\xca\xad\x2f\x97\xc7\xf8\x3c\x18\x5c\x7f\xed\x3b\x20\xb1\x7a\xe0\x49\x5f\x34\xf0\xb2\x58\x2b\xe2\x91\x2d\x11\x78\x26\x2b\x43\x33\x0b\x65\xeb\x40\xfc\x6e\xb6\xc5\x6f\x42\xf5\xfc\x37\x21\x76\xf1\x9b\xfe\x2a\x48\xbb\xb0\x2f\x85\x5f\x8c\x90\x29\x06\x94\x7e\x8d\x3b\x2c\x8a\x0e\xa7\x56\xe9\x29\x4f\xd5\x27\x41\x9b\xc5\xdb\x44\xa9\x41\x28\x91\x36\x2b\x13\xa0\x78\x23\xe8\x4e\x7e\x43\xc9\x4d\xbc\x91\xa9\x4c\xbc\x8c\xd5\x57\x12\x4d\xc1\x33\x21\x25\xf8\x51\x50\x10\x1d\x95\x01\x1b\x28\x46\x2f\xd2\x6f\x4e\x26\x8b\x2a\x22\x15\x05\xa4\xcc\x6b\x17\x57\x4c\xba\x43\xb1\xb1\x2e\x6d\x74\x7c\xaf\x5c\x9b\xec\xa9\x74\xb5\xd1\x69\x7b\x0a\xe1\x6d\x74\x3a\x5e\x31\xf1\x1b\x9d\xae\xa7\x8e\xde\x46\x67\x4d\xbf\x11\xd6\x49\x79\xa3\xdb\xf0\x18\xb5\x6e\x74\x01\x1f\x41\x29\x1b\xdd\xa6\x27\xd3\xca\x46\xb7\xed\xd9\xa8\x65\xa3\xdb\xf2\x64\x0a\xd9\xe8\x76\x3c\x99\x7e\x36\xba\x80\x97\x42\x33\x1b\xdd\x35\x4f\xa7\x9a\x8d\xee\xba\xa7\xd3\xcd\x46\xf7\x99\x67\x10\xc9\xc6\x5a\xc3\xb3\x90\xd3\xc6\x1a\xe0\xcf\x96\xc4\xc6\x1a\x60\xcf\x48\x63\x63\xad\xed\x19\xc4\xb1\xb1\x06\x88\x13\x32\xda\x58\x03\x9c\x8b\x75\xb6\xb1\xd6\x95\x2f\xd0\xbd\x62\xc9\x6e\xac\xf1\xab\x75\xb2\x98\x37\xd6\x9e\x79\x7c\xa9\x6e\xac\x37\xbc\x62\x09\x6f\xac\xfb\x5e\xb1\xb8\x37\xd6\x01\x9d\x82\x82\x37\xd6\xa1\x71\xc1\x68\x36\xd6\xdb\x37\x67\x5e\xb7\xf1\x70\x79\xf0\xe7\x5f\x1e\xf4\x46\x78\xf0\x89\x74\x0a\x56\x0a\x75\x03\xa2\x69\xce\xb2\xd9\x94\x0c\x0c\x66\xf1\xa9\xa5\x7e\x83\x1c\x4f\x43\x9a\xa3\x1f\x36\xd1\x13\x0e\xf9\x89\xc5\x22\x44\x38\x69\xdc\xe3\x75\x45\xa9\x39\xbe\x68\xe7\x08\x0f\x71\x8a\xe1\xa0\x97\x46\xe7\x70\x26\x8b\xe2\x28\x2f\xc0\x64\xb3\x29\x4e\x41\x75\xbd\xa9\xa5\xe7\x90\xa0\x6c\xcd\xce\x27\x38\xce\xb5\x02\x28\x4f\xd0\x28\x88\xc3\x31\x56\xc6\x4d\x86\xdd\xb7\x42\x56\x6c\x6a\xa0\xaa\xe9\x0e\x28\xe9\xbe\x69\x2c\x79\x6a\x02\x15\xc5\xf9\xba\xa4\xa1\x1f\xca\xf5\x85\x62\x42\x9d\x1d\xf3\x98\x5f\xd4\xa0\x4a\xf8\xf7\x04\x2a\xbc\x90\xb1\x51\x0e\x11\x56\xc4\x12\x9a\xfe\x0b\x20\x5d\x44\xf8\xd2\x85\xa2\xb3\x79\x09\xe1\x7d\x8e\x02\xfa\xf2\x45\x2d\xcf\x09\x0e\xb0\x04\x9d\x31\xaf\xfe\x03\x59\x73\xc2\x76\x04\x16\x9d\x1d\xb8\x51\xb5\x6e\xb4\xe2\xc4\xca\xef\xda\xd1\x72\xb7\xb4\x58\x8d\xfd\x38\x6f\x35\x17\x6d\x62\xb1\x1a\xbb\xe3\x24\xb8\x4d\x95\x6e\x1b\xde\x17\xe5\x6f\x49\x4a\x2b\x94\x82\x3d\x24\xbf\xba\xce\xf1\x21\x24\x07\x32\x5e\xdb\xf2\x2e\x2b\xf4\xb7\x47\x17\x5d\xd1\x56\x95\x15\x51\x94\x5e\x4c\x85\x50\x40\x7b\x29\x70\x43\x9b\x76\x9c\x2d\x9a\x85\x9d\x2b\x96\x7d\xf5\x3a\xb7\x19\x3f\x2f\xe4\x2e\x68\x43\x65\x91\x7c\xda\x45\xfd\xd3\xe8\xec\x56\xc9\xb3\x0b\x73\xee\xe8\x33\xa6\xaa\xda\xc2\x71\x54\x2d\x2a\x18\x6b\x91\xda\xc2\x43\xcc\x8d\xd0\xd6\x11\x65\xbe\xad\x59\xcf\xc8\x68\x92\xd7\x04\x1e\x8a\x89\xd4\x27\x33\x73\xb3\xdd\x60\x3a\x1d\x5f\xb3\x86\x83\xf4\x7c\x46\x58\x78\x56\xe6\xaf\xc8\xf8\xf5\xca\x34\x4d\xf2\x84\xe0\x28\x73\xee\x32\xc3\x09\x7d\xf7\xb1\x2b\x58\xba\xfe\x83\xac\xf3\xe7\xc8\x3a\x10\x30\xfa\x4f\x88\x4b\x64\xcd\xa9\x54\xc1\x44\x02\xb6\x58\x7a\x8f\x87\xf2\x42\xb7\x4e\xaa\x9c\x30\x66\x21\x95\xa4\xaa\x4b\xed\xe6\xcf\x26\xe9\xb9\xf8\x4a\xb7\x6d\xe7\x22\x27\x84\x4d\x6c\xd2\xe1\x5b\x09\xfa\x19\xfd\x91\x45\x31\x0b\xc6\x4a\x58\x46\xe3\xca\x6f\xb0\xbf\x3a\xfa\xa2\xa6\xf1\x65\xcb\xab\x56\xb7\x5a\xa8\x1f\x6c\x77\x34\x6b\x0a\x9b\x01\x88\xee\x35\x89\x36\xd9\xa8\x5a\x0c\x40\x78\xda\x9b\xd2\xdb\xb1\x42\x13\x6c\xcf\x55\x7c\x6a\x72\xd2\xc6\x55\x77\xad\xdd\x69\xb6\x1a\xbe\x87\x1a\x57\x78\x38\x08\x83\xfe\xfa\x33\x4b\x5e\xc5\xc6\xd5\xb3\xf5\x7e\x10\x0e\x86\xd8\x83\x81\x69\x35\x3b\xed\xb5\xae\x5a\xee\xcc\x79\x23\xa6\xa5\xd1\x93\x7b\x71\x20\x32\xe9\xd9\xf6\xae\xcb\x60\x8a\x30\xb8\x57\xcf\xdf\x43\xfc\xae\x7b\xc7\x70\x5f\x5f\xf3\xd9\xa0\x48\x7c\x20\xf0\x78\x7a\x41\x14\x39\x22\xf0\x1e\x7c\x90\x4a\x1f\x9c\xf2\x87\x33\x9b\x4b\x88\xf4\x99\x10\x9c\x59\x80\xfc\xd5\x6a\x35\x09\x26\xf5\x14\x47\x5f\x90\xfc\x12\xf6\xba\x76\x5d\xf3\x11\x47\x5f\x2a\x02\x6c\xb6\xeb\x16\x80\x10\xca\x58\x71\x49\x37\xc1\xdd\xcd\x38\x64\x4f\xb9\xa1\xb0\x5f\xf7\x2b\x43\xda\x40\xd2\x98\xa2\x25\xd4\xd0\xc5\x07\xa5\xb4\xaf\x95\xf6\x4b\x4b\x37\xb5\xd2\xcd\xd2\xd2\x2d\xad\x74\xab\xb4\x74\x5b\x2b\xdd\x2e\x2d\xdd\xd1\x4a\x77\x4a\x4b\x77\xb5\xd2\xdd\xd2\xd2\x6b\x5a\xe9\xb5\xd2\xd2\xeb\x5a\xe9\xf5\xd2\xd2\xcf\xb4\xd2\xcf\xca\x67\xa7\xa1\xcd\xce\x9c\xc9\xf4\xb5\xe2\xe5\xb3\xe9\x37\xb5\xe2\xe5\xd3\xe9\xb7\xb4\xe2\xe5\xf3\xe9\xb7\xb5\xe2\xe5\x13\xea\x77\xb4\xe2\x1d\x83\x1b\xac\xae\x12\x86\xfc\x29\x8a\xcf\x49\xd5\x28\x18\xf7\x6d\x62\x73\x40\xb6\x81\x53\xeb\x40\xf5\xe1\x93\x75\x50\x06\xf0\xc9\x3a\x00\x21\x7c\x6a\xd9\xd0\xe9\x15\x77\xd0\xea\x37\x82\xc4\xee\x6e\x2d\xf0\x50\xdf\x43\x03\x0f\x85\x9e\xb4\x40\x3d\x84\xd6\x3c\xb2\x85\x36\xce\x74\xde\x10\xd2\x7a\xa1\x87\x44\xd5\x62\x84\x3c\x84\xfc\xa6\x87\x4e\x4e\x7d\xa3\xde\x80\xd6\xa3\x2d\xd1\xaa\xc5\xa2\x25\xf5\xd6\x48\xbd\xa6\x51\xaf\x4f\xeb\x09\x24\x03\xa9\x5e\xcb\x43\xa8\x09\xed\xb5\x8c\x7a\x65\xfd\x6b\x8b\xfe\xb5\x17\xea\x5f\x47\xf4\xaf\xb3\x50\xff\xba\xa2\x7f\xdd\x85\xfa\xb7\x26\xfa\xb7\xb6\x50\xff\xd6\x45\xff\xd6\x17\xea\xdf\x33\xd1\xbf\x67\x0b\xf5\xcf\x6f\x78\xac\x7f\xbe\x49\x30\x65\x1d\xf4\x7d\x8f\x75\xd0\x37\x29\xa6\xac\x87\x04\x4b\xda\x43\xdf\x24\x99\x52\x12\x6d\x79\x9c\x44\x4d\x9a\x29\xed\x63\x5b\xf4\xd1\x24\x9a\xd2\x3e\x76\x44\x1f\x81\x6a\xcc\x4e\xbe\x7a\xe5\xe8\xa4\x87\x50\x87\x76\xd2\xa4\x9b\x90\x56\xb4\x76\x92\xd0\xdb\x33\x5a\xd1\x24\x9c\x01\xad\x68\xef\xa4\xef\x21\xd2\xd1\x93\x53\xdf\xa4\x9c\x3e\xad\x68\xed\x24\xe1\x18\xcd\x06\x54\x34\x49\xa7\xac\x8f\x1d\xd1\xc7\xa6\x9d\xd7\xb8\xfa\x48\x68\x8e\xf6\xb1\x69\x67\x36\xce\x3e\x76\x78\x1f\x9b\x76\x6e\xe3\xea\x63\x5b\xf4\xb1\x69\x67\x37\xae\x3e\x3e\x2b\xfa\x68\xe7\x37\xce\x3e\xb6\x45\x1f\xed\x0c\xc7\xd5\x47\xc2\x18\x59\x1f\xed\x1c\xc7\xd5\xc7\xf5\xa2\x8f\x76\x96\xe3\xa4\xd5\x96\xc7\xfb\x68\xe7\x39\xae\x3e\x36\x05\xad\x36\xed\x4c\xc7\xd5\xc7\x35\xd1\xc7\x96\x9d\xe9\xb8\xfa\x48\x96\x3f\xed\x63\xcb\xb7\x2f\xc8\xbd\x3d\x37\xb1\xb6\x01\xd7\x96\x9d\xeb\xec\xed\xd9\x3b\x49\x86\x95\xac\xad\x93\xd3\x96\x9d\xeb\xec\xed\x95\x2c\xc8\x2e\x54\xb4\x73\x9d\xbd\x3d\x47\x27\xdb\x1e\x6a\xb6\xa0\xa2\x49\x3a\x65\x7d\xf4\x8b\x3e\xda\x99\x8e\xab\x8f\xed\xa2\x8f\x76\xa6\xe3\xea\x23\x4c\x24\xed\xa3\x9d\xe9\x38\xfb\xd8\x10\x7d\xb4\x33\x1d\x67\x1f\x5b\x1e\xeb\x63\xdb\xce\x74\x5c\x7d\x6c\x88\x3e\xb6\xed\x4c\xc7\xd5\xc7\x96\xe8\x63\xdb\xce\x74\x5c\x7d\x24\xac\x9c\xf6\xb1\x6d\x67\x3a\xae\x3e\x3e\x13\xf3\xd8\xb6\x33\x1d\x57\x1f\xc9\xf2\x60\x7d\xb4\x33\x1d\x27\xad\x76\x38\xad\xb6\xed\x4c\xc7\xd5\xc7\x66\xd1\xc7\x35\xfb\x82\xdc\xdf\x77\x0b\xaa\x5d\xda\x49\x3b\xd7\xd9\xdf\xb7\x77\x12\x68\x0e\x78\x40\xdb\xce\x75\xf6\xf7\x4b\xc4\x80\x0e\x88\x80\x76\xae\xb3\xbf\x6f\xef\x24\xe1\x1d\x4d\x18\xd6\x8e\x5d\xd4\x71\xf5\x91\xcc\x07\xed\x63\xc7\xce\x74\x5c\x7d\x6c\x89\x3e\x76\xec\x4c\xc7\xd9\xc7\x86\xe8\xa3\x9d\xe9\xb8\xfa\xe8\x17\x7d\xb4\x33\x1d\x57\x1f\xd7\xc5\x3c\x76\xec\x4c\xc7\xd5\x47\xa0\x39\xda\x47\x3b\xd3\x71\xf5\x11\x44\x72\xda\x47\x3b\xd3\x71\xf6\xb1\xe5\xf1\x3e\xda\x99\x8e\xab\x8f\x6d\xd1\xc7\xae\x9d\xe9\x38\xfb\xe8\xf3\x3e\x76\xed\x4c\xc7\xd5\xc7\xa6\xe8\x63\xd7\xce\x74\x5c\x7d\x7c\x26\xe6\xb1\xdb\x32\x17\x24\x5c\xa3\xe4\x38\x9d\xe0\x30\x0a\x72\xe6\x54\x06\xee\x0a\x6a\x39\x72\xc4\x45\x9b\xa8\x06\xff\x2e\xa1\x40\xd7\xb0\xd2\x32\x3e\x2b\xe3\x93\x32\x7d\x7b\x99\x26\x2b\xd3\x24\x65\x06\xf6\x32\x2d\x56\xa6\x45\xca\x84\x86\x36\x57\x53\x55\xee\x5a\x2c\x75\x17\x0c\x68\x0b\x99\xd2\x45\x36\xdd\x20\x0f\x6c\x07\xf3\x20\x0f\x44\x28\x9f\x20\x0f\xdc\xca\xb1\xf8\x65\x94\x67\x27\x49\x1e\x8c\x05\xcc\x78\x3b\xc8\x03\xea\x41\xf2\x14\xad\x5b\xa0\x43\x9d\x37\x78\x98\x73\xe8\xc2\xe3\x04\xca\x1b\x9d\x71\xa6\xbc\x12\x68\x9e\x16\x20\x7f\xfe\xf9\x67\xd4\x81\x8b\xb7\xc6\xd5\x7a\xa3\xb8\x6f\x2b\x4a\xfc\x03\xb5\x9a\x06\x71\xa8\x7d\xd9\x43\x9b\x08\xd4\xee\xc3\x71\x92\xa4\x35\xa9\x93\xab\x8a\xee\xdd\xd5\x39\x28\xfb\x06\x6d\x4a\x4f\xfa\xc2\x11\xa8\xd7\x6a\xb5\x02\xb7\x25\xd4\x6d\xd3\x7c\x69\xcf\x20\x98\x68\xbb\x4e\x15\x36\x76\xfd\x2c\xaf\xca\x70\x2e\x94\xb3\xf2\xdb\xea\xda\x59\x13\x1c\x53\xcd\xea\xe0\xe6\xe9\x66\x0d\x2e\xb1\x48\x67\xdb\x55\x3a\xfb\xc6\xda\xd9\x37\xb7\xed\xec\x1b\x6b\x67\xdf\x54\xed\xac\xd9\x5b\xd9\x89\xaa\x26\xba\xcf\x83\x4d\x41\x4e\x3d\xbb\xff\x20\x18\xbc\x53\x37\x06\xf0\x51\xb4\x79\x52\x95\xe6\x95\x9f\xe3\x0d\xa9\xe8\xbc\x2d\xe4\xbb\xc7\x0c\xe3\x9d\xde\x6f\x0b\xdd\x7b\x38\xae\xb8\x50\xd9\xf5\xbf\xc0\x04\xae\x30\xf6\x4e\xed\x77\x17\x7b\xec\x96\xac\x56\xdb\x53\xae\x25\xf6\x16\xbe\x8f\xa0\xb4\xb0\xa7\xdc\x45\xec\x39\x2f\x21\xe6\xdf\x38\x1c\xb1\xdc\xc0\x30\x87\x2c\x02\x4f\x08\x63\xaa\x16\xad\x90\xac\x1c\xdc\x10\x4a\x59\x3d\x28\x58\xc1\x29\x53\xdc\xd0\xc1\x63\x71\xfd\x6f\x6c\xbc\xf0\xf9\x83\x41\x0b\x2e\xef\x4a\x1e\x41\x83\x7c\xb5\x7b\x38\xd0\x5f\x02\x49\x4d\xf5\x75\xe5\xa1\xcc\x43\xea\x15\x1a\xf0\x49\xb4\x89\x02\xb4\x84\x6a\xb5\x3e\xfa\x89\x6e\x8e\xb5\x7f\x93\x9f\x61\x9d\xb0\x81\x2b\xb4\x84\x72\xa9\x3d\x11\xb0\x38\x26\xd3\x94\xd1\x95\x4a\xe3\x94\xb7\x9a\x68\x19\x65\x75\xa8\xd6\xd7\x8c\xde\x04\x56\xda\xf9\xbf\x1a\x56\xb0\x1d\xd7\x06\xe8\x27\xf4\xef\xaf\x83\x95\x76\x08\x9a\x8b\x55\x1f\xfd\x8e\x06\xe8\x77\x82\xd8\xfd\x23\xa3\x09\x80\x73\x91\x21\x88\xd4\xfa\xe8\xcb\x3d\x0f\x8e\x7c\x5b\x7d\xec\x4a\x93\x3e\x37\xf1\x7e\x95\x20\x6b\xdc\x4f\x4c\x73\x51\x84\xd5\x60\x82\x71\x38\x8b\x39\x4a\xdf\x36\xac\x19\x5b\x97\xc2\xc8\xe5\x60\xbb\x63\xf1\xfd\x2a\x2f\x6f\x3a\x7c\x15\xf1\xc5\x94\xcb\x7c\x35\x23\xff\xc1\x76\xc7\x6a\x32\xe0\x9c\x84\x39\xb9\xea\xef\x6b\x0a\x6e\x15\xda\x61\xfe\xc4\xc9\x5e\x7e\xf7\x31\x71\xd4\xa9\x4c\x4c\xc4\xde\x24\x18\x90\xc9\x50\x32\xc3\x9b\xf3\xc1\x8a\x99\x73\x52\x64\xb3\xa7\xf3\x52\x9a\x81\x9d\x45\xb6\x76\x58\x40\x35\xff\xd2\x2e\x66\x7f\xff\x98\x6c\x74\xb1\x3d\x65\x71\x86\xd0\x2e\xc6\x61\x3f\x18\x7c\x62\x71\x35\x27\x49\x08\x4b\x8a\xd0\x8c\x98\x6f\x78\xd9\xdb\x7d\x49\x44\x20\x8b\x78\x00\x66\x4e\xf0\x55\xb1\x96\x03\x0b\x17\xda\xca\x01\x01\xc0\x8c\x79\xc4\xaa\xef\xed\xbe\x5c\xd9\x89\x69\xac\x72\x30\xa0\xda\x7d\x69\x31\xf8\x99\x3a\xcc\x65\x98\x99\x61\x89\xc9\x8c\x5b\x34\x65\x21\xa8\xb8\x40\x42\x1f\x6d\xf7\xcc\x52\x28\x0f\x5a\x48\x0e\xe5\xa1\x96\xe7\x31\xca\x5f\xe3\xeb\x2c\x4f\x71\x30\xd9\x8a\x43\xd6\x3b\x8b\x75\x64\xc2\xcc\x62\x05\x38\x8f\x35\x60\x13\xb2\x8f\xf0\x04\x43\x90\x71\x30\xc6\xa4\xf3\xc4\x62\x65\x82\xff\x7c\x8c\xaf\x72\xfa\xda\x2e\xbe\xe3\x8b\x97\x2c\x66\x2a\xb4\xbe\x92\x8d\xa3\x01\xae\x71\x14\xc4\x4d\xbd\xc0\xc5\x66\x3f\xa9\xcc\xda\x36\xfe\xbb\xcc\xda\x1d\x46\x17\x0c\x87\x47\x51\xb6\xf0\xd8\x7e\x33\xba\x39\x29\x3a\xd4\xc7\x83\x64\xc2\xbc\xee\x09\x41\x44\xc9\x2c\xab\x46\x32\xa2\x8b\x95\xc4\xf1\x92\xde\xd4\xe6\x76\x41\xf3\x8d\x30\x0f\x6c\x70\xde\xbb\x28\x82\xb5\x5c\x3c\x57\x8d\xc6\xe5\x70\xcc\xb4\xf9\xe2\x33\x64\x76\xbd\xb0\x1e\x69\x44\x69\xb4\x89\xa2\x0b\x36\x85\x0d\xc7\x4a\x4c\x2e\x30\xda\xff\x05\xce\x9f\xd9\xac\x9f\xe1\xff\x9d\xe1\x38\x2f\x39\x3d\x03\xbe\xc2\x81\x61\xae\x01\xb4\x8e\x8f\x36\x21\xe6\x24\x90\x3f\x46\xe5\x98\x0e\x34\x14\xac\x09\x20\x1e\x52\xbb\xb2\xba\x8a\xd8\x8c\x14\xef\xac\xd9\x72\xcb\xa3\xc6\x50\xd3\xf3\xc2\x42\x10\x22\xc1\x88\x46\xe1\x1c\x6d\xd0\x0b\xc3\x82\x8b\x13\xbb\x2f\xcb\x0c\xae\xf9\xa6\xb3\x48\x9c\xba\x6e\xeb\x41\xf8\xf8\xde\x85\x0f\xf4\xdf\xd3\x14\x67\x38\xbd\xc0\x54\x0c\x49\x66\x44\x94\x97\xc4\x0f\x50\x63\x04\x79\xd4\x1f\x33\x0e\x8c\xb6\x53\xf4\x32\x8d\x82\x18\xbd\xa2\xee\x99\x68\x18\x8d\x31\x8e\x07\x2b\x03\x00\xc1\x43\x3e\x43\x04\x6c\x8d\x7e\x4e\x8e\xa0\xc8\x3f\x83\x18\xed\xa5\xb3\xfe\x35\xfa\x38\x22\xff\xac\x5c\xe2\xfe\x7f\x9f\x4f\x82\x68\xbc\x32\x48\x26\x76\x79\xe7\xe4\x88\x37\x57\x22\xf6\xc8\x85\x2a\x4b\x3f\x8f\x8a\x7c\x2f\xf1\x80\x1c\x14\x68\xca\xa4\xc7\x8f\x1e\x91\x41\x07\xd2\x13\xe9\x90\x40\x49\x44\x95\x42\x75\x98\x75\xfa\xeb\x0f\xb4\xba\x9a\x5c\xe0\x74\x38\x4e\x2e\x49\x1d\xd8\xf8\x7c\x9e\x0e\x94\xd4\xf3\xbb\xf5\x9f\x48\xd9\xe7\xe2\x73\x53\xfe\xbc\xae\x7f\x6d\xb1\x3d\x8c\x35\x06\x78\x02\x2a\x04\xac\x68\x77\x75\x15\xf1\x66\x51\xdf\x27\x45\x00\x65\x68\xba\xf1\x5c\x54\x69\x16\x55\x44\x99\x47\x80\x00\x2d\x44\x4b\xb5\xd4\x52\xac\xd8\x23\x40\x85\x95\xbb\x81\xff\x12\x82\x94\x4b\x2c\x2d\xf5\x5b\xd2\x77\xf8\x0f\x2f\x43\x8b\x2c\x2d\xf5\x9b\xcf\x1f\xbb\x0b\x2c\x2d\xf5\x7d\xf6\x9d\xfc\x17\x3a\xce\x1b\x85\x87\xa5\x4d\xe8\xf9\x8b\x17\x2c\x1f\xa4\xfc\xba\x49\x55\x80\xca\x5b\x86\x90\xd9\x92\xa8\xd6\xb8\x6a\xf8\x4c\xeb\x57\x14\x65\x5c\x8f\x14\x22\x2f\x6f\x74\xea\x60\xcb\xa3\x36\xa0\xff\xaa\x34\xc2\x5e\xd2\x1b\x24\x4e\x4a\xc5\xcb\x3a\x23\x18\x69\x0a\x56\x57\x11\xd9\x25\xe0\x26\x06\x45\xd2\x42\xa2\x8b\xc7\x58\x69\x4f\x32\x04\xf0\x32\x94\xc4\xe3\x6b\xba\x1c\xb7\x7f\x3d\x3c\xda\x46\x1f\xd1\x0b\xb4\x0e\x30\x79\x83\xbe\x0d\x0b\x7a\x17\xa7\x76\x96\x7d\xe3\xfd\xe5\x6b\x49\x39\x0b\x88\x75\xb5\xe2\x78\xfd\x27\xca\x9c\x8b\x8a\x9c\x46\x71\x4d\x86\x31\x5b\x65\x3c\x51\x34\xcb\x07\xcc\x40\xbd\x4c\xe2\x41\x6e\xa9\x07\x84\x06\x7b\x23\xe5\x32\x10\xba\x85\x1c\x84\xe6\xcb\x42\x5c\x3a\x20\x84\x6d\xd2\x3c\x65\x45\x8f\x74\xd1\x88\x7d\x96\x70\x55\x55\xcf\x8b\x08\x45\xc8\x21\x18\xa1\xdb\x09\x47\x68\x41\x01\x09\xa9\xf2\x9c\x79\xe8\x2a\xe8\x5e\x3e\x7b\x89\xa5\xf1\x5c\x93\xac\x44\x71\x49\xc0\x72\x8a\x58\x52\xe1\x05\x24\xad\xf6\x83\xa4\xf5\xbd\x4b\x5a\x0e\xf9\xca\xa1\xde\x39\x39\x2a\x97\x73\x16\x55\xef\x58\x58\xba\xce\xcb\x1f\x98\xf8\xdf\x8f\x89\x97\x9e\x66\xbf\x02\xcb\xde\x8f\x07\x29\x86\xc8\x0d\x0c\xb8\x06\x92\xc9\x21\xc5\xe4\x2e\x23\x6a\x4c\xe3\xf8\x02\xb7\xe5\x5f\x50\xe3\x2f\xb5\x39\x54\xdd\x15\xe6\x9f\xb7\x49\x99\x05\x76\x81\xce\xc3\x2e\xf0\x97\xd8\x05\x76\xc6\x78\x90\xa7\x49\x1c\x0d\x50\x2f\x09\x71\x3f\x49\xe6\x2b\xfc\x77\x7a\x65\x0a\x7f\xfa\x75\xa1\x1d\x61\xa7\xa7\x2a\xfc\xc9\xf3\x7d\xed\x00\x32\x6b\x57\x19\x88\x5a\xaf\x4c\x8b\x49\xf0\x51\x16\xd2\xd7\xc2\x2f\xc4\xb7\xc2\x8f\xa7\x5e\xea\xcd\xd7\x9b\x41\x99\x05\xd6\xf1\x5f\x3b\x39\xf2\x7f\xce\x3a\x3e\x9c\xe5\xd3\x59\x5e\xfd\xd2\xee\xb0\xf4\xd2\xee\x70\xf1\x4b\x3b\x5d\xaa\x3b\xd4\x2e\xf1\x0e\xff\xdc\xeb\xa0\xaf\x2e\xd5\x99\xba\x79\xf1\xe6\x7e\x25\xbb\x92\x86\xbe\x17\xe9\xee\xef\x74\xc2\x3e\xd4\xae\x35\x5d\x42\xd4\x61\x85\x4b\x8b\xc3\x05\x2f\x2d\x1e\xb2\xd8\xfd\x35\x98\xef\xd6\xdb\xe3\x7d\xf4\xdb\xca\xb3\x66\x8b\x1b\x88\xa3\x2c\x27\xcb\xfb\xfc\xda\xe0\xbe\xd3\x20\x5c\xd9\x8a\xb3\xe8\x37\x52\x5a\xe4\x82\x9b\x06\xa1\xcc\xfe\xc2\x20\x0f\xa4\x8b\x50\xd7\x05\x68\xa6\xde\x80\x92\x5a\xc7\x85\xc1\xaf\x62\x00\xfc\x5c\x2d\xda\xd7\xd3\x8a\xf4\x5d\x09\x45\x80\x28\x66\x71\x2e\x7a\xa6\x05\xb3\x02\x5b\xbc\x77\xf4\x9b\x01\x8c\xbe\x58\x56\x31\xfb\x87\xf6\xdd\x68\x8d\xc6\xb4\x19\x07\x19\x8d\x9c\x85\xa6\x49\x16\xa9\x1e\xf8\xa4\x51\xf2\x9d\xd4\x7f\x97\xf0\xce\x8a\x16\x96\x34\x8c\x96\x91\xaf\x35\xf2\x2e\x08\x8b\x67\x18\x28\x91\x6d\x44\x7d\x4d\x59\x89\xdc\x56\x11\x52\x4b\x6d\xa4\x08\xa9\x25\x97\xb6\x05\xd7\x52\x2d\xb3\x97\x34\x40\xdc\x0e\x91\x5b\xe0\xce\x62\x0b\x71\xe8\x14\xf1\x0a\xe7\x52\xc2\x79\x65\xaa\xa8\x02\x5f\x8c\x66\xf9\xcc\x49\x7d\xae\xa9\x68\x2e\x93\xe3\x2f\xeb\x7b\x71\x11\x24\xa1\xc0\xf6\x15\xc3\x43\x42\x03\xe3\xe8\xed\xe3\x47\x37\x56\xbe\xc9\x97\xcb\xd5\xb3\x66\x6b\x21\xde\x79\xb7\xc4\x64\x0f\xbc\xf3\x5b\xf1\xce\xfd\xe3\x43\x04\x21\x71\xab\xb1\xce\x7d\x16\x40\xf7\xae\xac\xf3\x4f\x67\x87\xc5\x92\x98\xc3\x0f\x2d\xac\x8a\xa6\x03\xb0\x47\xa0\x5b\x49\x83\x38\x4c\x26\x35\x83\x03\xd6\xeb\x2b\x9a\xa4\x54\x0e\x87\xa5\x0e\x3b\x35\xb8\x5c\xb3\x7d\xe6\x11\x70\x0f\x8c\x4a\x67\x54\x9c\x38\x17\x62\x54\x7f\xed\xcc\x0b\xff\x51\x8c\x6a\x75\x7f\xa7\x87\x9e\xad\x3d\x5b\x5b\xf6\x11\xa3\x0d\x74\x80\xf3\x51\x12\xa2\xa6\x8b\x5b\x41\x68\xef\xdb\x72\xab\xad\x30\xa4\xfe\x83\xea\x82\xa8\xc0\x05\xf8\xea\x25\xb5\xe9\x1f\x5f\xb4\x4a\x03\xff\x83\xd3\x04\x72\x87\xe5\x23\x8c\x52\x9c\x49\x7c\x51\xe9\x08\x29\xc7\x7a\x4c\x9e\x0d\xbc\x6f\xc5\x0b\xd8\x42\xfc\xcc\x70\x50\x57\xa3\xb3\x79\x00\x4d\xe1\xd9\x17\x76\x12\x63\x34\x49\x52\x4c\x85\xc7\xe5\x65\xe8\x9b\x6b\x14\xf9\x7a\x5f\x5e\xae\xb8\xc0\x61\x3e\x17\x59\xe0\x6b\x77\x8b\x72\xfe\xb0\xc0\xbf\xd9\x29\x0e\xc5\x49\x32\xad\x26\x86\xbc\xe5\xe4\xe8\x5c\xd9\x82\xd8\xdd\x6b\xa2\x28\x52\x46\x73\xa2\xa9\x85\x88\xee\x6e\xe1\x66\x1f\x88\xee\x5b\x11\xdd\xff\x48\xcc\xaf\x9c\xe4\x24\x1e\xf8\x27\x0a\xbf\x95\x0f\xce\xf2\xf9\xd6\x10\x80\x6b\xb5\x72\x11\xb8\x8e\xbe\x7c\xd1\x5f\xdd\x6a\x8b\xb1\xf7\x78\x7e\x5c\x81\xd5\x55\xf4\x9e\xc0\x57\xeb\x45\x46\xa4\x00\xd0\x2c\x88\x32\x97\xa3\x68\x8c\x51\xed\x87\x5a\xe1\x6b\x5d\xc4\xe0\x06\x8f\x43\x23\xe6\xb6\x30\xe1\x34\x14\x99\x91\xd8\x92\x90\xaa\xa2\xd4\x1d\xbb\x21\x1e\x6f\x95\xdd\x4b\xa2\xa0\x85\x78\xc9\x5f\xdb\x71\xcb\x92\xa3\x8b\x26\xc9\xfa\xba\x7c\xa5\xc8\x84\x04\xad\xfd\xf9\x79\x3e\xbe\x6e\x92\xf0\x6a\x31\xb1\x8d\x98\xd7\xe2\xcb\xf1\xde\x96\x5f\xc4\x7a\x26\x4f\xd2\x47\x33\x11\xb8\xcd\x41\xf4\x5d\x90\x65\x64\x21\x2f\x13\xd4\x42\xf4\x1a\x5f\xa3\x6d\x9c\x46\x17\x34\x27\xe4\x2e\x1f\x94\x66\x79\xcc\xe9\x77\x2f\x5f\x6f\xef\x36\x8b\xd6\xc4\x73\xc5\xc4\xe3\xbd\x24\x1e\x46\xe7\x33\x96\x89\x32\x81\xac\x90\x59\x59\x7e\xc9\x34\x99\xe2\x34\xbf\x46\x7f\xd0\x63\x31\x78\x93\x02\xf3\x3d\x19\xd1\x1c\xc7\x19\x79\x88\x62\x96\x2e\x20\x4f\x84\x2f\xcd\x0a\xda\xc6\xc3\x60\x36\xce\x37\x50\x1b\xd5\xfc\xe6\x3a\x24\x52\xae\xbb\xe0\x3b\x12\x9a\xe3\x94\x27\x32\x2f\xc0\x91\xf1\x9f\x87\x66\x94\xb3\xe4\x99\x19\x80\x2a\x0e\xf5\xd2\x87\x3c\x41\x53\x9c\x0e\x93\x74\x22\x01\x57\x20\x4b\xe9\x1f\x07\xc3\xf3\x0d\xd7\x28\x23\x7a\xf1\x75\x0c\x31\x67\xfc\xe6\xfa\x6a\xab\xa9\x85\xe0\xa6\x5d\xa1\xa8\x6b\x9f\x0a\x84\x94\xc6\x6f\xea\x65\x09\x49\xcb\x12\xc8\x93\x59\x09\x0b\xd2\xe2\xeb\x6d\x7e\x16\xd1\x43\xe0\x73\x37\xa4\xab\x72\xc6\x50\x32\x7e\x03\x1b\xdd\x70\x7f\xb3\x61\x92\xc2\x29\xa6\x68\xf4\x1e\x12\x83\x7e\x0a\x87\x46\xd2\x78\x4a\xed\xfc\xf4\xa8\x98\x61\x2d\x52\xf1\x8f\x62\xb2\xd6\x69\xfa\xc9\x3b\x83\xf1\xd4\x69\x6c\x34\x1a\x3a\xe0\x92\xec\xf5\x83\xe1\xb9\xdd\xf0\x82\x4c\xc4\xa6\xf8\xc9\x09\x8f\x14\x77\x05\xc3\x30\xd7\x3b\x5c\x57\x50\x0f\xba\xaa\x2c\xe8\x36\xf9\x66\xa7\x0c\x36\x50\x0b\x7f\x58\xa9\x58\x39\x0b\xc6\x39\xda\x82\x7f\x16\x4f\x44\xcb\xdd\x68\x24\xbf\xf6\xbb\x90\x1d\x4d\xa4\x1e\x0e\x57\x58\x54\x92\x1a\xef\x8c\x07\xf8\x39\x27\x95\x15\x97\xe7\x55\xab\xb9\x50\x6e\x17\x75\xea\xad\x06\x84\x51\xee\x48\x0a\xcb\xbc\xec\xc1\x77\x9f\xd1\x2a\x21\x1f\xca\x83\x3c\x31\x3b\x76\xb3\x44\x77\x82\x72\x90\x4d\xe9\x60\xd3\x74\xf3\x86\x3e\xc7\x16\xea\x09\xe4\xe4\xfd\x38\xc4\x57\xb6\x1a\xa7\x8d\x2b\xa6\x00\xb2\x44\xeb\x9c\x13\xa2\x4b\xa0\x22\x84\x65\xf1\xc6\x99\xbf\xbe\xc0\x86\x57\x2a\xde\x38\x2b\xf1\x2d\x6f\x93\xcc\xca\x0a\x7b\xb2\x19\x61\x14\x5b\x0b\x2d\x5a\xbc\x98\x63\x64\xa1\x7e\x64\x82\xba\xd6\x41\x1e\x17\xe9\x05\xc7\xc7\x6a\x5c\x20\x3a\xc9\xf2\x1c\xf3\x64\xd9\x40\x81\x45\x1a\xdf\xa2\xd7\xfa\x9c\x21\x96\xd1\xbb\x48\x0d\x6c\x7e\x9f\x9f\x8d\x01\xe0\x2b\x43\x6c\x1d\x5d\xb3\xb8\xc8\x62\x54\xbc\x62\x1d\x77\x20\xb2\x2f\xc6\xd8\x0e\x3a\x92\xa3\xd9\x31\xb0\x16\x2c\x14\x5b\x0e\x9f\xda\x72\x48\xd3\xe7\x34\xe6\x40\xc0\xcf\x95\x26\x60\xf4\xc4\x48\xcb\x1f\x6d\x63\x5d\x65\xbc\xd1\xbc\x50\x50\xb6\xce\xf2\xd1\x97\xdf\xd9\x03\x56\x49\x4d\xfc\x76\x78\xa4\x76\x07\x5c\xa7\x2c\x1e\xd7\xc6\xb8\x7d\xa4\x36\x30\x1f\xb9\x0d\x8c\x34\x9b\xcf\xd1\xc7\x92\xd1\x23\x7f\x45\x8d\xd3\x8f\x60\x0e\x63\x74\xe4\xf4\xa3\x6e\x16\xc3\xff\x6e\xcc\xd7\x7a\xc0\x29\xf2\x27\x31\x07\xa6\x9b\x86\x46\x6d\x53\xa2\x31\x89\xd3\xc6\xd9\xd2\x52\xb9\x49\x91\x04\x5c\x3a\xfa\x72\xbe\x61\x09\x62\xc6\xf6\xb2\xa2\x5e\x99\x01\xa5\x7c\x8c\xb8\xd3\x86\x5e\x25\xd8\x4c\xe9\x46\xbe\xe0\x26\x7e\x5f\xa2\x65\x94\xd9\xd2\xed\xcf\x8f\x5e\x63\x11\x0d\xee\x21\x88\x0d\x15\x11\x84\x64\x48\x85\x42\x97\x98\xb0\x58\x35\x0f\x39\x64\xd3\xbb\x80\x29\x95\x4d\x8b\x20\x3b\xe2\x28\xe9\x12\x60\x3c\xa4\x0b\xaa\x6c\xd8\x55\xb1\x98\x14\x9a\x23\x3c\xdd\x94\xd9\xa2\x51\x68\xf6\x40\x3d\x7a\x0a\x5d\x9e\x13\xf6\xe6\xcc\x5b\xfb\x6b\xfb\xd0\x2f\x90\xd6\x7d\x7e\x72\xf4\xaf\xab\x3b\x72\xa6\xd7\x76\x65\xbd\xfe\x3b\x68\x97\x8e\xc1\x38\xb3\xc7\x8d\x77\xa9\x12\x49\x7e\x59\xa6\x47\x12\x78\x1c\xe1\x59\x16\xf4\xc7\x98\x85\x03\x93\xd0\x39\x46\x72\xaa\x45\x0a\x45\x7f\xf3\x0a\xa9\x19\xd6\xa4\x6d\xe1\x08\xb2\x29\x23\x66\x68\xcb\x6c\x8c\x4d\x4d\x92\x28\x0f\x31\x56\xa2\x0c\x05\x88\x26\x60\x46\x17\x38\xcd\x20\x6a\xd9\x28\xc8\x51\x8c\xcf\xc7\x78\x90\xe3\x90\xb0\xe1\x01\x4b\xa9\x9a\x33\x85\x4f\x9e\xa0\x71\x94\xe7\x63\xbc\x4c\x03\x5c\xae\xa8\x40\x71\x9a\x26\x29\x0a\x13\x9c\xc5\x4f\x72\x14\x0c\x87\x78\x40\xeb\x52\xa4\x9e\x64\x28\xc3\x83\x59\x1a\xe5\xd7\x9e\xa8\xd8\x9f\xe5\x28\xca\xa1\x12\xaf\x11\xe5\x99\x08\xa8\x10\x8d\xa3\x9c\x39\x71\xd3\xbc\xae\x11\xe1\xcf\x13\x1c\xd3\xfd\x20\xb3\x29\xca\xe8\x80\xbc\xa1\x9d\x13\xea\x32\xed\xad\x3c\x7f\xb7\x4d\xda\x56\x7e\x48\x79\x2d\x9b\x41\x3b\x0f\x18\x85\xf5\x36\x9c\x1a\x2e\xca\x4e\x0b\x11\x3b\xa1\x91\xdd\x0b\x3b\xcf\x69\xbf\x89\x76\xc9\x2f\x4b\xe2\xb8\xd7\xa7\x8d\x33\x0f\xd5\x5e\x9f\xb6\xce\x58\xb0\x00\xf4\x85\x3c\xb2\xab\x00\xbf\x5b\xb7\x24\x91\x7b\x7d\xea\xd3\x4a\x0d\xb5\x52\xab\xbc\x52\x93\x56\xf2\xd5\x4a\x8d\xf2\x4a\x2d\x5a\xa9\xa9\x56\xf2\x45\x25\xb5\x8e\x2d\x3b\x92\x31\x64\xdc\xcb\xd0\x35\x68\x3d\x31\x68\x3d\xfb\xa0\x99\xf8\x48\xc3\xc5\xfa\x44\x2f\x4c\x86\x43\x9e\x76\x90\x22\x4d\x83\xac\x36\x1a\xe4\x8b\xad\xbf\xe6\x44\xb4\x54\xc8\xbe\x15\x72\xb3\x12\xe4\x86\x73\xe0\x25\x18\x1a\xe4\x56\x25\xc8\xbe\x6b\x76\x3c\x09\x86\x06\xb9\xa1\x41\x9e\x3f\x91\xbd\x20\x4d\xaf\x51\x5f\x4f\xa7\x4a\xa7\xaa\x4f\xe3\x5f\x98\x9a\x8c\x9c\x4e\x3e\x61\x3d\xd9\x75\x96\xe3\x09\x1a\x26\xb3\x14\xe5\xd1\x44\x9f\xfb\x05\x83\xf2\xc6\xf8\x2a\x3f\x26\xab\xcf\x1d\x3f\xd6\x12\xf1\xf6\x20\x09\xa3\xe1\x35\xe5\x84\x94\x0e\x2b\x60\xb1\xee\xc6\xa2\x77\x4a\x1d\x07\x7e\x3b\x85\x94\x97\x10\x6d\xc5\xc8\x14\x67\x4b\x92\xfb\x0b\xca\x70\x3e\x9b\xaa\x1f\x4a\x3c\x3a\xe6\x1f\xf6\xf7\x7f\xa1\xae\x1d\x65\x27\xfc\xfd\x5f\x3e\x34\xd0\x26\xda\xff\xc5\x4c\x8d\x26\x15\xf1\x69\x11\xdf\x1a\xcd\x58\x5e\xd2\x30\x95\xd9\xac\x7f\x81\x89\xa8\xe0\x3a\xfa\x37\x68\xf0\x63\x68\x9b\x46\x3f\xfe\x82\xe8\x93\x2b\xfa\xb1\x5c\x9c\x85\x39\x16\xe5\x8b\xeb\x50\x7b\x98\x63\xd1\x6c\x53\x34\xeb\x2b\xcd\xfa\xf3\x9a\xf5\xd5\x66\xfd\xc5\x9a\x85\x30\x3a\x51\x83\x2f\x41\x02\x24\x6a\xaa\x2b\xd0\x55\xb5\x05\x55\x9b\x7c\x31\x43\xd5\x86\xba\x4c\x1d\x33\xc2\xc8\xba\x8c\xb5\x22\xa0\xd6\x06\x3d\xd7\xeb\xb1\xfd\xe9\x47\x9f\x7e\xf4\xad\x1f\x9b\xf4\x63\xd3\xfa\xb1\x45\x3f\xb6\xac\x1f\xdb\x65\x6d\x76\xca\xda\xec\x96\xb5\xb9\x26\xda\x2c\xd1\x48\x55\xe2\x3c\x68\x71\xee\x83\xaa\x71\x20\x64\x2a\x29\x64\x3f\xa2\x7b\x49\xee\xea\x54\x5e\x4b\xd2\x47\x25\xce\xac\x16\xb1\xf7\xce\xbd\xbd\xc3\xe0\x16\x5e\x66\xc0\x85\xd4\xd2\xc7\x34\xd4\xd0\x6f\x40\x84\xa8\xf6\x1b\x99\x7b\xbe\x4a\xe0\x59\xec\xbd\xcf\xf5\x8a\x3e\xad\xd8\x64\x15\xd7\xb4\x8a\x1d\x67\xc5\x26\xad\xd8\x66\x15\x7d\xad\xe2\x9a\xb3\x62\x8b\x56\xec\x9e\x09\xd4\x94\x8a\x7e\x51\xf1\x4e\xbb\x58\x59\x94\x7a\x8a\x08\x8f\x1d\x7f\xcc\x52\xb2\xb3\xe0\xf1\xf0\x78\x9b\xe8\xf1\x1c\x0e\x63\x70\x02\x8e\x2d\x7e\xbc\x15\x5f\xab\x13\x1e\x92\x72\xf4\x0a\x6f\xba\xe3\x72\x2f\x3a\x99\xfa\x85\x1d\x4f\x71\x73\x5b\x7c\x8c\x2e\xe8\x97\x6e\x7b\xb5\xd5\xd4\xd5\x72\x62\x99\x08\x82\xad\x55\x74\x85\x52\xd6\x87\xf2\x45\x12\x41\x35\x83\x9f\xe3\xe0\x02\xa3\x64\x1c\x3a\x59\xed\x02\xf2\x43\xef\x03\x9d\xdc\x9e\x1e\xef\x50\x69\xb1\x17\x8c\x07\xb3\x31\x59\x61\x31\xbe\x74\x36\xdb\x63\x89\x60\x7a\x34\x11\x4c\xe3\xaa\x1d\xb6\xe0\xff\xd0\x12\x97\xd0\xf4\x7c\x2d\x3d\x96\x17\xa6\x47\xf3\xc2\x34\xae\x58\x8d\x16\xc4\x94\xef\x71\x01\xb5\x51\x47\x2f\x50\xad\xf7\x41\x7a\xfe\x2f\xe4\xa3\x0d\xd4\xa8\x9b\x10\x9b\x0c\x62\x93\x42\x64\x00\xdb\x0c\xa2\xaf\x41\xf4\x2b\x40\x6c\x31\x88\x2d\xa3\x5b\x35\xda\x8e\x02\xb1\x59\x01\x62\x9b\x41\x6c\x5b\x7b\xdd\xd2\x20\xb6\x2a\x40\xec\x30\x88\x1d\x6b\xaf\xdb\x1a\xc4\x76\x05\x88\x5d\x06\xb1\x6b\xed\x75\x47\x83\xd8\xa9\x00\x71\x8d\x41\x5c\xb3\xf6\xba\xab\x41\xec\xce\x85\x58\x88\xfd\x14\xa8\x52\x7d\x4d\xaf\xae\x7b\xc7\x08\x9a\x26\xbb\xcf\xf9\xf2\x1d\x16\x11\x29\x75\x7e\x05\xbc\x3a\x22\x5d\xeb\x59\x92\x70\xf0\x74\xf9\xe9\x6c\x90\xa3\x51\x74\x3e\x42\x41\x1c\xa2\x71\x72\x89\x82\xf4\x7c\x06\xe1\x5f\xc0\xcd\xf9\x7f\x67\x41\x6a\x24\xee\x81\x06\x02\xb4\x49\x5a\xe1\x52\x9c\x45\x79\x70\xde\xa7\x45\xe8\x2e\x61\x3d\x3e\xf1\x3e\x2b\x18\xa4\x38\x9b\x8d\x73\x94\x0c\xcb\x9a\x1f\xd1\x2d\xa0\x76\x1e\xa0\xa7\xe8\x3c\xa0\xae\x2b\xfe\x5a\x1d\x2d\x21\xfa\xaa\xcf\x5e\x75\xe0\x55\x1f\x5e\xd9\x90\x1c\x53\x40\x52\x57\xe8\x91\xf0\x29\x3a\xbf\x82\x19\xae\x03\x41\xf0\x02\x42\xec\x94\x0a\xd8\x12\xc1\x90\x0e\xfd\x76\x78\x84\x20\x9c\xa4\xfc\xf1\x15\xe5\x70\xe7\x23\xf4\x3b\x3a\x1f\x57\x65\x72\x76\xa5\xca\x6f\x8c\xc5\xbd\xa2\x2c\xae\x56\x7b\x55\x6c\xdf\x64\x27\x7b\x25\x89\x05\x75\x56\xa0\xab\x16\xe8\x16\x05\x74\x7a\xfe\x8d\x71\xc3\x57\x94\x1b\xd6\x68\x33\xc5\x7e\xfb\x8a\xf3\x3f\xd8\x6f\x97\x10\x69\xcd\x84\xd1\x64\x30\x9a\x1c\x86\xaf\x22\xe0\x1b\x18\x36\xd4\x02\x8d\x32\x0c\x5b\x0c\x7a\x8b\x43\x6f\xaa\x18\x36\x35\x0c\x7d\x0b\x86\x6d\x06\xa3\xcd\x61\xb4\x54\x04\x5a\x06\x86\x4d\xb5\x40\xb3\x0c\xc3\x0e\x83\xde\xe1\xd0\xdb\x2a\x86\x6d\x0d\xc3\x96\x05\xc3\x2e\x83\xd1\xe5\x30\x3a\x2a\x02\x1d\x03\xc3\xb6\x5a\xa0\x5d\x86\xe1\x1a\x83\xbe\x76\xa6\x90\x88\xc0\xb0\xab\x61\xd8\x51\x30\xac\x94\xf8\x23\xe3\x49\x27\x84\xae\xb5\x42\xda\x89\x79\xd7\x5d\x14\x56\x8e\xaf\x72\xf9\xde\x49\xd6\xa4\xf2\x50\x0a\x4a\x1a\x07\x7a\x5b\x64\xde\x5f\x4d\xc7\x01\xc1\xe6\x2a\x47\x4e\x70\x2c\xce\x4c\xad\x68\xd9\x06\x51\x5c\x5c\x95\x29\x75\xd5\xe4\x1d\x72\xc9\x7a\xd9\x1d\x94\x5c\xb0\xb2\x31\xb2\xa7\xde\x8d\x6c\x74\xda\x5e\x71\x29\xb2\xd1\xe9\x7a\xec\xae\x64\xa3\xeb\xdf\x9c\x79\x6b\x7f\xed\x48\x84\x0f\xf7\x55\x0f\xf7\x55\x5f\xed\xbe\x4a\x5b\xe2\xc5\x7d\x8e\x7e\x93\xf3\xd7\xba\xc3\xb9\xaf\xac\x70\xaf\xc5\xd1\xfc\xb5\x7a\x34\x7f\x7d\xdb\xa3\xf9\x6b\xf5\x68\xfe\xba\xec\x68\x3e\x4f\xc1\xfc\x70\x53\xf5\x70\x53\xf5\x70\x53\xa5\x7c\x79\xb8\xa9\x7a\xb8\xa9\x7a\xb8\xa9\x2a\x9a\x7d\xb8\xa9\xd2\x3f\x3e\xdc\x54\x39\x1e\x1f\x6e\xaa\x1e\x6e\xaa\x1e\x6e\xaa\xe0\xef\xe1\xa6\xaa\x9a\x12\xf7\xe1\xa6\xea\xe1\xa6\xea\xe1\xa6\x4a\xfa\x7b\xb8\xa9\x7a\xb8\xa9\x7a\xb8\xa9\x7a\xb8\xa9\xfa\x4f\xbe\xa9\xba\xb7\x3b\xaa\xdb\xdd\x4e\x55\xb9\x97\xaa\x70\x23\xf5\xb5\xee\xa2\xfe\xda\xf9\x50\x1e\xee\xa2\xfe\xfe\x77\x51\xf2\xdd\x51\xaf\x3d\xd7\xd1\x49\xbe\x39\xea\xb5\xa5\x6b\x23\x78\xf8\xfa\x77\x46\xd4\x4b\x53\xdc\x1a\xd9\x83\x0a\x70\x0f\xed\xb2\x6b\x25\x70\xe3\x94\x3d\x8a\xa5\x98\xe9\xa6\xbe\x22\x8e\x72\x94\xf5\x93\x2b\x13\xce\xb1\x40\xe7\x58\xbe\xa6\xe3\x7f\x36\x69\xb2\xd9\xe9\xba\x0f\xe5\xec\xd0\x1d\xcd\x57\xe3\xbe\xc6\xd7\x36\x3d\xae\xda\xa2\xc7\xfd\xc7\xe7\x36\xcc\x06\x85\x0c\x01\x8f\x2a\x11\xa1\x7f\xc8\xe3\xe4\x50\x1d\xb2\x4a\x64\x6b\xe3\x63\x7f\xaa\x00\x32\x23\xa1\x29\x9f\x8d\xa0\x68\xb6\xb3\x3f\xe9\x45\xed\x23\x5a\xa2\xe3\xb3\xc4\x1b\xad\xa3\x7f\x40\xaf\x1c\xb1\x14\x2e\x83\xa9\x1d\x67\xd8\x37\x4c\x0d\x81\x34\x01\xc7\x76\xc7\x78\xf2\x9a\xcc\xf8\xfc\xe9\xe9\x59\x55\xfc\x2c\xab\x86\x20\x9a\x8f\x2c\xcb\xac\x00\x74\x67\xb5\x1c\xd7\x84\x80\x16\xc4\xc8\xbf\x4e\xa6\xc7\xae\x32\x54\x5a\x16\x4e\xce\xcd\x4e\xd7\xa1\x10\x69\x38\x95\x21\xd6\x46\xab\x2a\x46\xa4\xf5\xa4\x29\x46\x8a\x41\x8b\xb4\x2f\x1f\x8b\xe1\x9c\x9b\x01\x1e\x94\x83\x6a\xf5\x4f\x32\x9e\xda\x7c\x88\xd5\x14\xd3\x65\x14\x53\x95\x5a\x6c\x59\x44\x11\x68\xd0\x69\xc2\x38\x46\x95\xca\x77\x85\x84\x1d\x84\x6b\x25\xda\x12\x82\x75\x13\x6b\x41\xa8\xea\x7b\xb5\xb3\x5f\x48\xdd\x1a\x5b\x53\xa4\x0a\xc3\xeb\xac\xc8\x6b\x10\xeb\x79\x0c\xb4\xe3\xd3\x7b\x88\x83\x62\xb9\xd1\x2a\x48\x3d\x32\xce\xee\x64\x2c\x94\xb9\x62\x62\x99\x82\xdd\xf7\x2a\xf7\xf6\xda\xf7\x21\xf4\xf6\xda\x0b\x4b\xbc\xe6\x1e\xab\x89\xbb\xbd\xb6\x35\xb6\x05\xdc\xd0\x44\x38\xbc\xc5\x0e\xbf\x9d\x26\x53\x65\x97\x67\x2f\x60\x10\xbe\x41\x54\xbc\x90\x34\xa7\x06\x9a\xd3\xf4\xfc\x64\xe2\x49\x29\x11\x6a\x0e\xf9\xcf\x9a\x32\x58\x3d\xd6\x1c\x41\x5d\x8a\xfa\xa5\xad\x62\x02\x6a\x43\x05\xa1\x46\x8c\xab\x24\xc4\x90\x36\x78\xc1\xf2\x3b\x0c\x32\x9e\x25\x1b\xb8\x30\x7c\x21\x78\x91\x5d\xfc\x67\xd8\xcc\x97\x97\xad\x7b\xf8\x02\xec\x1e\xcd\x49\x80\xf4\x1d\xad\x36\x32\x44\xf7\xb3\xe2\x00\xd2\xe2\xab\x8e\xd1\x7c\xf9\xca\x23\x85\xca\x4f\x9a\xbd\xf6\xd7\x3a\x66\xde\x2d\x5d\xdf\xb7\x3c\x5f\x7e\xb5\x53\xe0\xb7\x0d\xe2\x4c\x58\x15\xce\x70\x7a\x81\x1f\x3f\xaa\x0d\xea\xa8\xd9\xf0\x9b\xa8\x7f\x8d\x7a\xff\xdf\xff\x1b\xa6\xd1\x00\x1d\xe0\x2c\x8e\xc6\x2b\x68\x6b\x3c\x46\x69\x74\x3e\xca\x33\xc4\xca\x87\x2b\x8f\x1f\x3f\x3a\xc2\x61\x94\xe5\x69\xd4\x9f\x01\xfc\x20\x0e\x21\x28\x4f\x14\xa3\x2c\x99\xa5\x03\x0c\x6f\xfa\x51\x1c\xa4\xd7\x84\x1d\x4c\x32\x8f\x45\x69\x48\xe1\xdf\x64\x96\xa3\x09\xf0\xf4\x01\x70\x56\x0f\x05\x29\x46\x53\x9c\x4e\xa2\x3c\xc7\x21\x9a\xa6\xc9\x45\x14\xe2\x90\x06\x9d\x20\xeb\x74\x98\x8c\xc7\xc9\x65\x14\x9f\xa3\x41\x12\x87\x11\x5d\xc3\xa4\xd2\x04\xe7\x1b\x6c\xc5\x2f\x23\x15\xad\x0c\x14\xc3\x14\x9f\x41\x12\x62\x34\x99\x65\x39\xd9\xa8\x83\x28\x06\xa0\x41\x3f\xb9\x20\x9f\xa6\xd7\xd0\x45\x14\x27\x79\x34\xc0\x1e\x8d\x2b\x34\x8e\x32\xd0\x2c\xcb\xed\xc5\xa1\x86\x4c\x18\x65\x83\x71\x10\x4d\x70\xba\xe2\xc2\x21\x8a\xe5\x81\xe0\x38\x4c\xd3\x24\x9c\x0d\xf0\xbd\xa3\x81\x58\xd7\xc2\x64\x30\x13\x71\x30\x48\x8d\xd5\x24\x65\x31\x32\x26\x41\x8e\xd3\x28\x18\x67\xc5\x30\xc3\xdc\x40\x35\x09\x75\x32\xcf\x27\x7b\xfb\xc7\xe8\xf8\x70\xf7\xe4\xd7\xad\xa3\x1d\xb4\x7f\x8c\xde\x1d\x1d\xfe\xb2\xbf\xbd\xb3\x8d\x5e\xfe\x0b\x9d\xec\xed\xa0\xde\xe1\xbb\x7f\x1d\xed\xbf\xda\x3b\x41\x7b\x87\x6f\xb6\x77\x8e\x8e\xd1\xd6\xdb\x6d\xd4\x3b\x7c\x7b\x72\xb4\xff\xf2\xfd\xc9\xe1\xd1\x31\xfa\x71\xeb\x18\xed\x1f\xff\x08\x1f\xb6\xde\xfe\x0b\xed\xfc\xf6\xee\x68\xe7\xf8\x18\x1d\x1e\xa1\xfd\x83\x77\x6f\xf6\x77\xb6\xd1\xaf\x5b\x47\x47\x5b\x6f\x4f\xf6\x77\x8e\x3d\xb4\xff\xb6\xf7\xe6\xfd\xf6\xfe\xdb\x57\x1e\x7a\xf9\xfe\x04\xbd\x3d\x3c\x41\x6f\xf6\x0f\xf6\x4f\x76\xb6\xd1\xc9\xa1\x07\x8d\x9a\xd5\xd0\xe1\x2e\x3a\xd8\x39\xea\xed\x6d\xbd\x3d\xd9\x7a\xb9\xff\x66\xff\xe4\x5f\xd0\xde\xee\xfe\xc9\x5b\xd2\xd6\xee\xe1\x11\xda\x42\xef\xb6\x8e\x4e\xf6\x7b\xef\xdf\x6c\x1d\xa1\x77\xef\x8f\xde\x1d\x1e\xef\x20\xd2\xad\xed\xfd\xe3\xde\x9b\xad\xfd\x83\x9d\xed\x15\xb4\xff\x16\xbd\x3d\x44\x3b\xbf\xec\xbc\x3d\x41\xc7\x7b\x5b\x6f\xde\x58\x7b\x49\x70\x57\xfa\xf8\x72\x07\xbd\xd9\xdf\x7a\xf9\x66\x87\xb6\xf4\xf6\x5f\x68\x7b\xff\x68\xa7\x77\x42\xba\x53\xfc\xea\xed\x6f\xef\xbc\x3d\xd9\x7a\xe3\xa1\xe3\x77\x3b\xbd\x7d\xf2\x63\xe7\xb7\x9d\x83\x77\x6f\xb6\x8e\xfe\xe5\x31\x98\xc7\x3b\xff\xf7\xfd\xce\xdb\x93\xfd\xad\x37\x68\x7b\xeb\x60\xeb\xd5\xce\x31\xaa\xcd\x19\x92\x77\x47\x87\xbd\xf7\x47\x3b\x07\x04\xe7\xc3\x5d\x74\xfc\xfe\xe5\xf1\xc9\xfe\xc9\xfb\x93\x1d\xf4\xea\xf0\x70\x1b\x06\xfa\x78\xe7\xe8\x97\xfd\xde\xce\xf1\x73\xf4\xe6\xf0\x18\x46\xeb\xfd\xf1\x8e\x87\xb6\xb7\x4e\xb6\xa0\xe1\x77\x47\x87\xbb\xfb\x27\xc7\xcf\xc9\xef\x97\xef\x8f\xf7\x61\xd0\xf6\xdf\x9e\xec\x1c\x1d\xbd\x7f\x77\xb2\x7f\xf8\xb6\x8e\xf6\x0e\x7f\xdd\xf9\x65\xe7\x08\xf5\xb6\xde\x1f\xef\x6c\xc3\xe8\x1e\xbe\x85\xae\x9e\xec\xed\x1c\x1e\xfd\x8b\x00\x25\x63\x00\x83\xef\xa1\x5f\xf7\x76\x4e\xf6\x76\x8e\xc8\x80\xc2\x48\x6d\x91\x21\x38\x3e\x39\xda\xef\x9d\xc8\xc5\x0e\x8f\xd0\xc9\xe1\xd1\x89\xd4\x47\xf4\x76\xe7\xd5\x9b\xfd\x57\x3b\x6f\x7b\x3b\xe4\xeb\x21\x81\xf2\xeb\xfe\xf1\x4e\x1d\x6d\x1d\xed\x1f\x93\x02\xfb\xb4\xd9\x5f\xb7\xfe\x85\x0e\xdf\x43\x97\xc9\x1c\xbd\x3f\xde\xa1\x3f\x25\x8a\xf5\x60\x26\xd1\xfe\x2e\xda\xda\xfe\x65\x9f\xa0\xcd\x0a\xbf\x3b\x3c\x3e\xde\x67\x74\x02\x43\xd6\xdb\x63\xc3\xbd\xf2\xf8\xd1\xd3\x55\x55\xe7\x75\x10\xe4\xa3\xfb\xd5\x7b\x55\x8b\x3a\x4d\x03\x1f\x8b\x22\xf4\xb1\x92\x75\x36\x5c\xd8\x05\x71\x9e\xa1\x3c\xe8\x73\x89\x85\x54\xf9\xf0\x79\x6c\x0d\xb6\x59\xc8\x51\x0d\x0f\x21\xdf\x43\xa8\xe9\x21\xd4\xf2\x10\x6a\x7b\x08\x75\x3c\x84\xba\x1e\x42\x6b\x1e\x42\xeb\x1e\x42\xcf\x3c\xe4\x37\x3c\xe4\xfb\x1e\xf2\x9b\x1e\xf2\x5b\x1e\xf2\xdb\x1e\xf2\x3b\x92\x85\xe5\x1a\xad\x4b\xbe\x11\x78\xa4\x3c\x81\xe1\x77\x28\x5c\x52\x0f\xda\x7a\xc6\xe0\x37\x19\x0c\x1f\xda\x28\xe0\xb4\x58\x5b\x6d\x86\xcb\x33\x06\x63\x5d\xc2\x73\x8d\xc1\xea\x32\x5c\x7c\x0a\xd3\x97\x63\x2d\xfb\xac\x2e\xc7\xa5\x41\x61\x00\x1e\x1c\xcf\x16\x85\x45\xe0\xfb\x72\xbf\x65\x38\x6d\x56\xb7\xc3\x70\x5f\x63\x30\x9a\x12\x9e\x3e\x83\xb5\xce\x70\x61\xfd\xf6\x5b\x67\xf5\xe7\xf2\x5c\xa4\x73\xe6\x82\xe3\xb1\x26\x8d\x55\x93\xc1\xe4\x38\x77\xd5\xf1\x80\xbe\xb5\xb4\xbe\x77\x59\x9d\x56\x01\x0b\xea\x76\x0a\x9c\x39\x0c\x3e\x1e\xd0\x96\xaf\xf5\x1d\x0a\x75\xa4\x0e\xae\x31\x04\xbb\xc5\xe0\x0a\x20\x4d\x69\xa0\x29\xb2\x05\xa0\x75\x56\x47\x1a\x2c\x98\x98\x4e\x31\xb8\x02\x46\x4b\x1a\x68\x8a\xac\x84\x50\x93\x8d\x6c\x43\x02\xc6\x47\x63\x4d\xcc\x9e\xa0\x50\xc4\x46\x87\x22\xab\xce\x46\x36\x6f\x65\x50\x14\xd9\x58\x01\x7a\x72\x4b\x9c\xb6\x5a\xd2\x78\x76\x8b\x6f\x0a\x4d\xaf\x79\xf0\x09\x86\x8a\xd3\xeb\xb3\x82\xf6\x38\x4d\xf9\x1d\x69\x58\xd7\x58\x59\x65\x3e\xfc\x82\x08\xc4\x5c\x3c\x63\x05\x39\xf1\xac\x4b\x65\x38\xe2\x6b\xf0\x5b\x3e\x4b\x89\xb5\xdc\x2e\xaa\xf2\xf6\xc5\x9a\x97\xd7\xc4\xba\x02\xb2\x00\xc5\xd7\x67\xa7\xa0\x7d\xd1\xcf\x66\x81\x82\x18\x27\x46\x32\x14\x2e\xd2\xa6\x64\xde\x02\x61\x88\x29\x83\xdf\x29\x10\x80\x7e\xae\x15\x0b\x11\x1a\x6c\x33\x44\xba\x1a\xd2\x2d\x75\xf0\x45\xa7\xfd\x02\x8e\x18\x3b\xb1\xa0\xe1\xbb\x02\x47\x30\x10\x5f\x1a\xa4\x6e\xd1\xae\x58\x78\x6c\x01\xfb\x2d\xcb\x7c\x88\x0e\x68\x88\x73\x40\x62\xc1\x35\xa5\x7f\x3b\x62\x15\xab\x03\xd4\xb1\x94\x6b\xab\x33\x23\x66\xb2\xe8\x14\xf2\x7d\x74\xa6\x64\xc9\xfe\x30\x22\x2b\xc4\x32\x1f\x48\x84\x6a\x6e\x78\xa8\x71\xd5\xd9\x5a\x6f\xae\x3d\x7b\xf6\x8c\xfc\xee\xee\x6c\x3f\xdb\x79\xb9\xe5\x93\xdf\xeb\xbb\xfe\xcb\x97\xbd\xed\x1e\xf9\xbd\xf5\xac\xd3\xda\xdd\x6e\xef\xa8\xf3\x3d\x4a\x9d\x0d\x74\x1a\x5b\xcd\xf5\x97\x3b\x5d\x68\xa0\xd7\xde\xde\xf6\x9b\x6d\x68\x60\x7b\xad\xd1\xda\xd9\x6d\x91\xdf\x6b\x5b\xdd\xed\xb5\xee\x0e\x34\xcc\x11\x3a\xb3\xea\x03\x8e\xf6\xdf\xed\x1c\x6c\xfb\xdd\x06\x84\xdf\x9f\xa3\x43\x12\x65\x0b\x2d\x92\xf4\x8a\xee\xca\xb7\xbd\x2b\xa2\xca\x44\x40\xc2\x11\x04\xbb\xbb\xd6\xee\x34\x5b\x0d\x18\xc1\x9d\xdd\xde\xf6\xd6\xcb\x75\xe8\xe0\xb3\xf5\x97\x5b\xdb\xbd\xdd\x1d\xf2\xdb\x6f\xb4\x9a\x9d\xf6\x1a\x0c\x4e\xaf\xb5\xdd\xdc\xf1\x77\x1b\x67\x4e\xd5\x78\x55\xa5\xbc\x55\xb1\x5b\xd9\x4b\xc9\x2f\xb9\xa9\x99\x6f\x8e\x4f\xb1\x00\xdd\x6b\x61\x16\xe9\xb8\xbe\x39\xf8\x20\x95\xe6\x97\x07\x1f\x4c\x43\x26\x54\x76\xa7\x22\xd5\x43\x9b\xa8\x66\x16\x40\xd4\x00\x54\x6a\xac\x30\x7c\x90\x5e\x2e\x66\x54\x6a\x00\x64\x76\xa5\x1a\x40\xd3\xba\xd4\x04\x57\xa2\x1a\x43\xf3\x6c\x9d\xf7\x90\xb8\x7f\x20\xa4\xe8\xbc\x72\x04\x06\xf0\x61\x34\x76\x17\x48\xa1\x40\xea\x2c\x00\xe2\xe7\x87\xcf\x6e\x08\x20\x13\x7d\xf8\xec\x86\x00\xdb\xf4\x87\xcc\x0d\x01\x36\x8d\x0f\x59\x6a\x8f\x68\xbd\xba\x4a\x56\xd9\x27\x72\x68\xbe\x08\xd2\x88\x48\xc7\x96\x4b\xda\x60\xec\xa1\xfe\xd8\x43\x83\xb1\x87\xc2\xb1\x87\xf0\xd8\xd2\x50\x90\x7a\xa8\x9f\x7a\x68\x90\x7a\x28\x4c\x3d\x84\x53\xbd\xb1\x80\xa0\x12\x10\x84\xf7\x4c\x97\x91\x7e\x0a\x41\xc7\xe1\xa3\xaf\x7f\x1c\x90\x8f\x03\xfa\xb1\xa9\x7f\x0c\xc9\xc7\x90\x7e\x6c\xe9\x1f\xe1\xc0\x80\xe9\xc7\xb6\xfe\x51\xa4\xa9\x0e\xd4\xbc\xd4\xbc\x4b\xfa\xad\xa0\xd5\x94\x10\xfe\x5d\xda\x44\xbe\x75\x6d\xe7\x64\xf9\x04\x63\xb4\x54\xac\xa9\xa5\xcf\xe3\xd3\xe8\xec\xac\xfe\xc5\xe6\xc4\x00\x5e\x3b\x2f\xfc\x6e\xfd\x8f\xc7\x8f\x54\xd6\x48\xda\x40\x43\xbf\xd6\x1f\x7b\x83\xb1\x17\x8e\xeb\x68\x09\x8d\xc6\x76\xdf\x9b\x1b\x24\x14\x72\xd1\x8b\x56\x93\xaa\xda\x2c\xd0\x9a\x3a\x34\x63\xe4\x0d\x68\xed\x75\x27\xb4\x96\x0e\xcd\x98\x2a\x03\x5a\xb7\xed\x84\xd6\xd6\xa1\x19\x73\x2b\x41\xfb\x63\x75\x95\x41\x5c\x6f\x38\x21\x76\x74\x88\x06\x41\x20\x7b\x98\x74\x32\x89\xb9\x75\xba\xc8\x17\x94\x26\xf9\xb8\x96\x7b\x19\x99\x56\x9b\xd3\x06\xd0\x40\xbe\x84\xc7\xf6\x29\x87\x15\x61\x2c\x29\xf2\x07\x74\x1b\xda\xbe\x00\xb9\x43\xbb\x64\x4d\xfa\x56\x37\x20\x58\x2f\x7d\x5b\x6d\x58\x66\xc6\x4d\xa2\x40\x35\x48\xd1\x92\x44\xad\xe9\xed\xa9\xb5\x53\xeb\xa7\xde\x20\xf5\xc2\x14\x46\x3c\xbd\x1b\xb5\xb6\x75\x68\x77\xa5\x56\x15\xda\x9d\xa8\xb5\xa9\x43\xbb\x33\xb5\xfa\x3a\xc4\x7b\xa6\xd6\x14\x6e\xad\x4b\xc8\x35\x75\x90\x2b\x70\xd4\xd4\x46\xae\xc0\x88\x6d\x5f\x80\x45\x53\x72\x4d\x9d\xe4\x0a\x1b\x80\xad\x36\x6c\x0d\xa6\x85\x86\xce\xca\xf7\xe5\x74\x0c\x20\x43\x82\xd5\xaf\x26\x61\x92\xff\x6c\xa2\xda\x1e\x35\xcd\x1d\x10\xce\x1c\x5a\x7a\xba\xc7\x4c\x78\xf7\xa8\xf9\x6d\x48\xca\xd9\x46\x64\x8f\x99\xe9\xee\x51\x43\x5a\x4c\xca\x05\xd6\x72\x2d\x56\x0e\x8c\x65\x61\x47\xe8\x5b\xcb\xb5\x59\x39\x30\x4c\xee\x93\x72\x03\x6b\x39\x30\x60\x56\x86\x45\x17\x6b\x77\x59\x6a\x8d\x3b\x98\x67\x85\x41\x1e\x08\x61\x88\x3c\x58\x36\xfe\xf9\x69\x18\x79\xc9\xf8\x65\x94\x67\x27\x49\x0e\x1c\x8f\xc2\x8c\xb7\x83\x3c\xa0\x56\x5b\x4f\xd1\xba\x05\x3a\xd4\x79\x83\x87\xb9\x91\xb4\x11\xca\x1b\x9d\xd9\x0a\x43\x33\x0b\x31\x62\xf9\x16\xa9\x31\x53\x01\x92\x48\x93\x9d\x33\xf4\x65\x93\x26\x16\x2e\x6c\x24\x44\x89\x7f\xa0\x56\x53\xa7\xd6\x02\x52\xad\x56\x2b\x8a\x2e\x21\xc2\x1f\x08\xc8\x67\x75\x02\xaa\x4d\xd6\xad\xdf\x76\x08\xd0\xbc\x2a\x1d\x8e\x42\x78\x96\x5e\x56\x17\x9e\x0d\x60\x4c\x70\xd6\x80\xcd\x13\x9c\x6d\x1d\x95\xf3\x74\x14\xf9\x30\x79\x8e\x1d\x30\x8e\xb1\xa4\xed\x58\x5d\x85\x93\x20\x82\xec\x2e\xd4\x21\xcb\x6a\x38\x35\xa5\x27\x2f\x33\x9b\x4b\x39\x59\xc2\xea\x96\x65\x74\x0b\xe1\xec\xa1\x4d\x24\x8b\xef\x77\x3b\xbf\x75\x2a\x1d\xdf\xec\x27\xb2\x3d\x38\x8a\xed\x59\x9c\x49\x50\xd9\x19\x6c\x4f\xb8\xeb\xed\x29\xc7\xab\xbd\x85\xcf\x55\x94\x42\xf6\x94\x33\xd5\x9e\xf3\x30\x35\xdf\x14\xee\x88\xde\x84\xd3\xc9\x65\x19\x2c\x42\x18\x6c\xb5\x28\xbb\x31\xd7\x26\x48\x61\x53\x83\x71\x12\x97\x33\x28\x30\x25\x20\xa5\x0a\xed\x02\x3c\xba\xcd\x20\xe8\xe7\x0f\x06\x91\xd0\x7a\x26\xad\x31\x34\xe1\xab\x62\x17\x05\x3f\x6f\xe8\xed\x3f\x92\x2d\xe2\x86\x7e\xed\xca\x43\xd7\x1e\xfa\x6c\x4b\xf3\x51\xab\x5d\x81\x67\xe7\x35\xfc\xf7\x73\x91\xad\xfd\xc6\x80\xd3\x2c\x87\x53\xbb\xaa\xff\x54\xbb\xae\x53\x77\xf2\x7f\x93\x87\xcf\xf5\x7a\xfd\xb9\x0b\x5a\x6b\x2e\x34\x02\xe8\xdf\x04\x62\x81\x9a\x03\x56\x7b\x3e\xac\x9f\x00\x02\xe0\x76\x5d\xff\xa9\xf6\x6f\x40\xce\x0d\xb1\x53\x65\xcc\xc8\xa0\x7d\x29\x40\x39\x60\x81\x28\x71\xe5\xc5\x56\x48\x57\x2f\x5e\xc4\x80\xd5\xd5\xcf\x3f\xff\x5c\x6b\x35\x97\x63\x19\x29\xfa\xa3\xd4\x1a\x86\x1b\xc3\xd0\x3c\x70\xd5\x8c\x61\x9c\xd9\x7e\x98\x7d\x0b\xd8\x3c\xf1\xdf\x79\x42\x39\x93\x09\xc6\x91\x9f\xc7\x51\xfa\xb6\x89\x79\xd8\xca\x28\x2c\x59\xb8\x02\xaf\xf6\x84\xa1\xf8\xc4\x62\x85\xe3\xae\x75\xc9\xb1\xb5\x99\xdb\x98\xca\x41\xcd\xd4\x86\x17\xa8\x66\xaa\xc4\x27\xe7\xff\x67\xef\xfd\xb7\xdb\xc6\x91\x84\xd1\xbf\xa7\x9f\xa2\xb2\x67\x26\x96\x62\x5a\x26\x48\x4a\xa2\x9c\x28\xf9\xd2\x69\x67\x3a\x3b\x8e\x93\x2f\x71\x6f\xf7\x7e\xee\xa4\x97\x3f\x20\x8b\x1d\x89\x54\x93\xb4\x2d\xcf\x24\x73\xee\x6b\xdc\xc7\xb8\xaf\x70\x1f\xe5\x3e\xc9\x3d\x28\x80\x24\x48\x02\xa4\xec\x24\xb3\x3b\xbb\xad\x3e\xed\x48\x24\x50\x28\xd4\x2f\x14\x0a\x40\xe1\xfb\x97\x4f\x9f\xfd\x03\x58\xd3\x51\xfd\x03\xbd\xc1\xaa\x19\x0d\x52\x9a\x6b\xee\x4e\xd2\x30\x14\xaf\x1c\xfc\x82\x0c\xe5\x17\x19\x96\xac\xf9\x7e\xed\x05\x15\x7b\xe4\x2d\x56\x0a\x0e\xd5\x0a\xb7\xb9\xb4\xf6\x02\x05\xa7\xfe\xf0\x89\xaf\x03\x6b\xb6\x46\x15\x25\xd5\xb7\x13\x7d\x7a\x67\x4c\xa7\xbf\x6f\x71\xfa\xef\x70\x64\xe5\x6b\x2f\xdd\x37\x12\xab\x49\x0d\x6b\x53\xa6\xbd\xfd\xfe\xe9\x01\xd9\x61\x25\xa3\x7d\x57\xf5\x97\x5c\xbf\x98\xe3\xe9\xd3\x6a\x09\x23\x8a\xa3\x7c\xa0\x48\x40\x55\x5f\xd2\xa0\x8b\x20\xf4\x7c\x77\xa6\xc8\xcd\x64\x6e\x67\xae\xef\x85\xc1\x82\xd6\xd6\x38\x54\x05\x03\x3b\xb4\x28\x59\x98\xf5\x77\x9f\xbf\x04\xa2\xf3\xd0\xd5\xce\x77\x3b\x82\xde\x02\xb0\x4b\xec\x59\x1d\x2e\x66\xaf\x7c\x75\xb0\x18\x1d\x46\x75\xa8\x18\xa7\xab\xea\x40\x31\x7b\x45\xcb\x30\x71\x0b\x53\x6d\x9c\x58\x1b\x13\xd6\xcc\x16\x30\xee\x03\xfc\x84\xa9\x26\x17\xcc\x8f\xdc\xf1\xaf\xa7\xc0\xa8\x9f\x3d\x2d\x3e\x45\x40\x49\x0d\xa8\x38\xe7\xf0\xe3\x79\x04\x07\x60\xbf\x83\xf7\xe2\xab\x5b\x7d\x25\x8e\xf4\x7d\xa2\xbb\x3b\x52\xa0\x34\x88\xf1\x70\x2c\x9f\x5b\xe2\xf4\xc1\x26\xea\x34\x35\xea\x99\x10\x86\x96\x06\x1e\x03\x32\x46\x20\x1e\x9f\xc9\x4c\xf1\x80\x2c\x85\x7d\x6c\x48\x17\x68\x84\x47\x60\x99\x5a\xaa\x61\xd8\x6c\x30\xf0\xe1\x3e\x04\xdc\xcf\x65\x5f\x43\x84\x6c\x6e\xc7\x1e\x5f\x85\xed\x09\xf1\xc1\x23\x70\xfa\x9a\xf0\xe1\x3d\x04\xf0\x1e\x42\x0e\x79\x42\xc3\x19\xf5\x3d\x55\xd2\xa1\x06\xe4\xc9\x2d\x90\xe7\xb8\xb3\x6f\x81\xe8\xc5\x01\x98\xdb\xa9\x49\x1d\xc7\xb6\x1c\x7d\x5b\x87\x0f\xca\xe6\x5c\x73\x08\x0f\x0e\x77\xee\x0b\x83\x6f\x8f\x67\xa1\x4d\xad\x66\x94\x07\x34\x2c\x65\xfa\x12\xaa\xc2\x7d\x30\x87\x40\x15\xe2\x03\x6c\xf2\xd1\x23\xb0\x4d\xd1\x4b\x64\xbf\xf2\x6e\x51\x98\x83\x0a\x0f\x6f\xb7\xd3\x5a\x3b\x05\x03\x45\x10\xad\x08\xb6\x79\xcd\x13\xde\x50\x0b\x04\x62\xc0\xb0\x95\xf9\x04\x6a\x41\x40\x0c\x16\x06\xea\x32\xb6\x1c\x28\x0c\xd5\x65\x1c\x39\x48\x48\x9b\x65\x7e\x0f\xf0\xfd\x57\x0d\xf0\x31\x5f\x78\xb4\x58\x25\x49\x2a\xc7\xdc\x0e\x71\xa0\x16\x9f\xcf\x6a\x04\x73\x21\x54\x90\x7b\xe2\x74\xad\x30\xdd\x57\x8a\xd0\xdd\x32\x0e\xa4\x0c\xd7\xfd\x33\x46\x83\x7e\x0f\x21\xb4\x82\x01\xcc\x7d\xbe\x55\xf4\x00\x2b\x74\x05\x0e\xea\x0e\x79\x3d\x66\xc0\xde\xfd\x1e\x2e\xf8\xa2\xe1\x02\xe4\xc7\x0e\x91\x02\x35\x5b\xaa\x20\x81\x60\x8d\xfe\xd8\x14\x2b\xa0\x0f\x0b\xb8\xff\xd4\x09\x36\xb2\xa5\x67\x8d\x27\x5f\x3b\x37\x86\x68\xe5\x7f\x4e\xf8\xa0\x15\x1e\x90\xe7\xf0\xd6\x78\x52\x9b\xc5\x4b\xa7\xb0\x9b\x51\x01\xcb\x72\x76\x8b\x0b\xb0\x82\x35\x98\xf8\x9b\x03\xff\x87\xc6\x06\x02\x62\x8e\x67\x34\x74\xd9\x94\xdf\x9e\x4c\x83\x70\x6c\x4e\xf1\xbb\x39\x35\xc3\x90\xe0\xf7\xc5\xd4\xa4\xe3\x99\xad\x8e\x19\x2c\x16\x81\x69\xfa\x36\x06\x17\x26\xee\xd8\x25\x63\xc2\xbf\x3b\x8b\x99\xbb\xf0\x10\x80\x4f\x17\x9e\xb3\xf0\x9c\x5b\x84\x0b\x76\xf2\x3c\x25\xb3\x2f\x48\x27\xd5\xec\x38\x45\x8b\x16\xb5\x74\x67\x0e\xe6\x6d\xe7\x45\xb3\xb0\xf4\xfb\x10\xdd\x33\xe2\x5a\x96\x73\xdb\x41\x9a\x55\xe9\x19\xa6\x6b\xda\xd1\x1a\xa8\x2d\x4b\x7d\x88\xfd\xf7\xa1\xfa\x33\x86\x6a\xc6\x95\xdd\x06\x6b\x25\x73\x6a\xc3\x35\x67\x50\xe7\x80\x6d\x59\xcd\xa3\xce\xd2\xb9\x66\x31\x1c\x1d\x4d\x67\x6c\x00\x9f\xfd\x1e\xd7\xff\xcf\x19\x98\xff\xf9\x8e\xe5\xbd\xe0\x97\x38\x44\x7f\x2d\x4f\xe5\x42\x9a\x5c\xc6\x21\x04\xf5\xf3\x7a\x52\x0f\xbe\x6f\x5e\x9d\xf2\x97\xfa\x32\x40\x11\xa8\xa5\x15\x0c\xfe\x46\xe5\xc1\x80\xbc\xa4\x1c\x65\xaf\xd3\x68\x4d\x07\xb1\x72\x18\xcb\x7e\x4b\xf3\xd3\x62\x9e\xcf\x7e\x0c\xe2\xe6\x3c\xb3\x0c\x04\x73\x76\xc2\x1c\xac\x87\xc5\xf7\x47\x73\x0e\xa1\x78\xd0\x11\x1b\xbe\x37\x88\xe1\x4f\xa2\xd8\x50\x1b\x2f\x14\x3a\xba\xf0\x56\x19\xed\xdf\x15\xd8\x8c\x8f\x15\xf3\xf1\xf4\xb2\x3e\xc3\x55\x90\xe5\x82\xe6\xcf\x53\x0f\xbf\x7b\xab\x6f\xa3\x3c\x53\x10\xa8\x5c\xc2\x8f\xe1\x00\x06\x31\x66\xf6\x1c\xc2\x83\x5a\xf0\xa3\x19\xc9\x92\xda\x2a\xa2\xd4\x72\x66\x76\x7c\x86\x0c\x69\xe4\xef\xb9\x5e\x46\x2b\x0a\x03\xf1\xee\x11\x88\x2d\x99\x4d\x2a\x56\xdc\xd4\x12\xba\x04\xe1\x6a\xa9\xfc\xfd\x39\x2f\x84\x69\x47\x5b\x84\x40\x59\xd8\x24\xd7\x83\xd8\x00\x02\x87\x60\x0d\x77\xc8\xd8\x0e\x78\x13\xca\x6d\xc0\xda\x43\x65\xf2\x6c\x0e\x62\x7f\xbf\x27\x14\x1a\xd7\x4a\x14\x1e\xd2\xa0\x82\x79\xf7\x35\x36\xe6\x78\xef\xe6\x4d\xb7\x3d\xf4\xaf\xbe\xd2\xf6\xfd\x28\x5b\x45\x01\x1d\x98\xc3\xdf\x57\xbd\x76\x5e\xf5\x6a\xbd\x5a\xe0\xab\xb1\xea\xd5\x05\xbe\x6a\x2d\x18\xa1\xcf\x82\xaf\xa6\x9f\xbd\x8c\x36\xe9\xc8\x75\xff\x8f\x5e\x46\xbb\xf0\xd6\x6b\xcf\xdc\x96\x8b\x69\xa4\x45\x94\x76\x69\xdc\x68\x3c\x28\x6a\x3e\x7a\x04\x16\x5f\xf4\x2a\x9e\x3c\x7e\xfc\x18\xa6\xc3\x21\xc0\x7b\x35\xa4\xfa\xa7\x06\x89\x38\x2d\x48\xc4\x1d\x0e\x77\x83\x54\xaf\x67\x2b\xcd\x4b\xad\x27\xa4\xea\xb7\x72\x93\x7c\xbd\xb0\xd4\x6d\xc2\x91\x95\xba\x4d\xb6\x45\xbe\xe9\x1d\x91\xad\x43\xb2\xdb\x90\x66\xb7\xec\x76\x51\x4f\x7d\x27\x01\x54\x82\x23\x98\xb8\x2f\x7a\x8e\x49\x7e\x45\x0f\xf7\x3b\x17\x4c\x75\xab\x9f\x01\x9e\x6a\x1c\x50\xb8\x0f\x0b\xdc\xec\xf6\x77\xf6\xf5\x42\x77\x85\xcb\xda\xc3\x0c\x73\x1e\xdc\x07\x1f\x8b\x7b\x7c\x75\xf0\x3d\x88\x75\x42\x15\xfe\xe8\xac\x44\x17\x0c\xf1\x72\xa9\x55\x2c\xb6\x89\xb5\x56\xbe\xf5\x8f\xbf\x21\x33\xe9\x0d\xb1\x6b\xaf\x6a\x95\xd4\x63\x5b\xd9\x18\xde\x53\x33\xa0\x28\xe3\x3c\x73\x32\xc5\x7a\x13\x01\x91\xbf\x21\xd2\x1b\x42\xe4\x57\x53\xbe\xb3\x95\xbf\xb2\xc6\xea\x11\x0f\x17\x90\x59\x4b\x4b\xd8\x2f\x9a\xdd\x67\x44\xdd\xe7\x17\xbd\x69\x17\x8f\xb1\xa2\x05\xf3\x82\x30\xfb\x8c\xb4\xaa\x16\x98\xe1\xba\x50\x00\x60\xb6\xae\x99\xa7\x9d\x7d\x98\x79\x54\xb9\x5f\x98\x3b\x13\x6f\x4b\x20\xaa\x65\x3e\xe8\x59\x22\x6d\x66\x5b\x87\x9e\xe5\xd0\x41\xce\x08\x91\x5b\xaa\xb6\xfe\xa7\x2c\x8d\xf2\x32\x63\x51\x06\x53\x86\x2f\xd4\x65\x26\xa2\x0c\xa6\x04\xbf\x50\x97\x99\x8a\x32\xa8\xf3\xcb\xdf\x97\x61\x7f\x5f\x86\xfd\x7d\x19\xb6\xed\x6d\xfe\xbe\x0c\xfb\x5f\x32\xc6\x3b\x9e\xdc\x3a\xc6\x3b\x9e\xf4\xc6\x78\xe5\x39\x5b\x3b\xc6\x3b\x9e\xfc\x1e\xe3\xfd\xe2\x31\xde\xf1\x64\xd7\x18\xaf\x8a\x39\xf5\x18\x2f\x32\xa8\x7b\xd3\x76\xb9\x76\xa6\x5e\x9a\x75\xcd\x7f\xea\xa5\xd9\xed\xc4\xf9\x87\x5c\x5c\x50\xb6\xf3\x7b\x14\xb8\x1e\x05\xde\x4e\x70\x4d\x75\xb4\x9d\x38\xd2\xf3\x9f\x26\x8e\xc8\xd2\x8d\x25\x46\x52\x9e\xe8\x5b\xe5\x74\x93\xfa\xf7\xe6\xfb\x57\xbf\xbc\x7a\xfe\xfc\xed\xf1\xd9\xdb\x66\xb4\xf8\xf5\x8b\x5f\x5e\x9c\x7e\x77\xfc\xd3\x71\xfb\x56\xee\x37\xaf\x7e\x38\xfd\xee\x97\x67\xaf\x4e\xdf\x9e\x3d\x3d\x2d\x6b\x4a\xcd\xf1\xb0\xf2\xb3\xdd\xc2\xca\x52\x8d\x74\x99\x14\x49\x5b\x1a\x31\xe9\xa2\x69\x36\xbb\x26\x06\xdc\xe8\x52\x95\xe7\x3c\x24\x92\xc3\x23\xb0\x9c\x87\x90\x2b\x42\x22\x52\x9f\xcf\xb7\xb0\x0f\x63\x78\x00\x37\xfc\xf4\x60\x5e\x1c\xd2\xc4\x6f\xd6\x10\x23\x95\xf0\x27\x98\xb4\x7c\x11\x74\x03\xe9\xf5\x4f\x30\x87\x1b\xf8\x13\x8c\x55\x5e\x22\xbd\xfe\x77\x06\xd5\x82\x07\xc0\xda\xb1\x59\x3b\x43\x45\xe1\x2d\x0f\xcb\xfd\xd4\x78\x7c\xc3\x1f\xff\xbb\x26\x14\x2c\x91\x6d\x13\x41\x84\xd7\x09\x28\x88\x56\x52\x66\xcb\x29\xb3\xe5\x07\x34\xb7\x0a\xc2\x94\x45\x39\x75\xe1\x86\x17\xbd\xd1\x84\x95\x2a\x01\xa9\x93\xf1\x06\x2f\xf8\x69\xf7\x9a\xd1\xb5\xd9\xf5\x4f\xbd\x7d\x6b\xac\x72\xd4\xa5\xe1\xe4\xf9\xdb\x37\x0c\xd7\xad\x49\x54\xc2\x20\xdf\x3b\xa1\x89\x8f\xb1\x62\xd8\x44\x21\xac\x2f\xb3\xeb\x86\x6c\x29\x8b\x9d\x14\xc5\x34\x24\x14\x37\x4f\xfc\x0a\x8f\x60\xfa\x10\x7e\xed\x88\xcc\x61\x1f\xf0\x68\xaa\x3a\x2b\x4a\xd1\xbc\x1f\xe5\xaf\x93\x0c\xf3\xb8\x32\xa9\xc2\xcb\x72\x7f\x1d\xc2\x01\xa8\x76\x53\x17\xc0\xe5\x4a\x8f\x40\xe4\x8b\x50\x15\x66\x9f\x56\x07\xdf\xcf\x01\x9b\x91\xa0\x68\xda\xaa\xef\xa8\x96\x5b\x7d\x3c\xc7\x66\xf5\x9b\xab\x5b\x2d\xbf\x94\x5a\xae\x81\x3a\x50\xcc\x7b\x4a\x04\x76\x0b\x2d\x49\x82\x15\xd3\x6d\x8e\x02\xd4\xc3\x16\x57\xbf\x13\xfd\xf0\x10\x5e\xa7\xd1\x3a\xca\xa3\x2b\x0a\x9b\x64\x75\x13\x27\xeb\xc8\x5b\x41\x72\x45\x53\xf8\xf3\xf3\x81\x35\x3c\x82\xed\x7b\x17\xf6\x61\xfb\x7e\x82\x7f\xc7\xf8\xd7\x61\x66\x46\x0d\x52\x48\x34\x6f\x9e\x9f\x1f\x78\x0f\xe6\x76\xda\xb1\x65\x5e\x83\x9c\x80\x30\x57\xca\x47\xcf\xa2\x57\xc3\xc0\xf3\x18\x9f\x18\x7e\x8a\x04\x63\x4d\x9e\x19\x2d\xf9\x19\xde\x76\x35\x25\x43\xfd\xc9\xe9\x7a\x93\xa4\x5e\x7a\x53\xbb\x89\x8e\xa9\xc0\x99\x3c\x10\x69\x57\x29\x95\xb7\xce\xa8\xb5\xff\x4c\xd9\xb3\x3e\xbc\x1b\x6b\x3b\xf6\x6e\x2b\x3b\x76\x6d\x5d\xc7\xee\x5a\xd5\xf9\xf2\x57\x09\x24\x97\xf9\xe6\x32\x3f\xc1\xa9\x75\xad\x2c\xa0\x93\x1e\xd2\x2c\x4a\x69\x28\x5d\x34\xe0\x47\x79\x56\x24\x84\xe6\x95\x6b\xb3\x85\xa2\xf2\xab\x78\x55\xb0\x49\xca\xc1\xed\xa5\xf4\x08\x2c\xcb\x31\xc0\x1a\x4f\x0c\xb0\x5d\xc7\x80\x31\xb1\x9a\x95\xc5\x9d\x05\x47\xec\x9d\xfc\xaa\x79\x69\x41\x31\x69\xd6\xde\x5b\x20\xf7\xae\x01\xed\x0e\xf7\x17\x60\xa4\x16\x6f\x42\x2c\xe6\xde\xc5\xaf\xf3\x77\x1a\x6b\xbf\x83\xa8\xb1\x0f\xc2\xe1\x22\x17\xd3\xeb\x52\xec\x70\x11\xae\x2f\x95\x00\x62\x52\xde\xd6\x8b\x23\xc0\xc4\x34\xe1\x00\xd8\x40\x5b\xde\x94\x20\x53\x82\x79\x2f\xb6\xf5\xb5\x56\xf4\x14\x81\x39\x05\xd1\x94\xc1\xb3\xa2\x13\x27\x5e\x8c\xb1\x9f\x46\xd7\x0e\xc1\x52\xc5\xd0\xfc\x2c\x49\xfd\x7e\xfa\x37\xc0\x7f\x4e\x26\xc1\x97\x56\x04\xf5\x45\x31\x46\x6b\x6d\xd8\xfc\xa5\x85\x77\xd0\x37\x8b\x33\x5b\xdf\x95\xcc\x42\x7b\x05\x35\x6b\xbe\x33\x9f\xa0\x55\x4b\x24\x68\xdd\x25\x83\xa0\x55\x4b\x1d\x68\xdd\x3d\x67\xa0\x40\x98\xf4\x61\x4c\xea\x28\x93\x3b\xe1\x4c\xea\x48\x93\xdb\x60\xad\xe4\x03\x17\xae\x32\x34\x12\xc5\x79\xc2\xa5\x59\xcd\xe9\x95\x87\xc1\xbc\x42\x9d\x15\xa4\x60\x25\x46\x78\xdf\xec\xfb\x39\xd2\x45\x57\x66\x95\x5c\x83\x28\xd3\xbf\x1a\xf1\x86\x0d\xb0\x99\x46\x07\xb8\xa3\x8c\x7a\xc0\xbf\x72\xa7\x17\xbf\xeb\x55\xe0\x6c\x49\x73\xaf\xfd\xe6\x16\xb3\x06\x09\xd8\xcb\x88\x4d\x41\x56\x97\xeb\x18\x3b\xa7\x50\xab\x82\x82\x85\x9b\x6d\x40\xe5\x49\x2b\x0b\xdf\x72\x4e\x22\xb7\x51\xe3\x52\x35\x43\xd1\x34\xc4\x3e\x85\xeb\x59\x72\xaf\xab\xec\x89\x54\x76\x95\x5c\x6b\xfd\x52\x2d\xb5\xce\x94\x7e\x8e\xaa\x27\x67\x8c\x0b\x67\xe7\x5b\x1d\xee\x67\x5b\x2e\x6b\x73\xec\x81\xbe\x10\x0a\xdb\x1c\x51\xdf\x6d\xf7\xcd\xdd\xc4\xa0\xc3\xac\x56\x3d\x72\xb0\x4b\x03\xc6\x17\x07\xa7\x87\x5d\x8b\xe5\x67\x5b\x52\x15\x27\xbb\x14\xe7\xf2\x75\xb6\x25\x5d\x7c\x14\x65\x4f\xca\xb2\xc8\xc7\x4e\xf1\xce\x2e\x53\xd4\x28\x7e\x9d\x08\x13\xf5\x7e\x29\x3f\xdb\x3a\xc2\x16\xc0\x60\x20\x70\x2b\x8f\x06\x8b\xf6\xc5\xf9\x60\xdd\xf4\x06\xa1\x9d\x94\xd0\xb8\xd5\xe0\xd0\x4e\x1a\xd0\x5e\xf6\x43\xfb\x87\x2a\x55\xcd\x14\x76\xc8\x27\x34\x4d\xa2\x46\x4c\xe1\x56\xb3\xbd\x37\xcb\x04\x5e\x47\x1d\x92\xcd\x9a\x2c\xee\x7c\x24\x0f\xa5\x9f\xdc\x95\x2b\x7f\x7f\xb6\xc8\xd7\x28\x57\x82\xed\x12\x63\x56\x88\x4b\x50\x9f\x41\x2a\x4a\x9f\x54\xa5\xf5\x26\x09\x07\x8b\x65\xf2\x8a\x7b\x29\xf3\x5a\x3c\x4c\xc6\x4b\xdb\xd9\x37\x09\x3a\x7a\x1d\x26\x9e\x4d\xa0\xab\x26\x7a\x03\x0f\x92\xae\x0c\x8a\x4e\x3f\x7a\x54\x21\x89\xa2\x5d\xf4\x0f\xaf\xd2\xb4\x2d\x38\x90\xde\xeb\x04\x1d\xea\xaa\x53\xc2\x50\x02\x7f\x79\x4b\xe0\xf5\x98\x47\xd5\xdd\x9d\x22\x1e\xcd\x2e\x0b\xac\x24\x30\x18\xed\x68\x23\x37\x71\xee\xdc\xf3\x97\x3d\x6d\x9c\xdc\xb2\x8d\xae\xb1\x2d\xf5\xe2\x6c\x93\x64\x9d\x52\x82\xe6\xf7\x75\x74\xc2\x15\xe3\xec\x5c\x0a\x28\x56\x72\xa8\x1d\xf3\x78\xc5\x5d\x06\x3e\x51\xb2\x6f\xf4\xd3\xda\x8f\x4d\x04\x5e\x8e\x43\x20\xda\x4b\xb5\x4f\x78\x66\x62\x1f\x94\x49\x5b\xcb\xc9\x91\x59\x1a\x00\x65\xb9\x33\xb3\xe8\x0e\x2f\xad\x53\xf9\x33\xb3\xe8\x8c\x28\xa7\x19\xb7\x0e\x0f\xe1\xd9\xb2\xcb\xf8\xed\x3e\xac\xdf\x71\xc8\xe8\x37\x8d\x20\x99\xaf\xc2\x0e\x97\xe3\x4a\x8f\x70\xdf\xce\xa4\x16\xb5\xce\x4a\x81\xdb\xbd\xca\x96\x94\x95\x06\x92\x13\x32\xdc\x65\x00\xe4\x00\xac\x06\x00\xab\x05\xa0\x93\x8a\xcc\xf7\x48\x93\xeb\x0e\x22\xae\x24\x6d\x38\xab\x54\xe3\x3d\x0c\xfe\x2e\xd0\xe7\x0f\xee\x17\xc8\xe0\xcf\x2e\xfb\xb1\x92\xb4\xe6\xac\x52\x21\x19\x22\x3e\xa8\x20\xae\x92\xeb\xcf\x0f\xd0\xbe\x48\x54\x33\x92\x16\xbf\xb5\x9a\x56\x0b\x43\xb2\xf1\xad\x11\xcc\xc4\xf7\xbd\x93\xb6\x1a\x14\x9d\x22\xd6\xfc\x95\x7a\x0d\xa6\x92\x1d\x8b\x1d\xff\xb5\xb6\x45\x29\x82\x34\x5f\x7c\x57\x54\xab\x7c\x19\xf1\x61\xf5\xda\x61\xa0\x07\x18\xbc\x6a\xc7\x81\xee\xba\x97\x8a\xdc\x65\x2b\x15\x6e\x92\x0a\x68\xb4\xaa\xef\x77\x22\x43\x38\xac\xe3\x3f\x84\x07\xcd\x07\xd8\x38\x2e\xd0\x94\xbb\xb9\xfe\x8b\x6c\x82\xfa\xec\x18\x9e\x1c\x66\x2c\x90\x57\xc6\x20\xe1\x50\xc9\x7a\xb9\x48\x11\x05\x6c\xc3\x3c\x54\x6e\xa6\x7b\xfb\xdb\x25\xa5\x7f\xa5\x6d\xa0\x4b\x2f\x5b\x16\xc2\xbd\xd3\x5d\xf4\x2d\x2c\x3e\x27\x58\xd8\x1f\x13\xda\xdd\xa5\xd7\xb9\xf3\xb7\x8f\x21\x56\xed\xe9\xa3\x72\x92\x6b\x28\x02\x73\xb2\xc3\x79\xab\xd8\x9c\x04\x4a\x84\xe7\x64\x50\x77\x8d\x2b\x56\xa4\xe8\xee\xc4\x49\xab\x13\x27\x77\xed\xc4\x49\xab\x13\x27\xb7\xeb\x84\x9a\x55\x5c\x74\x85\x92\xe5\x09\xa4\x34\x4f\x23\x7a\x45\x15\x1b\x10\x41\x1c\xee\xe6\xf6\x60\x73\x99\x2d\x0b\x34\x54\x24\x52\x94\x7c\xd9\x2e\xf9\xf9\xe9\x89\x15\xa7\x87\xca\xa6\x8d\xb6\x0a\x6b\xcf\x13\x7d\xa1\x5d\x93\x7a\xfb\x25\xb6\x50\x2a\xcc\x59\x79\xd8\x69\x07\x0b\xb1\xe3\x62\x4e\xf1\xb5\xda\x9f\xd9\x49\xf6\xdf\xb7\x6b\xde\x71\xbb\xa6\x7d\xdb\xcd\x9a\x76\xdf\x56\x4d\xbb\x63\xa3\xa6\xfd\xfb\x36\xcd\x2f\xbd\x4d\xd3\xde\x71\x93\xa6\x82\x2d\xb5\x2d\x9a\xf6\x2e\x1b\x34\x6d\xfd\x31\xfc\x72\xe3\xe1\x91\xeb\x7c\x7a\x67\xb8\xe4\xbf\xc9\x76\xcd\x66\x82\x9d\x31\xb1\xfe\x61\x7b\x38\x8b\x74\x3b\xac\xcd\x7f\xae\x74\x3b\x77\xda\x6d\x29\x5e\x57\xbb\x3d\x8b\x32\xb7\x4a\xc8\x33\x26\x56\x6d\x5b\xc8\x98\x58\xda\x6d\x26\xee\x8e\x09\x79\x58\xc1\xda\x56\x13\x57\x64\xb5\x18\x13\xeb\x8b\x1d\x21\x96\xbb\xaf\xcd\xc9\xd3\xda\xe4\x60\x6e\x03\xdf\xf7\x67\xe1\x38\x34\xa4\x84\x3d\x43\x43\x55\x72\x62\xcd\x3c\x6b\x66\x79\x72\x3a\x9f\xa1\x22\x6f\x8f\xa2\xea\x8c\x8c\x67\x26\x19\x7b\x72\xf6\x1f\x75\x23\x64\x6c\x2d\x68\xc0\x73\x06\x15\xb9\x81\x76\x6c\x64\x32\xb5\x6d\x6b\x32\xe1\x69\x85\x44\xe6\x20\x75\x23\x2e\xf5\x1d\xc7\x73\xa7\x72\x5e\xa1\x1d\x1b\x09\x7d\x33\xb0\xa8\x19\xca\x69\x88\xd4\x8d\x38\x53\x7f\xec\xb8\x24\x94\x93\x14\x35\x5c\xd3\x2f\x9d\xa5\x88\xc9\xd3\x1d\xb3\x14\x91\xc9\xef\x69\x8a\xbe\x90\x4f\xe4\xde\x3a\x4d\x11\xab\xd2\xe7\x17\xc9\x36\xa3\xed\x19\xb9\xbf\xa7\x29\xfa\xf2\xbe\x91\xbb\x6b\x9a\x22\x25\x73\xea\xfe\x91\xdb\x9b\xa6\xc8\x76\xbb\xd3\x14\xb1\x61\xfc\xc8\xb5\x54\xde\x92\xf5\xdf\xc4\x5b\xfa\x6f\x7d\xb8\xe5\xcb\x1e\x6c\xf9\x4a\x47\x56\xee\xee\x44\xf1\x57\x65\x77\x05\xa0\x5f\x8a\x1d\xbc\x8a\xbb\x6e\xea\x9b\x7c\x47\xde\x66\xb3\xba\x19\x88\x87\x06\x78\xe9\xc5\xe5\x9a\xc6\x79\xd6\xbc\x93\x47\x3e\x3e\x53\xe1\x83\xa9\x94\xaa\x26\x1a\xcd\x9b\x5b\xc7\x72\x3d\x6b\x31\x43\xbf\x22\x9c\x5a\xae\x47\x2d\x6b\x68\xb4\xcb\x4d\x89\x3d\x75\x9c\x19\xa6\x19\xb4\x6c\xba\x98\x8c\x83\x50\x76\x0d\x5a\x15\xfc\x71\x60\x2e\xfc\x60\x81\x17\x20\x04\x4e\x68\xfb\xd6\x42\x05\x98\xce\xfc\x71\xe8\x7b\x63\xbc\x3d\x9b\xb8\xb3\xd0\xf7\x83\x4e\xc0\xf6\x6c\x3c\x09\xac\xb1\x8f\xee\x8c\xed\xb8\xfe\xd8\x76\x55\x80\xc7\xb3\x05\x21\x64\x81\x18\xfb\x13\x73\x1c\x9a\x64\xd6\x09\x78\x66\xd9\x0b\xd7\xf2\xf0\xca\x6d\x6f\x41\x66\xce\x62\xe6\xab\x00\x7b\x3e\x09\xc6\x34\x44\x8c\x43\x6f\x12\xba\x84\xb8\x9d\x80\x43\xd7\x9c\x7a\x1e\xa7\xb1\x67\x9b\xb6\x69\x39\x4a\x1a\x13\xcb\xb5\xc7\x3e\xbf\x33\xc2\x19\x4f\xcd\xc9\xc2\xa7\x9d\x80\x2d\xc7\x26\xee\xd8\xc7\xbb\x23\x1c\x4a\x1d\xdf\x72\x03\x25\x29\xc6\x66\x30\x0d\x03\xbc\x40\x3c\x1c\x2f\x16\xbe\x43\xad\x4e\xc0\x53\xcb\xa7\xe3\x70\x8a\xa4\x58\x58\x53\xdf\x9d\x4d\x94\xcc\x73\xcd\x90\xfa\x84\x5f\x5e\x61\xfb\x64\x32\x9b\xf8\xa4\x9b\xc6\x7e\x18\x98\x13\x9e\xa1\xd2\x1a\x07\x53\x62\xd9\x63\x15\xe0\x80\xcc\xfc\x05\xe1\x08\x04\x8b\xc9\xcc\x9a\xcc\x9c\x4e\xc0\xd4\x99\xf9\x93\x59\x80\xb4\x9b\xd1\x05\x71\xbc\x50\x49\x63\xba\xf0\xa9\x33\x75\xf1\x1a\x71\xdb\x75\x16\xd6\x98\xda\x9d\x80\xcd\x45\x40\x66\x61\x80\x15\x5c\xdf\x0d\xc2\xb1\xaf\xc4\xd8\x72\xcc\xc0\x23\x41\x80\x97\xb4\x4f\xbd\x60\x16\x4c\xc6\xdd\xcc\x0b\xe9\xcc\x0a\x26\xa8\x20\xe3\x99\xe5\x9b\xd6\x54\x09\xd8\xf1\xa6\x8e\xeb\x78\x38\x47\x98\x50\x6f\x42\x1d\xb7\x1b\xe3\x71\xe0\x9b\xde\x2c\x44\x4c\xfc\xd0\x21\x0b\x3f\x74\x94\x2a\x3d\x59\xcc\x5c\x37\x44\xc0\xae\x4d\xc8\xd8\xf6\xbb\x31\x9e\xb9\x36\x1d\x93\xb1\x85\x2a\x4d\x27\x93\x70\xe1\xa9\x15\xc4\xb5\x49\x30\x99\xa0\x87\x6f\x85\xbe\x63\x5b\xc4\xec\xb6\x15\xa6\x69\x5b\xd3\xc0\xe5\x77\xbe\x2f\x7c\x8b\xd8\x4a\x71\xf3\x17\xe3\xd9\x74\x11\x88\xfc\xa6\x74\x61\x52\xda\x2d\x15\xc1\x84\x9a\xa6\xbf\x40\xc1\xb7\x43\xcf\x75\x17\x81\x52\x2a\xc2\xb1\x37\x9d\x11\x07\x01\xcf\x6c\xd3\xf3\xa6\x56\x37\x29\xcc\x49\xe0\x4d\xec\x31\xbf\xde\xc5\x34\x6d\xd7\x52\x2b\x08\x71\xac\x99\x35\xe3\x73\x2f\xd3\x33\xe9\x84\x4e\xbb\x49\x61\x4d\xfd\xa9\xe9\xb9\x68\x5c\x9c\x49\x68\x59\x8b\x85\x52\xa5\x2d\x4a\x18\x99\x90\x64\xe3\xc0\x9a\x04\x33\x6b\xd2\x09\xd8\x09\xad\x60\x12\x2e\x50\x2a\xc6\x5e\xe0\x58\x1e\x0d\x95\xb6\xc2\xb6\x5d\x33\x24\x48\xb2\x59\x38\x1b\xfb\x76\xb8\xe8\x04\x3c\x19\x9b\xde\xd4\x1e\x3b\x5c\x41\xbc\xc5\xc4\x0e\xa9\x5a\xdc\x26\x9e\xe9\xf9\x68\xb7\xed\x60\x3a\xf5\x2d\xaf\xdb\x6c\xba\x24\xb0\x82\x99\xc5\xad\xdb\x94\x86\x1e\xa5\x13\x15\xe0\x99\x35\xb5\xac\x80\x93\x8c\x38\xae\x65\x8f\x6d\xbf\x13\xb0\x67\xf9\x0b\xea\x7a\xdc\xce\x06\x0b\x62\xda\x13\xa5\x82\x78\x2e\xf1\x26\x13\x07\x31\xf6\x03\xc7\xb2\x4d\xb3\xdb\xba\x05\x96\xe3\xbb\xfe\xd4\x44\x3b\x6b\x2e\xdc\xd9\x74\x46\x94\xd6\x6d\x3a\x09\xc6\xc4\x43\x1a\x9b\x93\xb1\xe3\x53\xbb\x5b\x2a\x42\x32\xb3\xa8\x4b\x66\x08\x78\x42\x17\x63\x8b\x28\xc7\xbc\x70\x32\x9b\x99\x13\x0b\x79\x31\x1e\x4f\xc6\xde\xac\x47\xf3\x16\x8e\x49\xed\x31\xa7\xdd\x78\x3a\x25\x96\x69\x79\x4a\x39\x36\x27\x9e\x67\xf2\x9e\xd9\x96\xef\x87\xc4\xef\x66\x1e\x99\x79\x4e\x40\x08\x9a\x4d\xdf\x0d\xad\xd0\x0c\x94\x18\x13\x6a\x4f\x27\x81\xc9\xe5\x98\x38\xc4\xf3\xc7\xdd\xd6\xcd\x9a\x3a\xee\x74\xea\xa0\x1c\x87\x0b\x97\x52\x7f\x36\x53\x01\xb6\x1d\xdf\xf4\x03\x1f\x7b\x46\xc9\xcc\x77\xdc\x1e\x71\xb3\x67\x24\x30\x03\x1f\x99\x12\x8c\x83\xd9\xd8\x9b\xd8\x4a\x7b\x4c\x43\xd7\xf3\x1c\x34\x9b\xd4\x76\x88\xeb\x05\xdd\xe2\x36\xf6\x67\x41\xe0\x39\x0b\x3e\x32\x4c\x6c\x6a\x4f\x95\x80\x27\xae\x45\x27\x0b\x6e\xac\xc2\x89\x6f\xf9\xae\xd7\x4d\x8a\xa9\xe3\x2e\x5c\x8b\xa2\x82\x8c\x43\xba\xf0\x2d\xb5\xad\x98\xba\xde\x78\x62\xf3\x91\xc6\xb1\xc9\xd4\x5a\x4c\xba\xa5\xc2\x75\x02\x77\xea\x12\xee\x09\x91\x85\xe9\xf9\x53\xa5\xd9\x74\x83\x60\x6a\x5a\x9c\x79\xc4\x9b\x38\xf6\x8c\x76\xfb\x6e\x33\xd3\xa7\x8b\xc5\xc2\xe3\x5e\xe4\xc4\x26\xd4\x52\x4a\x85\xe7\x8c\xcd\x49\x40\x51\xf3\x42\xea\x5a\x7e\x48\xbb\x7d\x37\x9f\x2e\x66\x9e\xbd\xe0\x23\x83\x15\x4c\xa6\x33\xa2\xf6\x2b\x26\x53\x32\x75\x17\x7c\x08\xb3\xa7\xd6\xd8\xb6\xba\x99\x17\x78\xd6\xd4\xa6\x01\xd2\x98\x7a\xd6\x64\x42\x66\x4a\x1a\x87\xc4\x9d\xf8\x2e\x1f\x9a\x2c\x26\x48\x56\x3d\x08\xd8\x76\x44\xbc\xd0\x9b\x86\x21\x2a\x48\x10\x52\x93\xfa\x44\x69\x36\x17\xe3\x69\xe8\x2c\xa6\x0b\x31\xe8\xd2\x90\x4c\xbb\xe5\xd8\x9c\x2c\xcc\xc9\x94\xfb\x0b\x53\x8b\x4c\x27\x0b\x5f\xa9\xd2\xa6\x37\xb1\xa7\x61\x80\x0a\xe2\x59\x81\x3b\x73\xbd\xee\x11\x84\x10\x7b\x31\x73\x4d\x47\x04\xee\x66\x66\xe8\x29\x31\x26\xfe\x94\x98\xbe\xcd\xed\xb1\x4d\x02\x67\x4a\xba\x69\x6c\xb9\xa1\x3f\x9d\x2e\xc6\x5c\x2a\x4c\x67\x1a\xba\x4a\x7b\x6c\x5b\x81\xe7\xf9\x53\x94\x0a\xc7\x0c\xa6\x96\x33\xeb\x56\x10\x3b\x98\x51\x9f\x9a\x48\x0a\x32\x0e\x66\x3e\xf5\x95\xcc\x73\x6c\x12\x4e\xa6\x01\xf6\x6c\x16\x10\xd3\x0c\x9d\x6e\x39\x76\x82\x60\x1c\x3a\xdc\xf1\x0e\x7c\x9b\x3a\x96\xaf\x1c\x9a\x98\xbb\x62\xcd\x66\x68\xac\x16\xc1\x64\x3c\xa5\xcc\xbc\x76\xd9\x8a\x45\xe0\x4f\x16\x1e\x1f\x24\xbd\x70\xb2\xf0\xa8\x12\xe3\x49\xe0\x38\x64\xe6\x22\x60\xc7\x73\xa6\x63\x97\x4c\x45\x10\xf5\x5d\xc7\xb1\xd5\x6a\x5e\xf8\xe3\x5d\x4f\xa8\xea\xae\x41\xfb\xb1\x76\x42\xf5\x97\xbb\x9d\x50\x1d\x13\x6b\xb7\xa5\x03\xc5\x72\xc4\x97\xcf\x3e\x7a\xd7\xa5\x83\x89\x67\xce\x68\x11\x70\xb7\xfd\x20\x98\x99\x9a\xa5\x03\xdf\x9f\x4c\x3d\xca\x87\x5f\xd7\x09\x3c\x6f\x5a\x77\x5d\x3a\x1a\xb1\x83\x09\x5d\xd8\x53\xb4\x64\x0b\x3a\x73\x16\x2e\xb3\x64\xaa\x92\xde\xd8\x59\x2c\xc6\x36\x6a\xc1\x78\x41\x42\x7b\xb2\xd8\x35\xaa\x3f\x26\x26\x1d\x5b\xdc\xf8\x78\x21\x9d\xb8\x56\xa8\x59\x3a\x98\xf9\xe6\x78\xe2\x72\x81\xb4\x7c\x9b\x4e\x02\xb2\xd8\xb1\x11\xb2\x70\xed\x70\xc6\x65\x7e\xe1\x3b\xc4\x0f\x27\x9a\x9e\x8c\x7d\x6a\x06\x21\x77\x83\x88\x3d\xa5\x16\x99\xce\x6e\xb3\x74\xf0\xa5\xcf\x91\xee\x92\x1a\x16\xcb\x99\xfa\xcc\xaf\xdf\x13\x7d\xea\xd7\xef\x2d\x7d\xee\xd7\xef\x6d\x7d\xf2\xd7\xef\x1d\x7d\xf6\xd7\xef\xc7\xfa\xf4\xaf\xdf\x4f\xf4\xf9\x5f\xbf\x9f\x6a\x12\xc0\xf2\x0e\x62\x7a\x58\xe5\x3e\x70\xfe\x7e\xc5\xdf\xb7\x0f\x7b\x70\x1a\x60\x75\xe5\x11\x28\xfe\x7e\xc5\xdf\x6b\xaa\x5b\x58\xdd\xd2\x56\xb7\x56\xfc\xbd\xa6\xba\x8d\xd5\x6d\x6d\x75\x7b\xc5\xdf\x6b\xaa\x3b\x58\xdd\xd1\x56\x77\x56\xfc\xbd\xa6\xfa\x18\xab\x8f\xb5\xd5\xc7\x2b\xfe\x5e\x53\x7d\x82\xd5\x27\xda\xea\x93\x15\x7f\xaf\xa9\x3e\xc5\xea\x53\x6d\xf5\xe9\x8a\xbf\x57\x6c\xeb\xdb\x31\xe9\x31\x97\x0c\x15\x70\x8f\x0b\x45\x33\xe3\x1e\x6e\xb9\xe5\x02\xa1\xaa\xe5\x73\x59\x50\xd5\x0a\xb8\x1c\xa8\x6a\x05\x5c\x04\x54\xb5\x42\xce\x7e\x55\xad\x90\x73\x5e\x55\x8b\x72\xae\xab\x6a\x51\xce\x70\x55\xad\x05\x67\xb6\xaa\xd6\x82\xf3\x59\x55\xeb\x82\xf3\x58\x55\xeb\x82\xb3\x57\x55\x6b\xc9\x59\xab\xaa\xb5\xe4\x5c\x5d\xa9\xf2\x0e\x76\x1d\xdd\xdd\xf1\x3a\x54\x6d\x3e\xed\xa2\xfd\x1f\x23\x9e\x7b\x58\x77\xdc\xfc\x18\x47\xf0\x62\xf9\xac\x5d\x64\x87\x44\xd1\xbc\x19\x46\x82\x1f\xa3\xe2\xb4\x81\x9c\x35\x1a\x1e\x80\xf5\x0e\x4b\xaa\x73\xb9\x56\x30\x56\x1c\x86\x38\x5f\xd0\x84\x81\xa7\xe6\xef\x94\x81\xfa\xf0\x10\xfe\x8c\xd9\x88\xf5\x8d\x17\x29\x9d\x6f\x95\xa1\x7a\xbb\x2c\xf3\x1c\x6f\xfb\xce\xe2\x89\x62\x2b\xa9\x46\xf7\x79\x3c\x5e\x6a\x59\xcb\x82\xbd\xe4\xc9\x7f\xe5\xe4\xd5\x2b\x4c\x51\x5c\xa4\x03\xae\x95\x73\x5b\xe5\x70\xd3\xeb\x7b\xa8\x17\x9b\x76\x9d\x30\xe5\x25\x57\x35\x2c\x56\x6d\x2c\x96\x2a\x2c\x56\x6d\x2c\x96\x32\x16\xf5\x72\xd3\x76\x39\x4d\x26\x63\x99\xa5\x9a\x9c\x39\x57\x52\xee\xed\xdb\x24\xdf\xae\x38\x4a\x76\xe3\x28\xa9\x38\x4a\x76\xe2\x28\x59\xd6\x12\x7c\x2f\x8b\x2c\xdc\x52\x62\xee\x95\xc8\xd5\x2d\x11\x89\x08\x0a\xd7\x8b\xe1\x3e\xe6\x99\xc4\xd2\x02\xde\xa4\x97\xa5\x64\x55\x43\x63\xa5\x40\x63\xa9\x42\x63\xd5\x42\x63\x59\x43\xa3\x0e\x70\xd2\x82\x67\x4d\x3a\x79\x7a\xab\xdc\xe1\x5d\xa6\x64\x5a\xb1\x7d\xda\xc5\xf6\x1f\xa3\x29\xb7\x5c\xca\x81\xb9\x51\x72\x25\x4a\x76\x9c\x09\xe7\x25\xc9\x44\x32\x24\xda\x5b\xa1\x8b\xb2\x1c\x01\xa2\xf4\x2c\x9a\x65\x57\x45\xd9\x5e\x1c\x2a\x4b\xb3\x62\x44\x8b\xa6\xcd\x91\xab\x5e\xbc\x32\x65\x4b\x5e\x7c\x89\x39\xdb\x18\x1c\xc6\x49\x73\x08\x8f\x0a\xed\x2c\x9f\x3c\x01\x02\x47\xd0\xda\x36\xdd\xc6\x83\xfd\x2d\x38\xd8\x8f\x06\xfb\xbb\x5f\x6a\x8b\x06\x0b\x72\x57\x2c\x90\x8a\x3b\xe2\xc0\xb9\xd3\xc6\x80\x73\xa2\xd5\xbe\x1a\x68\x35\x2a\xfe\x18\xe9\xd8\x5b\x8d\x7a\x3f\x46\x2a\xe4\xf4\x39\xf1\x45\x52\xfc\x25\xdc\x87\xc5\x52\xa4\xc5\x67\x3f\xd4\xe7\xf8\x78\x1d\xae\xfb\x74\xc5\xea\xac\x44\x1d\xf6\xe3\x62\xd5\x91\x4c\x7f\x89\xd9\xf4\x19\x68\x9f\xb7\x83\xdf\x03\xfe\xdd\x17\xdf\xf5\xd5\x57\x58\x9d\xb5\xe2\xf3\x26\xf1\x7b\xc0\xbf\xfb\xe2\x7b\x77\x4a\xfe\x25\xcf\xc9\x2f\x0c\x0e\x1f\x57\xbc\x15\x4f\x2f\x3d\xe4\xc9\x0f\xbc\x65\x91\xb1\x5f\xbc\xac\xe5\xec\x5f\x4a\xb7\x48\x78\xc5\xa8\xd3\x99\x99\x1f\x67\x53\x83\x12\x90\x68\x73\x59\x6f\x73\x55\x6b\x73\x59\x6f\x73\x25\xb7\xb9\xdc\xa5\x4d\xc2\xfb\x49\xc5\xd0\xc0\xcf\x9b\x50\x3e\x28\xb8\x45\xda\xff\x65\x71\x69\x85\xf4\xd2\xa9\x5e\xb2\x36\xed\xe2\x1d\x4f\xc3\xdd\xdd\x26\xef\xa7\x28\x5c\xb4\xb9\xac\xb7\xb9\xaa\xb5\xb9\xac\xb7\xb9\x92\xdb\x5c\x56\x6d\x2a\xbd\xce\xfe\x7b\x08\xd4\xb8\xfe\x05\xb3\x2f\xfd\x45\x7f\x98\xea\x2f\xa8\xbc\x7f\x89\xba\x8e\x51\xfd\x05\x8d\xc1\x5f\x22\x9d\x09\xbd\xc2\x8b\x12\x58\x99\xe5\xaa\x44\x51\xa5\x94\xbc\x20\x6b\x70\x59\xf5\x85\x9b\x8b\x9c\xc8\xe6\x62\xb9\x8b\xad\xaa\x9a\x65\x7f\x19\x45\xba\xdb\xcc\xb1\xa9\x60\xa9\x6a\x30\xb8\x53\x8b\x7f\x51\x9a\x9e\x66\x8b\x7f\x89\x54\x2d\xfe\x25\xba\x4b\x8b\x6a\x63\xd7\x6c\xf1\x47\x65\x8b\x3f\xaa\x5a\x54\x4b\x5b\xf3\xf2\x0a\x4d\x93\x18\xbc\x28\xd4\x1e\x0b\x6a\xb1\xc3\x38\x48\x61\x95\xf6\xb9\x79\x44\x14\x2d\x19\xc5\x02\xd6\x6e\x68\xfe\xb0\x09\xbd\x9c\xc2\x75\xf7\x4c\x9f\x7d\x70\xbe\xa9\x94\x6f\x9c\x6e\x5e\xa8\xd0\xc6\x01\x68\xa1\xaa\x83\x13\xdb\x85\xaa\x0e\xce\xa1\xa9\xaa\x0e\x4e\xa1\xa9\xaa\x0e\x4e\xc9\x07\xe1\x0a\xaf\xef\x58\xe9\xee\xef\xc0\x39\xfd\x20\x5c\x62\x29\x4e\x3a\x2a\x53\x2e\x6c\x11\x4d\x7b\x13\x08\x83\x14\xa8\x70\xc4\x90\x42\xa0\xc2\x11\xa3\x17\xbe\xaa\x0e\x06\x2f\x7c\x55\x1d\x8c\x93\x78\xaa\x3a\x18\x26\x69\xdd\x66\xc0\x3e\x18\x76\x19\x70\x51\xcf\x2d\x2d\x31\x30\x70\x33\xe0\x74\x60\x92\xb5\x5f\x8d\x38\x9c\x1a\x79\xdb\xd9\xf9\xa2\x97\x95\x48\x31\x43\xf4\x0c\xbe\x47\xf9\xf7\x5a\xde\xc0\xf7\x65\x32\x8a\xc1\xf7\x28\xf7\x1e\x47\xf6\x7b\x53\xc6\xd6\x6b\x23\xdb\x84\x23\x45\x19\x79\x83\x48\x22\xbf\xdd\x20\xa9\x1a\x44\xf2\xf8\xa2\xc1\x9a\x25\xf0\xfb\x1b\x94\xe2\x92\xbc\x41\x0b\x4d\x6c\xbb\x41\xab\x6a\xd0\x5a\x16\xe3\xd2\x00\xcb\x4b\xe6\xb5\xbf\x41\x29\x92\xc9\x1b\xb4\x59\x83\x61\xbb\x41\xbb\x6a\xd0\x66\x6d\x85\xa2\x41\xbb\x47\x1d\x9a\x70\xa4\xd8\x27\x6f\xd0\x61\x0d\xd2\x76\x83\x4e\xd5\xa0\xc3\xda\xa2\xa2\x41\x47\x6e\x90\xf6\x37\x28\x45\x4b\x79\x83\x63\xd6\xe0\xa2\xdd\xe0\xb8\x6a\x70\xcc\xda\x5a\x88\x06\xc7\x72\x83\x8b\xfe\x06\xa5\xf8\x2a\x6f\x70\x82\x93\x8a\x76\x83\x93\xaa\x41\xf4\xde\x2f\x44\x83\x93\xda\x24\xa2\xbf\x41\x29\x22\xcb\x1b\x9c\xb2\x06\x97\xed\x06\xa7\x55\x83\x38\x6d\x12\x63\x32\x2b\xdf\xe5\x04\x7c\xf6\xd9\x8b\xdf\x2f\xc5\xf9\x72\x97\xe2\x10\xe6\xdc\x8b\x9b\xcd\x18\x30\xcc\xc3\x62\x9b\x5f\xfa\x5a\x1c\x75\x33\xe4\xbf\xe4\xc5\x38\xcf\x92\xf8\x8a\xa6\x3c\xcb\x2f\xe4\x09\xd8\xd6\x81\x1f\xe5\xcc\x41\x09\xc1\xc3\xfd\xd9\x3e\x5d\x24\x29\x15\xdb\xa9\x5b\x5c\x93\xce\x9a\x48\x6b\x77\x79\xf2\x93\x6d\x7d\x89\x8b\x78\xfe\x59\xaf\xe0\x91\xf1\x2c\xf3\x83\x1c\x01\x31\x2d\xe7\xd0\x16\x79\x8a\x7f\x3f\xdd\xa4\x3d\xaa\x34\x26\xd6\x6d\x4f\x37\xb1\x2a\x3d\xa7\x9b\x6a\xdb\x1a\x5a\xa7\x9b\xc6\xc4\xfa\xfd\x74\xd3\x97\x3e\xdd\xc4\xb8\xb2\xdb\xe9\x26\x25\x73\x6a\xa7\x9b\x38\x83\x3a\x4f\x37\xf1\x73\xb4\x3b\x9e\xfe\xb6\xff\xa9\xcf\x33\xd1\x38\x38\xf0\xbd\x8c\x4e\x9c\xc6\x8b\x75\x38\x6e\x16\xbd\xda\x7c\x08\x17\x8d\x87\x41\xb4\x59\xd2\xf4\x1f\x72\x24\x4a\x42\x15\x7f\x33\x0c\xf9\x0b\x8e\x18\x7e\x97\xf1\xf9\xef\x70\x74\xea\xc7\x9d\xee\x04\xc2\xcd\x33\xcf\xb0\xeb\x65\x39\xe9\x59\xff\x51\xa8\xc3\x43\x78\x4d\xd3\x35\x8e\xa2\xcf\x96\x49\x14\x50\x20\xcd\x6b\x53\x58\xf5\xd7\xcf\x48\xfd\xec\xd2\x78\x6a\x80\x33\x33\xc0\x21\x06\xd8\xb6\x01\xd6\xd8\x00\x32\x35\x60\x66\x00\x10\x69\xab\xd1\xd8\x35\x60\x6c\x1a\xe0\x58\x06\xd8\x8e\x01\xd6\xc4\x00\xe2\x1a\x40\x4c\x03\x2c\xb9\xdc\xcc\x80\x31\x31\xc0\xb1\x0d\xb0\xc7\x06\x58\x53\x03\xc8\xcc\x00\xc2\xe0\x4b\xe5\x26\xa6\x01\x63\xcb\x00\xc7\x31\xc0\x9e\x18\x30\xb1\x0d\x18\x8f\x0d\x70\xa6\x06\xd8\x33\xa9\xa0\x4d\x0c\xb0\x6c\x03\xc8\xd8\x80\xa9\x01\x30\xb1\x0c\x18\x3b\x06\x38\x78\xb5\x80\x5c\x90\x61\x62\x19\x40\x1c\x03\x26\xac\x20\x31\x60\x6c\x1b\xe0\x8c\x0d\xb0\xa7\x52\x41\x6b\x66\x80\x45\x0c\x20\xac\x49\x03\xc0\x72\x0d\xb0\x4c\x03\x08\x43\x87\x17\x7b\xd7\x41\x57\x4b\x4d\x57\xab\x4e\x57\x86\x05\xa3\x23\xeb\xb7\xc5\xbe\x1b\x00\x63\x19\x5b\xd1\x30\xeb\x16\xc3\x16\x11\x32\x65\x2c\x6d\x41\x38\x86\x15\x2b\x30\x31\x40\xee\x2e\x99\x70\x7a\x30\x02\x23\xf6\x76\x9d\x11\x8c\xa1\x8c\xc0\x8c\x7e\xf6\x94\x13\x76\x3c\x6e\xd0\xcb\x31\x05\xb7\xc6\x9c\xfb\x8e\xdc\x02\x63\x0d\x13\x0d\x9b\xb1\x74\xc2\xd9\x3e\x96\x79\xc8\x58\xc0\xe4\x81\xc9\x05\xe3\x21\x23\x6c\xe1\xd5\xd4\x6e\x84\xba\x5c\x5f\xae\x3c\xbc\x26\x85\x39\x95\xd9\x32\x5a\xb4\x6e\x78\x42\x2d\x78\x71\xf6\xcb\xdb\xef\x5f\x3c\xe7\x77\x4a\x31\x8a\x59\x06\x60\xe7\x19\x85\x5c\x26\x91\x82\x4d\x48\x5d\x21\xa9\x44\xb0\xd3\x12\xd2\x8b\x04\x71\xe5\xf6\xdf\x7e\xfb\xea\x27\x9a\x81\x17\x87\x22\x37\xfa\x06\x59\xca\xef\xd3\x50\xe0\xc1\xca\xff\xf2\xba\xce\xcf\x86\x4b\x69\x6e\xcd\x23\x9c\x8c\xb8\x96\x69\x1a\xcd\x77\xc5\x5c\x81\x17\x51\x14\xb0\x6a\x05\x5c\xd3\xb4\x5a\x45\x6c\xa9\x48\xfb\xad\x23\xbf\x55\x34\x30\xae\x37\x60\x29\x1a\x98\xd4\x91\x54\x15\x99\x36\xfa\xa1\x68\xc8\xad\x21\xd2\x06\x31\x6b\xb6\xd2\x06\xe1\xc9\x45\x54\x05\xfc\x26\xb5\xda\x45\x82\x46\x33\xad\x02\x61\xb3\x2b\xed\x22\x54\x2a\xd2\x6e\x61\x51\xc7\xb2\x5d\xdd\xed\xaa\x4d\xdc\x5e\x7e\x58\x6e\x4f\x03\xb6\xdb\x23\x55\x4e\xb3\x11\x85\x5c\xb8\xdd\x72\x33\x71\x7b\x05\x73\xea\x76\x09\xa6\xeb\xf6\xf2\x7b\xe6\xf6\xf0\xdb\x6b\x22\xa1\x10\x89\x66\x33\x6d\x4c\x02\xb7\x97\xe3\xa1\xdb\x23\x35\xd4\xed\x96\xee\x45\xb3\x0d\x05\xe7\xb5\xec\x12\x56\x82\xa8\x09\x69\x49\x6f\x35\xcc\xb4\x6b\x45\x94\xad\x3b\x75\x28\xaa\x3e\x8e\xe5\x22\x4a\x99\x90\xf1\x54\xbc\x9f\xd6\xd1\xe8\xd0\x0d\xd2\x21\xfe\xb3\x26\xa6\x5a\x43\x41\x3a\x38\xea\xd7\x3b\xa3\x90\x8a\x5a\x67\xb4\x76\x82\x74\xc8\x2f\x6d\x14\xd1\x99\x0a\xa2\x36\x05\x6e\x2f\x29\x88\xdb\x4b\x0a\xcb\xed\x65\xbd\xed\x76\xb3\xcd\x69\x80\xd0\xd9\x8a\x2e\x72\x4f\xdc\x2e\x11\x9e\xba\x3d\xcc\x70\xdd\x1e\x4a\xce\xdc\x5e\xd1\xf2\xdc\x6e\x86\xfa\x4d\x7a\x2b\x06\x8f\x66\x2b\xed\x22\xa1\xdb\xc5\x52\xea\xf6\xa8\xd0\xa2\xc9\x51\xf9\x8e\x2a\xa3\xcf\xcb\x70\x4c\xd3\x75\x4c\xa2\xb5\x20\xa2\x8c\xd6\xcd\x28\x19\xa8\xb3\x20\x45\x23\xa6\xaa\x11\xa7\xde\x88\xb2\xcc\xb8\x0e\x47\x89\xcc\xa4\x0e\x47\x59\x66\x5a\x95\x51\xb4\x22\x1b\x5b\x65\xf5\x59\xb3\x09\x05\x10\xaf\xd9\x1d\xbd\xc3\x21\x1a\x52\x00\x09\x6a\x84\x55\x14\x08\xab\x02\x5a\x03\xc2\x51\x50\x54\x5e\x34\xb9\xa2\xf5\xbb\x3a\x89\x49\xdc\x9e\x5e\x58\x6e\x17\xb5\xed\x66\x13\x2a\xd9\x70\x1b\x7c\x57\xc9\x86\xdb\x4f\xf0\x89\xdb\x23\xa8\x53\xb7\x5f\x50\x5d\xb7\x87\x29\x33\xb7\x83\x29\x9e\xdb\xad\x4b\x7e\x13\x03\xbd\x21\xe9\x54\x95\xd0\xed\x11\x62\xda\xa4\xa9\xde\x9e\x68\x25\x48\x9e\x80\x28\xde\x92\x1d\xd4\x9e\x58\x3b\x28\x13\xb1\x77\x50\x7c\xe2\xec\x20\xcf\x64\xdc\xa9\xfa\x64\xd2\xa7\x92\x64\xda\x63\x0c\x65\x17\x5c\x0d\x61\xd6\x67\x2e\x89\xd7\xa7\xf7\xc4\xdf\xc1\x5a\x92\xa0\xcf\x90\x91\x70\x07\x63\x49\xe8\x0e\xa6\x8c\x2c\x9a\x1c\x52\x8a\x4b\x9f\xa9\x20\xa4\x4f\x43\x89\xb5\x83\x82\x10\xbb\x47\xcb\x88\xb3\x8b\x61\x1b\xef\x60\x76\xc8\xa4\xd3\xba\x91\xe9\x0e\x66\x89\xb8\x3b\xe8\x22\x99\xed\xa0\xf5\xc4\xdb\xc1\x9a\x12\xbf\xcf\x82\x91\xa0\xcb\x84\x91\xb0\xcf\x2c\xd0\x1d\xcc\x28\x59\x34\x2c\xd4\x6d\x5c\x15\x62\x3a\x1a\x63\xa4\x46\xd9\xaa\x51\x85\x68\x5d\x14\x0e\x5b\x05\xdd\x91\xde\x9b\x8a\xf7\xe3\x06\x73\xda\x25\x26\x35\xa2\xa9\xda\x98\xd6\x4a\xf4\x0f\xc7\x7a\xdf\xa4\x6a\x45\xe7\x99\x14\x3d\xd5\x79\x25\x15\x16\x6d\x3c\x83\x06\x35\xdb\x25\xc2\x1a\xb5\x74\xae\x09\x42\xd0\xb8\x25\xa2\xae\x9a\x02\x5d\xdd\x23\x6e\x1f\xfa\x96\xab\x17\x14\xdb\xed\x13\x14\xc7\xed\x63\xf4\xd8\xed\xee\xfc\xc4\xed\x16\xa5\xa9\xf4\xbe\xfd\xd6\x75\xf5\xa4\x9b\xb9\x5d\xa4\xf3\xdc\x3e\xf1\xf2\xdd\x6e\x25\x08\xdc\x6e\xd1\x09\xdd\x3e\xc1\xa0\x6e\x9f\x12\x2c\xdc\x3e\x11\xaf\xb9\x15\x1a\x21\x20\x3d\xea\x4a\xac\x1e\x09\x25\x76\xaf\xc9\x20\x4e\xa7\xa4\x92\x71\xaf\xc2\x93\x49\xaf\xd5\x20\xd3\x2e\x4b\xec\xf6\x6a\x22\x99\xf5\x9a\x0c\xe2\x75\x68\x23\xf1\x7b\xcc\x05\x09\x7a\xad\x16\x91\xcd\x81\xa2\x09\xda\x63\x7b\xc9\xa2\xd7\x24\x09\xd7\xa2\xb3\x9b\xa4\x53\xaf\x88\xd5\x6f\x5a\xec\x0e\xcb\x41\x9c\x1e\xb5\x26\xe3\x5e\xdb\x42\x26\x9d\x0a\x4c\xa6\xbd\xb6\x8d\xb8\x3d\xc6\x87\xcc\x7a\x35\x90\x78\x3d\x66\x80\xf8\xbd\x36\x90\x04\xbd\xa6\x80\x84\xbd\xf6\x88\xd0\x0e\x63\x47\x16\x75\x6b\x74\x1b\xff\xc1\x35\x79\x93\x6a\xdb\x52\x78\x9f\xc4\x74\x34\xae\x44\x81\xb4\xe2\xbd\x5d\x41\x70\xd4\x82\xe8\xe8\x85\x68\x5c\xa7\x88\xda\x87\x28\x9d\x63\x55\xf3\x53\xb3\xe6\xfe\xe9\xc7\xcf\x62\x45\x45\xed\x41\x54\xbc\x55\xfb\x0f\xfc\xbd\xda\x77\xa8\xc8\xa7\x5b\x41\xa9\xc8\xa3\x80\x11\x4a\x5a\xaa\xf1\x1c\x0a\xf1\x56\xfb\x0e\x15\x83\x35\xfd\xef\xe4\x2f\x71\xf5\xdd\xb3\xdc\x3e\xe4\x6d\xb7\x8f\x00\x8e\xdb\xcd\xe2\xb1\xdb\xd7\x85\x89\xab\x95\x9f\xa9\xdb\x27\x7c\xae\xdb\x45\xbf\x59\xbd\x71\x9d\x13\xd1\x21\x1d\xbe\xdb\xc5\xbd\xc0\xed\x93\xbe\xd0\xed\x96\x5f\xea\x76\xab\xdf\xc2\xed\xd3\x10\x62\xf6\xa8\x08\x21\x3d\x5a\x48\xac\x5e\x35\x24\x76\xd7\x48\xd1\x29\xe1\x64\xdc\xab\x22\x64\x62\xf6\xf1\x89\x4c\x7b\x2d\x19\x71\x7b\xb5\x85\xcc\x7a\xcd\x05\xf1\x7a\x0d\x1e\xf1\x7b\x6c\x26\x09\x7a\xed\x06\x09\x7b\xcc\x12\xa1\x1d\x76\x89\x2c\x3a\xcd\x06\xf7\x1e\xba\xfb\x40\x7a\xf5\x92\x58\x7a\xc5\x24\x76\x8f\xda\x13\xa7\x47\xf0\xc9\xb8\x57\x77\xc8\xa4\xdf\xba\x4d\x3b\xcc\x1b\x71\xfb\x95\x67\xd6\x69\x3f\x88\xd7\x6b\xff\x88\xdf\x6b\x44\x49\xd0\x69\x44\x48\xd8\x6b\xa5\x08\xed\x31\x53\x64\x51\xb7\x23\xb7\x73\x1e\x94\x36\xa5\xc0\x57\xb7\x42\x52\x62\xa3\x74\x19\x8e\xa4\xed\x1a\x4a\x8f\x41\x14\xc0\x78\x8a\xd2\x6f\x28\x7d\x3e\xc5\xfb\x49\x01\x40\x57\x60\x5a\x21\xa8\x78\x2b\xf3\x5c\xe7\x32\x54\xf8\x69\x7c\x86\xaa\x87\x8a\x16\xfc\x0a\x41\x35\x0a\x41\xad\x80\x6a\xe0\xd0\xea\x1e\x95\x99\xa3\x00\xbd\xa8\x11\x47\x1d\x73\xe8\xaa\x4f\xdc\x1e\xe2\x5a\xae\xa9\x13\x1c\xdb\xed\x16\x1c\xc7\xed\x12\x9c\xb1\xdb\x23\x17\x13\xb7\x87\x6a\x53\xb7\x47\xf4\x5c\xb7\x87\xb5\x33\x57\x47\x77\xcf\xed\xe1\xa9\xef\x76\x4b\x6d\xe0\xf6\x48\x4d\xe8\xf6\x70\x8e\xba\xdd\x82\xbb\x70\xbb\xc4\x9e\x98\x9d\x6a\x4b\x88\xa9\xe5\x2b\xb1\xfa\x74\x9a\xd8\x7d\x3a\x49\x9c\x1e\xad\x26\xe3\x3e\xa5\x20\x93\x3e\xcb\x41\xa6\x3d\xba\x5d\x8e\x7b\x5a\x36\x92\x59\x9f\x02\x11\xaf\xc7\x3e\x12\xbf\xcf\x82\x90\xa0\xd3\x42\x91\xb0\xcf\xc2\x10\xaa\x1f\x9c\x17\x3d\x16\x02\xfd\x83\x6e\x5e\x91\x1e\x49\x23\x56\x8f\xa6\x13\xbb\x4f\x99\x89\xd3\xa7\xac\x64\xdc\x67\xaa\x26\x7a\x53\x44\xa6\x7d\xc6\x82\xb8\xdd\xea\x32\xeb\x53\x78\xe2\x69\x8d\x05\xf1\xfb\x74\x99\x04\x3d\xe6\x82\x84\x9d\xc6\x92\xd0\x3e\x53\x46\x16\x0d\x83\x73\x1b\xaf\x40\xa0\xed\xaa\xac\x48\x01\x53\xe5\x17\xf0\xba\x96\xba\xcf\x76\xf5\xde\x52\xc1\x76\x2a\x8a\x28\xe1\x8f\xe5\xfe\xa8\xbc\x82\xf2\x6d\x1b\xf6\xb4\x26\xd0\xda\x51\x51\xe9\x0d\x48\x48\xb5\x01\x7b\x45\xb3\x4a\x94\x7d\x21\xa0\x2a\x0f\x40\xa2\x55\xfb\x7d\x28\x81\x6d\xbf\xa5\x65\x5f\xdb\xef\x16\x35\x2a\xab\x7a\xda\xc9\x24\xe2\x76\x33\xc9\x72\x35\x3d\xb2\xdd\x2e\xee\x38\x6e\x57\x7f\xc6\x6e\xb7\xd4\x4d\xdc\x6e\xc9\x98\xba\x7a\x7a\xb8\x6e\x97\x5c\xcc\x5c\xbd\x3c\x7b\x6e\x37\xeb\x7d\xb7\x9b\x87\x81\xab\x91\xa9\xd0\xed\x66\x11\x75\xbb\x64\x6a\xe1\x76\x8b\x32\x31\x7b\xf4\x88\x90\x1e\xe1\x23\x56\x8f\xa6\x12\xbb\x43\x00\x89\xd3\xa9\xa7\x64\xdc\xa3\x8a\x64\x62\xf6\xd8\xa0\x69\xa7\xce\x95\x1e\xac\x06\xf7\x99\xd6\x6a\x7b\x3a\x6d\x25\x7e\x8f\x69\x23\x41\x87\x5d\x24\x61\x8f\x0d\x21\xb4\x47\x67\xc9\xa2\xd3\xb8\xb1\x11\x5d\x83\x38\xe9\x14\x25\x62\x75\x2a\x2d\xb1\x7b\xf4\x92\x38\x3d\x8a\x49\xc6\x1d\x9a\x49\x26\x3d\xb6\x86\x4c\x7b\x8d\x55\x8f\x26\x91\x59\x8f\x8e\x12\xaf\xc3\x00\x10\xbf\xd3\x6a\x91\xa0\xd3\xb4\x90\x50\xa7\xff\x84\xf6\xa9\xf0\xa2\x6e\x7a\x6e\x3f\x74\x2b\x64\xa4\x40\xd5\x31\x89\x62\xe8\x16\xae\x86\x62\xd0\x16\x40\x55\xd5\x9c\xd2\xc9\x51\xbd\x1d\x6b\xba\x3f\xe1\x20\x15\x63\x74\xe5\x32\xb5\xdf\xba\x52\x07\x54\xc3\x74\xd9\xf7\x76\x55\x4f\x12\xf2\xf6\x5b\x5f\xea\x84\x6a\xaa\x2e\xf9\x71\x8a\x61\x9a\xd3\xad\x0d\x95\x56\x74\x53\x4d\xd2\x25\xcf\xb7\xdd\xd3\x2e\x32\x10\x57\x4d\x54\xcb\xed\xe2\xaf\xed\x76\xf5\xd1\x71\x3b\x04\x67\xec\x76\x11\x6f\xe2\x76\xf5\x64\xea\xea\xc8\xe3\xba\x1d\x62\x35\x73\xbb\x58\xed\xb9\x5d\x1c\xf1\xdd\x0e\x41\x08\x5c\x9d\x98\x87\x6e\x97\x24\x53\x57\x2d\xb1\x0b\xb7\x83\xc9\xc4\xec\xe4\x32\x21\x9d\xea\x6a\x75\xea\x2b\xb1\x3b\x75\x85\x38\x5d\xea\x40\xc6\x9d\xaa\x44\x26\x9d\x0a\x41\xa6\x5d\x16\x41\x8c\x37\xca\x57\xb3\x4e\x6b\x41\xbc\x2e\x8d\x21\xbe\xc6\x68\x90\x40\x67\x64\xc3\x4e\xcd\x25\xb4\xd3\x28\x90\x85\xd6\x22\x12\xb3\x93\xeb\xa4\x53\x11\x89\xd5\xad\xdd\xb6\x46\xd2\x88\xd3\xa9\x68\x64\xdc\xa5\xc2\x64\xa2\xd5\x43\x32\xed\xb4\x0c\xc4\xed\xd4\x7e\x32\xeb\xd4\x45\xe2\x69\x8c\x15\xf1\x3b\xd5\x8d\x04\x5d\xd6\x81\x84\x5a\x2d\x26\xb4\xd3\x72\x90\x85\x64\x1c\x6e\x33\xa6\xba\x6c\x80\xb7\x14\x00\x4b\xe2\xb4\xed\xf1\x51\xb5\xb8\xd1\x36\xc7\xbc\x5e\xdb\x10\x0b\x78\x8a\x57\x63\x0e\xcf\x52\xe2\x31\x29\x5f\xaa\x8c\xb0\xc0\x44\x3d\xce\xb8\xa6\x1a\xff\x59\xd9\x6f\x95\x09\xe6\x78\xaa\x5e\xf9\x25\x50\x05\x9e\xc1\x11\x3f\xec\xd1\x36\xbf\x6a\x39\xa1\x25\x11\x15\x75\x16\x02\x09\xc5\xab\x62\x51\x49\xdb\x73\xfe\x9a\x74\xd1\x54\x94\xb1\xba\xf8\x2f\xca\xd8\x5d\xbc\x16\xcf\x9d\x2e\x62\x8b\x32\x63\x3d\x59\x45\x89\x49\x6f\x9f\xa7\x1a\xd1\x12\xaf\xdd\x2e\x8a\x8a\x32\x33\x1d\x97\xc4\x7b\x4f\x2f\xa5\xa2\x84\xdf\x25\x8f\xa2\x4c\xa0\x66\xb9\x78\x1b\x76\x89\x91\x28\x43\xbb\x44\x54\x94\x59\xe8\x35\xb4\xf0\x88\x95\x8a\x4d\xba\x7a\x40\x2c\x0d\x91\x89\xad\x93\x38\xe2\x74\x21\x4b\xc6\x5d\x6c\x21\x93\x2e\x62\x90\x69\x47\x17\x75\xf6\x77\xa6\x67\x21\xf1\xba\x24\x95\xf8\x9d\xf6\x30\xe8\xd2\x28\x12\xea\xe5\x9b\x50\x9d\xd0\x91\x45\xbf\x76\x55\x93\x1b\x6d\x09\xd2\x6d\x0b\x88\xd5\x2f\x70\xc4\xee\xd3\x3e\xe2\x74\x6a\x1f\x19\xf7\x1b\x81\x82\xd9\x9d\xdd\x9d\xf6\x1b\x25\xe2\xf6\x1b\x37\x32\xeb\xb7\x06\x85\x38\x74\x69\x19\x17\x0a\xed\xdb\xa0\xcf\xac\x71\xc1\xe8\xc0\x93\xf6\x59\x9c\x42\x48\xb0\x15\x69\x64\xe7\x5f\xe5\xbc\x06\x2f\xbd\xec\x43\x06\xf9\xd2\xcb\x21\xa3\x2b\x1a\xe4\x98\x8f\xe8\xed\xb7\xaf\x7e\x82\x28\xde\x14\xd7\x44\x94\x19\x0d\x5e\x3e\x7d\xdb\xb8\xb8\xb8\x3a\x98\x68\x40\xb5\xf1\x1f\x2f\x50\x14\x3f\xf0\xbb\xf8\x61\xc8\x15\x4d\xf1\x94\x17\xe0\x3f\x8a\xef\xec\x87\x21\xf5\xa7\x89\xb9\x94\x55\xe9\xbb\xe3\xb7\x3c\x31\x16\xf0\xc4\x2f\xdd\x77\x54\xb1\xd2\xe5\x05\x55\xfc\x87\x94\x25\xe5\xae\x57\x54\x75\xa7\xd6\xfb\x40\x6f\xca\x14\x60\x1f\xe8\x8d\x22\xf5\xdd\x07\x7a\x53\xe4\xd5\xfb\x40\x6f\xd4\x69\xf5\x58\x1b\x9c\x45\xe3\x09\xf8\x51\x9e\x81\x17\x04\x49\x1a\x46\xf1\x05\xe4\x09\xbc\x7e\x46\x94\x70\xbf\x8d\x30\x15\xd0\x79\x33\x07\xb2\xea\xee\x90\xf1\x44\x7f\x77\x48\x05\xee\x75\xc2\x00\xbe\x7e\x46\xce\xa3\x77\x70\x00\x44\x91\xa3\x54\xb4\xcb\xd3\xf3\x0f\x8a\xde\x9d\x57\xf5\x45\x3a\x3e\xf6\xcf\xc0\x26\x70\x20\x81\xc6\x3c\x7c\x43\xb8\xdf\x02\xac\x48\x58\xfa\x34\xcb\xe8\xda\x5f\x51\x20\x13\xc8\x2e\xfd\x0f\xf4\x46\x41\xfe\xec\xd2\xff\x0b\xbd\xc9\x4a\x16\x54\xbf\xf5\x44\x89\xdf\x62\x21\x4e\x9a\xe2\xc7\x23\x20\x93\xf2\x97\xfe\x8a\x95\x67\x98\x71\x4a\xe0\xa3\x26\x64\x56\x40\x17\xb8\x9c\x0b\xa0\xef\x04\x52\x4a\xb8\xdd\x57\xb7\xf8\x51\xfe\x16\xb3\xa2\xcc\xa5\x24\x28\x25\x5c\x1d\x48\x2e\x50\x8e\xab\x14\x28\xab\x5d\x47\x25\x35\x96\xa3\x97\x9a\x7a\x3b\x8b\x34\x59\xa3\x81\x59\xd1\x45\x0e\x96\x8b\x9a\xc1\x5a\x56\x57\xe4\xc4\x39\x1f\x44\x70\xc8\xef\x86\x30\x31\x81\x63\x21\x5c\x83\xc1\xeb\x67\x96\x90\xc1\x21\xec\x97\x14\x18\xc2\x9f\xc0\x72\xdf\x61\x8e\x47\x94\xad\x08\xfe\x84\x77\x5c\xec\x8c\x5e\x1a\x5d\x2c\x77\xc7\xcf\xc1\xf4\x9d\x15\x92\xc3\x1a\x96\x96\x8b\xaf\x39\xae\xb0\x0f\x96\xa3\x41\x78\xa8\xc0\xb8\xd5\xac\x2a\xb3\x3f\xeb\x40\x14\x07\x14\xa8\x17\x2c\x85\xd8\x41\x94\x81\xb7\xd9\xac\x22\x1a\x32\x5e\x7a\x31\xd0\xed\xc6\x8b\x43\x1a\x16\x79\x19\xd1\xbc\x1b\x4a\x68\x8c\x04\x02\x4c\xe0\xc5\xe0\x53\xf0\xd3\xe4\x03\x8d\x21\x8a\xf3\x04\x5c\x9e\x14\x38\x83\x2c\xf0\x56\x1c\x3c\x07\x99\xa9\xa1\x5d\x2f\xa3\x60\x09\xde\x6a\x95\x5c\x67\x08\x9a\xc1\xcd\x13\x06\xf6\x32\xa3\x21\x5c\x47\xf9\x32\xb9\xcc\x39\x82\x59\x94\xc4\x6d\x28\x82\xd0\x98\x5e\x73\x50\xfd\x78\xf4\x48\x5c\x2b\x53\x3d\x62\x06\xc5\x26\x2a\xca\xd5\x24\x97\x70\xc9\x9d\x76\x0b\xae\x00\x8b\x46\xac\xfa\x8e\x36\x6b\x10\x71\x26\x3e\x00\xc6\x7d\x5b\xcd\x2a\x5d\x3f\xa6\x72\x3f\xa6\xef\x44\x62\xcf\x8f\xf2\x23\xbc\x14\xa0\x75\xd5\x8e\xc2\x02\x3e\xe3\x89\x2f\x21\x8a\xaf\x68\x9a\x51\xbd\x15\x8c\xe2\xab\xb7\x0d\x43\x58\x7b\xb4\xd3\x00\x41\x3a\x06\x88\x0a\x9a\x4c\xb1\xec\x9c\x8c\x99\x40\x37\xa1\x7f\xaa\x05\x1c\xaa\x1f\x34\x0e\xd2\x9b\x4d\x7e\x8b\xab\x00\x45\xc6\xda\xe4\x59\x59\xaf\x2a\x6c\xd4\x4d\xbe\x36\x85\x6e\x48\xbf\x46\xab\x15\x45\xba\x72\xf7\x3e\xeb\x6e\xd9\x28\x08\xa9\x72\x3a\xfe\x4c\x73\xd9\x4f\xab\x23\xb7\x42\xa0\xd2\xd5\x58\x4d\x1e\xf0\x62\x69\xb3\x18\xde\x9c\xa5\xf0\x3e\x5e\xc4\x51\x1e\x79\x2b\x39\xf5\x55\xbd\x0c\xdd\x06\x4b\x2f\xbe\xa0\x27\x6f\xaa\xb4\xa8\x3c\xf3\x98\xb9\x35\x17\xfc\xbf\xa6\x48\xab\xeb\xf0\xfb\xa9\x71\xc6\xba\x58\x68\xeb\xbc\x39\x91\xeb\x58\xd8\x8e\x2d\x3e\xbb\xd5\x71\x39\x6e\xe6\x62\xc1\xfe\xdf\x11\x37\xac\x33\x16\x1f\x65\x66\xda\xae\xab\xda\x78\xfa\x30\xd4\x28\xfe\x95\x6b\x15\x7e\xef\xbf\xb6\x4d\x31\x12\x29\xfd\x09\x04\xa7\xbb\xf6\xa2\x14\x0c\x59\x4e\x34\x65\xd3\x7a\xd9\x54\x94\x55\x22\xf9\x9c\x46\x59\x4e\x57\xa5\x14\xab\x21\x2e\xb0\xf3\xbb\xb9\x16\x6e\xb7\x81\x5e\xb0\x81\x96\xa7\x5a\x3b\x8f\xde\x9d\x0f\x06\x02\xdb\xf7\x95\xb9\x66\x8e\x64\x39\x75\xc1\xdf\x98\x56\x5b\x45\x1a\x85\xc1\x6e\x28\x52\xaa\xa3\x54\x43\x93\x56\x05\x1a\x8b\x7e\x03\xfe\x43\x1c\x26\x90\x5d\x7b\x1b\xee\x7e\xac\xbc\x2c\xe7\xc2\xd0\x36\xe1\x79\x37\xcb\x1a\xc8\xd6\x19\xd6\xa5\xf8\xb9\x42\x86\x31\xa3\xf8\x6d\x55\xbd\xa5\x1a\x5f\x4c\x05\xef\xa2\xea\x77\x31\x29\x3d\xa6\x4b\x31\x23\xcb\x21\xb9\xcc\x5b\x16\xb8\x34\xb9\xdd\x2c\xab\x99\x5c\x3d\xcf\x6a\x43\xc6\x07\x7a\xc3\x53\x40\x4f\x9c\x43\xdb\x92\xdf\x44\x57\x9a\x17\x52\xde\xe8\x89\x32\x6b\xf4\x21\xbc\x65\x12\x28\x26\x01\x69\x92\x65\x95\x9b\x8e\x39\x0f\xd1\x21\xc6\x69\x29\xaf\x51\x0e\x54\x15\xe1\x06\xc5\x78\xb5\xf6\xb2\x0f\x35\x95\x2d\x64\x77\x30\xa8\x89\x28\x53\xc4\x62\x74\x7d\x5f\xeb\x3a\x53\x5a\x06\x45\x22\x41\x4d\x64\xdf\xa3\xcc\xfe\x41\x29\xf8\xec\x1d\xf3\xa8\x38\x64\x51\xaa\xd0\xbb\x16\xda\x6f\x4e\x76\x47\x3b\xd5\xa3\xbd\xea\x46\x7b\xd5\x81\x76\xba\x03\xda\x9d\x49\xa4\xb3\x22\x8b\x34\x0f\x7f\xec\x96\x47\xba\x2f\x09\x33\x87\x95\xd3\x6d\x2e\xa7\x62\xfe\xee\xf8\xed\x48\x38\x68\xb5\x5c\xcc\x06\x04\x8b\x0b\x45\x72\xed\xcd\xca\x63\x48\x6c\x73\x68\x42\x11\x0e\xd7\xa0\x6a\x47\x05\xa8\xcc\xec\xdc\x0e\xd4\xd4\x93\x6e\x7f\x77\xfc\x56\x99\x71\xfb\x2c\x8d\x36\x2b\x7a\x70\xbb\x10\x11\xaf\x54\x0b\x14\xc9\x8f\xfe\x79\xc2\x45\x22\x10\xc1\xd0\x8e\x30\x43\x69\xd0\xbc\x1e\x48\x78\xb1\x34\x23\x30\x67\xe5\x46\x9c\xaa\xc7\x9c\xc7\x49\x3a\xa8\xee\x59\x17\x17\xc7\x17\x4d\x8f\xb2\x55\x14\xd0\x81\x69\x80\x35\x6c\xdd\x85\x51\x82\xb5\xee\x08\xd6\x32\xc0\xe9\x00\x6b\xdf\x11\xac\x63\xc0\x64\xa8\xbf\x48\xe3\xce\x73\x0f\x9a\x91\x91\x5c\x59\xaa\xa1\xa5\xcc\x48\x9e\x73\xec\x50\xc1\xde\xa1\x85\x2f\x33\xa7\x61\x6d\xdd\x12\x39\xeb\xb6\xdd\x27\x3b\xb4\xa0\x1e\xf5\xc8\xcc\xfa\x62\xc3\xde\x7f\x11\xb3\x5a\x5a\x97\x2f\x60\x5c\x2b\x58\xb7\x34\xb1\x3a\x13\x57\x37\xb4\x65\xa9\xce\xfc\xf9\x65\xa9\x46\x0a\x7d\x29\x31\xfb\xd1\xd8\x32\x1a\x59\xf5\xa5\xe4\xee\x47\x63\xc7\xa8\xb2\xba\x1f\x8d\x27\x86\x48\xf6\x7e\x34\x21\x9f\xde\x19\xae\xf3\x59\x09\xf7\xff\x91\x99\xf6\xbf\x5a\x3e\xfc\xff\x9c\xcc\xf6\x78\x53\x41\x14\xd3\xf0\xcb\xa6\xb8\xff\xd6\xcb\x68\x95\xb5\xde\xcb\xa8\xf4\xee\x27\xdb\xea\xcc\x80\xdf\xd6\xe5\xed\xc4\x81\xd8\x5b\xd3\x6c\x23\x6b\xe9\xa1\x8c\x06\x2b\xc2\xd0\xe0\xff\xfe\xed\x93\x0a\xcc\x53\x98\x38\xe5\x15\x36\x2a\x30\x3f\x4d\x1c\x86\x07\x22\xb5\x9d\x38\x23\xf1\x83\xe1\xaf\xf0\x0c\x2a\xd0\x1c\xbc\x08\xa7\x44\x7f\xa5\x19\x78\x10\xd3\xeb\xd5\x0d\x70\x5d\x0b\x55\x0d\xcb\x06\x05\x6a\xb7\x79\xc4\x97\x6b\x9f\xa6\x9f\x00\x6f\x95\xc2\x5b\x55\xd8\x17\xdb\x42\x77\x7e\xd4\x59\x65\x95\x5c\x63\x0d\xf6\xaf\xaa\x42\xbd\x72\xdd\xba\xb5\x0b\x14\x74\xd9\x56\x74\x29\x2c\x42\x41\x9e\x62\x60\xe6\xab\x7f\xa6\x65\xda\x38\x2b\x73\xcc\xb1\x39\x31\xeb\xf1\xce\x82\xd2\x68\xe2\xe3\xa8\xe6\x51\xb1\x1e\x1a\x0c\x6b\xf5\x18\x26\xee\xd7\x52\xdc\xea\x89\xaf\x59\x6f\xe7\x50\xbf\x7d\x5b\x9e\x99\x37\x39\xf5\x6d\x94\x5f\x47\x19\x85\xd3\x57\x67\x19\x42\xe8\x63\x4c\x71\x51\x8a\x10\x90\x4f\xf0\x94\xf1\x97\xd1\xe5\x00\x09\x23\x46\x12\x6f\x91\xd3\x14\x62\x7a\xe1\xe5\x51\x7c\xf1\x05\x08\x8f\xa0\x28\x23\xbc\x60\xc1\x28\x4e\xf2\x81\x96\xaa\x87\x87\x10\x27\xbd\x9e\x2a\xde\xc9\xc2\x09\xfa\xf7\x92\xba\x0f\x95\xc5\x38\x61\xff\x5e\x10\x59\xe1\x92\x0a\xca\x08\xc2\x14\xd2\x50\xb1\xf3\x61\x0d\xbb\x9a\x07\xa0\xe3\xca\xd3\xd3\xef\x24\xae\xe0\x72\x02\x8e\xdb\x1b\x2f\xc3\xe5\x85\x9d\x74\xa8\xe4\x14\xc2\x60\x2a\x51\x32\x2b\x4f\x58\x13\x05\xdc\x2f\xcc\xfc\xa7\xa7\xdf\x7d\x19\xd6\xf3\xb5\x9d\x8a\xf1\x5e\x1c\x0e\xbc\x38\xc9\x97\x34\x15\x88\x74\x89\x81\x17\x87\xb2\x18\xb0\x1e\xf6\x88\x42\xa5\x67\xf7\x39\x41\xfa\xa4\xa2\xd4\x3c\x51\xfe\x1f\x26\x1f\xaf\xde\x7c\x6d\xf1\x78\xf5\xe6\x2b\x49\xc7\xab\x37\x5f\x46\x38\x92\xb4\x26\x1b\x49\x7a\x0b\xd1\x48\xd2\x3b\x4b\xc6\xc7\x5b\x4a\xc6\xc7\x7f\xb0\x64\xfc\xf4\xf5\x45\xe3\xa7\xaf\x26\x1b\x3f\x7d\x29\xe1\xd8\x36\xa4\x63\x7b\x2b\xf1\xd8\x7e\x86\x7c\xbc\xbf\xa5\x7c\xbc\xff\x07\xc9\x07\x2e\xca\xcb\x92\x11\xf3\xc8\xa8\x98\x10\xae\xe8\x22\xdf\xdd\x2b\x8b\x51\x26\xf8\x2f\x48\x16\x25\x24\xbc\xc2\xe6\x4b\x09\x03\x02\xfb\x32\xe2\x80\xa0\x6a\x02\x81\x4f\x4e\x06\xd6\xb8\x4b\x0e\x78\x21\x59\x14\x62\x95\x1c\xb0\x29\x50\x0c\x8f\xc0\xb6\x74\x2b\x5d\x92\xa4\x0c\x2a\x51\x79\xf4\x08\x62\x5c\x22\x2f\x85\x81\x6f\x1d\xb2\xe0\x00\x62\xe5\x65\xf5\x6a\x11\x62\x70\xda\xb2\xf6\x09\x8a\xc9\x53\x37\x42\x32\x98\x41\x0c\x07\x8a\x1b\x43\x5b\x4d\x37\x97\xba\x58\x73\xff\x99\xd2\x8b\xa1\xfc\xff\x71\xe2\xfb\x66\xa0\x9f\x5c\x14\xd2\xfb\xe6\x0b\x49\x2f\xe7\x7b\x5d\x52\x25\xe1\x2d\xe4\x79\x07\xe1\x6d\x59\x4c\x04\x75\x07\xf9\x95\xb4\xa0\x84\xd3\x2f\xc0\xa2\xf9\x7f\xb8\x04\xbf\x49\x72\x2f\xa7\x5f\xdb\x00\xa7\xd8\xca\x97\x12\x61\x84\xf6\x65\x44\x98\x23\x26\x8b\x70\x9a\xf4\xda\x5f\x56\xa4\x57\x7e\x45\x8f\x50\x0e\x84\x55\x8f\x87\xcc\x1d\xac\x9e\xbc\x19\x4c\x9c\x96\x58\x7e\x2e\xc3\xbe\x90\xcd\xf9\xe7\xe2\x58\x8f\xc9\x61\x25\x6e\xcf\xb0\x37\x2d\x86\x9d\xdc\x85\x61\x4f\xc3\xf0\x6b\x7b\xbe\x5e\x18\x7e\x25\xcf\x97\x5f\xf9\xfd\x25\xe6\xcc\x61\x63\xce\x1c\xde\x6a\xce\x1c\xee\x3c\x67\x6e\x8e\x08\xfb\xa5\x23\x8b\x1b\x46\xd5\xce\x6f\xe0\xa5\xe9\x0d\xab\x56\x8c\x21\xfc\x62\xf8\xda\xb0\x52\x5d\x0f\xaf\x86\xd1\x76\xa4\xf6\x2b\x9f\x1b\xf6\x79\x1b\x02\x87\xcf\xb5\xe8\xfc\x97\x7a\x75\xe5\x69\x2c\xae\x00\x4f\x16\x72\x6c\x33\x53\xdd\x70\x9c\x26\x1b\x9a\xe6\x37\xf0\x37\x71\xc5\x30\x16\x44\xf1\x2a\x41\xb4\xc2\x8a\x42\x40\xb2\x91\x0a\x4e\x61\x56\xca\x3b\xd1\xeb\xd6\x25\x8b\x2e\xe2\x68\x11\x05\x5e\x9c\x83\x8f\xef\xa3\x58\xd2\x0d\x6c\xb4\x23\xfa\x5b\xc5\xa5\x0b\x64\x8a\x27\x5f\x20\x0e\xdc\xc6\x40\xaf\x8e\x35\x72\x0d\x5e\x6d\x98\x58\x7a\xab\x61\x8d\xf6\xbd\x84\x03\xa5\x41\x2e\x29\x27\x81\xdd\x89\x88\xb4\xce\xe6\xcf\xd0\xd5\x6b\x99\xd4\xcd\x5e\xd4\xd6\x7c\xeb\x3a\xfb\x99\xc0\xce\x5b\xf5\xd9\xe7\xb6\x61\x6d\xe3\xb6\x50\x88\x4b\x66\xc4\x23\x3e\x9e\xa9\x09\x48\x48\x28\x59\x0c\x5b\x40\xde\xfd\x0f\xea\xaa\x01\xc4\xdc\x79\x79\x00\x85\xce\x28\xc5\xb6\x65\x96\xaf\xc5\xe6\x09\x34\x8b\xc5\x0f\xfe\xef\xc7\x8f\x8a\x03\x18\xcc\xef\x2f\x75\xe0\xde\x1c\xda\xab\x60\xf2\x87\x8f\xcd\x45\xf1\x79\x89\x46\x73\x2f\xa0\xd6\x69\x6f\x02\xe0\x3a\xb4\xa2\xf1\x45\xbe\x84\x07\xe0\xee\xb8\x95\xba\x69\x68\x9e\x25\xf1\x15\x4d\x8b\xa9\xa1\x64\x86\x85\x7d\x60\x83\x76\x71\x3a\x60\x27\xc3\x53\x8c\xda\x25\x77\x6b\x2b\x73\x9f\xe0\xac\x6e\x44\xf7\x32\x08\xbd\xdc\x03\x2f\xbb\x65\x3b\x3b\x47\xb2\xea\x2b\x85\x5b\xc9\x40\x8f\xf2\xe4\x27\xdb\xd2\x2f\x85\xe0\xeb\xcf\xd8\xb3\x23\xda\xaa\x0b\x95\x62\xe7\x4e\x51\xee\x84\x33\xb3\x44\xb2\x60\xaf\x6a\x17\x0f\x67\x9b\x02\x16\xef\xee\xce\x9b\xf7\xeb\x6d\x77\x9f\xf4\xaa\x96\xf0\x8a\x5a\xe7\xad\x2d\xfc\xec\x53\xe0\x30\xda\x5c\x66\xcb\x41\xe1\x48\x31\x1f\x41\x35\xaf\x54\x97\x6e\xf8\x12\xa0\xd8\x27\x5b\xb8\x22\x12\x83\x0b\x0b\x52\xc0\x34\xea\x6a\xa3\xdd\x48\xd2\xd2\x0a\x04\xc3\x44\x32\x48\x36\x38\x48\x6a\xc6\x7e\xe8\x75\x5b\x4b\xb1\xa7\x10\xac\x92\xb8\x6b\xa6\xb2\xab\x48\x23\x9c\xa6\x2c\xe3\x43\xbd\x2c\xe3\xeb\x4e\x59\x96\x21\xa3\x97\xc2\xd1\x2d\x77\xbe\xaa\x76\xba\x3e\xc3\xf2\xff\x82\x82\xfd\x2f\x9c\x32\x6d\xa0\x85\x2d\xe5\xf0\xda\x66\xb6\xd8\x35\xa6\x6f\x00\xcf\x30\x15\x0b\xeb\xdc\x39\xd1\x34\x53\xaa\xd0\x75\x4d\x7f\x7a\xd5\xe0\x7a\x17\x1d\xb8\x16\x22\x5f\x80\x3f\x8f\xde\xa9\xc8\xae\x17\x55\x2c\x5c\x5b\x5f\x2e\xdd\x63\xed\xbe\x99\xc6\x6e\x19\xb1\x35\xe6\xd3\x3b\xc3\x1d\xef\xb2\xdf\xe5\xf0\xc1\x3d\x58\xe6\xf9\x26\x3b\x3a\x3c\x5c\xe7\xcb\x6c\xe4\xd3\xc3\xcb\x7c\xe1\xfe\x9a\xc1\x95\x35\x22\x23\x0b\xfc\x1b\xf8\x5f\x6b\x2f\x5f\x46\x5e\xc6\x24\xa6\xda\x20\x83\xbb\x42\xf8\x66\x8f\xc3\x43\xf8\x8e\xe6\xfc\x38\x1c\xa5\x8c\xdc\x91\xe7\xaf\x68\x06\xff\x21\x5a\xfa\x8f\x6f\xfe\x80\xdb\xf8\x53\x4a\x8f\xcb\xfd\x2f\xad\x9d\x34\xb0\xc7\x99\xb7\x07\xf7\xef\x17\x8f\x1f\xea\xc1\xc3\x7f\xf0\xee\x48\xc0\x5f\xe2\x83\x0a\xf6\x5a\xfc\xae\x83\x16\x4f\xef\xdf\x57\xec\xcf\x99\xd7\x90\x2c\x0b\x77\xa2\x71\x81\x3b\x67\xfe\xc3\xe0\xbb\xf1\x4f\x93\x90\x8e\x7e\xcd\x20\x49\xe1\x5b\xbe\x95\x26\x5a\x44\x34\x84\x20\x09\xa9\x81\x50\xbc\x38\x84\xcb\x8c\x42\x94\xb3\x71\xed\x3f\x18\x1d\xa5\x3e\x88\x7d\x38\x65\x1f\x2e\xc4\xef\x7a\x1f\xf8\xd3\x87\x7c\x4f\x52\x55\x6d\x54\x96\x9e\xcb\xc0\x3e\x7e\x94\x7e\x8d\xae\xa3\x38\x64\xb3\xcb\x5a\x19\xbe\x75\x88\xe1\x02\xf2\x63\xdc\xec\xf3\xcd\x1f\x0e\x1f\x1c\x7c\xb1\xcf\x83\xc3\x6f\x78\x6f\xb3\x3c\x8d\xe2\x8b\xe7\x69\xb2\x7e\xb6\xf4\xd2\x67\x49\xc8\x38\xf7\x16\x1f\x8e\x16\xd2\x53\x41\xfc\x33\xef\x03\x8d\x39\x8d\x9b\x22\xbb\xb9\x8c\x6f\x18\x7d\xbf\xf9\x43\x69\xc1\x2e\x83\xcc\x0a\x29\x7b\x38\xe0\xed\xf0\x0e\xe2\xd2\x26\x6e\xbe\x2f\x86\x40\x7c\x14\x24\x97\x71\x4e\x53\x11\xb9\xc4\x47\xab\xc2\x56\xf0\xea\x95\xb1\xc0\xb7\x78\x9e\xb1\xf8\x41\xb7\x79\xea\xb1\x1f\xd7\xcb\x68\x45\x61\x50\x40\x7b\x24\x80\xf0\xa6\xff\x80\x75\x2a\x80\x81\xe8\xde\xd3\xbc\xa8\xb0\xbf\xcf\x54\xfd\x0f\xc8\x53\x5e\xf8\xf1\x1c\xcc\xed\x77\xae\x69\x32\x9e\xf3\x47\x8f\xf0\xd1\xb7\xcf\x9f\xb3\x47\x9a\x96\x18\xb9\x70\xba\x9e\x5d\xa6\x69\x72\xe1\xe5\xd4\x40\xa9\xcb\x97\x34\xa5\x78\xce\x13\x62\xba\xcd\x81\xa1\xe0\x05\x39\x4d\xb1\x12\x76\x63\x17\xfc\x10\xc1\x01\x2f\x7e\x1f\xcc\xed\xf3\x67\xa6\x39\x64\x12\x6a\x6e\xbf\xc3\xaf\x7f\x63\xc6\x79\x95\x5c\x57\xed\x63\xb5\x3f\x70\xca\xf3\xa1\x7c\x20\xba\xc8\x00\xd8\xcf\x9f\x0f\xf1\x68\xa6\x39\x84\x7d\x90\x20\xe3\x8b\xfd\x22\xe3\x90\x68\xbd\xf2\x82\x45\x57\x2f\xe3\xb5\x97\x07\x4b\x1a\x56\xed\x3d\x84\x24\x5e\xdd\x80\xb7\xd9\x50\xec\x77\x94\xa1\x02\xc2\x65\x1c\xe5\x06\x9b\x68\x06\x5e\x46\x71\xb6\xc9\x08\x51\x42\x2a\xcb\x30\x22\xe5\xc5\xbe\xa8\x12\x2a\x1b\xea\x3d\xe9\xe7\xc6\x8b\xd2\x76\xcf\xb0\x5f\x02\xd7\x3f\x08\xd2\x1d\x1c\x08\xdc\xbf\x69\x76\x40\x53\x93\x15\x64\xff\x0b\x7b\xcf\x4b\x15\xda\x78\x17\x65\xa0\x31\x2a\x03\x8e\xc2\x95\x2e\x94\x52\xce\xfd\x96\xba\x90\x47\x71\x48\xb7\x30\x87\x03\xa2\x14\xfb\x52\x8f\xf6\xf6\x24\xe1\xdf\xdf\xe7\xd5\x34\xc2\x8f\xed\x9c\x63\x91\x77\x4d\x61\x67\xa2\xf4\x9c\x71\x9c\x53\x86\x3f\x3d\x98\x17\xec\x7f\x28\xd1\x0b\xf6\xe7\x0a\xfb\x51\x00\x7a\xfc\x18\x88\x59\x08\x10\x7c\x14\x3a\x24\x58\x52\x60\xc2\x85\x15\x3e\x42\x4d\x0e\x4b\xe2\xef\xd0\x10\x02\xd4\x31\xa9\x24\x7e\xb0\xa4\xc1\x87\xb7\x81\xb7\xf2\xd2\x7f\x63\xb5\x06\x8c\x0f\xaf\x93\x28\xe6\xbb\xa9\x91\x00\xe5\xa3\xba\xc6\x57\x8f\xb9\xd6\x57\xc4\xc9\x97\x69\x72\x0d\xc7\x69\x9a\xa4\x03\xec\xd5\xde\x09\x73\x85\x2a\xd1\xfc\x61\x7f\x0f\xf6\x2b\x00\xa3\x3c\xe1\x96\x75\x40\x26\xc3\x51\x9e\xfc\xb0\xd9\xd0\xf4\x99\x97\xd1\xc1\x10\xf6\x39\x00\x26\xf2\x71\x92\x33\x01\x47\x64\x39\x5d\xf6\xd8\xcb\xa2\xa3\x9f\xbe\xc2\x48\x50\xd1\x09\xbd\x6a\xe6\x89\x57\xe4\x30\xf8\x32\x9b\x18\x9c\x38\x95\x15\xdc\x18\xc8\x04\x7c\x5c\xd4\xe1\x1c\xc5\x50\xe5\xd6\x35\x87\x4d\xbe\x70\x85\x78\x56\x54\x54\xb1\x45\x02\x7b\x5f\x08\xe7\xf3\xe7\xae\xb0\x75\xc2\xcc\x91\x03\xff\x26\xa7\x90\xd1\xdf\x2e\x69\x1c\xa0\xa1\xd3\x23\x5a\xb5\x51\x88\x0e\x0e\x84\x37\x6b\x3f\x59\x95\x8a\xa4\x6b\xd9\x35\xeb\x2d\x5b\xed\x96\x4b\x48\xfd\x44\x9a\x70\x02\x11\x41\xa0\x67\x66\x89\x52\xb9\xf1\x58\x81\x04\x9a\x61\x19\x09\xbb\x8d\x44\x87\xc0\x3f\xbc\x25\x92\xc4\xe2\x58\x9a\x02\xcb\x63\xb3\x06\x62\x7f\xae\x91\x9a\xc9\x0e\x9d\x39\x36\x5b\x9d\x71\x3e\x8b\xa2\xc4\x15\xc8\x4e\x39\xb2\xcf\x77\x44\x96\x58\xb7\xed\x54\x55\x52\x85\x55\xbd\xa3\x75\x0d\x28\x65\x13\x21\x34\x55\x82\xb9\xfe\x62\x9c\x68\x3a\x4d\x25\x50\xe6\xba\xb7\x9d\xab\x96\xd7\x54\x95\xef\x1d\x54\xca\xa2\xc5\x03\xc6\x04\x6e\xad\x76\x1c\x5c\xaa\x1e\xcb\x0d\xcb\xa3\x8c\x04\x72\x7f\xde\xa1\xfa\x0d\x8b\x5e\x55\xfb\x5a\x8e\x70\x49\xfb\x94\x7a\xe1\xb3\x24\xce\xa3\xf8\x12\x0f\xcf\x22\xf7\x2b\x53\xc4\x30\x79\x81\x7d\x7f\x3c\x47\xb4\x9e\x31\xc7\x42\x31\x1a\xec\xbd\x88\xaf\xbc\x55\x14\x62\x21\x4e\xed\x3d\xd1\xad\x92\xde\xf5\x56\x80\x03\xc4\x40\xc1\x79\xd9\xce\x3b\xa1\x26\xac\x6a\xf9\x70\x7f\x9f\x39\xe3\x85\x85\x6a\x80\xb9\xcf\xcd\x08\x77\x04\x99\x95\xfc\x9b\x64\x0c\x95\xa5\xed\xe7\x25\x62\x87\x87\xf0\x62\x01\xd7\x14\x98\xbf\x76\xb9\x01\xe6\xa9\x1a\x10\xe5\xff\xdf\xff\xf5\x7f\x17\xc3\x92\x0c\x02\x31\xfe\x46\xd3\xf3\x56\xc1\xbd\x96\xf1\xe7\xd2\xfb\x16\xb5\x60\x50\x49\x39\x2b\x4c\x64\x31\xb4\xe4\x1f\xb6\xfc\xc3\x51\x88\x6f\x9b\x57\x9f\xc1\xaa\x3a\xa4\x79\x9b\xeb\x82\xb2\x0b\x6f\x85\x87\x1f\x4a\x3a\xbe\xa1\x5e\x08\x8b\x28\xcd\xf2\x82\x4a\xd8\xad\xdb\xb3\xb9\x3d\xba\xc1\x20\x4e\xda\xe4\xcd\x86\x85\x4c\xf0\x86\xee\x0b\xfe\x0b\xcb\x2a\xe1\x5a\xd2\xb7\xc0\xb5\x3d\x86\x35\xe0\x1c\x17\x02\xf5\xac\x00\x85\x6c\x81\xb9\x46\x61\x1e\x36\xed\x81\x0c\x8c\xf0\x69\x06\xe6\xdc\x29\xb9\xab\x72\xc0\x4a\xe9\xad\xc4\x57\xb2\x51\x75\x07\xfe\x16\x22\x58\xb8\xf5\xbc\xef\x76\x93\xb6\x6b\xef\x06\xa2\x38\x58\x5d\xe2\x24\x84\x4d\x2e\xe4\x29\x8d\x8a\xca\xcf\x0b\xea\x1c\xdf\x82\x3a\x28\xca\x77\x23\xa0\x29\xe6\x69\x16\xee\x4d\xe2\x6d\xc9\x04\xb5\x75\x04\x35\xd1\x79\xe1\x04\xeb\xf3\x0f\xbe\x26\xcd\xdb\x23\x7c\x93\xa2\xae\xa0\xe8\xf3\x2f\x4b\x51\x34\x19\x77\x24\xfa\x14\x89\x6e\x6e\x9b\x64\x37\xb7\xe6\xb3\x21\x7c\x44\x8a\x0c\x38\x0e\xfc\x69\xc9\x0f\x47\xcb\x0f\x9c\x51\x29\xe6\x18\xc4\x94\xa7\x60\x6a\x4e\x14\xf4\x54\x72\xe1\x87\xb3\xe7\x07\x2e\x84\x18\x29\xa3\x61\x69\x79\x0b\xb3\x29\x4e\x60\x95\xbf\xd1\xa0\x49\xbf\xd1\xfe\x3c\x6c\xf8\x24\xc2\xd7\xa8\x46\x63\x8e\x5f\x09\xaf\xee\x92\x48\xc5\x0a\xab\x86\xad\xc8\x06\x50\x72\x4a\x24\x1b\x5b\x45\x7f\x6a\xee\x4e\x15\x27\xca\xd7\x1b\xc9\x1b\x19\xe4\xeb\x0d\xcc\x1b\x63\xc9\x10\xee\xcd\xe7\xdc\x28\x37\xbd\x13\xb1\x88\x91\xaf\x37\x4d\x3f\x43\x9a\xa0\x57\xa5\x87\x5f\x33\xf8\xc6\xc8\x0a\x73\x44\x70\xef\x8a\xa6\x59\x94\xc4\x7b\x47\xb0\x87\x41\xdf\x3d\x83\x3d\xe5\xf8\xec\x1d\x49\x5e\x21\x3e\xe7\xdd\x15\xcf\xf9\x8f\x6f\xfe\xf0\x49\x04\xe9\xde\x26\x6b\x0a\x4f\x5f\x7e\x07\xfe\x65\xb4\x0a\x21\xd9\xe4\xd1\x3a\xfa\x2b\x4d\x33\x03\x56\xd1\x07\x0a\xe9\xe8\xd7\xcc\xe0\x53\x62\x8c\xb4\x67\x1b\x1a\x44\x8b\x28\x60\xca\x1b\x46\xc8\xf0\x8d\x97\xe7\x34\x8d\x33\x84\x87\x95\xf2\x25\x85\x45\xb2\x5a\x25\xd7\x51\x7c\x71\xc4\x63\x9e\x4c\xfc\x1a\xe7\x22\x61\xaf\x10\x9a\x3d\x1e\xdc\xad\x15\x18\x79\xeb\xb0\x11\x45\x2d\x8f\x48\xb2\x77\xdf\xfc\x81\xb3\x4b\x1c\x9a\x2c\xc3\xdc\xf5\x01\x8c\xf5\x19\x79\x87\xcc\xa9\x66\x17\x8d\xa8\xf1\x3d\xe9\xf7\x28\x4e\x42\x7a\x76\xb3\xa1\x95\x33\x57\xc5\xaa\xc5\xc4\x23\x8a\xe5\xb8\xf1\x9b\x28\xbe\x48\xfe\xf5\x2d\x5c\x99\x23\x77\x64\xe2\xf4\xbc\xaa\x21\x9d\x25\x2d\x91\x11\xa6\xb1\x80\xe4\xa5\xd7\x4b\x6f\xd5\x80\x34\x1d\x99\x07\x3c\x10\x93\x16\x7b\xa3\xf8\x29\x46\xf1\x6c\xe9\x65\xaf\xae\xe3\xd7\xc5\x16\x98\xb9\x28\x34\xaa\x3f\xc7\xe2\xe5\x12\x09\x66\x8d\xe3\x44\x29\x2c\x46\xbd\x38\x5f\x1f\x62\xef\xf1\x20\xf1\x90\xd1\x46\xa6\xd5\xf9\x07\x9e\xc0\x90\x95\xc0\xef\xb5\xe0\x57\xa3\x5f\x6f\x96\x51\x9c\xb0\x5e\x79\x70\x4d\x7d\x10\x07\x55\x45\xd4\x7a\x24\x04\x5a\xd0\xe4\xd3\x37\xe2\x88\x2a\x2e\x9b\x7c\x32\xfe\xf6\xe9\x9d\xe1\x4e\x76\x59\x12\x69\x9d\xd8\xfd\xe9\xe5\xc9\xf7\x79\xbe\x79\xc3\x86\x8c\x2c\x2f\xa1\xfd\x8b\x1f\x5d\xf0\xcd\x2c\xa3\x5f\xb3\x7f\xd9\x75\xb1\x45\xae\x04\x57\xd6\xc8\x1c\x4d\xcb\x00\xde\x45\x94\x2f\x2f\xfd\x51\x90\xac\x0f\x5f\x46\x1f\xe8\xcb\x60\x75\x28\x17\x3f\x3c\x79\xf1\xec\xf8\xf4\xd9\x31\x30\x1d\x96\x0f\x2a\x5f\x94\x01\x7c\x00\x80\xbd\xcb\x8c\xe2\xb4\x30\xc8\xf7\x1e\x7e\x83\x8f\x0e\x1f\x7c\xc3\x57\x94\x14\xad\x8b\x37\x4f\xe1\x5f\xbd\x2b\xef\x6d\x90\x46\x9b\x1c\x56\x91\x9f\x7a\xe9\x0d\x2a\xa8\x97\xfa\x51\xce\x7e\x1d\x6c\x52\x1a\x44\xcc\x4e\x80\x87\x79\x30\x68\x1e\x05\x23\x51\x7d\xc7\x2e\x88\xd2\xcf\x92\xcd\x0d\x4f\x0f\x33\x08\x86\x60\x99\x64\x0c\x2f\xa3\x60\xe9\xd1\x15\xbc\x0c\x56\xde\xe5\xc5\x72\x15\xc5\xf0\xe8\xa5\x1b\x2c\x5d\x77\xf5\xbf\x2e\xd6\x5e\xb4\x62\x30\x1f\x8b\xfa\x2f\x5f\x9c\xc1\xf1\x76\xe3\xe5\x70\x12\x05\x38\x8c\x8b\xf5\x4c\xde\x5d\x3c\x1d\x1c\x5d\x9c\x62\xab\x06\xf0\x4c\x0f\x06\x6c\xbc\x34\xa3\xa7\x97\x6b\x9a\x46\x81\xf1\x4d\xb1\xc8\x16\x65\xe2\x11\xcc\xe1\xf0\xfd\xc1\x93\xc1\xcf\xe1\xfe\xe0\xe7\xd1\xcf\xe1\x83\xe1\x93\x8f\xec\xdf\xfd\xe1\x80\x9e\xef\x1f\xbc\x7b\xc2\xbe\x3e\xf9\xe3\x61\x54\xd5\x5d\x7b\xf9\x32\xa0\xd1\x0a\xe6\xf0\xd2\xcb\x97\x23\xf6\xbd\xfe\x76\xb1\x4a\x92\xb4\x78\x8d\x3f\xaa\xf7\x71\x92\x7f\x9b\xf0\xb0\x8f\x98\xe0\xf8\x49\xb2\xa2\x5e\xcc\x44\xdc\x8f\x62\xc6\x81\x30\xba\x88\xf2\xbd\xaa\x0e\x66\x79\x8a\xe2\x8b\x97\x7c\xb1\x64\xaf\xf8\x0d\x6b\x66\x92\xab\x72\x79\x92\xbc\xf4\xe2\x9b\xef\x58\x75\x26\xc3\x7b\x62\xdb\x15\xb3\x88\x4c\xd3\x61\x9d\xa4\xcc\xae\x7a\x31\x90\x71\x6d\x27\x16\xb6\x98\x49\xa0\x9e\x9e\xbc\xfe\xfe\xe9\xb7\xc7\x67\x0c\x8a\x49\x2c\xdb\x19\x4f\xa6\xee\xcc\xf3\x83\x90\x2e\x2e\x96\xd1\xaf\x1f\x56\xeb\x38\xd9\xfc\x96\x66\xf9\xe5\xd5\xf5\xf6\xe6\xaf\x4f\xbf\x7d\xf6\xdd\xf1\xf3\x3f\x7f\xff\xe2\x5f\xff\x72\xf2\xf2\xf4\xd5\xeb\xff\xfd\xe6\xed\xd9\x0f\xff\xf6\xe3\x4f\xff\xfe\x7f\xfe\xf8\x8b\x04\xf6\xdb\xa7\x6f\x8f\x61\x0e\x84\x12\xa7\x7a\x78\xf2\xea\xcf\xbf\x14\x2f\xa4\xc7\x2f\x9f\xfe\xf4\xcb\xdb\xa7\xcf\x8f\x7f\x79\x71\x7a\x76\xfc\xe7\xe3\x37\x18\xbc\x25\x0b\xf9\x63\x94\x8b\xa9\x6c\x52\xf1\x7e\x6c\xc3\x01\x90\x6f\xa4\x67\x0c\xc6\x8b\xd3\x33\xdb\xc2\xca\xd3\x56\x35\xa8\x03\xc0\x94\x9a\x15\x80\xd7\xaf\x7e\x7c\xfb\xcb\xd9\xf1\x29\x73\x06\x88\x01\xc4\x64\xff\xb3\x3f\xd4\x66\x7f\x1c\xf6\x67\xcc\xfe\x4c\xd8\x9f\x29\xfb\xe3\xb2\x3f\x33\xf6\x07\x4b\x53\x42\xf0\xaf\x85\x7f\xed\x77\x55\xef\xde\xfe\xef\x37\x67\x65\xaf\xe9\xd4\xf8\xa6\x42\xfb\x41\xf9\x15\x1e\xf0\x43\xd7\xd1\x3a\xca\x21\xe1\xfb\xe4\x78\xdc\x3a\x59\xc0\x77\xc7\xcf\x5e\xbc\x7c\x7a\xf2\xcb\xeb\x93\xa7\xcf\x8e\xdf\x1a\x70\xf6\xea\x97\xe3\x9f\x5e\xff\x72\x7a\xfc\xe7\xf2\xfb\xeb\x57\x6f\x0d\x78\xf9\xe2\x94\xfd\x30\x90\x18\xf8\xc5\x8b\x43\xb9\x89\x1c\x77\x4c\x5e\x5c\xae\x69\x2c\x76\x62\x27\xcc\x50\xc7\x34\xce\x23\x6f\x65\x40\x9e\x3c\x8f\xb6\x34\xc4\x2f\x49\xba\xf6\x72\xb1\xac\x94\xbc\x2e\x6c\x83\x01\x3e\xbd\x49\xe2\xb0\x48\xe1\x19\xcb\xe0\xe9\x36\xa0\xb8\x19\x90\xaf\xae\xa4\xc9\x75\x0c\x83\x68\x01\xc7\x6f\xde\xbc\x7a\xf3\x16\x1f\xa6\x97\x74\x38\x92\xea\x1c\xca\x42\xc0\x08\x74\x3c\x7b\xa8\xe0\x99\x82\x87\x26\xc3\xbf\xe4\xfa\x37\x75\x4b\x58\xec\xe1\xe0\x99\xaa\xf8\xd0\xee\x55\x46\x83\x79\x23\x59\x9e\x5e\x06\x79\x92\x0a\x6c\x04\x26\xa5\xd5\x15\x9b\x7e\x07\x41\x12\x2f\xa2\x8b\x57\xfe\xaf\x85\xfd\x05\x61\x81\xc2\xe8\x4a\x62\xa5\x40\x2a\x0a\x21\x4f\xbd\xe0\x03\x5f\x5c\x62\x83\x23\x4d\x4b\x98\x06\x64\x09\x30\x7d\x8d\xbd\x35\x2d\xd2\xa8\x8a\xf9\x60\xc8\x06\x40\xca\x3c\x6d\x10\x89\x3e\xb2\x51\x0d\x78\x84\x09\x02\x8d\xda\xb3\xd7\x30\xaf\xfa\x34\xda\xa4\x49\x9e\x30\x03\x50\x2f\xf4\xea\x94\x09\x5e\x4c\xaf\xab\xa2\x03\x32\x34\xbe\x69\xe0\xfe\xa0\xef\x03\xc7\xdf\xbd\x38\x7b\xfa\xed\xc9\x31\x7c\x77\xfc\xfc\xe9\x0f\x27\x67\x6f\xa1\xb7\x4e\x69\xb2\x55\x12\x0f\xa5\xd4\x87\x74\xe1\x5d\xae\xf2\x22\x89\xac\x4f\x57\xc9\x35\xac\x2f\xb3\x9c\x13\x28\xa7\x17\x34\xcd\x70\xe7\xb8\xd8\x41\x8a\x44\xcb\xa2\x2b\x0a\xa9\x17\x5f\xd0\x0c\x32\xdc\x6c\x3f\x52\x01\x17\x40\x19\xb9\xbd\x55\x86\x39\x66\x79\x9e\xaf\x10\xbc\x1c\xd2\xcb\xf8\x20\x8f\xd6\x14\x2e\x33\x66\x66\x2b\x6a\x72\xbe\x37\x21\x1e\xb6\x38\xce\x9a\x58\x7b\xdb\x68\x7d\xb9\x96\xf6\xbe\x86\x34\x88\xd6\xde\x0a\x36\x2b\x2f\xa0\x19\x0e\xb4\xcc\x61\xf2\x78\x16\x99\x28\xbe\x4a\x56\x57\xac\xbd\x30\xba\x42\xb5\xaa\xb7\x53\xd7\x77\x98\x83\x65\xaa\x0c\x59\x4d\x0d\x76\xa1\x73\x6d\x34\x11\x99\x76\x97\x34\xae\x9e\x8b\xb3\x19\x9e\x9f\x5c\xd1\x46\x1f\xb8\x25\xc0\xe2\x48\xaa\x26\xfc\x3e\x4b\xd2\x36\x24\xa8\x9a\x98\xee\x72\x50\x13\x80\x61\x8b\x8d\x3f\xbc\x2e\x7f\x98\xf0\xf4\xda\xbb\xe1\x0b\xa3\x7f\xa5\x69\xd2\x2a\xfb\xdd\xab\x1f\x4f\xc5\x0f\x02\x67\xc9\xb5\x97\x86\x99\xba\xe4\xb3\xe3\x17\x27\xe2\x87\x55\x96\xdc\x7f\x11\x2f\xa2\x38\xca\x6f\x5a\xc5\x9f\x9f\xbc\x7a\xf5\x86\xff\xb0\xcb\xe2\x07\xda\xe2\xdf\x3f\x3d\x79\xfe\x0b\x47\xdc\x29\x8b\xc7\xd4\x4b\x69\x96\x43\x4c\xa3\x8b\xa5\x9f\x5c\xa6\x23\x78\xb1\x00\xe6\x4f\x86\x51\x96\x7b\x71\x6e\xc0\xe5\x46\x0d\x8a\xf7\x6b\x7c\x1b\x50\x61\x72\x1d\xab\x81\x1d\xff\xdb\xf1\x29\xc0\xe4\x36\xc0\x72\x51\x94\x5e\xd1\x58\x2a\xa7\x04\xcf\x29\x3b\xbd\x0b\x78\x3d\xfd\x11\x32\x67\x82\x7b\x17\xc8\x5a\x56\x1d\xd6\x7e\xbf\x79\xf5\xc3\xe9\x77\x2f\x4e\xff\xfc\xcb\xcb\x57\xdf\x31\xc3\xe9\xa8\x35\xaf\xd2\x3d\xb7\x65\x12\x8e\x7f\x7a\xfd\xea\xf4\xf8\xf4\xec\xc5\xd3\x93\x5f\x9e\x9e\xc1\x11\x9c\x57\x03\x36\xc8\x23\xf6\x3b\xa5\x35\xa1\x42\x8f\xc4\xf8\x2f\x54\xc7\xa7\x31\xf5\xf2\xa5\x18\x77\x8b\xd5\x5e\x31\xb6\x65\x65\xa5\xc8\x5b\x31\x67\x13\x0d\xcd\xa8\x09\xfd\xb4\x72\x12\x8f\xe0\x60\x5a\x7b\x2d\xa1\x38\x87\x83\xa9\xae\xd7\x55\xbf\x0f\xda\x46\xa7\x0b\x7f\x6e\x53\xbe\x18\xf6\x16\x51\x61\xff\xfa\x15\x5a\x4b\xd2\x8f\xbd\x0a\xf9\x37\x4f\x4f\xff\x7c\xcc\xd8\xd5\xf4\xa3\xd4\x7c\x5a\x47\x31\x5a\xfd\x7a\x7f\x8d\x06\xa7\x2e\xe3\x90\xa6\x0b\x36\xa0\xe5\x09\xda\x21\x48\x82\xe0\x32\xcd\x7a\x98\x63\x5b\x0e\xc0\x60\x4c\xd9\x97\x61\xad\xa8\x40\x0e\x57\xd8\x68\x07\x9f\x18\xcc\x03\xd2\xc9\xa9\x62\xdc\x6a\xf6\x40\xe6\x55\x72\x55\xa1\x5f\x68\xd0\x4e\x5d\x00\xdb\x74\x01\x06\x64\x34\x9d\x4d\x27\x33\x9b\xd8\x8e\x3b\xb1\x6c\x32\x9e\xd2\x7d\xdb\x74\x87\xcd\xba\xcf\x93\xb4\x20\x37\x3c\xe6\x3e\x36\x1d\x5d\x8c\x1a\x8e\xcb\x1e\xf3\xb6\xc5\x67\x6f\x38\xda\xac\x2e\xb3\x01\x19\xc2\xda\xbb\x61\xe3\x7a\xb6\x4a\xae\xeb\x48\x15\x10\xb9\xe7\xad\xa7\x15\x2e\xf4\xeb\xe4\xe2\xc7\x25\x65\xae\xa0\xe4\x3e\x62\x48\x34\x03\x2f\xa5\xcc\x1e\xa6\xc2\xd7\xad\x37\x2d\x9c\xde\x39\xfa\xbc\x3d\x4d\xb3\x22\x6c\x56\x88\x51\xc5\x56\xfb\xcf\xd0\x5d\x61\xd8\x45\x71\xfe\x6f\xde\x2a\x0a\xbd\x3c\x49\x4f\x13\x81\x45\xcd\xc1\x46\x08\x0d\xcf\x31\xc3\x3a\x2f\x30\x40\x2a\x43\xf8\x31\xca\x97\x1c\x86\x51\x34\xa5\x7e\x7d\xa8\x6a\x57\x4b\xa6\x3c\xc1\xdd\x8f\x7c\x5a\x7e\x91\x7a\x9b\x65\xc4\x1c\xe1\x9b\x83\x8c\x06\x97\x29\xba\x6c\x61\x52\x3a\x4b\x17\x34\x16\x7e\x91\xc1\x7a\xe2\x5d\x79\xd1\xca\xf3\x57\x8d\x3e\x3c\x7b\xf3\xef\xaf\xcf\x5e\x81\x88\xbb\x76\x0b\x7d\x17\x31\x95\x6e\x11\x06\x72\x92\xa6\x53\x14\x78\xab\xe0\x72\x85\xc7\x41\xd1\x29\xc2\x52\x97\xd9\x11\x78\xec\x2b\xb4\x47\x56\x06\xea\xb7\xcb\x24\x8f\x98\x26\x0d\x7e\x83\x39\x78\x70\x08\xf1\x90\xb1\xa5\x00\xc6\x9c\x4e\xf9\x42\x0d\x9c\x25\x24\x69\x4a\xb3\x4d\xc2\x5d\xb0\x9a\x8f\xa6\x6c\x23\xa5\x6b\x2f\x62\x56\x05\x06\x69\x0b\x78\x76\x04\x29\xb6\x7c\x00\x31\x3c\x80\xdf\x9a\x10\xf4\xae\x95\xd9\x00\x1e\x65\xb0\x49\xb2\x28\x67\x5e\x76\xb4\x40\x4c\x99\xb7\x1a\xd2\x38\xc4\x9d\x44\x98\xa2\xea\x8a\x1a\x3c\x86\x27\x3d\xe9\x70\xc9\x48\xa3\x8d\xa5\xc7\x27\x4a\x19\x9b\x10\x65\xd1\x45\x0c\xe2\x41\xd1\x52\x0b\x96\xfc\xc1\xb3\x24\x32\xf3\x70\x13\xe0\x7a\x8d\x3b\x03\x3f\xc4\x6c\xf6\xe9\x65\xb0\x97\xa7\x97\x71\x80\xd4\x29\xbc\xed\x3d\x1c\x91\xa2\xac\x0b\x38\xf3\x21\xae\xbc\x15\xe3\x65\x9e\xc0\xc0\x83\x3f\x21\x2b\x63\x29\x8e\xd6\xe1\x22\xda\xb7\xe9\x68\x96\xa4\x30\x78\x7d\x93\x2f\x93\x18\xfe\xd4\xf6\x7e\x2b\x8f\x6d\xa2\xe8\xf2\x7a\xb3\xa2\x62\x3a\xbf\xa4\xf0\xe2\xf8\xf8\x18\xa6\x63\x47\x6a\xba\x98\x7d\xb6\xe0\x1e\xff\xf0\xec\xe4\xc5\x77\xec\xfb\x0c\x8e\x2f\x83\x55\x14\x46\x5e\x5c\xcd\x48\xe0\x37\x7e\x4e\x29\x1e\xc4\x43\x78\x00\x18\xdc\x1a\x30\x89\xf6\xfc\x6c\x10\x0f\xdb\x78\xd6\x59\xd3\x10\x25\x6f\x75\xed\xdd\x54\x12\xd5\x27\x96\xac\x7e\x9b\x6f\x06\xc7\xa2\xf6\xa4\x8d\x39\x32\xb7\x4d\x88\x66\x13\x8c\x7c\xdc\x84\x97\x32\x83\xca\xcf\xe6\x6a\x92\xbe\x57\xf3\xb6\x56\x87\x9f\xae\xf2\x65\x72\x79\xc1\x8f\x49\x63\xb4\xa0\xae\xbd\xf5\x49\x27\x03\x6e\xb0\xa2\x37\x38\x5c\xc5\x49\x0e\x17\x4c\xb7\x2e\x33\xba\xb8\x5c\x41\x4a\xb3\xcb\x55\x9e\x75\x3b\xa7\x2f\x5f\x7d\xf7\xc3\xc9\xab\xc2\x35\xdd\xc1\xcd\x99\xed\x38\x5f\x6d\x47\x08\xf9\xa9\x17\x2a\xf0\x2a\x7e\xe5\xc9\xeb\xe4\x9a\xa6\x3a\xa2\xf0\x4d\x1e\xaf\x5f\xfd\xf8\xcb\xeb\x37\xc7\xcf\x5e\xbc\x7d\xf1\xea\x94\x31\xdf\x34\xc4\xce\xe4\xeb\x68\xb5\x42\x5a\xc4\x18\xe8\xa2\xa1\xa2\xe1\x3a\xc4\x3a\xac\x39\x8f\xca\x75\xf5\x58\xe7\xeb\x2c\xf8\x2c\xb4\x58\x8f\xe2\x8b\xc8\xc8\x70\xff\x06\xbb\xa6\x08\xa4\x8c\xca\xc9\xeb\x9a\xe6\xcb\xa4\x61\x8d\x9e\xbf\x7a\xf3\xf2\xe9\x19\xae\xb1\x35\x91\x11\x53\xe7\xb7\x74\xe3\xa5\x6c\xcc\x3c\x82\xbd\xd1\x9e\xd1\x2a\x76\x91\x26\x97\x1b\xb9\x90\xa1\x2d\x84\x19\x6b\xed\xf6\xdb\x8c\x06\x49\x1c\x7a\xe9\xcd\x9f\xab\x62\x66\xbb\xd8\x22\xf5\xd0\x08\xfc\xb9\xd9\xe2\xcf\xdb\xa7\xe6\x9e\x51\x52\x2a\x4e\xe2\x03\x3f\xa5\xde\x07\x26\xc3\x98\x2b\xb3\x07\x14\x6f\xb0\x56\xe8\xd3\xc3\x6f\xe4\x10\xe7\x57\xfb\xc8\xb1\x25\xe6\x25\xbd\x3a\x7d\x7b\xf6\xe6\x87\x67\x67\xaf\xde\x7c\xd3\x15\x62\x55\x06\x01\xd1\x66\xf0\x95\x1c\x66\x02\xda\x26\x53\x1d\x50\x64\xce\x69\x91\x46\x9b\xef\x1d\xaf\xa0\x8b\xe5\x35\x09\x84\x0c\x2d\x2e\x4e\x52\x7f\xe4\x1b\xec\x3e\x96\x15\x31\xd1\x81\x58\xb2\x40\x7f\xbc\x86\xc5\xb9\xff\xae\x3a\x83\xcd\xba\xe3\x7b\x19\x36\x1d\x8f\xe0\x05\x8f\x94\x19\x60\x31\x45\x98\x38\x55\x98\x4c\x1d\x71\x2d\x63\x9d\x95\x7f\x0d\xb1\x01\x3e\x0c\x1b\x22\x8d\x0b\xe6\x06\x50\x03\x22\x83\xe1\x66\xc0\x8a\xc6\x06\x64\x79\xda\x96\xb4\xad\x38\xdc\xf5\xb0\x3d\x2d\x8e\xf1\x38\x8d\x4c\xf5\xcb\xcc\xbb\xa0\xe5\x6d\x4f\x31\x6d\x78\xef\xd1\x02\x06\x70\x6f\x00\xdb\x92\xc8\xc9\x42\xa2\xf0\x10\x11\x6d\x61\x70\x78\x08\x7b\x55\x8f\x86\xb5\x06\x99\x23\x2a\xb7\x77\x04\x7f\x8b\x3f\xed\xb5\x40\xb0\x86\xb9\x4f\x3d\x84\xd4\x8b\x32\x3a\x00\x6b\x62\xc0\x5e\x17\xa8\x3d\x03\x62\x18\x3e\x6c\xc1\x12\xc2\x52\x9f\xc7\x08\x3a\xd7\x4b\x7f\x6a\x91\x6c\xaf\x5e\x6b\xc8\xb9\x8d\x8b\x49\x71\x11\x18\x3d\x82\xbf\xf9\x8d\x2e\x68\x6b\x32\x54\x93\x05\x0f\x9a\x2a\xea\x21\xbd\x7d\x98\xcf\x21\xbe\x5c\xe1\xa9\xa2\x7b\xd5\xe4\x61\x00\x3e\xde\xb2\x31\x71\x0c\x88\x42\x03\xf6\x18\xc4\xbd\x0e\x26\x7c\x77\xb9\x59\x31\x43\xdb\x1c\xec\x8b\x86\x62\x1d\x57\xdb\xf6\x94\x7d\xb6\xa3\x0c\xe6\x10\x8f\xb2\x36\x89\xf9\x6b\x8a\xaf\xa9\xee\x75\x00\x73\x6c\x94\x15\x0a\x60\x08\x4f\x18\x2c\x3c\x7a\x38\x84\x23\x88\xd5\xd5\x78\xd4\x5d\xfd\x8e\x33\xb6\xfd\xee\x53\x9b\x1a\xd8\xdf\x01\x53\x9d\xea\xdc\x57\x8c\x9b\x15\xb8\x2a\x33\x32\xde\xbf\x8f\x1e\xbb\x89\xbb\x93\x7a\xa8\x40\xd8\xc4\x02\x1e\x81\x09\x4f\x44\x9f\x0e\x62\x83\xcd\xf6\x59\x57\xc8\xc3\x36\x02\x20\x26\xd9\x5e\x96\xc3\xc6\xcb\x97\xe8\xe5\x14\x91\xf5\x36\x7f\xa0\xe2\xd1\x7c\x3e\x87\xbf\xff\x3d\xd6\x22\x04\xc5\x91\x4a\xc0\x33\x17\x06\x1e\xab\x8c\x1f\x42\x04\x8f\xd9\x68\xcd\xbe\x1c\xce\x71\x41\x8d\xee\xef\xab\xf4\xa3\xea\x19\x03\xa0\x61\x1f\x94\x2c\x3c\x8f\xdf\xe9\x8b\x74\xb1\x0b\x3a\x58\x06\x6a\xb6\xb1\x4f\x96\xb3\xf9\x54\x0c\xfb\xb8\x51\xb9\x55\xa9\xd8\xb4\xa6\xc4\x06\xcd\x57\xb9\x00\x3d\xca\x69\x96\x0f\x6a\x00\x51\x7b\x84\x81\x90\x97\xaf\x07\xb0\xe5\xe6\x15\x45\x46\x43\x34\x2e\x0a\x59\x9e\xca\x27\xb9\x70\xbf\xe0\x1c\x9c\x31\x4a\x06\x6f\x8b\x15\xe1\x92\x4e\x86\xb2\x94\xb4\x29\xb0\x53\xd7\x7c\x98\x83\xcf\xf3\xc3\x74\x13\x4b\x65\x14\x8e\xe3\x0c\x63\x00\xbc\xcf\x3c\x42\x18\x65\xdc\x6f\xe6\x17\x07\x36\x16\x3f\x3c\xbe\xf0\x23\xfc\x6b\x66\x73\x14\xf2\x7a\x78\x08\x4f\x57\xab\xe4\x5a\x19\x48\x6c\x5e\x2c\xc8\x4d\x21\x31\xcb\x95\x50\x8d\x7d\x42\x43\x48\x3a\x54\xb1\xb5\xac\xa6\x33\x69\x4f\x20\x86\x23\x24\x8e\x86\x95\x82\x1c\x48\x05\xe4\x7d\x83\x08\xfb\xa8\x1d\xfb\xcc\xe3\xaf\xc7\xa7\x15\xf0\x14\x72\xcc\xc8\x73\x95\x44\x21\x6c\x92\x5c\x10\x07\x6f\x2c\xd8\xa4\x54\x90\x28\x59\x54\xc1\x3d\xe6\xe1\x9c\x7a\xa7\x8c\xf2\x48\x29\xc7\xd9\x17\x8b\x68\x6a\xc2\xc7\x37\xc5\x44\x22\x8a\x6b\x0c\x60\x2e\x37\x77\xf9\x17\x5e\xb4\x82\xf0\x92\x16\x21\x8f\xf3\x63\xfa\xee\x7c\xff\xe0\x9d\x86\xf2\xbb\x5a\xca\x7b\xcc\x52\x7e\xfc\xa8\x20\xe9\xbd\x01\xb2\xe6\x0d\xbd\x38\xde\x6e\x06\xb0\xf7\xfe\xe0\xc9\x1e\xec\xc3\x00\x98\x09\xd9\x3b\x67\xdf\x8b\x7d\x0f\x42\x35\x98\xe9\x62\x9e\xcf\x3e\xec\xbd\xdb\x67\xad\xec\x2b\x39\xb5\x37\x78\x72\xf4\xf3\xcf\x23\x3c\x7b\xc5\xca\x0e\x9f\xfc\x71\xcf\xf0\xe1\x11\xd8\x53\x78\x02\x7b\xd1\x1e\x1c\x09\xbd\xe6\xea\x9e\xe5\xe9\x50\x2b\x41\x7d\x9a\xaf\xf0\x11\x34\x1c\xc6\x2c\x84\x97\xeb\xdb\x8c\x1a\xdd\xb6\x41\x6f\xd0\x44\xac\xf1\xfe\x7d\xac\x9b\x52\x5c\x1e\x1c\xc0\xe1\x7b\xf3\xe7\x91\xf9\xe0\xe3\xcf\xa3\x43\x03\x29\x50\x24\x27\x79\x0c\x64\xac\xf6\x11\x8a\x8f\xca\x5d\xb9\xe5\x7e\x16\x8d\x1f\x57\x12\x9a\xfb\x70\x11\xae\x47\x4a\x3b\x67\x34\x2e\x9b\x86\xc8\x02\xd7\xd7\x29\xbd\xa2\x71\x0e\x2b\x2f\x67\x93\x88\x72\xab\xa3\xe8\x6f\x82\x67\x21\xae\x28\xce\x24\xc4\xce\x28\x25\x28\x2e\xe3\x62\x77\x7f\xab\xf9\xae\x81\xe5\x2b\x58\x7e\x8d\x29\x17\x3d\xf9\xd6\x63\xe4\x43\xb1\x64\x23\xb9\x6f\x20\x0a\xbd\xee\xeb\x77\xc5\x0a\x72\x12\xc5\xf9\x93\xb6\xab\xc9\x7d\x06\x86\x24\x9e\x8d\x78\xb5\x18\xec\x8d\xf6\x98\xba\x3c\xe6\xb8\x56\x9d\x28\xc5\x8c\xcd\xa3\x51\xbc\x14\xf3\x8b\x86\xe9\x51\x36\x18\x15\x54\xa1\x5e\x1a\x2c\x07\x70\x48\x0f\x23\xe0\x4d\x9a\x7a\x4f\x96\xe6\x34\x5d\x47\x71\xb5\xb6\xa5\x31\x5c\x14\xb5\x6b\x88\xdd\x8a\xda\x64\xa6\xb0\x3f\x87\xfd\x8a\x29\x10\x31\x9b\xae\x92\x40\x89\x7d\x97\x3e\x9f\x21\x0e\xb8\x73\xd5\x24\x3a\x94\x5b\x54\xcb\xd6\xd5\x9d\x10\xb3\xc3\x36\xe6\x05\x0f\x8a\x1d\xd3\x35\xf0\x0a\x9e\x16\xb4\x58\x51\x0f\x43\x5d\x7f\xa5\x69\xd2\x18\x1a\xb8\x43\x28\x12\x6c\x34\xe4\x34\x12\x72\xca\xef\x71\x54\x31\xb2\x6a\x22\x4f\xbd\x68\xd5\xd9\xc6\x8a\xc6\x75\xf4\x9b\xcd\x1d\x1c\xac\x68\x5c\x35\xd9\x20\x5f\x53\x4d\xd8\x04\x97\x81\x14\x6c\x69\x49\x10\x9a\xf3\xb6\x52\xb6\xb0\x50\x8b\x51\x94\xe1\x95\xc7\xc2\x2a\x14\x8e\xcd\x15\x4d\xd5\x46\x8d\xb5\x28\xd9\x41\xe5\xe8\xfb\x95\x0c\x27\x77\xfe\x2f\xd7\xcc\xcc\x57\x06\x9f\x75\x53\x98\x73\xbd\x45\x65\x96\xe1\x01\xb7\xab\x4a\x51\xa3\x78\x97\xf5\x81\x7a\x90\x39\x3c\x84\x57\x62\xc1\xf1\x89\x4e\xc5\x1e\x97\xab\x7a\xda\x51\x05\xc5\x5d\xb9\xda\x2f\x3e\x7c\x2e\x21\xe6\x8c\x97\xab\x95\x9a\x61\x3f\x14\x6b\xb7\x6d\x5c\x9a\x7a\x57\xac\xca\x76\xa1\xf4\x7f\xda\xbb\x50\x6a\xe8\x9c\x0b\x84\x4c\x50\x4c\x71\x7a\x06\x84\x8e\xb9\x93\x00\xfe\x4e\x3f\x2d\x3c\x4b\xbd\x38\x43\x6f\x8d\x39\x7c\xda\x62\xb4\x48\x9a\x50\x38\xd0\x7a\x6b\x28\x6a\x44\xac\xc6\x35\x86\x7e\xf3\x04\x50\xc5\x50\xe5\xf2\x04\x2e\x68\xce\xf7\xfd\xe3\x39\x36\xca\x17\x31\x8a\x30\x73\x90\xd0\xc5\x22\x0a\x70\x25\x4d\x24\x5c\x52\xb5\x10\xe1\x94\x9e\x72\x6d\x85\x3f\x95\xdb\x4b\x35\x73\x79\xd9\x46\x46\xcc\x14\x57\xe5\xf5\x15\x22\x7e\x16\xb5\x73\xfe\xcb\x0a\x46\x43\x46\x68\x7e\x00\xa4\x66\xe3\xb9\xd5\x56\xaa\x43\xf1\xa9\x4c\xd9\x81\x84\x54\xd1\xf4\xc3\xce\xb6\x81\x73\x58\xd1\x70\x64\xd4\x7b\xc9\x91\xd0\xc1\xd0\xf8\x3b\xa0\x30\x92\x51\x07\x18\xc6\x92\xb2\xc1\x03\xed\xb8\x52\xb6\xda\x25\xd5\x1c\xde\xc1\x1c\x89\x70\x1b\x27\x8d\xd3\xf3\x21\x44\x07\x07\x38\x1e\x30\x2a\xec\x99\x7b\xfa\x89\xb4\x4c\x3e\xb5\xc7\xad\x44\x5a\x65\x33\xd4\x4a\xde\xa3\xe0\x8d\x7e\x34\xc3\x18\x9f\xb4\x91\x6e\x78\xfd\xe6\xd5\xeb\xe3\x37\x67\x2f\x8e\xdf\x4a\x65\xaa\xa5\x0c\xb1\x8b\x15\xe6\xc5\x7e\xd6\x87\xaa\x52\x38\xa7\xfc\xe5\x87\xd7\xf5\x56\x9b\xef\x71\x19\x77\x2e\xbb\x8f\xcd\x12\xb8\xef\x6b\x0e\x96\xbe\x04\x5f\x21\x9d\x83\xad\x2f\x52\x6c\x9c\x9b\x83\xd3\x53\x48\x20\x34\xee\x29\x86\x4b\xa7\x73\x98\xf4\x14\x13\xc8\x4f\x7b\x8a\x15\x3d\x70\x55\xe5\xc4\x92\xea\x1c\x66\x0f\xb5\x6b\x10\xcf\x70\x63\xe9\x65\x4a\x21\x8a\x17\x29\x9e\x53\xcc\x57\x37\x07\xb8\x27\x95\xb9\x3a\xe2\x70\xc6\xc1\x75\x14\x52\xc8\x68\x9e\x47\xf1\x45\xa6\x5b\x46\x78\x1a\x04\x74\x83\xd1\x60\x71\xe4\x07\x97\x32\xca\xc8\x06\xac\xa2\x2c\x37\x84\x9f\x11\xe3\xae\x88\xb5\x17\xdf\x14\x66\xb6\x3c\x73\x05\x22\x33\x6e\x44\x33\x48\x52\xb9\x01\xcc\xfa\xca\xfc\xb1\x0c\x52\x9a\x6d\x68\x90\x47\x57\x74\x75\x73\xa4\xc1\xa7\xb5\x77\xb5\x5a\xac\xa8\x96\x27\x8a\x75\xba\x6a\x7d\xa2\x0e\xa2\x1e\xe2\xd0\x83\x70\x75\x00\x1a\x1b\xf0\xca\xa5\x16\xfe\xcf\xf9\x3b\x19\xd2\x01\x43\xa4\x89\x4f\x83\x08\x3b\x7d\xce\x45\x38\xb5\x84\x68\x22\xbc\x51\xa3\xbf\xa3\x77\x8d\xce\xe2\xa6\xb3\xea\xa3\xc0\xf5\x34\x89\x0f\x70\xe7\x58\xf4\xf5\x91\x3e\x20\x05\xd6\xc5\x1b\xd2\x85\xbd\xf0\x0d\x2b\xec\xc5\x11\x97\x8f\x25\xcb\xc4\xf6\x27\xb1\x6f\x87\x30\x11\x34\xeb\x30\xc4\xde\x9e\xcf\x82\x21\x2f\x8c\x43\x4d\x64\xca\x0f\x5f\x0f\xd7\x89\x4c\x7d\x9d\x59\x0f\xa0\x43\x6c\xc5\x7a\x70\xd5\x0f\xae\x92\x32\x88\xb7\xb4\x7b\x9d\xb9\xc5\xbf\xe6\x42\x72\x01\x9a\x4f\x09\x3f\xb5\xca\xd7\x57\x94\x2b\x54\xba\xcb\x47\x7f\xa5\x75\xb1\x28\x7a\xdf\x2a\xdf\x5e\x6e\xee\x2e\xaf\x5e\x77\xd6\xe3\xd3\x5a\x5c\xd6\xe2\x23\x57\x1d\x48\xfb\xfc\xbd\x8c\x4d\x72\x78\x28\xb9\xda\xcb\x2e\x78\x23\x8c\xa4\x64\xed\xbc\x94\xaf\xa7\x61\x18\x47\xec\xfe\xc0\x73\xce\x6c\xea\x30\xd4\xb4\x77\x3c\xba\xa8\x2d\xca\x36\x4f\x0d\x0c\x2c\xd3\x00\x07\xf7\x66\xd5\xb6\x11\x75\xd6\xf9\x5b\xd3\x74\x1e\xe1\xb6\xff\xba\x31\x3c\x02\x07\x3e\xe9\xd0\x7a\x71\x11\xb3\xc9\x5e\xd5\xbb\x43\xc9\x7a\x67\x14\x37\x32\xe1\xc2\x5e\x92\x56\xe9\x8a\x6b\x1d\x79\x23\x16\xb6\xcb\xe1\xa4\xba\x05\xa0\x22\x59\x70\x99\xa6\xe5\x66\xd1\x4c\xbd\xb4\xdc\xec\x1d\xcc\x1b\xb9\x47\x65\x69\xc3\xc4\x63\x06\x6c\xda\x8b\xc9\x51\xfb\xcc\x0b\xfb\xa4\x78\xb2\xb5\xfd\xdc\xc3\xfc\x63\xe2\x78\x53\xfb\x75\xc2\x5e\x9f\x9b\xef\xda\x6f\xd8\x44\x79\x0e\x09\x9b\xe3\x8a\x98\x73\x22\x1f\x25\x56\x78\x8d\x4f\xea\xfd\xe1\x73\x85\xa4\x71\x98\x76\xb0\x91\xd6\x77\x06\x70\xc5\xda\x38\xdf\xbc\x83\x21\xdc\x13\xd3\xce\x86\x67\xc9\x3f\x47\x2a\xd8\x5e\x15\x4f\x8d\x9a\x40\xbd\xf3\x68\x7f\xbf\x0e\x56\x11\x55\xa9\x4b\x57\x69\xe0\x3a\x86\xe5\xd6\xe6\x9e\x3d\x21\xab\xc3\x26\xb4\xd6\x92\xf4\x95\x62\x49\x5a\x57\xb9\xb1\x2a\xdd\xac\x8a\xdd\x5f\x7a\xd9\x00\x36\x30\x87\xbd\x7a\x65\xb1\x1e\x20\x2f\x53\x5f\x19\x6c\xce\xf5\xf2\xe9\x4f\xb8\x5c\xbd\x01\x75\xfc\xbd\x75\xc6\xe6\xaa\xbd\xa4\x55\x67\x4e\xca\x58\x37\x6f\x54\x6c\xd3\xb9\xae\xb0\x1a\x32\xbb\x3b\x11\xb9\x0e\xea\x76\x34\xae\xd7\xbd\x1d\x89\x6b\x75\xb5\x14\x76\x3b\xe9\xdb\x3c\x47\xb1\x2b\x79\x6b\xf5\x14\x41\xde\xba\x6b\xd7\xf2\x96\x9a\xe5\x7b\xfd\x3c\x9d\xdf\x86\xef\x55\x4a\xf1\xae\x83\x61\x0d\xec\x6e\xc7\xb1\x46\xe5\xdb\xb1\xac\x5e\x59\xbb\x2d\x83\x87\x34\x32\x4c\x91\x31\xb8\xd2\xaf\x4c\x89\x72\x12\xcb\x99\xdd\x44\x12\x21\xef\x05\xe3\x9b\x72\x71\x4e\xde\xed\xa4\x7c\xc5\xa7\x76\xe8\x84\x35\xa1\x5e\x56\x6e\x14\xe7\xa7\x3c\x58\x63\xfa\xe2\x6d\xbb\x2a\x47\xec\x1a\xc2\xcc\xbb\xb5\x0b\xd2\xf5\x53\x32\x83\x3a\x46\xcc\x18\xf3\xd5\xb5\x83\x2b\x38\x82\x2b\xc0\xc4\x6c\x3b\xc4\x13\x54\x7a\x70\xae\x39\xe5\x0b\xcd\x38\x5e\x79\x70\xa5\x3d\x73\xb8\xcb\xc4\x81\x43\xd4\xcd\x0b\x84\x56\x28\xe7\x06\xbd\xda\xc1\xd1\xbc\xa5\x19\xc3\x3a\x81\x17\xb3\x6a\x3e\xc5\x85\x80\xdd\xea\xdc\xd2\xe4\xb1\x3a\x5f\x57\x6d\x0e\x48\xb7\xde\x90\xdd\xf5\xa6\x3a\x03\xd4\xaf\x34\xd5\x11\x98\xff\x14\x8d\xc1\xda\x57\x5c\x11\xe4\xb3\x4b\x03\x09\xb1\xdd\x15\x87\x7d\x4a\xa4\x9a\x3b\xf4\x18\x22\xfb\xb0\xd7\x90\x96\x3d\x83\x01\xbc\xa3\x0e\x36\x4f\x82\xa9\xb4\x4f\xcc\x81\x5b\xd3\x56\xc5\xa4\xb5\x6b\xe8\xe0\x50\x3a\x13\x45\xec\x30\x0c\x20\x94\x6e\x39\xbe\xc2\xc5\xb0\x7b\xf7\xae\xe0\xe3\x47\xf1\x83\x54\x5f\xf5\xfb\x5d\xba\x36\x57\xd5\xce\x18\x0d\xaa\xb3\x4f\xac\x95\x21\x3c\xd1\x9c\x2b\x82\x23\xe5\x89\x26\xed\xe2\x87\xcc\x74\xcd\x8e\x8a\x9a\x28\x88\x0c\x1c\x77\x17\x00\xde\x58\x9b\xe5\x22\x64\xf1\x99\x2c\x17\x50\x6e\xcb\xf2\x1a\x0c\x7e\xca\x0a\x2e\xe3\xf2\xe0\xd4\x11\xfc\x8d\x3f\xec\x96\x14\xde\xf8\xd7\x91\x94\xf2\xb4\xd6\xbd\x7b\x0c\xc8\xfd\xfb\x05\x9a\xd5\xfc\x4a\x3c\x90\xf3\x35\x69\xd4\x5d\x60\x72\xff\x3e\xdc\x13\x70\xab\x35\x49\x59\xf7\xf7\xda\xa4\xd8\x2b\x92\xc3\x28\xd9\xff\x9f\x24\x53\xbc\x13\x6d\x99\x92\x43\x58\x9a\x59\xc3\x6c\xa7\x59\x83\x0c\xe8\x76\x83\xad\x5c\xf3\x76\xc3\xa7\x54\x53\x3b\x5f\x98\x75\x8e\x15\xf5\xa3\x2d\xbb\xce\x16\xa4\x5a\x6d\x8a\xd6\x63\x7a\x9f\x39\xe1\xad\x03\xbb\x1d\x5d\xeb\x75\x6f\x47\xd9\x5a\xdd\x3b\xcf\x76\x9b\xc7\x68\x76\xa5\x6f\xad\x5e\x9b\xc2\x22\xac\x56\x44\x3a\xf5\x14\x10\x05\x05\xd9\x78\xf1\xfe\xbe\xf3\x5a\xdd\x36\x4a\xd8\x93\xab\xba\x29\xd1\xa8\x72\x79\x64\xe7\xea\x8b\xd9\x83\xbd\x7a\xa7\x3e\xc3\xdb\xe0\xc8\x35\x88\x5c\xec\x0c\x95\x16\x03\xf5\x4b\x4b\x6f\xe4\x73\x29\xd5\xf6\xd3\xeb\x65\x92\xd1\x6a\xaf\x6d\x2e\x9d\x00\x13\x0b\x41\x65\xd0\x4c\xb7\xce\x54\x25\x0d\xd2\x1e\x5b\xe9\x89\x03\xae\xbd\x6d\x33\x08\x58\x74\x6e\xed\x6d\x5f\xa5\x2f\xa3\x78\x20\x05\xef\xe0\xf5\x68\x95\xc3\xf0\xe1\x17\xea\xae\x38\xaa\xff\x0f\xec\x6e\x14\xdf\xb2\xbb\x17\x77\xed\x6e\x94\x2f\xc1\x2b\x4e\x55\xf3\x6e\xd3\xdf\x2e\xbd\x15\xb3\x6e\x49\x0a\x17\x78\x6e\x29\xe5\x7b\x80\x4c\xdc\xdd\xbb\xa2\x59\x26\xf6\x04\x19\xb5\x6e\xc7\x62\x87\x74\xb8\x31\x58\xd5\x46\x8c\x2c\x5a\x40\xb8\x61\x24\x4d\xd6\x51\x9e\xd3\xd0\x68\xa6\xb9\x19\xe0\x2e\xc8\x0c\x37\x2e\x15\x5b\xb7\x64\xf8\xb8\x8b\x0b\x43\xee\x9b\x34\x09\x2f\x03\x1a\x0e\x75\x1c\x38\x0f\x37\xd2\x41\xa7\xef\x6a\xed\x8c\x76\x34\xe1\x35\x80\x7b\x9c\x40\x83\x61\x13\xe9\x96\x29\x0f\x37\xb2\x55\xea\xa8\xd9\x30\xe4\xfa\x7a\x3b\x3a\x69\x4a\x41\x12\x7c\x9d\xc3\xa0\x3b\x80\xbe\x49\xae\xad\x5f\xc6\x36\x66\x3f\xb3\x4c\xf9\xa3\x88\x17\x14\x92\x34\xb6\xc1\x8f\xf2\x72\x3a\x1f\x1b\x62\xb3\x8e\x09\x8f\xe6\xb8\x55\x78\x66\x9a\x53\x32\x9b\x59\x63\x67\xea\x98\xb3\x99\xd5\x1a\x20\x9f\xe1\xf6\xd7\x68\xc1\x33\xe0\x95\x3d\x16\xfc\x95\xb7\x9f\xd9\x16\xbf\xb4\x99\x53\x2c\x4c\xd6\x31\xcd\xda\x29\x24\x5e\x2c\x20\xca\x21\x4c\x30\xe1\x50\x96\x5d\xae\x31\x81\xc8\x8a\x7a\x59\x2e\xb0\xad\x0b\x90\xc1\x0f\x06\x5c\x47\x19\x6d\x95\xb7\x4d\x2c\xdf\x6a\xc3\xdc\x3a\x82\x34\x4c\x98\xad\xf7\xb6\x69\x60\x4a\xe8\xea\x89\x85\x17\x58\xf2\x0c\x74\xe2\x09\xe6\x8b\x1b\xb5\xc8\xce\xbb\x32\xb6\xfd\x28\x17\x93\x9f\x3a\x21\x1e\x14\x8c\x11\xb7\x31\x20\xc8\xc6\xe8\xd0\x5c\x4b\x28\xed\x84\xc8\x2f\x38\x00\x0d\x4c\x34\x18\x0d\x60\xcd\xc5\x83\x62\xa1\xa0\x85\x97\x44\x85\x8f\x60\xf2\x27\xae\xb8\x32\x41\xb5\xf7\x5d\x01\xc0\xad\xaa\xb7\x97\x1c\x8a\xec\xe5\x25\x36\xe1\x46\x35\xa2\xe2\xa5\xcb\xb8\xa5\x98\x1a\xf0\xc1\x80\xab\xf6\xea\x0c\xe8\x57\x82\xd8\x87\xef\x6e\x53\xbf\x63\xe8\xb6\x8e\x69\xbc\x3a\x3d\x56\xed\xc6\x0a\x31\xd7\xef\x46\x7b\xfc\x8d\x19\xc5\xc2\xd5\x22\x0e\x4e\x6b\x5b\x2b\x76\xe1\x46\x1d\x60\xf9\x00\xf3\x32\x9b\x24\x83\x04\x87\xd2\xb6\x2c\x05\x2e\xcc\x0b\xe1\x13\x85\xae\x0d\x85\xe2\xfe\xb1\x0c\xb2\xcb\xcd\x26\x49\x31\x55\x05\x37\x2b\xa3\x0b\x9a\xbf\x41\x56\xfd\x9b\xe6\xe4\x46\xd1\x8a\x34\x35\x53\x57\xed\xde\xbb\xef\xc1\x5c\x53\x8f\x9f\xc0\xf8\x21\x8a\x73\xdb\xe2\x81\x33\xf8\x00\x0f\xe6\x60\xed\xb4\x19\x8e\xef\x7e\xfb\xf0\xb0\xbb\x75\x41\x07\x61\x18\x8e\xfa\xca\x09\x25\xd8\x24\xd7\x03\xcb\x00\xdb\x1a\x32\x9d\x66\xa2\x2c\x3f\xb6\xc8\x70\x58\xdd\xa6\x63\x0d\xfb\x80\x12\xf6\xe1\x7f\xb5\x5f\xb8\x9e\x14\x06\xb9\xfc\x72\x47\x7c\xf1\xfa\x23\x72\x2b\x24\x77\xf9\x68\xf0\xef\x03\x2d\x86\x9b\xc2\x4c\xaa\x25\xad\xf8\x88\xd5\xca\x77\x68\x3e\x78\xbd\x7d\x18\x78\xe7\xb8\x11\xfe\x5d\xd1\xb3\x0e\xe9\x80\x62\x04\x63\xce\x36\x33\x2b\x99\xb7\xde\xac\x30\x6d\x74\x1f\x9e\x6c\x4c\xbb\x52\x8c\x69\x7d\x15\x5f\xa7\x89\xef\xf9\xd1\x2a\xca\x6f\xd8\x48\x96\xc3\x15\x3c\x9e\xc3\x8c\x92\xb1\xd1\xca\x21\xd2\xae\x5d\x6b\x0a\x0e\x5b\xad\xc3\xdf\xe7\x60\x8e\x4c\xd3\x74\x0d\x88\x46\x74\x04\x04\xa2\x18\x88\x35\xee\x26\xbc\x88\x8a\x08\x44\x7a\x77\x88\x82\x38\xb7\xb7\xab\xaa\x5a\x9d\x7b\x45\x8b\x8f\xc7\x6f\xc3\xf4\xcf\xcd\x8e\x33\x99\x52\x61\xce\x64\x56\x81\xf4\x54\xd0\x6f\xb1\x6c\x7e\x24\xce\xce\xc1\x9d\xd5\x3f\x3b\xd7\x1e\x5c\xc1\x9f\x30\x57\xed\x90\xfd\xba\x25\x90\x62\xf7\x68\x01\x63\x17\xd2\xe1\xce\x5c\xab\x87\x08\xda\xb7\xfa\x37\x6c\x9c\xfc\x00\x87\x0c\xb4\x6e\xd4\x28\x12\x91\xb7\x07\x0d\x3e\xb8\xe3\x5d\xb9\x6a\x35\x96\x57\x04\x5a\xe3\x86\x54\xbb\xf7\xbc\x97\x7f\xb9\x58\x34\x53\xb2\x48\x1f\x69\x54\x91\xa0\x8a\x01\x64\xfa\xa5\x87\x0f\x71\xfd\x9c\x59\x73\x0a\x1d\xd7\xa8\xbf\x10\x8f\x7b\x8d\xb6\x54\x49\xb8\x97\x96\x04\x49\x98\x49\xe7\x4b\x8c\x2a\x77\x35\xd8\x77\x32\x84\x57\x18\xd8\x1f\x70\x9d\xbf\x0f\x36\x01\xee\x03\xd6\x49\x87\xd7\x3b\x56\xaa\xde\x28\xa0\x3d\x55\x59\xff\x14\x00\xac\x06\x80\x1a\x74\xbb\xf6\xf2\x96\x90\x9d\x77\x78\xcb\xc9\xa4\x06\x71\x8c\x0f\x5d\x7c\xc6\x9f\x4c\x74\x67\x26\x8a\xcf\x1d\xac\xb0\x42\xac\xa7\xc3\x51\x90\x6c\x6e\x06\xcc\x0f\x6e\x1d\xf0\x6a\x7e\x6e\x6f\x19\xff\x73\x6c\xdb\xf4\xeb\xd9\x36\x0d\xe8\x9d\x03\x78\x50\x05\xf1\x88\x73\xfb\x85\x03\x35\x92\xea\x63\xd7\x3f\x64\x54\x9e\xbc\x1d\x15\x4b\x23\x45\xa6\x3e\x48\xd2\xa2\xa5\x28\x93\x31\xc0\x58\x4c\x67\x5a\x3f\x10\xf2\x77\x2f\xd2\xda\x38\x85\x2d\xd4\xd1\x83\xa9\x77\x7d\x2e\x3b\xe8\x3a\xe5\xb1\x10\x6b\xb6\x42\xec\x03\xbe\x01\x6d\x5e\x8a\xc9\x67\x50\x8d\x4d\x95\x82\xf3\x83\x83\x48\xe1\x22\x84\x1b\xf8\x53\xe7\xb1\x9d\xea\x6e\xfc\xea\xec\xa0\x38\x4c\x27\xd2\x6f\x66\xf5\x04\x7c\x61\x33\xdd\x6e\xd1\xbb\x0f\x6c\x64\x0b\x37\x5a\xa2\x5d\xf1\xe8\x38\x66\x8d\x3f\x97\x4e\xbc\x84\x1b\x8d\x6b\x13\x70\x67\x49\x9a\xd5\x33\x59\xbe\x42\x33\xaa\x0a\x47\x2b\x3b\xf7\x86\xae\x93\x2b\xe9\x5c\x24\x2d\x92\xbf\x89\x74\xec\x29\x55\xe5\x3a\x96\x44\x81\x63\x31\xc7\x83\x99\xc1\x68\x93\x6c\x06\x43\x03\xa2\x83\x03\xe5\x98\x2a\x8e\xb3\x68\x4e\xe2\x45\xe5\x71\x53\x65\x77\x71\xfd\xbc\xff\x38\x9b\xce\x4b\x11\x3d\x2d\x0e\x99\x6a\x3a\xca\x53\xcb\x86\xbf\x5e\x66\x79\x95\xc5\xb4\x64\xf0\x4a\x73\x6e\xac\xca\x57\x72\x40\x90\x26\xa6\x44\x13\xbc\x5c\x94\x51\x85\xca\xa7\xb1\x74\x2e\x07\x0a\xdc\x65\x9c\x8b\x64\x7e\x72\xe6\xb4\xd6\xc9\xb6\x00\x05\x4e\x7d\x7e\x16\xd3\x61\x8f\x46\x5d\xf8\x46\x3c\xe5\xdb\x15\xea\x87\xf9\xee\x21\x1f\x78\x88\xc9\xbe\x88\x14\x2b\x11\xde\xe0\xac\x43\x54\xd0\x29\x97\x73\xf4\xf6\xd2\xaa\x64\xb5\x74\x8c\xac\x46\x19\x38\x50\x1d\x75\x56\x88\x2f\x33\x2f\xba\x73\x8a\xf8\x8e\x89\x4c\xa0\x4d\xa0\xc4\x8a\x34\x56\xac\xa4\x45\x91\xe1\x60\xf8\xb0\x7e\x4a\xea\xf5\x9b\x17\xff\xf6\xf4\xec\x18\x9e\xff\x70\xfa\xec\xec\xc5\xab\xd3\xb7\x8d\x43\x54\xc2\x4c\x78\x65\xb2\x2d\x1e\xe2\x67\x8c\xf2\xbd\x8c\xbe\xc0\xbc\x21\xba\xb7\xaf\x2e\xa5\x43\x8f\xd5\x0d\xb7\xad\xd3\xf2\xa2\xac\x21\x40\x1a\x3c\xf7\xa3\x2a\x7e\x1b\x16\x01\xb0\xd4\x80\xad\x01\xdb\xc0\x80\x1b\xf5\x86\x68\xf9\xbc\x3c\xec\x8d\xf6\x60\xd8\x2e\x87\xb1\xac\xc6\xb5\x11\x6d\xc2\xae\x7b\xf6\x5b\xf2\x34\x28\x9c\x18\x98\xe1\x42\x3e\x92\x9f\x27\x27\xc9\x75\x71\xc7\x70\x3b\xc6\x7c\x9a\xc4\x07\x91\xea\xc8\xb9\x10\xa8\xc7\xba\x0d\x04\x1f\x7a\x96\x1d\xa1\x38\x9b\x5b\xa4\x10\x2c\xef\xad\x69\x0b\x70\x73\xd9\x53\x9b\xb2\x46\x97\x63\xa0\x59\xfa\xa6\x15\x4c\xe4\xe4\x51\x14\xdd\xc2\x1c\x6e\x30\x76\x23\x9d\x82\xc4\xb3\xcf\x8a\xc2\x4d\x44\x3f\x74\x8f\x6d\x0c\x69\x0f\x97\x59\xaa\x95\x0b\xcc\xb1\x18\x43\x4a\xb3\x9c\xc7\xdc\x69\x79\x9a\x02\x36\x5e\x9a\x83\x7f\xc3\xd3\xaa\x8a\x84\xb6\x2a\xf8\x22\xd9\xa3\x7f\x83\xd7\x54\xe0\x31\x5f\x74\x94\x42\xae\x0b\x1b\xc6\xf0\x36\x95\x6f\x50\x73\xf3\xe4\x5b\x2e\xec\x83\x22\xf9\x3f\xbf\x7b\x95\x1f\xe6\x3d\x2b\x62\x55\x78\x14\x72\x68\xe0\x49\xc8\xa1\x48\x27\xc1\xeb\x29\xe9\x8d\x06\xe3\x66\x14\xec\x98\x9d\xa0\x1c\xfc\x97\xb4\x38\x09\xcf\xe8\xa4\x92\xc3\x6d\x03\xe9\x52\x5f\x99\x9a\x6a\x50\xa2\xe8\x81\xce\x61\x1b\xa8\x0f\xfa\x2b\x46\x68\x6d\xe6\x82\x87\xb0\x65\x6e\xce\x87\x77\xc0\x47\x9e\xad\x18\x8e\x9b\x6d\xf2\x2c\x52\x5b\x1c\xa4\xca\x7d\xff\x7b\x66\x33\xbf\x52\xcf\x90\x7c\x70\x40\x95\x89\x23\xda\x25\xc5\xd1\x78\x85\x21\x2e\x4f\x99\xab\x44\x07\x0d\x1b\x66\x01\xa6\xa1\x38\x47\x83\x89\x8d\x83\xbc\x4c\x8a\xaa\x3a\x16\x9b\x89\x24\xb3\x6a\xfd\x09\xa3\x2b\x4c\x88\x73\x63\x60\xf4\x3d\x5d\x77\x0a\xcb\x96\x9f\xe9\x57\x0d\x21\xf8\x22\x55\x65\xe4\xc0\x2c\x00\x9d\x62\x15\x62\xd2\x82\x7d\x66\x53\xf7\x5b\x59\x0b\x44\x76\xd1\x32\xef\x2b\xba\x00\x22\x92\x57\xba\x04\xc5\x59\x24\x7e\x27\x56\xb2\x90\xdf\x2c\xbd\xbc\x48\x5f\x5e\x24\xc1\x6a\x5e\x01\x11\x21\x3f\xce\xc3\x86\x1b\xc5\x04\xb1\xa0\xc6\x61\x33\x96\xc4\x7a\x9c\xc2\xc7\x8f\x10\xa2\x48\x7c\xfc\x88\x10\xf8\xac\xfc\x9e\x32\xe7\x01\xd6\x58\xc3\x23\x70\x30\x81\x4c\x54\x14\x63\x75\x53\xbe\xef\x64\x80\x43\x06\x4f\xba\x24\xbe\x0e\x90\x87\x7c\xf3\xa6\x0d\x47\x3c\xba\xaf\x9b\x37\x1c\x31\xbb\x0f\x1f\x58\xed\x88\x55\x66\x3e\x76\x01\xd3\xe1\xed\x94\x80\x27\xac\x41\xc4\xf9\x80\xe1\x7c\x1f\x77\x9e\xe9\xa7\x94\x6d\x6c\x5c\x38\x82\xa9\x62\xad\x01\x15\x85\x51\x05\xb7\xb2\x95\x8a\xa5\x3e\xcd\x4d\xde\x1f\x84\x1b\xc5\x3e\x3e\x28\x47\x8e\x14\x9e\x34\xec\xdd\x1e\xd9\x33\xe0\x00\xa7\x0e\x47\x5c\x51\xe5\x5a\x7a\xbd\x2b\x6c\x0a\x93\x7b\xcd\x92\x50\xda\xb5\x1a\xf4\xa6\x90\xc1\xcb\x0d\x4a\xd4\x9a\x7a\xb1\x38\xbb\x45\xaf\xa2\xe4\x32\x13\x22\x87\xb9\xa8\x93\xba\xc0\xa1\x1f\x9d\x25\xa0\x1a\x44\xa1\x34\x59\x07\x07\x42\xde\x1e\xc2\xfe\x3e\x5a\xaf\xf0\x1d\x3c\x86\xf2\x61\xd7\x04\x13\x05\x98\x0f\xc1\xdd\xd3\xca\x7b\x61\x6f\x1c\x65\x7f\xbf\x23\x4d\x20\x6f\x6c\x74\x19\x73\x47\x9e\x74\xe6\x3c\xd8\xed\xa9\x7a\x2e\xb6\x5b\x9a\x1a\x28\xa9\x57\x1f\x38\x50\xf2\x98\xf9\x7f\xa8\x9b\x7a\x1d\x8f\x2e\x46\x70\xee\x18\x80\x37\x8b\x8d\xdf\x81\x4f\x83\x64\x4d\x33\x70\xfc\x85\xae\x0d\xbe\x4c\x2a\x44\x73\x6f\x0f\xa7\xfe\xcc\x9b\x28\xb2\x20\x94\x49\xcf\x82\xa5\x97\x3e\xcd\x07\x8c\x2d\xe2\xec\x98\x36\x0b\x51\x5d\xba\x71\x98\xa4\xfd\xb9\x9f\xce\xaa\xfb\xaf\x30\x05\x9c\x17\x86\x3c\x03\x7a\x74\xd1\x90\xb1\xe2\xc6\xfa\x3c\xd5\x66\x3c\x78\x4d\x53\x4c\x4f\x52\xa6\xf8\x16\xf7\x40\x89\x6c\xce\x34\x44\x19\x1c\xc1\x33\xd6\x60\x28\x3c\x1d\x94\x69\xc9\x25\xaf\x5a\x65\x2f\x5b\x1b\x2a\x9a\x1d\x78\xca\x77\x13\xc4\xc5\x19\x8a\x2d\xc2\xfb\xd0\x18\xca\x0b\x10\xeb\xcb\x55\x1e\x6d\x56\x37\x38\x5c\x7d\xe0\xc3\x94\x52\x8e\x99\xaf\xbf\x36\x20\xa7\xeb\x8d\x01\xdb\x55\x62\xc0\x76\x19\x69\x16\xb6\xbd\x34\xbd\xd1\xaf\x7b\xe3\xb0\x20\xc4\x49\x5d\xe2\xc3\x2a\x41\x87\xe5\x4f\xd5\x1d\x74\x9a\x82\xcb\x22\xb6\x56\x5d\x56\xf7\x51\xa9\xaa\x5c\xcc\xb6\xd8\xb4\xc8\x9e\x2a\xf2\x6c\x68\x73\xcf\x21\x12\xdb\xf3\xe8\x9d\x8c\x87\x26\x13\x07\xe2\x81\x65\x5b\xa8\xa8\xca\xb3\x09\x0c\xc3\xfd\x01\xb6\xb2\x8f\xf5\x1f\xb0\x6e\xab\x8b\x33\xa2\xb3\x1a\xab\xa4\xac\x31\x80\x01\xac\x65\xc4\x30\x1e\x23\xff\xda\xe7\x7c\xd0\x04\x75\x04\x8b\x06\x1c\xf6\x21\xe7\x3b\x3f\xec\xb0\x8f\xa0\x1b\xfd\xc0\xe7\x02\xe5\xa5\x62\xde\x8c\x54\xe0\x91\x22\x84\xf8\x27\x84\xb8\x73\x0e\x40\xc4\x67\x08\xdb\xd2\xfc\xf1\x07\x0a\x46\x0a\xad\xdb\x76\xea\xb1\x34\xb3\x5d\x6f\xbc\x94\x0e\xc4\x56\x0d\xef\xc4\x00\xff\x44\x2b\xdf\x91\x01\xc1\x7a\xa3\x19\xc3\xc0\x3b\x61\xae\x85\xa6\x3a\x12\x15\xb9\xe4\x9d\xb0\xa1\xe5\x04\x9e\x00\x81\x23\x38\x50\x65\xad\xeb\x8c\x21\x55\x06\x91\xc3\x33\x79\x1c\xd4\x3b\x11\x79\xc7\xba\x42\xe8\x1c\x4f\xc6\x06\x86\x29\xfb\xb7\x6f\x48\x12\x38\xb3\xa2\x8f\x79\x0d\x3d\xde\xf2\x07\x93\xad\x7f\x89\x11\xaa\xf9\xa4\xb8\xd9\x9b\xf1\xa1\x5e\x52\xcd\xe1\xec\xd2\xcf\xd9\x74\xb1\xc6\xe2\x2e\x23\x16\x69\x06\xf3\xc3\x43\x78\x2b\x60\x81\xcf\x2f\x6a\xf3\xf4\xf1\x48\xef\xa4\xcb\x76\x78\xe7\xde\xc9\x3b\x38\x50\x26\xd3\x03\x61\x02\x79\x99\x47\xe0\xe3\xbf\x9c\xea\x1a\x73\xc1\x8b\xce\x81\x69\x1f\xf6\x6d\xbf\x68\x81\xd7\xbe\x65\x14\xb6\x23\x01\x9e\xdc\xc5\x7b\x1e\xf3\x30\xef\xdf\x97\x8f\x70\x93\x87\xe0\x15\x91\xc6\xfe\xb1\x74\x7b\x54\x5e\x88\x62\xc0\xcd\x51\x71\x69\x88\x72\x18\xad\x06\x35\xc5\xc4\x49\xcb\xcc\x80\x8d\x46\x3c\xbf\xfb\x3a\x49\xa9\x01\xb1\x81\x5b\xec\xf8\xdf\x13\x03\x7e\x33\xe0\xb7\xc0\x80\x94\xae\xf1\xcf\x09\xfe\x35\x0d\xd8\x46\x06\x6c\x4f\x0c\xb8\x09\x34\xa3\xd4\x0d\x7b\xf9\x57\xf5\xbb\x8c\x0f\x23\xcc\x73\xbf\x19\x65\xa5\xc6\xa8\x0b\x17\xb3\x3b\x4d\x33\x01\x8f\x13\x68\x5c\xa9\x08\xb3\x20\x9d\x7a\xa7\x86\x74\x89\x55\x0a\xa6\x26\xb4\x7d\x6f\x1b\x48\x93\x03\xf6\xed\x26\x10\xff\x68\x67\x0b\xa0\xcb\xf5\xae\x33\x33\xd5\x46\xcc\x53\xef\x94\xb5\x4b\x25\x2c\x93\x14\xfc\x24\x5f\xd6\xb1\xd5\xed\xad\xb9\xc7\x88\x88\xe8\xf1\x7f\x99\x5b\x07\x4f\x18\x4d\xf8\x1c\x0a\xc3\xdb\xc0\x71\x3f\xc2\xbe\x0c\xe1\x09\xb6\x7a\xd4\xb9\x4a\x2f\xd0\xfb\x7f\xff\x1f\x93\xa1\xb7\x65\xd3\x7b\xf6\x3d\x49\xe1\x86\x7f\x2f\xb0\x43\x7c\xd3\xa2\x74\x95\x49\x38\x2b\x0a\x6a\x51\x47\xbe\xca\x58\x9a\x05\xb9\x9f\x40\x86\x49\x7e\x8f\x20\x83\x43\x50\x2f\xbb\xef\x96\x1c\xf7\xb7\x56\xd0\x2e\x53\x54\xfc\x8d\x49\xd0\x6f\x65\xae\xbc\xe6\x6b\x11\x29\x80\x03\xb8\x51\xe5\x98\xcf\xf8\xde\xc1\x7d\x9e\x8d\x4e\x37\xf4\xdd\xd3\x2a\x21\xfb\xe0\xcb\x39\xe8\xdd\x23\xf6\xd6\x8f\xf2\xe7\x7c\xf9\x88\x61\x23\x6f\x23\x64\x56\xac\x7c\x79\xd3\x78\xa9\x06\x88\xd1\x17\xb9\x9c\xd2\xd3\xd2\x19\x41\x8c\x15\x96\x2b\x09\x22\x88\x91\xe0\xca\x06\xee\x2f\xa7\xdc\x49\xaf\xe5\x0b\x81\x64\x01\xea\x4c\x96\x67\xf5\xbc\x7f\xe5\x32\x4a\xc9\xb5\x8c\x0f\x26\x92\x47\x8f\x6d\x2e\xbd\x9e\x70\x1b\x34\x13\x92\xde\x88\x45\x30\xe0\xd3\x1f\x54\x70\x13\x86\x65\x3e\x52\x25\xeb\x78\xa5\xc7\x8d\x3a\x30\x04\x7a\x70\xa0\x63\x77\xd6\xb9\x42\xf6\x9b\x58\x5b\xd7\xcd\x50\x71\xeb\x34\xbf\x3e\xee\xb6\xe9\x20\x4f\xea\x31\x4a\x55\x99\x1b\x56\xe6\xa6\xbb\x4c\xa4\x3f\xf0\x99\x89\xfd\x4b\xba\x60\xc4\x69\x92\xae\xbd\x55\x94\x51\xa6\xdf\x6c\xe2\x74\x13\x40\x96\xc0\x32\xba\x58\xd2\x2c\x87\x24\x0d\x69\x2a\xe2\x11\xc9\x82\xbd\x8c\x32\x78\xcc\xe3\x59\x70\x08\xd6\x48\x0d\x38\xae\x2f\xa0\x8a\xd2\x03\x61\xda\x78\x1a\xc8\x8e\x05\xb0\xd3\x24\x87\x98\x06\x34\xcb\xbc\xf4\xc6\x00\xff\x12\x23\x73\x4b\x2f\x0e\x57\x14\x92\x90\xcf\x22\x8b\x84\x95\x37\x85\x45\x2a\xdb\xb1\x50\xc7\x34\x3b\x1c\x0f\x0f\x8b\x1b\x13\x1e\xf3\xc8\x52\xbc\xbf\x8f\x09\xe4\x99\x75\xe3\xb0\x1e\xc9\x80\x3a\x4e\x4b\x73\x10\x5d\x1e\x27\x8e\x76\xd5\x94\xf3\x26\xc0\x01\x9b\x1b\x17\xbd\x33\xb9\xad\xd7\xda\xee\x56\x6b\x17\x41\x81\x1d\x85\x4e\x93\xaf\x71\xcb\x04\xed\xe6\x44\x5d\x27\xa5\x6b\x0e\xb8\xca\xa7\x79\x73\xa2\x4f\xa4\xbf\x66\x68\xa4\x74\xad\xcf\xc4\x0b\x62\x7e\x1f\x86\x62\x43\x40\x9e\xc0\xda\xfb\x20\x5f\x58\xe6\x65\xb0\x4a\xe2\x0b\xf6\xaf\xd2\xd7\x2a\x3e\x85\x8b\x87\xcd\x3e\x62\x5d\x60\x5f\xcf\xd9\x4f\xbe\x1f\x42\x7b\x88\xfd\xe6\xaf\x9c\xaa\xc5\x1c\x5a\x53\xa8\x9c\xc7\x99\xba\x22\x81\x09\x62\x68\xef\x38\x3e\x7b\x13\x9c\x93\x77\xb2\x7e\xc1\x90\xd5\xdc\xdf\x57\xd7\xd1\xaa\xca\x46\xa4\x3e\xcf\xd3\xc8\x5b\x09\xf5\x8d\x45\x04\xd0\x90\x2e\x87\xe6\xed\xd8\x5a\x4d\xa9\x76\x11\xf2\x31\x6f\x0e\x36\x57\x13\x93\xab\xcc\x50\xf4\x8b\x30\x9d\xa6\x07\x64\xac\x61\x63\x98\x74\x28\x49\xdc\x13\x6d\xc4\xe5\x22\x9c\xd6\x96\xb7\xf0\xf1\xcb\x9d\x84\x14\xe8\x5d\x16\x3e\xd9\x2b\xe7\xc4\x37\x85\x63\x7c\xc3\xdd\xe2\x93\xce\x0d\x8a\xfc\x90\x4b\xd1\xe2\xa3\x5d\xda\xe3\xfb\x2d\xd7\x1b\x7d\x7e\xef\x66\xbf\x8a\x1b\x21\x65\x4e\x19\x10\x6b\xcc\x6a\xf1\x61\x2e\x3d\xd7\x9e\xde\x1d\xbd\x5c\xac\x70\x26\xcf\x7b\x2c\x55\x36\xab\xe9\xd5\x00\x81\x91\x72\x88\xed\xc5\x1c\xd7\x90\x96\xc9\x35\xcf\x53\x99\x47\x6b\x5a\xbf\x27\xf1\x22\xa1\xb8\x9e\x97\xd4\x5c\x8b\x1d\x68\x08\xed\xe1\x03\x51\x3d\x44\x51\xdb\x01\x33\x78\xba\xba\x48\xd2\x28\x5f\xae\x7b\xb7\x9a\x03\x19\x89\x03\x4a\x39\x5f\xc4\x42\xd4\x1f\xd4\xd4\x66\x10\xf7\x6f\xda\xb7\x46\x8c\xce\x05\xa4\xc7\x55\x37\x8f\xca\x87\x07\x25\x7c\x03\xe2\x83\x83\x5e\x90\xf6\x48\x32\x73\x07\xf3\x02\x4e\x6f\x3d\xa7\x86\xca\xb5\x97\xc9\x92\x0b\x5e\x0e\x56\x3f\x55\x00\xc6\xa3\x42\x6b\xd0\x21\x97\x00\xc4\x61\xd1\x8f\x1d\xc0\x4c\xf0\x96\xef\xaa\xf6\xe3\xa2\xee\x51\xbd\x73\x15\x65\xf6\xf7\x77\xd8\xc8\x59\x8d\xbb\x9d\x65\xa1\x90\x54\xe1\xf1\x3e\x16\x77\x6b\xc5\xab\x1b\x6e\x02\xf1\x67\x94\xe9\xec\x5f\xb3\xdd\xb8\x30\xcc\x43\x14\x50\xac\xad\x49\x8f\xde\xc6\xa2\x47\xcc\xfa\x31\x60\x00\xee\xe2\x4c\xc8\xf5\xd9\x90\xcb\xfe\xed\xf5\x11\x8a\xcf\xae\xc3\x74\xa3\xb3\x85\xb9\x2e\x3a\xbd\xa3\xb9\x96\x20\xbc\x50\xaa\xd3\x4e\x55\xcf\x6a\x63\x5e\x9e\x70\x67\x76\xa7\xaa\x68\xd4\x48\x59\x07\x3c\x3f\xb9\xcc\x61\xfc\xa7\xf2\x56\xcd\x68\x4d\x0d\x71\x27\x2d\x9e\x47\xe5\x97\xd7\xa2\x6f\x7a\xd5\xde\xa8\xa1\x68\x01\x6f\xa1\xf6\x29\x8d\xe5\x7c\xff\xb7\x40\xf2\x7a\x19\xad\x28\x1b\x64\x8a\x31\x8d\x07\x7f\x70\x54\x13\x11\x20\x61\xe6\xc5\xf8\xdc\xbf\xd1\x99\x7d\x62\xe5\xdc\x48\xd3\x87\x32\x6a\x58\x48\x32\x4e\xf7\x04\xbb\xfa\xbb\xc0\x3e\x55\x10\x93\xe3\x7f\xc3\xbc\x32\x2e\xa1\x4f\x98\xcb\x75\x84\xd2\x2d\x3a\xb4\xab\x84\xc3\x5d\xa5\x1c\x4a\x57\xa1\x27\x08\x0c\x9d\xdb\x9e\xe1\xb6\xbb\xbe\x51\xdc\x30\x4c\x43\x30\x10\xcf\x7e\x1e\xf4\x1c\xcc\x82\x52\x3f\xe2\xda\x8d\xad\x28\x90\xb8\xa9\x83\x89\x63\x61\xbc\x6f\x82\x42\xf7\xc0\xbb\xf0\xa2\x18\x7c\xba\x4a\xae\xd5\x91\xb9\x46\x0b\x59\x02\x01\xbf\xcf\x9c\x61\x96\x27\x3c\x87\x98\x87\xd7\x53\xed\x62\xaf\x24\x24\x89\x01\x2b\xca\x66\xff\x0c\x92\x97\x61\x82\xad\x2c\xa9\x21\xc7\x6f\xf7\x65\x38\x87\x1c\xd3\xdd\x4c\x32\xbf\x72\x6a\x07\x5f\x4b\xc2\x4a\xe1\xd1\x21\x3a\x31\xac\x2f\x33\xcc\x46\x55\x1e\x4c\xde\x81\x17\x50\xca\x4e\xbc\xab\xfc\xdc\x69\xb8\xd8\x75\x7c\xe8\x9b\xaa\x34\xab\xdc\x4a\x59\x7a\x70\x47\x8e\x70\xa0\x8f\x0a\x33\x84\xb0\xe5\xc9\x51\x9f\xdb\x50\x5a\x97\x82\x04\x68\x5d\x76\x1c\x02\x2a\xbb\x52\x5a\xc4\x22\x0c\xbe\x8b\x15\xb9\xf5\x70\x57\x1f\xa9\x1a\xde\x56\x37\xaa\xe5\x5c\x61\x3e\xe7\x97\x28\xed\x66\x33\x54\x33\xa1\x9a\x8b\xb6\xab\x66\x56\x6a\x50\xab\x6e\x94\x34\xac\x9b\xf7\xcf\x1d\x83\x57\xc9\xf5\x6d\x87\xe0\x55\x72\xdd\x31\x02\x5f\xd1\xf4\x06\x52\x2f\xa5\xab\x1b\xbc\x47\x77\xc7\x26\x5a\x03\xa8\x62\x52\x88\x7b\x8e\x76\x1e\x3a\xd9\xe4\xfc\xf3\x86\xce\x5b\xd0\x16\xda\x42\x7e\x53\x6a\x9b\x34\x74\xee\x2e\xf3\xc5\x47\x21\xfb\x7d\x55\x7a\x86\x42\xed\xdb\xda\xe9\x44\xd4\x80\xae\x24\x65\xc5\x27\xd6\x45\x41\xa4\x1e\xc0\x1c\x3a\x67\xc4\x9f\xca\xa0\x46\xd1\x2e\xe1\x1a\x54\xde\x78\x6e\x76\x06\x04\x9e\x8a\xcd\x31\x31\xdd\xe6\xe5\x64\xdd\x28\xb7\x0d\xf2\x48\x7b\xc7\x45\x38\x80\xe1\xe4\xe2\x10\x4e\xdc\x1d\x7d\xf8\x61\x13\x62\x64\x40\xbe\xa2\xbf\x27\xf6\xc0\x23\x02\xbd\xa4\xac\xc7\xbe\xb6\xc1\xf9\x56\x04\xca\xbb\x28\xd7\x73\x01\x0c\x54\x1c\x28\x20\xf6\x84\x26\x84\xc4\x75\x8c\x99\x9a\x55\xf5\x52\x89\x07\xb0\x8d\xf6\xf7\xe1\x11\x6c\x4f\x70\x43\x22\xef\x7d\xb1\x1f\x12\xb7\x42\x66\x9a\x23\x33\x50\x05\xee\xeb\xd5\xf4\x81\xc8\x13\x69\x19\xb9\xbd\x1e\x09\xe5\xda\xd1\x6f\x62\xed\xf1\xb7\xf2\x8c\xca\xce\xdb\x42\xca\x30\x9b\x58\x29\xd2\x6f\x22\x3c\x4b\x20\x28\x83\x47\xbf\x8d\xa8\x21\x8e\xb1\x14\xd7\x35\x89\x4d\xd5\xc9\x42\x3a\xec\x82\x88\xed\x70\x72\x25\x83\x39\x2f\xfb\x10\xb2\xe2\xe8\x4a\x26\x1d\x5d\xd1\x06\x75\xf9\xb5\xa8\xbf\x19\x7c\x85\x6d\xc0\xf0\xc2\x55\xfc\x7d\xa0\xf0\x40\x3e\x88\x42\x70\x7b\x0d\xe1\x0b\xde\xc8\x06\xcd\xde\xba\x67\x7c\x67\x5a\x94\xa9\x37\x88\x95\xe4\xec\x92\xce\xdf\xba\x2e\xdd\xfa\x6d\x94\xc2\x1c\xf6\x19\x0e\xbb\x1d\x8e\xe1\x8b\xa7\xbf\xed\x7e\xc2\x45\x9d\x1b\x4a\x1c\x53\x49\xe9\x26\xa5\x19\x8d\x73\xb1\xd9\xbf\x5a\x7c\xab\x12\x47\xe1\x2e\xba\x45\xb4\xa5\xe1\x01\x5e\xd0\xc8\x26\x0c\xd2\xf5\xad\x32\xf8\xf2\x2a\x5d\xe9\x9e\xde\xfa\xfe\xbb\x66\x6a\xa4\x54\x71\xd7\x9c\xfe\x2e\xfc\x28\x93\xaf\xce\xaf\x5d\x49\x10\x15\x39\xbc\xf0\xc8\x4b\x31\x5e\xaf\x98\x1b\xcd\xfd\x80\x94\xfe\x76\x19\x31\xff\x7e\xd0\xdc\x74\xad\xdc\x5a\x5d\xcb\x38\x05\xe9\xba\x00\x5f\xee\xe0\x5e\x27\x61\xfd\xca\xfd\xa0\x92\x15\xf1\x2d\x3c\x82\x3c\x91\xaf\x9b\x24\x33\xa3\xd8\x26\x89\x97\x36\x14\xf7\x79\x80\x45\xd8\x8f\xd7\xc5\x09\x15\xb0\x9c\x9e\xab\xf8\x17\x58\x0f\xef\x87\x8f\xb8\x18\x8b\x46\x95\x77\xf2\x9b\xb8\x69\x23\xa6\xd5\x85\xfc\xcd\x4d\xdd\x6b\xbe\xab\xbb\xb0\x5d\x8d\xe4\x81\x0c\x3e\xcf\xe4\xce\x5b\x31\x4a\x32\xbc\x4c\x42\xda\xda\xc8\xfd\x84\x81\xfa\x88\x6b\xf2\xbd\xc7\x86\xee\xf1\x5b\xd6\x8b\x1d\x11\x55\xb2\x92\x86\x92\x63\x9c\x3f\x1e\xb5\x17\x30\xe2\xf2\x3e\xf7\x36\xf0\xa8\x4c\xd2\xa3\x1a\x92\x8a\xab\x4b\x6b\xc7\x4e\x10\x1d\xdd\x16\x57\x41\x63\x36\x6e\xcf\x98\xc5\xaf\x7e\x5b\x0e\x5e\x37\x4c\xe1\xd1\x5c\x4a\xc8\xad\x50\xf9\x27\x75\x91\x10\x1b\x65\xe3\x36\x11\x01\x37\xc2\x2b\x36\xd5\xc6\xed\x5d\xb5\x3a\xf3\xc3\xe6\x84\xc2\x2a\xd6\x37\x36\xc4\x43\x21\x37\x3a\xc3\x17\x8f\xa4\x55\x73\x3e\x11\x0f\x31\x5d\x5b\x69\x23\xd8\x6c\x43\x77\x12\x01\xc4\x26\x84\x36\x5b\x6e\x4b\xf7\xdd\x6e\xcc\x94\x55\x87\x4b\x52\xa6\xbe\xe2\x5b\xf4\xa0\x1a\x9d\xda\xd6\x47\x05\xbf\xb2\x5f\x51\x26\x65\xc5\x53\x0e\x74\xe5\x6a\x18\x33\x7e\xa5\x7d\x15\xa6\x09\xcf\x17\xa9\x5a\xc0\x93\x57\x89\x4c\xdf\x86\xd1\x2d\xba\xa0\x58\x9a\x69\xdc\x69\x5b\x95\x6c\x16\xe4\x1e\x6f\x8f\x0c\x0f\xf8\x5e\x70\xca\xde\x35\xc4\x59\x97\x60\x53\x20\xf1\x74\xb3\xa1\xb1\x58\x2c\x55\x3b\x28\xc5\x3a\x28\xe3\xea\x23\x88\xe4\x4b\xf7\xd0\x34\xe9\xc7\xf6\x62\x8b\x79\x5b\x75\xb4\x63\xf7\x73\x25\xf5\x9a\x05\xbb\x6f\xe6\x87\x83\x39\xc4\x9a\xa1\xbb\x7b\xd7\xfb\xdd\x89\x24\xee\x9f\xdc\x07\x02\x8f\x77\xba\x52\x12\x0e\x0e\x22\x71\x2f\x31\x27\x70\x41\xd5\xd1\xde\xce\x77\x1b\xee\x70\xc1\xe2\x3e\xbf\x93\x55\x7b\xc9\x22\x48\x87\x36\x77\x98\x4f\x49\xdd\x9c\xcf\x45\x3f\x25\xc4\x3b\xeb\xde\xf2\xe2\x46\xb8\xf3\x0e\xd9\x4f\xca\x5c\x75\xb1\x38\x3c\x74\xff\x3e\x1b\x96\x9e\xc0\xde\xc1\x1e\xec\x23\x1e\x47\x9d\xc7\x13\xbe\xe7\x3b\x48\xea\xc9\x4e\xd9\xfc\xaf\x96\x0f\x54\x71\x60\xb8\x96\x0a\x34\x33\x60\x4d\xf3\x65\xd2\x3e\xff\x22\xce\x0c\xc4\x9a\x0b\x92\x94\x23\xa4\xb8\xac\x00\x01\xf3\x79\xc3\x10\xbf\xf3\x2b\x92\xb2\xd6\x70\xbb\x6e\x6d\x92\xab\xaa\x36\x1a\x28\xb8\xb4\xbf\x8f\x1b\xaa\xd3\x8b\xac\x3c\xd4\xa2\x12\x8e\x58\x03\x39\x6a\x43\x86\x32\x8c\xe4\xc5\x37\x85\x09\x8e\x32\xbe\x25\x32\x2d\x37\x4b\x6a\x2c\xe0\x3d\xc6\x3f\x9d\x78\xae\xf9\xc4\x58\xf5\x4a\xb3\x07\x5b\x0e\x27\x70\xc6\x8c\x98\x4d\x1d\x20\x2b\x3a\x6e\x3c\xd0\xb4\xb4\x8b\x00\xae\x35\x22\xa6\xf2\xf5\xf3\xf4\x12\x91\xe3\xde\x73\x79\x0c\x98\x8d\x2f\x98\x91\x54\xce\x8c\x99\x2f\xd3\x5a\x10\xeb\x01\x26\x26\x61\x7c\x2c\x6f\x8a\xbc\xe2\x59\xf8\x99\x54\xe2\x22\x66\x95\x7b\x84\x35\xd4\xe3\xb5\xaa\xd3\xfb\xa3\x17\xbb\x8e\xd8\x1f\x6f\x5b\xb9\x98\xb1\xb7\x6e\xef\x81\x14\x51\xf7\x47\xac\x3c\xee\x9e\x82\xc7\xac\x16\xff\x7a\x0f\x77\xc1\xc5\x81\x97\xd3\x41\xac\x26\xbc\xc8\xe7\x52\xb4\x31\xe0\xad\x7c\xfc\x08\x7b\xf5\x99\xc9\x9e\x26\x53\x90\xb2\xf1\x27\xb0\x57\x4b\xf2\xba\x07\x47\x55\xbe\x67\x41\xef\x3d\x18\x1a\xfc\xb6\xeb\x7e\xf6\xd6\xb7\xf2\xe9\x39\xcc\x7c\xa7\x4d\x63\x4f\xa3\x21\xcd\xcb\x9b\xf7\x2f\xf3\x93\x4e\x98\x89\x15\x17\x39\xb2\xbc\xbc\x69\x83\xbd\x11\x77\x57\xd4\xf8\x5f\x9d\x94\x5a\x47\xf1\x65\x66\xc0\x66\x75\x99\x61\x69\xdc\x73\xd1\xc3\xef\xb8\xd8\xdd\x87\x2c\x0e\x70\x68\x54\xd8\x2c\x3e\xef\x6f\x51\xfb\x57\xe6\x25\x6a\xfc\xbe\xdb\x9d\xa0\xbe\x17\x9c\x1f\x1c\xfc\xfa\xae\x4c\x65\xa2\xba\x4d\x5e\xda\x0b\xa3\xba\xba\x1a\x9e\xf7\xc6\x37\xda\xe1\x0d\xde\xfe\xaf\x65\x26\x8e\x5f\x8b\x70\xc6\xaf\x8d\x70\x46\x13\x19\xf5\xe5\xe6\x28\xfc\x3c\x21\x89\x26\xa8\xd1\x73\xe7\x79\xe7\x7d\xe7\x31\xee\x69\x8e\x75\x77\x9d\xeb\xef\x39\xbf\xd5\x1d\xe7\xda\xab\x8f\x63\x71\xf5\x71\xac\xb9\xfa\x58\x3b\xc7\xd1\x85\x57\x62\x55\xa2\x10\xcd\x80\xde\x37\x64\x8b\x4b\x23\x31\x54\xb0\xf0\xa2\x55\xe1\xa7\xe3\xfd\x8f\x90\xd3\x2c\x67\xf6\x54\x11\x99\xd8\x78\x69\x46\x4f\x45\x6e\x90\xde\xe4\xcc\x4c\xea\x5e\xa7\x74\x11\x6d\x61\x0e\x87\xef\x07\x07\x4f\x86\xe6\xe0\x7c\xeb\x27\xef\x86\x87\x8a\xc3\x7f\x61\x92\x3f\x5d\xe4\x78\x6d\xf3\xe1\xfb\xc1\xf9\xfb\xd1\xbb\xfd\xe1\xcf\xa3\x3f\x1e\x2a\x4b\x7e\x4b\x17\x3c\xde\x78\xf8\xfe\xe7\x91\x28\xac\x2a\x1a\x65\x85\x88\xbc\x4a\x4f\xbd\x53\xac\x70\xf0\x64\x50\x3c\xfc\x78\xea\x9d\x2a\xeb\x5d\x2f\xa3\x9c\x66\x1b\x2f\xa0\xaf\xd2\xd7\xcc\x48\x60\x4b\xd9\x83\x9f\xf7\x3f\xbe\xff\x39\xdb\xff\xf8\x73\xb6\xff\xc7\xc3\x8b\xbe\xe4\xbf\xb0\x35\xc4\x2c\xf7\x72\x6d\x80\xaf\x3d\x88\x82\x3b\x09\xd5\x6e\x39\x8a\xef\x1a\x9e\x54\x0e\x59\x95\xb2\xa3\x89\x64\x91\xbf\x43\x25\xa6\xa7\x09\xd0\x6d\x40\x37\x88\x58\x52\x3b\xb0\x90\xa4\x1d\xee\x45\x83\x80\x23\x26\x1d\x83\x4c\xef\x07\xf0\xe4\x06\x51\x76\xea\x9d\xb2\x62\x4f\x78\xc0\xe2\x08\x8a\x03\xea\x07\x04\x8e\x54\x51\xea\xee\x99\x0b\x77\x74\x2e\xd7\xfd\x29\x16\xf5\x32\x37\x78\x32\xff\xf9\xfa\xfc\xe7\xeb\xd1\xbb\x07\x7f\x1c\x1e\x46\x5a\x28\x78\x3c\xa0\x22\x72\x05\xd1\x90\x39\xbb\x36\x60\x43\x0c\xd8\xe8\x77\x35\x17\x1f\x71\xc0\x61\xc0\xca\xce\x61\x63\xd5\x73\xc8\xf0\xcd\x25\x7b\xdb\x3d\x78\x02\x64\x02\x47\x58\x6a\x0e\x7b\x3e\x7b\x60\xc1\x91\x7c\xe5\xb6\xea\x23\x64\xee\x9e\xcf\x86\x70\x9f\x55\xc5\xf6\x9e\xc0\x86\x11\x7a\xdd\x31\x85\xe8\x5a\x3e\x66\x04\xf7\x77\xec\x98\xdf\xbf\x0c\x8d\x87\xba\xf7\xc8\x68\x0f\xf2\x84\x67\x0a\xd8\x1b\x11\xfe\xc3\x1c\x11\xd5\x4d\xa3\xd5\xa7\xc1\x8e\xc2\x4a\x18\xb0\xf7\x47\xb2\x07\xc3\xda\x1b\x6e\x15\x0c\x06\x15\x5f\x76\x4d\xa0\xba\x67\x7d\x4c\xdb\xee\xcd\x21\x93\x82\x79\x75\x67\x3e\xeb\x5e\x10\xd4\xc0\x3f\x3c\x84\xbd\x3a\xa0\xa1\xb8\x09\x89\x0f\xc1\x47\xf0\xb7\xff\x9f\xbb\x6f\xdd\x6e\x1b\x49\xd2\xfc\x5f\x4f\x11\xee\x5d\x17\x49\x13\xbc\xc9\x52\xd9\x96\x4d\xeb\xb8\xaa\x55\xdd\x9a\xe3\xa2\xbc\xb6\x7a\x7a\x76\xd5\xda\x3e\x20\x91\x92\x20\x91\x00\x0d\x40\x12\x29\xcb\xf3\x4e\xf3\x0a\xf3\x64\x7b\x32\x32\x13\xc8\x4b\x24\x08\xaa\xec\xde\xe9\xd1\x0f\x5b\x02\x32\x23\x13\x79\x89\x8c\x8c\xcb\x17\xc9\x57\x7a\x3c\xfc\x55\xb1\x1f\x5f\xa6\x5f\x37\xd3\x20\xf2\x87\xc5\x51\x00\x2d\xa4\xd3\x42\x2b\xc3\x14\xe5\x3f\x24\xc9\x1f\x4c\xb9\xf0\x87\xe2\x23\x97\x01\x91\x7e\x4b\x44\xda\x7b\x3e\x5c\xec\x7f\x71\xe2\x36\x18\x14\x89\xbb\xa2\x1d\xd3\x4e\x9f\x89\x04\x5c\xd5\xad\x82\x80\xc0\x3a\xe1\x62\xbf\xae\x59\x07\x14\xcc\x89\x8b\xa8\x25\x3e\x2f\xf2\x8b\x80\x1f\x83\xa4\x54\xc7\x38\x0d\x79\xa7\x43\x7a\x6d\x38\x75\xfa\x6a\x4e\x50\x2b\x50\x5d\x72\xe3\xb8\x5a\xb3\xc5\x52\xbe\xaf\x7e\x06\x03\x70\x71\x4c\x65\x3a\x19\xb3\xf0\x60\x00\x2e\x70\x69\x2b\x8a\x6f\x29\x9a\xcf\xc9\x92\x27\xe9\x51\x52\xe8\xc5\x07\x03\x70\x01\x5a\x5b\xec\xb3\x43\x12\xc1\xc7\xdd\x92\x17\x05\x59\xf2\x27\xaa\x24\xa3\xfa\xf9\xc2\x2d\x39\xa7\x69\xbe\xa4\x4a\x92\x34\x5d\xac\xcf\x16\x8a\xfe\x56\x59\x3e\xf2\xc4\x24\x2d\xd2\x88\x9c\x24\x62\x96\xf8\x4d\xc2\x2e\xcb\x8b\x12\xd3\x54\x42\x77\x69\xe5\x79\x51\x62\x9e\x04\x38\xa5\x33\xf7\x23\x62\xa2\x50\x7b\x4d\x7c\x16\x31\x53\x68\x48\x25\x8a\x12\x53\x85\xf7\x22\xa2\x28\x31\x57\x45\xfa\x47\xbc\x3c\x58\x6b\x6a\x44\x4c\x96\xa1\xf9\xac\xb6\xc9\x88\x98\x2d\xa9\x91\x34\xba\xc0\x57\x3f\x31\x5b\xca\xfe\x64\x75\x60\x87\x98\xad\x22\xfd\x55\xa2\x84\x55\x85\x79\x51\x6a\xb6\xd2\x3b\x6a\x0d\xec\x10\xb3\xa5\x29\xee\xcb\x2a\xbc\x28\x31\x5b\xca\x30\x64\xf7\x95\x98\xad\x8a\x9f\x98\x45\xcd\xd9\x3a\x3b\x15\x6c\xec\x8c\x73\xea\x76\x07\x99\xf7\x22\xbf\xe0\x7f\xed\xe3\x1f\xc8\xd8\xac\xa3\x1a\x99\x5a\x1f\x95\x06\x63\xad\x21\xc1\xe0\x2c\xad\x25\xc5\x87\x51\xc3\x22\xa8\x34\xd2\xe1\xf0\x25\x0a\x2b\x7e\xee\xe7\x11\x61\xac\x90\x61\x34\x86\x51\x12\xb2\x45\x5f\xe6\x5b\xe1\xf7\xcf\xf4\x96\x65\x83\x1b\x7e\x73\xeb\x9d\xcf\x2d\xed\xce\xd1\x39\x64\x52\x75\x53\x5c\xae\x03\x88\x0b\xfe\x97\xf4\x2a\xe6\x77\x1d\xe1\xdc\x19\x66\x4c\x58\xc9\x65\xa3\xe1\xb9\x48\x14\x64\xe3\x59\x6d\xd0\x06\x48\x4b\x14\x97\xf0\x23\x61\xb3\xa4\xcd\x95\x11\xda\xa6\xae\x10\x1f\x25\x09\x20\x89\x03\xc8\x22\x57\xd8\xf7\x07\x7a\x2f\xd3\xbb\x7c\x34\xd4\x80\x57\xdd\xab\xac\x8a\x53\xe6\xe7\xb8\x2d\xd6\xf7\x5d\x20\xc2\xd5\xcc\x77\x99\xcd\x22\xc7\x32\x4c\x63\x7b\x55\x83\xd6\x1c\xd1\x0b\x34\xa7\x34\x29\xb5\x20\xb8\xb2\x10\x2b\x02\xd3\x62\x8f\x78\x9d\x15\x8a\x28\xba\x01\xa1\xb4\x30\x4b\x93\x22\x8c\x13\x5c\x28\x11\xdd\x80\x6b\x3d\x4f\x30\xc3\x53\x9c\x70\x0a\x64\x9d\xf2\xbb\x29\x55\x08\x61\x68\xe1\x83\xee\xb4\x92\x45\xaa\x99\x44\xa4\x66\xc2\x01\xdc\x00\x98\x30\x18\xc0\x95\xa2\x14\xce\x8a\x9b\x70\x4e\x13\x6c\xc7\xe7\xfc\x0a\x15\xc8\x39\x0a\x0d\xba\x1d\x97\x6e\x7a\x53\xec\xd7\x98\xb7\xfe\x54\xa3\xfa\x21\x71\x5c\x57\xc4\xc0\x41\xa9\x15\x8a\x84\xb3\x8b\x40\x7b\x42\xed\xd0\xb5\xd2\x0e\x5d\x2b\xed\x50\xe4\x37\x88\x21\xc2\x67\x04\x3d\x12\x03\x0c\x4a\xfd\xb8\xbb\x30\xf9\x50\x48\x58\x24\xaa\xc7\x1e\x68\xd9\x06\x48\xbe\xa0\xac\x44\x15\xee\xb2\xaf\xd8\x15\x76\xde\xff\x3e\x11\x83\xc2\xd7\xa5\x54\x05\xd5\xdd\x60\xd5\xc4\x58\xdf\x19\x16\x72\x59\x5c\x79\x56\xa4\xfa\xc9\x30\xf5\x0f\x0c\x24\xdf\x38\x05\x3e\xac\x57\xa8\x51\x3b\x83\xa7\x30\x1a\xd6\x24\x43\xde\x64\x36\xc3\x2f\xa8\x32\xfa\xb4\x51\x71\x37\x82\xce\xa6\xc4\x3e\xea\x47\xe8\xbb\x11\x06\xb5\x02\x7e\xdb\xe8\xac\x5b\x8f\x01\xa7\xff\x0c\x06\x30\x11\x48\x8c\xd3\x35\xe4\x9f\xb3\x06\x9e\xf5\x15\x2c\xa5\xea\xcf\x9b\x31\x24\xb1\x40\xa6\xbc\xc9\x2f\xdb\xc3\x46\x49\x41\xd0\x37\xa1\x26\x55\xb0\xfe\x13\x35\xf3\x6d\x8f\x4d\xd4\xef\x4d\xc5\xaf\x50\x8f\xda\xab\x26\xa2\xbb\xa9\x91\x46\x5e\x88\xa0\x4c\x45\x9c\xa1\x6c\x72\x68\xff\x5d\x2d\x25\x25\xcc\xe8\x69\x12\x6f\xca\x41\xb0\x81\x83\x6d\x88\x78\xd0\x78\x56\x0d\xa3\x6a\xda\x01\x8a\x5d\x6f\x70\x57\xdf\x00\xe8\xbe\x45\x43\x81\x04\xb8\x96\xe8\xa3\x1b\x0e\x1b\x8b\xf0\x89\x31\x7c\x46\x5d\x71\x6a\xc6\x39\x5c\xc4\xb7\x2c\xe1\xfb\x49\x87\x7b\xaf\xa7\x4c\x2c\x45\x1f\x5f\x27\xbe\xf2\xb1\x8c\x0f\x14\xf3\xbb\x92\xaa\xc6\x21\xec\x3f\x92\x11\x42\x8d\x89\x9d\x7c\x5c\x02\x8f\xe6\x0a\x79\xd4\xef\x32\x21\x60\x8a\xb9\x20\x9a\xac\x2b\xa0\xbd\x0d\xc2\x28\xed\x5c\x21\xa7\x90\xad\x96\x19\xcb\xd1\x5f\x08\x12\x78\x4a\x7e\x70\xe9\x49\x14\xce\xe7\xfa\x46\x31\x50\x5a\x7d\x8d\x18\xe0\xad\x61\xc1\xa5\x59\xd6\xbf\xe8\x97\x86\xd8\x57\xc3\x97\x2f\x46\xbb\x68\x48\x43\x59\x66\x27\x50\x78\xeb\xaa\x5f\x7c\x15\xe5\xf0\x62\xb4\xeb\x9b\x3f\xdc\xf5\x06\x52\xab\xc0\xf4\x51\x93\x99\xe0\x64\xd2\xdf\xe6\xdb\xab\x15\xb8\xab\xa7\xd1\x03\x68\xf3\x25\xf3\xcd\xb0\x5e\xf7\x39\xb5\xb7\xb0\x87\xb5\x23\x5e\x7b\x4f\xa7\x4a\xa1\xbd\xd6\x47\xea\xe3\xbd\xe7\xee\x92\x21\x44\x92\x83\xac\x3b\x67\xe7\xa5\x9b\x95\x2b\x16\xa5\x51\xcd\x36\x6d\x97\x9e\x2d\x07\x70\x25\xff\x77\xf7\xca\x19\xec\xe3\x2e\x12\x93\x83\x90\xb4\x1d\xb1\x75\x3a\x1b\xb1\x69\xb7\x00\xa7\x55\x3f\x42\xf3\x4a\xa1\xd4\xfa\xda\xd0\xe1\x63\x37\x61\xac\x6e\x16\x21\x74\xac\xf1\x48\xa4\x2d\x30\x32\xb0\xd6\xeb\xa9\x23\xe8\x09\x4d\x26\x0d\x85\x64\x35\x34\x0a\x60\xd8\xc7\x7f\x86\xe2\x5f\xf5\xdf\x70\x04\xac\xf0\xc8\xda\xd5\x67\x23\x4a\x4b\x39\x5b\x79\x04\x4f\x2b\x6e\xbb\x21\x52\x40\x28\x5b\x7b\x79\xd4\x34\x48\x61\xd3\xa7\xd0\x16\x50\xaa\xbf\xa2\xe9\x5a\xa6\xeb\x97\x6b\x49\xe8\xc6\x0d\x15\x2b\xc3\x3a\x5b\xcd\x58\x9e\xbb\x3e\xd9\xda\x4f\xe5\x64\x5b\x7f\x2d\xd0\x17\x5d\xe2\xc1\xe8\x03\x09\x55\x5d\x23\x82\x25\x71\xaf\xf7\x48\x39\xdc\xec\x41\xbd\xa4\x77\xad\xad\x13\x3d\x7b\xc5\xa6\x7b\x08\xda\x6c\xf6\x7e\x7a\x31\x1c\x96\x10\xbc\x7b\x3f\x61\x2e\xaf\x73\x78\x41\x6b\x09\xfc\x8b\x00\x2f\xb9\x9c\xcb\x2c\x58\x98\xe4\xc8\x79\xea\xe4\x8e\x3a\xdc\x34\x2e\x1c\xe2\x21\x2f\x98\x96\x86\x6c\x41\xf1\xaf\xf2\xc0\xb8\x3a\x43\x8c\xd3\x6b\x3f\x4e\x62\xcd\x12\x42\xbd\xd5\xcd\xd2\xef\xe1\x58\xcf\x5b\xd4\x1d\xa3\x59\x62\xb6\xa3\x73\x93\xd3\x9b\x90\xd5\x8f\xba\xef\xea\x5d\xc5\x4b\x5c\xe3\x30\x5f\xd4\x73\xa8\x70\x2e\x71\xe6\xe0\xba\xc3\xe6\xf8\xa6\x9e\x0a\x43\xfc\x35\xea\x24\xa2\x88\x6d\x10\x0d\xc1\x0e\x8f\xb9\xaa\x34\x06\x5e\x7f\x92\x4d\x04\x4b\x1a\xfc\xbe\x5e\x83\x2b\x6a\x76\x40\x6c\x4f\xa2\xd5\xeb\x06\xe2\x3f\x94\x8a\x37\x84\x8c\xbf\xd6\xc7\xe6\x12\x93\x2f\xcc\x32\x16\xe6\x4d\x86\x43\xb2\x1d\xa4\xd2\x34\x4e\x72\xd5\x67\x9b\x02\xf8\x0c\xf2\x25\xd0\xa0\x0c\x85\x52\x0c\xf9\xdb\x84\x58\x6f\x80\x73\x85\x6d\xee\x9a\x72\x83\x37\x9b\x48\xf5\x6d\x89\xc0\xac\x95\x1f\xd7\xa0\x3b\x65\x4b\xbd\xde\x59\xb3\x4b\xfb\x06\x66\x0e\x8f\xc8\xee\xb6\xf1\xcc\xda\x84\xef\x07\xc6\x66\xd2\x50\xd6\x57\x22\x95\x98\x4a\xef\xe4\x4b\xb2\xe1\xe9\x84\xee\xb1\x55\xe3\x61\x25\x06\xbf\xcf\x2c\x37\x2d\xaa\x93\xae\x95\x97\x6a\xb4\x72\xc8\xf2\x88\x14\xba\x6b\x16\x27\x66\x3a\x67\xf9\x1b\x3e\x55\x82\x07\x99\x93\xeb\x87\x9a\xe1\x70\x85\x0e\x1b\xa3\xfd\xe3\xf1\xc9\xf1\xc9\xff\xfe\x70\x38\x38\x9a\x7c\x3a\x79\x37\xf9\xe5\x10\x7e\x3b\x3c\xf9\xf3\xf1\x1f\x3f\x6d\x8e\x5a\x33\x8c\xc5\x70\x77\x99\xe6\x65\xb4\x84\x54\x07\x4f\xf3\x74\x7e\x53\x18\x5a\xf1\x38\xa7\x43\xc6\x2a\x0b\xc5\x87\xbe\xaa\x87\x79\x6e\x61\x2c\x9e\xc0\x18\xea\xdd\xb5\x56\x8e\xc7\x32\x6f\x8d\xca\xcb\xa2\x24\xfa\x8e\xb4\xf6\x5b\xfb\x82\x18\xb4\x06\x31\x7c\x1b\x47\xc3\x33\x08\x7a\x74\x5e\xc8\xeb\xcd\x99\x4e\x5f\xb9\x53\x27\xf2\x50\xcd\x64\x06\xe5\xf4\x9c\x5a\xda\xc6\x30\xce\x58\x3c\xaf\x1d\x35\x95\xa3\x8b\x8a\x49\xc2\xb1\x0b\xb0\xaf\xe2\x4a\x10\xf0\x9b\xe3\x16\x43\xa2\x3f\x19\x99\xc1\x4a\xee\x18\xc4\x39\x5c\x64\x2c\x14\xba\x03\x19\xcb\xe3\x06\x3f\xb6\xd7\x01\x4c\xf5\xbc\x59\xcf\xa0\xd7\x84\xb4\x19\x23\xd4\x88\xee\x50\x92\x55\x48\xa5\x97\x0c\xf2\x70\x21\x2b\x1b\x25\xd3\x4c\xdc\xf6\xed\x6e\x48\x5c\x60\xe1\x07\xef\x9d\x22\x09\x73\x72\x92\xe2\x32\x17\xd8\x21\x9a\x97\xd6\x9a\xf2\xba\x8b\x09\x05\xac\x02\x0e\x57\x40\x06\x7c\x10\x02\xdb\xe7\x47\x52\xdb\x66\x16\x6d\x0d\xa5\x15\x30\x5a\x3b\xf4\x01\x39\x36\xc6\xd8\x51\xb3\x55\xe7\xd9\x67\x0c\x9e\xec\xcc\x07\xd1\x17\x3e\x7e\xd1\x72\x23\x97\x48\x02\xb8\x75\x6d\x94\x98\x55\x8a\x2f\x75\x1b\x8a\x5a\x78\xee\xe9\x31\x91\x8e\x93\x4f\x22\x73\xec\xde\x6a\x0e\xd2\xd2\x01\x58\xc7\xf6\x95\x3b\xc9\xc0\xfe\xed\x68\x3e\xc3\xae\x55\xb4\xc4\x87\x30\xe7\xc0\x3c\x55\x8d\xd8\xda\xc4\x66\xab\x55\xd6\xcf\x31\xcc\x4e\x6f\xcf\xca\xa0\xa4\xd7\x22\xe9\xe7\x50\xa6\xb1\x2a\x73\x11\x26\x22\x42\xde\x21\x90\x48\x86\x49\xc1\x33\x12\x6e\xbb\xfe\x65\x85\xb7\x9c\x21\x8c\xe1\xc8\x79\x3a\x81\x31\x4c\x9c\xa7\x47\xbc\x45\xe3\xe9\x10\x06\xa2\x1f\xce\xd3\xa1\x43\x61\x48\xd2\x1d\x92\x74\x27\x92\xee\xc4\x79\xea\xd2\x9d\x90\x74\x27\x92\xae\xf9\xf4\x48\xd2\x3d\x72\x9e\xba\xe3\x70\x44\xd2\x3d\x22\xe8\x7e\xdb\x43\x48\x20\xd5\xa3\xdd\x49\x2f\xa6\x37\x62\xb3\xcb\xf2\xe0\x32\x52\xb3\x9a\xe9\x0b\x51\xa5\x6a\x44\x1d\x7b\x37\xb3\xe8\xc0\xcf\x6b\xb1\x91\x31\xd7\x4b\x23\x46\xf8\x9c\x64\x84\x98\x83\xac\x86\x09\x06\x76\x9e\x45\xb3\x97\xdb\xf1\xc8\x06\xe3\xae\xe2\x7c\x54\x64\xa9\x9e\xd3\xcf\x9c\x14\x72\xc8\xed\x79\xb1\x27\x63\xc3\xa8\xa2\xaf\x1c\x6f\xbf\x1a\x5e\x7c\xd4\x74\x8c\x77\x1f\x39\xc6\xc3\x80\xb3\xc1\xad\x8e\x1b\x19\x1f\xb5\xe1\x44\x67\x9f\x6f\xc2\xb9\x52\x23\x37\x3a\xd0\xab\xb0\x2a\x65\x48\xb0\xb3\x33\x1b\x03\x87\x0d\x88\x43\x85\x7d\x6e\x3a\x4c\x7b\xbf\xe3\x4c\x96\x77\x9d\xff\xe2\x22\x67\x6f\x93\xcc\x89\xaa\xac\x6f\x29\x74\x3e\xff\x2e\xeb\xe7\x71\xc2\xe6\x96\x6b\x48\x36\x72\xc2\xdb\xe0\x0b\xe9\xa2\xf1\x7e\xfb\xe9\xf7\x2c\xa4\xb7\xdb\x2d\xa3\xc7\x8c\x58\x9a\xd1\x3b\xb0\xf6\xb8\x78\xfc\xe8\x1d\x67\x87\xbc\x35\x29\x24\x5f\x14\xac\xe9\x38\xbe\x20\xc7\xb1\x0d\x53\x1d\x08\xba\x7e\x34\x3b\x12\x18\x4a\x46\x27\x98\xd2\xcf\x37\x1b\xdd\x10\x70\x5b\xb1\xd2\x97\x6c\xcb\xc1\x8a\xf3\x5f\x45\xfd\x06\x3b\xef\xc9\x13\x25\xe9\x7e\xfb\xcf\xd0\xf2\xda\xda\x5f\xb0\xe9\x03\xe4\x09\x85\x53\x8c\x7f\x6d\xf3\x2d\xf0\xe3\x8f\x1b\x44\xed\xb7\x52\xbe\xaf\x04\xf4\x9d\xef\x30\x00\x22\x0b\xcc\xb6\x73\x27\x02\xbb\x36\x7f\x2c\x7e\x41\xfe\x1d\xba\x9d\xb0\x8b\xb0\x88\x6f\xd9\x63\xfa\x2e\xab\xca\x79\x9b\xb0\x8b\x26\x9f\x22\xbe\x84\xdf\x29\xbe\xc3\xd7\x20\x88\x6a\x6f\xf8\x88\x8f\xf9\x3f\x2c\x4b\xb7\x5d\x76\xe2\x37\x95\x07\xe7\x3b\x7c\xce\x23\xb4\x17\x5b\x7e\x38\x6f\xa1\x3c\xa5\xe6\x8d\x4f\xa9\x97\xbf\xe7\x94\xfa\x3e\x53\x5f\x8d\xd5\x3f\xe2\x88\x52\xe3\x66\x9e\x4f\xf3\xe6\xe7\xd3\xab\x6f\x75\x3e\xf5\xcc\x03\xaa\xc1\xb8\x42\x02\x3d\xbc\x7f\x26\xce\x53\xea\x1e\xde\xc3\xfb\x67\xef\xc8\xba\x46\xf7\xf0\x62\xdb\x4b\x9c\xc7\x43\xe2\x7e\x4e\x51\x1e\xd2\x94\x27\x92\xb2\x7d\xbd\xee\x91\x57\x71\x8a\xf0\x44\x12\xb6\x2f\xd2\x3d\xf2\x2a\xde\x23\xaf\xe2\x14\xdd\x23\x82\xee\xb7\x15\xce\x31\xbe\xa7\xe9\x9a\xf5\x2d\x4d\x41\x84\x2f\xc7\xfc\x66\xda\x60\x39\xca\x04\x90\x57\x01\x14\x01\xac\xde\x9f\xac\x09\x0f\x7f\xa9\x23\x73\xdf\x84\x22\x23\x9c\xad\x3a\x43\x35\xa5\x65\x9a\x72\x53\xf1\xcb\xfe\x98\xc5\xa6\x98\x17\xce\xa6\x68\xe4\x84\x23\x82\xf1\x9f\x84\xe8\x76\x33\xf5\x05\x3d\x4e\xc2\x09\x11\xdd\xff\x29\xbe\x48\x72\x88\xe2\xf3\x73\x96\x11\x44\x43\xcc\x26\x49\x5a\x68\xd6\x68\x3d\xe8\x4d\x5d\xa3\x8c\x32\x21\xf4\x97\xf3\x9b\xbc\xbd\xae\xc7\x99\x40\xe3\x85\xca\x54\x56\x09\x2d\xee\x38\xaf\x45\x5a\xfd\xfa\x42\xfe\x40\x0c\x4f\xb6\x3d\x99\x3b\x8f\x89\x14\x6e\xcc\x0b\x14\x20\x87\x5e\xdd\x00\x37\x24\xe1\x5b\x6b\x3a\x53\xcc\x6b\xd7\x2e\x87\x2b\x80\x35\x66\xd9\xb6\xd7\x01\x2f\xb5\x82\x7d\x4c\x71\xe7\xcb\xae\x2c\xfa\x40\x83\x6e\xea\x39\xf7\x1b\xa4\xfd\xab\x52\xe5\xad\x79\xd5\xb5\x08\x40\x11\xee\x8c\x01\xac\xb4\xa0\x14\xf5\x2c\x15\x2d\xf3\x37\x98\xe6\x2f\xcc\x18\x3e\xa0\x2d\x9b\xf2\xe3\x45\x2f\x1a\x7c\xff\x4a\x16\x5c\xf9\xf3\xfb\x0d\x06\x70\x74\x78\x78\x08\x2f\xf6\x76\xa1\xbd\x33\x1c\xbe\xec\xc0\x4f\xfd\xe7\xfb\xc8\x9f\x91\x11\x0f\x05\x0c\x4c\xe9\xd6\x52\xa4\xd5\x95\xdd\x43\xd3\xd4\x7b\x61\x52\x9f\x03\x4e\x68\x9f\x4e\x83\x54\x6b\x6e\x5c\x19\xb9\xee\x56\xcc\xaa\xbf\x36\x5e\xaf\xed\xd7\x62\xe5\x6a\x90\xe5\xf6\x4e\xad\x72\x77\xdf\x5d\xc6\xb3\x4b\xc5\x48\xa7\xf1\x05\xbf\x38\x78\x95\xdf\xc8\x9e\x30\x07\xa0\x67\x71\x0b\xa3\xe0\xfb\x13\xce\x9c\xc2\xda\xa8\x0a\x4e\xaa\x17\xd2\x66\xf4\x02\x7b\xbf\x25\x32\x00\x0e\xc9\xca\x83\x69\x56\x20\x84\x7b\x23\x9b\x77\xd1\xcf\xd8\x2d\xcb\x72\x77\xdc\x40\x1a\x7a\x33\x56\x41\x9d\xf1\x75\x81\xd2\x11\x17\x75\x14\xa8\x8a\x37\x01\x1f\x67\xc6\xe1\x6b\x98\xf6\x7a\xaf\xa1\xa8\x0b\x2a\x30\x3a\x41\x0e\x01\xb9\xa7\x55\xfb\xa2\x4b\x2a\x5a\x4e\xf8\x0f\x61\x52\x70\xd2\x35\xeb\x0a\xcd\x2e\x72\xd6\xe4\x24\x6b\x31\x19\x6f\x64\xc7\xd7\xda\xb3\x0e\x1c\x40\x08\xfb\x64\xc4\xbf\xf8\x54\x4e\x65\x2a\xf2\x0d\x4e\xe1\x0d\x5c\xbd\x86\x69\x5d\xd6\x61\xe5\xbf\x31\x45\xf7\x8d\x35\xfe\x52\xeb\x79\x27\x7a\x2b\x6a\xbc\x11\x15\xfc\x3e\x19\x35\x7e\x20\x5b\x22\xa5\x0d\x06\xb0\xe2\xed\x1d\x00\x22\xe3\xf1\x9d\x26\xc5\x62\x11\x97\x26\x6d\x48\x1b\x36\x12\xef\x7d\x47\x2e\xf3\x40\xec\xd6\xf5\x2c\x10\xc7\x4a\x11\x28\xf6\xe6\x1e\xdb\x53\x9c\xa0\x2b\x6b\x32\x7a\xb6\xdb\x07\x85\xbc\xa3\xe3\xf3\xf1\x2e\xaf\x66\xbc\x27\xf9\x65\x9a\x15\x76\x0f\x05\x46\x88\xca\x79\x11\xea\x79\xe2\xd6\x7a\x2d\x08\xf3\x0a\xd5\x1e\xd3\xff\xf0\x3a\x58\x2e\x2f\xc2\x0c\xfd\xc3\xcb\x7e\x12\xdc\x64\x6a\x80\xfb\xc9\x6d\xb1\x2a\x61\xbc\x1d\xa6\x39\x95\xc9\x41\x89\xec\x40\xba\x8d\x6f\x3d\x13\xf0\xef\x76\x98\x9a\x6a\xe6\x0a\xde\xf2\x4d\x58\xc3\xbf\x04\xaa\x92\x58\x56\x57\xfe\x75\x58\x39\xdc\x5c\xbd\x86\x98\xdf\x60\x9f\x48\x77\x9b\xd7\x32\x49\xe6\xd8\x95\xc7\xd4\x4f\xaf\x87\x45\x3c\xd0\x09\xd8\x6e\xd7\x97\x0b\x95\x42\x4f\xc0\x1a\xbd\xb1\xe8\x72\xad\x90\xe4\x49\xe0\x8c\x06\x26\x11\x41\xa2\x01\x6b\x29\x83\xd4\x7c\x4d\x0f\x66\x95\xb7\x16\x9d\x8b\x24\x30\x77\x00\xbd\xde\xda\x85\x8b\x94\x1e\xc2\x94\xbc\xb9\xf2\x4b\x18\x83\x01\xfc\x9a\xce\xe7\xe9\x1d\xef\x2a\x71\x68\xbb\xe2\x19\x86\x96\x8a\x73\xbc\x3b\x04\x4c\xde\xa7\x1f\xec\xce\xc9\x7e\x17\x66\x51\x4e\x6a\xe4\xe5\x8f\xd8\x90\xf4\xf9\xee\x41\xb1\x59\x4b\x7f\xa3\xb5\xdf\xdf\x48\x89\x35\x9b\x66\x4b\xdb\x8c\xb3\x32\xfc\x59\x4f\x32\xdc\x5d\x41\x0f\xba\x6b\xce\x39\xcb\xc7\x3f\xfe\x08\x3d\xfe\xb8\x67\x3c\xb6\x49\x73\x4a\x52\x5f\x2a\x10\x1b\xd7\x64\x52\x6d\x0d\xef\x6c\x1d\x20\xcf\x5a\xb3\x86\xd6\x04\x11\x87\xc2\xef\x84\xd6\xf5\x0f\x9f\x4f\x3c\xcf\xf9\xbd\xd0\xba\x4f\xc3\x10\x9e\xe2\x0c\x5a\xb7\xe1\x9e\x7a\xde\x1b\xba\xe5\xa9\x76\x87\x9e\x76\x87\xaa\x5d\x8b\xce\x44\xb5\x3b\x71\x9f\x53\xf4\x27\x1e\xfa\x13\x45\xdf\x7a\x7e\xe4\xa1\x7f\xe4\xa1\x7f\xe4\xa1\x7f\x44\xd1\xff\xc6\x17\xea\x34\xba\x99\x37\xd6\x02\xf5\x31\x24\x49\x66\x6f\x88\x50\x68\xca\x21\xb5\x94\x6f\xbf\x1d\xff\xf1\x2f\xef\x8f\x6b\x0d\xda\xb2\xd5\xb1\xf8\xb5\xe1\x15\xfc\x73\x00\xc4\xfd\x5a\xdd\xbc\xc9\x0b\xf6\xa8\xf1\x05\xdb\xe5\xa7\x7a\x1e\x73\xbc\xeb\x58\x9e\x37\x41\x99\x35\x9c\x17\x92\xd7\x1f\xe2\x4c\x7c\xb2\xea\xcf\xf4\x54\xe6\x6b\xa1\x1a\x7d\xb2\xee\x7b\x23\x60\xb6\xb8\xa0\xcb\x7e\xae\xca\x5b\x9a\xde\x4b\xec\xb6\xdb\x2d\xdd\xd5\x92\x77\x83\xf7\x6a\x25\x7b\xb5\xda\xb2\x57\xab\xfa\xeb\x3b\xb6\xa1\x2d\x08\xce\x63\x5f\xf9\x6f\xd1\x37\xb3\x79\x1c\xc5\x61\x22\xb2\xbe\xc4\x69\xb2\x8f\xa9\xce\xf3\xf8\x22\x69\xaf\x3b\xf0\x0c\x44\x34\xc0\x0a\x06\x10\x4e\xf3\xf6\xba\xe3\x06\x6b\x0d\x06\x18\x1a\xc6\x19\xe5\xe7\x35\x20\xda\x1b\xcb\x18\xe7\x05\x6f\xc6\x90\xc1\x1b\x59\xd1\xa9\x97\x2b\xad\x8a\xfd\x62\x4d\xb9\x41\x82\x4c\xc2\x8e\x66\xfe\x55\xc0\x97\xd1\xd0\xb2\xc7\x9a\xf5\x09\xc2\x9f\xfb\x39\x3c\x73\xde\x78\x6f\x44\x6e\x73\xfa\xb8\x36\x42\xeb\x5c\x09\xd5\x57\x1b\x3e\xf7\x11\xfb\x85\x8f\xe9\xb7\x76\xe6\xf0\x31\x1a\x34\xa3\xb0\xc8\x50\xc5\x23\xee\x84\xcc\xd3\x18\x0b\x07\x1b\x23\xab\x9b\xc1\x33\x24\x01\x64\x1a\xc9\x06\x4b\x4a\x63\x97\x57\xe1\xe3\xda\x5b\x89\xad\xe9\xfa\xaf\x6d\xe5\xee\x0a\x09\x74\x49\xb5\x71\x97\x54\x1b\x77\x91\xb7\xdb\x5a\xe3\xae\x40\x17\x76\x9e\x52\x4a\x63\x8a\xee\x90\xa4\x3b\x91\x74\x6d\x3d\x70\x97\xd4\x19\x53\x74\x27\x92\xae\xad\xf1\xed\x92\x3a\xe3\x2e\xa9\x33\xa6\xe8\x1e\x11\xfd\xfd\xb6\x2b\x0f\x71\x60\x7f\xa7\xca\x78\x39\x97\x1a\x63\x7e\x77\x6a\x76\x5c\x15\xdf\x4a\x4b\xbc\xf3\x4f\xac\x25\xfe\x16\x6a\x62\xc1\xb3\xfe\x7b\xe8\x89\xe5\x6a\xd6\xdc\x78\xe3\xd2\x1b\xba\x7a\xe8\x43\x03\x27\xd4\xc7\x36\x0c\x39\x3a\x4e\x3e\x46\x41\xfc\x3d\x35\xbe\x3e\xe5\xb3\xa5\x05\x5e\xd7\xea\x7d\x21\x44\xd7\xf3\xfa\x65\xf0\x9d\x95\xac\x4d\x14\x85\xf0\x6b\x98\xa3\x33\x50\x0a\x37\x68\x2c\x45\xad\x1f\x67\x40\x09\x44\x29\xc8\x0c\x8f\x79\x03\x5d\x2c\x39\x8c\x61\x6d\xca\x82\xc7\xa9\x4c\xeb\x94\xb0\x8f\xd2\xea\x6e\xd0\xc1\xda\x2f\x95\xea\x21\xfc\x1d\x5a\x54\xb3\x49\x43\xe3\x49\x30\x46\x0f\x58\x37\x9f\x62\x4b\x09\x38\x4f\x93\x0b\x96\x09\x5d\xa0\xc8\xa7\x38\x2d\x73\x45\x49\xa5\x99\x57\x1d\x16\x42\x0f\x55\xa5\x7c\xbe\x0a\x5d\x23\x58\xea\x08\x8b\x40\x6a\x90\x5d\x5c\xed\x64\xbe\x56\x4a\xb7\x08\xb5\x1a\xba\xee\x0d\x7d\xe8\x43\x71\xac\x9d\xdf\x64\xb8\xaf\x2b\xe0\x87\xd5\x0c\x66\x61\x02\x53\x06\xf1\x45\x92\x66\x76\xa0\x62\xa5\xce\x1d\xbe\x86\x29\x9d\xe2\x20\x14\x1a\xe4\xd9\x69\xaf\x37\x3d\x2b\xd5\xb2\x5d\xa9\xc7\xed\x42\x88\xc0\x40\xa8\xbb\x23\x03\xcd\x45\xf9\xa7\x94\xbe\x8b\xb8\x22\x84\x54\x17\x56\xb3\x32\x1d\x6a\x48\x2c\x85\x6e\x77\xcd\x1e\xa5\x67\x11\xdc\x4b\x28\x59\xba\x52\xc9\x32\x94\xda\x95\xae\xd4\xae\x0c\x6d\x4a\xb8\xb1\x54\x28\x5c\x17\x46\xb0\x4c\xf3\x3c\x9e\xce\x19\x25\x2e\xfe\x0e\xe5\x0a\x19\x59\x42\xa0\xe9\xd5\x47\x97\xf8\xf2\x92\x9d\xde\x9f\xc1\x97\x69\x9a\xce\x59\x98\x3c\x08\xfa\x5f\xe1\xaf\x0a\x82\x22\x85\x59\x7a\x93\x14\xca\x4d\xad\x87\xfe\xd8\x66\x44\xc5\x3e\x3a\x9b\x04\xc2\xf5\x23\x80\x11\x3f\x04\x86\x5e\xa1\xa9\xcc\x74\x84\xb6\x76\x53\x70\xba\x6f\x1e\x80\xe2\x17\x9b\xe4\x31\xed\xee\x9e\x0a\x87\xb3\xdd\xa9\x32\x42\x48\x48\x5d\xf1\xfd\xbc\xeb\xd3\x38\x09\x33\x69\x45\xd9\x87\x2f\xf7\x16\xb4\x2e\x6e\xe2\x7b\x3d\xd5\x18\xff\x63\x0c\x4f\x9e\xdc\x57\x7f\x8c\xaa\x5f\x69\xbe\x4c\x00\xf3\x8e\x9e\x07\xd0\x52\xdd\x6a\x71\x19\x3a\x2d\x7e\x4e\xd3\x79\x00\xf7\x14\xd7\xab\xfa\xc1\x5b\xee\xc0\x3d\x09\xa8\x4b\x5d\xbd\xeb\xa3\x73\xec\xa8\x1c\x37\x76\xe7\x56\x07\xee\x77\xb1\x2f\xec\xf8\x19\x5a\xe8\xd9\x3e\x56\x47\x06\xbe\xfb\x8c\x6e\x1b\x02\x74\xa8\x3e\x94\xf9\x48\x9b\x40\xe2\xf9\xda\xbd\x2d\xd3\x23\xdc\xaa\xc0\xf2\xaa\x6d\x37\x9c\x9d\x9a\x10\x5c\x38\x12\x48\x04\xde\x62\xd6\x95\x04\x7c\xd0\x22\x5b\x05\x0f\x7d\x63\xcf\xf7\x45\xb8\x8a\x17\x37\x0b\xeb\xba\x14\x2d\xed\x30\x37\x1a\xd6\x13\xa5\xc3\x22\x85\xa1\x1b\xe4\x02\x19\xcb\x97\x6c\x56\xc4\xb7\x6c\xce\x45\x4d\x9d\x7c\xba\x88\x8b\xc2\x38\xae\x4c\xf6\x15\x2d\xcf\xe0\x8b\xe2\x5b\x7f\x34\x01\x5c\xe0\x48\x79\xd7\x0e\x79\xcb\xbf\xbd\xfb\x37\x81\xd3\x98\xc7\xb7\x66\xf6\xc3\xd3\x6c\xa1\x51\xf9\x68\x64\x49\xb4\x88\xbc\xa4\x49\xe8\xd4\x04\x36\x6f\xbb\xe3\x84\xff\x69\x59\x56\xf6\xe1\x4b\xb4\xd4\x79\x8b\xbf\x9a\x99\x8a\xa5\xae\xa2\x39\xe4\x4e\xbd\x6c\xd1\xa8\x9e\xd5\x4d\xab\x96\xce\xcd\xb1\x9e\x79\xf7\x8d\x96\x22\x31\x1f\xc5\xc9\x7d\xda\x17\x77\x4b\x44\xcb\x32\xf7\xe1\xc3\x83\x91\xcc\x91\xd3\x1f\x06\x7c\x2a\x03\x18\xed\x79\x12\x14\xa9\x60\x89\x00\xfe\xfd\xdf\x31\x9b\xaa\x1e\x21\x21\x70\x8a\x24\x6d\x42\x86\x7d\x42\xe7\x8e\x1c\xed\xd9\x79\x23\xe1\xc0\x5a\xc5\xfb\x2a\x73\x64\x23\xcd\xdb\x3f\x6a\x0b\xa3\xb8\x24\x34\x69\xd7\x72\x49\xe9\x0d\xb4\x97\xe9\x1d\xcb\x90\xe9\x8d\x86\x9d\x3e\x7c\xe2\xc5\x0d\x94\x30\x01\xfb\xf5\x96\x8f\x03\xa6\xce\xd1\xc0\xa8\xf0\xcd\x1b\xf3\xb8\xd7\x89\x5f\x57\x9b\xaa\xdc\x45\x3d\x2e\x32\x7d\x7a\xf7\xeb\xe1\xdf\x8f\x26\x27\x87\x7f\x3a\xfc\x28\xb7\xa6\xf9\x6c\xe3\x26\x3b\x3a\x17\x20\x24\xfa\x6a\xc5\xfe\x55\x39\x9d\xa4\x44\xa2\x65\x97\x56\xc8\x26\xff\xf9\x1f\x18\xb0\x7c\x2d\x10\x56\x53\xfd\xa2\x6d\xf0\x1e\xe5\xdf\xea\xdd\xe9\xd2\x14\x6a\xc9\x13\xfa\xa6\xbb\xb6\xf6\x9c\x53\xc3\xda\x6e\xd7\xde\xdd\x86\x35\x8d\xdd\x76\xed\xdb\x66\xc2\xfa\x41\x2c\x3a\x7d\x6d\x5f\x13\x73\x11\x38\x33\x11\xc0\xe8\x27\x43\x32\xe9\xd8\x87\xe9\x60\x80\x03\x39\x62\xdd\x9d\x91\x60\xf2\x2a\x8d\xd5\x75\x47\x8c\xb8\xc8\xf1\xcf\xc8\xac\x96\xf6\xc1\x7a\x00\x89\xd4\x44\x43\x6b\xc4\xb8\x20\xa4\x93\xb3\x95\xf4\x8e\x76\x20\x11\x46\x0b\x91\x6b\x55\x80\xb1\xf1\xce\xb9\x8b\xee\xe1\x01\xae\x25\x94\x85\xf1\xdc\x35\x03\x1c\x60\xca\xbc\x67\x92\x92\x42\x1a\x1c\x09\xb5\x8a\x53\x7a\xdf\xcc\x93\x55\xa7\x1b\xce\x3f\x67\x45\xbb\x97\x74\x5c\x33\x1f\xbe\x81\x89\xef\x4d\xef\xc8\x5b\x47\xbc\x39\x22\xde\x0c\x3b\xae\xd9\x53\x50\xc3\x37\x86\x61\xf5\x71\x1c\x28\xff\x7c\x13\x66\x0c\xb2\x34\x2d\x36\x85\xba\xeb\x0d\x7c\xd3\xb8\x58\xd1\x87\x8f\xbc\x0b\x78\xc3\xf8\x9c\xd5\x07\xc6\x94\x59\x07\x21\x0b\x20\x63\xcb\x60\x3b\x25\xad\x57\x29\x98\x0b\xed\xad\xfb\x42\x2a\x24\x89\x2c\x47\x4b\x18\xdb\x9f\xdd\x85\x5d\xb7\xe0\x65\x38\x3f\x77\x8e\xd2\xd6\xb0\xbf\xd7\x22\xd4\x53\x2a\xde\x64\x30\x09\x27\x03\xc5\xe3\x06\xae\xbe\x4f\x60\xf1\xc9\xdb\xcb\xc3\x03\xbf\x25\xe0\xbf\x5b\x59\xfe\xe0\x09\xda\x4c\xca\xfc\x92\x6d\x49\x46\x52\x39\x40\xb3\xe8\x3e\x28\xc7\xd5\x91\xd2\x4c\xea\x84\xdd\x1b\xfb\x51\x12\x23\xc7\x60\x79\x11\x2f\xc2\xc2\xca\x60\xce\x07\xfa\xb7\xb0\xb8\xec\x8b\x55\xde\x5d\x51\xa6\xdb\xb2\x00\xdc\x28\xd0\x99\x41\x4a\x66\x29\x1b\x0c\xe0\x43\x98\xe7\x02\xb5\xbe\xaa\x86\x10\x4f\xf2\x00\x43\xb5\x9d\xf4\xa1\x91\xb0\x97\xc2\x8f\x46\x41\x33\xe2\x59\x43\xe8\x7e\xf2\x12\x6a\x12\x7f\x93\x9f\xef\x49\x26\x69\x66\x18\x9e\xf9\xae\x80\x9c\xe3\xc9\xdb\x5a\x17\x13\xd4\x3d\x85\x1d\x85\xf7\x95\xc8\xcc\xa2\x6e\x55\x73\xd0\x12\x82\xb8\xa1\x15\x2d\x73\x9d\x76\x60\x80\x80\x98\x3d\x99\x2c\x6d\x28\xf2\xec\x3e\x15\x58\x27\x74\x0f\x37\x7c\xab\xfa\x5e\xc9\xec\xa9\x44\xf2\x75\xba\x48\x4c\xb0\xdc\x37\x53\xeb\x7a\x9c\xb1\x50\xfe\x94\x8a\x5c\x7e\xec\x27\x7d\x04\x9a\x3d\x3e\x6f\xb7\x58\xab\x23\xbf\x8f\xee\x81\xfb\x69\x99\xb3\x03\xed\x51\xf4\x76\xdb\xad\x0a\x39\x74\x65\x2e\xaf\x9a\x66\x4b\x80\xd0\x73\xd2\xb3\x00\xad\xdc\xb3\xf4\x66\x1e\x71\x09\x47\xa9\xe1\x15\x62\x52\x9c\x97\x89\xb0\x2b\xcc\x59\x64\xca\x55\x42\xec\x19\x86\x90\x46\x0e\xd9\x13\x5e\xec\x0e\x29\xcf\xc2\x9b\x9c\x41\x58\x1a\xe3\xb9\x54\x89\x4d\xb5\x57\x83\xa2\x83\x6c\xfa\x92\x25\x33\x56\xf9\x1c\x4c\xd9\x3c\xbd\x0b\xa4\x07\xb2\x46\xc4\x6e\xc4\x58\xef\x42\xc8\x34\xd3\x79\xaa\xf5\x94\xf9\xdd\x11\xf8\xa2\xcd\xfa\xc4\x04\xf2\xf5\xce\x57\x70\xb4\xf4\x6c\x23\xce\xb2\x9e\x43\x07\x0b\x52\xc0\xa2\xc8\x49\xef\x8a\x34\xe9\x7d\x0c\x97\x97\x79\x9a\x40\x5c\xb0\xcc\x93\x95\xd9\xc4\xff\xb3\xdf\x82\xd4\x92\x67\xf4\x2a\xe5\xab\x83\x73\x78\x25\x04\x15\x22\x26\xa2\xb4\xf3\x17\x01\xde\x81\x46\x22\x9a\xa9\x0e\x59\xd5\xca\x51\x5e\xf4\x67\x00\xd0\xd1\x36\x40\x2e\xa3\xa1\xda\x7c\x6b\x90\x74\xf0\xc7\xa2\x93\x61\xca\x7b\x9b\xce\xa6\x44\x6d\x27\x16\xa3\xcc\x44\x82\x76\x96\x31\xbe\x5a\xd3\x84\x59\x71\x7b\xe7\x71\x12\xce\x95\xd8\xae\x2a\xd2\x39\xf3\x64\x0b\xac\x7f\x21\x00\x55\x5f\xbd\x7a\xf5\x0a\xda\xac\xb7\xdb\x81\x5e\xef\xad\xc0\x5a\xe5\x7f\x3f\xef\x04\x90\xa7\x8a\x73\xe7\xfc\x77\x17\xd3\xd2\xcd\xa0\xae\x35\xc1\xa5\x1b\xe4\x19\x2c\x82\x59\x9a\x65\x6c\x56\xd8\x2e\x93\xce\x2c\x64\x08\x5c\xc6\x39\x73\xaf\x47\x78\x7c\xa8\x1f\x83\x39\xe5\xd0\x83\xe7\x01\x72\x85\x51\x2d\x34\xa1\x1c\xd8\xdd\xe2\xd2\x06\x04\x96\xb9\x39\xe2\x44\x66\xb2\x42\x3f\x0a\xfe\xc9\x32\x28\x70\x77\xdb\xef\xc6\x51\x4d\x33\xd8\xc5\xd1\x45\x37\x8d\x70\xb9\xcc\xd2\x70\x76\x89\x96\x88\x8a\xde\x94\xff\x12\x66\xeb\x0e\xe6\xee\x88\x93\x1b\xb4\x74\xd5\xd1\xaf\xd9\x4b\xc6\x58\x26\x98\x2a\x8f\xf7\xa4\x85\xd2\x49\xc6\x96\x28\xec\xe3\xe3\x5d\x7c\xdc\x04\x71\xf3\x58\x07\xd4\x2c\xdb\x46\xe7\xe6\x40\x1a\x05\x8a\x14\x72\x86\xfe\x50\xe5\x67\xdd\x2c\x25\xaa\x75\xdd\xc7\xc8\x16\xd8\x2a\x9c\x15\x6a\xf5\x4a\x9b\x4c\x12\x27\x2c\xc7\x79\x89\x05\x6f\x64\xf3\x35\x97\x38\x59\xb8\x21\x6d\x81\xd0\xda\xf2\x6f\x6d\x02\x17\x29\x75\x1f\x45\x00\x05\x6a\x3c\x1c\x89\x72\x27\xf0\x98\x83\xc9\x76\x0b\xc9\x87\x8a\x4e\x9f\x7d\x6e\xaf\xfc\x89\x20\x9d\x7e\x70\x99\xb9\x19\x64\x65\x43\x00\x47\x3f\xde\x22\x6c\xc6\xad\x8c\x96\x5c\x18\xda\xad\x6f\x25\x6f\x50\x86\xcf\x43\x2d\x34\x64\x63\x1c\xe5\xa3\x73\x7b\x0f\xe2\x46\x4b\x6e\xe6\xf3\x00\x86\x5f\x86\xc1\xee\x57\xbe\xe1\xf6\xf8\xaf\xcf\xbf\x06\x9a\xb9\x0a\x97\xd7\x26\xf2\x52\x0c\xe5\xcd\x24\x69\x21\xc5\xd6\x2a\x25\x92\x65\x22\xe4\x27\xf7\xa2\x42\x7e\xc5\x94\x4a\x4d\x96\x65\x17\x73\x49\x3f\xe9\x2a\xde\x35\xea\xc8\xeb\xf7\x65\x98\xbd\x2b\xda\x43\x91\xee\x72\xaf\xc1\xc6\x94\xdd\x3e\x91\xb7\x7d\xa5\x67\x12\xbb\xb4\x29\xf0\xb0\xfa\x91\xbb\x80\xdf\xe9\xbc\xbb\x60\xd4\x04\x6b\x76\x01\x63\x78\x92\xc9\x4d\x90\xc9\x4d\xb0\x09\x17\xb4\xf6\xf5\x86\xd5\xfe\x2d\x53\xfd\x6f\x1c\x85\x91\x85\xe3\x14\xc0\xa2\xa9\xf2\x22\x41\xd7\x0b\xdb\x01\x8d\x3f\xa5\x1c\xdb\x9e\x91\x8e\x6d\xcf\x48\x5c\x32\x8a\xee\x90\xa4\x3b\x94\x74\x6d\xb7\xb4\x67\xa4\x63\xdb\x33\xd2\xb1\x8d\xa2\x3b\x21\xe9\x1e\x49\xba\xb6\x0b\x1b\x45\xf7\x88\xa4\x7b\x44\x8c\xc3\xe3\x54\x2d\x3e\x65\x2f\xae\xd3\xdf\xeb\xd9\x26\x88\xa0\x27\xf6\xcd\xbc\xa1\x6b\xdb\x2c\x00\xa6\x65\x3e\x5b\x04\xb0\x9a\xbd\x0f\x60\x35\x4f\x03\x58\x5d\xc6\x01\xac\xf9\x9f\x6b\xfe\xe7\x9a\xff\x79\x4f\xe8\x4c\x30\x2d\x32\xea\xa4\x7e\x26\x13\x24\xfb\xd5\x30\x1b\x9c\xb3\xda\xd2\x6d\xee\x45\xe0\x77\x95\x83\x0e\x65\x34\xae\x3c\xe3\x02\x0b\x68\xf1\x3f\xff\x63\x48\x87\xb8\x28\x7f\xac\x2a\xa3\xc1\x86\xe0\x5a\xc7\xb5\xdc\x80\xc2\x44\x8d\x2a\x97\x8f\x11\xa9\x03\x15\xf0\x97\x4c\x68\xa6\x75\xdf\x6e\xaf\x87\x95\x70\x63\x55\x9e\xe6\xab\x99\x8a\x60\x12\xda\x51\xd9\xd1\xb5\xf4\x3f\x2f\x1f\xaf\x66\x7e\x7f\xa2\xfe\x4c\xba\xcb\x8d\xa5\xab\x9e\x27\xfb\x6b\x6d\x1c\xa7\x70\x74\x76\xfd\x1b\xdd\x41\x21\x1d\xe3\x0c\xdc\xcb\x1a\x78\x7f\xc3\x3f\xce\x2f\xb8\xe8\xdf\xe4\x01\x2c\xb6\x3b\x35\xb4\x7b\x33\xa4\xbb\xb1\x11\x09\x5b\xc6\x10\x0d\x6b\x22\x1b\xd7\x75\x79\x14\xa8\xa3\xc1\xa7\xae\xab\x8f\x42\x32\x75\x3e\x2b\x1b\x12\xa8\xab\xbd\x5c\x5b\x2f\x2d\x9f\x3a\x6d\x76\xf5\xe7\xab\xd9\x7b\xbf\x13\xd6\x1a\x5f\xd6\xb8\x61\x1d\x26\xf9\x4d\xc6\xf8\x12\x5e\xa6\x71\x52\xa0\xb3\x9d\xee\x8a\x85\x9b\x83\x37\x51\xa4\xc0\x45\x1a\xaf\x0f\x16\x2f\xf3\x06\xdb\xeb\xc0\xfd\x8c\x8c\xcf\xbc\x9f\x05\x32\xda\xf2\x7d\x20\xbb\x2d\x18\x18\xfe\x1a\xbb\x9d\x93\x4a\xca\x58\xb8\xf5\x95\xa2\x3f\xf6\xeb\x2e\x2e\x2e\x29\x4c\x6f\x1d\xcb\xfb\x3d\x3a\x52\xbd\x0f\x44\x87\x4e\xcf\x5e\x43\xdc\xeb\xbd\x86\x7b\x23\x2b\x99\x51\x5b\xa6\xe3\x76\x9d\xa9\x14\x03\x85\x31\x7c\xfa\x5f\x1f\x4f\x28\xb4\xd4\xaa\xe5\xf5\xec\xfd\x6b\xe8\xf5\x30\x47\xdb\x90\x56\x58\xcc\xe8\xb5\xb7\xc6\x68\x9d\x35\x86\x40\x3e\x2d\x1b\x25\xca\x5d\xc6\x65\xb9\x41\xd5\xb9\x07\x52\xcf\x52\x41\xf5\xe3\xc8\x8b\xcc\x52\x5d\xb8\x16\x01\x9d\xb1\x5f\xa3\xb2\xc2\xde\xa0\x73\xda\x75\x7d\x7f\xb0\xf4\xa5\x18\xf5\xd3\x6b\xb7\x4f\x54\x79\x2e\x05\xf2\xef\x78\x86\xed\x74\xb1\xfe\x33\x3e\x02\x1e\xf2\x62\x68\xe6\x69\x59\xa1\x0d\x6d\x58\x68\xdd\x42\x28\x5b\xed\x8f\x2e\xdc\x8b\x68\x50\x20\x7c\x27\xd5\x24\xb4\x91\x98\x48\x7a\x2f\xec\xcc\x48\x79\x61\x7d\x02\x3e\x96\xbd\xbd\xf4\xe4\x2b\xe1\xad\x09\x2c\x7c\x4e\xf2\x29\x92\x6c\xa4\xf7\x14\xdd\x1c\xdb\xdd\x24\xfc\x5a\x66\xd4\x54\x75\xbb\xb6\x83\x9e\x8f\x3d\xde\x97\x71\xa6\x8d\x8c\xe9\x86\x7b\x1d\xdf\xbd\x5b\x7a\xd7\x7d\x5f\x1f\x99\x6d\xd2\xdf\xe2\x81\x6f\x3a\x16\xc4\xe7\x90\x2d\xd0\xd8\xbd\xc1\x19\x26\x8f\x34\x37\x96\x4f\x4e\x8b\x9a\x2f\xcb\xe8\x1f\xea\x10\xa3\x72\x45\xb7\x3b\x50\x79\x00\x5a\x86\xef\x3c\xb2\x2c\xe5\x64\x25\xc7\xbe\x5e\x57\x6d\x5b\x7f\x18\x6f\xd5\xe6\x2e\x31\x8a\x84\x29\x36\x8b\x94\xc1\xdb\x79\xc5\xe8\x05\xd1\x51\x32\x8f\x74\xa7\x18\xc3\x4d\x85\xd3\x1f\x29\xaf\x98\x97\x81\x9e\x73\x1c\xed\x6e\x58\x69\x9f\x53\x70\x58\x5c\xb6\x10\x59\xd3\x7c\xa4\x35\x0f\x98\x97\x8d\x3d\x60\x48\xdf\x83\x3c\x82\x03\xcd\x35\xa7\x1c\x93\xfd\x6d\x5d\x61\x72\x61\x23\xc8\xd8\x32\x63\x39\x4b\x0a\x12\x17\x58\x07\x3a\x4b\x48\xcf\x03\x2e\x2f\xe8\xf4\xcb\xac\x3b\xb8\x2d\xcd\x0f\x2b\x52\x88\x96\x70\x1e\xaf\x58\xe4\xcf\x12\xf6\x5f\xdf\x31\xcd\xb2\x93\x6d\xef\x69\xb6\x81\xc0\x26\x0f\x37\xbb\xfa\xf6\x1b\xb4\xae\xfe\x36\xbb\x54\xa3\xd3\xc8\x81\x4d\x81\x72\x62\xc6\xf9\x36\x79\x0d\x8d\x96\xba\x5b\xb0\xd7\x69\xed\x15\xee\x1b\xe9\x98\x36\xe2\xab\x1f\x15\x7e\x7c\x9f\xf1\x77\xdf\x7d\x2b\xe0\x22\xee\xa1\x08\x5d\x6d\x05\x35\x90\x7a\x23\xfe\x35\xff\xed\x4f\xae\x49\x5a\xb0\x7d\x08\x73\x21\x2b\xff\x4b\x78\x1b\x7e\x9a\x65\xf1\xb2\x68\xe5\xca\x3d\xb7\x58\x2f\x59\x00\xed\xde\xb0\xd3\x2f\xd2\x5f\x79\xa7\xb8\x50\x1c\xe7\xd0\x1a\xb6\x0c\x77\x92\xe9\x4d\x21\xb2\x55\xb6\x7b\x68\x0e\x1a\x8e\x9c\x1a\xbd\x61\xeb\x9f\x6c\xdb\x8a\xee\x3f\x6a\xc3\x7a\xaa\x6e\xde\xaa\xaa\xe2\xf6\x9b\x94\xae\xb9\xcd\xf6\x44\x0a\x8f\xde\x98\x0d\xb7\xe2\x8e\xeb\xbf\x75\xe0\x7a\x8c\x1a\x3b\x74\x67\xf8\xff\x75\x87\x32\xe3\xc0\x92\xbb\x70\xe1\x6e\x3b\xb1\x75\xcd\x19\x17\xde\x9b\x62\x9c\x0a\xdb\xdd\x8a\xf7\x68\x99\xa5\x4b\x96\x15\xb1\xe9\x1f\x2a\x9d\x5a\x7e\x3d\xfe\xf8\xdb\xbb\x13\x48\xa7\x57\x6c\x56\x40\x3b\x67\x4c\x0b\x2d\x99\xa5\xc9\x79\x7c\xd1\xf1\xad\x5f\x59\x77\xac\xcf\xdc\x33\xf1\x9f\xec\xe2\x27\xb6\x0c\xb3\xb0\x48\x33\xd8\x87\x56\xdf\xdc\xcf\xf8\x73\x91\xa5\x37\x4b\xa3\x54\xe0\x2d\x15\xdf\x33\xd8\x87\xe7\xee\xeb\x9c\xcd\x52\xb4\x4c\xfe\x49\x2b\x37\x74\xcb\x9d\x67\x21\x2e\xba\x3f\x39\x8d\xfe\x6d\xf5\x6e\xd8\x0a\x40\xa2\xcf\xa4\x49\x0f\x95\xf9\x7c\x0c\xf3\x65\x38\x63\x1b\x28\xc9\x06\xf5\x52\x5f\x5f\xff\x93\xf1\x21\xb1\xcd\x1e\xc7\x88\x3c\x75\x1b\x70\x22\x55\xf3\x11\xac\x88\xae\xba\x15\x2f\x42\x12\x8d\xdd\xdc\xf3\x02\x01\xfd\x1f\xc3\x8f\x46\xdb\xf3\x23\xd7\x3f\x40\x98\x6d\x05\xde\x32\x75\x05\x17\xd0\xa5\xa4\x56\x20\xcc\x78\xd7\xf3\x22\xeb\xe7\xcb\x79\x5c\xb4\x5b\xfd\x56\x87\x2e\x79\x31\x82\x31\x74\xc5\xc6\xee\x97\xdb\xce\x53\x76\x47\x2b\xeb\xee\x41\x4f\x25\x73\xef\x8d\xc1\x68\x4b\x3d\xa7\xeb\xc6\x49\xf1\x21\x44\xbf\xcf\x30\xcb\x4e\x87\x67\x74\x29\xb5\x37\xb5\xa2\x23\x4f\x51\x85\xd3\x5d\xc1\x70\x7b\x1b\x2e\x6f\x7f\xa2\xce\x81\xea\x4c\x65\x1e\xdd\x57\x8f\x68\x1a\x73\xc6\x6f\x84\x25\x25\x5a\x1b\x0a\x72\x9e\x2f\x76\x3a\xa8\xc5\xbb\x18\x05\x62\x4a\x2e\x76\x02\x31\xde\x71\x80\x94\x7a\xae\xb2\x52\xd5\xe5\x15\xde\x0a\x3f\x4d\x5e\xb2\x2e\x84\x98\x37\xc1\xcb\x3c\xe5\x75\x1e\x1e\xe0\xc2\x63\xfe\xae\x06\xbe\xea\x7f\x7e\x33\xcd\x8b\x0c\xfd\x84\x62\xaf\xdb\x81\xf2\x98\x8a\xe1\x0d\x6f\x88\xff\xd2\xe5\x5f\x55\xab\xb4\x57\xad\xf1\x92\xe6\x6a\xe9\x12\xed\xc7\x38\x42\x1e\xd3\xad\xc7\x64\x2b\x86\x69\x47\x8e\x4d\xc3\xf6\x70\x9e\x63\x4f\x43\x9c\x22\xae\x8c\x8e\x36\x58\xad\x5e\x4b\x90\xe0\x7f\x37\xd2\xc2\x49\x1e\xa3\xad\x60\xa2\xb5\x83\xaa\xc7\x6a\xf7\x38\xc7\xad\xd0\x4c\x1a\x3b\xd4\x3d\xb3\xe8\xf4\xe7\x07\x46\xfb\xfd\x8c\x21\x3b\x17\x29\x4a\x3e\xb2\x8b\xc3\xd5\xb2\x0d\xad\xbf\xfd\x2d\xfa\xc2\x3f\xee\x62\x07\xba\xd0\xfa\xfa\xb7\xbf\xfd\xdc\x0a\xa0\x75\xd1\x02\x0f\x5f\x01\x68\xfd\xcf\x1f\x5b\x55\x87\x3d\x47\x31\xdd\xa3\x7d\x73\x4f\x53\x85\xf6\xe9\x61\xa6\x95\x8a\x79\x91\x3d\x4a\xd6\x13\x5a\xff\xc6\x12\x5f\x98\xf3\xaa\xf1\x62\x39\x67\xe5\x07\xe0\x3d\x48\x6f\xa3\x3a\xe7\xf8\x85\x88\x89\x61\x40\x30\xbf\xea\x45\xc4\x92\x74\x11\x27\xfc\x95\x40\xe5\xd2\x1e\x94\xae\x1d\x21\x2c\xd3\x3c\x2e\xe2\x5b\x33\x87\x8d\x84\x70\x90\x9d\xf4\xe3\xc2\xe7\x4b\x36\x8b\xcf\x63\x16\x95\x9a\x4e\xa3\xd5\xa3\xf3\x4a\x07\xaa\xd3\xd7\x7b\x12\x0b\x71\xa1\xa4\x24\x22\x74\xa8\xbe\x8a\x60\xfb\x3b\x96\x17\xb2\x5f\x09\x9b\xb1\x3c\x0f\xb3\x35\x14\xa9\xa1\xba\x51\x63\xad\x07\x74\xa2\x97\x8c\xe1\x9f\x67\x4a\x58\x8b\x4a\x59\xfa\x20\x66\xee\xa1\x9c\x94\x32\x5e\x09\x83\x3a\x71\xa0\xdf\x54\xb6\x56\x1c\x5c\xea\xfb\x6b\x04\x27\x39\xb1\xed\x0e\xaf\x68\x7c\xad\x23\xc6\x2c\x5c\x95\x66\x4d\x75\x4b\x94\xb1\x2a\x5b\xa2\x8c\x5a\x5e\xba\x30\xb3\x88\x28\x31\x26\xcc\xb2\x00\xa2\x61\x00\xd1\x0e\x9a\xf6\xd9\x6a\x89\x61\x12\xc9\x30\xf0\xc0\xae\x5d\xc3\x58\x06\x5f\x7d\x1b\xd3\x7d\xe4\x68\x46\x8f\x27\x87\x04\xdf\x48\xf8\xc1\x17\x0d\x1b\x96\x8e\x78\xe9\x84\x2e\x4d\x49\x52\x8b\xa8\x14\xdd\xa8\xc3\x48\x46\x9b\x8d\x45\xb0\x99\xcb\xbc\x5d\xf5\xee\x22\x22\xce\x86\x92\xcc\xb5\xef\xb4\x7e\x22\xcc\x62\x89\x48\xf6\xd2\xee\x40\x07\xe1\xa9\xfa\xf3\x02\xbb\x5e\x0f\xba\xab\x62\xcd\xfd\x87\xa9\x8c\x42\xdf\xd9\xf1\xfb\xd8\x02\xb4\xec\xb5\xd7\xc2\x03\xe4\x1a\x0e\xa0\xa5\x2f\xc3\x16\xbf\x2b\x99\xcb\x9a\x73\x7c\x3e\x96\xdb\x1d\xc0\x83\x81\x1d\xce\xb7\xef\x2b\x77\x74\xce\xc9\x1b\xb9\x81\xd2\xa4\x17\x6b\xbb\x58\x6a\xaf\x41\xa4\x59\xd7\xf8\x26\xdf\xdd\x37\x39\x03\x9f\x63\xd9\x82\xaf\xc4\x27\xd7\xd2\xb1\x8d\xff\x57\x69\xb1\x13\x15\x56\x3a\x82\x4e\xff\xa2\x60\x62\x32\x0e\x20\x91\x62\xfa\x96\x88\xe0\xa5\xd3\x42\x05\x06\xdf\x2f\x94\xeb\xb5\x6d\x14\x70\xa2\x44\x56\xb3\x5a\x14\xf0\x58\x06\xd2\xd0\x1c\x4b\x94\x96\x43\x88\x41\xa1\x22\x26\xb4\xf4\x39\x59\xc4\x09\x32\x3c\x7b\x11\x14\x97\x61\xc5\xcd\x75\x53\x99\xcb\x80\xa5\x93\x41\x84\xfe\x0c\x79\x05\x33\xb0\xea\x33\x17\x6c\x20\x92\x69\x62\xe0\xc3\xf1\x5f\x3f\xfd\xfd\xe4\x70\x72\x0a\x6d\xce\x86\xd0\x97\xff\xa9\xee\x99\x20\xa2\xf2\x34\x50\x02\x5e\x6a\x1f\xff\xb5\xbc\x2a\xc4\x54\x2e\x22\xb1\x77\x66\x8b\x65\x3b\xc2\x0c\x60\x08\x38\xcf\xe4\x6f\x11\x9f\xbb\x91\xb2\x4c\x98\xbd\xc7\xe6\x25\xe8\x87\x49\x5a\x21\x81\xc8\x60\x17\x17\x38\xc1\x64\x03\x4e\xe0\xf3\x60\x20\xd8\x12\x32\x28\x13\x6c\x24\x19\xaa\xa1\xb0\x6d\xe6\x7a\xa8\x41\x1d\x40\x60\x12\x40\xe4\xe6\x17\x2c\x47\x7a\x07\x39\xa8\x8c\x34\x50\x48\x80\xd1\x88\xc4\xdb\x11\x01\xda\x3b\x38\x78\xfc\xe8\xc0\xe8\x1e\x6f\x16\xf6\x48\x7c\x12\xf1\x02\xb9\xf6\x0e\xc1\x31\x05\x83\xb6\x3a\x23\xfa\x88\xb3\x42\xf4\x49\x0c\x1c\x41\x0c\xcf\x10\x1b\xe2\x50\x7e\xaf\x87\x14\x41\xc9\xda\xa4\xa2\x3a\x1f\xd6\x45\x24\x69\x47\xc3\x4e\x00\xd1\x88\x1e\x62\x71\xda\xa8\x2f\x8a\x76\x64\x37\x12\x77\x7c\xc5\x68\x39\x25\x89\x99\x48\x86\xc2\xf5\x6a\xd4\xcf\x81\xf0\xb4\x61\xf0\x6c\x0c\x3b\x9b\x53\x02\x94\xf2\x66\x9c\xc3\x6c\x9e\xe6\x02\xf3\x65\xc5\x8f\xf9\x41\x84\x89\xa1\x92\xd1\x20\x1a\x19\x64\x84\x96\x40\x2c\xab\x91\xf8\x6a\xe6\xe4\x03\x95\xe3\xb2\xea\xf4\xc3\x69\xde\xee\xe0\x6a\x21\x98\xab\xa0\x32\x14\x92\xc6\x46\x2a\xb8\xd5\x47\x9e\xdb\xc8\x29\x1f\x8c\x8a\x57\xf2\x8e\x69\x7f\xc2\x99\xe7\xca\x70\xca\x87\xd2\xa8\x36\x34\xaa\x59\x63\x58\xed\x72\xb6\x5a\x92\x66\xce\x30\xdb\xea\xd6\x50\x77\x33\x98\xa5\xc9\x2d\xcb\x0a\xe5\x5b\x20\xe5\xda\x65\x16\x2f\x50\x80\xf7\xfa\x6f\xa6\xb2\x7e\x13\x3c\x4c\x02\x28\xb7\xf2\xb5\xc2\x2b\xc1\x65\x98\xab\x68\x17\xf4\x62\x20\xc1\xa3\xbb\x2b\xce\x52\x45\xae\xf8\x03\xfc\xf7\x19\x86\x49\xcb\xe4\x24\xcd\xc7\x23\x7c\xa4\x13\x06\x97\x5f\x4a\x70\x02\x71\x7c\x25\x86\x2e\xf4\xe8\x1c\x12\x3d\x79\x9b\x94\x06\x1e\x1d\x75\xcc\x09\x7e\x38\xfe\xeb\xdf\x3f\x7c\x3c\xfc\xe5\xe8\xd3\xd1\xf1\x44\x5d\x6c\x86\x4a\xd0\x28\x52\xab\x00\x61\x59\xf6\x5d\x19\x12\x0a\x39\xe1\xd5\x70\xf8\x62\xf4\xea\xd5\xce\xde\xee\x8b\xdd\xe1\xab\x57\x3b\xbc\x05\xe7\x19\xad\x09\x6e\x7f\x60\xd9\x79\x9a\x2d\x72\xd8\xdb\x85\x79\x9a\x2e\xab\xc0\x97\x1c\x4f\x11\xcc\x57\x6a\x13\xeb\x77\x7c\x37\x9a\x65\x7a\xd7\xee\x54\x11\x5d\xce\x1d\x26\xb1\xae\x30\x56\x79\xeb\xd2\x92\xd4\xdc\x59\x3e\xe0\x5c\x8e\xe1\x43\x7f\x99\xde\x19\x4b\x3a\xa1\xd6\xf4\x75\x00\x44\x32\xa6\x18\xc6\xb0\x08\x8b\x4b\x01\x16\x2c\xd3\x73\x1f\x40\x8f\x8b\x69\xdd\x84\xd2\x46\xf8\xf7\x06\xc6\x07\x6b\x5e\xa9\x2a\x50\x98\x77\x2f\x3e\xaf\xbe\xd1\x02\xa7\xa0\x70\xa0\x75\x4d\x70\xd2\x10\x8e\x61\xe7\x79\x00\x2d\xd5\x48\x0b\x3a\xf0\xe3\x8f\x56\xe7\x91\xb0\x48\x70\xc9\xc7\xe8\xe1\x01\x62\x0a\xe9\x00\x03\xb4\x13\x18\x88\x60\x61\x02\x0b\x65\x19\x66\x39\xfb\x75\x9e\x86\x05\x27\xc3\x6f\x41\xe8\x1b\xdc\x16\xde\xf5\x7c\x63\xfb\xf0\x57\xc8\xe0\x70\x35\x48\x6d\xe8\xf2\x03\xc6\x3d\x7e\xdd\x78\x57\x19\x0c\xc2\x77\x0d\x0b\x67\x97\x42\xdc\x8d\x67\x31\x66\x2d\x40\x2d\x0b\x32\x46\x29\x47\xa6\xe7\x70\x2d\xa3\x5b\xb1\xb4\x82\x11\x9e\x09\x0b\x1a\xfb\x7c\x13\x16\x2c\xb7\xdb\xe0\x2c\xa3\x6a\x86\x70\xd3\x72\xb6\x71\x17\x4e\x77\x5e\x06\xb0\x3b\x3a\x0b\x04\x5e\xb1\x88\xaa\x29\x35\x2c\x76\x0b\x4a\x70\x4e\xcf\x61\xe7\x25\x5c\xdc\x84\x59\xa4\x68\x67\xac\x08\xe3\x84\x45\x7d\x68\xff\x05\x99\x43\x17\x46\xfd\x3d\x19\x27\x7b\xc1\xb9\xd4\xe9\xab\x00\x76\x46\x67\x46\xb5\xbe\xa9\xda\xba\x16\x32\xb2\xd6\xc3\x03\x5c\xec\x33\x16\xcf\xdb\xd6\x9b\x81\x2e\x26\xef\xa0\x8c\xbb\x31\xe5\x18\x71\x35\x36\x43\x5c\x69\x19\x31\x16\x71\xe1\x3e\x0f\x70\x74\xb8\x16\xf2\x8d\x2f\xa2\xa6\x82\x23\xf7\xca\x97\x65\x31\xbc\x9e\xad\xab\x84\xa5\x6f\xe1\x1a\x3a\xfa\x03\xbc\x5b\xdb\x55\x89\x7b\xa7\xc5\x2a\x62\x11\xf2\xee\x91\x83\x9f\xc4\x55\xd7\x48\x16\xb2\xaa\xf9\xc4\xaa\xdf\x12\x6a\x7d\x65\x77\x7f\x55\xd3\x7d\xea\xe6\x98\x48\x64\x49\x3e\xb8\xc7\x93\xc3\x3e\x17\xaf\x6c\x94\x5c\xb9\x39\xaf\x2b\x67\xac\x75\x60\x2e\x12\x47\x0c\x83\x7d\xdd\x73\xfc\x7b\x58\xbd\x35\x1f\x4a\xd2\x57\x52\x6f\x84\x76\x3e\x71\x8c\xe0\xa8\x8c\xcc\x23\x37\x25\xa8\x8d\xf7\x66\x1c\xbb\x9a\x82\xd1\xd2\x2a\xda\x29\xe9\xab\xcf\xf1\x98\xec\x65\xc8\x9d\x11\xeb\xfe\x6c\x13\x06\xce\x3f\x8b\x3f\xe7\x07\x0d\x4c\x71\x3b\xef\x4c\xba\xe6\x66\x67\x50\xbd\xde\xf6\x76\x60\x7f\xed\x6d\x4c\xc1\x1f\x34\xf8\xca\xcd\xee\x9d\xa4\x6b\x4a\x1e\xf9\x4c\xc1\xba\x13\xe7\xce\xae\xe5\xc4\x69\x31\x8f\x03\xe9\xcb\x69\x1a\x83\x77\xff\x01\xce\x29\xe8\x7c\x3e\x45\x57\x2f\xfc\x75\x84\x81\x30\x53\x88\x4d\xaf\x11\xe9\xee\x25\x0c\x02\x58\x30\xce\x75\x95\x3f\xae\x31\x11\x2e\x2e\xa8\x04\xcd\xe4\x71\xe3\x33\x9c\xed\x5e\x35\x65\x59\x18\x84\x0e\xcb\xf8\x96\xcb\x30\xd7\x8c\x21\xe5\xbe\xd4\x1b\x40\xcd\x56\x9c\x57\x16\x90\x34\x33\x13\xbb\x9f\x1c\xf3\xcb\xe0\xdf\x3f\x1c\x7f\xc2\x01\x09\xab\xcb\x45\x29\x05\xea\x75\x4b\x3e\xa4\x37\x22\x69\x4c\x0e\xff\x14\xa8\x15\xb3\x15\x8f\x98\x9e\x11\x57\x05\xbc\x1a\xfc\xb4\xdb\x68\x2b\x97\x77\x5d\x1c\x3b\x67\x33\x4d\x9d\xbd\x64\x56\xb0\xf6\xcf\xb4\x66\xfb\x48\x70\x0f\x7d\xef\x4c\x3d\x2e\x14\x84\x9a\xdf\x6b\x42\xc8\x05\x76\x02\x8d\xb5\x94\xf4\x19\x15\xad\x63\xe4\x6d\x21\x02\xf9\x18\x22\x63\x94\x6a\x7f\xf2\xec\xce\x7d\xb2\x8d\x30\xcf\xb6\x54\x2b\x04\x00\x0f\xe8\xc0\x23\xfc\xc4\x96\x55\xd0\x12\x6c\xd8\x1d\xd5\x4f\x6d\x1c\x99\xac\x3d\x09\x27\x44\x5b\x96\xc2\xd9\x47\x47\xd0\xb0\xc0\x3e\x12\x2e\x7b\xf9\x4c\x12\x53\xaf\xd3\xf8\x34\x80\x9d\x00\x7e\xda\x0d\x60\x67\x2f\x80\x16\x5f\x27\x2d\xcf\x5d\xa1\x6a\x9a\xc1\x9b\xb1\xb6\x1b\x04\xb4\xd0\xdb\xb1\xb6\xc9\xc8\xca\x9c\x19\x9a\x7e\xc1\xb8\x7e\xc0\x67\xb7\x06\xd8\x07\xe9\x60\x88\xc0\xde\x55\xf1\x47\x0d\xba\xd4\xd1\xfc\x1c\xe6\xac\xed\xa1\x1b\xc0\x94\xf3\xea\x00\xb9\x5c\x4e\x67\x09\xa5\x47\xb8\x44\xd2\x4a\x14\xe8\x4d\xed\x3a\xf9\x46\x66\xec\xc7\x47\x1f\xcb\xd8\x7d\xa9\xaf\xba\xbb\x4c\xe7\xa6\x95\xd9\x41\xa2\x36\xf8\x43\x59\x7b\xac\xfe\x6a\x92\x5c\x5e\xd9\x62\xdc\x18\x8a\xc0\xc0\xfd\x1c\x39\x87\xe3\x86\x71\xe0\x37\x3f\xb1\x0f\x02\x74\x2a\x8e\x52\xc1\x1c\x67\x33\xb6\x2c\xd4\x51\xa3\x70\x11\x7d\x1f\x85\x43\x75\x7c\x2e\x3e\x29\xfd\x97\x4f\xc7\x93\xc6\xf9\xfe\x29\xbb\x8f\x39\x7d\x03\x78\x37\x8f\xc3\x9c\x09\x0d\xce\xcf\xf1\x85\xf2\x13\x5c\xb0\xe2\x32\x8d\xb4\xd8\x84\xc1\x40\xe5\x29\x11\x89\x4b\x5e\x83\x46\x44\xbc\x12\x27\x32\x8b\x20\x9c\xa6\x9a\x73\x00\xaf\x59\xe6\x7f\x1c\xab\x54\xd9\xaf\x55\xcd\xfc\x66\x5a\x57\x53\x5e\xc1\xd7\xe2\xfb\xf9\x4d\xa8\xac\xb9\xb8\x99\xd7\xd5\x8c\xe2\xdb\x38\x62\x58\x2f\x8a\x6f\x5f\x1b\xef\x32\xb6\x08\xe3\x24\x92\x6a\xa1\x45\x1a\x99\xaf\x65\x2a\x78\x99\x5f\x7e\xb6\x58\x9a\xaf\x45\xd6\x20\x95\x34\x48\x1f\x50\x09\x9b\x94\x9c\xc7\x17\xc7\xd3\x2b\xcd\xee\x6b\xbb\xba\xb6\xcb\x42\x3a\x73\x94\x93\x57\x16\x16\xcd\x7e\x95\x0d\xf0\x8f\xfe\x78\xf4\xaf\xef\x4e\x0e\xe1\xcf\x87\xef\x3f\x1c\x7e\x84\x5f\xff\x32\xf9\xe5\xe4\xe8\x78\xf2\x49\x96\x28\x97\x45\x19\x67\x6b\x68\xb8\xd0\x71\x8f\x9f\x68\x66\x84\x8d\x52\xb6\xa0\xf1\xea\xe1\x01\xd1\x70\xc6\x10\xc3\x01\xc4\xb0\x0f\x71\x65\x57\xd3\x3a\x52\x6e\x75\x57\xa1\x22\xbc\x51\xc4\x41\x9d\x9e\x97\x32\x9e\xbc\x70\x98\xfd\x34\x0f\x8b\xd0\xee\x6c\x1e\xc0\xbd\x79\x28\xf3\xee\x8f\xcc\x47\x57\x30\x86\x50\x5e\x72\xcd\x37\x7c\x76\x43\xce\xf5\xba\xd0\x6a\x69\xc3\xac\x3b\x8b\x5d\xb9\x11\xa1\x39\x56\xc3\xf4\xa2\xa2\xa2\xfe\xf2\x1e\xc6\x95\x02\xa4\x07\x39\x19\x89\xac\x1a\xb8\xef\xf5\x5e\x23\xb9\xd6\x10\xd9\xad\xcd\xb9\x33\xe8\x1a\xb9\xba\xbe\x1a\x5b\xb3\x32\xb5\x98\xa8\xe6\x7d\xeb\x43\xae\x10\xb4\x4c\xf6\x03\x32\x44\x4e\xf9\x25\x8d\xd8\xbb\xa2\xdd\xeb\x5d\x09\x84\xae\xdd\x97\xaf\xf5\xc6\x15\xe7\xd3\x30\xb8\xae\xd0\x35\xf4\xe1\xa1\x62\x73\xda\x74\xff\x22\x36\x84\xc9\xbb\xcb\x65\x9a\x9b\x59\x21\xb5\xd9\xc5\x5a\x22\xbb\x18\xd8\x93\x1b\x06\x30\x35\xe7\x8b\xf6\xe4\x50\xd9\x71\xdc\x85\xe0\xc0\x63\x5e\x09\x44\x81\xc0\x51\x6e\x39\x78\x99\x73\x11\xad\xff\xda\x18\x70\x2a\x8b\x91\x52\xd2\x70\x01\xe5\xca\xc6\xbd\x2f\x4b\x89\xd4\x20\x15\x32\x42\x35\xd2\x22\x33\x48\x05\x8e\x40\xb6\x68\xa2\x69\xca\x34\x1f\x0f\x0f\xa0\xa5\x4c\x0a\xe1\x00\xa6\x12\x39\xb6\x77\xc5\xf7\xa5\x49\x89\x4e\x97\x24\xd5\x68\x4f\xc6\xa0\xf5\x3d\xb6\x3a\xce\xb7\xc1\xd0\xec\xf1\x35\x17\xcc\xe6\x64\x5f\xdd\x74\xf4\xde\x3c\x42\xaa\xbf\xfc\xdd\xff\xc5\x2f\x18\xf1\xde\x8f\x4c\xba\x6a\x6d\x11\x69\xb1\x05\x65\x6d\x14\xae\xe1\x2d\xcc\x7d\xb4\x44\x82\xea\x6b\x22\x2f\xf5\xdc\x4a\x85\x7c\x00\xd7\xb0\x6f\x7f\x9f\xea\x87\x2f\x0f\x76\x15\xf2\x3e\x2c\x59\x47\x8c\xc9\xaa\x55\x3a\xe0\x58\x65\xa5\x8e\xcf\xf4\x5c\xfc\xfc\xcf\xb7\xf2\xf1\xe6\x61\x10\x9d\xd4\x06\xa1\xfc\x74\x3e\x25\x72\x44\xa9\x71\x00\x7d\xcb\x4a\x79\xa4\x32\x12\x66\x37\x4c\x80\x6d\xa3\x77\xc6\x2d\x17\xb4\x95\x1e\x2b\x4e\xc4\xdd\x2b\xa8\xe0\xaa\x85\xab\x4c\x5f\x11\xf9\x0b\x7f\xc2\xaf\xa7\x0a\x72\x1a\xeb\x0b\xa5\x38\x66\xc9\xb5\x7c\x6c\xca\x8a\x22\x2a\x0b\xcd\x00\x5c\xac\x6f\x8d\x58\x77\xd4\x92\x16\x7f\x2e\x11\x69\x06\x02\xfd\x9d\x42\xc2\x90\x82\x50\xc9\x50\xe2\xa4\xf8\x57\xd1\x72\x9a\x4d\xd2\xc3\x2c\x4b\xb3\x1c\xed\x1e\x8b\x98\xff\x13\xae\x0c\x26\x23\x07\x4e\x58\x1b\x4a\x0c\xe8\x84\xdf\x22\xde\x8e\x79\x15\x01\xfd\xf6\x66\xcc\x6b\x9a\xe3\x57\xb5\x98\xbf\xe3\x87\x5a\x3b\x9d\x5e\x11\xa4\x8f\x31\x98\xa5\xbf\xcc\xd2\x22\x2d\xd6\x4b\x56\x4a\x5c\xfd\x59\x38\x9f\x8b\x4a\xe3\x31\xb4\x4e\x65\xd4\x0b\xd2\x3a\x6b\xf9\xe6\xea\x17\x71\x13\xb0\x0e\xcf\xa3\x44\x7a\x1b\x95\xa9\xc3\x13\xc9\x75\x65\x81\xe3\x9b\xa2\x1c\xf0\xc3\x8b\xbe\x71\xa1\x68\xed\xec\xed\xb5\xc4\xbd\x61\xf4\x93\x5a\x93\x39\x9c\x8e\xf6\x02\x18\xed\x9d\xf9\xeb\x9d\x9f\xb7\x04\x70\xf7\x68\xa8\x55\xdb\x09\x60\x2f\x80\xaa\x9e\x35\x3f\x45\xfa\xb3\xe8\x8f\xbc\xba\x88\xee\x07\xaa\x97\xce\x11\x70\x65\x32\x65\xe1\x17\xe0\xf8\xdb\x87\x59\xf6\xde\x65\xfe\x96\x07\xbd\xf0\x7a\xcf\x8b\xcc\xf5\x77\x77\x7c\xc3\xed\x03\x5f\xe6\x2e\xca\xb2\xf7\xc2\x8d\xbf\x3c\x4b\xf9\x23\x7e\x84\x87\x59\x76\xca\x7f\x3f\x83\x67\x63\x35\x27\xd6\x51\xce\x8b\x20\x07\x1a\x02\xa6\xe4\x7e\xf7\xfe\xc3\x9f\xdf\xfd\x7c\x78\x52\x42\xc4\x62\xdf\x24\xa8\x99\xe4\x1b\x3e\x9b\xc8\x15\xbc\x31\xba\x71\xe5\x4b\x89\x2f\x4e\x8a\x2c\x3b\xbd\xe2\x1c\x46\x8d\x72\x0f\xfc\x6e\xef\x55\x0d\x7e\xdc\x9f\x41\xa5\xa2\xd0\x1f\xfa\x50\x2c\xb4\x32\xdd\xb1\x6a\x78\x50\x36\xec\x45\xbf\x90\x25\x9f\x8e\x55\xd1\xcd\x4e\x6d\xd5\x6f\xf6\xa6\xe3\x23\x63\x25\xec\x72\xb6\xad\xe7\x3a\x4f\x31\x87\x6a\xc9\xc0\x5b\x18\xc1\x81\x3e\x4f\xc3\x0e\x97\x00\xfb\xf2\xaa\xac\x47\x60\xf0\x5b\x74\x07\xba\x5a\xa7\x15\x9e\xf1\x01\xb4\x84\xfb\x22\xeb\xb6\x74\x38\x60\xa2\x8f\xd4\x55\xdf\xda\x21\x73\x96\x04\x70\x6f\x9e\x14\x13\x5b\x45\x68\x1d\xc5\x4c\x6a\x84\xbe\xd4\xa7\x9a\xa3\xa0\x64\xee\x51\x56\xed\xb7\x5e\x23\xce\x06\xdc\x4b\xfc\x67\x7b\xb1\x0b\x1d\xc2\xbd\xd2\x20\xe8\x9d\xfb\xe0\x55\x87\x92\xaa\x90\x9a\x6d\x2b\x09\xbe\x5b\xfa\xba\x8c\x1f\xdb\xed\x32\x7e\x16\xb2\x84\x5c\xf2\xfa\x57\xb5\xf8\xf8\xf6\xc6\x82\x05\xf4\x7a\x35\x9f\xa7\x3e\xb1\x3b\xe6\x43\xaf\x3f\xd5\xb3\x1c\x33\xc1\x4e\xc8\x76\xc5\x00\x55\x6b\x86\x0b\xd8\x02\xa5\xc5\x5e\x4d\x76\xba\xc0\xba\x95\x5f\xea\x61\xdc\xb5\xa4\x9d\x6e\x55\x6f\xf8\xd0\x1a\x26\x78\xe2\xce\x27\x96\x6c\x69\xec\x4d\xf8\xe2\xae\x8c\x97\x89\x7b\x15\x38\xfc\xb7\x0f\xc7\x1f\x4f\xe4\xdf\x95\xe6\x66\x0c\x61\x82\xe2\x43\x99\xe2\x90\xcf\xdd\x6f\x7f\x14\x53\x26\x42\xca\xd6\x4b\x96\x9e\x43\xc4\xce\xf9\x9d\x86\x9f\x8b\xaa\xff\x2d\x7e\x12\x8b\xe7\xfd\x70\x11\x19\x43\x2a\x1e\xb7\x4d\x95\x87\x7b\x53\x86\xaf\xa0\x35\x3c\x49\x23\x91\xcb\x43\xc0\x9c\xb1\xe4\x36\xce\xd2\x84\x8b\x2e\xb9\xf4\x36\xbd\x59\x2e\xd3\xac\x10\xa9\xca\x59\x9f\x2f\xd6\x4c\x49\x9e\xfa\x24\xcb\x3e\x8b\x62\x5c\xba\x6b\xdd\x24\xa2\x47\x11\x76\xda\xac\x6f\x74\xdc\x7a\x35\xb6\xaf\xf5\x50\xe5\xd3\xca\xd6\xcb\x22\x85\x0e\x14\xd9\x1a\xbe\x80\xfc\x73\x0c\x19\xfb\x7c\x13\x67\xac\xdd\x12\x4f\x5a\x1d\xfe\x95\xb3\xb0\x98\x5d\x42\x9b\x75\xe0\xcb\xd7\xf2\x7b\x7f\xce\xd2\xbb\x5c\x29\xc6\x9c\x8d\x76\x31\x4f\xa7\xe1\xbc\xaf\x4f\x96\xa3\x62\xf8\xda\x29\x93\xe9\x7c\x0d\xbe\xfc\x41\xb4\xf8\x87\xfd\xbd\xe1\xd7\xb3\xe0\x0f\x77\x6c\xfa\xfc\x0f\xfb\xa7\x6a\x0a\xda\xb2\x63\x81\xf8\xc4\x40\x7e\x62\xe7\xcb\x0f\x9c\x65\xfd\x95\x4d\x9f\xeb\x9d\xef\x0f\xe6\xf1\x74\xc0\x49\x60\x7a\x81\xc1\x00\xa2\x34\x29\x20\xbd\x65\x59\x16\x47\x4c\xf6\x8e\x73\xbb\x38\x9c\xce\xd9\x0f\x7c\x4c\xe4\xb0\xdf\xc5\x49\x94\xde\x61\x4e\x01\x6b\xdc\x8d\x02\x7d\xd1\xa4\x59\x4a\x4d\x85\x51\x04\x3b\xf7\xfa\x87\xaf\x3f\xfc\xe0\xcc\x8e\x78\x83\x1f\x5f\xf5\xf8\x0f\xfb\x3b\x3b\x5f\xcf\xbe\x06\x5f\xbe\x06\xa7\x62\x14\xce\x3a\x3f\x0c\x06\xff\x03\xf2\xf4\x26\x9b\xb1\xdf\xc2\xe5\x32\x4e\x2e\xfe\xf2\xf1\xfd\x98\xbf\xec\x5f\xe5\xfd\x45\xb8\xfc\xe1\xff\x05\x00\x00\xff\xff\x1f\xd2\x49\x1b\x25\x92\x07\x00") func scriptsWeb3JsBytes() ([]byte, error) { return bindataRead( @@ -124,132 +118,12 @@ func scriptsWeb3Js() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "scripts/web3.js", size: 496217, mode: os.FileMode(420), modTime: time.Unix(1495916191, 0)} + info := bindataFileInfo{name: "scripts/web3.js", size: 496165, mode: os.FileMode(420), modTime: time.Unix(1501859373, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _bootclusterHomesteadDevJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xce\x39\x6e\x96\x5b\x0c\x00\xd0\xfe\x5f\x45\x94\xfa\xe9\x8b\xe7\x21\xd5\xdb\x07\xa2\xb8\xbe\xb6\x4b\xd8\x7f\x87\x90\x82\x44\xc1\x06\x8e\xce\xb7\xd7\xdb\xdb\xfb\xfc\xf8\xd9\xf3\xf9\xf1\x91\x1c\xcc\x35\x81\x97\x1b\xab\x8b\xce\xe8\xed\x21\x8d\x1b\x1b\x74\x1a\x01\xf1\x60\xcd\x89\x29\xc9\x1d\x85\x82\xb3\x9c\xd2\xb2\xbe\x3e\xa2\xe9\xc2\x6a\xe1\xa0\x4a\xcb\xe6\x22\xb3\xed\x4c\x96\x74\x4c\xc2\xb4\x71\xa2\x4c\x10\x65\xce\x46\x1e\xac\xd3\x70\x30\x81\x0f\xfd\xaf\xf8\xa0\x3e\x26\x0f\xe5\x27\x03\x03\xbf\xff\xf7\xf7\xaf\xdd\x42\xa5\xae\x0a\x8a\x14\x91\xe5\x55\x46\x6b\x5d\x80\xfd\x8d\xc8\xec\x0c\x6d\x45\x33\x8e\x17\x26\xe7\xec\xb6\x0f\xfa\x92\xba\xf3\x46\x5f\xdf\x3e\x71\x65\x4a\x2c\x45\xc1\x33\xfb\xf8\x72\x96\x0c\x9b\x0c\x1d\xf2\xe8\xc4\x52\x56\xce\xbe\x55\x08\x85\x9c\xc6\xfa\xf5\x73\x7e\xd8\xff\xf5\x53\x0f\x17\x02\x4d\xc6\xde\x74\x03\xcf\x91\xdd\x98\x2a\x75\x35\x31\x04\x86\x2d\x80\x75\x96\xb0\x6a\x9d\x2b\x67\x6c\xda\xea\x64\x0c\x79\x43\xae\xc6\x68\x56\x87\x52\x60\x93\x40\xc8\x31\x30\xaa\x1b\xa7\x14\xa5\xeb\xf6\x39\x69\x1e\x7b\x19\x00\x5b\xdc\x9d\xc6\xc8\xe6\xcf\x4f\x1f\x42\xfe\x0a\xbe\xbe\xbf\x7e\x05\x00\x00\xff\xff\x73\x83\xab\x93\xe4\x01\x00\x00") - -func bootclusterHomesteadDevJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterHomesteadDevJson, - "bootcluster/homestead.dev.json", - ) -} - -func bootclusterHomesteadDevJson() (*asset, error) { - bytes, err := bootclusterHomesteadDevJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/homestead.dev.json", size: 484, mode: os.FileMode(420), modTime: time.Unix(1494937266, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _bootclusterHomesteadProdJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xce\x29\x6e\x9e\x5b\x0c\x00\x50\xfe\xaf\x22\x0a\x7e\xfa\xe2\xf1\xda\x0e\x7a\xfb\xa8\x0a\x3c\x5d\xd8\xee\x9f\x55\x95\x1a\x50\xa9\xf8\x90\xf3\xed\xf5\xf6\xf6\xbe\x3f\x7e\xce\x7e\x7e\x7c\x5c\x2e\x58\x9d\x4e\x63\x88\x43\x95\xeb\x28\x97\x05\xa8\xfc\x7a\x52\x9c\x23\xd2\xcc\xeb\x63\x19\x5a\x83\x59\x8c\x8c\xc2\x69\x4a\x6d\x06\x76\x12\xb8\xba\xec\xd0\x61\x35\xb8\x74\x59\x46\xb6\x94\xe1\xe2\xe4\x55\x50\x69\x88\x80\x20\x4c\x37\x4a\xfe\x8d\xa0\xd3\x3b\xf7\x7f\xc5\x07\xf5\x31\x7e\x90\xe2\x93\x81\x81\xdf\xff\xfb\x2b\xd8\x0b\x83\x4d\x14\xe4\x14\x05\xdb\xdd\x2b\x22\xd7\x43\xf8\xba\x83\x5b\x2f\x40\xea\x06\x42\xa1\x5a\x18\xed\xe2\x51\xcf\x10\x1f\xe2\xb6\x04\x39\x97\x8e\x1e\xbb\xc6\x45\x85\x3e\x48\xc7\x11\x15\x62\x6c\x2f\xce\x6a\x6d\x14\xce\xf6\xed\x2a\x14\x63\x4f\x0d\x68\x31\xfb\x0a\xea\x83\x6e\xff\x0a\x72\x49\xc5\x4d\xa0\x5c\x1f\x95\xa6\x29\xc5\x3c\x26\xd5\xc1\xe3\x7a\x24\x4a\xcc\xf4\x12\x09\xc0\x35\xc9\x25\xdd\xb8\xd8\xe7\x68\x65\x72\xf5\x0c\x73\xe7\x0c\x35\x66\x70\x0f\x78\x9e\xbc\xe1\xd2\x75\x40\x6f\xd5\xc1\x6d\x18\x53\x48\xc4\x11\x1f\x01\x07\x0a\xcf\x0b\xe0\x5f\x41\x7b\x30\xf8\x4f\xf0\xf5\xfd\xf5\x2b\x00\x00\xff\xff\xd9\xb7\x34\x6d\xe6\x01\x00\x00") - -func bootclusterHomesteadProdJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterHomesteadProdJson, - "bootcluster/homestead.prod.json", - ) -} - -func bootclusterHomesteadProdJson() (*asset, error) { - bytes, err := bootclusterHomesteadProdJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/homestead.prod.json", size: 486, mode: os.FileMode(420), modTime: time.Unix(1494937266, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _bootclusterRinkebyDevJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xd0\x29\x6e\x96\x51\x14\x00\x50\xdf\x55\x34\xd5\xe4\xeb\x9d\x87\x2a\xf6\x41\x10\xef\x0e\x4f\xc2\xfe\x1d\xe6\x27\x41\xb0\x83\x93\xf3\xe3\xed\xfd\xfd\x63\x7f\xfd\x9e\xfd\xfa\xfc\x74\x45\xea\xb8\xb6\x7e\xef\x74\x3b\x71\x5f\xf7\x35\xa0\x83\xb3\x39\xd1\x4d\x1b\x67\x58\xa7\x18\x52\x4c\x02\x13\x89\x7a\xdc\x39\xd4\x91\xf1\xec\x72\xc2\xdd\x66\x8e\x94\x29\xe4\x39\xce\xd0\x21\x4c\x55\x24\xb1\x3b\x26\xc0\xb9\x1c\x08\x8b\x6a\x9b\x9e\x45\x21\xde\xf5\x5d\xf1\x41\x7d\x3c\x1e\x12\xfe\x62\x60\xe0\x8f\x6f\xff\x02\xb1\x9b\xfc\xe8\x11\x44\x86\xa3\x1d\x95\x30\xa5\x45\xe4\x3c\x4d\x71\xbd\xd4\x2e\xef\xdc\x86\xe9\x56\x2f\x33\x1d\x51\x24\x97\x22\x53\xc1\x8d\x59\xc9\x3d\x7e\xc0\x85\x02\x13\xec\x04\x11\x64\xa5\x01\x10\x67\x67\x20\x1a\x97\xdd\x1b\xda\x0c\x1c\x27\x96\xaa\x75\xa2\xe2\x05\xb4\x78\xf2\xbf\x3e\xcf\x18\x74\x30\x41\xc1\x8a\x1b\x31\xd7\x31\x80\xe2\x04\x39\x55\x0a\x0f\x76\xc5\x5a\x5a\xf1\x9c\x52\x53\xcc\x76\x28\xf7\xc2\x61\xb1\x2c\xb5\xb2\x2b\xbd\xec\x11\xa2\x6e\x62\x01\x71\xb5\x9d\x32\x37\x11\xcd\xc8\x2e\x51\xe0\x65\xa8\xd4\x54\xf2\x4a\xcb\xe3\xb8\x72\xff\x06\xea\x43\x22\x2f\xe0\xdb\xcf\x3f\x01\x00\x00\xff\xff\x18\xe1\x19\x8d\xe4\x01\x00\x00") - -func bootclusterRinkebyDevJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterRinkebyDevJson, - "bootcluster/rinkeby.dev.json", - ) -} - -func bootclusterRinkebyDevJson() (*asset, error) { - bytes, err := bootclusterRinkebyDevJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/rinkeby.dev.json", size: 484, mode: os.FileMode(420), modTime: time.Unix(1494937266, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _bootclusterRinkebyProdJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xce\x2b\x6e\x1c\x50\x0c\x40\x51\x3e\xab\x88\x82\xab\x89\xed\xe7\x6f\x50\xf7\x51\x15\xf8\xf9\x03\xdb\xfd\xb3\x6a\xa4\x80\x80\xb2\x4b\xae\x74\x7e\x3d\xde\xde\xde\xe7\xcf\xdf\x9e\xcf\x8f\x8f\xed\x3c\xab\x64\x27\x61\xa9\x93\xb3\xc4\xc5\x1b\x57\x68\x24\x37\x37\x7a\x96\x1c\x91\xf0\xce\xe9\x63\x22\x5e\x6a\xcd\x1d\x95\xa4\xa5\xd9\x96\x20\x04\x97\xaa\x8d\x85\x91\x60\xaf\x19\x8c\x6b\x8b\x29\xb0\x5b\x45\x10\x5f\x42\xd5\x51\x61\x97\x55\xd0\x11\x6d\x85\xad\x9f\x82\x4f\x94\xa7\xc6\x13\x99\x3f\x0f\x1c\x38\xef\x3f\xbe\x03\x6f\x32\x66\x3a\x05\xb9\x25\x64\x80\x69\xc7\xdd\x9d\x0e\x2b\xaf\xa1\xe1\xc0\x1b\xe1\x76\xc8\xbd\x62\xdc\x75\x51\xb7\xc5\xe4\x80\x66\x69\xa9\x68\x5f\xde\xbb\x8e\xbc\x92\x01\x84\x39\x05\xc0\xbb\x19\x05\x39\xae\x02\x1b\xb4\x8d\x50\x48\x33\xd7\xea\x28\x4b\x9c\xb9\xe7\x3b\xd0\xfe\x07\x24\x9f\x5a\x21\xa3\x2b\x0a\x95\x21\xb8\x5c\x6d\x8b\x73\xfd\xb6\x52\xa7\xb8\x9c\x0b\xa4\x97\x5f\x8e\x43\xc5\x17\xd0\xc2\x56\x2e\x20\xb2\x63\x24\x04\xa4\x51\xbe\xbe\x43\xea\x72\x54\xa6\xda\x07\x80\x05\xc0\x78\x13\xd4\x0e\x9c\xc8\xd9\x41\xd8\xb3\x57\x55\xe7\x15\x5f\x40\xd3\x27\x71\x7c\x01\x1f\xbf\x1f\xff\x02\x00\x00\xff\xff\x4f\x3f\xe5\x15\xe6\x01\x00\x00") - -func bootclusterRinkebyProdJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterRinkebyProdJson, - "bootcluster/rinkeby.prod.json", - ) -} - -func bootclusterRinkebyProdJson() (*asset, error) { - bytes, err := bootclusterRinkebyProdJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/rinkeby.prod.json", size: 486, mode: os.FileMode(420), modTime: time.Unix(1494937266, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _bootclusterRopstenDevJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xd1\x39\x6e\x15\x50\x0c\x85\xe1\x3e\xab\x88\x52\xa3\x97\xeb\xd9\x4e\xc5\x3e\x10\x85\x87\xeb\x12\xf6\xdf\xa1\x48\x11\x50\xbc\x15\x9c\x4f\xe7\xff\xf1\xf2\xfa\xfa\x76\x7f\xfd\x9e\xfb\xf1\xfe\x3e\x49\xb5\xe4\x91\x87\x60\x89\xb6\x44\x3a\x56\x56\x78\xe7\x3a\x1b\x05\x20\x1f\x1c\xb4\xdd\xcd\x94\x73\x77\x8c\xfb\xcc\x11\x90\xa5\x54\x98\x5c\x1d\x41\x10\x58\x74\xd3\x82\x68\x10\x47\xbf\xba\x6a\x87\x04\x6b\x97\x09\x4b\x6e\xb3\x98\x0a\x5e\x63\x13\xb9\xde\xae\xbc\xdf\x05\x1e\x20\x0f\xc5\x07\x80\x7e\xd0\xa1\x43\x6f\xdf\xfe\x07\x8a\x7f\xae\x95\x47\x9d\x63\x10\x37\xae\x15\x94\x34\x61\x72\x7a\x30\x2e\x59\x2c\x8f\x8c\x6a\x95\xc6\x46\xdb\x66\xd8\x26\xe3\x2a\x87\xf1\xb5\x3a\x62\x45\x72\x4b\x52\x69\xc7\xc2\x28\xf7\x28\x6d\x24\x0c\xe1\x78\xeb\x99\x2a\x76\xe1\x56\xee\xf2\x2c\x72\x61\x3b\x28\xfe\x05\x24\x79\xe0\x33\xde\x35\xa8\x8c\xd0\x0a\xa4\xcb\x26\x6a\x4e\x64\x72\xcf\x1d\x58\x8c\x50\x2a\x5b\x93\xa0\x23\x81\x4a\x20\x43\xbd\x91\x06\xa4\x3c\x18\x7e\xa6\xda\xb5\xa0\x41\x38\x1c\xb0\x0d\x4f\x91\xaf\x9e\x21\x36\xe0\x58\xa8\x24\x52\x87\x96\x1e\x6e\xdf\x4e\xbe\xd7\x01\xf4\xee\x6d\xfd\xc7\xb3\xf3\xcc\xe7\x18\x7b\x22\x83\xb5\x3a\x5b\x2d\xb7\xc6\xca\x37\xfb\x3a\x36\x3b\x1c\xcd\xd5\xd4\x42\x39\xd6\xe7\xd8\x5c\x6d\x8b\xc2\xa9\x59\x11\x66\x52\xcf\x9d\x0d\xea\x15\x04\x1f\x1d\x93\x84\x3d\x08\x71\x95\x00\xa7\xd8\xab\x1b\xf7\xec\x6c\x76\xc1\x38\xb6\xc3\x1e\x85\x51\xa4\x2f\x9f\xf0\x03\x31\x9e\x1e\xe8\x07\x4d\x33\xab\x4c\xfd\xb3\xa9\x4a\x2c\x13\x43\x03\x44\xcc\xb5\x98\x80\xc4\x2b\xe7\xa4\xde\x1b\x75\x07\xf4\x0e\xf7\x0d\xb4\x4a\x1f\xc2\x4a\x99\x9b\x24\x66\x14\xbb\xb3\xd8\x52\xdd\xce\x3e\x74\x94\xab\x74\x3f\x7f\x3c\xc5\xc8\xd1\xb0\x76\x85\xd6\x6b\x0f\xd6\xf6\xdf\xbe\xf1\x10\xfb\xf2\xbd\xfc\x7c\xf9\x13\x00\x00\xff\xff\x78\x60\xe5\xe7\x24\x03\x00\x00") - -func bootclusterRopstenDevJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterRopstenDevJson, - "bootcluster/ropsten.dev.json", - ) -} - -func bootclusterRopstenDevJson() (*asset, error) { - bytes, err := bootclusterRopstenDevJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/ropsten.dev.json", size: 804, mode: os.FileMode(420), modTime: time.Unix(1495053455, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _bootclusterRopstenProdJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x6c\xd1\x39\x4e\x60\x59\x0c\x85\xe1\x9c\x55\x20\xe2\xd6\xc3\xe3\xb5\x4d\xd4\xfb\x68\x75\xe0\xeb\x21\xac\xda\x7f\x56\x42\x02\xa9\x02\x76\xf0\x9d\xff\xfc\xf7\xf2\xfa\xfa\x36\xbf\x7e\xf7\x7c\xbc\xbf\xef\xed\xde\x15\xf3\x41\xa7\xa0\x2e\xa6\x1b\xb0\xc8\x71\xd7\x8c\x13\xbc\xd3\x63\x77\x28\x08\x7c\xa4\x07\x20\x70\x4f\xa9\xc7\x1c\xd8\xaa\xcd\xc5\xd3\xb2\x92\x76\xee\x48\xac\x9a\x39\x15\x1c\x9c\xf2\xc9\x30\x30\x3f\x80\x75\x96\x8f\xed\xe4\xed\x34\x81\xd5\x1a\x27\x39\xff\x2a\x3e\xa8\x8f\xea\x43\x18\x1f\x0c\x0c\xfc\xf6\xcf\xdf\x40\x19\x9d\x01\x71\x4b\x69\x67\x89\xbc\x91\x11\xa4\x17\x60\xa6\x61\xc3\x4e\x87\x87\x51\x69\x12\xad\xf0\xb6\x42\xa3\x90\x78\x98\xa9\x01\x53\xf1\x59\x32\xbe\xc2\x92\xd2\x3c\x80\x9c\xa4\x22\x53\x69\x92\xd1\x98\x20\x18\x1b\x0b\xb6\x76\xaf\x30\x3a\xa5\x71\x2f\x9f\x80\x2f\x20\xeb\x83\x08\x3f\x01\xd1\x67\x3b\x72\xef\x01\x11\x1e\x80\x9d\x3e\x40\x55\xd0\xab\x74\xaa\xb1\x5d\x85\x9b\xf6\x00\x5b\x6f\xb0\xc3\xdc\x30\x6e\x86\xab\xdb\x20\x59\xb1\x44\x08\xca\xeb\x04\x2c\xea\x08\x8a\x77\xfb\x8c\x0a\xeb\xc9\x88\x5c\x22\xd5\xc5\x3c\x26\x6d\xd8\x68\x22\x90\xa7\x42\xef\x37\x50\x1e\xfe\x89\xa7\x37\xa2\xa0\x2e\x1b\x51\xc4\x36\x2f\x75\xc8\x41\xca\xe3\x14\x01\x46\x34\xd7\xea\xb3\x08\x75\xd6\x6c\x39\x19\xcc\xb5\x45\xa3\xad\x13\x51\xd8\xbd\xd9\x4e\x67\xef\x56\x58\x90\x81\xb2\x8f\xb7\xc7\xed\x13\x18\x06\x3c\x37\xe6\x73\xee\x64\x41\x8a\x4e\xec\x15\x55\x24\xfe\x3e\xf8\x3c\xa8\xf2\x13\x10\x06\x5b\x1a\xb6\x76\xdc\xfd\xae\xa7\x98\x5f\xd8\xf6\xb0\x03\x29\x66\xcc\xa9\x05\x52\x2d\xd6\xc3\xca\x14\x9a\x67\xae\x77\x8f\xaf\x8a\x13\x5e\x46\x8c\xa3\x64\x0d\xa5\x65\x9c\x06\x24\x5d\xb1\xcb\x82\x64\x27\xa8\x89\xcd\x05\xb6\x20\x8a\x91\x2e\x27\x46\x35\xf9\xce\x17\xf0\xc0\x43\xdf\x01\x5f\xfe\x7f\xf9\x13\x00\x00\xff\xff\xa3\xe6\x1d\x0b\x25\x03\x00\x00") - -func bootclusterRopstenProdJsonBytes() ([]byte, error) { - return bindataRead( - _bootclusterRopstenProdJson, - "bootcluster/ropsten.prod.json", - ) -} - -func bootclusterRopstenProdJson() (*asset, error) { - bytes, err := bootclusterRopstenProdJsonBytes() - if err != nil { - return nil, err - } - - info := bindataFileInfo{name: "bootcluster/ropsten.prod.json", size: 805, mode: os.FileMode(420), modTime: time.Unix(1495053455, 0)} - a := &asset{bytes: bytes, info: info} - return a, nil -} - -var _configLinter_exclude_listTxt = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xa4\x95\xcf\x6e\xe2\x30\x10\xc6\xef\xfb\x14\x16\xa7\xdd\x0b\xef\x80\x82\xb4\xda\x55\x85\x22\x82\x7a\x9f\xc6\x93\xc4\x92\xe3\x89\xc6\x13\x5a\xde\xbe\xa2\xd0\xf2\x2f\x0e\x19\xb8\xf2\xfd\xf8\x7d\xf6\x38\x4e\x4a\x6a\x5b\x0c\x62\x28\x18\xfc\xe8\x88\x05\xad\xa9\xfa\x50\x8a\xa3\x60\x32\x46\x10\x5c\x94\x25\xf5\x41\x4c\x6c\xa8\xf7\xd6\xbc\xa1\xa1\xca\x48\x83\xa6\x22\x6e\xcd\xec\x12\x9a\xcf\xe7\x33\xf3\xbb\x26\xef\x82\xfc\xf9\x35\xc1\x9e\x35\xce\xdb\x49\x15\x17\xa4\xa2\x67\x8d\x25\x6d\x91\xef\x74\x5c\x51\x0a\xff\x0b\xd5\x2e\xa4\xb4\x87\x50\x67\xa3\x3e\xb9\xca\x63\xaa\x99\x32\xb5\x9d\x47\xc1\x0d\x43\x88\x70\xf8\x2d\x35\xe6\x01\xf4\xb9\xa6\xa8\xa8\x8a\x9a\xae\xa5\x8b\x25\xb0\x9d\xb0\xa9\x01\xf2\xa9\x9e\xe4\x96\x86\x50\x45\xd3\x5f\x0c\xc8\xfb\xa7\x9c\x42\xe5\xea\x54\xc9\x15\xa5\xf0\x17\x02\x2c\x2b\xb2\x98\x52\x9f\x00\x95\x95\xba\x71\xe9\x31\x57\xdd\xd7\xd8\xb7\x38\x66\x3d\x23\x74\x5e\x94\xac\x01\x17\x96\x20\x30\xe2\x3e\xa7\x1e\x98\xc5\x3a\xcf\x0a\xe4\x2d\xf2\xbd\xa1\x9c\xc0\x47\xce\x71\x42\xcd\x0d\xa9\xe8\xf9\x17\x9c\xfc\x07\xe7\x53\xf6\x9f\x5c\xe1\xcc\x81\x63\xf2\x50\x0f\xa1\xe6\x7d\x03\x3e\xb9\xba\xaf\x4c\xb3\x32\xea\x7a\x0f\x82\x85\x80\xb8\x32\x47\xe4\xe4\x3d\x1f\x42\x15\x4d\x0b\x6b\xf7\xff\x49\xd9\xbf\x63\x85\x71\x45\xe2\xaa\xdd\xd8\x7d\x39\x23\x14\xde\x0d\xbb\xba\x46\xde\x60\x94\xc2\xd5\x01\x92\xc3\xbe\x05\x15\x2d\xaf\xc8\xae\xda\x1d\x3f\xbb\x39\xc4\xf8\x4e\x6c\x53\x4d\xc3\xf0\x65\xdb\x67\x00\x00\x00\xff\xff\xf3\x09\x13\xa2\xd2\x08\x00\x00") +var _configLinter_exclude_listTxt = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xa4\x95\xcf\x6e\xe2\x30\x10\xc6\xef\xfb\x14\x16\xa7\xdd\x0b\xef\x80\x82\xb4\xda\x55\x85\x22\x82\x7a\x9f\xc6\x93\xc4\x92\xe3\x89\xc6\x13\x5a\xde\xbe\xa2\xd0\xf2\x2f\x0e\x19\xb8\xf2\xfd\xf8\x7d\xf6\x38\x4e\x4a\x6a\x5b\x0c\x62\x28\x18\xfc\xe8\x88\x05\xad\xa9\xfa\x50\x8a\xa3\x60\x32\x46\x10\x5c\x94\x25\xf5\x41\x4c\x6c\xa8\xf7\xd6\xbc\xa1\xa1\xca\x48\x83\xa6\x22\x6e\xcd\xec\x12\x9a\xcf\xe7\x33\xf3\xbb\x26\xef\x82\xfc\xf9\x35\xc1\x9e\x35\xce\xdb\x49\x15\x17\xa4\xa2\x67\x8d\x25\x6d\x91\xef\x74\x5c\x51\x0a\xff\x0b\xd5\x2e\xa4\xb4\x87\x50\x67\xa3\x3e\xb9\xca\x63\xaa\x99\x32\xb5\x9d\x47\xc1\x0d\x43\x88\x70\xf8\x2d\x35\xe6\x01\xf4\xb9\xa6\xa8\xa8\x8a\x9a\xae\xa5\x8b\x25\xb0\x9d\xb0\xa9\x01\xf2\xa9\x9e\xe4\x96\x86\x50\x45\xd3\x5f\x0c\xc8\xfb\xa7\x9c\x42\xe5\xea\x54\xc9\x15\xa5\xf0\x17\x02\x2c\x2b\xb2\x98\x52\x9f\x00\x95\x95\xba\x71\xe9\x31\x57\xdd\xd7\xd8\xb7\x38\x66\x3d\x23\x74\x5e\x94\xac\x01\x17\x96\x20\x30\xe2\x3e\xa7\x1e\x98\xc5\x3a\xcf\x0a\xe4\x2d\xf2\xbd\xa1\x9c\xc0\x47\xce\x71\x42\xcd\x0d\xa9\xe8\xf9\x17\x9c\xfc\x07\xe7\x53\xf6\x9f\x5c\xe1\xcc\x81\x63\xf2\x50\x0f\xa1\xe6\x7d\x03\x3e\xb9\xba\xaf\x4c\xb3\x32\xea\x7a\x0f\x82\x85\x80\xb8\x32\x47\xe4\xe4\x3d\x1f\x42\x15\x4d\x0b\x6b\xf7\xff\x49\xd9\xbf\x63\x85\x71\x45\xe2\xaa\xdd\xd8\x7d\x39\x23\x14\xde\x0d\xbb\xba\x46\xde\x60\x94\xc2\xd5\x01\x92\xc3\xbe\x05\x15\x2d\xaf\xc8\xae\xda\x1d\x3f\xbb\x39\xc4\xf8\x4e\x6c\x53\x4d\xc3\xf0\x65\xdb\x67\x00\x00\x00\xff\xff\xf3\x09\x13\xa2\xd2\x08\x00\x00") func configLinter_exclude_listTxtBytes() ([]byte, error) { return bindataRead( @@ -264,12 +138,12 @@ func configLinter_exclude_listTxt() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "config/linter_exclude_list.txt", size: 2258, mode: os.FileMode(420), modTime: time.Unix(1494920851, 0)} + info := bindataFileInfo{name: "config/linter_exclude_list.txt", size: 2258, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _configTestDataJson = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x84\x8d\x31\x6b\xc4\x30\x0c\x46\xf7\xfc\x0a\xa1\xb9\x83\x1d\x57\xb2\x93\xed\xb6\x4e\x25\x90\x83\xce\xb2\xac\x8c\x31\xc4\x57\xda\x52\xee\xbf\x17\xd3\x83\x83\x42\xb9\x41\x20\x1e\x7c\xef\x7d\x0f\x00\xf8\x5a\x8b\xe1\x0c\xfd\x07\xc0\xf5\x6b\xd7\xd5\xb4\xee\xa5\xe1\x0c\xf1\xe9\x97\xbe\x9c\xcf\xcb\x52\x8f\x0b\xce\x90\xf8\x99\x6e\xf4\x6d\xbd\x33\x1e\x00\xae\x9d\xe3\x49\xb5\xbe\xef\x17\x7f\x77\x9e\x4a\x39\xac\x75\x1f\xba\x4f\x29\xb2\x79\x72\x79\x72\xa4\x1b\x19\x4b\x8c\xc9\x88\x82\x79\x12\x1f\xa6\xcc\xec\x53\xce\x39\xe2\x2d\xb2\x48\x6b\x1f\xf5\x28\x7d\x2d\xad\x6c\xfd\xf0\x6f\x6c\xfc\x27\xc6\xa4\xce\x53\x62\x11\xa7\xe6\x69\x4c\x81\x34\xa6\x24\x6a\xcc\x64\x93\x97\x1c\x68\x8c\x39\x3d\x8c\x0d\xd7\x9f\x00\x00\x00\xff\xff\xb4\xe1\xf5\x0c\x2c\x01\x00\x00") +var _configTestDataJson = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x8d\x31\x6b\xc4\x30\x0c\x46\xf7\xfc\x0a\xa1\xb9\x83\x1d\x57\xb2\x93\xed\xb6\x4e\x25\x90\x83\xce\xb2\xac\x8c\x31\xc4\x57\xda\x52\xee\xbf\x17\xd3\x83\x83\x42\xb9\x41\x20\x1e\x7c\xef\x7d\x0f\x00\xf8\x5a\x8b\xe1\x0c\xfd\x07\xc0\xf5\x6b\xd7\xd5\xb4\xee\xa5\xe1\x0c\xc1\x3d\xfd\xe2\x97\xf3\x79\x59\xea\x71\xc1\x19\x12\x3f\xd3\x8d\xbe\xad\x77\xc6\x03\xc0\xb5\x73\x3c\xa9\xd6\xf7\xfd\xe2\xef\xd2\x53\x29\x87\xb5\x2e\x44\xf7\x29\x45\x36\x4f\x2e\x4f\x8e\x74\x23\x63\x89\x31\x19\x51\x30\x4f\xe2\xc3\x94\x99\x7d\xca\x39\x47\xbc\x45\x16\x69\xed\xa3\x1e\xa5\xaf\xa5\x95\xad\x1f\xfe\x8d\x8d\xff\xc4\x98\xd4\x79\x4a\x2c\xe2\xd4\x3c\x8d\x29\x90\xc6\x94\x44\x8d\x99\x6c\xf2\x92\x03\x8d\x31\xa7\x87\xb1\xe1\xfa\x13\x00\x00\xff\xff\x4a\xf9\x67\x87\x2d\x01\x00\x00") func configTestDataJsonBytes() ([]byte, error) { return bindataRead( @@ -284,12 +158,12 @@ func configTestDataJson() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "config/test-data.json", size: 300, mode: os.FileMode(420), modTime: time.Unix(1495916186, 0)} + info := bindataFileInfo{name: "config/test-data.json", size: 301, mode: os.FileMode(420), modTime: time.Unix(1501859367, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _keysFirebaseauthkey = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x04\xc0\xcb\x52\x85\x20\x18\x00\xe0\x7d\xef\xc2\xcc\x71\x4a\xc4\x76\x3f\x29\x43\x5c\x34\x2d\x4d\x59\x6a\xa5\x8d\x24\xde\x42\x7b\xfb\x3e\x00\x00\x9e\x87\xfa\xfe\xf3\xf9\x11\x5e\x20\x0e\x3a\xf6\x7b\xb8\xf2\x03\xc7\xd9\x4a\x10\xec\x46\x74\xa7\x26\x9a\xfd\x71\xec\xeb\xea\x98\x84\xb2\x9b\x6c\x92\x5b\xaa\x0d\x0e\x7c\x71\x71\xb8\xb1\xb1\xf2\x62\xcc\x61\xfb\x59\x91\xa2\x6f\x69\x6f\x29\x09\xdf\x07\x99\xb5\x09\x2a\x5f\x5b\x69\xa2\xa5\x91\x33\xa9\xa5\x67\x2d\x5d\xdd\xe1\xf0\xac\x82\xb0\xcf\xec\xd7\x72\x3d\x9c\x4f\x54\x4c\x3c\x2d\xad\x8b\xac\x32\x57\x8c\x06\xfc\x5d\x24\xd3\x7e\xf7\x1f\x00\x00\xff\xff\xd6\xa2\x00\x4a\x99\x00\x00\x00") +var _keysFirebaseauthkey = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x04\xc0\xcb\x52\x85\x20\x18\x00\xe0\x7d\xef\xc2\xcc\x71\x4a\xc4\x76\x3f\x29\x43\x5c\x34\x2d\x4d\x59\x6a\xa5\x8d\x24\xde\x42\x7b\xfb\x3e\x00\x00\x9e\x87\xfa\xfe\xf3\xf9\x11\x5e\x20\x0e\x3a\xf6\x7b\xb8\xf2\x03\xc7\xd9\x4a\x10\xec\x46\x74\xa7\x26\x9a\xfd\x71\xec\xeb\xea\x98\x84\xb2\x9b\x6c\x92\x5b\xaa\x0d\x0e\x7c\x71\x71\xb8\xb1\xb1\xf2\x62\xcc\x61\xfb\x59\x91\xa2\x6f\x69\x6f\x29\x09\xdf\x07\x99\xb5\x09\x2a\x5f\x5b\x69\xa2\xa5\x91\x33\xa9\xa5\x67\x2d\x5d\xdd\xe1\xf0\xac\x82\xb0\xcf\xec\xd7\x72\x3d\x9c\x4f\x54\x4c\x3c\x2d\xad\x8b\xac\x32\x57\x8c\x06\xfc\x5d\x24\xd3\x7e\xf7\x1f\x00\x00\xff\xff\xd6\xa2\x00\x4a\x99\x00\x00\x00") func keysFirebaseauthkeyBytes() ([]byte, error) { return bindataRead( @@ -304,12 +178,12 @@ func keysFirebaseauthkey() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "keys/firebaseauthkey", size: 153, mode: os.FileMode(420), modTime: time.Unix(1494845997, 0)} + info := bindataFileInfo{name: "keys/firebaseauthkey", size: 153, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _keysTestAccount1Pk = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x74\x51\xdb\x6a\xdc\x40\x0c\xfd\x17\x3d\xdb\x30\x37\x69\x2e\x7f\x23\x8d\x34\xc4\x64\xe3\x5d\x6c\x6f\xba\x21\xe4\xdf\x8b\x17\xda\x90\x42\x1f\x25\x8e\x8e\xce\xe5\x13\x58\x75\xb3\x7d\x87\x06\xac\x3c\x3c\x3a\xa9\x0e\xfb\x40\x23\xce\xb9\x18\x62\x34\x8f\xec\x63\x15\x22\x5f\x44\x24\xc3\x04\x7d\xfb\xb8\x1d\x57\x68\x9f\xd0\x97\xdb\x8b\x6d\xe7\xb5\xed\xb3\x0f\x65\xee\xc7\x76\x02\x9e\xeb\xc3\x1e\x07\x34\x30\x92\xc4\x25\x0b\x05\xeb\x4c\x42\x98\x24\xa1\xf5\xe2\x88\x7d\x15\xe4\x32\x38\x98\x79\x89\x55\x43\x67\x9f\x93\xa3\xe1\xfd\x90\xe2\x53\x28\x09\xf1\x2f\xdf\x8d\x37\x7e\xdb\xcf\xb7\xcb\x3b\x34\x28\x14\xd1\xa3\x76\x25\x37\x8a\xd4\x61\x3d\x2b\x0a\x63\x1d\x81\x4b\x45\x83\xaf\x09\x5e\x75\x40\x83\xfd\x29\x18\x9e\xe3\x37\x89\xbe\x5e\x6c\x85\x16\xc3\x04\x2b\xb4\x40\xc1\xa7\x34\xc1\x0d\x9a\x9f\x60\x83\x56\x26\xd8\xf9\x72\x1a\x28\xd1\x92\x16\x0c\x2a\xea\x35\x89\xd4\xd8\x7d\x2d\x35\x47\x52\x4d\x7d\xa4\x94\xa2\xb8\x92\x42\xcd\x85\xc9\xac\x47\x47\x95\x7d\x4c\x8e\xba\x44\x72\x78\x0a\x79\xe3\x0e\x0d\xb2\x3a\x37\x2a\xb1\x89\xa7\x92\xb2\xcf\x21\x95\x21\x5d\x74\x58\x0f\x4a\xca\x54\x95\xd5\x98\x9c\x11\x86\x33\x10\x47\x29\x58\xac\xae\x66\xa9\x21\x9e\x4c\x8b\x42\x03\xe9\x2e\x85\x81\x79\x66\xad\x7e\x4e\x09\xeb\xcc\x0e\x69\x26\x97\xbb\x15\xc7\x99\x9c\xc2\x04\xef\xb6\xed\xcb\xf5\x34\x39\xc1\xaf\x97\x65\xbf\xd9\x66\x2b\xcb\xc5\x14\xda\xb1\xdd\x6d\x02\x7b\x1c\xb6\xaa\xe9\xab\x7d\xfc\xe8\xf3\xdf\x12\xff\x57\xc2\x77\xc8\x3f\xe3\x5d\xef\x97\xcb\x1f\xd7\x27\x66\xbf\x0b\xf7\x7e\xbd\xaf\xc7\xb2\xaa\x3d\xa0\xb9\xaf\xdf\x01\x00\x00\xff\xff\x5a\x39\xba\x20\x7d\x02\x00\x00") +var _keysTestAccount1Pk = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x74\x51\xdb\x6a\xdc\x40\x0c\xfd\x17\x3d\xdb\x30\x37\x69\x2e\x7f\x23\x8d\x34\xc4\x64\xe3\x5d\x6c\x6f\xba\x21\xe4\xdf\x8b\x17\xda\x90\x42\x1f\x25\x8e\x8e\xce\xe5\x13\x58\x75\xb3\x7d\x87\x06\xac\x3c\x3c\x3a\xa9\x0e\xfb\x40\x23\xce\xb9\x18\x62\x34\x8f\xec\x63\x15\x22\x5f\x44\x24\xc3\x04\x7d\xfb\xb8\x1d\x57\x68\x9f\xd0\x97\xdb\x8b\x6d\xe7\xb5\xed\xb3\x0f\x65\xee\xc7\x76\x02\x9e\xeb\xc3\x1e\x07\x34\x30\x92\xc4\x25\x0b\x05\xeb\x4c\x42\x98\x24\xa1\xf5\xe2\x88\x7d\x15\xe4\x32\x38\x98\x79\x89\x55\x43\x67\x9f\x93\xa3\xe1\xfd\x90\xe2\x53\x28\x09\xf1\x2f\xdf\x8d\x37\x7e\xdb\xcf\xb7\xcb\x3b\x34\x28\x14\xd1\xa3\x76\x25\x37\x8a\xd4\x61\x3d\x2b\x0a\x63\x1d\x81\x4b\x45\x83\xaf\x09\x5e\x75\x40\x83\xfd\x29\x18\x9e\xe3\x37\x89\xbe\x5e\x6c\x85\x16\xc3\x04\x2b\xb4\x40\xc1\xa7\x34\xc1\x0d\x9a\x9f\x60\x83\x56\x26\xd8\xf9\x72\x1a\x28\xd1\x92\x16\x0c\x2a\xea\x35\x89\xd4\xd8\x7d\x2d\x35\x47\x52\x4d\x7d\xa4\x94\xa2\xb8\x92\x42\xcd\x85\xc9\xac\x47\x47\x95\x7d\x4c\x8e\xba\x44\x72\x78\x0a\x79\xe3\x0e\x0d\xb2\x3a\x37\x2a\xb1\x89\xa7\x92\xb2\xcf\x21\x95\x21\x5d\x74\x58\x0f\x4a\xca\x54\x95\xd5\x98\x9c\x11\x86\x33\x10\x47\x29\x58\xac\xae\x66\xa9\x21\x9e\x4c\x8b\x42\x03\xe9\x2e\x85\x81\x79\x66\xad\x7e\x4e\x09\xeb\xcc\x0e\x69\x26\x97\xbb\x15\xc7\x99\x9c\xc2\x04\xef\xb6\xed\xcb\xf5\x34\x39\xc1\xaf\x97\x65\xbf\xd9\x66\x2b\xcb\xc5\x14\xda\xb1\xdd\x6d\x02\x7b\x1c\xb6\xaa\xe9\xab\x7d\xfc\xe8\xf3\xdf\x12\xff\x57\xc2\x77\xc8\x3f\xe3\x5d\xef\x97\xcb\x1f\xd7\x27\x66\xbf\x0b\xf7\x7e\xbd\xaf\xc7\xb2\xaa\x3d\xa0\xb9\xaf\xdf\x01\x00\x00\xff\xff\x5a\x39\xba\x20\x7d\x02\x00\x00") func keysTestAccount1PkBytes() ([]byte, error) { return bindataRead( @@ -324,12 +198,12 @@ func keysTestAccount1Pk() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "keys/test-account1.pk", size: 637, mode: os.FileMode(420), modTime: time.Unix(1493762696, 0)} + info := bindataFileInfo{name: "keys/test-account1.pk", size: 637, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _keysTestAccount2Pk = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xac\x92\x4d\x8a\xdb\x49\x0c\x47\xef\x52\x6b\x1b\x4a\x2a\xa9\xaa\xf4\xbf\x8d\x3e\x89\xe9\x8e\xbb\xb1\xdd\x99\x0e\x21\x77\x1f\xdc\x8b\xc9\x6a\x60\x16\xb3\x94\x10\x4f\x3f\xa1\xf7\xab\x69\xc4\x2d\xef\xf7\x76\xb4\xc9\xde\x81\xf7\x54\xed\x9e\xc0\xb8\x07\xfb\xda\x5b\x3d\xe7\xe4\x14\x50\x1b\x8c\xcb\x76\x3b\x35\xbf\xfd\x7c\x7f\xbc\xb5\xe3\x57\xf3\xcb\xfb\xb7\xbc\xb5\xa3\x69\xde\xcf\x80\xfb\xec\x8f\xdb\x73\xe0\xab\xfd\xc8\xcf\x47\x3b\x1a\x4e\x60\x2e\xf6\x01\x4c\x82\xee\x46\xbd\x90\x34\x6d\x50\xd5\xb4\xb2\xb0\x70\x5b\xd4\xd1\x24\x97\x19\xf3\x2e\x25\x97\x31\x2d\x19\xaa\xfe\xe1\xbd\xeb\x4d\xbf\xdf\x9f\x6b\x2f\x3f\xda\xd1\x20\xc4\x46\xa7\x61\x2c\x3e\x44\xd8\x09\x7a\x6d\xf4\x90\x69\x95\x9d\xdb\xef\x53\x7b\x89\x6a\x47\xbb\x7f\x05\x6e\x5f\xe5\x1f\x48\xbc\xbc\xe6\xb5\x1d\x03\x4f\xed\xda\x0e\xea\x32\x4f\xed\xbd\x1d\xf3\xd4\x6e\xed\xd8\xa7\x76\xd7\xd7\x67\x7c\x32\x9b\x81\x7d\x77\x40\xc8\x95\xee\xdb\x46\xb8\xa9\xb0\x47\xef\x03\xbc\x86\x8d\x09\x8b\x26\x20\xd2\x72\x20\xda\x13\xe7\xe4\xdd\x33\xc8\xf6\x33\xc6\x77\xf5\x76\x34\xf7\x5d\xd8\x25\x04\x70\x2b\xa5\xe8\x1e\xd3\xa7\xc0\x40\x4a\x20\x96\xa0\x18\x81\x8a\xd6\x27\x2e\x2f\xa1\x14\xd1\x95\xdb\x46\x67\x9b\xe1\x4f\xd2\x25\xda\xd1\x16\x4f\x47\xe0\x3c\xc7\xd0\x3a\xd3\xe0\x38\xef\xf2\x3a\x0f\x49\x9b\x18\xa2\x2c\xbd\x9d\xda\x8f\xbc\xdd\x2f\x6f\xcf\x13\x4f\xed\xaf\x6f\x97\xfb\x7b\xde\xf2\xaa\xf6\x9a\xd1\x8e\xc7\xed\x23\x4f\x2d\x3f\x1f\x79\x8d\x8c\x97\xfc\xf9\x5f\xbf\x19\xc1\xee\xb4\x3c\x52\x46\xb7\x30\x51\x98\xc8\x55\x98\x15\x38\xba\xa9\x8b\x32\xa6\xc4\x4a\xc4\xae\x3a\x45\xbc\xc3\x72\x52\x87\xaa\x49\xbc\x26\xeb\x42\x50\x9f\x45\x40\xa3\x4a\x99\x21\xbd\xd6\xe2\xc2\x6e\xc8\xb9\x3c\x38\xc6\xe6\x99\xc5\x92\xab\x06\x04\xf5\x65\x85\xd1\xa9\x53\xe1\xc0\x21\x20\xd0\xc1\xc7\x72\x21\x61\x2c\xdb\x34\x31\x08\x37\xa8\xa0\xf5\xce\x29\xb5\x41\x67\x04\x68\x15\x16\xa5\x01\xbb\x91\x4f\xe5\x19\x25\x7d\xb9\xb0\x00\xf7\xe1\x2b\xb6\x58\xf7\xd4\xbe\xdd\xfe\xcd\xb5\x9a\xd3\x08\xc8\xe6\x5c\x7b\xc3\x34\x1f\xc9\x66\x08\x34\x91\x8c\x6a\xfd\x4f\xae\x75\x21\x53\xaa\xc9\xa6\x3e\x77\x6d\x95\xdd\xd7\x5e\x00\x7b\x45\x08\x30\x53\xef\x30\xb4\x2f\x41\xab\x11\x00\xd1\x41\x34\x87\xa7\xae\x58\xde\xff\xb8\x86\x89\xb2\x44\x68\xe8\x62\xaf\x5a\x13\x69\x77\xc7\x69\x23\xb4\xaa\x97\xfa\xda\x1e\x05\x98\x3d\x63\x09\xe4\x54\x18\x08\x35\x32\x76\xb9\xc0\x93\x74\xff\x30\x75\x7f\xfb\xb8\x3e\x2e\xd7\xc8\xcf\x76\xf4\xdf\x7f\x07\x00\x00\xff\xff\x99\xc4\xef\xba\x31\x04\x00\x00") +var _keysTestAccount2Pk = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x92\x4d\x8a\xdb\x49\x0c\x47\xef\x52\x6b\x1b\x4a\x2a\xa9\xaa\xf4\xbf\x8d\x3e\x89\xe9\x8e\xbb\xb1\xdd\x99\x0e\x21\x77\x1f\xdc\x8b\xc9\x6a\x60\x16\xb3\x94\x10\x4f\x3f\xa1\xf7\xab\x69\xc4\x2d\xef\xf7\x76\xb4\xc9\xde\x81\xf7\x54\xed\x9e\xc0\xb8\x07\xfb\xda\x5b\x3d\xe7\xe4\x14\x50\x1b\x8c\xcb\x76\x3b\x35\xbf\xfd\x7c\x7f\xbc\xb5\xe3\x57\xf3\xcb\xfb\xb7\xbc\xb5\xa3\x69\xde\xcf\x80\xfb\xec\x8f\xdb\x73\xe0\xab\xfd\xc8\xcf\x47\x3b\x1a\x4e\x60\x2e\xf6\x01\x4c\x82\xee\x46\xbd\x90\x34\x6d\x50\xd5\xb4\xb2\xb0\x70\x5b\xd4\xd1\x24\x97\x19\xf3\x2e\x25\x97\x31\x2d\x19\xaa\xfe\xe1\xbd\xeb\x4d\xbf\xdf\x9f\x6b\x2f\x3f\xda\xd1\x20\xc4\x46\xa7\x61\x2c\x3e\x44\xd8\x09\x7a\x6d\xf4\x90\x69\x95\x9d\xdb\xef\x53\x7b\x89\x6a\x47\xbb\x7f\x05\x6e\x5f\xe5\x1f\x48\xbc\xbc\xe6\xb5\x1d\x03\x4f\xed\xda\x0e\xea\x32\x4f\xed\xbd\x1d\xf3\xd4\x6e\xed\xd8\xa7\x76\xd7\xd7\x67\x7c\x32\x9b\x81\x7d\x77\x40\xc8\x95\xee\xdb\x46\xb8\xa9\xb0\x47\xef\x03\xbc\x86\x8d\x09\x8b\x26\x20\xd2\x72\x20\xda\x13\xe7\xe4\xdd\x33\xc8\xf6\x33\xc6\x77\xf5\x76\x34\xf7\x5d\xd8\x25\x04\x70\x2b\xa5\xe8\x1e\xd3\xa7\xc0\x40\x4a\x20\x96\xa0\x18\x81\x8a\xd6\x27\x2e\x2f\xa1\x14\xd1\x95\xdb\x46\x67\x9b\xe1\x4f\xd2\x25\xda\xd1\x16\x4f\x47\xe0\x3c\xc7\xd0\x3a\xd3\xe0\x38\xef\xf2\x3a\x0f\x49\x9b\x18\xa2\x2c\xbd\x9d\xda\x8f\xbc\xdd\x2f\x6f\xcf\x13\x4f\xed\xaf\x6f\x97\xfb\x7b\xde\xf2\xaa\xf6\x9a\xd1\x8e\xc7\xed\x23\x4f\x2d\x3f\x1f\x79\x8d\x8c\x97\xfc\xf9\x5f\xbf\x19\xc1\xee\xb4\x3c\x52\x46\xb7\x30\x51\x98\xc8\x55\x98\x15\x38\xba\xa9\x8b\x32\xa6\xc4\x4a\xc4\xae\x3a\x45\xbc\xc3\x72\x52\x87\xaa\x49\xbc\x26\xeb\x42\x50\x9f\x45\x40\xa3\x4a\x99\x21\xbd\xd6\xe2\xc2\x6e\xc8\xb9\x3c\x38\xc6\xe6\x99\xc5\x92\xab\x06\x04\xf5\x65\x85\xd1\xa9\x53\xe1\xc0\x21\x20\xd0\xc1\xc7\x72\x21\x61\x2c\xdb\x34\x31\x08\x37\xa8\xa0\xf5\xce\x29\xb5\x41\x67\x04\x68\x15\x16\xa5\x01\xbb\x91\x4f\xe5\x19\x25\x7d\xb9\xb0\x00\xf7\xe1\x2b\xb6\x58\xf7\xd4\xbe\xdd\xfe\xcd\xb5\x9a\xd3\x08\xc8\xe6\x5c\x7b\xc3\x34\x1f\xc9\x66\x08\x34\x91\x8c\x6a\xfd\x4f\xae\x75\x21\x53\xaa\xc9\xa6\x3e\x77\x6d\x95\xdd\xd7\x5e\x00\x7b\x45\x08\x30\x53\xef\x30\xb4\x2f\x41\xab\x11\x00\xd1\x41\x34\x87\xa7\xae\x58\xde\xff\xb8\x86\x89\xb2\x44\x68\xe8\x62\xaf\x5a\x13\x69\x77\xc7\x69\x23\xb4\xaa\x97\xfa\xda\x1e\x05\x98\x3d\x63\x09\xe4\x54\x18\x08\x35\x32\x76\xb9\xc0\x93\x74\xff\x30\x75\x7f\xfb\xb8\x3e\x2e\xd7\xc8\xcf\x76\xf4\xdf\x7f\x07\x00\x00\xff\xff\x99\xc4\xef\xba\x31\x04\x00\x00") func keysTestAccount2PkBytes() ([]byte, error) { return bindataRead( @@ -344,12 +218,12 @@ func keysTestAccount2Pk() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "keys/test-account2.pk", size: 1073, mode: os.FileMode(420), modTime: time.Unix(1493762696, 0)} + info := bindataFileInfo{name: "keys/test-account2.pk", size: 1073, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _keysWnodekey = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x04\xc0\x57\x15\x43\x31\x0c\x03\xd0\xff\xa2\x51\x7a\x14\x0f\x38\xf2\x08\x7f\x08\xef\xba\xcf\x89\x9b\x76\x47\xa2\x61\xd7\x15\x5d\xe4\x33\xe0\x54\x65\x04\x05\xee\xfc\x5d\xcc\x92\xad\xf0\xe2\xf4\x70\xaf\x9a\xa8\xdf\x17\x00\x00\xff\xff\x8b\x9c\x8b\x4d\x41\x00\x00\x00") +var _keysWnodekey = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x04\xc0\x57\x15\x43\x31\x0c\x03\xd0\xff\xa2\x51\x7a\x14\x0f\x38\xf2\x08\x7f\x08\xef\xba\xcf\x89\x9b\x76\x47\xa2\x61\xd7\x15\x5d\xe4\x33\xe0\x54\x65\x04\x05\xee\xfc\x5d\xcc\x92\xad\xf0\xe2\xf4\x70\xaf\x9a\xa8\xdf\x17\x00\x00\xff\xff\x8b\x9c\x8b\x4d\x41\x00\x00\x00") func keysWnodekeyBytes() ([]byte, error) { return bindataRead( @@ -364,12 +238,12 @@ func keysWnodekey() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "keys/wnodekey", size: 65, mode: os.FileMode(420), modTime: time.Unix(1494845997, 0)} + info := bindataFileInfo{name: "keys/wnodekey", size: 65, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _keysWnodepassword = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x4a\x2c\x4e\x49\x03\x61\x2e\x40\x00\x00\x00\xff\xff\xc7\x84\xee\x6f\x09\x00\x00\x00") +var _keysWnodepassword = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4a\x2c\x4e\x49\x03\x61\x2e\x40\x00\x00\x00\xff\xff\xc7\x84\xee\x6f\x09\x00\x00\x00") func keysWnodepasswordBytes() ([]byte, error) { return bindataRead( @@ -384,12 +258,12 @@ func keysWnodepassword() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "keys/wnodepassword", size: 9, mode: os.FileMode(420), modTime: time.Unix(1494845997, 0)} + info := bindataFileInfo{name: "keys/wnodepassword", size: 9, mode: os.FileMode(420), modTime: time.Unix(1498222808, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailCommandsJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xec\x59\xdd\x73\xdb\xb8\x11\x7f\xd7\x5f\x81\xf0\x1a\x47\x4c\x64\x8a\x8a\xe3\x38\xa6\x47\xd3\x71\x5c\x77\x92\xe9\x25\x71\x23\x27\xbe\xab\xab\xcb\x40\xe4\x8a\x44\x4d\x02\x0c\x00\x5a\xfe\x38\xfd\xef\x1d\xf0\x13\xfc\x92\xec\xbb\x3c\xf4\xa1\x7c\x89\x05\x2c\x16\x8b\xc5\x6f\x7f\xbb\x8b\x08\x89\x65\x22\x2c\x97\x45\x11\xa6\xde\xf0\x7e\x80\x10\x42\x14\x47\xe0\x20\x23\x64\x2e\x96\x84\x51\x63\x94\x8e\x7a\x20\x5c\x4e\x62\x35\xe2\x20\x63\x06\xd4\x43\x0d\x09\x97\x85\x8c\x3b\xc8\xf8\xe9\x10\xef\x7b\xee\x32\x1f\x8d\x39\x5c\x13\x58\x39\x68\x99\x50\x57\x49\xa3\x61\x8c\x39\x8e\x84\x89\xb2\xed\xd4\x77\x8d\x39\x92\x70\x23\xd1\x14\x55\x26\xc5\x8c\x02\x95\xc2\x52\x13\xc3\x52\x54\x7d\xf7\xb5\x5f\xea\x13\xf2\x36\x04\xa7\x63\x42\x7d\x11\xe6\x3e\xa1\xe7\x2c\x76\xd0\xfe\x68\x83\xc4\x3b\xc6\xc9\x1d\xa3\x12\x87\x0e\xb2\xbb\x05\x97\x8c\xca\x19\xb9\x03\x07\x4d\x5e\xf5\x4b\xfc\x1d\x47\x24\xbc\x75\x90\xa1\x7e\x18\xdd\x72\x85\xb7\x16\x21\x76\xaf\x8c\x96\xc8\xba\x36\xb2\x1e\xa1\xcc\x69\xd6\x35\x0e\x13\x30\x8f\x6a\x9e\x4b\x38\x41\x53\x64\x04\x52\xc6\xc2\x19\x8f\x23\x1c\x0b\xcb\x67\xcc\x0f\x01\xc7\x24\x75\x65\x3a\x36\xc6\x31\x19\x2b\xf7\x12\x37\xc2\xf1\x5f\x5d\xa0\x12\xf8\xb4\xbe\xf5\x8b\xda\x3e\x8d\x29\x63\x47\x90\x3b\x98\x4e\x6c\xfb\x66\x62\xdb\x3b\x11\x8e\xe5\x6d\x0c\x53\xce\xb0\x17\xe1\x78\xe7\x0a\x6e\xa7\xc7\xef\xef\xf0\xec\xf6\xed\x47\xf1\x9f\xc9\x77\xf6\xcf\xd3\x5f\xcf\x16\x7b\xef\xc3\x30\xba\xf8\x70\x2c\xdc\xe4\x97\x0b\x1b\x20\xf9\xf5\xfb\xf1\xf1\x4e\x88\xa9\x9f\x60\x1f\xa6\x40\x9b\x06\x18\x3b\x11\xe6\x57\xc0\xc5\x54\xed\xe6\x44\xc4\x7b\x7a\x70\x92\x79\xcb\xbe\x59\x2e\x6d\xdb\xb6\x9f\x1e\x9c\x84\x78\x01\xa1\xf3\xf4\xe0\x64\x93\xfd\x47\x83\x9a\x9f\x48\x84\x7d\xe8\x84\x58\x3a\xb3\x15\x63\x2c\xe1\xae\x02\x59\xc2\x89\xa3\x9c\xbe\x6e\xdf\xec\x46\x1c\xae\x88\x27\x03\x07\x4d\xec\x1e\x70\x05\x40\xfc\x40\xa6\x02\xdb\xf0\x50\xfe\x32\xb5\x33\x72\x90\x09\xa7\x1d\xc7\x53\x01\x38\xbc\x5f\x8f\xd0\xa5\x8a\xa5\x51\xe6\x88\x79\x8e\xa2\xf5\x60\x6d\x5a\xa9\xd7\xea\xf1\x8f\x3d\x8f\x83\x10\x39\x7c\xd5\x4d\x3b\x85\x6a\xf5\x43\x58\xe7\xa7\xbf\x9c\xe7\x31\x1e\x62\x17\x02\x16\x7a\xa0\x10\x7d\x9c\x2f\x1c\xac\x95\x71\xca\xf1\x71\xc0\x28\x08\x34\x45\x97\x83\xba\x6b\x69\x12\x2d\xd2\x35\x6f\x0e\x27\x07\x93\xec\xd3\xe2\xa5\xce\x39\x1f\x53\x61\xb4\x64\x3c\xc2\x12\x4d\xb2\x8b\xcf\xef\xa0\x53\xe5\xde\x8f\x56\xf9\xe2\xe0\xd1\x66\xbe\xdc\xa6\xf3\xd1\x1a\xf7\x72\x8d\x83\xf9\xd1\x60\x50\x92\xaa\x48\x7c\x1f\x84\xfa\x53\x9c\x28\x0a\x23\x14\xf8\x4c\x81\x71\x58\x9b\x49\xa8\x2c\x78\x37\x47\x4b\x65\x52\x46\x82\x5f\x81\x4b\xe2\x2a\x0a\x9c\x8c\x1a\x53\x3d\xfc\x58\xc0\xf6\x03\x96\x81\x15\x11\x3a\x9c\xec\xdb\x23\x34\xdc\x7f\x8d\x9e\xa3\xd6\xe6\x66\xb5\x6e\x81\xdd\x2b\x9f\xb3\x84\x7a\x27\x39\x17\xae\x02\x22\x41\x73\xc3\x82\x71\x0f\xf8\x67\xec\x91\x44\x38\x68\x3f\x3b\xf7\xd1\x60\x9d\xa1\xaa\xd2\x5d\x3f\x31\x9a\xe6\x87\x8a\xb1\xe7\x11\xea\xff\x0c\x4b\x15\x54\xaf\x33\xbd\x7d\xbb\x0e\xd6\x47\x4d\xb5\xb3\x64\xd1\xa3\xb9\x38\xf2\x7e\xa1\x34\x35\xf4\x2d\x93\x92\x45\x17\x79\x94\xb7\x67\x8a\x0d\x7f\xb2\xd3\x6f\xb2\xac\x36\x4d\xe9\xaa\xbe\x87\x96\xb5\x0e\x33\x5d\xed\xe4\xd3\x97\x6c\xdc\xfa\x4e\x9e\x76\x3c\x0d\x5a\xbd\xfb\x4d\xac\xfd\x3f\xbc\xe3\x9b\xbd\x37\xee\xe1\x5e\xb1\x63\x85\x4f\x89\xb9\x14\x17\x44\x06\x43\x21\xf9\x64\x84\x84\xe4\x2f\x0b\x28\x8e\xc7\x68\x26\x39\xa1\xbe\xa5\x89\x59\x96\x65\x22\x8f\x81\xa0\xcf\x24\x5a\x31\x7e\x85\x08\x45\xca\x8f\x83\x1a\xd7\xf1\x89\x15\x62\x21\xdf\x53\x0f\x6e\x3e\x2d\x95\xf2\x97\x23\x64\x9b\x68\x3a\x45\x36\xda\xd9\x49\x25\xd0\x93\x69\xba\x5f\x0a\x9d\xd2\xa4\x94\x95\x66\x15\x40\x1b\x75\x49\x46\x5c\x23\x1d\xc2\x19\x61\x92\x25\x1a\x3e\xd1\xd3\x0c\xfa\xfd\xf7\x5a\xda\x51\x7b\x1b\x86\x5e\xdf\xc4\x01\x9a\xe6\x2c\x98\x93\x2e\x82\x50\x40\xb7\x84\xb5\x24\xa1\x04\x3e\xd4\x0a\x26\x35\x6e\x36\xb2\x4a\xc5\xf6\x85\xc7\x52\x31\x2b\x63\x96\xde\x82\x61\x5d\xd2\x7e\x79\x98\x38\xb0\x42\xa0\xbe\x0c\x52\xa7\xe9\xfb\x64\x7b\xd4\x16\x68\xee\x48\x2d\xb6\x22\x1c\x6f\x32\xb5\x37\x29\x49\x96\xb8\x01\x5e\x84\xcd\xbc\xcb\xe8\x99\x4a\x1f\x0e\xba\xcc\xd7\xc0\x75\x2a\x3f\x3b\x3d\xff\xf6\xf5\xf8\xe7\x2f\xa7\x23\xa4\x1f\x74\xde\xc8\xc2\x3d\xd9\xaf\x8f\x2c\xda\x99\xf8\x72\xab\x86\x16\x2f\x74\xa7\xf3\xcb\xce\xd1\x6e\x1b\xdb\x35\x6e\xf3\xbb\xcf\x4b\x8b\x8a\x29\x3a\xca\x0f\xfd\xd3\x9d\xd4\x2b\x68\xf6\xeb\xf8\x33\x46\x36\x49\xe6\x41\xa6\x6a\x8b\xfa\xed\xed\x9c\x99\x9b\x73\x53\xaf\x88\x50\x8e\xf3\x32\x8e\xd5\x05\x76\x16\x7e\xc2\xe5\x2c\x0c\xbf\xaa\xfb\x2d\x15\xf4\xa7\xd2\x32\x50\x34\xb7\x69\xd2\x03\xa4\x15\x64\x45\x7a\x55\xc5\x6c\x12\x3b\xa9\x09\x55\xee\x4a\x4f\x7c\xc2\xe8\x92\xf8\x25\x01\xe7\x75\x57\x3a\xd5\xdf\x74\xa5\xd3\x79\xf9\xd0\xe4\xde\xfd\xa5\xfb\xea\x8d\x97\x8f\x5e\xe3\x90\x78\x58\xaa\x99\x4d\xad\x57\xab\x0c\xd0\xd6\x12\x46\xdf\x61\xea\x85\x69\xa1\xa2\xdb\x55\x5e\x9c\x52\x07\x12\xb8\x0a\x57\x9d\x70\xe6\x15\xdf\x1c\xe9\x05\x50\x26\xe3\xa0\x4b\xad\x12\x6a\x1f\x1b\x75\x17\x9c\x67\xef\x3e\x7d\x3c\xed\xf4\xbc\xd3\x22\xf3\x4a\xac\x5e\x9c\x9e\xe9\xee\xcb\x2c\x9b\x67\xb2\x41\x71\xd2\x47\x7b\x2b\x25\x28\x07\x19\x82\xf8\x74\x37\x89\xbb\x7c\xb4\xdd\x3f\x2a\x5d\xe6\xa7\xe5\x20\x62\x46\x05\x0c\x35\x94\x98\xe5\x6c\xd1\xac\xd7\x27\x9b\xb3\x35\x48\x05\x10\xc6\x9d\x88\x7a\x57\x4d\x94\x20\x3a\xb0\x0f\x0f\xe1\x75\x3e\x3a\x7e\x8e\xbe\x16\x38\x42\x70\x83\xa3\x38\xcc\xbb\xc2\x87\xc0\x2b\x4d\x2e\x7a\x62\x7c\x32\x45\xc6\x5e\x95\x19\x55\x24\x00\xe7\x8c\x77\xc6\xe6\x75\x15\x95\xf7\xed\xaa\x8d\x83\x67\x14\xb4\xd2\x41\xd9\x29\x57\xa9\x96\xc7\x60\x8c\xc5\x02\x39\x43\xc3\xcc\x9d\x5e\x24\xc3\xe2\x2e\x53\x0b\xd4\x05\xa5\x7f\xcc\xf3\xde\xaa\xf8\x67\xf4\x7c\xbc\x05\xb9\xdf\x13\xe0\xb7\x9b\x91\xab\x5a\xa5\x1c\x6c\x59\x57\xd4\xbc\xe9\xda\x75\xb9\xea\x52\x55\xad\x4f\x18\xdd\x75\x99\x07\x1b\xaf\xa8\x7e\xa3\x27\xda\x5a\xa4\xad\xed\x37\x5f\x13\xea\xb1\xfe\xe3\x97\x0f\x6f\x4f\x3f\xff\xe0\x60\xc9\x0f\xb9\xfb\xa7\x82\xa6\x97\xe9\x0a\x6b\xaa\xbd\xc9\x72\xf8\x64\xfc\xdb\xe5\xbf\xbd\xf9\xfd\xab\xf5\x5f\xc6\x96\x04\x21\x6b\xe0\x34\xcd\x26\x07\x6e\x04\x67\xc9\x90\x1f\x40\x88\xd6\xeb\x81\xfa\x7a\xef\xa2\x26\x74\xc1\x19\xf5\xf3\xde\xae\xfe\x96\xa1\xb7\xf6\xdb\xf1\x5a\x42\x76\xfd\x00\x84\x5d\xc1\x6d\x8c\x49\x2b\x7f\x6c\xc0\xd5\x3f\xb2\x15\x28\xc6\x42\xac\x18\x2f\x92\x0c\x71\xd3\x59\xf5\xcf\xb7\x90\xb9\x57\xdf\xf4\x16\x6e\x03\xd9\xd7\xb5\xf4\xe0\xee\xec\x78\x36\xbb\xf8\xf4\xf9\x6f\x3f\x9a\xa6\xf1\x35\xec\x76\x58\xf0\x68\xdc\x3d\xe8\x69\xb3\xbf\xfe\xfd\xff\xb3\xa6\xa2\xe7\xe7\xea\x33\xb4\xb7\x28\xbd\x6b\x5c\xe1\x30\x04\x99\x96\x67\x75\xcf\x76\x66\x16\xa3\xf9\xa4\x9c\xf0\x50\xf5\x28\xb5\x17\xc1\x62\x3e\xed\xe2\xc6\xbf\x5d\xe2\xdd\xbb\xe3\xdd\x7f\xed\x7e\x9b\xbf\x70\x72\x52\x48\x78\x68\x36\x9b\xad\x4c\xd3\xb3\x40\xca\xd8\x19\x8f\x9f\xa1\x17\x6a\x44\x6b\xaa\x5a\x8f\x70\xf7\x2b\x58\x28\xbb\xbf\xf0\xd0\x51\xb2\x55\x9a\xdf\x9c\xaa\x17\x9c\xad\x44\x77\xf9\x97\x4d\xb5\x82\x76\xb9\xc4\xfb\xb6\x9d\x8f\x2e\x93\x30\x14\x2e\x07\xa0\x0e\x92\x3c\xc9\x3b\x13\xad\x52\x3a\xe7\xc4\xf7\x55\xf8\x3c\x63\x74\x57\x00\xf5\x9e\x6d\x8b\xd5\x15\x2c\x62\xec\xeb\xdc\x55\x2b\xbc\xaa\x2b\x7a\x5c\x06\x2c\xef\x38\x67\x52\x78\x8b\x43\x4c\x5d\x68\x5c\xb4\xe4\xb7\x8d\x4b\xbd\xc6\xea\x2a\x56\xb0\xd8\xb3\x24\xbb\x00\x52\xc3\xc1\x08\x19\x20\x03\xe0\x25\xa0\x90\x8b\xa5\x1b\xa0\x21\x70\xbe\x9d\x20\x0a\x62\xed\x88\xc3\x3f\xc0\xff\xea\x33\x8e\x23\x96\xf4\x06\x4b\x3e\x8b\x88\x40\x94\xc9\xcc\x13\x45\x6d\x3a\x1e\x03\xe7\x56\x94\x29\x6f\xad\xae\xf7\x41\x1d\xd5\x64\xd9\xfa\x2c\x32\xb7\x16\x2e\x03\x19\x58\x3e\xc8\xba\xb3\x0b\x28\x5a\xf9\x9b\xaf\x59\x3d\x74\x2c\xe8\xf0\x1a\x87\xa6\xe5\x73\xc0\x12\xf8\x79\x80\xa9\x1a\xcb\xb5\x9a\xe6\xff\xa0\x53\x3f\x32\x89\x80\xb2\xc4\x0f\xd0\xe9\xf9\x3b\xc4\x68\xe9\x83\x61\x9b\x90\x50\xfa\x9f\x06\xa9\x6b\x96\x9c\x45\x0a\x4f\xb9\x74\x05\xa5\x9e\x45\x86\x52\x6f\xb6\x55\x6e\xbd\x1b\xfd\x11\x4a\x85\xe0\x39\xc7\x54\xe0\x5a\xdd\xa2\xbd\x41\x79\x58\xe2\xb2\x47\x54\x9f\xb2\xd3\x41\x8d\x9b\x53\x83\x5a\x00\xb2\x96\x80\x64\x23\x2d\x8c\xc2\x04\x9c\xed\x31\x34\xd0\xcc\x56\xa6\x04\x58\x04\x3a\x90\x9a\xc6\x2b\x53\x9b\xfd\xaf\x21\x2b\x81\x5d\xa5\xc0\x70\x52\x3d\x59\x2f\xbc\x89\x0a\x95\xf6\x8d\x1d\x6e\x47\x77\xac\x6d\xb6\xb5\x08\xc1\x4d\x14\x3d\xac\xf4\xfd\xe1\x59\x7f\xdd\x55\x82\xe4\x69\x2d\x47\x59\x05\x32\xb3\x56\x81\x94\xc5\x50\xe3\x26\x5a\x75\x71\x83\x64\x53\x0a\xfe\x6f\x00\x00\x00\xff\xff\xa3\x78\x8b\xab\xfd\x1d\x00\x00") +var _testdataJailCommandsJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x59\xdd\x73\xdb\xb8\x11\x7f\xd7\x5f\x81\xf0\x1a\x47\x4c\x64\x8a\x8a\xe3\x38\xa6\x47\xd3\x71\x5c\x77\x92\xe9\x25\x71\x23\x27\xbe\xab\xab\xcb\x40\xe4\x8a\x44\x4d\x02\x0c\x00\x5a\xfe\x38\xfd\xef\x1d\xf0\x13\xfc\x92\xec\xbb\x3c\xf4\xa1\x7c\x89\x05\x2c\x16\x8b\xc5\x6f\x7f\xbb\x8b\x08\x89\x65\x22\x2c\x97\x45\x11\xa6\xde\xf0\x7e\x80\x10\x42\x14\x47\xe0\x20\x23\x64\x2e\x96\x84\x51\x63\x94\x8e\x7a\x20\x5c\x4e\x62\x35\xe2\x20\x63\x06\xd4\x43\x0d\x09\x97\x85\x8c\x3b\xc8\xf8\xe9\x10\xef\x7b\xee\x32\x1f\x8d\x39\x5c\x13\x58\x39\x68\x99\x50\x57\x49\xa3\x61\x8c\x39\x8e\x84\x89\xb2\xed\xd4\x77\x8d\x39\x92\x70\x23\xd1\x14\x55\x26\xc5\x8c\x02\x95\xc2\x52\x13\xc3\x52\x54\x7d\xf7\xb5\x5f\xea\x13\xf2\x36\x04\xa7\x63\x42\x7d\x11\xe6\x3e\xa1\xe7\x2c\x76\xd0\xfe\x68\x83\xc4\x3b\xc6\xc9\x1d\xa3\x12\x87\x0e\xb2\xbb\x05\x97\x8c\xca\x19\xb9\x03\x07\x4d\x5e\xf5\x4b\xfc\x1d\x47\x24\xbc\x75\x90\xa1\x7e\x18\xdd\x72\x85\xb7\x16\x21\x76\xaf\x8c\x96\xc8\xba\x36\xb2\x1e\xa1\xcc\x69\xd6\x35\x0e\x13\x30\x8f\x6a\x9e\x4b\x38\x41\x53\x64\x04\x52\xc6\xc2\x19\x8f\x23\x1c\x0b\xcb\x67\xcc\x0f\x01\xc7\x24\x75\x65\x3a\x36\xc6\x31\x19\x2b\xf7\x12\x37\xc2\xf1\x5f\x5d\xa0\x12\xf8\xb4\xbe\xf5\x8b\xda\x3e\x8d\x29\x63\x47\x90\x3b\x98\x4e\x6c\xfb\x66\x62\xdb\x3b\x11\x8e\xe5\x6d\x0c\x53\xce\xb0\x17\xe1\x78\xe7\x0a\x6e\xa7\xc7\xef\xef\xf0\xec\xf6\xed\x47\xf1\x9f\xc9\x77\xf6\xcf\xd3\x5f\xcf\x16\x7b\xef\xc3\x30\xba\xf8\x70\x2c\xdc\xe4\x97\x0b\x1b\x20\xf9\xf5\xfb\xf1\xf1\x4e\x88\xa9\x9f\x60\x1f\xa6\x40\x9b\x06\x18\x3b\x11\xe6\x57\xc0\xc5\x54\xed\xe6\x44\xc4\x7b\x7a\x70\x92\x79\xcb\xbe\x59\x2e\x6d\xdb\xb6\x9f\x1e\x9c\x84\x78\x01\xa1\xf3\xf4\xe0\x64\x93\xfd\x47\x83\x9a\x9f\x48\x84\x7d\xe8\x84\x58\x3a\xb3\x15\x63\x2c\xe1\xae\x02\x59\xc2\x89\xa3\x9c\xbe\x6e\xdf\xec\x46\x1c\xae\x88\x27\x03\x07\x4d\xec\x1e\x70\x05\x40\xfc\x40\xa6\x02\xdb\xf0\x50\xfe\x32\xb5\x33\x72\x90\x09\xa7\x1d\xc7\x53\x01\x38\xbc\x5f\x8f\xd0\xa5\x8a\xa5\x51\xe6\x88\x79\x8e\xa2\xf5\x60\x6d\x5a\xa9\xd7\xea\xf1\x8f\x3d\x8f\x83\x10\x39\x7c\xd5\x4d\x3b\x85\x6a\xf5\x43\x58\xe7\xa7\xbf\x9c\xe7\x31\x1e\x62\x17\x02\x16\x7a\xa0\x10\x7d\x9c\x2f\x1c\xac\x95\x71\xca\xf1\x71\xc0\x28\x08\x34\x45\x97\x83\xba\x6b\x69\x12\x2d\xd2\x35\x6f\x0e\x27\x07\x93\xec\xd3\xe2\xa5\xce\x39\x1f\x53\x61\xb4\x64\x3c\xc2\x12\x4d\xb2\x8b\xcf\xef\xa0\x53\xe5\xde\x8f\x56\xf9\xe2\xe0\xd1\x66\xbe\xdc\xa6\xf3\xd1\x1a\xf7\x72\x8d\x83\xf9\xd1\x60\x50\x92\xaa\x48\x7c\x1f\x84\xfa\x53\x9c\x28\x0a\x23\x14\xf8\x4c\x81\x71\x58\x9b\x49\xa8\x2c\x78\x37\x47\x4b\x65\x52\x46\x82\x5f\x81\x4b\xe2\x2a\x0a\x9c\x8c\x1a\x53\x3d\xfc\x58\xc0\xf6\x03\x96\x81\x15\x11\x3a\x9c\xec\xdb\x23\x34\xdc\x7f\x8d\x9e\xa3\xd6\xe6\x66\xb5\x6e\x81\xdd\x2b\x9f\xb3\x84\x7a\x27\x39\x17\xae\x02\x22\x41\x73\xc3\x82\x71\x0f\xf8\x67\xec\x91\x44\x38\x68\x3f\x3b\xf7\xd1\x60\x9d\xa1\xaa\xd2\x5d\x3f\x31\x9a\xe6\x87\x8a\xb1\xe7\x11\xea\xff\x0c\x4b\x15\x54\xaf\x33\xbd\x7d\xbb\x0e\xd6\x47\x4d\xb5\xb3\x64\xd1\xa3\xb9\x38\xf2\x7e\xa1\x34\x35\xf4\x2d\x93\x92\x45\x17\x79\x94\xb7\x67\x8a\x0d\x7f\xb2\xd3\x6f\xb2\xac\x36\x4d\xe9\xaa\xbe\x87\x96\xb5\x0e\x33\x5d\xed\xe4\xd3\x97\x6c\xdc\xfa\x4e\x9e\x76\x3c\x0d\x5a\xbd\xfb\x4d\xac\xfd\x3f\xbc\xe3\x9b\xbd\x37\xee\xe1\x5e\xb1\x63\x85\x4f\x89\xb9\x14\x17\x44\x06\x43\x21\xf9\x64\x84\x84\xe4\x2f\x0b\x28\x8e\xc7\x68\x26\x39\xa1\xbe\xa5\x89\x59\x96\x65\x22\x8f\x81\xa0\xcf\x24\x5a\x31\x7e\x85\x08\x45\xca\x8f\x83\x1a\xd7\xf1\x89\x15\x62\x21\xdf\x53\x0f\x6e\x3e\x2d\x95\xf2\x97\x23\x64\x9b\x68\x3a\x45\x36\xda\xd9\x49\x25\xd0\x93\x69\xba\x5f\x0a\x9d\xd2\xa4\x94\x95\x66\x15\x40\x1b\x75\x49\x46\x5c\x23\x1d\xc2\x19\x61\x92\x25\x1a\x3e\xd1\xd3\x0c\xfa\xfd\xf7\x5a\xda\x51\x7b\x1b\x86\x5e\xdf\xc4\x01\x9a\xe6\x2c\x98\x93\x2e\x82\x50\x40\xb7\x84\xb5\x24\xa1\x04\x3e\xd4\x0a\x26\x35\x6e\x36\xb2\x4a\xc5\xf6\x85\xc7\x52\x31\x2b\x63\x96\xde\x82\x61\x5d\xd2\x7e\x79\x98\x38\xb0\x42\xa0\xbe\x0c\x52\xa7\xe9\xfb\x64\x7b\xd4\x16\x68\xee\x48\x2d\xb6\x22\x1c\x6f\x32\xb5\x37\x29\x49\x96\xb8\x01\x5e\x84\xcd\xbc\xcb\xe8\x99\x4a\x1f\x0e\xba\xcc\xd7\xc0\x75\x2a\x3f\x3b\x3d\xff\xf6\xf5\xf8\xe7\x2f\xa7\x23\xa4\x1f\x74\xde\xc8\xc2\x3d\xd9\xaf\x8f\x2c\xda\x99\xf8\x72\xab\x86\x16\x2f\x74\xa7\xf3\xcb\xce\xd1\x6e\x1b\xdb\x35\x6e\xf3\xbb\xcf\x4b\x8b\x8a\x29\x3a\xca\x0f\xfd\xd3\x9d\xd4\x2b\x68\xf6\xeb\xf8\x33\x46\x36\x49\xe6\x41\xa6\x6a\x8b\xfa\xed\xed\x9c\x99\x9b\x73\x53\xaf\x88\x50\x8e\xf3\x32\x8e\xd5\x05\x76\x16\x7e\xc2\xe5\x2c\x0c\xbf\xaa\xfb\x2d\x15\xf4\xa7\xd2\x32\x50\x34\xb7\x69\xd2\x03\xa4\x15\x64\x45\x7a\x55\xc5\x6c\x12\x3b\xa9\x09\x55\xee\x4a\x4f\x7c\xc2\xe8\x92\xf8\x25\x01\xe7\x75\x57\x3a\xd5\xdf\x74\xa5\xd3\x79\xf9\xd0\xe4\xde\xfd\xa5\xfb\xea\x8d\x97\x8f\x5e\xe3\x90\x78\x58\xaa\x99\x4d\xad\x57\xab\x0c\xd0\xd6\x12\x46\xdf\x61\xea\x85\x69\xa1\xa2\xdb\x55\x5e\x9c\x52\x07\x12\xb8\x0a\x57\x9d\x70\xe6\x15\xdf\x1c\xe9\x05\x50\x26\xe3\xa0\x4b\xad\x12\x6a\x1f\x1b\x75\x17\x9c\x67\xef\x3e\x7d\x3c\xed\xf4\xbc\xd3\x22\xf3\x4a\xac\x5e\x9c\x9e\xe9\xee\xcb\x2c\x9b\x67\xb2\x41\x71\xd2\x47\x7b\x2b\x25\x28\x07\x19\x82\xf8\x74\x37\x89\xbb\x7c\xb4\xdd\x3f\x2a\x5d\xe6\xa7\xe5\x20\x62\x46\x05\x0c\x35\x94\x98\xe5\x6c\xd1\xac\xd7\x27\x9b\xb3\x35\x48\x05\x10\xc6\x9d\x88\x7a\x57\x4d\x94\x20\x3a\xb0\x0f\x0f\xe1\x75\x3e\x3a\x7e\x8e\xbe\x16\x38\x42\x70\x83\xa3\x38\xcc\xbb\xc2\x87\xc0\x2b\x4d\x2e\x7a\x62\x7c\x32\x45\xc6\x5e\x95\x19\x55\x24\x00\xe7\x8c\x77\xc6\xe6\x75\x15\x95\xf7\xed\xaa\x8d\x83\x67\x14\xb4\xd2\x41\xd9\x29\x57\xa9\x96\xc7\x60\x8c\xc5\x02\x39\x43\xc3\xcc\x9d\x5e\x24\xc3\xe2\x2e\x53\x0b\xd4\x05\xa5\x7f\xcc\xf3\xde\xaa\xf8\x67\xf4\x7c\xbc\x05\xb9\xdf\x13\xe0\xb7\x9b\x91\xab\x5a\xa5\x1c\x6c\x59\x57\xd4\xbc\xe9\xda\x75\xb9\xea\x52\x55\xad\x4f\x18\xdd\x75\x99\x07\x1b\xaf\xa8\x7e\xa3\x27\xda\x5a\xa4\xad\xed\x37\x5f\x13\xea\xb1\xfe\xe3\x97\x0f\x6f\x4f\x3f\xff\xe0\x60\xc9\x0f\xb9\xfb\xa7\x82\xa6\x97\xe9\x0a\x6b\xaa\xbd\xc9\x72\xf8\x64\xfc\xdb\xe5\xbf\xbd\xf9\xfd\xab\xf5\x5f\xc6\x96\x04\x21\x6b\xe0\x34\xcd\x26\x07\x6e\x04\x67\xc9\x90\x1f\x40\x88\xd6\xeb\x81\xfa\x7a\xef\xa2\x26\x74\xc1\x19\xf5\xf3\xde\xae\xfe\x96\xa1\xb7\xf6\xdb\xf1\x5a\x42\x76\xfd\x00\x84\x5d\xc1\x6d\x8c\x49\x2b\x7f\x6c\xc0\xd5\x3f\xb2\x15\x28\xc6\x42\xac\x18\x2f\x92\x0c\x71\xd3\x59\xf5\xcf\xb7\x90\xb9\x57\xdf\xf4\x16\x6e\x03\xd9\xd7\xb5\xf4\xe0\xee\xec\x78\x36\xbb\xf8\xf4\xf9\x6f\x3f\x9a\xa6\xf1\x35\xec\x76\x58\xf0\x68\xdc\x3d\xe8\x69\xb3\xbf\xfe\xfd\xff\xb3\xa6\xa2\xe7\xe7\xea\x33\xb4\xb7\x28\xbd\x6b\x5c\xe1\x30\x04\x99\x96\x67\x75\xcf\x76\x66\x16\xa3\xf9\xa4\x9c\xf0\x50\xf5\x28\xb5\x17\xc1\x62\x3e\xed\xe2\xc6\xbf\x5d\xe2\xdd\xbb\xe3\xdd\x7f\xed\x7e\x9b\xbf\x70\x72\x52\x48\x78\x68\x36\x9b\xad\x4c\xd3\xb3\x40\xca\xd8\x19\x8f\x9f\xa1\x17\x6a\x44\x6b\xaa\x5a\x8f\x70\xf7\x2b\x58\x28\xbb\xbf\xf0\xd0\x51\xb2\x55\x9a\xdf\x9c\xaa\x17\x9c\xad\x44\x77\xf9\x97\x4d\xb5\x82\x76\xb9\xc4\xfb\xb6\x9d\x8f\x2e\x93\x30\x14\x2e\x07\xa0\x0e\x92\x3c\xc9\x3b\x13\xad\x52\x3a\xe7\xc4\xf7\x55\xf8\x3c\x63\x74\x57\x00\xf5\x9e\x6d\x8b\xd5\x15\x2c\x62\xec\xeb\xdc\x55\x2b\xbc\xaa\x2b\x7a\x5c\x06\x2c\xef\x38\x67\x52\x78\x8b\x43\x4c\x5d\x68\x5c\xb4\xe4\xb7\x8d\x4b\xbd\xc6\xea\x2a\x56\xb0\xd8\xb3\x24\xbb\x00\x52\xc3\xc1\x08\x19\x20\x03\xe0\x25\xa0\x90\x8b\xa5\x1b\xa0\x21\x70\xbe\x9d\x20\x0a\x62\xed\x88\xc3\x3f\xc0\xff\xea\x33\x8e\x23\x96\xf4\x06\x4b\x3e\x8b\x88\x40\x94\xc9\xcc\x13\x45\x6d\x3a\x1e\x03\xe7\x56\x94\x29\x6f\xad\xae\xf7\x41\x1d\xd5\x64\xd9\xfa\x2c\x32\xb7\x16\x2e\x03\x19\x58\x3e\xc8\xba\xb3\x0b\x28\x5a\xf9\x9b\xaf\x59\x3d\x74\x2c\xe8\xf0\x1a\x87\xa6\xe5\x73\xc0\x12\xf8\x79\x80\xa9\x1a\xcb\xb5\x9a\xe6\xff\xa0\x53\x3f\x32\x89\x80\xb2\xc4\x0f\xd0\xe9\xf9\x3b\xc4\x68\xe9\x83\x61\x9b\x90\x50\xfa\x9f\x06\xa9\x6b\x96\x9c\x45\x0a\x4f\xb9\x74\x05\xa5\x9e\x45\x86\x52\x6f\xb6\x55\x6e\xbd\x1b\xfd\x11\x4a\x85\xe0\x39\xc7\x54\xe0\x5a\xdd\xa2\xbd\x41\x79\x58\xe2\xb2\x47\x54\x9f\xb2\xd3\x41\x8d\x9b\x53\x83\x5a\x00\xb2\x96\x80\x64\x23\x2d\x8c\xc2\x04\x9c\xed\x31\x34\xd0\xcc\x56\xa6\x04\x58\x04\x3a\x90\x9a\xc6\x2b\x53\x9b\xfd\xaf\x21\x2b\x81\x5d\xa5\xc0\x70\x52\x3d\x59\x2f\xbc\x89\x0a\x95\xf6\x8d\x1d\x6e\x47\x77\xac\x6d\xb6\xb5\x08\xc1\x4d\x14\x3d\xac\xf4\xfd\xe1\x59\x7f\xdd\x55\x82\xe4\x69\x2d\x47\x59\x05\x32\xb3\x56\x81\x94\xc5\x50\xe3\x26\x5a\x75\x71\x83\x64\x53\x0a\xfe\x6f\x00\x00\x00\xff\xff\xa3\x78\x8b\xab\xfd\x1d\x00\x00") func testdataJailCommandsJsBytes() ([]byte, error) { return bindataRead( @@ -404,12 +278,12 @@ func testdataJailCommandsJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/commands.js", size: 7677, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/commands.js", size: 7677, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailStatusJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\xb4\x56\xdf\x6f\xdb\xb6\x13\x7f\xf7\x5f\x71\xf5\x43\xe3\x02\xb6\xf1\xcd\x17\x43\x81\xd1\xf0\x43\x97\x65\x18\x86\x36\x19\x62\xb7\x1b\x60\x18\x01\x2d\x9d\x25\x76\x32\x29\x90\x94\xdd\x2c\xf5\xff\x3e\x90\x22\x45\x52\x72\x8a\xf5\x61\x7a\xb0\xc9\xbb\xcf\xfd\xe2\x1d\xef\x78\xa4\x12\x1e\x95\xa6\xba\x51\x8f\x19\xd5\xb4\x12\x05\x2c\xe1\x79\x04\x00\x90\x89\xc3\x81\xf2\x5c\x11\x78\x3e\x4f\x2d\x45\xa2\xaa\x05\x57\x68\x49\xa3\xf3\x62\x34\xda\x37\x3c\xd3\x4c\x70\xb8\x69\xc1\x93\x37\xf0\x3c\x3a\x07\xf2\x83\x93\x70\xf4\x91\x83\xcd\x6b\x29\xb4\xd0\x4f\x35\xce\x69\x9e\xaf\xc5\x4d\x67\xba\x93\xb4\x12\xc6\x68\xcf\xbd\xb9\x77\x6b\xa3\x4b\xa6\xe6\x9c\x1e\x70\x0b\x4b\x30\x9b\x85\x75\x69\x68\xa2\xa6\x92\x1e\x12\xdd\x96\x82\x1a\xa5\x37\x62\x75\x59\xaa\x9a\xd7\x8d\x2a\x23\xc4\x62\xe4\x62\xd7\x8d\xe4\xdf\xb4\x93\x49\xa4\x1a\x13\x43\x99\x38\x24\x26\x8c\xbb\xb0\x34\x47\x6b\x97\x8b\xc0\xc9\x51\x65\x92\xd5\x56\xac\x05\x44\x94\x08\x57\x52\x9e\x57\x28\x1d\xc6\xed\x02\x7f\x33\x2e\xa9\x9a\x39\xf2\x78\x9b\xc2\xe0\xd5\x12\x78\x53\x55\x91\xba\x23\xad\x58\x4e\xb5\xf0\x0a\xbb\x7d\x84\xc9\x44\xd5\xf1\xed\x3a\xe2\xb1\xac\xf3\xd7\x2c\x17\xfd\xd3\x74\x3c\xb7\xf9\xfa\x15\x36\xdb\x18\x23\xf1\xc8\xf0\xe4\x41\xed\x2e\x0e\x46\x35\x45\x81\xca\x1c\x81\x9a\x69\xc9\x8a\x22\x0a\x2a\xe2\xad\x5b\x96\xd1\x3f\x16\x7c\x96\x95\x94\x17\x38\x8e\x0c\xed\x9b\xaa\x52\x99\x44\xf4\xce\x06\x42\x84\x8a\x6b\x71\xf2\x62\xe2\x47\xbe\xa8\x43\xea\x61\x09\xf7\xbb\xcf\x98\x69\x57\x03\x93\x41\x71\xbc\x59\x5c\x10\xfb\xfe\xe2\xef\x6e\xe0\x0b\xd5\x7f\xc1\x86\xe0\x0f\x98\x21\x3b\xa2\xe7\x25\x86\x5c\x65\x24\x45\xda\x49\xc0\x12\xba\x02\x4b\x6e\x7b\x46\xab\x6a\x52\x53\x5d\xae\xb4\x9c\x42\x9b\xdc\x95\xee\xb4\x98\xae\xd2\xa5\xff\xb7\xd5\xfd\x9d\xc9\xbf\xc2\x49\x00\xb6\xfd\xc4\x7c\x46\x4b\x1f\x65\xf5\x46\x98\x3d\x9f\x9a\xde\xe3\x12\xb2\x37\x39\x34\xa0\xb9\xc4\xbc\xc9\x70\x12\x5d\xb7\xf6\x98\xa6\x60\x0e\xc6\x7b\xe3\x3f\xb6\xef\x00\xf0\xfa\x35\xb8\xe5\xc6\x9e\x61\x1f\x1b\x25\x3e\xc1\x2d\x12\xd4\xb9\xdb\x9d\x83\xb3\xbd\x94\x59\xba\xaf\x25\xe3\xc2\xab\x3d\x8f\xad\x39\x2b\xe1\x5a\x9e\x7d\xd9\x99\xc3\xdb\x73\x77\x68\xbd\x6a\xb4\xc7\xa5\xb4\x64\xbc\x60\xfb\xa7\x89\x44\x03\x38\x47\x19\xd2\xf8\x45\x4f\x84\x6d\x1e\x6a\x0a\xca\x5b\x74\xe2\x9b\x2b\xc3\xbf\x9a\x42\x40\x6c\x53\x79\x73\x11\x83\x3c\x56\x78\x40\xae\x87\x6a\x0c\x2c\xa8\xd9\xce\x33\xc1\x33\xaa\x27\x1d\x3e\x55\xca\x0e\xb4\x40\xaf\x75\xa0\xcb\x72\x23\x65\xbd\x80\x44\x93\x95\x74\x57\xe1\xc0\xab\x61\x6c\x1e\x1a\x07\xe8\xc0\x3d\xad\x2a\x93\xa2\xaa\x3e\xfd\xbb\x60\x5b\xf0\xec\xfb\x62\x3e\xe1\xce\xaa\x6f\x64\x35\x50\x78\xc2\x9d\xd7\x16\x0a\x42\x89\x46\x66\x48\x7a\x05\xd9\x48\x46\xa0\x91\xd5\xa5\x8a\xfb\x4c\x8f\x74\x65\x47\xc5\x2d\x37\x61\xe7\x04\xb4\x6c\xb0\xad\xa6\x7e\x5e\xdb\xfe\xce\x04\xff\x80\x4a\x99\x74\x68\xa6\x2b\x5c\xe3\x17\x3d\x85\x68\xe2\x18\x42\x7c\x9d\x2d\x6a\xa5\x9f\x2a\xec\xde\x07\xed\x1b\xa1\x12\x92\xc0\xf8\x54\x32\x8d\xe3\xe8\xc6\x0a\xae\x57\xec\x6f\x24\x70\xfd\xff\x94\xfa\x0b\x3d\xb0\xea\x89\xc0\x58\x51\xae\x66\x0a\x25\xdb\x8f\x5b\x4f\x17\xa9\x31\x58\x42\x7b\x93\xcc\xc4\xaf\x05\x37\x67\x3b\xb7\x65\x1d\x7c\x99\x42\xe7\xbd\xbf\x20\x46\x3e\x8a\xe3\xbf\x72\x39\x20\x44\x4d\x33\xa6\x9f\x08\xfc\x6f\xfe\x63\x3f\x90\x74\xa8\xbf\x10\x4e\xdf\xdb\x61\x1e\xd2\xbb\x3f\x54\x63\x2f\x6b\xe7\x50\x5a\x38\x3b\x9a\xfd\x55\x48\xd1\xf0\xfc\xc6\x05\x2e\x31\x8f\xdc\x37\x5f\x89\xac\x28\x35\x81\xb7\xd7\x29\xbd\xa6\x79\xce\x78\xf1\x1e\xf7\x9a\xc0\xf5\xdb\x8b\xcc\xb5\xa8\x09\x5c\xff\x30\xbd\x54\x98\x1b\x9b\x9d\x24\x9e\xad\xef\x87\xe7\xd1\xc8\x9c\x50\x1b\x4c\xff\xcd\x49\xe2\x09\x15\x77\x4b\x23\xe2\x30\xb0\x04\x8e\xa7\xf0\xf0\x5c\xf4\x5b\xaa\xc3\xf9\x91\x5c\x3a\x44\xef\x2d\xfb\x4d\x53\x32\x8c\x4c\x63\x2b\xbc\x66\x07\xc6\x3c\xf2\x05\x6b\xb4\xd1\x42\x36\x9c\xa4\x4f\x43\xe3\xde\x5d\x6f\x52\xf5\x27\xbe\x93\x6c\x9f\x2d\x5e\x20\xd1\x6d\xa6\xbc\x8a\xfb\xc5\xfa\xf6\xcf\x35\x01\xd7\xe2\x3b\xea\xdd\xc7\x0f\x3f\xdd\x3e\x10\xb8\xe2\xcd\x61\x87\x32\xe2\xfc\xfe\xeb\xfd\xdd\x2d\x81\xab\xba\x14\x1c\x63\xfa\xbb\xd5\xea\x8f\xfb\x87\x9f\x0d\x8b\x2a\x75\x12\x32\xbf\x8a\x0d\xe3\xd1\x54\x5f\x6c\x79\x75\xbb\x7e\xfc\xf4\xee\xfd\x47\xa3\x4d\xa1\x9e\x1d\x69\xd5\x60\x22\x13\xaa\x36\x96\x33\x05\x4c\xec\x6f\xb0\x6e\xdc\x27\xf6\x37\xd0\xec\x88\x20\xed\x5f\x84\xf4\xfd\x9e\x84\x65\xe0\x86\x16\x4f\xa2\x75\xe0\xbb\x06\x4d\xfc\x62\x1a\x55\x40\xaf\x57\x92\x21\xc9\x8d\xec\xf3\xe2\x9f\x00\x00\x00\xff\xff\x59\x9d\x9d\x6a\x4a\x0d\x00\x00") +var _testdataJailStatusJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x56\xdf\x6f\xdb\xb6\x13\x7f\xf7\x5f\x71\xf5\x43\xe3\x02\xb6\xf1\xcd\x17\x43\x81\xd1\xf0\x43\x97\x65\x18\x86\x36\x19\x62\xb7\x1b\x60\x18\x01\x2d\x9d\x25\x76\x32\x29\x90\x94\xdd\x2c\xf5\xff\x3e\x90\x22\x45\x52\x72\x8a\xf5\x61\x7a\xb0\xc9\xbb\xcf\xfd\xe2\x1d\xef\x78\xa4\x12\x1e\x95\xa6\xba\x51\x8f\x19\xd5\xb4\x12\x05\x2c\xe1\x79\x04\x00\x90\x89\xc3\x81\xf2\x5c\x11\x78\x3e\x4f\x2d\x45\xa2\xaa\x05\x57\x68\x49\xa3\xf3\x62\x34\xda\x37\x3c\xd3\x4c\x70\xb8\x69\xc1\x93\x37\xf0\x3c\x3a\x07\xf2\x83\x93\x70\xf4\x91\x83\xcd\x6b\x29\xb4\xd0\x4f\x35\xce\x69\x9e\xaf\xc5\x4d\x67\xba\x93\xb4\x12\xc6\x68\xcf\xbd\xb9\x77\x6b\xa3\x4b\xa6\xe6\x9c\x1e\x70\x0b\x4b\x30\x9b\x85\x75\x69\x68\xa2\xa6\x92\x1e\x12\xdd\x96\x82\x1a\xa5\x37\x62\x75\x59\xaa\x9a\xd7\x8d\x2a\x23\xc4\x62\xe4\x62\xd7\x8d\xe4\xdf\xb4\x93\x49\xa4\x1a\x13\x43\x99\x38\x24\x26\x8c\xbb\xb0\x34\x47\x6b\x97\x8b\xc0\xc9\x51\x65\x92\xd5\x56\xac\x05\x44\x94\x08\x57\x52\x9e\x57\x28\x1d\xc6\xed\x02\x7f\x33\x2e\xa9\x9a\x39\xf2\x78\x9b\xc2\xe0\xd5\x12\x78\x53\x55\x91\xba\x23\xad\x58\x4e\xb5\xf0\x0a\xbb\x7d\x84\xc9\x44\xd5\xf1\xed\x3a\xe2\xb1\xac\xf3\xd7\x2c\x17\xfd\xd3\x74\x3c\xb7\xf9\xfa\x15\x36\xdb\x18\x23\xf1\xc8\xf0\xe4\x41\xed\x2e\x0e\x46\x35\x45\x81\xca\x1c\x81\x9a\x69\xc9\x8a\x22\x0a\x2a\xe2\xad\x5b\x96\xd1\x3f\x16\x7c\x96\x95\x94\x17\x38\x8e\x0c\xed\x9b\xaa\x52\x99\x44\xf4\xce\x06\x42\x84\x8a\x6b\x71\xf2\x62\xe2\x47\xbe\xa8\x43\xea\x61\x09\xf7\xbb\xcf\x98\x69\x57\x03\x93\x41\x71\xbc\x59\x5c\x10\xfb\xfe\xe2\xef\x6e\xe0\x0b\xd5\x7f\xc1\x86\xe0\x0f\x98\x21\x3b\xa2\xe7\x25\x86\x5c\x65\x24\x45\xda\x49\xc0\x12\xba\x02\x4b\x6e\x7b\x46\xab\x6a\x52\x53\x5d\xae\xb4\x9c\x42\x9b\xdc\x95\xee\xb4\x98\xae\xd2\xa5\xff\xb7\xd5\xfd\x9d\xc9\xbf\xc2\x49\x00\xb6\xfd\xc4\x7c\x46\x4b\x1f\x65\xf5\x46\x98\x3d\x9f\x9a\xde\xe3\x12\xb2\x37\x39\x34\xa0\xb9\xc4\xbc\xc9\x70\x12\x5d\xb7\xf6\x98\xa6\x60\x0e\xc6\x7b\xe3\x3f\xb6\xef\x00\xf0\xfa\x35\xb8\xe5\xc6\x9e\x61\x1f\x1b\x25\x3e\xc1\x2d\x12\xd4\xb9\xdb\x9d\x83\xb3\xbd\x94\x59\xba\xaf\x25\xe3\xc2\xab\x3d\x8f\xad\x39\x2b\xe1\x5a\x9e\x7d\xd9\x99\xc3\xdb\x73\x77\x68\xbd\x6a\xb4\xc7\xa5\xb4\x64\xbc\x60\xfb\xa7\x89\x44\x03\x38\x47\x19\xd2\xf8\x45\x4f\x84\x6d\x1e\x6a\x0a\xca\x5b\x74\xe2\x9b\x2b\xc3\xbf\x9a\x42\x40\x6c\x53\x79\x73\x11\x83\x3c\x56\x78\x40\xae\x87\x6a\x0c\x2c\xa8\xd9\xce\x33\xc1\x33\xaa\x27\x1d\x3e\x55\xca\x0e\xb4\x40\xaf\x75\xa0\xcb\x72\x23\x65\xbd\x80\x44\x93\x95\x74\x57\xe1\xc0\xab\x61\x6c\x1e\x1a\x07\xe8\xc0\x3d\xad\x2a\x93\xa2\xaa\x3e\xfd\xbb\x60\x5b\xf0\xec\xfb\x62\x3e\xe1\xce\xaa\x6f\x64\x35\x50\x78\xc2\x9d\xd7\x16\x0a\x42\x89\x46\x66\x48\x7a\x05\xd9\x48\x46\xa0\x91\xd5\xa5\x8a\xfb\x4c\x8f\x74\x65\x47\xc5\x2d\x37\x61\xe7\x04\xb4\x6c\xb0\xad\xa6\x7e\x5e\xdb\xfe\xce\x04\xff\x80\x4a\x99\x74\x68\xa6\x2b\x5c\xe3\x17\x3d\x85\x68\xe2\x18\x42\x7c\x9d\x2d\x6a\xa5\x9f\x2a\xec\xde\x07\xed\x1b\xa1\x12\x92\xc0\xf8\x54\x32\x8d\xe3\xe8\xc6\x0a\xae\x57\xec\x6f\x24\x70\xfd\xff\x94\xfa\x0b\x3d\xb0\xea\x89\xc0\x58\x51\xae\x66\x0a\x25\xdb\x8f\x5b\x4f\x17\xa9\x31\x58\x42\x7b\x93\xcc\xc4\xaf\x05\x37\x67\x3b\xb7\x65\x1d\x7c\x99\x42\xe7\xbd\xbf\x20\x46\x3e\x8a\xe3\xbf\x72\x39\x20\x44\x4d\x33\xa6\x9f\x08\xfc\x6f\xfe\x63\x3f\x90\x74\xa8\xbf\x10\x4e\xdf\xdb\x61\x1e\xd2\xbb\x3f\x54\x63\x2f\x6b\xe7\x50\x5a\x38\x3b\x9a\xfd\x55\x48\xd1\xf0\xfc\xc6\x05\x2e\x31\x8f\xdc\x37\x5f\x89\xac\x28\x35\x81\xb7\xd7\x29\xbd\xa6\x79\xce\x78\xf1\x1e\xf7\x9a\xc0\xf5\xdb\x8b\xcc\xb5\xa8\x09\x5c\xff\x30\xbd\x54\x98\x1b\x9b\x9d\x24\x9e\xad\xef\x87\xe7\xd1\xc8\x9c\x50\x1b\x4c\xff\xcd\x49\xe2\x09\x15\x77\x4b\x23\xe2\x30\xb0\x04\x8e\xa7\xf0\xf0\x5c\xf4\x5b\xaa\xc3\xf9\x91\x5c\x3a\x44\xef\x2d\xfb\x4d\x53\x32\x8c\x4c\x63\x2b\xbc\x66\x07\xc6\x3c\xf2\x05\x6b\xb4\xd1\x42\x36\x9c\xa4\x4f\x43\xe3\xde\x5d\x6f\x52\xf5\x27\xbe\x93\x6c\x9f\x2d\x5e\x20\xd1\x6d\xa6\xbc\x8a\xfb\xc5\xfa\xf6\xcf\x35\x01\xd7\xe2\x3b\xea\xdd\xc7\x0f\x3f\xdd\x3e\x10\xb8\xe2\xcd\x61\x87\x32\xe2\xfc\xfe\xeb\xfd\xdd\x2d\x81\xab\xba\x14\x1c\x63\xfa\xbb\xd5\xea\x8f\xfb\x87\x9f\x0d\x8b\x2a\x75\x12\x32\xbf\x8a\x0d\xe3\xd1\x54\x5f\x6c\x79\x75\xbb\x7e\xfc\xf4\xee\xfd\x47\xa3\x4d\xa1\x9e\x1d\x69\xd5\x60\x22\x13\xaa\x36\x96\x33\x05\x4c\xec\x6f\xb0\x6e\xdc\x27\xf6\x37\xd0\xec\x88\x20\xed\x5f\x84\xf4\xfd\x9e\x84\x65\xe0\x86\x16\x4f\xa2\x75\xe0\xbb\x06\x4d\xfc\x62\x1a\x55\x40\xaf\x57\x92\x21\xc9\x8d\xec\xf3\xe2\x9f\x00\x00\x00\xff\xff\x59\x9d\x9d\x6a\x4a\x0d\x00\x00") func testdataJailStatusJsBytes() ([]byte, error) { return bindataRead( @@ -424,12 +298,12 @@ func testdataJailStatusJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/status.js", size: 3402, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/status.js", size: 3402, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailTxSendContextNoMessageIdJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x55\xc1\x8e\xdb\x36\x10\xbd\xeb\x2b\xa6\x3e\x24\x32\xa0\x95\x83\xb6\x97\xc8\xd9\x4b\x72\xeb\xa1\x05\xba\x0d\x72\x58\x04\xc1\x2c\x35\x96\x08\xd3\xa4\x4a\x8e\xd6\xbb\x58\xe8\xdf\x8b\xa1\x48\x59\x36\x8a\xf8\x44\x91\x33\x8f\x33\xef\xbd\xa1\x9f\xd1\xc3\x8f\xc0\xc8\x63\xf8\xa1\x90\xd1\xb8\x0e\xee\xe1\xad\x00\x00\x50\xee\x74\x42\xdb\x86\x06\xde\xa6\x2a\xee\x78\x0a\x83\xb3\x81\xe2\x56\x31\xed\x8b\x42\xf2\x95\xb3\x4c\x2f\x2c\x79\xd3\xbe\x38\x8c\x56\xb1\x76\x16\xb0\x6d\xbf\xcc\x27\xa5\x0d\x15\x1c\xe9\xb5\x82\x67\x34\x23\x6d\x13\xfe\x6e\x07\x67\x02\xdd\x59\xe7\x09\x6c\x80\x9e\x3c\x41\x89\x41\xd6\x3a\xc0\x89\x42\xc0\x8e\x40\xb7\x15\xa0\x6d\x41\x5b\xe0\x5e\x07\xf8\xfa\x45\xd2\x5a\x07\xd6\x31\xf4\xf8\x4c\xe0\x2c\x6d\x53\xc5\xf1\xbe\xc7\x23\xbd\x7e\x87\xfb\xf9\xb6\x7d\x31\x15\x97\xa2\x14\x1a\x53\x0e\xc8\xfd\x03\xfb\x0a\x06\xf4\x78\x0a\x0f\xec\x73\x49\xd2\xce\xbc\x09\xf7\xf0\xc7\xc3\x5f\x7f\xd6\x03\xfa\x40\xe5\x25\x70\x26\x42\x7e\x82\x72\x1b\x15\x71\x57\x31\x07\x5b\x09\x69\xfb\x62\x5d\x5e\x22\xaa\x98\x03\xe0\x3e\x22\xd5\x9e\xda\x51\x51\x99\x2b\x2d\x93\x1a\x15\x58\x3c\x2d\x94\xc9\x4f\x1f\x20\x1f\xc2\xbb\x77\x90\x96\x8f\x12\xf6\x7d\x1d\x37\x0b\xc6\xa3\xb7\xd7\x31\xfb\x25\x62\x8a\xab\xa9\xba\x75\xc0\x36\x15\x27\x37\xfd\x72\xb0\x6b\xd0\x04\x68\x47\x63\x66\x9c\xa9\x58\xb4\xec\xb5\x21\x69\xe8\x6c\x0c\x3c\x11\xd0\x0b\xa9\x91\xa9\x5d\xda\x3e\xeb\xf9\x60\x70\xc3\x68\x90\xa9\xcd\x99\x4f\xaf\x2b\xb3\x44\x89\x02\x1c\xbc\x3b\xc1\x5c\xd6\x5d\xe7\x66\xfa\xd0\x98\xbf\x29\x8c\x46\x18\x3c\xd8\x24\xca\x76\x9f\xad\xb9\x18\x37\x7d\x8f\x86\x9b\x55\xd2\x45\x95\xdd\x0e\x82\x5b\xca\x52\x6e\x34\x73\x91\xa8\xed\x3a\xe6\x8d\x3d\xda\x80\x51\x8e\xbb\x40\x96\x1b\x60\x3f\xd2\xb4\xc4\x24\x84\x26\x2f\x66\x42\x12\x79\x89\xa9\x68\x8f\xc0\x5e\xdb\x4e\x1f\x5e\x4b\x4f\x52\xf0\xda\x91\x81\x6c\xfb\xcf\xe5\xa2\xdc\xd5\xca\x90\x2d\x32\x5e\xf5\x26\xdc\x34\xc9\xa7\xb5\x7c\x5c\x5a\x63\xb7\x1c\xb0\xbb\x6c\xc7\x49\x68\xe0\x4c\x4f\xbf\xd5\xec\xbe\x91\x4e\xd7\xd4\xf1\xa0\x82\x0d\x71\x4f\x7e\xb3\xbd\xea\x60\xb7\x83\xcf\xc6\xa9\xa3\xb6\x5d\xa4\xb1\x02\x9d\x44\x4c\xbd\x9d\x7b\xb2\xb0\x22\x49\xa6\x56\xb9\xd3\x60\x88\xa9\xce\x10\xdf\xa2\x2d\x24\x5f\x8e\x67\x53\x68\xdb\x55\x17\x71\x67\xcc\x18\x31\x0e\xc0\x3d\x01\x0e\x83\xd1\x0a\x05\xb3\xca\x38\x68\x8c\x3b\x4b\x29\x9a\x81\x9d\x74\xa4\x5b\x64\x8a\x4f\x43\xbe\x74\x5d\xcc\x42\x5f\x8f\x41\xe6\x34\xf6\x4e\xdc\xd7\xb7\x84\x0b\xbd\xdb\x6b\xd1\xde\x36\x6b\xe9\x05\x60\xd3\x44\x9c\x29\x6a\x77\x33\x2e\x75\x7e\x28\x1f\xdf\x0b\xf6\x7b\x79\x7a\x6e\x2e\xd9\xff\x24\xa7\x23\xfe\x8c\x06\xad\xa2\x98\xb9\x18\xe3\x7f\x9c\xf0\x34\xc7\xad\xbb\xb9\x64\x67\x49\xb1\x6d\x3d\x85\x3c\x17\x37\x29\xe2\x16\x91\x3f\x6d\xdf\x28\x2f\x03\x9f\x13\x3e\xc1\xc7\x0f\xeb\xc9\x57\xce\x06\x67\xa8\x36\xae\x2b\x37\x5f\x2d\xbd\x0c\xa4\x64\xba\x73\x7c\xf9\xe9\xe3\x87\x6d\x03\x9b\x2a\xef\x24\x33\x65\xfd\xc6\x40\xf3\x1b\xfe\x02\x4c\x81\x43\x25\x2a\xaa\x9e\xd4\x11\xb8\x47\x06\xeb\xec\x5d\x9a\xa3\x2a\x7e\xa4\xf7\xff\x4e\xb7\xe0\xe9\xdf\x51\x72\xe0\xec\xfc\x11\xd8\xb9\xc5\x15\xc1\x01\x2a\x1e\xd1\x2c\x75\xe8\x10\xff\x18\xf4\x69\x70\x9e\xd1\xf2\xb5\xae\x29\x6a\xd3\xc0\xef\xbf\xc6\x7f\xb0\xff\x02\x00\x00\xff\xff\x9f\x55\x53\x4e\x01\x07\x00\x00") +var _testdataJailTxSendContextNoMessageIdJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x55\xc1\x8e\xdb\x36\x10\xbd\xeb\x2b\xa6\x3e\x24\x32\xa0\x95\x83\xb6\x97\xc8\xd9\x4b\x72\xeb\xa1\x05\xba\x0d\x72\x58\x04\xc1\x2c\x35\x96\x08\xd3\xa4\x4a\x8e\xd6\xbb\x58\xe8\xdf\x8b\xa1\x48\x59\x36\x8a\xf8\x44\x91\x33\x8f\x33\xef\xbd\xa1\x9f\xd1\xc3\x8f\xc0\xc8\x63\xf8\xa1\x90\xd1\xb8\x0e\xee\xe1\xad\x00\x00\x50\xee\x74\x42\xdb\x86\x06\xde\xa6\x2a\xee\x78\x0a\x83\xb3\x81\xe2\x56\x31\xed\x8b\x42\xf2\x95\xb3\x4c\x2f\x2c\x79\xd3\xbe\x38\x8c\x56\xb1\x76\x16\xb0\x6d\xbf\xcc\x27\xa5\x0d\x15\x1c\xe9\xb5\x82\x67\x34\x23\x6d\x13\xfe\x6e\x07\x67\x02\xdd\x59\xe7\x09\x6c\x80\x9e\x3c\x41\x89\x41\xd6\x3a\xc0\x89\x42\xc0\x8e\x40\xb7\x15\xa0\x6d\x41\x5b\xe0\x5e\x07\xf8\xfa\x45\xd2\x5a\x07\xd6\x31\xf4\xf8\x4c\xe0\x2c\x6d\x53\xc5\xf1\xbe\xc7\x23\xbd\x7e\x87\xfb\xf9\xb6\x7d\x31\x15\x97\xa2\x14\x1a\x53\x0e\xc8\xfd\x03\xfb\x0a\x06\xf4\x78\x0a\x0f\xec\x73\x49\xd2\xce\xbc\x09\xf7\xf0\xc7\xc3\x5f\x7f\xd6\x03\xfa\x40\xe5\x25\x70\x26\x42\x7e\x82\x72\x1b\x15\x71\x57\x31\x07\x5b\x09\x69\xfb\x62\x5d\x5e\x22\xaa\x98\x03\xe0\x3e\x22\xd5\x9e\xda\x51\x51\x99\x2b\x2d\x93\x1a\x15\x58\x3c\x2d\x94\xc9\x4f\x1f\x20\x1f\xc2\xbb\x77\x90\x96\x8f\x12\xf6\x7d\x1d\x37\x0b\xc6\xa3\xb7\xd7\x31\xfb\x25\x62\x8a\xab\xa9\xba\x75\xc0\x36\x15\x27\x37\xfd\x72\xb0\x6b\xd0\x04\x68\x47\x63\x66\x9c\xa9\x58\xb4\xec\xb5\x21\x69\xe8\x6c\x0c\x3c\x11\xd0\x0b\xa9\x91\xa9\x5d\xda\x3e\xeb\xf9\x60\x70\xc3\x68\x90\xa9\xcd\x99\x4f\xaf\x2b\xb3\x44\x89\x02\x1c\xbc\x3b\xc1\x5c\xd6\x5d\xe7\x66\xfa\xd0\x98\xbf\x29\x8c\x46\x18\x3c\xd8\x24\xca\x76\x9f\xad\xb9\x18\x37\x7d\x8f\x86\x9b\x55\xd2\x45\x95\xdd\x0e\x82\x5b\xca\x52\x6e\x34\x73\x91\xa8\xed\x3a\xe6\x8d\x3d\xda\x80\x51\x8e\xbb\x40\x96\x1b\x60\x3f\xd2\xb4\xc4\x24\x84\x26\x2f\x66\x42\x12\x79\x89\xa9\x68\x8f\xc0\x5e\xdb\x4e\x1f\x5e\x4b\x4f\x52\xf0\xda\x91\x81\x6c\xfb\xcf\xe5\xa2\xdc\xd5\xca\x90\x2d\x32\x5e\xf5\x26\xdc\x34\xc9\xa7\xb5\x7c\x5c\x5a\x63\xb7\x1c\xb0\xbb\x6c\xc7\x49\x68\xe0\x4c\x4f\xbf\xd5\xec\xbe\x91\x4e\xd7\xd4\xf1\xa0\x82\x0d\x71\x4f\x7e\xb3\xbd\xea\x60\xb7\x83\xcf\xc6\xa9\xa3\xb6\x5d\xa4\xb1\x02\x9d\x44\x4c\xbd\x9d\x7b\xb2\xb0\x22\x49\xa6\x56\xb9\xd3\x60\x88\xa9\xce\x10\xdf\xa2\x2d\x24\x5f\x8e\x67\x53\x68\xdb\x55\x17\x71\x67\xcc\x18\x31\x0e\xc0\x3d\x01\x0e\x83\xd1\x0a\x05\xb3\xca\x38\x68\x8c\x3b\x4b\x29\x9a\x81\x9d\x74\xa4\x5b\x64\x8a\x4f\x43\xbe\x74\x5d\xcc\x42\x5f\x8f\x41\xe6\x34\xf6\x4e\xdc\xd7\xb7\x84\x0b\xbd\xdb\x6b\xd1\xde\x36\x6b\xe9\x05\x60\xd3\x44\x9c\x29\x6a\x77\x33\x2e\x75\x7e\x28\x1f\xdf\x0b\xf6\x7b\x79\x7a\x6e\x2e\xd9\xff\x24\xa7\x23\xfe\x8c\x06\xad\xa2\x98\xb9\x18\xe3\x7f\x9c\xf0\x34\xc7\xad\xbb\xb9\x64\x67\x49\xb1\x6d\x3d\x85\x3c\x17\x37\x29\xe2\x16\x91\x3f\x6d\xdf\x28\x2f\x03\x9f\x13\x3e\xc1\xc7\x0f\xeb\xc9\x57\xce\x06\x67\xa8\x36\xae\x2b\x37\x5f\x2d\xbd\x0c\xa4\x64\xba\x73\x7c\xf9\xe9\xe3\x87\x6d\x03\x9b\x2a\xef\x24\x33\x65\xfd\xc6\x40\xf3\x1b\xfe\x02\x4c\x81\x43\x25\x2a\xaa\x9e\xd4\x11\xb8\x47\x06\xeb\xec\x5d\x9a\xa3\x2a\x7e\xa4\xf7\xff\x4e\xb7\xe0\xe9\xdf\x51\x72\xe0\xec\xfc\x11\xd8\xb9\xc5\x15\xc1\x01\x2a\x1e\xd1\x2c\x75\xe8\x10\xff\x18\xf4\x69\x70\x9e\xd1\xf2\xb5\xae\x29\x6a\xd3\xc0\xef\xbf\xc6\x7f\xb0\xff\x02\x00\x00\xff\xff\x9f\x55\x53\x4e\x01\x07\x00\x00") func testdataJailTxSendContextNoMessageIdJsBytes() ([]byte, error) { return bindataRead( @@ -444,12 +318,12 @@ func testdataJailTxSendContextNoMessageIdJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/tx-send/context-no-message-id.js", size: 1793, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/tx-send/context-no-message-id.js", size: 1793, mode: os.FileMode(420), modTime: time.Unix(1500821837, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailTxSendMessageIdNoContextJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x55\x4d\x8f\xdb\x36\x10\xbd\xfb\x57\x4c\x7c\x88\x6d\x40\x2b\x07\x69\x2e\xb1\xe3\x4b\x7a\xeb\xa1\x3d\x6c\x8b\x1c\x82\x60\x33\x26\x47\x12\xb3\xf4\x50\x21\x47\xf6\x2e\x16\xfe\xef\x05\x29\xea\x63\xdd\x22\x3e\x59\xe4\x9b\x37\x1f\xef\x91\xdc\x6e\xe1\x07\x1a\x5b\xde\x13\xeb\xf5\x06\xe8\xa9\x25\x25\x01\xc4\x41\x65\x58\x83\x34\x04\xaa\xf3\x9e\x58\xe0\x44\x21\x60\x4d\x60\x34\x18\x86\xef\x41\x50\xba\x50\xe6\xd5\x07\xa3\xbf\x2f\xb6\x5b\x58\x9b\x0a\xd8\x09\x54\xae\x63\x3d\x0f\xb9\x18\x6b\xd3\xce\x91\xc0\xf0\x0f\x52\x42\xba\x00\x64\x0d\xae\x25\x8f\x62\x1c\xf7\x98\xd6\x3b\x45\xa4\x37\x8b\x33\x7a\xe8\x93\xc0\x01\x5e\x16\x00\x00\x53\xb2\x1d\xac\x3e\xbc\x5f\x2d\xae\xfb\x45\xc2\x3d\xf4\xc0\x07\x85\x82\xd6\xd5\x63\x80\x72\xa7\x13\xb2\x0e\x3b\x78\xb9\x16\x69\xc5\x53\x68\x1d\x07\x4a\x4b\x29\xbe\xea\x58\xa5\xf4\x0a\xad\x5d\xb7\x28\xcd\xbd\xf8\x02\x5a\xf4\x78\x0a\xf7\xe2\x37\x99\x2b\xe6\xe9\x17\xe1\x00\x7f\xdc\xff\xf5\x67\xd9\xa2\x0f\xb4\x9e\x80\x7d\x86\xf8\x8b\x2c\xb7\xa8\xc4\x3b\xc3\x54\x5c\xc4\x6a\xf6\x8b\x45\xff\x05\x87\x14\x56\x7a\xd2\x9d\xa2\xf5\x50\xd6\x3a\xf7\x54\x00\xe3\x89\x86\x62\xe2\xcf\x54\x30\x6c\xc2\xdb\xb7\x90\xff\x7e\x8d\xb0\x6f\x73\x5c\xdf\xb6\x74\x9e\x5f\x63\xf6\x23\xe2\x9a\xfe\x5d\x8b\xdb\x39\x6e\x72\x71\x31\xd3\x9b\x8a\xe7\xa4\x99\x90\x3b\x6b\x7b\x9e\x6b\x0f\xdd\x6e\xe1\xd2\x18\x4b\xb1\xa1\x8b\xb5\x51\x6e\x7a\x22\xd5\x09\x69\x50\x8e\x85\x9e\xa4\xd7\xf9\x48\xd0\xba\xb6\xb3\x28\xa4\x87\xc8\xe3\x33\xa0\xd6\xbf\x67\x58\xd4\x23\x40\xe5\xdd\x29\xfb\xe0\xae\x76\x83\x86\x70\x80\x8a\xf3\xe8\x87\x2a\x73\x49\x69\xe8\x41\xbc\xe1\xda\x54\xcf\x6b\x4f\x11\x70\x9d\xe9\x1c\x88\xf5\xdf\x1e\x39\x60\x3f\xe0\xcc\x32\x93\x59\xa3\xe0\xe8\xa1\xa4\x8e\x77\xa7\x5d\x56\xbf\x8c\x1f\x93\x8c\xe2\xc6\x0d\x71\xd3\xf2\x19\x6d\x47\x3b\xb8\xd0\xf1\xb7\x52\xdc\x17\x32\x39\x4d\x99\x36\x0a\x58\x92\x34\xe4\x97\x9b\x7e\x76\xfb\x71\x78\x93\xc5\x01\xad\x75\x97\x00\xcf\xae\x8b\xe7\x51\x9b\x20\x86\xeb\xce\x84\x06\x8e\x24\x17\x22\x86\x37\xb1\x15\x30\x7c\x76\x2a\x9d\xa0\x30\xb0\xac\x2f\x0d\x71\x8a\xf4\xa4\xc8\x9c\x09\x64\x6a\x18\x7e\x76\xd4\x91\x06\x3a\x13\x4b\x31\xcf\x98\x85\x19\x58\x50\x04\x55\x43\xb1\x12\xc7\x75\xba\x0c\x72\xe8\x9c\xcd\xe8\xbe\x89\xff\x5c\x08\x70\x80\x55\xe5\xdc\x11\xfd\x6a\xea\xef\xb3\x75\xea\xd1\x70\x9d\xd4\x2d\xc0\x64\x37\x64\xed\x52\xd9\xaf\xc8\x43\x3c\xc3\xad\x25\xa1\x72\xa0\xf8\x92\xfc\x15\xe3\xe3\x76\xef\x2e\xc3\x75\x31\xb9\xa4\xe7\x4c\x88\xae\x4d\x75\x63\xdb\x5a\xd3\x0f\xa9\x18\xdb\x8b\xf3\x8d\xa5\x18\x89\x03\x3e\xa3\x35\x1a\x85\xd2\xa5\x34\x24\x9d\x17\x33\xda\xa3\xc1\x10\x4f\x77\xd2\x96\xa4\x29\x6f\x0d\x15\xed\x73\x63\xca\x97\xe5\x8c\xe8\x2e\x12\x2c\x77\x89\xe7\x9a\xbc\x79\x73\xee\xca\xe1\xde\xfa\xba\x8a\xdc\xab\x6f\x70\xb8\x75\xed\xfe\x17\x31\x35\xc9\x67\xb4\xc8\x8a\x52\xe4\x68\xfc\xff\x71\xfa\xb1\xc7\xcd\xbb\x99\xa2\x07\xcb\xa2\xd6\x9e\x42\x3c\x46\x31\xec\x26\x24\x9e\x86\x68\xef\xbc\x3c\x39\x7b\x3f\x5e\x1d\x43\xc4\x27\xf8\xf8\x6e\x7e\x87\x28\xc7\xc1\x59\x2a\xad\xab\xd7\xcb\x7f\xb8\x7f\x7c\x48\x8f\x19\xd6\x9f\x3e\xbe\xdb\xec\x60\x59\x0c\x2b\xf9\xb4\x0c\x02\x76\x81\xd2\x5b\x24\x4f\x20\x14\x24\x14\x51\x46\xd5\x90\x7a\x04\x69\x50\x80\x1d\xdf\xe5\x3b\xa7\x48\x1f\xd9\x9b\x77\x26\x80\xa7\x9f\x5d\x8c\x81\x8b\xf3\x8f\x20\xce\x0d\xa4\xc1\x01\x2a\xe9\xd0\x8e\x65\x98\x90\x1e\x2e\x73\x6a\x9d\x17\x64\x79\xad\x6b\x46\x2d\x77\xf0\xe1\x7d\x7a\x50\xfe\x0d\x00\x00\xff\xff\x81\xec\x3a\x33\x53\x07\x00\x00") +var _testdataJailTxSendMessageIdNoContextJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x55\x4d\x8f\xdb\x36\x10\xbd\xfb\x57\x4c\x7c\x88\x6d\x40\x2b\x07\x69\x2e\xb1\xe3\x4b\x7a\xeb\xa1\x3d\x6c\x8b\x1c\x82\x60\x33\x26\x47\x12\xb3\xf4\x50\x21\x47\xf6\x2e\x16\xfe\xef\x05\x29\xea\x63\xdd\x22\x3e\x59\xe4\x9b\x37\x1f\xef\x91\xdc\x6e\xe1\x07\x1a\x5b\xde\x13\xeb\xf5\x06\xe8\xa9\x25\x25\x01\xc4\x41\x65\x58\x83\x34\x04\xaa\xf3\x9e\x58\xe0\x44\x21\x60\x4d\x60\x34\x18\x86\xef\x41\x50\xba\x50\xe6\xd5\x07\xa3\xbf\x2f\xb6\x5b\x58\x9b\x0a\xd8\x09\x54\xae\x63\x3d\x0f\xb9\x18\x6b\xd3\xce\x91\xc0\xf0\x0f\x52\x42\xba\x00\x64\x0d\xae\x25\x8f\x62\x1c\xf7\x98\xd6\x3b\x45\xa4\x37\x8b\x33\x7a\xe8\x93\xc0\x01\x5e\x16\x00\x00\x53\xb2\x1d\xac\x3e\xbc\x5f\x2d\xae\xfb\x45\xc2\x3d\xf4\xc0\x07\x85\x82\xd6\xd5\x63\x80\x72\xa7\x13\xb2\x0e\x3b\x78\xb9\x16\x69\xc5\x53\x68\x1d\x07\x4a\x4b\x29\xbe\xea\x58\xa5\xf4\x0a\xad\x5d\xb7\x28\xcd\xbd\xf8\x02\x5a\xf4\x78\x0a\xf7\xe2\x37\x99\x2b\xe6\xe9\x17\xe1\x00\x7f\xdc\xff\xf5\x67\xd9\xa2\x0f\xb4\x9e\x80\x7d\x86\xf8\x8b\x2c\xb7\xa8\xc4\x3b\xc3\x54\x5c\xc4\x6a\xf6\x8b\x45\xff\x05\x87\x14\x56\x7a\xd2\x9d\xa2\xf5\x50\xd6\x3a\xf7\x54\x00\xe3\x89\x86\x62\xe2\xcf\x54\x30\x6c\xc2\xdb\xb7\x90\xff\x7e\x8d\xb0\x6f\x73\x5c\xdf\xb6\x74\x9e\x5f\x63\xf6\x23\xe2\x9a\xfe\x5d\x8b\xdb\x39\x6e\x72\x71\x31\xd3\x9b\x8a\xe7\xa4\x99\x90\x3b\x6b\x7b\x9e\x6b\x0f\xdd\x6e\xe1\xd2\x18\x4b\xb1\xa1\x8b\xb5\x51\x6e\x7a\x22\xd5\x09\x69\x50\x8e\x85\x9e\xa4\xd7\xf9\x48\xd0\xba\xb6\xb3\x28\xa4\x87\xc8\xe3\x33\xa0\xd6\xbf\x67\x58\xd4\x23\x40\xe5\xdd\x29\xfb\xe0\xae\x76\x83\x86\x70\x80\x8a\xf3\xe8\x87\x2a\x73\x49\x69\xe8\x41\xbc\xe1\xda\x54\xcf\x6b\x4f\x11\x70\x9d\xe9\x1c\x88\xf5\xdf\x1e\x39\x60\x3f\xe0\xcc\x32\x93\x59\xa3\xe0\xe8\xa1\xa4\x8e\x77\xa7\x5d\x56\xbf\x8c\x1f\x93\x8c\xe2\xc6\x0d\x71\xd3\xf2\x19\x6d\x47\x3b\xb8\xd0\xf1\xb7\x52\xdc\x17\x32\x39\x4d\x99\x36\x0a\x58\x92\x34\xe4\x97\x9b\x7e\x76\xfb\x71\x78\x93\xc5\x01\xad\x75\x97\x00\xcf\xae\x8b\xe7\x51\x9b\x20\x86\xeb\xce\x84\x06\x8e\x24\x17\x22\x86\x37\xb1\x15\x30\x7c\x76\x2a\x9d\xa0\x30\xb0\xac\x2f\x0d\x71\x8a\xf4\xa4\xc8\x9c\x09\x64\x6a\x18\x7e\x76\xd4\x91\x06\x3a\x13\x4b\x31\xcf\x98\x85\x19\x58\x50\x04\x55\x43\xb1\x12\xc7\x75\xba\x0c\x72\xe8\x9c\xcd\xe8\xbe\x89\xff\x5c\x08\x70\x80\x55\xe5\xdc\x11\xfd\x6a\xea\xef\xb3\x75\xea\xd1\x70\x9d\xd4\x2d\xc0\x64\x37\x64\xed\x52\xd9\xaf\xc8\x43\x3c\xc3\xad\x25\xa1\x72\xa0\xf8\x92\xfc\x15\xe3\xe3\x76\xef\x2e\xc3\x75\x31\xb9\xa4\xe7\x4c\x88\xae\x4d\x75\x63\xdb\x5a\xd3\x0f\xa9\x18\xdb\x8b\xf3\x8d\xa5\x18\x89\x03\x3e\xa3\x35\x1a\x85\xd2\xa5\x34\x24\x9d\x17\x33\xda\xa3\xc1\x10\x4f\x77\xd2\x96\xa4\x29\x6f\x0d\x15\xed\x73\x63\xca\x97\xe5\x8c\xe8\x2e\x12\x2c\x77\x89\xe7\x9a\xbc\x79\x73\xee\xca\xe1\xde\xfa\xba\x8a\xdc\xab\x6f\x70\xb8\x75\xed\xfe\x17\x31\x35\xc9\x67\xb4\xc8\x8a\x52\xe4\x68\xfc\xff\x71\xfa\xb1\xc7\xcd\xbb\x99\xa2\x07\xcb\xa2\xd6\x9e\x42\x3c\x46\x31\xec\x26\x24\x9e\x86\x68\xef\xbc\x3c\x39\x7b\x3f\x5e\x1d\x43\xc4\x27\xf8\xf8\x6e\x7e\x87\x28\xc7\xc1\x59\x2a\xad\xab\xd7\xcb\x7f\xb8\x7f\x7c\x48\x8f\x19\xd6\x9f\x3e\xbe\xdb\xec\x60\x59\x0c\x2b\xf9\xb4\x0c\x02\x76\x81\xd2\x5b\x24\x4f\x20\x14\x24\x14\x51\x46\xd5\x90\x7a\x04\x69\x50\x80\x1d\xdf\xe5\x3b\xa7\x48\x1f\xd9\x9b\x77\x26\x80\xa7\x9f\x5d\x8c\x81\x8b\xf3\x8f\x20\xce\x0d\xa4\xc1\x01\x2a\xe9\xd0\x8e\x65\x98\x90\x1e\x2e\x73\x6a\x9d\x17\x64\x79\xad\x6b\x46\x2d\x77\xf0\xe1\x7d\x7a\x50\xfe\x0d\x00\x00\xff\xff\x81\xec\x3a\x33\x53\x07\x00\x00") func testdataJailTxSendMessageIdNoContextJsBytes() ([]byte, error) { return bindataRead( @@ -464,12 +338,12 @@ func testdataJailTxSendMessageIdNoContextJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/tx-send/message-id-no-context.js", size: 1875, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/tx-send/message-id-no-context.js", size: 1875, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailTxSendNoMessageIdOrContextJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x54\xb1\x6e\xdb\x30\x10\xdd\xf5\x15\x57\x0f\x89\x0c\xc8\x4a\xd0\x76\x89\x1d\x2f\x19\x3b\xb4\x43\x5a\x64\x08\x82\xe0\x42\x9d\x25\x22\x14\xa9\x92\xa7\xd8\x45\xa0\x7f\x2f\x48\x91\xb2\x22\x14\xd5\x24\x91\xef\xde\xdd\xbd\xf7\xec\xec\x0d\x2d\x3c\x3b\x46\xee\xdd\xb3\x40\x46\x65\x6a\xd8\xc3\x7b\x06\x00\x20\x4c\xdb\xa2\xae\xdc\x16\xde\x87\x22\x9c\x58\x72\x9d\xd1\x8e\xc2\x51\x36\xec\xb2\xec\xd0\x6b\xc1\xd2\x68\x10\xa8\x54\xde\x21\x37\xf7\x6c\x0b\xe8\xd0\x62\xeb\xee\xd9\xae\x23\x97\xef\x33\x1e\xc2\x1e\xbe\xdd\xff\xf8\x5e\x76\x68\x1d\xe5\x67\xe0\xd8\xc1\x3f\x9e\x65\x89\x0a\xbc\x33\xcc\x41\x17\x7e\x9a\x5d\x96\x8d\x5f\xb0\x0f\x65\xa5\xa5\xaa\x17\x94\xa7\xb1\xf2\xb8\x53\x01\x1a\x5b\x4a\xc3\xf8\x47\x1e\x20\x5d\xc2\xc5\x05\xc4\xd7\x47\x0f\x7b\x9a\xe3\xc6\xb5\xb9\xb7\xfa\x23\x66\x37\x21\x86\xf0\x36\x14\x4b\x1d\xd7\x71\x38\xdf\xe9\xd3\x41\xcf\x49\x23\xa1\xee\x95\x1a\x79\x86\x2c\xe9\x0b\x7b\x38\xe8\x28\xcb\x7a\x97\xcd\xd0\x41\x0f\xc7\x56\xea\x5a\x1e\xfe\xe4\x96\xfc\xfd\x30\xb3\xc0\x91\xae\x7e\x5a\xd4\x0e\xc7\xdd\x23\xc9\xcc\x81\x0a\x19\x27\x7b\x83\x70\xd6\xb4\xdb\x68\x4c\xe9\x3f\xce\x0a\xb3\x99\x2e\xd8\x9c\x8f\xdf\x50\xf5\xb4\x85\x23\xbd\x7c\x29\xd9\x3c\x90\x8c\x6d\xca\x70\x51\xc0\x8a\xb8\x21\xbb\x5a\x8f\x6b\x45\x09\xae\xae\xe0\x4e\x19\xf1\x2a\x75\x1d\x82\x52\x80\x64\x38\x4a\xa5\xd2\x6e\xc7\x86\x34\xf0\x79\x76\x90\xce\xc7\xaf\x53\xc4\x54\x26\x8a\x87\x46\x2a\x0a\xf5\xfe\x9a\x4e\x24\x7a\x96\xba\x2e\x60\xd4\x7d\x53\x9b\x91\x33\x20\xfa\x0e\xb8\x21\xc0\xae\x53\x52\xa0\xe7\x2c\x12\x0f\x2a\x65\x8e\x7e\x14\xc9\xc0\xc6\x6f\x24\x2b\x64\x02\xd4\xd5\xd4\x74\x3e\xcc\x24\x5f\x83\xce\x07\x33\xec\x4e\xdc\x94\x4b\xc1\xbd\xbc\xc9\xf5\xb8\xd8\xfb\x6a\x46\xb4\xf1\x04\xab\x6d\xe0\x19\x82\x77\x8b\xc8\x94\xe9\x27\xf7\x78\xe9\xb9\x2f\x9f\x60\xbf\x74\x75\xf7\x9f\x9a\x9a\xf8\x0e\x15\x6a\x41\xa1\x72\x0a\xc6\x3f\x92\xf0\x32\xe2\xe6\xdb\x9c\xab\x93\xa5\x58\x55\x96\x5c\x8a\xe1\xa2\xc4\xa7\xc5\xdb\x1f\x8f\x17\xce\xfb\xd0\xa7\x82\x5b\xb8\xb9\x9e\xa7\x5f\x18\xed\x8c\xa2\x52\x99\x3a\x5f\xfd\xd2\x74\xea\x48\x30\x55\x53\x83\xfc\xf6\xe6\x7a\xbd\x85\x55\x91\x4e\x62\x98\x92\x7f\xbd\xa3\x0a\xa4\x06\x3e\x01\x93\x63\x57\x78\x17\x45\x43\xe2\x15\xb8\x41\x06\x6d\xf4\x46\x18\xcd\x74\xe2\x22\x7c\xb4\xe4\x1c\xd6\xb4\x91\x0e\x2c\xfd\xee\x7d\x0d\x1c\x8d\x7d\x05\x36\x26\x91\x3a\x03\x28\xb8\x47\x35\x8d\x21\x1d\x68\xc3\x20\xdb\xce\x58\x46\xcd\x1f\x6d\x8d\xa8\xd5\x16\xbe\x7e\xf6\x7f\x85\x7f\x03\x00\x00\xff\xff\xfd\x93\xd0\x40\x4a\x05\x00\x00") +var _testdataJailTxSendNoMessageIdOrContextJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x54\xb1\x6e\xdb\x30\x10\xdd\xf5\x15\x57\x0f\x89\x0c\xc8\x4a\xd0\x76\x89\x1d\x2f\x19\x3b\xb4\x43\x5a\x64\x08\x82\xe0\x42\x9d\x25\x22\x14\xa9\x92\xa7\xd8\x45\xa0\x7f\x2f\x48\x91\xb2\x22\x14\xd5\x24\x91\xef\xde\xdd\xbd\xf7\xec\xec\x0d\x2d\x3c\x3b\x46\xee\xdd\xb3\x40\x46\x65\x6a\xd8\xc3\x7b\x06\x00\x20\x4c\xdb\xa2\xae\xdc\x16\xde\x87\x22\x9c\x58\x72\x9d\xd1\x8e\xc2\x51\x36\xec\xb2\xec\xd0\x6b\xc1\xd2\x68\x10\xa8\x54\xde\x21\x37\xf7\x6c\x0b\xe8\xd0\x62\xeb\xee\xd9\xae\x23\x97\xef\x33\x1e\xc2\x1e\xbe\xdd\xff\xf8\x5e\x76\x68\x1d\xe5\x67\xe0\xd8\xc1\x3f\x9e\x65\x89\x0a\xbc\x33\xcc\x41\x17\x7e\x9a\x5d\x96\x8d\x5f\xb0\x0f\x65\xa5\xa5\xaa\x17\x94\xa7\xb1\xf2\xb8\x53\x01\x1a\x5b\x4a\xc3\xf8\x47\x1e\x20\x5d\xc2\xc5\x05\xc4\xd7\x47\x0f\x7b\x9a\xe3\xc6\xb5\xb9\xb7\xfa\x23\x66\x37\x21\x86\xf0\x36\x14\x4b\x1d\xd7\x71\x38\xdf\xe9\xd3\x41\xcf\x49\x23\xa1\xee\x95\x1a\x79\x86\x2c\xe9\x0b\x7b\x38\xe8\x28\xcb\x7a\x97\xcd\xd0\x41\x0f\xc7\x56\xea\x5a\x1e\xfe\xe4\x96\xfc\xfd\x30\xb3\xc0\x91\xae\x7e\x5a\xd4\x0e\xc7\xdd\x23\xc9\xcc\x81\x0a\x19\x27\x7b\x83\x70\xd6\xb4\xdb\x68\x4c\xe9\x3f\xce\x0a\xb3\x99\x2e\xd8\x9c\x8f\xdf\x50\xf5\xb4\x85\x23\xbd\x7c\x29\xd9\x3c\x90\x8c\x6d\xca\x70\x51\xc0\x8a\xb8\x21\xbb\x5a\x8f\x6b\x45\x09\xae\xae\xe0\x4e\x19\xf1\x2a\x75\x1d\x82\x52\x80\x64\x38\x4a\xa5\xd2\x6e\xc7\x86\x34\xf0\x79\x76\x90\xce\xc7\xaf\x53\xc4\x54\x26\x8a\x87\x46\x2a\x0a\xf5\xfe\x9a\x4e\x24\x7a\x96\xba\x2e\x60\xd4\x7d\x53\x9b\x91\x33\x20\xfa\x0e\xb8\x21\xc0\xae\x53\x52\xa0\xe7\x2c\x12\x0f\x2a\x65\x8e\x7e\x14\xc9\xc0\xc6\x6f\x24\x2b\x64\x02\xd4\xd5\xd4\x74\x3e\xcc\x24\x5f\x83\xce\x07\x33\xec\x4e\xdc\x94\x4b\xc1\xbd\xbc\xc9\xf5\xb8\xd8\xfb\x6a\x46\xb4\xf1\x04\xab\x6d\xe0\x19\x82\x77\x8b\xc8\x94\xe9\x27\xf7\x78\xe9\xb9\x2f\x9f\x60\xbf\x74\x75\xf7\x9f\x9a\x9a\xf8\x0e\x15\x6a\x41\xa1\x72\x0a\xc6\x3f\x92\xf0\x32\xe2\xe6\xdb\x9c\xab\x93\xa5\x58\x55\x96\x5c\x8a\xe1\xa2\xc4\xa7\xc5\xdb\x1f\x8f\x17\xce\xfb\xd0\xa7\x82\x5b\xb8\xb9\x9e\xa7\x5f\x18\xed\x8c\xa2\x52\x99\x3a\x5f\xfd\xd2\x74\xea\x48\x30\x55\x53\x83\xfc\xf6\xe6\x7a\xbd\x85\x55\x91\x4e\x62\x98\x92\x7f\xbd\xa3\x0a\xa4\x06\x3e\x01\x93\x63\x57\x78\x17\x45\x43\xe2\x15\xb8\x41\x06\x6d\xf4\x46\x18\xcd\x74\xe2\x22\x7c\xb4\xe4\x1c\xd6\xb4\x91\x0e\x2c\xfd\xee\x7d\x0d\x1c\x8d\x7d\x05\x36\x26\x91\x3a\x03\x28\xb8\x47\x35\x8d\x21\x1d\x68\xc3\x20\xdb\xce\x58\x46\xcd\x1f\x6d\x8d\xa8\xd5\x16\xbe\x7e\xf6\x7f\x85\x7f\x03\x00\x00\xff\xff\xfd\x93\xd0\x40\x4a\x05\x00\x00") func testdataJailTxSendNoMessageIdOrContextJsBytes() ([]byte, error) { return bindataRead( @@ -484,12 +358,12 @@ func testdataJailTxSendNoMessageIdOrContextJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/tx-send/no-message-id-or-context.js", size: 1354, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/tx-send/no-message-id-or-context.js", size: 1354, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataJailTxSendTxSendJs = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x7c\x56\xcd\x8e\xdb\x36\x10\xbe\xfb\x29\x26\x7b\xc8\xca\x81\xd6\x0e\xd2\x5c\x62\x67\x2f\xe9\xad\x87\x16\xe8\xb6\x08\x8a\x45\xb0\x19\x89\x23\x8b\x59\x9a\x54\xc8\x91\xbd\xee\x62\xdf\xbd\x18\x8a\x92\x68\x27\xe8\x4d\x22\xe7\x7f\xbe\xf9\x86\xeb\x35\x7c\x43\x6d\x56\x77\x64\x55\xb1\x04\x7a\xea\xa8\xe6\x00\xec\xa0\xd1\x56\x01\xb7\x04\x75\xef\x3d\x59\x86\x3d\x85\x80\x3b\x02\xad\x40\x5b\xf8\x1a\x18\xb9\x0f\xab\x74\xfa\xa0\xd5\xd7\xc5\x7a\x0d\x85\x6e\xc0\x3a\x86\xc6\xf5\x56\xe5\x2a\x47\x6d\x4c\xbc\xa9\x08\xb4\xfd\x46\x35\x93\x2a\x01\xad\x02\xd7\x91\x47\xd6\xce\x0e\x32\x9d\x77\x35\x91\x5a\x2e\x0e\xe8\x61\x70\x02\xb7\xf0\xbc\x00\x00\x98\x9d\x6d\xe0\xfa\xfd\xbb\x6b\x58\xaf\x61\x67\x5c\x85\x26\x73\x55\xc2\x8e\x38\x80\xa7\xce\x60\x4d\x31\xd8\x40\x56\xfd\xe5\xd1\x06\xac\xa3\xa3\xc2\x79\x40\x7b\x02\xc7\x2d\x79\xd8\x13\xb7\x4e\x2d\x17\x2f\xdb\x45\x74\xfa\x30\x78\x7d\xa8\x91\xd1\xb8\xdd\xe4\xbd\x76\xfb\x3d\x5a\x15\x36\xf0\xfc\x52\xc6\x13\x4f\xa1\x73\x36\x50\x3c\x9a\xf4\x6b\x67\x99\x9e\x58\xf4\x5e\xb6\x8b\xa6\xb7\x83\x53\x54\xea\xd7\xe1\xa6\xb0\xa1\x84\x47\x3a\x95\x70\x40\xd3\xd3\x12\x9e\x25\x11\x6e\x75\x80\x49\x5a\x87\xd4\x0c\x52\xd2\x8d\x8a\xa0\xf3\x14\xc8\x72\x09\x18\x52\x5d\x6e\x76\x0e\xfa\x40\x01\x34\x8b\x4c\x20\x1e\x7d\xc7\xe8\x74\x03\xc5\xab\xc2\x06\xa9\x40\x3a\x5f\x2e\x53\x2e\x43\x3e\xf1\xec\xde\x86\x2f\x31\xd6\x78\xf1\xb2\xb8\xb8\xba\x7f\xa4\x93\xdc\xc7\x50\xb7\x8b\x97\xc5\x9c\x51\x8d\xc6\x14\x1d\x72\x7b\xc7\xbe\x84\x0e\x3d\xee\xc3\x1d\xfb\xd1\x87\xd4\x62\x38\x84\x5b\xf8\xed\xee\x8f\xdf\x57\x1d\xfa\x40\xc5\x2c\x58\x4e\xb1\x88\x95\x4b\xa9\x68\x37\x93\x69\x6c\x29\x15\xdf\x2e\xe2\xc9\x7a\x0d\x77\xda\xd6\x04\x47\x02\x34\xc6\x1d\xc1\x4a\xd1\x3d\x7d\xef\x29\xc4\x7a\x24\x24\xc1\x1b\xbd\xdf\x93\xd2\xc8\x64\x4e\x6f\x00\x1b\x26\x1f\x41\x0f\xae\x62\xd4\x36\x64\xd8\x19\x2d\x1f\x09\x42\xeb\x7a\xa3\xa4\xf0\x35\x7a\x6a\x7a\x03\xee\x40\xfe\xe8\x35\xb3\xb6\xbb\x11\x76\x63\xaf\x0f\xe8\x35\x56\x86\x56\xa3\x85\xcf\xd2\x30\x57\x61\x65\x4e\xa3\x29\xa3\xf7\x9a\xd7\xa1\x76\x1d\x49\x78\x63\x8d\x67\x50\x67\x6d\x38\xc7\xd0\x62\x48\x1f\x6e\x63\x9d\x56\x9e\x54\x5f\x53\x31\xf6\xa1\x48\x40\x2d\xc1\xe2\x9e\xf2\x0e\x0b\x02\x46\x14\xbf\x7e\x0d\xe9\xf3\x5e\xc4\xbe\xe4\x72\x03\x96\xb9\xf7\xf6\x5c\x66\x3b\x49\x24\x70\x94\x97\xc3\xb1\x4c\xc1\x45\xac\x35\x36\x37\x9a\x0c\xda\xde\x98\x6d\x82\xd6\x54\xde\x56\x1b\x92\x84\x8e\xc6\x48\x85\xe9\x89\xea\x5e\x90\x3e\xa6\x1d\x99\x40\x30\xef\xba\xde\x20\xd3\xd4\x98\xea\x94\xcd\x51\x04\x60\x80\xc6\xbb\xfd\x3c\x11\x43\xf9\xd0\x98\x3f\x29\xf4\x46\x2a\xd8\xd8\x04\xb9\xe5\x76\x9c\xda\x69\xa6\xd3\x7f\x6f\x78\x93\x29\xcd\x98\x13\x94\xb9\x72\x8a\xab\x8e\x8d\x94\x3f\xd4\x16\x9e\x89\xdb\x07\x9e\x79\x45\x48\x74\x03\xec\x7b\x7a\xc9\x0d\xa0\x52\x5a\xae\xd1\x98\xd3\x6c\x2a\x92\xd4\xd7\x8c\x3e\x65\xae\x8f\x64\xcc\x2a\xd7\xfd\xc7\xf5\x50\xa3\x85\x01\x35\x43\x49\xb3\x3a\x55\xa7\x74\x26\x90\xfc\x09\xa0\xce\x12\x69\xdd\x91\x0e\xe4\x21\xc4\xb1\x09\xe4\x35\x1a\xfd\xef\x40\xbd\xbb\x1e\xbd\x9a\xca\xee\xc9\x10\x06\xe1\xce\x79\x72\xd2\xe0\x5c\xcc\x4a\x32\xad\x43\x1a\x26\x21\xf5\x93\xeb\xc1\xd2\xc4\x5b\xe3\xf8\xe8\x26\xde\xf4\x81\x7e\xe4\x6c\x28\x34\xe7\xf6\x8e\xce\x3f\x06\xa8\xc8\xb8\x63\x29\xf4\xc5\x14\xb8\x14\x9a\x9b\xd6\x88\x48\x48\xc5\x26\x92\xd4\x16\x5a\xbd\x6b\xcd\x49\xea\x30\xee\x2c\xb2\x07\xed\x9d\xdd\x93\xe5\xe5\x25\xef\x6d\xa6\x82\xfd\xb0\xca\xbe\x0c\x78\x4d\xd8\x4e\x40\x8e\xdc\x14\xd8\x6b\xbb\xd3\xcd\xa9\xf0\x24\x78\xca\xe9\xf0\x62\xcb\x8c\xa0\xcb\xd8\x50\x21\xe3\x19\xf4\x04\xba\x9b\x44\x92\x2b\xf9\x99\x1b\xc6\x6e\xba\x60\x37\x1f\x47\x1a\xde\xc0\x91\xaa\x5f\x56\xec\x3e\x93\x4e\x6e\x56\xf1\xa2\x84\x2b\x92\x9d\x76\xb5\x3c\xcb\x60\xbd\xce\x56\xe7\xc0\x96\x21\x36\x83\x1d\x28\x1d\x84\xd0\x7a\x1d\x5a\xa8\x88\x8f\x44\x16\x5e\x49\x2a\xa0\xed\xc1\xd5\x11\x1e\x61\xb4\x52\x1c\x5b\xb2\x51\xd3\x53\x4d\xfa\x40\x90\xc1\x1f\xbe\xf7\xd4\x93\x02\x3a\xc4\x35\x95\x79\x4c\xb8\x1a\xad\x20\x33\xd6\x2d\x49\x24\xce\xee\xe2\x23\x23\xa9\xe6\xd6\xb4\x1a\x92\xf8\xa1\x3b\x70\x0b\xd7\x8d\x73\x15\xfa\xeb\x39\xbf\x4f\xc6\xd5\x8f\x71\x0a\xd0\x98\x19\x2a\xa9\x77\x31\xec\x33\xe3\x41\xd6\x79\x67\x88\x33\xca\x8e\xac\x24\xfa\xc3\xf6\x15\x4e\xd2\x76\x57\x66\xdb\x36\xda\x8c\x12\x7d\x17\xe3\xc6\xae\x33\x7a\x28\x52\x39\xa5\x27\xf5\x95\x50\x86\xb5\x7c\x40\xa3\x15\x32\xc5\xc7\xce\xe8\x34\x0f\x66\x82\x47\x8b\x41\x96\x60\xec\x2d\x71\xbb\xba\x04\x94\xc0\x67\x79\x0e\xca\xe7\xab\xcc\xd0\x8d\x18\xb8\xda\x44\x3b\x2f\x11\x9b\x17\x6c\xbd\x1a\x9f\x30\xf7\xd7\x62\xfb\x5a\x16\xce\x85\x93\xed\xff\xe8\xec\x88\x3f\xa1\x41\x5b\x53\xd4\x9c\x80\xff\x13\xa4\x57\x83\x5c\x9e\xcd\xac\x3d\x42\x16\x95\xf2\x14\x46\x5a\xbe\x50\x91\x69\x10\x78\xa7\xe3\x19\xd9\xdb\x69\xe1\x8c\x1a\x1f\xe1\xc3\xdb\x8b\x87\x4d\x70\x86\x56\xc6\xed\x8a\xab\xbf\xed\x44\x11\xa3\x7c\xf1\xf1\xc3\xdb\xe5\x06\xae\xca\xf1\x64\x99\x3d\x7d\xd6\x6b\xa1\xa8\xc8\x27\xfc\x14\x89\x27\x94\x71\x5d\xb7\x54\x3f\x02\xb7\xc8\x60\x9d\xbd\x49\xdc\x51\xc6\x9f\x84\xcd\x1b\x1d\xc6\xf7\x47\x18\x08\x8a\x9d\x1b\x8d\x06\x07\x58\x73\x8f\x66\x0a\x43\x87\xc8\x64\x7a\xdf\x39\xcf\x68\xf9\xbc\xaf\x49\xea\x6a\x03\xef\xdf\xc5\xb7\xe5\x7f\x01\x00\x00\xff\xff\xbd\x38\xb5\x49\xab\x0b\x00\x00") +var _testdataJailTxSendTxSendJs = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x7c\x56\xcd\x8e\xdb\x36\x10\xbe\xfb\x29\x26\x7b\xc8\xca\x81\xd6\x0e\xd2\x5c\x62\x67\x2f\xe9\xad\x87\x16\xe8\xb6\x08\x8a\x45\xb0\x19\x89\x23\x8b\x59\x9a\x54\xc8\x91\xbd\xee\x62\xdf\xbd\x18\x8a\x92\x68\x27\xe8\x4d\x22\xe7\x7f\xbe\xf9\x86\xeb\x35\x7c\x43\x6d\x56\x77\x64\x55\xb1\x04\x7a\xea\xa8\xe6\x00\xec\xa0\xd1\x56\x01\xb7\x04\x75\xef\x3d\x59\x86\x3d\x85\x80\x3b\x02\xad\x40\x5b\xf8\x1a\x18\xb9\x0f\xab\x74\xfa\xa0\xd5\xd7\xc5\x7a\x0d\x85\x6e\xc0\x3a\x86\xc6\xf5\x56\xe5\x2a\x47\x6d\x4c\xbc\xa9\x08\xb4\xfd\x46\x35\x93\x2a\x01\xad\x02\xd7\x91\x47\xd6\xce\x0e\x32\x9d\x77\x35\x91\x5a\x2e\x0e\xe8\x61\x70\x02\xb7\xf0\xbc\x00\x00\x98\x9d\x6d\xe0\xfa\xfd\xbb\x6b\x58\xaf\x61\x67\x5c\x85\x26\x73\x55\xc2\x8e\x38\x80\xa7\xce\x60\x4d\x31\xd8\x40\x56\xfd\xe5\xd1\x06\xac\xa3\xa3\xc2\x79\x40\x7b\x02\xc7\x2d\x79\xd8\x13\xb7\x4e\x2d\x17\x2f\xdb\x45\x74\xfa\x30\x78\x7d\xa8\x91\xd1\xb8\xdd\xe4\xbd\x76\xfb\x3d\x5a\x15\x36\xf0\xfc\x52\xc6\x13\x4f\xa1\x73\x36\x50\x3c\x9a\xf4\x6b\x67\x99\x9e\x58\xf4\x5e\xb6\x8b\xa6\xb7\x83\x53\x54\xea\xd7\xe1\xa6\xb0\xa1\x84\x47\x3a\x95\x70\x40\xd3\xd3\x12\x9e\x25\x11\x6e\x75\x80\x49\x5a\x87\xd4\x0c\x52\xd2\x8d\x8a\xa0\xf3\x14\xc8\x72\x09\x18\x52\x5d\x6e\x76\x0e\xfa\x40\x01\x34\x8b\x4c\x20\x1e\x7d\xc7\xe8\x74\x03\xc5\xab\xc2\x06\xa9\x40\x3a\x5f\x2e\x53\x2e\x43\x3e\xf1\xec\xde\x86\x2f\x31\xd6\x78\xf1\xb2\xb8\xb8\xba\x7f\xa4\x93\xdc\xc7\x50\xb7\x8b\x97\xc5\x9c\x51\x8d\xc6\x14\x1d\x72\x7b\xc7\xbe\x84\x0e\x3d\xee\xc3\x1d\xfb\xd1\x87\xd4\x62\x38\x84\x5b\xf8\xed\xee\x8f\xdf\x57\x1d\xfa\x40\xc5\x2c\x58\x4e\xb1\x88\x95\x4b\xa9\x68\x37\x93\x69\x6c\x29\x15\xdf\x2e\xe2\xc9\x7a\x0d\x77\xda\xd6\x04\x47\x02\x34\xc6\x1d\xc1\x4a\xd1\x3d\x7d\xef\x29\xc4\x7a\x24\x24\xc1\x1b\xbd\xdf\x93\xd2\xc8\x64\x4e\x6f\x00\x1b\x26\x1f\x41\x0f\xae\x62\xd4\x36\x64\xd8\x19\x2d\x1f\x09\x42\xeb\x7a\xa3\xa4\xf0\x35\x7a\x6a\x7a\x03\xee\x40\xfe\xe8\x35\xb3\xb6\xbb\x11\x76\x63\xaf\x0f\xe8\x35\x56\x86\x56\xa3\x85\xcf\xd2\x30\x57\x61\x65\x4e\xa3\x29\xa3\xf7\x9a\xd7\xa1\x76\x1d\x49\x78\x63\x8d\x67\x50\x67\x6d\x38\xc7\xd0\x62\x48\x1f\x6e\x63\x9d\x56\x9e\x54\x5f\x53\x31\xf6\xa1\x48\x40\x2d\xc1\xe2\x9e\xf2\x0e\x0b\x02\x46\x14\xbf\x7e\x0d\xe9\xf3\x5e\xc4\xbe\xe4\x72\x03\x96\xb9\xf7\xf6\x5c\x66\x3b\x49\x24\x70\x94\x97\xc3\xb1\x4c\xc1\x45\xac\x35\x36\x37\x9a\x0c\xda\xde\x98\x6d\x82\xd6\x54\xde\x56\x1b\x92\x84\x8e\xc6\x48\x85\xe9\x89\xea\x5e\x90\x3e\xa6\x1d\x99\x40\x30\xef\xba\xde\x20\xd3\xd4\x98\xea\x94\xcd\x51\x04\x60\x80\xc6\xbb\xfd\x3c\x11\x43\xf9\xd0\x98\x3f\x29\xf4\x46\x2a\xd8\xd8\x04\xb9\xe5\x76\x9c\xda\x69\xa6\xd3\x7f\x6f\x78\x93\x29\xcd\x98\x13\x94\xb9\x72\x8a\xab\x8e\x8d\x94\x3f\xd4\x16\x9e\x89\xdb\x07\x9e\x79\x45\x48\x74\x03\xec\x7b\x7a\xc9\x0d\xa0\x52\x5a\xae\xd1\x98\xd3\x6c\x2a\x92\xd4\xd7\x8c\x3e\x65\xae\x8f\x64\xcc\x2a\xd7\xfd\xc7\xf5\x50\xa3\x85\x01\x35\x43\x49\xb3\x3a\x55\xa7\x74\x26\x90\xfc\x09\xa0\xce\x12\x69\xdd\x91\x0e\xe4\x21\xc4\xb1\x09\xe4\x35\x1a\xfd\xef\x40\xbd\xbb\x1e\xbd\x9a\xca\xee\xc9\x10\x06\xe1\xce\x79\x72\xd2\xe0\x5c\xcc\x4a\x32\xad\x43\x1a\x26\x21\xf5\x93\xeb\xc1\xd2\xc4\x5b\xe3\xf8\xe8\x26\xde\xf4\x81\x7e\xe4\x6c\x28\x34\xe7\xf6\x8e\xce\x3f\x06\xa8\xc8\xb8\x63\x29\xf4\xc5\x14\xb8\x14\x9a\x9b\xd6\x88\x48\x48\xc5\x26\x92\xd4\x16\x5a\xbd\x6b\xcd\x49\xea\x30\xee\x2c\xb2\x07\xed\x9d\xdd\x93\xe5\xe5\x25\xef\x6d\xa6\x82\xfd\xb0\xca\xbe\x0c\x78\x4d\xd8\x4e\x40\x8e\xdc\x14\xd8\x6b\xbb\xd3\xcd\xa9\xf0\x24\x78\xca\xe9\xf0\x62\xcb\x8c\xa0\xcb\xd8\x50\x21\xe3\x19\xf4\x04\xba\x9b\x44\x92\x2b\xf9\x99\x1b\xc6\x6e\xba\x60\x37\x1f\x47\x1a\xde\xc0\x91\xaa\x5f\x56\xec\x3e\x93\x4e\x6e\x56\xf1\xa2\x84\x2b\x92\x9d\x76\xb5\x3c\xcb\x60\xbd\xce\x56\xe7\xc0\x96\x21\x36\x83\x1d\x28\x1d\x84\xd0\x7a\x1d\x5a\xa8\x88\x8f\x44\x16\x5e\x49\x2a\xa0\xed\xc1\xd5\x11\x1e\x61\xb4\x52\x1c\x5b\xb2\x51\xd3\x53\x4d\xfa\x40\x90\xc1\x1f\xbe\xf7\xd4\x93\x02\x3a\xc4\x35\x95\x79\x4c\xb8\x1a\xad\x20\x33\xd6\x2d\x49\x24\xce\xee\xe2\x23\x23\xa9\xe6\xd6\xb4\x1a\x92\xf8\xa1\x3b\x70\x0b\xd7\x8d\x73\x15\xfa\xeb\x39\xbf\x4f\xc6\xd5\x8f\x71\x0a\xd0\x98\x19\x2a\xa9\x77\x31\xec\x33\xe3\x41\xd6\x79\x67\x88\x33\xca\x8e\xac\x24\xfa\xc3\xf6\x15\x4e\xd2\x76\x57\x66\xdb\x36\xda\x8c\x12\x7d\x17\xe3\xc6\xae\x33\x7a\x28\x52\x39\xa5\x27\xf5\x95\x50\x86\xb5\x7c\x40\xa3\x15\x32\xc5\xc7\xce\xe8\x34\x0f\x66\x82\x47\x8b\x41\x96\x60\xec\x2d\x71\xbb\xba\x04\x94\xc0\x67\x79\x0e\xca\xe7\xab\xcc\xd0\x8d\x18\xb8\xda\x44\x3b\x2f\x11\x9b\x17\x6c\xbd\x1a\x9f\x30\xf7\xd7\x62\xfb\x5a\x16\xce\x85\x93\xed\xff\xe8\xec\x88\x3f\xa1\x41\x5b\x53\xd4\x9c\x80\xff\x13\xa4\x57\x83\x5c\x9e\xcd\xac\x3d\x42\x16\x95\xf2\x14\x46\x5a\xbe\x50\x91\x69\x10\x78\xa7\xe3\x19\xd9\xdb\x69\xe1\x8c\x1a\x1f\xe1\xc3\xdb\x8b\x87\x4d\x70\x86\x56\xc6\xed\x8a\xab\xbf\xed\x44\x11\xa3\x7c\xf1\xf1\xc3\xdb\xe5\x06\xae\xca\xf1\x64\x99\x3d\x7d\xd6\x6b\xa1\xa8\xc8\x27\xfc\x14\x89\x27\x94\x71\x5d\xb7\x54\x3f\x02\xb7\xc8\x60\x9d\xbd\x49\xdc\x51\xc6\x9f\x84\xcd\x1b\x1d\xc6\xf7\x47\x18\x08\x8a\x9d\x1b\x8d\x06\x07\x58\x73\x8f\x66\x0a\x43\x87\xc8\x64\x7a\xdf\x39\xcf\x68\xf9\xbc\xaf\x49\xea\x6a\x03\xef\xdf\xc5\xb7\xe5\x7f\x01\x00\x00\xff\xff\xbd\x38\xb5\x49\xab\x0b\x00\x00") func testdataJailTxSendTxSendJsBytes() ([]byte, error) { return bindataRead( @@ -504,12 +378,12 @@ func testdataJailTxSendTxSendJs() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/jail/tx-send/tx-send.js", size: 2987, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/jail/tx-send/tx-send.js", size: 2987, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _testdataNodeTestSol = []byte("\x1f\x8b\x08\x00\x00\x09\x6e\x88\x00\xff\x2c\xcb\x31\x0a\xc2\x40\x10\x85\xe1\x7e\x4f\xf1\x4a\x63\x11\x44\x6c\x24\xd7\xb0\x16\xc6\xcd\x2a\x0b\x71\x46\x66\xde\x16\x22\xb9\xbb\xac\xe6\x2f\x3f\xf8\x5f\x2e\x8f\xa7\x20\x6c\xa9\x73\xe5\x1b\xd7\xc3\x78\x1a\xcf\x53\x4a\xd9\x94\x2e\x99\xb8\x94\x20\x3e\x09\x00\xee\x4d\x33\xab\x29\x66\x6b\xb7\xa5\xec\xaa\x12\x32\x20\x9b\x06\x45\x09\x2f\x6c\xae\xd1\x7d\xd8\x96\xde\x9f\x71\xdc\xcb\xf4\xb3\x35\xad\xdf\x00\x00\x00\xff\xff\x5a\xcc\x10\x28\x77\x00\x00\x00") +var _testdataNodeTestSol = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x2c\xcb\x31\x0a\xc2\x40\x10\x85\xe1\x7e\x4f\xf1\x4a\x63\x11\x44\x6c\x24\xd7\xb0\x16\xc6\xcd\x2a\x0b\x71\x46\x66\xde\x16\x22\xb9\xbb\xac\xe6\x2f\x3f\xf8\x5f\x2e\x8f\xa7\x20\x6c\xa9\x73\xe5\x1b\xd7\xc3\x78\x1a\xcf\x53\x4a\xd9\x94\x2e\x99\xb8\x94\x20\x3e\x09\x00\xee\x4d\x33\xab\x29\x66\x6b\xb7\xa5\xec\xaa\x12\x32\x20\x9b\x06\x45\x09\x2f\x6c\xae\xd1\x7d\xd8\x96\xde\x9f\x71\xdc\xcb\xf4\xb3\x35\xad\xdf\x00\x00\x00\xff\xff\x5a\xcc\x10\x28\x77\x00\x00\x00") func testdataNodeTestSolBytes() ([]byte, error) { return bindataRead( @@ -524,7 +398,7 @@ func testdataNodeTestSol() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "testdata/node/test.sol", size: 119, mode: os.FileMode(420), modTime: time.Unix(1495640010, 0)} + info := bindataFileInfo{name: "testdata/node/test.sol", size: 119, mode: os.FileMode(420), modTime: time.Unix(1500264813, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -583,12 +457,6 @@ func AssetNames() []string { var _bindata = map[string]func() (*asset, error){ "scripts/README.md": scriptsReadmeMd, "scripts/web3.js": scriptsWeb3Js, - "bootcluster/homestead.dev.json": bootclusterHomesteadDevJson, - "bootcluster/homestead.prod.json": bootclusterHomesteadProdJson, - "bootcluster/rinkeby.dev.json": bootclusterRinkebyDevJson, - "bootcluster/rinkeby.prod.json": bootclusterRinkebyProdJson, - "bootcluster/ropsten.dev.json": bootclusterRopstenDevJson, - "bootcluster/ropsten.prod.json": bootclusterRopstenProdJson, "config/linter_exclude_list.txt": configLinter_exclude_listTxt, "config/test-data.json": configTestDataJson, "keys/firebaseauthkey": keysFirebaseauthkey, @@ -645,14 +513,6 @@ type bintree struct { Children map[string]*bintree } var _bintree = &bintree{nil, map[string]*bintree{ - "bootcluster": &bintree{nil, map[string]*bintree{ - "homestead.dev.json": &bintree{bootclusterHomesteadDevJson, map[string]*bintree{}}, - "homestead.prod.json": &bintree{bootclusterHomesteadProdJson, map[string]*bintree{}}, - "rinkeby.dev.json": &bintree{bootclusterRinkebyDevJson, map[string]*bintree{}}, - "rinkeby.prod.json": &bintree{bootclusterRinkebyProdJson, map[string]*bintree{}}, - "ropsten.dev.json": &bintree{bootclusterRopstenDevJson, map[string]*bintree{}}, - "ropsten.prod.json": &bintree{bootclusterRopstenProdJson, map[string]*bintree{}}, - }}, "config": &bintree{nil, map[string]*bintree{ "linter_exclude_list.txt": &bintree{configLinter_exclude_listTxt, map[string]*bintree{}}, "test-data.json": &bintree{configTestDataJson, map[string]*bintree{}}, diff --git a/static/bootcluster/homestead.dev.json b/static/bootcluster/homestead.dev.json deleted file mode 100644 index 87952c820..000000000 --- a/static/bootcluster/homestead.dev.json +++ /dev/null @@ -1,5 +0,0 @@ -[ - "enode://93833be81c3d1bdb2ae5cde258c8f82ad1011a1bea8eb49fe50b0af394d4f7f7e45974356870552f36744efd732692a64865d1e8b64114eaf89a1bad0a1903a2@51.15.64.29:30303", - "enode://d76854bc54144b2269c5316d5f00f0a194efee2fb8d31e7b1939effd7e17f25773f8dc7fda8c4eb469450799da7f39b4e364e2a278d91b53539dcbb10b139635@51.15.73.37:30303", - "enode://57874205931df976079e4ff8ebb5756461030fb00f73486bd5ec4ae6ed6ba98e27d09f58e59bd85281d24084a6062bc8ab514dbcdaa9678fc3001d47772e626e@51.15.75.213:30303" -] diff --git a/static/bootcluster/homestead.prod.json b/static/bootcluster/homestead.prod.json deleted file mode 100644 index 2516ee89d..000000000 --- a/static/bootcluster/homestead.prod.json +++ /dev/null @@ -1,5 +0,0 @@ -[ - "enode://f3b0e5dca730962bae814f3402b8f8a296644c33e8d7a95bd1ab313143a752c77076a03bcb76263570f2f34d4eb530f1daf5054c0990921a872a34eb505dcedf@51.15.73.129:30303", - "enode://fce0d1c2292829b0eccce444f8943f88087ce00a5e910b157972ee1658a948d23c7a046f26567f73b2b18d126811509d7ef1de5be9b1decfcbb14738a590c477@51.15.75.187:30303", - "enode://3b4b9fa02ae8d54c2db51a674bc93d85649b4775f22400f74ae25e9f1c665baa3bcdd33cadd2c1a93cd08a6af984cb605fbb61ec0d750a11d48d4080298af008@51.15.77.193:30303" -] diff --git a/static/bootcluster/rinkeby.dev.json b/static/bootcluster/rinkeby.dev.json deleted file mode 100644 index 62e788757..000000000 --- a/static/bootcluster/rinkeby.dev.json +++ /dev/null @@ -1,5 +0,0 @@ -[ - "enode://7512c8f6e7ffdcc723cf77e602a1de9d8cc2e8ad35db309464819122cd773857131aee390fec33894db13da730c8432bb248eed64039e3810e156e979b2847cb@51.15.78.243:30303", - "enode://1cc27a5a41130a5c8b90db5b2273dc28f7b56f3edfc0dcc57b665d451274b26541e8de49ea7a074281906a82209b9600239c981163b6ff85c3038a8e2bc5d8b8@51.15.68.93:30303", - "enode://798d17064141b8f88df718028a8272b943d1cb8e696b3dab56519c70b77b1d3469b56b6f4ce3788457646808f5c7299e9116626f2281f30b959527b969a71e4f@51.15.75.244:30303" -] \ No newline at end of file diff --git a/static/bootcluster/rinkeby.prod.json b/static/bootcluster/rinkeby.prod.json deleted file mode 100644 index 946573fc1..000000000 --- a/static/bootcluster/rinkeby.prod.json +++ /dev/null @@ -1,5 +0,0 @@ -[ - "enode://fda3f6273a0f2da4ac5858d1f52e5afaf9def281121be3d37558c67d4d9ca26c6ad7a0520b2cd7454120fb770e86d5760487c9924b2166e65485f606e56d60fc@51.15.69.144:30303", - "enode://ba41aa829287a0a9076d9bffed97c8ce2e491b99873288c9e886f16fd575306ac6c656db4fbf814f5a9021aec004ffa9c0ae8650f92fd10c12eeb7c364593eb3@51.15.69.147:30303", - "enode://28ecf5272b560ca951f4cd7f1eb8bd62da5853b026b46db432c4b01797f5b0114819a090a72acd7f32685365ecd8e00450074fa0673039aefe10f3fb666e0f3f@51.15.76.249:30303" -] diff --git a/static/bootcluster/ropsten.dev.json b/static/bootcluster/ropsten.dev.json deleted file mode 100644 index 6043a5594..000000000 --- a/static/bootcluster/ropsten.dev.json +++ /dev/null @@ -1,7 +0,0 @@ -[ - "enode://da3bf389a031f33fb55c9f5f54fde8473912402d27fffaa50efd74c0d0515f3a61daf6d52151f2876b19c15828e6f670352bff432b5ec457652e74755e8c864f@51.15.62.116:30303", - "enode://584c0db89b00719e9e7b1b5c32a4a8942f379f4d5d66bb69f9c7fa97fa42f64974e7b057b35eb5a63fd7973af063f9a1d32d8c60dbb4854c64cb8ab385470258@51.15.35.2:30303", - "enode://e71ba996b923e4756783375e0ed1f29963b7f759305926315d3cf9a71364d2980dbc86b1c1549812c720b38f60d347149f1ba33681c5cd4c8fca4ee8116efec6@51.15.35.70:30303", - "enode://829f09a946bcac67afbd7b8face82c48106af6a6b2507c007de6c79b2dbdf5544368afdf93cf5218d6d75a1f0219e6312db48bcc2f0fdfacb1d82c81f061d623@51.15.54.229:30303", - "enode://e80276aabb7682a4a659f4341c1199de79d91a2e500a6ee9bed16ed4ce927ba8d32ba5dea357739ffdf2c5bcc848d3064bb6f149f0b4249c1f7e53f8bf02bfc8@51.15.39.57:30303" -] diff --git a/static/bootcluster/ropsten.prod.json b/static/bootcluster/ropsten.prod.json deleted file mode 100644 index 6e70e8725..000000000 --- a/static/bootcluster/ropsten.prod.json +++ /dev/null @@ -1,7 +0,0 @@ -[ - "enode://fbddff478e18292dc32b90f139bf773a08da89ffe29208e4de0091f6c589e60fccfaf16d4f4a76be49f57782c061ec8ea97078601c6f367feabda740f5ce8246@51.15.55.219:30303", - "enode://4e5ee0487a4d8349ab9a9925b00eed0f976d98972c5a22f43fd50d1424897757032c36f273b434a4d3e013a2544eca74a9d1a0419f9f07f7bb43182a73df3690@51.15.35.110:30303", - "enode://18efd9afb60443e00fed602cc0df526cd1d8543d2f6037df9380eb973d30b5fd04ac9f221053f82034581051bfd6e54356a99af2255f1a674d71d17440a6c95b@51.15.34.3:30303", - "enode://5b99c0cb372299fd3f2d94612a682990722eb7c3a252dacefc8270eb7f172fc699c1ddfad826fbfc979270538e8d89bd6919703eb9ef526eac0a45e9fb455123@51.15.56.154:30303", - "enode://0e1d4d0fcfe888bf8a478b0fd89760a47733a5c04cd47de353295a6eb8dde8f54821b31196527d0c5c73a7024dc9ff34127692d237840fc09c312b3a19cd28fe@51.15.60.23:30303" -] diff --git a/static/config/test-data.json b/static/config/test-data.json index 6eeb76dc2..73f493d0d 100644 --- a/static/config/test-data.json +++ b/static/config/test-data.json @@ -1,6 +1,6 @@ { "Node": { - "SyncSeconds": 7, + "SyncSeconds": 30, "HTTPPort": 8645, "WSPort": 8646 }, diff --git a/static/static.go b/static/static.go index 18f143bec..c6b9d6b3e 100644 --- a/static/static.go +++ b/static/static.go @@ -1,4 +1,4 @@ // Package static embeds static (JS, HTML) resources right into the binaries package static -//go:generate go-bindata -pkg static -o bindata.go scripts/ bootcluster/ config/ keys/ testdata/... +//go:generate go-bindata -pkg static -o bindata.go scripts/ config/ keys/ testdata/... diff --git a/static/tests/whisper.js b/static/tests/whisper.js index a706d81fb..97a33dbf4 100644 --- a/static/tests/whisper.js +++ b/static/tests/whisper.js @@ -286,7 +286,7 @@ describe('Whisper Tests', function () { }, 200); }); - it('shh.unsubscribe(filterID)', function () { + it.skip('shh.unsubscribe(filterID)', function () { node1.shh.unsubscribe(filterid1); node1.shh.unsubscribe(filterid2); }); diff --git a/vendor/github.com/ethereum/go-ethereum/.dockerignore b/vendor/github.com/ethereum/go-ethereum/.dockerignore index d1d79d53e..07eab0766 100644 --- a/vendor/github.com/ethereum/go-ethereum/.dockerignore +++ b/vendor/github.com/ethereum/go-ethereum/.dockerignore @@ -1,3 +1,6 @@ -.git +**/.git +**/*_test.go + build/_workspace build/_bin +tests/testdata diff --git a/vendor/github.com/ethereum/go-ethereum/.gitattributes b/vendor/github.com/ethereum/go-ethereum/.gitattributes new file mode 100644 index 000000000..dfe077042 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/vendor/github.com/ethereum/go-ethereum/.github/CONTRIBUTING.md b/vendor/github.com/ethereum/go-ethereum/.github/CONTRIBUTING.md new file mode 100644 index 000000000..a332b815d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.github/CONTRIBUTING.md @@ -0,0 +1,16 @@ +## Can I have feature X + +Before you do a feature request please check and make sure that it isn't possible +through some other means. The JavaScript enabled console is a powerful feature +in the right hands. Please check our [Bitchin' tricks](https://github.com/ethereum/go-ethereum/wiki/bitchin-tricks) wiki page for more info +and help. + +## Contributing + +If you'd like to contribute to go-ethereum please fork, fix, commit and +send a pull request. Commits which do not comply with the coding standards +are ignored (use gofmt!). + +See [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide) +for more details on configuring your environment, testing, and +dependency management. diff --git a/vendor/github.com/ethereum/go-ethereum/.github/ISSUE_TEMPLATE.md b/vendor/github.com/ethereum/go-ethereum/.github/ISSUE_TEMPLATE.md new file mode 100644 index 000000000..6c1cb9f9a --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,20 @@ +#### System information + +Geth version: `geth version` +OS & Version: Windows/Linux/OSX +Commit hash : (if `develop`) + +#### Expected behaviour + + +#### Actual behaviour + + +#### Steps to reproduce the behaviour + + +#### Backtrace + +```` +[backtrace] +```` diff --git a/vendor/github.com/ethereum/go-ethereum/.gitignore b/vendor/github.com/ethereum/go-ethereum/.gitignore new file mode 100644 index 000000000..e53e461dc --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.gitignore @@ -0,0 +1,32 @@ +# See http://help.github.com/ignore-files/ for more about ignoring files. +# +# If you find yourself ignoring temporary files generated by your text editor +# or operating system, you probably want to add a global ignore instead: +# git config --global core.excludesfile ~/.gitignore_global + +/tmp +*/**/*un~ +*/**/*.test +*un~ +.DS_Store +*/**/.DS_Store +.ethtest +*/**/*tx_database* +*/**/*dapps* +build/_vendor/pkg + +#* +.#* +*# +*~ +.project +.settings + +# used by the Makefile +/build/_workspace/ +/build/bin/ +/geth*.zip + +# travis +profile.tmp +profile.cov diff --git a/vendor/github.com/ethereum/go-ethereum/.gitmodules b/vendor/github.com/ethereum/go-ethereum/.gitmodules new file mode 100644 index 000000000..32bdb3b6e --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.gitmodules @@ -0,0 +1,3 @@ +[submodule "tests"] + path = tests/testdata + url = https://github.com/ethereum/tests diff --git a/vendor/github.com/ethereum/go-ethereum/.mailmap b/vendor/github.com/ethereum/go-ethereum/.mailmap new file mode 100644 index 000000000..d51c7b609 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.mailmap @@ -0,0 +1,111 @@ +Jeffrey Wilcke +Jeffrey Wilcke +Jeffrey Wilcke +Jeffrey Wilcke + +Viktor Trón + +Joseph Goulden + +Nick Savers + +Maran Hidskes + +Taylor Gerring +Taylor Gerring + +Bas van Kervel +Bas van Kervel +Bas van Kervel +Bas van Kervel + +Sven Ehlert + +Vitalik Buterin + +Marian Oancea + +Christoph Jentzsch + +Heiko Hees + +Alex Leverington +Alex Leverington + +Zsolt Felföldi + +Gavin Wood + +Martin Becze +Martin Becze + +Dimitry Khokhlov + +Roman Mandeleil + +Alec Perseghin + +Alon Muroch + +Arkadiy Paronyan + +Jae Kwon + +Aaron Kumavis + +Nick Dodson + +Jason Carver +Jason Carver + +Joseph Chow +Joseph Chow ethers + +Enrique Fynn + +Vincent G + +RJ Catalano + +Nchinda Nchinda + +Aron Fischer + +Vlad Gluhovsky + +Ville Sundell + +Elliot Shepherd + +Yohann Léon + +Gregg Dourgarian + +Casey Detrio + +Jens Agerberg + +Nick Johnson + +Henning Diedrich +Henning Diedrich Drake Burroughs + +Felix Lange +Felix Lange + +Максим Чусовлянов + +Louis Holbrook +Louis Holbrook + +Thomas Bocek + +Victor Tran + +Justin Drake + +Frank Wang + +Gary Rong + +Guillaume Nicolas diff --git a/vendor/github.com/ethereum/go-ethereum/.travis.yml b/vendor/github.com/ethereum/go-ethereum/.travis.yml new file mode 100644 index 000000000..703ed0cb1 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/.travis.yml @@ -0,0 +1,184 @@ +language: go +go_import_path: github.com/ethereum/go-ethereum +sudo: false +matrix: + include: + - os: linux + dist: trusty + sudo: required + go: 1.7.6 + script: + - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install fuse + - sudo modprobe fuse + - sudo chmod 666 /dev/fuse + - sudo chown root:$USER /etc/fuse.conf + - go run build/ci.go install + - go run build/ci.go test -coverage + + # These are the latest Go versions. + - os: linux + dist: trusty + sudo: required + go: 1.8.3 + script: + - sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install fuse + - sudo modprobe fuse + - sudo chmod 666 /dev/fuse + - sudo chown root:$USER /etc/fuse.conf + - go run build/ci.go install + - go run build/ci.go test -coverage -misspell + + - os: osx + go: 1.8.3 + sudo: required + script: + - brew update + - brew install caskroom/cask/brew-cask + - brew cask install osxfuse + - go run build/ci.go install + - go run build/ci.go test -coverage -misspell + + # This builder does the Ubuntu PPA and Linux Azure uploads + - os: linux + dist: trusty + sudo: required + go: 1.8.3 + env: + - ubuntu-ppa + - azure-linux + addons: + apt: + packages: + - devscripts + - debhelper + - dput + - gcc-multilib + - fakeroot + script: + # Build for the primary platforms that Trusty can manage + - go run build/ci.go debsrc -signer "Go Ethereum Linux Builder " -upload ppa:ethereum/ethereum + - go run build/ci.go install + - go run build/ci.go archive -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + - go run build/ci.go install -arch 386 + - go run build/ci.go archive -arch 386 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + # Switch over GCC to cross compilation (breaks 386, hence why do it here only) + - 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 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 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 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 archive -arch arm64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + # This builder does the Linux Azure MIPS xgo uploads + - os: linux + dist: trusty + sudo: required + services: + - docker + go: 1.8.3 + env: + - azure-linux-mips + script: + - go run build/ci.go xgo --alltools -- --targets=linux/mips --ldflags '-extldflags "-static"' -v + - for bin in build/bin/*-linux-mips; do mv -f "${bin}" "${bin/-linux-mips/}"; done + - go run build/ci.go archive -arch mips -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + - go run build/ci.go xgo --alltools -- --targets=linux/mipsle --ldflags '-extldflags "-static"' -v + - for bin in build/bin/*-linux-mipsle; do mv -f "${bin}" "${bin/-linux-mipsle/}"; done + - go run build/ci.go archive -arch mipsle -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + - go run build/ci.go xgo --alltools -- --targets=linux/mips64 --ldflags '-extldflags "-static"' -v + - for bin in build/bin/*-linux-mips64; do mv -f "${bin}" "${bin/-linux-mips64/}"; done + - go run build/ci.go archive -arch mips64 -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + - go run build/ci.go xgo --alltools -- --targets=linux/mips64le --ldflags '-extldflags "-static"' -v + - for bin in build/bin/*-linux-mips64le; do mv -f "${bin}" "${bin/-linux-mips64le/}"; done + - go run build/ci.go archive -arch mips64le -type tar -signer LINUX_SIGNING_KEY -upload gethstore/builds + + # This builder does the Android Maven and Azure uploads + - os: linux + dist: precise # Needed for the android tools + addons: + apt: + packages: + - oracle-java8-installer + - oracle-java8-set-default + language: android + android: + components: + - platform-tools + - tools + - android-15 + - android-19 + - android-24 + env: + - azure-android + - maven-android + before_install: + - curl https://storage.googleapis.com/golang/go1.8.3.linux-amd64.tar.gz | tar -xz + - export PATH=`pwd`/go/bin:$PATH + - export GOROOT=`pwd`/go + - export GOPATH=$HOME/go + script: + # Build the Android archive and upload it to Maven Central and Azure + - curl https://dl.google.com/android/repository/android-ndk-r14b-linux-x86_64.zip -o android-ndk-r14b.zip + - unzip -q android-ndk-r14b.zip && rm android-ndk-r14b.zip + - mv android-ndk-r14b $HOME + - export ANDROID_NDK=$HOME/android-ndk-r14b + + - mkdir -p $GOPATH/src/github.com/ethereum + - ln -s `pwd` $GOPATH/src/github.com/ethereum + - go run build/ci.go aar -signer ANDROID_SIGNING_KEY -deploy https://oss.sonatype.org -upload gethstore/builds + + # This builder does the OSX Azure, iOS CocoaPods and iOS Azure uploads + - os: osx + go: 1.8.3 + env: + - azure-osx + - azure-ios + - cocoapods-ios + script: + - go run build/ci.go install + - go run build/ci.go archive -type tar -signer OSX_SIGNING_KEY -upload gethstore/builds + + # Build the iOS framework and upload it to CocoaPods and Azure + - gem uninstall cocoapods -a -x + - gem install cocoapods + + - mv ~/.cocoapods/repos/master ~/.cocoapods/repos/master.bak + - sed -i '.bak' 's/repo.join/!repo.join/g' $(dirname `gem which cocoapods`)/cocoapods/sources_manager.rb + - if [ "$TRAVIS_PULL_REQUEST" = "false" ]; then git clone --depth=1 https://github.com/CocoaPods/Specs.git ~/.cocoapods/repos/master && pod setup --verbose; fi + + - xctool -version + - xcrun simctl list + + - go run build/ci.go xcode -signer IOS_SIGNING_KEY -deploy trunk -upload gethstore/builds + + # This builder does the Azure archive purges to avoid accumulating junk + - os: linux + dist: trusty + sudo: required + go: 1.8.3 + env: + - azure-purge + script: + - go run build/ci.go purge -store gethstore/builds -days 14 + +install: + - go get golang.org/x/tools/cmd/cover +script: + - go run build/ci.go install + - go run build/ci.go test -coverage + +notifications: + webhooks: + urls: + - https://webhooks.gitter.im/e/e09ccdce1048c5e03445 + on_success: change + on_failure: always diff --git a/vendor/github.com/ethereum/go-ethereum/AUTHORS b/vendor/github.com/ethereum/go-ethereum/AUTHORS new file mode 100644 index 000000000..faa19d281 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/AUTHORS @@ -0,0 +1,85 @@ +# This is the official list of go-ethereum authors for copyright purposes. + +Ales Katona +Alex Leverington +Alexandre Van de Sande +Aron Fischer +Bas van Kervel +Benjamin Brent +Brian Schroeder +Casey Detrio +Christoph Jentzsch +Daniel A. Nagy +Diego Siqueira +Elliot Shepherd +Enrique Fynn +Ethan Buchman +Fabian Vogelsteller +Fabio Berger +Felix Lange +Frank Wang +Gary Rong +Gregg Dourgarian +Guillaume Nicolas +Gustav Simonsson +Hao Bryan Cheng +Henning Diedrich +Isidoro Ghezzi +Jae Kwon +Jamie Pitts +Jason Carver +Jeff R. Allen +Jeffrey Wilcke +Jens Agerberg +Jonathan Brown +Joseph Chow +Justin Clark-Casey +Justin Drake +Kenji Siu +Kobi Gurkan +Lefteris Karapetsas +Leif Jurvetson +Lewis Marshall +Louis Holbrook +Luca Zeug +Maran Hidskes +Marek Kotewicz +Martin Holst Swende +Matthew Di Ferrante +Matthew Wampler-Doty +Micah Zoltu +Nchinda Nchinda +Nick Dodson +Nick Johnson +Paulo L F Casaretto +Peter Pratscher +Péter Szilágyi +RJ Catalano +Ramesh Nair +Ricardo Catalinas Jiménez +Rémy Roy +Shintaro Kaneko +Stein Dekker +Steven Roose +Taylor Gerring +Thomas Bocek +Tosh Camille +Valentin Wüstholz +Victor Farazdagi +Victor Tran +Viktor Trón +Ville Sundell +Vincent G +Vitalik Buterin +Vivek Anand +Vlad Gluhovsky +Yohann Léon +Yoichi Hirai +Zahoor Mohamed +Zsolt Felföldi +holisticode +ken10100147 +ligi +xiekeyang +ΞTHΞЯSPHΞЯΞ <{viktor.tron,nagydani,zsfelfoldi}@gmail.com> +Максим Чусовлянов diff --git a/vendor/github.com/ethereum/go-ethereum/Dockerfile b/vendor/github.com/ethereum/go-ethereum/Dockerfile new file mode 100644 index 000000000..6bf13dc31 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/Dockerfile @@ -0,0 +1,15 @@ +FROM alpine:3.5 + +ADD . /go-ethereum +RUN \ + apk add --update git go make gcc musl-dev linux-headers && \ + (cd go-ethereum && make geth) && \ + cp go-ethereum/build/bin/geth /usr/local/bin/ && \ + apk del git go make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 8545 +EXPOSE 30303 +EXPOSE 30303/udp + +ENTRYPOINT ["geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/Makefile b/vendor/github.com/ethereum/go-ethereum/Makefile new file mode 100644 index 000000000..b6e2ddd5e --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/Makefile @@ -0,0 +1,147 @@ +# This Makefile is meant to be used by people that do not usually work +# with Go source code. If you know what GOPATH is then you probably +# don't need to bother with make. + +.PHONY: geth android ios geth-cross swarm evm all test clean +.PHONY: geth-linux geth-linux-386 geth-linux-amd64 geth-linux-mips64 geth-linux-mips64le +.PHONY: geth-linux-arm geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64 +.PHONY: geth-darwin geth-darwin-386 geth-darwin-amd64 +.PHONY: geth-windows geth-windows-386 geth-windows-amd64 + +GOBIN = build/bin +GO ?= latest + +geth: + build/env.sh go run build/ci.go install ./cmd/geth + @echo "Done building." + @echo "Run \"$(GOBIN)/geth\" to launch geth." + +swarm: + build/env.sh go run build/ci.go install ./cmd/swarm + @echo "Done building." + @echo "Run \"$(GOBIN)/swarm\" to launch swarm." + +evm: + build/env.sh go run build/ci.go install ./cmd/evm + @echo "Done building." + @echo "Run \"$(GOBIN)/evm\" to start the evm." + +all: + build/env.sh go run build/ci.go install + +android: + build/env.sh go run build/ci.go aar --local + @echo "Done building." + @echo "Import \"$(GOBIN)/geth.aar\" to use the library." + +ios: + build/env.sh go run build/ci.go xcode --local + @echo "Done building." + @echo "Import \"$(GOBIN)/Geth.framework\" to use the library." + +test: all + build/env.sh go run build/ci.go test + +clean: + rm -fr build/_workspace/pkg/ $(GOBIN)/* + +# The devtools target installs tools required for 'go generate'. +# You need to put $GOBIN (or $GOPATH/bin) in your PATH to use 'go generate'. + +devtools: + env GOBIN= go get -u golang.org/x/tools/cmd/stringer + env GOBIN= go get -u github.com/jteeuwen/go-bindata/go-bindata + env GOBIN= go get -u github.com/fjl/gencodec + env GOBIN= go install ./cmd/abigen + +# Cross Compilation Targets (xgo) + +geth-cross: geth-linux geth-darwin geth-windows geth-android geth-ios + @echo "Full cross compilation done:" + @ls -ld $(GOBIN)/geth-* + +geth-linux: geth-linux-386 geth-linux-amd64 geth-linux-arm geth-linux-mips64 geth-linux-mips64le + @echo "Linux cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* + +geth-linux-386: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/386 -v ./cmd/geth + @echo "Linux 386 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep 386 + +geth-linux-amd64: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/amd64 -v ./cmd/geth + @echo "Linux amd64 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep amd64 + +geth-linux-arm: geth-linux-arm-5 geth-linux-arm-6 geth-linux-arm-7 geth-linux-arm64 + @echo "Linux ARM cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep arm + +geth-linux-arm-5: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-5 -v ./cmd/geth + @echo "Linux ARMv5 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep arm-5 + +geth-linux-arm-6: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-6 -v ./cmd/geth + @echo "Linux ARMv6 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep arm-6 + +geth-linux-arm-7: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm-7 -v ./cmd/geth + @echo "Linux ARMv7 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep arm-7 + +geth-linux-arm64: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/arm64 -v ./cmd/geth + @echo "Linux ARM64 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep arm64 + +geth-linux-mips: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips --ldflags '-extldflags "-static"' -v ./cmd/geth + @echo "Linux MIPS cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep mips + +geth-linux-mipsle: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mipsle --ldflags '-extldflags "-static"' -v ./cmd/geth + @echo "Linux MIPSle cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep mipsle + +geth-linux-mips64: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips64 --ldflags '-extldflags "-static"' -v ./cmd/geth + @echo "Linux MIPS64 cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep mips64 + +geth-linux-mips64le: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=linux/mips64le --ldflags '-extldflags "-static"' -v ./cmd/geth + @echo "Linux MIPS64le cross compilation done:" + @ls -ld $(GOBIN)/geth-linux-* | grep mips64le + +geth-darwin: geth-darwin-386 geth-darwin-amd64 + @echo "Darwin cross compilation done:" + @ls -ld $(GOBIN)/geth-darwin-* + +geth-darwin-386: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=darwin/386 -v ./cmd/geth + @echo "Darwin 386 cross compilation done:" + @ls -ld $(GOBIN)/geth-darwin-* | grep 386 + +geth-darwin-amd64: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=darwin/amd64 -v ./cmd/geth + @echo "Darwin amd64 cross compilation done:" + @ls -ld $(GOBIN)/geth-darwin-* | grep amd64 + +geth-windows: geth-windows-386 geth-windows-amd64 + @echo "Windows cross compilation done:" + @ls -ld $(GOBIN)/geth-windows-* + +geth-windows-386: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=windows/386 -v ./cmd/geth + @echo "Windows 386 cross compilation done:" + @ls -ld $(GOBIN)/geth-windows-* | grep 386 + +geth-windows-amd64: + build/env.sh go run build/ci.go xgo -- --go=$(GO) --targets=windows/amd64 -v ./cmd/geth + @echo "Windows amd64 cross compilation done:" + @ls -ld $(GOBIN)/geth-windows-* | grep amd64 diff --git a/vendor/github.com/ethereum/go-ethereum/README.md b/vendor/github.com/ethereum/go-ethereum/README.md new file mode 100644 index 000000000..0ac9fe8fb --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/README.md @@ -0,0 +1,302 @@ +## Go Ethereum + +Official golang implementation of the Ethereum protocol. + +[![API Reference]( +https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667 +)](https://godoc.org/github.com/ethereum/go-ethereum) +[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/ethereum/go-ethereum?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) + +Automated builds are available for stable releases and the unstable master branch. +Binary archives are published at https://geth.ethereum.org/downloads/. + +## Building the source + +For prerequisites and detailed build instructions please read the +[Installation Instructions](https://github.com/ethereum/go-ethereum/wiki/Building-Ethereum) +on the wiki. + +Building geth requires both a Go (version 1.7 or later) and a C compiler. +You can install them using your favourite package manager. +Once the dependencies are installed, run + + make geth + +or, to build the full suite of utilities: + + make all + +## Executables + +The go-ethereum project comes with several wrappers/executables found in the `cmd` directory. + +| Command | Description | +|:----------:|-------------| +| **`geth`** | Our main Ethereum CLI client. It is the entry point into the Ethereum network (main-, test- or private net), capable of running as a full node (default) archive node (retaining all historical state) or a light node (retrieving data live). It can be used by other processes as a gateway into the Ethereum network via JSON RPC endpoints exposed on top of HTTP, WebSocket and/or IPC transports. `geth --help` and the [CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options) for command line options. | +| `abigen` | Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages. It operates on plain [Ethereum contract ABIs](https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI) with expanded functionality if the contract bytecode is also available. However it also accepts Solidity source files, making development much more streamlined. Please see our [Native DApps](https://github.com/ethereum/go-ethereum/wiki/Native-DApps:-Go-bindings-to-Ethereum-contracts) wiki page for details. | +| `bootnode` | Stripped down version of our Ethereum client implementation that only takes part in the network node discovery protocol, but does not run any of the higher level application protocols. It can be used as a lightweight bootstrap node to aid in finding peers in private networks. | +| `disasm` | Bytecode disassembler to convert EVM (Ethereum Virtual Machine) bytecode into more user friendly assembly-like opcodes (e.g. `echo "6001" | disasm`). For details on the individual opcodes, please see pages 22-30 of the [Ethereum Yellow Paper](http://gavwood.com/paper.pdf). | +| `evm` | Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode. Its purpose is to allow insolated, fine-grained debugging of EVM opcodes (e.g. `evm --code 60ff60ff --debug`). | +| `gethrpctest` | Developer utility tool to support our [ethereum/rpc-test](https://github.com/ethereum/rpc-tests) test suite which validates baseline conformity to the [Ethereum JSON RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC) specs. Please see the [test suite's readme](https://github.com/ethereum/rpc-tests/blob/master/README.md) for details. | +| `rlpdump` | Developer utility tool to convert binary RLP ([Recursive Length Prefix](https://github.com/ethereum/wiki/wiki/RLP)) dumps (data encoding used by the Ethereum protocol both network as well as consensus wise) to user friendlier hierarchical representation (e.g. `rlpdump --hex CE0183FFFFFFC4C304050583616263`). | +| `swarm` | swarm daemon and tools. This is the entrypoint for the swarm network. `swarm --help` for command line options and subcommands. See https://swarm-guide.readthedocs.io for swarm documentation. | + +## Running geth + +Going through all the possible command line flags is out of scope here (please consult our +[CLI Wiki page](https://github.com/ethereum/go-ethereum/wiki/Command-Line-Options)), but we've +enumerated a few common parameter combos to get you up to speed quickly on how you can run your +own Geth instance. + +### Full node on the main Ethereum network + +By far the most common scenario is people wanting to simply interact with the Ethereum network: +create accounts; transfer funds; deploy and interact with contracts. For this particular use-case +the user doesn't care about years-old historical data, so we can fast-sync quickly to the current +state of the network. To do so: + +``` +$ geth --fast --cache=512 console +``` + +This command will: + + * Start geth in fast sync mode (`--fast`), causing it to download more data in exchange for avoiding + processing the entire history of the Ethereum network, which is very CPU intensive. + * Bump the memory allowance of the database to 512MB (`--cache=512`), which can help significantly in + sync times especially for HDD users. This flag is optional and you can set it as high or as low as + you'd like, though we'd recommend the 512MB - 2GB range. + * Start up Geth's built-in interactive [JavaScript console](https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console), + (via the trailing `console` subcommand) through which you can invoke all official [`web3` methods](https://github.com/ethereum/wiki/wiki/JavaScript-API) + as well as Geth's own [management APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs). + This too is optional and if you leave it out you can always attach to an already running Geth instance + with `geth attach`. + +### Full node on the Ethereum test network + +Transitioning towards developers, if you'd like to play around with creating Ethereum contracts, you +almost certainly would like to do that without any real money involved until you get the hang of the +entire system. In other words, instead of attaching to the main network, you want to join the **test** +network with your node, which is fully equivalent to the main network, but with play-Ether only. + +``` +$ geth --testnet --fast --cache=512 console +``` + +The `--fast`, `--cache` flags and `console` subcommand have the exact same meaning as above and they +are equally useful on the testnet too. Please see above for their explanations if you've skipped to +here. + +Specifying the `--testnet` flag however will reconfigure your Geth instance a bit: + + * Instead of using the default data directory (`~/.ethereum` on Linux for example), Geth will nest + itself one level deeper into a `testnet` subfolder (`~/.ethereum/testnet` on Linux). Note, on OSX + and Linux this also means that attaching to a running testnet node requires the use of a custom + endpoint since `geth attach` will try to attach to a production node endpoint by default. E.g. + `geth attach /testnet/geth.ipc`. Windows users are not affected by this. + * Instead of connecting the main Ethereum network, the client will connect to the test network, + which uses different P2P bootnodes, different network IDs and genesis states. + +*Note: Although there are some internal protective measures to prevent transactions from crossing +over between the main network and test network, you should make sure to always use separate accounts +for play-money and real-money. Unless you manually move accounts, Geth will by default correctly +separate the two networks and will not make any accounts available between them.* + +### Configuration + +As an alternative to passing the numerous flags to the `geth` binary, you can also pass a configuration file via: + +``` +$ geth --config /path/to/your_config.toml +``` + +To get an idea how the file should look like you can use the `dumpconfig` subcommand to export your existing configuration: + +``` +$ geth --your-favourite-flags dumpconfig +``` + +*Note: This works only with geth v1.6.0 and above* + +#### Docker quick start + +One of the quickest ways to get Ethereum up and running on your machine is by using Docker: + +``` +docker run -d --name ethereum-node -v /Users/alice/ethereum:/root \ + -p 8545:8545 -p 30303:30303 \ + ethereum/client-go --fast --cache=512 +``` + +This will start geth in fast sync mode with a DB memory allowance of 512MB just as the above command does. It will also create a persistent volume in your home directory for saving your blockchain as well as map the default ports. There is also an `alpine` tag available for a slim version of the image. + +### Programatically interfacing Geth nodes + +As a developer, sooner rather than later you'll want to start interacting with Geth and the Ethereum +network via your own programs and not manually through the console. To aid this, Geth has built in +support for a JSON-RPC based APIs ([standard APIs](https://github.com/ethereum/wiki/wiki/JSON-RPC) and +[Geth specific APIs](https://github.com/ethereum/go-ethereum/wiki/Management-APIs)). These can be +exposed via HTTP, WebSockets and IPC (unix sockets on unix based platforms, and named pipes on Windows). + +The IPC interface is enabled by default and exposes all the APIs supported by Geth, whereas the HTTP +and WS interfaces need to manually be enabled and only expose a subset of APIs due to security reasons. +These can be turned on/off and configured as you'd expect. + +HTTP based JSON-RPC API options: + + * `--rpc` Enable the HTTP-RPC server + * `--rpcaddr` HTTP-RPC server listening interface (default: "localhost") + * `--rpcport` HTTP-RPC server listening port (default: 8545) + * `--rpcapi` API's offered over the HTTP-RPC interface (default: "eth,net,web3") + * `--rpccorsdomain` Comma separated list of domains from which to accept cross origin requests (browser enforced) + * `--ws` Enable the WS-RPC server + * `--wsaddr` WS-RPC server listening interface (default: "localhost") + * `--wsport` WS-RPC server listening port (default: 8546) + * `--wsapi` API's offered over the WS-RPC interface (default: "eth,net,web3") + * `--wsorigins` Origins from which to accept websockets requests + * `--ipcdisable` Disable the IPC-RPC server + * `--ipcapi` API's offered over the IPC-RPC interface (default: "admin,debug,eth,miner,net,personal,shh,txpool,web3") + * `--ipcpath` Filename for IPC socket/pipe within the datadir (explicit paths escape it) + +You'll need to use your own programming environments' capabilities (libraries, tools, etc) to connect +via HTTP, WS or IPC to a Geth node configured with the above flags and you'll need to speak [JSON-RPC](http://www.jsonrpc.org/specification) +on all transports. You can reuse the same connection for multiple requests! + +**Note: Please understand the security implications of opening up an HTTP/WS based transport before +doing so! Hackers on the internet are actively trying to subvert Ethereum nodes with exposed APIs! +Further, all browser tabs can access locally running webservers, so malicious webpages could try to +subvert locally available APIs!** + +### Operating a private network + +Maintaining your own private network is more involved as a lot of configurations taken for granted in +the official networks need to be manually set up. + +#### Defining the private genesis state + +First, you'll need to create the genesis state of your networks, which all nodes need to be aware of +and agree upon. This consists of a small JSON file (e.g. call it `genesis.json`): + +```json +{ + "config": { + "chainId": 0, + "homesteadBlock": 0, + "eip155Block": 0, + "eip158Block": 0 + }, + "alloc" : {}, + "coinbase" : "0x0000000000000000000000000000000000000000", + "difficulty" : "0x20000", + "extraData" : "", + "gasLimit" : "0x2fefd8", + "nonce" : "0x0000000000000042", + "mixhash" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "parentHash" : "0x0000000000000000000000000000000000000000000000000000000000000000", + "timestamp" : "0x00" +} +``` + +The above fields should be fine for most purposes, although we'd recommend changing the `nonce` to +some random value so you prevent unknown remote nodes from being able to connect to you. If you'd +like to pre-fund some accounts for easier testing, you can populate the `alloc` field with account +configs: + +```json +"alloc": { + "0x0000000000000000000000000000000000000001": {"balance": "111111111"}, + "0x0000000000000000000000000000000000000002": {"balance": "222222222"} +} +``` + +With the genesis state defined in the above JSON file, you'll need to initialize **every** Geth node +with it prior to starting it up to ensure all blockchain parameters are correctly set: + +``` +$ geth init path/to/genesis.json +``` + +#### Creating the rendezvous point + +With all nodes that you want to run initialized to the desired genesis state, you'll need to start a +bootstrap node that others can use to find each other in your network and/or over the internet. The +clean way is to configure and run a dedicated bootnode: + +``` +$ bootnode --genkey=boot.key +$ bootnode --nodekey=boot.key +``` + +With the bootnode online, it will display an [`enode` URL](https://github.com/ethereum/wiki/wiki/enode-url-format) +that other nodes can use to connect to it and exchange peer information. Make sure to replace the +displayed IP address information (most probably `[::]`) with your externally accessible IP to get the +actual `enode` URL. + +*Note: You could also use a full fledged Geth node as a bootnode, but it's the less recommended way.* + +#### Starting up your member nodes + +With the bootnode operational and externally reachable (you can try `telnet ` to ensure +it's indeed reachable), start every subsequent Geth node pointed to the bootnode for peer discovery +via the `--bootnodes` flag. It will probably also be desirable to keep the data directory of your +private network separated, so do also specify a custom `--datadir` flag. + +``` +$ geth --datadir=path/to/custom/data/folder --bootnodes= +``` + +*Note: Since your network will be completely cut off from the main and test networks, you'll also +need to configure a miner to process transactions and create new blocks for you.* + +#### Running a private miner + +Mining on the public Ethereum network is a complex task as it's only feasible using GPUs, requiring +an OpenCL or CUDA enabled `ethminer` instance. For information on such a setup, please consult the +[EtherMining subreddit](https://www.reddit.com/r/EtherMining/) and the [Genoil miner](https://github.com/Genoil/cpp-ethereum) +repository. + +In a private network setting however, a single CPU miner instance is more than enough for practical +purposes as it can produce a stable stream of blocks at the correct intervals without needing heavy +resources (consider running on a single thread, no need for multiple ones either). To start a Geth +instance for mining, run it with all your usual flags, extended by: + +``` +$ geth --mine --minerthreads=1 --etherbase=0x0000000000000000000000000000000000000000 +``` + +Which will start mining bocks and transactions on a single CPU thread, crediting all proceedings to +the account specified by `--etherbase`. You can further tune the mining by changing the default gas +limit blocks converge to (`--targetgaslimit`) and the price transactions are accepted at (`--gasprice`). + +## Contribution + +Thank you for considering to help out with the source code! We welcome contributions from +anyone on the internet, and are grateful for even the smallest of fixes! + +If you'd like to contribute to go-ethereum, please fork, fix, commit and send a pull request +for the maintainers to review and merge into the main code base. If you wish to submit more +complex changes though, please check up with the core devs first on [our gitter channel](https://gitter.im/ethereum/go-ethereum) +to ensure those changes are in line with the general philosophy of the project and/or get some +early feedback which can make both your efforts much lighter as well as our review and merge +procedures quick and simple. + +Please make sure your contributions adhere to our coding guidelines: + + * Code must adhere to the official Go [formatting](https://golang.org/doc/effective_go.html#formatting) guidelines (i.e. uses [gofmt](https://golang.org/cmd/gofmt/)). + * Code must be documented adhering to the official Go [commentary](https://golang.org/doc/effective_go.html#commentary) guidelines. + * Pull requests need to be based on and opened against the `master` branch. + * Commit messages should be prefixed with the package(s) they modify. + * E.g. "eth, rpc: make trace configs optional" + +Please see the [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide) +for more details on configuring your environment, managing project dependencies and testing procedures. + +## License + +The go-ethereum library (i.e. all code outside of the `cmd` directory) is licensed under the +[GNU Lesser General Public License v3.0](https://www.gnu.org/licenses/lgpl-3.0.en.html), also +included in our repository in the `COPYING.LESSER` file. + +The go-ethereum binaries (i.e. all code inside of the `cmd` directory) is licensed under the +[GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html), also included +in our repository in the `COPYING` file. diff --git a/vendor/github.com/ethereum/go-ethereum/VERSION b/vendor/github.com/ethereum/go-ethereum/VERSION new file mode 100644 index 000000000..400084b1b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/VERSION @@ -0,0 +1 @@ +1.6.7 diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/abi.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/abi.go index 3d1010229..2a06d474b 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/abi.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/abi.go @@ -17,11 +17,9 @@ package abi import ( - "encoding/binary" "encoding/json" "fmt" "io" - "math/big" "reflect" "strings" @@ -67,7 +65,7 @@ func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) { } method = m } - arguments, err := method.pack(method, args...) + arguments, err := method.pack(args...) if err != nil { return nil, err } @@ -78,199 +76,6 @@ func (abi ABI) Pack(name string, args ...interface{}) ([]byte, error) { return append(method.Id(), arguments...), nil } -// toGoSliceType parses the input and casts it to the proper slice defined by the ABI -// argument in T. -func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { - index := i * 32 - // The slice must, at very least be large enough for the index+32 which is exactly the size required - // for the [offset in output, size of offset]. - if index+32 > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go slice: insufficient size output %d require %d", len(output), index+32) - } - elem := t.Type.Elem - - // first we need to create a slice of the type - var refSlice reflect.Value - switch elem.T { - case IntTy, UintTy, BoolTy: - // create a new reference slice matching the element type - switch t.Type.Kind { - case reflect.Bool: - refSlice = reflect.ValueOf([]bool(nil)) - case reflect.Uint8: - refSlice = reflect.ValueOf([]uint8(nil)) - case reflect.Uint16: - refSlice = reflect.ValueOf([]uint16(nil)) - case reflect.Uint32: - refSlice = reflect.ValueOf([]uint32(nil)) - case reflect.Uint64: - refSlice = reflect.ValueOf([]uint64(nil)) - case reflect.Int8: - refSlice = reflect.ValueOf([]int8(nil)) - case reflect.Int16: - refSlice = reflect.ValueOf([]int16(nil)) - case reflect.Int32: - refSlice = reflect.ValueOf([]int32(nil)) - case reflect.Int64: - refSlice = reflect.ValueOf([]int64(nil)) - default: - refSlice = reflect.ValueOf([]*big.Int(nil)) - } - case AddressTy: // address must be of slice Address - refSlice = reflect.ValueOf([]common.Address(nil)) - case HashTy: // hash must be of slice hash - refSlice = reflect.ValueOf([]common.Hash(nil)) - case FixedBytesTy: - refSlice = reflect.ValueOf([][]byte(nil)) - default: // no other types are supported - return nil, fmt.Errorf("abi: unsupported slice type %v", elem.T) - } - - var slice []byte - var size int - var offset int - if t.Type.IsSlice { - // get the offset which determines the start of this array ... - offset = int(binary.BigEndian.Uint64(output[index+24 : index+32])) - if offset+32 > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go slice: offset %d would go over slice boundary (len=%d)", len(output), offset+32) - } - - slice = output[offset:] - // ... starting with the size of the array in elements ... - size = int(binary.BigEndian.Uint64(slice[24:32])) - slice = slice[32:] - // ... and make sure that we've at the very least the amount of bytes - // available in the buffer. - if size*32 > len(slice) { - return nil, fmt.Errorf("abi: cannot marshal in to go slice: insufficient size output %d require %d", len(output), offset+32+size*32) - } - - // reslice to match the required size - slice = slice[:size*32] - } else if t.Type.IsArray { - //get the number of elements in the array - size = t.Type.SliceSize - - //check to make sure array size matches up - if index+32*size > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go array: offset %d would go over slice boundary (len=%d)", len(output), index+32*size) - } - //slice is there for a fixed amount of times - slice = output[index : index+size*32] - } - - for i := 0; i < size; i++ { - var ( - inter interface{} // interface type - returnOutput = slice[i*32 : i*32+32] // the return output - ) - // set inter to the correct type (cast) - switch elem.T { - case IntTy, UintTy: - inter = readInteger(t.Type.Kind, returnOutput) - case BoolTy: - inter = !allZero(returnOutput) - case AddressTy: - inter = common.BytesToAddress(returnOutput) - case HashTy: - inter = common.BytesToHash(returnOutput) - case FixedBytesTy: - inter = returnOutput - } - // append the item to our reflect slice - refSlice = reflect.Append(refSlice, reflect.ValueOf(inter)) - } - - // return the interface - return refSlice.Interface(), nil -} - -func readInteger(kind reflect.Kind, b []byte) interface{} { - switch kind { - case reflect.Uint8: - return uint8(b[len(b)-1]) - case reflect.Uint16: - return binary.BigEndian.Uint16(b[len(b)-2:]) - case reflect.Uint32: - return binary.BigEndian.Uint32(b[len(b)-4:]) - case reflect.Uint64: - return binary.BigEndian.Uint64(b[len(b)-8:]) - case reflect.Int8: - return int8(b[len(b)-1]) - case reflect.Int16: - return int16(binary.BigEndian.Uint16(b[len(b)-2:])) - case reflect.Int32: - return int32(binary.BigEndian.Uint32(b[len(b)-4:])) - case reflect.Int64: - return int64(binary.BigEndian.Uint64(b[len(b)-8:])) - default: - return new(big.Int).SetBytes(b) - } -} - -func allZero(b []byte) bool { - for _, byte := range b { - if byte != 0 { - return false - } - } - return true -} - -// toGoType parses the input and casts it to the proper type defined by the ABI -// argument in T. -func toGoType(i int, t Argument, output []byte) (interface{}, error) { - // we need to treat slices differently - if (t.Type.IsSlice || t.Type.IsArray) && t.Type.T != BytesTy && t.Type.T != StringTy && t.Type.T != FixedBytesTy && t.Type.T != FunctionTy { - return toGoSlice(i, t, output) - } - - index := i * 32 - if index+32 > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), index+32) - } - - // Parse the given index output and check whether we need to read - // a different offset and length based on the type (i.e. string, bytes) - var returnOutput []byte - switch t.Type.T { - case StringTy, BytesTy: // variable arrays are written at the end of the return bytes - // parse offset from which we should start reading - offset := int(binary.BigEndian.Uint64(output[index+24 : index+32])) - if offset+32 > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32) - } - // parse the size up until we should be reading - size := int(binary.BigEndian.Uint64(output[offset+24 : offset+32])) - if offset+32+size > len(output) { - return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32+size) - } - - // get the bytes for this return value - returnOutput = output[offset+32 : offset+32+size] - default: - returnOutput = output[index : index+32] - } - - // convert the bytes to whatever is specified by the ABI. - switch t.Type.T { - case IntTy, UintTy: - return readInteger(t.Type.Kind, returnOutput), nil - case BoolTy: - return !allZero(returnOutput), nil - case AddressTy: - return common.BytesToAddress(returnOutput), nil - case HashTy: - return common.BytesToHash(returnOutput), nil - case BytesTy, FixedBytesTy, FunctionTy: - return returnOutput, nil - case StringTy: - return string(returnOutput), nil - } - return nil, fmt.Errorf("abi: unknown type %v", t.Type.T) -} - // these variable are used to determine certain types during type assertion for // assignment. var ( diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/bind/backends/simulated.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/bind/backends/simulated.go index 159fca136..7ac8b5820 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/bind/backends/simulated.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/bind/backends/simulated.go @@ -90,7 +90,7 @@ func (b *SimulatedBackend) Rollback() { func (b *SimulatedBackend) rollback() { blocks, _ := core.GenerateChain(b.config, b.blockchain.CurrentBlock(), b.database, 1, func(int, *core.BlockGen) {}) b.pendingBlock = blocks[0] - b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database) + b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) } // CodeAt returns the code associated with a certain account in the blockchain. @@ -279,7 +279,7 @@ func (b *SimulatedBackend) SendTransaction(ctx context.Context, tx *types.Transa block.AddTx(tx) }) b.pendingBlock = blocks[0] - b.pendingState, _ = state.New(b.pendingBlock.Root(), b.database) + b.pendingState, _ = state.New(b.pendingBlock.Root(), state.NewDatabase(b.database)) return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/error.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/error.go index 67739c21d..420acf418 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/error.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/error.go @@ -17,10 +17,15 @@ package abi import ( + "errors" "fmt" "reflect" ) +var ( + errBadBool = errors.New("abi: improperly encoded boolean value") +) + // formatSliceString formats the reflection kind with the given slice size // and returns a formatted string representation. func formatSliceString(kind reflect.Kind, sliceSize int) string { diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/method.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/method.go index d56f3bc3d..62b3d2957 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/method.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/method.go @@ -39,7 +39,7 @@ type Method struct { Outputs []Argument } -func (m Method) pack(method Method, args ...interface{}) ([]byte, error) { +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)) diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/numbers.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/numbers.go index 10afa6511..5d3efff52 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/numbers.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/numbers.go @@ -62,19 +62,6 @@ func U256(n *big.Int) []byte { return math.PaddedBigBytes(math.U256(n), 32) } -// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation -func packNum(value reflect.Value) []byte { - switch kind := value.Kind(); kind { - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - return U256(new(big.Int).SetUint64(value.Uint())) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - return U256(big.NewInt(value.Int())) - case reflect.Ptr: - return U256(value.Interface().(*big.Int)) - } - return nil -} - // checks whether the given reflect value is signed. This also works for slices with a number type func isSigned(v reflect.Value) bool { switch v.Type() { diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/packing.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/pack.go similarity index 80% rename from vendor/github.com/ethereum/go-ethereum/accounts/abi/packing.go rename to vendor/github.com/ethereum/go-ethereum/accounts/abi/pack.go index 1d7f85e2b..4d8a3f031 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/packing.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/pack.go @@ -17,6 +17,7 @@ package abi import ( + "math/big" "reflect" "github.com/ethereum/go-ethereum/common" @@ -59,8 +60,20 @@ func packElement(t Type, reflectValue reflect.Value) []byte { if reflectValue.Kind() == reflect.Array { reflectValue = mustArrayToByteSlice(reflectValue) } - return common.RightPadBytes(reflectValue.Bytes(), 32) } panic("abi: fatal error") } + +// packNum packs the given number (using the reflect value) and will cast it to appropriate number representation +func packNum(value reflect.Value) []byte { + switch kind := value.Kind(); kind { + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + return U256(new(big.Int).SetUint64(value.Uint())) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return U256(big.NewInt(value.Int())) + case reflect.Ptr: + return U256(value.Interface().(*big.Int)) + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/reflect.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/reflect.go index 7970ba8ac..8fa75df07 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/reflect.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/reflect.go @@ -32,30 +32,30 @@ func indirect(v reflect.Value) reflect.Value { // reflectIntKind returns the reflect using the given size and // unsignedness. -func reflectIntKind(unsigned bool, size int) reflect.Kind { +func reflectIntKindAndType(unsigned bool, size int) (reflect.Kind, reflect.Type) { switch size { case 8: if unsigned { - return reflect.Uint8 + return reflect.Uint8, uint8_t } - return reflect.Int8 + return reflect.Int8, int8_t case 16: if unsigned { - return reflect.Uint16 + return reflect.Uint16, uint16_t } - return reflect.Int16 + return reflect.Int16, int16_t case 32: if unsigned { - return reflect.Uint32 + return reflect.Uint32, uint32_t } - return reflect.Int32 + return reflect.Int32, int32_t case 64: if unsigned { - return reflect.Uint64 + return reflect.Uint64, uint64_t } - return reflect.Int64 + return reflect.Int64, int64_t } - return reflect.Ptr + return reflect.Ptr, big_t } // mustArrayToBytesSlice creates a new byte slice with the exact same size as value diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/type.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/type.go index f2832aef5..5f20babb3 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/abi/type.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/type.go @@ -33,7 +33,7 @@ const ( FixedBytesTy BytesTy HashTy - FixedpointTy + FixedPointTy FunctionTy ) @@ -126,13 +126,11 @@ func NewType(t string) (typ Type, err error) { switch varType { case "int": - typ.Kind = reflectIntKind(false, varSize) - typ.Type = big_t + typ.Kind, typ.Type = reflectIntKindAndType(false, varSize) typ.Size = varSize typ.T = IntTy case "uint": - typ.Kind = reflectIntKind(true, varSize) - typ.Type = ubig_t + typ.Kind, typ.Type = reflectIntKindAndType(true, varSize) typ.Size = varSize typ.T = UintTy case "bool": diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/abi/unpack.go b/vendor/github.com/ethereum/go-ethereum/accounts/abi/unpack.go new file mode 100644 index 000000000..fc41c88ac --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/abi/unpack.go @@ -0,0 +1,235 @@ +// Copyright 2015 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 abi + +import ( + "encoding/binary" + "fmt" + "math/big" + "reflect" + + "github.com/ethereum/go-ethereum/common" +) + +// toGoSliceType parses the input and casts it to the proper slice defined by the ABI +// argument in T. +func toGoSlice(i int, t Argument, output []byte) (interface{}, error) { + index := i * 32 + // The slice must, at very least be large enough for the index+32 which is exactly the size required + // for the [offset in output, size of offset]. + if index+32 > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go slice: insufficient size output %d require %d", len(output), index+32) + } + elem := t.Type.Elem + + // first we need to create a slice of the type + var refSlice reflect.Value + switch elem.T { + case IntTy, UintTy, BoolTy: + // create a new reference slice matching the element type + switch t.Type.Kind { + case reflect.Bool: + refSlice = reflect.ValueOf([]bool(nil)) + case reflect.Uint8: + refSlice = reflect.ValueOf([]uint8(nil)) + case reflect.Uint16: + refSlice = reflect.ValueOf([]uint16(nil)) + case reflect.Uint32: + refSlice = reflect.ValueOf([]uint32(nil)) + case reflect.Uint64: + refSlice = reflect.ValueOf([]uint64(nil)) + case reflect.Int8: + refSlice = reflect.ValueOf([]int8(nil)) + case reflect.Int16: + refSlice = reflect.ValueOf([]int16(nil)) + case reflect.Int32: + refSlice = reflect.ValueOf([]int32(nil)) + case reflect.Int64: + refSlice = reflect.ValueOf([]int64(nil)) + default: + refSlice = reflect.ValueOf([]*big.Int(nil)) + } + case AddressTy: // address must be of slice Address + refSlice = reflect.ValueOf([]common.Address(nil)) + case HashTy: // hash must be of slice hash + refSlice = reflect.ValueOf([]common.Hash(nil)) + case FixedBytesTy: + refSlice = reflect.ValueOf([][]byte(nil)) + default: // no other types are supported + return nil, fmt.Errorf("abi: unsupported slice type %v", elem.T) + } + + var slice []byte + var size int + var offset int + if t.Type.IsSlice { + // get the offset which determines the start of this array ... + offset = int(binary.BigEndian.Uint64(output[index+24 : index+32])) + if offset+32 > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go slice: offset %d would go over slice boundary (len=%d)", len(output), offset+32) + } + + slice = output[offset:] + // ... starting with the size of the array in elements ... + size = int(binary.BigEndian.Uint64(slice[24:32])) + slice = slice[32:] + // ... and make sure that we've at the very least the amount of bytes + // available in the buffer. + if size*32 > len(slice) { + return nil, fmt.Errorf("abi: cannot marshal in to go slice: insufficient size output %d require %d", len(output), offset+32+size*32) + } + + // reslice to match the required size + slice = slice[:size*32] + } else if t.Type.IsArray { + //get the number of elements in the array + size = t.Type.SliceSize + + //check to make sure array size matches up + if index+32*size > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go array: offset %d would go over slice boundary (len=%d)", len(output), index+32*size) + } + //slice is there for a fixed amount of times + slice = output[index : index+size*32] + } + + for i := 0; i < size; i++ { + var ( + inter interface{} // interface type + returnOutput = slice[i*32 : i*32+32] // the return output + err error + ) + // set inter to the correct type (cast) + switch elem.T { + case IntTy, UintTy: + inter = readInteger(t.Type.Kind, returnOutput) + case BoolTy: + inter, err = readBool(returnOutput) + if err != nil { + return nil, err + } + case AddressTy: + inter = common.BytesToAddress(returnOutput) + case HashTy: + inter = common.BytesToHash(returnOutput) + case FixedBytesTy: + inter = returnOutput + } + // append the item to our reflect slice + refSlice = reflect.Append(refSlice, reflect.ValueOf(inter)) + } + + // return the interface + return refSlice.Interface(), nil +} + +func readInteger(kind reflect.Kind, b []byte) interface{} { + switch kind { + case reflect.Uint8: + return uint8(b[len(b)-1]) + case reflect.Uint16: + return binary.BigEndian.Uint16(b[len(b)-2:]) + case reflect.Uint32: + return binary.BigEndian.Uint32(b[len(b)-4:]) + case reflect.Uint64: + return binary.BigEndian.Uint64(b[len(b)-8:]) + case reflect.Int8: + return int8(b[len(b)-1]) + case reflect.Int16: + return int16(binary.BigEndian.Uint16(b[len(b)-2:])) + case reflect.Int32: + return int32(binary.BigEndian.Uint32(b[len(b)-4:])) + case reflect.Int64: + return int64(binary.BigEndian.Uint64(b[len(b)-8:])) + default: + return new(big.Int).SetBytes(b) + } +} + +func readBool(word []byte) (bool, error) { + if len(word) != 32 { + return false, fmt.Errorf("abi: fatal error: incorrect word length") + } + + for i, b := range word { + if b != 0 && i != 31 { + return false, errBadBool + } + } + switch word[31] { + case 0: + return false, nil + case 1: + return true, nil + default: + return false, errBadBool + } + +} + +// toGoType parses the input and casts it to the proper type defined by the ABI +// argument in T. +func toGoType(i int, t Argument, output []byte) (interface{}, error) { + // we need to treat slices differently + if (t.Type.IsSlice || t.Type.IsArray) && t.Type.T != BytesTy && t.Type.T != StringTy && t.Type.T != FixedBytesTy && t.Type.T != FunctionTy { + return toGoSlice(i, t, output) + } + + index := i * 32 + if index+32 > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), index+32) + } + + // Parse the given index output and check whether we need to read + // a different offset and length based on the type (i.e. string, bytes) + var returnOutput []byte + switch t.Type.T { + case StringTy, BytesTy: // variable arrays are written at the end of the return bytes + // parse offset from which we should start reading + offset := int(binary.BigEndian.Uint64(output[index+24 : index+32])) + if offset+32 > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32) + } + // parse the size up until we should be reading + size := int(binary.BigEndian.Uint64(output[offset+24 : offset+32])) + if offset+32+size > len(output) { + return nil, fmt.Errorf("abi: cannot marshal in to go type: length insufficient %d require %d", len(output), offset+32+size) + } + + // get the bytes for this return value + returnOutput = output[offset+32 : offset+32+size] + default: + returnOutput = output[index : index+32] + } + + // convert the bytes to whatever is specified by the ABI. + switch t.Type.T { + case IntTy, UintTy: + return readInteger(t.Type.Kind, returnOutput), nil + case BoolTy: + return readBool(returnOutput) + case AddressTy: + return common.BytesToAddress(returnOutput), nil + case HashTy: + return common.BytesToHash(returnOutput), nil + case BytesTy, FixedBytesTy, FunctionTy: + return returnOutput, nil + case StringTy: + return string(returnOutput), nil + } + return nil, fmt.Errorf("abi: unknown type %v", t.Type.T) +} diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/errors.go b/vendor/github.com/ethereum/go-ethereum/accounts/errors.go index 9ecc1eafd..64da8821c 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/errors.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/errors.go @@ -38,7 +38,7 @@ var ErrNotSupported = errors.New("not supported") var ErrInvalidPassphrase = errors.New("invalid passphrase") // ErrWalletAlreadyOpen is returned if a wallet is attempted to be opened the -// secodn time. +// second time. var ErrWalletAlreadyOpen = errors.New("wallet already open") // ErrWalletClosed is returned if a wallet is attempted to be opened the diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/key.go b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/key.go index 0b5262bd6..25a1bb71b 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/key.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/key.go @@ -134,14 +134,13 @@ func (k *Key) UnmarshalJSON(j []byte) (err error) { if err != nil { return err } - - privkey, err := hex.DecodeString(keyJSON.PrivateKey) + privkey, err := crypto.HexToECDSA(keyJSON.PrivateKey) if err != nil { return err } k.Address = common.BytesToAddress(addr) - k.PrivateKey = crypto.ToECDSA(privkey) + k.PrivateKey = privkey return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore.go b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore.go index d7be29ead..d294310b3 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore.go @@ -456,7 +456,6 @@ func (ks *KeyStore) ImportECDSA(priv *ecdsa.PrivateKey, passphrase string) (acco if ks.cache.hasAddress(key.Address) { return accounts.Account{}, fmt.Errorf("account already exists") } - return ks.importKey(key, passphrase) } diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore_passphrase.go b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore_passphrase.go index dd21a87e2..bd07d9560 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore_passphrase.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/keystore_passphrase.go @@ -259,7 +259,8 @@ func DecryptKey(keyjson []byte, auth string) (*Key, error) { if err != nil { return nil, err } - key := crypto.ToECDSA(keyBytes) + key := crypto.ToECDSAUnsafe(keyBytes) + return &Key{ Id: uuid.UUID(keyId), Address: crypto.PubkeyToAddress(key.PublicKey), diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/presale.go b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/presale.go index 5b883c45f..ed900ad08 100644 --- a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/presale.go +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/presale.go @@ -74,7 +74,8 @@ func decryptPreSaleKey(fileContent []byte, password string) (key *Key, err error return nil, err } ethPriv := crypto.Keccak256(plainText) - ecKey := crypto.ToECDSA(ethPriv) + ecKey := crypto.ToECDSAUnsafe(ethPriv) + key = &Key{ Id: nil, Address: crypto.PubkeyToAddress(ecKey.PublicKey), diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/1 b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/1 new file mode 100644 index 000000000..a3868ec6d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/1 @@ -0,0 +1 @@ +{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/2 b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/2 new file mode 100644 index 000000000..a3868ec6d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/2 @@ -0,0 +1 @@ +{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/foo b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/foo new file mode 100644 index 000000000..c57060aea --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/dupes/foo @@ -0,0 +1 @@ +{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/.hiddenfile b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/.hiddenfile new file mode 100644 index 000000000..d91faccde --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/.hiddenfile @@ -0,0 +1 @@ +{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/README b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/README new file mode 100644 index 000000000..a5a86f964 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/README @@ -0,0 +1,21 @@ +This directory contains accounts for testing. +The passphrase that unlocks them is "foobar". + +The "good" key files which are supposed to be loadable are: + +- File: UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8 + Address: 0x7ef5a6135f1fd6a02593eedc869c6d41d934aef8 +- File: aaa + Address: 0xf466859ead1932d743d622cb74fc058882e8648a +- File: zzz + Address: 0x289d485d9771714cce91d3393d764e1311907acc + +The other files (including this README) are broken in various ways +and should not be picked up by package accounts: + +- File: no-address (missing address field, otherwise same as "aaa") +- File: garbage (file with random data) +- File: empty (file with no content) +- File: swapfile~ (should be skipped) +- File: .hiddenfile (should be skipped) +- File: foo/... (should be skipped because it is a directory) diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8 b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8 new file mode 100644 index 000000000..c57060aea --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/UTC--2016-03-22T12-57-55.920751759Z--7ef5a6135f1fd6a02593eedc869c6d41d934aef8 @@ -0,0 +1 @@ +{"address":"7ef5a6135f1fd6a02593eedc869c6d41d934aef8","crypto":{"cipher":"aes-128-ctr","ciphertext":"1d0839166e7a15b9c1333fc865d69858b22df26815ccf601b28219b6192974e1","cipherparams":{"iv":"8df6caa7ff1b00c4e871f002cb7921ed"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"e5e6ef3f4ea695f496b643ebd3f75c0aa58ef4070e90c80c5d3fb0241bf1595c"},"mac":"6d16dfde774845e4585357f24bce530528bc69f4f84e1e22880d34fa45c273e5"},"id":"950077c7-71e3-4c44-a4a1-143919141ed4","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/aaa b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/aaa new file mode 100644 index 000000000..a3868ec6d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/aaa @@ -0,0 +1 @@ +{"address":"f466859ead1932d743d622cb74fc058882e8648a","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/empty b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/empty new file mode 100644 index 000000000..e69de29bb diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e new file mode 100644 index 000000000..309841e52 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/foo/fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e @@ -0,0 +1 @@ +{"address":"fd9bd350f08ee3c0c19b85a8e16114a11a60aa4e","crypto":{"cipher":"aes-128-ctr","ciphertext":"8124d5134aa4a927c79fd852989e4b5419397566f04b0936a1eb1d168c7c68a5","cipherparams":{"iv":"e2febe17176414dd2cda28287947eb2f"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":4096,"p":6,"r":8,"salt":"44b415ede89f3bdd6830390a21b78965f571b347a589d1d943029f016c5e8bd5"},"mac":"5e149ff25bfd9dd45746a84bb2bcd2f015f2cbca2b6d25c5de8c29617f71fe5b"},"id":"d6ac5452-2b2c-4d3c-ad80-4bf0327d971c","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/garbage b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/garbage new file mode 100644 index 000000000..ff45091e7 Binary files /dev/null and b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/garbage differ diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/no-address b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/no-address new file mode 100644 index 000000000..ad51269ea --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/no-address @@ -0,0 +1 @@ +{"crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zero b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zero new file mode 100644 index 000000000..b52617f8a --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zero @@ -0,0 +1 @@ +{"address":"0000000000000000000000000000000000000000","crypto":{"cipher":"aes-128-ctr","ciphertext":"cb664472deacb41a2e995fa7f96fe29ce744471deb8d146a0e43c7898c9ddd4d","cipherparams":{"iv":"dfd9ee70812add5f4b8f89d0811c9158"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"0d6769bf016d45c479213990d6a08d938469c4adad8a02ce507b4a4e7b7739f1"},"mac":"bac9af994b15a45dd39669fc66f9aa8a3b9dd8c22cb16e4d8d7ea089d0f1a1a9"},"id":"472e8b3d-afb6-45b5-8111-72c89895099a","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zzz b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zzz new file mode 100644 index 000000000..cfd8a4701 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/keystore/zzz @@ -0,0 +1 @@ +{"address":"289d485d9771714cce91d3393d764e1311907acc","crypto":{"cipher":"aes-128-ctr","ciphertext":"faf32ca89d286b107f5e6d842802e05263c49b78d46eac74e6109e9a963378ab","cipherparams":{"iv":"558833eec4a665a8c55608d7d503407d"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":8,"p":16,"r":8,"salt":"d571fff447ffb24314f9513f5160246f09997b857ac71348b73e785aab40dc04"},"mac":"21edb85ff7d0dab1767b9bf498f2c3cb7be7609490756bd32300bb213b59effe"},"id":"3279afcf-55ba-43ff-8997-02dcc46a6525","version":3} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e new file mode 100644 index 000000000..498d8131e --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e/cb61d5a9c4896fb9658090b597ef0e7be6f7b67e @@ -0,0 +1 @@ +{"address":"cb61d5a9c4896fb9658090b597ef0e7be6f7b67e","Crypto":{"cipher":"aes-128-cbc","ciphertext":"6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0","cipherparams":{"iv":"35337770fc2117994ecdcad026bccff4"},"kdf":"scrypt","kdfparams":{"n":262144,"r":8,"p":1,"dklen":32,"salt":"9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f"},"mac":"3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644","version":"1"},"id":"e25f7c1f-d318-4f29-b62c-687190d4d299","version":"1"} \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1_test_vector.json b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1_test_vector.json new file mode 100644 index 000000000..3d09b55b5 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v1_test_vector.json @@ -0,0 +1,28 @@ +{ + "test1": { + "json": { + "Crypto": { + "cipher": "aes-128-cbc", + "cipherparams": { + "iv": "35337770fc2117994ecdcad026bccff4" + }, + "ciphertext": "6143d3192db8b66eabd693d9c4e414dcfaee52abda451af79ccf474dafb35f1bfc7ea013aa9d2ee35969a1a2e8d752d0", + "kdf": "scrypt", + "kdfparams": { + "dklen": 32, + "n": 262144, + "p": 1, + "r": 8, + "salt": "9afcddebca541253a2f4053391c673ff9fe23097cd8555d149d929e4ccf1257f" + }, + "mac": "3f3d5af884b17a100b0b3232c0636c230a54dc2ac8d986227219b0dd89197644", + "version": "1" + }, + "address": "cb61d5a9c4896fb9658090b597ef0e7be6f7b67e", + "id": "e25f7c1f-d318-4f29-b62c-687190d4d299", + "version": "1" + }, + "password": "g", + "priv": "d1b1178d3529626a1a93e073f65028370d14c7eb0936eb42abef05db6f37ad7d" + } +} diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v3_test_vector.json b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v3_test_vector.json new file mode 100644 index 000000000..1e7f790c0 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/v3_test_vector.json @@ -0,0 +1,97 @@ +{ + "wikipage_test_vector_scrypt": { + "json": { + "crypto" : { + "cipher" : "aes-128-ctr", + "cipherparams" : { + "iv" : "83dbcc02d8ccb40e466191a123791e0e" + }, + "ciphertext" : "d172bf743a674da9cdad04534d56926ef8358534d458fffccd4e6ad2fbde479c", + "kdf" : "scrypt", + "kdfparams" : { + "dklen" : 32, + "n" : 262144, + "r" : 1, + "p" : 8, + "salt" : "ab0c7876052600dd703518d6fc3fe8984592145b591fc8fb5c6d43190334ba19" + }, + "mac" : "2103ac29920d71da29f15d75b4a16dbe95cfd7ff8faea1056c33131d846e3097" + }, + "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6", + "version" : 3 + }, + "password": "testpassword", + "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d" + }, + "wikipage_test_vector_pbkdf2": { + "json": { + "crypto" : { + "cipher" : "aes-128-ctr", + "cipherparams" : { + "iv" : "6087dab2f9fdbbfaddc31a909735c1e6" + }, + "ciphertext" : "5318b4d5bcd28de64ee5559e671353e16f075ecae9f99c7a79a38af5f869aa46", + "kdf" : "pbkdf2", + "kdfparams" : { + "c" : 262144, + "dklen" : 32, + "prf" : "hmac-sha256", + "salt" : "ae3cd4e7013836a3df6bd7241b12db061dbe2c6785853cce422d148a624ce0bd" + }, + "mac" : "517ead924a9d0dc3124507e3393d175ce3ff7c1e96529c6c555ce9e51205e9b2" + }, + "id" : "3198bc9c-6672-5ab3-d995-4942343ae5b6", + "version" : 3 + }, + "password": "testpassword", + "priv": "7a28b5ba57c53603b0b07b56bba752f7784bf506fa95edc395f5cf6c7514fe9d" + }, + "31_byte_key": { + "json": { + "crypto" : { + "cipher" : "aes-128-ctr", + "cipherparams" : { + "iv" : "e0c41130a323adc1446fc82f724bca2f" + }, + "ciphertext" : "9517cd5bdbe69076f9bf5057248c6c050141e970efa36ce53692d5d59a3984", + "kdf" : "scrypt", + "kdfparams" : { + "dklen" : 32, + "n" : 2, + "r" : 8, + "p" : 1, + "salt" : "711f816911c92d649fb4c84b047915679933555030b3552c1212609b38208c63" + }, + "mac" : "d5e116151c6aa71470e67a7d42c9620c75c4d23229847dcc127794f0732b0db5" + }, + "id" : "fecfc4ce-e956-48fd-953b-30f8b52ed66c", + "version" : 3 + }, + "password": "foo", + "priv": "fa7b3db73dc7dfdf8c5fbdb796d741e4488628c41fc4febd9160a866ba0f35" + }, + "30_byte_key": { + "json": { + "crypto" : { + "cipher" : "aes-128-ctr", + "cipherparams" : { + "iv" : "3ca92af36ad7c2cd92454c59cea5ef00" + }, + "ciphertext" : "108b7d34f3442fc26ab1ab90ca91476ba6bfa8c00975a49ef9051dc675aa", + "kdf" : "scrypt", + "kdfparams" : { + "dklen" : 32, + "n" : 2, + "r" : 8, + "p" : 1, + "salt" : "d0769e608fb86cda848065642a9c6fa046845c928175662b8e356c77f914cd3b" + }, + "mac" : "75d0e6759f7b3cefa319c3be41680ab6beea7d8328653474bd06706d4cc67420" + }, + "id" : "a37e1559-5955-450d-8075-7b8931b392b2", + "version" : 3 + }, + "password": "foo", + "priv": "81c29e8142bb6a81bef5a92bda7a8328a5c85bb2f9542e76f9b0f94fc018" + } +} diff --git a/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/very-light-scrypt.json b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/very-light-scrypt.json new file mode 100644 index 000000000..d23b9b2b9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/accounts/keystore/testdata/very-light-scrypt.json @@ -0,0 +1 @@ +{"address":"45dea0fb0bba44f4fcf290bba71fd57d7117cbb8","crypto":{"cipher":"aes-128-ctr","ciphertext":"b87781948a1befd247bff51ef4063f716cf6c2d3481163e9a8f42e1f9bb74145","cipherparams":{"iv":"dc4926b48a105133d2f16b96833abf1e"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":2,"p":1,"r":8,"salt":"004244bbdc51cadda545b1cfa43cff9ed2ae88e08c61f1479dbb45410722f8f0"},"mac":"39990c1684557447940d4c69e06b1b82b2aceacb43f284df65c956daf3046b85"},"id":"ce541d8d-c79b-40f8-9f8c-20f59616faba","version":3} diff --git a/vendor/github.com/ethereum/go-ethereum/appveyor.yml b/vendor/github.com/ethereum/go-ethereum/appveyor.yml new file mode 100644 index 000000000..945cafaf2 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/appveyor.yml @@ -0,0 +1,40 @@ +os: Visual Studio 2015 + +# Clone directly into GOPATH. +clone_folder: C:\gopath\src\github.com\ethereum\go-ethereum +clone_depth: 5 +version: "{branch}.{build}" +environment: + global: + GOPATH: C:\gopath + CC: gcc.exe + matrix: + - GETH_ARCH: amd64 + MSYS2_ARCH: x86_64 + MSYS2_BITS: 64 + MSYSTEM: MINGW64 + PATH: C:\msys64\mingw64\bin\;C:\Program Files (x86)\NSIS\;%PATH% + - GETH_ARCH: 386 + MSYS2_ARCH: i686 + MSYS2_BITS: 32 + MSYSTEM: MINGW32 + PATH: C:\msys64\mingw32\bin\;C:\Program Files (x86)\NSIS\;%PATH% + +install: + - git submodule update --init + - rmdir C:\go /s /q + - appveyor DownloadFile https://storage.googleapis.com/golang/go1.8.3.windows-%GETH_ARCH%.zip + - 7z x go1.8.3.windows-%GETH_ARCH%.zip -y -oC:\ > NUL + - go version + - gcc --version + +build_script: + - go run build\ci.go install + +after_build: + - go run build\ci.go archive -type zip -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + - go run build\ci.go nsis -signer WINDOWS_SIGNING_KEY -upload gethstore/builds + +test_script: + - set CGO_ENABLED=1 + - go run build\ci.go test -coverage diff --git a/vendor/github.com/ethereum/go-ethereum/build/ci-notes.md b/vendor/github.com/ethereum/go-ethereum/build/ci-notes.md new file mode 100644 index 000000000..7574bfffa --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/ci-notes.md @@ -0,0 +1,49 @@ +# Debian Packaging + +Tagged releases and develop branch commits are available as installable Debian packages +for Ubuntu. Packages are built for the all Ubuntu versions which are supported by +Canonical: + +- Trusty Tahr (14.04 LTS) +- Xenial Xerus (16.04 LTS) +- Yakkety Yak (16.10) +- Zesty Zapus (17.04) + +Packages of develop branch commits have suffix -unstable and cannot be installed alongside +the stable version. Switching between release streams requires user intervention. + +The packages are built and served by launchpad.net. We generate a Debian source package +for each distribution and upload it. Their builder picks up the source package, builds it +and installs the new version into the PPA repository. Launchpad requires a valid signature +by a team member for source package uploads. The signing key is stored in an environment +variable which Travis CI makes available to certain builds. + +We want to build go-ethereum with the most recent version of Go, irrespective of the Go +version that is available in the main Ubuntu repository. In order to make this possible, +our PPA depends on the ~gophers/ubuntu/archive PPA. Our source package build-depends on +golang-1.8, which is co-installable alongside the regular golang package. PPA dependencies +can be edited at https://launchpad.net/%7Eethereum/+archive/ubuntu/ethereum/+edit-dependencies + +## Building Packages Locally (for testing) + +You need to run Ubuntu to do test packaging. + +Add the gophers PPA and install Go 1.8 and Debian packaging tools: + + $ sudo apt-add-repository ppa:gophers/ubuntu/archive + $ sudo apt-get update + $ sudo apt-get install build-essential golang-1.8 devscripts debhelper + +Create the source packages: + + $ go run build/ci.go debsrc -workdir dist + +Then go into the source package directory for your running distribution and build the package: + + $ cd dist/ethereum-unstable-1.6.0+xenial + $ dpkg-buildpackage + +Built packages are placed in the dist/ directory. + + $ cd .. + $ dpkg-deb -c geth-unstable_1.6.0+xenial_amd64.deb diff --git a/vendor/github.com/ethereum/go-ethereum/build/ci.go b/vendor/github.com/ethereum/go-ethereum/build/ci.go new file mode 100644 index 000000000..6a52077d4 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/ci.go @@ -0,0 +1,1031 @@ +// 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 . + +// +build none + +/* +The ci command is called from Continuous Integration scripts. + +Usage: go run ci.go + +Available commands are: + + install [ -arch architecture ] [ packages... ] -- builds packages and executables + test [ -coverage ] [ -misspell ] [ packages... ] -- runs the tests + archive [ -arch architecture ] [ -type zip|tar ] [ -signer key-envvar ] [ -upload dest ] -- archives build artefacts + importkeys -- imports signing keys from env + debsrc [ -signer key-id ] [ -upload dest ] -- creates a debian source package + nsis -- creates a Windows NSIS installer + aar [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ] -- creates an Android archive + xcode [ -local ] [ -sign key-id ] [-deploy repo] [ -upload dest ] -- creates an iOS XCode framework + xgo [ -alltools ] [ options ] -- cross builds according to options + purge [ -store blobstore ] [ -days threshold ] -- purges old archives from the blobstore + +For all commands, -n prevents execution of external programs (dry run mode). + +*/ +package main + +import ( + "bufio" + "bytes" + "encoding/base64" + "flag" + "fmt" + "go/parser" + "go/token" + "io/ioutil" + "log" + "os" + "os/exec" + "path/filepath" + "regexp" + "runtime" + "strings" + "time" + + "github.com/ethereum/go-ethereum/internal/build" +) + +var ( + // Files that end up in the geth*.zip archive. + gethArchiveFiles = []string{ + "COPYING", + executablePath("geth"), + } + + // Files that end up in the geth-alltools*.zip archive. + allToolsArchiveFiles = []string{ + "COPYING", + executablePath("abigen"), + executablePath("bootnode"), + executablePath("evm"), + executablePath("geth"), + executablePath("puppeth"), + executablePath("rlpdump"), + executablePath("swarm"), + executablePath("wnode"), + } + + // A debian package is created for all executables listed here. + debExecutables = []debExecutable{ + { + Name: "abigen", + Description: "Source code generator to convert Ethereum contract definitions into easy to use, compile-time type-safe Go packages.", + }, + { + Name: "bootnode", + Description: "Ethereum bootnode.", + }, + { + Name: "evm", + Description: "Developer utility version of the EVM (Ethereum Virtual Machine) that is capable of running bytecode snippets within a configurable environment and execution mode.", + }, + { + Name: "geth", + Description: "Ethereum CLI client.", + }, + { + Name: "puppeth", + Description: "Ethereum private network manager.", + }, + { + Name: "rlpdump", + Description: "Developer utility tool that prints RLP structures.", + }, + { + Name: "swarm", + Description: "Ethereum Swarm daemon and tools", + }, + { + Name: "wnode", + Description: "Ethereum Whisper diagnostic tool", + }, + } + + // Distros for which packages are created. + // Note: vivid is unsupported because there is no golang-1.6 package for it. + // Note: wily is unsupported because it was officially deprecated on lanchpad. + debDistros = []string{"trusty", "xenial", "yakkety", "zesty"} +) + +var GOBIN, _ = filepath.Abs(filepath.Join("build", "bin")) + +func executablePath(name string) string { + if runtime.GOOS == "windows" { + name += ".exe" + } + return filepath.Join(GOBIN, name) +} + +func main() { + log.SetFlags(log.Lshortfile) + + if _, err := os.Stat(filepath.Join("build", "ci.go")); os.IsNotExist(err) { + log.Fatal("this script must be run from the root of the repository") + } + if len(os.Args) < 2 { + log.Fatal("need subcommand as first argument") + } + switch os.Args[1] { + case "install": + doInstall(os.Args[2:]) + case "test": + doTest(os.Args[2:]) + case "archive": + doArchive(os.Args[2:]) + case "debsrc": + doDebianSource(os.Args[2:]) + case "nsis": + doWindowsInstaller(os.Args[2:]) + case "aar": + doAndroidArchive(os.Args[2:]) + case "xcode": + doXCodeFramework(os.Args[2:]) + case "xgo": + doXgo(os.Args[2:]) + case "purge": + doPurge(os.Args[2:]) + default: + log.Fatal("unknown command ", os.Args[1]) + } +} + +// Compiling + +func doInstall(cmdline []string) { + var ( + arch = flag.String("arch", "", "Architecture to cross build for") + ) + 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) + } + // Compile packages given as arguments, or everything if there are no arguments. + packages := []string{"./..."} + if flag.NArg() > 0 { + packages = flag.Args() + } + packages = build.ExpandPackagesNoVendor(packages) + + if *arch == "" || *arch == runtime.GOARCH { + goinstall := goTool("install", buildFlags(env)...) + goinstall.Args = append(goinstall.Args, "-v") + goinstall.Args = append(goinstall.Args, packages...) + build.MustRun(goinstall) + return + } + // If we are cross compiling to ARMv5 ARMv6 or ARMv7, clean any prvious builds + if *arch == "arm" { + os.RemoveAll(filepath.Join(runtime.GOROOT(), "pkg", runtime.GOOS+"_arm")) + for _, path := range filepath.SplitList(build.GOPATH()) { + os.RemoveAll(filepath.Join(path, "pkg", runtime.GOOS+"_arm")) + } + } + // Seems we are cross compiling, work around forbidden GOBIN + goinstall := goToolArch(*arch, "install", buildFlags(env)...) + goinstall.Args = append(goinstall.Args, "-v") + goinstall.Args = append(goinstall.Args, []string{"-buildmode", "archive"}...) + goinstall.Args = append(goinstall.Args, packages...) + build.MustRun(goinstall) + + if cmds, err := ioutil.ReadDir("cmd"); err == nil { + for _, cmd := range cmds { + pkgs, err := parser.ParseDir(token.NewFileSet(), filepath.Join(".", "cmd", cmd.Name()), nil, parser.PackageClauseOnly) + if err != nil { + log.Fatal(err) + } + for name := range pkgs { + if name == "main" { + gobuild := goToolArch(*arch, "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())) + build.MustRun(gobuild) + break + } + } + } + } +} + +func buildFlags(env build.Environment) (flags []string) { + var ld []string + if env.Commit != "" { + ld = append(ld, "-X", "main.gitCommit="+env.Commit) + } + if runtime.GOOS == "darwin" { + ld = append(ld, "-s") + } + + if len(ld) > 0 { + flags = append(flags, "-ldflags", strings.Join(ld, " ")) + } + return flags +} + +func goTool(subcmd string, args ...string) *exec.Cmd { + return goToolArch(runtime.GOARCH, subcmd, args...) +} + +func goToolArch(arch string, subcmd string, args ...string) *exec.Cmd { + gocmd := filepath.Join(runtime.GOROOT(), "bin", "go") + cmd := exec.Command(gocmd, subcmd) + cmd.Args = append(cmd.Args, 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" { + cmd.Args = append(cmd.Args, []string{"-ldflags", "-extldflags -Wl,--allow-multiple-definition"}...) + } + } + cmd.Env = []string{"GOPATH=" + build.GOPATH()} + if arch == "" || arch == runtime.GOARCH { + cmd.Env = append(cmd.Env, "GOBIN="+GOBIN) + } else { + cmd.Env = append(cmd.Env, "CGO_ENABLED=1") + cmd.Env = append(cmd.Env, "GOARCH="+arch) + } + for _, e := range os.Environ() { + if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") { + continue + } + cmd.Env = append(cmd.Env, e) + } + return cmd +} + +// Running The Tests +// +// "tests" also includes static analysis tools such as vet. + +func doTest(cmdline []string) { + var ( + misspell = flag.Bool("misspell", false, "Whether to run the spell checker") + coverage = flag.Bool("coverage", false, "Whether to record code coverage") + ) + flag.CommandLine.Parse(cmdline) + env := build.Env() + + packages := []string{"./..."} + if len(flag.CommandLine.Args()) > 0 { + packages = flag.CommandLine.Args() + } + packages = build.ExpandPackagesNoVendor(packages) + + // Run analysis tools before the tests. + build.MustRun(goTool("vet", packages...)) + if *misspell { + // TODO(karalabe): Reenable after false detection is fixed: https://github.com/client9/misspell/issues/105 + // spellcheck(packages) + } + // Run the actual tests. + gotest := goTool("test", buildFlags(env)...) + // Test a single package at a time. CI builders are slow + // and some tests run into timeouts under load. + gotest.Args = append(gotest.Args, "-p", "1") + if *coverage { + gotest.Args = append(gotest.Args, "-covermode=atomic", "-cover") + } + gotest.Args = append(gotest.Args, packages...) + build.MustRun(gotest) +} + +// spellcheck runs the client9/misspell spellchecker package on all Go, Cgo and +// test files in the requested packages. +func spellcheck(packages []string) { + // Ensure the spellchecker is available + build.MustRun(goTool("get", "github.com/client9/misspell/cmd/misspell")) + + // Windows chokes on long argument lists, check packages individually + for _, pkg := range packages { + // The spell checker doesn't work on packages, gather all .go files for it + out, err := goTool("list", "-f", "{{.Dir}}{{range .GoFiles}}\n{{.}}{{end}}{{range .CgoFiles}}\n{{.}}{{end}}{{range .TestGoFiles}}\n{{.}}{{end}}", pkg).CombinedOutput() + if err != nil { + log.Fatalf("source file listing failed: %v\n%s", err, string(out)) + } + // Retrieve the folder and assemble the source list + lines := strings.Split(string(out), "\n") + root := lines[0] + + sources := make([]string, 0, len(lines)-1) + for _, line := range lines[1:] { + if line = strings.TrimSpace(line); line != "" { + sources = append(sources, filepath.Join(root, line)) + } + } + // Run the spell checker for this particular package + build.MustRunCommand(filepath.Join(GOBIN, "misspell"), append([]string{"-error"}, sources...)...) + } +} + +// Release Packaging + +func doArchive(cmdline []string) { + var ( + arch = flag.String("arch", runtime.GOARCH, "Architecture cross packaging") + atype = flag.String("type", "zip", "Type of archive to write (zip|tar)") + signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. LINUX_SIGNING_KEY)`) + upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) + ext string + ) + flag.CommandLine.Parse(cmdline) + switch *atype { + case "zip": + ext = ".zip" + case "tar": + ext = ".tar.gz" + default: + log.Fatal("unknown archive type: ", atype) + } + + var ( + env = build.Env() + base = archiveBasename(*arch, env) + geth = "geth-" + base + ext + alltools = "geth-alltools-" + base + ext + ) + maybeSkipArchive(env) + if err := build.WriteArchive(geth, gethArchiveFiles); err != nil { + log.Fatal(err) + } + if err := build.WriteArchive(alltools, allToolsArchiveFiles); err != nil { + log.Fatal(err) + } + for _, archive := range []string{geth, alltools} { + if err := archiveUpload(archive, *upload, *signer); err != nil { + log.Fatal(err) + } + } +} + +func archiveBasename(arch string, env build.Environment) string { + platform := runtime.GOOS + "-" + arch + if arch == "arm" { + platform += os.Getenv("GOARM") + } + if arch == "android" { + platform = "android-all" + } + if arch == "ios" { + platform = "ios-all" + } + return platform + "-" + archiveVersion(env) +} + +func archiveVersion(env build.Environment) string { + version := build.VERSION() + if isUnstableBuild(env) { + version += "-unstable" + } + if env.Commit != "" { + version += "-" + env.Commit[:8] + } + return version +} + +func archiveUpload(archive string, blobstore string, signer string) error { + // If signing was requested, generate the signature files + if signer != "" { + pgpkey, err := base64.StdEncoding.DecodeString(os.Getenv(signer)) + if err != nil { + return fmt.Errorf("invalid base64 %s", signer) + } + if err := build.PGPSignFile(archive, archive+".asc", string(pgpkey)); err != nil { + return err + } + } + // If uploading to Azure was requested, push the archive possibly with its signature + if blobstore != "" { + auth := build.AzureBlobstoreConfig{ + Account: strings.Split(blobstore, "/")[0], + Token: os.Getenv("AZURE_BLOBSTORE_TOKEN"), + Container: strings.SplitN(blobstore, "/", 2)[1], + } + if err := build.AzureBlobstoreUpload(archive, filepath.Base(archive), auth); err != nil { + return err + } + if signer != "" { + if err := build.AzureBlobstoreUpload(archive+".asc", filepath.Base(archive+".asc"), auth); err != nil { + return err + } + } + } + return nil +} + +// skips archiving for some build configurations. +func maybeSkipArchive(env build.Environment) { + if env.IsPullRequest { + log.Printf("skipping because this is a PR build") + os.Exit(0) + } + if env.IsCronJob { + log.Printf("skipping because this is a cron job") + os.Exit(0) + } + if env.Branch != "master" && !strings.HasPrefix(env.Tag, "v1.") { + log.Printf("skipping because branch %q, tag %q is not on the whitelist", env.Branch, env.Tag) + os.Exit(0) + } +} + +// Debian Packaging + +func doDebianSource(cmdline []string) { + var ( + signer = flag.String("signer", "", `Signing key name, also used as package author`) + upload = flag.String("upload", "", `Where to upload the source package (usually "ppa:ethereum/ethereum")`) + workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`) + now = time.Now() + ) + flag.CommandLine.Parse(cmdline) + *workdir = makeWorkdir(*workdir) + env := build.Env() + maybeSkipArchive(env) + + // Import the signing key. + if b64key := os.Getenv("PPA_SIGNING_KEY"); b64key != "" { + key, err := base64.StdEncoding.DecodeString(b64key) + if err != nil { + log.Fatal("invalid base64 PPA_SIGNING_KEY") + } + gpg := exec.Command("gpg", "--import") + gpg.Stdin = bytes.NewReader(key) + build.MustRun(gpg) + } + + // Create the packages. + for _, distro := range debDistros { + meta := newDebMetadata(distro, *signer, env, now) + pkgdir := stageDebianSource(*workdir, meta) + debuild := exec.Command("debuild", "-S", "-sa", "-us", "-uc") + debuild.Dir = pkgdir + build.MustRun(debuild) + + changes := fmt.Sprintf("%s_%s_source.changes", meta.Name(), meta.VersionString()) + changes = filepath.Join(*workdir, changes) + if *signer != "" { + build.MustRunCommand("debsign", changes) + } + if *upload != "" { + build.MustRunCommand("dput", *upload, changes) + } + } +} + +func makeWorkdir(wdflag string) string { + var err error + if wdflag != "" { + err = os.MkdirAll(wdflag, 0744) + } else { + wdflag, err = ioutil.TempDir("", "geth-build-") + } + if err != nil { + log.Fatal(err) + } + return wdflag +} + +func isUnstableBuild(env build.Environment) bool { + if env.Tag != "" { + return false + } + return true +} + +type debMetadata struct { + Env build.Environment + + // go-ethereum version being built. Note that this + // is not the debian package version. The package version + // is constructed by VersionString. + Version string + + Author string // "name ", also selects signing key + Distro, Time string + Executables []debExecutable +} + +type debExecutable struct { + Name, Description string +} + +func newDebMetadata(distro, author string, env build.Environment, t time.Time) debMetadata { + if author == "" { + // No signing key, use default author. + author = "Ethereum Builds " + } + return debMetadata{ + Env: env, + Author: author, + Distro: distro, + Version: build.VERSION(), + Time: t.Format(time.RFC1123Z), + Executables: debExecutables, + } +} + +// Name returns the name of the metapackage that depends +// on all executable packages. +func (meta debMetadata) Name() string { + if isUnstableBuild(meta.Env) { + return "ethereum-unstable" + } + return "ethereum" +} + +// VersionString returns the debian version of the packages. +func (meta debMetadata) VersionString() string { + vsn := meta.Version + if meta.Env.Buildnum != "" { + vsn += "+build" + meta.Env.Buildnum + } + if meta.Distro != "" { + vsn += "+" + meta.Distro + } + return vsn +} + +// ExeList returns the list of all executable packages. +func (meta debMetadata) ExeList() string { + names := make([]string, len(meta.Executables)) + for i, e := range meta.Executables { + names[i] = meta.ExeName(e) + } + return strings.Join(names, ", ") +} + +// ExeName returns the package name of an executable package. +func (meta debMetadata) ExeName(exe debExecutable) string { + if isUnstableBuild(meta.Env) { + return exe.Name + "-unstable" + } + return exe.Name +} + +// ExeConflicts returns the content of the Conflicts field +// for executable packages. +func (meta debMetadata) ExeConflicts(exe debExecutable) string { + if isUnstableBuild(meta.Env) { + // Set up the conflicts list so that the *-unstable packages + // cannot be installed alongside the regular version. + // + // https://www.debian.org/doc/debian-policy/ch-relationships.html + // is very explicit about Conflicts: and says that Breaks: should + // be preferred and the conflicting files should be handled via + // alternates. We might do this eventually but using a conflict is + // easier now. + return "ethereum, " + exe.Name + } + return "" +} + +func stageDebianSource(tmpdir string, meta debMetadata) (pkgdir string) { + pkg := meta.Name() + "-" + meta.VersionString() + pkgdir = filepath.Join(tmpdir, pkg) + if err := os.Mkdir(pkgdir, 0755); err != nil { + log.Fatal(err) + } + + // Copy the source code. + build.MustRunCommand("git", "checkout-index", "-a", "--prefix", pkgdir+string(filepath.Separator)) + + // Put the debian build files in place. + debian := filepath.Join(pkgdir, "debian") + build.Render("build/deb.rules", filepath.Join(debian, "rules"), 0755, meta) + build.Render("build/deb.changelog", filepath.Join(debian, "changelog"), 0644, meta) + build.Render("build/deb.control", filepath.Join(debian, "control"), 0644, meta) + build.Render("build/deb.copyright", filepath.Join(debian, "copyright"), 0644, meta) + build.RenderString("8\n", filepath.Join(debian, "compat"), 0644, meta) + build.RenderString("3.0 (native)\n", filepath.Join(debian, "source/format"), 0644, meta) + for _, exe := range meta.Executables { + install := filepath.Join(debian, meta.ExeName(exe)+".install") + docs := filepath.Join(debian, meta.ExeName(exe)+".docs") + build.Render("build/deb.install", install, 0644, exe) + build.Render("build/deb.docs", docs, 0644, exe) + } + + return pkgdir +} + +// Windows installer + +func doWindowsInstaller(cmdline []string) { + // Parse the flags and make skip installer generation on PRs + var ( + arch = flag.String("arch", runtime.GOARCH, "Architecture for cross build packaging") + signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. WINDOWS_SIGNING_KEY)`) + upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) + workdir = flag.String("workdir", "", `Output directory for packages (uses temp dir if unset)`) + ) + flag.CommandLine.Parse(cmdline) + *workdir = makeWorkdir(*workdir) + env := build.Env() + maybeSkipArchive(env) + + // Aggregate binaries that are included in the installer + var ( + devTools []string + allTools []string + gethTool string + ) + for _, file := range allToolsArchiveFiles { + if file == "COPYING" { // license, copied later + continue + } + allTools = append(allTools, filepath.Base(file)) + if filepath.Base(file) == "geth.exe" { + gethTool = file + } else { + devTools = append(devTools, file) + } + } + + // Render NSIS scripts: Installer NSIS contains two installer sections, + // first section contains the geth binary, second section holds the dev tools. + templateData := map[string]interface{}{ + "License": "COPYING", + "Geth": gethTool, + "DevTools": devTools, + } + build.Render("build/nsis.geth.nsi", filepath.Join(*workdir, "geth.nsi"), 0644, nil) + build.Render("build/nsis.install.nsh", filepath.Join(*workdir, "install.nsh"), 0644, templateData) + build.Render("build/nsis.uninstall.nsh", filepath.Join(*workdir, "uninstall.nsh"), 0644, allTools) + build.Render("build/nsis.pathupdate.nsh", filepath.Join(*workdir, "PathUpdate.nsh"), 0644, nil) + build.Render("build/nsis.envvarupdate.nsh", filepath.Join(*workdir, "EnvVarUpdate.nsh"), 0644, nil) + build.CopyFile(filepath.Join(*workdir, "SimpleFC.dll"), "build/nsis.simplefc.dll", 0755) + build.CopyFile(filepath.Join(*workdir, "COPYING"), "COPYING", 0755) + + // Build the installer. This assumes that all the needed files have been previously + // built (don't mix building and packaging to keep cross compilation complexity to a + // minimum). + version := strings.Split(build.VERSION(), ".") + if env.Commit != "" { + version[2] += "-" + env.Commit[:8] + } + installer, _ := filepath.Abs("geth-" + archiveBasename(*arch, env) + ".exe") + build.MustRunCommand("makensis.exe", + "/DOUTPUTFILE="+installer, + "/DMAJORVERSION="+version[0], + "/DMINORVERSION="+version[1], + "/DBUILDVERSION="+version[2], + "/DARCH="+*arch, + filepath.Join(*workdir, "geth.nsi"), + ) + + // Sign and publish installer. + if err := archiveUpload(installer, *upload, *signer); err != nil { + log.Fatal(err) + } +} + +// Android archives + +func doAndroidArchive(cmdline []string) { + var ( + local = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`) + signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. ANDROID_SIGNING_KEY)`) + deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "https://oss.sonatype.org")`) + upload = flag.String("upload", "", `Destination to upload the archive (usually "gethstore/builds")`) + ) + flag.CommandLine.Parse(cmdline) + env := build.Env() + + // Sanity check that the SDK and NDK are installed and set + if os.Getenv("ANDROID_HOME") == "" { + log.Fatal("Please ensure ANDROID_HOME points to your Android SDK") + } + if os.Getenv("ANDROID_NDK") == "" { + log.Fatal("Please ensure ANDROID_NDK points to your Android NDK") + } + // Build the Android archive and Maven resources + build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile")) + build.MustRun(gomobileTool("init", "--ndk", os.Getenv("ANDROID_NDK"))) + build.MustRun(gomobileTool("bind", "--target", "android", "--javapkg", "org.ethereum", "-v", "github.com/ethereum/go-ethereum/mobile")) + + if *local { + // If we're building locally, copy bundle to build dir and skip Maven + os.Rename("geth.aar", filepath.Join(GOBIN, "geth.aar")) + return + } + meta := newMavenMetadata(env) + build.Render("build/mvn.pom", meta.Package+".pom", 0755, meta) + + // Skip Maven deploy and Azure upload for PR builds + maybeSkipArchive(env) + + // Sign and upload the archive to Azure + archive := "geth-" + archiveBasename("android", env) + ".aar" + os.Rename("geth.aar", archive) + + if err := archiveUpload(archive, *upload, *signer); err != nil { + log.Fatal(err) + } + // Sign and upload all the artifacts to Maven Central + os.Rename(archive, meta.Package+".aar") + if *signer != "" && *deploy != "" { + // Import the signing key into the local GPG instance + if b64key := os.Getenv(*signer); b64key != "" { + key, err := base64.StdEncoding.DecodeString(b64key) + if err != nil { + log.Fatalf("invalid base64 %s", *signer) + } + gpg := exec.Command("gpg", "--import") + gpg.Stdin = bytes.NewReader(key) + build.MustRun(gpg) + } + // Upload the artifacts to Sonatype and/or Maven Central + repo := *deploy + "/service/local/staging/deploy/maven2" + if meta.Develop { + repo = *deploy + "/content/repositories/snapshots" + } + build.MustRunCommand("mvn", "gpg:sign-and-deploy-file", + "-settings=build/mvn.settings", "-Durl="+repo, "-DrepositoryId=ossrh", + "-DpomFile="+meta.Package+".pom", "-Dfile="+meta.Package+".aar") + } +} + +func gomobileTool(subcmd string, args ...string) *exec.Cmd { + cmd := exec.Command(filepath.Join(GOBIN, "gomobile"), subcmd) + cmd.Args = append(cmd.Args, args...) + cmd.Env = []string{ + "GOPATH=" + build.GOPATH(), + } + for _, e := range os.Environ() { + if strings.HasPrefix(e, "GOPATH=") { + continue + } + cmd.Env = append(cmd.Env, e) + } + return cmd +} + +type mavenMetadata struct { + Version string + Package string + Develop bool + Contributors []mavenContributor +} + +type mavenContributor struct { + Name string + Email string +} + +func newMavenMetadata(env build.Environment) mavenMetadata { + // Collect the list of authors from the repo root + contribs := []mavenContributor{} + if authors, err := os.Open("AUTHORS"); err == nil { + defer authors.Close() + + scanner := bufio.NewScanner(authors) + for scanner.Scan() { + // Skip any whitespace from the authors list + line := strings.TrimSpace(scanner.Text()) + if line == "" || line[0] == '#' { + continue + } + // Split the author and insert as a contributor + re := regexp.MustCompile("([^<]+) <(.+)>") + parts := re.FindStringSubmatch(line) + if len(parts) == 3 { + contribs = append(contribs, mavenContributor{Name: parts[1], Email: parts[2]}) + } + } + } + // Render the version and package strings + version := build.VERSION() + if isUnstableBuild(env) { + version += "-SNAPSHOT" + } + return mavenMetadata{ + Version: version, + Package: "geth-" + version, + Develop: isUnstableBuild(env), + Contributors: contribs, + } +} + +// XCode frameworks + +func doXCodeFramework(cmdline []string) { + var ( + local = flag.Bool("local", false, `Flag whether we're only doing a local build (skip Maven artifacts)`) + signer = flag.String("signer", "", `Environment variable holding the signing key (e.g. IOS_SIGNING_KEY)`) + deploy = flag.String("deploy", "", `Destination to deploy the archive (usually "trunk")`) + upload = flag.String("upload", "", `Destination to upload the archives (usually "gethstore/builds")`) + ) + flag.CommandLine.Parse(cmdline) + env := build.Env() + + // Build the iOS XCode framework + build.MustRun(goTool("get", "golang.org/x/mobile/cmd/gomobile")) + build.MustRun(gomobileTool("init")) + bind := gomobileTool("bind", "--target", "ios", "--tags", "ios", "-v", "github.com/ethereum/go-ethereum/mobile") + + if *local { + // If we're building locally, use the build folder and stop afterwards + bind.Dir, _ = filepath.Abs(GOBIN) + build.MustRun(bind) + return + } + archive := "geth-" + archiveBasename("ios", env) + if err := os.Mkdir(archive, os.ModePerm); err != nil { + log.Fatal(err) + } + bind.Dir, _ = filepath.Abs(archive) + build.MustRun(bind) + build.MustRunCommand("tar", "-zcvf", archive+".tar.gz", archive) + + // Skip CocoaPods deploy and Azure upload for PR builds + maybeSkipArchive(env) + + // Sign and upload the framework to Azure + if err := archiveUpload(archive+".tar.gz", *upload, *signer); err != nil { + log.Fatal(err) + } + // Prepare and upload a PodSpec to CocoaPods + if *deploy != "" { + meta := newPodMetadata(env, archive) + build.Render("build/pod.podspec", "Geth.podspec", 0755, meta) + build.MustRunCommand("pod", *deploy, "push", "Geth.podspec", "--allow-warnings", "--verbose") + } +} + +type podMetadata struct { + Version string + Commit string + Archive string + Contributors []podContributor +} + +type podContributor struct { + Name string + Email string +} + +func newPodMetadata(env build.Environment, archive string) podMetadata { + // Collect the list of authors from the repo root + contribs := []podContributor{} + if authors, err := os.Open("AUTHORS"); err == nil { + defer authors.Close() + + scanner := bufio.NewScanner(authors) + for scanner.Scan() { + // Skip any whitespace from the authors list + line := strings.TrimSpace(scanner.Text()) + if line == "" || line[0] == '#' { + continue + } + // Split the author and insert as a contributor + re := regexp.MustCompile("([^<]+) <(.+)>") + parts := re.FindStringSubmatch(line) + if len(parts) == 3 { + contribs = append(contribs, podContributor{Name: parts[1], Email: parts[2]}) + } + } + } + version := build.VERSION() + if isUnstableBuild(env) { + version += "-unstable." + env.Buildnum + } + return podMetadata{ + Archive: archive, + Version: version, + Commit: env.Commit, + Contributors: contribs, + } +} + +// Cross compilation + +func doXgo(cmdline []string) { + var ( + alltools = flag.Bool("alltools", false, `Flag whether we're building all known tools, or only on in particular`) + ) + flag.CommandLine.Parse(cmdline) + env := build.Env() + + // Make sure xgo is available for cross compilation + gogetxgo := goTool("get", "github.com/karalabe/xgo") + build.MustRun(gogetxgo) + + // If all tools building is requested, build everything the builder wants + args := append(buildFlags(env), flag.Args()...) + + if *alltools { + args = append(args, []string{"--dest", GOBIN}...) + for _, res := range allToolsArchiveFiles { + if strings.HasPrefix(res, GOBIN) { + // Binary tool found, cross build it explicitly + args = append(args, "./"+filepath.Join("cmd", filepath.Base(res))) + xgo := xgoTool(args) + build.MustRun(xgo) + args = args[:len(args)-1] + } + } + return + } + // Otherwise xxecute the explicit cross compilation + path := args[len(args)-1] + args = append(args[:len(args)-1], []string{"--dest", GOBIN, path}...) + + xgo := xgoTool(args) + build.MustRun(xgo) +} + +func xgoTool(args []string) *exec.Cmd { + cmd := exec.Command(filepath.Join(GOBIN, "xgo"), args...) + cmd.Env = []string{ + "GOPATH=" + build.GOPATH(), + "GOBIN=" + GOBIN, + } + for _, e := range os.Environ() { + if strings.HasPrefix(e, "GOPATH=") || strings.HasPrefix(e, "GOBIN=") { + continue + } + cmd.Env = append(cmd.Env, e) + } + return cmd +} + +// Binary distribution cleanups + +func doPurge(cmdline []string) { + var ( + store = flag.String("store", "", `Destination from where to purge archives (usually "gethstore/builds")`) + limit = flag.Int("days", 30, `Age threshold above which to delete unstalbe archives`) + ) + flag.CommandLine.Parse(cmdline) + + if env := build.Env(); !env.IsCronJob { + log.Printf("skipping because not a cron job") + os.Exit(0) + } + // Create the azure authentication and list the current archives + auth := build.AzureBlobstoreConfig{ + Account: strings.Split(*store, "/")[0], + Token: os.Getenv("AZURE_BLOBSTORE_TOKEN"), + Container: strings.SplitN(*store, "/", 2)[1], + } + blobs, err := build.AzureBlobstoreList(auth) + if err != nil { + log.Fatal(err) + } + // Iterate over the blobs, collect and sort all unstable builds + for i := 0; i < len(blobs); i++ { + if !strings.Contains(blobs[i].Name, "unstable") { + blobs = append(blobs[:i], blobs[i+1:]...) + i-- + } + } + for i := 0; i < len(blobs); i++ { + for j := i + 1; j < len(blobs); j++ { + iTime, err := time.Parse(time.RFC1123, blobs[i].Properties.LastModified) + if err != nil { + log.Fatal(err) + } + jTime, err := time.Parse(time.RFC1123, blobs[j].Properties.LastModified) + if err != nil { + log.Fatal(err) + } + if iTime.After(jTime) { + blobs[i], blobs[j] = blobs[j], blobs[i] + } + } + } + // Filter out all archives more recent that the given threshold + for i, blob := range blobs { + timestamp, _ := time.Parse(time.RFC1123, blob.Properties.LastModified) + if time.Since(timestamp) < time.Duration(*limit)*24*time.Hour { + blobs = blobs[:i] + break + } + } + // Delete all marked as such and return + if err := build.AzureBlobstoreDelete(auth, blobs); err != nil { + log.Fatal(err) + } +} diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.changelog b/vendor/github.com/ethereum/go-ethereum/build/deb.changelog new file mode 100644 index 000000000..83f804a83 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.changelog @@ -0,0 +1,5 @@ +{{.Name}} ({{.VersionString}}) {{.Distro}}; urgency=low + + * git build of {{.Env.Commit}} + + -- {{.Author}} {{.Time}} diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.control b/vendor/github.com/ethereum/go-ethereum/build/deb.control new file mode 100644 index 000000000..7394754ef --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.control @@ -0,0 +1,25 @@ +Source: {{.Name}} +Section: science +Priority: extra +Maintainer: {{.Author}} +Build-Depends: debhelper (>= 8.0.0), golang-1.8 +Standards-Version: 3.9.5 +Homepage: https://ethereum.org +Vcs-Git: git://github.com/ethereum/go-ethereum.git +Vcs-Browser: https://github.com/ethereum/go-ethereum + +Package: {{.Name}} +Architecture: any +Depends: ${misc:Depends}, {{.ExeList}} +Description: Meta-package to install geth and other tools + Meta-package to install geth and other tools + +{{range .Executables}} +Package: {{$.ExeName .}} +Conflicts: {{$.ExeConflicts .}} +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends} +Built-Using: ${misc:Built-Using} +Description: {{.Description}} + {{.Description}} +{{end}} diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.copyright b/vendor/github.com/ethereum/go-ethereum/build/deb.copyright new file mode 100644 index 000000000..513be45b1 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.copyright @@ -0,0 +1,14 @@ +Copyright 2016 The go-ethereum Authors + +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 . diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.docs b/vendor/github.com/ethereum/go-ethereum/build/deb.docs new file mode 100644 index 000000000..62deb0497 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.docs @@ -0,0 +1 @@ +AUTHORS diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.install b/vendor/github.com/ethereum/go-ethereum/build/deb.install new file mode 100644 index 000000000..7dc76e1f5 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.install @@ -0,0 +1 @@ +build/bin/{{.Name}} usr/bin diff --git a/vendor/github.com/ethereum/go-ethereum/build/deb.rules b/vendor/github.com/ethereum/go-ethereum/build/deb.rules new file mode 100644 index 000000000..b3fe5267f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/deb.rules @@ -0,0 +1,13 @@ +#!/usr/bin/make -f +# -*- makefile -*- + +# Uncomment this to turn on verbose mode. +#export DH_VERBOSE=1 + +override_dh_auto_build: + build/env.sh /usr/lib/go-1.8/bin/go run build/ci.go install -git-commit={{.Env.Commit}} -git-branch={{.Env.Branch}} -git-tag={{.Env.Tag}} -buildnum={{.Env.Buildnum}} -pull-request={{.Env.IsPullRequest}} + +override_dh_auto_test: + +%: + dh $@ diff --git a/vendor/github.com/ethereum/go-ethereum/build/env.sh b/vendor/github.com/ethereum/go-ethereum/build/env.sh new file mode 100755 index 000000000..832fb0e86 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/env.sh @@ -0,0 +1,39 @@ +#!/bin/sh + +set -e + +if [ ! -f "build/env.sh" ]; then + echo "$0 must be run from the root of the repository." + exit 2 +fi + +# Create fake Go workspace if it doesn't exist yet. +workspace="$PWD/build/_workspace" +root="$PWD" +ethdir="$workspace/src/github.com/ethereum" +if [ ! -L "$ethdir/go-ethereum" ]; then + mkdir -p "$ethdir" + cd "$ethdir" + ln -s ../../../../../. go-ethereum + cd "$root" +fi + +# Link status-go lib +statusgodir="$workspace/src/github.com/status-im" +if [ ! -L "$statusgodir/status-go" ]; then + mkdir -p "$statusgodir" + cd "$statusgodir" + ln -s ../../../../../../../status-im/status-go status-go + cd "$root" +fi + +# Set up the environment to use the workspace. +GOPATH="$workspace" +export GOPATH + +# Run the command inside the workspace. +cd "$ethdir/go-ethereum" +PWD="$ethdir/go-ethereum" + +# Launch the arguments with the configured environment. +exec "$@" diff --git a/vendor/github.com/ethereum/go-ethereum/build/mvn.pom b/vendor/github.com/ethereum/go-ethereum/build/mvn.pom new file mode 100644 index 000000000..7670246ba --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/mvn.pom @@ -0,0 +1,57 @@ + + 4.0.0 + + org.ethereum + geth + {{.Version}} + aar + + Android Ethereum Client + Android port of the go-ethereum libraries and node + https://github.com/ethereum/go-ethereum + 2015 + + + + GNU Lesser General Public License, Version 3.0 + https://www.gnu.org/licenses/lgpl-3.0.en.html + repo + + + + + Ethereum + https://ethereum.org + + + + + karalabe + Péter Szilágyi + peterke@gmail.com + https://github.com/karalabe + + https://www.gravatar.com/avatar/2ecbf0f5b4b79eebf8c193e5d324357f?s=256 + + + + + {{range .Contributors}} + + {{.Name}} + {{.Email}} + {{end}} + + + + GitHub Issues + https://github.com/ethereum/go-ethereum/issues/ + + + + https://github.com/ethereum/go-ethereum + + diff --git a/vendor/github.com/ethereum/go-ethereum/build/mvn.settings b/vendor/github.com/ethereum/go-ethereum/build/mvn.settings new file mode 100644 index 000000000..406b409b9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/mvn.settings @@ -0,0 +1,24 @@ + + + + ossrh + ${env.ANDROID_SONATYPE_USERNAME} + ${env.ANDROID_SONATYPE_PASSWORD} + + + + + ossrh + + true + + + gpg + + + + + diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.envvarupdate.nsh b/vendor/github.com/ethereum/go-ethereum/build/nsis.envvarupdate.nsh new file mode 100644 index 000000000..9c3ecbe33 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/nsis.envvarupdate.nsh @@ -0,0 +1,327 @@ +/** + * EnvVarUpdate.nsh + * : Environmental Variables: append, prepend, and remove entries + * + * WARNING: If you use StrFunc.nsh header then include it before this file + * with all required definitions. This is to avoid conflicts + * + * Usage: + * ${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString" + * + * Credits: + * Version 1.0 + * * Cal Turney (turnec2) + * * Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this + * function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, + * WriteEnvStr, and un.DeleteEnvStr + * * Diego Pedroso (deguix) for StrTok + * * Kevin English (kenglish_hi) for StrContains + * * Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry + * (dandaman32) for StrReplace + * + * Version 1.1 (compatibility with StrFunc.nsh) + * * techtonik + * + * http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries + * + */ + + +!ifndef ENVVARUPDATE_FUNCTION +!define ENVVARUPDATE_FUNCTION +!verbose push +!verbose 3 +!include "LogicLib.nsh" +!include "WinMessages.NSH" +!include "StrFunc.nsh" + +; ---- Fix for conflict if StrFunc.nsh is already includes in main file ----------------------- +!macro _IncludeStrFunction StrFuncName + !ifndef ${StrFuncName}_INCLUDED + ${${StrFuncName}} + !endif + !ifndef Un${StrFuncName}_INCLUDED + ${Un${StrFuncName}} + !endif + !define un.${StrFuncName} "${Un${StrFuncName}}" +!macroend + +!insertmacro _IncludeStrFunction StrTok +!insertmacro _IncludeStrFunction StrStr +!insertmacro _IncludeStrFunction StrRep + +; ---------------------------------- Macro Definitions ---------------------------------------- +!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString + Push "${EnvVarName}" + Push "${Action}" + Push "${RegLoc}" + Push "${PathString}" + Call EnvVarUpdate + Pop "${ResultVar}" +!macroend +!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"' + +!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString + Push "${EnvVarName}" + Push "${Action}" + Push "${RegLoc}" + Push "${PathString}" + Call un.EnvVarUpdate + Pop "${ResultVar}" +!macroend +!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"' +; ---------------------------------- Macro Definitions end------------------------------------- + +;----------------------------------- EnvVarUpdate start---------------------------------------- +!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"' +!define hkcu_current_user 'HKCU "Environment"' + +!macro EnvVarUpdate UN + +Function ${UN}EnvVarUpdate + + Push $0 + Exch 4 + Exch $1 + Exch 3 + Exch $2 + Exch 2 + Exch $3 + Exch + Exch $4 + Push $5 + Push $6 + Push $7 + Push $8 + Push $9 + Push $R0 + + /* After this point: + ------------------------- + $0 = ResultVar (returned) + $1 = EnvVarName (input) + $2 = Action (input) + $3 = RegLoc (input) + $4 = PathString (input) + $5 = Orig EnvVar (read from registry) + $6 = Len of $0 (temp) + $7 = tempstr1 (temp) + $8 = Entry counter (temp) + $9 = tempstr2 (temp) + $R0 = tempChar (temp) */ + + ; Step 1: Read contents of EnvVarName from RegLoc + ; + ; Check for empty EnvVarName + ${If} $1 == "" + SetErrors + DetailPrint "ERROR: EnvVarName is blank" + Goto EnvVarUpdate_Restore_Vars + ${EndIf} + + ; Check for valid Action + ${If} $2 != "A" + ${AndIf} $2 != "P" + ${AndIf} $2 != "R" + SetErrors + DetailPrint "ERROR: Invalid Action - must be A, P, or R" + Goto EnvVarUpdate_Restore_Vars + ${EndIf} + + ${If} $3 == HKLM + ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5 + ${ElseIf} $3 == HKCU + ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5 + ${Else} + SetErrors + DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"' + Goto EnvVarUpdate_Restore_Vars + ${EndIf} + + ; Check for empty PathString + ${If} $4 == "" + SetErrors + DetailPrint "ERROR: PathString is blank" + Goto EnvVarUpdate_Restore_Vars + ${EndIf} + + ; Make sure we've got some work to do + ${If} $5 == "" + ${AndIf} $2 == "R" + SetErrors + DetailPrint "$1 is empty - Nothing to remove" + Goto EnvVarUpdate_Restore_Vars + ${EndIf} + + ; Step 2: Scrub EnvVar + ; + StrCpy $0 $5 ; Copy the contents to $0 + ; Remove spaces around semicolons (NOTE: spaces before the 1st entry or + ; after the last one are not removed here but instead in Step 3) + ${If} $0 != "" ; If EnvVar is not empty ... + ${Do} + ${${UN}StrStr} $7 $0 " ;" + ${If} $7 == "" + ${ExitDo} + ${EndIf} + ${${UN}StrRep} $0 $0 " ;" ";" ; Remove ';' + ${Loop} + ${Do} + ${${UN}StrStr} $7 $0 "; " + ${If} $7 == "" + ${ExitDo} + ${EndIf} + ${${UN}StrRep} $0 $0 "; " ";" ; Remove ';' + ${Loop} + ${Do} + ${${UN}StrStr} $7 $0 ";;" + ${If} $7 == "" + ${ExitDo} + ${EndIf} + ${${UN}StrRep} $0 $0 ";;" ";" + ${Loop} + + ; Remove a leading or trailing semicolon from EnvVar + StrCpy $7 $0 1 0 + ${If} $7 == ";" + StrCpy $0 $0 "" 1 ; Change ';' to '' + ${EndIf} + StrLen $6 $0 + IntOp $6 $6 - 1 + StrCpy $7 $0 1 $6 + ${If} $7 == ";" + StrCpy $0 $0 $6 ; Change ';' to '' + ${EndIf} + ; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug + ${EndIf} + + /* Step 3. Remove all instances of the target path/string (even if "A" or "P") + $6 = bool flag (1 = found and removed PathString) + $7 = a string (e.g. path) delimited by semicolon(s) + $8 = entry counter starting at 0 + $9 = copy of $0 + $R0 = tempChar */ + + ${If} $5 != "" ; If EnvVar is not empty ... + StrCpy $9 $0 + StrCpy $0 "" + StrCpy $8 0 + StrCpy $6 0 + + ${Do} + ${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter + + ${If} $7 == "" ; If we've run out of entries, + ${ExitDo} ; were done + ${EndIf} ; + + ; Remove leading and trailing spaces from this entry (critical step for Action=Remove) + ${Do} + StrCpy $R0 $7 1 + ${If} $R0 != " " + ${ExitDo} + ${EndIf} + StrCpy $7 $7 "" 1 ; Remove leading space + ${Loop} + ${Do} + StrCpy $R0 $7 1 -1 + ${If} $R0 != " " + ${ExitDo} + ${EndIf} + StrCpy $7 $7 -1 ; Remove trailing space + ${Loop} + ${If} $7 == $4 ; If string matches, remove it by not appending it + StrCpy $6 1 ; Set 'found' flag + ${ElseIf} $7 != $4 ; If string does NOT match + ${AndIf} $0 == "" ; and the 1st string being added to $0, + StrCpy $0 $7 ; copy it to $0 without a prepended semicolon + ${ElseIf} $7 != $4 ; If string does NOT match + ${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0, + StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon + ${EndIf} ; + + IntOp $8 $8 + 1 ; Bump counter + ${Loop} ; Check for duplicates until we run out of paths + ${EndIf} + + ; Step 4: Perform the requested Action + ; + ${If} $2 != "R" ; If Append or Prepend + ${If} $6 == 1 ; And if we found the target + DetailPrint "Target is already present in $1. It will be removed and" + ${EndIf} + ${If} $0 == "" ; If EnvVar is (now) empty + StrCpy $0 $4 ; just copy PathString to EnvVar + ${If} $6 == 0 ; If found flag is either 0 + ${OrIf} $6 == "" ; or blank (if EnvVarName is empty) + DetailPrint "$1 was empty and has been updated with the target" + ${EndIf} + ${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty), + StrCpy $0 $0;$4 ; append PathString + ${If} $6 == 1 + DetailPrint "appended to $1" + ${Else} + DetailPrint "Target was appended to $1" + ${EndIf} + ${Else} ; If Prepend (and EnvVar is not empty), + StrCpy $0 $4;$0 ; prepend PathString + ${If} $6 == 1 + DetailPrint "prepended to $1" + ${Else} + DetailPrint "Target was prepended to $1" + ${EndIf} + ${EndIf} + ${Else} ; If Action = Remove + ${If} $6 == 1 ; and we found the target + DetailPrint "Target was found and removed from $1" + ${Else} + DetailPrint "Target was NOT found in $1 (nothing to remove)" + ${EndIf} + ${If} $0 == "" + DetailPrint "$1 is now empty" + ${EndIf} + ${EndIf} + + ; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change + ; + ClearErrors + ${If} $3 == HKLM + WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section + ${ElseIf} $3 == HKCU + WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section + ${EndIf} + + IfErrors 0 +4 + MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3" + DetailPrint "Could not write updated $1 to $3" + Goto EnvVarUpdate_Restore_Vars + + ; "Export" our change + SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 + + EnvVarUpdate_Restore_Vars: + ; + ; Restore the user's variables and return ResultVar + Pop $R0 + Pop $9 + Pop $8 + Pop $7 + Pop $6 + Pop $5 + Pop $4 + Pop $3 + Pop $2 + Pop $1 + Push $0 ; Push my $0 (ResultVar) + Exch + Pop $0 ; Restore his $0 + +FunctionEnd + +!macroend ; EnvVarUpdate UN +!insertmacro EnvVarUpdate "" +!insertmacro EnvVarUpdate "un." +;----------------------------------- EnvVarUpdate end---------------------------------------- + +!verbose pop +!endif \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.geth.nsi b/vendor/github.com/ethereum/go-ethereum/build/nsis.geth.nsi new file mode 100644 index 000000000..1034f3023 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/nsis.geth.nsi @@ -0,0 +1,70 @@ +# Builds a Windows installer with NSIS. +# It expects the following command line arguments: +# - OUTPUTFILE, filename of the installer (without extension) +# - MAJORVERSION, major build version +# - MINORVERSION, minor build version +# - BUILDVERSION, build id version +# +# The created installer executes the following steps: +# 1. install geth for all users +# 2. install optional development tools such as abigen +# 3. create an uninstaller +# 4. configures the Windows firewall for geth +# 5. create geth, attach and uninstall start menu entries +# 6. configures the registry that allows Windows to manage the package through its platform tools +# 7. adds the environment system wide variable ETHEREUM_SOCKET +# 8. adds the install directory to %PATH% +# +# Requirements: +# - NSIS, http://nsis.sourceforge.net/Main_Page +# - NSIS Large Strings build, http://nsis.sourceforge.net/Special_Builds +# - SFP, http://nsis.sourceforge.net/NSIS_Simple_Firewall_Plugin (put dll in NSIS\Plugins\x86-ansi) +# +# After intalling NSIS extra the NSIS Large Strings build zip and replace the makensis.exe and the +# files found in Stub. +# +# based on: http://nsis.sourceforge.net/A_simple_installer_with_start_menu_shortcut_and_uninstaller +# +# TODO: +# - sign installer +CRCCheck on + +!define GROUPNAME "Ethereum" +!define APPNAME "Geth" +!define DESCRIPTION "Official Go implementation of the Ethereum protocol" +!addplugindir .\ + +# Require admin rights on NT6+ (When UAC is turned on) +RequestExecutionLevel admin + +# Use LZMA compression +SetCompressor /SOLID lzma + +!include LogicLib.nsh +!include PathUpdate.nsh +!include EnvVarUpdate.nsh + +!macro VerifyUserIsAdmin +UserInfo::GetAccountType +pop $0 +${If} $0 != "admin" # Require admin rights on NT4+ + messageBox mb_iconstop "Administrator rights required!" + setErrorLevel 740 # ERROR_ELEVATION_REQUIRED + quit +${EndIf} +!macroend + +function .onInit + # make vars are global for all users since geth is installed global + setShellVarContext all + !insertmacro VerifyUserIsAdmin + + ${If} ${ARCH} == "amd64" + StrCpy $InstDir "$PROGRAMFILES64\${APPNAME}" + ${Else} + StrCpy $InstDir "$PROGRAMFILES32\${APPNAME}" + ${Endif} +functionEnd + +!include install.nsh +!include uninstall.nsh diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.install.nsh b/vendor/github.com/ethereum/go-ethereum/build/nsis.install.nsh new file mode 100644 index 000000000..57ef5a37c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/nsis.install.nsh @@ -0,0 +1,103 @@ +Name "geth ${MAJORVERSION}.${MINORVERSION}.${BUILDVERSION}" # VERSION variables set through command line arguments +InstallDir "$InstDir" +OutFile "${OUTPUTFILE}" # set through command line arguments + +# Links for "Add/Remove Programs" +!define HELPURL "https://github.com/ethereum/go-ethereum/issues" +!define UPDATEURL "https://github.com/ethereum/go-ethereum/releases" +!define ABOUTURL "https://github.com/ethereum/go-ethereum#ethereum-go" +!define /date NOW "%Y%m%d" + +PageEx license + LicenseData {{.License}} +PageExEnd + +# Install geth binary +Section "Geth" GETH_IDX + SetOutPath $INSTDIR + file {{.Geth}} + + # Create start menu launcher + createDirectory "$SMPROGRAMS\${APPNAME}" + createShortCut "$SMPROGRAMS\${APPNAME}\${APPNAME}.lnk" "$INSTDIR\geth.exe" "--fast" "--cache=512" + createShortCut "$SMPROGRAMS\${APPNAME}\Attach.lnk" "$INSTDIR\geth.exe" "attach" "" "" + createShortCut "$SMPROGRAMS\${APPNAME}\Uninstall.lnk" "$INSTDIR\uninstall.exe" "" "" "" + + # Firewall - remove rules (if exists) + SimpleFC::AdvRemoveRule "Geth incoming peers (TCP:30303)" + SimpleFC::AdvRemoveRule "Geth outgoing peers (TCP:30303)" + SimpleFC::AdvRemoveRule "Geth UDP discovery (UDP:30303)" + + # Firewall - add rules + SimpleFC::AdvAddRule "Geth incoming peers (TCP:30303)" "" 6 1 1 2147483647 1 "$INSTDIR\geth.exe" "" "" "Ethereum" 30303 "" "" "" + SimpleFC::AdvAddRule "Geth outgoing peers (TCP:30303)" "" 6 2 1 2147483647 1 "$INSTDIR\geth.exe" "" "" "Ethereum" "" 30303 "" "" + SimpleFC::AdvAddRule "Geth UDP discovery (UDP:30303)" "" 17 2 1 2147483647 1 "$INSTDIR\geth.exe" "" "" "Ethereum" "" 30303 "" "" + + # Set default IPC endpoint (https://github.com/ethereum/EIPs/issues/147) + ${EnvVarUpdate} $0 "ETHEREUM_SOCKET" "R" "HKLM" "\\.\pipe\geth.ipc" + ${EnvVarUpdate} $0 "ETHEREUM_SOCKET" "A" "HKLM" "\\.\pipe\geth.ipc" + + # Add instdir to PATH + Push "$INSTDIR" + Call AddToPath +SectionEnd + +# Install optional develop tools. +Section /o "Development tools" DEV_TOOLS_IDX + SetOutPath $INSTDIR + {{range .DevTools}}file {{.}} + {{end}} +SectionEnd + +# Return on top of stack the total size (as DWORD) of the selected/installed sections. +Var GetInstalledSize.total +Function GetInstalledSize + StrCpy $GetInstalledSize.total 0 + + ${if} ${SectionIsSelected} ${GETH_IDX} + SectionGetSize ${GETH_IDX} $0 + IntOp $GetInstalledSize.total $GetInstalledSize.total + $0 + ${endif} + + ${if} ${SectionIsSelected} ${DEV_TOOLS_IDX} + SectionGetSize ${DEV_TOOLS_IDX} $0 + IntOp $GetInstalledSize.total $GetInstalledSize.total + $0 + ${endif} + + IntFmt $GetInstalledSize.total "0x%08X" $GetInstalledSize.total + Push $GetInstalledSize.total +FunctionEnd + +# Write registry, Windows uses these values in various tools such as add/remove program. +# PowerShell: Get-ItemProperty HKLM:\Software\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall\* | Select-Object DisplayName, InstallLocation, InstallDate | Format-Table –AutoSize +function .onInstSuccess + # Save information in registry in HKEY_LOCAL_MACHINE branch, Windows add/remove functionality depends on this + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "DisplayName" "${GROUPNAME} - ${APPNAME} - ${DESCRIPTION}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "UninstallString" "$\"$INSTDIR\uninstall.exe$\"" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "QuietUninstallString" "$\"$INSTDIR\uninstall.exe$\" /S" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "InstallLocation" "$INSTDIR" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "InstallDate" "${NOW}" + # Wait for Alex + #WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "DisplayIcon" "$\"$INSTDIR\logo.ico$\"" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "Publisher" "${GROUPNAME}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "HelpLink" "${HELPURL}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "URLUpdateInfo" "${UPDATEURL}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "URLInfoAbout" "${ABOUTURL}" + WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "DisplayVersion" "${MAJORVERSION}.${MINORVERSION}.${BUILDVERSION}" + WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "VersionMajor" ${MAJORVERSION} + WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "VersionMinor" ${MINORVERSION} + # There is no option for modifying or repairing the install + WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "NoModify" 1 + WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "NoRepair" 1 + + Call GetInstalledSize + Pop $0 + WriteRegDWORD HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" "EstimatedSize" "$0" + + # Create uninstaller + writeUninstaller "$INSTDIR\uninstall.exe" +functionEnd + +Page components +Page directory +Page instfiles diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.pathupdate.nsh b/vendor/github.com/ethereum/go-ethereum/build/nsis.pathupdate.nsh new file mode 100644 index 000000000..f54b7e3e1 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/nsis.pathupdate.nsh @@ -0,0 +1,153 @@ +!include "WinMessages.nsh" + +; see https://support.microsoft.com/en-us/kb/104011 +!define Environ 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"' +; HKEY_LOCAL_MACHINE = 0x80000002 + +; AddToPath - Appends dir to PATH +; (does not work on Win9x/ME) +; +; Usage: +; Push "dir" +; Call AddToPath +Function AddToPath + Exch $0 + Push $1 + Push $2 + Push $3 + Push $4 + + ; NSIS ReadRegStr returns empty string on string overflow + ; Native calls are used here to check actual length of PATH + ; $4 = RegOpenKey(HKEY_LOCAL_MACHINE, "SYSTEM\CurrentControlSet\Control\Session Manager\Environment", &$3) + System::Call "advapi32::RegOpenKey(i 0x80000002, t'SYSTEM\CurrentControlSet\Control\Session Manager\Environment', *i.r3) i.r4" + IntCmp $4 0 0 done done + + ; $4 = RegQueryValueEx($3, "PATH", (DWORD*)0, (DWORD*)0, &$1, ($2=NSIS_MAX_STRLEN, &$2)) + ; RegCloseKey($3) + System::Call "advapi32::RegQueryValueEx(i $3, t'PATH', i 0, i 0, t.r1, *i ${NSIS_MAX_STRLEN} r2) i.r4" + System::Call "advapi32::RegCloseKey(i $3)" + + IntCmp $4 234 0 +4 +4 ; $4 == ERROR_MORE_DATA + DetailPrint "AddToPath: original length $2 > ${NSIS_MAX_STRLEN}" + MessageBox MB_OK "PATH not updated, original length $2 > ${NSIS_MAX_STRLEN}" + Goto done + + IntCmp $4 0 +5 ; $4 != NO_ERROR + IntCmp $4 2 +3 ; $4 != ERROR_FILE_NOT_FOUND + DetailPrint "AddToPath: unexpected error code $4" + Goto done + StrCpy $1 "" + + ; Check if already in PATH + Push "$1;" + Push "$0;" + Call StrStr + Pop $2 + StrCmp $2 "" 0 done + Push "$1;" + Push "$0\;" + Call StrStr + Pop $2 + StrCmp $2 "" 0 done + + ; Prevent NSIS string overflow + StrLen $2 $0 + StrLen $3 $1 + IntOp $2 $2 + $3 + IntOp $2 $2 + 2 ; $2 = strlen(dir) + strlen(PATH) + sizeof(";") + IntCmp $2 ${NSIS_MAX_STRLEN} +4 +4 0 + DetailPrint "AddToPath: new length $2 > ${NSIS_MAX_STRLEN}" + MessageBox MB_OK "PATH not updated, new length $2 > ${NSIS_MAX_STRLEN}." + Goto done + + ; Append dir to PATH + DetailPrint "Add to PATH: $0" + StrCpy $2 $1 1 -1 + StrCmp $2 ";" 0 +2 + StrCpy $1 $1 -1 ; remove trailing ';' + StrCmp $1 "" +2 ; no leading ';' + StrCpy $0 "$1;$0" + + WriteRegExpandStr ${Environ} "PATH" $0 + SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 + +done: + Pop $4 + Pop $3 + Pop $2 + Pop $1 + Pop $0 +FunctionEnd + + +; RemoveFromPath - Removes dir from PATH +; +; Usage: +; Push "dir" +; Call RemoveFromPath +Function un.RemoveFromPath + Exch $0 + Push $1 + Push $2 + Push $3 + Push $4 + Push $5 + Push $6 + + ; NSIS ReadRegStr returns empty string on string overflow + ; Native calls are used here to check actual length of PATH + ; $4 = RegOpenKey(HKEY_LOCAL_MACHINE, "SYSTEM\CurrentControlSet\Control\Session Manager\Environment", &$3) + System::Call "advapi32::RegOpenKey(i 0x80000002, t'SYSTEM\CurrentControlSet\Control\Session Manager\Environment', *i.r3) i.r4" + IntCmp $4 0 0 done done + + ; $4 = RegQueryValueEx($3, "PATH", (DWORD*)0, (DWORD*)0, &$1, ($2=NSIS_MAX_STRLEN, &$2)) + ; RegCloseKey($3) + System::Call "advapi32::RegQueryValueEx(i $3, t'PATH', i 0, i 0, t.r1, *i ${NSIS_MAX_STRLEN} r2) i.r4" + System::Call "advapi32::RegCloseKey(i $3)" + + IntCmp $4 234 0 +4 +4 ; $4 == ERROR_MORE_DATA + DetailPrint "RemoveFromPath: original length $2 > ${NSIS_MAX_STRLEN}" + MessageBox MB_OK "PATH not updated, original length $2 > ${NSIS_MAX_STRLEN}" + Goto done + + IntCmp $4 0 +5 ; $4 != NO_ERROR + IntCmp $4 2 +3 ; $4 != ERROR_FILE_NOT_FOUND + DetailPrint "RemoveFromPath: unexpected error code $4" + Goto done + StrCpy $1 "" + + ; length < ${NSIS_MAX_STRLEN} -> ReadRegStr can be used + ReadRegStr $1 ${Environ} "PATH" + StrCpy $5 $1 1 -1 + StrCmp $5 ";" +2 + StrCpy $1 "$1;" ; ensure trailing ';' + Push $1 + Push "$0;" + Call un.StrStr + Pop $2 ; pos of our dir + StrCmp $2 "" done + + DetailPrint "Remove from PATH: $0" + StrLen $3 "$0;" + StrLen $4 $2 + StrCpy $5 $1 -$4 ; $5 is now the part before the path to remove + StrCpy $6 $2 "" $3 ; $6 is now the part after the path to remove + StrCpy $3 "$5$6" + StrCpy $5 $3 1 -1 + StrCmp $5 ";" 0 +2 + StrCpy $3 $3 -1 ; remove trailing ';' + WriteRegExpandStr ${Environ} "PATH" $3 + SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 + +done: + Pop $6 + Pop $5 + Pop $4 + Pop $3 + Pop $2 + Pop $1 + Pop $0 +FunctionEnd + + diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.dll b/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.dll new file mode 100644 index 000000000..73b7d9634 Binary files /dev/null and b/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.dll differ diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.source.zip b/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.source.zip new file mode 100644 index 000000000..d7476022a Binary files /dev/null and b/vendor/github.com/ethereum/go-ethereum/build/nsis.simplefc.source.zip differ diff --git a/vendor/github.com/ethereum/go-ethereum/build/nsis.uninstall.nsh b/vendor/github.com/ethereum/go-ethereum/build/nsis.uninstall.nsh new file mode 100644 index 000000000..6358faa74 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/nsis.uninstall.nsh @@ -0,0 +1,33 @@ +Section "Uninstall" + # uninstall for all users + setShellVarContext all + + # Delete (optionally) installed files + {{range $}}Delete $INSTDIR\{{.}} + {{end}} + Delete $INSTDIR\uninstall.exe + + # Delete install directory + rmDir $INSTDIR + + # Delete start menu launcher + Delete "$SMPROGRAMS\${APPNAME}\${APPNAME}.lnk" + Delete "$SMPROGRAMS\${APPNAME}\Attach.lnk" + Delete "$SMPROGRAMS\${APPNAME}\Uninstall.lnk" + rmDir "$SMPROGRAMS\${APPNAME}" + + # Firewall - remove rules if exists + SimpleFC::AdvRemoveRule "Geth incoming peers (TCP:30303)" + SimpleFC::AdvRemoveRule "Geth outgoing peers (TCP:30303)" + SimpleFC::AdvRemoveRule "Geth UDP discovery (UDP:30303)" + + # Remove IPC endpoint (https://github.com/ethereum/EIPs/issues/147) + ${un.EnvVarUpdate} $0 "ETHEREUM_SOCKET" "R" "HKLM" "\\.\pipe\geth.ipc" + + # Remove install directory from PATH + Push "$INSTDIR" + Call un.RemoveFromPath + + # Cleanup registry (deletes all sub keys) + DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\${GROUPNAME} ${APPNAME}" +SectionEnd diff --git a/vendor/github.com/ethereum/go-ethereum/build/pod.podspec b/vendor/github.com/ethereum/go-ethereum/build/pod.podspec new file mode 100644 index 000000000..2c14c280c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/pod.podspec @@ -0,0 +1,22 @@ +Pod::Spec.new do |spec| + spec.name = 'Geth' + spec.version = '{{.Version}}' + spec.license = { :type => 'GNU Lesser General Public License, Version 3.0' } + spec.homepage = 'https://github.com/ethereum/go-ethereum' + spec.authors = { {{range .Contributors}} + '{{.Name}}' => '{{.Email}}',{{end}} + } + spec.summary = 'iOS Ethereum Client' + spec.source = { :git => 'https://github.com/ethereum/go-ethereum.git', :commit => '{{.Commit}}' } + + spec.platform = :ios + spec.ios.deployment_target = '9.0' + spec.ios.vendored_frameworks = 'Frameworks/Geth.framework' + + spec.prepare_command = <<-CMD + curl https://gethstore.blob.core.windows.net/builds/{{.Archive}}.tar.gz | tar -xvz + mkdir Frameworks + mv {{.Archive}}/Geth.framework Frameworks + rm -rf {{.Archive}} + CMD +end diff --git a/vendor/github.com/ethereum/go-ethereum/build/update-license.go b/vendor/github.com/ethereum/go-ethereum/build/update-license.go new file mode 100644 index 000000000..3d69598b7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/build/update-license.go @@ -0,0 +1,396 @@ +// +build none + +/* +This command generates GPL license headers on top of all source files. +You can run it once per month, before cutting a release or just +whenever you feel like it. + + go run update-license.go + +All authors (people who have contributed code) are listed in the +AUTHORS file. The author names are mapped and deduplicated using the +.mailmap file. You can use .mailmap to set the canonical name and +address for each author. See git-shortlog(1) for an explanation of the +.mailmap format. + +Please review the resulting diff to check whether the correct +copyright assignments are performed. +*/ + +package main + +import ( + "bufio" + "bytes" + "fmt" + "io/ioutil" + "log" + "os" + "os/exec" + "path/filepath" + "regexp" + "runtime" + "sort" + "strconv" + "strings" + "sync" + "text/template" + "time" +) + +var ( + // only files with these extensions will be considered + extensions = []string{".go", ".js", ".qml"} + + // paths with any of these prefixes will be skipped + skipPrefixes = []string{ + // boring stuff + "vendor/", "tests/testdata/", "build/", + // don't relicense vendored sources + "cmd/internal/browser", + "consensus/ethash/xor.go", + "crypto/bn256/", + "crypto/ecies/", + "crypto/secp256k1/curve.go", + "crypto/sha3/", + "internal/jsre/deps", + "log/", + // don't license generated files + "contracts/chequebook/contract/", + "contracts/ens/contract/", + "contracts/release/contract.go", + } + + // paths with this prefix are licensed as GPL. all other files are LGPL. + gplPrefixes = []string{"cmd/"} + + // this regexp must match the entire license comment at the + // beginning of each file. + licenseCommentRE = regexp.MustCompile(`^//\s*(Copyright|This file is part of).*?\n(?://.*?\n)*\n*`) + + // this text appears at the start of AUTHORS + authorsFileHeader = "# This is the official list of go-ethereum authors for copyright purposes.\n\n" +) + +// this template generates the license comment. +// its input is an info structure. +var licenseT = template.Must(template.New("").Parse(` +// Copyright {{.Year}} The go-ethereum Authors +// This file is part of {{.Whole false}}. +// +// {{.Whole true}} is free software: you can redistribute it and/or modify +// it under the terms of the GNU {{.License}} as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// {{.Whole true}} 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 {{.License}} for more details. +// +// You should have received a copy of the GNU {{.License}} +// along with {{.Whole false}}. If not, see . + +`[1:])) + +type info struct { + file string + Year int64 +} + +func (i info) License() string { + if i.gpl() { + return "General Public License" + } + return "Lesser General Public License" +} + +func (i info) ShortLicense() string { + if i.gpl() { + return "GPL" + } + return "LGPL" +} + +func (i info) Whole(startOfSentence bool) string { + if i.gpl() { + return "go-ethereum" + } + if startOfSentence { + return "The go-ethereum library" + } + return "the go-ethereum library" +} + +func (i info) gpl() bool { + for _, p := range gplPrefixes { + if strings.HasPrefix(i.file, p) { + return true + } + } + return false +} + +func main() { + var ( + files = getFiles() + filec = make(chan string) + infoc = make(chan *info, 20) + wg sync.WaitGroup + ) + + writeAuthors(files) + + go func() { + for _, f := range files { + filec <- f + } + close(filec) + }() + for i := runtime.NumCPU(); i >= 0; i-- { + // getting file info is slow and needs to be parallel. + // it traverses git history for each file. + wg.Add(1) + go getInfo(filec, infoc, &wg) + } + go func() { + wg.Wait() + close(infoc) + }() + writeLicenses(infoc) +} + +func skipFile(path string) bool { + if strings.Contains(path, "/testdata/") { + return true + } + for _, p := range skipPrefixes { + if strings.HasPrefix(path, p) { + return true + } + } + return false +} + +func getFiles() []string { + cmd := exec.Command("git", "ls-tree", "-r", "--name-only", "HEAD") + var files []string + err := doLines(cmd, func(line string) { + if skipFile(line) { + return + } + ext := filepath.Ext(line) + for _, wantExt := range extensions { + if ext == wantExt { + goto keep + } + } + return + keep: + files = append(files, line) + }) + if err != nil { + log.Fatal("error getting files:", err) + } + return files +} + +var authorRegexp = regexp.MustCompile(`\s*[0-9]+\s*(.*)`) + +func gitAuthors(files []string) []string { + cmds := []string{"shortlog", "-s", "-n", "-e", "HEAD", "--"} + cmds = append(cmds, files...) + cmd := exec.Command("git", cmds...) + var authors []string + err := doLines(cmd, func(line string) { + m := authorRegexp.FindStringSubmatch(line) + if len(m) > 1 { + authors = append(authors, m[1]) + } + }) + if err != nil { + log.Fatalln("error getting authors:", err) + } + return authors +} + +func readAuthors() []string { + content, err := ioutil.ReadFile("AUTHORS") + if err != nil && !os.IsNotExist(err) { + log.Fatalln("error reading AUTHORS:", err) + } + var authors []string + for _, a := range bytes.Split(content, []byte("\n")) { + if len(a) > 0 && a[0] != '#' { + authors = append(authors, string(a)) + } + } + // Retranslate existing authors through .mailmap. + // This should catch email address changes. + authors = mailmapLookup(authors) + return authors +} + +func mailmapLookup(authors []string) []string { + if len(authors) == 0 { + return nil + } + cmds := []string{"check-mailmap", "--"} + cmds = append(cmds, authors...) + cmd := exec.Command("git", cmds...) + var translated []string + err := doLines(cmd, func(line string) { + translated = append(translated, line) + }) + if err != nil { + log.Fatalln("error translating authors:", err) + } + return translated +} + +func writeAuthors(files []string) { + merge := make(map[string]bool) + // Add authors that Git reports as contributorxs. + // This is the primary source of author information. + for _, a := range gitAuthors(files) { + merge[a] = true + } + // Add existing authors from the file. This should ensure that we + // never lose authors, even if Git stops listing them. We can also + // add authors manually this way. + for _, a := range readAuthors() { + merge[a] = true + } + // Write sorted list of authors back to the file. + var result []string + for a := range merge { + result = append(result, a) + } + sort.Strings(result) + content := new(bytes.Buffer) + content.WriteString(authorsFileHeader) + for _, a := range result { + content.WriteString(a) + content.WriteString("\n") + } + fmt.Println("writing AUTHORS") + if err := ioutil.WriteFile("AUTHORS", content.Bytes(), 0644); err != nil { + log.Fatalln(err) + } +} + +func getInfo(files <-chan string, out chan<- *info, wg *sync.WaitGroup) { + for file := range files { + stat, err := os.Lstat(file) + if err != nil { + fmt.Printf("ERROR %s: %v\n", file, err) + continue + } + if !stat.Mode().IsRegular() { + continue + } + if isGenerated(file) { + continue + } + info, err := fileInfo(file) + if err != nil { + fmt.Printf("ERROR %s: %v\n", file, err) + continue + } + out <- info + } + wg.Done() +} + +func isGenerated(file string) bool { + fd, err := os.Open(file) + if err != nil { + return false + } + defer fd.Close() + buf := make([]byte, 2048) + n, _ := fd.Read(buf) + buf = buf[:n] + for _, l := range bytes.Split(buf, []byte("\n")) { + if bytes.HasPrefix(l, []byte("// Code generated")) { + return true + } + } + return false +} + +// fileInfo finds the lowest year in which the given file was committed. +func fileInfo(file string) (*info, error) { + info := &info{file: file, Year: int64(time.Now().Year())} + cmd := exec.Command("git", "log", "--follow", "--find-renames=80", "--find-copies=80", "--pretty=format:%ai", "--", file) + err := doLines(cmd, func(line string) { + y, err := strconv.ParseInt(line[:4], 10, 64) + if err != nil { + fmt.Printf("cannot parse year: %q", line[:4]) + } + if y < info.Year { + info.Year = y + } + }) + return info, err +} + +func writeLicenses(infos <-chan *info) { + for i := range infos { + writeLicense(i) + } +} + +func writeLicense(info *info) { + fi, err := os.Stat(info.file) + if os.IsNotExist(err) { + fmt.Println("skipping (does not exist)", info.file) + return + } + if err != nil { + log.Fatalf("error stat'ing %s: %v\n", info.file, err) + } + content, err := ioutil.ReadFile(info.file) + if err != nil { + log.Fatalf("error reading %s: %v\n", info.file, err) + } + // Construct new file content. + buf := new(bytes.Buffer) + licenseT.Execute(buf, info) + if m := licenseCommentRE.FindIndex(content); m != nil && m[0] == 0 { + buf.Write(content[:m[0]]) + buf.Write(content[m[1]:]) + } else { + buf.Write(content) + } + // Write it to the file. + if bytes.Equal(content, buf.Bytes()) { + fmt.Println("skipping (no changes)", info.file) + return + } + fmt.Println("writing", info.ShortLicense(), info.file) + if err := ioutil.WriteFile(info.file, buf.Bytes(), fi.Mode()); err != nil { + log.Fatalf("error writing %s: %v", info.file, err) + } +} + +func doLines(cmd *exec.Cmd, f func(string)) error { + stdout, err := cmd.StdoutPipe() + if err != nil { + return err + } + if err := cmd.Start(); err != nil { + return err + } + s := bufio.NewScanner(stdout) + for s.Scan() { + f(s.Text()) + } + if s.Err() != nil { + return s.Err() + } + if err := cmd.Wait(); err != nil { + return fmt.Errorf("%v (for %s)", err, strings.Join(cmd.Args, " ")) + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/circle.yml b/vendor/github.com/ethereum/go-ethereum/circle.yml new file mode 100644 index 000000000..39ff5d83c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/circle.yml @@ -0,0 +1,32 @@ +machine: + services: + - docker + +dependencies: + cache_directories: + - "~/.ethash" # Cache the ethash DAG generated by hive for consecutive builds + - "~/.docker" # Cache all docker images manually to avoid lengthy rebuilds + override: + # Restore all previously cached docker images + - mkdir -p ~/.docker + - for img in `ls ~/.docker`; do docker load -i ~/.docker/$img; done + + # Pull in and hive, restore cached ethash DAGs and do a dry run + - go get -u github.com/karalabe/hive + - (cd ~/.go_workspace/src/github.com/karalabe/hive && mkdir -p workspace/ethash/ ~/.ethash) + - (cd ~/.go_workspace/src/github.com/karalabe/hive && cp -r ~/.ethash/. workspace/ethash/) + - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=NONE --test=. --sim=. --loglevel=6) + + # Cache all the docker images and the ethash DAGs + - for img in `docker images | grep -v "^" | tail -n +2 | awk '{print $1}'`; do docker save $img > ~/.docker/`echo $img | tr '/' ':'`.tar; done + - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/ethash/. ~/.ethash + +test: + override: + # Build Geth and move into a known folder + - make geth + - cp ./build/bin/geth $HOME/geth + + # Run hive and move all generated logs into the public artifacts folder + - (cd ~/.go_workspace/src/github.com/karalabe/hive && hive --docker-noshell --client=go-ethereum:local --override=$HOME/geth --test=. --sim=.) + - cp -r ~/.go_workspace/src/github.com/karalabe/hive/workspace/logs/* $CIRCLE_ARTIFACTS diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/evm/json_logger.go b/vendor/github.com/ethereum/go-ethereum/cmd/evm/json_logger.go new file mode 100644 index 000000000..d61981062 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/cmd/evm/json_logger.go @@ -0,0 +1,67 @@ +// 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 main + +import ( + "encoding/json" + "io" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/core/vm" +) + +type JSONLogger struct { + encoder *json.Encoder + cfg *vm.LogConfig +} + +func NewJSONLogger(cfg *vm.LogConfig, writer io.Writer) *JSONLogger { + return &JSONLogger{json.NewEncoder(writer), cfg} +} + +// 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{ + Pc: pc, + Op: op, + Gas: gas + cost, + GasCost: cost, + MemorySize: memory.Len(), + Storage: nil, + Depth: depth, + Err: err, + } + if !l.cfg.DisableMemory { + log.Memory = memory.Data() + } + if !l.cfg.DisableStack { + log.Stack = stack.Data() + } + return l.encoder.Encode(log) +} + +// CaptureEnd is triggered at end of execution. +func (l *JSONLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration) error { + type endLog struct { + Output string `json:"output"` + GasUsed math.HexOrDecimal64 `json:"gasUsed"` + Time time.Duration `json:"time"` + } + return l.encoder.Encode(endLog{common.Bytes2Hex(output), math.HexOrDecimal64(gasUsed), t}) +} diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/evm/main.go b/vendor/github.com/ethereum/go-ethereum/cmd/evm/main.go index 5f85f484e..1892ae3d3 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/evm/main.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/evm/main.go @@ -35,6 +35,18 @@ var ( Name: "debug", Usage: "output full trace logs", } + MemProfileFlag = cli.StringFlag{ + Name: "memprofile", + Usage: "creates a memory profile at the given path", + } + CPUProfileFlag = cli.StringFlag{ + Name: "cpuprofile", + Usage: "creates a CPU profile at the given path", + } + StatDumpFlag = cli.BoolFlag{ + Name: "statdump", + Usage: "displays stack and heap memory information", + } CodeFlag = cli.StringFlag{ Name: "code", Usage: "EVM code", @@ -78,6 +90,26 @@ var ( Name: "nogasmetering", Usage: "disable gas metering", } + GenesisFlag = cli.StringFlag{ + Name: "prestate", + Usage: "JSON file with prestate (genesis) config", + } + MachineFlag = cli.BoolFlag{ + Name: "json", + Usage: "output trace logs in machine readable format (json)", + } + SenderFlag = cli.StringFlag{ + Name: "sender", + Usage: "The transaction origin", + } + DisableMemoryFlag = cli.BoolFlag{ + Name: "nomemory", + Usage: "disable memory output", + } + DisableStackFlag = cli.BoolFlag{ + Name: "nostack", + Usage: "disable stack output", + } ) func init() { @@ -93,6 +125,14 @@ func init() { DumpFlag, InputFlag, DisableGasMeteringFlag, + MemProfileFlag, + CPUProfileFlag, + StatDumpFlag, + GenesisFlag, + MachineFlag, + SenderFlag, + DisableMemoryFlag, + DisableStackFlag, } app.Commands = []cli.Command{ compileCommand, diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/evm/runner.go b/vendor/github.com/ethereum/go-ethereum/cmd/evm/runner.go index 6ef9230f4..3f95a0c93 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/evm/runner.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/evm/runner.go @@ -18,9 +18,11 @@ package main import ( "bytes" + "encoding/json" "fmt" "io/ioutil" "os" + "runtime/pprof" "time" goruntime "runtime" @@ -28,11 +30,13 @@ import ( "github.com/ethereum/go-ethereum/cmd/evm/internal/compiler" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/core/vm/runtime" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/params" cli "gopkg.in/urfave/cli.v1" ) @@ -44,17 +48,63 @@ var runCommand = cli.Command{ Description: `The run command runs arbitrary EVM code.`, } +// readGenesis will read the given JSON format genesis file and return +// the initialized Genesis structure +func readGenesis(genesisPath string) *core.Genesis { + // Make sure we have a valid genesis JSON + //genesisPath := ctx.Args().First() + if len(genesisPath) == 0 { + utils.Fatalf("Must supply path to genesis JSON file") + } + file, err := os.Open(genesisPath) + if err != nil { + utils.Fatalf("Failed to read genesis file: %v", err) + } + defer file.Close() + + genesis := new(core.Genesis) + if err := json.NewDecoder(file).Decode(genesis); err != nil { + utils.Fatalf("invalid genesis file: %v", err) + } + return genesis +} + func runCmd(ctx *cli.Context) error { glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false))) glogger.Verbosity(log.Lvl(ctx.GlobalInt(VerbosityFlag.Name))) log.Root().SetHandler(glogger) + logconfig := &vm.LogConfig{ + DisableMemory: ctx.GlobalBool(DisableMemoryFlag.Name), + DisableStack: ctx.GlobalBool(DisableStackFlag.Name), + } var ( - db, _ = ethdb.NewMemDatabase() - statedb, _ = state.New(common.Hash{}, db) - sender = common.StringToAddress("sender") - logger = vm.NewStructLogger(nil) + tracer vm.Tracer + debugLogger *vm.StructLogger + statedb *state.StateDB + chainConfig *params.ChainConfig + sender = common.StringToAddress("sender") ) + if ctx.GlobalBool(MachineFlag.Name) { + tracer = NewJSONLogger(logconfig, os.Stdout) + } else if ctx.GlobalBool(DebugFlag.Name) { + debugLogger = vm.NewStructLogger(logconfig) + tracer = debugLogger + } else { + debugLogger = vm.NewStructLogger(logconfig) + } + if ctx.GlobalString(GenesisFlag.Name) != "" { + gen := readGenesis(ctx.GlobalString(GenesisFlag.Name)) + _, statedb = gen.ToBlock() + chainConfig = gen.Config + } else { + db, _ := ethdb.NewMemDatabase() + statedb, _ = state.New(common.Hash{}, state.NewDatabase(db)) + } + if ctx.GlobalString(SenderFlag.Name) != "" { + sender = common.HexToAddress(ctx.GlobalString(SenderFlag.Name)) + } + statedb.CreateAccount(sender) var ( @@ -94,43 +144,77 @@ func runCmd(ctx *cli.Context) error { } code = common.Hex2Bytes(string(bytes.TrimRight(hexcode, "\n"))) } - + initialGas := ctx.GlobalUint64(GasFlag.Name) runtimeConfig := runtime.Config{ Origin: sender, State: statedb, - GasLimit: ctx.GlobalUint64(GasFlag.Name), + GasLimit: initialGas, GasPrice: utils.GlobalBig(ctx, PriceFlag.Name), Value: utils.GlobalBig(ctx, ValueFlag.Name), EVMConfig: vm.Config{ - Tracer: logger, - Debug: ctx.GlobalBool(DebugFlag.Name), + Tracer: tracer, + Debug: ctx.GlobalBool(DebugFlag.Name) || ctx.GlobalBool(MachineFlag.Name), DisableGasMetering: ctx.GlobalBool(DisableGasMeteringFlag.Name), }, } + if cpuProfilePath := ctx.GlobalString(CPUProfileFlag.Name); cpuProfilePath != "" { + f, err := os.Create(cpuProfilePath) + if err != nil { + fmt.Println("could not create CPU profile: ", err) + os.Exit(1) + } + if err := pprof.StartCPUProfile(f); err != nil { + fmt.Println("could not start CPU profile: ", err) + os.Exit(1) + } + defer pprof.StopCPUProfile() + } + + if chainConfig != nil { + runtimeConfig.ChainConfig = chainConfig + } tstart := time.Now() + var leftOverGas uint64 if ctx.GlobalBool(CreateFlag.Name) { input := append(code, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name))...) - ret, _, err = runtime.Create(input, &runtimeConfig) + ret, _, leftOverGas, err = runtime.Create(input, &runtimeConfig) } else { receiver := common.StringToAddress("receiver") statedb.SetCode(receiver, code) - ret, err = runtime.Call(receiver, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)), &runtimeConfig) + ret, leftOverGas, err = runtime.Call(receiver, common.Hex2Bytes(ctx.GlobalString(InputFlag.Name)), &runtimeConfig) } execTime := time.Since(tstart) if ctx.GlobalBool(DumpFlag.Name) { - statedb.Commit(true) + statedb.IntermediateRoot(true) fmt.Println(string(statedb.Dump())) } + if memProfilePath := ctx.GlobalString(MemProfileFlag.Name); memProfilePath != "" { + f, err := os.Create(memProfilePath) + if err != nil { + fmt.Println("could not create memory profile: ", err) + os.Exit(1) + } + if err := pprof.WriteHeapProfile(f); err != nil { + fmt.Println("could not write memory profile: ", err) + os.Exit(1) + } + f.Close() + } + if ctx.GlobalBool(DebugFlag.Name) { - fmt.Fprintln(os.Stderr, "#### TRACE ####") - vm.WriteTrace(os.Stderr, logger.StructLogs()) + if debugLogger != nil { + fmt.Fprintln(os.Stderr, "#### TRACE ####") + vm.WriteTrace(os.Stderr, debugLogger.StructLogs()) + } fmt.Fprintln(os.Stderr, "#### LOGS ####") vm.WriteLogs(os.Stderr, statedb.Logs()) + } + if ctx.GlobalBool(StatDumpFlag.Name) { var mem goruntime.MemStats goruntime.ReadMemStats(&mem) fmt.Fprintf(os.Stderr, `evm execution time: %v @@ -138,14 +222,18 @@ heap objects: %d allocations: %d total allocations: %d GC calls: %d +Gas used: %d -`, execTime, mem.HeapObjects, mem.Alloc, mem.TotalAlloc, mem.NumGC) +`, execTime, mem.HeapObjects, mem.Alloc, mem.TotalAlloc, mem.NumGC, initialGas-leftOverGas) + } + if tracer != nil { + tracer.CaptureEnd(ret, initialGas-leftOverGas, execTime) + } else { + fmt.Printf("0x%x\n", ret) } - fmt.Printf("0x%x", ret) if err != nil { - fmt.Printf(" error: %v", err) + fmt.Printf(" error: %v\n", err) } - fmt.Println() return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.go b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.go index 1c5c43edc..c06c4365b 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.go @@ -27,11 +27,13 @@ import ( "fmt" "html/template" "io/ioutil" + "math" "math/big" "net/http" "net/url" "os" "path/filepath" + "strconv" "strings" "sync" "time" @@ -67,6 +69,7 @@ var ( netnameFlag = flag.String("faucet.name", "", "Network name to assign to the faucet") payoutFlag = flag.Int("faucet.amount", 1, "Number of Ethers to pay out per user request") minutesFlag = flag.Int("faucet.minutes", 1440, "Number of minutes to wait between funding rounds") + tiersFlag = flag.Int("faucet.tiers", 3, "Number of funding tiers to enable (x3 time, x2.5 funds)") accJSONFlag = flag.String("account.json", "", "Key json file to fund user requests with") accPassFlag = flag.String("account.pass", "", "Decryption password to access faucet funds") @@ -89,22 +92,47 @@ func main() { flag.Parse() log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*logFlag), log.StreamHandler(os.Stderr, log.TerminalFormat(true)))) + // Construct the payout tiers + amounts := make([]string, *tiersFlag) + periods := make([]string, *tiersFlag) + for i := 0; i < *tiersFlag; i++ { + // Calculate the amount for the next tier and format it + amount := float64(*payoutFlag) * math.Pow(2.5, float64(i)) + amounts[i] = fmt.Sprintf("%s Ethers", strconv.FormatFloat(amount, 'f', -1, 64)) + if amount == 1 { + amounts[i] = strings.TrimSuffix(amounts[i], "s") + } + // Calculate the period for the next tier and format it + period := *minutesFlag * int(math.Pow(3, float64(i))) + periods[i] = fmt.Sprintf("%d mins", period) + if period%60 == 0 { + period /= 60 + periods[i] = fmt.Sprintf("%d hours", period) + + if period%24 == 0 { + period /= 24 + periods[i] = fmt.Sprintf("%d days", period) + } + } + if period == 1 { + periods[i] = strings.TrimSuffix(periods[i], "s") + } + } // Load up and render the faucet website tmpl, err := Asset("faucet.html") if err != nil { log.Crit("Failed to load the faucet template", "err", err) } - period := fmt.Sprintf("%d minute(s)", *minutesFlag) - if *minutesFlag%60 == 0 { - period = fmt.Sprintf("%d hour(s)", *minutesFlag/60) - } website := new(bytes.Buffer) - template.Must(template.New("").Parse(string(tmpl))).Execute(website, map[string]interface{}{ + err = template.Must(template.New("").Parse(string(tmpl))).Execute(website, map[string]interface{}{ "Network": *netnameFlag, - "Amount": *payoutFlag, - "Period": period, + "Amounts": amounts, + "Periods": periods, "Recaptcha": *captchaToken, }) + if err != nil { + log.Crit("Failed to render the faucet template", "err", err) + } // Load and parse the genesis block requested by the user blob, err := ioutil.ReadFile(*genesisFlag) if err != nil { @@ -171,10 +199,10 @@ type faucet struct { nonce uint64 // Current pending nonce of the faucet price *big.Int // Current gas price to issue funds with - conns []*websocket.Conn // Currently live websocket connections - history map[string]time.Time // History of users and their funding requests - reqs []*request // Currently pending funding requests - update chan struct{} // Channel to signal request updates + conns []*websocket.Conn // Currently live websocket connections + timeouts map[string]time.Time // History of users and their funding timeouts + reqs []*request // Currently pending funding requests + update chan struct{} // Channel to signal request updates lock sync.RWMutex // Lock protecting the faucet's internals } @@ -241,7 +269,7 @@ func newFaucet(genesis *core.Genesis, port int, enodes []*discv5.Node, network u index: index, keystore: ks, account: ks.Accounts()[0], - history: make(map[string]time.Time), + timeouts: make(map[string]time.Time), update: make(chan struct{}, 1), }, nil } @@ -295,14 +323,22 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { "peers": f.stack.Server().PeerCount(), "requests": f.reqs, }) - header, _ := f.client.HeaderByNumber(context.Background(), nil) - websocket.JSON.Send(conn, header) + // Send the initial block to the client + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + header, err := f.client.HeaderByNumber(ctx, nil) + cancel() + if err != nil { + log.Error("Failed to retrieve latest header", "err", err) + } else { + websocket.JSON.Send(conn, header) + } // Keep reading requests from the websocket until the connection breaks for { // Fetch the next funding request and validate against github var msg struct { URL string `json:"url"` + Tier uint `json:"tier"` Captcha string `json:"captcha"` } if err := websocket.JSON.Receive(conn, &msg); err != nil { @@ -312,7 +348,11 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { websocket.JSON.Send(conn, map[string]string{"error": "URL doesn't link to GitHub Gists"}) continue } - log.Info("Faucet funds requested", "gist", msg.URL) + if msg.Tier >= uint(*tiersFlag) { + websocket.JSON.Send(conn, map[string]string{"error": "Invalid funding tier requested"}) + continue + } + log.Info("Faucet funds requested", "gist", msg.URL, "tier", msg.Tier) // If captcha verifications are enabled, make sure we're not dealing with a robot if *captchaToken != "" { @@ -337,7 +377,7 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { } if !result.Success { log.Warn("Captcha verification failed", "err", string(result.Errors)) - websocket.JSON.Send(conn, map[string]string{"error": "Beep-boop, you're a robot!"}) + websocket.JSON.Send(conn, map[string]string{"error": "Beep-bop, you're a robot!"}) continue } } @@ -396,11 +436,15 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { f.lock.Lock() var ( fund bool - elapsed time.Duration + timeout time.Time ) - if elapsed = time.Since(f.history[gist.Owner.Login]); elapsed > time.Duration(*minutesFlag)*time.Minute { + if timeout = f.timeouts[gist.Owner.Login]; time.Now().After(timeout) { // User wasn't funded recently, create the funding transaction - tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, new(big.Int).Mul(big.NewInt(int64(*payoutFlag)), ether), big.NewInt(21000), f.price, nil) + amount := new(big.Int).Mul(big.NewInt(int64(*payoutFlag)), ether) + 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) signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainId) if err != nil { websocket.JSON.Send(conn, map[string]string{"error": err.Error()}) @@ -419,14 +463,14 @@ func (f *faucet) apiHandler(conn *websocket.Conn) { Time: time.Now(), Tx: signed, }) - f.history[gist.Owner.Login] = time.Now() + f.timeouts[gist.Owner.Login] = time.Now().Add(time.Duration(*minutesFlag*int(math.Pow(3, float64(msg.Tier)))) * time.Minute) fund = true } f.lock.Unlock() // Send an error if too frequent funding, othewise a success if !fund { - websocket.JSON.Send(conn, map[string]string{"error": fmt.Sprintf("User already funded %s ago", common.PrettyDuration(elapsed))}) + websocket.JSON.Send(conn, map[string]string{"error": fmt.Sprintf("%s left until next allowance", common.PrettyDuration(timeout.Sub(time.Now())))}) continue } websocket.JSON.Send(conn, map[string]string{"success": fmt.Sprintf("Funding request accepted for %s into %s", gist.Owner.Login, address.Hex())}) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.html b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.html index 9e02134b7..56dd37623 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.html +++ b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/faucet.html @@ -51,7 +51,10 @@
- + +
{{if .Recaptcha}}
{{end}} @@ -77,8 +80,9 @@

How does this work?

-

This Ether faucet is running on the {{.Network}} network. To prevent malicious actors from exhausting all available funds or accumulating enough Ether to mount long running spam attacks, requests are tied to GitHub accounts. Anyone having a GitHub account may request funds within the permitted limit of {{.Amount}} Ether(s) / {{.Period}}.{{if .Recaptcha}} The faucet is running invisible reCaptcha protection against bots.{{end}}

+

This Ether faucet is running on the {{.Network}} network. To prevent malicious actors from exhausting all available funds or accumulating enough Ether to mount long running spam attacks, requests are tied to GitHub accounts. Anyone having a GitHub account may request funds within the permitted limits.

To request funds, simply create a GitHub Gist with your Ethereum address pasted into the contents (the file name doesn't matter), copy paste the gists URL into the above input box and fire away! You can track the current pending requests below the input field to see how much you have to wait until your turn comes.

+ {{if .Recaptcha}}The faucet is running invisible reCaptcha protection against bots.{{end}}
@@ -88,10 +92,11 @@ // Global variables to hold the current status of the faucet var attempt = 0; var server; + var tier = 0; // Define the function that submits a gist url to the server var submit = function({{if .Recaptcha}}captcha{{end}}) { - server.send(JSON.stringify({url: $("#gist")[0].value{{if .Recaptcha}}, captcha: captcha{{end}}}));{{if .Recaptcha}} + server.send(JSON.stringify({url: $("#gist")[0].value, tier: tier{{if .Recaptcha}}, captcha: captcha{{end}}}));{{if .Recaptcha}} grecaptcha.reset();{{end}} }; // Define a method to reconnect upon server loss diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/website.go b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/website.go index 1a5e2e4c5..3151ab584 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/faucet/website.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/faucet/website.go @@ -68,7 +68,7 @@ func (fi bindataFileInfo) Sys() interface{} { return nil } -var _faucetHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x59\xef\x72\xdb\x36\x12\xff\xac\x3c\xc5\x86\x77\xad\xa5\xb1\x49\xda\x71\x26\xed\xc8\xa4\x3a\x99\x34\x97\xf6\xe6\xa6\xed\xb4\xe9\xdc\x75\xda\xce\x0d\x48\x2e\x49\xc4\x20\xc0\x02\x4b\xc9\xaa\x47\xef\x7e\x03\x80\xa4\x28\x59\x4e\xd3\x4b\xbf\xc8\x04\xb0\xf8\xed\x62\x77\xb1\x7f\xe0\xe4\xe9\x97\xdf\xbe\x7a\xfb\xd3\x77\xaf\xa1\xa6\x46\xac\x9e\x24\xf6\x0f\x08\x26\xab\x34\x40\x19\xac\x9e\xcc\x92\x1a\x59\xb1\x7a\x32\x9b\x25\x0d\x12\x83\xbc\x66\xda\x20\xa5\x41\x47\x65\xf8\x79\xb0\x5f\xa8\x89\xda\x10\x7f\xeb\xf8\x3a\x0d\xfe\x13\xfe\xf8\x32\x7c\xa5\x9a\x96\x11\xcf\x04\x06\x90\x2b\x49\x28\x29\x0d\xbe\x7e\x9d\x62\x51\xe1\x64\x9f\x64\x0d\xa6\xc1\x9a\xe3\xa6\x55\x9a\x26\xa4\x1b\x5e\x50\x9d\x16\xb8\xe6\x39\x86\x6e\x70\x01\x5c\x72\xe2\x4c\x84\x26\x67\x02\xd3\xab\x60\xf5\xc4\xe2\x10\x27\x81\xab\xfb\xfb\xe8\x1b\xa4\x8d\xd2\xb7\xbb\xdd\x12\xde\x70\xfa\xaa\xcb\xe0\x1f\xac\xcb\x91\x92\xd8\x93\x38\x6a\xc1\xe5\x2d\xd4\x1a\xcb\x34\xb0\x32\x9b\x65\x1c\xe7\x85\x7c\x67\xa2\x5c\xa8\xae\x28\x05\xd3\x18\xe5\xaa\x89\xd9\x3b\x76\x17\x0b\x9e\x99\x98\x36\x9c\x08\x75\x98\x29\x45\x86\x34\x6b\xe3\xeb\xe8\x3a\xfa\x2c\xce\x8d\x89\xc7\xb9\xa8\xe1\x32\xca\x8d\x09\x40\xa3\x48\x03\x43\x5b\x81\xa6\x46\xa4\x00\xe2\xd5\xff\xc7\xb7\x54\x92\x42\xb6\x41\xa3\x1a\x8c\x9f\x47\x9f\x45\x97\x8e\xe5\x74\xfa\xfd\x5c\x2d\x5b\x93\x6b\xde\x12\x18\x9d\x7f\x30\xdf\x77\xbf\x75\xa8\xb7\xf1\x75\x74\x15\x5d\xf5\x03\xc7\xe7\x9d\x09\x56\x49\xec\x01\x57\x1f\x85\x1d\x4a\x45\xdb\xf8\x59\xf4\x3c\xba\x8a\x5b\x96\xdf\xb2\x0a\x8b\x81\x93\x5d\x8a\x86\xc9\xbf\x8c\xef\x63\x36\x7c\x77\x6c\xc2\xbf\x82\x59\xa3\x1a\x94\x14\xbd\x33\xf1\xb3\xe8\xea\xf3\xe8\x72\x98\x78\x88\xef\x18\x58\xa3\x59\x56\xb3\x68\x8d\x9a\x78\xce\x44\x98\xa3\x24\xd4\x70\x6f\x67\x67\x0d\x97\x61\x8d\xbc\xaa\x69\x09\x57\x97\x97\x9f\xdc\x9c\x9a\x5d\xd7\x7e\xba\xe0\xa6\x15\x6c\xbb\x84\x52\xe0\x9d\x9f\x62\x82\x57\x32\xe4\x84\x8d\x59\x82\x47\x76\x0b\x3b\xc7\xb3\xd5\xaa\xd2\x68\x4c\xcf\xac\x55\x86\x13\x57\x72\x69\x3d\x8a\x11\x5f\xe3\x29\x5a\xd3\x32\xf9\x60\x03\xcb\x8c\x12\x1d\xe1\x91\x20\x99\x50\xf9\xad\x9f\x73\xd7\x78\x7a\x88\x5c\x09\xa5\x97\xb0\xa9\x79\xbf\x0d\x1c\x23\x68\x35\xf6\xf0\xd0\xb2\xa2\xe0\xb2\x5a\xc2\x8b\xb6\x3f\x0f\x34\x4c\x57\x5c\x2e\xe1\x72\xbf\x25\x89\x07\x35\x26\xb1\x8f\x58\x4f\x66\x49\xa6\x8a\xad\xb3\x61\xc1\xd7\x90\x0b\x66\x4c\x1a\x1c\xa9\xd8\x45\xa2\x03\x02\x1b\x80\x18\x97\xc3\xd2\xc1\x9a\x56\x9b\x00\x1c\xa3\x34\xf0\x42\x84\x99\x22\x52\xcd\x12\xae\xac\x78\xfd\x96\x23\x3c\x11\x8a\x2a\xbc\x7a\x36\x2c\xce\x92\xfa\x6a\x00\x21\xbc\xa3\xd0\xd9\x67\xb4\x4c\xb0\x4a\xf8\xb0\xb7\x64\x50\xb2\x30\x63\x54\x07\xc0\x34\x67\x61\xcd\x8b\x02\x65\x1a\x90\xee\xd0\xfa\x11\x5f\xc1\x34\xee\x0d\x61\xef\x65\x47\x35\x4a\x7b\x4e\xc2\xa2\x0f\x82\x70\x0c\x5b\x71\xaa\xbb\x2c\x64\x82\x1e\x05\x4f\xe2\xfa\x6a\x38\x52\x5c\xf0\x75\xaf\x91\xc9\xe7\x91\x72\x1e\x3f\xff\xe7\xd0\x7f\xa8\xb2\x34\x48\xe1\x44\x1d\x13\x62\x2e\xdb\x8e\xc2\x4a\xab\xae\x1d\xd7\x67\x89\x9b\x05\x5e\xa4\x41\xc5\x0d\x05\x40\xdb\xb6\xd7\x5d\x30\x1e\x49\xe9\x26\xb4\xa6\xd3\x4a\x04\xd0\x0a\x96\x63\xad\x44\x81\x3a\x0d\x7a\x9d\xbc\xe1\x86\xe0\xc7\xef\xff\x05\xbd\x81\xb9\xac\x60\xab\x3a\x0d\xaf\xa9\x46\x8d\x5d\x03\xac\x28\xac\x73\x47\x51\x34\xe1\xed\x3c\xfd\xa1\x74\x61\x46\x72\x4f\x35\x4b\xb2\x8e\x48\x8d\x84\x19\x49\xc8\x48\x86\x05\x96\xac\x13\xa3\xc4\x9e\x28\x00\x25\x73\xc1\xf3\xdb\x34\xb8\xbf\xe7\x25\x44\xdf\x63\xce\x5a\xca\x6b\xb6\xdb\x55\x7a\xf8\x8e\xf0\x0e\xf3\x8e\x70\xbe\xb8\xbf\x47\x61\x70\xb7\x33\x5d\xd6\x70\x72\x63\x59\xec\x76\xc1\xea\x0d\x5f\x23\x34\xe8\x0f\xf0\x34\x89\x3d\xfc\x5e\xf4\xd8\xca\x3e\x6a\xd9\x19\xed\x01\xc3\x13\x36\xa8\xc2\x51\x88\x00\x0a\x46\x2c\x34\x9c\xf0\x16\xb7\x56\xde\xe9\xde\x7e\x35\x67\x42\x64\xcc\x1e\xc7\x4b\x38\x6e\xfa\x1d\xad\xca\xd6\xdc\xb8\x22\x60\x35\x48\xe0\xa4\xff\x33\x4e\x75\x74\xe3\x48\xb5\x4b\xb8\x7e\x36\xb9\x6e\xa7\xfc\xed\xc5\x91\xbf\x5d\x9f\x24\x6e\x99\x44\x01\xee\x37\x34\x0d\x13\xc3\xf7\x60\xb8\xbd\x32\x8f\x37\x85\x36\xb8\x8c\xa2\x8d\x41\xea\xf2\x06\xd4\x1a\x75\x29\xd4\x66\x09\xac\x23\x75\x03\x0d\xbb\x1b\x03\xf5\xf5\xe5\xe5\x54\x6e\x5b\xbc\xb0\x4c\xa0\xf3\x6d\x8d\xbf\x75\x68\xc8\x8c\x3e\xed\x97\xdc\xaf\x75\xed\x02\xa5\xc1\xe2\x48\x1b\x96\xa3\x55\xad\xa3\x9a\x98\x7e\x54\xe6\x49\xd9\x4b\xa5\xc6\xd8\x37\x15\xa3\x87\x9e\x84\xe9\x60\x95\x90\xde\xd3\xcd\x12\x2a\xfe\x54\xec\xd2\xb6\x36\x79\x2c\x74\xf9\xcb\x65\xcf\xde\x22\x6a\x9f\x18\xad\xcb\x82\x1b\x26\x31\x15\x1f\xc1\xd9\x3a\x61\xc6\x0c\x7e\x08\x7b\x97\xa2\xf6\xec\xdd\xf0\x63\xf9\xd7\xc8\x34\x65\xc8\x1e\x8f\xae\x13\x01\xca\x4e\x16\x93\xf3\xbb\x1b\xfd\xb1\x02\x74\x92\xaf\x51\x1b\x4e\xdb\x0f\x95\x00\x8b\xbd\x08\x7e\x7c\x28\x42\x12\x93\x7e\xbf\xaf\x4d\x07\x7f\xd1\xe5\xfe\xa3\x5c\x7a\xbd\xfa\x4a\x6d\xa0\x50\x68\x80\x6a\x6e\xc0\x66\xc2\x2f\x92\xb8\xbe\x1e\x49\xda\xd5\x5b\xbb\xe0\x94\x0a\xa5\x4f\x86\xdc\x80\xee\xa4\x4b\x02\x4a\x02\xd5\x78\x98\x47\xa5\xff\x8a\xe0\xad\xb2\xb5\xc8\x1a\x25\x41\xc3\x04\xcf\xb9\xea\x0c\xb0\x9c\x94\x36\x50\x6a\xd5\x00\xde\xd5\xac\x33\x64\x81\x6c\xf8\x60\x6b\xc6\x85\xbb\x4b\xce\xa4\xa0\x34\xb0\x3c\xef\x9a\xce\xd6\x52\xb2\x02\x94\xaa\xab\xea\x5e\x16\x52\xd0\xa8\x4e\x12\x08\x25\xab\x51\x1e\xd3\xb2\x06\x18\x11\xcb\x6f\xcd\x05\x0c\x51\x01\x98\x46\x20\x8e\x85\xdd\xd5\xa7\x34\x96\xe7\x76\xbb\x89\xe0\xa5\xdc\x2a\x89\x50\xb3\xb5\x13\xe4\x88\x00\x1a\xb6\x1d\x80\x7a\xb9\x36\x9c\x6a\xee\x0f\xde\xa2\x6e\x6c\x71\x5c\x80\xe0\x0d\x27\x50\x25\x24\x86\xb4\x92\x95\xed\xa9\x5e\x3a\x09\x77\x3b\x2f\xf2\xdc\x2c\x20\xb6\xaa\xfa\x0e\x35\x57\xc5\x6e\x67\xeb\x2e\x47\x1a\x3d\x48\x2d\xf0\xb6\xc6\x13\xea\x1e\x33\x02\x68\x7c\xe5\x69\xa1\xd5\x8a\x30\xb7\x55\x24\xb0\x8a\x71\x69\x08\x32\x45\x26\xea\x93\x45\x12\xb7\x53\x63\xaa\xc3\xb3\x5c\x80\xe1\x4d\x2b\xb6\x90\x6b\x64\x84\xc0\x20\x61\x47\x8d\x96\x2d\x1b\x22\x5f\xef\xb8\x52\x3d\x00\x62\xba\xb2\x6d\xec\x7f\x59\xa6\x3a\x5a\x66\x82\xc9\x5b\x9b\x51\xc7\x52\x21\x89\xd9\xca\x69\xe9\x74\x91\x00\x2d\x33\x56\x65\x5c\x92\x72\x5a\xec\xfb\x56\x03\x73\x3b\x2a\xb9\x40\xd7\xda\x3a\xc7\x94\x67\xd6\x04\xb6\xff\x58\x5c\x40\xae\xda\xad\xdf\xed\xf6\x59\xd1\x8c\xab\x4b\x46\x28\x96\xa9\x35\x82\x2f\x7a\x32\x75\x07\x4c\x16\x50\x72\x8d\xc0\x36\x6c\xfb\x14\x7e\x52\x1d\xe4\x4c\x02\x69\x96\xdf\x7a\xde\x9d\xd6\xd6\x43\x5b\x94\x36\x0b\xed\x7d\x26\x43\xa1\x36\x8e\xc4\xa3\x95\x1c\x85\x73\x20\x83\x08\xb5\xda\x40\xd3\xe5\xee\x80\xd6\x73\xd0\x2e\x6c\x18\x27\xe8\x24\x71\xe1\xcf\x4d\x9d\x96\x90\xab\x06\x4d\xb4\xb7\xc2\xc9\x9b\x3d\x7e\xf5\x1f\xfb\xde\xc9\x2d\xc7\x31\xbc\x11\x2a\x63\x02\xd6\x36\x18\x65\xc2\xde\x57\x05\xb6\x48\x3b\x38\x83\x21\x46\x9d\xb1\x4e\x48\xa3\xfb\xd8\xfd\x6b\xa6\xed\xa5\xc0\xa6\x25\x48\xfb\xca\xdf\xce\x19\xd4\x6b\xdb\xcf\xf4\x3c\xbe\xc4\x92\x4b\xaf\xd9\xb2\x93\xde\xa5\xa8\x66\x04\xbe\x36\x31\xc0\x9c\xc6\xa1\xd3\x02\x7a\x75\x7b\x84\x11\xcf\xd1\x41\x3a\x6e\x9f\x3f\x70\xec\xfe\xa3\x77\xce\x45\xdf\xa8\x78\x98\xc8\xa0\x2c\xe6\xff\xfc\xe1\xdb\x6f\x22\x43\x9a\xcb\x8a\x97\xdb\xf9\x7d\xa7\xc5\x12\xfe\x3e\x0f\xfe\xe6\xea\xd7\xc5\xcf\x97\xbf\x46\x6b\x26\x3a\x7c\x00\x7d\x01\xfd\xe7\x12\x0e\xb9\xec\x16\x8b\x9b\xd3\xc5\xdb\xa4\x64\xd4\x68\x90\xe6\x96\x70\xac\xb1\x76\x37\x87\x8a\x61\xd0\x20\xd5\xca\x39\x81\xc6\x5c\x49\x89\x39\x41\xd7\x2a\xd9\xeb\x01\x84\x32\x66\x50\xc6\x9e\x62\xa2\x8f\xe1\xc0\xbc\x84\xf9\x60\x91\x4f\xe0\x19\xa4\x29\x5c\x0e\x6b\xbd\x36\x20\x05\x89\x1b\xf8\x37\x66\x3f\xa8\xfc\x16\x69\x1e\x6c\x8c\xbd\x8f\x01\x9c\x83\x50\x39\xb3\x78\x51\xad\x0c\xc1\x39\x04\x31\x6b\x79\xb0\xf0\x2d\xde\x0e\x6c\xcd\xfb\xc7\x60\x1f\x84\xe5\x9b\x60\x2f\xe9\xf9\xb9\x77\x95\xc1\x5c\x4a\x36\x68\x0c\xab\x70\x7a\x42\x17\xef\xc7\xa3\x58\x45\x34\xa6\x82\x14\x9c\x59\x5b\xa6\x0d\x7a\x92\xc8\xd6\x18\x3d\x17\xa7\x0e\x47\x96\xa6\x20\x3b\x21\xc6\xfd\x33\x8d\xf6\x16\xf5\x64\xbb\x27\x07\xe4\x91\x0f\xc7\x4f\xd3\x14\x6c\xc2\xb5\x36\x2a\xf6\x3b\xad\xcb\xf8\xd2\x60\x11\xd9\x9c\xbf\xdf\xb1\x18\xe1\x1e\xa0\x61\xf1\x47\x70\x58\x1c\xe3\x61\xf1\x08\xa0\xab\xc4\xde\x87\xe7\x2b\xb7\x09\x9c\x9b\x78\x04\x4d\x76\x4d\x86\xfa\x7d\x70\xbe\x12\xeb\xe1\x9c\xaa\xbf\x96\x34\xd9\x7b\x01\x57\x2f\x16\x8f\xa0\xa3\xd6\xea\x51\x70\xa9\x68\x3b\xbf\x17\x6c\x6b\xc3\x3d\x9c\x91\x6a\x5f\xb9\xc2\xe9\xec\x02\x2c\xaf\x25\x8c\x08\x17\xae\x5b\x5b\xc2\x99\x1b\x9d\xed\x1e\xe1\x66\xba\x3c\xb7\x89\xe0\x63\xf8\xf5\x18\x23\xc7\x7e\xfc\x28\xcf\x31\xb0\x1f\x30\x85\x4f\x3f\x85\x07\xab\x87\x2e\x68\x7d\xb8\xcf\x50\x90\x42\x10\xf4\xf0\xb3\x52\x69\x98\xdb\x45\x9e\x5e\xde\x00\x4f\xa6\x30\x91\x40\x59\x51\x7d\x03\xfc\xfc\x7c\x8f\x34\x1b\x60\xce\x53\x08\x6c\x6f\x90\x50\xb1\x72\x35\x9a\x2f\xe4\x7e\x09\x6c\x2f\x68\x7b\x64\x59\x2c\x6d\x98\x9d\x9f\xed\xb3\xf0\x24\x01\x9f\x1f\x88\xfc\x33\xff\x35\xea\x0c\x6a\x97\x32\xcf\x21\x88\x5a\x59\x7d\xe1\x3a\xc8\x17\xcf\xcf\x16\x37\xb0\xc7\x74\x7d\xe5\x12\x72\xdb\x65\xdd\x80\xef\x54\x5c\xbd\x08\x63\x8f\xe5\x46\x99\xd2\x05\xea\x50\xb3\x82\x77\x66\x09\xcf\xdb\xbb\x9b\x5f\x86\x1e\xd4\x55\xb5\x4e\xee\x56\xe3\xea\x94\x2c\x43\xe1\x74\x0e\x41\x12\x5b\xa2\x61\xcb\x78\xca\xe9\x53\x16\x9c\xa8\xc7\x61\x7c\x68\xea\xe7\x1b\x5e\x14\x02\xad\x10\x8e\xa1\x7f\x11\x2c\x3a\xed\x02\xd7\xdc\x8f\xe7\xc7\x72\x10\x6f\x70\x11\x75\x92\xdf\xcd\x17\x61\x4f\x33\x8c\x2f\xe0\xcc\xd8\xf8\x5c\x98\xb3\x45\x54\x77\x0d\x93\xfc\x77\x9c\xdb\xe2\x7e\xe1\xe5\xb6\x12\xdb\x8a\x7d\xb4\xf6\x6e\x72\xd1\xc6\x6e\x73\x11\xd5\xd4\x88\x79\x90\x90\x7b\x2e\xb3\xc2\x8d\x26\x76\x28\x7e\xfa\xd0\x23\x77\x87\x31\x34\x17\xca\xe0\x51\x8e\x00\x83\xf4\x96\x37\xa8\x3a\x9a\x8f\x79\xe4\xc2\x76\xc0\x97\x8b\x1b\xd8\xed\x5f\x15\xe3\x18\x5e\x1b\xdb\x53\x70\x53\x03\x83\x0d\x66\xc6\xc5\x77\xe8\xf7\xb8\x14\xee\x53\xf5\xcb\xef\xbe\x9e\xa4\xeb\x11\x75\xee\x84\x1b\x5f\x55\x4f\xe5\xc9\x93\xcf\xb8\x9b\xcd\x26\xaa\x94\xaa\x84\x7f\xc0\x1d\x13\xa9\xcd\x1e\xd1\x3b\xdb\xb8\x9a\xad\xcc\xa1\xc0\x12\xf5\x6a\x02\xdf\x67\xd7\x24\xf6\x0f\x8c\x49\xec\xff\x79\xf2\xbf\x00\x00\x00\xff\xff\x82\x9c\x59\xe7\x4d\x19\x00\x00") +var _faucetHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x59\x6d\x6f\xdc\x36\x12\xfe\xec\xfc\x8a\xa9\x2e\xad\x77\x61\x4b\xb2\xe3\x20\x2d\xd6\xd2\x16\x41\x9a\x4b\x7b\x38\xb4\x45\x9b\xe2\xae\x68\x8b\x03\x25\xcd\x4a\x8c\x29\x52\x25\x87\xbb\xde\x1a\xfb\xdf\x0f\x24\x25\xad\x76\x6d\xa7\xb9\x4b\xf3\x61\x23\x92\x33\xcf\xbc\x51\xf3\x22\x67\x9f\x7c\xf5\xdd\xab\xb7\x3f\x7f\xff\x1a\x1a\x6a\xc5\xf2\x49\xe6\xfe\x03\xc1\x64\x9d\x47\x28\xa3\xe5\x93\x93\xac\x41\x56\x2d\x9f\x9c\x9c\x64\x2d\x12\x83\xb2\x61\xda\x20\xe5\x91\xa5\x55\xfc\x45\xb4\x3f\x68\x88\xba\x18\x7f\xb7\x7c\x9d\x47\xff\x8e\x7f\x7a\x19\xbf\x52\x6d\xc7\x88\x17\x02\x23\x28\x95\x24\x94\x94\x47\xdf\xbc\xce\xb1\xaa\x71\xc2\x27\x59\x8b\x79\xb4\xe6\xb8\xe9\x94\xa6\x09\xe9\x86\x57\xd4\xe4\x15\xae\x79\x89\xb1\x5f\x9c\x03\x97\x9c\x38\x13\xb1\x29\x99\xc0\xfc\x32\x5a\x3e\x71\x38\xc4\x49\xe0\xf2\xee\x2e\xf9\x16\x69\xa3\xf4\xcd\x6e\xb7\x80\x37\x9c\xbe\xb6\x05\xfc\x9d\xd9\x12\x29\x4b\x03\x89\xa7\x16\x5c\xde\x40\xa3\x71\x95\x47\x4e\x67\xb3\x48\xd3\xb2\x92\xef\x4c\x52\x0a\x65\xab\x95\x60\x1a\x93\x52\xb5\x29\x7b\xc7\x6e\x53\xc1\x0b\x93\xd2\x86\x13\xa1\x8e\x0b\xa5\xc8\x90\x66\x5d\x7a\x95\x5c\x25\x9f\xa7\xa5\x31\xe9\xb8\x97\xb4\x5c\x26\xa5\x31\x11\x68\x14\x79\x64\x68\x2b\xd0\x34\x88\x14\x41\xba\xfc\xff\xe4\xae\x94\xa4\x98\x6d\xd0\xa8\x16\xd3\xe7\xc9\xe7\xc9\x85\x17\x39\xdd\x7e\xbf\x54\x27\xd6\x94\x9a\x77\x04\x46\x97\x1f\x2c\xf7\xdd\xef\x16\xf5\x36\xbd\x4a\x2e\x93\xcb\x7e\xe1\xe5\xbc\x33\xd1\x32\x4b\x03\xe0\xf2\xa3\xb0\x63\xa9\x68\x9b\x3e\x4b\x9e\x27\x97\x69\xc7\xca\x1b\x56\x63\x35\x48\x72\x47\xc9\xb0\xf9\x97\xc9\x7d\x2c\x86\xef\x8e\x43\xf8\x57\x08\x6b\x55\x8b\x92\x92\x77\x26\x7d\x96\x5c\x7e\x91\x5c\x0c\x1b\xf7\xf1\xbd\x00\x17\x34\x27\xea\x24\x59\xa3\x26\x5e\x32\x11\x97\x28\x09\x35\xdc\xb9\xdd\x93\x96\xcb\xb8\x41\x5e\x37\xb4\x80\xcb\x8b\x8b\x4f\xaf\x1f\xda\x5d\x37\x61\xbb\xe2\xa6\x13\x6c\xbb\x80\x95\xc0\xdb\xb0\xc5\x04\xaf\x65\xcc\x09\x5b\xb3\x80\x80\xec\x0f\x76\x5e\x66\xa7\x55\xad\xd1\x98\x5e\x58\xa7\x0c\x27\xae\xe4\xc2\xdd\x28\x46\x7c\x8d\x0f\xd1\x9a\x8e\xc9\x7b\x0c\xac\x30\x4a\x58\xc2\x23\x45\x0a\xa1\xca\x9b\xb0\xe7\x5f\xe3\xa9\x11\xa5\x12\x4a\x2f\x60\xd3\xf0\x9e\x0d\xbc\x20\xe8\x34\xf6\xf0\xd0\xb1\xaa\xe2\xb2\x5e\xc0\x8b\xae\xb7\x07\x5a\xa6\x6b\x2e\x17\x70\xb1\x67\xc9\xd2\xc1\x8d\x59\x1a\x32\xd6\x93\x93\xac\x50\xd5\xd6\xc7\xb0\xe2\x6b\x28\x05\x33\x26\x8f\x8e\x5c\xec\x33\xd1\x01\x81\x4b\x40\x8c\xcb\xe1\xe8\xe0\x4c\xab\x4d\x04\x5e\x50\x1e\x05\x25\xe2\x42\x11\xa9\x76\x01\x97\x4e\xbd\x9e\xe5\x08\x4f\xc4\xa2\x8e\x2f\x9f\x0d\x87\x27\x59\x73\x39\x80\x10\xde\x52\xec\xe3\x33\x46\x26\x5a\x66\x7c\xe0\x5d\x31\x58\xb1\xb8\x60\xd4\x44\xc0\x34\x67\x71\xc3\xab\x0a\x65\x1e\x91\xb6\xe8\xee\x11\x5f\xc2\x34\xef\x0d\x69\xef\xa5\xa5\x06\xa5\xb3\x93\xb0\xea\x93\x20\x1c\xc3\xd6\x9c\x1a\x5b\xc4\x4c\xd0\xa3\xe0\x59\xda\x5c\x0e\x26\xa5\x15\x5f\xf7\x1e\x99\x3c\x1e\x39\xe7\x71\xfb\xbf\x80\xfe\x41\xad\x56\x06\x29\x9e\xb8\x63\x42\xcc\x65\x67\x29\xae\xb5\xb2\xdd\x78\x7e\x92\xf9\x5d\xe0\x55\x1e\xd5\xdc\x50\x04\xb4\xed\x7a\xdf\x45\xa3\x49\x4a\xb7\xb1\x0b\x9d\x56\x22\x82\x4e\xb0\x12\x1b\x25\x2a\xd4\x79\xd4\xfb\xe4\x0d\x37\x04\x3f\xfd\xf0\x4f\xe8\x03\xcc\x65\x0d\x5b\x65\x35\xbc\xa6\x06\x35\xda\x16\x58\x55\xb9\xcb\x9d\x24\xc9\x44\xb6\xbf\xe9\xf7\xb5\x8b\x0b\x92\x7b\xaa\x93\xac\xb0\x44\x6a\x24\x2c\x48\x42\x41\x32\xae\x70\xc5\xac\x20\xa8\xb4\xea\x2a\xb5\x91\x31\xa9\xba\x76\x05\x31\x58\x10\x98\x22\xa8\x18\xb1\xfe\x28\x8f\x06\xda\x21\x28\xcc\x74\xaa\xb3\x5d\x1f\x96\xb0\x89\xb7\x1d\x93\x15\x56\x2e\x94\xc2\x60\xb4\x7c\xc3\xd7\x08\x2d\x06\x5b\x4e\x8e\x23\x5d\x32\x8d\x14\x4f\x41\x1f\x88\x74\x50\x26\x98\x04\xfd\xbf\xcc\x8a\x01\x69\x34\xa1\x45\x69\xe1\x60\x15\x6b\x97\x85\xa2\xe5\xdd\x9d\x66\xb2\x46\x78\xca\xab\xdb\x73\x78\xca\x5a\x65\x25\xc1\x22\x87\xe4\xa5\x7f\x34\xbb\xdd\x01\x3a\x40\x26\xf8\x32\x63\xef\x7b\x19\x40\xc9\x52\xf0\xf2\x26\x8f\x88\xa3\xce\xef\xee\x1c\xf8\x6e\x77\x0d\x77\x77\x7c\x05\x4f\x93\x1f\xb0\x64\x1d\x95\x0d\xdb\xed\x6a\x3d\x3c\x27\x78\x8b\xa5\x25\x9c\xcd\xef\xee\x50\x18\xdc\xed\x8c\x2d\x5a\x4e\xb3\x81\xdd\xed\xcb\x6a\xb7\x73\x3a\xf7\x7a\xee\x76\x90\x3a\x50\x59\xe1\x2d\x3c\x4d\xbe\x47\xcd\x55\x65\x20\xd0\x67\x29\x5b\x66\xa9\xe0\xcb\x9e\xef\xd0\x49\xa9\x15\xfb\xfb\x92\xba\x0b\x33\x5e\x6d\xff\xa6\x78\x55\xa7\x9a\x3e\x70\xf1\xeb\x78\xd4\xbe\xbf\x0f\x86\x13\xde\xe0\x36\x8f\xee\xee\xa6\xbc\xfd\x69\xc9\x84\x28\x98\xf3\x4b\x30\x6d\x64\xfa\x03\xdd\x3d\x5d\x73\xe3\x3b\xaf\xe5\xa0\xc1\x5e\xed\x0f\x7c\x93\x8f\xd2\x1c\xa9\x6e\x01\x57\xcf\x26\x39\xee\xa1\x97\xfc\xc5\xd1\x4b\x7e\xf5\x20\x71\xc7\x24\x0a\xf0\xbf\xb1\x69\x99\x18\x9e\xfb\xb7\x65\xf2\xf2\x1d\x33\xc5\x2e\xa3\x8f\xaa\x8d\x95\xe1\xe2\x1a\xd4\x1a\xf5\x4a\xa8\xcd\x02\x98\x25\x75\x0d\x2d\xbb\x1d\xab\xe3\xd5\xc5\xc5\x54\x6f\xd7\x31\xb2\x42\xa0\x4f\x28\x1a\x7f\xb7\x68\xc8\x8c\x89\x24\x1c\xf9\x5f\x97\x4f\x2a\x94\x06\xab\x23\x6f\x38\x89\xce\xb5\x9e\x6a\x12\xfa\xd1\x99\x0f\xea\xbe\x52\x6a\x2c\x38\x53\x35\x7a\xe8\x49\x6d\x8c\x96\x19\xe9\x3d\xdd\x49\x46\xd5\xff\x54\x30\xb4\x6b\x08\x1f\xab\x17\x21\xa3\x39\xdb\x3b\x44\x1d\xba\x11\x77\x65\xc1\x2f\xb3\x94\xaa\x8f\x90\xec\x2e\x61\xc1\x0c\x7e\x88\x78\xdf\x17\xec\xc5\xfb\xe5\xc7\xca\x6f\x90\x69\x2a\x90\x3d\x5e\xd2\x26\x0a\xac\xac\xac\x26\xf6\xfb\xdc\xf9\xb1\x0a\x58\xc9\xd7\xa8\x0d\xa7\xed\x87\x6a\x80\xd5\x5e\x85\xb0\x3e\x54\x21\x4b\x49\xbf\xff\xae\x4d\x17\x7f\xd1\xcb\xfd\x67\x0d\xcc\xd5\xf2\x6b\xb5\x81\x4a\xa1\x01\x6a\xb8\x01\xd7\x7e\x7c\x99\xa5\xcd\xd5\x48\xd2\x2d\xdf\xba\x03\xef\x54\x58\x85\x0e\x84\x1b\xd0\x56\xfa\xca\xab\x24\x50\x83\x87\xcd\x8b\x0c\x4f\x09\xbc\x55\xae\x01\x5c\xa3\x24\x68\x99\xe0\x25\x57\xd6\x00\x2b\x49\x69\x03\x2b\xad\x5a\xc0\xdb\x86\x59\x43\x0e\xc8\xa5\x0f\xb6\x66\x5c\xf8\x77\xc9\x87\x14\x94\x06\x56\x96\xb6\xb5\xae\x81\x95\x35\xa0\x54\xb6\x6e\x7a\x5d\x48\x41\x28\x4c\x42\xc9\x7a\xd4\xc7\x74\xac\x05\x46\xc4\xca\x1b\x73\x0e\x43\x56\x00\xa6\x11\x88\x63\xe5\xb8\xfa\x3e\x82\x95\xa5\x2f\x66\x09\xbc\x94\x5b\x25\x11\x1a\xb6\xf6\x8a\x1c\x11\x40\xcb\xb6\x03\x50\xaf\xd7\x86\x53\xc3\x83\xe1\x1d\xea\xd6\x4d\x24\x15\x08\xde\x72\x32\x49\x96\x76\x53\xdf\xa9\x43\xd6\x73\x30\xbc\xed\xc4\x16\x4a\x8d\x8c\x10\x18\x64\xec\x68\x98\x74\xad\x51\x12\x7a\x3a\x3f\x8e\x44\x40\x4c\xd7\x6e\x54\xff\x0f\x2b\x94\xa5\x45\x21\x98\xbc\x71\xad\xc2\xd8\x0e\xb9\xb2\xe6\x95\x7a\xb8\x11\x82\x8e\x19\xa7\x21\x97\xa4\xbc\xd2\xfd\x6c\x6e\x60\xe6\x56\x2b\x2e\xd0\x8f\xef\xfe\x1e\xc8\x53\x67\xb1\x9b\xb1\xe6\xe7\x50\xaa\x6e\x1b\xb8\x3d\x9f\x53\xcd\xf8\xde\x6b\x84\x62\x85\x5a\x23\x84\xc6\xae\x50\xb7\xc0\x64\x05\x2b\xae\x11\xd8\x86\x6d\x3f\x81\x9f\x95\x85\x92\x49\x20\xcd\xca\x9b\x20\xdb\x6a\xed\x2e\x44\x87\xd2\x25\xfd\x7d\x88\x0a\x14\x6a\xe3\x49\x02\xda\x8a\xa3\xf0\xf1\x32\x88\xd0\xa8\x0d\xb4\xb6\xf4\x06\xba\x40\xa1\x3b\xd8\x30\x4e\x60\x25\x71\x11\xec\x26\xab\x25\x94\xaa\xc5\x83\x28\xdc\xab\xda\x19\xb6\xcb\xb7\xce\xee\x7b\x97\x79\xac\xb7\xa0\xf1\x55\x20\x87\x4e\x2b\xc2\xd2\x0d\x46\xc0\x6a\xc6\xa5\x71\x76\xfa\x38\x63\xfb\x01\xf5\x78\x7c\xea\x1f\xf6\x93\xa8\x3f\x4e\x53\x78\x23\x54\xc1\x04\xac\x5d\x96\x29\x84\x7b\x11\x15\xb8\x96\xf7\xc0\x5b\x86\x18\x59\x03\x6a\xe5\x77\x83\xe6\x8e\x7f\xcd\xb4\xbb\xed\xd8\x76\x04\x79\x3f\x47\xb9\x3d\x83\x7a\xdd\x4f\x87\x6e\xe9\x7a\xae\x70\xde\x0b\xfd\x0a\x57\x5c\x86\xa0\xae\xac\x0c\xe6\x51\xc3\x08\x42\x17\x62\x80\xf9\x60\x83\xd5\x02\xfa\x48\x07\xc8\x51\x80\xa7\x83\x7c\x64\x9f\xdd\xf3\x73\xff\xd0\xfb\x68\xde\xcf\x81\x01\x26\x31\x28\xab\xd9\x3f\x7e\xfc\xee\xdb\xc4\x90\xe6\xb2\xe6\xab\xed\xec\xce\x6a\xb1\x80\xa7\xb3\xe8\x6f\x7e\x3c\x98\xff\x72\xf1\x5b\xb2\x66\xc2\xe2\xb9\x37\x60\xe1\x7f\xef\x89\x39\x87\xfe\x71\x01\x87\x12\x77\xf3\xf9\xf5\xc3\x2d\xdb\xa4\xc3\xd4\x68\x90\x66\x8e\x70\x8c\xe4\xee\xfa\xd0\x49\x0c\x5a\xa4\x46\xf9\xbb\xa8\xb1\x54\x52\x62\x49\x60\x3b\x25\x7b\x9f\x80\x50\xc6\x0c\x8e\xd9\x53\x4c\x7c\x33\x18\xcf\x57\x30\x1b\xc2\xf5\x29\x3c\x83\x3c\x87\x8b\xe1\xac\xf7\x0c\xe4\x20\x71\x03\xff\xc2\xe2\x47\x55\xde\x20\xcd\xa2\x8d\x71\x69\x21\x82\x33\x10\xaa\x64\x0e\x2f\x69\x94\x21\x38\x83\x28\x65\x1d\x8f\xe6\x61\x9a\xde\x81\x6b\x91\xff\x1c\xec\x83\xb0\xc2\xf7\x86\xa0\xe9\xd9\x59\xb8\x36\x43\xe8\x94\x6c\xd1\x18\x56\xe3\xd4\x42\x9f\xe5\x47\x53\x9c\x23\x5a\x53\x43\x0e\x3e\xc4\x1d\xd3\x06\x03\x49\xe2\x3a\x8b\x5e\x8a\x77\x87\x27\xcb\x73\x90\x56\x88\x91\xff\x44\xa3\x7b\x99\x7b\xb2\xdd\x93\x03\xf2\x24\x24\xe1\x4f\xf2\x1c\x5c\x99\x75\x31\xaa\xf6\x9c\xee\xfa\x84\x86\x60\x9e\xb8\x4a\xbf\xe7\x98\x8f\x70\xf7\xd0\xb0\xfa\x33\x38\xac\x8e\xf1\xb0\x7a\x04\xd0\xf7\x5f\xef\xc3\x0b\xfd\xda\x04\xce\x6f\x3c\x82\x26\x6d\x5b\xa0\x7e\x1f\x5c\xe8\xbf\x7a\x38\xef\xea\x6f\x24\x4d\x78\xcf\xe1\xf2\xc5\xfc\x11\x74\xd4\x5a\x3d\x0a\x2e\x15\x6d\x67\x77\x82\x6d\x5d\xd5\x81\x53\x52\xdd\x2b\xdf\x2e\x9d\x9e\x83\x93\xb5\x80\x11\xe1\xdc\x0f\xc2\x0b\x38\xf5\xab\xd3\xdd\x23\xd2\x8c\x2d\x4b\x57\x8f\x3e\x46\x5e\x8f\x31\x4a\xec\xd7\x8f\xca\x1c\xeb\xcb\x81\x50\xf8\xec\x33\xb8\x77\x7a\x78\x05\xdd\x1d\xee\x0b\x25\xe4\x10\x45\x3d\xfc\xc9\x4a\x69\x98\xb9\x43\x9e\x5f\x5c\x03\xcf\xa6\x30\x89\x40\x59\x53\x73\x0d\xfc\xec\x6c\x8f\x74\x32\xc0\x9c\xe5\x10\xb9\x89\x20\xa3\x6a\xe9\x3b\xb3\xd0\xbe\xfd\x1a\xb9\x09\xb0\xd6\xca\xca\x6a\xe1\x52\xee\xec\x74\xdf\x0c\x4c\xfa\x80\xb3\x03\x95\x7f\xe1\xbf\x25\xd6\xa0\xf6\x95\xfb\x0c\xa2\xa4\x93\xf5\x97\x7e\x6e\x7c\xf1\xfc\x74\x7e\x0d\x7b\x4c\x3f\x4d\x2e\xa0\x74\xb3\xd5\x35\x84\xf9\xc4\x77\x89\x30\x4e\x56\x7e\x55\x28\x5d\xa1\x8e\x35\xab\xb8\x35\x0b\x78\xde\xdd\x5e\xff\x3a\x4c\x9e\xbe\x97\xf5\x7a\x77\x1a\x97\x0f\xe9\x32\xb4\x4b\x67\x10\x65\xa9\x23\x1a\x58\x46\x2b\xa7\x5f\x0d\xe1\x81\x2e\x1c\xc6\x6f\x7a\xfd\x7e\xcb\xab\x4a\xa0\x53\xc2\x0b\x0c\x1f\x5f\x2b\xab\x7d\xe2\x9a\x85\xf5\xec\x58\x0f\xe2\x2d\xce\x13\x2b\xf9\xed\x6c\x1e\xf7\x34\xc3\xfa\x1c\x4e\x8d\xcb\xcf\x95\x39\x9d\x27\x8d\x6d\x99\xe4\x7f\xe0\xcc\xb5\xf4\xf3\xa0\xb7\xd3\xd8\xf5\xe9\x63\xb4\x77\x93\x17\x6d\x9c\x31\xe7\x49\x43\xad\x98\x45\x19\xf9\x2f\x93\x4e\xb9\x31\xc4\x1e\x25\x6c\x1f\xde\xc8\xdd\x61\x0e\x2d\x85\x32\x78\x54\x23\xc0\x20\xbd\xe5\x2d\x2a\x4b\xb3\xb1\x8e\x9c\xbb\xb9\xf7\x62\x7e\x0d\xbb\xfd\x07\xdc\x34\x85\xd7\xc6\x4d\x12\xdc\x34\xc0\x60\x83\x85\xf1\xf9\x1d\x7a\x1e\x5f\xce\x43\xd9\x7e\xf9\xfd\x37\x93\xd2\x3d\xa2\xce\xbc\x72\xe3\x07\xec\x87\xea\xe4\x83\x5f\xcc\x37\x9b\x4d\x52\x2b\x55\x8b\xf0\xad\x7c\x2c\xa4\xae\x7a\x24\xef\xdc\xb8\x6a\xb6\xb2\x84\x0a\x57\xa8\x97\x13\xf8\xbe\xba\x66\x69\xf8\x96\x9b\xa5\xe1\xef\x54\xff\x0d\x00\x00\xff\xff\x71\x50\x77\xf3\xb8\x1a\x00\x00") func faucetHtmlBytes() ([]byte, error) { return bindataRead( diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/accountcmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/accountcmd.go index edeb4f3c6..6fc420199 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/accountcmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/accountcmd.go @@ -40,32 +40,39 @@ var ( will prompt for your password and imports your ether presale account. It can be used non-interactively with the --password option taking a -passwordfile as argument containing the wallet password in plaintext. - -`, +passwordfile as argument containing the wallet password in plaintext.`, Subcommands: []cli.Command{ { - Action: importWallet, + Name: "import", Usage: "Import Ethereum presale wallet", ArgsUsage: "", + Action: utils.MigrateFlags(importWallet), + Category: "ACCOUNT COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.PasswordFileFlag, + utils.LightKDFFlag, + }, Description: ` -TODO: Please write this -`, + geth wallet [options] /path/to/my/presale.wallet + +will prompt for your password and imports your ether presale account. +It can be used non-interactively with the --password option taking a +passwordfile as argument containing the wallet password in plaintext.`, }, }, } - accountCommand = cli.Command{ - Action: accountList, - Name: "account", - Usage: "Manage accounts", - ArgsUsage: "", - Category: "ACCOUNT COMMANDS", - Description: ` -Manage accounts lets you create new accounts, list all existing accounts, -import a private key into a new account. -' help' shows a list of subcommands or help for one subcommand. + accountCommand = cli.Command{ + Name: "account", + Usage: "Manage accounts", + Category: "ACCOUNT COMMANDS", + Description: ` + +Manage accounts, list all existing accounts, import a private key into a new +account, create a new account or update an existing account. It supports interactive mode, when you are prompted for password as well as non-interactive mode where passwords are supplied via a given password file. @@ -80,36 +87,34 @@ Note that exporting your key in unencrypted format is NOT supported. Keys are stored under /keystore. It is safe to transfer the entire directory or the individual keys therein between ethereum nodes by simply copying. -Make sure you backup your keys regularly. -In order to use your account to send transactions, you need to unlock them using -the '--unlock' option. The argument is a space separated list of addresses or -indexes. If used non-interactively with a passwordfile, the file should contain -the respective passwords one per line. If you unlock n accounts and the password -file contains less than n entries, then the last password is meant to apply to -all remaining accounts. - -And finally. DO NOT FORGET YOUR PASSWORD. -`, +Make sure you backup your keys regularly.`, Subcommands: []cli.Command{ { - Action: accountList, - Name: "list", - Usage: "Print account addresses", - ArgsUsage: " ", + Name: "list", + Usage: "Print summary of existing accounts", + Action: utils.MigrateFlags(accountList), + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + }, Description: ` -TODO: Please write this -`, +Print a short summary of all accounts`, }, { - Action: accountCreate, - Name: "new", - Usage: "Create a new account", - ArgsUsage: " ", + Name: "new", + Usage: "Create a new account", + Action: utils.MigrateFlags(accountCreate), + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.PasswordFileFlag, + utils.LightKDFFlag, + }, Description: ` geth account new -Creates a new account. Prints the address. +Creates a new account and prints the address. The account is saved in encrypted format, you are prompted for a passphrase. @@ -117,17 +122,20 @@ You must remember this passphrase to unlock your account in the future. For non-interactive use the passphrase can be specified with the --password flag: - geth --password account new - Note, this is meant to be used for testing only, it is a bad idea to save your password to file or expose in any other way. `, }, { - Action: accountUpdate, Name: "update", Usage: "Update an existing account", + Action: utils.MigrateFlags(accountUpdate), ArgsUsage: "
", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.LightKDFFlag, + }, Description: ` geth account update
@@ -141,16 +149,22 @@ format to the newest format or change the password for an account. For non-interactive use the passphrase can be specified with the --password flag: - geth --password account update
+ geth account update [options]
Since only one password can be given, only format update can be performed, changing your password is only possible interactively. `, }, { - Action: accountImport, - Name: "import", - Usage: "Import a private key into a new account", + Name: "import", + Usage: "Import a private key into a new account", + Action: utils.MigrateFlags(accountImport), + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.PasswordFileFlag, + utils.LightKDFFlag, + }, ArgsUsage: "", Description: ` geth account import @@ -166,7 +180,7 @@ You must remember this passphrase to unlock your account in the future. For non-interactive use the passphrase can be specified with the -password flag: - geth --password account import + geth account import [options] Note: As you can directly copy your encrypted accounts to another ethereum instance, @@ -219,7 +233,7 @@ func unlockAccount(ctx *cli.Context, ks *keystore.KeyStore, address string, i in return accounts.Account{}, "" } -// getPassPhrase retrieves the passwor associated with an account, either fetched +// getPassPhrase retrieves the password associated with an account, either fetched // from a list of preloaded passphrases, or requested interactively from the user. func getPassPhrase(prompt string, confirmation bool, i int, passwords []string) string { // If a list of passwords was supplied, retrieve from them @@ -316,10 +330,12 @@ func accountUpdate(ctx *cli.Context) error { stack, _ := makeConfigNode(ctx) ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) - account, oldPassword := unlockAccount(ctx, ks, ctx.Args().First(), 0, nil) - newPassword := getPassPhrase("Please give a new password. Do not forget this password.", true, 0, nil) - if err := ks.Update(account, oldPassword, newPassword); err != nil { - utils.Fatalf("Could not update the account: %v", err) + for _, addr := range ctx.Args() { + account, oldPassword := unlockAccount(ctx, ks, addr, 0, nil) + newPassword := getPassPhrase("Please give a new password. Do not forget this password.", true, 0, nil) + if err := ks.Update(account, oldPassword, newPassword); err != nil { + utils.Fatalf("Could not update the account: %v", err) + } } return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/bugcmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/bugcmd.go index f21880501..ce9dbe6c0 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/bugcmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/bugcmd.go @@ -29,11 +29,12 @@ import ( "github.com/ethereum/go-ethereum/cmd/internal/browser" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/cmd/utils" cli "gopkg.in/urfave/cli.v1" ) var bugCommand = cli.Command{ - Action: reportBug, + Action: utils.MigrateFlags(reportBug), Name: "bug", Usage: "opens a window to report a bug on the geth repo", ArgsUsage: " ", diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/chaincmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/chaincmd.go index 66516b409..12bc1d7c6 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/chaincmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/chaincmd.go @@ -40,80 +40,98 @@ import ( var ( initCommand = cli.Command{ - Action: initGenesis, + Action: utils.MigrateFlags(initGenesis), Name: "init", Usage: "Bootstrap and initialize a new genesis block", ArgsUsage: "", - Category: "BLOCKCHAIN COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", Description: ` The init command initializes a new genesis block and definition for the network. This is a destructive action and changes the network in which you will be participating. -`, + +It expects the genesis file as argument.`, } importCommand = cli.Command{ - Action: importChain, + Action: utils.MigrateFlags(importChain), Name: "import", Usage: "Import a blockchain file", ArgsUsage: " ( ... ) ", - Category: "BLOCKCHAIN COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.CacheFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", Description: ` -The import command imports blocks from an RLP-encoded form. The form can be one file -with several RLP-encoded blocks, or several files can be used. +The import command imports blocks from an RLP-encoded form. The form can be one file +with several RLP-encoded blocks, or several files can be used. + If only one file is used, import error will result in failure. If several files are used, -processing will proceed even if an individual RLP-file import failure occurs. -`, +processing will proceed even if an individual RLP-file import failure occurs.`, } exportCommand = cli.Command{ - Action: exportChain, + Action: utils.MigrateFlags(exportChain), Name: "export", Usage: "Export blockchain into file", ArgsUsage: " [ ]", - Category: "BLOCKCHAIN COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.CacheFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", Description: ` Requires a first argument of the file to write to. Optional second and third arguments control the first and last block to write. In this mode, the file will be appended -if already existing. -`, +if already existing.`, } removedbCommand = cli.Command{ - Action: removeDB, + Action: utils.MigrateFlags(removeDB), Name: "removedb", Usage: "Remove blockchain and state databases", ArgsUsage: " ", - Category: "BLOCKCHAIN COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", Description: ` -TODO: Please write this -`, +Remove blockchain and state databases`, } dumpCommand = cli.Command{ - Action: dump, + Action: utils.MigrateFlags(dump), Name: "dump", Usage: "Dump a specific block from storage", ArgsUsage: "[ | ]...", - Category: "BLOCKCHAIN COMMANDS", + Flags: []cli.Flag{ + utils.DataDirFlag, + utils.CacheFlag, + utils.LightModeFlag, + }, + Category: "BLOCKCHAIN COMMANDS", Description: ` The arguments are interpreted as block numbers or hashes. -Use "ethereum dump 0" to dump the genesis block. -`, +Use "ethereum dump 0" to dump the genesis block.`, } ) // initGenesis will initialise the given JSON format genesis file and writes it as // the zero'd block (i.e. genesis) or will fail hard if it can't succeed. func initGenesis(ctx *cli.Context) error { + // Make sure we have a valid genesis JSON genesisPath := ctx.Args().First() if len(genesisPath) == 0 { - utils.Fatalf("must supply path to genesis JSON file") + utils.Fatalf("Must supply path to genesis JSON file") } - - stack := makeFullNode(ctx) - chaindb := utils.MakeChainDatabase(ctx, stack) - file, err := os.Open(genesisPath) if err != nil { - utils.Fatalf("failed to read genesis file: %v", err) + utils.Fatalf("Failed to read genesis file: %v", err) } defer file.Close() @@ -121,12 +139,19 @@ func initGenesis(ctx *cli.Context) error { if err := json.NewDecoder(file).Decode(genesis); err != nil { utils.Fatalf("invalid genesis file: %v", err) } - - _, hash, err := core.SetupGenesisBlock(chaindb, genesis) - if err != nil { - utils.Fatalf("failed to write genesis block: %v", err) + // Open an initialise both full and light databases + stack := makeFullNode(ctx) + for _, name := range []string{"chaindata", "lightchaindata"} { + chaindb, err := stack.OpenDatabase(name, 0, 0) + if err != nil { + utils.Fatalf("Failed to open database: %v", err) + } + _, hash, err := core.SetupGenesisBlock(chaindb, genesis) + if err != nil { + utils.Fatalf("Failed to write genesis block: %v", err) + } + log.Info("Successfully wrote genesis state", "database", name, "hash", hash) } - log.Info("Successfully wrote genesis state", "hash", hash) return nil } @@ -245,24 +270,29 @@ func exportChain(ctx *cli.Context) error { func removeDB(ctx *cli.Context) error { stack, _ := makeConfigNode(ctx) - dbdir := stack.ResolvePath(utils.ChainDbName(ctx)) - if !common.FileExist(dbdir) { - fmt.Println(dbdir, "does not exist") - return nil - } - fmt.Println(dbdir) - confirm, err := console.Stdin.PromptConfirm("Remove this database?") - switch { - case err != nil: - utils.Fatalf("%v", err) - case !confirm: - fmt.Println("Operation aborted") - default: - fmt.Println("Removing...") - start := time.Now() - os.RemoveAll(dbdir) - fmt.Printf("Removed in %v\n", time.Since(start)) + for _, name := range []string{"chaindata", "lightchaindata"} { + // Ensure the database exists in the first place + logger := log.New("database", name) + + dbdir := stack.ResolvePath(name) + if !common.FileExist(dbdir) { + logger.Info("Database doesn't exist, skipping", "path", dbdir) + continue + } + // Confirm removal and execute + fmt.Println(dbdir) + confirm, err := console.Stdin.PromptConfirm("Remove this database?") + switch { + case err != nil: + utils.Fatalf("%v", err) + case !confirm: + logger.Warn("Database deletion aborted") + default: + start := time.Now() + os.RemoveAll(dbdir) + logger.Info("Database successfully deleted", "elapsed", common.PrettyDuration(time.Since(start))) + } } return nil } @@ -282,7 +312,7 @@ func dump(ctx *cli.Context) error { fmt.Println("{}") utils.Fatalf("block not found") } else { - state, err := state.New(block.Root(), chainDb) + state, err := state.New(block.Root(), state.NewDatabase(chainDb)) if err != nil { utils.Fatalf("could not create new state: %v", err) } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/config.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/config.go index 8d47159b2..d3600f141 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/config.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/config.go @@ -33,15 +33,17 @@ import ( "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/params" + whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" "github.com/naoina/toml" ) var ( dumpConfigCommand = cli.Command{ - Action: dumpConfig, + Action: utils.MigrateFlags(dumpConfig), Name: "dumpconfig", Usage: "Show configuration values", ArgsUsage: "", + Flags: append(append(nodeFlags, rpcFlags...), whisperFlags...), Category: "MISCELLANEOUS COMMANDS", Description: `The dumpconfig command shows configuration values.`, } @@ -75,6 +77,7 @@ type ethstatsConfig struct { type gethConfig struct { Eth eth.Config + Shh whisper.Config Node node.Config Ethstats ethstatsConfig } @@ -98,8 +101,8 @@ func defaultNodeConfig() node.Config { cfg := node.DefaultConfig cfg.Name = clientIdentifier cfg.Version = params.VersionWithCommit(gitCommit) - cfg.HTTPModules = append(cfg.HTTPModules, "eth") - cfg.WSModules = append(cfg.WSModules, "eth") + cfg.HTTPModules = append(cfg.HTTPModules, "eth", "shh") + cfg.WSModules = append(cfg.WSModules, "eth", "shh") cfg.IPCPath = "geth.ipc" return cfg } @@ -108,6 +111,7 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) { // Load defaults. cfg := gethConfig{ Eth: eth.DefaultConfig, + Shh: whisper.DefaultConfig, Node: defaultNodeConfig(), } @@ -129,19 +133,37 @@ func makeConfigNode(ctx *cli.Context) (*node.Node, gethConfig) { cfg.Ethstats.URL = ctx.GlobalString(utils.EthStatsURLFlag.Name) } + utils.SetShhConfig(ctx, stack, &cfg.Shh) + return stack, cfg } +// enableWhisper returns true in case one of the whisper flags is set. +func enableWhisper(ctx *cli.Context) bool { + for _, flag := range whisperFlags { + if ctx.GlobalIsSet(flag.GetName()) { + return true + } + } + return false +} + func makeFullNode(ctx *cli.Context) *node.Node { stack, cfg := makeConfigNode(ctx) utils.RegisterEthService(stack, &cfg.Eth) - // Whisper must be explicitly enabled, but is auto-enabled in --dev mode. - shhEnabled := ctx.GlobalBool(utils.WhisperEnabledFlag.Name) + // Whisper must be explicitly enabled by specifying at least 1 whisper flag or in dev mode + shhEnabled := enableWhisper(ctx) shhAutoEnabled := !ctx.GlobalIsSet(utils.WhisperEnabledFlag.Name) && ctx.GlobalIsSet(utils.DevModeFlag.Name) if shhEnabled || shhAutoEnabled { - utils.RegisterShhService(stack) + if ctx.GlobalIsSet(utils.WhisperMaxMessageSizeFlag.Name) { + cfg.Shh.MaxMessageSize = uint32(ctx.Int(utils.WhisperMaxMessageSizeFlag.Name)) + } + if ctx.GlobalIsSet(utils.WhisperMinPOWFlag.Name) { + cfg.Shh.MinimumAcceptedPOW = ctx.Float64(utils.WhisperMinPOWFlag.Name) + } + utils.RegisterShhService(stack, &cfg.Shh) } // Add the Ethereum Stats daemon if requested. diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/consolecmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/consolecmd.go index b1c435e00..2bb452d73 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/consolecmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/consolecmd.go @@ -29,41 +29,44 @@ import ( ) var ( + consoleFlags = []cli.Flag{utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag} + consoleCommand = cli.Command{ - Action: localConsole, - Name: "console", - Usage: "Start an interactive JavaScript environment", - ArgsUsage: "", // TODO: Write this! - Category: "CONSOLE COMMANDS", + Action: utils.MigrateFlags(localConsole), + Name: "console", + Usage: "Start an interactive JavaScript environment", + Flags: append(append(append(nodeFlags, rpcFlags...), consoleFlags...), whisperFlags...), + Category: "CONSOLE COMMANDS", Description: ` The Geth console is an interactive shell for the JavaScript runtime environment which exposes a node admin interface as well as the Ðapp JavaScript API. -See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console -`, +See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console.`, } + attachCommand = cli.Command{ - Action: remoteConsole, + Action: utils.MigrateFlags(remoteConsole), Name: "attach", Usage: "Start an interactive JavaScript environment (connect to node)", - ArgsUsage: "", // TODO: Write this! + ArgsUsage: "[endpoint]", + Flags: append(consoleFlags, utils.DataDirFlag), Category: "CONSOLE COMMANDS", Description: ` The Geth console is an interactive shell for the JavaScript runtime environment which exposes a node admin interface as well as the Ðapp JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console. -This command allows to open a console on a running geth node. -`, +This command allows to open a console on a running geth node.`, } + javascriptCommand = cli.Command{ - Action: ephemeralConsole, + Action: utils.MigrateFlags(ephemeralConsole), Name: "js", Usage: "Execute the specified JavaScript files", - ArgsUsage: "", // TODO: Write this! + ArgsUsage: " [jsfile...]", + Flags: append(nodeFlags, consoleFlags...), Category: "CONSOLE COMMANDS", Description: ` The JavaScript VM exposes a node admin interface as well as the Ðapp -JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console -`, +JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Console`, } ) @@ -81,11 +84,12 @@ func localConsole(ctx *cli.Context) error { utils.Fatalf("Failed to attach to the inproc geth: %v", err) } config := console.Config{ - DataDir: node.DataDir(), + DataDir: utils.MakeDataDir(ctx), DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), Client: client, Preload: utils.MakeConsolePreloads(ctx), } + console, err := console.New(config) if err != nil { utils.Fatalf("Failed to start the JavaScript console: %v", err) @@ -118,17 +122,18 @@ func remoteConsole(ctx *cli.Context) error { Client: client, Preload: utils.MakeConsolePreloads(ctx), } + console, err := console.New(config) if err != nil { utils.Fatalf("Failed to start the JavaScript console: %v", err) } defer console.Stop(false) - // If only a short execution was requested, evaluate and return if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" { console.Evaluate(script) return nil } + // Otherwise print the welcome screen and enter interactive mode console.Welcome() console.Interactive() @@ -151,7 +156,7 @@ func dialRPC(endpoint string) (*rpc.Client, error) { } // ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript -// console to it, and each of the files specified as arguments and tears the +// console to it, executes each of the files specified as arguments and tears // everything down. func ephemeralConsole(ctx *cli.Context) error { // Create and start the node based on the CLI flags @@ -165,11 +170,12 @@ func ephemeralConsole(ctx *cli.Context) error { utils.Fatalf("Failed to attach to the inproc geth: %v", err) } config := console.Config{ - DataDir: node.DataDir(), + DataDir: utils.MakeDataDir(ctx), DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), Client: client, Preload: utils.MakeConsolePreloads(ctx), } + console, err := console.New(config) if err != nil { utils.Fatalf("Failed to start the JavaScript console: %v", err) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/main.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/main.go index ad7b639a3..607414bbb 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/main.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/main.go @@ -49,6 +49,88 @@ var ( relOracle = common.HexToAddress("0xfa7b9770ca4cb04296cac84f37736d4041251cdf") // The app that holds all commands and flags. app = utils.NewApp(gitCommit, "the go-ethereum command line interface") + // flags that configure the node + nodeFlags = []cli.Flag{ + utils.IdentityFlag, + utils.UnlockedAccountFlag, + utils.PasswordFileFlag, + utils.BootnodesFlag, + utils.BootnodesV4Flag, + utils.BootnodesV5Flag, + utils.DataDirFlag, + utils.KeyStoreDirFlag, + utils.NoUSBFlag, + utils.EthashCacheDirFlag, + utils.EthashCachesInMemoryFlag, + utils.EthashCachesOnDiskFlag, + utils.EthashDatasetDirFlag, + utils.EthashDatasetsInMemoryFlag, + utils.EthashDatasetsOnDiskFlag, + utils.TxPoolNoLocalsFlag, + utils.TxPoolPriceLimitFlag, + utils.TxPoolPriceBumpFlag, + utils.TxPoolAccountSlotsFlag, + utils.TxPoolGlobalSlotsFlag, + utils.TxPoolAccountQueueFlag, + utils.TxPoolGlobalQueueFlag, + utils.TxPoolLifetimeFlag, + utils.FastSyncFlag, + utils.LightModeFlag, + utils.SyncModeFlag, + utils.LightServFlag, + utils.LightPeersFlag, + utils.LightKDFFlag, + utils.CacheFlag, + utils.TrieCacheGenFlag, + utils.ListenPortFlag, + utils.MaxPeersFlag, + utils.MaxPendingPeersFlag, + utils.EtherbaseFlag, + utils.GasPriceFlag, + utils.MinerThreadsFlag, + utils.MiningEnabledFlag, + utils.TargetGasLimitFlag, + utils.NATFlag, + utils.NoDiscoverFlag, + utils.DiscoveryV5Flag, + utils.NetrestrictFlag, + utils.NodeKeyFileFlag, + utils.NodeKeyHexFlag, + utils.DevModeFlag, + utils.TestnetFlag, + utils.RinkebyFlag, + utils.VMEnableDebugFlag, + utils.NetworkIdFlag, + utils.RPCCORSDomainFlag, + utils.EthStatsURLFlag, + utils.MetricsEnabledFlag, + utils.FakePoWFlag, + utils.NoCompactionFlag, + utils.GpoBlocksFlag, + utils.GpoPercentileFlag, + utils.ExtraDataFlag, + configFileFlag, + } + + rpcFlags = []cli.Flag{ + utils.RPCEnabledFlag, + utils.RPCListenAddrFlag, + utils.RPCPortFlag, + utils.RPCApiFlag, + utils.WSEnabledFlag, + utils.WSListenAddrFlag, + utils.WSPortFlag, + utils.WSApiFlag, + utils.WSAllowedOriginsFlag, + utils.IPCDisabledFlag, + utils.IPCPathFlag, + } + + whisperFlags = []cli.Flag{ + utils.WhisperEnabledFlag, + utils.WhisperMaxMessageSizeFlag, + utils.WhisperMinPOWFlag, + } ) func init() { @@ -81,72 +163,11 @@ func init() { dumpConfigCommand, } - app.Flags = []cli.Flag{ - utils.IdentityFlag, - utils.UnlockedAccountFlag, - utils.PasswordFileFlag, - utils.BootnodesFlag, - utils.DataDirFlag, - utils.KeyStoreDirFlag, - utils.NoUSBFlag, - utils.EthashCacheDirFlag, - utils.EthashCachesInMemoryFlag, - utils.EthashCachesOnDiskFlag, - utils.EthashDatasetDirFlag, - utils.EthashDatasetsInMemoryFlag, - utils.EthashDatasetsOnDiskFlag, - utils.FastSyncFlag, - utils.LightModeFlag, - utils.SyncModeFlag, - utils.LightServFlag, - utils.LightPeersFlag, - utils.LightKDFFlag, - utils.CacheFlag, - utils.TrieCacheGenFlag, - utils.JSpathFlag, - utils.ListenPortFlag, - utils.MaxPeersFlag, - utils.MaxPendingPeersFlag, - utils.EtherbaseFlag, - utils.GasPriceFlag, - utils.MinerThreadsFlag, - utils.MiningEnabledFlag, - utils.TargetGasLimitFlag, - utils.NATFlag, - utils.NoDiscoverFlag, - utils.DiscoveryV5Flag, - utils.NetrestrictFlag, - utils.NodeKeyFileFlag, - utils.NodeKeyHexFlag, - utils.RPCEnabledFlag, - utils.RPCListenAddrFlag, - utils.RPCPortFlag, - utils.RPCApiFlag, - utils.WSEnabledFlag, - utils.WSListenAddrFlag, - utils.WSPortFlag, - utils.WSApiFlag, - utils.WSAllowedOriginsFlag, - utils.IPCDisabledFlag, - utils.IPCPathFlag, - utils.ExecFlag, - utils.PreloadJSFlag, - utils.WhisperEnabledFlag, - utils.DevModeFlag, - utils.TestNetFlag, - utils.VMEnableDebugFlag, - utils.NetworkIdFlag, - utils.RPCCORSDomainFlag, - utils.EthStatsURLFlag, - utils.MetricsEnabledFlag, - utils.FakePoWFlag, - utils.NoCompactionFlag, - utils.GpoBlocksFlag, - utils.GpoPercentileFlag, - utils.ExtraDataFlag, - configFileFlag, - } + app.Flags = append(app.Flags, nodeFlags...) + app.Flags = append(app.Flags, rpcFlags...) + app.Flags = append(app.Flags, consoleFlags...) app.Flags = append(app.Flags, debug.Flags...) + app.Flags = append(app.Flags, whisperFlags...) app.Before = func(ctx *cli.Context) error { runtime.GOMAXPROCS(runtime.NumCPU()) @@ -238,10 +259,12 @@ func startNode(ctx *cli.Context, stack *node.Node) { }() // Start auxiliary services if enabled if ctx.GlobalBool(utils.MiningEnabledFlag.Name) { + // Mining only makes sense if a full Ethereum node is running var ethereum *eth.Ethereum if err := stack.Service(ðereum); err != nil { utils.Fatalf("ethereum service not running: %v", err) } + // Use a reduced number of threads if requested if threads := ctx.GlobalInt(utils.MinerThreadsFlag.Name); threads > 0 { type threaded interface { SetThreads(threads int) @@ -250,6 +273,8 @@ func startNode(ctx *cli.Context, stack *node.Node) { th.SetThreads(threads) } } + // Set the gas price to the limits from the CLI and start mining + ethereum.TxPool().SetGasPrice(utils.GlobalBig(ctx, utils.GasPriceFlag.Name)) if err := ethereum.StartMining(true); err != nil { utils.Fatalf("Failed to start mining: %v", err) } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/misccmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/misccmd.go index cb7dc1673..62b93d65a 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/misccmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/misccmd.go @@ -34,7 +34,7 @@ import ( var ( makedagCommand = cli.Command{ - Action: makedag, + Action: utils.MigrateFlags(makedag), Name: "makedag", Usage: "Generate ethash DAG (for testing)", ArgsUsage: " ", @@ -47,7 +47,7 @@ Regular users do not need to execute it. `, } versionCommand = cli.Command{ - Action: version, + Action: utils.MigrateFlags(version), Name: "version", Usage: "Print version numbers", ArgsUsage: " ", @@ -57,7 +57,7 @@ The output of this command is supposed to be machine-readable. `, } licenseCommand = cli.Command{ - Action: license, + Action: utils.MigrateFlags(license), Name: "license", Usage: "Display license information", ArgsUsage: " ", @@ -103,7 +103,7 @@ func version(ctx *cli.Context) error { } fmt.Println("Architecture:", runtime.GOARCH) fmt.Println("Protocol Versions:", eth.ProtocolVersions) - fmt.Println("Network Id:", ctx.GlobalInt(utils.NetworkIdFlag.Name)) + fmt.Println("Network Id:", eth.DefaultConfig.NetworkId) fmt.Println("Go Version:", runtime.Version()) fmt.Println("Operating System:", runtime.GOOS) fmt.Printf("GOPATH=%s\n", os.Getenv("GOPATH")) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/monitorcmd.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/monitorcmd.go index c63542f13..cd19caa27 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/monitorcmd.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/monitorcmd.go @@ -49,7 +49,7 @@ var ( Usage: "Refresh interval in seconds", } monitorCommand = cli.Command{ - Action: monitor, + Action: utils.MigrateFlags(monitor), // keep track of migration progress Name: "monitor", Usage: "Monitor and visualize node metrics", ArgsUsage: " ", diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/empty.js b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/empty.js new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/empty.js @@ -0,0 +1 @@ + diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/guswallet.json b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/guswallet.json new file mode 100644 index 000000000..e8ea4f332 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/guswallet.json @@ -0,0 +1,6 @@ +{ + "encseed": "26d87f5f2bf9835f9a47eefae571bc09f9107bb13d54ff12a4ec095d01f83897494cf34f7bed2ed34126ecba9db7b62de56c9d7cd136520a0427bfb11b8954ba7ac39b90d4650d3448e31185affcd74226a68f1e94b1108e6e0a4a91cdd83eba", + "ethaddr": "d4584b5f6229b7be90727b0fc8c6b91bb427821f", + "email": "gustav.simonsson@gmail.com", + "btcaddr": "1EVknXyFC68kKNLkh6YnKzW41svSRoaAcx" +} diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/passwords.txt b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/passwords.txt new file mode 100644 index 000000000..96f98c7f4 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/passwords.txt @@ -0,0 +1,3 @@ +foobar +foobar +foobar diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/wrong-passwords.txt b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/wrong-passwords.txt new file mode 100644 index 000000000..7d1e338bb --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/testdata/wrong-passwords.txt @@ -0,0 +1,3 @@ +wrong +wrong +wrong diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/geth/usage.go b/vendor/github.com/ethereum/go-ethereum/cmd/geth/usage.go index 9f06a308b..275aad674 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/geth/usage.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/geth/usage.go @@ -20,6 +20,7 @@ package main import ( "io" + "sort" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/internal/debug" @@ -69,7 +70,8 @@ var AppHelpFlagGroups = []flagGroup{ utils.KeyStoreDirFlag, utils.NoUSBFlag, utils.NetworkIdFlag, - utils.TestNetFlag, + utils.TestnetFlag, + utils.RinkebyFlag, utils.DevModeFlag, utils.SyncModeFlag, utils.EthStatsURLFlag, @@ -90,6 +92,19 @@ var AppHelpFlagGroups = []flagGroup{ utils.EthashDatasetsOnDiskFlag, }, }, + { + Name: "TRANSACTION POOL", + Flags: []cli.Flag{ + utils.TxPoolNoLocalsFlag, + utils.TxPoolPriceLimitFlag, + utils.TxPoolPriceBumpFlag, + utils.TxPoolAccountSlotsFlag, + utils.TxPoolGlobalSlotsFlag, + utils.TxPoolAccountQueueFlag, + utils.TxPoolGlobalQueueFlag, + utils.TxPoolLifetimeFlag, + }, + }, { Name: "PERFORMANCE TUNING", Flags: []cli.Flag{ @@ -128,6 +143,8 @@ var AppHelpFlagGroups = []flagGroup{ Name: "NETWORKING", Flags: []cli.Flag{ utils.BootnodesFlag, + utils.BootnodesV4Flag, + utils.BootnodesV5Flag, utils.ListenPortFlag, utils.MaxPeersFlag, utils.MaxPendingPeersFlag, @@ -171,6 +188,10 @@ var AppHelpFlagGroups = []flagGroup{ utils.NoCompactionFlag, }, debug.Flags...), }, + { + Name: "WHISPER (EXPERIMENTAL)", + Flags: whisperFlags, + }, { Name: "DEPRECATED", Flags: []cli.Flag{ @@ -179,13 +200,43 @@ var AppHelpFlagGroups = []flagGroup{ }, }, { - Name: "EXPERIMENTAL", - Flags: []cli.Flag{ - utils.WhisperEnabledFlag, - }, + Name: "MISC", }, } +// byCategory sorts an array of flagGroup by Name in the order +// defined in AppHelpFlagGroups. +type byCategory []flagGroup + +func (a byCategory) Len() int { return len(a) } +func (a byCategory) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a byCategory) Less(i, j int) bool { + iCat, jCat := a[i].Name, a[j].Name + iIdx, jIdx := len(AppHelpFlagGroups), len(AppHelpFlagGroups) // ensure non categorized flags come last + + for i, group := range AppHelpFlagGroups { + if iCat == group.Name { + iIdx = i + } + if jCat == group.Name { + jIdx = i + } + } + + return iIdx < jIdx +} + +func flagCategory(flag cli.Flag) string { + for _, category := range AppHelpFlagGroups { + for _, flg := range category.Flags { + if flg.GetName() == flag.GetName() { + return category.Name + } + } + } + return "MISC" +} + func init() { // Override the default app help template cli.AppHelpTemplate = AppHelpTemplate @@ -195,6 +246,7 @@ func init() { App interface{} FlagGroups []flagGroup } + // Override the default app help printer, but only for the global app help originalHelpPrinter := cli.HelpPrinter cli.HelpPrinter = func(w io.Writer, tmpl string, data interface{}) { @@ -224,6 +276,27 @@ func init() { } // Render out custom usage screen originalHelpPrinter(w, tmpl, helpData{data, AppHelpFlagGroups}) + } else if tmpl == utils.CommandHelpTemplate { + // Iterate over all command specific flags and categorize them + categorized := make(map[string][]cli.Flag) + for _, flag := range data.(cli.Command).Flags { + if _, ok := categorized[flag.String()]; !ok { + categorized[flagCategory(flag)] = append(categorized[flagCategory(flag)], flag) + } + } + + // sort to get a stable ordering + sorted := make([]flagGroup, 0, len(categorized)) + for cat, flgs := range categorized { + sorted = append(sorted, flagGroup{cat, flgs}) + } + sort.Sort(byCategory(sorted)) + + // add sorted array to data and render with default printer + originalHelpPrinter(w, tmpl, map[string]interface{}{ + "cmd": data, + "categorizedFlags": sorted, + }) } else { originalHelpPrinter(w, tmpl, data) } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_faucet.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_faucet.go index fc957721d..5a5dc6506 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_faucet.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_faucet.go @@ -51,10 +51,10 @@ ADD account.pass /account.pass EXPOSE 8080 CMD [ \ - "/faucet", "--genesis", "/genesis.json", "--network", "{{.NetworkID}}", "--bootnodes", "{{.Bootnodes}}", "--ethstats", "{{.Ethstats}}", \ - "--ethport", "{{.EthPort}}", "--faucet.name", "{{.FaucetName}}", "--faucet.amount", "{{.FaucetAmount}}", "--faucet.minutes", "{{.FaucetMinutes}}", \ - "--github.user", "{{.GitHubUser}}", "--github.token", "{{.GitHubToken}}", "--account.json", "/account.json", "--account.pass", "/account.pass" \ - {{if .CaptchaToken}}, "--captcha.token", "{{.CaptchaToken}}", "--captcha.secret", "{{.CaptchaSecret}}"{{end}} \ + "/faucet", "--genesis", "/genesis.json", "--network", "{{.NetworkID}}", "--bootnodes", "{{.Bootnodes}}", "--ethstats", "{{.Ethstats}}", "--ethport", "{{.EthPort}}", \ + "--faucet.name", "{{.FaucetName}}", "--faucet.amount", "{{.FaucetAmount}}", "--faucet.minutes", "{{.FaucetMinutes}}", "--faucet.tiers", "{{.FaucetTiers}}", \ + "--github.user", "{{.GitHubUser}}", "--github.token", "{{.GitHubToken}}", "--account.json", "/account.json", "--account.pass", "/account.pass" \ + {{if .CaptchaToken}}, "--captcha.token", "{{.CaptchaToken}}", "--captcha.secret", "{{.CaptchaSecret}}"{{end}} \ ]` // faucetComposefile is the docker-compose.yml file required to deploy and maintain @@ -75,6 +75,7 @@ services: - ETH_NAME={{.EthName}} - FAUCET_AMOUNT={{.FaucetAmount}} - FAUCET_MINUTES={{.FaucetMinutes}} + - FAUCET_TIERS={{.FaucetTiers}} - GITHUB_USER={{.GitHubUser}} - GITHUB_TOKEN={{.GitHubToken}} - CAPTCHA_TOKEN={{.CaptchaToken}} @@ -105,6 +106,7 @@ func deployFaucet(client *sshClient, network string, bootnodes []string, config "FaucetName": strings.Title(network), "FaucetAmount": config.amount, "FaucetMinutes": config.minutes, + "FaucetTiers": config.tiers, }) files[filepath.Join(workdir, "Dockerfile")] = dockerfile.Bytes() @@ -122,6 +124,7 @@ func deployFaucet(client *sshClient, network string, bootnodes []string, config "CaptchaSecret": config.captchaSecret, "FaucetAmount": config.amount, "FaucetMinutes": config.minutes, + "FaucetTiers": config.tiers, }) files[filepath.Join(workdir, "docker-compose.yaml")] = composefile.Bytes() @@ -147,6 +150,7 @@ type faucetInfos struct { port int amount int minutes int + tiers int githubUser string githubToken string captchaToken string @@ -155,7 +159,7 @@ type faucetInfos struct { // String implements the stringer interface. func (info *faucetInfos) String() string { - return fmt.Sprintf("host=%s, api=%d, eth=%d, amount=%d, minutes=%d, github=%s, captcha=%v, ethstats=%s", info.host, info.port, info.node.portFull, info.amount, info.minutes, info.githubUser, info.captchaToken != "", info.node.ethstats) + return fmt.Sprintf("host=%s, api=%d, eth=%d, amount=%d, minutes=%d, tiers=%d, github=%s, captcha=%v, ethstats=%s", info.host, info.port, info.node.portFull, info.amount, info.minutes, info.tiers, info.githubUser, info.captchaToken != "", info.node.ethstats) } // checkFaucet does a health-check against an faucet server to verify whether @@ -186,6 +190,7 @@ func checkFaucet(client *sshClient, network string) (*faucetInfos, error) { } amount, _ := strconv.Atoi(infos.envvars["FAUCET_AMOUNT"]) minutes, _ := strconv.Atoi(infos.envvars["FAUCET_MINUTES"]) + tiers, _ := strconv.Atoi(infos.envvars["FAUCET_TIERS"]) // Retrieve the funding account informations var out []byte @@ -213,6 +218,7 @@ func checkFaucet(client *sshClient, network string) (*faucetInfos, error) { port: port, amount: amount, minutes: minutes, + tiers: tiers, githubUser: infos.envvars["GITHUB_USER"], githubToken: infos.envvars["GITHUB_TOKEN"], captchaToken: infos.envvars["CAPTCHA_TOKEN"], diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_node.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_node.go index 78681934d..ce1d34135 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_node.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/module_node.go @@ -40,7 +40,7 @@ ADD genesis.json /genesis.json RUN \ echo '/geth init /genesis.json' > geth.sh && \{{if .Unlock}} echo 'mkdir -p /root/.ethereum/keystore/ && cp /signer.json /root/.ethereum/keystore/' >> geth.sh && \{{end}} - echo $'/geth --networkid {{.NetworkID}} --cache 512 --port {{.Port}} --maxpeers {{.Peers}} {{.LightFlag}} --ethstats \'{{.Ethstats}}\' {{if .Bootnodes}}--bootnodes {{.Bootnodes}}{{end}} {{if .Etherbase}}--etherbase {{.Etherbase}} --mine{{end}}{{if .Unlock}}--unlock 0 --password /signer.pass --mine{{end}}' >> geth.sh + echo $'/geth --networkid {{.NetworkID}} --cache 512 --port {{.Port}} --maxpeers {{.Peers}} {{.LightFlag}} --ethstats \'{{.Ethstats}}\' {{if .BootV4}}--bootnodesv4 {{.BootV4}}{{end}} {{if .BootV5}}--bootnodesv5 {{.BootV5}}{{end}} {{if .Etherbase}}--etherbase {{.Etherbase}} --mine{{end}}{{if .Unlock}}--unlock 0 --password /signer.pass --mine{{end}} --targetgaslimit {{.GasTarget}} --gasprice {{.GasPrice}}' >> geth.sh ENTRYPOINT ["/bin/sh", "geth.sh"] ` @@ -66,17 +66,20 @@ services: - LIGHT_PEERS={{.LightPeers}} - STATS_NAME={{.Ethstats}} - MINER_NAME={{.Etherbase}} + - GAS_TARGET={{.GasTarget}} + - GAS_PRICE={{.GasPrice}} restart: always ` // deployNode deploys a new Ethereum node container to a remote machine via SSH, // docker and docker-compose. If an instance with the specified network name // already exists there, it will be overwritten! -func deployNode(client *sshClient, network string, bootnodes []string, config *nodeInfos) ([]byte, error) { +func deployNode(client *sshClient, network string, bootv4, bootv5 []string, config *nodeInfos) ([]byte, error) { kind := "sealnode" if config.keyJSON == "" && config.etherbase == "" { kind = "bootnode" - bootnodes = make([]string, 0) + bootv4 = make([]string, 0) + bootv5 = make([]string, 0) } // Generate the content to upload to the server workdir := fmt.Sprintf("%d", rand.Int63()) @@ -92,9 +95,12 @@ func deployNode(client *sshClient, network string, bootnodes []string, config *n "Port": config.portFull, "Peers": config.peersTotal, "LightFlag": lightFlag, - "Bootnodes": strings.Join(bootnodes, ","), + "BootV4": strings.Join(bootv4, ","), + "BootV5": strings.Join(bootv5, ","), "Ethstats": config.ethstats, "Etherbase": config.etherbase, + "GasTarget": uint64(1000000 * config.gasTarget), + "GasPrice": uint64(1000000000 * config.gasPrice), "Unlock": config.keyJSON != "", }) files[filepath.Join(workdir, "Dockerfile")] = dockerfile.Bytes() @@ -111,6 +117,8 @@ func deployNode(client *sshClient, network string, bootnodes []string, config *n "LightPeers": config.peersLight, "Ethstats": config.ethstats[:strings.Index(config.ethstats, ":")], "Etherbase": config.etherbase, + "GasTarget": config.gasTarget, + "GasPrice": config.gasPrice, }) files[filepath.Join(workdir, "docker-compose.yaml")] = composefile.Bytes() @@ -127,7 +135,7 @@ func deployNode(client *sshClient, network string, bootnodes []string, config *n } defer client.Run("rm -rf " + workdir) - // Build and deploy the bootnode service + // Build and deploy the boot or seal node service return nil, client.Stream(fmt.Sprintf("cd %s && docker-compose -p %s up -d --build", workdir, network)) } @@ -147,6 +155,8 @@ type nodeInfos struct { etherbase string keyJSON string keyPass string + gasTarget float64 + gasPrice float64 } // String implements the stringer interface. @@ -155,7 +165,8 @@ func (info *nodeInfos) String() string { if info.peersLight > 0 { discv5 = fmt.Sprintf(", portv5=%d", info.portLight) } - return fmt.Sprintf("port=%d%s, datadir=%s, peers=%d, lights=%d, ethstats=%s", info.portFull, discv5, info.datadir, info.peersTotal, info.peersLight, info.ethstats) + return fmt.Sprintf("port=%d%s, datadir=%s, peers=%d, lights=%d, ethstats=%s, gastarget=%0.3f MGas, gasprice=%0.3f GWei", + info.portFull, discv5, info.datadir, info.peersTotal, info.peersLight, info.ethstats, info.gasTarget, info.gasPrice) } // checkNode does a health-check against an boot or seal node server to verify @@ -176,6 +187,8 @@ func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error) // Resolve a few types from the environmental variables totalPeers, _ := strconv.Atoi(infos.envvars["TOTAL_PEERS"]) lightPeers, _ := strconv.Atoi(infos.envvars["LIGHT_PEERS"]) + gasTarget, _ := strconv.ParseFloat(infos.envvars["GAS_TARGET"], 64) + gasPrice, _ := strconv.ParseFloat(infos.envvars["GAS_PRICE"], 64) // Container available, retrieve its node ID and its genesis json var out []byte @@ -213,6 +226,8 @@ func checkNode(client *sshClient, network string, boot bool) (*nodeInfos, error) etherbase: infos.envvars["MINER_NAME"], keyJSON: keyJSON, keyPass: keyPass, + gasTarget: gasTarget, + gasPrice: gasPrice, } stats.enodeFull = fmt.Sprintf("enode://%s@%s:%d", id, client.address, stats.portFull) if stats.portLight != 0 { diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/ssh.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/ssh.go index 34fbc566d..93668945c 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/ssh.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/ssh.go @@ -17,6 +17,8 @@ package main import ( + "bufio" + "bytes" "errors" "fmt" "io/ioutil" @@ -37,18 +39,26 @@ import ( type sshClient struct { server string // Server name or IP without port number address string // IP address of the remote server + pubkey []byte // RSA public key to authenticate the server client *ssh.Client logger log.Logger } // dial establishes an SSH connection to a remote node using the current user and -// the user's configured private RSA key. -func dial(server string) (*sshClient, error) { +// the user's configured private RSA key. If that fails, password authentication +// is fallen back to. The caller may override the login user via user@server:port. +func dial(server string, pubkey []byte) (*sshClient, error) { // Figure out a label for the server and a logger label := server if strings.Contains(label, ":") { label = label[:strings.Index(label, ":")] } + login := "" + if strings.Contains(server, "@") { + login = label[:strings.Index(label, "@")] + label = label[strings.Index(label, "@")+1:] + server = server[strings.Index(server, "@")+1:] + } logger := log.New("server", label) logger.Debug("Attempting to establish SSH connection") @@ -56,6 +66,9 @@ func dial(server string) (*sshClient, error) { if err != nil { return nil, err } + if login == "" { + login = user.Username + } // Configure the supported authentication methods (private key and password) var auths []ssh.AuthMethod @@ -71,7 +84,7 @@ func dial(server string) (*sshClient, error) { } } auths = append(auths, ssh.PasswordCallback(func() (string, error) { - fmt.Printf("What's the login password for %s at %s? (won't be echoed)\n> ", user.Username, server) + fmt.Printf("What's the login password for %s at %s? (won't be echoed)\n> ", login, server) blob, err := terminal.ReadPassword(int(syscall.Stdin)) fmt.Println() @@ -86,11 +99,36 @@ func dial(server string) (*sshClient, error) { return nil, errors.New("no IPs associated with domain") } // Try to dial in to the remote server - logger.Trace("Dialing remote SSH server", "user", user.Username, "key", path) + logger.Trace("Dialing remote SSH server", "user", login) if !strings.Contains(server, ":") { server += ":22" } - client, err := ssh.Dial("tcp", server, &ssh.ClientConfig{User: user.Username, Auth: auths}) + keycheck := func(hostname string, remote net.Addr, key ssh.PublicKey) error { + // If no public key is known for SSH, ask the user to confirm + if pubkey == nil { + fmt.Printf("The authenticity of host '%s (%s)' can't be established.\n", hostname, remote) + fmt.Printf("SSH key fingerprint is %s [MD5]\n", ssh.FingerprintLegacyMD5(key)) + fmt.Printf("Are you sure you want to continue connecting (yes/no)? ") + + text, err := bufio.NewReader(os.Stdin).ReadString('\n') + switch { + case err != nil: + return err + case strings.TrimSpace(text) == "yes": + pubkey = key.Marshal() + return nil + default: + return fmt.Errorf("unknown auth choice: %v", text) + } + } + // If a public key exists for this SSH server, check that it matches + if bytes.Compare(pubkey, key.Marshal()) == 0 { + return nil + } + // We have a mismatch, forbid connecting + return errors.New("ssh key mismatch, readd the machine to update") + } + client, err := ssh.Dial("tcp", server, &ssh.ClientConfig{User: login, Auth: auths, HostKeyCallback: keycheck}) if err != nil { return nil, err } @@ -98,6 +136,7 @@ func dial(server string) (*sshClient, error) { c := &sshClient{ server: label, address: addr[0], + pubkey: pubkey, client: client, logger: logger, } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard.go index 92d7962a0..51e64688e 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard.go @@ -44,14 +44,24 @@ type config struct { bootLight []string // Bootnodes to always connect to by light nodes ethstats string // Ethstats settings to cache for node deploys - Servers []string `json:"servers,omitempty"` + Servers map[string][]byte `json:"servers,omitempty"` +} + +// servers retrieves an alphabetically sorted list of servers. +func (c config) servers() []string { + servers := make([]string, 0, len(c.Servers)) + for server := range c.Servers { + servers = append(servers, server) + } + sort.Strings(servers) + + return servers } // flush dumps the contents of config to disk. func (c config) flush() { os.MkdirAll(filepath.Dir(c.path), 0755) - sort.Strings(c.Servers) out, _ := json.MarshalIndent(c, "", " ") if err := ioutil.WriteFile(c.path, out, 0644); err != nil { log.Warn("Failed to save puppeth configs", "file", c.path, "err", err) @@ -152,6 +162,48 @@ func (w *wizard) readDefaultInt(def int) int { } } +// readFloat reads a single line from stdin, trimming if from spaces, enforcing it +// to parse into a float. +func (w *wizard) readFloat() float64 { + for { + fmt.Printf("> ") + text, err := w.in.ReadString('\n') + if err != nil { + log.Crit("Failed to read user input", "err", err) + } + if text = strings.TrimSpace(text); text == "" { + continue + } + val, err := strconv.ParseFloat(strings.TrimSpace(text), 64) + if err != nil { + log.Error("Invalid input, expected float", "err", err) + continue + } + return val + } +} + +// readDefaultFloat reads a single line from stdin, trimming if from spaces, enforcing +// it to parse into a float. If an empty line is entered, the default value is returned. +func (w *wizard) readDefaultFloat(def float64) float64 { + for { + fmt.Printf("> ") + text, err := w.in.ReadString('\n') + if err != nil { + log.Crit("Failed to read user input", "err", err) + } + if text = strings.TrimSpace(text); text == "" { + return def + } + val, err := strconv.ParseFloat(strings.TrimSpace(text), 64) + if err != nil { + log.Error("Invalid input, expected float", "err", err) + continue + } + return val + } +} + // readPassword reads a single line from stdin, trimming it from the trailing new // line and returns it. The input will not be echoed. func (w *wizard) readPassword() string { diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_faucet.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_faucet.go index f3fd7c2a1..51c4e2f7f 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_faucet.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_faucet.go @@ -44,6 +44,7 @@ func (w *wizard) deployFaucet() { host: client.server, amount: 1, minutes: 1440, + tiers: 3, } } infos.node.genesis, _ = json.MarshalIndent(w.conf.genesis, "", " ") @@ -68,6 +69,13 @@ func (w *wizard) deployFaucet() { fmt.Printf("How many minutes to enforce between requests? (default = %d)\n", infos.minutes) infos.minutes = w.readDefaultInt(infos.minutes) + fmt.Println() + fmt.Printf("How many funding tiers to feature (x2.5 amounts, x3 timeout)? (default = %d)\n", infos.tiers) + infos.tiers = w.readDefaultInt(infos.tiers) + if infos.tiers == 0 { + log.Error("At least one funding tier must be set") + return + } // Accessing GitHub gists requires API authorization, retrieve it if infos.githubUser != "" { fmt.Println() @@ -157,8 +165,7 @@ func (w *wizard) deployFaucet() { } // Load up the credential needed to release funds if infos.node.keyJSON != "" { - var key keystore.Key - if err := json.Unmarshal([]byte(infos.node.keyJSON), &key); err != nil { + if key, err := keystore.DecryptKey([]byte(infos.node.keyJSON), infos.node.keyPass); err != nil { infos.node.keyJSON, infos.node.keyPass = "", "" } else { fmt.Println() diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_intro.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_intro.go index 46383bb54..c3eaf5324 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_intro.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_intro.go @@ -31,7 +31,10 @@ import ( // makeWizard creates and returns a new puppeth wizard. func makeWizard(network string) *wizard { return &wizard{ - network: network, + network: network, + conf: config{ + Servers: make(map[string][]byte), + }, servers: make(map[string]*sshClient), services: make(map[string][]string), in: bufio.NewReader(os.Stdin), @@ -77,9 +80,9 @@ func (w *wizard) run() { } else if err := json.Unmarshal(blob, &w.conf); err != nil { log.Crit("Previous configuration corrupted", "path", w.conf.path, "err", err) } else { - for _, server := range w.conf.Servers { + for server, pubkey := range w.conf.Servers { log.Info("Dialing previously configured server", "server", server) - client, err := dial(server) + client, err := dial(server, pubkey) if err != nil { log.Error("Previous server unreachable", "server", server, "err", err) } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_netstats.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_netstats.go index c2a933a55..ab8078698 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_netstats.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_netstats.go @@ -39,16 +39,16 @@ func (w *wizard) networkStats(tips bool) { // Iterate over all the specified hosts and check their status stats := tablewriter.NewWriter(os.Stdout) stats.SetHeader([]string{"Server", "IP", "Status", "Service", "Details"}) - stats.SetColWidth(128) + stats.SetColWidth(100) - for _, server := range w.conf.Servers { + for server, pubkey := range w.conf.Servers { client := w.servers[server] logger := log.New("server", server) logger.Info("Starting remote server health-check") // If the server is not connected, try to connect again if client == nil { - conn, err := dial(server) + conn, err := dial(server, pubkey) if err != nil { logger.Error("Failed to establish remote connection", "err", err) stats.Append([]string{server, "", err.Error(), "", ""}) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_network.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_network.go index 001d4e5b4..0455e1ef3 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_network.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_network.go @@ -28,7 +28,9 @@ import ( func (w *wizard) manageServers() { // List all the servers we can disconnect, along with an entry to connect a new one fmt.Println() - for i, server := range w.conf.Servers { + + servers := w.conf.servers() + for i, server := range servers { fmt.Printf(" %d. Disconnect %s\n", i+1, server) } fmt.Printf(" %d. Connect another server\n", len(w.conf.Servers)+1) @@ -40,14 +42,14 @@ func (w *wizard) manageServers() { } // If the user selected an existing server, drop it if choice <= len(w.conf.Servers) { - server := w.conf.Servers[choice-1] + server := servers[choice-1] client := w.servers[server] delete(w.servers, server) if client != nil { client.Close() } - w.conf.Servers = append(w.conf.Servers[:choice-1], w.conf.Servers[choice:]...) + delete(w.conf.Servers, server) w.conf.flush() log.Info("Disconnected existing server", "server", server) @@ -73,14 +75,14 @@ func (w *wizard) makeServer() string { // Read and fial the server to ensure docker is present input := w.readString() - client, err := dial(input) + client, err := dial(input, nil) if err != nil { log.Error("Server not ready for puppeth", "err", err) return "" } // All checks passed, start tracking the server w.servers[input] = client - w.conf.Servers = append(w.conf.Servers, input) + w.conf.Servers[input] = client.pubkey w.conf.flush() return input @@ -93,7 +95,9 @@ func (w *wizard) selectServer() string { // List the available server to the user and wait for a choice fmt.Println() fmt.Println("Which server do you want to interact with?") - for i, server := range w.conf.Servers { + + servers := w.conf.servers() + for i, server := range servers { fmt.Printf(" %d. %s\n", i+1, server) } fmt.Printf(" %d. Connect another server\n", len(w.conf.Servers)+1) @@ -105,7 +109,7 @@ func (w *wizard) selectServer() string { } // If the user requested connecting to a new server, go for it if choice <= len(w.conf.Servers) { - return w.conf.Servers[choice-1] + return servers[choice-1] } return w.makeServer() } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_node.go b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_node.go index d70d8f3c9..05232486b 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_node.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/puppeth/wizard_node.go @@ -50,7 +50,7 @@ func (w *wizard) deployNode(boot bool) { if boot { infos = &nodeInfos{portFull: 30303, peersTotal: 512, peersLight: 256} } else { - infos = &nodeInfos{portFull: 30303, peersTotal: 50, peersLight: 0} + infos = &nodeInfos{portFull: 30303, peersTotal: 50, peersLight: 0, gasTarget: 4.7, gasPrice: 18} } } infos.genesis, _ = json.MarshalIndent(w.conf.genesis, "", " ") @@ -109,8 +109,7 @@ func (w *wizard) deployNode(boot bool) { } else if w.conf.genesis.Config.Clique != nil { // If a previous signer was already set, offer to reuse it if infos.keyJSON != "" { - var key keystore.Key - if err := json.Unmarshal([]byte(infos.keyJSON), &key); err != nil { + if key, err := keystore.DecryptKey([]byte(infos.keyJSON), infos.keyPass); err != nil { infos.keyJSON, infos.keyPass = "", "" } else { fmt.Println() @@ -136,9 +135,17 @@ func (w *wizard) deployNode(boot bool) { } } } + // Establish the gas dynamics to be enforced by the signer + fmt.Println() + fmt.Printf("What gas limit should empty blocks target (MGas)? (default = %0.3f)\n", infos.gasTarget) + infos.gasTarget = w.readDefaultFloat(infos.gasTarget) + + fmt.Println() + fmt.Printf("What gas price should the signer require (GWei)? (default = %0.3f)\n", infos.gasPrice) + infos.gasPrice = w.readDefaultFloat(infos.gasPrice) } // Try to deploy the full node on the host - if out, err := deployNode(client, w.network, w.conf.bootFull, infos); err != nil { + if out, err := deployNode(client, w.network, w.conf.bootFull, w.conf.bootLight, infos); err != nil { log.Error("Failed to deploy Ethereum node container", "err", err) if len(out) > 0 { fmt.Printf("%s\n", out) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/swarm/main.go b/vendor/github.com/ethereum/go-ethereum/cmd/swarm/main.go index 26aa3e50f..4ae06a1c9 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/swarm/main.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/swarm/main.go @@ -17,21 +17,25 @@ package main import ( + "context" "crypto/ecdsa" "fmt" "io/ioutil" + "math/big" "os" "os/signal" "runtime" "strconv" "strings" "syscall" + "time" "github.com/ethereum/go-ethereum/accounts" "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/console" + "github.com/ethereum/go-ethereum/contracts/ens" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/internal/debug" @@ -40,6 +44,7 @@ import ( "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/discover" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/swarm" bzzapi "github.com/ethereum/go-ethereum/swarm/api" "gopkg.in/urfave/cli.v1" @@ -67,6 +72,10 @@ var ( Name: "bzzaccount", Usage: "Swarm account key file", } + SwarmListenAddrFlag = cli.StringFlag{ + Name: "httpaddr", + Usage: "Swarm HTTP API listening interface", + } SwarmPortFlag = cli.StringFlag{ Name: "bzzport", Usage: "Swarm local http api port", @@ -83,15 +92,23 @@ var ( Name: "swap", Usage: "Swarm SWAP enabled (default false)", } + SwarmSwapAPIFlag = cli.StringFlag{ + Name: "swap-api", + Usage: "URL of the Ethereum API provider to use to settle SWAP payments", + } SwarmSyncEnabledFlag = cli.BoolTFlag{ Name: "sync", Usage: "Swarm Syncing enabled (default true)", } - EthAPIFlag = cli.StringFlag{ - Name: "ethapi", - Usage: "URL of the Ethereum API provider", + EnsAPIFlag = cli.StringFlag{ + Name: "ens-api", + Usage: "URL of the Ethereum API provider to use for ENS record lookups", Value: node.DefaultIPCEndpoint("geth"), } + EnsAddrFlag = cli.StringFlag{ + Name: "ens-addr", + Usage: "ENS contract address (default is detected as testnet or mainnet using --ens-api)", + } SwarmApiFlag = cli.StringFlag{ Name: "bzzapi", Usage: "Swarm HTTP endpoint", @@ -121,6 +138,12 @@ var ( Name: "corsdomain", Usage: "Domain on which to send Access-Control-Allow-Origin header (multiple domains can be supplied separated by a ',')", } + + // the following flags are deprecated and should be removed in the future + DeprecatedEthAPIFlag = cli.StringFlag{ + Name: "ethapi", + Usage: "DEPRECATED: please use --ens-api and --swap-api", + } ) var defaultNodeConfig = node.DefaultConfig @@ -245,10 +268,13 @@ Cleans database of corrupted entries. utils.PasswordFileFlag, // bzzd-specific flags CorsStringFlag, - EthAPIFlag, + EnsAPIFlag, + EnsAddrFlag, SwarmConfigPathFlag, SwarmSwapEnabledFlag, + SwarmSwapAPIFlag, SwarmSyncEnabledFlag, + SwarmListenAddrFlag, SwarmPortFlag, SwarmAccountFlag, SwarmNetworkIdFlag, @@ -260,6 +286,8 @@ Cleans database of corrupted entries. SwarmUploadDefaultPath, SwarmUpFromStdinFlag, SwarmUploadMimeType, + //deprecated flags + DeprecatedEthAPIFlag, } app.Flags = append(app.Flags, debug.Flags...) app.Before = func(ctx *cli.Context) error { @@ -294,6 +322,11 @@ func version(ctx *cli.Context) error { } func bzzd(ctx *cli.Context) error { + // exit if the deprecated --ethapi flag is set + if ctx.GlobalString(DeprecatedEthAPIFlag.Name) != "" { + utils.Fatalf("--ethapi is no longer a valid command line flag, please use --ens-api and/or --swap-api.") + } + cfg := defaultNodeConfig utils.SetNodeConfig(ctx, &cfg) stack, err := node.New(&cfg) @@ -328,6 +361,38 @@ func bzzd(ctx *cli.Context) error { return nil } +// detectEnsAddr determines the ENS contract address by getting both the +// version and genesis hash using the client and matching them to either +// mainnet or testnet addresses +func detectEnsAddr(client *rpc.Client) (common.Address, error) { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + var version string + if err := client.CallContext(ctx, &version, "net_version"); err != nil { + return common.Address{}, err + } + + block, err := ethclient.NewClient(client).BlockByNumber(ctx, big.NewInt(0)) + if err != nil { + return common.Address{}, err + } + + switch { + + case version == "1" && block.Hash() == params.MainnetGenesisHash: + log.Info("using Mainnet ENS contract address", "addr", ens.MainNetAddress) + return ens.MainNetAddress, nil + + case version == "3" && block.Hash() == params.TestnetGenesisHash: + log.Info("using Testnet ENS contract address", "addr", ens.TestNetAddress) + return ens.TestNetAddress, nil + + default: + return common.Address{}, fmt.Errorf("unknown version and genesis hash: %s %s", version, block.Hash()) + } +} + func registerBzzService(ctx *cli.Context, stack *node.Node) { prvkey := getAccount(ctx, stack) @@ -345,23 +410,54 @@ func registerBzzService(ctx *cli.Context, stack *node.Node) { if len(bzzport) > 0 { bzzconfig.Port = bzzport } + if bzzaddr := ctx.GlobalString(SwarmListenAddrFlag.Name); bzzaddr != "" { + bzzconfig.ListenAddr = bzzaddr + } swapEnabled := ctx.GlobalBool(SwarmSwapEnabledFlag.Name) syncEnabled := ctx.GlobalBoolT(SwarmSyncEnabledFlag.Name) - ethapi := ctx.GlobalString(EthAPIFlag.Name) + swapapi := ctx.GlobalString(SwarmSwapAPIFlag.Name) + if swapEnabled && swapapi == "" { + utils.Fatalf("SWAP is enabled but --swap-api is not set") + } + + ensapi := ctx.GlobalString(EnsAPIFlag.Name) + ensAddr := ctx.GlobalString(EnsAddrFlag.Name) + cors := ctx.GlobalString(CorsStringFlag.Name) boot := func(ctx *node.ServiceContext) (node.Service, error) { - var client *ethclient.Client - if len(ethapi) > 0 { - client, err = ethclient.Dial(ethapi) + var swapClient *ethclient.Client + if swapapi != "" { + log.Info("connecting to SWAP API", "url", swapapi) + swapClient, err = ethclient.Dial(swapapi) if err != nil { - utils.Fatalf("Can't connect: %v", err) + return nil, fmt.Errorf("error connecting to SWAP API %s: %s", swapapi, err) } - } else { - swapEnabled = false } - return swarm.NewSwarm(ctx, client, bzzconfig, swapEnabled, syncEnabled, cors) + + var ensClient *ethclient.Client + if ensapi != "" { + log.Info("connecting to ENS API", "url", ensapi) + client, err := rpc.Dial(ensapi) + if err != nil { + return nil, fmt.Errorf("error connecting to ENS API %s: %s", ensapi, err) + } + ensClient = ethclient.NewClient(client) + + if ensAddr != "" { + bzzconfig.EnsRoot = common.HexToAddress(ensAddr) + } else { + ensAddr, err := detectEnsAddr(client) + if err == nil { + bzzconfig.EnsRoot = ensAddr + } else { + log.Warn(fmt.Sprintf("could not determine ENS contract address, using default %s", bzzconfig.EnsRoot), "err", err) + } + } + } + + return swarm.NewSwarm(ctx, swapClient, ensClient, bzzconfig, swapEnabled, syncEnabled, cors) } if err := stack.Register(boot); err != nil { utils.Fatalf("Failed to register the Swarm service: %v", err) diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/swarm/upload.go b/vendor/github.com/ethereum/go-ethereum/cmd/swarm/upload.go index 42673ae21..9f4c525bb 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/swarm/upload.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/swarm/upload.go @@ -18,6 +18,7 @@ package main import ( + "errors" "fmt" "io" "io/ioutil" @@ -87,24 +88,32 @@ func upload(ctx *cli.Context) { if err != nil { utils.Fatalf("Error opening file: %s", err) } - var hash string + + // define a function which either uploads a directory or single file + // based on the type of the file being uploaded + var doUpload func() (hash string, err error) if stat.IsDir() { - if !recursive { - utils.Fatalf("Argument is a directory and recursive upload is disabled") + doUpload = func() (string, error) { + if !recursive { + return "", errors.New("Argument is a directory and recursive upload is disabled") + } + return client.UploadDirectory(file, defaultPath, "") } - hash, err = client.UploadDirectory(file, defaultPath, "") } else { - if mimeType == "" { - mimeType = detectMimeType(file) + doUpload = func() (string, error) { + f, err := swarm.Open(file) + if err != nil { + return "", fmt.Errorf("error opening file: %s", err) + } + defer f.Close() + if mimeType == "" { + mimeType = detectMimeType(file) + } + f.ContentType = mimeType + return client.Upload(f, "") } - f, err := swarm.Open(file) - if err != nil { - utils.Fatalf("Error opening file: %s", err) - } - defer f.Close() - f.ContentType = mimeType - hash, err = client.Upload(f, "") } + hash, err := doUpload() if err != nil { utils.Fatalf("Upload failed: %s", err) } diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/utils/flags.go b/vendor/github.com/ethereum/go-ethereum/cmd/utils/flags.go index afaa7214b..0159364af 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/utils/flags.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/utils/flags.go @@ -52,10 +52,23 @@ import ( "github.com/ethereum/go-ethereum/p2p/nat" "github.com/ethereum/go-ethereum/p2p/netutil" "github.com/ethereum/go-ethereum/params" - whisper "github.com/ethereum/go-ethereum/whisper/whisperv2" + whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" "gopkg.in/urfave/cli.v1" ) +var ( + CommandHelpTemplate = `{{.cmd.Name}}{{if .cmd.Subcommands}} command{{end}}{{if .cmd.Flags}} [command options]{{end}} [arguments...] +{{if .cmd.Description}}{{.cmd.Description}} +{{end}}{{if .cmd.Subcommands}} +SUBCOMMANDS: + {{range .cmd.Subcommands}}{{.cmd.Name}}{{with .cmd.ShortName}}, {{.cmd}}{{end}}{{ "\t" }}{{.cmd.Usage}} + {{end}}{{end}}{{if .categorizedFlags}} +{{range $idx, $categorized := .categorizedFlags}}{{$categorized.Name}} OPTIONS: +{{range $categorized.Flags}}{{"\t"}}{{.}} +{{end}} +{{end}}{{end}}` +) + func init() { cli.AppHelpTemplate = `{{.Name}} {{if .Flags}}[global options] {{end}}command{{if .Flags}} [command options]{{end}} [arguments...] @@ -70,16 +83,7 @@ GLOBAL OPTIONS: {{end}}{{end}} ` - cli.CommandHelpTemplate = `{{.Name}}{{if .Subcommands}} command{{end}}{{if .Flags}} [command options]{{end}} [arguments...] -{{if .Description}}{{.Description}} -{{end}}{{if .Subcommands}} -SUBCOMMANDS: - {{range .Subcommands}}{{.Name}}{{with .ShortName}}, {{.}}{{end}}{{ "\t" }}{{.Usage}} - {{end}}{{end}}{{if .Flags}} -OPTIONS: - {{range .Flags}}{{.}} - {{end}}{{end}} -` + cli.CommandHelpTemplate = CommandHelpTemplate } // NewApp creates an app with sane defaults. @@ -119,44 +123,19 @@ var ( Name: "nousb", Usage: "Disables monitoring for and managine USB hardware wallets", } - EthashCacheDirFlag = DirectoryFlag{ - Name: "ethash.cachedir", - Usage: "Directory to store the ethash verification caches (default = inside the datadir)", - } - EthashCachesInMemoryFlag = cli.IntFlag{ - Name: "ethash.cachesinmem", - Usage: "Number of recent ethash caches to keep in memory (16MB each)", - Value: eth.DefaultConfig.EthashCachesInMem, - } - EthashCachesOnDiskFlag = cli.IntFlag{ - Name: "ethash.cachesondisk", - Usage: "Number of recent ethash caches to keep on disk (16MB each)", - Value: eth.DefaultConfig.EthashCachesOnDisk, - } - EthashDatasetDirFlag = DirectoryFlag{ - Name: "ethash.dagdir", - Usage: "Directory to store the ethash mining DAGs (default = inside home folder)", - Value: DirectoryString{eth.DefaultConfig.EthashDatasetDir}, - } - EthashDatasetsInMemoryFlag = cli.IntFlag{ - Name: "ethash.dagsinmem", - Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)", - Value: eth.DefaultConfig.EthashDatasetsInMem, - } - EthashDatasetsOnDiskFlag = cli.IntFlag{ - Name: "ethash.dagsondisk", - Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)", - Value: eth.DefaultConfig.EthashDatasetsOnDisk, - } NetworkIdFlag = cli.Uint64Flag{ Name: "networkid", - Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten)", + Usage: "Network identifier (integer, 1=Frontier, 2=Morden (disused), 3=Ropsten, 4=Rinkeby)", Value: eth.DefaultConfig.NetworkId, } - TestNetFlag = cli.BoolFlag{ + TestnetFlag = cli.BoolFlag{ Name: "testnet", Usage: "Ropsten network: pre-configured proof-of-work test network", } + RinkebyFlag = cli.BoolFlag{ + Name: "rinkeby", + Usage: "Rinkeby network: pre-configured proof-of-authority test network", + } DevModeFlag = cli.BoolFlag{ Name: "dev", Usage: "Developer mode: pre-configured private network with several debugging flags", @@ -199,6 +178,76 @@ var ( Name: "lightkdf", Usage: "Reduce key-derivation RAM & CPU usage at some expense of KDF strength", } + // Ethash settings + EthashCacheDirFlag = DirectoryFlag{ + Name: "ethash.cachedir", + Usage: "Directory to store the ethash verification caches (default = inside the datadir)", + } + EthashCachesInMemoryFlag = cli.IntFlag{ + Name: "ethash.cachesinmem", + Usage: "Number of recent ethash caches to keep in memory (16MB each)", + Value: eth.DefaultConfig.EthashCachesInMem, + } + EthashCachesOnDiskFlag = cli.IntFlag{ + Name: "ethash.cachesondisk", + Usage: "Number of recent ethash caches to keep on disk (16MB each)", + Value: eth.DefaultConfig.EthashCachesOnDisk, + } + EthashDatasetDirFlag = DirectoryFlag{ + Name: "ethash.dagdir", + Usage: "Directory to store the ethash mining DAGs (default = inside home folder)", + Value: DirectoryString{eth.DefaultConfig.EthashDatasetDir}, + } + EthashDatasetsInMemoryFlag = cli.IntFlag{ + Name: "ethash.dagsinmem", + Usage: "Number of recent ethash mining DAGs to keep in memory (1+GB each)", + Value: eth.DefaultConfig.EthashDatasetsInMem, + } + EthashDatasetsOnDiskFlag = cli.IntFlag{ + Name: "ethash.dagsondisk", + Usage: "Number of recent ethash mining DAGs to keep on disk (1+GB each)", + Value: eth.DefaultConfig.EthashDatasetsOnDisk, + } + // Transaction pool settings + TxPoolNoLocalsFlag = cli.BoolFlag{ + Name: "txpool.nolocals", + Usage: "Disables price exemptions for locally submitted transactions", + } + TxPoolPriceLimitFlag = cli.Uint64Flag{ + Name: "txpool.pricelimit", + Usage: "Minimum gas price limit to enforce for acceptance into the pool", + Value: eth.DefaultConfig.TxPool.PriceLimit, + } + TxPoolPriceBumpFlag = cli.Uint64Flag{ + Name: "txpool.pricebump", + Usage: "Price bump percentage to replace an already existing transaction", + Value: eth.DefaultConfig.TxPool.PriceBump, + } + TxPoolAccountSlotsFlag = cli.Uint64Flag{ + Name: "txpool.accountslots", + Usage: "Minimum number of executable transaction slots guaranteed per account", + Value: eth.DefaultConfig.TxPool.AccountSlots, + } + TxPoolGlobalSlotsFlag = cli.Uint64Flag{ + Name: "txpool.globalslots", + Usage: "Maximum number of executable transaction slots for all accounts", + Value: eth.DefaultConfig.TxPool.GlobalSlots, + } + TxPoolAccountQueueFlag = cli.Uint64Flag{ + Name: "txpool.accountqueue", + Usage: "Maximum number of non-executable transaction slots permitted per account", + Value: eth.DefaultConfig.TxPool.AccountQueue, + } + TxPoolGlobalQueueFlag = cli.Uint64Flag{ + Name: "txpool.globalqueue", + Usage: "Maximum number of non-executable transaction slots for all accounts", + Value: eth.DefaultConfig.TxPool.GlobalQueue, + } + TxPoolLifetimeFlag = cli.DurationFlag{ + Name: "txpool.lifetime", + Usage: "Maximum amount of time non-executable transaction are queued", + Value: eth.DefaultConfig.TxPool.Lifetime, + } // Performance tuning settings CacheFlag = cli.IntFlag{ Name: "cache", @@ -233,7 +282,7 @@ var ( GasPriceFlag = BigFlag{ Name: "gasprice", Usage: "Minimal gas price to accept for mining a transactions", - Value: big.NewInt(20 * params.Shannon), + Value: eth.DefaultConfig.GasPrice, } ExtraDataFlag = cli.StringFlag{ Name: "extradata", @@ -331,7 +380,7 @@ var ( } ExecFlag = cli.StringFlag{ Name: "exec", - Usage: "Execute JavaScript statement (only in combination with console/attach)", + Usage: "Execute JavaScript statement", } PreloadJSFlag = cli.StringFlag{ Name: "preload", @@ -356,7 +405,17 @@ var ( } BootnodesFlag = cli.StringFlag{ Name: "bootnodes", - Usage: "Comma separated enode URLs for P2P discovery bootstrap", + Usage: "Comma separated enode URLs for P2P discovery bootstrap (set v4+v5 instead for light servers)", + Value: "", + } + BootnodesV4Flag = cli.StringFlag{ + Name: "bootnodesv4", + Usage: "Comma separated enode URLs for P2P v4 discovery bootstrap (light server, full nodes)", + Value: "", + } + BootnodesV5Flag = cli.StringFlag{ + Name: "bootnodesv5", + Usage: "Comma separated enode URLs for P2P v5 discovery bootstrap (light server, light nodes)", Value: "", } NodeKeyFileFlag = cli.StringFlag{ @@ -385,11 +444,6 @@ var ( Usage: "Restricts network communication to the given IP networks (CIDR masks)", } - WhisperEnabledFlag = cli.BoolFlag{ - Name: "shh", - Usage: "Enable Whisper", - } - // ATM the url is left to the user and deployment to JSpathFlag = cli.StringFlag{ Name: "jspath", @@ -408,6 +462,20 @@ var ( Usage: "Suggested gas price is the given percentile of a set of recent transaction gas prices", Value: eth.DefaultConfig.GPO.Percentile, } + WhisperEnabledFlag = cli.BoolFlag{ + Name: "shh", + Usage: "Enable Whisper", + } + WhisperMaxMessageSizeFlag = cli.IntFlag{ + Name: "shh.maxmessagesize", + Usage: "Max message size accepted", + Value: int(whisper.DefaultMaxMessageSize), + } + WhisperMinPOWFlag = cli.Float64Flag{ + Name: "shh.pow", + Usage: "Minimum POW accepted", + Value: whisper.DefaultMinimumPoW, + } ) // MakeDataDir retrieves the currently requested data directory, terminating @@ -415,10 +483,12 @@ var ( // the a subdirectory of the specified datadir will be used. func MakeDataDir(ctx *cli.Context) string { if path := ctx.GlobalString(DataDirFlag.Name); path != "" { - // TODO: choose a different location outside of the regular datadir. - if ctx.GlobalBool(TestNetFlag.Name) { + if ctx.GlobalBool(TestnetFlag.Name) { return filepath.Join(path, "testnet") } + if ctx.GlobalBool(RinkebyFlag.Name) { + return filepath.Join(path, "rinkeby") + } return path } Fatalf("Cannot determine default data directory, please set manually (--datadir)") @@ -462,10 +532,17 @@ func setNodeUserIdent(ctx *cli.Context, cfg *node.Config) { // flags, reverting to pre-configured ones if none have been specified. func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) { urls := params.MainnetBootnodes - if ctx.GlobalIsSet(BootnodesFlag.Name) { - urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") - } else if ctx.GlobalBool(TestNetFlag.Name) { + switch { + case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV4Flag.Name): + if ctx.GlobalIsSet(BootnodesV4Flag.Name) { + urls = strings.Split(ctx.GlobalString(BootnodesV4Flag.Name), ",") + } else { + urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") + } + case ctx.GlobalBool(TestnetFlag.Name): urls = params.TestnetBootnodes + case ctx.GlobalBool(RinkebyFlag.Name): + urls = params.RinkebyBootnodes } cfg.BootstrapNodes = make([]*discover.Node, 0, len(urls)) @@ -483,9 +560,16 @@ func setBootstrapNodes(ctx *cli.Context, cfg *p2p.Config) { // flags, reverting to pre-configured ones if none have been specified. func setBootstrapNodesV5(ctx *cli.Context, cfg *p2p.Config) { urls := params.DiscoveryV5Bootnodes - if ctx.GlobalIsSet(BootnodesFlag.Name) { - urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") - } else if cfg.BootstrapNodesV5 == nil { + switch { + case ctx.GlobalIsSet(BootnodesFlag.Name) || ctx.GlobalIsSet(BootnodesV5Flag.Name): + if ctx.GlobalIsSet(BootnodesV5Flag.Name) { + urls = strings.Split(ctx.GlobalString(BootnodesV5Flag.Name), ",") + } else { + urls = strings.Split(ctx.GlobalString(BootnodesFlag.Name), ",") + } + case ctx.GlobalBool(RinkebyFlag.Name): + urls = params.RinkebyV5Bootnodes + case cfg.BootstrapNodesV5 != nil: return // already set, don't apply defaults. } @@ -647,7 +731,7 @@ func setEtherbase(ctx *cli.Context, ks *keystore.KeyStore, cfg *eth.Config) { } } -// MakePasswordList reads password lines from the file specified by --password. +// MakePasswordList reads password lines from the file specified by the global --password flag. func MakePasswordList(ctx *cli.Context) []string { path := ctx.GlobalString(PasswordFileFlag.Name) if path == "" { @@ -705,6 +789,7 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) { // --dev mode can't use p2p networking. cfg.MaxPeers = 0 cfg.ListenAddr = ":0" + cfg.DiscoveryV5Addr = ":0" cfg.NoDiscovery = true cfg.DiscoveryV5 = false } @@ -723,8 +808,10 @@ func SetNodeConfig(ctx *cli.Context, cfg *node.Config) { cfg.DataDir = ctx.GlobalString(DataDirFlag.Name) case ctx.GlobalBool(DevModeFlag.Name): cfg.DataDir = filepath.Join(os.TempDir(), "ethereum_dev_mode") - case ctx.GlobalBool(TestNetFlag.Name): + case ctx.GlobalBool(TestnetFlag.Name): cfg.DataDir = filepath.Join(node.DefaultDataDir(), "testnet") + case ctx.GlobalBool(RinkebyFlag.Name): + cfg.DataDir = filepath.Join(node.DefaultDataDir(), "rinkeby") } if ctx.GlobalIsSet(KeyStoreDirFlag.Name) { @@ -747,6 +834,33 @@ func setGPO(ctx *cli.Context, cfg *gasprice.Config) { } } +func setTxPool(ctx *cli.Context, cfg *core.TxPoolConfig) { + if ctx.GlobalIsSet(TxPoolNoLocalsFlag.Name) { + cfg.NoLocals = ctx.GlobalBool(TxPoolNoLocalsFlag.Name) + } + if ctx.GlobalIsSet(TxPoolPriceLimitFlag.Name) { + cfg.PriceLimit = ctx.GlobalUint64(TxPoolPriceLimitFlag.Name) + } + if ctx.GlobalIsSet(TxPoolPriceBumpFlag.Name) { + cfg.PriceBump = ctx.GlobalUint64(TxPoolPriceBumpFlag.Name) + } + if ctx.GlobalIsSet(TxPoolAccountSlotsFlag.Name) { + cfg.AccountSlots = ctx.GlobalUint64(TxPoolAccountSlotsFlag.Name) + } + if ctx.GlobalIsSet(TxPoolGlobalSlotsFlag.Name) { + cfg.GlobalSlots = ctx.GlobalUint64(TxPoolGlobalSlotsFlag.Name) + } + if ctx.GlobalIsSet(TxPoolAccountQueueFlag.Name) { + cfg.AccountQueue = ctx.GlobalUint64(TxPoolAccountQueueFlag.Name) + } + if ctx.GlobalIsSet(TxPoolGlobalQueueFlag.Name) { + cfg.GlobalQueue = ctx.GlobalUint64(TxPoolGlobalQueueFlag.Name) + } + if ctx.GlobalIsSet(TxPoolLifetimeFlag.Name) { + cfg.Lifetime = ctx.GlobalDuration(TxPoolLifetimeFlag.Name) + } +} + func setEthash(ctx *cli.Context, cfg *eth.Config) { if ctx.GlobalIsSet(EthashCacheDirFlag.Name) { cfg.EthashCacheDir = ctx.GlobalString(EthashCacheDirFlag.Name) @@ -780,15 +894,26 @@ func checkExclusive(ctx *cli.Context, flags ...cli.Flag) { } } +// SetShhConfig applies shh-related command line flags to the config. +func SetShhConfig(ctx *cli.Context, stack *node.Node, cfg *whisper.Config) { + if ctx.GlobalIsSet(WhisperMaxMessageSizeFlag.Name) { + cfg.MaxMessageSize = uint32(ctx.GlobalUint(WhisperMaxMessageSizeFlag.Name)) + } + if ctx.GlobalIsSet(WhisperMinPOWFlag.Name) { + cfg.MinimumAcceptedPOW = ctx.GlobalFloat64(WhisperMinPOWFlag.Name) + } +} + // SetEthConfig applies eth-related command line flags to the config. func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) { // Avoid conflicting network flags - checkExclusive(ctx, DevModeFlag, TestNetFlag) + checkExclusive(ctx, DevModeFlag, TestnetFlag, RinkebyFlag) checkExclusive(ctx, FastSyncFlag, LightModeFlag, SyncModeFlag) ks := stack.AccountManager().Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) setEtherbase(ctx, ks, cfg) setGPO(ctx, &cfg.GPO) + setTxPool(ctx, &cfg.TxPool) setEthash(ctx, cfg) switch { @@ -835,13 +960,18 @@ func SetEthConfig(ctx *cli.Context, stack *node.Node, cfg *eth.Config) { cfg.EnablePreimageRecording = ctx.GlobalBool(VMEnableDebugFlag.Name) } - // Override any default configs for --dev and --testnet. + // Override any default configs for hard coded networks. switch { - case ctx.GlobalBool(TestNetFlag.Name): + case ctx.GlobalBool(TestnetFlag.Name): if !ctx.GlobalIsSet(NetworkIdFlag.Name) { cfg.NetworkId = 3 } cfg.Genesis = core.DefaultTestnetGenesisBlock() + case ctx.GlobalBool(RinkebyFlag.Name): + if !ctx.GlobalIsSet(NetworkIdFlag.Name) { + cfg.NetworkId = 4 + } + cfg.Genesis = core.DefaultRinkebyGenesisBlock() case ctx.GlobalBool(DevModeFlag.Name): cfg.Genesis = core.DevGenesisBlock() if !ctx.GlobalIsSet(GasPriceFlag.Name) { @@ -879,8 +1009,10 @@ func RegisterEthService(stack *node.Node, cfg *eth.Config) { } // RegisterShhService configures Whisper and adds it to the given node. -func RegisterShhService(stack *node.Node) { - if err := stack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil { +func RegisterShhService(stack *node.Node, cfg *whisper.Config) { + if err := stack.Register(func(n *node.ServiceContext) (node.Service, error) { + return whisper.New(cfg), nil + }); err != nil { Fatalf("Failed to register the Whisper service: %v", err) } } @@ -908,22 +1040,16 @@ func SetupNetwork(ctx *cli.Context) { params.TargetGasLimit = new(big.Int).SetUint64(ctx.GlobalUint64(TargetGasLimitFlag.Name)) } -func ChainDbName(ctx *cli.Context) string { - if ctx.GlobalBool(LightModeFlag.Name) { - return "lightchaindata" - } else { - return "chaindata" - } -} - // MakeChainDatabase open an LevelDB using the flags passed to the client and will hard crash if it fails. func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database { var ( cache = ctx.GlobalInt(CacheFlag.Name) handles = makeDatabaseHandles() - name = ChainDbName(ctx) ) - + name := "chaindata" + if ctx.GlobalBool(LightModeFlag.Name) { + name = "lightchaindata" + } chainDb, err := stack.OpenDatabase(name, cache, handles) if err != nil { Fatalf("Could not open database: %v", err) @@ -934,8 +1060,10 @@ func MakeChainDatabase(ctx *cli.Context, stack *node.Node) ethdb.Database { func MakeGenesis(ctx *cli.Context) *core.Genesis { var genesis *core.Genesis switch { - case ctx.GlobalBool(TestNetFlag.Name): + case ctx.GlobalBool(TestnetFlag.Name): genesis = core.DefaultTestnetGenesisBlock() + case ctx.GlobalBool(RinkebyFlag.Name): + genesis = core.DefaultRinkebyGenesisBlock() case ctx.GlobalBool(DevModeFlag.Name): genesis = core.DevGenesisBlock() } @@ -979,3 +1107,27 @@ func MakeConsolePreloads(ctx *cli.Context) []string { } return preloads } + +// MigrateFlags sets the global flag from a local flag when it's set. +// This is a temporary function used for migrating old command/flags to the +// new format. +// +// e.g. geth account new --keystore /tmp/mykeystore --lightkdf +// +// is equivalent after calling this method with: +// +// geth --keystore /tmp/mykeystore --lightkdf account new +// +// This allows the use of the existing configuration functionality. +// When all flags are migrated this function can be removed and the existing +// configuration functionality must be changed that is uses local flags +func MigrateFlags(action func(ctx *cli.Context) error) func(*cli.Context) error { + return func(ctx *cli.Context) error { + for _, name := range ctx.FlagNames() { + if ctx.IsSet(name) { + ctx.GlobalSet(name, ctx.String(name)) + } + } + return action(ctx) + } +} diff --git a/vendor/github.com/ethereum/go-ethereum/cmd/wnode/main.go b/vendor/github.com/ethereum/go-ethereum/cmd/wnode/main.go index 5eb177f4d..235d368ad 100644 --- a/vendor/github.com/ethereum/go-ethereum/cmd/wnode/main.go +++ b/vendor/github.com/ethereum/go-ethereum/cmd/wnode/main.go @@ -65,7 +65,7 @@ var ( pub *ecdsa.PublicKey asymKey *ecdsa.PrivateKey nodeid *ecdsa.PrivateKey - topic []byte + topic whisper.TopicType asymKeyID string filterID string symPass string @@ -84,10 +84,10 @@ var ( testMode = flag.Bool("test", false, "use of predefined parameters for diagnostics") echoMode = flag.Bool("echo", false, "echo mode: prints some arguments for diagnostics") - argVerbosity = flag.Int("verbosity", int(log.LvlWarn), "log verbosity level") + argVerbosity = flag.Int("verbosity", int(log.LvlError), "log verbosity level") argTTL = flag.Uint("ttl", 30, "time-to-live for messages in seconds") argWorkTime = flag.Uint("work", 5, "work time in seconds") - argMaxSize = flag.Int("maxsize", whisper.DefaultMaxMessageLength, "max size of message") + argMaxSize = flag.Uint("maxsize", uint(whisper.DefaultMaxMessageSize), "max size of message") argPoW = flag.Float64("pow", whisper.DefaultMinimumPoW, "PoW for normal messages in float format (e.g. 2.7)") argServerPoW = flag.Float64("mspow", whisper.DefaultMinimumPoW, "PoW requirement for Mail Server request") @@ -131,7 +131,7 @@ func processArgs() { if err != nil { utils.Fatalf("Failed to parse the topic: %s", err) } - topic = x + topic = whisper.BytesToTopic(x) } if *asymmetricMode && len(*argPub) > 0 { @@ -192,7 +192,7 @@ func initialize() { if *testMode { symPass = "wwww" // ascii code: 0x77777777 - msPassword = "mail server test password" + msPassword = "wwww" } if *bootstrapMode { @@ -207,6 +207,11 @@ func initialize() { peers = append(peers, peer) } + cfg := &whisper.Config{ + MaxMessageSize: uint32(*argMaxSize), + MinimumAcceptedPOW: *argPoW, + } + if *mailServerMode { if len(msPassword) == 0 { msPassword, err = console.Stdin.PromptPassword("Please enter the Mail Server password: ") @@ -214,11 +219,12 @@ func initialize() { utils.Fatalf("Failed to read Mail Server password: %s", err) } } - shh = whisper.New() + + shh = whisper.New(cfg) shh.RegisterServer(&mailServer) mailServer.Init(shh, *argDBPath, msPassword, *argServerPoW) } else { - shh = whisper.New() + shh = whisper.New(cfg) } if *argPoW != whisper.DefaultMinimumPoW { @@ -228,8 +234,8 @@ func initialize() { } } - if *argMaxSize != whisper.DefaultMaxMessageLength { - err := shh.SetMaxMessageLength(*argMaxSize) + if uint32(*argMaxSize) != whisper.DefaultMaxMessageSize { + err := shh.SetMaxMessageSize(uint32(*argMaxSize)) if err != nil { utils.Fatalf("Failed to set max message size: %s", err) } @@ -316,7 +322,11 @@ func configureNode() { if *asymmetricMode { if len(*argPub) == 0 { s := scanLine("Please enter the peer's public key: ") - pub = crypto.ToECDSAPub(common.FromHex(s)) + b := common.FromHex(s) + if b == nil { + utils.Fatalf("Error: can not convert hexadecimal string") + } + pub = crypto.ToECDSAPub(b) if !isKeyValid(pub) { utils.Fatalf("Error: invalid public key") } @@ -335,7 +345,7 @@ func configureNode() { if !*asymmetricMode && !*forwarderMode { if len(symPass) == 0 { - symPass, err = console.Stdin.PromptPassword("Please enter the password: ") + symPass, err = console.Stdin.PromptPassword("Please enter the password for symmetric encryption: ") if err != nil { utils.Fatalf("Failed to read passphrase: %v", err) } @@ -352,6 +362,8 @@ func configureNode() { if len(*argTopic) == 0 { generateTopic([]byte(symPass)) } + + fmt.Printf("Filter is configured for the topic: %x \n", topic) } if *mailServerMode { @@ -363,18 +375,17 @@ func configureNode() { filter := whisper.Filter{ KeySym: symKey, KeyAsym: asymKey, - Topics: [][]byte{topic}, + Topics: [][]byte{topic[:]}, AllowP2P: p2pAccept, } filterID, err = shh.Subscribe(&filter) if err != nil { utils.Fatalf("Failed to install filter: %s", err) } - fmt.Printf("Filter is configured for the topic: %x \n", topic) } func generateTopic(password []byte) { - x := pbkdf2.Key(password, password, 8196, 128, sha512.New) + x := pbkdf2.Key(password, password, 4096, 128, sha512.New) for i := 0; i < len(x); i++ { topic[i%whisper.TopicLength] ^= x[i] } @@ -508,16 +519,15 @@ func sendMsg(payload []byte) common.Hash { Dst: pub, KeySym: symKey, Payload: payload, - Topic: whisper.BytesToTopic(topic), + Topic: topic, TTL: uint32(*argTTL), PoW: *argPoW, WorkTime: uint32(*argWorkTime), } - msg := whisper.NewSentMessage(¶ms) - if msg == nil { - fmt.Printf("failed to create new message (OS level error)") - os.Exit(0) + msg, err := whisper.NewSentMessage(¶ms) + if err != nil { + utils.Fatalf("failed to create new message: %s", err) } envelope, err := msg.Wrap(¶ms) if err != nil { @@ -647,9 +657,9 @@ func requestExpiredMessagesLoop() { params.Src = nodeid params.WorkTime = 5 - msg := whisper.NewSentMessage(¶ms) - if msg == nil { - utils.Fatalf("failed to create new message (OS level error)") + msg, err := whisper.NewSentMessage(¶ms) + if err != nil { + utils.Fatalf("failed to create new message: %s", err) } env, err := msg.Wrap(¶ms) if err != nil { diff --git a/vendor/github.com/ethereum/go-ethereum/common/bitutil/bitutil.go b/vendor/github.com/ethereum/go-ethereum/common/bitutil/bitutil.go new file mode 100644 index 000000000..117616543 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/common/bitutil/bitutil.go @@ -0,0 +1,188 @@ +// Copyright 2013 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Adapted from: https://golang.org/src/crypto/cipher/xor.go + +// Package bitutil implements fast bitwise operations. +package bitutil + +import ( + "runtime" + "unsafe" +) + +const wordSize = int(unsafe.Sizeof(uintptr(0))) +const supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x" + +// XORBytes xors the bytes in a and b. The destination is assumed to have enough +// space. Returns the number of bytes xor'd. +func XORBytes(dst, a, b []byte) int { + if supportsUnaligned { + return fastXORBytes(dst, a, b) + } + return safeXORBytes(dst, a, b) +} + +// fastXORBytes xors in bulk. It only works on architectures that support +// unaligned read/writes. +func fastXORBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + w := n / wordSize + if w > 0 { + dw := *(*[]uintptr)(unsafe.Pointer(&dst)) + aw := *(*[]uintptr)(unsafe.Pointer(&a)) + bw := *(*[]uintptr)(unsafe.Pointer(&b)) + for i := 0; i < w; i++ { + dw[i] = aw[i] ^ bw[i] + } + } + for i := (n - n%wordSize); i < n; i++ { + dst[i] = a[i] ^ b[i] + } + return n +} + +// safeXORBytes xors one by one. It works on all architectures, independent if +// it supports unaligned read/writes or not. +func safeXORBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + for i := 0; i < n; i++ { + dst[i] = a[i] ^ b[i] + } + return n +} + +// ANDBytes ands the bytes in a and b. The destination is assumed to have enough +// space. Returns the number of bytes and'd. +func ANDBytes(dst, a, b []byte) int { + if supportsUnaligned { + return fastANDBytes(dst, a, b) + } + return safeANDBytes(dst, a, b) +} + +// fastANDBytes ands in bulk. It only works on architectures that support +// unaligned read/writes. +func fastANDBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + w := n / wordSize + if w > 0 { + dw := *(*[]uintptr)(unsafe.Pointer(&dst)) + aw := *(*[]uintptr)(unsafe.Pointer(&a)) + bw := *(*[]uintptr)(unsafe.Pointer(&b)) + for i := 0; i < w; i++ { + dw[i] = aw[i] & bw[i] + } + } + for i := (n - n%wordSize); i < n; i++ { + dst[i] = a[i] & b[i] + } + return n +} + +// safeANDBytes ands one by one. It works on all architectures, independent if +// it supports unaligned read/writes or not. +func safeANDBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + for i := 0; i < n; i++ { + dst[i] = a[i] & b[i] + } + return n +} + +// ORBytes ors the bytes in a and b. The destination is assumed to have enough +// space. Returns the number of bytes or'd. +func ORBytes(dst, a, b []byte) int { + if supportsUnaligned { + return fastORBytes(dst, a, b) + } + return safeORBytes(dst, a, b) +} + +// fastORBytes ors in bulk. It only works on architectures that support +// unaligned read/writes. +func fastORBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + w := n / wordSize + if w > 0 { + dw := *(*[]uintptr)(unsafe.Pointer(&dst)) + aw := *(*[]uintptr)(unsafe.Pointer(&a)) + bw := *(*[]uintptr)(unsafe.Pointer(&b)) + for i := 0; i < w; i++ { + dw[i] = aw[i] | bw[i] + } + } + for i := (n - n%wordSize); i < n; i++ { + dst[i] = a[i] | b[i] + } + return n +} + +// safeORBytes ors one by one. It works on all architectures, independent if +// it supports unaligned read/writes or not. +func safeORBytes(dst, a, b []byte) int { + n := len(a) + if len(b) < n { + n = len(b) + } + for i := 0; i < n; i++ { + dst[i] = a[i] | b[i] + } + return n +} + +// TestBytes tests whether any bit is set in the input byte slice. +func TestBytes(p []byte) bool { + if supportsUnaligned { + return fastTestBytes(p) + } + return safeTestBytes(p) +} + +// fastTestBytes tests for set bits in bulk. It only works on architectures that +// support unaligned read/writes. +func fastTestBytes(p []byte) bool { + n := len(p) + w := n / wordSize + if w > 0 { + pw := *(*[]uintptr)(unsafe.Pointer(&p)) + for i := 0; i < w; i++ { + if pw[i] != 0 { + return true + } + } + } + for i := (n - n%wordSize); i < n; i++ { + if p[i] != 0 { + return true + } + } + return false +} + +// safeTestBytes tests for set bits one byte at a time. It works on all +// architectures, independent if it supports unaligned read/writes or not. +func safeTestBytes(p []byte) bool { + for i := 0; i < len(p); i++ { + if p[i] != 0 { + return true + } + } + return false +} diff --git a/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress.go b/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress.go new file mode 100644 index 000000000..c057cee4a --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress.go @@ -0,0 +1,170 @@ +// 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 bitutil + +import "errors" + +var ( + // errMissingData is returned from decompression if the byte referenced by + // the bitset header overflows the input data. + errMissingData = errors.New("missing bytes on input") + + // errUnreferencedData is returned from decompression if not all bytes were used + // up from the input data after decompressing it. + errUnreferencedData = errors.New("extra bytes on input") + + // errExceededTarget is returned from decompression if the bitset header has + // more bits defined than the number of target buffer space available. + errExceededTarget = errors.New("target data size exceeded") + + // errZeroContent is returned from decompression if a data byte referenced in + // the bitset header is actually a zero byte. + errZeroContent = errors.New("zero byte in input content") +) + +// The compression algorithm implemented by CompressBytes and DecompressBytes is +// optimized for sparse input data which contains a lot of zero bytes. Decompression +// requires knowledge of the decompressed data length. +// +// Compression works as follows: +// +// if data only contains zeroes, +// CompressBytes(data) == nil +// otherwise if len(data) <= 1, +// CompressBytes(data) == data +// otherwise: +// CompressBytes(data) == append(CompressBytes(nonZeroBitset(data)), nonZeroBytes(data)...) +// where +// nonZeroBitset(data) is a bit vector with len(data) bits (MSB first): +// nonZeroBitset(data)[i/8] && (1 << (7-i%8)) != 0 if data[i] != 0 +// len(nonZeroBitset(data)) == (len(data)+7)/8 +// nonZeroBytes(data) contains the non-zero bytes of data in the same order + +// CompressBytes compresses the input byte slice according to the sparse bitset +// representation algorithm. If the result is bigger than the original input, no +// compression is done. +func CompressBytes(data []byte) []byte { + if out := bitsetEncodeBytes(data); len(out) < len(data) { + return out + } + cpy := make([]byte, len(data)) + copy(cpy, data) + return cpy +} + +// bitsetEncodeBytes compresses the input byte slice according to the sparse +// bitset representation algorithm. +func bitsetEncodeBytes(data []byte) []byte { + // Empty slices get compressed to nil + if len(data) == 0 { + return nil + } + // One byte slices compress to nil or retain the single byte + if len(data) == 1 { + if data[0] == 0 { + return nil + } + return data + } + // Calculate the bitset of set bytes, and gather the non-zero bytes + nonZeroBitset := make([]byte, (len(data)+7)/8) + nonZeroBytes := make([]byte, 0, len(data)) + + for i, b := range data { + if b != 0 { + nonZeroBytes = append(nonZeroBytes, b) + nonZeroBitset[i/8] |= 1 << byte(7-i%8) + } + } + if len(nonZeroBytes) == 0 { + return nil + } + return append(bitsetEncodeBytes(nonZeroBitset), nonZeroBytes...) +} + +// DecompressBytes decompresses data with a known target size. If the input data +// matches the size of the target, it means no compression was done in the first +// place. +func DecompressBytes(data []byte, target int) ([]byte, error) { + if len(data) > target { + return nil, errExceededTarget + } + if len(data) == target { + cpy := make([]byte, len(data)) + copy(cpy, data) + return cpy, nil + } + return bitsetDecodeBytes(data, target) +} + +// bitsetDecodeBytes decompresses data with a known target size. +func bitsetDecodeBytes(data []byte, target int) ([]byte, error) { + out, size, err := bitsetDecodePartialBytes(data, target) + if err != nil { + return nil, err + } + if size != len(data) { + return nil, errUnreferencedData + } + return out, nil +} + +// bitsetDecodePartialBytes decompresses data with a known target size, but does +// not enforce consuming all the input bytes. In addition to the decompressed +// output, the function returns the length of compressed input data corresponding +// to the output as the input slice may be longer. +func bitsetDecodePartialBytes(data []byte, target int) ([]byte, int, error) { + // Sanity check 0 targets to avoid infinite recursion + if target == 0 { + return nil, 0, nil + } + // Handle the zero and single byte corner cases + decomp := make([]byte, target) + if len(data) == 0 { + return decomp, 0, nil + } + if target == 1 { + decomp[0] = data[0] // copy to avoid referencing the input slice + if data[0] != 0 { + return decomp, 1, nil + } + return decomp, 0, nil + } + // Decompress the bitset of set bytes and distribute the non zero bytes + nonZeroBitset, ptr, err := bitsetDecodePartialBytes(data, (target+7)/8) + if err != nil { + return nil, ptr, err + } + for i := 0; i < 8*len(nonZeroBitset); i++ { + if nonZeroBitset[i/8]&(1<= len(data) { + return nil, 0, errMissingData + } + if i >= len(decomp) { + return nil, 0, errExceededTarget + } + // Make sure the data is valid and push into the slot + if data[ptr] == 0 { + return nil, 0, errZeroContent + } + decomp[i] = data[ptr] + ptr++ + } + } + return decomp, ptr, nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress_fuzz.go b/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress_fuzz.go new file mode 100644 index 000000000..1b87f50ed --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/common/bitutil/compress_fuzz.go @@ -0,0 +1,56 @@ +// 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 . + +// +build gofuzz + +package bitutil + +import "bytes" + +// Fuzz implements a go-fuzz fuzzer method to test various encoding method +// invocations. +func Fuzz(data []byte) int { + if len(data) == 0 { + return -1 + } + if data[0]%2 == 0 { + return fuzzEncode(data[1:]) + } + return fuzzDecode(data[1:]) +} + +// fuzzEncode implements a go-fuzz fuzzer method to test the bitset encoding and +// decoding algorithm. +func fuzzEncode(data []byte) int { + proc, _ := bitsetDecodeBytes(bitsetEncodeBytes(data), len(data)) + if !bytes.Equal(data, proc) { + panic("content mismatch") + } + return 0 +} + +// fuzzDecode implements a go-fuzz fuzzer method to test the bit decoding and +// reencoding algorithm. +func fuzzDecode(data []byte) int { + blob, err := bitsetDecodeBytes(data, 1024) + if err != nil { + return 0 + } + if comp := bitsetEncodeBytes(blob); !bytes.Equal(comp, data) { + panic("content mismatch") + } + return 0 +} diff --git a/vendor/github.com/ethereum/go-ethereum/common/bytes.go b/vendor/github.com/ethereum/go-ethereum/common/bytes.go index 0342083a1..c445968f2 100644 --- a/vendor/github.com/ethereum/go-ethereum/common/bytes.go +++ b/vendor/github.com/ethereum/go-ethereum/common/bytes.go @@ -89,18 +89,18 @@ func Hex2BytesFixed(str string, flen int) []byte { } func RightPadBytes(slice []byte, l int) []byte { - if l < len(slice) { + if l <= len(slice) { return slice } padded := make([]byte, l) - copy(padded[0:len(slice)], slice) + copy(padded, slice) return padded } func LeftPadBytes(slice []byte, l int) []byte { - if l < len(slice) { + if l <= len(slice) { return slice } diff --git a/vendor/github.com/ethereum/go-ethereum/common/hexutil/hexutil.go b/vendor/github.com/ethereum/go-ethereum/common/hexutil/hexutil.go index 6b128ae36..582a67c22 100644 --- a/vendor/github.com/ethereum/go-ethereum/common/hexutil/hexutil.go +++ b/vendor/github.com/ethereum/go-ethereum/common/hexutil/hexutil.go @@ -32,7 +32,6 @@ package hexutil import ( "encoding/hex" - "errors" "fmt" "math/big" "strconv" @@ -41,17 +40,23 @@ import ( const uintBits = 32 << (uint64(^uint(0)) >> 63) var ( - ErrEmptyString = errors.New("empty hex string") - ErrMissingPrefix = errors.New("missing 0x prefix for hex data") - ErrSyntax = errors.New("invalid hex") - ErrEmptyNumber = errors.New("hex number has no digits after 0x") - ErrLeadingZero = errors.New("hex number has leading zero digits after 0x") - ErrOddLength = errors.New("hex string has odd length") - ErrUint64Range = errors.New("hex number does not fit into 64 bits") - ErrUintRange = fmt.Errorf("hex number does not fit into %d bits", uintBits) - ErrBig256Range = errors.New("hex number does not fit into 256 bits") + ErrEmptyString = &decError{"empty hex string"} + ErrSyntax = &decError{"invalid hex string"} + ErrMissingPrefix = &decError{"hex string without 0x prefix"} + ErrOddLength = &decError{"hex string of odd length"} + ErrEmptyNumber = &decError{"hex string \"0x\""} + ErrLeadingZero = &decError{"hex number with leading zero digits"} + ErrUint64Range = &decError{"hex number > 64 bits"} + ErrUintRange = &decError{fmt.Sprintf("hex number > %d bits", uintBits)} + ErrBig256Range = &decError{"hex number > 256 bits"} ) +type decError struct{ msg string } + +func (err decError) Error() string { + return string(err.msg) +} + // Decode decodes a hex string with 0x prefix. func Decode(input string) ([]byte, error) { if len(input) == 0 { diff --git a/vendor/github.com/ethereum/go-ethereum/common/hexutil/json.go b/vendor/github.com/ethereum/go-ethereum/common/hexutil/json.go index 1bc1d014c..943288fad 100644 --- a/vendor/github.com/ethereum/go-ethereum/common/hexutil/json.go +++ b/vendor/github.com/ethereum/go-ethereum/common/hexutil/json.go @@ -18,15 +18,19 @@ package hexutil import ( "encoding/hex" - "errors" + "encoding/json" "fmt" "math/big" + "reflect" "strconv" ) var ( - textZero = []byte(`0x0`) - errNonString = errors.New("cannot unmarshal non-string as hex data") + textZero = []byte(`0x0`) + bytesT = reflect.TypeOf(Bytes(nil)) + bigT = reflect.TypeOf((*Big)(nil)) + uintT = reflect.TypeOf(Uint(0)) + uint64T = reflect.TypeOf(Uint64(0)) ) // Bytes marshals/unmarshals as a JSON string with 0x prefix. @@ -44,9 +48,9 @@ func (b Bytes) MarshalText() ([]byte, error) { // UnmarshalJSON implements json.Unmarshaler. func (b *Bytes) UnmarshalJSON(input []byte) error { if !isString(input) { - return errNonString + return errNonString(bytesT) } - return b.UnmarshalText(input[1 : len(input)-1]) + return wrapTypeError(b.UnmarshalText(input[1:len(input)-1]), bytesT) } // UnmarshalText implements encoding.TextUnmarshaler. @@ -69,6 +73,16 @@ func (b Bytes) String() string { return Encode(b) } +// UnmarshalFixedJSON decodes the input as a string with 0x prefix. The length of out +// determines the required input length. This function is commonly used to implement the +// UnmarshalJSON method for fixed-size types. +func UnmarshalFixedJSON(typ reflect.Type, input, out []byte) error { + if !isString(input) { + return errNonString(typ) + } + return wrapTypeError(UnmarshalFixedText(typ.String(), input[1:len(input)-1], out), typ) +} + // UnmarshalFixedText decodes the input as a string with 0x prefix. The length of out // determines the required input length. This function is commonly used to implement the // UnmarshalText method for fixed-size types. @@ -127,9 +141,9 @@ func (b Big) MarshalText() ([]byte, error) { // UnmarshalJSON implements json.Unmarshaler. func (b *Big) UnmarshalJSON(input []byte) error { if !isString(input) { - return errNonString + return errNonString(bigT) } - return b.UnmarshalText(input[1 : len(input)-1]) + return wrapTypeError(b.UnmarshalText(input[1:len(input)-1]), bigT) } // UnmarshalText implements encoding.TextUnmarshaler @@ -189,9 +203,9 @@ func (b Uint64) MarshalText() ([]byte, error) { // UnmarshalJSON implements json.Unmarshaler. func (b *Uint64) UnmarshalJSON(input []byte) error { if !isString(input) { - return errNonString + return errNonString(uint64T) } - return b.UnmarshalText(input[1 : len(input)-1]) + return wrapTypeError(b.UnmarshalText(input[1:len(input)-1]), uint64T) } // UnmarshalText implements encoding.TextUnmarshaler @@ -233,9 +247,9 @@ func (b Uint) MarshalText() ([]byte, error) { // UnmarshalJSON implements json.Unmarshaler. func (b *Uint) UnmarshalJSON(input []byte) error { if !isString(input) { - return errNonString + return errNonString(uintT) } - return b.UnmarshalText(input[1 : len(input)-1]) + return wrapTypeError(b.UnmarshalText(input[1:len(input)-1]), uintT) } // UnmarshalText implements encoding.TextUnmarshaler. @@ -295,3 +309,14 @@ func checkNumberText(input []byte) (raw []byte, err error) { } return input, nil } + +func wrapTypeError(err error, typ reflect.Type) error { + if _, ok := err.(*decError); ok { + return &json.UnmarshalTypeError{Value: err.Error(), Type: typ} + } + return err +} + +func errNonString(typ reflect.Type) error { + return &json.UnmarshalTypeError{Value: "non-string", Type: typ} +} diff --git a/vendor/github.com/ethereum/go-ethereum/common/math/big.go b/vendor/github.com/ethereum/go-ethereum/common/math/big.go index 5255a88e9..787278650 100644 --- a/vendor/github.com/ethereum/go-ethereum/common/math/big.go +++ b/vendor/github.com/ethereum/go-ethereum/common/math/big.go @@ -27,6 +27,8 @@ var ( tt256 = BigPow(2, 256) tt256m1 = new(big.Int).Sub(tt256, big.NewInt(1)) MaxBig256 = new(big.Int).Set(tt256m1) + tt63 = BigPow(2, 63) + MaxBig63 = new(big.Int).Sub(tt63, big.NewInt(1)) ) const ( @@ -128,6 +130,34 @@ func PaddedBigBytes(bigint *big.Int, n int) []byte { return ret } +// bigEndianByteAt returns the byte at position n, +// in Big-Endian encoding +// So n==0 returns the least significant byte +func bigEndianByteAt(bigint *big.Int, n int) byte { + words := bigint.Bits() + // Check word-bucket the byte will reside in + i := n / wordBytes + if i >= len(words) { + return byte(0) + } + word := words[i] + // Offset of the byte + shift := 8 * uint(n%wordBytes) + + return byte(word >> shift) +} + +// Byte returns the byte at position n, +// with the supplied padlength in Little-Endian encoding. +// n==0 returns the MSB +// Example: bigint '5', padlength 32, n=31 => 5 +func Byte(bigint *big.Int, padlength, n int) byte { + if n >= padlength { + return byte(0) + } + return bigEndianByteAt(bigint, padlength-1-n) +} + // ReadBits encodes the absolute value of bigint as big-endian bytes. Callers must ensure // that buf has enough space. If buf is too short the result will be incomplete. func ReadBits(bigint *big.Int, buf []byte) { diff --git a/vendor/github.com/ethereum/go-ethereum/common/types.go b/vendor/github.com/ethereum/go-ethereum/common/types.go index 05288bf46..803726634 100644 --- a/vendor/github.com/ethereum/go-ethereum/common/types.go +++ b/vendor/github.com/ethereum/go-ethereum/common/types.go @@ -31,6 +31,11 @@ const ( AddressLength = 20 ) +var ( + hashT = reflect.TypeOf(Hash{}) + addressT = reflect.TypeOf(Address{}) +) + // Hash represents the 32 byte Keccak256 hash of arbitrary data. type Hash [HashLength]byte @@ -72,6 +77,11 @@ func (h *Hash) UnmarshalText(input []byte) error { return hexutil.UnmarshalFixedText("Hash", input, h[:]) } +// UnmarshalJSON parses a hash in hex syntax. +func (h *Hash) UnmarshalJSON(input []byte) error { + return hexutil.UnmarshalFixedJSON(hashT, input, h[:]) +} + // MarshalText returns the hex representation of h. func (h Hash) MarshalText() ([]byte, error) { return hexutil.Bytes(h[:]).MarshalText() @@ -194,6 +204,11 @@ func (a *Address) UnmarshalText(input []byte) error { return hexutil.UnmarshalFixedText("Address", input, a[:]) } +// UnmarshalJSON parses a hash in hex syntax. +func (a *Address) UnmarshalJSON(input []byte) error { + return hexutil.UnmarshalFixedJSON(addressT, input, a[:]) +} + // UnprefixedHash allows marshaling an Address without 0x prefix. type UnprefixedAddress Address diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/clique/clique.go b/vendor/github.com/ethereum/go-ethereum/consensus/clique/clique.go index 8619bd1d8..d2fb6934b 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/clique/clique.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/clique/clique.go @@ -44,7 +44,7 @@ import ( const ( checkpointInterval = 1024 // Number of blocks after which to save the vote snapshot to the database inmemorySnapshots = 128 // Number of recent vote snapshots to keep in memory - inmemorySignatures = 1024 // Number of recent blocks to keep in memory + inmemorySignatures = 4096 // Number of recent block signatures to keep in memory wiggleTime = 500 * time.Millisecond // Random delay (per signer) to allow concurrent signers ) @@ -76,7 +76,7 @@ var ( errUnknownBlock = errors.New("unknown block") // errInvalidCheckpointBeneficiary is returned if a checkpoint/epoch transition - // block has a beneficiary set to non zeroes. + // block has a beneficiary set to non-zeroes. errInvalidCheckpointBeneficiary = errors.New("beneficiary in checkpoint block non-zero") // errInvalidVote is returned if a nonce value is something else that the two @@ -84,7 +84,7 @@ var ( errInvalidVote = errors.New("vote nonce not 0x00..0 or 0xff..f") // errInvalidCheckpointVote is returned if a checkpoint/epoch transition block - // has a vote nonce set to non zeroes. + // has a vote nonce set to non-zeroes. errInvalidCheckpointVote = errors.New("vote nonce in checkpoint block non-zero") // errMissingVanity is returned if a block's extra-data section is shorter than @@ -99,12 +99,12 @@ var ( // their extra-data fields. errExtraSigners = errors.New("non-checkpoint block contains extra signer list") - // drrInvalidCheckpointSigners is returned if a checkpoint block contains an + // errInvalidCheckpointSigners is returned if a checkpoint block contains an // invalid list of signers (i.e. non divisible by 20 bytes, or not the correct // ones). - drrInvalidCheckpointSigners = errors.New("invalid signer list on checkpoint block") + errInvalidCheckpointSigners = errors.New("invalid signer list on checkpoint block") - // errInvalidMixDigest is returned if a block's mix digest is non zero. + // errInvalidMixDigest is returned if a block's mix digest is non-zero. errInvalidMixDigest = errors.New("non-zero mix digest") // errInvalidUncleHash is returned if a block contains an non-empty uncle list. @@ -122,7 +122,7 @@ var ( // be modified via out-of-range or non-contiguous headers. errInvalidVotingChain = errors.New("invalid voting chain") - // errUnauthorized is returned if a header is signed by a non authorized entity. + // errUnauthorized is returned if a header is signed by a non-authorized entity. errUnauthorized = errors.New("unauthorized") ) @@ -162,7 +162,12 @@ func sigHash(header *types.Header) (hash common.Hash) { } // ecrecover extracts the Ethereum account address from a signed header. -func ecrecover(header *types.Header) (common.Address, error) { +func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, error) { + // If the signature's already cached, return that + hash := header.Hash() + if address, known := sigcache.Get(hash); known { + return address.(common.Address), nil + } // Retrieve the signature from the header extra-data if len(header.Extra) < extraSeal { return common.Address{}, errMissingSignature @@ -177,6 +182,7 @@ func ecrecover(header *types.Header) (common.Address, error) { var signer common.Address copy(signer[:], crypto.Keccak256(pubkey[1:])[12:]) + sigcache.Add(hash, signer) return signer, nil } @@ -223,7 +229,7 @@ func New(config *params.CliqueConfig, db ethdb.Database) *Clique { // Author implements consensus.Engine, returning the Ethereum address recovered // from the signature in the header's extra-data section. func (c *Clique) Author(header *types.Header) (common.Address, error) { - return ecrecover(header) + return ecrecover(header, c.signatures) } // VerifyHeader checks whether a header conforms to the consensus rules. @@ -291,7 +297,7 @@ func (c *Clique) verifyHeader(chain consensus.ChainReader, header *types.Header, return errExtraSigners } if checkpoint && signersBytes%common.AddressLength != 0 { - return drrInvalidCheckpointSigners + return errInvalidCheckpointSigners } // Ensure that the mix digest is zero as we don't have fork protection currently if header.MixDigest != (common.Hash{}) { @@ -347,7 +353,7 @@ func (c *Clique) verifyCascadingFields(chain consensus.ChainReader, header *type } extraSuffix := len(header.Extra) - extraSeal if !bytes.Equal(header.Extra[extraVanity:extraSuffix], signers) { - return drrInvalidCheckpointSigners + return errInvalidCheckpointSigners } } // All basic checks passed, verify the seal and return @@ -369,7 +375,7 @@ func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash commo } // If an on-disk checkpoint snapshot can be found, use that if number%checkpointInterval == 0 { - if s, err := loadSnapshot(c.config, c.db, hash); err == nil { + if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil { log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash) snap = s break @@ -385,7 +391,7 @@ func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash commo for i := 0; i < len(signers); i++ { copy(signers[i][:], genesis.Extra[extraVanity+i*common.AddressLength:]) } - snap = newSnapshot(c.config, 0, genesis.Hash(), signers) + snap = newSnapshot(c.config, c.signatures, 0, genesis.Hash(), signers) if err := snap.store(c.db); err != nil { return nil, err } @@ -461,10 +467,9 @@ func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, p if err != nil { return err } - c.recents.Add(snap.Hash, snap) // Resolve the authorization key and check against signers - signer, err := ecrecover(header) + signer, err := ecrecover(header, c.signatures) if err != nil { return err } @@ -473,13 +478,13 @@ func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, p } for seen, recent := range snap.Recents { if recent == signer { - // Signer is among recents, only fail if the current block doens't shift it out + // Signer is among recents, only fail if the current block doesn't shift it out if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { return errUnauthorized } } } - // Ensure that the difficulty corresponts to the turn-ness of the signer + // Ensure that the difficulty corresponds to the turn-ness of the signer inturn := snap.inturn(header.Number.Uint64(), signer) if inturn && header.Difficulty.Cmp(diffInTurn) != 0 { return errInvalidDifficulty @@ -493,18 +498,29 @@ func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, p // Prepare implements consensus.Engine, preparing all the consensus fields of the // header for running the transactions on top. func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) error { - // If the block isn't a checkpoint, cast a random vote (good enough fror now) + // If the block isn't a checkpoint, cast a random vote (good enough for now) header.Coinbase = common.Address{} 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 { + return err + } if number%c.config.Epoch != 0 { c.lock.RLock() - if len(c.proposals) > 0 { - addresses := make([]common.Address, 0, len(c.proposals)) - for address := range c.proposals { + + // Gather all the proposals that make sense voting on + addresses := make([]common.Address, 0, len(c.proposals)) + for address, authorize := range c.proposals { + if snap.validVote(address, authorize) { addresses = append(addresses, address) } + } + // If there's pending proposals, cast a vote on them + if len(addresses) > 0 { header.Coinbase = addresses[rand.Intn(len(addresses))] if c.proposals[header.Coinbase] { copy(header.Nonce[:], nonceAuthVote) @@ -514,11 +530,7 @@ func (c *Clique) Prepare(chain consensus.ChainReader, header *types.Header) erro } c.lock.RUnlock() } - // Assemble the voting snapshot and set the correct difficulty - snap, err := c.snapshot(chain, number-1, header.ParentHash, nil) - if err != nil { - return err - } + // Set the correct difficulty header.Difficulty = diffNoTurn if snap.inturn(header.Number.Uint64(), c.signer) { header.Difficulty = diffInTurn @@ -595,11 +607,11 @@ func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop <-ch if _, authorized := snap.Signers[signer]; !authorized { return nil, errUnauthorized } - // If we're amongs the recent signers, wait for the next block + // If we're amongst the recent signers, wait for the next block for seen, recent := range snap.Recents { if recent == signer { - // Signer is among recents, only wait if the current block doens't shift it out - if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit { + // Signer is among recents, only wait if the current block doesn't shift it out + if limit := uint64(len(snap.Signers)/2 + 1); number < limit || seen > number-limit { log.Info("Signed recently, must wait for others") <-stop return nil, nil diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/clique/snapshot.go b/vendor/github.com/ethereum/go-ethereum/consensus/clique/snapshot.go index 46b32ca5f..32a1191db 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/clique/snapshot.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/clique/snapshot.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" + lru "github.com/hashicorp/golang-lru" ) // Vote represents a single vote that an authorized signer made to modify the @@ -38,13 +39,14 @@ type Vote struct { // Tally is a simple vote tally to keep the current score of votes. Votes that // go against the proposal aren't counted since it's equivalent to not voting. type Tally struct { - Authorize bool `json:"authorize"` // Whether the vote it about authorizing or kicking someone + Authorize bool `json:"authorize"` // Whether the vote is about authorizing or kicking someone Votes int `json:"votes"` // Number of votes until now wanting to pass the proposal } // Snapshot is the state of the authorization voting at a given point in time. type Snapshot struct { - config *params.CliqueConfig // Consensus engine parameters to fine tune behavior + config *params.CliqueConfig // Consensus engine parameters to fine tune behavior + sigcache *lru.ARCCache // Cache of recent block signatures to speed up ecrecover Number uint64 `json:"number"` // Block number where the snapshot was created Hash common.Hash `json:"hash"` // Block hash where the snapshot was created @@ -54,17 +56,18 @@ type Snapshot struct { Tally map[common.Address]Tally `json:"tally"` // Current vote tally to avoid recalculating } -// newSnapshot create a new snapshot with the specified startup parameters. This +// newSnapshot creates a new snapshot with the specified startup parameters. This // method does not initialize the set of recent signers, so only ever use if for // the genesis block. -func newSnapshot(config *params.CliqueConfig, number uint64, hash common.Hash, signers []common.Address) *Snapshot { +func newSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, signers []common.Address) *Snapshot { snap := &Snapshot{ - config: config, - Number: number, - Hash: hash, - Signers: make(map[common.Address]struct{}), - Recents: make(map[uint64]common.Address), - Tally: make(map[common.Address]Tally), + config: config, + sigcache: sigcache, + Number: number, + Hash: hash, + Signers: make(map[common.Address]struct{}), + Recents: make(map[uint64]common.Address), + Tally: make(map[common.Address]Tally), } for _, signer := range signers { snap.Signers[signer] = struct{}{} @@ -73,7 +76,7 @@ func newSnapshot(config *params.CliqueConfig, number uint64, hash common.Hash, s } // loadSnapshot loads an existing snapshot from the database. -func loadSnapshot(config *params.CliqueConfig, db ethdb.Database, hash common.Hash) (*Snapshot, error) { +func loadSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) { blob, err := db.Get(append([]byte("clique-"), hash[:]...)) if err != nil { return nil, err @@ -83,6 +86,7 @@ func loadSnapshot(config *params.CliqueConfig, db ethdb.Database, hash common.Ha return nil, err } snap.config = config + snap.sigcache = sigcache return snap, nil } @@ -99,13 +103,14 @@ func (s *Snapshot) store(db ethdb.Database) error { // copy creates a deep copy of the snapshot, though not the individual votes. func (s *Snapshot) copy() *Snapshot { cpy := &Snapshot{ - config: s.config, - Number: s.Number, - Hash: s.Hash, - Signers: make(map[common.Address]struct{}), - Recents: make(map[uint64]common.Address), - Votes: make([]*Vote, len(s.Votes)), - Tally: make(map[common.Address]Tally), + config: s.config, + sigcache: s.sigcache, + Number: s.Number, + Hash: s.Hash, + Signers: make(map[common.Address]struct{}), + Recents: make(map[uint64]common.Address), + Votes: make([]*Vote, len(s.Votes)), + Tally: make(map[common.Address]Tally), } for signer := range s.Signers { cpy.Signers[signer] = struct{}{} @@ -121,11 +126,17 @@ func (s *Snapshot) copy() *Snapshot { return cpy } +// validVote returns whether it makes sense to cast the specified vote in the +// given snapshot context (e.g. don't try to add an already authorized signer). +func (s *Snapshot) validVote(address common.Address, authorize bool) bool { + _, signer := s.Signers[address] + return (signer && !authorize) || (!signer && authorize) +} + // cast adds a new vote into the tally. func (s *Snapshot) cast(address common.Address, authorize bool) bool { // Ensure the vote is meaningful - _, signer := s.Signers[address] - if (signer && authorize) || (!signer && !authorize) { + if !s.validVote(address, authorize) { return false } // Cast the vote into an existing or new tally @@ -190,7 +201,7 @@ func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) { delete(snap.Recents, number-limit) } // Resolve the authorization key and check against signers - signer, err := ecrecover(header) + signer, err := ecrecover(header, s.sigcache) if err != nil { return nil, err } diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/consensus.go b/vendor/github.com/ethereum/go-ethereum/consensus/consensus.go index 8cbd32c88..865238cee 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/consensus.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/consensus.go @@ -79,8 +79,7 @@ type Engine interface { // Finalize runs any post-transaction state modifications (e.g. block rewards) // and assembles the final block. - // - // Note, the block header and state database might be updated to reflect any + // Note: The block header and state database might be updated to reflect any // consensus rules that happen at finalization (e.g. block rewards). Finalize(chain ChainReader, header *types.Header, state *state.StateDB, txs []*types.Transaction, uncles []*types.Header, receipts []*types.Receipt) (*types.Block, error) diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/algorithm.go b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/algorithm.go index 7e8fbfc37..a737bc636 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/algorithm.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/algorithm.go @@ -27,6 +27,7 @@ import ( "unsafe" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/bitutil" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto/sha3" "github.com/ethereum/go-ethereum/log" @@ -52,7 +53,6 @@ type hasher func(dest []byte, data []byte) // makeHasher creates a repetitive hasher, allowing the same hash data structures // to be reused between hash runs instead of requiring new ones to be created. -// // The returned function is not thread safe! func makeHasher(h hash.Hash) hasher { return func(dest []byte, data []byte) { @@ -81,7 +81,6 @@ func seedHash(block uint64) []byte { // memory, then performing two passes of Sergio Demian Lerner's RandMemoHash // algorithm from Strict Memory Hard Hashing Functions (2014). The output is a // set of 524288 64-byte values. -// // This method places the result into dest in machine byte order. func generateCache(dest []uint32, epoch uint64, seed []byte) { // Print some debug logs to allow analysis on low end devices @@ -142,7 +141,7 @@ func generateCache(dest []uint32, epoch uint64, seed []byte) { dstOff = j * hashBytes xorOff = (binary.LittleEndian.Uint32(cache[dstOff:]) % uint32(rows)) * hashBytes ) - xorBytes(temp, cache[srcOff:srcOff+hashBytes], cache[xorOff:xorOff+hashBytes]) + bitutil.XORBytes(temp, cache[srcOff:srcOff+hashBytes], cache[xorOff:xorOff+hashBytes]) keccak512(cache[dstOff:], temp) atomic.AddUint32(&progress, 1) @@ -219,7 +218,6 @@ func generateDatasetItem(cache []uint32, index uint32, keccak512 hasher) []byte } // generateDataset generates the entire ethash dataset for mining. -// // This method places the result into dest in machine byte order. func generateDataset(dest []uint32, epoch uint64, cache []uint32) { // Print some debug logs to allow analysis on low end devices diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/consensus.go b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/consensus.go index 4f1ab8702..dd9c81fd4 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/consensus.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/consensus.go @@ -218,7 +218,6 @@ func (ethash *Ethash) VerifyUncles(chain consensus.ChainReader, block *types.Blo // verifyHeader checks whether a header conforms to the consensus rules of the // stock Ethereum ethash engine. -// // See YP section 4.3.4. "Block Header Validity" func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error { // Ensure that the header's extra-data section is of a reasonable size @@ -239,10 +238,19 @@ 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.Time.Uint64(), parent.Number, parent.Difficulty) + expected := CalcDifficulty(chain.Config(), 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) + } + // 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) + } + // Verify that the gas limit remains within allowed bounds diff := new(big.Int).Set(parent.GasLimit) diff = diff.Sub(diff, header.GasLimit) @@ -274,16 +282,18 @@ func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent * return nil } -// 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. -// +// 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 CalcDifficulty(config *params.ChainConfig, time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int { - if config.IsHomestead(new(big.Int).Add(parentNumber, common.Big1)) { - return calcDifficultyHomestead(time, parentTime, parentNumber, parentDiff) +func CalcDifficulty(config *params.ChainConfig, time uint64, parent *types.Header) *big.Int { + next := new(big.Int).Add(parent.Number, common.Big1) + switch { + case config.IsHomestead(next): + return calcDifficultyHomestead(time, parent) + default: + return calcDifficultyFrontier(time, parent) } - return calcDifficultyFrontier(time, parentTime, parentNumber, parentDiff) } // Some weird constants to avoid constant memory allocs for them. @@ -296,7 +306,7 @@ var ( // calcDifficultyHomestead 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. The calculation uses the Homestead rules. -func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int { +func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int { // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2.mediawiki // algorithm: // diff = (parent_diff + @@ -304,7 +314,7 @@ func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff * // ) + 2^(periodCount - 2) bigTime := new(big.Int).SetUint64(time) - bigParentTime := new(big.Int).SetUint64(parentTime) + bigParentTime := new(big.Int).Set(parent.Time) // holds intermediate values to make the algo easier to read & audit x := new(big.Int) @@ -320,16 +330,16 @@ func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff * x.Set(bigMinus99) } // (parent_diff + parent_diff // 2048 * max(1 - (block_timestamp - parent_timestamp) // 10, -99)) - y.Div(parentDiff, params.DifficultyBoundDivisor) + y.Div(parent.Difficulty, params.DifficultyBoundDivisor) x.Mul(y, x) - x.Add(parentDiff, x) + x.Add(parent.Difficulty, x) // minimum difficulty can ever be (before exponential factor) if x.Cmp(params.MinimumDifficulty) < 0 { x.Set(params.MinimumDifficulty) } // for the exponential factor - periodCount := new(big.Int).Add(parentNumber, common.Big1) + periodCount := new(big.Int).Add(parent.Number, common.Big1) periodCount.Div(periodCount, expDiffPeriod) // the exponential factor, commonly referred to as "the bomb" @@ -345,25 +355,25 @@ func calcDifficultyHomestead(time, parentTime uint64, parentNumber, parentDiff * // calcDifficultyFrontier 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. The calculation uses the Frontier rules. -func calcDifficultyFrontier(time, parentTime uint64, parentNumber, parentDiff *big.Int) *big.Int { +func calcDifficultyFrontier(time uint64, parent *types.Header) *big.Int { diff := new(big.Int) - adjust := new(big.Int).Div(parentDiff, params.DifficultyBoundDivisor) + adjust := new(big.Int).Div(parent.Difficulty, params.DifficultyBoundDivisor) bigTime := new(big.Int) bigParentTime := new(big.Int) bigTime.SetUint64(time) - bigParentTime.SetUint64(parentTime) + bigParentTime.Set(parent.Time) if bigTime.Sub(bigTime, bigParentTime).Cmp(params.DurationLimit) < 0 { - diff.Add(parentDiff, adjust) + diff.Add(parent.Difficulty, adjust) } else { - diff.Sub(parentDiff, adjust) + diff.Sub(parent.Difficulty, adjust) } if diff.Cmp(params.MinimumDifficulty) < 0 { diff.Set(params.MinimumDifficulty) } - periodCount := new(big.Int).Add(parentNumber, common.Big1) + periodCount := new(big.Int).Add(parent.Number, common.Big1) periodCount.Div(periodCount, expDiffPeriod) if periodCount.Cmp(common.Big1) > 0 { // diff = diff + 2^(periodCount - 2) @@ -425,8 +435,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.Time.Uint64(), parent.Number, parent.Difficulty) + header.Difficulty = CalcDifficulty(chain.Config(), header.Time.Uint64(), parent) return nil } @@ -451,7 +460,6 @@ 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(state *state.StateDB, header *types.Header, uncles []*types.Header) { reward := new(big.Int).Set(blockReward) diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/ethash.go b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/ethash.go index b028f50e6..dd6147072 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/ethash.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/ethash.go @@ -308,14 +308,14 @@ func (d *dataset) release() { // MakeCache generates a new ethash cache and optionally stores it to disk. func MakeCache(block uint64, dir string) { - c := cache{epoch: block/epochLength + 1} + c := cache{epoch: block / epochLength} c.generate(dir, math.MaxInt32, false) c.release() } // MakeDataset generates a new ethash dataset and optionally stores it to disk. func MakeDataset(block uint64, dir string) { - d := dataset{epoch: block/epochLength + 1} + d := dataset{epoch: block / epochLength} d.generate(dir, math.MaxInt32, false) d.release() } @@ -355,7 +355,7 @@ type Ethash struct { // New creates a full sized ethash PoW scheme. func New(cachedir string, cachesinmem, cachesondisk int, dagdir string, dagsinmem, dagsondisk int) *Ethash { if cachesinmem <= 0 { - log.Warn("One ethash cache must alwast be in memory", "requested", cachesinmem) + log.Warn("One ethash cache must always be in memory", "requested", cachesinmem) cachesinmem = 1 } if cachedir != "" && cachesondisk > 0 { @@ -412,7 +412,7 @@ func NewFakeDelayer(delay time.Duration) *Ethash { return &Ethash{fakeMode: true, fakeDelay: delay} } -// NewFullFaker creates a ethash consensus engine with a full fake scheme that +// NewFullFaker creates an ethash consensus engine with a full fake scheme that // accepts all blocks as valid, without checking any consensus rules whatsoever. func NewFullFaker() *Ethash { return &Ethash{fakeMode: true, fakeFull: true} @@ -467,8 +467,9 @@ func (ethash *Ethash) cache(block uint64) []uint32 { future = &cache{epoch: epoch + 1} ethash.fcache = future } + // New current cache, set its initial timestamp + current.used = time.Now() } - current.used = time.Now() ethash.lock.Unlock() // Wait for generation finish, bump the timestamp and finalize the cache @@ -529,8 +530,9 @@ func (ethash *Ethash) dataset(block uint64) []uint32 { future = &dataset{epoch: epoch + 1} ethash.fdataset = future } + // New current dataset, set its initial timestamp + current.used = time.Now() } - current.used = time.Now() ethash.lock.Unlock() // Wait for generation finish, bump the timestamp and finalize the cache diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/xor.go b/vendor/github.com/ethereum/go-ethereum/consensus/ethash/xor.go deleted file mode 100644 index 90e232746..000000000 --- a/vendor/github.com/ethereum/go-ethereum/consensus/ethash/xor.go +++ /dev/null @@ -1,85 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Source: https://golang.org/src/crypto/cipher/xor.go - -package ethash - -import ( - "runtime" - "unsafe" -) - -const wordSize = int(unsafe.Sizeof(uintptr(0))) -const supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x" - -// fastXORBytes xors in bulk. It only works on architectures that -// support unaligned read/writes. -func fastXORBytes(dst, a, b []byte) int { - n := len(a) - if len(b) < n { - n = len(b) - } - - w := n / wordSize - if w > 0 { - dw := *(*[]uintptr)(unsafe.Pointer(&dst)) - aw := *(*[]uintptr)(unsafe.Pointer(&a)) - bw := *(*[]uintptr)(unsafe.Pointer(&b)) - for i := 0; i < w; i++ { - dw[i] = aw[i] ^ bw[i] - } - } - - for i := (n - n%wordSize); i < n; i++ { - dst[i] = a[i] ^ b[i] - } - - return n -} - -func safeXORBytes(dst, a, b []byte) int { - n := len(a) - if len(b) < n { - n = len(b) - } - for i := 0; i < n; i++ { - dst[i] = a[i] ^ b[i] - } - return n -} - -// xorBytes xors the bytes in a and b. The destination is assumed to have enough -// space. Returns the number of bytes xor'd. -func xorBytes(dst, a, b []byte) int { - if supportsUnaligned { - return fastXORBytes(dst, a, b) - } - // TODO(hanwen): if (dst, a, b) have common alignment - // we could still try fastXORBytes. It is not clear - // how often this happens, and it's only worth it if - // the block encryption itself is hardware - // accelerated. - return safeXORBytes(dst, a, b) -} - -// fastXORWords XORs multiples of 4 or 8 bytes (depending on architecture.) -// The arguments are assumed to be of equal length. -func fastXORWords(dst, a, b []byte) { - dw := *(*[]uintptr)(unsafe.Pointer(&dst)) - aw := *(*[]uintptr)(unsafe.Pointer(&a)) - bw := *(*[]uintptr)(unsafe.Pointer(&b)) - n := len(b) / wordSize - for i := 0; i < n; i++ { - dw[i] = aw[i] ^ bw[i] - } -} - -func xorWords(dst, a, b []byte) { - if supportsUnaligned { - fastXORWords(dst, a, b) - } else { - safeXORBytes(dst, a, b) - } -} diff --git a/vendor/github.com/ethereum/go-ethereum/consensus/misc/dao.go b/vendor/github.com/ethereum/go-ethereum/consensus/misc/dao.go index 67d4adb44..9b22bd7a5 100644 --- a/vendor/github.com/ethereum/go-ethereum/consensus/misc/dao.go +++ b/vendor/github.com/ethereum/go-ethereum/consensus/misc/dao.go @@ -54,7 +54,7 @@ func VerifyDAOHeaderExtraData(config *params.ChainConfig, header *types.Header) if header.Number.Cmp(config.DAOForkBlock) < 0 || header.Number.Cmp(limit) >= 0 { return nil } - // Depending whether we support or oppose the fork, validate the extra-data contents + // Depending on whether we support or oppose the fork, validate the extra-data contents if config.DAOForkSupport { if !bytes.Equal(header.Extra, params.DAOForkBlockExtra) { return ErrBadProDAOExtra diff --git a/vendor/github.com/ethereum/go-ethereum/console/bridge.go b/vendor/github.com/ethereum/go-ethereum/console/bridge.go index 6db54eb21..75be68188 100644 --- a/vendor/github.com/ethereum/go-ethereum/console/bridge.go +++ b/vendor/github.com/ethereum/go-ethereum/console/bridge.go @@ -20,6 +20,7 @@ import ( "encoding/json" "fmt" "io" + "strings" "time" "github.com/ethereum/go-ethereum/log" @@ -240,17 +241,19 @@ func (b *bridge) Send(call otto.FunctionCall) (response otto.Value) { throwJSException(err.Error()) } var ( - rawReq = []byte(reqVal.String()) + rawReq = reqVal.String() + dec = json.NewDecoder(strings.NewReader(rawReq)) reqs []jsonrpcCall batch bool ) + dec.UseNumber() // avoid float64s if rawReq[0] == '[' { batch = true - json.Unmarshal(rawReq, &reqs) + dec.Decode(&reqs) } else { batch = false reqs = make([]jsonrpcCall, 1) - json.Unmarshal(rawReq, &reqs[0]) + dec.Decode(&reqs[0]) } // Execute the requests. diff --git a/vendor/github.com/ethereum/go-ethereum/console/testdata/exec.js b/vendor/github.com/ethereum/go-ethereum/console/testdata/exec.js new file mode 100644 index 000000000..59e34d7c4 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/console/testdata/exec.js @@ -0,0 +1 @@ +var execed = "some-executed-string"; diff --git a/vendor/github.com/ethereum/go-ethereum/console/testdata/preload.js b/vendor/github.com/ethereum/go-ethereum/console/testdata/preload.js new file mode 100644 index 000000000..556793970 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/console/testdata/preload.js @@ -0,0 +1 @@ +var preloaded = "some-preloaded-string"; diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-alpine/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-alpine/Dockerfile new file mode 100644 index 000000000..d239129d5 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-alpine/Dockerfile @@ -0,0 +1,14 @@ +FROM alpine:3.5 + +RUN \ + apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ + git clone --depth 1 https://github.com/ethereum/go-ethereum && \ + (cd go-ethereum && make geth) && \ + cp go-ethereum/build/bin/geth /geth && \ + apk del go git make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 8545 +EXPOSE 30303 + +ENTRYPOINT ["/geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-ubuntu/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-ubuntu/Dockerfile new file mode 100644 index 000000000..c79becb55 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/develop-ubuntu/Dockerfile @@ -0,0 +1,15 @@ +FROM ubuntu:xenial + +RUN \ + apt-get update && apt-get upgrade -q -y && \ + apt-get install -y --no-install-recommends golang 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 && \ + rm -rf /go-ethereum + +EXPOSE 8545 +EXPOSE 30303 + +ENTRYPOINT ["/geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/master-alpine/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/master-alpine/Dockerfile new file mode 100644 index 000000000..b2467f1a7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/master-alpine/Dockerfile @@ -0,0 +1,14 @@ +FROM alpine:3.5 + +RUN \ + apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ + git clone --depth 1 --branch release/1.6 https://github.com/ethereum/go-ethereum && \ + (cd go-ethereum && make geth) && \ + cp go-ethereum/build/bin/geth /geth && \ + apk del go git make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 8545 +EXPOSE 30303 + +ENTRYPOINT ["/geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/master-ubuntu/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/master-ubuntu/Dockerfile new file mode 100644 index 000000000..877ae94e9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/master-ubuntu/Dockerfile @@ -0,0 +1,15 @@ +FROM ubuntu:xenial + +RUN \ + apt-get update && apt-get upgrade -q -y && \ + apt-get install -y --no-install-recommends golang git make gcc libc-dev ca-certificates && \ + git clone --depth 1 --branch release/1.5 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 && \ + rm -rf /go-ethereum + +EXPOSE 8545 +EXPOSE 30303 + +ENTRYPOINT ["/geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/geth/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/geth/Dockerfile new file mode 100644 index 000000000..2cc2177d0 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/geth/Dockerfile @@ -0,0 +1,20 @@ +FROM alpine:3.5 + +RUN \ + apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ + + # clone status-go + mkdir -p /usr/lib/go/src/github.com/status-im && \ + git clone --depth 1 --branch 0.9.7 https://github.com/status-im/status-go.git /usr/lib/go/src/github.com/status-im/status-go && \ + + # clone go-ethereum (and install everything) + git clone --depth 1 --branch status/1.6.1-stable https://github.com/status-im/go-ethereum && \ + (cd go-ethereum && make geth) && \ + cp go-ethereum/build/bin/geth /geth && \ + apk del go git make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 8545 +EXPOSE 30303 + +ENTRYPOINT ["/geth"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/swarm/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/swarm/Dockerfile new file mode 100644 index 000000000..685bf5ad9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/swarm/Dockerfile @@ -0,0 +1,19 @@ +FROM alpine:3.5 + +RUN \ + apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ + + # clone status-go + mkdir -p /usr/lib/go/src/github.com/status-im && \ + git clone --depth 1 --branch develop https://github.com/status-im/status-go.git /usr/lib/go/src/github.com/status-im/status-go && \ + + # clone go-ethereum (and install everything) + git clone --depth 1 --branch status/1.6.1-stable https://github.com/status-im/go-ethereum && \ + (cd go-ethereum && build/env.sh go run build/ci.go install ./cmd/swarm) && \ + cp go-ethereum/build/bin/swarm /swarm && \ + apk del go git make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 30399 + +ENTRYPOINT ["/swarm"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/wnode/Dockerfile b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/wnode/Dockerfile new file mode 100644 index 000000000..e160ff9d7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/docker/status-alpine/wnode/Dockerfile @@ -0,0 +1,19 @@ +FROM alpine:3.5 + +RUN \ + apk add --update go git make gcc musl-dev linux-headers ca-certificates && \ + + # clone status-go + mkdir -p /usr/lib/go/src/github.com/status-im && \ + git clone --depth 1 --branch develop https://github.com/status-im/status-go.git /usr/lib/go/src/github.com/status-im/status-go && \ + + # clone go-ethereum (and install everything) + git clone --depth 1 --branch status/1.6.1-stable https://github.com/status-im/go-ethereum && \ + (cd go-ethereum && build/env.sh go run build/ci.go install ./cmd/wnode) && \ + cp go-ethereum/build/bin/wnode /wnode && \ + apk del go git make gcc musl-dev linux-headers && \ + rm -rf /go-ethereum && rm -rf /var/cache/apk/* + +EXPOSE 30379 + +ENTRYPOINT ["/wnode"] diff --git a/vendor/github.com/ethereum/go-ethereum/containers/vagrant/.gitignore b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/.gitignore new file mode 100644 index 000000000..8000dd9db --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/.gitignore @@ -0,0 +1 @@ +.vagrant diff --git a/vendor/github.com/ethereum/go-ethereum/containers/vagrant/Vagrantfile b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/Vagrantfile new file mode 100644 index 000000000..72ec366e2 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/Vagrantfile @@ -0,0 +1,38 @@ +# -*- mode: ruby -*- +# vi: set ft=ruby : + +require 'yaml' + +VAGRANTFILE_API_VERSION = 2 +VM_RAM = 2048 + +Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| + + config.vm.define "ubuntu", :primary => true do |ubuntu| + ubuntu.vm.box = "ubuntu/trusty64" + ubuntu.vm.provision "shell", :path => "provisioners/shell/ubuntu.sh" + end + + config.vm.define "debian", :primary => true do |debian| + debian.vm.box = "debian/jessie64" + debian.vm.provision "shell", :path => "provisioners/shell/debian.sh" + end + + config.vm.define "centos", :autostart => false do |centos| + centos.vm.box = "centos/7" + centos.vm.provision "shell", :path => "provisioners/shell/centos.sh" + end + + config.vm.provider "virtualbox" do |vb| + vb.memory = VM_RAM + end + + config.vm.provider "libvirt" do |lv| + lv.memory = VM_RAM + + config.vm.synced_folder ".", "/home/vagrant/sync", :disabled => true + end + + config.vm.synced_folder ".", "/vagrant", :disabled => true + config.vm.synced_folder "../../", "/home/vagrant/go/src/github.com/ethereum/go-ethereum" +end diff --git a/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/centos.sh b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/centos.sh new file mode 100755 index 000000000..744da4bfd --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/centos.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +sudo yum install -y git wget +sudo yum update -y + +wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz +sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz + +GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/" + +echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc diff --git a/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/debian.sh b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/debian.sh new file mode 100755 index 000000000..1c1793336 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/debian.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +sudo apt-get install -y build-essential git-all wget +sudo apt-get update + +wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz +sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz + +GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/" + +echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc diff --git a/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/ubuntu.sh b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/ubuntu.sh new file mode 100755 index 000000000..1c1793336 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/containers/vagrant/provisioners/shell/ubuntu.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +sudo apt-get install -y build-essential git-all wget +sudo apt-get update + +wget --continue https://storage.googleapis.com/golang/go1.8.1.linux-amd64.tar.gz +sudo tar -C /usr/local -xzf go1.8.1.linux-amd64.tar.gz + +GETH_PATH="~vagrant/go/src/github.com/ethereum/go-ethereum/build/bin/" + +echo "export PATH=$PATH:/usr/local/go/bin:$GETH_PATH" >> ~vagrant/.bashrc diff --git a/vendor/github.com/ethereum/go-ethereum/contracts/chequebook/cheque.go b/vendor/github.com/ethereum/go-ethereum/contracts/chequebook/cheque.go index 7e0f7eafc..bd635705e 100644 --- a/vendor/github.com/ethereum/go-ethereum/contracts/chequebook/cheque.go +++ b/vendor/github.com/ethereum/go-ethereum/contracts/chequebook/cheque.go @@ -49,7 +49,7 @@ import ( // TODO(zelig): watch peer solvency and notify of bouncing cheques // TODO(zelig): enable paying with cheque by signing off -// Some functionality require interacting with the blockchain: +// Some functionality requires interacting with the blockchain: // * setting current balance on peer's chequebook // * sending the transaction to cash the cheque // * depositing ether to the chequebook @@ -100,13 +100,13 @@ type Chequebook struct { // persisted fields balance *big.Int // not synced with blockchain contractAddr common.Address // contract address - sent map[common.Address]*big.Int //tallies for beneficiarys + sent map[common.Address]*big.Int //tallies for beneficiaries txhash string // tx hash of last deposit tx threshold *big.Int // threshold that triggers autodeposit if not nil buffer *big.Int // buffer to keep on top of balance for fork protection - log log.Logger // contextual logger with the contrac address embedded + log log.Logger // contextual logger with the contract address embedded } func (self *Chequebook) String() string { @@ -442,7 +442,7 @@ type Inbox struct { maxUncashed *big.Int // threshold that triggers autocashing cashed *big.Int // cumulative amount cashed cheque *Cheque // last cheque, nil if none yet received - log log.Logger // contextual logger with the contrac address embedded + log log.Logger // contextual logger with the contract address embedded } // NewInbox creates an Inbox. An Inboxes is not persisted, the cumulative sum is updated @@ -509,9 +509,8 @@ func (self *Inbox) AutoCash(cashInterval time.Duration, maxUncashed *big.Int) { self.autoCash(cashInterval) } -// autoCash starts a loop that periodically clears the last check +// autoCash starts a loop that periodically clears the last cheque // if the peer is trusted. Clearing period could be 24h or a week. -// // The caller must hold self.lock. func (self *Inbox) autoCash(cashInterval time.Duration) { if self.quit != nil { @@ -557,10 +556,10 @@ func (self *Inbox) Receive(promise swap.Promise) (*big.Int, error) { var sum *big.Int if self.cheque == nil { - // the sum is checked against the blockchain once a check is received + // the sum is checked against the blockchain once a cheque is received tally, err := self.session.Sent(self.beneficiary) if err != nil { - return nil, fmt.Errorf("inbox: error calling backend to set amount: %v", err) + return nil, fmt.Errorf("inbox: error calling backend to set amount: %v", err) } sum = tally } else { diff --git a/vendor/github.com/ethereum/go-ethereum/contracts/ens/README.md b/vendor/github.com/ethereum/go-ethereum/contracts/ens/README.md new file mode 100644 index 000000000..c09b47e39 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/contracts/ens/README.md @@ -0,0 +1,20 @@ +# Swarm ENS interface + +## Usage + +Full documentation for the Ethereum Name Service [can be found as EIP 137](https://github.com/ethereum/EIPs/issues/137). +This package offers a simple binding that streamlines the registration of arbitrary UTF8 domain names to swarm content hashes. + +## Development + +The SOL file in contract subdirectory implements the ENS root registry, a simple +first-in, first-served registrar for the root namespace, and a simple resolver contract; +they're used in tests, and can be used to deploy these contracts for your own purposes. + +The solidity source code can be found at [github.com/arachnid/ens/](https://github.com/arachnid/ens/). + +The go bindings for ENS contracts are generated using `abigen` via the go generator: + +```shell +go generate ./contracts/ens +``` diff --git a/vendor/github.com/ethereum/go-ethereum/contracts/ens/ens.go b/vendor/github.com/ethereum/go-ethereum/contracts/ens/ens.go index 7806742cf..c292a1714 100644 --- a/vendor/github.com/ethereum/go-ethereum/contracts/ens/ens.go +++ b/vendor/github.com/ethereum/go-ethereum/contracts/ens/ens.go @@ -29,6 +29,11 @@ import ( "github.com/ethereum/go-ethereum/crypto" ) +var ( + MainNetAddress = common.HexToAddress("0x314159265dD8dbb310642f98f50C066173C1259b") + TestNetAddress = common.HexToAddress("0x112234455c3a32fd11230c42e7bccd4a84e02010") +) + // swarm domain name registry and resolver type ENS struct { *contract.ENSSession @@ -52,7 +57,7 @@ func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contra }, nil } -// DeployENS deploys an instance of the ENS nameservice, with a 'first in first served' root registrar. +// DeployENS deploys an instance of the ENS nameservice, with a 'first-in, first-served' root registrar. func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (*ENS, error) { // Deploy the ENS registry ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend, transactOpts.From) diff --git a/vendor/github.com/ethereum/go-ethereum/core/.gitignore b/vendor/github.com/ethereum/go-ethereum/core/.gitignore new file mode 100644 index 000000000..f725d58d1 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/core/.gitignore @@ -0,0 +1,12 @@ +# See http://help.github.com/ignore-files/ for more about ignoring files. +# +# If you find yourself ignoring temporary files generated by your text editor +# or operating system, you probably want to add a global ignore instead: +# git config --global core.excludesfile ~/.gitignore_global + +/tmp +*/**/*un~ +*un~ +.DS_Store +*/**/.DS_Store + diff --git a/vendor/github.com/ethereum/go-ethereum/core/block_validator.go b/vendor/github.com/ethereum/go-ethereum/core/block_validator.go index 4f85df007..e9cfd0482 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/block_validator.go +++ b/vendor/github.com/ethereum/go-ethereum/core/block_validator.go @@ -52,16 +52,10 @@ func NewBlockValidator(config *params.ChainConfig, blockchain *BlockChain, engin // validated at this point. func (v *BlockValidator) ValidateBody(block *types.Block) error { // Check whether the block's known, and if not, that it's linkable - if v.bc.HasBlock(block.Hash()) { - if _, err := state.New(block.Root(), v.bc.chainDb); err == nil { - return ErrKnownBlock - } + if v.bc.HasBlockAndState(block.Hash()) { + return ErrKnownBlock } - parent := v.bc.GetBlock(block.ParentHash(), block.NumberU64()-1) - if parent == nil { - return consensus.ErrUnknownAncestor - } - if _, err := state.New(parent.Root(), v.bc.chainDb); err != nil { + if !v.bc.HasBlockAndState(block.ParentHash()) { return consensus.ErrUnknownAncestor } // Header validity is known at this point, check the uncles and transactions diff --git a/vendor/github.com/ethereum/go-ethereum/core/blockchain.go b/vendor/github.com/ethereum/go-ethereum/core/blockchain.go index cab923bca..6772ea284 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/blockchain.go +++ b/vendor/github.com/ethereum/go-ethereum/core/blockchain.go @@ -56,10 +56,10 @@ const ( blockCacheLimit = 256 maxFutureBlocks = 256 maxTimeFutureBlocks = 30 - // must be bumped when consensus algorithm is changed, this forces the upgradedb - // command to be run (forces the blocks to be imported again using the new algorithm) + badBlockLimit = 10 + + // BlockChainVersion ensures that an incompatible database forces a resync from scratch. BlockChainVersion = 3 - badBlockLimit = 10 ) // BlockChain represents the canonical chain given a database with a genesis @@ -92,7 +92,7 @@ type BlockChain struct { currentBlock *types.Block // Current head of the block chain currentFastBlock *types.Block // Current head of the fast-sync chain (may be above the block chain!) - stateCache *state.StateDB // State database to reuse between imports (contains state cache) + stateCache state.Database // State database to reuse between imports (contains state cache) bodyCache *lru.Cache // Cache for the most recent block bodies bodyRLPCache *lru.Cache // Cache for the most recent block bodies in RLP encoded format blockCache *lru.Cache // Cache for the most recent entire blocks @@ -125,6 +125,7 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine co bc := &BlockChain{ config: config, chainDb: chainDb, + stateCache: state.NewDatabase(chainDb), eventMux: mux, quit: make(chan struct{}), bodyCache: bodyCache, @@ -168,67 +169,61 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, engine co return bc, nil } -func (self *BlockChain) getProcInterrupt() bool { - return atomic.LoadInt32(&self.procInterrupt) == 1 +func (bc *BlockChain) getProcInterrupt() bool { + return atomic.LoadInt32(&bc.procInterrupt) == 1 } // loadLastState loads the last known chain state from the database. This method // assumes that the chain manager mutex is held. -func (self *BlockChain) loadLastState() error { +func (bc *BlockChain) loadLastState() error { // Restore the last known head block - head := GetHeadBlockHash(self.chainDb) + head := GetHeadBlockHash(bc.chainDb) if head == (common.Hash{}) { // Corrupt or empty database, init from scratch log.Warn("Empty database, resetting chain") - return self.Reset() + return bc.Reset() } // Make sure the entire head block is available - currentBlock := self.GetBlockByHash(head) + currentBlock := bc.GetBlockByHash(head) if currentBlock == nil { // Corrupt or empty database, init from scratch log.Warn("Head block missing, resetting chain", "hash", head) - return self.Reset() + return bc.Reset() } // Make sure the state associated with the block is available - if _, err := state.New(currentBlock.Root(), self.chainDb); err != nil { + if _, err := state.New(currentBlock.Root(), bc.stateCache); err != nil { // Dangling block without a state associated, init from scratch log.Warn("Head state missing, resetting chain", "number", currentBlock.Number(), "hash", currentBlock.Hash()) - return self.Reset() + return bc.Reset() } // Everything seems to be fine, set as the head block - self.currentBlock = currentBlock + bc.currentBlock = currentBlock // Restore the last known head header - currentHeader := self.currentBlock.Header() - if head := GetHeadHeaderHash(self.chainDb); head != (common.Hash{}) { - if header := self.GetHeaderByHash(head); header != nil { + currentHeader := bc.currentBlock.Header() + if head := GetHeadHeaderHash(bc.chainDb); head != (common.Hash{}) { + if header := bc.GetHeaderByHash(head); header != nil { currentHeader = header } } - self.hc.SetCurrentHeader(currentHeader) + bc.hc.SetCurrentHeader(currentHeader) // Restore the last known head fast block - self.currentFastBlock = self.currentBlock - if head := GetHeadFastBlockHash(self.chainDb); head != (common.Hash{}) { - if block := self.GetBlockByHash(head); block != nil { - self.currentFastBlock = block + bc.currentFastBlock = bc.currentBlock + if head := GetHeadFastBlockHash(bc.chainDb); head != (common.Hash{}) { + if block := bc.GetBlockByHash(head); block != nil { + bc.currentFastBlock = block } } - // Initialize a statedb cache to ensure singleton account bloom filter generation - statedb, err := state.New(self.currentBlock.Root(), self.chainDb) - if err != nil { - return err - } - self.stateCache = statedb // Issue a status log for the user - headerTd := self.GetTd(currentHeader.Hash(), currentHeader.Number.Uint64()) - blockTd := self.GetTd(self.currentBlock.Hash(), self.currentBlock.NumberU64()) - fastTd := self.GetTd(self.currentFastBlock.Hash(), self.currentFastBlock.NumberU64()) + headerTd := bc.GetTd(currentHeader.Hash(), currentHeader.Number.Uint64()) + blockTd := bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64()) + fastTd := bc.GetTd(bc.currentFastBlock.Hash(), bc.currentFastBlock.NumberU64()) log.Info("Loaded most recent local header", "number", currentHeader.Number, "hash", currentHeader.Hash(), "td", headerTd) - log.Info("Loaded most recent local full block", "number", self.currentBlock.Number(), "hash", self.currentBlock.Hash(), "td", blockTd) - log.Info("Loaded most recent local fast block", "number", self.currentFastBlock.Number(), "hash", self.currentFastBlock.Hash(), "td", fastTd) + log.Info("Loaded most recent local full block", "number", bc.currentBlock.Number(), "hash", bc.currentBlock.Hash(), "td", blockTd) + log.Info("Loaded most recent local fast block", "number", bc.currentFastBlock.Number(), "hash", bc.currentFastBlock.Hash(), "td", fastTd) return nil } @@ -261,7 +256,7 @@ func (bc *BlockChain) SetHead(head uint64) error { bc.currentBlock = bc.GetBlock(currentHeader.Hash(), currentHeader.Number.Uint64()) } if bc.currentBlock != nil { - if _, err := state.New(bc.currentBlock.Root(), bc.chainDb); err != nil { + if _, err := state.New(bc.currentBlock.Root(), bc.stateCache); err != nil { // Rewound state missing, rolled back to before pivot, reset to genesis bc.currentBlock = nil } @@ -288,103 +283,103 @@ func (bc *BlockChain) SetHead(head uint64) error { // FastSyncCommitHead sets the current head block to the one defined by the hash // irrelevant what the chain contents were prior. -func (self *BlockChain) FastSyncCommitHead(hash common.Hash) error { +func (bc *BlockChain) FastSyncCommitHead(hash common.Hash) error { // Make sure that both the block as well at its state trie exists - block := self.GetBlockByHash(hash) + block := bc.GetBlockByHash(hash) if block == nil { return fmt.Errorf("non existent block [%x…]", hash[:4]) } - if _, err := trie.NewSecure(block.Root(), self.chainDb, 0); err != nil { + if _, err := trie.NewSecure(block.Root(), bc.chainDb, 0); err != nil { return err } // If all checks out, manually set the head block - self.mu.Lock() - self.currentBlock = block - self.mu.Unlock() + bc.mu.Lock() + bc.currentBlock = block + bc.mu.Unlock() log.Info("Committed new head block", "number", block.Number(), "hash", hash) return nil } // GasLimit returns the gas limit of the current HEAD block. -func (self *BlockChain) GasLimit() *big.Int { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) GasLimit() *big.Int { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.currentBlock.GasLimit() + return bc.currentBlock.GasLimit() } // LastBlockHash return the hash of the HEAD block. -func (self *BlockChain) LastBlockHash() common.Hash { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) LastBlockHash() common.Hash { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.currentBlock.Hash() + return bc.currentBlock.Hash() } // CurrentBlock retrieves the current head block of the canonical chain. The // block is retrieved from the blockchain's internal cache. -func (self *BlockChain) CurrentBlock() *types.Block { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) CurrentBlock() *types.Block { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.currentBlock + return bc.currentBlock } // CurrentFastBlock retrieves the current fast-sync head block of the canonical // chain. The block is retrieved from the blockchain's internal cache. -func (self *BlockChain) CurrentFastBlock() *types.Block { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) CurrentFastBlock() *types.Block { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.currentFastBlock + return bc.currentFastBlock } // Status returns status information about the current chain such as the HEAD Td, // the HEAD hash and the hash of the genesis block. -func (self *BlockChain) Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash) { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) Status() (td *big.Int, currentBlock common.Hash, genesisBlock common.Hash) { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.GetTd(self.currentBlock.Hash(), self.currentBlock.NumberU64()), self.currentBlock.Hash(), self.genesisBlock.Hash() + return bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64()), bc.currentBlock.Hash(), bc.genesisBlock.Hash() } // SetProcessor sets the processor required for making state modifications. -func (self *BlockChain) SetProcessor(processor Processor) { - self.procmu.Lock() - defer self.procmu.Unlock() - self.processor = processor +func (bc *BlockChain) SetProcessor(processor Processor) { + bc.procmu.Lock() + defer bc.procmu.Unlock() + bc.processor = processor } // SetValidator sets the validator which is used to validate incoming blocks. -func (self *BlockChain) SetValidator(validator Validator) { - self.procmu.Lock() - defer self.procmu.Unlock() - self.validator = validator +func (bc *BlockChain) SetValidator(validator Validator) { + bc.procmu.Lock() + defer bc.procmu.Unlock() + bc.validator = validator } // Validator returns the current validator. -func (self *BlockChain) Validator() Validator { - self.procmu.RLock() - defer self.procmu.RUnlock() - return self.validator +func (bc *BlockChain) Validator() Validator { + bc.procmu.RLock() + defer bc.procmu.RUnlock() + return bc.validator } // Processor returns the current processor. -func (self *BlockChain) Processor() Processor { - self.procmu.RLock() - defer self.procmu.RUnlock() - return self.processor +func (bc *BlockChain) Processor() Processor { + bc.procmu.RLock() + defer bc.procmu.RUnlock() + return bc.processor } // State returns a new mutable state based on the current HEAD block. -func (self *BlockChain) State() (*state.StateDB, error) { - return self.StateAt(self.CurrentBlock().Root()) +func (bc *BlockChain) State() (*state.StateDB, error) { + return bc.StateAt(bc.CurrentBlock().Root()) } // StateAt returns a new mutable state based on a particular point in time. -func (self *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) { - return self.stateCache.New(root) +func (bc *BlockChain) StateAt(root common.Hash) (*state.StateDB, error) { + return state.New(root, bc.stateCache) } // Reset purges the entire blockchain, restoring it to its genesis state. @@ -420,14 +415,14 @@ func (bc *BlockChain) ResetWithGenesisBlock(genesis *types.Block) error { } // Export writes the active chain to the given writer. -func (self *BlockChain) Export(w io.Writer) error { - return self.ExportN(w, uint64(0), self.currentBlock.NumberU64()) +func (bc *BlockChain) Export(w io.Writer) error { + return bc.ExportN(w, uint64(0), bc.currentBlock.NumberU64()) } // ExportN writes a subset of the active chain to the given writer. -func (self *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error { + bc.mu.RLock() + defer bc.mu.RUnlock() if first > last { return fmt.Errorf("export failed: first (%d) is greater than last (%d)", first, last) @@ -435,7 +430,7 @@ func (self *BlockChain) ExportN(w io.Writer, first uint64, last uint64) error { log.Info("Exporting batch of blocks", "count", last-first+1) for nr := first; nr <= last; nr++ { - block := self.GetBlockByNumber(nr) + block := bc.GetBlockByNumber(nr) if block == nil { return fmt.Errorf("export failed on #%d: not found", nr) } @@ -478,41 +473,41 @@ func (bc *BlockChain) insert(block *types.Block) { } } -// Accessors +// Genesis retrieves the chain's genesis block. func (bc *BlockChain) Genesis() *types.Block { return bc.genesisBlock } // GetBody retrieves a block body (transactions and uncles) from the database by // hash, caching it if found. -func (self *BlockChain) GetBody(hash common.Hash) *types.Body { +func (bc *BlockChain) GetBody(hash common.Hash) *types.Body { // Short circuit if the body's already in the cache, retrieve otherwise - if cached, ok := self.bodyCache.Get(hash); ok { + if cached, ok := bc.bodyCache.Get(hash); ok { body := cached.(*types.Body) return body } - body := GetBody(self.chainDb, hash, self.hc.GetBlockNumber(hash)) + body := GetBody(bc.chainDb, hash, bc.hc.GetBlockNumber(hash)) if body == nil { return nil } // Cache the found body for next time and return - self.bodyCache.Add(hash, body) + bc.bodyCache.Add(hash, body) return body } // GetBodyRLP retrieves a block body in RLP encoding from the database by hash, // caching it if found. -func (self *BlockChain) GetBodyRLP(hash common.Hash) rlp.RawValue { +func (bc *BlockChain) GetBodyRLP(hash common.Hash) rlp.RawValue { // Short circuit if the body's already in the cache, retrieve otherwise - if cached, ok := self.bodyRLPCache.Get(hash); ok { + if cached, ok := bc.bodyRLPCache.Get(hash); ok { return cached.(rlp.RawValue) } - body := GetBodyRLP(self.chainDb, hash, self.hc.GetBlockNumber(hash)) + body := GetBodyRLP(bc.chainDb, hash, bc.hc.GetBlockNumber(hash)) if len(body) == 0 { return nil } // Cache the found body for next time and return - self.bodyRLPCache.Add(hash, body) + bc.bodyRLPCache.Add(hash, body) return body } @@ -531,47 +526,47 @@ func (bc *BlockChain) HasBlockAndState(hash common.Hash) bool { return false } // Ensure the associated state is also present - _, err := state.New(block.Root(), bc.chainDb) + _, err := bc.stateCache.OpenTrie(block.Root()) return err == nil } // GetBlock retrieves a block from the database by hash and number, // caching it if found. -func (self *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block { +func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block { // Short circuit if the block's already in the cache, retrieve otherwise - if block, ok := self.blockCache.Get(hash); ok { + if block, ok := bc.blockCache.Get(hash); ok { return block.(*types.Block) } - block := GetBlock(self.chainDb, hash, number) + block := GetBlock(bc.chainDb, hash, number) if block == nil { return nil } // Cache the found block for next time and return - self.blockCache.Add(block.Hash(), block) + bc.blockCache.Add(block.Hash(), block) return block } // GetBlockByHash retrieves a block from the database by hash, caching it if found. -func (self *BlockChain) GetBlockByHash(hash common.Hash) *types.Block { - return self.GetBlock(hash, self.hc.GetBlockNumber(hash)) +func (bc *BlockChain) GetBlockByHash(hash common.Hash) *types.Block { + return bc.GetBlock(hash, bc.hc.GetBlockNumber(hash)) } // GetBlockByNumber retrieves a block from the database by number, caching it // (associated with its hash) if found. -func (self *BlockChain) GetBlockByNumber(number uint64) *types.Block { - hash := GetCanonicalHash(self.chainDb, number) +func (bc *BlockChain) GetBlockByNumber(number uint64) *types.Block { + hash := GetCanonicalHash(bc.chainDb, number) if hash == (common.Hash{}) { return nil } - return self.GetBlock(hash, number) + return bc.GetBlock(hash, number) } -// [deprecated by eth/62] // GetBlocksFromHash returns the block corresponding to hash and up to n-1 ancestors. -func (self *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block) { - number := self.hc.GetBlockNumber(hash) +// [deprecated by eth/62] +func (bc *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*types.Block) { + number := bc.hc.GetBlockNumber(hash) for i := 0; i < n; i++ { - block := self.GetBlock(hash, number) + block := bc.GetBlock(hash, number) if block == nil { break } @@ -584,11 +579,11 @@ func (self *BlockChain) GetBlocksFromHash(hash common.Hash, n int) (blocks []*ty // GetUnclesInChain retrieves all the uncles from a given block backwards until // a specific distance is reached. -func (self *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header { +func (bc *BlockChain) GetUnclesInChain(block *types.Block, length int) []*types.Header { uncles := []*types.Header{} for i := 0; block != nil && i < length; i++ { uncles = append(uncles, block.Uncles()...) - block = self.GetBlock(block.ParentHash(), block.NumberU64()-1) + block = bc.GetBlock(block.ParentHash(), block.NumberU64()-1) } return uncles } @@ -606,10 +601,10 @@ func (bc *BlockChain) Stop() { log.Info("Blockchain manager stopped") } -func (self *BlockChain) procFutureBlocks() { - blocks := make([]*types.Block, 0, self.futureBlocks.Len()) - for _, hash := range self.futureBlocks.Keys() { - if block, exist := self.futureBlocks.Peek(hash); exist { +func (bc *BlockChain) procFutureBlocks() { + blocks := make([]*types.Block, 0, bc.futureBlocks.Len()) + for _, hash := range bc.futureBlocks.Keys() { + if block, exist := bc.futureBlocks.Peek(hash); exist { blocks = append(blocks, block.(*types.Block)) } } @@ -618,11 +613,12 @@ func (self *BlockChain) procFutureBlocks() { // Insert one by one as chain insertion needs contiguous ancestry between blocks for i := range blocks { - self.InsertChain(blocks[i : i+1]) + bc.InsertChain(blocks[i : i+1]) } } } +// WriteStatus status of write type WriteStatus byte const ( @@ -633,24 +629,24 @@ const ( // Rollback is designed to remove a chain of links from the database that aren't // certain enough to be valid. -func (self *BlockChain) Rollback(chain []common.Hash) { - self.mu.Lock() - defer self.mu.Unlock() +func (bc *BlockChain) Rollback(chain []common.Hash) { + bc.mu.Lock() + defer bc.mu.Unlock() for i := len(chain) - 1; i >= 0; i-- { hash := chain[i] - currentHeader := self.hc.CurrentHeader() + currentHeader := bc.hc.CurrentHeader() if currentHeader.Hash() == hash { - self.hc.SetCurrentHeader(self.GetHeader(currentHeader.ParentHash, currentHeader.Number.Uint64()-1)) + bc.hc.SetCurrentHeader(bc.GetHeader(currentHeader.ParentHash, currentHeader.Number.Uint64()-1)) } - if self.currentFastBlock.Hash() == hash { - self.currentFastBlock = self.GetBlock(self.currentFastBlock.ParentHash(), self.currentFastBlock.NumberU64()-1) - WriteHeadFastBlockHash(self.chainDb, self.currentFastBlock.Hash()) + if bc.currentFastBlock.Hash() == hash { + bc.currentFastBlock = bc.GetBlock(bc.currentFastBlock.ParentHash(), bc.currentFastBlock.NumberU64()-1) + WriteHeadFastBlockHash(bc.chainDb, bc.currentFastBlock.Hash()) } - if self.currentBlock.Hash() == hash { - self.currentBlock = self.GetBlock(self.currentBlock.ParentHash(), self.currentBlock.NumberU64()-1) - WriteHeadBlockHash(self.chainDb, self.currentBlock.Hash()) + if bc.currentBlock.Hash() == hash { + bc.currentBlock = bc.GetBlock(bc.currentBlock.ParentHash(), bc.currentBlock.NumberU64()-1) + WriteHeadBlockHash(bc.chainDb, bc.currentBlock.Hash()) } } } @@ -665,10 +661,11 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty // The transaction hash can be retrieved from the transaction itself receipts[j].TxHash = transactions[j].Hash() - tx, _ := transactions[j].AsMessage(signer) // The contract address can be derived from the transaction itself - if MessageCreatesContract(tx) { - receipts[j].ContractAddress = crypto.CreateAddress(tx.From(), tx.Nonce()) + if transactions[j].To() == nil { + // Deriving the signer is expensive, only do if it's actually needed + from, _ := types.Sender(signer, transactions[j]) + receipts[j].ContractAddress = crypto.CreateAddress(from, transactions[j].Nonce()) } // The used gas can be calculated based on previous receipts if j == 0 { @@ -691,7 +688,7 @@ func SetReceiptsData(config *params.ChainConfig, block *types.Block, receipts ty // InsertReceiptChain attempts to complete an already existing header chain with // transaction and receipt data. // XXX should this be moved to the test? -func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) { +func (bc *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain []types.Receipts) (int, error) { // Do a sanity check that the provided chain is actually ordered and linked for i := 1; i < len(blockChain); i++ { if blockChain[i].NumberU64() != blockChain[i-1].NumberU64()+1 || blockChain[i].ParentHash() != blockChain[i-1].Hash() { @@ -704,8 +701,8 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain } } // Pre-checks passed, start the block body and receipt imports - self.wg.Add(1) - defer self.wg.Done() + bc.wg.Add(1) + defer bc.wg.Done() // Collect some import statistics to report on stats := struct{ processed, ignored int32 }{} @@ -724,51 +721,51 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain block, receipts := blockChain[index], receiptChain[index] // Short circuit insertion if shutting down or processing failed - if atomic.LoadInt32(&self.procInterrupt) == 1 { + if atomic.LoadInt32(&bc.procInterrupt) == 1 { return } if atomic.LoadInt32(&failed) > 0 { return } // Short circuit if the owner header is unknown - if !self.HasHeader(block.Hash()) { + if !bc.HasHeader(block.Hash()) { errs[index] = fmt.Errorf("containing header #%d [%x…] unknown", block.Number(), block.Hash().Bytes()[:4]) atomic.AddInt32(&failed, 1) return } // Skip if the entire data is already known - if self.HasBlock(block.Hash()) { + if bc.HasBlock(block.Hash()) { atomic.AddInt32(&stats.ignored, 1) continue } // Compute all the non-consensus fields of the receipts - SetReceiptsData(self.config, block, receipts) + SetReceiptsData(bc.config, block, receipts) // Write all the data out into the database - if err := WriteBody(self.chainDb, block.Hash(), block.NumberU64(), block.Body()); err != nil { + if err := WriteBody(bc.chainDb, block.Hash(), block.NumberU64(), block.Body()); err != nil { errs[index] = fmt.Errorf("failed to write block body: %v", err) atomic.AddInt32(&failed, 1) log.Crit("Failed to write block body", "err", err) return } - if err := WriteBlockReceipts(self.chainDb, block.Hash(), block.NumberU64(), receipts); err != nil { + if err := WriteBlockReceipts(bc.chainDb, block.Hash(), block.NumberU64(), receipts); err != nil { errs[index] = fmt.Errorf("failed to write block receipts: %v", err) atomic.AddInt32(&failed, 1) log.Crit("Failed to write block receipts", "err", err) return } - if err := WriteMipmapBloom(self.chainDb, block.NumberU64(), receipts); err != nil { + if err := WriteMipmapBloom(bc.chainDb, block.NumberU64(), receipts); err != nil { errs[index] = fmt.Errorf("failed to write log blooms: %v", err) atomic.AddInt32(&failed, 1) log.Crit("Failed to write log blooms", "err", err) return } - if err := WriteTransactions(self.chainDb, block); err != nil { + if err := WriteTransactions(bc.chainDb, block); err != nil { errs[index] = fmt.Errorf("failed to write individual transactions: %v", err) atomic.AddInt32(&failed, 1) log.Crit("Failed to write individual transactions", "err", err) return } - if err := WriteReceipts(self.chainDb, receipts); err != nil { + if err := WriteReceipts(bc.chainDb, receipts); err != nil { errs[index] = fmt.Errorf("failed to write individual receipts: %v", err) atomic.AddInt32(&failed, 1) log.Crit("Failed to write individual receipts", "err", err) @@ -796,23 +793,23 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain } } } - if atomic.LoadInt32(&self.procInterrupt) == 1 { + if atomic.LoadInt32(&bc.procInterrupt) == 1 { log.Debug("Premature abort during receipts processing") return 0, nil } // Update the head fast sync block if better - self.mu.Lock() + bc.mu.Lock() head := blockChain[len(errs)-1] - if td := self.GetTd(head.Hash(), head.NumberU64()); td != nil { // Rewind may have occurred, skip in that case - if self.GetTd(self.currentFastBlock.Hash(), self.currentFastBlock.NumberU64()).Cmp(td) < 0 { - if err := WriteHeadFastBlockHash(self.chainDb, head.Hash()); err != nil { + if td := bc.GetTd(head.Hash(), head.NumberU64()); td != nil { // Rewind may have occurred, skip in that case + if bc.GetTd(bc.currentFastBlock.Hash(), bc.currentFastBlock.NumberU64()).Cmp(td) < 0 { + if err := WriteHeadFastBlockHash(bc.chainDb, head.Hash()); err != nil { log.Crit("Failed to update head fast block hash", "err", err) } - self.currentFastBlock = head + bc.currentFastBlock = head } } - self.mu.Unlock() + bc.mu.Unlock() // Report some public statistics so the user has a clue what's going on last := blockChain[len(blockChain)-1] @@ -823,27 +820,27 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain } // WriteBlock writes the block to the chain. -func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err error) { - self.wg.Add(1) - defer self.wg.Done() +func (bc *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err error) { + bc.wg.Add(1) + defer bc.wg.Done() // Calculate the total difficulty of the block - ptd := self.GetTd(block.ParentHash(), block.NumberU64()-1) + ptd := bc.GetTd(block.ParentHash(), block.NumberU64()-1) if ptd == nil { return NonStatTy, consensus.ErrUnknownAncestor } // Make sure no inconsistent state is leaked during insertion - self.mu.Lock() - defer self.mu.Unlock() + bc.mu.Lock() + defer bc.mu.Unlock() - localTd := self.GetTd(self.currentBlock.Hash(), self.currentBlock.NumberU64()) + localTd := bc.GetTd(bc.currentBlock.Hash(), bc.currentBlock.NumberU64()) externTd := new(big.Int).Add(block.Difficulty(), ptd) // Irrelevant of the canonical status, write the block itself to the database - if err := self.hc.WriteTd(block.Hash(), block.NumberU64(), externTd); err != nil { + if err := bc.hc.WriteTd(block.Hash(), block.NumberU64(), externTd); err != nil { log.Crit("Failed to write block total difficulty", "err", err) } - if err := WriteBlock(self.chainDb, block); err != nil { + if err := WriteBlock(bc.chainDb, block); err != nil { log.Crit("Failed to write block contents", "err", err) } @@ -852,25 +849,25 @@ func (self *BlockChain) WriteBlock(block *types.Block) (status WriteStatus, err // Please refer to http://www.cs.cornell.edu/~ie53/publications/btcProcFC.pdf if externTd.Cmp(localTd) > 0 || (externTd.Cmp(localTd) == 0 && mrand.Float64() < 0.5) { // Reorganise the chain if the parent is not the head block - if block.ParentHash() != self.currentBlock.Hash() { - if err := self.reorg(self.currentBlock, block); err != nil { + if block.ParentHash() != bc.currentBlock.Hash() { + if err := bc.reorg(bc.currentBlock, block); err != nil { return NonStatTy, err } } - self.insert(block) // Insert the block as the new head of the chain + bc.insert(block) // Insert the block as the new head of the chain status = CanonStatTy } else { status = SideStatTy } - self.futureBlocks.Remove(block.Hash()) + bc.futureBlocks.Remove(block.Hash()) return } // InsertChain will attempt to insert the given chain in to the canonical chain or, otherwise, create a fork. If an error is returned // it will return the index number of the failing block as well an error describing what went wrong (for possible errors see core/errors.go). -func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { +func (bc *BlockChain) InsertChain(chain types.Blocks) (int, error) { // Do a sanity check that the provided chain is actually ordered and linked for i := 1; i < len(chain); i++ { if chain[i].NumberU64() != chain[i-1].NumberU64()+1 || chain[i].ParentHash() != chain[i-1].Hash() { @@ -883,11 +880,11 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { } } // Pre-checks passed, start the full block imports - self.wg.Add(1) - defer self.wg.Done() + bc.wg.Add(1) + defer bc.wg.Done() - self.chainmu.Lock() - defer self.chainmu.Unlock() + bc.chainmu.Lock() + defer bc.chainmu.Unlock() // A queued approach to delivering events. This is generally // faster than direct delivery and requires much less mutex @@ -905,19 +902,19 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { headers[i] = block.Header() seals[i] = true } - abort, results := self.engine.VerifyHeaders(self, headers, seals) + abort, results := bc.engine.VerifyHeaders(bc, headers, seals) defer close(abort) // Iterate over the blocks and insert when the verifier permits for i, block := range chain { // If the chain is terminating, stop processing blocks - if atomic.LoadInt32(&self.procInterrupt) == 1 { + if atomic.LoadInt32(&bc.procInterrupt) == 1 { log.Debug("Premature abort during blocks processing") break } // If the header is a banned one, straight out abort if BadHashes[block.Hash()] { - self.reportBlock(block, nil, ErrBlacklistedHash) + bc.reportBlock(block, nil, ErrBlacklistedHash) return i, ErrBlacklistedHash } // Wait for the block's verification to complete @@ -925,7 +922,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { err := <-results if err == nil { - err = self.Validator().ValidateBody(block) + err = bc.Validator().ValidateBody(block) } if err != nil { if err == ErrKnownBlock { @@ -941,59 +938,58 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { if block.Time().Cmp(max) > 0 { return i, fmt.Errorf("future block: %v > %v", block.Time(), max) } - self.futureBlocks.Add(block.Hash(), block) + bc.futureBlocks.Add(block.Hash(), block) stats.queued++ continue } - if err == consensus.ErrUnknownAncestor && self.futureBlocks.Contains(block.ParentHash()) { - self.futureBlocks.Add(block.Hash(), block) + if err == consensus.ErrUnknownAncestor && bc.futureBlocks.Contains(block.ParentHash()) { + bc.futureBlocks.Add(block.Hash(), block) stats.queued++ continue } - self.reportBlock(block, nil, err) + bc.reportBlock(block, nil, err) return i, err } // Create a new statedb using the parent block and report an // error if it fails. - switch { - case i == 0: - err = self.stateCache.Reset(self.GetBlock(block.ParentHash(), block.NumberU64()-1).Root()) - default: - err = self.stateCache.Reset(chain[i-1].Root()) + var parent *types.Block + if i == 0 { + parent = bc.GetBlock(block.ParentHash(), block.NumberU64()-1) + } else { + parent = chain[i-1] } + state, err := state.New(parent.Root(), bc.stateCache) if err != nil { - self.reportBlock(block, nil, err) return i, err } // Process block using the parent state as reference point. - receipts, logs, usedGas, err := self.processor.Process(block, self.stateCache, self.vmConfig) + receipts, logs, usedGas, err := bc.processor.Process(block, state, bc.vmConfig) if err != nil { - self.reportBlock(block, receipts, err) + bc.reportBlock(block, receipts, err) return i, err } // Validate the state using the default validator - err = self.Validator().ValidateState(block, self.GetBlock(block.ParentHash(), block.NumberU64()-1), self.stateCache, receipts, usedGas) + err = bc.Validator().ValidateState(block, parent, state, receipts, usedGas) if err != nil { - self.reportBlock(block, receipts, err) + bc.reportBlock(block, receipts, err) return i, err } // Write state changes to database - _, err = self.stateCache.Commit(self.config.IsEIP158(block.Number())) - if err != nil { + if _, err = state.CommitTo(bc.chainDb, bc.config.IsEIP158(block.Number())); err != nil { return i, err } // coalesce logs for later processing coalescedLogs = append(coalescedLogs, logs...) - if err = WriteBlockReceipts(self.chainDb, block.Hash(), block.NumberU64(), receipts); err != nil { + if err = WriteBlockReceipts(bc.chainDb, block.Hash(), block.NumberU64(), receipts); err != nil { return i, err } // write the block to the chain and get the status - status, err := self.WriteBlock(block) + status, err := bc.WriteBlock(block) if err != nil { return i, err } @@ -1007,19 +1003,19 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { events = append(events, ChainEvent{block, block.Hash(), logs}) // This puts transactions in a extra db for rpc - if err := WriteTransactions(self.chainDb, block); err != nil { + if err := WriteTransactions(bc.chainDb, block); err != nil { return i, err } // store the receipts - if err := WriteReceipts(self.chainDb, receipts); err != nil { + if err := WriteReceipts(bc.chainDb, receipts); err != nil { return i, err } // Write map map bloom filters - if err := WriteMipmapBloom(self.chainDb, block.NumberU64(), receipts); err != nil { + if err := WriteMipmapBloom(bc.chainDb, block.NumberU64(), receipts); err != nil { return i, err } // Write hash preimages - if err := WritePreimages(self.chainDb, block.NumberU64(), self.stateCache.Preimages()); err != nil { + if err := WritePreimages(bc.chainDb, block.NumberU64(), state.Preimages()); err != nil { return i, err } case SideStatTy: @@ -1033,7 +1029,7 @@ func (self *BlockChain) InsertChain(chain types.Blocks) (int, error) { stats.usedGas += usedGas.Uint64() stats.report(chain, i) } - go self.postChainEvents(events, coalescedLogs) + go bc.postChainEvents(events, coalescedLogs) return 0, nil } @@ -1077,7 +1073,7 @@ func (st *insertStats) report(chain []*types.Block, index int) { } log.Info("Imported new chain segment", context...) - *st = insertStats{startTime: now, lastIndex: index} + *st = insertStats{startTime: now, lastIndex: index + 1} } } @@ -1091,7 +1087,7 @@ func countTransactions(chain []*types.Block) (c int) { // reorgs takes two blocks, an old chain and a new chain and will reconstruct the blocks and inserts them // to be part of the new canonical chain and accumulates potential missing transactions and post an // event about them -func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { +func (bc *BlockChain) reorg(oldBlock, newBlock *types.Block) error { var ( newChain types.Blocks oldChain types.Blocks @@ -1103,7 +1099,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { // These logs are later announced as deleted. collectLogs = func(h common.Hash) { // Coalesce logs and set 'Removed'. - receipts := GetBlockReceipts(self.chainDb, h, self.hc.GetBlockNumber(h)) + receipts := GetBlockReceipts(bc.chainDb, h, bc.hc.GetBlockNumber(h)) for _, receipt := range receipts { for _, log := range receipt.Logs { del := *log @@ -1117,7 +1113,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { // first reduce whoever is higher bound if oldBlock.NumberU64() > newBlock.NumberU64() { // reduce old chain - for ; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = self.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1) { + for ; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1) { oldChain = append(oldChain, oldBlock) deletedTxs = append(deletedTxs, oldBlock.Transactions()...) @@ -1125,7 +1121,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { } } else { // reduce new chain and append new chain blocks for inserting later on - for ; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = self.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) { + for ; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) { newChain = append(newChain, newBlock) } } @@ -1147,7 +1143,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { deletedTxs = append(deletedTxs, oldBlock.Transactions()...) collectLogs(oldBlock.Hash()) - oldBlock, newBlock = self.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1), self.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) + oldBlock, newBlock = bc.GetBlock(oldBlock.ParentHash(), oldBlock.NumberU64()-1), bc.GetBlock(newBlock.ParentHash(), newBlock.NumberU64()-1) if oldBlock == nil { return fmt.Errorf("Invalid old chain") } @@ -1170,18 +1166,18 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { // insert blocks. Order does not matter. Last block will be written in ImportChain itself which creates the new head properly for _, block := range newChain { // insert the block in the canonical way, re-writing history - self.insert(block) + bc.insert(block) // write canonical receipts and transactions - if err := WriteTransactions(self.chainDb, block); err != nil { + if err := WriteTransactions(bc.chainDb, block); err != nil { return err } - receipts := GetBlockReceipts(self.chainDb, block.Hash(), block.NumberU64()) + receipts := GetBlockReceipts(bc.chainDb, block.Hash(), block.NumberU64()) // write receipts - if err := WriteReceipts(self.chainDb, receipts); err != nil { + if err := WriteReceipts(bc.chainDb, receipts); err != nil { return err } // Write map map bloom filters - if err := WriteMipmapBloom(self.chainDb, block.NumberU64(), receipts); err != nil { + if err := WriteMipmapBloom(bc.chainDb, block.NumberU64(), receipts); err != nil { return err } addedTxs = append(addedTxs, block.Transactions()...) @@ -1192,22 +1188,22 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { // When transactions get deleted from the database that means the // receipts that were created in the fork must also be deleted for _, tx := range diff { - DeleteReceipt(self.chainDb, tx.Hash()) - DeleteTransaction(self.chainDb, tx.Hash()) + DeleteReceipt(bc.chainDb, tx.Hash()) + DeleteTransaction(bc.chainDb, tx.Hash()) } // Must be posted in a goroutine because of the transaction pool trying // to acquire the chain manager lock if len(diff) > 0 { - go self.eventMux.Post(RemovedTransactionEvent{diff}) + go bc.eventMux.Post(RemovedTransactionEvent{diff}) } if len(deletedLogs) > 0 { - go self.eventMux.Post(RemovedLogsEvent{deletedLogs}) + go bc.eventMux.Post(RemovedLogsEvent{deletedLogs}) } if len(oldChain) > 0 { go func() { for _, block := range oldChain { - self.eventMux.Post(ChainSideEvent{Block: block}) + bc.eventMux.Post(ChainSideEvent{Block: block}) } }() } @@ -1217,30 +1213,30 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error { // postChainEvents iterates over the events generated by a chain insertion and // posts them into the event mux. -func (self *BlockChain) postChainEvents(events []interface{}, logs []*types.Log) { +func (bc *BlockChain) postChainEvents(events []interface{}, logs []*types.Log) { // post event logs for further processing - self.eventMux.Post(logs) + bc.eventMux.Post(logs) for _, event := range events { if event, ok := event.(ChainEvent); ok { // We need some control over the mining operation. Acquiring locks and waiting // for the miner to create new block takes too long and in most cases isn't // even necessary. - if self.LastBlockHash() == event.Hash { - self.eventMux.Post(ChainHeadEvent{event.Block}) + if bc.LastBlockHash() == event.Hash { + bc.eventMux.Post(ChainHeadEvent{event.Block}) } } // Fire the insertion events individually too - self.eventMux.Post(event) + bc.eventMux.Post(event) } } -func (self *BlockChain) update() { +func (bc *BlockChain) update() { futureTimer := time.Tick(5 * time.Second) for { select { case <-futureTimer: - self.procFutureBlocks() - case <-self.quit: + bc.procFutureBlocks() + case <-bc.quit: return } } @@ -1298,28 +1294,28 @@ Error: %v // should be done or not. The reason behind the optional check is because some // of the header retrieval mechanisms already need to verify nonces, as well as // because nonces can be verified sparsely, not needing to check each. -func (self *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) { +func (bc *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) (int, error) { start := time.Now() - if i, err := self.hc.ValidateHeaderChain(chain, checkFreq); err != nil { + if i, err := bc.hc.ValidateHeaderChain(chain, checkFreq); err != nil { return i, err } // Make sure only one thread manipulates the chain at once - self.chainmu.Lock() - defer self.chainmu.Unlock() + bc.chainmu.Lock() + defer bc.chainmu.Unlock() - self.wg.Add(1) - defer self.wg.Done() + bc.wg.Add(1) + defer bc.wg.Done() whFunc := func(header *types.Header) error { - self.mu.Lock() - defer self.mu.Unlock() + bc.mu.Lock() + defer bc.mu.Unlock() - _, err := self.hc.WriteHeader(header) + _, err := bc.hc.WriteHeader(header) return err } - return self.hc.InsertHeaderChain(chain, whFunc, start) + return bc.hc.InsertHeaderChain(chain, whFunc, start) } // writeHeader writes a header into the local chain, given that its parent is @@ -1331,48 +1327,48 @@ func (self *BlockChain) InsertHeaderChain(chain []*types.Header, checkFreq int) // without the real blocks. Hence, writing headers directly should only be done // in two scenarios: pure-header mode of operation (light clients), or properly // separated header/block phases (non-archive clients). -func (self *BlockChain) writeHeader(header *types.Header) error { - self.wg.Add(1) - defer self.wg.Done() +func (bc *BlockChain) writeHeader(header *types.Header) error { + bc.wg.Add(1) + defer bc.wg.Done() - self.mu.Lock() - defer self.mu.Unlock() + bc.mu.Lock() + defer bc.mu.Unlock() - _, err := self.hc.WriteHeader(header) + _, err := bc.hc.WriteHeader(header) return err } // CurrentHeader retrieves the current head header of the canonical chain. The // header is retrieved from the HeaderChain's internal cache. -func (self *BlockChain) CurrentHeader() *types.Header { - self.mu.RLock() - defer self.mu.RUnlock() +func (bc *BlockChain) CurrentHeader() *types.Header { + bc.mu.RLock() + defer bc.mu.RUnlock() - return self.hc.CurrentHeader() + return bc.hc.CurrentHeader() } // GetTd retrieves a block's total difficulty in the canonical chain from the // database by hash and number, caching it if found. -func (self *BlockChain) GetTd(hash common.Hash, number uint64) *big.Int { - return self.hc.GetTd(hash, number) +func (bc *BlockChain) GetTd(hash common.Hash, number uint64) *big.Int { + return bc.hc.GetTd(hash, number) } // GetTdByHash retrieves a block's total difficulty in the canonical chain from the // database by hash, caching it if found. -func (self *BlockChain) GetTdByHash(hash common.Hash) *big.Int { - return self.hc.GetTdByHash(hash) +func (bc *BlockChain) GetTdByHash(hash common.Hash) *big.Int { + return bc.hc.GetTdByHash(hash) } // GetHeader retrieves a block header from the database by hash and number, // caching it if found. -func (self *BlockChain) GetHeader(hash common.Hash, number uint64) *types.Header { - return self.hc.GetHeader(hash, number) +func (bc *BlockChain) GetHeader(hash common.Hash, number uint64) *types.Header { + return bc.hc.GetHeader(hash, number) } // GetHeaderByHash retrieves a block header from the database by hash, caching it if // found. -func (self *BlockChain) GetHeaderByHash(hash common.Hash) *types.Header { - return self.hc.GetHeaderByHash(hash) +func (bc *BlockChain) GetHeaderByHash(hash common.Hash) *types.Header { + return bc.hc.GetHeaderByHash(hash) } // HasHeader checks if a block header is present in the database or not, caching @@ -1383,18 +1379,18 @@ func (bc *BlockChain) HasHeader(hash common.Hash) bool { // GetBlockHashesFromHash retrieves a number of block hashes starting at a given // hash, fetching towards the genesis block. -func (self *BlockChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash { - return self.hc.GetBlockHashesFromHash(hash, max) +func (bc *BlockChain) GetBlockHashesFromHash(hash common.Hash, max uint64) []common.Hash { + return bc.hc.GetBlockHashesFromHash(hash, max) } // GetHeaderByNumber retrieves a block header from the database by number, // caching it (associated with its hash) if found. -func (self *BlockChain) GetHeaderByNumber(number uint64) *types.Header { - return self.hc.GetHeaderByNumber(number) +func (bc *BlockChain) GetHeaderByNumber(number uint64) *types.Header { + return bc.hc.GetHeaderByNumber(number) } // Config retrieves the blockchain's chain configuration. -func (self *BlockChain) Config() *params.ChainConfig { return self.config } +func (bc *BlockChain) Config() *params.ChainConfig { return bc.config } // Engine retrieves the blockchain's consensus engine. -func (self *BlockChain) Engine() consensus.Engine { return self.engine } +func (bc *BlockChain) Engine() consensus.Engine { return bc.engine } diff --git a/vendor/github.com/ethereum/go-ethereum/core/blocks.go b/vendor/github.com/ethereum/go-ethereum/core/blocks.go index cf8c86507..f20ba4aaf 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/blocks.go +++ b/vendor/github.com/ethereum/go-ethereum/core/blocks.go @@ -18,7 +18,7 @@ package core import "github.com/ethereum/go-ethereum/common" -// Set of manually tracked bad hashes (usually hard forks) +// BadHashes represent a set of manually tracked bad hashes (usually hard forks) var BadHashes = map[common.Hash]bool{ common.HexToHash("05bef30ef572270f654746da22639a7a0c97dd97a7050b9e252391996aaeb689"): true, common.HexToHash("7d05d08cbc596a2e5e4f13b80a743e53e09221b5323c3a61946b20873e58583f"): true, diff --git a/vendor/github.com/ethereum/go-ethereum/core/chain_makers.go b/vendor/github.com/ethereum/go-ethereum/core/chain_makers.go index f34279ba0..38a69d42a 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/chain_makers.go +++ b/vendor/github.com/ethereum/go-ethereum/core/chain_makers.go @@ -84,7 +84,7 @@ func (b *BlockGen) AddTx(tx *types.Transaction) { if b.gasPool == nil { b.SetCoinbase(common.Address{}) } - b.statedb.StartRecord(tx.Hash(), common.Hash{}, len(b.txs)) + 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{}) if err != nil { panic(err) @@ -98,10 +98,10 @@ func (b *BlockGen) Number() *big.Int { return new(big.Int).Set(b.header.Number) } -// AddUncheckedReceipts forcefully adds a receipts to the block without a +// AddUncheckedReceipt forcefully adds a receipts to the block without a // backing transaction. // -// AddUncheckedReceipts will cause consensus failures when used during real +// AddUncheckedReceipt will cause consensus failures when used during real // chain processing. This is best used in conjunction with raw block insertion. func (b *BlockGen) AddUncheckedReceipt(receipt *types.Receipt) { b.receipts = append(b.receipts, receipt) @@ -142,7 +142,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.Time().Uint64(), b.parent.Number(), b.parent.Difficulty()) + b.header.Difficulty = ethash.CalcDifficulty(b.config, b.header.Time.Uint64(), b.parent.Header()) } // GenerateChain creates a chain of n blocks. The first block's @@ -181,7 +181,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat gen(i, b) } ethash.AccumulateRewards(statedb, h, b.uncles) - root, err := statedb.Commit(config.IsEIP158(h.Number)) + root, err := statedb.CommitTo(db, config.IsEIP158(h.Number)) if err != nil { panic(fmt.Sprintf("state write error: %v", err)) } @@ -189,7 +189,7 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, db ethdb.Dat return types.NewBlock(h, b.txs, b.uncles, b.receipts), b.receipts } for i := 0; i < n; i++ { - statedb, err := state.New(parent.Root(), db) + statedb, err := state.New(parent.Root(), state.NewDatabase(db)) if err != nil { panic(err) } @@ -209,15 +209,20 @@ func makeHeader(config *params.ChainConfig, parent *types.Block, state *state.St } else { time = new(big.Int).Add(parent.Time(), big.NewInt(10)) // block time is fixed at 10 seconds } + return &types.Header{ Root: state.IntermediateRoot(config.IsEIP158(parent.Number())), ParentHash: parent.Hash(), Coinbase: parent.Coinbase(), - Difficulty: ethash.CalcDifficulty(config, time.Uint64(), new(big.Int).Sub(time, big.NewInt(10)).Uint64(), parent.Number(), parent.Difficulty()), - GasLimit: CalcGasLimit(parent), - GasUsed: new(big.Int), - Number: new(big.Int).Add(parent.Number(), common.Big1), - Time: time, + Difficulty: ethash.CalcDifficulty(config, time.Uint64(), &types.Header{ + Number: parent.Number(), + Time: new(big.Int).Sub(time, big.NewInt(10)), + Difficulty: parent.Difficulty(), + }), + GasLimit: CalcGasLimit(parent), + GasUsed: new(big.Int), + Number: new(big.Int).Add(parent.Number(), common.Big1), + Time: time, } } diff --git a/vendor/github.com/ethereum/go-ethereum/core/database_util.go b/vendor/github.com/ethereum/go-ethereum/core/database_util.go index bcd99be5f..b4a230c9c 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/database_util.go +++ b/vendor/github.com/ethereum/go-ethereum/core/database_util.go @@ -64,7 +64,7 @@ var ( oldBlockReceiptsPrefix = []byte("receipts-block-") oldBlockHashPrefix = []byte("block-hash-") // [deprecated by the header/block split, remove eventually] - ChainConfigNotFoundErr = errors.New("ChainConfig not found") // general config not found error + ErrChainConfigNotFound = errors.New("ChainConfig not found") // general config not found error mipmapBloomMu sync.Mutex // protect against race condition when updating mipmap blooms @@ -546,7 +546,7 @@ func mipmapKey(num, level uint64) []byte { return append(mipmapPre, append(lkey, key.Bytes()...)...) } -// WriteMapmapBloom writes each address included in the receipts' logs to the +// WriteMipmapBloom writes each address included in the receipts' logs to the // MIP bloom bin. func WriteMipmapBloom(db ethdb.Database, number uint64, receipts types.Receipts) error { mipmapBloomMu.Lock() @@ -638,7 +638,7 @@ func WriteChainConfig(db ethdb.Database, hash common.Hash, cfg *params.ChainConf func GetChainConfig(db ethdb.Database, hash common.Hash) (*params.ChainConfig, error) { jsonChainConfig, _ := db.Get(append(configPrefix, hash[:]...)) if len(jsonChainConfig) == 0 { - return nil, ChainConfigNotFoundErr + return nil, ErrChainConfigNotFound } var config params.ChainConfig diff --git a/vendor/github.com/ethereum/go-ethereum/core/events.go b/vendor/github.com/ethereum/go-ethereum/core/events.go index 106b52c80..6f404f612 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/events.go +++ b/vendor/github.com/ethereum/go-ethereum/core/events.go @@ -17,8 +17,6 @@ package core import ( - "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" ) @@ -26,9 +24,6 @@ import ( // TxPreEvent is posted when a transaction enters the transaction pool. type TxPreEvent struct{ Tx *types.Transaction } -// TxPostEvent is posted when a transaction has been processed. -type TxPostEvent struct{ Tx *types.Transaction } - // PendingLogsEvent is posted pre mining and notifies of pending logs. type PendingLogsEvent struct { Logs []*types.Log @@ -43,7 +38,7 @@ type NewMinedBlockEvent struct{ Block *types.Block } // RemovedTransactionEvent is posted when a reorg happens type RemovedTransactionEvent struct{ Txs types.Transactions } -// RemovedLogEvent is posted when a reorg happens +// RemovedLogsEvent is posted when a reorg happens type RemovedLogsEvent struct{ Logs []*types.Log } type ChainEvent struct { @@ -56,19 +51,4 @@ type ChainSideEvent struct { Block *types.Block } -type PendingBlockEvent struct { - Block *types.Block - Logs []*types.Log -} - -type ChainUncleEvent struct { - Block *types.Block -} - type ChainHeadEvent struct{ Block *types.Block } - -type GasPriceChanged struct{ Price *big.Int } - -// Mining operation events -type StartMining struct{} -type TopMining struct{} diff --git a/vendor/github.com/ethereum/go-ethereum/core/fees.go b/vendor/github.com/ethereum/go-ethereum/core/fees.go index 0bb26f055..83275ea36 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/fees.go +++ b/vendor/github.com/ethereum/go-ethereum/core/fees.go @@ -20,4 +20,4 @@ import ( "math/big" ) -var BlockReward *big.Int = big.NewInt(5e+18) +var BlockReward = big.NewInt(5e+18) diff --git a/vendor/github.com/ethereum/go-ethereum/core/gen_genesis.go b/vendor/github.com/ethereum/go-ethereum/core/gen_genesis.go index 3f83905c9..1f3b4a8aa 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/gen_genesis.go +++ b/vendor/github.com/ethereum/go-ethereum/core/gen_genesis.go @@ -13,24 +13,27 @@ import ( "github.com/ethereum/go-ethereum/params" ) +var _ = (*genesisSpecMarshaling)(nil) + func (g Genesis) MarshalJSON() ([]byte, error) { type Genesis struct { Config *params.ChainConfig `json:"config"` Nonce math.HexOrDecimal64 `json:"nonce"` Timestamp math.HexOrDecimal64 `json:"timestamp"` - ParentHash common.Hash `json:"parentHash"` ExtraData hexutil.Bytes `json:"extraData"` GasLimit math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"` Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"` Mixhash common.Hash `json:"mixHash"` Coinbase common.Address `json:"coinbase"` Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"` + Number uint64 `json:"number"` + GasUsed math.HexOrDecimal64 `json:"gasUsed"` + ParentHash common.Hash `json:"parentHash"` } var enc Genesis enc.Config = g.Config enc.Nonce = math.HexOrDecimal64(g.Nonce) enc.Timestamp = math.HexOrDecimal64(g.Timestamp) - enc.ParentHash = g.ParentHash enc.ExtraData = g.ExtraData enc.GasLimit = math.HexOrDecimal64(g.GasLimit) enc.Difficulty = (*math.HexOrDecimal256)(g.Difficulty) @@ -42,6 +45,9 @@ func (g Genesis) MarshalJSON() ([]byte, error) { enc.Alloc[common.UnprefixedAddress(k)] = v } } + enc.Number = g.Number + enc.GasUsed = math.HexOrDecimal64(g.GasUsed) + enc.ParentHash = g.ParentHash return json.Marshal(&enc) } @@ -50,13 +56,15 @@ func (g *Genesis) UnmarshalJSON(input []byte) error { Config *params.ChainConfig `json:"config"` Nonce *math.HexOrDecimal64 `json:"nonce"` Timestamp *math.HexOrDecimal64 `json:"timestamp"` - ParentHash *common.Hash `json:"parentHash"` ExtraData hexutil.Bytes `json:"extraData"` GasLimit *math.HexOrDecimal64 `json:"gasLimit" gencodec:"required"` Difficulty *math.HexOrDecimal256 `json:"difficulty" gencodec:"required"` Mixhash *common.Hash `json:"mixHash"` Coinbase *common.Address `json:"coinbase"` Alloc map[common.UnprefixedAddress]GenesisAccount `json:"alloc" gencodec:"required"` + Number *uint64 `json:"number"` + GasUsed *math.HexOrDecimal64 `json:"gasUsed"` + ParentHash *common.Hash `json:"parentHash"` } var dec Genesis if err := json.Unmarshal(input, &dec); err != nil { @@ -71,9 +79,6 @@ func (g *Genesis) UnmarshalJSON(input []byte) error { if dec.Timestamp != nil { g.Timestamp = uint64(*dec.Timestamp) } - if dec.ParentHash != nil { - g.ParentHash = *dec.ParentHash - } if dec.ExtraData != nil { g.ExtraData = dec.ExtraData } @@ -98,5 +103,14 @@ func (g *Genesis) UnmarshalJSON(input []byte) error { for k, v := range dec.Alloc { g.Alloc[common.Address(k)] = v } + if dec.Number != nil { + g.Number = *dec.Number + } + if dec.GasUsed != nil { + g.GasUsed = uint64(*dec.GasUsed) + } + if dec.ParentHash != nil { + g.ParentHash = *dec.ParentHash + } return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/core/gen_genesis_account.go b/vendor/github.com/ethereum/go-ethereum/core/gen_genesis_account.go index bc5fc936b..15c9565a2 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/gen_genesis_account.go +++ b/vendor/github.com/ethereum/go-ethereum/core/gen_genesis_account.go @@ -12,27 +12,37 @@ import ( "github.com/ethereum/go-ethereum/common/math" ) +var _ = (*genesisAccountMarshaling)(nil) + func (g GenesisAccount) MarshalJSON() ([]byte, error) { type GenesisAccount struct { - Code hexutil.Bytes `json:"code,omitempty"` - Storage map[common.Hash]common.Hash `json:"storage,omitempty"` - Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"` - Nonce math.HexOrDecimal64 `json:"nonce,omitempty"` + Code hexutil.Bytes `json:"code,omitempty"` + Storage map[storageJSON]storageJSON `json:"storage,omitempty"` + Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"` + Nonce math.HexOrDecimal64 `json:"nonce,omitempty"` + PrivateKey hexutil.Bytes `json:"secretKey,omitempty"` } var enc GenesisAccount enc.Code = g.Code - enc.Storage = g.Storage + if g.Storage != nil { + enc.Storage = make(map[storageJSON]storageJSON, len(g.Storage)) + for k, v := range g.Storage { + enc.Storage[storageJSON(k)] = storageJSON(v) + } + } enc.Balance = (*math.HexOrDecimal256)(g.Balance) enc.Nonce = math.HexOrDecimal64(g.Nonce) + enc.PrivateKey = g.PrivateKey return json.Marshal(&enc) } func (g *GenesisAccount) UnmarshalJSON(input []byte) error { type GenesisAccount struct { - Code hexutil.Bytes `json:"code,omitempty"` - Storage map[common.Hash]common.Hash `json:"storage,omitempty"` - Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"` - Nonce *math.HexOrDecimal64 `json:"nonce,omitempty"` + Code hexutil.Bytes `json:"code,omitempty"` + Storage map[storageJSON]storageJSON `json:"storage,omitempty"` + Balance *math.HexOrDecimal256 `json:"balance" gencodec:"required"` + Nonce *math.HexOrDecimal64 `json:"nonce,omitempty"` + PrivateKey hexutil.Bytes `json:"secretKey,omitempty"` } var dec GenesisAccount if err := json.Unmarshal(input, &dec); err != nil { @@ -42,7 +52,10 @@ func (g *GenesisAccount) UnmarshalJSON(input []byte) error { g.Code = dec.Code } if dec.Storage != nil { - g.Storage = dec.Storage + g.Storage = make(map[common.Hash]common.Hash, len(dec.Storage)) + for k, v := range dec.Storage { + g.Storage[common.Hash(k)] = common.Hash(v) + } } if dec.Balance == nil { return errors.New("missing required field 'balance' for GenesisAccount") @@ -51,5 +64,8 @@ func (g *GenesisAccount) UnmarshalJSON(input []byte) error { if dec.Nonce != nil { g.Nonce = uint64(*dec.Nonce) } + if dec.PrivateKey != nil { + g.PrivateKey = dec.PrivateKey + } return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/core/genesis.go b/vendor/github.com/ethereum/go-ethereum/core/genesis.go index 8f55d3a37..a507d522b 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/genesis.go +++ b/vendor/github.com/ethereum/go-ethereum/core/genesis.go @@ -17,6 +17,9 @@ package core import ( + "bytes" + "encoding/hex" + "encoding/json" "errors" "fmt" "math/big" @@ -44,24 +47,42 @@ type Genesis struct { Config *params.ChainConfig `json:"config"` Nonce uint64 `json:"nonce"` Timestamp uint64 `json:"timestamp"` - ParentHash common.Hash `json:"parentHash"` ExtraData []byte `json:"extraData"` GasLimit uint64 `json:"gasLimit" gencodec:"required"` Difficulty *big.Int `json:"difficulty" gencodec:"required"` Mixhash common.Hash `json:"mixHash"` Coinbase common.Address `json:"coinbase"` Alloc GenesisAlloc `json:"alloc" gencodec:"required"` + + // These fields are used for consensus tests. Please don't use them + // in actual genesis blocks. + Number uint64 `json:"number"` + GasUsed uint64 `json:"gasUsed"` + ParentHash common.Hash `json:"parentHash"` } // GenesisAlloc specifies the initial state that is part of the genesis block. type GenesisAlloc map[common.Address]GenesisAccount +func (ga *GenesisAlloc) UnmarshalJSON(data []byte) error { + m := make(map[common.UnprefixedAddress]GenesisAccount) + if err := json.Unmarshal(data, &m); err != nil { + return err + } + *ga = make(GenesisAlloc) + for addr, a := range m { + (*ga)[common.Address(addr)] = a + } + return nil +} + // GenesisAccount is an account in the state of the genesis block. type GenesisAccount struct { - Code []byte `json:"code,omitempty"` - Storage map[common.Hash]common.Hash `json:"storage,omitempty"` - Balance *big.Int `json:"balance" gencodec:"required"` - Nonce uint64 `json:"nonce,omitempty"` + Code []byte `json:"code,omitempty"` + Storage map[common.Hash]common.Hash `json:"storage,omitempty"` + Balance *big.Int `json:"balance" gencodec:"required"` + Nonce uint64 `json:"nonce,omitempty"` + PrivateKey []byte `json:"secretKey,omitempty"` // for tests } // field type overrides for gencodec @@ -70,13 +91,38 @@ type genesisSpecMarshaling struct { Timestamp math.HexOrDecimal64 ExtraData hexutil.Bytes GasLimit math.HexOrDecimal64 + GasUsed math.HexOrDecimal64 Difficulty *math.HexOrDecimal256 Alloc map[common.UnprefixedAddress]GenesisAccount } + type genesisAccountMarshaling struct { - Code hexutil.Bytes - Balance *math.HexOrDecimal256 - Nonce math.HexOrDecimal64 + Code hexutil.Bytes + Balance *math.HexOrDecimal256 + Nonce math.HexOrDecimal64 + Storage map[storageJSON]storageJSON + PrivateKey hexutil.Bytes +} + +// storageJSON represents a 256 bit byte array, but allows less than 256 bits when +// unmarshaling from hex. +type storageJSON common.Hash + +func (h *storageJSON) UnmarshalText(text []byte) error { + text = bytes.TrimPrefix(text, []byte("0x")) + if len(text) > 64 { + return fmt.Errorf("too many hex characters in storage key/value %q", text) + } + offset := len(h) - len(text)/2 // pad on the left + if _, err := hex.Decode(h[offset:], text); err != nil { + fmt.Println(err) + return fmt.Errorf("invalid hex storage key/value %q", text) + } + return nil +} + +func (h storageJSON) MarshalText() ([]byte, error) { + return hexutil.Bytes(h[:]).MarshalText() } // GenesisMismatchError is raised when trying to overwrite an existing @@ -133,7 +179,7 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig newcfg := genesis.configOrDefault(stored) storedcfg, err := GetChainConfig(db, stored) if err != nil { - if err == ChainConfigNotFoundErr { + if err == ErrChainConfigNotFound { // This case happens if a genesis write was interrupted. log.Warn("Found genesis block without chain config") err = WriteChainConfig(db, stored, newcfg) @@ -143,7 +189,7 @@ func SetupGenesisBlock(db ethdb.Database, genesis *Genesis) (*params.ChainConfig // Special case: don't change the existing config of a non-mainnet chain if no new // config is supplied. These chains would get AllProtocolChanges (and a compat error) // if we just continued here. - if genesis == nil && stored != params.MainNetGenesisHash { + if genesis == nil && stored != params.MainnetGenesisHash { return storedcfg, stored, nil } @@ -164,9 +210,9 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig { switch { case g != nil: return g.Config - case ghash == params.MainNetGenesisHash: + case ghash == params.MainnetGenesisHash: return params.MainnetChainConfig - case ghash == params.TestNetGenesisHash: + case ghash == params.TestnetGenesisHash: return params.TestnetChainConfig default: return params.AllProtocolChanges @@ -176,7 +222,7 @@ func (g *Genesis) configOrDefault(ghash common.Hash) *params.ChainConfig { // ToBlock creates the block and state of a genesis specification. func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) { db, _ := ethdb.NewMemDatabase() - statedb, _ := state.New(common.Hash{}, db) + statedb, _ := state.New(common.Hash{}, state.NewDatabase(db)) for addr, account := range g.Alloc { statedb.AddBalance(addr, account.Balance) statedb.SetCode(addr, account.Code) @@ -187,11 +233,13 @@ func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) { } root := statedb.IntermediateRoot(false) head := &types.Header{ + Number: new(big.Int).SetUint64(g.Number), Nonce: types.EncodeNonce(g.Nonce), 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), Difficulty: g.Difficulty, MixDigest: g.Mixhash, Coinbase: g.Coinbase, @@ -210,6 +258,9 @@ func (g *Genesis) ToBlock() (*types.Block, *state.StateDB) { // The block is committed as the canonical head block. func (g *Genesis) Commit(db ethdb.Database) (*types.Block, error) { block, statedb := g.ToBlock() + if block.Number().Sign() != 0 { + return nil, fmt.Errorf("can't commit genesis block with number > 0") + } if _, err := statedb.CommitTo(db, false); err != nil { return nil, fmt.Errorf("cannot write state: %v", err) } diff --git a/vendor/github.com/ethereum/go-ethereum/core/headerchain.go b/vendor/github.com/ethereum/go-ethereum/core/headerchain.go index 9bb7f1793..6ec44b61d 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/headerchain.go +++ b/vendor/github.com/ethereum/go-ethereum/core/headerchain.go @@ -201,15 +201,6 @@ func (hc *HeaderChain) WriteHeader(header *types.Header) (status WriteStatus, er // header writes should be protected by the parent chain mutex individually. type WhCallback func(*types.Header) error -// InsertHeaderChain attempts to insert the given header chain in to the local -// chain, possibly creating a reorg. If an error is returned, it will return the -// index number of the failing header as well an error describing what went wrong. -// -// The verify parameter can be used to fine tune whether nonce verification -// should be done or not. The reason behind the optional check is because some -// of the header retrieval mechanisms already need to verfy nonces, as well as -// because nonces can be verified sparsely, not needing to check each. - func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int) (int, error) { // Do a sanity check that the provided chain is actually ordered and linked for i := 1; i < len(chain); i++ { @@ -257,6 +248,14 @@ func (hc *HeaderChain) ValidateHeaderChain(chain []*types.Header, checkFreq int) return 0, nil } +// InsertHeaderChain attempts to insert the given header chain in to the local +// chain, possibly creating a reorg. If an error is returned, it will return the +// index number of the failing header as well an error describing what went wrong. +// +// The verify parameter can be used to fine tune whether nonce verification +// should be done or not. The reason behind the optional check is because some +// of the header retrieval mechanisms already need to verfy nonces, as well as +// because nonces can be verified sparsely, not needing to check each. func (hc *HeaderChain) InsertHeaderChain(chain []*types.Header, writeHeader WhCallback, start time.Time) (int, error) { // Collect some import statistics to report on stats := struct{ processed, ignored int }{} diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/database.go b/vendor/github.com/ethereum/go-ethereum/core/state/database.go new file mode 100644 index 000000000..946625e76 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/core/state/database.go @@ -0,0 +1,154 @@ +// 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 state + +import ( + "fmt" + "sync" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/trie" + lru "github.com/hashicorp/golang-lru" +) + +// Trie cache generation limit after which to evic trie nodes from memory. +var MaxTrieCacheGen = uint16(120) + +const ( + // Number of past tries to keep. This value is chosen such that + // reasonable chain reorg depths will hit an existing trie. + maxPastTries = 12 + + // Number of codehash->size associations to keep. + codeSizeCacheSize = 100000 +) + +// Database wraps access to tries and contract code. +type Database interface { + // Accessing tries: + // OpenTrie opens the main account trie. + // OpenStorageTrie opens the storage trie of an account. + OpenTrie(root common.Hash) (Trie, error) + OpenStorageTrie(addrHash, root common.Hash) (Trie, error) + // Accessing contract code: + ContractCode(addrHash, codeHash common.Hash) ([]byte, error) + ContractCodeSize(addrHash, codeHash common.Hash) (int, error) + // CopyTrie returns an independent copy of the given trie. + CopyTrie(Trie) Trie +} + +// Trie is a Ethereum Merkle Trie. +type Trie interface { + TryGet(key []byte) ([]byte, error) + TryUpdate(key, value []byte) error + TryDelete(key []byte) error + CommitTo(trie.DatabaseWriter) (common.Hash, error) + Hash() common.Hash + NodeIterator(startKey []byte) trie.NodeIterator + GetKey([]byte) []byte // TODO(fjl): remove this when SecureTrie is removed +} + +// NewDatabase creates a backing store for state. The returned database is safe for +// concurrent use and retains cached trie nodes in memory. +func NewDatabase(db ethdb.Database) Database { + csc, _ := lru.New(codeSizeCacheSize) + return &cachingDB{db: db, codeSizeCache: csc} +} + +type cachingDB struct { + db ethdb.Database + mu sync.Mutex + pastTries []*trie.SecureTrie + codeSizeCache *lru.Cache +} + +func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) { + db.mu.Lock() + defer db.mu.Unlock() + + for i := len(db.pastTries) - 1; i >= 0; i-- { + if db.pastTries[i].Hash() == root { + return cachedTrie{db.pastTries[i].Copy(), db}, nil + } + } + tr, err := trie.NewSecure(root, db.db, MaxTrieCacheGen) + if err != nil { + return nil, err + } + return cachedTrie{tr, db}, nil +} + +func (db *cachingDB) pushTrie(t *trie.SecureTrie) { + db.mu.Lock() + defer db.mu.Unlock() + + if len(db.pastTries) >= maxPastTries { + copy(db.pastTries, db.pastTries[1:]) + db.pastTries[len(db.pastTries)-1] = t + } else { + db.pastTries = append(db.pastTries, t) + } +} + +func (db *cachingDB) OpenStorageTrie(addrHash, root common.Hash) (Trie, error) { + return trie.NewSecure(root, db.db, 0) +} + +func (db *cachingDB) CopyTrie(t Trie) Trie { + switch t := t.(type) { + case cachedTrie: + return cachedTrie{t.SecureTrie.Copy(), db} + case *trie.SecureTrie: + return t.Copy() + default: + panic(fmt.Errorf("unknown trie type %T", t)) + } +} + +func (db *cachingDB) ContractCode(addrHash, codeHash common.Hash) ([]byte, error) { + code, err := db.db.Get(codeHash[:]) + if err == nil { + db.codeSizeCache.Add(codeHash, len(code)) + } + return code, err +} + +func (db *cachingDB) ContractCodeSize(addrHash, codeHash common.Hash) (int, error) { + if cached, ok := db.codeSizeCache.Get(codeHash); ok { + return cached.(int), nil + } + code, err := db.ContractCode(addrHash, codeHash) + if err == nil { + db.codeSizeCache.Add(codeHash, len(code)) + } + return len(code), err +} + +// cachedTrie inserts its trie into a cachingDB on commit. +type cachedTrie struct { + *trie.SecureTrie + db *cachingDB +} + +func (m cachedTrie) CommitTo(dbw trie.DatabaseWriter) (common.Hash, error) { + root, err := m.SecureTrie.CommitTo(dbw) + if err == nil { + m.db.pushTrie(m.SecureTrie) + } + return root, err +} diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/dump.go b/vendor/github.com/ethereum/go-ethereum/core/state/dump.go index ffa1a7283..46e612850 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/dump.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/dump.go @@ -41,7 +41,7 @@ type Dump struct { func (self *StateDB) RawDump() Dump { dump := Dump{ - Root: common.Bytes2Hex(self.trie.Root()), + Root: fmt.Sprintf("%x", self.trie.Hash()), Accounts: make(map[string]DumpAccount), } diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/iterator.go b/vendor/github.com/ethereum/go-ethereum/core/state/iterator.go index a8a2722ae..6a5c73d3d 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/iterator.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/iterator.go @@ -19,7 +19,6 @@ package state import ( "bytes" "fmt" - "math/big" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/rlp" @@ -105,16 +104,11 @@ func (it *NodeIterator) step() error { return nil } // Otherwise we've reached an account node, initiate data iteration - var account struct { - Nonce uint64 - Balance *big.Int - Root common.Hash - CodeHash []byte - } + var account Account if err := rlp.Decode(bytes.NewReader(it.stateIt.LeafBlob()), &account); err != nil { return err } - dataTrie, err := trie.New(account.Root, it.state.db) + dataTrie, err := it.state.db.OpenStorageTrie(common.BytesToHash(it.stateIt.LeafKey()), account.Root) if err != nil { return err } @@ -124,7 +118,8 @@ func (it *NodeIterator) step() error { } if !bytes.Equal(account.CodeHash, emptyCodeHash) { it.codeHash = common.BytesToHash(account.CodeHash) - it.code, err = it.state.db.Get(account.CodeHash) + addrHash := common.BytesToHash(it.stateIt.LeafKey()) + it.code, err = it.state.db.ContractCode(addrHash, common.BytesToHash(account.CodeHash)) if err != nil { return fmt.Errorf("code %x: %v", account.CodeHash, err) } diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/journal.go b/vendor/github.com/ethereum/go-ethereum/core/state/journal.go index 73218dd28..b5c8ca9a2 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/journal.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/journal.go @@ -71,8 +71,8 @@ type ( hash common.Hash } touchChange struct { - account *common.Address - prev bool + account *common.Address + prev bool prevDirty bool } ) @@ -91,6 +91,11 @@ func (ch suicideChange) undo(s *StateDB) { if obj != nil { obj.suicided = ch.prev obj.setBalance(ch.prevbalance) + // if the object wasn't suicided before, remove + // it from the list of destructed objects as well. + if !obj.suicided { + delete(s.stateObjectsDestructed, *ch.account) + } } } diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/state_object.go b/vendor/github.com/ethereum/go-ethereum/core/state/state_object.go index dcad9d068..b2378c69c 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/state_object.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/state_object.go @@ -62,9 +62,10 @@ func (self Storage) Copy() Storage { // Account values can be accessed and modified through the object. // Finally, call CommitTrie to write the modified storage trie into a database. type stateObject struct { - address common.Address // Ethereum address of this account - data Account - db *StateDB + address common.Address + addrHash common.Hash // hash of ethereum address of the account + data Account + db *StateDB // DB error. // State objects are used by the consensus core and VM which are @@ -74,8 +75,8 @@ type stateObject struct { dbErr error // Write caches. - trie *trie.SecureTrie // storage trie, which becomes non-nil on first access - code Code // contract bytecode, which gets set when code is loaded + trie Trie // storage trie, which becomes non-nil on first access + code Code // contract bytecode, which gets set when code is loaded cachedStorage Storage // Storage entry cache to avoid duplicate reads dirtyStorage Storage // Storage entries that need to be flushed to disk @@ -112,7 +113,15 @@ func newObject(db *StateDB, address common.Address, data Account, onDirty func(a if data.CodeHash == nil { data.CodeHash = emptyCodeHash } - return &stateObject{db: db, address: address, data: data, cachedStorage: make(Storage), dirtyStorage: make(Storage), onDirty: onDirty} + return &stateObject{ + db: db, + address: address, + addrHash: crypto.Keccak256Hash(address[:]), + data: data, + cachedStorage: make(Storage), + dirtyStorage: make(Storage), + onDirty: onDirty, + } } // EncodeRLP implements rlp.Encoder. @@ -148,12 +157,12 @@ func (c *stateObject) touch() { c.touched = true } -func (c *stateObject) getTrie(db trie.Database) *trie.SecureTrie { +func (c *stateObject) getTrie(db Database) Trie { if c.trie == nil { var err error - c.trie, err = trie.NewSecure(c.data.Root, db, 0) + c.trie, err = db.OpenStorageTrie(c.addrHash, c.data.Root) if err != nil { - c.trie, _ = trie.NewSecure(common.Hash{}, db, 0) + c.trie, _ = db.OpenStorageTrie(c.addrHash, common.Hash{}) c.setError(fmt.Errorf("can't create storage trie: %v", err)) } } @@ -161,13 +170,18 @@ func (c *stateObject) getTrie(db trie.Database) *trie.SecureTrie { } // GetState returns a value in account storage. -func (self *stateObject) GetState(db trie.Database, key common.Hash) common.Hash { +func (self *stateObject) GetState(db Database, key common.Hash) common.Hash { value, exists := self.cachedStorage[key] if exists { return value } // Load from DB in case it is missing. - if enc := self.getTrie(db).Get(key[:]); len(enc) > 0 { + enc, err := self.getTrie(db).TryGet(key[:]) + if err != nil { + self.setError(err) + return common.Hash{} + } + if len(enc) > 0 { _, content, _, err := rlp.Split(enc) if err != nil { self.setError(err) @@ -181,7 +195,7 @@ func (self *stateObject) GetState(db trie.Database, key common.Hash) common.Hash } // SetState updates a value in account storage. -func (self *stateObject) SetState(db trie.Database, key, value common.Hash) { +func (self *stateObject) SetState(db Database, key, value common.Hash) { self.db.journal = append(self.db.journal, storageChange{ account: &self.address, key: key, @@ -201,30 +215,30 @@ func (self *stateObject) setState(key, value common.Hash) { } // updateTrie writes cached storage modifications into the object's storage trie. -func (self *stateObject) updateTrie(db trie.Database) *trie.SecureTrie { +func (self *stateObject) updateTrie(db Database) Trie { tr := self.getTrie(db) for key, value := range self.dirtyStorage { delete(self.dirtyStorage, key) if (value == common.Hash{}) { - tr.Delete(key[:]) + self.setError(tr.TryDelete(key[:])) continue } // Encoding []byte cannot fail, ok to ignore the error. v, _ := rlp.EncodeToBytes(bytes.TrimLeft(value[:], "\x00")) - tr.Update(key[:], v) + self.setError(tr.TryUpdate(key[:], v)) } return tr } // UpdateRoot sets the trie root to the current root hash of -func (self *stateObject) updateRoot(db trie.Database) { +func (self *stateObject) updateRoot(db Database) { self.updateTrie(db) self.data.Root = self.trie.Hash() } // CommitTrie the storage trie of the object to dwb. // This updates the trie root. -func (self *stateObject) CommitTrie(db trie.Database, dbw trie.DatabaseWriter) error { +func (self *stateObject) CommitTrie(db Database, dbw trie.DatabaseWriter) error { self.updateTrie(db) if self.dbErr != nil { return self.dbErr @@ -282,9 +296,7 @@ func (c *stateObject) ReturnGas(gas *big.Int) {} func (self *stateObject) deepCopy(db *StateDB, onDirty func(addr common.Address)) *stateObject { stateObject := newObject(db, self.address, self.data, onDirty) if self.trie != nil { - // A shallow copy makes the two tries independent. - cpy := *self.trie - stateObject.trie = &cpy + stateObject.trie = db.db.CopyTrie(self.trie) } stateObject.code = self.code stateObject.dirtyStorage = self.dirtyStorage.Copy() @@ -305,14 +317,14 @@ func (c *stateObject) Address() common.Address { } // Code returns the contract code associated with this object, if any. -func (self *stateObject) Code(db trie.Database) []byte { +func (self *stateObject) Code(db Database) []byte { if self.code != nil { return self.code } if bytes.Equal(self.CodeHash(), emptyCodeHash) { return nil } - code, err := db.Get(self.CodeHash()) + code, err := db.ContractCode(self.addrHash, common.BytesToHash(self.CodeHash())) if err != nil { self.setError(fmt.Errorf("can't load code hash %x: %v", self.CodeHash(), err)) } diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/statedb.go b/vendor/github.com/ethereum/go-ethereum/core/state/statedb.go index 3b753a2e6..694374f82 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/statedb.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/statedb.go @@ -26,23 +26,9 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" - lru "github.com/hashicorp/golang-lru" -) - -// Trie cache generation limit after which to evic trie nodes from memory. -var MaxTrieCacheGen = uint16(120) - -const ( - // Number of past tries to keep. This value is chosen such that - // reasonable chain reorg depths will hit an existing trie. - maxPastTries = 12 - - // Number of codehash->size associations to keep. - codeSizeCacheSize = 100000 ) type revision struct { @@ -56,14 +42,20 @@ type revision struct { // * Contracts // * Accounts type StateDB struct { - db ethdb.Database - trie *trie.SecureTrie - pastTries []*trie.SecureTrie - codeSizeCache *lru.Cache + db Database + trie Trie // This map holds 'live' objects, which will get modified while processing a state transition. - stateObjects map[common.Address]*stateObject - stateObjectsDirty map[common.Address]struct{} + stateObjects map[common.Address]*stateObject + stateObjectsDirty map[common.Address]struct{} + stateObjectsDestructed map[common.Address]struct{} + + // DB error. + // State objects are used by the consensus core and VM which are + // unable to deal with database-level errors. Any error that occurs + // during a database read is memoized here and will eventually be returned + // by StateDB.Commit. + dbErr error // The refund counter, also used by state transitioning. refund *big.Int @@ -85,59 +77,45 @@ type StateDB struct { } // Create a new state from a given trie -func New(root common.Hash, db ethdb.Database) (*StateDB, error) { - tr, err := trie.NewSecure(root, db, MaxTrieCacheGen) +func New(root common.Hash, db Database) (*StateDB, error) { + tr, err := db.OpenTrie(root) if err != nil { return nil, err } - csc, _ := lru.New(codeSizeCacheSize) return &StateDB{ - db: db, - trie: tr, - codeSizeCache: csc, - 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), + db: db, + trie: tr, + stateObjects: make(map[common.Address]*stateObject), + stateObjectsDirty: make(map[common.Address]struct{}), + stateObjectsDestructed: make(map[common.Address]struct{}), + refund: new(big.Int), + logs: make(map[common.Hash][]*types.Log), + preimages: make(map[common.Hash][]byte), }, nil } -// New creates a new statedb by reusing any journalled tries to avoid costly -// disk io. -func (self *StateDB) New(root common.Hash) (*StateDB, error) { - self.lock.Lock() - defer self.lock.Unlock() - - tr, err := self.openTrie(root) - if err != nil { - return nil, err +// setError remembers the first non-nil error it is called with. +func (self *StateDB) setError(err error) { + if self.dbErr == nil { + self.dbErr = err } - return &StateDB{ - db: self.db, - trie: tr, - codeSizeCache: self.codeSizeCache, - 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 +} + +func (self *StateDB) Error() error { + return self.dbErr } // Reset clears out all emphemeral state objects from the state db, but keeps // the underlying state trie to avoid reloading data for the next operations. func (self *StateDB) Reset(root common.Hash) error { - self.lock.Lock() - defer self.lock.Unlock() - - tr, err := self.openTrie(root) + tr, err := self.db.OpenTrie(root) if err != nil { return err } self.trie = tr self.stateObjects = make(map[common.Address]*stateObject) self.stateObjectsDirty = make(map[common.Address]struct{}) + self.stateObjectsDestructed = make(map[common.Address]struct{}) self.thash = common.Hash{} self.bhash = common.Hash{} self.txIndex = 0 @@ -145,40 +123,9 @@ func (self *StateDB) Reset(root common.Hash) error { self.logSize = 0 self.preimages = make(map[common.Hash][]byte) self.clearJournalAndRefund() - return nil } -// openTrie creates a trie. It uses an existing trie if one is available -// from the journal if available. -func (self *StateDB) openTrie(root common.Hash) (*trie.SecureTrie, error) { - for i := len(self.pastTries) - 1; i >= 0; i-- { - if self.pastTries[i].Hash() == root { - tr := *self.pastTries[i] - return &tr, nil - } - } - return trie.NewSecure(root, self.db, MaxTrieCacheGen) -} - -func (self *StateDB) pushTrie(t *trie.SecureTrie) { - self.lock.Lock() - defer self.lock.Unlock() - - if len(self.pastTries) >= maxPastTries { - copy(self.pastTries, self.pastTries[1:]) - self.pastTries[len(self.pastTries)-1] = t - } else { - self.pastTries = append(self.pastTries, t) - } -} - -func (self *StateDB) StartRecord(thash, bhash common.Hash, ti int) { - self.thash = thash - self.bhash = bhash - self.txIndex = ti -} - func (self *StateDB) AddLog(log *types.Log) { self.journal = append(self.journal, addLogChange{txhash: self.thash}) @@ -256,10 +203,7 @@ func (self *StateDB) GetNonce(addr common.Address) uint64 { func (self *StateDB) GetCode(addr common.Address) []byte { stateObject := self.getStateObject(addr) if stateObject != nil { - code := stateObject.Code(self.db) - key := common.BytesToHash(stateObject.CodeHash()) - self.codeSizeCache.Add(key, len(code)) - return code + return stateObject.Code(self.db) } return nil } @@ -269,13 +213,12 @@ func (self *StateDB) GetCodeSize(addr common.Address) int { if stateObject == nil { return 0 } - key := common.BytesToHash(stateObject.CodeHash()) - if cached, ok := self.codeSizeCache.Get(key); ok { - return cached.(int) + if stateObject.code != nil { + return len(stateObject.code) } - size := len(stateObject.Code(self.db)) - if stateObject.dbErr == nil { - self.codeSizeCache.Add(key, size) + size, err := self.db.ContractCodeSize(stateObject.addrHash, common.BytesToHash(stateObject.CodeHash())) + if err != nil { + self.setError(err) } return size } @@ -298,7 +241,7 @@ func (self *StateDB) GetState(a common.Address, b common.Hash) common.Hash { // StorageTrie returns the storage trie of an account. // The return value is a copy and is nil for non-existent accounts. -func (self *StateDB) StorageTrie(a common.Address) *trie.SecureTrie { +func (self *StateDB) StorageTrie(a common.Address) Trie { stateObject := self.getStateObject(a) if stateObject == nil { return nil @@ -380,6 +323,8 @@ func (self *StateDB) Suicide(addr common.Address) bool { }) stateObject.markSuicided() stateObject.data.Balance = new(big.Int) + self.stateObjectsDestructed[addr] = struct{}{} + return true } @@ -394,14 +339,14 @@ func (self *StateDB) updateStateObject(stateObject *stateObject) { if err != nil { panic(fmt.Errorf("can't encode object at %x: %v", addr[:], err)) } - self.trie.Update(addr[:], data) + self.setError(self.trie.TryUpdate(addr[:], data)) } // deleteStateObject removes the given object from the state trie. func (self *StateDB) deleteStateObject(stateObject *stateObject) { stateObject.deleted = true addr := stateObject.Address() - self.trie.Delete(addr[:]) + self.setError(self.trie.TryDelete(addr[:])) } // Retrieve a state object given my the address. Returns nil if not found. @@ -415,8 +360,9 @@ func (self *StateDB) getStateObject(addr common.Address) (stateObject *stateObje } // Load the object from the database. - enc := self.trie.Get(addr[:]) + enc, err := self.trie.TryGet(addr[:]) if len(enc) == 0 { + self.setError(err) return nil } var data Account @@ -510,21 +456,23 @@ func (self *StateDB) Copy() *StateDB { // Copy all the basic fields, initialize the memory ones state := &StateDB{ - db: self.db, - trie: self.trie, - pastTries: self.pastTries, - codeSizeCache: self.codeSizeCache, - 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), - logs: make(map[common.Hash][]*types.Log, len(self.logs)), - logSize: self.logSize, - preimages: make(map[common.Hash][]byte), + db: self.db, + trie: self.trie, + stateObjects: make(map[common.Address]*stateObject, len(self.stateObjectsDirty)), + stateObjectsDirty: make(map[common.Address]struct{}, len(self.stateObjectsDirty)), + stateObjectsDestructed: make(map[common.Address]struct{}, len(self.stateObjectsDestructed)), + refund: new(big.Int).Set(self.refund), + logs: make(map[common.Hash][]*types.Log, len(self.logs)), + logSize: self.logSize, + preimages: make(map[common.Hash][]byte), } // Copy the dirty states, logs, and preimages for addr := range self.stateObjectsDirty { state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty) state.stateObjectsDirty[addr] = struct{}{} + if self.stateObjects[addr].suicided { + state.stateObjectsDestructed[addr] = struct{}{} + } } for hash, logs := range self.logs { state.logs[hash] = make([]*types.Log, len(logs)) @@ -590,6 +538,27 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { return s.trie.Hash() } +// Prepare sets the current transaction hash and index and block hash which is +// used when the EVM emits new state logs. +func (self *StateDB) Prepare(thash, bhash common.Hash, ti int) { + self.thash = thash + self.bhash = bhash + self.txIndex = ti +} + +// Finalise finalises the state by removing the self destructed objects +// in the current stateObjectsDestructed buffer and clears the journal +// as well as the refunds. +// +// Please note that Finalise is used by EIP#98 and is used instead of +// IntermediateRoot. +func (s *StateDB) Finalise() { + for addr := range s.stateObjectsDestructed { + s.deleteStateObject(s.stateObjects[addr]) + } + s.clearJournalAndRefund() +} + // DeleteSuicides flags the suicided objects for deletion so that it // won't be referenced again when called / queried up on. // @@ -611,23 +580,6 @@ func (s *StateDB) DeleteSuicides() { } } -// Commit commits all state changes to the database. -func (s *StateDB) Commit(deleteEmptyObjects bool) (root common.Hash, err error) { - root, batch := s.CommitBatch(deleteEmptyObjects) - return root, batch.Write() -} - -// CommitBatch commits all state changes to a write batch but does not -// execute the batch. It is used to validate state changes against -// the root hash stored in a block. -func (s *StateDB) CommitBatch(deleteEmptyObjects bool) (root common.Hash, batch ethdb.Batch) { - batch = s.db.NewBatch() - root, _ = s.CommitTo(batch, deleteEmptyObjects) - - log.Debug("Trie cache stats after commit", "misses", trie.CacheMisses(), "unloads", trie.CacheUnloads()) - return root, batch -} - func (s *StateDB) clearJournalAndRefund() { s.journal = nil s.validRevisions = s.validRevisions[:0] @@ -665,8 +617,6 @@ func (s *StateDB) CommitTo(dbw trie.DatabaseWriter, deleteEmptyObjects bool) (ro } // Write trie changes. root, err = s.trie.CommitTo(dbw) - if err == nil { - s.pushTrie(s.trie) - } + log.Debug("Trie cache stats after commit", "misses", trie.CacheMisses(), "unloads", trie.CacheUnloads()) return root, err } diff --git a/vendor/github.com/ethereum/go-ethereum/core/state/sync.go b/vendor/github.com/ethereum/go-ethereum/core/state/sync.go index 8456a810b..2c29d706a 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state/sync.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state/sync.go @@ -59,10 +59,16 @@ func (s *StateSync) Missing(max int) []common.Hash { } // Process injects a batch of retrieved trie nodes data, returning if something -// was committed to the database and also the index of an entry if processing of +// was committed to the memcache and also the index of an entry if processing of // it failed. -func (s *StateSync) Process(list []trie.SyncResult, dbw trie.DatabaseWriter) (bool, int, error) { - return (*trie.TrieSync)(s).Process(list, dbw) +func (s *StateSync) Process(list []trie.SyncResult) (bool, int, error) { + return (*trie.TrieSync)(s).Process(list) +} + +// Commit flushes the data stored in the internal memcache out to persistent +// storage, returning th enumber of items written and any occurred error. +func (s *StateSync) Commit(dbw trie.DatabaseWriter) (int, error) { + return (*trie.TrieSync)(s).Commit(dbw) } // Pending returns the number of state entries currently pending for download. diff --git a/vendor/github.com/ethereum/go-ethereum/core/state_processor.go b/vendor/github.com/ethereum/go-ethereum/core/state_processor.go index 4fc2f1eae..90f5a4f60 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state_processor.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state_processor.go @@ -69,7 +69,7 @@ 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.StartRecord(tx.Hash(), block.Hash(), i) + statedb.Prepare(tx.Hash(), block.Hash(), i) receipt, _, err := ApplyTransaction(p.config, p.bc, nil, gp, statedb, header, tx, totalUsedGas, cfg) if err != nil { return nil, nil, nil, err @@ -107,7 +107,8 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common usedGas.Add(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(statedb.IntermediateRoot(config.IsEIP158(header.Number)).Bytes(), usedGas) + root := statedb.IntermediateRoot(config.IsEIP158(header.Number)) + receipt := types.NewReceipt(root.Bytes(), usedGas) receipt.TxHash = tx.Hash() receipt.GasUsed = new(big.Int).Set(gas) // if the transaction created a contract, store the creation address in the receipt. diff --git a/vendor/github.com/ethereum/go-ethereum/core/state_transition.go b/vendor/github.com/ethereum/go-ethereum/core/state_transition.go index 9e11144c6..0ae9d7fcb 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/state_transition.go +++ b/vendor/github.com/ethereum/go-ethereum/core/state_transition.go @@ -78,10 +78,6 @@ type Message interface { Data() []byte } -func MessageCreatesContract(msg Message) bool { - return msg.To() == nil -} - // IntrinsicGas computes the 'intrinsic gas' for a message // with the given data. // @@ -138,115 +134,116 @@ func ApplyMessage(evm *vm.EVM, msg Message, gp *GasPool) ([]byte, *big.Int, erro return ret, gasUsed, err } -func (self *StateTransition) from() vm.AccountRef { - f := self.msg.From() - if !self.state.Exist(f) { - self.state.CreateAccount(f) +func (st *StateTransition) from() vm.AccountRef { + f := st.msg.From() + if !st.state.Exist(f) { + st.state.CreateAccount(f) } return vm.AccountRef(f) } -func (self *StateTransition) to() vm.AccountRef { - if self.msg == nil { +func (st *StateTransition) to() vm.AccountRef { + if st.msg == nil { return vm.AccountRef{} } - to := self.msg.To() + to := st.msg.To() if to == nil { return vm.AccountRef{} // contract creation } reference := vm.AccountRef(*to) - if !self.state.Exist(*to) { - self.state.CreateAccount(*to) + if !st.state.Exist(*to) { + st.state.CreateAccount(*to) } return reference } -func (self *StateTransition) useGas(amount uint64) error { - if self.gas < amount { +func (st *StateTransition) useGas(amount uint64) error { + if st.gas < amount { return vm.ErrOutOfGas } - self.gas -= amount + st.gas -= amount return nil } -func (self *StateTransition) buyGas() error { - mgas := self.msg.Gas() +func (st *StateTransition) buyGas() error { + mgas := st.msg.Gas() if mgas.BitLen() > 64 { return vm.ErrOutOfGas } - mgval := new(big.Int).Mul(mgas, self.gasPrice) + mgval := new(big.Int).Mul(mgas, st.gasPrice) var ( - state = self.state - sender = self.from() + state = st.state + sender = st.from() ) if state.GetBalance(sender.Address()).Cmp(mgval) < 0 { return errInsufficientBalanceForGas } - if err := self.gp.SubGas(mgas); err != nil { + if err := st.gp.SubGas(mgas); err != nil { return err } - self.gas += mgas.Uint64() + st.gas += mgas.Uint64() - self.initialGas.Set(mgas) + st.initialGas.Set(mgas) state.SubBalance(sender.Address(), mgval) return nil } -func (self *StateTransition) preCheck() error { - msg := self.msg - sender := self.from() +func (st *StateTransition) preCheck() error { + msg := st.msg + sender := st.from() // Make sure this transaction's nonce is correct if msg.CheckNonce() { - if n := self.state.GetNonce(sender.Address()); n != msg.Nonce() { + if n := st.state.GetNonce(sender.Address()); n != msg.Nonce() { return fmt.Errorf("invalid nonce: have %d, expected %d", msg.Nonce(), n) } } - return self.buyGas() + 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 // failed. An error indicates a consensus issue. -func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, err error) { - if err = self.preCheck(); err != nil { +func (st *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *big.Int, err error) { + if err = st.preCheck(); err != nil { return } - msg := self.msg - sender := self.from() // err checked in preCheck + msg := st.msg + sender := st.from() // err checked in preCheck + + homestead := st.evm.ChainConfig().IsHomestead(st.evm.BlockNumber) + contractCreation := msg.To() == nil - homestead := self.evm.ChainConfig().IsHomestead(self.evm.BlockNumber) - contractCreation := MessageCreatesContract(msg) // Pay intrinsic gas // TODO convert to uint64 - intrinsicGas := IntrinsicGas(self.data, contractCreation, homestead) + intrinsicGas := IntrinsicGas(st.data, contractCreation, homestead) if intrinsicGas.BitLen() > 64 { return nil, nil, nil, vm.ErrOutOfGas } - if err = self.useGas(intrinsicGas.Uint64()); err != nil { + if err = st.useGas(intrinsicGas.Uint64()); err != nil { return nil, nil, nil, err } var ( - evm = self.evm + evm = st.evm // vm errors do not effect consensus and are therefor // not assigned to err, except for insufficient balance // error. vmerr error ) if contractCreation { - ret, _, self.gas, vmerr = evm.Create(sender, self.data, self.gas, self.value) + ret, _, st.gas, vmerr = evm.Create(sender, st.data, st.gas, st.value) } else { // Increment the nonce for the next transaction - self.state.SetNonce(sender.Address(), self.state.GetNonce(sender.Address())+1) - ret, self.gas, vmerr = evm.Call(sender, self.to().Address(), self.data, self.gas, self.value) + st.state.SetNonce(sender.Address(), st.state.GetNonce(sender.Address())+1) + ret, st.gas, vmerr = evm.Call(sender, st.to().Address(), st.data, st.gas, st.value) } if vmerr != nil { - log.Debug("VM returned with error", "err", err) + log.Debug("VM returned with error", "err", vmerr) // The only possible consensus-error would be if there wasn't // sufficient balance to make the transfer happen. The first // balance transfer may never fail. @@ -254,33 +251,33 @@ func (self *StateTransition) TransitionDb() (ret []byte, requiredGas, usedGas *b return nil, nil, nil, vmerr } } - requiredGas = new(big.Int).Set(self.gasUsed()) + requiredGas = new(big.Int).Set(st.gasUsed()) - self.refundGas() - self.state.AddBalance(self.evm.Coinbase, new(big.Int).Mul(self.gasUsed(), self.gasPrice)) + st.refundGas() + st.state.AddBalance(st.evm.Coinbase, new(big.Int).Mul(st.gasUsed(), st.gasPrice)) - return ret, requiredGas, self.gasUsed(), err + return ret, requiredGas, st.gasUsed(), err } -func (self *StateTransition) refundGas() { +func (st *StateTransition) refundGas() { // Return eth for remaining gas to the sender account, // exchanged at the original rate. - sender := self.from() // err already checked - remaining := new(big.Int).Mul(new(big.Int).SetUint64(self.gas), self.gasPrice) - self.state.AddBalance(sender.Address(), remaining) + sender := st.from() // err already checked + 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(self.gasUsed(), common.Big2) - refund := math.BigMin(uhalf, self.state.GetRefund()) - self.gas += refund.Uint64() + uhalf := remaining.Div(st.gasUsed(), common.Big2) + refund := math.BigMin(uhalf, st.state.GetRefund()) + st.gas += refund.Uint64() - self.state.AddBalance(sender.Address(), refund.Mul(refund, self.gasPrice)) + 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. - self.gp.AddGas(new(big.Int).SetUint64(self.gas)) + st.gp.AddGas(new(big.Int).SetUint64(st.gas)) } -func (self *StateTransition) gasUsed() *big.Int { - return new(big.Int).Sub(self.initialGas, new(big.Int).SetUint64(self.gas)) +func (st *StateTransition) gasUsed() *big.Int { + return new(big.Int).Sub(st.initialGas, new(big.Int).SetUint64(st.gas)) } diff --git a/vendor/github.com/ethereum/go-ethereum/core/tx_list.go b/vendor/github.com/ethereum/go-ethereum/core/tx_list.go index 535cb9dd6..0d87c20bc 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/tx_list.go +++ b/vendor/github.com/ethereum/go-ethereum/core/tx_list.go @@ -22,7 +22,9 @@ import ( "math/big" "sort" + "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/log" ) // nonceHeap is a heap.Interface implementation over 64bit unsigned integers for @@ -53,11 +55,11 @@ type txSortedMap struct { cache types.Transactions // Cache of the transactions already sorted } -// newTxSortedMap creates a new sorted transaction map. +// newTxSortedMap creates a new nonce-sorted transaction map. func newTxSortedMap() *txSortedMap { return &txSortedMap{ items: make(map[uint64]*types.Transaction), - index: &nonceHeap{}, + index: new(nonceHeap), } } @@ -218,9 +220,11 @@ func (m *txSortedMap) Flatten() types.Transactions { // the executable/pending queue; and for storing gapped transactions for the non- // executable/future queue, with minor behavioral changes. type txList struct { - strict bool // Whether nonces are strictly continuous or not - txs *txSortedMap // Heap indexed sorted hash map of the transactions - costcap *big.Int // Price of the highest costing transaction (reset only if exceeds balance) + strict bool // Whether nonces are strictly continuous or not + 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) } // newTxList create a new transaction list for maintaining nonce-indexable fast, @@ -230,25 +234,38 @@ func newTxList(strict bool) *txList { strict: strict, txs: newTxSortedMap(), costcap: new(big.Int), + gascap: new(big.Int), } } +// Overlaps returns whether the transaction specified has the same nonce as one +// already contained within the list. +func (l *txList) Overlaps(tx *types.Transaction) bool { + return l.txs.Get(tx.Nonce()) != nil +} + // Add tries to insert a new transaction into the list, returning whether the // transaction was accepted, and if yes, any previous transaction it replaced. // -// If the new transaction is accepted into the list, the lists' cost threshold -// is also potentially updated. -func (l *txList) Add(tx *types.Transaction) (bool, *types.Transaction) { +// If the new transaction is accepted into the list, the lists' cost and gas +// thresholds are also potentially updated. +func (l *txList) Add(tx *types.Transaction, priceBump uint64) (bool, *types.Transaction) { // If there's an older better transaction, abort old := l.txs.Get(tx.Nonce()) - if old != nil && old.GasPrice().Cmp(tx.GasPrice()) >= 0 { - return false, nil + if old != nil { + threshold := new(big.Int).Div(new(big.Int).Mul(old.GasPrice(), big.NewInt(100+int64(priceBump))), big.NewInt(100)) + if threshold.Cmp(tx.GasPrice()) >= 0 { + return false, nil + } } // Otherwise overwrite the old transaction with the current one l.txs.Put(tx) if cost := tx.Cost(); l.costcap.Cmp(cost) < 0 { l.costcap = cost } + if gas := tx.Gas(); l.gascap.Cmp(gas) < 0 { + l.gascap = gas + } return true, old } @@ -259,23 +276,25 @@ func (l *txList) Forward(threshold uint64) types.Transactions { return l.txs.Forward(threshold) } -// Filter removes all transactions from the list with a cost higher than the -// provided threshold. Every removed transaction is returned for any post-removal -// maintenance. Strict-mode invalidated transactions are also returned. +// Filter removes all transactions from the list with a cost or gas limit higher +// than the provided thresholds. Every removed transaction is returned for any +// post-removal maintenance. Strict-mode invalidated transactions are also +// returned. // -// This method uses the cached costcap to quickly decide if there's even a point -// in calculating all the costs or if the balance covers all. If the threshold is -// lower than the costcap, the costcap will be reset to a new high after removing -// expensive the too transactions. -func (l *txList) Filter(threshold *big.Int) (types.Transactions, types.Transactions) { +// This method uses the cached costcap and gascap to quickly decide if there's even +// 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) { // If all transactions are below the threshold, short circuit - if l.costcap.Cmp(threshold) <= 0 { + if l.costcap.Cmp(costLimit) <= 0 && l.gascap.Cmp(gasLimit) <= 0 { return nil, nil } - l.costcap = new(big.Int).Set(threshold) // Lower the cap to the threshold + l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds + l.gascap = new(big.Int).Set(gasLimit) // Filter out all the transactions above the account's funds - removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(threshold) > 0 }) + removed := l.txs.Filter(func(tx *types.Transaction) bool { return tx.Cost().Cmp(costLimit) > 0 || tx.Gas().Cmp(gasLimit) > 0 }) // If the list was strict, filter anything above the lowest nonce var invalids types.Transactions @@ -340,3 +359,146 @@ func (l *txList) Empty() bool { func (l *txList) Flatten() types.Transactions { return l.txs.Flatten() } + +// priceHeap is a heap.Interface implementation over transactions for retrieving +// price-sorted transactions to discard when the pool fills up. +type priceHeap []*types.Transaction + +func (h priceHeap) Len() int { return len(h) } +func (h priceHeap) Less(i, j int) bool { return h[i].GasPrice().Cmp(h[j].GasPrice()) < 0 } +func (h priceHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } + +func (h *priceHeap) Push(x interface{}) { + *h = append(*h, x.(*types.Transaction)) +} + +func (h *priceHeap) Pop() interface{} { + old := *h + n := len(old) + x := old[n-1] + *h = old[0 : n-1] + return x +} + +// txPricedList is a price-sorted heap to allow operating on transactions pool +// contents in a price-incrementing way. +type txPricedList struct { + all *map[common.Hash]*types.Transaction // Pointer to the map of all transactions + items *priceHeap // Heap of prices of all the stored transactions + stales int // Number of stale price points to (re-heap trigger) +} + +// newTxPricedList creates a new price-sorted transaction heap. +func newTxPricedList(all *map[common.Hash]*types.Transaction) *txPricedList { + return &txPricedList{ + all: all, + items: new(priceHeap), + } +} + +// Put inserts a new transaction into the heap. +func (l *txPricedList) Put(tx *types.Transaction) { + heap.Push(l.items, tx) +} + +// Removed notifies the prices transaction list that an old transaction dropped +// from the pool. The list will just keep a counter of stale objects and update +// the heap if a large enough ratio of transactions go stale. +func (l *txPricedList) Removed() { + // Bump the stale counter, but exit if still too low (< 25%) + l.stales++ + if l.stales <= len(*l.items)/4 { + return + } + // Seems we've reached a critical number of stale transactions, reheap + reheap := make(priceHeap, 0, len(*l.all)) + + l.stales, l.items = 0, &reheap + for _, tx := range *l.all { + *l.items = append(*l.items, tx) + } + heap.Init(l.items) +} + +// Cap finds all the transactions below the given price threshold, drops them +// from the priced list and returs them for further removal from the entire pool. +func (l *txPricedList) Cap(threshold *big.Int, local *accountSet) types.Transactions { + drop := make(types.Transactions, 0, 128) // Remote underpriced transactions to drop + save := make(types.Transactions, 0, 64) // Local underpriced transactions to keep + + for len(*l.items) > 0 { + // Discard stale transactions if found during cleanup + tx := heap.Pop(l.items).(*types.Transaction) + if _, ok := (*l.all)[tx.Hash()]; !ok { + l.stales-- + continue + } + // Stop the discards if we've reached the threshold + if tx.GasPrice().Cmp(threshold) >= 0 { + break + } + // Non stale transaction found, discard unless local + if local.containsTx(tx) { + save = append(save, tx) + } else { + drop = append(drop, tx) + } + } + for _, tx := range save { + heap.Push(l.items, tx) + } + return drop +} + +// Underpriced checks whether a transaction is cheaper than (or as cheap as) the +// lowest priced transaction currently being tracked. +func (l *txPricedList) Underpriced(tx *types.Transaction, local *accountSet) bool { + // Local transactions cannot be underpriced + if local.containsTx(tx) { + return false + } + // Discard stale price points if found at the heap start + for len(*l.items) > 0 { + head := []*types.Transaction(*l.items)[0] + if _, ok := (*l.all)[head.Hash()]; !ok { + l.stales-- + heap.Pop(l.items) + continue + } + break + } + // Check if the transaction is underpriced or not + if len(*l.items) == 0 { + log.Error("Pricing query for empty pool") // This cannot happen, print to catch programming errors + return false + } + cheapest := []*types.Transaction(*l.items)[0] + return cheapest.GasPrice().Cmp(tx.GasPrice()) >= 0 +} + +// Discard finds a number of most underpriced transactions, removes them from the +// priced list and returns them for further removal from the entire pool. +func (l *txPricedList) Discard(count int, local *accountSet) types.Transactions { + drop := make(types.Transactions, 0, count) // Remote underpriced transactions to drop + save := make(types.Transactions, 0, 64) // Local underpriced transactions to keep + + for len(*l.items) > 0 && count > 0 { + // Discard stale transactions if found during cleanup + tx := heap.Pop(l.items).(*types.Transaction) + if _, ok := (*l.all)[tx.Hash()]; !ok { + l.stales-- + continue + } + // Non stale transaction found, discard unless local + if local.containsTx(tx) { + save = append(save, tx) + } else { + drop = append(drop, tx) + count-- + } + } + for _, tx := range save { + heap.Push(l.items, tx) + } + return drop +} diff --git a/vendor/github.com/ethereum/go-ethereum/core/tx_pool.go b/vendor/github.com/ethereum/go-ethereum/core/tx_pool.go index 49bd81e48..8e2d1b31d 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/tx_pool.go +++ b/vendor/github.com/ethereum/go-ethereum/core/tx_pool.go @@ -35,45 +35,112 @@ import ( ) var ( - // Transaction Pool Errors - ErrInvalidSender = errors.New("Invalid sender") - ErrNonce = errors.New("Nonce too low") - ErrCheap = errors.New("Gas price too low for acceptance") - ErrBalance = errors.New("Insufficient balance") - ErrInsufficientFunds = errors.New("Insufficient funds for gas * price + value") - ErrIntrinsicGas = errors.New("Intrinsic gas too low") - ErrGasLimit = errors.New("Exceeds block gas limit") - ErrNegativeValue = errors.New("Negative value") + // ErrInvalidSender is returned if the transaction contains an invalid signature. + ErrInvalidSender = errors.New("invalid sender") + + // ErrNonceTooLow is returned if the nonce of a transaction is lower than the + // one present in the local chain. + ErrNonceTooLow = errors.New("nonce too low") + + // ErrUnderpriced is returned if a transaction's gas price is below the minimum + // configured for the transaction pool. + ErrUnderpriced = errors.New("transaction underpriced") + + // ErrReplaceUnderpriced is returned if a transaction is attempted to be replaced + // with a different one without the required price bump. + ErrReplaceUnderpriced = errors.New("replacement transaction underpriced") + + // ErrInsufficientFunds is returned if the total cost of executing a transaction + // is higher than the balance of the user's account. + ErrInsufficientFunds = errors.New("insufficient funds for gas * price + value") + + // ErrIntrinsicGas is returned if the transaction is specified to use less gas + // than required to start the invocation. + ErrIntrinsicGas = errors.New("intrinsic gas too low") + + // ErrGasLimit is returned if a transaction's requested gas limit exceeds the + // maximum allowance of the current block. + ErrGasLimit = errors.New("exceeds block gas limit") + + // ErrNegativeValue is a sanity error to ensure noone is able to specify a + // transaction with a negative value. + ErrNegativeValue = errors.New("negative value") + + // ErrOversizedData is returned if the input data of a transaction is greater + // than some meaningful limit a user might use. This is not a consensus error + // making the transaction invalid, rather a DOS protection. + ErrOversizedData = errors.New("oversized data") ) var ( - minPendingPerAccount = uint64(16) // Min number of guaranteed transaction slots per address - maxPendingTotal = uint64(4096) // Max limit of pending transactions from all accounts (soft) - maxQueuedPerAccount = uint64(64) // Max limit of queued transactions per address - maxQueuedInTotal = uint64(1024) // Max limit of queued transactions from all accounts - maxQueuedLifetime = 3 * time.Hour // Max amount of time transactions from idle accounts are queued - evictionInterval = time.Minute // Time interval to check for evictable transactions + evictionInterval = time.Minute // Time interval to check for evictable transactions + statsReportInterval = 8 * time.Second // Time interval to report transaction pool stats ) var ( // Metrics for the pending pool - pendingDiscardCounter = metrics.NewCounter("txpool/pending/discard") - pendingReplaceCounter = metrics.NewCounter("txpool/pending/replace") - pendingRLCounter = metrics.NewCounter("txpool/pending/ratelimit") // Dropped due to rate limiting - pendingNofundsCounter = metrics.NewCounter("txpool/pending/nofunds") // Dropped due to out-of-funds + pendingDiscardCounter = metrics.NewCounter("txpool/pending/discard") + pendingReplaceCounter = metrics.NewCounter("txpool/pending/replace") + pendingRateLimitCounter = metrics.NewCounter("txpool/pending/ratelimit") // Dropped due to rate limiting + pendingNofundsCounter = metrics.NewCounter("txpool/pending/nofunds") // Dropped due to out-of-funds // Metrics for the queued pool - queuedDiscardCounter = metrics.NewCounter("txpool/queued/discard") - queuedReplaceCounter = metrics.NewCounter("txpool/queued/replace") - queuedRLCounter = metrics.NewCounter("txpool/queued/ratelimit") // Dropped due to rate limiting - queuedNofundsCounter = metrics.NewCounter("txpool/queued/nofunds") // Dropped due to out-of-funds + queuedDiscardCounter = metrics.NewCounter("txpool/queued/discard") + queuedReplaceCounter = metrics.NewCounter("txpool/queued/replace") + queuedRateLimitCounter = metrics.NewCounter("txpool/queued/ratelimit") // Dropped due to rate limiting + queuedNofundsCounter = metrics.NewCounter("txpool/queued/nofunds") // Dropped due to out-of-funds // General tx metrics - invalidTxCounter = metrics.NewCounter("txpool/invalid") + invalidTxCounter = metrics.NewCounter("txpool/invalid") + underpricedTxCounter = metrics.NewCounter("txpool/underpriced") ) type stateFn func() (*state.StateDB, error) +// TxPoolConfig are the configuration parameters of the transaction pool. +type TxPoolConfig struct { + NoLocals bool // Whether local transaction handling should be disabled + + PriceLimit uint64 // Minimum gas price to enforce for acceptance into the pool + PriceBump uint64 // Minimum price bump percentage to replace an already existing transaction (nonce) + + AccountSlots uint64 // Minimum number of executable transaction slots guaranteed per account + GlobalSlots uint64 // Maximum number of executable transaction slots for all accounts + AccountQueue uint64 // Maximum number of non-executable transaction slots permitted per account + GlobalQueue uint64 // Maximum number of non-executable transaction slots for all accounts + + Lifetime time.Duration // Maximum amount of time non-executable transaction are queued +} + +// DefaultTxPoolConfig contains the default configurations for the transaction +// pool. +var DefaultTxPoolConfig = TxPoolConfig{ + PriceLimit: 1, + PriceBump: 10, + + AccountSlots: 16, + GlobalSlots: 4096, + AccountQueue: 64, + GlobalQueue: 1024, + + Lifetime: 3 * time.Hour, +} + +// sanitize checks the provided user configurations and changes anything that's +// unreasonable or unworkable. +func (config *TxPoolConfig) sanitize() TxPoolConfig { + conf := *config + if conf.PriceLimit < 1 { + log.Warn("Sanitizing invalid txpool price limit", "provided", conf.PriceLimit, "updated", DefaultTxPoolConfig.PriceLimit) + conf.PriceLimit = DefaultTxPoolConfig.PriceLimit + } + if conf.PriceBump < 1 { + log.Warn("Sanitizing invalid txpool price bump", "provided", conf.PriceBump, "updated", DefaultTxPoolConfig.PriceBump) + conf.PriceBump = DefaultTxPoolConfig.PriceBump + } + return conf +} + // TxPool contains all currently known transactions. Transactions // enter the pool when they are received from the network or submitted // locally. They exit the pool when they are included in the blockchain. @@ -82,21 +149,23 @@ type stateFn func() (*state.StateDB, error) // current state) and future transactions. Transactions move between those // two states over time as they are received and processed. type TxPool struct { - config *params.ChainConfig + config TxPoolConfig + chainconfig *params.ChainConfig currentState stateFn // The state function which will allow us to do some pre checks pendingState *state.ManagedState gasLimit func() *big.Int // The current gas limit function callback - minGasPrice *big.Int + gasPrice *big.Int eventMux *event.TypeMux events *event.TypeMuxSubscription - localTx *txSet + locals *accountSet signer types.Signer mu sync.RWMutex pending map[common.Address]*txList // All currently processable transactions queue map[common.Address]*txList // Queued but non-processable transactions - all map[common.Hash]*types.Transaction // All transactions to allow lookups beats map[common.Address]time.Time // Last heartbeat from each known account + all map[common.Hash]*types.Transaction // All transactions to allow lookups + priced *txPricedList // All transactions sorted by price wg sync.WaitGroup // for shutdown sync quit chan struct{} @@ -104,26 +173,34 @@ type TxPool struct { homestead bool } -func NewTxPool(config *params.ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool { +// NewTxPool creates a new transaction pool to gather, sort and filter inbound +// trnsactions from the network. +func NewTxPool(config TxPoolConfig, chainconfig *params.ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool { + // Sanitize the input to ensure no vulnerable gas prices are set + config = (&config).sanitize() + + // Create the transaction pool with its initial settings pool := &TxPool{ config: config, - signer: types.NewEIP155Signer(config.ChainId), + chainconfig: chainconfig, + signer: types.NewEIP155Signer(chainconfig.ChainId), pending: make(map[common.Address]*txList), queue: make(map[common.Address]*txList), - all: make(map[common.Hash]*types.Transaction), beats: make(map[common.Address]time.Time), + all: make(map[common.Hash]*types.Transaction), eventMux: eventMux, currentState: currentStateFn, gasLimit: gasLimitFn, - minGasPrice: new(big.Int), + gasPrice: new(big.Int).SetUint64(config.PriceLimit), pendingState: nil, - localTx: newTxSet(), - events: eventMux.Subscribe(ChainHeadEvent{}, GasPriceChanged{}, RemovedTransactionEvent{}), + events: eventMux.Subscribe(ChainHeadEvent{}, RemovedTransactionEvent{}), quit: make(chan struct{}), } - + pool.locals = newAccountSet(pool.signer) + pool.priced = newTxPricedList(&pool.all) pool.resetState() + // Start the various events loops and return pool.wg.Add(2) go pool.eventLoop() go pool.expirationLoop() @@ -134,27 +211,48 @@ func NewTxPool(config *params.ChainConfig, eventMux *event.TypeMux, currentState func (pool *TxPool) eventLoop() { defer pool.wg.Done() + // Start a ticker and keep track of interesting pool stats to report + var prevPending, prevQueued, prevStales int + + report := time.NewTicker(statsReportInterval) + defer report.Stop() + // Track chain events. When a chain events occurs (new chain canon block) // we need to know the new state. The new state will help us determine // the nonces in the managed state - for ev := range pool.events.Chan() { - switch ev := ev.Data.(type) { - case ChainHeadEvent: - pool.mu.Lock() - if ev.Block != nil { - if pool.config.IsHomestead(ev.Block.Number()) { - pool.homestead = true + for { + select { + // Handle any events fired by the system + case ev, ok := <-pool.events.Chan(): + if !ok { + return + } + switch ev := ev.Data.(type) { + case ChainHeadEvent: + pool.mu.Lock() + if ev.Block != nil { + if pool.chainconfig.IsHomestead(ev.Block.Number()) { + pool.homestead = true + } } + pool.resetState() + pool.mu.Unlock() + + case RemovedTransactionEvent: + pool.addTxs(ev.Txs, false) } - pool.resetState() - pool.mu.Unlock() - case GasPriceChanged: - pool.mu.Lock() - pool.minGasPrice = ev.Price - pool.mu.Unlock() - case RemovedTransactionEvent: - pool.AddBatch(ev.Txs) + // Handle stats reporting ticks + case <-report.C: + pool.mu.RLock() + pending, queued := pool.stats() + stales := pool.priced.stales + pool.mu.RUnlock() + + if pending != prevPending || queued != prevQueued || stales != prevStales { + log.Debug("Transaction pool status report", "executable", pending, "queued", queued, "stales", stales) + prevPending, prevQueued, prevStales = pending, queued, stales + } } } } @@ -180,9 +278,10 @@ func (pool *TxPool) resetState() { } // Check the queue and move transactions over to the pending if possible // or remove those that have become invalid - pool.promoteExecutables(currentState) + pool.promoteExecutables(currentState, nil) } +// Stop terminates the transaction pool. func (pool *TxPool) Stop() { pool.events.Unsubscribe() close(pool.quit) @@ -191,6 +290,28 @@ func (pool *TxPool) Stop() { log.Info("Transaction pool stopped") } +// GasPrice returns the current gas price enforced by the transaction pool. +func (pool *TxPool) GasPrice() *big.Int { + pool.mu.RLock() + defer pool.mu.RUnlock() + + return new(big.Int).Set(pool.gasPrice) +} + +// SetGasPrice updates the minimum price required by the transaction pool for a +// new transaction, and drops all transactions below this threshold. +func (pool *TxPool) SetGasPrice(price *big.Int) { + pool.mu.Lock() + defer pool.mu.Unlock() + + pool.gasPrice = price + for _, tx := range pool.priced.Cap(price, pool.locals) { + pool.removeTx(tx.Hash()) + } + log.Info("Transaction pool price threshold updated", "price", price) +} + +// State returns the virtual managed state of the transaction pool. func (pool *TxPool) State() *state.ManagedState { pool.mu.RLock() defer pool.mu.RUnlock() @@ -200,17 +321,25 @@ func (pool *TxPool) State() *state.ManagedState { // Stats retrieves the current pool stats, namely the number of pending and the // number of queued (non-executable) transactions. -func (pool *TxPool) Stats() (pending int, queued int) { +func (pool *TxPool) Stats() (int, int) { pool.mu.RLock() defer pool.mu.RUnlock() + return pool.stats() +} + +// stats retrieves the current pool stats, namely the number of pending and the +// number of queued (non-executable) transactions. +func (pool *TxPool) stats() (int, int) { + pending := 0 for _, list := range pool.pending { pending += list.Len() } + queued := 0 for _, list := range pool.queue { queued += list.Len() } - return + return pending, queued } // Content retrieves the data content of the transaction pool, returning all the @@ -237,17 +366,6 @@ func (pool *TxPool) Pending() (map[common.Address]types.Transactions, error) { pool.mu.Lock() defer pool.mu.Unlock() - state, err := pool.currentState() - if err != nil { - return nil, err - } - - // check queue first - pool.promoteExecutables(state) - - // invalidate any txs - pool.demoteUnexecutables(state) - pending := make(map[common.Address]types.Transactions) for addr, list := range pool.pending { pending[addr] = list.Flatten() @@ -255,106 +373,146 @@ func (pool *TxPool) Pending() (map[common.Address]types.Transactions, error) { return pending, nil } -// SetLocal marks a transaction as local, skipping gas price -// check against local miner minimum in the future -func (pool *TxPool) SetLocal(tx *types.Transaction) { - pool.mu.Lock() - defer pool.mu.Unlock() - pool.localTx.add(tx.Hash()) -} - -// validateTx checks whether a transaction is valid according -// to the consensus rules. -func (pool *TxPool) validateTx(tx *types.Transaction) error { - local := pool.localTx.contains(tx.Hash()) - // Drop transactions under our own minimal accepted gas price - if !local && pool.minGasPrice.Cmp(tx.GasPrice()) > 0 { - return ErrCheap +// validateTx checks whether a transaction is valid according to the consensus +// rules and adheres to some heuristic limits of the local node (price and size). +func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error { + // Heuristic limit, reject transactions over 32KB to prevent DOS attacks + if tx.Size() > 32*1024 { + return ErrOversizedData } - - currentState, err := pool.currentState() - if err != nil { - return err + // Transactions can't be negative. This may never happen using RLP decoded + // transactions but may occur if you create a transaction using the RPC. + if tx.Value().Sign() < 0 { + return ErrNegativeValue } - + // Ensure the transaction doesn't exceed the current block limit gas. + if pool.gasLimit().Cmp(tx.Gas()) < 0 { + return ErrGasLimit + } + // Make sure the transaction is signed properly from, err := types.Sender(pool.signer, tx) if err != nil { return ErrInvalidSender } - // Last but not least check for nonce errors + // Drop non-local transactions under our own minimal accepted gas price + local = local || pool.locals.contains(from) // account may be local even if the transaction arrived from the network + if !local && pool.gasPrice.Cmp(tx.GasPrice()) > 0 { + return ErrUnderpriced + } + // Ensure the transaction adheres to nonce ordering + currentState, err := pool.currentState() + if err != nil { + return err + } if currentState.GetNonce(from) > tx.Nonce() { - return ErrNonce + return ErrNonceTooLow } - - // Check the transaction doesn't exceed the current - // block limit gas. - if pool.gasLimit().Cmp(tx.Gas()) < 0 { - return ErrGasLimit - } - - // Transactions can't be negative. This may never happen - // using RLP decoded transactions but may occur if you create - // a transaction using the RPC for example. - if tx.Value().Sign() < 0 { - return ErrNegativeValue - } - // Transactor should have enough funds to cover the costs // cost == V + GP * GL if currentState.GetBalance(from).Cmp(tx.Cost()) < 0 { return ErrInsufficientFunds } - intrGas := IntrinsicGas(tx.Data(), tx.To() == nil, pool.homestead) if tx.Gas().Cmp(intrGas) < 0 { return ErrIntrinsicGas } - return nil } // add validates a transaction and inserts it into the non-executable queue for -// later pending promotion and execution. -func (pool *TxPool) add(tx *types.Transaction) error { +// later pending promotion and execution. If the transaction is a replacement for +// an already pending or queued one, it overwrites the previous and returns this +// so outer code doesn't uselessly call promote. +// +// If a newly added transaction is marked as local, its sending account will be +// whitelisted, preventing any associated transaction from being dropped out of +// the pool due to pricing constraints. +func (pool *TxPool) add(tx *types.Transaction, local bool) (bool, error) { // If the transaction is already known, discard it hash := tx.Hash() if pool.all[hash] != nil { log.Trace("Discarding already known transaction", "hash", hash) - return fmt.Errorf("known transaction: %x", hash) + return false, fmt.Errorf("known transaction: %x", hash) } - // Otherwise ensure basic validation passes and queue it up - if err := pool.validateTx(tx); err != nil { + // If the transaction fails basic validation, discard it + if err := pool.validateTx(tx, local); err != nil { log.Trace("Discarding invalid transaction", "hash", hash, "err", err) invalidTxCounter.Inc(1) - return err + return false, err } - pool.enqueueTx(hash, tx) + // If the transaction pool is full, discard underpriced transactions + if uint64(len(pool.all)) >= pool.config.GlobalSlots+pool.config.GlobalQueue { + // If the new transaction is underpriced, don't accept it + if pool.priced.Underpriced(tx, pool.locals) { + log.Trace("Discarding underpriced transaction", "hash", hash, "price", tx.GasPrice()) + underpricedTxCounter.Inc(1) + return false, ErrUnderpriced + } + // New transaction is better than our worse ones, make room for it + drop := pool.priced.Discard(len(pool.all)-int(pool.config.GlobalSlots+pool.config.GlobalQueue-1), pool.locals) + for _, tx := range drop { + log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "price", tx.GasPrice()) + underpricedTxCounter.Inc(1) + pool.removeTx(tx.Hash()) + } + } + // If the transaction is replacing an already pending one, do directly + from, _ := types.Sender(pool.signer, tx) // already validated + if list := pool.pending[from]; list != nil && list.Overlaps(tx) { + // Nonce already pending, check if required price bump is met + inserted, old := list.Add(tx, pool.config.PriceBump) + if !inserted { + pendingDiscardCounter.Inc(1) + return false, ErrReplaceUnderpriced + } + // New transaction is better, replace old one + if old != nil { + delete(pool.all, old.Hash()) + pool.priced.Removed() + pendingReplaceCounter.Inc(1) + } + pool.all[tx.Hash()] = tx + pool.priced.Put(tx) - // Print a log message if low enough level is set - log.Debug("Pooled new transaction", "hash", hash, "from", log.Lazy{Fn: func() common.Address { from, _ := types.Sender(pool.signer, tx); return from }}, "to", tx.To()) - return nil + log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To()) + return old != nil, nil + } + // New transaction isn't replacing a pending one, push into queue and potentially mark local + replace, err := pool.enqueueTx(hash, tx) + if err != nil { + return false, err + } + if local { + pool.locals.add(from) + } + log.Trace("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To()) + return replace, nil } // enqueueTx inserts a new transaction into the non-executable transaction queue. // // Note, this method assumes the pool lock is held! -func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction) { +func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction) (bool, error) { // Try to insert the transaction into the future queue from, _ := types.Sender(pool.signer, tx) // already validated if pool.queue[from] == nil { pool.queue[from] = newTxList(false) } - inserted, old := pool.queue[from].Add(tx) + inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump) if !inserted { + // An older transaction was better, discard this queuedDiscardCounter.Inc(1) - return // An older transaction was better, discard this + return false, ErrReplaceUnderpriced } // Discard any previous transaction and mark this if old != nil { delete(pool.all, old.Hash()) + pool.priced.Removed() queuedReplaceCounter.Inc(1) } pool.all[hash] = tx + pool.priced.Put(tx) + return old != nil, nil } // promoteTx adds a transaction to the pending (processable) list of transactions. @@ -367,63 +525,109 @@ func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.T } list := pool.pending[addr] - inserted, old := list.Add(tx) + inserted, old := list.Add(tx, pool.config.PriceBump) if !inserted { // An older transaction was better, discard this delete(pool.all, hash) + pool.priced.Removed() + pendingDiscardCounter.Inc(1) return } // Otherwise discard any previous transaction and mark this if old != nil { delete(pool.all, old.Hash()) + pool.priced.Removed() + pendingReplaceCounter.Inc(1) } - pool.all[hash] = tx // Failsafe to work around direct pending inserts (tests) - + // Failsafe to work around direct pending inserts (tests) + if pool.all[hash] == nil { + pool.all[hash] = tx + pool.priced.Put(tx) + } // Set the potentially new pending nonce and notify any subsystems of the new tx pool.beats[addr] = time.Now() pool.pendingState.SetNonce(addr, tx.Nonce()+1) go pool.eventMux.Post(TxPreEvent{tx}) } -// Add queues a single transaction in the pool if it is valid. -func (pool *TxPool) Add(tx *types.Transaction) error { +// AddLocal enqueues a single transaction into the pool if it is valid, marking +// the sender as a local one in the mean time, ensuring it goes around the local +// pricing constraints. +func (pool *TxPool) AddLocal(tx *types.Transaction) error { + return pool.addTx(tx, !pool.config.NoLocals) +} + +// AddRemote enqueues a single transaction into the pool if it is valid. If the +// sender is not among the locally tracked ones, full pricing constraints will +// apply. +func (pool *TxPool) AddRemote(tx *types.Transaction) error { + return pool.addTx(tx, false) +} + +// AddLocals enqueues a batch of transactions into the pool if they are valid, +// marking the senders as a local ones in the mean time, ensuring they go around +// the local pricing constraints. +func (pool *TxPool) AddLocals(txs []*types.Transaction) error { + return pool.addTxs(txs, !pool.config.NoLocals) +} + +// AddRemotes enqueues a batch of transactions into the pool if they are valid. +// If the senders are not among the locally tracked ones, full pricing constraints +// will apply. +func (pool *TxPool) AddRemotes(txs []*types.Transaction) error { + return pool.addTxs(txs, false) +} + +// addTx enqueues a single transaction into the pool if it is valid. +func (pool *TxPool) addTx(tx *types.Transaction, local bool) error { pool.mu.Lock() defer pool.mu.Unlock() - if err := pool.add(tx); err != nil { - return err - } - - state, err := pool.currentState() + // Try to inject the transaction and update any state + replace, err := pool.add(tx, local) if err != nil { return err } - pool.promoteExecutables(state) - - return nil -} - -// AddBatch attempts to queue a batch of transactions. -func (pool *TxPool) AddBatch(txs []*types.Transaction) error { - pool.mu.Lock() - defer pool.mu.Unlock() - - // Add the batch of transaction, tracking the accepted ones - added := 0 - for _, tx := range txs { - if err := pool.add(tx); err == nil { - added++ - } - } - // Only reprocess the internal state if something was actually added - if added > 0 { + // If we added a new transaction, run promotion checks and return + if !replace { state, err := pool.currentState() if err != nil { return err } - pool.promoteExecutables(state) + from, _ := types.Sender(pool.signer, tx) // already validated + pool.promoteExecutables(state, []common.Address{from}) + } + return nil +} + +// addTxs attempts to queue a batch of transactions if they are valid. +func (pool *TxPool) addTxs(txs []*types.Transaction, local bool) error { + pool.mu.Lock() + defer pool.mu.Unlock() + + // Add the batch of transaction, tracking the accepted ones + dirty := make(map[common.Address]struct{}) + for _, tx := range txs { + if replace, err := pool.add(tx, local); err == nil { + if !replace { + from, _ := types.Sender(pool.signer, tx) // already validated + dirty[from] = struct{}{} + } + } + } + // Only reprocess the internal state if something was actually added + if len(dirty) > 0 { + state, err := pool.currentState() + if err != nil { + return err + } + addrs := make([]common.Address, 0, len(dirty)) + for addr, _ := range dirty { + addrs = append(addrs, addr) + } + pool.promoteExecutables(state, addrs) } return nil } @@ -467,6 +671,7 @@ func (pool *TxPool) removeTx(hash common.Hash) { // Remove it from the list of known transactions delete(pool.all, hash) + pool.priced.Removed() // Remove the transaction from the pending lists and reset the account nonce if pending := pool.pending[addr]; pending != nil { @@ -483,8 +688,9 @@ func (pool *TxPool) removeTx(hash common.Hash) { } // Update the account nonce if needed if nonce := tx.Nonce(); pool.pendingState.GetNonce(addr) > nonce { - pool.pendingState.SetNonce(addr, tx.Nonce()) + pool.pendingState.SetNonce(addr, nonce) } + return } } // Transaction is in the future queue @@ -499,39 +705,54 @@ func (pool *TxPool) removeTx(hash common.Hash) { // promoteExecutables moves transactions that have become processable from the // future queue to the set of pending transactions. During this process, all // invalidated transactions (low nonce, low balance) are deleted. -func (pool *TxPool) promoteExecutables(state *state.StateDB) { +func (pool *TxPool) promoteExecutables(state *state.StateDB, accounts []common.Address) { + gaslimit := pool.gasLimit() + + // Gather all the accounts potentially needing updates + if accounts == nil { + accounts = make([]common.Address, 0, len(pool.queue)) + for addr, _ := range pool.queue { + accounts = append(accounts, addr) + } + } // Iterate over all accounts and promote any executable transactions - queued := uint64(0) - for addr, list := range pool.queue { + for _, addr := range accounts { + list := pool.queue[addr] + if list == nil { + continue // Just in case someone calls with a non existing account + } // Drop all transactions that are deemed too old (low nonce) for _, tx := range list.Forward(state.GetNonce(addr)) { hash := tx.Hash() - log.Debug("Removed old queued transaction", "hash", hash) + log.Trace("Removed old queued transaction", "hash", hash) delete(pool.all, hash) + pool.priced.Removed() } - // Drop all transactions that are too costly (low balance) - drops, _ := list.Filter(state.GetBalance(addr)) + // Drop all transactions that are too costly (low balance or out of gas) + drops, _ := list.Filter(state.GetBalance(addr), gaslimit) for _, tx := range drops { hash := tx.Hash() - log.Debug("Removed unpayable queued transaction", "hash", hash) + log.Trace("Removed unpayable queued transaction", "hash", hash) delete(pool.all, hash) + pool.priced.Removed() queuedNofundsCounter.Inc(1) } // Gather all executable transactions and promote them for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) { hash := tx.Hash() - log.Debug("Promoting queued transaction", "hash", hash) + log.Trace("Promoting queued transaction", "hash", hash) pool.promoteTx(addr, hash, tx) } // Drop all transactions over the allowed limit - for _, tx := range list.Cap(int(maxQueuedPerAccount)) { - hash := tx.Hash() - log.Debug("Removed cap-exceeding queued transaction", "hash", hash) - delete(pool.all, hash) - queuedRLCounter.Inc(1) + if !pool.locals.contains(addr) { + for _, tx := range list.Cap(int(pool.config.AccountQueue)) { + hash := tx.Hash() + delete(pool.all, hash) + pool.priced.Removed() + queuedRateLimitCounter.Inc(1) + log.Trace("Removed cap-exceeding queued transaction", "hash", hash) + } } - queued += uint64(list.Len()) - // Delete the entire queue entry if it became empty. if list.Empty() { delete(pool.queue, addr) @@ -542,25 +763,19 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) { for _, list := range pool.pending { pending += uint64(list.Len()) } - if pending > maxPendingTotal { + if pending > pool.config.GlobalSlots { pendingBeforeCap := pending // Assemble a spam order to penalize large transactors first spammers := prque.New() for addr, list := range pool.pending { // Only evict transactions from high rollers - if uint64(list.Len()) > minPendingPerAccount { - // Skip local accounts as pools should maintain backlogs for themselves - for _, tx := range list.txs.items { - if !pool.localTx.contains(tx.Hash()) { - spammers.Push(addr, float32(list.Len())) - } - break // Checking on transaction for locality is enough - } + if !pool.locals.contains(addr) && uint64(list.Len()) > pool.config.AccountSlots { + spammers.Push(addr, float32(list.Len())) } } // Gradually drop transactions from offenders offenders := []common.Address{} - for pending > maxPendingTotal && !spammers.Empty() { + for pending > pool.config.GlobalSlots && !spammers.Empty() { // Retrieve the next offender if not local address offender, _ := spammers.Pop() offenders = append(offenders, offender.(common.Address)) @@ -571,38 +786,66 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) { threshold := pool.pending[offender.(common.Address)].Len() // Iteratively reduce all offenders until below limit or threshold reached - for pending > maxPendingTotal && pool.pending[offenders[len(offenders)-2]].Len() > threshold { + for pending > pool.config.GlobalSlots && pool.pending[offenders[len(offenders)-2]].Len() > threshold { for i := 0; i < len(offenders)-1; i++ { list := pool.pending[offenders[i]] - list.Cap(list.Len() - 1) + for _, tx := range list.Cap(list.Len() - 1) { + // Drop the transaction from the global pools too + hash := tx.Hash() + delete(pool.all, hash) + pool.priced.Removed() + + // Update the account nonce to the dropped transaction + if nonce := tx.Nonce(); pool.pendingState.GetNonce(offenders[i]) > nonce { + pool.pendingState.SetNonce(offenders[i], nonce) + } + log.Trace("Removed fairness-exceeding pending transaction", "hash", hash) + } pending-- } } } } // If still above threshold, reduce to limit or min allowance - if pending > maxPendingTotal && len(offenders) > 0 { - for pending > maxPendingTotal && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > minPendingPerAccount { + if pending > pool.config.GlobalSlots && len(offenders) > 0 { + for pending > pool.config.GlobalSlots && uint64(pool.pending[offenders[len(offenders)-1]].Len()) > pool.config.AccountSlots { for _, addr := range offenders { list := pool.pending[addr] - list.Cap(list.Len() - 1) + for _, tx := range list.Cap(list.Len() - 1) { + // Drop the transaction from the global pools too + hash := tx.Hash() + delete(pool.all, hash) + pool.priced.Removed() + + // Update the account nonce to the dropped transaction + if nonce := tx.Nonce(); pool.pendingState.GetNonce(addr) > nonce { + pool.pendingState.SetNonce(addr, nonce) + } + log.Trace("Removed fairness-exceeding pending transaction", "hash", hash) + } pending-- } } } - pendingRLCounter.Inc(int64(pendingBeforeCap - pending)) + pendingRateLimitCounter.Inc(int64(pendingBeforeCap - pending)) } // If we've queued more transactions than the hard limit, drop oldest ones - if queued > maxQueuedInTotal { + queued := uint64(0) + for _, list := range pool.queue { + queued += uint64(list.Len()) + } + if queued > pool.config.GlobalQueue { // Sort all accounts with queued transactions by heartbeat addresses := make(addresssByHeartbeat, 0, len(pool.queue)) for addr := range pool.queue { - addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]}) + if !pool.locals.contains(addr) { // don't drop locals + addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]}) + } } sort.Sort(addresses) - // Drop transactions until the total is below the limit - for drop := queued - maxQueuedInTotal; drop > 0; { + // Drop transactions until the total is below the limit or only locals remain + for drop := queued - pool.config.GlobalQueue; drop > 0 && len(addresses) > 0; { addr := addresses[len(addresses)-1] list := pool.queue[addr.address] @@ -614,7 +857,7 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) { pool.removeTx(tx.Hash()) } drop -= size - queuedRLCounter.Inc(int64(size)) + queuedRateLimitCounter.Inc(int64(size)) continue } // Otherwise drop only last few transactions @@ -622,7 +865,7 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) { for i := len(txs) - 1; i >= 0 && drop > 0; i-- { pool.removeTx(txs[i].Hash()) drop-- - queuedRLCounter.Inc(1) + queuedRateLimitCounter.Inc(1) } } } @@ -632,6 +875,8 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) { // executable/pending queue and any subsequent transactions that become unexecutable // are moved back into the future queue. func (pool *TxPool) demoteUnexecutables(state *state.StateDB) { + gaslimit := pool.gasLimit() + // Iterate over all accounts and demote any non-executable transactions for addr, list := range pool.pending { nonce := state.GetNonce(addr) @@ -639,20 +884,22 @@ func (pool *TxPool) demoteUnexecutables(state *state.StateDB) { // Drop all transactions that are deemed too old (low nonce) for _, tx := range list.Forward(nonce) { hash := tx.Hash() - log.Debug("Removed old pending transaction", "hash", hash) + log.Trace("Removed old pending transaction", "hash", hash) delete(pool.all, hash) + pool.priced.Removed() } - // Drop all transactions that are too costly (low balance), and queue any invalids back for later - drops, invalids := list.Filter(state.GetBalance(addr)) + // Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later + drops, invalids := list.Filter(state.GetBalance(addr), gaslimit) for _, tx := range drops { hash := tx.Hash() - log.Debug("Removed unpayable pending transaction", "hash", hash) + log.Trace("Removed unpayable pending transaction", "hash", hash) delete(pool.all, hash) + pool.priced.Removed() pendingNofundsCounter.Inc(1) } for _, tx := range invalids { hash := tx.Hash() - log.Debug("Demoting pending transaction", "hash", hash) + log.Trace("Demoting pending transaction", "hash", hash) pool.enqueueTx(hash, tx) } // Delete the entire queue entry if it became empty. @@ -677,7 +924,12 @@ func (pool *TxPool) expirationLoop() { case <-evict.C: pool.mu.Lock() for addr := range pool.queue { - if time.Since(pool.beats[addr]) > maxQueuedLifetime { + // Skip local transactions from the eviction mechanism + if pool.locals.contains(addr) { + continue + } + // Any non-locals old enough should be removed + if time.Since(pool.beats[addr]) > pool.config.Lifetime { for _, tx := range pool.queue[addr].Flatten() { pool.removeTx(tx.Hash()) } @@ -703,48 +955,38 @@ func (a addresssByHeartbeat) Len() int { return len(a) } func (a addresssByHeartbeat) Less(i, j int) bool { return a[i].heartbeat.Before(a[j].heartbeat) } func (a addresssByHeartbeat) Swap(i, j int) { a[i], a[j] = a[j], a[i] } -// txSet represents a set of transaction hashes in which entries -// are automatically dropped after txSetDuration time -type txSet struct { - txMap map[common.Hash]struct{} - txOrd map[uint64]txOrdType - addPtr, delPtr uint64 +// accountSet is simply a set of addresses to check for existance, and a signer +// capable of deriving addresses from transactions. +type accountSet struct { + accounts map[common.Address]struct{} + signer types.Signer } -const txSetDuration = time.Hour * 2 - -// txOrdType represents an entry in the time-ordered list of transaction hashes -type txOrdType struct { - hash common.Hash - time time.Time -} - -// newTxSet creates a new transaction set -func newTxSet() *txSet { - return &txSet{ - txMap: make(map[common.Hash]struct{}), - txOrd: make(map[uint64]txOrdType), +// newAccountSet creates a new address set with an associated signer for sender +// derivations. +func newAccountSet(signer types.Signer) *accountSet { + return &accountSet{ + accounts: make(map[common.Address]struct{}), + signer: signer, } } -// contains returns true if the set contains the given transaction hash -// (not thread safe, should be called from a locked environment) -func (self *txSet) contains(hash common.Hash) bool { - _, ok := self.txMap[hash] - return ok +// contains checks if a given address is contained within the set. +func (as *accountSet) contains(addr common.Address) bool { + _, exist := as.accounts[addr] + return exist } -// add adds a transaction hash to the set, then removes entries older than txSetDuration -// (not thread safe, should be called from a locked environment) -func (self *txSet) add(hash common.Hash) { - self.txMap[hash] = struct{}{} - now := time.Now() - self.txOrd[self.addPtr] = txOrdType{hash: hash, time: now} - self.addPtr++ - delBefore := now.Add(-txSetDuration) - for self.delPtr < self.addPtr && self.txOrd[self.delPtr].time.Before(delBefore) { - delete(self.txMap, self.txOrd[self.delPtr].hash) - delete(self.txOrd, self.delPtr) - self.delPtr++ +// containsTx checks if the sender of a given tx is within the set. If the sender +// cannot be derived, this method returns false. +func (as *accountSet) containsTx(tx *types.Transaction) bool { + if addr, err := types.Sender(as.signer, tx); err == nil { + return as.contains(addr) } + return false +} + +// add inserts a new address into the set to track. +func (as *accountSet) add(addr common.Address) { + as.accounts[addr] = struct{}{} } diff --git a/vendor/github.com/ethereum/go-ethereum/core/types/block.go b/vendor/github.com/ethereum/go-ethereum/core/types/block.go index 8ca3d0e89..1d00d9f93 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/types/block.go +++ b/vendor/github.com/ethereum/go-ethereum/core/types/block.go @@ -381,7 +381,7 @@ func (b *Block) Hash() common.Hash { if hash := b.hash.Load(); hash != nil { return hash.(common.Hash) } - v := rlpHash(b.header) + v := b.header.Hash() b.hash.Store(v) return v } diff --git a/vendor/github.com/ethereum/go-ethereum/core/types/transaction_signing.go b/vendor/github.com/ethereum/go-ethereum/core/types/transaction_signing.go index b4bab0aad..ba4f2aa03 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/types/transaction_signing.go +++ b/vendor/github.com/ethereum/go-ethereum/core/types/transaction_signing.go @@ -27,7 +27,12 @@ import ( "github.com/ethereum/go-ethereum/params" ) -var ErrInvalidChainId = errors.New("invalid chaid id for signer") +var ( + ErrInvalidChainId = errors.New("invalid chain id for signer") + + errAbstractSigner = errors.New("abstract signer") + abstractSignerAddress = common.HexToAddress("ffffffffffffffffffffffffffffffffffffffff") +) // sigCache is used to cache the derived sender and contains // the signer used to derive it. diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/analysis.go b/vendor/github.com/ethereum/go-ethereum/core/vm/analysis.go index a0f615821..d5f048d1d 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/analysis.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/analysis.go @@ -22,41 +22,39 @@ import ( "github.com/ethereum/go-ethereum/common" ) -var bigMaxUint64 = new(big.Int).SetUint64(^uint64(0)) - // destinations stores one map per contract (keyed by hash of code). // The maps contain an entry for each location of a JUMPDEST // instruction. -type destinations map[common.Hash]map[uint64]struct{} +type destinations map[common.Hash][]byte // has checks whether code has a JUMPDEST at dest. func (d destinations) has(codehash common.Hash, code []byte, dest *big.Int) bool { - // PC cannot go beyond len(code) and certainly can't be bigger than 64bits. + // PC cannot go beyond len(code) and certainly can't be bigger than 63bits. // Don't bother checking for JUMPDEST in that case. - if dest.Cmp(bigMaxUint64) > 0 { + udest := dest.Uint64() + if dest.BitLen() >= 63 || udest >= uint64(len(code)) { return false } + m, analysed := d[codehash] if !analysed { m = jumpdests(code) d[codehash] = m } - _, ok := m[dest.Uint64()] - return ok + return (m[udest/8] & (1 << (udest % 8))) != 0 } // jumpdests creates a map that contains an entry for each // PC location that is a JUMPDEST instruction. -func jumpdests(code []byte) map[uint64]struct{} { - m := make(map[uint64]struct{}) +func jumpdests(code []byte) []byte { + m := make([]byte, len(code)/8+1) for pc := uint64(0); pc < uint64(len(code)); pc++ { - var op OpCode = OpCode(code[pc]) - switch op { - case PUSH1, PUSH2, PUSH3, PUSH4, PUSH5, PUSH6, PUSH7, PUSH8, PUSH9, PUSH10, PUSH11, PUSH12, PUSH13, PUSH14, PUSH15, PUSH16, PUSH17, PUSH18, PUSH19, PUSH20, PUSH21, PUSH22, PUSH23, PUSH24, PUSH25, PUSH26, PUSH27, PUSH28, PUSH29, PUSH30, PUSH31, PUSH32: + op := OpCode(code[pc]) + if op == JUMPDEST { + m[pc/8] |= 1 << (pc % 8) + } else if op >= PUSH1 && op <= PUSH32 { a := uint64(op) - uint64(PUSH1) + 1 pc += a - case JUMPDEST: - m[pc] = struct{}{} } } return m diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/contracts.go b/vendor/github.com/ethereum/go-ethereum/core/vm/contracts.go index e87640d02..90b2f913e 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/contracts.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/contracts.go @@ -18,6 +18,7 @@ package vm import ( "crypto/sha256" + "errors" "math/big" "github.com/ethereum/go-ethereum/common" @@ -27,15 +28,17 @@ import ( "golang.org/x/crypto/ripemd160" ) +var errBadPrecompileInput = errors.New("bad pre compile input") + // Precompiled contract is the basic interface for native Go contracts. The implementation // requires a deterministic gas count based on the input size of the Run method of the // contract. type PrecompiledContract interface { - RequiredGas(inputSize int) uint64 // RequiredPrice calculates the contract gas use - Run(input []byte) []byte // Run runs the precompiled contract + RequiredGas(input []byte) uint64 // RequiredPrice calculates the contract gas use + Run(input []byte) ([]byte, error) // Run runs the precompiled contract } -// Precompiled contains the default set of ethereum contracts +// PrecompiledContracts contains the default set of ethereum contracts var PrecompiledContracts = map[common.Address]PrecompiledContract{ common.BytesToAddress([]byte{1}): &ecrecover{}, common.BytesToAddress([]byte{2}): &sha256hash{}, @@ -45,11 +48,9 @@ var PrecompiledContracts = map[common.Address]PrecompiledContract{ // RunPrecompile runs and evaluate the output of a precompiled contract defined in contracts.go func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contract) (ret []byte, err error) { - gas := p.RequiredGas(len(input)) + gas := p.RequiredGas(input) if contract.UseGas(gas) { - ret = p.Run(input) - - return ret, nil + return p.Run(input) } else { return nil, ErrOutOfGas } @@ -58,11 +59,11 @@ func RunPrecompiledContract(p PrecompiledContract, input []byte, contract *Contr // ECRECOVER implemented as a native contract type ecrecover struct{} -func (c *ecrecover) RequiredGas(inputSize int) uint64 { +func (c *ecrecover) RequiredGas(input []byte) uint64 { return params.EcrecoverGas } -func (c *ecrecover) Run(in []byte) []byte { +func (c *ecrecover) Run(in []byte) ([]byte, error) { const ecRecoverInputLength = 128 in = common.RightPadBytes(in, ecRecoverInputLength) @@ -76,18 +77,18 @@ func (c *ecrecover) Run(in []byte) []byte { // tighter sig s values in homestead only apply to tx sigs if !allZero(in[32:63]) || !crypto.ValidateSignatureValues(v, r, s, false) { log.Trace("ECRECOVER error: v, r or s value invalid") - return nil + return nil, nil } // v needs to be at the end for libsecp256k1 pubKey, err := crypto.Ecrecover(in[:32], append(in[64:128], v)) // make sure the public key is a valid one if err != nil { log.Trace("ECRECOVER failed", "err", err) - return nil + return nil, nil } // the first byte of pubkey is bitcoin heritage - return common.LeftPadBytes(crypto.Keccak256(pubKey[1:])[12:], 32) + return common.LeftPadBytes(crypto.Keccak256(pubKey[1:])[12:], 32), nil } // SHA256 implemented as a native contract @@ -97,12 +98,12 @@ type sha256hash struct{} // // This method does not require any overflow checking as the input size gas costs // required for anything significant is so high it's impossible to pay for. -func (c *sha256hash) RequiredGas(inputSize int) uint64 { - return uint64(inputSize+31)/32*params.Sha256WordGas + params.Sha256Gas +func (c *sha256hash) RequiredGas(input []byte) uint64 { + return uint64(len(input)+31)/32*params.Sha256WordGas + params.Sha256Gas } -func (c *sha256hash) Run(in []byte) []byte { +func (c *sha256hash) Run(in []byte) ([]byte, error) { h := sha256.Sum256(in) - return h[:] + return h[:], nil } // RIPMED160 implemented as a native contract @@ -112,13 +113,13 @@ type ripemd160hash struct{} // // This method does not require any overflow checking as the input size gas costs // required for anything significant is so high it's impossible to pay for. -func (c *ripemd160hash) RequiredGas(inputSize int) uint64 { - return uint64(inputSize+31)/32*params.Ripemd160WordGas + params.Ripemd160Gas +func (c *ripemd160hash) RequiredGas(input []byte) uint64 { + return uint64(len(input)+31)/32*params.Ripemd160WordGas + params.Ripemd160Gas } -func (c *ripemd160hash) Run(in []byte) []byte { +func (c *ripemd160hash) Run(in []byte) ([]byte, error) { ripemd := ripemd160.New() ripemd.Write(in) - return common.LeftPadBytes(ripemd.Sum(nil), 32) + return common.LeftPadBytes(ripemd.Sum(nil), 32), nil } // data copy implemented as a native contract @@ -128,9 +129,9 @@ type dataCopy struct{} // // This method does not require any overflow checking as the input size gas costs // required for anything significant is so high it's impossible to pay for. -func (c *dataCopy) RequiredGas(inputSize int) uint64 { - return uint64(inputSize+31)/32*params.IdentityWordGas + params.IdentityGas +func (c *dataCopy) RequiredGas(input []byte) uint64 { + return uint64(len(input)+31)/32*params.IdentityWordGas + params.IdentityGas } -func (c *dataCopy) Run(in []byte) []byte { - return in +func (c *dataCopy) Run(in []byte) ([]byte, error) { + return in, nil } diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/evm.go b/vendor/github.com/ethereum/go-ethereum/core/vm/evm.go index 71efcfa45..9296cc7ca 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/evm.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/evm.go @@ -33,7 +33,20 @@ type ( GetHashFunc func(uint64) common.Hash ) -// Context provides the EVM with auxiliary information. Once provided it shouldn't be modified. +// 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) { + if contract.CodeAddr != nil { + precompiledContracts := PrecompiledContracts + if p := precompiledContracts[*contract.CodeAddr]; p != nil { + return RunPrecompiledContract(p, input, contract) + } + } + + return evm.interpreter.Run(snapshot, contract, input) +} + +// Context provides the EVM with auxiliary information. Once provided +// it shouldn't be modified. type Context struct { // CanTransfer returns whether the account contains // sufficient ether to transfer the value @@ -55,7 +68,13 @@ type Context struct { Difficulty *big.Int // Provides information for DIFFICULTY } -// EVM provides information about external sources for the EVM +// EVM is the Ethereum Virtual Machine base object and provides +// the necessary tools to run a contract on the given state with +// the provided context. It should be noted that any error +// generated through any of the calls should be considered a +// revert-state-and-consume-all-gas operation, no checks on +// specific errors should ever be performed. The interpreter makes +// sure that any errors generated are to be considered faulty code. // // The EVM should never be reused and is not thread safe. type EVM struct { @@ -68,6 +87,8 @@ type EVM struct { // chainConfig contains information about the current chain chainConfig *params.ChainConfig + // chain rules contains the chain rules for the current epoch + chainRules params.Rules // virtual machine configuration options used to initialise the // evm. vmConfig Config @@ -79,21 +100,23 @@ type EVM struct { abort int32 } -// NewEVM retutrns a new EVM evmironment. +// NewEVM retutrns a new EVM evmironment. The returned EVM is not thread safe +// and should only ever be used *once*. func NewEVM(ctx Context, statedb StateDB, chainConfig *params.ChainConfig, vmConfig Config) *EVM { evm := &EVM{ Context: ctx, StateDB: statedb, vmConfig: vmConfig, chainConfig: chainConfig, + chainRules: chainConfig.Rules(ctx.BlockNumber), } evm.interpreter = NewInterpreter(evm, vmConfig) return evm } -// Cancel cancels any running EVM operation. This may be called concurrently and it's safe to be -// called multiple times. +// Cancel cancels any running EVM operation. This may be called concurrently and +// it's safe to be called multiple times. func (evm *EVM) Cancel() { atomic.StoreInt32(&evm.abort, 1) } @@ -134,13 +157,12 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas contract := NewContract(caller, to, value, gas) contract.SetCallCode(&addr, evm.StateDB.GetCodeHash(addr), evm.StateDB.GetCode(addr)) - ret, err = evm.interpreter.Run(contract, input) + ret, err = run(evm, snapshot, 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. if err != nil { contract.UseGas(contract.Gas) - evm.StateDB.RevertToSnapshot(snapshot) } return ret, contract.Gas, err @@ -175,10 +197,9 @@ 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 = evm.interpreter.Run(contract, input) + ret, err = run(evm, snapshot, contract, input) if err != nil { contract.UseGas(contract.Gas) - evm.StateDB.RevertToSnapshot(snapshot) } @@ -210,10 +231,9 @@ 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 = evm.interpreter.Run(contract, input) + ret, err = run(evm, snapshot, contract, input) if err != nil { contract.UseGas(contract.Gas) - evm.StateDB.RevertToSnapshot(snapshot) } @@ -253,8 +273,7 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I contract := NewContract(caller, AccountRef(contractAddr), value, gas) contract.SetCallCode(&contractAddr, crypto.Keccak256Hash(code), code) - ret, err = evm.interpreter.Run(contract, nil) - + ret, err = run(evm, snapshot, contract, nil) // check whether the max code size has been exceeded maxCodeSizeExceeded := len(ret) > params.MaxCodeSize // if the contract creation ran successfully and no errors were returned @@ -275,10 +294,8 @@ func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.I // when we're in homestead this also counts for code storage gas errors. if maxCodeSizeExceeded || (err != nil && (evm.ChainConfig().IsHomestead(evm.BlockNumber) || err != ErrCodeStoreOutOfGas)) { + contract.UseGas(contract.Gas) evm.StateDB.RevertToSnapshot(snapshot) - - // Nothing should be returned when an error is thrown. - return nil, contractAddr, 0, err } // If the vm returned with an error the return value should be set to nil. // This isn't consensus critical but merely to for behaviour reasons such as diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/gas_table.go b/vendor/github.com/ethereum/go-ethereum/core/vm/gas_table.go index 24ad6caa5..761ca4450 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/gas_table.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/gas_table.go @@ -17,7 +17,6 @@ package vm import ( - gmath "math" "math/big" "github.com/ethereum/go-ethereum/common" @@ -28,15 +27,20 @@ import ( // memoryGasCosts calculates the quadratic gas for memory expansion. It does so // only for the memory region that is expanded, not the total memory. func memoryGasCost(mem *Memory, newMemSize uint64) (uint64, error) { - // The maximum that will fit in a uint64 is max_word_count - 1 - // anything above that will result in an overflow. - if newMemSize > gmath.MaxUint64-32 { - return 0, errGasUintOverflow - } if newMemSize == 0 { return 0, nil } + // The maximum that will fit in a uint64 is max_word_count - 1 + // anything above that will result in an overflow. + // Additionally, a newMemSize which results in a + // newMemSizeWords larger than 0x7ffffffff will cause the square operation + // to overflow. + // The constant 0xffffffffe0 is the highest number that can be used without + // overflowing the gas calculation + if newMemSize > 0xffffffffe0 { + return 0, errGasUintOverflow + } newMemSizeWords := toWordSize(newMemSize) newMemSize = newMemSizeWords * 32 diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/gen_structlog.go b/vendor/github.com/ethereum/go-ethereum/core/vm/gen_structlog.go new file mode 100644 index 000000000..88df942dc --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/gen_structlog.go @@ -0,0 +1,99 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package vm + +import ( + "encoding/json" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" +) + +func (s StructLog) MarshalJSON() ([]byte, error) { + type StructLog struct { + Pc uint64 `json:"pc"` + Op OpCode `json:"op"` + Gas math.HexOrDecimal64 `json:"gas"` + GasCost math.HexOrDecimal64 `json:"gasCost"` + Memory hexutil.Bytes `json:"memory"` + MemorySize int `json:"memSize"` + Stack []*math.HexOrDecimal256 `json:"stack"` + Storage map[common.Hash]common.Hash `json:"-"` + Depth int `json:"depth"` + Err error `json:"error"` + OpName string `json:"opName"` + } + var enc StructLog + enc.Pc = s.Pc + enc.Op = s.Op + enc.Gas = math.HexOrDecimal64(s.Gas) + enc.GasCost = math.HexOrDecimal64(s.GasCost) + enc.Memory = s.Memory + enc.MemorySize = s.MemorySize + if s.Stack != nil { + enc.Stack = make([]*math.HexOrDecimal256, len(s.Stack)) + for k, v := range s.Stack { + enc.Stack[k] = (*math.HexOrDecimal256)(v) + } + } + enc.Storage = s.Storage + enc.Depth = s.Depth + enc.Err = s.Err + enc.OpName = s.OpName() + return json.Marshal(&enc) +} + +func (s *StructLog) UnmarshalJSON(input []byte) error { + type StructLog struct { + Pc *uint64 `json:"pc"` + Op *OpCode `json:"op"` + Gas *math.HexOrDecimal64 `json:"gas"` + GasCost *math.HexOrDecimal64 `json:"gasCost"` + Memory hexutil.Bytes `json:"memory"` + MemorySize *int `json:"memSize"` + Stack []*math.HexOrDecimal256 `json:"stack"` + Storage map[common.Hash]common.Hash `json:"-"` + Depth *int `json:"depth"` + Err *error `json:"error"` + } + var dec StructLog + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Pc != nil { + s.Pc = *dec.Pc + } + if dec.Op != nil { + s.Op = *dec.Op + } + if dec.Gas != nil { + s.Gas = uint64(*dec.Gas) + } + if dec.GasCost != nil { + s.GasCost = uint64(*dec.GasCost) + } + if dec.Memory != nil { + s.Memory = dec.Memory + } + if dec.MemorySize != nil { + s.MemorySize = *dec.MemorySize + } + if dec.Stack != nil { + s.Stack = make([]*big.Int, len(dec.Stack)) + for k, v := range dec.Stack { + s.Stack[k] = (*big.Int)(v) + } + } + if dec.Storage != nil { + s.Storage = dec.Storage + } + if dec.Depth != nil { + s.Depth = *dec.Depth + } + if dec.Err != nil { + s.Err = *dec.Err + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/instructions.go b/vendor/github.com/ethereum/go-ethereum/core/vm/instructions.go index bfc0a668e..f5164fcdd 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/instructions.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/instructions.go @@ -27,7 +27,9 @@ import ( "github.com/ethereum/go-ethereum/params" ) -var bigZero = new(big.Int) +var ( + bigZero = new(big.Int) +) func opAdd(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { x, y := stack.pop(), stack.pop() @@ -254,15 +256,14 @@ func opXor(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stac } func opByte(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - th, val := stack.pop(), stack.pop() - if th.Cmp(big.NewInt(32)) < 0 { - byte := evm.interpreter.intPool.get().SetInt64(int64(math.PaddedBigBytes(val, 32)[th.Int64()])) - stack.push(byte) + th, val := stack.pop(), stack.peek() + if th.Cmp(common.Big32) < 0 { + b := math.Byte(val, 32, int(th.Int64())) + val.SetUint64(uint64(b)) } else { - stack.push(new(big.Int)) + val.SetUint64(0) } - - evm.interpreter.intPool.put(th, val) + evm.interpreter.intPool.put(th) return nil, nil } func opAddmod(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { @@ -599,7 +600,7 @@ func opCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Sta contract.Gas += returnGas evm.interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize) - return nil, nil + return ret, nil } func opCallCode(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { @@ -633,16 +634,10 @@ func opCallCode(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack contract.Gas += returnGas evm.interpreter.intPool.put(addr, value, inOffset, inSize, retOffset, retSize) - return nil, nil + return ret, nil } func opDelegateCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - // if not homestead return an error. DELEGATECALL is not supported - // during pre-homestead. - if !evm.ChainConfig().IsHomestead(evm.BlockNumber) { - return nil, fmt.Errorf("invalid opcode %x", DELEGATECALL) - } - gas, to, inOffset, inSize, outOffset, outSize := stack.pop().Uint64(), stack.pop(), stack.pop(), stack.pop(), stack.pop(), stack.pop() toAddr := common.BigToAddress(to) @@ -658,7 +653,7 @@ func opDelegateCall(pc *uint64, evm *EVM, contract *Contract, memory *Memory, st contract.Gas += returnGas evm.interpreter.intPool.put(to, inOffset, inSize, outOffset, outSize) - return nil, nil + return ret, nil } func opReturn(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { @@ -666,6 +661,7 @@ func opReturn(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *S ret := memory.GetPtr(offset.Int64(), size.Int64()) evm.interpreter.intPool.put(offset, size) + return ret, nil } @@ -709,10 +705,23 @@ func makeLog(size int) executionFunc { } // make push instruction function -func makePush(size uint64, bsize *big.Int) executionFunc { +func makePush(size uint64, pushByteSize int) executionFunc { return func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - byts := getData(contract.Code, evm.interpreter.intPool.get().SetUint64(*pc+1), bsize) - stack.push(new(big.Int).SetBytes(byts)) + codeLen := len(contract.Code) + + startMin := codeLen + if int(*pc+1) < startMin { + startMin = int(*pc + 1) + } + + endMin := codeLen + if startMin+pushByteSize < endMin { + endMin = startMin + pushByteSize + } + + integer := evm.interpreter.intPool.get() + stack.push(integer.SetBytes(common.RightPadBytes(contract.Code[startMin:endMin], pushByteSize))) + *pc += size return nil, nil } @@ -721,7 +730,7 @@ func makePush(size uint64, bsize *big.Int) executionFunc { // make push instruction function func makeDup(size int64) executionFunc { return func(pc *uint64, evm *EVM, contract *Contract, memory *Memory, stack *Stack) ([]byte, error) { - stack.dup(int(size)) + stack.dup(evm.interpreter.intPool, int(size)) return nil, nil } } diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/interpreter.go b/vendor/github.com/ethereum/go-ethereum/core/vm/interpreter.go index 8ee9d3ca7..545f7d650 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/interpreter.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/interpreter.go @@ -52,43 +52,53 @@ type Config struct { } // Interpreter is used to run Ethereum based contracts and will utilise the -// passed environment to query external sources for state information. +// passed evmironment to query external sources for state information. // The Interpreter will run the byte code VM or JIT VM based on the passed // configuration. type Interpreter struct { - env *EVM + evm *EVM cfg Config gasTable params.GasTable intPool *intPool + + readonly bool } // NewInterpreter returns a new instance of the Interpreter. -func NewInterpreter(env *EVM, cfg Config) *Interpreter { +func NewInterpreter(evm *EVM, cfg Config) *Interpreter { // We use the STOP instruction whether to see // the jump table was initialised. If it was not // we'll set the default jump table. if !cfg.JumpTable[STOP].valid { - cfg.JumpTable = defaultJumpTable + switch { + case evm.ChainConfig().IsHomestead(evm.BlockNumber): + cfg.JumpTable = homesteadInstructionSet + default: + cfg.JumpTable = frontierInstructionSet + } } return &Interpreter{ - env: env, + evm: evm, cfg: cfg, - gasTable: env.ChainConfig().GasTable(env.BlockNumber), + gasTable: evm.ChainConfig().GasTable(evm.BlockNumber), intPool: newIntPool(), } } -// Run loops and evaluates the contract's code with the given input data -func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err error) { - evm.env.depth++ - defer func() { evm.env.depth-- }() +func (in *Interpreter) enforceRestrictions(op OpCode, operation operation, stack *Stack) error { + return nil +} - if contract.CodeAddr != nil { - if p := PrecompiledContracts[*contract.CodeAddr]; p != nil { - return RunPrecompiledContract(p, input, contract) - } - } +// Run loops and evaluates the contract's code with the given input data and returns +// 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) { + in.evm.depth++ + defer func() { in.evm.depth-- }() // Don't bother with the execution if there's no code. if len(contract.Code) == 0 { @@ -105,7 +115,8 @@ func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err e mem = NewMemory() // bound memory stack = newstack() // local stack // For optimisation reason we're using uint64 as the program counter. - // It's theoretically possible to go above 2^64. The YP defines the PC to be uint256. Practically much less so feasible. + // It's theoretically possible to go above 2^64. The YP defines the PC + // to be uint256. Practically much less so feasible. pc = uint64(0) // program counter cost uint64 ) @@ -113,31 +124,34 @@ func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err e // User defer pattern to check for an error and, based on the error being nil or not, use all gas and return. defer func() { - if err != nil && evm.cfg.Debug { + if err != nil && in.cfg.Debug { // XXX For debugging //fmt.Printf("%04d: %8v cost = %-8d stack = %-8d ERR = %v\n", pc, op, cost, stack.len(), err) - evm.cfg.Tracer.CaptureState(evm.env, pc, op, contract.Gas, cost, mem, stack, contract, evm.env.depth, err) + in.cfg.Tracer.CaptureState(in.evm, pc, op, contract.Gas, cost, mem, stack, contract, in.evm.depth, err) } }() - log.Debug("EVM running contract", "hash", codehash[:]) + log.Debug("interpreter running contract", "hash", codehash[:]) tstart := time.Now() - defer log.Debug("EVM finished running contract", "hash", codehash[:], "elapsed", time.Since(tstart)) + defer log.Debug("interpreter finished running contract", "hash", codehash[:], "elapsed", time.Since(tstart)) // 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 evm.done is set by - // the parent context.Context. - for atomic.LoadInt32(&evm.env.abort) == 0 { + // the execution of one of the operations or until the done flag is set by the + // parent context. + for atomic.LoadInt32(&in.evm.abort) == 0 { // Get the memory location of pc op = contract.GetOp(pc) // get the operation from the jump table matching the opcode - operation := evm.cfg.JumpTable[op] + operation := in.cfg.JumpTable[op] + if err := in.enforceRestrictions(op, operation, stack); err != nil { + return nil, err + } // if the op is invalid abort the process and return an error if !operation.valid { - return nil, fmt.Errorf("invalid opcode %x", op) + return nil, fmt.Errorf("invalid opcode 0x%x", int(op)) } // validate the stack and make sure there enough stack items available @@ -161,10 +175,10 @@ func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err e } } - if !evm.cfg.DisableGasMetering { + if !in.cfg.DisableGasMetering { // consume the gas and return an error if not enough gas is available. // cost is explicitly set so that the capture state defer method cas get the proper cost - cost, err = operation.gasCost(evm.gasTable, evm.env, contract, stack, mem, memorySize) + cost, err = operation.gasCost(in.gasTable, in.evm, contract, stack, mem, memorySize) if err != nil || !contract.UseGas(cost) { return nil, ErrOutOfGas } @@ -173,19 +187,20 @@ func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err e mem.Resize(memorySize) } - if evm.cfg.Debug { - evm.cfg.Tracer.CaptureState(evm.env, pc, op, contract.Gas, cost, mem, stack, contract, evm.env.depth, err) + if in.cfg.Debug { + in.cfg.Tracer.CaptureState(in.evm, pc, op, contract.Gas, cost, mem, stack, contract, in.evm.depth, err) } // XXX For debugging //fmt.Printf("%04d: %8v cost = %-8d stack = %-8d\n", pc, op, cost, stack.len()) // execute the operation - res, err := operation.execute(&pc, evm.env, contract, mem, stack) + res, err := operation.execute(&pc, in.evm, contract, mem, stack) // verifyPool is a build flag. Pool verification makes sure the integrity // of the integer pool by comparing values to a default value. if verifyPool { - verifyIntegerPool(evm.intPool) + verifyIntegerPool(in.intPool) } + switch { case err != nil: return nil, err @@ -194,6 +209,11 @@ func (evm *Interpreter) Run(contract *Contract, input []byte) (ret []byte, err e case !operation.jumps: pc++ } + // if the operation returned a value make sure that is also set + // the last return data. + if res != nil { + mem.lastReturn = ret + } } return nil, nil } diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/intpool.go b/vendor/github.com/ethereum/go-ethereum/core/vm/intpool.go index 4f1228e14..384f5df59 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/intpool.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/intpool.go @@ -20,6 +20,8 @@ import "math/big" var checkVal = big.NewInt(-42) +const poolLimit = 256 + // intPool is a pool of big integers that // can be reused for all big.Int operations. type intPool struct { @@ -37,6 +39,10 @@ func (p *intPool) get() *big.Int { return new(big.Int) } func (p *intPool) put(is ...*big.Int) { + if len(p.pool.data) > poolLimit { + return + } + for _, i := range is { // verifyPool is a build flag. Pool verification makes sure the integrity // of the integer pool by comparing values to a default value. diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/jump_table.go b/vendor/github.com/ethereum/go-ethereum/core/vm/jump_table.go index ed30100ac..0034eacb7 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/jump_table.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/jump_table.go @@ -47,13 +47,36 @@ type operation struct { // jumps indicates whether operation made a jump. This prevents the program // counter from further incrementing. jumps bool + // writes determines whether this a state modifying operation + writes bool // valid is used to check whether the retrieved operation is valid and known valid bool + // reverts determined whether the operation reverts state + reverts bool } -var defaultJumpTable = NewJumpTable() +var ( + frontierInstructionSet = NewFrontierInstructionSet() + homesteadInstructionSet = NewHomesteadInstructionSet() +) -func NewJumpTable() [256]operation { +// NewHomesteadInstructionSet returns the frontier and homestead +// instructions that can be executed during the homestead phase. +func NewHomesteadInstructionSet() [256]operation { + instructionSet := NewFrontierInstructionSet() + instructionSet[DELEGATECALL] = operation{ + execute: opDelegateCall, + gasCost: gasDelegateCall, + validateStack: makeStackFunc(6, 1), + memorySize: memoryDelegateCall, + valid: true, + } + return instructionSet +} + +// NewFrontierInstructionSet returns the frontier instructions +// that can be executed during the frontier phase. +func NewFrontierInstructionSet() [256]operation { return [256]operation{ STOP: { execute: opStop, @@ -357,6 +380,7 @@ func NewJumpTable() [256]operation { gasCost: gasSStore, validateStack: makeStackFunc(2, 0), valid: true, + writes: true, }, JUMP: { execute: opJump, @@ -397,193 +421,193 @@ func NewJumpTable() [256]operation { valid: true, }, PUSH1: { - execute: makePush(1, big.NewInt(1)), + execute: makePush(1, 1), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH2: { - execute: makePush(2, big.NewInt(2)), + execute: makePush(2, 2), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH3: { - execute: makePush(3, big.NewInt(3)), + execute: makePush(3, 3), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH4: { - execute: makePush(4, big.NewInt(4)), + execute: makePush(4, 4), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH5: { - execute: makePush(5, big.NewInt(5)), + execute: makePush(5, 5), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH6: { - execute: makePush(6, big.NewInt(6)), + execute: makePush(6, 6), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH7: { - execute: makePush(7, big.NewInt(7)), + execute: makePush(7, 7), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH8: { - execute: makePush(8, big.NewInt(8)), + execute: makePush(8, 8), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH9: { - execute: makePush(9, big.NewInt(9)), + execute: makePush(9, 9), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH10: { - execute: makePush(10, big.NewInt(10)), + execute: makePush(10, 10), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH11: { - execute: makePush(11, big.NewInt(11)), + execute: makePush(11, 11), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH12: { - execute: makePush(12, big.NewInt(12)), + execute: makePush(12, 12), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH13: { - execute: makePush(13, big.NewInt(13)), + execute: makePush(13, 13), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH14: { - execute: makePush(14, big.NewInt(14)), + execute: makePush(14, 14), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH15: { - execute: makePush(15, big.NewInt(15)), + execute: makePush(15, 15), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH16: { - execute: makePush(16, big.NewInt(16)), + execute: makePush(16, 16), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH17: { - execute: makePush(17, big.NewInt(17)), + execute: makePush(17, 17), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH18: { - execute: makePush(18, big.NewInt(18)), + execute: makePush(18, 18), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH19: { - execute: makePush(19, big.NewInt(19)), + execute: makePush(19, 19), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH20: { - execute: makePush(20, big.NewInt(20)), + execute: makePush(20, 20), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH21: { - execute: makePush(21, big.NewInt(21)), + execute: makePush(21, 21), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH22: { - execute: makePush(22, big.NewInt(22)), + execute: makePush(22, 22), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH23: { - execute: makePush(23, big.NewInt(23)), + execute: makePush(23, 23), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH24: { - execute: makePush(24, big.NewInt(24)), + execute: makePush(24, 24), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH25: { - execute: makePush(25, big.NewInt(25)), + execute: makePush(25, 25), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH26: { - execute: makePush(26, big.NewInt(26)), + execute: makePush(26, 26), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH27: { - execute: makePush(27, big.NewInt(27)), + execute: makePush(27, 27), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH28: { - execute: makePush(28, big.NewInt(28)), + execute: makePush(28, 28), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH29: { - execute: makePush(29, big.NewInt(29)), + execute: makePush(29, 29), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH30: { - execute: makePush(30, big.NewInt(30)), + execute: makePush(30, 30), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH31: { - execute: makePush(31, big.NewInt(31)), + execute: makePush(31, 31), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, }, PUSH32: { - execute: makePush(32, big.NewInt(32)), + execute: makePush(32, 32), gasCost: gasPush, validateStack: makeStackFunc(0, 1), valid: true, @@ -821,6 +845,7 @@ func NewJumpTable() [256]operation { validateStack: makeStackFunc(3, 1), memorySize: memoryCreate, valid: true, + writes: true, }, CALL: { execute: opCall, @@ -844,19 +869,13 @@ func NewJumpTable() [256]operation { halts: true, valid: true, }, - DELEGATECALL: { - execute: opDelegateCall, - gasCost: gasDelegateCall, - validateStack: makeStackFunc(6, 1), - memorySize: memoryDelegateCall, - valid: true, - }, SELFDESTRUCT: { execute: opSuicide, gasCost: gasSuicide, validateStack: makeStackFunc(1, 0), halts: true, valid: true, + writes: true, }, } } diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/logger.go b/vendor/github.com/ethereum/go-ethereum/core/vm/logger.go index 825025b05..17a9c9ec3 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/logger.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/logger.go @@ -21,8 +21,10 @@ import ( "fmt" "io" "math/big" + "time" "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/types" ) @@ -47,18 +49,34 @@ type LogConfig struct { Limit int // maximum length of output, but zero means unlimited } +//go:generate gencodec -type StructLog -field-override structLogMarshaling -out gen_structlog.go + // StructLog is emitted to the EVM each cycle and lists information about the current internal state // prior to the execution of the statement. type StructLog struct { - Pc uint64 - Op OpCode - Gas uint64 - GasCost uint64 - Memory []byte - Stack []*big.Int - Storage map[common.Hash]common.Hash - Depth int - Err error + Pc uint64 `json:"pc"` + Op OpCode `json:"op"` + Gas uint64 `json:"gas"` + GasCost uint64 `json:"gasCost"` + Memory []byte `json:"memory"` + MemorySize int `json:"memSize"` + Stack []*big.Int `json:"stack"` + Storage map[common.Hash]common.Hash `json:"-"` + Depth int `json:"depth"` + Err error `json:"error"` +} + +// overrides for gencodec +type structLogMarshaling struct { + Stack []*math.HexOrDecimal256 + Gas math.HexOrDecimal64 + GasCost math.HexOrDecimal64 + Memory hexutil.Bytes + OpName string `json:"opName"` +} + +func (s *StructLog) OpName() string { + return s.Op.String() } // Tracer is used to collect execution traces from an EVM transaction @@ -68,6 +86,7 @@ type StructLog struct { // if you need to retain them beyond the current call. type Tracer interface { CaptureState(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) error } // StructLogger is an EVM state logger and implements Tracer. @@ -82,7 +101,7 @@ type StructLogger struct { changedValues map[common.Address]Storage } -// NewLogger returns a new logger +// NewStructLogger returns a new logger func NewStructLogger(cfg *LogConfig) *StructLogger { logger := &StructLogger{ changedValues: make(map[common.Address]Storage), @@ -93,9 +112,9 @@ func NewStructLogger(cfg *LogConfig) *StructLogger { return logger } -// captureState logs a new structured log message and pushes it out to the environment +// CaptureState logs a new structured log message and pushes it out to the environment // -// captureState also tracks SSTORE ops to track dirty values. +// CaptureState also tracks SSTORE ops to track dirty values. func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost uint64, memory *Memory, stack *Stack, contract *Contract, depth int, err error) error { // check if already accumulated the specified number of logs if l.cfg.Limit != 0 && l.cfg.Limit <= len(l.logs) { @@ -158,12 +177,17 @@ func (l *StructLogger) CaptureState(env *EVM, pc uint64, op OpCode, gas, cost ui } } // create a new snaptshot of the EVM. - log := StructLog{pc, op, gas, cost, mem, stck, storage, env.depth, err} + log := StructLog{pc, op, gas, cost, mem, memory.Len(), stck, storage, depth, err} l.logs = append(l.logs, log) return nil } +func (l *StructLogger) CaptureEnd(output []byte, gasUsed uint64, t time.Duration) error { + fmt.Printf("0x%x", output) + return nil +} + // StructLogs returns a list of captured log entries func (l *StructLogger) StructLogs() []StructLog { return l.logs diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/memory.go b/vendor/github.com/ethereum/go-ethereum/core/vm/memory.go index 99a84d227..6dbee94ef 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/memory.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/memory.go @@ -22,6 +22,7 @@ import "fmt" type Memory struct { store []byte lastGasCost uint64 + lastReturn []byte } func NewMemory() *Memory { diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/runtime/runtime.go b/vendor/github.com/ethereum/go-ethereum/core/vm/runtime/runtime.go index 94265626f..44cde4f70 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/runtime/runtime.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/runtime/runtime.go @@ -102,7 +102,7 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { if cfg.State == nil { db, _ := ethdb.NewMemDatabase() - cfg.State, _ = state.New(common.Hash{}, db) + cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db)) } var ( address = common.StringToAddress("contract") @@ -125,7 +125,7 @@ func Execute(code, input []byte, cfg *Config) ([]byte, *state.StateDB, error) { } // Create executes the code using the EVM create method -func Create(input []byte, cfg *Config) ([]byte, common.Address, error) { +func Create(input []byte, cfg *Config) ([]byte, common.Address, uint64, error) { if cfg == nil { cfg = new(Config) } @@ -133,7 +133,7 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, error) { if cfg.State == nil { db, _ := ethdb.NewMemDatabase() - cfg.State, _ = state.New(common.Hash{}, db) + cfg.State, _ = state.New(common.Hash{}, state.NewDatabase(db)) } var ( vmenv = NewEnv(cfg, cfg.State) @@ -141,13 +141,13 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, error) { ) // Call the code with the given configuration. - code, address, _, err := vmenv.Create( + code, address, leftOverGas, err := vmenv.Create( sender, input, cfg.GasLimit, cfg.Value, ) - return code, address, err + return code, address, leftOverGas, err } // Call executes the code given by the contract's address. It will return the @@ -155,14 +155,14 @@ func Create(input []byte, cfg *Config) ([]byte, common.Address, error) { // // Call, unlike Execute, requires a config and also requires the State field to // be set. -func Call(address common.Address, input []byte, cfg *Config) ([]byte, error) { +func Call(address common.Address, input []byte, cfg *Config) ([]byte, uint64, error) { setDefaults(cfg) vmenv := NewEnv(cfg, cfg.State) sender := cfg.State.GetOrNewStateObject(cfg.Origin) // Call the code with the given configuration. - ret, _, err := vmenv.Call( + ret, leftOverGas, err := vmenv.Call( sender, address, input, @@ -170,5 +170,5 @@ func Call(address common.Address, input []byte, cfg *Config) ([]byte, error) { cfg.Value, ) - return ret, err + return ret, leftOverGas, err } diff --git a/vendor/github.com/ethereum/go-ethereum/core/vm/stack.go b/vendor/github.com/ethereum/go-ethereum/core/vm/stack.go index 2d1b7bb82..9c10d50ad 100644 --- a/vendor/github.com/ethereum/go-ethereum/core/vm/stack.go +++ b/vendor/github.com/ethereum/go-ethereum/core/vm/stack.go @@ -29,7 +29,7 @@ type Stack struct { } func newstack() *Stack { - return &Stack{} + return &Stack{data: make([]*big.Int, 0, 1024)} } func (st *Stack) Data() []*big.Int { @@ -60,8 +60,8 @@ func (st *Stack) swap(n int) { st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n] } -func (st *Stack) dup(n int) { - st.push(new(big.Int).Set(st.data[st.len()-n])) +func (st *Stack) dup(pool *intPool, n int) { + st.push(pool.get().Set(st.data[st.len()-n])) } func (st *Stack) peek() *big.Int { diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/bn256.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/bn256.go new file mode 100644 index 000000000..92418369b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/bn256.go @@ -0,0 +1,428 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package bn256 implements a particular bilinear group at the 128-bit security level. +// +// Bilinear groups are the basis of many of the new cryptographic protocols +// that have been proposed over the past decade. They consist of a triplet of +// groups (G₁, G₂ and GT) such that there exists a function e(g₁ˣ,g₂ʸ)=gTˣʸ +// (where gₓ is a generator of the respective group). That function is called +// a pairing function. +// +// This package specifically implements the Optimal Ate pairing over a 256-bit +// Barreto-Naehrig curve as described in +// http://cryptojedi.org/papers/dclxvi-20100714.pdf. Its output is compatible +// with the implementation described in that paper. +package bn256 + +import ( + "crypto/rand" + "io" + "math/big" +) + +// BUG(agl): this implementation is not constant time. +// TODO(agl): keep GF(p²) elements in Mongomery form. + +// G1 is an abstract cyclic group. The zero value is suitable for use as the +// output of an operation, but cannot be used as an input. +type G1 struct { + p *curvePoint +} + +// RandomG1 returns x and g₁ˣ where x is a random, non-zero number read from r. +func RandomG1(r io.Reader) (*big.Int, *G1, error) { + var k *big.Int + var err error + + for { + k, err = rand.Int(r, Order) + if err != nil { + return nil, nil, err + } + if k.Sign() > 0 { + break + } + } + + return k, new(G1).ScalarBaseMult(k), nil +} + +func (g *G1) String() string { + return "bn256.G1" + g.p.String() +} + +// CurvePoints returns p's curve points in big integer +func (e *G1) CurvePoints() (*big.Int, *big.Int, *big.Int, *big.Int) { + return e.p.x, e.p.y, e.p.z, e.p.t +} + +// ScalarBaseMult sets e to g*k where g is the generator of the group and +// then returns e. +func (e *G1) ScalarBaseMult(k *big.Int) *G1 { + if e.p == nil { + e.p = newCurvePoint(nil) + } + e.p.Mul(curveGen, k, new(bnPool)) + return e +} + +// ScalarMult sets e to a*k and then returns e. +func (e *G1) ScalarMult(a *G1, k *big.Int) *G1 { + if e.p == nil { + e.p = newCurvePoint(nil) + } + e.p.Mul(a.p, k, new(bnPool)) + return e +} + +// Add sets e to a+b and then returns e. +// BUG(agl): this function is not complete: a==b fails. +func (e *G1) Add(a, b *G1) *G1 { + if e.p == nil { + e.p = newCurvePoint(nil) + } + e.p.Add(a.p, b.p, new(bnPool)) + return e +} + +// Neg sets e to -a and then returns e. +func (e *G1) Neg(a *G1) *G1 { + if e.p == nil { + e.p = newCurvePoint(nil) + } + e.p.Negative(a.p) + return e +} + +// Marshal converts n to a byte slice. +func (n *G1) Marshal() []byte { + n.p.MakeAffine(nil) + + xBytes := new(big.Int).Mod(n.p.x, P).Bytes() + yBytes := new(big.Int).Mod(n.p.y, P).Bytes() + + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + ret := make([]byte, numBytes*2) + copy(ret[1*numBytes-len(xBytes):], xBytes) + copy(ret[2*numBytes-len(yBytes):], yBytes) + + return ret +} + +// Unmarshal sets e to the result of converting the output of Marshal back into +// a group element and then returns e. +func (e *G1) Unmarshal(m []byte) (*G1, bool) { + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + if len(m) != 2*numBytes { + return nil, false + } + + if e.p == nil { + e.p = newCurvePoint(nil) + } + + e.p.x.SetBytes(m[0*numBytes : 1*numBytes]) + e.p.y.SetBytes(m[1*numBytes : 2*numBytes]) + + if e.p.x.Sign() == 0 && e.p.y.Sign() == 0 { + // This is the point at infinity. + e.p.y.SetInt64(1) + e.p.z.SetInt64(0) + e.p.t.SetInt64(0) + } else { + e.p.z.SetInt64(1) + e.p.t.SetInt64(1) + + if !e.p.IsOnCurve() { + return nil, false + } + } + + return e, true +} + +// G2 is an abstract cyclic group. The zero value is suitable for use as the +// output of an operation, but cannot be used as an input. +type G2 struct { + p *twistPoint +} + +// RandomG1 returns x and g₂ˣ where x is a random, non-zero number read from r. +func RandomG2(r io.Reader) (*big.Int, *G2, error) { + var k *big.Int + var err error + + for { + k, err = rand.Int(r, Order) + if err != nil { + return nil, nil, err + } + if k.Sign() > 0 { + break + } + } + + return k, new(G2).ScalarBaseMult(k), nil +} + +func (g *G2) String() string { + return "bn256.G2" + g.p.String() +} + +// CurvePoints returns the curve points of p which includes the real +// and imaginary parts of the curve point. +func (e *G2) CurvePoints() (*gfP2, *gfP2, *gfP2, *gfP2) { + return e.p.x, e.p.y, e.p.z, e.p.t +} + +// ScalarBaseMult sets e to g*k where g is the generator of the group and +// then returns out. +func (e *G2) ScalarBaseMult(k *big.Int) *G2 { + if e.p == nil { + e.p = newTwistPoint(nil) + } + e.p.Mul(twistGen, k, new(bnPool)) + return e +} + +// ScalarMult sets e to a*k and then returns e. +func (e *G2) ScalarMult(a *G2, k *big.Int) *G2 { + if e.p == nil { + e.p = newTwistPoint(nil) + } + e.p.Mul(a.p, k, new(bnPool)) + return e +} + +// Add sets e to a+b and then returns e. +// BUG(agl): this function is not complete: a==b fails. +func (e *G2) Add(a, b *G2) *G2 { + if e.p == nil { + e.p = newTwistPoint(nil) + } + e.p.Add(a.p, b.p, new(bnPool)) + return e +} + +// Marshal converts n into a byte slice. +func (n *G2) Marshal() []byte { + n.p.MakeAffine(nil) + + xxBytes := new(big.Int).Mod(n.p.x.x, P).Bytes() + xyBytes := new(big.Int).Mod(n.p.x.y, P).Bytes() + yxBytes := new(big.Int).Mod(n.p.y.x, P).Bytes() + yyBytes := new(big.Int).Mod(n.p.y.y, P).Bytes() + + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + ret := make([]byte, numBytes*4) + copy(ret[1*numBytes-len(xxBytes):], xxBytes) + copy(ret[2*numBytes-len(xyBytes):], xyBytes) + copy(ret[3*numBytes-len(yxBytes):], yxBytes) + copy(ret[4*numBytes-len(yyBytes):], yyBytes) + + return ret +} + +// Unmarshal sets e to the result of converting the output of Marshal back into +// a group element and then returns e. +func (e *G2) Unmarshal(m []byte) (*G2, bool) { + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + if len(m) != 4*numBytes { + return nil, false + } + + if e.p == nil { + e.p = newTwistPoint(nil) + } + + e.p.x.x.SetBytes(m[0*numBytes : 1*numBytes]) + e.p.x.y.SetBytes(m[1*numBytes : 2*numBytes]) + e.p.y.x.SetBytes(m[2*numBytes : 3*numBytes]) + e.p.y.y.SetBytes(m[3*numBytes : 4*numBytes]) + + if e.p.x.x.Sign() == 0 && + e.p.x.y.Sign() == 0 && + e.p.y.x.Sign() == 0 && + e.p.y.y.Sign() == 0 { + // This is the point at infinity. + e.p.y.SetOne() + e.p.z.SetZero() + e.p.t.SetZero() + } else { + e.p.z.SetOne() + e.p.t.SetOne() + + if !e.p.IsOnCurve() { + return nil, false + } + } + + return e, true +} + +// GT is an abstract cyclic group. The zero value is suitable for use as the +// output of an operation, but cannot be used as an input. +type GT struct { + p *gfP12 +} + +func (g *GT) String() string { + return "bn256.GT" + g.p.String() +} + +// ScalarMult sets e to a*k and then returns e. +func (e *GT) ScalarMult(a *GT, k *big.Int) *GT { + if e.p == nil { + e.p = newGFp12(nil) + } + e.p.Exp(a.p, k, new(bnPool)) + return e +} + +// Add sets e to a+b and then returns e. +func (e *GT) Add(a, b *GT) *GT { + if e.p == nil { + e.p = newGFp12(nil) + } + e.p.Mul(a.p, b.p, new(bnPool)) + return e +} + +// Neg sets e to -a and then returns e. +func (e *GT) Neg(a *GT) *GT { + if e.p == nil { + e.p = newGFp12(nil) + } + e.p.Invert(a.p, new(bnPool)) + return e +} + +// Marshal converts n into a byte slice. +func (n *GT) Marshal() []byte { + n.p.Minimal() + + xxxBytes := n.p.x.x.x.Bytes() + xxyBytes := n.p.x.x.y.Bytes() + xyxBytes := n.p.x.y.x.Bytes() + xyyBytes := n.p.x.y.y.Bytes() + xzxBytes := n.p.x.z.x.Bytes() + xzyBytes := n.p.x.z.y.Bytes() + yxxBytes := n.p.y.x.x.Bytes() + yxyBytes := n.p.y.x.y.Bytes() + yyxBytes := n.p.y.y.x.Bytes() + yyyBytes := n.p.y.y.y.Bytes() + yzxBytes := n.p.y.z.x.Bytes() + yzyBytes := n.p.y.z.y.Bytes() + + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + ret := make([]byte, numBytes*12) + copy(ret[1*numBytes-len(xxxBytes):], xxxBytes) + copy(ret[2*numBytes-len(xxyBytes):], xxyBytes) + copy(ret[3*numBytes-len(xyxBytes):], xyxBytes) + copy(ret[4*numBytes-len(xyyBytes):], xyyBytes) + copy(ret[5*numBytes-len(xzxBytes):], xzxBytes) + copy(ret[6*numBytes-len(xzyBytes):], xzyBytes) + copy(ret[7*numBytes-len(yxxBytes):], yxxBytes) + copy(ret[8*numBytes-len(yxyBytes):], yxyBytes) + copy(ret[9*numBytes-len(yyxBytes):], yyxBytes) + copy(ret[10*numBytes-len(yyyBytes):], yyyBytes) + copy(ret[11*numBytes-len(yzxBytes):], yzxBytes) + copy(ret[12*numBytes-len(yzyBytes):], yzyBytes) + + return ret +} + +// Unmarshal sets e to the result of converting the output of Marshal back into +// a group element and then returns e. +func (e *GT) Unmarshal(m []byte) (*GT, bool) { + // Each value is a 256-bit number. + const numBytes = 256 / 8 + + if len(m) != 12*numBytes { + return nil, false + } + + if e.p == nil { + e.p = newGFp12(nil) + } + + e.p.x.x.x.SetBytes(m[0*numBytes : 1*numBytes]) + e.p.x.x.y.SetBytes(m[1*numBytes : 2*numBytes]) + e.p.x.y.x.SetBytes(m[2*numBytes : 3*numBytes]) + e.p.x.y.y.SetBytes(m[3*numBytes : 4*numBytes]) + e.p.x.z.x.SetBytes(m[4*numBytes : 5*numBytes]) + e.p.x.z.y.SetBytes(m[5*numBytes : 6*numBytes]) + e.p.y.x.x.SetBytes(m[6*numBytes : 7*numBytes]) + e.p.y.x.y.SetBytes(m[7*numBytes : 8*numBytes]) + e.p.y.y.x.SetBytes(m[8*numBytes : 9*numBytes]) + e.p.y.y.y.SetBytes(m[9*numBytes : 10*numBytes]) + e.p.y.z.x.SetBytes(m[10*numBytes : 11*numBytes]) + e.p.y.z.y.SetBytes(m[11*numBytes : 12*numBytes]) + + return e, true +} + +// Pair calculates an Optimal Ate pairing. +func Pair(g1 *G1, g2 *G2) *GT { + return >{optimalAte(g2.p, g1.p, new(bnPool))} +} + +func PairingCheck(a []*G1, b []*G2) bool { + pool := new(bnPool) + e := newGFp12(pool) + e.SetOne() + for i := 0; i < len(a); i++ { + new_e := miller(b[i].p, a[i].p, pool) + e.Mul(e, new_e, pool) + } + ret := finalExponentiation(e, pool) + e.Put(pool) + return ret.IsOne() +} + +// bnPool implements a tiny cache of *big.Int objects that's used to reduce the +// number of allocations made during processing. +type bnPool struct { + bns []*big.Int + count int +} + +func (pool *bnPool) Get() *big.Int { + if pool == nil { + return new(big.Int) + } + + pool.count++ + l := len(pool.bns) + if l == 0 { + return new(big.Int) + } + + bn := pool.bns[l-1] + pool.bns = pool.bns[:l-1] + return bn +} + +func (pool *bnPool) Put(bn *big.Int) { + if pool == nil { + return + } + pool.bns = append(pool.bns, bn) + pool.count-- +} + +func (pool *bnPool) Count() int { + return pool.count +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/constants.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/constants.go new file mode 100644 index 000000000..ab649d7f3 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/constants.go @@ -0,0 +1,44 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +import ( + "math/big" +) + +func bigFromBase10(s string) *big.Int { + n, _ := new(big.Int).SetString(s, 10) + return n +} + +// u is the BN parameter that determines the prime: 1868033³. +var u = bigFromBase10("4965661367192848881") + +// p is a prime over which we form a basic field: 36u⁴+36u³+24u²+6u+1. +var P = bigFromBase10("21888242871839275222246405745257275088696311157297823662689037894645226208583") + +// Order is the number of elements in both G₁ and G₂: 36u⁴+36u³+18u²+6u+1. +var Order = bigFromBase10("21888242871839275222246405745257275088548364400416034343698204186575808495617") + +// xiToPMinus1Over6 is ξ^((p-1)/6) where ξ = i+9. +var xiToPMinus1Over6 = &gfP2{bigFromBase10("16469823323077808223889137241176536799009286646108169935659301613961712198316"), bigFromBase10("8376118865763821496583973867626364092589906065868298776909617916018768340080")} + +// xiToPMinus1Over3 is ξ^((p-1)/3) where ξ = i+9. +var xiToPMinus1Over3 = &gfP2{bigFromBase10("10307601595873709700152284273816112264069230130616436755625194854815875713954"), bigFromBase10("21575463638280843010398324269430826099269044274347216827212613867836435027261")} + +// xiToPMinus1Over2 is ξ^((p-1)/2) where ξ = i+9. +var xiToPMinus1Over2 = &gfP2{bigFromBase10("3505843767911556378687030309984248845540243509899259641013678093033130930403"), bigFromBase10("2821565182194536844548159561693502659359617185244120367078079554186484126554")} + +// xiToPSquaredMinus1Over3 is ξ^((p²-1)/3) where ξ = i+9. +var xiToPSquaredMinus1Over3 = bigFromBase10("21888242871839275220042445260109153167277707414472061641714758635765020556616") + +// xiTo2PSquaredMinus2Over3 is ξ^((2p²-2)/3) where ξ = i+9 (a cubic root of unity, mod p). +var xiTo2PSquaredMinus2Over3 = bigFromBase10("2203960485148121921418603742825762020974279258880205651966") + +// xiToPSquaredMinus1Over6 is ξ^((1p²-1)/6) where ξ = i+9 (a cubic root of -1, mod p). +var xiToPSquaredMinus1Over6 = bigFromBase10("21888242871839275220042445260109153167277707414472061641714758635765020556617") + +// xiTo2PMinus2Over3 is ξ^((2p-2)/3) where ξ = i+9. +var xiTo2PMinus2Over3 = &gfP2{bigFromBase10("19937756971775647987995932169929341994314640652964949448313374472400716661030"), bigFromBase10("2581911344467009335267311115468803099551665605076196740867805258568234346338")} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/curve.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/curve.go new file mode 100644 index 000000000..233b1f252 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/curve.go @@ -0,0 +1,278 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +import ( + "math/big" +) + +// curvePoint implements the elliptic curve y²=x³+3. Points are kept in +// Jacobian form and t=z² when valid. G₁ is the set of points of this curve on +// GF(p). +type curvePoint struct { + x, y, z, t *big.Int +} + +var curveB = new(big.Int).SetInt64(3) + +// curveGen is the generator of G₁. +var curveGen = &curvePoint{ + new(big.Int).SetInt64(1), + new(big.Int).SetInt64(-2), + new(big.Int).SetInt64(1), + new(big.Int).SetInt64(1), +} + +func newCurvePoint(pool *bnPool) *curvePoint { + return &curvePoint{ + pool.Get(), + pool.Get(), + pool.Get(), + pool.Get(), + } +} + +func (c *curvePoint) String() string { + c.MakeAffine(new(bnPool)) + return "(" + c.x.String() + ", " + c.y.String() + ")" +} + +func (c *curvePoint) Put(pool *bnPool) { + pool.Put(c.x) + pool.Put(c.y) + pool.Put(c.z) + pool.Put(c.t) +} + +func (c *curvePoint) Set(a *curvePoint) { + c.x.Set(a.x) + c.y.Set(a.y) + c.z.Set(a.z) + c.t.Set(a.t) +} + +// IsOnCurve returns true iff c is on the curve where c must be in affine form. +func (c *curvePoint) IsOnCurve() bool { + yy := new(big.Int).Mul(c.y, c.y) + xxx := new(big.Int).Mul(c.x, c.x) + xxx.Mul(xxx, c.x) + yy.Sub(yy, xxx) + yy.Sub(yy, curveB) + if yy.Sign() < 0 || yy.Cmp(P) >= 0 { + yy.Mod(yy, P) + } + return yy.Sign() == 0 +} + +func (c *curvePoint) SetInfinity() { + c.z.SetInt64(0) +} + +func (c *curvePoint) IsInfinity() bool { + return c.z.Sign() == 0 +} + +func (c *curvePoint) Add(a, b *curvePoint, pool *bnPool) { + if a.IsInfinity() { + c.Set(b) + return + } + if b.IsInfinity() { + c.Set(a) + return + } + + // See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/addition/add-2007-bl.op3 + + // Normalize the points by replacing a = [x1:y1:z1] and b = [x2:y2:z2] + // by [u1:s1:z1·z2] and [u2:s2:z1·z2] + // where u1 = x1·z2², s1 = y1·z2³ and u1 = x2·z1², s2 = y2·z1³ + z1z1 := pool.Get().Mul(a.z, a.z) + z1z1.Mod(z1z1, P) + z2z2 := pool.Get().Mul(b.z, b.z) + z2z2.Mod(z2z2, P) + u1 := pool.Get().Mul(a.x, z2z2) + u1.Mod(u1, P) + u2 := pool.Get().Mul(b.x, z1z1) + u2.Mod(u2, P) + + t := pool.Get().Mul(b.z, z2z2) + t.Mod(t, P) + s1 := pool.Get().Mul(a.y, t) + s1.Mod(s1, P) + + t.Mul(a.z, z1z1) + t.Mod(t, P) + s2 := pool.Get().Mul(b.y, t) + s2.Mod(s2, P) + + // Compute x = (2h)²(s²-u1-u2) + // where s = (s2-s1)/(u2-u1) is the slope of the line through + // (u1,s1) and (u2,s2). The extra factor 2h = 2(u2-u1) comes from the value of z below. + // This is also: + // 4(s2-s1)² - 4h²(u1+u2) = 4(s2-s1)² - 4h³ - 4h²(2u1) + // = r² - j - 2v + // with the notations below. + h := pool.Get().Sub(u2, u1) + xEqual := h.Sign() == 0 + + t.Add(h, h) + // i = 4h² + i := pool.Get().Mul(t, t) + i.Mod(i, P) + // j = 4h³ + j := pool.Get().Mul(h, i) + j.Mod(j, P) + + t.Sub(s2, s1) + yEqual := t.Sign() == 0 + if xEqual && yEqual { + c.Double(a, pool) + return + } + r := pool.Get().Add(t, t) + + v := pool.Get().Mul(u1, i) + v.Mod(v, P) + + // t4 = 4(s2-s1)² + t4 := pool.Get().Mul(r, r) + t4.Mod(t4, P) + t.Add(v, v) + t6 := pool.Get().Sub(t4, j) + c.x.Sub(t6, t) + + // Set y = -(2h)³(s1 + s*(x/4h²-u1)) + // This is also + // y = - 2·s1·j - (s2-s1)(2x - 2i·u1) = r(v-x) - 2·s1·j + t.Sub(v, c.x) // t7 + t4.Mul(s1, j) // t8 + t4.Mod(t4, P) + t6.Add(t4, t4) // t9 + t4.Mul(r, t) // t10 + t4.Mod(t4, P) + c.y.Sub(t4, t6) + + // Set z = 2(u2-u1)·z1·z2 = 2h·z1·z2 + t.Add(a.z, b.z) // t11 + t4.Mul(t, t) // t12 + t4.Mod(t4, P) + t.Sub(t4, z1z1) // t13 + t4.Sub(t, z2z2) // t14 + c.z.Mul(t4, h) + c.z.Mod(c.z, P) + + pool.Put(z1z1) + pool.Put(z2z2) + pool.Put(u1) + pool.Put(u2) + pool.Put(t) + pool.Put(s1) + pool.Put(s2) + pool.Put(h) + pool.Put(i) + pool.Put(j) + pool.Put(r) + pool.Put(v) + pool.Put(t4) + pool.Put(t6) +} + +func (c *curvePoint) Double(a *curvePoint, pool *bnPool) { + // See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/doubling/dbl-2009-l.op3 + A := pool.Get().Mul(a.x, a.x) + A.Mod(A, P) + B := pool.Get().Mul(a.y, a.y) + B.Mod(B, P) + C_ := pool.Get().Mul(B, B) + C_.Mod(C_, P) + + t := pool.Get().Add(a.x, B) + t2 := pool.Get().Mul(t, t) + t2.Mod(t2, P) + t.Sub(t2, A) + t2.Sub(t, C_) + d := pool.Get().Add(t2, t2) + t.Add(A, A) + e := pool.Get().Add(t, A) + f := pool.Get().Mul(e, e) + f.Mod(f, P) + + t.Add(d, d) + c.x.Sub(f, t) + + t.Add(C_, C_) + t2.Add(t, t) + t.Add(t2, t2) + c.y.Sub(d, c.x) + t2.Mul(e, c.y) + t2.Mod(t2, P) + c.y.Sub(t2, t) + + t.Mul(a.y, a.z) + t.Mod(t, P) + c.z.Add(t, t) + + pool.Put(A) + pool.Put(B) + pool.Put(C_) + pool.Put(t) + pool.Put(t2) + pool.Put(d) + pool.Put(e) + pool.Put(f) +} + +func (c *curvePoint) Mul(a *curvePoint, scalar *big.Int, pool *bnPool) *curvePoint { + sum := newCurvePoint(pool) + sum.SetInfinity() + t := newCurvePoint(pool) + + for i := scalar.BitLen(); i >= 0; i-- { + t.Double(sum, pool) + if scalar.Bit(i) != 0 { + sum.Add(t, a, pool) + } else { + sum.Set(t) + } + } + + c.Set(sum) + sum.Put(pool) + t.Put(pool) + return c +} + +func (c *curvePoint) MakeAffine(pool *bnPool) *curvePoint { + if words := c.z.Bits(); len(words) == 1 && words[0] == 1 { + return c + } + + zInv := pool.Get().ModInverse(c.z, P) + t := pool.Get().Mul(c.y, zInv) + t.Mod(t, P) + zInv2 := pool.Get().Mul(zInv, zInv) + zInv2.Mod(zInv2, P) + c.y.Mul(t, zInv2) + c.y.Mod(c.y, P) + t.Mul(c.x, zInv2) + t.Mod(t, P) + c.x.Set(t) + c.z.SetInt64(1) + c.t.SetInt64(1) + + pool.Put(zInv) + pool.Put(t) + pool.Put(zInv2) + + return c +} + +func (c *curvePoint) Negative(a *curvePoint) { + c.x.Set(a.x) + c.y.Neg(a.y) + c.z.Set(a.z) + c.t.SetInt64(0) +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp12.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp12.go new file mode 100644 index 000000000..f084eddf2 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp12.go @@ -0,0 +1,200 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +// For details of the algorithms used, see "Multiplication and Squaring on +// Pairing-Friendly Fields, Devegili et al. +// http://eprint.iacr.org/2006/471.pdf. + +import ( + "math/big" +) + +// gfP12 implements the field of size p¹² as a quadratic extension of gfP6 +// where ω²=τ. +type gfP12 struct { + x, y *gfP6 // value is xω + y +} + +func newGFp12(pool *bnPool) *gfP12 { + return &gfP12{newGFp6(pool), newGFp6(pool)} +} + +func (e *gfP12) String() string { + return "(" + e.x.String() + "," + e.y.String() + ")" +} + +func (e *gfP12) Put(pool *bnPool) { + e.x.Put(pool) + e.y.Put(pool) +} + +func (e *gfP12) Set(a *gfP12) *gfP12 { + e.x.Set(a.x) + e.y.Set(a.y) + return e +} + +func (e *gfP12) SetZero() *gfP12 { + e.x.SetZero() + e.y.SetZero() + return e +} + +func (e *gfP12) SetOne() *gfP12 { + e.x.SetZero() + e.y.SetOne() + return e +} + +func (e *gfP12) Minimal() { + e.x.Minimal() + e.y.Minimal() +} + +func (e *gfP12) IsZero() bool { + e.Minimal() + return e.x.IsZero() && e.y.IsZero() +} + +func (e *gfP12) IsOne() bool { + e.Minimal() + return e.x.IsZero() && e.y.IsOne() +} + +func (e *gfP12) Conjugate(a *gfP12) *gfP12 { + e.x.Negative(a.x) + e.y.Set(a.y) + return a +} + +func (e *gfP12) Negative(a *gfP12) *gfP12 { + e.x.Negative(a.x) + e.y.Negative(a.y) + return e +} + +// Frobenius computes (xω+y)^p = x^p ω·ξ^((p-1)/6) + y^p +func (e *gfP12) Frobenius(a *gfP12, pool *bnPool) *gfP12 { + e.x.Frobenius(a.x, pool) + e.y.Frobenius(a.y, pool) + e.x.MulScalar(e.x, xiToPMinus1Over6, pool) + return e +} + +// FrobeniusP2 computes (xω+y)^p² = x^p² ω·ξ^((p²-1)/6) + y^p² +func (e *gfP12) FrobeniusP2(a *gfP12, pool *bnPool) *gfP12 { + e.x.FrobeniusP2(a.x) + e.x.MulGFP(e.x, xiToPSquaredMinus1Over6) + e.y.FrobeniusP2(a.y) + return e +} + +func (e *gfP12) Add(a, b *gfP12) *gfP12 { + e.x.Add(a.x, b.x) + e.y.Add(a.y, b.y) + return e +} + +func (e *gfP12) Sub(a, b *gfP12) *gfP12 { + e.x.Sub(a.x, b.x) + e.y.Sub(a.y, b.y) + return e +} + +func (e *gfP12) Mul(a, b *gfP12, pool *bnPool) *gfP12 { + tx := newGFp6(pool) + tx.Mul(a.x, b.y, pool) + t := newGFp6(pool) + t.Mul(b.x, a.y, pool) + tx.Add(tx, t) + + ty := newGFp6(pool) + ty.Mul(a.y, b.y, pool) + t.Mul(a.x, b.x, pool) + t.MulTau(t, pool) + e.y.Add(ty, t) + e.x.Set(tx) + + tx.Put(pool) + ty.Put(pool) + t.Put(pool) + return e +} + +func (e *gfP12) MulScalar(a *gfP12, b *gfP6, pool *bnPool) *gfP12 { + e.x.Mul(e.x, b, pool) + e.y.Mul(e.y, b, pool) + return e +} + +func (c *gfP12) Exp(a *gfP12, power *big.Int, pool *bnPool) *gfP12 { + sum := newGFp12(pool) + sum.SetOne() + t := newGFp12(pool) + + for i := power.BitLen() - 1; i >= 0; i-- { + t.Square(sum, pool) + if power.Bit(i) != 0 { + sum.Mul(t, a, pool) + } else { + sum.Set(t) + } + } + + c.Set(sum) + + sum.Put(pool) + t.Put(pool) + + return c +} + +func (e *gfP12) Square(a *gfP12, pool *bnPool) *gfP12 { + // Complex squaring algorithm + v0 := newGFp6(pool) + v0.Mul(a.x, a.y, pool) + + t := newGFp6(pool) + t.MulTau(a.x, pool) + t.Add(a.y, t) + ty := newGFp6(pool) + ty.Add(a.x, a.y) + ty.Mul(ty, t, pool) + ty.Sub(ty, v0) + t.MulTau(v0, pool) + ty.Sub(ty, t) + + e.y.Set(ty) + e.x.Double(v0) + + v0.Put(pool) + t.Put(pool) + ty.Put(pool) + + return e +} + +func (e *gfP12) Invert(a *gfP12, pool *bnPool) *gfP12 { + // See "Implementing cryptographic pairings", M. Scott, section 3.2. + // ftp://136.206.11.249/pub/crypto/pairings.pdf + t1 := newGFp6(pool) + t2 := newGFp6(pool) + + t1.Square(a.x, pool) + t2.Square(a.y, pool) + t1.MulTau(t1, pool) + t1.Sub(t2, t1) + t2.Invert(t1, pool) + + e.x.Negative(a.x) + e.y.Set(a.y) + e.MulScalar(e, t2, pool) + + t1.Put(pool) + t2.Put(pool) + + return e +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp2.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp2.go new file mode 100644 index 000000000..3981f6cb4 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp2.go @@ -0,0 +1,227 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +// For details of the algorithms used, see "Multiplication and Squaring on +// Pairing-Friendly Fields, Devegili et al. +// http://eprint.iacr.org/2006/471.pdf. + +import ( + "math/big" +) + +// gfP2 implements a field of size p² as a quadratic extension of the base +// field where i²=-1. +type gfP2 struct { + x, y *big.Int // value is xi+y. +} + +func newGFp2(pool *bnPool) *gfP2 { + return &gfP2{pool.Get(), pool.Get()} +} + +func (e *gfP2) String() string { + x := new(big.Int).Mod(e.x, P) + y := new(big.Int).Mod(e.y, P) + return "(" + x.String() + "," + y.String() + ")" +} + +func (e *gfP2) Put(pool *bnPool) { + pool.Put(e.x) + pool.Put(e.y) +} + +func (e *gfP2) Set(a *gfP2) *gfP2 { + e.x.Set(a.x) + e.y.Set(a.y) + return e +} + +func (e *gfP2) SetZero() *gfP2 { + e.x.SetInt64(0) + e.y.SetInt64(0) + return e +} + +func (e *gfP2) SetOne() *gfP2 { + e.x.SetInt64(0) + e.y.SetInt64(1) + return e +} + +func (e *gfP2) Minimal() { + if e.x.Sign() < 0 || e.x.Cmp(P) >= 0 { + e.x.Mod(e.x, P) + } + if e.y.Sign() < 0 || e.y.Cmp(P) >= 0 { + e.y.Mod(e.y, P) + } +} + +func (e *gfP2) IsZero() bool { + return e.x.Sign() == 0 && e.y.Sign() == 0 +} + +func (e *gfP2) IsOne() bool { + if e.x.Sign() != 0 { + return false + } + words := e.y.Bits() + return len(words) == 1 && words[0] == 1 +} + +func (e *gfP2) Conjugate(a *gfP2) *gfP2 { + e.y.Set(a.y) + e.x.Neg(a.x) + return e +} + +func (e *gfP2) Negative(a *gfP2) *gfP2 { + e.x.Neg(a.x) + e.y.Neg(a.y) + return e +} + +func (e *gfP2) Add(a, b *gfP2) *gfP2 { + e.x.Add(a.x, b.x) + e.y.Add(a.y, b.y) + return e +} + +func (e *gfP2) Sub(a, b *gfP2) *gfP2 { + e.x.Sub(a.x, b.x) + e.y.Sub(a.y, b.y) + return e +} + +func (e *gfP2) Double(a *gfP2) *gfP2 { + e.x.Lsh(a.x, 1) + e.y.Lsh(a.y, 1) + return e +} + +func (c *gfP2) Exp(a *gfP2, power *big.Int, pool *bnPool) *gfP2 { + sum := newGFp2(pool) + sum.SetOne() + t := newGFp2(pool) + + for i := power.BitLen() - 1; i >= 0; i-- { + t.Square(sum, pool) + if power.Bit(i) != 0 { + sum.Mul(t, a, pool) + } else { + sum.Set(t) + } + } + + c.Set(sum) + + sum.Put(pool) + t.Put(pool) + + return c +} + +// See "Multiplication and Squaring in Pairing-Friendly Fields", +// http://eprint.iacr.org/2006/471.pdf +func (e *gfP2) Mul(a, b *gfP2, pool *bnPool) *gfP2 { + tx := pool.Get().Mul(a.x, b.y) + t := pool.Get().Mul(b.x, a.y) + tx.Add(tx, t) + tx.Mod(tx, P) + + ty := pool.Get().Mul(a.y, b.y) + t.Mul(a.x, b.x) + ty.Sub(ty, t) + e.y.Mod(ty, P) + e.x.Set(tx) + + pool.Put(tx) + pool.Put(ty) + pool.Put(t) + + return e +} + +func (e *gfP2) MulScalar(a *gfP2, b *big.Int) *gfP2 { + e.x.Mul(a.x, b) + e.y.Mul(a.y, b) + return e +} + +// MulXi sets e=ξa where ξ=i+9 and then returns e. +func (e *gfP2) MulXi(a *gfP2, pool *bnPool) *gfP2 { + // (xi+y)(i+3) = (9x+y)i+(9y-x) + tx := pool.Get().Lsh(a.x, 3) + tx.Add(tx, a.x) + tx.Add(tx, a.y) + + ty := pool.Get().Lsh(a.y, 3) + ty.Add(ty, a.y) + ty.Sub(ty, a.x) + + e.x.Set(tx) + e.y.Set(ty) + + pool.Put(tx) + pool.Put(ty) + + return e +} + +func (e *gfP2) Square(a *gfP2, pool *bnPool) *gfP2 { + // Complex squaring algorithm: + // (xi+b)² = (x+y)(y-x) + 2*i*x*y + t1 := pool.Get().Sub(a.y, a.x) + t2 := pool.Get().Add(a.x, a.y) + ty := pool.Get().Mul(t1, t2) + ty.Mod(ty, P) + + t1.Mul(a.x, a.y) + t1.Lsh(t1, 1) + + e.x.Mod(t1, P) + e.y.Set(ty) + + pool.Put(t1) + pool.Put(t2) + pool.Put(ty) + + return e +} + +func (e *gfP2) Invert(a *gfP2, pool *bnPool) *gfP2 { + // See "Implementing cryptographic pairings", M. Scott, section 3.2. + // ftp://136.206.11.249/pub/crypto/pairings.pdf + t := pool.Get() + t.Mul(a.y, a.y) + t2 := pool.Get() + t2.Mul(a.x, a.x) + t.Add(t, t2) + + inv := pool.Get() + inv.ModInverse(t, P) + + e.x.Neg(a.x) + e.x.Mul(e.x, inv) + e.x.Mod(e.x, P) + + e.y.Mul(a.y, inv) + e.y.Mod(e.y, P) + + pool.Put(t) + pool.Put(t2) + pool.Put(inv) + + return e +} + +func (e *gfP2) Real() *big.Int { + return e.x +} + +func (e *gfP2) Imag() *big.Int { + return e.y +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp6.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp6.go new file mode 100644 index 000000000..218856617 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/gfp6.go @@ -0,0 +1,296 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +// For details of the algorithms used, see "Multiplication and Squaring on +// Pairing-Friendly Fields, Devegili et al. +// http://eprint.iacr.org/2006/471.pdf. + +import ( + "math/big" +) + +// gfP6 implements the field of size p⁶ as a cubic extension of gfP2 where τ³=ξ +// and ξ=i+9. +type gfP6 struct { + x, y, z *gfP2 // value is xτ² + yτ + z +} + +func newGFp6(pool *bnPool) *gfP6 { + return &gfP6{newGFp2(pool), newGFp2(pool), newGFp2(pool)} +} + +func (e *gfP6) String() string { + return "(" + e.x.String() + "," + e.y.String() + "," + e.z.String() + ")" +} + +func (e *gfP6) Put(pool *bnPool) { + e.x.Put(pool) + e.y.Put(pool) + e.z.Put(pool) +} + +func (e *gfP6) Set(a *gfP6) *gfP6 { + e.x.Set(a.x) + e.y.Set(a.y) + e.z.Set(a.z) + return e +} + +func (e *gfP6) SetZero() *gfP6 { + e.x.SetZero() + e.y.SetZero() + e.z.SetZero() + return e +} + +func (e *gfP6) SetOne() *gfP6 { + e.x.SetZero() + e.y.SetZero() + e.z.SetOne() + return e +} + +func (e *gfP6) Minimal() { + e.x.Minimal() + e.y.Minimal() + e.z.Minimal() +} + +func (e *gfP6) IsZero() bool { + return e.x.IsZero() && e.y.IsZero() && e.z.IsZero() +} + +func (e *gfP6) IsOne() bool { + return e.x.IsZero() && e.y.IsZero() && e.z.IsOne() +} + +func (e *gfP6) Negative(a *gfP6) *gfP6 { + e.x.Negative(a.x) + e.y.Negative(a.y) + e.z.Negative(a.z) + return e +} + +func (e *gfP6) Frobenius(a *gfP6, pool *bnPool) *gfP6 { + e.x.Conjugate(a.x) + e.y.Conjugate(a.y) + e.z.Conjugate(a.z) + + e.x.Mul(e.x, xiTo2PMinus2Over3, pool) + e.y.Mul(e.y, xiToPMinus1Over3, pool) + return e +} + +// FrobeniusP2 computes (xτ²+yτ+z)^(p²) = xτ^(2p²) + yτ^(p²) + z +func (e *gfP6) FrobeniusP2(a *gfP6) *gfP6 { + // τ^(2p²) = τ²τ^(2p²-2) = τ²ξ^((2p²-2)/3) + e.x.MulScalar(a.x, xiTo2PSquaredMinus2Over3) + // τ^(p²) = ττ^(p²-1) = τξ^((p²-1)/3) + e.y.MulScalar(a.y, xiToPSquaredMinus1Over3) + e.z.Set(a.z) + return e +} + +func (e *gfP6) Add(a, b *gfP6) *gfP6 { + e.x.Add(a.x, b.x) + e.y.Add(a.y, b.y) + e.z.Add(a.z, b.z) + return e +} + +func (e *gfP6) Sub(a, b *gfP6) *gfP6 { + e.x.Sub(a.x, b.x) + e.y.Sub(a.y, b.y) + e.z.Sub(a.z, b.z) + return e +} + +func (e *gfP6) Double(a *gfP6) *gfP6 { + e.x.Double(a.x) + e.y.Double(a.y) + e.z.Double(a.z) + return e +} + +func (e *gfP6) Mul(a, b *gfP6, pool *bnPool) *gfP6 { + // "Multiplication and Squaring on Pairing-Friendly Fields" + // Section 4, Karatsuba method. + // http://eprint.iacr.org/2006/471.pdf + + v0 := newGFp2(pool) + v0.Mul(a.z, b.z, pool) + v1 := newGFp2(pool) + v1.Mul(a.y, b.y, pool) + v2 := newGFp2(pool) + v2.Mul(a.x, b.x, pool) + + t0 := newGFp2(pool) + t0.Add(a.x, a.y) + t1 := newGFp2(pool) + t1.Add(b.x, b.y) + tz := newGFp2(pool) + tz.Mul(t0, t1, pool) + + tz.Sub(tz, v1) + tz.Sub(tz, v2) + tz.MulXi(tz, pool) + tz.Add(tz, v0) + + t0.Add(a.y, a.z) + t1.Add(b.y, b.z) + ty := newGFp2(pool) + ty.Mul(t0, t1, pool) + ty.Sub(ty, v0) + ty.Sub(ty, v1) + t0.MulXi(v2, pool) + ty.Add(ty, t0) + + t0.Add(a.x, a.z) + t1.Add(b.x, b.z) + tx := newGFp2(pool) + tx.Mul(t0, t1, pool) + tx.Sub(tx, v0) + tx.Add(tx, v1) + tx.Sub(tx, v2) + + e.x.Set(tx) + e.y.Set(ty) + e.z.Set(tz) + + t0.Put(pool) + t1.Put(pool) + tx.Put(pool) + ty.Put(pool) + tz.Put(pool) + v0.Put(pool) + v1.Put(pool) + v2.Put(pool) + return e +} + +func (e *gfP6) MulScalar(a *gfP6, b *gfP2, pool *bnPool) *gfP6 { + e.x.Mul(a.x, b, pool) + e.y.Mul(a.y, b, pool) + e.z.Mul(a.z, b, pool) + return e +} + +func (e *gfP6) MulGFP(a *gfP6, b *big.Int) *gfP6 { + e.x.MulScalar(a.x, b) + e.y.MulScalar(a.y, b) + e.z.MulScalar(a.z, b) + return e +} + +// MulTau computes τ·(aτ²+bτ+c) = bτ²+cτ+aξ +func (e *gfP6) MulTau(a *gfP6, pool *bnPool) { + tz := newGFp2(pool) + tz.MulXi(a.x, pool) + ty := newGFp2(pool) + ty.Set(a.y) + e.y.Set(a.z) + e.x.Set(ty) + e.z.Set(tz) + tz.Put(pool) + ty.Put(pool) +} + +func (e *gfP6) Square(a *gfP6, pool *bnPool) *gfP6 { + v0 := newGFp2(pool).Square(a.z, pool) + v1 := newGFp2(pool).Square(a.y, pool) + v2 := newGFp2(pool).Square(a.x, pool) + + c0 := newGFp2(pool).Add(a.x, a.y) + c0.Square(c0, pool) + c0.Sub(c0, v1) + c0.Sub(c0, v2) + c0.MulXi(c0, pool) + c0.Add(c0, v0) + + c1 := newGFp2(pool).Add(a.y, a.z) + c1.Square(c1, pool) + c1.Sub(c1, v0) + c1.Sub(c1, v1) + xiV2 := newGFp2(pool).MulXi(v2, pool) + c1.Add(c1, xiV2) + + c2 := newGFp2(pool).Add(a.x, a.z) + c2.Square(c2, pool) + c2.Sub(c2, v0) + c2.Add(c2, v1) + c2.Sub(c2, v2) + + e.x.Set(c2) + e.y.Set(c1) + e.z.Set(c0) + + v0.Put(pool) + v1.Put(pool) + v2.Put(pool) + c0.Put(pool) + c1.Put(pool) + c2.Put(pool) + xiV2.Put(pool) + + return e +} + +func (e *gfP6) Invert(a *gfP6, pool *bnPool) *gfP6 { + // See "Implementing cryptographic pairings", M. Scott, section 3.2. + // ftp://136.206.11.249/pub/crypto/pairings.pdf + + // Here we can give a short explanation of how it works: let j be a cubic root of + // unity in GF(p²) so that 1+j+j²=0. + // Then (xτ² + yτ + z)(xj²τ² + yjτ + z)(xjτ² + yj²τ + z) + // = (xτ² + yτ + z)(Cτ²+Bτ+A) + // = (x³ξ²+y³ξ+z³-3ξxyz) = F is an element of the base field (the norm). + // + // On the other hand (xj²τ² + yjτ + z)(xjτ² + yj²τ + z) + // = τ²(y²-ξxz) + τ(ξx²-yz) + (z²-ξxy) + // + // So that's why A = (z²-ξxy), B = (ξx²-yz), C = (y²-ξxz) + t1 := newGFp2(pool) + + A := newGFp2(pool) + A.Square(a.z, pool) + t1.Mul(a.x, a.y, pool) + t1.MulXi(t1, pool) + A.Sub(A, t1) + + B := newGFp2(pool) + B.Square(a.x, pool) + B.MulXi(B, pool) + t1.Mul(a.y, a.z, pool) + B.Sub(B, t1) + + C_ := newGFp2(pool) + C_.Square(a.y, pool) + t1.Mul(a.x, a.z, pool) + C_.Sub(C_, t1) + + F := newGFp2(pool) + F.Mul(C_, a.y, pool) + F.MulXi(F, pool) + t1.Mul(A, a.z, pool) + F.Add(F, t1) + t1.Mul(B, a.x, pool) + t1.MulXi(t1, pool) + F.Add(F, t1) + + F.Invert(F, pool) + + e.x.Mul(C_, F, pool) + e.y.Mul(B, F, pool) + e.z.Mul(A, F, pool) + + t1.Put(pool) + A.Put(pool) + B.Put(pool) + C_.Put(pool) + F.Put(pool) + + return e +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/optate.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/optate.go new file mode 100644 index 000000000..68716b62b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/optate.go @@ -0,0 +1,398 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +func lineFunctionAdd(r, p *twistPoint, q *curvePoint, r2 *gfP2, pool *bnPool) (a, b, c *gfP2, rOut *twistPoint) { + // See the mixed addition algorithm from "Faster Computation of the + // Tate Pairing", http://arxiv.org/pdf/0904.0854v3.pdf + + B := newGFp2(pool).Mul(p.x, r.t, pool) + + D := newGFp2(pool).Add(p.y, r.z) + D.Square(D, pool) + D.Sub(D, r2) + D.Sub(D, r.t) + D.Mul(D, r.t, pool) + + H := newGFp2(pool).Sub(B, r.x) + I := newGFp2(pool).Square(H, pool) + + E := newGFp2(pool).Add(I, I) + E.Add(E, E) + + J := newGFp2(pool).Mul(H, E, pool) + + L1 := newGFp2(pool).Sub(D, r.y) + L1.Sub(L1, r.y) + + V := newGFp2(pool).Mul(r.x, E, pool) + + rOut = newTwistPoint(pool) + rOut.x.Square(L1, pool) + rOut.x.Sub(rOut.x, J) + rOut.x.Sub(rOut.x, V) + rOut.x.Sub(rOut.x, V) + + rOut.z.Add(r.z, H) + rOut.z.Square(rOut.z, pool) + rOut.z.Sub(rOut.z, r.t) + rOut.z.Sub(rOut.z, I) + + t := newGFp2(pool).Sub(V, rOut.x) + t.Mul(t, L1, pool) + t2 := newGFp2(pool).Mul(r.y, J, pool) + t2.Add(t2, t2) + rOut.y.Sub(t, t2) + + rOut.t.Square(rOut.z, pool) + + t.Add(p.y, rOut.z) + t.Square(t, pool) + t.Sub(t, r2) + t.Sub(t, rOut.t) + + t2.Mul(L1, p.x, pool) + t2.Add(t2, t2) + a = newGFp2(pool) + a.Sub(t2, t) + + c = newGFp2(pool) + c.MulScalar(rOut.z, q.y) + c.Add(c, c) + + b = newGFp2(pool) + b.SetZero() + b.Sub(b, L1) + b.MulScalar(b, q.x) + b.Add(b, b) + + B.Put(pool) + D.Put(pool) + H.Put(pool) + I.Put(pool) + E.Put(pool) + J.Put(pool) + L1.Put(pool) + V.Put(pool) + t.Put(pool) + t2.Put(pool) + + return +} + +func lineFunctionDouble(r *twistPoint, q *curvePoint, pool *bnPool) (a, b, c *gfP2, rOut *twistPoint) { + // See the doubling algorithm for a=0 from "Faster Computation of the + // Tate Pairing", http://arxiv.org/pdf/0904.0854v3.pdf + + A := newGFp2(pool).Square(r.x, pool) + B := newGFp2(pool).Square(r.y, pool) + C_ := newGFp2(pool).Square(B, pool) + + D := newGFp2(pool).Add(r.x, B) + D.Square(D, pool) + D.Sub(D, A) + D.Sub(D, C_) + D.Add(D, D) + + E := newGFp2(pool).Add(A, A) + E.Add(E, A) + + G := newGFp2(pool).Square(E, pool) + + rOut = newTwistPoint(pool) + rOut.x.Sub(G, D) + rOut.x.Sub(rOut.x, D) + + rOut.z.Add(r.y, r.z) + rOut.z.Square(rOut.z, pool) + rOut.z.Sub(rOut.z, B) + rOut.z.Sub(rOut.z, r.t) + + rOut.y.Sub(D, rOut.x) + rOut.y.Mul(rOut.y, E, pool) + t := newGFp2(pool).Add(C_, C_) + t.Add(t, t) + t.Add(t, t) + rOut.y.Sub(rOut.y, t) + + rOut.t.Square(rOut.z, pool) + + t.Mul(E, r.t, pool) + t.Add(t, t) + b = newGFp2(pool) + b.SetZero() + b.Sub(b, t) + b.MulScalar(b, q.x) + + a = newGFp2(pool) + a.Add(r.x, E) + a.Square(a, pool) + a.Sub(a, A) + a.Sub(a, G) + t.Add(B, B) + t.Add(t, t) + a.Sub(a, t) + + c = newGFp2(pool) + c.Mul(rOut.z, r.t, pool) + c.Add(c, c) + c.MulScalar(c, q.y) + + A.Put(pool) + B.Put(pool) + C_.Put(pool) + D.Put(pool) + E.Put(pool) + G.Put(pool) + t.Put(pool) + + return +} + +func mulLine(ret *gfP12, a, b, c *gfP2, pool *bnPool) { + a2 := newGFp6(pool) + a2.x.SetZero() + a2.y.Set(a) + a2.z.Set(b) + a2.Mul(a2, ret.x, pool) + t3 := newGFp6(pool).MulScalar(ret.y, c, pool) + + t := newGFp2(pool) + t.Add(b, c) + t2 := newGFp6(pool) + t2.x.SetZero() + t2.y.Set(a) + t2.z.Set(t) + ret.x.Add(ret.x, ret.y) + + ret.y.Set(t3) + + ret.x.Mul(ret.x, t2, pool) + ret.x.Sub(ret.x, a2) + ret.x.Sub(ret.x, ret.y) + a2.MulTau(a2, pool) + ret.y.Add(ret.y, a2) + + a2.Put(pool) + t3.Put(pool) + t2.Put(pool) + t.Put(pool) +} + +// sixuPlus2NAF is 6u+2 in non-adjacent form. +var sixuPlus2NAF = []int8{0, 0, 0, 1, 0, 1, 0, -1, 0, 0, 1, -1, 0, 0, 1, 0, + 0, 1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 0, 0, 0, 1, 1, + 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, -1, 0, 0, 1, + 1, 0, 0, -1, 0, 0, 0, 1, 1, 0, -1, 0, 0, 1, 0, 1, 1} + +// miller implements the Miller loop for calculating the Optimal Ate pairing. +// See algorithm 1 from http://cryptojedi.org/papers/dclxvi-20100714.pdf +func miller(q *twistPoint, p *curvePoint, pool *bnPool) *gfP12 { + ret := newGFp12(pool) + ret.SetOne() + + aAffine := newTwistPoint(pool) + aAffine.Set(q) + aAffine.MakeAffine(pool) + + bAffine := newCurvePoint(pool) + bAffine.Set(p) + bAffine.MakeAffine(pool) + + minusA := newTwistPoint(pool) + minusA.Negative(aAffine, pool) + + r := newTwistPoint(pool) + r.Set(aAffine) + + r2 := newGFp2(pool) + r2.Square(aAffine.y, pool) + + for i := len(sixuPlus2NAF) - 1; i > 0; i-- { + a, b, c, newR := lineFunctionDouble(r, bAffine, pool) + if i != len(sixuPlus2NAF)-1 { + ret.Square(ret, pool) + } + + mulLine(ret, a, b, c, pool) + a.Put(pool) + b.Put(pool) + c.Put(pool) + r.Put(pool) + r = newR + + switch sixuPlus2NAF[i-1] { + case 1: + a, b, c, newR = lineFunctionAdd(r, aAffine, bAffine, r2, pool) + case -1: + a, b, c, newR = lineFunctionAdd(r, minusA, bAffine, r2, pool) + default: + continue + } + + mulLine(ret, a, b, c, pool) + a.Put(pool) + b.Put(pool) + c.Put(pool) + r.Put(pool) + r = newR + } + + // In order to calculate Q1 we have to convert q from the sextic twist + // to the full GF(p^12) group, apply the Frobenius there, and convert + // back. + // + // The twist isomorphism is (x', y') -> (xω², yω³). If we consider just + // x for a moment, then after applying the Frobenius, we have x̄ω^(2p) + // where x̄ is the conjugate of x. If we are going to apply the inverse + // isomorphism we need a value with a single coefficient of ω² so we + // rewrite this as x̄ω^(2p-2)ω². ξ⁶ = ω and, due to the construction of + // p, 2p-2 is a multiple of six. Therefore we can rewrite as + // x̄ξ^((p-1)/3)ω² and applying the inverse isomorphism eliminates the + // ω². + // + // A similar argument can be made for the y value. + + q1 := newTwistPoint(pool) + q1.x.Conjugate(aAffine.x) + q1.x.Mul(q1.x, xiToPMinus1Over3, pool) + q1.y.Conjugate(aAffine.y) + q1.y.Mul(q1.y, xiToPMinus1Over2, pool) + q1.z.SetOne() + q1.t.SetOne() + + // For Q2 we are applying the p² Frobenius. The two conjugations cancel + // out and we are left only with the factors from the isomorphism. In + // the case of x, we end up with a pure number which is why + // xiToPSquaredMinus1Over3 is ∈ GF(p). With y we get a factor of -1. We + // ignore this to end up with -Q2. + + minusQ2 := newTwistPoint(pool) + minusQ2.x.MulScalar(aAffine.x, xiToPSquaredMinus1Over3) + minusQ2.y.Set(aAffine.y) + minusQ2.z.SetOne() + minusQ2.t.SetOne() + + r2.Square(q1.y, pool) + a, b, c, newR := lineFunctionAdd(r, q1, bAffine, r2, pool) + mulLine(ret, a, b, c, pool) + a.Put(pool) + b.Put(pool) + c.Put(pool) + r.Put(pool) + r = newR + + r2.Square(minusQ2.y, pool) + a, b, c, newR = lineFunctionAdd(r, minusQ2, bAffine, r2, pool) + mulLine(ret, a, b, c, pool) + a.Put(pool) + b.Put(pool) + c.Put(pool) + r.Put(pool) + r = newR + + aAffine.Put(pool) + bAffine.Put(pool) + minusA.Put(pool) + r.Put(pool) + r2.Put(pool) + + return ret +} + +// finalExponentiation computes the (p¹²-1)/Order-th power of an element of +// GF(p¹²) to obtain an element of GT (steps 13-15 of algorithm 1 from +// http://cryptojedi.org/papers/dclxvi-20100714.pdf) +func finalExponentiation(in *gfP12, pool *bnPool) *gfP12 { + t1 := newGFp12(pool) + + // This is the p^6-Frobenius + t1.x.Negative(in.x) + t1.y.Set(in.y) + + inv := newGFp12(pool) + inv.Invert(in, pool) + t1.Mul(t1, inv, pool) + + t2 := newGFp12(pool).FrobeniusP2(t1, pool) + t1.Mul(t1, t2, pool) + + fp := newGFp12(pool).Frobenius(t1, pool) + fp2 := newGFp12(pool).FrobeniusP2(t1, pool) + fp3 := newGFp12(pool).Frobenius(fp2, pool) + + fu, fu2, fu3 := newGFp12(pool), newGFp12(pool), newGFp12(pool) + fu.Exp(t1, u, pool) + fu2.Exp(fu, u, pool) + fu3.Exp(fu2, u, pool) + + y3 := newGFp12(pool).Frobenius(fu, pool) + fu2p := newGFp12(pool).Frobenius(fu2, pool) + fu3p := newGFp12(pool).Frobenius(fu3, pool) + y2 := newGFp12(pool).FrobeniusP2(fu2, pool) + + y0 := newGFp12(pool) + y0.Mul(fp, fp2, pool) + y0.Mul(y0, fp3, pool) + + y1, y4, y5 := newGFp12(pool), newGFp12(pool), newGFp12(pool) + y1.Conjugate(t1) + y5.Conjugate(fu2) + y3.Conjugate(y3) + y4.Mul(fu, fu2p, pool) + y4.Conjugate(y4) + + y6 := newGFp12(pool) + y6.Mul(fu3, fu3p, pool) + y6.Conjugate(y6) + + t0 := newGFp12(pool) + t0.Square(y6, pool) + t0.Mul(t0, y4, pool) + t0.Mul(t0, y5, pool) + t1.Mul(y3, y5, pool) + t1.Mul(t1, t0, pool) + t0.Mul(t0, y2, pool) + t1.Square(t1, pool) + t1.Mul(t1, t0, pool) + t1.Square(t1, pool) + t0.Mul(t1, y1, pool) + t1.Mul(t1, y0, pool) + t0.Square(t0, pool) + t0.Mul(t0, t1, pool) + + inv.Put(pool) + t1.Put(pool) + t2.Put(pool) + fp.Put(pool) + fp2.Put(pool) + fp3.Put(pool) + fu.Put(pool) + fu2.Put(pool) + fu3.Put(pool) + fu2p.Put(pool) + fu3p.Put(pool) + y0.Put(pool) + y1.Put(pool) + y2.Put(pool) + y3.Put(pool) + y4.Put(pool) + y5.Put(pool) + y6.Put(pool) + + return t0 +} + +func optimalAte(a *twistPoint, b *curvePoint, pool *bnPool) *gfP12 { + e := miller(a, b, pool) + ret := finalExponentiation(e, pool) + e.Put(pool) + + if a.IsInfinity() || b.IsInfinity() { + ret.SetOne() + } + + return ret +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/bn256/twist.go b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/twist.go new file mode 100644 index 000000000..95b966e2e --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/bn256/twist.go @@ -0,0 +1,249 @@ +// Copyright 2012 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package bn256 + +import ( + "math/big" +) + +// twistPoint implements the elliptic curve y²=x³+3/ξ over GF(p²). Points are +// kept in Jacobian form and t=z² when valid. The group G₂ is the set of +// n-torsion points of this curve over GF(p²) (where n = Order) +type twistPoint struct { + x, y, z, t *gfP2 +} + +var twistB = &gfP2{ + bigFromBase10("266929791119991161246907387137283842545076965332900288569378510910307636690"), + bigFromBase10("19485874751759354771024239261021720505790618469301721065564631296452457478373"), +} + +// twistGen is the generator of group G₂. +var twistGen = &twistPoint{ + &gfP2{ + bigFromBase10("11559732032986387107991004021392285783925812861821192530917403151452391805634"), + bigFromBase10("10857046999023057135944570762232829481370756359578518086990519993285655852781"), + }, + &gfP2{ + bigFromBase10("4082367875863433681332203403145435568316851327593401208105741076214120093531"), + bigFromBase10("8495653923123431417604973247489272438418190587263600148770280649306958101930"), + }, + &gfP2{ + bigFromBase10("0"), + bigFromBase10("1"), + }, + &gfP2{ + bigFromBase10("0"), + bigFromBase10("1"), + }, +} + +func newTwistPoint(pool *bnPool) *twistPoint { + return &twistPoint{ + newGFp2(pool), + newGFp2(pool), + newGFp2(pool), + newGFp2(pool), + } +} + +func (c *twistPoint) String() string { + return "(" + c.x.String() + ", " + c.y.String() + ", " + c.z.String() + ")" +} + +func (c *twistPoint) Put(pool *bnPool) { + c.x.Put(pool) + c.y.Put(pool) + c.z.Put(pool) + c.t.Put(pool) +} + +func (c *twistPoint) Set(a *twistPoint) { + c.x.Set(a.x) + c.y.Set(a.y) + c.z.Set(a.z) + c.t.Set(a.t) +} + +// IsOnCurve returns true iff c is on the curve where c must be in affine form. +func (c *twistPoint) IsOnCurve() bool { + pool := new(bnPool) + yy := newGFp2(pool).Square(c.y, pool) + xxx := newGFp2(pool).Square(c.x, pool) + xxx.Mul(xxx, c.x, pool) + yy.Sub(yy, xxx) + yy.Sub(yy, twistB) + yy.Minimal() + return yy.x.Sign() == 0 && yy.y.Sign() == 0 +} + +func (c *twistPoint) SetInfinity() { + c.z.SetZero() +} + +func (c *twistPoint) IsInfinity() bool { + return c.z.IsZero() +} + +func (c *twistPoint) Add(a, b *twistPoint, pool *bnPool) { + // For additional comments, see the same function in curve.go. + + if a.IsInfinity() { + c.Set(b) + return + } + if b.IsInfinity() { + c.Set(a) + return + } + + // See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/addition/add-2007-bl.op3 + z1z1 := newGFp2(pool).Square(a.z, pool) + z2z2 := newGFp2(pool).Square(b.z, pool) + u1 := newGFp2(pool).Mul(a.x, z2z2, pool) + u2 := newGFp2(pool).Mul(b.x, z1z1, pool) + + t := newGFp2(pool).Mul(b.z, z2z2, pool) + s1 := newGFp2(pool).Mul(a.y, t, pool) + + t.Mul(a.z, z1z1, pool) + s2 := newGFp2(pool).Mul(b.y, t, pool) + + h := newGFp2(pool).Sub(u2, u1) + xEqual := h.IsZero() + + t.Add(h, h) + i := newGFp2(pool).Square(t, pool) + j := newGFp2(pool).Mul(h, i, pool) + + t.Sub(s2, s1) + yEqual := t.IsZero() + if xEqual && yEqual { + c.Double(a, pool) + return + } + r := newGFp2(pool).Add(t, t) + + v := newGFp2(pool).Mul(u1, i, pool) + + t4 := newGFp2(pool).Square(r, pool) + t.Add(v, v) + t6 := newGFp2(pool).Sub(t4, j) + c.x.Sub(t6, t) + + t.Sub(v, c.x) // t7 + t4.Mul(s1, j, pool) // t8 + t6.Add(t4, t4) // t9 + t4.Mul(r, t, pool) // t10 + c.y.Sub(t4, t6) + + t.Add(a.z, b.z) // t11 + t4.Square(t, pool) // t12 + t.Sub(t4, z1z1) // t13 + t4.Sub(t, z2z2) // t14 + c.z.Mul(t4, h, pool) + + z1z1.Put(pool) + z2z2.Put(pool) + u1.Put(pool) + u2.Put(pool) + t.Put(pool) + s1.Put(pool) + s2.Put(pool) + h.Put(pool) + i.Put(pool) + j.Put(pool) + r.Put(pool) + v.Put(pool) + t4.Put(pool) + t6.Put(pool) +} + +func (c *twistPoint) Double(a *twistPoint, pool *bnPool) { + // See http://hyperelliptic.org/EFD/g1p/auto-code/shortw/jacobian-0/doubling/dbl-2009-l.op3 + A := newGFp2(pool).Square(a.x, pool) + B := newGFp2(pool).Square(a.y, pool) + C_ := newGFp2(pool).Square(B, pool) + + t := newGFp2(pool).Add(a.x, B) + t2 := newGFp2(pool).Square(t, pool) + t.Sub(t2, A) + t2.Sub(t, C_) + d := newGFp2(pool).Add(t2, t2) + t.Add(A, A) + e := newGFp2(pool).Add(t, A) + f := newGFp2(pool).Square(e, pool) + + t.Add(d, d) + c.x.Sub(f, t) + + t.Add(C_, C_) + t2.Add(t, t) + t.Add(t2, t2) + c.y.Sub(d, c.x) + t2.Mul(e, c.y, pool) + c.y.Sub(t2, t) + + t.Mul(a.y, a.z, pool) + c.z.Add(t, t) + + A.Put(pool) + B.Put(pool) + C_.Put(pool) + t.Put(pool) + t2.Put(pool) + d.Put(pool) + e.Put(pool) + f.Put(pool) +} + +func (c *twistPoint) Mul(a *twistPoint, scalar *big.Int, pool *bnPool) *twistPoint { + sum := newTwistPoint(pool) + sum.SetInfinity() + t := newTwistPoint(pool) + + for i := scalar.BitLen(); i >= 0; i-- { + t.Double(sum, pool) + if scalar.Bit(i) != 0 { + sum.Add(t, a, pool) + } else { + sum.Set(t) + } + } + + c.Set(sum) + sum.Put(pool) + t.Put(pool) + return c +} + +func (c *twistPoint) MakeAffine(pool *bnPool) *twistPoint { + if c.z.IsOne() { + return c + } + + zInv := newGFp2(pool).Invert(c.z, pool) + t := newGFp2(pool).Mul(c.y, zInv, pool) + zInv2 := newGFp2(pool).Square(zInv, pool) + c.y.Mul(t, zInv2, pool) + t.Mul(c.x, zInv2, pool) + c.x.Set(t) + c.z.SetOne() + c.t.SetOne() + + zInv.Put(pool) + t.Put(pool) + zInv2.Put(pool) + + return c +} + +func (c *twistPoint) Negative(a *twistPoint, pool *bnPool) { + c.x.Set(a.x) + c.y.SetZero() + c.y.Sub(c.y, a.y) + c.z.Set(a.z) + c.t.SetZero() +} diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/crypto.go b/vendor/github.com/ethereum/go-ethereum/crypto/crypto.go index 0b8c06008..8161769d3 100644 --- a/vendor/github.com/ethereum/go-ethereum/crypto/crypto.go +++ b/vendor/github.com/ethereum/go-ethereum/crypto/crypto.go @@ -22,12 +22,14 @@ import ( "crypto/rand" "encoding/hex" "errors" + "fmt" "io" "io/ioutil" "math/big" "os" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/crypto/sha3" "github.com/ethereum/go-ethereum/rlp" ) @@ -66,9 +68,6 @@ func Keccak512(data ...[]byte) []byte { return d.Sum(nil) } -// Deprecated: For backward compatibility as other packages depend on these -func Sha3Hash(data ...[]byte) common.Hash { return Keccak256Hash(data...) } - // Creates an ethereum address given the bytes and the nonce func CreateAddress(b common.Address, nonce uint64) common.Address { data, _ := rlp.EncodeToBytes([]interface{}{b, nonce}) @@ -76,23 +75,38 @@ func CreateAddress(b common.Address, nonce uint64) common.Address { } // ToECDSA creates a private key with the given D value. -func ToECDSA(prv []byte) *ecdsa.PrivateKey { - if len(prv) == 0 { - return nil - } +func ToECDSA(d []byte) (*ecdsa.PrivateKey, error) { + return toECDSA(d, true) +} - priv := new(ecdsa.PrivateKey) - priv.PublicKey.Curve = S256() - priv.D = new(big.Int).SetBytes(prv) - priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(prv) +// ToECDSAUnsafe blidly 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 { + priv, _ := toECDSA(d, false) return priv } -func FromECDSA(prv *ecdsa.PrivateKey) []byte { - if prv == nil { +// toECDSA creates a private key with the given D value. The strict parameter +// controls whether the key's length should be enforced at the curve size or +// it can also accept legacy encodings (0 prefixes). +func toECDSA(d []byte, strict bool) (*ecdsa.PrivateKey, error) { + priv := new(ecdsa.PrivateKey) + priv.PublicKey.Curve = S256() + if strict && 8*len(d) != priv.Params().BitSize { + return nil, fmt.Errorf("invalid length, need %d bits", priv.Params().BitSize) + } + priv.D = new(big.Int).SetBytes(d) + priv.PublicKey.X, priv.PublicKey.Y = priv.PublicKey.Curve.ScalarBaseMult(d) + return priv, nil +} + +// FromECDSA exports a private key into a binary dump. +func FromECDSA(priv *ecdsa.PrivateKey) []byte { + if priv == nil { return nil } - return prv.D.Bytes() + return math.PaddedBigBytes(priv.D, priv.Params().BitSize/8) } func ToECDSAPub(pub []byte) *ecdsa.PublicKey { @@ -116,14 +130,10 @@ func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error) { if err != nil { return nil, errors.New("invalid hex string") } - if len(b) != 32 { - return nil, errors.New("invalid length, need 256 bits") - } - return ToECDSA(b), nil + return ToECDSA(b) } // LoadECDSA loads a secp256k1 private key from the given file. -// The key data is expected to be hex-encoded. func LoadECDSA(file string) (*ecdsa.PrivateKey, error) { buf := make([]byte, 64) fd, err := os.Open(file) @@ -139,8 +149,7 @@ func LoadECDSA(file string) (*ecdsa.PrivateKey, error) { if err != nil { return nil, err } - - return ToECDSA(key), nil + return ToECDSA(key) } // SaveECDSA saves a secp256k1 private key to the given file with diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/ecies/.gitignore b/vendor/github.com/ethereum/go-ethereum/crypto/ecies/.gitignore new file mode 100644 index 000000000..802b6744a --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/ecies/.gitignore @@ -0,0 +1,24 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe + +*~ diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/.gitignore b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/.gitignore new file mode 100644 index 000000000..802b6744a --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/.gitignore @@ -0,0 +1,24 @@ +# Compiled Object files, Static and Dynamic libs (Shared Objects) +*.o +*.a +*.so + +# Folders +_obj +_test + +# Architecture specific extensions/prefixes +*.[568vq] +[568vq].out + +*.cgo1.go +*.cgo2.c +_cgo_defun.c +_cgo_gotypes.go +_cgo_export.* + +_testmain.go + +*.exe + +*~ diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.gitignore b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.gitignore new file mode 100644 index 000000000..87fea161b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.gitignore @@ -0,0 +1,49 @@ +bench_inv +bench_ecdh +bench_sign +bench_verify +bench_schnorr_verify +bench_recover +bench_internal +tests +exhaustive_tests +gen_context +*.exe +*.so +*.a +!.gitignore + +Makefile +configure +.libs/ +Makefile.in +aclocal.m4 +autom4te.cache/ +config.log +config.status +*.tar.gz +*.la +libtool +.deps/ +.dirstamp +*.lo +*.o +*~ +src/libsecp256k1-config.h +src/libsecp256k1-config.h.in +src/ecmult_static_context.h +build-aux/config.guess +build-aux/config.sub +build-aux/depcomp +build-aux/install-sh +build-aux/ltmain.sh +build-aux/m4/libtool.m4 +build-aux/m4/lt~obsolete.m4 +build-aux/m4/ltoptions.m4 +build-aux/m4/ltsugar.m4 +build-aux/m4/ltversion.m4 +build-aux/missing +build-aux/compile +build-aux/test-driver +src/stamp-h1 +libsecp256k1.pc diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.travis.yml b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.travis.yml new file mode 100644 index 000000000..243952924 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/.travis.yml @@ -0,0 +1,69 @@ +language: c +sudo: false +addons: + apt: + packages: libgmp-dev +compiler: + - clang + - gcc +cache: + directories: + - src/java/guava/ +env: + global: + - FIELD=auto BIGNUM=auto SCALAR=auto ENDOMORPHISM=no STATICPRECOMPUTATION=yes ASM=no BUILD=check EXTRAFLAGS= HOST= ECDH=no RECOVERY=no EXPERIMENTAL=no + - GUAVA_URL=https://search.maven.org/remotecontent?filepath=com/google/guava/guava/18.0/guava-18.0.jar GUAVA_JAR=src/java/guava/guava-18.0.jar + matrix: + - SCALAR=32bit RECOVERY=yes + - SCALAR=32bit FIELD=32bit ECDH=yes EXPERIMENTAL=yes + - SCALAR=64bit + - FIELD=64bit RECOVERY=yes + - FIELD=64bit ENDOMORPHISM=yes + - FIELD=64bit ENDOMORPHISM=yes ECDH=yes EXPERIMENTAL=yes + - FIELD=64bit ASM=x86_64 + - FIELD=64bit ENDOMORPHISM=yes ASM=x86_64 + - FIELD=32bit ENDOMORPHISM=yes + - BIGNUM=no + - BIGNUM=no ENDOMORPHISM=yes RECOVERY=yes EXPERIMENTAL=yes + - BIGNUM=no STATICPRECOMPUTATION=no + - BUILD=distcheck + - EXTRAFLAGS=CPPFLAGS=-DDETERMINISTIC + - EXTRAFLAGS=CFLAGS=-O0 + - BUILD=check-java ECDH=yes EXPERIMENTAL=yes +matrix: + fast_finish: true + include: + - compiler: clang + env: HOST=i686-linux-gnu ENDOMORPHISM=yes + addons: + apt: + packages: + - gcc-multilib + - libgmp-dev:i386 + - compiler: clang + env: HOST=i686-linux-gnu + addons: + apt: + packages: + - gcc-multilib + - compiler: gcc + env: HOST=i686-linux-gnu ENDOMORPHISM=yes + addons: + apt: + packages: + - gcc-multilib + - compiler: gcc + env: HOST=i686-linux-gnu + addons: + apt: + packages: + - gcc-multilib + - libgmp-dev:i386 +before_install: mkdir -p `dirname $GUAVA_JAR` +install: if [ ! -f $GUAVA_JAR ]; then wget $GUAVA_URL -O $GUAVA_JAR; fi +before_script: ./autogen.sh +script: + - if [ -n "$HOST" ]; then export USE_HOST="--host=$HOST"; fi + - if [ "x$HOST" = "xi686-linux-gnu" ]; then export CC="$CC -m32"; fi + - ./configure --enable-experimental=$EXPERIMENTAL --enable-endomorphism=$ENDOMORPHISM --with-field=$FIELD --with-bignum=$BIGNUM --with-scalar=$SCALAR --enable-ecmult-static-precomputation=$STATICPRECOMPUTATION --enable-module-ecdh=$ECDH --enable-module-recovery=$RECOVERY $EXTRAFLAGS $USE_HOST && make -j2 $BUILD +os: linux diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/README.md b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/README.md new file mode 100644 index 000000000..8cd344ea8 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/README.md @@ -0,0 +1,61 @@ +libsecp256k1 +============ + +[![Build Status](https://travis-ci.org/bitcoin-core/secp256k1.svg?branch=master)](https://travis-ci.org/bitcoin-core/secp256k1) + +Optimized C library for EC operations on curve secp256k1. + +This library is a work in progress and is being used to research best practices. Use at your own risk. + +Features: +* secp256k1 ECDSA signing/verification and key generation. +* Adding/multiplying private/public keys. +* Serialization/parsing of private keys, public keys, signatures. +* Constant time, constant memory access signing and pubkey generation. +* Derandomized DSA (via RFC6979 or with a caller provided function.) +* Very efficient implementation. + +Implementation details +---------------------- + +* General + * No runtime heap allocation. + * Extensive testing infrastructure. + * Structured to facilitate review and analysis. + * Intended to be portable to any system with a C89 compiler and uint64_t support. + * Expose only higher level interfaces to minimize the API surface and improve application security. ("Be difficult to use insecurely.") +* Field operations + * Optimized implementation of arithmetic modulo the curve's field size (2^256 - 0x1000003D1). + * Using 5 52-bit limbs (including hand-optimized assembly for x86_64, by Diederik Huys). + * Using 10 26-bit limbs. + * Field inverses and square roots using a sliding window over blocks of 1s (by Peter Dettman). +* Scalar operations + * Optimized implementation without data-dependent branches of arithmetic modulo the curve's order. + * Using 4 64-bit limbs (relying on __int128 support in the compiler). + * Using 8 32-bit limbs. +* Group operations + * Point addition formula specifically simplified for the curve equation (y^2 = x^3 + 7). + * Use addition between points in Jacobian and affine coordinates where possible. + * Use a unified addition/doubling formula where necessary to avoid data-dependent branches. + * Point/x comparison without a field inversion by comparison in the Jacobian coordinate space. +* Point multiplication for verification (a*P + b*G). + * Use wNAF notation for point multiplicands. + * Use a much larger window for multiples of G, using precomputed multiples. + * Use Shamir's trick to do the multiplication with the public key and the generator simultaneously. + * Optionally (off by default) use secp256k1's efficiently-computable endomorphism to split the P multiplicand into 2 half-sized ones. +* Point multiplication for signing + * Use a precomputed table of multiples of powers of 16 multiplied with the generator, so general multiplication becomes a series of additions. + * Access the table with branch-free conditional moves so memory access is uniform. + * No data-dependent branches + * The precomputed tables add and eventually subtract points for which no known scalar (private key) is known, preventing even an attacker with control over the private key used to control the data internally. + +Build steps +----------- + +libsecp256k1 is built using autotools: + + $ ./autogen.sh + $ ./configure + $ make + $ ./tests + $ sudo make install # optional diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/obj/.gitignore b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/obj/.gitignore new file mode 100644 index 000000000..e69de29bb diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src/modules/recovery/main_impl.h old mode 100644 new mode 100755 diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src/secp256k1.c b/vendor/github.com/ethereum/go-ethereum/crypto/secp256k1/libsecp256k1/src/secp256k1.c old mode 100644 new mode 100755 diff --git a/vendor/github.com/ethereum/go-ethereum/crypto/sha3/testdata/keccakKats.json.deflate b/vendor/github.com/ethereum/go-ethereum/crypto/sha3/testdata/keccakKats.json.deflate new file mode 100644 index 000000000..62e85ae24 Binary files /dev/null and b/vendor/github.com/ethereum/go-ethereum/crypto/sha3/testdata/keccakKats.json.deflate differ diff --git a/vendor/github.com/ethereum/go-ethereum/eth/api.go b/vendor/github.com/ethereum/go-ethereum/eth/api.go index 61f7bdd92..0d90759b6 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/api.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/api.go @@ -153,6 +153,12 @@ func (api *PrivateMinerAPI) Start(threads *int) error { } // Start the miner and return if !api.e.IsMining() { + // Propagate the initial price point to the transaction pool + api.e.lock.RLock() + price := api.e.gasPrice + api.e.lock.RUnlock() + + api.e.txPool.SetGasPrice(price) return api.e.StartMining(true) } return nil @@ -180,7 +186,11 @@ func (api *PrivateMinerAPI) SetExtra(extra string) (bool, error) { // SetGasPrice sets the minimum accepted gas price for the miner. func (api *PrivateMinerAPI) SetGasPrice(gasPrice hexutil.Big) bool { - api.e.Miner().SetGasPrice((*big.Int)(&gasPrice)) + api.e.lock.Lock() + api.e.gasPrice = (*big.Int)(&gasPrice) + api.e.lock.Unlock() + + api.e.txPool.SetGasPrice((*big.Int)(&gasPrice)) return true } @@ -627,7 +637,7 @@ func (api *PrivateDebugAPI) StorageRangeAt(ctx context.Context, blockHash common return storageRangeAt(st, keyStart, maxResult), nil } -func storageRangeAt(st *trie.SecureTrie, start []byte, maxResult int) StorageRangeResult { +func storageRangeAt(st state.Trie, start []byte, maxResult int) StorageRangeResult { it := trie.NewIterator(st.NodeIterator(start)) result := StorageRangeResult{Storage: storageMap{}} for i := 0; i < maxResult && it.Next(); i++ { diff --git a/vendor/github.com/ethereum/go-ethereum/eth/api_backend.go b/vendor/github.com/ethereum/go-ethereum/eth/api_backend.go index ec6727260..5bc1218b4 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/api_backend.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/api_backend.go @@ -86,11 +86,11 @@ func (b *EthApiBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumb return b.eth.blockchain.GetBlockByNumber(uint64(blockNr)), nil } -func (b *EthApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (ethapi.State, *types.Header, error) { +func (b *EthApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error) { // Pending state is only known by the miner if blockNr == rpc.PendingBlockNumber { block, state := b.eth.miner.Pending() - return EthApiState{state}, block.Header(), nil + return state, block.Header(), nil } // Otherwise resolve the block number and return its state header, err := b.HeaderByNumber(ctx, blockNr) @@ -98,7 +98,7 @@ func (b *EthApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc. return nil, nil, err } stateDb, err := b.eth.BlockChain().StateAt(header.Root) - return EthApiState{stateDb}, header, err + return stateDb, header, err } func (b *EthApiBackend) GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error) { @@ -113,40 +113,27 @@ func (b *EthApiBackend) GetTd(blockHash common.Hash) *big.Int { return b.eth.blockchain.GetTdByHash(blockHash) } -func (b *EthApiBackend) GetEVM(ctx context.Context, msg core.Message, state ethapi.State, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) { - statedb := state.(EthApiState).state - from := statedb.GetOrNewStateObject(msg.From()) - from.SetBalance(math.MaxBig256) +func (b *EthApiBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) { + state.SetBalance(msg.From(), math.MaxBig256) vmError := func() error { return nil } context := core.NewEVMContext(msg, header, b.eth.BlockChain(), nil) - return vm.NewEVM(context, statedb, b.eth.chainConfig, vmCfg), vmError, nil + return vm.NewEVM(context, state, b.eth.chainConfig, vmCfg), vmError, nil } func (b *EthApiBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - - b.eth.txPool.SetLocal(signedTx) - return b.eth.txPool.Add(signedTx) + return b.eth.txPool.AddLocal(signedTx) } func (b *EthApiBackend) RemoveTx(txHash common.Hash) { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - b.eth.txPool.Remove(txHash) } func (b *EthApiBackend) GetPoolTransactions() (types.Transactions, error) { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - pending, err := b.eth.txPool.Pending() if err != nil { return nil, err } - var txs types.Transactions for _, batch := range pending { txs = append(txs, batch...) @@ -155,30 +142,18 @@ func (b *EthApiBackend) GetPoolTransactions() (types.Transactions, error) { } func (b *EthApiBackend) GetPoolTransaction(hash common.Hash) *types.Transaction { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - return b.eth.txPool.Get(hash) } func (b *EthApiBackend) GetPoolNonce(ctx context.Context, addr common.Address) (uint64, error) { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - return b.eth.txPool.State().GetNonce(addr), nil } func (b *EthApiBackend) Stats() (pending int, queued int) { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - return b.eth.txPool.Stats() } func (b *EthApiBackend) TxPoolContent() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) { - b.eth.txMu.Lock() - defer b.eth.txMu.Unlock() - return b.eth.TxPool().Content() } @@ -205,23 +180,3 @@ func (b *EthApiBackend) EventMux() *event.TypeMux { func (b *EthApiBackend) AccountManager() *accounts.Manager { return b.eth.AccountManager() } - -type EthApiState struct { - state *state.StateDB -} - -func (s EthApiState) GetBalance(ctx context.Context, addr common.Address) (*big.Int, error) { - return s.state.GetBalance(addr), nil -} - -func (s EthApiState) GetCode(ctx context.Context, addr common.Address) ([]byte, error) { - return s.state.GetCode(addr), nil -} - -func (s EthApiState) GetState(ctx context.Context, a common.Address, b common.Hash) (common.Hash, error) { - return s.state.GetState(a, b), nil -} - -func (s EthApiState) GetNonce(ctx context.Context, addr common.Address) (uint64, error) { - return s.state.GetNonce(addr), nil -} diff --git a/vendor/github.com/ethereum/go-ethereum/eth/backend.go b/vendor/github.com/ethereum/go-ethereum/eth/backend.go index 45b92db2f..d2b6b7212 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/backend.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/backend.go @@ -20,6 +20,7 @@ package eth import ( "errors" "fmt" + "math/big" "runtime" "sync" "sync/atomic" @@ -61,7 +62,6 @@ type Ethereum struct { stopDbUpgrade func() // stop chain db sequential key upgrade // Handlers txPool *core.TxPool - txMu sync.Mutex blockchain *core.BlockChain protocolManager *ProtocolManager lesServer LesServer @@ -74,18 +74,18 @@ type Ethereum struct { ApiBackend *EthApiBackend - miner *miner.Miner - Mining bool - MinerThreads int - etherbase common.Address + miner *miner.Miner + gasPrice *big.Int + etherbase common.Address networkId uint64 netRPCService *ethapi.PublicNetAPI + + lock sync.RWMutex // Protects the variadic fields (e.g. gas price and etherbase) } func (s *Ethereum) AddLesServer(ls LesServer) { s.lesServer = ls - s.protocolManager.lesServer = ls } // New creates a new Ethereum object (including the @@ -118,8 +118,8 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) { shutdownChan: make(chan bool), stopDbUpgrade: stopDbUpgrade, networkId: config.NetworkId, + gasPrice: config.GasPrice, etherbase: config.Etherbase, - MinerThreads: config.MinerThreads, } if err := addMipmapBloomBins(chainDb); err != nil { @@ -147,7 +147,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) { core.WriteChainConfig(chainDb, genesisHash, chainConfig) } - newPool := core.NewTxPool(eth.chainConfig, eth.EventMux(), eth.blockchain.State, eth.blockchain.GasLimit) + newPool := core.NewTxPool(config.TxPool, eth.chainConfig, eth.EventMux(), eth.blockchain.State, eth.blockchain.GasLimit) eth.txPool = newPool maxPeers := config.MaxPeers @@ -166,7 +166,6 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) { } eth.miner = miner.New(eth, eth.chainConfig, eth.EventMux(), eth.engine) - eth.miner.SetGasPrice(config.GasPrice) eth.miner.SetExtra(makeExtraData(config.ExtraData)) eth.ApiBackend = &EthApiBackend{eth, nil, nil} @@ -198,10 +197,13 @@ func makeExtraData(extra []byte) []byte { // CreateDB creates the chain database. func CreateDB(ctx *node.ServiceContext, config *Config, name string) (ethdb.Database, error) { db, err := ctx.OpenDatabase(name, config.DatabaseCache, config.DatabaseHandles) + if err != nil { + return nil, err + } if db, ok := db.(*ethdb.LDBDatabase); ok { db.Meter("eth/db/chaindata/") } - return db, err + return db, nil } // CreateConsensusEngine creates the required type of consensus engine instance for an Ethereum service @@ -291,8 +293,12 @@ func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) { } func (s *Ethereum) Etherbase() (eb common.Address, err error) { - if s.etherbase != (common.Address{}) { - return s.etherbase, nil + s.lock.RLock() + etherbase := s.etherbase + s.lock.RUnlock() + + if etherbase != (common.Address{}) { + return etherbase, nil } if wallets := s.AccountManager().Wallets(); len(wallets) > 0 { if accounts := wallets[0].Accounts(); len(accounts) > 0 { @@ -304,7 +310,10 @@ func (s *Ethereum) Etherbase() (eb common.Address, err error) { // set in js console via admin interface or wrapper from cli flags func (self *Ethereum) SetEtherbase(etherbase common.Address) { + self.lock.Lock() self.etherbase = etherbase + self.lock.Unlock() + self.miner.SetEtherbase(etherbase) } diff --git a/vendor/github.com/ethereum/go-ethereum/eth/bind.go b/vendor/github.com/ethereum/go-ethereum/eth/bind.go index 245934183..0385db1f9 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/bind.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/bind.go @@ -48,20 +48,18 @@ func NewContractBackend(apiBackend ethapi.Backend) *ContractBackend { return &ContractBackend{ eapi: ethapi.NewPublicEthereumAPI(apiBackend), bcapi: ethapi.NewPublicBlockChainAPI(apiBackend), - txapi: ethapi.NewPublicTransactionPoolAPI(apiBackend), + txapi: ethapi.NewPublicTransactionPoolAPI(apiBackend, new(ethapi.AddrLocker)), } } // CodeAt retrieves any code associated with the contract from the local API. func (b *ContractBackend) CodeAt(ctx context.Context, contract common.Address, blockNum *big.Int) ([]byte, error) { - out, err := b.bcapi.GetCode(ctx, contract, toBlockNumber(blockNum)) - return common.FromHex(out), err + return b.bcapi.GetCode(ctx, contract, toBlockNumber(blockNum)) } // CodeAt retrieves any code associated with the contract from the local API. func (b *ContractBackend) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) { - out, err := b.bcapi.GetCode(ctx, contract, rpc.PendingBlockNumber) - return common.FromHex(out), err + return b.bcapi.GetCode(ctx, contract, rpc.PendingBlockNumber) } // ContractCall implements bind.ContractCaller executing an Ethereum contract diff --git a/vendor/github.com/ethereum/go-ethereum/eth/config.go b/vendor/github.com/ethereum/go-ethereum/eth/config.go index a09ca76f3..4109cff8b 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/config.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/config.go @@ -42,8 +42,9 @@ var DefaultConfig = Config{ NetworkId: 1, LightPeers: 20, DatabaseCache: 128, - GasPrice: big.NewInt(20 * params.Shannon), + GasPrice: big.NewInt(18 * params.Shannon), + TxPool: core.DefaultTxPoolConfig, GPO: gasprice.Config{ Blocks: 10, Percentile: 50, @@ -99,6 +100,9 @@ type Config struct { EthashDatasetsInMem int EthashDatasetsOnDisk int + // Transaction pool options + TxPool core.TxPoolConfig + // Gas Price Oracle options GPO gasprice.Config diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/downloader.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/downloader.go index d26995782..6ac58140a 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/downloader/downloader.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/downloader.go @@ -34,7 +34,6 @@ import ( "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/params" - "github.com/ethereum/go-ethereum/trie" "github.com/rcrowley/go-metrics" ) @@ -99,8 +98,9 @@ type Downloader struct { mode SyncMode // Synchronisation mode defining the strategy used (per sync cycle) mux *event.TypeMux // Event multiplexer to announce sync operation events - queue *queue // Scheduler for selecting the hashes to download - peers *peerSet // Set of active peers from which download can proceed + queue *queue // Scheduler for selecting the hashes to download + peers *peerSet // Set of active peers from which download can proceed + stateDB ethdb.Database fsPivotLock *types.Header // Pivot header on critical section entry (cannot change between retries) fsPivotFails uint32 // Number of subsequent fast sync failures in the critical section @@ -109,26 +109,16 @@ type Downloader struct { rttConfidence uint64 // Confidence in the estimated RTT (unit: millionths to allow atomic ops) // Statistics - syncStatsChainOrigin uint64 // Origin block number where syncing started at - syncStatsChainHeight uint64 // Highest block number known when syncing started - syncStatsStateDone uint64 // Number of state trie entries already pulled + syncStatsChainOrigin uint64 // Origin block number where syncing started at + syncStatsChainHeight uint64 // Highest block number known when syncing started + syncStatsState stateSyncStats syncStatsLock sync.RWMutex // Lock protecting the sync stats fields + lightchain LightChain + blockchain BlockChain + // Callbacks - hasHeader headerCheckFn // Checks if a header is present in the chain - hasBlockAndState blockAndStateCheckFn // Checks if a block and associated state is present in the chain - getHeader headerRetrievalFn // Retrieves a header from the chain - getBlock blockRetrievalFn // Retrieves a block from the chain - headHeader headHeaderRetrievalFn // Retrieves the head header from the chain - headBlock headBlockRetrievalFn // Retrieves the head block from the chain - headFastBlock headFastBlockRetrievalFn // Retrieves the head fast-sync block from the chain - commitHeadBlock headBlockCommitterFn // Commits a manually assembled block as the chain head - getTd tdRetrievalFn // Retrieves the TD of a block from the chain - insertHeaders headerChainInsertFn // Injects a batch of headers into the chain - insertBlocks blockChainInsertFn // Injects a batch of blocks into the chain - insertReceipts receiptChainInsertFn // Injects a batch of blocks and their receipts into the chain - rollback chainRollbackFn // Removes a batch of recently added chain links - dropPeer peerDropFn // Drops a peer for misbehaving + dropPeer peerDropFn // Drops a peer for misbehaving // Status synchroniseMock func(id string, hash common.Hash) error // Replacement for synchronise during testing @@ -136,16 +126,18 @@ type Downloader struct { notified int32 // Channels - newPeerCh chan *peer headerCh chan dataPack // [eth/62] Channel receiving inbound block headers bodyCh chan dataPack // [eth/62] Channel receiving inbound block bodies receiptCh chan dataPack // [eth/63] Channel receiving inbound receipts - stateCh chan dataPack // [eth/63] Channel receiving inbound node state data bodyWakeCh chan bool // [eth/62] Channel to signal the block body fetcher of new tasks receiptWakeCh chan bool // [eth/63] Channel to signal the receipt fetcher of new tasks - stateWakeCh chan bool // [eth/63] Channel to signal the state fetcher of new tasks headerProcCh chan []*types.Header // [eth/62] Channel to feed the header processor new tasks + // for stateFetcher + stateSyncStart chan *stateSync + trackStateReq chan *stateReq + stateCh chan dataPack // [eth/63] Channel receiving inbound node state data + // Cancellation and termination cancelPeer string // Identifier of the peer currently being used as the master (cancel on drop) cancelCh chan struct{} // Channel to cancel mid-flight syncs @@ -161,45 +153,83 @@ type Downloader struct { chainInsertHook func([]*fetchResult) // Method to call upon inserting a chain of blocks (possibly in multiple invocations) } +// LightChain encapsulates functions required to synchronise a light chain. +type LightChain interface { + // HasHeader verifies a header's presence in the local chain. + HasHeader(common.Hash) bool + + // GetHeaderByHash retrieves a header from the local chain. + GetHeaderByHash(common.Hash) *types.Header + + // CurrentHeader retrieves the head header from the local chain. + CurrentHeader() *types.Header + + // GetTdByHash returns the total difficulty of a local block. + GetTdByHash(common.Hash) *big.Int + + // InsertHeaderChain inserts a batch of headers into the local chain. + InsertHeaderChain([]*types.Header, int) (int, error) + + // Rollback removes a few recently added elements from the local chain. + Rollback([]common.Hash) +} + +// BlockChain encapsulates functions required to sync a (full or fast) blockchain. +type BlockChain interface { + LightChain + + // HasBlockAndState verifies block and associated states' presence in the local chain. + HasBlockAndState(common.Hash) bool + + // GetBlockByHash retrieves a block from the local chain. + GetBlockByHash(common.Hash) *types.Block + + // CurrentBlock retrieves the head block from the local chain. + CurrentBlock() *types.Block + + // CurrentFastBlock retrieves the head fast block from the local chain. + CurrentFastBlock() *types.Block + + // FastSyncCommitHead directly commits the head block to a certain entity. + FastSyncCommitHead(common.Hash) error + + // InsertChain inserts a batch of blocks into the local chain. + InsertChain(types.Blocks) (int, error) + + // InsertReceiptChain inserts a batch of receipts into the local chain. + InsertReceiptChain(types.Blocks, []types.Receipts) (int, error) +} + // New creates a new downloader to fetch hashes and blocks from remote peers. -func New(mode SyncMode, stateDb ethdb.Database, mux *event.TypeMux, hasHeader headerCheckFn, hasBlockAndState blockAndStateCheckFn, - getHeader headerRetrievalFn, getBlock blockRetrievalFn, headHeader headHeaderRetrievalFn, headBlock headBlockRetrievalFn, - headFastBlock headFastBlockRetrievalFn, commitHeadBlock headBlockCommitterFn, getTd tdRetrievalFn, insertHeaders headerChainInsertFn, - insertBlocks blockChainInsertFn, insertReceipts receiptChainInsertFn, rollback chainRollbackFn, dropPeer peerDropFn) *Downloader { +func New(mode SyncMode, stateDb ethdb.Database, mux *event.TypeMux, chain BlockChain, lightchain LightChain, dropPeer peerDropFn) *Downloader { + if lightchain == nil { + lightchain = chain + } dl := &Downloader{ - mode: mode, - mux: mux, - queue: newQueue(stateDb), - peers: newPeerSet(), - rttEstimate: uint64(rttMaxEstimate), - rttConfidence: uint64(1000000), - hasHeader: hasHeader, - hasBlockAndState: hasBlockAndState, - getHeader: getHeader, - getBlock: getBlock, - headHeader: headHeader, - headBlock: headBlock, - headFastBlock: headFastBlock, - commitHeadBlock: commitHeadBlock, - getTd: getTd, - insertHeaders: insertHeaders, - insertBlocks: insertBlocks, - insertReceipts: insertReceipts, - rollback: rollback, - dropPeer: dropPeer, - newPeerCh: make(chan *peer, 1), - headerCh: make(chan dataPack, 1), - bodyCh: make(chan dataPack, 1), - receiptCh: make(chan dataPack, 1), - stateCh: make(chan dataPack, 1), - bodyWakeCh: make(chan bool, 1), - receiptWakeCh: make(chan bool, 1), - stateWakeCh: make(chan bool, 1), - headerProcCh: make(chan []*types.Header, 1), - quitCh: make(chan struct{}), + mode: mode, + stateDB: stateDb, + mux: mux, + queue: newQueue(), + peers: newPeerSet(), + rttEstimate: uint64(rttMaxEstimate), + rttConfidence: uint64(1000000), + blockchain: chain, + lightchain: lightchain, + dropPeer: dropPeer, + headerCh: make(chan dataPack, 1), + bodyCh: make(chan dataPack, 1), + receiptCh: make(chan dataPack, 1), + bodyWakeCh: make(chan bool, 1), + receiptWakeCh: make(chan bool, 1), + headerProcCh: make(chan []*types.Header, 1), + quitCh: make(chan struct{}), + stateCh: make(chan dataPack), + stateSyncStart: make(chan *stateSync), + trackStateReq: make(chan *stateReq), } go dl.qosTuner() + go dl.stateFetcher() return dl } @@ -211,9 +241,6 @@ func New(mode SyncMode, stateDb ethdb.Database, mux *event.TypeMux, hasHeader he // of processed and the total number of known states are also returned. Otherwise // these are zero. func (d *Downloader) Progress() ethereum.SyncProgress { - // Fetch the pending state count outside of the lock to prevent unforeseen deadlocks - pendingStates := uint64(d.queue.PendingNodeData()) - // Lock the current stats and return the progress d.syncStatsLock.RLock() defer d.syncStatsLock.RUnlock() @@ -221,18 +248,18 @@ func (d *Downloader) Progress() ethereum.SyncProgress { current := uint64(0) switch d.mode { case FullSync: - current = d.headBlock().NumberU64() + current = d.blockchain.CurrentBlock().NumberU64() case FastSync: - current = d.headFastBlock().NumberU64() + current = d.blockchain.CurrentFastBlock().NumberU64() case LightSync: - current = d.headHeader().Number.Uint64() + current = d.lightchain.CurrentHeader().Number.Uint64() } return ethereum.SyncProgress{ StartingBlock: d.syncStatsChainOrigin, CurrentBlock: current, HighestBlock: d.syncStatsChainHeight, - PulledStates: d.syncStatsStateDone, - KnownStates: d.syncStatsStateDone + pendingStates, + PulledStates: d.syncStatsState.processed, + KnownStates: d.syncStatsState.processed + d.syncStatsState.pending, } } @@ -243,13 +270,11 @@ func (d *Downloader) Synchronising() bool { // RegisterPeer injects a new download peer into the set of block source to be // used for fetching hashes and blocks from. -func (d *Downloader) RegisterPeer(id string, version int, currentHead currentHeadRetrievalFn, - getRelHeaders relativeHeaderFetcherFn, getAbsHeaders absoluteHeaderFetcherFn, getBlockBodies blockBodyFetcherFn, - getReceipts receiptFetcherFn, getNodeData stateFetcherFn) error { +func (d *Downloader) RegisterPeer(id string, version int, peer Peer) error { logger := log.New("peer", id) logger.Trace("Registering sync peer") - if err := d.peers.Register(newPeer(id, version, currentHead, getRelHeaders, getAbsHeaders, getBlockBodies, getReceipts, getNodeData, logger)); err != nil { + if err := d.peers.Register(newPeerConnection(id, version, peer, logger)); err != nil { logger.Error("Failed to register sync peer", "err", err) return err } @@ -258,6 +283,11 @@ func (d *Downloader) RegisterPeer(id string, version int, currentHead currentHea return nil } +// RegisterLightPeer injects a light client peer, wrapping it so it appears as a regular peer. +func (d *Downloader) RegisterLightPeer(id string, version int, peer LightPeer) error { + return d.RegisterPeer(id, version, &lightPeerWrapper{peer}) +} + // UnregisterPeer remove a peer from the known list, preventing any action from // the specified peer. An effort is also made to return any pending fetches into // the queue. @@ -324,13 +354,13 @@ func (d *Downloader) synchronise(id string, hash common.Hash, td *big.Int, mode d.queue.Reset() d.peers.Reset() - for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh, d.stateWakeCh} { + for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { select { case <-ch: default: } } - for _, ch := range []chan dataPack{d.headerCh, d.bodyCh, d.receiptCh, d.stateCh} { + for _, ch := range []chan dataPack{d.headerCh, d.bodyCh, d.receiptCh} { for empty := false; !empty; { select { case <-ch: @@ -369,7 +399,7 @@ func (d *Downloader) synchronise(id string, hash common.Hash, td *big.Int, mode // syncWithPeer starts a block synchronization based on the hash chain from the // specified peer and head hash. -func (d *Downloader) syncWithPeer(p *peer, hash common.Hash, td *big.Int) (err error) { +func (d *Downloader) syncWithPeer(p *peerConnection, hash common.Hash, td *big.Int) (err error) { d.mux.Post(StartEvent{}) defer func() { // reset on error @@ -439,30 +469,40 @@ func (d *Downloader) syncWithPeer(p *peer, hash common.Hash, td *big.Int) (err e if d.syncInitHook != nil { d.syncInitHook(origin, height) } - return d.spawnSync(origin+1, - func() error { return d.fetchHeaders(p, origin+1) }, // Headers are always retrieved - func() error { return d.processHeaders(origin+1, td) }, // Headers are always retrieved - func() error { return d.fetchBodies(origin + 1) }, // Bodies are retrieved during normal and fast sync - func() error { return d.fetchReceipts(origin + 1) }, // Receipts are retrieved during fast sync - func() error { return d.fetchNodeData() }, // Node state data is retrieved during fast sync - ) + + fetchers := []func() error{ + func() error { return d.fetchHeaders(p, origin+1) }, // Headers are always retrieved + func() error { return d.fetchBodies(origin + 1) }, // Bodies are retrieved during normal and fast sync + func() error { return d.fetchReceipts(origin + 1) }, // Receipts are retrieved during fast sync + func() error { return d.processHeaders(origin+1, td) }, + } + if d.mode == FastSync { + fetchers = append(fetchers, func() error { return d.processFastSyncContent(latest) }) + } else if d.mode == FullSync { + fetchers = append(fetchers, d.processFullSyncContent) + } + err = d.spawnSync(fetchers) + if err != nil && d.mode == FastSync && d.fsPivotLock != nil { + // If sync failed in the critical section, bump the fail counter. + atomic.AddUint32(&d.fsPivotFails, 1) + } + return err } // spawnSync runs d.process and all given fetcher functions to completion in // separate goroutines, returning the first error that appears. -func (d *Downloader) spawnSync(origin uint64, fetchers ...func() error) error { +func (d *Downloader) spawnSync(fetchers []func() error) error { var wg sync.WaitGroup - errc := make(chan error, len(fetchers)+1) - wg.Add(len(fetchers) + 1) - go func() { defer wg.Done(); errc <- d.processContent() }() + errc := make(chan error, len(fetchers)) + wg.Add(len(fetchers)) for _, fn := range fetchers { fn := fn go func() { defer wg.Done(); errc <- fn() }() } // Wait for the first error, then terminate the others. var err error - for i := 0; i < len(fetchers)+1; i++ { - if i == len(fetchers) { + for i := 0; i < len(fetchers); i++ { + if i == len(fetchers)-1 { // Close the queue when all fetchers have exited. // This will cause the block processor to end when // it has processed the queue. @@ -475,11 +515,6 @@ func (d *Downloader) spawnSync(origin uint64, fetchers ...func() error) error { d.queue.Close() d.Cancel() wg.Wait() - - // If sync failed in the critical section, bump the fail counter - if err != nil && d.mode == FastSync && d.fsPivotLock != nil { - atomic.AddUint32(&d.fsPivotFails, 1) - } return err } @@ -517,12 +552,12 @@ func (d *Downloader) Terminate() { // fetchHeight retrieves the head header of the remote peer to aid in estimating // the total time a pending synchronisation would take. -func (d *Downloader) fetchHeight(p *peer) (*types.Header, error) { +func (d *Downloader) fetchHeight(p *peerConnection) (*types.Header, error) { p.log.Debug("Retrieving remote chain height") // Request the advertised remote head block and wait for the response - head, _ := p.currentHead() - go p.getRelHeaders(head, 1, 0, false) + head, _ := p.peer.Head() + go p.peer.RequestHeadersByHash(head, 1, 0, false) ttl := d.requestTTL() timeout := time.After(ttl) @@ -552,7 +587,6 @@ func (d *Downloader) fetchHeight(p *peer) (*types.Header, error) { return nil, errTimeout case <-d.bodyCh: - case <-d.stateCh: case <-d.receiptCh: // Out of bounds delivery, ignore } @@ -564,15 +598,15 @@ func (d *Downloader) fetchHeight(p *peer) (*types.Header, error) { // on the correct chain, checking the top N links should already get us a match. // In the rare scenario when we ended up on a long reorganisation (i.e. none of // the head links match), we do a binary search to find the common ancestor. -func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { +func (d *Downloader) findAncestor(p *peerConnection, height uint64) (uint64, error) { // Figure out the valid ancestor range to prevent rewrite attacks - floor, ceil := int64(-1), d.headHeader().Number.Uint64() + floor, ceil := int64(-1), d.lightchain.CurrentHeader().Number.Uint64() p.log.Debug("Looking for common ancestor", "local", ceil, "remote", height) if d.mode == FullSync { - ceil = d.headBlock().NumberU64() + ceil = d.blockchain.CurrentBlock().NumberU64() } else if d.mode == FastSync { - ceil = d.headFastBlock().NumberU64() + ceil = d.blockchain.CurrentFastBlock().NumberU64() } if ceil >= MaxForkAncestry { floor = int64(ceil - MaxForkAncestry) @@ -592,7 +626,7 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { if count > limit { count = limit } - go p.getAbsHeaders(uint64(from), count, 15, false) + go p.peer.RequestHeadersByNumber(uint64(from), count, 15, false) // Wait for the remote response to the head fetch number, hash := uint64(0), common.Hash{} @@ -632,7 +666,7 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { continue } // Otherwise check if we already know the header or not - if (d.mode == FullSync && d.hasBlockAndState(headers[i].Hash())) || (d.mode != FullSync && d.hasHeader(headers[i].Hash())) { + if (d.mode == FullSync && d.blockchain.HasBlockAndState(headers[i].Hash())) || (d.mode != FullSync && d.lightchain.HasHeader(headers[i].Hash())) { number, hash = headers[i].Number.Uint64(), headers[i].Hash() // If every header is known, even future ones, the peer straight out lied about its head @@ -649,7 +683,6 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { return 0, errTimeout case <-d.bodyCh: - case <-d.stateCh: case <-d.receiptCh: // Out of bounds delivery, ignore } @@ -675,7 +708,7 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { ttl := d.requestTTL() timeout := time.After(ttl) - go p.getAbsHeaders(uint64(check), 1, 0, false) + go p.peer.RequestHeadersByNumber(uint64(check), 1, 0, false) // Wait until a reply arrives to this request for arrived := false; !arrived; { @@ -698,11 +731,11 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { arrived = true // Modify the search interval based on the response - if (d.mode == FullSync && !d.hasBlockAndState(headers[0].Hash())) || (d.mode != FullSync && !d.hasHeader(headers[0].Hash())) { + if (d.mode == FullSync && !d.blockchain.HasBlockAndState(headers[0].Hash())) || (d.mode != FullSync && !d.lightchain.HasHeader(headers[0].Hash())) { end = check break } - header := d.getHeader(headers[0].Hash()) // Independent of sync mode, header surely exists + header := d.lightchain.GetHeaderByHash(headers[0].Hash()) // Independent of sync mode, header surely exists if header.Number.Uint64() != check { p.log.Debug("Received non requested header", "number", header.Number, "hash", header.Hash(), "request", check) return 0, errBadPeer @@ -714,7 +747,6 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { return 0, errTimeout case <-d.bodyCh: - case <-d.stateCh: case <-d.receiptCh: // Out of bounds delivery, ignore } @@ -737,7 +769,7 @@ func (d *Downloader) findAncestor(p *peer, height uint64) (uint64, error) { // other peers are only accepted if they map cleanly to the skeleton. If no one // can fill in the skeleton - not even the origin peer - it's assumed invalid and // the origin is dropped. -func (d *Downloader) fetchHeaders(p *peer, from uint64) error { +func (d *Downloader) fetchHeaders(p *peerConnection, from uint64) error { p.log.Debug("Directing header downloads", "origin", from) defer p.log.Debug("Header download terminated") @@ -757,10 +789,10 @@ func (d *Downloader) fetchHeaders(p *peer, from uint64) error { if skeleton { p.log.Trace("Fetching skeleton headers", "count", MaxHeaderFetch, "from", from) - go p.getAbsHeaders(from+uint64(MaxHeaderFetch)-1, MaxSkeletonSize, MaxHeaderFetch-1, false) + go p.peer.RequestHeadersByNumber(from+uint64(MaxHeaderFetch)-1, MaxSkeletonSize, MaxHeaderFetch-1, false) } else { p.log.Trace("Fetching full headers", "count", MaxHeaderFetch, "from", from) - go p.getAbsHeaders(from, MaxHeaderFetch, 0, false) + go p.peer.RequestHeadersByNumber(from, MaxHeaderFetch, 0, false) } } // Start pulling the header chain skeleton until all is done @@ -827,7 +859,7 @@ func (d *Downloader) fetchHeaders(p *peer, from uint64) error { d.dropPeer(p.id) // Finish the sync gracefully instead of dumping the gathered data though - for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh, d.stateWakeCh} { + for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { select { case ch <- false: case <-d.cancelCh: @@ -862,12 +894,12 @@ func (d *Downloader) fillHeaderSkeleton(from uint64, skeleton []*types.Header) ( } expire = func() map[string]int { return d.queue.ExpireHeaders(d.requestTTL()) } throttle = func() bool { return false } - reserve = func(p *peer, count int) (*fetchRequest, bool, error) { + reserve = func(p *peerConnection, count int) (*fetchRequest, bool, error) { return d.queue.ReserveHeaders(p, count), false, nil } - fetch = func(p *peer, req *fetchRequest) error { return p.FetchHeaders(req.From, MaxHeaderFetch) } - capacity = func(p *peer) int { return p.HeaderCapacity(d.requestRTT()) } - setIdle = func(p *peer, accepted int) { p.SetHeadersIdle(accepted) } + fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchHeaders(req.From, MaxHeaderFetch) } + capacity = func(p *peerConnection) int { return p.HeaderCapacity(d.requestRTT()) } + setIdle = func(p *peerConnection, accepted int) { p.SetHeadersIdle(accepted) } ) err := d.fetchParts(errCancelHeaderFetch, d.headerCh, deliver, d.queue.headerContCh, expire, d.queue.PendingHeaders, d.queue.InFlightHeaders, throttle, reserve, @@ -891,9 +923,9 @@ func (d *Downloader) fetchBodies(from uint64) error { return d.queue.DeliverBodies(pack.peerId, pack.transactions, pack.uncles) } expire = func() map[string]int { return d.queue.ExpireBodies(d.requestTTL()) } - fetch = func(p *peer, req *fetchRequest) error { return p.FetchBodies(req) } - capacity = func(p *peer) int { return p.BlockCapacity(d.requestRTT()) } - setIdle = func(p *peer, accepted int) { p.SetBodiesIdle(accepted) } + fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchBodies(req) } + capacity = func(p *peerConnection) int { return p.BlockCapacity(d.requestRTT()) } + setIdle = func(p *peerConnection, accepted int) { p.SetBodiesIdle(accepted) } ) err := d.fetchParts(errCancelBodyFetch, d.bodyCh, deliver, d.bodyWakeCh, expire, d.queue.PendingBlocks, d.queue.InFlightBlocks, d.queue.ShouldThrottleBlocks, d.queue.ReserveBodies, @@ -915,9 +947,9 @@ func (d *Downloader) fetchReceipts(from uint64) error { return d.queue.DeliverReceipts(pack.peerId, pack.receipts) } expire = func() map[string]int { return d.queue.ExpireReceipts(d.requestTTL()) } - fetch = func(p *peer, req *fetchRequest) error { return p.FetchReceipts(req) } - capacity = func(p *peer) int { return p.ReceiptCapacity(d.requestRTT()) } - setIdle = func(p *peer, accepted int) { p.SetReceiptsIdle(accepted) } + fetch = func(p *peerConnection, req *fetchRequest) error { return p.FetchReceipts(req) } + capacity = func(p *peerConnection) int { return p.ReceiptCapacity(d.requestRTT()) } + setIdle = func(p *peerConnection, accepted int) { p.SetReceiptsIdle(accepted) } ) err := d.fetchParts(errCancelReceiptFetch, d.receiptCh, deliver, d.receiptWakeCh, expire, d.queue.PendingReceipts, d.queue.InFlightReceipts, d.queue.ShouldThrottleReceipts, d.queue.ReserveReceipts, @@ -927,68 +959,6 @@ func (d *Downloader) fetchReceipts(from uint64) error { return err } -// fetchNodeData iteratively downloads the scheduled state trie nodes, taking any -// available peers, reserving a chunk of nodes for each, waiting for delivery and -// also periodically checking for timeouts. -func (d *Downloader) fetchNodeData() error { - log.Debug("Downloading node state data") - - var ( - deliver = func(packet dataPack) (int, error) { - start := time.Now() - return d.queue.DeliverNodeData(packet.PeerId(), packet.(*statePack).states, func(delivered int, progressed bool, err error) { - // If the peer returned old-requested data, forgive - if err == trie.ErrNotRequested { - log.Debug("Forgiving reply to stale state request", "peer", packet.PeerId()) - return - } - if err != nil { - // If the node data processing failed, the root hash is very wrong, abort - log.Error("State processing failed", "peer", packet.PeerId(), "err", err) - d.Cancel() - return - } - // Processing succeeded, notify state fetcher of continuation - pending := d.queue.PendingNodeData() - if pending > 0 { - select { - case d.stateWakeCh <- true: - default: - } - } - d.syncStatsLock.Lock() - d.syncStatsStateDone += uint64(delivered) - syncStatsStateDone := d.syncStatsStateDone // Thread safe copy for the log below - d.syncStatsLock.Unlock() - - // If real database progress was made, reset any fast-sync pivot failure - if progressed && atomic.LoadUint32(&d.fsPivotFails) > 1 { - log.Debug("Fast-sync progressed, resetting fail counter", "previous", atomic.LoadUint32(&d.fsPivotFails)) - atomic.StoreUint32(&d.fsPivotFails, 1) // Don't ever reset to 0, as that will unlock the pivot block - } - // Log a message to the user and return - if delivered > 0 { - log.Info("Imported new state entries", "count", delivered, "elapsed", common.PrettyDuration(time.Since(start)), "processed", syncStatsStateDone, "pending", pending) - } - }) - } - expire = func() map[string]int { return d.queue.ExpireNodeData(d.requestTTL()) } - throttle = func() bool { return false } - reserve = func(p *peer, count int) (*fetchRequest, bool, error) { - return d.queue.ReserveNodeData(p, count), false, nil - } - fetch = func(p *peer, req *fetchRequest) error { return p.FetchNodeData(req) } - capacity = func(p *peer) int { return p.NodeDataCapacity(d.requestRTT()) } - setIdle = func(p *peer, accepted int) { p.SetNodeDataIdle(accepted) } - ) - err := d.fetchParts(errCancelStateFetch, d.stateCh, deliver, d.stateWakeCh, expire, - d.queue.PendingNodeData, d.queue.InFlightNodeData, throttle, reserve, nil, fetch, - d.queue.CancelNodeData, capacity, d.peers.NodeDataIdlePeers, setIdle, "states") - - log.Debug("Node state data download terminated", "err", err) - return err -} - // fetchParts iteratively downloads scheduled block parts, taking any available // peers, reserving a chunk of fetch requests for each, waiting for delivery and // also periodically checking for timeouts. @@ -1015,9 +985,9 @@ func (d *Downloader) fetchNodeData() error { // - setIdle: network callback to set a peer back to idle and update its estimated capacity (traffic shaping) // - kind: textual label of the type being downloaded to display in log mesages func (d *Downloader) fetchParts(errCancel error, deliveryCh chan dataPack, deliver func(dataPack) (int, error), wakeCh chan bool, - expire func() map[string]int, pending func() int, inFlight func() bool, throttle func() bool, reserve func(*peer, int) (*fetchRequest, bool, error), - fetchHook func([]*types.Header), fetch func(*peer, *fetchRequest) error, cancel func(*fetchRequest), capacity func(*peer) int, - idle func() ([]*peer, int), setIdle func(*peer, int), kind string) error { + expire func() map[string]int, pending func() int, inFlight func() bool, throttle func() bool, reserve func(*peerConnection, int) (*fetchRequest, bool, error), + fetchHook func([]*types.Header), fetch func(*peerConnection, *fetchRequest) error, cancel func(*fetchRequest), capacity func(*peerConnection) int, + idle func() ([]*peerConnection, int), setIdle func(*peerConnection, int), kind string) error { // Create a ticker to detect expired retrieval tasks ticker := time.NewTicker(100 * time.Millisecond) @@ -1182,23 +1152,19 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { for i, header := range rollback { hashes[i] = header.Hash() } - lastHeader, lastFastBlock, lastBlock := d.headHeader().Number, common.Big0, common.Big0 - if d.headFastBlock != nil { - lastFastBlock = d.headFastBlock().Number() + lastHeader, lastFastBlock, lastBlock := d.lightchain.CurrentHeader().Number, common.Big0, common.Big0 + if d.mode != LightSync { + lastFastBlock = d.blockchain.CurrentFastBlock().Number() + lastBlock = d.blockchain.CurrentBlock().Number() } - if d.headBlock != nil { - lastBlock = d.headBlock().Number() - } - d.rollback(hashes) + d.lightchain.Rollback(hashes) curFastBlock, curBlock := common.Big0, common.Big0 - if d.headFastBlock != nil { - curFastBlock = d.headFastBlock().Number() - } - if d.headBlock != nil { - curBlock = d.headBlock().Number() + if d.mode != LightSync { + curFastBlock = d.blockchain.CurrentFastBlock().Number() + curBlock = d.blockchain.CurrentBlock().Number() } log.Warn("Rolled back headers", "count", len(hashes), - "header", fmt.Sprintf("%d->%d", lastHeader, d.headHeader().Number), + "header", fmt.Sprintf("%d->%d", lastHeader, d.lightchain.CurrentHeader().Number), "fast", fmt.Sprintf("%d->%d", lastFastBlock, curFastBlock), "block", fmt.Sprintf("%d->%d", lastBlock, curBlock)) @@ -1229,7 +1195,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { // Terminate header processing if we synced up if len(headers) == 0 { // Notify everyone that headers are fully processed - for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh, d.stateWakeCh} { + for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { select { case ch <- false: case <-d.cancelCh: @@ -1248,7 +1214,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { // L: Request new headers up from 11 (R's TD was higher, it must have something) // R: Nothing to give if d.mode != LightSync { - if !gotHeaders && td.Cmp(d.getTd(d.headBlock().Hash())) > 0 { + if !gotHeaders && td.Cmp(d.blockchain.GetTdByHash(d.blockchain.CurrentBlock().Hash())) > 0 { return errStallingPeer } } @@ -1260,7 +1226,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { // queued for processing when the header download completes. However, as long as the // peer gave us something useful, we're already happy/progressed (above check). if d.mode == FastSync || d.mode == LightSync { - if td.Cmp(d.getTd(d.headHeader().Hash())) > 0 { + if td.Cmp(d.lightchain.GetTdByHash(d.lightchain.CurrentHeader().Hash())) > 0 { return errStallingPeer } } @@ -1290,7 +1256,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { // Collect the yet unknown headers to mark them as uncertain unknown := make([]*types.Header, 0, len(headers)) for _, header := range chunk { - if !d.hasHeader(header.Hash()) { + if !d.lightchain.HasHeader(header.Hash()) { unknown = append(unknown, header) } } @@ -1299,7 +1265,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { if chunk[len(chunk)-1].Number.Uint64()+uint64(fsHeaderForceVerify) > pivot { frequency = 1 } - if n, err := d.insertHeaders(chunk, frequency); err != nil { + if n, err := d.lightchain.InsertHeaderChain(chunk, frequency); err != nil { // If some headers were inserted, add them too to the rollback list if n > 0 { rollback = append(rollback, chunk[:n]...) @@ -1341,7 +1307,7 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { origin += uint64(limit) } // Signal the content downloaders of the availablility of new tasks - for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh, d.stateWakeCh} { + for _, ch := range []chan bool{d.bodyWakeCh, d.receiptWakeCh} { select { case ch <- true: default: @@ -1351,73 +1317,154 @@ func (d *Downloader) processHeaders(origin uint64, td *big.Int) error { } } -// processContent takes fetch results from the queue and tries to import them -// into the chain. The type of import operation will depend on the result contents. -func (d *Downloader) processContent() error { - pivot := d.queue.FastSyncPivot() +// processFullSyncContent takes fetch results from the queue and imports them into the chain. +func (d *Downloader) processFullSyncContent() error { for { results := d.queue.WaitResults() if len(results) == 0 { - return nil // queue empty + return nil } if d.chainInsertHook != nil { d.chainInsertHook(results) } - // Actually import the blocks - first, last := results[0].Header, results[len(results)-1].Header + if err := d.importBlockResults(results); err != nil { + return err + } + } +} + +func (d *Downloader) importBlockResults(results []*fetchResult) error { + for len(results) != 0 { + // Check for any termination requests. This makes clean shutdown faster. + select { + case <-d.quitCh: + return errCancelContentProcessing + default: + } + // Retrieve the a batch of results to import + items := int(math.Min(float64(len(results)), float64(maxResultsProcess))) + first, last := results[0].Header, results[items-1].Header log.Debug("Inserting downloaded chain", "items", len(results), "firstnum", first.Number, "firsthash", first.Hash(), "lastnum", last.Number, "lasthash", last.Hash(), ) - for len(results) != 0 { - // Check for any termination requests - select { - case <-d.quitCh: - return errCancelContentProcessing - default: + blocks := make([]*types.Block, items) + for i, result := range results[:items] { + blocks[i] = types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) + } + if index, err := d.blockchain.InsertChain(blocks); err != nil { + log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err) + return errInvalidChain + } + // Shift the results to the next batch + results = results[items:] + } + return nil +} + +// processFastSyncContent takes fetch results from the queue and writes them to the +// database. It also controls the synchronisation of state nodes of the pivot block. +func (d *Downloader) processFastSyncContent(latest *types.Header) error { + // Start syncing state of the reported head block. + // This should get us most of the state of the pivot block. + stateSync := d.syncState(latest.Root) + defer stateSync.Cancel() + go func() { + if err := stateSync.Wait(); err != nil { + d.queue.Close() // wake up WaitResults + } + }() + + pivot := d.queue.FastSyncPivot() + for { + results := d.queue.WaitResults() + if len(results) == 0 { + return stateSync.Cancel() + } + if d.chainInsertHook != nil { + d.chainInsertHook(results) + } + P, beforeP, afterP := splitAroundPivot(pivot, results) + if err := d.commitFastSyncData(beforeP, stateSync); err != nil { + return err + } + if P != nil { + stateSync.Cancel() + if err := d.commitPivotBlock(P); err != nil { + return err + } - // Retrieve the a batch of results to import - var ( - blocks = make([]*types.Block, 0, maxResultsProcess) - receipts = make([]types.Receipts, 0, maxResultsProcess) - ) - items := int(math.Min(float64(len(results)), float64(maxResultsProcess))) - for _, result := range results[:items] { - switch { - case d.mode == FullSync: - blocks = append(blocks, types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles)) - case d.mode == FastSync: - blocks = append(blocks, types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles)) - if result.Header.Number.Uint64() <= pivot { - receipts = append(receipts, result.Receipts) - } - } - } - // Try to process the results, aborting if there's an error - var ( - err error - index int - ) - switch { - case len(receipts) > 0: - index, err = d.insertReceipts(blocks, receipts) - if err == nil && blocks[len(blocks)-1].NumberU64() == pivot { - log.Debug("Committing block as new head", "number", blocks[len(blocks)-1].Number(), "hash", blocks[len(blocks)-1].Hash()) - index, err = len(blocks)-1, d.commitHeadBlock(blocks[len(blocks)-1].Hash()) - } - default: - index, err = d.insertBlocks(blocks) - } - if err != nil { - log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err) - return errInvalidChain - } - // Shift the results to the next batch - results = results[items:] + } + if err := d.importBlockResults(afterP); err != nil { + return err } } } +func splitAroundPivot(pivot uint64, results []*fetchResult) (p *fetchResult, before, after []*fetchResult) { + for _, result := range results { + num := result.Header.Number.Uint64() + switch { + case num < pivot: + before = append(before, result) + case num == pivot: + p = result + default: + after = append(after, result) + } + } + return p, before, after +} + +func (d *Downloader) commitFastSyncData(results []*fetchResult, stateSync *stateSync) error { + for len(results) != 0 { + // Check for any termination requests. + select { + case <-d.quitCh: + return errCancelContentProcessing + case <-stateSync.done: + if err := stateSync.Wait(); err != nil { + return err + } + default: + } + // Retrieve the a batch of results to import + items := int(math.Min(float64(len(results)), float64(maxResultsProcess))) + first, last := results[0].Header, results[items-1].Header + log.Debug("Inserting fast-sync blocks", "items", len(results), + "firstnum", first.Number, "firsthash", first.Hash(), + "lastnumn", last.Number, "lasthash", last.Hash(), + ) + blocks := make([]*types.Block, items) + receipts := make([]types.Receipts, items) + for i, result := range results[:items] { + blocks[i] = types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) + receipts[i] = result.Receipts + } + if index, err := d.blockchain.InsertReceiptChain(blocks, receipts); err != nil { + log.Debug("Downloaded item processing failed", "number", results[index].Header.Number, "hash", results[index].Header.Hash(), "err", err) + return errInvalidChain + } + // Shift the results to the next batch + results = results[items:] + } + return nil +} + +func (d *Downloader) commitPivotBlock(result *fetchResult) error { + b := types.NewBlockWithHeader(result.Header).WithBody(result.Transactions, result.Uncles) + // Sync the pivot block state. This should complete reasonably quickly because + // we've already synced up to the reported head block state earlier. + if err := d.syncState(b.Root()).Wait(); err != nil { + return err + } + log.Debug("Committing fast sync pivot as new head", "number", b.Number(), "hash", b.Hash()) + if _, err := d.blockchain.InsertReceiptChain([]*types.Block{b}, []types.Receipts{result.Receipts}); err != nil { + return err + } + return d.blockchain.FastSyncCommitHead(b.Hash()) +} + // DeliverHeaders injects a new batch of block headers received from a remote // node into the download schedule. func (d *Downloader) DeliverHeaders(id string, headers []*types.Header) (err error) { @@ -1491,6 +1538,10 @@ func (d *Downloader) qosTuner() { func (d *Downloader) qosReduceConfidence() { // If we have a single peer, confidence is always 1 peers := uint64(d.peers.Len()) + if peers == 0 { + // Ensure peer connectivity races don't catch us off guard + return + } if peers == 1 { atomic.StoreUint64(&d.rttConfidence, 1000000) return diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/metrics.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/metrics.go index 0d76c7dfd..58764ccf0 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/downloader/metrics.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/metrics.go @@ -38,8 +38,6 @@ var ( receiptDropMeter = metrics.NewMeter("eth/downloader/receipts/drop") receiptTimeoutMeter = metrics.NewMeter("eth/downloader/receipts/timeout") - stateInMeter = metrics.NewMeter("eth/downloader/states/in") - stateReqTimer = metrics.NewTimer("eth/downloader/states/req") - stateDropMeter = metrics.NewMeter("eth/downloader/states/drop") - stateTimeoutMeter = metrics.NewMeter("eth/downloader/states/timeout") + stateInMeter = metrics.NewMeter("eth/downloader/states/in") + stateDropMeter = metrics.NewMeter("eth/downloader/states/drop") ) diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/peer.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/peer.go index 15a912f1f..d0dc9a8aa 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/downloader/peer.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/peer.go @@ -30,6 +30,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/log" ) @@ -38,24 +39,14 @@ const ( measurementImpact = 0.1 // The impact a single measurement has on a peer's final throughput value. ) -// Head hash and total difficulty retriever for -type currentHeadRetrievalFn func() (common.Hash, *big.Int) - -// Block header and body fetchers belonging to eth/62 and above -type relativeHeaderFetcherFn func(common.Hash, int, int, bool) error -type absoluteHeaderFetcherFn func(uint64, int, int, bool) error -type blockBodyFetcherFn func([]common.Hash) error -type receiptFetcherFn func([]common.Hash) error -type stateFetcherFn func([]common.Hash) error - var ( errAlreadyFetching = errors.New("already fetching blocks from peer") errAlreadyRegistered = errors.New("peer is already registered") errNotRegistered = errors.New("peer is not registered") ) -// peer represents an active peer from which hashes and blocks are retrieved. -type peer struct { +// peerConnection represents an active peer from which hashes and blocks are retrieved. +type peerConnection struct { id string // Unique identifier of the peer headerIdle int32 // Current header activity state of the peer (idle = 0, active = 1) @@ -77,37 +68,57 @@ type peer struct { lacking map[common.Hash]struct{} // Set of hashes not to request (didn't have previously) - currentHead currentHeadRetrievalFn // Method to fetch the currently known head of the peer - - getRelHeaders relativeHeaderFetcherFn // [eth/62] Method to retrieve a batch of headers from an origin hash - getAbsHeaders absoluteHeaderFetcherFn // [eth/62] Method to retrieve a batch of headers from an absolute position - getBlockBodies blockBodyFetcherFn // [eth/62] Method to retrieve a batch of block bodies - - getReceipts receiptFetcherFn // [eth/63] Method to retrieve a batch of block transaction receipts - getNodeData stateFetcherFn // [eth/63] Method to retrieve a batch of state trie data + peer Peer version int // Eth protocol version number to switch strategies log log.Logger // Contextual logger to add extra infos to peer logs lock sync.RWMutex } -// newPeer create a new downloader peer, with specific hash and block retrieval -// mechanisms. -func newPeer(id string, version int, currentHead currentHeadRetrievalFn, - getRelHeaders relativeHeaderFetcherFn, getAbsHeaders absoluteHeaderFetcherFn, getBlockBodies blockBodyFetcherFn, - getReceipts receiptFetcherFn, getNodeData stateFetcherFn, logger log.Logger) *peer { +// LightPeer encapsulates the methods required to synchronise with a remote light peer. +type LightPeer interface { + Head() (common.Hash, *big.Int) + RequestHeadersByHash(common.Hash, int, int, bool) error + RequestHeadersByNumber(uint64, int, int, bool) error +} - return &peer{ +// Peer encapsulates the methods required to synchronise with a remote full peer. +type Peer interface { + LightPeer + RequestBodies([]common.Hash) error + RequestReceipts([]common.Hash) error + RequestNodeData([]common.Hash) error +} + +// lightPeerWrapper wraps a LightPeer struct, stubbing out the Peer-only methods. +type lightPeerWrapper struct { + peer LightPeer +} + +func (w *lightPeerWrapper) Head() (common.Hash, *big.Int) { return w.peer.Head() } +func (w *lightPeerWrapper) RequestHeadersByHash(h common.Hash, amount int, skip int, reverse bool) error { + return w.peer.RequestHeadersByHash(h, amount, skip, reverse) +} +func (w *lightPeerWrapper) RequestHeadersByNumber(i uint64, amount int, skip int, reverse bool) error { + return w.peer.RequestHeadersByNumber(i, amount, skip, reverse) +} +func (w *lightPeerWrapper) RequestBodies([]common.Hash) error { + panic("RequestBodies not supported in light client mode sync") +} +func (w *lightPeerWrapper) RequestReceipts([]common.Hash) error { + panic("RequestReceipts not supported in light client mode sync") +} +func (w *lightPeerWrapper) RequestNodeData([]common.Hash) error { + panic("RequestNodeData not supported in light client mode sync") +} + +// newPeerConnection creates a new downloader peer. +func newPeerConnection(id string, version int, peer Peer, logger log.Logger) *peerConnection { + return &peerConnection{ id: id, lacking: make(map[common.Hash]struct{}), - currentHead: currentHead, - getRelHeaders: getRelHeaders, - getAbsHeaders: getAbsHeaders, - getBlockBodies: getBlockBodies, - - getReceipts: getReceipts, - getNodeData: getNodeData, + peer: peer, version: version, log: logger, @@ -115,7 +126,7 @@ func newPeer(id string, version int, currentHead currentHeadRetrievalFn, } // Reset clears the internal state of a peer entity. -func (p *peer) Reset() { +func (p *peerConnection) Reset() { p.lock.Lock() defer p.lock.Unlock() @@ -133,7 +144,7 @@ func (p *peer) Reset() { } // FetchHeaders sends a header retrieval request to the remote peer. -func (p *peer) FetchHeaders(from uint64, count int) error { +func (p *peerConnection) FetchHeaders(from uint64, count int) error { // Sanity check the protocol version if p.version < 62 { panic(fmt.Sprintf("header fetch [eth/62+] requested on eth/%d", p.version)) @@ -145,13 +156,13 @@ func (p *peer) FetchHeaders(from uint64, count int) error { p.headerStarted = time.Now() // Issue the header retrieval request (absolut upwards without gaps) - go p.getAbsHeaders(from, count, 0, false) + go p.peer.RequestHeadersByNumber(from, count, 0, false) return nil } // FetchBodies sends a block body retrieval request to the remote peer. -func (p *peer) FetchBodies(request *fetchRequest) error { +func (p *peerConnection) FetchBodies(request *fetchRequest) error { // Sanity check the protocol version if p.version < 62 { panic(fmt.Sprintf("body fetch [eth/62+] requested on eth/%d", p.version)) @@ -167,13 +178,13 @@ func (p *peer) FetchBodies(request *fetchRequest) error { for _, header := range request.Headers { hashes = append(hashes, header.Hash()) } - go p.getBlockBodies(hashes) + go p.peer.RequestBodies(hashes) return nil } // FetchReceipts sends a receipt retrieval request to the remote peer. -func (p *peer) FetchReceipts(request *fetchRequest) error { +func (p *peerConnection) FetchReceipts(request *fetchRequest) error { // Sanity check the protocol version if p.version < 63 { panic(fmt.Sprintf("body fetch [eth/63+] requested on eth/%d", p.version)) @@ -189,13 +200,13 @@ func (p *peer) FetchReceipts(request *fetchRequest) error { for _, header := range request.Headers { hashes = append(hashes, header.Hash()) } - go p.getReceipts(hashes) + go p.peer.RequestReceipts(hashes) return nil } // FetchNodeData sends a node state data retrieval request to the remote peer. -func (p *peer) FetchNodeData(request *fetchRequest) error { +func (p *peerConnection) FetchNodeData(hashes []common.Hash) error { // Sanity check the protocol version if p.version < 63 { panic(fmt.Sprintf("node data fetch [eth/63+] requested on eth/%d", p.version)) @@ -206,12 +217,7 @@ func (p *peer) FetchNodeData(request *fetchRequest) error { } p.stateStarted = time.Now() - // Convert the hash set to a retrievable slice - hashes := make([]common.Hash, 0, len(request.Hashes)) - for hash := range request.Hashes { - hashes = append(hashes, hash) - } - go p.getNodeData(hashes) + go p.peer.RequestNodeData(hashes) return nil } @@ -219,41 +225,41 @@ func (p *peer) FetchNodeData(request *fetchRequest) error { // SetHeadersIdle sets the peer to idle, allowing it to execute new header retrieval // requests. Its estimated header retrieval throughput is updated with that measured // just now. -func (p *peer) SetHeadersIdle(delivered int) { +func (p *peerConnection) SetHeadersIdle(delivered int) { p.setIdle(p.headerStarted, delivered, &p.headerThroughput, &p.headerIdle) } // SetBlocksIdle sets the peer to idle, allowing it to execute new block retrieval // requests. Its estimated block retrieval throughput is updated with that measured // just now. -func (p *peer) SetBlocksIdle(delivered int) { +func (p *peerConnection) SetBlocksIdle(delivered int) { p.setIdle(p.blockStarted, delivered, &p.blockThroughput, &p.blockIdle) } // SetBodiesIdle sets the peer to idle, allowing it to execute block body retrieval // requests. Its estimated body retrieval throughput is updated with that measured // just now. -func (p *peer) SetBodiesIdle(delivered int) { +func (p *peerConnection) SetBodiesIdle(delivered int) { p.setIdle(p.blockStarted, delivered, &p.blockThroughput, &p.blockIdle) } // SetReceiptsIdle sets the peer to idle, allowing it to execute new receipt // retrieval requests. Its estimated receipt retrieval throughput is updated // with that measured just now. -func (p *peer) SetReceiptsIdle(delivered int) { +func (p *peerConnection) SetReceiptsIdle(delivered int) { p.setIdle(p.receiptStarted, delivered, &p.receiptThroughput, &p.receiptIdle) } // SetNodeDataIdle sets the peer to idle, allowing it to execute new state trie // data retrieval requests. Its estimated state retrieval throughput is updated // with that measured just now. -func (p *peer) SetNodeDataIdle(delivered int) { +func (p *peerConnection) SetNodeDataIdle(delivered int) { p.setIdle(p.stateStarted, delivered, &p.stateThroughput, &p.stateIdle) } // setIdle sets the peer to idle, allowing it to execute new retrieval requests. // Its estimated retrieval throughput is updated with that measured just now. -func (p *peer) setIdle(started time.Time, delivered int, throughput *float64, idle *int32) { +func (p *peerConnection) setIdle(started time.Time, delivered int, throughput *float64, idle *int32) { // Irrelevant of the scaling, make sure the peer ends up idle defer atomic.StoreInt32(idle, 0) @@ -280,7 +286,7 @@ func (p *peer) setIdle(started time.Time, delivered int, throughput *float64, id // HeaderCapacity retrieves the peers header download allowance based on its // previously discovered throughput. -func (p *peer) HeaderCapacity(targetRTT time.Duration) int { +func (p *peerConnection) HeaderCapacity(targetRTT time.Duration) int { p.lock.RLock() defer p.lock.RUnlock() @@ -289,7 +295,7 @@ func (p *peer) HeaderCapacity(targetRTT time.Duration) int { // BlockCapacity retrieves the peers block download allowance based on its // previously discovered throughput. -func (p *peer) BlockCapacity(targetRTT time.Duration) int { +func (p *peerConnection) BlockCapacity(targetRTT time.Duration) int { p.lock.RLock() defer p.lock.RUnlock() @@ -298,7 +304,7 @@ func (p *peer) BlockCapacity(targetRTT time.Duration) int { // ReceiptCapacity retrieves the peers receipt download allowance based on its // previously discovered throughput. -func (p *peer) ReceiptCapacity(targetRTT time.Duration) int { +func (p *peerConnection) ReceiptCapacity(targetRTT time.Duration) int { p.lock.RLock() defer p.lock.RUnlock() @@ -307,7 +313,7 @@ func (p *peer) ReceiptCapacity(targetRTT time.Duration) int { // NodeDataCapacity retrieves the peers state download allowance based on its // previously discovered throughput. -func (p *peer) NodeDataCapacity(targetRTT time.Duration) int { +func (p *peerConnection) NodeDataCapacity(targetRTT time.Duration) int { p.lock.RLock() defer p.lock.RUnlock() @@ -317,7 +323,7 @@ func (p *peer) NodeDataCapacity(targetRTT time.Duration) int { // MarkLacking appends a new entity to the set of items (blocks, receipts, states) // that a peer is known not to have (i.e. have been requested before). If the // set reaches its maximum allowed capacity, items are randomly dropped off. -func (p *peer) MarkLacking(hash common.Hash) { +func (p *peerConnection) MarkLacking(hash common.Hash) { p.lock.Lock() defer p.lock.Unlock() @@ -332,7 +338,7 @@ func (p *peer) MarkLacking(hash common.Hash) { // Lacks retrieves whether the hash of a blockchain item is on the peers lacking // list (i.e. whether we know that the peer does not have it). -func (p *peer) Lacks(hash common.Hash) bool { +func (p *peerConnection) Lacks(hash common.Hash) bool { p.lock.RLock() defer p.lock.RUnlock() @@ -343,17 +349,22 @@ func (p *peer) Lacks(hash common.Hash) bool { // peerSet represents the collection of active peer participating in the chain // download procedure. type peerSet struct { - peers map[string]*peer - lock sync.RWMutex + peers map[string]*peerConnection + newPeerFeed event.Feed + lock sync.RWMutex } // newPeerSet creates a new peer set top track the active download sources. func newPeerSet() *peerSet { return &peerSet{ - peers: make(map[string]*peer), + peers: make(map[string]*peerConnection), } } +func (ps *peerSet) SubscribeNewPeers(ch chan<- *peerConnection) event.Subscription { + return ps.newPeerFeed.Subscribe(ch) +} + // Reset iterates over the current peer set, and resets each of the known peers // to prepare for a next batch of block retrieval. func (ps *peerSet) Reset() { @@ -371,15 +382,14 @@ func (ps *peerSet) Reset() { // The method also sets the starting throughput values of the new peer to the // average of all existing peers, to give it a realistic chance of being used // for data retrievals. -func (ps *peerSet) Register(p *peer) error { +func (ps *peerSet) Register(p *peerConnection) error { // Retrieve the current median RTT as a sane default p.rtt = ps.medianRTT() // Register the new peer with some meaningful defaults ps.lock.Lock() - defer ps.lock.Unlock() - if _, ok := ps.peers[p.id]; ok { + ps.lock.Unlock() return errAlreadyRegistered } if len(ps.peers) > 0 { @@ -399,6 +409,9 @@ func (ps *peerSet) Register(p *peer) error { p.stateThroughput /= float64(len(ps.peers)) } ps.peers[p.id] = p + ps.lock.Unlock() + + ps.newPeerFeed.Send(p) return nil } @@ -416,7 +429,7 @@ func (ps *peerSet) Unregister(id string) error { } // Peer retrieves the registered peer with the given id. -func (ps *peerSet) Peer(id string) *peer { +func (ps *peerSet) Peer(id string) *peerConnection { ps.lock.RLock() defer ps.lock.RUnlock() @@ -432,11 +445,11 @@ func (ps *peerSet) Len() int { } // AllPeers retrieves a flat list of all the peers within the set. -func (ps *peerSet) AllPeers() []*peer { +func (ps *peerSet) AllPeers() []*peerConnection { ps.lock.RLock() defer ps.lock.RUnlock() - list := make([]*peer, 0, len(ps.peers)) + list := make([]*peerConnection, 0, len(ps.peers)) for _, p := range ps.peers { list = append(list, p) } @@ -445,11 +458,11 @@ func (ps *peerSet) AllPeers() []*peer { // HeaderIdlePeers retrieves a flat list of all the currently header-idle peers // within the active peer set, ordered by their reputation. -func (ps *peerSet) HeaderIdlePeers() ([]*peer, int) { - idle := func(p *peer) bool { +func (ps *peerSet) HeaderIdlePeers() ([]*peerConnection, int) { + idle := func(p *peerConnection) bool { return atomic.LoadInt32(&p.headerIdle) == 0 } - throughput := func(p *peer) float64 { + throughput := func(p *peerConnection) float64 { p.lock.RLock() defer p.lock.RUnlock() return p.headerThroughput @@ -459,11 +472,11 @@ func (ps *peerSet) HeaderIdlePeers() ([]*peer, int) { // BodyIdlePeers retrieves a flat list of all the currently body-idle peers within // the active peer set, ordered by their reputation. -func (ps *peerSet) BodyIdlePeers() ([]*peer, int) { - idle := func(p *peer) bool { +func (ps *peerSet) BodyIdlePeers() ([]*peerConnection, int) { + idle := func(p *peerConnection) bool { return atomic.LoadInt32(&p.blockIdle) == 0 } - throughput := func(p *peer) float64 { + throughput := func(p *peerConnection) float64 { p.lock.RLock() defer p.lock.RUnlock() return p.blockThroughput @@ -473,11 +486,11 @@ func (ps *peerSet) BodyIdlePeers() ([]*peer, int) { // ReceiptIdlePeers retrieves a flat list of all the currently receipt-idle peers // within the active peer set, ordered by their reputation. -func (ps *peerSet) ReceiptIdlePeers() ([]*peer, int) { - idle := func(p *peer) bool { +func (ps *peerSet) ReceiptIdlePeers() ([]*peerConnection, int) { + idle := func(p *peerConnection) bool { return atomic.LoadInt32(&p.receiptIdle) == 0 } - throughput := func(p *peer) float64 { + throughput := func(p *peerConnection) float64 { p.lock.RLock() defer p.lock.RUnlock() return p.receiptThroughput @@ -487,11 +500,11 @@ func (ps *peerSet) ReceiptIdlePeers() ([]*peer, int) { // NodeDataIdlePeers retrieves a flat list of all the currently node-data-idle // peers within the active peer set, ordered by their reputation. -func (ps *peerSet) NodeDataIdlePeers() ([]*peer, int) { - idle := func(p *peer) bool { +func (ps *peerSet) NodeDataIdlePeers() ([]*peerConnection, int) { + idle := func(p *peerConnection) bool { return atomic.LoadInt32(&p.stateIdle) == 0 } - throughput := func(p *peer) float64 { + throughput := func(p *peerConnection) float64 { p.lock.RLock() defer p.lock.RUnlock() return p.stateThroughput @@ -502,11 +515,11 @@ func (ps *peerSet) NodeDataIdlePeers() ([]*peer, int) { // idlePeers retrieves a flat list of all currently idle peers satisfying the // protocol version constraints, using the provided function to check idleness. // The resulting set of peers are sorted by their measure throughput. -func (ps *peerSet) idlePeers(minProtocol, maxProtocol int, idleCheck func(*peer) bool, throughput func(*peer) float64) ([]*peer, int) { +func (ps *peerSet) idlePeers(minProtocol, maxProtocol int, idleCheck func(*peerConnection) bool, throughput func(*peerConnection) float64) ([]*peerConnection, int) { ps.lock.RLock() defer ps.lock.RUnlock() - idle, total := make([]*peer, 0, len(ps.peers)), 0 + idle, total := make([]*peerConnection, 0, len(ps.peers)), 0 for _, p := range ps.peers { if p.version >= minProtocol && p.version <= maxProtocol { if idleCheck(p) { diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/queue.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/queue.go index 855097c45..6926f1d8c 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/downloader/queue.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/queue.go @@ -26,20 +26,13 @@ import ( "time" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/trie" "github.com/rcrowley/go-metrics" "gopkg.in/karalabe/cookiejar.v2/collections/prque" ) -var ( - blockCacheLimit = 8192 // Maximum number of blocks to cache before throttling the download - maxInFlightStates = 8192 // Maximum number of state downloads to allow concurrently -) +var blockCacheLimit = 8192 // Maximum number of blocks to cache before throttling the download var ( errNoFetchesPending = errors.New("no fetches pending") @@ -48,7 +41,7 @@ var ( // fetchRequest is a currently running data retrieval operation. type fetchRequest struct { - Peer *peer // Peer to which the request was sent + Peer *peerConnection // Peer to which the request was sent From uint64 // [eth/62] Requested chain element index (used for skeleton fills only) Hashes map[common.Hash]int // [eth/61] Requested hashes with their insertion index (priority) Headers []*types.Header // [eth/62] Requested headers, sorted by request order @@ -94,15 +87,6 @@ type queue struct { receiptPendPool map[string]*fetchRequest // [eth/63] Currently pending receipt retrieval operations receiptDonePool map[common.Hash]struct{} // [eth/63] Set of the completed receipt fetches - stateTaskIndex int // [eth/63] Counter indexing the added hashes to ensure prioritised retrieval order - stateTaskPool map[common.Hash]int // [eth/63] Pending node data retrieval tasks, mapping to their priority - stateTaskQueue *prque.Prque // [eth/63] Priority queue of the hashes to fetch the node data for - statePendPool map[string]*fetchRequest // [eth/63] Currently pending node data retrieval operations - - stateDatabase ethdb.Database // [eth/63] Trie database to populate during state reassembly - stateScheduler *state.StateSync // [eth/63] State trie synchronisation scheduler and integrator - stateWriters int // [eth/63] Number of running state DB writer goroutines - resultCache []*fetchResult // Downloaded but not yet delivered fetch results resultOffset uint64 // Offset of the first cached fetch result in the block chain @@ -112,7 +96,7 @@ type queue struct { } // newQueue creates a new download queue for scheduling block retrieval. -func newQueue(stateDb ethdb.Database) *queue { +func newQueue() *queue { lock := new(sync.Mutex) return &queue{ headerPendPool: make(map[string]*fetchRequest), @@ -125,10 +109,6 @@ func newQueue(stateDb ethdb.Database) *queue { receiptTaskQueue: prque.New(), receiptPendPool: make(map[string]*fetchRequest), receiptDonePool: make(map[common.Hash]struct{}), - stateTaskPool: make(map[common.Hash]int), - stateTaskQueue: prque.New(), - statePendPool: make(map[string]*fetchRequest), - stateDatabase: stateDb, resultCache: make([]*fetchResult, blockCacheLimit), active: sync.NewCond(lock), lock: lock, @@ -158,12 +138,6 @@ func (q *queue) Reset() { q.receiptPendPool = make(map[string]*fetchRequest) q.receiptDonePool = make(map[common.Hash]struct{}) - q.stateTaskIndex = 0 - q.stateTaskPool = make(map[common.Hash]int) - q.stateTaskQueue.Reset() - q.statePendPool = make(map[string]*fetchRequest) - q.stateScheduler = nil - q.resultCache = make([]*fetchResult, blockCacheLimit) q.resultOffset = 0 } @@ -201,28 +175,6 @@ func (q *queue) PendingReceipts() int { return q.receiptTaskQueue.Size() } -// PendingNodeData retrieves the number of node data entries pending for retrieval. -func (q *queue) PendingNodeData() int { - q.lock.Lock() - defer q.lock.Unlock() - - return q.pendingNodeDataLocked() -} - -// pendingNodeDataLocked retrieves the number of node data entries pending for retrieval. -// The caller must hold q.lock. -func (q *queue) pendingNodeDataLocked() int { - var n int - if q.stateScheduler != nil { - n = q.stateScheduler.Pending() - } - // Ensure that PendingNodeData doesn't return 0 until all state is written. - if q.stateWriters > 0 { - n++ - } - return n -} - // InFlightHeaders retrieves whether there are header fetch requests currently // in flight. func (q *queue) InFlightHeaders() bool { @@ -250,28 +202,15 @@ func (q *queue) InFlightReceipts() bool { return len(q.receiptPendPool) > 0 } -// InFlightNodeData retrieves whether there are node data entry fetch requests -// currently in flight. -func (q *queue) InFlightNodeData() bool { - q.lock.Lock() - defer q.lock.Unlock() - - return len(q.statePendPool)+q.stateWriters > 0 -} - -// Idle returns if the queue is fully idle or has some data still inside. This -// method is used by the tester to detect termination events. +// Idle returns if the queue is fully idle or has some data still inside. func (q *queue) Idle() bool { q.lock.Lock() defer q.lock.Unlock() - queued := q.blockTaskQueue.Size() + q.receiptTaskQueue.Size() + q.stateTaskQueue.Size() - pending := len(q.blockPendPool) + len(q.receiptPendPool) + len(q.statePendPool) + queued := q.blockTaskQueue.Size() + q.receiptTaskQueue.Size() + pending := len(q.blockPendPool) + len(q.receiptPendPool) cached := len(q.blockDonePool) + len(q.receiptDonePool) - if q.stateScheduler != nil { - queued += q.stateScheduler.Pending() - } return (queued + pending + cached) == 0 } @@ -389,19 +328,6 @@ func (q *queue) Schedule(headers []*types.Header, from uint64) []*types.Header { q.receiptTaskPool[hash] = header q.receiptTaskQueue.Push(header, -float32(header.Number.Uint64())) } - if q.mode == FastSync && header.Number.Uint64() == q.fastSyncPivot { - // Pivoting point of the fast sync, switch the state retrieval to this - log.Debug("Switching state downloads to new block", "number", header.Number, "hash", hash) - - q.stateTaskIndex = 0 - q.stateTaskPool = make(map[common.Hash]int) - q.stateTaskQueue.Reset() - for _, req := range q.statePendPool { - req.Hashes = make(map[common.Hash]int) // Make sure executing requests fail, but don't disappear - } - - q.stateScheduler = state.NewStateSync(header.Root, q.stateDatabase) - } inserts = append(inserts, header) q.headerHead = hash from++ @@ -448,31 +374,15 @@ func (q *queue) countProcessableItems() int { if result == nil || result.Pending > 0 { return i } - // Special handling for the fast-sync pivot block: - if q.mode == FastSync { - bnum := result.Header.Number.Uint64() - if bnum == q.fastSyncPivot { - // If the state of the pivot block is not - // available yet, we cannot proceed and return 0. - // - // Stop before processing the pivot block to ensure that - // resultCache has space for fsHeaderForceVerify items. Not - // doing this could leave us unable to download the required - // amount of headers. - if i > 0 || len(q.stateTaskPool) > 0 || q.pendingNodeDataLocked() > 0 { + // Stop before processing the pivot block to ensure that + // resultCache has space for fsHeaderForceVerify items. Not + // doing this could leave us unable to download the required + // amount of headers. + if q.mode == FastSync && result.Header.Number.Uint64() == q.fastSyncPivot { + for j := 0; j < fsHeaderForceVerify; j++ { + if i+j+1 >= len(q.resultCache) || q.resultCache[i+j+1] == nil { return i } - for j := 0; j < fsHeaderForceVerify; j++ { - if i+j+1 >= len(q.resultCache) || q.resultCache[i+j+1] == nil { - return i - } - } - } - // If we're just the fast sync pivot, stop as well - // because the following batch needs different insertion. - // This simplifies handling the switchover in d.process. - if bnum == q.fastSyncPivot+1 && i > 0 { - return i } } } @@ -481,7 +391,7 @@ func (q *queue) countProcessableItems() int { // ReserveHeaders reserves a set of headers for the given peer, skipping any // previously failed batches. -func (q *queue) ReserveHeaders(p *peer, count int) *fetchRequest { +func (q *queue) ReserveHeaders(p *peerConnection, count int) *fetchRequest { q.lock.Lock() defer q.lock.Unlock() @@ -519,85 +429,10 @@ func (q *queue) ReserveHeaders(p *peer, count int) *fetchRequest { return request } -// ReserveNodeData reserves a set of node data hashes for the given peer, skipping -// any previously failed download. -func (q *queue) ReserveNodeData(p *peer, count int) *fetchRequest { - // Create a task generator to fetch status-fetch tasks if all schedules ones are done - generator := func(max int) { - if q.stateScheduler != nil { - for _, hash := range q.stateScheduler.Missing(max) { - q.stateTaskPool[hash] = q.stateTaskIndex - q.stateTaskQueue.Push(hash, -float32(q.stateTaskIndex)) - q.stateTaskIndex++ - } - } - } - q.lock.Lock() - defer q.lock.Unlock() - - return q.reserveHashes(p, count, q.stateTaskQueue, generator, q.statePendPool, maxInFlightStates) -} - -// reserveHashes reserves a set of hashes for the given peer, skipping previously -// failed ones. -// -// Note, this method expects the queue lock to be already held for writing. The -// reason the lock is not obtained in here is because the parameters already need -// to access the queue, so they already need a lock anyway. -func (q *queue) reserveHashes(p *peer, count int, taskQueue *prque.Prque, taskGen func(int), pendPool map[string]*fetchRequest, maxPending int) *fetchRequest { - // Short circuit if the peer's already downloading something (sanity check to - // not corrupt state) - if _, ok := pendPool[p.id]; ok { - return nil - } - // Calculate an upper limit on the hashes we might fetch (i.e. throttling) - allowance := maxPending - if allowance > 0 { - for _, request := range pendPool { - allowance -= len(request.Hashes) - } - } - // If there's a task generator, ask it to fill our task queue - if taskGen != nil && taskQueue.Size() < allowance { - taskGen(allowance - taskQueue.Size()) - } - if taskQueue.Empty() { - return nil - } - // Retrieve a batch of hashes, skipping previously failed ones - send := make(map[common.Hash]int) - skip := make(map[common.Hash]int) - - for proc := 0; (allowance == 0 || proc < allowance) && len(send) < count && !taskQueue.Empty(); proc++ { - hash, priority := taskQueue.Pop() - if p.Lacks(hash.(common.Hash)) { - skip[hash.(common.Hash)] = int(priority) - } else { - send[hash.(common.Hash)] = int(priority) - } - } - // Merge all the skipped hashes back - for hash, index := range skip { - taskQueue.Push(hash, float32(index)) - } - // Assemble and return the block download request - if len(send) == 0 { - return nil - } - request := &fetchRequest{ - Peer: p, - Hashes: send, - Time: time.Now(), - } - pendPool[p.id] = request - - return request -} - // ReserveBodies reserves a set of body fetches for the given peer, skipping any // previously failed downloads. Beside the next batch of needed fetches, it also // returns a flag whether empty blocks were queued requiring processing. -func (q *queue) ReserveBodies(p *peer, count int) (*fetchRequest, bool, error) { +func (q *queue) ReserveBodies(p *peerConnection, count int) (*fetchRequest, bool, error) { isNoop := func(header *types.Header) bool { return header.TxHash == types.EmptyRootHash && header.UncleHash == types.EmptyUncleHash } @@ -610,7 +445,7 @@ func (q *queue) ReserveBodies(p *peer, count int) (*fetchRequest, bool, error) { // ReserveReceipts reserves a set of receipt fetches for the given peer, skipping // any previously failed downloads. Beside the next batch of needed fetches, it // also returns a flag whether empty receipts were queued requiring importing. -func (q *queue) ReserveReceipts(p *peer, count int) (*fetchRequest, bool, error) { +func (q *queue) ReserveReceipts(p *peerConnection, count int) (*fetchRequest, bool, error) { isNoop := func(header *types.Header) bool { return header.ReceiptHash == types.EmptyRootHash } @@ -627,7 +462,7 @@ func (q *queue) ReserveReceipts(p *peer, count int) (*fetchRequest, bool, error) // Note, this method expects the queue lock to be already held for writing. The // reason the lock is not obtained in here is because the parameters already need // to access the queue, so they already need a lock anyway. -func (q *queue) reserveHeaders(p *peer, count int, taskPool map[common.Hash]*types.Header, taskQueue *prque.Prque, +func (q *queue) reserveHeaders(p *peerConnection, count int, taskPool map[common.Hash]*types.Header, taskQueue *prque.Prque, pendPool map[string]*fetchRequest, donePool map[common.Hash]struct{}, isNoop func(*types.Header) bool) (*fetchRequest, bool, error) { // Short circuit if the pool has been depleted, or if the peer's already // downloading something (sanity check not to corrupt state) @@ -722,12 +557,6 @@ func (q *queue) CancelReceipts(request *fetchRequest) { q.cancel(request, q.receiptTaskQueue, q.receiptPendPool) } -// CancelNodeData aborts a node state data fetch request, returning all pending -// hashes to the task queue. -func (q *queue) CancelNodeData(request *fetchRequest) { - q.cancel(request, q.stateTaskQueue, q.statePendPool) -} - // Cancel aborts a fetch request, returning all pending hashes to the task queue. func (q *queue) cancel(request *fetchRequest, taskQueue *prque.Prque, pendPool map[string]*fetchRequest) { q.lock.Lock() @@ -764,12 +593,6 @@ func (q *queue) Revoke(peerId string) { } delete(q.receiptPendPool, peerId) } - if request, ok := q.statePendPool[peerId]; ok { - for hash, index := range request.Hashes { - q.stateTaskQueue.Push(hash, float32(index)) - } - delete(q.statePendPool, peerId) - } } // ExpireHeaders checks for in flight requests that exceeded a timeout allowance, @@ -799,15 +622,6 @@ func (q *queue) ExpireReceipts(timeout time.Duration) map[string]int { return q.expire(timeout, q.receiptPendPool, q.receiptTaskQueue, receiptTimeoutMeter) } -// ExpireNodeData checks for in flight node data requests that exceeded a timeout -// allowance, canceling them and returning the responsible peers for penalisation. -func (q *queue) ExpireNodeData(timeout time.Duration) map[string]int { - q.lock.Lock() - defer q.lock.Unlock() - - return q.expire(timeout, q.statePendPool, q.stateTaskQueue, stateTimeoutMeter) -} - // expire is the generic check that move expired tasks from a pending pool back // into a task pool, returning all entities caught with expired tasks. // @@ -1044,84 +858,6 @@ func (q *queue) deliver(id string, taskPool map[common.Hash]*types.Header, taskQ } } -// DeliverNodeData injects a node state data retrieval response into the queue. -// The method returns the number of node state accepted from the delivery. -func (q *queue) DeliverNodeData(id string, data [][]byte, callback func(int, bool, error)) (int, error) { - q.lock.Lock() - defer q.lock.Unlock() - - // Short circuit if the data was never requested - request := q.statePendPool[id] - if request == nil { - return 0, errNoFetchesPending - } - stateReqTimer.UpdateSince(request.Time) - delete(q.statePendPool, id) - - // If no data was retrieved, mark their hashes as unavailable for the origin peer - if len(data) == 0 { - for hash := range request.Hashes { - request.Peer.MarkLacking(hash) - } - } - // Iterate over the downloaded data and verify each of them - errs := make([]error, 0) - process := []trie.SyncResult{} - for _, blob := range data { - // Skip any state trie entries that were not requested - hash := common.BytesToHash(crypto.Keccak256(blob)) - if _, ok := request.Hashes[hash]; !ok { - errs = append(errs, fmt.Errorf("non-requested state data %x", hash)) - continue - } - // Inject the next state trie item into the processing queue - process = append(process, trie.SyncResult{Hash: hash, Data: blob}) - delete(request.Hashes, hash) - delete(q.stateTaskPool, hash) - } - // Return all failed or missing fetches to the queue - for hash, index := range request.Hashes { - q.stateTaskQueue.Push(hash, float32(index)) - } - if q.stateScheduler == nil { - return 0, errNoFetchesPending - } - - // Run valid nodes through the trie download scheduler. It writes completed nodes to a - // batch, which is committed asynchronously. This may lead to over-fetches because the - // scheduler treats everything as written after Process has returned, but it's - // unlikely to be an issue in practice. - batch := q.stateDatabase.NewBatch() - progressed, nproc, procerr := q.stateScheduler.Process(process, batch) - q.stateWriters += 1 - go func() { - if procerr == nil { - nproc = len(process) - procerr = batch.Write() - } - // Return processing errors through the callback so the sync gets canceled. The - // number of writers is decremented prior to the call so PendingNodeData will - // return zero when the callback runs. - q.lock.Lock() - q.stateWriters -= 1 - q.lock.Unlock() - callback(nproc, progressed, procerr) - // Wake up WaitResults after the state has been written because it might be - // waiting for completion of the pivot block's state download. - q.active.Signal() - }() - - // If none of the data items were good, it's a stale delivery - switch { - case len(errs) == 0: - return len(process), nil - case len(errs) == len(request.Hashes): - return len(process), errStaleDelivery - default: - return len(process), fmt.Errorf("multiple failures: %v", errs) - } -} - // Prepare configures the result cache to allow accepting and caching inbound // fetch results. func (q *queue) Prepare(offset uint64, mode SyncMode, pivot uint64, head *types.Header) { @@ -1134,9 +870,4 @@ func (q *queue) Prepare(offset uint64, mode SyncMode, pivot uint64, head *types. } q.fastSyncPivot = pivot q.mode = mode - - // If long running fast sync, also start up a head stateretrieval immediately - if mode == FastSync && pivot > 0 { - q.stateScheduler = state.NewStateSync(head.Root, q.stateDatabase) - } } diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/statesync.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/statesync.go new file mode 100644 index 000000000..a5ce8c42d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/statesync.go @@ -0,0 +1,449 @@ +// 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 downloader + +import ( + "fmt" + "hash" + "sync" + "sync/atomic" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/crypto/sha3" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/trie" +) + +// stateReq represents a batch of state fetch requests groupped together into +// a single data retrieval network packet. +type stateReq struct { + items []common.Hash // Hashes of the state items to download + tasks map[common.Hash]*stateTask // Download tasks to track previous attempts + timeout time.Duration // Maximum round trip time for this to complete + timer *time.Timer // Timer to fire when the RTT timeout expires + peer *peerConnection // Peer that we're requesting from + response [][]byte // Response data of the peer (nil for timeouts) +} + +// timedOut returns if this request timed out. +func (req *stateReq) timedOut() bool { + return req.response == nil +} + +// stateSyncStats is a collection of progress stats to report during a state trie +// sync to RPC requests as well as to display in user logs. +type stateSyncStats struct { + processed uint64 // Number of state entries processed + duplicate uint64 // Number of state entries downloaded twice + unexpected uint64 // Number of non-requested state entries received + pending uint64 // Number of still pending state entries +} + +// syncState starts downloading state with the given root hash. +func (d *Downloader) syncState(root common.Hash) *stateSync { + s := newStateSync(d, root) + select { + case d.stateSyncStart <- s: + case <-d.quitCh: + s.err = errCancelStateFetch + close(s.done) + } + return s +} + +// stateFetcher manages the active state sync and accepts requests +// on its behalf. +func (d *Downloader) stateFetcher() { + for { + select { + case s := <-d.stateSyncStart: + for next := s; next != nil; { + next = d.runStateSync(next) + } + case <-d.stateCh: + // Ignore state responses while no sync is running. + case <-d.quitCh: + return + } + } +} + +// runStateSync runs a state synchronisation until it completes or another root +// hash is requested to be switched over to. +func (d *Downloader) runStateSync(s *stateSync) *stateSync { + var ( + active = make(map[string]*stateReq) // Currently in-flight requests + finished []*stateReq // Completed or failed requests + timeout = make(chan *stateReq) // Timed out active requests + ) + defer func() { + // Cancel active request timers on exit. Also set peers to idle so they're + // available for the next sync. + for _, req := range active { + req.timer.Stop() + req.peer.SetNodeDataIdle(len(req.items)) + } + }() + // Run the state sync. + go s.run() + defer s.Cancel() + + for { + // Enable sending of the first buffered element if there is one. + var ( + deliverReq *stateReq + deliverReqCh chan *stateReq + ) + if len(finished) > 0 { + deliverReq = finished[0] + deliverReqCh = s.deliver + } + + select { + // The stateSync lifecycle: + case next := <-d.stateSyncStart: + return next + + case <-s.done: + return nil + + // Send the next finished request to the current sync: + case deliverReqCh <- deliverReq: + finished = append(finished[:0], finished[1:]...) + + // Handle incoming state packs: + case pack := <-d.stateCh: + // Discard any data not requested (or previsouly timed out) + req := active[pack.PeerId()] + if req == nil { + log.Debug("Unrequested node data", "peer", pack.PeerId(), "len", pack.Items()) + continue + } + // Finalize the request and queue up for processing + req.timer.Stop() + req.response = pack.(*statePack).states + + finished = append(finished, req) + delete(active, pack.PeerId()) + + // Handle timed-out requests: + case req := <-timeout: + // If the peer is already requesting something else, ignore the stale timeout. + // This can happen when the timeout and the delivery happens simultaneously, + // causing both pathways to trigger. + if active[req.peer.id] != req { + continue + } + // Move the timed out data back into the download queue + finished = append(finished, req) + delete(active, req.peer.id) + + // Track outgoing state requests: + case req := <-d.trackStateReq: + // If an active request already exists for this peer, we have a problem. In + // theory the trie node schedule must never assign two requests to the same + // peer. In practive however, a peer might receive a request, disconnect and + // immediately reconnect before the previous times out. In this case the first + // request is never honored, alas we must not silently overwrite it, as that + // causes valid requests to go missing and sync to get stuck. + if old := active[req.peer.id]; old != nil { + log.Warn("Busy peer assigned new state fetch", "peer", old.peer.id) + + // Make sure the previous one doesn't get siletly lost + finished = append(finished, old) + } + // Start a timer to notify the sync loop if the peer stalled. + req.timer = time.AfterFunc(req.timeout, func() { + select { + case timeout <- req: + case <-s.done: + // Prevent leaking of timer goroutines in the unlikely case where a + // timer is fired just before exiting runStateSync. + } + }) + active[req.peer.id] = req + } + } +} + +// stateSync schedules requests for downloading a particular state trie defined +// by a given state root. +type stateSync struct { + d *Downloader // Downloader instance to access and manage current peerset + + sched *state.StateSync // State trie sync scheduler defining the tasks + keccak hash.Hash // Keccak256 hasher to verify deliveries with + tasks map[common.Hash]*stateTask // Set of tasks currently queued for retrieval + + deliver chan *stateReq // Delivery channel multiplexing peer responses + cancel chan struct{} // Channel to signal a termination request + cancelOnce sync.Once // Ensures cancel only ever gets called once + done chan struct{} // Channel to signal termination completion + err error // Any error hit during sync (set before completion) +} + +// stateTask represents a single trie node download taks, containing a set of +// peers already attempted retrieval from to detect stalled syncs and abort. +type stateTask struct { + attempts map[string]struct{} +} + +// newStateSync creates a new state trie download scheduler. This method does not +// yet start the sync. The user needs to call run to initiate. +func newStateSync(d *Downloader, root common.Hash) *stateSync { + return &stateSync{ + d: d, + sched: state.NewStateSync(root, d.stateDB), + keccak: sha3.NewKeccak256(), + tasks: make(map[common.Hash]*stateTask), + deliver: make(chan *stateReq), + cancel: make(chan struct{}), + done: make(chan struct{}), + } +} + +// run starts the task assignment and response processing loop, blocking until +// it finishes, and finally notifying any goroutines waiting for the loop to +// finish. +func (s *stateSync) run() { + s.err = s.loop() + close(s.done) +} + +// Wait blocks until the sync is done or canceled. +func (s *stateSync) Wait() error { + <-s.done + return s.err +} + +// Cancel cancels the sync and waits until it has shut down. +func (s *stateSync) Cancel() error { + s.cancelOnce.Do(func() { close(s.cancel) }) + return s.Wait() +} + +// loop is the main event loop of a state trie sync. It it responsible for the +// assignment of new tasks to peers (including sending it to them) as well as +// for the processing of inbound data. Note, that the loop does not directly +// receive data from peers, rather those are buffered up in the downloader and +// pushed here async. The reason is to decouple processing from data receipt +// and timeouts. +func (s *stateSync) loop() error { + // Listen for new peer events to assign tasks to them + newPeer := make(chan *peerConnection, 1024) + peerSub := s.d.peers.SubscribeNewPeers(newPeer) + defer peerSub.Unsubscribe() + + // Keep assigning new tasks until the sync completes or aborts + for s.sched.Pending() > 0 { + if err := s.assignTasks(); err != nil { + return err + } + // Tasks assigned, wait for something to happen + select { + case <-newPeer: + // New peer arrived, try to assign it download tasks + + case <-s.cancel: + return errCancelStateFetch + + case req := <-s.deliver: + // Response or timeout triggered, drop the peer if stalling + log.Trace("Received node data response", "peer", req.peer.id, "count", len(req.response), "timeout", req.timedOut()) + if len(req.items) <= 2 && req.timedOut() { + // 2 items are the minimum requested, if even that times out, we've no use of + // this peer at the moment. + log.Warn("Stalling state sync, dropping peer", "peer", req.peer.id) + s.d.dropPeer(req.peer.id) + } + // Process all the received blobs and check for stale delivery + stale, err := s.process(req) + if err != nil { + log.Warn("Node data write error", "err", err) + return err + } + // The the delivery contains requested data, mark the node idle (otherwise it's a timed out delivery) + if !stale { + req.peer.SetNodeDataIdle(len(req.response)) + } + } + } + return nil +} + +// assignTasks attempts to assing new tasks to all idle peers, either from the +// batch currently being retried, or fetching new data from the trie sync itself. +func (s *stateSync) assignTasks() error { + // Iterate over all idle peers and try to assign them state fetches + peers, _ := s.d.peers.NodeDataIdlePeers() + for _, p := range peers { + // Assign a batch of fetches proportional to the estimated latency/bandwidth + cap := p.NodeDataCapacity(s.d.requestRTT()) + req := &stateReq{peer: p, timeout: s.d.requestTTL()} + s.fillTasks(cap, req) + + // If the peer was assigned tasks to fetch, send the network request + if len(req.items) > 0 { + req.peer.log.Trace("Requesting new batch of data", "type", "state", "count", len(req.items)) + + select { + case s.d.trackStateReq <- req: + req.peer.FetchNodeData(req.items) + case <-s.cancel: + } + } + } + return nil +} + +// fillTasks fills the given request object with a maximum of n state download +// tasks to send to the remote peer. +func (s *stateSync) fillTasks(n int, req *stateReq) { + // Refill available tasks from the scheduler. + if len(s.tasks) < n { + new := s.sched.Missing(n - len(s.tasks)) + for _, hash := range new { + s.tasks[hash] = &stateTask{make(map[string]struct{})} + } + } + // Find tasks that haven't been tried with the request's peer. + req.items = make([]common.Hash, 0, n) + req.tasks = make(map[common.Hash]*stateTask, n) + for hash, t := range s.tasks { + // Stop when we've gathered enough requests + if len(req.items) == n { + break + } + // Skip any requests we've already tried from this peer + if _, ok := t.attempts[req.peer.id]; ok { + continue + } + // Assign the request to this peer + t.attempts[req.peer.id] = struct{}{} + req.items = append(req.items, hash) + req.tasks[hash] = t + delete(s.tasks, hash) + } +} + +// process iterates over a batch of delivered state data, injecting each item +// into a running state sync, re-queuing any items that were requested but not +// delivered. +func (s *stateSync) process(req *stateReq) (bool, error) { + // Collect processing stats and update progress if valid data was received + processed, written, duplicate, unexpected := 0, 0, 0, 0 + + defer func(start time.Time) { + if processed+written+duplicate+unexpected > 0 { + s.updateStats(processed, written, duplicate, unexpected, time.Since(start)) + } + }(time.Now()) + + // Iterate over all the delivered data and inject one-by-one into the trie + progress, stale := false, len(req.response) > 0 + + for _, blob := range req.response { + prog, hash, err := s.processNodeData(blob) + switch err { + case nil: + processed++ + case trie.ErrNotRequested: + unexpected++ + case trie.ErrAlreadyProcessed: + duplicate++ + default: + return stale, fmt.Errorf("invalid state node %s: %v", hash.TerminalString(), err) + } + if prog { + progress = true + } + // If the node delivered a requested item, mark the delivery non-stale + if _, ok := req.tasks[hash]; ok { + delete(req.tasks, hash) + stale = false + } + } + // If some data managed to hit the database, flush and reset failure counters + if progress { + // Flush any accumulated data out to disk + batch := s.d.stateDB.NewBatch() + + count, err := s.sched.Commit(batch) + if err != nil { + return stale, err + } + if err := batch.Write(); err != nil { + return stale, err + } + written = count + + // If we're inside the critical section, reset fail counter since we progressed + if atomic.LoadUint32(&s.d.fsPivotFails) > 1 { + log.Trace("Fast-sync progressed, resetting fail counter", "previous", atomic.LoadUint32(&s.d.fsPivotFails)) + atomic.StoreUint32(&s.d.fsPivotFails, 1) // Don't ever reset to 0, as that will unlock the pivot block + } + } + // Put unfulfilled tasks back into the retry queue + npeers := s.d.peers.Len() + + for hash, task := range req.tasks { + // If the node did deliver something, missing items may be due to a protocol + // limit or a previous timeout + delayed delivery. Both cases should permit + // the node to retry the missing items (to avoid single-peer stalls). + if len(req.response) > 0 || req.timedOut() { + delete(task.attempts, req.peer.id) + } + // If we've requested the node too many times already, it may be a malicious + // sync where nobody has the right data. Abort. + if len(task.attempts) >= npeers { + return stale, fmt.Errorf("state node %s failed with all peers (%d tries, %d peers)", hash.TerminalString(), len(task.attempts), npeers) + } + // Missing item, place into the retry queue. + s.tasks[hash] = task + } + return stale, nil +} + +// processNodeData tries to inject a trie node data blob delivered from a remote +// peer into the state trie, returning whether anything useful was written or any +// error occurred. +func (s *stateSync) processNodeData(blob []byte) (bool, common.Hash, error) { + res := trie.SyncResult{Data: blob} + + s.keccak.Reset() + s.keccak.Write(blob) + s.keccak.Sum(res.Hash[:0]) + + committed, _, err := s.sched.Process([]trie.SyncResult{res}) + return committed, res.Hash, err +} + +// updateStats bumps the various state sync progress counters and displays a log +// message for the user to see. +func (s *stateSync) updateStats(processed, written, duplicate, unexpected int, duration time.Duration) { + s.d.syncStatsLock.Lock() + defer s.d.syncStatsLock.Unlock() + + s.d.syncStatsState.pending = uint64(s.sched.Pending()) + s.d.syncStatsState.processed += uint64(processed) + s.d.syncStatsState.duplicate += uint64(duplicate) + s.d.syncStatsState.unexpected += uint64(unexpected) + + log.Info("Imported new state entries", "count", processed, "flushed", written, "elapsed", common.PrettyDuration(duration), "processed", s.d.syncStatsState.processed, "pending", s.d.syncStatsState.pending, "retry", len(s.tasks), "duplicate", s.d.syncStatsState.duplicate, "unexpected", s.d.syncStatsState.unexpected) +} diff --git a/vendor/github.com/ethereum/go-ethereum/eth/downloader/types.go b/vendor/github.com/ethereum/go-ethereum/eth/downloader/types.go index e10510486..3f30ea9dd 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/downloader/types.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/downloader/types.go @@ -18,51 +18,10 @@ package downloader import ( "fmt" - "math/big" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" ) -// headerCheckFn is a callback type for verifying a header's presence in the local chain. -type headerCheckFn func(common.Hash) bool - -// blockAndStateCheckFn is a callback type for verifying block and associated states' presence in the local chain. -type blockAndStateCheckFn func(common.Hash) bool - -// headerRetrievalFn is a callback type for retrieving a header from the local chain. -type headerRetrievalFn func(common.Hash) *types.Header - -// blockRetrievalFn is a callback type for retrieving a block from the local chain. -type blockRetrievalFn func(common.Hash) *types.Block - -// headHeaderRetrievalFn is a callback type for retrieving the head header from the local chain. -type headHeaderRetrievalFn func() *types.Header - -// headBlockRetrievalFn is a callback type for retrieving the head block from the local chain. -type headBlockRetrievalFn func() *types.Block - -// headFastBlockRetrievalFn is a callback type for retrieving the head fast block from the local chain. -type headFastBlockRetrievalFn func() *types.Block - -// headBlockCommitterFn is a callback for directly committing the head block to a certain entity. -type headBlockCommitterFn func(common.Hash) error - -// tdRetrievalFn is a callback type for retrieving the total difficulty of a local block. -type tdRetrievalFn func(common.Hash) *big.Int - -// headerChainInsertFn is a callback type to insert a batch of headers into the local chain. -type headerChainInsertFn func([]*types.Header, int) (int, error) - -// blockChainInsertFn is a callback type to insert a batch of blocks into the local chain. -type blockChainInsertFn func(types.Blocks) (int, error) - -// receiptChainInsertFn is a callback type to insert a batch of receipts into the local chain. -type receiptChainInsertFn func(types.Blocks, []types.Receipts) (int, error) - -// chainRollbackFn is a callback type to remove a few recently added elements from the local chain. -type chainRollbackFn func([]common.Hash) - // peerDropFn is a callback type for dropping a peer detected as malicious. type peerDropFn func(id string) diff --git a/vendor/github.com/ethereum/go-ethereum/eth/gen_config.go b/vendor/github.com/ethereum/go-ethereum/eth/gen_config.go index 955facf8f..477479419 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/gen_config.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/gen_config.go @@ -33,6 +33,7 @@ func (c Config) MarshalTOML() (interface{}, error) { EthashDatasetDir string EthashDatasetsInMem int EthashDatasetsOnDisk int + TxPool core.TxPoolConfig GPO gasprice.Config EnablePreimageRecording bool DocRoot string `toml:"-"` @@ -60,6 +61,7 @@ func (c Config) MarshalTOML() (interface{}, error) { enc.EthashDatasetDir = c.EthashDatasetDir enc.EthashDatasetsInMem = c.EthashDatasetsInMem enc.EthashDatasetsOnDisk = c.EthashDatasetsOnDisk + enc.TxPool = c.TxPool enc.GPO = c.GPO enc.EnablePreimageRecording = c.EnablePreimageRecording enc.DocRoot = c.DocRoot @@ -90,6 +92,7 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { EthashDatasetDir *string EthashDatasetsInMem *int EthashDatasetsOnDisk *int + TxPool *core.TxPoolConfig GPO *gasprice.Config EnablePreimageRecording *bool DocRoot *string `toml:"-"` @@ -158,6 +161,9 @@ func (c *Config) UnmarshalTOML(unmarshal func(interface{}) error) error { if dec.EthashDatasetsOnDisk != nil { c.EthashDatasetsOnDisk = *dec.EthashDatasetsOnDisk } + if dec.TxPool != nil { + c.TxPool = *dec.TxPool + } if dec.GPO != nil { c.GPO = *dec.GPO } diff --git a/vendor/github.com/ethereum/go-ethereum/eth/handler.go b/vendor/github.com/ethereum/go-ethereum/eth/handler.go index 16e371227..6c6449340 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/handler.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/handler.go @@ -87,8 +87,6 @@ type ProtocolManager struct { quitSync chan struct{} noMorePeers chan struct{} - lesServer LesServer - // wait group is used for graceful shutdowns during downloading // and processing wg sync.WaitGroup @@ -159,10 +157,7 @@ func NewProtocolManager(config *params.ChainConfig, mode downloader.SyncMode, ne return nil, errIncompatibleConfig } // Construct the different synchronisation mechanisms - manager.downloader = downloader.New(mode, chaindb, manager.eventMux, blockchain.HasHeader, blockchain.HasBlockAndState, blockchain.GetHeaderByHash, - blockchain.GetBlockByHash, blockchain.CurrentHeader, blockchain.CurrentBlock, blockchain.CurrentFastBlock, blockchain.FastSyncCommitHead, - blockchain.GetTdByHash, blockchain.InsertHeaderChain, manager.blockchain.InsertChain, blockchain.InsertReceiptChain, blockchain.Rollback, - manager.removePeer) + manager.downloader = downloader.New(mode, chaindb, manager.eventMux, blockchain, nil, manager.removePeer) validator := func(header *types.Header) error { return engine.VerifyHeader(blockchain, header, true) @@ -171,6 +166,11 @@ func NewProtocolManager(config *params.ChainConfig, mode downloader.SyncMode, ne return blockchain.CurrentBlock().NumberU64() } inserter := func(blocks types.Blocks) (int, error) { + // If fast sync is running, deny importing weird blocks + if atomic.LoadUint32(&manager.fastSync) == 1 { + log.Warn("Discarded bad propagated block", "number", blocks[0].Number(), "hash", blocks[0].Hash()) + return 0, nil + } atomic.StoreUint32(&manager.acceptTxs, 1) // Mark initial sync done on any fetcher import return manager.blockchain.InsertChain(blocks) } @@ -265,7 +265,7 @@ func (pm *ProtocolManager) handle(p *peer) error { defer pm.removePeer(p.id) // Register the peer in the downloader. If the downloader considers it banned, we disconnect - if err := pm.downloader.RegisterPeer(p.id, p.version, p.Head, p.RequestHeadersByHash, p.RequestHeadersByNumber, p.RequestBodies, p.RequestReceipts, p.RequestNodeData); err != nil { + if err := pm.downloader.RegisterPeer(p.id, p.version, p); err != nil { return err } // Propagate existing transactions. new transactions appearing @@ -658,7 +658,7 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { } p.MarkTransaction(tx.Hash()) } - pm.txpool.AddBatch(txs) + pm.txpool.AddRemotes(txs) default: return errResp(ErrInvalidMsgCode, "%v", msg.Code) diff --git a/vendor/github.com/ethereum/go-ethereum/eth/protocol.go b/vendor/github.com/ethereum/go-ethereum/eth/protocol.go index 4bc8bee72..376e4663e 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/protocol.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/protocol.go @@ -94,8 +94,8 @@ var errorToString = map[int]string{ } type txPool interface { - // AddBatch should add the given transactions to the pool. - AddBatch([]*types.Transaction) error + // AddRemotes should add the given transactions to the pool. + AddRemotes([]*types.Transaction) error // Pending should return pending transactions. // The slice should be modifiable by the caller. diff --git a/vendor/github.com/ethereum/go-ethereum/eth/sync.go b/vendor/github.com/ethereum/go-ethereum/eth/sync.go index b0653acf9..8784b225d 100644 --- a/vendor/github.com/ethereum/go-ethereum/eth/sync.go +++ b/vendor/github.com/ethereum/go-ethereum/eth/sync.go @@ -183,6 +183,7 @@ func (pm *ProtocolManager) synchronise(peer *peer) { // The only scenario where this can happen is if the user manually (or via a // bad block) rolled back a fast sync node below the sync point. In this case // however it's safe to reenable fast sync. + atomic.StoreUint32(&pm.fastSync, 1) mode = downloader.FastSync } if err := pm.downloader.Synchronise(peer.id, pHead, pTd, mode); err != nil { diff --git a/vendor/github.com/ethereum/go-ethereum/ethclient/ethclient.go b/vendor/github.com/ethereum/go-ethereum/ethclient/ethclient.go index 59f60d659..45bb87322 100644 --- a/vendor/github.com/ethereum/go-ethereum/ethclient/ethclient.go +++ b/vendor/github.com/ethereum/go-ethereum/ethclient/ethclient.go @@ -167,11 +167,11 @@ func (ec *Client) TransactionByHash(ctx context.Context, hash common.Hash) (tx * } else if _, r, _ := tx.RawSignatureValues(); r == nil { return nil, false, fmt.Errorf("server returned transaction without signature") } - var block struct{ BlockHash *common.Hash } + var block struct{ BlockNumber *string } if err := json.Unmarshal(raw, &block); err != nil { return nil, false, err } - return tx, block.BlockHash == nil, nil + return tx, block.BlockNumber == nil, nil } // TransactionCount returns the total number of transactions in the given block. diff --git a/vendor/github.com/ethereum/go-ethereum/ethdb/.gitignore b/vendor/github.com/ethereum/go-ethereum/ethdb/.gitignore new file mode 100644 index 000000000..f725d58d1 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/ethdb/.gitignore @@ -0,0 +1,12 @@ +# See http://help.github.com/ignore-files/ for more about ignoring files. +# +# If you find yourself ignoring temporary files generated by your text editor +# or operating system, you probably want to add a global ignore instead: +# git config --global core.excludesfile ~/.gitignore_global + +/tmp +*/**/*un~ +*un~ +.DS_Store +*/**/.DS_Store + diff --git a/vendor/github.com/ethereum/go-ethereum/ethdb/memory_database.go b/vendor/github.com/ethereum/go-ethereum/ethdb/memory_database.go index 65c487934..a2ee2f2cc 100644 --- a/vendor/github.com/ethereum/go-ethereum/ethdb/memory_database.go +++ b/vendor/github.com/ethereum/go-ethereum/ethdb/memory_database.go @@ -45,13 +45,6 @@ func (db *MemDatabase) Put(key []byte, value []byte) error { return nil } -func (db *MemDatabase) Set(key []byte, value []byte) { - db.lock.Lock() - defer db.lock.Unlock() - - db.Put(key, value) -} - func (db *MemDatabase) Get(key []byte) ([]byte, error) { db.lock.RLock() defer db.lock.RUnlock() diff --git a/vendor/github.com/ethereum/go-ethereum/ethstats/ethstats.go b/vendor/github.com/ethereum/go-ethereum/ethstats/ethstats.go index 8765da8fa..333c975c9 100644 --- a/vendor/github.com/ethereum/go-ethereum/ethstats/ethstats.go +++ b/vendor/github.com/ethereum/go-ethereum/ethstats/ethstats.go @@ -18,6 +18,7 @@ package ethstats import ( + "context" "encoding/json" "errors" "fmt" @@ -30,6 +31,7 @@ import ( "time" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/mclock" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core/types" @@ -118,7 +120,7 @@ func (s *Service) Stop() error { // loop keeps trying to connect to the netstats server, reporting chain events // until termination. func (s *Service) loop() { - // Subscribe tso chain events to execute updates on + // Subscribe to chain events to execute updates on var emux *event.TypeMux if s.eth != nil { emux = s.eth.EventMux() @@ -131,6 +133,46 @@ func (s *Service) loop() { txSub := emux.Subscribe(core.TxPreEvent{}) defer txSub.Unsubscribe() + // Start a goroutine that exhausts the subsciptions to avoid events piling up + var ( + quitCh = make(chan struct{}) + headCh = make(chan *types.Block, 1) + txCh = make(chan struct{}, 1) + ) + go func() { + var lastTx mclock.AbsTime + + for { + select { + // Notify of chain head events, but drop if too frequent + case head, ok := <-headSub.Chan(): + if !ok { // node stopped + close(quitCh) + return + } + select { + case headCh <- head.Data.(core.ChainHeadEvent).Block: + default: + } + + // Notify of new transaction events, but drop if too frequent + case _, ok := <-txSub.Chan(): + if !ok { // node stopped + close(quitCh) + return + } + if time.Duration(mclock.Now()-lastTx) < time.Second { + continue + } + lastTx = mclock.Now() + + select { + case txCh <- struct{}{}: + default: + } + } + } + }() // Loop reporting until termination for { // Resolve the URL, defaulting to TLS, but falling back to none too @@ -150,7 +192,7 @@ func (s *Service) loop() { if conf, err = websocket.NewConfig(url, "http://localhost/"); err != nil { continue } - conf.Dialer = &net.Dialer{Timeout: 3 * time.Second} + conf.Dialer = &net.Dialer{Timeout: 5 * time.Second} if conn, err = websocket.DialConfig(conf); err == nil { break } @@ -180,6 +222,10 @@ func (s *Service) loop() { for err == nil { select { + case <-quitCh: + conn.Close() + return + case <-fullReport.C: if err = s.report(conn); err != nil { log.Warn("Full stats report failed", "err", err) @@ -188,30 +234,14 @@ func (s *Service) loop() { if err = s.reportHistory(conn, list); err != nil { log.Warn("Requested history report failed", "err", err) } - case head, ok := <-headSub.Chan(): - if !ok { // node stopped - conn.Close() - return - } - if err = s.reportBlock(conn, head.Data.(core.ChainHeadEvent).Block); err != nil { + case head := <-headCh: + if err = s.reportBlock(conn, head); err != nil { log.Warn("Block stats report failed", "err", err) } if err = s.reportPending(conn); err != nil { log.Warn("Post-block transaction stats report failed", "err", err) } - case _, ok := <-txSub.Chan(): - if !ok { // node stopped - conn.Close() - return - } - // Exhaust events to avoid reporting too frequently - for exhausted := false; !exhausted; { - select { - case <-headSub.Chan(): - default: - exhausted = true - } - } + case <-txCh: if err = s.reportPending(conn); err != nil { log.Warn("Transaction stats report failed", "err", err) } @@ -397,7 +427,7 @@ func (s *Service) reportLatency(conn *websocket.Conn) error { select { case <-s.pongCh: // Pong delivered, report the latency - case <-time.After(3 * time.Second): + case <-time.After(5 * time.Second): // Ping timeout, abort return errors.New("ping timed out") } @@ -426,21 +456,15 @@ type blockStats struct { GasLimit *big.Int `json:"gasLimit"` Diff string `json:"difficulty"` TotalDiff string `json:"totalDifficulty"` - Txs txStats `json:"transactions"` + Txs []txStats `json:"transactions"` TxHash common.Hash `json:"transactionsRoot"` Root common.Hash `json:"stateRoot"` Uncles uncleStats `json:"uncles"` } -// txStats is a custom wrapper around a transaction array to force serializing -// empty arrays instead of returning null for them. -type txStats []*types.Transaction - -func (s txStats) MarshalJSON() ([]byte, error) { - if txs := ([]*types.Transaction)(s); len(txs) > 0 { - return json.Marshal(txs) - } - return []byte("[]"), nil +// txStats is the information to report about individual transactions. +type txStats struct { + Hash common.Hash `json:"hash"` } // uncleStats is a custom wrapper around an uncle array to force serializing @@ -479,7 +503,7 @@ func (s *Service) assembleBlockStats(block *types.Block) *blockStats { var ( header *types.Header td *big.Int - txs []*types.Transaction + txs []txStats uncles []*types.Header ) if s.eth != nil { @@ -490,7 +514,10 @@ func (s *Service) assembleBlockStats(block *types.Block) *blockStats { header = block.Header() td = s.eth.BlockChain().GetTd(header.Hash(), header.Number.Uint64()) - txs = block.Transactions() + txs = make([]txStats, len(block.Transactions())) + for i, tx := range block.Transactions() { + txs[i].Hash = tx.Hash() + } uncles = block.Uncles() } else { // Light nodes would need on-demand lookups for transactions/uncles, skip @@ -500,6 +527,7 @@ func (s *Service) assembleBlockStats(block *types.Block) *blockStats { header = s.les.BlockChain().CurrentHeader() } td = s.les.BlockChain().GetTd(header.Hash(), header.Number.Uint64()) + txs = []txStats{} } // Assemble and return the block stats author, _ := s.engine.Author(header) @@ -639,7 +667,8 @@ func (s *Service) reportStats(conn *websocket.Conn) error { sync := s.eth.Downloader().Progress() syncing = s.eth.BlockChain().CurrentHeader().Number.Uint64() >= sync.HighestBlock - gasprice = int(s.eth.Miner().GasPrice().Uint64()) + price, _ := s.eth.ApiBackend.SuggestPrice(context.Background()) + gasprice = int(price.Uint64()) } else { sync := s.les.Downloader().Progress() syncing = s.les.BlockChain().CurrentHeader().Number.Uint64() >= sync.HighestBlock diff --git a/vendor/github.com/ethereum/go-ethereum/internal/build/archive.go b/vendor/github.com/ethereum/go-ethereum/internal/build/archive.go new file mode 100644 index 000000000..ac680ba63 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/build/archive.go @@ -0,0 +1,185 @@ +// 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 build + +import ( + "archive/tar" + "archive/zip" + "compress/gzip" + "fmt" + "io" + "os" + "path/filepath" + "strings" +) + +type Archive interface { + // Directory adds a new directory entry to the archive and sets the + // directory for subsequent calls to Header. + Directory(name string) error + + // Header adds a new file to the archive. The file is added to the directory + // set by Directory. The content of the file must be written to the returned + // writer. + Header(os.FileInfo) (io.Writer, error) + + // Close flushes the archive and closes the underlying file. + Close() error +} + +func NewArchive(file *os.File) (Archive, string) { + switch { + case strings.HasSuffix(file.Name(), ".zip"): + return NewZipArchive(file), strings.TrimSuffix(file.Name(), ".zip") + case strings.HasSuffix(file.Name(), ".tar.gz"): + return NewTarballArchive(file), strings.TrimSuffix(file.Name(), ".tar.gz") + default: + return nil, "" + } +} + +// AddFile appends an existing file to an archive. +func AddFile(a Archive, file string) error { + fd, err := os.Open(file) + if err != nil { + return err + } + defer fd.Close() + fi, err := fd.Stat() + if err != nil { + return err + } + w, err := a.Header(fi) + if err != nil { + return err + } + if _, err := io.Copy(w, fd); err != nil { + return err + } + return nil +} + +// WriteArchive creates an archive containing the given files. +func WriteArchive(name string, files []string) (err error) { + archfd, err := os.Create(name) + if err != nil { + return err + } + + defer func() { + archfd.Close() + // Remove the half-written archive on failure. + if err != nil { + os.Remove(name) + } + }() + archive, basename := NewArchive(archfd) + if archive == nil { + return fmt.Errorf("unknown archive extension") + } + fmt.Println(name) + if err := archive.Directory(basename); err != nil { + return err + } + for _, file := range files { + fmt.Println(" +", filepath.Base(file)) + if err := AddFile(archive, file); err != nil { + return err + } + } + return archive.Close() +} + +type ZipArchive struct { + dir string + zipw *zip.Writer + file io.Closer +} + +func NewZipArchive(w io.WriteCloser) Archive { + return &ZipArchive{"", zip.NewWriter(w), w} +} + +func (a *ZipArchive) Directory(name string) error { + a.dir = name + "/" + return nil +} + +func (a *ZipArchive) Header(fi os.FileInfo) (io.Writer, error) { + head, err := zip.FileInfoHeader(fi) + if err != nil { + return nil, fmt.Errorf("can't make zip header: %v", err) + } + head.Name = a.dir + head.Name + head.Method = zip.Deflate + w, err := a.zipw.CreateHeader(head) + if err != nil { + return nil, fmt.Errorf("can't add zip header: %v", err) + } + return w, nil +} + +func (a *ZipArchive) Close() error { + if err := a.zipw.Close(); err != nil { + return err + } + return a.file.Close() +} + +type TarballArchive struct { + dir string + tarw *tar.Writer + gzw *gzip.Writer + file io.Closer +} + +func NewTarballArchive(w io.WriteCloser) Archive { + gzw := gzip.NewWriter(w) + tarw := tar.NewWriter(gzw) + return &TarballArchive{"", tarw, gzw, w} +} + +func (a *TarballArchive) Directory(name string) error { + a.dir = name + "/" + return a.tarw.WriteHeader(&tar.Header{ + Name: a.dir, + Mode: 0755, + Typeflag: tar.TypeDir, + }) +} + +func (a *TarballArchive) Header(fi os.FileInfo) (io.Writer, error) { + head, err := tar.FileInfoHeader(fi, "") + if err != nil { + return nil, fmt.Errorf("can't make tar header: %v", err) + } + head.Name = a.dir + head.Name + if err := a.tarw.WriteHeader(head); err != nil { + return nil, fmt.Errorf("can't add tar header: %v", err) + } + return a.tarw, nil +} + +func (a *TarballArchive) Close() error { + if err := a.tarw.Close(); err != nil { + return err + } + if err := a.gzw.Close(); err != nil { + return err + } + return a.file.Close() +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/build/azure.go b/vendor/github.com/ethereum/go-ethereum/internal/build/azure.go new file mode 100644 index 000000000..2081a9a0b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/build/azure.go @@ -0,0 +1,111 @@ +// 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 build + +import ( + "fmt" + "os" + + storage "github.com/Azure/azure-storage-go" +) + +// AzureBlobstoreConfig is an authentication and configuration struct containing +// the data needed by the Azure SDK to interact with a speicifc container in the +// blobstore. +type AzureBlobstoreConfig struct { + Account string // Account name to authorize API requests with + Token string // Access token for the above account + Container string // Blob container to upload files into +} + +// AzureBlobstoreUpload uploads a local file to the Azure Blob Storage. Note, this +// method assumes a max file size of 64MB (Azure limitation). Larger files will +// need a multi API call approach implemented. +// +// See: https://msdn.microsoft.com/en-us/library/azure/dd179451.aspx#Anchor_3 +func AzureBlobstoreUpload(path string, name string, config AzureBlobstoreConfig) error { + if *DryRunFlag { + fmt.Printf("would upload %q to %s/%s/%s\n", path, config.Account, config.Container, name) + return nil + } + // Create an authenticated client against the Azure cloud + rawClient, err := storage.NewBasicClient(config.Account, config.Token) + if err != nil { + return err + } + client := rawClient.GetBlobService() + + // Stream the file to upload into the designated blobstore container + in, err := os.Open(path) + if err != nil { + return err + } + defer in.Close() + + info, err := in.Stat() + if err != nil { + return err + } + return client.CreateBlockBlobFromReader(config.Container, name, uint64(info.Size()), in, nil) +} + +// AzureBlobstoreList lists all the files contained within an azure blobstore. +func AzureBlobstoreList(config AzureBlobstoreConfig) ([]storage.Blob, error) { + // Create an authenticated client against the Azure cloud + rawClient, err := storage.NewBasicClient(config.Account, config.Token) + if err != nil { + return nil, err + } + client := rawClient.GetBlobService() + + // List all the blobs from the container and return them + container := client.GetContainerReference(config.Container) + + blobs, err := container.ListBlobs(storage.ListBlobsParameters{ + MaxResults: 1024 * 1024 * 1024, // Yes, fetch all of them + Timeout: 3600, // Yes, wait for all of them + }) + if err != nil { + return nil, err + } + return blobs.Blobs, nil +} + +// AzureBlobstoreDelete iterates over a list of files to delete and removes them +// from the blobstore. +func AzureBlobstoreDelete(config AzureBlobstoreConfig, blobs []storage.Blob) error { + if *DryRunFlag { + for _, blob := range blobs { + fmt.Printf("would delete %s (%s) from %s/%s\n", blob.Name, blob.Properties.LastModified, config.Account, config.Container) + } + return nil + } + // Create an authenticated client against the Azure cloud + rawClient, err := storage.NewBasicClient(config.Account, config.Token) + if err != nil { + return err + } + client := rawClient.GetBlobService() + + // Iterate over the blobs and delete them + for _, blob := range blobs { + if err := client.DeleteBlob(config.Container, blob.Name, nil); err != nil { + return err + } + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/build/env.go b/vendor/github.com/ethereum/go-ethereum/internal/build/env.go new file mode 100644 index 000000000..c47681ebe --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/build/env.go @@ -0,0 +1,129 @@ +// 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 build + +import ( + "flag" + "fmt" + "os" + "strings" +) + +var ( + // These flags override values in build env. + GitCommitFlag = flag.String("git-commit", "", `Overrides git commit hash embedded into executables`) + GitBranchFlag = flag.String("git-branch", "", `Overrides git branch being built`) + GitTagFlag = flag.String("git-tag", "", `Overrides git tag being built`) + BuildnumFlag = flag.String("buildnum", "", `Overrides CI build number`) + PullRequestFlag = flag.Bool("pull-request", false, `Overrides pull request status of the build`) + CronJobFlag = flag.Bool("cron-job", false, `Overrides cron job status of the build`) +) + +// Environment contains metadata provided by the build environment. +type Environment struct { + Name string // name of the environment + Repo string // name of GitHub repo + Commit, Branch, Tag string // Git info + Buildnum string + IsPullRequest bool + IsCronJob bool +} + +func (env Environment) String() string { + return fmt.Sprintf("%s env (commit:%s branch:%s tag:%s buildnum:%s pr:%t)", + env.Name, env.Commit, env.Branch, env.Tag, env.Buildnum, env.IsPullRequest) +} + +// Env returns metadata about the current CI environment, falling back to LocalEnv +// if not running on CI. +func Env() Environment { + switch { + case os.Getenv("CI") == "true" && os.Getenv("TRAVIS") == "true": + return Environment{ + Name: "travis", + Repo: os.Getenv("TRAVIS_REPO_SLUG"), + Commit: os.Getenv("TRAVIS_COMMIT"), + Branch: os.Getenv("TRAVIS_BRANCH"), + Tag: os.Getenv("TRAVIS_TAG"), + Buildnum: os.Getenv("TRAVIS_BUILD_NUMBER"), + IsPullRequest: os.Getenv("TRAVIS_PULL_REQUEST") != "false", + IsCronJob: os.Getenv("TRAVIS_EVENT_TYPE") == "cron", + } + case os.Getenv("CI") == "True" && os.Getenv("APPVEYOR") == "True": + return Environment{ + Name: "appveyor", + Repo: os.Getenv("APPVEYOR_REPO_NAME"), + Commit: os.Getenv("APPVEYOR_REPO_COMMIT"), + Branch: os.Getenv("APPVEYOR_REPO_BRANCH"), + Tag: os.Getenv("APPVEYOR_REPO_TAG_NAME"), + Buildnum: os.Getenv("APPVEYOR_BUILD_NUMBER"), + IsPullRequest: os.Getenv("APPVEYOR_PULL_REQUEST_NUMBER") != "", + IsCronJob: os.Getenv("APPVEYOR_SCHEDULED_BUILD") == "True", + } + default: + return LocalEnv() + } +} + +// LocalEnv returns build environment metadata gathered from git. +func LocalEnv() Environment { + env := applyEnvFlags(Environment{Name: "local", Repo: "ethereum/go-ethereum"}) + if _, err := os.Stat(".git"); err != nil { + return env + } + if env.Commit == "" { + env.Commit = RunGit("rev-parse", "HEAD") + } + if env.Branch == "" { + if b := RunGit("rev-parse", "--abbrev-ref", "HEAD"); b != "HEAD" { + env.Branch = b + } + } + if env.Tag == "" { + env.Tag = firstLine(RunGit("tag", "-l", "--points-at", "HEAD")) + } + return env +} + +func firstLine(s string) string { + return strings.Split(s, "\n")[0] +} + +func applyEnvFlags(env Environment) Environment { + if !flag.Parsed() { + panic("you need to call flag.Parse before Env or LocalEnv") + } + if *GitCommitFlag != "" { + env.Commit = *GitCommitFlag + } + if *GitBranchFlag != "" { + env.Branch = *GitBranchFlag + } + if *GitTagFlag != "" { + env.Tag = *GitTagFlag + } + if *BuildnumFlag != "" { + env.Buildnum = *BuildnumFlag + } + if *PullRequestFlag { + env.IsPullRequest = true + } + if *CronJobFlag { + env.IsCronJob = true + } + return env +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/build/pgp.go b/vendor/github.com/ethereum/go-ethereum/internal/build/pgp.go new file mode 100644 index 000000000..79ab9c06f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/build/pgp.go @@ -0,0 +1,59 @@ +// 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 . + +// signFile reads the contents of an input file and signs it (in armored format) +// with the key provided, placing the signature into the output file. + +package build + +import ( + "bytes" + "fmt" + "os" + + "golang.org/x/crypto/openpgp" +) + +// PGPSignFile parses a PGP private key from the specified string and creates a +// signature file into the output parameter of the input file. +// +// Note, this method assumes a single key will be container in the pgpkey arg, +// furthermore that it is in armored format. +func PGPSignFile(input string, output string, pgpkey string) error { + // Parse the keyring and make sure we only have a single private key in it + keys, err := openpgp.ReadArmoredKeyRing(bytes.NewBufferString(pgpkey)) + if err != nil { + return err + } + if len(keys) != 1 { + return fmt.Errorf("key count mismatch: have %d, want %d", len(keys), 1) + } + // Create the input and output streams for signing + in, err := os.Open(input) + if err != nil { + return err + } + defer in.Close() + + out, err := os.Create(output) + if err != nil { + return err + } + defer out.Close() + + // Generate the signature and return + return openpgp.ArmoredDetachSign(out, keys[0], in, nil) +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/build/util.go b/vendor/github.com/ethereum/go-ethereum/internal/build/util.go new file mode 100644 index 000000000..44f6760b9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/build/util.go @@ -0,0 +1,166 @@ +// 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 build + +import ( + "bytes" + "flag" + "fmt" + "io" + "io/ioutil" + "log" + "os" + "os/exec" + "path/filepath" + "runtime" + "strings" + "text/template" +) + +var DryRunFlag = flag.Bool("n", false, "dry run, don't execute commands") + +// MustRun executes the given command and exits the host process for +// any error. +func MustRun(cmd *exec.Cmd) { + fmt.Println(">>>", strings.Join(cmd.Args, " ")) + if !*DryRunFlag { + cmd.Stderr = os.Stderr + cmd.Stdout = os.Stdout + if err := cmd.Run(); err != nil { + log.Fatal(err) + } + } +} + +func MustRunCommand(cmd string, args ...string) { + MustRun(exec.Command(cmd, args...)) +} + +// GOPATH returns the value that the GOPATH environment +// variable should be set to. +func GOPATH() string { + if os.Getenv("GOPATH") == "" { + log.Fatal("GOPATH is not set") + } + return os.Getenv("GOPATH") +} + +// VERSION returns the content of the VERSION file. +func VERSION() string { + version, err := ioutil.ReadFile("VERSION") + if err != nil { + log.Fatal(err) + } + return string(bytes.TrimSpace(version)) +} + +var warnedAboutGit bool + +// RunGit runs a git subcommand and returns its output. +// The command must complete successfully. +func RunGit(args ...string) string { + cmd := exec.Command("git", args...) + var stdout, stderr bytes.Buffer + cmd.Stdout, cmd.Stderr = &stdout, &stderr + if err := cmd.Run(); err == exec.ErrNotFound { + if !warnedAboutGit { + log.Println("Warning: can't find 'git' in PATH") + warnedAboutGit = true + } + return "" + } else if err != nil { + log.Fatal(strings.Join(cmd.Args, " "), ": ", err, "\n", stderr.String()) + } + return strings.TrimSpace(stdout.String()) +} + +// Render renders the given template file into outputFile. +func Render(templateFile, outputFile string, outputPerm os.FileMode, x interface{}) { + tpl := template.Must(template.ParseFiles(templateFile)) + render(tpl, outputFile, outputPerm, x) +} + +// RenderString renders the given template string into outputFile. +func RenderString(templateContent, outputFile string, outputPerm os.FileMode, x interface{}) { + tpl := template.Must(template.New("").Parse(templateContent)) + render(tpl, outputFile, outputPerm, x) +} + +func render(tpl *template.Template, outputFile string, outputPerm os.FileMode, x interface{}) { + if err := os.MkdirAll(filepath.Dir(outputFile), 0755); err != nil { + log.Fatal(err) + } + out, err := os.OpenFile(outputFile, os.O_CREATE|os.O_WRONLY|os.O_EXCL, outputPerm) + if err != nil { + log.Fatal(err) + } + if err := tpl.Execute(out, x); err != nil { + log.Fatal(err) + } + if err := out.Close(); err != nil { + log.Fatal(err) + } +} + +// CopyFile copies a file. +func CopyFile(dst, src string, mode os.FileMode) { + if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil { + log.Fatal(err) + } + destFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, mode) + if err != nil { + log.Fatal(err) + } + defer destFile.Close() + + srcFile, err := os.Open(src) + if err != nil { + log.Fatal(err) + } + defer srcFile.Close() + + if _, err := io.Copy(destFile, srcFile); err != nil { + log.Fatal(err) + } +} + +// ExpandPackagesNoVendor expands a cmd/go import path pattern, skipping +// vendored packages. +func ExpandPackagesNoVendor(patterns []string) []string { + expand := false + for _, pkg := range patterns { + if strings.Contains(pkg, "...") { + expand = true + } + } + if expand { + args := append([]string{"list"}, patterns...) + cmd := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), args...) + out, err := cmd.CombinedOutput() + if err != nil { + log.Fatalf("package listing failed: %v\n%s", err, string(out)) + } + var packages []string + for _, line := range strings.Split(string(out), "\n") { + if !strings.Contains(line, "/vendor/") { + packages = append(packages, strings.TrimSpace(line)) + } + } + return packages + } + return patterns +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/cmdtest/test_cmd.go b/vendor/github.com/ethereum/go-ethereum/internal/cmdtest/test_cmd.go new file mode 100644 index 000000000..541e51c4c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/cmdtest/test_cmd.go @@ -0,0 +1,270 @@ +// Copyright 2016 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 cmdtest + +import ( + "bufio" + "bytes" + "fmt" + "io" + "io/ioutil" + "os" + "os/exec" + "regexp" + "sync" + "testing" + "text/template" + "time" + + "github.com/docker/docker/pkg/reexec" +) + +func NewTestCmd(t *testing.T, data interface{}) *TestCmd { + return &TestCmd{T: t, Data: data} +} + +type TestCmd struct { + // For total convenience, all testing methods are available. + *testing.T + + Func template.FuncMap + Data interface{} + Cleanup func() + + cmd *exec.Cmd + stdout *bufio.Reader + stdin io.WriteCloser + stderr *testlogger +} + +// Run exec's the current binary using name as argv[0] which will trigger the +// reexec init function for that name (e.g. "geth-test" in cmd/geth/run_test.go) +func (tt *TestCmd) Run(name string, args ...string) { + tt.stderr = &testlogger{t: tt.T} + tt.cmd = &exec.Cmd{ + Path: reexec.Self(), + Args: append([]string{name}, args...), + Stderr: tt.stderr, + } + stdout, err := tt.cmd.StdoutPipe() + if err != nil { + tt.Fatal(err) + } + tt.stdout = bufio.NewReader(stdout) + if tt.stdin, err = tt.cmd.StdinPipe(); err != nil { + tt.Fatal(err) + } + if err := tt.cmd.Start(); err != nil { + tt.Fatal(err) + } +} + +// InputLine writes the given text to the childs stdin. +// This method can also be called from an expect template, e.g.: +// +// geth.expect(`Passphrase: {{.InputLine "password"}}`) +func (tt *TestCmd) InputLine(s string) string { + io.WriteString(tt.stdin, s+"\n") + return "" +} + +func (tt *TestCmd) SetTemplateFunc(name string, fn interface{}) { + if tt.Func == nil { + tt.Func = make(map[string]interface{}) + } + tt.Func[name] = fn +} + +// Expect runs its argument as a template, then expects the +// child process to output the result of the template within 5s. +// +// If the template starts with a newline, the newline is removed +// before matching. +func (tt *TestCmd) Expect(tplsource string) { + // Generate the expected output by running the template. + tpl := template.Must(template.New("").Funcs(tt.Func).Parse(tplsource)) + wantbuf := new(bytes.Buffer) + if err := tpl.Execute(wantbuf, tt.Data); err != nil { + panic(err) + } + // Trim exactly one newline at the beginning. This makes tests look + // much nicer because all expect strings are at column 0. + want := bytes.TrimPrefix(wantbuf.Bytes(), []byte("\n")) + if err := tt.matchExactOutput(want); err != nil { + tt.Fatal(err) + } + tt.Logf("Matched stdout text:\n%s", want) +} + +func (tt *TestCmd) matchExactOutput(want []byte) error { + buf := make([]byte, len(want)) + n := 0 + tt.withKillTimeout(func() { n, _ = io.ReadFull(tt.stdout, buf) }) + buf = buf[:n] + if n < len(want) || !bytes.Equal(buf, want) { + // Grab any additional buffered output in case of mismatch + // because it might help with debugging. + buf = append(buf, make([]byte, tt.stdout.Buffered())...) + tt.stdout.Read(buf[n:]) + // Find the mismatch position. + for i := 0; i < n; i++ { + if want[i] != buf[i] { + return fmt.Errorf("Output mismatch at ◊:\n---------------- (stdout text)\n%s◊%s\n---------------- (expected text)\n%s", + buf[:i], buf[i:n], want) + } + } + if n < len(want) { + return fmt.Errorf("Not enough output, got until ◊:\n---------------- (stdout text)\n%s\n---------------- (expected text)\n%s◊%s", + buf, want[:n], want[n:]) + } + } + return nil +} + +// ExpectRegexp expects the child process to output text matching the +// given regular expression within 5s. +// +// Note that an arbitrary amount of output may be consumed by the +// regular expression. This usually means that expect cannot be used +// after ExpectRegexp. +func (tt *TestCmd) ExpectRegexp(resource string) (*regexp.Regexp, []string) { + var ( + re = regexp.MustCompile(resource) + rtee = &runeTee{in: tt.stdout} + matches []int + ) + tt.withKillTimeout(func() { matches = re.FindReaderSubmatchIndex(rtee) }) + output := rtee.buf.Bytes() + if matches == nil { + tt.Fatalf("Output did not match:\n---------------- (stdout text)\n%s\n---------------- (regular expression)\n%s", + output, resource) + return re, nil + } + tt.Logf("Matched stdout text:\n%s", output) + var submatches []string + for i := 0; i < len(matches); i += 2 { + submatch := string(output[matches[i]:matches[i+1]]) + submatches = append(submatches, submatch) + } + return re, submatches +} + +// ExpectExit expects the child process to exit within 5s without +// printing any additional text on stdout. +func (tt *TestCmd) ExpectExit() { + var output []byte + tt.withKillTimeout(func() { + output, _ = ioutil.ReadAll(tt.stdout) + }) + tt.WaitExit() + if tt.Cleanup != nil { + tt.Cleanup() + } + if len(output) > 0 { + tt.Errorf("Unmatched stdout text:\n%s", output) + } +} + +func (tt *TestCmd) WaitExit() { + tt.cmd.Wait() +} + +func (tt *TestCmd) Interrupt() { + tt.cmd.Process.Signal(os.Interrupt) +} + +// StderrText returns any stderr output written so far. +// The returned text holds all log lines after ExpectExit has +// returned. +func (tt *TestCmd) StderrText() string { + tt.stderr.mu.Lock() + defer tt.stderr.mu.Unlock() + return tt.stderr.buf.String() +} + +func (tt *TestCmd) CloseStdin() { + tt.stdin.Close() +} + +func (tt *TestCmd) Kill() { + tt.cmd.Process.Kill() + if tt.Cleanup != nil { + tt.Cleanup() + } +} + +func (tt *TestCmd) withKillTimeout(fn func()) { + timeout := time.AfterFunc(5*time.Second, func() { + tt.Log("killing the child process (timeout)") + tt.Kill() + }) + defer timeout.Stop() + fn() +} + +// testlogger logs all written lines via t.Log and also +// collects them for later inspection. +type testlogger struct { + t *testing.T + mu sync.Mutex + buf bytes.Buffer +} + +func (tl *testlogger) Write(b []byte) (n int, err error) { + lines := bytes.Split(b, []byte("\n")) + for _, line := range lines { + if len(line) > 0 { + tl.t.Logf("(stderr) %s", line) + } + } + tl.mu.Lock() + tl.buf.Write(b) + tl.mu.Unlock() + return len(b), err +} + +// runeTee collects text read through it into buf. +type runeTee struct { + in interface { + io.Reader + io.ByteReader + io.RuneReader + } + buf bytes.Buffer +} + +func (rtee *runeTee) Read(b []byte) (n int, err error) { + n, err = rtee.in.Read(b) + rtee.buf.Write(b[:n]) + return n, err +} + +func (rtee *runeTee) ReadRune() (r rune, size int, err error) { + r, size, err = rtee.in.ReadRune() + if err == nil { + rtee.buf.WriteRune(r) + } + return r, size, err +} + +func (rtee *runeTee) ReadByte() (b byte, err error) { + b, err = rtee.in.ReadByte() + if err == nil { + rtee.buf.WriteByte(b) + } + return b, err +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/addrlock.go b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/addrlock.go new file mode 100644 index 000000000..5a9c948b8 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/addrlock.go @@ -0,0 +1,53 @@ +// Copyright 2015 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 ( + "sync" + + "github.com/ethereum/go-ethereum/common" +) + +type AddrLocker struct { + mu sync.Mutex + locks map[common.Address]*sync.Mutex +} + +// lock returns the lock of the given address. +func (l *AddrLocker) lock(address common.Address) *sync.Mutex { + l.mu.Lock() + defer l.mu.Unlock() + if l.locks == nil { + l.locks = make(map[common.Address]*sync.Mutex) + } + if _, ok := l.locks[address]; !ok { + l.locks[address] = new(sync.Mutex) + } + return l.locks[address] +} + +// LockAddr locks an account's mutex. This is used to prevent another tx getting the +// same nonce until the lock is released. The mutex prevents the (an identical nonce) from +// being read again during the time that the first transaction is being signed. +func (l *AddrLocker) LockAddr(address common.Address) { + l.lock(address).Lock() +} + +// UnlockAddr unlocks the mutex of the given account. +func (l *AddrLocker) UnlockAddr(address common.Address) { + l.lock(address).Unlock() +} diff --git a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/api.go b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/api.go index bcd62b091..1c2273655 100644 --- a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/api.go +++ b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/api.go @@ -19,7 +19,6 @@ package ethapi import ( "bytes" "context" - "encoding/hex" "errors" "fmt" "math/big" @@ -119,16 +118,16 @@ func (s *PublicTxPoolAPI) Content() map[string]map[string]map[string]*RPCTransac // Flatten the pending transactions for account, txs := range pending { dump := make(map[string]*RPCTransaction) - for nonce, tx := range txs { - dump[fmt.Sprintf("%d", nonce)] = newRPCPendingTransaction(tx) + for _, tx := range txs { + dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx) } content["pending"][account.Hex()] = dump } // Flatten the queued transactions for account, txs := range queue { dump := make(map[string]*RPCTransaction) - for nonce, tx := range txs { - dump[fmt.Sprintf("%d", nonce)] = newRPCPendingTransaction(tx) + for _, tx := range txs { + dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx) } content["queued"][account.Hex()] = dump } @@ -163,16 +162,16 @@ func (s *PublicTxPoolAPI) Inspect() map[string]map[string]map[string]string { // Flatten the pending transactions for account, txs := range pending { dump := make(map[string]string) - for nonce, tx := range txs { - dump[fmt.Sprintf("%d", nonce)] = format(tx) + for _, tx := range txs { + dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx) } content["pending"][account.Hex()] = dump } // Flatten the queued transactions for account, txs := range queue { dump := make(map[string]string) - for nonce, tx := range txs { - dump[fmt.Sprintf("%d", nonce)] = format(tx) + for _, tx := range txs { + dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx) } content["queued"][account.Hex()] = dump } @@ -214,15 +213,17 @@ func (s *PublicAccountAPI) Accounts() []common.Address { // It offers methods to create, (un)lock en list accounts. Some methods accept // passwords and are therefore considered private by default. type PrivateAccountAPI struct { - am *accounts.Manager - b Backend + am *accounts.Manager + nonceLock *AddrLocker + b Backend } // NewPrivateAccountAPI create a new PrivateAccountAPI. -func NewPrivateAccountAPI(b Backend) *PrivateAccountAPI { +func NewPrivateAccountAPI(b Backend, nonceLock *AddrLocker) *PrivateAccountAPI { return &PrivateAccountAPI{ - am: b.AccountManager(), - b: b, + am: b.AccountManager(), + nonceLock: nonceLock, + b: b, } } @@ -296,12 +297,11 @@ func fetchKeystore(am *accounts.Manager) *keystore.KeyStore { // ImportRawKey stores the given hex encoded ECDSA key into the key directory, // encrypting it with the passphrase. func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) { - hexkey, err := hex.DecodeString(privkey) + key, err := crypto.HexToECDSA(privkey) if err != nil { return common.Address{}, err } - - acc, err := fetchKeystore(s.am).ImportECDSA(crypto.ToECDSA(hexkey), password) + acc, err := fetchKeystore(s.am).ImportECDSA(key, password) return acc.Address, err } @@ -331,10 +331,6 @@ func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool { // tries to sign it with the key associated with args.To. If the given passwd isn't // able to decrypt the key it fails. func (s *PrivateAccountAPI) SendTransaction(ctx context.Context, args SendTxArgs, passwd string) (common.Hash, error) { - // Set some sanity defaults and terminate on failure - if err := args.setDefaults(ctx, s.b); err != nil { - return common.Hash{}, err - } // Look up the wallet containing the requested signer account := accounts.Account{Address: args.From} @@ -342,6 +338,18 @@ func (s *PrivateAccountAPI) SendTransaction(ctx context.Context, args SendTxArgs if err != nil { return common.Hash{}, err } + + if args.Nonce == nil { + // Hold the addresse's mutex around signing to prevent concurrent assignment of + // the same nonce to multiple accounts. + s.nonceLock.LockAddr(args.From) + defer s.nonceLock.UnlockAddr(args.From) + } + + // Set some sanity defaults and terminate on failure + if err := args.setDefaults(ctx, s.b); err != nil { + return common.Hash{}, err + } // Assemble the transaction and sign with the wallet tx := args.toTransaction() @@ -453,8 +461,8 @@ func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Add if state == nil || err != nil { return nil, err } - - return state.GetBalance(ctx, address) + b := state.GetBalance(address) + return b, state.Error() } // GetBlockByNumber returns the requested block. When blockNr is -1 the chain head is returned. When fullTx is true all @@ -535,31 +543,25 @@ func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, bloc } // GetCode returns the code stored at the given address in the state for the given block number. -func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (string, error) { +func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (hexutil.Bytes, error) { state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) if state == nil || err != nil { - return "", err + return nil, err } - res, err := state.GetCode(ctx, address) - if len(res) == 0 || err != nil { // backwards compatibility - return "0x", err - } - return common.ToHex(res), nil + code := state.GetCode(address) + return code, state.Error() } // GetStorageAt returns the storage from the state at the given address, key and // block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block // numbers are also allowed. -func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNr rpc.BlockNumber) (string, error) { +func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNr rpc.BlockNumber) (hexutil.Bytes, error) { state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) if state == nil || err != nil { - return "0x", err + return nil, err } - res, err := state.GetState(ctx, address, common.HexToHash(key)) - if err != nil { - return "0x", err - } - return res.Hex(), nil + res := state.GetState(address, common.HexToHash(key)) + return res[:], state.Error() } // callmsg is the message type used for call transitions. @@ -901,12 +903,13 @@ func newRPCTransaction(b *types.Block, txHash common.Hash) (*RPCTransaction, err // PublicTransactionPoolAPI exposes methods for the RPC interface type PublicTransactionPoolAPI struct { - b Backend + b Backend + nonceLock *AddrLocker } // NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool. -func NewPublicTransactionPoolAPI(b Backend) *PublicTransactionPoolAPI { - return &PublicTransactionPoolAPI{b} +func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransactionPoolAPI { + return &PublicTransactionPoolAPI{b, nonceLock} } func getTransaction(chainDb ethdb.Database, b Backend, txHash common.Hash) (*types.Transaction, bool, error) { @@ -983,11 +986,8 @@ func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, addr if state == nil || err != nil { return nil, err } - nonce, err := state.GetNonce(ctx, address) - if err != nil { - return nil, err - } - return (*hexutil.Uint64)(&nonce), nil + nonce := state.GetNonce(address) + return (*hexutil.Uint64)(&nonce), state.Error() } // getTransactionBlockData fetches the meta data for the given transaction from the chain database. This is useful to @@ -1216,6 +1216,18 @@ func (s *PublicTransactionPoolAPI) CompleteQueuedTransaction(ctx context.Context if err != nil { return common.Hash{}, err } + + if args.Nonce == nil { + // Hold the addresse's mutex around signing to prevent concurrent assignment of + // the same nonce to multiple accounts. + s.nonceLock.LockAddr(args.From) + defer s.nonceLock.UnlockAddr(args.From) + } + + // Set some sanity defaults and terminate on failure + if err := args.setDefaults(ctx, s.b); err != nil { + return common.Hash{}, err + } // Assemble the transaction and sign with the wallet tx := args.toTransaction() @@ -1292,6 +1304,12 @@ type SignTransactionResult struct { // The node needs to have the private key of the account corresponding with // the given from address and it needs to be unlocked. func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) { + if args.Nonce == nil { + // Hold the addresse's mutex around signing to prevent concurrent assignment of + // the same nonce to multiple accounts. + s.nonceLock.LockAddr(args.From) + defer s.nonceLock.UnlockAddr(args.From) + } if err := args.setDefaults(ctx, s.b); err != nil { return nil, err } diff --git a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/backend.go b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/backend.go index fdfc52fbc..7dc338f0d 100644 --- a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/backend.go +++ b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/backend.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/common" "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/downloader" @@ -47,11 +48,12 @@ type Backend interface { SetHead(number uint64) HeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Header, error) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*types.Block, error) - StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (State, *types.Header, error) + StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error) GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error) GetReceipts(ctx context.Context, blockHash common.Hash) (types.Receipts, error) GetTd(blockHash common.Hash) *big.Int - GetEVM(ctx context.Context, msg core.Message, state State, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) + GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) + // TxPool API SendTx(ctx context.Context, signedTx *types.Transaction) error RemoveTx(txHash common.Hash) @@ -67,14 +69,8 @@ type Backend interface { GetStatusBackend() *StatusBackend } -type State interface { - GetBalance(ctx context.Context, addr common.Address) (*big.Int, error) - GetCode(ctx context.Context, addr common.Address) ([]byte, error) - GetState(ctx context.Context, a common.Address, b common.Hash) (common.Hash, error) - GetNonce(ctx context.Context, addr common.Address) (uint64, error) -} - func GetAPIs(apiBackend Backend) []rpc.API { + nonceLock := new(AddrLocker) return []rpc.API{ { Namespace: "eth", @@ -89,7 +85,7 @@ func GetAPIs(apiBackend Backend) []rpc.API { }, { Namespace: "eth", Version: "1.0", - Service: NewPublicTransactionPoolAPI(apiBackend), + Service: NewPublicTransactionPoolAPI(apiBackend, nonceLock), Public: true, }, { Namespace: "txpool", @@ -113,7 +109,7 @@ func GetAPIs(apiBackend Backend) []rpc.API { }, { Namespace: "personal", Version: "1.0", - Service: NewPrivateAccountAPI(apiBackend), + Service: NewPrivateAccountAPI(apiBackend, nonceLock), Public: false, }, } diff --git a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/status_backend.go b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/status_backend.go index 68d251700..663251df1 100644 --- a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/status_backend.go +++ b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/status_backend.go @@ -34,7 +34,7 @@ func NewStatusBackend(apiBackend Backend) *StatusBackend { return &StatusBackend{ eapi: NewPublicEthereumAPI(apiBackend), bcapi: NewPublicBlockChainAPI(apiBackend), - txapi: NewPublicTransactionPoolAPI(apiBackend), + txapi: NewPublicTransactionPoolAPI(apiBackend, new(AddrLocker)), txQueue: status.NewTransactionQueue(), am: status.NewAccountManager(apiBackend.AccountManager()), } diff --git a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/tracer.go b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/tracer.go index d34363564..fc66839ea 100644 --- a/vendor/github.com/ethereum/go-ethereum/internal/ethapi/tracer.go +++ b/vendor/github.com/ethereum/go-ethereum/internal/ethapi/tracer.go @@ -21,6 +21,7 @@ import ( "errors" "fmt" "math/big" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" @@ -344,6 +345,12 @@ func (jst *JavascriptTracer) CaptureState(env *vm.EVM, pc uint64, op vm.OpCode, return nil } +// CaptureEnd is called after the call finishes +func (jst *JavascriptTracer) CaptureEnd(output []byte, gasUsed uint64, t time.Duration) 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 { diff --git a/vendor/github.com/ethereum/go-ethereum/internal/web3ext/web3ext.go b/vendor/github.com/ethereum/go-ethereum/internal/web3ext/web3ext.go index c9cac125d..44fabd6ab 100644 --- a/vendor/github.com/ethereum/go-ethereum/internal/web3ext/web3ext.go +++ b/vendor/github.com/ethereum/go-ethereum/internal/web3ext/web3ext.go @@ -208,8 +208,8 @@ web3._extend({ params: 1 }), new web3._extend.Method({ - name: 'traceBlockByFile', - call: 'debug_traceBlockByFile', + name: 'traceBlockFromFile', + call: 'debug_traceBlockFromFile', params: 1 }), new web3._extend.Method({ @@ -525,17 +525,126 @@ web3._extend({ const Shh_JS = ` web3._extend({ property: 'shh', - methods: [], + methods: [ + new web3._extend.Method({ + name: 'setMaxMessageLength', + call: 'shh_setMaxMessageLength', + params: 1 + }), + new web3._extend.Method({ + name: 'setMinimumPoW', + call: 'shh_setMinimumPoW', + params: 1 + }), + new web3._extend.Method({ + name: 'markTrustedPeer', + call: 'shh_markTrustedPeer', + params: 1 + }), + new web3._extend.Method({ + name: 'hasKeyPair', + call: 'shh_hasKeyPair', + params: 1 + }), + new web3._extend.Method({ + name: 'deleteKeyPair', + call: 'shh_deleteKeyPair', + params: 1 + }), + new web3._extend.Method({ + name: 'newKeyPair', + call: 'shh_newKeyPair' + }), + new web3._extend.Method({ + name: 'getPublicKey', + call: 'shh_getPublicKey', + params: 1 + }), + new web3._extend.Method({ + name: 'getPrivateKey', + call: 'shh_getPrivateKey', + params: 1 + }), + new web3._extend.Method({ + name: 'newSymKey', + call: 'shh_newSymKey', + }), + new web3._extend.Method({ + name: 'addSymKey', + call: 'shh_addSymKey', + params: 1 + }), + new web3._extend.Method({ + name: 'generateSymKeyFromPassword', + call: 'shh_generateSymKeyFromPassword', + params: 1 + }), + new web3._extend.Method({ + name: 'hasSymKey', + call: 'shh_hasSymKey', + params: 1 + }), + new web3._extend.Method({ + name: 'getSymKey', + call: 'shh_getSymKey', + params: 1 + }), + new web3._extend.Method({ + name: 'deleteSymKey', + call: 'shh_deleteSymKey', + params: 1 + }), + new web3._extend.Method({ + name: 'subscribe', + call: 'shh_subscribe', + params: 2 + }), + new web3._extend.Method({ + name: 'unsubscribe', + call: 'shh_unsubscribe', + params: 1 + }), + new web3._extend.Method({ + name: 'post', + call: 'shh_post', + params: 1 + }), + new web3._extend.Method({ + name: 'publicKey', + call: 'shh_getPublicKey', + params: 1 + }), + new web3._extend.Method({ + name: 'getFilterMessages', + call: 'shh_getFilterMessages', + params: 1 + }), + new web3._extend.Method({ + name: 'deleteMessageFilter', + call: 'shh_deleteMessageFilter', + params: 1 + }), + new web3._extend.Method({ + name: 'newMessageFilter', + call: 'shh_newMessageFilter', + params: 1 + }) + ], properties: [ new web3._extend.Property({ name: 'version', getter: 'shh_version', outputFormatter: web3._extend.utils.toDecimal - }) + }), + new web3._extend.Property({ + name: 'info', + getter: 'shh_info' + }), ] }); ` + const SWARMFS_JS = ` web3._extend({ property: 'swarmfs', diff --git a/vendor/github.com/ethereum/go-ethereum/les/api_backend.go b/vendor/github.com/ethereum/go-ethereum/les/api_backend.go index eb69e7f5e..35d9e8825 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/api_backend.go +++ b/vendor/github.com/ethereum/go-ethereum/les/api_backend.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/math" "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/downloader" @@ -75,12 +76,12 @@ func (b *LesApiBackend) BlockByNumber(ctx context.Context, blockNr rpc.BlockNumb return b.GetBlock(ctx, header.Hash()) } -func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (ethapi.State, *types.Header, error) { +func (b *LesApiBackend) StateAndHeaderByNumber(ctx context.Context, blockNr rpc.BlockNumber) (*state.StateDB, *types.Header, error) { header, err := b.HeaderByNumber(ctx, blockNr) if header == nil || err != nil { return nil, nil, err } - return light.NewLightState(light.StateTrieID(header), b.eth.odr), header, nil + return light.NewState(ctx, header, b.eth.odr), header, nil } func (b *LesApiBackend) GetBlock(ctx context.Context, blockHash common.Hash) (*types.Block, error) { @@ -95,18 +96,10 @@ func (b *LesApiBackend) GetTd(blockHash common.Hash) *big.Int { return b.eth.blockchain.GetTdByHash(blockHash) } -func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state ethapi.State, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) { - stateDb := state.(*light.LightState).Copy() - addr := msg.From() - from, err := stateDb.GetOrNewStateObject(ctx, addr) - if err != nil { - return nil, nil, err - } - from.SetBalance(math.MaxBig256) - - vmstate := light.NewVMState(ctx, stateDb) +func (b *LesApiBackend) GetEVM(ctx context.Context, msg core.Message, state *state.StateDB, header *types.Header, vmCfg vm.Config) (*vm.EVM, func() error, error) { + state.SetBalance(msg.From(), math.MaxBig256) context := core.NewEVMContext(msg, header, b.eth.blockchain, nil) - return vm.NewEVM(context, vmstate, b.eth.chainConfig, vmCfg), vmstate.Error, nil + return vm.NewEVM(context, state, b.eth.chainConfig, vmCfg), state.Error, nil } func (b *LesApiBackend) SendTx(ctx context.Context, signedTx *types.Transaction) error { diff --git a/vendor/github.com/ethereum/go-ethereum/les/backend.go b/vendor/github.com/ethereum/go-ethereum/les/backend.go index 0896de42b..47a337543 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/backend.go +++ b/vendor/github.com/ethereum/go-ethereum/les/backend.go @@ -19,6 +19,7 @@ package les import ( "fmt" + "sync" "time" "github.com/ethereum/go-ethereum/accounts" @@ -38,6 +39,7 @@ import ( "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/node" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/discv5" "github.com/ethereum/go-ethereum/params" rpc "github.com/ethereum/go-ethereum/rpc" ) @@ -49,9 +51,13 @@ type LightEthereum struct { // Channel for shutting down the service shutdownChan chan bool // Handlers + peers *peerSet txPool *light.TxPool blockchain *light.LightChain protocolManager *ProtocolManager + serverPool *serverPool + reqDist *requestDistributor + retriever *retrieveManager // DB interfaces chainDb ethdb.Database // Block chain database @@ -64,6 +70,9 @@ type LightEthereum struct { networkId uint64 netRPCService *ethapi.PublicNetAPI + quitSync chan struct{} + wg sync.WaitGroup + StatusBackend *ethapi.StatusBackend } @@ -78,20 +87,26 @@ func New(ctx *node.ServiceContext, config *eth.Config) (*LightEthereum, error) { } log.Info("Initialised chain configuration", "config", chainConfig) - odr := NewLesOdr(chainDb) - relay := NewLesTxRelay() + peers := newPeerSet() + quitSync := make(chan struct{}) + eth := &LightEthereum{ - odr: odr, - relay: relay, - chainDb: chainDb, chainConfig: chainConfig, + chainDb: chainDb, eventMux: ctx.EventMux, + peers: peers, + reqDist: newRequestDistributor(peers, quitSync), accountManager: ctx.AccountManager, engine: eth.CreateConsensusEngine(ctx, config, chainConfig, chainDb), shutdownChan: make(chan bool), networkId: config.NetworkId, } - if eth.blockchain, err = light.NewLightChain(odr, eth.chainConfig, eth.engine, eth.eventMux); err != nil { + + eth.relay = NewLesTxRelay(peers, eth.reqDist) + eth.serverPool = newServerPool(chainDb, quitSync, ð.wg) + eth.retriever = newRetrieveManager(peers, eth.reqDist, eth.serverPool) + eth.odr = NewLesOdr(chainDb, eth.retriever) + if eth.blockchain, err = light.NewLightChain(eth.odr, eth.chainConfig, eth.engine, eth.eventMux); err != nil { return nil, err } // Rewind the chain in case of an incompatible config upgrade. @@ -102,12 +117,9 @@ func New(ctx *node.ServiceContext, config *eth.Config) (*LightEthereum, error) { } eth.txPool = light.NewTxPool(eth.chainConfig, eth.eventMux, eth.blockchain, eth.relay) - lightSync := config.SyncMode == downloader.LightSync - if eth.protocolManager, err = NewProtocolManager(eth.chainConfig, lightSync, config.NetworkId, eth.eventMux, eth.engine, eth.blockchain, nil, chainDb, odr, relay); err != nil { + if eth.protocolManager, err = NewProtocolManager(eth.chainConfig, true, config.NetworkId, eth.eventMux, eth.engine, eth.peers, eth.blockchain, nil, chainDb, eth.odr, eth.relay, quitSync, ð.wg); err != nil { return nil, err } - relay.ps = eth.protocolManager.peers - relay.reqDist = eth.protocolManager.reqDist eth.ApiBackend = &LesApiBackend{eth, nil, nil} gpoParams := config.GPO @@ -119,9 +131,14 @@ func New(ctx *node.ServiceContext, config *eth.Config) (*LightEthereum, error) { // inject status-im backend eth.ApiBackend.statusBackend = ethapi.NewStatusBackend(eth.ApiBackend) eth.StatusBackend = eth.ApiBackend.statusBackend // alias + return eth, nil } +func lesTopic(genesisHash common.Hash) discv5.Topic { + return discv5.Topic("LES@" + common.Bytes2Hex(genesisHash.Bytes()[0:8])) +} + type LightDummyAPI struct{} // Etherbase is the address that mining rewards will be send to @@ -194,7 +211,8 @@ func (s *LightEthereum) Protocols() []p2p.Protocol { func (s *LightEthereum) Start(srvr *p2p.Server) error { log.Warn("Light client mode is an experimental feature") s.netRPCService = ethapi.NewPublicNetAPI(srvr, s.networkId) - s.protocolManager.Start(srvr) + s.serverPool.start(srvr, lesTopic(s.blockchain.Genesis().Hash())) + s.protocolManager.Start() s.StatusBackend.Start() return nil } diff --git a/vendor/github.com/ethereum/go-ethereum/les/distributor.go b/vendor/github.com/ethereum/go-ethereum/les/distributor.go index 71afe2b73..e8ef5b02e 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/distributor.go +++ b/vendor/github.com/ethereum/go-ethereum/les/distributor.go @@ -34,11 +34,11 @@ var ErrNoPeers = errors.New("no suitable peers available") type requestDistributor struct { reqQueue *list.List lastReqOrder uint64 + peers map[distPeer]struct{} + peerLock sync.RWMutex stopChn, loopChn chan struct{} loopNextSent bool lock sync.Mutex - - getAllPeers func() map[distPeer]struct{} } // distPeer is an LES server peer interface for the request distributor. @@ -71,15 +71,39 @@ type distReq struct { } // newRequestDistributor creates a new request distributor -func newRequestDistributor(getAllPeers func() map[distPeer]struct{}, stopChn chan struct{}) *requestDistributor { - r := &requestDistributor{ - reqQueue: list.New(), - loopChn: make(chan struct{}, 2), - stopChn: stopChn, - getAllPeers: getAllPeers, +func newRequestDistributor(peers *peerSet, stopChn chan struct{}) *requestDistributor { + d := &requestDistributor{ + reqQueue: list.New(), + loopChn: make(chan struct{}, 2), + stopChn: stopChn, + peers: make(map[distPeer]struct{}), } - go r.loop() - return r + if peers != nil { + peers.notify(d) + } + go d.loop() + return d +} + +// registerPeer implements peerSetNotify +func (d *requestDistributor) registerPeer(p *peer) { + d.peerLock.Lock() + d.peers[p] = struct{}{} + d.peerLock.Unlock() +} + +// unregisterPeer implements peerSetNotify +func (d *requestDistributor) unregisterPeer(p *peer) { + d.peerLock.Lock() + delete(d.peers, p) + d.peerLock.Unlock() +} + +// registerTestPeer adds a new test peer +func (d *requestDistributor) registerTestPeer(p distPeer) { + d.peerLock.Lock() + d.peers[p] = struct{}{} + d.peerLock.Unlock() } // distMaxWait is the maximum waiting time after which further necessary waiting @@ -152,8 +176,7 @@ func (sp selectPeerItem) Weight() int64 { // nextRequest returns the next possible request from any peer, along with the // associated peer and necessary waiting time func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) { - peers := d.getAllPeers() - + checkedPeers := make(map[distPeer]struct{}) elem := d.reqQueue.Front() var ( bestPeer distPeer @@ -162,11 +185,14 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) { sel *weightedRandomSelect ) - for (len(peers) > 0 || elem == d.reqQueue.Front()) && elem != nil { + d.peerLock.RLock() + defer d.peerLock.RUnlock() + + for (len(d.peers) > 0 || elem == d.reqQueue.Front()) && elem != nil { req := elem.Value.(*distReq) canSend := false - for peer, _ := range peers { - if peer.canQueue() && req.canSend(peer) { + for peer, _ := range d.peers { + if _, ok := checkedPeers[peer]; !ok && peer.canQueue() && req.canSend(peer) { canSend = true cost := req.getCost(peer) wait, bufRemain := peer.waitBefore(cost) @@ -182,7 +208,7 @@ func (d *requestDistributor) nextRequest() (distPeer, *distReq, time.Duration) { bestWait = wait } } - delete(peers, peer) + checkedPeers[peer] = struct{}{} } } next := elem.Next() diff --git a/vendor/github.com/ethereum/go-ethereum/les/execqueue.go b/vendor/github.com/ethereum/go-ethereum/les/execqueue.go index ac779003b..614721bf0 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/execqueue.go +++ b/vendor/github.com/ethereum/go-ethereum/les/execqueue.go @@ -16,56 +16,82 @@ package les -import ( - "sync/atomic" -) +import "sync" -// ExecQueue implements a queue that executes function calls in a single thread, +// execQueue implements a queue that executes function calls in a single thread, // in the same order as they have been queued. type execQueue struct { - chn chan func() - cnt, stop, capacity int32 + mu sync.Mutex + cond *sync.Cond + funcs []func() + closeWait chan struct{} } -// NewExecQueue creates a new execution queue. -func newExecQueue(capacity int32) *execQueue { - q := &execQueue{ - chn: make(chan func(), capacity), - capacity: capacity, - } +// newExecQueue creates a new execution queue. +func newExecQueue(capacity int) *execQueue { + q := &execQueue{funcs: make([]func(), 0, capacity)} + q.cond = sync.NewCond(&q.mu) go q.loop() return q } func (q *execQueue) loop() { - for f := range q.chn { - atomic.AddInt32(&q.cnt, -1) - if atomic.LoadInt32(&q.stop) != 0 { - return - } + for f := q.waitNext(false); f != nil; f = q.waitNext(true) { f() } + close(q.closeWait) } -// CanQueue returns true if more function calls can be added to the execution queue. +func (q *execQueue) waitNext(drop bool) (f func()) { + q.mu.Lock() + if drop { + // Remove the function that just executed. We do this here instead of when + // dequeuing so len(q.funcs) includes the function that is running. + q.funcs = append(q.funcs[:0], q.funcs[1:]...) + } + for !q.isClosed() { + if len(q.funcs) > 0 { + f = q.funcs[0] + break + } + q.cond.Wait() + } + q.mu.Unlock() + return f +} + +func (q *execQueue) isClosed() bool { + return q.closeWait != nil +} + +// canQueue returns true if more function calls can be added to the execution queue. func (q *execQueue) canQueue() bool { - return atomic.LoadInt32(&q.stop) == 0 && atomic.LoadInt32(&q.cnt) < q.capacity + q.mu.Lock() + ok := !q.isClosed() && len(q.funcs) < cap(q.funcs) + q.mu.Unlock() + return ok } -// Queue adds a function call to the execution queue. Returns true if successful. +// queue adds a function call to the execution queue. Returns true if successful. func (q *execQueue) queue(f func()) bool { - if atomic.LoadInt32(&q.stop) != 0 { - return false + q.mu.Lock() + ok := !q.isClosed() && len(q.funcs) < cap(q.funcs) + if ok { + q.funcs = append(q.funcs, f) + q.cond.Signal() } - if atomic.AddInt32(&q.cnt, 1) > q.capacity { - atomic.AddInt32(&q.cnt, -1) - return false - } - q.chn <- f - return true + q.mu.Unlock() + return ok } -// Stop stops the exec queue. +// quit stops the exec queue. +// quit waits for the current execution to finish before returning. func (q *execQueue) quit() { - atomic.StoreInt32(&q.stop, 1) + q.mu.Lock() + if !q.isClosed() { + q.closeWait = make(chan struct{}) + q.cond.Signal() + } + q.mu.Unlock() + <-q.closeWait } diff --git a/vendor/github.com/ethereum/go-ethereum/les/fetcher.go b/vendor/github.com/ethereum/go-ethereum/les/fetcher.go index a294d00d5..4fc142f0f 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/fetcher.go +++ b/vendor/github.com/ethereum/go-ethereum/les/fetcher.go @@ -116,6 +116,7 @@ func newLightFetcher(pm *ProtocolManager) *lightFetcher { syncDone: make(chan *peer), maxConfirmedTd: big.NewInt(0), } + pm.peers.notify(f) go f.syncLoop() return f } @@ -209,8 +210,8 @@ func (f *lightFetcher) syncLoop() { } } -// addPeer adds a new peer to the fetcher's peer set -func (f *lightFetcher) addPeer(p *peer) { +// registerPeer adds a new peer to the fetcher's peer set +func (f *lightFetcher) registerPeer(p *peer) { p.lock.Lock() p.hasBlock = func(hash common.Hash, number uint64) bool { return f.peerHasBlock(p, hash, number) @@ -223,8 +224,8 @@ func (f *lightFetcher) addPeer(p *peer) { f.peers[p] = &fetcherPeerInfo{nodeByHash: make(map[common.Hash]*fetcherTreeNode)} } -// removePeer removes a new peer from the fetcher's peer set -func (f *lightFetcher) removePeer(p *peer) { +// unregisterPeer removes a new peer from the fetcher's peer set +func (f *lightFetcher) unregisterPeer(p *peer) { p.lock.Lock() p.hasBlock = nil p.lock.Unlock() @@ -416,7 +417,7 @@ func (f *lightFetcher) nextRequest() (*distReq, uint64) { f.syncing = bestSyncing var rq *distReq - reqID := getNextReqID() + reqID := genReqID() if f.syncing { rq = &distReq{ getCost: func(dp distPeer) uint64 { diff --git a/vendor/github.com/ethereum/go-ethereum/les/handler.go b/vendor/github.com/ethereum/go-ethereum/les/handler.go index 64023af0f..f50abaaa3 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/handler.go +++ b/vendor/github.com/ethereum/go-ethereum/les/handler.go @@ -87,8 +87,8 @@ type BlockChain interface { } type txPool interface { - // AddTransactions should add the given transactions to the pool. - AddBatch([]*types.Transaction) error + // AddRemotes should add the given transactions to the pool. + AddRemotes([]*types.Transaction) error } type ProtocolManager struct { @@ -102,7 +102,9 @@ type ProtocolManager struct { odr *LesOdr server *LesServer serverPool *serverPool + lesTopic discv5.Topic reqDist *requestDistributor + retriever *retrieveManager downloader *downloader.Downloader fetcher *lightFetcher @@ -123,12 +125,12 @@ type ProtocolManager struct { // wait group is used for graceful shutdowns during downloading // and processing - wg sync.WaitGroup + wg *sync.WaitGroup } // NewProtocolManager returns a new ethereum sub protocol manager. The Ethereum sub protocol manages peers capable // with the ethereum network. -func NewProtocolManager(chainConfig *params.ChainConfig, lightSync bool, networkId uint64, mux *event.TypeMux, engine consensus.Engine, blockchain BlockChain, txpool txPool, chainDb ethdb.Database, odr *LesOdr, txrelay *LesTxRelay) (*ProtocolManager, error) { +func NewProtocolManager(chainConfig *params.ChainConfig, lightSync bool, networkId uint64, mux *event.TypeMux, engine consensus.Engine, peers *peerSet, blockchain BlockChain, txpool txPool, chainDb ethdb.Database, odr *LesOdr, txrelay *LesTxRelay, quitSync chan struct{}, wg *sync.WaitGroup) (*ProtocolManager, error) { // Create the protocol manager with the base fields manager := &ProtocolManager{ lightSync: lightSync, @@ -136,15 +138,20 @@ func NewProtocolManager(chainConfig *params.ChainConfig, lightSync bool, network blockchain: blockchain, chainConfig: chainConfig, chainDb: chainDb, + odr: odr, networkId: networkId, txpool: txpool, txrelay: txrelay, - odr: odr, - peers: newPeerSet(), + peers: peers, newPeerCh: make(chan *peer), - quitSync: make(chan struct{}), + quitSync: quitSync, + wg: wg, noMorePeers: make(chan struct{}), } + if odr != nil { + manager.retriever = odr.retriever + manager.reqDist = odr.retriever.dist + } // Initiate a sub-protocol for every implemented version we can handle manager.SubProtocols = make([]p2p.Protocol, 0, len(ProtocolVersions)) for i, version := range ProtocolVersions { @@ -199,87 +206,23 @@ func NewProtocolManager(chainConfig *params.ChainConfig, lightSync bool, network } if lightSync { - manager.downloader = downloader.New(downloader.LightSync, chainDb, manager.eventMux, blockchain.HasHeader, nil, blockchain.GetHeaderByHash, - nil, blockchain.CurrentHeader, nil, nil, nil, blockchain.GetTdByHash, - blockchain.InsertHeaderChain, nil, nil, blockchain.Rollback, removePeer) + manager.downloader = downloader.New(downloader.LightSync, chainDb, manager.eventMux, nil, blockchain, removePeer) + manager.peers.notify((*downloaderPeerNotify)(manager)) + manager.fetcher = newLightFetcher(manager) } - manager.reqDist = newRequestDistributor(func() map[distPeer]struct{} { - m := make(map[distPeer]struct{}) - peers := manager.peers.AllPeers() - for _, peer := range peers { - m[peer] = struct{}{} - } - return m - }, manager.quitSync) - if odr != nil { - odr.removePeer = removePeer - odr.reqDist = manager.reqDist - } - - /*validator := func(block *types.Block, parent *types.Block) error { - return core.ValidateHeader(pow, block.Header(), parent.Header(), true, false) - } - heighter := func() uint64 { - return chainman.LastBlockNumberU64() - } - manager.fetcher = fetcher.New(chainman.GetBlockNoOdr, validator, nil, heighter, chainman.InsertChain, manager.removePeer) - */ return manager, nil } +// removePeer initiates disconnection from a peer by removing it from the peer set func (pm *ProtocolManager) removePeer(id string) { - // Short circuit if the peer was already removed - peer := pm.peers.Peer(id) - if peer == nil { - return - } - log.Debug("Removing light Ethereum peer", "peer", id) - if err := pm.peers.Unregister(id); err != nil { - if err == errNotRegistered { - return - } - } - // Unregister the peer from the downloader and Ethereum peer set - if pm.lightSync { - pm.downloader.UnregisterPeer(id) - if pm.txrelay != nil { - pm.txrelay.removePeer(id) - } - if pm.fetcher != nil { - pm.fetcher.removePeer(peer) - } - } - // Hard disconnect at the networking layer - if peer != nil { - peer.Peer.Disconnect(p2p.DiscUselessPeer) - } + pm.peers.Unregister(id) } -func (pm *ProtocolManager) Start(srvr *p2p.Server) { - var topicDisc *discv5.Network - if srvr != nil { - topicDisc = srvr.DiscV5 - } - lesTopic := discv5.Topic("LES@" + common.Bytes2Hex(pm.blockchain.Genesis().Hash().Bytes()[0:8])) +func (pm *ProtocolManager) Start() { if pm.lightSync { - // start sync handler - if srvr != nil { // srvr is nil during testing - pm.serverPool = newServerPool(pm.chainDb, []byte("serverPool/"), srvr, lesTopic, pm.quitSync, &pm.wg) - pm.odr.serverPool = pm.serverPool - pm.fetcher = newLightFetcher(pm) - } go pm.syncer() } else { - if topicDisc != nil { - go func() { - logger := log.New("topic", lesTopic) - logger.Info("Starting topic registration") - defer logger.Info("Terminated topic registration") - - topicDisc.RegisterTopic(lesTopic, pm.quitSync) - }() - } go func() { for range pm.newPeerCh { } @@ -342,65 +285,10 @@ func (pm *ProtocolManager) handle(p *peer) error { }() // Register the peer in the downloader. If the downloader considers it banned, we disconnect if pm.lightSync { - requestHeadersByHash := func(origin common.Hash, amount int, skip int, reverse bool) error { - reqID := getNextReqID() - rq := &distReq{ - getCost: func(dp distPeer) uint64 { - peer := dp.(*peer) - return peer.GetRequestCost(GetBlockHeadersMsg, amount) - }, - canSend: func(dp distPeer) bool { - return dp.(*peer) == p - }, - request: func(dp distPeer) func() { - peer := dp.(*peer) - cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) - peer.fcServer.QueueRequest(reqID, cost) - return func() { peer.RequestHeadersByHash(reqID, cost, origin, amount, skip, reverse) } - }, - } - _, ok := <-pm.reqDist.queue(rq) - if !ok { - return ErrNoPeers - } - return nil - } - requestHeadersByNumber := func(origin uint64, amount int, skip int, reverse bool) error { - reqID := getNextReqID() - rq := &distReq{ - getCost: func(dp distPeer) uint64 { - peer := dp.(*peer) - return peer.GetRequestCost(GetBlockHeadersMsg, amount) - }, - canSend: func(dp distPeer) bool { - return dp.(*peer) == p - }, - request: func(dp distPeer) func() { - peer := dp.(*peer) - cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) - peer.fcServer.QueueRequest(reqID, cost) - return func() { peer.RequestHeadersByNumber(reqID, cost, origin, amount, skip, reverse) } - }, - } - _, ok := <-pm.reqDist.queue(rq) - if !ok { - return ErrNoPeers - } - return nil - } - if err := pm.downloader.RegisterPeer(p.id, ethVersion, p.HeadAndTd, - requestHeadersByHash, requestHeadersByNumber, nil, nil, nil); err != nil { - return err - } - if pm.txrelay != nil { - pm.txrelay.addPeer(p) - } - p.lock.Lock() head := p.headInfo p.lock.Unlock() if pm.fetcher != nil { - pm.fetcher.addPeer(p) pm.fetcher.announce(p, head) } @@ -913,7 +801,7 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { return errResp(ErrRequestRejected, "") } - if err := pm.txpool.AddBatch(txs); err != nil { + if err := pm.txpool.AddRemotes(txs); err != nil { return errResp(ErrUnexpectedResponse, "msg: %v", err) } @@ -926,7 +814,7 @@ func (pm *ProtocolManager) handleMsg(p *peer) error { } if deliverMsg != nil { - err := pm.odr.Deliver(p, deliverMsg) + err := pm.retriever.deliver(p, deliverMsg) if err != nil { p.responseErrors++ if p.responseErrors > maxResponseErrors { @@ -946,3 +834,77 @@ func (self *ProtocolManager) NodeInfo() *eth.EthNodeInfo { Head: self.blockchain.LastBlockHash(), } } + +// downloaderPeerNotify implements peerSetNotify +type downloaderPeerNotify ProtocolManager + +type peerConnection struct { + manager *ProtocolManager + peer *peer +} + +func (pc *peerConnection) Head() (common.Hash, *big.Int) { + return pc.peer.HeadAndTd() +} + +func (pc *peerConnection) RequestHeadersByHash(origin common.Hash, amount int, skip int, reverse bool) error { + reqID := genReqID() + rq := &distReq{ + getCost: func(dp distPeer) uint64 { + peer := dp.(*peer) + return peer.GetRequestCost(GetBlockHeadersMsg, amount) + }, + canSend: func(dp distPeer) bool { + return dp.(*peer) == pc.peer + }, + request: func(dp distPeer) func() { + peer := dp.(*peer) + cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) + peer.fcServer.QueueRequest(reqID, cost) + return func() { peer.RequestHeadersByHash(reqID, cost, origin, amount, skip, reverse) } + }, + } + _, ok := <-pc.manager.reqDist.queue(rq) + if !ok { + return ErrNoPeers + } + return nil +} + +func (pc *peerConnection) RequestHeadersByNumber(origin uint64, amount int, skip int, reverse bool) error { + reqID := genReqID() + rq := &distReq{ + getCost: func(dp distPeer) uint64 { + peer := dp.(*peer) + return peer.GetRequestCost(GetBlockHeadersMsg, amount) + }, + canSend: func(dp distPeer) bool { + return dp.(*peer) == pc.peer + }, + request: func(dp distPeer) func() { + peer := dp.(*peer) + cost := peer.GetRequestCost(GetBlockHeadersMsg, amount) + peer.fcServer.QueueRequest(reqID, cost) + return func() { peer.RequestHeadersByNumber(reqID, cost, origin, amount, skip, reverse) } + }, + } + _, ok := <-pc.manager.reqDist.queue(rq) + if !ok { + return ErrNoPeers + } + return nil +} + +func (d *downloaderPeerNotify) registerPeer(p *peer) { + pm := (*ProtocolManager)(d) + pc := &peerConnection{ + manager: pm, + peer: p, + } + pm.downloader.RegisterLightPeer(p.id, ethVersion, pc) +} + +func (d *downloaderPeerNotify) unregisterPeer(p *peer) { + pm := (*ProtocolManager)(d) + pm.downloader.UnregisterPeer(p.id) +} diff --git a/vendor/github.com/ethereum/go-ethereum/les/odr.go b/vendor/github.com/ethereum/go-ethereum/les/odr.go index 684f36c76..3f7584b48 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/odr.go +++ b/vendor/github.com/ethereum/go-ethereum/les/odr.go @@ -18,45 +18,24 @@ package les import ( "context" - "crypto/rand" - "encoding/binary" - "sync" - "time" - "github.com/ethereum/go-ethereum/common/mclock" "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/light" "github.com/ethereum/go-ethereum/log" ) -var ( - softRequestTimeout = time.Millisecond * 500 - hardRequestTimeout = time.Second * 10 -) - -// peerDropFn is a callback type for dropping a peer detected as malicious. -type peerDropFn func(id string) - -type odrPeerSelector interface { - adjustResponseTime(*poolEntry, time.Duration, bool) -} - +// LesOdr implements light.OdrBackend type LesOdr struct { - light.OdrBackend - db ethdb.Database - stop chan struct{} - removePeer peerDropFn - mlock, clock sync.Mutex - sentReqs map[uint64]*sentReq - serverPool odrPeerSelector - reqDist *requestDistributor + db ethdb.Database + stop chan struct{} + retriever *retrieveManager } -func NewLesOdr(db ethdb.Database) *LesOdr { +func NewLesOdr(db ethdb.Database, retriever *retrieveManager) *LesOdr { return &LesOdr{ - db: db, - stop: make(chan struct{}), - sentReqs: make(map[uint64]*sentReq), + db: db, + retriever: retriever, + stop: make(chan struct{}), } } @@ -68,17 +47,6 @@ func (odr *LesOdr) Database() ethdb.Database { return odr.db } -// validatorFunc is a function that processes a message. -type validatorFunc func(ethdb.Database, *Msg) error - -// sentReq is a request waiting for an answer that satisfies its valFunc -type sentReq struct { - valFunc validatorFunc - sentTo map[*peer]chan struct{} - lock sync.RWMutex // protects acces to sentTo - answered chan struct{} // closed and set to nil when any peer answers it -} - const ( MsgBlockBodies = iota MsgCode @@ -94,156 +62,29 @@ type Msg struct { Obj interface{} } -// Deliver is called by the LES protocol manager to deliver ODR reply messages to waiting requests -func (self *LesOdr) Deliver(peer *peer, msg *Msg) error { - var delivered chan struct{} - self.mlock.Lock() - req, ok := self.sentReqs[msg.ReqID] - self.mlock.Unlock() - if ok { - req.lock.Lock() - delivered, ok = req.sentTo[peer] - req.lock.Unlock() - } +// Retrieve tries to fetch an object from the LES network. +// If the network retrieval was successful, it stores the object in local db. +func (self *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err error) { + lreq := LesRequest(req) - if !ok { - return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID) - } - - if err := req.valFunc(self.db, msg); err != nil { - peer.Log().Warn("Invalid odr response", "err", err) - return errResp(ErrInvalidResponse, "reqID = %v", msg.ReqID) - } - close(delivered) - req.lock.Lock() - delete(req.sentTo, peer) - if req.answered != nil { - close(req.answered) - req.answered = nil - } - req.lock.Unlock() - return nil -} - -func (self *LesOdr) requestPeer(req *sentReq, peer *peer, delivered, timeout chan struct{}, reqWg *sync.WaitGroup) { - stime := mclock.Now() - defer func() { - req.lock.Lock() - delete(req.sentTo, peer) - req.lock.Unlock() - reqWg.Done() - }() - - select { - case <-delivered: - if self.serverPool != nil { - self.serverPool.adjustResponseTime(peer.poolEntry, time.Duration(mclock.Now()-stime), false) - } - return - case <-time.After(softRequestTimeout): - close(timeout) - case <-self.stop: - return - } - - select { - case <-delivered: - case <-time.After(hardRequestTimeout): - peer.Log().Debug("Request timed out hard") - go self.removePeer(peer.id) - case <-self.stop: - return - } - if self.serverPool != nil { - self.serverPool.adjustResponseTime(peer.poolEntry, time.Duration(mclock.Now()-stime), true) - } -} - -// networkRequest sends a request to known peers until an answer is received -// or the context is cancelled -func (self *LesOdr) networkRequest(ctx context.Context, lreq LesOdrRequest) error { - answered := make(chan struct{}) - req := &sentReq{ - valFunc: lreq.Validate, - sentTo: make(map[*peer]chan struct{}), - answered: answered, // reply delivered by any peer - } - - exclude := make(map[*peer]struct{}) - - reqWg := new(sync.WaitGroup) - reqWg.Add(1) - defer reqWg.Done() - - var timeout chan struct{} - reqID := getNextReqID() + reqID := genReqID() rq := &distReq{ getCost: func(dp distPeer) uint64 { return lreq.GetCost(dp.(*peer)) }, canSend: func(dp distPeer) bool { p := dp.(*peer) - _, ok := exclude[p] - return !ok && lreq.CanSend(p) + return lreq.CanSend(p) }, request: func(dp distPeer) func() { p := dp.(*peer) - exclude[p] = struct{}{} - delivered := make(chan struct{}) - timeout = make(chan struct{}) - req.lock.Lock() - req.sentTo[p] = delivered - req.lock.Unlock() - reqWg.Add(1) cost := lreq.GetCost(p) p.fcServer.QueueRequest(reqID, cost) - go self.requestPeer(req, p, delivered, timeout, reqWg) return func() { lreq.Request(reqID, p) } }, } - self.mlock.Lock() - self.sentReqs[reqID] = req - self.mlock.Unlock() - - go func() { - reqWg.Wait() - self.mlock.Lock() - delete(self.sentReqs, reqID) - self.mlock.Unlock() - }() - - for { - peerChn := self.reqDist.queue(rq) - select { - case <-ctx.Done(): - self.reqDist.cancel(rq) - return ctx.Err() - case <-answered: - self.reqDist.cancel(rq) - return nil - case _, ok := <-peerChn: - if !ok { - return ErrNoPeers - } - } - - select { - case <-ctx.Done(): - return ctx.Err() - case <-answered: - return nil - case <-timeout: - } - } -} - -// Retrieve tries to fetch an object from the LES network. -// If the network retrieval was successful, it stores the object in local db. -func (self *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err error) { - lreq := LesRequest(req) - err = self.networkRequest(ctx, lreq) - if err == nil { + if err = self.retriever.retrieve(ctx, reqID, rq, func(p distPeer, msg *Msg) error { return lreq.Validate(self.db, msg) }); err == nil { // retrieved from network, store in db req.StoreResult(self.db) } else { @@ -251,9 +92,3 @@ func (self *LesOdr) Retrieve(ctx context.Context, req light.OdrRequest) (err err } return } - -func getNextReqID() uint64 { - var rnd [8]byte - rand.Read(rnd[:]) - return binary.BigEndian.Uint64(rnd[:]) -} diff --git a/vendor/github.com/ethereum/go-ethereum/les/peer.go b/vendor/github.com/ethereum/go-ethereum/les/peer.go index ab55bafe3..791d0da24 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/peer.go +++ b/vendor/github.com/ethereum/go-ethereum/les/peer.go @@ -166,9 +166,9 @@ func (p *peer) GetRequestCost(msgcode uint64, amount int) uint64 { // HasBlock checks if the peer has a given block func (p *peer) HasBlock(hash common.Hash, number uint64) bool { p.lock.RLock() - hashBlock := p.hasBlock + hasBlock := p.hasBlock p.lock.RUnlock() - return hashBlock != nil && hashBlock(hash, number) + return hasBlock != nil && hasBlock(hash, number) } // SendAnnounce announces the availability of a number of blocks through @@ -433,12 +433,20 @@ func (p *peer) String() string { ) } +// peerSetNotify is a callback interface to notify services about added or +// removed peers +type peerSetNotify interface { + registerPeer(*peer) + unregisterPeer(*peer) +} + // peerSet represents the collection of active peers currently participating in // the Light Ethereum sub-protocol. type peerSet struct { - peers map[string]*peer - lock sync.RWMutex - closed bool + peers map[string]*peer + lock sync.RWMutex + notifyList []peerSetNotify + closed bool } // newPeerSet creates a new peer set to track the active participants. @@ -448,6 +456,17 @@ func newPeerSet() *peerSet { } } +// notify adds a service to be notified about added or removed peers +func (ps *peerSet) notify(n peerSetNotify) { + ps.lock.Lock() + defer ps.lock.Unlock() + + ps.notifyList = append(ps.notifyList, n) + for _, p := range ps.peers { + go n.registerPeer(p) + } +} + // Register injects a new peer into the working set, or returns an error if the // peer is already known. func (ps *peerSet) Register(p *peer) error { @@ -462,11 +481,14 @@ func (ps *peerSet) Register(p *peer) error { } ps.peers[p.id] = p p.sendQueue = newExecQueue(100) + for _, n := range ps.notifyList { + go n.registerPeer(p) + } return nil } // Unregister removes a remote peer from the active set, disabling any further -// actions to/from that particular entity. +// actions to/from that particular entity. It also initiates disconnection at the networking layer. func (ps *peerSet) Unregister(id string) error { ps.lock.Lock() defer ps.lock.Unlock() @@ -474,7 +496,11 @@ func (ps *peerSet) Unregister(id string) error { if p, ok := ps.peers[id]; !ok { return errNotRegistered } else { + for _, n := range ps.notifyList { + go n.unregisterPeer(p) + } p.sendQueue.quit() + p.Peer.Disconnect(p2p.DiscUselessPeer) } delete(ps.peers, id) return nil diff --git a/vendor/github.com/ethereum/go-ethereum/les/retrieve.go b/vendor/github.com/ethereum/go-ethereum/les/retrieve.go new file mode 100644 index 000000000..b060e0b0d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/les/retrieve.go @@ -0,0 +1,395 @@ +// 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 light implements on-demand retrieval capable state and chain objects +// for the Ethereum Light Client. +package les + +import ( + "context" + "crypto/rand" + "encoding/binary" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common/mclock" +) + +var ( + retryQueue = time.Millisecond * 100 + softRequestTimeout = time.Millisecond * 500 + hardRequestTimeout = time.Second * 10 +) + +// retrieveManager is a layer on top of requestDistributor which takes care of +// matching replies by request ID and handles timeouts and resends if necessary. +type retrieveManager struct { + dist *requestDistributor + peers *peerSet + serverPool peerSelector + + lock sync.RWMutex + sentReqs map[uint64]*sentReq +} + +// validatorFunc is a function that processes a reply message +type validatorFunc func(distPeer, *Msg) error + +// peerSelector receives feedback info about response times and timeouts +type peerSelector interface { + adjustResponseTime(*poolEntry, time.Duration, bool) +} + +// sentReq represents a request sent and tracked by retrieveManager +type sentReq struct { + rm *retrieveManager + req *distReq + id uint64 + validate validatorFunc + + eventsCh chan reqPeerEvent + stopCh chan struct{} + stopped bool + err error + + lock sync.RWMutex // protect access to sentTo map + sentTo map[distPeer]sentReqToPeer + + reqQueued bool // a request has been queued but not sent + reqSent bool // a request has been sent but not timed out + reqSrtoCount int // number of requests that reached soft (but not hard) timeout +} + +// sentReqToPeer notifies the request-from-peer goroutine (tryRequest) about a response +// delivered by the given peer. Only one delivery is allowed per request per peer, +// after which delivered is set to true, the validity of the response is sent on the +// valid channel and no more responses are accepted. +type sentReqToPeer struct { + delivered bool + valid chan bool +} + +// reqPeerEvent is sent by the request-from-peer goroutine (tryRequest) to the +// request state machine (retrieveLoop) through the eventsCh channel. +type reqPeerEvent struct { + event int + peer distPeer +} + +const ( + rpSent = iota // if peer == nil, not sent (no suitable peers) + rpSoftTimeout + rpHardTimeout + rpDeliveredValid + rpDeliveredInvalid +) + +// newRetrieveManager creates the retrieve manager +func newRetrieveManager(peers *peerSet, dist *requestDistributor, serverPool peerSelector) *retrieveManager { + return &retrieveManager{ + peers: peers, + dist: dist, + serverPool: serverPool, + sentReqs: make(map[uint64]*sentReq), + } +} + +// retrieve sends a request (to multiple peers if necessary) and waits for an answer +// that is delivered through the deliver function and successfully validated by the +// validator callback. It returns when a valid answer is delivered or the context is +// cancelled. +func (rm *retrieveManager) retrieve(ctx context.Context, reqID uint64, req *distReq, val validatorFunc) error { + sentReq := rm.sendReq(reqID, req, val) + select { + case <-sentReq.stopCh: + case <-ctx.Done(): + sentReq.stop(ctx.Err()) + } + return sentReq.getError() +} + +// sendReq starts a process that keeps trying to retrieve a valid answer for a +// request from any suitable peers until stopped or succeeded. +func (rm *retrieveManager) sendReq(reqID uint64, req *distReq, val validatorFunc) *sentReq { + r := &sentReq{ + rm: rm, + req: req, + id: reqID, + sentTo: make(map[distPeer]sentReqToPeer), + stopCh: make(chan struct{}), + eventsCh: make(chan reqPeerEvent, 10), + validate: val, + } + + canSend := req.canSend + req.canSend = func(p distPeer) bool { + // add an extra check to canSend: the request has not been sent to the same peer before + r.lock.RLock() + _, sent := r.sentTo[p] + r.lock.RUnlock() + return !sent && canSend(p) + } + + request := req.request + req.request = func(p distPeer) func() { + // before actually sending the request, put an entry into the sentTo map + r.lock.Lock() + r.sentTo[p] = sentReqToPeer{false, make(chan bool, 1)} + r.lock.Unlock() + return request(p) + } + rm.lock.Lock() + rm.sentReqs[reqID] = r + rm.lock.Unlock() + + go r.retrieveLoop() + return r +} + +// deliver is called by the LES protocol manager to deliver reply messages to waiting requests +func (rm *retrieveManager) deliver(peer distPeer, msg *Msg) error { + rm.lock.RLock() + req, ok := rm.sentReqs[msg.ReqID] + rm.lock.RUnlock() + + if ok { + return req.deliver(peer, msg) + } + return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID) +} + +// reqStateFn represents a state of the retrieve loop state machine +type reqStateFn func() reqStateFn + +// retrieveLoop is the retrieval state machine event loop +func (r *sentReq) retrieveLoop() { + go r.tryRequest() + r.reqQueued = true + state := r.stateRequesting + + for state != nil { + state = state() + } + + r.rm.lock.Lock() + delete(r.rm.sentReqs, r.id) + r.rm.lock.Unlock() +} + +// stateRequesting: a request has been queued or sent recently; when it reaches soft timeout, +// a new request is sent to a new peer +func (r *sentReq) stateRequesting() reqStateFn { + select { + case ev := <-r.eventsCh: + r.update(ev) + switch ev.event { + case rpSent: + if ev.peer == nil { + // request send failed, no more suitable peers + if r.waiting() { + // we are already waiting for sent requests which may succeed so keep waiting + return r.stateNoMorePeers + } + // nothing to wait for, no more peers to ask, return with error + r.stop(ErrNoPeers) + // no need to go to stopped state because waiting() already returned false + return nil + } + case rpSoftTimeout: + // last request timed out, try asking a new peer + go r.tryRequest() + r.reqQueued = true + return r.stateRequesting + case rpDeliveredValid: + r.stop(nil) + return r.stateStopped + } + return r.stateRequesting + case <-r.stopCh: + return r.stateStopped + } +} + +// stateNoMorePeers: could not send more requests because no suitable peers are available. +// Peers may become suitable for a certain request later or new peers may appear so we +// keep trying. +func (r *sentReq) stateNoMorePeers() reqStateFn { + select { + case <-time.After(retryQueue): + go r.tryRequest() + r.reqQueued = true + return r.stateRequesting + case ev := <-r.eventsCh: + r.update(ev) + if ev.event == rpDeliveredValid { + r.stop(nil) + return r.stateStopped + } + return r.stateNoMorePeers + case <-r.stopCh: + return r.stateStopped + } +} + +// stateStopped: request succeeded or cancelled, just waiting for some peers +// to either answer or time out hard +func (r *sentReq) stateStopped() reqStateFn { + for r.waiting() { + r.update(<-r.eventsCh) + } + return nil +} + +// update updates the queued/sent flags and timed out peers counter according to the event +func (r *sentReq) update(ev reqPeerEvent) { + switch ev.event { + case rpSent: + r.reqQueued = false + if ev.peer != nil { + r.reqSent = true + } + case rpSoftTimeout: + r.reqSent = false + r.reqSrtoCount++ + case rpHardTimeout, rpDeliveredValid, rpDeliveredInvalid: + r.reqSrtoCount-- + } +} + +// waiting returns true if the retrieval mechanism is waiting for an answer from +// any peer +func (r *sentReq) waiting() bool { + return r.reqQueued || r.reqSent || r.reqSrtoCount > 0 +} + +// tryRequest tries to send the request to a new peer and waits for it to either +// succeed or time out if it has been sent. It also sends the appropriate reqPeerEvent +// messages to the request's event channel. +func (r *sentReq) tryRequest() { + sent := r.rm.dist.queue(r.req) + var p distPeer + select { + case p = <-sent: + case <-r.stopCh: + if r.rm.dist.cancel(r.req) { + p = nil + } else { + p = <-sent + } + } + + r.eventsCh <- reqPeerEvent{rpSent, p} + if p == nil { + return + } + + reqSent := mclock.Now() + srto, hrto := false, false + + r.lock.RLock() + s, ok := r.sentTo[p] + r.lock.RUnlock() + if !ok { + panic(nil) + } + + defer func() { + // send feedback to server pool and remove peer if hard timeout happened + pp, ok := p.(*peer) + if ok && r.rm.serverPool != nil { + respTime := time.Duration(mclock.Now() - reqSent) + r.rm.serverPool.adjustResponseTime(pp.poolEntry, respTime, srto) + } + if hrto { + pp.Log().Debug("Request timed out hard") + if r.rm.peers != nil { + r.rm.peers.Unregister(pp.id) + } + } + + r.lock.Lock() + delete(r.sentTo, p) + r.lock.Unlock() + }() + + select { + case ok := <-s.valid: + if ok { + r.eventsCh <- reqPeerEvent{rpDeliveredValid, p} + } else { + r.eventsCh <- reqPeerEvent{rpDeliveredInvalid, p} + } + return + case <-time.After(softRequestTimeout): + srto = true + r.eventsCh <- reqPeerEvent{rpSoftTimeout, p} + } + + select { + case ok := <-s.valid: + if ok { + r.eventsCh <- reqPeerEvent{rpDeliveredValid, p} + } else { + r.eventsCh <- reqPeerEvent{rpDeliveredInvalid, p} + } + case <-time.After(hardRequestTimeout): + hrto = true + r.eventsCh <- reqPeerEvent{rpHardTimeout, p} + } +} + +// deliver a reply belonging to this request +func (r *sentReq) deliver(peer distPeer, msg *Msg) error { + r.lock.Lock() + defer r.lock.Unlock() + + s, ok := r.sentTo[peer] + if !ok || s.delivered { + return errResp(ErrUnexpectedResponse, "reqID = %v", msg.ReqID) + } + valid := r.validate(peer, msg) == nil + r.sentTo[peer] = sentReqToPeer{true, s.valid} + s.valid <- valid + if !valid { + return errResp(ErrInvalidResponse, "reqID = %v", msg.ReqID) + } + return nil +} + +// stop stops the retrieval process and sets an error code that will be returned +// by getError +func (r *sentReq) stop(err error) { + r.lock.Lock() + if !r.stopped { + r.stopped = true + r.err = err + close(r.stopCh) + } + r.lock.Unlock() +} + +// getError returns any retrieval error (either internally generated or set by the +// stop function) after stopCh has been closed +func (r *sentReq) getError() error { + return r.err +} + +// genReqID generates a new random request ID +func genReqID() uint64 { + var rnd [8]byte + rand.Read(rnd[:]) + return binary.BigEndian.Uint64(rnd[:]) +} diff --git a/vendor/github.com/ethereum/go-ethereum/les/server.go b/vendor/github.com/ethereum/go-ethereum/les/server.go index 22fe59b7a..2ff715ea8 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/server.go +++ b/vendor/github.com/ethereum/go-ethereum/les/server.go @@ -32,6 +32,7 @@ import ( "github.com/ethereum/go-ethereum/light" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p" + "github.com/ethereum/go-ethereum/p2p/discv5" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/trie" ) @@ -41,17 +42,24 @@ type LesServer struct { fcManager *flowcontrol.ClientManager // nil if our node is client only fcCostStats *requestCostStats defParams *flowcontrol.ServerParams + lesTopic discv5.Topic + quitSync chan struct{} stopped bool } func NewLesServer(eth *eth.Ethereum, config *eth.Config) (*LesServer, error) { - pm, err := NewProtocolManager(eth.BlockChain().Config(), false, config.NetworkId, eth.EventMux(), eth.Engine(), eth.BlockChain(), eth.TxPool(), eth.ChainDb(), nil, nil) + quitSync := make(chan struct{}) + pm, err := NewProtocolManager(eth.BlockChain().Config(), false, config.NetworkId, eth.EventMux(), eth.Engine(), newPeerSet(), eth.BlockChain(), eth.TxPool(), eth.ChainDb(), nil, nil, quitSync, new(sync.WaitGroup)) if err != nil { return nil, err } pm.blockLoop() - srv := &LesServer{protocolManager: pm} + srv := &LesServer{ + protocolManager: pm, + quitSync: quitSync, + lesTopic: lesTopic(eth.BlockChain().Genesis().Hash()), + } pm.server = srv srv.defParams = &flowcontrol.ServerParams{ @@ -69,7 +77,14 @@ func (s *LesServer) Protocols() []p2p.Protocol { // Start starts the LES server func (s *LesServer) Start(srvr *p2p.Server) { - s.protocolManager.Start(srvr) + s.protocolManager.Start() + go func() { + logger := log.New("topic", s.lesTopic) + logger.Info("Starting topic registration") + defer logger.Info("Terminated topic registration") + + srvr.DiscV5.RegisterTopic(s.lesTopic, s.quitSync) + }() } // Stop stops the LES service diff --git a/vendor/github.com/ethereum/go-ethereum/les/serverpool.go b/vendor/github.com/ethereum/go-ethereum/les/serverpool.go index 64fe991c6..f4e4df2fb 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/serverpool.go +++ b/vendor/github.com/ethereum/go-ethereum/les/serverpool.go @@ -102,6 +102,8 @@ type serverPool struct { wg *sync.WaitGroup connWg sync.WaitGroup + topic discv5.Topic + discSetPeriod chan time.Duration discNodes chan *discv5.Node discLookups chan bool @@ -118,11 +120,9 @@ type serverPool struct { } // newServerPool creates a new serverPool instance -func newServerPool(db ethdb.Database, dbPrefix []byte, server *p2p.Server, topic discv5.Topic, quit chan struct{}, wg *sync.WaitGroup) *serverPool { +func newServerPool(db ethdb.Database, quit chan struct{}, wg *sync.WaitGroup) *serverPool { pool := &serverPool{ db: db, - dbKey: append(dbPrefix, []byte(topic)...), - server: server, quit: quit, wg: wg, entries: make(map[discover.NodeID]*poolEntry), @@ -135,19 +135,25 @@ func newServerPool(db ethdb.Database, dbPrefix []byte, server *p2p.Server, topic } pool.knownQueue = newPoolEntryQueue(maxKnownEntries, pool.removeEntry) pool.newQueue = newPoolEntryQueue(maxNewEntries, pool.removeEntry) - wg.Add(1) - pool.loadNodes() - pool.checkDial() + return pool +} +func (pool *serverPool) start(server *p2p.Server, topic discv5.Topic) { + pool.server = server + pool.topic = topic + pool.dbKey = append([]byte("serverPool/"), []byte(topic)...) + pool.wg.Add(1) + pool.loadNodes() + + go pool.eventLoop() + + pool.checkDial() if pool.server.DiscV5 != nil { pool.discSetPeriod = make(chan time.Duration, 1) pool.discNodes = make(chan *discv5.Node, 100) pool.discLookups = make(chan bool, 100) - go pool.server.DiscV5.SearchTopic(topic, pool.discSetPeriod, pool.discNodes, pool.discLookups) + go pool.server.DiscV5.SearchTopic(pool.topic, pool.discSetPeriod, pool.discNodes, pool.discLookups) } - - go pool.eventLoop() - return pool } // connect should be called upon any incoming connection. If the connection has been @@ -485,7 +491,7 @@ func (pool *serverPool) checkDial() { // dial initiates a new connection func (pool *serverPool) dial(entry *poolEntry, knownSelected bool) { - if entry.state != psNotConnected { + if pool.server == nil || entry.state != psNotConnected { return } entry.state = psDialed diff --git a/vendor/github.com/ethereum/go-ethereum/les/status/txqueue.go b/vendor/github.com/ethereum/go-ethereum/les/status/txqueue.go index 32650106b..1ca48ad0a 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/status/txqueue.go +++ b/vendor/github.com/ethereum/go-ethereum/les/status/txqueue.go @@ -2,6 +2,8 @@ package status import ( "errors" + "os" + "runtime/debug" "sync" "time" @@ -105,8 +107,18 @@ func (q *TxQueue) Stop() { q.stoppedGroup.Wait() } +// HaltOnPanic recovers from panic, logs issue, and exits +func HaltOnPanic() { + if r := recover(); r != nil { + log.Error("Runtime PANIC!!!", "error", r, "stack", string(debug.Stack())) + time.Sleep(5 * time.Second) // allow logger to flush logs + os.Exit(1) + } +} + // evictionLoop frees up queue to accommodate another transaction item func (q *TxQueue) evictionLoop() { + defer HaltOnPanic() evict := func() { if len(q.transactions) >= DefaultTxQueueCap { // eviction is required to accommodate another/last item q.Remove(<-q.evictableIDs) @@ -129,6 +141,8 @@ func (q *TxQueue) evictionLoop() { // enqueueLoop process incoming enqueue requests func (q *TxQueue) enqueueLoop() { + defer HaltOnPanic() + // enqueue incoming transactions for { select { diff --git a/vendor/github.com/ethereum/go-ethereum/les/txrelay.go b/vendor/github.com/ethereum/go-ethereum/les/txrelay.go index 1ca3467e4..7a02cc837 100644 --- a/vendor/github.com/ethereum/go-ethereum/les/txrelay.go +++ b/vendor/github.com/ethereum/go-ethereum/les/txrelay.go @@ -39,26 +39,28 @@ type LesTxRelay struct { reqDist *requestDistributor } -func NewLesTxRelay() *LesTxRelay { - return &LesTxRelay{ +func NewLesTxRelay(ps *peerSet, reqDist *requestDistributor) *LesTxRelay { + r := &LesTxRelay{ txSent: make(map[common.Hash]*ltrInfo), txPending: make(map[common.Hash]struct{}), + ps: ps, + reqDist: reqDist, } + ps.notify(r) + return r } -func (self *LesTxRelay) addPeer(p *peer) { +func (self *LesTxRelay) registerPeer(p *peer) { self.lock.Lock() defer self.lock.Unlock() - self.ps.Register(p) self.peerList = self.ps.AllPeers() } -func (self *LesTxRelay) removePeer(id string) { +func (self *LesTxRelay) unregisterPeer(p *peer) { self.lock.Lock() defer self.lock.Unlock() - self.ps.Unregister(id) self.peerList = self.ps.AllPeers() } @@ -112,7 +114,7 @@ func (self *LesTxRelay) send(txs types.Transactions, count int) { pp := p ll := list - reqID := getNextReqID() + reqID := genReqID() rq := &distReq{ getCost: func(dp distPeer) uint64 { peer := dp.(*peer) diff --git a/vendor/github.com/ethereum/go-ethereum/light/lightchain.go b/vendor/github.com/ethereum/go-ethereum/light/lightchain.go index 5b7e57041..8bbf529cc 100644 --- a/vendor/github.com/ethereum/go-ethereum/light/lightchain.go +++ b/vendor/github.com/ethereum/go-ethereum/light/lightchain.go @@ -94,7 +94,7 @@ func NewLightChain(odr OdrBackend, config *params.ChainConfig, engine consensus. if bc.genesisBlock == nil { return nil, core.ErrNoGenesis } - if bc.genesisBlock.Hash() == params.MainNetGenesisHash { + if bc.genesisBlock.Hash() == params.MainnetGenesisHash { // add trusted CHT WriteTrustedCht(bc.chainDb, TrustedCht{Number: 805, Root: common.HexToHash("85e4286fe0a730390245c49de8476977afdae0eb5530b277f62a52b12313d50f")}) log.Info("Added trusted CHT for mainnet") @@ -180,11 +180,6 @@ func (self *LightChain) Status() (td *big.Int, currentBlock common.Hash, genesis return self.GetTd(hash, header.Number.Uint64()), hash, self.genesisBlock.Hash() } -// State returns a new mutable state based on the current HEAD block. -func (self *LightChain) State() *LightState { - return NewLightState(StateTrieID(self.hc.CurrentHeader()), self.odr) -} - // Reset purges the entire blockchain, restoring it to its genesis state. func (bc *LightChain) Reset() { bc.ResetWithGenesisBlock(bc.genesisBlock) diff --git a/vendor/github.com/ethereum/go-ethereum/light/odr.go b/vendor/github.com/ethereum/go-ethereum/light/odr.go index ca6364f28..d19a488f6 100644 --- a/vendor/github.com/ethereum/go-ethereum/light/odr.go +++ b/vendor/github.com/ethereum/go-ethereum/light/odr.go @@ -34,7 +34,7 @@ import ( // service is not required. var NoOdr = context.Background() -// OdrBackend is an interface to a backend service that handles ODR retrievals +// OdrBackend is an interface to a backend service that handles ODR retrievals type type OdrBackend interface { Database() ethdb.Database Retrieve(ctx context.Context, req OdrRequest) error @@ -66,11 +66,11 @@ func StateTrieID(header *types.Header) *TrieID { // StorageTrieID returns a TrieID for a contract storage trie at a given account // of a given state trie. It also requires the root hash of the trie for // checking Merkle proofs. -func StorageTrieID(state *TrieID, addr common.Address, root common.Hash) *TrieID { +func StorageTrieID(state *TrieID, addrHash, root common.Hash) *TrieID { return &TrieID{ BlockHash: state.BlockHash, BlockNumber: state.BlockNumber, - AccKey: crypto.Keccak256(addr[:]), + AccKey: addrHash[:], Root: root, } } @@ -102,7 +102,7 @@ func storeProof(db ethdb.Database, proof []rlp.RawValue) { // CodeRequest is the ODR request type for retrieving contract code type CodeRequest struct { OdrRequest - Id *TrieID + Id *TrieID // references storage trie of the account Hash common.Hash Data []byte } diff --git a/vendor/github.com/ethereum/go-ethereum/light/odr_util.go b/vendor/github.com/ethereum/go-ethereum/light/odr_util.go index d7f8458f1..fcdfdb82c 100644 --- a/vendor/github.com/ethereum/go-ethereum/light/odr_util.go +++ b/vendor/github.com/ethereum/go-ethereum/light/odr_util.go @@ -106,25 +106,6 @@ func GetCanonicalHash(ctx context.Context, odr OdrBackend, number uint64) (commo return common.Hash{}, err } -// retrieveContractCode tries to retrieve the contract code of the given account -// with the given hash from the network (id points to the storage trie belonging -// to the same account) -func retrieveContractCode(ctx context.Context, odr OdrBackend, id *TrieID, hash common.Hash) ([]byte, error) { - if hash == sha3_nil { - return nil, nil - } - res, _ := odr.Database().Get(hash[:]) - if res != nil { - return res, nil - } - r := &CodeRequest{Id: id, Hash: hash} - if err := odr.Retrieve(ctx, r); err != nil { - return nil, err - } else { - return r.Data, nil - } -} - // GetBodyRLP retrieves the block body (transactions and uncles) in RLP encoding. func GetBodyRLP(ctx context.Context, odr OdrBackend, hash common.Hash, number uint64) (rlp.RawValue, error) { if data := core.GetBodyRLP(odr.Database(), hash, number); data != nil { diff --git a/vendor/github.com/ethereum/go-ethereum/light/state.go b/vendor/github.com/ethereum/go-ethereum/light/state.go deleted file mode 100644 index b184dc3a5..000000000 --- a/vendor/github.com/ethereum/go-ethereum/light/state.go +++ /dev/null @@ -1,316 +0,0 @@ -// Copyright 2015 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 light - -import ( - "context" - "math/big" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" -) - -// LightState is a memory representation of a state. -// This version is ODR capable, caching only the already accessed part of the -// state, retrieving unknown parts on-demand from the ODR backend. Changes are -// never stored in the local database, only in the memory objects. -type LightState struct { - odr OdrBackend - trie *LightTrie - id *TrieID - stateObjects map[string]*StateObject - refund *big.Int -} - -// NewLightState creates a new LightState with the specified root. -// Note that the creation of a light state is always successful, even if the -// root is non-existent. In that case, ODR retrieval will always be unsuccessful -// and every operation will return with an error or wait for the context to be -// cancelled. -func NewLightState(id *TrieID, odr OdrBackend) *LightState { - var tr *LightTrie - if id != nil { - tr = NewLightTrie(id, odr, true) - } - return &LightState{ - odr: odr, - trie: tr, - id: id, - stateObjects: make(map[string]*StateObject), - refund: new(big.Int), - } -} - -// AddRefund adds an amount to the refund value collected during a vm execution -func (self *LightState) AddRefund(gas *big.Int) { - self.refund.Add(self.refund, gas) -} - -// HasAccount returns true if an account exists at the given address -func (self *LightState) HasAccount(ctx context.Context, addr common.Address) (bool, error) { - so, err := self.GetStateObject(ctx, addr) - return so != nil, err -} - -// GetBalance retrieves the balance from the given address or 0 if the account does -// not exist -func (self *LightState) GetBalance(ctx context.Context, addr common.Address) (*big.Int, error) { - stateObject, err := self.GetStateObject(ctx, addr) - if err != nil { - return common.Big0, err - } - if stateObject != nil { - return stateObject.balance, nil - } - - return common.Big0, nil -} - -// GetNonce returns the nonce at the given address or 0 if the account does -// not exist -func (self *LightState) GetNonce(ctx context.Context, addr common.Address) (uint64, error) { - stateObject, err := self.GetStateObject(ctx, addr) - if err != nil { - return 0, err - } - if stateObject != nil { - return stateObject.nonce, nil - } - return 0, nil -} - -// GetCode returns the contract code at the given address or nil if the account -// does not exist -func (self *LightState) GetCode(ctx context.Context, addr common.Address) ([]byte, error) { - stateObject, err := self.GetStateObject(ctx, addr) - if err != nil { - return nil, err - } - if stateObject != nil { - return stateObject.code, nil - } - return nil, nil -} - -// GetState returns the contract storage value at storage address b from the -// contract address a or common.Hash{} if the account does not exist -func (self *LightState) GetState(ctx context.Context, a common.Address, b common.Hash) (common.Hash, error) { - stateObject, err := self.GetStateObject(ctx, a) - if err == nil && stateObject != nil { - return stateObject.GetState(ctx, b) - } - return common.Hash{}, err -} - -// HasSuicided returns true if the given account has been marked for deletion -// or false if the account does not exist -func (self *LightState) HasSuicided(ctx context.Context, addr common.Address) (bool, error) { - stateObject, err := self.GetStateObject(ctx, addr) - if err == nil && stateObject != nil { - return stateObject.remove, nil - } - return false, err -} - -/* - * SETTERS - */ - -// AddBalance adds the given amount to the balance of the specified account -func (self *LightState) AddBalance(ctx context.Context, addr common.Address, amount *big.Int) error { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.AddBalance(amount) - } - return err -} - -// SubBalance adds the given amount to the balance of the specified account -func (self *LightState) SubBalance(ctx context.Context, addr common.Address, amount *big.Int) error { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.SubBalance(amount) - } - return err -} - -// SetNonce sets the nonce of the specified account -func (self *LightState) SetNonce(ctx context.Context, addr common.Address, nonce uint64) error { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.SetNonce(nonce) - } - return err -} - -// SetCode sets the contract code at the specified account -func (self *LightState) SetCode(ctx context.Context, addr common.Address, code []byte) error { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.SetCode(crypto.Keccak256Hash(code), code) - } - return err -} - -// SetState sets the storage value at storage address key of the account addr -func (self *LightState) SetState(ctx context.Context, addr common.Address, key common.Hash, value common.Hash) error { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.SetState(key, value) - } - return err -} - -// Delete marks an account to be removed and clears its balance -func (self *LightState) Suicide(ctx context.Context, addr common.Address) (bool, error) { - stateObject, err := self.GetOrNewStateObject(ctx, addr) - if err == nil && stateObject != nil { - stateObject.MarkForDeletion() - stateObject.balance = new(big.Int) - - return true, nil - } - - return false, err -} - -// -// Get, set, new state object methods -// - -// GetStateObject returns the state object of the given account or nil if the -// account does not exist -func (self *LightState) GetStateObject(ctx context.Context, addr common.Address) (stateObject *StateObject, err error) { - stateObject = self.stateObjects[addr.Str()] - if stateObject != nil { - if stateObject.deleted { - stateObject = nil - } - return stateObject, nil - } - data, err := self.trie.Get(ctx, addr[:]) - if err != nil { - return nil, err - } - if len(data) == 0 { - return nil, nil - } - - stateObject, err = DecodeObject(ctx, self.id, addr, self.odr, []byte(data)) - if err != nil { - return nil, err - } - - self.SetStateObject(stateObject) - - return stateObject, nil -} - -// SetStateObject sets the state object of the given account -func (self *LightState) SetStateObject(object *StateObject) { - self.stateObjects[object.Address().Str()] = object -} - -// GetOrNewStateObject returns the state object of the given account or creates a -// new one if the account does not exist -func (self *LightState) GetOrNewStateObject(ctx context.Context, addr common.Address) (*StateObject, error) { - stateObject, err := self.GetStateObject(ctx, addr) - if err == nil && (stateObject == nil || stateObject.deleted) { - stateObject, err = self.CreateStateObject(ctx, addr) - } - return stateObject, err -} - -// newStateObject creates a state object whether it exists in the state or not -func (self *LightState) newStateObject(addr common.Address) *StateObject { - stateObject := NewStateObject(addr, self.odr) - self.stateObjects[addr.Str()] = stateObject - - return stateObject -} - -// CreateStateObject creates creates a new state object and takes ownership. -// This is different from "NewStateObject" -func (self *LightState) CreateStateObject(ctx context.Context, addr common.Address) (*StateObject, error) { - // Get previous (if any) - so, err := self.GetStateObject(ctx, addr) - if err != nil { - return nil, err - } - // Create a new one - newSo := self.newStateObject(addr) - - // If it existed set the balance to the new account - if so != nil { - newSo.balance = so.balance - } - - return newSo, nil -} - -// ForEachStorage calls a callback function for every key/value pair found -// in the local storage cache. Note that unlike core/state.StateObject, -// light.StateObject only returns cached values and doesn't download the -// entire storage tree. -func (self *LightState) ForEachStorage(ctx context.Context, addr common.Address, cb func(key, value common.Hash) bool) error { - so, err := self.GetStateObject(ctx, addr) - if err != nil { - return err - } - - if so == nil { - return nil - } - - for h, v := range so.storage { - cb(h, v) - } - return nil -} - -// -// Setting, copying of the state methods -// - -// Copy creates a copy of the state -func (self *LightState) Copy() *LightState { - // ignore error - we assume state-to-be-copied always exists - state := NewLightState(nil, self.odr) - state.trie = self.trie - state.id = self.id - for k, stateObject := range self.stateObjects { - if stateObject.dirty { - state.stateObjects[k] = stateObject.Copy() - } - } - - state.refund.Set(self.refund) - return state -} - -// Set copies the contents of the given state onto this state, overwriting -// its contents -func (self *LightState) Set(state *LightState) { - self.trie = state.trie - self.stateObjects = state.stateObjects - self.refund = state.refund -} - -// GetRefund returns the refund value collected during a vm execution -func (self *LightState) GetRefund() *big.Int { - return self.refund -} diff --git a/vendor/github.com/ethereum/go-ethereum/light/state_object.go b/vendor/github.com/ethereum/go-ethereum/light/state_object.go deleted file mode 100644 index a54ea1d9f..000000000 --- a/vendor/github.com/ethereum/go-ethereum/light/state_object.go +++ /dev/null @@ -1,275 +0,0 @@ -// Copyright 2015 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 light - -import ( - "bytes" - "context" - "fmt" - "math/big" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/rlp" -) - -var emptyCodeHash = crypto.Keccak256(nil) - -// Code represents a contract code in binary form -type Code []byte - -// String returns a string representation of the code -func (self Code) String() string { - return string(self) //strings.Join(Disassemble(self), " ") -} - -// Storage is a memory map cache of a contract storage -type Storage map[common.Hash]common.Hash - -// String returns a string representation of the storage cache -func (self Storage) String() (str string) { - for key, value := range self { - str += fmt.Sprintf("%X : %X\n", key, value) - } - - return -} - -// Copy copies the contents of a storage cache -func (self Storage) Copy() Storage { - cpy := make(Storage) - for key, value := range self { - cpy[key] = value - } - - return cpy -} - -// StateObject is a memory representation of an account or contract and its storage. -// This version is ODR capable, caching only the already accessed part of the -// storage, retrieving unknown parts on-demand from the ODR backend. Changes are -// never stored in the local database, only in the memory objects. -type StateObject struct { - odr OdrBackend - trie *LightTrie - - // Address belonging to this account - address common.Address - // The balance of the account - balance *big.Int - // The nonce of the account - nonce uint64 - // The code hash if code is present (i.e. a contract) - codeHash []byte - // The code for this account - code Code - // Cached storage (flushed when updated) - storage Storage - - // Mark for deletion - // When an object is marked for deletion it will be delete from the trie - // during the "update" phase of the state transition - remove bool - deleted bool - dirty bool -} - -// NewStateObject creates a new StateObject of the specified account address -func NewStateObject(address common.Address, odr OdrBackend) *StateObject { - object := &StateObject{ - odr: odr, - address: address, - balance: new(big.Int), - dirty: true, - codeHash: emptyCodeHash, - storage: make(Storage), - } - object.trie = NewLightTrie(&TrieID{}, odr, true) - return object -} - -// MarkForDeletion marks an account to be removed -func (self *StateObject) MarkForDeletion() { - self.remove = true - self.dirty = true -} - -// getAddr gets the storage value at the given address from the trie -func (c *StateObject) getAddr(ctx context.Context, addr common.Hash) (common.Hash, error) { - var ret []byte - val, err := c.trie.Get(ctx, addr[:]) - if err != nil { - return common.Hash{}, err - } - rlp.DecodeBytes(val, &ret) - return common.BytesToHash(ret), nil -} - -// Storage returns the storage cache object of the account -func (self *StateObject) Storage() Storage { - return self.storage -} - -// GetState returns the storage value at the given address from either the cache -// or the trie -func (self *StateObject) GetState(ctx context.Context, key common.Hash) (common.Hash, error) { - value, exists := self.storage[key] - if !exists { - var err error - value, err = self.getAddr(ctx, key) - if err != nil { - return common.Hash{}, err - } - if (value != common.Hash{}) { - self.storage[key] = value - } - } - - return value, nil -} - -// SetState sets the storage value at the given address -func (self *StateObject) SetState(k, value common.Hash) { - self.storage[k] = value - self.dirty = true -} - -// AddBalance adds the given amount to the account balance -func (c *StateObject) AddBalance(amount *big.Int) { - c.SetBalance(new(big.Int).Add(c.balance, amount)) -} - -// SubBalance subtracts the given amount from the account balance -func (c *StateObject) SubBalance(amount *big.Int) { - c.SetBalance(new(big.Int).Sub(c.balance, amount)) -} - -// SetBalance sets the account balance to the given amount -func (c *StateObject) SetBalance(amount *big.Int) { - c.balance = amount - c.dirty = true -} - -// ReturnGas returns the gas back to the origin. Used by the Virtual machine or Closures -func (c *StateObject) ReturnGas(gas *big.Int) {} - -// Copy creates a copy of the state object -func (self *StateObject) Copy() *StateObject { - stateObject := NewStateObject(self.Address(), self.odr) - stateObject.balance.Set(self.balance) - stateObject.codeHash = common.CopyBytes(self.codeHash) - stateObject.nonce = self.nonce - stateObject.trie = self.trie - stateObject.code = self.code - stateObject.storage = self.storage.Copy() - stateObject.remove = self.remove - stateObject.dirty = self.dirty - stateObject.deleted = self.deleted - - return stateObject -} - -// -// Attribute accessors -// - -// empty returns whether the account is considered empty. -func (self *StateObject) empty() bool { - return self.nonce == 0 && self.balance.Sign() == 0 && bytes.Equal(self.codeHash, emptyCodeHash) -} - -// Balance returns the account balance -func (self *StateObject) Balance() *big.Int { - return self.balance -} - -// Address returns the address of the contract/account -func (self *StateObject) Address() common.Address { - return self.address -} - -// Code returns the contract code -func (self *StateObject) Code() []byte { - return self.code -} - -// SetCode sets the contract code -func (self *StateObject) SetCode(hash common.Hash, code []byte) { - self.code = code - self.codeHash = hash[:] - self.dirty = true -} - -// SetNonce sets the account nonce -func (self *StateObject) SetNonce(nonce uint64) { - self.nonce = nonce - self.dirty = true -} - -// Nonce returns the account nonce -func (self *StateObject) Nonce() uint64 { - return self.nonce -} - -// ForEachStorage calls a callback function for every key/value pair found -// in the local storage cache. Note that unlike core/state.StateObject, -// light.StateObject only returns cached values and doesn't download the -// entire storage tree. -func (self *StateObject) ForEachStorage(cb func(key, value common.Hash) bool) { - for h, v := range self.storage { - cb(h, v) - } -} - -// Never called, but must be present to allow StateObject to be used -// as a vm.Account interface that also satisfies the vm.ContractRef -// interface. Interfaces are awesome. -func (self *StateObject) Value() *big.Int { - panic("Value on StateObject should never be called") -} - -// Encoding - -type extStateObject struct { - Nonce uint64 - Balance *big.Int - Root common.Hash - CodeHash []byte -} - -// DecodeObject decodes an RLP-encoded state object. -func DecodeObject(ctx context.Context, stateID *TrieID, address common.Address, odr OdrBackend, data []byte) (*StateObject, error) { - var ( - obj = &StateObject{address: address, odr: odr, storage: make(Storage)} - ext extStateObject - err error - ) - if err = rlp.DecodeBytes(data, &ext); err != nil { - return nil, err - } - trieID := StorageTrieID(stateID, address, ext.Root) - obj.trie = NewLightTrie(trieID, odr, true) - if !bytes.Equal(ext.CodeHash, emptyCodeHash) { - if obj.code, err = retrieveContractCode(ctx, obj.odr, trieID, common.BytesToHash(ext.CodeHash)); err != nil { - return nil, fmt.Errorf("can't find code for hash %x: %v", ext.CodeHash, err) - } - } - obj.nonce = ext.Nonce - obj.balance = ext.Balance - obj.codeHash = ext.CodeHash - return obj, nil -} diff --git a/vendor/github.com/ethereum/go-ethereum/light/trie.go b/vendor/github.com/ethereum/go-ethereum/light/trie.go index 2988a16cf..7502b6e5d 100644 --- a/vendor/github.com/ethereum/go-ethereum/light/trie.go +++ b/vendor/github.com/ethereum/go-ethereum/light/trie.go @@ -18,99 +18,216 @@ package light import ( "context" + "fmt" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/crypto" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/trie" ) -// LightTrie is an ODR-capable wrapper around trie.SecureTrie -type LightTrie struct { - trie *trie.SecureTrie - id *TrieID - odr OdrBackend - db ethdb.Database +func NewState(ctx context.Context, head *types.Header, odr OdrBackend) *state.StateDB { + state, _ := state.New(head.Root, NewStateDatabase(ctx, head, odr)) + return state } -// NewLightTrie creates a new LightTrie instance. It doesn't instantly try to -// access the db or network and retrieve the root node, it only initializes its -// encapsulated SecureTrie at the first actual operation. -func NewLightTrie(id *TrieID, odr OdrBackend, useFakeMap bool) *LightTrie { - return &LightTrie{ - // SecureTrie is initialized before first request - id: id, - odr: odr, - db: odr.Database(), +func NewStateDatabase(ctx context.Context, head *types.Header, odr OdrBackend) state.Database { + return &odrDatabase{ctx, StateTrieID(head), odr} +} + +type odrDatabase struct { + ctx context.Context + id *TrieID + backend OdrBackend +} + +func (db *odrDatabase) OpenTrie(root common.Hash) (state.Trie, error) { + return &odrTrie{db: db, id: db.id}, nil +} + +func (db *odrDatabase) OpenStorageTrie(addrHash, root common.Hash) (state.Trie, error) { + return &odrTrie{db: db, id: StorageTrieID(db.id, addrHash, root)}, nil +} + +func (db *odrDatabase) CopyTrie(t state.Trie) state.Trie { + switch t := t.(type) { + case *odrTrie: + cpy := &odrTrie{db: t.db, id: t.id} + if t.trie != nil { + cpytrie := *t.trie + cpy.trie = &cpytrie + } + return cpy + default: + panic(fmt.Errorf("unknown trie type %T", t)) } } -// retrieveKey retrieves a single key, returns true and stores nodes in local -// database if successful -func (t *LightTrie) retrieveKey(ctx context.Context, key []byte) bool { - r := &TrieRequest{Id: t.id, Key: crypto.Keccak256(key)} - return t.odr.Retrieve(ctx, r) == nil +func (db *odrDatabase) ContractCode(addrHash, codeHash common.Hash) ([]byte, error) { + if codeHash == sha3_nil { + return nil, nil + } + if code, err := db.backend.Database().Get(codeHash[:]); err == nil { + return code, nil + } + id := *db.id + id.AccKey = addrHash[:] + req := &CodeRequest{Id: &id, Hash: codeHash} + err := db.backend.Retrieve(db.ctx, req) + return req.Data, err +} + +func (db *odrDatabase) ContractCodeSize(addrHash, codeHash common.Hash) (int, error) { + code, err := db.ContractCode(addrHash, codeHash) + return len(code), err +} + +type odrTrie struct { + db *odrDatabase + id *TrieID + trie *trie.Trie +} + +func (t *odrTrie) TryGet(key []byte) ([]byte, error) { + key = crypto.Keccak256(key) + var res []byte + err := t.do(key, func() (err error) { + res, err = t.trie.TryGet(key) + return err + }) + return res, err +} + +func (t *odrTrie) TryUpdate(key, value []byte) error { + key = crypto.Keccak256(key) + return t.do(key, func() error { + return t.trie.TryDelete(key) + }) +} + +func (t *odrTrie) TryDelete(key []byte) error { + key = crypto.Keccak256(key) + return t.do(key, func() error { + return t.trie.TryDelete(key) + }) +} + +func (t *odrTrie) CommitTo(db trie.DatabaseWriter) (common.Hash, error) { + if t.trie == nil { + return t.id.Root, nil + } + return t.trie.CommitTo(db) +} + +func (t *odrTrie) Hash() common.Hash { + if t.trie == nil { + return t.id.Root + } + return t.trie.Hash() +} + +func (t *odrTrie) NodeIterator(startkey []byte) trie.NodeIterator { + return newNodeIterator(t, startkey) +} + +func (t *odrTrie) GetKey(sha []byte) []byte { + return nil } // do tries and retries to execute a function until it returns with no error or // an error type other than MissingNodeError -func (t *LightTrie) do(ctx context.Context, key []byte, fn func() error) error { - err := fn() - for err != nil { +func (t *odrTrie) do(key []byte, fn func() error) error { + for { + var err error + if t.trie == nil { + t.trie, err = trie.New(t.id.Root, t.db.backend.Database()) + } + if err == nil { + err = fn() + } if _, ok := err.(*trie.MissingNodeError); !ok { return err } - if !t.retrieveKey(ctx, key) { - break + 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) } - err = fn() } - return err } -// Get returns the value for key stored in the trie. -// The value bytes must not be modified by the caller. -func (t *LightTrie) Get(ctx context.Context, key []byte) (res []byte, err error) { - err = t.do(ctx, key, func() (err error) { - if t.trie == nil { - t.trie, err = trie.NewSecure(t.id.Root, t.db, 0) - } - if err == nil { - res, err = t.trie.TryGet(key) - } - return - }) - return +type nodeIterator struct { + trie.NodeIterator + t *odrTrie + err error } -// Update associates key with value in the trie. Subsequent calls to -// Get will return value. If value has length zero, any existing value -// is deleted from the trie and calls to Get will return nil. -// -// The value bytes must not be modified by the caller while they are -// stored in the trie. -func (t *LightTrie) Update(ctx context.Context, key, value []byte) (err error) { - err = t.do(ctx, key, func() (err error) { - if t.trie == nil { - t.trie, err = trie.NewSecure(t.id.Root, t.db, 0) - } - if err == nil { - err = t.trie.TryUpdate(key, value) - } - return +func newNodeIterator(t *odrTrie, startkey []byte) trie.NodeIterator { + it := &nodeIterator{t: t} + // Open the actual non-ODR trie if that hasn't happened yet. + if t.trie == nil { + it.do(func() error { + t, err := trie.New(t.id.Root, t.db.backend.Database()) + if err == nil { + it.t.trie = t + } + return err + }) + } + it.do(func() error { + it.NodeIterator = it.t.trie.NodeIterator(startkey) + return it.NodeIterator.Error() }) - return + return it } -// Delete removes any existing value for key from the trie. -func (t *LightTrie) Delete(ctx context.Context, key []byte) (err error) { - err = t.do(ctx, key, func() (err error) { - if t.trie == nil { - t.trie, err = trie.NewSecure(t.id.Root, t.db, 0) - } - if err == nil { - err = t.trie.TryDelete(key) - } - return +func (it *nodeIterator) Next(descend bool) bool { + var ok bool + it.do(func() error { + ok = it.NodeIterator.Next(descend) + return it.NodeIterator.Error() }) - return + return ok +} + +// do runs fn and attempts to fill in missing nodes by retrieving. +func (it *nodeIterator) do(fn func() error) { + var lasthash common.Hash + for { + it.err = fn() + missing, ok := it.err.(*trie.MissingNodeError) + if !ok { + return + } + if missing.NodeHash == lasthash { + it.err = fmt.Errorf("retrieve loop for trie node %x", missing.NodeHash) + return + } + lasthash = missing.NodeHash + r := &TrieRequest{Id: it.t.id, Key: nibblesToKey(missing.Path)} + if it.err = it.t.db.backend.Retrieve(it.t.db.ctx, r); it.err != nil { + return + } + } +} + +func (it *nodeIterator) Error() error { + if it.err != nil { + return it.err + } + return it.NodeIterator.Error() +} + +func nibblesToKey(nib []byte) []byte { + if len(nib) > 0 && nib[len(nib)-1] == 0x10 { + nib = nib[:len(nib)-1] // drop terminator + } + if len(nib)&1 == 1 { + nib = append(nib, 0) // make even + } + key := make([]byte, len(nib)/2) + for bi, ni := 0, 0; ni < len(nib); bi, ni = bi+1, ni+2 { + key[bi] = nib[ni]<<4 | nib[ni+1] + } + return key } diff --git a/vendor/github.com/ethereum/go-ethereum/light/txpool.go b/vendor/github.com/ethereum/go-ethereum/light/txpool.go index 06bd7b81c..4de5daf41 100644 --- a/vendor/github.com/ethereum/go-ethereum/light/txpool.go +++ b/vendor/github.com/ethereum/go-ethereum/light/txpool.go @@ -24,6 +24,7 @@ import ( "github.com/ethereum/go-ethereum/common" "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/ethdb" "github.com/ethereum/go-ethereum/event" @@ -100,17 +101,18 @@ func NewTxPool(config *params.ChainConfig, eventMux *event.TypeMux, chain *Light } // currentState returns the light state of the current head header -func (pool *TxPool) currentState() *LightState { - return NewLightState(StateTrieID(pool.chain.CurrentHeader()), pool.odr) +func (pool *TxPool) currentState(ctx context.Context) *state.StateDB { + return NewState(ctx, pool.chain.CurrentHeader(), pool.odr) } // GetNonce returns the "pending" nonce of a given address. It always queries // the nonce belonging to the latest header too in order to detect if another // client using the same key sent a transaction. func (pool *TxPool) GetNonce(ctx context.Context, addr common.Address) (uint64, error) { - nonce, err := pool.currentState().GetNonce(ctx, addr) - if err != nil { - return 0, err + state := pool.currentState(ctx) + nonce := state.GetNonce(addr) + if state.Error() != nil { + return 0, state.Error() } sn, ok := pool.nonce[addr] if ok && sn > nonce { @@ -357,13 +359,9 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error return core.ErrInvalidSender } // Last but not least check for nonce errors - currentState := pool.currentState() - if n, err := currentState.GetNonce(ctx, from); err == nil { - if n > tx.Nonce() { - return core.ErrNonce - } - } else { - return err + currentState := pool.currentState(ctx) + if n := currentState.GetNonce(from); n > tx.Nonce() { + return core.ErrNonceTooLow } // Check the transaction doesn't exceed the current @@ -382,12 +380,8 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error // Transactor should have enough funds to cover the costs // cost == V + GP * GL - if b, err := currentState.GetBalance(ctx, from); err == nil { - if b.Cmp(tx.Cost()) < 0 { - return core.ErrInsufficientFunds - } - } else { - return err + if b := currentState.GetBalance(from); b.Cmp(tx.Cost()) < 0 { + return core.ErrInsufficientFunds } // Should supply enough intrinsic gas @@ -395,7 +389,7 @@ func (pool *TxPool) validateTx(ctx context.Context, tx *types.Transaction) error return core.ErrIntrinsicGas } - return nil + return currentState.Error() } // add validates a new transaction and sets its state pending if processable. diff --git a/vendor/github.com/ethereum/go-ethereum/light/vm_env.go b/vendor/github.com/ethereum/go-ethereum/light/vm_env.go deleted file mode 100644 index 54aa12875..000000000 --- a/vendor/github.com/ethereum/go-ethereum/light/vm_env.go +++ /dev/null @@ -1,194 +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 light - -import ( - "context" - "math/big" - - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/crypto" -) - -// VMState is a wrapper for the light state that holds the actual context and -// passes it to any state operation that requires it. -type VMState struct { - ctx context.Context - state *LightState - snapshots []*LightState - err error -} - -func NewVMState(ctx context.Context, state *LightState) *VMState { - return &VMState{ctx: ctx, state: state} -} - -func (s *VMState) Error() error { - return s.err -} - -func (s *VMState) AddLog(log *types.Log) {} - -func (s *VMState) AddPreimage(hash common.Hash, preimage []byte) {} - -// errHandler handles and stores any state error that happens during execution. -func (s *VMState) errHandler(err error) { - if err != nil && s.err == nil { - s.err = err - } -} - -func (self *VMState) Snapshot() int { - self.snapshots = append(self.snapshots, self.state.Copy()) - return len(self.snapshots) - 1 -} - -func (self *VMState) RevertToSnapshot(idx int) { - self.state.Set(self.snapshots[idx]) - self.snapshots = self.snapshots[:idx] -} - -// CreateAccount creates creates a new account object and takes ownership. -func (s *VMState) CreateAccount(addr common.Address) { - _, err := s.state.CreateStateObject(s.ctx, addr) - s.errHandler(err) -} - -// AddBalance adds the given amount to the balance of the specified account -func (s *VMState) AddBalance(addr common.Address, amount *big.Int) { - err := s.state.AddBalance(s.ctx, addr, amount) - s.errHandler(err) -} - -// SubBalance adds the given amount to the balance of the specified account -func (s *VMState) SubBalance(addr common.Address, amount *big.Int) { - err := s.state.SubBalance(s.ctx, addr, amount) - s.errHandler(err) -} - -// ForEachStorage calls a callback function for every key/value pair found -// in the local storage cache. Note that unlike core/state.StateObject, -// light.StateObject only returns cached values and doesn't download the -// entire storage tree. -func (s *VMState) ForEachStorage(addr common.Address, cb func(key, value common.Hash) bool) { - err := s.state.ForEachStorage(s.ctx, addr, cb) - s.errHandler(err) -} - -// GetBalance retrieves the balance from the given address or 0 if the account does -// not exist -func (s *VMState) GetBalance(addr common.Address) *big.Int { - res, err := s.state.GetBalance(s.ctx, addr) - s.errHandler(err) - return res -} - -// GetNonce returns the nonce at the given address or 0 if the account does -// not exist -func (s *VMState) GetNonce(addr common.Address) uint64 { - res, err := s.state.GetNonce(s.ctx, addr) - s.errHandler(err) - return res -} - -// SetNonce sets the nonce of the specified account -func (s *VMState) SetNonce(addr common.Address, nonce uint64) { - err := s.state.SetNonce(s.ctx, addr, nonce) - s.errHandler(err) -} - -// GetCode returns the contract code at the given address or nil if the account -// does not exist -func (s *VMState) GetCode(addr common.Address) []byte { - res, err := s.state.GetCode(s.ctx, addr) - s.errHandler(err) - return res -} - -// GetCodeHash returns the contract code hash at the given address -func (s *VMState) GetCodeHash(addr common.Address) common.Hash { - res, err := s.state.GetCode(s.ctx, addr) - s.errHandler(err) - return crypto.Keccak256Hash(res) -} - -// GetCodeSize returns the contract code size at the given address -func (s *VMState) GetCodeSize(addr common.Address) int { - res, err := s.state.GetCode(s.ctx, addr) - s.errHandler(err) - return len(res) -} - -// SetCode sets the contract code at the specified account -func (s *VMState) SetCode(addr common.Address, code []byte) { - err := s.state.SetCode(s.ctx, addr, code) - s.errHandler(err) -} - -// AddRefund adds an amount to the refund value collected during a vm execution -func (s *VMState) AddRefund(gas *big.Int) { - s.state.AddRefund(gas) -} - -// GetRefund returns the refund value collected during a vm execution -func (s *VMState) GetRefund() *big.Int { - return s.state.GetRefund() -} - -// GetState returns the contract storage value at storage address b from the -// contract address a or common.Hash{} if the account does not exist -func (s *VMState) GetState(a common.Address, b common.Hash) common.Hash { - res, err := s.state.GetState(s.ctx, a, b) - s.errHandler(err) - return res -} - -// SetState sets the storage value at storage address key of the account addr -func (s *VMState) SetState(addr common.Address, key common.Hash, value common.Hash) { - err := s.state.SetState(s.ctx, addr, key, value) - s.errHandler(err) -} - -// Suicide marks an account to be removed and clears its balance -func (s *VMState) Suicide(addr common.Address) bool { - res, err := s.state.Suicide(s.ctx, addr) - s.errHandler(err) - return res -} - -// Exist returns true if an account exists at the given address -func (s *VMState) Exist(addr common.Address) bool { - res, err := s.state.HasAccount(s.ctx, addr) - s.errHandler(err) - return res -} - -// Empty returns true if the account at the given address is considered empty -func (s *VMState) Empty(addr common.Address) bool { - so, err := s.state.GetStateObject(s.ctx, addr) - s.errHandler(err) - return so == nil || so.empty() -} - -// HasSuicided returns true if the given account has been marked for deletion -// or false if the account does not exist -func (s *VMState) HasSuicided(addr common.Address) bool { - res, err := s.state.HasSuicided(s.ctx, addr) - s.errHandler(err) - return res -} diff --git a/vendor/github.com/ethereum/go-ethereum/log/README.md b/vendor/github.com/ethereum/go-ethereum/log/README.md new file mode 100644 index 000000000..0951b21cb --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/log/README.md @@ -0,0 +1,77 @@ +![obligatory xkcd](http://imgs.xkcd.com/comics/standards.png) + +# log15 [![godoc reference](https://godoc.org/github.com/inconshreveable/log15?status.png)](https://godoc.org/github.com/inconshreveable/log15) [![Build Status](https://travis-ci.org/inconshreveable/log15.svg?branch=master)](https://travis-ci.org/inconshreveable/log15) + +Package log15 provides an opinionated, simple toolkit for best-practice logging in Go (golang) that is both human and machine readable. It is modeled after the Go standard library's [`io`](http://golang.org/pkg/io/) and [`net/http`](http://golang.org/pkg/net/http/) packages and is an alternative to the standard library's [`log`](http://golang.org/pkg/log/) package. + +## Features +- A simple, easy-to-understand API +- Promotes structured logging by encouraging use of key/value pairs +- Child loggers which inherit and add their own private context +- Lazy evaluation of expensive operations +- Simple Handler interface allowing for construction of flexible, custom logging configurations with a tiny API. +- Color terminal support +- Built-in support for logging to files, streams, syslog, and the network +- Support for forking records to multiple handlers, buffering records for output, failing over from failed handler writes, + more + +## Versioning +The API of the master branch of log15 should always be considered unstable. If you want to rely on a stable API, +you must vendor the library. + +## Importing + +```go +import log "github.com/inconshreveable/log15" +``` + +## Examples + +```go +// all loggers can have key/value context +srvlog := log.New("module", "app/server") + +// all log messages can have key/value context +srvlog.Warn("abnormal conn rate", "rate", curRate, "low", lowRate, "high", highRate) + +// child loggers with inherited context +connlog := srvlog.New("raddr", c.RemoteAddr()) +connlog.Info("connection open") + +// lazy evaluation +connlog.Debug("ping remote", "latency", log.Lazy{pingRemote}) + +// flexible configuration +srvlog.SetHandler(log.MultiHandler( + log.StreamHandler(os.Stderr, log.LogfmtFormat()), + log.LvlFilterHandler( + log.LvlError, + log.Must.FileHandler("errors.json", log.JsonFormat())))) +``` + +Will result in output that looks like this: + +``` +WARN[06-17|21:58:10] abnormal conn rate module=app/server rate=0.500 low=0.100 high=0.800 +INFO[06-17|21:58:10] connection open module=app/server raddr=10.0.0.1 +``` + +## Breaking API Changes +The following commits broke API stability. This reference is intended to help you understand the consequences of updating to a newer version +of log15. + +- 57a084d014d4150152b19e4e531399a7145d1540 - Added a `Get()` method to the `Logger` interface to retrieve the current handler +- 93404652ee366648fa622b64d1e2b67d75a3094a - `Record` field `Call` changed to `stack.Call` with switch to `github.com/go-stack/stack` +- a5e7613673c73281f58e15a87d2cf0cf111e8152 - Restored `syslog.Priority` argument to the `SyslogXxx` handler constructors + +## FAQ + +### The varargs style is brittle and error prone! Can I have type safety please? +Yes. Use `log.Ctx`: + +```go +srvlog := log.New(log.Ctx{"module": "app/server"}) +srvlog.Warn("abnormal conn rate", log.Ctx{"rate": curRate, "low": lowRate, "high": highRate}) +``` + +## License +Apache diff --git a/vendor/github.com/ethereum/go-ethereum/log/README_ETHEREUM.md b/vendor/github.com/ethereum/go-ethereum/log/README_ETHEREUM.md new file mode 100644 index 000000000..f6c42ccc0 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/log/README_ETHEREUM.md @@ -0,0 +1,5 @@ +This package is a fork of https://github.com/inconshreveable/log15, with some +minor modifications required by the go-ethereum codebase: + + * Support for log level `trace` + * Modified behavior to exit on `critical` failure diff --git a/vendor/github.com/ethereum/go-ethereum/miner/miner.go b/vendor/github.com/ethereum/go-ethereum/miner/miner.go index 453fff04d..fec0a40f5 100644 --- a/vendor/github.com/ethereum/go-ethereum/miner/miner.go +++ b/vendor/github.com/ethereum/go-ethereum/miner/miner.go @@ -19,7 +19,6 @@ package miner import ( "fmt" - "math/big" "sync/atomic" "github.com/ethereum/go-ethereum/accounts" @@ -104,18 +103,6 @@ out: } } -func (m *Miner) GasPrice() *big.Int { - return new(big.Int).Set(m.worker.gasPrice) -} - -func (m *Miner) SetGasPrice(price *big.Int) { - // FIXME block tests set a nil gas price. Quick dirty fix - if price == nil { - return - } - m.worker.setGasPrice(price) -} - func (self *Miner) Start(coinbase common.Address) { atomic.StoreInt32(&self.shouldStart, 1) self.worker.setEtherbase(coinbase) diff --git a/vendor/github.com/ethereum/go-ethereum/miner/worker.go b/vendor/github.com/ethereum/go-ethereum/miner/worker.go index 01241b3f3..e44514755 100644 --- a/vendor/github.com/ethereum/go-ethereum/miner/worker.go +++ b/vendor/github.com/ethereum/go-ethereum/miner/worker.go @@ -59,14 +59,12 @@ type Work struct { config *params.ChainConfig signer types.Signer - state *state.StateDB // apply state changes here - ancestors *set.Set // ancestor set (used for checking uncle parent validity) - family *set.Set // family set (used for checking uncle invalidity) - uncles *set.Set // uncle set - tcount int // tx count in cycle - ownedAccounts *set.Set - lowGasTxs types.Transactions - failedTxs types.Transactions + state *state.StateDB // apply state changes here + ancestors *set.Set // ancestor set (used for checking uncle parent validity) + family *set.Set // family set (used for checking uncle invalidity) + uncles *set.Set // uncle set + tcount int // tx count in cycle + failedTxs types.Transactions Block *types.Block // the new block @@ -103,7 +101,6 @@ type worker struct { chainDb ethdb.Database coinbase common.Address - gasPrice *big.Int extra []byte currentMu sync.Mutex @@ -132,7 +129,6 @@ func newWorker(config *params.ChainConfig, engine consensus.Engine, coinbase com mux: mux, chainDb: eth.ChainDb(), recv: make(chan *Result, resultQueueSize), - gasPrice: new(big.Int), chain: eth.BlockChain(), proc: eth.BlockChain().Validator(), possibleUncles: make(map[common.Hash]*types.Block), @@ -252,7 +248,7 @@ func (self *worker) update() { txs := map[common.Address]types.Transactions{acc: {ev.Tx}} txset := types.NewTransactionsByPriceAndNonce(txs) - self.current.commitTransactions(self.mux, txset, self.gasPrice, self.chain, self.coinbase) + self.current.commitTransactions(self.mux, txset, self.chain, self.coinbase) self.currentMu.Unlock() } } @@ -278,7 +274,7 @@ func (self *worker) wait() { } go self.mux.Post(core.NewMinedBlockEvent{Block: block}) } else { - work.state.Commit(self.config.IsEIP158(block.Number())) + work.state.CommitTo(self.chainDb, self.config.IsEIP158(block.Number())) stat, err := self.chain.WriteBlock(block) if err != nil { log.Error("Failed writing block to chain", "err", err) @@ -375,22 +371,10 @@ func (self *worker) makeCurrent(parent *types.Block, header *types.Header) error } // Keep track of transactions which return errors so they can be removed work.tcount = 0 - work.ownedAccounts = accountAddressesSet(accounts) self.current = work return nil } -func (w *worker) setGasPrice(p *big.Int) { - w.mu.Lock() - defer w.mu.Unlock() - - // calculate the minimal gas price the miner accepts when sorting out transactions. - const pct = int64(90) - w.gasPrice = gasprice(p, pct) - - w.mux.Post(core.GasPriceChanged{Price: w.gasPrice}) -} - func (self *worker) commitNewWork() { self.mu.Lock() defer self.mu.Unlock() @@ -460,9 +444,8 @@ func (self *worker) commitNewWork() { return } txs := types.NewTransactionsByPriceAndNonce(pending) - work.commitTransactions(self.mux, txs, self.gasPrice, self.chain, self.coinbase) + work.commitTransactions(self.mux, txs, self.chain, self.coinbase) - self.eth.TxPool().RemoveBatch(work.lowGasTxs) self.eth.TxPool().RemoveBatch(work.failedTxs) // compute uncles for the new block. @@ -515,7 +498,7 @@ func (self *worker) commitUncle(work *Work, uncle *types.Header) error { return nil } -func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsByPriceAndNonce, gasPrice *big.Int, bc *core.BlockChain, coinbase common.Address) { +func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsByPriceAndNonce, bc *core.BlockChain, coinbase common.Address) { gp := new(core.GasPool).AddGas(env.header.GasLimit) var coalescedLogs []*types.Log @@ -539,19 +522,8 @@ func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsB txs.Pop() continue } - - // Ignore any transactions (and accounts subsequently) with low gas limits - if tx.GasPrice().Cmp(gasPrice) < 0 && !env.ownedAccounts.Has(from) { - // Pop the current low-priced transaction without shifting in the next from the account - log.Warn("Transaction below gas price", "sender", from, "hash", tx.Hash(), "have", tx.GasPrice(), "want", gasPrice) - - env.lowGasTxs = append(env.lowGasTxs, tx) - txs.Pop() - - continue - } // Start executing the transaction - env.state.StartRecord(tx.Hash(), common.Hash{}, env.tcount) + env.state.Prepare(tx.Hash(), common.Hash{}, env.tcount) err, logs := env.commitTransaction(tx, bc, coinbase, gp) switch err { @@ -607,25 +579,3 @@ func (env *Work) commitTransaction(tx *types.Transaction, bc *core.BlockChain, c return nil, receipt.Logs } - -// TODO: remove or use -func (self *worker) HashRate() int64 { - return 0 -} - -// gasprice calculates a reduced gas price based on the pct -// XXX Use big.Rat? -func gasprice(price *big.Int, pct int64) *big.Int { - p := new(big.Int).Set(price) - p.Div(p, big.NewInt(100)) - p.Mul(p, big.NewInt(pct)) - return p -} - -func accountAddressesSet(accounts []accounts.Account) *set.Set { - accountSet := set.New() - for _, account := range accounts { - accountSet.Add(account.Address) - } - return accountSet -} diff --git a/vendor/github.com/ethereum/go-ethereum/mobile/accounts.go b/vendor/github.com/ethereum/go-ethereum/mobile/accounts.go index fbaa3bf40..977999c3a 100644 --- a/vendor/github.com/ethereum/go-ethereum/mobile/accounts.go +++ b/vendor/github.com/ethereum/go-ethereum/mobile/accounts.go @@ -25,6 +25,7 @@ import ( "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts/keystore" + "github.com/ethereum/go-ethereum/crypto" ) const ( @@ -115,6 +116,9 @@ func (ks *KeyStore) SignHash(address *Address, hash []byte) (signature []byte, _ // SignTx signs the given transaction with the requested account. func (ks *KeyStore) SignTx(account *Account, tx *Transaction, chainID *BigInt) (*Transaction, error) { + if chainID == nil { // Null passed from mobile app + chainID = new(BigInt) + } signed, err := ks.keystore.SignTx(account.account, tx.tx, chainID.bigint) if err != nil { return nil, err @@ -132,6 +136,9 @@ func (ks *KeyStore) SignHashPassphrase(account *Account, passphrase string, hash // SignTxPassphrase signs the transaction if the private key matching the // given address can be decrypted with the given passphrase. func (ks *KeyStore) SignTxPassphrase(account *Account, passphrase string, tx *Transaction, chainID *BigInt) (*Transaction, error) { + if chainID == nil { // Null passed from mobile app + chainID = new(BigInt) + } signed, err := ks.keystore.SignTxWithPassphrase(account.account, passphrase, tx.tx, chainID.bigint) if err != nil { return nil, err @@ -170,6 +177,11 @@ func (ks *KeyStore) NewAccount(passphrase string) (*Account, error) { return &Account{account}, nil } +// UpdateAccount changes the passphrase of an existing account. +func (ks *KeyStore) UpdateAccount(account *Account, passphrase, newPassphrase string) error { + return ks.keystore.Update(account.account, passphrase, newPassphrase) +} + // ExportKey exports as a JSON key, encrypted with newPassphrase. func (ks *KeyStore) ExportKey(account *Account, passphrase, newPassphrase string) (key []byte, _ error) { return ks.keystore.Export(account.account, passphrase, newPassphrase) @@ -184,9 +196,17 @@ func (ks *KeyStore) ImportKey(keyJSON []byte, passphrase, newPassphrase string) return &Account{acc}, nil } -// UpdateAccount changes the passphrase of an existing account. -func (ks *KeyStore) UpdateAccount(account *Account, passphrase, newPassphrase string) error { - return ks.keystore.Update(account.account, passphrase, newPassphrase) +// ImportECDSAKey stores the given encrypted JSON key into the key directory. +func (ks *KeyStore) ImportECDSAKey(key []byte, passphrase string) (account *Account, _ error) { + privkey, err := crypto.ToECDSA(key) + if err != nil { + return nil, err + } + acc, err := ks.keystore.ImportECDSA(privkey, passphrase) + if err != nil { + return nil, err + } + return &Account{acc}, nil } // ImportPreSaleKey decrypts the given Ethereum presale wallet and stores diff --git a/vendor/github.com/ethereum/go-ethereum/mobile/common.go b/vendor/github.com/ethereum/go-ethereum/mobile/common.go index 779f22b4e..3090014c5 100644 --- a/vendor/github.com/ethereum/go-ethereum/mobile/common.go +++ b/vendor/github.com/ethereum/go-ethereum/mobile/common.go @@ -89,6 +89,18 @@ func (h *Hash) GetHex() string { // Hashes represents a slice of hashes. type Hashes struct{ hashes []common.Hash } +// NewHashes creates a slice of uninitialized Hashes. +func NewHashes(size int) *Hashes { + return &Hashes{ + hashes: make([]common.Hash, size), + } +} + +// NewHashesEmpty creates an empty slice of Hashes values. +func NewHashesEmpty() *Hashes { + return NewHashes(0) +} + // Size returns the number of hashes in the slice. func (h *Hashes) Size() int { return len(h.hashes) @@ -102,6 +114,20 @@ func (h *Hashes) Get(index int) (hash *Hash, _ error) { return &Hash{h.hashes[index]}, nil } +// Set sets the Hash at the given index in the slice. +func (h *Hashes) Set(index int, hash *Hash) error { + if index < 0 || index >= len(h.hashes) { + return errors.New("index out of bounds") + } + h.hashes[index] = hash.hash + return nil +} + +// Append adds a new Hash element to the end of the slice. +func (h *Hashes) Append(hash *Hash) { + h.hashes = append(h.hashes, hash.hash) +} + // Address represents the 20 byte address of an Ethereum account. type Address struct { address common.Address @@ -164,6 +190,18 @@ func (a *Address) GetHex() string { // Addresses represents a slice of addresses. type Addresses struct{ addresses []common.Address } +// NewAddresses creates a slice of uninitialized addresses. +func NewAddresses(size int) *Addresses { + return &Addresses{ + addresses: make([]common.Address, size), + } +} + +// NewAddressesEmpty creates an empty slice of Addresses values. +func NewAddressesEmpty() *Addresses { + return NewAddresses(0) +} + // Size returns the number of addresses in the slice. func (a *Addresses) Size() int { return len(a.addresses) @@ -185,3 +223,8 @@ func (a *Addresses) Set(index int, address *Address) error { a.addresses[index] = address.address return nil } + +// Append adds a new address element to the end of the slice. +func (a *Addresses) Append(address *Address) { + a.addresses = append(a.addresses, address.address) +} diff --git a/vendor/github.com/ethereum/go-ethereum/mobile/ethereum.go b/vendor/github.com/ethereum/go-ethereum/mobile/ethereum.go index 94f707a87..30a94dc89 100644 --- a/vendor/github.com/ethereum/go-ethereum/mobile/ethereum.go +++ b/vendor/github.com/ethereum/go-ethereum/mobile/ethereum.go @@ -87,6 +87,18 @@ func (p *SyncProgress) GetKnownStates() int64 { return int64(p.progress.KnownS // Topics is a set of topic lists to filter events with. type Topics struct{ topics [][]common.Hash } +// NewTopics creates a slice of uninitialized Topics. +func NewTopics(size int) *Topics { + return &Topics{ + topics: make([][]common.Hash, size), + } +} + +// NewTopicsEmpty creates an empty slice of Topics values. +func NewTopicsEmpty() *Topics { + return NewTopics(0) +} + // Size returns the number of topic lists inside the set func (t *Topics) Size() int { return len(t.topics) @@ -109,6 +121,11 @@ func (t *Topics) Set(index int, topics *Hashes) error { return nil } +// Append adds a new topic list to the end of the slice. +func (t *Topics) Append(topics *Hashes) { + t.topics = append(t.topics, topics.hashes) +} + // FilterQuery contains options for contact log filtering. type FilterQuery struct { query ethereum.FilterQuery @@ -123,3 +140,8 @@ func (fq *FilterQuery) GetFromBlock() *BigInt { return &BigInt{fq.query.FromB func (fq *FilterQuery) GetToBlock() *BigInt { return &BigInt{fq.query.ToBlock} } func (fq *FilterQuery) GetAddresses() *Addresses { return &Addresses{fq.query.Addresses} } func (fq *FilterQuery) GetTopics() *Topics { return &Topics{fq.query.Topics} } + +func (fq *FilterQuery) SetFromBlock(fromBlock *BigInt) { fq.query.FromBlock = fromBlock.bigint } +func (fq *FilterQuery) SetToBlock(toBlock *BigInt) { fq.query.ToBlock = toBlock.bigint } +func (fq *FilterQuery) SetAddresses(addresses *Addresses) { fq.query.Addresses = addresses.addresses } +func (fq *FilterQuery) SetTopics(topics *Topics) { fq.query.Topics = topics.topics } diff --git a/vendor/github.com/ethereum/go-ethereum/mobile/geth.go b/vendor/github.com/ethereum/go-ethereum/mobile/geth.go index 4d679fb53..7b39faade 100644 --- a/vendor/github.com/ethereum/go-ethereum/mobile/geth.go +++ b/vendor/github.com/ethereum/go-ethereum/mobile/geth.go @@ -34,7 +34,7 @@ import ( "github.com/ethereum/go-ethereum/p2p" "github.com/ethereum/go-ethereum/p2p/nat" "github.com/ethereum/go-ethereum/params" - whisper "github.com/ethereum/go-ethereum/whisper/whisperv2" + whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" ) // NodeConfig represents the collection of configuration values to fine tune the Geth @@ -169,7 +169,9 @@ func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) { } // Register the Whisper protocol if requested if config.WhisperEnabled { - if err := rawStack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil { + if err := rawStack.Register(func(*node.ServiceContext) (node.Service, error) { + return whisper.New(&whisper.DefaultConfig), nil + }); err != nil { return nil, fmt.Errorf("whisper init: %v", err) } } diff --git a/vendor/github.com/ethereum/go-ethereum/mobile/types.go b/vendor/github.com/ethereum/go-ethereum/mobile/types.go index a9c8cf68c..02282f7a3 100644 --- a/vendor/github.com/ethereum/go-ethereum/mobile/types.go +++ b/vendor/github.com/ethereum/go-ethereum/mobile/types.go @@ -19,10 +19,12 @@ package geth import ( + "encoding/json" "errors" "fmt" "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/rlp" ) // A Nonce is a 64-bit hash which proves (combined with the mix-hash) that @@ -61,6 +63,45 @@ type Header struct { header *types.Header } +// NewHeaderFromRLP parses a header from an RLP data dump. +func NewHeaderFromRLP(data []byte) (*Header, error) { + h := &Header{ + header: new(types.Header), + } + if err := rlp.DecodeBytes(data, h.header); err != nil { + return nil, err + } + return h, nil +} + +// EncodeRLP encodes a header into an RLP data dump. +func (h *Header) EncodeRLP() ([]byte, error) { + return rlp.EncodeToBytes(h.header) +} + +// NewHeaderFromJSON parses a header from an JSON data dump. +func NewHeaderFromJSON(data string) (*Header, error) { + h := &Header{ + header: new(types.Header), + } + if err := json.Unmarshal([]byte(data), h.header); err != nil { + return nil, err + } + return h, nil +} + +// EncodeJSON encodes a header into an JSON data dump. +func (h *Header) EncodeJSON() (string, error) { + data, err := json.Marshal(h.header) + return string(data), err +} + +// String implements the fmt.Stringer interface to print some semi-meaningful +// data dump of the header for debugging purposes. +func (h *Header) String() string { + return h.header.String() +} + func (h *Header) GetParentHash() *Hash { return &Hash{h.header.ParentHash} } func (h *Header) GetUncleHash() *Hash { return &Hash{h.header.UncleHash} } func (h *Header) GetCoinbase() *Address { return &Address{h.header.Coinbase} } @@ -76,9 +117,7 @@ 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} } func (h *Header) GetNonce() *Nonce { return &Nonce{h.header.Nonce} } - -func (h *Header) GetHash() *Hash { return &Hash{h.header.Hash()} } -func (h *Header) GetHashNoNonce() *Hash { return &Hash{h.header.HashNoNonce()} } +func (h *Header) GetHash() *Hash { return &Hash{h.header.Hash()} } // Headers represents a slice of headers. type Headers struct{ headers []*types.Header } @@ -101,6 +140,45 @@ type Block struct { block *types.Block } +// NewBlockFromRLP parses a block from an RLP data dump. +func NewBlockFromRLP(data []byte) (*Block, error) { + b := &Block{ + block: new(types.Block), + } + if err := rlp.DecodeBytes(data, b.block); err != nil { + return nil, err + } + return b, nil +} + +// EncodeRLP encodes a block into an RLP data dump. +func (b *Block) EncodeRLP() ([]byte, error) { + return rlp.EncodeToBytes(b.block) +} + +// NewBlockFromJSON parses a block from an JSON data dump. +func NewBlockFromJSON(data string) (*Block, error) { + b := &Block{ + block: new(types.Block), + } + if err := json.Unmarshal([]byte(data), b.block); err != nil { + return nil, err + } + return b, nil +} + +// EncodeJSON encodes a block into an JSON data dump. +func (b *Block) EncodeJSON() (string, error) { + data, err := json.Marshal(b.block) + return string(data), err +} + +// String implements the fmt.Stringer interface to print some semi-meaningful +// data dump of the block for debugging purposes. +func (b *Block) String() string { + return b.block.String() +} + func (b *Block) GetParentHash() *Hash { return &Hash{b.block.ParentHash()} } func (b *Block) GetUncleHash() *Hash { return &Hash{b.block.UncleHash()} } func (b *Block) GetCoinbase() *Address { return &Address{b.block.Coinbase()} } @@ -137,6 +215,45 @@ func NewTransaction(nonce int64, to *Address, amount, gasLimit, gasPrice *BigInt return &Transaction{types.NewTransaction(uint64(nonce), to.address, amount.bigint, gasLimit.bigint, gasPrice.bigint, data)} } +// NewTransactionFromRLP parses a transaction from an RLP data dump. +func NewTransactionFromRLP(data []byte) (*Transaction, error) { + tx := &Transaction{ + tx: new(types.Transaction), + } + if err := rlp.DecodeBytes(data, tx.tx); err != nil { + return nil, err + } + return tx, nil +} + +// EncodeRLP encodes a transaction into an RLP data dump. +func (tx *Transaction) EncodeRLP() ([]byte, error) { + return rlp.EncodeToBytes(tx.tx) +} + +// NewTransactionFromJSON parses a transaction from an JSON data dump. +func NewTransactionFromJSON(data string) (*Transaction, error) { + tx := &Transaction{ + tx: new(types.Transaction), + } + if err := json.Unmarshal([]byte(data), tx.tx); err != nil { + return nil, err + } + return tx, nil +} + +// EncodeJSON encodes a transaction into an JSON data dump. +func (tx *Transaction) EncodeJSON() (string, error) { + data, err := json.Marshal(tx.tx) + return string(data), err +} + +// String implements the fmt.Stringer interface to print some semi-meaningful +// data dump of the transaction for debugging purposes. +func (tx *Transaction) String() string { + return tx.tx.String() +} + func (tx *Transaction) GetData() []byte { return tx.tx.Data() } func (tx *Transaction) GetGas() int64 { return tx.tx.Gas().Int64() } func (tx *Transaction) GetGasPrice() *BigInt { return &BigInt{tx.tx.GasPrice()} } @@ -147,8 +264,11 @@ func (tx *Transaction) GetHash() *Hash { return &Hash{tx.tx.Hash()} } func (tx *Transaction) GetSigHash() *Hash { return &Hash{tx.tx.SigHash(types.HomesteadSigner{})} } func (tx *Transaction) GetCost() *BigInt { return &BigInt{tx.tx.Cost()} } -func (tx *Transaction) GetFrom() (address *Address, _ error) { - from, err := types.Sender(types.HomesteadSigner{}, tx.tx) +func (tx *Transaction) GetFrom(chainID *BigInt) (address *Address, _ error) { + if chainID == nil { // Null passed from mobile app + chainID = new(BigInt) + } + from, err := types.Sender(types.NewEIP155Signer(chainID.bigint), tx.tx) return &Address{from}, err } @@ -185,6 +305,45 @@ type Receipt struct { receipt *types.Receipt } +// NewReceiptFromRLP parses a transaction receipt from an RLP data dump. +func NewReceiptFromRLP(data []byte) (*Receipt, error) { + r := &Receipt{ + receipt: new(types.Receipt), + } + if err := rlp.DecodeBytes(data, r.receipt); err != nil { + return nil, err + } + return r, nil +} + +// EncodeRLP encodes a transaction receipt into an RLP data dump. +func (r *Receipt) EncodeRLP() ([]byte, error) { + return rlp.EncodeToBytes(r.receipt) +} + +// NewReceiptFromJSON parses a transaction receipt from an JSON data dump. +func NewReceiptFromJSON(data string) (*Receipt, error) { + r := &Receipt{ + receipt: new(types.Receipt), + } + if err := json.Unmarshal([]byte(data), r.receipt); err != nil { + return nil, err + } + return r, nil +} + +// EncodeJSON encodes a transaction receipt into an JSON data dump. +func (r *Receipt) EncodeJSON() (string, error) { + data, err := rlp.EncodeToBytes(r.receipt) + return string(data), err +} + +// String implements the fmt.Stringer interface to print some semi-meaningful +// data dump of the transaction receipt for debugging purposes. +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} } diff --git a/vendor/github.com/ethereum/go-ethereum/node/defaults.go b/vendor/github.com/ethereum/go-ethereum/node/defaults.go index d4e148683..848f08e05 100644 --- a/vendor/github.com/ethereum/go-ethereum/node/defaults.go +++ b/vendor/github.com/ethereum/go-ethereum/node/defaults.go @@ -41,9 +41,10 @@ var DefaultConfig = Config{ WSPort: DefaultWSPort, WSModules: []string{"net", "web3"}, P2P: p2p.Config{ - ListenAddr: ":30303", - MaxPeers: 25, - NAT: nat.Any(), + ListenAddr: ":30303", + DiscoveryV5Addr: ":30304", + MaxPeers: 25, + NAT: nat.Any(), }, } diff --git a/vendor/github.com/ethereum/go-ethereum/node/service.go b/vendor/github.com/ethereum/go-ethereum/node/service.go index 5e1eb0e64..55062a500 100644 --- a/vendor/github.com/ethereum/go-ethereum/node/service.go +++ b/vendor/github.com/ethereum/go-ethereum/node/service.go @@ -43,7 +43,11 @@ func (ctx *ServiceContext) OpenDatabase(name string, cache int, handles int) (et if ctx.config.DataDir == "" { return ethdb.NewMemDatabase() } - return ethdb.NewLDBDatabase(ctx.config.resolvePath(name), cache, handles) + db, err := ethdb.NewLDBDatabase(ctx.config.resolvePath(name), cache, handles) + if err != nil { + return nil, err + } + return db, nil } // ResolvePath resolves a user path into the data directory if that was relative diff --git a/vendor/github.com/ethereum/go-ethereum/p2p/discover/udp.go b/vendor/github.com/ethereum/go-ethereum/p2p/discover/udp.go index 93545e7d5..f9eb99ee3 100644 --- a/vendor/github.com/ethereum/go-ethereum/p2p/discover/udp.go +++ b/vendor/github.com/ethereum/go-ethereum/p2p/discover/udp.go @@ -224,7 +224,7 @@ func ListenUDP(priv *ecdsa.PrivateKey, laddr string, natm nat.Interface, nodeDBP if err != nil { return nil, err } - log.Debug("UDP listener up", "self", tab.self) + log.Info("UDP listener up", "self", tab.self) return tab, nil } diff --git a/vendor/github.com/ethereum/go-ethereum/params/bootnodes.go b/vendor/github.com/ethereum/go-ethereum/params/bootnodes.go index 496ab68ec..6a145a7a8 100644 --- a/vendor/github.com/ethereum/go-ethereum/params/bootnodes.go +++ b/vendor/github.com/ethereum/go-ethereum/params/bootnodes.go @@ -39,6 +39,18 @@ var TestnetBootnodes = []string{ "enode://20c9ad97c081d63397d7b685a412227a40e23c8bdc6688c6f37e97cfbc22d2b4d1db1510d8f61e6a8866ad7f0e17c02b14182d37ea7c3c8b9c2683aeb6b733a1@52.169.14.227:30303", // IE } +// RinkebyBootnodes are the enode URLs of the P2P bootstrap nodes running on the +// Rinkeby test network. +var RinkebyBootnodes = []string{ + "enode://a24ac7c5484ef4ed0c5eb2d36620ba4e4aa13b8c84684e1b4aab0cebea2ae45cb4d375b77eab56516d34bfbd3c1a833fc51296ff084b770b94fb9028c4d25ccf@52.169.42.101:30303", // IE +} + +// RinkebyV5Bootnodes are the enode URLs of the P2P bootstrap nodes running on the +// Rinkeby test network for the experimental RLPx v5 topic-discovery network. +var RinkebyV5Bootnodes = []string{ + "enode://a24ac7c5484ef4ed0c5eb2d36620ba4e4aa13b8c84684e1b4aab0cebea2ae45cb4d375b77eab56516d34bfbd3c1a833fc51296ff084b770b94fb9028c4d25ccf@52.169.42.101:30303?discport=30304", // IE +} + // DiscoveryV5Bootnodes are the enode URLs of the P2P bootstrap nodes for the // experimental RLPx v5 topic-discovery network. var DiscoveryV5Bootnodes = []string{ diff --git a/vendor/github.com/ethereum/go-ethereum/params/config.go b/vendor/github.com/ethereum/go-ethereum/params/config.go index 18ba49c61..f4bb6172b 100644 --- a/vendor/github.com/ethereum/go-ethereum/params/config.go +++ b/vendor/github.com/ethereum/go-ethereum/params/config.go @@ -18,48 +18,60 @@ package params import ( "fmt" + "math" "math/big" "github.com/ethereum/go-ethereum/common" ) +var ( + MainnetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") // Mainnet genesis hash to enforce below configs on + TestnetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") // Testnet genesis hash to enforce below configs on +) + var ( // MainnetChainConfig is the chain parameters to run a node on the main network. MainnetChainConfig = &ChainConfig{ - ChainId: MainNetChainID, - HomesteadBlock: MainNetHomesteadBlock, - DAOForkBlock: MainNetDAOForkBlock, - DAOForkSupport: true, - EIP150Block: MainNetHomesteadGasRepriceBlock, - EIP150Hash: MainNetHomesteadGasRepriceHash, - EIP155Block: MainNetSpuriousDragon, - EIP158Block: MainNetSpuriousDragon, - Ethash: new(EthashConfig), + ChainId: big.NewInt(1), + HomesteadBlock: big.NewInt(1150000), + DAOForkBlock: big.NewInt(1920000), + DAOForkSupport: true, + EIP150Block: big.NewInt(2463000), + EIP150Hash: common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0"), + EIP155Block: big.NewInt(2675000), + EIP158Block: big.NewInt(2675000), + MetropolisBlock: big.NewInt(math.MaxInt64), // Don't enable yet + + Ethash: new(EthashConfig), } - // TestnetChainConfig contains the chain parameters to run a node on the ropsten test network. + // TestnetChainConfig contains the chain parameters to run a node on the Ropsten test network. TestnetChainConfig = &ChainConfig{ - ChainId: big.NewInt(3), - HomesteadBlock: big.NewInt(0), - DAOForkBlock: nil, - DAOForkSupport: true, - EIP150Block: big.NewInt(0), - EIP150Hash: common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"), - EIP155Block: big.NewInt(10), - EIP158Block: big.NewInt(10), - Ethash: new(EthashConfig), + ChainId: big.NewInt(3), + HomesteadBlock: big.NewInt(0), + DAOForkBlock: nil, + DAOForkSupport: true, + EIP150Block: big.NewInt(0), + EIP150Hash: common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d"), + EIP155Block: big.NewInt(10), + EIP158Block: big.NewInt(10), + MetropolisBlock: big.NewInt(math.MaxInt64), // Don't enable yet + + Ethash: new(EthashConfig), } // RinkebyChainConfig contains the chain parameters to run a node on the Rinkeby test network. RinkebyChainConfig = &ChainConfig{ - ChainId: big.NewInt(4), - HomesteadBlock: big.NewInt(1), - DAOForkBlock: nil, - DAOForkSupport: true, - EIP150Block: big.NewInt(2), - EIP150Hash: common.HexToHash("0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"), - EIP155Block: big.NewInt(3), - EIP158Block: big.NewInt(3), + ChainId: big.NewInt(4), + HomesteadBlock: big.NewInt(1), + DAOForkBlock: nil, + DAOForkSupport: true, + EIP150Block: big.NewInt(2), + EIP150Hash: common.HexToHash("0x9b095b36c15eaf13044373aef8ee0bd3a382a5abb92e402afa44b8249c3a90e9"), + EIP155Block: big.NewInt(3), + EIP158Block: big.NewInt(3), + MetropolisBlock: big.NewInt(math.MaxInt64), // Don't enable yet + Clique: &CliqueConfig{ Period: 15, Epoch: 30000, @@ -68,15 +80,15 @@ var ( // AllProtocolChanges contains every protocol change (EIPs) // introduced and accepted by the Ethereum core developers. - // TestChainConfig is like AllProtocolChanges but has chain ID 1. // // This configuration is intentionally not using keyed fields. // This configuration must *always* have all forks enabled, which // means that all fields must be set at all times. This forces // anyone adding flags to the config to also have to set these // fields. - AllProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), new(EthashConfig), nil} - TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), new(EthashConfig), nil} + AllProtocolChanges = &ChainConfig{big.NewInt(1337), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), big.NewInt(math.MaxInt64) /*disabled*/, new(EthashConfig), nil} + TestChainConfig = &ChainConfig{big.NewInt(1), big.NewInt(0), nil, false, big.NewInt(0), common.Hash{}, big.NewInt(0), big.NewInt(0), nil, new(EthashConfig), nil} + TestRules = TestChainConfig.Rules(new(big.Int)) ) // ChainConfig is the core config which determines the blockchain settings. @@ -98,6 +110,8 @@ type ChainConfig struct { EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block + MetropolisBlock *big.Int `json:"metropolisBlock,omitempty"` // Metropolis switch block (nil = no fork, 0 = alraedy on homestead) + // Various consensus engines Ethash *EthashConfig `json:"ethash,omitempty"` Clique *CliqueConfig `json:"clique,omitempty"` @@ -133,7 +147,7 @@ func (c *ChainConfig) String() string { default: engine = "unknown" } - return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Engine: %v}", + return fmt.Sprintf("{ChainID: %v Homestead: %v DAO: %v DAOSupport: %v EIP150: %v EIP155: %v EIP158: %v Metropolis: %v Engine: %v}", c.ChainId, c.HomesteadBlock, c.DAOForkBlock, @@ -141,6 +155,7 @@ func (c *ChainConfig) String() string { c.EIP150Block, c.EIP155Block, c.EIP158Block, + c.MetropolisBlock, engine, ) } @@ -167,6 +182,10 @@ func (c *ChainConfig) IsEIP158(num *big.Int) bool { return isForked(c.EIP158Block, num) } +func (c *ChainConfig) IsMetropolis(num *big.Int) bool { + return isForked(c.MetropolisBlock, num) +} + // GasTable returns the gas table corresponding to the current phase (homestead or homestead reprice). // // The returned GasTable's fields shouldn't, under any circumstances, be changed. @@ -224,6 +243,9 @@ func (c *ChainConfig) checkCompatible(newcfg *ChainConfig, head *big.Int) *Confi if c.IsEIP158(head) && !configNumEqual(c.ChainId, newcfg.ChainId) { return newCompatError("EIP158 chain ID", c.EIP158Block, newcfg.EIP158Block) } + if isForkIncompatible(c.MetropolisBlock, newcfg.MetropolisBlock, head) { + return newCompatError("Metropolis fork block", c.MetropolisBlock, newcfg.MetropolisBlock) + } return nil } @@ -281,3 +303,22 @@ func newCompatError(what string, storedblock, newblock *big.Int) *ConfigCompatEr func (err *ConfigCompatError) Error() string { return fmt.Sprintf("mismatching %s in database (have %d, want %d, rewindto %d)", err.What, err.StoredConfig, err.NewConfig, err.RewindTo) } + +// Rules wraps ChainConfig and is merely syntatic sugar or can be used for functions +// that do not have or require information about the block. +// +// Rules is a one time interface meaning that it shouldn't be used in between transition +// phases. +type Rules struct { + ChainId *big.Int + IsHomestead, IsEIP150, IsEIP155, IsEIP158 bool + IsMetropolis bool +} + +func (c *ChainConfig) Rules(num *big.Int) Rules { + chainId := c.ChainId + if chainId == nil { + chainId = new(big.Int) + } + return Rules{ChainId: new(big.Int).Set(chainId), IsHomestead: c.IsHomestead(num), IsEIP150: c.IsEIP150(num), IsEIP155: c.IsEIP155(num), IsEIP158: c.IsEIP158(num), IsMetropolis: c.IsMetropolis(num)} +} diff --git a/vendor/github.com/ethereum/go-ethereum/params/dao.go b/vendor/github.com/ethereum/go-ethereum/params/dao.go index ef8e838ff..da3c8dfc9 100644 --- a/vendor/github.com/ethereum/go-ethereum/params/dao.go +++ b/vendor/github.com/ethereum/go-ethereum/params/dao.go @@ -22,15 +22,6 @@ import ( "github.com/ethereum/go-ethereum/common" ) -// TestNetDAOForkBlock is the block number where the DAO hard-fork commences on -// the Ethereum test network. It's enforced nil since it was decided not to do a -// testnet transition. -var TestNetDAOForkBlock *big.Int - -// MainNetDAOForkBlock is the block number where the DAO hard-fork commences on -// the Ethereum main network. -var MainNetDAOForkBlock = big.NewInt(1920000) - // DAOForkBlockExtra is the block header extra-data field to set for the DAO fork // point and a number of consecutive blocks to allow fast/light syncers to correctly // pick the side they want ("dao-hard-fork"). diff --git a/vendor/github.com/ethereum/go-ethereum/params/util.go b/vendor/github.com/ethereum/go-ethereum/params/util.go deleted file mode 100644 index bf833d510..000000000 --- a/vendor/github.com/ethereum/go-ethereum/params/util.go +++ /dev/null @@ -1,43 +0,0 @@ -// Copyright 2015 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 params - -import ( - "math/big" - - "github.com/ethereum/go-ethereum/common" -) - -var ( - TestNetGenesisHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") // Testnet genesis hash to enforce below configs on - MainNetGenesisHash = common.HexToHash("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3") // Mainnet genesis hash to enforce below configs on - - TestNetHomesteadBlock = big.NewInt(0) // Testnet homestead block - MainNetHomesteadBlock = big.NewInt(1150000) // Mainnet homestead block - - TestNetHomesteadGasRepriceBlock = big.NewInt(0) // Testnet gas reprice block - MainNetHomesteadGasRepriceBlock = big.NewInt(2463000) // Mainnet gas reprice block - - TestNetHomesteadGasRepriceHash = common.HexToHash("0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d") // Testnet gas reprice block hash (used by fast sync) - MainNetHomesteadGasRepriceHash = common.HexToHash("0x2086799aeebeae135c246c65021c82b4e15a2c451340993aacfd2751886514f0") // Mainnet gas reprice block hash (used by fast sync) - - TestNetSpuriousDragon = big.NewInt(10) - MainNetSpuriousDragon = big.NewInt(2675000) - - TestNetChainID = big.NewInt(3) // Testnet default chain ID - MainNetChainID = big.NewInt(1) // Mainnet default chain ID -) diff --git a/vendor/github.com/ethereum/go-ethereum/params/version.go b/vendor/github.com/ethereum/go-ethereum/params/version.go index b46c980dd..a8e4aedfb 100644 --- a/vendor/github.com/ethereum/go-ethereum/params/version.go +++ b/vendor/github.com/ethereum/go-ethereum/params/version.go @@ -21,10 +21,10 @@ import ( ) const ( - VersionMajor = 1 // Major version component of the current release - VersionMinor = 6 // Minor version component of the current release - VersionPatch = 1 // Patch version component of the current release - VersionMeta = "unstable" // Version metadata to append to the version string + VersionMajor = 1 // Major version component of the current release + VersionMinor = 6 // Minor version component of the current release + VersionPatch = 7 // Patch version component of the current release + VersionMeta = "stable" // Version metadata to append to the version string ) // Version holds the textual version string. diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/decode.go b/vendor/github.com/ethereum/go-ethereum/rlp/decode.go index ee0b7dbcd..78ccf6275 100644 --- a/vendor/github.com/ethereum/go-ethereum/rlp/decode.go +++ b/vendor/github.com/ethereum/go-ethereum/rlp/decode.go @@ -55,7 +55,7 @@ type Decoder interface { // To decode into a pointer, Decode will decode into the value pointed // to. If the pointer is nil, a new value of the pointer's element // type is allocated. If the pointer is non-nil, the existing value -// will reused. +// will be reused. // // To decode into a struct, Decode expects the input to be an RLP // list. The decoded elements of the list are assigned to each public @@ -290,7 +290,7 @@ func makeListDecoder(typ reflect.Type, tag tags) (decoder, error) { } case tag.tail: // A slice with "tail" tag can occur as the last field - // of a struct and is upposed to swallow all remaining + // of a struct and is supposed to swallow all remaining // list elements. The struct decoder already called s.List, // proceed directly to decoding the elements. dec = func(s *Stream, val reflect.Value) error { @@ -741,7 +741,7 @@ func (s *Stream) uint(maxbits int) (uint64, error) { } // Bool reads an RLP string of up to 1 byte and returns its contents -// as an boolean. If the input does not contain an RLP string, the +// as a boolean. If the input does not contain an RLP string, the // returned error will be ErrExpectedString. func (s *Stream) Bool() (bool, error) { num, err := s.uint(8) diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/doc.go b/vendor/github.com/ethereum/go-ethereum/rlp/doc.go index 72667416c..b3a81fe23 100644 --- a/vendor/github.com/ethereum/go-ethereum/rlp/doc.go +++ b/vendor/github.com/ethereum/go-ethereum/rlp/doc.go @@ -17,13 +17,13 @@ /* Package rlp implements the RLP serialization format. -The purpose of RLP (Recursive Linear Prefix) qis to encode arbitrarily +The purpose of RLP (Recursive Linear Prefix) is to encode arbitrarily nested arrays of binary data, and RLP is the main encoding method used to serialize objects in Ethereum. The only purpose of RLP is to encode structure; encoding specific atomic data types (eg. strings, ints, floats) is left up to higher-order protocols; in Ethereum integers must be represented in big endian binary form with no leading zeroes -(thus making the integer value zero be equivalent to the empty byte +(thus making the integer value zero equivalent to the empty byte array). RLP values are distinguished by a type tag. The type tag precedes the diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/encode.go b/vendor/github.com/ethereum/go-ethereum/rlp/encode.go index c20897efe..44592c2f5 100644 --- a/vendor/github.com/ethereum/go-ethereum/rlp/encode.go +++ b/vendor/github.com/ethereum/go-ethereum/rlp/encode.go @@ -478,7 +478,7 @@ func writeEncoder(val reflect.Value, w *encbuf) error { // with a pointer receiver. func writeEncoderNoPtr(val reflect.Value, w *encbuf) error { if !val.CanAddr() { - // We can't get the address. It would be possible make the + // We can't get the address. It would be possible to make the // value addressable by creating a shallow copy, but this // creates other problems so we're not doing it (yet). // @@ -583,7 +583,7 @@ func makePtrWriter(typ reflect.Type) (writer, error) { return writer, err } -// putint writes i to the beginning of b in with big endian byte +// putint writes i to the beginning of b in big endian byte // order, using the least number of bytes needed to represent i. func putint(b []byte, i uint64) (size int) { switch { diff --git a/vendor/github.com/ethereum/go-ethereum/rlp/raw.go b/vendor/github.com/ethereum/go-ethereum/rlp/raw.go index 33aae6ee5..6bf1c1df8 100644 --- a/vendor/github.com/ethereum/go-ethereum/rlp/raw.go +++ b/vendor/github.com/ethereum/go-ethereum/rlp/raw.go @@ -22,7 +22,7 @@ import ( ) // RawValue represents an encoded RLP value and can be used to delay -// RLP decoding or precompute an encoding. Note that the decoder does +// RLP decoding or to precompute an encoding. Note that the decoder does // not verify whether the content of RawValues is valid RLP. type RawValue []byte diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/client.go b/vendor/github.com/ethereum/go-ethereum/rpc/client.go index 2c35ba54a..f02366a39 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/client.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/client.go @@ -27,6 +27,7 @@ import ( "net/url" "reflect" "strconv" + "strings" "sync" "sync/atomic" "time" @@ -348,6 +349,52 @@ func (c *Client) BatchCallContext(ctx context.Context, b []BatchElem) error { return err } +// ShhSubscribe calls the "shh_subscribe" method with the given arguments, +// registering a subscription. Server notifications for the subscription are +// sent to the given channel. The element type of the channel must match the +// expected type of content returned by the subscription. +// +// The context argument cancels the RPC request that sets up the subscription but has no +// effect on the subscription after ShhSubscribe has returned. +// +// Slow subscribers will be dropped eventually. Client buffers up to 8000 notifications +// before considering the subscriber dead. The subscription Err channel will receive +// ErrSubscriptionQueueOverflow. Use a sufficiently large buffer on the channel or ensure +// that the channel usually has at least one reader to prevent this issue. +func (c *Client) ShhSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (*ClientSubscription, error) { + // Check type of channel first. + chanVal := reflect.ValueOf(channel) + if chanVal.Kind() != reflect.Chan || chanVal.Type().ChanDir()&reflect.SendDir == 0 { + panic("first argument to ShhSubscribe must be a writable channel") + } + if chanVal.IsNil() { + panic("channel given to ShhSubscribe must not be nil") + } + if c.isHTTP { + return nil, ErrNotificationsUnsupported + } + + msg, err := c.newMessage("shh"+subscribeMethodSuffix, args...) + if err != nil { + return nil, err + } + op := &requestOp{ + ids: []json.RawMessage{msg.ID}, + resp: make(chan *jsonrpcMessage), + sub: newClientSubscription(c, "shh", chanVal), + } + + // Send the subscription request. + // The arrival and validity of the response is signaled on sub.quit. + if err := c.send(ctx, op, msg); err != nil { + return nil, err + } + if _, err := op.wait(ctx); err != nil { + return nil, err + } + return op.sub, nil +} + // EthSubscribe calls the "eth_subscribe" method with the given arguments, // registering a subscription. Server notifications for the subscription are // sent to the given channel. The element type of the channel must match the @@ -373,14 +420,14 @@ func (c *Client) EthSubscribe(ctx context.Context, channel interface{}, args ... return nil, ErrNotificationsUnsupported } - msg, err := c.newMessage(subscribeMethod, args...) + msg, err := c.newMessage("eth"+subscribeMethodSuffix, args...) if err != nil { return nil, err } op := &requestOp{ ids: []json.RawMessage{msg.ID}, resp: make(chan *jsonrpcMessage), - sub: newClientSubscription(c, chanVal), + sub: newClientSubscription(c, "eth", chanVal), } // Send the subscription request. @@ -575,7 +622,7 @@ func (c *Client) closeRequestOps(err error) { } func (c *Client) handleNotification(msg *jsonrpcMessage) { - if msg.Method != notificationMethod { + if !strings.HasSuffix(msg.Method, notificationMethodSuffix) { log.Debug(fmt.Sprint("dropping non-subscription message: ", msg)) return } @@ -653,11 +700,12 @@ func (c *Client) read(conn net.Conn) error { // A ClientSubscription represents a subscription established through EthSubscribe. type ClientSubscription struct { - client *Client - etype reflect.Type - channel reflect.Value - subid string - in chan json.RawMessage + client *Client + etype reflect.Type + channel reflect.Value + namespace string + subid string + in chan json.RawMessage quitOnce sync.Once // ensures quit is closed once quit chan struct{} // quit is closed when the subscription exits @@ -665,14 +713,15 @@ type ClientSubscription struct { err chan error } -func newClientSubscription(c *Client, channel reflect.Value) *ClientSubscription { +func newClientSubscription(c *Client, namespace string, channel reflect.Value) *ClientSubscription { sub := &ClientSubscription{ - client: c, - etype: channel.Type().Elem(), - channel: channel, - quit: make(chan struct{}), - err: make(chan error, 1), - in: make(chan json.RawMessage), + client: c, + namespace: namespace, + etype: channel.Type().Elem(), + channel: channel, + quit: make(chan struct{}), + err: make(chan error, 1), + in: make(chan json.RawMessage), } return sub } @@ -774,5 +823,5 @@ func (sub *ClientSubscription) unmarshal(result json.RawMessage) (interface{}, e func (sub *ClientSubscription) requestUnsubscribe() error { var result interface{} - return sub.client.Call(&result, unsubscribeMethod, sub.subid) + return sub.client.Call(&result, sub.namespace+unsubscribeMethodSuffix, sub.subid) } diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/http.go b/vendor/github.com/ethereum/go-ethereum/rpc/http.go index 022f9ce8f..4143e2a8d 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/http.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/http.go @@ -103,8 +103,8 @@ func (c *Client) sendBatchHTTP(ctx context.Context, op *requestOp, msgs []*jsonr if err := json.NewDecoder(respBody).Decode(&respmsgs); err != nil { return err } - for _, respmsg := range respmsgs { - op.resp <- &respmsg + for i := 0; i < len(respmsgs); i++ { + op.resp <- &respmsgs[i] } return nil } @@ -162,6 +162,11 @@ func (srv *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } func newCorsHandler(srv *Server, allowedOrigins []string) http.Handler { + // disable CORS support if user has not specified a custom CORS configuration + if len(allowedOrigins) == 0 { + return srv + } + c := cors.New(cors.Options{ AllowedOrigins: allowedOrigins, AllowedMethods: []string{"POST", "GET"}, diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/json.go b/vendor/github.com/ethereum/go-ethereum/rpc/json.go index c777fab6e..2e7fd599e 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/json.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/json.go @@ -30,11 +30,11 @@ import ( ) const ( - jsonrpcVersion = "2.0" - serviceMethodSeparator = "_" - subscribeMethod = "eth_subscribe" - unsubscribeMethod = "eth_unsubscribe" - notificationMethod = "eth_subscription" + jsonrpcVersion = "2.0" + serviceMethodSeparator = "_" + subscribeMethodSuffix = "_subscribe" + unsubscribeMethodSuffix = "_unsubscribe" + notificationMethodSuffix = "_subscription" ) type jsonRequest struct { @@ -164,7 +164,7 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) { } // subscribe are special, they will always use `subscribeMethod` as first param in the payload - if in.Method == subscribeMethod { + if strings.HasSuffix(in.Method, subscribeMethodSuffix) { reqs := []rpcRequest{{id: &in.Id, isPubSub: true}} if len(in.Payload) > 0 { // first param must be subscription name @@ -174,17 +174,16 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) { return nil, false, &invalidRequestError{"Unable to parse subscription request"} } - // all subscriptions are made on the eth service - reqs[0].service, reqs[0].method = "eth", subscribeMethod[0] + reqs[0].service, reqs[0].method = strings.TrimSuffix(in.Method, subscribeMethodSuffix), subscribeMethod[0] reqs[0].params = in.Payload return reqs, false, nil } return nil, false, &invalidRequestError{"Unable to parse subscription request"} } - if in.Method == unsubscribeMethod { + if strings.HasSuffix(in.Method, unsubscribeMethodSuffix) { return []rpcRequest{{id: &in.Id, isPubSub: true, - method: unsubscribeMethod, params: in.Payload}}, false, nil + method: in.Method, params: in.Payload}}, false, nil } elems := strings.Split(in.Method, serviceMethodSeparator) @@ -216,8 +215,8 @@ func parseBatchRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) id := &in[i].Id - // subscribe are special, they will always use `subscribeMethod` as first param in the payload - if r.Method == subscribeMethod { + // subscribe are special, they will always use `subscriptionMethod` as first param in the payload + if strings.HasSuffix(r.Method, subscribeMethodSuffix) { requests[i] = rpcRequest{id: id, isPubSub: true} if len(r.Payload) > 0 { // first param must be subscription name @@ -227,8 +226,7 @@ func parseBatchRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) return nil, false, &invalidRequestError{"Unable to parse subscription request"} } - // all subscriptions are made on the eth service - requests[i].service, requests[i].method = "eth", subscribeMethod[0] + requests[i].service, requests[i].method = strings.TrimSuffix(r.Method, subscribeMethodSuffix), subscribeMethod[0] requests[i].params = r.Payload continue } @@ -236,8 +234,8 @@ func parseBatchRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) return nil, true, &invalidRequestError{"Unable to parse (un)subscribe request arguments"} } - if r.Method == unsubscribeMethod { - requests[i] = rpcRequest{id: id, isPubSub: true, method: unsubscribeMethod, params: r.Payload} + if strings.HasSuffix(r.Method, unsubscribeMethodSuffix) { + requests[i] = rpcRequest{id: id, isPubSub: true, method: r.Method, params: r.Payload} continue } @@ -325,13 +323,13 @@ func (c *jsonCodec) CreateErrorResponseWithInfo(id interface{}, err Error, info } // CreateNotification will create a JSON-RPC notification with the given subscription id and event as params. -func (c *jsonCodec) CreateNotification(subid string, event interface{}) interface{} { +func (c *jsonCodec) CreateNotification(subid, namespace string, event interface{}) interface{} { if isHexNum(reflect.TypeOf(event)) { - return &jsonNotification{Version: jsonrpcVersion, Method: notificationMethod, + return &jsonNotification{Version: jsonrpcVersion, Method: namespace + notificationMethodSuffix, Params: jsonSubscription{Subscription: subid, Result: fmt.Sprintf(`%#x`, event)}} } - return &jsonNotification{Version: jsonrpcVersion, Method: notificationMethod, + return &jsonNotification{Version: jsonrpcVersion, Method: namespace + notificationMethodSuffix, Params: jsonSubscription{Subscription: subid, Result: event}} } diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/server.go b/vendor/github.com/ethereum/go-ethereum/rpc/server.go index 78df37e52..62b84af34 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/server.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/server.go @@ -21,6 +21,7 @@ import ( "fmt" "reflect" "runtime" + "strings" "sync" "sync/atomic" @@ -96,32 +97,30 @@ func (s *Server) RegisterName(name string, rcvr interface{}) error { return fmt.Errorf("%s is not exported", reflect.Indirect(rcvrVal).Type().Name()) } + methods, subscriptions := suitableCallbacks(rcvrVal, svc.typ) + // already a previous service register under given sname, merge methods/subscriptions if regsvc, present := s.services[name]; present { - methods, subscriptions := suitableCallbacks(rcvrVal, svc.typ) if len(methods) == 0 && len(subscriptions) == 0 { return fmt.Errorf("Service %T doesn't have any suitable methods/subscriptions to expose", rcvr) } - for _, m := range methods { regsvc.callbacks[formatName(m.method.Name)] = m } for _, s := range subscriptions { regsvc.subscriptions[formatName(s.method.Name)] = s } - return nil } svc.name = name - svc.callbacks, svc.subscriptions = suitableCallbacks(rcvrVal, svc.typ) + svc.callbacks, svc.subscriptions = methods, subscriptions if len(svc.callbacks) == 0 && len(svc.subscriptions) == 0 { return fmt.Errorf("Service %T doesn't have any suitable methods/subscriptions to expose", rcvr) } s.services[svc.name] = svc - return nil } @@ -303,7 +302,7 @@ func (s *Server) handle(ctx context.Context, codec ServerCodec, req *serverReque // active the subscription after the sub id was successfully sent to the client activateSub := func() { notifier, _ := NotifierFromContext(ctx) - notifier.activate(subid) + notifier.activate(subid, req.svcname) } return codec.CreateResponse(req.id, subid), activateSub @@ -383,7 +382,7 @@ func (s *Server) execBatch(ctx context.Context, codec ServerCodec, requests []*s codec.Close() } - // when request holds one of more subscribe requests this allows these subscriptions to be actived + // when request holds one of more subscribe requests this allows these subscriptions to be activated for _, c := range callbacks { c() } @@ -410,7 +409,7 @@ func (s *Server) readRequest(codec ServerCodec) ([]*serverRequest, bool, Error) continue } - if r.isPubSub && r.method == unsubscribeMethod { + if r.isPubSub && strings.HasSuffix(r.method, unsubscribeMethodSuffix) { requests[i] = &serverRequest{id: r.id, isUnsubscribe: true} argTypes := []reflect.Type{reflect.TypeOf("")} // expect subscription id as first arg if args, err := codec.ParseRequestArguments(argTypes, r.params); err == nil { @@ -439,7 +438,7 @@ func (s *Server) readRequest(codec ServerCodec) ([]*serverRequest, bool, Error) } } } else { - requests[i] = &serverRequest{id: r.id, err: &methodNotFoundError{subscribeMethod, r.method}} + requests[i] = &serverRequest{id: r.id, err: &methodNotFoundError{r.method, r.method}} } continue } diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/subscription.go b/vendor/github.com/ethereum/go-ethereum/rpc/subscription.go index 9ab6af9e1..720e4dd06 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/subscription.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/subscription.go @@ -35,8 +35,9 @@ type ID string // a Subscription is created by a notifier and tight to that notifier. The client can use // this subscription to wait for an unsubscribe request for the client, see Err(). type Subscription struct { - ID ID - err chan error // closed on unsubscribe + ID ID + namespace string + err chan error // closed on unsubscribe } // Err returns a channel that is closed when the client send an unsubscribe request. @@ -78,7 +79,7 @@ func NotifierFromContext(ctx context.Context) (*Notifier, bool) { // are dropped until the subscription is marked as active. This is done // by the RPC server after the subscription ID is send to the client. func (n *Notifier) CreateSubscription() *Subscription { - s := &Subscription{NewID(), make(chan error)} + s := &Subscription{ID: NewID(), err: make(chan error)} n.subMu.Lock() n.inactive[s.ID] = s n.subMu.Unlock() @@ -91,9 +92,9 @@ func (n *Notifier) Notify(id ID, data interface{}) error { n.subMu.RLock() defer n.subMu.RUnlock() - _, active := n.active[id] + sub, active := n.active[id] if active { - notification := n.codec.CreateNotification(string(id), data) + notification := n.codec.CreateNotification(string(id), sub.namespace, data) if err := n.codec.Write(notification); err != nil { n.codec.Close() return err @@ -124,10 +125,11 @@ func (n *Notifier) unsubscribe(id ID) error { // notifications are dropped. This method is called by the RPC server after // the subscription ID was sent to client. This prevents notifications being // send to the client before the subscription ID is send to the client. -func (n *Notifier) activate(id ID) { +func (n *Notifier) activate(id ID, namespace string) { n.subMu.Lock() defer n.subMu.Unlock() if sub, found := n.inactive[id]; found { + sub.namespace = namespace n.active[id] = sub delete(n.inactive, id) } diff --git a/vendor/github.com/ethereum/go-ethereum/rpc/types.go b/vendor/github.com/ethereum/go-ethereum/rpc/types.go index d29281a4a..a7b8c9788 100644 --- a/vendor/github.com/ethereum/go-ethereum/rpc/types.go +++ b/vendor/github.com/ethereum/go-ethereum/rpc/types.go @@ -104,17 +104,17 @@ type ServerCodec interface { // Read next request ReadRequestHeaders() ([]rpcRequest, bool, Error) // Parse request argument to the given types - ParseRequestArguments([]reflect.Type, interface{}) ([]reflect.Value, Error) + ParseRequestArguments(argTypes []reflect.Type, params interface{}) ([]reflect.Value, Error) // Assemble success response, expects response id and payload - CreateResponse(interface{}, interface{}) interface{} + CreateResponse(id interface{}, reply interface{}) interface{} // Assemble error response, expects response id and error - CreateErrorResponse(interface{}, Error) interface{} + CreateErrorResponse(id interface{}, err Error) interface{} // Assemble error response with extra information about the error through info CreateErrorResponseWithInfo(id interface{}, err Error, info interface{}) interface{} // Create notification response - CreateNotification(string, interface{}) interface{} + CreateNotification(id, namespace string, event interface{}) interface{} // Write msg to client. - Write(interface{}) error + Write(msg interface{}) error // Close underlying data stream Close() // Closed when underlying connection is closed diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/api.go b/vendor/github.com/ethereum/go-ethereum/swarm/api/api.go index 26a9445d5..803265a3e 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/api/api.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/api.go @@ -25,12 +25,13 @@ import ( "sync" "bytes" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/swarm/storage" "mime" "path/filepath" "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/swarm/storage" ) var ( @@ -84,26 +85,32 @@ type ErrResolve error func (self *Api) Resolve(uri *URI) (storage.Key, error) { log.Trace(fmt.Sprintf("Resolving : %v", uri.Addr)) - var err error - if !uri.Immutable() { - if self.dns != nil { - resolved, err := self.dns.Resolve(uri.Addr) - if err == nil { - return resolved[:], nil - } - } else { - err = fmt.Errorf("no DNS to resolve name") + // if the URI is immutable, check if the address is a hash + isHash := hashMatcher.MatchString(uri.Addr) + if uri.Immutable() { + if !isHash { + return nil, fmt.Errorf("immutable address not a content hash: %q", uri.Addr) } + return common.Hex2Bytes(uri.Addr), nil } - if hashMatcher.MatchString(uri.Addr) { - return storage.Key(common.Hex2Bytes(uri.Addr)), nil - } - if err != nil { - return nil, fmt.Errorf("'%s' does not resolve: %v but is not a content hash", uri.Addr, err) - } - return nil, fmt.Errorf("'%s' is not a content hash", uri.Addr) -} + // if DNS is not configured, check if the address is a hash + if self.dns == nil { + if !isHash { + return nil, fmt.Errorf("no DNS to resolve name: %q", uri.Addr) + } + return common.Hex2Bytes(uri.Addr), nil + } + + // try and resolve the address + resolved, err := self.dns.Resolve(uri.Addr) + if err == nil { + return resolved[:], nil + } else if !isHash { + return nil, err + } + return common.Hex2Bytes(uri.Addr), nil +} // Put provides singleton manifest creation on top of dpa store func (self *Api) Put(content, contentType string) (storage.Key, error) { diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/config.go b/vendor/github.com/ethereum/go-ethereum/swarm/api/config.go index 23a855500..d8d25b1c8 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/api/config.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/config.go @@ -25,6 +25,7 @@ import ( "path/filepath" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/contracts/ens" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/swarm/network" "github.com/ethereum/go-ethereum/swarm/services/swap" @@ -32,11 +33,8 @@ import ( ) const ( - port = "8500" -) - -var ( - ensRootAddress = common.HexToAddress("0x112234455c3a32fd11230c42e7bccd4a84e02010") + DefaultHTTPListenAddr = "127.0.0.1" + DefaultHTTPPort = "8500" ) // separate bzz directories @@ -48,12 +46,13 @@ type Config struct { *network.HiveParams Swap *swap.SwapParams *network.SyncParams - Path string - Port string - PublicKey string - BzzKey string - EnsRoot common.Address - NetworkId uint64 + Path string + ListenAddr string + Port string + PublicKey string + BzzKey string + EnsRoot common.Address + NetworkId uint64 } // config is agnostic to where private key is coming from @@ -76,12 +75,13 @@ func NewConfig(path string, contract common.Address, prvKey *ecdsa.PrivateKey, n HiveParams: network.NewHiveParams(dirpath), ChunkerParams: storage.NewChunkerParams(), StoreParams: storage.NewStoreParams(dirpath), - Port: port, + ListenAddr: DefaultHTTPListenAddr, + Port: DefaultHTTPPort, Path: dirpath, Swap: swap.DefaultSwapParams(contract, prvKey), PublicKey: pubkeyhex, BzzKey: keyhex, - EnsRoot: ensRootAddress, + EnsRoot: ens.TestNetAddress, NetworkId: networkId, } data, err = ioutil.ReadFile(confpath) @@ -126,7 +126,7 @@ func NewConfig(path string, contract common.Address, prvKey *ecdsa.PrivateKey, n self.Swap.SetKey(prvKey) if (self.EnsRoot == common.Address{}) { - self.EnsRoot = ensRootAddress + self.EnsRoot = ens.TestNetAddress } return diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/http/server.go b/vendor/github.com/ethereum/go-ethereum/swarm/api/http/server.go index 5e084975a..0f6d93dc0 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/api/http/server.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/http/server.go @@ -56,7 +56,7 @@ type ServerConfig struct { // https://github.com/atom/electron/blob/master/docs/api/protocol.md // starts up http server -func StartHttpServer(api *api.Api, config *ServerConfig) error { +func StartHttpServer(api *api.Api, config *ServerConfig) (*Server, error) { var allowedOrigins []string for _, domain := range strings.Split(config.CorsString, ",") { allowedOrigins = append(allowedOrigins, strings.TrimSpace(domain)) @@ -72,15 +72,16 @@ func StartHttpServer(api *api.Api, config *ServerConfig) error { err error ) if listener, err = net.Listen("tcp", config.Addr); err != nil { - return err + return nil, err } - hdlr := c.Handler(NewServer(api, config, listener)) + server := NewServer(api, config, listener) + handler := c.Handler(server) httpServer := http.Server{Handler: hdlr} go httpServer.Serve(listener) log.Info(fmt.Sprintf("Swarm HTTP proxy started on localhost:%s", config.Addr)) - return nil + return server, nil } // StopHttpServer stops http server diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/manifest.go b/vendor/github.com/ethereum/go-ethereum/swarm/api/manifest.go index dbaaf4bff..e251620a7 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/api/manifest.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/manifest.go @@ -237,12 +237,12 @@ func (self *manifestTrie) addEntry(entry *manifestTrieEntry, quitC chan bool) { } b := byte(entry.Path[0]) - if (self.entries[b] == nil) || (self.entries[b].Path == entry.Path) { + oldentry := self.entries[b] + if (oldentry == nil) || (oldentry.Path == entry.Path && oldentry.ContentType != ManifestType) { self.entries[b] = entry return } - oldentry := self.entries[b] cpl := 0 for (len(entry.Path) > cpl) && (len(oldentry.Path) > cpl) && (entry.Path[cpl] == oldentry.Path[cpl]) { cpl++ diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/img/logo.png b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/img/logo.png new file mode 100644 index 000000000..e0fb15ab3 Binary files /dev/null and b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/img/logo.png differ diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.css b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.css new file mode 100644 index 000000000..693b13a37 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.css @@ -0,0 +1,9 @@ +h1 { + color: black; + font-size: 12px; + background-color: orange; + border: 4px solid black; +} +body { + background-color: orange +} diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.html b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.html new file mode 100644 index 000000000..321e910d7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/api/testdata/test0/index.html @@ -0,0 +1,10 @@ + + + + + + +

Swarm Test

+ Ethereum logo + + \ No newline at end of file diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/.dockerignore b/vendor/github.com/ethereum/go-ethereum/swarm/dev/.dockerignore new file mode 100644 index 000000000..f9e69b37f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/.dockerignore @@ -0,0 +1,2 @@ +bin/* +cluster/* diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/.gitignore b/vendor/github.com/ethereum/go-ethereum/swarm/dev/.gitignore new file mode 100644 index 000000000..f9e69b37f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/.gitignore @@ -0,0 +1,2 @@ +bin/* +cluster/* diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/Dockerfile b/vendor/github.com/ethereum/go-ethereum/swarm/dev/Dockerfile new file mode 100644 index 000000000..728bdab1f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/Dockerfile @@ -0,0 +1,42 @@ +FROM ubuntu:xenial + +# install build + test dependencies +RUN apt-get update && \ + apt-get install --yes --no-install-recommends \ + ca-certificates \ + curl \ + fuse \ + g++ \ + gcc \ + git \ + iproute2 \ + iputils-ping \ + less \ + libc6-dev \ + make \ + pkg-config \ + && \ + apt-get clean + +# install Go +ENV GO_VERSION 1.8.1 +RUN curl -fSLo golang.tar.gz "https://golang.org/dl/go${GO_VERSION}.linux-amd64.tar.gz" && \ + tar -xzf golang.tar.gz -C /usr/local && \ + rm golang.tar.gz +ENV GOPATH /go +ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH + +# install docker CLI +RUN curl -fSLo docker.tar.gz https://get.docker.com/builds/Linux/x86_64/docker-17.04.0-ce.tgz && \ + tar -xzf docker.tar.gz -C /usr/local/bin --strip-components=1 docker/docker && \ + rm docker.tar.gz + +# install jq +RUN curl -fSLo /usr/local/bin/jq https://github.com/stedolan/jq/releases/download/jq-1.5/jq-linux64 && \ + chmod +x /usr/local/bin/jq + +# install govendor +RUN go get -u github.com/kardianos/govendor + +# add custom bashrc +ADD bashrc /root/.bashrc diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/Makefile b/vendor/github.com/ethereum/go-ethereum/swarm/dev/Makefile new file mode 100644 index 000000000..365964b7f --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/Makefile @@ -0,0 +1,14 @@ +.PHONY: build cluster test + +default: build + +build: + go build -o bin/swarm github.com/ethereum/go-ethereum/cmd/swarm + go build -o bin/geth github.com/ethereum/go-ethereum/cmd/geth + go build -o bin/bootnode github.com/ethereum/go-ethereum/cmd/bootnode + +cluster: build + scripts/boot-cluster.sh + +test: + go test -v github.com/ethereum/go-ethereum/swarm/... diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/README.md b/vendor/github.com/ethereum/go-ethereum/swarm/dev/README.md new file mode 100644 index 000000000..81e3b5358 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/README.md @@ -0,0 +1,20 @@ +Swarm development environment +============================= + +The Swarm development environment is a Linux bash shell which can be run in a +Docker container and provides a predictable build and test environment. + +### Start the Docker container + +Run the `run.sh` script to build the Docker image and run it, you will then be +at a bash prompt inside the `swarm/dev` directory. + +### Build binaries + +Run `make` to build the `swarm`, `geth` and `bootnode` binaries into the +`swarm/dev/bin` directory. + +### Boot a cluster + +Run `make cluster` to start a 3 node Swarm cluster, or run +`scripts/boot-cluster.sh --size N` to boot a cluster of size N. diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/bashrc b/vendor/github.com/ethereum/go-ethereum/swarm/dev/bashrc new file mode 100644 index 000000000..efb504fa3 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/bashrc @@ -0,0 +1,21 @@ +export ROOT="${GOPATH}/src/github.com/ethereum/go-ethereum" +export PATH="${ROOT}/swarm/dev/bin:${PATH}" + +cd "${ROOT}/swarm/dev" + +cat <&2 <&2 + exit 1 + fi + name="$2" + shift 2 + ;; + -d | --docker-args) + if [[ -z "$2" ]]; then + echo "ERROR: --docker-args flag requires an argument" >&2 + exit 1 + fi + docker_args="$2" + shift 2 + ;; + *) + break + ;; + esac + done + + if [[ $# -ne 0 ]]; then + usage + echo "ERROR: invalid arguments" >&2 + exit 1 + fi +} + +build_image() { + docker build --tag "${name}" "${ROOT}/swarm/dev" +} + +run_image() { + exec docker run \ + --privileged \ + --interactive \ + --tty \ + --rm \ + --hostname "${name}" \ + --name "${name}" \ + --volume "${ROOT}:/go/src/github.com/ethereum/go-ethereum" \ + --volume "/var/run/docker.sock:/var/run/docker.sock" \ + ${docker_args} \ + "${name}" \ + /bin/bash +} + +main "$@" diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/boot-cluster.sh b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/boot-cluster.sh new file mode 100755 index 000000000..98ae3c802 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/boot-cluster.sh @@ -0,0 +1,288 @@ +#!/bin/bash +# +# A script to boot a dev swarm cluster on a Linux host (typically in a Docker +# container started with swarm/dev/run.sh). +# +# The cluster contains a bootnode, a geth node and multiple swarm nodes, with +# each node having its own data directory in a base directory passed with the +# --dir flag (default is swarm/dev/cluster). +# +# To avoid using different ports for each node and to make networking more +# realistic, each node gets its own network namespace with IPs assigned from +# the 192.168.33.0/24 subnet: +# +# bootnode: 192.168.33.2 +# geth: 192.168.33.3 +# swarm: 192.168.33.10{1,2,...,n} + +set -e + +ROOT="$(cd "$(dirname "$0")/../../.." && pwd)" +source "${ROOT}/swarm/dev/scripts/util.sh" + +# DEFAULT_BASE_DIR is the default base directory to store node data +DEFAULT_BASE_DIR="${ROOT}/swarm/dev/cluster" + +# DEFAULT_CLUSTER_SIZE is the default swarm cluster size +DEFAULT_CLUSTER_SIZE=3 + +# Linux bridge configuration for connecting the node network namespaces +BRIDGE_NAME="swarmbr0" +BRIDGE_IP="192.168.33.1" + +# static bootnode configuration +BOOTNODE_IP="192.168.33.2" +BOOTNODE_PORT="30301" +BOOTNODE_KEY="32078f313bea771848db70745225c52c00981589ad6b5b49163f0f5ee852617d" +BOOTNODE_PUBKEY="760c4460e5336ac9bbd87952a3c7ec4363fc0a97bd31c86430806e287b437fd1b01abc6e1db640cf3106b520344af1d58b00b57823db3e1407cbc433e1b6d04d" +BOOTNODE_URL="enode://${BOOTNODE_PUBKEY}@${BOOTNODE_IP}:${BOOTNODE_PORT}" + +# static geth configuration +GETH_IP="192.168.33.3" +GETH_RPC_PORT="8545" +GETH_RPC_URL="http://${GETH_IP}:${GETH_RPC_PORT}" + +usage() { + cat >&2 < "${key_file}" + + local args=( + --addr "${BOOTNODE_IP}:${BOOTNODE_PORT}" + --nodekey "${key_file}" + --verbosity "6" + ) + + start_node "bootnode" "${BOOTNODE_IP}" "$(which bootnode)" ${args[@]} +} + +# start_geth_node starts a geth node with --datadir pointing at /geth +# and a single, unlocked account with password "geth" +start_geth_node() { + local dir="${base_dir}/geth" + mkdir -p "${dir}" + + local password="geth" + echo "${password}" > "${dir}/password" + + # create an account if necessary + if [[ ! -e "${dir}/keystore" ]]; then + info "creating geth account" + create_account "${dir}" "${password}" + fi + + # get the account address + local address="$(jq --raw-output '.address' ${dir}/keystore/*)" + if [[ -z "${address}" ]]; then + fail "failed to get geth account address" + fi + + local args=( + --datadir "${dir}" + --networkid "321" + --bootnodes "${BOOTNODE_URL}" + --unlock "${address}" + --password "${dir}/password" + --rpc + --rpcaddr "${GETH_IP}" + --rpcport "${GETH_RPC_PORT}" + --verbosity "6" + ) + + start_node "geth" "${GETH_IP}" "$(which geth)" ${args[@]} +} + +start_swarm_nodes() { + for i in $(seq 1 ${cluster_size}); do + start_swarm_node "${i}" + done +} + +# start_swarm_node starts a swarm node with a name like "swarmNN" (where NN is +# a zero-padded integer like "07"), --datadir pointing at / +# (e.g. /swarm07) and a single account with as the password +start_swarm_node() { + local num=$1 + local name="swarm$(printf '%02d' ${num})" + local ip="192.168.33.1$(printf '%02d' ${num})" + + local dir="${base_dir}/${name}" + mkdir -p "${dir}" + + local password="${name}" + echo "${password}" > "${dir}/password" + + # create an account if necessary + if [[ ! -e "${dir}/keystore" ]]; then + info "creating account for ${name}" + create_account "${dir}" "${password}" + fi + + # get the account address + local address="$(jq --raw-output '.address' ${dir}/keystore/*)" + if [[ -z "${address}" ]]; then + fail "failed to get swarm account address" + fi + + local args=( + --bootnodes "${BOOTNODE_URL}" + --datadir "${dir}" + --identity "${name}" + --ens-api "${GETH_RPC_URL}" + --bzznetworkid "321" + --bzzaccount "${address}" + --password "${dir}/password" + --verbosity "6" + ) + + start_node "${name}" "${ip}" "$(which swarm)" ${args[@]} +} + +# start_node runs the node command as a daemon in a network namespace +start_node() { + local name="$1" + local ip="$2" + local path="$3" + local cmd_args=${@:4} + + info "starting ${name} with IP ${ip}" + + create_node_network "${name}" "${ip}" + + # add a marker to the log file + cat >> "${log_dir}/${name}.log" <>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> +Starting ${name} node - $(date) +>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> + +EOF + + # run the command in the network namespace using start-stop-daemon to + # daemonise the process, sending all output to the log file + local daemon_args=( + --start + --background + --no-close + --make-pidfile + --pidfile "${pid_dir}/${name}.pid" + --exec "${path}" + ) + if ! ip netns exec "${name}" start-stop-daemon ${daemon_args[@]} -- $cmd_args &>> "${log_dir}/${name}.log"; then + fail "could not start ${name}, check ${log_dir}/${name}.log" + fi +} + +# create_node_network creates a network namespace and connects it to the Linux +# bridge using a veth pair +create_node_network() { + local name="$1" + local ip="$2" + + # create the namespace + ip netns add "${name}" + + # create the veth pair + local veth0="veth${name}0" + local veth1="veth${name}1" + ip link add name "${veth0}" type veth peer name "${veth1}" + + # add one end to the bridge + ip link set dev "${veth0}" master "${BRIDGE_NAME}" + ip link set dev "${veth0}" up + + # add the other end to the namespace, rename it eth0 and give it the ip + ip link set dev "${veth1}" netns "${name}" + ip netns exec "${name}" ip link set dev "${veth1}" name "eth0" + ip netns exec "${name}" ip link set dev "eth0" up + ip netns exec "${name}" ip address add "${ip}/24" dev "eth0" +} + +create_account() { + local dir=$1 + local password=$2 + + geth --datadir "${dir}" --password /dev/stdin account new <<< "${password}" +} + +main "$@" diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/random-uploads.sh b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/random-uploads.sh new file mode 100755 index 000000000..db7887e3c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/random-uploads.sh @@ -0,0 +1,96 @@ +#!/bin/bash +# +# A script to upload random data to a swarm cluster. +# +# Example: +# +# random-uploads.sh --addr 192.168.33.101:8500 --size 40k --count 1000 + +set -e + +ROOT="$(cd "$(dirname "$0")/../../.." && pwd)" +source "${ROOT}/swarm/dev/scripts/util.sh" + +DEFAULT_ADDR="localhost:8500" +DEFAULT_UPLOAD_SIZE="40k" +DEFAULT_UPLOAD_COUNT="1000" + +usage() { + cat >&2 </dev/null +} + +parse_args() { + while true; do + case "$1" in + -h | --help) + usage + exit 0 + ;; + -a | --addr) + if [[ -z "$2" ]]; then + fail "--addr flag requires an argument" + fi + addr="$2" + shift 2 + ;; + -s | --size) + if [[ -z "$2" ]]; then + fail "--size flag requires an argument" + fi + upload_size="$2" + shift 2 + ;; + -c | --count) + if [[ -z "$2" ]]; then + fail "--count flag requires an argument" + fi + upload_count="$2" + shift 2 + ;; + *) + break + ;; + esac + done + + if [[ $# -ne 0 ]]; then + usage + fail "ERROR: invalid arguments: $@" + fi +} + +main "$@" diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/stop-cluster.sh b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/stop-cluster.sh new file mode 100755 index 000000000..89cb7b0c9 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/stop-cluster.sh @@ -0,0 +1,98 @@ +#!/bin/bash +# +# A script to shutdown a dev swarm cluster. + +set -e + +ROOT="$(cd "$(dirname "$0")/../../.." && pwd)" +source "${ROOT}/swarm/dev/scripts/util.sh" + +DEFAULT_BASE_DIR="${ROOT}/swarm/dev/cluster" + +usage() { + cat >&2 </dev/null; then + ip link delete dev "veth${name}0" + fi +} + +delete_network() { + if ip link show "swarmbr0" &>/dev/null; then + ip link delete dev "swarmbr0" + fi +} + +main "$@" diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/util.sh b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/util.sh new file mode 100644 index 000000000..f17a12e42 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/swarm/dev/scripts/util.sh @@ -0,0 +1,53 @@ +# shared shell functions + +info() { + local msg="$@" + local timestamp="$(date +%H:%M:%S)" + say "===> ${timestamp} ${msg}" "green" +} + +warn() { + local msg="$@" + local timestamp=$(date +%H:%M:%S) + say "===> ${timestamp} WARN: ${msg}" "yellow" >&2 +} + +fail() { + local msg="$@" + say "ERROR: ${msg}" "red" >&2 + exit 1 +} + +# say prints the given message to STDOUT, using the optional color if +# STDOUT is a terminal. +# +# usage: +# +# say "foo" - prints "foo" +# say "bar" "red" - prints "bar" in red +# say "baz" "green" - prints "baz" in green +# say "qux" "red" | tee - prints "qux" with no colour +# +say() { + local msg=$1 + local color=$2 + + if [[ -n "${color}" ]] && [[ -t 1 ]]; then + case "${color}" in + red) + echo -e "\033[1;31m${msg}\033[0m" + ;; + green) + echo -e "\033[1;32m${msg}\033[0m" + ;; + yellow) + echo -e "\033[1;33m${msg}\033[0m" + ;; + *) + echo "${msg}" + ;; + esac + else + echo "${msg}" + fi +} diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_unix.go b/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_unix.go index f4eecef24..1a8390a4b 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_unix.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_unix.go @@ -19,18 +19,19 @@ package fuse import ( - "bazil.org/fuse" - "bazil.org/fuse/fs" "errors" "fmt" - "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/log" - "github.com/ethereum/go-ethereum/swarm/api" "os" "path/filepath" "strings" "sync" "time" + + "bazil.org/fuse" + "bazil.org/fuse/fs" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/log" + "github.com/ethereum/go-ethereum/swarm/api" ) var ( @@ -203,7 +204,7 @@ func (self *SwarmFS) Unmount(mountpoint string) (*MountInfo, error) { } err = fuse.Unmount(cleanedMountPoint) if err != nil { - err1 := externalUnMount(cleanedMountPoint) + err1 := externalUnmount(cleanedMountPoint) if err1 != nil { errStr := fmt.Sprintf("UnMount error: %v", err) log.Warn(errStr) diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_util.go b/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_util.go index d20ab258e..d39966c0e 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_util.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/fuse/swarmfs_util.go @@ -19,47 +19,31 @@ package fuse import ( + "context" "fmt" - "github.com/ethereum/go-ethereum/log" "os/exec" "runtime" - "time" + + "github.com/ethereum/go-ethereum/log" ) -func externalUnMount(mountPoint string) error { - - var cmd *exec.Cmd +func externalUnmount(mountPoint string) error { + ctx, cancel := context.WithTimeout(context.Background(), unmountTimeout) + defer cancel() + // Try generic umount. + if err := exec.CommandContext(ctx, "umount", mountPoint).Run(); err == nil { + return nil + } + // Try FUSE-specific commands if umount didn't work. switch runtime.GOOS { - case "darwin": - cmd = exec.Command("/usr/bin/diskutil", "umount", "force", mountPoint) - + return exec.CommandContext(ctx, "diskutil", "umount", "force", mountPoint).Run() case "linux": - cmd = exec.Command("fusermount", "-u", mountPoint) - + return exec.CommandContext(ctx, "fusermount", "-u", mountPoint).Run() default: return fmt.Errorf("unmount: unimplemented") } - - errc := make(chan error, 1) - go func() { - defer close(errc) - - if err := exec.Command("umount", mountPoint).Run(); err == nil { - return - } - errc <- cmd.Run() - }() - - select { - - case <-time.After(unmountTimeout): - return fmt.Errorf("umount timeout") - - case err := <-errc: - return err - } } func addFileToSwarm(sf *SwarmFile, content []byte, size int) error { diff --git a/vendor/github.com/ethereum/go-ethereum/swarm/swarm.go b/vendor/github.com/ethereum/go-ethereum/swarm/swarm.go index 3d1cee234..bd98c4eda 100644 --- a/vendor/github.com/ethereum/go-ethereum/swarm/swarm.go +++ b/vendor/github.com/ethereum/go-ethereum/swarm/swarm.go @@ -76,7 +76,7 @@ func (self *Swarm) API() *SwarmAPI { // creates a new swarm service instance // implements node.Service -func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api.Config, swapEnabled, syncEnabled bool, cors string) (self *Swarm, err error) { +func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, ensClient *ethclient.Client, config *api.Config, swapEnabled, syncEnabled bool, cors string) (self *Swarm, err error) { if bytes.Equal(common.FromHex(config.PublicKey), storage.ZeroKey) { return nil, fmt.Errorf("empty public key") } @@ -136,10 +136,10 @@ func NewSwarm(ctx *node.ServiceContext, backend chequebook.Backend, config *api. // set up high level api transactOpts := bind.NewKeyedTransactor(self.privateKey) - if backend == (*ethclient.Client)(nil) { - log.Warn("No ENS, please specify non-empty --ethapi to use domain name resolution") + if ensClient == nil { + log.Warn("No ENS, please specify non-empty --ens-api to use domain name resolution") } else { - self.dns, err = ens.NewENS(transactOpts, config.EnsRoot, self.backend) + self.dns, err = ens.NewENS(transactOpts, config.EnsRoot, ensClient) if err != nil { return nil, err } @@ -167,13 +167,13 @@ Start is called when the stack is started * TODO: start subservices like sword, swear, swarmdns */ // implements the node.Service interface -func (self *Swarm) Start(net *p2p.Server) error { +func (self *Swarm) Start(srv *p2p.Server) error { connectPeer := func(url string) error { node, err := discover.ParseNode(url) if err != nil { return fmt.Errorf("invalid node URL: %v", err) } - net.AddPeer(node) + srv.AddPeer(node) return nil } // set chequebook @@ -190,8 +190,8 @@ func (self *Swarm) Start(net *p2p.Server) error { log.Warn(fmt.Sprintf("Starting Swarm service")) self.hive.Start( - discover.PubkeyID(&net.PrivateKey.PublicKey), - func() string { return net.ListenAddr }, + discover.PubkeyID(&srv.PrivateKey.PublicKey), + func() string { return srv.ListenAddr }, connectPeer, ) log.Info(fmt.Sprintf("Swarm network started on bzz address: %v", self.hive.Addr())) @@ -201,19 +201,15 @@ func (self *Swarm) Start(net *p2p.Server) error { // start swarm http proxy server if self.config.Port != "" { - self.httpHandler = &httpapi.ServerConfig{ + serverConfig := &httpapi.ServerConfig{ Addr: ":" + self.config.Port, CorsString: self.corsString, } - if err := httpapi.StartHttpServer(self.api, self.httpHandler); err != nil { + server, err := httpapi.StartHttpServer(self.api, serverConfig) + if err != nil { return err } - } - - log.Debug(fmt.Sprintf("Swarm http proxy started on port: %v", self.config.Port)) - - if self.corsString != "" { - log.Debug(fmt.Sprintf("Swarm http proxy started with corsdomain: %v", self.corsString)) + self.httpHandler = server } return nil diff --git a/vendor/github.com/ethereum/go-ethereum/tests/block_test_util.go b/vendor/github.com/ethereum/go-ethereum/tests/block_test_util.go new file mode 100644 index 000000000..a74f7d68d --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/block_test_util.go @@ -0,0 +1,291 @@ +// Copyright 2015 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 tests implements execution of Ethereum JSON tests. +package tests + +import ( + "bytes" + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + + "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/consensus/ethash" + "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/ethdb" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" +) + +// A BlockTest checks handling of entire blocks. +type BlockTest struct { + json btJSON +} + +func (t *BlockTest) UnmarshalJSON(in []byte) error { + return json.Unmarshal(in, &t.json) +} + +type btJSON struct { + Blocks []btBlock `json:"blocks"` + Genesis btHeader `json:"genesisBlockHeader"` + Pre core.GenesisAlloc `json:"pre"` + Post core.GenesisAlloc `json:"postState"` + BestBlock common.UnprefixedHash `json:"lastblockhash"` +} + +type btBlock struct { + BlockHeader *btHeader + Rlp string + UncleHeaders []*btHeader +} + +//go:generate gencodec -type btHeader -field-override btHeaderMarshaling -out gen_btheader.go + +type btHeader struct { + Bloom types.Bloom + Coinbase common.Address + MixHash common.Hash + Nonce types.BlockNonce + Number *big.Int + Hash common.Hash + ParentHash common.Hash + ReceiptTrie common.Hash + StateRoot common.Hash + TransactionsTrie common.Hash + UncleHash common.Hash + ExtraData []byte + Difficulty *big.Int + GasLimit *big.Int + GasUsed *big.Int + Timestamp *big.Int +} + +type btHeaderMarshaling struct { + ExtraData hexutil.Bytes + Number *math.HexOrDecimal256 + Difficulty *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal256 + GasUsed *math.HexOrDecimal256 + Timestamp *math.HexOrDecimal256 +} + +func (t *BlockTest) Run(config *params.ChainConfig) error { + // import pre accounts & construct test genesis block & state root + db, _ := ethdb.NewMemDatabase() + gblock, err := t.genesis(config).Commit(db) + if err != nil { + return err + } + if gblock.Hash() != t.json.Genesis.Hash { + return fmt.Errorf("genesis block hash doesn't match test: computed=%x, test=%x\n", gblock.Hash().Bytes()[:6], t.json.Genesis.Hash[:6]) + } + if gblock.Root() != t.json.Genesis.StateRoot { + return fmt.Errorf("genesis block state root does not match test: computed=%x, test=%x", gblock.Root().Bytes()[:6], t.json.Genesis.StateRoot[:6]) + } + + chain, err := core.NewBlockChain(db, config, ethash.NewShared(), new(event.TypeMux), vm.Config{}) + if err != nil { + return err + } + defer chain.Stop() + + validBlocks, err := t.insertBlocks(chain) + if err != nil { + return err + } + cmlast := chain.LastBlockHash() + if common.Hash(t.json.BestBlock) != cmlast { + return fmt.Errorf("last block hash validation mismatch: want: %x, have: %x", t.json.BestBlock, cmlast) + } + newDB, err := chain.State() + if err != nil { + return err + } + if err = t.validatePostState(newDB); err != nil { + return fmt.Errorf("post state validation failed: %v", err) + } + return t.validateImportedHeaders(chain, validBlocks) +} + +func (t *BlockTest) genesis(config *params.ChainConfig) *core.Genesis { + return &core.Genesis{ + Config: config, + Nonce: t.json.Genesis.Nonce.Uint64(), + 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(), + Difficulty: t.json.Genesis.Difficulty, + Mixhash: t.json.Genesis.MixHash, + Coinbase: t.json.Genesis.Coinbase, + Alloc: t.json.Pre, + } +} + +/* See https://github.com/ethereum/tests/wiki/Blockchain-Tests-II + + Whether a block is valid or not is a bit subtle, it's defined by presence of + blockHeader, transactions and uncleHeaders fields. If they are missing, the block is + invalid and we must verify that we do not accept it. + + Since some tests mix valid and invalid blocks we need to check this for every block. + + If a block is invalid it does not necessarily fail the test, if it's invalidness is + expected we are expected to ignore it and continue processing and then validate the + post state. +*/ +func (t *BlockTest) insertBlocks(blockchain *core.BlockChain) ([]btBlock, error) { + validBlocks := make([]btBlock, 0) + // insert the test blocks, which will execute all transactions + for _, b := range t.json.Blocks { + cb, err := b.decode() + if err != nil { + if b.BlockHeader == nil { + continue // OK - block is supposed to be invalid, continue with next block + } else { + return nil, fmt.Errorf("Block RLP decoding failed when expected to succeed: %v", err) + } + } + // RLP decoding worked, try to insert into chain: + blocks := types.Blocks{cb} + i, err := blockchain.InsertChain(blocks) + if err != nil { + if b.BlockHeader == nil { + continue // OK - block is supposed to be invalid, continue with next block + } else { + return nil, fmt.Errorf("Block #%v insertion into chain failed: %v", blocks[i].Number(), err) + } + } + if b.BlockHeader == nil { + return nil, fmt.Errorf("Block insertion should have failed") + } + + // validate RLP decoding by checking all values against test file JSON + if err = validateHeader(b.BlockHeader, cb.Header()); err != nil { + return nil, fmt.Errorf("Deserialised block header validation failed: %v", err) + } + validBlocks = append(validBlocks, b) + } + return validBlocks, nil +} + +func validateHeader(h *btHeader, h2 *types.Header) error { + if h.Bloom != h2.Bloom { + return fmt.Errorf("Bloom: want: %x have: %x", h.Bloom, h2.Bloom) + } + if h.Coinbase != h2.Coinbase { + return fmt.Errorf("Coinbase: want: %x have: %x", h.Coinbase, h2.Coinbase) + } + if h.MixHash != h2.MixDigest { + return fmt.Errorf("MixHash: want: %x have: %x", h.MixHash, h2.MixDigest) + } + if h.Nonce != h2.Nonce { + return fmt.Errorf("Nonce: want: %x have: %x", h.Nonce, h2.Nonce) + } + if h.Number.Cmp(h2.Number) != 0 { + return fmt.Errorf("Number: want: %v have: %v", h.Number, h2.Number) + } + if h.ParentHash != h2.ParentHash { + return fmt.Errorf("Parent hash: want: %x have: %x", h.ParentHash, h2.ParentHash) + } + if h.ReceiptTrie != h2.ReceiptHash { + return fmt.Errorf("Receipt hash: want: %x have: %x", h.ReceiptTrie, h2.ReceiptHash) + } + if h.TransactionsTrie != h2.TxHash { + return fmt.Errorf("Tx hash: want: %x have: %x", h.TransactionsTrie, h2.TxHash) + } + if h.StateRoot != h2.Root { + return fmt.Errorf("State hash: want: %x have: %x", h.StateRoot, h2.Root) + } + if h.UncleHash != h2.UncleHash { + return fmt.Errorf("Uncle hash: want: %x have: %x", h.UncleHash, h2.UncleHash) + } + if !bytes.Equal(h.ExtraData, h2.Extra) { + return fmt.Errorf("Extra data: want: %x have: %x", h.ExtraData, h2.Extra) + } + 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.GasUsed.Cmp(h2.GasUsed) != 0 { + return fmt.Errorf("GasUsed: want: %v have: %v", h.GasUsed, h2.GasUsed) + } + if h.Timestamp.Cmp(h2.Time) != 0 { + return fmt.Errorf("Timestamp: want: %v have: %v", h.Timestamp, h2.Time) + } + return nil +} + +func (t *BlockTest) validatePostState(statedb *state.StateDB) error { + // validate post state accounts in test file against what we have in state db + for addr, acct := range t.json.Post { + // address is indirectly verified by the other fields, as it's the db key + code2 := statedb.GetCode(addr) + balance2 := statedb.GetBalance(addr) + nonce2 := statedb.GetNonce(addr) + if !bytes.Equal(code2, acct.Code) { + return fmt.Errorf("account code mismatch for addr: %s want: %v have: %s", addr, acct.Code, hex.EncodeToString(code2)) + } + if balance2.Cmp(acct.Balance) != 0 { + return fmt.Errorf("account balance mismatch for addr: %s, want: %d, have: %d", addr, acct.Balance, balance2) + } + if nonce2 != acct.Nonce { + return fmt.Errorf("account nonce mismatch for addr: %s want: %d have: %d", addr, acct.Nonce, nonce2) + } + } + return nil +} + +func (t *BlockTest) validateImportedHeaders(cm *core.BlockChain, validBlocks []btBlock) error { + // to get constant lookup when verifying block headers by hash (some tests have many blocks) + bmap := make(map[common.Hash]btBlock, len(t.json.Blocks)) + for _, b := range validBlocks { + bmap[b.BlockHeader.Hash] = b + } + // iterate over blocks backwards from HEAD and validate imported + // headers vs test file. some tests have reorgs, and we import + // block-by-block, so we can only validate imported headers after + // all blocks have been processed by BlockChain, as they may not + // be part of the longest chain until last block is imported. + for b := cm.CurrentBlock(); b != nil && b.NumberU64() != 0; b = cm.GetBlockByHash(b.Header().ParentHash) { + if err := validateHeader(bmap[b.Hash()].BlockHeader, b.Header()); err != nil { + return fmt.Errorf("Imported block header validation failed: %v", err) + } + } + return nil +} + +func (bb *btBlock) decode() (*types.Block, error) { + data, err := hexutil.Decode(bb.Rlp) + if err != nil { + return nil, err + } + var b types.Block + err = rlp.DecodeBytes(data, &b) + return &b, err +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_btheader.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_btheader.go new file mode 100644 index 000000000..5d65e0dbc --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_btheader.go @@ -0,0 +1,128 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + "math/big" + + "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/types" +) + +var _ = (*btHeaderMarshaling)(nil) + +func (b btHeader) MarshalJSON() ([]byte, error) { + type btHeader struct { + Bloom types.Bloom + Coinbase common.Address + MixHash common.Hash + Nonce types.BlockNonce + Number *math.HexOrDecimal256 + Hash common.Hash + ParentHash common.Hash + ReceiptTrie common.Hash + StateRoot common.Hash + TransactionsTrie common.Hash + UncleHash common.Hash + ExtraData hexutil.Bytes + Difficulty *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal256 + GasUsed *math.HexOrDecimal256 + Timestamp *math.HexOrDecimal256 + } + var enc btHeader + enc.Bloom = b.Bloom + enc.Coinbase = b.Coinbase + enc.MixHash = b.MixHash + enc.Nonce = b.Nonce + enc.Number = (*math.HexOrDecimal256)(b.Number) + enc.Hash = b.Hash + enc.ParentHash = b.ParentHash + enc.ReceiptTrie = b.ReceiptTrie + enc.StateRoot = b.StateRoot + enc.TransactionsTrie = b.TransactionsTrie + 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.Timestamp = (*math.HexOrDecimal256)(b.Timestamp) + return json.Marshal(&enc) +} + +func (b *btHeader) UnmarshalJSON(input []byte) error { + type btHeader struct { + Bloom *types.Bloom + Coinbase *common.Address + MixHash *common.Hash + Nonce *types.BlockNonce + Number *math.HexOrDecimal256 + Hash *common.Hash + ParentHash *common.Hash + ReceiptTrie *common.Hash + StateRoot *common.Hash + TransactionsTrie *common.Hash + UncleHash *common.Hash + ExtraData hexutil.Bytes + Difficulty *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal256 + GasUsed *math.HexOrDecimal256 + Timestamp *math.HexOrDecimal256 + } + var dec btHeader + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Bloom != nil { + b.Bloom = *dec.Bloom + } + if dec.Coinbase != nil { + b.Coinbase = *dec.Coinbase + } + if dec.MixHash != nil { + b.MixHash = *dec.MixHash + } + if dec.Nonce != nil { + b.Nonce = *dec.Nonce + } + if dec.Number != nil { + b.Number = (*big.Int)(dec.Number) + } + if dec.Hash != nil { + b.Hash = *dec.Hash + } + if dec.ParentHash != nil { + b.ParentHash = *dec.ParentHash + } + if dec.ReceiptTrie != nil { + b.ReceiptTrie = *dec.ReceiptTrie + } + if dec.StateRoot != nil { + b.StateRoot = *dec.StateRoot + } + if dec.TransactionsTrie != nil { + b.TransactionsTrie = *dec.TransactionsTrie + } + if dec.UncleHash != nil { + b.UncleHash = *dec.UncleHash + } + if dec.ExtraData != nil { + b.ExtraData = dec.ExtraData + } + if dec.Difficulty != nil { + b.Difficulty = (*big.Int)(dec.Difficulty) + } + if dec.GasLimit != nil { + b.GasLimit = (*big.Int)(dec.GasLimit) + } + if dec.GasUsed != nil { + b.GasUsed = (*big.Int)(dec.GasUsed) + } + if dec.Timestamp != nil { + b.Timestamp = (*big.Int)(dec.Timestamp) + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_stenv.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_stenv.go new file mode 100644 index 000000000..c780524bc --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_stenv.go @@ -0,0 +1,66 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/math" +) + +var _ = (*stEnvMarshaling)(nil) + +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"` + 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.Number = math.HexOrDecimal64(s.Number) + enc.Timestamp = math.HexOrDecimal64(s.Timestamp) + return json.Marshal(&enc) +} + +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"` + Number *math.HexOrDecimal64 `json:"currentNumber" gencodec:"required"` + Timestamp *math.HexOrDecimal64 `json:"currentTimestamp" gencodec:"required"` + } + var dec stEnv + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Coinbase == nil { + return errors.New("missing required field 'currentCoinbase' for stEnv") + } + s.Coinbase = common.Address(*dec.Coinbase) + if dec.Difficulty == nil { + return errors.New("missing required field 'currentDifficulty' for stEnv") + } + s.Difficulty = (*big.Int)(dec.Difficulty) + if dec.GasLimit == nil { + return errors.New("missing required field 'currentGasLimit' for stEnv") + } + s.GasLimit = (*big.Int)(dec.GasLimit) + if dec.Number == nil { + return errors.New("missing required field 'currentNumber' for stEnv") + } + s.Number = uint64(*dec.Number) + if dec.Timestamp == nil { + return errors.New("missing required field 'currentTimestamp' for stEnv") + } + s.Timestamp = uint64(*dec.Timestamp) + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_stlog.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_stlog.go new file mode 100644 index 000000000..4f7ebc966 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_stlog.go @@ -0,0 +1,61 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" +) + +var _ = (*stLogMarshaling)(nil) + +func (s stLog) MarshalJSON() ([]byte, error) { + type stLog struct { + Address common.UnprefixedAddress `json:"address"` + Data hexutil.Bytes `json:"data"` + Topics []common.UnprefixedHash `json:"topics"` + Bloom string `json:"bloom"` + } + var enc stLog + enc.Address = common.UnprefixedAddress(s.Address) + enc.Data = s.Data + if s.Topics != nil { + enc.Topics = make([]common.UnprefixedHash, len(s.Topics)) + for k, v := range s.Topics { + enc.Topics[k] = common.UnprefixedHash(v) + } + } + enc.Bloom = s.Bloom + return json.Marshal(&enc) +} + +func (s *stLog) UnmarshalJSON(input []byte) error { + type stLog struct { + Address *common.UnprefixedAddress `json:"address"` + Data hexutil.Bytes `json:"data"` + Topics []common.UnprefixedHash `json:"topics"` + Bloom *string `json:"bloom"` + } + var dec stLog + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Address != nil { + s.Address = common.Address(*dec.Address) + } + if dec.Data != nil { + s.Data = dec.Data + } + if dec.Topics != nil { + s.Topics = make([]common.Hash, len(dec.Topics)) + for k, v := range dec.Topics { + s.Topics[k] = common.Hash(v) + } + } + if dec.Bloom != nil { + s.Bloom = *dec.Bloom + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_sttransaction.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_sttransaction.go new file mode 100644 index 000000000..5a489d00b --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_sttransaction.go @@ -0,0 +1,80 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + "math/big" + + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" +) + +var _ = (*stTransactionMarshaling)(nil) + +func (s stTransaction) MarshalJSON() ([]byte, error) { + type stTransaction struct { + GasPrice *math.HexOrDecimal256 `json:"gasPrice"` + Nonce math.HexOrDecimal64 `json:"nonce"` + To string `json:"to"` + Data []string `json:"data"` + GasLimit []math.HexOrDecimal64 `json:"gasLimit"` + Value []string `json:"value"` + PrivateKey hexutil.Bytes `json:"secretKey"` + } + var enc stTransaction + enc.GasPrice = (*math.HexOrDecimal256)(s.GasPrice) + enc.Nonce = math.HexOrDecimal64(s.Nonce) + enc.To = s.To + enc.Data = s.Data + if s.GasLimit != nil { + enc.GasLimit = make([]math.HexOrDecimal64, len(s.GasLimit)) + for k, v := range s.GasLimit { + enc.GasLimit[k] = math.HexOrDecimal64(v) + } + } + enc.Value = s.Value + enc.PrivateKey = s.PrivateKey + return json.Marshal(&enc) +} + +func (s *stTransaction) UnmarshalJSON(input []byte) error { + type stTransaction struct { + GasPrice *math.HexOrDecimal256 `json:"gasPrice"` + Nonce *math.HexOrDecimal64 `json:"nonce"` + To *string `json:"to"` + Data []string `json:"data"` + GasLimit []math.HexOrDecimal64 `json:"gasLimit"` + Value []string `json:"value"` + PrivateKey hexutil.Bytes `json:"secretKey"` + } + var dec stTransaction + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.GasPrice != nil { + s.GasPrice = (*big.Int)(dec.GasPrice) + } + if dec.Nonce != nil { + s.Nonce = uint64(*dec.Nonce) + } + if dec.To != nil { + s.To = *dec.To + } + if dec.Data != nil { + s.Data = dec.Data + } + if dec.GasLimit != nil { + s.GasLimit = make([]uint64, len(dec.GasLimit)) + for k, v := range dec.GasLimit { + s.GasLimit[k] = uint64(v) + } + } + if dec.Value != nil { + s.Value = dec.Value + } + if dec.PrivateKey != nil { + s.PrivateKey = dec.PrivateKey + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_tttransaction.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_tttransaction.go new file mode 100644 index 000000000..b6759be91 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_tttransaction.go @@ -0,0 +1,95 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" +) + +var _ = (*ttTransactionMarshaling)(nil) + +func (t ttTransaction) MarshalJSON() ([]byte, error) { + type ttTransaction struct { + Data hexutil.Bytes `gencodec:"required"` + GasLimit *math.HexOrDecimal256 `gencodec:"required"` + GasPrice *math.HexOrDecimal256 `gencodec:"required"` + Nonce math.HexOrDecimal64 `gencodec:"required"` + Value *math.HexOrDecimal256 `gencodec:"required"` + R *math.HexOrDecimal256 `gencodec:"required"` + S *math.HexOrDecimal256 `gencodec:"required"` + V *math.HexOrDecimal256 `gencodec:"required"` + To common.Address `gencodec:"required"` + } + var enc ttTransaction + enc.Data = t.Data + enc.GasLimit = (*math.HexOrDecimal256)(t.GasLimit) + enc.GasPrice = (*math.HexOrDecimal256)(t.GasPrice) + enc.Nonce = math.HexOrDecimal64(t.Nonce) + enc.Value = (*math.HexOrDecimal256)(t.Value) + enc.R = (*math.HexOrDecimal256)(t.R) + enc.S = (*math.HexOrDecimal256)(t.S) + enc.V = (*math.HexOrDecimal256)(t.V) + enc.To = t.To + return json.Marshal(&enc) +} + +func (t *ttTransaction) UnmarshalJSON(input []byte) error { + type ttTransaction struct { + Data hexutil.Bytes `gencodec:"required"` + GasLimit *math.HexOrDecimal256 `gencodec:"required"` + GasPrice *math.HexOrDecimal256 `gencodec:"required"` + Nonce *math.HexOrDecimal64 `gencodec:"required"` + Value *math.HexOrDecimal256 `gencodec:"required"` + R *math.HexOrDecimal256 `gencodec:"required"` + S *math.HexOrDecimal256 `gencodec:"required"` + V *math.HexOrDecimal256 `gencodec:"required"` + To *common.Address `gencodec:"required"` + } + var dec ttTransaction + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Data == nil { + return errors.New("missing required field 'data' for ttTransaction") + } + t.Data = dec.Data + if dec.GasLimit == nil { + return errors.New("missing required field 'gasLimit' for ttTransaction") + } + t.GasLimit = (*big.Int)(dec.GasLimit) + if dec.GasPrice == nil { + return errors.New("missing required field 'gasPrice' for ttTransaction") + } + t.GasPrice = (*big.Int)(dec.GasPrice) + if dec.Nonce == nil { + return errors.New("missing required field 'nonce' for ttTransaction") + } + t.Nonce = uint64(*dec.Nonce) + if dec.Value == nil { + return errors.New("missing required field 'value' for ttTransaction") + } + t.Value = (*big.Int)(dec.Value) + if dec.R == nil { + return errors.New("missing required field 'r' for ttTransaction") + } + t.R = (*big.Int)(dec.R) + if dec.S == nil { + return errors.New("missing required field 's' for ttTransaction") + } + t.S = (*big.Int)(dec.S) + if dec.V == nil { + return errors.New("missing required field 'v' for ttTransaction") + } + t.V = (*big.Int)(dec.V) + if dec.To == nil { + return errors.New("missing required field 'to' for ttTransaction") + } + t.To = *dec.To + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/gen_vmexec.go b/vendor/github.com/ethereum/go-ethereum/tests/gen_vmexec.go new file mode 100644 index 000000000..dd2d3d94e --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/gen_vmexec.go @@ -0,0 +1,88 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package tests + +import ( + "encoding/json" + "errors" + "math/big" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/common/math" +) + +var _ = (*vmExecMarshaling)(nil) + +func (v vmExec) MarshalJSON() ([]byte, error) { + type vmExec struct { + Address common.UnprefixedAddress `json:"address" gencodec:"required"` + Caller common.UnprefixedAddress `json:"caller" gencodec:"required"` + Origin common.UnprefixedAddress `json:"origin" gencodec:"required"` + Code hexutil.Bytes `json:"code" gencodec:"required"` + Data hexutil.Bytes `json:"data" gencodec:"required"` + Value *math.HexOrDecimal256 `json:"value" gencodec:"required"` + GasLimit math.HexOrDecimal64 `json:"gas" gencodec:"required"` + GasPrice *math.HexOrDecimal256 `json:"gasPrice" gencodec:"required"` + } + var enc vmExec + enc.Address = common.UnprefixedAddress(v.Address) + enc.Caller = common.UnprefixedAddress(v.Caller) + enc.Origin = common.UnprefixedAddress(v.Origin) + enc.Code = v.Code + enc.Data = v.Data + enc.Value = (*math.HexOrDecimal256)(v.Value) + enc.GasLimit = math.HexOrDecimal64(v.GasLimit) + enc.GasPrice = (*math.HexOrDecimal256)(v.GasPrice) + return json.Marshal(&enc) +} + +func (v *vmExec) UnmarshalJSON(input []byte) error { + type vmExec struct { + Address *common.UnprefixedAddress `json:"address" gencodec:"required"` + Caller *common.UnprefixedAddress `json:"caller" gencodec:"required"` + Origin *common.UnprefixedAddress `json:"origin" gencodec:"required"` + Code hexutil.Bytes `json:"code" gencodec:"required"` + Data hexutil.Bytes `json:"data" gencodec:"required"` + Value *math.HexOrDecimal256 `json:"value" gencodec:"required"` + GasLimit *math.HexOrDecimal64 `json:"gas" gencodec:"required"` + GasPrice *math.HexOrDecimal256 `json:"gasPrice" gencodec:"required"` + } + var dec vmExec + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Address == nil { + return errors.New("missing required field 'address' for vmExec") + } + v.Address = common.Address(*dec.Address) + if dec.Caller == nil { + return errors.New("missing required field 'caller' for vmExec") + } + v.Caller = common.Address(*dec.Caller) + if dec.Origin == nil { + return errors.New("missing required field 'origin' for vmExec") + } + v.Origin = common.Address(*dec.Origin) + if dec.Code == nil { + return errors.New("missing required field 'code' for vmExec") + } + v.Code = dec.Code + if dec.Data == nil { + return errors.New("missing required field 'data' for vmExec") + } + v.Data = dec.Data + if dec.Value == nil { + return errors.New("missing required field 'value' for vmExec") + } + v.Value = (*big.Int)(dec.Value) + if dec.GasLimit == nil { + return errors.New("missing required field 'gas' for vmExec") + } + v.GasLimit = uint64(*dec.GasLimit) + if dec.GasPrice == nil { + return errors.New("missing required field 'gasPrice' for vmExec") + } + v.GasPrice = (*big.Int)(dec.GasPrice) + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/rlp_test_util.go b/vendor/github.com/ethereum/go-ethereum/tests/rlp_test_util.go new file mode 100644 index 000000000..58ef8a642 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/rlp_test_util.go @@ -0,0 +1,159 @@ +// Copyright 2015 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 tests + +import ( + "bytes" + "encoding/hex" + "errors" + "fmt" + "math/big" + "strings" + + "github.com/ethereum/go-ethereum/rlp" +) + +// RLPTest is the JSON structure of a single RLP test. +type RLPTest struct { + // If the value of In is "INVALID" or "VALID", the test + // checks whether Out can be decoded into a value of + // type interface{}. + // + // For other JSON values, In is treated as a driver for + // calls to rlp.Stream. The test also verifies that encoding + // In produces the bytes in Out. + In interface{} + + // Out is a hex-encoded RLP value. + Out string +} + +// Run executes the test. +func (t *RLPTest) Run() error { + outb, err := hex.DecodeString(t.Out) + if err != nil { + return fmt.Errorf("invalid hex in Out") + } + + // Handle simple decoding tests with no actual In value. + if t.In == "VALID" || t.In == "INVALID" { + return checkDecodeInterface(outb, t.In == "VALID") + } + + // Check whether encoding the value produces the same bytes. + in := translateJSON(t.In) + b, err := rlp.EncodeToBytes(in) + if err != nil { + return fmt.Errorf("encode failed: %v", err) + } + if !bytes.Equal(b, outb) { + return fmt.Errorf("encode produced %x, want %x", b, outb) + } + // Test stream decoding. + s := rlp.NewStream(bytes.NewReader(outb), 0) + return checkDecodeFromJSON(s, in) +} + +func checkDecodeInterface(b []byte, isValid bool) error { + err := rlp.DecodeBytes(b, new(interface{})) + switch { + case isValid && err != nil: + return fmt.Errorf("decoding failed: %v", err) + case !isValid && err == nil: + return fmt.Errorf("decoding of invalid value succeeded") + } + return nil +} + +// translateJSON makes test json values encodable with RLP. +func translateJSON(v interface{}) interface{} { + switch v := v.(type) { + case float64: + return uint64(v) + case string: + if len(v) > 0 && v[0] == '#' { // # starts a faux big int. + big, ok := new(big.Int).SetString(v[1:], 10) + if !ok { + panic(fmt.Errorf("bad test: bad big int: %q", v)) + } + return big + } + return []byte(v) + case []interface{}: + new := make([]interface{}, len(v)) + for i := range v { + new[i] = translateJSON(v[i]) + } + return new + default: + panic(fmt.Errorf("can't handle %T", v)) + } +} + +// checkDecodeFromJSON decodes from s guided by exp. exp drives the +// Stream by invoking decoding operations (Uint, Big, List, ...) based +// on the type of each value. The value decoded from the RLP stream +// must match the JSON value. +func checkDecodeFromJSON(s *rlp.Stream, exp interface{}) error { + switch exp := exp.(type) { + case uint64: + i, err := s.Uint() + if err != nil { + return addStack("Uint", exp, err) + } + if i != exp { + return addStack("Uint", exp, fmt.Errorf("result mismatch: got %d", i)) + } + case *big.Int: + big := new(big.Int) + if err := s.Decode(&big); err != nil { + return addStack("Big", exp, err) + } + if big.Cmp(exp) != 0 { + return addStack("Big", exp, fmt.Errorf("result mismatch: got %d", big)) + } + case []byte: + b, err := s.Bytes() + if err != nil { + return addStack("Bytes", exp, err) + } + if !bytes.Equal(b, exp) { + return addStack("Bytes", exp, fmt.Errorf("result mismatch: got %x", b)) + } + case []interface{}: + if _, err := s.List(); err != nil { + return addStack("List", exp, err) + } + for i, v := range exp { + if err := checkDecodeFromJSON(s, v); err != nil { + return addStack(fmt.Sprintf("[%d]", i), exp, err) + } + } + if err := s.ListEnd(); err != nil { + return addStack("ListEnd", exp, err) + } + default: + panic(fmt.Errorf("unhandled type: %T", exp)) + } + return nil +} + +func addStack(op string, val interface{}, err error) error { + lines := strings.Split(err.Error(), "\n") + lines = append(lines, fmt.Sprintf("\t%s: %v", op, val)) + return errors.New(strings.Join(lines, "\n")) +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/state_test_util.go b/vendor/github.com/ethereum/go-ethereum/tests/state_test_util.go new file mode 100644 index 000000000..5c7ed5d67 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/state_test_util.go @@ -0,0 +1,312 @@ +// 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 tests + +import ( + "bytes" + "encoding/hex" + "encoding/json" + "fmt" + "math/big" + "reflect" + "strings" + + "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/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/params" +) + +// This table defines supported forks and their chain config. +var stateTestForks = map[string]*params.ChainConfig{ + "Frontier": ¶ms.ChainConfig{ + ChainId: big.NewInt(1), + }, + "Homestead": ¶ms.ChainConfig{ + HomesteadBlock: big.NewInt(0), + ChainId: big.NewInt(1), + }, + "EIP150": ¶ms.ChainConfig{ + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + ChainId: big.NewInt(1), + }, + "EIP158": ¶ms.ChainConfig{ + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + ChainId: big.NewInt(1), + }, + "Metropolis": ¶ms.ChainConfig{ + HomesteadBlock: big.NewInt(0), + EIP150Block: big.NewInt(0), + EIP155Block: big.NewInt(0), + EIP158Block: big.NewInt(0), + MetropolisBlock: big.NewInt(0), + ChainId: big.NewInt(1), + }, +} + +// StateTest checks transaction processing without block context. +// See https://github.com/ethereum/EIPs/issues/176 for the test format specification. +type StateTest struct { + json stJSON +} + +// StateSubtest selects a specific configuration of a General State Test. +type StateSubtest struct { + Fork string + Index int +} + +func (t *StateTest) UnmarshalJSON(in []byte) error { + return json.Unmarshal(in, &t.json) +} + +type stJSON struct { + Env stEnv `json:"env"` + Pre core.GenesisAlloc `json:"pre"` + Tx stTransaction `json:"transaction"` + Out hexutil.Bytes `json:"out"` + Post map[string][]stPostState `json:"post"` +} + +type stPostState struct { + Root common.UnprefixedHash `json:"hash"` + Logs *[]stLog `json:"logs"` + Indexes struct { + Data int `json:"data"` + Gas int `json:"gas"` + Value int `json:"value"` + } +} + +//go:generate gencodec -type stEnv -field-override stEnvMarshaling -out gen_stenv.go + +type stEnv struct { + Coinbase common.Address `json:"currentCoinbase" gencodec:"required"` + Difficulty *big.Int `json:"currentDifficulty" gencodec:"required"` + GasLimit *big.Int `json:"currentGasLimit" gencodec:"required"` + Number uint64 `json:"currentNumber" gencodec:"required"` + Timestamp uint64 `json:"currentTimestamp" gencodec:"required"` +} + +type stEnvMarshaling struct { + Coinbase common.UnprefixedAddress + Difficulty *math.HexOrDecimal256 + GasLimit *math.HexOrDecimal256 + Number math.HexOrDecimal64 + Timestamp math.HexOrDecimal64 +} + +//go:generate gencodec -type stTransaction -field-override stTransactionMarshaling -out gen_sttransaction.go + +type stTransaction struct { + GasPrice *big.Int `json:"gasPrice"` + Nonce uint64 `json:"nonce"` + To string `json:"to"` + Data []string `json:"data"` + GasLimit []uint64 `json:"gasLimit"` + Value []string `json:"value"` + PrivateKey []byte `json:"secretKey"` +} + +type stTransactionMarshaling struct { + GasPrice *math.HexOrDecimal256 + Nonce math.HexOrDecimal64 + GasLimit []math.HexOrDecimal64 + PrivateKey hexutil.Bytes +} + +//go:generate gencodec -type stLog -field-override stLogMarshaling -out gen_stlog.go + +type stLog struct { + Address common.Address `json:"address"` + Data []byte `json:"data"` + Topics []common.Hash `json:"topics"` + Bloom string `json:"bloom"` +} + +type stLogMarshaling struct { + Address common.UnprefixedAddress + Data hexutil.Bytes + Topics []common.UnprefixedHash +} + +// Subtests returns all valid subtests of the test. +func (t *StateTest) Subtests() []StateSubtest { + var sub []StateSubtest + for fork, pss := range t.json.Post { + for i, _ := range pss { + sub = append(sub, StateSubtest{fork, i}) + } + } + return sub +} + +// Run executes a specific subtest. +func (t *StateTest) Run(subtest StateSubtest, vmconfig vm.Config) error { + config, ok := stateTestForks[subtest.Fork] + if !ok { + return fmt.Errorf("no config for fork %q", subtest.Fork) + } + block, _ := t.genesis(config).ToBlock() + db, _ := ethdb.NewMemDatabase() + statedb := makePreState(db, t.json.Pre) + + post := t.json.Post[subtest.Fork][subtest.Index] + msg, err := t.json.Tx.toMessage(post) + if err != nil { + return err + } + context := core.NewEVMContext(msg, block.Header(), nil, &t.json.Env.Coinbase) + context.GetHash = vmTestBlockHash + evm := vm.NewEVM(context, statedb, config, vmconfig) + + gaspool := new(core.GasPool) + gaspool.AddGas(block.GasLimit()) + snapshot := statedb.Snapshot() + if _, _, err := core.ApplyMessage(evm, msg, gaspool); err != nil { + statedb.RevertToSnapshot(snapshot) + } + if post.Logs != nil { + if err := checkLogs(statedb.Logs(), *post.Logs); err != nil { + return err + } + } + root, _ := statedb.CommitTo(db, config.IsEIP158(block.Number())) + if root != common.Hash(post.Root) { + return fmt.Errorf("post state root mismatch: got %x, want %x", root, post.Root) + } + return nil +} + +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 { + sdb := state.NewDatabase(db) + statedb, _ := state.New(common.Hash{}, sdb) + for addr, a := range accounts { + statedb.SetCode(addr, a.Code) + statedb.SetNonce(addr, a.Nonce) + statedb.SetBalance(addr, a.Balance) + for k, v := range a.Storage { + statedb.SetState(addr, k, v) + } + } + // Commit and re-open to start with a clean state. + root, _ := statedb.CommitTo(db, false) + statedb, _ = state.New(root, sdb) + return statedb +} + +func (t *StateTest) genesis(config *params.ChainConfig) *core.Genesis { + return &core.Genesis{ + Config: config, + Coinbase: t.json.Env.Coinbase, + Difficulty: t.json.Env.Difficulty, + GasLimit: t.json.Env.GasLimit.Uint64(), + Number: t.json.Env.Number, + Timestamp: t.json.Env.Timestamp, + Alloc: t.json.Pre, + } +} + +func (tx *stTransaction) toMessage(ps stPostState) (core.Message, error) { + // Derive sender from private key if present. + var from common.Address + if len(tx.PrivateKey) > 0 { + key, err := crypto.ToECDSA(tx.PrivateKey) + if err != nil { + return nil, fmt.Errorf("invalid private key: %v", err) + } + from = crypto.PubkeyToAddress(key.PublicKey) + } + // Parse recipient if present. + var to *common.Address + if tx.To != "" { + to = new(common.Address) + if err := to.UnmarshalText([]byte(tx.To)); err != nil { + return nil, fmt.Errorf("invalid to address: %v", err) + } + } + + // Get values specific to this post state. + if ps.Indexes.Data > len(tx.Data) { + return nil, fmt.Errorf("tx data index %d out of bounds", ps.Indexes.Data) + } + if ps.Indexes.Value > len(tx.Value) { + return nil, fmt.Errorf("tx value index %d out of bounds", ps.Indexes.Value) + } + if ps.Indexes.Gas > len(tx.GasLimit) { + return nil, fmt.Errorf("tx gas limit index %d out of bounds", ps.Indexes.Gas) + } + dataHex := tx.Data[ps.Indexes.Data] + valueHex := tx.Value[ps.Indexes.Value] + gasLimit := tx.GasLimit[ps.Indexes.Gas] + // Value, Data hex encoding is messy: https://github.com/ethereum/tests/issues/203 + value := new(big.Int) + if valueHex != "0x" { + v, ok := math.ParseBig256(valueHex) + if !ok { + return nil, fmt.Errorf("invalid tx value %q", valueHex) + } + value = v + } + data, err := hex.DecodeString(strings.TrimPrefix(dataHex, "0x")) + if err != nil { + 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) + return msg, nil +} + +func checkLogs(have []*types.Log, want []stLog) error { + if len(have) != len(want) { + return fmt.Errorf("logs length mismatch: got %d, want %d", len(have), len(want)) + } + for i := range have { + if have[i].Address != want[i].Address { + return fmt.Errorf("log address %d: got %x, want %x", i, have[i].Address, want[i].Address) + } + if !bytes.Equal(have[i].Data, want[i].Data) { + return fmt.Errorf("log data %d: got %x, want %x", i, have[i].Data, want[i].Data) + } + if !reflect.DeepEqual(have[i].Topics, want[i].Topics) { + return fmt.Errorf("log topics %d:\ngot %x\nwant %x", i, have[i].Topics, want[i].Topics) + } + genBloom := math.PaddedBigBytes(types.LogsBloom([]*types.Log{have[i]}), 256) + var wantBloom types.Bloom + if err := hexutil.UnmarshalFixedUnprefixedText("Bloom", []byte(want[i].Bloom), wantBloom[:]); err != nil { + return fmt.Errorf("test log %d has invalid bloom: %v", i, err) + } + if !bytes.Equal(genBloom, wantBloom[:]) { + return fmt.Errorf("bloom mismatch") + } + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/testdata b/vendor/github.com/ethereum/go-ethereum/tests/testdata new file mode 160000 index 000000000..f1de8c3b7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/testdata @@ -0,0 +1 @@ +Subproject commit f1de8c3b7fa2c2c0aa281b6b3a1ad7010356c5ff diff --git a/vendor/github.com/ethereum/go-ethereum/tests/transaction_test_util.go b/vendor/github.com/ethereum/go-ethereum/tests/transaction_test_util.go new file mode 100644 index 000000000..472b3d6f2 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/transaction_test_util.go @@ -0,0 +1,133 @@ +// Copyright 2015 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 tests + +import ( + "bytes" + "errors" + "fmt" + "math/big" + + "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/types" + "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" +) + +// TransactionTest checks RLP decoding and sender derivation of transactions. +type TransactionTest struct { + json ttJSON +} + +type ttJSON struct { + BlockNumber math.HexOrDecimal64 `json:"blockNumber"` + RLP hexutil.Bytes `json:"rlp"` + Sender hexutil.Bytes `json:"sender"` + Transaction *ttTransaction `json:"transaction"` +} + +//go:generate gencodec -type ttTransaction -field-override ttTransactionMarshaling -out gen_tttransaction.go + +type ttTransaction struct { + Data []byte `gencodec:"required"` + GasLimit *big.Int `gencodec:"required"` + GasPrice *big.Int `gencodec:"required"` + Nonce uint64 `gencodec:"required"` + Value *big.Int `gencodec:"required"` + R *big.Int `gencodec:"required"` + S *big.Int `gencodec:"required"` + V *big.Int `gencodec:"required"` + To common.Address `gencodec:"required"` +} + +type ttTransactionMarshaling struct { + Data hexutil.Bytes + GasLimit *math.HexOrDecimal256 + GasPrice *math.HexOrDecimal256 + Nonce math.HexOrDecimal64 + Value *math.HexOrDecimal256 + R *math.HexOrDecimal256 + S *math.HexOrDecimal256 + V *math.HexOrDecimal256 +} + +func (tt *TransactionTest) Run(config *params.ChainConfig) error { + tx := new(types.Transaction) + if err := rlp.DecodeBytes(tt.json.RLP, tx); err != nil { + if tt.json.Transaction == nil { + return nil + } else { + return fmt.Errorf("RLP decoding failed: %v", err) + } + } + // Check sender derivation. + signer := types.MakeSigner(config, new(big.Int).SetUint64(uint64(tt.json.BlockNumber))) + sender, err := types.Sender(signer, tx) + if err != nil { + return err + } + if sender != common.BytesToAddress(tt.json.Sender) { + return fmt.Errorf("Sender mismatch: got %x, want %x", sender, tt.json.Sender) + } + // Check decoded fields. + err = tt.json.Transaction.verify(signer, tx) + if tt.json.Sender == nil && err == nil { + return errors.New("field validations succeeded but should fail") + } + if tt.json.Sender != nil && err != nil { + return fmt.Errorf("field validations failed after RLP decoding: %s", err) + } + return nil +} + +func (tt *ttTransaction) verify(signer types.Signer, tx *types.Transaction) error { + 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.GasPrice().Cmp(tt.GasPrice) != 0 { + return fmt.Errorf("GasPrice mismatch: got %v, want %v", tx.GasPrice(), tt.GasPrice) + } + if tx.Nonce() != tt.Nonce { + return fmt.Errorf("Nonce mismatch: got %v, want %v", tx.Nonce(), tt.Nonce) + } + v, r, s := tx.RawSignatureValues() + if r.Cmp(tt.R) != 0 { + return fmt.Errorf("R mismatch: got %v, want %v", r, tt.R) + } + if s.Cmp(tt.S) != 0 { + return fmt.Errorf("S mismatch: got %v, want %v", s, tt.S) + } + if v.Cmp(tt.V) != 0 { + return fmt.Errorf("V mismatch: got %v, want %v", v, tt.V) + } + if tx.To() == nil { + if tt.To != (common.Address{}) { + return fmt.Errorf("To mismatch when recipient is nil (contract creation): %x", tt.To) + } + } else if *tx.To() != tt.To { + return fmt.Errorf("To mismatch: got %x, want %x", *tx.To(), tt.To) + } + if tx.Value().Cmp(tt.Value) != 0 { + return fmt.Errorf("Value mismatch: got %x, want %x", tx.Value(), tt.Value) + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/tests/vm_test_util.go b/vendor/github.com/ethereum/go-ethereum/tests/vm_test_util.go new file mode 100644 index 000000000..afdd896c3 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/tests/vm_test_util.go @@ -0,0 +1,149 @@ +// Copyright 2015 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 tests + +import ( + "bytes" + "encoding/json" + "fmt" + "math/big" + + "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/state" + "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/ethdb" + "github.com/ethereum/go-ethereum/params" +) + +// VMTest checks EVM execution without block or transaction context. +// See https://github.com/ethereum/tests/wiki/VM-Tests for the test format specification. +type VMTest struct { + json vmJSON +} + +func (t *VMTest) UnmarshalJSON(data []byte) error { + return json.Unmarshal(data, &t.json) +} + +type vmJSON struct { + Env stEnv `json:"env"` + Exec vmExec `json:"exec"` + Logs []stLog `json:"logs"` + GasRemaining *math.HexOrDecimal64 `json:"gas"` + Out hexutil.Bytes `json:"out"` + Pre core.GenesisAlloc `json:"pre"` + Post core.GenesisAlloc `json:"post"` + PostStateRoot common.Hash `json:"postStateRoot"` +} + +//go:generate gencodec -type vmExec -field-override vmExecMarshaling -out gen_vmexec.go + +type vmExec struct { + Address common.Address `json:"address" gencodec:"required"` + Caller common.Address `json:"caller" gencodec:"required"` + Origin common.Address `json:"origin" gencodec:"required"` + Code []byte `json:"code" gencodec:"required"` + Data []byte `json:"data" gencodec:"required"` + Value *big.Int `json:"value" gencodec:"required"` + GasLimit uint64 `json:"gas" gencodec:"required"` + GasPrice *big.Int `json:"gasPrice" gencodec:"required"` +} + +type vmExecMarshaling struct { + Address common.UnprefixedAddress + Caller common.UnprefixedAddress + Origin common.UnprefixedAddress + Code hexutil.Bytes + Data hexutil.Bytes + Value *math.HexOrDecimal256 + GasLimit math.HexOrDecimal64 + GasPrice *math.HexOrDecimal256 +} + +func (t *VMTest) Run(vmconfig vm.Config) error { + db, _ := ethdb.NewMemDatabase() + statedb := makePreState(db, t.json.Pre) + ret, gasRemaining, err := t.exec(statedb, vmconfig) + + if t.json.GasRemaining == nil { + if err == nil { + return fmt.Errorf("gas unspecified (indicating an error), but VM returned no error") + } + if gasRemaining > 0 { + return fmt.Errorf("gas unspecified (indicating an error), but VM returned gas remaining > 0") + } + return nil + } + // Test declares gas, expecting outputs to match. + if !bytes.Equal(ret, t.json.Out) { + return fmt.Errorf("return data mismatch: got %x, want %x", ret, t.json.Out) + } + if gasRemaining != uint64(*t.json.GasRemaining) { + return fmt.Errorf("remaining gas %v, want %v", gasRemaining, *t.json.GasRemaining) + } + for addr, account := range t.json.Post { + for k, wantV := range account.Storage { + if haveV := statedb.GetState(addr, k); haveV != wantV { + return fmt.Errorf("wrong storage value at %x:\n got %x\n want %x", k, haveV, wantV) + } + } + } + // if root := statedb.IntermediateRoot(false); root != t.json.PostStateRoot { + // return fmt.Errorf("post state root mismatch, got %x, want %x", root, t.json.PostStateRoot) + // } + return checkLogs(statedb.Logs(), t.json.Logs) +} + +func (t *VMTest) exec(statedb *state.StateDB, vmconfig vm.Config) ([]byte, uint64, error) { + evm := t.newEVM(statedb, vmconfig) + e := t.json.Exec + return evm.Call(vm.AccountRef(e.Caller), e.Address, e.Data, e.GasLimit, e.Value) +} + +func (t *VMTest) newEVM(statedb *state.StateDB, vmconfig vm.Config) *vm.EVM { + initialCall := true + canTransfer := func(db vm.StateDB, address common.Address, amount *big.Int) bool { + if initialCall { + initialCall = false + return true + } + return core.CanTransfer(db, address, amount) + } + transfer := func(db vm.StateDB, sender, recipient common.Address, amount *big.Int) {} + context := vm.Context{ + CanTransfer: canTransfer, + Transfer: transfer, + GetHash: vmTestBlockHash, + Origin: t.json.Exec.Origin, + Coinbase: t.json.Env.Coinbase, + BlockNumber: new(big.Int).SetUint64(t.json.Env.Number), + Time: new(big.Int).SetUint64(t.json.Env.Timestamp), + GasLimit: t.json.Env.GasLimit, + Difficulty: t.json.Env.Difficulty, + GasPrice: t.json.Exec.GasPrice, + } + vmconfig.NoRecursion = true + return vm.NewEVM(context, statedb, params.MainnetChainConfig, vmconfig) +} + +func vmTestBlockHash(n uint64) common.Hash { + return common.BytesToHash(crypto.Keccak256([]byte(big.NewInt(int64(n)).String()))) +} diff --git a/vendor/github.com/ethereum/go-ethereum/trie/errors.go b/vendor/github.com/ethereum/go-ethereum/trie/errors.go index e23f9d563..567b80078 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/errors.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/errors.go @@ -23,24 +23,13 @@ import ( ) // MissingNodeError is returned by the trie functions (TryGet, TryUpdate, TryDelete) -// in the case where a trie node is not present in the local database. Contains -// information necessary for retrieving the missing node through an ODR service. -// -// NodeHash is the hash of the missing node -// -// RootHash is the original root of the trie that contains the node -// -// PrefixLen is the nibble length of the key prefix that leads from the root to -// the missing node -// -// SuffixLen is the nibble length of the remaining part of the key that hints on -// which further nodes should also be retrieved (can be zero when there are no -// such hints in the error message) +// in the case where a trie node is not present in the local database. It contains +// information necessary for retrieving the missing node. type MissingNodeError struct { - RootHash, NodeHash common.Hash - PrefixLen, SuffixLen int + NodeHash common.Hash // hash of the missing node + Path []byte // hex-encoded path to the missing node } func (err *MissingNodeError) Error() string { - return fmt.Sprintf("Missing trie node %064x", err.NodeHash) + return fmt.Sprintf("missing trie node %x (path %x)", err.NodeHash, err.Path) } diff --git a/vendor/github.com/ethereum/go-ethereum/trie/hasher.go b/vendor/github.com/ethereum/go-ethereum/trie/hasher.go index 85b6b60f5..672456e2d 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/hasher.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/hasher.go @@ -50,7 +50,7 @@ func returnHasherToPool(h *hasher) { } // hash collapses a node down into a hash node, also returning a copy of the -// original node initialzied with the computed hash to replace the original one. +// original node initialized with the computed hash to replace the original one. func (h *hasher) hash(n node, db DatabaseWriter, force bool) (node, node, error) { // If we're not storing the node, just hashing, use available cached data if hash, dirty := n.cache(); hash != nil { diff --git a/vendor/github.com/ethereum/go-ethereum/trie/iterator.go b/vendor/github.com/ethereum/go-ethereum/trie/iterator.go index 26ae1d5ad..76146c0d6 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/iterator.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/iterator.go @@ -24,14 +24,13 @@ import ( "github.com/ethereum/go-ethereum/common" ) -var iteratorEnd = errors.New("end of iteration") - // Iterator is a key-value trie iterator that traverses a Trie. type Iterator struct { nodeIt NodeIterator Key []byte // Current data key on which the iterator is positioned on Value []byte // Current data value on which the iterator is positioned on + Err error } // NewIterator creates a new key-value iterator from a node iterator @@ -45,35 +44,42 @@ func NewIterator(it NodeIterator) *Iterator { func (it *Iterator) Next() bool { for it.nodeIt.Next(true) { if it.nodeIt.Leaf() { - it.Key = hexToKeybytes(it.nodeIt.Path()) + it.Key = it.nodeIt.LeafKey() it.Value = it.nodeIt.LeafBlob() return true } } it.Key = nil it.Value = nil + it.Err = it.nodeIt.Error() return false } // NodeIterator is an iterator to traverse the trie pre-order. type NodeIterator interface { - // Hash returns the hash of the current node - Hash() common.Hash - // Parent returns the hash of the parent of the current node - Parent() common.Hash - // Leaf returns true iff the current node is a leaf node. - Leaf() bool - // LeafBlob returns the contents of the node, if it is a leaf. - // Callers must not retain references to the return value after calling Next() - LeafBlob() []byte - // Path returns the hex-encoded path to the current node. - // Callers must not retain references to the return value after calling Next() - Path() []byte // Next moves the iterator to the next node. If the parameter is false, any child // nodes will be skipped. Next(bool) bool // Error returns the error status of the iterator. Error() error + + // Hash returns the hash of the current node. + Hash() common.Hash + // Parent returns the hash of the parent of the current node. The hash may be the one + // grandparent if the immediate parent is an internal node with no hash. + Parent() common.Hash + // Path returns the hex-encoded path to the current node. + // Callers must not retain references to the return value after calling Next. + // For leaf nodes, the last element of the path is the 'terminator symbol' 0x10. + Path() []byte + + // Leaf returns true iff the current node is a leaf node. + // LeafBlob, LeafKey return the contents and key of the leaf node. These + // method panic if the iterator is not positioned at a leaf. + // Callers must not retain references to their return value after calling Next + Leaf() bool + LeafBlob() []byte + LeafKey() []byte } // nodeIteratorState represents the iteration state at one particular node of the @@ -89,8 +95,21 @@ type nodeIteratorState struct { type nodeIterator struct { trie *Trie // Trie being iterated stack []*nodeIteratorState // Hierarchy of trie nodes persisting the iteration state - err error // Failure set in case of an internal error in the iterator path []byte // Path to the current node + err error // Failure set in case of an internal error in the iterator +} + +// iteratorEnd is stored in nodeIterator.err when iteration is done. +var iteratorEnd = errors.New("end of iteration") + +// seekError is stored in nodeIterator.err if the initial seek has failed. +type seekError struct { + key []byte + err error +} + +func (e seekError) Error() string { + return "seek error: " + e.err.Error() } func newNodeIterator(trie *Trie, start []byte) NodeIterator { @@ -98,60 +117,57 @@ func newNodeIterator(trie *Trie, start []byte) NodeIterator { return new(nodeIterator) } it := &nodeIterator{trie: trie} - it.seek(start) + it.err = it.seek(start) return it } -// Hash returns the hash of the current node func (it *nodeIterator) Hash() common.Hash { if len(it.stack) == 0 { return common.Hash{} } - return it.stack[len(it.stack)-1].hash } -// Parent returns the hash of the parent node func (it *nodeIterator) Parent() common.Hash { if len(it.stack) == 0 { return common.Hash{} } - return it.stack[len(it.stack)-1].parent } -// Leaf returns true if the current node is a leaf func (it *nodeIterator) Leaf() bool { - if len(it.stack) == 0 { - return false - } - - _, ok := it.stack[len(it.stack)-1].node.(valueNode) - return ok + return hasTerm(it.path) } -// LeafBlob returns the data for the current node, if it is a leaf func (it *nodeIterator) LeafBlob() []byte { - if len(it.stack) == 0 { - return nil + if len(it.stack) > 0 { + if node, ok := it.stack[len(it.stack)-1].node.(valueNode); ok { + return []byte(node) + } } - - if node, ok := it.stack[len(it.stack)-1].node.(valueNode); ok { - return []byte(node) - } - return nil + panic("not at leaf") +} + +func (it *nodeIterator) LeafKey() []byte { + if len(it.stack) > 0 { + if _, ok := it.stack[len(it.stack)-1].node.(valueNode); ok { + return hexToKeybytes(it.path) + } + } + panic("not at leaf") } -// Path returns the hex-encoded path to the current node func (it *nodeIterator) Path() []byte { return it.path } -// Error returns the error set in case of an internal error in the iterator func (it *nodeIterator) Error() error { if it.err == iteratorEnd { return nil } + if seek, ok := it.err.(seekError); ok { + return seek.err + } return it.err } @@ -160,29 +176,37 @@ func (it *nodeIterator) Error() error { // sets the Error field to the encountered failure. If `descend` is false, // skips iterating over any subnodes of the current node. func (it *nodeIterator) Next(descend bool) bool { - if it.err != nil { + if it.err == iteratorEnd { return false } - // Otherwise step forward with the iterator and report any errors + if seek, ok := it.err.(seekError); ok { + if it.err = it.seek(seek.key); it.err != nil { + return false + } + } + // Otherwise step forward with the iterator and report any errors. state, parentIndex, path, err := it.peek(descend) - if err != nil { - it.err = err + it.err = err + if it.err != nil { return false } it.push(state, parentIndex, path) return true } -func (it *nodeIterator) seek(prefix []byte) { +func (it *nodeIterator) seek(prefix []byte) error { // The path we're looking for is the hex encoded key without terminator. key := keybytesToHex(prefix) key = key[:len(key)-1] // Move forward until we're just before the closest match to key. for { state, parentIndex, path, err := it.peek(bytes.HasPrefix(key, it.path)) - if err != nil || bytes.Compare(path, key) >= 0 { - it.err = err - return + if err == iteratorEnd { + return iteratorEnd + } else if err != nil { + return seekError{prefix, err} + } else if bytes.Compare(path, key) >= 0 { + return nil } it.push(state, parentIndex, path) } @@ -197,7 +221,8 @@ func (it *nodeIterator) peek(descend bool) (*nodeIteratorState, *int, []byte, er if root != emptyRoot { state.hash = root } - return state, nil, nil, nil + err := state.resolve(it.trie, nil) + return state, nil, nil, err } if !descend { // If we're skipping children, pop the current node first @@ -205,72 +230,73 @@ func (it *nodeIterator) peek(descend bool) (*nodeIteratorState, *int, []byte, er } // Continue iteration to the next child - for { - if len(it.stack) == 0 { - return nil, nil, nil, iteratorEnd - } + for len(it.stack) > 0 { parent := it.stack[len(it.stack)-1] ancestor := parent.hash if (ancestor == common.Hash{}) { ancestor = parent.parent } - if node, ok := parent.node.(*fullNode); ok { - // Full node, move to the first non-nil child. - for i := parent.index + 1; i < len(node.Children); i++ { - child := node.Children[i] - if child != nil { - hash, _ := child.cache() - state := &nodeIteratorState{ - hash: common.BytesToHash(hash), - node: child, - parent: ancestor, - index: -1, - pathlen: len(it.path), - } - path := append(it.path, byte(i)) - parent.index = i - 1 - return state, &parent.index, path, nil - } - } - } else if node, ok := parent.node.(*shortNode); ok { - // Short node, return the pointer singleton child - if parent.index < 0 { - hash, _ := node.Val.cache() - state := &nodeIteratorState{ - hash: common.BytesToHash(hash), - node: node.Val, - parent: ancestor, - index: -1, - pathlen: len(it.path), - } - var path []byte - if hasTerm(node.Key) { - path = append(it.path, node.Key[:len(node.Key)-1]...) - } else { - path = append(it.path, node.Key...) - } - return state, &parent.index, path, nil - } - } else if hash, ok := parent.node.(hashNode); ok { - // Hash node, resolve the hash child from the database - if parent.index < 0 { - node, err := it.trie.resolveHash(hash, nil, nil) - if err != nil { - return it.stack[len(it.stack)-1], &parent.index, it.path, err - } - state := &nodeIteratorState{ - hash: common.BytesToHash(hash), - node: node, - parent: ancestor, - index: -1, - pathlen: len(it.path), - } - return state, &parent.index, it.path, nil + state, path, ok := it.nextChild(parent, ancestor) + if ok { + if err := state.resolve(it.trie, path); err != nil { + return parent, &parent.index, path, err } + return state, &parent.index, path, nil } // No more child nodes, move back up. it.pop() } + return nil, nil, nil, iteratorEnd +} + +func (st *nodeIteratorState) resolve(tr *Trie, path []byte) error { + if hash, ok := st.node.(hashNode); ok { + resolved, err := tr.resolveHash(hash, path) + if err != nil { + return err + } + st.node = resolved + st.hash = common.BytesToHash(hash) + } + return nil +} + +func (it *nodeIterator) nextChild(parent *nodeIteratorState, ancestor common.Hash) (*nodeIteratorState, []byte, bool) { + switch node := parent.node.(type) { + case *fullNode: + // Full node, move to the first non-nil child. + for i := parent.index + 1; i < len(node.Children); i++ { + child := node.Children[i] + if child != nil { + hash, _ := child.cache() + state := &nodeIteratorState{ + hash: common.BytesToHash(hash), + node: child, + parent: ancestor, + index: -1, + pathlen: len(it.path), + } + path := append(it.path, byte(i)) + parent.index = i - 1 + return state, path, true + } + } + case *shortNode: + // Short node, return the pointer singleton child + if parent.index < 0 { + hash, _ := node.Val.cache() + state := &nodeIteratorState{ + hash: common.BytesToHash(hash), + node: node.Val, + parent: ancestor, + index: -1, + pathlen: len(it.path), + } + path := append(it.path, node.Key...) + return state, path, true + } + } + return parent, it.path, false } func (it *nodeIterator) push(state *nodeIteratorState, parentIndex *int, path []byte) { @@ -288,23 +314,21 @@ func (it *nodeIterator) pop() { } func compareNodes(a, b NodeIterator) int { - cmp := bytes.Compare(a.Path(), b.Path()) - if cmp != 0 { + if cmp := bytes.Compare(a.Path(), b.Path()); cmp != 0 { return cmp } - if a.Leaf() && !b.Leaf() { return -1 } else if b.Leaf() && !a.Leaf() { return 1 } - - cmp = bytes.Compare(a.Hash().Bytes(), b.Hash().Bytes()) - if cmp != 0 { + if cmp := bytes.Compare(a.Hash().Bytes(), b.Hash().Bytes()); cmp != 0 { return cmp } - - return bytes.Compare(a.LeafBlob(), b.LeafBlob()) + if a.Leaf() && b.Leaf() { + return bytes.Compare(a.LeafBlob(), b.LeafBlob()) + } + return 0 } type differenceIterator struct { @@ -341,6 +365,10 @@ func (it *differenceIterator) LeafBlob() []byte { return it.b.LeafBlob() } +func (it *differenceIterator) LeafKey() []byte { + return it.b.LeafKey() +} + func (it *differenceIterator) Path() []byte { return it.b.Path() } @@ -410,7 +438,6 @@ func (h *nodeIteratorHeap) Pop() interface{} { type unionIterator struct { items *nodeIteratorHeap // Nodes returned are the union of the ones in these iterators count int // Number of nodes scanned across all tries - err error // The error, if one has been encountered } // NewUnionIterator constructs a NodeIterator that iterates over elements in the union @@ -421,9 +448,7 @@ func NewUnionIterator(iters []NodeIterator) (NodeIterator, *int) { copy(h, iters) heap.Init(&h) - ui := &unionIterator{ - items: &h, - } + ui := &unionIterator{items: &h} return ui, &ui.count } @@ -443,6 +468,10 @@ func (it *unionIterator) LeafBlob() []byte { return (*it.items)[0].LeafBlob() } +func (it *unionIterator) LeafKey() []byte { + return (*it.items)[0].LeafKey() +} + func (it *unionIterator) Path() []byte { return (*it.items)[0].Path() } diff --git a/vendor/github.com/ethereum/go-ethereum/trie/proof.go b/vendor/github.com/ethereum/go-ethereum/trie/proof.go index b92156f2e..298f648c4 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/proof.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/proof.go @@ -58,7 +58,7 @@ func (t *Trie) Prove(key []byte) []rlp.RawValue { nodes = append(nodes, n) case hashNode: var err error - tn, err = t.resolveHash(n, nil, nil) + tn, err = t.resolveHash(n, nil) if err != nil { log.Error(fmt.Sprintf("Unhandled trie error: %v", err)) return nil @@ -96,7 +96,6 @@ func VerifyProof(rootHash common.Hash, key []byte, proof []rlp.RawValue) (value sha.Reset() sha.Write(buf) if !bytes.Equal(sha.Sum(nil), wantHash) { - log.Error("Invalid CHT Proof", "hash", common.ToHex(sha.Sum(nil)), "node", i) return nil, fmt.Errorf("bad proof node %d: hash mismatch", i) } n, err := decodeNode(wantHash, buf, 0) @@ -126,7 +125,7 @@ func VerifyProof(rootHash common.Hash, key []byte, proof []rlp.RawValue) (value } func get(tn node, key []byte) ([]byte, node) { - for len(key) > 0 { + for { switch n := tn.(type) { case *shortNode: if len(key) < len(n.Key) || !bytes.Equal(n.Key, key[:len(n.Key)]) { @@ -141,9 +140,10 @@ func get(tn node, key []byte) ([]byte, node) { return key, n case nil: return key, nil + case valueNode: + return nil, n default: panic(fmt.Sprintf("%T: invalid node: %v", tn, tn)) } } - return nil, tn.(valueNode) } diff --git a/vendor/github.com/ethereum/go-ethereum/trie/secure_trie.go b/vendor/github.com/ethereum/go-ethereum/trie/secure_trie.go index 37d1d4b09..20c303f31 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/secure_trie.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/secure_trie.go @@ -156,6 +156,11 @@ func (t *SecureTrie) Root() []byte { return t.trie.Root() } +func (t *SecureTrie) Copy() *SecureTrie { + cpy := *t + return &cpy +} + // NodeIterator returns an iterator that returns nodes of the underlying trie. Iteration // starts at the key after the given start key. func (t *SecureTrie) NodeIterator(start []byte) NodeIterator { diff --git a/vendor/github.com/ethereum/go-ethereum/trie/sync.go b/vendor/github.com/ethereum/go-ethereum/trie/sync.go index 168501392..9e8449431 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/sync.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/sync.go @@ -28,6 +28,10 @@ import ( // node it did not request. var ErrNotRequested = errors.New("not requested") +// ErrAlreadyProcessed is returned by the trie sync when it's requested to process a +// node it already processed previously. +var ErrAlreadyProcessed = errors.New("already processed") + // request represents a scheduled or already in-flight state retrieval request. type request struct { hash common.Hash // Hash of the node data content to retrieve @@ -48,6 +52,21 @@ type SyncResult struct { Data []byte // Data content of the retrieved node } +// syncMemBatch is an in-memory buffer of successfully downloaded but not yet +// persisted data items. +type syncMemBatch struct { + batch map[common.Hash][]byte // In-memory membatch of recently ocmpleted items + order []common.Hash // Order of completion to prevent out-of-order data loss +} + +// newSyncMemBatch allocates a new memory-buffer for not-yet persisted trie nodes. +func newSyncMemBatch() *syncMemBatch { + return &syncMemBatch{ + batch: make(map[common.Hash][]byte), + order: make([]common.Hash, 0, 256), + } +} + // TrieSyncLeafCallback is a callback type invoked when a trie sync reaches a // leaf node. It's used by state syncing to check if the leaf node requires some // further data syncing. @@ -57,7 +76,8 @@ type TrieSyncLeafCallback func(leaf []byte, parent common.Hash) error // unknown trie hashes to retrieve, accepts node data associated with said hashes // and reconstructs the trie step by step until all is done. type TrieSync struct { - database DatabaseReader + database DatabaseReader // Persistent database to check for existing entries + membatch *syncMemBatch // Memory buffer to avoid frequest database writes requests map[common.Hash]*request // Pending requests pertaining to a key hash queue *prque.Prque // Priority queue with the pending requests } @@ -66,6 +86,7 @@ type TrieSync struct { func NewTrieSync(root common.Hash, database DatabaseReader, callback TrieSyncLeafCallback) *TrieSync { ts := &TrieSync{ database: database, + membatch: newSyncMemBatch(), requests: make(map[common.Hash]*request), queue: prque.New(), } @@ -79,6 +100,9 @@ func (s *TrieSync) AddSubTrie(root common.Hash, depth int, parent common.Hash, c if root == emptyRoot { return } + if _, ok := s.membatch.batch[root]; ok { + return + } key := root.Bytes() blob, _ := s.database.Get(key) if local, err := decodeNode(key, blob, 0); local != nil && err == nil { @@ -111,6 +135,9 @@ func (s *TrieSync) AddRawEntry(hash common.Hash, depth int, parent common.Hash) if hash == emptyState { return } + if _, ok := s.membatch.batch[hash]; ok { + return + } if blob, _ := s.database.Get(hash.Bytes()); blob != nil { return } @@ -144,7 +171,7 @@ func (s *TrieSync) Missing(max int) []common.Hash { // Process injects a batch of retrieved trie nodes data, returning if something // was committed to the database and also the index of an entry if processing of // it failed. -func (s *TrieSync) Process(results []SyncResult, dbw DatabaseWriter) (bool, int, error) { +func (s *TrieSync) Process(results []SyncResult) (bool, int, error) { committed := false for i, item := range results { @@ -153,10 +180,13 @@ func (s *TrieSync) Process(results []SyncResult, dbw DatabaseWriter) (bool, int, if request == nil { return committed, i, ErrNotRequested } + if request.data != nil { + return committed, i, ErrAlreadyProcessed + } // If the item is a raw entry request, commit directly if request.raw { request.data = item.Data - s.commit(request, dbw) + s.commit(request) committed = true continue } @@ -173,7 +203,7 @@ func (s *TrieSync) Process(results []SyncResult, dbw DatabaseWriter) (bool, int, return committed, i, err } if len(requests) == 0 && request.deps == 0 { - s.commit(request, dbw) + s.commit(request) committed = true continue } @@ -185,6 +215,22 @@ func (s *TrieSync) Process(results []SyncResult, dbw DatabaseWriter) (bool, int, return committed, 0, nil } +// Commit flushes the data stored in the internal membatch out to persistent +// storage, returning th enumber of items written and any occurred error. +func (s *TrieSync) Commit(dbw DatabaseWriter) (int, error) { + // Dump the membatch into a database dbw + for i, key := range s.membatch.order { + if err := dbw.Put(key[:], s.membatch.batch[key]); err != nil { + return i, err + } + } + written := len(s.membatch.order) + + // Drop the membatch data and return + s.membatch = newSyncMemBatch() + return written, nil +} + // Pending returns the number of state entries currently pending for download. func (s *TrieSync) Pending() int { return len(s.requests) @@ -246,13 +292,17 @@ func (s *TrieSync) children(req *request, object node) ([]*request, error) { // If the child references another node, resolve or schedule if node, ok := (child.node).(hashNode); ok { // Try to resolve the node from the local database + hash := common.BytesToHash(node) + if _, ok := s.membatch.batch[hash]; ok { + continue + } blob, _ := s.database.Get(node) if local, err := decodeNode(node[:], blob, 0); local != nil && err == nil { continue } // Locally unknown node, schedule for retrieval requests = append(requests, &request{ - hash: common.BytesToHash(node), + hash: hash, parents: []*request{req}, depth: child.depth, callback: req.callback, @@ -262,21 +312,21 @@ func (s *TrieSync) children(req *request, object node) ([]*request, error) { return requests, nil } -// commit finalizes a retrieval request and stores it into the database. If any +// commit finalizes a retrieval request and stores it into the membatch. If any // of the referencing parent requests complete due to this commit, they are also // committed themselves. -func (s *TrieSync) commit(req *request, dbw DatabaseWriter) (err error) { - // Write the node content to disk - if err := dbw.Put(req.hash[:], req.data); err != nil { - return err - } +func (s *TrieSync) commit(req *request) (err error) { + // Write the node content to the membatch + s.membatch.batch[req.hash] = req.data + s.membatch.order = append(s.membatch.order, req.hash) + delete(s.requests, req.hash) // Check all parents for completion for _, parent := range req.parents { parent.deps-- if parent.deps == 0 { - if err := s.commit(parent, dbw); err != nil { + if err := s.commit(parent); err != nil { return err } } diff --git a/vendor/github.com/ethereum/go-ethereum/trie/trie.go b/vendor/github.com/ethereum/go-ethereum/trie/trie.go index 5759f97e3..a3151b1ce 100644 --- a/vendor/github.com/ethereum/go-ethereum/trie/trie.go +++ b/vendor/github.com/ethereum/go-ethereum/trie/trie.go @@ -40,7 +40,7 @@ var ( ) // CacheMisses retrieves a global counter measuring the number of cache misses -// the trie did since process startup. This isn't useful for anything apart from +// the trie had since process startup. This isn't useful for anything apart from // trie debugging purposes. func CacheMisses() int64 { return cacheMissCounter.Count() @@ -87,14 +87,14 @@ type Trie struct { originalRoot common.Hash // Cache generation values. - // cachegen increase by one with each commit operation. + // cachegen increases by one with each commit operation. // new nodes are tagged with the current generation and unloaded // when their generation is older than than cachegen-cachelimit. cachegen, cachelimit uint16 } // SetCacheLimit sets the number of 'cache generations' to keep. -// A cache generations is created by a call to Commit. +// A cache generation is created by a call to Commit. func (t *Trie) SetCacheLimit(l uint16) { t.cachelimit = l } @@ -116,7 +116,7 @@ func New(root common.Hash, db Database) (*Trie, error) { if db == nil { panic("trie.New: cannot use existing root without a database") } - rootnode, err := trie.resolveHash(root[:], nil, nil) + rootnode, err := trie.resolveHash(root[:], nil) if err != nil { return nil, err } @@ -180,7 +180,7 @@ func (t *Trie) tryGet(origNode node, key []byte, pos int) (value []byte, newnode } return value, n, didResolve, err case hashNode: - child, err := t.resolveHash(n, key[:pos], key[pos:]) + child, err := t.resolveHash(n, key[:pos]) if err != nil { return nil, n, true, err } @@ -283,7 +283,7 @@ func (t *Trie) insert(n node, prefix, key []byte, value node) (bool, node, error // We've hit a part of the trie that isn't loaded yet. Load // the node and insert into it. This leaves all child nodes on // the path to the value in the trie. - rn, err := t.resolveHash(n, prefix, key) + rn, err := t.resolveHash(n, prefix) if err != nil { return false, nil, err } @@ -388,7 +388,7 @@ func (t *Trie) delete(n node, prefix, key []byte) (bool, node, error) { // shortNode{..., shortNode{...}}. Since the entry // might not be loaded yet, resolve it just for this // check. - cnode, err := t.resolve(n.Children[pos], prefix, []byte{byte(pos)}) + cnode, err := t.resolve(n.Children[pos], prefix) if err != nil { return false, nil, err } @@ -414,7 +414,7 @@ func (t *Trie) delete(n node, prefix, key []byte) (bool, node, error) { // We've hit a part of the trie that isn't loaded yet. Load // the node and delete from it. This leaves all child nodes on // the path to the value in the trie. - rn, err := t.resolveHash(n, prefix, key) + rn, err := t.resolveHash(n, prefix) if err != nil { return false, nil, err } @@ -436,24 +436,19 @@ func concat(s1 []byte, s2 ...byte) []byte { return r } -func (t *Trie) resolve(n node, prefix, suffix []byte) (node, error) { +func (t *Trie) resolve(n node, prefix []byte) (node, error) { if n, ok := n.(hashNode); ok { - return t.resolveHash(n, prefix, suffix) + return t.resolveHash(n, prefix) } return n, nil } -func (t *Trie) resolveHash(n hashNode, prefix, suffix []byte) (node, error) { +func (t *Trie) resolveHash(n hashNode, prefix []byte) (node, error) { cacheMissCounter.Inc(1) enc, err := t.db.Get(n) if err != nil || enc == nil { - return nil, &MissingNodeError{ - RootHash: t.originalRoot, - NodeHash: common.BytesToHash(n), - PrefixLen: len(prefix), - SuffixLen: len(suffix), - } + return nil, &MissingNodeError{NodeHash: common.BytesToHash(n), Path: prefix} } dec := mustDecodeNode(n, enc, t.cachegen) return dec, nil diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/shhclient/client.go b/vendor/github.com/ethereum/go-ethereum/whisper/shhclient/client.go new file mode 100644 index 000000000..61c1b7ab7 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/whisper/shhclient/client.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 shhclient + +import ( + "context" + + "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/common/hexutil" + "github.com/ethereum/go-ethereum/rpc" + whisper "github.com/ethereum/go-ethereum/whisper/whisperv5" +) + +// Client defines typed wrappers for the Whisper v5 RPC API. +type Client struct { + c *rpc.Client +} + +// Dial connects a client to the given URL. +func Dial(rawurl string) (*Client, error) { + c, err := rpc.Dial(rawurl) + if err != nil { + return nil, err + } + return NewClient(c), nil +} + +// NewClient creates a client that uses the given RPC client. +func NewClient(c *rpc.Client) *Client { + return &Client{c} +} + +// Version returns the Whisper sub-protocol version. +func (sc *Client) Version(ctx context.Context) (uint, error) { + var result uint + err := sc.c.CallContext(ctx, &result, "shh_version") + return result, err +} + +// Info returns diagnostic information about the whisper node. +func (sc *Client) Info(ctx context.Context) (whisper.Info, error) { + var info whisper.Info + err := sc.c.CallContext(ctx, &info, "shh_info") + return info, err +} + +// SetMaxMessageSize sets the maximal message size allowed by this node. Incoming +// and outgoing messages with a larger size will be rejected. Whisper message size +// can never exceed the limit imposed by the underlying P2P protocol (10 Mb). +func (sc *Client) SetMaxMessageSize(ctx context.Context, size uint32) error { + var ignored bool + return sc.c.CallContext(ctx, &ignored, "shh_setMaxMessageSize", size) +} + +// SetMinimumPoW (experimental) sets the minimal PoW required by this node. + +// This experimental function was introduced for the future dynamic adjustment of +// PoW requirement. If the node is overwhelmed with messages, it should raise the +// PoW requirement and notify the peers. The new value should be set relative to +// the old value (e.g. double). The old value could be obtained via shh_info call. +func (sc *Client) SetMinimumPoW(ctx context.Context, pow float64) error { + var ignored bool + return sc.c.CallContext(ctx, &ignored, "shh_setMinPoW", pow) +} + +// Marks specific peer trusted, which will allow it to send historic (expired) messages. +// Note This function is not adding new nodes, the node needs to exists as a peer. +func (sc *Client) MarkTrustedPeer(ctx context.Context, enode string) error { + var ignored bool + return sc.c.CallContext(ctx, &ignored, "shh_markTrustedPeer", enode) +} + +// NewKeyPair generates a new public and private key pair for message decryption and encryption. +// It returns an identifier that can be used to refer to the key. +func (sc *Client) NewKeyPair(ctx context.Context) (string, error) { + var id string + return id, sc.c.CallContext(ctx, &id, "shh_newKeyPair") +} + +// AddPrivateKey stored the key pair, and returns its ID. +func (sc *Client) AddPrivateKey(ctx context.Context, key []byte) (string, error) { + var id string + return id, sc.c.CallContext(ctx, &id, "shh_addPrivateKey", hexutil.Bytes(key)) +} + +// DeleteKeyPair delete the specifies key. +func (sc *Client) DeleteKeyPair(ctx context.Context, id string) (string, error) { + var ignored bool + return id, sc.c.CallContext(ctx, &ignored, "shh_deleteKeyPair", id) +} + +// HasKeyPair returns an indication if the node has a private key or +// key pair matching the given ID. +func (sc *Client) HasKeyPair(ctx context.Context, id string) (bool, error) { + var has bool + return has, sc.c.CallContext(ctx, &has, "shh_hasKeyPair", id) +} + +// PublicKey return the public key for a key ID. +func (sc *Client) PublicKey(ctx context.Context, id string) ([]byte, error) { + var key hexutil.Bytes + return []byte(key), sc.c.CallContext(ctx, &key, "shh_getPublicKey", id) +} + +// PrivateKey return the private key for a key ID. +func (sc *Client) PrivateKey(ctx context.Context, id string) ([]byte, error) { + var key hexutil.Bytes + return []byte(key), sc.c.CallContext(ctx, &key, "shh_getPrivateKey", id) +} + +// NewSymmetricKey generates a random symmetric key and returns its identifier. +// Can be used encrypting and decrypting messages where the key is known to both parties. +func (sc *Client) NewSymmetricKey(ctx context.Context) (string, error) { + var id string + return id, sc.c.CallContext(ctx, &id, "shh_newSymKey") +} + +// AddSymmetricKey stores the key, and returns its identifier. +func (sc *Client) AddSymmetricKey(ctx context.Context, key []byte) (string, error) { + var id string + return id, sc.c.CallContext(ctx, &id, "shh_addSymKey", hexutil.Bytes(key)) +} + +// GenerateSymmetricKeyFromPassword generates the key from password, stores it, and returns its identifier. +func (sc *Client) GenerateSymmetricKeyFromPassword(ctx context.Context, passwd []byte) (string, error) { + var id string + return id, sc.c.CallContext(ctx, &id, "shh_generateSymKeyFromPassword", hexutil.Bytes(passwd)) +} + +// HasSymmetricKey returns an indication if the key associated with the given id is stored in the node. +func (sc *Client) HasSymmetricKey(ctx context.Context, id string) (bool, error) { + var found bool + return found, sc.c.CallContext(ctx, &found, "shh_hasSymKey", id) +} + +// GetSymmetricKey returns the symmetric key associated with the given identifier. +func (sc *Client) GetSymmetricKey(ctx context.Context, id string) ([]byte, error) { + var key hexutil.Bytes + return []byte(key), sc.c.CallContext(ctx, &key, "shh_getSymKey", id) +} + +// DeleteSymmetricKey deletes the symmetric key associated with the given identifier. +func (sc *Client) DeleteSymmetricKey(ctx context.Context, id string) error { + var ignored bool + return sc.c.CallContext(ctx, &ignored, "shh_deleteSymKey", id) +} + +// Post a message onto the network. +func (sc *Client) Post(ctx context.Context, message whisper.NewMessage) error { + var ignored bool + return sc.c.CallContext(ctx, &ignored, "shh_post", message) +} + +// SubscribeMessages subscribes to messages that match the given criteria. This method +// is only supported on bi-directional connections such as websockets and IPC. +// NewMessageFilter uses polling and is supported over HTTP. +func (ec *Client) SubscribeMessages(ctx context.Context, criteria whisper.Criteria, ch chan<- *whisper.Message) (ethereum.Subscription, error) { + return ec.c.ShhSubscribe(ctx, ch, "messages", criteria) +} + +// NewMessageFilter creates a filter within the node. This filter can be used to poll +// for new messages (see FilterMessages) that satisfy the given criteria. A filter can +// timeout when it was polled for in whisper.filterTimeout. +func (ec *Client) NewMessageFilter(ctx context.Context, criteria whisper.Criteria) (string, error) { + var id string + return id, ec.c.CallContext(ctx, &id, "shh_newMessageFilter", criteria) +} + +// DeleteMessageFilter removes the filter associated with the given id. +func (ec *Client) DeleteMessageFilter(ctx context.Context, id string) error { + var ignored bool + return ec.c.CallContext(ctx, &ignored, "shh_deleteMessageFilter", id) +} + +// FilterMessages retrieves all messages that are received between the last call to +// this function and match the criteria that where given when the filter was created. +func (ec *Client) FilterMessages(ctx context.Context, id string) ([]*whisper.Message, error) { + var messages []*whisper.Message + return messages, ec.c.CallContext(ctx, &messages, "shh_getFilterMessages", id) +} diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/api.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/api.go index f4af2f8eb..7cf772cfc 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/api.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/api.go @@ -17,564 +17,585 @@ package whisperv5 import ( - "encoding/json" + "context" + "crypto/ecdsa" "errors" "fmt" + "sync" + "time" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/p2p/discover" + "github.com/ethereum/go-ethereum/rpc" ) -var whisperOfflineErr = errors.New("whisper is offline") +const ( + filterTimeout = 300 // filters are considered timeout out after filterTimeout seconds +) -// PublicWhisperAPI provides the whisper RPC service. +var ( + ErrSymAsym = errors.New("specify either a symetric or a asymmetric key") + ErrInvalidSymmetricKey = errors.New("invalid symmetric key") + ErrInvalidPublicKey = errors.New("invalid public key") + ErrInvalidSigningPubKey = errors.New("invalid signing public key") + ErrTooLowPoW = errors.New("message rejected, PoW too low") + ErrNoTopics = errors.New("missing topic(s)") +) + +// PublicWhisperAPI provides the whisper RPC service that can be +// use publicly without security implications. type PublicWhisperAPI struct { - whisper *Whisper + w *Whisper + + mu sync.Mutex + lastUsed map[string]time.Time // keeps track when a filter was polled for the last time. } // NewPublicWhisperAPI create a new RPC whisper service. func NewPublicWhisperAPI(w *Whisper) *PublicWhisperAPI { - return &PublicWhisperAPI{whisper: w} + api := &PublicWhisperAPI{ + w: w, + lastUsed: make(map[string]time.Time), + } + + go api.run() + return api } -// Start starts the Whisper worker threads. -func (api *PublicWhisperAPI) Start() error { - if api.whisper == nil { - return whisperOfflineErr +// run the api event loop. +// this loop deletes filter that have not been used within filterTimeout +func (api *PublicWhisperAPI) run() { + timeout := time.NewTicker(2 * time.Minute) + for { + <-timeout.C + + api.mu.Lock() + for id, lastUsed := range api.lastUsed { + if time.Since(lastUsed).Seconds() >= filterTimeout { + delete(api.lastUsed, id) + if err := api.w.Unsubscribe(id); err != nil { + log.Error("could not unsubscribe whisper filter", "error", err) + } + log.Debug("delete whisper filter (timeout)", "id", id) + } + } + api.mu.Unlock() } - return api.whisper.Start(nil) } -// Stop stops the Whisper worker threads. -func (api *PublicWhisperAPI) Stop() error { - if api.whisper == nil { - return whisperOfflineErr - } - return api.whisper.Stop() +// Version returns the Whisper sub-protocol version. +func (api *PublicWhisperAPI) Version(ctx context.Context) string { + return ProtocolVersionStr } -// Version returns the Whisper version this node offers. -func (api *PublicWhisperAPI) Version() (hexutil.Uint, error) { - if api.whisper == nil { - return 0, whisperOfflineErr - } - return hexutil.Uint(api.whisper.Version()), nil +// Info contains diagnostic information. +type Info struct { + Memory int `json:"memory"` // Memory size of the floating messages in bytes. + Messages int `json:"messages"` // Number of floating messages. + MinPow float64 `json:"minPow"` // Minimal accepted PoW + MaxMessageSize uint32 `json:"maxMessageSize"` // Maximum accepted message size } -// Info returns the Whisper statistics for diagnostics. -func (api *PublicWhisperAPI) Info() (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr +// Info returns diagnostic information about the whisper node. +func (api *PublicWhisperAPI) Info(ctx context.Context) Info { + stats := api.w.Stats() + return Info{ + Memory: stats.memoryUsed, + Messages: len(api.w.messageQueue) + len(api.w.p2pMsgQueue), + MinPow: api.w.MinPow(), + MaxMessageSize: api.w.MaxMessageSize(), } - return api.whisper.Stats(), nil } -// SetMaxMessageLength sets the maximal message length allowed by this node -func (api *PublicWhisperAPI) SetMaxMessageLength(val int) error { - if api.whisper == nil { - return whisperOfflineErr - } - return api.whisper.SetMaxMessageLength(val) +// SetMaxMessageSize sets the maximum message size that is accepted. +// Upper limit is defined in whisperv5.MaxMessageSize. +func (api *PublicWhisperAPI) SetMaxMessageSize(ctx context.Context, size uint32) (bool, error) { + return true, api.w.SetMaxMessageSize(size) } -// SetMinimumPoW sets the minimal PoW required by this node -func (api *PublicWhisperAPI) SetMinimumPoW(val float64) error { - if api.whisper == nil { - return whisperOfflineErr - } - return api.whisper.SetMinimumPoW(val) +// SetMinPow sets the minimum PoW for a message before it is accepted. +func (api *PublicWhisperAPI) SetMinPoW(ctx context.Context, pow float64) (bool, error) { + return true, api.w.SetMinimumPoW(pow) } -// AllowP2PMessagesFromPeer marks specific peer trusted, which will allow it -// to send historic (expired) messages. -func (api *PublicWhisperAPI) AllowP2PMessagesFromPeer(enode string) error { - if api.whisper == nil { - return whisperOfflineErr - } +// MarkTrustedPeer marks a peer trusted. , which will allow it to send historic (expired) messages. +// Note: This function is not adding new nodes, the node needs to exists as a peer. +func (api *PublicWhisperAPI) MarkTrustedPeer(ctx context.Context, enode string) (bool, error) { n, err := discover.ParseNode(enode) if err != nil { - return errors.New("failed to parse enode of trusted peer: " + err.Error()) + return false, err } - return api.whisper.AllowP2PMessagesFromPeer(n.ID[:]) + return true, api.w.AllowP2PMessagesFromPeer(n.ID[:]) } -// HasKeyPair checks if the whisper node is configured with the private key -// of the specified public pair. -func (api *PublicWhisperAPI) HasKeyPair(id string) (bool, error) { - if api.whisper == nil { - return false, whisperOfflineErr - } - return api.whisper.HasKeyPair(id), nil +// NewKeyPair generates a new public and private key pair for message decryption and encryption. +// It returns an ID that can be used to refer to the keypair. +func (api *PublicWhisperAPI) NewKeyPair(ctx context.Context) (string, error) { + return api.w.NewKeyPair() } -// DeleteKeyPair deletes the specifies key if it exists. -func (api *PublicWhisperAPI) DeleteKeyPair(id string) (bool, error) { - if api.whisper == nil { - return false, whisperOfflineErr - } - return api.whisper.DeleteKeyPair(id), nil -} - -// NewKeyPair generates a new cryptographic identity for the client, and injects -// it into the known identities for message decryption. -func (api *PublicWhisperAPI) NewKeyPair() (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr - } - return api.whisper.NewKeyPair() -} - -// GetPublicKey returns the public key for identity id -func (api *PublicWhisperAPI) GetPublicKey(id string) (hexutil.Bytes, error) { - if api.whisper == nil { - return nil, whisperOfflineErr - } - key, err := api.whisper.GetPrivateKey(id) +// AddPrivateKey imports the given private key. +func (api *PublicWhisperAPI) AddPrivateKey(ctx context.Context, privateKey hexutil.Bytes) (string, error) { + key, err := crypto.ToECDSA(privateKey) if err != nil { - return nil, err + return "", err + } + return api.w.AddKeyPair(key) +} + +// DeleteKeyPair removes the key with the given key if it exists. +func (api *PublicWhisperAPI) DeleteKeyPair(ctx context.Context, key string) (bool, error) { + if ok := api.w.DeleteKeyPair(key); ok { + return true, nil + } + return false, fmt.Errorf("key pair %s not found", key) +} + +// HasKeyPair returns an indication if the node has a key pair that is associated with the given id. +func (api *PublicWhisperAPI) HasKeyPair(ctx context.Context, id string) bool { + return api.w.HasKeyPair(id) +} + +// GetPublicKey returns the public key associated with the given key. The key is the hex +// encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62. +func (api *PublicWhisperAPI) GetPublicKey(ctx context.Context, id string) (hexutil.Bytes, error) { + key, err := api.w.GetPrivateKey(id) + if err != nil { + return hexutil.Bytes{}, err } return crypto.FromECDSAPub(&key.PublicKey), nil } -// GetPrivateKey returns the private key for identity id -func (api *PublicWhisperAPI) GetPrivateKey(id string) (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr - } - key, err := api.whisper.GetPrivateKey(id) +// GetPublicKey returns the private key associated with the given key. The key is the hex +// encoded representation of a key in the form specified in section 4.3.6 of ANSI X9.62. +func (api *PublicWhisperAPI) GetPrivateKey(ctx context.Context, id string) (hexutil.Bytes, error) { + key, err := api.w.GetPrivateKey(id) if err != nil { - return "", err + return hexutil.Bytes{}, err } - return common.ToHex(crypto.FromECDSA(key)), nil + return crypto.FromECDSA(key), nil } -// GenerateSymmetricKey generates a random symmetric key and stores it under id, -// which is then returned. Will be used in the future for session key exchange. -func (api *PublicWhisperAPI) GenerateSymmetricKey() (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr - } - return api.whisper.GenerateSymKey() +// NewSymKey generate a random symmetric key. +// It returns an ID that can be used to refer to the key. +// Can be used encrypting and decrypting messages where the key is known to both parties. +func (api *PublicWhisperAPI) NewSymKey(ctx context.Context) (string, error) { + return api.w.GenerateSymKey() } -// AddSymmetricKeyDirect stores the key, and returns its id. -func (api *PublicWhisperAPI) AddSymmetricKeyDirect(key hexutil.Bytes) (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr - } - return api.whisper.AddSymKeyDirect(key) +// AddSymKey import a symmetric key. +// It returns an ID that can be used to refer to the key. +// Can be used encrypting and decrypting messages where the key is known to both parties. +func (api *PublicWhisperAPI) AddSymKey(ctx context.Context, key hexutil.Bytes) (string, error) { + return api.w.AddSymKeyDirect([]byte(key)) } -// AddSymmetricKeyFromPassword generates the key from password, stores it, and returns its id. -func (api *PublicWhisperAPI) AddSymmetricKeyFromPassword(password string) (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr - } - return api.whisper.AddSymKeyFromPassword(password) +// GenerateSymKeyFromPassword derive a key from the given password, stores it, and returns its ID. +func (api *PublicWhisperAPI) GenerateSymKeyFromPassword(ctx context.Context, passwd string) (string, error) { + return api.w.AddSymKeyFromPassword(passwd) } -// HasSymmetricKey returns true if there is a key associated with the given id. -// Otherwise returns false. -func (api *PublicWhisperAPI) HasSymmetricKey(id string) (bool, error) { - if api.whisper == nil { - return false, whisperOfflineErr - } - res := api.whisper.HasSymKey(id) - return res, nil +// HasSymKey returns an indication if the node has a symmetric key associated with the given key. +func (api *PublicWhisperAPI) HasSymKey(ctx context.Context, id string) bool { + return api.w.HasSymKey(id) } -// GetSymmetricKey returns the symmetric key associated with the given id. -func (api *PublicWhisperAPI) GetSymmetricKey(name string) (hexutil.Bytes, error) { - if api.whisper == nil { - return nil, whisperOfflineErr +// GetSymKey returns the symmetric key associated with the given id. +func (api *PublicWhisperAPI) GetSymKey(ctx context.Context, id string) (hexutil.Bytes, error) { + return api.w.GetSymKey(id) +} + +// DeleteSymKey deletes the symmetric key that is associated with the given id. +func (api *PublicWhisperAPI) DeleteSymKey(ctx context.Context, id string) bool { + return api.w.DeleteSymKey(id) +} + +//go:generate gencodec -type NewMessage -field-override newMessageOverride -out gen_newmessage_json.go + +// NewMessage represents a new whisper message that is posted through the RPC. +type NewMessage struct { + SymKeyID string `json:"symKeyID"` + PublicKey []byte `json:"pubKey"` + Sig string `json:"sig"` + TTL uint32 `json:"ttl"` + Topic TopicType `json:"topic"` + Payload []byte `json:"payload"` + Padding []byte `json:"padding"` + PowTime uint32 `json:"powTime"` + PowTarget float64 `json:"powTarget"` + TargetPeer string `json:"targetPeer"` +} + +type newMessageOverride struct { + PublicKey hexutil.Bytes + Payload hexutil.Bytes + Padding hexutil.Bytes +} + +// Post a message on the Whisper network. +func (api *PublicWhisperAPI) Post(ctx context.Context, req NewMessage) (bool, error) { + var ( + symKeyGiven = len(req.SymKeyID) > 0 + pubKeyGiven = len(req.PublicKey) > 0 + err error + ) + + // user must specify either a symmetric or a asymmetric key + if (symKeyGiven && pubKeyGiven) || (!symKeyGiven && !pubKeyGiven) { + return false, ErrSymAsym } - b, err := api.whisper.GetSymKey(name) + + params := &MessageParams{ + TTL: req.TTL, + Payload: req.Payload, + Padding: req.Padding, + WorkTime: req.PowTime, + PoW: req.PowTarget, + Topic: req.Topic, + } + + // Set key that is used to sign the message + if len(req.Sig) > 0 { + if params.Src, err = api.w.GetPrivateKey(req.Sig); err != nil { + return false, err + } + } + + // Set symmetric key that is used to encrypt the message + if symKeyGiven { + if params.Topic == (TopicType{}) { // topics are mandatory with symmetric encryption + return false, ErrNoTopics + } + if params.KeySym, err = api.w.GetSymKey(req.SymKeyID); err != nil { + return false, err + } + if !validateSymmetricKey(params.KeySym) { + return false, ErrInvalidSymmetricKey + } + } + + // Set asymmetric key that is used to encrypt the message + if pubKeyGiven { + params.Dst = crypto.ToECDSAPub(req.PublicKey) + if !ValidatePublicKey(params.Dst) { + return false, ErrInvalidPublicKey + } + } + + // encrypt and sent message + whisperMsg, err := NewSentMessage(params) if err != nil { - return nil, err - } - return b, nil -} - -// DeleteSymmetricKey deletes the key associated with the name string if it exists. -func (api *PublicWhisperAPI) DeleteSymmetricKey(name string) (bool, error) { - if api.whisper == nil { - return false, whisperOfflineErr - } - res := api.whisper.DeleteSymKey(name) - return res, nil -} - -// NewFilter is alias to Subscribe -func (api *PublicWhisperAPI) NewFilter(args WhisperFilterArgs) (string, error) { - return api.Subscribe(args) -} - -// Subscribe creates and registers a new filter to watch for inbound whisper messages. -// Returns the ID of the newly created filter. -func (api *PublicWhisperAPI) Subscribe(args WhisperFilterArgs) (string, error) { - if api.whisper == nil { - return "", whisperOfflineErr + return false, err } - filter := Filter{ - PoW: args.MinPoW, - Messages: make(map[common.Hash]*ReceivedMessage), - AllowP2P: args.AllowP2P, - } - - var err error - for i, bt := range args.Topics { - if len(bt) == 0 || len(bt) > 4 { - return "", errors.New(fmt.Sprintf("subscribe: topic %d has wrong size: %d", i, len(bt))) - } - filter.Topics = append(filter.Topics, bt) - } - - args.Key, err = toDeterministicID(args.Key, keyIdSize) + env, err := whisperMsg.Wrap(params) if err != nil { - return "", err + return false, err } - if err = ValidateKeyID(args.Key); err != nil { - return "", errors.New("subscribe: " + err.Error()) - } - - if len(args.Sig) > 0 { - sb := common.FromHex(args.Sig) - if sb == nil { - return "", errors.New("subscribe: sig parameter is invalid") - } - filter.Src = crypto.ToECDSAPub(sb) - if !ValidatePublicKey(filter.Src) { - return "", errors.New("subscribe: invalid 'sig' field") - } - } - - if args.Symmetric { - if len(args.Topics) == 0 { - return "", errors.New("subscribe: at least one topic must be specified with symmetric encryption") - } - symKey, err := api.whisper.GetSymKey(args.Key) + // send to specific node (skip PoW check) + if len(req.TargetPeer) > 0 { + n, err := discover.ParseNode(req.TargetPeer) if err != nil { - return "", errors.New("subscribe: invalid key ID") - } - if !validateSymmetricKey(symKey) { - return "", errors.New("subscribe: retrieved key is invalid") - } - filter.KeySym = symKey - filter.SymKeyHash = crypto.Keccak256Hash(filter.KeySym) - } else { - filter.KeyAsym, err = api.whisper.GetPrivateKey(args.Key) - if err != nil { - return "", errors.New("subscribe: invalid key ID") - } - if filter.KeyAsym == nil { - return "", errors.New("subscribe: non-existent identity provided") + return false, fmt.Errorf("failed to parse target peer: %s", err) } + return true, api.w.SendP2PMessage(n.ID[:], env) } - return api.whisper.Subscribe(&filter) + // ensure that the message PoW meets the node's minimum accepted PoW + if req.PowTarget < api.w.MinPow() { + return false, ErrTooLowPoW + } + + return true, api.w.Send(env) } // UninstallFilter is alias for Unsubscribe func (api *PublicWhisperAPI) UninstallFilter(id string) { - api.Unsubscribe(id) + api.w.Unsubscribe(id) } // Unsubscribe disables and removes an existing filter. func (api *PublicWhisperAPI) Unsubscribe(id string) { - api.whisper.Unsubscribe(id) + api.w.Unsubscribe(id) } -// GetFilterChanges is alias for GetNewSubscriptionMessages -func (api *PublicWhisperAPI) GetFilterChanges(filterId string) []*WhisperMessage { - return api.GetNewSubscriptionMessages(filterId) +//go:generate gencodec -type Criteria -field-override criteriaOverride -out gen_criteria_json.go + +// Criteria holds various filter options for inbound messages. +type Criteria struct { + SymKeyID string `json:"symKeyID"` + PrivateKeyID string `json:"privateKeyID"` + Sig []byte `json:"sig"` + MinPow float64 `json:"minPow"` + Topics []TopicType `json:"topics"` + AllowP2P bool `json:"allowP2P"` } -// GetNewSubscriptionMessages retrieves all the new messages matched by the corresponding -// subscription filter since the last retrieval. -func (api *PublicWhisperAPI) GetNewSubscriptionMessages(id string) []*WhisperMessage { - f := api.whisper.GetFilter(id) - if f != nil { - newMail := f.Retrieve() - return toWhisperMessages(newMail) +type criteriaOverride struct { + Sig hexutil.Bytes +} + +// Messages set up a subscription that fires events when messages arrive that match +// the given set of criteria. +func (api *PublicWhisperAPI) Messages(ctx context.Context, crit Criteria) (*rpc.Subscription, error) { + var ( + symKeyGiven = len(crit.SymKeyID) > 0 + pubKeyGiven = len(crit.PrivateKeyID) > 0 + err error + ) + + // ensure that the RPC connection supports subscriptions + notifier, supported := rpc.NotifierFromContext(ctx) + if !supported { + return nil, rpc.ErrNotificationsUnsupported } - return toWhisperMessages(nil) + + // user must specify either a symmetric or a asymmetric key + if (symKeyGiven && pubKeyGiven) || (!symKeyGiven && !pubKeyGiven) { + return nil, ErrSymAsym + } + + filter := Filter{ + PoW: crit.MinPow, + Messages: make(map[common.Hash]*ReceivedMessage), + AllowP2P: crit.AllowP2P, + } + + if len(crit.Sig) > 0 { + filter.Src = crypto.ToECDSAPub(crit.Sig) + if !ValidatePublicKey(filter.Src) { + return nil, ErrInvalidSigningPubKey + } + } + + for i, bt := range crit.Topics { + if len(bt) == 0 || len(bt) > 4 { + return nil, fmt.Errorf("subscribe: topic %d has wrong size: %d", i, len(bt)) + } + filter.Topics = append(filter.Topics, bt[:]) + } + + // listen for message that are encrypted with the given symmetric key + if symKeyGiven { + if len(filter.Topics) == 0 { + return nil, ErrNoTopics + } + key, err := api.w.GetSymKey(crit.SymKeyID) + if err != nil { + return nil, err + } + if !validateSymmetricKey(key) { + return nil, ErrInvalidSymmetricKey + } + filter.KeySym = key + filter.SymKeyHash = crypto.Keccak256Hash(filter.KeySym) + } + + // listen for messages that are encrypted with the given public key + if pubKeyGiven { + filter.KeyAsym, err = api.w.GetPrivateKey(crit.PrivateKeyID) + if err != nil || filter.KeyAsym == nil { + return nil, ErrInvalidPublicKey + } + } + + id, err := api.w.Subscribe(&filter) + if err != nil { + return nil, err + } + + // create subscription and start waiting for message events + rpcSub := notifier.CreateSubscription() + go func() { + // for now poll internally, refactor whisper internal for channel support + ticker := time.NewTicker(250 * time.Millisecond) + defer ticker.Stop() + + for { + select { + case <-ticker.C: + if filter := api.w.GetFilter(id); filter != nil { + for _, rpcMessage := range toMessage(filter.Retrieve()) { + if err := notifier.Notify(rpcSub.ID, rpcMessage); err != nil { + log.Error("Failed to send notification", "err", err) + } + } + } + case <-rpcSub.Err(): + api.w.Unsubscribe(id) + return + case <-notifier.Closed(): + api.w.Unsubscribe(id) + return + } + } + }() + + return rpcSub, nil } -// GetMessages retrieves all the floating messages that match a specific subscription filter. -// It is likely to be called once per session, right after Subscribe call. -func (api *PublicWhisperAPI) GetFloatingMessages(id string) []*WhisperMessage { - all := api.whisper.Messages(id) - return toWhisperMessages(all) +//go:generate gencodec -type Message -field-override messageOverride -out gen_message_json.go + +// Message is the RPC representation of a whisper message. +type Message struct { + Sig []byte `json:"sig,omitempty"` + TTL uint32 `json:"ttl"` + Timestamp uint32 `json:"timestamp"` + Topic TopicType `json:"topic"` + Payload []byte `json:"payload"` + Padding []byte `json:"padding"` + PoW float64 `json:"pow"` + Hash []byte `json:"hash"` + Dst []byte `json:"recipientPublicKey,omitempty"` } -// toWhisperMessages converts a Whisper message to a RPC whisper message. -func toWhisperMessages(messages []*ReceivedMessage) []*WhisperMessage { - msgs := make([]*WhisperMessage, len(messages)) +type messageOverride struct { + Sig hexutil.Bytes + Payload hexutil.Bytes + Padding hexutil.Bytes + Hash hexutil.Bytes + Dst hexutil.Bytes +} + +// ToWhisperMessage converts an internal message into an API version. +func ToWhisperMessage(message *ReceivedMessage) *Message { + msg := Message{ + Payload: message.Payload, + Padding: message.Padding, + Timestamp: message.Sent, + TTL: message.TTL, + PoW: message.PoW, + Hash: message.EnvelopeHash.Bytes(), + Topic: message.Topic, + } + + if message.Dst != nil { + b := crypto.FromECDSAPub(message.Dst) + if b != nil { + msg.Dst = b + } + } + + if isMessageSigned(message.Raw[0]) { + b := crypto.FromECDSAPub(message.SigToPubKey()) + if b != nil { + msg.Sig = b + } + } + + return &msg +} + +// toMessage converts a set of messages to its RPC representation. +func toMessage(messages []*ReceivedMessage) []*Message { + msgs := make([]*Message, len(messages)) for i, msg := range messages { - msgs[i] = NewWhisperMessage(msg) + msgs[i] = ToWhisperMessage(msg) } return msgs } -// Post creates a whisper message and injects it into the network for distribution. -func (api *PublicWhisperAPI) Post(args PostArgs) error { - if api.whisper == nil { - return whisperOfflineErr +// GetFilterMessages returns the messages that match the filter criteria and +// are received between the last poll and now. +func (api *PublicWhisperAPI) GetFilterMessages(id string) ([]*Message, error) { + api.mu.Lock() + f := api.w.GetFilter(id) + if f == nil { + api.mu.Unlock() + return nil, fmt.Errorf("filter not found") + } + api.lastUsed[id] = time.Now() + api.mu.Unlock() + + receivedMessages := f.Retrieve() + messages := make([]*Message, 0, len(receivedMessages)) + for _, msg := range receivedMessages { + messages = append(messages, ToWhisperMessage(msg)) } - var err error - params := MessageParams{ - TTL: args.TTL, - WorkTime: args.PowTime, - PoW: args.PowTarget, - Payload: args.Payload, - Padding: args.Padding, + return messages, nil +} + +// DeleteMessageFilter deletes a filter. +func (api *PublicWhisperAPI) DeleteMessageFilter(id string) (bool, error) { + api.mu.Lock() + defer api.mu.Unlock() + + delete(api.lastUsed, id) + return true, api.w.Unsubscribe(id) +} + +// NewMessageFilter creates a new filter that can be used to poll for +// (new) messages that satisfy the given criteria. +func (api *PublicWhisperAPI) NewMessageFilter(req Criteria) (string, error) { + var ( + src *ecdsa.PublicKey + keySym []byte + keyAsym *ecdsa.PrivateKey + topics [][]byte + + symKeyGiven = len(req.SymKeyID) > 0 + asymKeyGiven = len(req.PrivateKeyID) > 0 + + err error + ) + + // user must specify either a symmetric or a asymmetric key + if (symKeyGiven && asymKeyGiven) || (!symKeyGiven && !asymKeyGiven) { + return "", ErrSymAsym } - if len(args.Key) == 0 { - return errors.New("post: key is missing") - } - - if len(args.Sig) > 0 { - params.Src, err = api.whisper.GetPrivateKey(args.Sig) - if err != nil { - return err - } - if params.Src == nil { - return errors.New("post: empty identity") + if len(req.Sig) > 0 { + src = crypto.ToECDSAPub(req.Sig) + if !ValidatePublicKey(src) { + return "", ErrInvalidSigningPubKey } } - if len(args.Topic) == TopicLength { - params.Topic = BytesToTopic(args.Topic) - } else if len(args.Topic) != 0 { - return errors.New(fmt.Sprintf("post: wrong topic size %d", len(args.Topic))) + if symKeyGiven { + if keySym, err = api.w.GetSymKey(req.SymKeyID); err != nil { + return "", err + } + if !validateSymmetricKey(keySym) { + return "", ErrInvalidSymmetricKey + } } - if args.Type == "sym" { - if err = ValidateKeyID(args.Key); err != nil { - return err + if asymKeyGiven { + if keyAsym, err = api.w.GetPrivateKey(req.PrivateKeyID); err != nil { + return "", err } - params.KeySym, err = api.whisper.GetSymKey(args.Key) - if err != nil { - return err - } - if !validateSymmetricKey(params.KeySym) { - return errors.New("post: key for symmetric encryption is invalid") - } - if len(params.Topic) == 0 { - return errors.New("post: topic is missing for symmetric encryption") - } - } else if args.Type == "asym" { - kb := common.FromHex(args.Key) - if kb == nil { - return errors.New("post: public key for asymmetric encryption is invalid") - } - params.Dst = crypto.ToECDSAPub(kb) - if !ValidatePublicKey(params.Dst) { - return errors.New("post: public key for asymmetric encryption is invalid") - } - } else { - return errors.New("post: wrong type (sym/asym)") } - // encrypt and send - message, err := NewSentMessage(¶ms) + if len(req.Topics) > 0 { + topics = make([][]byte, 1) + for _, topic := range req.Topics { + topics = append(topics, topic[:]) + } + } + + f := &Filter{ + Src: src, + KeySym: keySym, + KeyAsym: keyAsym, + PoW: req.MinPow, + AllowP2P: req.AllowP2P, + Topics: topics, + Messages: make(map[common.Hash]*ReceivedMessage), + } + + id, err := api.w.Subscribe(f) if err != nil { - return err - } - envelope, err := message.Wrap(¶ms) - if err != nil { - return err - } - if envelope.size() > api.whisper.maxMsgLength { - return errors.New("post: message is too big") + return "", err } - if len(args.TargetPeer) != 0 { - n, err := discover.ParseNode(args.TargetPeer) - if err != nil { - return errors.New("post: failed to parse enode of target peer: " + err.Error()) - } - return api.whisper.SendP2PMessage(n.ID[:], envelope) - } else if args.PowTarget < api.whisper.minPoW { - return errors.New("post: target PoW is less than minimum PoW, the message can not be sent") - } + api.mu.Lock() + api.lastUsed[id] = time.Now() + api.mu.Unlock() - return api.whisper.Send(envelope) -} - -type PostArgs struct { - Type string `json:"type"` // "sym"/"asym" (symmetric or asymmetric) - TTL uint32 `json:"ttl"` // time-to-live in seconds - Sig string `json:"sig"` // id of the signing key - Key string `json:"key"` // key id (in case of sym) or public key (in case of asym) - Topic hexutil.Bytes `json:"topic"` // topic (4 bytes) - Padding hexutil.Bytes `json:"padding"` // optional padding bytes - Payload hexutil.Bytes `json:"payload"` // payload to be encrypted - PowTime uint32 `json:"powTime"` // maximal time in seconds to be spent on PoW - PowTarget float64 `json:"powTarget"` // minimal PoW required for this message - TargetPeer string `json:"targetPeer"` // peer id (for p2p message only) -} - -func (args *PostArgs) UnmarshalJSON(data []byte) (err error) { - var obj struct { - Type string `json:"type"` - TTL hexutil.Uint64 `json:"ttl"` - Sig string `json:"sig"` - Key string `json:"key"` - Topic string `json:"topic"` - Payload string `json:"payload"` - PowTime hexutil.Uint64 `json:"powTime"` - PowTarget float64 `json:"powTarget,string"` - TargetPeer string `json:"targetPeer"` - } - - if err := json.Unmarshal(data, &obj); err != nil { - return err - } - - if obj.Type != "sym" && obj.Type != "asym" { - return errors.New("wrong type (sym/asym)") - } - - args.Type = obj.Type - args.Key = obj.Key - args.TTL = uint32(obj.TTL) - args.Sig = obj.Sig - args.Payload = []byte(obj.Payload) - args.PowTime = uint32(obj.PowTime) - if args.PowTime < DefaultMinimumPoWTime { // ensure minimum PoW - args.PowTime = DefaultMinimumPoWTime - } - args.PowTarget = obj.PowTarget - if args.PowTarget < DefaultMinimumPoW { // ensure minimum PoW - args.PowTarget = DefaultMinimumPoW - } - args.TargetPeer = obj.TargetPeer - - // process topic - x := common.FromHex(obj.Topic) - if x == nil { - return fmt.Errorf("topic is invalid: %v", obj.Topic) - } - topicBytes := BytesToTopic(x) - args.Topic = []byte(topicBytes[:]) - - return nil -} - -type WhisperFilterArgs struct { - Symmetric bool // encryption type - Key string // id of the key to be used for decryption - Sig string // public key of the sender to be verified - MinPoW float64 // minimal PoW requirement - Topics [][]byte // list of topics (up to 4 bytes each) to match - AllowP2P bool // indicates wheather direct p2p messages are allowed for this filter -} - -// UnmarshalJSON implements the json.Unmarshaler interface, invoked to convert a -// JSON message blob into a WhisperFilterArgs structure. -func (args *WhisperFilterArgs) UnmarshalJSON(b []byte) (err error) { - // Unmarshal the JSON message and sanity check - var obj struct { - Type string `json:"type"` - Key string `json:"key"` - Sig string `json:"sig"` - MinPoW float64 `json:"minPoW"` - Topics []interface{} `json:"topics"` - AllowP2P bool `json:"allowP2P"` - } - if err := json.Unmarshal(b, &obj); err != nil { - return err - } - - switch obj.Type { - case "sym": - args.Symmetric = true - case "asym": - args.Symmetric = false - default: - return errors.New("wrong type (sym/asym)") - } - - args.Key = obj.Key - args.Sig = obj.Sig - args.MinPoW = obj.MinPoW - if args.MinPoW < DefaultMinimumPoW { // ensure minimum PoW - args.MinPoW = DefaultMinimumPoW - } - args.AllowP2P = obj.AllowP2P - - // Construct the topic array - if obj.Topics != nil { - topics := make([]string, len(obj.Topics)) - for i, field := range obj.Topics { - switch value := field.(type) { - case string: - topics[i] = value - case nil: - return fmt.Errorf("topic[%d] is empty", i) - default: - return fmt.Errorf("topic[%d] is not a string", i) - } - } - topicsDecoded := make([][]byte, len(topics)) - for j, s := range topics { - x := common.FromHex(s) - if x == nil { - return fmt.Errorf("topic[%d] is invalid", j) - } - topicsDecoded[j] = x - } - args.Topics = topicsDecoded - } - - return nil -} - -// WhisperMessage is the RPC representation of a whisper message. -type WhisperMessage struct { - Topic string `json:"topic"` - Payload string `json:"payload"` - Padding string `json:"padding"` - Src string `json:"sig"` - Dst string `json:"recipientPublicKey"` - Timestamp uint32 `json:"timestamp"` - TTL uint32 `json:"ttl"` - PoW float64 `json:"pow"` - Hash string `json:"hash"` -} - -// NewWhisperMessage converts an internal message into an API version. -func NewWhisperMessage(message *ReceivedMessage) *WhisperMessage { - msg := WhisperMessage{ - Payload: common.ToHex(message.Payload), - Padding: common.ToHex(message.Padding), - Timestamp: message.Sent, - TTL: message.TTL, - PoW: message.PoW, - Hash: common.ToHex(message.EnvelopeHash.Bytes()), - } - - if len(message.Topic) == TopicLength { - msg.Topic = common.ToHex(message.Topic[:]) - } - if message.Dst != nil { - b := crypto.FromECDSAPub(message.Dst) - if b != nil { - msg.Dst = common.ToHex(b) - } - } - if isMessageSigned(message.Raw[0]) { - b := crypto.FromECDSAPub(message.SigToPubKey()) - if b != nil { - msg.Src = common.ToHex(b) - } - } - return &msg + return id, nil } diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/config.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/config.go new file mode 100644 index 000000000..290bf8962 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/config.go @@ -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 . + +package whisperv5 + +type Config struct { + MaxMessageSize uint32 `toml:",omitempty"` + MinimumAcceptedPOW float64 `toml:",omitempty"` +} + +var DefaultConfig = Config{ + MaxMessageSize: DefaultMaxMessageSize, + MinimumAcceptedPOW: DefaultMinimumPoW, +} + +var () diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/doc.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/doc.go index 175a84277..a6c9e610d 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/doc.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/doc.go @@ -57,9 +57,9 @@ const ( AESNonceLength = 12 keyIdSize = 32 - DefaultMaxMessageLength = 1024 * 1024 - DefaultMinimumPoWTime = 2 // todo: review after testing. - DefaultMinimumPoW = 0.001 // todo: review after testing. + MaxMessageSize = uint32(10 * 1024 * 1024) // maximum accepted size of a message. + DefaultMaxMessageSize = uint32(1024 * 1024) + DefaultMinimumPoW = 0.001 padSizeLimit = 256 // just an arbitrary number, could be changed without breaking the protocol (must not exceed 2^24) messageQueueLimit = 1024 diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/envelope.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/envelope.go index d95fcab75..169cbba9d 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/envelope.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/envelope.go @@ -62,7 +62,7 @@ func (e *Envelope) rlpWithoutNonce() []byte { // NewEnvelope wraps a Whisper message with expiration and destination data // included into an envelope for network forwarding. -func NewEnvelope(ttl uint32, topic TopicType, aesNonce []byte, msg *SentMessage) *Envelope { +func NewEnvelope(ttl uint32, topic TopicType, aesNonce []byte, msg *sentMessage) *Envelope { env := Envelope{ Version: make([]byte, 1), Expiry: uint32(time.Now().Add(time.Second * time.Duration(ttl)).Unix()), diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/filter.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/filter.go index 03101d4a4..d571160d7 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/filter.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/filter.go @@ -163,6 +163,7 @@ func (f *Filter) Retrieve() (all []*ReceivedMessage) { for _, msg := range f.Messages { all = append(all, msg) } + f.Messages = make(map[common.Hash]*ReceivedMessage) // delete old messages return all } diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_criteria_json.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_criteria_json.go new file mode 100644 index 000000000..8d3e9ee24 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_criteria_json.go @@ -0,0 +1,62 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package whisperv5 + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/common/hexutil" +) + +func (c Criteria) MarshalJSON() ([]byte, error) { + type Criteria struct { + SymKeyID string `json:"symKeyID"` + PrivateKeyID string `json:"privateKeyID"` + Sig hexutil.Bytes `json:"sig"` + MinPow float64 `json:"minPow"` + Topics []TopicType `json:"topics"` + AllowP2P bool `json:"allowP2P"` + } + var enc Criteria + enc.SymKeyID = c.SymKeyID + enc.PrivateKeyID = c.PrivateKeyID + enc.Sig = c.Sig + enc.MinPow = c.MinPow + enc.Topics = c.Topics + enc.AllowP2P = c.AllowP2P + return json.Marshal(&enc) +} + +func (c *Criteria) UnmarshalJSON(input []byte) error { + type Criteria struct { + SymKeyID *string `json:"symKeyID"` + PrivateKeyID *string `json:"privateKeyID"` + Sig hexutil.Bytes `json:"sig"` + MinPow *float64 `json:"minPow"` + Topics []TopicType `json:"topics"` + AllowP2P *bool `json:"allowP2P"` + } + var dec Criteria + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.SymKeyID != nil { + c.SymKeyID = *dec.SymKeyID + } + if dec.PrivateKeyID != nil { + c.PrivateKeyID = *dec.PrivateKeyID + } + if dec.Sig != nil { + c.Sig = dec.Sig + } + if dec.MinPow != nil { + c.MinPow = *dec.MinPow + } + if dec.Topics != nil { + c.Topics = dec.Topics + } + if dec.AllowP2P != nil { + c.AllowP2P = *dec.AllowP2P + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_message_json.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_message_json.go new file mode 100644 index 000000000..26168225c --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_message_json.go @@ -0,0 +1,80 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package whisperv5 + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/common/hexutil" +) + +func (m Message) MarshalJSON() ([]byte, error) { + type Message struct { + Sig hexutil.Bytes `json:"sig,omitempty"` + TTL uint32 `json:"ttl"` + Timestamp uint32 `json:"timestamp"` + Topic TopicType `json:"topic"` + Payload hexutil.Bytes `json:"payload"` + Padding hexutil.Bytes `json:"padding"` + PoW float64 `json:"pow"` + Hash hexutil.Bytes `json:"hash"` + Dst hexutil.Bytes `json:"recipientPublicKey,omitempty"` + } + var enc Message + enc.Sig = m.Sig + enc.TTL = m.TTL + enc.Timestamp = m.Timestamp + enc.Topic = m.Topic + enc.Payload = m.Payload + enc.Padding = m.Padding + enc.PoW = m.PoW + enc.Hash = m.Hash + enc.Dst = m.Dst + return json.Marshal(&enc) +} + +func (m *Message) UnmarshalJSON(input []byte) error { + type Message struct { + Sig hexutil.Bytes `json:"sig,omitempty"` + TTL *uint32 `json:"ttl"` + Timestamp *uint32 `json:"timestamp"` + Topic *TopicType `json:"topic"` + Payload hexutil.Bytes `json:"payload"` + Padding hexutil.Bytes `json:"padding"` + PoW *float64 `json:"pow"` + Hash hexutil.Bytes `json:"hash"` + Dst hexutil.Bytes `json:"recipientPublicKey,omitempty"` + } + var dec Message + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.Sig != nil { + m.Sig = dec.Sig + } + if dec.TTL != nil { + m.TTL = *dec.TTL + } + if dec.Timestamp != nil { + m.Timestamp = *dec.Timestamp + } + if dec.Topic != nil { + m.Topic = *dec.Topic + } + if dec.Payload != nil { + m.Payload = dec.Payload + } + if dec.Padding != nil { + m.Padding = dec.Padding + } + if dec.PoW != nil { + m.PoW = *dec.PoW + } + if dec.Hash != nil { + m.Hash = dec.Hash + } + if dec.Dst != nil { + m.Dst = dec.Dst + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_newmessage_json.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_newmessage_json.go new file mode 100644 index 000000000..0231cd919 --- /dev/null +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/gen_newmessage_json.go @@ -0,0 +1,86 @@ +// Code generated by github.com/fjl/gencodec. DO NOT EDIT. + +package whisperv5 + +import ( + "encoding/json" + + "github.com/ethereum/go-ethereum/common/hexutil" +) + +func (n NewMessage) MarshalJSON() ([]byte, error) { + type NewMessage struct { + SymKeyID string `json:"symKeyID"` + PublicKey hexutil.Bytes `json:"pubKey"` + Sig string `json:"sig"` + TTL uint32 `json:"ttl"` + Topic TopicType `json:"topic"` + Payload hexutil.Bytes `json:"payload"` + Padding hexutil.Bytes `json:"padding"` + PowTime uint32 `json:"powTime"` + PowTarget float64 `json:"powTarget"` + TargetPeer string `json:"targetPeer"` + } + var enc NewMessage + enc.SymKeyID = n.SymKeyID + enc.PublicKey = n.PublicKey + enc.Sig = n.Sig + enc.TTL = n.TTL + enc.Topic = n.Topic + enc.Payload = n.Payload + enc.Padding = n.Padding + enc.PowTime = n.PowTime + enc.PowTarget = n.PowTarget + enc.TargetPeer = n.TargetPeer + return json.Marshal(&enc) +} + +func (n *NewMessage) UnmarshalJSON(input []byte) error { + type NewMessage struct { + SymKeyID *string `json:"symKeyID"` + PublicKey hexutil.Bytes `json:"pubKey"` + Sig *string `json:"sig"` + TTL *uint32 `json:"ttl"` + Topic *TopicType `json:"topic"` + Payload hexutil.Bytes `json:"payload"` + Padding hexutil.Bytes `json:"padding"` + PowTime *uint32 `json:"powTime"` + PowTarget *float64 `json:"powTarget"` + TargetPeer *string `json:"targetPeer"` + } + var dec NewMessage + if err := json.Unmarshal(input, &dec); err != nil { + return err + } + if dec.SymKeyID != nil { + n.SymKeyID = *dec.SymKeyID + } + if dec.PublicKey != nil { + n.PublicKey = dec.PublicKey + } + if dec.Sig != nil { + n.Sig = *dec.Sig + } + if dec.TTL != nil { + n.TTL = *dec.TTL + } + if dec.Topic != nil { + n.Topic = *dec.Topic + } + if dec.Payload != nil { + n.Payload = dec.Payload + } + if dec.Padding != nil { + n.Padding = dec.Padding + } + if dec.PowTime != nil { + n.PowTime = *dec.PowTime + } + if dec.PowTarget != nil { + n.PowTarget = *dec.PowTarget + } + if dec.TargetPeer != nil { + n.TargetPeer = *dec.TargetPeer + } + return nil +} diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/message.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/message.go index 4ef469b51..c27535cd1 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/message.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/message.go @@ -49,7 +49,7 @@ type MessageParams struct { // SentMessage represents an end-user data packet to transmit through the // Whisper protocol. These are wrapped into Envelopes that need not be // understood by intermediate nodes, just forwarded. -type SentMessage struct { +type sentMessage struct { Raw []byte } @@ -87,8 +87,8 @@ func (msg *ReceivedMessage) isAsymmetricEncryption() bool { } // NewMessage creates and initializes a non-signed, non-encrypted Whisper message. -func NewSentMessage(params *MessageParams) (*SentMessage, error) { - msg := SentMessage{} +func NewSentMessage(params *MessageParams) (*sentMessage, error) { + msg := sentMessage{} msg.Raw = make([]byte, 1, len(params.Payload)+len(params.Padding)+signatureLength+padSizeLimit) msg.Raw[0] = 0 // set all the flags to zero err := msg.appendPadding(params) @@ -119,7 +119,7 @@ func intSize(i int) (s int) { // appendPadding appends the pseudorandom padding bytes and sets the padding flag. // The last byte contains the size of padding (thus, its size must not exceed 256). -func (msg *SentMessage) appendPadding(params *MessageParams) error { +func (msg *sentMessage) appendPadding(params *MessageParams) error { rawSize := len(params.Payload) + 1 if params.Src != nil { rawSize += signatureLength @@ -164,7 +164,7 @@ func (msg *SentMessage) appendPadding(params *MessageParams) error { // sign calculates and sets the cryptographic signature for the message, // also setting the sign flag. -func (msg *SentMessage) sign(key *ecdsa.PrivateKey) error { +func (msg *sentMessage) sign(key *ecdsa.PrivateKey) error { if isMessageSigned(msg.Raw[0]) { // this should not happen, but no reason to panic log.Error("failed to sign the message: already signed") @@ -183,7 +183,7 @@ func (msg *SentMessage) sign(key *ecdsa.PrivateKey) error { } // encryptAsymmetric encrypts a message with a public key. -func (msg *SentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error { +func (msg *sentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error { if !ValidatePublicKey(key) { return errors.New("invalid public key provided for asymmetric encryption") } @@ -196,7 +196,7 @@ func (msg *SentMessage) encryptAsymmetric(key *ecdsa.PublicKey) error { // encryptSymmetric encrypts a message with a topic key, using AES-GCM-256. // nonce size should be 12 bytes (see cipher.gcmStandardNonceSize). -func (msg *SentMessage) encryptSymmetric(key []byte) (nonce []byte, err error) { +func (msg *sentMessage) encryptSymmetric(key []byte) (nonce []byte, err error) { if !validateSymmetricKey(key) { return nil, errors.New("invalid key provided for symmetric encryption") } @@ -224,13 +224,12 @@ func (msg *SentMessage) encryptSymmetric(key []byte) (nonce []byte, err error) { } // Wrap bundles the message into an Envelope to transmit over the network. -func (msg *SentMessage) Wrap(options *MessageParams) (envelope *Envelope, err error) { +func (msg *sentMessage) Wrap(options *MessageParams) (envelope *Envelope, err error) { if options.TTL == 0 { options.TTL = DefaultTTL } if options.Src != nil { - err = msg.sign(options.Src) - if err != nil { + if err = msg.sign(options.Src); err != nil { return nil, err } } @@ -242,14 +241,12 @@ func (msg *SentMessage) Wrap(options *MessageParams) (envelope *Envelope, err er } else { err = errors.New("unable to encrypt the message: neither symmetric nor assymmetric key provided") } - if err != nil { return nil, err } envelope = NewEnvelope(options.TTL, options.Topic, nonce, msg) - err = envelope.Seal(options) - if err != nil { + if err = envelope.Seal(options); err != nil { return nil, err } return envelope, nil diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/topic.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/topic.go index 54d7422d1..d1996c460 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/topic.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/topic.go @@ -19,10 +19,8 @@ package whisperv5 import ( - "fmt" - "strings" - "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/hexutil" ) // Topic represents a cryptographically secure, probabilistic partial @@ -46,24 +44,12 @@ func (topic *TopicType) String() string { return string(common.ToHex(topic[:])) } -// UnmarshalJSON parses a hex representation to a topic. -func (t *TopicType) UnmarshalJSON(input []byte) error { - length := len(input) - if length >= 2 && input[0] == '"' && input[length-1] == '"' { - input = input[1 : length-1] - } - // strip "0x" for length check - if len(input) > 1 && strings.ToLower(string(input[:2])) == "0x" { - input = input[2:] - } - // validate the length of the input - if len(input) != TopicLength*2 { - return fmt.Errorf("unmarshalJSON failed: topic must be exactly %d bytes", TopicLength) - } - b := common.FromHex(string(input)) - if b == nil { - return fmt.Errorf("unmarshalJSON failed: wrong topic format") - } - *t = BytesToTopic(b) - return nil +// MarshalText returns the hex representation of t. +func (t TopicType) MarshalText() ([]byte, error) { + return hexutil.Bytes(t[:]).MarshalText() +} + +// UnmarshalText parses a hex representation to a topic. +func (t *TopicType) UnmarshalText(input []byte) error { + return hexutil.UnmarshalFixedText("Topic", input, t[:]) } diff --git a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/whisper.go b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/whisper.go index a866007e7..d1ef2445d 100644 --- a/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/whisper.go +++ b/vendor/github.com/ethereum/go-ethereum/whisper/whisperv5/whisper.go @@ -33,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/rpc" "github.com/syndtr/goleveldb/leveldb/errors" "golang.org/x/crypto/pbkdf2" + "golang.org/x/sync/syncmap" set "gopkg.in/fatih/set.v0" ) @@ -44,6 +45,12 @@ type Statistics struct { totalMessagesCleared int } +const ( + minPowIdx = iota // Minimal PoW required by the whisper node + maxMsgSizeIdx = iota // Maximal message length allowed by the whisper node + overflowIdx = iota // Indicator of message queue overflow +) + // Whisper represents a dark communication interface through the Ethereum // network, using its very own P2P communication layer. type Whisper struct { @@ -54,29 +61,32 @@ type Whisper struct { symKeys map[string][]byte // Symmetric key storage keyMu sync.RWMutex // Mutex associated with key storages + poolMu sync.RWMutex // Mutex to sync the message and expiration pools envelopes map[common.Hash]*Envelope // Pool of envelopes currently tracked by this node expirations map[uint32]*set.SetNonTS // Message expiration pool - poolMu sync.RWMutex // Mutex to sync the message and expiration pools - peers map[*Peer]struct{} // Set of currently active peers peerMu sync.RWMutex // Mutex to sync the active peer set + peers map[*Peer]struct{} // Set of currently active peers messageQueue chan *Envelope // Message queue for normal whisper messages p2pMsgQueue chan *Envelope // Message queue for peer-to-peer messages (not to be forwarded any further) quit chan struct{} // Channel used for graceful exit - minPoW float64 // Minimal PoW required by the whisper node - maxMsgLength int // Maximal message length allowed by the whisper node - overflow bool // Indicator of message queue overflow + settings syncmap.Map // holds configuration settings that can be dynamically changed - stats Statistics // Statistics of whisper node + statsMu sync.Mutex // guard stats + stats Statistics // Statistics of whisper node mailServer MailServer // MailServer interface notificationServer NotificationServer } // New creates a Whisper client ready to communicate through the Ethereum P2P network. -func New() *Whisper { +func New(cfg *Config) *Whisper { + if cfg == nil { + cfg = &DefaultConfig + } + whisper := &Whisper{ privateKeys: make(map[string]*ecdsa.PrivateKey), symKeys: make(map[string][]byte), @@ -86,22 +96,49 @@ func New() *Whisper { messageQueue: make(chan *Envelope, messageQueueLimit), p2pMsgQueue: make(chan *Envelope, messageQueueLimit), quit: make(chan struct{}), - minPoW: DefaultMinimumPoW, - maxMsgLength: DefaultMaxMessageLength, } + whisper.filters = NewFilters(whisper) + whisper.settings.Store(minPowIdx, cfg.MinimumAcceptedPOW) + whisper.settings.Store(maxMsgSizeIdx, cfg.MaxMessageSize) + whisper.settings.Store(overflowIdx, false) + // p2p whisper sub protocol handler whisper.protocol = p2p.Protocol{ Name: ProtocolName, Version: uint(ProtocolVersion), Length: NumberOfMessageCodes, Run: whisper.HandlePeer, + NodeInfo: func() interface{} { + return map[string]interface{}{ + "version": ProtocolVersionStr, + "maxMessageSize": whisper.MaxMessageSize(), + "minimumPoW": whisper.MinPow(), + } + }, } return whisper } +func (w *Whisper) MinPow() float64 { + val, _ := w.settings.Load(minPowIdx) + return val.(float64) +} + +// MaxMessageSize returns the maximum accepted message size. +func (w *Whisper) MaxMessageSize() uint32 { + val, _ := w.settings.Load(maxMsgSizeIdx) + return val.(uint32) +} + +// Overflow returns an indication if the message queue is full. +func (w *Whisper) Overflow() bool { + val, _ := w.settings.Load(overflowIdx) + return val.(bool) +} + // APIs returns the RPC descriptors the Whisper implementation offers func (w *Whisper) APIs() []rpc.API { return []rpc.API{ @@ -135,12 +172,12 @@ func (w *Whisper) Version() uint { return w.protocol.Version } -// SetMaxMessageLength sets the maximal message length allowed by this node -func (w *Whisper) SetMaxMessageLength(val int) error { - if val <= 0 { - return fmt.Errorf("invalid message length: %d", val) +// SetMaxMessageSize sets the maximal message size allowed by this node +func (w *Whisper) SetMaxMessageSize(size uint32) error { + if size > MaxMessageSize { + return fmt.Errorf("message size too large [%d>%d]", size, MaxMessageSize) } - w.maxMsgLength = val + w.settings.Store(maxMsgSizeIdx, uint32(size)) return nil } @@ -149,7 +186,7 @@ func (w *Whisper) SetMinimumPoW(val float64) error { if val <= 0.0 { return fmt.Errorf("invalid PoW: %f", val) } - w.minPoW = val + w.settings.Store(minPowIdx, val) return nil } @@ -550,7 +587,7 @@ func (wh *Whisper) runMessageLoop(p *Peer, rw p2p.MsgReadWriter) error { log.Warn("message loop", "peer", p.peer.ID(), "err", err) return err } - if packet.Size > uint32(wh.maxMsgLength) { + if packet.Size > wh.MaxMessageSize() { log.Warn("oversized message received", "peer", p.peer.ID()) return errors.New("oversized message received") } @@ -631,7 +668,7 @@ func (wh *Whisper) add(envelope *Envelope) (bool, error) { } } - if envelope.size() > wh.maxMsgLength { + if uint32(envelope.size()) > wh.MaxMessageSize() { return false, fmt.Errorf("huge messages are not allowed [%x]", envelope.Hash()) } @@ -646,7 +683,7 @@ func (wh *Whisper) add(envelope *Envelope) (bool, error) { return false, fmt.Errorf("wrong size of AESNonce: %d bytes [env: %x]", aesNonceSize, envelope.Hash()) } - if envelope.PoW() < wh.minPoW { + if envelope.PoW() < wh.MinPow() { log.Debug("envelope with low PoW dropped", "PoW", envelope.PoW(), "hash", envelope.Hash().Hex()) return false, nil // drop envelope without error } @@ -670,7 +707,9 @@ func (wh *Whisper) add(envelope *Envelope) (bool, error) { log.Trace("whisper envelope already cached", "hash", envelope.Hash().Hex()) } else { log.Trace("cached whisper envelope", "hash", envelope.Hash().Hex()) + wh.statsMu.Lock() wh.stats.memoryUsed += envelope.size() + wh.statsMu.Unlock() wh.postEvent(envelope, false) // notify the local node about the new message if wh.mailServer != nil { wh.mailServer.Archive(envelope) @@ -699,13 +738,13 @@ func (w *Whisper) checkOverflow() { queueSize := len(w.messageQueue) if queueSize == messageQueueLimit { - if !w.overflow { - w.overflow = true + if !w.Overflow() { + w.settings.Store(overflowIdx, true) log.Warn("message queue overflow") } } else if queueSize <= messageQueueLimit/2 { - if w.overflow { - w.overflow = false + if w.Overflow() { + w.settings.Store(overflowIdx, false) log.Warn("message queue overflow fixed (back to normal)") } } @@ -752,6 +791,8 @@ func (w *Whisper) expire() { w.poolMu.Lock() defer w.poolMu.Unlock() + w.statsMu.Lock() + defer w.statsMu.Unlock() w.stats.reset() now := uint32(time.Now().Unix()) for expiry, hashSet := range w.expirations { @@ -772,17 +813,11 @@ func (w *Whisper) expire() { } // Stats returns the whisper node statistics. -func (w *Whisper) Stats() string { - result := fmt.Sprintf("Memory usage: %d bytes. Average messages cleared per expiry cycle: %d. Total messages cleared: %d.", - w.stats.memoryUsed, w.stats.totalMessagesCleared/w.stats.cycles, w.stats.totalMessagesCleared) - if w.stats.messagesCleared > 0 { - result += fmt.Sprintf(" Latest expiry cycle cleared %d messages (%d bytes).", - w.stats.messagesCleared, w.stats.memoryCleared) - } - if w.overflow { - result += " Message queue state: overflow." - } - return result +func (w *Whisper) Stats() Statistics { + w.statsMu.Lock() + defer w.statsMu.Unlock() + + return w.stats } // Envelopes retrieves all the messages currently pooled by the node. @@ -833,15 +868,6 @@ func (s *Statistics) reset() { s.messagesCleared = 0 } -// ValidateKeyID checks the format of key id. -func ValidateKeyID(id string) error { - const target = keyIdSize * 2 - if len(id) != target { - return fmt.Errorf("wrong size of key ID (expected %d bytes, got %d): %s", target, len(id), id) - } - return nil -} - // ValidatePublicKey checks the format of the given public key. func ValidatePublicKey(k *ecdsa.PublicKey) bool { return k != nil && k.X != nil && k.Y != nil && k.X.Sign() != 0 && k.Y.Sign() != 0 diff --git a/vendor/golang.org/x/sync/syncmap/map.go b/vendor/golang.org/x/sync/syncmap/map.go new file mode 100644 index 000000000..80e15847e --- /dev/null +++ b/vendor/golang.org/x/sync/syncmap/map.go @@ -0,0 +1,372 @@ +// Copyright 2016 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Package syncmap provides a concurrent map implementation. +// It is a prototype for a proposed addition to the sync package +// in the standard library. +// (https://golang.org/issue/18177) +package syncmap + +import ( + "sync" + "sync/atomic" + "unsafe" +) + +// Map is a concurrent map with amortized-constant-time loads, stores, and deletes. +// It is safe for multiple goroutines to call a Map's methods concurrently. +// +// The zero Map is valid and empty. +// +// A Map must not be copied after first use. +type Map struct { + mu sync.Mutex + + // read contains the portion of the map's contents that are safe for + // concurrent access (with or without mu held). + // + // The read field itself is always safe to load, but must only be stored with + // mu held. + // + // Entries stored in read may be updated concurrently without mu, but updating + // a previously-expunged entry requires that the entry be copied to the dirty + // map and unexpunged with mu held. + read atomic.Value // readOnly + + // dirty contains the portion of the map's contents that require mu to be + // held. To ensure that the dirty map can be promoted to the read map quickly, + // it also includes all of the non-expunged entries in the read map. + // + // Expunged entries are not stored in the dirty map. An expunged entry in the + // clean map must be unexpunged and added to the dirty map before a new value + // can be stored to it. + // + // If the dirty map is nil, the next write to the map will initialize it by + // making a shallow copy of the clean map, omitting stale entries. + dirty map[interface{}]*entry + + // misses counts the number of loads since the read map was last updated that + // needed to lock mu to determine whether the key was present. + // + // Once enough misses have occurred to cover the cost of copying the dirty + // map, the dirty map will be promoted to the read map (in the unamended + // state) and the next store to the map will make a new dirty copy. + misses int +} + +// readOnly is an immutable struct stored atomically in the Map.read field. +type readOnly struct { + m map[interface{}]*entry + amended bool // true if the dirty map contains some key not in m. +} + +// expunged is an arbitrary pointer that marks entries which have been deleted +// from the dirty map. +var expunged = unsafe.Pointer(new(interface{})) + +// An entry is a slot in the map corresponding to a particular key. +type entry struct { + // p points to the interface{} value stored for the entry. + // + // If p == nil, the entry has been deleted and m.dirty == nil. + // + // If p == expunged, the entry has been deleted, m.dirty != nil, and the entry + // is missing from m.dirty. + // + // Otherwise, the entry is valid and recorded in m.read.m[key] and, if m.dirty + // != nil, in m.dirty[key]. + // + // An entry can be deleted by atomic replacement with nil: when m.dirty is + // next created, it will atomically replace nil with expunged and leave + // m.dirty[key] unset. + // + // An entry's associated value can be updated by atomic replacement, provided + // p != expunged. If p == expunged, an entry's associated value can be updated + // only after first setting m.dirty[key] = e so that lookups using the dirty + // map find the entry. + p unsafe.Pointer // *interface{} +} + +func newEntry(i interface{}) *entry { + return &entry{p: unsafe.Pointer(&i)} +} + +// Load returns the value stored in the map for a key, or nil if no +// value is present. +// The ok result indicates whether value was found in the map. +func (m *Map) Load(key interface{}) (value interface{}, ok bool) { + read, _ := m.read.Load().(readOnly) + e, ok := read.m[key] + if !ok && read.amended { + m.mu.Lock() + // Avoid reporting a spurious miss if m.dirty got promoted while we were + // blocked on m.mu. (If further loads of the same key will not miss, it's + // not worth copying the dirty map for this key.) + read, _ = m.read.Load().(readOnly) + e, ok = read.m[key] + if !ok && read.amended { + e, ok = m.dirty[key] + // Regardless of whether the entry was present, record a miss: this key + // will take the slow path until the dirty map is promoted to the read + // map. + m.missLocked() + } + m.mu.Unlock() + } + if !ok { + return nil, false + } + return e.load() +} + +func (e *entry) load() (value interface{}, ok bool) { + p := atomic.LoadPointer(&e.p) + if p == nil || p == expunged { + return nil, false + } + return *(*interface{})(p), true +} + +// Store sets the value for a key. +func (m *Map) Store(key, value interface{}) { + read, _ := m.read.Load().(readOnly) + if e, ok := read.m[key]; ok && e.tryStore(&value) { + return + } + + m.mu.Lock() + read, _ = m.read.Load().(readOnly) + if e, ok := read.m[key]; ok { + if e.unexpungeLocked() { + // The entry was previously expunged, which implies that there is a + // non-nil dirty map and this entry is not in it. + m.dirty[key] = e + } + e.storeLocked(&value) + } else if e, ok := m.dirty[key]; ok { + e.storeLocked(&value) + } else { + if !read.amended { + // We're adding the first new key to the dirty map. + // Make sure it is allocated and mark the read-only map as incomplete. + m.dirtyLocked() + m.read.Store(readOnly{m: read.m, amended: true}) + } + m.dirty[key] = newEntry(value) + } + m.mu.Unlock() +} + +// tryStore stores a value if the entry has not been expunged. +// +// If the entry is expunged, tryStore returns false and leaves the entry +// unchanged. +func (e *entry) tryStore(i *interface{}) bool { + p := atomic.LoadPointer(&e.p) + if p == expunged { + return false + } + for { + if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) { + return true + } + p = atomic.LoadPointer(&e.p) + if p == expunged { + return false + } + } +} + +// unexpungeLocked ensures that the entry is not marked as expunged. +// +// If the entry was previously expunged, it must be added to the dirty map +// before m.mu is unlocked. +func (e *entry) unexpungeLocked() (wasExpunged bool) { + return atomic.CompareAndSwapPointer(&e.p, expunged, nil) +} + +// storeLocked unconditionally stores a value to the entry. +// +// The entry must be known not to be expunged. +func (e *entry) storeLocked(i *interface{}) { + atomic.StorePointer(&e.p, unsafe.Pointer(i)) +} + +// LoadOrStore returns the existing value for the key if present. +// Otherwise, it stores and returns the given value. +// The loaded result is true if the value was loaded, false if stored. +func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) { + // Avoid locking if it's a clean hit. + read, _ := m.read.Load().(readOnly) + if e, ok := read.m[key]; ok { + actual, loaded, ok := e.tryLoadOrStore(value) + if ok { + return actual, loaded + } + } + + m.mu.Lock() + read, _ = m.read.Load().(readOnly) + if e, ok := read.m[key]; ok { + if e.unexpungeLocked() { + m.dirty[key] = e + } + actual, loaded, _ = e.tryLoadOrStore(value) + } else if e, ok := m.dirty[key]; ok { + actual, loaded, _ = e.tryLoadOrStore(value) + m.missLocked() + } else { + if !read.amended { + // We're adding the first new key to the dirty map. + // Make sure it is allocated and mark the read-only map as incomplete. + m.dirtyLocked() + m.read.Store(readOnly{m: read.m, amended: true}) + } + m.dirty[key] = newEntry(value) + actual, loaded = value, false + } + m.mu.Unlock() + + return actual, loaded +} + +// tryLoadOrStore atomically loads or stores a value if the entry is not +// expunged. +// +// If the entry is expunged, tryLoadOrStore leaves the entry unchanged and +// returns with ok==false. +func (e *entry) tryLoadOrStore(i interface{}) (actual interface{}, loaded, ok bool) { + p := atomic.LoadPointer(&e.p) + if p == expunged { + return nil, false, false + } + if p != nil { + return *(*interface{})(p), true, true + } + + // Copy the interface after the first load to make this method more amenable + // to escape analysis: if we hit the "load" path or the entry is expunged, we + // shouldn't bother heap-allocating. + ic := i + for { + if atomic.CompareAndSwapPointer(&e.p, nil, unsafe.Pointer(&ic)) { + return i, false, true + } + p = atomic.LoadPointer(&e.p) + if p == expunged { + return nil, false, false + } + if p != nil { + return *(*interface{})(p), true, true + } + } +} + +// Delete deletes the value for a key. +func (m *Map) Delete(key interface{}) { + read, _ := m.read.Load().(readOnly) + e, ok := read.m[key] + if !ok && read.amended { + m.mu.Lock() + read, _ = m.read.Load().(readOnly) + e, ok = read.m[key] + if !ok && read.amended { + delete(m.dirty, key) + } + m.mu.Unlock() + } + if ok { + e.delete() + } +} + +func (e *entry) delete() (hadValue bool) { + for { + p := atomic.LoadPointer(&e.p) + if p == nil || p == expunged { + return false + } + if atomic.CompareAndSwapPointer(&e.p, p, nil) { + return true + } + } +} + +// Range calls f sequentially for each key and value present in the map. +// If f returns false, range stops the iteration. +// +// Range does not necessarily correspond to any consistent snapshot of the Map's +// contents: no key will be visited more than once, but if the value for any key +// is stored or deleted concurrently, Range may reflect any mapping for that key +// from any point during the Range call. +// +// Range may be O(N) with the number of elements in the map even if f returns +// false after a constant number of calls. +func (m *Map) Range(f func(key, value interface{}) bool) { + // We need to be able to iterate over all of the keys that were already + // present at the start of the call to Range. + // If read.amended is false, then read.m satisfies that property without + // requiring us to hold m.mu for a long time. + read, _ := m.read.Load().(readOnly) + if read.amended { + // m.dirty contains keys not in read.m. Fortunately, Range is already O(N) + // (assuming the caller does not break out early), so a call to Range + // amortizes an entire copy of the map: we can promote the dirty copy + // immediately! + m.mu.Lock() + read, _ = m.read.Load().(readOnly) + if read.amended { + read = readOnly{m: m.dirty} + m.read.Store(read) + m.dirty = nil + m.misses = 0 + } + m.mu.Unlock() + } + + for k, e := range read.m { + v, ok := e.load() + if !ok { + continue + } + if !f(k, v) { + break + } + } +} + +func (m *Map) missLocked() { + m.misses++ + if m.misses < len(m.dirty) { + return + } + m.read.Store(readOnly{m: m.dirty}) + m.dirty = nil + m.misses = 0 +} + +func (m *Map) dirtyLocked() { + if m.dirty != nil { + return + } + + read, _ := m.read.Load().(readOnly) + m.dirty = make(map[interface{}]*entry, len(read.m)) + for k, e := range read.m { + if !e.tryExpungeLocked() { + m.dirty[k] = e + } + } +} + +func (e *entry) tryExpungeLocked() (isExpunged bool) { + p := atomic.LoadPointer(&e.p) + for p == nil { + if atomic.CompareAndSwapPointer(&e.p, nil, expunged) { + return true + } + p = atomic.LoadPointer(&e.p) + } + return p == expunged +}