Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _nonReentrantBefore()
•    - function _nonReentrantAfter()
• library SafeMath
•    - function tryAdd(
•    - function trySub(
•    - function tryMul(
•    - function tryDiv(
•    - function tryMod(
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(
• functionCallWithValue(
•    - function functionCall(
•    - function functionCallWithValue(
• functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(
• functionStaticCall(
•    - function functionStaticCall(
•    - function functionDelegateCall(
• functionDelegateCall(
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(
•    - function approve(address spender, uin ...
•    - function transferFrom(
• interface PAXGOLD
•    - function feeRate()
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
• interface IERC20Metadata is IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•  contract ERC20 is Context, IERC20, ...
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(
•    - function transfer(
•    - function allowance(
•    - function approve(
•    - function transferFrom(
•    - function increaseAllowance(
•    - function decreaseAllowance(
•    - function _transfer(
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(
•    - function _spendAllowance(
•    - function _beforeTokenTransfer(
•    - function _afterTokenTransfer(
•  contract AuriumToken is ERC20, Ree ... *
•    - function calculateReceivedPaxg(
•    - function getAuriumTokenAmountsOut(
•    - function getPaxgAmountsOut(
•    - function _updateValue()
•    - function mint(uint256 _value)
•    - function burn(uint256 _value)
•    - function transfer(
•    - function transferFrom(
•    - function getDetails()

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

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

abstract 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() {
        _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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

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

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

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

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

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

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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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"
        );

        (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
            functionCallWithValue(
                target,
                data,
                0,
                "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"
        );
        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return
            verifyCallResultFromTarget(
                target,
                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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return
            verifyCallResultFromTarget(
                target,
                success,
                returndata,
                errorMessage
            );
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(
        bytes memory returndata,
        string memory errorMessage
    ) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

interface IERC20 {
    /**
     * @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
    );

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

interface PAXGOLD {
    function feeRate() external view returns (uint256);
}

library SafeERC20 {
    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'
        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) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(
            nonceAfter == nonceBefore + 1,
            "SafeERC20: permit did not succeed"
        );
    }

    /**
     * @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
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 this function is
     * overridden;
     *
     * 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 virtual override 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:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, 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}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, 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}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        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) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + 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) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This 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:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(
            fromBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, 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:
     *
     * - `account` 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 += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(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);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This 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 Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @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 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

/**
 * @title AuriumToken
 * @dev AuriumToken is an ERC20 token that is backed by Pax Gold (PAXG).
 *The value of the token is derived from the amount of PAXG in the reserve.
 *AuriumToken can be minted and burned by depositing and withdrawing PAXG from the reserve.
 *A small percentage of each transfer is burned, decreasing the total supply and increasing the value of each token.
 */
contract AuriumToken is ERC20, ReentrancyGuard {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;

    uint256 public totalReserve_; // Total amount of PAXG in the reserve
    uint256 private immutable initialSupply_;
    uint256 public value_; // The value of each token, expressed in PAXG
    uint256 public constant burnFee_ = 5; // 0.5% burn rate (in basis points)
    uint256 private _maxBurnFee = 1e18; // Max burn fee (1 Paxg)
    uint256 public constant MULTIPLIER = 1000; //basis points
    IERC20 public paxGold_; // The PAXG contract
    address public immutable auriumTokenFactoryAddr_; //auriumToken Factory Address
    uint256 public constant PRECISION_FACTOR = 1e18; //Precison factor for value calculations
    uint256 public lastValue_; //The last value recorded
    // uint256 public paxGoldFee; //Get transfer fee from PaxGold
    uint256 public constant PAXGOLD_FEE_PARTS = 1000000; //Get paxGoldFeeParts

    event AuriumTokenMinted(
        address indexed tokenAddress,
        string name,
        string symbol,
        address indexed account,
        uint256 value
    );
    event AuriumTokenBurned(
        address indexed tokenAddress,
        string name,
        string symbol,
        address indexed account,
        uint256 value
    );
    event maxBurnFeeAlert(address sender, uint256 amount, uint256 maxBurnFee);

    /**

    @dev Constructor for AuriumToken contract

    @param _paxGold The address of the PAXG contract

    @param _initialDeposit The initial amount of PAXG to deposit into the reserve

    @param _initialSupply The initial supply of AuriumToken to mint

    @param _name The name of the AuriumToken

    @param _symbol The symbol of the AuriumToken

    @param _userAddress The address of the user that will receive the initial supply of AuriumToken
    */
    constructor(
        address _paxGold,
        uint256 _initialDeposit,
        uint256 _initialSupply,
        string memory _name,
        string memory _symbol,
        address _userAddress
    ) ERC20(_name, _symbol) {
        paxGold_ = IERC20(_paxGold);
        auriumTokenFactoryAddr_ = msg.sender;
        require(
            _initialDeposit > 0,
            "Initial deposit must be greater than zero"
        );
        require(_initialSupply > 0, "Initial supply must be greater than zero");

        totalReserve_ = calculateReceivedPaxg(_initialDeposit);
        initialSupply_ = _initialSupply;
        value_ = (totalReserve_.mul(PRECISION_FACTOR)).div(_initialSupply);
        _mint(_userAddress, _initialSupply);
    }

    /**
    @dev Calculates the receivable PAXG.
    @param _amount the amount of AuriumToken to burn.
    @return receivedPaxg - Receivable PAXG after fee deduction.
     */
    function calculateReceivedPaxg(
        uint256 _amount
    ) public view returns (uint256 receivedPaxg) {
        return
            _amount.sub(
                (_amount.mul(PAXGOLD(address(paxGold_)).feeRate())).div(
                    PAXGOLD_FEE_PARTS
                )
            );
    }

    /*
    @dev Calculates the AuriumToken to be minted.
    @param _amountPaxg the amount of PAXG to deposit
    @return ATKAmountsOut - AuriumToken to be minted.
     */
    function getAuriumTokenAmountsOut(
        uint _amountPaxg
    ) public view returns (uint256 ATKAmountsOut) {
        uint tempPaxgReceived = calculateReceivedPaxg(_amountPaxg); //Dummy var to calculate PAXG to be received after fee deduction.
        if (totalSupply() == 0) {
            return (tempPaxgReceived.mul(PRECISION_FACTOR)).div(lastValue_);
        } else {
            return (tempPaxgReceived.mul(PRECISION_FACTOR)).div(value_);
        }
    }

    function getPaxgAmountsOut(
        uint _amountAuriumToken
    ) public view returns (uint256 PAXGAmountsOut) {
        uint256 temp;
        if (value_ == 0) {
            temp = (_amountAuriumToken.mul(lastValue_)).div(PRECISION_FACTOR);
        } else {
            temp = (_amountAuriumToken.mul(value_)).div(PRECISION_FACTOR);
        }
        return calculateReceivedPaxg(temp);
    }

    /**

    @dev Calculates the current value of each AuriumToken
    */
    function _updateValue() public {
        value_ = totalSupply() == 0
            ? 0
            : (totalReserve_.mul(PRECISION_FACTOR)).div(totalSupply());
    }

    /**

    @dev Mint new AuriumToken by depositing PAXG into the reserve

    @param _value The amount of PAXG to deposit
    */
    function mint(uint256 _value) public nonReentrant {
        uint256 auriumTokenToMint;
        uint256 paxgReceived;

        require(
            paxGold_.balanceOf(msg.sender) >= _value,
            "Insufficient PaxGold balance"
        );

        paxGold_.safeTransferFrom(msg.sender, address(this), _value);
        paxgReceived = calculateReceivedPaxg(_value);

        if (totalSupply() == 0) {
            auriumTokenToMint = (paxgReceived.mul(PRECISION_FACTOR)).div(
                lastValue_
            );
        } else {
            auriumTokenToMint = (paxgReceived.mul(PRECISION_FACTOR)).div(
                value_
            );
        }
        _mint(msg.sender, auriumTokenToMint);

        totalReserve_ = totalReserve_.add(paxgReceived);
        lastValue_ = value_;
        _updateValue();
        emit AuriumTokenMinted(
            address(this),
            name(),
            symbol(),
            msg.sender,
            auriumTokenToMint
        );
    }

    /**

    @dev Burn AuriumToken and receive PAXG in return

    @param _value The amount of AuriumToken to burn
    */
    function burn(uint256 _value) public nonReentrant {
        require(
            balanceOf(msg.sender) >= _value,
            "Insufficient AuriumToken balance"
        );
        //Expected Paxg
        uint256 paxGoldValue = (_value.mul(value_)).div(PRECISION_FACTOR);
        paxGold_.safeTransfer(msg.sender, paxGoldValue);
        totalReserve_ = totalReserve_.sub(paxGoldValue);
        _burn(msg.sender, _value);
        lastValue_ = value_;
        _updateValue();
        emit AuriumTokenBurned(
            address(this),
            name(),
            symbol(),
            msg.sender,
            _value
        );
    }

    /**

    @dev Transfer AuriumToken while applying a burn fee

    @param recipient The address to transfer AuriumToken to

    @param amount The amount of AuriumToken to transfer

    @return A boolean indicating if the transfer was successful or not
    */
    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(amount > 1000, "Amount should be greater than 1000 wei");
        uint256 calculatedBurnFee = amount.mul(burnFee_).div(MULTIPLIER);
        uint256 FeeValueForComparison = value_ == 0
            ? lastValue_.mul(calculatedBurnFee)
            : value_.mul(calculatedBurnFee);
        if (FeeValueForComparison > (_maxBurnFee.mul(PRECISION_FACTOR))) {
            calculatedBurnFee = value_ == 0
                ? (_maxBurnFee.mul(PRECISION_FACTOR)).div(lastValue_)
                : (_maxBurnFee.mul(PRECISION_FACTOR)).div(value_);
            emit maxBurnFeeAlert(msg.sender, amount, calculatedBurnFee); //event if max burn fee is applied
        }
        _burn(msg.sender, calculatedBurnFee);
        lastValue_ = value_;
        _updateValue();
        return super.transfer(recipient, amount.sub(calculatedBurnFee));
    }

    /**

    @dev Transfer AuriumToken from a specified address to another while applying a burn fee

    @param sender The address to transfer AuriumToken from

    @param recipient The address to transfer AuriumToken to

    @param amount The amount of AuriumToken to transfer

    @return A boolean indicating if the transfer was successful or not
    */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        require(amount > 1000, "Amount should be greater than 1000 wei");
        uint256 calculatedBurnFee = amount.mul(burnFee_).div(MULTIPLIER);
        uint256 FeeValueForComparison = value_ == 0
            ? lastValue_.mul(calculatedBurnFee)
            : value_.mul(calculatedBurnFee);
        if (FeeValueForComparison > (_maxBurnFee.mul(PRECISION_FACTOR))) {
            calculatedBurnFee = value_ == 0
                ? (_maxBurnFee.mul(PRECISION_FACTOR)).div(lastValue_)
                : (_maxBurnFee.mul(PRECISION_FACTOR)).div(value_);
            emit maxBurnFeeAlert(msg.sender, amount, calculatedBurnFee); //event if max burn fee is applied
        }
        _burn(sender, calculatedBurnFee);
        lastValue_ = value_;
        _updateValue();
        return
            super.transferFrom(
                sender,
                recipient,
                amount.sub(calculatedBurnFee)
            );
    }

    /**

    @dev Get AuriumToken contract details
    @return A tuple containing the AuriumToken name, symbol, total supply, and current value of the AuriumToken
    */
    function getDetails()
        public
        view
        returns (string memory, string memory, uint256, uint256)
    {
        return (name(), symbol(), totalSupply(), value_);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_paxGold","type":"address"},{"internalType":"uint256","name":"_initialDeposit","type":"uint256"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_userAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"string","name":"symbol","type":"string"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"AuriumTokenBurned","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"string","name":"name","type":"string"},{"indexed":false,"internalType":"string","name":"symbol","type":"string"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"AuriumTokenMinted","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":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"maxBurnFee","type":"uint256"}],"name":"maxBurnFeeAlert","type":"event"},{"inputs":[],"name":"MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAXGOLD_FEE_PARTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_updateValue","outputs":[],"stateMutability":"nonpayable","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":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"auriumTokenFactoryAddr_","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"_value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"burnFee_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"calculateReceivedPaxg","outputs":[{"internalType":"uint256","name":"receivedPaxg","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","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":[{"internalType":"uint256","name":"_amountPaxg","type":"uint256"}],"name":"getAuriumTokenAmountsOut","outputs":[{"internalType":"uint256","name":"ATKAmountsOut","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDetails","outputs":[{"internalType":"string","name":"","type":"string"},{"internalType":"string","name":"","type":"string"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountAuriumToken","type":"uint256"}],"name":"getPaxgAmountsOut","outputs":[{"internalType":"uint256","name":"PAXGAmountsOut","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":"lastValue_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paxGold_","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReserve_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"value_","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000045804880de22913dafe09f4980848ece6ecbaf780000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000006c6b935b8bbd40000000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001000000000000000000000000003d01422a3a5ed4db61c17991e2a707cc54e07ed80000000000000000000000000000000000000000000000000000000000000009474f444c20476f6c6400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004474f444c00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _paxGold (address): 0x45804880De22913dAFE09f4980848ECE6EcbAf78
Arg [1] : _initialDeposit (uint256): 1000000000000000000
Arg [2] : _initialSupply (uint256): 2000000000000000000000
Arg [3] : _name (string): GODL Gold
Arg [4] : _symbol (string): GODL
Arg [5] : _userAddress (address): 0x3d01422A3A5Ed4DB61c17991E2a707CC54e07ed8

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000045804880de22913dafe09f4980848ece6ecbaf78
Arg [1] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [2] : 00000000000000000000000000000000000000000000006c6b935b8bbd400000
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [5] : 0000000000000000000000003d01422a3a5ed4db61c17991e2a707cc54e07ed8
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [7] : 474f444c20476f6c640000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [9] : 474f444c00000000000000000000000000000000000000000000000000000000

40873:9496:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41335:41;;41372:4;41335:41;;;;;160:25:1;;;148:2;133:18;41335:41:0;;;;;;;;29026:100;;;:::i;:::-;;;;;;;:::i;31443:226::-;;;;;;:::i;:::-;;:::i;:::-;;;1554:14:1;;1547:22;1529:41;;1517:2;1502:18;31443:226:0;1389:187:1;30146:108:0;30234:12;;30146:108;;41116:21;;;;;;48906:1087;;;;;;:::i;:::-;;:::i;29988:93::-;;;30071:2;2056:36:1;;2044:2;2029:18;29988:93:0;1914:184:1;32953:263:0;;;;;;:::i;:::-;;:::i;44192:471::-;;;;;;:::i;:::-;;:::i;41398:22::-;;;;;-1:-1:-1;;;;;41398:22:0;;;;;;-1:-1:-1;;;;;2466:32:1;;;2448:51;;2436:2;2421:18;41398:22:0;2288:217:1;46625:652:0;;;;;;:::i;:::-;;:::i;:::-;;45159:166;;;:::i;30317:143::-;;;;;;:::i;:::-;-1:-1:-1;;;;;30434:18:0;30407:7;30434:18;;;;;;;;;;;;30317:143;43702:305;;;;;;:::i;:::-;;:::i;41190:36::-;;41225:1;41190:36;;41448:48;;;;;29245:104;;;:::i;45470:1019::-;;;;;;:::i;:::-;;:::i;40995:28::-;;;;;;33719:498;;;;;;:::i;:::-;;:::i;47557:971::-;;;;;;:::i;:::-;;:::i;41753:51::-;;41797:7;41753:51;;41533:47;;41576:4;41533:47;;30947:176;;;;;;:::i;:::-;;:::i;41628:25::-;;;;;;44671:402;;;;;;:::i;:::-;;:::i;50176:190::-;;;:::i;:::-;;;;;;;;;;:::i;29026:100::-;29080:13;29113:5;29106:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29026:100;:::o;31443:226::-;31551:4;20573:10;31607:32;20573:10;31623:7;31632:6;31607:8;:32::i;:::-;31657:4;31650:11;;;31443:226;;;;;:::o;48906:1087::-;49038:4;49072;49063:6;:13;49055:64;;;;-1:-1:-1;;;49055:64:0;;;;;;;:::i;:::-;;;;;;;;;49130:25;49158:36;41372:4;49158:20;:6;41225:1;49158:10;:20::i;:::-;:24;;:36::i;:::-;49130:64;;49205:29;49237:6;;49247:1;49237:11;:105;;49313:6;;:29;;49324:17;49313:10;:29::i;:::-;49237:105;;;49264:10;;:33;;49279:17;49264:14;:33::i;:::-;49382:11;;49205:137;;-1:-1:-1;49382:33:0;;41576:4;49382:15;:33::i;:::-;49357:21;:59;49353:370;;;49453:6;;:11;:149;;49555:47;49595:6;;49556:33;41576:4;49556:11;;:15;;:33;;;;:::i;49555:47::-;49453:149;;;49484:51;49524:10;;49485:33;41576:4;49485:11;;:15;;:33;;;;:::i;49484:51::-;49622:54;;;49638:10;4700:51:1;;4782:2;4767:18;;4760:34;;;4810:18;;;4803:34;;;49433:169:0;;-1:-1:-1;49622:54:0;;4688:2:1;4673:18;49622:54:0;;;;;;;49353:370;49733:32;49739:6;49747:17;49733:5;:32::i;:::-;49789:6;;49776:10;:19;49806:14;:12;:14::i;:::-;49851:134;49888:6;49913:9;49941:29;:6;49952:17;49941:10;:29::i;:::-;49851:18;:134::i;:::-;49831:154;48906:1087;-1:-1:-1;;;;;;48906:1087:0:o;32953:263::-;33066:4;20573:10;33122:64;20573:10;33138:7;33175:10;33147:25;20573:10;33138:7;33147:9;:25::i;:::-;:38;;;;:::i;:::-;33122:8;:64::i;44192:471::-;44281:21;44315;44339:34;44361:11;44339:21;:34::i;:::-;44315:58;;44454:13;30234:12;;;30146:108;44454:13;44471:1;44454:18;44450:206;;44541:10;;44496:56;;44497:38;:16;41576:4;44497:20;:38::i;44496:56::-;44489:63;44192:471;-1:-1:-1;;;44192:471:0:o;44450:206::-;44637:6;;44592:52;;44593:38;:16;41576:4;44593:20;:38::i;44450:206::-;44304:359;44192:471;;;:::o;46625:652::-;1462:21;:19;:21::i;:::-;46718:10:::1;30407:7:::0;30434:18;;;;;;;;;;;46733:6;-1:-1:-1;46708:31:0::1;46686:113;;;::::0;-1:-1:-1;;;46686:113:0;;5312:2:1;46686:113:0::1;::::0;::::1;5294:21:1::0;;;5331:18;;;5324:30;5390:34;5370:18;;;5363:62;5442:18;;46686:113:0::1;5110:356:1::0;46686:113:0::1;46835:20;46858:42;41576:4;46859:18;46870:6;;46859;:10;;:18;;;;:::i;46858:42::-;46911:8;::::0;46835:65;;-1:-1:-1;46911:47:0::1;::::0;-1:-1:-1;;;;;46911:8:0::1;46933:10;46835:65:::0;46911:21:::1;:47::i;:::-;46985:13;::::0;:31:::1;::::0;47003:12;46985:17:::1;:31::i;:::-;46969:13;:47:::0;47027:25:::1;47033:10;47045:6:::0;47027:5:::1;:25::i;:::-;47076:6;::::0;47063:10:::1;:19:::0;47093:14:::1;:12;:14::i;:::-;47227:10;47163:4;47123:146;47183:6;:4;:6::i;:::-;47204:8;:6;:8::i;:::-;47252:6;47123:146;;;;;;;;:::i;:::-;;;;;;;;46675:602;1506:20:::0;900:1;2026:7;:22;1843:213;1506:20;46625:652;:::o;45159:166::-;30234:12;;45210:18;:107;;45261:56;45303:13;30234:12;;;30146:108;45303:13;45262;;:35;;41576:4;45262:17;:35::i;45261:56::-;45201:6;:116;45159:166::o;45210:107::-;45244:1;45201:6;:116;45159:166::o;43702:305::-;43787:20;43840:159;43870:114;41797:7;43871:49;43899:8;;;;;;;;;-1:-1:-1;;;;;43899:8:0;-1:-1:-1;;;;;43883:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43871:7;;:11;:49::i;43870:114::-;43840:7;;:11;:159::i;29245:104::-;29301:13;29334:7;29327:14;;;;;:::i;45470:1019::-;1462:21;:19;:21::i;:::-;45622:8:::1;::::0;:30:::1;::::0;-1:-1:-1;;;45622:30:0;;45641:10:::1;45622:30;::::0;::::1;2448:51:1::0;45531:25:0::1;::::0;;;45656:6;;-1:-1:-1;;;;;45622:8:0::1;::::0;:18:::1;::::0;2421::1;;45622:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:40;;45600:118;;;::::0;-1:-1:-1;;;45600:118:0;;6321:2:1;45600:118:0::1;::::0;::::1;6303:21:1::0;6360:2;6340:18;;;6333:30;6399;6379:18;;;6372:58;6447:18;;45600:118:0::1;6119:352:1::0;45600:118:0::1;45731:8;::::0;:60:::1;::::0;-1:-1:-1;;;;;45731:8:0::1;45757:10;45777:4;45784:6:::0;45731:25:::1;:60::i;:::-;45817:29;45839:6;45817:21;:29::i;:::-;45802:44;;45863:13;30234:12:::0;;;30146:108;45863:13:::1;45880:1;45863:18:::0;45859:288:::1;;45977:10;::::0;45918:84:::1;::::0;45919:34:::1;:12:::0;41576:4:::1;45919:16;:34::i;45918:84::-;45898:104;;45859:288;;;46114:6;::::0;46055:80:::1;::::0;46056:34:::1;:12:::0;41576:4:::1;46056:16;:34::i;46055:80::-;46035:100;;45859:288;46157:36;46163:10;46175:17;46157:5;:36::i;:::-;46222:13;::::0;:31:::1;::::0;46240:12;46222:17:::1;:31::i;:::-;46206:13;:47:::0;46277:6:::1;::::0;46264:10:::1;:19:::0;46294:14:::1;:12;:14::i;:::-;46428:10;46364:4;46324:157;46384:6;:4;:6::i;:::-;46405:8;:6;:8::i;:::-;46453:17;46324:157;;;;;;;;:::i;:::-;;;;;;;;45520:969;;1506:20:::0;900:1;2026:7;:22;1843:213;33719:498;33837:4;20573:10;33837:4;33920:25;20573:10;33937:7;33920:9;:25::i;:::-;33893:52;;33998:15;33978:16;:35;;33956:122;;;;-1:-1:-1;;;33956:122:0;;6678:2:1;33956:122:0;;;6660:21:1;6717:2;6697:18;;;6690:30;6756:34;6736:18;;;6729:62;-1:-1:-1;;;6807:18:1;;;6800:35;6852:19;;33956:122:0;6476:401:1;33956:122:0;34114:60;34123:5;34130:7;34158:15;34139:16;:34;34114:8;:60::i;:::-;-1:-1:-1;34205:4:0;;33719:498;-1:-1:-1;;;;33719:498:0:o;47557:971::-;47660:4;47694;47685:6;:13;47677:64;;;;-1:-1:-1;;;47677:64:0;;;;;;;:::i;:::-;47752:25;47780:36;41372:4;47780:20;:6;41225:1;47780:10;:20::i;:36::-;47752:64;;47827:29;47859:6;;47869:1;47859:11;:105;;47935:6;;:29;;47946:17;47935:10;:29::i;:::-;47859:105;;;47886:10;;:33;;47901:17;47886:14;:33::i;:::-;48004:11;;47827:137;;-1:-1:-1;48004:33:0;;41576:4;48004:15;:33::i;:::-;47979:21;:59;47975:370;;;48075:6;;:11;:149;;48177:47;48217:6;;48178:33;41576:4;48178:11;;:15;;:33;;;;:::i;48177:47::-;48075:149;;;48106:51;48146:10;;48107:33;41576:4;48107:11;;:15;;:33;;;;:::i;48106:51::-;48244:54;;;48260:10;4700:51:1;;4782:2;4767:18;;4760:34;;;4810:18;;;4803:34;;;48055:169:0;;-1:-1:-1;48244:54:0;;4688:2:1;4673:18;48244:54:0;;;;;;;47975:370;48355:36;48361:10;48373:17;48355:5;:36::i;:::-;48415:6;;48402:10;:19;48432:14;:12;:14::i;:::-;48464:56;48479:9;48490:29;:6;48501:17;48490:10;:29::i;:::-;48464:14;:56::i;:::-;48457:63;47557:971;-1:-1:-1;;;;;47557:971:0:o;30947:176::-;-1:-1:-1;;;;;31088:18:0;;;31061:7;31088:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;30947:176::o;44671:402::-;44760:22;44795:12;44822:6;;44832:1;44822:11;44818:203;;44857:58;41576:4;44858:34;44881:10;;44858:18;:22;;:34;;;;:::i;44857:58::-;44850:65;;44818:203;;;44955:54;41576:4;44956:30;44979:6;;44956:18;:22;;:30;;;;:::i;44955:54::-;44948:61;;44818:203;45038:27;45060:4;45038:21;:27::i;50176:190::-;50246:13;50261;50276:7;50285;50318:6;:4;:6::i;:::-;50326:8;:6;:8::i;:::-;30234:12;;50351:6;;50310:48;;;;;;;;50176:190;;;;:::o;37845:380::-;-1:-1:-1;;;;;37981:19:0;;37973:68;;;;-1:-1:-1;;;37973:68:0;;7084:2:1;37973:68:0;;;7066:21:1;7123:2;7103:18;;;7096:30;7162:34;7142:18;;;7135:62;-1:-1:-1;;;7213:18:1;;;7206:34;7257:19;;37973:68:0;6882:400:1;37973:68:0;-1:-1:-1;;;;;38060:21:0;;38052:68;;;;-1:-1:-1;;;38052:68:0;;7489:2:1;38052:68:0;;;7471:21:1;7528:2;7508:18;;;7501:30;7567:34;7547:18;;;7540:62;-1:-1:-1;;;7618:18:1;;;7611:32;7660:19;;38052:68:0;7287:398:1;38052:68:0;-1:-1:-1;;;;;38133:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;38185:32;;160:25:1;;;38185:32:0;;133:18:1;38185:32:0;;;;;;;;37845:380;;;:::o;5276:98::-;5334:7;5361:5;5365:1;5361;:5;:::i;5675:98::-;5733:7;5760:5;5764:1;5760;:5;:::i;36732:675::-;-1:-1:-1;;;;;36816:21:0;;36808:67;;;;-1:-1:-1;;;36808:67:0;;8287:2:1;36808:67:0;;;8269:21:1;8326:2;8306:18;;;8299:30;8365:34;8345:18;;;8338:62;-1:-1:-1;;;8416:18:1;;;8409:31;8457:19;;36808:67:0;8085:397:1;36808:67:0;-1:-1:-1;;;;;36975:18:0;;36950:22;36975:18;;;;;;;;;;;37012:24;;;;37004:71;;;;-1:-1:-1;;;37004:71:0;;8689:2:1;37004:71:0;;;8671:21:1;8728:2;8708:18;;;8701:30;8767:34;8747:18;;;8740:62;-1:-1:-1;;;8818:18:1;;;8811:32;8860:19;;37004:71:0;8487:398:1;37004:71:0;-1:-1:-1;;;;;37111:18:0;;:9;:18;;;;;;;;;;;37132:23;;;37111:44;;37250:12;:22;;;;;;;37301:37;160:25:1;;;37111:9:0;;:18;37301:37;;133:18:1;37301:37:0;14:177:1;37351:48:0;36797:610;36732:675;;:::o;4919:98::-;4977:7;5004:5;5008:1;5004;:5;:::i;32249:295::-;32380:4;20573:10;32438:38;32454:4;20573:10;32469:6;32438:15;:38::i;:::-;32487:27;32497:4;32503:2;32507:6;32487:9;:27::i;1542:293::-;944:1;1676:7;;:19;1668:63;;;;-1:-1:-1;;;1668:63:0;;9225:2:1;1668:63:0;;;9207:21:1;9264:2;9244:18;;;9237:30;9303:33;9283:18;;;9276:61;9354:18;;1668:63:0;9023:355:1;1668:63:0;944:1;1809:7;:18;1542:293::o;23549:214::-;23686:58;;-1:-1:-1;;;;;9575:32:1;;23686:58:0;;;9557:51:1;9624:18;;;9617:34;;;23632:123:0;;23666:5;;-1:-1:-1;;;23709:23:0;9530:18:1;;23686:58:0;;;;-1:-1:-1;;23686:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;23686:58:0;-1:-1:-1;;;;;;23686:58:0;;;;;;;;;;23632:19;:123::i;23771:285::-;23969:68;;-1:-1:-1;;;;;9920:15:1;;;23969:68:0;;;9902:34:1;9972:15;;9952:18;;;9945:43;10004:18;;;9997:34;;;23915:133:0;;23949:5;;-1:-1:-1;;;23992:27:0;9837:18:1;;23969:68:0;9662:375:1;23915:133:0;23771:285;;;;:::o;35851:548::-;-1:-1:-1;;;;;35935:21:0;;35927:65;;;;-1:-1:-1;;;35927:65:0;;10244:2:1;35927:65:0;;;10226:21:1;10283:2;10263:18;;;10256:30;10322:33;10302:18;;;10295:61;10373:18;;35927:65:0;10042:355:1;35927:65:0;36083:6;36067:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;36238:18:0;;:9;:18;;;;;;;;;;;:28;;;;;;36293:37;160:25:1;;;36293:37:0;;133:18:1;36293:37:0;;;;;;;35851:548;;:::o;4538:98::-;4596:7;4623:5;4627:1;4623;:5;:::i;30666:218::-;30770:4;20573:10;30826:28;20573:10;30843:2;30847:6;30826:9;:28::i;38516:502::-;38651:24;38678:25;38688:5;38695:7;38678:9;:25::i;:::-;38651:52;;-1:-1:-1;;38718:16:0;:37;38714:297;;38818:6;38798:16;:26;;38772:117;;;;-1:-1:-1;;;38772:117:0;;10604:2:1;38772:117:0;;;10586:21:1;10643:2;10623:18;;;10616:30;10682:31;10662:18;;;10655:59;10731:18;;38772:117:0;10402:353:1;38772:117:0;38933:51;38942:5;38949:7;38977:6;38958:16;:25;38933:8;:51::i;34687:877::-;-1:-1:-1;;;;;34818:18:0;;34810:68;;;;-1:-1:-1;;;34810:68:0;;10962:2:1;34810:68:0;;;10944:21:1;11001:2;10981:18;;;10974:30;11040:34;11020:18;;;11013:62;-1:-1:-1;;;11091:18:1;;;11084:35;11136:19;;34810:68:0;10760:401:1;34810:68:0;-1:-1:-1;;;;;34897:16:0;;34889:64;;;;-1:-1:-1;;;34889:64:0;;11368:2:1;34889:64:0;;;11350:21:1;11407:2;11387:18;;;11380:30;11446:34;11426:18;;;11419:62;-1:-1:-1;;;11497:18:1;;;11490:33;11540:19;;34889:64:0;11166:399:1;34889:64:0;-1:-1:-1;;;;;35039:15:0;;35017:19;35039:15;;;;;;;;;;;35087:21;;;;35065:109;;;;-1:-1:-1;;;35065:109:0;;11772:2:1;35065:109:0;;;11754:21:1;11811:2;11791:18;;;11784:30;11850:34;11830:18;;;11823:62;-1:-1:-1;;;11901:18:1;;;11894:36;11947:19;;35065:109:0;11570:402:1;35065:109:0;-1:-1:-1;;;;;35210:15:0;;;:9;:15;;;;;;;;;;;35228:20;;;35210:38;;35428:13;;;;;;;;;;:23;;;;;;35480:26;;160:25:1;;;35428:13:0;;35480:26;;133:18:1;35480:26:0;;;;;;;35519:37;36732:675;27013:802;27437:23;27463:106;27505:4;27463:106;;;;;;;;;;;;;;;;;27471:5;-1:-1:-1;;;;;27463:27:0;;;:106;;;;;:::i;:::-;27584:17;;27437:132;;-1:-1:-1;27584:21:0;27580:228;;27699:10;27688:30;;;;;;;;;;;;:::i;:::-;27662:134;;;;-1:-1:-1;;;27662:134:0;;12461:2:1;27662:134:0;;;12443:21:1;12500:2;12480:18;;;12473:30;12539:34;12519:18;;;12512:62;-1:-1:-1;;;12590:18:1;;;12583:40;12640:19;;27662:134:0;12259:406:1;12663:229:0;12800:12;12832:52;12854:6;12862:4;12868:1;12871:12;12832:21;:52::i;:::-;12825:59;12663:229;-1:-1:-1;;;;12663:229:0:o;13879:612::-;14049:12;14121:5;14096:21;:30;;14074:118;;;;-1:-1:-1;;;14074:118:0;;12872:2:1;14074:118:0;;;12854:21:1;12911:2;12891:18;;;12884:30;12950:34;12930:18;;;12923:62;-1:-1:-1;;;13001:18:1;;;12994:36;13047:19;;14074:118:0;12670:402:1;14074:118:0;14204:12;14218:23;14245:6;-1:-1:-1;;;;;14245:11:0;14264:5;14285:4;14245:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14203:97;;;;14331:152;14376:6;14401:7;14427:10;14456:12;14331:26;:152::i;:::-;14311:172;13879:612;-1:-1:-1;;;;;;;13879:612:0:o;17009:644::-;17194:12;17223:7;17219:427;;;17251:10;:17;17272:1;17251:22;17247:290;;-1:-1:-1;;;;;10006:19:0;;;17461:60;;;;-1:-1:-1;;;17461:60:0;;13571:2:1;17461:60:0;;;13553:21:1;13610:2;13590:18;;;13583:30;13649:31;13629:18;;;13622:59;13698:18;;17461:60:0;13369:353:1;17461:60:0;-1:-1:-1;17558:10:0;17551:17;;17219:427;17601:33;17609:10;17621:12;18381:17;;:21;18377:388;;18613:10;18607:17;18670:15;18657:10;18653:2;18649:19;18642:44;18377:388;18740:12;18733:20;;-1:-1:-1;;;18733:20:0;;;;;;;;:::i;196:250:1:-;281:1;291:113;305:6;302:1;299:13;291:113;;;381:11;;;375:18;362:11;;;355:39;327:2;320:10;291:113;;;-1:-1:-1;;438:1:1;420:16;;413:27;196:250::o;451:271::-;493:3;531:5;525:12;558:6;553:3;546:19;574:76;643:6;636:4;631:3;627:14;620:4;613:5;609:16;574:76;:::i;:::-;704:2;683:15;-1:-1:-1;;679:29:1;670:39;;;;711:4;666:50;;451:271;-1:-1:-1;;451:271:1:o;727:220::-;876:2;865:9;858:21;839:4;896:45;937:2;926:9;922:18;914:6;896:45;:::i;952:173::-;1020:20;;-1:-1:-1;;;;;1069:31:1;;1059:42;;1049:70;;1115:1;1112;1105:12;1049:70;952:173;;;:::o;1130:254::-;1198:6;1206;1259:2;1247:9;1238:7;1234:23;1230:32;1227:52;;;1275:1;1272;1265:12;1227:52;1298:29;1317:9;1298:29;:::i;:::-;1288:39;1374:2;1359:18;;;;1346:32;;-1:-1:-1;;;1130:254:1:o;1581:328::-;1658:6;1666;1674;1727:2;1715:9;1706:7;1702:23;1698:32;1695:52;;;1743:1;1740;1733:12;1695:52;1766:29;1785:9;1766:29;:::i;:::-;1756:39;;1814:38;1848:2;1837:9;1833:18;1814:38;:::i;:::-;1804:48;;1899:2;1888:9;1884:18;1871:32;1861:42;;1581:328;;;;;:::o;2103:180::-;2162:6;2215:2;2203:9;2194:7;2190:23;2186:32;2183:52;;;2231:1;2228;2221:12;2183:52;-1:-1:-1;2254:23:1;;2103:180;-1:-1:-1;2103:180:1:o;2510:186::-;2569:6;2622:2;2610:9;2601:7;2597:23;2593:32;2590:52;;;2638:1;2635;2628:12;2590:52;2661:29;2680:9;2661:29;:::i;2909:260::-;2977:6;2985;3038:2;3026:9;3017:7;3013:23;3009:32;3006:52;;;3054:1;3051;3044:12;3006:52;3077:29;3096:9;3077:29;:::i;:::-;3067:39;;3125:38;3159:2;3148:9;3144:18;3125:38;:::i;:::-;3115:48;;2909:260;;;;;:::o;3174:527::-;3427:3;3416:9;3409:22;3390:4;3454:46;3495:3;3484:9;3480:19;3472:6;3454:46;:::i;:::-;3548:9;3540:6;3536:22;3531:2;3520:9;3516:18;3509:50;3576:33;3602:6;3594;3576:33;:::i;:::-;3640:2;3625:18;;3618:34;;;;-1:-1:-1;;3683:2:1;3668:18;3661:34;3568:41;3174:527;-1:-1:-1;;3174:527:1:o;3706:380::-;3785:1;3781:12;;;;3828;;;3849:61;;3903:4;3895:6;3891:17;3881:27;;3849:61;3956:2;3948:6;3945:14;3925:18;3922:38;3919:161;;4002:10;3997:3;3993:20;3990:1;3983:31;4037:4;4034:1;4027:15;4065:4;4062:1;4055:15;4091:402;4293:2;4275:21;;;4332:2;4312:18;;;4305:30;4371:34;4366:2;4351:18;;4344:62;-1:-1:-1;;;4437:2:1;4422:18;;4415:36;4483:3;4468:19;;4091:402::o;4848:127::-;4909:10;4904:3;4900:20;4897:1;4890:31;4940:4;4937:1;4930:15;4964:4;4961:1;4954:15;4980:125;5045:9;;;5066:10;;;5063:36;;;5079:18;;:::i;5471:454::-;5696:2;5685:9;5678:21;5659:4;5722:45;5763:2;5752:9;5748:18;5740:6;5722:45;:::i;:::-;5815:9;5807:6;5803:22;5798:2;5787:9;5783:18;5776:50;5843:33;5869:6;5861;5843:33;:::i;:::-;5835:41;;;5912:6;5907:2;5896:9;5892:18;5885:34;5471:454;;;;;;:::o;5930:184::-;6000:6;6053:2;6041:9;6032:7;6028:23;6024:32;6021:52;;;6069:1;6066;6059:12;6021:52;-1:-1:-1;6092:16:1;;5930:184;-1:-1:-1;5930:184:1:o;7690:168::-;7763:9;;;7794;;7811:15;;;7805:22;;7791:37;7781:71;;7832:18;;:::i;7863:217::-;7903:1;7929;7919:132;;7973:10;7968:3;7964:20;7961:1;7954:31;8008:4;8005:1;7998:15;8036:4;8033:1;8026:15;7919:132;-1:-1:-1;8065:9:1;;7863:217::o;8890:128::-;8957:9;;;8978:11;;;8975:37;;;8992:18;;:::i;11977:277::-;12044:6;12097:2;12085:9;12076:7;12072:23;12068:32;12065:52;;;12113:1;12110;12103:12;12065:52;12145:9;12139:16;12198:5;12191:13;12184:21;12177:5;12174:32;12164:60;;12220:1;12217;12210:12;13077:287;13206:3;13244:6;13238:13;13260:66;13319:6;13314:3;13307:4;13299:6;13295:17;13260:66;:::i;:::-;13342:16;;;;;13077:287;-1:-1:-1;;13077:287:1:o

ipfs://ade6376e6b436601b7c047c3ed9f829d8650b28c509c2d1062c1afea384c7fda