Contract Source Code (Solidity)

IDE

• Blockscan IDE

Outline

• library Address
•    - 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 Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function getOwner()
•    - function proposeOwner(address newOwne ...
•    - function takeOwnership()
•    - function _transferOwnership(address n ...
•    - function compareStrings(string memory ...
•    - function _existIn(address account, ad ...
•    - function setApprover(address account, ...
•    - function setProposer(address account, ...
•    - function _isProposalApproved(uint256 ...
•    - function _isProposalOpposed(uint256 o ...
•    - function getProposalAdmin(address pro ...
•    - function proposeAdmin(address newAdmi ...
•    - function approveAdmin(address propose ...
•    - function takeAdmin()
•    - function _isProposalAdminApproved(add ...
•    - function _isProposalAdminOpposed(addr ...
•    - function _isProposalAdminApproving(ad ...
•    - function getDistributeProposal(addres ...
•    - function proposDistribution(uint256 c ...
•    - function approveDistribution(address ...
•    - function takeDistribution(uint256 tim ...
•    - function _isProposalDistributionAppro ...
•    - function _isProposalDistributionOppos ...
•    - function _isProposalDistributionAppro ...
•    - function getProposalEverythingAdmin(a ...
•    - function proposeEverythingAdmin(uint2 ...
•    - function approveEverythingAdmin(addre ...
•    - function takeEverythingAdmin(uint256 ...
•    - function _isProposalEverythingAdminAp ...
•    - function _isProposalEverythingAdminOp ...
•    - function _isProposalEverythingAdminAp ...
• 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 ...
•  contract Everything is ReentrancyG ... *
•    - function totalEquity()
•    - function _isValidatorApproved(uint256 ...
•    - function _isValidatorOpposed(uint256 ...
•    - function _isValidatorApproving()
•    - function getCurrentValidationStatus()
•    - function getCurrentClaimsCount()
•    - function getCurrentClaims(uint256 sta ...
•    - function set_governance_token(address ...
•    - function setOperationAddresses( addre ...
•    - function setDistribution( uint state, ...
•    - function uploading_start(uint256 cidT ...
•    - function upload_claim(address[] calld ...
•    - function uploading_done(uint256 cidTi ...
•    - function validating_start(uint256 cid ...
•    - function validate_claim(uint256 cidTi ...
•    - function validating_done(uint256 cidT ...
•    - function sending_start(uint256 cidTim ...
•    - function sendToAddress(uint256 cidTim ...
•    - function sending_done(uint256 cidTime ...
•    - function validating_cleanup(uint256 c ...
•  contract EverythingGov is Reentran ... *
•    - function setEverythingContractAddress ...
•    - function setEverythingAdmin()
•    - function setEverythingDistribution()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-05-12
*/

// SPDX-License-Identifier: GPL-3.0

pragma solidity >=0.7.0 <0.9.0;
pragma experimental ABIEncoderV2;

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * 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.
     *
     * > 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.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

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.
     *
     * > 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 Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0, "SafeMath: modulo by zero");
        return a % b;
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
abstract contract Ownable
{
    address public owner;
    address private proposedOwner;

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

    /**
    * @dev The Ownable constructor sets the original `owner` of the contract to the sender
    * account.
    */
    constructor(address _owner) {
        owner = _owner;   // msg.sender;
    }

    /**
    * @dev Returns the bep token owner.
    */
    function getOwner() external view returns (address) {
        return owner;
    }

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    /**
    * @dev propose a new owner by an existing owner
    * @param newOwner The address proposed to transfer ownership to.
    */
    function proposeOwner(address newOwner) public onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        proposedOwner = newOwner;
        emit OwnershipProposed(newOwner);
    }

    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    */
    function takeOwnership() public {
        require(proposedOwner == msg.sender, "Ownable: not the proposed owner");
        _transferOwnership(proposedOwner);
    }

    /**
    * @dev Transfers control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: zero address not allowed");
        emit OwnershipTransferred(owner, newOwner);
        owner = newOwner;
    }

    function compareStrings(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b));
    }

    function _existIn(address account, address[] memory accounts) internal pure returns(bool) {
        for (uint256 i = 0; i < accounts.length; i++) {
            if (account == accounts[i]) return true;
        }
        return false;
    }
}

abstract contract Governable is Ownable {

    uint256 public constant RATIO_DECIMALS = 4;  /** ratio decimals */
    uint256 public constant RATIO_PRECISION = 10 ** RATIO_DECIMALS /** ratio precision， 10000 */;
    uint256 public constant MIN_APPROVE_RATIO = 6666 ; /** min approve ratio, 66.66% */

    enum ApprovedStatus { NONE, STARTED, APPROVED, OPPOSED }

    event ApproverChanged(address indexed account, bool approve);
    event ProposerChanged(address indexed account, bool on);

    mapping (address => bool) public Approvers;
    uint256 approverCount;

    mapping (address => bool) public Proposers;

    /**
    * @dev Throws if called by any account other than the approver.
    */
    modifier onlyApprover() {
        require(Approvers[msg.sender], "Governable: caller is not the approver");
        _;
    }

    /**
    * @dev Throws if called by any account other than the proposer.
    */
    modifier onlyProposer() {
        require(Proposers[msg.sender], "Governable: caller is not the proposer");
        _;
    }

    function setApprover(address account, bool approve) public onlyOwner {
        if (Approvers[account] != approve) {
            if (approve) {
                Approvers[account] = true;
                approverCount += 1;
            } else {
                delete Approvers[account];
                approverCount -= 1;
            }
            emit ApproverChanged(account, approve);
        }
    }

    function setProposer(address account, bool on) public onlyOwner {
        if (Proposers[account] != on) {

            if (on) {
                Proposers[account] = on;
            } else {
                delete Proposers[account];
            }
            emit ApproverChanged(account, on);
        }
    }

    function _isProposalApproved(uint256 approvedCount) internal view returns(bool) {
        if (approverCount == 0) return false;

        return approvedCount * RATIO_PRECISION / approverCount >= MIN_APPROVE_RATIO;
    }

    function _isProposalOpposed(uint256 opposedCount) internal view returns(bool) {
        if (approverCount == 0) return false;

        return opposedCount  * RATIO_PRECISION / approverCount > RATIO_PRECISION - MIN_APPROVE_RATIO;
    }
}


abstract contract Administrable is Governable {

    event AdminProposed(address indexed proposer, address indexed newAdmin);
    event AdminApproved(address indexed proposer,
        address indexed newAdmin,
        address indexed approver,
        bool approved
    );
    event AdminChanged(address indexed previousAdmin, address indexed newAdmin);

    struct ProposalAdminData {
        // address     proposer;
        address     admin;
        address[]   approvers;
        address[]   opposers;
    }

    address public admin;
    // ProposalAdminData public proposalAdmin;

    // proposer -> ProposalAdminData
    mapping (address => ProposalAdminData) public proposalAdmin;    // allow multiple proposals so that no one can block this proces

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyAdmin() {
        require(msg.sender == admin /* , "Administrable: caller is not admin" */);
        _;
    }

    function getProposalAdmin(address proposer) public view returns(
        address     theproposer,
        address     newAdmin,
        address[] memory  approvers,
        address[] memory  opposers,
        ApprovedStatus approvedStatus
    ) {
        ApprovedStatus _approvedStatus =
            _isProposalAdminOpposed(proposer)   ? ApprovedStatus.OPPOSED  :
            _isProposalAdminApproved(proposer)  ? ApprovedStatus.APPROVED :
            _isProposalAdminApproving(proposer) ? ApprovedStatus.STARTED  : ApprovedStatus.NONE;

        return (proposer, proposalAdmin[proposer].admin, proposalAdmin[proposer].approvers,
            proposalAdmin[proposer].opposers, _approvedStatus);
    }

    /**
    * @dev propose new admin
    * @param newAdmin propose newAdmin
    */
    function proposeAdmin(address newAdmin) public onlyProposer()  returns(bool) {
        require(newAdmin != address(0) /* , "Administrable: zero address not allowed" */ );
        require(!_isProposalAdminApproving(msg.sender) || _isProposalAdminOpposed(msg.sender) /* ,
            "Administrable: proposal is approving and not opposed" */ );

        // delete proposalAdmin;
        delete proposalAdmin[msg.sender];

        //proposalAdmin by a proposer for once only otherwise would be overwritten
        // proposalAdmin.proposer = msg.sender;
        // proposalAdmin.admin = newAdmin;
        proposalAdmin[msg.sender].admin = newAdmin;

        emit AdminProposed(msg.sender, newAdmin);
        return true;
    }

    function approveAdmin(address proposer, address newAdmin, bool approved) public onlyApprover() returns(bool) {
        require( proposalAdmin[proposer].admin != address(0) /* , "Administrable: no proposal admin data" */ );
        require( newAdmin == proposalAdmin[proposer].admin /* , "Administrable: newAdmin mismatch" */ );
        require( !_existIn(msg.sender, proposalAdmin[proposer].approvers) &&  !_existIn(msg.sender, proposalAdmin[proposer].opposers) /*,
            "Administrable: duplicated approve admin" */);

        if (approved) {
            proposalAdmin[proposer].approvers.push(msg.sender);
        } else {
            proposalAdmin[proposer].opposers.push(msg.sender);
        }

        emit AdminApproved(proposer, newAdmin, msg.sender, approved);

        return true;
    }

    function takeAdmin() public onlyProposer() returns(bool) {
        require( proposalAdmin[msg.sender].admin != address(0) /* , "Administrable: no proposal admin data" */ );

        require( !_isProposalAdminOpposed(msg.sender) /* , "Administrable: proposal has been opposed" */ );
        require( _isProposalAdminApproved(msg.sender) /* , "Administrable: approved count not reach min approve ratio yet" */ );

        address previousAdmin = admin;
        admin = proposalAdmin[msg.sender].admin;

        delete proposalAdmin[msg.sender];

        emit AdminChanged(previousAdmin, admin);

        return true;
    }

    function _isProposalAdminApproved(address proposer) internal view returns(bool) {
        return _isProposalApproved(proposalAdmin[proposer].approvers.length);
    }

    function _isProposalAdminOpposed(address proposer) internal view returns(bool) {
        return _isProposalOpposed(proposalAdmin[proposer].opposers.length);
    }

    function _isProposalAdminApproving(address proposer) internal view returns(bool) {
         return proposalAdmin[proposer].approvers.length > 0 || proposalAdmin[proposer].opposers.length > 0;
    }

}

abstract contract Distributable is Administrable {
    using SafeMath for uint256;

    uint256 public constant MIN_DELAY = 7884000; // 3 months in seconds 

    event ProposeDistribution(address indexed proposer, uint256 timestamp, string cid, uint state, uint256 delay);
    event ApproveDistribution(address indexed proposer, uint256 timestamp, string cid, uint state, uint256 delay, address indexed approver, bool approved);
    event TakeDistribution(uint256 timestamp, string cid, uint state, uint256 theDistributionTime);

    struct DistributeProposalData {
        uint256     cidTimestamp;
        string      cid;
        uint        emergencyState;
        uint256     delayedTime;      // after approval, approved block.timestamp + delayedTime will be set as distributable time 
        address[]   approvers;
        address[]   opposers;
    }

    uint256 public distributionCIDTimestamp;
    string public  distributionCID;

    uint256 public theDistributionTime;             
    uint public emergencyState;              // 0 - regular, 1 - halt, 2 - distribute

    // proposer -> DistributeProposalData
    mapping (address => DistributeProposalData) public distributionProposals;    // allow multiple proposals so that no one can block this proces

    function getDistributeProposal(address proposer) public view returns(
        uint256     timeStamp,
        string memory cid,
        uint        state,
        uint256     delayedTime,
        address[] memory  approvers,
        address[] memory  opposers,
        ApprovedStatus approvedStatus
    ) {
        ApprovedStatus _approvedStatus =
            _isProposalDistributionOpposed(proposer)   ? ApprovedStatus.OPPOSED  :
            _isProposalDistributionApproved(proposer)  ? ApprovedStatus.APPROVED :
            _isProposalDistributionApproving(proposer) ? ApprovedStatus.STARTED  : ApprovedStatus.NONE;

        return (distributionProposals[proposer].cidTimestamp, 
                distributionProposals[proposer].cid,
                distributionProposals[proposer].emergencyState,
                distributionProposals[proposer].delayedTime, 
                distributionProposals[proposer].approvers, 
                distributionProposals[proposer].opposers, 
                _approvedStatus);
    }

    /**
    * @dev propose to distribute
    * @return bool
    */
    function proposDistribution(uint256 cidTimestamp, string calldata cid, uint state, uint256 timeDelay) public onlyProposer() returns(bool) {
        if (state >= 2) {
            require(timeDelay >= MIN_DELAY /* , "distribution: only distributable after 3 months"  */);
        }
        require(!_isProposalDistributionApproving(msg.sender) || _isProposalDistributionOpposed(msg.sender) /* ,
            "distribution: proposal is approving and not opposed" */ );

        delete distributionProposals[msg.sender];

        distributionProposals[msg.sender].cidTimestamp = cidTimestamp;
        distributionProposals[msg.sender].cid = cid;  
        distributionProposals[msg.sender].emergencyState = state;      
        distributionProposals[msg.sender].delayedTime = timeDelay;

        emit ProposeDistribution(msg.sender, cidTimestamp, cid, emergencyState, timeDelay);

        return true;
    }

    function approveDistribution(address proposer, uint256 cidTimestamp, string calldata cid, uint state, uint256 delay, bool approved) public onlyApprover() returns(bool) {
        require( proposer != address(0) /* , "distribution: no such proposal" */ );
        require( cidTimestamp == distributionProposals[proposer].cidTimestamp /* , "distribution: no such proposal" */);
        require( compareStrings(cid, distributionProposals[proposer].cid) /* , "distribution: no such proposal" */ );
        require( distributionProposals[proposer].emergencyState == state /* , "distribution: delay mismatch" */ );
        if (state >= 2) {
            require(delay >= MIN_DELAY /* , "distribution: only distributable after 3 months" */ );
        }
        require( distributionProposals[proposer].delayedTime == delay /* , "distribution: delay mismatch"  */);

        require( !_existIn(msg.sender, distributionProposals[proposer].approvers) &&  !_existIn(msg.sender, distributionProposals[proposer].opposers) /* ,
            "distribution: duplicated approve" */ );

        if (approved) {
            distributionProposals[proposer].approvers.push(msg.sender);
        } else {
            distributionProposals[proposer].opposers.push(msg.sender);
        }

        emit ApproveDistribution(proposer, cidTimestamp, cid, emergencyState, delay, msg.sender, approved);

        return true;
    }

    function takeDistribution(uint256 timestamp, string calldata cid, uint state, uint256 delayTime) public onlyProposer() returns(bool) {
        require( timestamp == distributionProposals[msg.sender].cidTimestamp /* , "distribution: no such proposal" */);
        require( compareStrings(cid, distributionProposals[msg.sender].cid) /* , "distribution: no such proposal" */ );
        require( state == distributionProposals[msg.sender].emergencyState /* , "distribution: no such proposal" */ );
        if (state >= 2) {
            require(delayTime >= MIN_DELAY /* , "distribution: only distributable after 3 months" */ );
        }
        require( delayTime == distributionProposals[msg.sender].delayedTime /* , "distribution: no such proposal" */);

        require( !_isProposalDistributionOpposed(msg.sender) /* , "distribution: proposal has been opposed" */ );
        require( _isProposalDistributionApproved(msg.sender) /* , "distribution: approved count not reach min approve ratio yet" */);

        distributionCIDTimestamp = distributionProposals[msg.sender].cidTimestamp;
        distributionCID = distributionProposals[msg.sender].cid;
        emergencyState = distributionProposals[msg.sender].emergencyState;
        theDistributionTime = distributionProposals[msg.sender].delayedTime.add( block.timestamp ) ;

        delete distributionProposals[msg.sender];

        emit TakeDistribution(distributionCIDTimestamp, distributionCID, emergencyState, theDistributionTime);

        return true;
    }

    function _isProposalDistributionApproved(address proposer) internal view returns(bool) {
        return _isProposalApproved(distributionProposals[proposer].approvers.length);
    }

    function _isProposalDistributionOpposed(address proposer) internal view returns(bool) {
        return _isProposalOpposed(distributionProposals[proposer].opposers.length);
    }

    function _isProposalDistributionApproving(address proposer) internal view returns(bool) {
        return distributionProposals[proposer].approvers.length > 0
            || distributionProposals[proposer].opposers.length > 0;
    }
}

abstract contract EverythingAdmin is Distributable {

    event EverythingUploaderProposed(address indexed proposer, address indexed newUploader);
    event EverythingValidatorProposed(address indexed proposer, address indexed newValidator);
    event EverythingSenderProposed(address indexed proposer, address indexed newSender);
    event EverythingAdminApproved(address indexed proposer, uint256 timeStamp, address indexed approver, bool approved);
    event EverythingAdminChanged(uint256 previousTimeStamp, uint256 newTimeStamp);

    struct ProposalEverythingAdminData {
        // address     proposer;
        uint256     timestamp;
        
        address     everythingUploader;
        address[]   everythingValidators;
        address     everythingSender;

        address[]   approvers;
        address[]   opposers;
    }

    uint256 public    everythingAdminTimestamp;
    address public    everythingUploader;
    address[] public  everythingValidators;
    address public    everythingSender;

    // ProposalEverythingAdminData public proposalEverythingAdmin;
    // proposer -> ProposalEverythingAdminData
    mapping (address => ProposalEverythingAdminData) public proposalEverythingAdmin;

    function getProposalEverythingAdmin(address proposer) public view returns(
        address     theProposer,
        address     newUploader,
        address[] memory  newValidators,
        address     newSender,
        address[] memory  approvers,
        address[] memory  opposers,
        ApprovedStatus approvedStatus
    ) {
        ApprovedStatus _approvedStatus =
            _isProposalEverythingAdminOpposed(proposer)   ? ApprovedStatus.OPPOSED  :
            _isProposalEverythingAdminApproved(proposer)  ? ApprovedStatus.APPROVED :
            _isProposalEverythingAdminApproving(proposer) ? ApprovedStatus.STARTED  : ApprovedStatus.NONE;

        return (proposer, 
                proposalEverythingAdmin[proposer].everythingUploader, 
                proposalEverythingAdmin[proposer].everythingValidators,
                proposalEverythingAdmin[proposer].everythingSender, 
                proposalEverythingAdmin[proposer].approvers,
                proposalEverythingAdmin[proposer].opposers, 
                _approvedStatus);
    }

    /**
    * @dev propose new Everything admin
    */
    function proposeEverythingAdmin(uint256 proposalTimestamp, address newUploader, address[] calldata newValidators, address newSender) public onlyProposer()  returns(bool) {
        require(newUploader != address(0) /* , "Uploader: zero address not allowed" */ );
        uint256 validatorsLen = newValidators.length;
        require(validatorsLen > 0 /* , "validators count 0 not allowed" */);
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = newValidators[iii];
            require(newValidator != address(0) /* , "Validator: zero address not allowed"  */ );
        }
        require(newSender != address(0) /* , "Sender: zero address not allowed"  */);
        require(!_isProposalEverythingAdminApproving(msg.sender) || _isProposalEverythingAdminOpposed(msg.sender) /* , "EverythingAdmin: proposal is approving and not opposed" */ );

        delete proposalEverythingAdmin[msg.sender];

        //proposalAdmin by a proposer for once only otherwise would be overwritten
        // proposalEverythingAdmin.proposer = msg.sender;
        proposalEverythingAdmin[msg.sender].timestamp = proposalTimestamp;
        proposalEverythingAdmin[msg.sender].everythingUploader = newUploader;
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = newValidators[iii];
            proposalEverythingAdmin[msg.sender].everythingValidators.push(newValidator);
        }
        proposalEverythingAdmin[msg.sender].everythingSender = newSender;

        emit EverythingUploaderProposed(msg.sender, newUploader);
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = proposalEverythingAdmin[msg.sender].everythingValidators[iii];
            emit EverythingValidatorProposed(msg.sender, newValidator);
        }
        emit EverythingSenderProposed(msg.sender, newSender);

        return true;
    }

    function approveEverythingAdmin(address proposer, uint256 proposalTimestamp, bool approved) public onlyApprover() returns(bool) {
        require( proposalEverythingAdmin[proposer].timestamp == proposalTimestamp /* , "everythingAdmin: no such proposal" */);
        // require( proposer == proposalEverythingAdmin.proposer, "EverythingAdmin: proposer mismatch" );
        require( !_existIn(msg.sender, proposalEverythingAdmin[proposer].approvers) &&  !_existIn(msg.sender, proposalEverythingAdmin[proposer].opposers) /* , "everythingAdmin: duplicated approve admin" */ );

        if (approved) {
            proposalEverythingAdmin[proposer].approvers.push(msg.sender);
        } else {
            proposalEverythingAdmin[proposer].opposers.push(msg.sender);
        }

        emit EverythingAdminApproved(proposer, proposalTimestamp, msg.sender, approved);

        return true;
    }

    function takeEverythingAdmin(uint256 timestamp) public onlyProposer() returns(bool) {
        require( proposalEverythingAdmin[msg.sender].timestamp == timestamp /* , "EverythingAdmin: no such proposal" */);

        require( !_isProposalEverythingAdminOpposed(msg.sender) /* , "EverythingAdmin: proposal has been opposed" */);
        require( _isProposalEverythingAdminApproved(msg.sender) /* , "EverythingAdmin: approved count not reach min approve ratio yet" */ );

        require(proposalEverythingAdmin[msg.sender].everythingUploader != address(0) /* , "Uploader: zero address not allowed"  */);
        uint256 validatorsLen = proposalEverythingAdmin[msg.sender].everythingValidators.length;
        require(validatorsLen > 0 /* , "validators count 0 not allowed" */);
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = proposalEverythingAdmin[msg.sender].everythingValidators[iii];
            require(newValidator != address(0) /* , "Validator: zero address not allowed" */ );
        }
        require(proposalEverythingAdmin[msg.sender].everythingSender != address(0) /* , "Sender: zero address not allowed" */ );

        delete everythingValidators;

        uint256 prevTimeStamp = everythingAdminTimestamp;

        everythingAdminTimestamp = proposalEverythingAdmin[msg.sender].timestamp;
        everythingUploader = proposalEverythingAdmin[msg.sender].everythingUploader;
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = proposalEverythingAdmin[msg.sender].everythingValidators[iii];
            require(newValidator != address(0) /* , "Validator: zero address not allowed" */ );
            everythingValidators.push(newValidator);
        }
        everythingSender = proposalEverythingAdmin[msg.sender].everythingSender;

        delete proposalEverythingAdmin[msg.sender];

        emit EverythingAdminChanged(prevTimeStamp, everythingAdminTimestamp);

        return true;
    }

    function _isProposalEverythingAdminApproved(address proposer) internal view returns(bool) {
        return _isProposalApproved(proposalEverythingAdmin[proposer].approvers.length);
    }

    function _isProposalEverythingAdminOpposed(address proposer) internal view returns(bool) {
        return _isProposalOpposed(proposalEverythingAdmin[proposer].opposers.length);
    }

    function _isProposalEverythingAdminApproving(address proposer) internal view returns(bool) {
         return proposalEverythingAdmin[proposer].approvers.length > 0 || proposalEverythingAdmin[proposer].opposers.length > 0;
    }

}

abstract contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter, "ReentrancyGuard: reentrant call");
    }
}


library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    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(address(token).isContract(), "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");
        }
    }
}

contract Everything is ReentrancyGuard, Ownable /* Governable */ {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    /* ========== Constant VARIABLES ========== */
    uint256 public constant EVERYTHING_RATIO_DECIMALS = 4;  /** ratio decimals */
    uint256 public constant EVERYTHING_RATIO_PRECISION = 10 ** EVERYTHING_RATIO_DECIMALS /** ratio precision， 10000 */;
    uint256 public constant EVERYTHING_MIN_APPROVE_RATIO = 6666 ; /** min approve ratio, 66.66% */

    /* ========== STATE VARIABLES ========== */
    address public theGovernanceToken;
    IERC20 public collateralToken; 

    // operating addresses
    address public uploader;

    // address -> uint
    address[] public validatorsArray;
    // address -> index into validatorsArray
    mapping(address => uint) public validators;  // Todo: check efficiency of memory usage vs looping for this

    address public sender;

    // for distribution setting
    uint public emergencyState;          // 0 regular, 1 emergency, 2 distribution
    uint256 public toDistributeTime;
    uint256 public distributionCIDTime;
    string public distributionCID;

    // proof of Balance Sheet CID for processing claims
    uint256 public epochCIDTimestamp;
    string  public epochCID;
    uint256 public totalEquityAmount;
    bytes32 public epochBalanceSheetProofRoot;   // Merkle proof of the current balance sheet and cashflow records, including history
    bytes32 public epochAccountsProofRoot;       // Merkle proof of the account info, including history

    // validators validates all these numbers
    // the blow info now is set by uploader and CID above, which is controlled by the governance contract
    // struct EBalance {
    //     uint256 cidTime;        // mtm time
	//     uint256 equity;	       // equity at cid time
	//     uint256 availableCollateral;	    // collateral that is available for withdrawal at cid time
    //     uint256 withdrawRequested;   // the total requested withdrawal from last epoch time (inclusive) to this epoch time (exclusive)
    //     uint256 withdrawable;   // withdrawable amount approved and to be sent 
    // }
    // // user -> EBalance
    // mapping(address => EBalance) public userEBalance;

    // sending claims variables
    uint256 public claimTotalAmount;
    uint256 public claimRemainingAmount;
    uint256 public claimTotalCount;

    struct ApprovedClaim {
        address withdrawAddress;
        uint256 withdrawable;        // withdrawable amount at startingTime

        // uint256 cidTimestamp;     // activate if using map
        // bool    validated;        // todo activate if using map. default false.  can only set by a validator according to overall validatorStatus.approvingResult
    }
    ApprovedClaim[] public userClaimsApproved;

    // todo which one is better, map or array ?
    // // user -> ApprovedClaim
    // mapping(address => ApprovedClaim) public userClaimsApproved;

    uint    public operationState;
    // uint256 public cumClaimAmountUploaded;

    // uploader status data.  only writterable by uploader
    // struct UploaderStatusData {
    //     bool        uploading;
    //     bool        uploaderDone;

    //     uint256     cumAmountUploaded;
    // }
    // UploaderStatusData public uploaderStatus;

    // validator status data.  only writterable by validators
    // struct ValidatorStatusData {
    //     bool        approving;
    //     bool        approvingDone;
    //     // bool        propogateResult;   // todo if using map for userClaimsApproved
    // }
    address[] public  validatorApprovers;
    address[] public  validatorOpposers;
    // ValidatorStatusData public validatorStatus;

    // sender status data.  only writterable by sender
    // struct SenderStatusData {
    //     bool        sending;
    //     bool        senderDone;
    // }
    // SenderStatusData public senderStatus;

    /* ========== CONSTRUCTOR ========== */
    constructor(
        address _owner,
        address _collateralToken
    ) Ownable(_owner) {
        collateralToken = IERC20(_collateralToken);
    }

    /* ========== VIEWS ========== */

    function totalEquity() external view returns (uint256) {
        return totalEquityAmount;
    }

    function _isValidatorApproved(uint256 approvedCount) internal view returns(bool) {
        if (validatorsArray.length == 0) return false;

        return approvedCount.mul( EVERYTHING_RATIO_PRECISION ).div( validatorsArray.length ) >= EVERYTHING_MIN_APPROVE_RATIO;
    }

    function _isValidatorOpposed(uint256 opposedCount) internal view returns(bool) {
        if (validatorsArray.length == 0) return false;

        return opposedCount.mul( EVERYTHING_RATIO_PRECISION ).div( validatorsArray.length ) > EVERYTHING_RATIO_PRECISION - EVERYTHING_MIN_APPROVE_RATIO;
    }

    function _isValidatorApproving() internal view returns(bool) {
         return validatorApprovers.length > 0 || validatorOpposers.length > 0;
    }

    function getCurrentValidationStatus() public view returns(
        uint256     timeStamp,
        string memory cid,
        address[] memory  approvers,
        address[] memory  opposers
    ) {
        return (epochCIDTimestamp, 
                epochCID,
                validatorApprovers, 
                validatorOpposers);
    }

    function getCurrentClaimsCount() external view returns (uint256) {
        return userClaimsApproved.length;
    }

    function getCurrentClaims(uint256 startIdx) public view returns(
        address[100] memory  claimers,
        uint256[100] memory  claimedAmounts
    ) {
        address[100] memory lclaimers;
        uint256[100] memory lamounts;

        uint256 finalIndex = Math.min( startIdx+100, userClaimsApproved.length);
        for (uint256 iii= startIdx; iii< finalIndex; iii++) {
            uint256 lidx = iii - startIdx;
            lclaimers[lidx] = userClaimsApproved[iii].withdrawAddress;
            lamounts[lidx] = userClaimsApproved[iii].withdrawable;
        }

        return (lclaimers,
            lamounts);
    }

    /* ========== MUTATIVE FUNCTIONS ========== */
    function set_governance_token(address govToken) nonReentrant external onlyOwner {
        require( theGovernanceToken == address(0) /* , "was set" */);
        require( govToken != address(0) /* , "everything: address cannot be empty" */ );
        theGovernanceToken = govToken;
        emergencyState = 0;
        operationState = 0;
    }

    function setOperationAddresses( address newUploader, address[] calldata newValidators, address newSender ) external onlyGovToken {
        require(newUploader != address(0) /* , "everything: non-zero uploader" */);
        require(newSender != address(0) /* , "everything: non-zero sender" */);

        uint256 valLen = newValidators.length;
        require (valLen > 0 /* , "everything: at least one validator" */);
        for (uint256 iii=0; iii<valLen; iii++) {
            address newValidator = newValidators[iii];
            require(newValidator != address(0) /* , "everything: non-zero sender" */);
        }

        delete validatorsArray;

        // operating addresses
        uploader = newUploader;
        sender = newSender;
        for (uint iii=0; iii<valLen; iii++) {
            address newValidator = newValidators[iii];
            validators[newValidator] = iii;
            validatorsArray.push(newValidator);
        }

        emit NewUploaderSet(uploader);
        for (uint iii=0; iii<valLen; iii++) {
            address newValidator = validatorsArray[iii];
            emit NewValidatorSet(newValidator);
        }
        emit NewSenderSet(sender);
    }

    function setDistribution( uint state, uint256 distributeTime, uint256 cidTime, string calldata cid ) external onlyGovToken {
        require(emergencyState < 2 /* "distribution is set" */ );
        if (state == 2) {
            require(distributeTime > block.timestamp /* , "everything: enought time to distribute" */);
        }

        // for distribution setting
        emergencyState = state;
        toDistributeTime = distributeTime;
        distributionCIDTime = cidTime;
        distributionCID = cid;

        emit SetDistribution(state, distributeTime, cidTime, cid);
    }

    function uploading_start(uint256 cidTimestamp, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount) nonReentrant external onlyUpLoader {
        // make sure we are in the right state of operation    
        // require(!validatorStatus.approving, "everything: uploader_start validator started");
        // require(!validatorStatus.approvingDone, "everything: uploader_start validator done");       
        // require(!senderStatus.sending, "everything: uploader_start sender started");
        // require(!senderStatus.senderDone, "everything: uploader_start sender done");
        require(operationState <= 1 /* , "everything: wrong state" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: uploading_start wrong epoch" */);
            require(compareStrings(cid, distributionCID) /* , "everything: uploading_start  CID does not match" */);
        }

        // delete uploaderStatus;    
        // cumClaimAmountUploaded = 0;    
        delete userClaimsApproved;

        epochCIDTimestamp = cidTimestamp;
        epochCID = cid;
        epochBalanceSheetProofRoot = balanceProof;
        epochAccountsProofRoot = accountsProof;
        totalEquityAmount = totalEq;

        claimTotalAmount = totalClaim;
        claimRemainingAmount = totalClaim;
        claimTotalCount = claimCount;

        // uploaderStatus.uploading = true;
        operationState = 1;

        emit Uploading_Start( epochCIDTimestamp,  epochCID,  epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount,  claimTotalAmount,  claimTotalCount);
    }

    function upload_claim(address[] calldata addies, uint256[] calldata withdrawables, uint256 cidTimestamp) nonReentrant external onlyUpLoader {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: update_claim timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == cidTimestamp /* , "everything: upload_claim wrong epoch" */);
        }

        // require(uploaderStatus.uploading, "everything: update_claim uploading not started");
        // require(!uploaderStatus.uploaderDone, "everything: update_claim uploading done");
        // require(!validatorStatus.approving, "everything: update_claim validator started");
        // require(!validatorStatus.approvingDone, "everything: update_claim validator done");
        // require(!senderStatus.sending, "everything: update_claim sender started");
        // require(!senderStatus.senderDone, "everything: update_claim sender done");

        require(operationState == 1 /* , "everything: wrong state" */);

        uint256 addlen = addies.length;
        require(addlen > 0 /* , "everything: update_claim  valid length" */);
        require(addlen == withdrawables.length /* , "everything: update_claim length not matching" */);

        // for(uint256 iii=0; iii<addlen; iii++) {
        for (uint256 iii; iii<addlen; ) {
            address thisAddress = addies[iii];
            uint256 thisAmount = withdrawables[iii];
            require(thisAddress != address(0) /* , "everything: update_claim address 0" */);
            require(thisAmount > 0 /* , "everything: update_claim amount 0" */);

            // using Map
            // userClaimsApproved[thisAddress].claimCIDTime = cidTimestamp;
            // userClaimsApproved[thisAddress].withdrawable = thisAmount;
            // userClaimsApproved[thisAddress].validated = false;             // initialize this to false

            // using Array
            userClaimsApproved.push(ApprovedClaim( thisAddress, thisAmount ));

            // cumClaimAmountUploaded = cumClaimAmountUploaded.add(thisAmount);  // todo: do not do this to save gas ?

            // emit Upload_Claim(thisAddress, thisAmount, cidTimestamp);

            unchecked {
                ++iii;
            }
        }
    }

    function uploading_done(uint256 cidTimestamp /*, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount */) nonReentrant external onlyUpLoader {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: uploading_done timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: uploading_done wrong epoch" */ );
            // require(compareStrings(cid, distributionCID), "everything: uploading_done  CID does not match");
        }

        // require(uploaderStatus.uploading, "everything: uploading_done uploading not started");
        // require(!uploaderStatus.uploaderDone, "everything: uploading_done uploading done");
        // require(!validatorStatus.approving, "everything: uploading_done validator started");
        // require(!validatorStatus.approvingDone, "everything: uploading_done validator done");
        // require(!senderStatus.sending, "everything: uploading_done sender started");
        // require(!senderStatus.senderDone, "everything: uploading_done sender done");

        require(operationState == 1 /* , "wrong state" */);
        // require(cumClaimAmountUploaded == claimTotalAmount /* , "amount wrong" */);

        // make sure global variables are right
        // require(compareStrings(epochCID, cid), "everything: uploading_done  CID does not match");
        // require(totalEquityAmount == totalEq, "everything: uploading_done total eq not correct");

        // require(claimTotalAmount == totalClaim, "everything, uploading_done right claim");
        // require(claimRemainingAmount == totalClaim, "everything, uploading_done right claim");
        // require(claimTotalCount == claimCount, "everything: uploading_done count not right");
        // require(userClaimsApproved.length == claimCount, "everything: uploading_done count not right");

        // require(epochBalanceSheetProofRoot == balanceProof, "everything: update_claim_done balance proof wrong");
        // require(epochAccountsProofRoot == accountsProof, "everything: update_claim_done acounts proof wrong");

        // uploaderStatus.uploaderDone = true;
        operationState = 2;

        emit Uploading_Done(epochCIDTimestamp /* epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, uploaderStatus.cumAmountUploaded, claimTotalCount */);
    }

    function validating_start(uint256 cidTimestamp /* , string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount */) nonReentrant external onlyValidator {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: validating_start timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: validating_start wrong epoch" */);
            // require(compareStrings(cid, distributionCID), "everything: validating_start  CID does not match");
        }

        // require(uploaderStatus.uploaderDone, "everything: validating_start uploader not done");
        // require(!validatorStatus.approving, "everything: validating_start validator started");
        // require(!validatorStatus.approvingDone, "everything: validating_start validator done");
        // require(!senderStatus.sending, "everything: validating_start sender started");
        // require(!senderStatus.senderDone, "everything: validating_start sender done");

        require(operationState == 2 /* , "everything: wrong state" */);

        // make sure global variables are right
        // require(compareStrings(epochCID, cid), "everything: validating_start  CID does not match");
        // require(totalEquityAmount == totalEq, "everything: validating_start total eq not correct");

        // require(claimTotalAmount == totalClaim, "everything, validating_start right claim");
        // require(claimRemainingAmount == totalClaim, "everything, validating_start right claim");
        // require(claimTotalCount == claimCount, "everything: validating_start count not right");
        // require(userClaimsApproved.length == claimCount, "everything: validating_start count not right");

        // require(epochBalanceSheetProofRoot == balanceProof, "everything: update_claim_done balance proof wrong");
        // require(epochAccountsProofRoot == accountsProof, "everything: update_claim_done acounts proof wrong");

        // delete validatorStatus;
        delete validatorApprovers;
        delete validatorOpposers;

        // validatorStatus.approving = true;
        // validatorStatus.approvingDone = false;

        operationState =3;

        emit Validating_Start(epochCIDTimestamp /*,  epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount */);
    }

    // validator calls only after they have validated global amounts and each individual claim amount
    function validate_claim(uint256 cidTimestamp, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount, bool valid) nonReentrant external onlyValidator {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: validate_claim timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: validate_claim wrong epoch" */);
            require(compareStrings(cid, distributionCID) /* , "everything: validate_claim  CID does not match" */);
        }

        // require(uploaderStatus.uploaderDone, "everything: validate_claim uploader not done");
        // require(validatorStatus.approving, "everything: validate_claim validator not started");
        // require(!validatorStatus.approvingDone, "everything: validate_claim validator done");
        // require(!senderStatus.sending, "everything: validate_claim sender started");
        // require(!senderStatus.senderDone, "everything: validate_claim sender done");

        require(operationState == 3 /* , "everything: wrong state" */);

        require( !_existIn(msg.sender, validatorApprovers) &&  !_existIn(msg.sender, validatorOpposers) /* , "everything: duplicated validator" */ );

        // make sure global variables are right
        require(compareStrings(epochCID, cid) /* , "everything: validate_claim CID does not match" */);
        require(totalEquityAmount == totalEq /* , "everything: validate_claim total eq not correct" */);

        require(claimTotalAmount == totalClaim /* , "everything, validate_claim right claim" */);
        require(claimRemainingAmount == totalClaim /* , "everything, validate_claim right claim" */);
        require(claimTotalCount == claimCount /* , "everything: validating_start count not right" */);
        require(userClaimsApproved.length == claimCount /* , "everything: validating_start count not right" */);

        require(epochBalanceSheetProofRoot == balanceProof /* , "everything: update_claim_done balance proof" */);
        require(epochAccountsProofRoot == accountsProof /* , "everything: update_claim_done acounts proof" */);

        if (valid) {
            validatorApprovers.push(msg.sender);
        } else {
            validatorOpposers.push(msg.sender);
        }

        emit Validate_Claim(msg.sender, epochCIDTimestamp, epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount, valid);
    }

    function validating_done(uint256 cidTimestamp, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount) nonReentrant external onlyValidator {
         // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: validating_done timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: validating_done wrong epoch" */);
            require(compareStrings(cid, distributionCID) /* , "everything: validating_done  CID does not match" */);
        }
 
        // require(uploaderStatus.uploaderDone, "everything: validating_done uploader not done");
        // require(validatorStatus.approving, "everything: validating_done validator not started");
        // require(!validatorStatus.approvingDone, "everything: validating_done validator done");
        // require(!senderStatus.sending, "everything: validating_done sender started");
        // require(!senderStatus.senderDone, "everything: validating_done sender done");

        require(operationState == 3 /* , "everything: wrong state" */);
        
        // make sure global variables are right
        require(compareStrings(epochCID, cid) /* , "everything: validating_done CID does not match" */);
        require(totalEquityAmount == totalEq /* , "everything: validating_done total eq not correct" */);

        require(claimTotalAmount == totalClaim /* , "everything, validating_done right claim" */);
        require(claimRemainingAmount == totalClaim /* , "everything, validating_done right claim" */);
        require(claimTotalCount == claimCount /*, "everything: validating_done count not right" */);
        require(userClaimsApproved.length == claimCount /* , "everything: validating_done count not right" */);

        require(epochBalanceSheetProofRoot == balanceProof /* , "everything: update_claim_done balance proof not correct" */);
        require(epochAccountsProofRoot == accountsProof /*, "everything: update_claim_done acounts proof not correct" */);

        require( !_isValidatorOpposed( validatorOpposers.length ) /*, "everything: validating_done has been opposed" */);
        require( _isValidatorApproved( validatorApprovers.length ) /*, "everything: validating_done count not reach min approve ratio yet" */);

        // validatorStatus.approvingDone = true;
        operationState = 4;

        emit Validating_Done(epochCIDTimestamp /*,  epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount, validatorStatus.approvingDone */);
    }


    function sending_start(uint256 cidTimestamp, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount) nonReentrant external onlySender {
         // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: sending_start timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /*, "everything: sending_start wrong epoch" */);
            require(compareStrings(cid, distributionCID) /*, "everything: sending_start  CID does not match" */);
            require(block.timestamp >= toDistributeTime /* , "everything: sending_start only after distributing time" */);
        }
 
        // require(uploaderStatus.uploaderDone, "everything: sending_start uploader not done");
        // require(validatorStatus.approvingDone, "everything: sending_start validator not done");
        // require(!senderStatus.sending, "everything: sending_start sender started");
        // require(!senderStatus.senderDone, "everything: sending_start sender done");

        require(operationState == 4 /*, "everything: wrong state" */);
        
        // make sure global variables are right
        require(compareStrings(epochCID, cid) /* , "everything: sending_start  CID does not match" */);
        require(totalEquityAmount == totalEq /* , "everything: sending_start total eq not correct" */);

        require(claimTotalAmount == totalClaim /* , "everything, sending_start claim not correct" */);
        require(claimRemainingAmount == totalClaim /* , "everything, sending_start claim not correct" */);
        require(claimTotalCount == claimCount /* , "everything: sending_start count not correct" */);
        require(userClaimsApproved.length == claimCount /* , "everything: sending_start count not correct" */);

        require(epochBalanceSheetProofRoot == balanceProof /* , "everything: update_claim_done balance proof not corret" */);
        require(epochAccountsProofRoot == accountsProof /* , "everything: update_claim_done acounts proof not correct" */);

        // delete senderStatus;
        // senderStatus.sending = true;
        // senderStatus.senderDone = false;
        operationState = 5;

        emit Sending_Start(epochCIDTimestamp /*, epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount */);
    }

    function sendToAddress(uint256 cidTimestamp) nonReentrant external onlySender {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: sendToAddress timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: sendToAddress wrong epoch" */);
            // require(compareStrings(epochCID, distributionCID), "everything: sendToAddress  CID does not match");
            require(block.timestamp >= toDistributeTime /* , "everything: sendToAddress only after distributing time" */);
        }

        // require(uploaderStatus.uploaderDone, "everything: sendToAddress uploader not done");
        // require(validatorStatus.approvingDone, "everything: sendToAddress validator not done");
        // require(senderStatus.sending, "everything: sendToAddress sender has not started");
        // require(!senderStatus.senderDone, "everything: sendToAddress sender has done");

        require(operationState == 5 /* , "everything: wrong state" */);

        require(claimRemainingAmount <= claimTotalAmount /* , "everything: sendToAddress remaining amount not correct" */);

        uint256 idx = userClaimsApproved.length-1;
        require(idx >=0 /* , "everything: sendToAddress no data left" */);
        address sending_address = userClaimsApproved[idx].withdrawAddress;
        require(sending_address != address(0) /* , "everything: sendToAddress none zero address" */);
        uint256 sending_amount = userClaimsApproved[idx].withdrawable;
        require(sending_amount > 0 /* , "everything: sendToAddress none zero amount" */);
        require(sending_amount <= claimRemainingAmount /* , "everything: sendToAddress wrong sending amount" */);

        claimRemainingAmount = claimRemainingAmount.sub( sending_amount );
        userClaimsApproved.pop();
        // delete userClaimsApproved[sending_address];

        collateralToken.safeTransfer(sending_address, sending_amount);

        emit SentClaimToAddress(sending_address, sending_amount, cidTimestamp);
    }

    function sending_done(uint256 cidTimestamp, string calldata cid) nonReentrant external onlySender {
        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: sender_done timestamp not correct" */);

        if (emergencyState > 0) {
            require(distributionCIDTime == epochCIDTimestamp /* , "everything: sending_done wrong epoch" */);
            require(compareStrings(cid, distributionCID) /* , "everything: sending_done  CID does not match" */);
            require(block.timestamp >= toDistributeTime /* , "everything: sending_done only after distributing time" */);
        }

        // require(uploaderStatus.uploaderDone, "everything: sender_done upload not done");
        // require(validatorStatus.approvingDone, "everything: sender_done validator not done");
        // require(senderStatus.sending, "everything: sender_done sender has not started");
        // require(!senderStatus.senderDone, "everything: sender_done sender done");

        require(operationState == 5 /* , "everything: wrong state" */);

        // make sure global variables are right
        // bool cidOk = compareStrings(epochCID, cid);
        // require(cidOk, "everything: sending_done CID does not match");
        // require(totalEquityAmount == totalEq, "everything: validate_claim total eq not correct");

        // require(claimTotalAmount == totalClaim, "everything, validate_claim claim not correct");
        // require(claimTotalCount == claimCount, "everything: validating_start count not correct");

        // require(epochBalanceSheetProofRoot == balanceProof, "everything: update_claim_done balance proof not correct");
        // require(epochAccountsProofRoot == accountsProof, "everything: update_claim_done acounts proof not correct");

        require(userClaimsApproved.length == 0 /* , "everything: claim has not been fully processed" */);
        require(claimRemainingAmount == 0 /* , "everything: claim has not been fully processed" */);

        // senderStatus.senderDone = true;
        operationState = 6;

        emit Sending_Done(epochCIDTimestamp /*, epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount */);
    }

    function validating_cleanup(uint256 cidTimestamp, string calldata cid, bytes32 balanceProof, bytes32 accountsProof, uint256 totalEq, uint256 totalClaim, uint256 claimCount) nonReentrant external onlyValidator {
        if (emergencyState > 0 && epochCIDTimestamp != cidTimestamp) {
            // in emergency state, the smart contract fund movement is frozen.
            // validator needs to clean up to restart the fund distribution process

            // delete validatorStatus;
            delete validatorApprovers;
            delete validatorOpposers;
            // delete senderStatus;

            operationState = 0;

            emit Validating_Cleanup(epochCIDTimestamp /* , epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount */);

            return;
            
            // require(distributionCIDTime == epochCIDTimestamp, "everything: validating_cleanup wrong epoch");
            // require(compareStrings(cid, distributionCID), "everything: validating_cleanup  CID does not match");
            // require(block.timestamp >= toDistributeTime, "everything: validating_cleanup only after distributing time");
        }

        // make sure we are in the right state of operation
        require(epochCIDTimestamp == cidTimestamp /* , "everything: validating_cleanup timestamp not correct" */);

        // require(uploaderStatus.uploaderDone, "everything: validating_cleanup not done");
        // require(validatorStatus.approvingDone, "everything: validating_cleanup validator not done");
        // require(senderStatus.senderDone, "everything: validating_cleanup sender not done");

        require(operationState == 6 /* , "everything: wrong state" */);

        // make sure global variables are right
        require(compareStrings(epochCID, cid) /* , "everything: validating_cleanup CID does not match" */ );
        require(totalEquityAmount == totalEq /* , "everything: validate_claim total eq not correct" */ );

        require(claimTotalAmount == totalClaim /* , "everything, validate_claim claim is not correct" */);
        require(claimTotalCount == claimCount /* , "everything: validating_start count not correct" */);

        require(epochBalanceSheetProofRoot == balanceProof /* , "everything: update_claim_done balance proof not correct" */ );
        require(epochAccountsProofRoot == accountsProof /* , "everything: update_claim_done acounts proof not correct" */ );

        require(userClaimsApproved.length == 0 /* , "everything: validating_cleanup claims have not been fully processed" */ );
        require(claimRemainingAmount == 0 /* , "everything: validating_cleanup  claims have not been fully processed" */ );

        // delete validatorStatus;
        delete validatorApprovers;
        delete validatorOpposers;
        // delete senderStatus;

        operationState = 0;

        emit Validating_Cleanup(epochCIDTimestamp /* , epochCID, epochBalanceSheetProofRoot, epochAccountsProofRoot, totalEquityAmount, claimTotalAmount, claimTotalCount */);
    }

    /* ========== RESTRICTED FUNCTIONS ========== */


    /* ========== MODIFIERS ========== */
    modifier onlyGovToken() {
        require(theGovernanceToken != address(0) && msg.sender == theGovernanceToken /* , "everything: caller is not govToken" */ );
        _;
    }

    modifier onlyUpLoader() {
        require(uploader != address(0) && msg.sender == uploader /* , "everything: caller is not uploader" */ );
        _;
    }

    modifier onlyValidator() {
        uint idx = validators[msg.sender];
        require(idx < validatorsArray.length && msg.sender == validatorsArray[idx] /* , "everything: caller is not validator" */);
        _;
    }

    modifier onlySender() {
        require(sender != address(0) && msg.sender == sender /* , "everything: caller is not sender" */);
        _;
    }

    /* ========== EVENTS ========== */
    event Uploading_Start(uint256 cidTimestamp, string cid, bytes32 balance, bytes32 accounts, uint256 totalEquityAmount,  uint256 claimTotalAmount,  uint256 claimTotalCount);
    event Upload_Claim(address indexed thisAddress, uint256 thisAmount, uint256 timestamp);
    event Uploading_Done(uint256 cidTimestamp /*, string cid, bytes32 balance, bytes32 accounts, uint256 cumAmount, uint256 claimCount */);

    event Validating_Start(uint256 cidTimestamp /*, string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256 totalClaim, uint256 claimCount */);
    event Validate_Claim(address indexed thisAddress, uint256 cidTimestamp, string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256 totalClaim, uint256 claimCount, bool valid);
    event Validating_Done(uint256 cidTimestamp /*, string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256 totalClaim, uint256 claimCount, bool validated */);
    event Validating_Cleanup(uint256 cidTimestamp /*, string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256 totalClaim, uint256 claimCount */);

    event Sending_Start(uint256 cidTimestamp /* , string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256  totalClaim, uint256 claimCount */);
    event SentClaimToAddress(address indexed user, uint256 amount, uint256 cidTimestamp);
    event Sending_Done(uint256 cidTimestamp /*, string cid, bytes32 balance, bytes32 accounts, uint256 totalEq, uint256 totalClaim, uint256 claimCount */);

    event NewUploaderSet(address indexed newUploader);
    event NewValidatorSet(address indexed newValidator);
    event NewSenderSet(address indexed newSender);
    event SetDistribution(uint state, uint256 distributeTime, uint256 cidTime, string cid);
}

contract EverythingGov is ReentrancyGuard, EverythingAdmin {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    /* ========== STATE VARIABLES ========== */
    address public everythingContract;
    bool public toDistribute;

    constructor(
        address _owner
    ) Ownable(_owner) {
        toDistribute = false;
    }

    function setEverythingContractAddress(address everythingAddress) nonReentrant  external onlyAdmin {
        require(everythingAddress != address(0) /* , "EverythingGov: zero address not allowed" */ );
        everythingContract = everythingAddress;

        emit SetEverythingContractAddress(everythingAddress);
    }

    function setEverythingAdmin() nonReentrant external onlyAdmin {
        require(everythingContract != address(0) /* , "EverthingGov: zero address not allowed" */);
        Everything everything = Everything(everythingContract);

        require(everythingUploader != address(0) /* , "EverthingGov: zero address not allowed" */);
        uint256 validatorsLen = everythingValidators.length;
        require(validatorsLen > 0 /* , "EverthingGov: more than 1 validator" */);
        for (uint256 iii = 0; iii<validatorsLen; iii++) {
            address newValidator = everythingValidators[iii];
            require(newValidator != address(0) /* , "EverthingGov: zero address not allowed" */ );
        }
        require(everythingSender != address(0) /* , "EverthingGov: zero address not allowed" */);

        everything.setOperationAddresses( everythingUploader, everythingValidators, everythingSender );

        emit SetEverythingAdmin(everythingUploader, everythingValidators, everythingSender);
    }

    function setEverythingDistribution() nonReentrant external onlyAdmin {
        Everything everything = Everything(everythingContract);

        // require(emergencyState > 0 /* , "EverythingGov: require on" */);   // cannot be reversed

        everything.setDistribution( emergencyState, theDistributionTime, distributionCIDTimestamp, distributionCID );

        emit SetEverythingDistribution(emergencyState, theDistributionTime, distributionCIDTimestamp, distributionCID);
    }

    event SetEverythingContractAddress(address indexed everything);
    event SetEverythingAdmin(address indexed everythingUploader, address[] everythingValidators, address indexed everythingSender);
    event SetEverythingDistribution(uint state, uint256 theDistributionTime, uint256 distributionCIDTimestamp, string distributionCID);
}

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_collateralToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newSender","type":"address"}],"name":"NewSenderSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newUploader","type":"address"}],"name":"NewUploaderSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newValidator","type":"address"}],"name":"NewValidatorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipProposed","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":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Sending_Done","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Sending_Start","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"SentClaimToAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"state","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"distributeTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cidTime","type":"uint256"},{"indexed":false,"internalType":"string","name":"cid","type":"string"}],"name":"SetDistribution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"thisAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"thisAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"Upload_Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Uploading_Done","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"indexed":false,"internalType":"string","name":"cid","type":"string"},{"indexed":false,"internalType":"bytes32","name":"balance","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"accounts","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"totalEquityAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimTotalAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimTotalCount","type":"uint256"}],"name":"Uploading_Start","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"thisAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"indexed":false,"internalType":"string","name":"cid","type":"string"},{"indexed":false,"internalType":"bytes32","name":"balance","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"accounts","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"totalEq","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalClaim","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claimCount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"valid","type":"bool"}],"name":"Validate_Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Validating_Cleanup","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Validating_Done","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"Validating_Start","type":"event"},{"inputs":[],"name":"EVERYTHING_MIN_APPROVE_RATIO","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EVERYTHING_RATIO_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EVERYTHING_RATIO_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimRemainingAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimTotalAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimTotalCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"collateralToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributionCID","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributionCIDTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyState","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochAccountsProofRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochBalanceSheetProofRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochCID","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"epochCIDTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"startIdx","type":"uint256"}],"name":"getCurrentClaims","outputs":[{"internalType":"address[100]","name":"claimers","type":"address[100]"},{"internalType":"uint256[100]","name":"claimedAmounts","type":"uint256[100]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentClaimsCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentValidationStatus","outputs":[{"internalType":"uint256","name":"timeStamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"address[]","name":"approvers","type":"address[]"},{"internalType":"address[]","name":"opposers","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operationState","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"proposeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"sendToAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sender","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"}],"name":"sending_done","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"bytes32","name":"balanceProof","type":"bytes32"},{"internalType":"bytes32","name":"accountsProof","type":"bytes32"},{"internalType":"uint256","name":"totalEq","type":"uint256"},{"internalType":"uint256","name":"totalClaim","type":"uint256"},{"internalType":"uint256","name":"claimCount","type":"uint256"}],"name":"sending_start","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"state","type":"uint256"},{"internalType":"uint256","name":"distributeTime","type":"uint256"},{"internalType":"uint256","name":"cidTime","type":"uint256"},{"internalType":"string","name":"cid","type":"string"}],"name":"setDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newUploader","type":"address"},{"internalType":"address[]","name":"newValidators","type":"address[]"},{"internalType":"address","name":"newSender","type":"address"}],"name":"setOperationAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"govToken","type":"address"}],"name":"set_governance_token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"takeOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"theGovernanceToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toDistributeTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalEquity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalEquityAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addies","type":"address[]"},{"internalType":"uint256[]","name":"withdrawables","type":"uint256[]"},{"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"upload_claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uploader","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"uploading_done","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"bytes32","name":"balanceProof","type":"bytes32"},{"internalType":"bytes32","name":"accountsProof","type":"bytes32"},{"internalType":"uint256","name":"totalEq","type":"uint256"},{"internalType":"uint256","name":"totalClaim","type":"uint256"},{"internalType":"uint256","name":"claimCount","type":"uint256"}],"name":"uploading_start","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"userClaimsApproved","outputs":[{"internalType":"address","name":"withdrawAddress","type":"address"},{"internalType":"uint256","name":"withdrawable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"bytes32","name":"balanceProof","type":"bytes32"},{"internalType":"bytes32","name":"accountsProof","type":"bytes32"},{"internalType":"uint256","name":"totalEq","type":"uint256"},{"internalType":"uint256","name":"totalClaim","type":"uint256"},{"internalType":"uint256","name":"claimCount","type":"uint256"},{"internalType":"bool","name":"valid","type":"bool"}],"name":"validate_claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"bytes32","name":"balanceProof","type":"bytes32"},{"internalType":"bytes32","name":"accountsProof","type":"bytes32"},{"internalType":"uint256","name":"totalEq","type":"uint256"},{"internalType":"uint256","name":"totalClaim","type":"uint256"},{"internalType":"uint256","name":"claimCount","type":"uint256"}],"name":"validating_cleanup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"},{"internalType":"string","name":"cid","type":"string"},{"internalType":"bytes32","name":"balanceProof","type":"bytes32"},{"internalType":"bytes32","name":"accountsProof","type":"bytes32"},{"internalType":"uint256","name":"totalEq","type":"uint256"},{"internalType":"uint256","name":"totalClaim","type":"uint256"},{"internalType":"uint256","name":"claimCount","type":"uint256"}],"name":"validating_done","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cidTimestamp","type":"uint256"}],"name":"validating_start","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validatorApprovers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validatorOpposers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"validators","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"validatorsArray","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

35722:35959:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36434:32;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;363:32:1;;;345:51;;333:2;318:18;36434:32:0;;;;;;;;56147:2730;;;;;;:::i;:::-;;:::i;:::-;;35914:53;;35966:1;35914:53;;;;;1734:25:1;;;1722:2;1707:18;35914:53:0;1588:177:1;48309:2527:0;;;;;;:::i;:::-;;:::i;39375:36::-;;;;;;:::i;:::-;;:::i;38079:35::-;;;;;;50844:2551;;;;;;:::i;:::-;;:::i;58887:2505::-;;;;;;:::i;:::-;;:::i;36120:59::-;;36175:4;36120:59;;65889:3130;;;;;;:::i;:::-;;:::i;37197:37::-;;;;;;40833:347;;;:::i;:::-;;;;;;;;;;:::i;36859:29::-;;;:::i;:::-;;;;;;;:::i;38537:41::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4222:32:1;;;4204:51;;4286:2;4271:18;;4264:34;;;;4177:18;38537:41:0;4030:274:1;8871:166:0;;;:::i;37062:41::-;;;;;;42367:1216;;;;;;:::i;:::-;;:::i;36378:23::-;;;;;-1:-1:-1;;;;;36378:23:0;;;38121:30;;;;;;41312:640;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;36633:21::-;;;;;-1:-1:-1;;;;;36633:21:0;;;45921:2380;;;;;;:::i;:::-;;:::i;36780:31::-;;;;;;61400:2160;;;;;;:::i;:::-;;:::i;38740:29::-;;;;;;8093:83;8163:5;;-1:-1:-1;;;;;8163:5:0;8093:83;;43591:599;;;;;;:::i;:::-;;:::i;7586:20::-;;;;;-1:-1:-1;;;;;7586:20:0;;;38041:31;;;;;;35997:84;;;:::i;63568:2313::-;;;;;;:::i;:::-;;:::i;39981:98::-;40054:17;;39981:98;;36311:29;;;;;-1:-1:-1;;;;;36311:29:0;;;41188:116;41271:18;:25;41188:116;;8531:227;;;;;;:::i;:::-;;:::i;36818:34::-;;;;;;36993:23;;;:::i;42012:347::-;;;;;;:::i;:::-;;:::i;53506:2633::-;;;;;;:::i;:::-;;:::i;36954:32::-;;;;;;36271:33;;;;;-1:-1:-1;;;;;36271:33:0;;;37023:32;;;;;;36696:26;;;;;;36519:42;;;;;;:::i;:::-;;;;;;;;;;;;;;44198:1715;;;;;;:::i;:::-;;:::i;39418:35::-;;;;;;:::i;:::-;;:::i;36434:32::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36434:32:0;;-1:-1:-1;36434:32:0;:::o;56147:2730::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;;69538:10:::1;69527:22:::0;;:10:::1;:22;::::0;;;;;;69574:15:::1;:22:::0;69568:28;::::1;:66:::0;::::1;;;;69614:15;69630:3;69614:20;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;69614:20:0::1;69600:10;:34;69568:66;69560:121;;;::::0;::::1;;56455:12:::2;56434:17;;:33;56426:102;;;::::0;::::2;;56545:14;::::0;:18;56541:268:::2;;56611:17;;56588:19;;:40;56580:99;;;::::0;::::2;;56702:36;56717:3;;56702:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;56722:15:0::2;56702:36:::0;;56722:15;;-1:-1:-1;56702:36:0::2;::::0;-1:-1:-1;56702:36:0::2;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:14;:36::i;:::-;56694:103;;;::::0;::::2;;57311:14;;57329:1;57311:19;57303:62;;;::::0;::::2;;57443:29;57458:8;57443:29;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57468:3;;57443:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;57443:14:0::2;::::0;-1:-1:-1;;;57443:29:0:i:2;:::-;57435:95;;;::::0;::::2;;57570:7;57549:17;;:28;57541:96;;;::::0;::::2;;57678:10;57658:16;;:30;57650:89;;;::::0;::::2;;57782:10;57758:20;;:34;57750:93;;;::::0;::::2;;57881:10;57862:15;;:29;57854:91;;;::::0;::::2;;57964:18;:25:::0;:39;::::2;57956:102;;;::::0;::::2;;58109:12;58079:26;;:42;58071:117;;;::::0;::::2;;58233:13;58207:22;;:39;58199:113;;;::::0;::::2;;58356:17;:24:::0;58335:47:::2;::::0;:19:::2;:47::i;:::-;58334:48;58325:112;;;::::0;::::2;;58479:18;:25:::0;58457:49:::2;::::0;:20:::2;:49::i;:::-;58448:134;;;::::0;::::2;;58662:1;58645:14;:18:::0;58697:17:::2;::::0;58681:188:::2;::::0;1734:25:1;;;58681:188:0::2;::::0;1722:2:1;1707:18;58681:188:0::2;;;;;;;;69505:196:::1;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;:::-;;;;;;;;;32326:180;56147:2730;;;;;;;;:::o;48309:2527::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69357:8:::1;::::0;-1:-1:-1;;;;;69357:8:0::1;:22:::0;;::::1;::::0;:48:::1;;-1:-1:-1::0;69397:8:0::1;::::0;-1:-1:-1;;;;;69397:8:0::1;69383:10;:22;69357:48;69349:103;;;::::0;::::1;;48620:12:::2;48599:17;;:33;48591:101;;;::::0;::::2;;48709:14;::::0;:18;48705:263:::2;;48775:17;;48752:19;;:40;48744:99;;;::::0;::::2;;49558:14;;49576:1;49558:19;49550:50;;;::::0;::::2;;50658:1;50641:14;:18:::0;50692:17:::2;::::0;50677:151:::2;::::0;1734:25:1;;;50677:151:0::2;::::0;1722:2:1;1707:18;50677:151:0::2;;;;;;;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;:::-;32326:180;48309:2527;:::o;39375:36::-;;;;;;;;;;;;50844:2551;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;;69538:10:::1;69527:22:::0;;:10:::1;:22;::::0;;;;;;69574:15:::1;:22:::0;69568:28;::::1;:66:::0;::::1;;;;69614:15;69630:3;69614:20;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;69614:20:0::1;69600:10;:34;69568:66;69560:121;;;::::0;::::1;;51159:12:::2;51138:17;;:33;51130:103;;;::::0;::::2;;51250:14;::::0;:18;51246:266:::2;;51316:17;;51293:19;;:40;51285:100;;;::::0;::::2;;52015:14;;52033:1;52015:19;52007:62;;;::::0;::::2;;53022:25;53029:18;;53022:25;:::i;:::-;53058:24;53065:17;;53058:24;:::i;:::-;53210:1;53194:14;:17:::0;53246::::2;::::0;53229:158:::2;::::0;1734:25:1;;;53229:158:0::2;::::0;1722:2:1;1707:18;53229:158:0::2;;;;;;;69505:196:::1;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;58887:2505::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69750:6:::1;::::0;-1:-1:-1;;;;;69750:6:0::1;:20:::0;;::::1;::::0;:44:::1;;-1:-1:-1::0;69788:6:0::1;::::0;-1:-1:-1;;;;;69788:6:0::1;69774:10;:20;69750:44;69742:96;;;::::0;::::1;;59190:12:::2;59169:17;;:33;59161:100;;;::::0;::::2;;59278:14;::::0;:18;59274:386:::2;;59344:17;;59321:19;;:40;59313:96;;;::::0;::::2;;59432:36;59447:3;;59432:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;59452:15:0::2;59432:36:::0;;59452:15;;-1:-1:-1;59432:36:0::2;::::0;-1:-1:-1;59432:36:0::2;:::i;:::-;59424:100;;;::::0;::::2;;59566:16;;59547:15;:35;;59539:109;;;::::0;::::2;;60056:14;;60074:1;60056:19;60048:61;;;::::0;::::2;;60187:29;60202:8;60187:29;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60212:3;;60187:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;60187:14:0::2;::::0;-1:-1:-1;;;60187:29:0:i:2;:::-;60179:94;;;::::0;::::2;;60313:7;60292:17;;:28;60284:94;;;::::0;::::2;;60419:10;60399:16;;:30;60391:93;;;::::0;::::2;;60527:10;60503:20;;:34;60495:97;;;::::0;::::2;;60630:10;60611:15;;:29;60603:92;;;::::0;::::2;;60714:18;:25:::0;:39;::::2;60706:102;;;::::0;::::2;;60859:12;60829:26;;:42;60821:116;;;::::0;::::2;;60982:13;60956:22;;:39;60948:114;;;::::0;::::2;;61211:1;61194:14;:18:::0;61244:17:::2;::::0;61230:154:::2;::::0;1734:25:1;;;61230:154:0::2;::::0;1722:2:1;1707:18;61230:154:0::2;;;;;;;;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;65889:3130::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;;69538:10:::1;69527:22:::0;;:10:::1;:22;::::0;;;;;;69574:15:::1;:22:::0;69568:28;::::1;:66:::0;::::1;;;;69614:15;69630:3;69614:20;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;69614:20:0::1;69600:10;:34;69568:66;69560:121;;;::::0;::::1;;66130:1:::2;66113:14;;:18;:55;;;;;66156:12;66135:17;;:33;;66113:55;66109:1005;;;66392:25;66399:18;;66392:25;:::i;:::-;66432:24;66439:17;;66432:24;:::i;:::-;66527:1;66510:14;:18:::0;66569:17:::2;::::0;66550:160:::2;::::0;1734:25:1;;;66550:160:0::2;::::0;1722:2:1;1707:18;66550:160:0::2;;;;;;;66727:7;;66109:1005;67216:12;67195:17;;:33;67187:105;;;::::0;::::2;;67609:14;;67627:1;67609:19;67601:62;;;::::0;::::2;;67733:29;67748:8;67733:29;;;;;:::i;:::-;67725:99;;;::::0;::::2;;67864:7;67843:17;;:28;67835:96;;;::::0;::::2;;67972:10;67952:16;;:30;67944:97;;;::::0;::::2;;68079:10;68060:15;;:29;68052:95;;;::::0;::::2;;68198:12;68168:26;;:42;68160:118;;;::::0;::::2;;68323:13;68297:22;;:39;68289:115;;;::::0;::::2;;68425:18;:25:::0;:30;68417:118:::2;;;::::0;::::2;;68554:20;::::0;:25;68546:114:::2;;;::::0;::::2;;68709:25;68716:18;;68709:25;:::i;:::-;68745:24;68752:17;;68745:24;:::i;:::-;68832:1;68815:14;:18:::0;68870:17:::2;::::0;68851:160:::2;::::0;1734:25:1;;;68851:160:0::2;::::0;1722:2:1;1707:18;68851:160:0::2;1588:177:1::0;69692:1:0::2;69505:196:::1;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;40833:347::-;40901:21;40933:17;40961:27;40999:26;41052:17;;41089:8;41116:18;41154:17;41044:128;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41044:128:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41044:128:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40833:347;;;;:::o;36859:29::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;38537:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;38537:41:0;;;;-1:-1:-1;38537:41:0;:::o;8871:166::-;8922:13;;-1:-1:-1;;;;;8922:13:0;8939:10;8922:27;8914:71;;;;-1:-1:-1;;;8914:71:0;;11184:2:1;8914:71:0;;;11166:21:1;11223:2;11203:18;;;11196:30;11262:33;11242:18;;;11235:61;11313:18;;8914:71:0;10982:355:1;8914:71:0;9015:13;;8996:33;;-1:-1:-1;;;;;9015:13:0;8996:18;:33::i;:::-;8871:166::o;42367:1216::-;69171:18;;-1:-1:-1;;;;;69171:18:0;:32;;;;:68;;-1:-1:-1;69221:18:0;;-1:-1:-1;;;;;69221:18:0;69207:10;:32;69171:68;69163:123;;;;;;-1:-1:-1;;;;;42515:25:0;::::1;42507:74;;;::::0;::::1;;-1:-1:-1::0;;;;;42600:23:0;::::1;42592:70;;;::::0;::::1;;42692:13:::0;42732:10;42723:65:::1;;;::::0;::::1;;42804:11;42799:195;42823:6;42819:3;:10;42799:195;;;42853:20;42876:13;;42890:3;42876:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;42853:41:::0;-1:-1:-1;;;;;;42917:26:0;::::1;42909:73;;;::::0;::::1;;-1:-1:-1::0;42831:5:0;::::1;::::0;::::1;:::i;:::-;;;;42799:195;;;-1:-1:-1::0;43006:22:0::1;43013:15;;43006:22;:::i;:::-;43073:8;:22:::0;;-1:-1:-1;;;;;43073:22:0;;::::1;-1:-1:-1::0;;;;;;43073:22:0;;::::1;;::::0;;;43106:6:::1;:18:::0;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;43073:8:::1;43135:198;43156:6;43152:3;:10;43135:198;;;43186:20;43209:13;;43223:3;43209:18;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;43242:24:0::1;;::::0;;;:10:::1;:24;::::0;;;;:30;;;43287:15:::1;:34:::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;;-1:-1:-1;;;;;;43287:34:0::1;::::0;;::::1;::::0;;-1:-1:-1;43269:3:0;43164:5:::1;43269:3:::0;43164:5:::1;:::i;:::-;;;;43135:198;;;-1:-1:-1::0;43365:8:0::1;::::0;43350:24:::1;::::0;-1:-1:-1;;;;;43365:8:0;;::::1;::::0;43350:24:::1;::::0;43365:8:::1;::::0;43350:24:::1;43390:8;43385:155;43406:6;43402:3;:10;43385:155;;;43436:20;43459:15;43475:3;43459:20;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;::::1;::::0;43499:29:::1;::::0;-1:-1:-1;;;;;43459:20:0;;::::1;::::0;-1:-1:-1;43459:20:0;;43499:29:::1;::::0;::::1;-1:-1:-1::0;43414:5:0;::::1;::::0;::::1;:::i;:::-;;;;43385:155;;;-1:-1:-1::0;43568:6:0::1;::::0;43555:20:::1;::::0;-1:-1:-1;;;;;43568:6:0;;::::1;::::0;43555:20:::1;::::0;43568:6:::1;::::0;43555:20:::1;42496:1087;42367:1216:::0;;;;:::o;41312:640::-;41386:29;;:::i;:::-;41426:35;;:::i;:::-;41480:29;;:::i;:::-;41520:28;;:::i;:::-;41561:18;41582:50;41592:12;:8;41601:3;41592:12;:::i;:::-;41606:18;:25;41582:8;:50::i;:::-;41561:71;-1:-1:-1;41661:8:0;41643:248;41676:10;41671:3;:15;41643:248;;;41710:12;41725:14;41731:8;41725:3;:14;:::i;:::-;41710:29;;41772:18;41791:3;41772:23;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:39;-1:-1:-1;;;;;41772:39:0;41754:9;41764:4;41754:15;;;;;;;:::i;:::-;-1:-1:-1;;;;;41754:57:0;;;:15;;;;;;:57;41843:18;:23;;41862:3;;41843:23;;;;;;:::i;:::-;;;;;;;;;;;:36;;;41826:8;41835:4;41826:14;;;;;;;:::i;:::-;;;;:53;-1:-1:-1;41688:5:0;;;;:::i;:::-;;;;41643:248;;;-1:-1:-1;41911:9:0;;41935:8;;-1:-1:-1;41312:640:0;-1:-1:-1;;;41312:640:0:o;45921:2380::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69357:8:::1;::::0;-1:-1:-1;;;;;69357:8:0::1;:22:::0;;::::1;::::0;:48:::1;;-1:-1:-1::0;69397:8:0::1;::::0;-1:-1:-1;;;;;69397:8:0::1;69383:10;:22;69357:48;69349:103;;;::::0;::::1;;46162:12:::2;46141:17;;:33;46133:99;;;::::0;::::2;;46249:14;::::0;:18;46245:142:::2;;46315:12;46292:19;;:35;46284:91;;;::::0;::::2;;46965:14;;46983:1;46965:19;46957:62;;;::::0;::::2;;47049:6:::0;47081:10;47073:68:::2;;;::::0;::::2;;47160:30:::0;;::::2;47152:94;;;::::0;::::2;;47316:11;47311:983;47333:6;47329:3;:10;47311:983;;;47358:19;47380:6;;47387:3;47380:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;47358:33;;47406:18;47427:13;;47441:3;47427:18;;;;;;;:::i;:::-;;;::::0;;;::::2;;::::0;-1:-1:-1;;;;;;;47468:25:0;::::2;47460:79;;;::::0;::::2;;47575:1;47562:10;:14;47554:67;;;::::0;::::2;;47977:40;::::0;;;;::::2;::::0;;;-1:-1:-1;;;;;47977:40:0;;::::2;::::0;;::::2;::::0;::::2;::::0;;;47953:18:::2;:65:::0;;::::2;::::0;;::::2;::::0;;-1:-1:-1;47953:65:0;;;;;;;::::2;::::0;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;;47953:65:0::2;::::0;;;::::2;;::::0;;;;;;;;;;48262:5:::2;47311:983;;;;46061:2240;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;:::-;32326:180;45921:2380;;;;;:::o;61400:2160::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69750:6:::1;::::0;-1:-1:-1;;;;;69750:6:0::1;:20:::0;;::::1;::::0;:44:::1;;-1:-1:-1::0;69788:6:0::1;::::0;-1:-1:-1;;;;;69788:6:0::1;69774:10;:20;69750:44;69742:96;;;::::0;::::1;;61579:12:::2;61558:17;;:33;61550:100;;;::::0;::::2;;61667:14;::::0;:18;61663:389:::2;;61733:17;;61710:19;;:40;61702:97;;;::::0;::::2;;61958:16;;61939:15;:35;;61931:109;;;::::0;::::2;;62458:14;;62476:1;62458:19;62450:62;;;::::0;::::2;;62557:16;;62533:20;;:40;;62525:114;;;::::0;::::2;;62666:18;:25:::0;62652:11:::2;::::0;62666:27:::2;::::0;62692:1:::2;::::0;62666:27:::2;:::i;:::-;62652:41:::0;-1:-1:-1;62780:23:0::2;62806:18;62825:3;62806:23;;;;;;;;:::i;:::-;;::::0;;;::::2;::::0;;;::::2;::::0;;::::2;;:39:::0;-1:-1:-1;;;;;62806:39:0::2;::::0;-1:-1:-1;62864:29:0;62856:92:::2;;;::::0;::::2;;62959:22;62984:18;63003:3;62984:23;;;;;;;;:::i;:::-;;;;;;;;;;;:36;;;62959:61;;63056:1;63039:14;:18;63031:80;;;::::0;::::2;;63148:20;;63130:14;:38;;63122:104;;;::::0;::::2;;63262:20;::::0;:42:::2;::::0;63288:14;63262:24:::2;:42::i;:::-;63239:20;:65:::0;63315:18:::2;:24:::0;;;::::2;;;;:::i;:::-;;::::0;;;::::2;::::0;;::::2;-1:-1:-1::0;;63315:24:0;;;;;::::2;;::::0;;-1:-1:-1;;;;;;63315:24:0::2;::::0;;::::2;;::::0;;;63408:15:::2;::::0;:61:::2;::::0;-1:-1:-1;;;;;63408:15:0::2;63437::::0;63454:14;63408:28:::2;:61::i;:::-;63487:65;::::0;;11918:25:1;;;11974:2;11959:18;;11952:34;;;-1:-1:-1;;;;;63487:65:0;::::2;::::0;::::2;::::0;11891:18:1;63487:65:0::2;;;;;;;61478:2082;;;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;43591:599::-;69171:18;;-1:-1:-1;;;;;69171:18:0;:32;;;;:68;;-1:-1:-1;69221:18:0;;-1:-1:-1;;;;;69221:18:0;69207:10;:32;69171:68;69163:123;;;;;;43750:1:::1;43733:14;;:18;43725:56;;;::::0;::::1;;43796:5;43805:1;43796:10;43792:133;;;43848:15;43831:14;:32;43823:90;;;::::0;::::1;;43974:14;:22:::0;;;44007:16:::1;:33:::0;;;44051:19:::1;:29:::0;;;44091:21:::1;:15;44109:3:::0;;44091:21:::1;:::i;:::-;;44130:52;44146:5;44153:14;44169:7;44178:3;;44130:52;;;;;;;;;;:::i;:::-;;;;;;;;43591:599:::0;;;;;:::o;35997:84::-;36050:31;35966:1;36050:2;:31;:::i;:::-;35997:84;:::o;63568:2313::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69750:6:::1;::::0;-1:-1:-1;;;;;69750:6:0::1;:20:::0;;::::1;::::0;:44:::1;;-1:-1:-1::0;69788:6:0::1;::::0;-1:-1:-1;;;;;69788:6:0::1;69774:10;:20;69750:44;69742:96;;;::::0;::::1;;63767:12:::2;63746:17;;:33;63738:98;;;::::0;::::2;;63853:14;::::0;:18;63849:385:::2;;63919:17;;63896:19;;:40;63888:96;;;::::0;::::2;;64007:36;64022:3;;64007:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;64027:15:0::2;64007:36:::0;;64027:15;;-1:-1:-1;64007:36:0::2;::::0;-1:-1:-1;64007:36:0::2;:::i;:::-;63999:100;;;::::0;::::2;;64141:16;;64122:15;:35;;64114:108;;;::::0;::::2;;64626:14;;64644:1;64626:19;64618:62;;;::::0;::::2;;65437:18;:25:::0;:30;65429:96:::2;;;::::0;::::2;;65544:20;::::0;:25;65536:91:::2;;;::::0;::::2;;65701:1;65684:14;:18:::0;65733:17:::2;::::0;65720:153:::2;::::0;1734:25:1;;;65720:153:0::2;::::0;1722:2:1;1707:18;65720:153:0::2;;;;;;;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;:::-;32326:180;63568:2313;;;:::o;8531:227::-;8321:5;;-1:-1:-1;;;;;8321:5:0;8307:10;:19;8299:64;;;;-1:-1:-1;;;8299:64:0;;14186:2:1;8299:64:0;;;14168:21:1;;;14205:18;;;14198:30;14264:34;14244:18;;;14237:62;14316:18;;8299:64:0;13984:356:1;8299:64:0;-1:-1:-1;;;;;8607:22:0;::::1;8599:73;;;::::0;-1:-1:-1;;;8599:73:0;;14547:2:1;8599:73:0::1;::::0;::::1;14529:21:1::0;14586:2;14566:18;;;14559:30;14625:34;14605:18;;;14598:62;-1:-1:-1;;;14676:18:1;;;14669:36;14722:19;;8599:73:0::1;14345:402:1::0;8599:73:0::1;8683:13;:24:::0;;-1:-1:-1;;;;;;8683:24:0::1;-1:-1:-1::0;;;;;8683:24:0;::::1;::::0;;::::1;::::0;;;8723:27:::1;::::0;::::1;::::0;-1:-1:-1;;8723:27:0::1;8531:227:::0;:::o;36993:23::-;;;;;;;:::i;42012:347::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;8321:5:::1;::::0;-1:-1:-1;;;;;8321:5:0::1;8307:10;:19;8299:64;;;::::0;-1:-1:-1;;;8299:64:0;;14186:2:1;8299:64:0::1;::::0;::::1;14168:21:1::0;;;14205:18;;;14198:30;14264:34;14244:18;;;14237:62;14316:18;;8299:64:0::1;13984:356:1::0;8299:64:0::1;42112:18:::2;::::0;-1:-1:-1;;;;;42112:18:0::2;:32:::0;42103:60:::2;;;::::0;::::2;;-1:-1:-1::0;;;;;42183:22:0;::::2;42174:79;;;::::0;::::2;;42264:18;:29:::0;;-1:-1:-1;;;;;;42264:29:0::2;-1:-1:-1::0;;;;;42264:29:0;::::2;;::::0;;-1:-1:-1;42304:14:0::2;:18:::0;;;42333:14:::2;:18:::0;;;32449:13;32433:29;;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;53506:2633::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;;69538:10:::1;69527:22:::0;;:10:::1;:22;::::0;;;;;;69574:15:::1;:22:::0;69568:28;::::1;:66:::0;::::1;;;;69614:15;69630:3;69614:20;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;69614:20:0::1;69600:10;:34;69568:66;69560:121;;;::::0;::::1;;53824:12:::2;53803:17;;:33;53795:101;;;::::0;::::2;;53913:14;::::0;:18;53909:266:::2;;53979:17;;53956:19;;:40;53948:98;;;::::0;::::2;;54069:36;54084:3;;54069:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;54089:15:0::2;54069:36:::0;;54089:15;;-1:-1:-1;54069:36:0::2;::::0;-1:-1:-1;54069:36:0::2;:::i;:::-;54061:102;;;::::0;::::2;;54671:14;;54689:1;54671:19;54663:62;;;::::0;::::2;;54748:40;54757:10;54769:18;54748:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;54748:40:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;;:8;:40::i;:::-;54747:41;:86;;;;;54794:39;54803:10;54815:17;54794:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;54794:39:0::2;::::0;;;;;::::2;::::0;::::2;;::::0;;::::2;;;;;;;;:8;:39::i;:::-;54793:40;54747:86;54738:140;;;::::0;::::2;;54948:29;54963:8;54948:29;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54973:3;;54948:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;54948:14:0::2;::::0;-1:-1:-1;;;54948:29:0:i:2;:::-;54940:94;;;::::0;::::2;;55074:7;55053:17;;:28;55045:95;;;::::0;::::2;;55181:10;55161:16;;:30;55153:88;;;::::0;::::2;;55284:10;55260:20;;:34;55252:92;;;::::0;::::2;;55382:10;55363:15;;:29;55355:93;;;::::0;::::2;;55467:18;:25:::0;:39;::::2;55459:103;;;::::0;::::2;;55613:12;55583:26;;:42;55575:105;;;::::0;::::2;;55725:13;55699:22;;:39;55691:102;;;::::0;::::2;;55810:5;55806:140;;;55832:18;:35:::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;55832:35:0;;;;;::::2;::::0;;-1:-1:-1;;;;;;55832:35:0::2;55856:10;55832:35;::::0;;55806:140:::2;;;55900:17;:34:::0;;::::2;::::0;::::2;::::0;;-1:-1:-1;55900:34:0;;;;;::::2;::::0;;-1:-1:-1;;;;;;55900:34:0::2;55923:10;55900:34;::::0;;55806:140:::2;55978:10;-1:-1:-1::0;;;;;55963:168:0::2;;55990:17;;56009:8;56019:26;;56047:22;;56071:17;;56090:16;;56108:15;;56125:5;55963:168;;;;;;;;;;;;;:::i;:::-;;;;;;;;69505:196:::1;32449:13:::0;;32433:12;:29;32425:73;;;;-1:-1:-1;;;32425:73:0;;;;;;;:::i;:::-;32326:180;53506:2633;;;;;;;;;:::o;44198:1715::-;32354:1;32337:13;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;;32366:20:0;32389:13;69357:8:::1;::::0;-1:-1:-1;;;;;69357:8:0::1;:22:::0;;::::1;::::0;:48:::1;;-1:-1:-1::0;69397:8:0::1;::::0;-1:-1:-1;;;;;69397:8:0::1;69383:10;:22;69357:48;69349:103;;;::::0;::::1;;44885:1:::2;44867:14;;:19;;44859:62;;;::::0;::::2;;44938:14;::::0;:18;44934:268:::2;;45004:17;;44981:19;;:40;44973:99;;;::::0;::::2;;45095:36;45110:3;;45095:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;45115:15:0::2;45095:36:::0;;45115:15;;-1:-1:-1;45095:36:0::2;::::0;-1:-1:-1;45095:36:0::2;:::i;:::-;45087:103;;;::::0;::::2;;45297:25;45304:18;;45297:25;:::i;:::-;45335:17;:32:::0;;;45378:14:::2;:8;45389:3:::0;;45378:14:::2;:::i;:::-;-1:-1:-1::0;45403:26:0::2;:41:::0;;;45455:22:::2;:38:::0;;;45504:17:::2;:27:::0;;;45544:16:::2;:29:::0;;;45584:20:::2;:33:::0;;;45628:15:::2;:28:::0;;;-1:-1:-1;45714:14:0::2;:18:::0;45767:17:::2;::::0;45750:155:::2;::::0;::::2;::::0;::::2;::::0;45787:8:::2;::::0;45432:12;;45480:13;;45524:7;;45563:10;;45646;;45750:155:::2;:::i;39418:35::-:0;;;;;;;;;;;;9414:177;9495:4;9580:1;9563:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;9553:30;;;;;;9546:1;9529:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;9519:30;;;;;;:64;9512:71;;9414:177;;;;;:::o;40369:299::-;40463:15;:22;40442:4;;40459:45;;-1:-1:-1;40499:5:0;;40369:299;-1:-1:-1;40369:299:0:o;40459:45::-;36175:4;36050:31;35966:1;36050:2;:31;:::i;:::-;40603:57;;;;:::i;:::-;40576:15;:22;40524:76;;:46;36050:31;35966:1;36050:2;:31;:::i;:::-;40524:12;;:16;:46::i;:::-;:50;;:76::i;:::-;:136;;40369:299;-1:-1:-1;;40369:299:0:o;40087:274::-;40183:15;:22;40162:4;;40179:45;;-1:-1:-1;40219:5:0;;40087:274;-1:-1:-1;40087:274:0:o;40179:45::-;40297:15;:22;36175:4;;40244:77;;:47;36050:31;35966:1;36050:2;:31;:::i;40244:77::-;:109;;;40087:274;-1:-1:-1;;40087:274:0:o;9184:222::-;-1:-1:-1;;;;;9258:22:0;;9250:68;;;;-1:-1:-1;;;9250:68:0;;17832:2:1;9250:68:0;;;17814:21:1;17871:2;17851:18;;;17844:30;17910:34;17890:18;;;17883:62;-1:-1:-1;;;17961:18:1;;;17954:31;18002:19;;9250:68:0;17630:397:1;9250:68:0;9355:5;;9334:37;;-1:-1:-1;;;;;9334:37:0;;;;9355:5;;9334:37;;9355:5;;9334:37;9382:5;:16;;-1:-1:-1;;;;;;9382:16:0;-1:-1:-1;;;;;9382:16:0;;;;;;;;;;9184:222::o;3899:106::-;3957:7;3988:1;3984;:5;:13;;3996:1;3984:13;;;3992:1;3984:13;3977:20;3899:106;-1:-1:-1;;;3899:106:0:o;5035:184::-;5093:7;5126:1;5121;:6;;5113:49;;;;-1:-1:-1;;;5113:49:0;;18234:2:1;5113:49:0;;;18216:21:1;18273:2;18253:18;;;18246:30;18312:32;18292:18;;;18285:60;18362:18;;5113:49:0;18032:354:1;5113:49:0;5173:9;5185:5;5189:1;5185;:5;:::i;:::-;5173:17;5035:184;-1:-1:-1;;;;5035:184:0:o;32607:176::-;32716:58;;;-1:-1:-1;;;;;4222:32:1;;32716:58:0;;;4204:51:1;4271:18;;;;4264:34;;;32716:58:0;;;;;;;;;;4177:18:1;;;;32716:58:0;;;;;;;;-1:-1:-1;;;;;32716:58:0;-1:-1:-1;;;32716:58:0;;;32690:85;;32709:5;;32690:18;:85::i;:::-;32607:176;;;:::o;9599:243::-;9683:4;;9700:112;9724:8;:15;9720:1;:19;9700:112;;;9776:8;9785:1;9776:11;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;9765:22:0;:7;-1:-1:-1;;;;;9765:22:0;;9761:39;;;9796:4;9789:11;;;;;9761:39;9741:3;;;;:::i;:::-;;;;9700:112;;;-1:-1:-1;9829:5:0;;9599:243;-1:-1:-1;;;9599:243:0:o;5470:470::-;5528:7;5772:6;5768:47;;-1:-1:-1;5802:1:0;5795:8;;5768:47;5827:9;5839:5;5843:1;5839;:5;:::i;:::-;5827:17;-1:-1:-1;5872:1:0;5863:5;5867:1;5827:17;5863:5;:::i;:::-;:10;5855:56;;;;-1:-1:-1;;;5855:56:0;;18988:2:1;5855:56:0;;;18970:21:1;19027:2;19007:18;;;19000:30;19066:34;19046:18;;;19039:62;-1:-1:-1;;;19117:18:1;;;19110:31;19158:19;;5855:56:0;18786:397:1;6408:333:0;6466:7;6565:1;6561;:5;6553:44;;;;-1:-1:-1;;;6553:44:0;;19390:2:1;6553:44:0;;;19372:21:1;19429:2;19409:18;;;19402:30;19468:28;19448:18;;;19441:56;19514:18;;6553:44:0;19188:350:1;6553:44:0;6608:9;6620:5;6624:1;6620;:5;:::i;34601:1114::-;-1:-1:-1;;;;;35205:25:0;;935:20;35197:71;;;;-1:-1:-1;;;35197:71:0;;19745:2:1;35197:71:0;;;19727:21:1;19784:2;19764:18;;;19757:30;19823:33;19803:18;;;19796:61;19874:18;;35197:71:0;19543:355:1;35197:71:0;35342:12;35356:23;35391:5;-1:-1:-1;;;;;35383:19:0;35403:4;35383:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35341:67;;;;35427:7;35419:52;;;;-1:-1:-1;;;35419:52:0;;20384:2:1;35419:52:0;;;20366:21:1;;;20403:18;;;20396:30;20462:34;20442:18;;;20435:62;20514:18;;35419:52:0;20182:356:1;35419:52:0;35488:17;;:21;35484:224;;35630:10;35619:30;;;;;;;;;;;;:::i;:::-;35611:85;;;;-1:-1:-1;;;35611:85:0;;20995:2:1;35611:85:0;;;20977:21:1;21034:2;21014:18;;;21007:30;21073:34;21053:18;;;21046:62;-1:-1:-1;;;21124:18:1;;;21117:40;21174:19;;35611:85:0;20793:406:1;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:180:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;407:348::-;459:8;469:6;523:3;516:4;508:6;504:17;500:27;490:55;;541:1;538;531:12;490:55;-1:-1:-1;564:20:1;;607:18;596:30;;593:50;;;639:1;636;629:12;593:50;676:4;668:6;664:17;652:29;;728:3;721:4;712:6;704;700:19;696:30;693:39;690:59;;;745:1;742;735:12;690:59;407:348;;;;;:::o;760:823::-;885:6;893;901;909;917;925;933;941;994:3;982:9;973:7;969:23;965:33;962:53;;;1011:1;1008;1001:12;962:53;1047:9;1034:23;1024:33;;1108:2;1097:9;1093:18;1080:32;1135:18;1127:6;1124:30;1121:50;;;1167:1;1164;1157:12;1121:50;1206:59;1257:7;1248:6;1237:9;1233:22;1206:59;:::i;:::-;760:823;;1284:8;;-1:-1:-1;1180:85:1;;1366:2;1351:18;;1338:32;;1417:2;1402:18;;1389:32;;-1:-1:-1;1468:3:1;1453:19;;1440:33;;-1:-1:-1;1520:3:1;1505:19;;1492:33;;-1:-1:-1;1572:3:1;1557:19;;;1544:33;;-1:-1:-1;760:823:1;-1:-1:-1;;;;760:823:1:o;2107:258::-;2179:1;2189:113;2203:6;2200:1;2197:13;2189:113;;;2279:11;;;2273:18;2260:11;;;2253:39;2225:2;2218:10;2189:113;;;2320:6;2317:1;2314:13;2311:48;;;-1:-1:-1;;2355:1:1;2337:16;;2330:27;2107:258::o;2370:::-;2412:3;2450:5;2444:12;2477:6;2472:3;2465:19;2493:63;2549:6;2542:4;2537:3;2533:14;2526:4;2519:5;2515:16;2493:63;:::i;:::-;2610:2;2589:15;-1:-1:-1;;2585:29:1;2576:39;;;;2617:4;2572:50;;2370:258;-1:-1:-1;;2370:258:1:o;2633:461::-;2686:3;2724:5;2718:12;2751:6;2746:3;2739:19;2777:4;2806:2;2801:3;2797:12;2790:19;;2843:2;2836:5;2832:14;2864:1;2874:195;2888:6;2885:1;2882:13;2874:195;;;2953:13;;-1:-1:-1;;;;;2949:39:1;2937:52;;3009:12;;;;3044:15;;;;2985:1;2903:9;2874:195;;;-1:-1:-1;3085:3:1;;2633:461;-1:-1:-1;;;;;2633:461:1:o;3099:701::-;3432:6;3421:9;3414:25;3475:3;3470:2;3459:9;3455:18;3448:31;3395:4;3502:46;3543:3;3532:9;3528:19;3520:6;3502:46;:::i;:::-;3596:9;3588:6;3584:22;3579:2;3568:9;3564:18;3557:50;3630:44;3667:6;3659;3630:44;:::i;:::-;3616:58;;3722:9;3714:6;3710:22;3705:2;3694:9;3690:18;3683:50;3750:44;3787:6;3779;3750:44;:::i;:::-;3742:52;3099:701;-1:-1:-1;;;;;;;3099:701:1:o;3805:220::-;3954:2;3943:9;3936:21;3917:4;3974:45;4015:2;4004:9;4000:18;3992:6;3974:45;:::i;4309:173::-;4377:20;;-1:-1:-1;;;;;4426:31:1;;4416:42;;4406:70;;4472:1;4469;4462:12;4406:70;4309:173;;;:::o;4487:367::-;4550:8;4560:6;4614:3;4607:4;4599:6;4595:17;4591:27;4581:55;;4632:1;4629;4622:12;4581:55;-1:-1:-1;4655:20:1;;4698:18;4687:30;;4684:50;;;4730:1;4727;4720:12;4684:50;4767:4;4759:6;4755:17;4743:29;;4827:3;4820:4;4810:6;4807:1;4803:14;4795:6;4791:27;4787:38;4784:47;4781:67;;;4844:1;4841;4834:12;4859:585;4963:6;4971;4979;4987;5040:2;5028:9;5019:7;5015:23;5011:32;5008:52;;;5056:1;5053;5046:12;5008:52;5079:29;5098:9;5079:29;:::i;:::-;5069:39;;5159:2;5148:9;5144:18;5131:32;5186:18;5178:6;5175:30;5172:50;;;5218:1;5215;5208:12;5172:50;5257:70;5319:7;5310:6;5299:9;5295:22;5257:70;:::i;:::-;5346:8;;-1:-1:-1;5231:96:1;-1:-1:-1;5400:38:1;;-1:-1:-1;5434:2:1;5419:18;;5400:38;:::i;:::-;5390:48;;4859:585;;;;;;;:::o;5449:942::-;5711:4;5696:20;;5700:9;5793:6;5669:4;5827:220;5841:4;5838:1;5835:11;5827:220;;;5904:13;;-1:-1:-1;;;;;5900:39:1;5888:52;;5963:4;5987:12;;;;6022:15;;;;5936:1;5854:9;5827:220;;;5831:3;;;6084:4;6073:9;6069:20;6137:6;6163:1;6173:212;6189:4;6184:3;6181:13;6173:212;;;6254:15;;6240:30;;6293:4;6319:14;;;;6358:17;;;;6213:1;6204:11;6173:212;;;6177:3;;;5449:942;;;;;:::o;6396:841::-;6527:6;6535;6543;6551;6559;6612:2;6600:9;6591:7;6587:23;6583:32;6580:52;;;6628:1;6625;6618:12;6580:52;6668:9;6655:23;6697:18;6738:2;6730:6;6727:14;6724:34;;;6754:1;6751;6744:12;6724:34;6793:70;6855:7;6846:6;6835:9;6831:22;6793:70;:::i;:::-;6882:8;;-1:-1:-1;6767:96:1;-1:-1:-1;6970:2:1;6955:18;;6942:32;;-1:-1:-1;6986:16:1;;;6983:36;;;7015:1;7012;7005:12;6983:36;;7054:72;7118:7;7107:8;7096:9;7092:24;7054:72;:::i;:::-;6396:841;;;;-1:-1:-1;7145:8:1;7227:2;7212:18;7199:32;;6396:841;-1:-1:-1;;;;6396:841:1:o;7242:616::-;7340:6;7348;7356;7364;7372;7425:3;7413:9;7404:7;7400:23;7396:33;7393:53;;;7442:1;7439;7432:12;7393:53;7478:9;7465:23;7455:33;;7535:2;7524:9;7520:18;7507:32;7497:42;;7586:2;7575:9;7571:18;7558:32;7548:42;;7641:2;7630:9;7626:18;7613:32;7668:18;7660:6;7657:30;7654:50;;;7700:1;7697;7690:12;7654:50;7739:59;7790:7;7781:6;7770:9;7766:22;7739:59;:::i;:::-;7242:616;;;;-1:-1:-1;7242:616:1;;-1:-1:-1;7817:8:1;;7713:85;7242:616;-1:-1:-1;;;7242:616:1:o;7863:479::-;7943:6;7951;7959;8012:2;8000:9;7991:7;7987:23;7983:32;7980:52;;;8028:1;8025;8018:12;7980:52;8064:9;8051:23;8041:33;;8125:2;8114:9;8110:18;8097:32;8152:18;8144:6;8141:30;8138:50;;;8184:1;8181;8174:12;8138:50;8223:59;8274:7;8265:6;8254:9;8250:22;8223:59;:::i;:::-;7863:479;;8301:8;;-1:-1:-1;8197:85:1;;-1:-1:-1;;;;7863:479:1:o;8568:186::-;8627:6;8680:2;8668:9;8659:7;8655:23;8651:32;8648:52;;;8696:1;8693;8686:12;8648:52;8719:29;8738:9;8719:29;:::i;8759:118::-;8845:5;8838:13;8831:21;8824:5;8821:32;8811:60;;8867:1;8864;8857:12;8882:953;9013:6;9021;9029;9037;9045;9053;9061;9069;9077;9130:3;9118:9;9109:7;9105:23;9101:33;9098:53;;;9147:1;9144;9137:12;9098:53;9183:9;9170:23;9160:33;;9244:2;9233:9;9229:18;9216:32;9271:18;9263:6;9260:30;9257:50;;;9303:1;9300;9293:12;9257:50;9342:59;9393:7;9384:6;9373:9;9369:22;9342:59;:::i;:::-;9420:8;;-1:-1:-1;9316:85:1;-1:-1:-1;;9502:2:1;9487:18;;9474:32;;-1:-1:-1;9553:2:1;9538:18;;9525:32;;-1:-1:-1;9604:3:1;9589:19;;9576:33;;-1:-1:-1;9656:3:1;9641:19;;9628:33;;-1:-1:-1;9708:3:1;9693:19;;9680:33;;-1:-1:-1;9763:3:1;9748:19;;9735:33;9777:28;9735:33;9777:28;:::i;:::-;9824:5;9814:15;;;8882:953;;;;;;;;;;;:::o;9840:127::-;9901:10;9896:3;9892:20;9889:1;9882:31;9932:4;9929:1;9922:15;9956:4;9953:1;9946:15;9972:128;10012:3;10043:1;10039:6;10036:1;10033:13;10030:39;;;10049:18;;:::i;:::-;-1:-1:-1;10085:9:1;;9972:128::o;10105:127::-;10166:10;10161:3;10157:20;10154:1;10147:31;10197:4;10194:1;10187:15;10221:4;10218:1;10211:15;10237:380;10316:1;10312:12;;;;10359;;;10380:61;;10434:4;10426:6;10422:17;10412:27;;10380:61;10487:2;10479:6;10476:14;10456:18;10453:38;10450:161;;;10533:10;10528:3;10524:20;10521:1;10514:31;10568:4;10565:1;10558:15;10596:4;10593:1;10586:15;10450:161;;10237:380;;;:::o;10622:355::-;10824:2;10806:21;;;10863:2;10843:18;;;10836:30;10902:33;10897:2;10882:18;;10875:61;10968:2;10953:18;;10622:355::o;11342:135::-;11381:3;-1:-1:-1;;11402:17:1;;11399:43;;;11422:18;;:::i;:::-;-1:-1:-1;11469:1:1;11458:13;;11342:135::o;11482:125::-;11522:4;11550:1;11547;11544:8;11541:34;;;11555:18;;:::i;:::-;-1:-1:-1;11592:9:1;;11482:125::o;11612:127::-;11673:10;11668:3;11664:20;11661:1;11654:31;11704:4;11701:1;11694:15;11728:4;11725:1;11718:15;11997:608;12240:6;12229:9;12222:25;12283:6;12278:2;12267:9;12263:18;12256:34;12326:6;12321:2;12310:9;12306:18;12299:34;12369:3;12364:2;12353:9;12349:18;12342:31;12410:6;12404:3;12393:9;12389:19;12382:35;12468:6;12460;12454:3;12443:9;12439:19;12426:49;12525:1;12495:22;;;12519:3;12491:32;;;12484:43;;;;12588:2;12567:15;;;-1:-1:-1;;12563:29:1;12548:45;12544:55;;11997:608;-1:-1:-1;;;;11997:608:1:o;12610:422::-;12699:1;12742:5;12699:1;12756:270;12777:7;12767:8;12764:21;12756:270;;;12836:4;12832:1;12828:6;12824:17;12818:4;12815:27;12812:53;;;12845:18;;:::i;:::-;12895:7;12885:8;12881:22;12878:55;;;12915:16;;;;12878:55;12994:22;;;;12954:15;;;;12756:270;;;12760:3;12610:422;;;;;:::o;13037:806::-;13086:5;13116:8;13106:80;;-1:-1:-1;13157:1:1;13171:5;;13106:80;13205:4;13195:76;;-1:-1:-1;13242:1:1;13256:5;;13195:76;13287:4;13305:1;13300:59;;;;13373:1;13368:130;;;;13280:218;;13300:59;13330:1;13321:10;;13344:5;;;13368:130;13405:3;13395:8;13392:17;13389:43;;;13412:18;;:::i;:::-;-1:-1:-1;;13468:1:1;13454:16;;13483:5;;13280:218;;13582:2;13572:8;13569:16;13563:3;13557:4;13554:13;13550:36;13544:2;13534:8;13531:16;13526:2;13520:4;13517:12;13513:35;13510:77;13507:159;;;-1:-1:-1;13619:19:1;;;13651:5;;13507:159;13698:34;13723:8;13717:4;13698:34;:::i;:::-;13768:6;13764:1;13760:6;13756:19;13747:7;13744:32;13741:58;;;13779:18;;:::i;:::-;13817:20;;13037:806;-1:-1:-1;;;13037:806:1:o;13848:131::-;13908:5;13937:36;13964:8;13958:4;13937:36;:::i;14878:1042::-;14963:12;;14928:3;;15018:1;15038:18;;;;15091;;;;15118:61;;15172:4;15164:6;15160:17;15150:27;;15118:61;15198:2;15246;15238:6;15235:14;15215:18;15212:38;15209:161;;;15292:10;15287:3;15283:20;15280:1;15273:31;15327:4;15324:1;15317:15;15355:4;15352:1;15345:15;15209:161;2039:19;;;2091:4;2082:14;;15456:18;15483:104;;;;15601:1;15596:318;;;;15449:465;;15483:104;-1:-1:-1;;15518:24:1;;15504:39;;15563:14;;;;-1:-1:-1;15483:104:1;;15596:318;14825:1;14818:14;;;14862:4;14849:18;;15690:1;15704:167;15718:6;15715:1;15712:13;15704:167;;;15798:14;;15783:13;;;15776:37;15841:16;;;;15733:10;;15704:167;;;15891:13;;;-1:-1:-1;;15449:465:1;;;;;;;;14878:1042;;;;:::o;15925:758::-;16224:4;16253:3;16283:6;16272:9;16265:25;16326:2;16321;16310:9;16306:18;16299:30;16346:53;16395:2;16384:9;16380:18;16372:6;16346:53;:::i;:::-;16430:2;16415:18;;16408:34;;;;-1:-1:-1;;16473:2:1;16458:18;;16451:34;;;;16516:3;16501:19;;16494:35;;;;16560:3;16545:19;;16538:35;;;;16604:3;16589:19;;16582:35;16661:14;16654:22;16648:3;16633:19;;;16626:51;16338:61;15925:758;-1:-1:-1;;15925:758:1:o;16688:656::-;17002:6;16991:9;16984:25;17045:3;17040:2;17029:9;17025:18;17018:31;16965:4;17066:54;17115:3;17104:9;17100:19;17092:6;17066:54;:::i;:::-;17151:2;17136:18;;17129:34;;;;-1:-1:-1;17194:2:1;17179:18;;17172:34;;;;17237:3;17222:19;;17215:35;;;;17281:3;17266:19;;17259:35;17325:3;17310:19;;;17303:35;17058:62;16688:656;-1:-1:-1;;16688:656:1:o;17349:276::-;17480:3;17518:6;17512:13;17534:53;17580:6;17575:3;17568:4;17560:6;17556:17;17534:53;:::i;:::-;17603:16;;;;;17349:276;-1:-1:-1;;17349:276:1:o;18391:168::-;18431:7;18497:1;18493;18489:6;18485:14;18482:1;18479:21;18474:1;18467:9;18460:17;18456:45;18453:71;;;18504:18;;:::i;:::-;-1:-1:-1;18544:9:1;;18391:168::o;18564:217::-;18604:1;18630;18620:132;;18674:10;18669:3;18665:20;18662:1;18655:31;18709:4;18706:1;18699:15;18737:4;18734:1;18727:15;18620:132;-1:-1:-1;18766:9:1;;18564:217::o;20543:245::-;20610:6;20663:2;20651:9;20642:7;20638:23;20634:32;20631:52;;;20679:1;20676;20669:12;20631:52;20711:9;20705:16;20730:28;20752:5;20730:28;:::i

ipfs://e3ebe014bae49f01c485f5ec7566a24b8db60620a2a440f75714ab4b74ff37d0