Contract 0x44Bb1a3E56Cb12b7B1a8E925f09A170e3646346d 1

/**
 *Submitted for verification at polygonscan.com on 2022-06-14
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin\contracts\math\SafeMath.sol

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

// File: @openzeppelin\contracts\utils\Address.sol

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

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

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

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

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

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

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

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

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

// File: @openzeppelin\contracts\token\ERC20\SafeERC20.sol

pragma solidity ^0.6.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
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));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    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, "SafeERC20: decreased allowance below zero");
        _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. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "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");
        }
    }
}

// File: @openzeppelin\contracts\GSN\Context.sol

pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

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

// File: @openzeppelin\contracts\access\Ownable.sol

pragma solidity ^0.6.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract Ownable is Context {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

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

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: @openzeppelin\contracts\utils\ReentrancyGuard.sol

pragma solidity ^0.6.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @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() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: contracts\libraries\BoringERC20.sol

pragma solidity 0.6.12;

// solhint-disable avoid-low-level-calls

library BoringERC20 {
    bytes4 private constant SIG_SYMBOL = 0x95d89b41; // symbol()
    bytes4 private constant SIG_NAME = 0x06fdde03; // name()
    bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals()
    bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256)
    bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256)

    function returnDataToString(bytes memory data) internal pure returns (string memory) {
        if (data.length >= 64) {
            return abi.decode(data, (string));
        } else if (data.length == 32) {
            uint8 i = 0;
            while (i < 32 && data[i] != 0) {
                i++;
            }
            bytes memory bytesArray = new bytes(i);
            for (i = 0; i < 32 && data[i] != 0; i++) {
                bytesArray[i] = data[i];
            }
            return string(bytesArray);
        } else {
            return "???";
        }
    }

    /// @notice Provides a safe ERC20.symbol version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token symbol.
    function safeSymbol(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_SYMBOL));
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.name version which returns '???' as fallback string.
    /// @param token The address of the ERC-20 token contract.
    /// @return (string) Token name.
    function safeName(IERC20 token) internal view returns (string memory) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_NAME));
        return success ? returnDataToString(data) : "???";
    }

    /// @notice Provides a safe ERC20.decimals version which returns '18' as fallback value.
    /// @param token The address of the ERC-20 token contract.
    /// @return (uint8) Token decimals.
    function safeDecimals(IERC20 token) internal view returns (uint8) {
        (bool success, bytes memory data) = address(token).staticcall(abi.encodeWithSelector(SIG_DECIMALS));
        return success && data.length == 32 ? abi.decode(data, (uint8)) : 18;
    }

    /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransfer(
        IERC20 token,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed");
    }

    /// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations.
    /// Reverts on a failed transfer.
    /// @param token The address of the ERC-20 token.
    /// @param from Transfer tokens from.
    /// @param to Transfer tokens to.
    /// @param amount The token amount.
    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        (bool success, bytes memory data) = address(token).call(
            abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount)
        );
        require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed");
    }
}

// File: @openzeppelin\contracts\token\ERC20\ERC20.sol

pragma solidity ^0.6.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// File: contracts\AuraToken.sol

pragma solidity 0.6.12;


// AuraToken with Governance.
contract AuraToken is ERC20("AuraSwap Token", "AURA"), Ownable {

    /// @notice Total number of tokens
    uint256 public constant maxSupply = 100_000_000e18; // 100_000_000 Aura

    /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
    function mint(address _to, uint256 _amount) public onlyOwner {
        if(totalSupply().add(_amount) <= maxSupply){
            _mint(_to, _amount);
            _moveDelegates(address(0), _delegates[_to], _amount);
        }
    }

    // Copied and modified from YAM code:
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
    // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
    // Which is copied and modified from COMPOUND:
    // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol

    /// @notice A record of each accounts delegate
    mapping (address => address) internal _delegates;

    /// @notice A checkpoint for marking number of votes from a given block
    struct Checkpoint {
        uint32 fromBlock;
        uint256 votes;
    }

    /// @notice A record of votes checkpoints for each account, by index
    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;

    /// @notice The number of checkpoints for each account
    mapping (address => uint32) public numCheckpoints;

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

    /// @notice The EIP-712 typehash for the delegation struct used by the contract
    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");

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

      /// @notice An event thats emitted when an account changes its delegate
    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);

    /// @notice An event thats emitted when a delegate account's vote balance changes
    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);

    /**
     * @notice Delegate votes from `msg.sender` to `delegatee`
     * @param delegator The address to get delegatee for
     */
    function delegates(address delegator)
        external
        view
        returns (address)
    {
        return _delegates[delegator];
    }

   /**
    * @notice Delegate votes from `msg.sender` to `delegatee`
    * @param delegatee The address to delegate votes to
    */
    function delegate(address delegatee) external {
        return _delegate(msg.sender, delegatee);
    }

    /**
     * @notice Delegates votes from signatory to `delegatee`
     * @param delegatee The address to delegate votes to
     * @param nonce The contract state required to match the signature
     * @param expiry 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 delegateBySig(
        address delegatee,
        uint nonce,
        uint expiry,
        uint8 v,
        bytes32 r,
        bytes32 s
    )
        external
    {
        bytes32 domainSeparator = keccak256(
            abi.encode(
                DOMAIN_TYPEHASH,
                keccak256(bytes(name())),
                getChainId(),
                address(this)
            )
        );

        bytes32 structHash = keccak256(
            abi.encode(
                DELEGATION_TYPEHASH,
                delegatee,
                nonce,
                expiry
            )
        );

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                structHash
            )
        );

        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "AURA::delegateBySig: invalid signature");
        require(nonce == nonces[signatory]++, "AURA::delegateBySig: invalid nonce");
        require(now <= expiry, "AURA::delegateBySig: signature expired");
        return _delegate(signatory, delegatee);
    }

    /**
     * @notice Gets the current votes balance for `account`
     * @param account The address to get votes balance
     * @return The number of current votes for `account`
     */
    function getCurrentVotes(address account)
        external
        view
        returns (uint256)
    {
        uint32 nCheckpoints = numCheckpoints[account];
        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
    }

    /**
     * @notice Determine the prior number of votes for an account as of a block number
     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
     * @param account The address of the account to check
     * @param blockNumber The block number to get the vote balance at
     * @return The number of votes the account had as of the given block
     */
    function getPriorVotes(address account, uint blockNumber)
        external
        view
        returns (uint256)
    {
        require(blockNumber < block.number, "AURA::getPriorVotes: not yet determined");

        uint32 nCheckpoints = numCheckpoints[account];
        if (nCheckpoints == 0) {
            return 0;
        }

        // First check most recent balance
        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
            return checkpoints[account][nCheckpoints - 1].votes;
        }

        // Next check implicit zero balance
        if (checkpoints[account][0].fromBlock > blockNumber) {
            return 0;
        }

        uint32 lower = 0;
        uint32 upper = nCheckpoints - 1;
        while (upper > lower) {
            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
            Checkpoint memory cp = checkpoints[account][center];
            if (cp.fromBlock == blockNumber) {
                return cp.votes;
            } else if (cp.fromBlock < blockNumber) {
                lower = center;
            } else {
                upper = center - 1;
            }
        }
        return checkpoints[account][lower].votes;
    }

    function _delegate(address delegator, address delegatee)
        internal
    {
        address currentDelegate = _delegates[delegator];
        uint256 delegatorBalance = balanceOf(delegator); // balance of underlying AURAs (not scaled);
        _delegates[delegator] = delegatee;

        emit DelegateChanged(delegator, currentDelegate, delegatee);

        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
    }

    function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
        if (srcRep != dstRep && amount > 0) {
            if (srcRep != address(0)) {
                // decrease old representative
                uint32 srcRepNum = numCheckpoints[srcRep];
                uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
                uint256 srcRepNew = srcRepOld.sub(amount);
                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
            }

            if (dstRep != address(0)) {
                // increase new representative
                uint32 dstRepNum = numCheckpoints[dstRep];
                uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
                uint256 dstRepNew = dstRepOld.add(amount);
                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
            }
        }
    }

    function _writeCheckpoint(
        address delegatee,
        uint32 nCheckpoints,
        uint256 oldVotes,
        uint256 newVotes
    )
        internal
    {
        uint32 blockNumber = safe32(block.number, "AURA::_writeCheckpoint: block number exceeds 32 bits");

        if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
            checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
        } else {
            checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
            numCheckpoints[delegatee] = nCheckpoints + 1;
        }

        emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
    }

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

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

// File: contracts\SousChef.sol

pragma solidity 0.6.12;
contract SousChef is Ownable {
    // The AURA TOKEN
    AuraToken public aura;

    constructor(
        AuraToken _aura
    ) public {
        aura = _aura;
    }

    // Safe aura transfer function, just in case if rounding error causes pool to not have enough AURAs.
    function safeAuraTransfer(address _to, uint256 _amount) public onlyOwner {
        uint256 auraBal = aura.balanceOf(address(this));
        if (_amount > auraBal) {
            aura.transfer(_to, auraBal);
        } else {
            aura.transfer(_to, _amount);
        }
    }
}

// File: contracts\MasterChef.sol

pragma solidity 0.6.12;
pragma experimental ABIEncoderV2;
interface IRewarder {
    function onAuraReward(address user, uint256 newLpAmount) external;
    function pendingTokens(address user) external view returns (uint256 pending);
    function rewardToken() external view returns (IERC20);
}

contract MasterChef is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using BoringERC20 for IERC20;

    /// @notice Info of each user.
    /// `amount` LP token amount the user has provided.
    /// `rewardDebt` The amount of AURA entitled to the user.
    struct UserInfo {
        uint256 amount;
        uint256 rewardDebt;
    }

    /// @notice Info of each pool.
    /// `lpToken` Address of LP token contract.
    /// `allocPoint` The amount of allocation points assigned to the pool.
    ///     Also known as the amount of AURA to distribute per second.
    /// `lastRewardTimestamp` Last timestamp that AURAs distribution occurs.
    /// `accAuraPerShare` Accumulated AURAs per share.
    struct PoolInfo {
        IERC20 lpToken;
        uint256 allocPoint;
        uint256 lastRewardTimestamp;
        uint256 accAuraPerShare;
        IRewarder rewarder;
    }

    /// @notice The AURA TOKEN!
    AuraToken public aura;
    /// @notice The SOUS CHEF!
    SousChef public sous;
    /// @notice DEV address.
    address public devAddr;
    /// @notice AURA tokens created per second.
    uint256 public auraPerSec;
    /// @notice Limit aura per sec
    uint256 public auraPerSecLimit;

    /// @notice Info of each pool.
    PoolInfo[] public poolInfo;
    /// @notice Mapping to check which LP tokens have been added as pools.
    mapping(IERC20 => bool) public isPool;
    /// @notice Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;
    /// @notice Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint;
    /// @notice The timestamp when AURA mining starts.
    uint256 public startTimestamp;
    uint256 public constant ACC_AURA_PRECISION = 1e18;

    event Add(uint256 indexed pid, uint256 allocPoint, IERC20 indexed lpToken, IRewarder indexed rewarder);
    event Set(uint256 indexed pid, uint256 allocPoint, IRewarder indexed rewarder, bool overwrite);
    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event UpdatePool(uint256 indexed pid, uint256 lastRewardTimestamp, uint256 lpSupply, uint256 accAuraPerShare);
    event Harvest(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event SetDevAddress(address indexed oldAddress, address indexed newAddress);
    event UpdateEmissionRate(address indexed user, uint256 auraPerSec);

    constructor(
        AuraToken _aura,
        SousChef _sous,
        address _devAddr,
        uint256 _auraPerSec,
        uint256 _startTimestamp
    ) public {
        aura = _aura;
        sous = _sous;
        devAddr = _devAddr;
        auraPerSec = _auraPerSec;
        auraPerSecLimit = _auraPerSec;
        startTimestamp = _startTimestamp;
        totalAllocPoint = 0;
    }

    /// @notice Returns the number of MasterChef pools.
    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    /// @notice Add a new lp to the pool. Can only be called by the owner.
    /// DO NOT add the same LP token more than once. Rewards will be messed up if you do.
    /// @param _allocPoint AP of the new pool.
    /// @param _lpToken Address of the LP ERC-20 token.
    /// @param _rewarder Address of the rewarder delegate.
    /// @param _withUpdate Whether call "massUpdatePools" operation.
    function add(
        uint256 _allocPoint,
        IERC20 _lpToken,
        IRewarder _rewarder,
        bool _withUpdate
    ) external onlyOwner {
        require(!isPool[_lpToken], "add: LP already added");
        // Sanity check to ensure _lpToken is an ERC20 token
        _lpToken.balanceOf(address(this));
        // Sanity check if we add a rewarder
        if (address(_rewarder) != address(0)) {
            _rewarder.onAuraReward(address(0), 0);
        }
        if (_withUpdate) {
            massUpdatePools();
        }

        uint256 lastRewardTimestamp = block.timestamp > startTimestamp ? block.timestamp : startTimestamp;
        totalAllocPoint = totalAllocPoint.add(_allocPoint);

        poolInfo.push(
            PoolInfo({
                lpToken: _lpToken,
                allocPoint: _allocPoint,
                lastRewardTimestamp: lastRewardTimestamp,
                accAuraPerShare: 0,
                rewarder: _rewarder
            })
        );
        isPool[_lpToken] = true;
        emit Add(poolInfo.length.sub(1), _allocPoint, _lpToken, _rewarder);
    }

    /// @notice Update the given pool's AURA allocation point and `IRewarder` contract. Can only be called by the owner.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _allocPoint New AP of the pool.
    /// @param _rewarder Address of the rewarder delegate.
    /// @param overwrite True if _rewarder should be `set`. Otherwise `_rewarder` is ignored.
    /// @param _withUpdate Whether call "massUpdatePools" operation.
    function set(
        uint256 _pid,
        uint256 _allocPoint,
        IRewarder _rewarder,
        bool overwrite,
        bool _withUpdate
    ) external onlyOwner {
        // No matter _withUpdate is true or false, we need to execute updatePool once before set the pool parameters.
        updatePool(_pid);

        if (_withUpdate) {
            massUpdatePools();
        }

        totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint);
        poolInfo[_pid].allocPoint = _allocPoint;
        if (overwrite) {
            _rewarder.onAuraReward(address(0), 0); // sanity check
            poolInfo[_pid].rewarder = _rewarder;
        }
        emit Set(_pid, _allocPoint, overwrite ? _rewarder : poolInfo[_pid].rewarder, overwrite);
    }

    /// @notice View function to see pending AURA on frontend.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _user Address of user.
    /// @return pendingAura AURA reward for a given user.
    //          bonusTokenAddress The address of the bonus reward.
    //          bonusTokenSymbol The symbol of the bonus token.
    //          pendingBonusToken The amount of bonus rewards pending.
    function pendingTokens(uint256 _pid, address _user)
        external
        view
        returns (
            uint256 pendingAura,
            address bonusTokenAddress,
            string memory bonusTokenSymbol,
            uint256 pendingBonusToken
        )
    {
        PoolInfo memory pool = poolInfo[_pid];
        UserInfo memory user = userInfo[_pid][_user];
        uint256 accAuraPerShare = pool.accAuraPerShare;
        uint256 lpSupply = pool.lpToken.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTimestamp && lpSupply != 0) {
            uint256 timeElapsed = block.timestamp.sub(pool.lastRewardTimestamp);
            uint256 auraReward = timeElapsed.mul(auraPerSec).mul(pool.allocPoint).div(totalAllocPoint);
            accAuraPerShare = accAuraPerShare.add(auraReward.mul(ACC_AURA_PRECISION).div(lpSupply));
        }
        pendingAura = user.amount.mul(accAuraPerShare).div(ACC_AURA_PRECISION).sub(user.rewardDebt);

        // If it's a double reward farm, we return info about the bonus token
        if (address(pool.rewarder) != address(0)) {
            bonusTokenAddress = address(pool.rewarder.rewardToken());
            bonusTokenSymbol = IERC20(pool.rewarder.rewardToken()).safeSymbol();
            pendingBonusToken = pool.rewarder.pendingTokens(_user);
        }
    }

    /// @notice Update aura reward for all the active pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            PoolInfo memory pool = poolInfo[pid];
            if (pool.allocPoint != 0) {
                updatePool(pid);
            }
        }
    }

    /// @notice Update reward variables of the given pool.
    /// @param _pid The index of the pool. See `poolInfo`.
    function updatePool(uint256 _pid) public {
        PoolInfo memory pool = poolInfo[_pid];
        if (block.timestamp > pool.lastRewardTimestamp) {
            uint256 lpSupply = pool.lpToken.balanceOf(address(this));
            // gas opt and prevent div by 0
            if (lpSupply > 0 && totalAllocPoint > 0) {
                uint256 timeElapsed = block.timestamp.sub(pool.lastRewardTimestamp);
                uint256 auraReward = timeElapsed.mul(auraPerSec).mul(pool.allocPoint).div(totalAllocPoint);
                aura.mint(devAddr, auraReward.div(8));
                aura.mint(address(sous), auraReward);
                pool.accAuraPerShare = pool.accAuraPerShare.add(auraReward.mul(ACC_AURA_PRECISION).div(lpSupply));
            }
            pool.lastRewardTimestamp = block.timestamp;
            poolInfo[_pid] = pool;
            emit UpdatePool(_pid, pool.lastRewardTimestamp, lpSupply, pool.accAuraPerShare);
        }
    }

    /// @notice Deposit LP tokens to MasterChef for Aura allocation.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _amount LP token amount to deposit.
    function deposit(uint256 _pid, uint256 _amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        updatePool(_pid);

        if (user.amount > 0) {
            // Harvest AURA
            uint256 pending = user.amount.mul(pool.accAuraPerShare).div(ACC_AURA_PRECISION).sub(user.rewardDebt);
            if(pending > 0) {
                safeAuraTransfer(msg.sender, pending);
                emit Harvest(msg.sender, _pid, pending);
            }
        }
        if (_amount > 0) {
            pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount);
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accAuraPerShare).div(ACC_AURA_PRECISION);

        IRewarder rewarder = pool.rewarder;
        if (address(rewarder) != address(0)) {
            rewarder.onAuraReward(msg.sender, user.amount);
        }
        emit Deposit(msg.sender, _pid, _amount);
    }

    /// @notice Withdraw LP tokens from MasterChef.
    /// @param _pid The index of the pool. See `poolInfo`.
    /// @param _amount LP token amount to withdraw.
    function withdraw(uint256 _pid, uint256 _amount) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "withdraw: Insufficient");

        updatePool(_pid);

        // Harvest AURA
        uint256 pending = user.amount.mul(pool.accAuraPerShare).div(ACC_AURA_PRECISION).sub(user.rewardDebt);
        if(pending > 0) {
            safeAuraTransfer(msg.sender, pending);
            emit Harvest(msg.sender, _pid, pending);
        }
        if(_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.lpToken.safeTransfer(address(msg.sender), _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accAuraPerShare).div(ACC_AURA_PRECISION);

        IRewarder rewarder = pool.rewarder;
        if (address(rewarder) != address(0)) {
            rewarder.onAuraReward(msg.sender, user.amount);
        }
        emit Withdraw(msg.sender, _pid, _amount);
    }

    /// @notice Withdraw without caring about rewards. EMERGENCY ONLY.
    /// @param _pid The index of the pool. See `poolInfo`.
    function emergencyWithdraw(uint256 _pid) external nonReentrant {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];

        uint256 amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        IRewarder rewarder = pool.rewarder;
        if (address(rewarder) != address(0)) {
            rewarder.onAuraReward(msg.sender, 0);
        }

        // Note: transfer can fail or succeed if `amount` is zero.
        pool.lpToken.safeTransfer(address(msg.sender), amount);
        emit EmergencyWithdraw(msg.sender, _pid, amount);

    }

    /// @notice Safe aura transfer function, just in case if rounding error causes pool to not have enough AURAs.
    function safeAuraTransfer(address _to, uint256 _amount) internal {
        sous.safeAuraTransfer(_to, _amount);
    }

    /// @notice Update dev address by the previous dev.
    function dev(address _devAddr) external {
        require(msg.sender == devAddr, "dev: wut?");
        devAddr = _devAddr;
        emit SetDevAddress(msg.sender, _devAddr);
    }

    /// @notice Update aura per second
    function updateEmissionRate(uint256 _auraPerSec) external onlyOwner {
        require(_auraPerSec < auraPerSecLimit, "updateEmissionRate: cannot exceed auraPerSecLimit");
        massUpdatePools();
        auraPerSec = _auraPerSec;
        emit UpdateEmissionRate(msg.sender, _auraPerSec);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract AuraToken","name":"_aura","type":"address"},{"internalType":"contract SousChef","name":"_sous","type":"address"},{"internalType":"address","name":"_devAddr","type":"address"},{"internalType":"uint256","name":"_auraPerSec","type":"uint256"},{"internalType":"uint256","name":"_startTimestamp","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IERC20","name":"lpToken","type":"address"},{"indexed":true,"internalType":"contract IRewarder","name":"rewarder","type":"address"}],"name":"Add","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Harvest","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":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allocPoint","type":"uint256"},{"indexed":true,"internalType":"contract IRewarder","name":"rewarder","type":"address"},{"indexed":false,"internalType":"bool","name":"overwrite","type":"bool"}],"name":"Set","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"auraPerSec","type":"uint256"}],"name":"UpdateEmissionRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpSupply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accAuraPerShare","type":"uint256"}],"name":"UpdatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"ACC_AURA_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"aura","outputs":[{"internalType":"contract AuraToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auraPerSec","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auraPerSecLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddr","type":"address"}],"name":"dev","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"devAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"isPool","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingTokens","outputs":[{"internalType":"uint256","name":"pendingAura","type":"uint256"},{"internalType":"address","name":"bonusTokenAddress","type":"address"},{"internalType":"string","name":"bonusTokenSymbol","type":"string"},{"internalType":"uint256","name":"pendingBonusToken","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTimestamp","type":"uint256"},{"internalType":"uint256","name":"accAuraPerShare","type":"uint256"},{"internalType":"contract IRewarder","name":"rewarder","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IRewarder","name":"_rewarder","type":"address"},{"internalType":"bool","name":"overwrite","type":"bool"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sous","outputs":[{"internalType":"contract SousChef","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_auraPerSec","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000001b7805e2829fd7d194dcc3078a4199b13c77e467000000000000000000000000266eb9a845f677b1e24d59a4c0fdc24f625f7757000000000000000000000000af919587175a57d7f108af412f57f491297b1e7700000000000000000000000000000000000000000000000012bc29d8eec700000000000000000000000000000000000000000000000000000000000062b5b550

-----Decoded View---------------
Arg [0] : _aura (address): 0x1b7805e2829fd7d194dcc3078a4199b13c77e467
Arg [1] : _sous (address): 0x266eb9a845f677b1e24d59a4c0fdc24f625f7757
Arg [2] : _devAddr (address): 0xaf919587175a57d7f108af412f57f491297b1e77
Arg [3] : _auraPerSec (uint256): 1350000000000000000
Arg [4] : _startTimestamp (uint256): 1656075600

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000001b7805e2829fd7d194dcc3078a4199b13c77e467
Arg [1] : 000000000000000000000000266eb9a845f677b1e24d59a4c0fdc24f625f7757
Arg [2] : 000000000000000000000000af919587175a57d7f108af412f57f491297b1e77
Arg [3] : 00000000000000000000000000000000000000000000000012bc29d8eec70000
Arg [4] : 0000000000000000000000000000000000000000000000000000000062b5b550

49111:13364:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52243:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62172:300;;;;;;:::i;:::-;;:::i;:::-;;50403:26;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;50782:30::-;;;:::i;54339:798::-;;;;;;:::i;:::-;;:::i;59827:1037::-;;;;;;:::i;:::-;;:::i;50911:49::-;;;:::i;57446:963::-;;;;;;:::i;:::-;;:::i;61004:631::-;;;;;;:::i;:::-;;:::i;50512:37::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;57027:291::-;;;:::i;20829:148::-;;;:::i;50328:30::-;;;:::i;61942:182::-;;;;;;:::i;:::-;;:::i;20187:79::-;;;:::i;:::-;;;;;;;:::i;50614:64::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;50260:25::-;;;:::i;50125:20::-;;;:::i;52748:1128::-;;;;;;:::i;:::-;;:::i;50182:22::-;;;:::i;50065:21::-;;;:::i;58599:1054::-;;;;;;:::i;:::-;;:::i;50875:29::-;;;:::i;21132:244::-;;;;;;:::i;:::-;;:::i;55572:1357::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;52243:95::-;52315:8;:15;52243:95;:::o;62172:300::-;20409:12;:10;:12::i;:::-;20399:6;;-1:-1:-1;;;;;20399:6:0;;;:22;;;20391:67;;;;-1:-1:-1;;;20391:67:0;;;;;;;:::i;:::-;;;;;;;;;62273:15:::1;;62259:11;:29;62251:91;;;;-1:-1:-1::0;;;62251:91:0::1;;;;;;;:::i;:::-;62353:17;:15;:17::i;:::-;62381:10;:24:::0;;;62421:43:::1;::::0;62440:10:::1;::::0;62421:43:::1;::::0;::::1;::::0;62394:11;;62421:43:::1;:::i;:::-;;;;;;;;62172:300:::0;:::o;50403:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;50403:26:0;;;;-1:-1:-1;50403:26:0;;;;;;;;:::o;50782:30::-;;;;:::o;54339:798::-;20409:12;:10;:12::i;:::-;20399:6;;-1:-1:-1;;;;;20399:6:0;;;:22;;;20391:67;;;;-1:-1:-1;;;20391:67:0;;;;;;;:::i;:::-;54643:16:::1;54654:4;54643:10;:16::i;:::-;54676:11;54672:61;;;54704:17;:15;:17::i;:::-;54763:63;54814:11;54763:46;54783:8;54792:4;54783:14;;;;;;;;;;;;;;;;;;:25;;;54763:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;54745:15;:81;;;;54865:11;54837:8;54846:4;54837:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;54891:9;54887:145;;;54917:37;::::0;-1:-1:-1;;;54917:37:0;;-1:-1:-1;;;;;54917:22:0;::::1;::::0;::::1;::::0;:37:::1;::::0;54948:1:::1;::::0;;;54917:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;55011:9;54985:8;54994:4;54985:14;;;;;;;;;;;;;;;;;;:23;;;:35;;;;;-1:-1:-1::0;;;;;54985:35:0::1;;;;;-1:-1:-1::0;;;;;54985:35:0::1;;;;;;54887:145;55070:9;:47;;55094:8;55103:4;55094:14;;;;;;;;;::::0;;;::::1;::::0;;;:23:::1;:14;::::0;;::::1;;:23;::::0;-1:-1:-1;;;;;55094:23:0::1;55070:47;;;55082:9;55070:47;-1:-1:-1::0;;;;;55047:82:0::1;55051:4;55047:82;55057:11;55119:9;55047:82;;;;;;;:::i;:::-;;;;;;;;54339:798:::0;;;;;:::o;59827:1037::-;23114:1;23720:7;;:19;;23712:63;;;;-1:-1:-1;;;23712:63:0;;;;;;;:::i;:::-;23114:1;23853:7;:18;;;;59909:21:::1;59933:8;59942:4;59933:14;;;;;;;;;::::0;;;::::1;::::0;;;59982;;;:8:::1;:14:::0;;;;;;59997:10:::1;59982:26:::0;;;;;;;60027:11;;59933:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;60027:22:0;-1:-1:-1;60027:22:0::1;60019:57;;;;-1:-1:-1::0;;;60019:57:0::1;;;;;;;:::i;:::-;60089:16;60100:4;60089:10;:16::i;:::-;60143:15;60161:82;60227:4;:15;;;60161:61;50956:4;60161:37;60177:4;:20;;;60161:4;:11;;;:15;;:37;;;;:::i;:::-;:41:::0;::::1;:61::i;:::-;:65:::0;::::1;:82::i;:::-;60143:100:::0;-1:-1:-1;60257:11:0;;60254:134:::1;;60285:37;60302:10;60314:7;60285:16;:37::i;:::-;60362:4;60350:10;-1:-1:-1::0;;;;;60342:34:0::1;;60368:7;60342:34;;;;;;:::i;:::-;;;;;;;;60254:134;60401:11:::0;;60398:151:::1;;60443:11:::0;;:24:::1;::::0;60459:7;60443:15:::1;:24::i;:::-;60429:38:::0;;60482:12;;:55:::1;::::0;-1:-1:-1;;;;;60482:12:0::1;60516:10;60529:7:::0;60482:25:::1;:55::i;:::-;60593:20;::::0;::::1;::::0;60577:11;;:61:::1;::::0;50956:4:::1;::::0;60577:37:::1;::::0;:15:::1;:37::i;:61::-;60559:15;::::0;::::1;:79:::0;60672:13:::1;::::0;::::1;::::0;-1:-1:-1;;;;;60672:13:0::1;60700:31:::0;;60696:110:::1;;60782:11:::0;;60748:46:::1;::::0;-1:-1:-1;;;60748:46:0;;-1:-1:-1;;;;;60748:21:0;::::1;::::0;::::1;::::0;:46:::1;::::0;60770:10:::1;::::0;60748:46:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;60696:110;60842:4;60830:10;-1:-1:-1::0;;;;;60821:35:0::1;;60848:7;60821:35;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;23070:1:0;24032:22;;-1:-1:-1;;;;59827:1037:0:o;50911:49::-;50956:4;50911:49;:::o;57446:963::-;57498:20;;:::i;:::-;57521:8;57530:4;57521:14;;;;;;;;;;;;;;;;;57498:37;;;;;;;;57521:14;;;;;;;57498:37;;-1:-1:-1;;;;;57498:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57550:15:0;:42;57546:856;;;57628:12;;:37;;-1:-1:-1;;;57628:37:0;;57609:16;;-1:-1:-1;;;;;57628:22:0;;;;:37;;57659:4;;57628:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57609:56;;57740:1;57729:8;:12;:35;;;;;57763:1;57745:15;;:19;57729:35;57725:479;;;57785:19;57807:45;57827:4;:24;;;57807:15;:19;;:45;;;;:::i;:::-;57785:67;;57871:18;57892:69;57945:15;;57892:48;57924:4;:15;;;57892:27;57908:10;;57892:11;:15;;:27;;;;:::i;:::-;:31;;:48::i;:69::-;57980:4;;57990:7;;57871:90;;-1:-1:-1;;;;;;57980:4:0;;;;:9;;57990:7;57999:17;57871:90;58014:1;57999:14;:17::i;:::-;57980:37;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;58036:4:0;;58054;;58036:36;;-1:-1:-1;;;58036:36:0;;-1:-1:-1;;;;;58036:4:0;;;;-1:-1:-1;58036:9:0;;-1:-1:-1;58036:36:0;;58054:4;;;;58061:10;;58036:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58114:74;58139:48;58178:8;58139:34;50956:4;58139:10;:14;;:34;;;;:::i;:48::-;58114:20;;;;;:24;:74::i;:::-;58091:20;;;:97;-1:-1:-1;;57725:479:0;58245:15;58218:24;;;:42;58275:8;:14;;58218:4;;58275:8;58284:4;;58275:14;;;;;;;;;;;;;;;:21;;:14;;;;;:21;;-1:-1:-1;;;;;58275:21:0;;;-1:-1:-1;;;;;;58275:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58333:24;;;;58369:20;;;;58316:74;;58327:4;;58316:74;;;;58359:8;;58369:20;58316:74;:::i;:::-;;;;;;;;57546:856;;57446:963;;:::o;61004:631::-;23114:1;23720:7;;:19;;23712:63;;;;-1:-1:-1;;;23712:63:0;;;;;;;:::i;:::-;23114:1;23853:7;:18;;;;61078:21:::1;61102:8;61111:4;61102:14;;;;;;;;;::::0;;;::::1;::::0;;;61151;;;:8:::1;:14:::0;;;;;;61166:10:::1;61151:26:::0;;;;;;;;61207:11;;61229:15;;;-1:-1:-1;61255:15:0;::::1;:19:::0;;;;61102:14:::1;::::0;;;::::1;;61308:13;::::0;::::1;::::0;61102:14;;-1:-1:-1;61151:26:0;;61207:11;-1:-1:-1;;;;;61308:13:0::1;61336:31:::0;;61332:100:::1;;61384:36;::::0;-1:-1:-1;;;61384:36:0;;-1:-1:-1;;;;;61384:21:0;::::1;::::0;::::1;::::0;:36:::1;::::0;61406:10:::1;::::0;61418:1:::1;::::0;61384:36:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;61332:100;61512:12:::0;;:54:::1;::::0;-1:-1:-1;;;;;61512:12:0::1;61546:10;61559:6:::0;61512:25:::1;:54::i;:::-;61612:4;61600:10;-1:-1:-1::0;;;;;61582:43:0::1;;61618:6;61582:43;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;23070:1:0;24032:22;;-1:-1:-1;;;61004:631:0:o;50512:37::-;;;;;;;;;;;;;;;:::o;57027:291::-;57089:8;:15;57072:14;57115:196;57143:6;57137:3;:12;57115:196;;;57173:20;;:::i;:::-;57196:8;57205:3;57196:13;;;;;;;;;;;;;;;;;57173:36;;;;;;;;57196:13;;;;;;;57173:36;;-1:-1:-1;;;;;57173:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57228:20:0;57224:76;;57269:15;57280:3;57269:10;:15::i;:::-;-1:-1:-1;57151:5:0;;57115:196;;20829:148;20409:12;:10;:12::i;:::-;20399:6;;-1:-1:-1;;;;;20399:6:0;;;:22;;;20391:67;;;;-1:-1:-1;;;20391:67:0;;;;;;;:::i;:::-;20936:1:::1;20920:6:::0;;20899:40:::1;::::0;-1:-1:-1;;;;;20920:6:0;;::::1;::::0;20899:40:::1;::::0;20936:1;;20899:40:::1;20967:1;20950:19:::0;;-1:-1:-1;;;;;;20950:19:0::1;::::0;;20829:148::o;50328:30::-;;;;:::o;61942:182::-;62015:7;;-1:-1:-1;;;;;62015:7:0;62001:10;:21;61993:43;;;;-1:-1:-1;;;61993:43:0;;;;;;;:::i;:::-;62047:7;:18;;-1:-1:-1;;;;;;62047:18:0;-1:-1:-1;;;;;62047:18:0;;;;;;;;62081:35;;62095:10;;62081:35;;-1:-1:-1;;62081:35:0;61942:182;:::o;20187:79::-;20225:7;20252:6;-1:-1:-1;;;;;20252:6:0;20187:79;:::o;50614:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50260:25::-;;;;:::o;50125:20::-;;;-1:-1:-1;;;;;50125:20:0;;:::o;52748:1128::-;20409:12;:10;:12::i;:::-;20399:6;;-1:-1:-1;;;;;20399:6:0;;;:22;;;20391:67;;;;-1:-1:-1;;;20391:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;52920:16:0;::::1;;::::0;;;:6:::1;:16;::::0;;;;;::::1;;52919:17;52911:51;;;;-1:-1:-1::0;;;52911:51:0::1;;;;;;;:::i;:::-;53035:33;::::0;-1:-1:-1;;;53035:33:0;;-1:-1:-1;;;;;53035:18:0;::::1;::::0;::::1;::::0;:33:::1;::::0;53062:4:::1;::::0;53035:33:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;;53129:32:0;::::1;::::0;53125:102:::1;;53178:37;::::0;-1:-1:-1;;;53178:37:0;;-1:-1:-1;;;;;53178:22:0;::::1;::::0;::::1;::::0;:37:::1;::::0;53209:1:::1;::::0;;;53178:37:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;53125:102;53241:11;53237:61;;;53269:17;:15;:17::i;:::-;53310:27;53358:14;;53340:15;:32;:67;;53393:14;;53340:67;;;53375:15;53340:67;53436:15;::::0;53310:97;;-1:-1:-1;53436:32:0::1;::::0;53456:11;53436:19:::1;:32::i;:::-;53418:15;:50:::0;53509:237:::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;53509:237:0;;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;;;;;;;-1:-1:-1;53509:237:0;;;;;;;;::::1;::::0;;;;;;53481:8:::1;:276:::0;;::::1;::::0;;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;;53481:276:0;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;;53768:16;;;:6:::1;:16:::0;;;;;;;:23;;-1:-1:-1;;53768:23:0::1;::::0;::::1;::::0;;53811:15;;53509:237;;;53811:22:::1;::::0;:15;:19:::1;:22::i;:::-;53807:61;53835:11;53807:61;;;;;;:::i;:::-;;;;;;;;20469:1;52748:1128:::0;;;;:::o;50182:22::-;;;-1:-1:-1;;;;;50182:22:0;;:::o;50065:21::-;;;-1:-1:-1;;;;;50065:21:0;;:::o;58599:1054::-;23114:1;23720:7;;:19;;23712:63;;;;-1:-1:-1;;;23712:63:0;;;;;;;:::i;:::-;23114:1;23853:7;:18;;;;58680:21:::1;58704:8;58713:4;58704:14;;;;;;;;;::::0;;;::::1;::::0;;;58753;;;:8:::1;:14:::0;;;;;;58768:10:::1;58753:26:::0;;;;;;;58704:14:::1;::::0;;::::1;::::0;;::::1;::::0;-1:-1:-1;58792:16:0::1;58762:4:::0;58792:10:::1;:16::i;:::-;58825:11:::0;;:15;58821:337:::1;;58886:15;58904:82;58970:4;:15;;;58904:61;50956:4;58904:37;58920:4;:20;;;58904:4;:11;;;:15;;:37;;;;:::i;:82::-;58886:100:::0;-1:-1:-1;59004:11:0;;59001:146:::1;;59036:37;59053:10;59065:7;59036:16;:37::i;:::-;59117:4;59105:10;-1:-1:-1::0;;;;;59097:34:0::1;;59123:7;59097:34;;;;;;:::i;:::-;;;;;;;;59001:146;58821:337;;59172:11:::0;;59168:171:::1;;59200:12:::0;;:74:::1;::::0;-1:-1:-1;;;;;59200:12:0::1;59238:10;59259:4;59266:7:::0;59200:29:::1;:74::i;:::-;59303:11:::0;;:24:::1;::::0;59319:7;59303:15:::1;:24::i;:::-;59289:38:::0;;59168:171:::1;59383:20;::::0;::::1;::::0;59367:11;;:61:::1;::::0;50956:4:::1;::::0;59367:37:::1;::::0;:15:::1;:37::i;:61::-;59349:15;::::0;::::1;:79:::0;59462:13:::1;::::0;::::1;::::0;-1:-1:-1;;;;;59462:13:0::1;59490:31:::0;;59486:110:::1;;59572:11:::0;;59538:46:::1;::::0;-1:-1:-1;;;59538:46:0;;-1:-1:-1;;;;;59538:21:0;::::1;::::0;::::1;::::0;:46:::1;::::0;59560:10:::1;::::0;59538:46:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;59486:110;59631:4;59619:10;-1:-1:-1::0;;;;;59611:34:0::1;;59637:7;59611:34;;;;;;:::i;50875:29::-:0;;;;:::o;21132:244::-;20409:12;:10;:12::i;:::-;20399:6;;-1:-1:-1;;;;;20399:6:0;;;:22;;;20391:67;;;;-1:-1:-1;;;20391:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;21221:22:0;::::1;21213:73;;;;-1:-1:-1::0;;;21213:73:0::1;;;;;;;:::i;:::-;21323:6;::::0;;21302:38:::1;::::0;-1:-1:-1;;;;;21302:38:0;;::::1;::::0;21323:6;::::1;::::0;21302:38:::1;::::0;::::1;21351:6;:17:::0;;-1:-1:-1;;;;;;21351:17:0::1;-1:-1:-1::0;;;;;21351:17:0;;;::::1;::::0;;;::::1;::::0;;21132:244::o;55572:1357::-;55688:19;55722:25;55762:30;55807:25;55860:20;;:::i;:::-;55883:8;55892:4;55883:14;;;;;;;;;;;;;;;;;55860:37;;;;;;;;55883:14;;;;;;;55860:37;;-1:-1:-1;;;;;55860:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55908:20:0;;:::i;:::-;-1:-1:-1;55931:14:0;;;;:8;:14;;;;;;;;-1:-1:-1;;;;;55931:21:0;;;;;;;;;;;55908:44;;;;;;;;;;;;;;;;;;;;;;;55989:20;;;;56039:12;;:37;;-1:-1:-1;;;56039:37:0;;55908:44;;55989:20;;55931:14;;56039:22;;;;;;:37;;56070:4;;56039:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56020:56;;56109:4;:24;;;56091:15;:42;:59;;;;-1:-1:-1;56137:13:0;;;56091:59;56087:366;;;56167:19;56189:45;56209:4;:24;;;56189:15;:19;;:45;;;;:::i;:::-;56167:67;;56249:18;56270:69;56323:15;;56270:48;56302:4;:15;;;56270:27;56286:10;;56270:11;:15;;:27;;;;:::i;:69::-;56249:90;-1:-1:-1;56372:69:0;56392:48;56431:8;56392:34;56249:90;50956:4;56392:14;:34::i;:48::-;56372:15;;:19;:69::i;:::-;56354:87;;56087:366;;;56477:77;56538:4;:15;;;56477:56;50956:4;56477:32;56493:15;56477:4;:11;;;:15;;:32;;;;:::i;:77::-;56658:13;;;;56463:91;;-1:-1:-1;;;;;;56650:36:0;;56646:276;;56731:4;:13;;;-1:-1:-1;;;;;56731:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56703:56;;56793:48;56800:4;:13;;;-1:-1:-1;;;;;56800:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;56793:46:0;;:48::i;:::-;56876:13;;;;:34;;-1:-1:-1;;;56876:34:0;;56774:67;;-1:-1:-1;;;;;;56876:27:0;;;;:34;;56904:5;;56876:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56856:54;;56646:276;55572:1357;;;;;;;;;;;:::o;18743:106::-;18831:10;18743:106;:::o;4160:136::-;4218:7;4245:43;4249:1;4252;4245:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;4238:50;;4160:136;;;;;:::o;3696:181::-;3754:7;3786:5;;;3810:6;;;;3802:46;;;;-1:-1:-1;;;3802:46:0;;;;;;;:::i;5050:471::-;5108:7;5353:6;5349:47;;-1:-1:-1;5383:1:0;5376:8;;5349:47;5420:5;;;5424:1;5420;:5;:1;5444:5;;;;;:10;5436:56;;;;-1:-1:-1;;;5436:56:0;;;;;;;:::i;5997:132::-;6055:7;6082:39;6086:1;6089;6082:39;;;;;;;;;;;;;;;;;:3;:39::i;61758:119::-;61834:4;;:35;;-1:-1:-1;;;61834:35:0;;-1:-1:-1;;;;;61834:4:0;;;;:21;;:35;;61856:3;;61861:7;;61834:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61758:119;;:::o;26835:340::-;26954:12;26968:17;26997:5;-1:-1:-1;;;;;26989:19:0;24452:10;27032:12;;27046:2;27050:6;27009:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;27009:48:0;;;;;;;;;;;;;;-1:-1:-1;;;;;27009:48:0;-1:-1:-1;;;;;;27009:48:0;;;;;;;;;;26989:69;;;;27009:48;26989:69;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26953:105;;;;27077:7;:57;;;;-1:-1:-1;27089:11:0;;:16;;:44;;;27120:4;27109:24;;;;;;;;;;;;:::i;:::-;27069:98;;;;-1:-1:-1;;;27069:98:0;;;;;;;:::i;:::-;26835:340;;;;;:::o;27498:406::-;27644:12;27658:17;27687:5;-1:-1:-1;;;;;27679:19:0;24542:10;27736:17;;27755:4;27761:2;27765:6;27713:59;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;27713:59:0;;;;;;;;;;;;;;-1:-1:-1;;;;;27713:59:0;-1:-1:-1;;;;;;27713:59:0;;;;;;;;;;27679:104;;;;27713:59;27679:104;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27643:140;;;;27802:7;:57;;;;-1:-1:-1;27814:11:0;;:16;;:44;;;27845:4;27834:24;;;;;;;;;;;;:::i;:::-;27794:102;;;;-1:-1:-1;;;27794:102:0;;;;;;;:::i;25395:248::-;25540:34;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25540:34:0;-1:-1:-1;;;25540:34:0;;;25514:61;;25452:13;;25479:12;;25452:13;;-1:-1:-1;;;;;25514:25:0;;;:61;;25540:34;25514:61;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25478:97;;;;25593:7;:42;;;;;;;;;;;;;;;-1:-1:-1;;;25593:42:0;;;;;;25603:24;25622:4;25603:18;:24::i;:::-;25586:49;;;;25395:248;;;;:::o;4599:192::-;4685:7;4721:12;4713:6;;;;4705:29;;;;-1:-1:-1;;;4705:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;4757:5:0;;;4599:192::o;6625:278::-;6711:7;6746:12;6739:5;6731:28;;;;-1:-1:-1;;;6731:28:0;;;;;;;;:::i;:::-;;6770:9;6786:1;6782;:5;;;;;;;6625:278;-1:-1:-1;;;;;6625:278:0:o;24602:587::-;24672:13;24717:2;24702:4;:11;:17;24698:484;;24754:4;24743:26;;;;;;;;;;;;:::i;:::-;24736:33;;;;24698:484;24791:4;:11;24806:2;24791:17;24787:395;;;24825:7;24851:69;24862:2;24858:1;:6;;;:22;;;;;24868:4;24873:1;24868:7;;;;;;;;;;;;;;-1:-1:-1;;;;;;24868:7:0;:12;;24858:22;24851:69;;;24901:3;;24851:69;;;24934:23;24970:1;24960:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;24960:12:0;;24934:38;;24996:1;24992:5;;24987:99;25003:2;24999:1;:6;;;:22;;;;;25009:4;25014:1;25009:7;;;;;;;;;;;;;;-1:-1:-1;;;;;;25009:7:0;:12;;24999:22;24987:99;;;25063:4;25068:1;25063:7;;;;;;;;;;;;;;;;;;25047:10;25058:1;25047:13;;;;;;;;;;;;;:23;-1:-1:-1;;;;;25047:23:0;;;;;;;;-1:-1:-1;25023:3:0;;;;;24987:99;;;25114:10;-1:-1:-1;25100:25:0;;-1:-1:-1;25100:25:0;24787:395;-1:-1:-1;25158:12:0;;;;;;;;;;;;-1:-1:-1;;;25158:12:0;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;1642:241::-;;1746:2;1734:9;1725:7;1721:23;1717:32;1714:2;;;-1:-1;;1752:12;1714:2;85:6;72:20;97:33;124:5;97:33;:::i;1890:257::-;;2002:2;1990:9;1981:7;1977:23;1973:32;1970:2;;;-1:-1;;2008:12;1970:2;354:6;348:13;366:30;390:5;366:30;:::i;2428:289::-;;2556:2;2544:9;2535:7;2531:23;2527:32;2524:2;;;-1:-1;;2562:12;2524:2;668:6;662:13;680:46;720:5;680:46;:::i;2724:362::-;;2849:2;2837:9;2828:7;2824:23;2820:32;2817:2;;;-1:-1;;2855:12;2817:2;2906:17;2900:24;2944:18;;2936:6;2933:30;2930:2;;;-1:-1;;2966:12;2930:2;3053:6;3042:9;3038:22;;;1025:3;1018:4;1010:6;1006:17;1002:27;992:2;;-1:-1;;1033:12;992:2;1073:6;1067:13;2944:18;22548:6;22545:30;22542:2;;;-1:-1;;22578:12;22542:2;22211;22205:9;22651;22632:17;;-1:-1;;22628:33;22237:17;;2849:2;22237:17;22297:34;;;22333:22;;;22294:62;22291:2;;;-1:-1;;22359:12;22291:2;22211;22378:22;1166:21;;;1266:16;;;2849:2;1266:16;1263:25;-1:-1;1260:2;;;-1:-1;;1291:12;1260:2;1311:39;1343:6;2849:2;1242:5;1238:16;2849:2;1208:6;1204:17;1311:39;:::i;:::-;2986:84;2811:275;-1:-1;;;;;;2811:275::o;3093:241::-;;3197:2;3185:9;3176:7;3172:23;3168:32;3165:2;;;-1:-1;;3203:12;3165:2;-1:-1;1431:20;;3159:175;-1:-1;3159:175::o;3341:263::-;;3456:2;3444:9;3435:7;3431:23;3427:32;3424:2;;;-1:-1;;3462:12;3424:2;-1:-1;1579:13;;3418:186;-1:-1;3418:186::o;3611:366::-;;;3732:2;3720:9;3711:7;3707:23;3703:32;3700:2;;;-1:-1;;3738:12;3700:2;1444:6;1431:20;3790:63;;3890:2;3933:9;3929:22;72:20;97:33;124:5;97:33;:::i;:::-;3898:63;;;;3694:283;;;;;:::o;3984:673::-;;;;;4167:3;4155:9;4146:7;4142:23;4138:33;4135:2;;;-1:-1;;4174:12;4135:2;1444:6;1431:20;4226:63;;4326:2;4382:9;4378:22;488:20;513:46;553:5;513:46;:::i;:::-;4334:76;-1:-1;4447:2;4504:22;;823:20;848:51;823:20;848:51;:::i;:::-;4455:81;-1:-1;4573:2;4609:22;;206:20;231:30;206:20;231:30;:::i;:::-;4129:528;;;;-1:-1;4129:528;;-1:-1;;4129:528::o;4664:366::-;;;4785:2;4773:9;4764:7;4760:23;4756:32;4753:2;;;-1:-1;;4791:12;4753:2;-1:-1;;1431:20;;;4943:2;4982:22;;;1431:20;;-1:-1;4747:283::o;5037:767::-;;;;;;5221:3;5209:9;5200:7;5196:23;5192:33;5189:2;;;-1:-1;;5228:12;5189:2;1444:6;1431:20;5280:63;;5380:2;5423:9;5419:22;1431:20;5388:63;;5488:2;5549:9;5545:22;823:20;848:51;893:5;848:51;:::i;:::-;5496:81;-1:-1;5614:2;5650:22;;206:20;231:30;206:20;231:30;:::i;:::-;5622:60;-1:-1;5719:3;5756:22;;206:20;231:30;206:20;231:30;:::i;:::-;5728:60;;;;5183:621;;;;;;;;:::o;7367:347::-;;7512:5;22828:12;23267:6;23262:3;23255:19;7606:52;7651:6;23304:4;23299:3;23295:14;23304:4;7632:5;7628:16;7606:52;:::i;:::-;22651:9;25964:14;-1:-1;;25960:28;7670:39;;;;23304:4;7670:39;;7459:255;-1:-1;;7459:255::o;11672:271::-;;6351:5;22828:12;6462:52;6507:6;6502:3;6495:4;6488:5;6484:16;6462:52;:::i;:::-;6526:16;;;;;11806:137;-1:-1;;11806:137::o;11950:222::-;-1:-1;;;;;23802:54;;;;6031:37;;12077:2;12062:18;;12048:124::o;12179:365::-;-1:-1;;;;;23802:54;;;;5890:58;;12530:2;12515:18;;7297:58;12350:2;12335:18;;12321:223::o;12907:444::-;-1:-1;;;;;23802:54;;;6031:37;;23802:54;;;;13254:2;13239:18;;6031:37;13337:2;13322:18;;11623:37;;;;13090:2;13075:18;;13061:290::o;13698:210::-;23487:13;;23480:21;6145:34;;13819:2;13804:18;;13790:118::o;14180:730::-;-1:-1;;;;;23802:54;;;6643:68;;14628:2;14613:18;;11623:37;;;;14711:2;14696:18;;11623:37;;;;14794:2;14779:18;;11623:37;23802:54;;;14895:3;14880:19;;6643:68;14450:3;14435:19;;14421:489::o;15180:310::-;;15327:2;15348:17;15341:47;15402:78;15327:2;15316:9;15312:18;15466:6;15402:78;:::i;15497:416::-;15697:2;15711:47;;;7946:2;15682:18;;;23255:19;7982:30;23295:14;;;7962:51;8032:12;;;15668:245::o;15920:416::-;16120:2;16134:47;;;8283:2;16105:18;;;23255:19;8319:34;23295:14;;;8299:55;-1:-1;;;8374:12;;;8367:30;8416:12;;;16091:245::o;16343:416::-;16543:2;16557:47;;;8667:2;16528:18;;;23255:19;8703:29;23295:14;;;8683:50;8752:12;;;16514:245::o;16766:416::-;16966:2;16980:47;;;9003:2;16951:18;;;23255:19;9039:34;23295:14;;;9019:55;-1:-1;;;9094:12;;;9087:41;9147:12;;;16937:245::o;17189:416::-;17389:2;17403:47;;;9398:1;17374:18;;;23255:19;-1:-1;;;23295:14;;;9413:32;9464:12;;;17360:245::o;17612:416::-;17812:2;17826:47;;;9715:2;17797:18;;;23255:19;9751:34;23295:14;;;9731:55;-1:-1;;;9806:12;;;9799:25;9843:12;;;17783:245::o;18035:416::-;18235:2;18249:47;;;10094:2;18220:18;;;23255:19;-1:-1;;;23295:14;;;10110:45;10174:12;;;18206:245::o;18458:416::-;18658:2;18672:47;;;10425:2;18643:18;;;23255:19;-1:-1;;;23295:14;;;10441:44;10504:12;;;18629:245::o;18881:416::-;19081:2;19095:47;;;19066:18;;;23255:19;10791:34;23295:14;;;10771:55;10845:12;;;19052:245::o;19304:416::-;19504:2;19518:47;;;19489:18;;;23255:19;11132:34;23295:14;;;11112:55;11186:12;;;19475:245::o;19727:416::-;19927:2;19941:47;;;11437:2;19912:18;;;23255:19;11473:33;23295:14;;;11453:54;11526:12;;;19898:245::o;20150:222::-;11623:37;;;20277:2;20262:18;;20248:124::o;20379:644::-;11623:37;;;-1:-1;;;;;23802:54;;20775:2;20760:18;;6031:37;20610:3;20812:2;20797:18;;20790:48;;;20379:644;;20852:78;;20595:19;;20916:6;20852:78;:::i;:::-;20844:86;;11653:5;21009:2;20998:9;20994:18;11623:37;20581:442;;;;;;;:::o;21030:321::-;11623:37;;;23487:13;23480:21;21337:2;21322:18;;6145:34;21179:2;21164:18;;21150:201::o;21358:333::-;11623:37;;;21677:2;21662:18;;11623:37;21513:2;21498:18;;21484:207::o;21698:444::-;11623:37;;;22045:2;22030:18;;11623:37;;;;22128:2;22113:18;;11623:37;21881:2;21866:18;;21852:290::o;25620:268::-;25685:1;25692:101;25706:6;25703:1;25700:13;25692:101;;;25773:11;;;25767:18;25754:11;;;25747:39;25728:2;25721:10;25692:101;;;25808:6;25805:1;25802:13;25799:2;;;25685:1;25864:6;25859:3;25855:16;25848:27;25799:2;;25669:219;;;:::o;26001:117::-;-1:-1;;;;;23802:54;;26060:35;;26050:2;;26109:1;;26099:12;26050:2;26044:74;:::o;26125:111::-;26206:5;23487:13;23480:21;26184:5;26181:32;26171:2;;26227:1;;26217:12

ipfs://4fc27d5837db4125eca5624509f65819a1a728f25f7d9ba6d544be896a55c5de