Contract 0x28ff66a1b95d7cacf8eded2e658f768f44841212 3

/**
 *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;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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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

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;:::-;;;;;;;;;;;;;;;;;

bzzr://3a5c520047c3c747e2f886b2d9596534cae0a7441997c5ff4174b820ea948aa6