Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

Outline

• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - 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 sub(
•    - function div(
•    - function mod(
•  contract Ptp *
•    - function setMinter(address minter_)
•    - function mint(address dst, uint256 ra ...
•    - function allowance(address account, a ...
•    - function approve(address spender, uin ...
•    - function permit(
•    - function balanceOf(address account)
•    - function transfer(address dst, uint25 ...
•    - function transferFrom(
•    - function _transferTokens(
•    - function safe32(uint256 n, string mem ...
•    - function safe96(uint256 n, string mem ...
•    - function add96(
•    - function sub96(
•    - function getChainId()

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at snowscan.xyz on 2021-12-12
*/

// Sources flattened with hardhat v2.6.7 https://hardhat.org

// File @openzeppelin/contracts/utils/math/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @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) {
        return a + b;
    }

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

    /**
     * @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) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


// File contracts/Ptp.sol
pragma solidity 0.8.9;

/// @title the ptp token
/// Note initially forked from Uniswap and then upgraded to 0.8.9
contract Ptp {
    /// @notice EIP-20 token name for this token
    string public constant name = 'Platypus';

    /// @notice EIP-20 token symbol for this token
    string public constant symbol = 'PTP';

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    /// @notice Total number of tokens in circulation
    uint256 public totalSupply = 300_000_000e18; // 300M PTP

    /// @notice Address which may mint new tokens
    address public minter;

    /// @notice The timestamp after which minting may occur
    uint256 public mintingAllowedAfter;

    /// @notice Minimum time between mints
    uint32 public constant minimumTimeBetweenMints = 1 days * 365;

    /// @notice Cap on the percentage of totalSupply that can be minted at each mint
    uint8 public constant mintCap = 2;

    /// @notice Allowance amounts on behalf of others
    mapping(address => mapping(address => uint96)) internal allowances;

    /// @notice Official record of token balances for each account
    mapping(address => uint96) internal balances;

    /// @notice The EIP-712 typehash for the contract's domain
    bytes32 public immutable DOMAIN_TYPEHASH =
        keccak256('EIP712Domain(string name,uint256 chainId,address verifyingContract)');

    /// @notice The EIP-712 typehash for the permit struct used by the contract
    bytes32 public immutable PERMIT_TYPEHASH =
        keccak256('Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)');

    /// @notice A record of states for signing / validating signatures
    mapping(address => uint256) public nonces;

    /// @notice An event thats emitted when the minter address is changed
    event MinterChanged(address minter, address newMinter);

    /// @notice The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @notice The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /**
     * @notice Construct a new Ptp token
     * @param account The initial account to grant all the tokens
     * @param minter_ The account with minting ability
     * @param mintingAllowedAfter_ The timestamp after which minting may occur
     */
    constructor(
        address account,
        address minter_,
        uint256 mintingAllowedAfter_
    ) {
        require(mintingAllowedAfter_ >= block.timestamp, 'Ptp::constructor: minting can only begin after deployment');

        balances[account] = uint96(totalSupply);
        emit Transfer(address(0), account, totalSupply);
        minter = minter_;
        emit MinterChanged(address(0), minter_);
        mintingAllowedAfter = mintingAllowedAfter_;
    }

    /**
     * @notice Change the minter address
     * @param minter_ The address of the new minter
     */
    function setMinter(address minter_) external {
        require(msg.sender == minter, 'Ptp::setMinter: only the minter can change the minter address');
        emit MinterChanged(minter, minter_);
        minter = minter_;
    }

    /**
     * @notice Mint new tokens
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to be minted
     */
    function mint(address dst, uint256 rawAmount) external {
        require(msg.sender == minter, 'Ptp::mint: only the minter can mint');
        require(block.timestamp >= mintingAllowedAfter, 'Ptp::mint: minting not allowed yet');
        require(dst != address(0), 'Ptp::mint: cannot transfer to the zero address');

        // record the mint
        mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);

        // mint the amount
        uint96 amount = safe96(rawAmount, 'Ptp::mint: amount exceeds 96 bits');
        require(amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100), 'Ptp::mint: exceeded mint cap');
        totalSupply = safe96(SafeMath.add(totalSupply, amount), 'Ptp::mint: totalSupply exceeds 96 bits');

        // transfer the amount to the recipient
        balances[dst] = add96(balances[dst], amount, 'Ptp::mint: transfer amount overflows');
        emit Transfer(address(0), dst, amount);
    }

    /**
     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint256) {
        return allowances[account][spender];
    }

    /**
     * @notice Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * @param spender The address of the account which may transfer tokens
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint256 rawAmount) external returns (bool) {
        uint96 amount;
        if (rawAmount == type(uint256).max) {
            amount = type(uint96).max;
        } else {
            amount = safe96(rawAmount, 'Ptp::approve: amount exceeds 96 bits');
        }

        allowances[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice Triggers an approval from owner to spends
     * @param owner The address to approve from
     * @param spender The address to be approved
     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
     * @param deadline The time at which to expire the signature
     * @param v The recovery byte of the signature
     * @param r Half of the ECDSA signature pair
     * @param s Half of the ECDSA signature pair
     */
    function permit(
        address owner,
        address spender,
        uint256 rawAmount,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        // PTP-01M fix
        require(v == 27 || v == 28, 'Ptp::permit: invalid range for v');
        require(
            uint256(s) < 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A1,
            'Ptp::permit: invalid range for s'
        );

        uint96 amount;
        if (rawAmount == type(uint256).max) {
            amount = type(uint96).max;
        } else {
            amount = safe96(rawAmount, 'Ptp::permit: amount exceeds 96 bits');
        }

        bytes32 domainSeparator = keccak256(
            abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))
        );
        bytes32 structHash = keccak256(
            abi.encode(PERMIT_TYPEHASH, owner, spender, rawAmount, nonces[owner]++, deadline)
        );
        bytes32 digest = keccak256(abi.encodePacked('\x19\x01', domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), 'Ptp::permit: invalid signature');
        require(signatory == owner, 'Ptp::permit: unauthorized');
        require(block.timestamp <= deadline, 'Ptp::permit: signature expired');

        allowances[owner][spender] = amount;

        emit Approval(owner, spender, amount);
    }

    /**
     * @notice Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint256) {
        return balances[account];
    }

    /**
     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
     * @dev This function is expected to ALWAYS return true, or else it should throw
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint256 rawAmount) external returns (bool) {
        uint96 amount = safe96(rawAmount, 'Ptp::transfer: amount exceeds 96 bits');
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     * @notice Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param rawAmount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(
        address src,
        address dst,
        uint256 rawAmount
    ) external returns (bool) {
        address spender = msg.sender;
        uint96 spenderAllowance = allowances[src][spender];
        uint96 amount = safe96(rawAmount, 'Ptp::approve: amount exceeds 96 bits');

        if (spender != src && spenderAllowance != type(uint96).max) {
            uint96 newAllowance = sub96(
                spenderAllowance,
                amount,
                'Ptp::transferFrom: transfer amount exceeds spender allowance'
            );
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    function _transferTokens(
        address src,
        address dst,
        uint96 amount
    ) internal {
        require(src != address(0), 'Ptp::_transferTokens: cannot transfer from the zero address');
        require(dst != address(0), 'Ptp::_transferTokens: cannot transfer to the zero address');

        balances[src] = sub96(balances[src], amount, 'Ptp::_transferTokens: transfer amount exceeds balance');
        balances[dst] = add96(balances[dst], amount, 'Ptp::_transferTokens: transfer amount overflows');
        emit Transfer(src, dst, amount);
    }

    function safe32(uint256 n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function safe96(uint256 n, string memory errorMessage) internal pure returns (uint96) {
        require(n < 2**96, errorMessage);
        return uint96(n);
    }

    function add96(
        uint96 a,
        uint96 b,
        string memory errorMessage
    ) internal pure returns (uint96) {
        uint96 c = a + b;
        require(c >= a, errorMessage);
        return c;
    }

    function sub96(
        uint96 a,
        uint96 b,
        string memory errorMessage
    ) internal pure returns (uint96) {
        require(b <= a, errorMessage);
        return a - b;
    }

    function getChainId() internal view returns (uint256) {
        uint256 chainId;
        assembly {
            chainId := chainid()
        }
        return chainId;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"minter_","type":"address"},{"internalType":"uint256","name":"mintingAllowedAfter_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"address","name":"newMinter","type":"address"}],"name":"MinterChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumTimeBetweenMints","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintCap","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintingAllowedAfter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter_","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"rawAmount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

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

7206:11193:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7276:40;;;;;;;;;;;;;;;-1:-1:-1;;;7276:40:0;;;;;;;;;;;;:::i;:::-;;;;;;;;7691:21;;;;;-1:-1:-1;;;;;7691:21:0;;;;;;-1:-1:-1;;;;;780:55:1;;;762:74;;750:2;735:18;7691:21:0;616:226:1;12452:436:0;;;;;;:::i;:::-;;:::i;:::-;;;1472:14:1;;1465:22;1447:41;;1435:2;1420:18;12452:436:0;1307:187:1;7576:43:0;;;;;;;;;1645:25:1;;;1633:2;1618:18;7576:43:0;1499:177:1;8382:132:0;;;;;16065:779;;;;;;:::i;:::-;;:::i;8604:147::-;;;;;7782:34;;;;;;7477:35;;7510:2;7477:35;;;;;2368:4:1;2356:17;;;2338:36;;2326:2;2311:18;7477:35:0;2196:184:1;10560:971:0;;;;;;:::i;:::-;;:::i;:::-;;7869:61;;7918:12;7869:61;;;;;2559:10:1;2547:23;;;2529:42;;2517:2;2502:18;7869:61:0;2385:192:1;15054:111:0;;;;;;:::i;:::-;-1:-1:-1;;;;;15140:17:0;15113:7;15140:17;;;:8;:17;;;;;;-1:-1:-1;;;;;15140:17:0;;15054:111;8025:33;;8057:1;8025:33;;8832:41;;;;;;:::i;:::-;;;;;;;;;;;;;;7377:37;;;;;;;;;;;;;;;;;;;;;15515:240;;;;;;:::i;:::-;;:::i;13378:1473::-;;;;;;:::i;:::-;;:::i;11835:139::-;;;;;;:::i;:::-;-1:-1:-1;;;;;11938:19:0;;;11911:7;11938:19;;;:10;:19;;;;;;;;:28;;;;;;;;;;;;-1:-1:-1;;;;;11938:28:0;;11835:139;10154:231;;;;;;:::i;:::-;;:::i;12452:436::-;12523:4;12540:13;-1:-1:-1;;12568:9:0;:30;12564:187;;;-1:-1:-1;;;;;;12564:187:0;;;12682:57;12689:9;12682:57;;;;;;;;;;;;;;;;;:6;:57::i;:::-;12673:66;;12564:187;12774:10;12763:22;;;;:10;:22;;;;;;;;-1:-1:-1;;;;;12763:31:0;;;;;;;;;;;;:40;;-1:-1:-1;;12763:40:0;-1:-1:-1;;;;;12763:40:0;;;;;;;;12821:37;;3881:58:1;;;12763:31:0;;12774:10;12821:37;;3854:18:1;12821:37:0;;;;;;;-1:-1:-1;12876:4:0;;12452:436;-1:-1:-1;;;12452:436:0:o;16065:779::-;-1:-1:-1;;;;;16266:15:0;;16184:4;16266:15;;;:10;:15;;;;;;;;16219:10;16266:24;;;;;;;;;;16317:57;;;;;;;;;;;;16219:10;;-1:-1:-1;;;;;16266:24:0;;;;16184:4;;16317:57;;16324:9;;16317:57;;;;;;;:6;:57::i;:::-;16301:73;;16402:3;-1:-1:-1;;;;;16391:14:0;:7;-1:-1:-1;;;;;16391:14:0;;;:54;;;;-1:-1:-1;;;;;;16409:36:0;;;;;16391:54;16387:382;;;16462:19;16484:161;16508:16;16543:6;16484:161;;;;;;;;;;;;;;;;;:5;:161::i;:::-;-1:-1:-1;;;;;16660:15:0;;;;;;;:10;:15;;;;;;;;:24;;;;;;;;;;;;;:39;;-1:-1:-1;;16660:39:0;-1:-1:-1;;;;;16660:39:0;;;;;;;;16721:36;;3881:58:1;;;16660:39:0;;-1:-1:-1;16660:24:0;;:15;;16721:36;;3854:18:1;16721:36:0;;;;;;;16447:322;16387:382;16781:33;16797:3;16802;16807:6;16781:15;:33::i;:::-;-1:-1:-1;16832:4:0;;16065:779;-1:-1:-1;;;;;;16065:779:0:o;10560:971::-;10648:6;;-1:-1:-1;;;;;10648:6:0;10634:10;:20;10626:68;;;;-1:-1:-1;;;10626:68:0;;4152:2:1;10626:68:0;;;4134:21:1;4191:2;4171:18;;;4164:30;4230:34;4210:18;;;4203:62;4301:5;4281:18;;;4274:33;4324:19;;10626:68:0;;;;;;;;;10732:19;;10713:15;:38;;10705:85;;;;-1:-1:-1;;;10705:85:0;;4556:2:1;10705:85:0;;;4538:21:1;4595:2;4575:18;;;4568:30;4634:34;4614:18;;;4607:62;4705:4;4685:18;;;4678:32;4727:19;;10705:85:0;4354:398:1;10705:85:0;-1:-1:-1;;;;;10809:17:0;;10801:76;;;;-1:-1:-1;;;10801:76:0;;4959:2:1;10801:76:0;;;4941:21:1;4998:2;4978:18;;;4971:30;5037:34;5017:18;;;5010:62;5108:16;5088:18;;;5081:44;5142:19;;10801:76:0;4757:410:1;10801:76:0;10940:54;10953:15;7918:12;10940;:54::i;:::-;10918:19;:76;;;;11035:13;11051:54;11058:9;11051:54;;;;;;;;;;;;;;;;;:6;:54::i;:::-;11035:70;;11134:53;11147:34;11160:11;;8057:1;11147:34;;:12;:34::i;:::-;11183:3;11134:12;:53::i;:::-;11124:6;-1:-1:-1;;;;;11124:63:0;;;11116:104;;;;-1:-1:-1;;;11116:104:0;;5374:2:1;11116:104:0;;;5356:21:1;5413:2;5393:18;;;5386:30;5452;5432:18;;;5425:58;5500:18;;11116:104:0;5172:352:1;11116:104:0;11245:83;11252:33;11265:11;;11278:6;-1:-1:-1;;;;;11252:33:0;:12;:33::i;:::-;11245:83;;;;;;;;;;;;;;;;;:6;:83::i;:::-;-1:-1:-1;;;;;11231:97:0;;;:11;:97;;;-1:-1:-1;;;;;11412:13:0;;;;:8;:13;;;;;;;;;;11406:68;;;;;;;;;;;;;;11412:13;;;;;11427:6;;11406:68;;;;;;;;:5;:68::i;:::-;-1:-1:-1;;;;;11390:13:0;;;;;;:8;:13;;;;;;;;:84;;-1:-1:-1;;11390:84:0;-1:-1:-1;;;;;11390:84:0;;;;;;11490:33;3899:39:1;;;3881:58;;11390:13:0;;;;11490:33;;3854:18:1;11490:33:0;;;;;;;;10615:916;10560:971;;:::o;15515:240::-;15583:4;15600:13;15616:58;15623:9;15616:58;;;;;;;;;;;;;;;;;:6;:58::i;:::-;15600:74;;15685:40;15701:10;15713:3;15718:6;15685:15;:40::i;:::-;-1:-1:-1;15743:4:0;;15515:240;-1:-1:-1;;;15515:240:0:o;13378:1473::-;13616:1;:7;;13621:2;13616:7;:18;;;;13627:1;:7;;13632:2;13627:7;13616:18;13608:63;;;;-1:-1:-1;;;13608:63:0;;5731:2:1;13608:63:0;;;5713:21:1;;;5750:18;;;5743:30;5809:34;5789:18;;;5782:62;5861:18;;13608:63:0;5529:356:1;13608:63:0;13717:66;13704:79;;13682:161;;;;-1:-1:-1;;;13682:161:0;;6092:2:1;13682:161:0;;;6074:21:1;;;6111:18;;;6104:30;6170:34;6150:18;;;6143:62;6222:18;;13682:161:0;5890:356:1;13682:161:0;13856:13;-1:-1:-1;;13884:9:0;:30;13880:186;;;-1:-1:-1;;;;;;13880:186:0;;;13998:56;14005:9;13998:56;;;;;;;;;;;;;;;;;:6;:56::i;:::-;13989:65;;13880:186;14172:4;;;;;;;;;;;-1:-1:-1;;;14172:4:0;;;;;14128:80;;14139:15;14128:80;;;6482:25:1;14156:22:0;6523:18:1;;;6516:34;18344:9:0;6566:18:1;;;6559:34;14202:4:0;6609:18:1;;;;6602:83;;;;14128:80:0;;;;;;;;;;6454:19:1;;;;14128:80:0;;14104:115;;;;;;-1:-1:-1;;;;;14330:13:0;;-1:-1:-1;14330:13:0;;;:6;:13;;;;;;:15;;14286;;14330:13;;14310:7;;14319:9;;14330:15;-1:-1:-1;14330:15:0;;;:::i;:::-;;;;-1:-1:-1;14275:81:0;;;;;;7312:25:1;;;;-1:-1:-1;;;;;7434:15:1;;;7414:18;;;7407:43;7486:15;;;;7466:18;;;7459:43;7518:18;;;7511:34;7561:19;;;7554:35;7605:19;;;7598:35;;;7284:19;;14275:81:0;;;;;;;;;;;;14251:116;;;;;;14230:137;;14378:14;14434:15;14451:10;14405:57;;;;;;;;7914:66:1;7902:79;;8006:1;7997:11;;7990:27;;;;8042:2;8033:12;;8026:28;8079:2;8070:12;;7644:444;14405:57:0;;;;-1:-1:-1;;14405:57:0;;;;;;;;;14395:68;;14405:57;14395:68;;;;14474:17;14494:26;;;;;;;;;8320:25:1;;;8393:4;8381:17;;8361:18;;;8354:45;;;;8415:18;;;8408:34;;;8458:18;;;8451:34;;;14395:68:0;;-1:-1:-1;14474:17:0;14494:26;;8292:19:1;;14494:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14494:26:0;;-1:-1:-1;;14494:26:0;;;-1:-1:-1;;;;;;;14539:23:0;;14531:66;;;;-1:-1:-1;;;14531:66:0;;8698:2:1;14531:66:0;;;8680:21:1;8737:2;8717:18;;;8710:30;8776:32;8756:18;;;8749:60;8826:18;;14531:66:0;8496:354:1;14531:66:0;14629:5;-1:-1:-1;;;;;14616:18:0;:9;-1:-1:-1;;;;;14616:18:0;;14608:56;;;;-1:-1:-1;;;14608:56:0;;9057:2:1;14608:56:0;;;9039:21:1;9096:2;9076:18;;;9069:30;9135:27;9115:18;;;9108:55;9180:18;;14608:56:0;8855:349:1;14608:56:0;14702:8;14683:15;:27;;14675:70;;;;-1:-1:-1;;;14675:70:0;;9411:2:1;14675:70:0;;;9393:21:1;9450:2;9430:18;;;9423:30;9489:32;9469:18;;;9462:60;9539:18;;14675:70:0;9209:354:1;14675:70:0;14787:6;14758:10;:17;14769:5;-1:-1:-1;;;;;14758:17:0;-1:-1:-1;;;;;14758:17:0;;;;;;;;;;;;:26;14776:7;-1:-1:-1;;;;;14758:26:0;-1:-1:-1;;;;;14758:26:0;;;;;;;;;;;;;:35;;;;;-1:-1:-1;;;;;14758:35:0;;;;;-1:-1:-1;;;;;14758:35:0;;;;;;14827:7;-1:-1:-1;;;;;14811:32:0;14820:5;-1:-1:-1;;;;;14811:32:0;;14836:6;14811:32;;;;;-1:-1:-1;;;;;3899:39:1;;;;3881:58;;3869:2;3854:18;;3736:209;14811:32:0;;;;;;;;13573:1278;;;;;13378:1473;;;;;;;:::o;10154:231::-;10232:6;;-1:-1:-1;;;;;10232:6:0;10218:10;:20;10210:94;;;;-1:-1:-1;;;10210:94:0;;9770:2:1;10210:94:0;;;9752:21:1;9809:2;9789:18;;;9782:30;9848:34;9828:18;;;9821:62;9919:31;9899:18;;;9892:59;9968:19;;10210:94:0;9568:425:1;10210:94:0;10334:6;;10320:30;;;-1:-1:-1;;;;;10334:6:0;;;10233:34:1;;10303:15;;;10298:2;10283:18;;10276:43;10320:30:0;;10145:18:1;10320:30:0;;;;;;;10361:6;:16;;;;-1:-1:-1;;;;;10361:16:0;;;;;;;;;;10154:231::o;17609:164::-;17687:6;17725:12;17718:5;17714:9;;17706:32;;;;-1:-1:-1;;;17706:32:0;;;;;;;;:::i;:::-;-1:-1:-1;17763:1:0;;17609:164;-1:-1:-1;;17609:164:0:o;18011:199::-;18131:6;18163:1;-1:-1:-1;;;;;18158:6:0;:1;-1:-1:-1;;;;;18158:6:0;;;18166:12;18150:29;;;;;-1:-1:-1;;;18150:29:0;;;;;;;;:::i;:::-;-1:-1:-1;18197:5:0;18201:1;18197;:5;:::i;:::-;18190:12;18011:199;-1:-1:-1;;;;18011:199:0:o;16852:577::-;-1:-1:-1;;;;;16980:17:0;;16972:89;;;;-1:-1:-1;;;16972:89:0;;10774:2:1;16972:89:0;;;10756:21:1;10813:2;10793:18;;;10786:30;10852:34;10832:18;;;10825:62;10923:29;10903:18;;;10896:57;10970:19;;16972:89:0;10572:423:1;16972:89:0;-1:-1:-1;;;;;17080:17:0;;17072:87;;;;-1:-1:-1;;;17072:87:0;;11202:2:1;17072:87:0;;;11184:21:1;11241:2;11221:18;;;11214:30;11280:34;11260:18;;;11253:62;11351:27;11331:18;;;11324:55;11396:19;;17072:87:0;11000:421:1;17072:87:0;-1:-1:-1;;;;;17194:13:0;;;;;;:8;:13;;;;;;;;;;17188:85;;;;;;;;;;;;;;-1:-1:-1;;;;;17194:13:0;;;;17209:6;;17188:85;;;;;;;:5;:85::i;:::-;-1:-1:-1;;;;;17172:13:0;;;;;;;:8;:13;;;;;;;;:101;;-1:-1:-1;;17172:101:0;-1:-1:-1;;;;;17172:101:0;;;;;;17306:13;;;;;;;;;;17300:79;;;;;;;;;;;;;;17306:13;;;;;17321:6;;17300:79;;;;;;;;:5;:79::i;:::-;-1:-1:-1;;;;;17284:13:0;;;;;;;:8;:13;;;;;;;;;:95;;-1:-1:-1;;17284:95:0;-1:-1:-1;;;;;17284:95:0;;;;;;17395:26;;3899:39:1;;;3881:58;;17284:13:0;;17395:26;;;;;;3854:18:1;17395:26:0;3736:209:1;2893:98:0;2951:7;2978:5;2982:1;2978;:5;:::i;:::-;2971:12;2893:98;-1:-1:-1;;;2893:98:0:o;3631:::-;3689:7;3716:5;3720:1;3716;:5;:::i;4030:98::-;4088:7;4115:5;4119:1;4115;:5;:::i;17781:222::-;17901:6;;17931:5;17935:1;17931;:5;:::i;:::-;17920:16;;17960:1;-1:-1:-1;;;;;17955:6:0;:1;-1:-1:-1;;;;;17955:6:0;;;17963:12;17947:29;;;;;-1:-1:-1;;;17947:29:0;;;;;;;;:::i;:::-;-1:-1:-1;17994:1:0;17781:222;-1:-1:-1;;;;17781:222:0:o;14:597:1:-;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;847:196::-;915:20;;-1:-1:-1;;;;;964:54:1;;954:65;;944:93;;1033:1;1030;1023:12;944:93;847:196;;;:::o;1048:254::-;1116:6;1124;1177:2;1165:9;1156:7;1152:23;1148:32;1145:52;;;1193:1;1190;1183:12;1145:52;1216:29;1235:9;1216:29;:::i;:::-;1206:39;1292:2;1277:18;;;;1264:32;;-1:-1:-1;;;1048:254:1:o;1863:328::-;1940:6;1948;1956;2009:2;1997:9;1988:7;1984:23;1980:32;1977:52;;;2025:1;2022;2015:12;1977:52;2048:29;2067:9;2048:29;:::i;:::-;2038:39;;2096:38;2130:2;2119:9;2115:18;2096:38;:::i;:::-;2086:48;;2181:2;2170:9;2166:18;2153:32;2143:42;;1863:328;;;;;:::o;2582:186::-;2641:6;2694:2;2682:9;2673:7;2669:23;2665:32;2662:52;;;2710:1;2707;2700:12;2662:52;2733:29;2752:9;2733:29;:::i;2773:693::-;2884:6;2892;2900;2908;2916;2924;2932;2985:3;2973:9;2964:7;2960:23;2956:33;2953:53;;;3002:1;2999;2992:12;2953:53;3025:29;3044:9;3025:29;:::i;:::-;3015:39;;3073:38;3107:2;3096:9;3092:18;3073:38;:::i;:::-;3063:48;;3158:2;3147:9;3143:18;3130:32;3120:42;;3209:2;3198:9;3194:18;3181:32;3171:42;;3263:3;3252:9;3248:19;3235:33;3308:4;3301:5;3297:16;3290:5;3287:27;3277:55;;3328:1;3325;3318:12;3277:55;2773:693;;;;-1:-1:-1;2773:693:1;;;;3351:5;3403:3;3388:19;;3375:33;;-1:-1:-1;3455:3:1;3440:19;;;3427:33;;2773:693;-1:-1:-1;;2773:693:1:o;3471:260::-;3539:6;3547;3600:2;3588:9;3579:7;3575:23;3571:32;3568:52;;;3616:1;3613;3606:12;3568:52;3639:29;3658:9;3639:29;:::i;:::-;3629:39;;3687:38;3721:2;3710:9;3706:18;3687:38;:::i;:::-;3677:48;;3471:260;;;;;:::o;6696:184::-;-1:-1:-1;;;6745:1:1;6738:88;6845:4;6842:1;6835:15;6869:4;6866:1;6859:15;6885:135;6924:3;-1:-1:-1;;6945:17:1;;6942:43;;;6965:18;;:::i;:::-;-1:-1:-1;7012:1:1;7001:13;;6885:135::o;10330:237::-;10369:4;-1:-1:-1;;;;;10474:10:1;;;;10444;;10496:12;;;10493:38;;;10511:18;;:::i;:::-;10548:13;;10330:237;-1:-1:-1;;;10330:237:1:o;11426:128::-;11466:3;11497:1;11493:6;11490:1;11487:13;11484:39;;;11503:18;;:::i;:::-;-1:-1:-1;11539:9:1;;11426:128::o;11559:168::-;11599:7;11665:1;11661;11657:6;11653:14;11650:1;11647:21;11642:1;11635:9;11628:17;11624:45;11621:71;;;11672:18;;:::i;:::-;-1:-1:-1;11712:9:1;;11559:168::o;11732:274::-;11772:1;11798;11788:189;;-1:-1:-1;;;11830:1:1;11823:88;11934:4;11931:1;11924:15;11962:4;11959:1;11952:15;11788:189;-1:-1:-1;11991:9:1;;11732:274::o;12011:244::-;12050:3;-1:-1:-1;;;;;12131:2:1;12128:1;12124:10;12161:2;12158:1;12154:10;12192:3;12188:2;12184:12;12179:3;12176:21;12173:47;;;12200:18;;:::i;:::-;12236:13;;12011:244;-1:-1:-1;;;;12011:244:1:o

ipfs://89cc78e8f89503ba4205cb70c5a3b863ed46c10a83ba7884bc65b4ae203f11b3