More Info
Private Name Tags
ContractCreator
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block |
From
|
To
|
|||
---|---|---|---|---|---|---|
12076321 | 1373 days ago | 235.60395064 ETH | ||||
12076321 | 1373 days ago | 0.57058079 ETH | ||||
12076321 | 1373 days ago | 235.03336985 ETH | ||||
12073819 | 1374 days ago | 0 ETH | ||||
12073819 | 1374 days ago | 337.55649532 ETH | ||||
12073819 | 1374 days ago | 143.35831426 ETH | ||||
12073819 | 1374 days ago | 480.91480959 ETH | ||||
12072190 | 1374 days ago | 27.54516512 ETH | ||||
12072190 | 1374 days ago | 0.04426536 ETH | ||||
12072190 | 1374 days ago | 27.50089976 ETH | ||||
12070791 | 1374 days ago | 0 ETH | ||||
12070791 | 1374 days ago | 5,079.37053675 ETH | ||||
12070791 | 1374 days ago | 890.09058372 ETH | ||||
12070791 | 1374 days ago | 5,969.46112047 ETH | ||||
12069796 | 1374 days ago | 0 ETH | ||||
12069796 | 1374 days ago | 19.3280159 ETH | ||||
12069796 | 1374 days ago | 3.83270162 ETH | ||||
12069796 | 1374 days ago | 23.16071752 ETH | ||||
12068317 | 1374 days ago | 0 ETH | ||||
12068317 | 1374 days ago | 241.34939365 ETH | ||||
12068317 | 1374 days ago | 48.10829854 ETH | ||||
12068317 | 1374 days ago | 289.4576922 ETH | ||||
12068242 | 1374 days ago | 0 ETH | ||||
12068242 | 1374 days ago | 241.63200462 ETH | ||||
12068242 | 1374 days ago | 47.87921153 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xa57F6445...805C45d0d The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
StrategyAddTwoSidesOptimal
Compiler Version
v0.5.16+commit.9c3226ce
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-10-22 */ // File: openzeppelin-solidity-2.3.0/contracts/ownership/Ownable.sol pragma solidity ^0.5.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be aplied to your functions to restrict their use to * the owner. */ contract Ownable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return msg.sender == _owner; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * > Note: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: openzeppelin-solidity-2.3.0/contracts/math/SafeMath.sol pragma solidity ^0.5.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } // File: openzeppelin-solidity-2.3.0/contracts/utils/ReentrancyGuard.sol pragma solidity ^0.5.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the `nonReentrant` modifier * available, which can be aplied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. */ contract ReentrancyGuard { /// @dev counter to allow mutex lock with only one SSTORE operation uint256 private _guardCounter; constructor () internal { // The counter starts at one to prevent changing it from zero to a non-zero // value, which is a more expensive operation. _guardCounter = 1; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { _guardCounter += 1; uint256 localCounter = _guardCounter; _; require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call"); } } // File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } // File: @uniswap/v2-core/contracts/libraries/Math.sol pragma solidity =0.5.16; // a library for performing various math operations library Math { function min(uint x, uint y) internal pure returns (uint z) { z = x < y ? x : y; } // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method) function sqrt(uint y) internal pure returns (uint z) { if (y > 3) { z = y; uint x = y / 2 + 1; while (x < z) { z = x; x = (y / x + x) / 2; } } else if (y != 0) { z = 1; } } } // File: contracts/5/uniswap/IUniswapV2Router02.sol pragma solidity >=0.5.0; interface IUniswapV2Router02 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns ( uint256 amountA, uint256 amountB, uint256 liquidity ); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountETH, uint256 liquidity ); function removeLiquidity( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityETH( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external returns (uint256 amountToken, uint256 amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountA, uint256 amountB); function removeLiquidityETHWithPermit( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountToken, uint256 amountETH); function swapExactTokensForTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapTokensForExactTokens( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactETHForTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function swapTokensForExactETH( uint256 amountOut, uint256 amountInMax, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapExactTokensForETH( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function swapETHForExactTokens( uint256 amountOut, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function quote( uint256 amountA, uint256 reserveA, uint256 reserveB ) external pure returns (uint256 amountB); function getAmountOut( uint256 amountIn, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountOut); function getAmountIn( uint256 amountOut, uint256 reserveIn, uint256 reserveOut ) external pure returns (uint256 amountIn); function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts); function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts); function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external returns (uint256 amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint256 amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } // File: contracts/5/SafeToken.sol pragma solidity 0.5.16; interface ERC20Interface { function balanceOf(address user) external view returns (uint256); } library SafeToken { function myBalance(address token) internal view returns (uint256) { return ERC20Interface(token).balanceOf(address(this)); } function balanceOf(address token, address user) internal view returns (uint256) { return ERC20Interface(token).balanceOf(user); } function safeApprove(address token, address to, uint256 value) internal { // bytes4(keccak256(bytes('approve(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove"); } function safeTransfer(address token, address to, uint256 value) internal { // bytes4(keccak256(bytes('transfer(address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransfer"); } function safeTransferFrom(address token, address from, address to, uint256 value) internal { // bytes4(keccak256(bytes('transferFrom(address,address,uint256)'))); (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value)); require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransferFrom"); } function safeTransferETH(address to, uint256 value) internal { (bool success, ) = to.call.value(value)(new bytes(0)); require(success, "!safeTransferETH"); } } // File: contracts/5/Strategy.sol pragma solidity 0.5.16; interface Strategy { /// @dev Execute worker strategy. Take LP tokens + ETH. Return LP tokens + ETH. /// @param user The original user that is interacting with the operator. /// @param debt The user's total debt, for better decision making context. /// @param data Extra calldata information passed along to this strategy. function execute(address user, uint256 debt, bytes calldata data) external payable; } // File: contracts/5/StrategyAddTwoSidesOptimal.sol pragma solidity 0.5.16; contract StrategyAddTwoSidesOptimal is Ownable, ReentrancyGuard, Strategy { using SafeToken for address; using SafeMath for uint256; IUniswapV2Factory public factory; IUniswapV2Router02 public router; address public weth; address public goblin; /// @dev Create a new add two-side optimal strategy instance. /// @param _router The Uniswap router smart contract. constructor(IUniswapV2Router02 _router, address _goblin) public { factory = IUniswapV2Factory(_router.factory()); router = _router; weth = _router.WETH(); goblin = _goblin; } /// @dev Throws if called by any account other than the goblin. modifier onlyGoblin() { require(isGoblin(), "caller is not the goblin"); _; } /// @dev Returns true if the caller is the current goblin. function isGoblin() public view returns (bool) { return msg.sender == goblin; } /// @dev Compute optimal deposit amount /// @param amtA amount of token A desired to deposit /// @param amtB amonut of token B desired to deposit /// @param resA amount of token A in reserve /// @param resB amount of token B in reserve function optimalDeposit( uint256 amtA, uint256 amtB, uint256 resA, uint256 resB ) internal pure returns (uint256 swapAmt, bool isReversed) { if (amtA.mul(resB) >= amtB.mul(resA)) { swapAmt = _optimalDepositA(amtA, amtB, resA, resB); isReversed = false; } else { swapAmt = _optimalDepositA(amtB, amtA, resB, resA); isReversed = true; } } /// @dev Compute optimal deposit amount helper /// @param amtA amount of token A desired to deposit /// @param amtB amonut of token B desired to deposit /// @param resA amount of token A in reserve /// @param resB amount of token B in reserve function _optimalDepositA( uint256 amtA, uint256 amtB, uint256 resA, uint256 resB ) internal pure returns (uint256) { require(amtA.mul(resB) >= amtB.mul(resA), "Reversed"); uint256 a = 997; uint256 b = uint256(1997).mul(resA); uint256 _c = (amtA.mul(resB)).sub(amtB.mul(resA)); uint256 c = _c.mul(1000).div(amtB.add(resB)).mul(resA); uint256 d = a.mul(c).mul(4); uint256 e = Math.sqrt(b.mul(b).add(d)); uint256 numerator = e.sub(b); uint256 denominator = a.mul(2); return numerator.div(denominator); } /// @dev Execute worker strategy. Take LP tokens + ETH. Return LP tokens + ETH. /// @param user User address /// @param data Extra calldata information passed along to this strategy. function execute(address user, uint256, /* debt */ bytes calldata data) external payable onlyGoblin nonReentrant { // 1. Find out what farming token we are dealing with. (address fToken, uint256 fAmount, uint256 minLPAmount) = abi.decode(data, (address, uint256, uint256)); IUniswapV2Pair lpToken = IUniswapV2Pair(factory.getPair(fToken, weth)); // 2. Compute the optimal amount of ETH and fToken to be converted. if (fAmount > 0) { fToken.safeTransferFrom(user, address(this), fAmount); } uint256 ethBalance = address(this).balance; uint256 swapAmt; bool isReversed; { (uint256 r0, uint256 r1, ) = lpToken.getReserves(); (uint256 ethReserve, uint256 fReserve) = lpToken.token0() == weth ? (r0, r1) : (r1, r0); (swapAmt, isReversed) = optimalDeposit(ethBalance, fToken.myBalance(), ethReserve, fReserve); } // 3. Convert between ETH and farming tokens fToken.safeApprove(address(router), 0); fToken.safeApprove(address(router), uint256(-1)); address[] memory path = new address[](2); (path[0], path[1]) = isReversed ? (fToken, weth) : (weth, fToken); if (isReversed) { router.swapExactTokensForETH(swapAmt, 0, path, address(this), now); // farming tokens to ETH } else { router.swapExactETHForTokens.value(swapAmt)(0, path, address(this), now); // ETH to farming tokens } // 4. Mint more LP tokens and return all LP tokens to the sender. (,, uint256 moreLPAmount) = router.addLiquidityETH.value(address(this).balance)( fToken, fToken.myBalance(), 0, 0, address(this), now ); require(moreLPAmount >= minLPAmount, "insufficient LP tokens received"); lpToken.transfer(msg.sender, lpToken.balanceOf(address(this))); } /// @dev Recover ERC20 tokens that were accidentally sent to this smart contract. /// @param token The token contract. Can be anything. This contract should not hold ERC20 tokens. /// @param to The address to send the tokens to. /// @param value The number of tokens to transfer to `to`. function recover(address token, address to, uint256 value) external onlyOwner nonReentrant { token.safeTransfer(to, value); } function() external payable {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract IUniswapV2Router02","name":"_router","type":"address"},{"internalType":"address","name":"_goblin","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"execute","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"factory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"goblin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isGoblin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"recover","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
19815:5334:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24969:139;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24969:139:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;24969:139:0;;;;;;;;;;;;;;;;;:::i;20043:19::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20043:19:0;;;:::i;:::-;;;;-1:-1:-1;;;;;20043:19:0;;;;;;;;;;;;;;20693:93;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20693:93:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;1724:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1724:140:0;;;:::i;913:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;913:79:0;;;:::i;1279:92::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;1279:92:0;;;:::i;22643:2010::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;22643:2010:0;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;22643:2010:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;22643:2010:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;22643:2010:0;;-1:-1:-1;22643:2010:0;-1:-1:-1;22643:2010:0;:::i;20069:21::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20069:21:0;;;:::i;19965:32::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19965:32:0;;;:::i;2019:109::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2019:109:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2019:109:0;-1:-1:-1;;;;;2019:109:0;;:::i;20004:32::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;20004:32:0;;;:::i;24969:139::-;1125:9;:7;:9::i;:::-;1117:54;;;;;-1:-1:-1;;;1117:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7601:1;7584:18;;;;;;;;25071:29;-1:-1:-1;;;;;25071:18:0;;25090:2;25094:5;25071:29;:18;:29;:::i;:::-;7696:13;;7680:12;:29;7672:73;;;;;-1:-1:-1;;;7672:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1182:1;24969:139;;;:::o;20043:19::-;;;-1:-1:-1;;;;;20043:19:0;;:::o;20693:93::-;20772:6;;-1:-1:-1;;;;;20772:6:0;20758:10;:20;;20693:93::o;1724:140::-;1125:9;:7;:9::i;:::-;1117:54;;;;;-1:-1:-1;;;1117:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1823:1;1807:6;;1786:40;;-1:-1:-1;;;;;1807:6:0;;;;1786:40;;1823:1;;1786:40;1854:1;1837:19;;-1:-1:-1;;;;;;1837:19:0;;;1724:140::o;913:79::-;951:7;978:6;-1:-1:-1;;;;;978:6:0;913:79;:::o;1279:92::-;1319:4;1357:6;-1:-1:-1;;;;;1357:6:0;1343:10;:20;;1279:92::o;22643:2010::-;20562:10;:8;:10::i;:::-;20554:47;;;;;-1:-1:-1;;;20554:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7601:1;7584:18;;;;;;;;:13;;;22960:4;;13:2:-1;5:11;;2:2;;;29:1;26;19:12;2:2;-1:-1;23045:7:0;;23069:4;;;22949:45;23045:29;;-1:-1:-1;;;23045:29:0;;-1:-1:-1;;;;;22949:45:0;;;;23045:29;;;;;;23069:4;;;23045:29;;;;;;22949:45;;-1:-1:-1;22949:45:0;;;;;;-1:-1:-1;22949:45:0;;;;;;-1:-1:-1;23005:22:0;;23045:7;;;;;:15;;:29;;;;;22949:45;23045:29;;;;;:7;:29;;;5:2:-1;;;;30:1;27;20:12;5:2;23045:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23045:29:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23045:29:0;;-1:-1:-1;23177:11:0;;23173:111;;23207:53;-1:-1:-1;;;;;23207:23:0;;23231:4;23245;23252:7;23207:53;:23;:53;:::i;:::-;23294:18;23315:21;23294:42;;23347:15;23373;23415:10;23427;23443:7;-1:-1:-1;;;;;23443:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;23443:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23443:21:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23443:21:0;;;;;;;23540:4;;;23443:21;23520:16;;-1:-1:-1;;;23520:16:0;;;;23414:50;;;;;-1:-1:-1;23414:50:0;;;;;-1:-1:-1;23480:18:0;;;;-1:-1:-1;;;;;23540:4:0;;;;23520:14;;;;;;:16;;;;23443:21;23520:16;;;;;;;:14;:16;;;5:2:-1;;;;30:1;27;20:12;5:2;23520:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;23520:16:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;23520:16:0;-1:-1:-1;;;;;23520:24:0;;:46;;23559:2;23563;23520:46;;;23548:2;23552;23520:46;23479:87;;;;23605:68;23620:10;23632:18;:6;-1:-1:-1;;;;;23632:16:0;;:18::i;:::-;23652:10;23664:8;23605:14;:68::i;:::-;23776:6;;23581:92;;-1:-1:-1;23581:92:0;-1:-1:-1;23749:38:0;;-1:-1:-1;;;;;;23749:18:0;;;;-1:-1:-1;23776:6:0;;-1:-1:-1;23776:6:0;;-1:-1:-1;23749:38:0;:18;:38;:::i;:::-;23825:6;;23798:48;;-1:-1:-1;;;;;23798:18:0;;;;23825:6;-1:-1:-1;;23798:48:0;:18;:48;:::i;:::-;23881:16;;;23895:1;23881:16;;;23857:21;23881:16;;;;;23857:21;23881:16;;;;;105:10:-1;23881:16:0;88:34:-1;136:17;;-1:-1;23881:16:0;23857:40;;23929:10;:44;;23960:4;;-1:-1:-1;;;;;23960:4:0;23966:6;23929:44;;;23951:4;;23943:6;;-1:-1:-1;;;;;23951:4:0;23929:44;23909:4;23914:1;23909:7;;;;;;;;;;;;;23918:4;23923:1;23918:7;;;;;;;;-1:-1:-1;;;;;23908:65:0;;;23918:7;;;;;;;;;23908:65;;;;;23984:264;;;;24015:6;;:66;;-1:-1:-1;;;24015:66:0;;;;;;;;:6;:66;;;;;;24070:4;24015:66;;;;;;24077:3;24015:66;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24015:6:0;;;;:28;;24044:7;;24056:4;;24070;24077:3;24015:66;;;;;;;;;;;;;;;;:6;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;24015:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24015:66:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24015:66:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;24015:66:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;13:2;5:11;;2:2;;;29:1;26;19:12;2:2;24015:66:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;62:21;;;;123:4;114:14;;138:31;;;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;373:25;;-1:-1;24015:66:0;;421:4:-1;412:14;;;;24015:66:0;;;;;412:14:-1;24015:66:0;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;24015:66:0;;;;;;;;;;;;23984:264;;;24139:6;;:72;;-1:-1:-1;;;24139:72:0;;:6;:72;;;;;;24200:4;24139:72;;;;;;24207:3;24139:72;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24139:6:0;;;;:28;;24174:7;;24139:6;24186:4;;24200;24207:3;24139:72;;;;;;;;;;;;;;;;:6;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;24139:72:0;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;24139:72:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24139:72:0;;;;;;;39:16:-1;36:1;17:17;2:54;101:4;24139:72:0;80:15:-1;;;-1:-1;;76:31;65:43;;120:4;113:20;13:2;5:11;;2:2;;;29:1;26;19:12;2:2;24139:72:0;;;;;;;;;;;;;19:11:-1;14:3;11:20;8:2;;;44:1;41;34:12;8:2;62:21;;;;123:4;114:14;;138:31;;;135:2;;;182:1;179;172:12;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;261:11;247:12;244:29;233:116;230:2;;;362:1;359;352:12;230:2;373:25;;-1:-1;24139:72:0;;421:4:-1;412:14;;;;24139:72:0;;;;;412:14:-1;24139:72:0;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;24139:72:0;;;;;;;;;;;;23984:264;24361:6;;24337:20;;-1:-1:-1;;;;;24361:6:0;;;;:22;;24390:21;;24427:6;;24435:18;;:16;;;:18::i;:::-;24361:129;;;-1:-1:-1;;;;;;24361:129:0;;;;;;;-1:-1:-1;;;;;24361:129:0;;;;;;;;;;;;;;24455:1;24361:129;;;;;;;;;;24469:4;24361:129;;;;24476:3;24361:129;;;;;;;;;;;;;;;;;;;;;;;;5:2:-1;;;;30:1;27;20:12;5:2;24361:129:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24361:129:0;;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24361:129:0;;;;-1:-1:-1;24509:27:0;;;;24501:71;;;;;-1:-1:-1;;;24501:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;24612:32;;;-1:-1:-1;;;24612:32:0;;24638:4;24612:32;;;;;;-1:-1:-1;;;;;24583:16:0;;;;;24600:10;;24583:16;;24612:17;;:32;;;;;;;;;;;;;;;24583:16;24612:32;;;5:2:-1;;;;30:1;27;20:12;5:2;24612:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24612:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;24612:32:0;24583:62;;;-1:-1:-1;;;;;;24583:62:0;;;;;;;-1:-1:-1;;;;;24583:62:0;;;;;;;;;;;;;;;;;;;;24612:32;;24583:62;;;;;;;-1:-1:-1;24583:62:0;;;;5:2:-1;;;;30:1;27;20:12;5:2;24583:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;24583:62:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;7696:13:0;;7680:29;;;-1:-1:-1;7672:73:0;;-1:-1:-1;;;;;;;;7672:73:0;;;;-1:-1:-1;;;7672:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;20612:1;22643:2010;;;;:::o;20069:21::-;;;-1:-1:-1;;;;;20069:21:0;;:::o;19965:32::-;;;-1:-1:-1;;;;;19965:32:0;;:::o;2019:109::-;1125:9;:7;:9::i;:::-;1117:54;;;;;-1:-1:-1;;;1117:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2092:28;2111:8;2092:18;:28::i;:::-;2019:109;:::o;20004:32::-;;;-1:-1:-1;;;;;20004:32:0;;:::o;18278:346::-;18476:45;;;-1:-1:-1;;;;;18476:45:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18476:45:0;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;18465:57:0;;;;18430:12;;18444:17;;18465:10;;;;18476:45;18465:57;;;25:18:-1;18465:57:0;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;18465:57:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;18429:93:0;;;;18541:7;:57;;;;-1:-1:-1;18553:11:0;;:16;;:44;;;18584:4;18573:24;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18573:24:0;18553:44;18533:83;;;;;-1:-1:-1;;;18533:83:0;;;;;;;;;;;;-1:-1:-1;;;18533:83:0;;;;;;;;;;;;;;18632:386;18860:51;;;-1:-1:-1;;;;;18860:51:0;;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18860:51:0;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;18849:63:0;;;;18814:12;;18828:17;;18849:10;;;;18860:51;18849:63;;;25:18:-1;18849:63:0;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;18849:63:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;18813:99:0;;;;18931:7;:57;;;;-1:-1:-1;18943:11:0;;:16;;:44;;;18974:4;18963:24;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18963:24:0;18943:44;18923:87;;;;;-1:-1:-1;;;18923:87:0;;;;;;;;;;;;-1:-1:-1;;;18923:87:0;;;;;;;;;;;;;;;18632:386;;;;;;:::o;17630:138::-;17714:46;;;-1:-1:-1;;;17714:46:0;;17754:4;17714:46;;;;;;17687:7;;-1:-1:-1;;;;;17714:31:0;;;;;:46;;;;;;;;;;;;;;;:31;:46;;;5:2:-1;;;;30:1;27;20:12;5:2;17714:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;17714:46:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17714:46:0;;-1:-1:-1;17630:138:0;;;;:::o;21055:461::-;21201:15;;21268:14;:4;21277;21268:14;:8;:14;:::i;:::-;21250;:4;21259;21250:14;:8;:14;:::i;:::-;:32;21246:263;;21309:40;21326:4;21332;21338;21344;21309:16;:40::i;:::-;21299:50;;21377:5;21364:18;;21246:263;;;21425:40;21442:4;21448;21454;21460;21425:16;:40::i;:::-;21415:50;;21493:4;21480:17;;21246:263;21055:461;;;;;;;:::o;17927:343::-;18123:45;;;-1:-1:-1;;;;;18123:45:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18123:45:0;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;18112:57:0;;;;18077:12;;18091:17;;18112:10;;;;18123:45;18112:57;;;25:18:-1;18112:57:0;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;18112:57:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;18076:93:0;;;;18188:7;:57;;;;-1:-1:-1;18200:11:0;;:16;;:44;;;18231:4;18220:24;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18220:24:0;18200:44;18180:82;;;;;-1:-1:-1;;;18180:82:0;;;;;;;;;;;;-1:-1:-1;;;18180:82:0;;;;;;;;;;;;;;2234:229;-1:-1:-1;;;;;2308:22:0;;2300:73;;;;-1:-1:-1;;;2300:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2410:6;;;2389:38;;-1:-1:-1;;;;;2389:38:0;;;;2410:6;;;2389:38;;;2438:6;:17;;-1:-1:-1;;;;;;2438:17:0;-1:-1:-1;;;;;2438:17:0;;;;;;;;;;2234:229::o;4288:470::-;4346:7;4590:6;4586:47;;-1:-1:-1;4620:1:0;4613:8;;4586:47;4657:5;;;4661:1;4657;:5;:1;4681:5;;;;;:10;4673:56;;;;-1:-1:-1;;;4673:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4749:1;-1:-1:-1;4288:470:0;;;;;:::o;21792:645::-;21940:7;21986:14;:4;21995;21986:14;:8;:14;:::i;:::-;21968;:4;21977;21968:14;:8;:14;:::i;:::-;:32;;21960:53;;;;;-1:-1:-1;;;21960:53:0;;;;;;;;;;;;-1:-1:-1;;;21960:53:0;;;;;;;;;;;;;;;22038:3;22026:9;22064:23;22072:4;22082;22064:23;:17;:23;:::i;:::-;22052:35;-1:-1:-1;22098:10:0;22111:36;22132:14;:4;22141;22132:14;:8;:14;:::i;:::-;22112;:4;22121;22112:14;:8;:14;:::i;:::-;22111:20;:36;:20;:36;:::i;:::-;22098:49;-1:-1:-1;22158:9:0;22170:42;22207:4;22170:32;22187:14;:4;22196;22187:14;:8;:14;:::i;:::-;22170:12;:2;22177:4;22170:12;:6;:12;:::i;:::-;:16;:32;:16;:32;:::i;:::-;:36;:42;:36;:42;:::i;:::-;22158:54;-1:-1:-1;22225:9:0;22237:15;22250:1;22237:8;:1;22158:54;22237:8;:5;:8;:::i;:15::-;22225:27;-1:-1:-1;22263:9:0;22275:26;22285:15;22225:27;22285:8;22291:1;;22285:8;:5;:8;:::i;:::-;:12;:15;:12;:15;:::i;:::-;22275:9;:26::i;:::-;22263:38;-1:-1:-1;22314:17:0;22334:8;22263:38;22340:1;22334:8;:5;:8;:::i;:::-;22314:28;-1:-1:-1;22353:19:0;22375:8;:1;22381;22375:8;:5;:8;:::i;:::-;22353:30;-1:-1:-1;22403:26:0;:9;22353:30;22403:26;:13;:26;:::i;:::-;22396:33;21792:645;-1:-1:-1;;;;;;;;;;;;;21792:645:0:o;3853:184::-;3911:7;3944:1;3939;:6;;3931:49;;;;;-1:-1:-1;;;3931:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4003:5:0;;;3853:184::o;3397:181::-;3455:7;3487:5;;;3511:6;;;;3503:46;;;;;-1:-1:-1;;;3503:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;5226:333;5284:7;5383:1;5379;:5;5371:44;;;;;-1:-1:-1;;;5371:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5426:9;5442:1;5438;:5;;;;;;;5226:333;-1:-1:-1;;;;5226:333:0:o;11434:303::-;11479:6;11506:1;11502;:5;11498:232;;;-1:-1:-1;11528:1:0;11561;11557;11553:5;;:9;11577:92;11588:1;11584;:5;11577:92;;;11614:1;11610:5;;11652:1;11647;11643;11639;:5;;;;;;:9;11638:15;;;;;;11634:19;;11577:92;;;11498:232;;;;11690:6;;11686:44;;-1:-1:-1;11717:1:0;11434:303;;;:::o
Swarm Source
bzzr://3bb62ec71722384d9a0ff6f1b1bee32791eec6c2b798185c87e77ad8ab77afa3
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.