Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.12;

import "./multiOwnable.sol";
import "./munchTokenETH.sol";

contract ethBridge is Multiownable {
    MUNCH private token;

    mapping(address => uint256) public tokensSent;
    mapping(address => uint256) public tokensRecieved;
    mapping(address => uint256) public tokensRecievedButNotSent;
 
    constructor (address payable _token) public {
        token = MUNCH(_token);
    }
 
    uint256 amountToSent;
    bool transferStatus;
    
    bool avoidReentrancy = false;
 
    function sendTokens(uint256 amount) public {
        require(msg.sender != address(0), "Zero account");
        require(amount > 0,"Amount of tokens should be more than 0");
        require(token.balanceOf(msg.sender) >= amount,"Not enough balance");
        
        transferStatus = token.transferFrom(msg.sender, address(this), amount);
        if (transferStatus == true) {
            tokensRecieved[msg.sender] += amount;
        }
    }
 
    function writeTransaction(address user, uint256 amount) public onlyAllOwners {
        require(user != address(0), "Zero account");
        require(amount > 0,"Amount of tokens should be more than 0");
        require(!avoidReentrancy);
        
        avoidReentrancy = true;
        tokensRecievedButNotSent[user] += amount;
        avoidReentrancy = false;
    }

    function recieveTokens(uint256[] memory commissions) public payable {
        if (tokensRecievedButNotSent[msg.sender] != 0) {
            require(commissions.length == owners.length, "The number of commissions and owners does not match");
            uint256 sum;
            for(uint i = 0; i < commissions.length; i++) {
                sum += commissions[i];
            }
            require(msg.value >= sum, "Not enough ETH (The amount of ETH is less than the amount of commissions.)");
            require(msg.value >= owners.length * 150000 * 10**9, "Not enough ETH (The amount of ETH is less than the internal commission.)");
        
            for (uint i = 0; i < owners.length; i++) {
                address payable owner = payable(owners[i]);
                uint256 commission = commissions[i];
                owner.transfer(commission);
            }
            
            amountToSent = tokensRecievedButNotSent[msg.sender] - tokensSent[msg.sender];
            token.transfer(msg.sender, amountToSent);
            tokensSent[msg.sender] += amountToSent;
        }
    }
 
    function withdrawTokens(uint256 amount, address reciever) public onlyAllOwners {
        require(amount > 0,"Amount of tokens should be more than 0");
        require(reciever != address(0), "Zero account");
        require(token.balanceOf(address(this)) >= amount,"Not enough balance");
        
        token.transfer(reciever, amount);
    }
    
    function withdrawEther(uint256 amount, address payable reciever) public onlyAllOwners {
        require(amount > 0,"Amount of tokens should be more than 0");
        require(reciever != address(0), "Zero account");
        require(address(this).balance >= amount,"Not enough balance");

        reciever.transfer(amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

contract Multiownable {

    // VARIABLES

    uint256 public ownersGeneration;
    uint256 public howManyOwnersDecide;
    address[] public owners;
    bytes32[] public allOperations;
    address internal insideCallSender;
    uint256 internal insideCallCount;

    // Reverse lookup tables for owners and allOperations
    mapping(address => uint) public ownersIndices; // Starts from 1
    mapping(bytes32 => uint) public allOperationsIndicies;

    // Owners voting mask per operations
    mapping(bytes32 => uint256) public votesMaskByOperation;
    mapping(bytes32 => uint256) public votesCountByOperation;

    // EVENTS

    event OwnershipTransferred(address[] previousOwners, uint howManyOwnersDecide, address[] newOwners, uint newHowManyOwnersDecide);
    event OperationCreated(bytes32 operation, uint howMany, uint ownersCount, address proposer);
    event OperationUpvoted(bytes32 operation, uint votes, uint howMany, uint ownersCount, address upvoter);
    event OperationPerformed(bytes32 operation, uint howMany, uint ownersCount, address performer);
    event OperationDownvoted(bytes32 operation, uint votes, uint ownersCount,  address downvoter);
    event OperationCancelled(bytes32 operation, address lastCanceller);
    
    // ACCESSORS

    function isOwner(address wallet) public view returns(bool) {
        return ownersIndices[wallet] > 0;
    }

    function ownersCount() public view returns(uint) {
        return owners.length;
    }

    function allOperationsCount() public view returns(uint) {
        return allOperations.length;
    }

    // MODIFIERS

    /**
    * @dev Allows to perform method by any of the owners
    */
    modifier onlyAnyOwner {
        if (checkHowManyOwners(1)) {
            bool update = (insideCallSender == address(0));
            if (update) {
                insideCallSender = msg.sender;
                insideCallCount = 1;
            }
            _;
            if (update) {
                insideCallSender = address(0);
                insideCallCount = 0;
            }
        }
    }

    /**
    * @dev Allows to perform method only after many owners call it with the same arguments
    */
    modifier onlyManyOwners {
        if (checkHowManyOwners(howManyOwnersDecide)) {
            bool update = (insideCallSender == address(0));
            if (update) {
                insideCallSender = msg.sender;
                insideCallCount = howManyOwnersDecide;
            }
            _;
            if (update) {
                insideCallSender = address(0);
                insideCallCount = 0;
            }
        }
    }

    /**
    * @dev Allows to perform method only after all owners call it with the same arguments
    */
    modifier onlyAllOwners {
        if (checkHowManyOwners(owners.length)) {
            bool update = (insideCallSender == address(0));
            if (update) {
                insideCallSender = msg.sender;
                insideCallCount = owners.length;
            }
            _;
            if (update) {
                insideCallSender = address(0);
                insideCallCount = 0;
            }
        }
    }

    /**
    * @dev Allows to perform method only after some owners call it with the same arguments
    */
    modifier onlySomeOwners(uint howMany) {
        require(howMany > 0, "onlySomeOwners: howMany argument is zero");
        require(howMany <= owners.length, "onlySomeOwners: howMany argument exceeds the number of owners");
        
        if (checkHowManyOwners(howMany)) {
            bool update = (insideCallSender == address(0));
            if (update) {
                insideCallSender = msg.sender;
                insideCallCount = howMany;
            }
            _;
            if (update) {
                insideCallSender = address(0);
                insideCallCount = 0;
            }
        }
    }

    // CONSTRUCTOR

    constructor() public {
        owners.push(msg.sender);
        ownersIndices[msg.sender] = 1;
        howManyOwnersDecide = 1;
    }

    // INTERNAL METHODS

    /**
     * @dev onlyManyOwners modifier helper
     */
    function checkHowManyOwners(uint howMany) internal returns(bool) {
        if (insideCallSender == msg.sender) {
            require(howMany <= insideCallCount, "checkHowManyOwners: nested owners modifier check require more owners");
            return true;
        }

        uint ownerIndex = ownersIndices[msg.sender] - 1;
        require(ownerIndex < owners.length, "checkHowManyOwners: msg.sender is not an owner");
        bytes32 operation = keccak256(abi.encodePacked(msg.data, ownersGeneration));

        require((votesMaskByOperation[operation] & (2 ** ownerIndex)) == 0, "checkHowManyOwners: owner already voted for the operation");
        votesMaskByOperation[operation] |= (2 ** ownerIndex);
        uint operationVotesCount = votesCountByOperation[operation] + 1;
        votesCountByOperation[operation] = operationVotesCount;
        if (operationVotesCount == 1) {
            allOperationsIndicies[operation] = allOperations.length;
            allOperations.push(operation);
            emit OperationCreated(operation, howMany, owners.length, msg.sender);
        }
        emit OperationUpvoted(operation, operationVotesCount, howMany, owners.length, msg.sender);

        // If enough owners confirmed the same operation
        if (votesCountByOperation[operation] == howMany) {
            deleteOperation(operation);
            emit OperationPerformed(operation, howMany, owners.length, msg.sender);
            return true;
        }

        return false;
    }

    /**
    * @dev Used to delete cancelled or performed operation
    * @param operation defines which operation to delete
    */
    function deleteOperation(bytes32 operation) internal {
        uint index = allOperationsIndicies[operation];
        if (index < allOperations.length - 1) { // Not last
            allOperations[index] = allOperations[allOperations.length - 1];
            allOperationsIndicies[allOperations[index]] = index;
        }
        //allOperations.length-1
        allOperations.push(allOperations[allOperations.length-1]);

        delete votesMaskByOperation[operation];
        delete votesCountByOperation[operation];
        delete allOperationsIndicies[operation];
    }

    // PUBLIC METHODS

    /**
    * @dev Allows owners to change their mind by cacnelling votesMaskByOperation operations
    * @param operation defines which operation to delete
    */
    function cancelPending(bytes32 operation) public onlyAnyOwner {
        uint ownerIndex = ownersIndices[msg.sender] - 1;
        require((votesMaskByOperation[operation] & (2 ** ownerIndex)) != 0, "cancelPending: operation not found for this user");
        votesMaskByOperation[operation] &= ~(2 ** ownerIndex);
        uint operationVotesCount = votesCountByOperation[operation] - 1;
        votesCountByOperation[operation] = operationVotesCount;
        emit OperationDownvoted(operation, operationVotesCount, owners.length, msg.sender);
        if (operationVotesCount == 0) {
            deleteOperation(operation);
            emit OperationCancelled(operation, msg.sender);
        }
    }

    /**
    * @dev Allows owners to change ownership
    * @param newOwners defines array of addresses of new owners
    */
    function transferOwnership(address[] memory newOwners) public {
        transferOwnershipWithHowMany(newOwners, newOwners.length);
    }

    /**
    * @dev Allows owners to change ownership
    * @param newOwners defines array of addresses of new owners
    * @param newHowManyOwnersDecide defines how many owners can decide
    */
    function transferOwnershipWithHowMany(address[] memory newOwners, uint256 newHowManyOwnersDecide) public onlyManyOwners {
        require(newOwners.length > 0, "transferOwnershipWithHowMany: owners array is empty");
        require(newOwners.length <= 256, "transferOwnershipWithHowMany: owners count is greater then 256");
        require(newHowManyOwnersDecide > 0, "transferOwnershipWithHowMany: newHowManyOwnersDecide equal to 0");
        require(newHowManyOwnersDecide <= newOwners.length, "transferOwnershipWithHowMany: newHowManyOwnersDecide exceeds the number of owners");

        // Reset owners reverse lookup table
        for (uint j = 0; j < owners.length; j++) {
            delete ownersIndices[owners[j]];
        }
        for (uint i = 0; i < newOwners.length; i++) {
            require(newOwners[i] != address(0), "transferOwnershipWithHowMany: owners array contains zero");
            require(ownersIndices[newOwners[i]] == 0, "transferOwnershipWithHowMany: owners array contains duplicates");
            ownersIndices[newOwners[i]] = i + 1;
        }
        
        emit OwnershipTransferred(owners, howManyOwnersDecide, newOwners, newHowManyOwnersDecide);
        owners = newOwners;
        howManyOwnersDecide = newHowManyOwnersDecide;
        // allOperations.length = 0;
        allOperations.push(allOperations[0]);
        ownersGeneration++;
    }

}

/**
 *Submitted for verification at Etherscan.io on 2021-04-12
*/

// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.6.12;

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

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

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

    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.
        */
        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.
        */
        function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
            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.
        */
        function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
            require(b != 0, errorMessage);
            return a % b;
        }
    }

    library Address {
        /**
        * @dev Returns true if `account` is 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.
        *
        * Among others, `isContract` will return false for the following
        * types of addresses:
        *
        *  - an externally-owned account
        *  - a contract in construction
        *  - an address where a contract will be created
        *  - an address where a contract lived, but was destroyed
        * ====
        */
        function isContract(address account) internal view returns (bool) {
            // 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 != accountHash && codehash != 0x0);
        }

        /**
        * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
        * `recipient`, forwarding all available gas and reverting on errors.
        *
        * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
        * of certain opcodes, possibly making contracts go over the 2300 gas limit
        * imposed by `transfer`, making them unable to receive funds via
        * `transfer`. {sendValue} removes this limitation.
        *
        * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
        *
        * IMPORTANT: because control is transferred to `recipient`, care must be
        * taken to not create reentrancy vulnerabilities. Consider using
        * {ReentrancyGuard} or the
        * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
        */
        function sendValue(address payable recipient, uint256 amount) internal {
            require(address(this).balance >= amount, "Address: insufficient balance");

            // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
            (bool success, ) = recipient.call{ value: amount }("");
            require(success, "Address: unable to send value, recipient may have reverted");
        }

        /**
        * @dev Performs a Solidity function call using a low level `call`. A
        * plain`call` is an unsafe replacement for a function call: use this
        * function instead.
        *
        * If `target` reverts with a revert reason, it is bubbled up by this
        * function (like regular Solidity function calls).
        *
        * Returns the raw returned data. To convert to the expected return value,
        * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
        *
        * Requirements:
        *
        * - `target` must be a contract.
        * - calling `target` with `data` must not revert.
        *
        * _Available since v3.1._
        */
        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
        }

        /**
        * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
        * `errorMessage` as a fallback revert reason when `target` reverts.
        *
        * _Available since v3.1._
        */
        function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
            return _functionCallWithValue(target, data, 0, errorMessage);
        }

        /**
        * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
        * but also transferring `value` wei to `target`.
        *
        * Requirements:
        *
        * - the calling contract must have an ETH balance of at least `value`.
        * - the called Solidity function must be `payable`.
        *
        * _Available since v3.1._
        */
        function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
        }

        /**
        * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
        * with `errorMessage` as a fallback revert reason when `target` reverts.
        *
        * _Available since v3.1._
        */
        function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
            require(address(this).balance >= value, "Address: insufficient balance for call");
            return _functionCallWithValue(target, data, value, errorMessage);
        }

        function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
            require(isContract(target), "Address: call to non-contract");

            // solhint-disable-next-line avoid-low-level-calls
            (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
            if (success) {
                return returndata;
            } else {
                // Look for revert reason and bubble it up if present
                if (returndata.length > 0) {
                    // The easiest way to bubble the revert reason is using memory via assembly

                    // solhint-disable-next-line no-inline-assembly
                    assembly {
                        let returndata_size := mload(returndata)
                        revert(add(32, returndata), returndata_size)
                    }
                } else {
                    revert(errorMessage);
                }
            }
        }
    }

    contract Ownable is Context {
        address private _owner;
        address private _previousOwner;
        uint256 private _lockTime;

        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(_owner == _msgSender(), "Ownable: caller is not the 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 virtual 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 virtual onlyOwner {
            require(newOwner != address(0), "Ownable: new owner is the zero address");
            emit OwnershipTransferred(_owner, newOwner);
            _owner = newOwner;
        }

        function geUnlockTime() public view returns (uint256) {
            return _lockTime;
        }

        //Locks the contract for owner for the amount of time provided
        function lock(uint256 time) public virtual onlyOwner {
            _previousOwner = _owner;
            _owner = address(0);
            _lockTime = now + time;
            emit OwnershipTransferred(_owner, address(0));
        }
        
        //Unlocks the contract for owner when _lockTime is exceeds
        function unlock() public virtual {
            require(_previousOwner == msg.sender, "You don't have permission to unlock");
            require(now > _lockTime , "Contract is locked until 7 days");
            emit OwnershipTransferred(_owner, _previousOwner);
            _owner = _previousOwner;
        }
    }  

    interface IUniswapV2Factory {
        event PairCreated(address indexed token0, address indexed token1, address pair, uint);

        function feeTo() external view returns (address);
        function feeToSetter() external view returns (address);

        function getPair(address tokenA, address tokenB) external view returns (address pair);
        function allPairs(uint) external view returns (address pair);
        function allPairsLength() external view returns (uint);

        function createPair(address tokenA, address tokenB) external returns (address pair);

        function setFeeTo(address) external;
        function setFeeToSetter(address) external;
    } 

    interface IUniswapV2Pair {
        event Approval(address indexed owner, address indexed spender, uint value);
        event Transfer(address indexed from, address indexed to, uint value);

        function name() external pure returns (string memory);
        function symbol() external pure returns (string memory);
        function decimals() external pure returns (uint8);
        function totalSupply() external view returns (uint);
        function balanceOf(address owner) external view returns (uint);
        function allowance(address owner, address spender) external view returns (uint);

        function approve(address spender, uint value) external returns (bool);
        function transfer(address to, uint value) external returns (bool);
        function transferFrom(address from, address to, uint value) external returns (bool);

        function DOMAIN_SEPARATOR() external view returns (bytes32);
        function PERMIT_TYPEHASH() external pure returns (bytes32);
        function nonces(address owner) external view returns (uint);

        function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

        event Mint(address indexed sender, uint amount0, uint amount1);
        event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
        event Swap(
            address indexed sender,
            uint amount0In,
            uint amount1In,
            uint amount0Out,
            uint amount1Out,
            address indexed to
        );
        event Sync(uint112 reserve0, uint112 reserve1);

        function MINIMUM_LIQUIDITY() external pure returns (uint);
        function factory() external view returns (address);
        function token0() external view returns (address);
        function token1() external view returns (address);
        function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
        function price0CumulativeLast() external view returns (uint);
        function price1CumulativeLast() external view returns (uint);
        function kLast() external view returns (uint);

        function mint(address to) external returns (uint liquidity);
        function burn(address to) external returns (uint amount0, uint amount1);
        function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
        function skim(address to) external;
        function sync() external;

        function initialize(address, address) external;
    }

    interface IUniswapV2Router01 {
        function factory() external pure returns (address);
        function WETH() external pure returns (address);

        function addLiquidity(
            address tokenA,
            address tokenB,
            uint amountADesired,
            uint amountBDesired,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline
        ) external returns (uint amountA, uint amountB, uint liquidity);
        function addLiquidityETH(
            address token,
            uint amountTokenDesired,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
        function removeLiquidity(
            address tokenA,
            address tokenB,
            uint liquidity,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline
        ) external returns (uint amountA, uint amountB);
        function removeLiquidityETH(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external returns (uint amountToken, uint amountETH);
        function removeLiquidityWithPermit(
            address tokenA,
            address tokenB,
            uint liquidity,
            uint amountAMin,
            uint amountBMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountA, uint amountB);
        function removeLiquidityETHWithPermit(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountToken, uint amountETH);
        function swapExactTokensForTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external returns (uint[] memory amounts);
        function swapTokensForExactTokens(
            uint amountOut,
            uint amountInMax,
            address[] calldata path,
            address to,
            uint deadline
        ) external returns (uint[] memory amounts);
        function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
            external
            payable
            returns (uint[] memory amounts);
        function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
            external
            returns (uint[] memory amounts);
        function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
            external
            returns (uint[] memory amounts);
        function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
            external
            payable
            returns (uint[] memory amounts);

        function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
        function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
        function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
        function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
        function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
    }

    interface IUniswapV2Router02 is IUniswapV2Router01 {
        function removeLiquidityETHSupportingFeeOnTransferTokens(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline
        ) external returns (uint amountETH);
        function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
            address token,
            uint liquidity,
            uint amountTokenMin,
            uint amountETHMin,
            address to,
            uint deadline,
            bool approveMax, uint8 v, bytes32 r, bytes32 s
        ) external returns (uint amountETH);

        function swapExactTokensForTokensSupportingFeeOnTransferTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external;
        function swapExactETHForTokensSupportingFeeOnTransferTokens(
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external payable;
        function swapExactTokensForETHSupportingFeeOnTransferTokens(
            uint amountIn,
            uint amountOutMin,
            address[] calldata path,
            address to,
            uint deadline
        ) external;
    }

    // Contract implementarion
    contract MUNCH is Context, IERC20, Ownable {
        using SafeMath for uint256;
        using Address for address;

        mapping (address => uint256) private _rOwned;
        mapping (address => uint256) private _tOwned;
        mapping (address => mapping (address => uint256)) private _allowances;

        mapping (address => bool) private _isExcludedFromFee;

        mapping (address => bool) private _isExcluded;
        address[] private _excluded;
    
        uint256 private constant MAX = ~uint256(0);
        uint256 private _tTotal = 100000000 * 10**6 * 10**9;
        uint256 private _rTotal = (MAX - (MAX % _tTotal));
        uint256 private _tFeeTotal;

        string private _name = 'MUNCH Token';
        string private _symbol = 'MUNCH';
        uint8 private _decimals = 9;
        
        // Tax and charity fees will start at 0 so we don't have a big impact when deploying to Uniswap
        // Charity wallet address is null but the method to set the address is exposed
        uint256 private _taxFee = 5; 
        uint256 private _charityFee = 5;
        uint256 private _previousTaxFee = _taxFee;
        uint256 private _previousCharityFee = _charityFee;

        address payable public _charityWalletAddress;

        IUniswapV2Router02 public immutable uniswapV2Router;
        address public immutable uniswapV2Pair;

        bool inSwap = false;
        bool public swapEnabled = true;

        uint256 private _maxTxAmount = 100000000000000e9;
        // We will set a minimum amount of tokens to be swaped => 5M
        uint256 private _numOfTokensToExchangeForCharity = 5 * 10**6 * 10**9;

        event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap);
        event SwapEnabledUpdated(bool enabled);

        modifier lockTheSwap {
            inSwap = true;
            _;
            inSwap = false;
        }

        constructor (address payable charityWalletAddress) public {
            _charityWalletAddress = charityWalletAddress;
            _rOwned[_msgSender()] = _rTotal;

            IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // UniswapV2 for Ethereum network
            // Create a uniswap pair for this new token
            uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
                .createPair(address(this), _uniswapV2Router.WETH());

            // set the rest of the contract variables
            uniswapV2Router = _uniswapV2Router;

            // Exclude owner and this contract from fee
            _isExcludedFromFee[owner()] = true;
            _isExcludedFromFee[address(this)] = true;

            emit Transfer(address(0), _msgSender(), _tTotal);
        }

        function name() public view returns (string memory) {
            return _name;
        }

        function symbol() public view returns (string memory) {
            return _symbol;
        }

        function decimals() public view returns (uint8) {
            return _decimals;
        }

        function totalSupply() public view override returns (uint256) {
            return _tTotal;
        }

        function balanceOf(address account) public view override returns (uint256) {
            if (_isExcluded[account]) return _tOwned[account];
            return tokenFromReflection(_rOwned[account]);
        }

        function transfer(address recipient, uint256 amount) public override returns (bool) {
            _transfer(_msgSender(), recipient, amount);
            return true;
        }

        function allowance(address owner, address spender) public view override returns (uint256) {
            return _allowances[owner][spender];
        }

        function approve(address spender, uint256 amount) public override returns (bool) {
            _approve(_msgSender(), spender, amount);
            return true;
        }

        function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
            _transfer(sender, recipient, amount);
            _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
            return true;
        }

        function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
            _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
            return true;
        }

        function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
            _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
            return true;
        }

        function isExcluded(address account) public view returns (bool) {
            return _isExcluded[account];
        }

        function setExcludeFromFee(address account, bool excluded) external onlyOwner() {
            _isExcludedFromFee[account] = excluded;
        }

        function totalFees() public view returns (uint256) {
            return _tFeeTotal;
        }

        function deliver(uint256 tAmount) public {
            address sender = _msgSender();
            require(!_isExcluded[sender], "Excluded addresses cannot call this function");
            (uint256 rAmount,,,,,) = _getValues(tAmount);
            _rOwned[sender] = _rOwned[sender].sub(rAmount);
            _rTotal = _rTotal.sub(rAmount);
            _tFeeTotal = _tFeeTotal.add(tAmount);
        }

        function reflectionFromToken(uint256 tAmount, bool deductTransferFee) public view returns(uint256) {
            require(tAmount <= _tTotal, "Amount must be less than supply");
            if (!deductTransferFee) {
                (uint256 rAmount,,,,,) = _getValues(tAmount);
                return rAmount;
            } else {
                (,uint256 rTransferAmount,,,,) = _getValues(tAmount);
                return rTransferAmount;
            }
        }

        function tokenFromReflection(uint256 rAmount) public view returns(uint256) {
            require(rAmount <= _rTotal, "Amount must be less than total reflections");
            uint256 currentRate =  _getRate();
            return rAmount.div(currentRate);
        }

        function excludeAccount(address account) external onlyOwner() {
            require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
            require(!_isExcluded[account], "Account is already excluded");
            if(_rOwned[account] > 0) {
                _tOwned[account] = tokenFromReflection(_rOwned[account]);
            }
            _isExcluded[account] = true;
            _excluded.push(account);
        }

        function includeAccount(address account) external onlyOwner() {
            require(_isExcluded[account], "Account is already excluded");
            for (uint256 i = 0; i < _excluded.length; i++) {
                if (_excluded[i] == account) {
                    _excluded[i] = _excluded[_excluded.length - 1];
                    _tOwned[account] = 0;
                    _isExcluded[account] = false;
                    _excluded.pop();
                    break;
                }
            }
        }

        function removeAllFee() private {
            if(_taxFee == 0 && _charityFee == 0) return;
            
            _previousTaxFee = _taxFee;
            _previousCharityFee = _charityFee;
            
            _taxFee = 0;
            _charityFee = 0;
        }
    
        function restoreAllFee() private {
            _taxFee = _previousTaxFee;
            _charityFee = _previousCharityFee;
        }
    
        function isExcludedFromFee(address account) public view returns(bool) {
            return _isExcludedFromFee[account];
        }

        function _approve(address owner, address spender, uint256 amount) private {
            require(owner != address(0), "ERC20: approve from the zero address");
            require(spender != address(0), "ERC20: approve to the zero address");

            _allowances[owner][spender] = amount;
            emit Approval(owner, spender, amount);
        }

        function _transfer(address sender, address recipient, uint256 amount) private {
            require(sender != address(0), "ERC20: transfer from the zero address");
            require(recipient != address(0), "ERC20: transfer to the zero address");
            require(amount > 0, "Transfer amount must be greater than zero");
            
            if(sender != owner() && recipient != owner())
                require(amount <= _maxTxAmount, "Transfer amount exceeds the maxTxAmount.");

            // is the token balance of this contract address over the min number of
            // tokens that we need to initiate a swap?
            // also, don't get caught in a circular charity event.
            // also, don't swap if sender is uniswap pair.
            uint256 contractTokenBalance = balanceOf(address(this));
            
            if(contractTokenBalance >= _maxTxAmount)
            {
                contractTokenBalance = _maxTxAmount;
            }
            
            bool overMinTokenBalance = contractTokenBalance >= _numOfTokensToExchangeForCharity;
            if (!inSwap && swapEnabled && overMinTokenBalance && sender != uniswapV2Pair) {
                // We need to swap the current tokens to ETH and send to the charity wallet
                swapTokensForEth(contractTokenBalance);
                
                uint256 contractETHBalance = address(this).balance;
                if(contractETHBalance > 0) {
                    sendETHToCharity(address(this).balance);
                }
            }
            
            //indicates if fee should be deducted from transfer
            bool takeFee = true;
            
            //if any account belongs to _isExcludedFromFee account then remove the fee
            if(_isExcludedFromFee[sender] || _isExcludedFromFee[recipient]){
                takeFee = false;
            }
            
            //transfer amount, it will take tax and charity fee
            _tokenTransfer(sender,recipient,amount,takeFee);
        }

        function swapTokensForEth(uint256 tokenAmount) private lockTheSwap{
            // generate the uniswap pair path of token -> weth
            address[] memory path = new address[](2);
            path[0] = address(this);
            path[1] = uniswapV2Router.WETH();

            _approve(address(this), address(uniswapV2Router), tokenAmount);

            // make the swap
            uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
                tokenAmount,
                0, // accept any amount of ETH
                path,
                address(this),
                block.timestamp
            );
        }
        
        function sendETHToCharity(uint256 amount) private {
            _charityWalletAddress.transfer(amount);
        }
        
        // We are exposing these functions to be able to manual swap and send
        // in case the token is highly valued and 5M becomes too much
        function manualSwap() external onlyOwner() {
            uint256 contractBalance = balanceOf(address(this));
            swapTokensForEth(contractBalance);
        }
        
        function manualSend() external onlyOwner() {
            uint256 contractETHBalance = address(this).balance;
            sendETHToCharity(contractETHBalance);
        }

        function setSwapEnabled(bool enabled) external onlyOwner(){
            swapEnabled = enabled;
        }
        
        function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
            if(!takeFee)
                removeAllFee();

            if (_isExcluded[sender] && !_isExcluded[recipient]) {
                _transferFromExcluded(sender, recipient, amount);
            } else if (!_isExcluded[sender] && _isExcluded[recipient]) {
                _transferToExcluded(sender, recipient, amount);
            } else if (!_isExcluded[sender] && !_isExcluded[recipient]) {
                _transferStandard(sender, recipient, amount);
            } else if (_isExcluded[sender] && _isExcluded[recipient]) {
                _transferBothExcluded(sender, recipient, amount);
            } else {
                _transferStandard(sender, recipient, amount);
            }

            if(!takeFee)
                restoreAllFee();
        }

        function _transferStandard(address sender, address recipient, uint256 tAmount) private {
            (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tCharity) = _getValues(tAmount);
            _rOwned[sender] = _rOwned[sender].sub(rAmount);
            _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); 
            _takeCharity(tCharity); 
            _reflectFee(rFee, tFee);
            emit Transfer(sender, recipient, tTransferAmount);
        }

        function _transferToExcluded(address sender, address recipient, uint256 tAmount) private {
            (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tCharity) = _getValues(tAmount);
            _rOwned[sender] = _rOwned[sender].sub(rAmount);
            _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
            _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);    
            _takeCharity(tCharity);           
            _reflectFee(rFee, tFee);
            emit Transfer(sender, recipient, tTransferAmount);
        }

        function _transferFromExcluded(address sender, address recipient, uint256 tAmount) private {
            (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tCharity) = _getValues(tAmount);
            _tOwned[sender] = _tOwned[sender].sub(tAmount);
            _rOwned[sender] = _rOwned[sender].sub(rAmount);
            _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); 
            _takeCharity(tCharity);   
            _reflectFee(rFee, tFee);
            emit Transfer(sender, recipient, tTransferAmount);
        }

        function _transferBothExcluded(address sender, address recipient, uint256 tAmount) private {
            (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tCharity) = _getValues(tAmount);
            _tOwned[sender] = _tOwned[sender].sub(tAmount);
            _rOwned[sender] = _rOwned[sender].sub(rAmount);
            _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount);
            _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);   
            _takeCharity(tCharity);         
            _reflectFee(rFee, tFee);
            emit Transfer(sender, recipient, tTransferAmount);
        }

        function _takeCharity(uint256 tCharity) private {
            uint256 currentRate =  _getRate();
            uint256 rCharity = tCharity.mul(currentRate);
            _rOwned[address(this)] = _rOwned[address(this)].add(rCharity);
            if(_isExcluded[address(this)])
                _tOwned[address(this)] = _tOwned[address(this)].add(tCharity);
        }

        function _reflectFee(uint256 rFee, uint256 tFee) private {
            _rTotal = _rTotal.sub(rFee);
            _tFeeTotal = _tFeeTotal.add(tFee);
        }

         //to recieve ETH from uniswapV2Router when swaping
        receive() external payable {}

        function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
            (uint256 tTransferAmount, uint256 tFee, uint256 tCharity) = _getTValues(tAmount, _taxFee, _charityFee);
            uint256 currentRate =  _getRate();
            (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, currentRate);
            return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tCharity);
        }

        function _getTValues(uint256 tAmount, uint256 taxFee, uint256 charityFee) private pure returns (uint256, uint256, uint256) {
            uint256 tFee = tAmount.mul(taxFee).div(100);
            uint256 tCharity = tAmount.mul(charityFee).div(100);
            uint256 tTransferAmount = tAmount.sub(tFee).sub(tCharity);
            return (tTransferAmount, tFee, tCharity);
        }

        function _getRValues(uint256 tAmount, uint256 tFee, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
            uint256 rAmount = tAmount.mul(currentRate);
            uint256 rFee = tFee.mul(currentRate);
            uint256 rTransferAmount = rAmount.sub(rFee);
            return (rAmount, rTransferAmount, rFee);
        }

        function _getRate() private view returns(uint256) {
            (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
            return rSupply.div(tSupply);
        }

        function _getCurrentSupply() private view returns(uint256, uint256) {
            uint256 rSupply = _rTotal;
            uint256 tSupply = _tTotal;      
            for (uint256 i = 0; i < _excluded.length; i++) {
                if (_rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply) return (_rTotal, _tTotal);
                rSupply = rSupply.sub(_rOwned[_excluded[i]]);
                tSupply = tSupply.sub(_tOwned[_excluded[i]]);
            }
            if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
            return (rSupply, tSupply);
        }
        
        function _getTaxFee() private view returns(uint256) {
            return _taxFee;
        }

        function _getMaxTxAmount() private view returns(uint256) {
            return _maxTxAmount;
        }

        function _getETHBalance() public view returns(uint256 balance) {
            return address(this).balance;
        }
        
        function _setTaxFee(uint256 taxFee) external onlyOwner() {
            require(taxFee >= 1 && taxFee <= 10, 'taxFee should be in 1 - 10');
            _taxFee = taxFee;
        }

        function _setCharityFee(uint256 charityFee) external onlyOwner() {
            require(charityFee >= 1 && charityFee <= 5, 'charityFee should be in 1 - 5');
            _charityFee = charityFee;
        }
        
        function _setCharityWallet(address payable charityWalletAddress) external onlyOwner() {
            _charityWalletAddress = charityWalletAddress;
        }
        
        function _setMaxTxAmount(uint256 maxTxAmount) external onlyOwner() {
            require(maxTxAmount >= 100000000000000e9 , 'maxTxAmount should be greater than 100000000000000e9');
            _maxTxAmount = maxTxAmount;
        }
    }

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"_token","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"operation","type":"bytes32"},{"indexed":false,"internalType":"address","name":"lastCanceller","type":"address"}],"name":"OperationCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"operation","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"howMany","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownersCount","type":"uint256"},{"indexed":false,"internalType":"address","name":"proposer","type":"address"}],"name":"OperationCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"operation","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"votes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownersCount","type":"uint256"},{"indexed":false,"internalType":"address","name":"downvoter","type":"address"}],"name":"OperationDownvoted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"operation","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"howMany","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownersCount","type":"uint256"},{"indexed":false,"internalType":"address","name":"performer","type":"address"}],"name":"OperationPerformed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"operation","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"votes","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"howMany","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ownersCount","type":"uint256"},{"indexed":false,"internalType":"address","name":"upvoter","type":"address"}],"name":"OperationUpvoted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"previousOwners","type":"address[]"},{"indexed":false,"internalType":"uint256","name":"howManyOwnersDecide","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"newOwners","type":"address[]"},{"indexed":false,"internalType":"uint256","name":"newHowManyOwnersDecide","type":"uint256"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allOperations","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allOperationsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"allOperationsIndicies","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"operation","type":"bytes32"}],"name":"cancelPending","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"howManyOwnersDecide","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"owners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownersCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownersGeneration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"ownersIndices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"commissions","type":"uint256[]"}],"name":"recieveTokens","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"sendTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensRecieved","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensRecievedButNotSent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokensSent","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"newOwners","type":"address[]"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"newOwners","type":"address[]"},{"internalType":"uint256","name":"newHowManyOwnersDecide","type":"uint256"}],"name":"transferOwnershipWithHowMany","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"votesCountByOperation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"votesMaskByOperation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"reciever","type":"address"}],"name":"withdrawEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"reciever","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"writeTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000944eee930933be5e23b690c8589021ec8619a301

-----Decoded View---------------
Arg [0] : _token (address): 0x944eeE930933BE5E23b690c8589021Ec8619a301

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000944eee930933be5e23b690c8589021ec8619a301

122:3028:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;182:23:1;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;182:23:1;;:::i;:::-;;;;-1:-1:-1;;;;;182:23:1;;;;;;;;;;;;;;1365:1095:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1365:1095:0;;-1:-1:-1;1365:1095:0;;-1:-1:-1;;;;;1365:1095:0:i;:::-;;7410:136:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7410:136:1;;-1:-1:-1;7410:136:1;;-1:-1:-1;;;;;7410:136:1:i;1530:100::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;142:34;;;;;;;;;;;;;:::i;1324:108::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1324:108:1;-1:-1:-1;;;;;1324:108:1;;:::i;:::-;;;;;;;;;;;;;;;;;;2467:344:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2467:344:0;;;;;;-1:-1:-1;;;;;2467:344:0;;:::i;240:49::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;240:49:0;-1:-1:-1;;;;;240:49:0;;:::i;211:30:1:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;211:30:1;;:::i;552:55::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;552:55:1;;:::i;6583:697::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6583:697:1;;:::i;189:45:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;189:45:0;-1:-1:-1;;;;;189:45:0;;:::i;613:56:1:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;613:56:1;;:::i;105:31::-;;;;;;;;;;;;;:::i;1438:86::-;;;;;;;;;;;;;:::i;993:366:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;993:366:0;;;;;;;;:::i;383:45:1:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;383:45:1;-1:-1:-1;;;;;383:45:1;;:::i;2821:327:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2821:327:0;;;;;;-1:-1:-1;;;;;2821:327:0;;:::i;295:59::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;295:59:0;-1:-1:-1;;;;;295:59:0;;:::i;7747:1383:1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7747:1383:1;;-1:-1:-1;;7747:1383:1;;;-1:-1:-1;7747:1383:1;;-1:-1:-1;;7747:1383:1:i;451:53::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;451:53:1;;:::i;543:443:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;543:443:0;;:::i;182:23:1:-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;182:23:1;;-1:-1:-1;182:23:1;:::o;1365:1095:0:-;1472:10;1447:36;;;;:24;:36;;;;;;:41;1443:1011;;1534:6;:13;1512:18;;:35;1504:99;;;;-1:-1:-1;;;1504:99:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1617:11;;1642:99;1662:11;:18;1658:1;:22;1642:99;;;1712:11;1724:1;1712:14;;;;;;;;;;;;;;1705:21;;;;1682:3;;;;;;;1642:99;;;;1775:3;1762:9;:16;;1754:103;;;;-1:-1:-1;;;1754:103:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1892:6;:13;:30;;1879:9;:43;;1871:128;;;;-1:-1:-1;;;1871:128:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2027:6;2022:213;2043:6;:13;2039:17;;2022:213;;;2081:21;2113:6;2120:1;2113:9;;;;;;;;;;;;;;;;;2162:14;;-1:-1:-1;;;;;2113:9:0;;;;-1:-1:-1;2162:11:0;;2174:1;;2162:14;;;;;;;;;;;;2141:35;;2194:5;-1:-1:-1;;;;;2194:14:0;:26;2209:10;2194:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2058:3:0;;2022:213;;;-1:-1:-1;2326:10:0;2315:22;;;;:10;:22;;;;;;;;;2276:24;:36;;;;;;:61;2261:12;:76;;;2351:5;;:40;;-1:-1:-1;;;2351:40:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;2351:5:0;;;;:14;;:40;;;;;2315:22;2351:40;;;;;;;;:5;:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2431:12:0;;2416:10;2405:22;;;;:10;2351:40;2405:22;;;;:38;;;;;;;-1:-1:-1;1443:1011:0;1365:1095;:::o;7410:136:1:-;7482:57;7511:9;7522;:16;7482:28;:57::i;1530:100::-;1603:13;:20;1530:100;:::o;142:34::-;;;;:::o;1324:108::-;-1:-1:-1;;;;;1400:21:1;;1377:4;1400:21;;;:13;:21;;;;;;:25;;1324:108;;;;:::o;2467:344:0:-;2841:6:1;:13;2822:33;;:18;:33::i;:::-;2818:385;;;2886:16;;-1:-1:-1;;;;;2886:16:1;:30;2931:123;;;;2961:16;:29;;-1:-1:-1;;;;;;2961:29:1;2980:10;2961:29;;;3026:6;:13;3008:15;:31;2931:123;2573:1:0::1;2564:6;:10;2556:60;;;;-1:-1:-1::0;;;2556:60:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2634:22:0;::::1;2626:47;;;::::0;;-1:-1:-1;;;2626:47:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2626:47:0;;;;;;;;;;;;;::::1;;2691:5;::::0;:30:::1;::::0;;-1:-1:-1;;;2691:30:0;;2715:4:::1;2691:30;::::0;::::1;::::0;;;2725:6;;-1:-1:-1;;;;;2691:5:0::1;::::0;:15:::1;::::0;:30;;;;;::::1;::::0;;;;;;;;:5;:30;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;2691:30:0;:40:::1;;2683:70;;;::::0;;-1:-1:-1;;;2683:70:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2683:70:0;;;;;;;;;;;;;::::1;;2772:5;::::0;:32:::1;::::0;;-1:-1:-1;;;2772:32:0;;-1:-1:-1;;;;;2772:32:0;;::::1;;::::0;::::1;::::0;;;;;;;;;:5;;;::::1;::::0;:14:::1;::::0;:32;;;;;::::1;::::0;;;;;;;;:5:::1;::::0;:32;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;3082:111:1;;;;3112:16;:29;;-1:-1:-1;;;;;;3112:29:1;;;3139:1;3159:15;:19;3082:111;2818:385;;2467:344:0;;:::o;240:49::-;;;;;;;;;;;;;:::o;211:30:1:-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;211:30:1;:::o;552:55::-;;;;;;;;;;;;;:::o;6583:697::-;1762:21;1781:1;1762:18;:21::i;:::-;1758:361;;;1814:16;;-1:-1:-1;;;;;1814:16:1;:30;1859:111;;;;1889:16;:29;;-1:-1:-1;;;;;;1889:29:1;1908:10;1889:29;;;;1936:15;:19;1859:111;6687:10:::1;6655:15;6673:25:::0;;;:13:::1;:25;::::0;;;;;;;;6721:31;;;:20:::1;:31:::0;;;;;;;-1:-1:-1;;6673:29:1;;;;6756:1:::1;:15:::0;;::::1;6721:51;6712:119;;;;-1:-1:-1::0;;;6712:119:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6841:31;::::0;;;:20:::1;:31;::::0;;;;;;;:53;;6878:1:::1;:15:::0;;::::1;6876:18;6841:53:::0;;;::::1;::::0;;;6931:21:::1;:32:::0;;;;;;;;-1:-1:-1;;6931:36:1;6977:54;;;;7097:13;;7046:77;;;;;;;::::1;::::0;;;;;;;7112:10:::1;7046:77:::0;;;;;::::1;::::0;;;;;;;::::1;7137:24:::0;7133:141:::1;;7177:26;7193:9;7177:15;:26::i;:::-;7222:41;::::0;;;;;7252:10:::1;7222:41;::::0;::::1;::::0;;;::::1;::::0;;;;;;;;;::::1;7133:141;1983:1;;2002:6:::0;1998:111;;;2028:16;:29;;-1:-1:-1;;;;;;2028:29:1;;;2055:1;2075:15;:19;1758:361;6583:697;:::o;189:45:0:-;;;;;;;;;;;;;:::o;613:56:1:-;;;;;;;;;;;;;:::o;105:31::-;;;;:::o;1438:86::-;1504:6;:13;1438:86;:::o;993:366:0:-;2841:6:1;:13;2822:33;;:18;:33::i;:::-;2818:385;;;2886:16;;-1:-1:-1;;;;;2886:16:1;:30;2931:123;;;;2961:16;:29;;-1:-1:-1;;;;;;2961:29:1;2980:10;2961:29;;;3026:6;:13;3008:15;:31;2931:123;-1:-1:-1;;;;;1088:18:0;::::1;1080:43;;;::::0;;-1:-1:-1;;;1080:43:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;1080:43:0;;;;;;;;;;;;;::::1;;1150:1;1141:6;:10;1133:60;;;;-1:-1:-1::0;;;1133:60:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1212:15;::::0;::::1;::::0;::::1;;;1211:16;1203:25;;;::::0;::::1;;1247:15;:22:::0;;-1:-1:-1;;1247:22:0;;::::1;;;::::0;;-1:-1:-1;;;;;1279:30:0;::::1;1247:22:::0;1279:30;;;:24:::1;:30;::::0;;;;:40;;;::::1;::::0;;1329:23;;::::1;::::0;;3082:111:1;;;;3112:16;:29;;-1:-1:-1;;;;;;3112:29:1;;;3139:1;3159:15;:19;2818:385;993:366:0;;:::o;383:45:1:-;;;;;;;;;;;;;:::o;2821:327:0:-;2841:6:1;:13;2822:33;;:18;:33::i;:::-;2818:385;;;2886:16;;-1:-1:-1;;;;;2886:16:1;:30;2931:123;;;;2961:16;:29;;-1:-1:-1;;;;;;2961:29:1;2980:10;2961:29;;;3026:6;:13;3008:15;:31;2931:123;2934:1:0::1;2925:6;:10;2917:60;;;;-1:-1:-1::0;;;2917:60:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;2995:22:0;::::1;2987:47;;;::::0;;-1:-1:-1;;;2987:47:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;2987:47:0;;;;;;;;;;;;;::::1;;3077:6;3052:21;:31;;3044:61;;;::::0;;-1:-1:-1;;;3044:61:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;3044:61:0;;;;;;;;;;;;;::::1;;3116:25;::::0;-1:-1:-1;;;;;3116:17:0;::::1;::::0;:25;::::1;;;::::0;3134:6;;3116:25:::1;::::0;;;3134:6;3116:17;:25;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;3086:6:1::0;3082:111;;;3112:16;:29;;-1:-1:-1;;;;;;3112:29:1;;;3139:1;3159:15;:19;2818:385;2821:327:0;;:::o;295:59::-;;;;;;;;;;;;;:::o;7747:1383:1:-;2275:39;2294:19;;2275:18;:39::i;:::-;2271:397;;;2345:16;;-1:-1:-1;;;;;2345:16:1;:30;2390:129;;;;2420:16;:29;;-1:-1:-1;;;;;;2420:29:1;2439:10;2420:29;;;;2485:19;2467:15;:37;2390:129;7904:1:::1;7885:9;:16;:20;7877:84;;;;-1:-1:-1::0;;;7877:84:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7999:3;7979:9;:16;:23;;7971:98;;;;-1:-1:-1::0;;;7971:98:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8112:1;8087:22;:26;8079:102;;;;-1:-1:-1::0;;;8079:102:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8225:9;:16;8199:22;:42;;8191:136;;;;-1:-1:-1::0;;;8191:136:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8388:6;8383:97;8404:6;:13:::0;8400:17;::::1;8383:97;;;8445:13;:24;8459:6;8466:1;8459:9;;;;;;;;;::::0;;;::::1;::::0;;;;;::::1;::::0;-1:-1:-1;;;;;8459:9:1::1;8445:24:::0;;;::::1;::::0;;;;;;;;8438:31;8459:9;8419:3:::1;8383:97;;;;8494:6;8489:334;8510:9;:16;8506:1;:20;8489:334;;;8579:1;-1:-1:-1::0;;;;;8555:26:1::1;:9;8565:1;8555:12;;;;;;;;;;;;;;-1:-1:-1::0;;;;;8555:26:1::1;;;8547:95;;;;-1:-1:-1::0;;;8547:95:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8664:13;:27;8678:9;8688:1;8678:12;;;;;;;;;;;;;;-1:-1:-1::0;;;;;8664:27:1::1;-1:-1:-1::0;;;;;8664:27:1::1;;;;;;;;;;;;;8695:1;8664:32;8656:107;;;;-1:-1:-1::0;;;8656:107:1::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8807:1;8811;8807:5;8777:13;:27;8791:9;8801:1;8791:12;;;;;;;;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;8777:27:1::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;8777:27:1;:35;8528:3:::1;;8489:334;;;;8846:84;8867:6;8875:19;;8896:9;8907:22;8846:84;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;8846:84:1::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;-1:-1:-1::0;;8846:84:1;;::::1;::::0;;;;;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;8940:18:::0;;::::1;::::0;:6:::1;::::0;:18:::1;::::0;::::1;::::0;::::1;:::i;:::-;;8990:22;8968:19;:44;;;;9059:13;9078::::0;9092:1:::1;9078:16;;;;;;;;;::::0;;;::::1;::::0;;;;;::::1;::::0;9059:36;;::::1;::::0;;::::1;::::0;;;;;;;;;;::::1;::::0;9105:18;;;;::::1;::::0;;2547:111;;;;2577:16;:29;;-1:-1:-1;;;;;;2577:29:1;;;2604:1;2624:15;:19;2271:397;7747:1383;;:::o;451:53::-;;;;;;;;;;;;;:::o;543:443:0:-;604:10;596:49;;;;;-1:-1:-1;;;596:49:0;;;;;;;;;;;;-1:-1:-1;;;596:49:0;;;;;;;;;;;;;;;672:1;663:6;:10;655:60;;;;-1:-1:-1;;;655:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;733:5;;:27;;;-1:-1:-1;;;733:27:0;;749:10;733:27;;;;;;764:6;;-1:-1:-1;;;;;733:5:0;;:15;;:27;;;;;;;;;;;;;;:5;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;733:27:0;:37;;725:67;;;;;-1:-1:-1;;;725:67:0;;;;;;;;;;;;-1:-1:-1;;;725:67:0;;;;;;;;;;;;;;;828:5;;:53;;;-1:-1:-1;;;828:53:0;;847:10;828:53;;;;867:4;828:53;;;;;;;;;;;;-1:-1:-1;;;;;828:5:0;;;;:18;;:53;;;;;;;;;;;;;;;:5;;:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;828:53:0;811:14;:70;;-1:-1:-1;;811:70:0;;;;;;;;;;;;;895:14;:22;;-1:-1:-1;895:22:0;891:89;;;948:10;933:26;;;;:14;:26;;;;;:36;;;;;;543:443;:::o;4188:1492:1:-;4267:16;;4247:4;;-1:-1:-1;;;;;4267:16:1;4287:10;4267:30;4263:193;;;4332:15;;4321:7;:26;;4313:107;;;;-1:-1:-1;;;4313:107:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4441:4:1;4434:11;;4263:193;4498:10;4466:15;4484:25;;;:13;:25;;;;;;4544:6;:13;-1:-1:-1;;4484:29:1;;;;4531:26;;4523:85;;;;-1:-1:-1;;;4523:85:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4618:17;4665:8;;4675:16;;4648:44;;;;;;;;;;;;;;;;;;-1:-1:-1;;4648:44:1;;;;;;;;;;;;;;4638:55;;;;;;4648:44;4713:31;;;:20;:31;;;;;;4638:55;;-1:-1:-1;4748:1:1;:15;;;4713:51;4712:58;;-1:-1:-1;4704:128:1;;-1:-1:-1;4704:128:1;;;-1:-1:-1;;;4704:128:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4842:31;;;;:20;:31;;;;;;;;:52;;4878:1;:15;;;4842:52;;;4931:21;:32;;;;;;;-1:-1:-1;4931:36:1;;;4977:54;;;;5045:24;;5041:235;;;5120:13;:20;;5085:32;;;;:21;:32;;;;;;;;:55;;;5154:29;;;;;;;;;;;;;;;;5239:6;:13;5202:63;;;;;;;;;;;;;;;5254:10;5202:63;;;;;;;;;;;;;;;5041:235;5348:6;:13;5290:84;;;;;;;;;;;;;;;;;;;;;;;;;5363:10;5290:84;;;;;;;;;;;;;;5446:32;;;;:21;:32;;;;;;:43;;5442:209;;;5505:26;5521:9;5505:15;:26::i;:::-;5589:6;:13;5550:65;;;;;;;;;;;;;;;;;;;5604:10;5550:65;;;;;;;;;;;;;;5636:4;5629:11;;;;;;;5442:209;-1:-1:-1;5668:5:1;;4188:1492;-1:-1:-1;;;;4188:1492:1:o;5817:573::-;5880:10;5893:32;;;:21;:32;;;;;;5947:13;:20;-1:-1:-1;;5947:24:1;5939:32;;5935:202;;;6022:13;6036:20;;-1:-1:-1;;6036:24:1;;;6022:39;;;;;;;;;;;;;;5999:13;6013:5;5999:20;;;;;;;;;;;;;;;:62;;;;6121:5;6075:21;:43;6097:13;6111:5;6097:20;;;;;;;;;;;;;;;;6075:43;;;;;;;;;;;:51;;;;5935:202;6179:13;6212:20;;6179:13;;-1:-1:-1;;6212:22:1;;;6198:37;;;;;;;;;;;;;;;;;;6179:57;;;;;;;;;;;;;;;;;;;;6254:31;;;:20;:31;;;;;;6247:38;;;6302:21;:32;;;;;6295:39;;;6351:21;:32;;;;;6344:39;;;;-1:-1:-1;5817:573:1:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;

ipfs://f538d621744b85bad2358ea7791c1f48fbf8b3025838dffda84d52438d2cba16