Contract 0x28FF66a1B95d7CAcf8eDED2e658f768F44841212 1

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xc9dfb4c8f1071d0e75cb1a6505994dd6364cbc893dccda683fef19afae57ba36Bind Asset Hash194128122021-09-23 7:42:431 day 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000448264
0x498bd20876e37bcc7c68a438ca6cc0bedb98abd4f0707c4b245680f355aae9c3Bind Asset Hash194128072021-09-23 7:42:331 day 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000616363
0x59e6c78cdd48047879c11aad6fb75f6d70f105ea4ab2983101745b64f00db819Bind Asset Hash194128072021-09-23 7:42:331 day 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00112066
0x48d6836bb8b670377de07d66ede71d6ac14db81d28b448e6ecba5c063014f9e7Bind Asset Hash194128072021-09-23 7:42:331 day 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00043537641
0xea29696882df97a8f959c3ca89c63798432658867fe8272a91620df80b411a68Bind Asset Hash194098032021-09-23 5:42:081 day 22 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.0006233982
0x40ce3a3a561153a48c35b4aa6f73256980eafb489953dda874484db586f82d59Bind Asset Hash194097962021-09-23 5:41:541 day 22 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00081041766
0xc1ae77aed0a061eb30c0569971e30449c8784f3fb03008b1d4bdb4e6ea393fbcBind Asset Hash194097952021-09-23 5:41:521 day 22 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.0009350973
0xb47155c390cfa1c3304344223aa12698db81c63dd045a670a9667b52c99781f8Bind Asset Hash194097402021-09-23 5:39:581 day 22 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00056162
0x84fcd5ab408ac9358fbbdcee57e9c45933b03f3d34459ed48988cdce9474cdf7Bind Asset Hash186479782021-09-02 3:59:4522 days 23 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000066430902
0xb4b76c78ca63f790acf69a27f553c4d79122b95ccf3346946ab981c5b7e0b680Bind Asset Hash185860602021-08-31 10:22:3524 days 17 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000068610432
0xc39d6e9231e63ad3fe706a31bd4de442ce108bb6bccc436dc7f321f7d1cbdb6cBind Asset Hash185860602021-08-31 10:22:3524 days 17 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000056192
0xba3816bbdd177adc43f7e93ac5a50fee29dc7b9af388f9c1442fcc8ac1e1d573Transfer184890012021-08-28 14:34:1427 days 13 hrs ago0xe7804c37c13166ff0b37f5ae0bb07a3aebb6e245 IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120.3 MATIC0.000042092
0x82460daf6314c84a840cb09e631ef35d8b990fdb9304d56817033639c00af040Transfer184772392021-08-28 6:58:4427 days 20 hrs ago0xe7804c37c13166ff0b37f5ae0bb07a3aebb6e245 IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120.3 MATIC0.000042092
0xb55816637310aca6ae682a926b46b310916d90265cfe195725d4582f5b408c55Bind Asset Hash183293712021-08-24 3:09:1032 days 36 mins ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000336378
0x683b6811c3e1a82a00b24cdc8bddb414613964526255652e5cdb2a638a6f56d6Bind Asset Hash183293662021-08-24 3:09:0032 days 36 mins ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00033918115
0xe2337ba086d17922ea948983db74308891a292d39a7e88f29b13e1e3b3c9884eBind Asset Hash183293632021-08-24 3:08:5432 days 37 mins ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00033918115
0x7e5fc6448243e4257f2b32993ebfa70182f776609e4b06c42e73820d85d0b55bTransfer183148672021-08-23 18:29:1432 days 9 hrs ago0xd442c0eff7ad7e558c915279f60756fa91ec679a IN  0x28ff66a1b95d7cacf8eded2e658f768f448412121 MATIC0.00010523
0xd4d6c3a0d353a1fca7b30570d415e9827673560277406c326dc54e1d093b300aTransfer183143332021-08-23 18:10:5032 days 9 hrs ago0xd442c0eff7ad7e558c915279f60756fa91ec679a IN  0x28ff66a1b95d7cacf8eded2e658f768f448412121 MATIC0.000105
0x044afba1288263bff153c81f7aca9a2042bec23858fa2af4d33ed3abe978f812Transfer183142642021-08-23 18:08:2832 days 9 hrs ago0xd442c0eff7ad7e558c915279f60756fa91ec679a IN  0x28ff66a1b95d7cacf8eded2e658f768f448412121 MATIC0.0000475524
0xd4c518bab69efd8a8e64f94a9c7687c43d742217ea9b7915a0061b958be649e9Transfer183142432021-08-23 18:07:4632 days 9 hrs ago0xd442c0eff7ad7e558c915279f60756fa91ec679a IN  0x28ff66a1b95d7cacf8eded2e658f768f448412121 MATIC0.000105
0x0c8396b6112cb785978c5fe677fc6b4ef4a85313448d3f8722f7d7283bb2cbccBind Asset Hash182971982021-08-23 7:35:5132 days 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000280525
0x12413fdf971862a33231e2a4ca057b9eb6997039b1f25037cb4cad7d32f5af1fBind Asset Hash182971762021-08-23 7:35:0732 days 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000345634852
0xabc09cf473a50ed717a0d69dc6f79db817064d87f0b498bbc13f3aebef031c95Bind Asset Hash182969762021-08-23 7:22:5932 days 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.00078547028
0x06c5bc9d746cb32d976c577e79b034593df83c9d6091a8244695ab743965da91Bind Asset Hash182969702021-08-23 7:22:2332 days 20 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000841575
0x2f291be4bb2bf2d4074f93be505885cd067e1da31f2178a6a1172e6f53cd8e34Bind Asset Hash182193482021-08-21 4:41:5634 days 23 hrs ago0x33bb64087e2ca54d1b74bf765745fdd8eeb196bb IN  0x28ff66a1b95d7cacf8eded2e658f768f448412120 MATIC0.000041319
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
LockProxy

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-09-01
*/

pragma solidity ^0.5.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 * Refer from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/GSN/Context.sol
 */
contract Context {
    // Empty internal constructor, to prevent people from mistakenly deploying
    // an instance of this contract, which should be used via inheritance.
    constructor () internal { }
    // solhint-disable-previous-line no-empty-blocks

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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 applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @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 _msgSender() == _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;
    }
}
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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     *
     * _Available since v2.4.0._
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        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-contracts/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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b != 0, errorMessage);
        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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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.
     *
     * _Available since v2.4.0._
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}
pragma solidity ^0.5.0;


library Utils {

    /* @notice      Convert the bytes array to bytes32 type, the bytes array length must be 32
    *  @param _bs   Source bytes array
    *  @return      bytes32
    */
    function bytesToBytes32(bytes memory _bs) internal pure returns (bytes32 value) {
        require(_bs.length == 32, "bytes length is not 32.");
        assembly {
            // load 32 bytes from memory starting from position _bs + 0x20 since the first 0x20 bytes stores _bs length
            value := mload(add(_bs, 0x20))
        }
    }

    /* @notice      Convert bytes to uint256
    *  @param _b    Source bytes should have length of 32
    *  @return      uint256
    */
    function bytesToUint256(bytes memory _bs) internal pure returns (uint256 value) {
        require(_bs.length == 32, "bytes length is not 32.");
        assembly {
            // load 32 bytes from memory starting from position _bs + 32
            value := mload(add(_bs, 0x20))
        }
        require(value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
    }

    /* @notice      Convert uint256 to bytes
    *  @param _b    uint256 that needs to be converted
    *  @return      bytes
    */
    function uint256ToBytes(uint256 _value) internal pure returns (bytes memory bs) {
        require(_value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
        assembly {
            // Get a location of some free memory and store it in result as
            // Solidity does for memory variables.
            bs := mload(0x40)
            // Put 0x20 at the first word, the length of bytes for uint256 value
            mstore(bs, 0x20)
            //In the next word, put value in bytes format to the next 32 bytes
            mstore(add(bs, 0x20), _value)
            // Update the free-memory pointer by padding our last write location to 32 bytes
            mstore(0x40, add(bs, 0x40))
        }
    }

    /* @notice      Convert bytes to address
    *  @param _bs   Source bytes: bytes length must be 20
    *  @return      Converted address from source bytes
    */
    function bytesToAddress(bytes memory _bs) internal pure returns (address addr)
    {
        require(_bs.length == 20, "bytes length does not match address");
        assembly {
            // for _bs, first word store _bs.length, second word store _bs.value
            // load 32 bytes from mem[_bs+20], convert it into Uint160, meaning we take last 20 bytes as addr (address).
            addr := mload(add(_bs, 0x14))
        }

    }
    
    /* @notice      Convert address to bytes
    *  @param _addr Address need to be converted
    *  @return      Converted bytes from address
    */
    function addressToBytes(address _addr) internal pure returns (bytes memory bs){
        assembly {
            // Get a location of some free memory and store it in result as
            // Solidity does for memory variables.
            bs := mload(0x40)
            // Put 20 (address byte length) at the first word, the length of bytes for uint256 value
            mstore(bs, 0x14)
            // logical shift left _a by 12 bytes, change _a from right-aligned to left-aligned
            mstore(add(bs, 0x20), shl(96, _addr))
            // Update the free-memory pointer by padding our last write location to 32 bytes
            mstore(0x40, add(bs, 0x40))
       }
    }

    /* @notice          Do hash leaf as the multi-chain does
    *  @param _data     Data in bytes format
    *  @return          Hashed value in bytes32 format
    */
    function hashLeaf(bytes memory _data) internal pure returns (bytes32 result)  {
        result = sha256(abi.encodePacked(byte(0x0), _data));
    }

    /* @notice          Do hash children as the multi-chain does
    *  @param _l        Left node
    *  @param _r        Right node
    *  @return          Hashed value in bytes32 format
    */
    function hashChildren(bytes32 _l, bytes32  _r) internal pure returns (bytes32 result)  {
        result = sha256(abi.encodePacked(bytes1(0x01), _l, _r));
    }

    /* @notice              Compare if two bytes are equal, which are in storage and memory, seperately
                            Refer from https://github.com/summa-tx/bitcoin-spv/blob/master/solidity/contracts/BytesLib.sol#L368
    *  @param _preBytes     The bytes stored in storage
    *  @param _postBytes    The bytes stored in memory
    *  @return              Bool type indicating if they are equal
    */
    function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes_slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // fslot can contain both the length and contents of the array
                // if slength < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                // slength != 0
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes_slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    /* @notice              Slice the _bytes from _start index till the result has length of _length
                            Refer from https://github.com/summa-tx/bitcoin-spv/blob/master/solidity/contracts/BytesLib.sol#L246
    *  @param _bytes        The original bytes needs to be sliced
    *  @param _start        The index of _bytes for the start of sliced bytes
    *  @param _length       The index of _bytes for the end of sliced bytes
    *  @return              The sliced bytes
    */
    function slice(
        bytes memory _bytes,
        uint _start,
        uint _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_bytes.length >= (_start + _length));

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                // lengthmod <= _length % 32
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }
    /* @notice              Check if the elements number of _signers within _keepers array is no less than _m
    *  @param _keepers      The array consists of serveral address
    *  @param _signers      Some specific addresses to be looked into
    *  @param _m            The number requirement paramter
    *  @return              True means containment, false meansdo do not contain.
    */
    function containMAddresses(address[] memory _keepers, address[] memory _signers, uint _m) internal pure returns (bool){
        uint m = 0;
        for(uint i = 0; i < _signers.length; i++){
            for (uint j = 0; j < _keepers.length; j++) {
                if (_signers[i] == _keepers[j]) {
                    m++;
                    delete _keepers[j];
                }
            }
        }
        return m >= _m;
    }

    /* @notice              TODO
    *  @param key
    *  @return
    */
    function compressMCPubKey(bytes memory key) internal pure returns (bytes memory newkey) {
         require(key.length >= 67, "key lenggh is too short");
         newkey = slice(key, 0, 35);
         if (uint8(key[66]) % 2 == 0){
             newkey[2] = byte(0x02);
         } else {
             newkey[2] = byte(0x03);
         }
         return newkey;
    }
    
    /**
     * @dev Returns true if `account` is a contract.
     *      Refer from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol#L18
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * IMPORTANT: It is unsafe to assume that an address for which this
     * function returns false is an externally-owned account (EOA) and not a
     * contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }
}
pragma solidity ^0.5.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP. Does not include
 * the optional functions; to access them see {ERC20Detailed}.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves.

        // A Solidity high level call has three parts:
        //  1. The target address is checked to verify it contains contract code
        //  2. The call itself is made, and success asserted
        //  3. The return value is decoded, which in turn checks the size of the returned data.
        // solhint-disable-next-line max-line-length
        require(Utils.isContract(address(token)), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}
pragma solidity ^0.5.0;

/**
 * @dev Interface of the EthCrossChainManager contract for business contract like LockProxy to request cross chain transaction
 */
interface IEthCrossChainManager {
    function crossChain(uint64 _toChainId, bytes calldata _toContract, bytes calldata _method, bytes calldata _txData) external returns (bool);
}
pragma solidity ^0.5.0;

/**
 * @dev Interface of the EthCrossChainManagerProxy for business contract like LockProxy to obtain the reliable EthCrossChainManager contract hash.
 */
interface IEthCrossChainManagerProxy {
    function getEthCrossChainManager() external view returns (address);
}
pragma solidity ^0.5.0;

/**
 * @dev Wrappers over decoding and deserialization operation from bytes into bassic types in Solidity for PolyNetwork cross chain utility.
 *
 * Decode into basic types in Solidity from bytes easily. It's designed to be used 
 * for PolyNetwork cross chain application, and the decoding rules on Ethereum chain 
 * and the encoding rule on other chains should be consistent, and . Here we
 * follow the underlying deserialization rule with implementation found here: 
 * https://github.com/polynetwork/poly/blob/master/common/zero_copy_source.go
 *
 * Using this library instead of the unchecked serialization method can help reduce
 * the risk of serious bugs and handfule, so it's recommended to use it.
 *
 * Please note that risk can be minimized, yet not eliminated.
 */
library ZeroCopySource {
    /* @notice              Read next byte as boolean type starting at offset from buff
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the boolean value
    *  @return              The the read boolean value and new offset
    */
    function NextBool(bytes memory buff, uint256 offset) internal pure returns(bool, uint256) {
        require(offset + 1 <= buff.length && offset < offset + 1, "Offset exceeds limit");
        // byte === bytes1
        byte v;
        assembly{
            v := mload(add(add(buff, 0x20), offset))
        }
        bool value;
        if (v == 0x01) {
		    value = true;
    	} else if (v == 0x00) {
            value = false;
        } else {
            revert("NextBool value error");
        }
        return (value, offset + 1);
    }

    /* @notice              Read next byte starting at offset from buff
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the byte value
    *  @return              The read byte value and new offset
    */
    function NextByte(bytes memory buff, uint256 offset) internal pure returns (byte, uint256) {
        require(offset + 1 <= buff.length && offset < offset + 1, "NextByte, Offset exceeds maximum");
        byte v;
        assembly{
            v := mload(add(add(buff, 0x20), offset))
        }
        return (v, offset + 1);
    }

    /* @notice              Read next byte as uint8 starting at offset from buff
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the byte value
    *  @return              The read uint8 value and new offset
    */
    function NextUint8(bytes memory buff, uint256 offset) internal pure returns (uint8, uint256) {
        require(offset + 1 <= buff.length && offset < offset + 1, "NextUint8, Offset exceeds maximum");
        uint8 v;
        assembly{
            let tmpbytes := mload(0x40)
            let bvalue := mload(add(add(buff, 0x20), offset))
            mstore8(tmpbytes, byte(0, bvalue))
            mstore(0x40, add(tmpbytes, 0x01))
            v := mload(sub(tmpbytes, 0x1f))
        }
        return (v, offset + 1);
    }

    /* @notice              Read next two bytes as uint16 type starting from offset
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the uint16 value
    *  @return              The read uint16 value and updated offset
    */
    function NextUint16(bytes memory buff, uint256 offset) internal pure returns (uint16, uint256) {
        require(offset + 2 <= buff.length && offset < offset + 2, "NextUint16, offset exceeds maximum");
        
        uint16 v;
        assembly {
            let tmpbytes := mload(0x40)
            let bvalue := mload(add(add(buff, 0x20), offset))
            mstore8(tmpbytes, byte(0x01, bvalue))
            mstore8(add(tmpbytes, 0x01), byte(0, bvalue))
            mstore(0x40, add(tmpbytes, 0x02))
            v := mload(sub(tmpbytes, 0x1e))
        }
        return (v, offset + 2);
    }


    /* @notice              Read next four bytes as uint32 type starting from offset
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the uint32 value
    *  @return              The read uint32 value and updated offset
    */
    function NextUint32(bytes memory buff, uint256 offset) internal pure returns (uint32, uint256) {
        require(offset + 4 <= buff.length && offset < offset + 4, "NextUint32, offset exceeds maximum");
        uint32 v;
        assembly {
            let tmpbytes := mload(0x40)
            let byteLen := 0x04
            for {
                let tindex := 0x00
                let bindex := sub(byteLen, 0x01)
                let bvalue := mload(add(add(buff, 0x20), offset))
            } lt(tindex, byteLen) {
                tindex := add(tindex, 0x01)
                bindex := sub(bindex, 0x01)
            }{
                mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
            }
            mstore(0x40, add(tmpbytes, byteLen))
            v := mload(sub(tmpbytes, sub(0x20, byteLen)))
        }
        return (v, offset + 4);
    }

    /* @notice              Read next eight bytes as uint64 type starting from offset
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the uint64 value
    *  @return              The read uint64 value and updated offset
    */
    function NextUint64(bytes memory buff, uint256 offset) internal pure returns (uint64, uint256) {
        require(offset + 8 <= buff.length && offset < offset + 8, "NextUint64, offset exceeds maximum");
        uint64 v;
        assembly {
            let tmpbytes := mload(0x40)
            let byteLen := 0x08
            for {
                let tindex := 0x00
                let bindex := sub(byteLen, 0x01)
                let bvalue := mload(add(add(buff, 0x20), offset))
            } lt(tindex, byteLen) {
                tindex := add(tindex, 0x01)
                bindex := sub(bindex, 0x01)
            }{
                mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
            }
            mstore(0x40, add(tmpbytes, byteLen))
            v := mload(sub(tmpbytes, sub(0x20, byteLen)))
        }
        return (v, offset + 8);
    }

    /* @notice              Read next 32 bytes as uint256 type starting from offset,
                            there are limits considering the numerical limits in multi-chain
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the uint256 value
    *  @return              The read uint256 value and updated offset
    */
    function NextUint255(bytes memory buff, uint256 offset) internal pure returns (uint256, uint256) {
        require(offset + 32 <= buff.length && offset < offset + 32, "NextUint255, offset exceeds maximum");
        uint256 v;
        assembly {
            let tmpbytes := mload(0x40)
            let byteLen := 0x20
            for {
                let tindex := 0x00
                let bindex := sub(byteLen, 0x01)
                let bvalue := mload(add(add(buff, 0x20), offset))
            } lt(tindex, byteLen) {
                tindex := add(tindex, 0x01)
                bindex := sub(bindex, 0x01)
            }{
                mstore8(add(tmpbytes, tindex), byte(bindex, bvalue))
            }
            mstore(0x40, add(tmpbytes, byteLen))
            v := mload(tmpbytes)
        }
        require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range");
        return (v, offset + 32);
    }
    /* @notice              Read next variable bytes starting from offset,
                            the decoding rule coming from multi-chain
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the bytes value
    *  @return              The read variable bytes array value and updated offset
    */
    function NextVarBytes(bytes memory buff, uint256 offset) internal pure returns(bytes memory, uint256) {
        uint len;
        (len, offset) = NextVarUint(buff, offset);
        require(offset + len <= buff.length && offset < offset + len, "NextVarBytes, offset exceeds maximum");
        bytes memory tempBytes;
        assembly{
            switch iszero(len)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(len, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, len)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))), offset)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, len)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return (tempBytes, offset + len);
    }
    /* @notice              Read next 32 bytes starting from offset,
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the bytes value
    *  @return              The read bytes32 value and updated offset
    */
    function NextHash(bytes memory buff, uint256 offset) internal pure returns (bytes32 , uint256) {
        require(offset + 32 <= buff.length && offset < offset + 32, "NextHash, offset exceeds maximum");
        bytes32 v;
        assembly {
            v := mload(add(buff, add(offset, 0x20)))
        }
        return (v, offset + 32);
    }

    /* @notice              Read next 20 bytes starting from offset,
    *  @param buff          Source bytes array
    *  @param offset        The position from where we read the bytes value
    *  @return              The read bytes20 value and updated offset
    */
    function NextBytes20(bytes memory buff, uint256 offset) internal pure returns (bytes20 , uint256) {
        require(offset + 20 <= buff.length && offset < offset + 20, "NextBytes20, offset exceeds maximum");
        bytes20 v;
        assembly {
            v := mload(add(buff, add(offset, 0x20)))
        }
        return (v, offset + 20);
    }
    
    function NextVarUint(bytes memory buff, uint256 offset) internal pure returns(uint, uint256) {
        byte v;
        (v, offset) = NextByte(buff, offset);

        uint value;
        if (v == 0xFD) {
            // return NextUint16(buff, offset);
            (value, offset) = NextUint16(buff, offset);
            require(value >= 0xFD && value <= 0xFFFF, "NextUint16, value outside range");
            return (value, offset);
        } else if (v == 0xFE) {
            // return NextUint32(buff, offset);
            (value, offset) = NextUint32(buff, offset);
            require(value > 0xFFFF && value <= 0xFFFFFFFF, "NextVarUint, value outside range");
            return (value, offset);
        } else if (v == 0xFF) {
            // return NextUint64(buff, offset);
            (value, offset) = NextUint64(buff, offset);
            require(value > 0xFFFFFFFF, "NextVarUint, value outside range");
            return (value, offset);
        } else{
            // return (uint8(v), offset);
            value = uint8(v);
            require(value < 0xFD, "NextVarUint, value outside range");
            return (value, offset);
        }
    }
}
pragma solidity ^0.5.0;

/**
 * @dev Wrappers over encoding and serialization operation into bytes from bassic types in Solidity for PolyNetwork cross chain utility.
 *
 * Encode basic types in Solidity into bytes easily. It's designed to be used 
 * for PolyNetwork cross chain application, and the encoding rules on Ethereum chain 
 * and the decoding rules on other chains should be consistent. Here we  
 * follow the underlying serialization rule with implementation found here: 
 * https://github.com/polynetwork/poly/blob/master/common/zero_copy_sink.go
 *
 * Using this library instead of the unchecked serialization method can help reduce
 * the risk of serious bugs and handfule, so it's recommended to use it.
 *
 * Please note that risk can be minimized, yet not eliminated.
 */
library ZeroCopySink {
    /* @notice          Convert boolean value into bytes
    *  @param b         The boolean value
    *  @return          Converted bytes array
    */
    function WriteBool(bool b) internal pure returns (bytes memory) {
        bytes memory buff;
        assembly{
            buff := mload(0x40)
            mstore(buff, 1)
            switch iszero(b)
            case 1 {
                mstore(add(buff, 0x20), shl(248, 0x00))
                // mstore8(add(buff, 0x20), 0x00)
            }
            default {
                mstore(add(buff, 0x20), shl(248, 0x01))
                // mstore8(add(buff, 0x20), 0x01)
            }
            mstore(0x40, add(buff, 0x21))
        }
        return buff;
    }

    /* @notice          Convert byte value into bytes
    *  @param b         The byte value
    *  @return          Converted bytes array
    */
    function WriteByte(byte b) internal pure returns (bytes memory) {
        return WriteUint8(uint8(b));
    }

    /* @notice          Convert uint8 value into bytes
    *  @param v         The uint8 value
    *  @return          Converted bytes array
    */
    function WriteUint8(uint8 v) internal pure returns (bytes memory) {
        bytes memory buff;
        assembly{
            buff := mload(0x40)
            mstore(buff, 1)
            mstore(add(buff, 0x20), shl(248, v))
            // mstore(add(buff, 0x20), byte(0x1f, v))
            mstore(0x40, add(buff, 0x21))
        }
        return buff;
    }

    /* @notice          Convert uint16 value into bytes
    *  @param v         The uint16 value
    *  @return          Converted bytes array
    */
    function WriteUint16(uint16 v) internal pure returns (bytes memory) {
        bytes memory buff;

        assembly{
            buff := mload(0x40)
            let byteLen := 0x02
            mstore(buff, byteLen)
            for {
                let mindex := 0x00
                let vindex := 0x1f
            } lt(mindex, byteLen) {
                mindex := add(mindex, 0x01)
                vindex := sub(vindex, 0x01)
            }{
                mstore8(add(add(buff, 0x20), mindex), byte(vindex, v))
            }
            mstore(0x40, add(buff, 0x22))
        }
        return buff;
    }
    
    /* @notice          Convert uint32 value into bytes
    *  @param v         The uint32 value
    *  @return          Converted bytes array
    */
    function WriteUint32(uint32 v) internal pure returns(bytes memory) {
        bytes memory buff;
        assembly{
            buff := mload(0x40)
            let byteLen := 0x04
            mstore(buff, byteLen)
            for {
                let mindex := 0x00
                let vindex := 0x1f
            } lt(mindex, byteLen) {
                mindex := add(mindex, 0x01)
                vindex := sub(vindex, 0x01)
            }{
                mstore8(add(add(buff, 0x20), mindex), byte(vindex, v))
            }
            mstore(0x40, add(buff, 0x24))
        }
        return buff;
    }

    /* @notice          Convert uint64 value into bytes
    *  @param v         The uint64 value
    *  @return          Converted bytes array
    */
    function WriteUint64(uint64 v) internal pure returns(bytes memory) {
        bytes memory buff;

        assembly{
            buff := mload(0x40)
            let byteLen := 0x08
            mstore(buff, byteLen)
            for {
                let mindex := 0x00
                let vindex := 0x1f
            } lt(mindex, byteLen) {
                mindex := add(mindex, 0x01)
                vindex := sub(vindex, 0x01)
            }{
                mstore8(add(add(buff, 0x20), mindex), byte(vindex, v))
            }
            mstore(0x40, add(buff, 0x28))
        }
        return buff;
    }

    /* @notice          Convert limited uint256 value into bytes
    *  @param v         The uint256 value
    *  @return          Converted bytes array
    */
    function WriteUint255(uint256 v) internal pure returns (bytes memory) {
        require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds uint255 range");
        bytes memory buff;

        assembly{
            buff := mload(0x40)
            let byteLen := 0x20
            mstore(buff, byteLen)
            for {
                let mindex := 0x00
                let vindex := 0x1f
            } lt(mindex, byteLen) {
                mindex := add(mindex, 0x01)
                vindex := sub(vindex, 0x01)
            }{
                mstore8(add(add(buff, 0x20), mindex), byte(vindex, v))
            }
            mstore(0x40, add(buff, 0x40))
        }
        return buff;
    }

    /* @notice          Encode bytes format data into bytes
    *  @param data      The bytes array data
    *  @return          Encoded bytes array
    */
    function WriteVarBytes(bytes memory data) internal pure returns (bytes memory) {
        uint64 l = uint64(data.length);
        return abi.encodePacked(WriteVarUint(l), data);
    }

    function WriteVarUint(uint64 v) internal pure returns (bytes memory) {
        if (v < 0xFD){
    		return WriteUint8(uint8(v));
    	} else if (v <= 0xFFFF) {
    		return abi.encodePacked(WriteByte(0xFD), WriteUint16(uint16(v)));
    	} else if (v <= 0xFFFFFFFF) {
            return abi.encodePacked(WriteByte(0xFE), WriteUint32(uint32(v)));
    	} else {
    		return abi.encodePacked(WriteByte(0xFF), WriteUint64(uint64(v)));
    	}
    }
}
contract LockProxy is Ownable {
    using SafeMath for uint;
    using SafeERC20 for IERC20;

    struct TxArgs {
        bytes toAssetHash;
        bytes toAddress;
        uint256 amount;
    }
    address public managerProxyContract;
    mapping(uint64 => bytes) public proxyHashMap;
    mapping(address => mapping(uint64 => bytes)) public assetHashMap;
    mapping(address => bool) safeTransfer;

    event SetManagerProxyEvent(address manager);
    event BindProxyEvent(uint64 toChainId, bytes targetProxyHash);
    event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint initialAmount);
    event UnlockEvent(address toAssetHash, address toAddress, uint256 amount);
    event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount);
    
    modifier onlyManagerContract() {
        IEthCrossChainManagerProxy ieccmp = IEthCrossChainManagerProxy(managerProxyContract);
        require(_msgSender() == ieccmp.getEthCrossChainManager(), "msgSender is not EthCrossChainManagerContract");
        _;
    }
    
    function setManagerProxy(address ethCCMProxyAddr) onlyOwner public {
        managerProxyContract = ethCCMProxyAddr;
        emit SetManagerProxyEvent(managerProxyContract);
    }
    
    function bindProxyHash(uint64 toChainId, bytes memory targetProxyHash) onlyOwner public returns (bool) {
        proxyHashMap[toChainId] = targetProxyHash;
        emit BindProxyEvent(toChainId, targetProxyHash);
        return true;
    }
    
    function bindAssetHash(address fromAssetHash, uint64 toChainId, bytes memory toAssetHash) onlyOwner public returns (bool) {
        assetHashMap[fromAssetHash][toChainId] = toAssetHash;
        emit BindAssetEvent(fromAssetHash, toChainId, toAssetHash, getBalanceFor(fromAssetHash));
        return true;
    }
    
    /* @notice                  This function is meant to be invoked by the user,
    *                           a certin amount teokens will be locked in the proxy contract the invoker/msg.sender immediately.
    *                           Then the same amount of tokens will be unloked from target chain proxy contract at the target chain with chainId later.
    *  @param fromAssetHash     The asset address in current chain, uniformly named as `fromAssetHash`
    *  @param toChainId         The target chain id
    *                           
    *  @param toAddress         The address in bytes format to receive same amount of tokens in target chain 
    *  @param amount            The amount of tokens to be crossed from ethereum to the chain with chainId
    */
    function lock(address fromAssetHash, uint64 toChainId, bytes memory toAddress, uint256 amount) public payable returns (bool) {
        require(amount != 0, "amount cannot be zero!");
        
        
        require(_transferToContract(fromAssetHash, amount), "transfer asset from fromAddress to lock_proxy contract  failed!");
        
        bytes memory toAssetHash = assetHashMap[fromAssetHash][toChainId];
        require(toAssetHash.length != 0, "empty illegal toAssetHash");

        TxArgs memory txArgs = TxArgs({
            toAssetHash: toAssetHash,
            toAddress: toAddress,
            amount: amount
        });
        bytes memory txData = _serializeTxArgs(txArgs);
        
        IEthCrossChainManagerProxy eccmp = IEthCrossChainManagerProxy(managerProxyContract);
        address eccmAddr = eccmp.getEthCrossChainManager();
        IEthCrossChainManager eccm = IEthCrossChainManager(eccmAddr);
        
        bytes memory toProxyHash = proxyHashMap[toChainId];
        require(toProxyHash.length != 0, "empty illegal toProxyHash");
        require(eccm.crossChain(toChainId, toProxyHash, "unlock", txData), "EthCrossChainManager crossChain executed error!");

        emit LockEvent(fromAssetHash, _msgSender(), toChainId, toAssetHash, toAddress, amount);
        
        return true;

    }
    
    // /* @notice                  This function is meant to be invoked by the ETH crosschain management contract,
    // *                           then mint a certin amount of tokens to the designated address since a certain amount 
    // *                           was burnt from the source chain invoker.
    // *  @param argsBs            The argument bytes recevied by the ethereum lock proxy contract, need to be deserialized.
    // *                           based on the way of serialization in the source chain proxy contract.
    // *  @param fromContractAddr  The source chain contract address
    // *  @param fromChainId       The source chain id
    // */
    function unlock(bytes memory argsBs, bytes memory fromContractAddr, uint64 fromChainId) onlyManagerContract public returns (bool) {
        TxArgs memory args = _deserializeTxArgs(argsBs);

        require(fromContractAddr.length != 0, "from proxy contract address cannot be empty");
        require(Utils.equalStorage(proxyHashMap[fromChainId], fromContractAddr), "From Proxy contract address error!");
        
        require(args.toAssetHash.length != 0, "toAssetHash cannot be empty");
        address toAssetHash = Utils.bytesToAddress(args.toAssetHash);

        require(args.toAddress.length != 0, "toAddress cannot be empty");
        address toAddress = Utils.bytesToAddress(args.toAddress);
        
        
        require(_transferFromContract(toAssetHash, toAddress, args.amount), "transfer asset from lock_proxy contract to toAddress failed!");
        
        emit UnlockEvent(toAssetHash, toAddress, args.amount);
        return true;
    }
    
    function getBalanceFor(address fromAssetHash) public view returns (uint256) {
        if (fromAssetHash == address(0)) {
            // return address(this).balance; // this expression would result in error: Failed to decode output: Error: insufficient data for uint256 type
            address selfAddr = address(this);
            return selfAddr.balance;
        } else {
            IERC20 erc20Token = IERC20(fromAssetHash);
            return erc20Token.balanceOf(address(this));
        }
    }
    function _transferToContract(address fromAssetHash, uint256 amount) internal returns (bool) {
        if (fromAssetHash == address(0)) {
            // fromAssetHash === address(0) denotes user choose to lock ether
            // passively check if the received msg.value equals amount
            require(msg.value != 0, "transferred ether cannot be zero!");
            require(msg.value == amount, "transferred ether is not equal to amount!");
        } else {
            // make sure lockproxy contract will decline any received ether
            require(msg.value == 0, "there should be no ether transfer!");
            // actively transfer amount of asset from msg.sender to lock_proxy contract
            require(_transferERC20ToContract(fromAssetHash, _msgSender(), address(this), amount), "transfer erc20 asset to lock_proxy contract failed!");
        }
        return true;
    }
    function _transferFromContract(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) {
        if (toAssetHash == address(0x0000000000000000000000000000000000000000)) {
            // toAssetHash === address(0) denotes contract needs to unlock ether to toAddress
            // convert toAddress from 'address' type to 'address payable' type, then actively transfer ether
            address(uint160(toAddress)).transfer(amount);
        } else {
            // actively transfer amount of asset from msg.sender to lock_proxy contract 
            require(_transferERC20FromContract(toAssetHash, toAddress, amount), "transfer erc20 asset to lock_proxy contract failed!");
        }
        return true;
    }
    
    function _transferERC20ToContract(address fromAssetHash, address fromAddress, address toAddress, uint256 amount) internal returns (bool) {
        IERC20 erc20Token = IERC20(fromAssetHash);
        //  require(erc20Token.transferFrom(fromAddress, toAddress, amount), "trasnfer ERC20 Token failed!");
        erc20Token.safeTransferFrom(fromAddress, toAddress, amount);
        return true;
    }

    function _transferERC20FromContract(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) {
        IERC20 erc20Token = IERC20(toAssetHash);
        //  require(erc20Token.transfer(toAddress, amount), "trasnfer ERC20 Token failed!");
        erc20Token.safeTransfer(toAddress, amount);
        return true;
    }
    
    function _serializeTxArgs(TxArgs memory args) internal pure returns (bytes memory) {
        bytes memory buff;
        buff = abi.encodePacked(
            ZeroCopySink.WriteVarBytes(args.toAssetHash),
            ZeroCopySink.WriteVarBytes(args.toAddress),
            ZeroCopySink.WriteUint255(args.amount)
            );
        return buff;
    }

    function _deserializeTxArgs(bytes memory valueBs) internal pure returns (TxArgs memory) {
        TxArgs memory args;
        uint256 off = 0;
        (args.toAssetHash, off) = ZeroCopySource.NextVarBytes(valueBs, off);
        (args.toAddress, off) = ZeroCopySource.NextVarBytes(valueBs, off);
        (args.amount, off) = ZeroCopySource.NextUint255(valueBs, off);
        return args;
    }
}

Contract Security Audit

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"fromAssetHash","type":"address"},{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"targetProxyHash","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"initialAmount","type":"uint256"}],"name":"BindAssetEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"targetProxyHash","type":"bytes"}],"name":"BindProxyEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"fromAssetHash","type":"address"},{"indexed":false,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"toAssetHash","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"toAddress","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LockEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"manager","type":"address"}],"name":"SetManagerProxyEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"toAssetHash","type":"address"},{"indexed":false,"internalType":"address","name":"toAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UnlockEvent","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint64","name":"","type":"uint64"}],"name":"assetHashMap","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"},{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"toAssetHash","type":"bytes"}],"name":"bindAssetHash","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"targetProxyHash","type":"bytes"}],"name":"bindProxyHash","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"}],"name":"getBalanceFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"},{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"toAddress","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"lock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"managerProxyContract","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"proxyHashMap","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"ethCCMProxyAddr","type":"address"}],"name":"setManagerProxy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"argsBs","type":"bytes"},{"internalType":"bytes","name":"fromContractAddr","type":"bytes"},{"internalType":"uint64","name":"fromChainId","type":"uint64"}],"name":"unlock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

49680:9456:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54432:976;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54432:976:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;54432:976:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;54432:976:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54432:976:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54432:976:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;54432:976:0;;;;;;;;-1:-1:-1;54432:976:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;54432:976:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54432:976:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54432:976:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;54432:976:0;;-1:-1:-1;;;54432:976:0;;-1:-1:-1;;;;;54432:976:0;;-1:-1:-1;54432:976:0;;-1:-1:-1;54432:976:0:i;:::-;;;;;;;;;;;;;;;;;;51274:314;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51274:314:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;51274:314:0;;;;-1:-1:-1;;;;;51274:314:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;51274:314:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51274:314:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51274:314:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;51274:314:0;;-1:-1:-1;51274:314:0;;-1:-1:-1;;;;;51274:314:0:i;51019:243::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51019:243:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;51019:243:0;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;51019:243:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51019:243:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51019:243:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;51019:243:0;;-1:-1:-1;51019:243:0;;-1:-1:-1;;;;;51019:243:0:i;49982:64::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49982:64:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49982:64:0;;-1:-1:-1;;;;;49982:64:0;;;;;-1:-1:-1;;;;;49982:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;49982:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55420:510;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55420:510:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;55420:510:0;-1:-1:-1;;;;;55420:510:0;;:::i;:::-;;;;;;;;;;;;;;;;2961:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2961:140:0;;;:::i;:::-;;52384:1352;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;52384:1352:0;;;;-1:-1:-1;;;;;52384:1352:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;52384:1352:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;52384:1352:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;52384:1352:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;52384:1352:0;;-1:-1:-1;;52384:1352:0;;;-1:-1:-1;52384:1352:0;;-1:-1:-1;;52384:1352:0:i;2150:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2150:79:0;;;:::i;:::-;;;;-1:-1:-1;;;;;2150:79:0;;;;;;;;;;;;;;2516:94;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2516:94:0;;;:::i;49931:44::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49931:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49931:44:0;-1:-1:-1;;;;;49931:44:0;;:::i;50825:182::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50825:182:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50825:182:0;-1:-1:-1;;;;;50825:182:0;;:::i;49889:35::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49889:35:0;;;:::i;3256:110::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3256:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3256:110:0;-1:-1:-1;;;;;3256:110:0;;:::i;54432:976::-;50655:20;;50711:32;;;-1:-1:-1;;;50711:32:0;;;;54556:4;;-1:-1:-1;;;;;50655:20:0;;;;50711:30;;:32;;;;;;;;;;;;;;;50655:20;50711:32;;;5:2:-1;;;;30:1;27;20:12;5:2;50711:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50711:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50711:32:0;-1:-1:-1;;;;;50695:48:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;50695:48:0;;50687:106;;;;-1:-1:-1;;;50687:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54573:18;;:::i;:::-;54594:26;54613:6;54594:18;:26::i;:::-;54573:47;;54641:16;:23;54668:1;54641:28;;54633:84;;;;-1:-1:-1;;;54633:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54755:25:0;;;;;;:12;:25;;;;;54736:63;;54782:16;54736:18;:63::i;:::-;54728:110;;;;-1:-1:-1;;;54728:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54867:16;;:23;54859:68;;;;;-1:-1:-1;;;54859:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54938:19;54960:38;54981:4;:16;;;54960:20;:38::i;:::-;54938:60;;55019:4;:14;;;:21;55044:1;55019:26;;55011:64;;;;;-1:-1:-1;;;55011:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55086:17;55106:36;55127:4;:14;;;55106:20;:36::i;:::-;55086:56;;55181:58;55203:11;55216:9;55227:4;:11;;;55181:21;:58::i;:::-;55173:131;;;;-1:-1:-1;;;55173:131:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55366:11;;;;;55330:48;;-1:-1:-1;;;;;55330:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55396:4:0;;54432:976;-1:-1:-1;;;;;;;54432:976:0:o;51274:314::-;51390:4;2362:9;:7;:9::i;:::-;2354:54;;;;;-1:-1:-1;;;2354:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2354:54:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;51407:27:0;;;;;;:12;:27;;;;;;;;-1:-1:-1;;;;;51407:38:0;;;;;;;;;:52;;;;;;;;:::i;:::-;;51475:83;51490:13;51505:9;51516:11;51529:28;51543:13;51529;:28::i;:::-;51475:83;;;;-1:-1:-1;;;;;51475:83:0;-1:-1:-1;;;;;51475:83:0;;;;;;-1:-1:-1;;;;;51475:83:0;-1:-1:-1;;;;;51475:83: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;51475:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51576:4:0;51274:314;;;;;:::o;51019:243::-;51116:4;2362:9;:7;:9::i;:::-;2354:54;;;;;-1:-1:-1;;;2354:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2354:54:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;51133:23:0;;;;;;:12;:23;;;;;;;;:41;;;;;;;;:::i;:::-;;51190:42;51205:9;51216:15;51190:42;;;;-1:-1:-1;;;;;51190:42:0;-1:-1:-1;;;;;51190:42: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;51190:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51250:4:0;51019:243;;;;:::o;49982:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49982:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55420:510::-;55487:7;-1:-1:-1;;;;;55511:27:0;;55507:416;;-1:-1:-1;55737:4:0;55764:16;55757:23;;55507:416;55876:35;;;-1:-1:-1;;;55876:35:0;;55905:4;55876:35;;;;;;55840:13;;-1:-1:-1;;;;;55876:20:0;;;;;:35;;;;;;;;;;;;;;;:20;:35;;;5:2:-1;;;;30:1;27;20:12;5:2;55876:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;55876:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;55876:35:0;;-1:-1:-1;55869:42:0;;-1:-1:-1;55869:42:0;55507:416;55420:510;;;:::o;2961:140::-;2362:9;:7;:9::i;:::-;2354:54;;;;;-1:-1:-1;;;2354:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2354:54:0;;;;;;;;;;;;;;;3060:1;3044:6;;3023:40;;-1:-1:-1;;;;;3044:6:0;;;;3023:40;;3060:1;;3023:40;3091:1;3074:19;;-1:-1:-1;;;;;;3074:19:0;;;2961:140::o;52384:1352::-;52503:4;52528:11;52520:46;;;;;-1:-1:-1;;;52520:46:0;;;;;;;;;;;;-1:-1:-1;;;52520:46:0;;;;;;;;;;;;;;;52605:42;52625:13;52640:6;52605:19;:42::i;:::-;52597:118;;;;-1:-1:-1;;;52597:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52763:27:0;;;;;;:12;:27;;;;;;;;-1:-1:-1;;;;;52763:38:0;;;;;;;;;;52736:65;;;;;;-1:-1:-1;;52736:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:24;;:65;;;52763:38;52736:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52820:11;:18;52842:1;52820:23;;52812:61;;;;;-1:-1:-1;;;52812:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;52886:20;;:::i;:::-;52909:122;;;;;;;;52944:11;52909:122;;;;52981:9;52909:122;;;;53013:6;52909:122;;;52886:145;;53042:19;53064:24;53081:6;53064:16;:24::i;:::-;53042:46;;53109:32;53171:20;;;;;;;;;-1:-1:-1;;;;;53171:20:0;53109:83;;53203:16;53222:5;-1:-1:-1;;;;;53222:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53222:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53222:31:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53222:31:0;-1:-1:-1;;;;;53372:23:0;;53264:26;53372:23;;;:12;53222:31;53372:23;;;;;;;;53345:50;;;;;;;;;;-1:-1:-1;;53345:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;53222:31;;-1:-1:-1;53222:31:0;;53345:24;;53372:23;;53345:50;;53372:23;53345:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53414:11;:18;53436:1;53414:23;;53406:61;;;;;-1:-1:-1;;;53406:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53486:4;-1:-1:-1;;;;;53486:15:0;;53502:9;53513:11;53536:6;53486:57;;;;;;;;;;;;;-1:-1:-1;;;;;53486:57:0;-1:-1:-1;;;;;53486:57: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;53486:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53486:57: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;53486:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53486:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53486:57:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53486:57:0;53478:117;;;;-1:-1:-1;;;53478:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53613:81;53623:13;53638:12;:10;:12::i;:::-;53652:9;53663:11;53676:9;53687:6;53613:81;;;;-1:-1:-1;;;;;53613:81:0;-1:-1:-1;;;;;53613:81:0;;;;;;-1:-1:-1;;;;;53613:81:0;-1:-1:-1;;;;;53613:81:0;;;;;;-1:-1:-1;;;;;53613:81:0;-1:-1:-1;;;;;53613:81: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;53613:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53613:81: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;53613:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53722:4:0;;52384:1352;-1:-1:-1;;;;;;;;;;;52384:1352:0:o;2150:79::-;2188:7;2215:6;-1:-1:-1;;;;;2215:6:0;2150:79;;:::o;2516:94::-;2556:4;2596:6;;-1:-1:-1;;;;;2596:6:0;2580:12;:10;:12::i;:::-;-1:-1:-1;;;;;2580:22:0;;2573:29;;2516:94;:::o;49931:44::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49931:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50825:182;2362:9;:7;:9::i;:::-;2354:54;;;;;-1:-1:-1;;;2354:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2354:54:0;;;;;;;;;;;;;;;50903:20;:38;;-1:-1:-1;;;;;;50903:38:0;-1:-1:-1;;;;;50903:38:0;;;;;;;;;;;50957:42;;;50978:20;;;;50957:42;;;;;;;;;;;;;50825:182;:::o;49889:35::-;;;-1:-1:-1;;;;;49889:35:0;;:::o;3256:110::-;2362:9;:7;:9::i;:::-;2354:54;;;;;-1:-1:-1;;;2354:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2354:54:0;;;;;;;;;;;;;;;3330:28;3349:8;3330:18;:28::i;:::-;3256:110;:::o;914:98::-;994:10;914:98;:::o;58734:399::-;58807:13;;:::i;:::-;58833:18;;:::i;:::-;58862:11;58914:41;58942:7;58862:11;58914:27;:41::i;:::-;58888:67;;;;-1:-1:-1;58990:41:0;59018:7;58888:67;58990:27;:41::i;:::-;58967:14;;;58966:65;;;;;-1:-1:-1;59063:40:0;59090:7;58966:65;59063:26;:40::i;:::-;-1:-1:-1;59043:11:0;;;59042:61;-1:-1:-1;59043:11:0;58734:399;-1:-1:-1;;58734:399:0:o;13832:3160::-;13927:4;13944:12;13959:4;13944:19;;14065:14;14059:21;14655:1;14650;14644;14637:5;14633:13;14626:21;14619:5;14615:33;14611:41;14604:5;14600:53;14596:61;14692:10;14686:17;14802:7;14793;14790:20;14829:1;14824:2024;;;;16931:1;16920:12;;14783:2164;;14824:2024;15168:7;15161:15;15151:2;;15220;15211:7;15208:15;15250:1;15245:355;;;;15914:1;16036:14;16031:3;16024:27;16102:4;16097:3;16087:20;16161:4;16149:10;16145:21;16211:7;16207:2;16203:16;16372:419;16404:1;16399:2;16393:3;16389:2;16386:11;16382:20;16379:27;16372:419;;;16592:2;16586:9;16581:2;16575:9;16572:24;16562:2;;16691:1;16680:12;;16732:1;16726:7;;16562:2;16452:1;16448:2;16444:10;16438:16;;16498:4;16494:2;16490:13;16484:19;;16372:419;;;15630:1184;;;;15201:1613;;15245:355;15379:5;15371;15364;15360:17;15356:29;15347:38;;15455:4;15443:10;15439:21;15433:28;15426:5;15423:39;15413:2;;15549:1;15538:12;;15413:2;15201:1613;15151:2;-1:-1:-1;16977:7:0;;13832:3160;-1:-1:-1;;;;;;13832:3160:0:o;11400:447::-;11465:12;11503:3;:10;11517:2;11503:16;11495:64;;;;-1:-1:-1;;;11495:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11821:4:0;11812:14;11806:21;;11579:259::o;56848:744::-;56953:4;-1:-1:-1;;;;;56974:66:0;;56970:593;;57262:44;;-1:-1:-1;;;;;57262:36:0;;;:44;;;;;57299:6;;57262:44;;;;57299:6;57262:36;:44;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57262:44:0;56970:593;;;57437:58;57464:11;57477:9;57488:6;57437:26;:58::i;:::-;57429:122;;;;-1:-1:-1;;;57429:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57580:4:0;56848:744;;;;;:::o;55936:906::-;56022:4;-1:-1:-1;;;;;56043:27:0;;56039:774;;56246:9;56238:60;;;;-1:-1:-1;;;56238:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56334:6;56321:9;:19;56313:73;;;;-1:-1:-1;;;56313:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56039:774;;;56504:9;:14;56496:61;;;;-1:-1:-1;;;56496:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56669:76;56694:13;56709:12;:10;:12::i;:::-;56731:4;56738:6;56669:24;:76::i;:::-;56661:140;;;;-1:-1:-1;;;56661:140:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56830:4:0;55936:906;;;;:::o;58367:359::-;58436:12;58461:17;58527:44;58554:4;:16;;;58527:26;:44::i;:::-;58586:42;58613:4;:14;;;58586:26;:42::i;:::-;58643:38;58669:4;:11;;;58643:25;:38::i;:::-;58496:200;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;58496:200:0;;;;;;;;;;-1:-1:-1;58496:200:0;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;58496:200:0;;;;;;;;;;-1:-1:-1;58496:200:0;;;36:153:-1;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;;;58496:200:0;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;58496:200:0;;;58489:207;;58714:4;58707:11;;;58367:359;;;:::o;3472:229::-;-1:-1:-1;;;;;3546:22:0;;3538:73;;;;-1:-1:-1;;;3538:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3648:6;;;3627:38;;-1:-1:-1;;;;;3627:38:0;;;;3648:6;;;3627:38;;;3676:6;:17;;-1:-1:-1;;;;;;3676:17:0;-1:-1:-1;;;;;3676:17:0;;;;;;;;;;3472:229::o;38103:2656::-;38182:12;38196:7;38216:8;38251:25;38263:4;38269:6;38251:11;:25::i;:::-;38311:11;;38235:41;;-1:-1:-1;38235:41:0;;-1:-1:-1;38295:12:0;;;:27;;;;:52;;;38344:3;38335:6;:12;38326:6;:21;38295:52;38287:101;;;;-1:-1:-1;;;38287:101:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38399:22;38462:11;;38487:1991;;;;40622:4;40616:11;40603:24;;40675:4;40664:9;40660:20;40654:4;40647:34;38455:2241;;38487:1991;38672:4;38666:11;38653:24;;39337:2;39332:3;39328:12;39725:9;39718:17;39712:4;39708:28;39696:9;39685;39681:25;39677:60;39774:3;39770:2;39766:12;40025:6;40011:9;40004:17;39998:4;39994:28;39982:9;39976:4;39972:20;39968:55;39964:68;39798:432;40059:3;40055:2;40052:11;39798:432;;;40201:9;;40190:21;;40101:4;40093:13;;;;40134;39798:432;;;-1:-1:-1;;40250:22:0;;;40458:2;40441:11;-1:-1:-1;;40437:25:0;40431:4;40424:39;-1:-1:-1;38455:2241:0;-1:-1:-1;40727:9:0;-1:-1:-1;40738:12:0;;;-1:-1:-1;38103:2656:0;;;;;;:::o;36758:975::-;36837:7;36846;36889:4;:11;36874:6;36883:2;36874:11;:26;;:50;;;;;36913:6;36922:2;36913:11;36904:6;:20;36874:50;36866:98;;;;-1:-1:-1;;;36866:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36975:9;37041:4;37035:11;37075:4;37130;37179;37170:7;37166:18;37243:6;37236:4;37230;37226:15;37222:28;37216:35;37093:386;37278:7;37270:6;37267:19;37093:386;;;37456:6;37448;37443:20;37434:6;37424:8;37420:21;37412:52;37328:4;37320:6;37316:17;37306:27;;37373:4;37365:6;37361:17;37351:27;;37093:386;;;-1:-1:-1;;;37506:22:0;;37500:4;37493:36;37548:15;;-1:-1:-1;;;;;;37592:71:0;;;37584:107;;;;;-1:-1:-1;;;37584:107:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;37710:1;37722:2;37713:11;;;;;-1:-1:-1;;;36758:975:0:o;58012:343::-;58122:4;58166:11;58283:42;-1:-1:-1;;;;;58283:23:0;;58307:9;58318:6;58283:42;:23;:42;:::i;:::-;-1:-1:-1;58343:4:0;;58012:343;-1:-1:-1;;;;58012:343:0:o;57604:400::-;57735:4;57779:13;57915:59;-1:-1:-1;;;;;57915:27:0;;57943:11;57956:9;57967:6;57915:59;:27;:59;:::i;:::-;-1:-1:-1;57992:4:0;;57604:400;-1:-1:-1;;;;;57604:400:0:o;49029:185::-;49137:11;;49094:12;;49184:15;49137:11;49184:12;:15::i;:::-;49201:4;49167:39;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;49167:39:0;;;;;;;;;;-1:-1:-1;49167:39:0;;;36:153:-1;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;;;49167:39:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;49167:39:0;;;49160:46;;;49029:185;;;:::o;48114:747::-;48170:12;-1:-1:-1;;;;;48203:1:0;:71;;48195:111;;;;;-1:-1:-1;;;48195:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48384:4;48378:11;48418:4;48436:21;;;48508:4;48544;48471:307;48575:7;48567:6;48564:19;48471:307;;;48760:1;48752:6;48747:15;48738:6;48731:4;48725;48721:15;48717:28;48709:54;48625:4;48613:17;;;;;-1:-1:-1;;48658:17:0;48471:307;;;-1:-1:-1;;;48815:4:0;48805:15;;;48792:29;;48805:15;48114:747;-1:-1:-1;;48114:747:0:o;42035:1186::-;42113:4;42119:7;42139:6;42170:22;42179:4;42185:6;42170:8;:22::i;:::-;42156:36;-1:-1:-1;42156:36:0;-1:-1:-1;42205:10:0;-1:-1:-1;;;;;;;;;42230:9:0;;;42226:988;;;42323:24;42334:4;42340:6;42323:10;:24::i;:::-;42305:42;-1:-1:-1;42305:42:0;;;-1:-1:-1;42379:4:0;42370:13;;;;;:32;;;42396:6;42387:5;:15;;42370:32;42362:76;;;;;-1:-1:-1;;;42362:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42461:5;-1:-1:-1;42468:6:0;;-1:-1:-1;42453:22:0;;-1:-1:-1;42453:22:0;42226:988;-1:-1:-1;;;;;;;;;42497:9:0;;;42493:721;;;42590:24;42601:4;42607:6;42590:10;:24::i;:::-;42572:42;-1:-1:-1;42572:42:0;;;-1:-1:-1;42645:6:0;42637:14;;:37;;;;;42664:10;42655:5;:19;;42637:37;42629:82;;;;;-1:-1:-1;;;42629:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42493:721;-1:-1:-1;;;;;;42770:9:0;;;;42766:448;;;42863:24;42874:4;42880:6;42863:10;:24::i;:::-;42845:42;-1:-1:-1;;;;;;42845:42:0;;-1:-1:-1;42918:10:0;42910:18;;42902:63;;;;;-1:-1:-1;;;42902:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42766:448;-1:-1:-1;43085:8:0;;;;43124:4;43116:12;;43108:57;;;;;-1:-1:-1;;;43108:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26209:176;26318:58;;;-1:-1:-1;;;;;26318:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;26318:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;26292:85:0;;26311:5;;26292:18;:85::i;:::-;26209:176;;;:::o;26393:204::-;26520:68;;;-1:-1:-1;;;;;26520:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;26520:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;26494:95:0;;26513:5;;26494:18;:95::i;:::-;26393:204;;;;:::o;49222:453::-;49277:12;49310:4;49306:1;-1:-1:-1;;;;;49306:8:0;;49302:366;;;49331:20;49348:1;49331:10;:20::i;:::-;49324:27;;;;49302:366;49375:6;49370:1;-1:-1:-1;;;;;49370:11:0;;49366:302;;49416:15;-1:-1:-1;;;49416:9:0;:15::i;:::-;49433:22;49452:1;49433:11;:22::i;:::-;49399:57;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;49399:57:0;;;;;;;;;;-1:-1:-1;49399:57:0;;;36:153:-1;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;;;49399:57:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;49399:57:0;;;49392:64;;;;49366:302;49480:10;49475:1;-1:-1:-1;;;;;49475:15:0;;49471:197;;49531:15;-1:-1:-1;;;49531:9:0;:15::i;:::-;49548:22;49567:1;49548:11;:22::i;49471:197::-;49619:15;-1:-1:-1;;;;;;49619:9:0;:15::i;:::-;49636:22;49655:1;49636:11;:22::i;31955:337::-;32031:4;32037:7;32079:4;:11;32065:6;32074:1;32065:10;:25;;:48;;;;;32103:6;32112:1;32103:10;32094:6;:19;32065:48;32057:93;;;;;-1:-1:-1;;;32057:93:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;32212:28:0;;;32226:4;32212:28;32206:35;32282:1;32273:10;;31955:337;;;;;:::o;33407:608::-;33485:6;33493:7;33535:4;:11;33521:6;33530:1;33521:10;:25;;:48;;;;;33559:6;33568:1;33559:10;33550:6;:19;33521:48;33513:95;;;;-1:-1:-1;;;33513:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33629:8;33694:4;33688:11;33754:6;33747:4;33741;33737:15;33733:28;33727:35;33805:6;33799:4;33794:18;33784:8;33776:37;33864:6;33861:1;33856:15;33849:4;33839:8;33835:19;33827:45;-1:-1:-1;33913:4:0;33899:19;;;33893:4;33886:33;-1:-1:-1;;33944:19:0;;;33938:26;;33996:10;;;-1:-1:-1;;;;33407:608:0:o;34315:875::-;34393:6;34401:7;34443:4;:11;34429:6;34438:1;34429:10;:25;;:48;;;;;34467:6;34476:1;34467:10;34458:6;:19;34429:48;34421:95;;;;-1:-1:-1;;;34421:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34527:8;34592:4;34586:11;34626:4;34681;34730;34721:7;34717:18;34794:6;34787:4;34781;34777:15;34773:28;34767:35;34644:386;34829:7;34821:6;34818:19;34644:386;;;35007:6;34999;34994:20;34985:6;34975:8;34971:21;34963:52;34879:4;34871:6;34867:17;34857:27;;34924:4;34916:6;34912:17;34902:27;;34644:386;;;-1:-1:-1;;;35057:22:0;;;35051:4;35044:36;35123:4;35119:18;35105:33;;35099:40;;35180:1;35171:10;;;;;-1:-1:-1;;;;34315:875:0:o;35489:::-;35567:6;35575:7;35617:4;:11;35603:6;35612:1;35603:10;:25;;:48;;;;;35641:6;35650:1;35641:10;35632:6;:19;35603:48;35595:95;;;;-1:-1:-1;;;35595:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35701:8;35766:4;35760:11;35800:4;35855;35904;35895:7;35891:18;35968:6;35961:4;35955;35951:15;35947:28;35941:35;35818:386;36003:7;35995:6;35992:19;35818:386;;;36181:6;36173;36168:20;36159:6;36149:8;36145:21;36137:52;36053:4;36045:6;36041:17;36031:27;;36098:4;36090:6;36086:17;36076:27;;35818:386;;;-1:-1:-1;;;36231:22:0;;;36225:4;36218:36;36297:4;36293:18;36279:33;;36273:40;;36354:1;36345:10;;;;;-1:-1:-1;;;;35489:875:0:o;28203:1119::-;28807:32;28832:5;28807:16;:32::i;:::-;28799:76;;;;;-1:-1:-1;;;28799:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;28949:12;28963:23;28998:5;-1:-1:-1;;;;;28990:19:0;29010:4;28990:25;;;;;;;;;;;;;36:153:-1;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;;;28990:25: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;;28948:67:0;;;;29034:7;29026:52;;;;;-1:-1:-1;;;29026:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29095:17;;:21;29091:224;;29237:10;29226:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29226:30:0;29218:85;;;;-1:-1:-1;;;29218:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45223:364;45365:4;45359:11;;45397:1;45384:15;;45441:3;45437:11;;;;45430:4;45420:15;;45413:36;45541:4;45531:15;;45518:29;;45359:11;45223:364::o;44953:110::-;45003:12;45035:20;45052:1;45046:8;;45035:10;:20::i;:::-;45028:27;44953:110;-1:-1:-1;;44953:110:0:o;45749:623::-;45895:4;45889:11;45929:4;45947:21;;;45803:12;;45889:11;46019:4;46055;45982:307;46086:7;46078:6;46075:19;45982:307;;;46271:1;46263:6;46258:15;46249:6;46242:4;46236;46232:15;46228:28;46220:54;46136:4;46124:17;;;;;-1:-1:-1;;46169:17:0;45982:307;;;-1:-1:-1;;;46326:4:0;46316:15;;46310:4;46303:29;46316:15;45749:623;-1:-1:-1;;45749:623:0:o;46538:620::-;46681:4;46675:11;46715:4;46733:21;;;46591:12;;46675:11;46805:4;46841;46768:307;46872:7;46864:6;46861:19;46768:307;;;47057:1;47049:6;47044:15;47035:6;47028:4;47022;47018:15;47014:28;47006:54;46922:4;46910:17;;;;;-1:-1:-1;;46955:17:0;46768:307;;;-1:-1:-1;;;47112:4:0;47102:15;;47096:4;47089:29;47102:15;46538:620;-1:-1:-1;;46538:620:0:o;47320:622::-;47465:4;47459:11;47499:4;47517:21;;;47373:12;;47459:11;47589:4;47625;47552:307;47656:7;47648:6;47645:19;47552:307;;;47841:1;47833:6;47828:15;47819:6;47812:4;47806;47802:15;47798:28;47790:54;47706:4;47694:17;;;;;-1:-1:-1;;47739:17:0;47552:307;;;-1:-1:-1;;;47896:4:0;47886:15;;47880:4;47873:29;47886:15;47320:622;-1:-1:-1;;47320:622:0:o;22049:810::-;22109:4;22768:20;;22611:66;22808:15;;;;;:42;;;22839:11;22827:8;:23;;22808:42;22800:51;22049:810;-1:-1:-1;;;;22049:810:0:o;49680:9456::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49680:9456:0;;;-1:-1:-1;49680:9456:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;

Swarm Source

bzzr://3a5c520047c3c747e2f886b2d9596534cae0a7441997c5ff4174b820ea948aa6
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.