Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•  contract Context
•    - function _msgSender()
•    - function _msgData()
•  contract Ownable is Context
•    - function owner()
•    - function isOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• library ZeroCopySource
•    - function NextBool(bytes memory buff, ...
•    - function NextByte(bytes memory buff, ...
•    - function NextUint8(bytes memory buff, ...
•    - function NextUint16(bytes memory buff ...
•    - function NextUint32(bytes memory buff ...
•    - function NextUint64(bytes memory buff ...
•    - function NextUint255(bytes memory buf ...
•    - function NextVarBytes(bytes memory bu ...
•    - function NextHash(bytes memory buff, ...
•    - function NextBytes20(bytes memory buf ...
•    - function NextVarUint(bytes memory buf ...
• library ZeroCopySink
•    - function WriteBool(bool b)
•    - function WriteByte(byte b)
•    - function WriteUint8(uint8 v)
•    - function WriteUint16(uint16 v)
•    - function WriteUint32(uint32 v)
•    - function WriteUint64(uint64 v)
•    - function WriteUint255(uint256 v)
•    - function WriteVarBytes(bytes memory d ...
•    - function WriteVarUint(uint64 v)
• library Utils
•    - function bytesToBytes32(bytes memory ...
•    - function bytesToUint256(bytes memory ...
•    - function uint256ToBytes(uint256 _valu ...
•    - function bytesToAddress(bytes memory ...
•    - function addressToBytes(address _addr ...
•    - function hashLeaf(bytes memory _data)
•    - function hashChildren(bytes32 _l, byt ...
•    - function equalStorage(bytes storage _ ...
•    - function slice(
•    - function containMAddresses(address[] ...
•    - function compressMCPubKey(bytes memor ...
•    - function isContract(address account)
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function callOptionalReturn(IERC20 to ...
• interface IEthCrossChainManager
•    - function crossChain(uint64 _toChainId ...
• interface IEthCrossChainManagerProxy
•    - function getEthCrossChainManager()
• interface IBridgeAsset
•    - function mint(address to, uint256 amo ...
•    - function burnFrom(address account, ui ...
•  contract LockProxy is Ownable *
•    - function setManagerProxy(address ethC ...
•    - function bindProxyHash(uint64 toChain ...
•    - function bindAssetHash(address fromAs ...
•    - function lock(address fromAssetHash, ...
•    - function unlock(bytes memory argsBs, ...
•    - function getBalanceFor(address fromAs ...
•    - function _burn(address fromAssetHash, ...
•    - function _mint(address toAssetHash, a ...
•    - function _burnERC20(address fromAsset ...
•    - function _mintERC20(address toAssetHa ...
•    - function _serializeTxArgs(TxArgs memo ...
•    - function _deserializeTxArgs(bytes mem ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-04-03
*/

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

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

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

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

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];
                    _keepers[j] = 0x7777777777777777777777777777777777777777;
                }
            }
        }
        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);
    }
}

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

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

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

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

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

interface IBridgeAsset {

    function mint(address to, uint256 amount) external;
    
    function burnFrom(address account, uint256 amount) external;
}

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(_burn(fromAssetHash, amount), "burn asset from fromAddress 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(_mint(toAssetHash, toAddress, args.amount), "mint asset 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 _burn(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(_burnERC20(fromAssetHash, _msgSender(), address(this), amount), "burn erc20 asset from msgSender failed!");
        }
        return true;
    }
    function _mint(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 lock_proxy contract to toAddress
            require(_mintERC20(toAssetHash, toAddress, amount), "mint erc20 asset to toAddress failed!");
        }
        return true;
    }
    
    
    function _burnERC20(address fromAssetHash, address fromAddress, address toAddress, uint256 amount) internal returns (bool) {
         IBridgeAsset erc20Token = IBridgeAsset(fromAssetHash);
         erc20Token.burnFrom(fromAddress, amount);
         return true;
    }
    function _mintERC20(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) {
         IBridgeAsset erc20Token = IBridgeAsset(toAssetHash);
         erc20Token.mint(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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

49722:9053:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54432:931;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54432:931:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;54432:931:0;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;54432:931:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54432:931:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54432:931:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;54432:931:0;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;54432:931:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54432:931:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54432:931:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;54432:931:0;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;51316:314;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51316:314:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;51316:314:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;51316:314:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51316:314:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51316:314:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;51316:314:0;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;51061:243;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51061:243:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;51061:243:0;;;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;51061:243:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51061:243:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51061:243:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;51061:243:0;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;50024:64;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50024:64:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;50024:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;50024:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55375:510;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55375:510:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;55375:510:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2934:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2934:140:0;;;:::i;:::-;;52426:1310;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;52426:1310:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;8;5:28;2:2;;;46:1;43;36:12;2:2;52426:1310:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;52426:1310:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;52426:1310:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;52426:1310:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;2123:79;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2123:79:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;2489:94;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2489:94:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;49973:44;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49973:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;49973:44:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;49973:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50867:182;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50867:182:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;50867:182:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;49931:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49931:35:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;3229:110;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3229:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;3229:110:0;;;;;;;;;;;;;;;;;;;:::i;:::-;;54432:931;54556:4;50634:33;50697:20;;;;;;;;;;;50634:84;;50753:6;:30;;;:32;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50753:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50753:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;50753:32:0;;;;;;;;;;;;;;;;50737:48;;:12;:10;:12::i;:::-;:48;;;50729:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54573:18;;:::i;:::-;54594:26;54613:6;54594:18;:26::i;:::-;54573:47;;54668:1;54641:16;:23;:28;;54633:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54736:63;54755:12;:25;54768:11;54755:25;;;;;;;;;;;;;;;54782:16;54736:18;:63::i;:::-;54728:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54894:1;54867:4;:16;;;:23;:28;;54859:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54938:19;54960:38;54981:4;:16;;;54960:20;:38::i;:::-;54938:60;;55044:1;55019:4;:14;;;:21;:26;;55011:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55086:17;55106:36;55127:4;:14;;;55106:20;:36::i;:::-;55086:56;;55181:42;55187:11;55200:9;55211:4;:11;;;55181:5;:42::i;:::-;55173:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55285:48;55297:11;55310:9;55321:4;:11;;;55285:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55351:4;55344:11;;;;;54432:931;;;;;;:::o;51316:314::-;51432:4;2335:9;:7;:9::i;:::-;2327:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51490:11;51449:12;:27;51462:13;51449:27;;;;;;;;;;;;;;;:38;51477:9;51449:38;;;;;;;;;;;;;;;:52;;;;;;;;;;;;:::i;:::-;;51517:83;51532:13;51547:9;51558:11;51571:28;51585:13;51571;:28::i;:::-;51517:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;51517:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51618:4;51611:11;;51316:314;;;;;:::o;51061:243::-;51158:4;2335:9;:7;:9::i;:::-;2327:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51201:15;51175:12;:23;51188:9;51175:23;;;;;;;;;;;;;;;:41;;;;;;;;;;;;:::i;:::-;;51232:42;51247:9;51258:15;51232:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;51232:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51292:4;51285:11;;51061:243;;;;:::o;50024:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55375:510::-;55442:7;55491:1;55466:27;;:13;:27;;;55462:416;;;55665:16;55692:4;55665:32;;55719:8;:16;;;55712:23;;;;;55462:416;55768:17;55795:13;55768:41;;55831:10;:20;;;55860:4;55831:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55831:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;55831:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;55831:35:0;;;;;;;;;;;;;;;;55824:42;;;55375:510;;;;:::o;2934:140::-;2335:9;:7;:9::i;:::-;2327:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3033:1;2996:40;;3017:6;;;;;;;;;;;2996:40;;;;;;;;;;;;3064:1;3047:6;;:19;;;;;;;;;;;;;;;;;;2934:140::o;52426:1310::-;52545:4;52580:1;52570:6;:11;;52562:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52647:28;52653:13;52668:6;52647:5;:28::i;:::-;52639:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52736:24;52763:12;:27;52776:13;52763:27;;;;;;;;;;;;;;;:38;52791:9;52763:38;;;;;;;;;;;;;;;52736:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52842:1;52820:11;:18;:23;;52812:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;53109:83;;53203:16;53222:5;:29;;;: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;53222:31:0;;;;;;;;;;;;;;;;53203:50;;53264:26;53315:8;53264:60;;53345:24;53372:12;:23;53385:9;53372:23;;;;;;;;;;;;;;;53345:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53436:1;53414:11;:18;:23;;53406:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53486:4;:15;;;53502:9;53513:11;53536:6;53486:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;53486:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;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;53486:57:0;;;;;;;;;;;;;;;;53478:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53613:81;53623:13;53638:12;:10;:12::i;:::-;53652:9;53663:11;53676:9;53687:6;53613:81;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;53613:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;99:1;94:3;90:11;84:18;80:1;75:3;71:11;64:39;52:2;49:1;45:10;40:15;;8:100;;;12:14;53613:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53722:4;53715:11;;;;;;;;;52426:1310;;;;;;:::o;2123:79::-;2161:7;2188:6;;;;;;;;;;;2181:13;;2123:79;:::o;2489:94::-;2529:4;2569:6;;;;;;;;;;;2553:22;;:12;:10;:12::i;:::-;:22;;;2546:29;;2489:94;:::o;49973:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50867:182::-;2335:9;:7;:9::i;:::-;2327:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50968:15;50945:20;;:38;;;;;;;;;;;;;;;;;;50999:42;51020:20;;;;;;;;;;;50999:42;;;;;;;;;;;;;;;;;;;;;;50867:182;:::o;49931:35::-;;;;;;;;;;;;;:::o;3229:110::-;2335:9;:7;:9::i;:::-;2327:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3303:28;3322:8;3303:18;:28::i;:::-;3229:110;:::o;914:98::-;959:15;994:10;987:17;;914:98;:::o;58373:399::-;58446:13;;:::i;:::-;58472:18;;:::i;:::-;58501:11;58515:1;58501:15;;58553:41;58581:7;58590:3;58553:27;:41::i;:::-;58527:67;;;58528:4;:16;;58527:67;;;;;;;;58629:41;58657:7;58666:3;58629:27;:41::i;:::-;58605:65;;;58606:4;:14;;58605:65;;;;;;;;58702:40;58729:7;58738:3;58702:26;:40::i;:::-;58682:4;:11;;58681:61;;;;;;;;;58760:4;58753:11;;;;58373:399;;;:::o;27975:3160::-;28070:4;28087:12;28102:4;28087:19;;28208:14;28202:21;28798:1;28793;28787;28780:5;28776:13;28769:21;28762:5;28758:33;28754:41;28747:5;28743:53;28739:61;28835:10;28829:17;28945:7;28936;28933:20;28972:1;28967:2024;;;;31074:1;31063:12;;28926:2164;;28967:2024;29311:7;29304:15;29294:2;;29363;29354:7;29351:15;29393:1;29388:355;;;;30057:1;30179:14;30174:3;30167:27;30245:4;30240:3;30230:20;30304:4;30292:10;30288:21;30354:7;30350:2;30346:16;30515:419;30547:1;30542:2;30536:3;30532:2;30529:11;30525:20;30522:27;30515:419;;;30735:2;30729:9;30724:2;30718:9;30715:24;30705:2;;30834:1;30823:12;;30875:1;30869:7;;30705:2;30595:1;30591:2;30587:10;30581:16;;30641:4;30637:2;30633:13;30627:19;;30515:419;;;29773:1184;;;;29344:1613;;29388:355;29522:5;29514;29507;29503:17;29499:29;29490:38;;29598:4;29586:10;29582:21;29576:28;29569:5;29566:39;29556:2;;29692:1;29681:12;;29556:2;29344:1613;;29294:2;28926:2164;;28128:2973;;;31120:7;31113:14;;;27975:3160;;;;:::o;25543:447::-;25608:12;25660:2;25646:3;:10;:16;25638:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25964:4;25959:3;25955:14;25949:21;25941:29;;25722:259;;;:::o;56763:696::-;56852:4;56896:42;56873:66;;:11;:66;;;56869:561;;;57177:9;57161:36;;:44;57198:6;57161:44;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57161:44:0;56869:561;;;57334:42;57345:11;57358:9;57369:6;57334:10;:42::i;:::-;57326:92;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56869:561;57447:4;57440:11;;56763:696;;;;;:::o;55891:866::-;55963:4;56009:1;55984:27;;:13;:27;;;55980:748;;;56200:1;56187:9;:14;;56179:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56275:6;56262:9;:19;56254:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55980:748;;;56458:1;56445:9;:14;56437:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56610:62;56621:13;56636:12;:10;:12::i;:::-;56658:4;56665:6;56610:10;:62::i;:::-;56602:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55980:748;56745:4;56738:11;;55891:866;;;;:::o;58006:359::-;58075:12;58100:17;58166:44;58193:4;:16;;;58166:26;:44::i;:::-;58225:42;58252:4;:14;;;58225:26;:42::i;:::-;58282:38;58308:4;:11;;;58282:25;:38::i;:::-;58135:200;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;58135:200:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;58135:200:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;58135:200:0;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;58135:200:0;;;58128:207;;58353:4;58346:11;;;58006:359;;;:::o;3445:229::-;3539:1;3519:22;;:8;:22;;;;3511:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3629:8;3600:38;;3621:6;;;;;;;;;;;3600:38;;;;;;;;;;;;3658:8;3649:6;;:17;;;;;;;;;;;;;;;;;;3445:229;:::o;11779:2656::-;11858:12;11872:7;11892:8;11927:25;11939:4;11945:6;11927:11;:25::i;:::-;11911:41;;;;;;;;11987:4;:11;11980:3;11971:6;:12;:27;;:52;;;;;12020:3;12011:6;:12;12002:6;:21;11971:52;11963:101;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12075:22;12145:3;12138:11;12168:1;12163:1991;;;;14298:4;14292:11;14279:24;;14351:4;14340:9;14336:20;14330:4;14323:34;12131:2241;;12163:1991;12348:4;12342:11;12329:24;;13013:2;13008:3;13004:12;13401:9;13394:17;13388:4;13384:28;13372:9;13361;13357:25;13353:60;13450:3;13446:2;13442:12;13701:6;13687:9;13680:17;13674:4;13670:28;13658:9;13652:4;13648:20;13644:55;13640:68;13474:432;13735:3;13731:2;13728:11;13474:432;;;13883:2;13877:9;13873:2;13866:21;13777:4;13773:2;13769:13;13763:19;;13818:4;13814:2;13810:13;13804:19;;13474:432;;;13478:249;13944:3;13933:9;13926:22;14134:2;14130:7;14125:2;14121;14117:11;14113:25;14107:4;14100:39;12170:1984;;;12131:2241;;14403:9;14423:3;14414:6;:12;14395:32;;;;;;11779:2656;;;;;:::o;10434:975::-;10513:7;10522;10565:4;:11;10559:2;10550:6;:11;:26;;:50;;;;;10598:2;10589:6;:11;10580:6;:20;10550:50;10542:98;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10651:9;10717:4;10711:11;10751:4;10806;10855;10846:7;10842:18;10919:6;10912:4;10906;10902:15;10898:28;10892:35;10769:386;10954:7;10946:6;10943:19;10769:386;;;11132:6;11124;11119:20;11110:6;11100:8;11096:21;11088:52;11004:4;10996:6;10992:17;10982:27;;11049:4;11041:6;11037:17;11027:27;;10769:386;;;10773:169;;;11196:7;11186:8;11182:22;11176:4;11169:36;11230:8;11224:15;11219:20;;10680:570;;11273:66;11268:1;:71;;11260:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11386:1;11398:2;11389:6;:11;11378:23;;;;;10434:975;;;;;:::o;57754:240::-;57848:4;57866:23;57905:11;57866:51;;57929:10;:15;;;57945:9;57956:6;57929:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;57929:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57929:34:0;;;;57982:4;57975:11;;;57754:240;;;;;:::o;57477:271::-;57594:4;57612:23;57651:13;57612:53;;57677:10;:19;;;57697:11;57710:6;57677:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;57677:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57677:40:0;;;;57736:4;57729:11;;;57477:271;;;;;;:::o;22680:185::-;22745:12;22770:8;22788:4;:11;22770:30;;22835:15;22848:1;22835:12;:15::i;:::-;22852:4;22818:39;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;22818:39:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;22818:39:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;22818:39:0;;;22811:46;;;22680:185;;;:::o;21765:747::-;21821:12;21859:66;21854:1;:71;;21846:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21968:17;22035:4;22029:11;22021:19;;22069:4;22100:7;22094:4;22087:21;22159:4;22195;22122:307;22226:7;22218:6;22215:19;22122:307;;;22411:1;22403:6;22398:15;22389:6;22382:4;22376;22372:15;22368:28;22360:54;22276:4;22268:6;22264:17;22254:27;;22321:4;22313:6;22309:17;22299:27;;22122:307;;;22126:88;;22466:4;22460;22456:15;22450:4;22443:29;22006:477;22500:4;22493:11;;;21765:747;;;:::o;15711:1186::-;15789:4;15795:7;15815:6;15846:22;15855:4;15861:6;15846:8;:22::i;:::-;15832:36;;;;;;;;15881:10;15911:4;15906:9;;:1;:9;;;;15902:988;;;15999:24;16010:4;16016:6;15999:10;:24::i;:::-;15981:42;;;;;;;;;;;;;16055:4;16046:5;:13;;:32;;;;;16072:6;16063:5;:15;;16046:32;16038:76;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16137:5;16144:6;16129:22;;;;;;;;15902:988;16178:4;16173:9;;:1;:9;;;;16169:721;;;16266:24;16277:4;16283:6;16266:10;:24::i;:::-;16248:42;;;;;;;;;;;;;16321:6;16313:5;:14;:37;;;;;16340:10;16331:5;:19;;16313:37;16305:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16410:5;16417:6;16402:22;;;;;;;;16169:721;16451:4;16446:9;;:1;:9;;;;16442:448;;;16539:24;16550:4;16556:6;16539:10;:24::i;:::-;16521:42;;;;;;;;;;;;;16594:10;16586:5;:18;16578:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16664:5;16671:6;16656:22;;;;;;;;16442:448;16767:1;16761:8;;16753:16;;;;16800:4;16792:5;:12;16784:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16864:5;16871:6;16856:22;;;;;;15711:1186;;;;;;:::o;22873:453::-;22928:12;22961:4;22957:1;:8;;;22953:366;;;22982:20;22999:1;22982:10;:20::i;:::-;22975:27;;;;22953:366;23026:6;23021:1;:11;;;23017:302;;23067:15;23077:4;23067:15;;:9;:15::i;:::-;23084:22;23103:1;23084:11;:22::i;:::-;23050:57;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23050:57:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23050:57:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;23050:57:0;;;23043:64;;;;23017:302;23131:10;23126:1;:15;;;23122:197;;23182:15;23192:4;23182:15;;:9;:15::i;:::-;23199:22;23218:1;23199:11;:22::i;:::-;23165:57;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23165:57:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23165:57:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;23165:57:0;;;23158:64;;;;23122:197;23270:15;23280:4;23270:15;;:9;:15::i;:::-;23287:22;23306:1;23287:11;:22::i;:::-;23253:57;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23253:57:0;;;;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;182:3;176:10;171:3;164:23;98:2;93:3;89:12;82:19;;123:2;118:3;114:12;107:19;;148:2;143:3;139:12;132:19;;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;;;23253:57:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;23253:57:0;;;23246:64;;22873:453;;;;:::o;5633:337::-;5709:4;5715:7;5757:4;:11;5752:1;5743:6;:10;:25;;:48;;;;;5790:1;5781:6;:10;5772:6;:19;5743:48;5735:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5839:6;5911;5904:4;5898;5894:15;5890:28;5884:35;5879:40;;5948:1;5960;5951:6;:10;5940:22;;;;;5633:337;;;;;:::o;7085:608::-;7163:6;7171:7;7213:4;:11;7208:1;7199:6;:10;:25;;:48;;;;;7246:1;7237:6;:10;7228:6;:19;7199:48;7191:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7307:8;7372:4;7366:11;7432:6;7425:4;7419;7415:15;7411:28;7405:35;7483:6;7477:4;7472:18;7462:8;7454:37;7542:6;7539:1;7534:15;7527:4;7517:8;7513:19;7505:45;7591:4;7581:8;7577:19;7571:4;7564:33;7636:4;7626:8;7622:19;7616:26;7611:31;;7335:318;;7671:1;7683;7674:6;:10;7663:22;;;;;7085:608;;;;;:::o;7991:875::-;8069:6;8077:7;8119:4;:11;8114:1;8105:6;:10;:25;;:48;;;;;8152:1;8143:6;:10;8134:6;:19;8105:48;8097:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8203:8;8268:4;8262:11;8302:4;8357;8406;8397:7;8393:18;8470:6;8463:4;8457;8453:15;8449:28;8443:35;8320:386;8505:7;8497:6;8494:19;8320:386;;;8683:6;8675;8670:20;8661:6;8651:8;8647:21;8639:52;8555:4;8547:6;8543:17;8533:27;;8600:4;8592:6;8588:17;8578:27;;8320:386;;;8324:169;;;8747:7;8737:8;8733:22;8727:4;8720:36;8805:7;8799:4;8795:18;8785:8;8781:33;8775:40;8770:45;;8231:595;;8844:1;8856;8847:6;:10;8836:22;;;;;7991:875;;;;;:::o;9165:::-;9243:6;9251:7;9293:4;:11;9288:1;9279:6;:10;:25;;:48;;;;;9326:1;9317:6;:10;9308:6;:19;9279:48;9271:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9377:8;9442:4;9436:11;9476:4;9531;9580;9571:7;9567:18;9644:6;9637:4;9631;9627:15;9623:28;9617:35;9494:386;9679:7;9671:6;9668:19;9494:386;;;9857:6;9849;9844:20;9835:6;9825:8;9821:21;9813:52;9729:4;9721:6;9717:17;9707:27;;9774:4;9766:6;9762:17;9752:27;;9494:386;;;9498:169;;;9921:7;9911:8;9907:22;9901:4;9894:36;9979:7;9973:4;9969:18;9959:8;9955:33;9949:40;9944:45;;9405:595;;10018:1;10030;10021:6;:10;10010:22;;;;;9165:875;;;;;:::o;18874:364::-;18926:12;18951:17;19016:4;19010:11;19002:19;;19048:1;19042:4;19035:15;19097:1;19092:3;19088:11;19081:4;19075;19071:15;19064:36;19192:4;19186;19182:15;19176:4;19169:29;19226:4;19219:11;;;18874:364;;;:::o;18604:110::-;18654:12;18686:20;18703:1;18697:8;;18686:10;:20::i;:::-;18679:27;;18604:110;;;:::o;19400:623::-;19454:12;19479:17;19546:4;19540:11;19532:19;;19580:4;19611:7;19605:4;19598:21;19670:4;19706;19633:307;19737:7;19729:6;19726:19;19633:307;;;19922:1;19914:6;19909:15;19900:6;19893:4;19887;19883:15;19879:28;19871:54;19787:4;19779:6;19775:17;19765:27;;19832:4;19824:6;19820:17;19810:27;;19633:307;;;19637:88;;19977:4;19971;19967:15;19961:4;19954:29;19517:477;20011:4;20004:11;;;19400:623;;;:::o;20189:620::-;20242:12;20267:17;20332:4;20326:11;20318:19;;20366:4;20397:7;20391:4;20384:21;20456:4;20492;20419:307;20523:7;20515:6;20512:19;20419:307;;;20708:1;20700:6;20695:15;20686:6;20679:4;20673;20669:15;20665:28;20657:54;20573:4;20565:6;20561:17;20551:27;;20618:4;20610:6;20606:17;20596:27;;20419:307;;;20423:88;;20763:4;20757;20753:15;20747:4;20740:29;20303:477;20797:4;20790:11;;;20189:620;;;:::o;20971:622::-;21024:12;21049:17;21116:4;21110:11;21102:19;;21150:4;21181:7;21175:4;21168:21;21240:4;21276;21203:307;21307:7;21299:6;21296:19;21203:307;;;21492:1;21484:6;21479:15;21470:6;21463:4;21457;21453:15;21449:28;21441:54;21357:4;21349:6;21345:17;21335:27;;21402:4;21394:6;21390:17;21380:27;;21203:307;;;21207:88;;21547:4;21541;21537:15;21531:4;21524:29;21087:477;21581:4;21574:11;;;20971:622;;;:::o;49722:9053::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o

bzzr://69504ca58a541d3c5b046cc13edc975fb9026bfd983c8c94e97b436e4b6fad3d