Token

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 * 
 * 

 /$$$$$$$$ /$$$$$$  /$$    /$$  /$$$$$$  /$$$$$$$        /$$   /$$  /$$$$$$  /$$$$$$$  /$$$$$$$$
| $$_____//$$__  $$| $$   | $$ /$$__  $$| $$__  $$      | $$  | $$ /$$__  $$| $$__  $$| $$_____/
| $$     | $$  \ $$| $$   | $$| $$  \ $$| $$  \ $$      | $$  | $$| $$  \__/| $$  \ $$| $$      
| $$$$$  | $$$$$$$$|  $$ / $$/| $$  | $$| $$$$$$$/      | $$  | $$|  $$$$$$ | $$  | $$| $$$$$   
| $$__/  | $$__  $$ \  $$ $$/ | $$  | $$| $$__  $$      | $$  | $$ \____  $$| $$  | $$| $$__/   
| $$     | $$  | $$  \  $$$/  | $$  | $$| $$  \ $$      | $$  | $$ /$$  \ $$| $$  | $$| $$      
| $$     | $$  | $$   \  $/   |  $$$$$$/| $$  | $$      |  $$$$$$/|  $$$$$$/| $$$$$$$/| $$      
|__/     |__/  |__/    \_/     \______/ |__/  |__/       \______/  \______/ |_______/ |__/   StableCoin   
                                        εɖɖίε રεĢĢίε ĵΘε
 *
 */


// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;

import {ERC20} from "./ERC20.sol";
import {FavorCurrency} from "./FavorCurrency.sol";
import {ClaimableOwnable} from "./ClaimableOwnable.sol";

/**
 * @title FavorUSD
 * @dev This is the top-level ERC20 contract, but most of the interesting functionality is
 * inherited - see the documentation on the corresponding contracts.
 */
contract FavorUSD is FavorCurrency {
    
    uint8 constant DECIMALS = 18;
    uint8 constant ROUNDING = 2;

    function initialize() external {
        require(!initialized);
        owner = msg.sender;
        initialized = true;
    }
    
    function decimals() public override pure returns (uint8) {
        return DECIMALS;
    }

    function rounding() public pure returns (uint8) {
        return ROUNDING;
    }

    function name() public override pure returns (string memory) {
        return "FAVOR USD StableCoin";
    }

    function symbol() public override pure returns (string memory) {
        return "USDF";
    }
    
    function donate() public payable {}


 
    function burnFrom(address _to, uint256 _amount) external onlyOwner() returns (bool) {
        transferFrom(_to, msg.sender, _amount);
        _burn(msg.sender, _amount);
        return true;
    }
    
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;

import {ReclaimerToken} from "./ReclaimerToken.sol";

/**
 * @title BurnableTokenWithBounds
 * @dev Burning functions as redeeming money from the system.
 * The platform will keep track of who burns coins,
 * and will send them back the equivalent amount of money (rounded down to the nearest cent).
 */
abstract contract BurnableTokenWithBounds is ReclaimerToken {
    /**
     * @dev Emitted when `value` tokens are burnt from one account (`burner`)
     * @param burner address which burned tokens
     * @param value amount of tokens burned
     */
    event Burn(address indexed burner, uint256 value);

    /**
     * @dev Emitted when new burn bounds were set
     * @param newMin new minimum burn amount
     * @param newMax new maximum burn amount
     * @notice `newMin` should never be greater than `newMax`
     */
    event SetBurnBounds(uint256 newMin, uint256 newMax);

    /**
     * @dev Destroys `amount` tokens from `msg.sender`, reducing the
     * total supply.
     * @param amount amount of tokens to burn
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     * Emits a {Burn} event with `burner` set to `msg.sender`
     *
     * Requirements
     *
     * - `msg.sender` must have at least `amount` tokens.
     *
     */
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    /**
     * @dev Change the minimum and maximum amount that can be burned at once.
     * Burning may be disabled by setting both to 0 (this will not be done
     * under normal operation, but we can't add checks to disallow it without
     * losing a lot of flexibility since burning could also be as good as disabled
     * by setting the minimum extremely high, and we don't want to lock
     * in any particular cap for the minimum)
     * @param _min minimum amount that can be burned at once
     * @param _max maximum amount that can be burned at once
     */
    function setBurnBounds(uint256 _min, uint256 _max) external onlyOwner {
        require(_min <= _max, "BurnableTokenWithBounds: min > max");
        burnMin = _min;
        burnMax = _max;
        emit SetBurnBounds(_min, _max);
    }

    /**
     * @dev Checks if amount is within allowed burn bounds and
     * destroys `amount` tokens from `account`, reducing the
     * total supply.
     * @param account account to burn tokens for
     * @param amount amount of tokens to burn
     *
     * Emits a {Burn} event
     */
    function _burn(address account, uint256 amount) internal virtual override {
        require(amount >= burnMin, "BurnableTokenWithBounds: below min burn bound");
        require(amount <= burnMax, "BurnableTokenWithBounds: exceeds max burn bound");

        super._burn(account, amount);
        emit Burn(account, amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;

import {ProxyStorage} from "./ProxyStorage.sol";

/**
 * @title ClamableOwnable
 * @dev The ClamableOwnable contract is a copy of Claimable Contract by Zeppelin.
 * and provides basic authorization control functions. Inherits storage layout of
 * ProxyStorage.
 */
contract ClaimableOwnable is ProxyStorage {
    /**
     * @dev emitted when ownership is transferred
     * @param previousOwner previous owner of this contract
     * @param newOwner new owner of this contract
     */
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev sets the original `owner` of the contract to the sender
     * at construction. Must then be reinitialized
     */
    constructor()  {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), owner);
    }

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

    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingOwner() {
        require(msg.sender == pendingOwner, "only pending owner");
        _;
    }

    /**
     * @dev Allows the current owner to set the pendingOwner address.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        pendingOwner = newOwner;
    }

    /**
     * @dev Allows the pendingOwner address to finalize the transfer.
     */
    function claimOwnership() public onlyPendingOwner {
        emit OwnershipTransferred(owner, pendingOwner);
        owner = pendingOwner;
        pendingOwner = address(0);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.0;


import {ClaimableOwnable} from "./ClaimableOwnable.sol";


library SafeMath {
    function min(uint x, uint y) internal pure returns (uint z) {
        return x <= y ? x : y;
    }
    function max(uint x, uint y) internal pure returns (uint z) {
        return x >= y ? x : y;
    }
    function imin(int x, int y) internal pure returns (int z) {
        return x <= y ? x : y;
    }
    function imax(int x, int y) internal pure returns (int z) {
        return x >= y ? x : y;
    }
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

    function rmul(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, y), RAY / 2) / RAY;
    }

    function rdiv(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, RAY), y / 2) / y;
    }

    function wmul(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, y), WAD / 2) / WAD;
    }

    function wdiv(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, WAD), y / 2) / y;
    }
    
    function ceil(uint256 a, uint256 m) internal pure returns (uint256) {
        uint256 c = add(a,m);
        uint256 d = sub(c,1);
        return mul(div(d,m),m);
    }
}

/**
 * @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);
    
    event Deposit(address indexed from, uint256 value);
    
    event Withdraw(address indexed to, uint256 value);
    
    
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return payable(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;
    }
}

/**
 * @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) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

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

    /**
     * @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");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        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);
            }
        }
    }
}
abstract contract Percentage {
    using SafeMath for uint256;
    

    function onePercent(uint256 _value, uint256 _basePercent) public pure returns (uint256)  {
        uint256 basePercent = _basePercent * 100;
        uint256 roundValue = SafeMath.ceil(_value, basePercent);
        uint256 _onePercent = SafeMath.div(SafeMath.mul(roundValue, basePercent), 1000);
        return _onePercent;
    }
}

// prettier-ignore
/**
 * @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}.
 */
abstract contract ERC20 is ClaimableOwnable, Context, IERC20  {
    using SafeMath for uint256;
    using Address for address;
    
    address internal DAI_ADDRESS = 0xFf795577d9AC8bD7D90Ee22b6C1703490b6512FD; //mainnet 0x6B175474E89094C44Da98b954EedeAC495271d0F;
   
    uint public FEE = 1;
    bool private fillDaiPool=true;
     
    constructor() {
    }
    
    event FeeUpdated(uint256 newFee);
    event FillingDaiPool(bool _fill);
     
    /**
     * @dev Returns the name of the token.
     */
    function name() public virtual pure returns (string memory);

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public virtual pure returns (string memory);

    /**
     * @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 virtual pure returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual 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);
    }
    
    
    function allowanceOfDai(address _wallet) public view returns (uint256){
       return IERC20(DAI_ADDRESS).allowance(address(this),_wallet);
    }
    
    function contractDaiBalance() public view returns (uint256){
        return IERC20(DAI_ADDRESS).balanceOf(address(this));
    }
    
    function senderDaiBalance(address _wallet) public view returns (uint256){
         return IERC20(DAI_ADDRESS).balanceOf(_wallet); 
    }
    
    
    function buy(uint256 amount) public {
        require(IERC20(DAI_ADDRESS).balanceOf(msg.sender) >= amount, "Not enough dai");
        require(IERC20(DAI_ADDRESS).allowance(msg.sender,address(this))>=amount,"No Approval");
        if(IERC20(DAI_ADDRESS).transferFrom(msg.sender, address(this), amount) == true){
        
            uint256 _fee = SafeMath.wdiv((SafeMath.wmul(amount,FEE)),1000);
            uint256 usdfTokenCount= SafeMath.sub(amount,_fee);
    
            if(usdfTokenCount>0){
                emit Deposit(msg.sender, usdfTokenCount);
                _mint(msg.sender,usdfTokenCount);
            }else{
                revert();
            }
        }else{
            revert();
        }
    } 

    function withdraw(uint256 amount) public returns (uint256){
        assert(amount <= balanceOf(msg.sender));
        
        uint256 _fee = SafeMath.wdiv((SafeMath.wmul(amount,FEE)),1000);
        uint256 daiSwap= SafeMath.sub(amount,_fee);

        if(daiSwap>0){
            require(IERC20(DAI_ADDRESS).transfer(msg.sender,daiSwap), "Swap Failed");
            emit Withdraw(msg.sender,daiSwap);
            _burn(msg.sender, amount);
            
        }else{
            revert();
        }
        return daiSwap;
    }
    
    function getEstimatedDAIforUSDF(uint256 usdfAmount) public view returns (uint256) {
        
        if (usdfAmount > 0) {
            uint256 _fee = (usdfAmount.wmul(FEE)).wdiv(1000);
            return(usdfAmount.sub(_fee));
        }else{
            return 0;
        }
    }
   
    function getEstimatedUSDFforDAI(uint256 daiAmount) public view returns (uint256) {
        if (daiAmount > 0) {
            uint256 _fee = (daiAmount.wmul(FEE)).wdiv(1000);
            return(daiAmount.sub(_fee));
        }else{
            return 0;
        }
    }
 
    function setFee(uint _fee) external onlyOwner{
        FEE = _fee;
        emit FeeUpdated(FEE);
    }

    function setDaiAddress(address _daiAddress) external onlyOwner{
        DAI_ADDRESS=_daiAddress;
    }

    /**
     * @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].
     */
    // solhint-disable-next-line no-empty-blocks
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;

import {BurnableTokenWithBounds} from "./BurnableTokenWithBounds.sol";


library SafeMath {
    function min(uint x, uint y) internal pure returns (uint z) {
        return x <= y ? x : y;
    }
    function max(uint x, uint y) internal pure returns (uint z) {
        return x >= y ? x : y;
    }
    function imin(int x, int y) internal pure returns (int z) {
        return x <= y ? x : y;
    }
    function imax(int x, int y) internal pure returns (int z) {
        return x >= y ? x : y;
    }
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

    function rmul(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, y), RAY / 2) / RAY;
    }

    function rdiv(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, RAY), y / 2) / y;
    }

    function wmul(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, y), WAD / 2) / WAD;
    }

    function wdiv(uint x, uint y) internal pure returns (uint z) {
        z = add(mul(x, WAD), y / 2) / y;
    }
}


/**
 * @title FavorCurrency
 * @dev FavorCurrency is an ERC20 with blacklist & redemption addresses
 *
 * FavorCurrency is a compliant stablecoin with blacklist and redemption
 * addresses. Only the owner can blacklist accounts. Redemption addresses
 * are assigned automatically to the first 0x100000 addresses. Sending
 * tokens to the redemption address will trigger a burn operation. Only
 * the owner can mint or blacklist accounts.
 *
 * This contract is owned by the FavorTokenController, which manages token
 * minting & admin functionality. See FavorTokenController.sol
 *
 * See also: BurnableTokenWithBounds.sol
 *
 * ~~~~ Features ~~~~
 *
 * Redemption Addresses
 * - The first 0x100000 addresses are redemption addresses
 * - Tokens sent to redemption addresses are burned
 * - Redemptions are tracked off-chain
 * - Cannot mint tokens to redemption addresses
 *
 * Blacklist
 * - Owner can blacklist accounts in accordance with local regulatory bodies
 * - Only a court order will merit a blacklist; blacklisting is extremely rare
 *
 * Burn Bounds & CanBurn
 * - Owner can set min & max burn amounts
 * - Only accounts flagged in canBurn are allowed to burn tokens
 * - canBurn prevents tokens from being sent to the incorrect address
 *
 * Reclaimer Token
 * - ERC20 Tokens and Ether sent to this contract can be reclaimed by the owner
 */
abstract contract FavorCurrency is BurnableTokenWithBounds {
    using SafeMath for uint256;
    uint256 constant CENT = 10**16;
    uint256 constant REDEMPTION_ADDRESS_COUNT = 0x100000;
    /**
     * @dev Emitted when account blacklist status changes
     */
    event Blacklisted(address indexed account, bool isBlacklisted);

    /**
     * @dev Emitted when `value` tokens are minted for `to`
     * @param to address to mint tokens for
     * @param value amount of tokens to be minted
     */
    event Mint(address indexed to, uint256 value);

    /**
     * @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     * @param account address to mint tokens for
     * @param amount amount of tokens to be minted
     *
     * Emits a {Mint} event
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` cannot be blacklisted.
     * - `account` cannot be a redemption address.
     */
    function mint(address account, uint256 amount) external onlyOwner {
        require(!isBlacklisted[account], "FavorCurrency: account is blacklisted");
        require(!isRedemptionAddress(account), "FavorCurrency: account is a redemption address");
        
        _mint(account, amount);
        emit Mint(account, amount);
    }

    /**
     * @dev Set blacklisted status for the account.
     * @param account address to set blacklist flag for
     * @param _isBlacklisted blacklist flag value
     *
     * Requirements:
     *
     * - `msg.sender` should be owner.
     */
    function setBlacklisted(address account, bool _isBlacklisted) external onlyOwner {
        require(uint160(account) >= REDEMPTION_ADDRESS_COUNT, "FavorCurrency: blacklisting of redemption address is not allowed");
        isBlacklisted[account] = _isBlacklisted;
        emit Blacklisted(account, _isBlacklisted);
    }

    /**
     * @dev Set canBurn status for the account.
     * @param account address to set canBurn flag for
     * @param _canBurn canBurn flag value
     *
     * Requirements:
     *
     * - `msg.sender` should be owner.
     */
    function setCanBurn(address account, bool _canBurn) external onlyOwner {
        canBurn[account] = _canBurn;
    }

    /**
     * @dev Check if neither account is blacklisted before performing transfer
     * If transfer recipient is a redemption address, burns tokens
     * @notice Transfer to redemption address will burn tokens with a 1 cent precision
     * @param sender address of sender
     * @param recipient address of recipient
     * @param amount amount of tokens to transfer
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual override {
        require(!isBlacklisted[sender], "FavorCurrency: sender is blacklisted");
        require(!isBlacklisted[recipient], "FavorCurrency: recipient is blacklisted");

        if (isRedemptionAddress(recipient)) {
            super._transfer(sender, recipient, amount.sub(amount.mod(CENT)));
            _burn(recipient, amount.sub(amount.mod(CENT)));
        } else {
            super._transfer(sender, recipient, amount);
        }
    }

    /**
     * @dev Requere neither accounts to be blacklisted before approval
     * @param owner address of owner giving approval
     * @param spender address of spender to approve for
     * @param amount amount of tokens to approve
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal override {
        require(!isBlacklisted[owner], "FavorCurrency: tokens owner is blacklisted");
        require(!isBlacklisted[spender] || amount == 0, "FavorCurrency: tokens spender is blacklisted");

        super._approve(owner, spender, amount);
    }

    /**
     * @dev Check if tokens can be burned at address before burning
     * @param account account to burn tokens from
     * @param amount amount of tokens to burn
     */
    function _burn(address account, uint256 amount) internal override {
        super._burn(account, amount);
    }

    /**
     * @dev First 0x100000-1 addresses (0x0000000000000000000000000000000000000001 to 0x00000000000000000000000000000000000fffff)
     * are the redemption addresses.
     * @param account address to check is a redemption address
     *
     * All transfers to redemption address will trigger token burn.
     *
     * @notice For transfer to succeed, canBurn must be true for redemption address
     *
     * @return is `account` a redemption address
     */
    function isRedemptionAddress(address account) internal pure returns (bool) {
        return uint160(account) < uint160(REDEMPTION_ADDRESS_COUNT) && uint160(account) != 0;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.0;

// solhint-disable max-states-count, var-name-mixedcase

/**
 * Defines the storage layout of the token implementation contract. Any
 * newly declared state variables in future upgrades should be appended
 * to the bottom. Never remove state variables from this list, however variables
 * can be renamed. Please add _Deprecated to deprecated variables.
 */
contract ProxyStorage {
    address public owner;
    address public pendingOwner;

    bool initialized;

    address balances_Deprecated;
    address allowances_Deprecated;

    uint256 _totalSupply;

    bool private paused_Deprecated = false;
    address private globalPause_Deprecated;

    uint256 public burnMin = 0;
    uint256 public burnMax = 0;

    address registry_Deprecated;

    string name_Deprecated;
    string symbol_Deprecated;

    uint256[] gasRefundPool_Deprecated;
    uint256 private redemptionAddressCount_Deprecated;
    uint256 minimumGasPriceForFutureRefunds_Deprecated;

    mapping(address => uint256) _balances;
    mapping(address => mapping(address => uint256)) _allowances;
    mapping(bytes32 => mapping(address => uint256)) attributes_Deprecated;

    // reward token storage
    mapping(address => address) finOps_Deprecated;
    mapping(address => mapping(address => uint256)) finOpBalances_Deprecated;
    mapping(address => uint256) finOpSupply_Deprecated;

    // favor reward allocation
    // proportion: 1000 = 100%
    struct RewardAllocation {
        uint256 proportion;
        address finOp;
    }
    mapping(address => RewardAllocation[]) _rewardDistribution_Deprecated;
    uint256 maxRewardProportion_Deprecated = 1000;

    mapping(address => bool) isBlacklisted;
    mapping(address => bool) public canBurn;

    /* Additionally, we have several keccak-based storage locations.
     * If you add more keccak-based storage mappings, such as mappings, you must document them here.
     * If the length of the keccak input is the same as an existing mapping, it is possible there could be a preimage collision.
     * A preimage collision can be used to attack the contract by treating one storage location as another,
     * which would always be a critical issue.
     * Carefully examine future keccak-based storage to ensure there can be no preimage collisions.
     *******************************************************************************************************
     ** length     input                                                         usage
     *******************************************************************************************************
     ** 19         "favorXXX.proxy.owner"                                         Proxy Owner
     ** 27         "favorXXX.pending.proxy.owner"                                 Pending Proxy Owner
     ** 28         "favorXXX.proxy.implementation"                                Proxy Implementation
     ** 32         uint256(11)                                                   gasRefundPool_Deprecated
     ** 64         uint256(address),uint256(14)                                  balanceOf
     ** 64         uint256(address),keccak256(uint256(address),uint256(15))      allowance
     ** 64         uint256(address),keccak256(bytes32,uint256(16))               attributes
     **/
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.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);
}

import {ERC20} from "./ERC20.sol";

/**
 * @title ReclaimerToken
 * @dev ERC20 token which allows owner to reclaim ERC20 tokens
 * or ether sent to this contract
 */
abstract contract ReclaimerToken is ERC20 {
    /**
     * @dev send all eth balance in the contract to another address
     * @param _to address to send eth balance to
     */
    function reclaimEther(address payable _to) external onlyOwner {
        _to.transfer(address(this).balance);
    }

    /**
     * @dev send all token balance of an arbitrary erc20 token
     * in the contract to another address
     * @param token token to reclaim
     * @param _to address to send eth balance to
     */
    function reclaimToken(IERC20 token, address _to) external onlyOwner {
        uint256 balance = token.balanceOf(address(this));
        token.transfer(_to, balance);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isBlacklisted","type":"bool"}],"name":"Blacklisted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"burner","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newFee","type":"uint256"}],"name":"FeeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"_fill","type":"bool"}],"name":"FillingDaiPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMin","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMax","type":"uint256"}],"name":"SetBurnBounds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"allowanceOfDai","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burnFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnMin","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"canBurn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractDaiBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"donate","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"usdfAmount","type":"uint256"}],"name":"getEstimatedDAIforUSDF","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"daiAmount","type":"uint256"}],"name":"getEstimatedUSDFforDAI","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"_to","type":"address"}],"name":"reclaimEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"_to","type":"address"}],"name":"reclaimToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rounding","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"senderDaiBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"_isBlacklisted","type":"bool"}],"name":"setBlacklisted","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_min","type":"uint256"},{"internalType":"uint256","name":"_max","type":"uint256"}],"name":"setBurnBounds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"_canBurn","type":"bool"}],"name":"setCanBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_daiAddress","type":"address"}],"name":"setDaiAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

1267:893:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;709:26:5;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1697:107:4;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;21548:169:2:-;;;;;;;;;;-1:-1:-1;21548:169:2;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;20501:108::-;;;;;;;;;;;;;:::i;22191:321::-;;;;;;;;;;-1:-1:-1;22191:321:2;;;;;:::i;:::-;;:::i;28352:542::-;;;;;;;;;;-1:-1:-1;28352:542:2;;;;;:::i;:::-;;:::i;1611:80:4:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;1516:89::-;;;;;;;;;;;;;:::i;1737:39:5:-;;;;;;;;;;-1:-1:-1;1737:39:5;;;;;:::i;:::-;;:::i;22921:218:2:-;;;;;;;;;;-1:-1:-1;22921:218:2;;;;;:::i;:::-;;:::i;8125:331:3:-;;;;;;;;;;-1:-1:-1;8125:331:3;;;;;:::i;:::-;;:::i;:::-;;1332:81:0;;;;;;;;;;-1:-1:-1;1332:81:0;;;;;:::i;:::-;;:::i;1617:178:1:-;;;;;;;;;;;;;:::i;1989:234:0:-;;;;;;;;;;-1:-1:-1;1989:234:0;;;;;:::i;:::-;;:::i;741:26:5:-;;;;;;;;;;;;;:::i;28906:287:2:-;;;;;;;;;;-1:-1:-1;28906:287:2;;;;;:::i;:::-;;:::i;29486:105::-;;;;;;;;;;-1:-1:-1;29486:105:2;;;;;:::i;:::-;;:::i;20672:127::-;;;;;;;;;;-1:-1:-1;20672:127:2;;;;;:::i;:::-;;:::i;1957:196:4:-;;;;;;;;;;-1:-1:-1;1957:196:4;;;;;:::i;:::-;;:::i;27312:129:2:-;;;;;;;;;;;;;:::i;9269:115:3:-;;;;;;;;;;-1:-1:-1;9269:115:3;;;;;:::i;:::-;;:::i;27153:147:2:-;;;;;;;;;;-1:-1:-1;27153:147:2;;;;;:::i;:::-;;:::i;1381:125:4:-;;;;;;;;;;;;;:::i;27453:138:2:-;;;;;;;;;;-1:-1:-1;27453:138:2;;;;;:::i;:::-;;:::i;3369:171:6:-;;;;;;;;;;-1:-1:-1;3369:171:6;;;;;:::i;:::-;;:::i;441:20:5:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;1810:93:4:-;;;;;;;;;;;;;:::i;3042:114:6:-;;;;;;;;;;-1:-1:-1;3042:114:6;;;;;:::i;:::-;;:::i;23642:269:2:-;;;;;;;;;;-1:-1:-1;23642:269:2;;;;;:::i;:::-;;:::i;29599:104::-;;;;;;;;;;-1:-1:-1;29599:104:2;;;;;:::i;:::-;;:::i;21012:175::-;;;;;;;;;;-1:-1:-1;21012:175:2;;;;;:::i;:::-;;:::i;19223:19::-;;;;;;;;;;;;;:::i;8710:319:3:-;;;;;;;;;;-1:-1:-1;8710:319:3;;;;;:::i;:::-;;:::i;27609:734:2:-;;;;;;;;;;-1:-1:-1;27609:734:2;;;;;:::i;:::-;;:::i;21250:151::-;;;;;;;;;;-1:-1:-1;21250:151:2;;;;;:::i;:::-;;:::i;467:27:5:-;;;;;;;;;;;;;:::i;1913:35:4:-;;;:::i;1423:102:1:-;;;;;;;;;;-1:-1:-1;1423:102:1;;;;;:::i;:::-;;:::i;709:26:5:-;;;;:::o;1697:107:4:-;1768:29;;;;;;;;;;;;-1:-1:-1;;;1768:29:4;;;;1697:107;:::o;21548:169:2:-;21631:4;21648:39;21657:12;:10;:12::i;:::-;21671:7;21680:6;21648:8;:39::i;:::-;-1:-1:-1;21705:4:2;21548:169;;;;;:::o;20501:108::-;20589:12;;20501:108;:::o;22191:321::-;22297:4;22314:36;22324:6;22332:9;22343:6;22314:9;:36::i;:::-;22361:121;22370:6;22378:12;:10;:12::i;:::-;22392:89;22430:6;22392:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22392:19:2;;;;;;:11;:19;;;;;;22412:12;:10;:12::i;:::-;-1:-1:-1;;;;;22392:33:2;;;;;;;;;;;;-1:-1:-1;22392:33:2;;;:89;:37;:89::i;:::-;22361:8;:121::i;:::-;-1:-1:-1;22500:4:2;22191:321;;;;;:::o;28352:542::-;28402:7;28438:21;28448:10;28438:9;:21::i;:::-;28428:6;:31;;28421:39;;-1:-1:-1;;;28421:39:2;;;;;;;;;28481:12;28496:47;28511:25;28525:6;28532:3;;28511:13;:25::i;:::-;28538:4;28496:13;:47::i;:::-;28481:62;;28554:15;28571:25;28584:6;28591:4;28571:12;:25::i;:::-;28554:42;-1:-1:-1;28612:9:2;;28609:253;;28652:11;;28645:48;;-1:-1:-1;;;28645:48:2;;-1:-1:-1;;;;;28652:11:2;;;;28645:28;;:48;;28674:10;;28685:7;;28645:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;28637:72;;;;-1:-1:-1;;;28637:72:2;;;;;;;:::i;:::-;;;;;;;;;28738:10;-1:-1:-1;;;;;28729:28:2;;28749:7;28729:28;;;;;;:::i;:::-;;;;;;;;28772:25;28778:10;28790:6;28772:5;:25::i;:::-;28879:7;-1:-1:-1;;28352:542:2;;;;:::o;1611:80:4:-;1373:1;1611:80;:::o;1516:89::-;1339:2;1516:89;:::o;1737:39:5:-;;;;;;;;;;;;;;;:::o;22921:218:2:-;23009:4;23026:83;23035:12;:10;:12::i;:::-;23049:7;23058:50;23097:10;23058:11;:25;23070:12;:10;:12::i;:::-;-1:-1:-1;;;;;23058:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;23058:25:2;;;:34;;;;;;;;;;;:38;:50::i;8125:331:3:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;8210:22:3;::::1;;::::0;;;:13:::1;:22;::::0;;;;;::::1;;8209:23;8201:73;;;;-1:-1:-1::0;;;8201:73:3::1;;;;;;;:::i;:::-;8293:28;8313:7;8293:19;:28::i;:::-;8292:29;8284:88;;;;-1:-1:-1::0;;;8284:88:3::1;;;;;;;:::i;:::-;8391:22;8397:7;8406:6;8391:5;:22::i;:::-;8433:7;-1:-1:-1::0;;;;;8428:21:3::1;;8442:6;8428:21;;;;;;:::i;:::-;;;;;;;;8125:331:::0;;:::o;1332:81:0:-;1381:25;1387:10;1399:6;1381:5;:25::i;:::-;1332:81;:::o;1617:178:1:-;1217:12;;-1:-1:-1;;;;;1217:12:1;1203:10;:26;1195:57;;;;-1:-1:-1;;;1195:57:1;;;;;;;:::i;:::-;1710:12:::1;::::0;::::1;1703:5:::0;;1682:41:::1;::::0;-1:-1:-1;;;;;1710:12:1;;::::1;::::0;1703:5;;::::1;::::0;1682:41:::1;::::0;::::1;1741:12;::::0;;::::1;1733:20:::0;;-1:-1:-1;;;;;;1733:20:1;;::::1;-1:-1:-1::0;;;;;1741:12:1;::::1;1733:20;::::0;;;1763:25:::1;::::0;;1617:178::o;1989:234:0:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;2085:4:0::1;2077;:12;;2069:59;;;;-1:-1:-1::0;;;2069:59:0::1;;;;;;;:::i;:::-;2138:7;:14:::0;;;2162:7:::1;:14:::0;;;2191:25:::1;::::0;::::1;::::0;::::1;::::0;2148:4;;2172;;2191:25:::1;:::i;:::-;;;;;;;;1989:234:::0;;:::o;741:26:5:-;;;;:::o;28906:287:2:-;28979:7;29013:14;;29009:177;;29044:12;29059:33;29087:4;29060:20;29076:3;;29060:10;:15;;:20;;;;:::i;:::-;29059:27;;:33::i;:::-;29044:48;-1:-1:-1;29114:20:2;:10;29044:48;29114:14;:20::i;:::-;29107:28;;;;;29009:177;-1:-1:-1;29173:1:2;29166:8;;29486:105;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;29542:3:2::1;:10:::0;;;29568:15:::1;::::0;::::1;::::0;::::1;::::0;29548:4;;29568:15:::1;:::i;:::-;;;;;;;;29486:105:::0;:::o;20672:127::-;-1:-1:-1;;;;;20773:18:2;20746:7;20773:18;;;:9;:18;;;;;;;20672:127::o;1957:196:4:-;2035:4;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;2051:38:4::1;2064:3;2069:10;2081:7;2051:12;:38::i;:::-;;2099:26;2105:10;2117:7;2099:5;:26::i;27312:129:2:-:0;27396:11;;27389:44;;-1:-1:-1;;;27389:44:2;;27363:7;;-1:-1:-1;;;;;27396:11:2;;27389:29;;:44;;27427:4;;27389:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;27382:51;;27312:129;:::o;9269:115:3:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;-1:-1:-1;;;;;9350:16:3;;;::::1;;::::0;;;:7:::1;:16;::::0;;;;:27;;-1:-1:-1;;9350:27:3::1;::::0;::::1;;::::0;;;::::1;::::0;;9269:115::o;27153:147:2:-;27247:11;;27240:52;;-1:-1:-1;;;27240:52:2;;27215:7;;-1:-1:-1;;;;;27247:11:2;;27240:29;;:52;;27278:4;;27284:7;;27240:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;1381:125:4:-;1431:11;;-1:-1:-1;;;1431:11:4;;;;1430:12;1422:21;;;;;;1453:5;:18;;-1:-1:-1;;;;;;1453:18:4;1461:10;1453:18;;;;1481;;-1:-1:-1;;;;1481:18:4;-1:-1:-1;;;1481:18:4;;;1381:125::o;27453:138:2:-;27551:11;;27544:38;;-1:-1:-1;;;27544:38:2;;27517:7;;-1:-1:-1;;;;;27551:11:2;;27544:29;;:38;;27574:7;;27544:38;;;:::i;3369:171:6:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;3465:30:6::1;::::0;-1:-1:-1;;;3465:30:6;;3447:15:::1;::::0;-1:-1:-1;;;;;3465:15:6;::::1;::::0;::::1;::::0;:30:::1;::::0;3489:4:::1;::::0;3465:30:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3505:28;::::0;-1:-1:-1;;;3505:28:6;;3447:48;;-1:-1:-1;;;;;;3505:14:6;::::1;::::0;::::1;::::0;:28:::1;::::0;3520:3;;3447:48;;3505:28:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1045:1:1;3369:171:6::0;;:::o;441:20:5:-;;;-1:-1:-1;;;;;441:20:5;;:::o;1810:93:4:-;1883:13;;;;;;;;;;;;-1:-1:-1;;;1883:13:4;;;;1810:93;:::o;3042:114:6:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;3114:35:6::1;::::0;-1:-1:-1;;;;;3114:12:6;::::1;::::0;3127:21:::1;3114:35:::0;::::1;;;::::0;::::1;::::0;;;3127:21;3114:12;:35;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;3042:114:::0;:::o;23642:269:2:-;23735:4;23752:129;23761:12;:10;:12::i;:::-;23775:7;23784:96;23823:15;23784:96;;;;;;;;;;;;;;;;;:11;:25;23796:12;:10;:12::i;:::-;-1:-1:-1;;;;;23784:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;23784:25:2;;;:34;;;;;;;;;;;:96;:38;:96::i;29599:104::-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;29672:11:2::1;:23:::0;;-1:-1:-1;;;;;;29672:23:2::1;-1:-1:-1::0;;;;;29672:23:2;;;::::1;::::0;;;::::1;::::0;;29599:104::o;21012:175::-;21098:4;21115:42;21125:12;:10;:12::i;:::-;21139:9;21150:6;21115:9;:42::i;19223:19::-;;;;:::o;8710:319:3:-;1015:5:1;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;7318:8:3::1;8817:7;-1:-1:-1::0;;;;;8809:44:3::1;;;8801:121;;;;-1:-1:-1::0;;;8801:121:3::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;8932:22:3;::::1;;::::0;;;:13:::1;:22;::::0;;;;;;:39;;-1:-1:-1;;8932:39:3::1;::::0;::::1;;;::::0;;8986:36;::::1;::::0;::::1;::::0;8932:39;;8986:36:::1;:::i;27609:734:2:-:0;27671:11;;27664:41;;-1:-1:-1;;;27664:41:2;;27709:6;;-1:-1:-1;;;;;27671:11:2;;27664:29;;:41;;27694:10;;27664:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:51;;27656:78;;;;-1:-1:-1;;;27656:78:2;;;;;;;:::i;:::-;27760:11;;27753:55;;-1:-1:-1;;;27753:55:2;;27810:6;;-1:-1:-1;;;;;27760:11:2;;27753:29;;:55;;27783:10;;27802:4;;27753:55;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:63;;27745:86;;;;-1:-1:-1;;;27745:86:2;;;;;;;:::i;:::-;27852:11;;27845:67;;-1:-1:-1;;;27845:67:2;;-1:-1:-1;;;;;27852:11:2;;;;27845:32;;:67;;27878:10;;27898:4;;27905:6;;27845:67;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:75;;27916:4;27845:75;27842:494;;;27946:12;27961:47;27976:25;27990:6;27997:3;;27976:13;:25::i;27961:47::-;27946:62;;28023:22;28047:25;28060:6;28067:4;28047:12;:25::i;:::-;28023:49;-1:-1:-1;28096:16:2;;28093:193;;28145:10;-1:-1:-1;;;;;28137:35:2;;28157:14;28137:35;;;;;;:::i;:::-;;;;;;;;28191:32;28197:10;28208:14;28191:5;:32::i;:::-;27842:494;;;;21250:151;-1:-1:-1;;;;;21366:18:2;;;21339:7;21366:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;21250:151::o;467:27:5:-;;;-1:-1:-1;;;;;467:27:5;;:::o;1913:35:4:-;:::o;1423:102:1:-;1015:5;;-1:-1:-1;;;;;1015:5:1;1001:10;:19;993:42;;;;-1:-1:-1;;;993:42:1;;;;;;;:::i;:::-;1495:12:::1;:23:::0;;-1:-1:-1;;;;;;1495:23:1::1;-1:-1:-1::0;;;;;1495:23:1;;;::::1;::::0;;;::::1;::::0;;1423:102::o;9019:115:2:-;9115:10;9019:115;:::o;10593:361:3:-;-1:-1:-1;;;;;10726:20:3;;;;;;:13;:20;;;;;;;;10725:21;10717:76;;;;-1:-1:-1;;;10717:76:3;;;;;;;:::i;:::-;-1:-1:-1;;;;;10812:22:3;;;;;;:13;:22;;;;;;;;10811:23;;:38;;-1:-1:-1;10838:11:3;;10811:38;10803:95;;;;-1:-1:-1;;;10803:95:3;;;;;;;:::i;:::-;10909:38;10924:5;10931:7;10940:6;10909:14;:38::i;:::-;10593:361;;;:::o;9773:569::-;-1:-1:-1;;;;;9918:21:3;;;;;;:13;:21;;;;;;;;9917:22;9909:71;;;;-1:-1:-1;;;9909:71:3;;;;;;;:::i;:::-;-1:-1:-1;;;;;9999:24:3;;;;;;:13;:24;;;;;;;;9998:25;9990:77;;;;-1:-1:-1;;;9990:77:3;;;;;;;:::i;:::-;10082:30;10102:9;10082:19;:30::i;:::-;10078:258;;;10128:64;10144:6;10152:9;10163:28;10174:16;:6;7262;10174:10;:16::i;:::-;10163:6;;:10;:28::i;:::-;10128:15;:64::i;:::-;10206:46;10212:9;10223:28;10234:16;:6;7262;10234:10;:16::i;:::-;10223:6;;:10;:28::i;:::-;10206:5;:46::i;:::-;10078:258;;;10283:42;10299:6;10307:9;10318:6;10283:15;:42::i;1729:192:2:-;1815:7;1851:12;1843:6;;;;1835:29;;;;-1:-1:-1;;;1835:29:2;;;;;;;;:::i;:::-;-1:-1:-1;1875:9:2;1887:5;1891:1;1887;:5;:::i;:::-;1875:17;1729:192;-1:-1:-1;;;;;1729:192:2:o;5714:113::-;5767:6;5422:8;5790:23;5794:9;5798:1;5801;5794:3;:9::i;:::-;5805:7;5811:1;5422:8;5805:7;:::i;:::-;5790:3;:23::i;:::-;:29;;;;:::i;:::-;5786:33;5714:113;-1:-1:-1;;;5714:113:2:o;5835:111::-;5888:6;5937:1;5911:23;5915:11;5919:1;5422:8;5915:3;:11::i;:::-;5928:5;5932:1;5928;:5;:::i;1256:136::-;1314:7;1341:43;1345:1;1348;1341:43;;;;;;;;;;;;;;;;;:3;:43::i;11140:111:3:-;11216:28;11228:7;11237:6;11216:11;:28::i;800:181:2:-;858:7;;890:5;894:1;890;:5;:::i;:::-;878:17;;919:1;914;:6;;906:46;;;;-1:-1:-1;;;906:46:2;;;;;;;:::i;11725:176:3:-;11794:4;7318:8;-1:-1:-1;;;;;11817:52:3;;;:77;;;;-1:-1:-1;;;;;;;11873:21:3;;;;11725:176::o;25221:378:2:-;-1:-1:-1;;;;;25305:21:2;;25297:65;;;;-1:-1:-1;;;25297:65:2;;;;;;;:::i;:::-;25375:49;25404:1;25408:7;25417:6;25375:20;:49::i;:::-;25452:12;;:24;;25469:6;25452:16;:24::i;:::-;25437:12;:39;-1:-1:-1;;;;;25508:18:2;;;;;;:9;:18;;;;;;:30;;25531:6;25508:22;:30::i;:::-;-1:-1:-1;;;;;25487:18:2;;;;;;:9;:18;;;;;;:51;;;;25554:37;;25487:18;;;25554:37;;;;25584:6;;25554:37;:::i;:::-;;;;;;;;25221:378;;:::o;26789:346::-;-1:-1:-1;;;;;26891:19:2;;26883:68;;;;-1:-1:-1;;;26883:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;26970:21:2;;26962:68;;;;-1:-1:-1;;;26962:68:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;27043:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;27095:32;;;;;27073:6;;27095:32;:::i;:::-;;;;;;;;26789:346;;;:::o;4448:128:3:-;4506:7;4532:37;4536:1;4539;4532:37;;;;;;;;;;;;;;;;;:3;:37::i;24401:539:2:-;-1:-1:-1;;;;;24507:20:2;;24499:70;;;;-1:-1:-1;;;24499:70:2;;;;;;;:::i;:::-;-1:-1:-1;;;;;24588:23:2;;24580:71;;;;-1:-1:-1;;;24580:71:2;;;;;;;:::i;:::-;24664:47;24685:6;24693:9;24704:6;24664:20;:47::i;:::-;24744:71;24766:6;24744:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;24744:17:2;;;;;;:9;:17;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;24724:17:2;;;;;;;:9;:17;;;;;;:91;;;;24849:20;;;;;;;:32;;24874:6;24849:24;:32::i;:::-;-1:-1:-1;;;;;24826:20:2;;;;;;;:9;:20;;;;;;;:55;;;;24897:35;;;;;;;;;;24925:6;;24897:35;:::i;2172:471::-;2230:7;2475:6;2471:47;;-1:-1:-1;2505:1:2;2498:8;;2471:47;2530:9;2542:5;2546:1;2542;:5;:::i;:::-;2530:17;-1:-1:-1;2575:1:2;2566:5;2570:1;2530:17;2566:5;:::i;:::-;:10;2558:56;;;;-1:-1:-1;;;2558:56:2;;;;;;;:::i;2520:328:0:-;2622:7;;2612:6;:17;;2604:75;;;;-1:-1:-1;;;2604:75:0;;;;;;;:::i;:::-;2707:7;;2697:6;:17;;2689:77;;;;-1:-1:-1;;;2689:77:0;;;;;;;:::i;:::-;2777:28;2789:7;2798:6;2777:11;:28::i;:::-;2825:7;-1:-1:-1;;;;;2820:21:0;;2834:6;2820:21;;;;;;:::i;5080:163:3:-;5166:7;5201:12;5193:6;5185:29;;;;-1:-1:-1;;;5185:29:3;;;;;;;;:::i;:::-;-1:-1:-1;5231:5:3;5235:1;5231;:5;:::i;:::-;5224:12;5080:163;-1:-1:-1;;;;5080:163:3:o;25931:418:2:-;-1:-1:-1;;;;;26015:21:2;;26007:67;;;;-1:-1:-1;;;26007:67:2;;;;;;;:::i;:::-;26087:49;26108:7;26125:1;26129:6;26087:20;:49::i;:::-;26170:68;26193:6;26170:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26170:18:2;;;;;;:9;:18;;;;;;;:68;:22;:68::i;:::-;-1:-1:-1;;;;;26149:18:2;;;;;;:9;:18;;;;;:89;26264:12;;:24;;26281:6;26264:16;:24::i;:::-;26249:12;:39;26304:37;;26330:1;;-1:-1:-1;;;;;26304:37:2;;;;;;;26334:6;;26304:37;:::i;14:259:7:-;;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:33;237:5;210:33;:::i;550:402::-;;;679:2;667:9;658:7;654:23;650:32;647:2;;;700:6;692;685:22;647:2;744:9;731:23;763:33;790:5;763:33;:::i;:::-;815:5;-1:-1:-1;872:2:7;857:18;;844:32;885:35;844:32;885:35;:::i;:::-;939:7;929:17;;;637:315;;;;;:::o;957:470::-;;;;1103:2;1091:9;1082:7;1078:23;1074:32;1071:2;;;1124:6;1116;1109:22;1071:2;1168:9;1155:23;1187:33;1214:5;1187:33;:::i;:::-;1239:5;-1:-1:-1;1296:2:7;1281:18;;1268:32;1309:35;1268:32;1309:35;:::i;:::-;1061:366;;1363:7;;-1:-1:-1;;;1417:2:7;1402:18;;;;1389:32;;1061:366::o;1432:396::-;;;1558:2;1546:9;1537:7;1533:23;1529:32;1526:2;;;1579:6;1571;1564:22;1526:2;1623:9;1610:23;1642:33;1669:5;1642:33;:::i;:::-;1694:5;-1:-1:-1;1751:2:7;1736:18;;1723:32;1764;1723;1764;:::i;1833:327::-;;;1962:2;1950:9;1941:7;1937:23;1933:32;1930:2;;;1983:6;1975;1968:22;1930:2;2027:9;2014:23;2046:33;2073:5;2046:33;:::i;:::-;2098:5;2150:2;2135:18;;;;2122:32;;-1:-1:-1;;;1920:240:7:o;2165:257::-;;2285:2;2273:9;2264:7;2260:23;2256:32;2253:2;;;2306:6;2298;2291:22;2253:2;2343:9;2337:16;2362:30;2386:5;2362:30;:::i;2427:417::-;;;2571:2;2559:9;2550:7;2546:23;2542:32;2539:2;;;2592:6;2584;2577:22;2849:190;;2961:2;2949:9;2940:7;2936:23;2932:32;2929:2;;;2982:6;2974;2967:22;2929:2;-1:-1:-1;3010:23:7;;2919:120;-1:-1:-1;2919:120:7:o;3044:194::-;;3167:2;3155:9;3146:7;3142:23;3138:32;3135:2;;;3188:6;3180;3173:22;3135:2;-1:-1:-1;3216:16:7;;3125:113;-1:-1:-1;3125:113:7:o;3243:258::-;;;3372:2;3360:9;3351:7;3347:23;3343:32;3340:2;;;3393:6;3385;3378:22;3340:2;-1:-1:-1;;3421:23:7;;;3491:2;3476:18;;;3463:32;;-1:-1:-1;3330:171:7:o;3506:203::-;-1:-1:-1;;;;;3670:32:7;;;;3652:51;;3640:2;3625:18;;3607:102::o;3714:304::-;-1:-1:-1;;;;;3944:15:7;;;3926:34;;3996:15;;3991:2;3976:18;;3969:43;3876:2;3861:18;;3843:175::o;4023:375::-;-1:-1:-1;;;;;4281:15:7;;;4263:34;;4333:15;;;;4328:2;4313:18;;4306:43;4380:2;4365:18;;4358:34;;;;4213:2;4198:18;;4180:218::o;4403:274::-;-1:-1:-1;;;;;4595:32:7;;;;4577:51;;4659:2;4644:18;;4637:34;4565:2;4550:18;;4532:145::o;4682:187::-;4847:14;;4840:22;4822:41;;4810:2;4795:18;;4777:92::o;4874:603::-;;5015:2;5044;5033:9;5026:21;5076:6;5070:13;5119:6;5114:2;5103:9;5099:18;5092:34;5144:4;5157:140;5171:6;5168:1;5165:13;5157:140;;;5266:14;;;5262:23;;5256:30;5232:17;;;5251:2;5228:26;5221:66;5186:10;;5157:140;;;5315:6;5312:1;5309:13;5306:2;;;5385:4;5380:2;5371:6;5360:9;5356:22;5352:31;5345:45;5306:2;-1:-1:-1;5461:2:7;5440:15;-1:-1:-1;;5436:29:7;5421:45;;;;5468:2;5417:54;;4995:482;-1:-1:-1;;;4995:482:7:o;5482:408::-;5684:2;5666:21;;;5723:2;5703:18;;;5696:30;5762:34;5757:2;5742:18;;5735:62;-1:-1:-1;;;5828:2:7;5813:18;;5806:42;5880:3;5865:19;;5656:234::o;5895:399::-;6097:2;6079:21;;;6136:2;6116:18;;;6109:30;6175:34;6170:2;6155:18;;6148:62;-1:-1:-1;;;6241:2:7;6226:18;;6219:33;6284:3;6269:19;;6069:225::o;6299:409::-;6501:2;6483:21;;;6540:2;6520:18;;;6513:30;6579:34;6574:2;6559:18;;6552:62;-1:-1:-1;;;6645:2:7;6630:18;;6623:43;6698:3;6683:19;;6473:235::o;6713:410::-;6915:2;6897:21;;;6954:2;6934:18;;;6927:30;6993:34;6988:2;6973:18;;6966:62;-1:-1:-1;;;7059:2:7;7044:18;;7037:44;7113:3;7098:19;;6887:236::o;7128:398::-;7330:2;7312:21;;;7369:2;7349:18;;;7342:30;7408:34;7403:2;7388:18;;7381:62;-1:-1:-1;;;7474:2:7;7459:18;;7452:32;7516:3;7501:19;;7302:224::o;7531:334::-;7733:2;7715:21;;;7772:2;7752:18;;;7745:30;-1:-1:-1;;;7806:2:7;7791:18;;7784:40;7856:2;7841:18;;7705:160::o;7870:351::-;8072:2;8054:21;;;8111:2;8091:18;;;8084:30;8150:29;8145:2;8130:18;;8123:57;8212:2;8197:18;;8044:177::o;8226:406::-;8428:2;8410:21;;;8467:2;8447:18;;;8440:30;8506:34;8501:2;8486:18;;8479:62;-1:-1:-1;;;8572:2:7;8557:18;;8550:40;8622:3;8607:19;;8400:232::o;8637:335::-;8839:2;8821:21;;;8878:2;8858:18;;;8851:30;-1:-1:-1;;;8912:2:7;8897:18;;8890:41;8963:2;8948:18;;8811:161::o;8977:400::-;9179:2;9161:21;;;9218:2;9198:18;;;9191:30;9257:34;9252:2;9237:18;;9230:62;-1:-1:-1;;;9323:2:7;9308:18;;9301:34;9367:3;9352:19;;9151:226::o;9382:342::-;9584:2;9566:21;;;9623:2;9603:18;;;9596:30;-1:-1:-1;;;9657:2:7;9642:18;;9635:48;9715:2;9700:18;;9556:168::o;9729:428::-;9931:2;9913:21;;;9970:2;9950:18;;;9943:30;;;10009:34;9989:18;;;9982:62;10080:34;10075:2;10060:18;;10053:62;10147:3;10132:19;;9903:254::o;10162:338::-;10364:2;10346:21;;;10403:2;10383:18;;;10376:30;-1:-1:-1;;;10437:2:7;10422:18;;10415:44;10491:2;10476:18;;10336:164::o;10505:397::-;10707:2;10689:21;;;10746:2;10726:18;;;10719:30;10785:34;10780:2;10765:18;;10758:62;-1:-1:-1;;;10851:2:7;10836:18;;10829:31;10892:3;10877:19;;10679:223::o;10907:398::-;11109:2;11091:21;;;11148:2;11128:18;;;11121:30;11187:34;11182:2;11167:18;;11160:62;-1:-1:-1;;;11253:2:7;11238:18;;11231:32;11295:3;11280:19;;11081:224::o;11310:397::-;11512:2;11494:21;;;11551:2;11531:18;;;11524:30;11590:34;11585:2;11570:18;;11563:62;-1:-1:-1;;;11656:2:7;11641:18;;11634:31;11697:3;11682:19;;11484:223::o;11712:401::-;11914:2;11896:21;;;11953:2;11933:18;;;11926:30;11992:34;11987:2;11972:18;;11965:62;-1:-1:-1;;;12058:2:7;12043:18;;12036:35;12103:3;12088:19;;11886:227::o;12118:335::-;12320:2;12302:21;;;12359:2;12339:18;;;12332:30;-1:-1:-1;;;12393:2:7;12378:18;;12371:41;12444:2;12429:18;;12292:161::o;12458:403::-;12660:2;12642:21;;;12699:2;12679:18;;;12672:30;12738:34;12733:2;12718:18;;12711:62;-1:-1:-1;;;12804:2:7;12789:18;;12782:37;12851:3;12836:19;;12632:229::o;12866:400::-;13068:2;13050:21;;;13107:2;13087:18;;;13080:30;13146:34;13141:2;13126:18;;13119:62;-1:-1:-1;;;13212:2:7;13197:18;;13190:34;13256:3;13241:19;;13040:226::o;13271:401::-;13473:2;13455:21;;;13512:2;13492:18;;;13485:30;13551:34;13546:2;13531:18;;13524:62;-1:-1:-1;;;13617:2:7;13602:18;;13595:35;13662:3;13647:19;;13445:227::o;13677:355::-;13879:2;13861:21;;;13918:2;13898:18;;;13891:30;13957:33;13952:2;13937:18;;13930:61;14023:2;14008:18;;13851:181::o;14037:411::-;14239:2;14221:21;;;14278:2;14258:18;;;14251:30;14317:34;14312:2;14297:18;;14290:62;-1:-1:-1;;;14383:2:7;14368:18;;14361:45;14438:3;14423:19;;14211:237::o;14453:177::-;14599:25;;;14587:2;14572:18;;14554:76::o;14635:248::-;14809:25;;;14865:2;14850:18;;14843:34;14797:2;14782:18;;14764:119::o;14888:184::-;15060:4;15048:17;;;;15030:36;;15018:2;15003:18;;14985:87::o;15077:128::-;;15148:1;15144:6;15141:1;15138:13;15135:2;;;15154:18;;:::i;:::-;-1:-1:-1;15190:9:7;;15125:80::o;15210:120::-;;15276:1;15266:2;;15281:18;;:::i;:::-;-1:-1:-1;15315:9:7;;15256:74::o;15335:168::-;;15441:1;15437;15433:6;15429:14;15426:1;15423:21;15418:1;15411:9;15404:17;15400:45;15397:2;;;15448:18;;:::i;:::-;-1:-1:-1;15488:9:7;;15387:116::o;15508:125::-;;15576:1;15573;15570:8;15567:2;;;15581:18;;:::i;:::-;-1:-1:-1;15618:9:7;;15557:76::o;15638:112::-;;15696:1;15686:2;;15701:18;;:::i;:::-;-1:-1:-1;15735:9:7;;15676:74::o;15755:127::-;15816:10;15811:3;15807:20;15804:1;15797:31;15847:4;15844:1;15837:15;15871:4;15868:1;15861:15;15887:127;15948:10;15943:3;15939:20;15936:1;15929:31;15979:4;15976:1;15969:15;16003:4;16000:1;15993:15;16019:133;-1:-1:-1;;;;;16096:31:7;;16086:42;;16076:2;;16142:1;16139;16132:12;16157:120;16245:5;16238:13;16231:21;16224:5;16221:32;16211:2;;16267:1;16264;16257:12

ipfs://a7bb0ce91ac698f2150c588cb0e983e5c1221d8388d2d8a61b3451bfd08064f7