From c1d1fa096b5033121c76154d4f4bc50b897c514a Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Tue, 17 Sep 2024 20:36:09 -0600 Subject: [PATCH 01/15] Use raw text list of contract addresses --- .../beanstalk-3/beanstalk-3-Contracts.js | 8 +-- .../data/inputs/ContractAddresses.json | 49 ------------------- .../data/inputs/ContractAddresses.txt | 47 ++++++++++++++++++ 3 files changed, 52 insertions(+), 52 deletions(-) delete mode 100644 protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json create mode 100644 protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.txt diff --git a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js index ff48598b8..060a83ab7 100644 --- a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js +++ b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js @@ -13,9 +13,11 @@ const POD_ORDERS = "./scripts/beanstalk-3/data/inputs/PodOrders.json"; function updateInputJsonData(verbose = false) { // reads ContractAddresses.json, pulls data from protocol/reseed/data/*.json, updates corresponding deposits/plots/internalbals/fertilizers/podorders jsons - const contractAddresses = JSON.parse( - fs.readFileSync("./scripts/beanstalk-3/data/inputs/ContractAddresses.json") - ); + const contractAddresses = fs + .readFileSync("./scripts/beanstalk-3/data/inputs/ContractAddresses.txt", "utf8") + .split("\n") + .map((line) => line.trim()) + .filter((line) => line.length > 0); // loop through and update contract addresses to be the checksummed address for (const [address, data] of Object.entries(contractAddresses)) { diff --git a/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json b/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json deleted file mode 100644 index 73d7a450a..000000000 --- a/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json +++ /dev/null @@ -1,49 +0,0 @@ -[ - "0x7bf4b9d4ec3b9aab1f00dad63ea58389b9f68909", - "0xdd9f24efc84d93deef3c8745c837ab63e80abd27", - "0x9008d19f58aabd9ed0d60971565aa8510560ab41", - "0xb1be0000c6b3c62749b5f0c92480146452d15423", - "0x9662c8e686fe84f468a139b10769d65665c344f9", - "0xe37e799d5077682fa0a244d46e5649f71457bd09", - "0x92f3f71cef740ed5784874b8c70ff87ecdf33588", - "0x0b3f6d4a5d6835137ccb2c1248f5a7d882c0dbda", - "0x5fba3e7eeeb50a4dc3328e2f974e0d608b38913e", - "0x00000000009726632680fb29d3f7a9734e3010e2", - "0x20db9f8c46f9cd438bfd65e09297350a8cdb0f95", - "0xaa420e97534ab55637957e868b658193b112a551", - "0x7e04231a59c9589d17bcf2b0614bc86ad5df7c11", - "0x8525664820c549864982d4965a41f83a7d26af58", - "0x1136b25047e142fa3018184793aec68fbb173ce4", - "0xa9febe780f9ede9b424f5ce7da88d650f2d55498", - "0x3aa228a80f50763045bdfc45012da124bd0a6809", - "0x7122db0ebe4eb9b434a9f2ffe6760bc03bfbd0e0", - "0x81b9cfcb1dc180acaf7c187db5fe2c961f74d67e", - "0x735cab9b02fd153174763958ffb4e0a971dd7f29", - "0x2d0ba6af26c6738feaacb6d85da29d3fadda1706", - "0xb01f8f528702d411d24c9bb8cc0e2fff779ec013", - "0xb9f14efae1d14b6d06816b6e3a5f6e79c87232fa", - "0x21de18b6a8f78ede6d16c50a167f6b222dc08df7", - "0x153072c11d6dffc0f1e5489bc7c996c219668c67", - "0x4a183b7ed67b9e14b3f45abfb2cf44ed22c29e54", - "0x1111111254eeb25477b68fb85ed929f73a960582", - "0x251fae8f687545bdd462ba4fcdd7581051740463", - "0x23ed1e6384705dfd23788d5093266c0d9ebe3fae", - "0xc1fe2bb036e3fc9eddcc83304dbe752881087cdf", - "0x5eefd9c64d8c35142b7611ae3a6decfc6d7a8a5e", - "0x1c694fc3006d81ff4a56f97e1b99529066a23725", - "0xc5a7f91ac0b24ca8957a97aacab4fc1022e256f5", - "0x77700005bea4de0a78b956517f099260c2ca9a26", - "0x7119f398b6c06095c6e8964c1f58e7c1baa79e18", - "0x25c1278454254f783ef8760987db8de0268c6cbe", - "0xbc7c5f21c632c5c7ca1bfde7cbff96254847d997", - "0x517b37dc73f756192b318d3853bd4c66ba4b41cb", - "0x3f9208f556735504e985ff1a369af2e8ff6240a3", - "0x75a158b6939d9abc27b5e3ea9e79c11302cec60c", - "0x9edaff6744d6f539298cddd8c0171b774be2b86d", - "0x66efac6e6d58d4058cf017e66a0039315a3eb29c", - "0x83a758a6a24fe27312c1f8bda7f3277993b64783", - "0xc9c32cd16bf7efb85ff14e0c8603cc90f6f2ee49", - "0xbea0e11282e2bb5893bece110cf199501e872bad", - "0xf2d47e78dea8e0f96902c85902323d2a2012b0c0", - "0x7c28e0977f72c5d08d5e1ac7d52a34db378282b3" -] \ No newline at end of file diff --git a/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.txt b/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.txt new file mode 100644 index 000000000..5239f50e3 --- /dev/null +++ b/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.txt @@ -0,0 +1,47 @@ +0x7bf4b9d4ec3b9aab1f00dad63ea58389b9f68909 +0xdd9f24efc84d93deef3c8745c837ab63e80abd27 +0x9008d19f58aabd9ed0d60971565aa8510560ab41 +0xb1be0000c6b3c62749b5f0c92480146452d15423 +0x9662c8e686fe84f468a139b10769d65665c344f9 +0xe37e799d5077682fa0a244d46e5649f71457bd09 +0x92f3f71cef740ed5784874b8c70ff87ecdf33588 +0x0b3f6d4a5d6835137ccb2c1248f5a7d882c0dbda +0x5fba3e7eeeb50a4dc3328e2f974e0d608b38913e +0x00000000009726632680fb29d3f7a9734e3010e2 +0x20db9f8c46f9cd438bfd65e09297350a8cdb0f95 +0xaa420e97534ab55637957e868b658193b112a551 +0x7e04231a59c9589d17bcf2b0614bc86ad5df7c11 +0x8525664820c549864982d4965a41f83a7d26af58 +0x1136b25047e142fa3018184793aec68fbb173ce4 +0xa9febe780f9ede9b424f5ce7da88d650f2d55498 +0x3aa228a80f50763045bdfc45012da124bd0a6809 +0x7122db0ebe4eb9b434a9f2ffe6760bc03bfbd0e0 +0x81b9cfcb1dc180acaf7c187db5fe2c961f74d67e +0x735cab9b02fd153174763958ffb4e0a971dd7f29 +0x2d0ba6af26c6738feaacb6d85da29d3fadda1706 +0xb01f8f528702d411d24c9bb8cc0e2fff779ec013 +0xb9f14efae1d14b6d06816b6e3a5f6e79c87232fa +0x21de18b6a8f78ede6d16c50a167f6b222dc08df7 +0x153072c11d6dffc0f1e5489bc7c996c219668c67 +0x4a183b7ed67b9e14b3f45abfb2cf44ed22c29e54 +0x1111111254eeb25477b68fb85ed929f73a960582 +0x251fae8f687545bdd462ba4fcdd7581051740463 +0x23ed1e6384705dfd23788d5093266c0d9ebe3fae +0xc1fe2bb036e3fc9eddcc83304dbe752881087cdf +0x5eefd9c64d8c35142b7611ae3a6decfc6d7a8a5e +0x1c694fc3006d81ff4a56f97e1b99529066a23725 +0xc5a7f91ac0b24ca8957a97aacab4fc1022e256f5 +0x77700005bea4de0a78b956517f099260c2ca9a26 +0x7119f398b6c06095c6e8964c1f58e7c1baa79e18 +0x25c1278454254f783ef8760987db8de0268c6cbe +0xbc7c5f21c632c5c7ca1bfde7cbff96254847d997 +0x517b37dc73f756192b318d3853bd4c66ba4b41cb +0x3f9208f556735504e985ff1a369af2e8ff6240a3 +0x75a158b6939d9abc27b5e3ea9e79c11302cec60c +0x9edaff6744d6f539298cddd8c0171b774be2b86d +0x66efac6e6d58d4058cf017e66a0039315a3eb29c +0x83a758a6a24fe27312c1f8bda7f3277993b64783 +0xc9c32cd16bf7efb85ff14e0c8603cc90f6f2ee49 +0xbea0e11282e2bb5893bece110cf199501e872bad +0xf2d47e78dea8e0f96902c85902323d2a2012b0c0 +0x7c28e0977f72c5d08d5e1ac7d52a34db378282b3 \ No newline at end of file From 6b71f1148e8eccc8449913e422fbf5a0e6a9f717 Mon Sep 17 00:00:00 2001 From: Brean0 Date: Wed, 18 Sep 2024 19:58:05 -0500 Subject: [PATCH 02/15] update convertGlobal.js to properly reorder. --- protocol/reseed/data/global.json | 24 +++++++++---------- protocol/reseed/dataConverts/convertGlobal.js | 24 +++++++++++-------- 2 files changed, 26 insertions(+), 22 deletions(-) diff --git a/protocol/reseed/data/global.json b/protocol/reseed/data/global.json index aa2beda71..2db653c48 100644 --- a/protocol/reseed/data/global.json +++ b/protocol/reseed/data/global.json @@ -255,28 +255,28 @@ ], [ [ - "3569521145236", - "3582258810468" + "93730848969040", + "21505944545778" ], [ - "890052022584", - "119822073895" + "64256517403254", + "17207954363487" ], [ - "122660960", - "3003870654" + "3569521145236", + "3582258810468" ], [ - "966131510422", - "88320676626" + "122660960", + "3003870654" ], [ - "93730848969040", - "21505944545778" + "890052022584", + "119822073895" ], [ - "64256517403254", - "17207954363487" + "966131510422", + "88320676626" ] ], [ diff --git a/protocol/reseed/dataConverts/convertGlobal.js b/protocol/reseed/dataConverts/convertGlobal.js index adef93b9b..efdd54d88 100644 --- a/protocol/reseed/dataConverts/convertGlobal.js +++ b/protocol/reseed/dataConverts/convertGlobal.js @@ -4,6 +4,17 @@ const { convertToBigNum } = require("../../utils/read.js"); function parseGlobals(inputFilePath, outputFilePath) { const data = JSON.parse(fs.readFileSync(inputFilePath, "utf8")); + // Sort silo tokens alphabetically + const sortedSiloTokens = Object.keys( + data.silo?.balances || { "0x0000000000000000000000000000000000000000": {} } + ).sort(); + + // Create an object of sorted balances + const sortedBalances = sortedSiloTokens.reduce((acc, token) => { + acc[token] = data.silo?.balances[token] || { deposited: "0", depositedBdv: "0" }; + return acc; + }, {}); + const result = [ // SystemInternalBalances [ @@ -35,16 +46,9 @@ function parseGlobals(inputFilePath, outputFilePath) { data.silo?.earnedBeans ? convertToBigNum(data.silo.earnedBeans) : "0", data.orderLockedBeans ? convertToBigNum(data.orderLockedBeans) : "0", // all silo tokens - Object.keys( - data.silo?.balances || { "0x0000000000000000000000000000000000000000": {} } - ).sort(), // Sort alphabetically so that the 2 Unripe tokens that start with 0x1BEA appear first - // This is assumed in ReseedGlobal.sol - // all silo balances - Object.values( - data.silo?.balances || { - "0x0000000000000000000000000000000000000000": { deposited: "0", depositedBdv: "0" } - } - ).map((balance) => [ + sortedSiloTokens, + // all silo balances (now sorted to match tokens) + Object.values(sortedBalances).map((balance) => [ convertToBigNum(balance.deposited), convertToBigNum(balance.depositedBdv) ]), From 1ce83dae05f2df97097c3f843a20b03725d2ab27 Mon Sep 17 00:00:00 2001 From: Brean0 Date: Thu, 19 Sep 2024 01:01:46 +0000 Subject: [PATCH 03/15] prettier auto formatting changes --- protocol/test/foundry/sun/Gauge.t.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol/test/foundry/sun/Gauge.t.sol b/protocol/test/foundry/sun/Gauge.t.sol index 430beab9d..ea18a4d2b 100644 --- a/protocol/test/foundry/sun/Gauge.t.sol +++ b/protocol/test/foundry/sun/Gauge.t.sol @@ -455,7 +455,7 @@ contract GaugeTest is TestHelper { * note: beanToMaxLPRatio and averageGrownStalkPerBdvPerSeason are kept constant for testing purposes. * see {testDistroGaugeBeanToLp} to see how the beanToMaxLPRatio and averageGrownStalkPerBdvPerSeason are adjusted. */ - // FAILS + // FAILS function testDistroGaugeLpToLp() public { initLpToLpDistro(); bs.mockStepGauge(); From b0e76f54b5505963979fe1b5e1bddd505fc40c07 Mon Sep 17 00:00:00 2001 From: Brean0 Date: Wed, 18 Sep 2024 21:04:16 -0500 Subject: [PATCH 04/15] add 0.6 to prevent invariable break. --- protocol/reseed/reseedAddLiquidityAndTransfer.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/protocol/reseed/reseedAddLiquidityAndTransfer.js b/protocol/reseed/reseedAddLiquidityAndTransfer.js index aa8b292d0..b1b4ab6f6 100644 --- a/protocol/reseed/reseedAddLiquidityAndTransfer.js +++ b/protocol/reseed/reseedAddLiquidityAndTransfer.js @@ -36,7 +36,7 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, ); const nonBeanAmounts = [ - to18("20"), // BEAN/WETH + to18("20.6"), // BEAN/WETH to18("2556"), // BEAN/WstETH to18("16"), // BEAN/WEEETH toX("8", 8), // BEAN/WBTC (8 decimals) From af2ab682c816ac50467e9b2e885fb2c31279260f Mon Sep 17 00:00:00 2001 From: Brean0 Date: Wed, 18 Sep 2024 21:31:02 -0500 Subject: [PATCH 05/15] adds task, updates bean supply for invariant breakage. --- protocol/hardhat.config.js | 18 +++++++++++++++++- .../exports/contract-circulating20736200.json | 4 ++-- protocol/reseed/data/r2/L2_initial_supply.json | 2 +- .../reseed/reseedAddLiquidityAndTransfer.js | 4 ++-- 4 files changed, 22 insertions(+), 6 deletions(-) diff --git a/protocol/hardhat.config.js b/protocol/hardhat.config.js index 006e034d7..eb5002a3a 100644 --- a/protocol/hardhat.config.js +++ b/protocol/hardhat.config.js @@ -111,7 +111,9 @@ task("sunriseArb", async function () { // make a few seconds pass to avoid pump NoTimePassed() error for twa reserves right after the sunrise. const afterSunriseTimestamp = (await ethers.provider.getBlock("latest")).timestamp; const additionalSeconds = 12; - await network.provider.send("evm_setNextBlockTimestamp", [afterSunriseTimestamp + additionalSeconds]); + await network.provider.send("evm_setNextBlockTimestamp", [ + afterSunriseTimestamp + additionalSeconds + ]); await network.provider.send("evm_mine"); console.log( @@ -128,6 +130,20 @@ task("sunriseArb", async function () { ); }); +task("tokenSettings", async function () { + const beanstalk = await getBeanstalk("0xD1A0060ba708BC4BCD3DA6C37EFa8deDF015FB70"); + + let whitelistedTokens = await beanstalk.getWhitelistedTokens(); + console.log(whitelistedTokens); + for (let i = 0; whitelistedTokens.length; i++) { + let tokenSettings = await beanstalk.tokenSettings(whitelistedTokens[i]); + console.log("token:", whitelistedTokens[i]); + console.log("stalkEarnedPerSeason:", tokenSettings[1]); + console.log("deposited BDV:", await beanstalk.getTotalDepositedBdv(whitelistedTokens[i])); + console.log("-----"); + } +}); + task("getTime", async function () { beanstalk = await ethers.getContractAt("SeasonFacet", BEANSTALK); console.log("Current time: ", await this.seasonGetter.time()); diff --git a/protocol/reseed/data/exports/contract-circulating20736200.json b/protocol/reseed/data/exports/contract-circulating20736200.json index 7e6a7a547..05818edd0 100644 --- a/protocol/reseed/data/exports/contract-circulating20736200.json +++ b/protocol/reseed/data/exports/contract-circulating20736200.json @@ -1,6 +1,6 @@ { "beanstalk": { - "beans": "32952499881747", + "beans": "33408617554460", "unripeBeans": "107495547853813", "unripeLp": "67632589795645" }, @@ -18,4 +18,4 @@ "3crv": "20668624046092866087554" } } -} \ No newline at end of file +} diff --git a/protocol/reseed/data/r2/L2_initial_supply.json b/protocol/reseed/data/r2/L2_initial_supply.json index ba691e080..17ba0377e 100644 --- a/protocol/reseed/data/r2/L2_initial_supply.json +++ b/protocol/reseed/data/r2/L2_initial_supply.json @@ -1,5 +1,5 @@ [ - "32952499881747", + "33408617554460", "107495547853813", "67632589795645" ] \ No newline at end of file diff --git a/protocol/reseed/reseedAddLiquidityAndTransfer.js b/protocol/reseed/reseedAddLiquidityAndTransfer.js index b1b4ab6f6..033a8f876 100644 --- a/protocol/reseed/reseedAddLiquidityAndTransfer.js +++ b/protocol/reseed/reseedAddLiquidityAndTransfer.js @@ -36,7 +36,7 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, ); const nonBeanAmounts = [ - to18("20.6"), // BEAN/WETH + to18("20.8"), // BEAN/WETH to18("2556"), // BEAN/WstETH to18("16"), // BEAN/WEEETH toX("8", 8), // BEAN/WBTC (8 decimals) @@ -70,7 +70,7 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, if (mock) { // mint tokens to add liquidity: await token.mint(account.address, nonBeanAmounts[i]); - await bean.mint(account.address, beanAmounts[i] + to6("1000000")); + await bean.mint(account.address, beanAmounts[i]); } await token.connect(account).approve(well.address, MAX_UINT256); await bean.connect(account).approve(well.address, MAX_UINT256); From 1955c977f1a99b824a1b28685a8fa432c6044dbb Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Wed, 18 Sep 2024 21:55:47 -0600 Subject: [PATCH 06/15] Test all contracts migrating deposits --- .../scripts/beanstalk-3/depositDataReader.js | 46 ++ protocol/scripts/beanstalk-3/proofReader.js | 41 ++ .../migrationFinderScripts/depositFinder.js | 128 +++-- .../foundry/Migration/ReseedContracts.sol | 539 ++++++++++++++++++ 4 files changed, 698 insertions(+), 56 deletions(-) create mode 100644 protocol/scripts/beanstalk-3/depositDataReader.js create mode 100644 protocol/scripts/beanstalk-3/proofReader.js create mode 100644 protocol/test/foundry/Migration/ReseedContracts.sol diff --git a/protocol/scripts/beanstalk-3/depositDataReader.js b/protocol/scripts/beanstalk-3/depositDataReader.js new file mode 100644 index 000000000..e4cb2b2ad --- /dev/null +++ b/protocol/scripts/beanstalk-3/depositDataReader.js @@ -0,0 +1,46 @@ +const fs = require("fs"); +const { ethers } = require("ethers"); + +function readDepositData(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Convert the input address to checksummed format + const checksummedAccount = ethers.utils.getAddress(account); + + // Find the data for the specified account + const accountData = jsonData.find( + (data) => ethers.utils.getAddress(data[0]) === checksummedAccount + ); + + if (!accountData) { + // console.error(`No data found for account: ${checksummedAccount}`); + return "0x"; + } + + const depositIds = accountData[1]; + const amounts = accountData[2]; + const bdvs = accountData[3]; + + // Encode the data + const encodedData = ethers.utils.defaultAbiCoder.encode( + ["uint256[]", "uint256[]", "uint256[]"], + [depositIds, amounts, bdvs] + ); + + return encodedData; + } catch (error) { + console.error(`Error reading deposit data: ${error.message}`); + return "0x"; + } +} + +// Get command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const encodedData = readDepositData(jsonFilePath, account); +console.log(encodedData); diff --git a/protocol/scripts/beanstalk-3/proofReader.js b/protocol/scripts/beanstalk-3/proofReader.js new file mode 100644 index 000000000..aab2901ce --- /dev/null +++ b/protocol/scripts/beanstalk-3/proofReader.js @@ -0,0 +1,41 @@ +const fs = require("fs"); +const path = require("path"); + +function getProofForAccount(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Create a new object with lowercased keys + const lowercaseProofs = Object.keys(jsonData.proofs).reduce((acc, key) => { + acc[key.toLowerCase()] = jsonData.proofs[key]; + return acc; + }, {}); + + // Convert the input account to lowercase + const lowercaseAccount = account.toLowerCase(); + + // Check if the lowercased account exists in the proofs object + if (lowercaseProofs.hasOwnProperty(lowercaseAccount)) { + const proof = lowercaseProofs[lowercaseAccount]; + + // Convert the proof array to a single packed string without '0x' prefixes + return proof.map((element) => element.slice(2)).join(""); + } else { + // console.error(`No proof found for account: ${account}`); + return "NO_PROOF_FOUND"; + } + } catch (error) { + console.error(`Error reading proof data: ${error.message}`); + return "ERROR_READING_PROOF"; + } +} + +// Get the command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const proof = getProofForAccount(jsonFilePath, account); +console.log(proof); diff --git a/protocol/scripts/migrationFinderScripts/depositFinder.js b/protocol/scripts/migrationFinderScripts/depositFinder.js index 345ebd780..eace7dce5 100644 --- a/protocol/scripts/migrationFinderScripts/depositFinder.js +++ b/protocol/scripts/migrationFinderScripts/depositFinder.js @@ -1,71 +1,87 @@ -const fs = require('fs'); -const { ethers } = require('ethers'); +const fs = require("fs"); +const { ethers } = require("ethers"); const whitelistedTokens = [ - '0xBEA0005B8599265D41256905A9B3073D397812E4', // BEAN - '0x1BEA054dddBca12889e07B3E076f511Bf1d27543', // urBEAN - '0x1BEA059c3Ea15F6C10be1c53d70C75fD1266D788', // urLP - "0xBEA00A3F7aaF99476862533Fe7DcA4b50f6158cB", // BEAN/WETH - "0xBEA0093f626Ce32dd6dA19617ba4e7aA0c3228e8", // BEAN/WstETH - "0xBEA00865405A02215B44eaADB853d0d2192Fc29D", // BEAN/WEETH - "0xBEA008aC57c2bEfe82E87d1D8Fb9f4784d0B73cA", // BEAN/WBTC - "0xBEA00dAf62D5549D265c5cA6D6BE87eF17881279", // BEAN/USDC - "0xBEA00bE150FEF7560A8ff3C68D07387693Ddfd0b" // BEAN/USDT + "0xBEA0005B8599265D41256905A9B3073D397812E4", // BEAN + "0x1BEA054dddBca12889e07B3E076f511Bf1d27543", // urBEAN + "0x1BEA059c3Ea15F6C10be1c53d70C75fD1266D788", // urLP + "0xBEA00A3F7aaF99476862533Fe7DcA4b50f6158cB", // BEAN/WETH + "0xBEA0093f626Ce32dd6dA19617ba4e7aA0c3228e8", // BEAN/WstETH + "0xBEA00865405A02215B44eaADB853d0d2192Fc29D", // BEAN/WEETH + "0xBEA008aC57c2bEfe82E87d1D8Fb9f4784d0B73cA", // BEAN/WBTC + "0xBEA00dAf62D5549D265c5cA6D6BE87eF17881279", // BEAN/USDC + "0xBEA00bE150FEF7560A8ff3C68D07387693Ddfd0b" // BEAN/USDT ]; function findTokenDepositIds(jsonFilePath, account) { - // Load the JSON file - const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, 'utf8')); + // Load the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); - // Check if the account exists in the JSON data - if (!jsonData.hasOwnProperty(account)) { - console.error(`Account ${account} not found in the JSON file.`); - return null; - } + //make sure account passed in is checksummed + if (account.toLowerCase() == account) { + account = ethers.utils.getAddress(account); + } + + // Check if the account exists in the JSON data + if (!jsonData.hasOwnProperty(account)) { + return "0x"; // indicate to caller that there are no deposits + } + + const deposits = jsonData[account].deposits; + const depositIdList = jsonData[account].depositIdList || {}; - const deposits = jsonData[account].deposits; - const depositIdList = jsonData[account].depositIdList || {}; + // Array to hold the TokenDepositId structs + let tokenDepositIds = []; - // Array to hold the TokenDepositId structs - let tokenDepositIds = []; + // Arrays to hold all deposit IDs, amounts, and BDVs in order + let allDepositIds = []; + let allAmounts = []; + let allBdvs = []; - // Process each token in the whitelistedTokens array - for (const token of whitelistedTokens) { - if (depositIdList.hasOwnProperty(token)) { - const depositIds = depositIdList[token]; - const tokenDeposits = depositIds.map(depositId => { - const depositInfo = deposits[ethers.BigNumber.from(depositId).toString()]; - return { - amount: ethers.BigNumber.from(depositInfo.amount), - bdv: ethers.BigNumber.from(depositInfo.bdv) - }; - }); + // Process each token in the whitelistedTokens array + for (const token of whitelistedTokens) { + if (depositIdList.hasOwnProperty(token)) { + const depositIds = depositIdList[token]; + const tokenDeposits = depositIds.map((depositId) => { + const depositInfo = deposits[ethers.BigNumber.from(depositId).toString()]; + // Add to the all* arrays + allDepositIds.push(ethers.BigNumber.from(depositId)); + allAmounts.push(ethers.BigNumber.from(depositInfo.amount)); + allBdvs.push(ethers.BigNumber.from(depositInfo.bdv)); + return { + amount: ethers.BigNumber.from(depositInfo.amount), + bdv: ethers.BigNumber.from(depositInfo.bdv) + }; + }); - // Create the TokenDepositId struct with deposits - tokenDepositIds.push({ - token: token, - depositIds: depositIds.map(id => ethers.BigNumber.from(id)), - tokenDeposits: tokenDeposits - }); - } else { - // Create the TokenDepositId struct with no deposits - tokenDepositIds.push({ - token: token, - depositIds: [], - tokenDeposits: [] - }); - } + // Create the TokenDepositId struct with deposits + tokenDepositIds.push({ + token: token, + depositIds: depositIds.map((id) => ethers.BigNumber.from(id)), + tokenDeposits: tokenDeposits + }); + } else { + // Create the TokenDepositId struct with no deposits + tokenDepositIds.push({ + token: token, + depositIds: [], + tokenDeposits: [] + }); } + } - // ABI encode the array of TokenDepositId structs - const encodedData = ethers.utils.defaultAbiCoder.encode( - [ - 'tuple(address token, uint256[] depositIds, tuple(uint256 amount, uint256 bdv)[] tokenDeposits)[]' - ], - [tokenDepositIds] - ); + // ABI encode the array of TokenDepositId structs + const encodedData = ethers.utils.defaultAbiCoder.encode( + [ + "tuple(address token, uint256[] depositIds, tuple(uint256 amount, uint256 bdv)[] tokenDeposits)[]", + "uint256[]", + "uint256[]", + "uint256[]" + ], + [tokenDepositIds, allDepositIds, allAmounts, allBdvs] + ); - return encodedData; + return encodedData; } // Get the command line arguments @@ -76,5 +92,5 @@ const account = args[1]; // Run the function and output the result const encodedTokenDepositIds = findTokenDepositIds(jsonFilePath, account); if (encodedTokenDepositIds) { - console.log(encodedTokenDepositIds); + console.log(encodedTokenDepositIds); } diff --git a/protocol/test/foundry/Migration/ReseedContracts.sol b/protocol/test/foundry/Migration/ReseedContracts.sol new file mode 100644 index 000000000..67e226f65 --- /dev/null +++ b/protocol/test/foundry/Migration/ReseedContracts.sol @@ -0,0 +1,539 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.6.0 <0.9.0; +pragma abicoder v2; + +import {TestHelper, LibTransfer, C, IMockFBeanstalk} from "test/foundry/utils/TestHelper.sol"; +import {L1RecieverFacet} from "contracts/beanstalk/migration/L1RecieverFacet.sol"; +import {Order} from "contracts/beanstalk/market/MarketplaceFacet/Order.sol"; +import {LibBytes} from "contracts/Libraries/LibBytes.sol"; +import "@openzeppelin/contracts/utils/Strings.sol"; +import "forge-std/console.sol"; + +/** + * @notice Tests the functionality of the L1RecieverFacet. + */ + +interface IERC1555 { + function balanceOf(address account, uint256 id) external view returns (uint256); +} + +contract L1RecieverFacetTest is Order, TestHelper { + using Strings for string; + // Offset arbitrum uses for corresponding L2 address + uint160 internal constant OFFSET = uint160(0x1111000000000000000000000000000000001111); + + address constant L2BEAN = address(0xBEA0005B8599265D41256905A9B3073D397812E4); + address constant L2URBEAN = address(0x1BEA054dddBca12889e07B3E076f511Bf1d27543); + address constant L2URLP = address(0x1BEA059c3Ea15F6C10be1c53d70C75fD1266D788); + + string constant CONTRACT_ADDRESSES_PATH = + "./scripts/beanstalk-3/data/inputs/ContractAddresses.txt"; + uint256 constant CONTRACT_ADDRESSES_LENGTH = 47; // should be the number of lines in the file above + + // contracts for testing: + // note this is the first address numerically sorted in the merkle tree + address OWNER; + address RECIEVER; + + function setUp() public { + initializeBeanstalkTestState(true, false); + + // setup basic whitelisting for testing + bs.mockWhitelistToken(L2BEAN, IMockFBeanstalk.beanToBDV.selector, 10000000000, 1); + bs.mockWhitelistToken(L2URBEAN, IMockFBeanstalk.unripeBeanToBDV.selector, 10000000000, 1); + bs.mockWhitelistToken(L2URLP, IMockFBeanstalk.unripeLPToBDV.selector, 10000000000, 1); + + // set the milestone stem for BEAN + bs.mockSetMilestoneStem(L2BEAN, 36462179909); + bs.mockSetMilestoneSeason(L2BEAN, bs.season()); + bs.mockSetMilestoneStem(L2URBEAN, 0); + bs.mockSetMilestoneSeason(L2URBEAN, bs.season()); + bs.mockSetMilestoneStem(L2URLP, 0); + bs.mockSetMilestoneSeason(L2URLP, bs.season()); + } + + /** + * @notice validates that an account verification works, with the correct data. + */ + function test_L2MigrateDeposits() public { + // loop through all contracts that have deposits + for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { + OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + ( + uint256[] memory depositIds, + uint256[] memory amounts, + uint256[] memory bdvs + ) = getDepositData(OWNER); + + // log deposit ids, amounts, bdvs, and proof + // for (uint256 j = 0; j < depositIds.length; j++) { + // console.log("depositId:", depositIds[j]); + // console.log("amount:", amounts[j]); + // console.log("bdv:", bdvs[j]); + // } + + bytes32[] memory proof = getProofForAccount(OWNER); + + // log proof + // console.log("proof:"); + // for (uint256 j = 0; j < proof.length; j++) { + // console.logBytes32(proof[j]); + // } + + // if there are no deposits, continue to next contract + if (depositIds.length == 0) { + // console.log("No deposits found for account, skipping:", OWNER); + continue; + } + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueDeposits(OWNER, depositIds, amounts, bdvs, proof); + } + + // assertEq(bs.balanceOfStalk(RECIEVER), 9278633023225688000000); + // (address token, int96 stem) = LibBytes.unpackAddressAndStem(depositIds[0]); + // (uint256 amount, uint256 bdv) = bs.getDeposit(RECIEVER, token, stem); + // assertEq(amount, depositAmounts[0]); + // assertEq(bdv, bdvs[0]); + } + + function test_L2MigratePlots() public { + OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + uint256[] memory index, + uint256[] memory pods, + bytes32[] memory proof + ) = getMockPlot(); + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); + uint256 amt = bs.plot(RECIEVER, 0, index[0]); + assertEq(amt, pods[0]); + + // verify user cannot migrate afterwords. + vm.expectRevert("L2Migration: Plots have been migrated"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); + } + + function test_L2MigrateInternalBalances() public { + OWNER = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + address[] memory tokens, + uint256[] memory amounts, + bytes32[] memory proof + ) = getMockInternalBalance(); + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); + uint256 amount = bs.getInternalBalance(RECIEVER, tokens[0]); + assertEq(amount, amounts[0]); + // verify user cannot migrate afterwords. + vm.expectRevert("L2Migration: Internal Balances have been migrated"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); + } + + function test_L2MigrateFert() public { + OWNER = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + uint256[] memory ids, + uint128[] memory amounts, + uint128 lastBpf, + bytes32[] memory proof + ) = getMockFertilizer(); + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); + + assertEq(IERC1555(fertilizerAddress).balanceOf(RECIEVER, ids[0]), amounts[0]); + + // verify user cannot migrate afterwords. + vm.expectRevert("L2Migration: Fertilizer have been migrated"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); + } + + /* + // commented out because no pod orders owned by contracts + function test_L2MigratePodOrder() public { + bs.setRecieverForL1Migration(address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4), RECIEVER); + + ( + address owner, + L1RecieverFacet.L1PodOrder[] memory podOrders, + bytes32[] memory proof + ) = getMockPodOrder(); + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePodOrders( + address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4), + podOrders, + proof + ); + + // update pod order with reciever to verify id: + podOrders[0].podOrder.orderer = RECIEVER; + + bytes32 id = _getOrderId(podOrders[0].podOrder); + + assertEq(bs.getPodOrder(id), podOrders[0].beanAmount); + + // verify user cannot migrate afterwords. + vm.expectRevert("L2Migration: Orders have been migrated"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePodOrders(owner, podOrders, proof); + }*/ + + /** + * @notice verifies only the owner or bridge can call the migration functions. + */ + function test_L2MigrateInvalidReciever(address reciever) public { + vm.prank(reciever); + vm.expectRevert("L1RecieverFacet: Invalid Caller"); + bs.approveReciever(OWNER, reciever); + + uint256 snapshot = vm.snapshot(); + address aliasedAddress = applyL1ToL2Alias(BEANSTALK); + vm.prank(aliasedAddress); + bs.approveReciever(OWNER, reciever); + assertEq(bs.getReciever(OWNER), reciever); + + vm.revertTo(snapshot); + vm.prank(users[0]); + bs.approveReciever(OWNER, reciever); + assertEq(bs.getReciever(OWNER), reciever); + } + + /** + * @notice verifies that a user cannot gain an invalid plot. + */ + function test_L2MigrateInvalidPlot() public { + OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + uint256[] memory index, + uint256[] memory pods, + bytes32[] memory proof + ) = getMockPlot(); + + pods[0] = type(uint256).max; + + vm.expectRevert("L2Migration: Invalid plots"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); + } + + function test_L2MigrateInvalidInternalBalance() public { + OWNER = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + address[] memory tokens, + uint256[] memory amounts, + bytes32[] memory proof + ) = getMockInternalBalance(); + + amounts[0] = type(uint256).max; + + vm.expectRevert("L2Migration: Invalid internal balances"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); + } + + function test_L2MigrateInvalidFert() public { + OWNER = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + + ( + address owner, + uint256[] memory ids, + uint128[] memory amounts, + uint128 lastBpf, + bytes32[] memory proof + ) = getMockFertilizer(); + + amounts[0] = type(uint128).max; + + // verify user cannot migrate afterwords. + vm.expectRevert("L2Migration: Invalid Fertilizer"); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); + } + + // test helpers + function getDepositData( + address account + ) internal returns (uint256[] memory, uint256[] memory, uint256[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/depositDataReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/inputs/Deposits.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Check if the result is empty or just "0x" + if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { + // console.log("No deposit data found for account:", account); + return (new uint256[](0), new uint256[](0), new uint256[](0)); + } + + (uint256[] memory depositIds, uint256[] memory amounts, uint256[] memory bdvs) = abi.decode( + result, + (uint256[], uint256[], uint256[]) + ); + + // Log the results + // console.log("Deposit data found for account:", account); + // for (uint i = 0; i < depositIds.length; i++) { + // console.log("depositId:", depositIds[i]); + // console.log("amount:", amounts[i]); + // console.log("bdv:", bdvs[i]); + // } + + return (depositIds, amounts, bdvs); + } + + function decodeDepositData( + bytes memory data + ) external pure returns (IMockFBeanstalk.TokenDepositId[] memory) { + return abi.decode(data, (IMockFBeanstalk.TokenDepositId[])); + } + + function getMockPlot() + internal + returns (address, uint256[] memory, uint256[] memory, bytes32[] memory) + { + address account = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); + + uint256[] memory index = new uint256[](6); + index[0] = 633990925883216; + index[1] = 649972854809057; + index[2] = 666992136712860; + index[3] = 696658166381444; + index[4] = 696966636250825; + index[5] = 707711446117109; + + uint256[] memory pods = new uint256[](6); + pods[0] = 13743931655; + pods[1] = 310402500; + pods[2] = 5130435000; + pods[3] = 39926484; + pods[4] = 2347857; + pods[5] = 1525000; + + bytes32[] memory proof = new bytes32[](3); + proof[0] = bytes32(0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921); + proof[1] = bytes32(0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789); + proof[2] = bytes32(0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3); + + return (account, index, pods, proof); + } + + function getMockInternalBalance() + internal + returns (address, address[] memory, uint256[] memory, bytes32[] memory) + { + address account = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); + + address[] memory tokens = new address[](1); + tokens[0] = address(0x1BEA054dddBca12889e07B3E076f511Bf1d27543); + + uint256[] memory amounts = new uint256[](1); + amounts[0] = 8568; + + bytes32[] memory proof = new bytes32[](3); + proof[0] = bytes32(0xe6b126b486d1049a3c4ea6d32708dedf47b9d508d591671eddd7214476914f69); + proof[1] = bytes32(0x88659cfb1b3bec548b7ac3b0c5dd1ff653cbc33e3a12e10fd6e7a554a0402f46); + proof[2] = bytes32(0x18679f0b3b62978601eb10e75699f4a869665f734fcca4c304a4d639e2c32f26); + + return (account, tokens, amounts, proof); + } + + function getMockFertilizer() + internal + returns (address, uint256[] memory, uint128[] memory, uint128, bytes32[] memory) + { + address account = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); + + uint256[] memory ids = new uint256[](4); + ids[0] = 3458512; + ids[1] = 3458531; + ids[2] = 3470220; + ids[3] = 6000000; + + uint128[] memory amounts = new uint128[](4); + amounts[0] = 542767; + amounts[1] = 56044; + amounts[2] = 291896; + amounts[3] = 8046712; + + uint128 lastBpf = 340802; + + bytes32[] memory proof = new bytes32[](3); + proof[0] = bytes32(0x044efadc8244d78f08686bb10b22ee313b8331aefafc0badffbb74c0558e3f8a); + proof[1] = bytes32(0xf6e0807e42179f8c975067c891e93ac48621024dc25b223baf4a78f0edcfa61d); + proof[2] = bytes32(0x7e77601c08f8772a9cf44337db2696d84da8290be446b231dc70c4289526a4d9); + + return (account, ids, amounts, lastBpf, proof); + } + + /*function getMockPodOrder() + internal + returns (address, L1RecieverFacet.L1PodOrder[] memory, bytes32[] memory) + { + address account = address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4); + + L1RecieverFacet.L1PodOrder[] memory podOrders = new L1RecieverFacet.L1PodOrder[](1); + podOrders[0] = L1RecieverFacet.L1PodOrder( + Order.PodOrder(account, 1, 100000, 1000000000000, 1000000), + 1000000 + ); + + bytes32[] memory proof = new bytes32[](3); + proof[0] = bytes32(0x9887e2354e3cdb5d01aff524d71607cfdf3c4293c6f5711c806277fee5ad2063); + proof[1] = bytes32(0xe7d5a9eada9ddd23ca981cb62c1c0668339becddfdd69c463ae63ee3ebbdf50f); + proof[2] = bytes32(0x9dc791f184484213529aa44fad0074c356eb252777a3c9b0516efaf0fd740650); + + return (account, podOrders, proof); + }*/ + + /** + * @notice Utility function that converts the address in the L1 that submitted a tx to + * the inbox to the msg.sender viewed in the L2 + * @param l1Address the address in the L1 that triggered the tx to L2 + * @return l2Address L2 address as viewed in msg.sender + */ + function applyL1ToL2Alias(address l1Address) internal pure returns (address l2Address) { + unchecked { + l2Address = address( + uint160(l1Address) + uint160(0x1111000000000000000000000000000000001111) + ); + } + } + + function getAllDeposits( + address account + ) internal returns (IMockFBeanstalk.TokenDepositId[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/migrationFinderScripts/depositFinder.js"; // existing script + inputs[2] = "./reseed/data/exports/storage-accounts20736200.json"; // json file + inputs[3] = vm.toString(account); + bytes memory encodedData = vm.ffi(inputs); + + if (encodedData.length == 0) { + return new IMockFBeanstalk.TokenDepositId[](0); + } + + return abi.decode(encodedData, (IMockFBeanstalk.TokenDepositId[])); + } + + function hexStringToBytes32(string memory s) internal view returns (bytes32 result) { + bytes memory b = bytes(s); + require(b.length == 64, "Invalid input length"); + + for (uint i = 0; i < 64; i++) { + uint8 digit = uint8(b[i]); + // console.log("Processing character:", string(abi.encodePacked(b[i]))); + // console.log("ASCII value:", digit); + + if (digit >= 48 && digit <= 57) { + digit -= 48; // 0-9 + } else if (digit >= 65 && digit <= 70) { + digit -= 55; // A-F + } else if (digit >= 97 && digit <= 102) { + digit -= 87; // a-f + } else { + // console.log("Invalid character found at position:", i); + // console.log("Invalid character:", string(abi.encodePacked(b[i]))); + // console.log("ASCII value of invalid character:", digit); + revert("Invalid character in hex string"); + } + result = bytes32(uint256(result) * 16 + digit); + } + } + + function getProofForAccount(address account) internal returns (bytes32[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/proofReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/merkle/deposit_tree.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Convert raw bytes to hex string + string memory proofString = bytesToHexString(result); + + if ( + keccak256(bytes(proofString)) == keccak256(bytes("NO_PROOF_FOUND")) || + keccak256(bytes(proofString)) == keccak256(bytes("ERROR_READING_PROOF")) + ) { + return new bytes32[](0); + } + + // Calculate the number of proof elements (each element is 64 characters long) + uint256 numElements = bytes(proofString).length / 64; + // console.log("Number of elements:", numElements); + + // Create an array with the correct size + bytes32[] memory proof = new bytes32[](numElements); + + // Split the packed string into an array of bytes32 + for (uint256 i = 0; i < numElements; i++) { + string memory element = substring(proofString, i * 64, (i + 1) * 64); + // console.log("Processing element:", i); + // console.log("Element string:", element); + proof[i] = hexStringToBytes32(element); + // console.log("Processed proof element:"); + console.logBytes32(proof[i]); + } + + return proof; + } + + function bytesToHexString(bytes memory data) internal pure returns (string memory) { + bytes memory hexChars = "0123456789abcdef"; + bytes memory result = new bytes(data.length * 2); + for (uint i = 0; i < data.length; i++) { + result[i * 2] = hexChars[uint8(data[i] >> 4)]; + result[i * 2 + 1] = hexChars[uint8(data[i] & 0x0f)]; + } + return string(result); + } + + function substring( + string memory str, + uint256 startIndex, + uint256 endIndex + ) internal pure returns (string memory) { + bytes memory strBytes = bytes(str); + bytes memory result = new bytes(endIndex - startIndex); + for (uint256 i = startIndex; i < endIndex; i++) { + result[i - startIndex] = strBytes[i]; + } + return string(result); + } +} From 49228f6bc282c66789876317fe74edf8637b2535 Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 10:11:49 -0600 Subject: [PATCH 07/15] Cleanup --- .../foundry/Migration/ReseedContracts.sol | 105 +++++------------- 1 file changed, 30 insertions(+), 75 deletions(-) diff --git a/protocol/test/foundry/Migration/ReseedContracts.sol b/protocol/test/foundry/Migration/ReseedContracts.sol index 67e226f65..f60826401 100644 --- a/protocol/test/foundry/Migration/ReseedContracts.sol +++ b/protocol/test/foundry/Migration/ReseedContracts.sol @@ -55,7 +55,7 @@ contract L1RecieverFacetTest is Order, TestHelper { /** * @notice validates that an account verification works, with the correct data. */ - function test_L2MigrateDeposits() public { + function test_L2MigrateAllDeposits() public { // loop through all contracts that have deposits for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); @@ -67,21 +67,8 @@ contract L1RecieverFacetTest is Order, TestHelper { uint256[] memory bdvs ) = getDepositData(OWNER); - // log deposit ids, amounts, bdvs, and proof - // for (uint256 j = 0; j < depositIds.length; j++) { - // console.log("depositId:", depositIds[j]); - // console.log("amount:", amounts[j]); - // console.log("bdv:", bdvs[j]); - // } - bytes32[] memory proof = getProofForAccount(OWNER); - // log proof - // console.log("proof:"); - // for (uint256 j = 0; j < proof.length; j++) { - // console.logBytes32(proof[j]); - // } - // if there are no deposits, continue to next contract if (depositIds.length == 0) { // console.log("No deposits found for account, skipping:", OWNER); @@ -91,12 +78,6 @@ contract L1RecieverFacetTest is Order, TestHelper { vm.prank(RECIEVER); L1RecieverFacet(BEANSTALK).issueDeposits(OWNER, depositIds, amounts, bdvs, proof); } - - // assertEq(bs.balanceOfStalk(RECIEVER), 9278633023225688000000); - // (address token, int96 stem) = LibBytes.unpackAddressAndStem(depositIds[0]); - // (uint256 amount, uint256 bdv) = bs.getDeposit(RECIEVER, token, stem); - // assertEq(amount, depositAmounts[0]); - // assertEq(bdv, bdvs[0]); } function test_L2MigratePlots() public { @@ -281,40 +262,6 @@ contract L1RecieverFacetTest is Order, TestHelper { L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); } - // test helpers - function getDepositData( - address account - ) internal returns (uint256[] memory, uint256[] memory, uint256[] memory) { - string[] memory inputs = new string[](4); - inputs[0] = "node"; - inputs[1] = "./scripts/beanstalk-3/depositDataReader.js"; - inputs[2] = "./scripts/beanstalk-3/data/inputs/Deposits.json"; - inputs[3] = Strings.toHexString(uint160(account), 20); - - bytes memory result = vm.ffi(inputs); - - // Check if the result is empty or just "0x" - if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { - // console.log("No deposit data found for account:", account); - return (new uint256[](0), new uint256[](0), new uint256[](0)); - } - - (uint256[] memory depositIds, uint256[] memory amounts, uint256[] memory bdvs) = abi.decode( - result, - (uint256[], uint256[], uint256[]) - ); - - // Log the results - // console.log("Deposit data found for account:", account); - // for (uint i = 0; i < depositIds.length; i++) { - // console.log("depositId:", depositIds[i]); - // console.log("amount:", amounts[i]); - // console.log("bdv:", bdvs[i]); - // } - - return (depositIds, amounts, bdvs); - } - function decodeDepositData( bytes memory data ) external pure returns (IMockFBeanstalk.TokenDepositId[] memory) { @@ -399,26 +346,6 @@ contract L1RecieverFacetTest is Order, TestHelper { return (account, ids, amounts, lastBpf, proof); } - /*function getMockPodOrder() - internal - returns (address, L1RecieverFacet.L1PodOrder[] memory, bytes32[] memory) - { - address account = address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4); - - L1RecieverFacet.L1PodOrder[] memory podOrders = new L1RecieverFacet.L1PodOrder[](1); - podOrders[0] = L1RecieverFacet.L1PodOrder( - Order.PodOrder(account, 1, 100000, 1000000000000, 1000000), - 1000000 - ); - - bytes32[] memory proof = new bytes32[](3); - proof[0] = bytes32(0x9887e2354e3cdb5d01aff524d71607cfdf3c4293c6f5711c806277fee5ad2063); - proof[1] = bytes32(0xe7d5a9eada9ddd23ca981cb62c1c0668339becddfdd69c463ae63ee3ebbdf50f); - proof[2] = bytes32(0x9dc791f184484213529aa44fad0074c356eb252777a3c9b0516efaf0fd740650); - - return (account, podOrders, proof); - }*/ - /** * @notice Utility function that converts the address in the L1 that submitted a tx to * the inbox to the msg.sender viewed in the L2 @@ -433,6 +360,34 @@ contract L1RecieverFacetTest is Order, TestHelper { } } + //////////////////////// DEPOSITS //////////////////////// + + // test helpers + function getDepositData( + address account + ) internal returns (uint256[] memory, uint256[] memory, uint256[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/depositDataReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/inputs/Deposits.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Check if the result is empty or just "0x" + if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { + // console.log("No deposit data found for account:", account); + return (new uint256[](0), new uint256[](0), new uint256[](0)); + } + + (uint256[] memory depositIds, uint256[] memory amounts, uint256[] memory bdvs) = abi.decode( + result, + (uint256[], uint256[], uint256[]) + ); + + return (depositIds, amounts, bdvs); + } + function getAllDeposits( address account ) internal returns (IMockFBeanstalk.TokenDepositId[] memory) { @@ -450,7 +405,7 @@ contract L1RecieverFacetTest is Order, TestHelper { return abi.decode(encodedData, (IMockFBeanstalk.TokenDepositId[])); } - function hexStringToBytes32(string memory s) internal view returns (bytes32 result) { + function hexStringToBytes32(string memory s) internal pure returns (bytes32 result) { bytes memory b = bytes(s); require(b.length == 64, "Invalid input length"); From 45a777aa917acc0d37729b102c19970906e20c80 Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 12:07:29 -0600 Subject: [PATCH 08/15] Exercise contracts migrating all owned plots --- .../scripts/beanstalk-3/plotDataReader.js | 45 +++ ...{proofReader.js => proofReaderDeposits.js} | 0 .../scripts/beanstalk-3/proofReaderPlots.js | 40 +++ .../foundry/Migration/ReseedContracts.sol | 338 ++++++++---------- 4 files changed, 234 insertions(+), 189 deletions(-) create mode 100644 protocol/scripts/beanstalk-3/plotDataReader.js rename protocol/scripts/beanstalk-3/{proofReader.js => proofReaderDeposits.js} (100%) create mode 100644 protocol/scripts/beanstalk-3/proofReaderPlots.js diff --git a/protocol/scripts/beanstalk-3/plotDataReader.js b/protocol/scripts/beanstalk-3/plotDataReader.js new file mode 100644 index 000000000..2aa090eff --- /dev/null +++ b/protocol/scripts/beanstalk-3/plotDataReader.js @@ -0,0 +1,45 @@ +const fs = require("fs"); +const { ethers } = require("ethers"); + +function readPlotData(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Convert the input address to checksummed format + const checksummedAccount = ethers.utils.getAddress(account); + + // Find the data for the specified account + const accountData = jsonData.find( + (data) => ethers.utils.getAddress(data[0]) === checksummedAccount + ); + + if (!accountData) { + console.error(`No plot data found for account: ${checksummedAccount}`); + return "0x"; + } + + const plotIds = accountData[1]; + const amounts = accountData[2]; + + // Encode the data + const encodedData = ethers.utils.defaultAbiCoder.encode( + ["uint256[]", "uint256[]"], + [plotIds, amounts] + ); + + return encodedData; + } catch (error) { + console.error(`Error reading plot data: ${error.message}`); + return "0x"; + } +} + +// Get command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const encodedData = readPlotData(jsonFilePath, account); +console.log(encodedData); diff --git a/protocol/scripts/beanstalk-3/proofReader.js b/protocol/scripts/beanstalk-3/proofReaderDeposits.js similarity index 100% rename from protocol/scripts/beanstalk-3/proofReader.js rename to protocol/scripts/beanstalk-3/proofReaderDeposits.js diff --git a/protocol/scripts/beanstalk-3/proofReaderPlots.js b/protocol/scripts/beanstalk-3/proofReaderPlots.js new file mode 100644 index 000000000..c50cfaeb5 --- /dev/null +++ b/protocol/scripts/beanstalk-3/proofReaderPlots.js @@ -0,0 +1,40 @@ +const fs = require("fs"); +const path = require("path"); + +function getProofForAccount(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Create a new object with lowercased keys + const lowercaseProofs = Object.keys(jsonData.proofs).reduce((acc, key) => { + acc[key.toLowerCase()] = jsonData.proofs[key]; + return acc; + }, {}); + + // Convert the input account to lowercase + const lowercaseAccount = account.toLowerCase(); + + // Check if the lowercased account exists in the proofs object + if (lowercaseProofs.hasOwnProperty(lowercaseAccount)) { + const proof = lowercaseProofs[lowercaseAccount]; + + // Convert the proof array to a single packed string without '0x' prefixes + return proof.map((element) => element.slice(2)).join(""); + } else { + return "NO_PROOF_FOUND"; + } + } catch (error) { + console.error(`Error reading proof data: ${error.message}`); + return "ERROR_READING_PROOF"; + } +} + +// Get the command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const proof = getProofForAccount(jsonFilePath, account); +console.log(proof); diff --git a/protocol/test/foundry/Migration/ReseedContracts.sol b/protocol/test/foundry/Migration/ReseedContracts.sol index f60826401..c10534242 100644 --- a/protocol/test/foundry/Migration/ReseedContracts.sol +++ b/protocol/test/foundry/Migration/ReseedContracts.sol @@ -67,7 +67,7 @@ contract L1RecieverFacetTest is Order, TestHelper { uint256[] memory bdvs ) = getDepositData(OWNER); - bytes32[] memory proof = getProofForAccount(OWNER); + bytes32[] memory proof = getDepositsProofForAccount(OWNER); // if there are no deposits, continue to next contract if (depositIds.length == 0) { @@ -80,27 +80,44 @@ contract L1RecieverFacetTest is Order, TestHelper { } } - function test_L2MigratePlots() public { - OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); + function test_L2MigrateAllPlots() public { + // OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); + // RECIEVER = applyL1ToL2Alias(OWNER); + // bs.setRecieverForL1Migration(OWNER, RECIEVER); - ( - address owner, - uint256[] memory index, - uint256[] memory pods, - bytes32[] memory proof - ) = getMockPlot(); + // ( + // address owner, + // uint256[] memory index, + // uint256[] memory pods, + // bytes32[] memory proof + // ) = getMockPlot(); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); - uint256 amt = bs.plot(RECIEVER, 0, index[0]); - assertEq(amt, pods[0]); + // vm.prank(RECIEVER); + // L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); + // uint256 amt = bs.plot(RECIEVER, 0, index[0]); + // assertEq(amt, pods[0]); - // verify user cannot migrate afterwords. - vm.expectRevert("L2Migration: Plots have been migrated"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); + // // verify user cannot migrate afterwords. + // vm.expectRevert("L2Migration: Plots have been migrated"); + // vm.prank(RECIEVER); + + for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { + OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + (uint256[] memory index, uint256[] memory pods) = getPlotData(OWNER); + + bytes32[] memory proof = getPlotsProofForAccount(OWNER); + + // if there are no indexes, continue to next contract + if (index.length == 0) { + console.log("No index found for account, skipping:", OWNER); + continue; + } + + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issuePlots(OWNER, index, pods, proof); + } } function test_L2MigrateInternalBalances() public { @@ -149,155 +166,12 @@ contract L1RecieverFacetTest is Order, TestHelper { L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); } - /* - // commented out because no pod orders owned by contracts - function test_L2MigratePodOrder() public { - bs.setRecieverForL1Migration(address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4), RECIEVER); - - ( - address owner, - L1RecieverFacet.L1PodOrder[] memory podOrders, - bytes32[] memory proof - ) = getMockPodOrder(); - - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issuePodOrders( - address(0x000000009d3a9e5C7C620514E1F36905c4eb91e4), - podOrders, - proof - ); - - // update pod order with reciever to verify id: - podOrders[0].podOrder.orderer = RECIEVER; - - bytes32 id = _getOrderId(podOrders[0].podOrder); - - assertEq(bs.getPodOrder(id), podOrders[0].beanAmount); - - // verify user cannot migrate afterwords. - vm.expectRevert("L2Migration: Orders have been migrated"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issuePodOrders(owner, podOrders, proof); - }*/ - - /** - * @notice verifies only the owner or bridge can call the migration functions. - */ - function test_L2MigrateInvalidReciever(address reciever) public { - vm.prank(reciever); - vm.expectRevert("L1RecieverFacet: Invalid Caller"); - bs.approveReciever(OWNER, reciever); - - uint256 snapshot = vm.snapshot(); - address aliasedAddress = applyL1ToL2Alias(BEANSTALK); - vm.prank(aliasedAddress); - bs.approveReciever(OWNER, reciever); - assertEq(bs.getReciever(OWNER), reciever); - - vm.revertTo(snapshot); - vm.prank(users[0]); - bs.approveReciever(OWNER, reciever); - assertEq(bs.getReciever(OWNER), reciever); - } - - /** - * @notice verifies that a user cannot gain an invalid plot. - */ - function test_L2MigrateInvalidPlot() public { - OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); - - ( - address owner, - uint256[] memory index, - uint256[] memory pods, - bytes32[] memory proof - ) = getMockPlot(); - - pods[0] = type(uint256).max; - - vm.expectRevert("L2Migration: Invalid plots"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); - } - - function test_L2MigrateInvalidInternalBalance() public { - OWNER = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); - - ( - address owner, - address[] memory tokens, - uint256[] memory amounts, - bytes32[] memory proof - ) = getMockInternalBalance(); - - amounts[0] = type(uint256).max; - - vm.expectRevert("L2Migration: Invalid internal balances"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); - } - - function test_L2MigrateInvalidFert() public { - OWNER = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); - - ( - address owner, - uint256[] memory ids, - uint128[] memory amounts, - uint128 lastBpf, - bytes32[] memory proof - ) = getMockFertilizer(); - - amounts[0] = type(uint128).max; - - // verify user cannot migrate afterwords. - vm.expectRevert("L2Migration: Invalid Fertilizer"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); - } - function decodeDepositData( bytes memory data ) external pure returns (IMockFBeanstalk.TokenDepositId[] memory) { return abi.decode(data, (IMockFBeanstalk.TokenDepositId[])); } - function getMockPlot() - internal - returns (address, uint256[] memory, uint256[] memory, bytes32[] memory) - { - address account = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); - - uint256[] memory index = new uint256[](6); - index[0] = 633990925883216; - index[1] = 649972854809057; - index[2] = 666992136712860; - index[3] = 696658166381444; - index[4] = 696966636250825; - index[5] = 707711446117109; - - uint256[] memory pods = new uint256[](6); - pods[0] = 13743931655; - pods[1] = 310402500; - pods[2] = 5130435000; - pods[3] = 39926484; - pods[4] = 2347857; - pods[5] = 1525000; - - bytes32[] memory proof = new bytes32[](3); - proof[0] = bytes32(0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921); - proof[1] = bytes32(0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789); - proof[2] = bytes32(0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3); - - return (account, index, pods, proof); - } - function getMockInternalBalance() internal returns (address, address[] memory, uint256[] memory, bytes32[] memory) @@ -405,35 +279,10 @@ contract L1RecieverFacetTest is Order, TestHelper { return abi.decode(encodedData, (IMockFBeanstalk.TokenDepositId[])); } - function hexStringToBytes32(string memory s) internal pure returns (bytes32 result) { - bytes memory b = bytes(s); - require(b.length == 64, "Invalid input length"); - - for (uint i = 0; i < 64; i++) { - uint8 digit = uint8(b[i]); - // console.log("Processing character:", string(abi.encodePacked(b[i]))); - // console.log("ASCII value:", digit); - - if (digit >= 48 && digit <= 57) { - digit -= 48; // 0-9 - } else if (digit >= 65 && digit <= 70) { - digit -= 55; // A-F - } else if (digit >= 97 && digit <= 102) { - digit -= 87; // a-f - } else { - // console.log("Invalid character found at position:", i); - // console.log("Invalid character:", string(abi.encodePacked(b[i]))); - // console.log("ASCII value of invalid character:", digit); - revert("Invalid character in hex string"); - } - result = bytes32(uint256(result) * 16 + digit); - } - } - - function getProofForAccount(address account) internal returns (bytes32[] memory) { + function getDepositsProofForAccount(address account) internal returns (bytes32[] memory) { string[] memory inputs = new string[](4); inputs[0] = "node"; - inputs[1] = "./scripts/beanstalk-3/proofReader.js"; + inputs[1] = "./scripts/beanstalk-3/proofReaderDeposits.js"; inputs[2] = "./scripts/beanstalk-3/data/merkle/deposit_tree.json"; inputs[3] = Strings.toHexString(uint160(account), 20); @@ -491,4 +340,115 @@ contract L1RecieverFacetTest is Order, TestHelper { } return string(result); } + + //////////////////////// PLOTS //////////////////////// + + function getPlotData(address account) internal returns (uint256[] memory, uint256[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/plotDataReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/inputs/Plots.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Check if the result is empty or just "0x" + if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { + console.log("No plot data found for account:", account); + return (new uint256[](0), new uint256[](0)); + } + + (uint256[] memory plotIds, uint256[] memory amounts) = abi.decode( + result, + (uint256[], uint256[]) + ); + + // Log the results + // console.log("Plot data found for account:", account); + // for (uint i = 0; i < plotIds.length; i++) { + // console.log("plotId:", plotIds[i]); + // console.log("amount:", amounts[i]); + // } + + return (plotIds, amounts); + } + + function getPlotsProofForAccount(address account) internal returns (bytes32[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/proofReaderPlots.js"; + inputs[2] = "./scripts/beanstalk-3/data/merkle/plot_tree.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + string memory proofString = bytesToHexString(result); + + if ( + keccak256(bytes(proofString)) == keccak256(bytes("NO_PROOF_FOUND")) || + keccak256(bytes(proofString)) == keccak256(bytes("ERROR_READING_PROOF")) + ) { + return new bytes32[](0); + } + + // Calculate the number of proof elements (each element is 64 characters long) + uint256 numElements = bytes(proofString).length / 64; + console.log("Number of proof elements:", numElements); + + // Create an array with the correct size + bytes32[] memory proof = new bytes32[](numElements); + + // Split the packed string into an array of bytes32 + for (uint256 i = 0; i < numElements; i++) { + string memory element = substring(proofString, i * 64, (i + 1) * 64); + proof[i] = hexStringToBytes32(element); + console.log("Processed proof element:"); + console.logBytes32(proof[i]); + } + + return proof; + } + + function hexStringToBytes32(string memory s) internal pure returns (bytes32 result) { + bytes memory b = bytes(s); + require(b.length == 64, "Invalid input length"); + + for (uint i = 0; i < 64; i++) { + uint8 digit = uint8(b[i]); + if (digit >= 48 && digit <= 57) { + digit -= 48; // 0-9 + } else if (digit >= 65 && digit <= 70) { + digit -= 55; // A-F + } else if (digit >= 97 && digit <= 102) { + digit -= 87; // a-f + } else { + revert("Invalid character in hex string"); + } + result = bytes32(uint256(result) * 16 + digit); + } + } + + function hexStringToBytes16(string memory s) public pure returns (bytes16 result) { + bytes memory b = bytes(s); + require(b.length == 32, "Invalid input length"); + + for (uint i = 0; i < 32; i++) { + uint8 digit = uint8(b[i]); + console.log("Processing character:", string(abi.encodePacked(b[i]))); + console.log("ASCII value:", digit); + + if (digit >= 48 && digit <= 57) { + digit -= 48; // 0-9 + } else if (digit >= 65 && digit <= 70) { + digit -= 55; // A-F + } else if (digit >= 97 && digit <= 102) { + digit -= 87; // a-f + } else { + console.log("Invalid character found at position:", i); + console.log("Invalid character:", string(abi.encodePacked(b[i]))); + console.log("ASCII value of invalid character:", digit); + revert("Invalid character in hex string"); + } + result = bytes16(uint128(result) * 16 + digit); + } + } } From 8ff1786f61288eb505989050db53dbaffdad8caf Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 12:31:13 -0600 Subject: [PATCH 09/15] Support for internal balances checking for all contracts --- .../beanstalk-3/internalBalancesDataReader.js | 45 +++++++++++++++++++ .../proofReaderInternalBalances.js | 40 +++++++++++++++++ 2 files changed, 85 insertions(+) create mode 100644 protocol/scripts/beanstalk-3/internalBalancesDataReader.js create mode 100644 protocol/scripts/beanstalk-3/proofReaderInternalBalances.js diff --git a/protocol/scripts/beanstalk-3/internalBalancesDataReader.js b/protocol/scripts/beanstalk-3/internalBalancesDataReader.js new file mode 100644 index 000000000..b28f4e9dc --- /dev/null +++ b/protocol/scripts/beanstalk-3/internalBalancesDataReader.js @@ -0,0 +1,45 @@ +const fs = require("fs"); +const { ethers } = require("ethers"); + +function readDepositData(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Convert the input address to checksummed format + const checksummedAccount = ethers.utils.getAddress(account); + + // Find the data for the specified account + const accountData = jsonData.find( + (data) => ethers.utils.getAddress(data[0]) === checksummedAccount + ); + + if (!accountData) { + // console.error(`No data found for account: ${checksummedAccount}`); + return "0x"; + } + + const addresses = accountData[1]; + const amounts = accountData[2]; + + // Encode the data + const encodedData = ethers.utils.defaultAbiCoder.encode( + ["address[]", "uint256[]"], + [addresses, amounts] + ); + + return encodedData; + } catch (error) { + console.error(`Error reading deposit data: ${error.message}`); + return "0x"; + } +} + +// Get command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const encodedData = readDepositData(jsonFilePath, account); +console.log(encodedData); diff --git a/protocol/scripts/beanstalk-3/proofReaderInternalBalances.js b/protocol/scripts/beanstalk-3/proofReaderInternalBalances.js new file mode 100644 index 000000000..c50cfaeb5 --- /dev/null +++ b/protocol/scripts/beanstalk-3/proofReaderInternalBalances.js @@ -0,0 +1,40 @@ +const fs = require("fs"); +const path = require("path"); + +function getProofForAccount(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Create a new object with lowercased keys + const lowercaseProofs = Object.keys(jsonData.proofs).reduce((acc, key) => { + acc[key.toLowerCase()] = jsonData.proofs[key]; + return acc; + }, {}); + + // Convert the input account to lowercase + const lowercaseAccount = account.toLowerCase(); + + // Check if the lowercased account exists in the proofs object + if (lowercaseProofs.hasOwnProperty(lowercaseAccount)) { + const proof = lowercaseProofs[lowercaseAccount]; + + // Convert the proof array to a single packed string without '0x' prefixes + return proof.map((element) => element.slice(2)).join(""); + } else { + return "NO_PROOF_FOUND"; + } + } catch (error) { + console.error(`Error reading proof data: ${error.message}`); + return "ERROR_READING_PROOF"; + } +} + +// Get the command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const proof = getProofForAccount(jsonFilePath, account); +console.log(proof); From a7d1d8d105db074e91fda7f657e744018c346750 Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 13:40:02 -0600 Subject: [PATCH 10/15] Support for testing migrating all contract's fert --- .../scripts/beanstalk-3/fertDataReader.js | 46 +++ .../scripts/beanstalk-3/plotDataReader.js | 2 +- .../scripts/beanstalk-3/proofReaderFert.js | 40 ++ .../foundry/Migration/ReseedContracts.sol | 350 +++++++++--------- 4 files changed, 267 insertions(+), 171 deletions(-) create mode 100644 protocol/scripts/beanstalk-3/fertDataReader.js create mode 100644 protocol/scripts/beanstalk-3/proofReaderFert.js diff --git a/protocol/scripts/beanstalk-3/fertDataReader.js b/protocol/scripts/beanstalk-3/fertDataReader.js new file mode 100644 index 000000000..f945285b3 --- /dev/null +++ b/protocol/scripts/beanstalk-3/fertDataReader.js @@ -0,0 +1,46 @@ +const fs = require("fs"); +const { ethers } = require("ethers"); + +function readFertData(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Convert the input address to checksummed format + const checksummedAccount = ethers.utils.getAddress(account); + + // Find the data for the specified account + const accountData = jsonData.find( + (data) => ethers.utils.getAddress(data[0]) === checksummedAccount + ); + + if (!accountData) { + // console.error(`No fert data found for account: ${checksummedAccount}`); + return "0x"; + } + + const fertIds = accountData[1]; + const amounts = accountData[2]; + const lastBpf = accountData[3]; + + // Encode the data + const encodedData = ethers.utils.defaultAbiCoder.encode( + ["uint256[]", "uint128[]", "uint128"], + [fertIds, amounts, lastBpf] + ); + + return encodedData; + } catch (error) { + console.error(`Error reading fert data: ${error.message}`); + return "0x"; + } +} + +// Get command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const encodedData = readFertData(jsonFilePath, account); +console.log(encodedData); diff --git a/protocol/scripts/beanstalk-3/plotDataReader.js b/protocol/scripts/beanstalk-3/plotDataReader.js index 2aa090eff..1f80acecb 100644 --- a/protocol/scripts/beanstalk-3/plotDataReader.js +++ b/protocol/scripts/beanstalk-3/plotDataReader.js @@ -15,7 +15,7 @@ function readPlotData(jsonFilePath, account) { ); if (!accountData) { - console.error(`No plot data found for account: ${checksummedAccount}`); + // console.error(`No plot data found for account: ${checksummedAccount}`); return "0x"; } diff --git a/protocol/scripts/beanstalk-3/proofReaderFert.js b/protocol/scripts/beanstalk-3/proofReaderFert.js new file mode 100644 index 000000000..c50cfaeb5 --- /dev/null +++ b/protocol/scripts/beanstalk-3/proofReaderFert.js @@ -0,0 +1,40 @@ +const fs = require("fs"); +const path = require("path"); + +function getProofForAccount(jsonFilePath, account) { + try { + // Read the JSON file + const jsonData = JSON.parse(fs.readFileSync(jsonFilePath, "utf8")); + + // Create a new object with lowercased keys + const lowercaseProofs = Object.keys(jsonData.proofs).reduce((acc, key) => { + acc[key.toLowerCase()] = jsonData.proofs[key]; + return acc; + }, {}); + + // Convert the input account to lowercase + const lowercaseAccount = account.toLowerCase(); + + // Check if the lowercased account exists in the proofs object + if (lowercaseProofs.hasOwnProperty(lowercaseAccount)) { + const proof = lowercaseProofs[lowercaseAccount]; + + // Convert the proof array to a single packed string without '0x' prefixes + return proof.map((element) => element.slice(2)).join(""); + } else { + return "NO_PROOF_FOUND"; + } + } catch (error) { + console.error(`Error reading proof data: ${error.message}`); + return "ERROR_READING_PROOF"; + } +} + +// Get the command line arguments +const args = process.argv.slice(2); +const jsonFilePath = args[0]; +const account = args[1]; + +// Run the function and output the result +const proof = getProofForAccount(jsonFilePath, account); +console.log(proof); diff --git a/protocol/test/foundry/Migration/ReseedContracts.sol b/protocol/test/foundry/Migration/ReseedContracts.sol index c10534242..606bd5afa 100644 --- a/protocol/test/foundry/Migration/ReseedContracts.sol +++ b/protocol/test/foundry/Migration/ReseedContracts.sol @@ -30,8 +30,6 @@ contract L1RecieverFacetTest is Order, TestHelper { "./scripts/beanstalk-3/data/inputs/ContractAddresses.txt"; uint256 constant CONTRACT_ADDRESSES_LENGTH = 47; // should be the number of lines in the file above - // contracts for testing: - // note this is the first address numerically sorted in the merkle tree address OWNER; address RECIEVER; @@ -81,26 +79,6 @@ contract L1RecieverFacetTest is Order, TestHelper { } function test_L2MigrateAllPlots() public { - // OWNER = address(0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7); - // RECIEVER = applyL1ToL2Alias(OWNER); - // bs.setRecieverForL1Migration(OWNER, RECIEVER); - - // ( - // address owner, - // uint256[] memory index, - // uint256[] memory pods, - // bytes32[] memory proof - // ) = getMockPlot(); - - // vm.prank(RECIEVER); - // L1RecieverFacet(BEANSTALK).issuePlots(owner, index, pods, proof); - // uint256 amt = bs.plot(RECIEVER, 0, index[0]); - // assertEq(amt, pods[0]); - - // // verify user cannot migrate afterwords. - // vm.expectRevert("L2Migration: Plots have been migrated"); - // vm.prank(RECIEVER); - for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); RECIEVER = applyL1ToL2Alias(OWNER); @@ -120,104 +98,46 @@ contract L1RecieverFacetTest is Order, TestHelper { } } - function test_L2MigrateInternalBalances() public { - OWNER = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); - - ( - address owner, - address[] memory tokens, - uint256[] memory amounts, - bytes32[] memory proof - ) = getMockInternalBalance(); - - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); - uint256 amount = bs.getInternalBalance(RECIEVER, tokens[0]); - assertEq(amount, amounts[0]); - // verify user cannot migrate afterwords. - vm.expectRevert("L2Migration: Internal Balances have been migrated"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueInternalBalances(owner, tokens, amounts, proof); - } - - function test_L2MigrateFert() public { - OWNER = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); - RECIEVER = applyL1ToL2Alias(OWNER); - bs.setRecieverForL1Migration(OWNER, RECIEVER); - - ( - address owner, - uint256[] memory ids, - uint128[] memory amounts, - uint128 lastBpf, - bytes32[] memory proof - ) = getMockFertilizer(); - - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); - - assertEq(IERC1555(fertilizerAddress).balanceOf(RECIEVER, ids[0]), amounts[0]); - - // verify user cannot migrate afterwords. - vm.expectRevert("L2Migration: Fertilizer have been migrated"); - vm.prank(RECIEVER); - L1RecieverFacet(BEANSTALK).issueFertilizer(owner, ids, amounts, lastBpf, proof); - } - - function decodeDepositData( - bytes memory data - ) external pure returns (IMockFBeanstalk.TokenDepositId[] memory) { - return abi.decode(data, (IMockFBeanstalk.TokenDepositId[])); - } - - function getMockInternalBalance() - internal - returns (address, address[] memory, uint256[] memory, bytes32[] memory) - { - address account = address(0x20DB9F8c46f9cD438Bfd65e09297350a8CDB0F95); - - address[] memory tokens = new address[](1); - tokens[0] = address(0x1BEA054dddBca12889e07B3E076f511Bf1d27543); + function test_L2MigrateAllInternalBalances() public { + for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { + OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + (address[] memory _tokens, uint256[] memory _amounts) = getInternalBalanceData(OWNER); - uint256[] memory amounts = new uint256[](1); - amounts[0] = 8568; + bytes32[] memory _proof = getInternalBalancesProofForAccount(OWNER); - bytes32[] memory proof = new bytes32[](3); - proof[0] = bytes32(0xe6b126b486d1049a3c4ea6d32708dedf47b9d508d591671eddd7214476914f69); - proof[1] = bytes32(0x88659cfb1b3bec548b7ac3b0c5dd1ff653cbc33e3a12e10fd6e7a554a0402f46); - proof[2] = bytes32(0x18679f0b3b62978601eb10e75699f4a869665f734fcca4c304a4d639e2c32f26); + // if there are no indexes, continue to next contract + if (_tokens.length == 0) { + // console.log("No internal balances found for account, skipping:", OWNER); + continue; + } - return (account, tokens, amounts, proof); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueInternalBalances(OWNER, _tokens, _amounts, _proof); + } } - function getMockFertilizer() - internal - returns (address, uint256[] memory, uint128[] memory, uint128, bytes32[] memory) - { - address account = address(0x735CAB9B02Fd153174763958FFb4E0a971DD7f29); - - uint256[] memory ids = new uint256[](4); - ids[0] = 3458512; - ids[1] = 3458531; - ids[2] = 3470220; - ids[3] = 6000000; - - uint128[] memory amounts = new uint128[](4); - amounts[0] = 542767; - amounts[1] = 56044; - amounts[2] = 291896; - amounts[3] = 8046712; + function test_L2MigrateAllFert() public { + for (uint i; i < CONTRACT_ADDRESSES_LENGTH; i++) { + OWNER = vm.parseAddress(vm.readLine(CONTRACT_ADDRESSES_PATH)); + RECIEVER = applyL1ToL2Alias(OWNER); + bs.setRecieverForL1Migration(OWNER, RECIEVER); + (uint256[] memory fertIds, uint128[] memory _amounts, uint128 lastBpf) = getFertData( + OWNER + ); - uint128 lastBpf = 340802; + bytes32[] memory proof = getFertProofForAccount(OWNER); - bytes32[] memory proof = new bytes32[](3); - proof[0] = bytes32(0x044efadc8244d78f08686bb10b22ee313b8331aefafc0badffbb74c0558e3f8a); - proof[1] = bytes32(0xf6e0807e42179f8c975067c891e93ac48621024dc25b223baf4a78f0edcfa61d); - proof[2] = bytes32(0x7e77601c08f8772a9cf44337db2696d84da8290be446b231dc70c4289526a4d9); + // if there are no indexes, continue to next contract + if (fertIds.length == 0) { + // console.log("No fert for account, skipping:", OWNER); + continue; + } - return (account, ids, amounts, lastBpf, proof); + vm.prank(RECIEVER); + L1RecieverFacet(BEANSTALK).issueFertilizer(OWNER, fertIds, _amounts, lastBpf, proof); + } } /** @@ -318,29 +238,6 @@ contract L1RecieverFacetTest is Order, TestHelper { return proof; } - function bytesToHexString(bytes memory data) internal pure returns (string memory) { - bytes memory hexChars = "0123456789abcdef"; - bytes memory result = new bytes(data.length * 2); - for (uint i = 0; i < data.length; i++) { - result[i * 2] = hexChars[uint8(data[i] >> 4)]; - result[i * 2 + 1] = hexChars[uint8(data[i] & 0x0f)]; - } - return string(result); - } - - function substring( - string memory str, - uint256 startIndex, - uint256 endIndex - ) internal pure returns (string memory) { - bytes memory strBytes = bytes(str); - bytes memory result = new bytes(endIndex - startIndex); - for (uint256 i = startIndex; i < endIndex; i++) { - result[i - startIndex] = strBytes[i]; - } - return string(result); - } - //////////////////////// PLOTS //////////////////////// function getPlotData(address account) internal returns (uint256[] memory, uint256[] memory) { @@ -354,7 +251,7 @@ contract L1RecieverFacetTest is Order, TestHelper { // Check if the result is empty or just "0x" if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { - console.log("No plot data found for account:", account); + // console.log("No plot data found for account:", account); return (new uint256[](0), new uint256[](0)); } @@ -363,13 +260,6 @@ contract L1RecieverFacetTest is Order, TestHelper { (uint256[], uint256[]) ); - // Log the results - // console.log("Plot data found for account:", account); - // for (uint i = 0; i < plotIds.length; i++) { - // console.log("plotId:", plotIds[i]); - // console.log("amount:", amounts[i]); - // } - return (plotIds, amounts); } @@ -392,7 +282,6 @@ contract L1RecieverFacetTest is Order, TestHelper { // Calculate the number of proof elements (each element is 64 characters long) uint256 numElements = bytes(proofString).length / 64; - console.log("Number of proof elements:", numElements); // Create an array with the correct size bytes32[] memory proof = new bytes32[](numElements); @@ -401,41 +290,165 @@ contract L1RecieverFacetTest is Order, TestHelper { for (uint256 i = 0; i < numElements; i++) { string memory element = substring(proofString, i * 64, (i + 1) * 64); proof[i] = hexStringToBytes32(element); - console.log("Processed proof element:"); console.logBytes32(proof[i]); } return proof; } - function hexStringToBytes32(string memory s) internal pure returns (bytes32 result) { - bytes memory b = bytes(s); - require(b.length == 64, "Invalid input length"); + //////////////////////// INTERNAL BALANCES //////////////////////// - for (uint i = 0; i < 64; i++) { - uint8 digit = uint8(b[i]); - if (digit >= 48 && digit <= 57) { - digit -= 48; // 0-9 - } else if (digit >= 65 && digit <= 70) { - digit -= 55; // A-F - } else if (digit >= 97 && digit <= 102) { - digit -= 87; // a-f - } else { - revert("Invalid character in hex string"); - } - result = bytes32(uint256(result) * 16 + digit); + function getInternalBalanceData( + address account + ) internal returns (address[] memory, uint256[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/internalBalancesDataReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/inputs/InternalBalances.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Check if the result is empty or just "0x" + if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { + console.log("No internal balance data found for account:", account); + return (new address[](0), new uint256[](0)); + } + + (address[] memory tokens, uint256[] memory amounts) = abi.decode( + result, + (address[], uint256[]) + ); + + return (tokens, amounts); + } + + function getInternalBalancesProofForAccount( + address account + ) internal returns (bytes32[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/proofReaderInternalBalances.js"; + inputs[2] = "./scripts/beanstalk-3/data/merkle/internal_balance_tree.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + string memory proofString = bytesToHexString(result); + + if ( + keccak256(bytes(proofString)) == keccak256(bytes("NO_PROOF_FOUND")) || + keccak256(bytes(proofString)) == keccak256(bytes("ERROR_READING_PROOF")) + ) { + return new bytes32[](0); + } + + // Calculate the number of proof elements (each element is 64 characters long) + uint256 numElements = bytes(proofString).length / 64; + + // Create an array with the correct size + bytes32[] memory proof = new bytes32[](numElements); + + // Split the packed string into an array of bytes32 + for (uint256 i = 0; i < numElements; i++) { + string memory element = substring(proofString, i * 64, (i + 1) * 64); + proof[i] = hexStringToBytes32(element); + console.logBytes32(proof[i]); + } + + return proof; + } + + //////////////////////// FERT //////////////////////// + + function getFertData( + address account + ) internal returns (uint256[] memory, uint128[] memory, uint128) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/fertDataReader.js"; + inputs[2] = "./scripts/beanstalk-3/data/inputs/Fertilizers.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + + // Check if the result is empty or just "0x" + if (result.length == 0 || (result.length == 2 && result[0] == "0" && result[1] == "x")) { + console.log("No fert data found for account:", account); + return (new uint256[](0), new uint128[](0), 0); + } + + (uint256[] memory fertIds, uint128[] memory amounts, uint128 lastBpf) = abi.decode( + result, + (uint256[], uint128[], uint128) + ); + + return (fertIds, amounts, lastBpf); + } + + function getFertProofForAccount(address account) internal returns (bytes32[] memory) { + string[] memory inputs = new string[](4); + inputs[0] = "node"; + inputs[1] = "./scripts/beanstalk-3/proofReaderFert.js"; + inputs[2] = "./scripts/beanstalk-3/data/merkle/fert_tree.json"; + inputs[3] = Strings.toHexString(uint160(account), 20); + + bytes memory result = vm.ffi(inputs); + string memory proofString = bytesToHexString(result); + + if ( + keccak256(bytes(proofString)) == keccak256(bytes("NO_PROOF_FOUND")) || + keccak256(bytes(proofString)) == keccak256(bytes("ERROR_READING_PROOF")) + ) { + return new bytes32[](0); + } + + // Calculate the number of proof elements (each element is 64 characters long) + uint256 numElements = bytes(proofString).length / 64; + + // Create an array with the correct size + bytes32[] memory proof = new bytes32[](numElements); + + // Split the packed string into an array of bytes32 + for (uint256 i = 0; i < numElements; i++) { + string memory element = substring(proofString, i * 64, (i + 1) * 64); + proof[i] = hexStringToBytes32(element); + console.logBytes32(proof[i]); + } + + return proof; + } + + //////////////////////// HELPER FUNCTIONS //////////////////////// + + function bytesToHexString(bytes memory data) internal pure returns (string memory) { + bytes memory hexChars = "0123456789abcdef"; + bytes memory result = new bytes(data.length * 2); + for (uint i = 0; i < data.length; i++) { + result[i * 2] = hexChars[uint8(data[i] >> 4)]; + result[i * 2 + 1] = hexChars[uint8(data[i] & 0x0f)]; + } + return string(result); + } + + function substring( + string memory str, + uint256 startIndex, + uint256 endIndex + ) internal pure returns (string memory) { + bytes memory strBytes = bytes(str); + bytes memory result = new bytes(endIndex - startIndex); + for (uint256 i = startIndex; i < endIndex; i++) { + result[i - startIndex] = strBytes[i]; } + return string(result); } - function hexStringToBytes16(string memory s) public pure returns (bytes16 result) { + function hexStringToBytes32(string memory s) internal pure returns (bytes32 result) { bytes memory b = bytes(s); - require(b.length == 32, "Invalid input length"); + require(b.length == 64, "Invalid input length"); - for (uint i = 0; i < 32; i++) { + for (uint i = 0; i < 64; i++) { uint8 digit = uint8(b[i]); - console.log("Processing character:", string(abi.encodePacked(b[i]))); - console.log("ASCII value:", digit); - if (digit >= 48 && digit <= 57) { digit -= 48; // 0-9 } else if (digit >= 65 && digit <= 70) { @@ -443,12 +456,9 @@ contract L1RecieverFacetTest is Order, TestHelper { } else if (digit >= 97 && digit <= 102) { digit -= 87; // a-f } else { - console.log("Invalid character found at position:", i); - console.log("Invalid character:", string(abi.encodePacked(b[i]))); - console.log("ASCII value of invalid character:", digit); revert("Invalid character in hex string"); } - result = bytes16(uint128(result) * 16 + digit); + result = bytes32(uint256(result) * 16 + digit); } } } From 406057237e108be93f3366141f376676c5cb091a Mon Sep 17 00:00:00 2001 From: Brean0 Date: Thu, 19 Sep 2024 15:03:30 -0500 Subject: [PATCH 11/15] update reseedAddLiqudityAndTransfer --- .../reseed/reseedAddLiquidityAndTransfer.js | 66 ++++++++++++------- 1 file changed, 43 insertions(+), 23 deletions(-) diff --git a/protocol/reseed/reseedAddLiquidityAndTransfer.js b/protocol/reseed/reseedAddLiquidityAndTransfer.js index aa8b292d0..8d4cf644a 100644 --- a/protocol/reseed/reseedAddLiquidityAndTransfer.js +++ b/protocol/reseed/reseedAddLiquidityAndTransfer.js @@ -29,49 +29,69 @@ const NonBeanToken = [ L2_USDT // USDT ]; +async function setBalance( + contract, // token contract address + account, // account address + amount, // amount to set + slot // storage slot to set +) { + const index = ethers.utils.solidityKeccak256(["uint256", "uint256"], [account, slot]); + const balance = ethers.utils.hexlify( + ethers.utils.zeroPad(ethers.BigNumber.from(amount).toHexString(), 32) + ); + await hre.network.provider.send("hardhat_setStorageAt", [contract, index, balance]); +} + async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, verbose = true) { const INIT_WELL_BALANCES = "./reseed/data/r2/L2_well_balances.json"; [balancesInBeanEthWell, balancesInBeanWstEthWell, balancesInBeanStableWell] = JSON.parse( await fs.readFileSync(INIT_WELL_BALANCES) ); + const slots = [ + 51, // WETH + 1, // wstETH + 51, // WEETH + 51, // WBTC + 9, // USDC + 51 // USDT + ]; + const nonBeanAmounts = [ - to18("20"), // BEAN/WETH + to18("20.6"), // BEAN/WETH to18("2556"), // BEAN/WstETH - to18("16"), // BEAN/WEEETH - toX("8", 8), // BEAN/WBTC (8 decimals) - to6("190000"), // BEAN/USDC - to6("190000") // BEAN/USDT + to6("0"), // to18("16"), // BEAN/WEEETH + toX("0", 8), // BEAN/WBTC (8 decimals) + to6("206686.240460"), // to6("190000"), // BEAN/USDC + to6("0") // to6("190000") // BEAN/USDT ]; const beanAmounts = [ - to6("108357"), // BEAN/WETH - to6("14642617"), // BEAN/WstETH - to6("100000"), // BEAN/WEEETH - to6("1000000"), // BEAN/WBTC - to6("1000000"), // BEAN/USDC - to6("1000000") // BEAN/USDT + to6("107380.655868"), // BEAN/WETH + to6("14544578.478380"), // BEAN/WstETH + to6("0"), // to6("100000"), // BEAN/WEEETH + to6("0"), // to6("1000000"), // BEAN/WBTC + to6("83855.245277"), // BEAN/USDC + to6("0") // to6("1000000") // BEAN/USDT ]; console.log("-----------------------------------"); console.log("add liquidity to wells and transfers to l2 beanstalk.\n"); + const beanAddress = "0xBEA0005B8599265D41256905A9B3073D397812E4"; + await impersonateToken(beanAddress, 6); + const bean = await ethers.getContractAt("MockToken", beanAddress); - await impersonateToken("0xBEA0005B8599265D41256905A9B3073D397812E4", 6); - const bean = await ethers.getContractAt( - "MockToken", - "0xBEA0005B8599265D41256905A9B3073D397812E4" - ); // add liquidity and transfer to L2 Beanstalk: for (let i = 0; i < WellAddresses.length; i++) { const well = await ethers.getContractAt("IWell", WellAddresses[i], account); - const wellERC20 = await ethers.getContractAt("IERC20", WellAddresses[i], account); - const token = await ethers.getContractAt("MockToken", NonBeanToken[i], account); - const decimals = await token.decimals(); - await impersonateToken(NonBeanToken[i], decimals); + const token = await ethers.getContractAt("IERC20", NonBeanToken[i], account); + if (mock) { - // mint tokens to add liquidity: - await token.mint(account.address, nonBeanAmounts[i]); - await bean.mint(account.address, beanAmounts[i] + to6("1000000")); + console.log(`Minting tokens for ${WellAddresses[i]} and ${NonBeanToken[i]}`); + await setBalance(NonBeanToken[i], account.address, nonBeanAmounts[i], slots[i]); + await setBalance(beanAddress, account.address, beanAmounts[i], 0); // storage slot 0 for MockToken } + + console.log(`Approving tokens for ${WellAddresses[i]} and ${NonBeanToken[i]}`); await token.connect(account).approve(well.address, MAX_UINT256); await bean.connect(account).approve(well.address, MAX_UINT256); // add liquidity to well, to L2 Beanstalk: From ddae95b0e68bde3ed4e579056404aeac1a2deb7c Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 15:10:00 -0600 Subject: [PATCH 12/15] Allow only the 435 highest value plots per contract --- .../beanstalk/migration/L1RecieverFacet.sol | 2 +- .../beanstalk-3/beanstalk-3-Contracts.js | 36 +- .../beanstalk-3/data/inputs/Plots.json | 22134 +--------------- .../beanstalk-3/data/merkle/plot_tree.json | 98 +- .../test/foundry/Migration/L1Reciever.t.sol | 6 +- .../foundry/Migration/ReseedContracts.sol | 6 + 6 files changed, 1306 insertions(+), 20976 deletions(-) diff --git a/protocol/contracts/beanstalk/migration/L1RecieverFacet.sol b/protocol/contracts/beanstalk/migration/L1RecieverFacet.sol index 3acc6bc33..048d3be95 100644 --- a/protocol/contracts/beanstalk/migration/L1RecieverFacet.sol +++ b/protocol/contracts/beanstalk/migration/L1RecieverFacet.sol @@ -42,7 +42,7 @@ contract L1RecieverFacet is ReentrancyGuard { bytes32 internal constant DEPOSIT_MERKLE_ROOT = 0x53d64bba5389504aeff2d680bd0d5a4a27f7c535578915ccfbc64f4aef1656ee; bytes32 internal constant PLOT_MERKLE_ROOT = - 0x26da8c597f94901bab9ecbe1f491f3d953d358c7221680a27dc76e19318de3d1; + 0x828c73c8e073801828c564f95bafd55c6a0485f244d4581e638c90ca678d3a28; bytes32 internal constant INTERNAL_BALANCE_MERKLE_ROOT = 0x0ed5cf8908ddecd7d9285e5809315d007bfd5bd6d71f4c7db1131569180d23e2; bytes32 internal constant FERTILIZER_MERKLE_ROOT = diff --git a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js index 060a83ab7..bcb9ba9f5 100644 --- a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js +++ b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js @@ -38,7 +38,11 @@ function updateInputJsonData(verbose = false) { // update Plots.json const allPlotsData = JSON.parse(fs.readFileSync(storageAccountsPath)); - const plots = restructurePlots(allPlotsData, contractAddresses); + var plots = restructurePlots(allPlotsData, contractAddresses); + + // Process the plots to keep only the top 435 per address + plots = processPlots(plots); + fs.writeFileSync(PLOTS, JSON.stringify(plots, null, 2)); // update InternalBalances.json @@ -84,6 +88,36 @@ function restructureDeposits(inputData, addressesToInclude) { }); } +function processPlots(plots, maxPlotsPerAddress = 435) { + return plots.map(([address, indices, sizes]) => { + // If there are 435 or fewer plots, return the original data + if (sizes.length <= maxPlotsPerAddress) { + return [address, indices, sizes]; + } + + // Create an array of objects with index and size + let plotData = indices.map((index, i) => ({ + index: index, + size: BigInt(sizes[i]) // Convert to BigInt for accurate sorting + })); + + // Sort the plots by size in descending order + plotData.sort((a, b) => (b.size > a.size ? 1 : -1)); + + // Keep only the top 435 plots + plotData = plotData.slice(0, maxPlotsPerAddress); + + // Sort back by index to maintain original order + plotData.sort((a, b) => a.index - b.index); + + // Extract the indices and sizes + const newIndices = plotData.map((plot) => plot.index); + const newSizes = plotData.map((plot) => plot.size.toString()); // Convert back to string + + return [address, newIndices, newSizes]; + }); +} + function restructurePlots(inputData, addressesToInclude) { return Object.entries(inputData) .filter( diff --git a/protocol/scripts/beanstalk-3/data/inputs/Plots.json b/protocol/scripts/beanstalk-3/data/inputs/Plots.json index 8118dfc6d..433073699 100644 --- a/protocol/scripts/beanstalk-3/data/inputs/Plots.json +++ b/protocol/scripts/beanstalk-3/data/inputs/Plots.json @@ -76,21464 +76,1754 @@ "0x9662C8E686fe84F468a139b10769D65665c344F9", [ "825005612570458", + "825006309996070", "825006792959320", - "825033713179365", - "825032739068084", "825027429792389", - "825006309996070", + "825032739068084", + "825033713179365", "825043729473846", + "825067479800367", + "825068463817853", "825073423059996", "825083597785599", + "825104981788091", "825105091513710", "825105215395727", "825105297465088", - "825068463817853", - "825067479800367", - "825104981788091", "825109941497200", - "825188263322267", "825112145678391", - "825185831227889", "825185248381016", + "825185831227889", + "825188263322267", + "825583268409137", "825586077512037", "826383983904818", - "825583268409137", - "828640295617136", - "828640295615928", - "828640295618387", - "828640295612559", - "828640295637550", - "828640295610525", - "828640295605430", - "828640295604727", - "828640295627203", - "828640295611521", - "828640295627412", "828639443029287", - "828640295661507", - "828640295609571", - "828640295625280", - "828640295643879", - "828631979817364", - "828639443032132", + "828639443029410", + "828639443029575", + "828639443029781", + "828639443030069", "828639443030399", - "828640295623816", + "828639443030770", + "828639443031183", + "828639443031637", + "828639443032132", "828639443032669", + "828640295603445", "828640295604065", - "828640295627036", - "828640295636538", - "828639443029205", - "828640295614763", + "828640295604727", + "828640295605430", "828640295606175", - "828639443031637", - "828639443030069", + "828640295606961", + "828640295607789", + "828640295608659", + "828640295609571", + "828640295610525", + "828640295611521", + "828640295612559", "828640295613640", - "828640295639827", - "828640295626828", - "828640295628669", + "828640295614763", + "828640295615928", + "828640295617136", + "828640295618387", "828640295619680", - "828640295608659", - "828640295648694", - "828639443029575", - "828640295654527", - "828640295656726", - "828640295627663", - "828640295632494", - "828640295638646", + "828640295621016", + "828640295622395", + "828640295623816", + "828640295625280", + "828640295626828", "828640295626911", - "828639443030770", + "828640295627036", + "828640295627203", + "828640295627412", + "828640295627663", + "828640295627956", "828640295628291", - "828640295630601", - "828640295659053", - "828640295647004", - "828640295645399", - "828639443029410", - "828640295622395", - "828640295633968", + "828640295628669", "828640295629089", - "828640295607789", - "828640295641093", - "828631979817323", - "828640295635611", - "828640295650511", - "828640295642444", - "828640295631190", - "828639443029781", "828640295629551", + "828640295630055", + "828640295630601", + "828640295631190", "828640295631821", + "828640295632494", "828640295633210", - "828640295627956", - "828640295603445", - "828640295621016", - "828640295630055", + "828640295633968", "828640295634768", + "828640295635611", + "828640295636538", + "828640295637550", + "828640295638646", + "828640295639827", + "828640295641093", + "828640295642444", + "828640295643879", + "828640295645399", + "828640295647004", + "828640295648694", + "828640295650511", "828640295652455", - "828640295626787", - "828639443031183", - "828640295606961", - "828707206227142", + "828640295654527", + "828640295656726", + "828640295659053", + "828640295661507", "828640295664089", - "828712127658925", - "828707206497591", - "828640295761721", - "828712127859929", - "828640295769888", - "828640295715142", - "828677403376611", - "828677402660397", - "828640295854354", - "828677402828170", - "828677402906703", - "828640295733025", - "828712127285939", - "828712128772525", - "828707206402878", - "828712127112996", + "828640295666841", + "828640295669763", + "828640295672855", + "828640295676117", + "828640295679549", + "828640295683194", "828640295687052", - "828640295699947", - "828640295778483", + "828640295691123", "828640295695407", - "828640295683194", + "828640295699947", + "828640295704742", + "828640295709793", + "828640295715142", + "828640295720790", "828640295726737", - "828707802117605", - "828640295882555", - "828640295948561", - "828640295868090", + "828640295733025", "828640295739655", - "828677402724392", - "828640296157285", - "828677403040374", - "828640295828896", + "828640295746626", "828640295753981", + "828640295761721", + "828640295769888", + "828640295778483", + "828640295787548", + "828640295797083", "828640295807131", - "828640295704742", + "828640295817735", + "828640295828896", + "828640295841304", + "828640295854354", + "828640295868090", + "828640295882555", + "828640295897791", + "828640295913842", + "828640295930751", + "828640295948561", + "828640295967315", + "828640295987056", "828640296007827", - "828712128293409", + "828640296029672", + "828640296052676", + "828640296076883", + "828640296102337", + "828640296129123", + "828640296157285", + "828677402660397", + "828677402691569", + "828677402724392", + "828677402757222", "828677402791791", + "828677402828170", "828677402866445", - "828640295746626", - "828640295679549", - "828640295797083", - "828712126948489", - "828712128071249", - "828640295709793", - "828677403141384", - "828677402757222", + "828677402906703", "828677402949031", - "828707802643352", - "828640296129123", - "828677403253101", - "828678664789605", - "828677402691569", - "828707802367274", - "828640295720790", - "828640295967315", + "828677402993559", + "828677403040374", "828677403089606", + "828677403141384", + "828677403195839", + "828677403253101", "828677403313301", - "828707206701839", - "828640295841304", - "828640295666841", - "828640296102337", - "828640296076883", - "828712128526978", + "828677403376611", + "828678664789605", + "828678664859614", + "828707206068244", + "828707206145683", + "828707206227142", "828707206312801", - "828640295930751", - "828712127467755", - "828677403195839", + "828707206402878", + "828707206497591", + "828707206597158", + "828707206701839", "828707206811897", - "828712129587380", + "828707802117605", "828707802239286", - "828712130202733", - "828640295987056", - "828640295691123", + "828707802367274", "828707802501861", - "828678664859614", - "828640295669763", + "828707802643352", "828712126792097", - "828640295676117", - "828707206068244", - "828707206145683", - "828640295672855", - "828640295913842", - "828712129030663", - "828712130534288", - "828712129887360", - "828640295817735", - "828640296029672", - "828707206597158", - "828640295897791", - "828640295787548", + "828712126948489", + "828712127112996", + "828712127285939", + "828712127467755", + "828712127658925", + "828712127859929", + "828712128071249", + "828712128293409", + "828712128526978", + "828712128772525", + "828712129030663", "828712129302048", - "828640296052676", - "828677402993559", + "828712129587380", + "828712129887360", + "828712130202733", + "828712130534288", + "828712130882857", + "828712131249316", + "828712131634587", + "828712132039634", + "828712132465509", + "828712132465596", + "828712132465726", + "828712132465900", + "828712132466117", + "828755702466378", + "828755702466683", + "828755702467031", + "828755702467423", + "828755702467859", "828755702468339", "828755702468862", - "828811561416372", + "828755702469429", "828755702470040", + "828755702470695", + "828755702471394", + "828755702472136", + "828755702472922", + "828755702473752", + "828755702474626", + "828771230175588", + "828771230176638", + "828771230177776", + "828771230179002", + "828771230180316", + "828771230181717", "828771230183207", - "828811561477877", - "828834434231067", + "828771230184787", + "828771230186456", + "828771230188213", "828771230190102", - "828811561407863", + "828771230192125", + "828771230194281", + "828771230196571", + "828771230198993", + "828771230201548", "828771230204236", - "828771230176638", - "828811561377966", + "828771230207101", + "828771230210143", + "828771230213362", "828771230216758", - "828811561490136", - "828755702467423", + "828771230220331", + "828771230224126", + "828771792446737", + "828771792450975", + "828771792455437", "828771792460165", - "828755702467859", + "828771792465159", + "828811561353763", + "828811561359334", "828811561365219", - "828771230213362", - "828834434217460", - "828755702471394", - "828771230194281", - "828771230220331", - "828834434260471", - "828712132466117", - "828771230181717", - "828811561425326", - "828755702469429", - "828755702466378", - "828712132465509", - "828712131634587", - "828771230186456", - "828771230207101", - "828771230201548", - "828771230184787", - "828771230188213", - "828953329555879", - "828755702473752", "828811561371415", + "828811561377966", + "828811561384873", + "828811561392136", "828811561399799", - "828811561444711", + "828811561407863", + "828811561416372", + "828811561425326", "828811561434770", - "828771230180316", - "828755702466683", - "828771230198993", - "828755702467031", - "828755702470695", - "828771230179002", - "828834434276357", - "828712131249316", - "828771792465159", - "828771792455437", - "828712132039634", - "828712132465466", - "828712130882857", - "828834434329290", - "828771230177776", - "828771230175588", - "828755702472136", - "828755702472922", - "828953329586783", - "828712132465900", - "828771230192125", - "828941762330134", - "828936762042901", + "828811561444711", "828811561455187", - "828771230210143", - "828941762351785", "828811561466242", - "828811561392136", - "828755702474626", - "828771792446737", + "828811561477877", + "828811561490136", + "828834434217460", + "828834434231067", + "828834434245389", + "828834434260471", + "828834434276357", "828834434293092", - "828953329526500", "828834434310721", + "828834434329290", + "828936762042901", + "828941762330134", + "828941762351785", "828941762374565", - "828811561353763", + "828941762398554", "828953329498556", - "828834434245389", - "828712132465596", - "828771230196571", - "828953329653526", - "828712132465726", - "828771230224126", + "828953329526500", + "828953329555879", + "828953329586783", "828953329619302", - "828811561359334", - "828941762398554", - "828811561384873", - "828771792450975", - "828977271741851", - "828977271874904", - "828977270436635", - "828977270721399", - "828977273426121", + "828953329653526", + "828954488135145", "828954495122360", - "828977272014816", - "828977273645683", - "828981794214491", - "828977270801985", - "828977270502551", - "828981794213449", - "828977273018645", - "828977270373985", "828954495164260", + "828954495208314", "828954495254657", - "828977270644774", - "828992350761903", - "828954495354617", - "828977270571885", "828954495303380", - "828981794212996", - "828981794212588", - "828977275220899", - "828992478313995", - "828977277768574", - "828981794210961", - "828981794213947", - "828977272316532", - "828977270975810", - "828977275860212", - "828981794211096", + "828954495354617", + "828954495408504", "828954495465176", - "828981794211638", - "828977273217275", + "828977270373985", + "828977270436635", + "828977270502551", + "828977270571885", + "828977270644774", + "828977270721399", + "828977270801985", "828977270886713", - "828977276566804", - "828981794215080", - "828977272479107", - "828954495408504", - "828977277347776", - "828977275532561", - "828992445497261", - "828954488135145", - "828992434559425", - "828977272650037", - "828992235579828", - "828977274924453", - "828992313904181", + "828977270975810", + "828977271069501", + "828977271168013", "828977271271572", - "828992271971140", - "828981794216396", "828977271380450", - "828977276947520", - "828977274119181", - "828981794211231", - "828977271069501", "828977271494919", "828977271615295", - "828981794215715", - "828977274374299", - "828977271168013", - "828977273876506", + "828977271741851", + "828977271874904", + "828977272014816", + "828977272161904", + "828977272316532", + "828977272479107", + "828977272650037", "828977272829732", - "828954495208314", + "828977273018645", + "828977273217275", + "828977273426121", + "828977273645683", + "828977273876506", + "828977274119181", + "828977274374299", "828977274642496", - "828981794211006", + "828977274924453", + "828977275220899", + "828977275532561", + "828977275860212", "828977276204671", - "828992290455618", - "828992295623555", - "828977272161904", + "828977276566804", + "828977276947520", + "828977277347776", + "828977277768574", + "828981794211006", + "828981794211096", + "828981794211231", "828981794211412", + "828981794211638", "828981794211909", - "828992385370613", - "828992369239389", - "828992332318857", "828981794212226", - "829244139697666", - "829248540990688", - "829246809676356", - "829251371101752", + "828981794212588", + "828981794212996", + "828981794213449", + "828981794213947", + "828981794214491", + "828981794215080", + "828981794215715", + "828981794216396", + "828992235579828", + "828992271971140", + "828992290455618", + "828992295623555", + "828992313904181", + "828992332318857", + "828992350761903", + "828992369239389", + "828992385370613", + "828992434559425", + "828992445497261", + "828992478313995", + "829243491948066", "829243790179188", + "829243808852145", + "829244139697666", "829244888132383", - "829249681203502", "829245184809189", - "829250512238517", - "829254036353999", - "829243808852145", - "829244888132260", - "829254036354039", - "829246809676274", + "829245481537954", + "829246374208626", "829246672552169", - "829243491947943", - "829248843751875", - "829244888132301", - "829243491948066", - "829424736097261", + "829246809676356", "829247079803064", - "829244471022251", - "829253745812308", - "829246374208626", - "829245481537954", + "829248540990688", + "829248843751875", + "829249681203502", + "829250512238517", + "829251371101752", + "829252258224389", "829252856780256", + "829253745812308", "829254036354119", - "829252258224389", + "829424736097261", "829425021913782", + "829425307295032", + "829427108136477", + "829427176449853", + "829427176450054", + "829427449471931", + "829427767002725", + "829428089196510", + "829428420425852", "829429414412532", - "829440847235053", - "829437137735025", + "829430039177649", + "829430351385367", + "829431559419721", + "829432757562476", "829433009669316", + "829433515894879", + "829437137735025", + "829437137735183", + "829437137735616", + "829437137735892", + "829437137736207", "829437638648482", + "829437638649541", "829438038191651", - "829430351385367", + "829439169458150", + "829439517411998", + "829439718494344", "829440344695716", "829440344695987", - "829442032311177", - "829442383369757", - "829427767002725", - "829437137736207", - "829439718494344", - "829430039177649", - "829431559419721", - "829441044306114", - "829428089196510", - "829427108136477", - "829425307295032", - "829425858372662", - "829427176449853", - "829437638649541", - "829437137735892", - "829441044306345", - "829439517411998", - "829439169458150", - "829437137735616", - "829441532591718", + "829440344696181", "829440344696413", - "829432757562476", - "829428420425852", - "829440344695601", - "829440735410650", "829440735410379", - "829427176449493", - "829427449471931", - "829442383369526", - "829437137735183", - "829427176450054", - "829440344696181", - "829433515894879", - "829442383397134", - "829442383375452", - "829442383370916", + "829440735410650", + "829440847235053", + "829441044306345", + "829441532591718", + "829442032311177", + "829442383369757", "829442383370607", - "829442383373589", + "829442383370916", "829442383371264", - "829442383393196", - "829444810599819", - "829442383381554", - "829442383378521", - "829442383388170", - "829442383372077", "829442383371651", - "829445451034972", - "829445149656189", - "829442383389728", - "829443264969393", + "829442383372077", "829442383372542", - "829442383399279", + "829442383373589", + "829442383374792", + "829442383375452", "829442383376889", + "829442383378521", + "829442383380465", + "829442383381554", "829442383382721", - "829442383374792", "829442383386690", + "829442383388170", + "829442383389728", + "829442383393196", "829442383395106", - "829442383380465" + "829442383397134", + "829442383399279", + "829443264969393", + "829444810599819", + "829445149656189", + "829445451034972" ], [ "46201857", + "53680946", "1494533087", - "52372148", - "684952219", "974988542", - "53680946", + "684952219", + "52372148", "23750326521", + "79147734", + "4893969099", "9019889238", "21118416942", + "54845693", "52203689", "51007458", "1300355823", - "4893969099", - "79147734", - "54845693", "2130472638", - "590245000", "69051736", - "1434013875", "516217762", + "1434013875", + "590245000", + "2799546066", "797906392781", "857156766102", - "2799546066", - "1251", - "1208", - "1293", - "1081", - "1096", - "996", - "745", - "703", - "209", - "1038", - "251", "123", - "2582", - "954", - "1507", - "1520", - "41", - "537", + "165", + "206", + "288", + "330", "371", - "1464", + "413", + "454", + "495", + "537", "578", + "620", "662", - "167", - "1012", - "82", - "1165", + "703", + "745", "786", - "495", - "330", + "828", + "870", + "912", + "954", + "996", + "1038", + "1081", "1123", - "1266", - "83", - "420", + "1165", + "1208", + "1251", + "1293", "1336", - "912", - "1817", - "206", - "2199", - "2327", - "293", - "716", - "1181", + "1379", + "1421", + "1464", + "1507", + "83", "125", - "413", + "167", + "209", + "251", + "293", + "335", "378", - "589", - "2454", - "1690", - "1605", - "165", - "1421", - "800", + "420", "462", - "870", - "1351", - "41", - "927", - "1944", - "1435", - "631", - "288", "504", + "546", + "589", + "631", "673", + "716", "758", - "335", - "620", - "1379", - "546", + "800", "843", - "2072", - "41", - "454", - "828", - "85659", - "2752", - "201004", - "99567", - "8167", - "211320", - "8595", - "5648", - "66594", - "31172", - "13736", - "38275", - "42328", - "6630", - "181816", - "258138", - "94713", - "172943", + "927", + "1012", + "1096", + "1181", + "1266", + "1351", + "1435", + "1520", + "1605", + "1690", + "1817", + "1944", + "2072", + "2199", + "2327", + "2454", + "2582", + "2752", + "2922", + "3092", + "3262", + "3432", + "3645", + "3858", "4071", - "4795", - "9065", + "4284", "4540", - "3858", + "4795", + "5051", + "5349", + "5648", + "5947", "6288", - "121681", - "15236", - "18754", - "14465", + "6630", "6971", - "32830", - "29624", - "49232", - "12408", + "7355", "7740", + "8167", + "8595", + "9065", + "9535", + "10048", "10604", - "5051", + "11161", + "12408", + "13050", + "13736", + "14465", + "15236", + "16051", + "16909", + "17810", + "18754", + "19741", + "20771", "21845", - "233569", + "23004", + "24207", + "25454", + "26786", + "28162", + "29624", + "31172", + "32823", + "32830", + "34569", "36379", + "38275", "40258", - "7355", - "3645", - "10048", - "164507", - "222160", - "5349", - "54455", - "34569", + "42328", "44528", - "148745", - "28162", - "60200", - "70009", - "32823", - "134587", - "5947", - "19741", + "46815", + "49232", "51778", + "54455", + "57262", + "60200", "63310", - "110058", - "13050", - "2922", - "26786", - "25454", - "245547", + "66594", + "70009", + "73632", + "77439", + "81459", + "85659", "90077", - "17810", - "191170", - "57262", + "94713", + "99567", + "104681", + "110058", "115738", - "299980", + "121681", "127988", - "331555", - "20771", - "4284", + "134587", "141491", - "73632", - "3092", + "148745", "156392", - "3432", - "77439", - "81459", - "3262", - "16909", + "164507", + "172943", + "181816", + "191170", + "201004", + "211320", + "222160", + "233569", + "245547", + "258138", "271385", - "348569", - "315373", - "11161", - "23004", - "104681", - "16051", - "9535", "285332", - "24207", - "46815", + "299980", + "315373", + "331555", + "348569", + "366459", + "385271", + "405047", + "425832", + "87", + "130", + "174", + "217", + "261", + "305", + "348", + "392", + "436", + "480", "523", "567", - "8954", + "611", "655", + "699", + "742", + "786", + "830", + "874", + "962", + "1050", + "1138", + "1226", + "1314", + "1401", + "1490", "1580", - "12259", - "14322", + "1669", + "1757", + "1889", "2023", - "8509", + "2156", + "2290", + "2422", + "2555", + "2688", "2865", - "1138", - "6907", + "3042", + "3219", + "3396", "3573", - "12929", - "436", + "3795", + "4016", + "4238", + "4462", + "4728", "4994", - "480", + "5260", + "5571", + "5885", "6196", - "3396", - "13607", - "742", - "2290", - "3795", - "15886", - "261", - "1490", - "9444", - "611", - "305", - "87", - "405047", - "1757", - "3042", - "2688", - "1669", - "1889", - "30904", - "874", "6551", + "6907", + "7263", + "7663", "8064", - "10476", + "8509", + "8954", + "9444", "9941", - "1401", - "348", - "2555", - "392", - "699", - "1314", - "16735", - "385271", - "5260", - "4728", - "425832", - "43", - "366459", - "19553", - "1226", - "1050", - "786", - "830", - "32519", - "217", - "2156", - "21651", - "20582", + "10476", "11055", - "3219", - "22780", "11635", - "7663", - "962", - "4238", + "12259", + "12929", + "13607", + "14322", + "15082", + "15886", + "16735", "17629", - "29379", "18569", + "19553", + "20582", + "21651", + "22780", "23989", - "5571", + "25243", "27944", - "15082", - "130", - "2422", - "36020", - "174", - "4016", + "29379", + "30904", + "32519", "34224", - "5885", - "25243", - "7263", - "4462", - "133053", - "139912", - "65916", - "80586", - "219562", + "36020", + "37871", "41900", - "147088", - "230823", - "589", - "84728", - "69334", - "498", - "198630", - "62650", "44054", + "46343", "48723", - "76625", - "18477486", - "53887", - "72889", "51237", - "453", - "408", - "311662", - "15950506", - "442387", - "45", - "544", - "162575", - "93691", - "344459", - "135", + "53887", + "56672", "59593", - "271", - "208846", + "62650", + "65916", + "69334", + "72889", + "76625", + "80586", + "84728", "89097", - "380716", - "635", - "170930", - "56672", - "420798", - "327651", - "16385295", - "37871", - "10937836", - "179695", - "91", - "296446", - "18414676", + "93691", + "98512", + "103559", "108878", - "18484478", - "727", "114469", - "400256", - "255118", - "181", - "98512", "120376", "126556", - "681", - "268197", - "103559", - "242675", + "133053", + "139912", + "147088", + "154628", + "162575", + "170930", + "179695", "188913", - "46343", + "198630", + "208846", + "219562", + "230823", + "242675", + "255118", + "268197", "281957", - "90", + "296446", + "311662", + "327651", + "344459", "362133", - "5167937", - "18280626", - "154628", + "380716", + "400256", + "420798", + "442387", + "90", + "135", + "181", "226", + "271", "317", - "16087207", - "16131224", - "18443046", "362", - "331324585", - "302761187", - "123", - "296600700", + "408", + "453", + "498", + "544", + "589", + "635", + "681", + "727", + "91", + "18484478", + "5167937", + "18280626", + "18414676", + "18443046", + "18477486", + "16131224", + "16087207", + "10937836", + "16385295", + "15950506", + "298231122", "18672957", + "330845521", + "331324585", "296676806", - "279694893", "296728765", - "276767301", - "40", - "330845521", - "41", - "80", - "82", + "296762499", + "298343543", "137124064", - "41", - "280418672", - "82", - "298231122", - "285816521", + "123", "256642528", - "41", - "290541691", - "298343543", - "296762499", + "302761187", + "280418672", + "279694893", + "276767301", + "296600700", + "302369890", "296342950", + "290541691", "291176686", - "302369890", + "285816521", "285381250", + "284997197", + "68312976", + "201", + "273021877", + "317530794", + "322193785", + "331229342", + "331260558", "321182204", - "197071061", - "158", + "312207718", + "288907800", + "308531054", + "252106840", "244186585", + "114725072", + "158", + "197", + "276", + "315", + "354", "510", + "588", "364833293", - "288907800", + "347953848", + "201082346", + "201245887", "116", "194", - "210719422", - "154", - "322193785", - "354", - "201245887", - "312207718", - "308531054", - "38", - "331229342", - "68312976", - "284997197", - "80", - "201", - "588", - "315", - "155", - "201082346", - "347953848", - "276", - "499719459", + "232", "271", - "252106840", - "331260558", - "38", - "193", "116", - "80", - "317530794", - "38", - "197", - "273021877", - "232", - "114725072", - "2145", - "699", - "348", + "193", + "197071061", + "155", + "499719459", + "210719422", + "154", "309", - "582", + "348", "387", - "1910", - "339056370", - "1167", - "933", - "1558", - "465", "426", - "35791954", - "301378783", - "1675", - "88909462", + "465", "504", - "2263", + "582", + "660", + "699", "777", + "933", + "1089", + "1167", "1245", - "660", "1480", + "1558", + "1675", + "1910", "2028", - "1089" + "2145", + "2263", + "88909462", + "339056370", + "301378783", + "35791954" ] ], [ "0xB9F14eFae1D14b6d06816B6E3a5F6e79c87232fA", [ "828981810852752", - "828992253603674", - "828992217901803", - "828994872314885", - "828992401457820", - "828992200627928", "828981831566205", - "828994738903282", - "828994806213643", + "828992235579919", + "828992253603674", "828992494264501", - "828994854338702", - "828992417972044", + "828994738903282", "828994768298030", "828994786359723", - "828992461882556", + "828994806213643", + "828994872314885", "828994890776476", - "828992235579919", - "829006199988905", "828994909361323", - "829006090261220", + "828994927971499", + "828994956360339", "828994975717653", - "829006116108926", - "829005853897171", - "829005991887398", - "829006060223980", - "829005936122071", - "829005936122204", - "829005996381487", - "829005853899597", - "828994996339094", - "829006199990489", - "829006199990082", - "829006116106546", "828995014076578", - "829006000876608", - "828995032057730", - "829006116108431", - "829006000875800", - "829006116106859", - "829006000876293", - "829006199991670", - "829005853896677", + "828995032059076", + "829005853899597", "829005882363649", - "829006116109151", - "828994956360339", - "829005853898923", - "829006199980896", - "829006199992534", - "829006116106413", - "828995032057506", - "829006116111358", - "829006199979090", - "829006000876968", - "828994927971499", - "829006199987908", - "829006116108881", - "829005963670356", - "829006199980444", - "829006199990716", - "829006116109331", - "829006116110141", + "829005909226879", "829005936122338", - "828995032057193", - "829006199991306", - "829006199987002", - "829006000876024", - "829006199983156", - "829006116106457", - "829006199989992", - "828995032059076", - "829006116110907", - "829006199986142", - "829006199990172", - "829006116109556", - "829006116109016", - "829006116106680", - "829006199990037", - "829006199990308", - "829006116107666", - "828995032057327", - "829006116107352", - "829006199979361", - "829006199981935", - "829006199982523", - "829006172012547", + "829005963670356", + "829006000876968", "829006030227137", - "829006199984558", - "829006199983834", - "828995032057999", - "829006199990988", - "829006199979677", - "828995032058313", - "829006199978550", - "829006000875621", - "829005853898294", - "829006199978460", - "829006199985327", - "829006116109826", - "829005936122115", - "829006199978865", - "829005853897710", - "829006199981393", + "829006060223980", + "829006090261220", + "829006116111358", "829006144048883", - "829006199978685", - "829005991887354", - "829006116108026", - "828995032057060", - "829006199980038", - "829006199992079", - "829006199978415", - "829006116107083", - "829005909226879", - "829006116110501", - "828995032057104", - "828995032058672", - "829006199993034", - "829111675230469", - "829087368706074", - "829106464828198", - "829111564257772", - "829087474310267", - "829111564257994", - "829013858698025", - "829106308806116", - "829106506416744", - "829018632524072", + "829006172012547", "829009896121312", "829013592248544", - "829111779447157", - "829106256920164", - "829111564257950", - "829111564257549", - "829013912454226", - "829087314404090", - "829106934060079", - "829132731424577", - "829018632524117", - "829111831621183", - "829006199993580", - "829106360729546", + "829013644229851", + "829013697768773", + "829013751364139", "829013805012233", + "829013858698025", + "829013912454226", + "829013968557091", + "829014014557884", "829014078095091", + "829087240983659", + "829087290156335", + "829087314404090", + "829087368706074", + "829087424377352", + "829087474310267", + "829087520542296", + "829087566833206", + "829106153308296", "829106205055293", - "829133852675561", - "829013967605303", + "829106256920164", + "829106308806116", + "829106360729546", "829106412729751", - "829013966211583", + "829106464828198", + "829106506416744", + "829106833236673", "829106934382596", + "829106980674231", + "829111564257994", + "829111617843224", + "829111675230469", "829111727292683", - "829013697768773", - "829111617843180", - "829101708988161", - "829013592248499", - "829107101257505", - "829014069232719", - "829014014557884", - "829112041188907", + "829111779447157", + "829111831621183", "829111883845181", - "829106933552354", - "829111564257638", - "829106933854415", - "829111988564667", - "829106933590211", - "829132731424980", - "829107095677115", - "829132731424443", "829111936188134", - "829087424377352", - "829106933700589", - "829106833236673", - "829087290156335", - "829013751364139", - "829132731424756", - "829013644229851", - "829106980674231", - "829013966724783", - "829087520542296", - "829132731425248", - "829132731424354", - "829013968557091", - "829087240983659", - "829132731424310", - "829087566833206", - "829106153308296", - "829106933566786", - "829006199994172", - "829111617843224", - "829018632524207", - "829135369662756", - "829183942521991", - "829134841360036", - "829183942517170", - "829190226097377", - "829135369662490", - "829136481167870", - "829135369663067", + "829111988564667", + "829112041188907", + "829134485220626", + "829134574180550", "829134663145919", "829134752133073", - "829186743618923", - "829183942526548", + "829134841360036", "829134929324679", - "829191713619410", - "829192037589637", - "829134485220626", - "829185060780034", - "829183942519401", - "829187277011342", - "829186920041004", "829185941691894", - "829190404755008", - "829136481167158", - "829136481164755", - "829191539184722", - "829192207356773", - "829190957741257", - "829136481163822", - "829136481169429", - "829135369661826", - "829183942520651", + "829186743618923", + "829186920041004", + "829187099802571", + "829187277011342", "829189129880320", - "829135369662268", - "829136481170276", - "829183942518241", - "829183942516189", + "829189260058713", + "829189390868292", + "829189521213228", "829189693070495", - "829136481168627", "829189870726800", - "829191864346990", "829190050894735", - "829183942528246", - "829136481166490", - "829135369662091", + "829190226097377", + "829190404755008", "829190581557182", - "829189521213228", - "829189390868292", - "829136481165289", - "829191201306987", - "829183942524939", - "829136481163422", - "829134574180550", - "829135369661958", "829190762270847", - "829187099802571", + "829190957741257", + "829191201306987", "829191365955628", - "829189260058713", - "829136481165867", - "829183942523420", - "829136481164266", - "829135369661870", - "829200322783278", - "829198350388150", - "829204999965838", - "829209151460992", - "829214289723985", - "829204999965587", - "829196538253298", - "829204670335114", - "829196538253425", - "829213708468534", - "829204999966216", + "829191539184722", + "829191713619410", + "829191864346990", + "829192037589637", + "829192207356773", "829192377960293", - "829209600930541", - "829210623926384", - "829192758331164", "829192549382379", - "829209605370400", - "829204366276703", - "829196280266073", - "829195289809078", - "829195031752041", - "829196545188379", - "829197703875021", - "829203848904359", - "829194525552561", - "829203608965771", + "829192758331164", "829193012618217", - "829198791414417", - "829196552678042", - "829199819479589", + "829193263453107", + "829193514528954", "829193767012356", - "829209605369599", - "829204999966006", - "829215944270552", - "829204999965628", - "829200830914858", - "829196538253171", - "829211985018181", - "829214962805520", - "829210284387017", - "829216916493539", - "829196538253808", "829194019282285", - "829199053850418", - "829200574851909", - "829197973230178", - "829196552677915", - "829211648451146", - "829196538253595", + "829194269297938", + "829194525552561", "829194779306879", - "829216263749333", - "829204107573326", - "829196935050633", - "829193514528954", + "829195031752041", + "829195289809078", "829195524229003", - "829213683311498", - "829212658163974", - "829194269297938", - "829214623097679", - "829213331403362", "829195764608803", - "829213950803066", - "829204999965712", - "829197443812300", - "829209600931299", - "829213539362333", - "829212321586189", - "829203608965687", - "829196552677957", + "829196022412065", + "829196280266073", + "829196552678042", "829196674385922", + "829196935050633", + "829197196247807", + "829197443812300", + "829197703875021", + "829197973230178", + "829198250532928", "829198353835232", - "829198351903131", - "829209151460782", - "829211305116502", - "829210963014791", "829198529384329", - "829212994764012", + "829198791414417", + "829199053850418", + "829199316292935", + "829199568122218", + "829199819479589", + "829200070868877", + "829200322783278", + "829200574851909", + "829200830914858", + "829203608965771", + "829203848904359", + "829204107573326", + "829204366276703", + "829204670335114", + "829209605370400", "829209944871466", - "829196538254063", - "829196022412065", - "829209600931004", + "829210284387017", + "829210623926384", + "829210963014791", + "829211305116502", + "829211648451146", + "829211985018181", + "829212321586189", + "829212658163974", + "829212994764012", + "829213331403362", + "829213539362333", + "829213683311498", + "829213708468534", + "829213950803066", + "829214289723985", + "829214623097679", + "829214962805520", + "829215301078345", "829215631770907", - "829209605369978", - "829198250532928", - "829213538748352", - "829199316292935", - "829209151460866", + "829215944270552", + "829216263749333", "829216583995210", - "829215301078345", - "829200070868877", - "829199568122218", - "829209600930751", - "829193263453107", - "829196538253213", - "829201089289843", - "829197196247807", + "829216916494409", + "829217589042071", + "829217927394862", + "829218273223470", "829218615971652", - "829221836639781", - "829243491947654", - "829216916493787", - "829218273223263", + "829218958774083", "829219300307587", - "829254327530805", - "829222757497991", - "829218958774042", - "829249960898395", - "829221176957385", - "829246076187885", - "829249402674104", - "829251667702452", - "829218273223346", + "829221176957468", "829221466429049", - "829253153123206", - "829246809676233", - "829244471022292", - "829219468224134", - "829218958774083", - "829216916493953", - "829218273223470", - "829223601035696", - "829245778300453", - "829224235071419", - "829216916493580", - "829250789005818", - "829217587953251", - "829224235071460", + "829221836639781", + "829222211414714", "829222232153268", + "829222575811485", "829222757498198", - "829216916493663", - "829252560594279", - "829222757497950", + "829222922083521", + "829223092421970", + "829223260591500", + "829223428231991", + "829223601035696", + "829223769123728", "829223999099760", - "829222757498074", - "829248232453937", "829224171467911", - "829243491947778", - "829247336445592", - "829222211414631", - "829249124170547", - "829250236619381", - "829222211414714", - "829223260591500", + "829244471022292", + "829244679562677", + "829245778300453", + "829246076187885", "829246809676479", - "829222575811444", - "829216916494160", - "829218273223222", - "829217927394862", - "829222922083521", - "829217589042071", - "829221176957468", - "829223092421970", - "829243491947984", - "829253449560982", - "829251964337662", + "829247336445592", "829247630823418", - "829223769123728", - "829219300307546", - "829216916494409", "829247923953752", - "829244679562677", - "829223428231991", - "829222575811485", - "829222211414590", + "829248232453937", + "829249124170547", + "829249402674104", + "829249960898395", + "829250236619381", + "829250789005818", "829251074767074", - "829431867950775", - "829429735594736", - "829441044306500", + "829251667702452", + "829251964337662", + "829252560594279", + "829253153123206", + "829253449560982", + "829254327530805", + "829425592292229", + "829425858372742", + "829426131295780", + "829426456902085", "829426782516512", - "829437137734828", - "829432483237858", - "829437137735380", - "829429083047133", - "829442383369641", "829428751686410", - "829433496303772", - "829426131295780", + "829429083047133", + "829429735594736", + "829430640293167", + "829430945130495", "829431252274305", - "829427176449693", - "829440735410264", - "829427176449453", - "829437638647579", - "829438789634188", - "829433253855901", - "829437638647186", - "829426456902085", + "829431867950775", "829432181955939", - "829430945130495", - "829425858372742", - "829437638652123", - "829425858372622", - "829440735410843", - "829437638648992", - "829437638651420", - "829441044306229", - "829442383370104", - "829437137734789", - "829427176449573", - "829430640293167", - "829437638650129", - "829440735410302", - "829442243030599", - "829442383369911", - "829441044306731", - "829440344695639", + "829432483237858", + "829433253855901", + "829433496303772", + "829438789634188", "829439919740231", - "829441044306152", "829440234578203", - "829440735410495", - "829441044306693", - "829437638648011", - "829437638650755", - "829442383369564", - "829425592292229", - "829437137734907", - "829440344695832", - "829440708910710", "829440344696684", - "829442383370336", - "829451152035501", - "829442383379454", - "829442383373046", - "829452086952762", + "829440708910710", + "829440735410843", + "829441044306731", + "829442243030599", + "829442383401542", + "829442868920228", "829443353878855", + "829443622035732", + "829444088600116", + "829444472835730", "829445486826926", - "829727397021756", - "829446949867995", - "829727454460307", - "829442383376151", - "829449745849472", - "829446949867764", "829445938442180", "829446949868072", - "829444472835730", - "829442383374171", - "829446949867378", - "829442868920228", - "829442383377666", - "829727454459122", - "829446949867493", - "829442383401542", - "829452563725007", - "829450683381354", - "829727454457372", - "829455380159102", - "829454000366014", - "829448317433778", - "829453041850757", - "829727397021500", - "829448794074242", - "829444088600116", - "829727454458144", "829447399288368", - "829442383383966", - "829449292516175", - "829727454457732", - "829442383391403", - "829727454459689", - "829446949867609", - "829454937488100", - "829727397021602", - "829727397021449", - "829446949867416", - "829446949867957", "829447858226797", - "829454480153395", - "829727397022218", - "829450199417473", + "829448317433778", + "829448794074242", "829449292516214", - "829727454458607", + "829449745849472", + "829450199417473", + "829450683381354", + "829451152035501", "829451619406763", + "829452086952762", + "829452563725007", + "829453041850757", "829453520642430", - "829727397021961", - "829443622035732", - "829442383385289", - "829727454461699", - "829766411183778", - "829766411307584", - "829727454460977", - "829727454473830", - "829778517495595", - "829763387326004", - "829727454477242", - "829763387284737", - "829763387288944", - "829763387273368", - "829766411192325", - "829778562136566", - "829727454464174", - "829778563215934", - "829727454468251", - "829766411220844", - "829730795578011", - "829778517540419", - "829778562397309", - "829778517616855", - "829766411210832", - "829727454475484", - "829730795579977", - "829766353049479", - "829766411338767", - "829766353042558", - "829778517705915", - "829763387260970", - "829778562901108", - "829766353056768", - "829727454470833", - "829763387276949", - "829766411175652", - "829763387280739", - "829763387263821", - "829763387298139", - "829727454472280", - "829763322081919", - "829778517590079", - "829778563000824", - "829766411266496", - "829778517564618", - "829730795582047", - "829778532475693", - "829763387303128", - "829778532513891", - "829766411231380", - "829766411242492", - "829727454466083", - "829763387313939", - "829766411254180", - "829763387266830", - "829778517645051", - "829727454467115", - "829763387319815", - "829778561972718", - "829778562260381", - "829766411279493", - "829727454465103", - "829778562196914", - "829778517455186", - "829778562024591", - "829778547252293", - "829778562806264", - "829778562630288", - "829778563331860", - "829778517517429", - "829727454463297", - "829727454462472", - "829778563105677", - "829778563453722", - "829766411293172", - "829763387269995", - "829778562079178", - "829778547207740", - "829778562716079", - "829778517474865", - "829766411201343", - "829763387308377", - "829778517674720", - "829778517436512", - "829778517738742", - "829778562327126", - "829778562548678", - "829730795584273", - "829778517773254", - "829763387293411", - "829766411322782", + "829454000366014", + "829454480153395", + "829454937488100", + "829455380159102", + "829727397022218", "829763322084457", - "829778562471089", - "829727454469490", - "829766411355591", - "829778563581839", - "829778563716530", - "829778649748718", - "829778649673579", - "829778586285527", - "829778649686104", - "829778649674856", - "829778602428213", - "829778564501260", - "829778565509075", - "829778649679703", - "829778649675974", - "829778565286864", - "829778567103485", - "829778649677305", - "829778568099042", - "829778649673260", - "829778649682582", - "829778649791368", - "829778564874417", - "829778602923291", - "829778601957287", - "829778649719681", - "829778649730766", - "829778649673951", - "829778649680609", - "829778649853414", - "829778649765020", - "829778649672782", - "829778564007070", - "829778649887772", - "829778565075489", - "829778603443752", - "829778649683649", - "829778649815209", - "829778603443805", - "829778649723161", - "829778601509505", - "829778649698069", - "829778665099490", - "829778649681569", - "829778567418881", - "829778649739231", - "829778649692298", - "829778664919435", - "829778665055658", - "829778649694114", - "829778665016154", - "829778566246586", - "829778568465516", - "829778649900466", - "829778649777467", - "829778649759281", - "829778649710369", - "829778649702506", - "829778649684823", - "829778649843094", - "829778565988349", - "829778564683167", - "829778565742708", - "829778649824019", - "829778649864273", - "829778665035392", - "829778664980543", - "829778649696038", - "829778567750449", - "829778585880514", - "829778649707587", - "829778649833314", + "829766353056768", "829778618273981", - "829778649806831", - "829778649713312", - "829778649675388", - "829778649674377", - "829778649753865", - "829778649716416", - "829778649875726", - "829778649700207", - "829778649676613", - "829778564163611", - "829778649690589", - "829778649743840", - "829778649771082", - "829778649688987", - "829778649678051", - "829778649726856", - "829778664964062", - "829778649678850", - "829778649687492", - "829778649704966", - "829778665077006", - "829778664997889", - "829778566518058", - "829778649798884", - "829778664948392", - "829778563858167", - "829778649784229", - "829778649672994", - "829778664933533", - "829778566803460", - "829778649734891", - "829778564328217", - "829778712613033", - "829778712959547", - "829849316160951", - "829778712832253", - "829849243800001", - "829849250316238", - "829849244269453", - "829849248786679", - "829849226726725", - "829778712225140", - "829778665148085", - "829849226350010", - "829778712357194", - "829849227011213", - "829778712663778", - "829849226865394", - "829846496028696", - "829778665123165", - "829849242482029", - "829778712518926", - "829849250317056", - "829778712773252", - "829849250316565", - "829846495789071", - "829906249618499", - "829846495944748", - "829778713028167", - "829849226025914", - "829849246696062", - "829849226594824", - "829778712394589", - "829849245067939", - "829849250321983", - "829849243582314", - "829906249624443", - "829849245995627", - "829846495864937", - "829778712564785", - "829849226236494", - "829849250322805", - "829849250316292", - "829778665174304", - "829849316158645", - "829849243178273", - "829849248325736", - "829849250320504", - "829849242812717", - "829849250318698", - "829849316159743", - "829849226469362", - "829849242990931", - "829846511428355", - "829849246337079", - "829849244028846", - "829849247887276", - "829849331488551", - "829849249271260", - "829849250321216", - "829849242643191", - "829849226128541", - "829849247073457", - "829778712255692", - "829849244522425", - "829849243375236", - "829849331487123", - "829849249780691", - "829906249622351", - "829849316155682", "829778680278193", - "829849247470198", - "829849244788367", - "829906249620370", - "829849250319847", - "829846496116944", - "829849331490090", - "829849250319245", - "829849316157602", - "829849250317767", - "829849250318205", - "829849245670827", - "829849245361854", - "829849250316401", - "829778712894297", - "829778712433937", - "829778712475346", - "829849316156614", - "829906249626645", - "829778712717130", - "829906249616739", - "829778712321643", - "829849250317384", - "829778712287827", - "829849250316783", - "829906265466040", - "829906249631547", - "829906249819805", - "829906249666837", - "829906249720531", - "829906269380587", - "829906265488021", - "829906267080286", - "829906271859396", - "829906249832877", - "829906249654092", - "829906249629013", - "829906265425363", - "829906249807400", - "829906249861188", - "829906268773136", - "829906249713179", - "829906249699640", - "829906265745831", - "829906265388702", - "829906272578823", - "829906268590078", - "829906249650286", - "829906266271358", - "829906268965569", - "829906249795607", - "829906269839247", - "829906266884522", - "829906265511172", - "829906266210635", - "829906249892613", - "829906249693397", - "829906249671584", - "829906265677950", - "829906265445172", - "829906265904029", - "829906267185785", - "829906266335213", - "829906266547248", - "829906249637111", - "829906266979940", - "829906265948882", - "829906249784425", - "829906266625312", - "829906249658119", - "829906267800478", - "829906267664938", - "829906269167884", - "829906266402367", - "829906269604187", - "829906268415944", - "829906265996081", - "829906265782422", - "829906249745083", - "829906270346226", - "829906249876483", - "829906270906544", - "829906272966447", - "829906249728271", - "829906268250339", - "829906249646702", - "829906273373940", - "829906266707405", - "829906249676608", - "829906270086386", - "829906249687487", - "829906267536014", - "829906265561208", - "829906271208433", - "829906266152875", - "829906265535549", - "829906265406556", - "829906266097965", - "829906265588205", - "829906271525787", - "829906249754155", - "829906249681909", - "829906265711026", - "829906272210107", - "829906267942972", - "829906268092813", - "829906266793752", - "829906267413368", - "829906249706215", - "829906265616596", - "829906270619386", - "829906249643339", - "829906249773798", - "829906249662367", - "829906266472989", - "829906266045738", - "829906265820911", - "829906267296719", - "829906249640142", - "829906249736455", - "829906265861409", - "829906265646492", - "829906249634246", - "829906249846671", - "829906249763727", - "829906292015172", - "829906307771473", - "829906292010381", - "829906276300147", - "829907697995214", - "829906339407718", - "829906276297058", - "829906307767293", - "829906276298236", - "829907698515611", - "829906292018218", - "829906339359773", - "829906339401649", - "829906292016638", - "829906339380447", - "829906292013819", - "829906371239169", - "829906323566336", - "829906307781533", - "829906276297114", - "829906323559944", - "829907698061535", - "829906371349747", - "829906371410840", - "829906339367360", - "829906371369063", - "829906292006663", - "829906307769326", - "829907698305975", - "829906292007508", - "829906339395922", - "829906276297618", - "829906276301441", - "829906307773733", - "829907698574968", - "829906276297899", - "829906292011452", - "829906339420880", - "829906339390479", - "829906307776163", - "829906387355681", - "829906276299585", - "829907698174462", - "829906323563054", - "829907697964489", - "829906371281687", - "829906355305531", - "829906387379458", - "829906275223789", - "829907698027543", - "829906371226424", - "829906371266772", - "829906276297394", - "829906339385321", - "829906371252599", - "829907698637370", - "829906275747013", - "829906273802319", - "829906371214307", - "829906307763567", - "829906276299079", - "829906307765373", - "829906274252657", - "829906274726085", - "829906371389408", - "829906339435579", - "829907698216081", - "829906339375857", - "829907697935322", - "829907698354480", - "829906276300766", - "829906339371495", - "829907698702989", - "829907698405511", - "829906292008409", - "829906371297402", - "829906371313974", - "829906307778763", - "829906292005875", - "829906276298629", - "829907698134908", - "829906371202818", - "829906339443526", - "829906355296672", - "829906292012579", - "829906339428030", - "829906292009367", - "829906371191899", - "829906387430863", - "829906276297226", - "829906387404502", - "829906371171720", - "829906339414128", - "829907698459183", - "829906371331403", - "829907698259880", - "829906339363452", - "829906371181551", - "829907698097304", - "829907698771999", - "829907725327134", - "829907725385595", - "829907721902731", - "829907724760597", - "829907701405868", - "829907725491903", - "829907701020038", - "829907700509077", - "829907699468634", - "829907702062060", - "829907700841108", - "829907723711296", - "829907725327538", - "829907725446043", - "829907699174193", - "829907725730562", - "829907702557523", - "829907700069411", - "829907700355108", - "829907702303586", - "829907725326500", - "829907698844572", - "829914240365433", - "829914223240010", - "829914240361134", - "829907724222833", - "829914240364266", - "829907722321558", - "829907725333784", - "829907725328000", - "829907725695166", - "829907725468377", - "829907725328520", - "829914223239336", - "829907725332858", - "829914240360213", - "829907725325981", - "829907699267468", - "829907725325924", - "829907725329734", - "829907725767809", - "829907725599123", - "829907723224708", - "829907725326269", - "829907699691038", - "829907725326788", - "829914259701460", - "829907702824508", - "829914240363160", - "829907721125350", - "829907720765005", - "829907742695426", - "829907725806966", - "829907725404712", - "829907700670942", - "829907725367431", - "829914240366662", - "829907725848153", - "829907725331990", - "829907701613751", - "829907721504324", - "829907725350161", - "829907703400231", - "829907703105179", - "829914259705028", - "829907699001102", - "829907725516681", - "829907704036493", "829914240369489", - "829914240359354", - "829907725424841", - "829907725661501", - "829907699936932", - "829907698920882", - "829907701208137", - "829907699365519", - "829907725326096", - "829907700208687", - "829914240358557", - "829907725891490", - "829914240362116", - "829907725330428", - "829907699810904", - "829907725937097", - "829907699085462", - "829907703710418", - "829907725629507", - "829907722761849", - "829907725985094", - "829907725331180", - "829907701832308", - "829907725570231", - "829914259703182", - "829907699577044", - "829914240368014", - "829907725542770", - "829907725329098", - "829914297268648", - "829914276878216", - "829914276974236", - "829914276966882", - "829914276920444", - "829914295492474", - "829914276915940", - "829914277641559", - "829914276885237", - "829914277264734", - "829914296352010", - "829914317522416", - "829914276907674", - "829914276893740", - "829914298570019", - "829914276903912", - "829914276882773", - "829914295427932", - "829914277115868", - "829914277600678", - "829914276925196", - "829914277312616", - "829914276947052", - "829914277101253", - "829914295366574", - "829914295706710", - "829914277338486", - "829914277147521", - "829914277394396", - "829914277049812", - "829914276930196", - "829914297595193", - "829914295252721", - "829914295308212", - "829914276900336", - "829914276941124", - "829914296047528", - "829914277008054", - "829914277027847", - "829914298355088", - "829914318117754", - "829914296245409", - "829914295102222", - "829914299283271", - "829914295056977", - "829914276887886", - "829914297427819", - "829914297117242", - "829914277424562", - "829914277087383", - "829914277524836", - "829914296143999", - "829914296464115", - "829914277489688", - "829914298150624", - "829914277201619", - "829914276880433", - "829914276990246", - "829914276953290", - "829914277017702", - "829914276890720", - "829914299033544", - "829914295868588", - "829914295149851", - "829914295955808", - "829914298795982", - "829914277242597", - "829914299545792", - "829914296581975", - "829914317812601", - "829914277561791", - "829914295631675", - "829914277038550", - "829914277365725", - "829914276935505", - "829914276876123", - "829914276896945", - "829914295785618", - "829914276982024", - "829914296836215", - "829914295199976", - "829914297771148", - "829914277221579", - "829914276998902", - "829914277061694", - "829914318438539", - "829914277131291", - "829914277074197", - "829914277456284", - "829914295560326", - "829914318775773", - "829914297956124", - "829914277164621", - "829914276911683", - "829914276959900", - "829914277182654", - "829914277288053", - "829914296705904", - "829914319130276", - "829914296973223", - "829914341938398", - "829914377117387", - "829917265616042", - "829914377175070", - "829914377109249", - "829914321194653", - "829914320306534", - "829914359500202", - "829914394891328", - "829914394901210", - "829914377163246", "829917301688563", - "829914341320445", - "829914341935010", - "829914377114484", - "829914341935888", - "829917283542319", - "829914339651078", - "829917339460886", - "829914341942483", - "829914341941540", - "829917283809004", - "829914341937770", - "829917283458159", - "829914319502930", - "829917339661586", - "829914340735895", - "829917339556120", - "829914377120479", - "829914359513808", - "829914359516077", - "829914359499007", - "829914377168999", - "829917283591413", - "829914319894680", - "829914359504357", - "829914377127233", - "829914377130895", - "829914341935574", - "829917283439669", - "829914394864667", - "829914377188226", - "829917339416799", - "829917283738718", - "829914341935135", - "829914377134747", - "829917283617938", - "829917283389680", - "829917283706193", - "829914394849160", - "829914359501461", - "829914341934948", - "829914341939089", - "829914359502846", - "829914341936703", - "829917339607510", - "829914341937205", - "829914321673124", - "829914377152690", - "829917283334136", - "829917283645867", - "829914341944558", - "829914341940660", - "829914359505995", - "829914377143212", - "829914341936264", - "829914377123761", - "829917265604502", - "829914377138853", - "829914377147824", - "829914359509649", - "829914412593539", - "829917283360473", - "829914377181458", - "829914340179846", - "829917339507288", - "829917283772967", - "829917283374694", - "829914377157810", - "829914394856690", - "829914377111771", - "829917283519621", - "829914341943489", - "829914359507759", - "829917283498071", - "829917283846893", - "829917283675264", - "829914359511665", - "829917283405493", - "829914394873088", - "829914394881954", - "829917283422135", - "829914320739501", - "829917283346952", - "829917283566228", - "829914341935323", - "829917339718477", - "829914341939843", - "829917283477605", - "830263701767274", - "830263533317037", - "830263683776824", "829917341284980", - "829917340679300", - "830263533927886", - "830264997455309", - "830263532764384", - "829917360215440", - "830263538633657", - "830263701776567", - "830263532264309", - "830263533033791", - "830263538091223", - "829917339778312", - "830263537084390", - "829917340476434", - "830263540433916", - "829917339976951", - "830263701787035", - "829917359397236", - "830263531811911", - "830263683778563", - "830263539803355", - "829917359544878", - "829917340207924", - "830263540434173", - "829917340050100", - "829917359863367", - "829917341024341", - "830263701777988", - "829917341151389", - "830263536617469", - "830263701771789", - "830263701784966", - "830263701781218", - "830263701805537", - "830263534256975", - "829917359700142", - "830263536173304", - "830263535348911", - "830263513329283", - "829917340788586", - "830263540433595", - "829917340382403", - "830263701768886", - "830264997468090", - "830263540433531", - "829917339841218", - "830263537575232", - "830263535750796", - "830263683777339", - "830264997433585", - "830263683777919", "830263513528765", - "830263533614832", - "830263683776373", - "830263701802366", - "830263532032415", - "830264997438577", - "829917340575335", - "830263532508105", - "830264997428853", - "830263701799389", - "830264997490093", - "830263701812464", - "830263701770757", - "830264997420170", - "830263534966615", - "829917360035004", - "830264997475034", - "830263683775987", - "830263701779538", - "830263701769789", - "829917340292985", - "830263540433723", - "829917340127027", - "830263701783027", - "830264997443829", - "830263701808903", - "830263534602938", - "829917340903514", - "830263701791561", - "830263701772886", - "830263701775275", - "830263701768048", - "830263701774048", - "830264997449406", - "830264997424381", - "830263701789233", - "830264997461537", - "830263701796607", - "829917339907388", - "830263539203893", - "830263701816220", - "830264997482368", - "830263701794019", - "830438678002480", - "830264997506911", - "830297545756485", - "830265015742634", - "830438677906702", - "830438678188767", - "830438677811706", - "830438737918369", - "830438696525712", - "830264997525618", + "830263683778563", "830264997581963", - "830438677780106", - "830438737830114", - "830438677885702", - "830264997498274", - "830264997535753", - "830264997516004", - "830438739061806", - "830438761060132", - "830438768255030", - "830438758209572", - "830438738684847", - "830438767608821", - "830438738308603", - "830438758831986", - "830438738447868", - "830438768255162", - "830438768257340", - "830438761976655", - "830438738124296", - "830438758664528", - "830438739280596", - "830438761350484", - "830438738522919", - "830438759387791", - "830438768254965", - "830438764820932", - "830438762668635", - "830438760271338", - "830438759592411", - "830438759807512", - "830438759008074", - "830438765324220", - "830438738376495", - "830438738601846", - "830438758505237", - "830438739398508", - "830438738016084", - "830438678029697", - "830438677976638", - "830438764342169", - "830438738960335", - "830438760033623", - "830438768257934", - "830438760521253", - "830438738772119", - "830438766409478", - "830438763041430", - "830438763453512", - "830264997557652", - "830438768255954", - "830438760783964", - "830438762313997", - "830438768255624", - "830438738863861", - "830438758072513", - "830438677846775", - "830264997569482", - "830438739522473", - "830438759193188", - "830438737873120", - "830438678058354", - "830438768255360", - "830438758353717", - "830438678088517", - "830438738244060", - "830438677928814", - "830264997546409", - "830438768256812", "830438678225743", - "830438677828783", - "830438677795479", - "830438737965980", - "830438766994167", - "830438739168472", - "830438678120252", - "830438768256350", - "830438765853293", - "830438677952104", - "830438763886738", - "830438678153625", - "830438677865748", - "830438738182668", - "830438761655749", - "830438738068812", - "830438768259320", - "832093413989291", - "832104321767231", - "832104321765413", - "832104360963358", - "832104341318701", - "832104341288930", - "832093413307098", - "830439330369753", - "832104341298732", - "832093413989986", - "832104360979656", - "832104361176629", - "832093413989360", - "832104321760799", - "832104360929585", - "832104360997857", + "830438696525712", + "830438739522473", "830439311902999", - "832104341327044", - "830439311901808", - "832104341336441", - "832104360935620", - "832104361196064", - "832104321762197", - "830438768260972", - "832104360942009", - "832104360971296", - "832104341301534", - "830438768258594", - "832104341296071", - "830438768260113", - "832093413990752", - "832112476947653", - "832093413991240", - "832104361052768", - "832093433456651", - "832093412040827", - "832104341346963", - "832112476704657", - "832104341304546", - "832104299788015", - "832112476911582", - "832093412658147", - "832104361140653", - "832093413989499", - "830439311899625", - "832104361040601", - "832104341291170", - "832104341322767", - "832104341314846", - "832104299789272", - "832112476844678", - "832112476729832", - "832104361124041", - "832112476658061", - "832112476784284", + "830439330369753", "832093413992424", - "832093433450999", - "832112476813703", - "832104361158182", - "832104360988510", - "832112476680755", - "832093413989708", - "832104361065569", - "832104341341561", - "832093433453510", - "832104341331602", - "832104361079076", - "832104361093288", - "832104360948750", - "832093413990334", - "832104361108276", - "832112477025600", - "832104341286831", - "832104341307769", - "832104341311202", - "832093413991797", - "832112476985635", - "832093433451766", - "832093433452603", - "832112476877281", - "832104360955843", - "832104361018101", - "830439311900683", - "832104321763735", - "832093433455534", - "832104341293550", - "832104361007697", - "832093433454487", - "830438768261897", - "832104380879910", - "832104361029069", - "832112476756351", - "832112630979789", - "832112724841328", + "832104299789272", + "832104321767231", + "832104341346963", + "832104361196064", + "832112477312775", + "832112497326543", + "832112517192598", + "832112561992276", + "832112631611086", + "832112652636684", "832112677961380", - "832256453567952", - "832112724841541", "832112704265752", - "832112744753840", - "832112724841186", - "832112630272818", - "832112477258642", - "832112477067618", - "832112629220495", - "832112744746336", - "832112676133742", - "832112631390024", - "832112652109743", - "832112676463692", - "832112700037234", - "832112630117078", - "832256453568962", - "832256453567808", - "832112630789546", - "832112744744195", "832112724841826", - "832112651865469", - "832112628747695", - "832256453548529", - "832256453569396", - "832112744752553", - "832112629330170", - "832112631611086", - "832112497197117", - "832112699076820", "832112744758203", - "832256453571854", - "832112497326543", - "832112630436524", - "832112703567494", - "832112675521485", - "832112744747193", - "832256453568601", - "832256453561427", - "832112699545031", - "832112744750194", - "832112629694088", - "832256453555837", - "832256453546380", - "832112629828070", - "832256453568312", - "832112629566646", - "832112744745551", - "832112744751338", - "832112702271396", - "832112629017057", - "832112630608624", - "832256453568096", - "832112497260199", - "832112628922725", - "832112628666593", - "832112675819907", - "832112701670331", - "832256453558560", - "832112652636684", - "832256453544375", - "832256453553257", - "832112631179782", - "832112701098559", - "832112629116219", - "832112677558458", - "832112744756629", - "832112477312775", - "832112676810544", - "832256453569902", - "832112477111832", - "832256453570480", - "832112652366623", - "832256453550821", - "832112744744837", - "832112744743196", - "832112744755199", - "832112629968948", - "832112477158313", - "832112700554647", - "832112744749122", - "832256453567880", - "832256453571131", - "832112628833009", - "832112744743624", - "832112561992276", - "832112744748122", - "832256453564510", - "832112477207202", - "832112677175156", - "832112702903258", - "832112698631581", - "832112497137172", - "832112629445459", - "832112764720795", - "832112517192598", - "832256453581628", - "840213540077393", - "840663722024992", - "835708527290681", - "840663680084216", - "840663680085866", - "832256453592501", - "840663722022057", - "840679838990154", - "832256453600987", - "835708527289412", - "832256453600117", - "832256453578948", - "832256453575472", - "835708527307036", - "835708527300312", - "832256453601422", - "840213519122020", - "832256453590326", - "840213519115359", - "832256453577717", - "835638551831956", - "840213540071323", - "835708527286055", - "840663722018221", - "840213498241150", - "840663680084891", - "840663722020703", - "832256453586411", - "835708527282626", - "832256453599972", - "835708527293442", - "832256453573518", - "835638551831659", - "832256453588296", - "832256453594822", - "835708527302404", - "832256453599900", - "840663722028455", - "835638572606810", - "840663680085341", - "840663701042777", - "840213519118577", - "832256453580252", - "832256453574459", - "840663722019424", - "840213519138042", - "835708527292024", - "835638572606364", - "840213519147479", - "835708527281955", - "840213519158117", - "832256453576558", - "835638551831436", - "840213519133699", - "840663701043528", - "835708527288218", - "832256453572650", - "832256453600334", - "835708527281359", - "840663722017093", - "835708527296578", - "835638531071347", - "840213519112367", - "840679838992263", - "840663722023487", - "840663722026648", - "840213519129581", - "832256453600624", - "840213519142610", - "835708527287099", - "840213519125688", "835638531071421", - "840663701044354", - "832256453583077", - "835708527284191", + "835638551831956", "840213498243841", - "835708527298370", - "840663680084516", - "840663722016040", - "835708527304645", - "840663680083991", + "840213519158117", "840663680086466", - "840663722015063", - "832256453584671", - "840663680083841", - "835708527283371", - "832256453597288", - "840213519152648", - "835708527294935", - "835708527285086", - "840679860015819", - "840780855304379", - "840780855309963", - "840960296438805", - "842972190032503", - "840960275193247", - "842972190125488", - "842942589665851", - "840960275180779", - "843824619454004", - "843824619458768", - "842562968221761", - "840960275213508", - "840960296352236", + "840663701044354", + "840679838992263", "840960275225457", - "840780855307095", - "842972190699823", - "840960296385548", - "842972190348903", - "840960275197857", - "842942568299414", - "842942589610125", - "840960275188864", - "842942589695962", - "840960296367981", - "840960275177078", - "840960296415771", - "840960296359881", "842942568344764", - "842972190077812", - "840960296376537", - "840960275184708", - "840960296426984", - "842942568321518", - "842942568278458", - "842972190177234", - "842972190288750", - "842972190478764", - "842972189948451", - "840960296395091", - "840960275170358", - "842562968188604", - "842562968173281", - "843824619460643", - "842562968239671", - "842562968131801", - "843824619455488", - "840960296344970", - "842562968204764", - "840780855301815", - "842972212620905", - "843131470459583", - "843824619464862", - "840960275207988", - "842972190125564", - "842972190412190", - "842972189872565", - "842972189909554", - "840960275202771", - "843583452696488", - "842942589584365", - "842972189837417", - "843824619457050", "842942589727674", - "840960296405165", - "842972212516126", - "842972189989408", - "842972190548779", - "840960296338085", - "842562968158718", - "843824619467207", - "843131470575405", - "842972190231578", - "840960275173604", - "842972212321727", - "842972212416477", "842972190781235", - "842972212231670", - "843824619462674", - "842562968144916", - "840960275219331", - "842562968258570", - "842972190622389", - "842942589637264", - "843824619469708", - "844484841087767", - "843824641398886", - "844476989077735", - "843824619507906", - "844484841283166", - "843824641420292", - "843824619481280", - "844484818152001", - "844484932489803", - "843824619493494", - "844484932075167", - "844476989123048", - "844476989067843", - "844485018029326", - "844476989149523", - "844477011356034", - "844485041238091", - "844477011385647", - "844477011228886", - "844485040951126", - "844477011166958", - "843824619485116", - "844485017782355", - "843824641412763", - "844484817939394", - "843824619513312", - "844477011132600", - "843824641405627", - "844484886517346", - "844484840751241", - "844477011275878", - "844476989058502", - "844476989135931", - "844477011327921", - "843824619502814", - "844476989110795", - "844484840358149", - "844484840829135", - "844476989088178", - "843824619489187", - "844484841499171", + "843824619525066", "844476989178913", - "844484840303530", - "844484840997199", - "844484818105068", + "844484818152001", + "844484841615576", "844484864041561", - "844484909600485", - "844476989049633", - "843824619498036", - "844484817868374", - "843824619525066", - "844484886375053", - "844485018289005", - "844485043704299", - "844476989163824", - "844484818018002", "844484886989734", - "844477011301229", - "843824619478152", - "844477011207165", - "844476989099172", - "844484840476092", - "844485043297039", - "844484817977710", - "844485044582467", - "844484886666977", + "844484909600485", + "844484932489803", "844484955039006", - "844485042190497", - "843824619519032", - "843824619472366", - "844485042541056", - "844484840606699", - "844484840911068", - "844484840415617", - "844484932277254", - "844484863912866", - "844484909417669", - "844477011149343", - "844485044132429", - "844484840677149", - "844477011251790", - "844477011186549", - "844484840251614", - "844485041539852", - "844484841615576", - "844484840539733", - "844484817902975", - "844484817835519", - "844476989041238", - "844484886824307", - "844484841388473", - "843824619475181", - "844485041857055", - "844485042909611", - "844484818060428", - "844484841183010", - "844485119054564", - "844485093935298", - "844485163663787", - "844485119053370", - "844485095312363", - "844485069319485", - "844485096054328", - "844485163657147", - "844485163641318", - "844485208887100", - "844485096834285", - "844485208749912", - "844485163700210", - "844485186243517", - "844485119059107", - "844485163732897", - "844485119061261", - "844485141347149", - "844485119055122", - "844485209005222", - "844485163645953", - "844485163740591", - "844485208695829", - "844485208973352", - "844485163648511", - "844485163684595", - "844485208914372", - "844485119065092", - "844485045552820", - "844485119053688", - "844485209741457", - "844485186201843", - "844485186258938", - "844485186145422", - "844485208813186", - "844485119055759", - "844485163725605", - "844485209038786", - "844485209111320", - "844485208730943", - "844485186155532", - "844485208790993", - "844485045055531", - "844485163675550", - "844485119058150", - "844485141345392", - "844485119063735", - "844485163712225", - "844485209328456", - "844485208769929", - "844485163718714", - "844485119054086", - "844485163671388", - "844485119066529", - "844485208861199", - "844485163654108", - "844485163706057", - "844485209608104", - "844485186166205", - "844485209673083", - "844485119056476", - "844485119057273", - "844485163749171", - "844485209280523", - "844485186135878", - "844485209150452", - "844485209813387", - "844485119053131", - "844485186228901", - "844485209191602", - "844485208712941", - "844485119068046", - "844485069897197", + "844485018289005", + "844485046075612", "844485070504640", - "844485186177441", - "844485119062458", - "844485163689479", - "844485208836588", - "844485209968566", - "844485163651229", - "844485163660347", - "844485186215010", - "844485209234932", - "844485208943096", - "844485209431913", - "844485163667467", - "844485209546357", - "844485209074125", - "844485119060144", - "844485209889036", - "844485094606550", "844485096834364", - "844485186189320", - "844485209378892", + "844485119068046", "844485141349066", - "844485163643555", - "844485163694684", - "844485046075612", - "844485163679952", - "844485209487681", - "844485211027920", - "844485214038899", - "844505548385831", - "844505548382657", - "844505593913672", - "844505503020889", - "844505473730121", - "844485212559651", - "844505571139540", - "844505474823661", - "844505503022024", - "844485213243893", + "844485163749171", + "844485186258938", + "844505478842977", "844505503022511", - "844505593941835", - "844505503021618", - "844485212157367", - "844505593896212", - "844485210432133", - "844505503021294", - "844485210539652", - "844505476032058", - "844485210232631", - "844485213004327", "844505525689041", - "844485214962474", - "844505593918650", - "844485210140161", - "844485215659740", - "844485216035440", - "844485211166036", - "844505593970750", - "844505593948450", - "844485210771523", - "844505593935548", - "844485210052220", - "844485216845533", - "844505548391693", "844505548401793", - "844485214331505", - "844485211463971", - "844505475412779", - "844505593979002", - "844555865817469", - "844505593955474", - "844505525683434", - "844485213760569", - "844505571136443", - "844505548387622", - "844505478086753", - "844485211970812", - "844505476683046", - "844505548389576", - "844505473223010", - "844505548378508", - "844485214639119", - "844485216430379", - "844505477367374", - "844485210652674", - "844505548379809", - "844505548384203", - "844505548393973", - "844505474263237", - "844485217281961", - "844505548396416", - "844505525685871", - "844485211311278", - "844505525682784", - "844485211624520", - "844505503020808", - "844505593962907", "844505571142801", - "844505478842977", - "844485213495784", - "844505525684165", - "844505548381192", - "844555865816708", - "844505503021051", - "844505593923955", - "844505548399023", - "844505593908939", - "844505525684977", - "844505525687903", - "844505593900209", - "844485210329874", - "844505525686846", - "844485212353484", - "844505593929588", - "844505593996981", - "844505593904451", - "844505593892461", - "844485212776436", - "844505593987746", - "844485211793332", - "844485215302383", - "844485210896524", - "844505472740720", - "844555892626245", - "844555892425841", - "844555892555896", - "844555969055180", - "844555969297809", - "844555892610684", - "844555968008473", - "844555893187572", "844555865819246", - "844555892923105", - "844555892678154", - "844556019839261", - "844555917612261", - "844555892595895", - "844555892784846", - "844555892435326", - "844555942103012", - "844555893062551", - "844555892447442", - "844555892454013", - "844555892501991", - "844555892433716", - "844555892642662", - "844555892863511", - "844555892430751", - "844555892511642", - "844555966920511", - "844555941929307", - "844555893233683", - "844555892468266", - "844555892835945", - "844555942196632", - "844556022950586", - "844555893443305", - "844555892460926", - "844555893143780", - "844555892426941", - "844555967053608", - "844556049298858", - "844555892543933", - "844555892717503", - "844555892484230", - "844556021948153", - "844555892428126", - "844556019477140", - "844556023490603", - "844555893386882", - "844555892659937", - "844555893102135", - "844555892568544", - "844555967828736", - "844555966793964", + "844555893502650", "844555917830758", - "844555892697314", - "844555917546554", - "844555967193513", + "844555942196632", "844555969552866", - "844555967495218", - "844555968604869", - "844555966559135", - "844555893333209", - "844555892429396", - "844555892809752", - "844556021483223", - "844555967340573", - "844555893282200", - "844556022436869", - "844555892532570", - "844555966346729", - "844555892476034", - "844555892492854", - "844555966450250", - "844556018805006", - "844555968824373", - "844555892441213", - "844555968197438", - "844555966673620", - "844555893502650", - "844555892955305", - "844555865818315", - "844556020219968", - "844555893024942", - "844555942013955", - "844556021040952", - "844556019132652", - "844555892521806", - "844555892989222", - "844556020620214", - "844555967657795", - "844555892761226", - "844555917754198", "844555994159924", "844556024058309", - "844555892892536", - "844555892432191", - "844555968396064", - "844555892738807", - "844555892581877", - "844555993863534", - "844555917681423", - "844556103533976", - "844556180398236", - "844556180263986", - "844556180020459", - "844556152468469", - "844556127852233", - "844556049926190", - "844556205119049", "844556054426322", - "844556127814565", - "844556180185208", - "844556103557349", - "844556205472833", - "844556206261655", - "844556127928080", - "844556205827761", - "844556205320436", - "844556103524600", - "844556103542836", - "844556152308381", - "844556103549614", - "844556231084578", - "844556152388012", - "844556205394703", - "844556103514880", - "844556127845880", - "844556103520954", - "844556180306486", - "844556152353642", - "844556205928196", - "844556103516268", - "844556127823869", - "844556079374720", - "844556180114140", - "844556052008023", - "844556127839876", - "844556204894035", - "844556180050080", - "844556127917713", - "844556079375065", - "844556205182785", - "844556205058472", - "844556205249855", - "844556127828914", - "844556231513139", - "844556180351178", - "844556180081278", - "844556180223589", - "844556127858935", "844556079375497", - "844556231363104", - "844556205555001", - "844556152370390", - "844556204946091", - "844556127834221", - "844556103536755", - "844556205732245", - "844556051279153", - "844556152281881", - "844556152491338", - "844556206144879", - "844556205641384", - "844556152337768", - "844556152294780", - "844556127873473", - "844556103522690", - "844556152446737", - "844556152406596", - "844556127881396", - "844556103528940", - "844556127889755", - "844556079374461", - "844556206033814", - "844556127898551", + "844556103557349", "844556127950647", - "844556152322681", - "844556103513579", "844556152515432", - "844556179992333", - "844556127907870", + "844556180398236", + "844556206261655", "844556231670967", - "844556103526683", - "844556103531371", - "844556052774220", - "844556079374289", - "844556205000878", - "844556127865986", - "844556127939058", - "844556152426142", - "844556230955499", - "844556127819086", - "844556053579654", - "844556231220368", - "844556050585787", - "844556103519305", - "844556103517743", - "844556103553351", - "844556103539708", - "844556180148754", - "844556103546138", - "844556609821128", - "844556585193888", - "844556256162377", - "844556609820068", - "844556282044130", - "844556256520270", - "844556584329783", - "844556282787854", - "844556609819097", - "844556634486848", - "844556256336815", - "844556581981893", - "844556579351420", - "844556659239973", - "844556659244581", - "844556283651943", - "844556609816713", - "844556609815566", - "844556392202501", - "847574024707849", - "844556282527465", - "844556609816095", - "847583757808545", - "844556634482339", - "844556585193976", - "844556391036185", - "844556281820036", - "844556659231556", - "844556281606912", - "847583757802033", - "844556634504632", - "844556609823513", - "844556609817419", - "847574024702162", - "844556609818214", - "844556634501800", - "847574024702703", - "844556579960643", - "844556585194152", - "847583757804022", - "844556283349430", - "844556418538438", - "847583757811079", "844556256713144", - "844556418064025", - "844556581274241", - "844556282279763", - "847574024709023", - "847574024710288", + "844556283969970", + "844556309152742", "844556392631823", - "844556609822276", - "847574024706765", - "844556634488528", - "844556283061636", - "844556391405613", - "847574024701350", - "844556634485256", - "847574024704057", - "844556634492243", - "844556634517736", - "847574024700900", - "847574024701711", - "844556659254597", - "844556609815125", - "844556634514194", - "847574024704869", - "844556580601052", - "844556391794089", + "844556418538438", "844556444074063", - "847574024700810", - "847574024713089", - "847574024714625", - "844556634507642", - "844556283969970", - "844556634499145", - "847574024701080", - "844556634483753", - "844556634490297", - "847574024703335", - "847574024705772", - "844556634510829", - "847574024716252", - "844556634494366", - "844556659249456", - "847574024717969", "844556497567420", - "844556659235631", - "844556582725779", - "844556634496667", "844556585194416", - "844556578772009", - "847574024711643", - "847583757806193", - "844556309152742", - "844556583507759", - "847583757830089", - "847594525112208", - "847594362535714", - "847594525111478", - "847594470725667", - "847594525110293", - "847583757847298", - "847955727073219", - "847594470705297", - "847955778143211", - "847955752589453", - "847594362506581", - "847594525109200", - "847594362481814", - "847594525109837", - "847594470818724", - "847594362489614", - "847594470873048", - "847594445270057", - "847594525108927", - "847594470902353", - "847594362497870", - "847583757857536", + "844556609823513", + "844556634517736", "847594362596185", - "847583757819768", - "847583757881827", - "847594525110840", - "847594362557955", - "847955778191590", - "847955727069383", - "847955778231111", - "847594525113029", - "847594470650114", - "847955778161714", - "847594470769780", - "847955727076234", - "847955778172618", - "847594362525457", - "847955778151912", - "847594362546516", - "847955727079615", - "847955778271477", - "847594470999936", - "847594525109018", - "847955727074681", - "847583757868955", - "847955752591647", - "847955778139274", - "847594525109473", - "847594445254340", - "847583757842587", "847594387957737", - "847955778198649", - "847594470667564", - "847583757816690", - "847583757888808", - "847583757838149", - "847955752594025", - "847594550575311", - "847955778178575", - "847955778213961", - "847955727081443", - "847583757826467", - "847955778250191", - "847583757875209", - "847955778132133", - "847594362570031", - "847955727077879", - "847955778240375", + "847594445270057", "847594471035991", - "847955778122798", - "847594470685929", - "847955778135612", + "847594525113029", + "847955727081443", "847955752596586", - "847955778206075", - "847955778184899", - "847594470965705", - "847583757813794", - "847955778128838", - "847594362582744", - "847955778260558", - "847594470845202", - "847594470933208", - "847955778167028", - "847594550574307", - "847594470747131", - "847583757823027", - "847955727070570", - "847955727071849", - "847594470793614", - "847955778156675", - "847583757852281", - "847955778147424", - "847583757833983", - "847955778125726", - "847594362515746", - "847955778222306", - "847583757863064", - "848000374458241", - "850685454915399", - "848000115125395", - "847955778366948", - "847955778336004", - "848000293076758", - "848000374581197", - "849185560907415", - "847955778308096", - "848000115028809", - "849185560904573", - "848000401693339", - "850685454910264", - "850685454912641", - "848000292800985", - "847955778481687", - "848000293002453", - "850685454908268", - "851449324329046", - "848000115232316", - "848000319548998", - "848000400581832", - "847955778669684", - "849185560904289", - "851449324332026", - "851449296622435", - "848000401010999", - "848000114984068", - "847955778283040", - "847955778351062", - "847955778401297", - "847955778383662", - "847955778702517", - "848000292931844", - "848000401509721", - "847955778321682", - "848000293510286", - "848000114862760", - "848000114901136", - "848000403271307", - "848000401335085", - "850685454911405", - "848000115177517", - "848000115075856", "848000293610838", - "849185560904952", - "848000115289976", - "848000403010699", - "848000292864745", - "847955778460001", - "848000402089380", - "848000401886404", - "848000400860714", - "848000401168968", - "848000293237194", - "848000114941541", - "848000374341323", - "847955778504570", - "848000402302731", - "848000293323696", - "850685454916921", - "847955778419852", - "848000293414634", - "848000400717741", - "849185560904100", - "848000402762787", - "847955778638510", - "848000293154943", - "847955778554019", - "849185560905426", - "847955778295246", - "848000402527014", - "847955778580770", - "847955778439420", - "847955778528650", - "848000114826328", - "851449324329642", - "849185560906657", - "847955778608903", - "849185560905994", - "848001786853165", - "851449324333020", - "851449296622633", + "848000319548998", + "848000374581197", "851449296623327", - "851449324331132", - "851449296622336", - "851449296622930", - "851449324330337", - "850685454909218", - "850685454913972", - "851449352090311", - "851449379891748", - "851449324336598", - "851578437103089", + "851449324337990", "851449352104247", - "851449324334113", - "851851994560301", - "851852022501515", - "856443195828385", - "856443071683644", - "851449352082451", - "851449352086132", - "851852137553865", - "851449379888163", - "851578437091222", - "851449352092699", - "851449352084242", - "851449352098074", - "851852022526000", - "851852363252975", - "851449379918452", - "851449379908386", - "851851994576975", - "851449352095287", - "851852363226689", - "851578437097005", - "856443226026068", "851851994605739", - "851449352088122", - "851851994595651", - "851449379903802", - "851851994538441", - "851852022539294", + "851852022568086", + "851852050487293", "851852109611001", - "851852022490226", - "856443101833098", + "851852137574077", "851852305347068", - "856443195830332", - "851851994568388", - "851449352079169", - "856443071682132", - "856443071682348", - "851449379913269", - "851852363178042", - "851852363280668", - "851449379895533", - "851852109592794", - "851851994552614", - "851449352101061", "856443071685912", - "851852022513407", - "851852109575493", - "851852022553289", - "856443226031481", - "851852137574077", - "856443226034513", - "856443195826546", - "856443071685048", - "851449324335306", - "851851994545327", - "856443071682024", - "851852363378351", - "856443195823193", - "851449379899518", - "851852363309869", - "856443071683104", + "856443101833098", "856443165656892", - "856443195821679", - "856443165655595", - "851852363340579", - "856443071684292", - "856443226023687", "856443195832388", - "856443226028666", - "851852050487293", - "851449352080760", - "856443195824815", - "856443071682672", - "851851994586063", - "851852363201710", - "851449324337990", - "851852022568086", - "856443165654406", - "856443226041227", - "856443353184384", - "856443353292680", - "856443352489291", - "856443353652207", - "856443256608967", - "857167556808962", "856443226188479", - "856443226155493", - "856443353526318", - "856443226077848", - "856443256628739", "856443257332003", - "857252181496807", - "856443354069989", - "856443352890413", - "857252181497353", - "856443257133833", - "856443226103757", - "856443256800236", - "856443257090289", - "856443226096710", - "856443353923660", - "856443256930173", - "857167524681510", - "857167525048439", - "856443256496025", - "856443256572362", - "856443257227900", - "856443354223862", - "856443226048808", - "856443226165909", - "856443256895156", - "856443256539347", - "856443257179667", - "856443256555419", - "856443352717734", - "856443352293065", - "856443226061917", - "856443226127506", - "856443352801889", - "856443353784545", - "856443226057258", "856443287817763", - "857167524860363", - "856443226052924", - "856443226066902", - "856443226176868", - "857167559625861", - "856443257046773", - "856443257278642", - "856443256590175", - "856443352355155", - "856443226090097", - "857167556118679", - "856443257005872", - "857167556337288", - "856443226111239", - "857167558886158", - "856443256649599", - "856443256861882", - "856443226136292", - "856443352983524", - "856443352637728", - "856443353081441", - "857167557330237", - "857167590910525", - "856443353406549", - "857252181498337", - "856443256771754", - "856443226119155", - "857167557063084", - "856443256744688", - "857167557611080", - "857167556567213", + "856443354223862", "857167525246145", - "856443226072212", - "856443352420531", - "856443226037762", - "856443256719038", - "856443256483109", - "856443256509704", - "857167558543096", - "857252181497790", - "857167557906380", - "856443256671548", - "856443256524145", - "856443256967042", - "857167559246750", - "856443226044909", - "856443226145621", - "857167558216796", - "857252181497025", - "856443352561653", - "856443384978968", - "856443256830242", - "856443226083810", - "856443256694694", - "859415688674399", - "859648867102138", - "859649532589559", - "859415835862797", - "859415688682834", + "857167559625861", "859415688699390", - "859415688675275", - "859649114579587", - "859649115683596", + "859415719307931", + "859415749925327", "859415835890469", - "859649147129486", - "859649564224501", - "859649147129148", - "859415688694345", - "859649532586387", - "859648866465221", - "859649621887522", - "859415870457381", - "859649724446463", - "859649532583441", - "859415835880035", - "859415870442652", - "859415688692152", - "859415688696758", - "859649532592958", - "859415870429574", - "859415870435948", + "859648867102138", "859648903753633", - "859415688690069", + "859648980583965", + "859649021429390", "859649115683708", - "859415688688096", + "859649147129486", "859649315219558", - "859649724421418", - "859415688678561", - "859649724409922", - "859649532580723", - "859648980583965", - "859649113529503", "859649532596584", - "859415870449796", - "859415688681300", - "859415835875313", - "859415688684478", - "859415688686232", - "859415719307931", - "859415749925327", - "859649756230254", - "859649724433598", - "859415870465406", - "859415835870921", - "859415719304859", - "859415688676261", - "859415835866749", - "859415688673633", - "859415688679876", - "859415835885087", - "859415688677356", - "859649021429390", - "859415835859065", - "859649724398998", - "920968369492125", - "920968369492447", - "921018369187835", - "920968369493576", - "920968369494383", - "920968369495351", - "920968369491964", - "921018369183149", - "920968369496480", - "920968369499709", - "921018369185411", - "920968369492931", - "920968369497771", - "921018369992230", - "921018789344181", - "921019056783073", + "859649564224501", + "859649621887522", + "859649724446463", "921018424496433", - "921018869815166", - "921018377646412", - "921033870927310", - "921030595395046", - "921018381174037", + "921018452418194", "921018481377726", - "921019071563220", - "921018834643179", - "921018678831926", - "921033913768994", - "921018817393742", - "921033870927150", - "921018408660907", + "921018510423443", + "921018539512112", + "921018568659831", + "921018598443583", + "921018624462038", "921018651518093", - "921018852185514", - "921033844825944", - "921033913769154", - "921033863639829", - "921018372695195", + "921018678831926", + "921018706230997", + "921018733662471", + "921018761352469", + "921018789344181", + "921018902653457", "921018922250728", + "921018942721559", + "921018963202877", + "921018983706570", + "921019005060503", + "921030610959283", + "921031077614823", "921033103097217", "921033729804203", - "921019086344137", - "921018624462038", - "921018761352469", - "921018817394545", - "921018401385438", - "921030599800107", - "921018733662471", - "921018374775153", - "921018706230997", + "921033788975379", + "921033807345352", + "921033826083159", + "921033844825944", + "921033870927310", + "921038052593441", "921038880158182", - "921018510423443", - "921038052593282", - "921018568659831", - "921030604243974", - "921039496051531", - "921030610959283", + "921039413247822", "921039436171464", - "921038052423651", - "921018424495467", - "921033103097057", - "921039463981415", + "921039496051531", "921039764442130", - "921019115957549", - "921018539512112", - "921030608736737", - "921018394415931", - "921019101144764", - "921040609779941", - "921018902653457", - "921040490631505", - "921033826083159", - "921039487094131", - "921018598443583", - "921038052593441", - "921019042043687", - "921040669506483", - "921018983706570", - "921030591340816", - "921033788975379", - "921018416468793", - "921019026863992", - "921018371314437", - "921018942721559", "921040309169736", - "921019005060503", - "921039413247822", - "921030591340656", - "921018424495950", - "921018424495628", - "921018817394063", - "921018389749044", "921040369925099", - "921018963202877", - "921018817393582", - "921018452418194", - "921018385086131", - "921031077614823", - "921018887445231", - "921018424495306", - "921039478460455", - "921040550060014", "921040431352103", - "921033807345352", - "921228155168907", - "921228155169066", - "921228132743937", - "921234904431867", - "921040717291346", - "921234904427581", - "921234847894285", - "921234904450617", - "921234847894922", - "921228101677977", - "921228146438999", - "921234847893490", - "921234848210198", - "921228155347659", - "921234900037192", - "921234847896674", - "921228156171553", - "921228101684033", - "921102463475396", - "921234912980106", - "921234847895718", + "921040490631505", + "921040550060014", + "921040609779941", + "921040669506483", "921040719720324", - "921234847897789", - "921234865755109", - "921228101676862", - "921234909500904", - "921234939741296", - "921234964927923", - "921234847900497", - "921234847893808", - "921234855035258", - "921234904961197", - "921228101675110", - "921228101679252", - "921234872297648", - "921234907784092", - "921228155744761", - "921234892568625", - "921228101682280", - "921102463474919", - "921234952284006", - "921102463475078", - "921234847899063", - "921234927879490", - "921234860232291", - "921234904428374", - "921234852712371", - "921234916948601", - "921228155169862", - "921234904453638", - "921234857563832", - "921228155545511", - "921234904447755", - "921228155169384", - "921228156622644", - "921228101674473", - "921234904440126", - "921234882368871", - "921234850458152", - "921234847974116", - "921234904436154", - "921234904464132", - "921234875644387", - "921234904434566", - "921041016109728", - "921234896105482", - "921234904437901", - "921234904427423", - "921228101675906", - "921234904427898", - "921234904429803", - "921234904442510", - "921234869022950", - "921234848054731", - "921234906344164", - "921228118779791", - "921234904445053", - "921228101680686", - "921234889118303", - "921234904456818", - "921234904460316", - "921234904429009", - "921234879001622", - "921234904433137", - "921234911234076", - "921234914765672", - "921234862965164", - "921234904430756", - "921234885736279", - "921234977644937", - "921377157102487", - "921377157049786", - "921364331699508", - "921377157043877", - "921377157109837", - "921364331694262", - "921377157144037", - "921364331700939", - "921235006824038", - "921377157212138", - "921364331682363", - "921377157056493", - "921377157186877", - "921377157125977", - "921364331679035", - "921234996001817", - "921364331686169", - "921364331845496", - "921364331697123", - "921364331688548", - "921414805128720", - "921364331681095", - "921364331695374", - "921364331690929", - "921377157153787", - "921377157041162", - "921414804981373", - "921379066055847", - "921377157242028", - "921364331692357", - "921364331687596", - "921377157199187", - "921235040991764", - "921377157090027", - "921364331686803", - "921377157084277", - "921377157164177", - "921234986331329", - "921377157026628", - "921364339468316", - "921235017831839", - "921414805170584", - "921377157031898", - "921364331689659", - "921377157038606", - "921377157226685", - "921377157033974", - "921414805310062", - "921377157332472", - "921364331702529", - "921414804949086", - "921377157078847", - "921414805532766", - "921414805472689", - "921377157117667", - "921377157376093", - "921364331685693", - "921364331698236", - "921414805261176", - "921414805015416", - "921414805051215", - "921377157353721", - "921364331694738", - "921377157046752", - "921377157029982", - "921414805214683", - "921414805415652", - "921414805088930", - "921379066080778", - "921364335478964", - "921377157036210", - "921377157064476", - "921377157275268", - "921364331678402", - "921377157096097", - "921377157134767", - "921377157258169", - "921414804889301", - "921364331679986", - "921377157052980", - "921377157293325", - "921414805361501", - "921377157060325", - "921364331683790", - "921377157175207", - "921377157068946", - "921377157073737", - "921414804918397", - "921235029064125", - "921364331685376", - "921364331696169", - "921377157028225", - "921377157025190", - "921377157312340", - "921452904658333", - "921452907574934", - "921452929600423", - "921452905415245", - "921452909443139", - "921452908136441", - "921452924948693", - "921452905722920", - "921452906641893", - "921452909812695", - "921452916040111", - "921414805596042", - "921452905565249", - "921452908757090", - "921452906063122", - "921452929542481", - "921452929651460", - "921452911964642", - "921452906246436", - "921452918806285", - "921452929681572", - "921452923594715", - "921452907848636", - "921452910609527", - "921452929440692", - "921452921081198", - "921452929569035", - "921452929445026", - "921452929637613", - "921452911490219", - "921452929507729", - "921452905136959", - "921452904885511", - "921452912463442", - "921452910201170", - "921452929534596", - "921452919915384", - "921452906439199", - "921452904769053", - "921452905008040", - "921452929464148", - "921452929666113", - "921452913538831", - "921452929715071", - "921452907314533", - "921452929624572", - "921452914727146", - "921452905888777", - "921452929440532", - "921452926371935", - "921452929501938", - "921452929578853", - "921452929446311", - "921452929461255", - "921452909091538", - "921452929470417", - "921452927867981", - "921452907078999", - "921452929697838", - "921452912987743", - "921452929467202", - "921452929473954", - "921452929455951", - "921452929733271", - "921452929451451", - "921452905272588", - "921452929441494", - "921452929527195", - "921452929589316", - "921452915367264", - "921452929486497", - "921452929442939", - "921452929496469", - "921452908438992", - "921452929443902", - "921452922306623", - "921452917751166", - "921452929491322", - "921452929447756", - "921452911038889", - "921452929453540", - "921452929520277", - "921452916747454", - "921414805762850", - "921452929458523", - "921452929772736", - "921452929559700", - "921452929550849", - "921452929442136", - "921452929481994", - "921452929513842", - "921452929752439", - "921452929612175", - "921414805662678", - "921452929477813", - "921452929441013", - "921452914118150", - "921452906854999", - "921452929449523", - "921520991079557", - "921520990487064", - "921452929816717", - "921452929794162", - "921452930165671", - "921520991196903", - "921521061128297", - "921521057453297", - "921452930470660", - "921520990113680", - "921520994429933", - "921520993406240", - "921520991450269", - "921452929865698", - "921452930306458", - "921521055912116", - "921520995343605", - "921521056660110", - "921520994154589", - "921520991881826", - "921452930012835", - "921521053912608", - "921452929892124", - "921452930358393", - "921520991730677", - "921521064504668", - "921521054540682", - "921520990180958", - "921520997279979", - "921452930210178", - "921452930413073", - "921521063313041", - "921452929920002", - "921520992383390", - "921452929840562", - "921520991586932", - "921520992568010", - "921521059184030", - "921520990861931", - "921520990326284", - "921520996255469", - "921452930257107", - "921520991320366", - "921521067110314", - "921520990251773", - "921521067108870", - "921456183809328", - "921521062188813", - "921520995786300", - "921452929949333", - "921520996752773", - "921520990968007", - "921520992762123", - "921452929980277", - "921521065768022", - "921520990404661", - "921521060127805", - "921520992207781", - "921521055206439", - "921521067107270", - "921520992966211", - "921521067108710", - "921520993892594", - "921521067109672", - "921520990573816", - "921520994719428", - "921520993643305", - "921521058293592", - "921452930047168", - "921520993180756", - "921520990761008", - "921452930083276", - "921521067109191", - "921520990665077", - "921520992040700", - "921452930123424", - "921520995023718", - "921521067346968", - "921521067327544", - "921521067113682", - "921521067112719", - "921521067114485", - "921521067337655", - "921521067120911", - "921521067112079", - "921521067116573", - "921521067355800", - "921521067112399", - "921521067122679", - "921521067112239", - "921521067339742", - "921521067349698", - "921521067332358", - "921521067325300", - "921521067335729", - "921521067344399", - "921555163096434", - "921521067113040", - "921521067330914", - "921521067325140", - "921521067326101", - "921521067112559", - "921521067329630", - "921521067352749", - "921555163107304", - "921521067328507", - "921521067115449", - "921521067111116", - "921521067124928", - "921521067326742", - "921521067119304", - "921521067325620", - "921521067333963", - "921521067117858", - "921521067341990", - "921939836829663", - "921939836803341", - "921555163519379", - "921939836844720", - "921939836816509", - "922214747360386", - "922214747358960", - "922214747388964", - "922214747383087", - "922214747392141", - "922214747377846", - "922214747365939", - "922214747380387", - "922214747359277", - "922214747364511", - "922214747373241", - "922214747361179", - "922214747359752", - "922214747385946", - "922214747375464", - "922214747362131", - "922214747371177", - "922214747358802", - "922214747363242", - "922214747369272", - "922214747367526", - "921939836870877", - "921939836836954", - "921793706547781", - "921939836852963", - "921939836809055", - "921939836914957", - "921939836902271", - "921939836797946", - "921793706543022", - "921555164366474", - "921939836890854", - "921939836861682", - "921939836880548", - "921939836822848", - "922214747356116", - "922214747410250", - "922214747408184", - "922214747395952", - "922214747643782", - "922214747627992", - "922214747429169", - "922214747651920", - "922214747425989", - "922214747655749", - "922214747665820", - "922214747420106", - "922214747492649", - "922214747609516", - "922214747557759", - "922214747664061", - "922214747397380", - "922214747655111", - "922214747669818", - "922214747661023", - "922214747639156", - "922214747454937", - "922214747395794", - "922214747399127", - "922214747629108", - "922214747659744", - "922214747625602", - "922214747656228", - "922214747402940", - "922214747398174", - "922214747440620", - "922214747406277", - "922214747478485", - "922214747656867", - "922214747412475", - "922214747449846", - "922214747472120", - "922214747646335", - "922214747485328", - "922214747526713", - "922214747630384", - "922214747404529", - "922214747401510", - "922214747637082", - "922214747674456", - "922214747688853", - "922214747658625", - "922214747649048", - "922214747536424", - "922214747633414", - "922214747631819", - "922214747667739", - "922214747460346", - "922214747682613", - "922214747581645", - "922214747624806", - "922214747679734", - "922214747569383", - "922214747508725", - "922214747500448", - "922214747654952", - "922214747655430", - "922214747422968", - "922214747677015", - "922214747517480", - "922214747432668", - "922214747657666", - "922214747641389", - "922214747662462", - "922214747672057", - "922214747625124", - "922214747546773", - "922214747466074", - "922214747627036", - "922214747635168", - "922214747445074", - "922214747595182", - "922214747626239", - "922214747436485", - "922214747395636", - "922214747624647", - "922214747400239", - "922214747417403", - "922214747685653", - "922214747396269", - "922214747396745", - "922214747414859", - "922214747698255", - "922214747699691", - "922214747692515", - "922214747694906", - "922214747709266", - "922214747716934", - "922214747695863", - "922214747725245", - "922214747714214", - "922214747701287", - "922214747694109", - "922214747704957", - "922214747728761", - "922232828041259", - "922214747711660", - "922214747730040", - "922232828071601", - "922232828067132", - "922214747724447", - "922232828043816", - "922232922726047", - "922232922856071", - "922232922815041", - "922232828076388", - "922232828105093", - "922232922742138", - "922232922780193", - "922214747703042", - "922232828062982", - "922232922871333", - "922214747727642", - "922232922750898", - "922232828092657", - "922214747696979", - "922214747724766", - "922232922769846", - "922214747733078", - "922232922718716", - "922214747707032", - "922232922904390", - "922232828052443", - "922232922827925", - "922214747693471", - "922214747724288", - "922232922841602", - "922233389474069", - "922232922733854", - "922232828059150", - "922232922760134", - "922232828098716", - "922214747692993", - "922232922887386", - "922232922802791", - "922232828049408", - "922214747726683", - "922214747725884", - "922214747731479", - "922232922791175", - "922232828081493", - "922214747734837", - "922232828046532", - "922232828038861", - "922232828034544", - "922232828055637", - "922233389472326", - "922214747692674", - "922232828036623", - "922232828086916", - "922232922945845", - "922232922944577", - "922214747719814", - "922232922922344", - "922632881799240", - "922233389493710", - "922233389476130", - "922625815606279", - "922625815607388", - "922632881801614", - "922632881794967", - "922632881796865", - "922557900484865", - "922233389492920", - "922632881791963", - "922632881798290", - "922632881812528", - "922233389493394", - "922625815605804", - "922632881792753", - "922233389491972", - "922632881788794", - "922632881788636", - "922632881790220", - "922233389492130", - "922632881841419", - "922233389484212", - "922632881789111", - "922632881843152", - "922625815605329", - "922632881833223", - "922233389493552", - "922632881806360", - "922632881794176", - "922625815603586", - "922632881789586", - "922625815606913", - "922625815602001", - "922625815600575", - "922632881838425", - "922557900487715", - "922632881835115", - "922632881792279", - "922632881796390", - "922632881845042", - "922233389487539", - "922625815605487", - "922632881825961", - "922632881787685", - "922632881803038", - "922632881832908", - "922632881791012", - "922233389478507", - "922632881795916", - "922233389493236", - "922632881793543", - "922632881804620", - "922632881792595", - "922632881820115", - "922632881832751", - "922625815599308", - "922632881800348", - "922632881792437", - "922632881792121", - "922632881839843", - "922632881788002", - "922632881822959", - "922632881793069", - "922632881836061", - "922632881847089", - "922557900485973", - "922557900485340", - "922632881829120", - "922233389491656", - "922632881814899", - "922632881810314", - "922632881808258", - "922625815607071", - "922632881837164", - "922233389491340", - "922632881797498", - "922632881796074", - "922632881833696", - "922632881832594", - "922632881817428", - "922632881834327", - "922233389481201", - "922557900486765", - "922632881788478", - "922648585918682", - "922632881851654", - "922632881881536", - "922632881886566", - "922632881887822", - "922648585893312", - "922648585894566", - "922648585933538", - "922632881887194", - "922648585933226", - "922703259285539", - "922632881886252", - "922648585934632", - "922632881873048", - "922648585888293", - "922648585910231", - "922648585888921", - "922648585915709", - "922703259263583", - "922648585889078", - "922648585940253", - "922632881849293", - "922703259267011", - "922648585937443", - "922632881862668", - "922648585933070", - "922648585929005", - "922648585907726", - "922703259257183", - "922648585935413", - "922648585912892", - "922703259267322", - "922703259265299", - "922648585925252", - "922648585901148", - "922703259256247", - "922703259279003", - "922632881854172", - "922648585890489", - "922632881865814", - "922632881856847", - "922648585897544", - "922648585892214", - "922703259260618", - "922632881887508", - "922703259275422", - "922703259285694", - "922632881887351", - "922648585921811", - "922648585887979", - "922703259259525", - "922703259277135", - "922703259271217", - "922632881859679", - "922703259262491", - "922648585889392", - "922648585888764", - "922703259269191", - "922703259256403", - "922703259266856", - "922703259258588", - "922648585891273", - "922703259261867", - "922703259283205", - "922703259272463", - "922703259257807", - "922632881869274", - "922703259266545", - "922703259286005", - "922648585938692", - "922632881886409", - "922703259273865", - "922648585936350", - "922648585889862", - "922703259262959", - "922648585934007", - "922632881886723", - "922648585905377", - "922703259256715", - "922648585940409", - "922703259264363", - "922648585895977", - "922648585899268", - "922648585940097", - "922703259286160", - "922703259270126", - "922648585903184", - "922703259267789", - "922703259262023", - "922632881877135", - "922632881887665", - "922632881887037", - "922703259268412", - "922703259262179", - "922703259281026", - "922632881886880", - "922703259266390", - "922817751889464", - "922782913473183", - "922817751906222", - "922786592891799", - "922786592860520", - "922786592892265", - "922817751912411", - "922817751904056", - "922786592887753", - "922817751900489", - "922817751903747", - "922786592896775", - "922817751902352", - "922786592893975", - "922817751914112", - "922786592874522", - "922786592894753", - "922817751951801", - "922786592861453", - "922817751890395", - "922817751895831", - "922817751891172", - "922817751902972", - "922824130964616", - "922786592895686", - "922817751897228", - "922817751915967", - "922817751890085", - "922817751933271", - "922786592863786", - "922817751922459", - "922824130972186", - "922817751939757", - "922786592892886", - "922817751903282", - "922817751902507", - "922817751927557", - "922786592872343", - "922817751890240", - "922817751905448", - "922786592868453", - "922786592870320", - "922786592892420", - "922782913473649", - "922786592859743", - "922817751936360", - "922817751907151", - "922817751966627", - "922817751910864", - "922817751904829", - "922817751908234", - "922817751943462", - "922817751892570", - "922824130938819", - "922786592884795", - "922817751902817", - "922824130944688", - "922817751898781", - "922817751903437", - "922786592890867", - "922824130950866", - "922786592893353", - "922817751920141", - "922817751903127", - "922786592862542", - "922817751904365", - "922824130980221", - "922817751930337", - "922817751891793", - "922817751917977", - "922817751894589", - "922817751893502", - "922786592891488", - "922786592866742", - "922786592892575", - "922786592865186", - "922786592876857", - "922817751961377", - "922817751889619", - "922817751903592", - "922817751889774", - "922817751902662", - "922786592898020", - "922817751909472", - "922786592891022", - "922786592879347", - "922824130957509", - "922817751903902", - "922817751947475", - "922786592891333", - "922817751890706", - "922817751924931", - "922786592881993", - "922817751956435", - "922786592899421", - "927165330903475", - "927165330992614", - "927165330876378", - "927165331021148", - "927165330913699", - "922824130997683", - "927165330877306", - "927165331031845", - "927165330892633", - "927165330879627", - "922824131027821", - "927630225887568", - "922824130988720", - "927630225774841", - "927165330900532", - "927165330984083", - "927165330936944", - "927630225892207", - "923695272794760", - "922824131007110", - "927634141404300", - "927630225885248", - "927630225621785", - "927165330968419", - "927630225592795", - "927630225579460", - "927630225882463", - "927630225884320", - "927165330931674", - "927630225709553", - "927630225903034", - "927630225880610", - "927630225886331", - "927165330890310", - "927165330942525", - "927630225824464", - "923695272782857", - "927165330873750", - "927630225908449", - "927165330881020", - "927165330917727", - "927165330926715", - "927630225900559", - "927165330874213", - "927630225799035", - "927630225606902", - "927630225690012", - "927630225566904", - "927630225879681", - "927630225881229", - "927630225911389", - "927630225751890", - "927630225905664", - "927630225881846", - "927630225730181", - "927165330948416", - "927165330886129", - "927630225879526", - "927630225898239", - "927630225851296", - "927630225890506", - "927630225879836", - "927165331043160", - "927630225671558", - "922824131017156", - "927630225654036", - "927165331001610", - "927630225881383", - "927165330878389", - "927165330884271", - "927630225880146", - "927630225888960", - "927630225881692", - "927630225882154", - "927630225896074", - "927165330874522", - "927630225882927", - "927165330874986", - "927630225894063", - "927165330961286", - "927165330875605", - "927165331011070", - "927630225882000", - "927165330897744", - "927165330882568", - "927630225637445", - "927630225883546", - "927634141404454", - "927165330895111", - "927165330909981", - "927165330976018", - "927165330888142", - "927165330906573", - "927165330922066", - "927165330954618", - "927165330874059", - "927996250319771", - "927634141416378", - "927996250391653", - "927997460858265", - "927996249731699", - "927997461058171", - "927634141478699", - "927634141817947", - "927634141425364", - "927634141467222", - "927634141611384", - "927996250546790", - "927996249958262", - "927996249772434", - "927634141551467", - "927634141690264", - "927996249556975", - "927997461059257", - "927997461058636", - "927634141404763", - "927634141412815", - "927634141708745", - "927996250467274", - "927997461066410", - "927997460765660", - "927634141407549", - "927996249471975", - "927996249498855", - "927634141598033", - "927997460955714", - "927997460677574", - "927634141472805", - "927634141461949", - "927996249588371", - "927634141418392", - "927996249908185", - "927634141514379", - "927997461058791", - "927634141422885", - "927996250186600", - "927634141728315", - "927996249656299", - "927997461065321", - "927996249815349", - "927634141409872", - "927996250066513", - "927996250251472", - "927634141506311", - "927996249692987", - "927634141427998", - "927634141440243", - "927634141656100", - "927996250010986", - "927997461058481", - "927634141573507", - "927634141436833", - "927634141625512", - "927634141585459", - "927634141793711", - "927634141408633", - "927997461062056", - "927634141672716", - "927997461060345", - "927997461058326", - "927634141406620", - "927634141405846", - "927634141430788", - "927997461059723", - "927997461062988", - "927997461061123", - "927634141484903", - "927997461058946", - "927634141452335", - "927634141405227", - "927996250124999", - "927634141433733", - "927997461062522", - "927996249621479", - "927634141531913", - "927634141447994", - "927997461063610", - "927634141522913", - "927634141414519", - "927634141420561", - "927997461064388", - "927634141498709", - "927634141640417", - "927634141562176", - "927996249527135", - "927634141541379", - "927634141456987", - "927634141770720", - "927634141443963", - "927997461062211", - "927634141491573", - "927634141411266", - "927996249860599", - "927634141748973", - "927997461085867", - "927997461102218", - "927997461074192", - "927997461069056", - "927997461102684", - "927997461124039", - "927997461113124", - "928108490767054", - "928108490850717", - "927997461121544", - "927997461150526", - "927997461119205", - "927997461126846", - "928030515632430", - "928113645341528", - "927997461078394", - "927997461098170", - "927997461094744", - "927997461103772", - "927997461109850", - "928030515619491", - "928030515625726", - "927997461102839", - "928113645406365", - "928108490682487", - "928108490655350", - "927997461111409", - "927997461140873", - "928108490703391", - "927997461156288", - "927997461083220", - "928108490986093", - "928108490913012", - "927997461108447", - "927997461127158", - "928108490782036", - "928108490692627", - "927997461132304", - "927997461102373", - "927997461166569", - "927997461126690", - "927997461184642", - "928108491013112", - "927997461080729", - "927997461129966", - "927997461107200", - "927997461101908", - "927997461147879", - "927997461133707", - "927997461072324", - "927997461076215", - "927997461103305", - "927997461067655", - "928108490870388", - "928108490797800", - "927997461136979", - "927997461170620", - "928108490960482", - "927997461106109", - "927997461102994", - "927997461070612", - "927997461105174", - "927997461102063", - "927997461135265", - "927997461117022", - "928108490752853", - "928108490832140", - "928030515639602", - "928108490936122", - "928108490726794", - "927997461153329", - "927997461143053", - "927997461127626", - "927997461189940", - "927997461131057", - "927997461104395", - "928108490739433", - "928108490814501", - "927997461088670", - "928113645311538", - "927997461159403", - "928108490663927", - "927997461162830", - "927997461129030", - "927997461138848", - "928108490891153", - "928113645373086", - "928030515613568", - "927997461114995", - "927997461145388", - "928108490672972", - "927997461128250", - "927997461174982", - "927997461091629", - "927997461179656", - "928108490714780", - "928030515647242", - "928113651056987", - "928113645441365", - "928113645694547", - "928113646256513", - "928113648357231", - "928113647543637", - "928113645478242", - "928113646420591", - "928113650167884", - "928113647145163", - "928113652869974", - "928113646509130", - "928113645558098", - "928113648007152", - "928113654684418", - "928113645744882", - "928113647404022", - "928113654196237", - "928113655197558", - "928113646803098", - "928113648177802", - "928113645601234", - "928113674717679", - "928113662907894", - "928113676260047", - "928113663841762", - "928113676263660", - "928113666939995", - "928113655736915", - "928113673254533", - "928113676263188", - "928113676279263", - "928113676262716", - "928113665855295", - "928113676256122", - "928113676256593", - "928113646180503", - "928113669278634", - "928113646700148", - "928113646108251", - "928113648545909", - "928113661174157", - "928113649172153", - "928113676255651", - "928113671862592", - "928113646911375", - "928113664823390", - "928113676258006", - "928113670538394", - "928113647025292", - "928113676258948", - "928113676269805", - "928113676281628", - "928113658877252", - "928113646336438", - "928113676257221", - "928113645797877", - "928113647271302", - "928113676275007", - "928113653731914", - "928113651384312", - "928113649900013", - "928113656899937", - "928113645517153", - "928113676271381", - "928113650449558", - "928113649402697", - "928113657526432", - "928113676268387", - "928113676273115", - "928113647844810", - "928113648952899", - "928113676255808", - "928113648744308", - "928113651728425", - "928113645646717", - "928113676266023", - "928113649645160", - "928113652470313", - "928113656303903", - "928113658184961", - "928113645974395", - "928113647690462", - "928113653290193", - "928113676264290", - "928113652090111", - "928113646602211", - "928113676265078", - "928113650745664", - "928113676277056", - "928113676262873", - "928113645853690", - "928113676261303", - "928113676267126", - "928113668080164", - "928113659605036", - "928113660370042", - "928113662019426", - "928113645912477", - "928113646039601", - "928548201366797", - "928548201357323", - "928548201377217", - "928548201426024", - "928548201432344", - "928153180768991", - "928153180738821", - "928153180840843", - "928548201353534", - "928153180744187", - "928548201434714", - "928548201435662", - "928548201371691", - "928153180829953", - "928153180905208", - "928113676299293", - "928153180877286", - "928548201327178", - "928113676303079", - "928548201322763", - "928548201349908", - "928548201354639", - "928548201351798", - "928548201446732", - "928548201324339", - "928113676284151", - "928548201323708", - "928548201349751", - "928548201352587", - "928548201414332", - "928548201386849", - "928153180762194", - "928548201346909", - "928153180890852", - "928548201351167", - "928548201369165", - "928548201350379", - "928548201380217", - "928548201355902", - "928153180852362", - "928153180810062", - "928548201350694", - "928548201399167", - "928548201350222", - "928113676295823", - "928548201383375", - "928548201444676", - "928548201420020", - "928548201390639", - "928548201325128", - "928548201442778", - "928548201323235", - "928548201333174", - "928153180819693", - "928548201329860", - "928153180749869", - "928548201374375", - "928153180776260", - "928548201403906", - "928548201358902", - "928548201432502", - "928548201335068", - "928548201451320", - "928113676289671", - "928548201433924", - "928548201453851", - "928548201344224", - "928548201339330", - "928548201362534", - "928153180800903", - "928548201439457", - "928548201350065", - "928548201438034", - "928548201394745", - "928548201433292", - "928548201337120", - "928153180755873", - "928548201432818", - "928548201322920", - "928153180792216", - "928548201448947", - "928153180864510", - "928113676286832", - "928153180784002", - "928113676292668", - "928548201328440", - "928548201341698", - "928548201331438", - "928548201408961", - "928548201326074", - "928548201436769", - "928113676307181", - "928548201360639", - "928153180729037", - "928548201441038", - "928153180733771", - "928548201364587", - "928717129001802", - "928548201508306", - "928717129004646", - "928717128959059", - "928717128979022", - "928717128973477", - "928717128978074", - "928548201456541", - "928717128979813", - "928717129016158", - "928717128982975", - "928717128964760", - "928717128963492", - "928717128984082", - "928717128959217", - "928717128961433", - "928717129006853", - "928717128978548", - "928548201481390", - "928717129033188", - "928548201521451", - "928717129044860", - "928717129006065", - "928548201472842", - "928548201462396", - "928717129007484", - "928717129011902", - "928717128980129", - "928717129056221", - "928717129005751", - "928717129011588", - "928717128985348", - "928717129006380", - "928717128980603", - "928717128979497", - "928717128967771", - "928717129020414", - "928717128991994", - "928717128962383", - "928717129015055", - "928717128996266", - "928548201491205", - "928717128975696", - "928717129002276", - "928548201486139", - "928717129041705", - "928717129010325", - "928717128960641", - "928717129070427", - "928717128981235", - "928717128988354", - "928717128990095", - "928548201465561", - "928717128978390", - "928717129005908", - "928717128982026", - "928717129048331", - "928717128966186", - "928717129009220", - "928717129022148", - "928717129017419", - "928717128986772", - "928548201502288", - "928717128998639", - "928717129011745", - "928717128994051", - "928717128979655", - "928717128959533", - "928717128958901", - "928717129065375", - "928548201459389", - "928717129018838", - "928548201469043", - "928717129014109", - "928717128978706", - "928548201514641", - "928717128969514", - "928717128978232", - "928548201496588", - "928717129030664", - "928717129008273", - "928717129001486", - "928717129060640", - "928717129035869", - "928717129001170", - "928717128971416", - "928717129012217", - "928717129026090", - "928717129003698", - "928717129052118", - "928717129013321", - "928717129028298", - "928717129024040", - "928717129002908", - "928717129012690", - "928717128960008", - "928717129038708", - "928548201476958", - "928717129001328", - "928717129070584", - "928717129079242", - "928717129106149", - "928717129072630", - "928717129114010", - "928717129125004", - "928717129104105", - "928717129073418", - "928717129070898", - "928717129089162", - "928717129093411", - "928717129091208", - "928717129117624", - "928717129110396", - "928717129101591", - "928717129101905", - "928717129076882", - "928717129107407", - "928717129229591", - "928717129113224", - "928717129112595", - "928717129117467", - "928717129075465", - "928717129111810", - "928717129110710", - "928717129114953", - "928717129071527", - "928717129213697", - "928717129147791", - "928717129117781", - "928717129101277", - "928717129111496", - "928717129171378", - "928717129101120", - "928717129187422", - "928717129078455", - "928717129070741", - "928717129095771", - "928717129117938", - "928717129111024", - "928717129119508", - "928717129136788", - "928717129130188", - "928717129256978", - "928717129081289", - "928717129077353", - "928717129238247", - "928717129085541", - "928717129071212", - "928717129102690", - "928717129098289", - "928717129162257", - "928717129118095", - "928717129278072", - "928717129128303", - "928717129176411", - "928717129132231", - "928717129103319", - "928717129206459", - "928717129101748", - "928717129087273", - "928717129166660", - "928717129118880", - "928717129141975", - "928717129082549", - "928717129123590", - "928717129247376", - "928717129080187", - "928717129267210", - "928717129120293", - "928717129150935", - "928717129072000", - "928717129110553", - "928717129100963", - "928717129116053", - "928717129122334", - "928717129077825", - "928717129083966", - "928717129139303", - "928717129126575", - "928717129071055", - "928717129117310", - "928717129108823", - "928717129144804", - "928717129121235", - "928717129154394", - "928717129111653", - "928717129105048", - "928717129112124", - "928717129193400", - "928717129199693", - "928717129158168", - "928717129134431", - "928717129118409", - "928717129074363", - "928717129221408", - "928717129077039", - "928717129076725", - "928717129102219", - "928717129181759", - "928717129314442", - "928717133991687", - "928717131871375", - "928717131348394", - "928717130056523", - "928717137245314", - "928717130921527", - "928717138583422", - "928717129826755", - "928717130353882", - "928717129512920", - "928717130109993", - "928724930236669", - "928717133293238", - "928717130423147", - "928717131596604", - "928717133514452", - "928717136458484", - "928717129446588", - "928717138114953", - "928717129868067", - "928717134248818", - "928717129619295", - "928717129426738", - "928717142607761", - "928717131469337", - "928717135416130", - "928717129714976", - "928717133082782", - "928717131233458", - "928717129681399", - "928717129301688", - "928717140137859", - "928724942762742", - "928717132511211", - "928717139075963", - "928717129467542", - "928717143306232", - "928717144812346", - "928717129327984", - "928717132175241", - "928717129649558", - "928724935722612", - "928717134519083", - "928717129911589", - "928717130288092", - "928724941210860", - "928717129489600", - "928717134803274", - "928717144040512", - "928717139593686", - "928717141943354", - "928717135102026", - "928717140709910", - "928717130738282", - "928717130496045", - "928717131020341", - "928717136093567", - "928717129373340", - "928724939734479", - "928717132692244", - "928717130225620", - "928724933362814", - "928717131730511", - "928724932268299", - "928717129957479", - "928717129289565", - "928717137669287", - "928724929294468", - "928724936993769", - "928717145623638", - "928717133747057", - "928717129750289", - "928717129390193", - "928724931227056", - "928717132882609", - "928717130572735", - "928717129563346", - "928717129590610", - "928717129342314", - "928717130653375", - "928717129537502", - "928724934513299", - "928724938329947", - "928724942763216", - "928717130827613", - "928717132339035", - "928717129407992", - "928717141311266", - "928717130005738", - "928717136842083", - "928717135746380", - "928717129357433", - "928717129787496", - "928717132019513", - "928717130166306", - "928717146476450", - "928724942762900", - "928717131124212", - "928724942767176", - "928724942763691", - "929127565882352", - "929042430815657", - "929042430712292", - "928724942834151", - "929042430676368", - "928724942794137", - "928724942819856", - "929127565883792", - "928724942764324", - "929042430980170", - "928724942776051", - "929042431092698", - "928724942776685", - "929042430648082", - "929127565889554", - "929042430684633", - "928724942777478", - "929042430661270", - "928724942829068", - "928724942796677", - "929042430770329", - "928724942783822", - "928724942782236", - "929042431033486", - "928724942779539", - "929127565893549", - "928724942775259", - "928724942765116", - "928724942771455", - "929042430850334", - "929042430909995", - "928724942778429", - "929042430832518", - "929042430799751", - "929127565892430", - "929127565890033", - "929127565894827", - "928724942775576", - "928724942824303", - "929127565889234", - "928724942799375", - "929042430733597", - "929042430757448", - "929127565886673", - "929042431193948", - "928724942791756", - "928724942769870", - "929042431006111", - "929127565663527", - "929042430654437", - "928724942802232", - "928724942805248", - "928724942768444", - "928724942815727", - "929127565883152", - "929042430784642", - "929127565887954", - "929127565702856", - "928724942787471", - "929127565787897", - "928724942808423", - "929127565889074", - "929042430693375", - "929042430722626", - "929127565882033", - "928724942811916", - "929042430702595", - "928724942780808", - "929127565890672", - "929127565882192", - "929042430642045", - "929042430668580", - "929127565744258", - "929042431062295", - "928724942789534", - "929127565888594", - "929127565884592", - "928724942839552", - "929042430932112", - "929127565888114", - "929127565888274", - "929042430888993", - "929042431124695", - "929127565891471", - "929042431158445", - "929127565882672", - "928724942766067", - "929127565833769", - "928724942785567", - "929042430745204", - "929042430869106", - "929127565885552", - "929042430955504", - "928724942775101", - "928724942773199", - "929223150839382", - "929131326385055", - "929133119234595", - "929133119305165", - "929846368234744", - "929131326417181", - "930117308144392", - "929133119267878", - "929144268207251", - "929846368232329", - "929277339762254", - "929144268205809", - "929131326393047", - "929264027455305", - "929133119306125", - "929144268201004", - "929131326386813", - "929131326425813", - "929133119305805", - "929133119204676", - "929277339761773", - "929144268200524", - "929131326413345", - "929133119165645", - "930117308140363", - "929223150840343", - "929264027455145", - "929144268204527", - "929846368235710", - "929131326459396", - "929144268201644", - "929131326409829", - "929223150839542", - "929133119177961", - "929131326446921", - "929133119285961", - "929131326406632", - "929144268203406", - "929131326473632", - "929133119306285", - "929133119305325", - "929131326403596", - "929223150840984", - "929131326398003", - "929264027456751", - "929131326395445", - "929277339760808", - "930117308149067", - "929133119305645", - "929133119190918", - "929133119122782", - "929846368233939", - "929133119113507", - "929133119250756", - "929846368232490", - "930117308146649", - "929133119305005", - "929131326400720", - "929131326466274", - "929131326421337", - "930117308142297", - "930117308136979", - "929133119142934", - "929144268207411", - "930117308138590", - "929846368233295", - "929846368232812", - "929131326452998", - "929277339761933", - "929131326383457", - "929144268202445", - "930117308135529", - "929133119153969", - "929131326441164", - "929264027455626", - "929131326489788", - "929131326388731", - "929133119219235", - "929131326430610", - "929131326481471", - "929131326435727", - "929133119132539", - "929846368236837", - "929131326390809", - "929223150839862", - "929264027456108", - "930800397944448", - "931070959211303", - "930117308157290", - "930800397987125", - "931070959250971", - "930800398001517", - "930800397953175", - "930800397968693", - "930800398026747", - "930117308151647", - "930800397974513", - "930800397937015", - "930800397980657", - "931070959115151", - "930800397917791", - "930800397958024", - "931070959046224", - "930228783024747", - "930800397922475", - "930117308154388", - "930800397920052", - "930117308167127", - "930800397994078", - "931232211297230", - "930800397908911", - "930800397940570", - "931280941648832", - "931070959175687", - "930304797083952", - "931280941608470", - "931070959102042", - "931280941466660", - "930800397927805", - "931070959066606", - "931070959129070", - "930800397930713", - "930228783023779", - "931070959230570", - "930228783022972", - "930800397910364", - "931070959319146", - "931280941832819", - "931280942123193", - "931280942123517", - "930141513671965", - "931070959089582", - "931280941885018", - "930800397963197", - "930800397913754", - "930800398009441", - "930117308163579", - "931280941570217", - "930800397925059", - "931070959370974", - "931280941691304", - "931316549881909", - "931280941939976", - "931280941533912", - "930800398017851", - "930117308171159", - "931280941736049", - "931070959295178", - "931280941783217", - "931070959056091", - "931316549883368", - "931280942123031", - "931070959193009", - "931316549883044", - "930800397911978", - "931280942058820", - "930141513671481", - "930800397915692", - "931070959344411", - "931280941499392", - "931070959159338", - "930800397948650", - "930117308160354", - "930117308170998", - "931316549882882", - "931232211267748", - "931070959143799", - "931070959272507", - "931280942124003", - "931070959077770", - "931280941997856", - "931316549881098", - "930800397933783", - "931316549931127", - "931316549929177", - "931736156534522", - "931316549920564", - "931736156525689", - "931736156542054", - "931736156522422", - "931736156533049", - "931736156569078", - "931736156530595", - "931736156499242", - "931316549907727", - "931736156544346", - "931736156507722", - "931736156626936", - "931736156527323", - "931316549890185", - "931736156508537", - "931316549893595", - "931316549941372", - "931736156514906", - "931736156505765", - "931316549928690", - "931736156527160", - "931316549891809", - "931316549937631", - "931316549933240", - "931736156588086", - "931736156558266", - "931736156529613", - "931316549930314", - "931736156619394", - "931736156509190", - "931679348365130", - "931736156510006", - "931316549902366", - "931736156525199", - "931316549939420", - "931316549899929", - "931736156555154", - "931316549895544", - "931316549932102", - "931679348364641", - "931736156561542", - "931316549934541", - "931686967389612", - "931316549910652", - "931736156537960", - "931316549924464", - "931736156552206", - "931316549936005", - "931736156549422", - "931736156546802", - "931736156520298", - "931736156605788", - "931679348365619", - "931316549929664", - "931736156524873", - "931316549928852", - "931316549888724", - "931736156573338", - "931316549913739", - "931736156539925", - "931736156512129", - "931736156501361", - "931316549943487", - "931736156565146", - "931736156516540", - "931736156599559", - "931736156582842", - "931736156528795", - "931736156507559", - "931736156593658", - "931316549887425", - "931736156510986", - "931736156528141", - "931736156527650", - "931736156526343", - "931736156524710", - "931736156504134", - "931736156577926", - "931316549886289", - "931316549904965", - "931316549916989", - "931316549884504", - "931316549883855", - "931316549897655", - "931679348364804", - "931736156500220", - "931316549885315", - "931736156536159", - "931736156612345", - "931736156531740", - "931736156508048", - "931736156518337", - "931736156513436", - "931736156502666", - "931736156634970", - "931736156847878", - "931736156871525", - "931736156643496", - "931736156816364", - "931736156795926", - "931736156718615", - "931736156746013", - "931736156765536", - "931736156783264", - "931736156868708", - "931736156843587", - "931736156768326", - "931736156773742", - "931736156769967", - "931736156705984", - "931736156761436", - "931736156771772", - "931736156803832", - "931736156786220", - "931736156788518", - "931736156810427", - "931736156766849", - "931736156853825", - "931736156652515", - "931736156812241", - "931736156731903", - "931736156832696", - "931736156694010", - "931736156862919", - "931736156801526", - "931736156762584", - "931736156805975", - "931736156760944", - "931736156791974", - "931736156662027", - "931736156872687", - "931736156787697", - "931736156873517", - "931736156787040", - "931736156871193", - "931736156797573", - "931736156761108", - "931736156789505", - "931736156786056", - "931736156761928", - "931736156839626", - "931736156826591", - "931736156865234", - "931736156860769", - "931736156848868", - "931736156875677", - "931736156789011", - "931736156823786", - "931736156869536", - "931736156848043", - "931736156869867", - "931736156802349", - "931736156850355", - "931736156786548", - "931736156869371", - "931736156874514", - "931736156790163", - "931736156872023", - "931736156764388", - "931736156868211", - "931736156807294", - "931736156780637", - "931736156763404", - "931736156803008", - "931736156877006", - "931736156818673", - "931736156871027", - "931736156778174", - "931736156821147", - "931736156794444", - "931736156849529", - "931736156852503", - "931736156788682", - "931736156829561", - "931736156870364", - "931736156848373", - "931736156799385", - "931736156793127", - "931736156814220", - "931736156804821", - "931736156775876", - "931736156851346", - "931736156835996", - "931736156867715", - "931736156790986", - "931736156856966", - "931736156801362", - "931736156801855", - "931736156682692", - "931736156808778", - "931736156672031", - "931736156858785", - "931736156867880", - "931736156855313", - "931736156908136", - "931736156878501", - "931736156909138", - "931736156909975", - "931736156893793", - "931736156893627", - "931736156897293", - "931736156900126", - "933873712003511", - "931736156912487", - "931736156900960", - "931736156896293", - "931736156890967", - "931736156898626", - "933873711998814", - "931736156886146", - "931736156888473", - "933873712004854", - "933873712001329", - "931736156898460", - "931736156916507", - "933873711999819", - "931736156899459", - "931736156913659", - "931736156907802", - "931736156880163", - "931736156898959", - "931736156894292", - "933873712039972", - "931736156909473", - "933873711999316", - "933873712055294", - "933873712066762", - "933873712011906", - "933873712054115", - "933873712000490", - "933873712006365", - "931736156920193", - "933873712046033", - "933873712076548", - "931736156894792", - "933873712059678", - "931736156918183", - "931736156911482", - "933873712068955", - "933873712034250", - "931736156908637", - "933873712038289", - "933873711998981", - "933873712057149", - "933873712082623", - "933873712048390", - "933873712036774", - "933873712035428", - "933873712031223", - "933873712043844", - "933873712079417", - "931736156908804", - "933873712073848", - "933873712018959", - "933873712053778", - "933873712002336", - "931736156904464", - "933873712056137", - "931736156920026", - "931736156908971", - "933873712009891", - "931736156895459", - "933873712054620", - "933873712062883", - "933873712064738", - "931736156881991", - "933873712030887", - "933873712031727", - "931736156905966", - "933873712024503", - "933873712027527", - "931736156903129", - "933873712033241", - "931736156907635", - "933873712008044", - "933873712014089", - "933873712021647", - "933873712082960", - "933873712053610", - "933873712041824", - "933873712032400", - "933873712071317", - "931736156910645", - "933873712030719", - "933873712050916", - "933873712082455", - "933873712016440", - "931736156914999", - "933873712061196", - "931736156893959", - "931736156883985", - "931736156901961", - "933873712058329", - "933873712090051", - "933890397215991", - "933873712087180", - "933873712561272", - "933873712108298", - "933873712117932", - "933873712121651", - "933873712170353", - "933873712724261", - "933873712185407", - "933873712231935", - "933890397232339", - "933873712221613", - "933890397202064", - "933890397205967", - "933890397198335", - "933873712084141", - "933873712125708", - "933873712254611", - "933890397202403", - "933873712688169", - "933873712481999", - "933873712091740", - "933873712157160", - "933873712177626", - "933873712088531", - "933890397201556", - "933873712097821", - "933890397223481", - "933890397220586", - "933873712095625", - "933873712193696", - "933873712394275", - "933873712100186", - "933873712093598", - "933873712151072", - "933873712105425", - "933890397202911", - "933873712621413", - "933873712084985", - "933890397201387", - "933873712507067", - "933890397202572", - "933873712211799", - "933873712279999", - "933873712590579", - "933890397201895", - "933873712130104", - "933890397199183", - "933873712083466", - "933890397213612", - "933890397210044", - "933873712266966", - "933873712111340", - "933890397221948", - "933890397204948", - "933890397196641", - "933890397203420", - "933890397200200", - "933873712293709", - "933873712458288", - "933890397217522", - "933873712139911", - "933890397231317", - "933873712357024", - "933873712435764", - "933873712242934", - "933890397227058", - "933873712085998", - "933890397215821", - "933873712339924", - "933890397208515", - "933890397197149", - "933873712308267", - "933873712653943", - "933890397231487", - "933890397219394", - "933873712114551", - "933873712145322", - "933873712533491", - "933873712375141", - "933873712163587", - "933873712202493", - "933890397196810", - "933873712134838", - "933873712102721", - "933890397216841", - "933890397229102", - "933890397225184", - "933873712414426", - "933890397211743", - "933890397207156", - "933890397216331", - "933890397231828", - "933890397218373", - "933873712323672", - "933890397204099", - "933890397215651", - "933890397197657", - "933890397242751", - "933890397234726", - "933890397275425", - "933890397349972", - "933890397235579", - "933890397291011", - "933890397267894", - "933890397237968", - "933890397269433", - "933890397283303", - "933890397264131", - "933890397261223", - "933890397240528", - "933960523141004", - "933890397241554", - "933890397281076", - "933960522416422", - "933890397285701", - "933890397249249", - "933890397255919", - "933890397233191", - "933960522426887", - "933890397247368", - "933960522462404", - "933890397267381", - "933960522449878", - "933890397279021", - "933960522611910", - "933890397273884", - "933890397272514", - "933890397233532", - "933960522397037", - "933960522591479", - "933890397239674", - "933890397307460", - "933890397337285", - "933890397238479", - "933960522760795", - "933960522926046", - "933890397293923", - "933960522388118", - "933890397325970", - "933890397267210", - "933960523047865", - "933890397364205", - "933960522572080", - "933960522406472", - "933960523005080", - "933890397297007", - "933890397237798", - "933960522656381", - "933960523141348", - "933890397331456", - "933890397356831", - "933890397288270", - "933890397251301", - "933960522964531", - "933960522854752", - "933890397267723", - "933890397238138", - "933960523140488", - "933960522889453", - "933890397234044", - "933960522438039", - "933890397236603", - "933960522504278", - "933890397233021", - "933960522489518", - "933960522379715", - "933890397238991", - "933890397253524", - "933890397320828", - "933890397245658", - "933960522536375", - "933960522732628", - "933960522553712", - "933890397343457", - "933890397311573", - "933960522821771", - "933890397303690", - "933960522680421", - "933960522705837", - "933960523140317", - "933890397300263", - "933890397268749", - "933890397244119", - "933960522475617", - "933960522790509", - "933960523140660", - "933890397268236", - "933890397316029", - "933890397258485", - "933960523092887", - "933890397270289", - "933890397277137", - "933890397271316", - "933960522519897", - "933960522633544", - "933960523140832", - "934274510651664", - "934274510634481", - "934274510638981", - "933960523142724", - "934274510663683", - "934274510665772", - "933960523159786", - "933960523145133", - "933960523148749", - "934274510633789", - "933960523143584", - "944443811786035", - "934274510649924", - "934274510640885", - "933960523152538", - "934274510645748", - "934274510645922", - "933960523152193", - "934274510651142", - "934274510632405", - "934274510648358", - "933960523156851", - "934274510640539", - "933960523153055", - "934274510636384", - "933960523144272", - "934274510649402", - "934274510652186", - "934274510646792", - "934274510637596", - "934274510644008", - "934274510641232", - "933960523158232", - "934274510641405", - "933960523155643", - "934274510646270", - "934274510632232", - "934274510654798", - "934274510652360", - "934274510661767", - "934274510650446", - "934274510649576", - "934274510653927", - "934274510660025", - "934274510647488", - "933960523141864", - "934274510642967", - "934274510642273", - "933960523161512", - "934274510645052", - "934274510653230", - "933960523152021", - "934274510644530", - "934274510633270", - "934274510640712", - "934274510632924", - "934274510657063", - "933960523163411", - "944603246601274", - "934274510651316", - "933960523142552", - "934274510652708", - "934274510644182", - "934274510629641", - "934274510632751", - "944663804227961", - "944745891525308", - "944603246601450", - "934274510641752", - "933960523153745", - "933960523154608", - "934274510658457", - "933960523150299", - "933960523165483", - "934274510651838", - "934274510655843", - "934274510635346", - "933960523147371", - "933960523146166", - "933960523143068", - "934274510643835", - "933960523167728", - "944757410085377", - "945326060111705", - "944757410079174", - "944757410078642", - "945408796113276", - "944757410081123", - "944899299581496", - "944757410083426", - "944899299575289", - "945408796111434", - "944757410082717", - "945326060116411", - "945326060117865", - "945326060116049", - "945326060114420", - "945326060115506", - "944899299588435", - "944757410082185", - "944757410078288", - "945326060112248", - "944899299573338", - "945326060119151", - "944839928759513", - "944899299583095", - "944899299579545", - "945326060112791", - "944899299587005", - "944899299572629", - "944881620448699", - "944839928759867", - "945408796112170", - "944899299586116", - "945408796111986", - "945408796114014", - "944899299585228", - "945326060118415", - "944899299581851", - "945326060118599", - "944899299587362", - "944757410084313", - "945086995481061", - "944899299585583", - "944839928759336", - "945326060121359", - "944757410081831", - "945326060111525", - "945408796112354", - "944899299572097", - "944899299577949", - "944757410077757", - "944899299583984", - "945326060122463", - "944899299576530", - "945326060120439", - "944899299586827", - "944899299581319", - "944899299587897", - "944745891525485", - "944757410078111", - "944899299571743", - "945326060118232", - "945326060115868", - "945326060117136", - "945408796112723", - "945326060115687", - "944757410080237", - "944757410079351", - "944757410079705", - "944881620447813", - "945326060117499", - "945326060111886", - "944757410081300", - "945408796111618", - "945326060119703", - "945326060118783", - "945408796111250", - "944881620447104", - "945326060113515", - "944757410080946", - "944757410086618", - "945326060117682", - "945326060116955", - "944899299585051", - "944745891525839", - "944899299588076", - "944757410077580", - "944899299582384", - "945258164673073", - "945326060117317", - "944757410081654", - "944899299574225", - "944839928759159", - "945443590000286", - "945443590224378", - "945408796117335", - "945672971075652", - "945443589962421", - "945443589985876", - "945443590024678", - "945672970834180", - "945672971053974", - "945672971072872", - "945672971129795", - "945408796116043", - "945443590106385", - "945672971061753", - "945443589990310", - "945672970873616", - "945443589955221", - "945672971128868", - "945443590047042", - "945672970915091", - "945672970796782", - "945443589974609", - "945408796114936", - "945443590031701", - "945672971092336", - "945443590131163", - "945443590283762", - "945443589978118", - "945672970761241", - "945443590466220", - "945443590406997", - "945443590055545", - "945672971078618", - "945672971100865", - "945672971054529", - "945672971004900", - "945443590005829", - "945443590144662", - "945672971130537", - "945443590064603", - "945443590435867", - "945672971053419", - "945443590262856", - "945443589995113", - "945672971063606", - "945443589965191", - "945443589959836", - "945672970958791", - "945672971133876", - "945443590329092", - "945821268662288", - "945672970727553", - "945443589957436", - "945443590095107", - "945672971096415", - "945443589981812", - "945672971110878", - "945672971122377", - "945443590189788", - "945443589971285", - "945443590379609", - "945672971116442", - "945672971088628", - "945672971058604", - "945672971070277", - "945443590305779", - "945443590118404", - "945672971128683", - "945672971132577", - "945443590173882", - "945672971060086", - "945443590039094", - "945443589951345", - "945672971056196", - "945672971067868", - "945821268664144", - "945672971065644", - "945443590018025", - "945672971053604", - "945672971081769", - "945672971057307", - "945672971129239", - "945443589953191", - "945443590206620", - "945443589968146", - "945408796118811", - "945672971055270", - "945443590084384", - "945672971135360", - "945443590243061", - "945672971105686", - "945443590011742", - "945443590158902", - "945672971085106", - "945443590074216", - "945443590353702", - "945672971131464", - "945821268670825", - "945821268701647", - "945821268690876", - "945821268666185", - "945821268707227", - "945821268742613", - "945821268887439", - "945821268705739", - "945821268757707", - "945821268682337", - "945821268715603", - "945821268783448", - "945821268756030", - "945821268693287", - "945821268692916", - "945821268754913", - "945821268844487", - "945821268807522", - "945821268760131", - "945821268708343", - "945821268692731", - "945821268685679", - "945821268691433", - "945821268689207", - "945821268695516", - "945821268698487", - "945821268690505", - "945821268676209", - "945821268689763", - "945821268679180", - "945821268721748", - "945821268724169", - "945821268794084", - "945821268700717", - "945821268696816", - "945821268908546", - "945821268771881", - "945821268859986", - "945821268944975", - "945821268668412", - "945821268691989", - "945821268719513", - "945821268692546", - "945821268919941", - "945821268755099", - "945821268702391", - "945821268802669", - "945821268774493", - "945821268868576", - "945821268690320", - "945821268673424", - "945821268746340", - "945821268693844", - "945821268712438", - "945821268691618", - "945821268824323", - "945821268851956", - "945821268696631", - "945821268703321", - "945821268777291", - "945821268830671", - "945821268877727", - "945821268729571", - "945821268697744", - "945821268732552", - "945821268790352", - "945821268694587", - "945821268739073", - "945821268769456", - "945821268812749", - "945821268709087", - "945821268798190", - "945821268707413", - "945821268786807", - "945821268726777", - "945821268710018", - "945821268707785", - "945821268701089", - "945821268756775", - "945821268697187", - "945821268717465", - "945821268713927", - "945821268704437", - "945821268758826", - "945821268755471", - "945821268735719", - "945821268767218", - "945821268689392", - "945821268711135", - "945821268897712", - "945821268780276", - "945821268700531", - "945821268765166", - "945821268761623", - "945821268699416", - "945821268932084", - "945821268818349", - "945821268837392", - "945821268763301", - "945821268750440", - "945821271133625", - "945821269252824", - "945841294898812", - "945841294907246", - "945821272379758", - "945841294921122", - "945841294943646", - "945821269078028", - "945841294905559", - "945821272379384", - "945841294898999", - "945841294916434", - "945841294899373", - "945821269169811", - "945821269004206", - "945821270389241", - "945821272018963", - "945821269283490", - "945841294924312", - "945821272379010", - "945841294926375", - "945841294929002", - "945841294922623", - "945821269349869", - "945841294916996", - "945821269808140", - "945821269195985", - "945821269121393", - "945821269696511", - "945821271399271", - "945841294941393", - "945841294930128", - "945841294919809", - "945841294938578", - "945821269223656", - "945841294944773", - "945841294931442", - "945841294926188", - "945821271263077", - "945841294934634", - "945821269505227", - "945821270302852", - "945821269039153", - "945821270068766", - "945821272380320", - "945821268988136", - "945821269463346", - "945841294901622", - "945821272379197", - "945841294927313", - "945821269423524", - "945821268958614", - "945841294900685", - "945841294904059", - "945821269549354", - "945821269058029", - "945821270575685", - "945821269931736", - "945821270893447", - "945821270782159", - "945821269099149", - "945821271010540", - "945821268973001", - "945841294928064", - "945841294926750", - "945821271693383", - "945841294941956", - "945841294902747", - "945821269021212", - "945841294918684", - "945821269385761", - "945821269595914", - "945821271852052", - "945821270480123", - "945821270142802", - "945821270220768", - "945821269644908", - "945841294915872", - "945841294911184", - "945841294936512", - "945841294947591", - "945821269868354", - "945821269750922", - "945821272194490", - "945821269315841", - "945821271542581", - "945841294942707", - "945841294941018", - "945841294913434", - "945821270676301", - "945821269144947", - "945841294916059", - "945841294940831", - "945841294946088", - "945841294932944", - "945841294917746", - "945841294909121", - "945821269998473", - "945841294899935", - "945841295236508", - "945841295248388", - "945841295267065", - "945841295271970", - "945841295132367", - "945841295023950", - "945841295231796", - "945841295239713", - "945841294963381", - "945841295230101", - "945841295270839", - "945841295263480", - "946048161678273", - "945841295160611", - "945841294966389", - "945841295209197", - "945841295238016", - "945841295241599", - "945841295228406", - "945841294957929", - "945841294960561", - "945841294993848", - "945841295004759", - "946048161682611", - "946048161683554", - "945841295227841", - "946048161685253", - "945841294949282", - "945841294999115", - "945841295293467", - "945841295256877", - "945841295285547", - "946048161677142", - "945841295017176", - "945841295074385", - "945841295046719", - "945841295293655", - "945841295107139", - "945841295251029", - "945841294984443", - "945841295038627", - "946048161673179", - "945841295231419", - "945841295245936", - "945841295271404", - "946048161681102", - "945841295295352", - "946048161679027", - "945841295243673", - "945841295235188", - "945841295010779", - "945841295290638", - "945841295227465", - "945841294951161", - "945841295031100", - "945841295277628", - "945841294953229", - "945841295229159", - "945841295233115", - "946048161679970", - "945841294988957", - "945841295175864", - "946048161684309", - "945841295232361", - "945841294980305", - "945841294972971", - "946048161675632", - "945841295146112", - "945841295095656", - "946048161682988", - "945841295272724", - "946048161677707", - "945841295271027", - "945841295192059", - "945841295231231", - "945841295274799", - "945841295283284", - "945841295234057", - "945841295260084", - "945841295227277", - "945841294969586", - "945841294955485", - "945841295253859", - "945841295084738", - "945841295064598", - "945841295281210", - "946048161686386", - "945841295294598", - "945841295287998", - "946048161674311", - "945841295276119", - "945841295279325", - "945841295273667", - "945841294976544", - "946048161682423", - "945841295119376", - "945841295055376", - "946048161677330", - "945841295294032", - "948085335913484", - "948085336034043", - "948085335912919", - "946590324570654", - "946590324570842", - "947585500808997", - "948085335941806", - "947585500810694", - "948085335935573", - "948085335927641", - "947585500811826", - "948085335923298", - "947206303615830", - "947416151679353", - "948085335913107", - "948085335966174", - "947416151675390", - "948085336075169", - "946048161687707", - "948085336027792", - "948085336064361", - "948085335912542", - "948085336064929", - "948085336024572", - "948085336074788", - "948085336019460", - "948085336042001", - "948085336029686", - "948085335938595", - "948085335948795", - "946590324571219", - "947585500809751", - "948085336066635", - "948085336003585", - "948085335918201", - "948085336031770", - "947416151676522", - "948085336063225", - "948085336063414", - "948085335916880", - "948085335919711", - "948085336045033", - "948085335977132", - "948085336074408", - "948085335945206", - "948085336063982", - "948085335914050", - "948085336036506", - "948085336022110", - "948085336039159", - "947585500808431", - "948085335983178", - "948085336074598", - "948085336065687", - "948085335961263", - "948085336074219", - "948085335932740", - "948085335996404", - "948085335930096", - "948085336023246", - "946590324571785", - "948085336070616", - "948085336069099", - "948085336072891", - "948085336072323", - "948085336019271", - "948085335915748", - "948085336072512", - "948085335912354", - "948085336011144", - "946590324570466", - "948085336019838", - "948085336063793", - "948085336055267", - "948085336059057", - "948085336051666", - "947416151677843", - "948085335925375", - "948085335971464", - "948085335989602", - "948085335952573", - "948085336048255", - "948085335914805", - "948085336067772", - "948085336020406", - "947585500808054", - "948085335956729", - "948085336073460", - "948085335921410", - "948085336021163", - "948085336026087", - "948946767647238", - "948085336079370", - "948085336077458", - "948099127201628", - "948099127176677", - "948418309747887", - "948418309568141", - "948099127139267", - "948085336082815", - "948099127162477", - "948946767648391", - "948946767567404", - "948099127253276", - "948085336077076", - "948418309695397", - "948085336090664", - "948085336084346", - "948099127165739", - "948085336076885", - "948099127156529", - "948099127153843", - "948085336091239", - "948372056529257", - "948099127244443", - "948418309606005", - "948085336090281", - "948099127140417", - "948085336081475", - "948418309671173", - "948946767495467", - "948099127146937", - "948085336078031", - "948085336086069", - "948946767649160", - "948085336075741", - "948085336087984", - "948418309776345", - "948946767650122", - "948372056575165", - "948099127221210", - "949006842268931", - "948099127185505", - "948418309720968", - "948085336080327", - "948418309626573", - "948099127141759", - "948946767651276", - "949006842267199", - "948099127145019", - "948099127190495", - "949006842262965", - "948372056632806", - "948099127169193", - "948946767647430", - "949006842267007", - "948085336077649", - "948946767462196", - "948372056562678", - "948418309806343", - "948099127262686", - "948372056602447", - "948099127195869", - "948418309550653", - "948418309586591", - "948946767606262", - "948418309648296", - "948372056550960", - "949006842267584", - "949006842264890", - "948099127214298", - "948099127172839", - "948099127149047", - "948946767530471", - "948099127236186", - "948372056588421", - "949006842268161", - "948099127159407", - "948085336076504", - "948946767652623", - "948085336076694", - "949006842269894", - "948085336092005", - "948099127207771", - "948946767647814", - "948946767654162", - "948372056539820", - "948099127151349", - "948085336090090", - "948372056617242", - "948099127180899", - "948099127228506", - "948099127143293", - "948085336078605", - "949006843055152", - "949006843042584", - "949006843120956", - "949006842338696", - "949006842321344", - "949006843075466", - "949006843079143", - "949006842271049", - "949006842393853", - "949153290162488", - "949006842722550", - "949006842303610", - "949006843143030", - "949006842299948", - "949006842277597", - "949006842345252", - "949006843091917", - "949006843045290", - "949006842384401", - "949006843042970", - "949006843053024", - "949006842282028", - "949006843043550", - "949006842881486", - "949006842492252", - "949006842918570", - "949006842275671", - "949006842542045", - "949006843068694", - "949006842560574", - "949006842812924", - "949006843042391", - "949006842669839", - "949006842751128", - "949006842273938", - "949006842311706", - "949006842524482", - "949006843071983", - "949006843083014", - "949006843042198", - "949006842307465", - "949006843047803", - "949006842998733", - "949153290113468", - "949006842403884", - "949153290124704", - "949006843059988", - "949006842352194", - "949006843114373", - "949006842296479", - "949006843096950", - "949056502314464", - "949006842290120", - "949006843057473", - "949006842437452", - "949006842695518", - "949006842622539", - "949006842284533", - "949006843046450", - "949006842645513", - "949006842600725", - "949153290102814", - "949006842846335", - "949006842375529", - "949006843051090", - "949006842449993", - "949006843062696", - "949006843044323", - "949006843049350", - "949006843108178", - "949006843102370", - "949006843065598", - "949006842359522", - "949006843087272", - "949006842326742", - "949006842293203", - "949056502296066", - "949006842316332", - "949006843042005", - "949006842957588", - "949006842425683", - "949006842781253", - "949006843127926", - "949006842272397", - "949056502304974", - "949153290149118", - "949006842414494", - "949006842279716", - "949006842580070", - "949006842367236", - "949153290176634", - "949006842463307", - "949006842287230", - "949006842332526", - "949153290136523", - "949006842507884", - "949006843135284", - "949006842477393", - "949153290223922", - "949411235199185", - "949153290381100", - "949153290326956", - "949411235225743", - "949153290313330", - "949411235185918", - "949411235186502", - "949153290423185", - "949153290444036", - "949153290455340", - "949411235195476", - "949153290433318", - "949411235225938", - "949411235239818", - "949411235208947", - "949411235218321", - "949411235225548", - "949153290260168", - "949153290309243", - "949411235189622", - "949153290304573", - "949153290388503", - "949411235231215", - "949153290307492", - "949153290315666", - "949153290396296", - "949153290413637", - "949411235189037", - "949411235188647", - "949411235238253", - "949153290241560", - "949411235241579", - "949411235193915", - "949411235170907", - "949153290302433", - "949411235236884", - "949153290345650", - "949153290305935", - "949411235191378", - "949411235206213", - "949411235228674", - "949153290303406", - "949153290333771", - "949411235247251", - "949153290361231", - "949153290279746", - "949153290191556", - "949411235233365", - "949153290207254", - "949411235244121", - "949153290318196", - "949411235186112", - "949411235226915", - "949153290300489", - "949153290330266", - "949411235235711", - "949153290320921", - "949411235190402", - "949411235243730", - "949411235192549", - "949153290479898", - "949153290301655", - "949411235243535", - "949411235233951", - "949153290467229", - "949153290341366", - "949411235244902", - "949411235234733", - "949411235227697", - "949411235246272", - "949411235229847", - "949411235187867", - "949153290374087", - "949411235203675", - "949153290311189", - "949411235226329", - "949411235188452", - "949411235232974", - "949153290367464", - "949411235187087", - "949411235232779", - "949411235215001", - "949153290355388", - "949153290404674", - "949411235221837", - "949411235244511", - "949153290493348", - "949153290323841", - "949411235244316", - "949153290337471", - "949411235188062", - "949153290350324", - "949411235211876", - "949411235201332", - "949153290300683", - "949153290301072", - "949411235197233", - "949411235245489", - "949411235262143", - "949411235460244", - "949411235248426", - "949411235471059", - "949411235329405", - "949411235326854", - "949411235463980", - "949411235534214", - "949411235325873", - "949411235253127", - "949411235533035", - "949411235533231", - "949411235533624", - "949411235384782", - "949411235542677", - "949411235332741", - "949411235379281", - "949411235544253", - "949411235251364", - "949411235330975", - "949411235344520", - "949411235396963", - "949411235324500", - "949411235289786", - "949411235350607", - "949411235281550", - "949411235324108", - "949411235323912", - "949411235476762", - "949411235257243", - "949411235334704", - "949411235453758", - "949411235299591", - "949411235458671", - "949411235479909", - "949411235336863", - "949411235357480", - "949411235514143", - "949411235508633", - "949411235456116", - "949411235486794", - "949411235285472", - "949411235374174", - "949411235462014", - "949411235483253", - "949411235434497", - "949411235365139", - "949411235535590", - "949411235249797", - "949411235418185", - "949411235325088", - "949411235328031", - "949411235466143", - "949411235535197", - "949411235277825", - "949411235410718", - "949411235526344", - "949411235347465", - "949411235537951", - "949411235544450", - "949411235426046", - "949411235542283", - "949411235294492", - "949411235498795", - "949411235369460", - "949411235310966", - "949411235535001", - "949411235455133", - "949411235317243", - "949411235542086", - "949411235267827", - "949411235544056", - "949411235353945", - "949411235454347", - "949411235473812", - "949411235536967", - "949411235259595", - "949411235539132", - "949411235457295", - "949411235443538", - "949411235468503", - "949411235490532", - "949411235494467", - "949411235543268", - "949411235305082", - "949411235453169", - "949411235264887", - "949411235339219", - "949411235274296", - "949411235520047", - "949411235341771", - "949411235536180", - "949411235255087", - "949411235540510", - "949411235390676", - "949411235270963", - "949411235403644", - "949411235503517", - "949411235453365", - "949411235361211", - "949411235548990", - "949432131618888", - "949432131654372", - "949411235544844", - "949432131652975", - "949432131608530", - "949432131653574", - "949432131611517", - "949432131607933", - "949432131625464", - "949432131607336", - "949411235550175", - "949432131648788", - "949411235551164", - "949432131618490", - "949432131659562", - "949432131616298", - "949411235550767", - "949432131681743", - "949432131622475", - "949432131607535", - "949432131663356", - "949411235545633", - "949432131645398", - "949432131609326", - "949432131601562", - "949432131676750", - "949432131639217", - "950025729146923", - "949432131677149", - "949432131642208", - "949411235550372", - "949432131672351", - "949432131620283", - "949432131652576", - "949432131631443", - "949432131627258", - "949432131679145", - "949432131602756", - "949411235548002", - "949432131664553", - "949432131677349", - "949432131602159", - "949432131655370", - "949432131612911", - "949411235547212", - "949411235545436", - "950025729151137", - "949432131623870", - "949432131621279", - "949432131667551", - "949432131652377", - "949411235546028", - "949432131677948", - "949432131656568", - "949432131633835", - "949432131674351", - "949432131607137", - "949432131601363", - "949432131619486", - "950025729145119", - "950025729146121", - "949432131678147", - "949432131679944", - "949432131680943", - "949432131661359", - "949432131678546", - "949432131663954", - "949432131614505", - "949432131668951", - "950025729148929", - "950025729149933", - "950025729147524", - "949432131681143", - "949411235546620", - "949432131657965", - "949432131610322", - "949432131601761", - "950025729145520", - "950025729147123", - "949432131676551", - "949432131605743", - "949432131629251", - "950025729148126", - "949432131636426", - "949432131666351", - "949432131618291", - "950025729144919", - "949432131663555", - "949411235546225", - "949432131603552", - "949432131604548", - "949411235550569", - "949432131670551", - "949432131665352", - "949432131681543", - "949432131677749", - "950092088177266", - "950092088198772", - "950092088144722", - "950258935859706", - "972810760392469", - "950258935858297", - "950092088157373", - "950092088199375", - "950092088185707", - "950092088204405", - "950258935862759", - "950258935862964", - "950092088190531", - "950092088196360", - "972673204890471", - "950258935861533", - "950092088150143", - "950092088204606", - "950258935855680", - "972810760391137", - "950092088166415", - "972673204888028", - "950258935862554", - "972139314218686", - "950092088173448", - "950092088148135", - "950255493807495", - "950258935860717", - "950258935859102", - "950255493807093", - "972139314218905", - "972673204876483", - "950258935857089", - "972673204879147", - "950258935858699", - "950258935861125", - "950258935855278", - "972673204882033", - "972810760394469", - "972810760391803", - "950092088154762", - "972673204883809", - "950092088195958", - "972673204878037", - "950092088160186", - "970040661811223", - "950258935861941", - "950092088200783", - "950258935861329", - "972673204893136", - "972810760391359", - "950092088181285", - "950092088199978", - "950258935859303", - "972673204885807", - "972810760390915", - "950258935860513", - "950258935856284", - "972673204880479", - "950092088196963", - "972673204877149", - "972673204875597", - "972673204875818", - "950258935858096", - "950092088169831", - "950092088163200", - "950092088197767", - "950092088195757", - "972810760393358", - "950092088202996", - "950092088152352", - "950092088198973", - "970040661811441", - "950092088146328", - "950258935860311", - "950092088201789", - "950258935858498", - "972673204896023", - "972673204876039", - "972959009739358", - "972959009778071", - "972959010174030", - "972959010982513", - "972959010145958", - "972959009735799", - "972959010896427", - "972959009732463", - "972959010047938", - "972959009867106", - "972959009855529", - "972959009935686", - "972959010267835", - "972959010506076", - "972959010969341", - "972959009791868", - "973035904014557", - "972810760403360", - "972959010979388", - "972959009920321", - "972959009807447", - "972959009834381", - "972959010119446", - "972959010711602", - "972959010006285", - "972959010965324", - "972959010302598", - "972959009726458", - "972959010972690", - "972959010965993", - "972959009751370", - "973020995554971", - "972959010984526", - "972959010983631", - "972959009987131", - "972810760399136", - "973035904017929", - "972959010094272", - "972959010377699", - "973020995553406", - "972959009743139", - "972959010770012", - "973020995554748", - "972959009815905", - "972959010982290", - "972959009784747", - "973035904019503", - "972959009844621", - "972959009799435", - "972959010968002", - "972959009905847", - "972810760405806", - "972959010974699", - "972959009729349", - "973020995555418", - "972959009771840", - "972959009747143", - "972959010553553", - "972959010026554", - "972959010964878", - "972959009755820", - "972959010418261", - "972959010831546", - "973035904015456", - "972959010656093", - "973020995560352", - "972959010976932", - "973020995560576", - "972810760397358", - "972959010964655", - "972959010966886", - "973020995557884", - "972959010982067", - "973020995555866", - "973035904013883", - "972959009760715", - "973020995556987", - "973020995556314", - "973020995555642", - "972810760395802", - "973020995559006", - "972959010982960", - "972959009892265", - "972959009951943", - "972959010603484", - "973035904016580", - "972959009824809", - "972959009766055", - "972959009879351", - "972959010339145", - "972959010461053", - "972959010970904", - "972810760401137", - "972959009969091", - "972959010070436", - "972959010203663", - "972959010234857", - "973035904038859", - "973035904021302", - "973035904127954", - "973035904139707", - "973035904131568", - "973035904028950", - "973035904141969", - "973035904035030", - "973035904032102", - "973035904059589", - "973035904132698", - "973035904086655", - "973035904029400", - "973035904129534", - "973035904124569", - "973035904071991", - "973035904067705", - "973035904028275", - "973035904028725", - "973035904141291", - "973035904033453", - "973035904046294", - "973035904134506", - "973035904130664", - "973035904043590", - "973035904062970", - "973035904164206", - "973035904030075", - "973035904129309", - "973035904123892", - "973035904178528", - "973035904111930", - "973035904077179", - "973035904143100", - "973035904125922", - "973035904147635", - "973035904055758", - "973035904134280", - "973035904161252", - "973035904083271", - "973035904136541", - "973035904135636", - "973035904125245", - "973035904137672", - "973035904106965", - "973035904144233", - "973035904030976", - "973035904080112", - "973035904168070", - "973035904158072", - "973035904142874", - "973035904141517", - "973035904094101", - "973035904129986", - "973035904025575", - "973035904064323", - "973035904175572", - "973035904061843", - "973035904134054", - "973035904052378", - "973035904069735", - "973035904123441", - "973035904059364", - "973035904158526", - "973035904146274", - "973035904102451", - "973035904124794", - "973035904117347", - "973035904166024", - "973035904159207", - "973035904162615", - "973035904139255", - "973035904145140", - "973035904151038", - "973035904023326", - "973035904126825", - "973035904059814", - "973035904172844", - "973035904149223", - "973035904153080", - "973035904060265", - "973035904049223", - "973035904074472", - "973035904098163", - "973035904090265", - "973035904028050", - "973035904140386", - "973035904157845", - "973035904160116", - "973035904123216", - "973035904041112", - "973035904036832", - "973035904139029", - "973035904142648", - "973035904170343", - "973035904134958", - "973035904060941", - "973035904155349", - "973035904065901", - "973035904143553", - "973035904231809", - "973035904202425", - "973035904221554", - "973035904182393", - "973035904564039", - "973035904196733", - "973035904216545", - "973035904255746", - "973035904264639", - "973035905082247", - "973035904251642", - "973035904216772", - "973035904218137", - "973035905577816", - "973035905589704", - "973035904217454", - "973035905577359", - "973035905367161", - "973035905579415", - "973035904199465", - "973035904224972", - "973035904212673", - "973035904186489", - "973035905577131", - "973035905580558", - "973035904418408", - "973035904483228", - "973035904862500", - "973035904542123", - "973035904287445", - "973035904378700", - "973035904433242", - "973035904209029", - "973035904260078", - "973035904181711", - "973035904587098", - "973035904188082", - "973035905594964", - "973035904223149", - "973035904185123", - "973035904465652", - "973035904366835", - "973035904326224", - "973035904189903", - "973035904391251", - "973035904987444", - "973035904355655", - "973035905187340", - "973035904269656", - "973035904183985", - "973035904227023", - "973035904448990", - "973035904294288", - "973035904191952", - "973035904237507", - "973035904404487", - "973035904943586", - "973035904281059", - "973035905592220", - "973035905583530", - "973035904229302", - "973035904637329", - "973035904216999", - "973035904693273", - "973035904501717", - "973035904317555", - "973035905581930", - "973035904275129", - "973035904183075", - "973035904194229", - "973035904335350", - "973035904240698", - "973035904247766", - "973035904521349", - "973035904244118", - "973035904219048", - "973035904345160", - "973035904611528", - "973035904664501", - "973035904309343", - "973035905595192", - "973035904234544", - "973035904301587", - "973035904181938", - "973035904220187", - "973035904205613", - "973035905304095", - "973035905585359", - "973035905033588", - "973035904723644", - "973035904789415", - "973035905433657", - "973035904902014", - "973035904755615", - "973035905133422", - "973035905587417", - "973035905503571", - "973035905578501", - "973035905244231", - "973035904825043", - "973035905595649", - "973088658098646", - "973088658090825", - "973059938486227", - "973035905602056", - "973035905603888", - "973059938444018", - "973035905640307", - "973035905640994", - "973035905634809", - "973059938490129", - "973059938449292", - "973035905644432", - "973035905613506", - "973088658101177", - "973088658092435", - "973059938455485", - "973088658157578", - "973035905605949", - "973059938509646", - "973088658134318", - "973059938480490", - "973059938494951", - "973088658121198", - "973088658147210", - "973035905623126", - "973088658155274", - "973088658096345", - "973059938508728", - "973035905600453", - "973059938509416", - "973035905619690", - "973035905596334", - "973035905595877", - "973035905641911", - "973059938507580", - "973059938466496", - "973035905639162", - "973059938484620", - "973088658113603", - "973088658094275", - "973088658148362", - "973035905630685", - "973088658129714", - "973035905597020", - "973059938508957", - "973059938488063", - "973059938441725", - "973088658149744", - "973035905646037", - "973035905599079", - "973088658144908", - "973035905597935", - "973088658145598", - "973035905610758", - "973059938446540", - "973059938508039", - "973059938462596", - "973059938510106", - "973035905639391", - "973088658162878", - "973088658165874", - "973088658151357", - "973088658125341", - "973035905608239", - "973088658088295", - "973059938474984", - "973059938500691", - "973035905639849", - "973035905643057", - "973088658139383", - "973059938503906", - "973059938507351", - "973088658145138", - "973059938458926", - "973059938482096", - "973035905626791", - "973059938452274", - "973059938481178", - "973088658153200", - "973059938510796", - "973059938483243", - "973035905639620", - "973059938492425", - "973059938470625", - "973088658110151", - "973088658103938", - "973035905616483", - "973088658160113", - "973088658106929", - "973059938479802", - "973088658117285", - "973088658146289", - "973059938497706", - "973059938480031", - "973088658089445", - "973035905647871", - "973059938479573", - "973088658388682", - "973088658274710", - "973088658408079", - "973088658570540", - "973088658334690", - "973088658482473", - "973088658557131", - "973088658255566", - "973088658386835", - "973088658404615", - "973088658439495", - "973088658348764", - "973088658380604", - "973088658393069", - "973088658510439", - "973088658716277", - "973088658308620", - "973088658216361", - "973088658379683", - "973088658451971", - "973088658180165", - "973088658381757", - "973088658655859", - "973088658690575", - "973088658466297", - "973088658651233", - "973088658238499", - "973088658424248", - "973088658230658", - "973088658762135", - "973088658415701", - "973088658398380", - "973088658615625", - "973088658383834", - "973088658193305", - "973088658223279", - "973088658650309", - "973088658675297", - "973088658411774", - "973088658744995", - "973088658521071", - "973088658433950", - "973088658321309", - "973088658666271", - "973088658428868", - "973088658678769", - "973088658458903", - "973088658380374", - "973088658686408", - "973088658654471", - "973088658203910", - "973088658699605", - "973088658285321", - "973088658379913", - "973088658663725", - "973088658246802", - "973088658710256", - "973088658651002", - "973088658382680", - "973088658198377", - "973088658657478", - "973088658659329", - "973088658209905", - "973088658661411", - "973088658694974", - "973088658669048", - "973088658491255", - "973088658599671", - "973088658632504", - "973088658172558", - "973088658188694", - "973088658296624", - "973088658652389", - "973088658737120", - "973088658381065", - "973088658363762", - "973088658653314", - "973088658753333", - "973088658176246", - "973088658385219", - "973088658474154", - "973088658419859", - "973088658390760", - "973088658704699", - "973088658729709", - "973088658184314", - "973088658401382", - "973088658169101", - "973088658395609", - "973088658532397", - "973088658445502", - "973088658682473", - "973088658264792", - "973088658584643", - "973088658500500", - "973088658672057", - "973088658544417", - "973088658651695", - "973088658722761", - "973088658650540", - "973144598182168", - "973144599988177", - "973088659134810", - "973144598597573", - "973144599674714", - "973144599134931", - "973144599827495", - "973144608827696", - "973088659051813", - "973088659346751", - "973088659388960", - "973144599016308", - "973088658855733", - "973144613079589", - "973088658903702", - "973144598335556", - "973144603684590", - "973088659105597", - "973144598111164", - "973144600522282", - "973144601867335", - "973144597754341", - "973144599529370", - "973088659306631", - "973144601614139", - "973144621142239", - "973144598418404", - "973144605676790", - "973144625097481", - "973088658981345", - "973088659198108", - "973144610794711", - "973144600335105", - "973144622395541", - "973144598796254", - "973088658841599", - "973088659232426", - "973144609450948", - "973088658828160", - "973144610106076", - "973144613920417", - "973144618815591", - "973144600926388", - "973144601373265", - "973144602413483", - "973144612279721", - "973088659165647", - "973144597918821", - "973144600157225", - "973144607134529", - "973144606624113", - "973088658792018", - "973144611518716", - "973144598256888", - "973088658803370", - "973144603017295", - "973144599391229", - "973144628082782", - "973088659027009", - "973144598903493", - "973144602133550", - "973144626552876", - "973088659003597", - "973144597704936", - "973144600719221", - "973144617736420", - "973144623712868", - "973144598505666", - "973088658870795", - "973144598043644", - "973088658771401", - "973144597658085", - "973144604819717", - "973144607671000", - "973088658815417", - "973144597979607", - "973144604044283", - "973144616709857", - "973144603342571", - "973088659078009", - "973144597861053", - "973144604422348", - "973088658781362", - "973144606138588", - "973144599259827", - "973144619949932", - "973088658886785", - "973088658940320", - "973144605237554", - "973144602707832", - "973144614804301", - "973144601144247", - "973144615733338", - "973144608234923", - "973144597806304", - "973088658921547", - "973088658960253", - "973088659268600", - "973144598694358", - "973144643619897", - "973144643573048", - "973144644707789", - "973144643737502", - "973144644646547", - "973144643999272", - "973144643505742", - "973144643605905", - "973144643974279", - "973144644533186", - "973144643511328", - "973144644588346", - "973144643566525", - "973144643598911", - "973144643608237", - "973144643502251", - "973144643761079", - "973144633158018", - "973144643649522", - "973144643726765", - "973144644431053", - "973144643507371", - "973144643513656", - "973144643536476", - "973144644256025", - "973144639052083", - "973144644181256", - "973144631381274", - "973144643560468", - "973144643501088", - "973144641221033", - "973144643600310", - "973144643595416", - "973144643549752", - "973144643631092", - "973144643500856", - "973144643595649", - "973144643773919", - "973144643509233", - "973144643928268", - "973144643748940", - "973144643682187", - "973144643545093", - "973144643587494", - "973144644480833", - "973144643516217", - "973144643540668", - "973144643596115", - "973144643519011", - "973144643554877", - "973144643690121", - "973144644296449", - "973144636988644", - "973144643613600", - "973144643950689", - "973144643580038", - "973144643504346", - "973144643655121", - "973144643667720", - "973144643525298", - "973144644146678", - "973144643886931", - "973144644217705", - "973144643603807", - "973144643627127", - "973144643707392", - "973144643528791", - "973144643610802", - "973144643616632", - "973144644383846", - "973144643503182", - "973144635025587", - "973144644338978", - "973144643801702", - "973144643816878", - "973144644772306", - "973144643601942", - "973144643522038", - "973144643907015", - "973144643868016", - "973144643597746", - "973144643635291", - "973144629690927", - "973144643850035", - "973144643698523", - "973144643623395", - "973144643644389", - "973144643596814", - "973144643639723", - "973144644113970", - "973144643832989", - "973144643501553", - "973144643674720", - "973144643532517", - "973144644025667", - "973144644082899", - "973144644053465", - "973144643661187", - "973144643787460", - "973144643716728", - "973194749407602", - "973194749418847", - "973144644840333", - "973144648369238", - "973144645330389", - "973194749432911", - "973194721459457", - "973194744930537", - "973144650816223", - "973194720523988", - "973194718787334", - "973209522344415", - "973144651196908", - "973209522358019", - "973144646569649", - "973144648892249", - "973194724562862", - "973194749413223", - "973194728166976", - "973144649174122", - "973144645149877", - "973194749429629", - "973194749408304", - "973144647269637", - "973194740878433", - "973144644987149", - "973144655035239", - "973194749426582", - "973144645997654", - "973194722442736", - "973144652459825", - "973144652924743", - "973144647896090", - "973144647081098", - "973194729493193", - "973144650109649", - "973144647676683", - "973194742853975", - "973194749436427", - "973194749409006", - "973144649470511", - "973194749416738", - "973144645427900", - "973194749407836", - "973194738999226", - "973144645638603", - "973194725704860", - "973194749440178", - "973144654467507", - "973209522338317", - "973194732352118", - "973144647468009", - "973144646269252", - "973144645871806", - "973194749411817", - "973194717215653", - "973209522322839", - "973194717981927", - "973194719633984", - "973209522350982", - "973194749421191", - "973194714519231", - "973194733892085", - "973144650454038", - "973194726905215", - "973194749408538", - "973144645530560", - "973209522327529", - "973144648624189", - "973194749414863", - "973144646901893", - "973144645237793", - "973144653413548", - "973144646415704", - "973194715793291", - "973194735510529", - "973144646130058", - "973194730887151", - "973194715133739", - "973209522318384", - "973144653927412", - "973194749409709", - "973209522314164", - "973144645752278", - "973194716486635", - "973144651596962", - "973209522332688", - "973194737211410", - "973144652017622", - "973144644911869", - "973144646731556", - "973144645066407", - "973144648126695", - "973194749423769", - "973194747113281", - "973194749410646", - "973194723476406", - "973144649782119", - "973209522432626", - "973209522400246", - "973209522552323", - "973209522684264", - "973209522485663", - "973209522832440", - "973209522365525", - "973209523929357", - "973209522390861", - "973209523529773", - "973209522982993", - "973209522571337", - "973209522534249", - "973209526381252", - "973209523396521", - "973209525268210", - "973232097148163", - "973209523461383", - "973209522373501", - "973209522591526", - "973209522799561", - "973209523677374", - "973209522410335", - "973209532152297", - "973209528185626", - "973209523220984", - "973209523118305", - "973209530747900", - "973209523757055", - "973209528499072", - "973209523276439", - "973209523334951", - "973209524966246", - "973209525782356", - "973209524022448", - "973209524120480", - "973209522471347", - "973209529922205", - "973209523601692", - "973209523025744", - "973209522738740", - "973209522421128", - "973209531660526", - "973209522381946", - "973209522942358", - "973232097779484", - "973209524566727", - "973209523840971", - "973209527077856", - "973209524332308", - "973209529539275", - "973209522457735", - "973209526833882", - "973209526601916", - "973209522768328", - "973209527887489", - "973209526171418", - "973209522612890", - "973209525430961", - "973209523168351", - "973209522659141", - "973232108414367", - "973232106172209", - "973232095433166", - "973232099874023", - "973209522710797", - "973232103202139", - "973232107265346", - "973232095976538", - "973209524826326", - "973209527603953", - "973232110891408", - "973209531192787", - "973209529174954", - "973232104143201", - "973209522517114", - "973209524223688", - "973209525113462", - "973209522903838", - "973232101455102", - "973209527334311", - "973209522867199", - "973209522444828", - "973232098443094", - "973232099140645", - "973209528828534", - "973232100644879", - "973232105132359", - "973209524446576", - "973232102306814", - "973209522635428", - "973209524693232", - "973209523070846", - "973209522500919", - "973209530324687", - "973209525971943", - "973209525602186", - "973232109622103", - "973232096547715", - "973232115100617", - "973232116649528", - "973333621970854", - "973333621828854", - "973337164209245", - "973232132259324", - "973232132291132", - "973333621929802", - "973333622019698", - "973232123678569", - "973232132272044", - "973232125666006", - "973337164415976", - "973337164080028", - "973337163969492", - "973337163936431", - "973337163875279", - "973232132259089", - "973337164307290", - "973337165592586", - "973333621905976", - "973333622121416", - "973232132274636", - "973337164819129", - "973232132267568", - "973337164670712", - "973337165713401", - "973333622077281", - "973337165974435", - "973337164360214", - "973333622170513", - "973333621884982", - "973232118277649", - "973337164041290", - "973333621842530", - "973232132259795", - "973337166263158", - "973333622197187", - "973333621895125", - "973337164899251", - "973232132262621", - "973337163905028", - "973337165477686", - "973337164601943", - "973333621835456", - "973232132265683", - "973337166754584", - "973333621858094", - "973232132295139", - "973337165166112", - "973333622037869", - "973333621917535", - "973337164743028", - "973232132303861", - "973333622056985", - "973232119988992", - "973333621986191", - "973232132308576", - "973337167126385", - "973232132269688", - "973333622098758", - "973337166418761", - "973232132280527", - "973333622002472", - "973232127755071", - "973232132287361", - "973333621942778", - "973337164983631", - "973232121787804", - "973337165264686", - "973337166115128", - "973337164004443", - "973337164256967", - "973232132283826", - "973232132313762", - "973232132299382", - "973337165840605", - "973337164536722", - "973333621866584", - "973232132261443", - "973232113627142", - "973337166935750", - "973337164120894", - "973232129950956", - "973333621822724", - "973333621850076", - "973333621875547", - "973232132264034", - "973337165072506", - "973333622145256", - "973232112225327", - "973333621956462", - "973232132277464", - "973337164474812", - "973337166582412", - "973232132260501", - "973337164163887", - "973337165368465", - "973337210908565", - "973337210975459", - "973337211143530", - "973337202269331", - "973337179915774", - "973337167326962", - "973337176887102", - "973337172376071", - "973337193639306", - "973337175585132", - "973337170713427", - "973337168767413", - "973337210910462", - "973337204268831", - "973337169998759", - "973337185758329", - "973337211127146", - "973337210905484", - "973337210903351", - "973337210902166", - "973337183613481", - "973337167993086", - "973337170347093", - "973337210901929", - "973337210982578", - "973337210906906", - "973337211240424", - "973337211218811", - "973337189404768", - "973337210914967", - "973337196835625", - "973337211339474", - "973337167537955", - "973337190746559", - "973337169352300", - "973337210904299", - "973337211025298", - "973337169052516", - "973337211015804", - "973337210968815", - "973337210930382", - "973337208579788", - "973337210951732", - "973337171928727", - "973337182618822", - "973337206370576", - "973337167759838", - "973337210902640", - "973337173860717", - "973337210912596", - "973337211070401", - "973337210926824", - "973337186913739", - "973337188128190", - "973337176219885", - "973337211006785", - "973337211312631", - "973337211198386", - "973337210920421", - "973337171098472", - "973337210956952", - "973337173340880", - "973337192156885", - "973337168238409", - "973337210934177", - "973337211367743", - "973337210990172", - "973337171503177", - "973337211035505", - "973337168496281", - "973337177588444", - "973337211097229", - "973337178325901", - "973337179101045", - "973337169667477", - "973337174981420", - "973337180772223", - "973337211179150", - "973337211046424", - "973337174407089", - "973337181672527", - "973337211263225", - "973337198557357", - "973337210946987", - "973337210962646", - "973337211111712", - "973337211058056", - "973337211160865", - "973337211083459", - "973337210917575", - "973337195197620", - "973337200367089", - "973337184659113", - "973337210998241", - "973337210923504", - "973337211397676", - "973337211287215", - "973337172846393", - "973337210942480", - "973337210938210", - "973337230222331", - "973337213769886", - "973337223785934", - "973337211911687", - "973337212765460", - "973337213095315", - "973337216016320", - "973337211534767", - "973337211429274", - "973337211614845", - "973337217194496", - "973337214840031", - "973337212167943", - "973337214091043", - "973337258676815", - "973337213344814", - "973337211658095", - "973337211703723", - "973337233380126", - "973337213926417", - "973337214264241", - "973337212482729", - "973337212666298", - "973337219041132", - "973337211970874", - "973337227503534", - "973337235763791", - "973337212317246", - "973337216877441", - "973337217878161", - "973337216575870", - "973337256334481", - "973337248073966", - "973337224457125", - "973337249987284", - "973337241307006", - "973337220889782", - "973337226684058", - "973337212979730", - "973337213620974", - "973337251998426", - "973337258672523", - "973337213479442", - "973337244521939", - "973337229270523", - "973337225162643", - "973337212869858", - "973337246253697", - "973337219469217", - "973337238397411", - "973337234542266", - "973337225904397", - "973337258678723", - "973337216289068", - "973337258671570", - "973337218246677", - "973337212572134", - "973337258683254", - "973337211497700", - "973337258685878", - "973337258680869", - "973337212098764", - "973337237047805", - "973337258670379", - "973337211751730", - "973337232274507", - "973337219919226", - "973337242874395", - "973337211802353", - "973337258670855", - "973337211855593", - "973337223147401", - "973337214638258", - "973337222540093", - "973337211462536", - "973337258691841", - "973337214446487", - "973337231222784", - "973337239815951", - "973337254112407", - "973337258675146", - "973337218634016", - "973337258688740", - "973337215510126", - "973337258673715", - "973337228364973", - "973337215756911", - "973337212397846", - "973337221412715", - "973337258670141", - "973337213216851", - "973337221962342", - "973337217527752", - "973337215275488", - "973337220392350", - "973337211573736", - "973337215052282", - "973337212033154", - "973337212240691", - "973337258695181", - "973468864703950", - "973337258827181", - "973337258725485", - "973684270708255", - "973337258852732", - "973337258913152", - "973337259387206", - "973337258720235", - "973337258988871", - "973337258744101", - "973684270706580", - "973337258930588", - "973337258866582", - "973337258784682", - "973337260174752", - "973453082747148", - "973337258758900", - "973684270716631", - "973684270709452", - "973337258710928", - "973337259057672", - "973684270706102", - "973337258706633", - "973337259575803", - "976389175563980", - "973337259033543", - "973337258896673", - "973337258775610", - "973684270707298", - "973337260544501", - "973337260649505", - "973337259430707", - "973337259685772", - "973337259138668", - "973468864705146", - "973337258794232", - "973337258702577", - "973337258839598", - "973337259269380", - "973684270712563", - "973337259083236", - "973337258804498", - "973337258698760", - "973337259010609", - "973684270705385", - "973684270705863", - "973337259524886", - "973337259629352", - "973337260093684", - "976389175594862", - "973337259168775", - "973337259807943", - "973337259306662", - "976389175556081", - "973337258881150", - "973337258968328", - "976389175568289", - "973337260444763", - "973337258737418", - "973684270714477", - "973337258815481", - "973337259110235", - "973684270730992", - "973337260016685", - "973684270724529", - "973337258767016", - "973337260260128", - "973337258948980", - "973337259345858", - "976389175572838", - "973684270719024", - "973337259200556", - "976389175577627", - "976389175559911", - "973468864702993", - "976389175582894", - "973337259873934", - "976389175601563", - "973684270710888", - "973468864702276", - "973337259943515", - "973684270721657", - "973453082746909", - "976389175588639", - "973684270727641", - "973337258715462", - "973337259234011", - "973337260350052", - "973337258731213", - "973337258751262", - "973337259745302", - "973337259476600", - "976407929872226", - "978397267397334", - "978072441546181", - "976523795555668", - "976407929834428", - "976540080918620", - "976407929852133", - "977044923514372", - "978397267388464", - "978397267364973", - "978086960290236", - "978397267392779", - "978397267353230", - "978397267376958", - "976407929818634", - "976435448712024", - "978397267419388", - "978397267352511", - "976407929861702", - "978397267351554", - "976540080917665", - "978397267433292", - "978592303291216", - "976425187497132", - "979431393305840", - "976547212156005", - "978397267358502", - "976786112157436", - "976425187498327", - "978397267535177", - "978397267362576", - "976407929871987", - "976425187501434", - "976786112156720", - "978397267352032", - "976407929843042", - "978397267509526", - "978397267449114", - "979431393355468", - "977065153661644", - "978397267407402", - "978397267380554", - "977044923514133", - "978190849184131", - "976786112156243", - "976425187496176", - "978397267440963", - "978397267384389", - "978397267370486", - "976547212154572", - "978397267355386", - "976472218628735", - "978086960289041", - "976425187499761", - "978397267486751", - "978397267413155", - "979431393337965", - "978397267521992", - "978397267360419", - "979431393321423", - "978190849185804", - "978190849189867", - "976407929872704", - "976407929826292", - "978397267476443", - "978364317474216", - "978397267426100", - "978397267354188", - "978397267351793", - "978397267373602", - "978190849187716", - "978397267367610", - "978397267497779", - "978397267466854", - "978397267356824", - "978397267457744", - "978397267402128", - "979431393373930", - "979747808355650", - "979644389246716", - "979747809078945", - "979431393458812", - "979747808250780", - "979431393393351", - "979431393435792", - "979747808156229", - "979431393565279", - "979747823303982", - "979431393508689", - "979644389246237", - "979747816034033", - "979747809490269", - "979644389256789", - "979431393564561", - "979644389331647", - "979747808472040", - "979747811580969", - "979644389284378", - "979644389307413", - "979747814076998", - "979644389254630", - "979431393535786", - "979747812828144", - "979747808744415", - "979747810969981", - "979747808903041", - "979747813117319", - "979747816487595", - "979747815602549", - "979747808112553", - "979644389262064", - "979747819740762", - "979644389252711", - "979747810287480", - "979747808071037", - "979747814801737", - "979747811366907", - "979747818546622", - "979747812042690", - "979747815192184", - "979747821771231", - "979747808670982", - "979747814430248", - "979747808202305", - "979747809606899", - "979747810786157", - "979747810445386", - "979747817992749", - "979747807994245", - "979644389249593", - "979747808534914", - "979747822518528", - "979644389261825", - "979644389357321", - "979747810137253", - "979747809173977", - "979431393413971", - "979747811806070", - "979644389251032", - "979747821060411", - "979747811163404", - "979747808601148", - "979431393483031", - "979644389412989", - "979747816964435", - "979747820384148", - "979431393564800", - "979644389248394", - "979747809994465", - "979747809274048", - "979747809858637", - "979747813421373", - "979644389247435", - "979644389259187", - "979747808031681", - "979747807925135", - "979747808988713", - "979747808412285", - "979747810611452", - "979644389262543", - "979644389384435", - "979747813741026", - "979431393564322", - "979431393565998", - "979747808821688", - "979747817465753", - "979747809379399", - "979747807893222", - "979747807958728", - "979747808301895", - "979747812553127", - "979747809729528", - "979747819128813", - "979747812291549", - "980012573167599", - "980012572464686", - "979747826983363", - "980012572757776", - "979747827038563", - "980012572576573", - "979747826870563", - "979747826913763", - "979747827095923", - "979747824129513", - "979747826869603", - "979747826868883", - "980012572977728", - "979747826923843", - "980012572517622", - "979747826871763", - "980012572386975", - "980012573338218", - "980012573688843", - "980012573116341", - "979747827148483", - "979747827026083", - "980012572727455", - "980012573278297", - "979747826942563", - "979747827167923", - "980012573537716", - "979747826886883", - "979747826935843", - "979747826896963", - "979747826929603", - "980012572621571", - "979747827014323", - "979747826890003", - "979747826876803", - "979747826949763", - "980012572387215", - "980012572490432", - "980012572388657", - "979747827130003", - "980012574248112", - "980012572789782", - "980012572393225", - "979747827051763", - "979747827065683", - "979747826868163", - "979747827003283", - "980012572671625", - "980012572387696", - "980012573221504", - "979747827112483", - "980012572395389", - "980012572598469", - "979747827080323", - "980012572698818", - "980012573611354", - "979747826918563", - "980012572389378", - "979747826992963", - "979747824997280", - "980012572823473", - "980012572393706", - "979747825909443", - "980012573021526", - "980012572936096", - "980012572546255", - "980012572388176", - "980012572896630", - "980012573946819", - "979747826965603", - "980012573467687", - "980012572440384", - "979747826868403", - "979747826878963", - "980012574359292", - "979747826900803", - "979747826873203", - "980012572391542", - "980012573401268", - "980012572417285", - "980012573067730", - "979747826893363", - "980012572859089", - "980012572390340", - "980012574042116", - "979747826909203", - "980012574142467", - "979747826904883", - "980012572387936", - "980012573856335", - "979747826957443", - "980012573770423", - "980012572392985", - "979747826874883", - "979747826881363", - "979747826884003", - "979747826974243", - "980012572394427", - "980012572645876", - "980012574476247", - "980012575161373", - "980012575158727", - "980012575159688", - "980012574599219", - "980012575256960", - "980012575201091", - "980012575246605", - "980012575191704", - "980012575202294", - "980115291830698", - "980115291788782", - "980012575211685", - "980012575187852", - "980012575229747", - "980012575233600", - "980115291853825", - "980012575165705", - "980115291761081", - "980012575169797", - "980115292018849", - "980115291817690", - "980115291968980", - "980115292228685", - "980012575237694", - "980012575200130", - "980115291984639", - "980012575205906", - "980115292001262", - "980115291954284", - "980115291811908", - "980012575195797", - "980115291797213", - "980012575159207", - "980115291871652", - "980012575167631", - "980012575256720", - "980012575174852", - "980115291891647", - "980012575184241", - "980012575207592", - "980115291801790", - "980115291764694", - "980012575209518", - "980115292200016", - "980115291774812", - "980115292056913", - "980115291781315", - "980012575201572", - "980012575216742", - "980115291777943", - "980115291837925", - "980012575200851", - "980115291766862", - "980115292077632", - "980012575164020", - "980012575260330", - "980115292147015", - "980012575162576", - "980012575251422", - "980012575160410", - "980012575257441", - "980115291792877", - "980012575258163", - "980115291823953", - "980115291862498", - "980115292099555", - "980012574864895", - "980115291881288", - "980012575259126", - "980115291927061", - "980012575214093", - "980115291845634", - "980115292259040", - "980012575219632", - "980012574728688", - "980115291784928", - "980012575008081", - "980012575226135", - "980115292037399", - "980115292291082", - "980012575158967", - "980012575200370", - "980115291940311", - "980115291762767", - "980115291771921", - "980012575172204", - "980115292172793", - "980012575222763", - "980012575242029", - "980115291914534", - "980012575204461", - "980115291902729", - "980115292122683", - "980012575203257", - "980012575180871", - "980115291806608", - "980115291769271", - "980012575177741", - "980115292324810", - "980115292523085", - "980115292669321", - "980115293358830", - "980115296450312", - "980115295163313", - "980115292479238", - "980115296425007", - "980115292723287", - "980115296430068", - "980155067630956", - "980115293645282", - "980115292840133", - "980155067633609", - "980115293039854", - "980115296453927", - "980115296187220", - "980115296458747", - "980115296440913", - "980115292618006", - "980155067623001", - "980115296460916", - "980115296443805", - "980115296426453", - "980115296463567", - "980115296462121", - "980155067625653", - "980155067669785", - "980115296435852", - "980115294662683", - "980115294511868", - "980115296478030", - "980115293751045", - "980115296468628", - "980155067657485", - "980115294232161", - "980115295746338", - "980155067629992", - "980155067661344", - "980115296424767", - "980155067639396", - "980115296475860", - "980115294102547", - "980115296465736", - "980155067644461", - "980115292360466", - "980115296431755", - "980115292437559", - "980115292903254", - "980155067629269", - "980115293979437", - "980115296446938", - "980115296428622", - "980115296472243", - "980155067641808", - "980115292969747", - "980115296425730", - "980115292780144", - "980115295542038", - "980155067650490", - "980155067628787", - "980115293862350", - "980115294368521", - "980115296462844", - "980115294821208", - "980155067647355", - "980115296458506", - "980115296427417", - "980115296464531", - "980115294987924", - "980155067632162", - "980115296459952", - "980115296467423", - "980115293191151", - "980115292569341", - "980115296467182", - "980115293544819", - "980155067635297", - "980115293449415", - "980115296458024", - "980155067637226", - "980115296470797", - "980115296459229", - "980155067665444", - "980115295961238", - "980115293113575", - "980115296457783", - "980115296467905", - "980155067628546", - "980115296469592", - "980115296433683", - "980115296425248", - "980155067653867", - "980115295347857", - "980115292398049", - "980115296438262", - "980115296462362", - "980115293272822", - "980115296473931", - "980155069419570", - "980155068045834", - "980155077757804", - "980155068597016", - "980155067787252", - "980155067764337", - "980155077756598", - "980155069977991", - "980155067753965", - "980155070107767", - "980155067841766", - "980155067684498", - "980155067718267", - "980155068396564", - "980155070387822", - "980155068073091", - "980155068020024", - "980155067857445", - "980155067827052", - "980155068198041", - "980155077767452", - "980155068491604", - "980155072816178", - "980155069233349", - "980155071040079", - "980155074347924", - "980155067950553", - "980155067679192", - "980155077754428", - "980155067735151", - "980155068987789", - "980155069065461", - "980155077770105", - "980155067674368", - "980155069147234", - "980155073688911", - "980155071224853", - "980155067703312", - "980155067710548", - "980155067744317", - "980155067813062", - "980155067874089", - "980155067929809", - "980155068352662", - "980155077773000", - "980155068132189", - "980155071419276", - "980155072553249", - "980155077754187", - "980155067799795", - "980155075881357", - "980155070538825", - "980155067775433", - "980155069626053", - "980155070697547", - "980155070864471", - "980155069854728", - "980155067972504", - "980155077755633", - "980155067696558", - "980155077776136", - "980155067995661", - "980155072303104", - "980155067726468", - "980155076315070", - "980155069324047", - "980155071838998", - "980155068843781", - "980155073383286", - "980155076770975", - "980155068542983", - "980155075076407", - "980155074010216", - "980155068653943", - "980155068101796", - "980155068913976", - "980155075468871", - "980155077760939", - "980155069737496", - "980155068233741", - "980155068442878", - "980155068777205", - "980155073092616", - "980155077762869", - "980155071623830", - "980155068271371", - "980155072065262", - "980155068310931", - "980155067910271", - "980155069520158", - "980155077250279", - "980155077759251", - "980155077765040", - "980155070244297", - "980155077754910", - "980155067891698", - "980155068164271", - "980155067690287", - "980155074702999", - "980155068714006", - "980155078257899", - "980155082191468", - "980155078227502", - "980155082429340", - "980155077860810", - "980155081545401", - "980155077967439", - "980155078098194", - "980155078121354", - "980155077810149", - "980155077843923", - "980155078568628", - "980155077786991", - "980155077828966", - "980155081965176", - "980155078668746", - "980155077779513", - "980155078289985", - "980155078035953", - "980155078017377", - "980155081350954", - "980155077822211", - "980155078969584", - "980155078478401", - "980155090814942", - "980155077890000", - "980155078359465", - "980155077999766", - "980155079113609", - "980155077869977", - "980155081749981", - "980155078902999", - "980155078839792", - "980155077879627", - "980155086897768", - "980155077952723", - "980155082942478", - "980155078198794", - "980155079646046", - "980155077783131", - "980155077983120", - "980155077901097", - "980155077836203", - "980155083218950", - "980155080823582", - "980155079273074", - "980155087881102", - "980155081166157", - "980155078397100", - "980155091494784", - "980155079751954", - "980155087377131", - "980155078722786", - "980155079039787", - "980155079863411", - "980155080513818", - "980155078522308", - "980155079449910", - "980155089552964", - "980155078436665", - "980155078171533", - "980155078617360", - "980155079359200", - "980155078779721", - "980155077791092", - "980155086441806", - "980155077804842", - "980155080233728", - "980155083815319", - "980155077815939", - "980155080103936", - "980155088967692", - "980155084136664", - "980155084829534", - "980155085202989", - "980155082679516", - "980155079980658", - "980155078076241", - "980155090168151", - "980155078145720", - "980155079191291", - "980155077912918", - "980155079545445", - "980155084474414", - "980155078055494", - "980155092209366", - "980155080990527", - "980155083509656", - "980155077925463", - "980155077795434", - "980155077852125", - "980155092960618", - "980155077938731", - "980155077800017", - "980155086008039", - "980155088410887", - "980155085595502", - "980155078323760", - "980155080370275", - "980155080664840", - "980155126155161", - "980155126132967", - "980155098346281", - "980155126662074", - "980155126493422", - "980155126126456", - "980155126355172", - "980155126427554", - "980155127731416", - "980155126242015", - "980155126208238", - "980155101707134", - "980155126262041", - "980155126131279", - "980155100530558", - "980155126187972", - "980155126167465", - "980155126470260", - "980155126126215", - "980155096369480", - "980155126176874", - "980155126182182", - "980155104243636", - "980155127094924", - "980155126940748", - "980155108555014", - "980155126310777", - "980155128018296", - "980155126894423", - "980155126989486", - "980155127822137", - "980155128476244", - "980155126129832", - "980155127563487", - "980155126201000", - "980155126134897", - "980155126172049", - "980155126273139", - "980155094580129", - "980155093750229", - "980155113561675", - "980155126159021", - "980155126389433", - "980155110141474", - "980155117340132", - "980155102943781", - "980155111808994", - "980155097333273", - "980155127485795", - "980155126731562", - "980155126284961", - "980155126148165", - "980155126128626", - "980155127411964", - "980155126215958", - "980155127645280", - "980155126232847", - "980155126448304", - "980155126808770", - "980155126543607", - "980155123762930", - "980155119375317", - "980155126371820", - "980155126194245", - "980155095452489", - "980155126142134", - "980155126251666", - "980155127917683", - "980155126127661", - "980155127040878", - "980155127211944", - "980155128235688", - "980155126570871", - "980155127151866", - "980155127341752", - "980155126297507", - "980155127275159", - "980155128352950", - "980155126126938", - "980155126145029", - "980155126695853", - "980155099411158", - "980155126339489", - "980155105609834", - "980155126137068", - "980155126163122", - "980155126850511", - "980155126629984", - "980155128124217", - "980155126151542", - "980155126769201", - "980155107045754", - "980155126408011", - "980155126517791", - "980155126599583", - "980155126224161", - "980155115403860", - "980155126324771", - "980155126139480", - "980155121514480", - "980155129195980", - "980156255283514", - "980155128742616", - "980156266606285", - "980156280686853", - "980156283490016", - "980284267078583", - "980156284999839", - "980156302582658", - "980156278149406", - "980155129538596", - "980155128886177", - "980156260974560", - "980156257229192", - "980156302580004", - "980156302610410", - "980156274787300", - "980284267063617", - "980156282053561", - "980156255057194", - "980156302614513", - "980156269399629", - "980284267160173", - "980156268648097", - "980156256907768", - "980156302581210", - "980156259534907", - "980156258688392", - "980155129723416", - "980156290008367", - "980156256602029", - "980156258295781", - "980156261504476", - "980156267933248", - "980156260470464", - "980284267086790", - "980156270189534", - "980284267173450", - "980156302577833", - "980284267044791", - "980156288255032", - "980156302584347", - "980155129917887", - "980284267114309", - "980156302606549", - "980155128606052", - "980156259101032", - "980156273773914", - "980156302618857", - "980156302602929", - "980156256034710", - "980156286586890", - "980156272809761", - "980284267217867", - "980156275852574", - "980156302579039", - "980156302623443", - "980284267050583", - "980156291851239", - "980284267124689", - "980155129037218", - "980156271892428", - "980284267104653", - "980284267135793", - "980156267253237", - "980155129362945", - "980284267147621", - "980284267070859", - "980156302577592", - "980156279386514", - "980156302588449", - "980156302586277", - "980156257567026", - "980156302590862", - "980284267056858", - "980156259990982", - "980156302599550", - "980156297964138", - "980156302578315", - "980156302596413", - "980156302593517", - "980156262061419", - "980156256311251", - "980284267095480", - "980284267187451", - "980156302628270", - "980156255521445", - "980156271019743", - "980156295824177", - "980156276972391", - "980156293788233", - "980156262646837", - "980156257922234", - "980156300213426", - "980156254841973", - "980284267202176", - "980156255771683", - "980284267234523", - "980284267406396", - "980284269606500", - "980284270060090", - "980284268781157", - "980284273713190", - "980284274130326", - "980284274068771", - "980284274075287", - "980284274070942", - "980284273053686", - "980284268685563", - "980284267462400", - "980284274114393", - "980284268075067", - "980284267632103", - "980284274184403", - "980284268138313", - "980284274069253", - "980284267803736", - "980284274194060", - "980284269901249", - "980284274097495", - "980284267333012", - "980284274281937", - "980284269216640", - "980284271666845", - "980284267757388", - "980284267252145", - "980284267356186", - "980284274093874", - "980284274090494", - "980284272180302", - "980284271428825", - "980284269099320", - "980284274227376", - "980284274077218", - "980284274119221", - "980284268987794", - "980284267594445", - "980284274150605", - "980284270402877", - "980284268881820", - "980284267433674", - "980284267713454", - "980284269469868", - "980284272747833", - "980284274267210", - "980284267558718", - "980284267903916", - "980284274101357", - "980284270227138", - "980284268275186", - "980284267311045", - "980284267492816", - "980284271202392", - "980284274331911", - "980284269750133", - "980284274314287", - "980284274079390", - "980284274105461", - "980284267957989", - "980284273375230", - "980284274253208", - "980284270587789", - "980284271917176", - "980284274124532", - "980284267270732", - "980284274081804", - "980284274068530", - "980284268426784", - "980284274239930", - "980284268014959", - "980284268349054", - "980284272456946", - "980284270782357", - "980284274166538", - "980284274109806", - "980284274204441", - "980284268508618", - "980284274084459", - "980284267290285", - "980284274072149", - "980284270987064", - "980284274073597", - "980284274175229", - "980284268204939", - "980284274069977", - "980284274215546", - "980284268594797", - "980284267852498", - "980284274297629", - "980284267671692", - "980284274158330", - "980284274143363", - "980284274136603", - "980284274087356", - "980284269339995", - "980284267524922", - "980284267380567", - "980412265752620", - "980284274350501", - "980284274711917", - "980284274932340", - "980412270454325", - "980284274486182", - "980412263585039", - "980412262822525", - "980412263304705", - "980412267904509", - "980412271488980", - "980412262934065", - "980284274460349", - "980284275861115", - "980284275588542", - "980412277663591", - "980284275154937", - "980284275218191", - "980284274751511", - "980412282498825", - "980412276832969", - "980284274983764", - "980412268671144", - "980412263441371", - "980488731338965", - "980412269084040", - "980412266292524", - "980412291650637", - "980284274837218", - "980412283619199", - "980412269518185", - "980412264062162", - "980412270958734", - "980412264422902", - "980412267211036", - "980412272046269", - "980412281433021", - "980412264237944", - "980412266583483", - "980284274542193", - "980412266015811", - "980284275506698", - "980284275355081", - "980284274435965", - "980412274575561", - "980284275674732", - "980284275428958", - "980488742722857", - "980284275094821", - "980412265264147", - "980488733007936", - "980284274638523", - "980284274674254", - "980412286034522", - "980412263051414", - "980284275037844", - "980412273895127", - "980412279454499", - "980412268278289", - "980412264617518", - "980284275284825", - "980412265037658", - "980284275961791", - "980284274883572", - "980412290140064", - "980284274513463", - "980412287335508", - "980412284796799", - "980488738544357", - "980488734762142", - "980488740581566", - "980284274604723", - "980412263895072", - "980412276042671", - "980412264822276", - "980412278536710", - "980412269974544", - "980284275765509", - "980412266889412", - "980284274412788", - "980412267549080", - "980412280419131", - "980284274793278", - "980284274370056", - "980488747339420", - "980488747339179", - "980488736606159", - "980412273247773", - "980488747339903", - "980412263174800", - "980412272632050", - "980412275290765", - "980284274390818", - "980412263736192", - "980412288702895", - "980488744973543", - "980412265502226", - "980284274572613", - "980488747352459", - "980488750939956", - "980488747389889", - "980488747585026", - "980488747875568", - "980488749958180", - "980488747498082", - "980488748203306", - "980488747813015", - "980488747429012", - "980488747372019", - "980488747661586", - "980488751554864", - "980488747437223", - "980488747455094", - "980488749233140", - "980488749691543", - "980488747340627", - "980488750101884", - "980488747364533", - "980488748700109", - "980488748365847", - "980488747347871", - "980488747552664", - "980488747445917", - "980488747368155", - "980488747537932", - "980488747350044", - "980488747358013", - "980488750754952", - "980488749132427", - "980488748154519", - "980488747568362", - "980488749568127", - "980488748022410", - "980488747464754", - "980488747731142", - "980488750411995", - "980488747342800", - "980488754066908", - "980488747475139", - "980488752270003", - "980488747784275", - "980488747361152", - "980488747945124", - "980488747523924", - "980488748777878", - "980488755602249", - "980488747982801", - "980488748626204", - "980488755189250", - "980488749821480", - "980488747486248", - "980488747344249", - "980488747843446", - "980488748254749", - "980488749450749", - "980488749036786", - "980488747407277", - "980488747421284", - "980488749339167", - "980488753101071", - "980488752810040", - "980488748425985", - "980488748555922", - "980488748108148", - "980488747909380", - "980488747395202", - "980488747706749", - "980488751339429", - "980488747510641", - "980488747640816", - "980488748489263", - "980488751134621", - "980488754796297", - "980488748308849", - "980488752019547", - "980488747385059", - "980488747602656", - "980488756036501", - "980488747621253", - "980488750579126", - "980488753407076", - "980488748859753", - "980488747345939", - "980488747355115", - "980488750253075", - "980488747341593", - "980488747683564", - "980488747380471", - "980488747756984", - "980488748064192", - "980488747376124", - "980488752533259", - "980488747414039", - "980488754422425", - "980488747400998", - "980488753728780", - "980488751781409", - "980488748945975", - "980488758565213", - "980488795806613", - "980488795765558", - "980488778174455", - "980488795833424", - "980488795765317", - "980488795774009", - "980488756972873", - "980488795964095", - "980488795802266", - "980488795978829", - "980488760414531", - "980488759767016", - "980488758007785", - "980488795872069", - "980488771318912", - "980488795794296", - "980488795770387", - "980488756492973", - "980488761095134", - "980488795798160", - "980488773858252", - "980488795768938", - "980488795784152", - "980488795781254", - "980488765057267", - "980488795790673", - "980488796011195", - "980488796109746", - "980488795778597", - "980488796982216", - "980488796852263", - "980488795787292", - "980488795912406", - "980488767954298", - "980488775225979", - "980488796183175", - "980488786969403", - "980488764183931", - "980488765975284", - "980488769020367", - "980488796409022", - "980488795924241", - "980488796681006", - "980488795766765", - "980488796087765", - "980488795816033", - "980488796448636", - "980488796792118", - "980488795994529", - "980488772556943", - "980488761810516", - "980488785030964", - "980488793399388", - "980488795811202", - "980488789006865", - "980488796534386", - "980488779762690", - "980488795936801", - "980488795827144", - "980488796132934", - "980488796210470", - "980488795901295", - "980488796047427", - "980488796335592", - "980488796371341", - "980488781432076", - "980488796490424", - "980488796629556", - "980488797052507", - "980488795847433", - "980488795766041", - "980488762562609", - "980488795890909", - "980488796580763", - "980488796239214", - "980488776663506", - "980488757477408", - "980488770141019", - "980488796269649", - "980488795863374", - "980488795950086", - "980488796066992", - "980488796301775", - "980488795776182", - "980488795881247", - "980488795855162", - "980488763353103", - "980488791148422", - "980488759151140", - "980488796915549", - "980488795772077", - "980488795821347", - "980488796028828", - "980488796157330", - "980488783186718", - "980488795767731", - "980488796735113", - "980488766940156", - "980488795840187", - "980488800973332", - "980488801075994", - "980488800960291", - "980488801405257", - "980488798384650", - "980488801223594", - "980488801058118", - "980488800965120", - "980488798679582", - "980488801352110", - "980488798838521", - "980488800997003", - "980488800963671", - "980488798528372", - "980488802960537", - "980488799181521", - "980488802481003", - "980488801042175", - "980488801824395", - "980488800446274", - "980488801464444", - "980488801144841", - "980488797286085", - "980488801034928", - "980488801261762", - "980488800982027", - "980488801304520", - "980488799005673", - "980488801158852", - "980488801131555", - "980488800962464", - "980488797765559", - "980488800992897", - "980488801434005", - "980488797204200", - "980488801775596", - "980488801643453", - "980488801096044", - "980488802567247", - "980488800966811", - "980488798117980", - "980488797877155", - "980488799366548", - "980488801173588", - "980488801929964", - "980488800968743", - "980488802321320", - "980488797659519", - "980488800961498", - "980488801049905", - "980488801118993", - "980488801016086", - "980488799561237", - "980488800208106", - "980488800960050", - "980488801986976", - "980488800696761", - "980488797372318", - "980488802177098", - "980488798247933", - "980488797558793", - "980488800960774", - "980488801205959", - "980488801729213", - "980488800985409", - "980488801189290", - "980488801327711", - "980488802047129", - "980488800978887", - "980488801530395", - "980488801282537", - "980488799981533", - "980488801001351", - "980488802753746", - "980488801028164", - "980488801066814", - "980488801005941", - "980488801242195", - "980488801685246", - "980488802110422", - "980488802658081", - "980488797463140", - "980488797126421", - "980488801603834", - "980488801566148", - "980488801875851", - "980488801021883", - "980488800975989", - "980488801377959", - "980488801496574", - "980488800989032", - "980488802854484", - "980488799766071", - "980488801010772", - "980488797994548", - "980488800970917", - "980488802247397", - "980488802399108", - "980488801085657", - "980488801107156", - "980488803072146", - "980488805403388", - "980488811100801", - "980488815434984", - "980488805892103", - "980488804200805", - "980488814038653", - "980488808045060", - "980488809225176", - "980488813390978", - "980488806155425", - "980488812774949", - "980488803313000", - "980488805641585", - "980488803579704", - "980488803189553", - "980488804376675", - "980488808812075", - "980488803442970", - "980488809659536", - "980488803874673", - "980488849486636", - "980488849484945", - "980488828853783", - "980488833391621", - "980488811631310", - "980488827485716", - "980488849398947", - "980488849420203", - "980488810596141", - "980488849398223", - "980488806432275", - "980488822646628", - "980488849448951", - "980488849401845", - "980488849399671", - "980488806723378", - "980488803723444", - "980488805176786", - "980488831802991", - "980488830291667", - "980488849409091", - "980488807029459", - "980488849404985", - "980488808419025", - "980488849439529", - "980488819600788", - "980488849478181", - "980488804033632", - "980488849435181", - "980488849479872", - "980488816187264", - "980488824945744", - "980488847031706", - "980488804756438", - "980488838661203", - "980488842638092", - "980488836816499", - "980488804561725", - "980488840600124", - "980488821580294", - "980488849406917", - "980488849483495", - "980488849454266", - "980488849403294", - "980488814719425", - "980488817808990", - "980488849475524", - "980488849474558", - "980488849480596", - "980488849460064", - "980488835061421", - "980488849473110", - "980488849414164", - "980488849398464", - "980488849400637", - "980488849482287", - "980488849481321", - "980488844780181", - "980488849423585", - "980488849431074", - "980488849427209", - "980488849417063", - "980488849473834", - "980488804961297", - "980488820565900", - "980488849476732", - "980488849466345", - "980488810116122", - "980488849480113", - "980488849411507", - "980488812188876", - "980488849473351", - "980488818682543", - "980488807351243", - "980488816977955", - "980488823767559", - "980488849444119", - "980488807689455", - "980488826184083", - "980488849498718", - "980488849780278", - "980488849861245", - "980488850021248", - "980488849516841", - "980488849839251", - "980488849521673", - "980488849591516", - "980488849598767", - "980488849745957", - "980488849715504", - "980488849488569", - "980488849529889", - "980488849532547", - "980488849572665", - "980488849675625", - "980488849519015", - "980488850167477", - "980488849557922", - "980488849688193", - "980488850171588", - "980488849517324", - "980488849518049", - "980488849762634", - "980488850258897", - "980488850206655", - "980488850222618", - "980488849535447", - "980488849520223", - "980488849505242", - "980488850087232", - "980488849538589", - "980488849908859", - "980488849652664", - "980488850346452", - "980488850176666", - "980488849512733", - "980488849501859", - "980488849884448", - "980488849527472", - "980488849549464", - "980488850186098", - "980488849562514", - "980488850250674", - "980488850053394", - "980488849545597", - "980488850202060", - "980488849525297", - "980488850123003", - "980488850160949", - "980488850307996", - "980488849606501", - "980488850216813", - "980488849567348", - "980488850211492", - "980488849495818", - "980488850197707", - "980488850179568", - "980488850276795", - "980488849584749", - "980488849553572", - "980488850161432", - "980488850160708", - "980488849818465", - "980488850163124", - "980488849493160", - "980488850189726", - "980488850345969", - "980488849701486", - "980488850332425", - "980488849730247", - "980488850164333", - "980488849642271", - "980488849632603", - "980488849508867", - "980488850242934", - "980488850267604", - "980488850162157", - "980488850182712", - "980488850296870", - "980488849663782", - "980488850169412", - "980488849623419", - "980488850165784", - "980488850193596", - "980488849798888", - "980488849934720", - "980488849541972", - "980488849490744", - "980488850345728", - "980488849578465", - "980488849962032", - "980488849990794", - "980488850174006", - "980488850235678", - "980488849614718", - "980488850319848", - "980488850286470", - "980488850228906", - "980488849523364", - "980488851074572", - "980488850374749", - "980488850508040", - "980488850588310", - "980488850378619", - "980488850396519", - "980488850910133", - "980488850544526", - "980488850518256", - "980488850465477", - "980488850443930", - "980488850350804", - "980488850361689", - "980488850491014", - "980488850676853", - "980488850832048", - "980488850560580", - "980488850359028", - "980488850477880", - "980488851036139", - "980488851079435", - "980488850598770", - "980488850354432", - "980488850461830", - "980488850609959", - "980488850387085", - "980488851087464", - "980488850413935", - "980488850364591", - "980488850427965", - "980488851083815", - "980488850367735", - "980488851085274", - "980488850349353", - "980488851072141", - "980488850468638", - "980488850462559", - "980488850786560", - "980488850727205", - "980488850348144", - "980488850452638", - "980488850382731", - "980488850435706", - "980488850407646", - "980488850512905", - "980488850356609", - "980488850503419", - "980488850882645", - "980488850856617", - "980488850475205", - "980488851078949", - "980488851081138", - "980488850487366", - "980488850470584", - "980488850347177", - "980488850569337", - "980488851078706", - "980488850391681", - "980488851077490", - "980488851086247", - "980488850466936", - "980488851084058", - "980488850464261", - "980488850939080", - "980488851002083", - "980488850462073", - "980488850745936", - "980488850969730", - "980488851082355", - "980488850494906", - "980488850621878", - "980488851084544", - "980488850709448", - "980488850401841", - "980488850472773", - "980488850578580", - "980488850499041", - "980488850662015", - "980488850530418", - "980488850352497", - "980488851077247", - "980488850463288", - "980488851073599", - "980488851075788", - "980488850420708", - "980488850634527", - "980488850480799", - "980488850692664", - "980488851080165", - "980488850552310", - "980488850537229", - "980488850765640", - "980488850808696", - "980488851072384", - "980488850647906", - "980488850483961", - "980488851072870", - "980488850524094", - "980488851077976", - "980488850371121", - "980488851088924", - "980488851256662", - "980488851094766", - "980488851694656", - "980488851159279", - "980488851284173", - "980488852534134", - "980488851140289", - "980488851478945", - "980488851592157", - "980488852061319", - "980488855561918", - "980488851102799", - "980488852310387", - "980488851454355", - "980488851210404", - "980488851408827", - "980488851561480", - "980488851858997", - "980488854349927", - "980488851772566", - "980488853330764", - "980488854021243", - "980488852006782", - "980488851092575", - "980488851099878", - "980488851732637", - "980488852703588", - "980488851299024", - "980488851954923", - "980488851105964", - "980488855116369", - "980488856892236", - "980488852795132", - "980488851532508", - "980488851191415", - "980488861303907", - "980488853586163", - "980488851270052", - "980488851182651", - "980488852993072", - "980488852118777", - "980488851113024", - "980488858224259", - "980488851220873", - "980488858601150", - "980488860311525", - "980488854713671", - "980488851134933", - "980488851152462", - "980488851121057", - "980488851331648", - "980488858997275", - "980488859851367", - "980488853212438", - "980488852381236", - "980488854909907", - "980488854527173", - "980488852891546", - "980488851504996", - "980488852455737", - "980488857200712", - "980488851905743", - "980488855801979", - "980488851314849", - "980488853455177", - "980488856054457", - "980488852179401", - "980488851125439", - "980488851130064", - "980488851387889", - "980488851090628", - "980488851349421", - "980488851624538", - "980488851244002", - "980488851232072", - "980488851146132", - "980488851368168", - "980488859413608", - "980488857525014", - "980488852243190", - "980488856319839", - "980488851174374", - "980488852616670", - "980488851166583", - "980488856598855", - "980488854181446", - "980488851116919", - "980488851814686", - "980488851200666", - "980488851109372", - "980488853868831", - "980488851658623", - "980488857865872", - "980488851097200", - "980488855333544", - "980488853099955", - "980488860795299", - "980488853723967", - "980488851430982", - "980531854906483", - "980488899923103", - "980531854969203", - "980488899983733", - "980488864950842", - "980531854915303", - "980488864264744", - "980488899963279", - "980488869870394", - "980488899942582", - "980488882168059", - "980488861838567", - "980488887220790", - "980531854907953", - "980531854906728", - "980531854975573", - "980488868064578", - "980488872940062", - "980488867227042", - "980488899901191", - "980488899999804", - "980488875257165", - "980488899903382", - "980488870843056", - "980531854925593", - "980488899947208", - "980488891034016", - "980488900008570", - "980488899952078", - "980488877817008", - "980488899904599", - "980488899909712", - "980488899976428", - "980488899991525", - "980488865672000", - "980531855080441", - "980488899934060", - "980531854932208", - "980488862400495", - "980488862991153", - "980488899901678", - "980531854928778", - "980531854911628", - "980531854997623", - "980531855123074", - "980488899900948", - "980531855055694", - "980531854963323", - "980488876505192", - "980531854935883", - "980531854943968", - "980488868944965", - "980488885451981", - "980488866430165", - "980488899902408", - "980488879195778", - "980531854957933", - "980488899919938", - "980488899907764", - "980531854910158", - "980531855005954", - "980488899914338", - "980531854982433", - "980531854953033", - "980488895246776", - "980488900017823", - "980488899969610", - "980488874069762", - "980488880644911", - "980531854948378", - "980531854939803", - "980531854922653", - "980488883769117", - "980488889079926", - "980488899957435", - "980488899911903", - "980488899938199", - "980488863612001", - "980488893087928", - "980531855044423", - "980488899917016", - "980488899930164", - "980531855067700", - "980488871865386", - "980531854908933", - "980488897515916", - "980531855033887", - "980531854913343", - "980531855139000", - "980531854907218", - "980531855108128", - "980531854919958", - "980488899926512", - "980531855093917", - "980488899906060", - "980531855024086", - "980531855014775", - "980531854989783", - "980531854917508", - "980531855212508", - "980531862870646", - "980531856628767", - "980531855783174", - "980531855948078", - "980531855733678", - "980531864680190", - "980531856140915", - "980531857563552", - "980531858193521", - "980531868862358", - "980531857424866", - "980531857048746", - "980531858023961", - "980531855599648", - "980531856449161", - "980531865192057", - "980531855890251", - "980531856009090", - "980531855387211", - "980531858757088", - "980531855484976", - "980531861731993", - "980531857293040", - "980531858964873", - "980531904036647", - "980531856366096", - "980531872882073", - "980531859654876", - "980531862092677", - "980531855686633", - "980531861062572", - "980531856725798", - "980531857167830", - "980531857862732", - "980531873813432", - "980531855835365", - "980531863289647", - "980531856827975", - "980531855279399", - "980531862471983", - "980531855521240", - "980531855358053", - "980531855173794", - "980531886189891", - "980531856073287", - "980531856935543", - "980531855233580", - "980531865730142", - "980531883198566", - "980531860752119", - "980531855418084", - "980531859908972", - "980531855559464", - "980531870351159", - "980531867514939", - "980531858559594", - "980531901636089", - "980531860176054", - "980531904036402", - "980531858371902", - "980531866295671", - "980531855450672", - "980531856287197", - "980531859183439", - "980531864193316", - "980531855155907", - "980531887801208", - "980531875821206", - "980531899352410", - "980531895112656", - "980531891274997", - "980531861388951", - "980531859413277", - "980531855255877", - "980531904037137", - "980531871153142", - "980531856536636", - "980531863730210", - "980531871996045", - "980531878039707", - "980531897179729", - "980531884656984", - "980531876902768", - "980531856212218", - "980531855642038", - "980531893146046", - "980531889494855", - "980531879234718", - "980531860456858", - "980531868171864", - "980531866890113", - "980531881810962", - "980531855330365", - "980531880490741", - "980531869588136", - "980531855304147", - "980531874792326", - "980531855192661", - "980531857709344", - "980531904112360", - "980531907502244", - "980531904434113", - "980531904913198", - "980531904082955", - "980531905579266", - "980531904863696", - "980531906065708", - "980531904965395", - "980531904163820", - "980531904037872", - "980531908785375", - "980531904062127", - "980531905270982", - "980531905758894", - "980531904043262", - "980531911602826", - "980531904197636", - "980531905139141", - "980531904223857", - "980531904303744", - "980531904069722", - "980531904174357", - "980531904385837", - "980531907887477", - "980531904342462", - "980531904409362", - "980531905958127", - "980531904210379", - "980531906993011", - "980531904460334", - "980531904135884", - "980531904047427", - "980531908543746", - "980531905417282", - "980531904041547", - "980531904127552", - "980531905203346", - "980531904049877", - "980531906839604", - "980531907323841", - "980531904363537", - "980531904517187", - "980531906298024", - "980531912420590", - "980531905855937", - "980531904040077", - "980531909306617", - "980531904729650", - "980531904322613", - "980531904238070", - "980531908313880", - "980531904045222", - "980531905078122", - "980531904038852", - "980531904689461", - "980531904185629", - "980531904144706", - "980531910519662", - "980531906693794", - "980531912001538", - "980531906178925", - "980531906423249", - "980531904253018", - "980531905342294", - "980531904488025", - "980531904105499", - "980531904154018", - "980531904065802", - "980531907689959", - "980531904055512", - "980531904651232", - "980531905496191", - "980531904816645", - "980531911223474", - "980531904087856", - "980531904772045", - "980531904548064", - "980531909882752", - "980531904580656", - "980531904268946", - "980531904058697", - "980531910862746", - "980531904078299", - "980531904285855", - "980531907154260", - "980531904073888", - "980531906555091", - "980531904052572", - "980531908095287", - "980531904093247", - "980531905666752", - "980531905020288", - "980531910193243", - "980531912861207", - "980531909039502", - "980531904614964", - "980531909587455", - "980531904099128", - "980531904119711", - "980531924721610", - "980531925683122", - "980531923972919", - "980531924077692", - "980531924591825", - "980531925589096", - "980531923968168", - "980531923959416", - "980531923983421", - "980531924281994", - "980531923927914", - "980531913324370", - "980531923941914", - "980531924089945", - "980531923930664", - "980531924331257", - "980531924820137", - "980531924018428", - "980531920285049", - "980531923924923", - "980531923939164", - "980531926942469", - "980531914861385", - "980531923929164", - "980531924306000", - "980531923925664", - "980531923955415", - "980531923924678", - "980531925258006", - "980531923936664", - "980531913811304", - "980531924259238", - "980531923934414", - "980531925116217", - "980531925185236", - "980531924002924", - "980531926637135", - "980531925499822", - "980531924873401", - "980531916021498", - "980531924447537", - "980531924066189", - "980531924116701", - "980531924217477", - "980531924102948", - "980531923948164", - "980531923995923", - "980531924026930", - "980531925415049", - "980531924552815", - "980531916646401", - "980531924386271", - "980531924010426", - "980531917303406", - "980531925050699", - "980531924358014", - "980531924988432", - "980531927107015", - "980531923926914", - "980531924045434", - "980531926495596", - "980531924162713", - "980531924515805", - "980531923963667", - "980531926233274", - "980531924929416", - "980531925334527", - "980531919482968", - "980531915426983", - "980531924769623", - "980531923925414", - "980531925886428", - "980531924035932", - "980531924480796", - "980531923944914", - "980531925782149", - "980531917993985", - "980531924632836", - "980531923932414", - "980531924416029", - "980531923977920", - "980531926785926", - "980531924237732", - "980531924131205", - "980531922945664", - "980531925996208", - "980531924179967", - "980531923951664", - "980531924676098", - "980531914323234", - "980531921128055", - "980531923989422", - "980531924146459", - "980531923926164", - "980531924055436", - "980531918719852", - "980531922014191", - "980531926111740", - "980531924198222", - "980531926361059", - "980531927653666", - "980531938909055", - "980531938168348", - "980531948756125", - "980531969292542", - "980531927855222", - "980531959229815", - "980531974090531", - "980531933900157", - "980531974386455", - "980531974074026", - "980531971623753", - "980531940506443", - "980531974151564", - "980531974430732", - "980531927462113", - "980531930208127", - "980531927280063", - "980531974328670", - "980531947536241", - "980531936155536", - "980531932053392", - "980531928771477", - "980531931646529", - "980531974104038", - "980531932481011", - "980531928524908", - "980531929891289", - "980531974077776", - "980531932930636", - "980531930541220", - "980531974214851", - "980531934422553", - "980531929030799", - "980531974083028", - "980531974076526", - "980531929303375", - "980531955856063", - "980531974251623", - "980531935548867", - "980531950038291", - "980531974075526", - "980531974184583", - "980531974194089", - "980531944221270", - "980531974204095", - "980531928067281", - "980531957500917", - "980531974074776", - "980531974279890", - "980531941366787", - "980531974126550", - "980531974175578", - "980531974112292", - "980531943222001", - "980531936793214", - "980531929589955", - "980531974138056", - "980531974074276", - "980531954291250", - "980531946375638", - "980531974100286", - "980531974108040", - "980531974116794", - "980531974081027", - "980531952802477", - "980531962957001", - "980531974366193", - "980531974295149", - "980531974407968", - "980531945271565", - "980531974167073", - "980531934971706", - "980531974480013", - "980531974132053", - "980531974121547", - "980531928290343", - "980531974346931", - "980531974085279", - "980531967074640", - "980531931259421", - "980531964964544", - "980531974087780", - "980531933403268", - "980531974454747", - "980531939687866", - "980531942271257", - "980531974226358", - "980531974265381", - "980531951385991", - "980531937463651", - "980531974159068", - "980531974093532", - "980531930891318", - "980531974311409", - "980531974238615", - "980531974096784", - "980531961047009", - "980531974144560", - "980531974079276", - "980531974664630", - "980531974506780", - "980531976382716", - "980531976935568", - "980531975078390", - "980531974824980", - "980531975334301", - "980531981042436", - "980531976145566", - "980531974629608", - "980531974596337", - "980531978217384", - "980531985124292", - "980531983555290", - "980531974781703", - "980531974535048", - "980531975649000", - "980532011203962", - "980531975931430", - "980531975199716", - "980531977256773", - "980531975483645", - "980531986308549", - "980531976645133", - "980531979453922", - "980531990660829", - "980532009386550", - "980531975407097", - "980531975738307", - "980531975022355", - "980531976261139", - "980531974969071", - "980531989842056", - "980531980358999", - "980532015121967", - "980531976035746", - "980531984052357", - "980531977429883", - "980531993376815", - "980531978440526", - "980532004447393", - "980531976510547", - "980531987617135", - "980531980692212", - "980532006012393", - "980531980042047", - "980531975137427", - "980531974870509", - "980531986946457", - "980531989063058", - "980531988322085", - "980531982632701", - "980531991521379", - "980531975564196", - "980531992425957", - "980531994376204", - "980531976786723", - "980531974564817", - "980531977611999", - "980532013114183", - "980531978675176", - "980532021781975", - "980531977092168", - "980531982204928", - "980532017232316", - "980531974740677", - "980531981410671", - "980532024232542", - "980531983082488", - "980531981797918", - "980531985701661", - "980531984574941", - "980531977803621", - "980531979181248", - "980531996530831", - "980531998911603", - "980532024232792", - "980531995426625", - "980531974701653", - "980531979740605", - "980532001541785", - "980531978921833", - "980532000193923", - "980532019450484", - "980531997691573", - "980531978005249", - "980532002958441", - "980532007657445", - "980531975832367", - "980531974918539", - "980531975265257" + "921041016109728" ], [ "20713453", - "18367466", - "17678025", - "18461591", - "16514224", - "17273875", "10369061723", - "29394748", - "48125059", + "18023755", + "18367466", "2244638781", - "17976183", - "16587381", + "29394748", "18061693", "19853920", - "16431439", + "48125059", + "18461591", "18584847", - "18023755", - "1087", "18610176", - "25845193", + "28388840", + "19357314", "20621441", - "90", - "539", - "89", - "30037240", - "44", - "134", - "4494134", - "28464052", - "17737484", - "227", - "90", - "134", "17980482", - "360", - "269", - "450", - "224", - "224", - "315", - "409", - "494", + "45837601", + "28464052", "26863230", - "180", - "19357314", - "674", - "497", - "500", - "44", - "224", - "27937525", - "271", - "29350169", - "28388840", - "997", - "45", - "28216998", - "452", - "272", - "225", - "360", + "26895192", "27548018", - "134", - "364", - "906", - "269", - "678", - "89", - "45", - "45837601", - "451", - "860", - "136", - "270", - "135", - "179", - "45", - "181", - "360", - "179", - "314", - "316", - "588", - "633", - "27965868", + "28216998", + "29350169", "29996843", - "769", - "724", - "314", - "318", - "361", - "359", - "135", - "179", - "629", - "90", - "815", - "315", - "89", - "225", - "584", - "542", + "30037240", + "25845193", + "27937525", "27963664", - "180", - "44", - "405", - "44", - "406", - "455", - "45", - "269", - "26895192", - "406", - "89", - "404", - "546", - "52062214", - "55671278", - "41588546", - "178", - "46232029", - "53585186", - "53756201", - "51923430", - "326819929", - "45", + "27965868", "3696127187", "51981307", - "52174026", - "51885952", - "44", - "89", - "53757357", - "54301984", - "322517", - "179", - "90", - "52223998", - "592", - "52000205", + "53538922", + "53595366", + "53648094", "53685792", + "53756201", + "53757357", + "46000793", + "54674835", "29428981", + "49172676", + "24247755", + "54301984", + "55671278", + "49932915", + "46232029", + "46290910", + "47092065", + "51746997", "51864871", - "358", - "951788", + "51885952", + "51923430", + "52000205", "52098447", - "513200", + "41588546", + "326819929", + "100315681", "46291635", + "115002884", + "53585186", + "57387245", + "52062214", "52154474", - "53595366", - "44", - "45", - "45", - "44", - "8862372", - "54674835", - "52723335", + "52174026", + "52223998", "52342953", - "14432", - "134", - "205664", - "52624240", - "110378", - "268", - "5580390", - "134", "52376533", - "49932915", - "153826", - "100315681", - "24247755", - "53648094", - "224", - "53538922", - "115002884", - "880520", - "46290910", - "313", - "89", - "46000793", - "49172676", - "44", - "47092065", - "51746997", - "23425", - "637", - "57387245", - "135", - "311", - "1429", - "87964643", - "1071", - "178657631", - "266", - "757", - "355", + "52624240", + "52723335", + "88959924", + "88965369", "88987154", "89226963", - "176422081", - "1698", + "87964643", "88019206", - "150727580", - "169767136", - "88959924", - "1923", - "1250", - "157116092", - "179761567", "128476264", - "176802174", - "712", - "534", - "174434688", - "170603520", - "243565730", - "444", - "847", - "44", - "1340", + "176422081", + "179761567", + "177208771", + "157116092", "130178393", - "222", - "891", - "1160", - "981", + "130809579", + "130344936", + "171857267", "177656305", - "802", "180167935", - "173242647", "175202642", - "1788", - "668", - "177", + "178657631", + "176802174", "180713665", - "171857267", - "130344936", - "578", - "164648641", - "1609", - "400", - "88965369", - "133", "195470410", - "177208771", + "243565730", + "164648641", "173229094", - "130809579", - "623", - "1519", - "489", - "88", - "252068631", - "1514981", - "168", - "168", - "333373694", - "41", - "127", - "329630473", - "170", - "242334532", - "42", + "174434688", + "150727580", + "173242647", + "169767136", + "170603520", "171422086", - "210", - "339088407", - "254287053", "208948785", - "339501066", - "304058411", - "257987098", - "234419925", - "258057037", - "7489536", - "269355157", - "258668967", - "253754318", - "239938588", + "254287053", "250834890", - "262436001", - "121707880", - "251389288", + "251075847", + "252483402", "252269929", - "379", - "210", - "319478781", - "84", - "258374985", - "42", - "336568008", - "338272825", - "339539367", - "41", - "255", "250015653", - "262442517", - "256062949", - "277302750", - "42", - "336567035", - "213", + "256254623", + "253754318", "252445162", - "320245877", - "258703377", - "261197174", - "252483402", + "258057037", + "234419925", "240379800", - "25157036", - "336600038", - "256254623", - "339707841", - "207344990", "257803262", - "338920919", - "126", - "260062721", - "337", - "143949165", - "336577785", - "84", - "85", + "257854008", + "257987098", + "121707880", "260664711", + "261197174", + "247564493", + "260062721", + "269355157", + "277302750", + "99855222", "175549097", - "1932101", - "84", - "343334644", - "342101711", "262030088", - "336639350", + "262436001", + "262442517", + "251829283", + "251357371", + "251389288", + "251914401", + "252068631", + "256062949", + "258374985", + "239938588", + "258668967", + "258703377", + "304058411", + "329630473", + "339501066", "339515551", - "6934316", - "257854008", - "295", + "339539367", + "339088407", + "342101711", + "343334644", + "336567035", + "336568008", + "336577785", + "336600038", + "336639350", + "207344990", + "143949165", + "25157036", + "242334532", + "338920919", + "333373694", + "339707841", + "338272825", + "330692562", "312499645", - "422", - "99855222", - "613981", - "251829283", - "126", + "319478781", + "320245877", "332498329", - "330692562", - "251914401", - "251357371", - "253", - "251075847", - "85", - "42", - "247564493", + "342009060", + "338352791", + "345828360", + "342748182", "342802390", - "374774809", - "124", - "166", - "83", + "341533463", "167916547", - "85645987252", - "83", - "41", - "275720986", - "83", - "298020741", - "278529398", - "296635210", - "124", + "289471581", "370210732", - "296437776", - "41", - "208540385", - "41", - "341533463", - "207", - "342748182", - "168088032", - "297887432", - "41", - "83", - "285761256", - "1088820", - "82", + "374774809", + "20738554", "343658176", + "181686465", "164585323", - "124", - "296185977", - "41", + "170338449", + "168169530", + "167640491", + "172803705", + "168088032", + "229976032", "172368151", - "124", - "308536751", "63603508", - "165", - "294377826", - "83", - "278503557", - "275619136", - "20738554", - "167640491", + "208540385", + "208569583", + "297887432", + "298020741", "270126585", - "41", - "249", - "41", - "345828360", - "170338449", - "338352791", - "289471581", - "168169530", - "82", - "296251326", - "293886727", + "294377826", "293130334", - "229976032", - "41", - "342009060", "308500185", - "208569583", - "172803705", - "181686465", - "41", + "308536751", + "278503557", + "278529398", + "275720986", + "275619136", + "285761256", "296334678", - "314005164", - "303582913", - "193", + "296635210", + "293886727", + "296185977", + "296437776", + "296251326", + "85645987252", + "266080393", + "272923038", + "325606305", + "325614427", "325619965", - "79", - "274324618", - "236", - "331365399", - "116", "331360723", - "19591107", - "325606305", + "331365399", + "303582913", + "304837328", + "307143810", "307145416", - "160", - "38", - "40", - "432", - "379823962", - "242447871", - "393", - "325614427", + "314005164", "301281919", - "307143810", - "272923038", - "742", - "40", - "111824210", - "549", - "703", - "116", - "232", - "39", - "120", - "304837328", - "626", - "77", - "140338927", - "193", - "488284987", - "77", + "274324618", + "242447871", + "19591107", + "379823962", "314837972", - "77", "110117398", - "155", - "38", - "471", - "665", - "77", - "266080393", - "118", - "155", - "26499554", "364214026", - "271", - "467371262", - "1011", - "543", - "476772245", + "26499554", + "111824210", + "488284987", + "140338927", + "485518686", + "396049165", "268156877", + "466564384", + "384235614", + "337764089", "451615254", - "205", - "77", - "670", - "738", - "453568001", - "193", "453591169", "449420296", - "337764089", - "621", - "38", - "396049165", - "855", - "567", - "116", - "485518686", - "478125750", - "468654147", - "360", - "451362163", - "479787381", - "476640464", - "478791673", - "102", - "498441933", - "384235614", - "463", "458938429", - "1323", - "39", - "412", - "1793", - "618", - "155", - "442671002", - "154", - "51", - "77", - "38", "459206981", - "457334705", - "57435154", - "483963881", + "476640464", + "498441933", "453333258", - "515", + "453568001", + "483963881", + "468654147", + "467371262", "467545999", + "476772245", + "478125750", + "478791673", "479723584", - "257", - "466564384", - "1401", - "773", - "8547", - "15198", - "722", - "1654", - "21834", - "6554", - "1861", - "4207", - "4467", - "3581", - "9018", - "60348", - "929", - "115926", - "1239", - "10536", - "1966", - "24199", - "73780", - "28196", - "10012", - "1758", - "2070", - "7289", - "16824", - "6921", - "32827", - "2851", - "99716", - "58118884", - "1447", - "3790", - "8126", - "3998", - "3009", - "4989", - "1550", - "2538", - "26776", - "104853", - "12997", - "25461", - "2226", - "38198", - "5249", - "14693849", - "11112", - "11688", - "1032", - "5876", - "12316", - "3165", - "29669", - "1136", - "6189", - "51873", - "66745", - "13679", - "980", - "63467", - "19679", - "54587", - "14720425", - "94844", - "85791", - "121862", - "22990", - "877", - "825", - "110257", - "128117", - "14412", - "3373", - "57388", - "44553", - "90185", - "20730", - "9489", - "5562", - "31195", - "18674", - "34512", - "70183", - "81610", - "2382", - "14702439", - "4728", - "15985", + "479787381", + "457334705", + "442671002", + "451362163", + "57435154", "65176513", - "77589", - "1343", - "17716", - "134691", - "141637", - "5147", - "372", - "15223978", - "1388", - "532", - "495078", - "181907", - "233633", - "906", - "639", - "222211", - "315396", - "746", - "366474", - "319", - "1067", - "7516", - "201072", - "520461", - "470926", - "3480", - "4125", - "426", - "960", - "10859", - "6062", - "212", - "156541", - "12694", - "211375", - "53", - "1174", - "8810", - "14830176", - "3695", - "447782", - "2138", - "23675", - "1013", - "331568", - "4609", - "1816", - "14098", - "21348", - "1924", - "19238", - "271472", - "17414998", - "15018969", - "6762", - "5739", - "2943", - "2460", - "1281", - "10320", - "258237", - "191250", - "245641", - "9295", - "11453", - "20266", - "17346", - "2031", - "348593", - "405013", - "2782", - "9780", + "58118884", "31398801", - "8378", - "3104", - "586", - "479", - "5416", - "3265", - "12046", - "2299", - "692", - "164606", - "1709", - "4878", - "6385", - "1602", - "799", - "3910", - "16481", - "853", - "1495", - "2621", - "22484", - "18265", - "285402", - "7947", - "15670", - "148903", - "7139", - "266", - "14859", - "300025", - "4340", - "173043", - "50745", - "68620", - "15326172", - "62044", - "228845", - "54", - "252972", - "484581", - "138669", - "30552", - "26219", - "119352", - "37395", - "15470816", - "53352", - "145819", - "88248", - "24920", - "161162", - "45859", - "328", - "59001", - "218", - "75866", - "1871", - "83948", - "72154", - "102627", - "377395", - "131901", - "39348", - "293915", - "822", - "217687", - "2202", - "341452", - "79811", - "48248", - "113516", - "877", - "109", - "15103889", - "1098", - "196963", - "460943", - "712", - "178214", - "547", - "1208", - "125462", - "187342", - "97559", - "358983", - "240607", - "438460", - "1539", - "509431", - "767", - "169526", - "107953", - "396741", - "32135", - "265942", - "207078", - "1428", - "535547", - "2092", - "932", "31946947", - "417078", - "279572", - "1981", - "657", - "15311411", - "1649", - "602", - "1043", - "438", - "493", - "324800", - "308973", - "164", - "65250", - "41409", - "43580", - "988", - "2368", - "56122", - "1760", - "35551", - "383", - "33816", - "273", - "21981", - "2699", - "13072", - "4747", - "7740", - "223600", - "23151", - "105499", - "350711", - "13794", - "4027", - "2534", - "19809", - "12405", - "15295", - "192433", - "7352", - "6575", - "36591", - "17854", - "387624", - "183058", - "3806", - "63855", - "202315", - "11793", - "247139", - "95418", - "24377", - "60723", - "15496089", - "6243", - "5024", - "33076", - "20868", - "44853", - "110934", - "67154", - "78064", - "3031", - "100346", - "47199", - "11182", - "82093", - "4248", - "142494", - "135540", - "212703", - "70622", - "235060", - "174134", - "49657", - "38489", - "9072", - "273160", - "16130", - "301889", - "407493", - "8184", - "165605", - "3584", - "428379", - "86347", - "5301", - "259840", - "5910", - "128924", - "26997", - "317354", - "57760", - "25659", - "18807", - "54910", - "28391", - "333609", - "9572", - "5578", - "34805", - "368716", - "149841", - "157526", - "90770", - "122646", - "6964", - "29896", - "287158", - "3363", - "10627", - "4470", - "74259", - "52227", - "40498", - "116649", - "3197", - "8628", - "42620", - "31458", - "2865", - "14517", - "10071", - "1466", - "2260", - "1071", - "619", - "32329", - "6410", - "56", - "2033", - "393", - "59357", - "15745349", - "3679", - "6069", - "1580", - "4874", - "1353", - "13430", - "15793437", - "15778411", - "112", - "3110", - "35769", - "19316", - "15944841", - "4135", - "20345", - "845", - "2147", - "48505", - "901", - "5727", - "281", - "15704434", - "2430", - "62402", - "337", - "1127", - "7150", - "5443", - "2600", - "23777", - "562", - "41619", - "3282", - "30725", - "15715", - "15866189", - "25044", - "523224", - "33992", - "12745", - "14915", - "224", - "5158", - "14173", - "65619", - "550045", - "450338", - "12117", - "1806", - "506", - "1920", - "473428", - "497704", - "21432", - "7947", - "43799", - "4590", - "29167", - "51031", - "675", - "4362", - "69010", - "53672", - "958", - "16572", - "17429", - "2770", - "788", - "450", - "39554", - "11489", - "15853146", - "8859", - "1240", - "7549", - "1014", - "10919", - "27736", - "168", - "26361", - "9831", - "6752", - "56428", - "18344", - "46095", - "3908", - "10348", - "37604", - "72573", - "404", - "19117", - "418827", - "565327", - "207883", - "24778", - "188099", - "161865", - "108410", - "241526", - "178930", - "511537", - "462", - "22334", - "93275", - "37247", - "266985", - "139276", - "153969", - "253937", - "288", - "76310", - "1229", - "17118547", - "982", - "537764", - "1167", - "440291", - "16377", - "520", - "35396", - "23526", - "578", - "674", - "926", - "921", - "115", - "98051", - "57", - "694", - "39157", - "30384", - "486588", - "231", - "119866", - "346", - "1722", - "280671", - "1106", - "378974", - "360345", - "53136", - "41187", - "20129", - "170166", - "18164", - "1352", - "43337", - "868", - "218557", - "398407", - "17270", - "310187", - "295052", - "17171095", - "84360", - "26089", - "16728512", "19331971", - "859", - "21202", - "33665", - "132479", - "80220", - "197731", - "103115", - "173", - "146421", - "797", - "45607", - "1044", - "752", - "126028", - "47997", - "88731", - "326075", - "31994", - "462859", - "16710332", - "810", - "229752", - "28892", - "1846", - "113994", - "1475", - "27461", - "636", - "159171", - "2217", - "7788", - "7354", - "4752", - "67852", - "4504", - "17415418", - "2649", - "23319", - "112105", - "290185", - "4009", - "3205", - "225963", - "3762", - "2464", - "64542", - "15423", - "40881", - "5000", - "25870", - "6238", - "14615", - "61358", - "78908", - "27239", - "17100", - "30166", - "11882", - "5309", - "175955", - "55491", - "58362", - "3576", - "5928", - "96471", - "9648", - "10703", - "214931", - "320785", - "106601", - "47629", - "262521", - "45245", - "2834", - "167374", - "151406", - "31722", - "13870", - "36955", - "101410", - "117860", - "35148", - "204464", - "19960", - "2340", - "8656", - "6610", - "10145", - "3020", - "249727", - "87220", - "50125", - "91720", - "237562", - "22137", - "17976624", - "123929", - "305153", - "38887", - "75035", - "11262", - "28671", - "5619", - "2093", - "3391", - "82970", - "8222", - "137008", - "52745", - "184976", - "21018", - "9152", - "12503", - "337234", - "16230", - "13186", - "33404", - "71349", - "354503", - "194500", - "18033", - "4257", - "6982", - "18965", - "24563", - "130311", - "372654", - "144019", - "691", - "3092", - "17718094", - "6388", - "2522", - "478471", - "432967", - "1259", - "9882", - "17692329", - "5753", "37728236", - "614503", - "125", - "2903", - "376", - "23909", - "528768", - "46402", - "1006", - "943", - "37889", - "628", - "19446", - "391750", - "56891", - "584550", - "51390", - "3282", - "2269", - "17593172", - "1195", - "6071", - "26525", - "411854", - "1638", - "3662", - "3852", - "314", - "18490", - "8421", - "17660934", - "44087", - "34249", - "188", - "4106", - "27929", - "15813", - "32525", - "7530", - "1385", - "62", - "754", - "1511", - "502", - "54076", - "565", - "17977954", - "5120", - "12816", - "29397", - "17554449", - "880", - "1764", - "4612", - "439", - "3472", - "11540", - "4359", - "4866", - "2016", - "10963", - "14221", - "6768", - "556049", - "48832", - "36037", - "14986", - "5436", - "7977", - "2713", - "22698", - "1069", - "1890", - "21550", - "17841670", - "30929", - "2143", - "16642", - "8866", - "9374", - "17534", - "455152", - "13521", - "25185", - "251", - "59835", - "817", - "20466", - "774", - "297795", - "515", "18112256", - "109286", - "329089", - "6228", - "269407", - "189686", - "570236", - "1421", - "243796", - "283246", - "542434", - "62906", - "490842", - "98901", - "257", - "73149", - "2198", - "147642", - "220504", - "17988711", - "630176", - "155264", - "85061", - "322", - "76927", - "171637", - "127048", - "1550", - "133591", - "466921", - "1097", - "2069", - "1809", - "3366", - "345963", - "163225", - "444165", - "401885", - "199482", - "114928", - "128", - "94031", - "903", - "6944", - "64", - "66170", - "515991", - "422508", - "580", - "4992", - "644", "18283146", - "313054", - "451", - "3171", - "231894", - "5252", - "103965", - "256279", - "4732", - "2977", - "8181", - "3756", - "1032", - "4211", - "382296", - "180436", - "7334", - "386", - "1680", - "968", - "89418", - "193", - "80897", - "1939", - "5577", - "3561", - "363677", - "120827", - "2458", - "1162", - "1292", - "838", - "1227", - "5903", - "4472", - "2328", - "6553", - "2782", - "69563", - "599462", - "3950", - "7725", - "2588", - "27217", - "9093", - "14575", - "13851", - "22112", - "36976", - "17077", - "47611", - "41304402", - "10135", + "17988711", "18160671", - "15373", - "43006", - "21000", - "8637", - "10656", - "9614", - "106666", - "290352", - "132", - "144145", - "87272", - "646144", - "67892", - "176088", - "75051", - "198", - "594", - "337342", - "58372", - "167458", - "117912", - "305265", - "78927", - "204620", - "65", - "503288", - "372795", - "249915", - "215101", - "226111", - "185114", - "529073", - "71373", - "83001", - "159291", - "123965", - "52728", - "28657", - "25842", - "478763", - "101471", - "237715", - "660", - "262711", - "91742", - "584689", - "412082", - "433226", - "11830", - "396", - "276168", - "354638", - "330", - "96474", - "137059", - "18973", - "12481", - "18550040", - "194603", - "45249", - "30163", - "264", - "151520", - "31735", - "64543", - "23290", - "11243", - "528", "18299969", - "17992", - "16227", - "50104", - "614654", - "112124", - "33373", - "462", - "556185", - "24534", - "455431", - "35142", - "19954", - "61392", - "320906", - "55484", - "793", - "69", - "19519600", - "1818", - "7938", - "4066", - "2240", - "682193", - "39095349", - "2802", - "348", - "8854", - "19435", - "139", - "1398", - "6035", - "9840", + "41304402", + "18550040", "18466754", - "4558", - "1191", - "5120", - "6389", - "19683846", - "1538", - "925", - "6741", - "8360", - "3012", - "726", - "2661", - "859", - "488", - "37982", - "557", - "12801", - "1187", - "617320", - "19582622", - "25175", - "3223", - "1257", - "36071", - "648951", - "17529", - "209", - "1058", - "12167", - "2380", - "4277", - "3855", - "21971527", - "32603", - "26519", - "16612", - "22694", - "29419", + "39095349", "19458575", - "767", - "30975", - "18447", - "9347", - "23902", - "278", - "13507", - "5402", - "977", - "4839", - "14212", - "14988", - "7093", - "418", - "15765", - "42018", - "2099", - "3433", - "3644", - "627", - "39965", - "837", - "907", - "34301", - "7515", - "10968", - "1125", - "1678", - "1117", - "2521", - "10404", - "1047", - "991", - "21554", - "11532", - "27933", - "199993", - "213", - "20670201", - "144", - "285", - "20575434", - "1359", - "142", - "163706", - "54133", - "44214", - "109675", - "857", - "329950", - "221062", - "256880", - "346852", - "517413", - "155740", - "434", - "72", - "190243", - "642", - "19901370", - "244274", - "85314", - "2292", - "506", - "1287", - "115289", - "20254383", - "63082", - "468211", - "19962592", - "796", - "19866055", - "172100", - "698258", - "298422", - "929", - "361", - "3083", - "492203", - "1144", - "133982", - "2723", - "2149", - "140878", - "289", - "127442", - "785", - "1215", - "631862", - "99162", - "180922", - "216", - "66344", - "94332", - "81102", - "313835", - "601065", - "2867", - "22884801", - "2005", - "2580", - "210242", - "571772", - "104276", - "402922", - "1574", - "19824397", - "364612", - "578", - "46481", - "651", - "270061", - "2436", - "714", - "428", - "1430", - "148130", - "48889", - "543912", - "1072", - "72", - "723", - "89716", - "571", - "66674317", - "1000", - "3298", - "51440", - "383302", - "664236", - "445239", - "59945", - "121187", - "1860", + "21971527", + "19519600", + "19582622", + "19683846", + "19824397", + "19866055", "44799678", - "1449", - "6448", - "1656", - "1343", - "300", - "600", - "2321", - "1430", - "2109", - "435", - "1269", - "217", - "1304", - "1086", - "2541", - "2092", - "508", - "3668", - "2175", - "3218", - "1231", - "20774408", - "6070", - "1044", - "1203", - "2691", - "450", - "1354", - "1885", - "745", - "145", - "1493", - "941", - "297", - "2030", - "2466", - "2241", - "72", - "1958", - "521", - "525", - "751", - "3443", - "1376", - "1013", - "1279", - "4568", - "1418", - "446", - "5169", - "671", - "20913206", - "1159", - "223", - "4343", - "826", - "1194", - "868", - "290", - "596", - "1128", - "1792", - "74", - "2992", - "21023556", - "1505", - "1807", - "4118", - "363", - "4869", - "1119", - "3893", + "66674317", + "20254383", + "22884801", + "20670201", + "20575434", + "19901370", + "19962592", "20760015", - "20970709", - "1594", - "895", + "20774408", "20868526", - "1942", - "375", - "1053", - "2391", - "225", + "20913206", "20956311", - "977", - "1740", - "150", - "820", - "2612", - "5469", - "1643", - "969", - "2411", - "2716", - "3019", - "12429", - "45309", - "4610", - "76", - "30111", - "3929", - "1484", - "1875", - "17910", - "5823", - "7645", + "20970709", + "21023556", "21112628", - "2868", - "81412", - "9543", - "63287", - "4914", - "22104", - "27139", - "4383", - "31712", - "8556", - "3701", - "11213", - "8100", "21239601", - "47676", - "9011", - "4156", - "11821", - "23246", - "20956", - "54344", - "60153", - "70015", - "40957", - "10074", - "3246", - "16160", - "15323", - "2031", - "18899", - "13115", - "1562", - "7266", - "16997", - "2564", - "110139", - "115822", - "2345", - "5520", - "51670", - "66574", - "36989", - "38897", - "5217", - "128130", - "25760", - "35148", - "1718", "21279230", - "10606", - "104779", - "43095", - "73610", - "6885", - "14563", - "2501", - "121829", - "57172", - "3474", - "94750", - "99649", "21450435", - "90057", - "2188", - "13802", - "6126", - "19888", - "77434", - "28587", - "2658", - "95243", - "6741", - "10443", - "5406", - "105307", - "7922", - "3836", - "22099613", - "22549203", - "4542", - "202087", - "12883", - "9892", - "259679", - "14301", - "29613", - "301761", - "31192", - "22904", - "286965", - "19591", - "4071", - "246971", - "7529", - "38316", - "5720", - "16743", - "7136", - "149631", - "77894", - "25351", - "9341", - "13592", - "28113", - "5092", - "12253", - "57468", - "81933", - "10994", - "4307", - "116405", + "21873820", "21953687", - "54619", - "90568", - "46933", + "22099613", + "22297290", "22333492", - "22474682", - "8869", - "4778", - "34601", - "21873820", - "142293", - "22662121", - "428130", - "15089", - "42426", "22427935", - "26692", - "3128", - "21721", - "11623", - "63641", - "407260", - "40292", - "473064", - "157330", + "22474682", + "22549203", "62743349", - "350559", - "6034", - "2815", - "368555", - "70450", - "86131", - "60475", - "212549", - "128695", - "182816", - "17615", - "450038", - "74092", - "24088", - "20616", - "51916", - "317203", - "22297290", - "66966", - "36419", - "32855", - "8395", - "165427", - "110698", - "2971", - "333442", - "387428", - "44640", - "100156", - "558", - "671252", - "3680", - "318", - "741965", - "577712", - "779957", - "3200", - "2237", - "27272", - "79", - "20017", - "5847", - "15421", - "1037", - "7694", - "1197", - "1917", - "637", - "33564", - "2558", - "8580", - "17112", - "31870", - "2718", - "4884", - "28724", - "1437", - "522792", - "398", - "71930", - "13167", - "22436891", - "10110", - "23402", - "717", - "7292", - "35339", - "39132", - "18969", - "10673", - "22193", - "497289", - "4402", - "957", - "1757", - "1357", - "6489", - "50436", - "21064", - "6891", - "478", - "4162", - "1517", - "25901", - "3039", - "6168", - "64979", - "11236", - "68374", - "797", - "877", - "22386707", - "47933", - "9544", - "41150", - "75649", - "239", - "14616", - "43330", - "18002", - "22277346", - "607443", + "22662121", + "23243873", "23430658", - "11879", - "1277", - "5205", - "24611", - "83654", - "2879", - "3440", - "13891", - "45591", - "30256", - "55768", - "3921", - "61747", - "37195", - "1117", - "79530", - "705813", "22218767", - "12523", - "53021", + "22277346", "22292252", - "2398", - "5526", - "23243873", - "4643", - "58676", - "138116", - "292606", - "1791", - "1546", - "4978", - "162", - "533116", - "216785", - "3261", - "589118", - "487", - "251891", + "22386707", + "22436891", + "24177831", "22660273", - "6615", - "406", - "196117", - "3997", - "107519", - "324", - "113022", - "650988", - "97243", - "239566", "22689467", - "339909", - "5305", - "92470", - "375700", - "394939", - "145242", - "8252", - "7024", - "125001", - "6287", - "87941", - "436428", - "2280", "22734650", - "307614", - "160549", - "619279", - "8744", - "846", - "7433", - "731", - "278330", - "3097", - "1954", - "756224", - "186555", - "684328", - "2117", - "507111", - "1301", - "323355", - "415154", - "719379", - "118849", - "1383", - "1628", - "2443", - "560424", - "458759", - "2607", - "975", - "152693", - "650", - "168812", - "81", - "7843", "22749660", - "24177831", - "264785", - "812", - "1465", - "761", - "243", - "5633", - "2770", - "4733", - "894", - "1138", - "4242", - "102259", - "1057", - "206167", - "5960", - "9727", - "4488", - "3751", - "227891", - "9235", - "177480", - "357357", - "131396", - "482290", - "16417", - "1100", - "12648", - "242629", - "255057", - "15561", - "188965", - "46111", "26606595", - "32200", - "19160", - "380707", - "69162", - "14789", - "24906", - "5887", - "93620", - "39584", - "6571", - "6913", - "9651", - "1610", - "17275", - "29025", - "1440", - "10164", - "133097", - "84648", - "48517", - "7768", - "27566", - "24150097", - "540017", - "59345", - "7340", - "43792", - "1185", - "139905", - "627332", - "11963", - "21304", - "8624", - "488716", - "1270", - "362121", - "567706", - "56423", - "18217", - "41645", - "13333", - "179737", - "126547", + "24043904", "24098549", - "20189", - "65707", - "147060", + "24150097", "24310668", - "162577", - "219504", - "114485", - "53673", - "1355", - "26193", - "464930", - "154645", - "51009", - "513717", - "11363", - "103521", - "8196", - "9137", - "108885", - "327646", - "230807", - "6229", - "198626", - "120344", - "24043904", - "33917", - "931", - "400246", - "37609", - "89057", - "442271", - "344488", - "10764", - "35720", - "420738", - "170941", - "23620", - "76560", "24645082", "25240549", - "30569", - "1525", - "208805", - "22419", - "14018", - "296390", - "72775", - "2779", - "24495799", - "42500", - "29621", - "22869", - "6702", - "659597", - "63736", "24947967", - "4521", - "38381", - "24257216", - "82168", - "24693844", - "10978", - "100435", - "74267", - "2083", - "3302", - "14300", - "3737", - "135790", - "18584", - "78130", - "1388", - "6353", - "1736", - "44692", - "16748", - "105618", - "1475", - "5045", - "345", - "34614", - "766197", - "6004", - "52056", - "31198", - "10367", - "432", - "67070", - "60577", - "70581", - "5307", - "157828", - "47058", - "32862", - "40397", - "7051", "24138082", - "150035", - "86383", - "17622", - "54787", - "5655", - "2953", - "95516", - "728870", - "12899", - "24094", - "116776", - "90861", - "15874", - "13601", - "7923", - "1910", - "21732", - "19546", - "8359", - "2431", - "8796", - "259", - "111065", - "9319", + "24257216", "24331234", - "15087", - "1301", "27476901", - "28126", - "9843", + "24495799", + "24693844", "24491410", - "2257", - "2605", - "805434", - "172", - "57594", - "7487", - "11589", - "20595", - "129079", - "4783", - "846668", - "142736", - "693366", - "1649", - "1562", - "3998", - "3128", - "36454", - "3476", - "1148", - "88", - "174438", - "1060", - "235633", - "192874", - "864105", - "273782", - "971", - "1680", - "183455", - "743886", - "609223", - "4608", - "4875", - "318027", - "706", - "529", - "429322", - "1174", - "260389", - "618", - "2534", - "1414", - "176", - "369428", - "224094", - "4075", - "213124", - "1989", - "3010", - "24658826", - "795", - "541", - "883", - "2832", - "632", - "640409", - "264", - "2171", - "302513", - "25535625", - "2715", "24893768", - "474413", - "707652", - "247702", - "1265", - "1355", + "25182772", + "81883443", "25432202", - "1237", - "1084", - "1769", - "287794", - "388476", - "361", - "1592", - "812", - "2123", - "24713820", - "180", - "451", - "5408", - "441", - "3542", - "903", - "673189", - "408412", + "25535625", "53493357", - "90", - "1536", - "1627", - "3187", - "25182772", - "2655", - "270", - "1503", - "1946", - "722", - "993", - "3365", - "1717", - "2301", - "5141", - "1808", "81204589", - "4342", - "781980", - "2478", "24620709", - "579411", - "1446", - "2352", - "81883443", - "822024", - "3894", - "821", - "10802", - "730", - "21464", - "547", - "4983", - "1462", - "20370", - "4213", - "2194", - "9165", - "273", - "7800", - "456", - "26478", - "8256", - "29305", - "25380057", - "91", - "30855", - "8711", - "5528", + "24658826", + "24713820", "25361552", - "3259", - "6981", - "638", - "12076", - "7059", - "1187", - "9264", - "25461278", - "17450", - "5314", - "23834", - "1645", - "5957", - "10257", - "4763", - "11439", - "1828", - "11563", - "36055", - "182", - "1553", - "6254", - "2378", - "3937", - "364", - "15717", - "4711", "57296603", - "7426", - "18365", - "3078", - "7345", - "4438", - "2561", - "1095", - "6324", - "8345", - "25508010", - "3622", - "10367", - "6618", - "3479", - "12713", - "1736", - "9816", + "25380057", "54072936", - "2928", - "19368", - "3662", + "25461278", + "25508010", "25526212", - "7886", - "6691", - "34231", - "2896", - "3295", - "13441", - "10919", - "27846", - "32497", - "5590", - "1004", - "22649", - "3440", - "1279", - "1370", - "25110", - "5039", - "5255", - "4488", - "4166", - "3112", - "9711", - "8805", - "5891", - "122956", - "1522", - "52122", - "16714", - "15058", - "78185", - "26000635", - "853", - "13586", - "47047", - "379", - "193065", - "1141", - "1331", - "63760", - "22883", - "74305", - "950", - "596", - "57660", - "54792325", - "135909", - "32833", - "284", - "994", - "198", - "157969", - "44741", - "12206", - "15886", - "18555", - "17635", - "34584", - "70609", - "183618", - "14322", - "100552", - "38376", - "40405", - "273955", - "174636", - "1236", - "54799", - "49539", "25938160", - "474", - "60614", - "260608", - "67099", - "21686", - "213351", - "202976", - "150285", - "166117", - "86502", - "42527", - "116918", - "24080", - "224283", - "90938", - "1617", - "19568", - "95652", - "142973", - "189", - "247912", - "31174", - "82251", - "26751", - "568", - "12850", - "235773", - "28133", - "20581", - "25369", - "36432", - "695", - "758", - "29607", - "663", - "94", - "1093", - "297", + "54792325", + "26000635", "27705719", - "894", - "99", - "397", - "795", - "1046", - "1427", - "2388", - "3785", - "1392", - "6483", + "27741179", "27783916", - "1193", - "8087", - "11892", - "1947", - "648", - "1791", - "1990", - "20212", - "3585", - "5783", - "2588", - "1890", - "2987", - "13294", - "27693", - "5482", - "4883", - "9088", - "2787", - "26286", - "6084", - "2598", "27884487", - "2189", - "10088", - "4584", - "6886", - "13995", + "27919207", + "59088200", "27942864", - "11289", - "63821308", + "167772991", "57830974", - "2056", - "8587", - "1591", - "216", - "324", - "5183", - "23668", - "29201", - "3985", - "18207", - "7687", - "3186", "30147186", - "12593", - "17301", - "14797", - "3032", - "167772991", - "3249", - "1839", - "864", - "1292", - "7287", - "108", - "63063", - "1622", - "4284", - "30710", - "540", + "63821308", "30164787", - "1514", - "1297", - "37772", - "756", - "2381", "30191299", - "2815", - "59088200", - "1691", - "1731", - "432", - "9588", - "24979", - "27741179", - "27919207", - "1189", - "3682", - "108296", - "113869", - "72362", - "132338", - "19772", - "254122", "30294630", - "10416", - "125889", - "5962", - "20860", "30485760", - "218", - "153873", - "93111", - "437", - "45834", - "7482", - "30006", - "43544", - "7047", - "146329", - "36869", - "178853", - "197706", - "13679", - "17813", - "50742", - "30755106", - "4116", - "10959", - "35017", - "16072", - "48233", - "16943", - "84155", - "62090", - "4985", - "8786", - "88524", - "139115", - "4659", "64475302", - "188076", - "4334", - "5310", - "11611", - "31284664", - "43516", - "53361", - "18792", - "65376", - "6613", - "218609", - "40901", - "229925", - "7916", - "360592", - "21949", - "33274", - "9329", - "97917", - "80006", - "102943", - "280843", - "418892", - "119769", - "657", - "28482", - "8351", - "267153", - "27066", - "295300", - "241749", + "30755106", "30872534", - "5636", - "68760", - "3465", - "25650", - "12916", - "14441", - "343062", - "547", - "310416", - "23146", - "15202", - "38830", - "379111", - "3899", - "9872", - "326300", - "328", - "76075", - "170055", - "31640", - "6287", - "24344", - "876", - "36651495", - "3399", - "3952", - "1644", + "31284664", "30605469", - "986", - "1104009", - "112", + "30617396", + "85933738", "34539105", - "168090072", - "57663021", - "338", - "2413", - "3172", - "636917", - "102511476", - "8025", - "31783791", - "2946", - "5052", - "7144", - "2193", - "2632", - "3626", - "6374", - "6704", + "36651495", "76830332", - "2083", + "40845425", + "92100113", "31445440", - "1973", + "168090072", "217361165", - "12180", - "1315", - "11496", - "2718", - "40845425", - "1050084", "31627917", - "7585", - "1534", - "4722", - "1754", - "1864", - "30617396", - "85933738", - "14347", - "12865", - "8466", - "4392", - "3072", - "1095", - "4172", - "766", - "1424", - "5382", - "1205", - "92100113", - "3732", - "10924", - "322", - "484", - "804395", - "807", - "968", - "1129", - "161", - "2262", - "1291", - "2100", - "2424", - "645", - "1938", - "1322207", - "28049401", - "14780147", + "57663021", + "102511476", + "31783791", "27921761", - "17630065", - "3527625", - "42841684", - "4405061", - "3912094", + "28959532", "29045717", - "14780917", - "17542335", - "27399071", - "160", - "321", - "160", - "7807886", + "29088669", + "29147719", + "29783752", + "26018455", + "27056055", "27313833", - "17629652", - "18813885", - "160", - "7287321", - "2079958", + "27399071", + "27431474", + "27689998", + "27991712", + "28049401", + "19597271", "20470831", + "20481318", + "20503693", + "21353933", + "21803489", + "466655540", + "1000126500", "626706986", "59171176", - "14800627", - "27056055", - "27991712", - "17248634", - "7275469", - "4443867", - "27689998", - "2871259", - "27431474", + "18369973", + "18737807", + "18742785", + "18813885", + "42841684", + "827564741", "533089640", - "29088669", - "159", - "29783752", - "4492763", - "268390599", - "466655540", + "22923642", "27809951", - "159", - "161", - "160", - "14479040", + "268390599", "544727606", - "622866", - "29147719", - "2222546", - "6969507", - "14812785", - "59726542", - "19597271", - "59428509", - "18742785", - "8957400", - "26018455", - "827564741", - "14739386", - "47784863", - "21353933", - "4054230", - "18369973", - "8026513", - "15179695", - "1380758", - "20481318", "60755363", - "21803489", - "22923642", - "160", - "483", - "322", - "482", - "4666887", "61427004", - "20503693", - "160", - "28959532", - "4662913", - "1000126500", - "15208226", - "161", - "8633676", - "59719927", "59279402", - "18737807", - "159", - "318", - "13695062", - "1270", - "2428978", - "317", - "637", - "3021", - "796", - "1275", - "8729908", - "318", - "2247954", - "197852", - "4390231", - "1115", - "451091", - "17095758", - "478", - "1785566", - "956", + "59428509", + "59719927", + "59726542", + "47784863", "296389404", - "1274", - "3267841", - "1115", - "1733172", - "12542710", - "12717014", - "73619", - "477", - "2528574", - "1382967", - "796", - "1434", - "3346739", - "1716812", - "426792", - "3536857", - "1753", - "159", - "12643917", - "318", - "1434", - "11861806", - "2732873", - "635", - "2322887", - "10563829", - "177797", - "3180", - "2668459", - "199250", - "2862", - "478", - "973702", - "637", - "2384", - "3367408", - "2254219", - "80615", - "1747", - "497065", - "3357235", - "1588", - "38483322", - "3931710", - "2225", - "158", - "956", - "476", - "953", - "2543", - "3274698", - "155467", - "1439928", - "13964146", - "2702", - "1594", - "3450322", - "3498", - "3816", - "794", - "3367249", - "1429", - "1746030", - "1855895", - "2789945", - "1111", - "3382024", - "8686392", - "7350", - "3194", - "1431", - "2875", - "7830", - "476", - "9750", - "1590", - "11007801", - "14547", - "1427", - "3832", - "12310", - "8790", - "951", - "10822221", - "634", - "3633468", - "1113", - "1111", - "41864", - "1268", - "795", - "1428", - "10390", - "2715", - "34043", - "24931", - "16141", - "1905", - "952", - "12951", - "13124158", - "6070", - "793", - "5750", - "11030", - "9670488", - "1597", - "328514", - "11232286", - "44099", - "2076", - "1270", - "2556", - "15343", - "2236", - "51439", - "21249", - "142967", - "32287", - "5430", - "63276", - "60077", - "8310", - "23651", - "476", - "1272", - "48886", - "35799", - "37715", - "22372", - "636", - "3034", - "1916", - "46493", - "57037", - "39790", - "27655", - "3989352", - "2396", - "4470", - "18057", - "633", - "6390", - "9270", - "17099", - "29096", - "1109", - "3513", - "19015", - "54151", - "4151", - "1586", - "11670", - "4791", - "5110", - "30689", - "11927639", - "317", - "954", - "1757", - "1438", - "20132", - "110720", - "273702", - "11752", - "150004", - "369556", - "302551", - "1423242", - "165857", - "213106", - "388475", - "707343", - "66636", - "157671", - "334448", - "183314", - "8368", - "14653", - "498800", - "192763", - "1109099", - "16266", - "1353978", - "287805", - "429362", - "321", - "1225425", - "9818", - "1285", - "13847", - "474423", - "6113", - "135629", - "122529", - "524301", - "408357", - "7885", - "1165814", - "202694", - "116458", - "128919", - "3054", - "15459", - "579319", - "18200", - "260401", - "13041", - "640118", - "174345", - "160", - "1496046", - "5791", - "10463", - "1445", - "2893", - "351601", - "3537", - "1572551", - "235534", - "17233", - "551088", - "3215", - "3859", - "2572", - "19168", - "2089", - "142657", - "642", - "7401", - "11107", - "672847", - "4825", - "963", - "5469", - "318098", - "1124", - "1288092", - "1055119", - "5147", - "1767", - "451330", - "2411", - "6918", - "1003712", - "105299", - "2732", - "21426", - "9335", - "8851", - "803", - "4503", - "6435", - "20297", - "12397", - "100172", - "4181", - "481", - "608996", - "224000", - "1928", - "117346", - "86752", - "23845", - "22555", - "44507", - "123463", - "1060516", - "840135", - "60656", - "67278", - "289495", - "237065", - "136663", - "26426", - "51935", - "747834", - "442695", - "792707", - "275344", - "158874", - "34333", - "627914", - "27878", - "54680", - "151149", - "1263194", - "665597", - "70815", - "558875", - "46929", - "57587", - "1191627", - "29331", - "184620", - "25136", - "143745", - "194113", - "943775", - "106076", - "78377", - "497304", - "49351", - "129903", - "802", - "74511", - "321", - "63886", - "1124228", - "469169", - "30944", - "527206", - "111550", - "204088", - "32558", - "1338928", - "82403", - "1000492", - "175609", - "705517", - "160", - "214545", - "160", - "261995", - "642", - "91261", - "304290", - "249289", - "890438", - "36108", - "225484", - "100923", - "40148", - "481", - "95931", - "167081", - "42247", - "319887", - "2730", - "963", - "803", - "321", - "964", - "2087", - "1768", - "160", - "1285", - "3212", - "160", - "1929", - "160", - "2248", - "2891", - "1605", - "320", - "1926", - "2569", - "3534", - "642", - "1444", - "160", - "641", - "160", - "1284", - "3051", - "410012", - "1123", - "1124", - "963", - "198452", - "802", - "1607", - "481", - "1766", - "1446", - "2409", - "7291", - "5714", - "846937", - "8243", - "6339", - "793", - "317", - "3177", - "2859", - "3495", - "2541", - "1587", - "2700", - "475", - "1428", - "2223", - "952", - "634", - "3018", - "2382", - "1111", - "2064", - "158", - "1269", - "1905", - "1746", - "9671", - "7766", - "5077", - "8719", - "6032", - "13480", - "12686", - "5395", - "4759", - "5121015", - "11417", - "9195", - "10306", - "6815", - "158", - "2225", - "2066", - "317", - "2553", - "1116", - "3499", - "3032", - "3180", - "479", - "1919", - "2862", - "7799", - "15131", - "11624", - "1759", - "794", - "319", - "2239", - "1439", - "2233", - "5409", - "158", - "1112", - "1276", - "1279", - "637", - "639", - "1589", - "953", - "4454", - "1907", - "6843", - "799", - "2384", - "5091", - "6365", - "2713", - "7321", - "9711", - "1435", - "1748", - "1430", - "2074", - "2559", - "320", - "1119", - "2872", - "10349", - "1754", - "1595", - "2079", - "5728", - "3040", - "13537", - "318", - "2879", - "12262", - "8755", - "8277", - "159", - "319", - "3021", - "2719", - "9233", - "3817", - "959", - "2393", - "1599", - "2399", - "478", - "10986", - "6046", - "956", - "1914", - "4772", - "14334", - "797", - "4135", - "158", - "159", - "1271", - "2703", - "3200", - "476", - "635", - "2544", - "1436", - "1596", - "159", - "957", - "2394", - "2880", - "1116", - "639", - "2720", - "1755", - "797", - "2075", - "1279", - "2557", - "2554", - "1439", - "4787", - "4469", - "319", - "2716", - "7807", - "15262", - "12884", - "5105", - "6854", - "8760", - "10982", - "1915", - "4150", - "16053", - "1119", - "9236", - "6059", - "1276", - "479", - "10347", - "1759", - "7331", - "2234", - "17954", - "3194", - "13677", - "638", - "159", - "14469", - "634", - "8284", - "3832", - "9712", - "6377", - "478", - "17004", - "12250", - "3035", - "959", - "799", - "1599", - "11616", - "5423", - "1919", - "2876", - "2398", - "2079", - "3513", - "475", - "319", - "2238", - "5741", - "317", - "158", - "3041", - "18904", - "1108", - "316", - "792", - "634", - "158", - "1424", - "949", - "633", - "475", - "158", - "158", - "950", - "2371", - "158", - "475", - "316", - "158", - "317", - "158", - "792", - "316", - "1733", - "1267", - "475", - "1890", - "158", - "473", - "158", - "1898", - "791", - "1743", - "634", - "158", - "1585", - "1426", - "1418", - "1109", - "946", - "158", - "475", - "2047", - "1425", - "317", - "3159", - "317", - "1582", - "315", - "951", - "951", - "158", - "158", - "633", - "1740", - "158", - "2844", - "157", - "1267", - "1266", - "158", - "158", - "1576", - "476", - "3002", - "474", - "1103", - "2204", - "792", - "633", - "3474", - "158", - "2529", - "2214", - "2056", - "317", - "1261", - "158", - "792", - "316", - "631", - "157", - "2687", - "788", - "1109", - "950", - "158", - "3129", - "2518", - "4716", - "157", - "157", - "1254", - "1411", - "469", - "157", - "312", - "155", - "157", - "781", - "4087", - "471", - "2661", - "157", - "2973", - "780", - "314", - "156", - "2361", - "311", - "1249", - "3146", - "156", - "4065", - "2505", - "624", - "937", - "2817", - "467", - "1091", - "3753", - "2036", - "156", - "2023", - "2675", - "784", - "3460", - "2832", - "1724", - "1098", - "1249", - "157", - "1713", - "311", - "157", - "3441", - "314", - "1093", - "1868", - "1246", - "2989", - "468", - "470", - "157", - "935", - "312", - "155", - "937", - "941", - "156", - "2334", - "1402", - "781", - "3774", - "311", - "155", - "1405", - "157", - "1557", - "1093", - "627", - "624", - "625", - "157", - "2349", - "468", - "156", - "936", - "1567", - "1880", - "156", - "311", - "1091", - "2193", - "623", - "156", - "4401", - "157", - "157", - "779", - "312", - "2179", - "157", - "155", - "155", - "466", - "929", - "466", - "933", - "155", - "1701", - "309", - "3114", - "1863", - "155", - "1245", - "155", - "778", - "1855", - "2335", - "933", - "4634", - "1089", - "311", - "1397", - "621", - "155", - "7570", - "1089", - "1553", - "2010", - "155", - "3089", - "1400", - "2472", - "8035", - "3705", - "467", - "155", - "155", - "2780", - "2179", - "155", - "774", - "1867", - "2023", - "155", - "622", - "777", - "3397", - "1083", - "5559", - "1547", - "619", - "1238", - "4013", - "932", - "5869", - "2958", - "155", - "6178", - "1708", - "155", - "155", - "6643", - "622", - "2318", - "155", - "1244", - "464", - "8499", - "2934", - "777", - "2164", - "1242", - "1087", - "311", - "1711", - "311", - "1556", - "2490", - "5250", - "155", - "155", - "311", - "155", - "1401", - "1392", - "311", - "2646", - "7107", - "154", - "4326", - "155", - "466", - "2626", - "2802", - "4942", - "1556", - "3098", - "8996", - "928", - "10697", - "4028", - "9427", - "1083", - "11315", - "2478", - "1393", - "11284", - "1392", - "8963", - "24194", - "2943", - "8531", - "5581", - "1856", - "154", - "10046", - "154", - "1083", - "15660", - "7599", - "14107", - "13335", - "464", - "928", - "5270", - "20628", - "2630", - "619", - "1237", - "2323", - "5891", - "26832", - "11903", - "309", - "2940", - "1548", - "4339", - "4959", - "2475", - "309", - "25429", - "14883", - "19541", - "12556", - "155", - "154", - "3095", - "22951", - "2785", - "154", - "21709", - "6202", - "2013", - "155", - "2320", - "28230", - "1701", - "310", - "11935", - "18454", - "10665", - "17522", - "9460", - "309", - "1238", - "1858", - "464", - "1546", - "154", - "309", - "2165", - "464", - "619", - "619", - "2011", - "7133", - "773", - "10078", - "154", - "2788", - "1703", - "16591", - "774", - "309", - "2633", - "3718", - "8065", - "2168", - "3408", - "4649", - "6668", - "154", - "71882", - "2014", - "75621", - "97449", - "40735", - "155", - "6204", - "25480", - "2634", - "5583", - "14128", - "83723", - "52724", - "42915", - "10709", - "18481", - "31396", - "466", - "155", - "464", - "1704", - "19570", - "79516", - "1245", - "92605", - "1084", - "26880", - "28280", - "13351", - "102457", - "88086", - "5894", - "5273", - "33108", - "2169", - "50077", - "8534", - "155", - "2479", - "64872", - "20658", - "36688", - "1089", - "45250", - "1394", - "58486", - "68299", - "8068", - "38712", - "2790", - "3720", - "16616", - "55527", - "155", - "11952", - "3410", - "14905", - "12574", - "24236", - "1239", - "155", - "17548", - "778", - "155", - "929", - "774", - "2945", - "622", - "622", - "933", - "6670", - "311", - "4652", - "619", - "61601", - "3100", - "466", - "34820", - "9466", - "4341", - "778", - "9000", - "1859", - "2324", - "933", - "7602", - "15683", - "11331", - "29840", - "10088", - "4962", - "22991", - "4031", - "311", - "7136", - "1549", - "47586", - "21747", - "2803", - "155", - "2023", - "1556", - "155", - "2651", - "1871", - "14982", - "19671", - "2495", - "2803", - "2339", - "312", - "7172", - "31558", - "2335", - "3738", - "3426", - "623", - "1559", - "6235", - "6704", - "155", - "35000", - "10140", - "8577", - "1715", - "2180", - "11389", - "3115", - "2647", - "27019", - "23110", - "1403", - "468", - "15764", - "10764", - "1403", - "311", - "4051", - "156", - "5298", - "28426", - "2491", - "1091", - "1247", - "155", - "2647", - "1558", - "1868", - "2179", - "467", - "1401", - "20765", - "16701", - "1869", - "4362", - "25611", - "1091", - "311", - "1712", - "935", - "155", - "1714", - "2183", - "14201", - "18577", - "7640", - "24360", - "12639", - "2959", - "2335", - "624", - "5610", - "1247", - "779", - "13420", - "17639", - "2959", - "29990", - "3427", - "9045", - "3739", - "936", - "2025", - "21859", - "33279", - "5923", - "2027", - "2491", - "9515", - "780", - "4674", - "3115", - "4986", - "12014", - "8108", - "327325", - "36877", - "50335", - "79925", - "188678", - "146825", - "38911", - "88539", - "281674", - "126139", - "420219", - "93081", - "43136", - "170650", - "513140", - "52995", - "139615", - "488181", - "539357", - "108277", - "179429", - "45483", - "1537972", - "933868", - "1256", - "981628", - "630", - "1140169", - "566988", - "1463146", - "472", - "2365", - "157", - "1084700", - "471", - "628", - "76010", - "1259760", - "102950", - "72252", - "198399", - "845269", - "230544", - "157", - "1391941", - "113917", - "1031905", - "942", - "1324198", - "119871", - "1099", - "1576", - "2523", - "727784", - "84153", - "785", - "55813", - "132720", - "2049", - "464323", - "344113", - "267871", - "626495", - "40945", - "1734", - "296106", - "242463", - "658529", - "1418", - "1892", - "162342", - "219254", - "314", - "208591", - "361686", - "47830", - "1103", - "254853", - "399661", - "596034", - "692291", - "65206", - "154348", - "441721", - "788", - "380202", - "97937", - "945", - "311323", - "2207", - "315", - "58787", - "1413", - "1261", - "1198470", - "765006", - "804115", - "888468", - "61918", - "68650", - "2368", - "1579", - "3000", - "6320", - "158", - "7269", - "5366", - "11519", - "1105", - "5682", - "948", - "1107", - "2684", - "10890", - "157", - "3786", - "13566", - "1262", - "4102", - "157", - "157", - "1263", - "789", - "2215", - "789", - "2681", - "631", - "157", - "947", - "5688", - "3790", - "6797", - "2842", - "14356", - "631", - "2526", - "315", - "3158", - "1421", - "12148", - "9631", - "473", - "4739", - "157", - "3470", - "3474", - "2056", - "6004", - "4106", - "946", - "1898", - "473", - "1894", - "10260", - "1578", - "6004", - "2842", - "7742", - "5055", - "1737", - "316", - "2052", - "2531", - "2997", - "790", - "2690", - "2685", - "2368", - "2053", - "9159", - "1581", - "157", - "1423", - "4422", - "632", - "2210", - "6321", - "474", - "315", - "8687", - "2373", - "12776", - "2839", - "8214", - "3155", - "1420", - "2526", - "1736", - "5371", - "1104", - "1265", - "4418", - "1895", - "4734", - "1740", - "5050", - "2210", - "474", - "6335", - "1105", - "158", - "475", - "2219", - "158", - "2848", - "316", - "1261", - "1107", - "1426", - "1268", - "1266", - "316", - "950", - "631", - "158", - "4749", - "2681", - "7287", - "3471", - "315", - "4116", - "3165", - "789", - "315", - "474", - "4419", - "157", - "157", - "1424", - "473", - "632", - "158", - "1743", - "1734", - "2057", - "1109", - "1103", - "2373", - "5383", - "2378", - "632", - "5066", - "3155", - "1263", - "792", - "157", - "791", - "1741", - "1899", - "3482", - "158", - "157", - "949", - "3787", - "1585", - "1105", - "1892", - "1419", - "1582", - "6018", - "2531", - "157", - "2215", - "158", - "475", - "158", - "5052", - "3007", - "1576", - "3799", - "946", - "316", - "6810", - "1902", - "158", - "5700", - "2524", - "947", - "316", - "4735", - "2839", - "158", - "2061", - "473", - "2208", - "948", - "4103", - "788", - "2366", - "2050", - "790", - "631", - "633", - "2997", - "4432", - "158", - "157", - "945", - "1258", - "788", - "943", - "1571", - "943", - "945", - "157", - "2046", - "2360", - "2203", - "157", - "157", - "157", - "314", - "157", - "1416", - "8656", - "786", - "629", - "157", - "1260", - "314", - "314", - "1100", - "473", - "7711", - "3144", - "157", - "314", - "157", - "5033", - "157", - "5978", - "787", - "157", - "2518", - "157", - "472", - "785", - "2515", - "2043", - "10232", - "1260", - "472", - "9129", - "1732", - "315", - "629", - "2674", - "4403", - "314", - "11493", - "1885", - "5348", - "2200", - "786", - "7238", - "157", - "1889", - "4718", - "628", - "2829", - "1417", - "1414", - "9602", - "1102", - "10862", - "942", - "3459", - "630", - "157", - "157", - "1257", - "1256", - "630", - "1575", - "2672", - "1728", - "157", - "157", - "1573", - "2987", - "1099", - "3774", - "157", - "1101", - "471", - "6293", - "6766", - "4089", - "2357", - "471", - "1102", - "8183", - "314", - "157", - "471", - "5663", - "13542", - "257131", - "148138", - "120943", - "53470", - "423973", - "98814", - "492541", - "41312", - "69265", - "24582", - "56313", - "990387", - "221214", - "72898", - "133907", - "232605", - "383599", - "20954", - "468469", - "43522", - "270265", - "30263", - "19850", - "698471", - "127267", - "330250", - "35313", - "210456", - "114936", - "33577", - "12754", - "572051", - "158", - "181033", - "517723", - "22058", - "734280", - "811292", - "14330", - "163794", - "31841", - "1271157", - "284191", - "45890", - "65790", - "1551882", - "23320", - "298752", - "771834", - "544173", - "664407", - "314104", - "601356", - "89331", - "76690", - "103871", - "364917", - "16853", - "1476381", - "190365", - "62472", - "1150485", - "140864", - "1094515", - "48259", - "12123", - "445666", - "942201", - "1336178", - "852812", - "244630", - "37207", - "17799", - "1041243", - "200173", - "80640", - "27264", - "28685", - "15119", - "84907", - "25844", - "1209313", - "1404532", - "475", - "93914", - "172176", - "18746", - "632088", - "50785", - "403231", - "347187", - "15907", - "39259", - "155728", - "59314", - "896396", - "316", - "109246", - "1268", - "633", - "320", - "16861", - "10334", - "5401", - "8265", - "2540", - "4447", - "800", - "792", - "25941", - "634", - "31997", - "793", - "6355", - "479", - "8742", - "951", - "7310", - "5083", - "2698", - "14313", - "1745", - "1586", - "28809", - "1269", - "1278", - "317", - "951", - "1744", - "18772", - "22117", - "1110", - "17816", - "15906", - "1119", - "639", - "1438", - "475", - "4765", - "320", - "2857", - "11607", - "12881", - "1281", - "37416", - "2381", - "1585", - "27375", - "39329", - "6833", - "3016", - "3175", - "1426", - "4129", - "640", - "15109", - "160", - "41402", - "2063", - "45872", - "3493", - "160", - "9220", - "10971", - "159", - "3811", - "9697", - "1428", - "799", - "160", - "6037", - "7788", - "43639", - "30403", - "2222", - "480", - "960", - "5719", - "23392", - "160", - "320", - "21002", - "33750", - "959", - "35503", - "480", - "1109", - "48264", - "1904", - "12244", - "19887", - "1121", - "24666", - "158", - "1902", - "160", - "1758", - "16161", - "160", - "966", - "4156", - "2257", - "18083", - "160", - "161", - "482", - "1442", - "2398", - "321", - "160", - "640", - "1918", - "4797", - "320", - "14559", - "160", - "480", - "3836", - "12316", - "1934", - "641", - "160", - "1282", - "1127", - "6878", - "801", - "3516", - "320", - "12957", - "6077", - "19044", - "3197", - "1121", - "7839", - "320", - "320", - "3036", - "801", - "2717", - "804", - "2558", - "965", - "2580", - "160", - "13758", - "9757", - "805", - "9275", - "17122", - "322", - "2418", - "160", - "2876", - "7358", - "4476", - "2095", - "1611", - "11035", - "320", - "1773", - "644", - "483", - "6398", - "321", - "1598", - "961", - "1450", - "11676", - "5757", - "482", - "8795", - "2078", - "15360", - "5117", - "8317", - "5437", - "10395", - "1289", - "2238", - "481", - "643", - "4202", - "19267", - "3064", - "6953", - "21536", - "7924", - "4849", - "5820", - "9382", - "2741", - "6144", - "3555", - "6468", - "13919", - "2261", - "5173", - "9867", - "1130", - "2584", - "2902", - "2423", - "3871", - "7439", - "31104", - "1453", - "3878", - "42472", - "17322", - "1291", - "40362", - "13109", - "32732", - "2908", - "11164", - "14729", - "3070", - "968", - "20401", - "807", - "1614", - "25265", - "52199", - "324", - "486", - "645", - "12460", - "54958", - "5496", - "1938", - "8410", - "3548", - "38253", - "2746", - "28022", - "44745", - "973", - "57880", - "36305", - "8896", - "322", - "47168", - "23968", - "49602", - "10515", - "487", - "162", - "18294", - "324", - "1776", - "64211", - "484", - "2099", - "26563", - "34520", - "16349", - "4525", - "3225", - "161", - "162", - "29482", - "15539", - "22671", - "649", - "11812", - "60964", - "811", - "3232", - "975", - "487", - "1637", - "3900", - "654", - "2292", - "2288", - "1473", - "4260", - "1145", - "978", - "2925", - "2456", - "326", - "8034", - "327", - "1624", - "653", - "1949", - "2115", - "1634", - "1794", - "162", - "163", - "1786", - "1789", - "1301", - "5572", - "3276", - "982", - "813", - "7542", - "816", - "489", - "980", - "2599", - "490", - "1952", - "2437", - "3112", - "2111", - "1138", - "163", - "3604", - "1464", - "815", - "3087", - "1965", - "4226", - "2948", - "1626", - "2784", - "2620", - "2124", - "6557", - "652", - "650", - "326", - "325", - "1461", - "4588", - "3250", - "2129", - "1307", - "1305", - "162", - "3932", - "1797", - "6229", - "5244", - "818", - "163", - "5901", - "1299", - "1143", - "654", - "491", - "817", - "163", - "1631", - "4916", - "1136", - "2762", - "3575", - "811", - "649", - "2274", - "326", - "1141", - "974", - "1801", - "7049", - "1309", - "489", - "1961", - "1470", - "1468", - "8526", - "165", - "498", - "9019", - "2309", - "1647", - "13288", - "14931", - "1313", - "2792", - "663", - "4291", - "1641", - "2134", - "1805", - "12631", - "492", - "1970", - "989", - "328", - "164", - "1814", - "1477", - "1488", - "9512", - "1979", - "14110", - "3300", - "11974", - "2315", - "329", - "820", - "1319", - "164", - "1153", - "10004", - "830", - "821", - "997", - "657", - "332", - "1812", - "328", - "658", - "164", - "656", - "3961", - "2970", - "2481", - "2150", - "661", - "1329", - "494", - "2805", - "331", - "330", - "497", - "659", - "991", - "492", - "165", - "1163", - "823", - "664", - "1148", - "497", - "1484", - "2627", - "984", - "824", - "1495", - "2474", - "166", - "2463", - "2639", - "1482", - "826", - "1322", - "329", - "3135", - "663", - "495", - "1977", - "1317", - "2144", - "1154", - "2298", - "1157", - "3630", - "165", - "988", - "1819", - "164", - "494", - "11318", - "1649", - "10661", - "1984", - "331", - "1653", - "501", - "1662", - "335", - "670", - "166", - "166", - "1167", - "834", - "1343", - "1172", - "1001", - "1000", - "2660", - "333", - "167", - "2327", - "2494", - "1511", - "1007", - "166", - "1676", - "671", - "667", - "1340", - "334", - "1828", - "500", - "500", - "1852", - "502", - "503", - "843", - "2193", - "2183", - "505", - "839", - "1679", - "335", - "2357", - "2869", - "667", - "1518", - "1843", - "1005", - "2362", - "1178", - "167", - "1683", - "335", - "1180", - "337", - "2526", - "1515", - "1346", - "504", - "2189", - "3038", - "167", - "2700", - "2688", - "337", - "1175", - "1502", - "1012", - "167", - "167", - "2015", - "834", - "674", - "1855", - "2024", - "1994", - "336", - "673", - "1669", - "3024", - "3192", - "1335", - "1009", - "167", - "1847", - "2351", - "2856", - "506", - "168", - "2020", - "841", - "2531", - "837", - "168", - "2694", - "168", - "2519", - "1508", - "1687", - "333", - "2161", - "1168", - "1349", - "1689", - "340", - "1351", - "29307", - "3042", - "3719", - "4057", - "7273", - "169", - "8289", - "10999", - "682", - "10322", - "339", - "1189", - "848", - "844", - "4396", - "12355", - "169", - "36092", - "25068", - "1858", - "6427", - "7781", - "1520", - "339", - "2365", - "1703", - "1362", - "2196", - "8797", - "20151", - "2535", - "2027", - "6088", - "2873", - "509", - "32530", - "1013", - "169", - "26424", - "339", - "9814", - "13710", - "30834", - "169", - "4734", - "1017", - "675", - "2039", - "1699", - "13033", - "3211", - "1533", - "1019", - "169", - "679", - "1187", - "14558", - "23711", - "851", - "5411", - "170", - "18117", - "22524", - "11677", - "2044", - "1182", - "170", - "17100", - "1529", - "508", - "15405", - "34226", - "341", - "1192", - "3381", - "5750", - "27781", - "19134", - "6766", - "9306", - "339", - "5073", - "2704", - "681", - "2215", - "1874", - "21338", - "1869", - "1359", - "510", - "511", - "1021", - "16252", - "849", - "170", - "678", - "1368", - "853", - "1712", - "6859", - "1024", - "2912", - "342", - "170", - "856", - "2398", - "3079", - "2908", - "1026", - "344", - "1197", - "2227", - "10465", - "2569", - "2052", - "2566", - "341", - "11152", - "1881", - "13213", - "342", - "12526", - "2055", - "21634", - "1541", - "1370", - "512", - "9435", - "20431", - "854", - "4113", - "6172", - "512", - "29714", - "38485", - "3084", - "8919", - "5486", - "171", - "45022", - "7889", - "19399", - "9950", - "42785", - "3256", - "170", - "24040", - "516", - "5829", - "7374", - "2741", - "2223", - "40549", - "34701", - "171", - "341", - "172", - "36593", - "682", - "11839", - "1195", - "15619", - "170", - "14760", - "8403", - "683", - "2395", - "5142", - "1710", - "17337", - "28167", - "18368", - "6515", - "4456", - "32981", - "3770", - "25416", - "26791", - "171", - "3427", - "684", - "1539", - "13901", - "31262", - "172", - "513", - "4799", - "2738", - "47430", - "1027", - "1884", - "1198", - "16478", - "22837", - "172", - "174", - "865", - "1558", - "344", - "2089", - "174", - "1726", - "1033", - "1550", - "692", - "688", - "176", - "522", - "347", - "517", - "174", - "348", - "345", - "174", - "346", - "1044", - "1381", - "173", - "690", - "1212", - "861", - "174", - "174", - "696", - "1385", - "174", - "173", - "1554", - "347", - "1208", - "522", - "173", - "1045", - "348", - "1916", - "696", - "348", - "871", - "1742", - "870", - "688", - "868", - "694", - "1899", - "696", - "697", - "172", - "522", - "519", - "173", - "346", - "1394", - "2072", - "176", - "348", - "172", - "522", - "348", - "2591", - "173", - "177", - "177", - "176", - "521", - "863", - "1035", - "1568", - "1722", - "2245", - "348", - "1220", - "1038", - "1378", - "1205", - "516", - "173", - "2418", - "1241", - "181", - "177", - "532", - "738", - "177", - "355", - "887", - "1241", - "184", - "709", - "544", - "367", - "362", - "1086", - "181", - "179", - "532", - "354", - "543", - "887", - "552", - "354", - "889", - "1774", - "724", - "357", - "709", - "177", - "531", - "184", - "711", - "184", - "922", - "355", - "184", - "533", - "184", - "535", - "1064", - "359", - "533", - "177", - "1104", - "354", - "180", - "369", - "532", - "1596", - "354", - "1067", - "1289", - "1419", - "920", - "178", - "177", - "179", - "354", - "177", - "354", - "183", - "181", - "181", - "553", - "181", - "709", - "354", - "532", - "886", - "183", - "362", - "354", - "368", - "736", - "368", - "184", - "709", - "905", - "177", - "1418", - "183", - "181", - "177", - "177", - "359", - "177", - "711", - "180", - "182", - "177", - "1064", - "177", - "5543", - "18683", - "1476", - "2966", - "2770", - "4434", - "7023", - "39436", - "555", - "2780", - "742", - "1292", - "12019", - "1853", - "4803", - "41475", - "2215", - "371", - "8503", - "43700", - "37398", - "3509", - "1107", - "7393", - "4079", - "13499", - "22017", - "3694", - "35541", - "32020", - "28870", - "9058", - "3151", - "4821", - "741", - "48519", - "5913", - "14240", - "927", - "9613", - "30353", - "185", - "20906", - "5173", - "2038", - "2955", - "2585", - "46109", - "1484", - "24610", - "1856", - "33688", - "2400", - "11278", - "4450", - "4064", - "5564", - "6306", - "16832", - "3324", - "27388", - "5935", - "3708", - "1482", - "2595", - "23313", - "12759", - "185", - "1299", - "15906", - "1667", - "7948", - "1846", - "1111", - "2409", - "2041", - "2224", - "6653", - "370", - "3337", - "1297", - "556", - "2030", - "17758", - "3139", - "1661", - "926", - "10723", - "1670", - "19795", - "5192", - "6283", - "14980", - "3522", - "10168", - "25907", - "1113", - "2599", - "744", - "557", - "2227", - "186", - "3727", - "10273", - "1488", - "1119", - "3342", - "1862", - "3359", - "745", - "557", - "371", - "186", - "7469", - "5227", - "1492", - "744", - "185", - "3528", - "185", - "185", - "1115", - "929", - "371", - "2971", - "557", - "3157", - "2421", - "2608", - "4106", - "372", - "371", - "11395", - "2612", - "8590", - "13639", - "2413", - "557", - "2235", - "185", - "12143", - "372", - "930", - "4853", - "2798", - "9151", - "185", - "2785", - "4100", - "743", - "1489", - "371", - "6348", - "8030", - "185", - "1116", - "2985", - "6721", - "9712", - "2981", - "743", - "3167", - "3732", - "929", - "3540", - "2425", - "5600", - "931", - "4479", - "372", - "3545", - "2794", - "1117", - "558", - "558", - "932", - "557", - "2048", - "1676", - "1302", - "1305", - "559", - "3354", - "2238", - "371", - "1303", - "10834", - "3172", - "186", - "2052", - "1678", - "1115", - "12891", - "5974", - "7095", - "1865", - "4473", - "129452", - "30666", - "187", - "1875", - "562", - "1501", - "1127", - "21121", - "1687", - "374", - "374", - "562", - "562", - "26174", - "17006", - "90882", - "175527", - "32351", - "1876", - "187", - "375", - "1126", - "1689", - "35892", - "750", - "60214", - "27671", - "23554", - "54411", - "143310", - "563", - "1314", - "1313", - "2253", - "29168", - "1315", - "1502", - "187", - "136194", - "1878", - "44127", - "86389", - "18876", - "74036", - "187", - "16070", - "41881", - "1125", - "187", - "751", - "39822", - "14387", - "937", - "1500", - "46560", - "19999", - "100616", - "66737", - "117093", - "111288", - "22244", - "123085", - "15135", - "938", - "563", - "158669", - "751", - "1312", - "17941", - "1125", - "37763", - "48994", - "166911", - "95562", - "77966", - "82084", - "51603", - "187", - "2250", - "2066", - "1691", - "63382", - "57218", - "184520", - "34028", - "150802", - "939", - "375", - "2438", - "105858", - "24864", - "375", - "187", - "1503", - "1690", - "938", - "2063", - "70293", - "750", - "1508", - "2641", - "3774", - "754", - "13745", - "7150", - "565", - "1886", - "3008", - "1130", - "188", - "3585", - "754", - "15253", - "3197", - "18080", - "1697", - "2074", - "753", - "2632", - "2820", - "5267", - "6020", - "377", - "755", - "565", - "1133", - "1879", - "5644", - "188", - "3207", - "2451", - "188", - "6774", - "10353", - "8657", - "377", - "12237", - "2830", - "4514", - "8092", - "1132", - "377", - "2452", - "566", - "1321", - "943", - "943", - "2263", - "1320", - "6397", - "2829", - "376", - "2068", - "7527", - "1697", - "2256", - "942", - "942", - "1132", - "4891", - "16195", - "944", - "754", - "4138", - "3573", - "1510", - "14499", - "11483", - "566", - "943", - "566", - "377", - "17138", - "188", - "1320", - "2263", - "1131", - "3396", - "188", - "3385", - "2444", - "3018", - "10918", - "9787", - "2074", - "1321", - "754", - "2640", - "1321", - "1509", - "1885", - "1132", - "3761", - "188", - "12991", - "9222", - "377", - "566", - "566", - "2463", - "188", - "188", - "377", - "754", - "3400", - "1132", - "3022", - "2455", - "1320", - "2077", - "943", - "1698", - "377", - "5290", - "1132", - "572", - "1510", - "1894", - "568", - "377", - "758", - "1515", - "381", - "378", - "3032", - "2084", - "3211", - "3778", - "566", - "943", - "1137", - "7559", - "1510", - "2273", - "1321", - "189", - "379", - "1321", - "1699", - "3222", - "6046", - "190", - "3589", - "379", - "755", - "2653", - "1136", - "2842", - "566", - "6424", - "190", - "948", - "4911", - "189", - "2833", - "7181", - "2644", - "1326", - "754", - "1707", - "1517", - "569", - "189", - "189", - "1132", - "379", - "188", - "8127", - "188", - "568", - "189", - "3790", - "4168", - "3601", - "1510", - "2266", - "5668", - "6802", - "4156", - "3411", - "943", - "1327", - "757", - "377", - "4534", - "759", - "1888", - "947", - "1705", - "192", - "957", - "191", - "6143", - "4222", - "28458", - "18450", - "1150", - "1531", - "3262", - "769", - "38858", - "9410", - "382", - "25571", - "575", - "1723", - "3454", - "191", - "2878", - "2686", - "766", - "10563", - "8833", - "20568", - "383", - "1342", - "1340", - "24224", - "35004", - "2110", - "574", - "1915", - "962", - "763", - "2106", - "29998", - "1154", - "13256", - "7296", - "963", - "4990", - "26919", - "1148", - "21723", - "1534", - "1347", - "385", - "1918", - "5374", - "1925", - "16526", - "3646", - "384", - "192", - "382", - "33271", - "12487", - "31538", - "9987", - "14795", - "5759", - "17488", - "19414", - "40976", - "22877", - "11718", - "577", - "2117", - "6912", - "3838", - "2302", - "36933", - "8257", - "14026", - "770", - "3070", - "190", - "1539", - "191", - "1155", - "958", - "6527", - "577", - "1732", - "11140", - "2494", - "191", - "15564", - "4606", - "7680", - "1726", - "765", - "2321", - "386", - "6970", - "6556", - "5398", - "3677", - "3871", - "1348", - "10031", - "14146", - "28578", - "3855", - "8327", - "3662", - "2119", - "6942", - "5033", - "1160", - "9452", - "580", - "2128", - "2505", - "773", - "37084", - "15632", - "39018", - "1926", - "18529", - "3289", - "19496", - "33411", - "193", - "25679", - "30125", - "1733", - "4626", - "17563", - "3483", - "4258", - "193", - "4241", - "1547", - "43272", - "11236", - "10610", - "11819", - "2708", - "7328", - "6583", - "3469", - "5420", - "10072", - "3083", - "2515", - "12541", - "27032", - "22974", - "2697", - "1353", - "24326", - "21814", - "10654", - "35151", - "8872", - "1934", - "13314", - "2902", - "967", - "1740", - "6195", - "5808", - "3096", - "7714", - "4645", - "5784", - "3276", - "8908", - "5012", - "193", - "41145", - "11769", - "31671", - "7358", - "1541", - "9490", - "13370", - "11189", - "2312", - "20655", - "8293", - "14922", - "14086", - "2890", - "6170", - "12595", - "16598", - "7746", - "14859", - "17638", - "2147", - "7403", - "3310", - "195", - "2336", - "194", - "585", - "10133", - "11304", - "11889", - "1757", - "10718", - "391", - "1761", - "2929", - "3516", - "195", - "19578", - "1946", - "780", - "1362", - "7793", - "1564", - "1751", - "2530", - "8378", - "9548", - "585", - "390", - "1565", - "18608", - "1956", - "1561", - "15011", - "973", - "1369", - "4674", - "1557", - "1171", - "2734", - "1173", - "1167", - "3700", - "1175", - "6233", - "20743", - "15698", - "586", - "16668", - "195", - "2725", - "390", - "782", - "194", - "3505", - "1173", - "2920", - "976", - "391", - "1366", - "13450", - "778", - "195", - "782", - "12669", - "4284", - "587", - "978", - "977", - "979", - "1368", - "195", - "7013", - "2538", - "2141", - "586", - "195", - "391", - "6623", - "780", - "195", - "3320", - "5843", - "8963", - "3711", - "391", - "14230", - "3115", - "195", - "3895", - "390", - "5064", - "3125", - "2343", - "389", - "583", - "1952", - "783", - "2744", - "1770", - "1371", - "2753", - "1570", - "1177", - "2163", - "787", - "981", - "1960", - "196", - "393", - "590", - "5894", - "591", - "1963", - "5501", - "197", - "1763", - "1766", - "2945", - "6681", - "588", - "4706", - "3338", - "3922", - "392", - "196", - "3147", - "2352", - "2159", - "589", - "5491", - "1573", - "3344", - "2356", - "3731", - "5904", - "5510", - "1179", - "3738", - "4314", - "5107", - "1966", - "3541", - "9041", - "4321", - "590", - "1567", - "7861", - "785", - "1374", - "2360", - "393", - "3725", - "7467", - "6691", - "3142", - "1181", - "394", - "8451", - "394", - "5099", - "4722", - "4714", - "6277", - "196", - "983", - "6669", - "197", - "3136", - "197", - "3535", - "786", - "2950", - "984", - "2548", - "1378", - "1376", - "9631", - "2556", - "3935", - "4328", - "788", - "5884", - "196", - "2940", - "2552", - "3529", - "6297", - "2749", - "787", - "2156", - "1576", - "6287", - "3333", - "7074", - "5116", - "393", - "3928", - "1185", - "598", - "998", - "592", - "599", - "796", - "798", - "1394", - "597", - "1794", - "199", - "197", - "3589", - "199", - "398", - "1797", - "1993", - "397", - "400", - "1395", - "398", - "199", - "395", - "3390", - "996", - "199", - "399", - "2991", - "200", - "200", - "3190", - "197", - "2000", - "996", - "399", - "2392", - "1993", - "799", - "796", - "988", - "799", - "400", - "597", - "1198", - "1594", - "790", - "197", - "1405", - "1594", - "1196", - "1400", - "199", - "197", - "199", - "1397", - "2591", - "2200", - "199", - "199", - "797", - "401", - "802", - "399", - "999", - "200", - "1997", - "599", - "599", - "1793", - "1600", - "1004", - "1204", - "602", - "400", - "592", - "1597", - "1195", - "398", - "601", - "401", - "199", - "1394", - "2192", - "803", - "2791", - "1200", - "199", - "200", - "399", - "395", - "996", - "1195", - "198", - "1800", - "999", - "200", - "199", - "4019", - "201", - "1606", - "605", - "889", - "201", - "2813", - "603", - "4824", - "201", - "205", - "410", - "5226", - "603", - "2665", - "408", - "2209", - "201", - "604", - "222", - "3416", - "2443", - "205", - "219", - "3818", - "2008", - "201", - "408", - "201", - "402", - "220", - "666", - "1007", - "1332", - "403", - "204", - "402", - "1776", - "1333", - "666", - "2611", - "1998", - "402", - "1110", - "3014", - "218", - "613", - "1006", - "204", - "2887", - "444", - "4422", - "805", - "403", - "2221", - "222", - "204", - "805", - "1554", - "804", - "888", - "221", - "221", - "201", - "3617", - "3215", - "1005", - "201", - "1111", - "1409", - "2410", - "402", - "219", - "1807", - "202", - "1207", - "201", - "222", - "444", - "3781", - "6676", - "29633", - "447", - "28072", - "3559", - "68228", - "3336", - "22498", - "12245", - "11577", - "16257", - "34763", - "47477", - "1563", - "7567", - "899", - "2446", - "2679", - "15365", - "8458", - "10240", - "26512", - "58410", - "20269", - "669", - "36547", - "2891", - "2009", - "893", - "4450", - "447", - "1118", - "895", - "19154", - "2001", - "1574", - "25174", - "40562", - "1342", - "4004", - "61534", - "223", - "8904", - "223", - "7121", - "1799", - "10908", - "8012", - "1339", - "14474", - "2668", - "2233", - "3114", - "224", - "6231", - "4227", - "49931", - "21384", - "446", - "4895", - "42792", - "64881", - "1124", - "55509", - "224", - "2456", - "449", - "1778", - "223", - "1116", - "1122", - "223", - "448", - "674", - "5340", - "897", - "673", - "224", - "1556", - "1346", - "671", - "13582", - "17148", - "52609", - "1349", - "9572", - "5785", - "12914", - "38554", - "45023", - "1786", - "2223", - "18040", - "23836", - "31194", - "32978", - "2253", - "2024", - "1355", - "679", - "1130", - "450", - "679", - "1802", - "1351", - "225", - "1356", - "3610", - "675", - "452", - "225", - "2481", - "2030", - "450", - "225", - "226", - "1577", - "2929", - "452", - "904", - "2704", - "1353", - "1818", - "901", - "225", - "677", - "3183", - "5417", - "2933", - "453", - "903", - "1588", - "3606", - "226", - "1363", - "3384", - "1131", - "905", - "677", - "1357", - "4965", - "907", - "1126", - "3159", - "2273", - "454", - "226", - "452", - "4062", - "678", - "2475", - "1578", - "2956", - "1127", - "226", - "3380", - "2256", - "451", - "225", - "681", - "1361", - "4514", - "451", - "5869", - "2046", - "909", - "1591", - "452", - "1134", - "2042", - "2249", - "1129", - "451", - "2728", - "1815", - "2269", - "676", - "3155", - "2707", - "4288", - "3836", - "225", - "905", - "227", - "1136", - "225", - "2478", - "2027", - "226", - "226", - "2501", - "678", - "902", - "2496", - "1804", - "680", - "2735", - "3188", - "1595", - "682", - "23059", - "2732", - "227", - "4332", - "5017", - "51175", - "4104", - "227", - "911", - "685", - "2516", - "683", - "457", - "66496", - "1143", - "2960", - "2051", - "3872", - "1593", - "228", - "1372", - "14834", - "18489", - "39514", - "21916", - "6843", - "12551", - "15748", - "3644", - "4561", - "227", - "24430", - "1821", - "228", - "1823", - "1366", - "17576", - "11865", - "9126", - "2049", - "13236", - "46144", - "11180", - "56891", - "5473", - "1138", - "2279", - "16662", - "7299", - "2277", - "3191", - "13921", - "43858", - "6386", - "2744", - "1829", - "2507", - "27172", - "455", - "30371", - "19632", - "8669", - "1600", - "5930", - "910", - "2504", - "9810", - "3420", - "3876", - "20774", - "3648", - "1139", - "10495", - "25801", - "28772", - "8212", - "457", - "2963", - "7756", - "455", - "1367", - "3416", - "63066", - "2058", - "48659", - "31971", - "35628", - "69914", - "41572", - "33800", - "53918", - "2287", - "73560", - "914", - "59864", - "37457", - "228", - "2531", - "1610", - "1836", - "1832", - "2061", - "2522", - "687", - "917", - "4353", - "2296", - "2982", - "1605", - "2977", - "2761", - "1840", - "3441", - "2535", - "2290", - "460", - "5065", - "688", - "2755", - "4143", - "1152", - "3665", - "2304", - "2301", - "229", - "1603", - "230", - "3436", - "686", - "457", - "1146", - "459", - "4129", - "229", - "1607", - "3682", - "2070", - "1382", - "4124", - "4604", - "915", - "459", - "2066", - "2293", - "1613", - "1834", - "1374", - "230", - "1144", - "691", - "2748", - "2752", - "689", - "3900", - "690", - "229", - "2996", - "3227", - "1843", - "4373", - "2519", - "1150", - "4589", - "3215", - "458", - "1375", - "5525", - "3445", - "229", - "460", - "3670", - "1147", - "3894", - "3211", - "918", - "2074", - "920", - "1377", - "229", - "2526", - "4359", - "3452", - "2991", - "3207", - "2765", - "3222", - "229", - "3913", - "921", - "2985", - "459", - "1380", - "2063", - "229", - "2078", - "10611", - "3695", - "14103", - "14074", - "8782", - "13409", - "9226", - "1847", - "3464", - "6007", - "14998", - "461", - "2540", - "10632", - "6484", - "12689", - "6918", - "230", - "6932", - "4149", - "923", - "1619", - "4399", - "7857", - "462", - "8303", - "4620", - "7841", - "9266", - "4158", - "3002", - "16879", - "1385", - "5072", - "7379", - "231", - "3472", - "3927", - "8338", - "11326", - "5545", - "13381", - "2777", - "5082", - "3704", - "7394", - "230", - "4167", - "1388", - "5995", - "5094", - "11303", - "461", - "2546", - "8764", - "6021", - "231", - "1154", - "5533", - "1851", - "2082", - "6456", - "2314", - "4631", - "3009", - "9245", - "15954", - "17805", - "3688", - "4611", - "11996", - "925", - "7875", - "692", - "15921", - "1157", - "8802", - "3919", - "1616", - "8319", - "4389", - "2309", - "5557", - "7411", - "4380", - "3233", - "3457", - "2771", - "12020", - "6469", - "3935", - "9918", - "15028", - "9939", - "3240", - "12714", - "694", - "6948", - "462", - "74720", - "169048", - "30837", - "96785", - "152781", - "124896", - "160682", - "623252", - "26196", - "42209", - "44530", - "118623", - "15062", - "840828", - "17845", - "82848", - "359693", - "29213", - "71004", - "196939", - "266215", - "51963", - "145344", - "40120", - "253196", - "1253302", - "87262", - "461798", - "1455395", - "22252", - "34318", - "724005", - "187177", - "1317327", - "107239", - "14134", - "36174", - "655128", - "13439", - "688635", - "883884", - "1134341", - "217859", - "240874", - "294349", - "799868", - "32461", - "60786", - "177880", - "536471", - "510416", - "11352", - "761005", - "78668", - "12047", - "325276", - "138141", - "1608145", - "24804", - "112815", - "279933", - "1529906", - "23412", - "49405", - "207167", - "1079171", - "1384613", - "91907", - "15990", - "67520", - "9961", - "46851", - "417837", - "563923", - "12743", - "64037", - "378065", - "1026563", - "342019", - "27588", - "57768", - "397369", - "10656", - "485525", - "131402", - "1192307", - "16917", - "19933", - "439236", - "309463", - "929037", - "229018", - "976519", - "592773", - "54749", - "18773", - "21092", - "38031", - "101896", - "3498", - "6990", - "64517", - "11438", - "61242", - "26395", - "1629", - "2332", - "24993", - "55160", - "2328", - "58201", - "6523", - "1399", - "2565", - "931", - "12840", - "1867569", - "5599", - "10737", - "49780", - "1862", - "2561", - "4192", - "40424", - "2168950", - "36449", - "1776744", - "6057", - "465", - "2279823", - "1632", - "233", - "5125", - "4199", - "232", - "466", - "13541", - "2095", - "22421", - "12139", - "7934", - "4659", - "7922", - "52353", - "2794", - "4425", - "699", - "3027", - "5591", - "8402", - "42529", - "2063439", - "3032", - "23590", - "7456", - "1396", - "6066", - "7000", - "3493", - "34578", - "20084", - "38320", - "2098", - "3965", - "9336", - "3726", - "2798", - "3265", - "47207", - "1164", - "1963057", - "44868", - "15176", - "16111", - "68027", - "1865", - "3260", - "21253", - "18915", - "1165", - "4432", - "1690347", - "17981", - "8869", - "3732", - "5133", - "932", - "4666", - "32708", - "17046", - "698", - "7467", - "3959", - "27798", - "31071", - "29434", - "6533", - "14242", - "10037", - "234", - "2344", - "71536", - "254951", - "97511", - "3516", - "983279", - "2182744", - "380685", - "935469", - "846650", - "6567", - "400054", - "7506", - "161907", - "281873", - "1141998", - "1640", - "1326217", - "296389", - "87916", - "3282", - "234", - "198372", - "1975542", - "79258", - "596776", - "3047", - "132404", - "1033670", - "464918", - "488805", - "230605", - "188539", - "1393958", - "344389", - "219407", - "2076562", - "3751", - "703", - "311608", - "2109", - "102660", - "468", - "1879207", - "113675", - "1200355", - "3986", - "567732", - "6098", - "1539967", - "208674", - "146452", - "125848", - "1406", - "766274", - "4690", - "805407", - "890004", - "7037", - "2578", - "614508", - "1618444", - "362185", - "1261761", - "468", - "108043", - "5159", - "268060", - "1875", - "179205", - "92596", - "513864", - "153945", - "693344", - "1700881", - "139194", - "1464967", - "659552", - "4455", - "540095", - "937", - "4220", - "119528", - "729018", - "420660", - "5629", - "1787816", - "442203", - "75280", - "170337", - "83470", - "242543", - "2813", - "2294321", - "1171", - "1086456", - "327530", - "12202", - "10089", - "19014", - "26533", - "15256", - "34759", - "7976", - "93091", - "9385", - "71919", - "42751", - "20189", - "18074", - "220664", - "64862", - "162751", - "631321", - "68390", - "8445", - "21364", - "32879", - "79681", - "10793", - "516982", - "313446", - "55455", - "50046", - "444887", - "83916", - "329462", - "58512", - "61570", - "147216", - "189587", - "98032", - "103208", - "14316", - "402482", - "75682", - "45102", - "29588", - "11498", - "491771", - "8915", - "40635", - "663610", - "126505", - "88386", - "256455", - "114268", - "382930", - "13612", - "243974", - "231966", - "31233", - "298137", - "209834", - "22538", - "171225", - "52633", - "25123", - "1207736", - "1093137", - "543372", - "770856", - "27943", - "941062", - "1149021", - "571177", - "139920", - "283536", - "1333919", - "467739", - "364321", - "989158", - "17135", - "108620", - "154748", - "38520", - "851712", - "269642", - "36639", - "12907", - "697551", - "733378", - "346420", - "810223", - "1039850", - "120151", - "895325", - "23713", - "133094", - "47459", - "16195", - "423213", - "199475", - "180170", - "1269305", - "600448", - "1548911", - "1628121", - "15337", - "6602", - "47722", - "471", - "4007", - "12976", - "18171", - "1987437", - "2592", - "2089065", - "58836", - "40866", - "34951", - "33061", - "29749", - "235", - "52924", - "120815", - "11559", - "23840", - "2828", - "80122", - "2120", - "72316", - "127204", - "21477", - "140693", - "55762", - "26674", - "10143", - "1711343", - "38738", - "7546", - "706", - "155603", - "28092", - "10851", - "84380", - "1413", - "31403", - "114900", - "68769", - "7074", - "1885", - "181166", - "8490", - "4243", - "98574", - "19116", - "12267", - "76101", - "4715", - "20296", - "1798812", - "16281", - "5186", - "200577", - "2356", - "22658", - "163651", - "3299", - "17226", - "2195885", - "3771", - "13684", - "88875", - "1890765", - "103779", - "148030", - "36847", - "50323", - "3535", - "5658", - "4479", - "133830", - "65221", - "8963", - "1178", - "1473475", - "190635", - "42993", - "2308133", - "6130", - "8018", - "9435", - "1649", - "93606", - "25257", - "1401815", - "14392", - "3063", - "61910", - "172172", - "942", - "45358", - "109221", - "1897", - "7119", - "17335", - "1999500", - "856449", - "210993", - "701342", - "470322", - "1558314", - "634753", - "385045", - "285103", - "2134", - "2101745", - "348334", - "1155410", - "16384", - "1422", - "948", - "474", - "1045632", - "245323", - "366334", - "237", - "7594", - "1659", - "22801", - "21613", - "1341791", - "2608", - "1721732", - "28269", - "221883", - "1410326", - "315177", - "1185", - "10207", - "299784", - "9494", - "6644", - "3795", - "2322141", - "5220", - "447344", - "994659", - "2209212", - "233248", - "711", - "546372", - "2371", - "13058", - "3558", - "1214451", - "1276578", - "667217", - "9019", - "26843", - "20425", - "3083", - "404705", - "5694", - "519837", - "1482421", - "257872", - "4033", - "29933", - "8069", - "425550", - "10919", - "271132", - "737457", - "14483", - "775144", - "814729", - "331282", - "603712", - "900304", - "19236", - "11632", - "574331", - "946295", - "23990", - "1809732", - "4745", - "6169", - "15434", - "12345", - "18285", - "13770", - "2846", - "1638005", - "1902242", - "1099216", - "8544", - "3320", - "31598", - "25416", - "494487", - "4507", - "4270", - "1000453", - "156531", - "671191", - "59187", - "104398", - "121536", - "272748", - "38969", - "33262", - "43250", - "333256", - "212251", - "72748", - "173198", - "1908", - "134628", - "45628", - "48007", - "1162140", - "164626", - "182246", - "89405", - "99162", - "428085", - "62280", - "861439", - "1284014", - "80600", - "317055", - "368516", - "301571", - "2335660", - "1913318", - "705518", - "2011142", - "1567389", - "522933", - "819476", - "115585", - "148912", - "2113981", - "1192", - "141532", - "1731758", - "951808", - "741754", - "109872", - "1820269", - "450009", - "1418540", - "1221525", - "779661", - "2146", - "286802", - "953", - "387339", - "94164", - "2624", - "37067", - "2862", - "2385", - "69179", - "1349606", - "476", - "50623", - "1105619", - "473124", - "1647544", - "53240", - "715", - "56094", - "638533", - "201773", - "607308", - "35164", - "3340", - "191771", - "1051723", - "1491055", - "2222074", - "1669", - "407116", - "3101", - "246785", - "1431", - "905550", - "259409", - "84883", - "549627", - "238", - "127963", - "577751", - "350409", - "234638", - "497432", - "41109", - "223206", - "65610", - "76555", - "3579", - "1196", - "12417", - "5728", - "1197", - "13850", - "17436", - "43501", - "5250", - "21738", - "7161", - "718", - "18392", - "14568", - "9550", - "85376", - "478", - "8116", - "2393", - "1436", - "4534", - "25564", - "478", - "4295", - "53549", - "4309", - "24129", - "16479", - "9072", - "957", - "105004", - "110510", - "45893", - "59530", - "30107", - "239", - "10266", - "4056", - "13134", - "37282", - "1914", - "26999", - "10983", - "3817", - "22934", - "478", - "239", - "50917", - "56420", - "81068", - "6701", - "31781", - "65991", - "39196", - "3830", - "15523", - "20543", - "4549", - "99738", - "6683", - "2154", - "11700", - "28433", - "3590", - "76999", - "3112", - "8594", - "89924", - "19348", - "41348", - "4789", - "2633", - "33455", - "5267", - "4069", - "957", - "5745", - "69581", - "7180", - "1675", - "717", - "73170", - "2872", - "239", - "6223", - "3351", - "4773", - "35369", - "94711", - "6205", - "7638", - "62641", - "48286", - "478", - "4794", - "956", - "716", - "8614", - "1194", - "9569", - "478", - "4315", - "2637", - "1434", - "4555", - "958", - "3596", - "7658", - "2150", - "6712", - "719", - "10285", - "239", - "955", - "7671", - "14624", - "1195", - "15583", - "238", - "1917", - "955", - "1434", - "13904", - "2397", - "239", - "1912", - "716", - "479", - "9091", - "12466", - "8630", - "18462", - "717", - "5753", - "3835", - "239", - "1673", - "477", - "956", - "8151", - "4075", - "3116", - "1433", - "1438", - "477", - "1195", - "1673", - "11028", - "6233", - "17503", - "13185", - "2157", - "16542", - "1912", - "2391", - "717", - "8136", - "10308", - "239", - "7192", - "1198", - "239", - "3356", - "2151", - "2876", - "11747", - "9589", - "1678", - "9110", - "5274", - "19421", - "56635", - "719", - "95032", - "24219", - "51115", - "20620", - "23020", - "46076", - "719", - "825531", - "27097", - "479", - "453562", - "116630", - "2398", - "239", - "25674", - "62874", - "225101", - "23035", - "24234", - "353250", - "2159", - "28536", - "289175", - "77273", - "193423", - "85672", - "304054", - "476840", - "431484", - "43676", - "479", - "643386", - "1919", - "157906", - "41516", - "390447", - "214062", - "582191", - "248859", - "410365", - "747297", - "73433", - "371489", - "48475", - "122629", - "183824", - "166066", - "553873", - "37436", - "1439", - "66234", - "785454", - "239", - "27114", - "150227", - "100071", - "21821", - "236620", - "1679", - "710820", - "203503", - "69834", - "25658", - "30233", - "501318", - "676263", - "479", - "1199", - "142788", - "105351", - "135828", - "319653", - "959", - "2638", - "39356", - "33593", - "90232", - "59755", - "174705", - "21835", - "28554", - "335972", - "239", - "239", - "81353", - "526996", - "110870", - "31913", - "35517", - "53755", - "275017", - "129109", - "611949", - "261578", - "53905", - "25746", - "9600", - "32006", - "13200", - "21896", - "1200", - "4800", - "16560", - "867767", - "960", - "720", - "43798", - "5760", - "28633", - "1440", - "240", - "63050", - "81580", - "51258", - "19440", - "12480", - "30321", - "59921", - "7200", - "20640", - "73638", - "3120", - "6720", - "3840", - "6240", - "24305", - "11760", - "3360", - "2160", - "7680", - "481", - "27190", - "721", - "18480", - "111180", - "33691", - "481", - "13920", - "14640", - "240", - "11040", - "27193", - "240", - "56793", - "17520", - "21896", - "23102", - "15600", - "28637", - "77489", - "5280", - "962", - "10320", - "912163", - "35616", - "721", - "958720", - "46204", - "41632", - "30318", - "481", - "39466", - "95297", - "8640", - "70029", - "24302", - "480", - "2400", - "116955", - "4080", - "1680", - "1443", - "66419", - "23099", - "48611", - "3600", - "37541", - "1202", - "100351", - "4560", - "105645", - "4320", - "240", - "90484", - "8160", - "85912", - "240", - "1920", - "2640", - "2880", - "9120", - "962", - "25749", - "122972", - "1203", - "240", - "722", - "129469", - "481", - "481", - "4817", - "4093", - "963", - "7227", - "4095", - "2408", - "3852", - "3853", - "4094", - "8673", - "1926", - "1686", - "2407", - "18550", - "6263", - "15659", - "30355", - "4335", - "240", - "16623", - "1686", - "17587", - "14696", - "5782", - "4333", - "4577", - "481", - "9636", - "2166", - "240", - "2889", - "11082", - "3611", - "1926", - "4818", - "2168", - "2167", - "28669", - "3131", - "20719", - "3613", - "722", - "2890", - "3372", - "7709", - "240", - "2409", - "21923", - "1685", - "1445", - "25778", - "1444", - "5298", - "963", - "722", - "4336", - "963", - "6745", - "9154", - "23128", - "143186", - "10359", - "1204", - "13250", - "2649", - "8191", - "32042", - "3131", - "136207", - "3854", - "150646", - "3612", - "19514", - "33728", - "240", - "481", - "13973", - "1927", - "2891", - "2648", - "27223", - "3372", - "4576", - "12527", - "1445", - "11805", - "24332", - "1204", - "3370", - "5300", - "2650", - "3130", - "35656", - "46256", - "53966", - "90585", - "3615", - "184544", - "43847", - "241", - "56857", - "1687", - "1206", - "105763", - "63121", - "1688", - "73721", - "3856", - "237547", - "482", - "2892", - "51315", - "2652", - "1205", - "3133", - "964", - "964", - "241", - "2893", - "4583", - "2410", - "158525", - "150815", - "2411", - "111305", - "964", - "3859", - "136360", - "214900", - "964", - "4100", - "240", - "2412", - "2170", - "129614", - "1446", - "2894", - "37583", - "1928", - "41679", - "66493", - "723", - "123110", - "3374", - "1446", - "1688", - "2653", - "70107", - "723", - "59989", - "204300", - "3377", - "482", - "117087", - "143347", - "723", - "166716", - "3135", - "241", - "1205", - "1205", - "175389", - "1447", - "964", - "482", - "81671", - "48665", - "241", - "100463", - "1929", - "95404", - "482", - "2170", - "1446", - "723", - "4341", - "225982", - "77576", - "241", - "723", - "241", - "1205", - "2169", - "482", - "3618", - "194181", - "39510", - "2651", - "482", - "86008", - "1929", - "100588", - "27257", - "1447", - "56927", - "12543", - "11096", - "1206", - "129776", - "10372", - "136530", - "15679", - "5789", - "8201", - "46314", - "151003", - "28705", - "25810", - "16644", - "14714", - "35700", - "2653", - "51379", - "276438", - "90698", - "184774", - "355075", - "21951", - "5306", - "482", - "9166", - "77672", - "81773", - "2895", - "4824", - "86115", - "321305", - "194423", - "7236", - "7719", - "9648", - "13990", - "17609", - "20744", - "43902", - "3136", - "32082", - "204554", - "262929", - "241", - "13267", - "433713", - "158722", - "11819", - "111443", - "166924", - "175608", - "123263", - "23157", - "965", - "6754", - "3377", - "24363", - "250145", - "8683", - "455905", - "95523", - "226264", - "70195", - "305625", - "479304", - "54033", - "392464", - "337708", - "60063", - "30393", - "73813", - "412486", - "1930", - "117232", - "37630", - "48726", - "66576", - "290670", - "2171", - "215168", - "39560", - "237842", - "41731", - "19538", - "105895", - "503908", - "1688", - "2412", - "143525", - "723", - "18573", - "33770", - "6271", - "373408", - "63199", - "32086", - "237872", - "30397", - "250176", - "9167", - "204580", - "15681", - "23160", - "24366", - "5790", - "8202", - "48732", - "4101", - "7237", - "226292", - "54040", - "3618", - "33775", - "19541", - "18576", - "194447", - "6755", - "70203", - "43907", - "679842", - "11097", - "37635", - "17611", - "77682", - "9650", - "215195", - "66585", - "63207", - "10373", - "479363", - "14716", - "276472", - "28708", - "105908", - "3860", - "16646", - "11821", - "7720", - "290706", - "166945", - "86126", - "529785", - "184797", - "39565", - "714582", - "111457", - "503971", - "56935", - "73822", - "117247", - "151022", - "46320", - "95535", - "615187", - "41736", - "27261", - "51386", - "90710", - "60071", - "4342", - "455962", - "5307", - "136547", - "321345", - "6272", - "129792", - "585272", - "337750", - "373455", - "392513", - "262962", - "123278", - "21953", - "646791", - "25813", - "81783", - "12545", - "100601", - "355120", - "20747", - "751252", - "175630", - "305663", - "13268", - "4583", - "8685", - "789611", - "13992", - "4825", - "433767", - "556805", - "412537", - "35705", - "143543", - "158742", - "3860", - "1930", - "1064877", - "33779", - "24369", - "482", - "16648", - "20750", - "90721", - "9651", - "7720", - "1236647", - "11098", - "1688", - "1176576", - "6273", - "4584", - "23162", - "241", - "963793", - "5308", - "5790", - "1366198", - "56942", - "48738", - "1586460", - "13994", - "105921", - "46325", - "51392", - "95546", - "129808", - "1447", - "81793", - "7238", - "2171", - "4825", - "11822", - "872360", - "829900", - "1842185", - "4101", - "18578", - "1667520", - "2035185", - "1299855", - "1752681", - "1013008", - "77692", - "37639", - "12546", - "3377", - "1206", - "73831", - "8203", - "86136", - "9168", - "21956", - "41741", - "27264", - "2363285", - "2139163", - "17613", - "6755", - "916991", - "2895", - "10375", - "100613", - "965", - "54046", - "63215", - "117262", - "28712", - "60078", - "70212", - "13270", - "66593", - "123294", - "723", - "3136", - "35709", - "1119400", - "15683", - "1435920", - "2412", - "4343", - "43912", - "32090", - "111471", - "3619", - "39569", - "1509260", - "19543", - "25816", - "30401", - "8686", - "1936272", - "14718", - "2654", - "2248450", - "166965", - "237931", - "143561", - "646952", - "1366708", - "1509823", - "8207", - "1587051", - "1689", - "1237108", - "184820", - "151041", - "529916", - "337834", - "1206", - "4103", - "1065274", - "7242", - "1436455", - "226320", - "4344", - "789905", - "13277", - "751532", - "321424", - "1448", - "456075", - "412640", - "194471", - "1842872", - "305739", - "392611", - "556943", - "714849", - "504096", - "8690", - "830209", - "14001", - "482", - "5792", - "1753335", - "1930", - "204605", - "10380", - "3861", - "136564", - "433875", - "1013386", - "4586", - "3620", - "276541", - "1668142", - "964153", - "16656", - "1119817", - "965", - "4827", - "6275", - "1936994", - "11104", - "158762", - "917333", - "9656", - "11828", - "680011", - "175651", - "12552", - "7724", - "241", - "1300339", - "2413", - "2172", - "355208", - "2655", - "6759", - "479482", - "3379", - "2249288", - "724", - "3137", - "2896", - "585418", - "290778", - "9173", - "14725", - "5310", - "250238", - "872685", - "2139961", - "1177015", - "2035944", - "615340", - "373547", - "2364166", - "215221", - "15691", - "263027", - "17622", - "27278", - "143633", - "167048", - "100663", - "355340", - "6277", - "482", - "1931", - "1207", - "321544", - "95594", - "30416", - "4828", - "63246", - "39589", - "9657", - "66626", - "724", - "48762", - "10381", - "158841", - "3862", - "23174", - "15692", - "123355", - "250331", - "46348", - "18587", - "24381", - "3621", - "3380", - "276644", - "238020", - "117320", - "12554", - "2172", - "5311", - "111526", - "37658", - "7725", - "184912", - "105974", - "28726", - "43934", - "136632", - "305853", - "14727", - "35727", - "54073", - "4104", - "175739", - "73868", - "21967", - "32106", - "226433", - "18590", - "151116", - "17624", - "2414", - "4345", - "56970", - "337960", - "14002", - "194568", - "263126", - "5794", - "19553", - "2655", - "241", - "81834", - "13278", - "60108", - "77730", - "290887", - "204707", - "8691", - "4587", - "11105", - "86179", - "2897", - "20760", - "1448", - "215328", - "1690", - "9174", - "70247", - "965", - "11830", - "90766", - "51418", - "16658", - "41762", - "8208", - "7242", - "6760", - "3138", - "129873", - "33796", - "25829", - "263191", - "19555", - "39594", - "51424", - "504409", - "27281", - "151153", - "111540", - "136666", - "373780", - "557289", - "117349", - "25833", - "100676", - "86190", - "873119", - "63254", - "66634", - "41767", - "1120374", - "830622", - "54080", - "412896", - "143668", - "1668971", - "434145", - "290959", - "1587840", - "46354", - "1177600", - "456359", - "175782", - "530246", - "194616", - "338044", - "585781", - "1065804", - "184958", - "305929", - "30420", - "276713", - "81844", - "73877", - "24384", - "715204", - "90777", - "77740", - "2250686", - "60116", - "238079", - "1754206", - "35731", - "37663", - "1300986", - "123386", - "56977", - "680434", - "964632", - "392855", - "204758", - "70256", - "226489", - "105987", - "48768", - "1510573", - "28730", - "1367387", - "1237723", - "2037209", - "1844017", - "2141291", - "33800", - "167090", - "790298", - "215382", - "917789", - "479781", - "95606", - "321624", - "23177", - "355429", - "1013890", - "43940", - "20762", - "483", - "241", - "1938198", - "647354", - "724", - "129905", - "615723", - "751906", - "21970", - "158880", - "1437169", - "2365636", - "250394", - "32110", - "2656", - "194665", - "5313", - "17630", - "33812", - "143704", - "12559", - "51443", - "30431", - "8211", - "4105", - "21978", - "226545", - "8694", - "9660", - "106027", - "129937", - "966", - "151191", - "3622", - "77769", - "60138", - "2173", - "15698", - "9177", - "3864", - "14732", - "2415", - "3139", - "185004", - "100713", - "48787", - "16664", - "123416", - "41782", - "10385", - "25842", - "167131", - "1449", - "355517", - "11109", - "263256", - "28740", - "3381", - "37677", - "14008", - "81875", - "434252", - "39609", - "73905", - "412999", - "136700", - "11834", - "1690", - "32122", - "54100", - "117378", - "95641", - "6762", - "7728", - "111582", - "306005", - "291031", - "63278", - "70282", - "46371", - "35744", - "5796", - "24393", - "215435", - "13283", - "20770", - "66659", - "204808", - "392953", - "56998", - "250456", - "4830", - "18597", - "456472", - "19563", - "175826", - "321704", - "86222", - "1932", - "2898", - "158920", - "1207", - "23185", - "4588", - "27291", - "43956", - "4347", - "276781", - "7245", - "373872", - "6279", - "338128", - "238138", - "90811", - "585927", - "4589", - "483", - "1588235", - "6763", - "241", - "2173", - "504535", - "14734", - "4347", - "15700", - "680603", - "647515", - "557428", - "9178", - "1238031", - "3864", - "1690", - "479900", - "715382", - "4106", - "1367727", - "1449", - "3140", - "2898", - "918017", - "3623", - "17633", - "23188", - "2657", - "70291", - "63286", - "3381", - "11835", - "1066069", - "1437527", - "27295", - "2037462", - "873336", - "964872", - "1120652", - "39614", - "12560", - "54107", - "966", - "21981", - "5314", - "41788", - "60145", - "16666", - "1301309", - "752093", - "1938439", - "2365929", - "4831", - "2141557", - "46377", - "1669386", - "13285", - "6280", - "24396", - "28744", - "11111", - "19565", - "35749", - "37681", - "1754642", - "43962", - "51450", - "73914", - "7729", - "724", - "790494", - "10386", - "48793", - "30435", - "1510949", - "530377", - "1177893", - "32126", - "8695", - "14009", - "20773", - "33817", - "2415", - "9662", - "8212", - "830828", - "2250966", - "615876", - "66667", - "1932", - "5797", - "18599", - "25845", - "1844246", - "1207", - "57005", - "1014142", - "7246", - "2657", - "9663", - "483", - "28748", - "143722", - "18601", - "8696", - "1691", - "158939", - "25849", - "167152", - "4348", - "1449", - "151210", - "111609", - "185027", - "86244", - "7730", - "51456", - "250487", - "32130", - "14011", - "86233", - "7247", - "20775", - "3382", - "23191", - "175848", - "14736", - "13286", - "1207", - "111596", - "4106", - "30439", - "81885", - "48799", - "41793", - "11112", - "90834", - "1932", - "129953", - "117393", - "194689", - "15702", - "57012", - "2174", - "77788", - "106040", - "966", - "8213", - "12562", - "5797", - "204834", - "238168", - "241", - "60153", - "263289", - "90822", - "70299", - "136717", - "100726", - "724", - "17635", - "46383", - "3623", - "16669", - "24399", - "63293", - "3140", - "35753", - "21983", - "226573", - "4590", - "100738", - "6764", - "9180", - "4831", - "19567", - "43967", - "66676", - "95665", - "95653", - "77779", - "39619", - "37686", - "54113", - "6281", - "2898", - "27298", - "33821", - "3865", - "106053", - "215462", - "5314", - "123432", - "2415", - "73923", - "81895", - "10387", - "11837", - "117407", - "238197", - "530509", - "752280", - "263322", - "175870", - "680772", - "373965", - "434360", - "647675", - "276850", - "616029", - "129970", - "250518", - "143740", - "123447", - "185050", - "413101", - "136734", - "456586", - "158959", - "1933", - "1691", - "1437884", - "1669800", - "557566", - "1368067", - "724", - "3382", - "504660", - "241", - "291103", - "1120931", - "5315", - "1449", - "966", - "306081", - "151229", - "226602", - "1588630", - "1511324", - "2416", - "321784", - "1932", - "393050", - "4590", - "965112", - "1691", - "167173", - "4348", - "241", - "790691", - "1238339", - "2366517", - "204859", - "1938921", - "2142089", - "1844704", - "194713", - "2037968", - "1066334", - "2174", - "1450", - "5798", - "1691", - "715559", - "873553", - "1208", - "966", - "725", - "6281", - "1755078", - "241", - "2899", - "483", - "1208", - "1208", - "966", - "2251525", - "3624", - "4107", - "3865", - "3140", - "724", - "215489", - "1014394", - "1449", - "6765", - "480019", - "483", - "2657", - "586073", - "483", - "918245", - "338212", - "831035", - "1178185", - "4832", - "355605", - "1301633", - "3141", - "18610", - "23203", - "32146", - "483", - "21994", - "1691", - "7251", - "7734", - "16677", - "14743", - "2175", - "2658", - "2900", - "5800", - "12568", - "1208", - "1935", - "4592", - "13293", - "2418", - "725", - "966", - "17644", - "8707", - "4837", - "6288", - "3142", - "1450", - "3625", - "35771", - "3383", - "25861", - "11118", - "725", - "2902", - "4108", - "3383", - "24411", - "2417", - "4108", - "3628", - "4834", - "8223", - "33838", - "3867", - "4595", - "2175", - "37705", - "483", - "11852", - "8217", - "5805", - "5317", - "5321", - "2900", - "4353", - "3144", - "9675", - "6767", - "4350", - "725", - "241", - "20786", - "1209", - "2658", - "3870", - "483", - "14018", - "13303", - "15710", - "1451", - "10393", - "9668", - "3866", - "7740", - "9191", - "967", - "3386", - "11126", - "11843", - "2176", - "9184", - "1693", - "4111", - "19577", - "27312", - "3625", - "2416", - "241", - "6284", - "28762", - "30454", - "2660", - "7256", - "8701", - "12577", - "10400", - "6772", - "1933", - "1216", - "3870", - "4865", - "10460", - "4112", - "5322", - "28947", - "7784", - "5838", - "1459", - "8708", - "1693", - "2902", - "3892", - "15811", - "24569", - "8757", - "2661", - "2919", - "36002", - "730", - "11189", - "2177", - "243", - "11919", - "4596", - "1460", - "6773", - "3144", - "7741", - "243", - "3386", - "973", - "1451", - "243", - "1946", - "729", - "22136", - "18731", - "1209", - "9192", - "4354", - "8224", - "6289", - "5351", - "2419", - "4621", - "27488", - "26028", - "2675", - "486", - "1217", - "3648", - "2189", - "967", - "9243", - "243", - "4838", - "486", - "1217", - "1702", - "486", - "1216", - "30650", - "34056", - "486", - "19704", - "32353", - "1460", - "4135", - "12649", - "730", - "17757", - "5805", - "2432", - "9730", - "4378", - "14838", - "6811", - "1935", - "243", - "973", - "973", - "1459", - "7257", - "13379", - "3162", - "16784", - "973", - "8270", - "7297", - "20920", - "23352", - "486", - "14109", - "3405", - "729", - "6324", - "730", - "3628", - "1704", - "13390", - "2434", - "37981", - "7304", - "14851", - "82536", - "5843", - "26051", - "32381", - "57458", - "240061", - "3165", - "70849", - "24590", - "10469", - "22155", - "30677", - "46746", - "177246", - "42120", - "124413", - "160203", - "54537", - "2191", - "2921", - "39929", - "91544", - "15825", - "51859", - "3408", - "217175", - "308476", - "96414", - "28972", - "9251", - "534660", - "137804", - "14121", - "8764", - "106883", - "60624", - "3895", - "376891", - "11199", - "396125", - "483774", - "196236", - "5356", - "6817", - "4382", - "17773", - "416333", - "460158", - "118326", - "74501", - "206462", - "186498", - "101526", - "27512", - "78397", - "324302", - "49180", - "252478", - "16799", - "130986", - "265382", - "63789", - "4625", - "4869", - "20938", - "1947", - "18747", - "34085", - "12660", - "11930", - "6330", - "19721", - "437759", - "340858", - "67197", - "279016", - "8277", - "86918", - "7791", - "293381", - "168481", - "4138", - "44311", - "9738", - "3652", - "152412", - "36033", - "358387", - "2678", - "228374", - "112483", - "508608", - "144864", - "23373", - "245", - "3409", - "6370", - "7792", - "721158", - "2205", - "686098", - "6331", - "972662", - "4626", - "1601058", - "561928", - "1859136", - "980", - "490", - "6860", - "880387", - "1129700", - "837536", - "487", - "8766", - "1248027", - "1217", - "1022330", - "3185", - "4870", - "2053912", - "9253", - "5357", - "1378770", - "1461", - "2191", - "7305", - "8279", - "758165", - "13476", - "4139", - "3675", - "590658", - "620848", - "730", - "3430", - "1715", - "8331", - "15926", - "243", - "12006", - "5880", - "1311816", - "3920", - "4410", - "925429", - "1768809", - "796877", - "974", - "1449133", - "5390", - "3165", - "1948", - "1470", - "8821", - "2678", - "7350", - "4900", - "2269140", - "9740", - "6818", - "1187403", - "1523148", - "4655", - "4165", - "2940", - "1682864", - "1954090", - "5844", - "2435", - "4383", - "652743", - "2158848", - "11271", - "2922", - "3896", - "12741", - "1074676", - "1225", - "2385032", - "10536", - "1960", - "16907", - "735", - "14946", - "2695", - "3652", - "14211", - "1704", - "9801", - "9311", - "7840", - "2450", - "21072", - "419001", - "97031", - "52191", - "61012", - "49496", - "511867", - "71303", - "145792", - "178381", - "725778", - "138686", - "119084", - "169560", - "42390", - "87475", - "538085", - "57827", - "64197", - "30873", - "207785", - "36264", - "360684", - "131826", - "218566", - "490", - "83065", - "931359", - "254096", - "379306", - "47045", - "326379", - "102177", - "125210", - "161229", - "978894", - "54886", - "440563", - "107568", - "24748", - "398663", - "38224", - "29158", - "18867", - "1611317", - "67628", - "113203", - "22297", - "565529", - "1458418", - "310453", - "32588", - "267082", - "40184", - "801983", - "656925", - "197494", - "2400313", - "280804", - "245", - "187692", - "594442", - "34304", - "78899", - "229838", - "486874", - "17887", - "1693647", - "1081562", - "2283679", - "2067073", - "1871049", - "343042", - "241599", - "23522", - "735", - "842903", - "92131", - "463106", - "886028", - "1195011", - "2172681", - "1532907", - "1136939", - "74979", - "44595", - "1966610", - "1780142", - "1256023", - "295261", - "690494", - "624826", - "1387604", - "27688", - "1320221", - "763023", - "26218", - "1028880", - "19847", - "153388", - "7351", - "187715", - "26221", - "52197", - "4901", - "87486", - "49502", - "113217", - "54893", - "10537", - "980", - "254127", - "3675", - "71312", - "97043", - "1960", - "398712", - "12743", - "64205", - "14213", - "18869", - "4166", - "11272", - "23525", - "207810", - "21075", - "24751", - "107581", - "13478", - "161249", - "27691", - "8822", - "2450", - "241629", - "78909", - "1715", - "8332", - "67636", - "2695", - "153407", - "178403", - "22300", - "30877", - "125225", - "440617", - "102190", - "1470", - "280838", - "42395", - "19849", - "14948", - "229866", - "2205", - "61019", - "1225", - "40189", - "12007", - "9312", - "343084", - "145810", - "419052", - "119099", - "131842", - "15928", - "74988", - "29162", - "6861", - "9802", - "3920", - "197518", - "3185", - "38229", - "83075", - "47051", - "379352", - "5391", - "44600", - "32592", - "310491", - "34308", - "16909", - "3430", - "360728", - "4656", - "17889", - "169581", - "4411", - "138703", - "2940", - "218593", - "5881", - "92142", - "57834", - "326419", - "463163", - "267115", - "36268", - "295297", - "6371", - "7841", - "48013", - "99027", - "5001", - "12253", - "41011", - "94026", - "4751", - "4251", - "6001", - "24006", - "1250", - "486934", - "3000", - "13003", - "1750", - "26757", - "53264", - "8502", - "843006", - "491", - "2750", - "164546", - "565598", - "1500", - "25257", - "500", - "4001", - "245", - "76521", - "2500", - "511930", - "22756", - "2250", - "69019", - "72770", - "7502", - "148791", - "89274", - "56015", - "624903", - "33259", - "11503", - "14504", - "20255", - "13753", - "3500", - "7001", - "9002", - "84773", - "39010", - "657005", - "29758", - "8002", - "690579", - "65518", - "28257", - "62267", - "173048", - "1000", - "10002", - "141539", - "17254", - "37010", - "4501", - "127785", - "59016", - "80522", - "802081", - "594515", - "50514", - "250", - "109780", - "9502", - "35009", - "3250", - "104279", - "725867", - "43262", - "2000", - "31508", - "5501", - "156543", - "21506", - "15254", - "979014", - "115532", - "18255", - "3751", - "45512", - "538151", - "886136", - "6501", - "16254", - "750", - "10753", - "763116", - "931473", - "121534", - "19255", - "134537", - "201556", - "778811", - "740707", - "1282166", - "2331211", - "212059", - "1817194", - "3001", - "522396", - "21513", - "250", - "2450273", - "860344", - "7504", - "24015", - "191553", - "333093", - "182050", - "18261", - "1219884", - "637678", - "427619", - "259322", - "406863", - "4002", - "449625", - "246569", - "316838", - "1500", - "472632", - "350098", - "11507", - "549153", - "272576", - "2251", - "1250", - "286580", - "1644854", - "13758", - "606669", - "1347700", - "1000", - "9506", - "10006", - "1050295", - "10756", - "223062", - "1728898", - "750", - "15259", - "904470", - "5503", - "9005", - "4502", - "999269", - "670437", - "301334", - "6504", - "500", - "1564813", - "1160603", - "3752", - "4252", - "4753", - "2001", - "1488773", - "2007543", - "20262", - "16260", - "22764", - "1104073", - "8505", - "577161", - "26767", - "6003", - "5003", - "234565", - "19262", - "2501", - "2217902", - "387108", - "2110096", - "2751", - "496889", - "25266", - "818577", - "950744", - "12257", - "14509", - "1416486", - "704697", - "8005", - "3252", - "368103", - "17261", - "13008", - "3502", - "1909992", - "7004", - "1751", - "37023", - "28268", - "127831", - "156600", - "59037", - "45529", - "72796", - "368235", - "115573", - "35022", - "33271", - "223142", - "577369", - "497067", - "43277", - "29769", - "89307", - "1910221", - "104316", - "65541", - "173110", - "80551", - "637908", - "141590", - "286683", - "860550", - "1817412", - "76548", - "94060", - "56035", - "121577", - "53284", - "818773", - "333213", - "2110349", - "109820", - "522584", - "182116", - "999389", - "234650", - "1565000", - "134586", - "704950", - "350224", - "1645052", - "316952", - "62289", - "48030", - "670678", - "778998", - "740973", - "449787", - "904578", - "84804", - "950858", - "1050421", - "148845", - "31520", - "191622", - "2007784", - "246657", - "2450567", - "164605", - "427773", - "2218168", - "41026", - "387247", - "250", - "472802", - "407010", - "606888", - "549351", - "201628", - "272674", - "1160742", - "1282320", - "500", - "1104206", - "39024", - "301442", - "1416656", - "259415", - "1347862", - "2331491", - "1220030", - "212135", - "1488952", - "1729105", - "99063", - "50532", - "69044" + "38483322" ] ], [ diff --git a/protocol/scripts/beanstalk-3/data/merkle/plot_tree.json b/protocol/scripts/beanstalk-3/data/merkle/plot_tree.json index 30c2e9bf5..247d84748 100644 --- a/protocol/scripts/beanstalk-3/data/merkle/plot_tree.json +++ b/protocol/scripts/beanstalk-3/data/merkle/plot_tree.json @@ -6,23 +6,23 @@ "bytes32" ], "tree": [ - "0x26da8c597f94901bab9ecbe1f491f3d953d358c7221680a27dc76e19318de3d1", - "0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d", - "0xccd11741688095f29e181e570e30cf0ffe4358113fd1d34ce1e9da988a3bf7f5", - "0x6e2858d71bc1af713bd1d79cb187cd16fa8c67e8de5f2c7a127fa111b864639d", - "0xf0977befdca378433f408995e4280460216300121762cb94a38b140f0812572b", - "0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789", - "0xe12941b340f655a30ee924ca20416f89d4b9a11f391bfe1dd845fade9b555338", + "0x828c73c8e073801828c564f95bafd55c6a0485f244d4581e638c90ca678d3a28", + "0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c", + "0x0874acf6b9bc1475d9b59d97d17de9393625ca078123ae65ce80152a0fc2614e", + "0xd7c83efeca8d82fcff070cdaf84ef38869f82b20cb548d44e17c078920ba5ddb", + "0xa2bf812102fee36e8db0bd0c3288a59e3119f9b631f2c33f95c4f12baddca96d", + "0x287ba7a5eeff9282b22024bfb2d7af934ad86babc16f9ff0e8d08ee11c407870", + "0xb64765464faf321baf465546dbc889c894c15a5e47cba25f0723e4c29bb71e07", "0xd929688571d3927708ef267be9dc729d2761eb272cffd20c751fc902db4665ce", + "0xd96385e785dc31df7b95ae21a0966cb05e35914cb4335da8f98b829baeae1a72", "0xd684994c40c11000834514d4bc24d071cfb371ec91d9ab4b8a7ef962e48e1dc8", "0xd2a8d5629db2ba385a1a93740c3102de2868ad323baf3ec33ae0cc61acc1aa04", "0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921", "0xc12dac6cfcaad9353619c0f2c6145ccce20e40bfb83f9189a00e8ce0fb4d6927", "0xbaef3e12a2feef6cdf5bf77dbc0274421b66278087273b06a1b7b9be6e4de62d", - "0x9af61a7eb29235502d404871729391d8f3e855500dd892cba5639126c2b486cd", + "0x807e7c8b9232dba90b23852a9cddc5aa2682de0140325828e085fc6a489bed4a", "0x39c842071da1cf89a9936d1bdc14de97bda9005d8b6d27bbba581541aff573ff", - "0x1c7efee5e1ef30094ceab20c33dfa117e60a141dfe917157076f372554e0ee9f", "0x1336d7666c8f3ae213791ad005915349fa9519212f9b5ec2dec617905dd61c3b", "0x0fd1c8a42208be79bbc34aaf5b54f5cfaed1b1b0b68e0f1c1e5253b4b35f2851" ], @@ -32,7 +32,7 @@ "0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7", "0x61255d510110f2a7f0f078498ab8213b22aeb5b84ee0d27a83a3648f649def32" ], - "treeIndex": 12 + "treeIndex": 13 }, { "value": [ @@ -46,28 +46,28 @@ "0x7e04231a59C9589D17bcF2B0614bC86aD5Df7C11", "0x083da975eceb76df17d62d9bcd915d9cf74a80f48d88d60c8f733e0a0e1fbf21" ], - "treeIndex": 15 + "treeIndex": 16 }, { "value": [ "0x9662C8E686fe84F468a139b10769D65665c344F9", - "0x8d5cc615a7f50c1787f801e450594ddff5719d6ba2d6a10a4dc00af6993b2e33" + "0x9e839ca66a018ee9f778c55aa5384f717203b151629451dfd930918a6f3d5528" ], - "treeIndex": 16 + "treeIndex": 15 }, { "value": [ "0xB9F14eFae1D14b6d06816B6E3a5F6e79c87232fA", - "0x6e03ffe69636c5635de4ea3dd365a5e096f6f9cdb9ab4903bd2a5763c711c498" + "0x26b5cdff054ce4aa360f5edcadeb498a95120f278e2cb0292b217a874c52989b" ], - "treeIndex": 14 + "treeIndex": 9 }, { "value": [ "0xBc7c5f21C632c5C7CA1Bfde7CBFf96254847d997", "0xd09876ca2d2421a95f99e35744dbd42786e343b49ae6bbaa376cae70d0b5a3c5" ], - "treeIndex": 11 + "treeIndex": 12 }, { "value": [ @@ -81,78 +81,78 @@ "0x251FAe8f687545BDD462Ba4FCDd7581051740463", "0xc0dae375fa30dfb920c0c0dccbdecc5c6c4690a37ecbd80861ba2c103f4e59c7" ], - "treeIndex": 10 + "treeIndex": 11 }, { "value": [ "0xAA420e97534aB55637957e868b658193b112A551", "0xbd9d28015513b80697cb8ddaedb6d1ed6a9ed24d421f74131fed0a8aa2195d87" ], - "treeIndex": 13 + "treeIndex": 14 }, { "value": [ "0x83A758a6a24FE27312C1f8BDa7F3277993b64783", "0xcac7f64f1e4fef62d986fa415202446e7e19560364040484886dc25fdf6f33a1" ], - "treeIndex": 9 + "treeIndex": 10 } ] }, "proofs": { "0x21DE18B6A8f78eDe6D16C50A167f6B222DC08DF7": [ - "0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921", - "0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789", - "0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3" + "0xbaef3e12a2feef6cdf5bf77dbc0274421b66278087273b06a1b7b9be6e4de62d", + "0xa2bf812102fee36e8db0bd0c3288a59e3119f9b631f2c33f95c4f12baddca96d", + "0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2" ], "0x735CAB9B02Fd153174763958FFb4E0a971DD7f29": [ "0x1336d7666c8f3ae213791ad005915349fa9519212f9b5ec2dec617905dd61c3b", - "0xe12941b340f655a30ee924ca20416f89d4b9a11f391bfe1dd845fade9b555338", - "0x6e2858d71bc1af713bd1d79cb187cd16fa8c67e8de5f2c7a127fa111b864639d", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xb64765464faf321baf465546dbc889c894c15a5e47cba25f0723e4c29bb71e07", + "0xd7c83efeca8d82fcff070cdaf84ef38869f82b20cb548d44e17c078920ba5ddb", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ], "0x7e04231a59C9589D17bcF2B0614bC86aD5Df7C11": [ - "0x1c7efee5e1ef30094ceab20c33dfa117e60a141dfe917157076f372554e0ee9f", + "0x807e7c8b9232dba90b23852a9cddc5aa2682de0140325828e085fc6a489bed4a", "0xd929688571d3927708ef267be9dc729d2761eb272cffd20c751fc902db4665ce", - "0x6e2858d71bc1af713bd1d79cb187cd16fa8c67e8de5f2c7a127fa111b864639d", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xd7c83efeca8d82fcff070cdaf84ef38869f82b20cb548d44e17c078920ba5ddb", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ], "0x9662C8E686fe84F468a139b10769D65665c344F9": [ "0x39c842071da1cf89a9936d1bdc14de97bda9005d8b6d27bbba581541aff573ff", "0xd929688571d3927708ef267be9dc729d2761eb272cffd20c751fc902db4665ce", - "0x6e2858d71bc1af713bd1d79cb187cd16fa8c67e8de5f2c7a127fa111b864639d", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xd7c83efeca8d82fcff070cdaf84ef38869f82b20cb548d44e17c078920ba5ddb", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ], "0xB9F14eFae1D14b6d06816B6E3a5F6e79c87232fA": [ - "0xbaef3e12a2feef6cdf5bf77dbc0274421b66278087273b06a1b7b9be6e4de62d", - "0xf0977befdca378433f408995e4280460216300121762cb94a38b140f0812572b", - "0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3" + "0xd684994c40c11000834514d4bc24d071cfb371ec91d9ab4b8a7ef962e48e1dc8", + "0x0874acf6b9bc1475d9b59d97d17de9393625ca078123ae65ce80152a0fc2614e", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ], "0xBc7c5f21C632c5C7CA1Bfde7CBFf96254847d997": [ - "0xc12dac6cfcaad9353619c0f2c6145ccce20e40bfb83f9189a00e8ce0fb4d6927", - "0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789", - "0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3" + "0xd2a8d5629db2ba385a1a93740c3102de2868ad323baf3ec33ae0cc61acc1aa04", + "0x287ba7a5eeff9282b22024bfb2d7af934ad86babc16f9ff0e8d08ee11c407870", + "0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2" ], "0x8525664820C549864982D4965a41F83A7d26AF58": [ "0x0fd1c8a42208be79bbc34aaf5b54f5cfaed1b1b0b68e0f1c1e5253b4b35f2851", - "0xe12941b340f655a30ee924ca20416f89d4b9a11f391bfe1dd845fade9b555338", - "0x6e2858d71bc1af713bd1d79cb187cd16fa8c67e8de5f2c7a127fa111b864639d", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xb64765464faf321baf465546dbc889c894c15a5e47cba25f0723e4c29bb71e07", + "0xd7c83efeca8d82fcff070cdaf84ef38869f82b20cb548d44e17c078920ba5ddb", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ], "0x251FAe8f687545BDD462Ba4FCDd7581051740463": [ - "0xd684994c40c11000834514d4bc24d071cfb371ec91d9ab4b8a7ef962e48e1dc8", - "0xccd11741688095f29e181e570e30cf0ffe4358113fd1d34ce1e9da988a3bf7f5", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921", + "0x287ba7a5eeff9282b22024bfb2d7af934ad86babc16f9ff0e8d08ee11c407870", + "0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2" ], "0xAA420e97534aB55637957e868b658193b112A551": [ - "0x9af61a7eb29235502d404871729391d8f3e855500dd892cba5639126c2b486cd", - "0xf0977befdca378433f408995e4280460216300121762cb94a38b140f0812572b", - "0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3" + "0xc12dac6cfcaad9353619c0f2c6145ccce20e40bfb83f9189a00e8ce0fb4d6927", + "0xa2bf812102fee36e8db0bd0c3288a59e3119f9b631f2c33f95c4f12baddca96d", + "0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2" ], "0x83A758a6a24FE27312C1f8BDa7F3277993b64783": [ - "0xd2a8d5629db2ba385a1a93740c3102de2868ad323baf3ec33ae0cc61acc1aa04", - "0xccd11741688095f29e181e570e30cf0ffe4358113fd1d34ce1e9da988a3bf7f5", - "0x6960d96bb5ea8e584616207988e4398ab4662e227b68425035d2e84bd0bc613d" + "0xd96385e785dc31df7b95ae21a0966cb05e35914cb4335da8f98b829baeae1a72", + "0x0874acf6b9bc1475d9b59d97d17de9393625ca078123ae65ce80152a0fc2614e", + "0xa43260a6e564e1e25c804859624b69fa8ce32ae186437d8634c30ead414b229c" ] } } \ No newline at end of file diff --git a/protocol/test/foundry/Migration/L1Reciever.t.sol b/protocol/test/foundry/Migration/L1Reciever.t.sol index 4e96d9581..8e68eb258 100644 --- a/protocol/test/foundry/Migration/L1Reciever.t.sol +++ b/protocol/test/foundry/Migration/L1Reciever.t.sol @@ -335,9 +335,9 @@ contract L1RecieverFacetTest is Order, TestHelper { pods[5] = 1525000; bytes32[] memory proof = new bytes32[](3); - proof[0] = bytes32(0xce6c05520ca960525c486ec28de7ab8018c0d094a404feb043b60ef658e1e921); - proof[1] = bytes32(0x804c830f86722b4afe4c1e19fe9445e7b1087969871708451c204d4a1a333789); - proof[2] = bytes32(0xe59a902f19ff32a47a5eac21bb2642fb0e6c695edfed938122aed52a46a635c3); + proof[0] = bytes32(0xbaef3e12a2feef6cdf5bf77dbc0274421b66278087273b06a1b7b9be6e4de62d); + proof[1] = bytes32(0xa2bf812102fee36e8db0bd0c3288a59e3119f9b631f2c33f95c4f12baddca96d); + proof[2] = bytes32(0xf8138f4b12984d61c5fe1a0f360d005fdef03cc9e06f1dd67c9f98700a5532c2); return (account, index, pods, proof); } diff --git a/protocol/test/foundry/Migration/ReseedContracts.sol b/protocol/test/foundry/Migration/ReseedContracts.sol index 606bd5afa..45504f82b 100644 --- a/protocol/test/foundry/Migration/ReseedContracts.sol +++ b/protocol/test/foundry/Migration/ReseedContracts.sol @@ -94,7 +94,13 @@ contract L1RecieverFacetTest is Order, TestHelper { } vm.prank(RECIEVER); + // start measuring gas + uint256 gasBefore = gasleft(); L1RecieverFacet(BEANSTALK).issuePlots(OWNER, index, pods, proof); + + //stop measuring gas + uint256 gasAfter = gasleft(); + console.log("Gas used for issuePlots:", gasBefore - gasAfter); } } From f5498e37bc4aabe6fea5cd8864e652d1b6bb3159 Mon Sep 17 00:00:00 2001 From: pizzaman1337 Date: Thu, 19 Sep 2024 16:55:18 -0600 Subject: [PATCH 13/15] Add group sums calculations --- .../scripts/beanstalk-3/beanstalk-3-Contracts.js | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js index bcb9ba9f5..7eb2b38e4 100644 --- a/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js +++ b/protocol/scripts/beanstalk-3/beanstalk-3-Contracts.js @@ -104,6 +104,18 @@ function processPlots(plots, maxPlotsPerAddress = 435) { // Sort the plots by size in descending order plotData.sort((a, b) => (b.size > a.size ? 1 : -1)); + // sum the total of the first 435 plots, then the next 435 plots, etc. + let groupSums = []; + for (let i = 0; i < plotData.length; i += maxPlotsPerAddress) { + let groupSum = plotData + .slice(i, i + maxPlotsPerAddress) + .reduce((sum, plot) => sum + plot.size, BigInt(0)); + groupSums.push(groupSum.toString()); + } + + console.log("Group sums for address:", address); + console.log(groupSums); + // Keep only the top 435 plots plotData = plotData.slice(0, maxPlotsPerAddress); From 5329312acceb515aadc9d0344e2f2886e6be9c82 Mon Sep 17 00:00:00 2001 From: Brean0 Date: Thu, 19 Sep 2024 22:30:22 -0500 Subject: [PATCH 14/15] update various json values, update % of wells, --- .../exports/contract-circulating20736200.json | 9 ++- .../data/exports/storage-system20736200.json | 4 +- .../reseed/data/r2/L2_initial_supply.json | 4 +- .../reseed/reseedAddLiquidityAndTransfer.js | 76 +++++++++++++++++-- .../data/inputs/ContractAddresses.json | 49 ++++++++++++ 5 files changed, 128 insertions(+), 14 deletions(-) create mode 100644 protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json diff --git a/protocol/reseed/data/exports/contract-circulating20736200.json b/protocol/reseed/data/exports/contract-circulating20736200.json index 05818edd0..9c415b04b 100644 --- a/protocol/reseed/data/exports/contract-circulating20736200.json +++ b/protocol/reseed/data/exports/contract-circulating20736200.json @@ -1,8 +1,11 @@ { "beanstalk": { - "beans": "33408617554460", - "unripeBeans": "107495547853813", - "unripeLp": "67632589795645" + "beans": "29976763899684", + "unripeBeans": "96200825182974", + "unripeLp": "67632589795645", + "ethLp": "1323213132988957601130", + "wstethLp": "185335736965741266416875", + "bs3crvLp": "93024994011998500979055" }, "pools": { "beanweth": { diff --git a/protocol/reseed/data/exports/storage-system20736200.json b/protocol/reseed/data/exports/storage-system20736200.json index 1d698aaa8..6ee0f24aa 100644 --- a/protocol/reseed/data/exports/storage-system20736200.json +++ b/protocol/reseed/data/exports/storage-system20736200.json @@ -619,7 +619,7 @@ "unripeSettings": { "0x1BEA054dddBca12889e07B3E076f511Bf1d27543": { "underlyingToken": "0xBEA0005B8599265D41256905A9B3073D397812E4", - "balanceOfUnderlying": "0x19f4f0551a45" + "balanceOfUnderlying": "0x174018a57256" }, "0x1BEA059c3Ea15F6C10be1c53d70C75fD1266D788": { "underlyingToken": "0xBEA0093f626Ce32dd6dA19617ba4e7aA0c3228e8", @@ -941,7 +941,7 @@ "activeFertilizer": "0x106b5be", "fertilizedIndex": "0x5249320f8fa", "unfertilizedIndex": "0x57266060fa3c", - "fertilizedPaidIndex": "0x4ba57633e2d", + "fertilizedPaidIndex": "0x5249320f8fa", "fertFirst": "0x145c1f", "fertLast": "0x5b8d80", "bpf": "0x53342", diff --git a/protocol/reseed/data/r2/L2_initial_supply.json b/protocol/reseed/data/r2/L2_initial_supply.json index 17ba0377e..2b036c4e0 100644 --- a/protocol/reseed/data/r2/L2_initial_supply.json +++ b/protocol/reseed/data/r2/L2_initial_supply.json @@ -1,5 +1,5 @@ [ - "33408617554460", - "107495547853813", + "29976763899684", + "96200825182974", "67632589795645" ] \ No newline at end of file diff --git a/protocol/reseed/reseedAddLiquidityAndTransfer.js b/protocol/reseed/reseedAddLiquidityAndTransfer.js index 8d4cf644a..6b67fdd68 100644 --- a/protocol/reseed/reseedAddLiquidityAndTransfer.js +++ b/protocol/reseed/reseedAddLiquidityAndTransfer.js @@ -9,7 +9,9 @@ const { } = require("../test/hardhat/utils/constants.js"); const { to18, to6, toX } = require("../test/hardhat/utils/helpers.js"); const { impersonateToken } = require("../scripts/impersonate.js"); +const { getWellContractAt } = require("../utils/well.js"); const fs = require("fs"); +const { toBN } = require("../utils"); const WellAddresses = [ "0xBEA00A3F7aaF99476862533Fe7DcA4b50f6158cB", // BEAN/WETH @@ -48,6 +50,8 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, await fs.readFileSync(INIT_WELL_BALANCES) ); + // divide balancesInBeanStableWell[1] by 1e12: + balancesInBeanStableWell[1] = Math.floor(balancesInBeanStableWell[1] / 1e12).toString(); const slots = [ 51, // WETH 1, // wstETH @@ -57,21 +61,78 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, 51 // USDT ]; + const L1_beanstalkBalances = [ + "1323213132988957601130", // ethLP + "185335736965741266416875", // wstethLP + "93024994011998500979055" // 3crvLP + ]; + + // note: the amounts + // were updated with the amounts in `L2_well_balances.json` + + // calculate the LP token supply for each well: + // note: this is an estimation and is used for the sake of testing. + + const cp2 = await getWellContractAt( + "ConstantProduct2", + "0xBA5104f2df98974A83CD10d16E24282ce6Bb647f" + ); + + const beanEthLpTokenSupply = await cp2.calcLpTokenSupply(balancesInBeanEthWell, "0x"); + console.log("beanEthLpTokenSupply", beanEthLpTokenSupply); + const beanWstEthLpTokenSupply = await cp2.calcLpTokenSupply(balancesInBeanWstEthWell, "0x"); + console.log("beanWstEthLpTokenSupply", beanWstEthLpTokenSupply); + // const beanStableLpTokenSupply = await cp2.calcLpTokenSupply(balancesInBeanStableWell, "0x"); + // console.log("beanStableLpTokenSupply", beanStableLpTokenSupply); + + // get the % of the total LP token supply that each well has: + // note: the bean3crv was manually calculated given the migration to the well. + const beanEthLpTokenSupplyPercentage = L1_beanstalkBalances[0] / beanEthLpTokenSupply; + const beanWstEthLpTokenSupplyPercentage = L1_beanstalkBalances[1] / beanWstEthLpTokenSupply; + const beanStableLpTokenSupplyPercentage = 0.998832; + + const scaleFactor = to18("1"); // Scale factor to avoid decimals + + // Convert percentages to BigNumber with scaling + const beanEthLpTokenSupplyPercentageBN = toBN((beanEthLpTokenSupplyPercentage * 1e18).toString()); + const beanWstEthLpTokenSupplyPercentageBN = toBN( + (beanWstEthLpTokenSupplyPercentage * 1e18).toString() + ); + const beanStableLpTokenSupplyPercentageBN = toBN( + (beanStableLpTokenSupplyPercentage * 1e18).toString() + ); + + // Scale balances using the percentages + balancesInBeanEthWell = await balancesInBeanEthWell.map((balance) => { + const balanceBN = toBN(balance.toString()); + return balanceBN.mul(beanEthLpTokenSupplyPercentageBN).div(scaleFactor).toString(); // Scale down + }); + + balancesInBeanWstEthWell = await balancesInBeanWstEthWell.map((balance) => { + const balanceBN = toBN(balance.toString()); + return balanceBN.mul(beanWstEthLpTokenSupplyPercentageBN).div(scaleFactor).toString(); // Scale down + }); + + balancesInBeanStableWell = await balancesInBeanStableWell.map((balance) => { + const balanceBN = toBN(balance.toString()); + return balanceBN.mul(beanStableLpTokenSupplyPercentageBN).div(scaleFactor).toString(); // Scale down + }); + const nonBeanAmounts = [ - to18("20.6"), // BEAN/WETH - to18("2556"), // BEAN/WstETH - to6("0"), // to18("16"), // BEAN/WEEETH + balancesInBeanEthWell[1], // BEAN/WETH + balancesInBeanWstEthWell[1], // BEAN/WstETH + to6("0"), // BEAN/WEEETH toX("0", 8), // BEAN/WBTC (8 decimals) - to6("206686.240460"), // to6("190000"), // BEAN/USDC + balancesInBeanStableWell[1], // BEAN/USDC to6("0") // to6("190000") // BEAN/USDT ]; const beanAmounts = [ - to6("107380.655868"), // BEAN/WETH - to6("14544578.478380"), // BEAN/WstETH + balancesInBeanEthWell[0], // BEAN/WETH + balancesInBeanWstEthWell[0], // BEAN/WstETH to6("0"), // to6("100000"), // BEAN/WEEETH to6("0"), // to6("1000000"), // BEAN/WBTC - to6("83855.245277"), // BEAN/USDC + balancesInBeanStableWell[0], // BEAN/USDC to6("0") // to6("1000000") // BEAN/USDT ]; console.log("-----------------------------------"); @@ -82,6 +143,7 @@ async function reseedAddLiquidityAndTransfer(account, L2Beanstalk, mock = true, // add liquidity and transfer to L2 Beanstalk: for (let i = 0; i < WellAddresses.length; i++) { + console.log(`-----------------------------------`); const well = await ethers.getContractAt("IWell", WellAddresses[i], account); const token = await ethers.getContractAt("IERC20", NonBeanToken[i], account); diff --git a/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json b/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json new file mode 100644 index 000000000..b08e2fbf9 --- /dev/null +++ b/protocol/scripts/beanstalk-3/data/inputs/ContractAddresses.json @@ -0,0 +1,49 @@ +[ + "0x7bf4b9d4ec3b9aab1f00dad63ea58389b9f68909", + "0xdd9f24efc84d93deef3c8745c837ab63e80abd27", + "0x9008d19f58aabd9ed0d60971565aa8510560ab41", + "0xb1be0000c6b3c62749b5f0c92480146452d15423", + "0x9662c8e686fe84f468a139b10769d65665c344f9", + "0xe37e799d5077682fa0a244d46e5649f71457bd09", + "0x92f3f71cef740ed5784874b8c70ff87ecdf33588", + "0x0b3f6d4a5d6835137ccb2c1248f5a7d882c0dbda", + "0x5fba3e7eeeb50a4dc3328e2f974e0d608b38913e", + "0x00000000009726632680fb29d3f7a9734e3010e2", + "0x20db9f8c46f9cd438bfd65e09297350a8cdb0f95", + "0xaa420e97534ab55637957e868b658193b112a551", + "0x7e04231a59c9589d17bcf2b0614bc86ad5df7c11", + "0x8525664820c549864982d4965a41f83a7d26af58", + "0x1136b25047e142fa3018184793aec68fbb173ce4", + "0xa9febe780f9ede9b424f5ce7da88d650f2d55498", + "0x3aa228a80f50763045bdfc45012da124bd0a6809", + "0x7122db0ebe4eb9b434a9f2ffe6760bc03bfbd0e0", + "0x81b9cfcb1dc180acaf7c187db5fe2c961f74d67e", + "0x735cab9b02fd153174763958ffb4e0a971dd7f29", + "0x2d0ba6af26c6738feaacb6d85da29d3fadda1706", + "0xb01f8f528702d411d24c9bb8cc0e2fff779ec013", + "0xb9f14efae1d14b6d06816b6e3a5f6e79c87232fa", + "0x21de18b6a8f78ede6d16c50a167f6b222dc08df7", + "0x153072c11d6dffc0f1e5489bc7c996c219668c67", + "0x4a183b7ed67b9e14b3f45abfb2cf44ed22c29e54", + "0x1111111254eeb25477b68fb85ed929f73a960582", + "0x251fae8f687545bdd462ba4fcdd7581051740463", + "0x23ed1e6384705dfd23788d5093266c0d9ebe3fae", + "0xc1fe2bb036e3fc9eddcc83304dbe752881087cdf", + "0x5eefd9c64d8c35142b7611ae3a6decfc6d7a8a5e", + "0x1c694fc3006d81ff4a56f97e1b99529066a23725", + "0xc5a7f91ac0b24ca8957a97aacab4fc1022e256f5", + "0x77700005bea4de0a78b956517f099260c2ca9a26", + "0x7119f398b6c06095c6e8964c1f58e7c1baa79e18", + "0x25c1278454254f783ef8760987db8de0268c6cbe", + "0xbc7c5f21c632c5c7ca1bfde7cbff96254847d997", + "0x517b37dc73f756192b318d3853bd4c66ba4b41cb", + "0x3f9208f556735504e985ff1a369af2e8ff6240a3", + "0x75a158b6939d9abc27b5e3ea9e79c11302cec60c", + "0x9edaff6744d6f539298cddd8c0171b774be2b86d", + "0x66efac6e6d58d4058cf017e66a0039315a3eb29c", + "0x83a758a6a24fe27312c1f8bda7f3277993b64783", + "0xc9c32cd16bf7efb85ff14e0c8603cc90f6f2ee49", + "0xbea0e11282e2bb5893bece110cf199501e872bad", + "0xf2d47e78dea8e0f96902c85902323d2a2012b0c0", + "0x7c28e0977f72c5d08d5e1ac7d52a34db378282b3" +] From aff65433d9220d545d57265e722c088e5d899da4 Mon Sep 17 00:00:00 2001 From: Brean0 Date: Thu, 19 Sep 2024 22:33:16 -0500 Subject: [PATCH 15/15] add global, remove rpc from hardhat.config --- protocol/hardhat.config.js | 5 ----- protocol/reseed/data/global.json | 4 ++-- 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/protocol/hardhat.config.js b/protocol/hardhat.config.js index 6b89be7c9..5aab348f3 100644 --- a/protocol/hardhat.config.js +++ b/protocol/hardhat.config.js @@ -547,11 +547,6 @@ module.exports = { chainId: 5, url: process.env.GOERLI_RPC || "", timeout: 100000 - }, - reseedArbitrum: { - url: "https://virtual.arbitrum.rpc.tenderly.co/10991114-8428-4e06-88dc-426e4e5673da", - chainId: 42161, - timeout: 10000000000000 } }, etherscan: { diff --git a/protocol/reseed/data/global.json b/protocol/reseed/data/global.json index 2db653c48..de7597c0a 100644 --- a/protocol/reseed/data/global.json +++ b/protocol/reseed/data/global.json @@ -233,7 +233,7 @@ "17216958", "5654645373178", "95822337342012", - "5198376549933", + "5654645373178", "1334303", "6000000", "340802", @@ -282,7 +282,7 @@ [ [ "0xBEA0005B8599265D41256905A9B3073D397812E4", - "28539794823749" + "25564058841686" ], [ "0xBEA0093f626Ce32dd6dA19617ba4e7aA0c3228e8",